9949a48b4c041b83d1a89fe8b6c8f254deaad398
[people/mcb30/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 <gpxe/dhcp.h>
22 #include <gpxe/nvs.h>
23 #include <gpxe/nvo.h>
24
25 /** @file
26  *
27  * Non-volatile stored options
28  *
29  */
30
31 /**
32  * Calculate checksum over non-volatile stored options
33  *
34  * @v nvo               Non-volatile options block
35  * @ret sum             Checksum
36  */
37 static unsigned int nvo_checksum ( struct nvo_block *nvo ) {
38         uint8_t *data = nvo->options->data;
39         uint8_t sum = 0;
40         unsigned int i;
41
42         for ( i = 0 ; i < nvo->total_len ; i++ ) {
43                 sum += *(data++);
44         }
45         return sum;
46 }
47
48 /**
49  * Load non-volatile stored options from non-volatile storage device
50  *
51  * @v nvo               Non-volatile options block
52  * @ret rc              Return status code
53  */
54 static int nvo_load ( struct nvo_block *nvo ) {
55         void *data = nvo->options->data;
56         struct nvo_fragment *fragment;
57         int rc;
58
59         /* Read data a fragment at a time */
60         for ( fragment = nvo->fragments ; fragment->len ; fragment++ ) {
61                 if ( ( rc = nvs_read ( nvo->nvs, fragment->address,
62                                        data, fragment->len ) ) != 0 ) {
63                         DBG ( "NVO %p could not read %zd bytes at %#04x\n",
64                               nvo, fragment->len, fragment->address );
65                         return rc;
66                 }
67                 data += fragment->len;
68         }
69         
70         return 0;
71 }
72
73 /**
74  * Save non-volatile stored options back to non-volatile storage device
75  *
76  * @v nvo               Non-volatile options block
77  * @ret rc              Return status code
78  */
79 int nvo_save ( struct nvo_block *nvo ) {
80         void *data = nvo->options->data;
81         uint8_t *checksum = ( data + nvo->total_len - 1 );
82         struct nvo_fragment *fragment;
83         int rc;
84
85         /* Recalculate checksum */
86         checksum -= nvo_checksum ( nvo );
87
88         /* Write data a fragment at a time */
89         for ( fragment = nvo->fragments ; fragment->len ; fragment++ ) {
90                 if ( ( rc = nvs_write ( nvo->nvs, fragment->address,
91                                         data, fragment->len ) ) != 0 ) {
92                         DBG ( "NVO %p could not write %zd bytes at %#04x\n",
93                               nvo, fragment->len, fragment->address );
94                         return rc;
95                 }
96                 data += fragment->len;
97         }
98         
99         return 0;
100 }
101
102 /**
103  * Parse stored options
104  *
105  * @v nvo               Non-volatile options block
106  *
107  * Verifies that the options data is valid, and configures the DHCP
108  * options block.  If the data is not valid, it is replaced with an
109  * empty options block.
110  */
111 static void nvo_init_dhcp ( struct nvo_block *nvo ) {
112         struct dhcp_option_block *options = nvo->options;
113         struct dhcp_option *option;
114
115         /* Steal one byte for the checksum */
116         options->max_len = ( nvo->total_len - 1 );
117
118         /* Verify checksum over whole block */
119         if ( nvo_checksum ( nvo ) != 0 ) {
120                 DBG ( "NVO %p has bad checksum %02x; assuming empty\n",
121                       nvo, nvo_checksum ( nvo ) );
122                 goto empty;
123         }
124
125         /* Check that we don't just have a block full of zeroes */
126         option = options->data;
127         if ( option->tag == DHCP_PAD ) {
128                 DBG ( "NVO %p has bad start; assuming empty\n", nvo );
129                 goto empty;
130         }
131         
132         /* Search for the DHCP_END tag */
133         options->len = options->max_len;
134         option = find_dhcp_option ( options, DHCP_END );
135         if ( ! option ) {
136                 DBG ( "NVO %p has no end tag; assuming empty\n", nvo );
137                 goto empty;
138         }
139
140         /* Set correct length of DHCP options */
141         options->len = ( ( void * ) option - options->data + 1 );
142         DBG ( "NVO %p contains %zd bytes of options (maximum %zd)\n",
143               nvo, options->len, options->max_len );
144         return;
145
146  empty:
147         /* No options found; initialise an empty options block */
148         option = options->data;
149         option->tag = DHCP_END;
150         options->len = 1;
151         return;
152 }
153
154 /**
155  * Register non-volatile stored options
156  *
157  * @v nvo               Non-volatile options block
158  * @ret rc              Return status code
159  */
160 int nvo_register ( struct nvo_block *nvo ) {
161         struct nvo_fragment *fragment = nvo->fragments;
162         int rc;
163
164         /* Calculate total length of all fragments */
165         nvo->total_len = 0;
166         for ( fragment = nvo->fragments ; fragment->len ; fragment++ ) {
167                 nvo->total_len += fragment->len;
168         }
169
170         /* Allocate memory for options and read in from NVS */
171         nvo->options = alloc_dhcp_options ( nvo->total_len );
172         if ( ! nvo->options ) {
173                 DBG ( "NVO %p could not allocate %zd bytes\n",
174                       nvo, nvo->total_len );
175                 rc = -ENOMEM;
176                 goto err;
177         }
178         if ( ( rc = nvo_load ( nvo ) ) != 0 )
179                 goto err;
180
181         /* Verify and register options */
182         nvo_init_dhcp ( nvo );
183         register_dhcp_options ( nvo->options );
184
185         return 0;
186         
187  err:
188         free_dhcp_options ( nvo->options );
189         nvo->options = NULL;
190         return rc;
191 }
192
193 /**
194  * Unregister non-volatile stored options
195  *
196  * @v nvo               Non-volatile options block
197  */
198 void nvo_unregister ( struct nvo_block *nvo ) {
199         if ( nvo->options ) {
200                 unregister_dhcp_options ( nvo->options );
201                 free_dhcp_options ( nvo->options );
202                 nvo->options = NULL;
203         }
204 }