d3cb77e7c329e1e7de73847d33d2a26993ed3b76
[people/sha0/gpxe.git] / src / core / nvo.c
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 #include <stdint.h>
20 #include <string.h>
21 #include <errno.h>
22 #include <gpxe/dhcp.h>
23 #include <gpxe/nvs.h>
24 #include <gpxe/nvo.h>
25
26 /** @file
27  *
28  * Non-volatile stored options
29  *
30  */
31
32 /* FIXME: "Temporary hack" */
33 struct nvo_block *ugly_nvo_hack = NULL;
34
35 /**
36  * Calculate checksum over non-volatile stored options
37  *
38  * @v nvo               Non-volatile options block
39  * @ret sum             Checksum
40  */
41 static unsigned int nvo_checksum ( struct nvo_block *nvo ) {
42         uint8_t *data = nvo->options->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  */
58 static int nvo_load ( struct nvo_block *nvo ) {
59         void *data = nvo->options->data;
60         struct nvo_fragment *fragment;
61         int rc;
62
63         /* Read data a fragment at a time */
64         for ( fragment = nvo->fragments ; fragment->len ; fragment++ ) {
65                 if ( ( rc = nvs_read ( nvo->nvs, fragment->address,
66                                        data, fragment->len ) ) != 0 ) {
67                         DBG ( "NVO %p could not read %zd bytes at %#04x\n",
68                               nvo, fragment->len, fragment->address );
69                         return rc;
70                 }
71                 data += fragment->len;
72         }
73
74         DBG ( "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  */
84 int nvo_save ( struct nvo_block *nvo ) {
85         void *data = nvo->options->data;
86         uint8_t *checksum = ( data + nvo->total_len - 1 );
87         struct nvo_fragment *fragment;
88         int rc;
89
90         /* Recalculate checksum */
91         *checksum -= nvo_checksum ( nvo );
92
93         /* Write data a fragment at a time */
94         for ( fragment = nvo->fragments ; fragment->len ; fragment++ ) {
95                 if ( ( rc = nvs_write ( nvo->nvs, fragment->address,
96                                         data, fragment->len ) ) != 0 ) {
97                         DBG ( "NVO %p could not write %zd bytes at %#04x\n",
98                               nvo, fragment->len, fragment->address );
99                         return rc;
100                 }
101                 data += fragment->len;
102         }
103
104         DBG ( "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  */
117 static void nvo_init_dhcp ( struct nvo_block *nvo ) {
118         struct dhcp_option_block *options = nvo->options;
119         struct dhcp_option *option;
120
121         /* Steal one byte for the checksum */
122         options->max_len = ( nvo->total_len - 1 );
123
124         /* Verify checksum over whole block */
125         if ( nvo_checksum ( nvo ) != 0 ) {
126                 DBG ( "NVO %p has bad checksum %02x; assuming empty\n",
127                       nvo, nvo_checksum ( nvo ) );
128                 goto empty;
129         }
130
131         /* Check that we don't just have a block full of zeroes */
132         option = options->data;
133         if ( option->tag == DHCP_PAD ) {
134                 DBG ( "NVO %p has bad start; assuming empty\n", nvo );
135                 goto empty;
136         }
137         
138         /* Search for the DHCP_END tag */
139         options->len = options->max_len;
140         option = find_dhcp_option ( options, DHCP_END );
141         if ( ! option ) {
142                 DBG ( "NVO %p has no end tag; assuming empty\n", nvo );
143                 goto empty;
144         }
145
146         /* Set correct length of DHCP options */
147         options->len = ( ( void * ) option - options->data + 1 );
148         DBG ( "NVO %p contains %zd bytes of options (maximum %zd)\n",
149               nvo, options->len, options->max_len );
150         return;
151
152  empty:
153         /* No options found; initialise an empty options block */
154         option = options->data;
155         option->tag = DHCP_END;
156         options->len = 1;
157         return;
158 }
159
160 /**
161  * Register non-volatile stored options
162  *
163  * @v nvo               Non-volatile options block
164  * @ret rc              Return status code
165  */
166 int nvo_register ( struct nvo_block *nvo ) {
167         struct nvo_fragment *fragment = nvo->fragments;
168         int rc;
169
170         /* Calculate total length of all fragments */
171         nvo->total_len = 0;
172         for ( fragment = nvo->fragments ; fragment->len ; fragment++ ) {
173                 nvo->total_len += fragment->len;
174         }
175
176         /* Allocate memory for options and read in from NVS */
177         nvo->options = alloc_dhcp_options ( nvo->total_len );
178         if ( ! nvo->options ) {
179                 DBG ( "NVO %p could not allocate %zd bytes\n",
180                       nvo, nvo->total_len );
181                 rc = -ENOMEM;
182                 goto err;
183         }
184         if ( ( rc = nvo_load ( nvo ) ) != 0 )
185                 goto err;
186
187         /* Verify and register options */
188         nvo_init_dhcp ( nvo );
189         register_dhcp_options ( nvo->options );
190
191         ugly_nvo_hack = nvo;
192
193         DBG ( "NVO %p registered\n", nvo );
194         return 0;
195         
196  err:
197         dhcpopt_put ( nvo->options );
198         nvo->options = NULL;
199         return rc;
200 }
201
202 /**
203  * Unregister non-volatile stored options
204  *
205  * @v nvo               Non-volatile options block
206  */
207 void nvo_unregister ( struct nvo_block *nvo ) {
208
209         if ( nvo->options ) {
210                 unregister_dhcp_options ( nvo->options );
211                 dhcpopt_put ( nvo->options );
212                 nvo->options = NULL;
213         }
214
215         DBG ( "NVO %p unregistered\n", nvo );
216
217         ugly_nvo_hack = NULL;
218 }