/*ARGSUSED*/
static void
zfs_ereport_when(fmd_hdl_t *hdl, nvlist_t *nvl, er_timeval_t *when)
{
int64_t *tod;
uint_t nelem;
if (nvlist_lookup_int64_array(nvl, FM_EREPORT_TIME, &tod,
&nelem) == 0 && nelem == 2) {
when->ertv_sec = tod[0];
when->ertv_nsec = tod[1];
} else {
when->ertv_sec = when->ertv_nsec = UINT64_MAX;
}
}
/*
* Seek to the event specified by [saved_eid] and [saved_etime].
* This protects against processing a given event more than once.
* Return 0 upon a successful seek to the specified event, or -1 otherwise.
*
* A zevent is considered to be uniquely specified by its (eid,time) tuple.
* The unsigned 64b eid is set to 1 when the kernel module is loaded, and
* incremented by 1 for each new event. Since the state file can persist
* across a kernel module reload, the time must be checked to ensure a match.
*/
int
zed_event_seek(struct zed_conf *zcp, uint64_t saved_eid, int64_t saved_etime[])
{
uint64_t eid;
int found;
nvlist_t *nvl;
int n_dropped;
int64_t *etime;
uint_t nelem;
int rv;
if (!zcp) {
errno = EINVAL;
zed_log_msg(LOG_ERR, "Failed to seek zevent: %s",
strerror(errno));
return (-1);
}
eid = 0;
found = 0;
while ((eid < saved_eid) && !found) {
rv = zpool_events_next(zcp->zfs_hdl, &nvl, &n_dropped,
ZEVENT_NONBLOCK, zcp->zevent_fd);
if ((rv != 0) || !nvl)
break;
if (n_dropped > 0) {
zed_log_msg(LOG_WARNING, "Missed %d events", n_dropped);
/*
* FIXME: Increase max size of event nvlist in
* /sys/module/zfs/parameters/zfs_zevent_len_max ?
*/
}
if (nvlist_lookup_uint64(nvl, "eid", &eid) != 0) {
zed_log_msg(LOG_WARNING, "Failed to lookup zevent eid");
} else if (nvlist_lookup_int64_array(nvl, "time",
&etime, &nelem) != 0) {
zed_log_msg(LOG_WARNING,
"Failed to lookup zevent time (eid=%llu)", eid);
} else if (nelem != 2) {
zed_log_msg(LOG_WARNING,
"Failed to lookup zevent time (eid=%llu, nelem=%u)",
eid, nelem);
} else if ((eid != saved_eid) ||
(etime[0] != saved_etime[0]) ||
(etime[1] != saved_etime[1])) {
/* no-op */
} else {
found = 1;
}
free(nvl);
}
if (!found && (saved_eid > 0)) {
if (zpool_events_seek(zcp->zfs_hdl, ZEVENT_SEEK_START,
zcp->zevent_fd) < 0)
zed_log_msg(LOG_WARNING, "Failed to seek to eid=0");
else
eid = 0;
}
zed_log_msg(LOG_NOTICE, "Processing events since eid=%llu", eid);
return (found ? 0 : -1);
}
static int
prop_getval(tnode_t *node, const char *pgname, const char *pname, void *val,
topo_type_t type, uint_t *nelems, int *err)
{
int i, j, ret = 0;
topo_hdl_t *thp = node->tn_hdl;
topo_propval_t *pv;
topo_node_lock(node);
if ((pv = prop_get(node, pgname, pname, NULL, err))
== NULL)
return (get_properror(node, err, *err));
if (pv->tp_type != type)
return (get_properror(node, err, ETOPO_PROP_TYPE));
switch (type) {
case TOPO_TYPE_INT32:
ret = nvlist_lookup_int32(pv->tp_val, TOPO_PROP_VAL_VAL,
(int32_t *)val);
break;
case TOPO_TYPE_UINT32:
ret = nvlist_lookup_uint32(pv->tp_val,
TOPO_PROP_VAL_VAL, (uint32_t *)val);
break;
case TOPO_TYPE_INT64:
ret = nvlist_lookup_int64(pv->tp_val, TOPO_PROP_VAL_VAL,
(int64_t *)val);
break;
case TOPO_TYPE_UINT64:
ret = nvlist_lookup_uint64(pv->tp_val,
TOPO_PROP_VAL_VAL, (uint64_t *)val);
break;
case TOPO_TYPE_DOUBLE:
ret = nvlist_lookup_double(pv->tp_val,
TOPO_PROP_VAL_VAL, (double *)val);
break;
case TOPO_TYPE_STRING: {
char *str;
ret = nvlist_lookup_string(pv->tp_val,
TOPO_PROP_VAL_VAL, &str);
if (ret == 0) {
char *s2;
if ((s2 = topo_hdl_strdup(thp, str)) == NULL)
ret = -1;
else
*(char **)val = s2;
}
break;
}
case TOPO_TYPE_FMRI: {
nvlist_t *nvl;
ret = nvlist_lookup_nvlist(pv->tp_val,
TOPO_PROP_VAL_VAL, &nvl);
if (ret == 0)
ret = topo_hdl_nvdup(thp, nvl,
(nvlist_t **)val);
break;
}
case TOPO_TYPE_INT32_ARRAY: {
int32_t *a1, *a2;
if ((ret = nvlist_lookup_int32_array(pv->tp_val,
TOPO_PROP_VAL_VAL, &a2, nelems)) != 0)
break;
if ((a1 = topo_hdl_alloc(thp, sizeof (int32_t) *
*nelems)) == NULL) {
ret = ETOPO_NOMEM;
break;
}
for (i = 0; i < *nelems; ++i)
a1[i] = a2[i];
*(int32_t **)val = a1;
break;
}
case TOPO_TYPE_UINT32_ARRAY: {
uint32_t *a1, *a2;
if ((ret = nvlist_lookup_uint32_array(pv->tp_val,
TOPO_PROP_VAL_VAL, &a2, nelems)) != 0)
break;
if ((a1 = topo_hdl_alloc(thp, sizeof (uint32_t) *
*nelems)) == NULL) {
ret = ETOPO_NOMEM;
break;
}
for (i = 0; i < *nelems; ++i)
a1[i] = a2[i];
*(uint32_t **)val = a1;
break;
}
case TOPO_TYPE_INT64_ARRAY: {
int64_t *a1, *a2;
if ((ret = nvlist_lookup_int64_array(pv->tp_val,
TOPO_PROP_VAL_VAL, &a2, nelems)) != 0)
break;
if ((a1 = topo_hdl_alloc(thp, sizeof (int64_t) *
*nelems)) == NULL) {
ret = ETOPO_NOMEM;
break;
}
for (i = 0; i < *nelems; ++i)
a1[i] = a2[i];
*(int64_t **)val = a1;
break;
}
case TOPO_TYPE_UINT64_ARRAY: {
uint64_t *a1, *a2;
if ((ret = nvlist_lookup_uint64_array(pv->tp_val,
TOPO_PROP_VAL_VAL, &a2, nelems)) != 0)
break;
if ((a1 = topo_hdl_alloc(thp, sizeof (uint64_t) *
*nelems)) == NULL) {
ret = ETOPO_NOMEM;
break;
}
for (i = 0; i < *nelems; ++i)
a1[i] = a2[i];
*(uint64_t **)val = a1;
break;
}
case TOPO_TYPE_STRING_ARRAY: {
char **a1, **a2;
if ((ret = nvlist_lookup_string_array(pv->tp_val,
TOPO_PROP_VAL_VAL, &a2, nelems)) != 0)
break;
if ((a1 = topo_hdl_alloc(thp, sizeof (char *) *
*nelems)) == NULL) {
ret = ETOPO_NOMEM;
break;
}
for (i = 0; i < *nelems; ++i) {
if ((a1[i] = topo_hdl_strdup(thp, a2[i]))
== NULL) {
for (j = 0; j < i; ++j)
topo_hdl_free(thp, a1[j],
sizeof (char *));
topo_hdl_free(thp, a1,
sizeof (char *) * *nelems);
break;
}
}
*(char ***)val = a1;
break;
}
case TOPO_TYPE_FMRI_ARRAY: {
nvlist_t **a1, **a2;
if ((ret = nvlist_lookup_nvlist_array(pv->tp_val,
TOPO_PROP_VAL_VAL, &a2, nelems)) != 0)
break;
if ((a1 = topo_hdl_alloc(thp, sizeof (nvlist_t *) *
*nelems)) == NULL) {
ret = ETOPO_NOMEM;
break;
}
for (i = 0; i < *nelems; ++i) {
if (topo_hdl_nvdup(thp, a2[i], &a1[i]) < 0) {
for (j = 0; j < i; ++j)
nvlist_free(a1[j]);
topo_hdl_free(thp, a1,
sizeof (nvlist_t *) * *nelems);
break;
}
}
*(nvlist_t ***)val = a1;
break;
}
default:
ret = ETOPO_PROP_NOENT;
}
if (ret != 0)
if (ret == ENOENT)
return (get_properror(node, err, ETOPO_PROP_NOENT));
else if (ret < ETOPO_UNKNOWN)
return (get_properror(node, err, ETOPO_PROP_NVL));
else
return (get_properror(node, err, ret));
topo_node_unlock(node);
return (0);
}
