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 }