xref: /titanic_50/usr/src/lib/libzfs/common/libzfs_mount.c (revision c0889d7a91fa87e1cb7ef4457629b0cb51d47b50)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 #pragma ident	"%Z%%M%	%I%	%E% SMI"
28 
29 /*
30  * Routines to manage ZFS mounts.  We separate all the nasty routines that have
31  * to deal with the OS.  The following functions are the main entry points --
32  * they are used by mount and unmount and when changing a filesystem's
33  * mountpoint.
34  *
35  * 	zfs_is_mounted()
36  * 	zfs_mount()
37  * 	zfs_unmount()
38  * 	zfs_unmountall()
39  *
40  * This file also contains the functions used to manage sharing filesystems via
41  * NFS and iSCSI:
42  *
43  * 	zfs_is_shared()
44  * 	zfs_share()
45  * 	zfs_unshare()
46  *
47  * 	zfs_is_shared_nfs()
48  * 	zfs_is_shared_smb()
49  * 	zfs_is_shared_iscsi()
50  * 	zfs_share_proto()
51  * 	zfs_shareall();
52  * 	zfs_share_iscsi()
53  * 	zfs_unshare_nfs()
54  * 	zfs_unshare_smb()
55  * 	zfs_unshareall_nfs()
56  *	zfs_unshareall_smb()
57  *	zfs_unshareall()
58  *	zfs_unshareall_bypath()
59  * 	zfs_unshare_iscsi()
60  *
61  * The following functions are available for pool consumers, and will
62  * mount/unmount and share/unshare all datasets within pool:
63  *
64  * 	zpool_enable_datasets()
65  * 	zpool_disable_datasets()
66  */
67 
68 #include <dirent.h>
69 #include <dlfcn.h>
70 #include <errno.h>
71 #include <libgen.h>
72 #include <libintl.h>
73 #include <stdio.h>
74 #include <stdlib.h>
75 #include <strings.h>
76 #include <unistd.h>
77 #include <zone.h>
78 #include <sys/mntent.h>
79 #include <sys/mnttab.h>
80 #include <sys/mount.h>
81 #include <sys/stat.h>
82 
83 #include <libzfs.h>
84 
85 #include "libzfs_impl.h"
86 
87 #include <libshare.h>
88 #include <sys/systeminfo.h>
89 #define	MAXISALEN	257	/* based on sysinfo(2) man page */
90 
91 static int zfs_share_proto(zfs_handle_t *, zfs_share_proto_t *);
92 zfs_share_type_t zfs_is_shared_proto(zfs_handle_t *, char **,
93     zfs_share_proto_t);
94 
95 static int (*iscsitgt_zfs_share)(const char *);
96 static int (*iscsitgt_zfs_unshare)(const char *);
97 static int (*iscsitgt_zfs_is_shared)(const char *);
98 static int (*iscsitgt_svc_online)();
99 
100 /*
101  * The share protocols table must be in the same order as the zfs_share_prot_t
102  * enum in libzfs_impl.h
103  */
104 typedef struct {
105 	zfs_prop_t p_prop;
106 	char *p_name;
107 	int p_share_err;
108 	int p_unshare_err;
109 } proto_table_t;
110 
111 proto_table_t proto_table[PROTO_END] = {
112 	{ZFS_PROP_SHARENFS, "nfs", EZFS_SHARENFSFAILED, EZFS_UNSHARENFSFAILED},
113 	{ZFS_PROP_SHARESMB, "smb", EZFS_SHARESMBFAILED, EZFS_UNSHARESMBFAILED},
114 };
115 
116 zfs_share_proto_t nfs_only[] = {
117 	PROTO_NFS,
118 	PROTO_END
119 };
120 
121 zfs_share_proto_t smb_only[] = {
122 	PROTO_SMB,
123 	PROTO_END
124 };
125 zfs_share_proto_t share_all_proto[] = {
126 	PROTO_NFS,
127 	PROTO_SMB,
128 	PROTO_END
129 };
130 
131 #pragma init(zfs_iscsi_init)
132 static void
133 zfs_iscsi_init(void)
134 {
135 	void *libiscsitgt;
136 
137 	if ((libiscsitgt = dlopen("/lib/libiscsitgt.so.1",
138 	    RTLD_LAZY | RTLD_GLOBAL)) == NULL ||
139 	    (iscsitgt_zfs_share = (int (*)(const char *))dlsym(libiscsitgt,
140 	    "iscsitgt_zfs_share")) == NULL ||
141 	    (iscsitgt_zfs_unshare = (int (*)(const char *))dlsym(libiscsitgt,
142 	    "iscsitgt_zfs_unshare")) == NULL ||
143 	    (iscsitgt_zfs_is_shared = (int (*)(const char *))dlsym(libiscsitgt,
144 	    "iscsitgt_zfs_is_shared")) == NULL ||
145 	    (iscsitgt_svc_online = (int (*)(const char *))dlsym(libiscsitgt,
146 	    "iscsitgt_svc_online")) == NULL) {
147 		iscsitgt_zfs_share = NULL;
148 		iscsitgt_zfs_unshare = NULL;
149 		iscsitgt_zfs_is_shared = NULL;
150 		iscsitgt_svc_online = NULL;
151 	}
152 }
153 
154 /*
155  * Search the sharetab for the given mountpoint and protocol, returning
156  * a zfs_share_type_t value.
157  */
158 static zfs_share_type_t
159 is_shared(libzfs_handle_t *hdl, const char *mountpoint, zfs_share_proto_t proto)
160 {
161 	char buf[MAXPATHLEN], *tab;
162 	char *ptr;
163 
164 	if (hdl->libzfs_sharetab == NULL)
165 		return (SHARED_NOT_SHARED);
166 
167 	(void) fseek(hdl->libzfs_sharetab, 0, SEEK_SET);
168 
169 	while (fgets(buf, sizeof (buf), hdl->libzfs_sharetab) != NULL) {
170 
171 		/* the mountpoint is the first entry on each line */
172 		if ((tab = strchr(buf, '\t')) == NULL)
173 			continue;
174 
175 		*tab = '\0';
176 		if (strcmp(buf, mountpoint) == 0) {
177 			/*
178 			 * the protocol field is the third field
179 			 * skip over second field
180 			 */
181 			ptr = ++tab;
182 			if ((tab = strchr(ptr, '\t')) == NULL)
183 				continue;
184 			ptr = ++tab;
185 			if ((tab = strchr(ptr, '\t')) == NULL)
186 				continue;
187 			*tab = '\0';
188 			if (strcmp(ptr,
189 			    proto_table[proto].p_name) == 0) {
190 				switch (proto) {
191 				case PROTO_NFS:
192 					return (SHARED_NFS);
193 				case PROTO_SMB:
194 					return (SHARED_SMB);
195 				default:
196 					return (0);
197 				}
198 			}
199 		}
200 	}
201 
202 	return (SHARED_NOT_SHARED);
203 }
204 
205 /*
206  * Returns true if the specified directory is empty.  If we can't open the
207  * directory at all, return true so that the mount can fail with a more
208  * informative error message.
209  */
210 static boolean_t
211 dir_is_empty(const char *dirname)
212 {
213 	DIR *dirp;
214 	struct dirent64 *dp;
215 
216 	if ((dirp = opendir(dirname)) == NULL)
217 		return (B_TRUE);
218 
219 	while ((dp = readdir64(dirp)) != NULL) {
220 
221 		if (strcmp(dp->d_name, ".") == 0 ||
222 		    strcmp(dp->d_name, "..") == 0)
223 			continue;
224 
225 		(void) closedir(dirp);
226 		return (B_FALSE);
227 	}
228 
229 	(void) closedir(dirp);
230 	return (B_TRUE);
231 }
232 
233 /*
234  * Checks to see if the mount is active.  If the filesystem is mounted, we fill
235  * in 'where' with the current mountpoint, and return 1.  Otherwise, we return
236  * 0.
237  */
238 boolean_t
239 is_mounted(libzfs_handle_t *zfs_hdl, const char *special, char **where)
240 {
241 	struct mnttab search = { 0 }, entry;
242 
243 	/*
244 	 * Search for the entry in /etc/mnttab.  We don't bother getting the
245 	 * mountpoint, as we can just search for the special device.  This will
246 	 * also let us find mounts when the mountpoint is 'legacy'.
247 	 */
248 	search.mnt_special = (char *)special;
249 	search.mnt_fstype = MNTTYPE_ZFS;
250 
251 	rewind(zfs_hdl->libzfs_mnttab);
252 	if (getmntany(zfs_hdl->libzfs_mnttab, &entry, &search) != 0)
253 		return (B_FALSE);
254 
255 	if (where != NULL)
256 		*where = zfs_strdup(zfs_hdl, entry.mnt_mountp);
257 
258 	return (B_TRUE);
259 }
260 
261 boolean_t
262 zfs_is_mounted(zfs_handle_t *zhp, char **where)
263 {
264 	return (is_mounted(zhp->zfs_hdl, zfs_get_name(zhp), where));
265 }
266 
267 /*
268  * Returns true if the given dataset is mountable, false otherwise.  Returns the
269  * mountpoint in 'buf'.
270  */
271 static boolean_t
272 zfs_is_mountable(zfs_handle_t *zhp, char *buf, size_t buflen,
273     zprop_source_t *source)
274 {
275 	char sourceloc[ZFS_MAXNAMELEN];
276 	zprop_source_t sourcetype;
277 
278 	if (!zfs_prop_valid_for_type(ZFS_PROP_MOUNTPOINT, zhp->zfs_type))
279 		return (B_FALSE);
280 
281 	verify(zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, buf, buflen,
282 	    &sourcetype, sourceloc, sizeof (sourceloc), B_FALSE) == 0);
283 
284 	if (strcmp(buf, ZFS_MOUNTPOINT_NONE) == 0 ||
285 	    strcmp(buf, ZFS_MOUNTPOINT_LEGACY) == 0)
286 		return (B_FALSE);
287 
288 	if (!zfs_prop_get_int(zhp, ZFS_PROP_CANMOUNT))
289 		return (B_FALSE);
290 
291 	if (zfs_prop_get_int(zhp, ZFS_PROP_ZONED) &&
292 	    getzoneid() == GLOBAL_ZONEID)
293 		return (B_FALSE);
294 
295 	if (source)
296 		*source = sourcetype;
297 
298 	return (B_TRUE);
299 }
300 
301 /*
302  * Mount the given filesystem.
303  */
304 int
305 zfs_mount(zfs_handle_t *zhp, const char *options, int flags)
306 {
307 	struct stat buf;
308 	char mountpoint[ZFS_MAXPROPLEN];
309 	char mntopts[MNT_LINE_MAX];
310 	libzfs_handle_t *hdl = zhp->zfs_hdl;
311 
312 	if (options == NULL)
313 		mntopts[0] = '\0';
314 	else
315 		(void) strlcpy(mntopts, options, sizeof (mntopts));
316 
317 	if (!zfs_is_mountable(zhp, mountpoint, sizeof (mountpoint), NULL))
318 		return (0);
319 
320 	/* Create the directory if it doesn't already exist */
321 	if (lstat(mountpoint, &buf) != 0) {
322 		if (mkdirp(mountpoint, 0755) != 0) {
323 			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
324 			    "failed to create mountpoint"));
325 			return (zfs_error_fmt(hdl, EZFS_MOUNTFAILED,
326 			    dgettext(TEXT_DOMAIN, "cannot mount '%s'"),
327 			    mountpoint));
328 		}
329 	}
330 
331 	/*
332 	 * Determine if the mountpoint is empty.  If so, refuse to perform the
333 	 * mount.  We don't perform this check if MS_OVERLAY is specified, which
334 	 * would defeat the point.  We also avoid this check if 'remount' is
335 	 * specified.
336 	 */
337 	if ((flags & MS_OVERLAY) == 0 &&
338 	    strstr(mntopts, MNTOPT_REMOUNT) == NULL &&
339 	    !dir_is_empty(mountpoint)) {
340 		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
341 		    "directory is not empty"));
342 		return (zfs_error_fmt(hdl, EZFS_MOUNTFAILED,
343 		    dgettext(TEXT_DOMAIN, "cannot mount '%s'"), mountpoint));
344 	}
345 
346 	/* perform the mount */
347 	if (mount(zfs_get_name(zhp), mountpoint, MS_OPTIONSTR | flags,
348 	    MNTTYPE_ZFS, NULL, 0, mntopts, sizeof (mntopts)) != 0) {
349 		/*
350 		 * Generic errors are nasty, but there are just way too many
351 		 * from mount(), and they're well-understood.  We pick a few
352 		 * common ones to improve upon.
353 		 */
354 		if (errno == EBUSY) {
355 			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
356 			    "mountpoint or dataset is busy"));
357 		} else if (errno == EPERM) {
358 			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
359 			    "Insufficient privileges"));
360 		} else {
361 			zfs_error_aux(hdl, strerror(errno));
362 		}
363 
364 		return (zfs_error_fmt(hdl, EZFS_MOUNTFAILED,
365 		    dgettext(TEXT_DOMAIN, "cannot mount '%s'"),
366 		    zhp->zfs_name));
367 	}
368 
369 	return (0);
370 }
371 
372 /*
373  * Unmount a single filesystem.
374  */
375 static int
376 unmount_one(libzfs_handle_t *hdl, const char *mountpoint, int flags)
377 {
378 	if (umount2(mountpoint, flags) != 0) {
379 		zfs_error_aux(hdl, strerror(errno));
380 		return (zfs_error_fmt(hdl, EZFS_UMOUNTFAILED,
381 		    dgettext(TEXT_DOMAIN, "cannot unmount '%s'"),
382 		    mountpoint));
383 	}
384 
385 	return (0);
386 }
387 
388 /*
389  * Unmount the given filesystem.
390  */
391 int
392 zfs_unmount(zfs_handle_t *zhp, const char *mountpoint, int flags)
393 {
394 	struct mnttab search = { 0 }, entry;
395 	char *mntpt = NULL;
396 
397 	/* check to see if need to unmount the filesystem */
398 	search.mnt_special = zhp->zfs_name;
399 	search.mnt_fstype = MNTTYPE_ZFS;
400 	rewind(zhp->zfs_hdl->libzfs_mnttab);
401 	if (mountpoint != NULL || ((zfs_get_type(zhp) == ZFS_TYPE_FILESYSTEM) &&
402 	    getmntany(zhp->zfs_hdl->libzfs_mnttab, &entry, &search) == 0)) {
403 
404 		/*
405 		 * mountpoint may have come from a call to
406 		 * getmnt/getmntany if it isn't NULL. If it is NULL,
407 		 * we know it comes from getmntany which can then get
408 		 * overwritten later. We strdup it to play it safe.
409 		 */
410 		if (mountpoint == NULL)
411 			mntpt = zfs_strdup(zhp->zfs_hdl, entry.mnt_mountp);
412 		else
413 			mntpt = zfs_strdup(zhp->zfs_hdl, mountpoint);
414 
415 		/*
416 		 * Unshare and unmount the filesystem
417 		 */
418 		if (zfs_unshare_proto(zhp, mntpt, share_all_proto) != 0)
419 			return (-1);
420 
421 		if (unmount_one(zhp->zfs_hdl, mntpt, flags) != 0) {
422 			free(mntpt);
423 			(void) zfs_shareall(zhp);
424 			return (-1);
425 		}
426 		free(mntpt);
427 	}
428 
429 	return (0);
430 }
431 
432 /*
433  * Unmount this filesystem and any children inheriting the mountpoint property.
434  * To do this, just act like we're changing the mountpoint property, but don't
435  * remount the filesystems afterwards.
436  */
437 int
438 zfs_unmountall(zfs_handle_t *zhp, int flags)
439 {
440 	prop_changelist_t *clp;
441 	int ret;
442 
443 	clp = changelist_gather(zhp, ZFS_PROP_MOUNTPOINT, flags);
444 	if (clp == NULL)
445 		return (-1);
446 
447 	ret = changelist_prefix(clp);
448 	changelist_free(clp);
449 
450 	return (ret);
451 }
452 
453 boolean_t
454 zfs_is_shared(zfs_handle_t *zhp)
455 {
456 	zfs_share_type_t rc = 0;
457 	zfs_share_proto_t *curr_proto;
458 
459 	if (ZFS_IS_VOLUME(zhp))
460 		return (zfs_is_shared_iscsi(zhp));
461 
462 	for (curr_proto = share_all_proto; *curr_proto != PROTO_END;
463 	    curr_proto++)
464 		rc |= zfs_is_shared_proto(zhp, NULL, *curr_proto);
465 
466 	return (rc ? B_TRUE : B_FALSE);
467 }
468 
469 int
470 zfs_share(zfs_handle_t *zhp)
471 {
472 	if (ZFS_IS_VOLUME(zhp))
473 		return (zfs_share_iscsi(zhp));
474 
475 	return (zfs_share_proto(zhp, share_all_proto));
476 }
477 
478 int
479 zfs_unshare(zfs_handle_t *zhp)
480 {
481 	if (ZFS_IS_VOLUME(zhp))
482 		return (zfs_unshare_iscsi(zhp));
483 
484 	return (zfs_unshareall(zhp));
485 }
486 
487 /*
488  * Check to see if the filesystem is currently shared.
489  */
490 zfs_share_type_t
491 zfs_is_shared_proto(zfs_handle_t *zhp, char **where, zfs_share_proto_t proto)
492 {
493 	char *mountpoint;
494 	zfs_share_type_t rc;
495 
496 	if (!zfs_is_mounted(zhp, &mountpoint))
497 		return (SHARED_NOT_SHARED);
498 
499 	if (rc = is_shared(zhp->zfs_hdl, mountpoint, proto)) {
500 		if (where != NULL)
501 			*where = mountpoint;
502 		else
503 			free(mountpoint);
504 		return (rc);
505 	} else {
506 		free(mountpoint);
507 		return (SHARED_NOT_SHARED);
508 	}
509 }
510 
511 boolean_t
512 zfs_is_shared_nfs(zfs_handle_t *zhp, char **where)
513 {
514 	return (zfs_is_shared_proto(zhp, where,
515 	    PROTO_NFS) != SHARED_NOT_SHARED);
516 }
517 
518 boolean_t
519 zfs_is_shared_smb(zfs_handle_t *zhp, char **where)
520 {
521 	return (zfs_is_shared_proto(zhp, where,
522 	    PROTO_SMB) != SHARED_NOT_SHARED);
523 }
524 
525 /*
526  * Make sure things will work if libshare isn't installed by using
527  * wrapper functions that check to see that the pointers to functions
528  * initialized in _zfs_init_libshare() are actually present.
529  */
530 
531 static sa_handle_t (*_sa_init)(int);
532 static void (*_sa_fini)(sa_handle_t);
533 static sa_share_t (*_sa_find_share)(sa_handle_t, char *);
534 static int (*_sa_enable_share)(sa_share_t, char *);
535 static int (*_sa_disable_share)(sa_share_t, char *);
536 static char *(*_sa_errorstr)(int);
537 static int (*_sa_parse_legacy_options)(sa_group_t, char *, char *);
538 static boolean_t (*_sa_needs_refresh)(sa_handle_t *);
539 static libzfs_handle_t *(*_sa_get_zfs_handle)(sa_handle_t);
540 static int (*_sa_zfs_process_share)(sa_handle_t, sa_group_t, sa_share_t,
541     char *, char *, zprop_source_t, char *, char *, char *);
542 static void (*_sa_update_sharetab_ts)(sa_handle_t);
543 
544 /*
545  * _zfs_init_libshare()
546  *
547  * Find the libshare.so.1 entry points that we use here and save the
548  * values to be used later. This is triggered by the runtime loader.
549  * Make sure the correct ISA version is loaded.
550  */
551 
552 #pragma init(_zfs_init_libshare)
553 static void
554 _zfs_init_libshare(void)
555 {
556 	void *libshare;
557 	char path[MAXPATHLEN];
558 	char isa[MAXISALEN];
559 
560 #if defined(_LP64)
561 	if (sysinfo(SI_ARCHITECTURE_64, isa, MAXISALEN) == -1)
562 		isa[0] = '\0';
563 #else
564 	isa[0] = '\0';
565 #endif
566 	(void) snprintf(path, MAXPATHLEN,
567 	    "/usr/lib/%s/libshare.so.1", isa);
568 
569 	if ((libshare = dlopen(path, RTLD_LAZY | RTLD_GLOBAL)) != NULL) {
570 		_sa_init = (sa_handle_t (*)(int))dlsym(libshare, "sa_init");
571 		_sa_fini = (void (*)(sa_handle_t))dlsym(libshare, "sa_fini");
572 		_sa_find_share = (sa_share_t (*)(sa_handle_t, char *))
573 		    dlsym(libshare, "sa_find_share");
574 		_sa_enable_share = (int (*)(sa_share_t, char *))dlsym(libshare,
575 		    "sa_enable_share");
576 		_sa_disable_share = (int (*)(sa_share_t, char *))dlsym(libshare,
577 		    "sa_disable_share");
578 		_sa_errorstr = (char *(*)(int))dlsym(libshare, "sa_errorstr");
579 		_sa_parse_legacy_options = (int (*)(sa_group_t, char *, char *))
580 		    dlsym(libshare, "sa_parse_legacy_options");
581 		_sa_needs_refresh = (boolean_t (*)(sa_handle_t *))
582 		    dlsym(libshare, "sa_needs_refresh");
583 		_sa_get_zfs_handle = (libzfs_handle_t *(*)(sa_handle_t))
584 		    dlsym(libshare, "sa_get_zfs_handle");
585 		_sa_zfs_process_share = (int (*)(sa_handle_t, sa_group_t,
586 		    sa_share_t, char *, char *, zprop_source_t, char *,
587 		    char *, char *))dlsym(libshare, "sa_zfs_process_share");
588 		_sa_update_sharetab_ts = (void (*)(sa_handle_t))
589 		    dlsym(libshare, "sa_update_sharetab_ts");
590 		if (_sa_init == NULL || _sa_fini == NULL ||
591 		    _sa_find_share == NULL || _sa_enable_share == NULL ||
592 		    _sa_disable_share == NULL || _sa_errorstr == NULL ||
593 		    _sa_parse_legacy_options == NULL ||
594 		    _sa_needs_refresh == NULL || _sa_get_zfs_handle == NULL ||
595 		    _sa_zfs_process_share == NULL ||
596 		    _sa_update_sharetab_ts == NULL) {
597 			_sa_init = NULL;
598 			_sa_fini = NULL;
599 			_sa_disable_share = NULL;
600 			_sa_enable_share = NULL;
601 			_sa_errorstr = NULL;
602 			_sa_parse_legacy_options = NULL;
603 			(void) dlclose(libshare);
604 			_sa_needs_refresh = NULL;
605 			_sa_get_zfs_handle = NULL;
606 			_sa_zfs_process_share = NULL;
607 			_sa_update_sharetab_ts = NULL;
608 		}
609 	}
610 }
611 
612 /*
613  * zfs_init_libshare(zhandle, service)
614  *
615  * Initialize the libshare API if it hasn't already been initialized.
616  * In all cases it returns 0 if it succeeded and an error if not. The
617  * service value is which part(s) of the API to initialize and is a
618  * direct map to the libshare sa_init(service) interface.
619  */
620 int
621 zfs_init_libshare(libzfs_handle_t *zhandle, int service)
622 {
623 	int ret = SA_OK;
624 
625 	if (_sa_init == NULL)
626 		ret = SA_CONFIG_ERR;
627 
628 	if (ret == SA_OK && zhandle->libzfs_shareflags & ZFSSHARE_MISS) {
629 		/*
630 		 * We had a cache miss. Most likely it is a new ZFS
631 		 * dataset that was just created. We want to make sure
632 		 * so check timestamps to see if a different process
633 		 * has updated any of the configuration. If there was
634 		 * some non-ZFS change, we need to re-initialize the
635 		 * internal cache.
636 		 */
637 		zhandle->libzfs_shareflags &= ~ZFSSHARE_MISS;
638 		if (_sa_needs_refresh != NULL &&
639 		    _sa_needs_refresh(zhandle->libzfs_sharehdl)) {
640 			zfs_uninit_libshare(zhandle);
641 			zhandle->libzfs_sharehdl = _sa_init(service);
642 		}
643 	}
644 
645 	if (ret == SA_OK && zhandle && zhandle->libzfs_sharehdl == NULL)
646 		zhandle->libzfs_sharehdl = _sa_init(service);
647 
648 	if (ret == SA_OK && zhandle->libzfs_sharehdl == NULL)
649 		ret = SA_NO_MEMORY;
650 
651 	return (ret);
652 }
653 
654 /*
655  * zfs_uninit_libshare(zhandle)
656  *
657  * Uninitialize the libshare API if it hasn't already been
658  * uninitialized. It is OK to call multiple times.
659  */
660 void
661 zfs_uninit_libshare(libzfs_handle_t *zhandle)
662 {
663 	if (zhandle != NULL && zhandle->libzfs_sharehdl != NULL) {
664 		if (_sa_fini != NULL)
665 			_sa_fini(zhandle->libzfs_sharehdl);
666 		zhandle->libzfs_sharehdl = NULL;
667 	}
668 }
669 
670 /*
671  * zfs_parse_options(options, proto)
672  *
673  * Call the legacy parse interface to get the protocol specific
674  * options using the NULL arg to indicate that this is a "parse" only.
675  */
676 int
677 zfs_parse_options(char *options, zfs_share_proto_t proto)
678 {
679 	if (_sa_parse_legacy_options != NULL) {
680 		return (_sa_parse_legacy_options(NULL, options,
681 		    proto_table[proto].p_name));
682 	}
683 	return (SA_CONFIG_ERR);
684 }
685 
686 /*
687  * zfs_sa_find_share(handle, path)
688  *
689  * wrapper around sa_find_share to find a share path in the
690  * configuration.
691  */
692 static sa_share_t
693 zfs_sa_find_share(sa_handle_t handle, char *path)
694 {
695 	if (_sa_find_share != NULL)
696 		return (_sa_find_share(handle, path));
697 	return (NULL);
698 }
699 
700 /*
701  * zfs_sa_enable_share(share, proto)
702  *
703  * Wrapper for sa_enable_share which enables a share for a specified
704  * protocol.
705  */
706 static int
707 zfs_sa_enable_share(sa_share_t share, char *proto)
708 {
709 	if (_sa_enable_share != NULL)
710 		return (_sa_enable_share(share, proto));
711 	return (SA_CONFIG_ERR);
712 }
713 
714 /*
715  * zfs_sa_disable_share(share, proto)
716  *
717  * Wrapper for sa_enable_share which disables a share for a specified
718  * protocol.
719  */
720 static int
721 zfs_sa_disable_share(sa_share_t share, char *proto)
722 {
723 	if (_sa_disable_share != NULL)
724 		return (_sa_disable_share(share, proto));
725 	return (SA_CONFIG_ERR);
726 }
727 
728 /*
729  * Share the given filesystem according to the options in the specified
730  * protocol specific properties (sharenfs, sharesmb).  We rely
731  * on "libshare" to the dirty work for us.
732  */
733 static int
734 zfs_share_proto(zfs_handle_t *zhp, zfs_share_proto_t *proto)
735 {
736 	char mountpoint[ZFS_MAXPROPLEN];
737 	char shareopts[ZFS_MAXPROPLEN];
738 	char sourcestr[ZFS_MAXPROPLEN];
739 	libzfs_handle_t *hdl = zhp->zfs_hdl;
740 	sa_share_t share;
741 	zfs_share_proto_t *curr_proto;
742 	zprop_source_t sourcetype;
743 	int ret;
744 
745 	if (!zfs_is_mountable(zhp, mountpoint, sizeof (mountpoint), NULL))
746 		return (0);
747 
748 	if ((ret = zfs_init_libshare(hdl, SA_INIT_SHARE_API)) != SA_OK) {
749 		(void) zfs_error_fmt(hdl, EZFS_SHARENFSFAILED,
750 		    dgettext(TEXT_DOMAIN, "cannot share '%s': %s"),
751 		    zfs_get_name(zhp), _sa_errorstr != NULL ?
752 		    _sa_errorstr(ret) : "");
753 		return (-1);
754 	}
755 
756 	for (curr_proto = proto; *curr_proto != PROTO_END; curr_proto++) {
757 		/*
758 		 * Return success if there are no share options.
759 		 */
760 		if (zfs_prop_get(zhp, proto_table[*curr_proto].p_prop,
761 		    shareopts, sizeof (shareopts), &sourcetype, sourcestr,
762 		    ZFS_MAXPROPLEN, B_FALSE) != 0 ||
763 		    strcmp(shareopts, "off") == 0)
764 			continue;
765 
766 		/*
767 		 * If the 'zoned' property is set, then zfs_is_mountable()
768 		 * will have already bailed out if we are in the global zone.
769 		 * But local zones cannot be NFS servers, so we ignore it for
770 		 * local zones as well.
771 		 */
772 		if (zfs_prop_get_int(zhp, ZFS_PROP_ZONED))
773 			continue;
774 
775 		share = zfs_sa_find_share(hdl->libzfs_sharehdl, mountpoint);
776 		if (share == NULL) {
777 			/*
778 			 * This may be a new file system that was just
779 			 * created so isn't in the internal cache
780 			 * (second time through). Rather than
781 			 * reloading the entire configuration, we can
782 			 * assume ZFS has done the checking and it is
783 			 * safe to add this to the internal
784 			 * configuration.
785 			 */
786 			if (_sa_zfs_process_share(hdl->libzfs_sharehdl,
787 			    NULL, NULL, mountpoint,
788 			    proto_table[*curr_proto].p_name, sourcetype,
789 			    shareopts, sourcestr, zhp->zfs_name) != SA_OK) {
790 				(void) zfs_error_fmt(hdl,
791 				    proto_table[*curr_proto].p_share_err,
792 				    dgettext(TEXT_DOMAIN, "cannot share '%s'"),
793 				    zfs_get_name(zhp));
794 				return (-1);
795 			}
796 			hdl->libzfs_shareflags |= ZFSSHARE_MISS;
797 			share = zfs_sa_find_share(hdl->libzfs_sharehdl,
798 			    mountpoint);
799 		}
800 		if (share != NULL) {
801 			int err;
802 			err = zfs_sa_enable_share(share,
803 			    proto_table[*curr_proto].p_name);
804 			if (err != SA_OK) {
805 				(void) zfs_error_fmt(hdl,
806 				    proto_table[*curr_proto].p_share_err,
807 				    dgettext(TEXT_DOMAIN, "cannot share '%s'"),
808 				    zfs_get_name(zhp));
809 				return (-1);
810 			}
811 		} else {
812 			(void) zfs_error_fmt(hdl,
813 			    proto_table[*curr_proto].p_share_err,
814 			    dgettext(TEXT_DOMAIN, "cannot share '%s'"),
815 			    zfs_get_name(zhp));
816 			return (-1);
817 		}
818 
819 	}
820 	return (0);
821 }
822 
823 
824 int
825 zfs_share_nfs(zfs_handle_t *zhp)
826 {
827 	return (zfs_share_proto(zhp, nfs_only));
828 }
829 
830 int
831 zfs_share_smb(zfs_handle_t *zhp)
832 {
833 	return (zfs_share_proto(zhp, smb_only));
834 }
835 
836 int
837 zfs_shareall(zfs_handle_t *zhp)
838 {
839 	return (zfs_share_proto(zhp, share_all_proto));
840 }
841 
842 /*
843  * Unshare a filesystem by mountpoint.
844  */
845 static int
846 unshare_one(libzfs_handle_t *hdl, const char *name, const char *mountpoint,
847     zfs_share_proto_t proto)
848 {
849 	sa_share_t share;
850 	int err;
851 	char *mntpt;
852 	/*
853 	 * Mountpoint could get trashed if libshare calls getmntany
854 	 * which id does during API initialization, so strdup the
855 	 * value.
856 	 */
857 	mntpt = zfs_strdup(hdl, mountpoint);
858 
859 	/* make sure libshare initialized */
860 	if ((err = zfs_init_libshare(hdl, SA_INIT_SHARE_API)) != SA_OK) {
861 		free(mntpt);	/* don't need the copy anymore */
862 		return (zfs_error_fmt(hdl, EZFS_SHARENFSFAILED,
863 		    dgettext(TEXT_DOMAIN, "cannot unshare '%s': %s"),
864 		    name, _sa_errorstr(err)));
865 	}
866 
867 	share = zfs_sa_find_share(hdl->libzfs_sharehdl, mntpt);
868 	free(mntpt);	/* don't need the copy anymore */
869 
870 	if (share != NULL) {
871 		err = zfs_sa_disable_share(share, proto_table[proto].p_name);
872 		if (err != SA_OK) {
873 			return (zfs_error_fmt(hdl, EZFS_UNSHARENFSFAILED,
874 			    dgettext(TEXT_DOMAIN, "cannot unshare '%s': %s"),
875 			    name, _sa_errorstr(err)));
876 		}
877 	} else {
878 		return (zfs_error_fmt(hdl, EZFS_UNSHARENFSFAILED,
879 		    dgettext(TEXT_DOMAIN, "cannot unshare '%s': not found"),
880 		    name));
881 	}
882 	return (0);
883 }
884 
885 /*
886  * Unshare the given filesystem.
887  */
888 int
889 zfs_unshare_proto(zfs_handle_t *zhp, const char *mountpoint,
890     zfs_share_proto_t *proto)
891 {
892 	struct mnttab search = { 0 }, entry;
893 	char *mntpt = NULL;
894 
895 	/* check to see if need to unmount the filesystem */
896 	search.mnt_special = (char *)zfs_get_name(zhp);
897 	search.mnt_fstype = MNTTYPE_ZFS;
898 	rewind(zhp->zfs_hdl->libzfs_mnttab);
899 	if (mountpoint != NULL)
900 		mntpt = zfs_strdup(zhp->zfs_hdl, mountpoint);
901 
902 	if (mountpoint != NULL || ((zfs_get_type(zhp) == ZFS_TYPE_FILESYSTEM) &&
903 	    getmntany(zhp->zfs_hdl->libzfs_mnttab, &entry, &search) == 0)) {
904 		zfs_share_proto_t *curr_proto;
905 
906 		if (mountpoint == NULL)
907 			mntpt = zfs_strdup(zhp->zfs_hdl, entry.mnt_mountp);
908 
909 		for (curr_proto = proto; *curr_proto != PROTO_END;
910 		    curr_proto++) {
911 
912 			if (is_shared(zhp->zfs_hdl, mntpt, *curr_proto) &&
913 			    unshare_one(zhp->zfs_hdl, zhp->zfs_name,
914 			    mntpt, *curr_proto) != 0) {
915 				if (mntpt != NULL)
916 					free(mntpt);
917 				return (-1);
918 			}
919 		}
920 	}
921 	if (mntpt != NULL)
922 		free(mntpt);
923 
924 	return (0);
925 }
926 
927 int
928 zfs_unshare_nfs(zfs_handle_t *zhp, const char *mountpoint)
929 {
930 	return (zfs_unshare_proto(zhp, mountpoint, nfs_only));
931 }
932 
933 int
934 zfs_unshare_smb(zfs_handle_t *zhp, const char *mountpoint)
935 {
936 	return (zfs_unshare_proto(zhp, mountpoint, smb_only));
937 }
938 
939 /*
940  * Same as zfs_unmountall(), but for NFS and SMB unshares.
941  */
942 int
943 zfs_unshareall_proto(zfs_handle_t *zhp, zfs_share_proto_t *proto)
944 {
945 	prop_changelist_t *clp;
946 	int ret;
947 
948 	clp = changelist_gather(zhp, ZFS_PROP_SHARENFS, 0);
949 	if (clp == NULL)
950 		return (-1);
951 
952 	ret = changelist_unshare(clp, proto);
953 	changelist_free(clp);
954 
955 	return (ret);
956 }
957 
958 int
959 zfs_unshareall_nfs(zfs_handle_t *zhp)
960 {
961 	return (zfs_unshareall_proto(zhp, nfs_only));
962 }
963 
964 int
965 zfs_unshareall_smb(zfs_handle_t *zhp)
966 {
967 	return (zfs_unshareall_proto(zhp, smb_only));
968 }
969 
970 int
971 zfs_unshareall(zfs_handle_t *zhp)
972 {
973 	return (zfs_unshareall_proto(zhp, share_all_proto));
974 }
975 
976 int
977 zfs_unshareall_bypath(zfs_handle_t *zhp, const char *mountpoint)
978 {
979 	return (zfs_unshare_proto(zhp, mountpoint, share_all_proto));
980 }
981 
982 /*
983  * Remove the mountpoint associated with the current dataset, if necessary.
984  * We only remove the underlying directory if:
985  *
986  *	- The mountpoint is not 'none' or 'legacy'
987  *	- The mountpoint is non-empty
988  *	- The mountpoint is the default or inherited
989  *	- The 'zoned' property is set, or we're in a local zone
990  *
991  * Any other directories we leave alone.
992  */
993 void
994 remove_mountpoint(zfs_handle_t *zhp)
995 {
996 	char mountpoint[ZFS_MAXPROPLEN];
997 	zprop_source_t source;
998 
999 	if (!zfs_is_mountable(zhp, mountpoint, sizeof (mountpoint),
1000 	    &source))
1001 		return;
1002 
1003 	if (source == ZPROP_SRC_DEFAULT ||
1004 	    source == ZPROP_SRC_INHERITED) {
1005 		/*
1006 		 * Try to remove the directory, silently ignoring any errors.
1007 		 * The filesystem may have since been removed or moved around,
1008 		 * and this error isn't really useful to the administrator in
1009 		 * any way.
1010 		 */
1011 		(void) rmdir(mountpoint);
1012 	}
1013 }
1014 
1015 boolean_t
1016 zfs_is_shared_iscsi(zfs_handle_t *zhp)
1017 {
1018 
1019 	/*
1020 	 * If iscsi deamon isn't running then we aren't shared
1021 	 */
1022 	if (iscsitgt_svc_online && iscsitgt_svc_online() == 1)
1023 		return (B_FALSE);
1024 	else
1025 		return (iscsitgt_zfs_is_shared != NULL &&
1026 		    iscsitgt_zfs_is_shared(zhp->zfs_name) != 0);
1027 }
1028 
1029 int
1030 zfs_share_iscsi(zfs_handle_t *zhp)
1031 {
1032 	char shareopts[ZFS_MAXPROPLEN];
1033 	const char *dataset = zhp->zfs_name;
1034 	libzfs_handle_t *hdl = zhp->zfs_hdl;
1035 
1036 	/*
1037 	 * Return success if there are no share options.
1038 	 */
1039 	if (zfs_prop_get(zhp, ZFS_PROP_SHAREISCSI, shareopts,
1040 	    sizeof (shareopts), NULL, NULL, 0, B_FALSE) != 0 ||
1041 	    strcmp(shareopts, "off") == 0)
1042 		return (0);
1043 
1044 	if (iscsitgt_zfs_share == NULL || iscsitgt_zfs_share(dataset) != 0) {
1045 		int error = EZFS_SHAREISCSIFAILED;
1046 
1047 		/*
1048 		 * If service isn't availabele and EPERM was
1049 		 * returned then use special error.
1050 		 */
1051 		if (iscsitgt_svc_online && errno == EPERM &&
1052 		    (iscsitgt_svc_online() != 0))
1053 			error = EZFS_ISCSISVCUNAVAIL;
1054 
1055 		return (zfs_error_fmt(hdl, error,
1056 		    dgettext(TEXT_DOMAIN, "cannot share '%s'"), dataset));
1057 	}
1058 
1059 	return (0);
1060 }
1061 
1062 int
1063 zfs_unshare_iscsi(zfs_handle_t *zhp)
1064 {
1065 	const char *dataset = zfs_get_name(zhp);
1066 	libzfs_handle_t *hdl = zhp->zfs_hdl;
1067 
1068 	/*
1069 	 * Return if the volume is not shared
1070 	 */
1071 	if (zfs_is_shared_iscsi(zhp) != SHARED_ISCSI)
1072 		return (0);
1073 
1074 	/*
1075 	 * If this fails with ENODEV it indicates that zvol wasn't shared so
1076 	 * we should return success in that case.
1077 	 */
1078 	if (iscsitgt_zfs_unshare == NULL ||
1079 	    (iscsitgt_zfs_unshare(dataset) != 0 && errno != ENODEV)) {
1080 		if (errno == EPERM)
1081 			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1082 			    "Insufficient privileges to unshare iscsi"));
1083 		return (zfs_error_fmt(hdl, EZFS_UNSHAREISCSIFAILED,
1084 		    dgettext(TEXT_DOMAIN, "cannot unshare '%s'"), dataset));
1085 	}
1086 
1087 	return (0);
1088 }
1089 
1090 typedef struct mount_cbdata {
1091 	zfs_handle_t	**cb_datasets;
1092 	int 		cb_used;
1093 	int		cb_alloc;
1094 } mount_cbdata_t;
1095 
1096 static int
1097 mount_cb(zfs_handle_t *zhp, void *data)
1098 {
1099 	mount_cbdata_t *cbp = data;
1100 
1101 	if (!(zfs_get_type(zhp) & (ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME))) {
1102 		zfs_close(zhp);
1103 		return (0);
1104 	}
1105 
1106 	if (cbp->cb_alloc == cbp->cb_used) {
1107 		void *ptr;
1108 
1109 		if ((ptr = zfs_realloc(zhp->zfs_hdl,
1110 		    cbp->cb_datasets, cbp->cb_alloc * sizeof (void *),
1111 		    cbp->cb_alloc * 2 * sizeof (void *))) == NULL)
1112 			return (-1);
1113 		cbp->cb_datasets = ptr;
1114 
1115 		cbp->cb_alloc *= 2;
1116 	}
1117 
1118 	cbp->cb_datasets[cbp->cb_used++] = zhp;
1119 
1120 	return (zfs_iter_filesystems(zhp, mount_cb, cbp));
1121 }
1122 
1123 static int
1124 dataset_cmp(const void *a, const void *b)
1125 {
1126 	zfs_handle_t **za = (zfs_handle_t **)a;
1127 	zfs_handle_t **zb = (zfs_handle_t **)b;
1128 	char mounta[MAXPATHLEN];
1129 	char mountb[MAXPATHLEN];
1130 	boolean_t gota, gotb;
1131 
1132 	if ((gota = (zfs_get_type(*za) == ZFS_TYPE_FILESYSTEM)) != 0)
1133 		verify(zfs_prop_get(*za, ZFS_PROP_MOUNTPOINT, mounta,
1134 		    sizeof (mounta), NULL, NULL, 0, B_FALSE) == 0);
1135 	if ((gotb = (zfs_get_type(*zb) == ZFS_TYPE_FILESYSTEM)) != 0)
1136 		verify(zfs_prop_get(*zb, ZFS_PROP_MOUNTPOINT, mountb,
1137 		    sizeof (mountb), NULL, NULL, 0, B_FALSE) == 0);
1138 
1139 	if (gota && gotb)
1140 		return (strcmp(mounta, mountb));
1141 
1142 	if (gota)
1143 		return (-1);
1144 	if (gotb)
1145 		return (1);
1146 
1147 	return (strcmp(zfs_get_name(a), zfs_get_name(b)));
1148 }
1149 
1150 /*
1151  * Mount and share all datasets within the given pool.  This assumes that no
1152  * datasets within the pool are currently mounted.  Because users can create
1153  * complicated nested hierarchies of mountpoints, we first gather all the
1154  * datasets and mountpoints within the pool, and sort them by mountpoint.  Once
1155  * we have the list of all filesystems, we iterate over them in order and mount
1156  * and/or share each one.
1157  */
1158 #pragma weak zpool_mount_datasets = zpool_enable_datasets
1159 int
1160 zpool_enable_datasets(zpool_handle_t *zhp, const char *mntopts, int flags)
1161 {
1162 	mount_cbdata_t cb = { 0 };
1163 	libzfs_handle_t *hdl = zhp->zpool_hdl;
1164 	zfs_handle_t *zfsp;
1165 	int i, ret = -1;
1166 	int *good;
1167 
1168 	/*
1169 	 * Gather all non-snap datasets within the pool.
1170 	 */
1171 	if ((cb.cb_datasets = zfs_alloc(hdl, 4 * sizeof (void *))) == NULL)
1172 		return (-1);
1173 	cb.cb_alloc = 4;
1174 
1175 	if ((zfsp = zfs_open(hdl, zhp->zpool_name, ZFS_TYPE_DATASET)) == NULL)
1176 		goto out;
1177 
1178 	cb.cb_datasets[0] = zfsp;
1179 	cb.cb_used = 1;
1180 
1181 	if (zfs_iter_filesystems(zfsp, mount_cb, &cb) != 0)
1182 		goto out;
1183 
1184 	/*
1185 	 * Sort the datasets by mountpoint.
1186 	 */
1187 	qsort(cb.cb_datasets, cb.cb_used, sizeof (void *), dataset_cmp);
1188 
1189 	/*
1190 	 * And mount all the datasets, keeping track of which ones
1191 	 * succeeded or failed. By using zfs_alloc(), the good pointer
1192 	 * will always be non-NULL.
1193 	 */
1194 	good = zfs_alloc(zhp->zpool_hdl, cb.cb_used * sizeof (int));
1195 	ret = 0;
1196 	for (i = 0; i < cb.cb_used; i++) {
1197 		if (zfs_mount(cb.cb_datasets[i], mntopts, flags) != 0)
1198 			ret = -1;
1199 		else
1200 			good[i] = 1;
1201 	}
1202 
1203 	/*
1204 	 * Then share all the ones that need to be shared. This needs
1205 	 * to be a separate pass in order to avoid excessive reloading
1206 	 * of the configuration. Good should never be NULL since
1207 	 * zfs_alloc is supposed to exit if memory isn't available.
1208 	 */
1209 	for (i = 0; i < cb.cb_used; i++) {
1210 		if (good[i] && zfs_share(cb.cb_datasets[i]) != 0)
1211 			ret = -1;
1212 	}
1213 
1214 	free(good);
1215 
1216 out:
1217 	for (i = 0; i < cb.cb_used; i++)
1218 		zfs_close(cb.cb_datasets[i]);
1219 	free(cb.cb_datasets);
1220 
1221 	return (ret);
1222 }
1223 
1224 
1225 static int
1226 zvol_cb(const char *dataset, void *data)
1227 {
1228 	libzfs_handle_t *hdl = data;
1229 	zfs_handle_t *zhp;
1230 
1231 	/*
1232 	 * Ignore snapshots and ignore failures from non-existant datasets.
1233 	 */
1234 	if (strchr(dataset, '@') != NULL ||
1235 	    (zhp = zfs_open(hdl, dataset, ZFS_TYPE_VOLUME)) == NULL)
1236 		return (0);
1237 
1238 	if (zfs_unshare_iscsi(zhp) != 0)
1239 		return (-1);
1240 
1241 	zfs_close(zhp);
1242 
1243 	return (0);
1244 }
1245 
1246 static int
1247 mountpoint_compare(const void *a, const void *b)
1248 {
1249 	const char *mounta = *((char **)a);
1250 	const char *mountb = *((char **)b);
1251 
1252 	return (strcmp(mountb, mounta));
1253 }
1254 
1255 /*
1256  * Unshare and unmount all datasets within the given pool.  We don't want to
1257  * rely on traversing the DSL to discover the filesystems within the pool,
1258  * because this may be expensive (if not all of them are mounted), and can fail
1259  * arbitrarily (on I/O error, for example).  Instead, we walk /etc/mnttab and
1260  * gather all the filesystems that are currently mounted.
1261  */
1262 #pragma weak zpool_unmount_datasets = zpool_disable_datasets
1263 int
1264 zpool_disable_datasets(zpool_handle_t *zhp, boolean_t force)
1265 {
1266 	int used, alloc;
1267 	struct mnttab entry;
1268 	size_t namelen;
1269 	char **mountpoints = NULL;
1270 	zfs_handle_t **datasets = NULL;
1271 	libzfs_handle_t *hdl = zhp->zpool_hdl;
1272 	int i;
1273 	int ret = -1;
1274 	int flags = (force ? MS_FORCE : 0);
1275 
1276 	/*
1277 	 * First unshare all zvols.
1278 	 */
1279 	if (zpool_iter_zvol(zhp, zvol_cb, hdl) != 0)
1280 		return (-1);
1281 
1282 	namelen = strlen(zhp->zpool_name);
1283 
1284 	rewind(hdl->libzfs_mnttab);
1285 	used = alloc = 0;
1286 	while (getmntent(hdl->libzfs_mnttab, &entry) == 0) {
1287 		/*
1288 		 * Ignore non-ZFS entries.
1289 		 */
1290 		if (entry.mnt_fstype == NULL ||
1291 		    strcmp(entry.mnt_fstype, MNTTYPE_ZFS) != 0)
1292 			continue;
1293 
1294 		/*
1295 		 * Ignore filesystems not within this pool.
1296 		 */
1297 		if (entry.mnt_mountp == NULL ||
1298 		    strncmp(entry.mnt_special, zhp->zpool_name, namelen) != 0 ||
1299 		    (entry.mnt_special[namelen] != '/' &&
1300 		    entry.mnt_special[namelen] != '\0'))
1301 			continue;
1302 
1303 		/*
1304 		 * At this point we've found a filesystem within our pool.  Add
1305 		 * it to our growing list.
1306 		 */
1307 		if (used == alloc) {
1308 			if (alloc == 0) {
1309 				if ((mountpoints = zfs_alloc(hdl,
1310 				    8 * sizeof (void *))) == NULL)
1311 					goto out;
1312 
1313 				if ((datasets = zfs_alloc(hdl,
1314 				    8 * sizeof (void *))) == NULL)
1315 					goto out;
1316 
1317 				alloc = 8;
1318 			} else {
1319 				void *ptr;
1320 
1321 				if ((ptr = zfs_realloc(hdl, mountpoints,
1322 				    alloc * sizeof (void *),
1323 				    alloc * 2 * sizeof (void *))) == NULL)
1324 					goto out;
1325 				mountpoints = ptr;
1326 
1327 				if ((ptr = zfs_realloc(hdl, datasets,
1328 				    alloc * sizeof (void *),
1329 				    alloc * 2 * sizeof (void *))) == NULL)
1330 					goto out;
1331 				datasets = ptr;
1332 
1333 				alloc *= 2;
1334 			}
1335 		}
1336 
1337 		if ((mountpoints[used] = zfs_strdup(hdl,
1338 		    entry.mnt_mountp)) == NULL)
1339 			goto out;
1340 
1341 		/*
1342 		 * This is allowed to fail, in case there is some I/O error.  It
1343 		 * is only used to determine if we need to remove the underlying
1344 		 * mountpoint, so failure is not fatal.
1345 		 */
1346 		datasets[used] = make_dataset_handle(hdl, entry.mnt_special);
1347 
1348 		used++;
1349 	}
1350 
1351 	/*
1352 	 * At this point, we have the entire list of filesystems, so sort it by
1353 	 * mountpoint.
1354 	 */
1355 	qsort(mountpoints, used, sizeof (char *), mountpoint_compare);
1356 
1357 	/*
1358 	 * Walk through and first unshare everything.
1359 	 */
1360 	for (i = 0; i < used; i++) {
1361 		zfs_share_proto_t *curr_proto;
1362 		for (curr_proto = share_all_proto; *curr_proto != PROTO_END;
1363 		    curr_proto++) {
1364 			if (is_shared(hdl, mountpoints[i], *curr_proto) &&
1365 			    unshare_one(hdl, mountpoints[i],
1366 			    mountpoints[i], *curr_proto) != 0)
1367 				goto out;
1368 		}
1369 	}
1370 
1371 	/*
1372 	 * Now unmount everything, removing the underlying directories as
1373 	 * appropriate.
1374 	 */
1375 	for (i = 0; i < used; i++) {
1376 		if (unmount_one(hdl, mountpoints[i], flags) != 0)
1377 			goto out;
1378 	}
1379 
1380 	for (i = 0; i < used; i++) {
1381 		if (datasets[i])
1382 			remove_mountpoint(datasets[i]);
1383 	}
1384 
1385 	ret = 0;
1386 out:
1387 	for (i = 0; i < used; i++) {
1388 		if (datasets[i])
1389 			zfs_close(datasets[i]);
1390 		free(mountpoints[i]);
1391 	}
1392 	free(datasets);
1393 	free(mountpoints);
1394 
1395 	return (ret);
1396 }
1397