int
topo_fmri_nvl2str(topo_hdl_t *thp, nvlist_t *fmri, char **fmristr, int *err)
{
char *scheme, *str;
nvlist_t *out = NULL;
tnode_t *rnode;
if (nvlist_lookup_string(fmri, FM_FMRI_SCHEME, &scheme) != 0)
return (set_error(thp, ETOPO_FMRI_MALFORM, err,
TOPO_METH_NVL2STR, out));
if ((rnode = topo_hdl_root(thp, scheme)) == NULL)
return (set_error(thp, ETOPO_METHOD_NOTSUP, err,
TOPO_METH_NVL2STR, out));
if (topo_method_invoke(rnode, TOPO_METH_NVL2STR,
TOPO_METH_NVL2STR_VERSION, fmri, &out, err) != 0)
return (set_error(thp, *err, err, TOPO_METH_NVL2STR, out));
if (out == NULL || nvlist_lookup_string(out, "fmri-string", &str) != 0)
return (set_error(thp, ETOPO_METHOD_INVAL, err,
TOPO_METH_NVL2STR, out));
if ((*fmristr = topo_hdl_strdup(thp, str)) == NULL)
return (set_error(thp, ETOPO_NOMEM, err,
TOPO_METH_NVL2STR, out));
nvlist_free(out);
return (0);
}
static int
hclist_contains(nvlist_t **erhcl, uint_t erhclsz, nvlist_t **eehcl,
uint_t eehclsz)
{
uint_t i;
char *erval, *eeval;
if (erhclsz > eehclsz || erhcl == NULL || eehcl == NULL)
return (0);
for (i = 0; i < erhclsz; i++) {
(void) nvlist_lookup_string(erhcl[i], FM_FMRI_HC_NAME,
&erval);
(void) nvlist_lookup_string(eehcl[i], FM_FMRI_HC_NAME,
&eeval);
if (strcmp(erval, eeval) != 0)
return (0);
(void) nvlist_lookup_string(erhcl[i], FM_FMRI_HC_ID,
&erval);
(void) nvlist_lookup_string(eehcl[i], FM_FMRI_HC_ID,
&eeval);
if (strcmp(erval, eeval) != 0)
return (0);
}
return (1);
}
int
topo_fmri_serial(topo_hdl_t *thp, nvlist_t *nvl, char **serial, int *err)
{
nvlist_t *prop = NULL;
char *sp;
/*
* If there is a serial id in the resource fmri, then use that.
* Otherwise fall back to looking for a serial id property in the
* protocol group.
*/
if (nvlist_lookup_string(nvl, FM_FMRI_HC_SERIAL_ID, &sp) == 0) {
if ((*serial = topo_hdl_strdup(thp, sp)) == NULL)
return (set_error(thp, ETOPO_PROP_NOMEM, err,
"topo_fmri_serial", prop));
else
return (0);
}
if (fmri_prop(thp, nvl, TOPO_PGROUP_PROTOCOL, FM_FMRI_HC_SERIAL_ID,
NULL, &prop, err) < 0)
return (set_error(thp, *err, err, "topo_fmri_serial", NULL));
if (nvlist_lookup_string(prop, TOPO_PROP_VAL_VAL, &sp) != 0)
return (set_error(thp, ETOPO_PROP_NVL, err, "topo_fmri_serial",
prop));
if ((*serial = topo_hdl_strdup(thp, sp)) == NULL)
return (set_error(thp, ETOPO_PROP_NOMEM, err,
"topo_fmri_serial", prop));
nvlist_free(prop);
return (0);
}
/*
* Fetch the Facility Node properties (name, type) from the FMRI
* for this node, or return -1 if we can't.
*/
static int
get_facility_props(topo_hdl_t *hdl, tnode_t *node, char **facname,
char **factype)
{
int e, ret = -1;
nvlist_t *fmri = NULL, *fnvl;
char *nn = NULL, *tt = NULL;
if (topo_node_resource(node, &fmri, &e) != 0)
goto out;
if (nvlist_lookup_nvlist(fmri, FM_FMRI_FACILITY, &fnvl) != 0)
goto out;
if (nvlist_lookup_string(fnvl, FM_FMRI_FACILITY_NAME, &nn) != 0)
goto out;
if (nvlist_lookup_string(fnvl, FM_FMRI_FACILITY_TYPE, &tt) != 0)
goto out;
*facname = topo_hdl_strdup(hdl, nn);
*factype = topo_hdl_strdup(hdl, tt);
ret = 0;
out:
nvlist_free(fmri);
return (ret);
}
nvlist_t *
cmd_boardfru_create_fault(fmd_hdl_t *hdl, nvlist_t *asru, const char *fltnm,
uint_t cert, char *loc)
{
nvlist_t *flt, *nvlfru;
char *serialstr, *partstr;
if ((loc == NULL) || (strcmp(loc, EMPTY_STR) == 0))
return (NULL);
if (nvlist_lookup_string(asru, FM_FMRI_HC_SERIAL_ID, &serialstr) != 0)
serialstr = NULL;
if (nvlist_lookup_string(asru, FM_FMRI_HC_PART, &partstr) != 0)
partstr = NULL;
nvlfru = cmd_mkboard_fru(hdl, loc, serialstr, partstr);
if (nvlfru == NULL)
return (NULL);
flt = cmd_nvl_create_fault(hdl, fltnm, cert, nvlfru, nvlfru, NULL);
flt = cmd_fault_add_location(hdl, flt, loc);
if (nvlfru != NULL)
nvlist_free(nvlfru);
return (flt);
}
void
setupInterface(nvlist_t *data)
{
char *iface, *gateway, *netmask, *ip;
boolean_t primary;
int ret;
ret = nvlist_lookup_string(data, "interface", &iface);
if (ret == 0) {
plumbIf(iface);
ret = nvlist_lookup_string(data, "ip", &ip);
if (ret == 0) {
ret = nvlist_lookup_string(data, "netmask", &netmask);
if (ret == 0) {
if (raiseIf(iface, ip, netmask) != 0) {
fatal(ERR_RAISE_IF, "Error bringing up interface %s",
iface);
}
}
ret = nvlist_lookup_boolean_value(data, "primary", &primary);
if ((ret == 0) && (primary == B_TRUE)) {
ret = nvlist_lookup_string(data, "gateway", &gateway);
if (ret == 0) {
(void) addRoute(iface, gateway, "0.0.0.0", 0);
}
}
}
}
}
/*
* Handle a EC_DEV_ADD.ESC_DISK event.
*
* illumos
* Expects: DEV_PHYS_PATH string in schema
* Matches: vdev's ZPOOL_CONFIG_PHYS_PATH or ZPOOL_CONFIG_DEVID
*
* path: '/dev/dsk/c0t1d0s0' (persistent)
* devid: 'id1,sd@SATA_____Hitachi_HDS72101______JP2940HZ3H74MC/a'
* phys_path: '/pci@0,0/pci103c,1609@11/disk@1,0:a'
*
* linux
* provides: DEV_PHYS_PATH and DEV_IDENTIFIER strings in schema
* Matches: vdev's ZPOOL_CONFIG_PHYS_PATH or ZPOOL_CONFIG_DEVID
*
* path: '/dev/sdc1' (not persistent)
* devid: 'ata-SAMSUNG_HD204UI_S2HGJD2Z805891-part1'
* phys_path: 'pci-0000:04:00.0-sas-0x4433221106000000-lun-0'
*/
static int
zfs_deliver_add(nvlist_t *nvl, boolean_t is_lofi)
{
char *devpath = NULL, *devid;
boolean_t is_slice;
/*
* Expecting a devid string and an optional physical location
*/
if (nvlist_lookup_string(nvl, DEV_IDENTIFIER, &devid) != 0)
return (-1);
(void) nvlist_lookup_string(nvl, DEV_PHYS_PATH, &devpath);
is_slice = (nvlist_lookup_boolean(nvl, DEV_IS_PART) == 0);
zed_log_msg(LOG_INFO, "zfs_deliver_add: adding %s (%s) (is_slice %d)",
devid, devpath ? devpath : "NULL", is_slice);
/*
* Iterate over all vdevs looking for a match in the folllowing order:
* 1. ZPOOL_CONFIG_DEVID (identifies the unique disk)
* 2. ZPOOL_CONFIG_PHYS_PATH (identifies disk physical location).
*
* For disks, we only want to pay attention to vdevs marked as whole
* disks or are a multipath device.
*/
if (!devid_iter(devid, zfs_process_add, is_slice) && devpath != NULL)
(void) devphys_iter(devpath, devid, zfs_process_add, is_slice);
return (0);
}
static int
auth_compare(nvlist_t *nvl1, nvlist_t *nvl2)
{
const char *names[] = {
FM_FMRI_AUTH_PRODUCT,
FM_FMRI_AUTH_PRODUCT_SN,
FM_FMRI_AUTH_CHASSIS,
FM_FMRI_AUTH_SERVER,
FM_FMRI_AUTH_DOMAIN,
FM_FMRI_AUTH_HOST,
NULL
};
const char **namep;
nvlist_t *auth1 = NULL, *auth2 = NULL;
(void) nvlist_lookup_nvlist(nvl1, FM_FMRI_AUTHORITY, &auth1);
(void) nvlist_lookup_nvlist(nvl2, FM_FMRI_AUTHORITY, &auth2);
if (auth1 == NULL && auth2 == NULL)
return (0);
if (auth1 == NULL || auth2 == NULL)
return (1);
for (namep = names; *namep != NULL; namep++) {
char *val1 = NULL, *val2 = NULL;
(void) nvlist_lookup_string(auth1, *namep, &val1);
(void) nvlist_lookup_string(auth2, *namep, &val2);
if (val1 == NULL && val2 == NULL)
continue;
if (val1 == NULL || val2 == NULL || strcmp(val1, val2) != 0)
return (1);
}
return (0);
}
int
main(void)
{
uint_t i;
uint8_t buf[256];
bzero(buf, sizeof (buf));
for (i = 0; i < UINT8_MAX; i++) {
int ret;
nvlist_t *nvl;
char *val;
buf[SFF_8472_CONNECTOR] = i;
if ((ret = libsff_parse(buf, sizeof (buf), 0xa0, &nvl)) != 0) {
errx(1, "TEST FAILED: failed to parse SFP connector "
"%d: %s\n", i, strerror(ret));
}
if ((ret = nvlist_lookup_string(nvl, LIBSFF_KEY_CONNECTOR,
&val)) != 0) {
errx(1, "TEST FAILED: failed to find key %s with "
"value %d: %s", LIBSFF_KEY_CONNECTOR, i,
strerror(ret));
}
(void) puts(val);
nvlist_free(nvl);
}
/*
* Now for QSFP+
*/
(void) puts("\n\nQSFP\n");
bzero(buf, sizeof (buf));
buf[SFF_8472_IDENTIFIER] = SFF_8024_ID_QSFP;
for (i = 0; i < UINT8_MAX; i++) {
int ret;
nvlist_t *nvl;
char *val;
buf[SFF_8636_CONNECTOR] = i;
if ((ret = libsff_parse(buf, sizeof (buf), 0xa0, &nvl)) != 0) {
errx(1, "TEST FAILED: failed to parse QSFP connector "
"%d: %s\n", i, strerror(errno));
}
if ((ret = nvlist_lookup_string(nvl, LIBSFF_KEY_CONNECTOR,
&val)) != 0) {
errx(1, "TEST FAILED: failed to find key %s with "
"value %d: %s", LIBSFF_KEY_CONNECTOR, i,
strerror(ret));
}
(void) puts(val);
nvlist_free(nvl);
}
return (0);
}
static int
setupStaticRoute(nvlist_t *route, const char *idx)
{
boolean_t linklocal = B_FALSE;
char *slash;
char *dstraw = NULL;
char *dst;
char *gateway;
int dstpfx = -1;
int ret = -1;
if (nvlist_lookup_boolean_value(route, "linklocal", &linklocal) == 0 &&
linklocal) {
WARNLOG("route[%s]: linklocal routes not supported", idx);
goto bail;
}
if (nvlist_lookup_string(route, "dst", &dst) != 0) {
WARNLOG("route[%s]: route is missing \"dst\"", idx);
goto bail;
}
if (nvlist_lookup_string(route, "gateway", &gateway) != 0) {
WARNLOG("route[%s]: route is missing \"gateway\"", idx);
goto bail;
}
/*
* Parse the CIDR-notation destination specification. For example:
* "172.20.5.1/24" becomes a destination of "172.20.5.1" with a prefix
* length of 24.
*/
if ((dstraw = strdup(dst)) == NULL) {
WARNLOG("route[%s]: strdup failure", idx);
goto bail;
}
if ((slash = strchr(dstraw, '/')) == NULL) {
WARNLOG("route[%s]: dst \"%s\" invalid", idx, dst);
goto bail;
}
*slash = '\0';
dstpfx = atoi(slash + 1);
if (dstpfx < 0 || dstpfx > 32) {
WARNLOG("route[%s]: dst \"%s\" pfx %d invalid", idx, dst, dstpfx);
goto bail;
}
if ((ret = addRoute(NULL, gateway, dstraw, dstpfx)) != 0) {
WARNLOG("route[%s]: failed to add (%d)", idx, ret);
goto bail;
}
ret = 0;
bail:
free(dstraw);
return (ret);
}
/*
* DR event handler
* respond to the picl events:
* PICLEVENT_DR_AP_STATE_CHANGE
*/
static void
dr_handler(const char *ename, const void *earg, size_t size, void *cookie)
{
nvlist_t *nvlp = NULL;
char *dtype;
char *ap_id;
char *hint;
if (strcmp(ename, PICLEVENT_DR_AP_STATE_CHANGE) != 0) {
return;
}
if (nvlist_unpack((char *)earg, size, &nvlp, NULL)) {
return;
}
if (nvlist_lookup_string(nvlp, PICLEVENTARG_DATA_TYPE, &dtype)) {
nvlist_free(nvlp);
return;
}
if (strcmp(dtype, PICLEVENTARG_PICLEVENT_DATA) != 0) {
nvlist_free(nvlp);
return;
}
if (nvlist_lookup_string(nvlp, PICLEVENTARG_AP_ID, &ap_id)) {
nvlist_free(nvlp);
return;
}
if (nvlist_lookup_string(nvlp, PICLEVENTARG_HINT, &hint)) {
nvlist_free(nvlp);
return;
}
mdp = mdesc_devinit();
if (mdp == NULL) {
nvlist_free(nvlp);
return;
}
rootnode = md_root_node(mdp);
if (strcmp(hint, DR_HINT_INSERT) == 0)
(void) update_devices(ap_id, DEV_ADD);
else if (strcmp(hint, DR_HINT_REMOVE) == 0)
(void) update_devices(ap_id, DEV_REMOVE);
mdesc_devfini(mdp);
nvlist_free(nvlp);
/*
* Signal the devtree plugin to add more cpu properties.
*/
signal_devtree();
}
static void
print_everstyle(tnode_t *node)
{
char buf[PATH_MAX], numbuf[64];
nvlist_t *fmri, **hcl;
int i, err;
uint_t n;
if (topo_prop_get_fmri(node, TOPO_PGROUP_PROTOCOL,
TOPO_PROP_RESOURCE, &fmri, &err) < 0) {
(void) fprintf(stderr, "%s: failed to get fmri for %s=%d: %s\n",
g_pname, topo_node_name(node),
topo_node_instance(node), topo_strerror(err));
return;
}
if (nvlist_lookup_nvlist_array(fmri, FM_FMRI_HC_LIST, &hcl, &n) != 0) {
(void) fprintf(stderr, "%s: failed to find %s for %s=%d\n",
g_pname, FM_FMRI_HC_LIST, topo_node_name(node),
topo_node_instance(node));
nvlist_free(fmri);
return;
}
buf[0] = '\0';
for (i = 0; i < n; i++) {
char *name, *inst, *estr;
ulong_t ul;
if (nvlist_lookup_string(hcl[i], FM_FMRI_HC_NAME, &name) != 0 ||
nvlist_lookup_string(hcl[i], FM_FMRI_HC_ID, &inst) != 0) {
(void) fprintf(stderr, "%s: failed to get "
"name-instance for %s=%d\n", g_pname,
topo_node_name(node), topo_node_instance(node));
nvlist_free(fmri);
return;
}
errno = 0;
ul = strtoul(inst, &estr, 10);
if (errno != 0 || estr == inst) {
(void) fprintf(stderr, "%s: instance %s does not "
"convert to an unsigned integer\n", g_pname, inst);
}
(void) strlcat(buf, "/", sizeof (buf));
(void) strlcat(buf, name, sizeof (buf));
(void) snprintf(numbuf, sizeof (numbuf), "%u", ul);
(void) strlcat(buf, numbuf, sizeof (buf));
}
nvlist_free(fmri);
(void) printf("%s\n", buf);
}
/*
* This function is called when we receive a devfs add event. This can be
* either a disk event or a lofi event, and the behavior is slightly different
* depending on which it is.
*/
static int
zfs_deliver_add(nvlist_t *nvl, boolean_t is_lofi)
{
char *devpath, *devname;
char path[PATH_MAX], realpath[PATH_MAX];
char *colon, *raw;
int ret;
/*
* The main unit of operation is the physical device path. For disks,
* this is the device node, as all minor nodes are affected. For lofi
* devices, this includes the minor path. Unfortunately, this isn't
* represented in the DEV_PHYS_PATH for various reasons.
*/
if (nvlist_lookup_string(nvl, DEV_PHYS_PATH, &devpath) != 0)
return (-1);
/*
* If this is a lofi device, then also get the minor instance name.
* Unfortunately, the current payload doesn't include an easy way to get
* this information. So we cheat by resolving the 'dev_name' (which
* refers to the raw device) and taking the portion between ':(*),raw'.
*/
(void) strlcpy(realpath, devpath, sizeof (realpath));
if (is_lofi) {
if (nvlist_lookup_string(nvl, DEV_NAME,
&devname) == 0 &&
(ret = resolvepath(devname, path,
sizeof (path))) > 0) {
path[ret] = '\0';
colon = strchr(path, ':');
if (colon != NULL)
raw = strstr(colon + 1, ",raw");
if (colon != NULL && raw != NULL) {
*raw = '\0';
(void) snprintf(realpath,
sizeof (realpath), "%s%s",
devpath, colon);
*raw = ',';
}
}
}
/*
* Iterate over all vdevs with a matching devid, and then those with a
* matching /devices path. For disks, we only want to pay attention to
* vdevs marked as whole disks. For lofi, we don't care (because we're
* matching an exact minor name).
*/
if (!devid_iter(realpath, zfs_process_add, !is_lofi))
(void) devpath_iter(realpath, zfs_process_add, !is_lofi);
return (0);
}
static void
set_fstyp_properties (LibHalContext *ctx, const char *udi, const char *fstype, nvlist_t *fsattr)
{
char buf[256];
DBusError error;
char *uuid = NULL;
char *label_orig = NULL;
char *label = NULL;
int err;
LibHalChangeSet *cs;
dbus_error_init (&error);
if ((cs = libhal_device_new_changeset (udi)) == NULL) {
return;
}
libhal_changeset_set_property_string (cs, "volume.fsusage", "filesystem");
libhal_changeset_set_property_string (cs, "volume.fstype", fstype);
/* label */
(void) nvlist_lookup_string(fsattr, "gen_volume_label", &label_orig);
if (label_orig != NULL) {
label = rtrim_copy(label_orig, 0);
}
/* Check if label is utf8 format */
if ((label != NULL) && (label[0] != '\0') &&
(u8_validate(label, strlen(label), (char **)NULL,
U8_VALIDATE_ENTIRE, &err) != -1)) {
libhal_changeset_set_property_string (cs, "volume.label", label);
libhal_changeset_set_property_string (cs, "info.product", label);
} else {
libhal_changeset_set_property_string (cs, "volume.label", "");
snprintf (buf, sizeof (buf), "Volume (%s)", fstype);
libhal_changeset_set_property_string (cs, "info.product", buf);
}
free(label);
/* uuid */
if (nvlist_lookup_string(fsattr, "gen_uuid", &uuid) == 0) {
libhal_changeset_set_property_string (cs, "volume.uuid", uuid);
} else {
libhal_changeset_set_property_string (cs, "volume.uuid", "");
}
libhal_device_commit_changeset (ctx, cs, &error);
libhal_device_free_changeset (cs);
my_dbus_error_free (&error);
}
gmem_dimm_t *
gmem_dimm_create(fmd_hdl_t *hdl, nvlist_t *asru, nvlist_t *det)
{
gmem_dimm_t *dimm;
nvlist_t *fmri;
char *serial;
uint32_t chip_id;
if (nvlist_lookup_string(asru, FM_FMRI_HC_SERIAL_ID, &serial) != 0) {
fmd_hdl_debug(hdl, "Unable to get dimm serial\n");
return (NULL);
}
if (nvlist_dup(asru, &fmri, 0) != 0) {
fmd_hdl_debug(hdl, "dimm create nvlist dup failed");
return (NULL);
}
(void) gmem_find_dimm_chip(det, &chip_id);
fmd_hdl_debug(hdl, "dimm_create: creating new DIMM serial=%s\n",
serial);
GMEM_STAT_BUMP(dimm_creat);
dimm = fmd_hdl_zalloc(hdl, sizeof (gmem_dimm_t), FMD_SLEEP);
dimm->dimm_nodetype = GMEM_NT_DIMM;
dimm->dimm_version = GMEM_DIMM_VERSION;
dimm->dimm_phys_addr_low = ULLONG_MAX;
dimm->dimm_phys_addr_hi = 0;
dimm->dimm_syl_error = USHRT_MAX;
dimm->dimm_chipid = chip_id;
gmem_bufname(dimm->dimm_bufname, sizeof (dimm->dimm_bufname), "dimm_%s",
serial);
gmem_fmri_init(hdl, &dimm->dimm_asru, fmri, "dimm_asru_%s", serial);
nvlist_free(fmri);
(void) nvlist_lookup_string(dimm->dimm_asru_nvl, FM_FMRI_HC_SERIAL_ID,
(char **)&dimm->dimm_serial);
gmem_mem_retirestat_create(hdl, &dimm->dimm_retstat, dimm->dimm_serial,
0, GMEM_DIMM_STAT_PREFIX);
gmem_list_append(&gmem.gm_dimms, dimm);
gmem_dimm_dirty(hdl, dimm);
return (dimm);
}
char *
fnvlist_lookup_string(nvlist_t *nvl, const char *name)
{
char *rv;
VERIFY0(nvlist_lookup_string(nvl, name, &rv));
return (rv);
}
/*
* Look up the diagcode for this case and cache it in ci_code. If no suspects
* were defined for this case or if the lookup fails, the event dictionary or
* module code is broken, and we set the event code to a precomputed default.
*/
static const char *
fmd_case_mkcode(fmd_case_t *cp)
{
fmd_case_impl_t *cip = (fmd_case_impl_t *)cp;
fmd_case_susp_t *cis;
char **keys, **keyp;
const char *s;
ASSERT(MUTEX_HELD(&cip->ci_lock));
ASSERT(cip->ci_state >= FMD_CASE_SOLVED);
fmd_free(cip->ci_code, cip->ci_codelen);
cip->ci_codelen = cip->ci_mod->mod_codelen;
cip->ci_code = fmd_zalloc(cip->ci_codelen, FMD_SLEEP);
keys = keyp = alloca(sizeof (char *) * (cip->ci_nsuspects + 1));
for (cis = cip->ci_suspects; cis != NULL; cis = cis->cis_next) {
if (nvlist_lookup_string(cis->cis_nvl, FM_CLASS, keyp) == 0)
keyp++;
}
*keyp = NULL; /* mark end of keys[] array for libdiagcode */
if (cip->ci_nsuspects == 0 || fmd_module_dc_key2code(
cip->ci_mod, keys, cip->ci_code, cip->ci_codelen) != 0) {
(void) fmd_conf_getprop(fmd.d_conf, "nodiagcode", &s);
fmd_free(cip->ci_code, cip->ci_codelen);
cip->ci_codelen = strlen(s) + 1;
cip->ci_code = fmd_zalloc(cip->ci_codelen, FMD_SLEEP);
(void) strcpy(cip->ci_code, s);
}
return (cip->ci_code);
}
/*
* If an asru has a unum string that is an hc path string then return
* a new nvl (to be freed by the caller) that is a duplicate of the
* original but with an additional member of a reconstituted hc fmri.
*/
int
mem_unum_rewrite(nvlist_t *nvl, nvlist_t **rnvl)
{
int err;
char *unumstr;
nvlist_t *unum;
struct topo_hdl *thp;
if (nvlist_lookup_string(nvl, FM_FMRI_MEM_UNUM, &unumstr) != 0 ||
!ISHCUNUM(unumstr))
return (0);
if ((thp = fmd_fmri_topo_hold(TOPO_VERSION)) == NULL)
return (EINVAL);
if (topo_fmri_str2nvl(thp, unumstr, &unum, &err) != 0) {
fmd_fmri_topo_rele(thp);
return (EINVAL);
}
fmd_fmri_topo_rele(thp);
if ((err = nvlist_dup(nvl, rnvl, 0)) != 0) {
nvlist_free(unum);
return (err);
}
err = nvlist_add_nvlist(*rnvl, FM_FMRI_MEM_UNUM "-fmri", unum);
nvlist_free(unum);
if (err != 0)
nvlist_free(*rnvl);
return (err);
}
int
zfs_deliver_dle(nvlist_t *nvl)
{
char *devname;
if (nvlist_lookup_string(nvl, DEV_PHYS_PATH, &devname) != 0) {
syseventd_print(9, "zfs_deliver_event: no physpath\n");
return (-1);
}
if (strncmp(devname, DEVICE_PREFIX, strlen(DEVICE_PREFIX)) != 0) {
syseventd_print(9, "zfs_deliver_event: invalid "
"device '%s'", devname);
return (-1);
}
/*
* We try to find the device using the physical
* path that has been supplied. We need to strip off
* the /devices prefix before starting our search.
*/
devname += strlen(DEVICE_PREFIX);
if (zpool_iter(g_zfshdl, zfsdle_vdev_online, devname) != 1) {
syseventd_print(9, "zfs_deliver_event: device '%s' not"
" found\n", devname);
return (1);
}
return (0);
}
static boolean_t
proplist_has_encryption_props(nvlist_t *props)
{
int ret;
uint64_t intval;
char *strval;
ret = nvlist_lookup_uint64(props,
zfs_prop_to_name(ZFS_PROP_ENCRYPTION), &intval);
if (ret == 0 && intval != ZIO_CRYPT_OFF)
return (B_TRUE);
ret = nvlist_lookup_string(props,
zfs_prop_to_name(ZFS_PROP_KEYLOCATION), &strval);
if (ret == 0 && strcmp(strval, "none") != 0)
return (B_TRUE);
ret = nvlist_lookup_uint64(props,
zfs_prop_to_name(ZFS_PROP_KEYFORMAT), &intval);
if (ret == 0)
return (B_TRUE);
ret = nvlist_lookup_uint64(props,
zfs_prop_to_name(ZFS_PROP_PBKDF2_ITERS), &intval);
if (ret == 0)
return (B_TRUE);
return (B_FALSE);
}
int
fstyp_zfs(FILE *fp, char *label, size_t labelsize)
{
vdev_label_t *vdev_label = NULL;
vdev_phys_t *vdev_phys;
char *zpool_name = NULL;
nvlist_t *config = NULL;
int err = 0;
/*
* Read in the first ZFS vdev label ("L0"), located at the beginning
* of the vdev and extract the pool name from it.
*
* TODO: the checksum of label should be validated.
*/
vdev_label = (vdev_label_t *)read_buf(fp, 0, sizeof(*vdev_label));
if (vdev_label == NULL)
return (1);
vdev_phys = &(vdev_label->vl_vdev_phys);
if ((nvlist_unpack(vdev_phys->vp_nvlist, sizeof(vdev_phys->vp_nvlist),
&config, 0)) == 0 &&
(nvlist_lookup_string(config, "name", &zpool_name) == 0)) {
strlcpy(label, zpool_name, labelsize);
} else
err = 1;
nvlist_free(config);
free(vdev_label);
return (err);
}
/*
* Function: be_activate
* Description: Calls _be_activate which activates the BE named in the
* attributes passed in through be_attrs. The process of
* activation sets the bootfs property of the root pool, resets
* the canmount property to noauto, and sets the default in the
* grub menu to the entry corresponding to the entry for the named
* BE.
* Parameters:
* be_attrs - pointer to nvlist_t of attributes being passed in.
* The follow attribute values are used by this function:
*
* BE_ATTR_ORIG_BE_NAME *required
* Return:
* BE_SUCCESS - Success
* be_errno_t - Failure
* Scope:
* Public
*/
int
be_activate(nvlist_t *be_attrs)
{
int ret = BE_SUCCESS;
char *be_name = NULL;
/* Initialize libzfs handle */
if (!be_zfs_init())
return (BE_ERR_INIT);
/* Get the BE name to activate */
if (nvlist_lookup_string(be_attrs, BE_ATTR_ORIG_BE_NAME, &be_name)
!= 0) {
be_print_err(gettext("be_activate: failed to "
"lookup BE_ATTR_ORIG_BE_NAME attribute\n"));
be_zfs_fini();
return (BE_ERR_INVAL);
}
/* Validate BE name */
if (!be_valid_be_name(be_name)) {
be_print_err(gettext("be_activate: invalid BE name %s\n"),
be_name);
be_zfs_fini();
return (BE_ERR_INVAL);
}
ret = _be_activate(be_name);
be_zfs_fini();
return (ret);
}
/*
* 'avail_spare' is set to TRUE if the provided guid refers to an AVAIL
* spare; but FALSE if its an INUSE spare.
*/
static nvlist_t *
vdev_to_nvlist_iter(nvlist_t *nv, const char *search, uint64_t guid,
boolean_t *avail_spare)
{
uint_t c, children;
nvlist_t **child;
uint64_t theguid, present;
char *path;
uint64_t wholedisk = 0;
nvlist_t *ret;
verify(nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID, &theguid) == 0);
if (search == NULL &&
nvlist_lookup_uint64(nv, ZPOOL_CONFIG_NOT_PRESENT, &present) == 0) {
/*
* If the device has never been present since import, the only
* reliable way to match the vdev is by GUID.
*/
if (theguid == guid)
return (nv);
} else if (search != NULL &&
nvlist_lookup_string(nv, ZPOOL_CONFIG_PATH, &path) == 0) {
(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_WHOLE_DISK,
&wholedisk);
if (wholedisk) {
/*
* For whole disks, the internal path has 's0', but the
* path passed in by the user doesn't.
*/
if (strlen(search) == strlen(path) - 2 &&
strncmp(search, path, strlen(search)) == 0)
return (nv);
} else if (strcmp(search, path) == 0) {
return (nv);
}
}
if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
&child, &children) != 0)
return (NULL);
for (c = 0; c < children; c++)
if ((ret = vdev_to_nvlist_iter(child[c], search, guid,
avail_spare)) != NULL)
return (ret);
if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_SPARES,
&child, &children) == 0) {
for (c = 0; c < children; c++) {
if ((ret = vdev_to_nvlist_iter(child[c], search, guid,
avail_spare)) != NULL) {
*avail_spare = B_TRUE;
return (ret);
}
}
}
return (NULL);
}
int
topo_fmri_unretire(topo_hdl_t *thp, nvlist_t *fmri, int *err)
{
char *scheme;
uint32_t status;
nvlist_t *out = NULL;
tnode_t *rnode;
if (nvlist_lookup_string(fmri, FM_FMRI_SCHEME, &scheme) != 0)
return (set_error(thp, ETOPO_FMRI_MALFORM, err,
TOPO_METH_UNRETIRE, out));
if ((rnode = topo_hdl_root(thp, scheme)) == NULL)
return (set_error(thp, ETOPO_METHOD_NOTSUP, err,
TOPO_METH_UNRETIRE, out));
if (topo_method_invoke(rnode, TOPO_METH_UNRETIRE,
TOPO_METH_UNRETIRE_VERSION, fmri, &out, err) < 0)
return (set_error(thp, *err, err, TOPO_METH_UNRETIRE, out));
if (nvlist_lookup_uint32(out, TOPO_METH_UNRETIRE_RET, &status) != 0) {
nvlist_free(out);
return (set_error(thp, ETOPO_METHOD_FAIL, err,
TOPO_METH_UNRETIRE, out));
}
nvlist_free(out);
return (status);
}
char *
fmdump_nvl2str(nvlist_t *nvl)
{
fmd_scheme_t *sp;
char c, *name, *s = NULL;
ssize_t len;
if (nvlist_lookup_string(nvl, FM_FMRI_SCHEME, &name) != 0) {
fmdump_warn("fmri does not contain required '%s' nvpair\n",
FM_FMRI_SCHEME);
return (NULL);
}
if ((sp = fmd_scheme_lookup("/usr/lib/fm/fmd/schemes", name)) == NULL ||
sp->sch_dlp == NULL || sp->sch_err != 0) {
const char *msg =
sp->sch_err == ELIBACC ? dlerror() : strerror(sp->sch_err);
fmdump_warn("cannot init '%s' scheme library to "
"format fmri: %s\n", name, msg ? msg : "unknown error");
return (NULL);
}
if ((len = sp->sch_ops.sop_nvl2str(nvl, &c, sizeof (c))) == -1 ||
(s = malloc(len + 1)) == NULL ||
sp->sch_ops.sop_nvl2str(nvl, s, len + 1) == -1) {
fmdump_warn("cannot format fmri using scheme '%s'", name);
free(s);
return (NULL);
}
return (s);
}
int
topo_fmri_service_state(topo_hdl_t *thp, nvlist_t *fmri, int *err)
{
char *scheme;
uint32_t service_state = FMD_SERVICE_STATE_UNKNOWN;
nvlist_t *out = NULL;
tnode_t *rnode;
if (nvlist_lookup_string(fmri, FM_FMRI_SCHEME, &scheme) != 0)
return (set_error(thp, ETOPO_FMRI_MALFORM, err,
TOPO_METH_SERVICE_STATE, out));
if ((rnode = topo_hdl_root(thp, scheme)) == NULL)
return (set_error(thp, ETOPO_METHOD_NOTSUP, err,
TOPO_METH_SERVICE_STATE, out));
if (topo_method_invoke(rnode, TOPO_METH_SERVICE_STATE,
TOPO_METH_SERVICE_STATE_VERSION, fmri, &out, err) < 0)
return (set_error(thp, *err, err, TOPO_METH_SERVICE_STATE,
out));
(void) nvlist_lookup_uint32(out, TOPO_METH_SERVICE_STATE_RET,
&service_state);
nvlist_free(out);
return (service_state);
}
cmd_branch_t *
cmd_branch_create(fmd_hdl_t *hdl, nvlist_t *asru)
{
cmd_branch_t *branch;
const char *b_unum;
if ((b_unum = cmd_fmri_get_unum(asru)) == NULL) {
CMD_STAT_BUMP(bad_mem_asru);
return (NULL);
}
fmd_hdl_debug(hdl, "branch_create: creating new branch %s\n", b_unum);
CMD_STAT_BUMP(branch_creat);
branch = fmd_hdl_zalloc(hdl, sizeof (cmd_branch_t), FMD_SLEEP);
branch->branch_nodetype = CMD_NT_BRANCH;
branch->branch_version = CMD_BRANCH_VERSION;
cmd_bufname(branch->branch_bufname, sizeof (branch->branch_bufname),
"branch_%s", b_unum);
cmd_fmri_init(hdl, &branch->branch_asru, asru, "branch_asru_%s",
b_unum);
(void) nvlist_lookup_string(branch->branch_asru_nvl, FM_FMRI_MEM_UNUM,
(char **)&branch->branch_unum);
cmd_list_append(&cmd.cmd_branches, branch);
cmd_branch_dirty(hdl, branch);
return (branch);
}
/*
* Locate a jail based on an arbitrary identifier. This may be either a name,
* a jid, or a BE name. Returns the jid or -1 on failure.
*/
static int
bectl_locate_jail(const char *ident)
{
nvlist_t *belist, *props;
char *mnt;
int jid;
/* Try the easy-match first */
jid = jail_getid(ident);
if (jid != -1)
return (jid);
/* Attempt to try it as a BE name, first */
if (be_prop_list_alloc(&belist) != 0)
return (-1);
if (be_get_bootenv_props(be, belist) != 0)
return (-1);
if (nvlist_lookup_nvlist(belist, ident, &props) == 0) {
/* path where a boot environment is mounted */
if (nvlist_lookup_string(props, "mounted", &mnt) == 0) {
/* looking for a jail that matches our bootenv path */
jid = bectl_search_jail_paths(mnt);
be_prop_list_free(belist);
return (jid);
}
be_prop_list_free(belist);
}
return (-1);
}
static int
name_or_guid_exists(zpool_handle_t *zhp, void *data)
{
importargs_t *import = data;
int found = 0;
if (import->poolname != NULL) {
char *pool_name;
verify(nvlist_lookup_string(zhp->zpool_config,
ZPOOL_CONFIG_POOL_NAME, &pool_name) == 0);
if (strcmp(pool_name, import->poolname) == 0)
found = 1;
} else {
uint64_t pool_guid;
verify(nvlist_lookup_uint64(zhp->zpool_config,
ZPOOL_CONFIG_POOL_GUID, &pool_guid) == 0);
if (pool_guid == import->guid)
found = 1;
}
zpool_close(zhp);
return (found);
}
/*ARGSUSED*/
static void
event_handler(void *cookie, char *argp, size_t asize,
door_desc_t *dp, uint_t n_desc)
{
door_cred_t cred;
nvlist_t *nvlp;
char *dtype;
if (piclevent_debug)
syslog(LOG_INFO,
"piclevent: got SLM event cookie:%p evarg:%p size:0x%x\n",
cookie, argp, asize);
if ((door_id < 0) || (argp == NULL) || (door_cred(&cred) < 0) ||
(cred.dc_euid != 0))
(void) door_return(argp, 0, NULL, 0);
if (nvlist_unpack(argp, asize, &nvlp, NULL))
(void) door_return(argp, 0, NULL, 0);
if (nvlist_lookup_string(nvlp, PICLEVENTARG_DATA_TYPE, &dtype)) {
nvlist_free(nvlp);
(void) door_return(argp, 0, NULL, 0);
}
if (strcmp(dtype, PICLEVENTARG_PICLEVENT_DATA) == 0)
parse_piclevent(nvlp);
/*
* ignore other event data types
*/
nvlist_free(nvlp);
(void) door_return(argp, 0, NULL, 0);
}
