static int
elem_setprop_lang(ses_plugin_t *sp, ses_node_t *np, ses2_diag_page_t page,
nvpair_t *nvp)
{
ses2_lang_ctl_impl_t *lip;
const char *name;
boolean_t v1;
uint64_t v64;
if ((lip = ses_plugin_ctlpage_lookup(sp, ses_node_snapshot(np),
page, 0, np, B_FALSE)) == NULL)
return (-1);
name = nvpair_name(nvp);
if (strcmp(name, SES_LANG_PROP_LANGCODE) == 0) {
(void) nvpair_value_uint64(nvp, &v64);
SCSI_WRITE16(&lip->slci_language_code, v64);
return (0);
}
(void) nvpair_value_boolean_value(nvp, &v1);
if (strcmp(name, SES_PROP_IDENT) == 0)
lip->slci_rqst_ident = v1;
else
ses_panic("Bad property %s", name);
return (0);
}
static int
elem_common_setprop_threshold(ses_plugin_t *sp, ses_node_t *np,
ses2_diag_page_t page, nvpair_t *nvp)
{
ses2_threshold_impl_t *tip;
const char *name;
uint64_t v;
ASSERT(page == SES2_DIAGPAGE_THRESHOLD_IO);
if ((tip = ses_plugin_ctlpage_lookup(sp, ses_node_snapshot(np),
page, 0, np, B_FALSE)) == NULL)
return (-1);
name = nvpair_name(nvp);
(void) nvpair_value_uint64(nvp, &v);
if (strcmp(name, SES_PROP_THRESH_CRIT_HI) == 0)
tip->sti_high_crit = v;
else if (strcmp(name, SES_PROP_THRESH_CRIT_LO) == 0)
tip->sti_low_crit = v;
else if (strcmp(name, SES_PROP_THRESH_WARN_HI) == 0)
tip->sti_high_warn = v;
else if (strcmp(name, SES_PROP_THRESH_WARN_LO) == 0)
tip->sti_low_warn = v;
else
ses_panic("Bad property %s", name);
return (0);
}
static int
elem_setprop_cooling(ses_plugin_t *sp, ses_node_t *np, ses2_diag_page_t page,
nvpair_t *nvp)
{
ses2_cooling_ctl_impl_t *cip;
const char *name;
boolean_t v1;
uint64_t v64;
if ((cip = ses_plugin_ctlpage_lookup(sp, ses_node_snapshot(np),
page, 0, np, B_FALSE)) == NULL)
return (-1);
name = nvpair_name(nvp);
if (strcmp(name, SES_COOLING_PROP_SPEED_CODE) == 0) {
(void) nvpair_value_uint64(nvp, &v64);
cip->scci_requested_speed_code = v64;
return (0);
}
(void) nvpair_value_boolean_value(nvp, &v1);
if (strcmp(name, SES_PROP_IDENT) == 0)
cip->scci_rqst_ident = v1;
else if (strcmp(name, SES_PROP_REQUESTED_ON) == 0)
cip->scci_rqst_on = v1;
else if (strcmp(name, SES_PROP_FAIL) == 0)
cip->scci_rqst_fail = v1;
else
ses_panic("Bad property %s", name);
return (0);
}
uint64_t
fnvpair_value_uint64(nvpair_t *nvp)
{
uint64_t rv;
VERIFY0(nvpair_value_uint64(nvp, &rv));
return (rv);
}
static void
get_disk_size(dm_descriptor_t media, char *name, uint64_t *size,
uint32_t *blocksize, int *error)
{
nvlist_t *attrs;
*size = 0;
*error = 0;
attrs = dm_get_attributes(media, error);
if (*error) {
handle_error("could not get media attributes from disk: %s",
name);
} else {
/* Try to get the number of accessible blocks */
nvpair_t *match = zjni_nvlist_walk_nvpair(
attrs, DM_NACCESSIBLE, DATA_TYPE_UINT64, NULL);
if (match == NULL || nvpair_value_uint64(match, size)) {
/* Disk is probably not labeled, get raw size instead */
match = zjni_nvlist_walk_nvpair(
attrs, DM_SIZE, DATA_TYPE_UINT64, NULL);
if (match == NULL || nvpair_value_uint64(match, size)) {
handle_error("could not get size of disk: %s",
name);
*error = 1;
}
}
if (*error == 0) {
match = zjni_nvlist_walk_nvpair(
attrs, DM_BLOCKSIZE, DATA_TYPE_UINT32, NULL);
if (match == NULL ||
nvpair_value_uint32(match, blocksize)) {
handle_error("could not get "
"block size of disk: %s", name);
*error = 1;
} else {
*size *= *blocksize;
}
}
nvlist_free(attrs);
}
}
/*
* Use the supplied nvpair_t to set the name, type and value of the
* supplied pool_value_t.
*
* Return: PO_SUCCESS/PO_FAIL
*/
int
pool_value_from_nvpair(pool_value_t *pv, nvpair_t *pn)
{
uchar_t bval;
uint64_t uval;
int64_t ival;
double dval;
uint_t nelem;
uchar_t *dval_b;
char *sval;
if (pool_value_set_name(pv, nvpair_name(pn)) != PO_SUCCESS)
return (PO_FAIL);
switch (nvpair_type(pn)) {
case DATA_TYPE_BYTE:
if (nvpair_value_byte(pn, &bval) != 0) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
pool_value_set_bool(pv, bval);
break;
case DATA_TYPE_BYTE_ARRAY:
if (nvpair_value_byte_array(pn, &dval_b, &nelem) != 0) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
(void) memcpy(&dval, dval_b, sizeof (double));
pool_value_set_double(pv, dval);
break;
case DATA_TYPE_INT64:
if (nvpair_value_int64(pn, &ival) != 0) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
pool_value_set_int64(pv, ival);
break;
case DATA_TYPE_UINT64:
if (nvpair_value_uint64(pn, &uval) != 0) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
pool_value_set_uint64(pv, uval);
break;
case DATA_TYPE_STRING:
if (nvpair_value_string(pn, &sval) != 0) {
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
if (pool_value_set_string(pv, sval) != PO_SUCCESS)
return (PO_FAIL);
break;
default:
pool_seterror(POE_SYSTEM);
return (PO_FAIL);
}
return (PO_SUCCESS);
}
static PyObject *
nvl2py(nvlist_t *nvl)
{
PyObject *pyo;
nvpair_t *nvp;
pyo = PyDict_New();
for (nvp = nvlist_next_nvpair(nvl, NULL); nvp;
nvp = nvlist_next_nvpair(nvl, nvp)) {
PyObject *pyval;
char *sval;
uint64_t ival;
boolean_t bval;
nvlist_t *nval;
switch (nvpair_type(nvp)) {
case DATA_TYPE_STRING:
(void) nvpair_value_string(nvp, &sval);
pyval = Py_BuildValue("s", sval);
break;
case DATA_TYPE_UINT64:
(void) nvpair_value_uint64(nvp, &ival);
pyval = Py_BuildValue("K", ival);
break;
case DATA_TYPE_NVLIST:
(void) nvpair_value_nvlist(nvp, &nval);
pyval = nvl2py(nval);
break;
case DATA_TYPE_BOOLEAN:
Py_INCREF(Py_None);
pyval = Py_None;
break;
case DATA_TYPE_BOOLEAN_VALUE:
(void) nvpair_value_boolean_value(nvp, &bval);
pyval = Py_BuildValue("i", bval);
break;
default:
PyErr_SetNone(PyExc_ValueError);
Py_DECREF(pyo);
return (NULL);
}
PyDict_SetItemString(pyo, nvpair_name(nvp), pyval);
Py_DECREF(pyval);
}
return (pyo);
}
/*
* Lookup seq_num. We can not use the standard nvlist_lookup functions since
* the nvlist is not allocated with NV_UNIQUE_NAME or NV_UNIQUE_NAME_TYPE.
*/
static int
lookup_seq_num(nvlist_t *nvl, uint64_t *seq_num)
{
nvpair_t *nvp = NULL;
while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
if (strcmp(nvpair_name(nvp), RCM_SEQ_NUM) == 0 &&
nvpair_type(nvp) == DATA_TYPE_UINT64)
return (nvpair_value_uint64(nvp, seq_num));
}
return (ENOENT);
}
void
zpool_get_load_policy(nvlist_t *nvl, zpool_load_policy_t *zlpp)
{
nvlist_t *policy;
nvpair_t *elem;
char *nm;
/* Defaults */
zlpp->zlp_rewind = ZPOOL_NO_REWIND;
zlpp->zlp_maxmeta = 0;
zlpp->zlp_maxdata = UINT64_MAX;
zlpp->zlp_txg = UINT64_MAX;
if (nvl == NULL)
return;
elem = NULL;
while ((elem = nvlist_next_nvpair(nvl, elem)) != NULL) {
nm = nvpair_name(elem);
if (strcmp(nm, ZPOOL_LOAD_POLICY) == 0) {
if (nvpair_value_nvlist(elem, &policy) == 0)
zpool_get_load_policy(policy, zlpp);
return;
} else if (strcmp(nm, ZPOOL_LOAD_REWIND_POLICY) == 0) {
if (nvpair_value_uint32(elem, &zlpp->zlp_rewind) == 0)
if (zlpp->zlp_rewind & ~ZPOOL_REWIND_POLICIES)
zlpp->zlp_rewind = ZPOOL_NO_REWIND;
} else if (strcmp(nm, ZPOOL_LOAD_REQUEST_TXG) == 0) {
(void) nvpair_value_uint64(elem, &zlpp->zlp_txg);
} else if (strcmp(nm, ZPOOL_LOAD_META_THRESH) == 0) {
(void) nvpair_value_uint64(elem, &zlpp->zlp_maxmeta);
} else if (strcmp(nm, ZPOOL_LOAD_DATA_THRESH) == 0) {
(void) nvpair_value_uint64(elem, &zlpp->zlp_maxdata);
}
}
if (zlpp->zlp_rewind == 0)
zlpp->zlp_rewind = ZPOOL_NO_REWIND;
}
/*
* Get the named uint64 from the given nvlist_t.
*
* @param attrs
* the nvlist_t to search
*
* @param which
* the string key for this element in the list
*
* @param val
* RETURN: the value of the requested uint64
*
* @return 0
* if successful
*
* @return ENOENT
* if no matching name-value pair is found
*/
int
get_uint64(
nvlist_t *attrs,
char *which,
uint64_t *val)
{
int error;
nvpair_t *match =
nvlist_walk_nvpair(attrs, which, DATA_TYPE_UINT64, NULL);
if (match == NULL) {
error = ENOENT;
} else {
error = nvpair_value_uint64(match, val);
}
return (error);
}
static int
elem_setprop_display(ses_plugin_t *sp, ses_node_t *np, ses2_diag_page_t page,
nvpair_t *nvp)
{
ses2_display_ctl_impl_t *dip;
const char *name;
boolean_t v1;
uint16_t v16;
uint64_t v64;
if ((dip = ses_plugin_ctlpage_lookup(sp, ses_node_snapshot(np),
page, 0, np, B_FALSE)) == NULL)
return (-1);
name = nvpair_name(nvp);
if (strcmp(name, SES_DPY_PROP_MODE) == 0) {
(void) nvpair_value_uint64(nvp, &v64);
dip->sdci_display_mode = v64;
return (0);
} else if (strcmp(name, SES_DPY_PROP_CHAR) == 0) {
(void) nvpair_value_uint16(nvp, &v16);
SCSI_WRITE16(&dip->sdci_display_character, v16);
return (0);
}
(void) nvpair_value_boolean_value(nvp, &v1);
if (strcmp(name, SES_PROP_FAIL) == 0)
dip->sdci_rqst_fail = v1;
else if (strcmp(name, SES_PROP_IDENT) == 0)
dip->sdci_rqst_ident = v1;
else
ses_panic("Bad property %s", name);
return (0);
}
void
zfs_create_fs(objset_t *os, cred_t *cr, nvlist_t *zplprops, dmu_tx_t *tx)
{
struct super_block *sb;
zfs_sb_t *zsb;
uint64_t moid, obj, sa_obj, version;
uint64_t sense = ZFS_CASE_SENSITIVE;
uint64_t norm = 0;
nvpair_t *elem;
int error;
int i;
znode_t *rootzp = NULL;
vattr_t vattr;
znode_t *zp;
zfs_acl_ids_t acl_ids;
/*
* First attempt to create master node.
*/
/*
* In an empty objset, there are no blocks to read and thus
* there can be no i/o errors (which we assert below).
*/
moid = MASTER_NODE_OBJ;
error = zap_create_claim(os, moid, DMU_OT_MASTER_NODE,
DMU_OT_NONE, 0, tx);
ASSERT(error == 0);
/*
* Set starting attributes.
*/
version = zfs_zpl_version_map(spa_version(dmu_objset_spa(os)));
elem = NULL;
while ((elem = nvlist_next_nvpair(zplprops, elem)) != NULL) {
/* For the moment we expect all zpl props to be uint64_ts */
uint64_t val;
char *name;
ASSERT(nvpair_type(elem) == DATA_TYPE_UINT64);
VERIFY(nvpair_value_uint64(elem, &val) == 0);
name = nvpair_name(elem);
if (strcmp(name, zfs_prop_to_name(ZFS_PROP_VERSION)) == 0) {
if (val < version)
version = val;
} else {
error = zap_update(os, moid, name, 8, 1, &val, tx);
}
ASSERT(error == 0);
if (strcmp(name, zfs_prop_to_name(ZFS_PROP_NORMALIZE)) == 0)
norm = val;
else if (strcmp(name, zfs_prop_to_name(ZFS_PROP_CASE)) == 0)
sense = val;
}
ASSERT(version != 0);
error = zap_update(os, moid, ZPL_VERSION_STR, 8, 1, &version, tx);
/*
* Create zap object used for SA attribute registration
*/
if (version >= ZPL_VERSION_SA) {
sa_obj = zap_create(os, DMU_OT_SA_MASTER_NODE,
DMU_OT_NONE, 0, tx);
error = zap_add(os, moid, ZFS_SA_ATTRS, 8, 1, &sa_obj, tx);
ASSERT(error == 0);
} else {
sa_obj = 0;
}
/*
* Create a delete queue.
*/
obj = zap_create(os, DMU_OT_UNLINKED_SET, DMU_OT_NONE, 0, tx);
error = zap_add(os, moid, ZFS_UNLINKED_SET, 8, 1, &obj, tx);
ASSERT(error == 0);
/*
* Create root znode. Create minimal znode/inode/zsb/sb
* to allow zfs_mknode to work.
*/
vattr.va_mask = ATTR_MODE|ATTR_UID|ATTR_GID;
vattr.va_mode = S_IFDIR|0755;
vattr.va_uid = crgetuid(cr);
vattr.va_gid = crgetgid(cr);
rootzp = kmem_cache_alloc(znode_cache, KM_PUSHPAGE);
rootzp->z_moved = 0;
rootzp->z_unlinked = 0;
rootzp->z_atime_dirty = 0;
rootzp->z_is_sa = USE_SA(version, os);
zsb = kmem_zalloc(sizeof (zfs_sb_t), KM_PUSHPAGE | KM_NODEBUG);
zsb->z_os = os;
zsb->z_parent = zsb;
zsb->z_version = version;
zsb->z_use_fuids = USE_FUIDS(version, os);
zsb->z_use_sa = USE_SA(version, os);
zsb->z_norm = norm;
sb = kmem_zalloc(sizeof (struct super_block), KM_PUSHPAGE);
sb->s_fs_info = zsb;
ZTOI(rootzp)->i_sb = sb;
error = sa_setup(os, sa_obj, zfs_attr_table, ZPL_END,
&zsb->z_attr_table);
ASSERT(error == 0);
/*
* Fold case on file systems that are always or sometimes case
* insensitive.
*/
if (sense == ZFS_CASE_INSENSITIVE || sense == ZFS_CASE_MIXED)
zsb->z_norm |= U8_TEXTPREP_TOUPPER;
mutex_init(&zsb->z_znodes_lock, NULL, MUTEX_DEFAULT, NULL);
list_create(&zsb->z_all_znodes, sizeof (znode_t),
offsetof(znode_t, z_link_node));
for (i = 0; i != ZFS_OBJ_MTX_SZ; i++)
mutex_init(&zsb->z_hold_mtx[i], NULL, MUTEX_DEFAULT, NULL);
VERIFY(0 == zfs_acl_ids_create(rootzp, IS_ROOT_NODE, &vattr,
cr, NULL, &acl_ids));
zfs_mknode(rootzp, &vattr, tx, cr, IS_ROOT_NODE, &zp, &acl_ids);
ASSERT3P(zp, ==, rootzp);
error = zap_add(os, moid, ZFS_ROOT_OBJ, 8, 1, &rootzp->z_id, tx);
ASSERT(error == 0);
zfs_acl_ids_free(&acl_ids);
atomic_set(&ZTOI(rootzp)->i_count, 0);
sa_handle_destroy(rootzp->z_sa_hdl);
kmem_cache_free(znode_cache, rootzp);
/*
* Create shares directory
*/
error = zfs_create_share_dir(zsb, tx);
ASSERT(error == 0);
for (i = 0; i != ZFS_OBJ_MTX_SZ; i++)
mutex_destroy(&zsb->z_hold_mtx[i]);
kmem_free(sb, sizeof (struct super_block));
kmem_free(zsb, sizeof (zfs_sb_t));
}
static dmgt_slice_t *
get_slice(dm_descriptor_t slice, uint32_t blocksize, int *error)
{
dmgt_slice_t *sp;
*error = 0;
sp = (dmgt_slice_t *)calloc(1, sizeof (dmgt_slice_t));
if (sp == NULL) {
*error = -1;
handle_error("out of memory");
} else {
/* Get name */
sp->name = get_device_name(slice, error);
if (!*error) {
nvlist_t *attrs = dm_get_attributes(slice, error);
if (*error) {
handle_error("could not get "
"attributes from slice: %s", sp->name);
} else {
/* Get the size in blocks */
nvpair_t *match = zjni_nvlist_walk_nvpair(
attrs, DM_SIZE, DATA_TYPE_UINT64, NULL);
uint64_t size_blocks;
sp->size = 0;
if (match == NULL ||
nvpair_value_uint64(match, &size_blocks)) {
handle_error("could not get "
"size of slice: %s", sp->name);
*error = 1;
} else {
uint64_t start_blocks;
/* Convert to bytes */
sp->size = blocksize * size_blocks;
/* Get the starting block */
match = zjni_nvlist_walk_nvpair(
attrs, DM_START, DATA_TYPE_UINT64,
NULL);
if (match == NULL ||
nvpair_value_uint64(match,
&start_blocks)) {
handle_error(
"could not get "
"start block of slice: %s",
sp->name);
*error = 1;
} else {
/* Convert to bytes */
sp->start =
blocksize * start_blocks;
/* Set slice use */
get_slice_use(slice, sp->name,
&(sp->used_name),
&(sp->used_by), error);
}
}
}
}
}
if (*error && sp != NULL) {
dmgt_free_slice(sp);
}
return (sp);
}
/*
* Convert the nvpair [nvp] to a string which is added to the environment
* of the child process.
* Return 0 on success, -1 on error.
*
* FIXME: Refactor with cmd/zpool/zpool_main.c:zpool_do_events_nvprint()?
*/
static void
_zed_event_add_nvpair(uint64_t eid, zed_strings_t *zsp, nvpair_t *nvp)
{
const char *name;
data_type_t type;
char buf[4096];
int buflen;
int n;
char *p;
const char *q;
const char *fmt;
boolean_t b;
double d;
uint8_t i8;
uint16_t i16;
uint32_t i32;
uint64_t i64;
char *str;
assert(zsp != NULL);
assert(nvp != NULL);
name = nvpair_name(nvp);
type = nvpair_type(nvp);
buflen = sizeof (buf);
/* Copy NAME prefix for ZED zevent namespace. */
n = strlcpy(buf, ZEVENT_VAR_PREFIX, sizeof (buf));
if (n >= sizeof (buf)) {
zed_log_msg(LOG_WARNING,
"Failed to convert nvpair \"%s\" for eid=%llu: %s",
name, eid, "Exceeded buffer size");
return;
}
buflen -= n;
p = buf + n;
/* Convert NAME to alphanumeric uppercase. */
for (q = name; *q && (buflen > 0); q++) {
*p++ = isalnum(*q) ? toupper(*q) : '_';
buflen--;
}
/* Separate NAME from VALUE. */
if (buflen > 0) {
*p++ = '=';
buflen--;
}
*p = '\0';
/* Convert VALUE. */
switch (type) {
case DATA_TYPE_BOOLEAN:
n = snprintf(p, buflen, "%s", "1");
break;
case DATA_TYPE_BOOLEAN_VALUE:
(void) nvpair_value_boolean_value(nvp, &b);
n = snprintf(p, buflen, "%s", b ? "1" : "0");
break;
case DATA_TYPE_BYTE:
(void) nvpair_value_byte(nvp, &i8);
n = snprintf(p, buflen, "%d", i8);
break;
case DATA_TYPE_INT8:
(void) nvpair_value_int8(nvp, (int8_t *) &i8);
n = snprintf(p, buflen, "%d", i8);
break;
case DATA_TYPE_UINT8:
(void) nvpair_value_uint8(nvp, &i8);
n = snprintf(p, buflen, "%u", i8);
break;
case DATA_TYPE_INT16:
(void) nvpair_value_int16(nvp, (int16_t *) &i16);
n = snprintf(p, buflen, "%d", i16);
break;
case DATA_TYPE_UINT16:
(void) nvpair_value_uint16(nvp, &i16);
n = snprintf(p, buflen, "%u", i16);
break;
case DATA_TYPE_INT32:
(void) nvpair_value_int32(nvp, (int32_t *) &i32);
n = snprintf(p, buflen, "%d", i32);
break;
case DATA_TYPE_UINT32:
(void) nvpair_value_uint32(nvp, &i32);
n = snprintf(p, buflen, "%u", i32);
break;
case DATA_TYPE_INT64:
(void) nvpair_value_int64(nvp, (int64_t *) &i64);
n = snprintf(p, buflen, "%lld", (longlong_t) i64);
break;
case DATA_TYPE_UINT64:
(void) nvpair_value_uint64(nvp, &i64);
fmt = _zed_event_value_is_hex(name) ? "0x%.16llX" : "%llu";
n = snprintf(p, buflen, fmt, (u_longlong_t) i64);
break;
case DATA_TYPE_DOUBLE:
(void) nvpair_value_double(nvp, &d);
n = snprintf(p, buflen, "%g", d);
break;
case DATA_TYPE_HRTIME:
(void) nvpair_value_hrtime(nvp, (hrtime_t *) &i64);
n = snprintf(p, buflen, "%llu", (u_longlong_t) i64);
break;
case DATA_TYPE_NVLIST:
/* FIXME */
n = snprintf(p, buflen, "%s", "_NOT_IMPLEMENTED_");
break;
case DATA_TYPE_STRING:
(void) nvpair_value_string(nvp, &str);
n = snprintf(p, buflen, "%s", (str ? str : "<NULL>"));
break;
case DATA_TYPE_BOOLEAN_ARRAY:
/* FIXME */
n = snprintf(p, buflen, "%s", "_NOT_IMPLEMENTED_");
break;
case DATA_TYPE_BYTE_ARRAY:
/* FIXME */
n = snprintf(p, buflen, "%s", "_NOT_IMPLEMENTED_");
break;
case DATA_TYPE_INT8_ARRAY:
n = _zed_event_convert_int8_array(p, buflen, nvp);
break;
case DATA_TYPE_UINT8_ARRAY:
n = _zed_event_convert_uint8_array(p, buflen, nvp);
break;
case DATA_TYPE_INT16_ARRAY:
n = _zed_event_convert_int16_array(p, buflen, nvp);
break;
case DATA_TYPE_UINT16_ARRAY:
n = _zed_event_convert_uint16_array(p, buflen, nvp);
break;
case DATA_TYPE_INT32_ARRAY:
n = _zed_event_convert_int32_array(p, buflen, nvp);
break;
case DATA_TYPE_UINT32_ARRAY:
n = _zed_event_convert_uint32_array(p, buflen, nvp);
break;
case DATA_TYPE_INT64_ARRAY:
n = _zed_event_convert_int64_array(p, buflen, nvp);
break;
case DATA_TYPE_UINT64_ARRAY:
fmt = _zed_event_value_is_hex(name) ? "0x%.16llX " : "%llu ";
n = _zed_event_convert_uint64_array(p, buflen, nvp, fmt);
break;
case DATA_TYPE_STRING_ARRAY:
n = _zed_event_convert_string_array(p, buflen, nvp);
break;
case DATA_TYPE_NVLIST_ARRAY:
/* FIXME */
n = snprintf(p, buflen, "%s", "_NOT_IMPLEMENTED_");
break;
default:
zed_log_msg(LOG_WARNING,
"Failed to convert nvpair \"%s\" for eid=%llu: "
"Unrecognized type=%u", name, eid, (unsigned int) type);
return;
}
if ((n < 0) || (n >= sizeof (buf))) {
zed_log_msg(LOG_WARNING,
"Failed to convert nvpair \"%s\" for eid=%llu: %s",
name, eid, "Exceeded buffer size");
return;
}
if (zed_strings_add(zsp, buf) < 0) {
zed_log_msg(LOG_WARNING,
"Failed to convert nvpair \"%s\" for eid=%llu: %s",
name, eid, strerror(ENOMEM));
return;
}
}
/*
* Copy in a packed nvlist from the user and create a request set out of it.
* If successful, return 0 and store a pointer to the set we've created. Returns
* error code on error.
*/
int
kcpc_copyin_set(kcpc_set_t **inset, void *ubuf, size_t len)
{
kcpc_set_t *set;
int i;
int j;
char *packbuf;
nvlist_t *nvl;
nvpair_t *nvp = NULL;
nvlist_t *attrs;
nvpair_t *nvp_attr;
kcpc_attr_t *attrp;
nvlist_t **reqlist;
uint_t nreqs;
uint64_t uint64;
uint32_t uint32;
uint32_t setflags = (uint32_t)-1;
char *string;
char *name;
if (len < CPC_MIN_PACKSIZE || len > CPC_MAX_PACKSIZE)
return (EINVAL);
packbuf = kmem_alloc(len, KM_SLEEP);
if (copyin(ubuf, packbuf, len) == -1) {
kmem_free(packbuf, len);
return (EFAULT);
}
if (nvlist_unpack(packbuf, len, &nvl, KM_SLEEP) != 0) {
kmem_free(packbuf, len);
return (EINVAL);
}
/*
* The nvlist has been unpacked so there is no need for the packed
* representation from this point on.
*/
kmem_free(packbuf, len);
i = 0;
while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
switch (nvpair_type(nvp)) {
case DATA_TYPE_UINT32:
if (strcmp(nvpair_name(nvp), "flags") != 0 ||
nvpair_value_uint32(nvp, &setflags) != 0) {
nvlist_free(nvl);
return (EINVAL);
}
break;
case DATA_TYPE_NVLIST_ARRAY:
if (strcmp(nvpair_name(nvp), "reqs") != 0 ||
nvpair_value_nvlist_array(nvp, &reqlist,
&nreqs) != 0) {
nvlist_free(nvl);
return (EINVAL);
}
break;
default:
nvlist_free(nvl);
return (EINVAL);
}
i++;
}
/*
* There should be two members in the top-level nvlist:
* an array of nvlists consisting of the requests, and flags.
* Anything else is an invalid set.
*/
if (i != 2) {
nvlist_free(nvl);
return (EINVAL);
}
if (nreqs > CPC_MAX_NREQS) {
nvlist_free(nvl);
return (EINVAL);
}
/*
* The requests are now stored in the nvlist array at reqlist.
* Note that the use of kmem_zalloc() to alloc the kcpc_set_t means
* we don't need to call the init routines for ks_lock and ks_condv.
*/
set = kmem_zalloc(sizeof (kcpc_set_t), KM_SLEEP);
set->ks_req = (kcpc_request_t *)kmem_zalloc(sizeof (kcpc_request_t) *
nreqs, KM_SLEEP);
set->ks_nreqs = nreqs;
/*
* If the nvlist didn't contain a flags member, setflags was initialized
* with an illegal value and this set will fail sanity checks later on.
*/
set->ks_flags = setflags;
/*
* Initialize bind/unbind set synchronization.
*/
set->ks_state &= ~KCPC_SET_BOUND;
/*
* Build the set up one request at a time, always keeping it self-
* consistent so we can give it to kcpc_free_set() if we need to back
* out and return and error.
*/
for (i = 0; i < nreqs; i++) {
nvp = NULL;
set->ks_req[i].kr_picnum = -1;
while ((nvp = nvlist_next_nvpair(reqlist[i], nvp)) != NULL) {
name = nvpair_name(nvp);
switch (nvpair_type(nvp)) {
case DATA_TYPE_UINT32:
if (nvpair_value_uint32(nvp, &uint32) == EINVAL)
goto inval;
if (strcmp(name, "cr_flags") == 0)
set->ks_req[i].kr_flags = uint32;
if (strcmp(name, "cr_index") == 0)
set->ks_req[i].kr_index = uint32;
break;
case DATA_TYPE_UINT64:
if (nvpair_value_uint64(nvp, &uint64) == EINVAL)
goto inval;
if (strcmp(name, "cr_preset") == 0)
set->ks_req[i].kr_preset = uint64;
break;
case DATA_TYPE_STRING:
if (nvpair_value_string(nvp, &string) == EINVAL)
goto inval;
if (strcmp(name, "cr_event") == 0)
(void) strncpy(set->ks_req[i].kr_event,
string, CPC_MAX_EVENT_LEN);
break;
case DATA_TYPE_NVLIST:
if (strcmp(name, "cr_attr") != 0)
goto inval;
if (nvpair_value_nvlist(nvp, &attrs) == EINVAL)
goto inval;
nvp_attr = NULL;
/*
* If the picnum has been specified as an
* attribute, consume that attribute here and
* remove it from the list of attributes.
*/
if (nvlist_lookup_uint64(attrs, "picnum",
&uint64) == 0) {
if (nvlist_remove(attrs, "picnum",
DATA_TYPE_UINT64) != 0)
panic("nvlist %p faulty",
(void *)attrs);
set->ks_req[i].kr_picnum = uint64;
}
if ((set->ks_req[i].kr_nattrs =
kcpc_nvlist_npairs(attrs)) == 0)
break;
if (set->ks_req[i].kr_nattrs > CPC_MAX_ATTRS)
goto inval;
set->ks_req[i].kr_attr =
kmem_alloc(set->ks_req[i].kr_nattrs *
sizeof (kcpc_attr_t), KM_SLEEP);
j = 0;
while ((nvp_attr = nvlist_next_nvpair(attrs,
nvp_attr)) != NULL) {
attrp = &set->ks_req[i].kr_attr[j];
if (nvpair_type(nvp_attr) !=
DATA_TYPE_UINT64)
goto inval;
(void) strncpy(attrp->ka_name,
nvpair_name(nvp_attr),
CPC_MAX_ATTR_LEN);
if (nvpair_value_uint64(nvp_attr,
&(attrp->ka_val)) == EINVAL)
goto inval;
j++;
}
ASSERT(j == set->ks_req[i].kr_nattrs);
default:
break;
}
}
}
nvlist_free(nvl);
*inset = set;
return (0);
inval:
nvlist_free(nvl);
kcpc_free_set(set);
return (EINVAL);
}
static void
rcm_print_nvlist(nvlist_t *nvl)
{
uchar_t data_byte;
int16_t data_int16;
uint16_t data_uint16;
int32_t data_int32;
uint32_t data_uint32;
int64_t data_int64;
uint64_t data_uint64;
char *data_string;
char **data_strings;
uint_t data_nstrings;
nvpair_t *nvp = NULL;
int i;
char *name;
data_type_t type;
rcm_log_message(RCM_TRACE3, "event attributes:\n");
while (nvp = nvlist_next_nvpair(nvl, nvp)) {
type = nvpair_type(nvp);
name = nvpair_name(nvp);
rcm_log_message(RCM_TRACE3, "\t%s(%d)=", name, type);
switch (type) {
case DATA_TYPE_BOOLEAN:
rcm_log_message(RCM_TRACE3, "True (boolean)\n");
break;
case DATA_TYPE_BYTE:
(void) nvpair_value_byte(nvp, &data_byte);
rcm_log_message(RCM_TRACE3, "0x%x (byte)\n",
data_byte);
break;
case DATA_TYPE_INT16:
(void) nvpair_value_int16(nvp, &data_int16);
rcm_log_message(RCM_TRACE3, "0x%x (int16)\n",
data_int16);
break;
case DATA_TYPE_UINT16:
(void) nvpair_value_uint16(nvp, &data_uint16);
rcm_log_message(RCM_TRACE3, "0x%x (uint16)\n",
data_uint16);
break;
case DATA_TYPE_INT32:
(void) nvpair_value_int32(nvp, &data_int32);
rcm_log_message(RCM_TRACE3, "0x%x (int32)\n",
data_int32);
break;
case DATA_TYPE_UINT32:
(void) nvpair_value_uint32(nvp, &data_uint32);
rcm_log_message(RCM_TRACE3, "0x%x (uint32)\n",
data_uint32);
break;
case DATA_TYPE_INT64:
(void) nvpair_value_int64(nvp, &data_int64);
rcm_log_message(RCM_TRACE3, "0x%lx (int64)\n",
data_int64);
break;
case DATA_TYPE_UINT64:
(void) nvpair_value_uint64(nvp, &data_uint64);
rcm_log_message(RCM_TRACE3, "0x%lx (uint64)\n",
data_uint64);
break;
case DATA_TYPE_STRING:
(void) nvpair_value_string(nvp, &data_string);
rcm_log_message(RCM_TRACE3, "\"%s\" (string)\n",
data_string);
break;
case DATA_TYPE_STRING_ARRAY:
(void) nvpair_value_string_array(nvp, &data_strings,
&data_nstrings);
for (i = 0; i < data_nstrings; i++) {
rcm_log_message(RCM_TRACE3,
"\t\"%s\" (string)\n", data_strings[i]);
if (i < (data_nstrings - 1))
rcm_log_message(RCM_TRACE3, "\t\t\t");
}
break;
default:
rcm_log_message(RCM_TRACE3, "<not dumped>\n");
break;
}
}
}
static void
print_prop_nameval(topo_hdl_t *thp, tnode_t *node, nvlist_t *nvl)
{
int err;
topo_type_t type;
char *tstr, *propn, buf[48], *factype;
nvpair_t *pv_nvp;
int i;
uint_t nelem;
if ((pv_nvp = nvlist_next_nvpair(nvl, NULL)) == NULL)
return;
/* Print property name */
if ((pv_nvp = nvlist_next_nvpair(nvl, NULL)) == NULL ||
nvpair_name(pv_nvp) == NULL ||
strcmp(TOPO_PROP_VAL_NAME, nvpair_name(pv_nvp)) != 0) {
(void) fprintf(stderr, "%s: malformed property name\n",
g_pname);
return;
} else {
(void) nvpair_value_string(pv_nvp, &propn);
}
if ((pv_nvp = nvlist_next_nvpair(nvl, pv_nvp)) == NULL ||
nvpair_name(pv_nvp) == NULL ||
strcmp(nvpair_name(pv_nvp), TOPO_PROP_VAL_TYPE) != 0 ||
nvpair_type(pv_nvp) != DATA_TYPE_UINT32) {
(void) fprintf(stderr, "%s: malformed property type for %s\n",
g_pname, propn);
return;
} else {
(void) nvpair_value_uint32(pv_nvp, (uint32_t *)&type);
}
switch (type) {
case TOPO_TYPE_BOOLEAN: tstr = "boolean"; break;
case TOPO_TYPE_INT32: tstr = "int32"; break;
case TOPO_TYPE_UINT32: tstr = "uint32"; break;
case TOPO_TYPE_INT64: tstr = "int64"; break;
case TOPO_TYPE_UINT64: tstr = "uint64"; break;
case TOPO_TYPE_DOUBLE: tstr = "double"; break;
case TOPO_TYPE_STRING: tstr = "string"; break;
case TOPO_TYPE_FMRI: tstr = "fmri"; break;
case TOPO_TYPE_INT32_ARRAY: tstr = "int32[]"; break;
case TOPO_TYPE_UINT32_ARRAY: tstr = "uint32[]"; break;
case TOPO_TYPE_INT64_ARRAY: tstr = "int64[]"; break;
case TOPO_TYPE_UINT64_ARRAY: tstr = "uint64[]"; break;
case TOPO_TYPE_STRING_ARRAY: tstr = "string[]"; break;
case TOPO_TYPE_FMRI_ARRAY: tstr = "fmri[]"; break;
default: tstr = "unknown type";
}
(void) printf(" %-17s %-8s ", propn, tstr);
/*
* Get property value
*/
if (nvpair_name(pv_nvp) == NULL ||
(pv_nvp = nvlist_next_nvpair(nvl, pv_nvp)) == NULL) {
(void) fprintf(stderr, "%s: malformed property value\n",
g_pname);
return;
}
switch (nvpair_type(pv_nvp)) {
case DATA_TYPE_INT32: {
int32_t val;
(void) nvpair_value_int32(pv_nvp, &val);
(void) printf(" %d", val);
break;
}
case DATA_TYPE_UINT32: {
uint32_t val, type;
char val_str[49];
nvlist_t *fac, *rsrc = NULL;
(void) nvpair_value_uint32(pv_nvp, &val);
if (node == NULL || topo_node_flags(node) !=
TOPO_NODE_FACILITY)
goto uint32_def;
if (topo_node_resource(node, &rsrc, &err) != 0)
goto uint32_def;
if (nvlist_lookup_nvlist(rsrc, "facility", &fac) != 0)
goto uint32_def;
if (nvlist_lookup_string(fac, FM_FMRI_FACILITY_TYPE,
&factype) != 0)
goto uint32_def;
nvlist_free(rsrc);
rsrc = NULL;
/*
* Special case code to do friendlier printing of
* facility node properties
*/
if ((strcmp(propn, TOPO_FACILITY_TYPE) == 0) &&
(strcmp(factype, TOPO_FAC_TYPE_SENSOR) == 0)) {
topo_sensor_type_name(val, val_str, 48);
(void) printf(" 0x%x (%s)", val, val_str);
break;
} else if ((strcmp(propn, TOPO_FACILITY_TYPE) == 0) &&
(strcmp(factype, TOPO_FAC_TYPE_INDICATOR) == 0)) {
topo_led_type_name(val, val_str, 48);
(void) printf(" 0x%x (%s)", val, val_str);
break;
} else if (strcmp(propn, TOPO_SENSOR_UNITS) == 0) {
topo_sensor_units_name(val, val_str, 48);
(void) printf(" 0x%x (%s)", val, val_str);
break;
} else if (strcmp(propn, TOPO_LED_MODE) == 0) {
topo_led_state_name(val, val_str, 48);
(void) printf(" 0x%x (%s)", val, val_str);
break;
} else if ((strcmp(propn, TOPO_SENSOR_STATE) == 0) &&
(strcmp(factype, TOPO_FAC_TYPE_SENSOR) == 0)) {
if (topo_prop_get_uint32(node,
TOPO_PGROUP_FACILITY, TOPO_FACILITY_TYPE,
&type, &err) != 0) {
goto uint32_def;
}
topo_sensor_state_name(type, val, val_str, 48);
(void) printf(" 0x%x (%s)", val, val_str);
break;
}
uint32_def:
(void) printf(" 0x%x", val);
if (rsrc != NULL)
nvlist_free(rsrc);
break;
}
case DATA_TYPE_INT64: {
int64_t val;
(void) nvpair_value_int64(pv_nvp, &val);
(void) printf(" %lld", (longlong_t)val);
break;
}
case DATA_TYPE_UINT64: {
uint64_t val;
(void) nvpair_value_uint64(pv_nvp, &val);
(void) printf(" 0x%llx", (u_longlong_t)val);
break;
}
case DATA_TYPE_DOUBLE: {
double val;
(void) nvpair_value_double(pv_nvp, &val);
(void) printf(" %lf", (double)val);
break;
}
case DATA_TYPE_STRING: {
char *val;
(void) nvpair_value_string(pv_nvp, &val);
if (!opt_V && strlen(val) > 48) {
(void) snprintf(buf, 48, "%s...", val);
(void) printf(" %s", buf);
} else {
(void) printf(" %s", val);
}
break;
}
case DATA_TYPE_NVLIST: {
nvlist_t *val;
char *fmri;
(void) nvpair_value_nvlist(pv_nvp, &val);
if (topo_fmri_nvl2str(thp, val, &fmri, &err) != 0) {
if (opt_V)
nvlist_print(stdout, nvl);
break;
}
if (!opt_V && strlen(fmri) > 48) {
(void) snprintf(buf, 48, "%s", fmri);
(void) snprintf(&buf[45], 4, "%s", DOTS);
(void) printf(" %s", buf);
} else {
(void) printf(" %s", fmri);
}
topo_hdl_strfree(thp, fmri);
break;
}
case DATA_TYPE_INT32_ARRAY: {
int32_t *val;
(void) nvpair_value_int32_array(pv_nvp, &val, &nelem);
(void) printf(" [ ");
for (i = 0; i < nelem; i++)
(void) printf("%d ", val[i]);
(void) printf("]");
break;
}
case DATA_TYPE_UINT32_ARRAY: {
uint32_t *val;
(void) nvpair_value_uint32_array(pv_nvp, &val, &nelem);
(void) printf(" [ ");
for (i = 0; i < nelem; i++)
(void) printf("%u ", val[i]);
(void) printf("]");
break;
}
case DATA_TYPE_INT64_ARRAY: {
int64_t *val;
(void) nvpair_value_int64_array(pv_nvp, &val, &nelem);
(void) printf(" [ ");
for (i = 0; i < nelem; i++)
(void) printf("%lld ", val[i]);
(void) printf("]");
break;
}
case DATA_TYPE_UINT64_ARRAY: {
uint64_t *val;
(void) nvpair_value_uint64_array(pv_nvp, &val, &nelem);
(void) printf(" [ ");
for (i = 0; i < nelem; i++)
(void) printf("%llu ", val[i]);
(void) printf("]");
break;
}
case DATA_TYPE_STRING_ARRAY: {
char **val;
(void) nvpair_value_string_array(pv_nvp, &val, &nelem);
(void) printf(" [ ");
for (i = 0; i < nelem; i++)
(void) printf("\"%s\" ", val[i]);
(void) printf("]");
break;
}
default:
(void) fprintf(stderr, " unknown data type (%d)",
nvpair_type(pv_nvp));
break;
}
(void) printf("\n");
}
/*ARGSUSED*/
static int
net_notify_event(rcm_handle_t *hd, char *rsrc, id_t id, uint_t flags,
char **errorp, nvlist_t *nvl, rcm_info_t **depend_info)
{
nvpair_t *nvp = NULL;
uint64_t id64 = (uint64_t)DATALINK_INVALID_LINKID;
boolean_t reconfigured = B_FALSE;
rcm_log_message(RCM_TRACE1, _("NET: notify_event(%s)\n"), rsrc);
if (strcmp(rsrc, RCM_RESOURCE_PHYSLINK_NEW) != 0) {
rcm_log_message(RCM_INFO,
_("NET: unrecognized event for %s\n"), rsrc);
errno = EINVAL;
return (RCM_FAILURE);
}
/* Update cache to reflect latest physical links */
update_cache(hd);
while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
if (strcmp(nvpair_name(nvp), RCM_NV_RECONFIGURED) == 0) {
if (nvpair_value_boolean_value(nvp,
&reconfigured) != 0) {
rcm_log_message(RCM_INFO,
_("NET: unrecognized %s event data\n"),
RCM_NV_RECONFIGURED);
errno = EINVAL;
return (RCM_FAILURE);
}
rcm_log_message(RCM_TRACE1,
"NET: %s event data (%sreconfiguration)\n",
RCM_NV_RECONFIGURED, reconfigured ? "" : "not ");
}
if (strcmp(nvpair_name(nvp), RCM_NV_LINKID) == 0) {
if (nvpair_value_uint64(nvp, &id64) != 0) {
rcm_log_message(RCM_INFO,
_("NET: unrecognized %s event data\n"),
RCM_NV_LINKID);
errno = EINVAL;
return (RCM_FAILURE);
}
rcm_log_message(RCM_TRACE1,
"NET: %s event data (linkid %d)\n", RCM_NV_LINKID,
(datalink_id_t)id64);
}
}
if ((datalink_id_t)id64 == DATALINK_INVALID_LINKID) {
rcm_log_message(RCM_INFO, _("NET: invalid datalink\n"));
errno = EINVAL;
return (RCM_FAILURE);
}
/*
* If this is device reconfiguration, populate the LINK_NEW event
* to start the DR process.
*/
if (reconfigured) {
nvlist_t *nnvl = NULL;
rcm_log_message(RCM_TRACE1,
"NET: reconfigured data-link (id %d)\n",
(datalink_id_t)id64);
if ((nvlist_alloc(&nnvl, 0, 0) != 0) || (nvlist_add_uint64(nnvl,
RCM_NV_LINKID, id64) != 0) || (rcm_notify_event(hd,
RCM_RESOURCE_LINK_NEW, 0, nnvl, NULL) != RCM_SUCCESS)) {
nvlist_free(nnvl);
rcm_log_message(RCM_INFO,
_("NET: notify %s event failed\n"),
RCM_RESOURCE_LINK_NEW);
errno = EINVAL;
return (RCM_FAILURE);
}
nvlist_free(nnvl);
}
rcm_log_message(RCM_TRACE1,
_("NET: notify_event: device configuration complete\n"));
return (RCM_SUCCESS);
}
CCIMInstance *
partbasedon_descriptor_toCCIMInstance(char *hostname, dm_descriptor_t ant,
dm_descriptor_t dep, char *provider, int *errp)
{
nvlist_t *nvlp;
nvpair_t *nvp;
CCIMInstance *inst = NULL;
CCIMInstance *ant_inst;
CCIMInstance *dep_inst;
CCIMObjectPath *ant_op;
CCIMObjectPath *dep_op;
CCIMException *ex;
int error;
uint64_t size; /* need these to calculate ending addr */
uint64_t startaddr;
uint64_t endaddr;
char attrval[100];
int isFdisk = 0;
*errp = 0;
/* Create instance of partition based on assoc. */
if ((inst = cim_createInstance(provider)) == NULL) {
ex = cim_getLastError();
util_handleError(PARTBASEDON_DESCRIPTOR_FUNC,
CIM_ERR_FAILED, CREATE_INSTANCE_FAILURE, ex, errp);
return ((CCIMInstance *)NULL);
}
if ((strcasecmp(provider, DISKPART_BASEDONFDISK)) == 0) {
isFdisk = 1;
}
/*
* Now get the object path for the REF pointers.
*/
if (isFdisk) {
ant_inst = partition_descriptor_toCCIMInstance(hostname, ant,
DISK_PARTITION, &error);
} else {
ant_inst = logicaldisk_descriptor_toCCIMInstance(hostname, ant,
LOGICAL_DISK, &error);
}
if (error != 0) {
util_handleError(PARTBASEDON_DESCRIPTOR_FUNC,
CIM_ERR_FAILED, PARTBASEDON_DESC_TO_INSTANCE_FAILURE,
NULL, &error);
cim_freeInstance(inst);
return ((CCIMInstance *)NULL);
}
dep_inst = partition_descriptor_toCCIMInstance(hostname, dep,
DISK_PARTITION, &error);
if (error != 0) {
util_handleError(PARTBASEDON_DESCRIPTOR_FUNC,
CIM_ERR_FAILED, PARTBASEDON_DESC_TO_INSTANCE_FAILURE,
NULL, &error);
cim_freeInstance(inst);
cim_freeInstance(ant_inst);
return ((CCIMInstance *)NULL);
}
/*
* Get the object paths that are represented by these instances.
* Add these properties to the association instance.
*/
ant_op = cim_createObjectPath(ant_inst);
dep_op = cim_createObjectPath(dep_inst);
cim_freeInstance(ant_inst);
cim_freeInstance(dep_inst);
if (ant_op == NULL || dep_op == NULL) {
ex = cim_getLastError();
util_handleError(PARTBASEDON_DESCRIPTOR_FUNC,
CIM_ERR_FAILED, CREATE_OBJECT_PATH_FAILURE, ex, &error);
cim_freeInstance(inst);
return ((CCIMInstance *)NULL);
}
util_doReferenceProperty(ANTECEDENT, ant_op, cim_true, inst, errp);
util_doReferenceProperty(DEPENDENT, dep_op, cim_true, inst, errp);
cim_freeObjectPath(ant_op);
cim_freeObjectPath(dep_op);
if (*errp != 0) {
ex = cim_getLastError();
util_handleError(PARTBASEDON_DESCRIPTOR_FUNC,
CIM_ERR_FAILED, ADD_PROPERTY_FAILURE, ex, errp);
cim_freeInstance(inst);
return ((CCIMInstance *)NULL);
}
/*
* Now get the other attributes we are interested in
*/
nvlp = dm_get_attributes(dep, &error);
if (error != 0) {
util_handleError(PARTBASEDON_DESCRIPTOR_FUNC, CIM_ERR_FAILED,
DM_GET_ATTR_FAILURE, NULL, errp);
cim_freeInstance(inst);
return ((CCIMInstance *)NULL);
}
if (nvlp == NULL) {
return (inst);
}
for (nvp = nvlist_next_nvpair(nvlp, NULL); nvp != NULL;
nvp = nvlist_next_nvpair(nvlp, nvp)) {
char *attrname;
uint64_t ui64;
uint32_t ui32;
attrname = nvpair_name(nvp);
if (attrname == NULL) {
continue;
}
if (strcasecmp(attrname, DM_SIZE) == 0) {
error = nvpair_value_uint64(nvp, &ui64);
if (error != 0) {
cim_freeInstance(inst);
nvlist_free(nvlp);
util_handleError(PARTBASEDON_DESCRIPTOR_FUNC,
CIM_ERR_FAILED, DM_GET_ATTR_FAILURE, NULL, errp);
return ((CCIMInstance *)NULL);
}
size = ui64;
} else if (strcasecmp(attrname, DM_START) == 0) {
error = nvpair_value_uint64(nvp, &ui64);
if (error != 0) {
cim_freeInstance(inst);
nvlist_free(nvlp);
util_handleError(PARTBASEDON_DESCRIPTOR_FUNC,
CIM_ERR_FAILED, DM_GET_ATTR_FAILURE, NULL, errp);
return ((CCIMInstance *)NULL);
}
startaddr = ui64;
error = snprintf(attrval, sizeof (attrval), "%llu", ui64);
if (error < 0) {
cim_freeInstance(inst);
nvlist_free(nvlp);
util_handleError(PARTBASEDON_DESCRIPTOR_FUNC,
CIM_ERR_FAILED, DM_GET_ATTR_FAILURE, NULL, errp);
return ((CCIMInstance *)NULL);
}
util_doProperty("StartingAddress", uint64, attrval, cim_false,
inst, errp);
if (*errp != 0) {
ex = cim_getLastError();
util_handleError(PARTBASEDON_DESCRIPTOR_FUNC,
CIM_ERR_FAILED, ADD_PROPERTY_FAILURE, ex, errp);
cim_freeInstance(inst);
nvlist_free(nvlp);
return ((CCIMInstance *)NULL);
}
} else if (strcasecmp(attrname, DM_INDEX) == 0) {
error = nvpair_value_uint32(nvp, &ui32);
if (error != 0) {
cim_freeInstance(inst);
nvlist_free(nvlp);
util_handleError(PARTBASEDON_DESCRIPTOR_FUNC,
CIM_ERR_FAILED, DM_GET_ATTR_FAILURE, NULL, errp);
return ((CCIMInstance *)NULL);
}
error = snprintf(attrval, sizeof (attrval), "%u", ui32);
if (error < 0) {
cim_freeInstance(inst);
nvlist_free(nvlp);
util_handleError(PARTBASEDON_DESCRIPTOR_FUNC,
CIM_ERR_FAILED, DM_GET_ATTR_FAILURE, NULL, errp);
return ((CCIMInstance *)NULL);
}
util_doProperty("OrderIndex", uint32, attrval, cim_false,
inst, errp);
if (*errp != 0) {
ex = cim_getLastError();
util_handleError(PARTBASEDON_DESCRIPTOR_FUNC,
CIM_ERR_FAILED, ADD_PROPERTY_FAILURE, ex, errp);
cim_freeInstance(inst);
nvlist_free(nvlp);
return ((CCIMInstance *)NULL);
}
}
}
nvlist_free(nvlp);
/*
* Now add the ending address attribute. Do this here because
* there is no guarantee about the order for how these name/value
* pairs are given and without the starting address we cannot
* calculate the ending address.
*/
endaddr = startaddr + size;
error = snprintf(attrval, sizeof (attrval), "%llu", endaddr);
if (error < 0) {
cim_freeInstance(inst);
util_handleError(PARTBASEDON_DESCRIPTOR_FUNC,
CIM_ERR_FAILED, DM_GET_ATTR_FAILURE, NULL, errp);
return ((CCIMInstance *)NULL);
}
util_doProperty("EndingAddress", uint64, attrval, cim_false, inst,
errp);
if (*errp != 0) {
ex = cim_getLastError();
util_handleError(PARTBASEDON_DESCRIPTOR_FUNC,
CIM_ERR_FAILED, ADD_PROPERTY_FAILURE, ex, errp);
cim_freeInstance(inst);
return ((CCIMInstance *)NULL);
}
return (inst);
}
/*
* Determine if string 'value' matches 'nvp' value. The 'value' string is
* converted, depending on the type of 'nvp', prior to match. For numeric
* types, a radix independent sscanf conversion of 'value' is used. If 'nvp'
* is an array type, 'ai' is the index into the array against which we are
* checking for match. If nvp is of DATA_TYPE_STRING*, the caller can pass
* in a regex_t compilation of value in 'value_regex' to trigger regular
* expression string match instead of simple strcmp().
*
* Return 1 on match, 0 on no-match, and -1 on error. If the error is
* related to value syntax error and 'ep' is non-NULL, *ep will point into
* the 'value' string at the location where the error exists.
*
* NOTE: It may be possible to move the non-regex_t version of this into
* common code used by library/kernel/boot.
*/
int
nvpair_value_match_regex(nvpair_t *nvp, int ai,
char *value, regex_t *value_regex, char **ep)
{
char *evalue;
uint_t a_len;
int sr;
if (ep)
*ep = NULL;
if ((nvp == NULL) || (value == NULL))
return (-1); /* error fail match - invalid args */
/* make sure array and index combination make sense */
if ((nvpair_type_is_array(nvp) && (ai < 0)) ||
(!nvpair_type_is_array(nvp) && (ai >= 0)))
return (-1); /* error fail match - bad index */
/* non-string values should be single 'chunk' */
if ((nvpair_type(nvp) != DATA_TYPE_STRING) &&
(nvpair_type(nvp) != DATA_TYPE_STRING_ARRAY)) {
value += strspn(value, " \t");
evalue = value + strcspn(value, " \t");
if (*evalue) {
if (ep)
*ep = evalue;
return (-1); /* error fail match - syntax */
}
}
sr = EOF;
switch (nvpair_type(nvp)) {
case DATA_TYPE_STRING: {
char *val;
/* check string value for match */
if (nvpair_value_string(nvp, &val) == 0) {
if (value_regex) {
if (regexec(value_regex, val,
(size_t)0, NULL, 0) == 0)
return (1); /* match */
} else {
if (strcmp(value, val) == 0)
return (1); /* match */
}
}
break;
}
case DATA_TYPE_STRING_ARRAY: {
char **val_array;
/* check indexed string value of array for match */
if ((nvpair_value_string_array(nvp, &val_array, &a_len) == 0) &&
(ai < a_len)) {
if (value_regex) {
if (regexec(value_regex, val_array[ai],
(size_t)0, NULL, 0) == 0)
return (1);
} else {
if (strcmp(value, val_array[ai]) == 0)
return (1);
}
}
break;
}
case DATA_TYPE_BYTE: {
uchar_t val, val_arg;
/* scanf uchar_t from value and check for match */
sr = sscanf(value, "%c", &val_arg);
if ((sr == 1) && (nvpair_value_byte(nvp, &val) == 0) &&
(val == val_arg))
return (1);
break;
}
case DATA_TYPE_BYTE_ARRAY: {
uchar_t *val_array, val_arg;
/* check indexed value of array for match */
sr = sscanf(value, "%c", &val_arg);
if ((sr == 1) &&
(nvpair_value_byte_array(nvp, &val_array, &a_len) == 0) &&
(ai < a_len) &&
(val_array[ai] == val_arg))
return (1);
break;
}
case DATA_TYPE_INT8: {
int8_t val, val_arg;
/* scanf int8_t from value and check for match */
sr = sscanf(value, "%"SCNi8, &val_arg);
if ((sr == 1) &&
(nvpair_value_int8(nvp, &val) == 0) &&
(val == val_arg))
return (1);
break;
}
case DATA_TYPE_INT8_ARRAY: {
int8_t *val_array, val_arg;
/* check indexed value of array for match */
sr = sscanf(value, "%"SCNi8, &val_arg);
if ((sr == 1) &&
(nvpair_value_int8_array(nvp, &val_array, &a_len) == 0) &&
(ai < a_len) &&
(val_array[ai] == val_arg))
return (1);
break;
}
case DATA_TYPE_UINT8: {
uint8_t val, val_arg;
/* scanf uint8_t from value and check for match */
sr = sscanf(value, "%"SCNi8, (int8_t *)&val_arg);
if ((sr == 1) &&
(nvpair_value_uint8(nvp, &val) == 0) &&
(val == val_arg))
return (1);
break;
}
case DATA_TYPE_UINT8_ARRAY: {
uint8_t *val_array, val_arg;
/* check indexed value of array for match */
sr = sscanf(value, "%"SCNi8, (int8_t *)&val_arg);
if ((sr == 1) &&
(nvpair_value_uint8_array(nvp, &val_array, &a_len) == 0) &&
(ai < a_len) &&
(val_array[ai] == val_arg))
return (1);
break;
}
case DATA_TYPE_INT16: {
int16_t val, val_arg;
/* scanf int16_t from value and check for match */
sr = sscanf(value, "%"SCNi16, &val_arg);
if ((sr == 1) &&
(nvpair_value_int16(nvp, &val) == 0) &&
(val == val_arg))
return (1);
break;
}
case DATA_TYPE_INT16_ARRAY: {
int16_t *val_array, val_arg;
/* check indexed value of array for match */
sr = sscanf(value, "%"SCNi16, &val_arg);
if ((sr == 1) &&
(nvpair_value_int16_array(nvp, &val_array, &a_len) == 0) &&
(ai < a_len) &&
(val_array[ai] == val_arg))
return (1);
break;
}
case DATA_TYPE_UINT16: {
uint16_t val, val_arg;
/* scanf uint16_t from value and check for match */
sr = sscanf(value, "%"SCNi16, (int16_t *)&val_arg);
if ((sr == 1) &&
(nvpair_value_uint16(nvp, &val) == 0) &&
(val == val_arg))
return (1);
break;
}
case DATA_TYPE_UINT16_ARRAY: {
uint16_t *val_array, val_arg;
/* check indexed value of array for match */
sr = sscanf(value, "%"SCNi16, (int16_t *)&val_arg);
if ((sr == 1) &&
(nvpair_value_uint16_array(nvp, &val_array, &a_len) == 0) &&
(ai < a_len) &&
(val_array[ai] == val_arg))
return (1);
break;
}
case DATA_TYPE_INT32: {
int32_t val, val_arg;
/* scanf int32_t from value and check for match */
sr = sscanf(value, "%"SCNi32, &val_arg);
if ((sr == 1) &&
(nvpair_value_int32(nvp, &val) == 0) &&
(val == val_arg))
return (1);
break;
}
case DATA_TYPE_INT32_ARRAY: {
int32_t *val_array, val_arg;
/* check indexed value of array for match */
sr = sscanf(value, "%"SCNi32, &val_arg);
if ((sr == 1) &&
(nvpair_value_int32_array(nvp, &val_array, &a_len) == 0) &&
(ai < a_len) &&
(val_array[ai] == val_arg))
return (1);
break;
}
case DATA_TYPE_UINT32: {
uint32_t val, val_arg;
/* scanf uint32_t from value and check for match */
sr = sscanf(value, "%"SCNi32, (int32_t *)&val_arg);
if ((sr == 1) &&
(nvpair_value_uint32(nvp, &val) == 0) &&
(val == val_arg))
return (1);
break;
}
case DATA_TYPE_UINT32_ARRAY: {
uint32_t *val_array, val_arg;
/* check indexed value of array for match */
sr = sscanf(value, "%"SCNi32, (int32_t *)&val_arg);
if ((sr == 1) &&
(nvpair_value_uint32_array(nvp, &val_array, &a_len) == 0) &&
(ai < a_len) &&
(val_array[ai] == val_arg))
return (1);
break;
}
case DATA_TYPE_INT64: {
int64_t val, val_arg;
/* scanf int64_t from value and check for match */
sr = sscanf(value, "%"SCNi64, &val_arg);
if ((sr == 1) &&
(nvpair_value_int64(nvp, &val) == 0) &&
(val == val_arg))
return (1);
break;
}
case DATA_TYPE_INT64_ARRAY: {
int64_t *val_array, val_arg;
/* check indexed value of array for match */
sr = sscanf(value, "%"SCNi64, &val_arg);
if ((sr == 1) &&
(nvpair_value_int64_array(nvp, &val_array, &a_len) == 0) &&
(ai < a_len) &&
(val_array[ai] == val_arg))
return (1);
break;
}
case DATA_TYPE_UINT64: {
uint64_t val_arg, val;
/* scanf uint64_t from value and check for match */
sr = sscanf(value, "%"SCNi64, (int64_t *)&val_arg);
if ((sr == 1) &&
(nvpair_value_uint64(nvp, &val) == 0) &&
(val == val_arg))
return (1);
break;
}
case DATA_TYPE_UINT64_ARRAY: {
uint64_t *val_array, val_arg;
/* check indexed value of array for match */
sr = sscanf(value, "%"SCNi64, (int64_t *)&val_arg);
if ((sr == 1) &&
(nvpair_value_uint64_array(nvp, &val_array, &a_len) == 0) &&
(ai < a_len) &&
(val_array[ai] == val_arg))
return (1);
break;
}
case DATA_TYPE_BOOLEAN_VALUE: {
boolean_t val, val_arg;
/* scanf boolean_t from value and check for match */
sr = sscanf(value, "%"SCNi32, &val_arg);
if ((sr == 1) &&
(nvpair_value_boolean_value(nvp, &val) == 0) &&
(val == val_arg))
return (1);
break;
}
case DATA_TYPE_BOOLEAN_ARRAY: {
boolean_t *val_array, val_arg;
/* check indexed value of array for match */
sr = sscanf(value, "%"SCNi32, &val_arg);
if ((sr == 1) &&
(nvpair_value_boolean_array(nvp,
&val_array, &a_len) == 0) &&
(ai < a_len) &&
(val_array[ai] == val_arg))
return (1);
break;
}
case DATA_TYPE_HRTIME:
case DATA_TYPE_NVLIST:
case DATA_TYPE_NVLIST_ARRAY:
case DATA_TYPE_BOOLEAN:
case DATA_TYPE_DOUBLE:
case DATA_TYPE_UNKNOWN:
default:
/*
* unknown/unsupported data type
*/
return (-1); /* error fail match */
}
/*
* check to see if sscanf failed conversion, return approximate
* pointer to problem
*/
if (sr != 1) {
if (ep)
*ep = value;
return (-1); /* error fail match - syntax */
}
return (0); /* fail match */
}
/*
* Convert the nvpair [nvp] to a string which is added to the environment
* of the child process.
* Return 0 on success, -1 on error.
*
* FIXME: Refactor with cmd/zpool/zpool_main.c:zpool_do_events_nvprint()?
*/
static void
_zed_event_add_nvpair(uint64_t eid, zed_strings_t *zsp, nvpair_t *nvp)
{
const char *name;
data_type_t type;
const char *prefix = ZEVENT_VAR_PREFIX;
boolean_t b;
double d;
uint8_t i8;
uint16_t i16;
uint32_t i32;
uint64_t i64;
char *str;
assert(zsp != NULL);
assert(nvp != NULL);
name = nvpair_name(nvp);
type = nvpair_type(nvp);
switch (type) {
case DATA_TYPE_BOOLEAN:
_zed_event_add_var(eid, zsp, prefix, name, "%s", "1");
break;
case DATA_TYPE_BOOLEAN_VALUE:
(void) nvpair_value_boolean_value(nvp, &b);
_zed_event_add_var(eid, zsp, prefix, name, "%s", b ? "1" : "0");
break;
case DATA_TYPE_BYTE:
(void) nvpair_value_byte(nvp, &i8);
_zed_event_add_var(eid, zsp, prefix, name, "%d", i8);
break;
case DATA_TYPE_INT8:
(void) nvpair_value_int8(nvp, (int8_t *) &i8);
_zed_event_add_var(eid, zsp, prefix, name, "%d", i8);
break;
case DATA_TYPE_UINT8:
(void) nvpair_value_uint8(nvp, &i8);
_zed_event_add_var(eid, zsp, prefix, name, "%u", i8);
break;
case DATA_TYPE_INT16:
(void) nvpair_value_int16(nvp, (int16_t *) &i16);
_zed_event_add_var(eid, zsp, prefix, name, "%d", i16);
break;
case DATA_TYPE_UINT16:
(void) nvpair_value_uint16(nvp, &i16);
_zed_event_add_var(eid, zsp, prefix, name, "%u", i16);
break;
case DATA_TYPE_INT32:
(void) nvpair_value_int32(nvp, (int32_t *) &i32);
_zed_event_add_var(eid, zsp, prefix, name, "%d", i32);
break;
case DATA_TYPE_UINT32:
(void) nvpair_value_uint32(nvp, &i32);
_zed_event_add_var(eid, zsp, prefix, name, "%u", i32);
break;
case DATA_TYPE_INT64:
(void) nvpair_value_int64(nvp, (int64_t *) &i64);
_zed_event_add_var(eid, zsp, prefix, name,
"%lld", (longlong_t) i64);
break;
case DATA_TYPE_UINT64:
(void) nvpair_value_uint64(nvp, &i64);
_zed_event_add_var(eid, zsp, prefix, name,
(_zed_event_value_is_hex(name) ? "0x%.16llX" : "%llu"),
(u_longlong_t) i64);
/*
* shadow readable strings for vdev state pairs
*/
if (strcmp(name, FM_EREPORT_PAYLOAD_ZFS_VDEV_STATE) == 0 ||
strcmp(name, FM_EREPORT_PAYLOAD_ZFS_VDEV_LASTSTATE) == 0) {
char alt[32];
(void) snprintf(alt, sizeof (alt), "%s_str", name);
_zed_event_add_var(eid, zsp, prefix, alt, "%s",
zpool_state_to_name(i64, VDEV_AUX_NONE));
}
break;
case DATA_TYPE_DOUBLE:
(void) nvpair_value_double(nvp, &d);
_zed_event_add_var(eid, zsp, prefix, name, "%g", d);
break;
case DATA_TYPE_HRTIME:
(void) nvpair_value_hrtime(nvp, (hrtime_t *) &i64);
_zed_event_add_var(eid, zsp, prefix, name,
"%llu", (u_longlong_t) i64);
break;
case DATA_TYPE_NVLIST:
_zed_event_add_var(eid, zsp, prefix, name,
"%s", "_NOT_IMPLEMENTED_"); /* FIXME */
break;
case DATA_TYPE_STRING:
(void) nvpair_value_string(nvp, &str);
_zed_event_add_var(eid, zsp, prefix, name,
"%s", (str ? str : "<NULL>"));
break;
case DATA_TYPE_BOOLEAN_ARRAY:
_zed_event_add_var(eid, zsp, prefix, name,
"%s", "_NOT_IMPLEMENTED_"); /* FIXME */
break;
case DATA_TYPE_BYTE_ARRAY:
_zed_event_add_var(eid, zsp, prefix, name,
"%s", "_NOT_IMPLEMENTED_"); /* FIXME */
break;
case DATA_TYPE_INT8_ARRAY:
_zed_event_add_int8_array(eid, zsp, prefix, nvp);
break;
case DATA_TYPE_UINT8_ARRAY:
_zed_event_add_uint8_array(eid, zsp, prefix, nvp);
break;
case DATA_TYPE_INT16_ARRAY:
_zed_event_add_int16_array(eid, zsp, prefix, nvp);
break;
case DATA_TYPE_UINT16_ARRAY:
_zed_event_add_uint16_array(eid, zsp, prefix, nvp);
break;
case DATA_TYPE_INT32_ARRAY:
_zed_event_add_int32_array(eid, zsp, prefix, nvp);
break;
case DATA_TYPE_UINT32_ARRAY:
_zed_event_add_uint32_array(eid, zsp, prefix, nvp);
break;
case DATA_TYPE_INT64_ARRAY:
_zed_event_add_int64_array(eid, zsp, prefix, nvp);
break;
case DATA_TYPE_UINT64_ARRAY:
_zed_event_add_uint64_array(eid, zsp, prefix, nvp);
break;
case DATA_TYPE_STRING_ARRAY:
_zed_event_add_string_array(eid, zsp, prefix, nvp);
break;
case DATA_TYPE_NVLIST_ARRAY:
_zed_event_add_var(eid, zsp, prefix, name,
"%s", "_NOT_IMPLEMENTED_"); /* FIXME */
break;
default:
errno = EINVAL;
zed_log_msg(LOG_WARNING,
"Failed to convert nvpair \"%s\" for eid=%llu: "
"Unrecognized type=%u", name, eid, (unsigned int) type);
break;
}
}
/*
* nvlist_print - Prints elements in an event buffer
*/
static
void
nvlist_print_with_indent(FILE *fp, nvlist_t *nvl, int depth)
{
int i;
char *name;
uint_t nelem;
nvpair_t *nvp;
if (nvl == NULL)
return;
indent(fp, depth);
(void) fprintf(fp, "nvlist version: %d\n", NVL_VERSION(nvl));
nvp = nvlist_next_nvpair(nvl, NULL);
while (nvp) {
data_type_t type = nvpair_type(nvp);
indent(fp, depth);
name = nvpair_name(nvp);
(void) fprintf(fp, "\t%s =", name);
nelem = 0;
switch (type) {
case DATA_TYPE_BOOLEAN: {
(void) fprintf(fp, " 1");
break;
}
case DATA_TYPE_BOOLEAN_VALUE: {
boolean_t val;
(void) nvpair_value_boolean_value(nvp, &val);
(void) fprintf(fp, " %d", val);
break;
}
case DATA_TYPE_BYTE: {
uchar_t val;
(void) nvpair_value_byte(nvp, &val);
(void) fprintf(fp, " 0x%2.2x", val);
break;
}
case DATA_TYPE_INT8: {
int8_t val;
(void) nvpair_value_int8(nvp, &val);
(void) fprintf(fp, " %d", val);
break;
}
case DATA_TYPE_UINT8: {
uint8_t val;
(void) nvpair_value_uint8(nvp, &val);
(void) fprintf(fp, " 0x%x", val);
break;
}
case DATA_TYPE_INT16: {
int16_t val;
(void) nvpair_value_int16(nvp, &val);
(void) fprintf(fp, " %d", val);
break;
}
case DATA_TYPE_UINT16: {
uint16_t val;
(void) nvpair_value_uint16(nvp, &val);
(void) fprintf(fp, " 0x%x", val);
break;
}
case DATA_TYPE_INT32: {
int32_t val;
(void) nvpair_value_int32(nvp, &val);
(void) fprintf(fp, " %d", val);
break;
}
case DATA_TYPE_UINT32: {
uint32_t val;
(void) nvpair_value_uint32(nvp, &val);
(void) fprintf(fp, " 0x%x", val);
break;
}
case DATA_TYPE_INT64: {
int64_t val;
(void) nvpair_value_int64(nvp, &val);
(void) fprintf(fp, " %lld", (longlong_t)val);
break;
}
case DATA_TYPE_UINT64: {
uint64_t val;
(void) nvpair_value_uint64(nvp, &val);
(void) fprintf(fp, " 0x%llx", (u_longlong_t)val);
break;
}
case DATA_TYPE_DOUBLE: {
double val;
(void) nvpair_value_double(nvp, &val);
(void) fprintf(fp, " 0x%llf", val);
break;
}
case DATA_TYPE_STRING: {
char *val;
(void) nvpair_value_string(nvp, &val);
(void) fprintf(fp, " %s", val);
break;
}
case DATA_TYPE_BOOLEAN_ARRAY: {
boolean_t *val;
(void) nvpair_value_boolean_array(nvp, &val, &nelem);
for (i = 0; i < nelem; i++)
(void) fprintf(fp, " %d", val[i]);
break;
}
case DATA_TYPE_BYTE_ARRAY: {
uchar_t *val;
(void) nvpair_value_byte_array(nvp, &val, &nelem);
for (i = 0; i < nelem; i++)
(void) fprintf(fp, " 0x%2.2x", val[i]);
break;
}
case DATA_TYPE_INT8_ARRAY: {
int8_t *val;
(void) nvpair_value_int8_array(nvp, &val, &nelem);
for (i = 0; i < nelem; i++)
(void) fprintf(fp, " %d", val[i]);
break;
}
case DATA_TYPE_UINT8_ARRAY: {
uint8_t *val;
(void) nvpair_value_uint8_array(nvp, &val, &nelem);
for (i = 0; i < nelem; i++)
(void) fprintf(fp, " 0x%x", val[i]);
break;
}
case DATA_TYPE_INT16_ARRAY: {
int16_t *val;
(void) nvpair_value_int16_array(nvp, &val, &nelem);
for (i = 0; i < nelem; i++)
(void) fprintf(fp, " %d", val[i]);
break;
}
case DATA_TYPE_UINT16_ARRAY: {
uint16_t *val;
(void) nvpair_value_uint16_array(nvp, &val, &nelem);
for (i = 0; i < nelem; i++)
(void) fprintf(fp, " 0x%x", val[i]);
break;
}
case DATA_TYPE_INT32_ARRAY: {
int32_t *val;
(void) nvpair_value_int32_array(nvp, &val, &nelem);
for (i = 0; i < nelem; i++)
(void) fprintf(fp, " %d", val[i]);
break;
}
case DATA_TYPE_UINT32_ARRAY: {
uint32_t *val;
(void) nvpair_value_uint32_array(nvp, &val, &nelem);
for (i = 0; i < nelem; i++)
(void) fprintf(fp, " 0x%x", val[i]);
break;
}
case DATA_TYPE_INT64_ARRAY: {
int64_t *val;
(void) nvpair_value_int64_array(nvp, &val, &nelem);
for (i = 0; i < nelem; i++)
(void) fprintf(fp, " %lld", (longlong_t)val[i]);
break;
}
case DATA_TYPE_UINT64_ARRAY: {
uint64_t *val;
(void) nvpair_value_uint64_array(nvp, &val, &nelem);
for (i = 0; i < nelem; i++)
(void) fprintf(fp, " 0x%llx",
(u_longlong_t)val[i]);
break;
}
case DATA_TYPE_STRING_ARRAY: {
char **val;
(void) nvpair_value_string_array(nvp, &val, &nelem);
for (i = 0; i < nelem; i++)
(void) fprintf(fp, " %s", val[i]);
break;
}
case DATA_TYPE_HRTIME: {
hrtime_t val;
(void) nvpair_value_hrtime(nvp, &val);
(void) fprintf(fp, " 0x%llx", val);
break;
}
case DATA_TYPE_NVLIST: {
nvlist_t *val;
(void) nvpair_value_nvlist(nvp, &val);
(void) fprintf(fp, " (embedded nvlist)\n");
nvlist_print_with_indent(fp, val, depth + 1);
indent(fp, depth + 1);
(void) fprintf(fp, "(end %s)\n", name);
break;
}
case DATA_TYPE_NVLIST_ARRAY: {
nvlist_t **val;
(void) nvpair_value_nvlist_array(nvp, &val, &nelem);
(void) fprintf(fp, " (array of embedded nvlists)\n");
for (i = 0; i < nelem; i++) {
indent(fp, depth + 1);
(void) fprintf(fp,
"(start %s[%d])\n", name, i);
nvlist_print_with_indent(fp, val[i], depth + 1);
indent(fp, depth + 1);
(void) fprintf(fp, "(end %s[%d])\n", name, i);
}
break;
}
default:
(void) fprintf(fp, " unknown data type (%d)", type);
break;
}
(void) fprintf(fp, "\n");
nvp = nvlist_next_nvpair(nvl, nvp);
}
}
/* Handle a given list, boolean or numerical key=value pair */
static kv_status_t
iser_handle_key(nvpair_t *nvp, const idm_kv_xlate_t *ikvx,
nvlist_t *request_nvl, nvlist_t *response_nvl, nvlist_t *negotiated_nvl)
{
kv_status_t kvrc = KV_UNHANDLED;
boolean_t bool_val;
uint64_t num_val;
int nvrc;
/* Retrieve values for booleans and numericals */
switch (ikvx->ik_key_id) {
/* Booleans */
case KI_RDMA_EXTENSIONS:
case KI_IMMEDIATE_DATA:
case KI_IFMARKER:
case KI_OFMARKER:
nvrc = nvpair_value_boolean_value(nvp, &bool_val);
ASSERT(nvrc == 0);
break;
/* Numericals */
case KI_INITIATOR_RECV_DATA_SEGMENT_LENGTH:
case KI_TARGET_RECV_DATA_SEGMENT_LENGTH:
case KI_MAX_OUTSTANDING_UNEXPECTED_PDUS:
nvrc = nvpair_value_uint64(nvp, &num_val);
ASSERT(nvrc == 0);
break;
default:
break;
}
/* Now handle the values according to the key name */
switch (ikvx->ik_key_id) {
case KI_HEADER_DIGEST:
case KI_DATA_DIGEST:
/* Ensure "None" */
kvrc = iser_handle_digest(nvp, ikvx, request_nvl, response_nvl,
negotiated_nvl);
break;
case KI_RDMA_EXTENSIONS:
/* Ensure "Yes" */
kvrc = iser_handle_boolean(nvp, bool_val, ikvx, B_TRUE,
request_nvl, response_nvl, negotiated_nvl);
break;
case KI_TARGET_RECV_DATA_SEGMENT_LENGTH:
/* Validate the proposed value */
kvrc = iser_handle_numerical(nvp, num_val, ikvx,
ISER_TARGET_RECV_DATA_SEGMENT_LENGTH_MIN,
ISER_TARGET_RECV_DATA_SEGMENT_LENGTH_MAX,
ISER_TARGET_RECV_DATA_SEGMENT_LENGTH_IMPL_MAX,
request_nvl, response_nvl, negotiated_nvl);
break;
case KI_INITIATOR_RECV_DATA_SEGMENT_LENGTH:
/* Validate the proposed value */
kvrc = iser_handle_numerical(nvp, num_val, ikvx,
ISER_INITIATOR_RECV_DATA_SEGMENT_LENGTH_MIN,
ISER_INITIATOR_RECV_DATA_SEGMENT_LENGTH_MAX,
ISER_INITIATOR_RECV_DATA_SEGMENT_LENGTH_IMPL_MAX,
request_nvl, response_nvl, negotiated_nvl);
break;
case KI_IMMEDIATE_DATA:
case KI_OFMARKER:
case KI_IFMARKER:
/* Ensure "No" */
kvrc = iser_handle_boolean(nvp, bool_val, ikvx, B_FALSE,
request_nvl, response_nvl, negotiated_nvl);
break;
case KI_MAX_OUTSTANDING_UNEXPECTED_PDUS:
/* Validate the proposed value */
kvrc = iser_handle_numerical(nvp, num_val, ikvx,
ISER_MAX_OUTSTANDING_UNEXPECTED_PDUS_MIN,
ISER_MAX_OUTSTANDING_UNEXPECTED_PDUS_MAX,
ISER_MAX_OUTSTANDING_UNEXPECTED_PDUS_IMPL_MAX,
request_nvl, response_nvl, negotiated_nvl);
break;
default:
/*
* All other keys, including invalid keys, will be
* handled at the client layer.
*/
kvrc = KV_HANDLED;
break;
}
return (kvrc);
}
