nvo.c File Reference

Non-volatile stored options. More...

#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <gpxe/dhcp.h>
#include <gpxe/nvs.h>
#include <gpxe/nvo.h>

Go to the source code of this file.

Functions
	FILE_LICENCE (GPL2_OR_LATER)
static unsigned int	nvo_checksum (struct nvo_block *nvo)
	Calculate checksum over non-volatile stored options.
static int	nvo_load (struct nvo_block *nvo)
	Load non-volatile stored options from non-volatile storage device.
static int	nvo_save (struct nvo_block *nvo)
	Save non-volatile stored options back to non-volatile storage device.
static void	nvo_init_dhcpopts (struct nvo_block *nvo)
	Parse stored options.
static int	nvo_store (struct settings *settings, struct setting *setting, const void *data, size_t len)
	Store value of NVO setting.
static int	nvo_fetch (struct settings *settings, struct setting *setting, void *data, size_t len)
	Fetch value of NVO setting.
void	nvo_init (struct nvo_block *nvo, struct nvs_device *nvs, struct nvo_fragment *fragments, struct refcnt *refcnt)
	Initialise non-volatile stored options.
int	register_nvo (struct nvo_block *nvo, struct settings *parent)
	Register non-volatile stored options.
void	unregister_nvo (struct nvo_block *nvo)
	Unregister non-volatile stored options.
Variables
static struct settings_operations	nvo_settings_operations
	NVO settings operations.

---

Detailed Description

Non-volatile stored options.

Definition in file nvo.c.

---

Function Documentation

FILE_LICENCE

(

GPL2_OR_LATER

)

static unsigned int nvo_checksum

(

struct nvo_block *

nvo

)

[static]

Calculate checksum over non-volatile stored options.

Parameters:

nvo

Non-volatile options block

Return values:

sum

Checksum

Definition at line 41 of file nvo.c.

References nvo_block::data, and nvo_block::total_len.

Referenced by nvo_init_dhcpopts(), and nvo_save().

                                                           {
        uint8_t *data = nvo->data;
        uint8_t sum = 0;
        unsigned int i;

        for ( i = 0 ; i < nvo->total_len ; i++ ) {
                sum += *(data++);
        }
        return sum;
}

static int nvo_load

(

struct nvo_block *

nvo

)

[static]

Load non-volatile stored options from non-volatile storage device.

Parameters:

nvo

Non-volatile options block

Return values:

rc

Return status code

Definition at line 58 of file nvo.c.

References nvo_fragment::address, nvo_block::data, DBGC, nvo_block::fragments, nvo_fragment::len, nvo_block::nvs, and nvs_read().

Referenced by register_nvo().

                                              {
        void *data = nvo->data;
        struct nvo_fragment *frag;
        int rc;

        /* Read data a fragment at a time */
        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 += frag->len;
        }

        DBGC ( nvo, "NVO %p loaded from non-volatile storage\n", nvo );
        return 0;
}

static int nvo_save

(

struct nvo_block *

nvo

)

[static]

Save non-volatile stored options back to non-volatile storage device.

Parameters:

nvo

Non-volatile options block

Return values:

rc

Return status code

Definition at line 84 of file nvo.c.

References nvo_fragment::address, nvo_block::data, DBGC, nvo_block::fragments, nvo_fragment::len, nvo_checksum(), nvo_block::nvs, and nvs_write().

Referenced by nvo_store().

                                              {
        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 ( 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 += frag->len;
        }

        DBGC ( nvo, "NVO %p saved to non-volatile storage\n", nvo );
        return 0;
}

static void nvo_init_dhcpopts

(

struct nvo_block *

nvo

)

[static]

Parse stored options.

Parameters:

nvo

Non-volatile options block

Verifies that the options data is valid, and configures the DHCP options block. If the data is not valid, it is replaced with an empty options block.

Definition at line 117 of file nvo.c.

References nvo_block::data, DBGC, dhcpopt_init(), nvo_block::dhcpopts, memset(), nvo_checksum(), and nvo_block::total_len.

Referenced by register_nvo().

                                                        {
        uint8_t *options_data;
        size_t options_len;

        /* Steal one byte for the checksum */
        options_data = ( nvo->data + 1 );
        options_len = ( nvo->total_len - 1 );

        /* 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 );
        }

        dhcpopt_init ( &nvo->dhcpopts, options_data, options_len );
}

static int nvo_store	(	struct settings *	settings,
		struct setting *	setting,
		const void *	data,
		size_t	len
	)			[static]

Store value of NVO setting.

Parameters:

	settings	Settings block
	setting	Setting to store
	data	Setting data, or NULL to clear setting
	len	Length of setting data

Return values:

rc

Return status code

Definition at line 148 of file nvo.c.

References container_of, DBGC, dhcpopt_store(), nvo_block::dhcpopts, nvo_save(), strerror(), and setting::tag.

                                                      {
        struct nvo_block *nvo =
                container_of ( settings, struct nvo_block, settings );
        int rc;

        /* Update stored options */
        if ( ( rc = dhcpopt_store ( &nvo->dhcpopts, setting->tag,
                                    data, len ) ) != 0 ) {
                DBGC ( nvo, "NVO %p could not store %zd bytes: %s\n",
                       nvo, len, strerror ( rc ) );
                return rc;
        }

        /* Save updated options to NVS */
        if ( ( rc = nvo_save ( nvo ) ) != 0 )
                return rc;

        return 0;
}

static int nvo_fetch	(	struct settings *	settings,
		struct setting *	setting,
		void *	data,
		size_t	len
	)			[static]

Fetch value of NVO setting.

Parameters:

	settings	Settings block
	setting	Setting to fetch
	data	Buffer to fill with setting data
	len	Length of buffer

Return values:

len

Length of setting data, or negative error

The actual length of the setting will be returned even if the buffer was too small.

Definition at line 181 of file nvo.c.

References container_of, dhcpopt_fetch(), nvo_block::dhcpopts, and setting::tag.

                                                {
        struct nvo_block *nvo =
                container_of ( settings, struct nvo_block, settings );

        return dhcpopt_fetch ( &nvo->dhcpopts, setting->tag, data, len );
}

void nvo_init	(	struct nvo_block *	nvo,
		struct nvs_device *	nvs,
		struct nvo_fragment *	fragments,
		struct refcnt *	refcnt
	)

Initialise non-volatile stored options.

Parameters:

	nvo	Non-volatile options block
	nvs	Underlying non-volatile storage device
	fragments	List of option-containing fragments
	refcnt	Containing object reference counter, or NULL

Definition at line 203 of file nvo.c.

References nvo_block::fragments, nvo_block::nvs, nvo_block::settings, and settings_init().

Referenced by falcon_probe_spi(), and rtl_init_eeprom().

                                                                        {
        nvo->nvs = nvs;
        nvo->fragments = fragments;
        settings_init ( &nvo->settings, &nvo_settings_operations, refcnt,
                        "nvo", 0 );
}

int register_nvo	(	struct nvo_block *	nvo,
		struct settings *	parent
	)

Register non-volatile stored options.

Parameters:

	nvo	Non-volatile options block
	parent	Parent settings block, or NULL

Return values:

rc

Return status code

Definition at line 218 of file nvo.c.

References nvo_block::data, DBGC, ENOMEM, nvo_block::fragments, free(), nvo_fragment::len, malloc(), NULL, nvo_init_dhcpopts(), nvo_load(), register_settings(), nvo_block::settings, and nvo_block::total_len.

Referenced by efab_probe(), and rtl_probe().

                                                                    {
        struct nvo_fragment *fragment = nvo->fragments;
        int rc;

        /* Calculate total length of all fragments */
        for ( fragment = nvo->fragments ; fragment->len ; fragment++ )
                nvo->total_len += fragment->len;

        /* Allocate memory for options and read in from NVS */
        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_malloc;
        }
        if ( ( rc = nvo_load ( nvo ) ) != 0 )
                goto err_load;

        /* Verify and register options */
        nvo_init_dhcpopts ( nvo );
        if ( ( rc = register_settings ( &nvo->settings, parent ) ) != 0 )
                goto err_register;

        DBGC ( nvo, "NVO %p registered\n", nvo );
        return 0;
        
 err_register:
 err_load:
        free ( nvo->data );
        nvo->data = NULL;
 err_malloc:
        return rc;
}

void unregister_nvo

(

struct nvo_block *

nvo

)

Unregister non-volatile stored options.

Parameters:

nvo

Non-volatile options block

Definition at line 258 of file nvo.c.

References nvo_block::data, DBGC, free(), NULL, nvo_block::settings, and unregister_settings().

Referenced by efab_remove(), and rtl_remove().

                                              {
        unregister_settings ( &nvo->settings );
        free ( nvo->data );
        nvo->data = NULL;
        DBGC ( nvo, "NVO %p unregistered\n", nvo );
}

---

Variable Documentation

struct settings_operations nvo_settings_operations [static]

Initial value:

 {
        .store = nvo_store,
        .fetch = nvo_fetch,
}

NVO settings operations.

Definition at line 190 of file nvo.c.