1 /*
2 * Copyright (C) 2006 Michael Brown <mbrown@fensystems.co.uk>.
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License as
6 * published by the Free Software Foundation; either version 2 of the
7 * License, or any later version.
8 *
9 * This program is distributed in the hope that it will be useful, but
10 * WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17 */
18
19 FILE_LICENCE ( GPL2_OR_LATER );
20
21 #include <stdint.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <errno.h>
25 #include <gpxe/dhcp.h>
26 #include <gpxe/nvs.h>
27 #include <gpxe/nvo.h>
28
29 /** @file
30 *
31 * Non-volatile stored options
32 *
33 */
34
35 /**
36 * Calculate checksum over non-volatile stored options
37 *
38 * @v nvo Non-volatile options block
39 * @ret sum Checksum
40 */
nvo_checksum(struct nvo_block * nvo)41 static unsigned int nvo_checksum ( struct nvo_block *nvo ) {
42 uint8_t *data = nvo->data;
43 uint8_t sum = 0;
44 unsigned int i;
45
46 for ( i = 0 ; i < nvo->total_len ; i++ ) {
47 sum += *(data++);
48 }
49 return sum;
50 }
51
52 /**
53 * Load non-volatile stored options from non-volatile storage device
54 *
55 * @v nvo Non-volatile options block
56 * @ret rc Return status code
57 */
nvo_load(struct nvo_block * nvo)58 static int nvo_load ( struct nvo_block *nvo ) {
59 void *data = nvo->data;
60 struct nvo_fragment *frag;
61 int rc;
62
63 /* Read data a fragment at a time */
64 for ( frag = nvo->fragments ; frag->len ; frag++ ) {
65 if ( ( rc = nvs_read ( nvo->nvs, frag->address, data,
66 frag->len ) ) != 0 ) {
67 DBGC ( nvo, "NVO %p could not read %zd bytes at "
68 "%#04x\n", nvo, frag->len, frag->address );
69 return rc;
70 }
71 data += frag->len;
72 }
73
74 DBGC ( nvo, "NVO %p loaded from non-volatile storage\n", nvo );
75 return 0;
76 }
77
78 /**
79 * Save non-volatile stored options back to non-volatile storage device
80 *
81 * @v nvo Non-volatile options block
82 * @ret rc Return status code
83 */
nvo_save(struct nvo_block * nvo)84 static int nvo_save ( struct nvo_block *nvo ) {
85 void *data = nvo->data;
86 uint8_t *checksum = data;
87 struct nvo_fragment *frag;
88 int rc;
89
90 /* Recalculate checksum */
91 *checksum -= nvo_checksum ( nvo );
92
93 /* Write data a fragment at a time */
94 for ( frag = nvo->fragments ; frag->len ; frag++ ) {
95 if ( ( rc = nvs_write ( nvo->nvs, frag->address, data,
96 frag->len ) ) != 0 ) {
97 DBGC ( nvo, "NVO %p could not write %zd bytes at "
98 "%#04x\n", nvo, frag->len, frag->address );
99 return rc;
100 }
101 data += frag->len;
102 }
103
104 DBGC ( nvo, "NVO %p saved to non-volatile storage\n", nvo );
105 return 0;
106 }
107
108 /**
109 * Parse stored options
110 *
111 * @v nvo Non-volatile options block
112 *
113 * Verifies that the options data is valid, and configures the DHCP
114 * options block. If the data is not valid, it is replaced with an
115 * empty options block.
116 */
nvo_init_dhcpopts(struct nvo_block * nvo)117 static void nvo_init_dhcpopts ( struct nvo_block *nvo ) {
118 uint8_t *options_data;
119 size_t options_len;
120
121 /* Steal one byte for the checksum */
122 options_data = ( nvo->data + 1 );
123 options_len = ( nvo->total_len - 1 );
124
125 /* If checksum fails, or options data starts with a zero,
126 * assume the whole block is invalid. This should capture the
127 * case of random initial contents.
128 */
129 if ( ( nvo_checksum ( nvo ) != 0 ) || ( options_data[0] == 0 ) ) {
130 DBGC ( nvo, "NVO %p has checksum %02x and initial byte %02x; "
131 "assuming empty\n", nvo, nvo_checksum ( nvo ),
132 options_data[0] );
133 memset ( nvo->data, 0, nvo->total_len );
134 }
135
136 dhcpopt_init ( &nvo->dhcpopts, options_data, options_len );
137 }
138
139 /**
140 * Store value of NVO setting
141 *
142 * @v settings Settings block
143 * @v setting Setting to store
144 * @v data Setting data, or NULL to clear setting
145 * @v len Length of setting data
146 * @ret rc Return status code
147 */
nvo_store(struct settings * settings,struct setting * setting,const void * data,size_t len)148 static int nvo_store ( struct settings *settings, struct setting *setting,
149 const void *data, size_t len ) {
150 struct nvo_block *nvo =
151 container_of ( settings, struct nvo_block, settings );
152 int rc;
153
154 /* Update stored options */
155 if ( ( rc = dhcpopt_store ( &nvo->dhcpopts, setting->tag,
156 data, len ) ) != 0 ) {
157 DBGC ( nvo, "NVO %p could not store %zd bytes: %s\n",
158 nvo, len, strerror ( rc ) );
159 return rc;
160 }
161
162 /* Save updated options to NVS */
163 if ( ( rc = nvo_save ( nvo ) ) != 0 )
164 return rc;
165
166 return 0;
167 }
168
169 /**
170 * Fetch value of NVO setting
171 *
172 * @v settings Settings block
173 * @v setting Setting to fetch
174 * @v data Buffer to fill with setting data
175 * @v len Length of buffer
176 * @ret len Length of setting data, or negative error
177 *
178 * The actual length of the setting will be returned even if
179 * the buffer was too small.
180 */
nvo_fetch(struct settings * settings,struct setting * setting,void * data,size_t len)181 static int nvo_fetch ( struct settings *settings, struct setting *setting,
182 void *data, size_t len ) {
183 struct nvo_block *nvo =
184 container_of ( settings, struct nvo_block, settings );
185
186 return dhcpopt_fetch ( &nvo->dhcpopts, setting->tag, data, len );
187 }
188
189 /** NVO settings operations */
190 static struct settings_operations nvo_settings_operations = {
191 .store = nvo_store,
192 .fetch = nvo_fetch,
193 };
194
195 /**
196 * Initialise non-volatile stored options
197 *
198 * @v nvo Non-volatile options block
199 * @v nvs Underlying non-volatile storage device
200 * @v fragments List of option-containing fragments
201 * @v refcnt Containing object reference counter, or NULL
202 */
nvo_init(struct nvo_block * nvo,struct nvs_device * nvs,struct nvo_fragment * fragments,struct refcnt * refcnt)203 void nvo_init ( struct nvo_block *nvo, struct nvs_device *nvs,
204 struct nvo_fragment *fragments, struct refcnt *refcnt ) {
205 nvo->nvs = nvs;
206 nvo->fragments = fragments;
207 settings_init ( &nvo->settings, &nvo_settings_operations, refcnt,
208 "nvo", 0 );
209 }
210
211 /**
212 * Register non-volatile stored options
213 *
214 * @v nvo Non-volatile options block
215 * @v parent Parent settings block, or NULL
216 * @ret rc Return status code
217 */
register_nvo(struct nvo_block * nvo,struct settings * parent)218 int register_nvo ( struct nvo_block *nvo, struct settings *parent ) {
219 struct nvo_fragment *fragment = nvo->fragments;
220 int rc;
221
222 /* Calculate total length of all fragments */
223 for ( fragment = nvo->fragments ; fragment->len ; fragment++ )
224 nvo->total_len += fragment->len;
225
226 /* Allocate memory for options and read in from NVS */
227 nvo->data = malloc ( nvo->total_len );
228 if ( ! nvo->data ) {
229 DBGC ( nvo, "NVO %p could not allocate %zd bytes\n",
230 nvo, nvo->total_len );
231 rc = -ENOMEM;
232 goto err_malloc;
233 }
234 if ( ( rc = nvo_load ( nvo ) ) != 0 )
235 goto err_load;
236
237 /* Verify and register options */
238 nvo_init_dhcpopts ( nvo );
239 if ( ( rc = register_settings ( &nvo->settings, parent ) ) != 0 )
240 goto err_register;
241
242 DBGC ( nvo, "NVO %p registered\n", nvo );
243 return 0;
244
245 err_register:
246 err_load:
247 free ( nvo->data );
248 nvo->data = NULL;
249 err_malloc:
250 return rc;
251 }
252
253 /**
254 * Unregister non-volatile stored options
255 *
256 * @v nvo Non-volatile options block
257 */
unregister_nvo(struct nvo_block * nvo)258 void unregister_nvo ( struct nvo_block *nvo ) {
259 unregister_settings ( &nvo->settings );
260 free ( nvo->data );
261 nvo->data = NULL;
262 DBGC ( nvo, "NVO %p unregistered\n", nvo );
263 }
264