Add the concept of a fragment list for non-volatile stored options.
[people/xl0/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 total length of non-volatile stored options
33  *
34  * @v nvo               Non-volatile options block
35  * @ret total_len       Total length of all fragments
36  */
37 static size_t nvo_total_len ( struct nvo_block *nvo ) {
38         struct nvo_fragment *fragment = nvo->fragments;
39         size_t total_len = 0;
40
41         for ( ; fragment->len ; fragment++ ) {
42                 total_len += fragment->len;
43         }
44
45         return total_len;
46 }
47
48 /**
49  * Read 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_read ( struct nvo_block *nvo ) {
55         struct nvo_fragment *fragment = nvo->fragments;
56         void *data = nvo->options->data;
57         int rc;
58
59         for ( ; fragment->len ; fragment++ ) {
60                 if ( ( rc = nvs_read ( nvo->nvs, fragment->address,
61                                        data, fragment->len ) ) != 0 ) {
62                         DBG ( "NVO %p could not read %zd bytes at %#04x\n",
63                               nvo, fragment->len, fragment->address );
64                         return rc;
65                 }
66                 data += fragment->len;
67         }
68         
69         return 0;
70 }
71
72 /**
73  * Parse stored options
74  *
75  * @v nvo               Non-volatile options block
76  * @v total_len         Total length of options data
77  *
78  * Verifies that the options data is valid, and configures the DHCP
79  * options block.  If the data is not valid, it is replaced with an
80  * empty options block.
81  */
82 static void nvo_init_dhcp ( struct nvo_block *nvo, size_t total_len ) {
83         struct dhcp_option_block *options = nvo->options;
84         struct dhcp_option *option;
85         uint8_t sum;
86         unsigned int i;
87
88         /* Steal one byte for the checksum */
89         options->max_len = ( total_len - 1 );
90
91         /* Verify checksum over whole block */
92         for ( sum = 0, i = 0 ; i < total_len ; i++ ) {
93                 sum += * ( ( uint8_t * ) ( options->data + i ) );
94         }
95         if ( sum != 0 ) {
96                 DBG ( "NVO %p has bad checksum %02x; assuming empty\n",
97                       nvo, sum );
98                 goto empty;
99         }
100
101         /* Check that we don't just have a block full of zeroes */
102         option = options->data;
103         if ( option->tag == DHCP_PAD ) {
104                 DBG ( "NVO %p has bad start; assuming empty\n", nvo );
105                 goto empty;
106         }
107         
108         /* Search for the DHCP_END tag */
109         options->len = options->max_len;
110         option = find_dhcp_option ( options, DHCP_END );
111         if ( ! option ) {
112                 DBG ( "NVO %p has no end tag; assuming empty\n", nvo );
113                 goto empty;
114         }
115
116         /* Set correct length of DHCP options */
117         options->len = ( ( void * ) option - options->data + 1 );
118         DBG ( "NVO %p contains %zd bytes of options (maximum %zd)\n",
119               nvo, options->len, options->max_len );
120         return;
121
122  empty:
123         /* No options found; initialise an empty options block */
124         option = options->data;
125         option->tag = DHCP_END;
126         options->len = 1;
127         return;
128 }
129
130 /**
131  * Register non-volatile stored options
132  *
133  * @v nvo               Non-volatile options block
134  * @ret rc              Return status code
135  */
136 int nvo_register ( struct nvo_block *nvo ) {
137         size_t total_len;
138         int rc;
139
140         /* Allocate memory for options and read in from NVS */
141         total_len = nvo_total_len ( nvo );
142         nvo->options = alloc_dhcp_options ( total_len );
143         if ( ! nvo->options ) {
144                 DBG ( "NVO %p could not allocate %zd bytes\n",
145                       nvo, total_len );
146                 rc = -ENOMEM;
147                 goto err;
148         }
149
150         if ( ( rc = nvo_read ( nvo ) ) != 0 )
151                 goto err;
152
153         /* Verify and register options */
154         nvo_init_dhcp ( nvo, total_len );
155         register_dhcp_options ( nvo->options );
156
157         return 0;
158         
159  err:
160         free_dhcp_options ( nvo->options );
161         nvo->options = NULL;
162         return rc;
163 }
164
165 /**
166  * Unregister non-volatile stored options
167  *
168  * @v nvo               Non-volatile options block
169  */
170 void nvo_unregister ( struct nvo_block *nvo ) {
171         if ( nvo->options ) {
172                 unregister_dhcp_options ( nvo->options );
173                 free_dhcp_options ( nvo->options );
174                 nvo->options = NULL;
175         }
176 }