static int
get_status(disk_t *diskp, int fd, nvlist_t *attrs)
{
struct dk_minfo minfo;
/* Make sure media is inserted and spun up. */
if (fd >= 0 && media_read_info(fd, &minfo)) {
if (nvlist_add_uint32(attrs, DM_STATUS, DM_DISK_UP) != 0) {
return (ENOMEM);
}
} else {
/* Not ready, so either no media or dead. */
if (diskp->removable) {
/* This is a removable drive with no media. */
if (nvlist_add_uint32(attrs, DM_STATUS, DM_DISK_UP) != 0) {
return (ENOMEM);
}
} else {
/* not removable, so must be dead */
if (nvlist_add_uint32(attrs, DM_STATUS, DM_DISK_DOWN) != 0) {
return (ENOMEM);
}
}
}
return (0);
}
/*
* Encodes (packs) DFS information in 'info' into a flat
* buffer in a name-value format. This function allocates a
* buffer with appropriate size to contain all the information
* so the caller MUST free the allocated memory by calling free().
*/
static uint32_t
dfs_root_encode(dfs_info_t *info, char **buf, size_t *bufsz)
{
dfs_target_t *t;
nvlist_t *nvl;
int rc;
if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0)
return (ERROR_NOT_ENOUGH_MEMORY);
rc = nvlist_add_string(nvl, "comment", info->i_comment);
rc |= nvlist_add_string(nvl, "guid", info->i_guid);
rc |= nvlist_add_uint32(nvl, "state", info->i_state);
rc |= nvlist_add_uint32(nvl, "timeout", info->i_timeout);
rc |= nvlist_add_uint32(nvl, "propflags", info->i_propflags);
t = info->i_targets;
rc |= nvlist_add_string(nvl, "t_server", t->t_server);
rc |= nvlist_add_string(nvl, "t_share", t->t_share);
rc |= nvlist_add_uint32(nvl, "t_state", t->t_state);
rc |= nvlist_add_uint32(nvl, "t_priority_class",
t->t_priority.p_class);
rc |= nvlist_add_uint16(nvl, "t_priority_rank",
t->t_priority.p_rank);
if (rc == 0)
rc = nvlist_pack(nvl, buf, bufsz, NV_ENCODE_NATIVE, 0);
nvlist_free(nvl);
return ((rc == 0) ? ERROR_SUCCESS : ERROR_INTERNAL_ERROR);
}
static int ntfs_get_attr(fstyp_ntfs_t *h) {
if(h->vol == NULL) {
return 1;
}
(void) nvlist_add_string(h->attr, "vol_name", h->vol->vol_name);
(void) nvlist_add_uint32(h->attr, "vol_state", (uint32_t) h->vol->state);
(void) nvlist_add_uint32(h->attr, "vol_flags", (uint32_t) h->vol->flags);
return 0;
}
/*
* Load the current IE mode pages
*/
static int
load_ie_modepage(ds_scsi_info_t *sip)
{
struct scsi_ms_hdrs junk_hdrs;
int result;
uint_t skey, asc, ascq;
if (!(sip->si_supp_mode & MODEPAGE_SUPP_IEC))
return (0);
bzero(&sip->si_iec_current, sizeof (sip->si_iec_current));
bzero(&sip->si_iec_changeable, sizeof (sip->si_iec_changeable));
if ((result = scsi_mode_sense(sip,
MODEPAGE_INFO_EXCPT, PC_CURRENT, &sip->si_iec_current,
MODEPAGE_INFO_EXCPT_LEN, &sip->si_hdrs, &skey, &asc,
&ascq)) == 0) {
result = scsi_mode_sense(sip,
MODEPAGE_INFO_EXCPT, PC_CHANGEABLE,
&sip->si_iec_changeable,
MODEPAGE_INFO_EXCPT_LEN, &junk_hdrs, &skey, &asc, &ascq);
}
if (result != 0) {
printf("failed to get IEC modepage (KEY=0x%x "
"ASC=0x%x ASCQ=0x%x)", skey, asc, ascq);
sip->si_supp_mode &= ~MODEPAGE_SUPP_IEC;
} else {
if (nvlist_add_boolean_value(sip->si_state_iec,
"dexcpt", sip->si_iec_current.ie_dexcpt) != 0 ||
nvlist_add_boolean_value(sip->si_state_iec,
"logerr", sip->si_iec_current.ie_logerr) != 0 ||
nvlist_add_uint8(sip->si_state_iec,
"mrie", sip->si_iec_current.ie_mrie) != 0 ||
nvlist_add_boolean_value(sip->si_state_iec,
"test", sip->si_iec_current.ie_test) != 0 ||
nvlist_add_boolean_value(sip->si_state_iec,
"ewasc", sip->si_iec_current.ie_ewasc) != 0 ||
nvlist_add_boolean_value(sip->si_state_iec,
"perf", sip->si_iec_current.ie_perf) != 0 ||
nvlist_add_boolean_value(sip->si_state_iec,
"ebf", sip->si_iec_current.ie_ebf) != 0 ||
nvlist_add_uint32(sip->si_state_iec,
"interval-timer",
BE_32(sip->si_iec_current.ie_interval_timer)) != 0 ||
nvlist_add_uint32(sip->si_state_iec,
"report-count",
BE_32(sip->si_iec_current.ie_report_count)) != 0)
return (scsi_set_errno(sip, EDS_NOMEM));
}
return (0);
}
static int
cpu_present(fmd_hdl_t *hdl, nvlist_t *asru, uint32_t *cpuid)
{
nvlist_t *cp_asru;
uint32_t i;
if (nvlist_dup(asru, &cp_asru, 0) != 0) {
fmd_hdl_debug(hdl, "unable to alloc asru for thread\n");
return (-1);
}
for (i = *cpuid; i < *cpuid + UTS2_CPUS_PER_CHIP; i++) {
(void) nvlist_remove_all(cp_asru, FM_FMRI_CPU_ID);
if (nvlist_add_uint32(cp_asru, FM_FMRI_CPU_ID, i) == 0) {
if (fmd_nvl_fmri_present(hdl, cp_asru) &&
!fmd_nvl_fmri_unusable(hdl, cp_asru)) {
nvlist_free(cp_asru);
*cpuid = i;
return (0);
}
}
}
nvlist_free(cp_asru);
return (-1);
}
static int
update_stat32(nvlist_t *stats, char *attr, uint32_t value)
{
int32_t currval;
if (nvlist_lookup_int32(stats, attr, &currval) == 0) {
value += currval;
}
return (nvlist_add_uint32(stats, attr, value));
}
/*ARGSUSED*/
static int
disk_temp_reading(topo_mod_t *mod, tnode_t *node, topo_version_t vers,
nvlist_t *in, nvlist_t **out)
{
char *devid;
uint32_t temp;
dm_descriptor_t drive_descr = NULL;
nvlist_t *drive_stats, *pargs, *nvl;
int err;
if (vers > TOPO_METH_DISK_TEMP_VERSION)
return (topo_mod_seterrno(mod, ETOPO_METHOD_VERNEW));
if (nvlist_lookup_nvlist(in, TOPO_PROP_ARGS, &pargs) != 0 ||
nvlist_lookup_string(pargs, TOPO_IO_DEVID, &devid) != 0) {
topo_mod_dprintf(mod, "Failed to lookup %s arg",
TOPO_IO_DEVID);
return (topo_mod_seterrno(mod, EMOD_NVL_INVAL));
}
if ((drive_descr = dm_get_descriptor_by_name(DM_DRIVE, devid,
&err)) == NULL) {
topo_mod_dprintf(mod, "failed to get drive decriptor for %s",
devid);
return (topo_mod_seterrno(mod, EMOD_UNKNOWN));
}
if ((drive_stats = dm_get_stats(drive_descr, DM_DRV_STAT_TEMPERATURE,
&err)) == NULL ||
nvlist_lookup_uint32(drive_stats, DM_TEMPERATURE, &temp) != 0) {
topo_mod_dprintf(mod, "failed to read disk temp for %s",
devid);
dm_free_descriptor(drive_descr);
return (topo_mod_seterrno(mod, EMOD_UNKNOWN));
}
dm_free_descriptor(drive_descr);
if (topo_mod_nvalloc(mod, &nvl, NV_UNIQUE_NAME) != 0 ||
nvlist_add_string(nvl, TOPO_PROP_VAL_NAME,
TOPO_SENSOR_READING) != 0 ||
nvlist_add_uint32(nvl, TOPO_PROP_VAL_TYPE, TOPO_TYPE_DOUBLE) !=
0 || nvlist_add_double(nvl, TOPO_PROP_VAL_VAL, (double)temp) != 0) {
topo_mod_dprintf(mod, "Failed to allocate 'out' nvlist\n");
nvlist_free(nvl);
return (topo_mod_seterrno(mod, EMOD_NOMEM));
}
*out = nvl;
return (0);
}
static nvlist_t *
inhm_dimm(nhm_dimm_t *nhm_dimm, uint32_t node, uint8_t channel, uint32_t dimm)
{
nvlist_t *newdimm;
uint8_t t;
char sbuf[65];
(void) nvlist_alloc(&newdimm, NV_UNIQUE_NAME, KM_SLEEP);
(void) nvlist_add_uint32(newdimm, "dimm-number", dimm);
if (nhm_dimm->dimm_size >= 1024*1024*1024) {
(void) snprintf(sbuf, sizeof (sbuf), "%dG",
(int)(nhm_dimm->dimm_size / (1024*1024*1024)));
} else {
(void) snprintf(sbuf, sizeof (sbuf), "%dM",
(int)(nhm_dimm->dimm_size / (1024*1024)));
}
(void) nvlist_add_string(newdimm, "dimm-size", sbuf);
(void) nvlist_add_uint64(newdimm, "size", nhm_dimm->dimm_size);
(void) nvlist_add_uint32(newdimm, "nbanks", (uint32_t)nhm_dimm->nbanks);
(void) nvlist_add_uint32(newdimm, "ncolumn",
(uint32_t)nhm_dimm->ncolumn);
(void) nvlist_add_uint32(newdimm, "nrow", (uint32_t)nhm_dimm->nrow);
(void) nvlist_add_uint32(newdimm, "width", (uint32_t)nhm_dimm->width);
(void) nvlist_add_uint32(newdimm, "ranks", (uint32_t)nhm_dimm->nranks);
inhm_rank(newdimm, nhm_dimm, node, channel, dimm,
nhm_dimm->dimm_size / nhm_dimm->nranks);
if (nhm_dimm->manufacturer && nhm_dimm->manufacturer[0]) {
t = sizeof (nhm_dimm->manufacturer);
(void) strncpy(sbuf, nhm_dimm->manufacturer, t);
sbuf[t] = 0;
(void) nvlist_add_string(newdimm, "manufacturer", sbuf);
}
if (nhm_dimm->serial_number && nhm_dimm->serial_number[0]) {
t = sizeof (nhm_dimm->serial_number);
(void) strncpy(sbuf, nhm_dimm->serial_number, t);
sbuf[t] = 0;
(void) nvlist_add_string(newdimm, FM_FMRI_HC_SERIAL_ID, sbuf);
}
if (nhm_dimm->part_number && nhm_dimm->part_number[0]) {
t = sizeof (nhm_dimm->part_number);
(void) strncpy(sbuf, nhm_dimm->part_number, t);
sbuf[t] = 0;
(void) nvlist_add_string(newdimm, FM_FMRI_HC_PART, sbuf);
}
if (nhm_dimm->revision && nhm_dimm->revision[0]) {
t = sizeof (nhm_dimm->revision);
(void) strncpy(sbuf, nhm_dimm->revision, t);
sbuf[t] = 0;
(void) nvlist_add_string(newdimm, FM_FMRI_HC_REVISION, sbuf);
}
t = sizeof (nhm_dimm->label);
(void) strncpy(sbuf, nhm_dimm->label, t);
sbuf[t] = 0;
(void) nvlist_add_string(newdimm, FM_FAULT_FRU_LABEL, sbuf);
return (newdimm);
}
/*
* Set the named uint32 in the given nvlist_t.
*
* @param attrs
* the nvlist_t to search
*
* @param which
* the string key for this element in the list
*
* @param val
* the value to set
*
* @return 0
* if successful
*
* @return EINVAL
* if there is an invalid argument
*
* @return ENOMEM
* if there is insufficient memory
*/
int
set_uint32(
nvlist_t *attrs,
char *which,
uint32_t val)
{
int error = 0;
if ((error = nvlist_add_uint32(attrs, which, val)) != 0) {
volume_set_error(
gettext("nvlist_add_int32(%s) failed: %d\n"), which, error);
}
return (error);
}
int
_init(void)
{
const fm_vers_t *p;
int ret;
if ((ret = mod_install(&modlinkage)) == 0) {
(void) nvlist_alloc(&fm_vers_nvl, NV_UNIQUE_NAME, KM_SLEEP);
for (p = fm_versions; p->interface != NULL; p++)
(void) nvlist_add_uint32(fm_vers_nvl, p->interface,
p->version);
}
return (ret);
}
static int
set_retnvl(topo_mod_t *mod, nvlist_t **out, const char *retname, uint32_t ret)
{
nvlist_t *nvl;
topo_mod_dprintf(mod, "topo method set \"%s\" = %u\n", retname, ret);
if (topo_mod_nvalloc(mod, &nvl, NV_UNIQUE_NAME) < 0)
return (topo_mod_seterrno(mod, EMOD_NOMEM));
if (nvlist_add_uint32(nvl, retname, ret) != 0) {
nvlist_free(nvl);
return (topo_mod_seterrno(mod, EMOD_NVL_INVAL));
}
*out = nvl;
return (0);
}
/*
* fps_fmri_cpu_set(nvlist_t *fmri_cpu, uint32_t cpu_id)
* adds the resource data to fmri_cpu.
*/
static int
fps_fmri_cpu_set(nvlist_t *fmri_cpu, uint32_t cpu_id)
{
if (fmri_cpu == NULL)
return (1);
if (nvlist_add_uint8(fmri_cpu, FM_VERSION,
FM_CPU_SCHEME_VERSION) != 0)
return (1);
if (nvlist_add_string(fmri_cpu, FM_FMRI_SCHEME,
FM_FMRI_SCHEME_CPU) != 0)
return (1);
if (nvlist_add_uint32(fmri_cpu, FM_FMRI_CPU_ID, cpu_id) != 0)
return (1);
return (0);
}
nvlist_t *
bus_get_attributes(descriptor_t *dp, int *errp)
{
bus_t *bp;
nvlist_t *attrs;
if (nvlist_alloc(&attrs, NVATTRS, 0) != 0) {
*errp = ENOMEM;
return (NULL);
}
bp = dp->p.bus;
if (nvlist_add_string(attrs, DM_BTYPE, bp->btype) != 0) {
nvlist_free(attrs);
*errp = ENOMEM;
return (NULL);
}
if (bp->freq != 0) {
if (nvlist_add_uint32(attrs, DM_CLOCK, bp->freq) != 0) {
nvlist_free(attrs);
*errp = ENOMEM;
return (NULL);
}
}
if (bp->pname != NULL) {
if (nvlist_add_string(attrs, DM_PNAME, bp->pname) != 0) {
nvlist_free(attrs);
*errp = ENOMEM;
return (NULL);
}
}
*errp = 0;
return (attrs);
}
/*
* topo_fmri_create
*
* If possible, creates an FMRI of the requested version in the
* requested scheme. Args are passed as part of the inputs to the
* fmri-create method of the scheme.
*/
nvlist_t *
topo_fmri_create(topo_hdl_t *thp, const char *scheme, const char *name,
topo_instance_t inst, nvlist_t *nvl, int *err)
{
nvlist_t *ins;
nvlist_t *out;
tnode_t *rnode;
ins = out = NULL;
if ((rnode = topo_hdl_root(thp, scheme)) == NULL)
return (set_nverror(thp, ETOPO_METHOD_NOTSUP, err,
TOPO_METH_FMRI, NULL));
if ((*err = topo_hdl_nvalloc(thp, &ins, NV_UNIQUE_NAME)) != 0)
return (set_nverror(thp, ETOPO_FMRI_NVL, err,
TOPO_METH_FMRI, NULL));
if (nvlist_add_string(ins, TOPO_METH_FMRI_ARG_NAME, name) != 0 ||
nvlist_add_uint32(ins, TOPO_METH_FMRI_ARG_INST, inst) != 0) {
return (set_nverror(thp, ETOPO_FMRI_NVL, err,
TOPO_METH_FMRI, ins));
}
if (nvl != NULL &&
nvlist_add_nvlist(ins, TOPO_METH_FMRI_ARG_NVL, nvl) != 0) {
return (set_nverror(thp, ETOPO_FMRI_NVL, err,
TOPO_METH_FMRI, ins));
}
if (topo_method_invoke(rnode,
TOPO_METH_FMRI, TOPO_METH_FMRI_VERSION, ins, &out, err) != 0) {
return (set_nverror(thp, *err, err, TOPO_METH_FMRI, ins));
}
nvlist_free(ins);
return (out);
}
static void
inhm_vrank(nvlist_t *vrank, int num, uint64_t dimm_base, uint64_t limit,
uint32_t sinterleave, uint32_t cinterleave, uint32_t rinterleave,
uint32_t sway, uint32_t cway, uint32_t rway)
{
char buf[128];
(void) snprintf(buf, sizeof (buf), "dimm-rank-base-%d", num);
(void) nvlist_add_uint64(vrank, buf, dimm_base);
(void) snprintf(buf, sizeof (buf), "dimm-rank-limit-%d", num);
(void) nvlist_add_uint64(vrank, buf, dimm_base + limit);
if (sinterleave > 1) {
(void) snprintf(buf, sizeof (buf), "dimm-socket-interleave-%d",
num);
(void) nvlist_add_uint32(vrank, buf, sinterleave);
(void) snprintf(buf, sizeof (buf),
"dimm-socket-interleave-way-%d", num);
(void) nvlist_add_uint32(vrank, buf, sway);
}
if (cinterleave > 1) {
(void) snprintf(buf, sizeof (buf), "dimm-channel-interleave-%d",
num);
(void) nvlist_add_uint32(vrank, buf, cinterleave);
(void) snprintf(buf, sizeof (buf),
"dimm-channel-interleave-way-%d", num);
(void) nvlist_add_uint32(vrank, buf, cway);
}
if (rinterleave > 1) {
(void) snprintf(buf, sizeof (buf), "dimm-rank-interleave-%d",
num);
(void) nvlist_add_uint32(vrank, buf, rinterleave);
(void) snprintf(buf, sizeof (buf),
"dimm-rank-interleave-way-%d", num);
(void) nvlist_add_uint32(vrank, buf, rway);
}
}
void
fnvlist_add_uint32(nvlist_t *nvl, const char *name, uint32_t val)
{
VERIFY0(nvlist_add_uint32(nvl, name, val));
}
/* ARGSUSED */
static int
tokenmt_info(ipp_action_id_t aid, int (*fn)(nvlist_t *, void *), void *arg,
ipp_flags_t flags)
{
nvlist_t *nvlp;
tokenmt_data_t *tokenmt_data;
tokenmt_cfg_t *cfg_parms;
char *next_action;
int32_t dscp_to_colour[64];
int rc;
tokenmt_data = (tokenmt_data_t *)ipp_action_get_ptr(aid);
ASSERT(tokenmt_data != NULL);
cfg_parms = tokenmt_data->cfg_parms;
/* allocate nvlist to be passed back */
if ((rc = nvlist_alloc(&nvlp, NV_UNIQUE_NAME, KM_NOSLEEP)) != 0) {
tokenmt0dbg(("tokenmt_info: memory allocation failure\n"));
return (rc);
}
/* look up red next action with the next action id */
if ((rc = ipp_action_name(cfg_parms->red_action, &next_action)) != 0) {
tokenmt0dbg(("tokenmt_info: red_action not available\n"));
nvlist_free(nvlp);
return (rc);
}
/* add next action name */
if ((rc = nvlist_add_string(nvlp, TOKENMT_RED_ACTION_NAME,
next_action)) != 0) {
nvlist_free(nvlp);
tokenmt0dbg(("tokenmt_info: error adding red_action\n"));
kmem_free(next_action, (strlen(next_action) + 1));
return (rc);
}
/* free action name */
kmem_free(next_action, (strlen(next_action) + 1));
/* look up yellow next action with the next action id */
if (cfg_parms->yellow_action != TOKENMT_NO_ACTION) {
if ((rc = ipp_action_name(cfg_parms->yellow_action,
&next_action)) != 0) {
tokenmt0dbg(("tokenmt_info: yellow_action not "\
"available\n"));
nvlist_free(nvlp);
return (rc);
}
/* add next action name */
if ((rc = nvlist_add_string(nvlp, TOKENMT_YELLOW_ACTION_NAME,
next_action)) != 0) {
nvlist_free(nvlp);
tokenmt0dbg(("tokenmt_info: error adding "\
"yellow_action\n"));
kmem_free(next_action, (strlen(next_action) + 1));
return (rc);
}
/* free action name */
kmem_free(next_action, (strlen(next_action) + 1));
}
/* look up green next action with the next action id */
if ((rc = ipp_action_name(cfg_parms->green_action,
&next_action)) != 0) {
tokenmt0dbg(("tokenmt_info: green_action not available\n"));
nvlist_free(nvlp);
return (rc);
}
/* add next action name */
if ((rc = nvlist_add_string(nvlp, TOKENMT_GREEN_ACTION_NAME,
next_action)) != 0) {
nvlist_free(nvlp);
tokenmt0dbg(("tokenmt_info: error adding green_action\n"));
kmem_free(next_action, (strlen(next_action) + 1));
return (rc);
}
/* free action name */
kmem_free(next_action, (strlen(next_action) + 1));
/* add config type */
if ((rc = nvlist_add_byte(nvlp, IPP_CONFIG_TYPE, IPP_SET)) != 0) {
tokenmt0dbg(("tokenmt_info: error adding config_type\n"));
nvlist_free(nvlp);
return (rc);
}
/* add committed_rate */
if ((rc = nvlist_add_uint32(nvlp, TOKENMT_COMMITTED_RATE,
cfg_parms->committed_rate)) != 0) {
tokenmt0dbg(("tokenmt_info: error adding committed_rate\n"));
nvlist_free(nvlp);
return (rc);
}
if (cfg_parms->tokenmt_type == TRTCL_TOKENMT) {
/* add peak rate */
if ((rc = nvlist_add_uint32(nvlp, TOKENMT_PEAK_RATE,
cfg_parms->peak_rate)) != 0) {
tokenmt0dbg(("tokenmt_info: error adding peak_rate\n"));
nvlist_free(nvlp);
return (rc);
}
}
/* add committed_burst */
if ((rc = nvlist_add_uint32(nvlp, TOKENMT_COMMITTED_BURST,
cfg_parms->committed_burst)) != 0) {
tokenmt0dbg(("tokenmt_info: error adding committed_burst\n"));
nvlist_free(nvlp);
return (rc);
}
/* add peak_burst */
if (cfg_parms->peak_burst != 0) {
if ((rc = nvlist_add_uint32(nvlp, TOKENMT_PEAK_BURST,
cfg_parms->peak_burst)) != 0) {
tokenmt0dbg(("tokenmt_info: error adding peak "\
"burst\n"));
nvlist_free(nvlp);
return (rc);
}
}
/* add colour aware */
if ((rc = nvlist_add_uint32(nvlp, TOKENMT_COLOUR_AWARE,
cfg_parms->colour_aware)) != 0) {
tokenmt0dbg(("tokenmt_info: error adding mode\n"));
nvlist_free(nvlp);
return (rc);
}
if (cfg_parms->colour_aware) {
bcopy(cfg_parms->dscp_to_colour, dscp_to_colour,
sizeof (cfg_parms->dscp_to_colour));
if ((rc = nvlist_add_int32_array(nvlp, TOKENMT_COLOUR_MAP,
dscp_to_colour, 64)) != 0) {
tokenmt0dbg(("tokenmt_info: error adding colour "\
"array\n"));
nvlist_free(nvlp);
return (rc);
}
}
if ((rc = nvlist_add_uint32(nvlp, IPP_ACTION_STATS_ENABLE,
(uint32_t)cfg_parms->stats)) != 0) {
tokenmt0dbg(("tokenmt_info: error adding stats status\n"));
nvlist_free(nvlp);
return (rc);
}
/* call back with nvlist */
rc = fn(nvlp, arg);
nvlist_free(nvlp);
return (rc);
}
int
main(int argc, char *argv[])
{
fmd_msg_hdl_t *h;
pid_t pid;
int i, err = 0;
char *s;
nvlist_t *auth, *fmri, *list, *test_arr[TEST_ARR_SZ];
const char *code = "TEST-8000-08";
int64_t tod[] = { 0x9400000, 0 };
if (argc > 1) {
(void) fprintf(stderr, "Usage: %s\n", argv[0]);
return (2);
}
/*
* Build up a valid list.suspect event for a fictional diagnosis
* using a diagnosis code from our test dictionary so we can format
* messages.
*/
if (nvlist_alloc(&auth, NV_UNIQUE_NAME, 0) != 0 ||
nvlist_alloc(&fmri, NV_UNIQUE_NAME, 0) != 0 ||
nvlist_alloc(&list, NV_UNIQUE_NAME, 0) != 0) {
(void) fprintf(stderr, "%s: nvlist_alloc failed\n", argv[0]);
return (1);
}
err |= nvlist_add_uint8(auth, FM_VERSION, FM_FMRI_AUTH_VERSION);
err |= nvlist_add_string(auth, FM_FMRI_AUTH_PRODUCT, "product");
err |= nvlist_add_string(auth, FM_FMRI_AUTH_PRODUCT_SN, "product_sn");
err |= nvlist_add_string(auth, FM_FMRI_AUTH_CHASSIS, "chassis");
err |= nvlist_add_string(auth, FM_FMRI_AUTH_DOMAIN, "domain");
err |= nvlist_add_string(auth, FM_FMRI_AUTH_SERVER, "server");
if (err != 0) {
(void) fprintf(stderr, "%s: failed to build auth nvlist: %s\n",
argv[0], strerror(err));
return (1);
}
err |= nvlist_add_uint8(fmri, FM_VERSION, FM_FMD_SCHEME_VERSION);
err |= nvlist_add_string(fmri, FM_FMRI_SCHEME, FM_FMRI_SCHEME_FMD);
err |= nvlist_add_nvlist(fmri, FM_FMRI_AUTHORITY, auth);
err |= nvlist_add_string(fmri, FM_FMRI_FMD_NAME, "fmd_msg_test");
err |= nvlist_add_string(fmri, FM_FMRI_FMD_VERSION, "1.0");
if (err != 0) {
(void) fprintf(stderr, "%s: failed to build fmri nvlist: %s\n",
argv[0], strerror(err));
return (1);
}
err |= nvlist_add_uint8(list, FM_VERSION, FM_SUSPECT_VERSION);
err |= nvlist_add_string(list, FM_CLASS, FM_LIST_SUSPECT_CLASS);
err |= nvlist_add_string(list, FM_SUSPECT_UUID, "12345678");
err |= nvlist_add_string(list, FM_SUSPECT_DIAG_CODE, code);
err |= nvlist_add_int64_array(list, FM_SUSPECT_DIAG_TIME, tod, 2);
err |= nvlist_add_nvlist(list, FM_SUSPECT_DE, fmri);
err |= nvlist_add_uint32(list, FM_SUSPECT_FAULT_SZ, 0);
/*
* Add a contrived nvlist array to our list.suspect so that we can
* exercise the expansion syntax for dereferencing nvlist array members
*/
for (i = 0; i < TEST_ARR_SZ; i++) {
if (nvlist_alloc(&test_arr[i], NV_UNIQUE_NAME, 0) != 0) {
(void) fprintf(stderr, "%s: failed to alloc nvlist "
"array: %s\n", argv[0], strerror(err));
return (1);
}
err |= nvlist_add_uint8(test_arr[i], "index", i);
}
err |= nvlist_add_nvlist_array(list, "test_arr", test_arr, TEST_ARR_SZ);
if (err != 0) {
(void) fprintf(stderr, "%s: failed to build list nvlist: %s\n",
argv[0], strerror(err));
return (1);
}
/*
* Now initialize the libfmd_msg library for testing, using the message
* catalogs found in the proto area of the current workspace.
*/
if ((h = fmd_msg_init(getenv("ROOT"), FMD_MSG_VERSION)) == NULL) {
(void) fprintf(stderr, "%s: fmd_msg_init failed: %s\n",
argv[0], strerror(errno));
return (1);
}
/*
* Test 0: Verify that both fmd_msg_getitem_id and fmd_msg_gettext_id
* return NULL and EINVAL for an illegal message code, and NULL
* and ENOENT for a valid but not defined message code.
*/
s = fmd_msg_getitem_id(h, NULL, "I_AM_NOT_VALID", 0);
if (s != NULL || errno != EINVAL) {
(void) fprintf(stderr, "%s: test0 FAIL: illegal code returned "
"s = %p, errno = %d\n", argv[0], (void *)s, errno);
return (1);
}
s = fmd_msg_gettext_id(h, NULL, "I_AM_NOT_VALID");
if (s != NULL || errno != EINVAL) {
(void) fprintf(stderr, "%s: test0 FAIL: illegal code returned "
"s = %p, errno = %d\n", argv[0], (void *)s, errno);
return (1);
}
s = fmd_msg_getitem_id(h, NULL, "I_AM_NOT_HERE-0000-0000", 0);
if (s != NULL || errno != ENOENT) {
(void) fprintf(stderr, "%s: test0 FAIL: missing code returned "
"s = %p, errno = %d\n", argv[0], (void *)s, errno);
return (1);
}
s = fmd_msg_gettext_id(h, NULL, "I_AM_NOT_HERE-0000-0000");
if (s != NULL || errno != ENOENT) {
(void) fprintf(stderr, "%s: test0 FAIL: missing code returned "
"s = %p, errno = %d\n", argv[0], (void *)s, errno);
return (1);
}
/*
* Test 1: Use fmd_msg_getitem_id to retrieve the item strings for
* a known message code without having any actual event handle.
*/
for (i = 0; i < FMD_MSG_ITEM_MAX; i++) {
if ((s = fmd_msg_getitem_id(h, NULL, code, i)) == NULL) {
(void) fprintf(stderr, "%s: fmd_msg_getitem_id failed "
"for %s, item %d: %s\n",
argv[0], code, i, strerror(errno));
}
(void) printf("code %s item %d = <<%s>>\n", code, i, s);
free(s);
}
/*
* Test 2: Use fmd_msg_gettext_id to retrieve the complete message for
* a known message code without having any actual event handle.
*/
if ((s = fmd_msg_gettext_id(h, NULL, code)) == NULL) {
(void) fprintf(stderr, "%s: fmd_msg_gettext_id failed for %s: "
"%s\n", argv[0], code, strerror(errno));
return (1);
}
(void) printf("%s\n", s);
free(s);
/*
* Test 3: Use fmd_msg_getitem_nv to retrieve the item strings for
* our list.suspect event handle.
*/
for (i = 0; i < FMD_MSG_ITEM_MAX; i++) {
if ((s = fmd_msg_getitem_nv(h, NULL, list, i)) == NULL) {
(void) fprintf(stderr, "%s: fmd_msg_getitem_nv failed "
"for %s, item %d: %s\n",
argv[0], code, i, strerror(errno));
}
(void) printf("code %s item %d = <<%s>>\n", code, i, s);
free(s);
}
/*
* Test 4: Use fmd_msg_getitem_nv to retrieve the complete message for
* a known message code using our list.suspect event handle.
*/
if ((s = fmd_msg_gettext_nv(h, NULL, list)) == NULL) {
(void) fprintf(stderr, "%s: fmd_msg_gettext_nv failed for %s: "
"%s\n", argv[0], code, strerror(errno));
return (1);
}
(void) printf("%s\n", s);
free(s);
/*
* Test 5: Use fmd_msg_getitem_nv to retrieve the complete message for
* a known message code using our list.suspect event handle, but this
* time set the URL to our own customized URL. Our contrived message
* has been designed to exercise the key aspects of the variable
* expansion syntax.
*/
if (fmd_msg_url_set(h, "http://foo.bar.com/") != 0) {
(void) fprintf(stderr, "%s: fmd_msg_url_set failed: %s\n",
argv[0], strerror(errno));
}
if ((s = fmd_msg_gettext_nv(h, NULL, list)) == NULL) {
(void) fprintf(stderr, "%s: fmd_msg_gettext_nv failed for %s: "
"%s\n", argv[0], code, strerror(errno));
return (1);
}
(void) printf("%s\n", s);
free(s);
for (i = 0; i < TEST_ARR_SZ; i++)
nvlist_free(test_arr[i]);
nvlist_free(fmri);
nvlist_free(auth);
nvlist_free(list);
fmd_msg_fini(h); /* free library state before dumping core */
pid = fork(); /* fork into background to not bother make(1) */
switch (pid) {
case -1:
(void) fprintf(stderr, "FAIL (failed to fork)\n");
return (1);
case 0:
abort();
return (1);
}
if (waitpid(pid, &err, 0) == -1) {
(void) fprintf(stderr, "FAIL (failed to wait for %d: %s)\n",
(int)pid, strerror(errno));
return (1);
}
if (WIFSIGNALED(err) == 0 || WTERMSIG(err) != SIGABRT) {
(void) fprintf(stderr, "FAIL (child did not SIGABRT)\n");
return (1);
}
if (!WCOREDUMP(err)) {
(void) fprintf(stderr, "FAIL (no core generated)\n");
return (1);
}
(void) fprintf(stderr, "done\n");
return (0);
}
/* ARGSUSED */
static int
xattr_fill_nvlist(vnode_t *vp, xattr_view_t xattr_view, nvlist_t *nvlp,
cred_t *cr, caller_context_t *ct)
{
int error;
f_attr_t attr;
uint64_t fsid;
xvattr_t xvattr;
xoptattr_t *xoap; /* Pointer to optional attributes */
vnode_t *ppvp;
const char *domain;
uint32_t rid;
xva_init(&xvattr);
if ((xoap = xva_getxoptattr(&xvattr)) == NULL)
return (EINVAL);
/*
* For detecting ephemeral uid/gid
*/
xvattr.xva_vattr.va_mask |= (AT_UID|AT_GID);
/*
* We need to access the real fs object.
* vp points to a GFS file; ppvp points to the real object.
*/
ppvp = gfs_file_parent(gfs_file_parent(vp));
/*
* Iterate through the attrs associated with this view
*/
for (attr = 0; attr < F_ATTR_ALL; attr++) {
if (xattr_view != attr_to_xattr_view(attr)) {
continue;
}
switch (attr) {
case F_SYSTEM:
XVA_SET_REQ(&xvattr, XAT_SYSTEM);
break;
case F_READONLY:
XVA_SET_REQ(&xvattr, XAT_READONLY);
break;
case F_HIDDEN:
XVA_SET_REQ(&xvattr, XAT_HIDDEN);
break;
case F_ARCHIVE:
XVA_SET_REQ(&xvattr, XAT_ARCHIVE);
break;
case F_IMMUTABLE:
XVA_SET_REQ(&xvattr, XAT_IMMUTABLE);
break;
case F_APPENDONLY:
XVA_SET_REQ(&xvattr, XAT_APPENDONLY);
break;
case F_NOUNLINK:
XVA_SET_REQ(&xvattr, XAT_NOUNLINK);
break;
case F_OPAQUE:
XVA_SET_REQ(&xvattr, XAT_OPAQUE);
break;
case F_NODUMP:
XVA_SET_REQ(&xvattr, XAT_NODUMP);
break;
case F_AV_QUARANTINED:
XVA_SET_REQ(&xvattr, XAT_AV_QUARANTINED);
break;
case F_AV_MODIFIED:
XVA_SET_REQ(&xvattr, XAT_AV_MODIFIED);
break;
case F_AV_SCANSTAMP:
if (ppvp->v_type == VREG)
XVA_SET_REQ(&xvattr, XAT_AV_SCANSTAMP);
break;
case F_CRTIME:
XVA_SET_REQ(&xvattr, XAT_CREATETIME);
break;
case F_FSID:
fsid = (((uint64_t)vp->v_vfsp->vfs_fsid.val[0] << 32) |
(uint64_t)(vp->v_vfsp->vfs_fsid.val[1] &
0xffffffff));
VERIFY(nvlist_add_uint64(nvlp, attr_to_name(attr),
fsid) == 0);
break;
case F_REPARSE:
XVA_SET_REQ(&xvattr, XAT_REPARSE);
break;
case F_GEN:
XVA_SET_REQ(&xvattr, XAT_GEN);
break;
case F_OFFLINE:
XVA_SET_REQ(&xvattr, XAT_OFFLINE);
break;
case F_SPARSE:
XVA_SET_REQ(&xvattr, XAT_SPARSE);
break;
default:
break;
}
}
error = VOP_GETATTR(ppvp, &xvattr.xva_vattr, 0, cr, ct);
if (error)
return (error);
/*
* Process all the optional attributes together here. Notice that
* xoap was set when the optional attribute bits were set above.
*/
if ((xvattr.xva_vattr.va_mask & AT_XVATTR) && xoap) {
if (XVA_ISSET_RTN(&xvattr, XAT_READONLY)) {
VERIFY(nvlist_add_boolean_value(nvlp,
attr_to_name(F_READONLY),
xoap->xoa_readonly) == 0);
}
if (XVA_ISSET_RTN(&xvattr, XAT_HIDDEN)) {
VERIFY(nvlist_add_boolean_value(nvlp,
attr_to_name(F_HIDDEN),
xoap->xoa_hidden) == 0);
}
if (XVA_ISSET_RTN(&xvattr, XAT_SYSTEM)) {
VERIFY(nvlist_add_boolean_value(nvlp,
attr_to_name(F_SYSTEM),
xoap->xoa_system) == 0);
}
if (XVA_ISSET_RTN(&xvattr, XAT_ARCHIVE)) {
VERIFY(nvlist_add_boolean_value(nvlp,
attr_to_name(F_ARCHIVE),
xoap->xoa_archive) == 0);
}
if (XVA_ISSET_RTN(&xvattr, XAT_IMMUTABLE)) {
VERIFY(nvlist_add_boolean_value(nvlp,
attr_to_name(F_IMMUTABLE),
xoap->xoa_immutable) == 0);
}
if (XVA_ISSET_RTN(&xvattr, XAT_NOUNLINK)) {
VERIFY(nvlist_add_boolean_value(nvlp,
attr_to_name(F_NOUNLINK),
xoap->xoa_nounlink) == 0);
}
if (XVA_ISSET_RTN(&xvattr, XAT_APPENDONLY)) {
VERIFY(nvlist_add_boolean_value(nvlp,
attr_to_name(F_APPENDONLY),
xoap->xoa_appendonly) == 0);
}
if (XVA_ISSET_RTN(&xvattr, XAT_NODUMP)) {
VERIFY(nvlist_add_boolean_value(nvlp,
attr_to_name(F_NODUMP),
xoap->xoa_nodump) == 0);
}
if (XVA_ISSET_RTN(&xvattr, XAT_OPAQUE)) {
VERIFY(nvlist_add_boolean_value(nvlp,
attr_to_name(F_OPAQUE),
xoap->xoa_opaque) == 0);
}
if (XVA_ISSET_RTN(&xvattr, XAT_AV_QUARANTINED)) {
VERIFY(nvlist_add_boolean_value(nvlp,
attr_to_name(F_AV_QUARANTINED),
xoap->xoa_av_quarantined) == 0);
}
if (XVA_ISSET_RTN(&xvattr, XAT_AV_MODIFIED)) {
VERIFY(nvlist_add_boolean_value(nvlp,
attr_to_name(F_AV_MODIFIED),
xoap->xoa_av_modified) == 0);
}
if (XVA_ISSET_RTN(&xvattr, XAT_AV_SCANSTAMP)) {
VERIFY(nvlist_add_uint8_array(nvlp,
attr_to_name(F_AV_SCANSTAMP),
xoap->xoa_av_scanstamp,
sizeof (xoap->xoa_av_scanstamp)) == 0);
}
if (XVA_ISSET_RTN(&xvattr, XAT_CREATETIME)) {
VERIFY(nvlist_add_uint64_array(nvlp,
attr_to_name(F_CRTIME),
(uint64_t *)&(xoap->xoa_createtime),
sizeof (xoap->xoa_createtime) /
sizeof (uint64_t)) == 0);
}
if (XVA_ISSET_RTN(&xvattr, XAT_REPARSE)) {
VERIFY(nvlist_add_boolean_value(nvlp,
attr_to_name(F_REPARSE),
xoap->xoa_reparse) == 0);
}
if (XVA_ISSET_RTN(&xvattr, XAT_GEN)) {
VERIFY(nvlist_add_uint64(nvlp,
attr_to_name(F_GEN),
xoap->xoa_generation) == 0);
}
if (XVA_ISSET_RTN(&xvattr, XAT_OFFLINE)) {
VERIFY(nvlist_add_boolean_value(nvlp,
attr_to_name(F_OFFLINE),
xoap->xoa_offline) == 0);
}
if (XVA_ISSET_RTN(&xvattr, XAT_SPARSE)) {
VERIFY(nvlist_add_boolean_value(nvlp,
attr_to_name(F_SPARSE),
xoap->xoa_sparse) == 0);
}
}
/*
* Check for optional ownersid/groupsid
*/
if (xvattr.xva_vattr.va_uid > MAXUID) {
nvlist_t *nvl_sid;
if (nvlist_alloc(&nvl_sid, NV_UNIQUE_NAME, KM_SLEEP))
return (ENOMEM);
if (kidmap_getsidbyuid(crgetzone(cr), xvattr.xva_vattr.va_uid,
&domain, &rid) == 0) {
VERIFY(nvlist_add_string(nvl_sid,
SID_DOMAIN, domain) == 0);
VERIFY(nvlist_add_uint32(nvl_sid, SID_RID, rid) == 0);
VERIFY(nvlist_add_nvlist(nvlp, attr_to_name(F_OWNERSID),
nvl_sid) == 0);
}
nvlist_free(nvl_sid);
}
if (xvattr.xva_vattr.va_gid > MAXUID) {
nvlist_t *nvl_sid;
if (nvlist_alloc(&nvl_sid, NV_UNIQUE_NAME, KM_SLEEP))
return (ENOMEM);
if (kidmap_getsidbygid(crgetzone(cr), xvattr.xva_vattr.va_gid,
&domain, &rid) == 0) {
VERIFY(nvlist_add_string(nvl_sid,
SID_DOMAIN, domain) == 0);
VERIFY(nvlist_add_uint32(nvl_sid, SID_RID, rid) == 0);
VERIFY(nvlist_add_nvlist(nvlp, attr_to_name(F_GROUPSID),
nvl_sid) == 0);
}
nvlist_free(nvl_sid);
}
return (0);
}
/* ARGSUSED */
static int
tswtcl_info(ipp_action_id_t aid, int (*fn)(nvlist_t *, void *), void *arg,
ipp_flags_t flags)
{
nvlist_t *nvlp;
tswtcl_data_t *tswtcl_data;
tswtcl_cfg_t *cfg_parms;
char *next_action;
int rc;
tswtcl_data = (tswtcl_data_t *)ipp_action_get_ptr(aid);
ASSERT(tswtcl_data != NULL);
cfg_parms = tswtcl_data->cfg_parms;
/* allocate nvlist to be passed back */
if ((rc = nvlist_alloc(&nvlp, NV_UNIQUE_NAME, KM_NOSLEEP)) != 0) {
tswtcl0dbg(("tswtcl_info: memory allocation failure\n"));
return (rc);
}
/* look up red next action with the next action id */
if ((rc = ipp_action_name(cfg_parms->red_action, &next_action)) != 0) {
tswtcl0dbg(("tswtcl_info: red action not available\n"));
nvlist_free(nvlp);
return (rc);
}
/* add next action name */
if ((rc = nvlist_add_string(nvlp, TSWTCL_RED_ACTION_NAME,
next_action)) != 0) {
tswtcl0dbg(("tswtcl_info: error adding\n"));
nvlist_free(nvlp);
kmem_free(next_action, (strlen(next_action) + 1));
return (rc);
}
/* free action name */
kmem_free(next_action, (strlen(next_action) + 1));
/* look up yellow next action with the next action id */
if ((rc = ipp_action_name(cfg_parms->yellow_action,
&next_action)) != 0) {
tswtcl0dbg(("tswtcl_info: yellow action not available\n"));
nvlist_free(nvlp);
return (rc);
}
/* add next action name */
if ((rc = nvlist_add_string(nvlp, TSWTCL_YELLOW_ACTION_NAME,
next_action)) != 0) {
tswtcl0dbg(("tswtcl_info: error adding yellow action\n"));
nvlist_free(nvlp);
kmem_free(next_action, (strlen(next_action) + 1));
return (rc);
}
/* free action name */
kmem_free(next_action, (strlen(next_action) + 1));
/* look up green next action with the next action id */
if ((rc = ipp_action_name(cfg_parms->green_action,
&next_action)) != 0) {
tswtcl0dbg(("tswtcl_info: green action not available\n"));
nvlist_free(nvlp);
return (rc);
}
/* add next action name */
if ((rc = nvlist_add_string(nvlp, TSWTCL_GREEN_ACTION_NAME,
next_action)) != 0) {
tswtcl0dbg(("tswtcl_info: error adding green action\n"));
nvlist_free(nvlp);
kmem_free(next_action, (strlen(next_action) + 1));
return (rc);
}
/* free action name */
kmem_free(next_action, (strlen(next_action) + 1));
/* add config type */
if ((rc = nvlist_add_byte(nvlp, IPP_CONFIG_TYPE, IPP_SET)) != 0) {
tswtcl0dbg(("tswtcl_info: error adding config_type\n"));
nvlist_free(nvlp);
return (rc);
}
/* add committed_rate */
if ((rc = nvlist_add_uint32(nvlp, TSWTCL_COMMITTED_RATE,
cfg_parms->committed_rate)) != 0) {
tswtcl0dbg(("tswtcl_info: error adding committed_rate\n"));
nvlist_free(nvlp);
return (rc);
}
/* add peak_rate */
if ((rc = nvlist_add_uint32(nvlp, TSWTCL_PEAK_RATE,
cfg_parms->peak_rate)) != 0) {
tswtcl0dbg(("tswtcl_info: error adding peak_rate\n"));
nvlist_free(nvlp);
return (rc);
}
/* add window */
if ((rc = nvlist_add_uint32(nvlp, TSWTCL_WINDOW,
cfg_parms->window)) != 0) {
tswtcl0dbg(("tswtcl_info: error adding window\n"));
nvlist_free(nvlp);
return (rc);
}
if ((rc = nvlist_add_uint32(nvlp, IPP_ACTION_STATS_ENABLE,
(uint32_t)(uintptr_t)tswtcl_data->stats)) != 0) {
tswtcl0dbg(("tswtcl_info: error adding stats status\n"));
nvlist_free(nvlp);
return (rc);
}
/* call back with nvlist */
rc = fn(nvlp, arg);
nvlist_free(nvlp);
return (rc);
}
nvlist_t *
cmd_mkboard_fru(fmd_hdl_t *hdl, char *frustr, char *serialstr, char *partstr) {
char *nac, *nac_name;
int n, i, len;
nvlist_t *fru, **hc_list;
if (frustr == NULL)
return (NULL);
if ((nac_name = strstr(frustr, "MB")) == NULL)
return (NULL);
len = strlen(nac_name) + 1;
nac = fmd_hdl_zalloc(hdl, len, FMD_SLEEP);
(void) strcpy(nac, nac_name);
n = cmd_count_components(nac, '/');
fmd_hdl_debug(hdl, "cmd_mkboard_fru: nac=%s components=%d\n", nac, n);
hc_list = fmd_hdl_zalloc(hdl, sizeof (nvlist_t *)*n, FMD_SLEEP);
for (i = 0; i < n; i++) {
(void) nvlist_alloc(&hc_list[i],
NV_UNIQUE_NAME|NV_UNIQUE_NAME_TYPE, 0);
}
if (cmd_breakup_components(nac, "/", hc_list) < 0) {
for (i = 0; i < n; i++) {
if (hc_list[i] != NULL)
nvlist_free(hc_list[i]);
}
fmd_hdl_free(hdl, hc_list, sizeof (nvlist_t *)*n);
fmd_hdl_free(hdl, nac, len);
return (NULL);
}
if (nvlist_alloc(&fru, NV_UNIQUE_NAME, 0) != 0) {
for (i = 0; i < n; i++) {
if (hc_list[i] != NULL)
nvlist_free(hc_list[i]);
}
fmd_hdl_free(hdl, hc_list, sizeof (nvlist_t *)*n);
fmd_hdl_free(hdl, nac, len);
return (NULL);
}
if (nvlist_add_uint8(fru, FM_VERSION, FM_HC_SCHEME_VERSION) != 0 ||
nvlist_add_string(fru, FM_FMRI_SCHEME, FM_FMRI_SCHEME_HC) != 0 ||
nvlist_add_string(fru, FM_FMRI_HC_ROOT, "") != 0 ||
nvlist_add_uint32(fru, FM_FMRI_HC_LIST_SZ, n) != 0 ||
nvlist_add_nvlist_array(fru, FM_FMRI_HC_LIST, hc_list, n) != 0) {
for (i = 0; i < n; i++) {
if (hc_list[i] != NULL)
nvlist_free(hc_list[i]);
}
fmd_hdl_free(hdl, hc_list, sizeof (nvlist_t *)*n);
fmd_hdl_free(hdl, nac, len);
nvlist_free(fru);
return (NULL);
}
for (i = 0; i < n; i++) {
if (hc_list[i] != NULL)
nvlist_free(hc_list[i]);
}
fmd_hdl_free(hdl, hc_list, sizeof (nvlist_t *)*n);
fmd_hdl_free(hdl, nac, len);
if ((serialstr != NULL &&
nvlist_add_string(fru, FM_FMRI_HC_SERIAL_ID, serialstr) != 0) ||
(partstr != NULL &&
nvlist_add_string(fru, FM_FMRI_HC_PART, partstr) != 0)) {
nvlist_free(fru);
return (NULL);
}
return (fru);
}
static int
zpool_import_by_guid(uint64_t searchguid)
{
int err = 0;
nvlist_t *pools = NULL;
nvpair_t *elem;
nvlist_t *config;
nvlist_t *found_config = NULL;
nvlist_t *policy = NULL;
boolean_t first;
int flags = ZFS_IMPORT_NORMAL;
uint32_t rewind_policy = ZPOOL_NO_REWIND;
uint64_t pool_state, txg = -1ULL;
importargs_t idata = { 0 };
#ifdef ZFS_AUTOIMPORT_ZPOOL_STATUS_OK_ONLY
char *msgid;
zpool_status_t reason;
zpool_errata_t errata;
#endif
if ((g_zfs = libzfs_init()) == NULL)
return (1);
idata.unique = B_TRUE;
/* In the future, we can capture further policy and include it here */
if (nvlist_alloc(&policy, NV_UNIQUE_NAME, 0) != 0 ||
nvlist_add_uint64(policy, ZPOOL_REWIND_REQUEST_TXG, txg) != 0 ||
nvlist_add_uint32(policy, ZPOOL_REWIND_REQUEST, rewind_policy) != 0)
goto error;
if (!priv_ineffect(PRIV_SYS_CONFIG)) {
printf("cannot discover pools: permission denied\n");
nvlist_free(policy);
return (1);
}
idata.guid = searchguid;
pools = zpool_search_import(g_zfs, &idata);
if (pools == NULL && idata.exists) {
printf("cannot import '%llu': a pool with that guid is already "
"created/imported\n", searchguid);
err = 1;
} else if (pools == NULL) {
printf("cannot import '%llu': no such pool available\n",
searchguid);
err = 1;
}
if (err == 1) {
nvlist_free(policy);
return (1);
}
/*
* At this point we have a list of import candidate configs. Even though
* we were searching by guid, we still need to post-process the list to
* deal with pool state.
*/
err = 0;
elem = NULL;
first = B_TRUE;
while ((elem = nvlist_next_nvpair(pools, elem)) != NULL) {
verify(nvpair_value_nvlist(elem, &config) == 0);
verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_STATE,
&pool_state) == 0);
if (pool_state == POOL_STATE_DESTROYED)
continue;
verify(nvlist_add_nvlist(config, ZPOOL_REWIND_POLICY,
policy) == 0);
uint64_t guid;
/*
* Search for a pool by guid.
*/
verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID,
&guid) == 0);
if (guid == searchguid)
found_config = config;
}
/*
* If we were searching for a specific pool, verify that we found a
* pool, and then do the import.
*/
if (err == 0) {
if (found_config == NULL) {
printf("cannot import '%llu': no such pool available\n",
searchguid);
err = B_TRUE;
} else {
#ifdef ZFS_AUTOIMPORT_ZPOOL_STATUS_OK_ONLY
reason = zpool_import_status(config, &msgid, &errata);
if (reason == ZPOOL_STATUS_OK)
err |= do_import(found_config, NULL, NULL, NULL,
flags);
else
err = 1;
#else
err |= do_import(found_config, NULL, NULL, NULL, flags);
#endif
}
}
error:
nvlist_free(pools);
nvlist_free(policy);
libzfs_fini(g_zfs);
return (err ? 1 : 0);
}
static int
mptsas_led_mode(topo_mod_t *mod, tnode_t *node, topo_version_t vers,
nvlist_t *in, nvlist_t **nvout)
{
int err, ret = 0;
tnode_t *pnode = topo_node_parent(node);
uint32_t type, ledmode = 0;
nvlist_t *pargs, *nvl;
char *driver = NULL, *devctl = NULL;
uint32_t enclosure, slot;
uint8_t mptsas_led;
boolean_t set;
if (vers > TOPO_METH_MPTSAS_LED_MODE_VERSION)
return (topo_mod_seterrno(mod, ETOPO_METHOD_VERNEW));
if (topo_prop_get_string(pnode, TOPO_PGROUP_BINDING,
TOPO_BINDING_DRIVER, &driver, &err) != 0 ||
strcmp("mpt_sas", driver) != 0) {
topo_mod_dprintf(mod, "%s: Facility driver was not mpt_sas",
__func__);
ret = topo_mod_seterrno(mod, EMOD_NVL_INVAL);
goto out;
}
if (topo_prop_get_uint32(node, TOPO_PGROUP_FACILITY, TOPO_FACILITY_TYPE,
&type, &err) != 0) {
topo_mod_dprintf(mod, "%s: Failed to lookup %s property "
"(%s)", __func__, TOPO_FACILITY_TYPE, topo_strerror(err));
return (topo_mod_seterrno(mod, EMOD_NVL_INVAL));
}
switch (type) {
case (TOPO_LED_TYPE_SERVICE):
mptsas_led = MPTSAS_LEDCTL_LED_FAIL;
break;
case (TOPO_LED_TYPE_LOCATE):
mptsas_led = MPTSAS_LEDCTL_LED_IDENT;
break;
case (TOPO_LED_TYPE_OK2RM):
mptsas_led = MPTSAS_LEDCTL_LED_OK2RM;
break;
default:
topo_mod_dprintf(mod, "%s: Invalid LED type: 0x%x\n", __func__,
type);
return (topo_mod_seterrno(mod, EMOD_NVL_INVAL));
}
if (topo_prop_get_string(pnode, TOPO_PGROUP_BINDING,
TOPO_BINDING_DEVCTL, &devctl, &err) != 0 ||
topo_prop_get_uint32(pnode, TOPO_PGROUP_BINDING,
TOPO_BINDING_ENCLOSURE, &enclosure, &err) != 0 ||
topo_prop_get_uint32(pnode, TOPO_PGROUP_BINDING,
TOPO_BINDING_SLOT, &slot, &err) != 0) {
topo_mod_dprintf(mod, "%s: Facility was missing mpt_sas binding"
" properties\n", __func__);
ret = topo_mod_seterrno(mod, EMOD_NVL_INVAL);
goto out;
}
if ((nvlist_lookup_nvlist(in, TOPO_PROP_PARGS, &pargs) == 0) &&
nvlist_exists(pargs, TOPO_PROP_VAL_VAL)) {
/*
* Set the LED mode
*/
set = B_TRUE;
if ((ret = nvlist_lookup_uint32(pargs, TOPO_PROP_VAL_VAL,
&ledmode)) != 0) {
topo_mod_dprintf(mod, "%s: Failed to lookup %s nvpair "
"(%s)\n", __func__, TOPO_PROP_VAL_VAL,
strerror(ret));
ret = topo_mod_seterrno(mod, EMOD_NVL_INVAL);
goto out;
}
topo_mod_dprintf(mod, "%s: Setting LED mode to %s\n", __func__,
ledmode ? "ON" : "OFF");
} else {
/*
* Get the LED mode
*/
set = B_FALSE;
topo_mod_dprintf(mod, "%s: Getting LED mode\n", __func__);
}
if (do_led_control(mod, devctl, enclosure, slot, mptsas_led, &ledmode,
set) != 0) {
topo_mod_dprintf(mod, "%s: do_led_control failed", __func__);
ret = topo_mod_seterrno(mod, EMOD_UNKNOWN);
goto out;
}
if (topo_mod_nvalloc(mod, &nvl, NV_UNIQUE_NAME) != 0 ||
nvlist_add_string(nvl, TOPO_PROP_VAL_NAME, TOPO_LED_MODE) != 0 ||
nvlist_add_uint32(nvl, TOPO_PROP_VAL_TYPE, TOPO_TYPE_UINT32) != 0 ||
nvlist_add_uint32(nvl, TOPO_PROP_VAL_VAL, ledmode) != 0) {
topo_mod_dprintf(mod, "%s: Failed to allocate 'out' nvlist\n",
__func__);
nvlist_free(nvl);
ret = topo_mod_seterrno(mod, EMOD_NOMEM);
goto out;
}
*nvout = nvl;
out:
if (driver != NULL)
topo_mod_strfree(mod, driver);
if (devctl != NULL)
topo_mod_strfree(mod, devctl);
return (ret);
}
static int
topo_prop_set(tnode_t *node, const char *pgname, const char *pname,
topo_type_t type, int flag, void *val, int nelems, int *err)
{
int ret;
topo_hdl_t *thp = node->tn_hdl;
nvlist_t *nvl;
if (topo_hdl_nvalloc(thp, &nvl, NV_UNIQUE_NAME) < 0) {
*err = ETOPO_PROP_NVL;
return (-1);
}
ret = nvlist_add_string(nvl, TOPO_PROP_VAL_NAME, pname);
ret |= nvlist_add_uint32(nvl, TOPO_PROP_VAL_TYPE, type);
switch (type) {
case TOPO_TYPE_INT32:
ret |= nvlist_add_int32(nvl, TOPO_PROP_VAL_VAL,
*(int32_t *)val);
break;
case TOPO_TYPE_UINT32:
ret |= nvlist_add_uint32(nvl, TOPO_PROP_VAL_VAL,
*(uint32_t *)val);
break;
case TOPO_TYPE_INT64:
ret |= nvlist_add_int64(nvl, TOPO_PROP_VAL_VAL,
*(int64_t *)val);
break;
case TOPO_TYPE_UINT64:
ret |= nvlist_add_uint64(nvl, TOPO_PROP_VAL_VAL,
*(uint64_t *)val);
break;
case TOPO_TYPE_DOUBLE:
ret |= nvlist_add_double(nvl, TOPO_PROP_VAL_VAL,
*(double *)val);
break;
case TOPO_TYPE_STRING:
ret |= nvlist_add_string(nvl, TOPO_PROP_VAL_VAL,
(char *)val);
break;
case TOPO_TYPE_FMRI:
ret |= nvlist_add_nvlist(nvl, TOPO_PROP_VAL_VAL,
(nvlist_t *)val);
break;
case TOPO_TYPE_INT32_ARRAY:
ret |= nvlist_add_int32_array(nvl,
TOPO_PROP_VAL_VAL, (int32_t *)val, nelems);
break;
case TOPO_TYPE_UINT32_ARRAY:
ret |= nvlist_add_uint32_array(nvl,
TOPO_PROP_VAL_VAL, (uint32_t *)val, nelems);
break;
case TOPO_TYPE_INT64_ARRAY:
ret |= nvlist_add_int64_array(nvl,
TOPO_PROP_VAL_VAL, (int64_t *)val, nelems);
break;
case TOPO_TYPE_UINT64_ARRAY:
ret |= nvlist_add_uint64_array(nvl,
TOPO_PROP_VAL_VAL, (uint64_t *)val, nelems);
break;
case TOPO_TYPE_STRING_ARRAY:
ret |= nvlist_add_string_array(nvl,
TOPO_PROP_VAL_VAL, (char **)val, nelems);
break;
case TOPO_TYPE_FMRI_ARRAY:
ret |= nvlist_add_nvlist_array(nvl,
TOPO_PROP_VAL_VAL, (nvlist_t **)val, nelems);
break;
default:
*err = ETOPO_PROP_TYPE;
return (-1);
}
if (ret != 0) {
nvlist_free(nvl);
if (ret == ENOMEM) {
*err = ETOPO_PROP_NOMEM;
return (-1);
} else {
*err = ETOPO_PROP_NVL;
return (-1);
}
}
if (topo_prop_setprop(node, pgname, nvl, flag, nvl, err) != 0) {
nvlist_free(nvl);
return (-1); /* err set */
}
nvlist_free(nvl);
return (ret);
}
static int
get_attrs(disk_t *dp, int fd, nvlist_t *attrs)
{
struct dk_minfo minfo;
struct dk_geom geometry;
if (fd < 0) {
return (ENODEV);
}
bzero(&minfo, sizeof (struct dk_minfo));
/* The first thing to do is read the media */
if (!media_read_info(fd, &minfo)) {
return (ENODEV);
}
if (partition_has_fdisk(dp, fd)) {
if (nvlist_add_boolean(attrs, DM_FDISK) != 0) {
return (ENOMEM);
}
}
if (dp->removable) {
if (nvlist_add_boolean(attrs, DM_REMOVABLE) != 0) {
return (ENOMEM);
}
if (nvlist_add_boolean(attrs, DM_LOADED) != 0) {
return (ENOMEM);
}
}
if (nvlist_add_uint64(attrs, DM_SIZE, minfo.dki_capacity) != 0) {
return (ENOMEM);
}
if (nvlist_add_uint32(attrs, DM_BLOCKSIZE, minfo.dki_lbsize) != 0) {
return (ENOMEM);
}
if (nvlist_add_uint32(attrs, DM_MTYPE,
get_media_type(minfo.dki_media_type)) != 0) {
return (ENOMEM);
}
/* only for disks < 1TB and x86 */
#if defined(i386) || defined(__amd64)
if (ioctl(fd, DKIOCG_PHYGEOM, &geometry) >= 0) {
#else
/* sparc call */
if (ioctl(fd, DKIOCGGEOM, &geometry) >= 0) {
#endif
struct extvtoc vtoc;
if (nvlist_add_uint64(attrs, DM_START, 0) != 0) {
return (ENOMEM);
}
if (nvlist_add_uint64(attrs, DM_NACCESSIBLE,
geometry.dkg_ncyl * geometry.dkg_nhead * geometry.dkg_nsect)
!= 0) {
return (ENOMEM);
}
if (nvlist_add_uint32(attrs, DM_NCYLINDERS, geometry.dkg_ncyl)
!= 0) {
return (ENOMEM);
}
if (nvlist_add_uint32(attrs, DM_NPHYSCYLINDERS,
geometry.dkg_pcyl) != 0) {
return (ENOMEM);
}
if (nvlist_add_uint32(attrs, DM_NALTCYLINDERS,
geometry.dkg_acyl) != 0) {
return (ENOMEM);
}
if (nvlist_add_uint32(attrs, DM_NHEADS,
geometry.dkg_nhead) != 0) {
return (ENOMEM);
}
if (nvlist_add_uint32(attrs, DM_NSECTORS, geometry.dkg_nsect)
!= 0) {
return (ENOMEM);
}
if (nvlist_add_uint32(attrs, DM_NACTUALCYLINDERS,
geometry.dkg_ncyl) != 0) {
return (ENOMEM);
}
if (read_extvtoc(fd, &vtoc) >= 0 && vtoc.v_volume[0] != 0) {
char label[LEN_DKL_VVOL + 1];
(void) snprintf(label, sizeof (label), "%.*s",
LEN_DKL_VVOL, vtoc.v_volume);
if (nvlist_add_string(attrs, DM_LABEL, label) != 0) {
return (ENOMEM);
}
}
} else {
/* check for disks > 1TB for accessible size */
struct dk_gpt *efip;
if (efi_alloc_and_read(fd, &efip) >= 0) {
diskaddr_t p8size = 0;
if (nvlist_add_boolean(attrs, DM_EFI) != 0) {
return (ENOMEM);
}
if (nvlist_add_uint64(attrs, DM_START,
efip->efi_first_u_lba) != 0) {
return (ENOMEM);
}
/* partition 8 is reserved on EFI labels */
if (efip->efi_nparts >= 9) {
p8size = efip->efi_parts[8].p_size;
}
if (nvlist_add_uint64(attrs, DM_NACCESSIBLE,
(efip->efi_last_u_lba - p8size) -
efip->efi_first_u_lba) != 0) {
efi_free(efip);
return (ENOMEM);
}
efi_free(efip);
}
}
return (0);
}
static int
get_media_type(uint_t media_type)
{
switch (media_type) {
case DK_UNKNOWN:
return (DM_MT_UNKNOWN);
case DK_MO_ERASABLE:
return (DM_MT_MO_ERASABLE);
case DK_MO_WRITEONCE:
return (DM_MT_MO_WRITEONCE);
case DK_AS_MO:
return (DM_MT_AS_MO);
case DK_CDROM:
return (DM_MT_CDROM);
case DK_CDR:
return (DM_MT_CDR);
case DK_CDRW:
return (DM_MT_CDRW);
case DK_DVDROM:
return (DM_MT_DVDROM);
case DK_DVDR:
return (DM_MT_DVDR);
case DK_DVDRAM:
return (DM_MT_DVDRAM);
case DK_FIXED_DISK:
return (DM_MT_FIXED);
case DK_FLOPPY:
return (DM_MT_FLOPPY);
case DK_ZIP:
return (DM_MT_ZIP);
case DK_JAZ:
return (DM_MT_JAZ);
default:
return (DM_MT_UNKNOWN);
}
}
/*
* This function handles removable media.
*/
static int
get_rmm_name(disk_t *dp, char *mname, int size)
{
int loaded;
int fd;
loaded = 0;
if ((fd = drive_open_disk(dp, NULL, 0)) >= 0) {
struct dk_minfo minfo;
if ((loaded = media_read_info(fd, &minfo))) {
struct extvtoc vtoc;
if (read_extvtoc(fd, &vtoc) >= 0) {
if (vtoc.v_volume[0] != NULL) {
if (LEN_DKL_VVOL < size) {
(void) strlcpy(mname,
vtoc.v_volume,
LEN_DKL_VVOL);
} else {
(void) strlcpy(mname,
vtoc.v_volume, size);
}
}
}
}
(void) close(fd);
}
return (loaded);
}
static int
get_attrs(descriptor_t *dp, int fd, nvlist_t *attrs)
{
struct dk_minfo minfo;
int status;
int data_format = FMT_UNKNOWN;
int snum = -1;
int error;
struct extvtoc vtoc;
struct dk_gpt *efip;
struct dk_cinfo dkinfo;
int cooked_fd;
struct stat buf;
if (fd < 0) {
return (ENODEV);
}
/* First make sure media is inserted and spun up. */
if (!media_read_info(fd, &minfo)) {
return (ENODEV);
}
if ((status = read_extvtoc(fd, &vtoc)) >= 0) {
data_format = FMT_VTOC;
} else if (status == VT_ENOTSUP && efi_alloc_and_read(fd, &efip) >= 0) {
data_format = FMT_EFI;
if (nvlist_add_boolean(attrs, DM_EFI) != 0) {
efi_free(efip);
return (ENOMEM);
}
}
if (data_format == FMT_UNKNOWN) {
return (ENODEV);
}
if (ioctl(fd, DKIOCINFO, &dkinfo) >= 0) {
snum = dkinfo.dki_partition;
}
/* check the slice */
if (data_format == FMT_VTOC) {
if (snum < 0 || snum >= vtoc.v_nparts ||
vtoc.v_part[snum].p_size == 0) {
return (ENODEV);
}
} else { /* data_format == FMT_EFI */
if (snum < 0 || snum >= efip->efi_nparts ||
efip->efi_parts[snum].p_size == 0) {
efi_free(efip);
return (ENODEV);
}
}
/* the slice exists */
if (nvlist_add_uint32(attrs, DM_INDEX, snum) != 0) {
if (data_format == FMT_EFI) {
efi_free(efip);
}
return (ENOMEM);
}
if (data_format == FMT_VTOC) {
if (nvlist_add_uint64(attrs, DM_START, vtoc.v_part[snum].p_start)
!= 0) {
return (ENOMEM);
}
if (nvlist_add_uint64(attrs, DM_SIZE, vtoc.v_part[snum].p_size)
!= 0) {
return (ENOMEM);
}
if (nvlist_add_uint32(attrs, DM_TAG, vtoc.v_part[snum].p_tag)
!= 0) {
return (ENOMEM);
}
if (nvlist_add_uint32(attrs, DM_FLAG, vtoc.v_part[snum].p_flag)
!= 0) {
return (ENOMEM);
}
} else { /* data_format == FMT_EFI */
if (nvlist_add_uint64(attrs, DM_START,
efip->efi_parts[snum].p_start) != 0) {
efi_free(efip);
return (ENOMEM);
}
if (nvlist_add_uint64(attrs, DM_SIZE, efip->efi_parts[snum].p_size)
!= 0) {
efi_free(efip);
return (ENOMEM);
}
if (efip->efi_parts[snum].p_name[0] != 0) {
char label[EFI_PART_NAME_LEN + 1];
(void) snprintf(label, sizeof (label), "%.*s",
EFI_PART_NAME_LEN, efip->efi_parts[snum].p_name);
if (nvlist_add_string(attrs, DM_EFI_NAME, label) != 0) {
efi_free(efip);
return (ENOMEM);
}
}
}
if (data_format == FMT_EFI) {
efi_free(efip);
}
if (inuse_mnt(dp->name, attrs, &error)) {
if (error != 0)
return (error);
}
if (fstat(fd, &buf) != -1) {
if (nvlist_add_uint64(attrs, DM_DEVT, buf.st_rdev) != 0) {
return (ENOMEM);
}
}
/*
* We need to open the cooked slice (not the raw one) to get the
* correct devid.
*/
cooked_fd = open(dp->name, O_RDONLY|O_NDELAY);
if (cooked_fd >= 0) {
int no_mem = 0;
ddi_devid_t devid;
if (devid_get(cooked_fd, &devid) == 0) {
char *minor;
if (devid_get_minor_name(cooked_fd, &minor) == 0) {
char *devidstr;
if ((devidstr = devid_str_encode(devid, minor)) != 0) {
if (nvlist_add_string(attrs, DM_DEVICEID, devidstr)
!= 0) {
no_mem = 1;
}
devid_str_free(devidstr);
}
devid_str_free(minor);
}
devid_free(devid);
}
(void) close(cooked_fd);
if (no_mem) {
return (ENOMEM);
}
}
return (0);
}
/*ARGSUSED*/
int
topo_method_sensor_failure(topo_mod_t *mod, tnode_t *node,
topo_version_t version, nvlist_t *in, nvlist_t **out)
{
const char *name = topo_node_name(node);
topo_faclist_t faclist, *fp;
int err;
nvlist_t *nvl, *props, *propval, *tmp;
int ret = -1;
uint32_t type, state, units;
nvpair_t *elem;
double reading;
char *propname;
boolean_t has_reading;
struct sensor_errinfo seinfo;
if (strcmp(name, PSU) != 0 && strcmp(name, FAN) != 0)
return (topo_mod_seterrno(mod, ETOPO_METHOD_NOTSUP));
if (topo_node_facility(mod->tm_hdl, node, TOPO_FAC_TYPE_SENSOR,
TOPO_FAC_TYPE_ANY, &faclist, &err) != 0)
return (topo_mod_seterrno(mod, ETOPO_METHOD_NOTSUP));
if (topo_mod_nvalloc(mod, &nvl, NV_UNIQUE_NAME) != 0)
goto error;
for (fp = topo_list_next(&faclist.tf_list); fp != NULL;
fp = topo_list_next(fp)) {
if (topo_prop_getpgrp(fp->tf_node, TOPO_PGROUP_FACILITY,
&props, &err) != 0) {
nvlist_free(nvl);
goto error;
}
type = state = units = 0;
reading = 0;
has_reading = B_FALSE;
elem = NULL;
while ((elem = nvlist_next_nvpair(props, elem)) != NULL) {
if (strcmp(nvpair_name(elem), TOPO_PROP_VAL) != 0 ||
nvpair_type(elem) != DATA_TYPE_NVLIST)
continue;
(void) nvpair_value_nvlist(elem, &propval);
if (nvlist_lookup_string(propval,
TOPO_PROP_VAL_NAME, &propname) != 0)
continue;
if (strcmp(propname, TOPO_FACILITY_TYPE) == 0) {
(void) nvlist_lookup_uint32(propval,
TOPO_PROP_VAL_VAL, &type);
} else if (strcmp(propname, TOPO_SENSOR_STATE) == 0) {
(void) nvlist_lookup_uint32(propval,
TOPO_PROP_VAL_VAL, &state);
} else if (strcmp(propname, TOPO_SENSOR_UNITS) == 0) {
(void) nvlist_lookup_uint32(propval,
TOPO_PROP_VAL_VAL, &units);
} else if (strcmp(propname, TOPO_SENSOR_READING) == 0) {
has_reading = B_TRUE;
(void) nvlist_lookup_double(propval,
TOPO_PROP_VAL_VAL, &reading);
}
}
if (topo_sensor_failed(type, state, &seinfo)) {
tmp = NULL;
if (topo_mod_nvalloc(mod, &tmp, NV_UNIQUE_NAME) != 0 ||
nvlist_add_uint32(tmp, TOPO_FACILITY_TYPE,
type) != 0 ||
nvlist_add_uint32(tmp, TOPO_SENSOR_STATE,
state) != 0 ||
nvlist_add_uint32(tmp, TOPO_SENSOR_UNITS,
units) != 0 ||
nvlist_add_boolean_value(tmp,
"nonrecov", seinfo.se_nonrecov) != 0 ||
nvlist_add_boolean_value(tmp,
"predictive", seinfo.se_predictive) != 0 ||
nvlist_add_uint32(tmp, "source",
seinfo.se_src) != 0 ||
(has_reading && nvlist_add_double(tmp,
TOPO_SENSOR_READING, reading) != 0) ||
nvlist_add_nvlist(nvl, topo_node_name(fp->tf_node),
tmp) != 0) {
nvlist_free(props);
nvlist_free(tmp);
nvlist_free(nvl);
ret = topo_mod_seterrno(mod,
ETOPO_METHOD_NOMEM);
goto error;
}
nvlist_free(tmp);
}
nvlist_free(props);
}
*out = nvl;
ret = 0;
error:
while ((fp = topo_list_next(&faclist.tf_list)) != NULL) {
topo_list_delete(&faclist.tf_list, fp);
topo_mod_free(mod, fp, sizeof (topo_faclist_t));
}
return (ret);
}
/* Topo Methods */
static int
mem_asru_compute(topo_mod_t *mod, tnode_t *node, topo_version_t version,
nvlist_t *in, nvlist_t **out)
{
nvlist_t *asru, *pargs, *args, *hcsp;
int err;
char *serial = NULL, *label = NULL;
uint64_t pa, offset;
if (version > TOPO_METH_ASRU_COMPUTE_VERSION)
return (topo_mod_seterrno(mod, EMOD_VER_NEW));
if (strcmp(topo_node_name(node), DIMM) != 0)
return (topo_mod_seterrno(mod, EMOD_METHOD_INVAL));
pargs = NULL;
if (nvlist_lookup_nvlist(in, TOPO_PROP_PARGS, &pargs) == 0)
(void) nvlist_lookup_string(pargs, FM_FMRI_HC_SERIAL_ID,
&serial);
if (serial == NULL &&
nvlist_lookup_nvlist(in, TOPO_PROP_ARGS, &args) == 0)
(void) nvlist_lookup_string(args, FM_FMRI_HC_SERIAL_ID,
&serial);
(void) topo_node_label(node, &label, &err);
asru = mem_fmri_create(mod, serial, label);
if (label != NULL)
topo_mod_strfree(mod, label);
if (asru == NULL)
return (topo_mod_seterrno(mod, EMOD_NOMEM));
err = 0;
/*
* For a memory page, 'in' includes an hc-specific member which
* specifies physaddr and/or offset. Set them in asru as well.
*/
if (pargs && nvlist_lookup_nvlist(pargs,
FM_FMRI_HC_SPECIFIC, &hcsp) == 0) {
if (nvlist_lookup_uint64(hcsp,
FM_FMRI_HC_SPECIFIC_PHYSADDR, &pa) == 0)
err += nvlist_add_uint64(asru, FM_FMRI_MEM_PHYSADDR,
pa);
if (nvlist_lookup_uint64(hcsp,
FM_FMRI_HC_SPECIFIC_OFFSET, &offset) == 0)
err += nvlist_add_uint64(asru, FM_FMRI_MEM_OFFSET,
offset);
}
if (err != 0 || topo_mod_nvalloc(mod, out, NV_UNIQUE_NAME) < 0) {
nvlist_free(asru);
return (topo_mod_seterrno(mod, EMOD_NOMEM));
}
err = nvlist_add_string(*out, TOPO_PROP_VAL_NAME, TOPO_PROP_ASRU);
err |= nvlist_add_uint32(*out, TOPO_PROP_VAL_TYPE, TOPO_TYPE_FMRI);
err |= nvlist_add_nvlist(*out, TOPO_PROP_VAL_VAL, asru);
nvlist_free(asru);
if (err != 0) {
nvlist_free(*out);
*out = NULL;
return (topo_mod_seterrno(mod, EMOD_NVL_INVAL));
}
return (0);
}
/* ARGSUSED */
static int
dlcosmk_info(ipp_action_id_t aid, int (*fn)(nvlist_t *, void *), void *arg,
ipp_flags_t flags)
{
nvlist_t *nvlp;
dlcosmk_data_t *dlcosmk_data;
char *next_action;
int err;
ASSERT(fn != NULL);
dlcosmk_data = (dlcosmk_data_t *)ipp_action_get_ptr(aid);
ASSERT(dlcosmk_data != NULL);
/* allocate nvlist to be passed back */
if ((err = nvlist_alloc(&nvlp, NV_UNIQUE_NAME, KM_NOSLEEP)) != 0) {
dlcosmk0dbg(("dlcosmk_info: error allocating memory\n"));
return (err);
}
/* look up next action with the next action id */
if ((err = ipp_action_name(dlcosmk_data->next_action,
&next_action)) != 0) {
dlcosmk0dbg(("dlcosmk_info: next action not available\n"));
nvlist_free(nvlp);
return (err);
}
/* add next action name */
if ((err = nvlist_add_string(nvlp, DLCOSMK_NEXT_ACTION_NAME,
next_action)) != 0) {
dlcosmk0dbg(("dlcosmk_info: error adding next action\n"));
nvlist_free(nvlp);
kmem_free(next_action, (strlen(next_action) + 1));
return (err);
}
/* free action name */
kmem_free(next_action, (strlen(next_action) + 1));
/* add config type */
if ((err = nvlist_add_byte(nvlp, IPP_CONFIG_TYPE, IPP_SET)) != 0) {
dlcosmk0dbg(("dlcosmk_info: error adding config. type\n"));
nvlist_free(nvlp);
return (err);
}
/* just give the cos, since that is what is provided in the config */
if ((err = nvlist_add_byte(nvlp, DLCOSMK_COS, dlcosmk_data->usr_pri))
!= 0) {
dlcosmk0dbg(("dlcosmk_info: error adding cos\n"));
nvlist_free(nvlp);
return (err);
}
/* add gather stats boolean */
if ((err = nvlist_add_uint32(nvlp, IPP_ACTION_STATS_ENABLE,
(dlcosmk_data->gather_stats ? 1 : 0))) != 0) {
dlcosmk0dbg(("dlcosmk_info: error adding stats status\n"));
nvlist_free(nvlp);
return (err);
}
/* call back with nvlist */
err = fn(nvlp, arg);
nvlist_free(nvlp);
return (err);
}
static void
set_prop(topo_hdl_t *thp, tnode_t *node, nvlist_t *fmri, struct prop_args *pp)
{
int ret, err = 0;
topo_type_t type;
nvlist_t *nvl, *f = NULL;
char *end;
if (pp->prop == NULL || pp->type == NULL || pp->value == NULL)
return;
if ((type = str2type(pp->type)) == TOPO_TYPE_INVALID) {
(void) fprintf(stderr, "%s: invalid property type %s for %s\n",
g_pname, pp->type, pp->prop);
return;
}
if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0) {
(void) fprintf(stderr, "%s: nvlist allocation failed for "
"%s=%s:%s\n", g_pname, pp->prop, pp->type, pp->value);
return;
}
ret = nvlist_add_string(nvl, TOPO_PROP_VAL_NAME, pp->prop);
ret |= nvlist_add_uint32(nvl, TOPO_PROP_VAL_TYPE, type);
if (ret != 0) {
(void) fprintf(stderr, "%s: invalid property type %s for %s\n",
g_pname, pp->type, pp->prop);
nvlist_free(nvl);
return;
}
errno = 0;
switch (type) {
case TOPO_TYPE_INT32:
{
int32_t val;
val = strtol(pp->value, &end, 0);
if (errno == ERANGE) {
ret = -1;
break;
}
ret = nvlist_add_int32(nvl, TOPO_PROP_VAL_VAL, val);
break;
}
case TOPO_TYPE_UINT32:
{
uint32_t val;
val = strtoul(pp->value, &end, 0);
if (errno == ERANGE) {
ret = -1;
break;
}
ret = nvlist_add_uint32(nvl, TOPO_PROP_VAL_VAL, val);
break;
}
case TOPO_TYPE_INT64:
{
int64_t val;
val = strtoll(pp->value, &end, 0);
if (errno == ERANGE) {
ret = -1;
break;
}
ret = nvlist_add_int64(nvl, TOPO_PROP_VAL_VAL, val);
break;
}
case TOPO_TYPE_UINT64:
{
uint64_t val;
val = strtoull(pp->value, &end, 0);
if (errno == ERANGE) {
ret = -1;
break;
}
ret = nvlist_add_uint64(nvl, TOPO_PROP_VAL_VAL, val);
break;
}
case TOPO_TYPE_STRING:
{
ret = nvlist_add_string(nvl, TOPO_PROP_VAL_VAL,
pp->value);
break;
}
case TOPO_TYPE_FMRI:
{
if ((ret = topo_fmri_str2nvl(thp, pp->value, &f, &err))
< 0)
break;
if ((ret = nvlist_add_nvlist(nvl, TOPO_PROP_VAL_VAL,
f)) != 0)
err = ETOPO_PROP_NVL;
break;
}
default:
ret = -1;
}
if (ret != 0) {
(void) fprintf(stderr, "%s: unable to set property value for "
"%s: %s\n", g_pname, pp->prop, topo_strerror(err));
nvlist_free(nvl);
return;
}
if (node != NULL) {
if (topo_prop_setprop(node, pp->group, nvl, TOPO_PROP_MUTABLE,
f, &ret) < 0) {
(void) fprintf(stderr, "%s: unable to set property "
"value for " "%s=%s:%s: %s\n", g_pname, pp->prop,
pp->type, pp->value, topo_strerror(ret));
nvlist_free(nvl);
nvlist_free(f);
return;
}
} else {
if (topo_fmri_setprop(thp, fmri, pp->group, nvl,
TOPO_PROP_MUTABLE, f, &ret) < 0) {
(void) fprintf(stderr, "%s: unable to set property "
"value for " "%s=%s:%s: %s\n", g_pname, pp->prop,
pp->type, pp->value, topo_strerror(ret));
nvlist_free(nvl);
nvlist_free(f);
return;
}
}
nvlist_free(nvl);
/*
* Now, get the property back for printing
*/
if (node != NULL) {
if (topo_prop_getprop(node, pp->group, pp->prop, f, &nvl,
&err) < 0) {
(void) fprintf(stderr, "%s: failed to get %s.%s: %s\n",
g_pname, pp->group, pp->prop, topo_strerror(err));
nvlist_free(f);
return;
}
} else {
if (topo_fmri_getprop(thp, fmri, pp->group, pp->prop,
f, &nvl, &err) < 0) {
(void) fprintf(stderr, "%s: failed to get %s.%s: %s\n",
g_pname, pp->group, pp->prop, topo_strerror(err));
nvlist_free(f);
return;
}
}
print_pgroup(thp, node, pp->group, NULL, NULL, 0);
print_prop_nameval(thp, node, nvl);
nvlist_free(nvl);
nvlist_free(f);
}