diff --git a/tests/runfiles/common.run b/tests/runfiles/common.run index 51a38d70bc..ec0e392b3a 100644 --- a/tests/runfiles/common.run +++ b/tests/runfiles/common.run @@ -780,6 +780,10 @@ tests = ['nopwrite_copies', 'nopwrite_mtime', 'nopwrite_negative', 'nopwrite_varying_compression', 'nopwrite_volume'] tags = ['functional', 'nopwrite'] +[tests/functional/libnvpair] +tests = ['packed'] +tags = ['functional', 'libnvpair'] + [tests/functional/online_offline] tests = ['online_offline_001_pos', 'online_offline_002_neg', 'online_offline_003_neg'] diff --git a/tests/runfiles/sanity.run b/tests/runfiles/sanity.run index d6a791e337..8fa958fe46 100644 --- a/tests/runfiles/sanity.run +++ b/tests/runfiles/sanity.run @@ -491,6 +491,10 @@ tags = ['functional', 'nestedfs'] tests = ['nopwrite_sync', 'nopwrite_volume'] tags = ['functional', 'nopwrite'] +[tests/functional/libnvpair] +tests = ['packed'] +tags = ['functional', 'libnvpair'] + [tests/functional/pool_checkpoint] tests = ['checkpoint_conf_change', 'checkpoint_discard_many', 'checkpoint_removal', 'checkpoint_sm_scale', 'checkpoint_twice'] diff --git a/tests/zfs-tests/cmd/.gitignore b/tests/zfs-tests/cmd/.gitignore index 0ed0a69eb0..13fade41da 100644 --- a/tests/zfs-tests/cmd/.gitignore +++ b/tests/zfs-tests/cmd/.gitignore @@ -25,6 +25,7 @@ /mmap_seek /mmap_sync /mmapwrite +/nvlist_packed /nvlist_to_lua /randfree_file /randwritecomp diff --git a/tests/zfs-tests/cmd/Makefile.am b/tests/zfs-tests/cmd/Makefile.am index 23848a82ff..900d75e5d1 100644 --- a/tests/zfs-tests/cmd/Makefile.am +++ b/tests/zfs-tests/cmd/Makefile.am @@ -75,6 +75,10 @@ scripts_zfs_tests_bin_PROGRAMS += %D%/mmap_libaio endif +scripts_zfs_tests_bin_PROGRAMS += %D%/nvlist_packed +%C%_nvlist_packed_LDADD = \ + libnvpair.la + scripts_zfs_tests_bin_PROGRAMS += %D%/nvlist_to_lua %C%_nvlist_to_lua_LDADD = \ libzfs_core.la \ diff --git a/tests/zfs-tests/cmd/nvlist_packed.c b/tests/zfs-tests/cmd/nvlist_packed.c new file mode 100644 index 0000000000..1ccaa5b40a --- /dev/null +++ b/tests/zfs-tests/cmd/nvlist_packed.c @@ -0,0 +1,843 @@ +/* + * SPDX-License-Identifier: BSD-2-Clause + * + * Copyright (c) 2022 SRI International + * + * This software was developed by SRI International and the University of + * Cambridge Computer Laboratory (Department of Computer Science and + * Technology) under Defense Advanced Research Projects Agency (DARPA) + * Contract No. HR001122C0110 ("ETC"). + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#define NNVLISTS 4 + +#ifndef nitems +#define nitems(x) (sizeof (x) / sizeof ((x)[0])) +#endif + +static int verbose; +static bool genrefs, ref_match_exact; +static const char *refdir; +static int refdir_fd; + +static int tests_run, tests_failed; + +static bool nvlist_equal(nvlist_t *nvl_a, nvlist_t *nvl_b); + +static void +usage(void) +{ + printf("usage:\n"); + printf(" nvlist_pack [options] -a\n"); + printf(" nvlist_pack [options] [ [...]]\n"); + printf(" nvlist_pack [options] -l\n"); + printf("options:\n"); + printf(" -a Run all test cases\n"); + printf(" -l list test cases\n"); + printf(" -r reference directory\n"); + printf(" -R generate reference files (requires -r)\n"); + printf(" -v verbose output\n"); + printf(" -x reference buffers must match exactly\n"); + exit(1); +} + +struct nvcase { + const char *nvc_name; + const char *nvc_nvname; /* pair name, nvc_name used if NULL */ + data_type_t nvc_type; + int nvc_nelem; + const void *nvc_data; + char *nvc_failure_reason; +}; + +#define NVCASE_SIMPLE(type, nvtype) { \ + .nvc_name = #type, \ + .nvc_type = nvtype, \ + .nvc_data = &data_##type[0], \ +} +#define NVCASE_STRING(string) { \ + .nvc_name = "string_" string, \ + .nvc_type = DATA_TYPE_STRING, \ + .nvc_data = string, \ +} +#define _NVCASE_ARRAY(type, nvtype, array, nelem) { \ + .nvc_name = (type), \ + .nvc_type = (nvtype), \ + .nvc_nelem = (nelem), \ + .nvc_data = (array), \ +} +#define _NVCASE_ARRAY_ALL(type, nvtype) \ + _NVCASE_ARRAY(#type "_array", (nvtype), data_##type, \ + nitems(data_##type)) +#define _NVCASE_ARRAY_EMPTY(type, nvtype) \ + _NVCASE_ARRAY(#type "_array_empty", (nvtype), NULL, 0) +#define _NVCASE_ARRAY_SINGLE(type, nvtype) \ + _NVCASE_ARRAY(#type "_array_single", (nvtype), data_##type, 1) +#define NVCASE_ARRAY(type, nvtype) \ + _NVCASE_ARRAY_ALL(type, nvtype), \ + _NVCASE_ARRAY_EMPTY(type, nvtype), \ + _NVCASE_ARRAY_SINGLE(type, nvtype) + +static boolean_t data_boolean[] = {true, false, false, true}; +static uchar_t data_byte[] = {'a', 'b', 'c', 'd'}; +static int8_t data_int8[] = {0, 1, 2, -1}; +static uint8_t data_uint8[] = {0, 1, 2, 255}; +static int16_t data_int16[] = {0, 1, 2, -1}; +static uint16_t data_uint16[] = {0, 1, 2, 255}; +static int32_t data_int32[] = {0, 1, 2, -1}; +static uint32_t data_uint32[] = {0, 1, 2, UINT_MAX}; +static int64_t data_int64[] = {0, 1, 2, -1}; +static uint64_t data_uint64[] = {0, 1, 2, ULONG_MAX}; + +static hrtime_t data_hrtime[] = {0}; +static double data_double[] = {0.0}; + +static const char *data_string[] = {"a", "quick", "brown", "fox"}; + +/* + * Initialized by init_nvlists(). + * The naming allow the use of NVCASE_ARRAY() + */ +static nvlist_t _data_nvlist[NNVLISTS]; +static nvlist_t *data_nvlist[NNVLISTS]; + +static struct nvcase test_cases[] = { + { + .nvc_name = "boolean_flag", + .nvc_type = DATA_TYPE_BOOLEAN, + }, + NVCASE_SIMPLE(byte, DATA_TYPE_BYTE), + NVCASE_SIMPLE(int16, DATA_TYPE_INT16), + NVCASE_SIMPLE(uint16, DATA_TYPE_UINT16), + NVCASE_SIMPLE(int32, DATA_TYPE_INT32), + NVCASE_SIMPLE(uint32, DATA_TYPE_UINT32), + NVCASE_SIMPLE(int64, DATA_TYPE_INT64), + NVCASE_SIMPLE(uint64, DATA_TYPE_UINT64), + + /* XXX: use fixed width nvnames to actually hit all aligments */ + NVCASE_STRING(""), + NVCASE_STRING("0"), + NVCASE_STRING("01"), + NVCASE_STRING("012"), + NVCASE_STRING("0123"), + NVCASE_STRING("01234"), + NVCASE_STRING("012345"), + NVCASE_STRING("0123456"), + NVCASE_STRING("01234567"), + NVCASE_STRING("012345678"), + NVCASE_STRING("0123456789"), + NVCASE_STRING("0123456789a"), + NVCASE_STRING("0123456789ab"), + NVCASE_STRING("0123456789abc"), + NVCASE_STRING("0123456789abcd"), + NVCASE_STRING("0123456789abcde"), + NVCASE_STRING("0123456789abcdef"), + NVCASE_STRING("0123456789abcdefg"), + + NVCASE_ARRAY(byte, DATA_TYPE_BYTE_ARRAY), + NVCASE_ARRAY(int16, DATA_TYPE_INT16_ARRAY), + NVCASE_ARRAY(uint16, DATA_TYPE_UINT16_ARRAY), + NVCASE_ARRAY(int32, DATA_TYPE_INT32_ARRAY), + NVCASE_ARRAY(uint32, DATA_TYPE_UINT32_ARRAY), + NVCASE_ARRAY(int64, DATA_TYPE_INT64_ARRAY), + NVCASE_ARRAY(uint64, DATA_TYPE_UINT64_ARRAY), + NVCASE_ARRAY(string, DATA_TYPE_STRING_ARRAY), + NVCASE_SIMPLE(hrtime, DATA_TYPE_HRTIME), + + { + .nvc_name = "nvlist0", + .nvc_type = DATA_TYPE_NVLIST, + .nvc_data = &_data_nvlist[0], + }, + { + .nvc_name = "nvlist1", + .nvc_type = DATA_TYPE_NVLIST, + .nvc_data = &_data_nvlist[1], + }, + { + .nvc_name = "nvlist2", + .nvc_type = DATA_TYPE_NVLIST, + .nvc_data = &_data_nvlist[2], + }, + { + .nvc_name = "nvlist3", + .nvc_type = DATA_TYPE_NVLIST, + .nvc_data = &_data_nvlist[3], + }, + NVCASE_ARRAY(nvlist, DATA_TYPE_NVLIST_ARRAY), + + NVCASE_SIMPLE(boolean, DATA_TYPE_BOOLEAN_VALUE), + NVCASE_SIMPLE(int8, DATA_TYPE_INT8), + NVCASE_SIMPLE(uint8, DATA_TYPE_UINT8), + NVCASE_ARRAY(boolean, DATA_TYPE_BOOLEAN_ARRAY), + NVCASE_ARRAY(int8, DATA_TYPE_INT8_ARRAY), + NVCASE_ARRAY(uint8, DATA_TYPE_UINT8_ARRAY), + NVCASE_SIMPLE(double, DATA_TYPE_DOUBLE), + + { + .nvc_name = "empty_name", + .nvc_nvname = "", + .nvc_type = DATA_TYPE_BOOLEAN, + }, +}; + +static void +init_nvlists(void) +{ + nvlist_t *nvp; + + for (int i = 0; i < NNVLISTS; i++) { + nvp = fnvlist_alloc(); + fnvlist_add_int32(nvp, "index", i); + + switch (i) { + case 0: + fnvlist_add_byte(nvp, "byte", 'b'); + fnvlist_add_uint32(nvp, "uint32", UINT_MAX); + fnvlist_add_int64(nvp, "int64", -1); + fnvlist_add_string(nvp, "string", "value"); + break; + case 1: + fnvlist_add_nvlist(nvp, "nvlist0", data_nvlist[0]); + break; + case 2: + fnvlist_add_nvlist(nvp, "nvlist1", data_nvlist[1]); + break; + case 3: + fnvlist_add_nvlist(nvp, "nvlist2", data_nvlist[2]); + break; + default: + abort(); + } + + data_nvlist[i] = nvp; + /* + * Hack to allow statically allocated nvlist storage + * Ideally nvlist_init() would be exposed and be able to + * alloc programmer managed storage, but it isn't so we + * cheat and copy the allocated one's contents into + * static storage to allow test_cases[] to be + * initialised at compile time. + */ + memcpy(&_data_nvlist[i], nvp, sizeof (_data_nvlist[i])); + } +} + +static void +list_tests(void) +{ + for (int i = 0; i < nitems(test_cases); i++) + printf("'%s'\n", test_cases[i].nvc_name); + exit(0); +} + +static int +case_populate_nvlist(struct nvcase *tc, nvlist_t *nvl) +{ + const char *name = tc->nvc_nvname != NULL? tc->nvc_nvname : + tc->nvc_name; + + switch (tc->nvc_type) { + case DATA_TYPE_BOOLEAN: + return (nvlist_add_boolean(nvl, name)); + case DATA_TYPE_BOOLEAN_VALUE: + return (nvlist_add_boolean_value(nvl, name, + *(boolean_t *)tc->nvc_data)); + case DATA_TYPE_BYTE: + return (nvlist_add_byte(nvl, name, + *(uchar_t *)tc->nvc_data)); + case DATA_TYPE_INT8 : + return (nvlist_add_int8(nvl, name, + *(int8_t *)tc->nvc_data)); + case DATA_TYPE_UINT8: + return (nvlist_add_uint8(nvl, name, + *(uint8_t *)tc->nvc_data)); + case DATA_TYPE_INT16: + return (nvlist_add_int16(nvl, name, + *(int16_t *)tc->nvc_data)); + case DATA_TYPE_UINT16: + return (nvlist_add_uint16(nvl, name, + *(uint16_t *)tc->nvc_data)); + case DATA_TYPE_INT32: + return (nvlist_add_int32(nvl, name, + *(int32_t *)tc->nvc_data)); + case DATA_TYPE_UINT32: + return (nvlist_add_uint32(nvl, name, + *(uint32_t *)tc->nvc_data)); + case DATA_TYPE_INT64: + return (nvlist_add_int64(nvl, name, + *(int64_t *)tc->nvc_data)); + case DATA_TYPE_UINT64: + return (nvlist_add_uint64(nvl, name, + *(uint64_t *)tc->nvc_data)); + case DATA_TYPE_HRTIME: + return (nvlist_add_hrtime(nvl, name, + *(hrtime_t *)tc->nvc_data)); + case DATA_TYPE_DOUBLE: + return (nvlist_add_double(nvl, name, + *(double *)tc->nvc_data)); + + case DATA_TYPE_BOOLEAN_ARRAY: + return (nvlist_add_boolean_array(nvl, name, + tc->nvc_data, tc->nvc_nelem)); + case DATA_TYPE_BYTE_ARRAY: + return (nvlist_add_byte_array(nvl, name, + tc->nvc_data, tc->nvc_nelem)); + case DATA_TYPE_INT8_ARRAY: + return (nvlist_add_int8_array(nvl, name, + tc->nvc_data, tc->nvc_nelem)); + case DATA_TYPE_UINT8_ARRAY: + return (nvlist_add_uint8_array(nvl, name, + tc->nvc_data, tc->nvc_nelem)); + case DATA_TYPE_INT16_ARRAY: + return (nvlist_add_int16_array(nvl, name, + tc->nvc_data, tc->nvc_nelem)); + case DATA_TYPE_UINT16_ARRAY: + return (nvlist_add_uint16_array(nvl, name, + tc->nvc_data, tc->nvc_nelem)); + case DATA_TYPE_INT32_ARRAY: + return (nvlist_add_int32_array(nvl, name, + tc->nvc_data, tc->nvc_nelem)); + case DATA_TYPE_UINT32_ARRAY: + return (nvlist_add_uint32_array(nvl, name, + tc->nvc_data, tc->nvc_nelem)); + case DATA_TYPE_INT64_ARRAY: + return (nvlist_add_int64_array(nvl, name, + tc->nvc_data, tc->nvc_nelem)); + case DATA_TYPE_UINT64_ARRAY: + return (nvlist_add_uint64_array(nvl, name, + tc->nvc_data, tc->nvc_nelem)); + + case DATA_TYPE_STRING: + return (nvlist_add_string(nvl, name, + tc->nvc_data)); + case DATA_TYPE_STRING_ARRAY: + return (nvlist_add_string_array(nvl, name, + tc->nvc_data, tc->nvc_nelem)); + + case DATA_TYPE_NVLIST: + return (nvlist_add_nvlist(nvl, name, + tc->nvc_data)); + case DATA_TYPE_NVLIST_ARRAY: + return (nvlist_add_nvlist_array(nvl, name, + tc->nvc_data, tc->nvc_nelem)); + default: + return (-1); + } +} + +static nvlist_t * +case_create_nvlist(struct nvcase *tc) +{ + nvlist_t *nvl; + + if (nvlist_alloc(&nvl, 0, 0) != 0) + return (NULL); + + if (case_populate_nvlist(tc, nvl) != 0) + return (NULL); + + return (nvl); +} + +static void +case_failed(struct nvcase *tc, const char *reason) +{ + if (tc->nvc_failure_reason != NULL) + return; /* Already called */ + tests_failed++; + tc->nvc_failure_reason = strdup(reason); + printf("FAIL: %s: %s\n", tc->nvc_name, reason); +} + +static void +run_case(struct nvcase *tc) +{ + nvlist_t *created_nvl, *ref_nvl, *unpacked_nvl; + char *packed_buffer = NULL; + size_t buflen; + + tests_run++; + + created_nvl = case_create_nvlist(tc); + if (created_nvl == NULL) { + case_failed(tc, "case_create_nvlist"); + return; + } + if (nvlist_pack(created_nvl, &packed_buffer, &buflen, NV_ENCODE_XDR, + KM_SLEEP) != 0) { + case_failed(tc, "nvlist_pack"); + return; + } + if (nvlist_unpack(packed_buffer, buflen, &unpacked_nvl, + KM_SLEEP) != 0) { + case_failed(tc, "nvlist_unpack (round-trip)"); + return; + } + + if (!nvlist_equal(created_nvl, unpacked_nvl)) { + case_failed(tc, + "create and unpacked nvlists aren't equal"); + return; + } + + if (refdir != NULL) { + struct stat sb; + char *ref_buffer, *ref_file; + size_t ref_len; + int ref_fd; + + if (asprintf(&ref_file, "%s.ref", tc->nvc_name) == -1) { + case_failed(tc, "asprintf"); + return; + } + if (genrefs) { + ref_fd = openat(refdir_fd, ref_file, + O_WRONLY | O_CREAT | O_TRUNC, 0660); + if (ref_fd == -1) { + fprintf(stderr, + "%s: unable to create ref file %s/%s\n", + tc->nvc_name, refdir, ref_file); + exit(1); + } + if (write(ref_fd, packed_buffer, buflen) != buflen) { + fprintf(stderr, "%s: failed to write packed\n", + tc->nvc_name); + exit(1); + } + close(ref_fd); + } + + ref_fd = openat(refdir_fd, ref_file, O_RDONLY); + if (ref_fd == -1) { + case_failed(tc, "failed to open ref file"); + return; + } + fstat(ref_fd, &sb); + ref_len = sb.st_size; + if (ref_len != buflen) { + case_failed(tc, + "ref_len and buflen aren't the same size"); + close(ref_fd); + return; + } + ref_buffer = malloc(ref_len); + if (read(ref_fd, ref_buffer, ref_len) != sb.st_size) { + case_failed(tc, "failed to read from ref file"); + close(ref_fd); + return; + } + close(ref_fd); + + if (nvlist_unpack(ref_buffer, buflen, &ref_nvl, + KM_SLEEP) != 0) { + case_failed(tc, "nvlist_unpack (ref)"); + return; + } + if (!nvlist_equal(created_nvl, ref_nvl)) { + case_failed(tc, + "created and ref_unpacked nvlists aren't equal"); + return; + } + if (ref_match_exact && + memcmp(packed_buffer, ref_buffer, buflen) != 0) { + case_failed(tc, "packed and ref buffers differ"); + return; + } + } + + printf("PASS: %s\n", tc->nvc_name); +} + +static void +run_case_name(const char *name) +{ + int i; + + for (i = 0; i < nitems(test_cases); i++) { + if (strcmp(name, test_cases[i].nvc_name) == 0) { + run_case(&test_cases[i]); + return; + } + } + fprintf(stderr, "unknown test: '%s'\n", name); + exit(1); +} + +/* CSTYLED */ +#define NVP_EQUAL_TYPE(type, name) __extension__({ \ + bool is_equal; \ + type a, b; \ + nvpair_value_##name(nvp_a, &a); \ + nvpair_value_##name(nvp_b, &b); \ + is_equal = (a == b); \ + is_equal; \ +}) + +/* CSTYLED */ +#define NVP_EQUAL_TYPE_ARRAY(type, name) __extension__({ \ + bool is_equal; \ + type *a, *b; \ + uint_t nelem_a, nelem_b; \ + nvpair_value_##name##_array(nvp_a, &a, &nelem_a); \ + nvpair_value_##name##_array(nvp_b, &b, &nelem_b); \ + is_equal = (nelem_a == nelem_b); \ + if (is_equal) \ + for (uint_t i = 0; i < nelem_a; i++) \ + if (a[i] != b[i]) { \ + is_equal = false; \ + break; \ + } \ + is_equal; \ +}) + +static bool +nvpair_value_equal(nvpair_t *nvp_a, nvpair_t *nvp_b) +{ + if (nvpair_type(nvp_a) != nvpair_type(nvp_b)) { + if (verbose >= 2) + printf("%s: pair types differ\n", __func__); + return (false); + } + switch (nvpair_type(nvp_a)) { + case DATA_TYPE_BOOLEAN: + return (true); /* Presence is the value */ + + case DATA_TYPE_BOOLEAN_VALUE: + if (NVP_EQUAL_TYPE(boolean_t, boolean_value)) + return (true); + break; + case DATA_TYPE_BYTE: + if (NVP_EQUAL_TYPE(uchar_t, byte)) + return (true); + break; + case DATA_TYPE_INT8 : + if (NVP_EQUAL_TYPE(int8_t, int8)) + return (true); + break; + case DATA_TYPE_UINT8: + if (NVP_EQUAL_TYPE(uint8_t, uint8)) + return (true); + break; + case DATA_TYPE_INT16: + if (NVP_EQUAL_TYPE(int16_t, int16)) + return (true); + break; + case DATA_TYPE_UINT16: + if (NVP_EQUAL_TYPE(uint16_t, uint16)) + return (true); + break; + case DATA_TYPE_INT32: + if (NVP_EQUAL_TYPE(int32_t, int32)) + return (true); + break; + case DATA_TYPE_UINT32: + if (NVP_EQUAL_TYPE(uint32_t, uint32)) + return (true); + break; + case DATA_TYPE_INT64: + if (NVP_EQUAL_TYPE(int64_t, int64)) + return (true); + break; + case DATA_TYPE_UINT64: + if (NVP_EQUAL_TYPE(uint64_t, uint64)) + return (true); + break; + case DATA_TYPE_HRTIME: + if (NVP_EQUAL_TYPE(hrtime_t, hrtime)) + return (true); + break; + case DATA_TYPE_DOUBLE: + if (NVP_EQUAL_TYPE(double, double)) + return (true); + break; + + case DATA_TYPE_BOOLEAN_ARRAY: + if (NVP_EQUAL_TYPE_ARRAY(boolean_t, boolean)) + return (true); + break; + case DATA_TYPE_BYTE_ARRAY: + if (NVP_EQUAL_TYPE_ARRAY(uchar_t, byte)) + return (true); + break; + case DATA_TYPE_INT8_ARRAY: + if (NVP_EQUAL_TYPE_ARRAY(int8_t, int8)) + return (true); + break; + case DATA_TYPE_UINT8_ARRAY: + if (NVP_EQUAL_TYPE_ARRAY(uint8_t, uint8)) + return (true); + break; + case DATA_TYPE_INT16_ARRAY: + if (NVP_EQUAL_TYPE_ARRAY(int16_t, int16)) + return (true); + break; + case DATA_TYPE_UINT16_ARRAY: + if (NVP_EQUAL_TYPE_ARRAY(uint16_t, uint16)) + return (true); + break; + case DATA_TYPE_INT32_ARRAY: + if (NVP_EQUAL_TYPE_ARRAY(int32_t, int32)) + return (true); + break; + case DATA_TYPE_UINT32_ARRAY: + if (NVP_EQUAL_TYPE_ARRAY(uint32_t, uint32)) + return (true); + break; + case DATA_TYPE_INT64_ARRAY: + if (NVP_EQUAL_TYPE_ARRAY(int64_t, int64)) + return (true); + break; + case DATA_TYPE_UINT64_ARRAY: + if (NVP_EQUAL_TYPE_ARRAY(uint64_t, uint64)) + return (true); + break; + + case DATA_TYPE_STRING: { + char *str_a, *str_b; + nvpair_value_string(nvp_a, &str_a); + nvpair_value_string(nvp_b, &str_b); + if (strcmp(str_a, str_b) == 0) + return (true); + break; + } + case DATA_TYPE_STRING_ARRAY: { + char **stra_a, **stra_b; + uint_t nelem_a, nelem_b; + nvpair_value_string_array(nvp_a, &stra_a, &nelem_a); + nvpair_value_string_array(nvp_b, &stra_b, &nelem_b); + if (nelem_a != nelem_b) + goto not_equal; + for (int i = 0; i < nelem_a; i++) { + if (strcmp(stra_a[i], stra_b[i]) != 0) + goto not_equal; + } + return (true); + } + + case DATA_TYPE_NVLIST: { + nvlist_t *nvl_a, *nvl_b; + nvpair_value_nvlist(nvp_a, &nvl_a); + nvpair_value_nvlist(nvp_b, &nvl_b); + if (nvlist_equal(nvl_a, nvl_b)) + return (true); + break; + } + case DATA_TYPE_NVLIST_ARRAY: { + nvlist_t **nvla_a, **nvla_b; + uint_t nelem_a, nelem_b; + nvpair_value_nvlist_array(nvp_a, &nvla_a, &nelem_a); + nvpair_value_nvlist_array(nvp_b, &nvla_b, &nelem_b); + if (nelem_a != nelem_b) + goto not_equal; + for (int i = 0; i < nelem_a; i++) { + if (!nvlist_equal(nvla_a[i], nvla_b[i])) + goto not_equal; + } + return (true); + } + + case DATA_TYPE_DONTCARE: + case DATA_TYPE_UNKNOWN: + if (verbose >= 2) + printf("%s: unhandled type %d\n", __func__, + nvpair_type(nvp_a)); + return (false); + } + +not_equal: + if (verbose >= 2) + printf("%s: values are not equal\n", __func__); + return (false); +} +#undef NVP_EQUAL_TYPE +#undef NVP_EQUAL_TYPE_ARRAY + +static bool +nvpair_equal(nvpair_t *nvp_a, nvpair_t *nvp_b) +{ + if (strcmp(nvpair_name(nvp_a), nvpair_name(nvp_b)) != 0) { + if (verbose >= 2) + printf("%s: pair names differ\n", __func__); + return (false); + } + return (nvpair_value_equal(nvp_a, nvp_b)); +} + +/* + * nvlist_equal - check if two nvlists are equal. + * + * Each pair be present in each list and they must appear in the same + * order. While ordering does not matter from an API perspective, it + * must hold for the packed forms to be identical. + */ +static bool +nvlist_equal(nvlist_t *nvl_a, nvlist_t *nvl_b) +{ + nvpair_t *nvp_a, *nvp_b; + + if (fnvlist_num_pairs(nvl_a) != fnvlist_num_pairs(nvl_b)) + return (false); + + if (verbose >= 3) { + nvpair_t *pair; + pair = NULL; + printf("dumping nvp_a\n"); + while ((pair = nvlist_next_nvpair(nvl_a, pair)) != NULL) + printf("'%s'\n", nvpair_name(pair)); + printf("dumping nvp_b\n"); + while ((pair = nvlist_next_nvpair(nvl_b, pair)) != NULL) + printf("'%s'\n", nvpair_name(pair)); + } + + for (nvp_a = nvlist_next_nvpair(nvl_a, NULL), + nvp_b = nvlist_next_nvpair(nvl_b, NULL); + nvp_a != NULL && nvp_b != NULL; + nvp_a = nvlist_next_nvpair(nvl_a, nvp_a), + nvp_b = nvlist_next_nvpair(nvl_b, nvp_b)) { + if (!nvpair_equal(nvp_a, nvp_b)) + return (false); + } + if (nvp_a == NULL && nvp_b == NULL) + return (true); + + return (false); +} + +int +main(int argc, char **argv) +{ + int i, opt; + bool list, run_all; + + list = run_all = false; + + while ((opt = getopt(argc, argv, "alr:Rvx")) != -1) { + switch (opt) { + case 'a': + run_all = true; + break; + case 'l': + list = true; + break; + case 'r': + refdir = optarg; + break; + case 'R': + genrefs = true; + break; + case 'v': + verbose++; + break; + case 'x': + ref_match_exact = true; + break; + default: + fprintf(stderr, "unknown argument %c\n", opt); + usage(); + } + } + argc -= optind; + argv += optind; + if (run_all && list) { + fprintf(stderr, "-a and -l are incompatible\n"); + usage(); + } + if (list && genrefs) { + fprintf(stderr, "-l and -R are incompatible\n"); + usage(); + } + if (list && refdir != NULL) { + fprintf(stderr, "-l and -r are incompatible\n"); + usage(); + } + if (list) { + if (argc == 0) + list_tests(); + fprintf(stderr, "-l and a list of test are incompatible\n"); + usage(); + } + if (argc == 0 && !run_all) + usage(); + if (argc > 0 && run_all) { + fprintf(stderr, "-a and a list of cases are incompatible\n"); + usage(); + } + + if (refdir != NULL) { +#ifdef O_PATH + const int o_path_flag = O_PATH; +#else + const int o_path_flag = O_RDONLY; +#endif + + refdir_fd = open(refdir, O_DIRECTORY | O_CLOEXEC | o_path_flag); + if (refdir_fd == -1) { + fprintf(stderr, "Failed to open refdir %s: %s\n", + refdir, strerror(errno)); + exit(1); + } + } + + init_nvlists(); + + if (run_all) { + for (i = 0; i < nitems(test_cases); i++) + run_case(&test_cases[i]); + } else { + for (i = 0; i < argc; i++) + run_case_name(argv[i]); + } + + if (verbose > 0 && tests_failed > 0) { + printf("Unexpected failures:\n"); + for (i = 0; i < nitems(test_cases); i++) { + if (test_cases[i].nvc_failure_reason != NULL) { + printf("\t%s: %s\n", test_cases[i].nvc_name, + test_cases[i].nvc_failure_reason); + } + } + } + if (verbose >= 0) { + printf("SUMMARY"); + if (tests_run - tests_failed > 0) + printf(": passed %d", tests_run - tests_failed); + if (tests_failed > 0) + printf(": failed %d", tests_failed); + printf("\n"); + } + + return (tests_failed); +} diff --git a/tests/zfs-tests/include/commands.cfg b/tests/zfs-tests/include/commands.cfg index daa7945516..78d5a78912 100644 --- a/tests/zfs-tests/include/commands.cfg +++ b/tests/zfs-tests/include/commands.cfg @@ -208,6 +208,7 @@ export ZFSTEST_FILES='badsend mmap_seek mmap_sync mmapwrite + nvlist_packed nvlist_to_lua randfree_file randwritecomp diff --git a/tests/zfs-tests/tests/Makefile.am b/tests/zfs-tests/tests/Makefile.am index 73a6f00b50..ba36b9ae98 100644 --- a/tests/zfs-tests/tests/Makefile.am +++ b/tests/zfs-tests/tests/Makefile.am @@ -340,6 +340,78 @@ nobase_dist_datadir_zfs_tests_tests_DATA += \ functional/mv_files/mv_files_common.kshlib \ functional/nopwrite/nopwrite.shlib \ functional/no_space/enospc.cfg \ + functional/libnvpair/refs/boolean_flag.ref \ + functional/libnvpair/refs/byte.ref \ + functional/libnvpair/refs/int16.ref \ + functional/libnvpair/refs/uint16.ref \ + functional/libnvpair/refs/int32.ref \ + functional/libnvpair/refs/uint32.ref \ + functional/libnvpair/refs/int64.ref \ + functional/libnvpair/refs/uint64.ref \ + functional/libnvpair/refs/string_.ref \ + functional/libnvpair/refs/string_0.ref \ + functional/libnvpair/refs/string_01.ref \ + functional/libnvpair/refs/string_012.ref \ + functional/libnvpair/refs/string_0123.ref \ + functional/libnvpair/refs/string_01234.ref \ + functional/libnvpair/refs/string_012345.ref \ + functional/libnvpair/refs/string_0123456.ref \ + functional/libnvpair/refs/string_01234567.ref \ + functional/libnvpair/refs/string_012345678.ref \ + functional/libnvpair/refs/string_0123456789.ref \ + functional/libnvpair/refs/byte_array.ref \ + functional/libnvpair/refs/string_0123456789a.ref \ + functional/libnvpair/refs/string_0123456789ab.ref \ + functional/libnvpair/refs/string_0123456789abc.ref \ + functional/libnvpair/refs/string_0123456789abcd.ref \ + functional/libnvpair/refs/string_0123456789abcde.ref \ + functional/libnvpair/refs/string_0123456789abcdef.ref \ + functional/libnvpair/refs/string_0123456789abcdefg.ref \ + functional/libnvpair/refs/byte_array_empty.ref \ + functional/libnvpair/refs/byte_array_single.ref \ + functional/libnvpair/refs/int16_array.ref \ + functional/libnvpair/refs/int16_array_empty.ref \ + functional/libnvpair/refs/int16_array_single.ref \ + functional/libnvpair/refs/uint16_array.ref \ + functional/libnvpair/refs/uint16_array_empty.ref \ + functional/libnvpair/refs/uint16_array_single.ref \ + functional/libnvpair/refs/hrtime.ref \ + functional/libnvpair/refs/int32_array.ref \ + functional/libnvpair/refs/int32_array_empty.ref \ + functional/libnvpair/refs/int32_array_single.ref \ + functional/libnvpair/refs/uint32_array.ref \ + functional/libnvpair/refs/uint32_array_empty.ref \ + functional/libnvpair/refs/uint32_array_single.ref \ + functional/libnvpair/refs/int64_array.ref \ + functional/libnvpair/refs/int64_array_empty.ref \ + functional/libnvpair/refs/int64_array_single.ref \ + functional/libnvpair/refs/uint64_array.ref \ + functional/libnvpair/refs/uint64_array_empty.ref \ + functional/libnvpair/refs/uint64_array_single.ref \ + functional/libnvpair/refs/string_array.ref \ + functional/libnvpair/refs/string_array_empty.ref \ + functional/libnvpair/refs/string_array_single.ref \ + functional/libnvpair/refs/nvlist0.ref \ + functional/libnvpair/refs/nvlist1.ref \ + functional/libnvpair/refs/nvlist2.ref \ + functional/libnvpair/refs/nvlist3.ref \ + functional/libnvpair/refs/nvlist_array.ref \ + functional/libnvpair/refs/nvlist_array_empty.ref \ + functional/libnvpair/refs/nvlist_array_single.ref \ + functional/libnvpair/refs/boolean.ref \ + functional/libnvpair/refs/int8.ref \ + functional/libnvpair/refs/uint8.ref \ + functional/libnvpair/refs/boolean_array.ref \ + functional/libnvpair/refs/boolean_array_empty.ref \ + functional/libnvpair/refs/boolean_array_single.ref \ + functional/libnvpair/refs/int8_array.ref \ + functional/libnvpair/refs/int8_array_empty.ref \ + functional/libnvpair/refs/int8_array_single.ref \ + functional/libnvpair/refs/uint8_array.ref \ + functional/libnvpair/refs/uint8_array_empty.ref \ + functional/libnvpair/refs/uint8_array_single.ref \ + functional/libnvpair/refs/double.ref \ + functional/libnvpair/refs/empty_name.ref \ functional/online_offline/online_offline.cfg \ functional/pool_checkpoint/pool_checkpoint.kshlib \ functional/projectquota/projectquota.cfg \ @@ -1637,6 +1709,9 @@ nobase_dist_datadir_zfs_tests_tests_SCRIPTS += \ functional/no_space/enospc_ganging.ksh \ functional/no_space/enospc_rm.ksh \ functional/no_space/setup.ksh \ + functional/libnvpair/cleanup.ksh \ + functional/libnvpair/packed.ksh \ + functional/libnvpair/setup.ksh \ functional/online_offline/cleanup.ksh \ functional/online_offline/online_offline_001_pos.ksh \ functional/online_offline/online_offline_002_neg.ksh \ diff --git a/tests/zfs-tests/tests/functional/libnvpair/cleanup.ksh b/tests/zfs-tests/tests/functional/libnvpair/cleanup.ksh new file mode 100644 index 0000000000..dc49790c99 --- /dev/null +++ b/tests/zfs-tests/tests/functional/libnvpair/cleanup.ksh @@ -0,0 +1,34 @@ +#!/bin/ksh -p +# +# CDDL HEADER START +# +# The contents of this file are subject to the terms of the +# Common Development and Distribution License (the "License"). +# You may not use this file except in compliance with the License. +# +# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE +# or https://opensource.org/licenses/CDDL-1.0. +# See the License for the specific language governing permissions +# and limitations under the License. +# +# When distributing Covered Code, include this CDDL HEADER in each +# file and include the License file at usr/src/OPENSOLARIS.LICENSE. +# If applicable, add the following below this CDDL HEADER, with the +# fields enclosed by brackets "[]" replaced with your own identifying +# information: Portions Copyright [yyyy] [name of copyright owner] +# +# CDDL HEADER END +# + +# +# Copyright 2022 SRI International +# +# This software was developed by SRI International, the University of +# Cambridge Computer Laboratory (Department of Computer Science and +# Technology), and Capabilities Limited under Defense Advanced Research +# Projects Agency (DARPA) Contract No. HR001122C0110 ("ETC"). +# + +. $STF_SUITE/include/libtest.shlib + +log_pass diff --git a/tests/zfs-tests/tests/functional/libnvpair/packed.ksh b/tests/zfs-tests/tests/functional/libnvpair/packed.ksh new file mode 100644 index 0000000000..ef50e9a194 --- /dev/null +++ b/tests/zfs-tests/tests/functional/libnvpair/packed.ksh @@ -0,0 +1,48 @@ +#! /bin/ksh -p +# +# CDDL HEADER START +# +# The contents of this file are subject to the terms of the +# Common Development and Distribution License (the "License"). +# You may not use this file except in compliance with the License. +# +# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE +# or https://opensource.org/licenses/CDDL-1.0. +# See the License for the specific language governing permissions +# and limitations under the License. +# +# When distributing Covered Code, include this CDDL HEADER in each +# file and include the License file at usr/src/OPENSOLARIS.LICENSE. +# If applicable, add the following below this CDDL HEADER, with the +# fields enclosed by brackets "[]" replaced with your own identifying +# information: Portions Copyright [yyyy] [name of copyright owner] +# +# CDDL HEADER END +# + +# +# Copyright 2022 SRI International +# +# This software was developed by SRI International, the University of +# Cambridge Computer Laboratory (Department of Computer Science and +# Technology), and Capabilities Limited under Defense Advanced Research +# Projects Agency (DARPA) Contract No. HR001122C0110 ("ETC"). +# + +. $STF_SUITE/include/libtest.shlib + +# +# DESCRIPTION: +# Ensure that nvlists can be packed and unpacked correctly. +# +# STRATEGY: +# Run all test cases and check against reference outputs +# + +verify_runnable "both" + +log_assert "Ensure nvlist pack/unpack work" + +log_must nvlist_packed -a -r ${STF_SUITE}/tests/functional/libnvpair/refs + +log_pass "Packed nvlists round trip and compare to references" diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/boolean.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/boolean.ref new file mode 100644 index 0000000000..e169cf5ffa Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/boolean.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/boolean_array.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/boolean_array.ref new file mode 100644 index 0000000000..a66f023f28 Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/boolean_array.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/boolean_array_empty.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/boolean_array_empty.ref new file mode 100644 index 0000000000..cbeaa3d8cf Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/boolean_array_empty.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/boolean_array_single.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/boolean_array_single.ref new file mode 100644 index 0000000000..90b966b4e3 Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/boolean_array_single.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/boolean_flag.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/boolean_flag.ref new file mode 100644 index 0000000000..019f6b4e85 Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/boolean_flag.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/byte.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/byte.ref new file mode 100644 index 0000000000..8f021bb1fd Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/byte.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/byte_array.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/byte_array.ref new file mode 100644 index 0000000000..20191e4259 Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/byte_array.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/byte_array_empty.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/byte_array_empty.ref new file mode 100644 index 0000000000..d1eed75650 Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/byte_array_empty.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/byte_array_single.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/byte_array_single.ref new file mode 100644 index 0000000000..d94b768314 Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/byte_array_single.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/double.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/double.ref new file mode 100644 index 0000000000..c789a04927 Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/double.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/empty_name.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/empty_name.ref new file mode 100644 index 0000000000..e4afe72b9f Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/empty_name.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/hrtime.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/hrtime.ref new file mode 100644 index 0000000000..ee20de2866 Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/hrtime.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/int16.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/int16.ref new file mode 100644 index 0000000000..411a9f2ad9 Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/int16.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/int16_array.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/int16_array.ref new file mode 100644 index 0000000000..0ae965558d Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/int16_array.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/int16_array_empty.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/int16_array_empty.ref new file mode 100644 index 0000000000..90b79e3352 Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/int16_array_empty.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/int16_array_single.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/int16_array_single.ref new file mode 100644 index 0000000000..61389231b5 Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/int16_array_single.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/int32.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/int32.ref new file mode 100644 index 0000000000..254e0bc384 Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/int32.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/int32_array.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/int32_array.ref new file mode 100644 index 0000000000..e908ca2743 Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/int32_array.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/int32_array_empty.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/int32_array_empty.ref new file mode 100644 index 0000000000..79fbb2aa19 Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/int32_array_empty.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/int32_array_single.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/int32_array_single.ref new file mode 100644 index 0000000000..6f82c2108e Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/int32_array_single.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/int64.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/int64.ref new file mode 100644 index 0000000000..503a97b2fa Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/int64.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/int64_array.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/int64_array.ref new file mode 100644 index 0000000000..68d1b43a83 Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/int64_array.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/int64_array_empty.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/int64_array_empty.ref new file mode 100644 index 0000000000..31d50ff1bc Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/int64_array_empty.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/int64_array_single.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/int64_array_single.ref new file mode 100644 index 0000000000..eaeb0de9f9 Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/int64_array_single.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/int8.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/int8.ref new file mode 100644 index 0000000000..4d104062fe Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/int8.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/int8_array.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/int8_array.ref new file mode 100644 index 0000000000..bd380dff9d Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/int8_array.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/int8_array_empty.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/int8_array_empty.ref new file mode 100644 index 0000000000..54546eae2c Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/int8_array_empty.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/int8_array_single.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/int8_array_single.ref new file mode 100644 index 0000000000..40d4a6d24b Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/int8_array_single.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/nvlist0.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/nvlist0.ref new file mode 100644 index 0000000000..8a29be6701 Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/nvlist0.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/nvlist1.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/nvlist1.ref new file mode 100644 index 0000000000..dc355f8a50 Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/nvlist1.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/nvlist2.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/nvlist2.ref new file mode 100644 index 0000000000..e9871d83ed Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/nvlist2.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/nvlist3.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/nvlist3.ref new file mode 100644 index 0000000000..365655962f Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/nvlist3.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/nvlist_array.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/nvlist_array.ref new file mode 100644 index 0000000000..93561ac89f Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/nvlist_array.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/nvlist_array_empty.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/nvlist_array_empty.ref new file mode 100644 index 0000000000..e27fbf98ac Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/nvlist_array_empty.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/nvlist_array_single.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/nvlist_array_single.ref new file mode 100644 index 0000000000..b20a194365 Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/nvlist_array_single.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/string_.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/string_.ref new file mode 100644 index 0000000000..325938256e Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/string_.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/string_0.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/string_0.ref new file mode 100644 index 0000000000..860cf3d071 Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/string_0.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/string_01.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/string_01.ref new file mode 100644 index 0000000000..5c6724102c Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/string_01.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/string_012.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/string_012.ref new file mode 100644 index 0000000000..5b11119afa Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/string_012.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/string_0123.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/string_0123.ref new file mode 100644 index 0000000000..74498975c4 Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/string_0123.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/string_01234.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/string_01234.ref new file mode 100644 index 0000000000..70d1748939 Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/string_01234.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/string_012345.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/string_012345.ref new file mode 100644 index 0000000000..800d18e723 Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/string_012345.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/string_0123456.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/string_0123456.ref new file mode 100644 index 0000000000..d80bae7103 Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/string_0123456.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/string_01234567.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/string_01234567.ref new file mode 100644 index 0000000000..ff971aef05 Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/string_01234567.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/string_012345678.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/string_012345678.ref new file mode 100644 index 0000000000..d6344c1194 Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/string_012345678.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/string_0123456789.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/string_0123456789.ref new file mode 100644 index 0000000000..6488575d83 Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/string_0123456789.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/string_0123456789a.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/string_0123456789a.ref new file mode 100644 index 0000000000..c693671ed5 Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/string_0123456789a.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/string_0123456789ab.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/string_0123456789ab.ref new file mode 100644 index 0000000000..2eaade3c16 Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/string_0123456789ab.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/string_0123456789abc.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/string_0123456789abc.ref new file mode 100644 index 0000000000..8db35412b9 Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/string_0123456789abc.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/string_0123456789abcd.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/string_0123456789abcd.ref new file mode 100644 index 0000000000..2bba00dc31 Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/string_0123456789abcd.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/string_0123456789abcde.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/string_0123456789abcde.ref new file mode 100644 index 0000000000..947a866223 Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/string_0123456789abcde.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/string_0123456789abcdef.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/string_0123456789abcdef.ref new file mode 100644 index 0000000000..b8dbb54734 Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/string_0123456789abcdef.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/string_0123456789abcdefg.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/string_0123456789abcdefg.ref new file mode 100644 index 0000000000..67b794d908 Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/string_0123456789abcdefg.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/string_array.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/string_array.ref new file mode 100644 index 0000000000..d2d42086ab Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/string_array.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/string_array_empty.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/string_array_empty.ref new file mode 100644 index 0000000000..a47a74f130 Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/string_array_empty.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/string_array_single.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/string_array_single.ref new file mode 100644 index 0000000000..86eddce6f0 Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/string_array_single.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/uint16.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/uint16.ref new file mode 100644 index 0000000000..0ac7b54bbb Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/uint16.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/uint16_array.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/uint16_array.ref new file mode 100644 index 0000000000..37168018d9 Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/uint16_array.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/uint16_array_empty.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/uint16_array_empty.ref new file mode 100644 index 0000000000..e31d698e26 Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/uint16_array_empty.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/uint16_array_single.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/uint16_array_single.ref new file mode 100644 index 0000000000..3722cc1142 Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/uint16_array_single.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/uint32.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/uint32.ref new file mode 100644 index 0000000000..2773cc71eb Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/uint32.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/uint32_array.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/uint32_array.ref new file mode 100644 index 0000000000..257accf94f Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/uint32_array.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/uint32_array_empty.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/uint32_array_empty.ref new file mode 100644 index 0000000000..8dad832d29 Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/uint32_array_empty.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/uint32_array_single.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/uint32_array_single.ref new file mode 100644 index 0000000000..48e74f046b Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/uint32_array_single.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/uint64.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/uint64.ref new file mode 100644 index 0000000000..5cf66821f9 Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/uint64.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/uint64_array.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/uint64_array.ref new file mode 100644 index 0000000000..dfceee2f15 Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/uint64_array.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/uint64_array_empty.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/uint64_array_empty.ref new file mode 100644 index 0000000000..f2632fbe0d Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/uint64_array_empty.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/uint64_array_single.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/uint64_array_single.ref new file mode 100644 index 0000000000..a739e51bd7 Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/uint64_array_single.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/uint8.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/uint8.ref new file mode 100644 index 0000000000..d051cccfe9 Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/uint8.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/uint8_array.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/uint8_array.ref new file mode 100644 index 0000000000..23418e847d Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/uint8_array.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/uint8_array_empty.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/uint8_array_empty.ref new file mode 100644 index 0000000000..a69446d734 Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/uint8_array_empty.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/refs/uint8_array_single.ref b/tests/zfs-tests/tests/functional/libnvpair/refs/uint8_array_single.ref new file mode 100644 index 0000000000..cf69f38a69 Binary files /dev/null and b/tests/zfs-tests/tests/functional/libnvpair/refs/uint8_array_single.ref differ diff --git a/tests/zfs-tests/tests/functional/libnvpair/setup.ksh b/tests/zfs-tests/tests/functional/libnvpair/setup.ksh new file mode 100644 index 0000000000..c8a0bcd27b --- /dev/null +++ b/tests/zfs-tests/tests/functional/libnvpair/setup.ksh @@ -0,0 +1,37 @@ +#!/bin/ksh -p +# +# CDDL HEADER START +# +# The contents of this file are subject to the terms of the +# Common Development and Distribution License (the "License"). +# You may not use this file except in compliance with the License. +# +# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE +# or https://opensource.org/licenses/CDDL-1.0. +# See the License for the specific language governing permissions +# and limitations under the License. +# +# When distributing Covered Code, include this CDDL HEADER in each +# file and include the License file at usr/src/OPENSOLARIS.LICENSE. +# If applicable, add the following below this CDDL HEADER, with the +# fields enclosed by brackets "[]" replaced with your own identifying +# information: Portions Copyright [yyyy] [name of copyright owner] +# +# CDDL HEADER END +# + +# +# Copyright 2022 SRI International +# +# This software was developed by SRI International, the University of +# Cambridge Computer Laboratory (Department of Computer Science and +# Technology), and Capabilities Limited under Defense Advanced Research +# Projects Agency (DARPA) Contract No. HR001122C0110 ("ETC"). +# + +. $STF_SUITE/include/libtest.shlib + +# No setup required, test is self contained other than committed reference +# files. +log_pass +