static int get_disk_online(dm_descriptor_t disk, int *error) { uint32_t status = 0; nvlist_t *attrs; *error = 0; attrs = dm_get_attributes(disk, error); if (*error) { handle_error("could not get disk attributes for disk"); } else { /* Try to get the status */ nvpair_t *match = zjni_nvlist_walk_nvpair( attrs, DM_STATUS, DATA_TYPE_UINT32, NULL); if (match == NULL || nvpair_value_uint32(match, &status)) { handle_error("could not get status of disk"); *error = 1; } nvlist_free(attrs); } return (status != 0); }
uint32_t fnvpair_value_uint32(nvpair_t *nvp) { uint32_t rv; VERIFY0(nvpair_value_uint32(nvp, &rv)); return (rv); }
static void get_disk_size(dm_descriptor_t media, char *name, uint64_t *size, uint32_t *blocksize, int *error) { nvlist_t *attrs; *size = 0; *error = 0; attrs = dm_get_attributes(media, error); if (*error) { handle_error("could not get media attributes from disk: %s", name); } else { /* Try to get the number of accessible blocks */ nvpair_t *match = zjni_nvlist_walk_nvpair( attrs, DM_NACCESSIBLE, DATA_TYPE_UINT64, NULL); if (match == NULL || nvpair_value_uint64(match, size)) { /* Disk is probably not labeled, get raw size instead */ match = zjni_nvlist_walk_nvpair( attrs, DM_SIZE, DATA_TYPE_UINT64, NULL); if (match == NULL || nvpair_value_uint64(match, size)) { handle_error("could not get size of disk: %s", name); *error = 1; } } if (*error == 0) { match = zjni_nvlist_walk_nvpair( attrs, DM_BLOCKSIZE, DATA_TYPE_UINT32, NULL); if (match == NULL || nvpair_value_uint32(match, blocksize)) { handle_error("could not get " "block size of disk: %s", name); *error = 1; } else { *size *= *blocksize; } } nvlist_free(attrs); } }
/* * Get the named uint32 from the given nvlist_t. * * @param attrs * the nvlist_t to search * * @param which * the string key for this element in the list * * @param val * RETURN: the value of the requested uint32 * * @return 0 * if successful * * @return ENOENT * if no matching name-value pair is found */ int get_uint32( nvlist_t *attrs, char *which, uint32_t *val) { int error; nvpair_t *match = nvlist_walk_nvpair(attrs, which, DATA_TYPE_UINT32, NULL); if (match == NULL) { error = ENOENT; } else { error = nvpair_value_uint32(match, val); } return (error); }
void zpool_get_load_policy(nvlist_t *nvl, zpool_load_policy_t *zlpp) { nvlist_t *policy; nvpair_t *elem; char *nm; /* Defaults */ zlpp->zlp_rewind = ZPOOL_NO_REWIND; zlpp->zlp_maxmeta = 0; zlpp->zlp_maxdata = UINT64_MAX; zlpp->zlp_txg = UINT64_MAX; if (nvl == NULL) return; elem = NULL; while ((elem = nvlist_next_nvpair(nvl, elem)) != NULL) { nm = nvpair_name(elem); if (strcmp(nm, ZPOOL_LOAD_POLICY) == 0) { if (nvpair_value_nvlist(elem, &policy) == 0) zpool_get_load_policy(policy, zlpp); return; } else if (strcmp(nm, ZPOOL_LOAD_REWIND_POLICY) == 0) { if (nvpair_value_uint32(elem, &zlpp->zlp_rewind) == 0) if (zlpp->zlp_rewind & ~ZPOOL_REWIND_POLICIES) zlpp->zlp_rewind = ZPOOL_NO_REWIND; } else if (strcmp(nm, ZPOOL_LOAD_REQUEST_TXG) == 0) { (void) nvpair_value_uint64(elem, &zlpp->zlp_txg); } else if (strcmp(nm, ZPOOL_LOAD_META_THRESH) == 0) { (void) nvpair_value_uint64(elem, &zlpp->zlp_maxmeta); } else if (strcmp(nm, ZPOOL_LOAD_DATA_THRESH) == 0) { (void) nvpair_value_uint64(elem, &zlpp->zlp_maxdata); } } if (zlpp->zlp_rewind == 0) zlpp->zlp_rewind = ZPOOL_NO_REWIND; }
/* * nvlist_print - Prints elements in an event buffer */ static void nvlist_print_with_indent(FILE *fp, nvlist_t *nvl, int depth) { int i; char *name; uint_t nelem; nvpair_t *nvp; if (nvl == NULL) return; indent(fp, depth); (void) fprintf(fp, "nvlist version: %d\n", NVL_VERSION(nvl)); nvp = nvlist_next_nvpair(nvl, NULL); while (nvp) { data_type_t type = nvpair_type(nvp); indent(fp, depth); name = nvpair_name(nvp); (void) fprintf(fp, "\t%s =", name); nelem = 0; switch (type) { case DATA_TYPE_BOOLEAN: { (void) fprintf(fp, " 1"); break; } case DATA_TYPE_BOOLEAN_VALUE: { boolean_t val; (void) nvpair_value_boolean_value(nvp, &val); (void) fprintf(fp, " %d", val); break; } case DATA_TYPE_BYTE: { uchar_t val; (void) nvpair_value_byte(nvp, &val); (void) fprintf(fp, " 0x%2.2x", val); break; } case DATA_TYPE_INT8: { int8_t val; (void) nvpair_value_int8(nvp, &val); (void) fprintf(fp, " %d", val); break; } case DATA_TYPE_UINT8: { uint8_t val; (void) nvpair_value_uint8(nvp, &val); (void) fprintf(fp, " 0x%x", val); break; } case DATA_TYPE_INT16: { int16_t val; (void) nvpair_value_int16(nvp, &val); (void) fprintf(fp, " %d", val); break; } case DATA_TYPE_UINT16: { uint16_t val; (void) nvpair_value_uint16(nvp, &val); (void) fprintf(fp, " 0x%x", val); break; } case DATA_TYPE_INT32: { int32_t val; (void) nvpair_value_int32(nvp, &val); (void) fprintf(fp, " %d", val); break; } case DATA_TYPE_UINT32: { uint32_t val; (void) nvpair_value_uint32(nvp, &val); (void) fprintf(fp, " 0x%x", val); break; } case DATA_TYPE_INT64: { int64_t val; (void) nvpair_value_int64(nvp, &val); (void) fprintf(fp, " %lld", (longlong_t)val); break; } case DATA_TYPE_UINT64: { uint64_t val; (void) nvpair_value_uint64(nvp, &val); (void) fprintf(fp, " 0x%llx", (u_longlong_t)val); break; } case DATA_TYPE_DOUBLE: { double val; (void) nvpair_value_double(nvp, &val); (void) fprintf(fp, " 0x%llf", val); break; } case DATA_TYPE_STRING: { char *val; (void) nvpair_value_string(nvp, &val); (void) fprintf(fp, " %s", val); break; } case DATA_TYPE_BOOLEAN_ARRAY: { boolean_t *val; (void) nvpair_value_boolean_array(nvp, &val, &nelem); for (i = 0; i < nelem; i++) (void) fprintf(fp, " %d", val[i]); break; } case DATA_TYPE_BYTE_ARRAY: { uchar_t *val; (void) nvpair_value_byte_array(nvp, &val, &nelem); for (i = 0; i < nelem; i++) (void) fprintf(fp, " 0x%2.2x", val[i]); break; } case DATA_TYPE_INT8_ARRAY: { int8_t *val; (void) nvpair_value_int8_array(nvp, &val, &nelem); for (i = 0; i < nelem; i++) (void) fprintf(fp, " %d", val[i]); break; } case DATA_TYPE_UINT8_ARRAY: { uint8_t *val; (void) nvpair_value_uint8_array(nvp, &val, &nelem); for (i = 0; i < nelem; i++) (void) fprintf(fp, " 0x%x", val[i]); break; } case DATA_TYPE_INT16_ARRAY: { int16_t *val; (void) nvpair_value_int16_array(nvp, &val, &nelem); for (i = 0; i < nelem; i++) (void) fprintf(fp, " %d", val[i]); break; } case DATA_TYPE_UINT16_ARRAY: { uint16_t *val; (void) nvpair_value_uint16_array(nvp, &val, &nelem); for (i = 0; i < nelem; i++) (void) fprintf(fp, " 0x%x", val[i]); break; } case DATA_TYPE_INT32_ARRAY: { int32_t *val; (void) nvpair_value_int32_array(nvp, &val, &nelem); for (i = 0; i < nelem; i++) (void) fprintf(fp, " %d", val[i]); break; } case DATA_TYPE_UINT32_ARRAY: { uint32_t *val; (void) nvpair_value_uint32_array(nvp, &val, &nelem); for (i = 0; i < nelem; i++) (void) fprintf(fp, " 0x%x", val[i]); break; } case DATA_TYPE_INT64_ARRAY: { int64_t *val; (void) nvpair_value_int64_array(nvp, &val, &nelem); for (i = 0; i < nelem; i++) (void) fprintf(fp, " %lld", (longlong_t)val[i]); break; } case DATA_TYPE_UINT64_ARRAY: { uint64_t *val; (void) nvpair_value_uint64_array(nvp, &val, &nelem); for (i = 0; i < nelem; i++) (void) fprintf(fp, " 0x%llx", (u_longlong_t)val[i]); break; } case DATA_TYPE_STRING_ARRAY: { char **val; (void) nvpair_value_string_array(nvp, &val, &nelem); for (i = 0; i < nelem; i++) (void) fprintf(fp, " %s", val[i]); break; } case DATA_TYPE_HRTIME: { hrtime_t val; (void) nvpair_value_hrtime(nvp, &val); (void) fprintf(fp, " 0x%llx", val); break; } case DATA_TYPE_NVLIST: { nvlist_t *val; (void) nvpair_value_nvlist(nvp, &val); (void) fprintf(fp, " (embedded nvlist)\n"); nvlist_print_with_indent(fp, val, depth + 1); indent(fp, depth + 1); (void) fprintf(fp, "(end %s)\n", name); break; } case DATA_TYPE_NVLIST_ARRAY: { nvlist_t **val; (void) nvpair_value_nvlist_array(nvp, &val, &nelem); (void) fprintf(fp, " (array of embedded nvlists)\n"); for (i = 0; i < nelem; i++) { indent(fp, depth + 1); (void) fprintf(fp, "(start %s[%d])\n", name, i); nvlist_print_with_indent(fp, val[i], depth + 1); indent(fp, depth + 1); (void) fprintf(fp, "(end %s[%d])\n", name, i); } break; } default: (void) fprintf(fp, " unknown data type (%d)", type); break; } (void) fprintf(fp, "\n"); nvp = nvlist_next_nvpair(nvl, nvp); } }
/* * Determine if string 'value' matches 'nvp' value. The 'value' string is * converted, depending on the type of 'nvp', prior to match. For numeric * types, a radix independent sscanf conversion of 'value' is used. If 'nvp' * is an array type, 'ai' is the index into the array against which we are * checking for match. If nvp is of DATA_TYPE_STRING*, the caller can pass * in a regex_t compilation of value in 'value_regex' to trigger regular * expression string match instead of simple strcmp(). * * Return 1 on match, 0 on no-match, and -1 on error. If the error is * related to value syntax error and 'ep' is non-NULL, *ep will point into * the 'value' string at the location where the error exists. * * NOTE: It may be possible to move the non-regex_t version of this into * common code used by library/kernel/boot. */ int nvpair_value_match_regex(nvpair_t *nvp, int ai, char *value, regex_t *value_regex, char **ep) { char *evalue; uint_t a_len; int sr; if (ep) *ep = NULL; if ((nvp == NULL) || (value == NULL)) return (-1); /* error fail match - invalid args */ /* make sure array and index combination make sense */ if ((nvpair_type_is_array(nvp) && (ai < 0)) || (!nvpair_type_is_array(nvp) && (ai >= 0))) return (-1); /* error fail match - bad index */ /* non-string values should be single 'chunk' */ if ((nvpair_type(nvp) != DATA_TYPE_STRING) && (nvpair_type(nvp) != DATA_TYPE_STRING_ARRAY)) { value += strspn(value, " \t"); evalue = value + strcspn(value, " \t"); if (*evalue) { if (ep) *ep = evalue; return (-1); /* error fail match - syntax */ } } sr = EOF; switch (nvpair_type(nvp)) { case DATA_TYPE_STRING: { char *val; /* check string value for match */ if (nvpair_value_string(nvp, &val) == 0) { if (value_regex) { if (regexec(value_regex, val, (size_t)0, NULL, 0) == 0) return (1); /* match */ } else { if (strcmp(value, val) == 0) return (1); /* match */ } } break; } case DATA_TYPE_STRING_ARRAY: { char **val_array; /* check indexed string value of array for match */ if ((nvpair_value_string_array(nvp, &val_array, &a_len) == 0) && (ai < a_len)) { if (value_regex) { if (regexec(value_regex, val_array[ai], (size_t)0, NULL, 0) == 0) return (1); } else { if (strcmp(value, val_array[ai]) == 0) return (1); } } break; } case DATA_TYPE_BYTE: { uchar_t val, val_arg; /* scanf uchar_t from value and check for match */ sr = sscanf(value, "%c", &val_arg); if ((sr == 1) && (nvpair_value_byte(nvp, &val) == 0) && (val == val_arg)) return (1); break; } case DATA_TYPE_BYTE_ARRAY: { uchar_t *val_array, val_arg; /* check indexed value of array for match */ sr = sscanf(value, "%c", &val_arg); if ((sr == 1) && (nvpair_value_byte_array(nvp, &val_array, &a_len) == 0) && (ai < a_len) && (val_array[ai] == val_arg)) return (1); break; } case DATA_TYPE_INT8: { int8_t val, val_arg; /* scanf int8_t from value and check for match */ sr = sscanf(value, "%"SCNi8, &val_arg); if ((sr == 1) && (nvpair_value_int8(nvp, &val) == 0) && (val == val_arg)) return (1); break; } case DATA_TYPE_INT8_ARRAY: { int8_t *val_array, val_arg; /* check indexed value of array for match */ sr = sscanf(value, "%"SCNi8, &val_arg); if ((sr == 1) && (nvpair_value_int8_array(nvp, &val_array, &a_len) == 0) && (ai < a_len) && (val_array[ai] == val_arg)) return (1); break; } case DATA_TYPE_UINT8: { uint8_t val, val_arg; /* scanf uint8_t from value and check for match */ sr = sscanf(value, "%"SCNi8, (int8_t *)&val_arg); if ((sr == 1) && (nvpair_value_uint8(nvp, &val) == 0) && (val == val_arg)) return (1); break; } case DATA_TYPE_UINT8_ARRAY: { uint8_t *val_array, val_arg; /* check indexed value of array for match */ sr = sscanf(value, "%"SCNi8, (int8_t *)&val_arg); if ((sr == 1) && (nvpair_value_uint8_array(nvp, &val_array, &a_len) == 0) && (ai < a_len) && (val_array[ai] == val_arg)) return (1); break; } case DATA_TYPE_INT16: { int16_t val, val_arg; /* scanf int16_t from value and check for match */ sr = sscanf(value, "%"SCNi16, &val_arg); if ((sr == 1) && (nvpair_value_int16(nvp, &val) == 0) && (val == val_arg)) return (1); break; } case DATA_TYPE_INT16_ARRAY: { int16_t *val_array, val_arg; /* check indexed value of array for match */ sr = sscanf(value, "%"SCNi16, &val_arg); if ((sr == 1) && (nvpair_value_int16_array(nvp, &val_array, &a_len) == 0) && (ai < a_len) && (val_array[ai] == val_arg)) return (1); break; } case DATA_TYPE_UINT16: { uint16_t val, val_arg; /* scanf uint16_t from value and check for match */ sr = sscanf(value, "%"SCNi16, (int16_t *)&val_arg); if ((sr == 1) && (nvpair_value_uint16(nvp, &val) == 0) && (val == val_arg)) return (1); break; } case DATA_TYPE_UINT16_ARRAY: { uint16_t *val_array, val_arg; /* check indexed value of array for match */ sr = sscanf(value, "%"SCNi16, (int16_t *)&val_arg); if ((sr == 1) && (nvpair_value_uint16_array(nvp, &val_array, &a_len) == 0) && (ai < a_len) && (val_array[ai] == val_arg)) return (1); break; } case DATA_TYPE_INT32: { int32_t val, val_arg; /* scanf int32_t from value and check for match */ sr = sscanf(value, "%"SCNi32, &val_arg); if ((sr == 1) && (nvpair_value_int32(nvp, &val) == 0) && (val == val_arg)) return (1); break; } case DATA_TYPE_INT32_ARRAY: { int32_t *val_array, val_arg; /* check indexed value of array for match */ sr = sscanf(value, "%"SCNi32, &val_arg); if ((sr == 1) && (nvpair_value_int32_array(nvp, &val_array, &a_len) == 0) && (ai < a_len) && (val_array[ai] == val_arg)) return (1); break; } case DATA_TYPE_UINT32: { uint32_t val, val_arg; /* scanf uint32_t from value and check for match */ sr = sscanf(value, "%"SCNi32, (int32_t *)&val_arg); if ((sr == 1) && (nvpair_value_uint32(nvp, &val) == 0) && (val == val_arg)) return (1); break; } case DATA_TYPE_UINT32_ARRAY: { uint32_t *val_array, val_arg; /* check indexed value of array for match */ sr = sscanf(value, "%"SCNi32, (int32_t *)&val_arg); if ((sr == 1) && (nvpair_value_uint32_array(nvp, &val_array, &a_len) == 0) && (ai < a_len) && (val_array[ai] == val_arg)) return (1); break; } case DATA_TYPE_INT64: { int64_t val, val_arg; /* scanf int64_t from value and check for match */ sr = sscanf(value, "%"SCNi64, &val_arg); if ((sr == 1) && (nvpair_value_int64(nvp, &val) == 0) && (val == val_arg)) return (1); break; } case DATA_TYPE_INT64_ARRAY: { int64_t *val_array, val_arg; /* check indexed value of array for match */ sr = sscanf(value, "%"SCNi64, &val_arg); if ((sr == 1) && (nvpair_value_int64_array(nvp, &val_array, &a_len) == 0) && (ai < a_len) && (val_array[ai] == val_arg)) return (1); break; } case DATA_TYPE_UINT64: { uint64_t val_arg, val; /* scanf uint64_t from value and check for match */ sr = sscanf(value, "%"SCNi64, (int64_t *)&val_arg); if ((sr == 1) && (nvpair_value_uint64(nvp, &val) == 0) && (val == val_arg)) return (1); break; } case DATA_TYPE_UINT64_ARRAY: { uint64_t *val_array, val_arg; /* check indexed value of array for match */ sr = sscanf(value, "%"SCNi64, (int64_t *)&val_arg); if ((sr == 1) && (nvpair_value_uint64_array(nvp, &val_array, &a_len) == 0) && (ai < a_len) && (val_array[ai] == val_arg)) return (1); break; } case DATA_TYPE_BOOLEAN_VALUE: { boolean_t val, val_arg; /* scanf boolean_t from value and check for match */ sr = sscanf(value, "%"SCNi32, &val_arg); if ((sr == 1) && (nvpair_value_boolean_value(nvp, &val) == 0) && (val == val_arg)) return (1); break; } case DATA_TYPE_BOOLEAN_ARRAY: { boolean_t *val_array, val_arg; /* check indexed value of array for match */ sr = sscanf(value, "%"SCNi32, &val_arg); if ((sr == 1) && (nvpair_value_boolean_array(nvp, &val_array, &a_len) == 0) && (ai < a_len) && (val_array[ai] == val_arg)) return (1); break; } case DATA_TYPE_HRTIME: case DATA_TYPE_NVLIST: case DATA_TYPE_NVLIST_ARRAY: case DATA_TYPE_BOOLEAN: case DATA_TYPE_DOUBLE: case DATA_TYPE_UNKNOWN: default: /* * unknown/unsupported data type */ return (-1); /* error fail match */ } /* * check to see if sscanf failed conversion, return approximate * pointer to problem */ if (sr != 1) { if (ep) *ep = value; return (-1); /* error fail match - syntax */ } return (0); /* fail match */ }
/* * Copy in a packed nvlist from the user and create a request set out of it. * If successful, return 0 and store a pointer to the set we've created. Returns * error code on error. */ int kcpc_copyin_set(kcpc_set_t **inset, void *ubuf, size_t len) { kcpc_set_t *set; int i; int j; char *packbuf; nvlist_t *nvl; nvpair_t *nvp = NULL; nvlist_t *attrs; nvpair_t *nvp_attr; kcpc_attr_t *attrp; nvlist_t **reqlist; uint_t nreqs; uint64_t uint64; uint32_t uint32; uint32_t setflags = (uint32_t)-1; char *string; char *name; if (len < CPC_MIN_PACKSIZE || len > CPC_MAX_PACKSIZE) return (EINVAL); packbuf = kmem_alloc(len, KM_SLEEP); if (copyin(ubuf, packbuf, len) == -1) { kmem_free(packbuf, len); return (EFAULT); } if (nvlist_unpack(packbuf, len, &nvl, KM_SLEEP) != 0) { kmem_free(packbuf, len); return (EINVAL); } /* * The nvlist has been unpacked so there is no need for the packed * representation from this point on. */ kmem_free(packbuf, len); i = 0; while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) { switch (nvpair_type(nvp)) { case DATA_TYPE_UINT32: if (strcmp(nvpair_name(nvp), "flags") != 0 || nvpair_value_uint32(nvp, &setflags) != 0) { nvlist_free(nvl); return (EINVAL); } break; case DATA_TYPE_NVLIST_ARRAY: if (strcmp(nvpair_name(nvp), "reqs") != 0 || nvpair_value_nvlist_array(nvp, &reqlist, &nreqs) != 0) { nvlist_free(nvl); return (EINVAL); } break; default: nvlist_free(nvl); return (EINVAL); } i++; } /* * There should be two members in the top-level nvlist: * an array of nvlists consisting of the requests, and flags. * Anything else is an invalid set. */ if (i != 2) { nvlist_free(nvl); return (EINVAL); } if (nreqs > CPC_MAX_NREQS) { nvlist_free(nvl); return (EINVAL); } /* * The requests are now stored in the nvlist array at reqlist. * Note that the use of kmem_zalloc() to alloc the kcpc_set_t means * we don't need to call the init routines for ks_lock and ks_condv. */ set = kmem_zalloc(sizeof (kcpc_set_t), KM_SLEEP); set->ks_req = (kcpc_request_t *)kmem_zalloc(sizeof (kcpc_request_t) * nreqs, KM_SLEEP); set->ks_nreqs = nreqs; /* * If the nvlist didn't contain a flags member, setflags was initialized * with an illegal value and this set will fail sanity checks later on. */ set->ks_flags = setflags; /* * Initialize bind/unbind set synchronization. */ set->ks_state &= ~KCPC_SET_BOUND; /* * Build the set up one request at a time, always keeping it self- * consistent so we can give it to kcpc_free_set() if we need to back * out and return and error. */ for (i = 0; i < nreqs; i++) { nvp = NULL; set->ks_req[i].kr_picnum = -1; while ((nvp = nvlist_next_nvpair(reqlist[i], nvp)) != NULL) { name = nvpair_name(nvp); switch (nvpair_type(nvp)) { case DATA_TYPE_UINT32: if (nvpair_value_uint32(nvp, &uint32) == EINVAL) goto inval; if (strcmp(name, "cr_flags") == 0) set->ks_req[i].kr_flags = uint32; if (strcmp(name, "cr_index") == 0) set->ks_req[i].kr_index = uint32; break; case DATA_TYPE_UINT64: if (nvpair_value_uint64(nvp, &uint64) == EINVAL) goto inval; if (strcmp(name, "cr_preset") == 0) set->ks_req[i].kr_preset = uint64; break; case DATA_TYPE_STRING: if (nvpair_value_string(nvp, &string) == EINVAL) goto inval; if (strcmp(name, "cr_event") == 0) (void) strncpy(set->ks_req[i].kr_event, string, CPC_MAX_EVENT_LEN); break; case DATA_TYPE_NVLIST: if (strcmp(name, "cr_attr") != 0) goto inval; if (nvpair_value_nvlist(nvp, &attrs) == EINVAL) goto inval; nvp_attr = NULL; /* * If the picnum has been specified as an * attribute, consume that attribute here and * remove it from the list of attributes. */ if (nvlist_lookup_uint64(attrs, "picnum", &uint64) == 0) { if (nvlist_remove(attrs, "picnum", DATA_TYPE_UINT64) != 0) panic("nvlist %p faulty", (void *)attrs); set->ks_req[i].kr_picnum = uint64; } if ((set->ks_req[i].kr_nattrs = kcpc_nvlist_npairs(attrs)) == 0) break; if (set->ks_req[i].kr_nattrs > CPC_MAX_ATTRS) goto inval; set->ks_req[i].kr_attr = kmem_alloc(set->ks_req[i].kr_nattrs * sizeof (kcpc_attr_t), KM_SLEEP); j = 0; while ((nvp_attr = nvlist_next_nvpair(attrs, nvp_attr)) != NULL) { attrp = &set->ks_req[i].kr_attr[j]; if (nvpair_type(nvp_attr) != DATA_TYPE_UINT64) goto inval; (void) strncpy(attrp->ka_name, nvpair_name(nvp_attr), CPC_MAX_ATTR_LEN); if (nvpair_value_uint64(nvp_attr, &(attrp->ka_val)) == EINVAL) goto inval; j++; } ASSERT(j == set->ks_req[i].kr_nattrs); default: break; } } } nvlist_free(nvl); *inset = set; return (0); inval: nvlist_free(nvl); kcpc_free_set(set); return (EINVAL); }
/* * Convert the nvpair [nvp] to a string which is added to the environment * of the child process. * Return 0 on success, -1 on error. * * FIXME: Refactor with cmd/zpool/zpool_main.c:zpool_do_events_nvprint()? */ static void _zed_event_add_nvpair(uint64_t eid, zed_strings_t *zsp, nvpair_t *nvp) { const char *name; data_type_t type; const char *prefix = ZEVENT_VAR_PREFIX; boolean_t b; double d; uint8_t i8; uint16_t i16; uint32_t i32; uint64_t i64; char *str; assert(zsp != NULL); assert(nvp != NULL); name = nvpair_name(nvp); type = nvpair_type(nvp); switch (type) { case DATA_TYPE_BOOLEAN: _zed_event_add_var(eid, zsp, prefix, name, "%s", "1"); break; case DATA_TYPE_BOOLEAN_VALUE: (void) nvpair_value_boolean_value(nvp, &b); _zed_event_add_var(eid, zsp, prefix, name, "%s", b ? "1" : "0"); break; case DATA_TYPE_BYTE: (void) nvpair_value_byte(nvp, &i8); _zed_event_add_var(eid, zsp, prefix, name, "%d", i8); break; case DATA_TYPE_INT8: (void) nvpair_value_int8(nvp, (int8_t *) &i8); _zed_event_add_var(eid, zsp, prefix, name, "%d", i8); break; case DATA_TYPE_UINT8: (void) nvpair_value_uint8(nvp, &i8); _zed_event_add_var(eid, zsp, prefix, name, "%u", i8); break; case DATA_TYPE_INT16: (void) nvpair_value_int16(nvp, (int16_t *) &i16); _zed_event_add_var(eid, zsp, prefix, name, "%d", i16); break; case DATA_TYPE_UINT16: (void) nvpair_value_uint16(nvp, &i16); _zed_event_add_var(eid, zsp, prefix, name, "%u", i16); break; case DATA_TYPE_INT32: (void) nvpair_value_int32(nvp, (int32_t *) &i32); _zed_event_add_var(eid, zsp, prefix, name, "%d", i32); break; case DATA_TYPE_UINT32: (void) nvpair_value_uint32(nvp, &i32); _zed_event_add_var(eid, zsp, prefix, name, "%u", i32); break; case DATA_TYPE_INT64: (void) nvpair_value_int64(nvp, (int64_t *) &i64); _zed_event_add_var(eid, zsp, prefix, name, "%lld", (longlong_t) i64); break; case DATA_TYPE_UINT64: (void) nvpair_value_uint64(nvp, &i64); _zed_event_add_var(eid, zsp, prefix, name, (_zed_event_value_is_hex(name) ? "0x%.16llX" : "%llu"), (u_longlong_t) i64); /* * shadow readable strings for vdev state pairs */ if (strcmp(name, FM_EREPORT_PAYLOAD_ZFS_VDEV_STATE) == 0 || strcmp(name, FM_EREPORT_PAYLOAD_ZFS_VDEV_LASTSTATE) == 0) { char alt[32]; (void) snprintf(alt, sizeof (alt), "%s_str", name); _zed_event_add_var(eid, zsp, prefix, alt, "%s", zpool_state_to_name(i64, VDEV_AUX_NONE)); } break; case DATA_TYPE_DOUBLE: (void) nvpair_value_double(nvp, &d); _zed_event_add_var(eid, zsp, prefix, name, "%g", d); break; case DATA_TYPE_HRTIME: (void) nvpair_value_hrtime(nvp, (hrtime_t *) &i64); _zed_event_add_var(eid, zsp, prefix, name, "%llu", (u_longlong_t) i64); break; case DATA_TYPE_NVLIST: _zed_event_add_var(eid, zsp, prefix, name, "%s", "_NOT_IMPLEMENTED_"); /* FIXME */ break; case DATA_TYPE_STRING: (void) nvpair_value_string(nvp, &str); _zed_event_add_var(eid, zsp, prefix, name, "%s", (str ? str : "<NULL>")); break; case DATA_TYPE_BOOLEAN_ARRAY: _zed_event_add_var(eid, zsp, prefix, name, "%s", "_NOT_IMPLEMENTED_"); /* FIXME */ break; case DATA_TYPE_BYTE_ARRAY: _zed_event_add_var(eid, zsp, prefix, name, "%s", "_NOT_IMPLEMENTED_"); /* FIXME */ break; case DATA_TYPE_INT8_ARRAY: _zed_event_add_int8_array(eid, zsp, prefix, nvp); break; case DATA_TYPE_UINT8_ARRAY: _zed_event_add_uint8_array(eid, zsp, prefix, nvp); break; case DATA_TYPE_INT16_ARRAY: _zed_event_add_int16_array(eid, zsp, prefix, nvp); break; case DATA_TYPE_UINT16_ARRAY: _zed_event_add_uint16_array(eid, zsp, prefix, nvp); break; case DATA_TYPE_INT32_ARRAY: _zed_event_add_int32_array(eid, zsp, prefix, nvp); break; case DATA_TYPE_UINT32_ARRAY: _zed_event_add_uint32_array(eid, zsp, prefix, nvp); break; case DATA_TYPE_INT64_ARRAY: _zed_event_add_int64_array(eid, zsp, prefix, nvp); break; case DATA_TYPE_UINT64_ARRAY: _zed_event_add_uint64_array(eid, zsp, prefix, nvp); break; case DATA_TYPE_STRING_ARRAY: _zed_event_add_string_array(eid, zsp, prefix, nvp); break; case DATA_TYPE_NVLIST_ARRAY: _zed_event_add_var(eid, zsp, prefix, name, "%s", "_NOT_IMPLEMENTED_"); /* FIXME */ break; default: errno = EINVAL; zed_log_msg(LOG_WARNING, "Failed to convert nvpair \"%s\" for eid=%llu: " "Unrecognized type=%u", name, eid, (unsigned int) type); break; } }
static void print_prop_nameval(topo_hdl_t *thp, tnode_t *node, nvlist_t *nvl) { int err; topo_type_t type; char *tstr, *propn, buf[48], *factype; nvpair_t *pv_nvp; int i; uint_t nelem; if ((pv_nvp = nvlist_next_nvpair(nvl, NULL)) == NULL) return; /* Print property name */ if ((pv_nvp = nvlist_next_nvpair(nvl, NULL)) == NULL || nvpair_name(pv_nvp) == NULL || strcmp(TOPO_PROP_VAL_NAME, nvpair_name(pv_nvp)) != 0) { (void) fprintf(stderr, "%s: malformed property name\n", g_pname); return; } else { (void) nvpair_value_string(pv_nvp, &propn); } if ((pv_nvp = nvlist_next_nvpair(nvl, pv_nvp)) == NULL || nvpair_name(pv_nvp) == NULL || strcmp(nvpair_name(pv_nvp), TOPO_PROP_VAL_TYPE) != 0 || nvpair_type(pv_nvp) != DATA_TYPE_UINT32) { (void) fprintf(stderr, "%s: malformed property type for %s\n", g_pname, propn); return; } else { (void) nvpair_value_uint32(pv_nvp, (uint32_t *)&type); } switch (type) { case TOPO_TYPE_BOOLEAN: tstr = "boolean"; break; case TOPO_TYPE_INT32: tstr = "int32"; break; case TOPO_TYPE_UINT32: tstr = "uint32"; break; case TOPO_TYPE_INT64: tstr = "int64"; break; case TOPO_TYPE_UINT64: tstr = "uint64"; break; case TOPO_TYPE_DOUBLE: tstr = "double"; break; case TOPO_TYPE_STRING: tstr = "string"; break; case TOPO_TYPE_FMRI: tstr = "fmri"; break; case TOPO_TYPE_INT32_ARRAY: tstr = "int32[]"; break; case TOPO_TYPE_UINT32_ARRAY: tstr = "uint32[]"; break; case TOPO_TYPE_INT64_ARRAY: tstr = "int64[]"; break; case TOPO_TYPE_UINT64_ARRAY: tstr = "uint64[]"; break; case TOPO_TYPE_STRING_ARRAY: tstr = "string[]"; break; case TOPO_TYPE_FMRI_ARRAY: tstr = "fmri[]"; break; default: tstr = "unknown type"; } (void) printf(" %-17s %-8s ", propn, tstr); /* * Get property value */ if (nvpair_name(pv_nvp) == NULL || (pv_nvp = nvlist_next_nvpair(nvl, pv_nvp)) == NULL) { (void) fprintf(stderr, "%s: malformed property value\n", g_pname); return; } switch (nvpair_type(pv_nvp)) { case DATA_TYPE_INT32: { int32_t val; (void) nvpair_value_int32(pv_nvp, &val); (void) printf(" %d", val); break; } case DATA_TYPE_UINT32: { uint32_t val, type; char val_str[49]; nvlist_t *fac, *rsrc = NULL; (void) nvpair_value_uint32(pv_nvp, &val); if (node == NULL || topo_node_flags(node) != TOPO_NODE_FACILITY) goto uint32_def; if (topo_node_resource(node, &rsrc, &err) != 0) goto uint32_def; if (nvlist_lookup_nvlist(rsrc, "facility", &fac) != 0) goto uint32_def; if (nvlist_lookup_string(fac, FM_FMRI_FACILITY_TYPE, &factype) != 0) goto uint32_def; nvlist_free(rsrc); rsrc = NULL; /* * Special case code to do friendlier printing of * facility node properties */ if ((strcmp(propn, TOPO_FACILITY_TYPE) == 0) && (strcmp(factype, TOPO_FAC_TYPE_SENSOR) == 0)) { topo_sensor_type_name(val, val_str, 48); (void) printf(" 0x%x (%s)", val, val_str); break; } else if ((strcmp(propn, TOPO_FACILITY_TYPE) == 0) && (strcmp(factype, TOPO_FAC_TYPE_INDICATOR) == 0)) { topo_led_type_name(val, val_str, 48); (void) printf(" 0x%x (%s)", val, val_str); break; } else if (strcmp(propn, TOPO_SENSOR_UNITS) == 0) { topo_sensor_units_name(val, val_str, 48); (void) printf(" 0x%x (%s)", val, val_str); break; } else if (strcmp(propn, TOPO_LED_MODE) == 0) { topo_led_state_name(val, val_str, 48); (void) printf(" 0x%x (%s)", val, val_str); break; } else if ((strcmp(propn, TOPO_SENSOR_STATE) == 0) && (strcmp(factype, TOPO_FAC_TYPE_SENSOR) == 0)) { if (topo_prop_get_uint32(node, TOPO_PGROUP_FACILITY, TOPO_FACILITY_TYPE, &type, &err) != 0) { goto uint32_def; } topo_sensor_state_name(type, val, val_str, 48); (void) printf(" 0x%x (%s)", val, val_str); break; } uint32_def: (void) printf(" 0x%x", val); if (rsrc != NULL) nvlist_free(rsrc); break; } case DATA_TYPE_INT64: { int64_t val; (void) nvpair_value_int64(pv_nvp, &val); (void) printf(" %lld", (longlong_t)val); break; } case DATA_TYPE_UINT64: { uint64_t val; (void) nvpair_value_uint64(pv_nvp, &val); (void) printf(" 0x%llx", (u_longlong_t)val); break; } case DATA_TYPE_DOUBLE: { double val; (void) nvpair_value_double(pv_nvp, &val); (void) printf(" %lf", (double)val); break; } case DATA_TYPE_STRING: { char *val; (void) nvpair_value_string(pv_nvp, &val); if (!opt_V && strlen(val) > 48) { (void) snprintf(buf, 48, "%s...", val); (void) printf(" %s", buf); } else { (void) printf(" %s", val); } break; } case DATA_TYPE_NVLIST: { nvlist_t *val; char *fmri; (void) nvpair_value_nvlist(pv_nvp, &val); if (topo_fmri_nvl2str(thp, val, &fmri, &err) != 0) { if (opt_V) nvlist_print(stdout, nvl); break; } if (!opt_V && strlen(fmri) > 48) { (void) snprintf(buf, 48, "%s", fmri); (void) snprintf(&buf[45], 4, "%s", DOTS); (void) printf(" %s", buf); } else { (void) printf(" %s", fmri); } topo_hdl_strfree(thp, fmri); break; } case DATA_TYPE_INT32_ARRAY: { int32_t *val; (void) nvpair_value_int32_array(pv_nvp, &val, &nelem); (void) printf(" [ "); for (i = 0; i < nelem; i++) (void) printf("%d ", val[i]); (void) printf("]"); break; } case DATA_TYPE_UINT32_ARRAY: { uint32_t *val; (void) nvpair_value_uint32_array(pv_nvp, &val, &nelem); (void) printf(" [ "); for (i = 0; i < nelem; i++) (void) printf("%u ", val[i]); (void) printf("]"); break; } case DATA_TYPE_INT64_ARRAY: { int64_t *val; (void) nvpair_value_int64_array(pv_nvp, &val, &nelem); (void) printf(" [ "); for (i = 0; i < nelem; i++) (void) printf("%lld ", val[i]); (void) printf("]"); break; } case DATA_TYPE_UINT64_ARRAY: { uint64_t *val; (void) nvpair_value_uint64_array(pv_nvp, &val, &nelem); (void) printf(" [ "); for (i = 0; i < nelem; i++) (void) printf("%llu ", val[i]); (void) printf("]"); break; } case DATA_TYPE_STRING_ARRAY: { char **val; (void) nvpair_value_string_array(pv_nvp, &val, &nelem); (void) printf(" [ "); for (i = 0; i < nelem; i++) (void) printf("\"%s\" ", val[i]); (void) printf("]"); break; } default: (void) fprintf(stderr, " unknown data type (%d)", nvpair_type(pv_nvp)); break; } (void) printf("\n"); }
static void rcm_print_nvlist(nvlist_t *nvl) { uchar_t data_byte; int16_t data_int16; uint16_t data_uint16; int32_t data_int32; uint32_t data_uint32; int64_t data_int64; uint64_t data_uint64; char *data_string; char **data_strings; uint_t data_nstrings; nvpair_t *nvp = NULL; int i; char *name; data_type_t type; rcm_log_message(RCM_TRACE3, "event attributes:\n"); while (nvp = nvlist_next_nvpair(nvl, nvp)) { type = nvpair_type(nvp); name = nvpair_name(nvp); rcm_log_message(RCM_TRACE3, "\t%s(%d)=", name, type); switch (type) { case DATA_TYPE_BOOLEAN: rcm_log_message(RCM_TRACE3, "True (boolean)\n"); break; case DATA_TYPE_BYTE: (void) nvpair_value_byte(nvp, &data_byte); rcm_log_message(RCM_TRACE3, "0x%x (byte)\n", data_byte); break; case DATA_TYPE_INT16: (void) nvpair_value_int16(nvp, &data_int16); rcm_log_message(RCM_TRACE3, "0x%x (int16)\n", data_int16); break; case DATA_TYPE_UINT16: (void) nvpair_value_uint16(nvp, &data_uint16); rcm_log_message(RCM_TRACE3, "0x%x (uint16)\n", data_uint16); break; case DATA_TYPE_INT32: (void) nvpair_value_int32(nvp, &data_int32); rcm_log_message(RCM_TRACE3, "0x%x (int32)\n", data_int32); break; case DATA_TYPE_UINT32: (void) nvpair_value_uint32(nvp, &data_uint32); rcm_log_message(RCM_TRACE3, "0x%x (uint32)\n", data_uint32); break; case DATA_TYPE_INT64: (void) nvpair_value_int64(nvp, &data_int64); rcm_log_message(RCM_TRACE3, "0x%lx (int64)\n", data_int64); break; case DATA_TYPE_UINT64: (void) nvpair_value_uint64(nvp, &data_uint64); rcm_log_message(RCM_TRACE3, "0x%lx (uint64)\n", data_uint64); break; case DATA_TYPE_STRING: (void) nvpair_value_string(nvp, &data_string); rcm_log_message(RCM_TRACE3, "\"%s\" (string)\n", data_string); break; case DATA_TYPE_STRING_ARRAY: (void) nvpair_value_string_array(nvp, &data_strings, &data_nstrings); for (i = 0; i < data_nstrings; i++) { rcm_log_message(RCM_TRACE3, "\t\"%s\" (string)\n", data_strings[i]); if (i < (data_nstrings - 1)) rcm_log_message(RCM_TRACE3, "\t\t\t"); } break; default: rcm_log_message(RCM_TRACE3, "<not dumped>\n"); break; } } }
/* * Convert the nvpair [nvp] to a string which is added to the environment * of the child process. * Return 0 on success, -1 on error. * * FIXME: Refactor with cmd/zpool/zpool_main.c:zpool_do_events_nvprint()? */ static void _zed_event_add_nvpair(uint64_t eid, zed_strings_t *zsp, nvpair_t *nvp) { const char *name; data_type_t type; char buf[4096]; int buflen; int n; char *p; const char *q; const char *fmt; boolean_t b; double d; uint8_t i8; uint16_t i16; uint32_t i32; uint64_t i64; char *str; assert(zsp != NULL); assert(nvp != NULL); name = nvpair_name(nvp); type = nvpair_type(nvp); buflen = sizeof (buf); /* Copy NAME prefix for ZED zevent namespace. */ n = strlcpy(buf, ZEVENT_VAR_PREFIX, sizeof (buf)); if (n >= sizeof (buf)) { zed_log_msg(LOG_WARNING, "Failed to convert nvpair \"%s\" for eid=%llu: %s", name, eid, "Exceeded buffer size"); return; } buflen -= n; p = buf + n; /* Convert NAME to alphanumeric uppercase. */ for (q = name; *q && (buflen > 0); q++) { *p++ = isalnum(*q) ? toupper(*q) : '_'; buflen--; } /* Separate NAME from VALUE. */ if (buflen > 0) { *p++ = '='; buflen--; } *p = '\0'; /* Convert VALUE. */ switch (type) { case DATA_TYPE_BOOLEAN: n = snprintf(p, buflen, "%s", "1"); break; case DATA_TYPE_BOOLEAN_VALUE: (void) nvpair_value_boolean_value(nvp, &b); n = snprintf(p, buflen, "%s", b ? "1" : "0"); break; case DATA_TYPE_BYTE: (void) nvpair_value_byte(nvp, &i8); n = snprintf(p, buflen, "%d", i8); break; case DATA_TYPE_INT8: (void) nvpair_value_int8(nvp, (int8_t *) &i8); n = snprintf(p, buflen, "%d", i8); break; case DATA_TYPE_UINT8: (void) nvpair_value_uint8(nvp, &i8); n = snprintf(p, buflen, "%u", i8); break; case DATA_TYPE_INT16: (void) nvpair_value_int16(nvp, (int16_t *) &i16); n = snprintf(p, buflen, "%d", i16); break; case DATA_TYPE_UINT16: (void) nvpair_value_uint16(nvp, &i16); n = snprintf(p, buflen, "%u", i16); break; case DATA_TYPE_INT32: (void) nvpair_value_int32(nvp, (int32_t *) &i32); n = snprintf(p, buflen, "%d", i32); break; case DATA_TYPE_UINT32: (void) nvpair_value_uint32(nvp, &i32); n = snprintf(p, buflen, "%u", i32); break; case DATA_TYPE_INT64: (void) nvpair_value_int64(nvp, (int64_t *) &i64); n = snprintf(p, buflen, "%lld", (longlong_t) i64); break; case DATA_TYPE_UINT64: (void) nvpair_value_uint64(nvp, &i64); fmt = _zed_event_value_is_hex(name) ? "0x%.16llX" : "%llu"; n = snprintf(p, buflen, fmt, (u_longlong_t) i64); break; case DATA_TYPE_DOUBLE: (void) nvpair_value_double(nvp, &d); n = snprintf(p, buflen, "%g", d); break; case DATA_TYPE_HRTIME: (void) nvpair_value_hrtime(nvp, (hrtime_t *) &i64); n = snprintf(p, buflen, "%llu", (u_longlong_t) i64); break; case DATA_TYPE_NVLIST: /* FIXME */ n = snprintf(p, buflen, "%s", "_NOT_IMPLEMENTED_"); break; case DATA_TYPE_STRING: (void) nvpair_value_string(nvp, &str); n = snprintf(p, buflen, "%s", (str ? str : "<NULL>")); break; case DATA_TYPE_BOOLEAN_ARRAY: /* FIXME */ n = snprintf(p, buflen, "%s", "_NOT_IMPLEMENTED_"); break; case DATA_TYPE_BYTE_ARRAY: /* FIXME */ n = snprintf(p, buflen, "%s", "_NOT_IMPLEMENTED_"); break; case DATA_TYPE_INT8_ARRAY: n = _zed_event_convert_int8_array(p, buflen, nvp); break; case DATA_TYPE_UINT8_ARRAY: n = _zed_event_convert_uint8_array(p, buflen, nvp); break; case DATA_TYPE_INT16_ARRAY: n = _zed_event_convert_int16_array(p, buflen, nvp); break; case DATA_TYPE_UINT16_ARRAY: n = _zed_event_convert_uint16_array(p, buflen, nvp); break; case DATA_TYPE_INT32_ARRAY: n = _zed_event_convert_int32_array(p, buflen, nvp); break; case DATA_TYPE_UINT32_ARRAY: n = _zed_event_convert_uint32_array(p, buflen, nvp); break; case DATA_TYPE_INT64_ARRAY: n = _zed_event_convert_int64_array(p, buflen, nvp); break; case DATA_TYPE_UINT64_ARRAY: fmt = _zed_event_value_is_hex(name) ? "0x%.16llX " : "%llu "; n = _zed_event_convert_uint64_array(p, buflen, nvp, fmt); break; case DATA_TYPE_STRING_ARRAY: n = _zed_event_convert_string_array(p, buflen, nvp); break; case DATA_TYPE_NVLIST_ARRAY: /* FIXME */ n = snprintf(p, buflen, "%s", "_NOT_IMPLEMENTED_"); break; default: zed_log_msg(LOG_WARNING, "Failed to convert nvpair \"%s\" for eid=%llu: " "Unrecognized type=%u", name, eid, (unsigned int) type); return; } if ((n < 0) || (n >= sizeof (buf))) { zed_log_msg(LOG_WARNING, "Failed to convert nvpair \"%s\" for eid=%llu: %s", name, eid, "Exceeded buffer size"); return; } if (zed_strings_add(zsp, buf) < 0) { zed_log_msg(LOG_WARNING, "Failed to convert nvpair \"%s\" for eid=%llu: %s", name, eid, strerror(ENOMEM)); return; } }
CCIMInstance * partbasedon_descriptor_toCCIMInstance(char *hostname, dm_descriptor_t ant, dm_descriptor_t dep, char *provider, int *errp) { nvlist_t *nvlp; nvpair_t *nvp; CCIMInstance *inst = NULL; CCIMInstance *ant_inst; CCIMInstance *dep_inst; CCIMObjectPath *ant_op; CCIMObjectPath *dep_op; CCIMException *ex; int error; uint64_t size; /* need these to calculate ending addr */ uint64_t startaddr; uint64_t endaddr; char attrval[100]; int isFdisk = 0; *errp = 0; /* Create instance of partition based on assoc. */ if ((inst = cim_createInstance(provider)) == NULL) { ex = cim_getLastError(); util_handleError(PARTBASEDON_DESCRIPTOR_FUNC, CIM_ERR_FAILED, CREATE_INSTANCE_FAILURE, ex, errp); return ((CCIMInstance *)NULL); } if ((strcasecmp(provider, DISKPART_BASEDONFDISK)) == 0) { isFdisk = 1; } /* * Now get the object path for the REF pointers. */ if (isFdisk) { ant_inst = partition_descriptor_toCCIMInstance(hostname, ant, DISK_PARTITION, &error); } else { ant_inst = logicaldisk_descriptor_toCCIMInstance(hostname, ant, LOGICAL_DISK, &error); } if (error != 0) { util_handleError(PARTBASEDON_DESCRIPTOR_FUNC, CIM_ERR_FAILED, PARTBASEDON_DESC_TO_INSTANCE_FAILURE, NULL, &error); cim_freeInstance(inst); return ((CCIMInstance *)NULL); } dep_inst = partition_descriptor_toCCIMInstance(hostname, dep, DISK_PARTITION, &error); if (error != 0) { util_handleError(PARTBASEDON_DESCRIPTOR_FUNC, CIM_ERR_FAILED, PARTBASEDON_DESC_TO_INSTANCE_FAILURE, NULL, &error); cim_freeInstance(inst); cim_freeInstance(ant_inst); return ((CCIMInstance *)NULL); } /* * Get the object paths that are represented by these instances. * Add these properties to the association instance. */ ant_op = cim_createObjectPath(ant_inst); dep_op = cim_createObjectPath(dep_inst); cim_freeInstance(ant_inst); cim_freeInstance(dep_inst); if (ant_op == NULL || dep_op == NULL) { ex = cim_getLastError(); util_handleError(PARTBASEDON_DESCRIPTOR_FUNC, CIM_ERR_FAILED, CREATE_OBJECT_PATH_FAILURE, ex, &error); cim_freeInstance(inst); return ((CCIMInstance *)NULL); } util_doReferenceProperty(ANTECEDENT, ant_op, cim_true, inst, errp); util_doReferenceProperty(DEPENDENT, dep_op, cim_true, inst, errp); cim_freeObjectPath(ant_op); cim_freeObjectPath(dep_op); if (*errp != 0) { ex = cim_getLastError(); util_handleError(PARTBASEDON_DESCRIPTOR_FUNC, CIM_ERR_FAILED, ADD_PROPERTY_FAILURE, ex, errp); cim_freeInstance(inst); return ((CCIMInstance *)NULL); } /* * Now get the other attributes we are interested in */ nvlp = dm_get_attributes(dep, &error); if (error != 0) { util_handleError(PARTBASEDON_DESCRIPTOR_FUNC, CIM_ERR_FAILED, DM_GET_ATTR_FAILURE, NULL, errp); cim_freeInstance(inst); return ((CCIMInstance *)NULL); } if (nvlp == NULL) { return (inst); } for (nvp = nvlist_next_nvpair(nvlp, NULL); nvp != NULL; nvp = nvlist_next_nvpair(nvlp, nvp)) { char *attrname; uint64_t ui64; uint32_t ui32; attrname = nvpair_name(nvp); if (attrname == NULL) { continue; } if (strcasecmp(attrname, DM_SIZE) == 0) { error = nvpair_value_uint64(nvp, &ui64); if (error != 0) { cim_freeInstance(inst); nvlist_free(nvlp); util_handleError(PARTBASEDON_DESCRIPTOR_FUNC, CIM_ERR_FAILED, DM_GET_ATTR_FAILURE, NULL, errp); return ((CCIMInstance *)NULL); } size = ui64; } else if (strcasecmp(attrname, DM_START) == 0) { error = nvpair_value_uint64(nvp, &ui64); if (error != 0) { cim_freeInstance(inst); nvlist_free(nvlp); util_handleError(PARTBASEDON_DESCRIPTOR_FUNC, CIM_ERR_FAILED, DM_GET_ATTR_FAILURE, NULL, errp); return ((CCIMInstance *)NULL); } startaddr = ui64; error = snprintf(attrval, sizeof (attrval), "%llu", ui64); if (error < 0) { cim_freeInstance(inst); nvlist_free(nvlp); util_handleError(PARTBASEDON_DESCRIPTOR_FUNC, CIM_ERR_FAILED, DM_GET_ATTR_FAILURE, NULL, errp); return ((CCIMInstance *)NULL); } util_doProperty("StartingAddress", uint64, attrval, cim_false, inst, errp); if (*errp != 0) { ex = cim_getLastError(); util_handleError(PARTBASEDON_DESCRIPTOR_FUNC, CIM_ERR_FAILED, ADD_PROPERTY_FAILURE, ex, errp); cim_freeInstance(inst); nvlist_free(nvlp); return ((CCIMInstance *)NULL); } } else if (strcasecmp(attrname, DM_INDEX) == 0) { error = nvpair_value_uint32(nvp, &ui32); if (error != 0) { cim_freeInstance(inst); nvlist_free(nvlp); util_handleError(PARTBASEDON_DESCRIPTOR_FUNC, CIM_ERR_FAILED, DM_GET_ATTR_FAILURE, NULL, errp); return ((CCIMInstance *)NULL); } error = snprintf(attrval, sizeof (attrval), "%u", ui32); if (error < 0) { cim_freeInstance(inst); nvlist_free(nvlp); util_handleError(PARTBASEDON_DESCRIPTOR_FUNC, CIM_ERR_FAILED, DM_GET_ATTR_FAILURE, NULL, errp); return ((CCIMInstance *)NULL); } util_doProperty("OrderIndex", uint32, attrval, cim_false, inst, errp); if (*errp != 0) { ex = cim_getLastError(); util_handleError(PARTBASEDON_DESCRIPTOR_FUNC, CIM_ERR_FAILED, ADD_PROPERTY_FAILURE, ex, errp); cim_freeInstance(inst); nvlist_free(nvlp); return ((CCIMInstance *)NULL); } } } nvlist_free(nvlp); /* * Now add the ending address attribute. Do this here because * there is no guarantee about the order for how these name/value * pairs are given and without the starting address we cannot * calculate the ending address. */ endaddr = startaddr + size; error = snprintf(attrval, sizeof (attrval), "%llu", endaddr); if (error < 0) { cim_freeInstance(inst); util_handleError(PARTBASEDON_DESCRIPTOR_FUNC, CIM_ERR_FAILED, DM_GET_ATTR_FAILURE, NULL, errp); return ((CCIMInstance *)NULL); } util_doProperty("EndingAddress", uint64, attrval, cim_false, inst, errp); if (*errp != 0) { ex = cim_getLastError(); util_handleError(PARTBASEDON_DESCRIPTOR_FUNC, CIM_ERR_FAILED, ADD_PROPERTY_FAILURE, ex, errp); cim_freeInstance(inst); return ((CCIMInstance *)NULL); } return (inst); }