Lines Matching defs:nvp
108 #define NVPAIR_MAGIC 0x6e7670 /* "nvp" */
120 #define NVPAIR_ASSERT(nvp) do { \
121 PJDLOG_ASSERT((nvp) != NULL); \
122 PJDLOG_ASSERT((nvp)->nvp_magic == NVPAIR_MAGIC); \
134 nvpair_assert(const nvpair_t *nvp)
137 NVPAIR_ASSERT(nvp);
144 nvpair_t *nvp;
155 nvp = nv_calloc(1, sizeof(*nvp) + namelen + 1);
156 if (nvp != NULL) {
157 nvp->nvp_name = (char *)(nvp + 1);
158 memcpy(nvp->nvp_name, name, namelen);
159 nvp->nvp_name[namelen] = '\0';
160 nvp->nvp_type = type;
161 nvp->nvp_data = data;
162 nvp->nvp_datasize = datasize;
163 nvp->nvp_nitems = nitems;
164 nvp->nvp_magic = NVPAIR_MAGIC;
167 return (nvp);
171 nvpair_append(nvpair_t *nvp, const void *value, size_t valsize, size_t datasize)
176 oldlen = nvp->nvp_nitems * valsize;
177 olddata = (void *)(uintptr_t)nvp->nvp_data;
186 nvp->nvp_data = (uint64_t)(uintptr_t)data;
187 nvp->nvp_datasize += datasize;
188 nvp->nvp_nitems++;
193 nvpair_nvlist(const nvpair_t *nvp)
196 NVPAIR_ASSERT(nvp);
198 return (nvp->nvp_list);
202 nvpair_next(const nvpair_t *nvp)
205 NVPAIR_ASSERT(nvp);
206 PJDLOG_ASSERT(nvp->nvp_list != NULL);
208 return (TAILQ_NEXT(nvp, nvp_next));
212 nvpair_prev(const nvpair_t *nvp)
215 NVPAIR_ASSERT(nvp);
216 PJDLOG_ASSERT(nvp->nvp_list != NULL);
218 return (TAILQ_PREV(nvp, nvl_head, nvp_next));
222 nvpair_insert(struct nvl_head *head, nvpair_t *nvp, nvlist_t *nvl)
225 NVPAIR_ASSERT(nvp);
226 PJDLOG_ASSERT(nvp->nvp_list == NULL);
228 !nvlist_exists(nvl, nvpair_name(nvp)));
230 TAILQ_INSERT_TAIL(head, nvp, nvp_next);
231 nvp->nvp_list = nvl;
235 nvpair_remove_nvlist(nvpair_t *nvp)
240 nvl = __DECONST(nvlist_t *, nvpair_get_nvlist(nvp));
246 nvpair_remove_nvlist_array(nvpair_t *nvp)
253 nvpair_get_nvlist_array(nvp, &count));
261 nvpair_remove(struct nvl_head *head, nvpair_t *nvp, const nvlist_t *nvl)
264 NVPAIR_ASSERT(nvp);
265 PJDLOG_ASSERT(nvp->nvp_list == nvl);
267 if (nvpair_type(nvp) == NV_TYPE_NVLIST)
268 nvpair_remove_nvlist(nvp);
269 else if (nvpair_type(nvp) == NV_TYPE_NVLIST_ARRAY)
270 nvpair_remove_nvlist_array(nvp);
272 TAILQ_REMOVE(head, nvp, nvp_next);
273 nvp->nvp_list = NULL;
277 nvpair_clone(const nvpair_t *nvp)
284 NVPAIR_ASSERT(nvp);
286 name = nvpair_name(nvp);
288 switch (nvpair_type(nvp)) {
293 newnvp = nvpair_create_bool(name, nvpair_get_bool(nvp));
296 newnvp = nvpair_create_number(name, nvpair_get_number(nvp));
299 newnvp = nvpair_create_string(name, nvpair_get_string(nvp));
302 newnvp = nvpair_create_nvlist(name, nvpair_get_nvlist(nvp));
305 data = nvpair_get_binary(nvp, &datasize);
309 data = nvpair_get_bool_array(nvp, &datasize);
313 data = nvpair_get_number_array(nvp, &datasize);
317 data = nvpair_get_string_array(nvp, &datasize);
321 data = nvpair_get_nvlist_array(nvp, &datasize);
327 nvpair_get_descriptor(nvp));
330 data = nvpair_get_descriptor_array(nvp, &datasize);
335 PJDLOG_ABORT("Unknown type: %d.", nvpair_type(nvp));
349 nvpair_size(const nvpair_t *nvp)
352 NVPAIR_ASSERT(nvp);
354 return (nvp->nvp_datasize);
358 nvpair_pack_header(const nvpair_t *nvp, unsigned char *ptr, size_t *leftp)
363 NVPAIR_ASSERT(nvp);
365 nvphdr.nvph_type = nvp->nvp_type;
366 namesize = strlen(nvp->nvp_name) + 1;
369 nvphdr.nvph_datasize = nvp->nvp_datasize;
370 nvphdr.nvph_nitems = nvp->nvp_nitems;
377 memcpy(ptr, nvp->nvp_name, namesize);
385 nvpair_pack_null(const nvpair_t *nvp, unsigned char *ptr,
389 NVPAIR_ASSERT(nvp);
390 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NULL);
396 nvpair_pack_bool(const nvpair_t *nvp, unsigned char *ptr, size_t *leftp)
400 NVPAIR_ASSERT(nvp);
401 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BOOL);
403 value = (uint8_t)nvp->nvp_data;
414 nvpair_pack_number(const nvpair_t *nvp, unsigned char *ptr, size_t *leftp)
418 NVPAIR_ASSERT(nvp);
419 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NUMBER);
421 value = (uint64_t)nvp->nvp_data;
432 nvpair_pack_string(const nvpair_t *nvp, unsigned char *ptr, size_t *leftp)
435 NVPAIR_ASSERT(nvp);
436 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_STRING);
438 PJDLOG_ASSERT(*leftp >= nvp->nvp_datasize);
439 memcpy(ptr, (const void *)(intptr_t)nvp->nvp_data, nvp->nvp_datasize);
440 ptr += nvp->nvp_datasize;
441 *leftp -= nvp->nvp_datasize;
498 nvpair_pack_descriptor(const nvpair_t *nvp, unsigned char *ptr, int64_t *fdidxp,
503 NVPAIR_ASSERT(nvp);
504 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_DESCRIPTOR);
506 value = (int64_t)nvp->nvp_data;
529 nvpair_pack_binary(const nvpair_t *nvp, unsigned char *ptr, size_t *leftp)
532 NVPAIR_ASSERT(nvp);
533 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BINARY);
535 PJDLOG_ASSERT(*leftp >= nvp->nvp_datasize);
536 memcpy(ptr, (const void *)(intptr_t)nvp->nvp_data, nvp->nvp_datasize);
537 ptr += nvp->nvp_datasize;
538 *leftp -= nvp->nvp_datasize;
544 nvpair_pack_bool_array(const nvpair_t *nvp, unsigned char *ptr, size_t *leftp)
547 NVPAIR_ASSERT(nvp);
548 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BOOL_ARRAY);
549 PJDLOG_ASSERT(*leftp >= nvp->nvp_datasize);
551 memcpy(ptr, (const void *)(intptr_t)nvp->nvp_data, nvp->nvp_datasize);
552 ptr += nvp->nvp_datasize;
553 *leftp -= nvp->nvp_datasize;
559 nvpair_pack_number_array(const nvpair_t *nvp, unsigned char *ptr, size_t *leftp)
562 NVPAIR_ASSERT(nvp);
563 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NUMBER_ARRAY);
564 PJDLOG_ASSERT(*leftp >= nvp->nvp_datasize);
566 memcpy(ptr, (const void *)(intptr_t)nvp->nvp_data, nvp->nvp_datasize);
567 ptr += nvp->nvp_datasize;
568 *leftp -= nvp->nvp_datasize;
574 nvpair_pack_string_array(const nvpair_t *nvp, unsigned char *ptr, size_t *leftp)
580 NVPAIR_ASSERT(nvp);
581 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_STRING_ARRAY);
582 PJDLOG_ASSERT(*leftp >= nvp->nvp_datasize);
585 array = nvpair_get_string_array(nvp, NULL);
588 for (ii = 0; ii < nvp->nvp_nitems; ii++) {
598 PJDLOG_ASSERT(size == nvp->nvp_datasize);
605 nvpair_pack_descriptor_array(const nvpair_t *nvp, unsigned char *ptr,
612 NVPAIR_ASSERT(nvp);
613 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_DESCRIPTOR_ARRAY);
614 PJDLOG_ASSERT(*leftp >= nvp->nvp_datasize);
616 array = nvpair_get_descriptor_array(nvp, NULL);
619 for (ii = 0; ii < nvp->nvp_nitems; ii++) {
644 nvpair_init_datasize(nvpair_t *nvp)
647 NVPAIR_ASSERT(nvp);
649 if (nvp->nvp_type == NV_TYPE_NVLIST) {
650 if (nvp->nvp_data == 0) {
651 nvp->nvp_datasize = 0;
653 nvp->nvp_datasize =
654 nvlist_size((const nvlist_t *)(intptr_t)nvp->nvp_data);
660 nvpair_unpack_header(bool isbe, nvpair_t *nvp, const unsigned char *ptr,
705 memcpy(nvp->nvp_name, ptr, nvphdr.nvph_namesize);
712 nvp->nvp_type = nvphdr.nvph_type;
713 nvp->nvp_data = 0;
714 nvp->nvp_datasize = nvphdr.nvph_datasize;
715 nvp->nvp_nitems = nvphdr.nvph_nitems;
724 nvpair_unpack_null(bool isbe __unused, nvpair_t *nvp, const unsigned char *ptr,
728 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NULL);
730 if (nvp->nvp_datasize != 0) {
739 nvpair_unpack_bool(bool isbe __unused, nvpair_t *nvp, const unsigned char *ptr,
744 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BOOL);
746 if (nvp->nvp_datasize != sizeof(value)) {
764 nvp->nvp_data = (uint64_t)value;
770 nvpair_unpack_number(bool isbe, nvpair_t *nvp, const unsigned char *ptr,
774 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NUMBER);
776 if (nvp->nvp_datasize != sizeof(uint64_t)) {
786 nvp->nvp_data = be64dec(ptr);
788 nvp->nvp_data = le64dec(ptr);
797 nvpair_unpack_string(bool isbe __unused, nvpair_t *nvp,
801 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_STRING);
803 if (*leftp < nvp->nvp_datasize || nvp->nvp_datasize == 0) {
808 if (strnlen((const char *)ptr, nvp->nvp_datasize) !=
809 nvp->nvp_datasize - 1) {
814 nvp->nvp_data = (uint64_t)(uintptr_t)nv_strdup((const char *)ptr);
815 if (nvp->nvp_data == 0)
818 ptr += nvp->nvp_datasize;
819 *leftp -= nvp->nvp_datasize;
825 nvpair_unpack_nvlist(bool isbe __unused, nvpair_t *nvp,
830 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NVLIST);
832 if (*leftp < nvp->nvp_datasize || nvp->nvp_datasize == 0) {
845 nvp->nvp_data = (uint64_t)(uintptr_t)value;
853 nvpair_unpack_descriptor(bool isbe, nvpair_t *nvp, const unsigned char *ptr,
858 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_DESCRIPTOR);
860 if (nvp->nvp_datasize != sizeof(idx)) {
884 nvp->nvp_data = (uint64_t)fds[idx];
894 nvpair_unpack_binary(bool isbe __unused, nvpair_t *nvp,
899 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BINARY);
901 if (*leftp < nvp->nvp_datasize || nvp->nvp_datasize == 0) {
906 value = nv_malloc(nvp->nvp_datasize);
910 memcpy(value, ptr, nvp->nvp_datasize);
911 ptr += nvp->nvp_datasize;
912 *leftp -= nvp->nvp_datasize;
914 nvp->nvp_data = (uint64_t)(uintptr_t)value;
920 nvpair_unpack_bool_array(bool isbe __unused, nvpair_t *nvp,
927 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BOOL_ARRAY);
929 size = sizeof(*value) * nvp->nvp_nitems;
930 if (nvp->nvp_datasize != size || *leftp < size ||
931 nvp->nvp_nitems == 0 || size < nvp->nvp_nitems) {
940 for (i = 0; i < nvp->nvp_nitems; i++) {
947 nvp->nvp_data = (uint64_t)(uintptr_t)value;
953 nvpair_unpack_number_array(bool isbe, nvpair_t *nvp, const unsigned char *ptr,
960 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NUMBER_ARRAY);
962 size = sizeof(*value) * nvp->nvp_nitems;
963 if (nvp->nvp_datasize != size || *leftp < size ||
964 nvp->nvp_nitems == 0 || size < nvp->nvp_nitems) {
973 for (i = 0; i < nvp->nvp_nitems; i++) {
983 nvp->nvp_data = (uint64_t)(uintptr_t)value;
989 nvpair_unpack_string_array(bool isbe __unused, nvpair_t *nvp,
998 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_STRING_ARRAY);
1000 if (*leftp < nvp->nvp_datasize || nvp->nvp_datasize == 0 ||
1001 nvp->nvp_nitems == 0) {
1006 size = nvp->nvp_datasize;
1008 for (ii = 0; ii < nvp->nvp_nitems; ii++) {
1026 value = nv_calloc(nvp->nvp_nitems, sizeof(*value));
1030 for (ii = 0; ii < nvp->nvp_nitems; ii++) {
1038 nvp->nvp_data = (uint64_t)(uintptr_t)value;
1050 nvpair_unpack_descriptor_array(bool isbe, nvpair_t *nvp,
1058 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_DESCRIPTOR_ARRAY);
1060 size = sizeof(idx) * nvp->nvp_nitems;
1061 if (nvp->nvp_datasize != size || *leftp < size ||
1062 nvp->nvp_nitems == 0 || size < nvp->nvp_nitems) {
1071 for (ii = 0; ii < nvp->nvp_nitems; ii++) {
1095 nvp->nvp_data = (uint64_t)(uintptr_t)array;
1102 nvpair_unpack_nvlist_array(bool isbe __unused, nvpair_t *nvp,
1110 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NVLIST_ARRAY);
1112 sizeup = sizeof(struct nvpair_header) * nvp->nvp_nitems;
1113 if (nvp->nvp_nitems == 0 || sizeup < nvp->nvp_nitems ||
1119 value = nv_calloc(nvp->nvp_nitems, sizeof(*value));
1123 for (ii = 0; ii < nvp->nvp_nitems; ii++) {
1135 nvlist_set_flags(value[nvp->nvp_nitems - 1], NV_FLAG_IN_ARRAY);
1137 nvp->nvp_data = (uint64_t)(uintptr_t)value;
1155 nvpair_t *nvp, *tmp;
1157 nvp = nv_calloc(1, sizeof(*nvp) + NV_NAME_MAX);
1158 if (nvp == NULL)
1160 nvp->nvp_name = (char *)(nvp + 1);
1162 ptr = nvpair_unpack_header(isbe, nvp, ptr, leftp);
1165 tmp = nv_realloc(nvp, sizeof(*nvp) + strlen(nvp->nvp_name) + 1);
1168 nvp = tmp;
1171 nvp->nvp_name = (char *)(nvp + 1);
1172 nvp->nvp_data = 0x00;
1173 nvp->nvp_magic = NVPAIR_MAGIC;
1174 *nvpp = nvp;
1177 nv_free(nvp);
1182 nvpair_type(const nvpair_t *nvp)
1185 NVPAIR_ASSERT(nvp);
1187 return (nvp->nvp_type);
1191 nvpair_name(const nvpair_t *nvp)
1194 NVPAIR_ASSERT(nvp);
1196 return (nvp->nvp_name);
1204 nvpair_t *nvp;
1207 nvp = nvpair_create_stringv(name, valuefmt, valueap);
1210 return (nvp);
1216 nvpair_t *nvp;
1223 nvp = nvpair_create_string(name, str);
1225 return (nvp);
1254 nvpair_t *nvp;
1268 nvp = nvpair_allocv(name, NV_TYPE_STRING, (uint64_t)(uintptr_t)data,
1270 if (nvp == NULL)
1273 return (nvp);
1280 nvpair_t *nvp;
1291 nvp = nvpair_allocv(name, NV_TYPE_NVLIST, (uint64_t)(uintptr_t)nvl, 0,
1293 if (nvp == NULL)
1296 nvlist_set_parent(nvl, nvp);
1298 return (nvp);
1305 nvpair_t *nvp;
1316 nvp = nvpair_allocv(name, NV_TYPE_DESCRIPTOR, (uint64_t)value,
1318 if (nvp == NULL) {
1324 return (nvp);
1331 nvpair_t *nvp;
1344 nvp = nvpair_allocv(name, NV_TYPE_BINARY, (uint64_t)(uintptr_t)data,
1346 if (nvp == NULL)
1349 return (nvp);
1355 nvpair_t *nvp;
1370 nvp = nvpair_allocv(name, NV_TYPE_BOOL_ARRAY, (uint64_t)(uintptr_t)data,
1372 if (nvp == NULL) {
1378 return (nvp);
1385 nvpair_t *nvp;
1400 nvp = nvpair_allocv(name, NV_TYPE_NUMBER_ARRAY,
1402 if (nvp == NULL) {
1408 return (nvp);
1415 nvpair_t *nvp;
1425 nvp = NULL;
1443 nvp = nvpair_allocv(name, NV_TYPE_STRING_ARRAY,
1447 if (nvp == NULL) {
1455 return (nvp);
1489 nvpair_t *nvp;
1491 nvp = nvpair_allocv(" ", NV_TYPE_NVLIST,
1493 if (nvp == NULL) {
1499 nvlist_set_array_next(nvls[ii - 1], nvp);
1531 nvpair_t *nvp;
1539 nvp = NULL;
1559 nvp = nvpair_allocv(name, NV_TYPE_DESCRIPTOR_ARRAY,
1563 if (nvp == NULL) {
1573 return (nvp);
1580 nvpair_t *nvp;
1587 nvp = nvpair_allocv(name, NV_TYPE_STRING, (uint64_t)(uintptr_t)value,
1589 if (nvp == NULL) {
1595 return (nvp);
1601 nvpair_t *nvp;
1614 nvp = nvpair_allocv(name, NV_TYPE_NVLIST, (uint64_t)(uintptr_t)value,
1616 if (nvp == NULL)
1619 nvlist_set_parent(value, nvp);
1621 return (nvp);
1628 nvpair_t *nvp;
1635 nvp = nvpair_allocv(name, NV_TYPE_DESCRIPTOR, (uint64_t)value,
1637 if (nvp == NULL) {
1643 return (nvp);
1650 nvpair_t *nvp;
1657 nvp = nvpair_allocv(name, NV_TYPE_BINARY, (uint64_t)(uintptr_t)value,
1659 if (nvp == NULL) {
1665 return (nvp);
1671 nvpair_t *nvp;
1678 nvp = nvpair_allocv(name, NV_TYPE_BOOL_ARRAY,
1680 if (nvp == NULL) {
1686 return (nvp);
1692 nvpair_t *nvp;
1710 nvp = nvpair_allocv(name, NV_TYPE_STRING_ARRAY,
1712 if (nvp == NULL) {
1720 return (nvp);
1726 nvpair_t *nvp;
1733 nvp = nvpair_allocv(name, NV_TYPE_NUMBER_ARRAY,
1735 if (nvp == NULL) {
1741 return (nvp);
1763 nvpair_t *nvp;
1765 nvp = nvpair_allocv(" ", NV_TYPE_NVLIST,
1767 if (nvp == NULL)
1769 nvlist_set_array_next(value[ii - 1], nvp);
1802 nvpair_t *nvp;
1817 nvp = nvpair_allocv(name, NV_TYPE_DESCRIPTOR_ARRAY,
1819 if (nvp == NULL)
1822 return (nvp);
1837 nvpair_get_bool(const nvpair_t *nvp)
1840 NVPAIR_ASSERT(nvp);
1842 return (nvp->nvp_data == 1);
1846 nvpair_get_number(const nvpair_t *nvp)
1849 NVPAIR_ASSERT(nvp);
1851 return (nvp->nvp_data);
1855 nvpair_get_string(const nvpair_t *nvp)
1858 NVPAIR_ASSERT(nvp);
1859 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_STRING);
1861 return ((const char *)(intptr_t)nvp->nvp_data);
1865 nvpair_get_nvlist(const nvpair_t *nvp)
1868 NVPAIR_ASSERT(nvp);
1869 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NVLIST);
1871 return ((const nvlist_t *)(intptr_t)nvp->nvp_data);
1876 nvpair_get_descriptor(const nvpair_t *nvp)
1879 NVPAIR_ASSERT(nvp);
1880 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_DESCRIPTOR);
1882 return ((int)nvp->nvp_data);
1887 nvpair_get_binary(const nvpair_t *nvp, size_t *sizep)
1890 NVPAIR_ASSERT(nvp);
1891 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BINARY);
1894 *sizep = nvp->nvp_datasize;
1896 return ((const void *)(intptr_t)nvp->nvp_data);
1900 nvpair_get_bool_array(const nvpair_t *nvp, size_t *nitems)
1903 NVPAIR_ASSERT(nvp);
1904 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BOOL_ARRAY);
1907 *nitems = nvp->nvp_nitems;
1909 return ((const bool *)(intptr_t)nvp->nvp_data);
1913 nvpair_get_number_array(const nvpair_t *nvp, size_t *nitems)
1916 NVPAIR_ASSERT(nvp);
1917 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NUMBER_ARRAY);
1920 *nitems = nvp->nvp_nitems;
1922 return ((const uint64_t *)(intptr_t)nvp->nvp_data);
1926 nvpair_get_string_array(const nvpair_t *nvp, size_t *nitems)
1929 NVPAIR_ASSERT(nvp);
1930 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_STRING_ARRAY);
1933 *nitems = nvp->nvp_nitems;
1935 return ((const char * const *)(intptr_t)nvp->nvp_data);
1939 nvpair_get_nvlist_array(const nvpair_t *nvp, size_t *nitems)
1942 NVPAIR_ASSERT(nvp);
1943 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NVLIST_ARRAY);
1946 *nitems = nvp->nvp_nitems;
1948 return ((const nvlist_t * const *)((intptr_t)nvp->nvp_data));
1953 nvpair_get_descriptor_array(const nvpair_t *nvp, size_t *nitems)
1956 NVPAIR_ASSERT(nvp);
1957 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_DESCRIPTOR_ARRAY);
1960 *nitems = nvp->nvp_nitems;
1962 return ((const int *)(intptr_t)nvp->nvp_data);
1967 nvpair_append_bool_array(nvpair_t *nvp, const bool value)
1970 NVPAIR_ASSERT(nvp);
1971 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BOOL_ARRAY);
1972 return (nvpair_append(nvp, &value, sizeof(value), sizeof(value)));
1976 nvpair_append_number_array(nvpair_t *nvp, const uint64_t value)
1979 NVPAIR_ASSERT(nvp);
1980 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NUMBER_ARRAY);
1981 return (nvpair_append(nvp, &value, sizeof(value), sizeof(value)));
1985 nvpair_append_string_array(nvpair_t *nvp, const char *value)
1989 NVPAIR_ASSERT(nvp);
1990 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_STRING_ARRAY);
1999 if (nvpair_append(nvp, &str, sizeof(str), strlen(str) + 1) == -1) {
2007 nvpair_append_nvlist_array(nvpair_t *nvp, const nvlist_t *value)
2013 NVPAIR_ASSERT(nvp);
2014 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NVLIST_ARRAY);
2029 if (nvp->nvp_nitems > 0) {
2030 nvlist_t **nvls = (void *)(uintptr_t)nvp->nvp_data;
2032 prev = nvls[nvp->nvp_nitems - 1];
2041 if (nvpair_append(nvp, &nvl, sizeof(nvl), 0) == -1) {
2048 nvlist_set_parent(nvl, nvp);
2060 nvpair_append_descriptor_array(nvpair_t *nvp, const int value)
2064 NVPAIR_ASSERT(nvp);
2065 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_DESCRIPTOR_ARRAY);
2074 if (nvpair_append(nvp, &fd, sizeof(fd), sizeof(fd)) == -1) {
2083 nvpair_free(nvpair_t *nvp)
2087 NVPAIR_ASSERT(nvp);
2088 PJDLOG_ASSERT(nvp->nvp_list == NULL);
2090 nvp->nvp_magic = 0;
2091 switch (nvp->nvp_type) {
2094 close((int)nvp->nvp_data);
2097 for (i = 0; i < nvp->nvp_nitems; i++)
2098 close(((int *)(intptr_t)nvp->nvp_data)[i]);
2099 nv_free((int *)(intptr_t)nvp->nvp_data);
2103 nvlist_destroy((nvlist_t *)(intptr_t)nvp->nvp_data);
2106 nv_free((char *)(intptr_t)nvp->nvp_data);
2109 nv_free((void *)(intptr_t)nvp->nvp_data);
2112 for (i = 0; i < nvp->nvp_nitems; i++) {
2114 ((nvlist_t **)(intptr_t)nvp->nvp_data)[i]);
2116 nv_free(((nvlist_t **)(intptr_t)nvp->nvp_data));
2119 nv_free((uint64_t *)(intptr_t)nvp->nvp_data);
2122 nv_free((bool *)(intptr_t)nvp->nvp_data);
2125 for (i = 0; i < nvp->nvp_nitems; i++)
2126 nv_free(((char **)(intptr_t)nvp->nvp_data)[i]);
2127 nv_free((char **)(intptr_t)nvp->nvp_data);
2130 nv_free(nvp);
2134 nvpair_free_structure(nvpair_t *nvp)
2137 NVPAIR_ASSERT(nvp);
2138 PJDLOG_ASSERT(nvp->nvp_list == NULL);
2140 nvp->nvp_magic = 0;
2141 nv_free(nvp);