static int zfs_do_list_ioctl(zfs_handle_t *zhp, int arg, zfs_cmd_t *zc) { int rc; uint64_t orig_cookie; orig_cookie = zc->zc_cookie; top: (void) strlcpy(zc->zc_name, zhp->zfs_name, sizeof (zc->zc_name)); rc = ioctl(zhp->zfs_hdl->libzfs_fd, arg, zc); if (rc == -1) { switch (errno) { case ENOMEM: /* expand nvlist memory and try again */ if (zcmd_expand_dst_nvlist(zhp->zfs_hdl, zc) != 0) { zcmd_free_nvlists(zc); return (-1); } zc->zc_cookie = orig_cookie; goto top; /* * An errno value of ESRCH indicates normal completion. * If ENOENT is returned, then the underlying dataset * has been removed since we obtained the handle. */ case ESRCH: case ENOENT: rc = 1; break; default: rc = zfs_standard_error(zhp->zfs_hdl, errno, dgettext(TEXT_DOMAIN, "cannot iterate filesystems")); break; } } return (rc); }
/* * Loads the pool namespace, or re-loads it if the cache has changed. */ static int namespace_reload(libzfs_handle_t *hdl) { nvlist_t *config; config_node_t *cn; nvpair_t *elem; zfs_cmd_t zc = { "\0", "\0", "\0", "\0", 0 }; void *cookie; if (hdl->libzfs_ns_gen == 0) { /* * This is the first time we've accessed the configuration * cache. Initialize the AVL tree and then fall through to the * common code. */ if ((hdl->libzfs_ns_avlpool = uu_avl_pool_create("config_pool", sizeof (config_node_t), offsetof(config_node_t, cn_avl), config_node_compare, UU_DEFAULT)) == NULL) return (no_memory(hdl)); if ((hdl->libzfs_ns_avl = uu_avl_create(hdl->libzfs_ns_avlpool, NULL, UU_DEFAULT)) == NULL) return (no_memory(hdl)); } if (zcmd_alloc_dst_nvlist(hdl, &zc, 0) != 0) return (-1); for (;;) { zc.zc_cookie = hdl->libzfs_ns_gen; //if (ioctl(hdl->libzfs_fd, ZFS_IOC_POOL_CONFIGS, &zc) != 0) { if (zfs_ioctl(hdl, ZFS_IOC_POOL_CONFIGS, &zc) != 0) { switch (errno) { case EEXIST: /* * The namespace hasn't changed. */ zcmd_free_nvlists(&zc); return (0); case ENOMEM: if (zcmd_expand_dst_nvlist(hdl, &zc) != 0) { zcmd_free_nvlists(&zc); return (-1); } break; default: zcmd_free_nvlists(&zc); return (zfs_standard_error(hdl, errno, dgettext(TEXT_DOMAIN, "failed to read " "pool configuration"))); } } else { hdl->libzfs_ns_gen = zc.zc_cookie; break; } } if (zcmd_read_dst_nvlist(hdl, &zc, &config) != 0) { zcmd_free_nvlists(&zc); return (-1); } zcmd_free_nvlists(&zc); /* * Clear out any existing configuration information. */ cookie = NULL; while ((cn = uu_avl_teardown(hdl->libzfs_ns_avl, &cookie)) != NULL) { nvlist_free(cn->cn_config); free(cn->cn_name); free(cn); } elem = NULL; while ((elem = nvlist_next_nvpair(config, elem)) != NULL) { nvlist_t *child; uu_avl_index_t where; if ((cn = zfs_alloc(hdl, sizeof (config_node_t))) == NULL) { nvlist_free(config); return (-1); } if ((cn->cn_name = zfs_strdup(hdl, nvpair_name(elem))) == NULL) { free(cn); nvlist_free(config); return (-1); } verify(nvpair_value_nvlist(elem, &child) == 0); if (nvlist_dup(child, &cn->cn_config, 0) != 0) { free(cn->cn_name); free(cn); nvlist_free(config); return (no_memory(hdl)); } verify(uu_avl_find(hdl->libzfs_ns_avl, cn, NULL, &where) == NULL); uu_avl_insert(hdl->libzfs_ns_avl, cn, where); } nvlist_free(config); return (0); }
int zfs_key_change(zfs_handle_t *zhp, boolean_t recursing, nvlist_t *props) { char errbuf[1024]; int ret; zfs_cmd_t zc = { { 0 } }; char keysource[ZFS_MAXNAMELEN]; uint64_t crypt; zprop_source_t propsrctype = ZPROP_SRC_NONE; char propsrc[ZFS_MAXNAMELEN] = { 0 }; (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN, "cannot change wrapping key for '%s'"), zfs_get_name(zhp)); crypt = zfs_prop_get_int(zhp, ZFS_PROP_ENCRYPTION); if (crypt == ZIO_CRYPT_OFF) { zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN, "cannot change key when encryption=off")); goto error; } switch (zfs_prop_get_int(zhp, ZFS_PROP_KEYSTATUS)) { case ZFS_CRYPT_KEY_NONE: zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN, "inconsistent state encryption enabled but " "key not defined.")); return (zfs_error(zhp->zfs_hdl, EZFS_KEYERR, errbuf)); case ZFS_CRYPT_KEY_UNAVAILABLE: zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN, "load existing key first: 'zfs key -l <dataset>'.")); goto error; } (void) zfs_prop_get(zhp, ZFS_PROP_KEYSOURCE, keysource, ZFS_MAXNAMELEN, &propsrctype, propsrc, ZFS_MAXNAMELEN, B_TRUE); if (!(propsrctype & ZPROP_SRC_LOCAL || propsrctype & ZPROP_SRC_RECEIVED)) { if (recursing) return (0); zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN, "keysource property not local, change key on '%s'."), propsrc); goto error; } zhp->zfs_hdl->libzfs_crypt.zc_is_key_change = B_TRUE; /* * The only thing we currently expect in props is a keysource * if we have props without keysource then that isn't valid. */ if (props != NULL) { char *nkeysource; ret = nvlist_lookup_string(props, zfs_prop_to_name(ZFS_PROP_KEYSOURCE), (char **)&nkeysource); if (ret != 0) { zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN, "invalid props for key change; expected " "%s property missing."), zfs_prop_to_name(ZFS_PROP_KEYSOURCE)); goto error; } (void) strlcpy(keysource, nkeysource, sizeof (keysource)); } (void) strlcpy(zc.zc_name, zfs_get_name(zhp), sizeof (zc.zc_name)); zc.zc_crypto.zic_crypt = crypt; if (!zfs_can_prompt_if_needed(keysource)) { zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN, "unable to prompt for new wrapping key.")); errno = ENOTTY; goto error; } ret = key_hdl_to_zc(zhp->zfs_hdl, zhp, keysource, crypt, &zc, ZFS_CRYPTO_KEY_CHANGE); if (props != NULL) { if (zcmd_write_src_nvlist(zhp->zfs_hdl, &zc, props) != 0) goto error; } if (ret == 0) { /* Send change to kernel */ ret = zfs_ioctl(zhp->zfs_hdl, ZFS_IOC_CRYPTO_KEY_CHANGE, &zc); zcmd_free_nvlists(&zc); if (ret != 0) { return (zfs_standard_error(zhp->zfs_hdl, errno, errbuf)); } zfs_refresh_properties(zhp); return (ret); } error: zcmd_free_nvlists(&zc); return (zfs_error(zhp->zfs_hdl, EZFS_KEYERR, errbuf)); }