1fa9e4066Sahrens /*
2fa9e4066Sahrens * CDDL HEADER START
3fa9e4066Sahrens *
4fa9e4066Sahrens * The contents of this file are subject to the terms of the
5ea8dc4b6Seschrock * Common Development and Distribution License (the "License").
6ea8dc4b6Seschrock * You may not use this file except in compliance with the License.
7fa9e4066Sahrens *
8fa9e4066Sahrens * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9fa9e4066Sahrens * or http://www.opensolaris.org/os/licensing.
10fa9e4066Sahrens * See the License for the specific language governing permissions
11fa9e4066Sahrens * and limitations under the License.
12fa9e4066Sahrens *
13fa9e4066Sahrens * When distributing Covered Code, include this CDDL HEADER in each
14fa9e4066Sahrens * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15fa9e4066Sahrens * If applicable, add the following below this CDDL HEADER, with the
16fa9e4066Sahrens * fields enclosed by brackets "[]" replaced with your own identifying
17fa9e4066Sahrens * information: Portions Copyright [yyyy] [name of copyright owner]
18fa9e4066Sahrens *
19fa9e4066Sahrens * CDDL HEADER END
20fa9e4066Sahrens */
21f3861e1aSahl
22fa9e4066Sahrens /*
23dc7cd546SMark Shellenbaum * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
24fb41d494SMatthew Ahrens * Copyright (c) 2014 by Delphix. All rights reserved.
25fa9e4066Sahrens */
26fa9e4066Sahrens
27fa9e4066Sahrens /*
28fa9e4066Sahrens * Routines to manage ZFS mounts. We separate all the nasty routines that have
29f3861e1aSahl * to deal with the OS. The following functions are the main entry points --
30f3861e1aSahl * they are used by mount and unmount and when changing a filesystem's
31f3861e1aSahl * mountpoint.
32fa9e4066Sahrens *
33fa9e4066Sahrens * zfs_is_mounted()
34fa9e4066Sahrens * zfs_mount()
35fa9e4066Sahrens * zfs_unmount()
36fa9e4066Sahrens * zfs_unmountall()
37fa9e4066Sahrens *
38f3861e1aSahl * This file also contains the functions used to manage sharing filesystems via
39f3861e1aSahl * NFS and iSCSI:
40fa9e4066Sahrens *
41fa9e4066Sahrens * zfs_is_shared()
42fa9e4066Sahrens * zfs_share()
43fa9e4066Sahrens * zfs_unshare()
44f3861e1aSahl *
45f3861e1aSahl * zfs_is_shared_nfs()
46da6c28aaSamw * zfs_is_shared_smb()
47da6c28aaSamw * zfs_share_proto()
48da6c28aaSamw * zfs_shareall();
49da6c28aaSamw * zfs_unshare_nfs()
50da6c28aaSamw * zfs_unshare_smb()
51da6c28aaSamw * zfs_unshareall_nfs()
52da6c28aaSamw * zfs_unshareall_smb()
53da6c28aaSamw * zfs_unshareall()
54da6c28aaSamw * zfs_unshareall_bypath()
553bb79becSeschrock *
563bb79becSeschrock * The following functions are available for pool consumers, and will
57f3861e1aSahl * mount/unmount and share/unshare all datasets within pool:
583bb79becSeschrock *
59f3861e1aSahl * zpool_enable_datasets()
60f3861e1aSahl * zpool_disable_datasets()
61fa9e4066Sahrens */
62fa9e4066Sahrens
63fa9e4066Sahrens #include <dirent.h>
64d8d59944Sahl #include <dlfcn.h>
65fa9e4066Sahrens #include <errno.h>
66fa9e4066Sahrens #include <libgen.h>
67fa9e4066Sahrens #include <libintl.h>
68fa9e4066Sahrens #include <stdio.h>
69fa9e4066Sahrens #include <stdlib.h>
70fa9e4066Sahrens #include <strings.h>
71fa9e4066Sahrens #include <unistd.h>
72fa9e4066Sahrens #include <zone.h>
73fa9e4066Sahrens #include <sys/mntent.h>
74fa9e4066Sahrens #include <sys/mount.h>
75fa9e4066Sahrens #include <sys/stat.h>
76fa9e4066Sahrens
77fa9e4066Sahrens #include <libzfs.h>
78fa9e4066Sahrens
79fa9e4066Sahrens #include "libzfs_impl.h"
80fa9e4066Sahrens
8167331909Sdougm #include <libshare.h>
8267331909Sdougm #include <sys/systeminfo.h>
8367331909Sdougm #define MAXISALEN 257 /* based on sysinfo(2) man page */
8467331909Sdougm
85da6c28aaSamw static int zfs_share_proto(zfs_handle_t *, zfs_share_proto_t *);
86da6c28aaSamw zfs_share_type_t zfs_is_shared_proto(zfs_handle_t *, char **,
87da6c28aaSamw zfs_share_proto_t);
88da6c28aaSamw
89da6c28aaSamw /*
90da6c28aaSamw * The share protocols table must be in the same order as the zfs_share_prot_t
91da6c28aaSamw * enum in libzfs_impl.h
92da6c28aaSamw */
93da6c28aaSamw typedef struct {
94da6c28aaSamw zfs_prop_t p_prop;
95da6c28aaSamw char *p_name;
96da6c28aaSamw int p_share_err;
97da6c28aaSamw int p_unshare_err;
98da6c28aaSamw } proto_table_t;
99da6c28aaSamw
100da6c28aaSamw proto_table_t proto_table[PROTO_END] = {
101da6c28aaSamw {ZFS_PROP_SHARENFS, "nfs", EZFS_SHARENFSFAILED, EZFS_UNSHARENFSFAILED},
102da6c28aaSamw {ZFS_PROP_SHARESMB, "smb", EZFS_SHARESMBFAILED, EZFS_UNSHARESMBFAILED},
103da6c28aaSamw };
104da6c28aaSamw
105da6c28aaSamw zfs_share_proto_t nfs_only[] = {
106da6c28aaSamw PROTO_NFS,
107da6c28aaSamw PROTO_END
108da6c28aaSamw };
109da6c28aaSamw
110da6c28aaSamw zfs_share_proto_t smb_only[] = {
111da6c28aaSamw PROTO_SMB,
112da6c28aaSamw PROTO_END
113da6c28aaSamw };
114da6c28aaSamw zfs_share_proto_t share_all_proto[] = {
115da6c28aaSamw PROTO_NFS,
116da6c28aaSamw PROTO_SMB,
117da6c28aaSamw PROTO_END
118da6c28aaSamw };
119da6c28aaSamw
120fa9e4066Sahrens /*
121da6c28aaSamw * Search the sharetab for the given mountpoint and protocol, returning
122da6c28aaSamw * a zfs_share_type_t value.
123fa9e4066Sahrens */
124da6c28aaSamw static zfs_share_type_t
is_shared(libzfs_handle_t * hdl,const char * mountpoint,zfs_share_proto_t proto)125da6c28aaSamw is_shared(libzfs_handle_t *hdl, const char *mountpoint, zfs_share_proto_t proto)
126fa9e4066Sahrens {
127fa9e4066Sahrens char buf[MAXPATHLEN], *tab;
128da6c28aaSamw char *ptr;
129fa9e4066Sahrens
13099653d4eSeschrock if (hdl->libzfs_sharetab == NULL)
131da6c28aaSamw return (SHARED_NOT_SHARED);
132fa9e4066Sahrens
13399653d4eSeschrock (void) fseek(hdl->libzfs_sharetab, 0, SEEK_SET);
134fa9e4066Sahrens
13599653d4eSeschrock while (fgets(buf, sizeof (buf), hdl->libzfs_sharetab) != NULL) {
136fa9e4066Sahrens
137fa9e4066Sahrens /* the mountpoint is the first entry on each line */
138da6c28aaSamw if ((tab = strchr(buf, '\t')) == NULL)
139da6c28aaSamw continue;
140da6c28aaSamw
141fa9e4066Sahrens *tab = '\0';
142da6c28aaSamw if (strcmp(buf, mountpoint) == 0) {
143da6c28aaSamw /*
144da6c28aaSamw * the protocol field is the third field
145da6c28aaSamw * skip over second field
146da6c28aaSamw */
147da6c28aaSamw ptr = ++tab;
148da6c28aaSamw if ((tab = strchr(ptr, '\t')) == NULL)
149da6c28aaSamw continue;
150da6c28aaSamw ptr = ++tab;
151da6c28aaSamw if ((tab = strchr(ptr, '\t')) == NULL)
152da6c28aaSamw continue;
153da6c28aaSamw *tab = '\0';
154da6c28aaSamw if (strcmp(ptr,
155da6c28aaSamw proto_table[proto].p_name) == 0) {
156da6c28aaSamw switch (proto) {
157da6c28aaSamw case PROTO_NFS:
158da6c28aaSamw return (SHARED_NFS);
159da6c28aaSamw case PROTO_SMB:
160da6c28aaSamw return (SHARED_SMB);
161da6c28aaSamw default:
162da6c28aaSamw return (0);
163da6c28aaSamw }
164da6c28aaSamw }
165fa9e4066Sahrens }
166fa9e4066Sahrens }
167fa9e4066Sahrens
168da6c28aaSamw return (SHARED_NOT_SHARED);
169fa9e4066Sahrens }
170fa9e4066Sahrens
171fa9e4066Sahrens /*
17299653d4eSeschrock * Returns true if the specified directory is empty. If we can't open the
17399653d4eSeschrock * directory at all, return true so that the mount can fail with a more
174fa9e4066Sahrens * informative error message.
175fa9e4066Sahrens */
17699653d4eSeschrock static boolean_t
dir_is_empty(const char * dirname)177fa9e4066Sahrens dir_is_empty(const char *dirname)
178fa9e4066Sahrens {
179fa9e4066Sahrens DIR *dirp;
180fa9e4066Sahrens struct dirent64 *dp;
181fa9e4066Sahrens
182fa9e4066Sahrens if ((dirp = opendir(dirname)) == NULL)
18399653d4eSeschrock return (B_TRUE);
184fa9e4066Sahrens
185fa9e4066Sahrens while ((dp = readdir64(dirp)) != NULL) {
186fa9e4066Sahrens
187fa9e4066Sahrens if (strcmp(dp->d_name, ".") == 0 ||
188fa9e4066Sahrens strcmp(dp->d_name, "..") == 0)
189fa9e4066Sahrens continue;
190fa9e4066Sahrens
191fa9e4066Sahrens (void) closedir(dirp);
19299653d4eSeschrock return (B_FALSE);
193fa9e4066Sahrens }
194fa9e4066Sahrens
195fa9e4066Sahrens (void) closedir(dirp);
19699653d4eSeschrock return (B_TRUE);
197fa9e4066Sahrens }
198fa9e4066Sahrens
199fa9e4066Sahrens /*
200fa9e4066Sahrens * Checks to see if the mount is active. If the filesystem is mounted, we fill
201fa9e4066Sahrens * in 'where' with the current mountpoint, and return 1. Otherwise, we return
202fa9e4066Sahrens * 0.
203fa9e4066Sahrens */
20499653d4eSeschrock boolean_t
is_mounted(libzfs_handle_t * zfs_hdl,const char * special,char ** where)20555434c77Sek110237 is_mounted(libzfs_handle_t *zfs_hdl, const char *special, char **where)
206fa9e4066Sahrens {
207ebedde84SEric Taylor struct mnttab entry;
208fa9e4066Sahrens
209ebedde84SEric Taylor if (libzfs_mnttab_find(zfs_hdl, special, &entry) != 0)
21099653d4eSeschrock return (B_FALSE);
211fa9e4066Sahrens
212fa9e4066Sahrens if (where != NULL)
21355434c77Sek110237 *where = zfs_strdup(zfs_hdl, entry.mnt_mountp);
214fa9e4066Sahrens
21599653d4eSeschrock return (B_TRUE);
216fa9e4066Sahrens }
217fa9e4066Sahrens
21855434c77Sek110237 boolean_t
zfs_is_mounted(zfs_handle_t * zhp,char ** where)21955434c77Sek110237 zfs_is_mounted(zfs_handle_t *zhp, char **where)
22055434c77Sek110237 {
22155434c77Sek110237 return (is_mounted(zhp->zfs_hdl, zfs_get_name(zhp), where));
22255434c77Sek110237 }
22355434c77Sek110237
224fa9e4066Sahrens /*
225e9dbad6fSeschrock * Returns true if the given dataset is mountable, false otherwise. Returns the
226e9dbad6fSeschrock * mountpoint in 'buf'.
227e9dbad6fSeschrock */
228e9dbad6fSeschrock static boolean_t
zfs_is_mountable(zfs_handle_t * zhp,char * buf,size_t buflen,zprop_source_t * source)229e9dbad6fSeschrock zfs_is_mountable(zfs_handle_t *zhp, char *buf, size_t buflen,
230990b4856Slling zprop_source_t *source)
231e9dbad6fSeschrock {
232*675fc291SMatthew Ahrens char sourceloc[MAXNAMELEN];
233990b4856Slling zprop_source_t sourcetype;
234e9dbad6fSeschrock
235e9dbad6fSeschrock if (!zfs_prop_valid_for_type(ZFS_PROP_MOUNTPOINT, zhp->zfs_type))
236e9dbad6fSeschrock return (B_FALSE);
237e9dbad6fSeschrock
238e9dbad6fSeschrock verify(zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, buf, buflen,
239e9dbad6fSeschrock &sourcetype, sourceloc, sizeof (sourceloc), B_FALSE) == 0);
240e9dbad6fSeschrock
241e9dbad6fSeschrock if (strcmp(buf, ZFS_MOUNTPOINT_NONE) == 0 ||
242e9dbad6fSeschrock strcmp(buf, ZFS_MOUNTPOINT_LEGACY) == 0)
243e9dbad6fSeschrock return (B_FALSE);
244e9dbad6fSeschrock
245a227b7f4Shs24103 if (zfs_prop_get_int(zhp, ZFS_PROP_CANMOUNT) == ZFS_CANMOUNT_OFF)
246e9dbad6fSeschrock return (B_FALSE);
247e9dbad6fSeschrock
248e9dbad6fSeschrock if (zfs_prop_get_int(zhp, ZFS_PROP_ZONED) &&
249e9dbad6fSeschrock getzoneid() == GLOBAL_ZONEID)
250e9dbad6fSeschrock return (B_FALSE);
251e9dbad6fSeschrock
252e9dbad6fSeschrock if (source)
253e9dbad6fSeschrock *source = sourcetype;
254e9dbad6fSeschrock
255e9dbad6fSeschrock return (B_TRUE);
256e9dbad6fSeschrock }
257e9dbad6fSeschrock
258e9dbad6fSeschrock /*
259fa9e4066Sahrens * Mount the given filesystem.
260fa9e4066Sahrens */
261fa9e4066Sahrens int
zfs_mount(zfs_handle_t * zhp,const char * options,int flags)262fa9e4066Sahrens zfs_mount(zfs_handle_t *zhp, const char *options, int flags)
263fa9e4066Sahrens {
264fa9e4066Sahrens struct stat buf;
265fa9e4066Sahrens char mountpoint[ZFS_MAXPROPLEN];
266fa9e4066Sahrens char mntopts[MNT_LINE_MAX];
26799653d4eSeschrock libzfs_handle_t *hdl = zhp->zfs_hdl;
268fa9e4066Sahrens
269fa9e4066Sahrens if (options == NULL)
270fa9e4066Sahrens mntopts[0] = '\0';
271fa9e4066Sahrens else
272fa9e4066Sahrens (void) strlcpy(mntopts, options, sizeof (mntopts));
273fa9e4066Sahrens
274f9af39baSGeorge Wilson /*
275f9af39baSGeorge Wilson * If the pool is imported read-only then all mounts must be read-only
276f9af39baSGeorge Wilson */
277f9af39baSGeorge Wilson if (zpool_get_prop_int(zhp->zpool_hdl, ZPOOL_PROP_READONLY, NULL))
278f9af39baSGeorge Wilson flags |= MS_RDONLY;
279f9af39baSGeorge Wilson
280e9dbad6fSeschrock if (!zfs_is_mountable(zhp, mountpoint, sizeof (mountpoint), NULL))
281fa9e4066Sahrens return (0);
282fa9e4066Sahrens
283fa9e4066Sahrens /* Create the directory if it doesn't already exist */
284fa9e4066Sahrens if (lstat(mountpoint, &buf) != 0) {
285fa9e4066Sahrens if (mkdirp(mountpoint, 0755) != 0) {
28699653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
28799653d4eSeschrock "failed to create mountpoint"));
288ece3d9b3Slling return (zfs_error_fmt(hdl, EZFS_MOUNTFAILED,
28999653d4eSeschrock dgettext(TEXT_DOMAIN, "cannot mount '%s'"),
29099653d4eSeschrock mountpoint));
291fa9e4066Sahrens }
292fa9e4066Sahrens }
293fa9e4066Sahrens
294fa9e4066Sahrens /*
295fa9e4066Sahrens * Determine if the mountpoint is empty. If so, refuse to perform the
296fa9e4066Sahrens * mount. We don't perform this check if MS_OVERLAY is specified, which
297fa9e4066Sahrens * would defeat the point. We also avoid this check if 'remount' is
298fa9e4066Sahrens * specified.
299fa9e4066Sahrens */
300fa9e4066Sahrens if ((flags & MS_OVERLAY) == 0 &&
301fa9e4066Sahrens strstr(mntopts, MNTOPT_REMOUNT) == NULL &&
302fa9e4066Sahrens !dir_is_empty(mountpoint)) {
30399653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
30499653d4eSeschrock "directory is not empty"));
305ece3d9b3Slling return (zfs_error_fmt(hdl, EZFS_MOUNTFAILED,
30699653d4eSeschrock dgettext(TEXT_DOMAIN, "cannot mount '%s'"), mountpoint));
307fa9e4066Sahrens }
308fa9e4066Sahrens
309fa9e4066Sahrens /* perform the mount */
310fa9e4066Sahrens if (mount(zfs_get_name(zhp), mountpoint, MS_OPTIONSTR | flags,
311fa9e4066Sahrens MNTTYPE_ZFS, NULL, 0, mntopts, sizeof (mntopts)) != 0) {
312fa9e4066Sahrens /*
313fa9e4066Sahrens * Generic errors are nasty, but there are just way too many
314fa9e4066Sahrens * from mount(), and they're well-understood. We pick a few
315fa9e4066Sahrens * common ones to improve upon.
316fa9e4066Sahrens */
317d8689a57Sdougm if (errno == EBUSY) {
31899653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
31999653d4eSeschrock "mountpoint or dataset is busy"));
320ecd6cf80Smarks } else if (errno == EPERM) {
321ecd6cf80Smarks zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
322ecd6cf80Smarks "Insufficient privileges"));
32354a91118SChris Kirby } else if (errno == ENOTSUP) {
32454a91118SChris Kirby char buf[256];
325dc7cd546SMark Shellenbaum int spa_version;
32654a91118SChris Kirby
327dc7cd546SMark Shellenbaum VERIFY(zfs_spa_version(zhp, &spa_version) == 0);
32854a91118SChris Kirby (void) snprintf(buf, sizeof (buf),
329dc7cd546SMark Shellenbaum dgettext(TEXT_DOMAIN, "Can't mount a version %lld "
330dc7cd546SMark Shellenbaum "file system on a version %d pool. Pool must be"
331dc7cd546SMark Shellenbaum " upgraded to mount this file system."),
33254a91118SChris Kirby (u_longlong_t)zfs_prop_get_int(zhp,
333dc7cd546SMark Shellenbaum ZFS_PROP_VERSION), spa_version);
33454a91118SChris Kirby zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, buf));
335d8689a57Sdougm } else {
33699653d4eSeschrock zfs_error_aux(hdl, strerror(errno));
337d8689a57Sdougm }
338ece3d9b3Slling return (zfs_error_fmt(hdl, EZFS_MOUNTFAILED,
33999653d4eSeschrock dgettext(TEXT_DOMAIN, "cannot mount '%s'"),
34099653d4eSeschrock zhp->zfs_name));
341fa9e4066Sahrens }
342fa9e4066Sahrens
343ebedde84SEric Taylor /* add the mounted entry into our cache */
344ebedde84SEric Taylor libzfs_mnttab_add(hdl, zfs_get_name(zhp), mountpoint,
345ebedde84SEric Taylor mntopts);
346fa9e4066Sahrens return (0);
347fa9e4066Sahrens }
348fa9e4066Sahrens
349fa9e4066Sahrens /*
3503bb79becSeschrock * Unmount a single filesystem.
3513bb79becSeschrock */
3523bb79becSeschrock static int
unmount_one(libzfs_handle_t * hdl,const char * mountpoint,int flags)3533bb79becSeschrock unmount_one(libzfs_handle_t *hdl, const char *mountpoint, int flags)
3543bb79becSeschrock {
3553bb79becSeschrock if (umount2(mountpoint, flags) != 0) {
3563bb79becSeschrock zfs_error_aux(hdl, strerror(errno));
357ece3d9b3Slling return (zfs_error_fmt(hdl, EZFS_UMOUNTFAILED,
3583bb79becSeschrock dgettext(TEXT_DOMAIN, "cannot unmount '%s'"),
3593bb79becSeschrock mountpoint));
3603bb79becSeschrock }
3613bb79becSeschrock
3623bb79becSeschrock return (0);
3633bb79becSeschrock }
3643bb79becSeschrock
3653bb79becSeschrock /*
366fa9e4066Sahrens * Unmount the given filesystem.
367fa9e4066Sahrens */
368fa9e4066Sahrens int
zfs_unmount(zfs_handle_t * zhp,const char * mountpoint,int flags)369fa9e4066Sahrens zfs_unmount(zfs_handle_t *zhp, const char *mountpoint, int flags)
370fa9e4066Sahrens {
371ebedde84SEric Taylor libzfs_handle_t *hdl = zhp->zfs_hdl;
372ebedde84SEric Taylor struct mnttab entry;
37367331909Sdougm char *mntpt = NULL;
374fa9e4066Sahrens
375ebedde84SEric Taylor /* check to see if we need to unmount the filesystem */
376fa9e4066Sahrens if (mountpoint != NULL || ((zfs_get_type(zhp) == ZFS_TYPE_FILESYSTEM) &&
377ebedde84SEric Taylor libzfs_mnttab_find(hdl, zhp->zfs_name, &entry) == 0)) {
37867331909Sdougm /*
37967331909Sdougm * mountpoint may have come from a call to
38067331909Sdougm * getmnt/getmntany if it isn't NULL. If it is NULL,
381ebedde84SEric Taylor * we know it comes from libzfs_mnttab_find which can
382ebedde84SEric Taylor * then get freed later. We strdup it to play it safe.
38367331909Sdougm */
384fa9e4066Sahrens if (mountpoint == NULL)
385ebedde84SEric Taylor mntpt = zfs_strdup(hdl, entry.mnt_mountp);
38667331909Sdougm else
387ebedde84SEric Taylor mntpt = zfs_strdup(hdl, mountpoint);
388fa9e4066Sahrens
389fa9e4066Sahrens /*
3903bb79becSeschrock * Unshare and unmount the filesystem
391fa9e4066Sahrens */
392da6c28aaSamw if (zfs_unshare_proto(zhp, mntpt, share_all_proto) != 0)
393eb66cf86Sth199096 return (-1);
394eb66cf86Sth199096
395ebedde84SEric Taylor if (unmount_one(hdl, mntpt, flags) != 0) {
39667331909Sdougm free(mntpt);
397da6c28aaSamw (void) zfs_shareall(zhp);
398fa9e4066Sahrens return (-1);
399fa9e4066Sahrens }
400ebedde84SEric Taylor libzfs_mnttab_remove(hdl, zhp->zfs_name);
40167331909Sdougm free(mntpt);
40267331909Sdougm }
403fa9e4066Sahrens
404fa9e4066Sahrens return (0);
405fa9e4066Sahrens }
406fa9e4066Sahrens
407fa9e4066Sahrens /*
408fa9e4066Sahrens * Unmount this filesystem and any children inheriting the mountpoint property.
409fa9e4066Sahrens * To do this, just act like we're changing the mountpoint property, but don't
410fa9e4066Sahrens * remount the filesystems afterwards.
411fa9e4066Sahrens */
412fa9e4066Sahrens int
zfs_unmountall(zfs_handle_t * zhp,int flags)413fa9e4066Sahrens zfs_unmountall(zfs_handle_t *zhp, int flags)
414fa9e4066Sahrens {
415fa9e4066Sahrens prop_changelist_t *clp;
416fa9e4066Sahrens int ret;
417fa9e4066Sahrens
4180069fd67STim Haley clp = changelist_gather(zhp, ZFS_PROP_MOUNTPOINT, 0, flags);
419fa9e4066Sahrens if (clp == NULL)
420fa9e4066Sahrens return (-1);
421fa9e4066Sahrens
422fa9e4066Sahrens ret = changelist_prefix(clp);
423fa9e4066Sahrens changelist_free(clp);
424fa9e4066Sahrens
425fa9e4066Sahrens return (ret);
426fa9e4066Sahrens }
427fa9e4066Sahrens
428f3861e1aSahl boolean_t
zfs_is_shared(zfs_handle_t * zhp)429f3861e1aSahl zfs_is_shared(zfs_handle_t *zhp)
430f3861e1aSahl {
431da6c28aaSamw zfs_share_type_t rc = 0;
432da6c28aaSamw zfs_share_proto_t *curr_proto;
433da6c28aaSamw
434f3861e1aSahl if (ZFS_IS_VOLUME(zhp))
435ab003da8SJim Dunham return (B_FALSE);
436f3861e1aSahl
437da6c28aaSamw for (curr_proto = share_all_proto; *curr_proto != PROTO_END;
438da6c28aaSamw curr_proto++)
439da6c28aaSamw rc |= zfs_is_shared_proto(zhp, NULL, *curr_proto);
440da6c28aaSamw
441da6c28aaSamw return (rc ? B_TRUE : B_FALSE);
442f3861e1aSahl }
443f3861e1aSahl
444f3861e1aSahl int
zfs_share(zfs_handle_t * zhp)445f3861e1aSahl zfs_share(zfs_handle_t *zhp)
446f3861e1aSahl {
4479d9a58e3SEric Taylor assert(!ZFS_IS_VOLUME(zhp));
448da6c28aaSamw return (zfs_share_proto(zhp, share_all_proto));
449f3861e1aSahl }
450f3861e1aSahl
451f3861e1aSahl int
zfs_unshare(zfs_handle_t * zhp)452f3861e1aSahl zfs_unshare(zfs_handle_t *zhp)
453f3861e1aSahl {
4549d9a58e3SEric Taylor assert(!ZFS_IS_VOLUME(zhp));
455da6c28aaSamw return (zfs_unshareall(zhp));
456f3861e1aSahl }
457f3861e1aSahl
458fa9e4066Sahrens /*
459fa9e4066Sahrens * Check to see if the filesystem is currently shared.
460fa9e4066Sahrens */
461da6c28aaSamw zfs_share_type_t
zfs_is_shared_proto(zfs_handle_t * zhp,char ** where,zfs_share_proto_t proto)462da6c28aaSamw zfs_is_shared_proto(zfs_handle_t *zhp, char **where, zfs_share_proto_t proto)
463fa9e4066Sahrens {
464fa9e4066Sahrens char *mountpoint;
465da6c28aaSamw zfs_share_type_t rc;
466fa9e4066Sahrens
467fa9e4066Sahrens if (!zfs_is_mounted(zhp, &mountpoint))
468da6c28aaSamw return (SHARED_NOT_SHARED);
469fa9e4066Sahrens
470da6c28aaSamw if (rc = is_shared(zhp->zfs_hdl, mountpoint, proto)) {
471fa9e4066Sahrens if (where != NULL)
472fa9e4066Sahrens *where = mountpoint;
473fa9e4066Sahrens else
474fa9e4066Sahrens free(mountpoint);
475da6c28aaSamw return (rc);
476fa9e4066Sahrens } else {
477fa9e4066Sahrens free(mountpoint);
478da6c28aaSamw return (SHARED_NOT_SHARED);
479fa9e4066Sahrens }
480fa9e4066Sahrens }
481fa9e4066Sahrens
482da6c28aaSamw boolean_t
zfs_is_shared_nfs(zfs_handle_t * zhp,char ** where)483da6c28aaSamw zfs_is_shared_nfs(zfs_handle_t *zhp, char **where)
484da6c28aaSamw {
485da6c28aaSamw return (zfs_is_shared_proto(zhp, where,
486da6c28aaSamw PROTO_NFS) != SHARED_NOT_SHARED);
487da6c28aaSamw }
488da6c28aaSamw
489da6c28aaSamw boolean_t
zfs_is_shared_smb(zfs_handle_t * zhp,char ** where)490da6c28aaSamw zfs_is_shared_smb(zfs_handle_t *zhp, char **where)
491da6c28aaSamw {
492da6c28aaSamw return (zfs_is_shared_proto(zhp, where,
493da6c28aaSamw PROTO_SMB) != SHARED_NOT_SHARED);
494da6c28aaSamw }
495da6c28aaSamw
496fa9e4066Sahrens /*
49767331909Sdougm * Make sure things will work if libshare isn't installed by using
49867331909Sdougm * wrapper functions that check to see that the pointers to functions
49967331909Sdougm * initialized in _zfs_init_libshare() are actually present.
500fa9e4066Sahrens */
50167331909Sdougm
50267331909Sdougm static sa_handle_t (*_sa_init)(int);
50367331909Sdougm static void (*_sa_fini)(sa_handle_t);
50467331909Sdougm static sa_share_t (*_sa_find_share)(sa_handle_t, char *);
50567331909Sdougm static int (*_sa_enable_share)(sa_share_t, char *);
50667331909Sdougm static int (*_sa_disable_share)(sa_share_t, char *);
50767331909Sdougm static char *(*_sa_errorstr)(int);
50867331909Sdougm static int (*_sa_parse_legacy_options)(sa_group_t, char *, char *);
5095b6e0c46Sdougm static boolean_t (*_sa_needs_refresh)(sa_handle_t *);
5105b6e0c46Sdougm static libzfs_handle_t *(*_sa_get_zfs_handle)(sa_handle_t);
5115b6e0c46Sdougm static int (*_sa_zfs_process_share)(sa_handle_t, sa_group_t, sa_share_t,
5125b6e0c46Sdougm char *, char *, zprop_source_t, char *, char *, char *);
5135b6e0c46Sdougm static void (*_sa_update_sharetab_ts)(sa_handle_t);
51467331909Sdougm
51567331909Sdougm /*
51667331909Sdougm * _zfs_init_libshare()
51767331909Sdougm *
51867331909Sdougm * Find the libshare.so.1 entry points that we use here and save the
51967331909Sdougm * values to be used later. This is triggered by the runtime loader.
52067331909Sdougm * Make sure the correct ISA version is loaded.
52167331909Sdougm */
5225b6e0c46Sdougm
52367331909Sdougm #pragma init(_zfs_init_libshare)
52467331909Sdougm static void
_zfs_init_libshare(void)52567331909Sdougm _zfs_init_libshare(void)
52667331909Sdougm {
52767331909Sdougm void *libshare;
52867331909Sdougm char path[MAXPATHLEN];
52967331909Sdougm char isa[MAXISALEN];
53067331909Sdougm
53167331909Sdougm #if defined(_LP64)
53267331909Sdougm if (sysinfo(SI_ARCHITECTURE_64, isa, MAXISALEN) == -1)
53367331909Sdougm isa[0] = '\0';
53467331909Sdougm #else
53567331909Sdougm isa[0] = '\0';
53667331909Sdougm #endif
53767331909Sdougm (void) snprintf(path, MAXPATHLEN,
53867331909Sdougm "/usr/lib/%s/libshare.so.1", isa);
53967331909Sdougm
54067331909Sdougm if ((libshare = dlopen(path, RTLD_LAZY | RTLD_GLOBAL)) != NULL) {
54167331909Sdougm _sa_init = (sa_handle_t (*)(int))dlsym(libshare, "sa_init");
54267331909Sdougm _sa_fini = (void (*)(sa_handle_t))dlsym(libshare, "sa_fini");
54367331909Sdougm _sa_find_share = (sa_share_t (*)(sa_handle_t, char *))
54467331909Sdougm dlsym(libshare, "sa_find_share");
54567331909Sdougm _sa_enable_share = (int (*)(sa_share_t, char *))dlsym(libshare,
54667331909Sdougm "sa_enable_share");
54767331909Sdougm _sa_disable_share = (int (*)(sa_share_t, char *))dlsym(libshare,
54867331909Sdougm "sa_disable_share");
54967331909Sdougm _sa_errorstr = (char *(*)(int))dlsym(libshare, "sa_errorstr");
55067331909Sdougm _sa_parse_legacy_options = (int (*)(sa_group_t, char *, char *))
55167331909Sdougm dlsym(libshare, "sa_parse_legacy_options");
5525b6e0c46Sdougm _sa_needs_refresh = (boolean_t (*)(sa_handle_t *))
5535b6e0c46Sdougm dlsym(libshare, "sa_needs_refresh");
5545b6e0c46Sdougm _sa_get_zfs_handle = (libzfs_handle_t *(*)(sa_handle_t))
5555b6e0c46Sdougm dlsym(libshare, "sa_get_zfs_handle");
5565b6e0c46Sdougm _sa_zfs_process_share = (int (*)(sa_handle_t, sa_group_t,
5575b6e0c46Sdougm sa_share_t, char *, char *, zprop_source_t, char *,
5585b6e0c46Sdougm char *, char *))dlsym(libshare, "sa_zfs_process_share");
5595b6e0c46Sdougm _sa_update_sharetab_ts = (void (*)(sa_handle_t))
5605b6e0c46Sdougm dlsym(libshare, "sa_update_sharetab_ts");
56157b448deSdougm if (_sa_init == NULL || _sa_fini == NULL ||
56257b448deSdougm _sa_find_share == NULL || _sa_enable_share == NULL ||
56357b448deSdougm _sa_disable_share == NULL || _sa_errorstr == NULL ||
5645b6e0c46Sdougm _sa_parse_legacy_options == NULL ||
5655b6e0c46Sdougm _sa_needs_refresh == NULL || _sa_get_zfs_handle == NULL ||
5665b6e0c46Sdougm _sa_zfs_process_share == NULL ||
5675b6e0c46Sdougm _sa_update_sharetab_ts == NULL) {
56857b448deSdougm _sa_init = NULL;
56957b448deSdougm _sa_fini = NULL;
57057b448deSdougm _sa_disable_share = NULL;
57157b448deSdougm _sa_enable_share = NULL;
57257b448deSdougm _sa_errorstr = NULL;
57357b448deSdougm _sa_parse_legacy_options = NULL;
57457b448deSdougm (void) dlclose(libshare);
5755b6e0c46Sdougm _sa_needs_refresh = NULL;
5765b6e0c46Sdougm _sa_get_zfs_handle = NULL;
5775b6e0c46Sdougm _sa_zfs_process_share = NULL;
5785b6e0c46Sdougm _sa_update_sharetab_ts = NULL;
57957b448deSdougm }
58067331909Sdougm }
58167331909Sdougm }
58267331909Sdougm
58367331909Sdougm /*
58467331909Sdougm * zfs_init_libshare(zhandle, service)
58567331909Sdougm *
58667331909Sdougm * Initialize the libshare API if it hasn't already been initialized.
58767331909Sdougm * In all cases it returns 0 if it succeeded and an error if not. The
58867331909Sdougm * service value is which part(s) of the API to initialize and is a
58967331909Sdougm * direct map to the libshare sa_init(service) interface.
59067331909Sdougm */
59167331909Sdougm int
zfs_init_libshare(libzfs_handle_t * zhandle,int service)59267331909Sdougm zfs_init_libshare(libzfs_handle_t *zhandle, int service)
59367331909Sdougm {
59467331909Sdougm int ret = SA_OK;
59567331909Sdougm
596d8689a57Sdougm if (_sa_init == NULL)
59767331909Sdougm ret = SA_CONFIG_ERR;
598d8689a57Sdougm
5995b6e0c46Sdougm if (ret == SA_OK && zhandle->libzfs_shareflags & ZFSSHARE_MISS) {
6005b6e0c46Sdougm /*
6015b6e0c46Sdougm * We had a cache miss. Most likely it is a new ZFS
6025b6e0c46Sdougm * dataset that was just created. We want to make sure
6035b6e0c46Sdougm * so check timestamps to see if a different process
6045b6e0c46Sdougm * has updated any of the configuration. If there was
6055b6e0c46Sdougm * some non-ZFS change, we need to re-initialize the
6065b6e0c46Sdougm * internal cache.
6075b6e0c46Sdougm */
6085b6e0c46Sdougm zhandle->libzfs_shareflags &= ~ZFSSHARE_MISS;
6095b6e0c46Sdougm if (_sa_needs_refresh != NULL &&
6105b6e0c46Sdougm _sa_needs_refresh(zhandle->libzfs_sharehdl)) {
6115b6e0c46Sdougm zfs_uninit_libshare(zhandle);
6125b6e0c46Sdougm zhandle->libzfs_sharehdl = _sa_init(service);
6135b6e0c46Sdougm }
6145b6e0c46Sdougm }
6155b6e0c46Sdougm
616d8689a57Sdougm if (ret == SA_OK && zhandle && zhandle->libzfs_sharehdl == NULL)
61767331909Sdougm zhandle->libzfs_sharehdl = _sa_init(service);
618d8689a57Sdougm
619d8689a57Sdougm if (ret == SA_OK && zhandle->libzfs_sharehdl == NULL)
62067331909Sdougm ret = SA_NO_MEMORY;
621d8689a57Sdougm
62267331909Sdougm return (ret);
62367331909Sdougm }
62467331909Sdougm
62567331909Sdougm /*
62667331909Sdougm * zfs_uninit_libshare(zhandle)
62767331909Sdougm *
62867331909Sdougm * Uninitialize the libshare API if it hasn't already been
62967331909Sdougm * uninitialized. It is OK to call multiple times.
63067331909Sdougm */
63167331909Sdougm void
zfs_uninit_libshare(libzfs_handle_t * zhandle)63267331909Sdougm zfs_uninit_libshare(libzfs_handle_t *zhandle)
63367331909Sdougm {
63467331909Sdougm if (zhandle != NULL && zhandle->libzfs_sharehdl != NULL) {
63567331909Sdougm if (_sa_fini != NULL)
63667331909Sdougm _sa_fini(zhandle->libzfs_sharehdl);
63767331909Sdougm zhandle->libzfs_sharehdl = NULL;
63867331909Sdougm }
63967331909Sdougm }
64067331909Sdougm
64167331909Sdougm /*
64267331909Sdougm * zfs_parse_options(options, proto)
64367331909Sdougm *
64467331909Sdougm * Call the legacy parse interface to get the protocol specific
64567331909Sdougm * options using the NULL arg to indicate that this is a "parse" only.
64667331909Sdougm */
64767331909Sdougm int
zfs_parse_options(char * options,zfs_share_proto_t proto)648da6c28aaSamw zfs_parse_options(char *options, zfs_share_proto_t proto)
64967331909Sdougm {
6503cb34c60Sahrens if (_sa_parse_legacy_options != NULL) {
6513cb34c60Sahrens return (_sa_parse_legacy_options(NULL, options,
6523cb34c60Sahrens proto_table[proto].p_name));
6533cb34c60Sahrens }
6543cb34c60Sahrens return (SA_CONFIG_ERR);
65567331909Sdougm }
65667331909Sdougm
65767331909Sdougm /*
65867331909Sdougm * zfs_sa_find_share(handle, path)
65967331909Sdougm *
66067331909Sdougm * wrapper around sa_find_share to find a share path in the
66167331909Sdougm * configuration.
66267331909Sdougm */
66367331909Sdougm static sa_share_t
zfs_sa_find_share(sa_handle_t handle,char * path)66467331909Sdougm zfs_sa_find_share(sa_handle_t handle, char *path)
66567331909Sdougm {
66667331909Sdougm if (_sa_find_share != NULL)
66767331909Sdougm return (_sa_find_share(handle, path));
66867331909Sdougm return (NULL);
66967331909Sdougm }
67067331909Sdougm
67167331909Sdougm /*
67267331909Sdougm * zfs_sa_enable_share(share, proto)
67367331909Sdougm *
67467331909Sdougm * Wrapper for sa_enable_share which enables a share for a specified
67567331909Sdougm * protocol.
67667331909Sdougm */
67767331909Sdougm static int
zfs_sa_enable_share(sa_share_t share,char * proto)67867331909Sdougm zfs_sa_enable_share(sa_share_t share, char *proto)
67967331909Sdougm {
68067331909Sdougm if (_sa_enable_share != NULL)
68167331909Sdougm return (_sa_enable_share(share, proto));
68267331909Sdougm return (SA_CONFIG_ERR);
68367331909Sdougm }
68467331909Sdougm
68567331909Sdougm /*
68667331909Sdougm * zfs_sa_disable_share(share, proto)
68767331909Sdougm *
68867331909Sdougm * Wrapper for sa_enable_share which disables a share for a specified
68967331909Sdougm * protocol.
69067331909Sdougm */
69167331909Sdougm static int
zfs_sa_disable_share(sa_share_t share,char * proto)69267331909Sdougm zfs_sa_disable_share(sa_share_t share, char *proto)
69367331909Sdougm {
69467331909Sdougm if (_sa_disable_share != NULL)
69567331909Sdougm return (_sa_disable_share(share, proto));
69667331909Sdougm return (SA_CONFIG_ERR);
69767331909Sdougm }
69867331909Sdougm
69967331909Sdougm /*
700da6c28aaSamw * Share the given filesystem according to the options in the specified
701da6c28aaSamw * protocol specific properties (sharenfs, sharesmb). We rely
70267331909Sdougm * on "libshare" to the dirty work for us.
70367331909Sdougm */
704da6c28aaSamw static int
zfs_share_proto(zfs_handle_t * zhp,zfs_share_proto_t * proto)705da6c28aaSamw zfs_share_proto(zfs_handle_t *zhp, zfs_share_proto_t *proto)
706fa9e4066Sahrens {
707fa9e4066Sahrens char mountpoint[ZFS_MAXPROPLEN];
708fa9e4066Sahrens char shareopts[ZFS_MAXPROPLEN];
7095b6e0c46Sdougm char sourcestr[ZFS_MAXPROPLEN];
71099653d4eSeschrock libzfs_handle_t *hdl = zhp->zfs_hdl;
71167331909Sdougm sa_share_t share;
712da6c28aaSamw zfs_share_proto_t *curr_proto;
7135b6e0c46Sdougm zprop_source_t sourcetype;
71467331909Sdougm int ret;
715fa9e4066Sahrens
716e9dbad6fSeschrock if (!zfs_is_mountable(zhp, mountpoint, sizeof (mountpoint), NULL))
717fa9e4066Sahrens return (0);
718fa9e4066Sahrens
719da6c28aaSamw for (curr_proto = proto; *curr_proto != PROTO_END; curr_proto++) {
720da6c28aaSamw /*
721da6c28aaSamw * Return success if there are no share options.
722da6c28aaSamw */
723da6c28aaSamw if (zfs_prop_get(zhp, proto_table[*curr_proto].p_prop,
7245b6e0c46Sdougm shareopts, sizeof (shareopts), &sourcetype, sourcestr,
7255b6e0c46Sdougm ZFS_MAXPROPLEN, B_FALSE) != 0 ||
7265b6e0c46Sdougm strcmp(shareopts, "off") == 0)
727da6c28aaSamw continue;
728da6c28aaSamw
729fb41d494SMatthew Ahrens ret = zfs_init_libshare(hdl, SA_INIT_SHARE_API);
730fb41d494SMatthew Ahrens if (ret != SA_OK) {
731fb41d494SMatthew Ahrens (void) zfs_error_fmt(hdl, EZFS_SHARENFSFAILED,
732fb41d494SMatthew Ahrens dgettext(TEXT_DOMAIN, "cannot share '%s': %s"),
733fb41d494SMatthew Ahrens zfs_get_name(zhp), _sa_errorstr != NULL ?
734fb41d494SMatthew Ahrens _sa_errorstr(ret) : "");
735fb41d494SMatthew Ahrens return (-1);
736fb41d494SMatthew Ahrens }
737fb41d494SMatthew Ahrens
738da6c28aaSamw /*
739da6c28aaSamw * If the 'zoned' property is set, then zfs_is_mountable()
740da6c28aaSamw * will have already bailed out if we are in the global zone.
741da6c28aaSamw * But local zones cannot be NFS servers, so we ignore it for
742da6c28aaSamw * local zones as well.
743da6c28aaSamw */
744da6c28aaSamw if (zfs_prop_get_int(zhp, ZFS_PROP_ZONED))
745da6c28aaSamw continue;
746da6c28aaSamw
74767331909Sdougm share = zfs_sa_find_share(hdl->libzfs_sharehdl, mountpoint);
7485b6e0c46Sdougm if (share == NULL) {
7495b6e0c46Sdougm /*
7505b6e0c46Sdougm * This may be a new file system that was just
7515b6e0c46Sdougm * created so isn't in the internal cache
7525b6e0c46Sdougm * (second time through). Rather than
7535b6e0c46Sdougm * reloading the entire configuration, we can
7545b6e0c46Sdougm * assume ZFS has done the checking and it is
7555b6e0c46Sdougm * safe to add this to the internal
7565b6e0c46Sdougm * configuration.
7575b6e0c46Sdougm */
7585b6e0c46Sdougm if (_sa_zfs_process_share(hdl->libzfs_sharehdl,
7595b6e0c46Sdougm NULL, NULL, mountpoint,
7605b6e0c46Sdougm proto_table[*curr_proto].p_name, sourcetype,
7615b6e0c46Sdougm shareopts, sourcestr, zhp->zfs_name) != SA_OK) {
7625b6e0c46Sdougm (void) zfs_error_fmt(hdl,
7635b6e0c46Sdougm proto_table[*curr_proto].p_share_err,
7645b6e0c46Sdougm dgettext(TEXT_DOMAIN, "cannot share '%s'"),
7655b6e0c46Sdougm zfs_get_name(zhp));
7665b6e0c46Sdougm return (-1);
7675b6e0c46Sdougm }
7685b6e0c46Sdougm hdl->libzfs_shareflags |= ZFSSHARE_MISS;
7695b6e0c46Sdougm share = zfs_sa_find_share(hdl->libzfs_sharehdl,
7705b6e0c46Sdougm mountpoint);
7715b6e0c46Sdougm }
77267331909Sdougm if (share != NULL) {
77367331909Sdougm int err;
774da6c28aaSamw err = zfs_sa_enable_share(share,
775da6c28aaSamw proto_table[*curr_proto].p_name);
77667331909Sdougm if (err != SA_OK) {
777da6c28aaSamw (void) zfs_error_fmt(hdl,
778da6c28aaSamw proto_table[*curr_proto].p_share_err,
7793bb79becSeschrock dgettext(TEXT_DOMAIN, "cannot share '%s'"),
7803bb79becSeschrock zfs_get_name(zhp));
781fa9e4066Sahrens return (-1);
782fa9e4066Sahrens }
78367331909Sdougm } else {
784da6c28aaSamw (void) zfs_error_fmt(hdl,
785da6c28aaSamw proto_table[*curr_proto].p_share_err,
78667331909Sdougm dgettext(TEXT_DOMAIN, "cannot share '%s'"),
78767331909Sdougm zfs_get_name(zhp));
78867331909Sdougm return (-1);
78967331909Sdougm }
790fa9e4066Sahrens
791da6c28aaSamw }
792fa9e4066Sahrens return (0);
793fa9e4066Sahrens }
794fa9e4066Sahrens
795da6c28aaSamw
796da6c28aaSamw int
zfs_share_nfs(zfs_handle_t * zhp)797da6c28aaSamw zfs_share_nfs(zfs_handle_t *zhp)
798da6c28aaSamw {
799da6c28aaSamw return (zfs_share_proto(zhp, nfs_only));
800da6c28aaSamw }
801da6c28aaSamw
802da6c28aaSamw int
zfs_share_smb(zfs_handle_t * zhp)803da6c28aaSamw zfs_share_smb(zfs_handle_t *zhp)
804da6c28aaSamw {
805da6c28aaSamw return (zfs_share_proto(zhp, smb_only));
806da6c28aaSamw }
807da6c28aaSamw
808da6c28aaSamw int
zfs_shareall(zfs_handle_t * zhp)809da6c28aaSamw zfs_shareall(zfs_handle_t *zhp)
810da6c28aaSamw {
811da6c28aaSamw return (zfs_share_proto(zhp, share_all_proto));
812da6c28aaSamw }
813da6c28aaSamw
814fa9e4066Sahrens /*
8153bb79becSeschrock * Unshare a filesystem by mountpoint.
816fa9e4066Sahrens */
8173bb79becSeschrock static int
unshare_one(libzfs_handle_t * hdl,const char * name,const char * mountpoint,zfs_share_proto_t proto)818da6c28aaSamw unshare_one(libzfs_handle_t *hdl, const char *name, const char *mountpoint,
819da6c28aaSamw zfs_share_proto_t proto)
820fa9e4066Sahrens {
82167331909Sdougm sa_share_t share;
82267331909Sdougm int err;
82367331909Sdougm char *mntpt;
824fa9e4066Sahrens /*
82567331909Sdougm * Mountpoint could get trashed if libshare calls getmntany
826ebedde84SEric Taylor * which it does during API initialization, so strdup the
82767331909Sdougm * value.
828fa9e4066Sahrens */
82967331909Sdougm mntpt = zfs_strdup(hdl, mountpoint);
830fa9e4066Sahrens
83167331909Sdougm /* make sure libshare initialized */
83267331909Sdougm if ((err = zfs_init_libshare(hdl, SA_INIT_SHARE_API)) != SA_OK) {
83367331909Sdougm free(mntpt); /* don't need the copy anymore */
83467331909Sdougm return (zfs_error_fmt(hdl, EZFS_SHARENFSFAILED,
835d8689a57Sdougm dgettext(TEXT_DOMAIN, "cannot unshare '%s': %s"),
83667331909Sdougm name, _sa_errorstr(err)));
837fa9e4066Sahrens }
838fa9e4066Sahrens
83967331909Sdougm share = zfs_sa_find_share(hdl->libzfs_sharehdl, mntpt);
84067331909Sdougm free(mntpt); /* don't need the copy anymore */
8413bb79becSeschrock
84267331909Sdougm if (share != NULL) {
843da6c28aaSamw err = zfs_sa_disable_share(share, proto_table[proto].p_name);
84467331909Sdougm if (err != SA_OK) {
84567331909Sdougm return (zfs_error_fmt(hdl, EZFS_UNSHARENFSFAILED,
846d8689a57Sdougm dgettext(TEXT_DOMAIN, "cannot unshare '%s': %s"),
847d8689a57Sdougm name, _sa_errorstr(err)));
84867331909Sdougm }
84967331909Sdougm } else {
85067331909Sdougm return (zfs_error_fmt(hdl, EZFS_UNSHARENFSFAILED,
851d8689a57Sdougm dgettext(TEXT_DOMAIN, "cannot unshare '%s': not found"),
852d8689a57Sdougm name));
85367331909Sdougm }
8543bb79becSeschrock return (0);
855fa9e4066Sahrens }
8563bb79becSeschrock
8573bb79becSeschrock /*
8583bb79becSeschrock * Unshare the given filesystem.
8593bb79becSeschrock */
8603bb79becSeschrock int
zfs_unshare_proto(zfs_handle_t * zhp,const char * mountpoint,zfs_share_proto_t * proto)861da6c28aaSamw zfs_unshare_proto(zfs_handle_t *zhp, const char *mountpoint,
862da6c28aaSamw zfs_share_proto_t *proto)
8633bb79becSeschrock {
864ebedde84SEric Taylor libzfs_handle_t *hdl = zhp->zfs_hdl;
865ebedde84SEric Taylor struct mnttab entry;
86667331909Sdougm char *mntpt = NULL;
8673bb79becSeschrock
8683bb79becSeschrock /* check to see if need to unmount the filesystem */
8693bb79becSeschrock rewind(zhp->zfs_hdl->libzfs_mnttab);
870d8689a57Sdougm if (mountpoint != NULL)
871ebedde84SEric Taylor mountpoint = mntpt = zfs_strdup(hdl, mountpoint);
872d8689a57Sdougm
8733bb79becSeschrock if (mountpoint != NULL || ((zfs_get_type(zhp) == ZFS_TYPE_FILESYSTEM) &&
874ebedde84SEric Taylor libzfs_mnttab_find(hdl, zfs_get_name(zhp), &entry) == 0)) {
875da6c28aaSamw zfs_share_proto_t *curr_proto;
8763bb79becSeschrock
8773bb79becSeschrock if (mountpoint == NULL)
878da6c28aaSamw mntpt = zfs_strdup(zhp->zfs_hdl, entry.mnt_mountp);
8793bb79becSeschrock
880da6c28aaSamw for (curr_proto = proto; *curr_proto != PROTO_END;
881da6c28aaSamw curr_proto++) {
882da6c28aaSamw
883ebedde84SEric Taylor if (is_shared(hdl, mntpt, *curr_proto) &&
884ebedde84SEric Taylor unshare_one(hdl, zhp->zfs_name,
885da6c28aaSamw mntpt, *curr_proto) != 0) {
88667331909Sdougm if (mntpt != NULL)
88767331909Sdougm free(mntpt);
8883bb79becSeschrock return (-1);
889fa9e4066Sahrens }
89067331909Sdougm }
891da6c28aaSamw }
89267331909Sdougm if (mntpt != NULL)
89367331909Sdougm free(mntpt);
894fa9e4066Sahrens
895fa9e4066Sahrens return (0);
896fa9e4066Sahrens }
897fa9e4066Sahrens
898da6c28aaSamw int
zfs_unshare_nfs(zfs_handle_t * zhp,const char * mountpoint)899da6c28aaSamw zfs_unshare_nfs(zfs_handle_t *zhp, const char *mountpoint)
900da6c28aaSamw {
901da6c28aaSamw return (zfs_unshare_proto(zhp, mountpoint, nfs_only));
902da6c28aaSamw }
903da6c28aaSamw
904da6c28aaSamw int
zfs_unshare_smb(zfs_handle_t * zhp,const char * mountpoint)905da6c28aaSamw zfs_unshare_smb(zfs_handle_t *zhp, const char *mountpoint)
906da6c28aaSamw {
907da6c28aaSamw return (zfs_unshare_proto(zhp, mountpoint, smb_only));
908da6c28aaSamw }
909da6c28aaSamw
910fa9e4066Sahrens /*
911da6c28aaSamw * Same as zfs_unmountall(), but for NFS and SMB unshares.
912fa9e4066Sahrens */
913fa9e4066Sahrens int
zfs_unshareall_proto(zfs_handle_t * zhp,zfs_share_proto_t * proto)914da6c28aaSamw zfs_unshareall_proto(zfs_handle_t *zhp, zfs_share_proto_t *proto)
915fa9e4066Sahrens {
916fa9e4066Sahrens prop_changelist_t *clp;
917fa9e4066Sahrens int ret;
918fa9e4066Sahrens
9190069fd67STim Haley clp = changelist_gather(zhp, ZFS_PROP_SHARENFS, 0, 0);
920fa9e4066Sahrens if (clp == NULL)
921fa9e4066Sahrens return (-1);
922fa9e4066Sahrens
923da6c28aaSamw ret = changelist_unshare(clp, proto);
924fa9e4066Sahrens changelist_free(clp);
925fa9e4066Sahrens
926fa9e4066Sahrens return (ret);
927fa9e4066Sahrens }
928fa9e4066Sahrens
929da6c28aaSamw int
zfs_unshareall_nfs(zfs_handle_t * zhp)930da6c28aaSamw zfs_unshareall_nfs(zfs_handle_t *zhp)
931da6c28aaSamw {
932da6c28aaSamw return (zfs_unshareall_proto(zhp, nfs_only));
933da6c28aaSamw }
934da6c28aaSamw
935da6c28aaSamw int
zfs_unshareall_smb(zfs_handle_t * zhp)936da6c28aaSamw zfs_unshareall_smb(zfs_handle_t *zhp)
937da6c28aaSamw {
938da6c28aaSamw return (zfs_unshareall_proto(zhp, smb_only));
939da6c28aaSamw }
940da6c28aaSamw
941da6c28aaSamw int
zfs_unshareall(zfs_handle_t * zhp)942da6c28aaSamw zfs_unshareall(zfs_handle_t *zhp)
943da6c28aaSamw {
944da6c28aaSamw return (zfs_unshareall_proto(zhp, share_all_proto));
945da6c28aaSamw }
946da6c28aaSamw
947da6c28aaSamw int
zfs_unshareall_bypath(zfs_handle_t * zhp,const char * mountpoint)948da6c28aaSamw zfs_unshareall_bypath(zfs_handle_t *zhp, const char *mountpoint)
949da6c28aaSamw {
950da6c28aaSamw return (zfs_unshare_proto(zhp, mountpoint, share_all_proto));
951da6c28aaSamw }
952da6c28aaSamw
953fa9e4066Sahrens /*
954fa9e4066Sahrens * Remove the mountpoint associated with the current dataset, if necessary.
955fa9e4066Sahrens * We only remove the underlying directory if:
956fa9e4066Sahrens *
957fa9e4066Sahrens * - The mountpoint is not 'none' or 'legacy'
958fa9e4066Sahrens * - The mountpoint is non-empty
959fa9e4066Sahrens * - The mountpoint is the default or inherited
960fa9e4066Sahrens * - The 'zoned' property is set, or we're in a local zone
961fa9e4066Sahrens *
962fa9e4066Sahrens * Any other directories we leave alone.
963fa9e4066Sahrens */
964fa9e4066Sahrens void
remove_mountpoint(zfs_handle_t * zhp)965fa9e4066Sahrens remove_mountpoint(zfs_handle_t *zhp)
966fa9e4066Sahrens {
967fa9e4066Sahrens char mountpoint[ZFS_MAXPROPLEN];
968990b4856Slling zprop_source_t source;
969fa9e4066Sahrens
970e9dbad6fSeschrock if (!zfs_is_mountable(zhp, mountpoint, sizeof (mountpoint),
971e9dbad6fSeschrock &source))
972fa9e4066Sahrens return;
973fa9e4066Sahrens
974990b4856Slling if (source == ZPROP_SRC_DEFAULT ||
975990b4856Slling source == ZPROP_SRC_INHERITED) {
976fa9e4066Sahrens /*
977fa9e4066Sahrens * Try to remove the directory, silently ignoring any errors.
978fa9e4066Sahrens * The filesystem may have since been removed or moved around,
979e9dbad6fSeschrock * and this error isn't really useful to the administrator in
980e9dbad6fSeschrock * any way.
981fa9e4066Sahrens */
982fa9e4066Sahrens (void) rmdir(mountpoint);
983fa9e4066Sahrens }
984fa9e4066Sahrens }
9853bb79becSeschrock
9869d9a58e3SEric Taylor void
libzfs_add_handle(get_all_cb_t * cbp,zfs_handle_t * zhp)9879d9a58e3SEric Taylor libzfs_add_handle(get_all_cb_t *cbp, zfs_handle_t *zhp)
9889d9a58e3SEric Taylor {
9899d9a58e3SEric Taylor if (cbp->cb_alloc == cbp->cb_used) {
9909d9a58e3SEric Taylor size_t newsz;
9919d9a58e3SEric Taylor void *ptr;
9929d9a58e3SEric Taylor
9939d9a58e3SEric Taylor newsz = cbp->cb_alloc ? cbp->cb_alloc * 2 : 64;
9949d9a58e3SEric Taylor ptr = zfs_realloc(zhp->zfs_hdl,
9959d9a58e3SEric Taylor cbp->cb_handles, cbp->cb_alloc * sizeof (void *),
9969d9a58e3SEric Taylor newsz * sizeof (void *));
9979d9a58e3SEric Taylor cbp->cb_handles = ptr;
9989d9a58e3SEric Taylor cbp->cb_alloc = newsz;
9999d9a58e3SEric Taylor }
10009d9a58e3SEric Taylor cbp->cb_handles[cbp->cb_used++] = zhp;
10019d9a58e3SEric Taylor }
10023bb79becSeschrock
10033bb79becSeschrock static int
mount_cb(zfs_handle_t * zhp,void * data)10043bb79becSeschrock mount_cb(zfs_handle_t *zhp, void *data)
10053bb79becSeschrock {
10069d9a58e3SEric Taylor get_all_cb_t *cbp = data;
10073bb79becSeschrock
10089d9a58e3SEric Taylor if (!(zfs_get_type(zhp) & ZFS_TYPE_FILESYSTEM)) {
10093bb79becSeschrock zfs_close(zhp);
10103bb79becSeschrock return (0);
10113bb79becSeschrock }
10123bb79becSeschrock
1013a227b7f4Shs24103 if (zfs_prop_get_int(zhp, ZFS_PROP_CANMOUNT) == ZFS_CANMOUNT_NOAUTO) {
1014a227b7f4Shs24103 zfs_close(zhp);
1015a227b7f4Shs24103 return (0);
1016a227b7f4Shs24103 }
1017a227b7f4Shs24103
10188429b235SMatthew Ahrens /*
10198429b235SMatthew Ahrens * If this filesystem is inconsistent and has a receive resume
10208429b235SMatthew Ahrens * token, we can not mount it.
10218429b235SMatthew Ahrens */
10228429b235SMatthew Ahrens if (zfs_prop_get_int(zhp, ZFS_PROP_INCONSISTENT) &&
10238429b235SMatthew Ahrens zfs_prop_get(zhp, ZFS_PROP_RECEIVE_RESUME_TOKEN,
10248429b235SMatthew Ahrens NULL, 0, NULL, NULL, 0, B_TRUE) == 0) {
10258429b235SMatthew Ahrens zfs_close(zhp);
10268429b235SMatthew Ahrens return (0);
10278429b235SMatthew Ahrens }
10288429b235SMatthew Ahrens
10299d9a58e3SEric Taylor libzfs_add_handle(cbp, zhp);
10309d9a58e3SEric Taylor if (zfs_iter_filesystems(zhp, mount_cb, cbp) != 0) {
10319d9a58e3SEric Taylor zfs_close(zhp);
10323bb79becSeschrock return (-1);
10339d9a58e3SEric Taylor }
10349d9a58e3SEric Taylor return (0);
10353bb79becSeschrock }
10363bb79becSeschrock
10379d9a58e3SEric Taylor int
libzfs_dataset_cmp(const void * a,const void * b)10389d9a58e3SEric Taylor libzfs_dataset_cmp(const void *a, const void *b)
10393bb79becSeschrock {
10403bb79becSeschrock zfs_handle_t **za = (zfs_handle_t **)a;
10413bb79becSeschrock zfs_handle_t **zb = (zfs_handle_t **)b;
10423bb79becSeschrock char mounta[MAXPATHLEN];
10433bb79becSeschrock char mountb[MAXPATHLEN];
1044f3861e1aSahl boolean_t gota, gotb;
10453bb79becSeschrock
1046f3861e1aSahl if ((gota = (zfs_get_type(*za) == ZFS_TYPE_FILESYSTEM)) != 0)
10473bb79becSeschrock verify(zfs_prop_get(*za, ZFS_PROP_MOUNTPOINT, mounta,
10483bb79becSeschrock sizeof (mounta), NULL, NULL, 0, B_FALSE) == 0);
1049f3861e1aSahl if ((gotb = (zfs_get_type(*zb) == ZFS_TYPE_FILESYSTEM)) != 0)
10503bb79becSeschrock verify(zfs_prop_get(*zb, ZFS_PROP_MOUNTPOINT, mountb,
10513bb79becSeschrock sizeof (mountb), NULL, NULL, 0, B_FALSE) == 0);
10523bb79becSeschrock
1053f3861e1aSahl if (gota && gotb)
10543bb79becSeschrock return (strcmp(mounta, mountb));
1055f3861e1aSahl
1056f3861e1aSahl if (gota)
1057f3861e1aSahl return (-1);
1058f3861e1aSahl if (gotb)
1059f3861e1aSahl return (1);
1060f3861e1aSahl
1061f3861e1aSahl return (strcmp(zfs_get_name(a), zfs_get_name(b)));
10623bb79becSeschrock }
10633bb79becSeschrock
1064f3861e1aSahl /*
1065f3861e1aSahl * Mount and share all datasets within the given pool. This assumes that no
1066f3861e1aSahl * datasets within the pool are currently mounted. Because users can create
1067f3861e1aSahl * complicated nested hierarchies of mountpoints, we first gather all the
1068f3861e1aSahl * datasets and mountpoints within the pool, and sort them by mountpoint. Once
1069f3861e1aSahl * we have the list of all filesystems, we iterate over them in order and mount
1070f3861e1aSahl * and/or share each one.
1071f3861e1aSahl */
1072f3861e1aSahl #pragma weak zpool_mount_datasets = zpool_enable_datasets
10733bb79becSeschrock int
zpool_enable_datasets(zpool_handle_t * zhp,const char * mntopts,int flags)1074f3861e1aSahl zpool_enable_datasets(zpool_handle_t *zhp, const char *mntopts, int flags)
10753bb79becSeschrock {
10769d9a58e3SEric Taylor get_all_cb_t cb = { 0 };
10773bb79becSeschrock libzfs_handle_t *hdl = zhp->zpool_hdl;
10783bb79becSeschrock zfs_handle_t *zfsp;
10793bb79becSeschrock int i, ret = -1;
108067331909Sdougm int *good;
10813bb79becSeschrock
10823bb79becSeschrock /*
1083d87468daSrm160521 * Gather all non-snap datasets within the pool.
10843bb79becSeschrock */
1085990b4856Slling if ((zfsp = zfs_open(hdl, zhp->zpool_name, ZFS_TYPE_DATASET)) == NULL)
10863bb79becSeschrock goto out;
10873bb79becSeschrock
10889d9a58e3SEric Taylor libzfs_add_handle(&cb, zfsp);
1089d87468daSrm160521 if (zfs_iter_filesystems(zfsp, mount_cb, &cb) != 0)
10903bb79becSeschrock goto out;
10913bb79becSeschrock /*
10923bb79becSeschrock * Sort the datasets by mountpoint.
10933bb79becSeschrock */
10949d9a58e3SEric Taylor qsort(cb.cb_handles, cb.cb_used, sizeof (void *),
10959d9a58e3SEric Taylor libzfs_dataset_cmp);
10963bb79becSeschrock
10973bb79becSeschrock /*
109867331909Sdougm * And mount all the datasets, keeping track of which ones
10996e77af0aSDavid Pacheco * succeeded or failed.
11003bb79becSeschrock */
11016e77af0aSDavid Pacheco if ((good = zfs_alloc(zhp->zpool_hdl,
11026e77af0aSDavid Pacheco cb.cb_used * sizeof (int))) == NULL)
11036e77af0aSDavid Pacheco goto out;
11046e77af0aSDavid Pacheco
11053bb79becSeschrock ret = 0;
11063bb79becSeschrock for (i = 0; i < cb.cb_used; i++) {
11079d9a58e3SEric Taylor if (zfs_mount(cb.cb_handles[i], mntopts, flags) != 0)
110867331909Sdougm ret = -1;
1109d8689a57Sdougm else
111067331909Sdougm good[i] = 1;
111167331909Sdougm }
11125b6e0c46Sdougm
111367331909Sdougm /*
111467331909Sdougm * Then share all the ones that need to be shared. This needs
111567331909Sdougm * to be a separate pass in order to avoid excessive reloading
111667331909Sdougm * of the configuration. Good should never be NULL since
111767331909Sdougm * zfs_alloc is supposed to exit if memory isn't available.
111867331909Sdougm */
111967331909Sdougm for (i = 0; i < cb.cb_used; i++) {
11209d9a58e3SEric Taylor if (good[i] && zfs_share(cb.cb_handles[i]) != 0)
11213bb79becSeschrock ret = -1;
11223bb79becSeschrock }
11233bb79becSeschrock
112467331909Sdougm free(good);
112567331909Sdougm
11263bb79becSeschrock out:
11273bb79becSeschrock for (i = 0; i < cb.cb_used; i++)
11289d9a58e3SEric Taylor zfs_close(cb.cb_handles[i]);
11299d9a58e3SEric Taylor free(cb.cb_handles);
11303bb79becSeschrock
11313bb79becSeschrock return (ret);
11323bb79becSeschrock }
11333bb79becSeschrock
11343bb79becSeschrock static int
mountpoint_compare(const void * a,const void * b)11353bb79becSeschrock mountpoint_compare(const void *a, const void *b)
11363bb79becSeschrock {
11373bb79becSeschrock const char *mounta = *((char **)a);
11383bb79becSeschrock const char *mountb = *((char **)b);
11393bb79becSeschrock
11403bb79becSeschrock return (strcmp(mountb, mounta));
11413bb79becSeschrock }
11423bb79becSeschrock
1143681d9761SEric Taylor /* alias for 2002/240 */
1144681d9761SEric Taylor #pragma weak zpool_unmount_datasets = zpool_disable_datasets
1145f3861e1aSahl /*
1146f3861e1aSahl * Unshare and unmount all datasets within the given pool. We don't want to
1147f3861e1aSahl * rely on traversing the DSL to discover the filesystems within the pool,
1148f3861e1aSahl * because this may be expensive (if not all of them are mounted), and can fail
1149f3861e1aSahl * arbitrarily (on I/O error, for example). Instead, we walk /etc/mnttab and
1150f3861e1aSahl * gather all the filesystems that are currently mounted.
1151f3861e1aSahl */
11523bb79becSeschrock int
zpool_disable_datasets(zpool_handle_t * zhp,boolean_t force)1153f3861e1aSahl zpool_disable_datasets(zpool_handle_t *zhp, boolean_t force)
11543bb79becSeschrock {
11553bb79becSeschrock int used, alloc;
11563bb79becSeschrock struct mnttab entry;
11573bb79becSeschrock size_t namelen;
11583bb79becSeschrock char **mountpoints = NULL;
11593bb79becSeschrock zfs_handle_t **datasets = NULL;
11603bb79becSeschrock libzfs_handle_t *hdl = zhp->zpool_hdl;
11613bb79becSeschrock int i;
11623bb79becSeschrock int ret = -1;
11633bb79becSeschrock int flags = (force ? MS_FORCE : 0);
11643bb79becSeschrock
11653bb79becSeschrock namelen = strlen(zhp->zpool_name);
11663bb79becSeschrock
11673bb79becSeschrock rewind(hdl->libzfs_mnttab);
11683bb79becSeschrock used = alloc = 0;
11693bb79becSeschrock while (getmntent(hdl->libzfs_mnttab, &entry) == 0) {
11703bb79becSeschrock /*
11713bb79becSeschrock * Ignore non-ZFS entries.
11723bb79becSeschrock */
11733bb79becSeschrock if (entry.mnt_fstype == NULL ||
11743bb79becSeschrock strcmp(entry.mnt_fstype, MNTTYPE_ZFS) != 0)
11753bb79becSeschrock continue;
11763bb79becSeschrock
11773bb79becSeschrock /*
11783bb79becSeschrock * Ignore filesystems not within this pool.
11793bb79becSeschrock */
11803bb79becSeschrock if (entry.mnt_mountp == NULL ||
11813bb79becSeschrock strncmp(entry.mnt_special, zhp->zpool_name, namelen) != 0 ||
11823bb79becSeschrock (entry.mnt_special[namelen] != '/' &&
11833bb79becSeschrock entry.mnt_special[namelen] != '\0'))
11843bb79becSeschrock continue;
11853bb79becSeschrock
11863bb79becSeschrock /*
11873bb79becSeschrock * At this point we've found a filesystem within our pool. Add
11883bb79becSeschrock * it to our growing list.
11893bb79becSeschrock */
11903bb79becSeschrock if (used == alloc) {
11913bb79becSeschrock if (alloc == 0) {
11923bb79becSeschrock if ((mountpoints = zfs_alloc(hdl,
11933bb79becSeschrock 8 * sizeof (void *))) == NULL)
11943bb79becSeschrock goto out;
11953bb79becSeschrock
11963bb79becSeschrock if ((datasets = zfs_alloc(hdl,
11973bb79becSeschrock 8 * sizeof (void *))) == NULL)
11983bb79becSeschrock goto out;
11993bb79becSeschrock
12003bb79becSeschrock alloc = 8;
12013bb79becSeschrock } else {
1202e9dbad6fSeschrock void *ptr;
12033bb79becSeschrock
1204e9dbad6fSeschrock if ((ptr = zfs_realloc(hdl, mountpoints,
1205e9dbad6fSeschrock alloc * sizeof (void *),
12063bb79becSeschrock alloc * 2 * sizeof (void *))) == NULL)
12073bb79becSeschrock goto out;
1208e9dbad6fSeschrock mountpoints = ptr;
12093bb79becSeschrock
1210e9dbad6fSeschrock if ((ptr = zfs_realloc(hdl, datasets,
1211e9dbad6fSeschrock alloc * sizeof (void *),
12123bb79becSeschrock alloc * 2 * sizeof (void *))) == NULL)
12133bb79becSeschrock goto out;
1214e9dbad6fSeschrock datasets = ptr;
12153bb79becSeschrock
12163bb79becSeschrock alloc *= 2;
12173bb79becSeschrock }
12183bb79becSeschrock }
12193bb79becSeschrock
12203bb79becSeschrock if ((mountpoints[used] = zfs_strdup(hdl,
12213bb79becSeschrock entry.mnt_mountp)) == NULL)
12223bb79becSeschrock goto out;
12233bb79becSeschrock
12243bb79becSeschrock /*
12253bb79becSeschrock * This is allowed to fail, in case there is some I/O error. It
12263bb79becSeschrock * is only used to determine if we need to remove the underlying
12273bb79becSeschrock * mountpoint, so failure is not fatal.
12283bb79becSeschrock */
12293bb79becSeschrock datasets[used] = make_dataset_handle(hdl, entry.mnt_special);
12303bb79becSeschrock
12313bb79becSeschrock used++;
12323bb79becSeschrock }
12333bb79becSeschrock
12343bb79becSeschrock /*
12353bb79becSeschrock * At this point, we have the entire list of filesystems, so sort it by
12363bb79becSeschrock * mountpoint.
12373bb79becSeschrock */
12383bb79becSeschrock qsort(mountpoints, used, sizeof (char *), mountpoint_compare);
12393bb79becSeschrock
12403bb79becSeschrock /*
12413bb79becSeschrock * Walk through and first unshare everything.
12423bb79becSeschrock */
12433bb79becSeschrock for (i = 0; i < used; i++) {
1244da6c28aaSamw zfs_share_proto_t *curr_proto;
1245da6c28aaSamw for (curr_proto = share_all_proto; *curr_proto != PROTO_END;
1246da6c28aaSamw curr_proto++) {
1247da6c28aaSamw if (is_shared(hdl, mountpoints[i], *curr_proto) &&
1248da6c28aaSamw unshare_one(hdl, mountpoints[i],
1249da6c28aaSamw mountpoints[i], *curr_proto) != 0)
12503bb79becSeschrock goto out;
12513bb79becSeschrock }
1252da6c28aaSamw }
12533bb79becSeschrock
12543bb79becSeschrock /*
12553bb79becSeschrock * Now unmount everything, removing the underlying directories as
12563bb79becSeschrock * appropriate.
12573bb79becSeschrock */
12583bb79becSeschrock for (i = 0; i < used; i++) {
12593bb79becSeschrock if (unmount_one(hdl, mountpoints[i], flags) != 0)
12603bb79becSeschrock goto out;
1261e9dbad6fSeschrock }
12623bb79becSeschrock
1263e9dbad6fSeschrock for (i = 0; i < used; i++) {
12643bb79becSeschrock if (datasets[i])
12653bb79becSeschrock remove_mountpoint(datasets[i]);
12663bb79becSeschrock }
12673bb79becSeschrock
12683bb79becSeschrock ret = 0;
12693bb79becSeschrock out:
12703bb79becSeschrock for (i = 0; i < used; i++) {
12713bb79becSeschrock if (datasets[i])
12723bb79becSeschrock zfs_close(datasets[i]);
12733bb79becSeschrock free(mountpoints[i]);
12743bb79becSeschrock }
12753bb79becSeschrock free(datasets);
12763bb79becSeschrock free(mountpoints);
12773bb79becSeschrock
12783bb79becSeschrock return (ret);
12793bb79becSeschrock }
1280