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

/* * Unshare a filesystem by mountpoint. */static intunshare_one(libzfs_handle_t *hdl, const char *name, const char *mountpoint,    zfs_share_proto_t proto){#ifdef illumos	sa_share_t share;	int err;	char *mntpt;	/*	 * Mountpoint could get trashed if libshare calls getmntany	 * which it does during API initialization, so strdup the	 * value.	 */	mntpt = zfs_strdup(hdl, mountpoint);	/* make sure libshare initialized */	if ((err = zfs_init_libshare(hdl, SA_INIT_SHARE_API)) != SA_OK) {		free(mntpt);	/* don't need the copy anymore */		return (zfs_error_fmt(hdl, EZFS_SHARENFSFAILED,		    dgettext(TEXT_DOMAIN, "cannot unshare '%s': %s"),		    name, _sa_errorstr(err)));	}	share = zfs_sa_find_share(hdl->libzfs_sharehdl, mntpt);	free(mntpt);	/* don't need the copy anymore */	if (share != NULL) {		err = zfs_sa_disable_share(share, proto_table[proto].p_name);		if (err != SA_OK) {			return (zfs_error_fmt(hdl, EZFS_UNSHARENFSFAILED,			    dgettext(TEXT_DOMAIN, "cannot unshare '%s': %s"),			    name, _sa_errorstr(err)));		}	} else {		return (zfs_error_fmt(hdl, EZFS_UNSHARENFSFAILED,		    dgettext(TEXT_DOMAIN, "cannot unshare '%s': not found"),		    name));	}#else	char buf[MAXPATHLEN];	FILE *fp;	int err;	if (proto != PROTO_NFS) {		fprintf(stderr, "No SMB support in FreeBSD yet./n");		return (EOPNOTSUPP);	}	err = fsunshare(ZFS_EXPORTS_PATH, mountpoint);	if (err != 0) {		zfs_error_aux(hdl, "%s", strerror(err));		return (zfs_error_fmt(hdl, EZFS_UNSHARENFSFAILED,		    dgettext(TEXT_DOMAIN,		    "cannot unshare '%s'"), name));	}#endif	return (0);}

intzfs_unshare_iscsi(zfs_handle_t *zhp){	const char *dataset = zfs_get_name(zhp);	libzfs_handle_t *hdl = zhp->zfs_hdl;	/*	 * Return if the volume is not shared	 */	if (zfs_is_shared_iscsi(zhp) != SHARED_ISCSI)		return (0);	/*	 * If this fails with ENODEV it indicates that zvol wasn't shared so	 * we should return success in that case.	 */	if (iscsitgt_zfs_unshare == NULL ||	    (iscsitgt_zfs_unshare(dataset) != 0 && errno != ENODEV)) {		if (errno == EPERM)			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,			    "Insufficient privileges to unshare iscsi"));		return (zfs_error_fmt(hdl, EZFS_UNSHAREISCSIFAILED,		    dgettext(TEXT_DOMAIN, "cannot unshare '%s'"), dataset));	}	return (0);}

intzfs_share_iscsi(zfs_handle_t *zhp){	char shareopts[ZFS_MAXPROPLEN];	const char *dataset = zhp->zfs_name;	libzfs_handle_t *hdl = zhp->zfs_hdl;	/*	 * Return success if there are no share options.	 */	if (zfs_prop_get(zhp, ZFS_PROP_SHAREISCSI, shareopts,	    sizeof (shareopts), NULL, NULL, 0, B_FALSE) != 0 ||	    strcmp(shareopts, "off") == 0)		return (0);	if (iscsitgt_zfs_share == NULL || iscsitgt_zfs_share(dataset) != 0) {		int error = EZFS_SHAREISCSIFAILED;		/*		 * If service isn't availabele and EPERM was		 * returned then use special error.		 */		if (iscsitgt_svc_online && errno == EPERM &&		    (iscsitgt_svc_online() != 0))			error = EZFS_ISCSISVCUNAVAIL;		return (zfs_error_fmt(hdl, error,		    dgettext(TEXT_DOMAIN, "cannot share '%s'"), dataset));	}	return (0);}

/* * Unmount a single filesystem. */static intunmount_one(libzfs_handle_t *hdl, const char *mountpoint, int flags){	ASSERT((flags & ~MS_FORCE) == 0);	char *cmd;	int res_print;	if(flags & MS_FORCE)		res_print = asprintf(&cmd, "umount -l %s", mountpoint);	else		res_print = asprintf(&cmd, "umount %s", mountpoint);	if(res_print == -1) {		zfs_error_aux(hdl, strerror(ENOMEM));		goto error;	}	int ret = system(cmd);	free(cmd);	if (ret != 0) {		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "umount failed"));		goto error;	}	return (0);error:	return (zfs_error_fmt(hdl, EZFS_UMOUNTFAILED,	    dgettext(TEXT_DOMAIN, "cannot unmount '%s'"),	    mountpoint));}

/* * Unshare a filesystem by mountpoint. */static intunshare_one(libzfs_handle_t *hdl, const char *name, const char *mountpoint,    zfs_share_proto_t proto){#ifndef __APPLE__	sa_share_t share;	int err;#endif	char *mntpt;	/*	 * Mountpoint could get trashed if libshare calls getmntany	 * which id does during API initialization, so strdup the	 * value.	 */	mntpt = zfs_strdup(hdl, mountpoint);#ifndef __APPLE__	/* make sure libshare initialized */	if ((err = zfs_init_libshare(hdl, SA_INIT_SHARE_API)) != SA_OK) {		free(mntpt);	/* don't need the copy anymore */		return (zfs_error_fmt(hdl, EZFS_SHARENFSFAILED,		    dgettext(TEXT_DOMAIN, "cannot unshare '%s': %s"),		    name, _sa_errorstr(err)));	}	share = zfs_sa_find_share(hdl->libzfs_sharehdl, mntpt);#endif	free(mntpt);	/* don't need the copy anymore */#ifndef __APPLE__	if (share != NULL) {		err = zfs_sa_disable_share(share, proto_table[proto].p_name);		if (err != SA_OK) {			return (zfs_error_fmt(hdl, EZFS_UNSHARENFSFAILED,			    dgettext(TEXT_DOMAIN, "cannot unshare '%s': %s"),			    name, _sa_errorstr(err)));		}	} else {		return (zfs_error_fmt(hdl, EZFS_UNSHARENFSFAILED,		    dgettext(TEXT_DOMAIN, "cannot unshare '%s': not found"),		    name));	}#endif	return (0);}

/* * Unmount the given filesystem. */intzfs_unmount(zfs_handle_t *zhp, const char *mountpoint, int flags){	libzfs_handle_t *hdl = zhp->zfs_hdl;	struct mnttab entry;	char *mntpt = NULL;	/* check to see if we need to unmount the filesystem */	if (mountpoint != NULL || ((zfs_get_type(zhp) == ZFS_TYPE_FILESYSTEM ||				    zfs_get_type(zhp) == ZFS_TYPE_SNAPSHOT ) &&				   libzfs_mnttab_find(hdl, zhp->zfs_name,						      &entry) == 0)) {		/*		 * mountpoint may have come from a call to		 * getmnt/getmntany if it isn't NULL. If it is NULL,		 * we know it comes from libzfs_mnttab_find which can		 * then get freed later. We strdup it to play it safe.		 */		if (mountpoint == NULL)			mntpt = zfs_strdup(hdl, entry.mnt_mountp);		else			mntpt = zfs_strdup(hdl, mountpoint);#if defined(HAVE_ZPL)		/*		 * Unshare and unmount the filesystem		 */		if (zfs_unshare_proto(zhp, mntpt, share_all_proto) != 0)			return (-1);#else		if (unmount_one(hdl, mntpt, flags) != 0) {			free(mntpt);#if defined(HAVE_ZPL)			(void) zfs_shareall(zhp);#endif			return (-1);		}#endif		libzfs_mnttab_remove(hdl, zhp->zfs_name);#if defined(LINUX_PORT)		/* remove a /etc/mtab entry */		if (zfs_linux_remove_entry(mntpt, zhp->zfs_name, MTAB_FILE) < 0) {			free(mntpt);			return (zfs_error_fmt(hdl, EZFS_MOUNTFAILED,				  dgettext(TEXT_DOMAIN, "failed to remove from /etc/mtab '%s'"),					      zhp->zfs_name));		}#endif		free(mntpt);	}	return (0);}

/* * Unmount a single filesystem. */static intunmount_one(libzfs_handle_t *hdl, const char *mountpoint, int flags){    if (umount2(mountpoint, flags) != 0) {        zfs_error_aux(hdl, strerror(errno));        return (zfs_error_fmt(hdl, EZFS_UMOUNTFAILED,                              dgettext(TEXT_DOMAIN, "cannot unmount '%s'"),                              mountpoint));    }    return (0);}

/* * Perform ioctl to get some command history of a pool. * * 'buf' is the buffer to fill up to 'len' bytes.  'off' is the * logical offset of the history buffer to start reading from. * * Upon return, 'off' is the next logical offset to read from and * 'len' is the actual amount of bytes read into 'buf'. */static intget_history(zpool_handle_t *zhp, char *buf, uint64_t *off, uint64_t *len){	zfs_cmd_t zc = { 0 };	libzfs_handle_t *hdl = zhp->zpool_hdl;	(void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));	zc.zc_history = (uint64_t)(uintptr_t)buf;	zc.zc_history_len = *len;	zc.zc_history_offset = *off;	if (ioctl(hdl->libzfs_fd, ZFS_IOC_POOL_GET_HISTORY, &zc) != 0) {		switch (errno) {		case EPERM:			return (zfs_error_fmt(hdl, EZFS_PERM,			    dgettext(TEXT_DOMAIN,			    "cannot show history for pool '%s'"),			    zhp->zpool_name));		case ENOENT:			return (zfs_error_fmt(hdl, EZFS_NOHISTORY,			    dgettext(TEXT_DOMAIN, "cannot get history for pool "			    "'%s'"), zhp->zpool_name));		case ENOTSUP:			return (zfs_error_fmt(hdl, EZFS_BADVERSION,			    dgettext(TEXT_DOMAIN, "cannot get history for pool "			    "'%s', pool must be upgraded"), zhp->zpool_name));		default:			return (zpool_standard_error_fmt(hdl, errno,			    dgettext(TEXT_DOMAIN,			    "cannot get history for '%s'"), zhp->zpool_name));		}	}	*len = zc.zc_history_len;	*off = zc.zc_history_offset;	return (0);}

/* * Open a handle to the given pool, even if the pool is currently in the FAULTED * state. */zpool_handle_t *zpool_open_canfail(libzfs_handle_t *hdl, const char *pool){	zpool_handle_t *zhp;	boolean_t missing;	/*	 * Make sure the pool name is valid.	 */	if (!zpool_name_valid(hdl, B_TRUE, pool)) {		(void) zfs_error_fmt(hdl, EZFS_INVALIDNAME,		    dgettext(TEXT_DOMAIN, "cannot open '%s'"),		    pool);		return (NULL);	}	if ((zhp = zfs_alloc(hdl, sizeof (zpool_handle_t))) == NULL)		return (NULL);	zhp->zpool_hdl = hdl;	(void) strlcpy(zhp->zpool_name, pool, sizeof (zhp->zpool_name));	if (zpool_refresh_stats(zhp, &missing) != 0) {		zpool_close(zhp);		return (NULL);	}	if (missing) {		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,		    "no such pool"));		(void) zfs_error_fmt(hdl, EZFS_NOENT,		    dgettext(TEXT_DOMAIN, "cannot open '%s'"),		    pool);		zpool_close(zhp);		return (NULL);	}	return (zhp);}

/* * Unmount a single filesystem. */static intunmount_one(libzfs_handle_t *hdl, const char *mountpoint, int flags){	int error;	error = do_unmount(mountpoint, flags);	if (error != 0) {		return (zfs_error_fmt(hdl, EZFS_UMOUNTFAILED,		    dgettext(TEXT_DOMAIN, "cannot unmount '%s'"),		    mountpoint));	}	return (0);}

/* * Unmount a single filesystem. */static intunmount_one(libzfs_handle_t *hdl, const char *mountpoint, int flags){	char *mntpt = NULL;	zfs_handle_t *zhp ;		if (umount2(mountpoint, flags) != 0) {		zfs_error_aux(hdl, strerror(errno));		return (zfs_error_fmt(hdl, EZFS_UMOUNTFAILED,		    dgettext(TEXT_DOMAIN, "cannot unmount '%s'"),		    mountpoint));	}	mntpt = zfs_strdup(hdl, mountpoint);	#if defined(LINUX_PORT)        /* remove a /etc/mtab entry */        if (zfs_linux_remove_entry(mntpt, zhp->zfs_name, MTAB_FILE) < 0) {            free(mntpt);            return (zfs_error_fmt(hdl, EZFS_MOUNTFAILED,                        dgettext(TEXT_DOMAIN, "failed to remove from /etc/mtab '%s'"),                        zhp->zfs_name));        }	#endif	return (0);}

/* * Similar to zpool_open_canfail(), but refuses to open pools in the faulted * state. */zpool_handle_t *zpool_open(libzfs_handle_t *hdl, const char *pool){	zpool_handle_t *zhp;	if ((zhp = zpool_open_canfail(hdl, pool)) == NULL)		return (NULL);	if (zhp->zpool_state == POOL_STATE_UNAVAIL) {		(void) zfs_error_fmt(hdl, EZFS_POOLUNAVAIL,		    dgettext(TEXT_DOMAIN, "cannot open '%s'"), zhp->zpool_name);		zpool_close(zhp);		return (NULL);	}	return (zhp);}

/* * Unmount a single filesystem. */static intunmount_one(libzfs_handle_t *hdl, const char *mountpoint, int flags){	ASSERT((flags & ~MS_FORCE) == 0);	int ret = 0;		pid_t umountpid = fork();		if (umountpid == -1) {		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "umount failed: fork() failed"));		goto error;	}		if (umountpid) {		/* parent, we wait */		umountpid = waitpid(umountpid,&ret,0);	}	else{		/* child, we umount */		if (flags & MS_FORCE) execlp("umount","umount","-l",mountpoint,NULL);		else execlp("umount","umount",mountpoint,NULL);		/* we do not reach this line */	}	if (umountpid == -1) {		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "umount failed: waitpid() failed"));		goto error;	}	if (ret != 0) {		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "umount failed: umount child process failed"));		goto error;	}	return (0);error:	return (zfs_error_fmt(hdl, EZFS_UMOUNTFAILED,	    dgettext(TEXT_DOMAIN, "cannot unmount '%s'"),	    mountpoint));}

/* * 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];#if defined(HAVE_ZPL)	libzfs_handle_t *hdl = zhp->zfs_hdl;	sa_share_t share;#endif	zfs_share_proto_t *curr_proto;	zprop_source_t sourcetype;#if defined(HAVE_ZPL)	int ret;#endif	if (!zfs_is_mountable(zhp, mountpoint, sizeof (mountpoint), NULL))		return (0);#if defined(HAVE_ZPL)	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 != NULL ?		    _sa_errorstr(ret) : "");		return (-1);	}#endif	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;#if !defined(HAVE_ZPL)       if (*curr_proto == PROTO_NFS) {           int pid;           int rc;           if ((pid = fork()) < 0) {               fprintf(stderr, "cannot share '%s'", zfs_get_name(zhp));               return -1;           } else if (pid == 0) {               /* child process */               /* exec exportfs */               char export_string[PATH_MAX];               char options[100];               char *argv [] = {                   "exportfs",                   "-v",                   "-i",                   export_string,                   "-o",                   options,                   NULL               };               struct statfs buf;               int fsid_arr[2];               uint64_t fsid;               if (statfs(mountpoint, &buf) < 0)                   return -1;               memcpy((void *)fsid_arr, (void *) &buf.f_fsid, sizeof(int) * 2);               fsid = fsid_arr[0];               fsid |= (((uint64_t)fsid_arr[1]) << 32);//               fprintf(stderr, "using fsid=%lu/n", fsid);               sprintf(export_string, "*:%s", mountpoint);               sprintf(options, "rw,sync,fsid=%lu", fsid);               execvp("exportfs", argv);               return -1;           }           /* parent process */           if (waitpid(pid, &rc, WUNTRACED) != pid) {               fprintf(stderr, "cannot share '%s'", zfs_get_name(zhp));               return -1;           }           if (!WIFEXITED(rc) || WEXITSTATUS(rc) != 0) {               fprintf(stderr, "cannot share '%s'", zfs_get_name(zhp));               return -1;           }//.........这里部分代码省略.........

/* * 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) {//.........这里部分代码省略.........

/* * Create the named pool, using the provided vdev list.  It is assumed * that the consumer has already validated the contents of the nvlist, so we * don't have to worry about error semantics. */intzpool_create(libzfs_handle_t *hdl, const char *pool, nvlist_t *nvroot,    const char *altroot){	zfs_cmd_t zc = { 0 };	char msg[1024];	(void) snprintf(msg, sizeof (msg), dgettext(TEXT_DOMAIN,	    "cannot create '%s'"), pool);	if (!zpool_name_valid(hdl, B_FALSE, pool))		return (zfs_error(hdl, EZFS_INVALIDNAME, msg));	if (altroot != NULL && altroot[0] != '/')		return (zfs_error_fmt(hdl, EZFS_BADPATH,		    dgettext(TEXT_DOMAIN, "bad alternate root '%s'"), altroot));	if (zcmd_write_src_nvlist(hdl, &zc, nvroot, NULL) != 0)		return (-1);	(void) strlcpy(zc.zc_name, pool, sizeof (zc.zc_name));	if (altroot != NULL)		(void) strlcpy(zc.zc_value, altroot, sizeof (zc.zc_value));	if (ioctl(hdl->libzfs_fd, ZFS_IOC_POOL_CREATE, &zc) != 0) {		zcmd_free_nvlists(&zc);		switch (errno) {		case EBUSY:			/*			 * This can happen if the user has specified the same			 * device multiple times.  We can't reliably detect this			 * until we try to add it and see we already have a			 * label.			 */			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,			    "one or more vdevs refer to the same device"));			return (zfs_error(hdl, EZFS_BADDEV, msg));		case EOVERFLOW:			/*			 * This occurs when one of the devices is below			 * SPA_MINDEVSIZE.  Unfortunately, we can't detect which			 * device was the problem device since there's no			 * reliable way to determine device size from userland.			 */			{				char buf[64];				zfs_nicenum(SPA_MINDEVSIZE, buf, sizeof (buf));				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,				    "one or more devices is less than the "				    "minimum size (%s)"), buf);			}			return (zfs_error(hdl, EZFS_BADDEV, msg));		case ENOSPC:			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,			    "one or more devices is out of space"));			return (zfs_error(hdl, EZFS_BADDEV, msg));		default:			return (zpool_standard_error(hdl, errno, msg));		}	}	zcmd_free_nvlists(&zc);	/*	 * If this is an alternate root pool, then we automatically set the	 * mountpoint of the root dataset to be '/'.	 */	if (altroot != NULL) {		zfs_handle_t *zhp;		verify((zhp = zfs_open(hdl, pool, ZFS_TYPE_ANY)) != NULL);		verify(zfs_prop_set(zhp, zfs_prop_to_name(ZFS_PROP_MOUNTPOINT),		    "/") == 0);		zfs_close(zhp);	}	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;    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);}

/* * Given a list of directories to search, find all pools stored on disk.  This * includes partial pools which are not available to import.  If no args are * given (argc is 0), then the default directory (/dev/dsk) is searched. * poolname or guid (but not both) are provided by the caller when trying * to import a specific pool. */static nvlist_t *zpool_find_import_impl(libzfs_handle_t *hdl, importargs_t *iarg){	int i, num_labels, dirs = iarg->paths;	DIR *dirp = NULL;	struct dirent *dp;	char path[MAXPATHLEN];	char *end, **dir = iarg->path;	size_t pathleft;	struct stat statbuf;	nvlist_t *ret = NULL, *config;	int fd;	pool_list_t pools = { 0 };	pool_entry_t *pe, *penext;	vdev_entry_t *ve, *venext;	config_entry_t *ce, *cenext;	name_entry_t *ne, *nenext;	verify(iarg->poolname == NULL || iarg->guid == 0);	if (dirs == 0) {#ifdef HAVE_LIBBLKID		/* Use libblkid to scan all device for their type */		if (zpool_find_import_blkid(hdl, &pools) == 0)			goto skip_scanning;		(void) zfs_error_fmt(hdl, EZFS_BADCACHE,		    dgettext(TEXT_DOMAIN, "blkid failure falling back "		    "to manual probing"));#endif /* HAVE_LIBBLKID */		dir = zpool_default_import_path;		dirs = DEFAULT_IMPORT_PATH_SIZE;	}	/*	 * Go through and read the label configuration information from every	 * possible device, organizing the information according to pool GUID	 * and toplevel GUID.	 */	for (i = 0; i < dirs; i++) {		char *rdsk;		int dfd;		/* use realpath to normalize the path */		if (realpath(dir[i], path) == 0) {			/* it is safe to skip missing search paths */			if (errno == ENOENT)				continue;			zfs_error_aux(hdl, strerror(errno));			(void) zfs_error_fmt(hdl, EZFS_BADPATH,			    dgettext(TEXT_DOMAIN, "cannot open '%s'"), dir[i]);			goto error;		}		end = &path[strlen(path)];		*end++ = '/';		*end = 0;		pathleft = &path[sizeof (path)] - end;		/*		 * Using raw devices instead of block devices when we're		 * reading the labels skips a bunch of slow operations during		 * close(2) processing, so we replace /dev/dsk with /dev/rdsk.		 */		if (strcmp(path, "/dev/dsk/") == 0)			rdsk = "/dev/rdsk/";		else			rdsk = path;		if ((dfd = open(rdsk, O_RDONLY)) < 0 ||		    (dirp = fdopendir(dfd)) == NULL) {			zfs_error_aux(hdl, strerror(errno));			(void) zfs_error_fmt(hdl, EZFS_BADPATH,			    dgettext(TEXT_DOMAIN, "cannot open '%s'"),			    rdsk);			goto error;		}		/*		 * This is not MT-safe, but we have no MT consumers of libzfs		 */		while ((dp = readdir(dirp)) != NULL) {			const char *name = dp->d_name;			if (name[0] == '.' &&			    (name[1] == 0 || (name[1] == '.' && name[2] == 0)))				continue;			/*			 * Skip checking devices with well known prefixes:			 * watchdog - A special close is required to avoid			 *            triggering it and resetting the system.//.........这里部分代码省略.........

/* * Unmount a single filesystem. */static intunmount_one(libzfs_handle_t *hdl, const char *mountpoint, int flags){#ifdef __APPLE__#if !TARGET_OS_EMBEDDED && !TARGET_OS_IPHONE	/* First try going through diskarb */	if (diskarb_unmount(mountpoint, flags) == 0) {		return (0);	}#endif#endif#ifdef __APPLE__	if (unmount(mountpoint, flags) != 0) {#else	if (umount2(mountpoint, flags) != 0) {#endif		zfs_error_aux(hdl, strerror(errno));		return (zfs_error_fmt(hdl, EZFS_UMOUNTFAILED,		    dgettext(TEXT_DOMAIN, "cannot unmount '%s'"),		    mountpoint));	}	return (0);}/* * Unmount the given filesystem. */intzfs_unmount(zfs_handle_t *zhp, const char *mountpoint, int flags){	struct mnttab search = { 0 }, entry;	char *mntpt = NULL;	/* check to see if need to unmount the filesystem */	search.mnt_special = zhp->zfs_name;	search.mnt_fstype = MNTTYPE_ZFS;#ifndef __APPLE__	rewind(zhp->zfs_hdl->libzfs_mnttab);#endif /*!__APPLE__*/	if (mountpoint != NULL || ((zfs_get_type(zhp) == ZFS_TYPE_FILESYSTEM) &&	    getmntany(zhp->zfs_hdl->libzfs_mnttab, &entry, &search) == 0)) {		/*		 * mountpoint may have come from a call to		 * getmnt/getmntany if it isn't NULL. If it is NULL,		 * we know it comes from getmntany which can then get		 * overwritten later. We strdup it to play it safe.		 */		if (mountpoint == NULL)			mntpt = zfs_strdup(zhp->zfs_hdl, entry.mnt_mountp);		else			mntpt = zfs_strdup(zhp->zfs_hdl, mountpoint);		/*		 * Unshare and unmount the filesystem		 */#ifndef __APPLE__		if (zfs_unshare_proto(zhp, mntpt, share_all_proto) != 0)			return (-1);#endif		if (unmount_one(zhp->zfs_hdl, mntpt, flags) != 0) {			free(mntpt);			(void) zfs_shareall(zhp);			return (-1);		}		free(mntpt);	}	return (0);}/* * Unmount this filesystem and any children inheriting the mountpoint property. * To do this, just act like we're changing the mountpoint property, but don't * remount the filesystems afterwards. */intzfs_unmountall(zfs_handle_t *zhp, int flags){	prop_changelist_t *clp;	int ret;	clp = changelist_gather(zhp, ZFS_PROP_MOUNTPOINT, flags);	if (clp == NULL)		return (-1);	ret = changelist_prefix(clp);	changelist_free(clp);	return (ret);}

/* * 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 (!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 */	/* ZFSFUSE */	if (zfsfuse_mount(hdl, zfs_get_name(zhp), mountpoint, MS_OPTIONSTR | flags,	    MNTTYPE_ZFS, NULL, 0, mntopts, strlen (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 {			zfs_error_aux(hdl, strerror(errno));		}		return (zfs_error_fmt(hdl, EZFS_MOUNTFAILED,		    dgettext(TEXT_DOMAIN, "cannot mount '%s'"),		    zhp->zfs_name));	}	return (0);}

/* * Use libblkid to quickly search for zfs devices */static intzpool_find_import_blkid(libzfs_handle_t *hdl, pool_list_t *pools){	blkid_cache cache;	blkid_dev_iterate iter;	blkid_dev dev;	const char *devname;	nvlist_t *config;	int fd, err, num_labels;	err = blkid_get_cache(&cache, NULL);	if (err != 0) {		(void) zfs_error_fmt(hdl, EZFS_BADCACHE,		    dgettext(TEXT_DOMAIN, "blkid_get_cache() %d"), err);		goto err_blkid1;	}	err = blkid_probe_all(cache);	if (err != 0) {		(void) zfs_error_fmt(hdl, EZFS_BADCACHE,		    dgettext(TEXT_DOMAIN, "blkid_probe_all() %d"), err);		goto err_blkid2;	}	iter = blkid_dev_iterate_begin(cache);	if (iter == NULL) {		(void) zfs_error_fmt(hdl, EZFS_BADCACHE,		    dgettext(TEXT_DOMAIN, "blkid_dev_iterate_begin()"));		goto err_blkid2;	}	err = blkid_dev_set_search(iter, "TYPE", "zfs_member");	if (err != 0) {		(void) zfs_error_fmt(hdl, EZFS_BADCACHE,		    dgettext(TEXT_DOMAIN, "blkid_dev_set_search() %d"), err);		goto err_blkid3;	}	while (blkid_dev_next(iter, &dev) == 0) {		devname = blkid_dev_devname(dev);		if ((fd = open(devname, O_RDONLY)) < 0)			continue;		err = zpool_read_label(fd, &config, &num_labels);		(void) close(fd);		if (err != 0) {			(void) no_memory(hdl);			goto err_blkid3;		}		if (config != NULL) {			err = add_config(hdl, pools, devname, 0,			    num_labels, config);			if (err != 0)				goto err_blkid3;		}	}err_blkid3:	blkid_dev_iterate_end(iter);err_blkid2:	blkid_put_cache(cache);err_blkid1:	return (err);}

/* * 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;#ifdef __APPLE__	struct zfs_mount_args mnt_args = {0};	char  devpath[MAXPATHLEN];#endif	if (options == NULL)		mntopts[0] = '/0';	else		(void) strlcpy(mntopts, options, sizeof (mntopts));	if (!zfs_is_mountable(zhp, mountpoint, sizeof (mountpoint), NULL))		return (0);#ifdef __APPLE__	/*	 * Check for optional paths	 */	if (hasoptionalpath(mntopts, "mountdev=", devpath, sizeof (devpath)))		mnt_args.mountdev = devpath;	if (hasoptionalpath(mntopts, "mountpoint=", mountpoint,	    sizeof (mountpoint)))		goto callmount;#endif	/* 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));		}	}#ifndef __APPLE__	/*	 * 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));	}#endif /*!__APPLE__*/	/* perform the mount */#ifdef __APPLE__callmount:	mnt_args.dataset = zfs_get_name(zhp);	mnt_args.flags = 0;	if (mount(MNTTYPE_ZFS, mountpoint, flags, &mnt_args) != 0) {#else	if (mount(zfs_get_name(zhp), mountpoint, MS_OPTIONSTR | flags,	    MNTTYPE_ZFS, NULL, 0, mntopts, sizeof (mntopts)) != 0) {#endif#ifdef __APPLE__		/*		 * If this was a top-level filesystem, then IOKit		 * probing may have already mounted it, causing		 * our call to mount() to fail.		 */		if (zfs_is_mounted(zhp, NULL)) {			goto success;		}#endif       		/*		 * 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 {			zfs_error_aux(hdl, strerror(errno));		}//.........这里部分代码省略.........

/* * Unshare a filesystem by mountpoint. */static intunshare_one(libzfs_handle_t *hdl, const char *name, const char *mountpoint,    zfs_share_proto_t proto){#if defined(HAVE_ZPL)	sa_share_t share;	int err;	char *mntpt;	/*	 * Mountpoint could get trashed if libshare calls getmntany	 * which it does during API initialization, so strdup the	 * value.	 */	mntpt = zfs_strdup(hdl, mountpoint);	/* make sure libshare initialized */	if ((err = zfs_init_libshare(hdl, SA_INIT_SHARE_API)) != SA_OK) {		free(mntpt);	/* don't need the copy anymore */		return (zfs_error_fmt(hdl, EZFS_SHARENFSFAILED,		    dgettext(TEXT_DOMAIN, "cannot unshare '%s': %s"),		    name, _sa_errorstr(err)));	}	share = zfs_sa_find_share(hdl->libzfs_sharehdl, mntpt);	free(mntpt);	/* don't need the copy anymore */	if (share != NULL) {		err = zfs_sa_disable_share(share, proto_table[proto].p_name);		if (err != SA_OK) {			return (zfs_error_fmt(hdl, EZFS_UNSHARENFSFAILED,			    dgettext(TEXT_DOMAIN, "cannot unshare '%s': %s"),			    name, _sa_errorstr(err)));		}	} else {		return (zfs_error_fmt(hdl, EZFS_UNSHARENFSFAILED,		    dgettext(TEXT_DOMAIN, "cannot unshare '%s': not found"),		    name));	}	return (0);#else	int rc;	if (proto == PROTO_NFS) {		int pid;		if ((pid = fork()) < 0) {			fprintf(stderr, "cannot unshare '%s'/n", mountpoint);			return -1;		} else if (pid == 0) {			/* child process */			/* exec exportfs */			char export_string[PATH_MAX];			char *argv[] = {				"exportfs",				"-v",				"-u",				export_string,				NULL			};			sprintf(export_string, "*:%s", mountpoint);			execvp("exportfs", argv);			return -1;		}		/* parent process */		if (waitpid(pid, &rc, WUNTRACED) != pid) {			fprintf(stderr, "cannot unshare '%s'", mountpoint);			return -1;		}		if (!WIFEXITED(rc) || WEXITSTATUS(rc) != 0) {			fprintf(stderr, "cannot unshare '%s'", mountpoint);			return -1;		}		return 0;	}	return -1;#endif}

/* * 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;	zfs_share_proto_t *curr_proto;	zprop_source_t sourcetype;	int error, ret;	if (!zfs_is_mountable(zhp, mountpoint, sizeof (mountpoint), NULL))		return (0);	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;#ifdef illumos		ret = zfs_init_libshare_arg(hdl, SA_INIT_ONE_SHARE_FROM_HANDLE,		    zhp);		if (ret != SA_OK) {			(void) zfs_error_fmt(hdl, EZFS_SHARENFSFAILED,			    dgettext(TEXT_DOMAIN, "cannot share '%s': %s"),			    zfs_get_name(zhp), _sa_errorstr != NULL ?			    _sa_errorstr(ret) : "");			return (-1);		}#endif		/*		 * 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;#ifdef illumos		share = zfs_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);			}			share = zfs_sa_find_share(hdl->libzfs_sharehdl,			    mountpoint);		}		if (share != NULL) {			int err;			err = zfs_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#else		if (*curr_proto != PROTO_NFS) {			fprintf(stderr, "Unsupported share protocol: %d./n",			    *curr_proto);			continue;		}		if (strcmp(shareopts, "on") == 0)			error = fsshare(ZFS_EXPORTS_PATH, mountpoint, "");		else			error = fsshare(ZFS_EXPORTS_PATH, mountpoint, shareopts);		if (error != 0)#endif		{//.........这里部分代码省略.........

/* * Import the given pool using the known configuration.  The configuration * should have come from zpool_find_import().  The 'newname' and 'altroot' * parameters control whether the pool is imported with a different name or with * an alternate root, respectively. */intzpool_import(libzfs_handle_t *hdl, nvlist_t *config, const char *newname,    const char *altroot){	zfs_cmd_t zc = { 0 };	char *thename;	char *origname;	int ret;	verify(nvlist_lookup_string(config, ZPOOL_CONFIG_POOL_NAME,	    &origname) == 0);	if (newname != NULL) {		if (!zpool_name_valid(hdl, B_FALSE, newname))			return (zfs_error_fmt(hdl, EZFS_INVALIDNAME,			    dgettext(TEXT_DOMAIN, "cannot import '%s'"),			    newname));		thename = (char *)newname;	} else {		thename = origname;	}	if (altroot != NULL && altroot[0] != '/')		return (zfs_error_fmt(hdl, EZFS_BADPATH,		    dgettext(TEXT_DOMAIN, "bad alternate root '%s'"),		    altroot));	(void) strlcpy(zc.zc_name, thename, sizeof (zc.zc_name));	if (altroot != NULL)		(void) strlcpy(zc.zc_value, altroot, sizeof (zc.zc_value));	else		zc.zc_value[0] = '/0';	verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID,	    &zc.zc_guid) == 0);	if (zcmd_write_src_nvlist(hdl, &zc, config, NULL) != 0)		return (-1);	ret = 0;	if (ioctl(hdl->libzfs_fd, ZFS_IOC_POOL_IMPORT, &zc) != 0) {		char desc[1024];		if (newname == NULL)			(void) snprintf(desc, sizeof (desc),			    dgettext(TEXT_DOMAIN, "cannot import '%s'"),			    thename);		else			(void) snprintf(desc, sizeof (desc),			    dgettext(TEXT_DOMAIN, "cannot import '%s' as '%s'"),			    origname, thename);		switch (errno) {		case ENOTSUP:			/*			 * Unsupported version.			 */			(void) zfs_error(hdl, EZFS_BADVERSION, desc);			break;		case EINVAL:			(void) zfs_error(hdl, EZFS_INVALCONFIG, desc);			break;		default:			(void) zpool_standard_error(hdl, errno, desc);		}		ret = -1;	} else {		zpool_handle_t *zhp;		/*		 * This should never fail, but play it safe anyway.		 */		if (zpool_open_silent(hdl, thename, &zhp) != 0) {			ret = -1;		} else if (zhp != NULL) {			ret = zpool_create_zvol_links(zhp);			zpool_close(zhp);		}	}	zcmd_free_nvlists(&zc);	return (ret);}

intzfs_error(libzfs_handle_t *hdl, int error, const char *msg){	return (zfs_error_fmt(hdl, error, "%s", msg));}

/* * Given a list of directories to search, find all pools stored on disk.  This * includes partial pools which are not available to import.  If no args are * given (argc is 0), then the default directory (/dev/dsk) is searched. * poolname or guid (but not both) are provided by the caller when trying * to import a specific pool. */static nvlist_t *zpool_find_import_impl(libzfs_handle_t *hdl, importargs_t *iarg){	int i, dirs = iarg->paths;	struct dirent64 *dp;	char path[MAXPATHLEN];	char *end, **dir = iarg->path;	size_t pathleft;	nvlist_t *ret = NULL;	static char *default_dir = "/dev/dsk";	pool_list_t pools = { 0 };	pool_entry_t *pe, *penext;	vdev_entry_t *ve, *venext;	config_entry_t *ce, *cenext;	name_entry_t *ne, *nenext;	avl_tree_t slice_cache;	rdsk_node_t *slice;	void *cookie;	if (dirs == 0) {		dirs = 1;		dir = &default_dir;	}	/*	 * Go through and read the label configuration information from every	 * possible device, organizing the information according to pool GUID	 * and toplevel GUID.	 */	for (i = 0; i < dirs; i++) {		tpool_t *t;		char *rdsk;		int dfd;		boolean_t config_failed = B_FALSE;		DIR *dirp;		/* use realpath to normalize the path */		if (realpath(dir[i], path) == 0) {			(void) zfs_error_fmt(hdl, EZFS_BADPATH,			    dgettext(TEXT_DOMAIN, "cannot open '%s'"), dir[i]);			goto error;		}		end = &path[strlen(path)];		*end++ = '/';		*end = 0;		pathleft = &path[sizeof (path)] - end;		/*		 * Using raw devices instead of block devices when we're		 * reading the labels skips a bunch of slow operations during		 * close(2) processing, so we replace /dev/dsk with /dev/rdsk.		 */		if (strcmp(path, "/dev/dsk/") == 0)			rdsk = "/dev/rdsk/";		else			rdsk = path;		if ((dfd = open64(rdsk, O_RDONLY)) < 0 ||		    (dirp = fdopendir(dfd)) == NULL) {			if (dfd >= 0)				(void) close(dfd);			zfs_error_aux(hdl, strerror(errno));			(void) zfs_error_fmt(hdl, EZFS_BADPATH,			    dgettext(TEXT_DOMAIN, "cannot open '%s'"),			    rdsk);			goto error;		}		avl_create(&slice_cache, slice_cache_compare,		    sizeof (rdsk_node_t), offsetof(rdsk_node_t, rn_node));		/*		 * This is not MT-safe, but we have no MT consumers of libzfs		 */		while ((dp = readdir64(dirp)) != NULL) {			const char *name = dp->d_name;			if (name[0] == '.' &&			    (name[1] == 0 || (name[1] == '.' && name[2] == 0)))				continue;			slice = zfs_alloc(hdl, sizeof (rdsk_node_t));			slice->rn_name = zfs_strdup(hdl, name);			slice->rn_avl = &slice_cache;			slice->rn_dfd = dfd;			slice->rn_hdl = hdl;			slice->rn_nozpool = B_FALSE;			avl_add(&slice_cache, slice);		}		/*		 * create a thread pool to do all of this in parallel;		 * rn_nozpool is not protected, so this is racy in that		 * multiple tasks could decide that the same slice can		 * not hold a zpool, which is benign.  Also choose		 * double the number of processors; we hold a lot of//.........这里部分代码省略.........

/* * Given a list of directories to search, find all pools stored on disk.  This * includes partial pools which are not available to import.  If no args are * given (argc is 0), then the default directory (/dev/dsk) is searched. * poolname or guid (but not both) are provided by the caller when trying * to import a specific pool. */static nvlist_t *zpool_find_import_impl(libzfs_handle_t *hdl, importargs_t *iarg){	int i, dirs = iarg->paths;	struct dirent *dp;	char path[MAXPATHLEN];	char *end, **dir = iarg->path;	size_t pathleft;	nvlist_t *ret = NULL;	pool_list_t pools = { 0 };	pool_entry_t *pe, *penext;	vdev_entry_t *ve, *venext;	config_entry_t *ce, *cenext;	name_entry_t *ne, *nenext;	avl_tree_t slice_cache;	rdsk_node_t *slice;	void *cookie;	verify(iarg->poolname == NULL || iarg->guid == 0);	if (dirs == 0) {#ifdef HAVE_LIBBLKID		/* Use libblkid to scan all device for their type */		if (zpool_find_import_blkid(hdl, &pools) == 0)			goto skip_scanning;		(void) zfs_error_fmt(hdl, EZFS_BADCACHE,		    dgettext(TEXT_DOMAIN, "blkid failure falling back "		    "to manual probing"));#endif /* HAVE_LIBBLKID */		dir = zpool_default_import_path;		dirs = DEFAULT_IMPORT_PATH_SIZE;	}	/*	 * Go through and read the label configuration information from every	 * possible device, organizing the information according to pool GUID	 * and toplevel GUID.	 */	for (i = 0; i < dirs; i++) {		taskq_t *t;		char rdsk[MAXPATHLEN];		int dfd;		boolean_t config_failed = B_FALSE;		DIR *dirp;		/* use realpath to normalize the path */		if (realpath(dir[i], path) == 0) {			/* it is safe to skip missing search paths */			if (errno == ENOENT)				continue;			zfs_error_aux(hdl, strerror(errno));			(void) zfs_error_fmt(hdl, EZFS_BADPATH,			    dgettext(TEXT_DOMAIN, "cannot open '%s'"), dir[i]);			goto error;		}		end = &path[strlen(path)];		*end++ = '/';		*end = 0;		pathleft = &path[sizeof (path)] - end;		/*		 * Using raw devices instead of block devices when we're		 * reading the labels skips a bunch of slow operations during		 * close(2) processing, so we replace /dev/dsk with /dev/rdsk.		 */		if (strcmp(path, ZFS_DISK_ROOTD) == 0)			(void) strlcpy(rdsk, ZFS_RDISK_ROOTD, sizeof (rdsk));		else			(void) strlcpy(rdsk, path, sizeof (rdsk));		if ((dfd = open(rdsk, O_RDONLY)) < 0 ||		    (dirp = fdopendir(dfd)) == NULL) {			if (dfd >= 0)				(void) close(dfd);			zfs_error_aux(hdl, strerror(errno));			(void) zfs_error_fmt(hdl, EZFS_BADPATH,			    dgettext(TEXT_DOMAIN, "cannot open '%s'"),			    rdsk);			goto error;		}		avl_create(&slice_cache, slice_cache_compare,		    sizeof (rdsk_node_t), offsetof(rdsk_node_t, rn_node));		/*		 * This is not MT-safe, but we have no MT consumers of libzfs		 */		while ((dp = readdir(dirp)) != NULL) {			const char *name = dp->d_name;//.........这里部分代码省略.........

/* * Mount the given filesystem. * * 'flags' appears pretty much always 0 here. */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;	if (options == NULL) {		mntopts[0] = '/0';	} 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	 */#ifdef __LINUX__	if (zpool_get_prop_int(zhp->zpool_hdl, ZPOOL_PROP_READONLY, NULL))		(void) strlcat(mntopts, "," MNTOPT_RO, sizeof (mntopts));#else	if (zpool_get_prop_int(zhp->zpool_hdl, ZPOOL_PROP_READONLY, NULL))		flags |= MS_RDONLY;#endif /* __LINUX__ */	if (!zfs_is_mountable(zhp, mountpoint, sizeof (mountpoint), NULL))		return (0);#ifdef __LINUX__	/*	 * 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, &flags);	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));#endif /* __LINUX__ */	/* Create the directory if it doesn't already exist */#ifdef __APPLE__	if (zfs_get_type(zhp) != ZFS_TYPE_SNAPSHOT &&	    lstat(mountpoint, &buf) != 0) {#else	if (lstat(mountpoint, &buf) != 0) {#endif		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 */#ifdef __LINUX__	rc = do_mount(zfs_get_name(zhp), mountpoint, mntopts);#elif defined(__APPLE__) || defined (__FREEBSD__)	if (zmount(zfs_get_name(zhp), mountpoint, MS_OPTIONSTR | flags,	    MNTTYPE_ZFS, NULL, 0, mntopts, sizeof (mntopts)) != 0) {#elif defined(__illumos__)	if (mount(zfs_get_name(zhp), mountpoint, MS_OPTIONSTR | flags,	    MNTTYPE_ZFS, NULL, 0, mntopts, sizeof (mntopts)) != 0) {//.........这里部分代码省略.........