自学教程：C++ zfs_prop_get_int函数代码示例

/* * Returns true if the given dataset is mountable, false otherwise.  Returns the * mountpoint in 'buf'. */static boolean_tzfs_is_mountable(zfs_handle_t *zhp, char *buf, size_t buflen,    zprop_source_t *source){	char sourceloc[ZFS_MAXNAMELEN];	zprop_source_t sourcetype;	if (!zfs_prop_valid_for_type(ZFS_PROP_MOUNTPOINT, zhp->zfs_type))		return (B_FALSE);	verify(zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, buf, buflen,	    &sourcetype, sourceloc, sizeof (sourceloc), B_FALSE) == 0);	if (strcmp(buf, ZFS_MOUNTPOINT_NONE) == 0 ||	    strcmp(buf, ZFS_MOUNTPOINT_LEGACY) == 0)		return (B_FALSE);	if (zfs_prop_get_int(zhp, ZFS_PROP_CANMOUNT) == ZFS_CANMOUNT_OFF)		return (B_FALSE);	if (zfs_prop_get_int(zhp, ZFS_PROP_ZONED) &&	    getzoneid() == GLOBAL_ZONEID)		return (B_FALSE);    if (zfs_prop_get_int(zhp, ZFS_PROP_KEYSTATUS) ==        ZFS_CRYPT_KEY_UNAVAILABLE)        return (B_FALSE);	if (source)		*source = sourcetype;	return (B_TRUE);}

static intmount_cb(zfs_handle_t *zhp, void *data){	get_all_cb_t *cbp = data;    if (zfs_prop_get_int(zhp, ZFS_PROP_KEYSTATUS) ==        ZFS_CRYPT_KEY_UNAVAILABLE) {        if (zfs_key_load(zhp, B_FALSE, B_FALSE, B_TRUE) != 0) {            zfs_close(zhp);            return (0);        }    }	if (!(zfs_get_type(zhp) & ZFS_TYPE_FILESYSTEM)) {		zfs_close(zhp);		return (0);	}	if (zfs_prop_get_int(zhp, ZFS_PROP_CANMOUNT) == ZFS_CANMOUNT_NOAUTO) {		zfs_close(zhp);		return (0);	}	libzfs_add_handle(cbp, zhp);	if (zfs_iter_filesystems(zhp, mount_cb, cbp) != 0) {		zfs_close(zhp);		return (-1);	}	return (0);}

static intmount_cb(zfs_handle_t *zhp, void *data){	get_all_cb_t *cbp = data;	if (!(zfs_get_type(zhp) & ZFS_TYPE_FILESYSTEM)) {		zfs_close(zhp);		return (0);	}	if (zfs_prop_get_int(zhp, ZFS_PROP_CANMOUNT) == ZFS_CANMOUNT_NOAUTO) {		zfs_close(zhp);		return (0);	}	/*	 * If this filesystem is inconsistent and has a receive resume	 * token, we can not mount it.	 */	if (zfs_prop_get_int(zhp, ZFS_PROP_INCONSISTENT) &&	    zfs_prop_get(zhp, ZFS_PROP_RECEIVE_RESUME_TOKEN,	    NULL, 0, NULL, NULL, 0, B_TRUE) == 0) {		zfs_close(zhp);		return (0);	}	libzfs_add_handle(cbp, zhp);	if (zfs_iter_filesystems(zhp, mount_cb, cbp) != 0) {		zfs_close(zhp);		return (-1);	}	return (0);}

/* ARGSUSED */static intzfs_compare(const void *larg, const void *rarg, void *unused){	zfs_handle_t *l = ((zfs_node_t *)larg)->zn_handle;	zfs_handle_t *r = ((zfs_node_t *)rarg)->zn_handle;	const char *lname = zfs_get_name(l);	const char *rname = zfs_get_name(r);	char *lat, *rat;	uint64_t lcreate, rcreate;	int ret;	lat = (char *)strchr(lname, '@');	rat = (char *)strchr(rname, '@');	if (lat != NULL)		*lat = '/0';	if (rat != NULL)		*rat = '/0';	ret = strcmp(lname, rname);	if (ret == 0) {		/*		 * If we're comparing a dataset to one of its snapshots, we		 * always make the full dataset first.		 */		if (lat == NULL) {			ret = -1;		} else if (rat == NULL) {			ret = 1;		} else {			/*			 * If we have two snapshots from the same dataset, then			 * we want to sort them according to creation time.  We			 * use the hidden CREATETXG property to get an absolute			 * ordering of snapshots.			 */			lcreate = zfs_prop_get_int(l, ZFS_PROP_CREATETXG);			rcreate = zfs_prop_get_int(r, ZFS_PROP_CREATETXG);			/*			 * Both lcreate and rcreate being 0 means we don't have			 * properties and we should compare full name.			 */			if (lcreate == 0 && rcreate == 0)				ret = strcmp(lat + 1, rat + 1);			else if (lcreate < rcreate)				ret = -1;			else if (lcreate > rcreate)				ret = 1;		}	}	if (lat != NULL)		*lat = '@';	if (rat != NULL)		*rat = '@';	return (ret);}

intzfs_key_unload(zfs_handle_t *zhp, boolean_t force){	zfs_cmd_t zc = { { 0 }};	int ret = 0;	int terrno;	int type = zfs_get_type(zhp);	char errbuf[1024];	(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,	    "cannot unload key for '%s'"), zfs_get_name(zhp));	if (zfs_prop_get_int(zhp, ZFS_PROP_ENCRYPTION) == ZIO_CRYPT_OFF) {		zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,		    "no key to unload when encryption=off."));		return (zfs_error(zhp->zfs_hdl, EZFS_KEYERR, errbuf));	}	if (zfs_prop_get_int(zhp, ZFS_PROP_KEYSTATUS) !=	    ZFS_CRYPT_KEY_AVAILABLE) {		zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,		    "key not present."));		return (zfs_error(zhp->zfs_hdl, EZFS_KEYERR, errbuf));	}	/*	 * We need to be sure that all the data has been written to	 * disk before we unload the key so we first have to attempt	 * an unmount, if that fails we don't continue with the key unload	 * and instead return the error from zfs_umount.	 */	if (type == ZFS_TYPE_FILESYSTEM) {		if (zfs_is_mounted(zhp, NULL)) {			ret = zfs_unmountall(zhp, force ? MS_FORCE : 0);			if (ret) {				zfs_error_aux(zhp->zfs_hdl,				    dgettext(TEXT_DOMAIN,				    "failed to unload key: unmount failed"));				return (zfs_error(zhp->zfs_hdl,				    EZFS_KEYERR, errbuf));			}		}	}	(void) strlcpy(zc.zc_name, zfs_get_name(zhp), sizeof (zc.zc_name));	errno = 0;	ret = zfs_ioctl(zhp->zfs_hdl, ZFS_IOC_CRYPTO_KEY_UNLOAD, &zc);	terrno = errno;	if (ret != 0) {		zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,		    "failed to unload key: %s"), strerror(terrno));		errno = terrno;	/* make sure it is the zfs_ioctl errno */		return (zfs_error(zhp->zfs_hdl, EZFS_KEYERR, errbuf));	}	zfs_refresh_properties(zhp);	return (0);}

intzfs_crypto_clone_check(libzfs_handle_t *hdl, zfs_handle_t *origin_zhp,    char *parent_name, nvlist_t *props){	int ret;	char errbuf[1024];	zfs_handle_t *pzhp = NULL;	uint64_t pcrypt, ocrypt;	(void) snprintf(errbuf, sizeof (errbuf),	    dgettext(TEXT_DOMAIN, "Encryption clone error"));	/*	 * No encryption properties should be specified. They will all be	 * inherited from the origin dataset.	 */	if (nvlist_exists(props, zfs_prop_to_name(ZFS_PROP_KEYFORMAT)) ||	    nvlist_exists(props, zfs_prop_to_name(ZFS_PROP_KEYLOCATION)) ||	    nvlist_exists(props, zfs_prop_to_name(ZFS_PROP_ENCRYPTION)) ||	    nvlist_exists(props, zfs_prop_to_name(ZFS_PROP_PBKDF2_ITERS))) {		ret = EINVAL;		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,		    "Encryption properties must inherit from origin dataset."));		goto out;	}	/* get a reference to parent dataset, should never be NULL */	pzhp = make_dataset_handle(hdl, parent_name);	if (pzhp == NULL) {		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,		    "Failed to lookup parent."));		return (ENOENT);	}	/* Lookup parent's crypt */	pcrypt = zfs_prop_get_int(pzhp, ZFS_PROP_ENCRYPTION);	ocrypt = zfs_prop_get_int(origin_zhp, ZFS_PROP_ENCRYPTION);	/* all children of encrypted parents must be encrypted */	if (pcrypt != ZIO_CRYPT_OFF && ocrypt == ZIO_CRYPT_OFF) {		ret = EINVAL;		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,		    "Cannot create unencrypted clone as a child "		    "of encrypted parent."));		goto out;	}	zfs_close(pzhp);	return (0);out:	if (pzhp != NULL)		zfs_close(pzhp);	return (ret);}

/* * Function:	be_get_ss_data * Description: Helper function used by be_add_children_callback to collect *		the dataset related information that will be returned by *		be_list. * Parameters: *		zhp - Handle to the zfs snapshot whose information we're *		      collecting. *		name - The name of the snapshot we're processing. *		shapshot - A pointer to the be_snapshot_list structure *			   we're filling in. *		node - The node structure that this snapshot belongs to. * Returns: *		BE_SUCCESS - Success *		be_errno_t - Failure * Scope: *		Private */static intbe_get_ss_data(	zfs_handle_t *zfshp,	char *name,	be_snapshot_list_t *snapshot,	be_node_list_t *node){	nvlist_t	*propval = NULL;	nvlist_t	*userprops = NULL;	char		*prop_str = NULL;	int		err = 0;	if (zfshp == NULL || name == NULL || snapshot == NULL || node == NULL) {		be_print_err(gettext("be_get_ss_data: invalid arguments, "		    "can not be NULL/n"));		return (BE_ERR_INVAL);	}	errno = 0;	snapshot->be_snapshot_name = strdup(name);	if ((err = errno) != 0) {		be_print_err(gettext("be_get_ss_data: failed to copy name/n"));		return (errno_to_be_err(err));	}	snapshot->be_snapshot_creation = (time_t)zfs_prop_get_int(zfshp,	    ZFS_PROP_CREATION);	/*	 * Try to get this snapshot's cleanup policy from its	 * user properties first.  If not there, use default	 * cleanup policy.	 */	if ((userprops = zfs_get_user_props(zfshp)) != NULL &&	    nvlist_lookup_nvlist(userprops, BE_POLICY_PROPERTY,	    &propval) == 0 && nvlist_lookup_string(propval,	    ZPROP_VALUE, &prop_str) == 0) {		snapshot->be_snapshot_type =		    strdup(prop_str);	} else {		snapshot->be_snapshot_type =		    strdup(be_default_policy());	}	snapshot->be_snapshot_space_used = zfs_prop_get_int(zfshp,	    ZFS_PROP_USED);	node->be_node_num_snapshots++;	return (BE_SUCCESS);}

/* * Get the snapshot creation time */intchkpnt_creationtime_bypattern(char *volname, char *pattern, time_t *tp){    char chk_name[PATH_MAX];    zfs_handle_t *zhp;    char *p;    if (!volname || !*volname)        return (-1);    /* Should also return -1 if checkpoint not enabled */    /* Remove the leading slash */    p = volname;    while (*p == '/')        p++;    (void) strlcpy(chk_name, p, PATH_MAX);    (void) strlcat(chk_name, "@", PATH_MAX);    (void) strlcat(chk_name, pattern, PATH_MAX);    (void) mutex_lock(&zlib_mtx);    if ((zhp = zfs_open(zlibh, chk_name, ZFS_TYPE_DATASET)) == NULL) {        NDMP_LOG(LOG_DEBUG, "chkpnt_creationtime: open %s failed",                 chk_name);        (void) mutex_unlock(&zlib_mtx);        return (-1);    }    *tp = zfs_prop_get_int(zhp, ZFS_PROP_CREATION);    zfs_close(zhp);    (void) mutex_unlock(&zlib_mtx);    return (0);}

static intmount_cb(zfs_handle_t *zhp, void *data){	mount_cbdata_t *cbp = data;	if (!(zfs_get_type(zhp) & (ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME))) {		zfs_close(zhp);		return (0);	}	if (zfs_prop_get_int(zhp, ZFS_PROP_CANMOUNT) == ZFS_CANMOUNT_NOAUTO) {		zfs_close(zhp);		return (0);	}	if (cbp->cb_alloc == cbp->cb_used) {		void *ptr;		if ((ptr = zfs_realloc(zhp->zfs_hdl,		    cbp->cb_datasets, cbp->cb_alloc * sizeof (void *),		    cbp->cb_alloc * 2 * sizeof (void *))) == NULL)			return (-1);		cbp->cb_datasets = ptr;		cbp->cb_alloc *= 2;	}	cbp->cb_datasets[cbp->cb_used++] = zhp;	return (zfs_iter_filesystems(zhp, mount_cb, cbp));}

intzfs_crypto_get_encryption_root(zfs_handle_t *zhp, boolean_t *is_encroot,    char *buf){	int ret;	char prop_encroot[MAXNAMELEN];	/* if the dataset isn't encrypted, just return */	if (zfs_prop_get_int(zhp, ZFS_PROP_ENCRYPTION) == ZIO_CRYPT_OFF) {		*is_encroot = B_FALSE;		if (buf != NULL)			buf[0] = '/0';		return (0);	}	ret = zfs_prop_get(zhp, ZFS_PROP_ENCRYPTION_ROOT, prop_encroot,	    sizeof (prop_encroot), NULL, NULL, 0, B_TRUE);	if (ret != 0) {		*is_encroot = B_FALSE;		if (buf != NULL)			buf[0] = '/0';		return (ret);	}	*is_encroot = strcmp(prop_encroot, zfs_get_name(zhp)) == 0;	if (buf != NULL)		strcpy(buf, prop_encroot);	return (0);}

static intload_keys_cb(zfs_handle_t *zhp, void *arg){	int ret;	boolean_t is_encroot;	loadkey_cbdata_t *cb = arg;	uint64_t keystatus = zfs_prop_get_int(zhp, ZFS_PROP_KEYSTATUS);	/* only attempt to load keys for encryption roots */	ret = zfs_crypto_get_encryption_root(zhp, &is_encroot, NULL);	if (ret != 0 || !is_encroot)		goto out;	/* don't attempt to load already loaded keys */	if (keystatus == ZFS_KEYSTATUS_AVAILABLE)		goto out;	/* Attempt to load the key. Record status in cb. */	cb->cb_numattempted++;	ret = zfs_crypto_load_key(zhp, B_FALSE, NULL);	if (ret)		cb->cb_numfailed++;out:	(void) zfs_iter_filesystems(zhp, load_keys_cb, cb);	zfs_close(zhp);	/* always return 0, since this function is best effort */	return (0);}

boolean_tzfs_is_encrypted(zfs_handle_t *zhp){	int crypt = zfs_prop_get_int(zhp, ZFS_PROP_ENCRYPTION);	return (!(crypt == ZIO_CRYPT_OFF));}

static intzfs_snapshot_compare(const void *larg, const void *rarg){	zfs_handle_t *l = ((zfs_node_t *)larg)->zn_handle;	zfs_handle_t *r = ((zfs_node_t *)rarg)->zn_handle;	uint64_t lcreate, rcreate;	/*	 * Sort them according to creation time.  We use the hidden	 * CREATETXG property to get an absolute ordering of snapshots.	 */	lcreate = zfs_prop_get_int(l, ZFS_PROP_CREATETXG);	rcreate = zfs_prop_get_int(r, ZFS_PROP_CREATETXG);	return (AVL_CMP(lcreate, rcreate));}

static intzfs_crypto_verify_rewrap_nvlist(zfs_handle_t *zhp, nvlist_t *props,    nvlist_t **props_out, char *errbuf){	int ret = 0;	nvpair_t *elem = NULL;	zfs_prop_t prop;	nvlist_t *new_props = NULL;	new_props = fnvlist_alloc();	/*	 * loop through all provided properties, we should only have	 * keyformat, keylocation and pbkdf2iters. The actual validation of	 * values is done by zfs_valid_proplist().	 */	while ((elem = nvlist_next_nvpair(props, elem)) != NULL) {		const char *propname = nvpair_name(elem);		prop = zfs_name_to_prop(propname);		switch (prop) {		case ZFS_PROP_PBKDF2_ITERS:		case ZFS_PROP_KEYFORMAT:		case ZFS_PROP_KEYLOCATION:			break;		default:			ret = EINVAL;			zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,			    "Only keyformat, keylocation and pbkdf2iters may "			    "be set with this command."));			goto error;		}	}	new_props = zfs_valid_proplist(zhp->zfs_hdl, zhp->zfs_type, props,	    zfs_prop_get_int(zhp, ZFS_PROP_ZONED), NULL, zhp->zpool_hdl,	    B_TRUE, errbuf);	if (new_props == NULL) {		ret = EINVAL;		goto error;	}	*props_out = new_props;	return (0);error:	nvlist_free(new_props);	*props_out = NULL;	return (ret);}

static intmount_cb(zfs_handle_t *zhp, void *data){    get_all_cb_t *cbp = data;    if (!(zfs_get_type(zhp) & ZFS_TYPE_FILESYSTEM)) {        zfs_close(zhp);        return (0);    }    if (zfs_prop_get_int(zhp, ZFS_PROP_CANMOUNT) == ZFS_CANMOUNT_NOAUTO) {        zfs_close(zhp);        return (0);    }    libzfs_add_handle(cbp, zhp);    if (zfs_iter_filesystems(zhp, mount_cb, cbp) != 0) {        zfs_close(zhp);        return (-1);    }    return (0);}

static intchange_one(zfs_handle_t *zhp, void *data){	prop_changelist_t *clp = data;	char property[ZFS_MAXPROPLEN];	char where[64];	prop_changenode_t *cn;	zfs_source_t sourcetype;	/*	 * We only want to unmount/unshare those filesystems that may inherit	 * from the target filesystem.  If we find any filesystem with a	 * locally set mountpoint, we ignore any children since changing the	 * property will not affect them.  If this is a rename, we iterate	 * over all children regardless, since we need them unmounted in	 * order to do the rename.  Also, if this is a volume and we're doing	 * a rename, then always add it to the changelist.	 */	if (!(ZFS_IS_VOLUME(zhp) && clp->cl_realprop == ZFS_PROP_NAME) &&	    zfs_prop_get(zhp, clp->cl_prop, property,	    sizeof (property), &sourcetype, where, sizeof (where),	    B_FALSE) != 0) {		zfs_close(zhp);		return (0);	}	if (clp->cl_alldependents || clp->cl_allchildren ||	    sourcetype == ZFS_SRC_DEFAULT || sourcetype == ZFS_SRC_INHERITED) {		if ((cn = zfs_alloc(zfs_get_handle(zhp),		    sizeof (prop_changenode_t))) == NULL) {			zfs_close(zhp);			return (-1);		}		cn->cn_handle = zhp;		cn->cn_mounted = zfs_is_mounted(zhp, NULL);		cn->cn_shared = zfs_is_shared(zhp);#ifndef __APPLE__		cn->cn_zoned = zfs_prop_get_int(zhp, ZFS_PROP_ZONED);		/* Indicate if any child is exported to a local zone. */		if (getzoneid() == GLOBAL_ZONEID && cn->cn_zoned)			clp->cl_haszonedchild = B_TRUE;#endif /*!__APPLE__*/		uu_list_node_init(cn, &cn->cn_listnode, clp->cl_pool);		if (clp->cl_sorted) {			uu_list_index_t idx;			(void) uu_list_find(clp->cl_list, cn, NULL,			    &idx);			uu_list_insert(clp->cl_list, cn, idx);		} else {			ASSERT(!clp->cl_alldependents);			verify(uu_list_insert_before(clp->cl_list,			    uu_list_first(clp->cl_list), cn) == 0);		}		if (!clp->cl_alldependents)			return (zfs_iter_children(zhp, change_one, data));	} else {		zfs_close(zhp);	}	return (0);}

/* * Share the given filesystem according to the options in the specified * protocol specific properties (sharenfs, sharesmb).  We rely * on "libshare" to the dirty work for us. */static intzfs_share_proto(zfs_handle_t *zhp, zfs_share_proto_t *proto){	char mountpoint[ZFS_MAXPROPLEN];	char shareopts[ZFS_MAXPROPLEN];	char sourcestr[ZFS_MAXPROPLEN];	libzfs_handle_t *hdl = zhp->zfs_hdl;	sa_share_t share;	zfs_share_proto_t *curr_proto;	zprop_source_t sourcetype;	int ret;	if (!zfs_is_mountable(zhp, mountpoint, sizeof (mountpoint), NULL))		return (0);	if ((ret = zfs_init_libshare(hdl, SA_INIT_SHARE_API)) != SA_OK) {		(void) zfs_error_fmt(hdl, EZFS_SHARENFSFAILED,		    dgettext(TEXT_DOMAIN, "cannot share '%s': %s"),		    zfs_get_name(zhp), sa_errorstr(ret));		return (-1);	}	for (curr_proto = proto; *curr_proto != PROTO_END; curr_proto++) {		/*		 * Return success if there are no share options.		 */		if (zfs_prop_get(zhp, proto_table[*curr_proto].p_prop,		    shareopts, sizeof (shareopts), &sourcetype, sourcestr,		    ZFS_MAXPROPLEN, B_FALSE) != 0 ||		    strcmp(shareopts, "off") == 0)			continue;		/*		 * If the 'zoned' property is set, then zfs_is_mountable()		 * will have already bailed out if we are in the global zone.		 * But local zones cannot be NFS servers, so we ignore it for		 * local zones as well.		 */		if (zfs_prop_get_int(zhp, ZFS_PROP_ZONED))			continue;		share = sa_find_share(hdl->libzfs_sharehdl, mountpoint);		if (share == NULL) {			/*			 * This may be a new file system that was just			 * created so isn't in the internal cache			 * (second time through). Rather than			 * reloading the entire configuration, we can			 * assume ZFS has done the checking and it is			 * safe to add this to the internal			 * configuration.			 */			if (sa_zfs_process_share(hdl->libzfs_sharehdl,			    NULL, NULL, mountpoint,			    proto_table[*curr_proto].p_name, sourcetype,			    shareopts, sourcestr, zhp->zfs_name) != SA_OK) {				(void) zfs_error_fmt(hdl,				    proto_table[*curr_proto].p_share_err,				    dgettext(TEXT_DOMAIN, "cannot share '%s'"),				    zfs_get_name(zhp));				return (-1);			}			hdl->libzfs_shareflags |= ZFSSHARE_MISS;			share = sa_find_share(hdl->libzfs_sharehdl,			    mountpoint);		}		if (share != NULL) {			int err;			err = sa_enable_share(share,			    proto_table[*curr_proto].p_name);			if (err != SA_OK) {				(void) zfs_error_fmt(hdl,				    proto_table[*curr_proto].p_share_err,				    dgettext(TEXT_DOMAIN, "cannot share '%s'"),				    zfs_get_name(zhp));				return (-1);			}		} else {			(void) zfs_error_fmt(hdl,			    proto_table[*curr_proto].p_share_err,			    dgettext(TEXT_DOMAIN, "cannot share '%s'"),			    zfs_get_name(zhp));			return (-1);		}	}	return (0);}

/* * Mount the given filesystem. */intzfs_mount(zfs_handle_t *zhp, const char *options, int flags){	struct stat buf;	char mountpoint[ZFS_MAXPROPLEN];	char mntopts[MNT_LINE_MAX];	libzfs_handle_t *hdl = zhp->zfs_hdl;	int remount = 0, rc;	if (options == NULL) {		(void) strlcpy(mntopts, MNTOPT_DEFAULTS, sizeof (mntopts));	} else {		(void) strlcpy(mntopts, options, sizeof (mntopts));	}	if (strstr(mntopts, MNTOPT_REMOUNT) != NULL)		remount = 1;	/*	 * If the pool is imported read-only then all mounts must be read-only	 */	if (zpool_get_prop_int(zhp->zpool_hdl, ZPOOL_PROP_READONLY, NULL))		(void) strlcat(mntopts, "," MNTOPT_RO, sizeof (mntopts));    /*     * Load encryption key if required and not already present.     * Don't need to check ZFS_PROP_ENCRYPTION because encrypted     * datasets have keystatus of ZFS_CRYPT_KEY_NONE.     */    fprintf(stderr, "zfs_mount: mount, keystatus is %d/r/n",            zfs_prop_get_int(zhp, ZFS_PROP_KEYSTATUS));    if (zfs_prop_get_int(zhp, ZFS_PROP_KEYSTATUS) ==        ZFS_CRYPT_KEY_UNAVAILABLE) {        fprintf(stderr, "loading KEY/r/n");        (void )zfs_key_load(zhp, B_FALSE, B_FALSE, B_FALSE);    }	/*	 * Append default mount options which apply to the mount point.	 * This is done because under Linux (unlike Solaris) multiple mount	 * points may reference a single super block.  This means that just	 * given a super block there is no back reference to update the per	 * mount point options.	 */	rc = zfs_add_options(zhp, mntopts, sizeof (mntopts));	if (rc) {		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,		    "default options unavailable"));		return (zfs_error_fmt(hdl, EZFS_MOUNTFAILED,		    dgettext(TEXT_DOMAIN, "cannot mount '%s'"),		    mountpoint));	}	/*	 * Append zfsutil option so the mount helper allow the mount	 */	strlcat(mntopts, "," MNTOPT_ZFSUTIL, sizeof (mntopts));	if (!zfs_is_mountable(zhp, mountpoint, sizeof (mountpoint), NULL))		return (0);	/* Create the directory if it doesn't already exist */	if (lstat(mountpoint, &buf) != 0) {		if (mkdirp(mountpoint, 0755) != 0) {			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,			    "failed to create mountpoint"));			return (zfs_error_fmt(hdl, EZFS_MOUNTFAILED,			    dgettext(TEXT_DOMAIN, "cannot mount '%s'"),			    mountpoint));		}	}	/*	 * Determine if the mountpoint is empty.  If so, refuse to perform the	 * mount.  We don't perform this check if 'remount' is	 * specified or if overlay option(-O) is given	 */	if ((flags & MS_OVERLAY) == 0 && !remount &&	    !dir_is_empty(mountpoint)) {		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,		    "directory is not empty"));		return (zfs_error_fmt(hdl, EZFS_MOUNTFAILED,		    dgettext(TEXT_DOMAIN, "cannot mount '%s'"), mountpoint));	}	/* perform the mount */	rc = do_mount(zfs_get_name(zhp), mountpoint, mntopts);	if (rc) {		/*		 * Generic errors are nasty, but there are just way too many		 * from mount(), and they're well-understood.  We pick a few		 * common ones to improve upon.		 */		if (rc == EBUSY) {			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,			    "mountpoint or dataset is busy"));		} else if (rc == EPERM) {//.........这里部分代码省略.........

intzfs_crypto_load_key(zfs_handle_t *zhp, boolean_t noop, char *alt_keylocation){	int ret, attempts = 0;	char errbuf[1024];	uint64_t keystatus, iters = 0, salt = 0;	uint64_t keyformat = ZFS_KEYFORMAT_NONE;	char prop_keylocation[MAXNAMELEN];	char prop_encroot[MAXNAMELEN];	char *keylocation = NULL;	uint8_t *key_material = NULL, *key_data = NULL;	size_t key_material_len;	boolean_t is_encroot, can_retry = B_FALSE, correctible = B_FALSE;	(void) snprintf(errbuf, sizeof (errbuf),	    dgettext(TEXT_DOMAIN, "Key load error"));	/* check that encryption is enabled for the pool */	if (!encryption_feature_is_enabled(zhp->zpool_hdl)) {		zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,		    "Encryption feature not enabled."));		ret = EINVAL;		goto error;	}	/* Fetch the keyformat. Check that the dataset is encrypted. */	keyformat = zfs_prop_get_int(zhp, ZFS_PROP_KEYFORMAT);	if (keyformat == ZFS_KEYFORMAT_NONE) {		zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,		    "'%s' is not encrypted."), zfs_get_name(zhp));		ret = EINVAL;		goto error;	}	/*	 * Fetch the key location. Check that we are working with an	 * encryption root.	 */	ret = zfs_crypto_get_encryption_root(zhp, &is_encroot, prop_encroot);	if (ret != 0) {		zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,		    "Failed to get encryption root for '%s'."),		    zfs_get_name(zhp));		goto error;	} else if (!is_encroot) {		zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,		    "Keys must be loaded for encryption root of '%s' (%s)."),		    zfs_get_name(zhp), prop_encroot);		ret = EINVAL;		goto error;	}	/*	 * if the caller has elected to override the keylocation property	 * use that instead	 */	if (alt_keylocation != NULL) {		keylocation = alt_keylocation;	} else {		ret = zfs_prop_get(zhp, ZFS_PROP_KEYLOCATION, prop_keylocation,		    sizeof (prop_keylocation), NULL, NULL, 0, B_TRUE);		if (ret != 0) {			zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,			    "Failed to get keylocation for '%s'."),			    zfs_get_name(zhp));			goto error;		}		keylocation = prop_keylocation;	}	/* check that the key is unloaded unless this is a noop */	if (!noop) {		keystatus = zfs_prop_get_int(zhp, ZFS_PROP_KEYSTATUS);		if (keystatus == ZFS_KEYSTATUS_AVAILABLE) {			zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,			    "Key already loaded for '%s'."), zfs_get_name(zhp));			ret = EEXIST;			goto error;		}	}	/* passphrase formats require a salt and pbkdf2_iters property */	if (keyformat == ZFS_KEYFORMAT_PASSPHRASE) {		salt = zfs_prop_get_int(zhp, ZFS_PROP_PBKDF2_SALT);		iters = zfs_prop_get_int(zhp, ZFS_PROP_PBKDF2_ITERS);	}try_again:	/* fetching and deriving the key are correctible errors. set the flag */	correctible = B_TRUE;	/* get key material from key format and location */	ret = get_key_material(zhp->zfs_hdl, B_FALSE, B_FALSE, keyformat,	    keylocation, zfs_get_name(zhp), &key_material, &key_material_len,	    &can_retry);	if (ret != 0)		goto error;	/* derive a key from the key material *///.........这里部分代码省略.........

intzpool_enable_datasets(zpool_handle_t *zhp, const char *mntopts, int flags){	get_all_cb_t cb = { 0 };	libzfs_handle_t *hdl = zhp->zpool_hdl;	zfs_handle_t *zfsp;	int i, ret = -1;	int *good;	/*	 * Gather all non-snap datasets within the pool.	 */	if ((zfsp = zfs_open(hdl, zhp->zpool_name, ZFS_TYPE_DATASET)) == NULL)		goto out;	libzfs_add_handle(&cb, zfsp);    /*     * If the top level dataset is encrypted load its keys.     */    if (zfs_prop_get_int(zfsp, ZFS_PROP_KEYSTATUS) ==        ZFS_CRYPT_KEY_UNAVAILABLE) {        (void) zfs_key_load(zfsp, B_FALSE, B_FALSE, B_TRUE);    }	if (zfs_iter_filesystems(zfsp, mount_cb, &cb) != 0)		goto out;	/*	 * Sort the datasets by mountpoint.	 */	qsort(cb.cb_handles, cb.cb_used, sizeof (void *),	    libzfs_dataset_cmp);	/*	 * And mount all the datasets, keeping track of which ones	 * succeeded or failed.	 */	if ((good = zfs_alloc(zhp->zpool_hdl,	    cb.cb_used * sizeof (int))) == NULL)		goto out;	ret = 0;	for (i = 0; i < cb.cb_used; i++) {		if (zfs_mount(cb.cb_handles[i], mntopts, flags) != 0)			ret = -1;		else			good[i] = 1;	}	/*	 * Then share all the ones that need to be shared. This needs	 * to be a separate pass in order to avoid excessive reloading	 * of the configuration. Good should never be NULL since	 * zfs_alloc is supposed to exit if memory isn't available.	 */	for (i = 0; i < cb.cb_used; i++) {		if (good[i] && zfs_share(cb.cb_handles[i]) != 0)			ret = -1;	}	free(good);out:	for (i = 0; i < cb.cb_used; i++)		zfs_close(cb.cb_handles[i]);	free(cb.cb_handles);	return (ret);}

intzfs_crypto_unload_key(zfs_handle_t *zhp){	int ret;	char errbuf[1024];	char prop_encroot[MAXNAMELEN];	uint64_t keystatus, keyformat;	boolean_t is_encroot;	(void) snprintf(errbuf, sizeof (errbuf),	    dgettext(TEXT_DOMAIN, "Key unload error"));	/* check that encryption is enabled for the pool */	if (!encryption_feature_is_enabled(zhp->zpool_hdl)) {		zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,		    "Encryption feature not enabled."));		ret = EINVAL;		goto error;	}	/* Fetch the keyformat. Check that the dataset is encrypted. */	keyformat = zfs_prop_get_int(zhp, ZFS_PROP_KEYFORMAT);	if (keyformat == ZFS_KEYFORMAT_NONE) {		zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,		    "'%s' is not encrypted."), zfs_get_name(zhp));		ret = EINVAL;		goto error;	}	/*	 * Fetch the key location. Check that we are working with an	 * encryption root.	 */	ret = zfs_crypto_get_encryption_root(zhp, &is_encroot, prop_encroot);	if (ret != 0) {		zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,		    "Failed to get encryption root for '%s'."),		    zfs_get_name(zhp));		goto error;	} else if (!is_encroot) {		zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,		    "Keys must be unloaded for encryption root of '%s' (%s)."),		    zfs_get_name(zhp), prop_encroot);		ret = EINVAL;		goto error;	}	/* check that the key is loaded */	keystatus = zfs_prop_get_int(zhp, ZFS_PROP_KEYSTATUS);	if (keystatus == ZFS_KEYSTATUS_UNAVAILABLE) {		zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,		    "Key already unloaded for '%s'."), zfs_get_name(zhp));		ret = ENOENT;		goto error;	}	/* call the ioctl */	ret = lzc_unload_key(zhp->zfs_name);	if (ret != 0) {		switch (ret) {		case EPERM:			zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,			    "Permission denied."));			break;		case ENOENT:			zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,			    "Key already unloaded for '%s'."),			    zfs_get_name(zhp));			break;		case EBUSY:			zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,			    "'%s' is busy."), zfs_get_name(zhp));			break;		}		zfs_error(zhp->zfs_hdl, EZFS_CRYPTOFAILED, errbuf);	}	return (ret);error:	zfs_error(zhp->zfs_hdl, EZFS_CRYPTOFAILED, errbuf);	return (ret);}

intzfs_crypto_rewrap(zfs_handle_t *zhp, nvlist_t *raw_props, boolean_t inheritkey){	int ret;	char errbuf[1024];	boolean_t is_encroot;	nvlist_t *props = NULL;	uint8_t *wkeydata = NULL;	uint_t wkeylen = 0;	dcp_cmd_t cmd = (inheritkey) ? DCP_CMD_INHERIT : DCP_CMD_NEW_KEY;	uint64_t crypt, pcrypt, keystatus, pkeystatus;	uint64_t keyformat = ZFS_KEYFORMAT_NONE;	zfs_handle_t *pzhp = NULL;	char *keylocation = NULL;	char origin_name[MAXNAMELEN];	char prop_keylocation[MAXNAMELEN];	char parent_name[ZFS_MAX_DATASET_NAME_LEN];	(void) snprintf(errbuf, sizeof (errbuf),	    dgettext(TEXT_DOMAIN, "Key change error"));	/* check that encryption is enabled for the pool */	if (!encryption_feature_is_enabled(zhp->zpool_hdl)) {		zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,		    "Encryption feature not enabled."));		ret = EINVAL;		goto error;	}	/* get crypt from dataset */	crypt = zfs_prop_get_int(zhp, ZFS_PROP_ENCRYPTION);	if (crypt == ZIO_CRYPT_OFF) {		zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,		    "Dataset not encrypted."));		ret = EINVAL;		goto error;	}	/* get the encryption root of the dataset */	ret = zfs_crypto_get_encryption_root(zhp, &is_encroot, NULL);	if (ret != 0) {		zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,		    "Failed to get encryption root for '%s'."),		    zfs_get_name(zhp));		goto error;	}	/* Clones use their origin's key and cannot rewrap it */	ret = zfs_prop_get(zhp, ZFS_PROP_ORIGIN, origin_name,	    sizeof (origin_name), NULL, NULL, 0, B_TRUE);	if (ret == 0 && strcmp(origin_name, "") != 0) {		zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,		    "Keys cannot be changed on clones."));		ret = EINVAL;		goto error;	}	/*	 * If the user wants to use the inheritkey variant of this function	 * we don't need to collect any crypto arguments.	 */	if (!inheritkey) {		/* validate the provided properties */		ret = zfs_crypto_verify_rewrap_nvlist(zhp, raw_props, &props,		    errbuf);		if (ret != 0)			goto error;		/*		 * Load keyformat and keylocation from the nvlist. Fetch from		 * the dataset properties if not specified.		 */		(void) nvlist_lookup_uint64(props,		    zfs_prop_to_name(ZFS_PROP_KEYFORMAT), &keyformat);		(void) nvlist_lookup_string(props,		    zfs_prop_to_name(ZFS_PROP_KEYLOCATION), &keylocation);		if (is_encroot) {			/*			 * If this is already an ecryption root, just keep			 * any properties not set by the user.			 */			if (keyformat == ZFS_KEYFORMAT_NONE) {				keyformat = zfs_prop_get_int(zhp,				    ZFS_PROP_KEYFORMAT);				ret = nvlist_add_uint64(props,				    zfs_prop_to_name(ZFS_PROP_KEYFORMAT),				    keyformat);				if (ret != 0) {					zfs_error_aux(zhp->zfs_hdl,					    dgettext(TEXT_DOMAIN, "Failed to "					    "get existing keyformat "					    "property."));					goto error;				}			}			if (keylocation == NULL) {				ret = zfs_prop_get(zhp, ZFS_PROP_KEYLOCATION,				    prop_keylocation, sizeof (prop_keylocation),//.........这里部分代码省略.........

/* * Mount the given filesystem. */intzfs_mount(zfs_handle_t *zhp, const char *options, int flags){    struct stat buf;    char mountpoint[ZFS_MAXPROPLEN];    char mntopts[MNT_LINE_MAX];    libzfs_handle_t *hdl = zhp->zfs_hdl;    if (options == NULL)        mntopts[0] = '/0';    else        (void) strlcpy(mntopts, options, sizeof (mntopts));    /*     * If the pool is imported read-only then all mounts must be read-only     */    if (zpool_get_prop_int(zhp->zpool_hdl, ZPOOL_PROP_READONLY, NULL))        flags |= MS_RDONLY;    if (!zfs_is_mountable(zhp, mountpoint, sizeof (mountpoint), NULL))        return (0);    /* Create the directory if it doesn't already exist */    if (lstat(mountpoint, &buf) != 0) {        if (mkdirp(mountpoint, 0755) != 0) {            zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,                                        "failed to create mountpoint"));            return (zfs_error_fmt(hdl, EZFS_MOUNTFAILED,                                  dgettext(TEXT_DOMAIN, "cannot mount '%s'"),                                  mountpoint));        }    }    /*     * Determine if the mountpoint is empty.  If so, refuse to perform the     * mount.  We don't perform this check if MS_OVERLAY is specified, which     * would defeat the point.  We also avoid this check if 'remount' is     * specified.     */    if ((flags & MS_OVERLAY) == 0 &&            strstr(mntopts, MNTOPT_REMOUNT) == NULL &&            !dir_is_empty(mountpoint)) {        zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,                                    "directory is not empty"));        return (zfs_error_fmt(hdl, EZFS_MOUNTFAILED,                              dgettext(TEXT_DOMAIN, "cannot mount '%s'"), mountpoint));    }    /* perform the mount */    if (mount(zfs_get_name(zhp), mountpoint, MS_OPTIONSTR | flags,              MNTTYPE_ZFS, NULL, 0, mntopts, sizeof (mntopts)) != 0) {        /*         * Generic errors are nasty, but there are just way too many         * from mount(), and they're well-understood.  We pick a few         * common ones to improve upon.         */        if (errno == EBUSY) {            zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,                                        "mountpoint or dataset is busy"));        } else if (errno == EPERM) {            zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,                                        "Insufficient privileges"));        } else if (errno == ENOTSUP) {            char buf[256];            int spa_version;            VERIFY(zfs_spa_version(zhp, &spa_version) == 0);            (void) snprintf(buf, sizeof (buf),                            dgettext(TEXT_DOMAIN, "Can't mount a version %lld "                                     "file system on a version %d pool. Pool must be"                                     " upgraded to mount this file system."),                            (u_longlong_t)zfs_prop_get_int(zhp,                                    ZFS_PROP_VERSION), spa_version);            zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, buf));        } else {            zfs_error_aux(hdl, strerror(errno));        }        return (zfs_error_fmt(hdl, EZFS_MOUNTFAILED,                              dgettext(TEXT_DOMAIN, "cannot mount '%s'"),                              zhp->zfs_name));    }    /* add the mounted entry into our cache */    libzfs_mnttab_add(hdl, zfs_get_name(zhp), mountpoint,                      mntopts);    return (0);}

//.........这里部分代码省略.........	clp->cl_flags = flags;	if (clp->cl_list == NULL) {		assert(uu_error() == UU_ERROR_NO_MEMORY);		(void) zfs_error(zhp->zfs_hdl, EZFS_NOMEM, "internal error");		changelist_free(clp);		return (NULL);	}	/*	 * If this is a rename or the 'zoned' property, we pretend we're	 * changing the mountpoint and flag it so we can catch all children in	 * change_one().	 *	 * Flag cl_alldependents to catch all children plus the dependents	 * (clones) that are not in the hierarchy.	 */	if (prop == ZFS_PROP_NAME) {		clp->cl_prop = ZFS_PROP_MOUNTPOINT;		clp->cl_alldependents = B_TRUE;	} else if (prop == ZFS_PROP_ZONED) {		clp->cl_prop = ZFS_PROP_MOUNTPOINT;		clp->cl_allchildren = B_TRUE;	} else if (prop == ZFS_PROP_CANMOUNT) {		clp->cl_prop = ZFS_PROP_MOUNTPOINT;	} else if (prop == ZFS_PROP_VOLSIZE) {		clp->cl_prop = ZFS_PROP_MOUNTPOINT;	} else if (prop == ZFS_PROP_VERSION) {		clp->cl_prop = ZFS_PROP_MOUNTPOINT;	} else {		clp->cl_prop = prop;	}	clp->cl_realprop = prop;	if (clp->cl_prop != ZFS_PROP_MOUNTPOINT &&	    clp->cl_prop != ZFS_PROP_SHARENFS &&	    clp->cl_prop != ZFS_PROP_SHAREISCSI)		return (clp);	if (clp->cl_alldependents) {		if (zfs_iter_dependents(zhp, B_TRUE, change_one, clp) != 0) {			changelist_free(clp);			return (NULL);		}	} else if (zfs_iter_children(zhp, change_one, clp) != 0) {		changelist_free(clp);		return (NULL);	}	/*	 * We have to re-open ourselves because we auto-close all the handles	 * and can't tell the difference.	 */	if ((temp = zfs_open(zhp->zfs_hdl, zfs_get_name(zhp),	    ZFS_TYPE_ANY)) == NULL) {		changelist_free(clp);		return (NULL);	}	/*	 * Always add ourself to the list.  We add ourselves to the end so that	 * we're the last to be unmounted.	 */	if ((cn = zfs_alloc(zhp->zfs_hdl,	    sizeof (prop_changenode_t))) == NULL) {		zfs_close(temp);		changelist_free(clp);		return (NULL);	}	cn->cn_handle = temp;	cn->cn_mounted = zfs_is_mounted(temp, NULL);	cn->cn_shared = zfs_is_shared(temp);#ifndef	__APPLE__	cn->cn_zoned = zfs_prop_get_int(zhp, ZFS_PROP_ZONED);#endif	/*!__APPLE__*/	uu_list_node_init(cn, &cn->cn_listnode, clp->cl_pool);	if (clp->cl_sorted) {		uu_list_index_t idx;		(void) uu_list_find(clp->cl_list, cn, NULL, &idx);		uu_list_insert(clp->cl_list, cn, idx);	} else {		verify(uu_list_insert_after(clp->cl_list,		    uu_list_last(clp->cl_list), cn) == 0);	}	/*	 * If the mountpoint property was previously 'legacy', or 'none',	 * record it as the behavior of changelist_postfix() will be different.	 */	if ((clp->cl_prop == ZFS_PROP_MOUNTPOINT) &&	    (zfs_prop_get(zhp, prop, property, sizeof (property),	    NULL, NULL, 0, B_FALSE) == 0 &&	    (strcmp(property, "legacy") == 0 || strcmp(property, "none") == 0)))		clp->cl_waslegacy = B_TRUE;	return (clp);}

intzfs_crypto_create(libzfs_handle_t *hdl, char *parent_name, nvlist_t *props,    nvlist_t *pool_props, uint8_t **wkeydata_out, uint_t *wkeylen_out){	int ret;	char errbuf[1024];	uint64_t crypt = ZIO_CRYPT_INHERIT, pcrypt = ZIO_CRYPT_INHERIT;	uint64_t keyformat = ZFS_KEYFORMAT_NONE;	char *keylocation = NULL;	zfs_handle_t *pzhp = NULL;	uint8_t *wkeydata = NULL;	uint_t wkeylen = 0;	boolean_t local_crypt = B_TRUE;	(void) snprintf(errbuf, sizeof (errbuf),	    dgettext(TEXT_DOMAIN, "Encryption create error"));	/* lookup crypt from props */	ret = nvlist_lookup_uint64(props,	    zfs_prop_to_name(ZFS_PROP_ENCRYPTION), &crypt);	if (ret != 0)		local_crypt = B_FALSE;	/* lookup key location and format from props */	(void) nvlist_lookup_uint64(props,	    zfs_prop_to_name(ZFS_PROP_KEYFORMAT), &keyformat);	(void) nvlist_lookup_string(props,	    zfs_prop_to_name(ZFS_PROP_KEYLOCATION), &keylocation);	if (parent_name != NULL) {		/* get a reference to parent dataset */		pzhp = make_dataset_handle(hdl, parent_name);		if (pzhp == NULL) {			ret = ENOENT;			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,			    "Failed to lookup parent."));			goto out;		}		/* Lookup parent's crypt */		pcrypt = zfs_prop_get_int(pzhp, ZFS_PROP_ENCRYPTION);		/* Params require the encryption feature */		if (!encryption_feature_is_enabled(pzhp->zpool_hdl)) {			if (proplist_has_encryption_props(props)) {				ret = EINVAL;				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,				    "Encryption feature not enabled."));				goto out;			}			ret = 0;			goto out;		}	} else {		/*		 * special case for root dataset where encryption feature		 * feature won't be on disk yet		 */		if (!nvlist_exists(pool_props, "[email
C++ zfs_strdup函数代码示例
C++ zfs_prop_get函数代码示例