sysadmin/ipxe
1
0
Fork 0
mirror of https://github.com/ipxe/ipxe synced 2025-12-23 13:30:57 +03:00
Code Issues Packages Projects Releases Wiki Activity

[Settings] Migrate DHCP and NVO code to the new settings API (untested)

Browse Source
This commit is contained in:
Michael Brown
2008-03-21 22:15:31 +00:00
parent bb32b8999c
commit 8afb36c3bc
16 changed files with 966 additions and 936 deletions
Download Patch File Download Diff File Expand all files Collapse all files

214
src/core/nvo.c
View File

@@ -17,6 +17,7 @@
*/
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <gpxe/dhcp.h>
@@ -29,9 +30,6 @@
*
*/
/* FIXME: "Temporary hack" */
struct nvo_block *ugly_nvo_hack = NULL;
/**
* Calculate checksum over non-volatile stored options
*
@@ -39,7 +37,7 @@ struct nvo_block *ugly_nvo_hack = NULL;
* @ret sum Checksum
*/
static unsigned int nvo_checksum ( struct nvo_block *nvo ) {
uint8_t *data = nvo->options->data;
uint8_t *data = nvo->data;
uint8_t sum = 0;
unsigned int i;
@@ -56,22 +54,22 @@ static unsigned int nvo_checksum ( struct nvo_block *nvo ) {
* @ret rc Return status code
*/
static int nvo_load ( struct nvo_block *nvo ) {
void *data = nvo->options->data;
struct nvo_fragment *fragment;
void *data = nvo->data;
struct nvo_fragment *frag;
int rc;
/* Read data a fragment at a time */
for ( fragment = nvo->fragments ; fragment->len ; fragment++ ) {
if ( ( rc = nvs_read ( nvo->nvs, fragment->address,
data, fragment->len ) ) != 0 ) {
DBG ( "NVO %p could not read %zd bytes at %#04x\n",
nvo, fragment->len, fragment->address );
for ( frag = nvo->fragments ; frag->len ; frag++ ) {
if ( ( rc = nvs_read ( nvo->nvs, frag->address, data,
frag->len ) ) != 0 ) {
DBGC ( nvo, "NVO %p could not read %zd bytes at "
"%#04x\n", nvo, frag->len, frag->address );
return rc;
}
data += fragment->len;
data += frag->len;
}
DBG ( "NVO %p loaded from non-volatile storage\n", nvo );
DBGC ( nvo, "NVO %p loaded from non-volatile storage\n", nvo );
return 0;
}
@@ -81,27 +79,27 @@ static int nvo_load ( struct nvo_block *nvo ) {
* @v nvo Non-volatile options block
* @ret rc Return status code
*/
int nvo_save ( struct nvo_block *nvo ) {
void *data = nvo->options->data;
uint8_t *checksum = ( data + nvo->total_len - 1 );
struct nvo_fragment *fragment;
static int nvo_save ( struct nvo_block *nvo ) {
void *data = nvo->data;
uint8_t *checksum = data;
struct nvo_fragment *frag;
int rc;
/* Recalculate checksum */
*checksum -= nvo_checksum ( nvo );
/* Write data a fragment at a time */
for ( fragment = nvo->fragments ; fragment->len ; fragment++ ) {
if ( ( rc = nvs_write ( nvo->nvs, fragment->address,
data, fragment->len ) ) != 0 ) {
DBG ( "NVO %p could not write %zd bytes at %#04x\n",
nvo, fragment->len, fragment->address );
for ( frag = nvo->fragments ; frag->len ; frag++ ) {
if ( ( rc = nvs_write ( nvo->nvs, frag->address, data,
frag->len ) ) != 0 ) {
DBGC ( nvo, "NVO %p could not write %zd bytes at "
"%#04x\n", nvo, frag->len, frag->address );
return rc;
}
data += fragment->len;
data += frag->len;
}
DBG ( "NVO %p saved to non-volatile storage\n", nvo );
DBGC ( nvo, "NVO %p saved to non-volatile storage\n", nvo );
return 0;
}
@@ -114,88 +112,138 @@ int nvo_save ( struct nvo_block *nvo ) {
* options block. If the data is not valid, it is replaced with an
* empty options block.
*/
static void nvo_init_dhcp ( struct nvo_block *nvo ) {
struct dhcp_option_block *options = nvo->options;
struct dhcp_option *option;
static void nvo_init_dhcpopts ( struct nvo_block *nvo ) {
uint8_t *options_data;
size_t options_len;
/* Steal one byte for the checksum */
options->max_len = ( nvo->total_len - 1 );
options_data = ( nvo->data + 1 );
options_len = ( nvo->total_len - 1 );
/* Verify checksum over whole block */
if ( nvo_checksum ( nvo ) != 0 ) {
DBG ( "NVO %p has bad checksum %02x; assuming empty\n",
nvo, nvo_checksum ( nvo ) );
goto empty;
/* If checksum fails, or options data starts with a zero,
* assume the whole block is invalid. This should capture the
* case of random initial contents.
*/
if ( ( nvo_checksum ( nvo ) != 0 ) || ( options_data[0] == 0 ) ) {
DBGC ( nvo, "NVO %p has checksum %02x and initial byte %02x; "
"assuming empty\n", nvo, nvo_checksum ( nvo ),
options_data[0] );
memset ( nvo->data, 0, nvo->total_len );
}
/* Check that we don't just have a block full of zeroes */
option = options->data;
if ( option->tag == DHCP_PAD ) {
DBG ( "NVO %p has bad start; assuming empty\n", nvo );
goto empty;
}
/* Search for the DHCP_END tag */
options->len = options->max_len;
option = find_dhcp_option ( options, DHCP_END );
if ( ! option ) {
DBG ( "NVO %p has no end tag; assuming empty\n", nvo );
goto empty;
dhcpopt_init ( &nvo->dhcpopts, options_data, options_len );
}
/**
* Store value of NVO setting
*
* @v settings Settings block
* @v tag Setting tag number
* @v data Setting data, or NULL to clear setting
* @v len Length of setting data
* @ret rc Return status code
*/
static int nvo_store ( struct settings *settings, unsigned int tag,
const void *data, size_t len ) {
struct nvo_block *nvo =
container_of ( settings, struct nvo_block, settings );
int rc;
/* Update stored options */
if ( ( rc = dhcpopt_store ( &nvo->dhcpopts, tag, data, len ) ) != 0 ) {
DBGC ( nvo, "NVO %p could not store %zd bytes: %s\n",
nvo, len, strerror ( rc ) );
return rc;
}
/* Set correct length of DHCP options */
options->len = ( ( void * ) option - options->data + 1 );
DBG ( "NVO %p contains %zd bytes of options (maximum %zd)\n",
nvo, options->len, options->max_len );
return;
/* Save updated options to NVS */
if ( ( rc = nvo_save ( nvo ) ) != 0 )
return rc;
empty:
/* No options found; initialise an empty options block */
option = options->data;
option->tag = DHCP_END;
options->len = 1;
return;
return 0;
}
/**
* Fetch value of NVO setting
*
* @v settings Settings block
* @v tag Setting tag number
* @v data Buffer to fill with setting data
* @v len Length of buffer
* @ret len Length of setting data, or negative error
*
* The actual length of the setting will be returned even if
* the buffer was too small.
*/
static int nvo_fetch ( struct settings *settings, unsigned int tag,
void *data, size_t len ) {
struct nvo_block *nvo =
container_of ( settings, struct nvo_block, settings );
return dhcpopt_fetch ( &nvo->dhcpopts, tag, data, len );
}
/** NVO settings operations */
static struct settings_operations nvo_settings_operations = {
.store = nvo_store,
.fetch = nvo_fetch,
};
/**
* Initialise non-volatile stored options
*
* @v nvo Non-volatile options block
* @v nvs Underlying non-volatile storage device
* @v fragments List of option-containing fragments
* @v refcnt Containing object reference counter, or NULL
*/
void nvo_init ( struct nvo_block *nvo, struct nvs_device *nvs,
struct nvo_fragment *fragments, struct refcnt *refcnt ) {
nvo->nvs = nvs;
nvo->fragments = fragments;
settings_init ( &nvo->settings, &nvo_settings_operations, refcnt,
"nvo" );
}
/**
* Register non-volatile stored options
*
* @v nvo Non-volatile options block
* @v parent Parent settings block, or NULL
* @ret rc Return status code
*/
int nvo_register ( struct nvo_block *nvo ) {
int register_nvo ( struct nvo_block *nvo, struct settings *parent ) {
struct nvo_fragment *fragment = nvo->fragments;
int rc;
/* Calculate total length of all fragments */
nvo->total_len = 0;
for ( fragment = nvo->fragments ; fragment->len ; fragment++ ) {
for ( fragment = nvo->fragments ; fragment->len ; fragment++ )
nvo->total_len += fragment->len;
}
/* Allocate memory for options and read in from NVS */
nvo->options = alloc_dhcp_options ( nvo->total_len );
if ( ! nvo->options ) {
DBG ( "NVO %p could not allocate %zd bytes\n",
nvo, nvo->total_len );
nvo->data = malloc ( nvo->total_len );
if ( ! nvo->data ) {
DBGC ( nvo, "NVO %p could not allocate %zd bytes\n",
nvo, nvo->total_len );
rc = -ENOMEM;
goto err;
goto err_malloc;
}
if ( ( rc = nvo_load ( nvo ) ) != 0 )
goto err;
goto err_load;
/* Verify and register options */
nvo_init_dhcp ( nvo );
register_dhcp_options ( nvo->options );
nvo_init_dhcpopts ( nvo );
if ( ( rc = register_settings ( &nvo->settings, parent ) ) != 0 )
goto err_register;
ugly_nvo_hack = nvo;
DBG ( "NVO %p registered\n", nvo );
DBGC ( nvo, "NVO %p registered\n", nvo );
return 0;
err:
dhcpopt_put ( nvo->options );
nvo->options = NULL;
err_register:
err_load:
free ( nvo->data );
nvo->data = NULL;
err_malloc:
return rc;
}
@@ -204,15 +252,9 @@ int nvo_register ( struct nvo_block *nvo ) {
*
* @v nvo Non-volatile options block
*/
void nvo_unregister ( struct nvo_block *nvo ) {
if ( nvo->options ) {
unregister_dhcp_options ( nvo->options );
dhcpopt_put ( nvo->options );
nvo->options = NULL;
}
DBG ( "NVO %p unregistered\n", nvo );
ugly_nvo_hack = NULL;
void unregister_nvo ( struct nvo_block *nvo ) {
unregister_settings ( &nvo->settings );
free ( nvo->data );
nvo->data = NULL;
DBGC ( nvo, "NVO %p unregistered\n", nvo );
}

101
src/core/settings.c
View File

@@ -213,6 +213,7 @@ void unregister_settings ( struct settings *settings ) {
/* Remove from list of settings */
ref_put ( settings->refcnt );
ref_put ( settings->parent->refcnt );
settings->parent = NULL;
list_del ( &settings->siblings );
DBGC ( settings, "Settings %p unregistered\n", settings );
@@ -280,8 +281,13 @@ struct settings * find_settings ( const char *name ) {
*/
int store_setting ( struct settings *settings, unsigned int tag,
const void *data, size_t len ) {
struct settings *parent;
int rc;
/* Sanity check */
if ( ! settings )
return -ENODEV;
/* Store setting */
if ( ( rc = settings->op->store ( settings, tag, data, len ) ) != 0 )
return rc;
@@ -290,9 +296,16 @@ int store_setting ( struct settings *settings, unsigned int tag,
if ( tag == DHCP_EB_PRIORITY )
reprioritise_settings ( settings );
/* Apply potentially-updated setting */
if ( ( rc = apply_settings() ) != 0 )
return rc;
/* If these settings are registered, apply potentially-updated
* settings
*/
for ( parent = settings->parent ; parent ; parent = parent->parent ) {
if ( parent == &settings_root ) {
if ( ( rc = apply_settings() ) != 0 )
return rc;
break;
}
}
return 0;
}
@@ -468,6 +481,88 @@ unsigned long fetch_uintz_setting ( struct settings *settings,
return value;
}
/**
* Copy setting
*
* @v dest Destination settings block
* @v dest_tag Destination setting tag number
* @v source Source settings block
* @v source_tag Source setting tag number
* @ret rc Return status code
*/
int copy_setting ( struct settings *dest, unsigned int dest_tag,
struct settings *source, unsigned int source_tag ) {
int len;
int check_len;
int rc;
len = fetch_setting_len ( source, source_tag );
if ( len < 0 )
return len;
{
char buf[len];
check_len = fetch_setting ( source, source_tag, buf,
sizeof ( buf ) );
assert ( check_len == len );
if ( ( rc = store_setting ( dest, dest_tag, buf,
sizeof ( buf ) ) ) != 0 )
return rc;
}
return 0;
}
/**
* Copy settings
*
* @v dest Destination settings block
* @v source Source settings block
* @v encapsulator Encapsulating setting tag number, or zero
* @ret rc Return status code
*/
static int copy_encap_settings ( struct settings *dest,
struct settings *source,
unsigned int encapsulator ) {
unsigned int subtag;
unsigned int tag;
int rc;
for ( subtag = DHCP_MIN_OPTION; subtag <= DHCP_MAX_OPTION; subtag++ ) {
tag = DHCP_ENCAP_OPT ( encapsulator, subtag );
switch ( tag ) {
case DHCP_EB_ENCAP:
case DHCP_VENDOR_ENCAP:
/* Process encapsulated options field */
if ( ( rc = copy_encap_settings ( dest, source,
tag ) ) != 0 )
return rc;
break;
default:
/* Copy option to reassembled packet */
if ( ( rc = copy_setting ( dest, tag, source,
tag ) ) != 0 )
return rc;
break;
}
}
return 0;
}
/**
* Copy settings
*
* @v dest Destination settings block
* @v source Source settings block
* @ret rc Return status code
*/
int copy_settings ( struct settings *dest, struct settings *source ) {
return copy_encap_settings ( dest, source, 0 );
}
/******************************************************************************
*
* Named and typed setting routines