Lines Matching refs:nvp
85 #define NVPAIR_MAGIC 0x6e7670 /* "nvp" */
97 #define NVPAIR_ASSERT(nvp) do { \
98 PJDLOG_ASSERT((nvp) != NULL); \
99 PJDLOG_ASSERT((nvp)->nvp_magic == NVPAIR_MAGIC); \
111 nvpair_assert(const nvpair_t *nvp __unused)
114 NVPAIR_ASSERT(nvp);
121 nvpair_t *nvp;
132 nvp = nv_calloc(1, sizeof(*nvp) + namelen + 1);
133 if (nvp != NULL) {
134 nvp->nvp_name = (char *)(nvp + 1);
135 memcpy(nvp->nvp_name, name, namelen);
136 nvp->nvp_name[namelen] = '\0';
137 nvp->nvp_type = type;
138 nvp->nvp_data = data;
139 nvp->nvp_datasize = datasize;
140 nvp->nvp_nitems = nitems;
141 nvp->nvp_magic = NVPAIR_MAGIC;
144 return (nvp);
148 nvpair_append(nvpair_t *nvp, const void *value, size_t valsize, size_t datasize)
153 oldlen = nvp->nvp_nitems * valsize;
154 olddata = (void *)(uintptr_t)nvp->nvp_data;
163 nvp->nvp_data = (uint64_t)(uintptr_t)data;
164 nvp->nvp_datasize += datasize;
165 nvp->nvp_nitems++;
170 nvpair_nvlist(const nvpair_t *nvp)
173 NVPAIR_ASSERT(nvp);
175 return (nvp->nvp_list);
179 nvpair_next(const nvpair_t *nvp)
182 NVPAIR_ASSERT(nvp);
183 PJDLOG_ASSERT(nvp->nvp_list != NULL);
185 return (TAILQ_NEXT(nvp, nvp_next));
189 nvpair_prev(const nvpair_t *nvp)
192 NVPAIR_ASSERT(nvp);
193 PJDLOG_ASSERT(nvp->nvp_list != NULL);
195 return (TAILQ_PREV(nvp, nvl_head, nvp_next));
199 nvpair_insert(struct nvl_head *head, nvpair_t *nvp, nvlist_t *nvl)
202 NVPAIR_ASSERT(nvp);
203 PJDLOG_ASSERT(nvp->nvp_list == NULL);
205 !nvlist_exists(nvl, nvpair_name(nvp)));
207 TAILQ_INSERT_TAIL(head, nvp, nvp_next);
208 nvp->nvp_list = nvl;
212 nvpair_remove_nvlist(nvpair_t *nvp)
217 nvl = __DECONST(nvlist_t *, nvpair_get_nvlist(nvp));
223 nvpair_remove_nvlist_array(nvpair_t *nvp)
230 nvpair_get_nvlist_array(nvp, &count));
238 nvpair_remove(struct nvl_head *head, nvpair_t *nvp,
242 NVPAIR_ASSERT(nvp);
243 PJDLOG_ASSERT(nvp->nvp_list == nvl);
245 if (nvpair_type(nvp) == NV_TYPE_NVLIST)
246 nvpair_remove_nvlist(nvp);
247 else if (nvpair_type(nvp) == NV_TYPE_NVLIST_ARRAY)
248 nvpair_remove_nvlist_array(nvp);
250 TAILQ_REMOVE(head, nvp, nvp_next);
251 nvp->nvp_list = NULL;
255 nvpair_clone(const nvpair_t *nvp)
262 NVPAIR_ASSERT(nvp);
264 name = nvpair_name(nvp);
266 switch (nvpair_type(nvp)) {
271 newnvp = nvpair_create_bool(name, nvpair_get_bool(nvp));
274 newnvp = nvpair_create_number(name, nvpair_get_number(nvp));
277 newnvp = nvpair_create_string(name, nvpair_get_string(nvp));
280 newnvp = nvpair_create_nvlist(name, nvpair_get_nvlist(nvp));
283 data = nvpair_get_binary(nvp, &datasize);
287 data = nvpair_get_bool_array(nvp, &datasize);
291 data = nvpair_get_number_array(nvp, &datasize);
295 data = nvpair_get_string_array(nvp, &datasize);
299 data = nvpair_get_nvlist_array(nvp, &datasize);
305 nvpair_get_descriptor(nvp));
308 data = nvpair_get_descriptor_array(nvp, &datasize);
313 PJDLOG_ABORT("Unknown type: %d.", nvpair_type(nvp));
327 nvpair_size(const nvpair_t *nvp)
330 NVPAIR_ASSERT(nvp);
332 return (nvp->nvp_datasize);
336 nvpair_pack_header(const nvpair_t *nvp, unsigned char *ptr, size_t *leftp)
341 NVPAIR_ASSERT(nvp);
343 nvphdr.nvph_type = nvp->nvp_type;
344 namesize = strlen(nvp->nvp_name) + 1;
347 nvphdr.nvph_datasize = nvp->nvp_datasize;
348 nvphdr.nvph_nitems = nvp->nvp_nitems;
355 memcpy(ptr, nvp->nvp_name, namesize);
363 nvpair_pack_null(const nvpair_t *nvp __unused, unsigned char *ptr,
367 NVPAIR_ASSERT(nvp);
368 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NULL);
374 nvpair_pack_bool(const nvpair_t *nvp, unsigned char *ptr, size_t *leftp)
378 NVPAIR_ASSERT(nvp);
379 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BOOL);
381 value = (uint8_t)nvp->nvp_data;
392 nvpair_pack_number(const nvpair_t *nvp, unsigned char *ptr, size_t *leftp)
396 NVPAIR_ASSERT(nvp);
397 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NUMBER);
399 value = (uint64_t)nvp->nvp_data;
410 nvpair_pack_string(const nvpair_t *nvp, unsigned char *ptr, size_t *leftp)
413 NVPAIR_ASSERT(nvp);
414 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_STRING);
416 PJDLOG_ASSERT(*leftp >= nvp->nvp_datasize);
417 memcpy(ptr, (const void *)(intptr_t)nvp->nvp_data, nvp->nvp_datasize);
418 ptr += nvp->nvp_datasize;
419 *leftp -= nvp->nvp_datasize;
476 nvpair_pack_descriptor(const nvpair_t *nvp, unsigned char *ptr, int64_t *fdidxp,
481 NVPAIR_ASSERT(nvp);
482 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_DESCRIPTOR);
484 value = (int64_t)nvp->nvp_data;
507 nvpair_pack_binary(const nvpair_t *nvp, unsigned char *ptr, size_t *leftp)
510 NVPAIR_ASSERT(nvp);
511 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BINARY);
513 PJDLOG_ASSERT(*leftp >= nvp->nvp_datasize);
514 memcpy(ptr, (const void *)(intptr_t)nvp->nvp_data, nvp->nvp_datasize);
515 ptr += nvp->nvp_datasize;
516 *leftp -= nvp->nvp_datasize;
522 nvpair_pack_bool_array(const nvpair_t *nvp, unsigned char *ptr, size_t *leftp)
525 NVPAIR_ASSERT(nvp);
526 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BOOL_ARRAY);
527 PJDLOG_ASSERT(*leftp >= nvp->nvp_datasize);
529 memcpy(ptr, (const void *)(intptr_t)nvp->nvp_data, nvp->nvp_datasize);
530 ptr += nvp->nvp_datasize;
531 *leftp -= nvp->nvp_datasize;
537 nvpair_pack_number_array(const nvpair_t *nvp, unsigned char *ptr, size_t *leftp)
540 NVPAIR_ASSERT(nvp);
541 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NUMBER_ARRAY);
542 PJDLOG_ASSERT(*leftp >= nvp->nvp_datasize);
544 memcpy(ptr, (const void *)(intptr_t)nvp->nvp_data, nvp->nvp_datasize);
545 ptr += nvp->nvp_datasize;
546 *leftp -= nvp->nvp_datasize;
552 nvpair_pack_string_array(const nvpair_t *nvp, unsigned char *ptr, size_t *leftp)
558 NVPAIR_ASSERT(nvp);
559 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_STRING_ARRAY);
560 PJDLOG_ASSERT(*leftp >= nvp->nvp_datasize);
563 array = nvpair_get_string_array(nvp, NULL);
566 for (ii = 0; ii < nvp->nvp_nitems; ii++) {
576 PJDLOG_ASSERT(size == nvp->nvp_datasize);
583 nvpair_pack_descriptor_array(const nvpair_t *nvp, unsigned char *ptr,
590 NVPAIR_ASSERT(nvp);
591 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_DESCRIPTOR_ARRAY);
592 PJDLOG_ASSERT(*leftp >= nvp->nvp_datasize);
594 array = nvpair_get_descriptor_array(nvp, NULL);
597 for (ii = 0; ii < nvp->nvp_nitems; ii++) {
622 nvpair_init_datasize(nvpair_t *nvp)
625 NVPAIR_ASSERT(nvp);
627 if (nvp->nvp_type == NV_TYPE_NVLIST) {
628 if (nvp->nvp_data == 0) {
629 nvp->nvp_datasize = 0;
631 nvp->nvp_datasize =
632 nvlist_size((const nvlist_t *)(intptr_t)nvp->nvp_data);
638 nvpair_unpack_header(bool isbe, nvpair_t *nvp, const unsigned char *ptr,
683 memcpy(nvp->nvp_name, ptr, nvphdr.nvph_namesize);
690 nvp->nvp_type = nvphdr.nvph_type;
691 nvp->nvp_data = 0;
692 nvp->nvp_datasize = nvphdr.nvph_datasize;
693 nvp->nvp_nitems = nvphdr.nvph_nitems;
702 nvpair_unpack_null(bool isbe __unused, nvpair_t *nvp, const unsigned char *ptr,
706 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NULL);
708 if (nvp->nvp_datasize != 0) {
717 nvpair_unpack_bool(bool isbe __unused, nvpair_t *nvp, const unsigned char *ptr,
722 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BOOL);
724 if (nvp->nvp_datasize != sizeof(value)) {
742 nvp->nvp_data = (uint64_t)value;
748 nvpair_unpack_number(bool isbe, nvpair_t *nvp, const unsigned char *ptr,
752 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NUMBER);
754 if (nvp->nvp_datasize != sizeof(uint64_t)) {
764 nvp->nvp_data = be64dec(ptr);
766 nvp->nvp_data = le64dec(ptr);
775 nvpair_unpack_string(bool isbe __unused, nvpair_t *nvp,
779 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_STRING);
781 if (*leftp < nvp->nvp_datasize || nvp->nvp_datasize == 0) {
786 if (strnlen((const char *)ptr, nvp->nvp_datasize) !=
787 nvp->nvp_datasize - 1) {
792 nvp->nvp_data = (uint64_t)(uintptr_t)nv_strdup((const char *)ptr);
793 if (nvp->nvp_data == 0)
796 ptr += nvp->nvp_datasize;
797 *leftp -= nvp->nvp_datasize;
803 nvpair_unpack_nvlist(bool isbe __unused, nvpair_t *nvp,
808 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NVLIST);
810 if (*leftp < nvp->nvp_datasize || nvp->nvp_datasize == 0) {
823 nvp->nvp_data = (uint64_t)(uintptr_t)value;
831 nvpair_unpack_descriptor(bool isbe, nvpair_t *nvp, const unsigned char *ptr,
836 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_DESCRIPTOR);
838 if (nvp->nvp_datasize != sizeof(idx)) {
862 nvp->nvp_data = (uint64_t)fds[idx];
872 nvpair_unpack_binary(bool isbe __unused, nvpair_t *nvp,
877 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BINARY);
879 if (*leftp < nvp->nvp_datasize || nvp->nvp_datasize == 0) {
884 value = nv_malloc(nvp->nvp_datasize);
888 memcpy(value, ptr, nvp->nvp_datasize);
889 ptr += nvp->nvp_datasize;
890 *leftp -= nvp->nvp_datasize;
892 nvp->nvp_data = (uint64_t)(uintptr_t)value;
898 nvpair_unpack_bool_array(bool isbe __unused, nvpair_t *nvp,
905 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BOOL_ARRAY);
907 size = sizeof(*value) * nvp->nvp_nitems;
908 if (nvp->nvp_datasize != size || *leftp < size ||
909 nvp->nvp_nitems == 0 || size < nvp->nvp_nitems) {
918 for (i = 0; i < nvp->nvp_nitems; i++) {
925 nvp->nvp_data = (uint64_t)(uintptr_t)value;
931 nvpair_unpack_number_array(bool isbe, nvpair_t *nvp, const unsigned char *ptr,
938 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NUMBER_ARRAY);
940 size = sizeof(*value) * nvp->nvp_nitems;
941 if (nvp->nvp_datasize != size || *leftp < size ||
942 nvp->nvp_nitems == 0 || size < nvp->nvp_nitems) {
951 for (i = 0; i < nvp->nvp_nitems; i++) {
961 nvp->nvp_data = (uint64_t)(uintptr_t)value;
967 nvpair_unpack_string_array(bool isbe __unused, nvpair_t *nvp,
976 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_STRING_ARRAY);
978 if (*leftp < nvp->nvp_datasize || nvp->nvp_datasize == 0 ||
979 nvp->nvp_nitems == 0) {
984 size = nvp->nvp_datasize;
986 for (ii = 0; ii < nvp->nvp_nitems; ii++) {
1000 value = nv_malloc(sizeof(*value) * nvp->nvp_nitems);
1004 for (ii = 0; ii < nvp->nvp_nitems; ii++) {
1012 nvp->nvp_data = (uint64_t)(uintptr_t)value;
1024 nvpair_unpack_descriptor_array(bool isbe, nvpair_t *nvp,
1032 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_DESCRIPTOR_ARRAY);
1034 size = sizeof(idx) * nvp->nvp_nitems;
1035 if (nvp->nvp_datasize != size || *leftp < size ||
1036 nvp->nvp_nitems == 0 || size < nvp->nvp_nitems) {
1045 for (ii = 0; ii < nvp->nvp_nitems; ii++) {
1069 nvp->nvp_data = (uint64_t)(uintptr_t)array;
1076 nvpair_unpack_nvlist_array(bool isbe __unused, nvpair_t *nvp,
1084 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NVLIST_ARRAY);
1086 sizeup = sizeof(struct nvpair_header) * nvp->nvp_nitems;
1087 if (nvp->nvp_nitems == 0 || sizeup < nvp->nvp_nitems ||
1093 value = nv_malloc(nvp->nvp_nitems * sizeof(*value));
1097 for (ii = 0; ii < nvp->nvp_nitems; ii++) {
1109 nvlist_set_flags(value[nvp->nvp_nitems - 1], NV_FLAG_IN_ARRAY);
1111 nvp->nvp_data = (uint64_t)(uintptr_t)value;
1129 nvpair_t *nvp, *tmp;
1131 nvp = nv_calloc(1, sizeof(*nvp) + NV_NAME_MAX);
1132 if (nvp == NULL)
1134 nvp->nvp_name = (char *)(nvp + 1);
1136 ptr = nvpair_unpack_header(isbe, nvp, ptr, leftp);
1139 tmp = nv_realloc(nvp, sizeof(*nvp) + strlen(nvp->nvp_name) + 1);
1142 nvp = tmp;
1145 nvp->nvp_name = (char *)(nvp + 1);
1146 nvp->nvp_data = 0x00;
1147 nvp->nvp_magic = NVPAIR_MAGIC;
1148 *nvpp = nvp;
1151 nv_free(nvp);
1156 nvpair_type(const nvpair_t *nvp)
1159 NVPAIR_ASSERT(nvp);
1161 return (nvp->nvp_type);
1165 nvpair_name(const nvpair_t *nvp)
1168 NVPAIR_ASSERT(nvp);
1170 return (nvp->nvp_name);
1177 nvpair_t *nvp;
1180 nvp = nvpair_create_stringv(name, valuefmt, valueap);
1183 return (nvp);
1189 nvpair_t *nvp;
1196 nvp = nvpair_create_string(name, str);
1197 if (nvp == NULL)
1199 return (nvp);
1227 nvpair_t *nvp;
1241 nvp = nvpair_allocv(name, NV_TYPE_STRING, (uint64_t)(uintptr_t)data,
1243 if (nvp == NULL)
1246 return (nvp);
1253 nvpair_t *nvp;
1264 nvp = nvpair_allocv(name, NV_TYPE_NVLIST, (uint64_t)(uintptr_t)nvl, 0,
1266 if (nvp == NULL)
1269 nvlist_set_parent(nvl, nvp);
1271 return (nvp);
1278 nvpair_t *nvp;
1284 nvp = nvpair_allocv(name, NV_TYPE_DESCRIPTOR, (uint64_t)value,
1286 if (nvp == NULL) {
1292 return (nvp);
1299 nvpair_t *nvp;
1312 nvp = nvpair_allocv(name, NV_TYPE_BINARY, (uint64_t)(uintptr_t)data,
1314 if (nvp == NULL)
1317 return (nvp);
1323 nvpair_t *nvp;
1338 nvp = nvpair_allocv(name, NV_TYPE_BOOL_ARRAY, (uint64_t)(uintptr_t)data,
1340 if (nvp == NULL) {
1346 return (nvp);
1353 nvpair_t *nvp;
1368 nvp = nvpair_allocv(name, NV_TYPE_NUMBER_ARRAY,
1370 if (nvp == NULL) {
1376 return (nvp);
1383 nvpair_t *nvp;
1393 nvp = NULL;
1411 nvp = nvpair_allocv(name, NV_TYPE_STRING_ARRAY,
1415 if (nvp == NULL) {
1423 return (nvp);
1457 nvpair_t *nvp;
1459 nvp = nvpair_allocv(" ", NV_TYPE_NVLIST,
1461 if (nvp == NULL) {
1467 nvlist_set_array_next(nvls[ii - 1], nvp);
1499 nvpair_t *nvp;
1507 nvp = NULL;
1522 nvp = nvpair_allocv(name, NV_TYPE_DESCRIPTOR_ARRAY,
1526 if (nvp == NULL) {
1536 return (nvp);
1543 nvpair_t *nvp;
1550 nvp = nvpair_allocv(name, NV_TYPE_STRING, (uint64_t)(uintptr_t)value,
1552 if (nvp == NULL) {
1558 return (nvp);
1564 nvpair_t *nvp;
1577 nvp = nvpair_allocv(name, NV_TYPE_NVLIST, (uint64_t)(uintptr_t)value,
1579 if (nvp == NULL)
1582 nvlist_set_parent(value, nvp);
1584 return (nvp);
1591 nvpair_t *nvp;
1598 nvp = nvpair_allocv(name, NV_TYPE_DESCRIPTOR, (uint64_t)value,
1600 if (nvp == NULL) {
1606 return (nvp);
1613 nvpair_t *nvp;
1620 nvp = nvpair_allocv(name, NV_TYPE_BINARY, (uint64_t)(uintptr_t)value,
1622 if (nvp == NULL) {
1628 return (nvp);
1634 nvpair_t *nvp;
1641 nvp = nvpair_allocv(name, NV_TYPE_BOOL_ARRAY,
1643 if (nvp == NULL) {
1649 return (nvp);
1655 nvpair_t *nvp;
1673 nvp = nvpair_allocv(name, NV_TYPE_STRING_ARRAY,
1675 if (nvp == NULL) {
1683 return (nvp);
1689 nvpair_t *nvp;
1696 nvp = nvpair_allocv(name, NV_TYPE_NUMBER_ARRAY,
1698 if (nvp == NULL) {
1704 return (nvp);
1726 nvpair_t *nvp;
1728 nvp = nvpair_allocv(" ", NV_TYPE_NVLIST,
1730 if (nvp == NULL)
1732 nvlist_set_array_next(value[ii - 1], nvp);
1765 nvpair_t *nvp;
1780 nvp = nvpair_allocv(name, NV_TYPE_DESCRIPTOR_ARRAY,
1782 if (nvp == NULL)
1785 return (nvp);
1800 nvpair_get_bool(const nvpair_t *nvp)
1803 NVPAIR_ASSERT(nvp);
1805 return (nvp->nvp_data == 1);
1809 nvpair_get_number(const nvpair_t *nvp)
1812 NVPAIR_ASSERT(nvp);
1814 return (nvp->nvp_data);
1818 nvpair_get_string(const nvpair_t *nvp)
1821 NVPAIR_ASSERT(nvp);
1822 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_STRING);
1824 return ((const char *)(intptr_t)nvp->nvp_data);
1828 nvpair_get_nvlist(const nvpair_t *nvp)
1831 NVPAIR_ASSERT(nvp);
1832 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NVLIST);
1834 return ((const nvlist_t *)(intptr_t)nvp->nvp_data);
1839 nvpair_get_descriptor(const nvpair_t *nvp)
1842 NVPAIR_ASSERT(nvp);
1843 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_DESCRIPTOR);
1845 return ((int)nvp->nvp_data);
1850 nvpair_get_binary(const nvpair_t *nvp, size_t *sizep)
1853 NVPAIR_ASSERT(nvp);
1854 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BINARY);
1857 *sizep = nvp->nvp_datasize;
1859 return ((const void *)(intptr_t)nvp->nvp_data);
1863 nvpair_get_bool_array(const nvpair_t *nvp, size_t *nitems)
1866 NVPAIR_ASSERT(nvp);
1867 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BOOL_ARRAY);
1870 *nitems = nvp->nvp_nitems;
1872 return ((const bool *)(intptr_t)nvp->nvp_data);
1876 nvpair_get_number_array(const nvpair_t *nvp, size_t *nitems)
1879 NVPAIR_ASSERT(nvp);
1880 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NUMBER_ARRAY);
1883 *nitems = nvp->nvp_nitems;
1885 return ((const uint64_t *)(intptr_t)nvp->nvp_data);
1889 nvpair_get_string_array(const nvpair_t *nvp, size_t *nitems)
1892 NVPAIR_ASSERT(nvp);
1893 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_STRING_ARRAY);
1896 *nitems = nvp->nvp_nitems;
1898 return ((const char * const *)(intptr_t)nvp->nvp_data);
1902 nvpair_get_nvlist_array(const nvpair_t *nvp, size_t *nitems)
1905 NVPAIR_ASSERT(nvp);
1906 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NVLIST_ARRAY);
1909 *nitems = nvp->nvp_nitems;
1911 return ((const nvlist_t * const *)((intptr_t)nvp->nvp_data));
1916 nvpair_get_descriptor_array(const nvpair_t *nvp, size_t *nitems)
1919 NVPAIR_ASSERT(nvp);
1920 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_DESCRIPTOR_ARRAY);
1923 *nitems = nvp->nvp_nitems;
1925 return ((const int *)(intptr_t)nvp->nvp_data);
1930 nvpair_append_bool_array(nvpair_t *nvp, const bool value)
1933 NVPAIR_ASSERT(nvp);
1934 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BOOL_ARRAY);
1935 return (nvpair_append(nvp, &value, sizeof(value), sizeof(value)));
1939 nvpair_append_number_array(nvpair_t *nvp, const uint64_t value)
1942 NVPAIR_ASSERT(nvp);
1943 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NUMBER_ARRAY);
1944 return (nvpair_append(nvp, &value, sizeof(value), sizeof(value)));
1948 nvpair_append_string_array(nvpair_t *nvp, const char *value)
1952 NVPAIR_ASSERT(nvp);
1953 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_STRING_ARRAY);
1962 if (nvpair_append(nvp, &str, sizeof(str), strlen(str) + 1) == -1) {
1970 nvpair_append_nvlist_array(nvpair_t *nvp, const nvlist_t *value)
1976 NVPAIR_ASSERT(nvp);
1977 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NVLIST_ARRAY);
1992 if (nvp->nvp_nitems > 0) {
1993 nvlist_t **nvls = (void *)(uintptr_t)nvp->nvp_data;
1995 prev = nvls[nvp->nvp_nitems - 1];
2004 if (nvpair_append(nvp, &nvl, sizeof(nvl), 0) == -1) {
2011 nvlist_set_parent(nvl, nvp);
2023 nvpair_append_descriptor_array(nvpair_t *nvp, const int value)
2027 NVPAIR_ASSERT(nvp);
2028 PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_DESCRIPTOR_ARRAY);
2033 if (nvpair_append(nvp, &fd, sizeof(fd), sizeof(fd)) == -1) {
2042 nvpair_free(nvpair_t *nvp)
2046 NVPAIR_ASSERT(nvp);
2047 PJDLOG_ASSERT(nvp->nvp_list == NULL);
2049 nvp->nvp_magic = 0;
2050 switch (nvp->nvp_type) {
2053 close((int)nvp->nvp_data);
2056 for (i = 0; i < nvp->nvp_nitems; i++)
2057 close(((int *)(intptr_t)nvp->nvp_data)[i]);
2061 nvlist_destroy((nvlist_t *)(intptr_t)nvp->nvp_data);
2064 nv_free((char *)(intptr_t)nvp->nvp_data);
2067 nv_free((void *)(intptr_t)nvp->nvp_data);
2070 for (i = 0; i < nvp->nvp_nitems; i++) {
2072 ((nvlist_t **)(intptr_t)nvp->nvp_data)[i]);
2074 nv_free(((nvlist_t **)(intptr_t)nvp->nvp_data));
2077 nv_free((uint64_t *)(intptr_t)nvp->nvp_data);
2080 nv_free((bool *)(intptr_t)nvp->nvp_data);
2083 for (i = 0; i < nvp->nvp_nitems; i++)
2084 nv_free(((char **)(intptr_t)nvp->nvp_data)[i]);
2085 nv_free((char **)(intptr_t)nvp->nvp_data);
2088 nv_free(nvp);
2092 nvpair_free_structure(nvpair_t *nvp)
2095 NVPAIR_ASSERT(nvp);
2096 PJDLOG_ASSERT(nvp->nvp_list == NULL);
2098 nvp->nvp_magic = 0;
2099 nv_free(nvp);