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 }