int
lzc_change_key(const char *fsname, uint64_t crypt_cmd, nvlist_t *props,
uint8_t *wkeydata, uint_t wkeylen)
{
int error;
nvlist_t *ioc_args = fnvlist_alloc();
nvlist_t *hidden_args = NULL;
fnvlist_add_uint64(ioc_args, "crypt_cmd", crypt_cmd);
if (wkeydata != NULL) {
hidden_args = fnvlist_alloc();
fnvlist_add_uint8_array(hidden_args, "wkeydata", wkeydata,
wkeylen);
fnvlist_add_nvlist(ioc_args, ZPOOL_HIDDEN_ARGS, hidden_args);
}
if (props != NULL)
fnvlist_add_nvlist(ioc_args, "props", props);
error = lzc_ioctl(ZFS_IOC_CHANGE_KEY, fsname, ioc_args, NULL);
nvlist_free(hidden_args);
nvlist_free(ioc_args);
return (error);
}
static void
test_load_key(const char *dataset)
{
nvlist_t *required = fnvlist_alloc();
nvlist_t *optional = fnvlist_alloc();
nvlist_t *hidden = fnvlist_alloc();
uint8_t keydata[WRAPPING_KEY_LEN] = {0};
fnvlist_add_uint8_array(hidden, "wkeydata", keydata, sizeof (keydata));
fnvlist_add_nvlist(required, "hidden_args", hidden);
fnvlist_add_boolean(optional, "noop");
IOC_INPUT_TEST(ZFS_IOC_LOAD_KEY, dataset, required, optional, EINVAL);
nvlist_free(hidden);
nvlist_free(optional);
nvlist_free(required);
}
/*
* Performs key management functions
*
* crypto_cmd should be a value from zfs_ioc_crypto_cmd_t. If the command
* specifies to load or change a wrapping key, the key should be specified in
* the hidden_args nvlist so that it is not logged
*/
int
lzc_load_key(const char *fsname, boolean_t noop, uint8_t *wkeydata,
uint_t wkeylen)
{
int error;
nvlist_t *ioc_args;
nvlist_t *hidden_args;
if (wkeydata == NULL)
return (EINVAL);
ioc_args = fnvlist_alloc();
hidden_args = fnvlist_alloc();
fnvlist_add_uint8_array(hidden_args, "wkeydata", wkeydata, wkeylen);
fnvlist_add_nvlist(ioc_args, ZPOOL_HIDDEN_ARGS, hidden_args);
if (noop)
fnvlist_add_boolean(ioc_args, "noop");
error = lzc_ioctl(ZFS_IOC_LOAD_KEY, fsname, ioc_args, NULL);
nvlist_free(hidden_args);
nvlist_free(ioc_args);
return (error);
}
int
lzc_create(const char *fsname, enum lzc_dataset_type type, nvlist_t *props,
uint8_t *wkeydata, uint_t wkeylen)
{
int error;
nvlist_t *hidden_args = NULL;
nvlist_t *args = fnvlist_alloc();
fnvlist_add_int32(args, "type", (dmu_objset_type_t)type);
if (props != NULL)
fnvlist_add_nvlist(args, "props", props);
if (wkeydata != NULL) {
hidden_args = fnvlist_alloc();
fnvlist_add_uint8_array(hidden_args, "wkeydata", wkeydata,
wkeylen);
fnvlist_add_nvlist(args, ZPOOL_HIDDEN_ARGS, hidden_args);
}
error = lzc_ioctl(ZFS_IOC_CREATE, fsname, args, NULL);
nvlist_free(hidden_args);
nvlist_free(args);
return (error);
}
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,
uint8_t *wkeydata, uint_t wkeylen, 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;
}
/*
* Raw receives, resumable receives, and receives that include a
* wrapping key all use the new interface.
*/
if (resumable || raw || wkeydata != NULL) {
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 (wkeydata != NULL) {
/*
* wkeydata must be placed in the special
* ZPOOL_HIDDEN_ARGS nvlist so that it
* will not be printed to the zpool history.
*/
nvlist_t *hidden_args = fnvlist_alloc();
fnvlist_add_uint8_array(hidden_args, "wkeydata",
wkeydata, wkeylen);
fnvlist_add_nvlist(innvl, ZPOOL_HIDDEN_ARGS,
hidden_args);
nvlist_free(hidden_args);
}
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);
}
