6cffadf0f0
NULL (which we'll use to denote deleted values in bhnd_nvram_store), and opaque data (aka octet-strings). Approved by: adrian (mentor) Differential Revision: https://reviews.freebsd.org/D8758
1937 lines
51 KiB
C
1937 lines
51 KiB
C
/*-
|
|
* Copyright (c) 2015-2016 Landon Fuller <landonf@FreeBSD.org>
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer,
|
|
* without modification.
|
|
* 2. Redistributions in binary form must reproduce at minimum a disclaimer
|
|
* similar to the "NO WARRANTY" disclaimer below ("Disclaimer") and any
|
|
* redistribution must be conditioned upon including a substantially
|
|
* similar Disclaimer requirement for further binary redistribution.
|
|
*
|
|
* NO WARRANTY
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTIBILITY
|
|
* AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
|
|
* THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY,
|
|
* OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
|
|
* IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
|
|
* THE POSSIBILITY OF SUCH DAMAGES.
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/sbuf.h>
|
|
|
|
#ifdef _KERNEL
|
|
|
|
#include <sys/ctype.h>
|
|
#include <sys/kernel.h>
|
|
#include <sys/malloc.h>
|
|
#include <sys/systm.h>
|
|
|
|
#include <machine/_inttypes.h>
|
|
|
|
#else /* !_KERNEL */
|
|
|
|
#include <ctype.h>
|
|
#include <inttypes.h>
|
|
#include <errno.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#endif /* _KERNEL */
|
|
|
|
#include "bhnd_nvram_private.h"
|
|
|
|
#include "bhnd_nvram_valuevar.h"
|
|
|
|
static int bhnd_nvram_val_fmt_filter(const bhnd_nvram_val_fmt **fmt,
|
|
const void *inp, size_t ilen, bhnd_nvram_type itype);
|
|
|
|
static void *bhnd_nvram_val_alloc_bytes(bhnd_nvram_val *value, size_t ilen,
|
|
bhnd_nvram_type itype, uint32_t flags);
|
|
static int bhnd_nvram_val_set(bhnd_nvram_val *value, const void *inp,
|
|
size_t ilen, bhnd_nvram_type itype, uint32_t flags);
|
|
static int bhnd_nvram_val_set_inline(bhnd_nvram_val *value,
|
|
const void *inp, size_t ilen, bhnd_nvram_type itype);
|
|
|
|
|
|
static int bhnd_nvram_val_encode_data(const void *inp, size_t ilen,
|
|
bhnd_nvram_type itype, void *outp, size_t *olen,
|
|
bhnd_nvram_type otype);
|
|
static int bhnd_nvram_val_encode_int(const void *inp, size_t ilen,
|
|
bhnd_nvram_type itype, void *outp, size_t *olen,
|
|
bhnd_nvram_type otype);
|
|
static int bhnd_nvram_val_encode_null(const void *inp, size_t ilen,
|
|
bhnd_nvram_type itype, void *outp, size_t *olen,
|
|
bhnd_nvram_type otype);
|
|
static int bhnd_nvram_val_encode_bool(const void *inp, size_t ilen,
|
|
bhnd_nvram_type itype, void *outp, size_t *olen,
|
|
bhnd_nvram_type otype);
|
|
static int bhnd_nvram_val_encode_string(const void *inp, size_t ilen,
|
|
bhnd_nvram_type itype, void *outp, size_t *olen,
|
|
bhnd_nvram_type otype);
|
|
|
|
/** Initialize an empty value instance with @p _fmt, @p _storage, and
|
|
* an implicit callee-owned reference */
|
|
#define BHND_NVRAM_VAL_INITIALIZER(_fmt, _storage) \
|
|
(bhnd_nvram_val) { \
|
|
.refs = 1, \
|
|
.val_storage = _storage, \
|
|
.fmt = _fmt, \
|
|
.data_storage = BHND_NVRAM_VAL_DATA_NONE, \
|
|
};
|
|
|
|
/** Assert that @p value's backing representation state has initialized
|
|
* as empty. */
|
|
#define BHND_NVRAM_VAL_ASSERT_EMPTY(_value) \
|
|
BHND_NV_ASSERT( \
|
|
value->data_storage == BHND_NVRAM_VAL_DATA_NONE && \
|
|
value->data_len == 0 && \
|
|
value->data.ptr == NULL, \
|
|
("previously initialized value"))
|
|
|
|
/** Return true if BHND_NVRAM_VAL_BORROW_DATA or BHND_NVRAM_VAL_STATIC_DATA is
|
|
* set in @p _flags (e.g. we should attempt to directly reference external
|
|
* data */
|
|
#define BHND_NVRAM_VAL_EXTREF_BORROWED_DATA(_flags) \
|
|
(((_flags) & BHND_NVRAM_VAL_BORROW_DATA) || \
|
|
((_flags) & BHND_NVRAM_VAL_STATIC_DATA))
|
|
|
|
/** Flags permitted when performing val-based initialization via
|
|
* bhnd_nvram_val_convert_init() or bhnd_nvram_val_convert_new() */
|
|
#define BHND_NVRAM_VALID_CONV_FLAGS \
|
|
(BHND_NVRAM_VAL_FIXED | \
|
|
BHND_NVRAM_VAL_DYNAMIC | \
|
|
BHND_NVRAM_VAL_COPY_DATA)
|
|
|
|
/** Returns true if @p _val must be copied in bhnd_nvram_val_copy(), false
|
|
* if its reference count may be safely incremented */
|
|
#define BHND_NVRAM_VAL_NEED_COPY(_val) \
|
|
((_val)->val_storage == BHND_NVRAM_VAL_STORAGE_AUTO || \
|
|
(_val)->data_storage == BHND_NVRAM_VAL_DATA_EXT_WEAK)
|
|
|
|
volatile u_int refs; /**< reference count */
|
|
bhnd_nvram_val_storage val_storage; /**< value structure storage */
|
|
const bhnd_nvram_val_fmt *fmt; /**< value format */
|
|
bhnd_nvram_val_data_storage data_storage; /**< data storage */
|
|
bhnd_nvram_type data_type; /**< data type */
|
|
size_t data_len; /**< data size */
|
|
|
|
/* Shared NULL value instance */
|
|
bhnd_nvram_val bhnd_nvram_val_null = {
|
|
.refs = 1,
|
|
.val_storage = BHND_NVRAM_VAL_STORAGE_STATIC,
|
|
.fmt = &bhnd_nvram_val_null_fmt,
|
|
.data_storage = BHND_NVRAM_VAL_DATA_INLINE,
|
|
.data_type = BHND_NVRAM_TYPE_NULL,
|
|
.data_len = 0,
|
|
};
|
|
|
|
/**
|
|
* Return the human-readable name of @p fmt.
|
|
*/
|
|
const char *
|
|
bhnd_nvram_val_fmt_name(const bhnd_nvram_val_fmt *fmt)
|
|
{
|
|
return (fmt->name);
|
|
}
|
|
|
|
/**
|
|
* Return the default format for values of @p type.
|
|
*/
|
|
const bhnd_nvram_val_fmt *
|
|
bhnd_nvram_val_default_fmt(bhnd_nvram_type type)
|
|
{
|
|
switch (type) {
|
|
case BHND_NVRAM_TYPE_UINT8:
|
|
return (&bhnd_nvram_val_uint8_fmt);
|
|
case BHND_NVRAM_TYPE_UINT16:
|
|
return (&bhnd_nvram_val_uint16_fmt);
|
|
case BHND_NVRAM_TYPE_UINT32:
|
|
return (&bhnd_nvram_val_uint32_fmt);
|
|
case BHND_NVRAM_TYPE_UINT64:
|
|
return (&bhnd_nvram_val_uint64_fmt);
|
|
case BHND_NVRAM_TYPE_INT8:
|
|
return (&bhnd_nvram_val_int8_fmt);
|
|
case BHND_NVRAM_TYPE_INT16:
|
|
return (&bhnd_nvram_val_int16_fmt);
|
|
case BHND_NVRAM_TYPE_INT32:
|
|
return (&bhnd_nvram_val_int32_fmt);
|
|
case BHND_NVRAM_TYPE_INT64:
|
|
return (&bhnd_nvram_val_int64_fmt);
|
|
case BHND_NVRAM_TYPE_CHAR:
|
|
return (&bhnd_nvram_val_char_fmt);
|
|
case BHND_NVRAM_TYPE_STRING:
|
|
return (&bhnd_nvram_val_string_fmt);
|
|
case BHND_NVRAM_TYPE_BOOL:
|
|
return (&bhnd_nvram_val_bool_fmt);
|
|
case BHND_NVRAM_TYPE_NULL:
|
|
return (&bhnd_nvram_val_null_fmt);
|
|
case BHND_NVRAM_TYPE_DATA:
|
|
return (&bhnd_nvram_val_data_fmt);
|
|
case BHND_NVRAM_TYPE_UINT8_ARRAY:
|
|
return (&bhnd_nvram_val_uint8_array_fmt);
|
|
case BHND_NVRAM_TYPE_UINT16_ARRAY:
|
|
return (&bhnd_nvram_val_uint16_array_fmt);
|
|
case BHND_NVRAM_TYPE_UINT32_ARRAY:
|
|
return (&bhnd_nvram_val_uint32_array_fmt);
|
|
case BHND_NVRAM_TYPE_UINT64_ARRAY:
|
|
return (&bhnd_nvram_val_uint64_array_fmt);
|
|
case BHND_NVRAM_TYPE_INT8_ARRAY:
|
|
return (&bhnd_nvram_val_int8_array_fmt);
|
|
case BHND_NVRAM_TYPE_INT16_ARRAY:
|
|
return (&bhnd_nvram_val_int16_array_fmt);
|
|
case BHND_NVRAM_TYPE_INT32_ARRAY:
|
|
return (&bhnd_nvram_val_int32_array_fmt);
|
|
case BHND_NVRAM_TYPE_INT64_ARRAY:
|
|
return (&bhnd_nvram_val_int64_array_fmt);
|
|
case BHND_NVRAM_TYPE_CHAR_ARRAY:
|
|
return (&bhnd_nvram_val_char_array_fmt);
|
|
case BHND_NVRAM_TYPE_STRING_ARRAY:
|
|
return (&bhnd_nvram_val_string_array_fmt);
|
|
case BHND_NVRAM_TYPE_BOOL_ARRAY:
|
|
return (&bhnd_nvram_val_bool_array_fmt);
|
|
}
|
|
|
|
/* Quiesce gcc4.2 */
|
|
BHND_NV_PANIC("bhnd nvram type %u unknown", type);
|
|
}
|
|
|
|
/**
|
|
* Determine whether @p fmt (or new format delegated to by @p fmt) is
|
|
* capable of direct initialization from buffer @p inp.
|
|
*
|
|
* @param[in,out] fmt Indirect pointer to the NVRAM value format. If
|
|
* the format instance cannot handle the data type
|
|
* directly, it may delegate to a new format
|
|
* instance. On success, this parameter will be
|
|
* set to the format that should be used when
|
|
* performing initialization from @p inp.
|
|
* @param inp Input data.
|
|
* @param ilen Input data length.
|
|
* @param itype Input data type.
|
|
*
|
|
* @retval 0 If initialization from @p inp is supported.
|
|
* @retval EFTYPE If initialization from @p inp is unsupported.
|
|
* @retval EFAULT if @p ilen is not correctly aligned for elements of
|
|
* @p itype.
|
|
*/
|
|
static int
|
|
bhnd_nvram_val_fmt_filter(const bhnd_nvram_val_fmt **fmt, const void *inp,
|
|
size_t ilen, bhnd_nvram_type itype)
|
|
{
|
|
const bhnd_nvram_val_fmt *ofmt, *nfmt;
|
|
int error;
|
|
|
|
nfmt = ofmt = *fmt;
|
|
|
|
/* Validate alignment */
|
|
if ((error = bhnd_nvram_value_check_aligned(inp, ilen, itype)))
|
|
return (error);
|
|
|
|
/* If the format does not provide a filter function, it only supports
|
|
* direct initialization from its native type */
|
|
if (ofmt->op_filter == NULL) {
|
|
if (itype == ofmt->native_type)
|
|
return (0);
|
|
|
|
return (EFTYPE);
|
|
}
|
|
|
|
/* Use the filter function to determine whether direct initialization
|
|
* from itype is permitted */
|
|
error = ofmt->op_filter(&nfmt, inp, ilen, itype);
|
|
if (error)
|
|
return (error);
|
|
|
|
/* Retry filter with new format? */
|
|
if (ofmt != nfmt) {
|
|
error = bhnd_nvram_val_fmt_filter(&nfmt, inp, ilen, itype);
|
|
if (error)
|
|
return (error);
|
|
|
|
/* Success -- provide delegated format to caller */
|
|
*fmt = nfmt;
|
|
}
|
|
|
|
/* Value can be initialized with provided format and input type */
|
|
return (0);
|
|
}
|
|
|
|
/* Common initialization support for bhnd_nvram_val_init() and
|
|
* bhnd_nvram_val_new() */
|
|
static int
|
|
bhnd_nvram_val_init_common(bhnd_nvram_val *value,
|
|
bhnd_nvram_val_storage val_storage, const bhnd_nvram_val_fmt *fmt,
|
|
const void *inp, size_t ilen, bhnd_nvram_type itype, uint32_t flags)
|
|
{
|
|
void *outp;
|
|
bhnd_nvram_type otype;
|
|
size_t olen;
|
|
int error;
|
|
|
|
/* If the value format is unspecified, we use the default format
|
|
* for the input data type */
|
|
if (fmt == NULL)
|
|
fmt = bhnd_nvram_val_default_fmt(itype);
|
|
|
|
/* Determine expected data type, and allow the format to delegate to
|
|
* a new format instance */
|
|
if ((error = bhnd_nvram_val_fmt_filter(&fmt, inp, ilen, itype))) {
|
|
/* Direct initialization from the provided input type is
|
|
* not supported; alue must be initialized with the format's
|
|
* native type */
|
|
otype = fmt->native_type;
|
|
} else {
|
|
/* Value can be initialized with provided input type */
|
|
otype = itype;
|
|
}
|
|
|
|
/* Initialize value instance */
|
|
*value = BHND_NVRAM_VAL_INITIALIZER(fmt, val_storage);
|
|
|
|
/* If input data already in native format, init directly. */
|
|
if (otype == itype) {
|
|
error = bhnd_nvram_val_set(value, inp, ilen, itype, flags);
|
|
if (error)
|
|
return (error);
|
|
|
|
return (0);
|
|
}
|
|
|
|
/* Determine size when encoded in native format */
|
|
error = bhnd_nvram_value_coerce(inp, ilen, itype, NULL, &olen, otype);
|
|
if (error)
|
|
return (error);
|
|
|
|
/* Fetch reference to (or allocate) an appropriately sized buffer */
|
|
outp = bhnd_nvram_val_alloc_bytes(value, olen, otype, flags);
|
|
if (outp == NULL)
|
|
return (ENOMEM);
|
|
|
|
/* Perform encode */
|
|
error = bhnd_nvram_value_coerce(inp, ilen, itype, outp, &olen, otype);
|
|
if (error)
|
|
return (error);
|
|
|
|
return (0);
|
|
}
|
|
|
|
/**
|
|
* Initialize an externally allocated instance of @p value with @p fmt from the
|
|
* given @p inp buffer of @p itype and @p ilen.
|
|
*
|
|
* On success, the caller owns a reference to @p value, and is responsible for
|
|
* freeing any resources allocated for @p value via bhnd_nvram_val_release().
|
|
*
|
|
* @param value The externally allocated value instance to be
|
|
* initialized.
|
|
* @param fmt The value's format, or NULL to use the default format
|
|
* for @p itype.
|
|
* @param inp Input buffer.
|
|
* @param ilen Input buffer length.
|
|
* @param itype Input buffer type.
|
|
* @param flags Value flags (see BHND_NVRAM_VAL_*).
|
|
*
|
|
* @retval 0 success
|
|
* @retval ENOMEM If allocation fails.
|
|
* @retval EFTYPE If @p fmt initialization from @p itype is unsupported.
|
|
* @retval EFAULT if @p ilen is not correctly aligned for elements of
|
|
* @p itype.
|
|
* @retval ERANGE If value coercion would overflow (or underflow) the
|
|
* @p fmt representation.
|
|
*/
|
|
int
|
|
bhnd_nvram_val_init(bhnd_nvram_val *value, const bhnd_nvram_val_fmt *fmt,
|
|
const void *inp, size_t ilen, bhnd_nvram_type itype, uint32_t flags)
|
|
{
|
|
int error;
|
|
|
|
error = bhnd_nvram_val_init_common(value, BHND_NVRAM_VAL_STORAGE_AUTO,
|
|
fmt, inp, ilen, itype, flags);
|
|
if (error)
|
|
bhnd_nvram_val_release(value);
|
|
|
|
return (error);
|
|
}
|
|
|
|
/**
|
|
* Allocate a value instance with @p fmt, and attempt to initialize its internal
|
|
* representation from the given @p inp buffer of @p itype and @p ilen.
|
|
*
|
|
* On success, the caller owns a reference to @p value, and is responsible for
|
|
* freeing any resources allocated for @p value via bhnd_nvram_val_release().
|
|
*
|
|
* @param[out] value On success, the allocated value instance.
|
|
* @param fmt The value's format, or NULL to use the default format
|
|
* for @p itype.
|
|
* @param inp Input buffer.
|
|
* @param ilen Input buffer length.
|
|
* @param itype Input buffer type.
|
|
* @param flags Value flags (see BHND_NVRAM_VAL_*).
|
|
*
|
|
* @retval 0 success
|
|
* @retval ENOMEM If allocation fails.
|
|
* @retval EFTYPE If @p fmt initialization from @p itype is unsupported.
|
|
* @retval EFAULT if @p ilen is not correctly aligned for elements of
|
|
* @p itype.
|
|
* @retval ERANGE If value coercion would overflow (or underflow) the
|
|
* @p fmt representation.
|
|
*/
|
|
int
|
|
bhnd_nvram_val_new(bhnd_nvram_val **value, const bhnd_nvram_val_fmt *fmt,
|
|
const void *inp, size_t ilen, bhnd_nvram_type itype, uint32_t flags)
|
|
{
|
|
int error;
|
|
|
|
/* Allocate new instance */
|
|
if ((*value = bhnd_nv_malloc(sizeof(**value))) == NULL)
|
|
return (ENOMEM);
|
|
|
|
/* Perform common initialization. */
|
|
error = bhnd_nvram_val_init_common(*value,
|
|
BHND_NVRAM_VAL_STORAGE_DYNAMIC, fmt, inp, ilen, itype, flags);
|
|
if (error) {
|
|
/* Will also free() the value allocation */
|
|
bhnd_nvram_val_release(*value);
|
|
}
|
|
|
|
return (error);
|
|
}
|
|
|
|
|
|
/* Common initialization support for bhnd_nvram_val_convert_init() and
|
|
* bhnd_nvram_val_convert_new() */
|
|
static int
|
|
bhnd_nvram_val_convert_common(bhnd_nvram_val *value,
|
|
bhnd_nvram_val_storage val_storage, const bhnd_nvram_val_fmt *fmt,
|
|
bhnd_nvram_val *src, uint32_t flags)
|
|
{
|
|
const void *inp;
|
|
void *outp;
|
|
bhnd_nvram_type itype, otype;
|
|
size_t ilen, olen;
|
|
int error;
|
|
|
|
/* Determine whether direct initialization from the source value's
|
|
* existing data type is supported by the new format */
|
|
inp = bhnd_nvram_val_bytes(src, &ilen, &itype);
|
|
if (bhnd_nvram_val_fmt_filter(&fmt, inp, ilen, itype) == 0) {
|
|
/* Adjust value flags based on the source data storage */
|
|
switch (src->data_storage) {
|
|
case BHND_NVRAM_VAL_DATA_NONE:
|
|
case BHND_NVRAM_VAL_DATA_INLINE:
|
|
case BHND_NVRAM_VAL_DATA_EXT_WEAK:
|
|
case BHND_NVRAM_VAL_DATA_EXT_ALLOC:
|
|
break;
|
|
|
|
case BHND_NVRAM_VAL_DATA_EXT_STATIC:
|
|
/* If the source data has static storage duration,
|
|
* we should apply that transitively */
|
|
if (flags & BHND_NVRAM_VAL_BORROW_DATA)
|
|
flags |= BHND_NVRAM_VAL_STATIC_DATA;
|
|
|
|
break;
|
|
}
|
|
|
|
/* Delegate to standard initialization */
|
|
return (bhnd_nvram_val_init_common(value, val_storage, fmt, inp,
|
|
ilen, itype, flags));
|
|
}
|
|
|
|
/* Value must be initialized with the format's native type */
|
|
otype = fmt->native_type;
|
|
|
|
/* Initialize value instance */
|
|
*value = BHND_NVRAM_VAL_INITIALIZER(fmt, val_storage);
|
|
|
|
/* Determine size when encoded in native format */
|
|
if ((error = bhnd_nvram_val_encode(src, NULL, &olen, otype)))
|
|
return (error);
|
|
|
|
/* Fetch reference to (or allocate) an appropriately sized buffer */
|
|
outp = bhnd_nvram_val_alloc_bytes(value, olen, otype, flags);
|
|
if (outp == NULL)
|
|
return (ENOMEM);
|
|
|
|
/* Perform encode */
|
|
if ((error = bhnd_nvram_val_encode(src, outp, &olen, otype)))
|
|
return (error);
|
|
|
|
return (0);
|
|
}
|
|
|
|
/**
|
|
* Initialize an externally allocated instance of @p value with @p fmt, and
|
|
* attempt to initialize its internal representation from the given @p src
|
|
* value.
|
|
*
|
|
* On success, the caller owns a reference to @p value, and is responsible for
|
|
* freeing any resources allocated for @p value via bhnd_nvram_val_release().
|
|
*
|
|
* @param value The externally allocated value instance to be
|
|
* initialized.
|
|
* @param fmt The value's format.
|
|
* @param src Input value to be converted.
|
|
* @param flags Value flags (see BHND_NVRAM_VAL_*).
|
|
*
|
|
* @retval 0 success
|
|
* @retval ENOMEM If allocation fails.
|
|
* @retval EFTYPE If @p fmt initialization from @p src is unsupported.
|
|
* @retval EFAULT if @p ilen is not correctly aligned for elements of
|
|
* @p itype.
|
|
* @retval ERANGE If value coercion of @p src would overflow
|
|
* (or underflow) the @p fmt representation.
|
|
*/
|
|
int
|
|
bhnd_nvram_val_convert_init(bhnd_nvram_val *value,
|
|
const bhnd_nvram_val_fmt *fmt, bhnd_nvram_val *src, uint32_t flags)
|
|
{
|
|
int error;
|
|
|
|
error = bhnd_nvram_val_convert_common(value,
|
|
BHND_NVRAM_VAL_STORAGE_AUTO, fmt, src, flags);
|
|
if (error)
|
|
bhnd_nvram_val_release(value);
|
|
|
|
return (error);
|
|
}
|
|
|
|
/**
|
|
* Allocate a value instance with @p fmt, and attempt to initialize its internal
|
|
* representation from the given @p src value.
|
|
*
|
|
* On success, the caller owns a reference to @p value, and is responsible for
|
|
* freeing any resources allocated for @p value via bhnd_nvram_val_release().
|
|
*
|
|
* @param[out] value On success, the allocated value instance.
|
|
* @param fmt The value's format.
|
|
* @param src Input value to be converted.
|
|
* @param flags Value flags (see BHND_NVRAM_VAL_*).
|
|
*
|
|
* @retval 0 success
|
|
* @retval ENOMEM If allocation fails.
|
|
* @retval EFTYPE If @p fmt initialization from @p src is unsupported.
|
|
* @retval EFAULT if @p ilen is not correctly aligned for elements of
|
|
* @p itype.
|
|
* @retval ERANGE If value coercion of @p src would overflow
|
|
* (or underflow) the @p fmt representation.
|
|
*/
|
|
int
|
|
bhnd_nvram_val_convert_new(bhnd_nvram_val **value,
|
|
const bhnd_nvram_val_fmt *fmt, bhnd_nvram_val *src, uint32_t flags)
|
|
{
|
|
int error;
|
|
|
|
/* Allocate new instance */
|
|
if ((*value = bhnd_nv_malloc(sizeof(**value))) == NULL)
|
|
return (ENOMEM);
|
|
|
|
/* Perform common initialization. */
|
|
error = bhnd_nvram_val_convert_common(*value,
|
|
BHND_NVRAM_VAL_STORAGE_DYNAMIC, fmt, src, flags);
|
|
if (error) {
|
|
/* Will also free() the value allocation */
|
|
bhnd_nvram_val_release(*value);
|
|
}
|
|
|
|
return (error);
|
|
}
|
|
|
|
/**
|
|
* Copy or retain a reference to @p value.
|
|
*
|
|
* On success, the caller is responsible for freeing the result via
|
|
* bhnd_nvram_val_release().
|
|
*
|
|
* @param value The value to be copied (or retained).
|
|
*
|
|
* @retval bhnd_nvram_val if @p value was successfully copied or retained.
|
|
* @retval NULL if allocation failed.
|
|
*/
|
|
bhnd_nvram_val *
|
|
bhnd_nvram_val_copy(bhnd_nvram_val *value)
|
|
{
|
|
bhnd_nvram_val *result;
|
|
const void *bytes;
|
|
bhnd_nvram_type type;
|
|
size_t len;
|
|
uint32_t flags;
|
|
int error;
|
|
|
|
switch (value->val_storage) {
|
|
case BHND_NVRAM_VAL_STORAGE_STATIC:
|
|
/* If static, can return as-is */
|
|
return (value);
|
|
|
|
case BHND_NVRAM_VAL_STORAGE_DYNAMIC:
|
|
if (!BHND_NVRAM_VAL_NEED_COPY(value)) {
|
|
refcount_acquire(&value->refs);
|
|
return (value);
|
|
}
|
|
|
|
/* Perform copy below */
|
|
break;
|
|
|
|
case BHND_NVRAM_VAL_STORAGE_AUTO:
|
|
BHND_NV_ASSERT(value->refs == 1, ("non-allocated value has "
|
|
"active refcount (%u)", value->refs));
|
|
|
|
/* Perform copy below */
|
|
break;
|
|
}
|
|
|
|
|
|
/* Compute the new value's flags based on the source value */
|
|
switch (value->data_storage) {
|
|
case BHND_NVRAM_VAL_DATA_NONE:
|
|
case BHND_NVRAM_VAL_DATA_INLINE:
|
|
case BHND_NVRAM_VAL_DATA_EXT_WEAK:
|
|
case BHND_NVRAM_VAL_DATA_EXT_ALLOC:
|
|
/* Copy the source data and permit additional allocation if the
|
|
* value cannot be represented inline */
|
|
flags = BHND_NVRAM_VAL_COPY_DATA|BHND_NVRAM_VAL_DYNAMIC;
|
|
break;
|
|
case BHND_NVRAM_VAL_DATA_EXT_STATIC:
|
|
flags = BHND_NVRAM_VAL_STATIC_DATA;
|
|
break;
|
|
default:
|
|
BHND_NV_PANIC("invalid storage type: %d", value->data_storage);
|
|
}
|
|
|
|
/* Allocate new value copy */
|
|
bytes = bhnd_nvram_val_bytes(value, &len, &type);
|
|
error = bhnd_nvram_val_new(&result, value->fmt, bytes, len, type,
|
|
flags);
|
|
if (error) {
|
|
BHND_NV_LOG("copy failed: %d", error);
|
|
return (NULL);
|
|
}
|
|
|
|
return (result);
|
|
}
|
|
|
|
/**
|
|
* Release a reference to @p value.
|
|
*
|
|
* If this is the last reference, all associated resources will be freed.
|
|
*
|
|
* @param value The value to be released.
|
|
*/
|
|
void
|
|
bhnd_nvram_val_release(bhnd_nvram_val *value)
|
|
{
|
|
BHND_NV_ASSERT(value->refs >= 1, ("value over-released"));
|
|
|
|
/* Skip if value is static */
|
|
if (value->val_storage == BHND_NVRAM_VAL_STORAGE_STATIC)
|
|
return;
|
|
|
|
/* Drop reference */
|
|
if (!refcount_release(&value->refs))
|
|
return;
|
|
|
|
/* Free allocated external representation data */
|
|
switch (value->data_storage) {
|
|
case BHND_NVRAM_VAL_DATA_EXT_ALLOC:
|
|
bhnd_nv_free(__DECONST(void *, value->data.ptr));
|
|
break;
|
|
case BHND_NVRAM_VAL_DATA_NONE:
|
|
case BHND_NVRAM_VAL_DATA_INLINE:
|
|
case BHND_NVRAM_VAL_DATA_EXT_WEAK:
|
|
case BHND_NVRAM_VAL_DATA_EXT_STATIC:
|
|
/* Nothing to free */
|
|
break;
|
|
}
|
|
|
|
/* Free instance if dynamically allocated */
|
|
if (value->val_storage == BHND_NVRAM_VAL_STORAGE_DYNAMIC)
|
|
bhnd_nv_free(value);
|
|
}
|
|
|
|
/**
|
|
* Standard BHND_NVRAM_TYPE_NULL encoding implementation.
|
|
*/
|
|
static int
|
|
bhnd_nvram_val_encode_null(const void *inp, size_t ilen, bhnd_nvram_type itype,
|
|
void *outp, size_t *olen, bhnd_nvram_type otype)
|
|
{
|
|
size_t limit, nbytes;
|
|
|
|
BHND_NV_ASSERT(itype == BHND_NVRAM_TYPE_NULL,
|
|
("unsupported type: %d", itype));
|
|
|
|
/* Determine output byte limit */
|
|
if (outp != NULL)
|
|
limit = *olen;
|
|
else
|
|
limit = 0;
|
|
|
|
nbytes = 0;
|
|
|
|
/* Write to output */
|
|
switch (otype) {
|
|
case BHND_NVRAM_TYPE_NULL:
|
|
/* Can be directly encoded as a zero-length NULL value */
|
|
nbytes = 0;
|
|
break;
|
|
default:
|
|
/* Not representable */
|
|
return (EFTYPE);
|
|
}
|
|
|
|
/* Provide required length */
|
|
*olen = nbytes;
|
|
if (limit < *olen) {
|
|
if (outp == NULL)
|
|
return (0);
|
|
|
|
return (ENOMEM);
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
/**
|
|
* Standard BHND_NVRAM_TYPE_BOOL encoding implementation.
|
|
*/
|
|
static int
|
|
bhnd_nvram_val_encode_bool(const void *inp, size_t ilen, bhnd_nvram_type itype,
|
|
void *outp, size_t *olen, bhnd_nvram_type otype)
|
|
{
|
|
bhnd_nvram_bool_t bval;
|
|
size_t limit, nbytes, nelem;
|
|
int error;
|
|
|
|
BHND_NV_ASSERT(itype == BHND_NVRAM_TYPE_BOOL,
|
|
("unsupported type: %d", itype));
|
|
|
|
/* Determine output byte limit */
|
|
if (outp != NULL)
|
|
limit = *olen;
|
|
else
|
|
limit = 0;
|
|
|
|
/* Must be exactly one element in input */
|
|
if ((error = bhnd_nvram_value_nelem(inp, ilen, itype, &nelem)))
|
|
return (error);
|
|
|
|
if (nelem != 1)
|
|
return (EFTYPE);
|
|
|
|
/* Fetch (and normalize) boolean value */
|
|
bval = (*(const bhnd_nvram_bool_t *)inp != 0) ? true : false;
|
|
|
|
/* Write to output */
|
|
switch (otype) {
|
|
case BHND_NVRAM_TYPE_NULL:
|
|
/* False can be directly encoded as a zero-length NULL value */
|
|
if (bval != false)
|
|
return (EFTYPE);
|
|
|
|
nbytes = 0;
|
|
break;
|
|
|
|
case BHND_NVRAM_TYPE_STRING:
|
|
case BHND_NVRAM_TYPE_STRING_ARRAY: {
|
|
/* Can encode as "true" or "false" */
|
|
const char *str = bval ? "true" : "false";
|
|
|
|
nbytes = strlen(str) + 1;
|
|
if (limit > nbytes)
|
|
strcpy(outp, str);
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
/* If output type is an integer, we can delegate to standard
|
|
* integer encoding to encode as zero or one. */
|
|
if (bhnd_nvram_is_int_type(otype)) {
|
|
uint8_t ival = bval ? 1 : 0;
|
|
|
|
return (bhnd_nvram_val_encode_int(&ival, sizeof(ival),
|
|
BHND_NVRAM_TYPE_UINT8, outp, olen, otype));
|
|
}
|
|
|
|
/* Otherwise not representable */
|
|
return (EFTYPE);
|
|
}
|
|
|
|
/* Provide required length */
|
|
*olen = nbytes;
|
|
if (limit < *olen) {
|
|
if (outp == NULL)
|
|
return (0);
|
|
|
|
return (ENOMEM);
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
/**
|
|
* Standard BHND_NVRAM_TYPE_DATA encoding implementation.
|
|
*/
|
|
static int
|
|
bhnd_nvram_val_encode_data(const void *inp, size_t ilen, bhnd_nvram_type itype,
|
|
void *outp, size_t *olen, bhnd_nvram_type otype)
|
|
{
|
|
BHND_NV_ASSERT(itype == BHND_NVRAM_TYPE_DATA,
|
|
("unsupported type: %d", itype));
|
|
|
|
/* Write to output */
|
|
switch (otype) {
|
|
case BHND_NVRAM_TYPE_STRING:
|
|
case BHND_NVRAM_TYPE_STRING_ARRAY:
|
|
/* If encoding as a string, produce an EFI-style hexadecimal
|
|
* byte array (HF1F...) by interpreting the octet string
|
|
* as an array of uint8 values */
|
|
return (bhnd_nvram_value_printf("H%[]02hhX", inp, ilen,
|
|
BHND_NVRAM_TYPE_UINT8_ARRAY, outp, olen, ""));
|
|
|
|
default:
|
|
/* Fall back on direct interpretation as an array of 8-bit
|
|
* integers array */
|
|
return (bhnd_nvram_value_coerce(inp, ilen,
|
|
BHND_NVRAM_TYPE_UINT8_ARRAY, outp, olen, otype));
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Standard string/char array/char encoding implementation.
|
|
*
|
|
* Input type must be one of:
|
|
* - BHND_NVRAM_TYPE_STRING
|
|
* - BHND_NVRAM_TYPE_CHAR
|
|
* - BHND_NVRAM_TYPE_CHAR_ARRAY
|
|
*/
|
|
static int
|
|
bhnd_nvram_val_encode_string(const void *inp, size_t ilen,
|
|
bhnd_nvram_type itype, void *outp, size_t *olen, bhnd_nvram_type otype)
|
|
{
|
|
const char *cstr;
|
|
bhnd_nvram_type otype_base;
|
|
size_t cstr_size, cstr_len;
|
|
size_t limit, nbytes;
|
|
|
|
BHND_NV_ASSERT(
|
|
itype == BHND_NVRAM_TYPE_STRING ||
|
|
itype == BHND_NVRAM_TYPE_CHAR ||
|
|
itype == BHND_NVRAM_TYPE_CHAR_ARRAY,
|
|
("unsupported type: %d", itype));
|
|
|
|
cstr = inp;
|
|
cstr_size = ilen;
|
|
nbytes = 0;
|
|
otype_base = bhnd_nvram_base_type(otype);
|
|
|
|
/* Determine output byte limit */
|
|
if (outp != NULL)
|
|
limit = *olen;
|
|
else
|
|
limit = 0;
|
|
|
|
/* Determine string length, minus trailing NUL (if any) */
|
|
cstr_len = strnlen(cstr, cstr_size);
|
|
|
|
/* Parse the string data and write to output */
|
|
switch (otype) {
|
|
case BHND_NVRAM_TYPE_NULL:
|
|
/* Only an empty string may be represented as a NULL value */
|
|
if (cstr_len != 0)
|
|
return (EFTYPE);
|
|
|
|
*olen = 0;
|
|
return (0);
|
|
|
|
case BHND_NVRAM_TYPE_CHAR:
|
|
case BHND_NVRAM_TYPE_CHAR_ARRAY:
|
|
/* String must contain exactly 1 non-terminating-NUL character
|
|
* to be represented as a single char */
|
|
if (!bhnd_nvram_is_array_type(otype)) {
|
|
if (cstr_len != 1)
|
|
return (EFTYPE);
|
|
}
|
|
|
|
/* Copy out the characters directly (excluding trailing NUL) */
|
|
for (size_t i = 0; i < cstr_len; i++) {
|
|
if (limit > nbytes)
|
|
*((uint8_t *)outp + nbytes) = cstr[i];
|
|
nbytes++;
|
|
}
|
|
|
|
/* Provide required length */
|
|
*olen = nbytes;
|
|
if (limit < *olen && outp != NULL)
|
|
return (ENOMEM);
|
|
|
|
return (0);
|
|
|
|
case BHND_NVRAM_TYPE_BOOL:
|
|
case BHND_NVRAM_TYPE_BOOL_ARRAY: {
|
|
const char *p;
|
|
size_t plen;
|
|
bhnd_nvram_bool_t bval;
|
|
|
|
/* Trim leading/trailing whitespace */
|
|
p = cstr;
|
|
plen = bhnd_nvram_trim_field(&p, cstr_len, '\0');
|
|
|
|
/* Parse string representation */
|
|
if (strncasecmp(p, "true", plen) == 0 ||
|
|
strncasecmp(p, "yes", plen) == 0 ||
|
|
strncmp(p, "1", plen) == 0)
|
|
{
|
|
bval = true;
|
|
} else if (strncasecmp(p, "false", plen) == 0 ||
|
|
strncasecmp(p, "no", plen) == 0 ||
|
|
strncmp(p, "0", plen) == 0)
|
|
{
|
|
bval = false;
|
|
} else {
|
|
/* Not a recognized boolean string */
|
|
return (EFTYPE);
|
|
}
|
|
|
|
/* Write to output */
|
|
nbytes = sizeof(bhnd_nvram_bool_t);
|
|
if (limit >= nbytes)
|
|
*((bhnd_nvram_bool_t *)outp) = bval;
|
|
|
|
/* Provide required length */
|
|
*olen = nbytes;
|
|
if (limit < *olen && outp != NULL)
|
|
return (ENOMEM);
|
|
|
|
return (0);
|
|
}
|
|
|
|
case BHND_NVRAM_TYPE_DATA: {
|
|
const char *p;
|
|
size_t plen, parsed_len;
|
|
int error;
|
|
|
|
/* Trim leading/trailing whitespace */
|
|
p = cstr;
|
|
plen = bhnd_nvram_trim_field(&p, cstr_len, '\0');
|
|
|
|
/* Check for EFI-style hexadecimal byte array string format.
|
|
* Must have a 'H' prefix */
|
|
if (plen < 1 || bhnd_nv_toupper(*p) != 'H')
|
|
return (EFTYPE);
|
|
|
|
/* Skip leading 'H' */
|
|
p++;
|
|
plen--;
|
|
|
|
/* Parse the input string's two-char octets until the end
|
|
* of input is reached. The last octet may contain only
|
|
* one char */
|
|
while (plen > 0) {
|
|
uint8_t byte;
|
|
size_t byte_len = sizeof(byte);
|
|
|
|
/* Parse next two-character hex octet */
|
|
error = bhnd_nvram_parse_int(p, bhnd_nv_ummin(plen, 2),
|
|
16, &parsed_len, &byte, &byte_len, otype_base);
|
|
if (error) {
|
|
BHND_NV_DEBUG("error parsing '%.*s' as "
|
|
"integer: %d\n", BHND_NV_PRINT_WIDTH(plen),
|
|
p, error);
|
|
|
|
return (error);
|
|
}
|
|
|
|
/* Write to output */
|
|
if (limit > nbytes)
|
|
*((uint8_t *)outp + nbytes) = byte;
|
|
nbytes++;
|
|
|
|
/* Advance input */
|
|
p += parsed_len;
|
|
plen -= parsed_len;
|
|
}
|
|
|
|
/* Provide required length */
|
|
*olen = nbytes;
|
|
if (limit < *olen && outp != NULL)
|
|
return (ENOMEM);
|
|
|
|
return (0);
|
|
}
|
|
|
|
case BHND_NVRAM_TYPE_UINT8:
|
|
case BHND_NVRAM_TYPE_UINT8_ARRAY:
|
|
case BHND_NVRAM_TYPE_UINT16:
|
|
case BHND_NVRAM_TYPE_UINT16_ARRAY:
|
|
case BHND_NVRAM_TYPE_UINT32:
|
|
case BHND_NVRAM_TYPE_UINT32_ARRAY:
|
|
case BHND_NVRAM_TYPE_UINT64:
|
|
case BHND_NVRAM_TYPE_UINT64_ARRAY:
|
|
case BHND_NVRAM_TYPE_INT8:
|
|
case BHND_NVRAM_TYPE_INT8_ARRAY:
|
|
case BHND_NVRAM_TYPE_INT16:
|
|
case BHND_NVRAM_TYPE_INT16_ARRAY:
|
|
case BHND_NVRAM_TYPE_INT32:
|
|
case BHND_NVRAM_TYPE_INT32_ARRAY:
|
|
case BHND_NVRAM_TYPE_INT64:
|
|
case BHND_NVRAM_TYPE_INT64_ARRAY: {
|
|
const char *p;
|
|
size_t plen, parsed_len;
|
|
int error;
|
|
|
|
/* Trim leading/trailing whitespace */
|
|
p = cstr;
|
|
plen = bhnd_nvram_trim_field(&p, cstr_len, '\0');
|
|
|
|
/* Try to parse the integer value */
|
|
error = bhnd_nvram_parse_int(p, plen, 0, &parsed_len, outp,
|
|
olen, otype_base);
|
|
if (error) {
|
|
BHND_NV_DEBUG("error parsing '%.*s' as integer: %d\n",
|
|
BHND_NV_PRINT_WIDTH(plen), p, error);
|
|
return (error);
|
|
}
|
|
|
|
/* Do additional bytes remain unparsed? */
|
|
if (plen != parsed_len) {
|
|
BHND_NV_DEBUG("error parsing '%.*s' as a single "
|
|
"integer value; trailing garbage '%.*s'\n",
|
|
BHND_NV_PRINT_WIDTH(plen), p,
|
|
BHND_NV_PRINT_WIDTH(plen-parsed_len), p+parsed_len);
|
|
return (EFTYPE);
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
case BHND_NVRAM_TYPE_STRING:
|
|
case BHND_NVRAM_TYPE_STRING_ARRAY:
|
|
/* Copy out the string representation as-is */
|
|
*olen = cstr_size;
|
|
|
|
/* Need additional space for trailing NUL? */
|
|
if (cstr_len == cstr_size)
|
|
(*olen)++;
|
|
|
|
/* Skip output? */
|
|
if (outp == NULL)
|
|
return (0);
|
|
|
|
/* Verify required length */
|
|
if (limit < *olen)
|
|
return (ENOMEM);
|
|
|
|
/* Copy and NUL terminate */
|
|
strncpy(outp, cstr, cstr_len);
|
|
*((char *)outp + cstr_len) = '\0';
|
|
|
|
return (0);
|
|
}
|
|
|
|
BHND_NV_PANIC("unknown type %s", bhnd_nvram_type_name(otype));
|
|
}
|
|
|
|
/**
|
|
* Standard integer encoding implementation.
|
|
*/
|
|
static int
|
|
bhnd_nvram_val_encode_int(const void *inp, size_t ilen, bhnd_nvram_type itype,
|
|
void *outp, size_t *olen, bhnd_nvram_type otype)
|
|
{
|
|
bhnd_nvram_type otype_base;
|
|
size_t limit, nbytes;
|
|
bool itype_signed, otype_signed, otype_int;
|
|
union {
|
|
uint64_t u64;
|
|
int64_t i64;
|
|
} intv;
|
|
|
|
BHND_NV_ASSERT(bhnd_nvram_is_int_type(itype), ("non-integer type"));
|
|
|
|
/* Determine output byte limit */
|
|
if (outp != NULL)
|
|
limit = *olen;
|
|
else
|
|
limit = 0;
|
|
|
|
/* Fetch output type info */
|
|
otype_base = bhnd_nvram_base_type(otype);
|
|
otype_int = bhnd_nvram_is_int_type(otype);
|
|
otype_signed = bhnd_nvram_is_signed_type(otype_base);
|
|
|
|
/*
|
|
* Promote integer value to a common 64-bit representation.
|
|
*/
|
|
switch (itype) {
|
|
case BHND_NVRAM_TYPE_UINT8:
|
|
if (ilen != sizeof(uint8_t))
|
|
return (EFAULT);
|
|
|
|
itype_signed = false;
|
|
intv.u64 = *(const uint8_t *)inp;
|
|
break;
|
|
|
|
case BHND_NVRAM_TYPE_UINT16:
|
|
if (ilen != sizeof(uint16_t))
|
|
return (EFAULT);
|
|
|
|
itype_signed = false;
|
|
intv.u64 = *(const uint16_t *)inp;
|
|
break;
|
|
|
|
case BHND_NVRAM_TYPE_UINT32:
|
|
if (ilen != sizeof(uint32_t))
|
|
return (EFAULT);
|
|
|
|
itype_signed = false;
|
|
intv.u64 = *(const uint32_t *)inp;
|
|
break;
|
|
|
|
case BHND_NVRAM_TYPE_UINT64:
|
|
if (ilen != sizeof(uint64_t))
|
|
return (EFAULT);
|
|
|
|
itype_signed = false;
|
|
intv.u64 = *(const uint64_t *)inp;
|
|
break;
|
|
|
|
case BHND_NVRAM_TYPE_INT8:
|
|
if (ilen != sizeof(int8_t))
|
|
return (EFAULT);
|
|
|
|
itype_signed = true;
|
|
intv.i64 = *(const int8_t *)inp;
|
|
break;
|
|
|
|
case BHND_NVRAM_TYPE_INT16:
|
|
if (ilen != sizeof(int16_t))
|
|
return (EFAULT);
|
|
|
|
itype_signed = true;
|
|
intv.i64 = *(const int16_t *)inp;
|
|
break;
|
|
|
|
case BHND_NVRAM_TYPE_INT32:
|
|
if (ilen != sizeof(int32_t))
|
|
return (EFAULT);
|
|
|
|
itype_signed = true;
|
|
intv.i64 = *(const int32_t *)inp;
|
|
break;
|
|
|
|
case BHND_NVRAM_TYPE_INT64:
|
|
if (ilen != sizeof(int32_t))
|
|
return (EFAULT);
|
|
|
|
itype_signed = true;
|
|
intv.i64 = *(const int32_t *)inp;
|
|
break;
|
|
|
|
default:
|
|
BHND_NV_PANIC("invalid type %d\n", itype);
|
|
}
|
|
|
|
/* Perform signed/unsigned conversion */
|
|
if (itype_signed && otype_int && !otype_signed) {
|
|
if (intv.i64 < 0) {
|
|
/* Can't represent negative value */
|
|
BHND_NV_LOG("cannot represent %" PRId64 " as %s\n",
|
|
intv.i64, bhnd_nvram_type_name(otype));
|
|
|
|
return (ERANGE);
|
|
}
|
|
|
|
/* Convert to unsigned representation */
|
|
intv.u64 = intv.i64;
|
|
|
|
} else if (!itype_signed && otype_int && otype_signed) {
|
|
/* Handle unsigned -> signed coercions */
|
|
if (intv.u64 > INT64_MAX) {
|
|
/* Can't represent positive value */
|
|
BHND_NV_LOG("cannot represent %" PRIu64 " as %s\n",
|
|
intv.u64, bhnd_nvram_type_name(otype));
|
|
return (ERANGE);
|
|
}
|
|
|
|
/* Convert to signed representation */
|
|
intv.i64 = intv.u64;
|
|
}
|
|
|
|
/* Write output */
|
|
switch (otype) {
|
|
case BHND_NVRAM_TYPE_NULL:
|
|
/* Cannot encode an integer value as NULL */
|
|
return (EFTYPE);
|
|
|
|
case BHND_NVRAM_TYPE_BOOL: {
|
|
bhnd_nvram_bool_t bval;
|
|
|
|
if (intv.u64 == 0 || intv.u64 == 1) {
|
|
bval = intv.u64;
|
|
} else {
|
|
/* Encoding as a bool would lose information */
|
|
return (ERANGE);
|
|
}
|
|
|
|
nbytes = sizeof(bhnd_nvram_bool_t);
|
|
if (limit >= nbytes)
|
|
*((bhnd_nvram_bool_t *)outp) = bval;
|
|
|
|
break;
|
|
}
|
|
|
|
case BHND_NVRAM_TYPE_CHAR:
|
|
case BHND_NVRAM_TYPE_CHAR_ARRAY:
|
|
case BHND_NVRAM_TYPE_DATA:
|
|
case BHND_NVRAM_TYPE_UINT8:
|
|
case BHND_NVRAM_TYPE_UINT8_ARRAY:
|
|
if (intv.u64 > UINT8_MAX)
|
|
return (ERANGE);
|
|
|
|
nbytes = sizeof(uint8_t);
|
|
if (limit >= nbytes)
|
|
*((uint8_t *)outp) = (uint8_t)intv.u64;
|
|
break;
|
|
|
|
case BHND_NVRAM_TYPE_UINT16:
|
|
case BHND_NVRAM_TYPE_UINT16_ARRAY:
|
|
if (intv.u64 > UINT16_MAX)
|
|
return (ERANGE);
|
|
|
|
nbytes = sizeof(uint16_t);
|
|
if (limit >= nbytes)
|
|
*((uint16_t *)outp) = (uint16_t)intv.u64;
|
|
break;
|
|
|
|
case BHND_NVRAM_TYPE_UINT32:
|
|
case BHND_NVRAM_TYPE_UINT32_ARRAY:
|
|
if (intv.u64 > UINT32_MAX)
|
|
return (ERANGE);
|
|
|
|
nbytes = sizeof(uint32_t);
|
|
if (limit >= nbytes)
|
|
*((uint32_t *)outp) = (uint32_t)intv.u64;
|
|
break;
|
|
|
|
case BHND_NVRAM_TYPE_UINT64:
|
|
case BHND_NVRAM_TYPE_UINT64_ARRAY:
|
|
nbytes = sizeof(uint64_t);
|
|
if (limit >= nbytes)
|
|
*((uint64_t *)outp) = intv.u64;
|
|
break;
|
|
|
|
case BHND_NVRAM_TYPE_INT8:
|
|
case BHND_NVRAM_TYPE_INT8_ARRAY:
|
|
if (intv.i64 < INT8_MIN || intv.i64 > INT8_MAX)
|
|
return (ERANGE);
|
|
|
|
nbytes = sizeof(int8_t);
|
|
if (limit >= nbytes)
|
|
*((int8_t *)outp) = (int8_t)intv.i64;
|
|
break;
|
|
|
|
case BHND_NVRAM_TYPE_INT16:
|
|
case BHND_NVRAM_TYPE_INT16_ARRAY:
|
|
if (intv.i64 < INT16_MIN || intv.i64 > INT16_MAX)
|
|
return (ERANGE);
|
|
|
|
nbytes = sizeof(int16_t);
|
|
if (limit >= nbytes)
|
|
*((int16_t *)outp) = (int16_t)intv.i64;
|
|
break;
|
|
|
|
case BHND_NVRAM_TYPE_INT32:
|
|
case BHND_NVRAM_TYPE_INT32_ARRAY:
|
|
if (intv.i64 < INT32_MIN || intv.i64 > INT32_MAX)
|
|
return (ERANGE);
|
|
|
|
nbytes = sizeof(int32_t);
|
|
if (limit >= nbytes)
|
|
*((int32_t *)outp) = (int32_t)intv.i64;
|
|
break;
|
|
|
|
case BHND_NVRAM_TYPE_INT64:
|
|
case BHND_NVRAM_TYPE_INT64_ARRAY:
|
|
nbytes = sizeof(int64_t);
|
|
if (limit >= nbytes)
|
|
*((int64_t *)outp) = intv.i64;
|
|
break;
|
|
|
|
case BHND_NVRAM_TYPE_STRING:
|
|
case BHND_NVRAM_TYPE_STRING_ARRAY: {
|
|
ssize_t len;
|
|
|
|
/* Attempt to write the entry + NUL */
|
|
if (otype_signed) {
|
|
len = snprintf(outp, limit, "%" PRId64, intv.i64);
|
|
} else {
|
|
len = snprintf(outp, limit, "%" PRIu64, intv.u64);
|
|
}
|
|
|
|
if (len < 0) {
|
|
BHND_NV_LOG("snprintf() failed: %zd\n", len);
|
|
return (EFTYPE);
|
|
}
|
|
|
|
/* Set total length to the formatted string length, plus
|
|
* trailing NUL */
|
|
nbytes = len + 1;
|
|
break;
|
|
}
|
|
|
|
default:
|
|
BHND_NV_LOG("unknown type %s\n", bhnd_nvram_type_name(otype));
|
|
return (EFTYPE);
|
|
}
|
|
|
|
/* Provide required length */
|
|
*olen = nbytes;
|
|
if (limit < *olen) {
|
|
if (outp == NULL)
|
|
return (0);
|
|
|
|
return (ENOMEM);
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
/**
|
|
* Encode the given @p value as @p otype, writing the result to @p outp.
|
|
*
|
|
* @param value The value to be encoded.
|
|
* @param[out] outp On success, the value will be written to this
|
|
* buffer. This argment may be NULL if the value is
|
|
* not desired.
|
|
* @param[in,out] olen The capacity of @p outp. On success, will be set
|
|
* to the actual size of the requested value.
|
|
* @param otype The data type to be written to @p outp.
|
|
*
|
|
* @retval 0 success
|
|
* @retval ENOMEM If the @p outp is non-NULL, and the provided @p olen
|
|
* is too small to hold the encoded value.
|
|
* @retval EFTYPE If value coercion from @p value to @p otype is
|
|
* impossible.
|
|
* @retval ERANGE If value coercion would overflow (or underflow) the
|
|
* a @p otype representation.
|
|
*/
|
|
int
|
|
bhnd_nvram_val_encode(bhnd_nvram_val *value, void *outp, size_t *olen,
|
|
bhnd_nvram_type otype)
|
|
{
|
|
/* Prefer format implementation */
|
|
if (value->fmt->op_encode != NULL)
|
|
return (value->fmt->op_encode(value, outp, olen, otype));
|
|
|
|
return (bhnd_nvram_val_generic_encode(value, outp, olen, otype));
|
|
}
|
|
|
|
/**
|
|
* Encode the given @p value's element as @p otype, writing the result to
|
|
* @p outp.
|
|
*
|
|
* @param inp The element to be be encoded. Must be a value
|
|
* previously returned by bhnd_nvram_val_next()
|
|
* or bhnd_nvram_val_elem().
|
|
* @param ilen The size of @p inp, as returned by
|
|
* bhnd_nvram_val_next() or bhnd_nvram_val_elem().
|
|
* @param[out] outp On success, the value will be written to this
|
|
* buffer. This argment may be NULL if the value is
|
|
* not desired.
|
|
* @param[in,out] olen The capacity of @p outp. On success, will be set
|
|
* to the actual size of the requested value.
|
|
* @param otype The data type to be written to @p outp.
|
|
*
|
|
* @retval 0 success
|
|
* @retval ENOMEM If the @p outp is non-NULL, and the provided @p olen
|
|
* is too small to hold the encoded value.
|
|
* @retval EFTYPE If value coercion from @p value to @p otype is
|
|
* impossible.
|
|
* @retval ERANGE If value coercion would overflow (or underflow) the
|
|
* a @p otype representation.
|
|
*/
|
|
int
|
|
bhnd_nvram_val_encode_elem(bhnd_nvram_val *value, const void *inp,
|
|
size_t ilen, void *outp, size_t *olen, bhnd_nvram_type otype)
|
|
{
|
|
/* Prefer format implementation */
|
|
if (value->fmt->op_encode_elem != NULL) {
|
|
return (value->fmt->op_encode_elem(value, inp, ilen, outp,
|
|
olen, otype));
|
|
}
|
|
|
|
return (bhnd_nvram_val_generic_encode_elem(value, inp, ilen, outp,
|
|
olen, otype));
|
|
}
|
|
|
|
/**
|
|
* Return the type, size, and a pointer to the internal representation
|
|
* of @p value.
|
|
*
|
|
* @param value The value to be queried.
|
|
* @param[out] olen Size of the returned data, in bytes.
|
|
* @param[out] otype Data type.
|
|
*/
|
|
const void *
|
|
bhnd_nvram_val_bytes(bhnd_nvram_val *value, size_t *olen,
|
|
bhnd_nvram_type *otype)
|
|
{
|
|
/* Provide type and length */
|
|
*otype = value->data_type;
|
|
*olen = value->data_len;
|
|
|
|
switch (value->data_storage) {
|
|
case BHND_NVRAM_VAL_DATA_EXT_ALLOC:
|
|
case BHND_NVRAM_VAL_DATA_EXT_STATIC:
|
|
case BHND_NVRAM_VAL_DATA_EXT_WEAK:
|
|
/* Return a pointer to external storage */
|
|
return (value->data.ptr);
|
|
|
|
case BHND_NVRAM_VAL_DATA_INLINE:
|
|
/* Return a pointer to inline storage */
|
|
return (&value->data);
|
|
|
|
case BHND_NVRAM_VAL_DATA_NONE:
|
|
BHND_NV_PANIC("uninitialized value");
|
|
}
|
|
|
|
BHND_NV_PANIC("unknown storage type: %d", value->data_storage);
|
|
}
|
|
|
|
/**
|
|
* Iterate over all array elements in @p value.
|
|
*
|
|
* @param value The value to be iterated
|
|
* @param prev A value pointer previously returned by
|
|
* bhnd_nvram_val_next() or bhnd_nvram_val_elem(),
|
|
* or NULL to begin iteration at the first element.
|
|
* @param[in,out] olen If @p prev is non-NULL, @p olen must be a
|
|
* pointer to the length previously returned by
|
|
* bhnd_nvram_val_next() or bhnd_nvram_val_elem().
|
|
* On success, will be set to the next element's
|
|
* length, in bytes.
|
|
*
|
|
* @retval non-NULL A borrowed reference to the element data.
|
|
* @retval NULL If the end of the element array is reached.
|
|
*/
|
|
const void *
|
|
bhnd_nvram_val_next(bhnd_nvram_val *value, const void *prev, size_t *olen)
|
|
{
|
|
/* Prefer the format implementation */
|
|
if (value->fmt->op_next != NULL)
|
|
return (value->fmt->op_next(value, prev, olen));
|
|
|
|
return (bhnd_nvram_val_generic_next(value, prev, olen));
|
|
}
|
|
|
|
/**
|
|
* Return the value's data type.
|
|
*
|
|
* @param value The value to be queried.
|
|
*/
|
|
bhnd_nvram_type
|
|
bhnd_nvram_val_type(bhnd_nvram_val *value)
|
|
{
|
|
return (value->data_type);
|
|
}
|
|
|
|
/**
|
|
* Return value's element data type.
|
|
*
|
|
* @param value The value to be queried.
|
|
*/
|
|
bhnd_nvram_type
|
|
bhnd_nvram_val_elem_type(bhnd_nvram_val *value)
|
|
{
|
|
return (bhnd_nvram_base_type(value->data_type));
|
|
}
|
|
|
|
/**
|
|
* Return the total number of elements represented by @p value.
|
|
*/
|
|
size_t
|
|
bhnd_nvram_val_nelem(bhnd_nvram_val *value)
|
|
{
|
|
const void *bytes;
|
|
bhnd_nvram_type type;
|
|
size_t nelem, len;
|
|
int error;
|
|
|
|
/* Prefer format implementation */
|
|
if (value->fmt->op_nelem != NULL)
|
|
return (value->fmt->op_nelem(value));
|
|
|
|
/*
|
|
* If a custom op_next() is defined, bhnd_nvram_value_nelem() almost
|
|
* certainly cannot produce a valid element count; it assumes a standard
|
|
* data format that may not apply when custom iteration is required.
|
|
*
|
|
* Instead, use bhnd_nvram_val_next() to parse the backing data and
|
|
* produce a total count.
|
|
*/
|
|
if (value->fmt->op_next != NULL) {
|
|
const void *next;
|
|
|
|
next = NULL;
|
|
nelem = 0;
|
|
while ((next = bhnd_nvram_val_next(value, next, &len)) != NULL)
|
|
nelem++;
|
|
|
|
return (nelem);
|
|
}
|
|
|
|
/* Otherwise, compute the standard element count */
|
|
bytes = bhnd_nvram_val_bytes(value, &len, &type);
|
|
if ((error = bhnd_nvram_value_nelem(bytes, len, type, &nelem))) {
|
|
/* Should always succeed */
|
|
BHND_NV_PANIC("error calculating element count for type '%s' "
|
|
"with length %zu: %d\n", bhnd_nvram_type_name(type), len,
|
|
error);
|
|
}
|
|
|
|
return (nelem);
|
|
}
|
|
|
|
/**
|
|
* Generic implementation of bhnd_nvram_val_op_encode(), compatible with
|
|
* all supported NVRAM data types.
|
|
*/
|
|
int
|
|
bhnd_nvram_val_generic_encode(bhnd_nvram_val *value, void *outp, size_t *olen,
|
|
bhnd_nvram_type otype)
|
|
{
|
|
const void *inp;
|
|
bhnd_nvram_type itype;
|
|
size_t ilen;
|
|
const void *next;
|
|
bhnd_nvram_type otype_base;
|
|
size_t limit, nelem, nbytes;
|
|
size_t next_len;
|
|
int error;
|
|
|
|
nbytes = 0;
|
|
nelem = 0;
|
|
otype_base = bhnd_nvram_base_type(otype);
|
|
inp = bhnd_nvram_val_bytes(value, &ilen, &itype);
|
|
|
|
/*
|
|
* Normally, an array type is not universally representable as
|
|
* non-array type.
|
|
*
|
|
* As exceptions, we support conversion directly to/from:
|
|
* - CHAR_ARRAY/STRING:
|
|
* ->STRING Interpret the character array as a
|
|
* non-NUL-terminated string.
|
|
* ->CHAR_ARRAY Trim the trailing NUL from the string.
|
|
*/
|
|
#define BHND_NV_IS_ISO_CONV(_lhs, _rhs) \
|
|
((itype == BHND_NVRAM_TYPE_ ## _lhs && \
|
|
otype == BHND_NVRAM_TYPE_ ## _rhs) || \
|
|
(itype == BHND_NVRAM_TYPE_ ## _rhs && \
|
|
otype == BHND_NVRAM_TYPE_ ## _lhs))
|
|
|
|
if (BHND_NV_IS_ISO_CONV(CHAR_ARRAY, STRING)) {
|
|
return (bhnd_nvram_val_encode_elem(value, inp, ilen, outp, olen,
|
|
otype));
|
|
}
|
|
|
|
#undef BHND_NV_IS_ISO_CONV
|
|
|
|
/*
|
|
* If both input and output are non-array types, try to encode them
|
|
* without performing element iteration.
|
|
*/
|
|
if (!bhnd_nvram_is_array_type(itype) &&
|
|
!bhnd_nvram_is_array_type(otype))
|
|
{
|
|
return (bhnd_nvram_val_encode_elem(value, inp, ilen, outp, olen,
|
|
otype));
|
|
}
|
|
|
|
/* Determine output byte limit */
|
|
if (outp != NULL)
|
|
limit = *olen;
|
|
else
|
|
limit = 0;
|
|
|
|
/* Iterate over our array elements and encode as the requested
|
|
* type */
|
|
next = NULL;
|
|
while ((next = bhnd_nvram_val_next(value, next, &next_len))) {
|
|
void *elem_outp;
|
|
size_t elem_nbytes;
|
|
|
|
/* If the output type is not an array type, we can only encode
|
|
* one element */
|
|
nelem++;
|
|
if (nelem > 1 && !bhnd_nvram_is_array_type(otype)) {
|
|
return (EFTYPE);
|
|
}
|
|
|
|
/* Determine output offset / limit */
|
|
if (nbytes >= limit) {
|
|
elem_nbytes = 0;
|
|
elem_outp = NULL;
|
|
} else {
|
|
elem_nbytes = limit - nbytes;
|
|
elem_outp = (uint8_t *)outp + nbytes;
|
|
}
|
|
|
|
/* Attempt encode */
|
|
error = bhnd_nvram_val_encode_elem(value, next, next_len,
|
|
elem_outp, &elem_nbytes, otype_base);
|
|
|
|
/* If encoding failed for any reason other than ENOMEM (which
|
|
* we'll detect and report below), return immediately */
|
|
if (error && error != ENOMEM)
|
|
return (error);
|
|
|
|
/* Add to total length */
|
|
if (SIZE_MAX - nbytes < elem_nbytes)
|
|
return (EFTYPE); /* would overflow size_t */
|
|
|
|
nbytes += elem_nbytes;
|
|
}
|
|
|
|
/* Provide the actual length */
|
|
*olen = nbytes;
|
|
|
|
/* If no output was requested, nothing left to do */
|
|
if (outp == NULL)
|
|
return (0);
|
|
|
|
/* Otherwise, report a memory error if the output buffer was too
|
|
* small */
|
|
if (limit < nbytes)
|
|
return (ENOMEM);
|
|
|
|
return (0);
|
|
}
|
|
|
|
/**
|
|
* Generic implementation of bhnd_nvram_val_op_encode_elem(), compatible with
|
|
* all supported NVRAM data types.
|
|
*/
|
|
int
|
|
bhnd_nvram_val_generic_encode_elem(bhnd_nvram_val *value, const void *inp,
|
|
size_t ilen, void *outp, size_t *olen, bhnd_nvram_type otype)
|
|
{
|
|
bhnd_nvram_type itype;
|
|
|
|
itype = bhnd_nvram_val_elem_type(value);
|
|
switch (itype) {
|
|
case BHND_NVRAM_TYPE_NULL:
|
|
return (bhnd_nvram_val_encode_null(inp, ilen, itype, outp, olen,
|
|
otype));
|
|
|
|
case BHND_NVRAM_TYPE_DATA:
|
|
return (bhnd_nvram_val_encode_data(inp, ilen, itype, outp,
|
|
olen, otype));
|
|
|
|
case BHND_NVRAM_TYPE_STRING:
|
|
case BHND_NVRAM_TYPE_CHAR:
|
|
return (bhnd_nvram_val_encode_string(inp, ilen, itype, outp,
|
|
olen, otype));
|
|
|
|
case BHND_NVRAM_TYPE_BOOL:
|
|
return (bhnd_nvram_val_encode_bool(inp, ilen, itype, outp, olen,
|
|
otype));
|
|
|
|
case BHND_NVRAM_TYPE_UINT8:
|
|
case BHND_NVRAM_TYPE_UINT16:
|
|
case BHND_NVRAM_TYPE_UINT32:
|
|
case BHND_NVRAM_TYPE_UINT64:
|
|
case BHND_NVRAM_TYPE_INT8:
|
|
case BHND_NVRAM_TYPE_INT16:
|
|
case BHND_NVRAM_TYPE_INT32:
|
|
case BHND_NVRAM_TYPE_INT64:
|
|
return (bhnd_nvram_val_encode_int(inp, ilen, itype, outp, olen,
|
|
otype));
|
|
default:
|
|
BHND_NV_PANIC("missing encode_elem() implementation");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Generic implementation of bhnd_nvram_val_op_next(), compatible with
|
|
* all supported NVRAM data types.
|
|
*/
|
|
const void *
|
|
bhnd_nvram_val_generic_next(bhnd_nvram_val *value, const void *prev,
|
|
size_t *olen)
|
|
{
|
|
const uint8_t *inp;
|
|
bhnd_nvram_type itype;
|
|
size_t ilen;
|
|
|
|
/* Iterate over the backing representation */
|
|
inp = bhnd_nvram_val_bytes(value, &ilen, &itype);
|
|
return (bhnd_nvram_value_array_next(inp, ilen, itype, prev, olen));
|
|
}
|
|
|
|
/**
|
|
* Initialize the representation of @p value with @p ptr.
|
|
*
|
|
* @param value The value to be initialized.
|
|
* @param inp The external representation.
|
|
* @param ilen The external representation length, in bytes.
|
|
* @param itype The external representation's data type.
|
|
* @param flags Value flags.
|
|
*
|
|
* @retval 0 success.
|
|
* @retval ENOMEM if allocation fails
|
|
* @retval EFTYPE if @p itype is not an array type, and @p ilen is not
|
|
* equal to the size of a single element of @p itype.
|
|
* @retval EFAULT if @p ilen is not correctly aligned for elements of
|
|
* @p itype.
|
|
*/
|
|
static int
|
|
bhnd_nvram_val_set(bhnd_nvram_val *value, const void *inp, size_t ilen,
|
|
bhnd_nvram_type itype, uint32_t flags)
|
|
{
|
|
void *bytes;
|
|
int error;
|
|
|
|
BHND_NVRAM_VAL_ASSERT_EMPTY(value);
|
|
|
|
/* Validate alignment */
|
|
if ((error = bhnd_nvram_value_check_aligned(inp, ilen, itype)))
|
|
return (error);
|
|
|
|
/* Reference the external data */
|
|
if ((flags & BHND_NVRAM_VAL_BORROW_DATA) ||
|
|
(flags & BHND_NVRAM_VAL_STATIC_DATA))
|
|
{
|
|
if (flags & BHND_NVRAM_VAL_STATIC_DATA)
|
|
value->data_storage = BHND_NVRAM_VAL_DATA_EXT_STATIC;
|
|
else
|
|
value->data_storage = BHND_NVRAM_VAL_DATA_EXT_WEAK;
|
|
|
|
value->data.ptr = inp;
|
|
value->data_type = itype;
|
|
value->data_len = ilen;
|
|
return (0);
|
|
}
|
|
|
|
/* Fetch reference to (or allocate) an appropriately sized buffer */
|
|
bytes = bhnd_nvram_val_alloc_bytes(value, ilen, itype, flags);
|
|
if (bytes == NULL)
|
|
return (ENOMEM);
|
|
|
|
/* Copy data */
|
|
memcpy(bytes, inp, ilen);
|
|
|
|
return (0);
|
|
}
|
|
|
|
/**
|
|
* Initialize the internal inline representation of @p value with a copy of
|
|
* the data referenced by @p inp of @p itype.
|
|
*
|
|
* If @p inp is NULL, @p itype and @p ilen will be validated, but no data will
|
|
* be copied.
|
|
*
|
|
* @param value The value to be initialized.
|
|
* @param inp The input data to be copied, or NULL to verify
|
|
* that data of @p ilen and @p itype can be represented
|
|
* inline.
|
|
* @param ilen The size of the external buffer to be allocated.
|
|
* @param itype The type of the external buffer to be allocated.
|
|
*
|
|
* @retval 0 success
|
|
* @retval ENOMEM if @p ilen is too large to be represented inline.
|
|
* @retval EFAULT if @p ilen is not correctly aligned for elements of
|
|
* @p itype.
|
|
*/
|
|
static int
|
|
bhnd_nvram_val_set_inline(bhnd_nvram_val *value, const void *inp, size_t ilen,
|
|
bhnd_nvram_type itype)
|
|
{
|
|
BHND_NVRAM_VAL_ASSERT_EMPTY(value);
|
|
|
|
#define NV_STORE_INIT_INLINE() do { \
|
|
value->data_len = ilen; \
|
|
value->data_type = itype; \
|
|
} while(0)
|
|
|
|
#define NV_STORE_INLINE(_type, _dest) do { \
|
|
if (ilen != sizeof(_type)) \
|
|
return (EFAULT); \
|
|
\
|
|
if (inp != NULL) { \
|
|
value->data._dest[0] = *(const _type *)inp; \
|
|
NV_STORE_INIT_INLINE(); \
|
|
} \
|
|
} while (0)
|
|
|
|
#define NV_COPY_ARRRAY_INLINE(_type, _dest) do { \
|
|
if (ilen % sizeof(_type) != 0) \
|
|
return (EFAULT); \
|
|
\
|
|
if (ilen > nitems(value->data. _dest)) \
|
|
return (ENOMEM); \
|
|
\
|
|
if (inp == NULL) \
|
|
return (0); \
|
|
\
|
|
memcpy(&value->data._dest, inp, ilen); \
|
|
if (inp != NULL) { \
|
|
memcpy(&value->data._dest, inp, ilen); \
|
|
NV_STORE_INIT_INLINE(); \
|
|
} \
|
|
} while (0)
|
|
|
|
/* Attempt to copy to inline storage */
|
|
switch (itype) {
|
|
case BHND_NVRAM_TYPE_NULL:
|
|
if (ilen != 0)
|
|
return (EFAULT);
|
|
|
|
/* Nothing to copy */
|
|
NV_STORE_INIT_INLINE();
|
|
return (0);
|
|
|
|
case BHND_NVRAM_TYPE_CHAR:
|
|
NV_STORE_INLINE(uint8_t, ch);
|
|
return (0);
|
|
|
|
case BHND_NVRAM_TYPE_BOOL:
|
|
NV_STORE_INLINE(bhnd_nvram_bool_t, b);
|
|
return(0);
|
|
|
|
case BHND_NVRAM_TYPE_UINT8:
|
|
case BHND_NVRAM_TYPE_INT8:
|
|
NV_STORE_INLINE(uint8_t, u8);
|
|
return (0);
|
|
|
|
case BHND_NVRAM_TYPE_UINT16:
|
|
case BHND_NVRAM_TYPE_INT16:
|
|
NV_STORE_INLINE(uint16_t, u16);
|
|
return (0);
|
|
|
|
case BHND_NVRAM_TYPE_UINT32:
|
|
case BHND_NVRAM_TYPE_INT32:
|
|
NV_STORE_INLINE(uint32_t, u32);
|
|
return (0);
|
|
|
|
case BHND_NVRAM_TYPE_UINT64:
|
|
case BHND_NVRAM_TYPE_INT64:
|
|
NV_STORE_INLINE(uint32_t, u32);
|
|
return (0);
|
|
|
|
case BHND_NVRAM_TYPE_CHAR_ARRAY:
|
|
NV_COPY_ARRRAY_INLINE(uint8_t, ch);
|
|
return (0);
|
|
|
|
case BHND_NVRAM_TYPE_DATA:
|
|
case BHND_NVRAM_TYPE_UINT8_ARRAY:
|
|
case BHND_NVRAM_TYPE_INT8_ARRAY:
|
|
NV_COPY_ARRRAY_INLINE(uint8_t, u8);
|
|
return (0);
|
|
|
|
case BHND_NVRAM_TYPE_UINT16_ARRAY:
|
|
case BHND_NVRAM_TYPE_INT16_ARRAY:
|
|
NV_COPY_ARRRAY_INLINE(uint16_t, u16);
|
|
return (0);
|
|
|
|
case BHND_NVRAM_TYPE_UINT32_ARRAY:
|
|
case BHND_NVRAM_TYPE_INT32_ARRAY:
|
|
NV_COPY_ARRRAY_INLINE(uint32_t, u32);
|
|
return (0);
|
|
|
|
case BHND_NVRAM_TYPE_UINT64_ARRAY:
|
|
case BHND_NVRAM_TYPE_INT64_ARRAY:
|
|
NV_COPY_ARRRAY_INLINE(uint64_t, u64);
|
|
return (0);
|
|
|
|
case BHND_NVRAM_TYPE_BOOL_ARRAY:
|
|
NV_COPY_ARRRAY_INLINE(bhnd_nvram_bool_t, b);
|
|
return(0);
|
|
|
|
case BHND_NVRAM_TYPE_STRING:
|
|
case BHND_NVRAM_TYPE_STRING_ARRAY:
|
|
if (ilen > sizeof(value->data.ch))
|
|
return (ENOMEM);
|
|
|
|
if (inp != NULL) {
|
|
memcpy(&value->data.ch, inp, ilen);
|
|
NV_STORE_INIT_INLINE();
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
#undef NV_STORE_INIT_INLINE
|
|
#undef NV_STORE_INLINE
|
|
#undef NV_COPY_ARRRAY_INLINE
|
|
|
|
BHND_NV_PANIC("unknown data type %d", itype);
|
|
}
|
|
|
|
/**
|
|
* Initialize the internal representation of @p value with a buffer allocation
|
|
* of @p len and @p itype, returning a pointer to the allocated buffer.
|
|
*
|
|
* If a buffer of @p len and @p itype can be represented inline, no
|
|
* external buffer will be allocated, and instead a pointer to the inline
|
|
* data representation will be returned.
|
|
*
|
|
* @param value The value to be initialized.
|
|
* @param ilen The size of the external buffer to be allocated.
|
|
* @param itype The type of the external buffer to be allocated.
|
|
* @param flags Value flags.
|
|
*
|
|
* @retval non-null The newly allocated buffer.
|
|
* @retval NULL If allocation failed.
|
|
* @retval NULL If @p value is an externally allocated instance.
|
|
*/
|
|
static void *
|
|
bhnd_nvram_val_alloc_bytes(bhnd_nvram_val *value, size_t ilen,
|
|
bhnd_nvram_type itype, uint32_t flags)
|
|
{
|
|
void *ptr;
|
|
|
|
BHND_NVRAM_VAL_ASSERT_EMPTY(value);
|
|
|
|
/* Can we use inline storage? */
|
|
if (bhnd_nvram_val_set_inline(value, NULL, ilen, itype) == 0) {
|
|
BHND_NV_ASSERT(sizeof(value->data) >= ilen,
|
|
("ilen exceeds inline storage"));
|
|
|
|
value->data_type = itype;
|
|
value->data_len = ilen;
|
|
value->data_storage = BHND_NVRAM_VAL_DATA_INLINE;
|
|
return (&value->data);
|
|
}
|
|
|
|
/* Is allocation permitted? */
|
|
if (!(flags & BHND_NVRAM_VAL_DYNAMIC))
|
|
return (NULL);
|
|
|
|
/* Allocate external storage */
|
|
if ((ptr = bhnd_nv_malloc(ilen)) == NULL)
|
|
return (NULL);
|
|
|
|
value->data.ptr = ptr;
|
|
value->data_len = ilen;
|
|
value->data_type = itype;
|
|
value->data_storage = BHND_NVRAM_VAL_DATA_EXT_ALLOC;
|
|
|
|
return (ptr);
|
|
}
|