static void
test_recv_new(const char *dataset, int fd)
{
dmu_replay_record_t drr = { 0 };
nvlist_t *required = fnvlist_alloc();
nvlist_t *optional = fnvlist_alloc();
nvlist_t *props = fnvlist_alloc();
char snapshot[MAXNAMELEN + 32];
ssize_t count;
int cleanup_fd = open(ZFS_DEV, O_RDWR);
(void) snprintf(snapshot, sizeof (snapshot), "%s@replicant", dataset);
count = pread(fd, &drr, sizeof (drr), 0);
if (count != sizeof (drr)) {
(void) fprintf(stderr, "could not read stream: %s\n",
strerror(errno));
}
fnvlist_add_string(required, "snapname", snapshot);
fnvlist_add_byte_array(required, "begin_record", (uchar_t *)&drr,
sizeof (drr));
fnvlist_add_int32(required, "input_fd", fd);
fnvlist_add_string(props, "org.openzfs:launch", "September 17th, 2013");
fnvlist_add_nvlist(optional, "localprops", props);
fnvlist_add_boolean(optional, "force");
fnvlist_add_int32(optional, "cleanup_fd", cleanup_fd);
/*
* TODO - Resumable receive is harder to set up. So we currently
* ignore testing for one.
*/
#if 0
fnvlist_add_nvlist(optional, "props", recvdprops);
fnvlist_add_string(optional, "origin", origin);
fnvlist_add_boolean(optional, "resumable");
fnvlist_add_uint64(optional, "action_handle", *action_handle);
#endif
IOC_INPUT_TEST(ZFS_IOC_RECV_NEW, dataset, required, optional, EBADE);
nvlist_free(props);
nvlist_free(optional);
nvlist_free(required);
(void) close(cleanup_fd);
}
static void
run_tests(void)
{
const char *key = "key";
/* Note: maximum nvlist key length is 32KB */
int len = 1024 * 31;
char *bigstring = malloc(len);
for (int i = 0; i < len; i++)
bigstring[i] = 'a' + i % 26;
bigstring[len - 1] = '\0';
nvl = fnvlist_alloc();
fnvlist_add_boolean(nvl, key);
test("boolean", B_TRUE, B_FALSE);
fnvlist_add_boolean_value(nvl, key, B_TRUE);
test("boolean_value", B_FALSE, B_FALSE);
fnvlist_add_byte(nvl, key, 1);
test("byte", B_FALSE, B_FALSE);
fnvlist_add_int8(nvl, key, 1);
test("int8", B_FALSE, B_FALSE);
fnvlist_add_uint8(nvl, key, 1);
test("uint8", B_FALSE, B_FALSE);
fnvlist_add_int16(nvl, key, 1);
test("int16", B_FALSE, B_FALSE);
fnvlist_add_uint16(nvl, key, 1);
test("uint16", B_FALSE, B_FALSE);
fnvlist_add_int32(nvl, key, 1);
test("int32", B_FALSE, B_FALSE);
fnvlist_add_uint32(nvl, key, 1);
test("uint32", B_FALSE, B_FALSE);
fnvlist_add_int64(nvl, key, 1);
test("int64", B_TRUE, B_TRUE);
fnvlist_add_uint64(nvl, key, 1);
test("uint64", B_FALSE, B_FALSE);
fnvlist_add_string(nvl, key, "1");
test("string", B_TRUE, B_TRUE);
{
nvlist_t *val = fnvlist_alloc();
fnvlist_add_string(val, "subkey", "subvalue");
fnvlist_add_nvlist(nvl, key, val);
fnvlist_free(val);
test("nvlist", B_TRUE, B_TRUE);
}
{
boolean_t val[2] = { B_FALSE, B_TRUE };
fnvlist_add_boolean_array(nvl, key, val, 2);
test("boolean_array", B_FALSE, B_FALSE);
}
{
uchar_t val[2] = { 0, 1 };
fnvlist_add_byte_array(nvl, key, val, 2);
test("byte_array", B_FALSE, B_FALSE);
}
{
int8_t val[2] = { 0, 1 };
fnvlist_add_int8_array(nvl, key, val, 2);
test("int8_array", B_FALSE, B_FALSE);
}
{
uint8_t val[2] = { 0, 1 };
fnvlist_add_uint8_array(nvl, key, val, 2);
test("uint8_array", B_FALSE, B_FALSE);
}
{
int16_t val[2] = { 0, 1 };
fnvlist_add_int16_array(nvl, key, val, 2);
test("int16_array", B_FALSE, B_FALSE);
}
{
uint16_t val[2] = { 0, 1 };
fnvlist_add_uint16_array(nvl, key, val, 2);
test("uint16_array", B_FALSE, B_FALSE);
}
{
int32_t val[2] = { 0, 1 };
fnvlist_add_int32_array(nvl, key, val, 2);
test("int32_array", B_FALSE, B_FALSE);
}
{
uint32_t val[2] = { 0, 1 };
fnvlist_add_uint32_array(nvl, key, val, 2);
test("uint32_array", B_FALSE, B_FALSE);
}
{
int64_t val[2] = { 0, 1 };
fnvlist_add_int64_array(nvl, key, val, 2);
test("int64_array", B_TRUE, B_FALSE);
}
{
uint64_t val[2] = { 0, 1 };
fnvlist_add_uint64_array(nvl, key, val, 2);
test("uint64_array", B_FALSE, B_FALSE);
}
{
char *const val[2] = { "0", "1" };
fnvlist_add_string_array(nvl, key, val, 2);
test("string_array", B_TRUE, B_FALSE);
}
{
nvlist_t *val[2];
val[0] = fnvlist_alloc();
fnvlist_add_string(val[0], "subkey", "subvalue");
val[1] = fnvlist_alloc();
fnvlist_add_string(val[1], "subkey2", "subvalue2");
fnvlist_add_nvlist_array(nvl, key, val, 2);
fnvlist_free(val[0]);
fnvlist_free(val[1]);
test("nvlist_array", B_FALSE, B_FALSE);
}
{
fnvlist_add_string(nvl, bigstring, "1");
test("large_key", B_TRUE, B_TRUE);
}
{
fnvlist_add_string(nvl, key, bigstring);
test("large_value", B_TRUE, B_TRUE);
}
{
for (int i = 0; i < 1024; i++) {
char buf[32];
(void) snprintf(buf, sizeof (buf), "key-%u", i);
fnvlist_add_int64(nvl, buf, i);
}
test("many_keys", B_TRUE, B_TRUE);
}
#ifndef __sparc__
{
for (int i = 0; i < 10; i++) {
nvlist_t *newval = fnvlist_alloc();
fnvlist_add_nvlist(newval, "key", nvl);
fnvlist_free(nvl);
nvl = newval;
}
test("deeply_nested_pos", B_TRUE, B_TRUE);
}
{
for (int i = 0; i < 90; i++) {
nvlist_t *newval = fnvlist_alloc();
fnvlist_add_nvlist(newval, "key", nvl);
fnvlist_free(nvl);
nvl = newval;
}
test("deeply_nested_neg", B_FALSE, B_FALSE);
}
#endif
free(bigstring);
fnvlist_free(nvl);
}
/*
* Linux adds ZFS_IOC_RECV_NEW for resumable and raw streams and preserves the
* legacy ZFS_IOC_RECV user/kernel interface. The new interface supports all
* stream options but is currently only used for resumable streams. This way
* updated user space utilities will interoperate with older kernel modules.
*
* Non-Linux OpenZFS platforms have opted to modify the legacy interface.
*/
static int
recv_impl(const char *snapname, nvlist_t *recvdprops, nvlist_t *localprops,
const char *origin, boolean_t force, boolean_t resumable, boolean_t raw,
int input_fd, const dmu_replay_record_t *begin_record, int cleanup_fd,
uint64_t *read_bytes, uint64_t *errflags, uint64_t *action_handle,
nvlist_t **errors)
{
dmu_replay_record_t drr;
char fsname[MAXPATHLEN];
char *atp;
int error;
ASSERT3S(g_refcount, >, 0);
VERIFY3S(g_fd, !=, -1);
/* Set 'fsname' to the name of containing filesystem */
(void) strlcpy(fsname, snapname, sizeof (fsname));
atp = strchr(fsname, '@');
if (atp == NULL)
return (EINVAL);
*atp = '\0';
/* If the fs does not exist, try its parent. */
if (!lzc_exists(fsname)) {
char *slashp = strrchr(fsname, '/');
if (slashp == NULL)
return (ENOENT);
*slashp = '\0';
}
/*
* The begin_record is normally a non-byteswapped BEGIN record.
* For resumable streams it may be set to any non-byteswapped
* dmu_replay_record_t.
*/
if (begin_record == NULL) {
error = recv_read(input_fd, &drr, sizeof (drr));
if (error != 0)
return (error);
} else {
drr = *begin_record;
}
if (resumable || raw) {
nvlist_t *outnvl = NULL;
nvlist_t *innvl = fnvlist_alloc();
fnvlist_add_string(innvl, "snapname", snapname);
if (recvdprops != NULL)
fnvlist_add_nvlist(innvl, "props", recvdprops);
if (localprops != NULL)
fnvlist_add_nvlist(innvl, "localprops", localprops);
if (origin != NULL && strlen(origin))
fnvlist_add_string(innvl, "origin", origin);
fnvlist_add_byte_array(innvl, "begin_record",
(uchar_t *)&drr, sizeof (drr));
fnvlist_add_int32(innvl, "input_fd", input_fd);
if (force)
fnvlist_add_boolean(innvl, "force");
if (resumable)
fnvlist_add_boolean(innvl, "resumable");
if (cleanup_fd >= 0)
fnvlist_add_int32(innvl, "cleanup_fd", cleanup_fd);
if (action_handle != NULL)
fnvlist_add_uint64(innvl, "action_handle",
*action_handle);
error = lzc_ioctl(ZFS_IOC_RECV_NEW, fsname, innvl, &outnvl);
if (error == 0 && read_bytes != NULL)
error = nvlist_lookup_uint64(outnvl, "read_bytes",
read_bytes);
if (error == 0 && errflags != NULL)
error = nvlist_lookup_uint64(outnvl, "error_flags",
errflags);
if (error == 0 && action_handle != NULL)
error = nvlist_lookup_uint64(outnvl, "action_handle",
action_handle);
if (error == 0 && errors != NULL) {
nvlist_t *nvl;
error = nvlist_lookup_nvlist(outnvl, "errors", &nvl);
if (error == 0)
*errors = fnvlist_dup(nvl);
}
fnvlist_free(innvl);
fnvlist_free(outnvl);
} else {
zfs_cmd_t zc = {"\0"};
char *packed = NULL;
size_t size;
ASSERT3S(g_refcount, >, 0);
(void) strlcpy(zc.zc_name, fsname, sizeof (zc.zc_value));
(void) strlcpy(zc.zc_value, snapname, sizeof (zc.zc_value));
if (recvdprops != NULL) {
packed = fnvlist_pack(recvdprops, &size);
zc.zc_nvlist_src = (uint64_t)(uintptr_t)packed;
zc.zc_nvlist_src_size = size;
}
if (localprops != NULL) {
packed = fnvlist_pack(localprops, &size);
zc.zc_nvlist_conf = (uint64_t)(uintptr_t)packed;
zc.zc_nvlist_conf_size = size;
}
if (origin != NULL)
(void) strlcpy(zc.zc_string, origin,
sizeof (zc.zc_string));
ASSERT3S(drr.drr_type, ==, DRR_BEGIN);
zc.zc_begin_record = drr.drr_u.drr_begin;
zc.zc_guid = force;
zc.zc_cookie = input_fd;
zc.zc_cleanup_fd = -1;
zc.zc_action_handle = 0;
if (cleanup_fd >= 0)
zc.zc_cleanup_fd = cleanup_fd;
if (action_handle != NULL)
zc.zc_action_handle = *action_handle;
zc.zc_nvlist_dst_size = 128 * 1024;
zc.zc_nvlist_dst = (uint64_t)(uintptr_t)
malloc(zc.zc_nvlist_dst_size);
error = ioctl(g_fd, ZFS_IOC_RECV, &zc);
if (error != 0) {
error = errno;
} else {
if (read_bytes != NULL)
*read_bytes = zc.zc_cookie;
if (errflags != NULL)
*errflags = zc.zc_obj;
if (action_handle != NULL)
*action_handle = zc.zc_action_handle;
if (errors != NULL)
VERIFY0(nvlist_unpack(
(void *)(uintptr_t)zc.zc_nvlist_dst,
zc.zc_nvlist_dst_size, errors, KM_SLEEP));
}
if (packed != NULL)
fnvlist_pack_free(packed, size);
free((void *)(uintptr_t)zc.zc_nvlist_dst);
}
return (error);
}