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.
240dfe541eSEvan Layton */
250dfe541eSEvan Layton
260dfe541eSEvan Layton /*
270dfe541eSEvan Layton * Copyright 2019 Nexenta Systems, Inc.
280dfe541eSEvan Layton * Copyright (c) 2014, 2016 by Delphix. All rights reserved.
2988f61deeSIgor Kozhukhov * Copyright 2016 Igor Kozhukhov <ikozhukhov@gmail.com>
301c18e8fbSJerry Jelinek * Copyright 2017 Joyent, Inc.
314f4378ccSAndrew Stormont * Copyright 2017 RackTop Systems.
32bc4c0ff1SAndy Fiddaman * Copyright 2018 OmniOS Community Edition (OmniOSce) Association.
33fa9e4066Sahrens */
34fa9e4066Sahrens
35fa9e4066Sahrens /*
36fa9e4066Sahrens * Routines to manage ZFS mounts. We separate all the nasty routines that have
37f3861e1aSahl * to deal with the OS. The following functions are the main entry points --
38f3861e1aSahl * they are used by mount and unmount and when changing a filesystem's
39f3861e1aSahl * mountpoint.
40fa9e4066Sahrens *
41591e0e13SSebastien Roy * zfs_is_mounted()
42591e0e13SSebastien Roy * zfs_mount()
43591e0e13SSebastien Roy * zfs_unmount()
44591e0e13SSebastien Roy * zfs_unmountall()
45fa9e4066Sahrens *
46f3861e1aSahl * This file also contains the functions used to manage sharing filesystems via
47f3861e1aSahl * NFS and iSCSI:
48fa9e4066Sahrens *
49591e0e13SSebastien Roy * zfs_is_shared()
50591e0e13SSebastien Roy * zfs_share()
51591e0e13SSebastien Roy * zfs_unshare()
52f3861e1aSahl *
53591e0e13SSebastien Roy * zfs_is_shared_nfs()
54591e0e13SSebastien Roy * zfs_is_shared_smb()
55591e0e13SSebastien Roy * zfs_share_proto()
56591e0e13SSebastien Roy * zfs_shareall();
57591e0e13SSebastien Roy * zfs_unshare_nfs()
58591e0e13SSebastien Roy * zfs_unshare_smb()
59591e0e13SSebastien Roy * zfs_unshareall_nfs()
60da6c28aaSamw * zfs_unshareall_smb()
61da6c28aaSamw * zfs_unshareall()
62da6c28aaSamw * zfs_unshareall_bypath()
633bb79becSeschrock *
643bb79becSeschrock * The following functions are available for pool consumers, and will
65f3861e1aSahl * mount/unmount and share/unshare all datasets within pool:
663bb79becSeschrock *
67591e0e13SSebastien Roy * zpool_enable_datasets()
68591e0e13SSebastien Roy * zpool_disable_datasets()
69fa9e4066Sahrens */
70fa9e4066Sahrens
71fa9e4066Sahrens #include <dirent.h>
72d8d59944Sahl #include <dlfcn.h>
73fa9e4066Sahrens #include <errno.h>
74d420209dSAlex Reece #include <fcntl.h>
75fa9e4066Sahrens #include <libgen.h>
76fa9e4066Sahrens #include <libintl.h>
77fa9e4066Sahrens #include <stdio.h>
78fa9e4066Sahrens #include <stdlib.h>
79fa9e4066Sahrens #include <strings.h>
80fa9e4066Sahrens #include <unistd.h>
81fa9e4066Sahrens #include <zone.h>
82fa9e4066Sahrens #include <sys/mntent.h>
83fa9e4066Sahrens #include <sys/mount.h>
84fa9e4066Sahrens #include <sys/stat.h>
85873c4903SPrakash Surya #include <sys/statvfs.h>
86eb633035STom Caputi #include <sys/dsl_crypt.h>
87fa9e4066Sahrens
88fa9e4066Sahrens #include <libzfs.h>
89fa9e4066Sahrens
90fa9e4066Sahrens #include "libzfs_impl.h"
91591e0e13SSebastien Roy #include "libzfs_taskq.h"
92fa9e4066Sahrens
9367331909Sdougm #include <libshare.h>
9467331909Sdougm #include <sys/systeminfo.h>
9567331909Sdougm #define MAXISALEN 257 /* based on sysinfo(2) man page */
9667331909Sdougm
97591e0e13SSebastien Roy static int mount_tq_nthr = 512; /* taskq threads for multi-threaded mounting */
98591e0e13SSebastien Roy
99591e0e13SSebastien Roy static void zfs_mount_task(void *);
100da6c28aaSamw static int zfs_share_proto(zfs_handle_t *, zfs_share_proto_t *);
101da6c28aaSamw zfs_share_type_t zfs_is_shared_proto(zfs_handle_t *, char **,
102da6c28aaSamw zfs_share_proto_t);
103da6c28aaSamw
104da6c28aaSamw /*
1054f4378ccSAndrew Stormont * The share protocols table must be in the same order as the zfs_share_proto_t
106da6c28aaSamw * enum in libzfs_impl.h
107da6c28aaSamw */
108da6c28aaSamw typedef struct {
109da6c28aaSamw zfs_prop_t p_prop;
110da6c28aaSamw char *p_name;
111da6c28aaSamw int p_share_err;
112da6c28aaSamw int p_unshare_err;
113da6c28aaSamw } proto_table_t;
114da6c28aaSamw
115da6c28aaSamw proto_table_t proto_table[PROTO_END] = {
116da6c28aaSamw {ZFS_PROP_SHARENFS, "nfs", EZFS_SHARENFSFAILED, EZFS_UNSHARENFSFAILED},
117da6c28aaSamw {ZFS_PROP_SHARESMB, "smb", EZFS_SHARESMBFAILED, EZFS_UNSHARESMBFAILED},
118da6c28aaSamw };
119da6c28aaSamw
120da6c28aaSamw zfs_share_proto_t nfs_only[] = {
121da6c28aaSamw PROTO_NFS,
122da6c28aaSamw PROTO_END
123da6c28aaSamw };
124da6c28aaSamw
125da6c28aaSamw zfs_share_proto_t smb_only[] = {
126da6c28aaSamw PROTO_SMB,
127da6c28aaSamw PROTO_END
128da6c28aaSamw };
129da6c28aaSamw zfs_share_proto_t share_all_proto[] = {
130da6c28aaSamw PROTO_NFS,
131da6c28aaSamw PROTO_SMB,
132da6c28aaSamw PROTO_END
133da6c28aaSamw };
134da6c28aaSamw
135fa9e4066Sahrens /*
136da6c28aaSamw * Search the sharetab for the given mountpoint and protocol, returning
137da6c28aaSamw * a zfs_share_type_t value.
138fa9e4066Sahrens */
139da6c28aaSamw static zfs_share_type_t
is_shared(libzfs_handle_t * hdl,const char * mountpoint,zfs_share_proto_t proto)140da6c28aaSamw is_shared(libzfs_handle_t *hdl, const char *mountpoint, zfs_share_proto_t proto)
141fa9e4066Sahrens {
142fa9e4066Sahrens char buf[MAXPATHLEN], *tab;
143da6c28aaSamw char *ptr;
144fa9e4066Sahrens
14599653d4eSeschrock if (hdl->libzfs_sharetab == NULL)
146da6c28aaSamw return (SHARED_NOT_SHARED);
147fa9e4066Sahrens
14899653d4eSeschrock (void) fseek(hdl->libzfs_sharetab, 0, SEEK_SET);
149fa9e4066Sahrens
15099653d4eSeschrock while (fgets(buf, sizeof (buf), hdl->libzfs_sharetab) != NULL) {
151fa9e4066Sahrens
152fa9e4066Sahrens /* the mountpoint is the first entry on each line */
153da6c28aaSamw if ((tab = strchr(buf, '\t')) == NULL)
154da6c28aaSamw continue;
155da6c28aaSamw
156da6c28aaSamw *tab = '\0';
157da6c28aaSamw if (strcmp(buf, mountpoint) == 0) {
158da6c28aaSamw /*
159da6c28aaSamw * the protocol field is the third field
160da6c28aaSamw * skip over second field
161da6c28aaSamw */
162da6c28aaSamw ptr = ++tab;
163da6c28aaSamw if ((tab = strchr(ptr, '\t')) == NULL)
164da6c28aaSamw continue;
165da6c28aaSamw ptr = ++tab;
166da6c28aaSamw if ((tab = strchr(ptr, '\t')) == NULL)
167da6c28aaSamw continue;
168fa9e4066Sahrens *tab = '\0';
169da6c28aaSamw if (strcmp(ptr,
170da6c28aaSamw proto_table[proto].p_name) == 0) {
171da6c28aaSamw switch (proto) {
172da6c28aaSamw case PROTO_NFS:
173da6c28aaSamw return (SHARED_NFS);
174da6c28aaSamw case PROTO_SMB:
175da6c28aaSamw return (SHARED_SMB);
176da6c28aaSamw default:
177da6c28aaSamw return (0);
178da6c28aaSamw }
179da6c28aaSamw }
180fa9e4066Sahrens }
181fa9e4066Sahrens }
182fa9e4066Sahrens
183da6c28aaSamw return (SHARED_NOT_SHARED);
184fa9e4066Sahrens }
185fa9e4066Sahrens
18699653d4eSeschrock static boolean_t
dir_is_empty_stat(const char * dirname)187873c4903SPrakash Surya dir_is_empty_stat(const char *dirname)
188873c4903SPrakash Surya {
189873c4903SPrakash Surya struct stat st;
190873c4903SPrakash Surya
191873c4903SPrakash Surya /*
192873c4903SPrakash Surya * We only want to return false if the given path is a non empty
193873c4903SPrakash Surya * directory, all other errors are handled elsewhere.
194873c4903SPrakash Surya */
195873c4903SPrakash Surya if (stat(dirname, &st) < 0 || !S_ISDIR(st.st_mode)) {
196873c4903SPrakash Surya return (B_TRUE);
197873c4903SPrakash Surya }
198873c4903SPrakash Surya
199873c4903SPrakash Surya /*
200873c4903SPrakash Surya * An empty directory will still have two entries in it, one
201873c4903SPrakash Surya * entry for each of "." and "..".
202873c4903SPrakash Surya */
203873c4903SPrakash Surya if (st.st_size > 2) {
204873c4903SPrakash Surya return (B_FALSE);
205873c4903SPrakash Surya }
206873c4903SPrakash Surya
207873c4903SPrakash Surya return (B_TRUE);
208873c4903SPrakash Surya }
209873c4903SPrakash Surya
210873c4903SPrakash Surya static boolean_t
dir_is_empty_readdir(const char * dirname)211873c4903SPrakash Surya dir_is_empty_readdir(const char *dirname)
212fa9e4066Sahrens {
213fa9e4066Sahrens DIR *dirp;
214fa9e4066Sahrens struct dirent64 *dp;
215d420209dSAlex Reece int dirfd;
216fa9e4066Sahrens
217d420209dSAlex Reece if ((dirfd = openat(AT_FDCWD, dirname,
218d420209dSAlex Reece O_RDONLY | O_NDELAY | O_LARGEFILE | O_CLOEXEC, 0)) < 0) {
21999653d4eSeschrock return (B_TRUE);
220d420209dSAlex Reece }
221d420209dSAlex Reece
222d420209dSAlex Reece if ((dirp = fdopendir(dirfd)) == NULL) {
223ba6e7e65SSowrabha Gopal (void) close(dirfd);
224d420209dSAlex Reece return (B_TRUE);
225d420209dSAlex Reece }
226fa9e4066Sahrens
227fa9e4066Sahrens while ((dp = readdir64(dirp)) != NULL) {
228fa9e4066Sahrens
229fa9e4066Sahrens if (strcmp(dp->d_name, ".") == 0 ||
230fa9e4066Sahrens strcmp(dp->d_name, "..") == 0)
231fa9e4066Sahrens continue;
232fa9e4066Sahrens
233fa9e4066Sahrens (void) closedir(dirp);
23499653d4eSeschrock return (B_FALSE);
235fa9e4066Sahrens }
236fa9e4066Sahrens
237fa9e4066Sahrens (void) closedir(dirp);
23899653d4eSeschrock return (B_TRUE);
239fa9e4066Sahrens }
240fa9e4066Sahrens
241873c4903SPrakash Surya /*
242873c4903SPrakash Surya * Returns true if the specified directory is empty. If we can't open the
243873c4903SPrakash Surya * directory at all, return true so that the mount can fail with a more
244873c4903SPrakash Surya * informative error message.
245873c4903SPrakash Surya */
246873c4903SPrakash Surya static boolean_t
dir_is_empty(const char * dirname)247873c4903SPrakash Surya dir_is_empty(const char *dirname)
248873c4903SPrakash Surya {
249873c4903SPrakash Surya struct statvfs64 st;
250873c4903SPrakash Surya
251873c4903SPrakash Surya /*
252873c4903SPrakash Surya * If the statvfs call fails or the filesystem is not a ZFS
253873c4903SPrakash Surya * filesystem, fall back to the slow path which uses readdir.
254873c4903SPrakash Surya */
255873c4903SPrakash Surya if ((statvfs64(dirname, &st) != 0) ||
256873c4903SPrakash Surya (strcmp(st.f_basetype, "zfs") != 0)) {
257873c4903SPrakash Surya return (dir_is_empty_readdir(dirname));
258873c4903SPrakash Surya }
259873c4903SPrakash Surya
260873c4903SPrakash Surya /*
261873c4903SPrakash Surya * At this point, we know the provided path is on a ZFS
262873c4903SPrakash Surya * filesystem, so we can use stat instead of readdir to
263873c4903SPrakash Surya * determine if the directory is empty or not. We try to avoid
264873c4903SPrakash Surya * using readdir because that requires opening "dirname"; this
265873c4903SPrakash Surya * open file descriptor can potentially end up in a child
266873c4903SPrakash Surya * process if there's a concurrent fork, thus preventing the
267873c4903SPrakash Surya * zfs_mount() from otherwise succeeding (the open file
268873c4903SPrakash Surya * descriptor inherited by the child process will cause the
269873c4903SPrakash Surya * parent's mount to fail with EBUSY). The performance
270873c4903SPrakash Surya * implications of replacing the open, read, and close with a
271873c4903SPrakash Surya * single stat is nice; but is not the main motivation for the
272873c4903SPrakash Surya * added complexity.
273873c4903SPrakash Surya */
274873c4903SPrakash Surya return (dir_is_empty_stat(dirname));
275873c4903SPrakash Surya }
276873c4903SPrakash Surya
277fa9e4066Sahrens /*
278fa9e4066Sahrens * Checks to see if the mount is active. If the filesystem is mounted, we fill
279fa9e4066Sahrens * in 'where' with the current mountpoint, and return 1. Otherwise, we return
280fa9e4066Sahrens * 0.
281fa9e4066Sahrens */
28299653d4eSeschrock boolean_t
is_mounted(libzfs_handle_t * zfs_hdl,const char * special,char ** where)28355434c77Sek is_mounted(libzfs_handle_t *zfs_hdl, const char *special, char **where)
284fa9e4066Sahrens {
285ebedde84SEric Taylor struct mnttab entry;
286fa9e4066Sahrens
287ebedde84SEric Taylor if (libzfs_mnttab_find(zfs_hdl, special, &entry) != 0)
28899653d4eSeschrock return (B_FALSE);
289fa9e4066Sahrens
290fa9e4066Sahrens if (where != NULL)
29155434c77Sek *where = zfs_strdup(zfs_hdl, entry.mnt_mountp);
292fa9e4066Sahrens
29399653d4eSeschrock return (B_TRUE);
294fa9e4066Sahrens }
295fa9e4066Sahrens
29655434c77Sek boolean_t
zfs_is_mounted(zfs_handle_t * zhp,char ** where)29755434c77Sek zfs_is_mounted(zfs_handle_t *zhp, char **where)
29855434c77Sek {
29955434c77Sek return (is_mounted(zhp->zfs_hdl, zfs_get_name(zhp), where));
30055434c77Sek }
30155434c77Sek
302e9dbad6fSeschrock /*
303e9dbad6fSeschrock * Returns true if the given dataset is mountable, false otherwise. Returns the
304e9dbad6fSeschrock * mountpoint in 'buf'.
305e9dbad6fSeschrock */
306e9dbad6fSeschrock static boolean_t
zfs_is_mountable(zfs_handle_t * zhp,char * buf,size_t buflen,zprop_source_t * source)307e9dbad6fSeschrock zfs_is_mountable(zfs_handle_t *zhp, char *buf, size_t buflen,
308990b4856Slling zprop_source_t *source)
309e9dbad6fSeschrock {
3109adfa60dSMatthew Ahrens char sourceloc[MAXNAMELEN];
311990b4856Slling zprop_source_t sourcetype;
312e9dbad6fSeschrock
313*4c2bdae2STim Chase if (!zfs_prop_valid_for_type(ZFS_PROP_MOUNTPOINT, zhp->zfs_type,
314*4c2bdae2STim Chase B_FALSE))
315e9dbad6fSeschrock return (B_FALSE);
316e9dbad6fSeschrock
317e9dbad6fSeschrock verify(zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, buf, buflen,
318e9dbad6fSeschrock &sourcetype, sourceloc, sizeof (sourceloc), B_FALSE) == 0);
319e9dbad6fSeschrock
320e9dbad6fSeschrock if (strcmp(buf, ZFS_MOUNTPOINT_NONE) == 0 ||
321e9dbad6fSeschrock strcmp(buf, ZFS_MOUNTPOINT_LEGACY) == 0)
322e9dbad6fSeschrock return (B_FALSE);
323e9dbad6fSeschrock
324a227b7f4Shs if (zfs_prop_get_int(zhp, ZFS_PROP_CANMOUNT) == ZFS_CANMOUNT_OFF)
325e9dbad6fSeschrock return (B_FALSE);
326e9dbad6fSeschrock
327e9dbad6fSeschrock if (zfs_prop_get_int(zhp, ZFS_PROP_ZONED) &&
328e9dbad6fSeschrock getzoneid() == GLOBAL_ZONEID)
329e9dbad6fSeschrock return (B_FALSE);
330e9dbad6fSeschrock
331e9dbad6fSeschrock if (source)
332e9dbad6fSeschrock *source = sourcetype;
333e9dbad6fSeschrock
334e9dbad6fSeschrock return (B_TRUE);
335e9dbad6fSeschrock }
336e9dbad6fSeschrock
337fa9e4066Sahrens /*
338fa9e4066Sahrens * Mount the given filesystem.
339fa9e4066Sahrens */
340fa9e4066Sahrens int
zfs_mount(zfs_handle_t * zhp,const char * options,int flags)341fa9e4066Sahrens zfs_mount(zfs_handle_t *zhp, const char *options, int flags)
342fa9e4066Sahrens {
343fa9e4066Sahrens struct stat buf;
344fa9e4066Sahrens char mountpoint[ZFS_MAXPROPLEN];
345fa9e4066Sahrens char mntopts[MNT_LINE_MAX];
34699653d4eSeschrock libzfs_handle_t *hdl = zhp->zfs_hdl;
347eb633035STom Caputi uint64_t keystatus;
348eb633035STom Caputi int rc;
349fa9e4066Sahrens
350fa9e4066Sahrens if (options == NULL)
351fa9e4066Sahrens mntopts[0] = '\0';
352fa9e4066Sahrens else
353fa9e4066Sahrens (void) strlcpy(mntopts, options, sizeof (mntopts));
354fa9e4066Sahrens
355f9af39baSGeorge Wilson /*
356f9af39baSGeorge Wilson * If the pool is imported read-only then all mounts must be read-only
357f9af39baSGeorge Wilson */
358f9af39baSGeorge Wilson if (zpool_get_prop_int(zhp->zpool_hdl, ZPOOL_PROP_READONLY, NULL))
359f9af39baSGeorge Wilson flags |= MS_RDONLY;
360f9af39baSGeorge Wilson
361e9dbad6fSeschrock if (!zfs_is_mountable(zhp, mountpoint, sizeof (mountpoint), NULL))
36299653d4eSeschrock return (0);
363fa9e4066Sahrens
364eb633035STom Caputi /*
365eb633035STom Caputi * If the filesystem is encrypted the key must be loaded in order to
366eb633035STom Caputi * mount. If the key isn't loaded, the MS_CRYPT flag decides whether
367eb633035STom Caputi * or not we attempt to load the keys. Note: we must call
368eb633035STom Caputi * zfs_refresh_properties() here since some callers of this function
369eb633035STom Caputi * (most notably zpool_enable_datasets()) may implicitly load our key
370eb633035STom Caputi * by loading the parent's key first.
371eb633035STom Caputi */
372eb633035STom Caputi if (zfs_prop_get_int(zhp, ZFS_PROP_ENCRYPTION) != ZIO_CRYPT_OFF) {
373eb633035STom Caputi zfs_refresh_properties(zhp);
374eb633035STom Caputi keystatus = zfs_prop_get_int(zhp, ZFS_PROP_KEYSTATUS);
375eb633035STom Caputi
376eb633035STom Caputi /*
377eb633035STom Caputi * If the key is unavailable and MS_CRYPT is set give the
378eb633035STom Caputi * user a chance to enter the key. Otherwise just fail
379eb633035STom Caputi * immediately.
380eb633035STom Caputi */
381eb633035STom Caputi if (keystatus == ZFS_KEYSTATUS_UNAVAILABLE) {
382eb633035STom Caputi if (flags & MS_CRYPT) {
383eb633035STom Caputi rc = zfs_crypto_load_key(zhp, B_FALSE, NULL);
384eb633035STom Caputi if (rc != 0)
385eb633035STom Caputi return (rc);
386eb633035STom Caputi } else {
387eb633035STom Caputi zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
388eb633035STom Caputi "encryption key not loaded"));
389eb633035STom Caputi return (zfs_error_fmt(hdl, EZFS_MOUNTFAILED,
390eb633035STom Caputi dgettext(TEXT_DOMAIN, "cannot mount '%s'"),
391eb633035STom Caputi mountpoint));
392eb633035STom Caputi }
393eb633035STom Caputi }
394eb633035STom Caputi
395eb633035STom Caputi }
396eb633035STom Caputi
397fa9e4066Sahrens /* Create the directory if it doesn't already exist */
398fa9e4066Sahrens if (lstat(mountpoint, &buf) != 0) {
399fa9e4066Sahrens if (mkdirp(mountpoint, 0755) != 0) {
40099653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
40199653d4eSeschrock "failed to create mountpoint"));
402ece3d9b3Slling return (zfs_error_fmt(hdl, EZFS_MOUNTFAILED,
40399653d4eSeschrock dgettext(TEXT_DOMAIN, "cannot mount '%s'"),
40499653d4eSeschrock mountpoint));
405fa9e4066Sahrens }
406fa9e4066Sahrens }
407fa9e4066Sahrens
408fa9e4066Sahrens /*
409fa9e4066Sahrens * Determine if the mountpoint is empty. If so, refuse to perform the
410fa9e4066Sahrens * mount. We don't perform this check if MS_OVERLAY is specified, which
411fa9e4066Sahrens * would defeat the point. We also avoid this check if 'remount' is
412fa9e4066Sahrens * specified.
413fa9e4066Sahrens */
414fa9e4066Sahrens if ((flags & MS_OVERLAY) == 0 &&
415fa9e4066Sahrens strstr(mntopts, MNTOPT_REMOUNT) == NULL &&
416fa9e4066Sahrens !dir_is_empty(mountpoint)) {
41799653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
41899653d4eSeschrock "directory is not empty"));
419ece3d9b3Slling return (zfs_error_fmt(hdl, EZFS_MOUNTFAILED,
42099653d4eSeschrock dgettext(TEXT_DOMAIN, "cannot mount '%s'"), mountpoint));
421fa9e4066Sahrens }
422fa9e4066Sahrens
423fa9e4066Sahrens /* perform the mount */
424fa9e4066Sahrens if (mount(zfs_get_name(zhp), mountpoint, MS_OPTIONSTR | flags,
425fa9e4066Sahrens MNTTYPE_ZFS, NULL, 0, mntopts, sizeof (mntopts)) != 0) {
426fa9e4066Sahrens /*
427fa9e4066Sahrens * Generic errors are nasty, but there are just way too many
428fa9e4066Sahrens * from mount(), and they're well-understood. We pick a few
429fa9e4066Sahrens * common ones to improve upon.
430fa9e4066Sahrens */
431d8689a57Sdougm if (errno == EBUSY) {
43299653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
43399653d4eSeschrock "mountpoint or dataset is busy"));
434ecd6cf80Smarks } else if (errno == EPERM) {
435ecd6cf80Smarks zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
436ecd6cf80Smarks "Insufficient privileges"));
43754a91118SChris Kirby } else if (errno == ENOTSUP) {
43854a91118SChris Kirby char buf[256];
439dc7cd546SMark Shellenbaum int spa_version;
44054a91118SChris Kirby
441dc7cd546SMark Shellenbaum VERIFY(zfs_spa_version(zhp, &spa_version) == 0);
44254a91118SChris Kirby (void) snprintf(buf, sizeof (buf),
443dc7cd546SMark Shellenbaum dgettext(TEXT_DOMAIN, "Can't mount a version %lld "
444dc7cd546SMark Shellenbaum "file system on a version %d pool. Pool must be"
445dc7cd546SMark Shellenbaum " upgraded to mount this file system."),
44654a91118SChris Kirby (u_longlong_t)zfs_prop_get_int(zhp,
447dc7cd546SMark Shellenbaum ZFS_PROP_VERSION), spa_version);
44854a91118SChris Kirby zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, buf));
449d8689a57Sdougm } else {
45099653d4eSeschrock zfs_error_aux(hdl, strerror(errno));
451d8689a57Sdougm }
452ece3d9b3Slling return (zfs_error_fmt(hdl, EZFS_MOUNTFAILED,
45399653d4eSeschrock dgettext(TEXT_DOMAIN, "cannot mount '%s'"),
45499653d4eSeschrock zhp->zfs_name));
455fa9e4066Sahrens }
456fa9e4066Sahrens
457ebedde84SEric Taylor /* add the mounted entry into our cache */
458ebedde84SEric Taylor libzfs_mnttab_add(hdl, zfs_get_name(zhp), mountpoint,
459ebedde84SEric Taylor mntopts);
460fa9e4066Sahrens return (0);
461fa9e4066Sahrens }
462fa9e4066Sahrens
4633bb79becSeschrock /*
4643bb79becSeschrock * Unmount a single filesystem.
4653bb79becSeschrock */
4663bb79becSeschrock static int
unmount_one(libzfs_handle_t * hdl,const char * mountpoint,int flags)4673bb79becSeschrock unmount_one(libzfs_handle_t *hdl, const char *mountpoint, int flags)
4683bb79becSeschrock {
4693bb79becSeschrock if (umount2(mountpoint, flags) != 0) {
4703bb79becSeschrock zfs_error_aux(hdl, strerror(errno));
471ece3d9b3Slling return (zfs_error_fmt(hdl, EZFS_UMOUNTFAILED,
4723bb79becSeschrock dgettext(TEXT_DOMAIN, "cannot unmount '%s'"),
4733bb79becSeschrock mountpoint));
4743bb79becSeschrock }
4753bb79becSeschrock
4763bb79becSeschrock return (0);
4773bb79becSeschrock }
4783bb79becSeschrock
479fa9e4066Sahrens /*
480fa9e4066Sahrens * Unmount the given filesystem.
481fa9e4066Sahrens */
482fa9e4066Sahrens int
zfs_unmount(zfs_handle_t * zhp,const char * mountpoint,int flags)483fa9e4066Sahrens zfs_unmount(zfs_handle_t *zhp, const char *mountpoint, int flags)
484fa9e4066Sahrens {
485ebedde84SEric Taylor libzfs_handle_t *hdl = zhp->zfs_hdl;
486ebedde84SEric Taylor struct mnttab entry;
48767331909Sdougm char *mntpt = NULL;
488fa9e4066Sahrens
489ebedde84SEric Taylor /* check to see if we need to unmount the filesystem */
490fa9e4066Sahrens if (mountpoint != NULL || ((zfs_get_type(zhp) == ZFS_TYPE_FILESYSTEM) &&
491ebedde84SEric Taylor libzfs_mnttab_find(hdl, zhp->zfs_name, &entry) == 0)) {
49267331909Sdougm /*
49367331909Sdougm * mountpoint may have come from a call to
49467331909Sdougm * getmnt/getmntany if it isn't NULL. If it is NULL,
495ebedde84SEric Taylor * we know it comes from libzfs_mnttab_find which can
496ebedde84SEric Taylor * then get freed later. We strdup it to play it safe.
49767331909Sdougm */
498fa9e4066Sahrens if (mountpoint == NULL)
499ebedde84SEric Taylor mntpt = zfs_strdup(hdl, entry.mnt_mountp);
50067331909Sdougm else
501ebedde84SEric Taylor mntpt = zfs_strdup(hdl, mountpoint);
502fa9e4066Sahrens
503fa9e4066Sahrens /*
5043bb79becSeschrock * Unshare and unmount the filesystem
505fa9e4066Sahrens */
506da6c28aaSamw if (zfs_unshare_proto(zhp, mntpt, share_all_proto) != 0)
507eb66cf86Sth return (-1);
508eb66cf86Sth
509ebedde84SEric Taylor if (unmount_one(hdl, mntpt, flags) != 0) {
51067331909Sdougm free(mntpt);
511da6c28aaSamw (void) zfs_shareall(zhp);
512fa9e4066Sahrens return (-1);
51367331909Sdougm }
514ebedde84SEric Taylor libzfs_mnttab_remove(hdl, zhp->zfs_name);
51567331909Sdougm free(mntpt);
516fa9e4066Sahrens }
517fa9e4066Sahrens
518fa9e4066Sahrens return (0);
519fa9e4066Sahrens }
520fa9e4066Sahrens
521fa9e4066Sahrens /*
522fa9e4066Sahrens * Unmount this filesystem and any children inheriting the mountpoint property.
523fa9e4066Sahrens * To do this, just act like we're changing the mountpoint property, but don't
524fa9e4066Sahrens * remount the filesystems afterwards.
525fa9e4066Sahrens */
526fa9e4066Sahrens int
zfs_unmountall(zfs_handle_t * zhp,int flags)527fa9e4066Sahrens zfs_unmountall(zfs_handle_t *zhp, int flags)
528fa9e4066Sahrens {
529fa9e4066Sahrens prop_changelist_t *clp;
530fa9e4066Sahrens int ret;
531fa9e4066Sahrens
5320069fd67STim Haley clp = changelist_gather(zhp, ZFS_PROP_MOUNTPOINT, 0, flags);
533fa9e4066Sahrens if (clp == NULL)
534fa9e4066Sahrens return (-1);
535fa9e4066Sahrens
536fa9e4066Sahrens ret = changelist_prefix(clp);
537fa9e4066Sahrens changelist_free(clp);
538fa9e4066Sahrens
539fa9e4066Sahrens return (ret);
540fa9e4066Sahrens }
541fa9e4066Sahrens
542f3861e1aSahl boolean_t
zfs_is_shared(zfs_handle_t * zhp)543f3861e1aSahl zfs_is_shared(zfs_handle_t *zhp)
544f3861e1aSahl {
545da6c28aaSamw zfs_share_type_t rc = 0;
546da6c28aaSamw zfs_share_proto_t *curr_proto;
547da6c28aaSamw
548f3861e1aSahl if (ZFS_IS_VOLUME(zhp))
549ab003da8SJim Dunham return (B_FALSE);
550f3861e1aSahl
551da6c28aaSamw for (curr_proto = share_all_proto; *curr_proto != PROTO_END;
552da6c28aaSamw curr_proto++)
553da6c28aaSamw rc |= zfs_is_shared_proto(zhp, NULL, *curr_proto);
554da6c28aaSamw
555da6c28aaSamw return (rc ? B_TRUE : B_FALSE);
556f3861e1aSahl }
557f3861e1aSahl
558f3861e1aSahl int
zfs_share(zfs_handle_t * zhp)559f3861e1aSahl zfs_share(zfs_handle_t *zhp)
560f3861e1aSahl {
5619d9a58e3SEric Taylor assert(!ZFS_IS_VOLUME(zhp));
562da6c28aaSamw return (zfs_share_proto(zhp, share_all_proto));
563f3861e1aSahl }
564f3861e1aSahl
565f3861e1aSahl int
zfs_unshare(zfs_handle_t * zhp)566f3861e1aSahl zfs_unshare(zfs_handle_t *zhp)
567f3861e1aSahl {
5689d9a58e3SEric Taylor assert(!ZFS_IS_VOLUME(zhp));
569da6c28aaSamw return (zfs_unshareall(zhp));
570f3861e1aSahl }
571f3861e1aSahl
572fa9e4066Sahrens /*
573fa9e4066Sahrens * Check to see if the filesystem is currently shared.
574fa9e4066Sahrens */
575da6c28aaSamw zfs_share_type_t
zfs_is_shared_proto(zfs_handle_t * zhp,char ** where,zfs_share_proto_t proto)576da6c28aaSamw zfs_is_shared_proto(zfs_handle_t *zhp, char **where, zfs_share_proto_t proto)
577fa9e4066Sahrens {
578fa9e4066Sahrens char *mountpoint;
579da6c28aaSamw zfs_share_type_t rc;
580fa9e4066Sahrens
581fa9e4066Sahrens if (!zfs_is_mounted(zhp, &mountpoint))
582da6c28aaSamw return (SHARED_NOT_SHARED);
583fa9e4066Sahrens
58488f61deeSIgor Kozhukhov if ((rc = is_shared(zhp->zfs_hdl, mountpoint, proto))
58588f61deeSIgor Kozhukhov != SHARED_NOT_SHARED) {
586fa9e4066Sahrens if (where != NULL)
587fa9e4066Sahrens *where = mountpoint;
588fa9e4066Sahrens else
589fa9e4066Sahrens free(mountpoint);
590da6c28aaSamw return (rc);
591fa9e4066Sahrens } else {
592fa9e4066Sahrens free(mountpoint);
593da6c28aaSamw return (SHARED_NOT_SHARED);
594fa9e4066Sahrens }
595fa9e4066Sahrens }
596fa9e4066Sahrens
597da6c28aaSamw boolean_t
zfs_is_shared_nfs(zfs_handle_t * zhp,char ** where)598da6c28aaSamw zfs_is_shared_nfs(zfs_handle_t *zhp, char **where)
599da6c28aaSamw {
600da6c28aaSamw return (zfs_is_shared_proto(zhp, where,
601da6c28aaSamw PROTO_NFS) != SHARED_NOT_SHARED);
602da6c28aaSamw }
603da6c28aaSamw
604da6c28aaSamw boolean_t
zfs_is_shared_smb(zfs_handle_t * zhp,char ** where)605da6c28aaSamw zfs_is_shared_smb(zfs_handle_t *zhp, char **where)
606da6c28aaSamw {
607da6c28aaSamw return (zfs_is_shared_proto(zhp, where,
608da6c28aaSamw PROTO_SMB) != SHARED_NOT_SHARED);
609da6c28aaSamw }
610da6c28aaSamw
61167331909Sdougm /*
61267331909Sdougm * Make sure things will work if libshare isn't installed by using
61367331909Sdougm * wrapper functions that check to see that the pointers to functions
61467331909Sdougm * initialized in _zfs_init_libshare() are actually present.
61567331909Sdougm */
61667331909Sdougm
61767331909Sdougm static sa_handle_t (*_sa_init)(int);
6188a981c33SDaniel Hoffman static sa_handle_t (*_sa_init_arg)(int, void *);
619b8dc1b43SJoyce McIntosh static int (*_sa_service)(sa_handle_t);
62067331909Sdougm static void (*_sa_fini)(sa_handle_t);
62167331909Sdougm static sa_share_t (*_sa_find_share)(sa_handle_t, char *);
62267331909Sdougm static int (*_sa_enable_share)(sa_share_t, char *);
62367331909Sdougm static int (*_sa_disable_share)(sa_share_t, char *);
62467331909Sdougm static char *(*_sa_errorstr)(int);
62567331909Sdougm static int (*_sa_parse_legacy_options)(sa_group_t, char *, char *);
6265b6e0c46Sdougm static boolean_t (*_sa_needs_refresh)(sa_handle_t *);
6275b6e0c46Sdougm static libzfs_handle_t *(*_sa_get_zfs_handle)(sa_handle_t);
6280dfe541eSEvan Layton static int (* _sa_get_zfs_share)(sa_handle_t, char *, zfs_handle_t *);
6295b6e0c46Sdougm static void (*_sa_update_sharetab_ts)(sa_handle_t);
63067331909Sdougm
63167331909Sdougm /*
63267331909Sdougm * _zfs_init_libshare()
63367331909Sdougm *
63467331909Sdougm * Find the libshare.so.1 entry points that we use here and save the
63567331909Sdougm * values to be used later. This is triggered by the runtime loader.
63667331909Sdougm * Make sure the correct ISA version is loaded.
63767331909Sdougm */
6385b6e0c46Sdougm
63967331909Sdougm #pragma init(_zfs_init_libshare)
64067331909Sdougm static void
_zfs_init_libshare(void)64167331909Sdougm _zfs_init_libshare(void)
64267331909Sdougm {
64367331909Sdougm void *libshare;
64467331909Sdougm char path[MAXPATHLEN];
64567331909Sdougm char isa[MAXISALEN];
64667331909Sdougm
64767331909Sdougm #if defined(_LP64)
64867331909Sdougm if (sysinfo(SI_ARCHITECTURE_64, isa, MAXISALEN) == -1)
649d8689a57Sdougm isa[0] = '\0';
65067331909Sdougm #else
65167331909Sdougm isa[0] = '\0';
65267331909Sdougm #endif
65367331909Sdougm (void) snprintf(path, MAXPATHLEN,
654d8689a57Sdougm "/usr/lib/%s/libshare.so.1", isa);
65567331909Sdougm
65667331909Sdougm if ((libshare = dlopen(path, RTLD_LAZY | RTLD_GLOBAL)) != NULL) {
657d8689a57Sdougm _sa_init = (sa_handle_t (*)(int))dlsym(libshare, "sa_init");
6588a981c33SDaniel Hoffman _sa_init_arg = (sa_handle_t (*)(int, void *))dlsym(libshare,
6598a981c33SDaniel Hoffman "sa_init_arg");
660d8689a57Sdougm _sa_fini = (void (*)(sa_handle_t))dlsym(libshare, "sa_fini");
661b8dc1b43SJoyce McIntosh _sa_service = (int (*)(sa_handle_t))dlsym(libshare,
662b8dc1b43SJoyce McIntosh "sa_service");
663d8689a57Sdougm _sa_find_share = (sa_share_t (*)(sa_handle_t, char *))
664d8689a57Sdougm dlsym(libshare, "sa_find_share");
665d8689a57Sdougm _sa_enable_share = (int (*)(sa_share_t, char *))dlsym(libshare,
666d8689a57Sdougm "sa_enable_share");
667d8689a57Sdougm _sa_disable_share = (int (*)(sa_share_t, char *))dlsym(libshare,
668d8689a57Sdougm "sa_disable_share");
669d8689a57Sdougm _sa_errorstr = (char *(*)(int))dlsym(libshare, "sa_errorstr");
670d8689a57Sdougm _sa_parse_legacy_options = (int (*)(sa_group_t, char *, char *))
671d8689a57Sdougm dlsym(libshare, "sa_parse_legacy_options");
6725b6e0c46Sdougm _sa_needs_refresh = (boolean_t (*)(sa_handle_t *))
6735b6e0c46Sdougm dlsym(libshare, "sa_needs_refresh");
6745b6e0c46Sdougm _sa_get_zfs_handle = (libzfs_handle_t *(*)(sa_handle_t))
6755b6e0c46Sdougm dlsym(libshare, "sa_get_zfs_handle");
6760dfe541eSEvan Layton _sa_get_zfs_share = (int (*)(sa_handle_t, char *,
6770dfe541eSEvan Layton zfs_handle_t *)) dlsym(libshare, "sa_get_zfs_share");
6785b6e0c46Sdougm _sa_update_sharetab_ts = (void (*)(sa_handle_t))
6795b6e0c46Sdougm dlsym(libshare, "sa_update_sharetab_ts");
6808a981c33SDaniel Hoffman if (_sa_init == NULL || _sa_init_arg == NULL ||
6818a981c33SDaniel Hoffman _sa_fini == NULL || _sa_find_share == NULL ||
6828a981c33SDaniel Hoffman _sa_enable_share == NULL || _sa_disable_share == NULL ||
6838a981c33SDaniel Hoffman _sa_errorstr == NULL || _sa_parse_legacy_options == NULL ||
6845b6e0c46Sdougm _sa_needs_refresh == NULL || _sa_get_zfs_handle == NULL ||
6850dfe541eSEvan Layton _sa_get_zfs_share == NULL || _sa_service == NULL ||
6865b6e0c46Sdougm _sa_update_sharetab_ts == NULL) {
68757b448deSdougm _sa_init = NULL;
6888a981c33SDaniel Hoffman _sa_init_arg = NULL;
689b8dc1b43SJoyce McIntosh _sa_service = NULL;
69057b448deSdougm _sa_fini = NULL;
69157b448deSdougm _sa_disable_share = NULL;
69257b448deSdougm _sa_enable_share = NULL;
69357b448deSdougm _sa_errorstr = NULL;
69457b448deSdougm _sa_parse_legacy_options = NULL;
69557b448deSdougm (void) dlclose(libshare);
6965b6e0c46Sdougm _sa_needs_refresh = NULL;
6975b6e0c46Sdougm _sa_get_zfs_handle = NULL;
6980dfe541eSEvan Layton _sa_get_zfs_share = NULL;
6995b6e0c46Sdougm _sa_update_sharetab_ts = NULL;
70057b448deSdougm }
70167331909Sdougm }
70267331909Sdougm }
70367331909Sdougm
70467331909Sdougm /*
70567331909Sdougm * zfs_init_libshare(zhandle, service)
70667331909Sdougm *
70767331909Sdougm * Initialize the libshare API if it hasn't already been initialized.
70867331909Sdougm * In all cases it returns 0 if it succeeded and an error if not. The
70967331909Sdougm * service value is which part(s) of the API to initialize and is a
71067331909Sdougm * direct map to the libshare sa_init(service) interface.
71167331909Sdougm */
7128a981c33SDaniel Hoffman static int
zfs_init_libshare_impl(libzfs_handle_t * zhandle,int service,void * arg)7138a981c33SDaniel Hoffman zfs_init_libshare_impl(libzfs_handle_t *zhandle, int service, void *arg)
71467331909Sdougm {
7151c18e8fbSJerry Jelinek /*
7161c18e8fbSJerry Jelinek * libshare is either not installed or we're in a branded zone. The
7171c18e8fbSJerry Jelinek * rest of the wrapper functions around the libshare calls already
7181c18e8fbSJerry Jelinek * handle NULL function pointers, but we don't want the callers of
7191c18e8fbSJerry Jelinek * zfs_init_libshare() to fail prematurely if libshare is not available.
7201c18e8fbSJerry Jelinek */
721d8689a57Sdougm if (_sa_init == NULL)
7221c18e8fbSJerry Jelinek return (SA_OK);
723d8689a57Sdougm
72409c9e6dcSChris Williamson /*
72509c9e6dcSChris Williamson * Attempt to refresh libshare. This is necessary if there was a cache
72609c9e6dcSChris Williamson * miss for a new ZFS dataset that was just created, or if state of the
72709c9e6dcSChris Williamson * sharetab file has changed since libshare was last initialized. We
72809c9e6dcSChris Williamson * want to make sure so check timestamps to see if a different process
72909c9e6dcSChris Williamson * has updated any of the configuration. If there was some non-ZFS
73009c9e6dcSChris Williamson * change, we need to re-initialize the internal cache.
73109c9e6dcSChris Williamson */
73209c9e6dcSChris Williamson if (_sa_needs_refresh != NULL &&
73309c9e6dcSChris Williamson _sa_needs_refresh(zhandle->libzfs_sharehdl)) {
73409c9e6dcSChris Williamson zfs_uninit_libshare(zhandle);
7358a981c33SDaniel Hoffman zhandle->libzfs_sharehdl = _sa_init_arg(service, arg);
7365b6e0c46Sdougm }
7375b6e0c46Sdougm
73809c9e6dcSChris Williamson if (zhandle && zhandle->libzfs_sharehdl == NULL)
7398a981c33SDaniel Hoffman zhandle->libzfs_sharehdl = _sa_init_arg(service, arg);
740d8689a57Sdougm
74109c9e6dcSChris Williamson if (zhandle->libzfs_sharehdl == NULL)
74209c9e6dcSChris Williamson return (SA_NO_MEMORY);
743d8689a57Sdougm
74409c9e6dcSChris Williamson return (SA_OK);
74567331909Sdougm }
7468a981c33SDaniel Hoffman int
zfs_init_libshare(libzfs_handle_t * zhandle,int service)7478a981c33SDaniel Hoffman zfs_init_libshare(libzfs_handle_t *zhandle, int service)
7488a981c33SDaniel Hoffman {
7498a981c33SDaniel Hoffman return (zfs_init_libshare_impl(zhandle, service, NULL));
7508a981c33SDaniel Hoffman }
7518a981c33SDaniel Hoffman
7528a981c33SDaniel Hoffman int
zfs_init_libshare_arg(libzfs_handle_t * zhandle,int service,void * arg)7538a981c33SDaniel Hoffman zfs_init_libshare_arg(libzfs_handle_t *zhandle, int service, void *arg)
7548a981c33SDaniel Hoffman {
7558a981c33SDaniel Hoffman return (zfs_init_libshare_impl(zhandle, service, arg));
7568a981c33SDaniel Hoffman }
7578a981c33SDaniel Hoffman
75867331909Sdougm
75967331909Sdougm /*
76067331909Sdougm * zfs_uninit_libshare(zhandle)
76167331909Sdougm *
76267331909Sdougm * Uninitialize the libshare API if it hasn't already been
76367331909Sdougm * uninitialized. It is OK to call multiple times.
76467331909Sdougm */
76567331909Sdougm void
zfs_uninit_libshare(libzfs_handle_t * zhandle)76667331909Sdougm zfs_uninit_libshare(libzfs_handle_t *zhandle)
76767331909Sdougm {
76867331909Sdougm if (zhandle != NULL && zhandle->libzfs_sharehdl != NULL) {
769d8689a57Sdougm if (_sa_fini != NULL)
770d8689a57Sdougm _sa_fini(zhandle->libzfs_sharehdl);
771d8689a57Sdougm zhandle->libzfs_sharehdl = NULL;
77267331909Sdougm }
77367331909Sdougm }
77467331909Sdougm
77567331909Sdougm /*
77667331909Sdougm * zfs_parse_options(options, proto)
77767331909Sdougm *
77867331909Sdougm * Call the legacy parse interface to get the protocol specific
77967331909Sdougm * options using the NULL arg to indicate that this is a "parse" only.
78067331909Sdougm */
78167331909Sdougm int
zfs_parse_options(char * options,zfs_share_proto_t proto)782da6c28aaSamw zfs_parse_options(char *options, zfs_share_proto_t proto)
78367331909Sdougm {
7843cb34c60Sahrens if (_sa_parse_legacy_options != NULL) {
7853cb34c60Sahrens return (_sa_parse_legacy_options(NULL, options,
7863cb34c60Sahrens proto_table[proto].p_name));
7873cb34c60Sahrens }
7883cb34c60Sahrens return (SA_CONFIG_ERR);
78967331909Sdougm }
79067331909Sdougm
79167331909Sdougm /*
79267331909Sdougm * zfs_sa_find_share(handle, path)
79367331909Sdougm *
79467331909Sdougm * wrapper around sa_find_share to find a share path in the
79567331909Sdougm * configuration.
79667331909Sdougm */
79767331909Sdougm static sa_share_t
zfs_sa_find_share(sa_handle_t handle,char * path)79867331909Sdougm zfs_sa_find_share(sa_handle_t handle, char *path)
79967331909Sdougm {
80067331909Sdougm if (_sa_find_share != NULL)
801d8689a57Sdougm return (_sa_find_share(handle, path));
80267331909Sdougm return (NULL);
80367331909Sdougm }
80467331909Sdougm
80567331909Sdougm /*
80667331909Sdougm * zfs_sa_enable_share(share, proto)
80767331909Sdougm *
80867331909Sdougm * Wrapper for sa_enable_share which enables a share for a specified
80967331909Sdougm * protocol.
81067331909Sdougm */
81167331909Sdougm static int
zfs_sa_enable_share(sa_share_t share,char * proto)81267331909Sdougm zfs_sa_enable_share(sa_share_t share, char *proto)
81367331909Sdougm {
81467331909Sdougm if (_sa_enable_share != NULL)
815d8689a57Sdougm return (_sa_enable_share(share, proto));
81667331909Sdougm return (SA_CONFIG_ERR);
81767331909Sdougm }
81867331909Sdougm
81967331909Sdougm /*
82067331909Sdougm * zfs_sa_disable_share(share, proto)
82167331909Sdougm *
82267331909Sdougm * Wrapper for sa_enable_share which disables a share for a specified
82367331909Sdougm * protocol.
82467331909Sdougm */
82567331909Sdougm static int
zfs_sa_disable_share(sa_share_t share,char * proto)82667331909Sdougm zfs_sa_disable_share(sa_share_t share, char *proto)
82767331909Sdougm {
82867331909Sdougm if (_sa_disable_share != NULL)
829d8689a57Sdougm return (_sa_disable_share(share, proto));
83067331909Sdougm return (SA_CONFIG_ERR);
83167331909Sdougm }
83267331909Sdougm
833fa9e4066Sahrens /*
834da6c28aaSamw * Share the given filesystem according to the options in the specified
835da6c28aaSamw * protocol specific properties (sharenfs, sharesmb). We rely
83667331909Sdougm * on "libshare" to the dirty work for us.
837fa9e4066Sahrens */
838da6c28aaSamw static int
zfs_share_proto(zfs_handle_t * zhp,zfs_share_proto_t * proto)839da6c28aaSamw zfs_share_proto(zfs_handle_t *zhp, zfs_share_proto_t *proto)
840fa9e4066Sahrens {
841fa9e4066Sahrens char mountpoint[ZFS_MAXPROPLEN];
842fa9e4066Sahrens char shareopts[ZFS_MAXPROPLEN];
8435b6e0c46Sdougm char sourcestr[ZFS_MAXPROPLEN];
84499653d4eSeschrock libzfs_handle_t *hdl = zhp->zfs_hdl;
84567331909Sdougm sa_share_t share;
846da6c28aaSamw zfs_share_proto_t *curr_proto;
8475b6e0c46Sdougm zprop_source_t sourcetype;
848b8dc1b43SJoyce McIntosh int service = SA_INIT_ONE_SHARE_FROM_HANDLE;
84967331909Sdougm int ret;
850fa9e4066Sahrens
851e9dbad6fSeschrock if (!zfs_is_mountable(zhp, mountpoint, sizeof (mountpoint), NULL))
852fa9e4066Sahrens return (0);
853fa9e4066Sahrens
854b8dc1b43SJoyce McIntosh /*
855b8dc1b43SJoyce McIntosh * Function may be called in a loop from higher up stack, with libshare
856b8dc1b43SJoyce McIntosh * initialized for multiple shares (SA_INIT_SHARE_API_SELECTIVE).
857b8dc1b43SJoyce McIntosh * zfs_init_libshare_arg will refresh the handle's cache if necessary.
858b8dc1b43SJoyce McIntosh * In this case we do not want to switch to per share initialization.
859b8dc1b43SJoyce McIntosh * Specify SA_INIT_SHARE_API to do full refresh, if refresh required.
860b8dc1b43SJoyce McIntosh */
861b8dc1b43SJoyce McIntosh if ((hdl->libzfs_sharehdl != NULL) && (_sa_service != NULL) &&
862b8dc1b43SJoyce McIntosh (_sa_service(hdl->libzfs_sharehdl) ==
863b8dc1b43SJoyce McIntosh SA_INIT_SHARE_API_SELECTIVE)) {
864b8dc1b43SJoyce McIntosh service = SA_INIT_SHARE_API;
865b8dc1b43SJoyce McIntosh }
866b8dc1b43SJoyce McIntosh
867da6c28aaSamw for (curr_proto = proto; *curr_proto != PROTO_END; curr_proto++) {
868da6c28aaSamw /*
869da6c28aaSamw * Return success if there are no share options.
870da6c28aaSamw */
871da6c28aaSamw if (zfs_prop_get(zhp, proto_table[*curr_proto].p_prop,
8725b6e0c46Sdougm shareopts, sizeof (shareopts), &sourcetype, sourcestr,
8735b6e0c46Sdougm ZFS_MAXPROPLEN, B_FALSE) != 0 ||
8745b6e0c46Sdougm strcmp(shareopts, "off") == 0)
875da6c28aaSamw continue;
876b8dc1b43SJoyce McIntosh ret = zfs_init_libshare_arg(hdl, service, zhp);
87733cde0d0SMatthew Ahrens if (ret != SA_OK) {
87833cde0d0SMatthew Ahrens (void) zfs_error_fmt(hdl, EZFS_SHARENFSFAILED,
87933cde0d0SMatthew Ahrens dgettext(TEXT_DOMAIN, "cannot share '%s': %s"),
88033cde0d0SMatthew Ahrens zfs_get_name(zhp), _sa_errorstr != NULL ?
88133cde0d0SMatthew Ahrens _sa_errorstr(ret) : "");
88233cde0d0SMatthew Ahrens return (-1);
88333cde0d0SMatthew Ahrens }
88433cde0d0SMatthew Ahrens
885da6c28aaSamw share = zfs_sa_find_share(hdl->libzfs_sharehdl, mountpoint);
8865b6e0c46Sdougm if (share == NULL) {
8875b6e0c46Sdougm /*
8885b6e0c46Sdougm * This may be a new file system that was just
8890dfe541eSEvan Layton * created so isn't in the internal cache.
8900dfe541eSEvan Layton * Rather than reloading the entire configuration,
8910dfe541eSEvan Layton * we can add just this one share to the cache.
8925b6e0c46Sdougm */
8930dfe541eSEvan Layton if ((_sa_get_zfs_share == NULL) ||
8940dfe541eSEvan Layton (_sa_get_zfs_share(hdl->libzfs_sharehdl, "zfs", zhp)
8950dfe541eSEvan Layton != SA_OK)) {
8965b6e0c46Sdougm (void) zfs_error_fmt(hdl,
8975b6e0c46Sdougm proto_table[*curr_proto].p_share_err,
8985b6e0c46Sdougm dgettext(TEXT_DOMAIN, "cannot share '%s'"),
8995b6e0c46Sdougm zfs_get_name(zhp));
9005b6e0c46Sdougm return (-1);
9015b6e0c46Sdougm }
9025b6e0c46Sdougm share = zfs_sa_find_share(hdl->libzfs_sharehdl,
9035b6e0c46Sdougm mountpoint);
9045b6e0c46Sdougm }
905da6c28aaSamw if (share != NULL) {
906da6c28aaSamw int err;
907da6c28aaSamw err = zfs_sa_enable_share(share,
908da6c28aaSamw proto_table[*curr_proto].p_name);
909da6c28aaSamw if (err != SA_OK) {
910da6c28aaSamw (void) zfs_error_fmt(hdl,
911da6c28aaSamw proto_table[*curr_proto].p_share_err,
912da6c28aaSamw dgettext(TEXT_DOMAIN, "cannot share '%s'"),
913da6c28aaSamw zfs_get_name(zhp));
914da6c28aaSamw return (-1);
915da6c28aaSamw }
916da6c28aaSamw } else {
917da6c28aaSamw (void) zfs_error_fmt(hdl,
918da6c28aaSamw proto_table[*curr_proto].p_share_err,
919d8689a57Sdougm dgettext(TEXT_DOMAIN, "cannot share '%s'"),
920d8689a57Sdougm zfs_get_name(zhp));
921d8689a57Sdougm return (-1);
922d8689a57Sdougm }
923fa9e4066Sahrens
924da6c28aaSamw }
925fa9e4066Sahrens return (0);
926fa9e4066Sahrens }
927fa9e4066Sahrens
928da6c28aaSamw
929da6c28aaSamw int
zfs_share_nfs(zfs_handle_t * zhp)930da6c28aaSamw zfs_share_nfs(zfs_handle_t *zhp)
931da6c28aaSamw {
932da6c28aaSamw return (zfs_share_proto(zhp, nfs_only));
933da6c28aaSamw }
934da6c28aaSamw
935da6c28aaSamw int
zfs_share_smb(zfs_handle_t * zhp)936da6c28aaSamw zfs_share_smb(zfs_handle_t *zhp)
937da6c28aaSamw {
938da6c28aaSamw return (zfs_share_proto(zhp, smb_only));
939da6c28aaSamw }
940da6c28aaSamw
941da6c28aaSamw int
zfs_shareall(zfs_handle_t * zhp)942da6c28aaSamw zfs_shareall(zfs_handle_t *zhp)
943da6c28aaSamw {
944da6c28aaSamw return (zfs_share_proto(zhp, share_all_proto));
945da6c28aaSamw }
946da6c28aaSamw
9473bb79becSeschrock /*
9483bb79becSeschrock * Unshare a filesystem by mountpoint.
9493bb79becSeschrock */
9503bb79becSeschrock static int
unshare_one(libzfs_handle_t * hdl,const char * name,const char * mountpoint,zfs_share_proto_t proto)951da6c28aaSamw unshare_one(libzfs_handle_t *hdl, const char *name, const char *mountpoint,
952da6c28aaSamw zfs_share_proto_t proto)
9533bb79becSeschrock {
95467331909Sdougm sa_share_t share;
95567331909Sdougm int err;
95667331909Sdougm char *mntpt;
957b8dc1b43SJoyce McIntosh int service = SA_INIT_ONE_SHARE_FROM_NAME;
9588a981c33SDaniel Hoffman
9593bb79becSeschrock /*
96067331909Sdougm * Mountpoint could get trashed if libshare calls getmntany
961ebedde84SEric Taylor * which it does during API initialization, so strdup the
96267331909Sdougm * value.
9633bb79becSeschrock */
96467331909Sdougm mntpt = zfs_strdup(hdl, mountpoint);
9653bb79becSeschrock
9668a981c33SDaniel Hoffman /*
967b8dc1b43SJoyce McIntosh * Function may be called in a loop from higher up stack, with libshare
968b8dc1b43SJoyce McIntosh * initialized for multiple shares (SA_INIT_SHARE_API_SELECTIVE).
969b8dc1b43SJoyce McIntosh * zfs_init_libshare_arg will refresh the handle's cache if necessary.
970b8dc1b43SJoyce McIntosh * In this case we do not want to switch to per share initialization.
971b8dc1b43SJoyce McIntosh * Specify SA_INIT_SHARE_API to do full refresh, if refresh required.
9728a981c33SDaniel Hoffman */
973b8dc1b43SJoyce McIntosh if ((hdl->libzfs_sharehdl != NULL) && (_sa_service != NULL) &&
974b8dc1b43SJoyce McIntosh (_sa_service(hdl->libzfs_sharehdl) ==
975b8dc1b43SJoyce McIntosh SA_INIT_SHARE_API_SELECTIVE)) {
976b8dc1b43SJoyce McIntosh service = SA_INIT_SHARE_API;
977b8dc1b43SJoyce McIntosh }
978b8dc1b43SJoyce McIntosh
979b8dc1b43SJoyce McIntosh err = zfs_init_libshare_arg(hdl, service, (void *)name);
980b8dc1b43SJoyce McIntosh if (err != SA_OK) {
98167331909Sdougm free(mntpt); /* don't need the copy anymore */
9824f4378ccSAndrew Stormont return (zfs_error_fmt(hdl, proto_table[proto].p_unshare_err,
983d8689a57Sdougm dgettext(TEXT_DOMAIN, "cannot unshare '%s': %s"),
984d8689a57Sdougm name, _sa_errorstr(err)));
98567331909Sdougm }
9863bb79becSeschrock
98767331909Sdougm share = zfs_sa_find_share(hdl->libzfs_sharehdl, mntpt);
98867331909Sdougm free(mntpt); /* don't need the copy anymore */
9893bb79becSeschrock
99067331909Sdougm if (share != NULL) {
991da6c28aaSamw err = zfs_sa_disable_share(share, proto_table[proto].p_name);
99267331909Sdougm if (err != SA_OK) {
9934f4378ccSAndrew Stormont return (zfs_error_fmt(hdl,
9944f4378ccSAndrew Stormont proto_table[proto].p_unshare_err,
995d8689a57Sdougm dgettext(TEXT_DOMAIN, "cannot unshare '%s': %s"),
996d8689a57Sdougm name, _sa_errorstr(err)));
99767331909Sdougm }
99867331909Sdougm } else {
9994f4378ccSAndrew Stormont return (zfs_error_fmt(hdl, proto_table[proto].p_unshare_err,
1000d8689a57Sdougm dgettext(TEXT_DOMAIN, "cannot unshare '%s': not found"),
1001d8689a57Sdougm name));
10023bb79becSeschrock }
10033bb79becSeschrock return (0);
10043bb79becSeschrock }
10053bb79becSeschrock
1006fa9e4066Sahrens /*
1007fa9e4066Sahrens * Unshare the given filesystem.
1008fa9e4066Sahrens */
1009fa9e4066Sahrens int
zfs_unshare_proto(zfs_handle_t * zhp,const char * mountpoint,zfs_share_proto_t * proto)1010da6c28aaSamw zfs_unshare_proto(zfs_handle_t *zhp, const char *mountpoint,
1011da6c28aaSamw zfs_share_proto_t *proto)
1012fa9e4066Sahrens {
1013ebedde84SEric Taylor libzfs_handle_t *hdl = zhp->zfs_hdl;
1014ebedde84SEric Taylor struct mnttab entry;
101567331909Sdougm char *mntpt = NULL;
1016fa9e4066Sahrens
1017fa9e4066Sahrens /* check to see if need to unmount the filesystem */
101899653d4eSeschrock rewind(zhp->zfs_hdl->libzfs_mnttab);
1019d8689a57Sdougm if (mountpoint != NULL)
1020ebedde84SEric Taylor mountpoint = mntpt = zfs_strdup(hdl, mountpoint);
1021d8689a57Sdougm
1022fa9e4066Sahrens if (mountpoint != NULL || ((zfs_get_type(zhp) == ZFS_TYPE_FILESYSTEM) &&
1023ebedde84SEric Taylor libzfs_mnttab_find(hdl, zfs_get_name(zhp), &entry) == 0)) {
1024da6c28aaSamw zfs_share_proto_t *curr_proto;
1025fa9e4066Sahrens
1026fa9e4066Sahrens if (mountpoint == NULL)
1027da6c28aaSamw mntpt = zfs_strdup(zhp->zfs_hdl, entry.mnt_mountp);
1028fa9e4066Sahrens
1029da6c28aaSamw for (curr_proto = proto; *curr_proto != PROTO_END;
1030da6c28aaSamw curr_proto++) {
1031da6c28aaSamw
1032ebedde84SEric Taylor if (is_shared(hdl, mntpt, *curr_proto) &&
1033ebedde84SEric Taylor unshare_one(hdl, zhp->zfs_name,
1034da6c28aaSamw mntpt, *curr_proto) != 0) {
1035da6c28aaSamw if (mntpt != NULL)
1036da6c28aaSamw free(mntpt);
1037da6c28aaSamw return (-1);
1038da6c28aaSamw }
103967331909Sdougm }
1040fa9e4066Sahrens }
104167331909Sdougm if (mntpt != NULL)
1042d8689a57Sdougm free(mntpt);
1043fa9e4066Sahrens
1044fa9e4066Sahrens return (0);
1045fa9e4066Sahrens }
1046fa9e4066Sahrens
1047da6c28aaSamw int
zfs_unshare_nfs(zfs_handle_t * zhp,const char * mountpoint)1048da6c28aaSamw zfs_unshare_nfs(zfs_handle_t *zhp, const char *mountpoint)
1049da6c28aaSamw {
1050da6c28aaSamw return (zfs_unshare_proto(zhp, mountpoint, nfs_only));
1051da6c28aaSamw }
1052da6c28aaSamw
1053da6c28aaSamw int
zfs_unshare_smb(zfs_handle_t * zhp,const char * mountpoint)1054da6c28aaSamw zfs_unshare_smb(zfs_handle_t *zhp, const char *mountpoint)
1055da6c28aaSamw {
1056da6c28aaSamw return (zfs_unshare_proto(zhp, mountpoint, smb_only));
1057da6c28aaSamw }
1058da6c28aaSamw
1059fa9e4066Sahrens /*
1060da6c28aaSamw * Same as zfs_unmountall(), but for NFS and SMB unshares.
1061fa9e4066Sahrens */
1062fa9e4066Sahrens int
zfs_unshareall_proto(zfs_handle_t * zhp,zfs_share_proto_t * proto)1063da6c28aaSamw zfs_unshareall_proto(zfs_handle_t *zhp, zfs_share_proto_t *proto)
1064fa9e4066Sahrens {
1065fa9e4066Sahrens prop_changelist_t *clp;
1066fa9e4066Sahrens int ret;
1067fa9e4066Sahrens
10680069fd67STim Haley clp = changelist_gather(zhp, ZFS_PROP_SHARENFS, 0, 0);
1069fa9e4066Sahrens if (clp == NULL)
1070fa9e4066Sahrens return (-1);
1071fa9e4066Sahrens
1072da6c28aaSamw ret = changelist_unshare(clp, proto);
1073fa9e4066Sahrens changelist_free(clp);
1074fa9e4066Sahrens
1075fa9e4066Sahrens return (ret);
1076fa9e4066Sahrens }
1077fa9e4066Sahrens
1078da6c28aaSamw int
zfs_unshareall_nfs(zfs_handle_t * zhp)1079da6c28aaSamw zfs_unshareall_nfs(zfs_handle_t *zhp)
1080da6c28aaSamw {
1081da6c28aaSamw return (zfs_unshareall_proto(zhp, nfs_only));
1082da6c28aaSamw }
1083da6c28aaSamw
1084da6c28aaSamw int
zfs_unshareall_smb(zfs_handle_t * zhp)1085da6c28aaSamw zfs_unshareall_smb(zfs_handle_t *zhp)
1086da6c28aaSamw {
1087da6c28aaSamw return (zfs_unshareall_proto(zhp, smb_only));
1088da6c28aaSamw }
1089da6c28aaSamw
1090da6c28aaSamw int
zfs_unshareall(zfs_handle_t * zhp)1091da6c28aaSamw zfs_unshareall(zfs_handle_t *zhp)
1092da6c28aaSamw {
1093da6c28aaSamw return (zfs_unshareall_proto(zhp, share_all_proto));
1094da6c28aaSamw }
1095da6c28aaSamw
1096da6c28aaSamw int
zfs_unshareall_bypath(zfs_handle_t * zhp,const char * mountpoint)1097da6c28aaSamw zfs_unshareall_bypath(zfs_handle_t *zhp, const char *mountpoint)
1098da6c28aaSamw {
1099da6c28aaSamw return (zfs_unshare_proto(zhp, mountpoint, share_all_proto));
1100da6c28aaSamw }
1101da6c28aaSamw
1102fa9e4066Sahrens /*
1103fa9e4066Sahrens * Remove the mountpoint associated with the current dataset, if necessary.
1104fa9e4066Sahrens * We only remove the underlying directory if:
1105fa9e4066Sahrens *
1106fa9e4066Sahrens * - The mountpoint is not 'none' or 'legacy'
1107fa9e4066Sahrens * - The mountpoint is non-empty
1108fa9e4066Sahrens * - The mountpoint is the default or inherited
1109fa9e4066Sahrens * - The 'zoned' property is set, or we're in a local zone
1110fa9e4066Sahrens *
1111fa9e4066Sahrens * Any other directories we leave alone.
1112fa9e4066Sahrens */
1113fa9e4066Sahrens void
remove_mountpoint(zfs_handle_t * zhp)1114fa9e4066Sahrens remove_mountpoint(zfs_handle_t *zhp)
1115fa9e4066Sahrens {
1116fa9e4066Sahrens char mountpoint[ZFS_MAXPROPLEN];
1117990b4856Slling zprop_source_t source;
1118fa9e4066Sahrens
1119e9dbad6fSeschrock if (!zfs_is_mountable(zhp, mountpoint, sizeof (mountpoint),
1120e9dbad6fSeschrock &source))
1121fa9e4066Sahrens return;
1122fa9e4066Sahrens
1123990b4856Slling if (source == ZPROP_SRC_DEFAULT ||
1124990b4856Slling source == ZPROP_SRC_INHERITED) {
1125fa9e4066Sahrens /*
1126fa9e4066Sahrens * Try to remove the directory, silently ignoring any errors.
1127fa9e4066Sahrens * The filesystem may have since been removed or moved around,
1128e9dbad6fSeschrock * and this error isn't really useful to the administrator in
1129e9dbad6fSeschrock * any way.
1130fa9e4066Sahrens */
1131fa9e4066Sahrens (void) rmdir(mountpoint);
1132fa9e4066Sahrens }
1133fa9e4066Sahrens }
11343bb79becSeschrock
1135591e0e13SSebastien Roy /*
1136591e0e13SSebastien Roy * Add the given zfs handle to the cb_handles array, dynamically reallocating
1137591e0e13SSebastien Roy * the array if it is out of space.
1138591e0e13SSebastien Roy */
11399d9a58e3SEric Taylor void
libzfs_add_handle(get_all_cb_t * cbp,zfs_handle_t * zhp)11409d9a58e3SEric Taylor libzfs_add_handle(get_all_cb_t *cbp, zfs_handle_t *zhp)
11419d9a58e3SEric Taylor {
11429d9a58e3SEric Taylor if (cbp->cb_alloc == cbp->cb_used) {
11439d9a58e3SEric Taylor size_t newsz;
1144591e0e13SSebastien Roy zfs_handle_t **newhandles;
11459d9a58e3SEric Taylor
1146591e0e13SSebastien Roy newsz = cbp->cb_alloc != 0 ? cbp->cb_alloc * 2 : 64;
1147591e0e13SSebastien Roy newhandles = zfs_realloc(zhp->zfs_hdl,
1148591e0e13SSebastien Roy cbp->cb_handles, cbp->cb_alloc * sizeof (zfs_handle_t *),
1149591e0e13SSebastien Roy newsz * sizeof (zfs_handle_t *));
1150591e0e13SSebastien Roy cbp->cb_handles = newhandles;
11519d9a58e3SEric Taylor cbp->cb_alloc = newsz;
11529d9a58e3SEric Taylor }
11539d9a58e3SEric Taylor cbp->cb_handles[cbp->cb_used++] = zhp;
11549d9a58e3SEric Taylor }
11553bb79becSeschrock
1156591e0e13SSebastien Roy /*
1157591e0e13SSebastien Roy * Recursive helper function used during file system enumeration
1158591e0e13SSebastien Roy */
11593bb79becSeschrock static int
zfs_iter_cb(zfs_handle_t * zhp,void * data)1160591e0e13SSebastien Roy zfs_iter_cb(zfs_handle_t *zhp, void *data)
11613bb79becSeschrock {
11629d9a58e3SEric Taylor get_all_cb_t *cbp = data;
11633bb79becSeschrock
11649d9a58e3SEric Taylor if (!(zfs_get_type(zhp) & ZFS_TYPE_FILESYSTEM)) {
11653bb79becSeschrock zfs_close(zhp);
11663bb79becSeschrock return (0);
11673bb79becSeschrock }
11683bb79becSeschrock
1169a227b7f4Shs if (zfs_prop_get_int(zhp, ZFS_PROP_CANMOUNT) == ZFS_CANMOUNT_NOAUTO) {
1170a227b7f4Shs zfs_close(zhp);
1171a227b7f4Shs return (0);
1172a227b7f4Shs }
1173a227b7f4Shs
1174eb633035STom Caputi if (zfs_prop_get_int(zhp, ZFS_PROP_KEYSTATUS) ==
1175eb633035STom Caputi ZFS_KEYSTATUS_UNAVAILABLE) {
1176eb633035STom Caputi zfs_close(zhp);
1177eb633035STom Caputi return (0);
1178eb633035STom Caputi }
1179eb633035STom Caputi
11809c3fd121SMatthew Ahrens /*
11819c3fd121SMatthew Ahrens * If this filesystem is inconsistent and has a receive resume
11829c3fd121SMatthew Ahrens * token, we can not mount it.
11839c3fd121SMatthew Ahrens */
11849c3fd121SMatthew Ahrens if (zfs_prop_get_int(zhp, ZFS_PROP_INCONSISTENT) &&
11859c3fd121SMatthew Ahrens zfs_prop_get(zhp, ZFS_PROP_RECEIVE_RESUME_TOKEN,
11869c3fd121SMatthew Ahrens NULL, 0, NULL, NULL, 0, B_TRUE) == 0) {
11879c3fd121SMatthew Ahrens zfs_close(zhp);
11889c3fd121SMatthew Ahrens return (0);
11899c3fd121SMatthew Ahrens }
11909c3fd121SMatthew Ahrens
11919d9a58e3SEric Taylor libzfs_add_handle(cbp, zhp);
1192591e0e13SSebastien Roy if (zfs_iter_filesystems(zhp, zfs_iter_cb, cbp) != 0) {
11939d9a58e3SEric Taylor zfs_close(zhp);
11949d9a58e3SEric Taylor return (-1);
11953bb79becSeschrock }
11969d9a58e3SEric Taylor return (0);
11973bb79becSeschrock }
11983bb79becSeschrock
1199591e0e13SSebastien Roy /*
1200591e0e13SSebastien Roy * Sort comparator that compares two mountpoint paths. We sort these paths so
1201591e0e13SSebastien Roy * that subdirectories immediately follow their parents. This means that we
1202bc4c0ff1SAndy Fiddaman * effectively treat the '/' character as the lowest value non-nul char.
1203bc4c0ff1SAndy Fiddaman * Since filesystems from non-global zones can have the same mountpoint
1204bc4c0ff1SAndy Fiddaman * as other filesystems, the comparator sorts global zone filesystems to
1205bc4c0ff1SAndy Fiddaman * the top of the list. This means that the global zone will traverse the
1206bc4c0ff1SAndy Fiddaman * filesystem list in the correct order and can stop when it sees the
1207bc4c0ff1SAndy Fiddaman * first zoned filesystem. In a non-global zone, only the delegated
1208bc4c0ff1SAndy Fiddaman * filesystems are seen.
1209bc4c0ff1SAndy Fiddaman *
1210bc4c0ff1SAndy Fiddaman * An example sorted list using this comparator would look like:
1211591e0e13SSebastien Roy *
1212591e0e13SSebastien Roy * /foo
1213591e0e13SSebastien Roy * /foo/bar
1214591e0e13SSebastien Roy * /foo/bar/baz
1215591e0e13SSebastien Roy * /foo/baz
1216591e0e13SSebastien Roy * /foo.bar
1217bc4c0ff1SAndy Fiddaman * /foo (NGZ1)
1218bc4c0ff1SAndy Fiddaman * /foo (NGZ2)
1219591e0e13SSebastien Roy *
1220591e0e13SSebastien Roy * The mounting code depends on this ordering to deterministically iterate
1221591e0e13SSebastien Roy * over filesystems in order to spawn parallel mount tasks.
1222591e0e13SSebastien Roy */
1223bc4c0ff1SAndy Fiddaman static int
mountpoint_cmp(const void * arga,const void * argb)1224591e0e13SSebastien Roy mountpoint_cmp(const void *arga, const void *argb)
12253bb79becSeschrock {
1226591e0e13SSebastien Roy zfs_handle_t *const *zap = arga;
1227591e0e13SSebastien Roy zfs_handle_t *za = *zap;
1228591e0e13SSebastien Roy zfs_handle_t *const *zbp = argb;
1229591e0e13SSebastien Roy zfs_handle_t *zb = *zbp;
12303bb79becSeschrock char mounta[MAXPATHLEN];
12313bb79becSeschrock char mountb[MAXPATHLEN];
1232591e0e13SSebastien Roy const char *a = mounta;
1233591e0e13SSebastien Roy const char *b = mountb;
1234f3861e1aSahl boolean_t gota, gotb;
1235bc4c0ff1SAndy Fiddaman uint64_t zoneda, zonedb;
1236bc4c0ff1SAndy Fiddaman
1237bc4c0ff1SAndy Fiddaman zoneda = zfs_prop_get_int(za, ZFS_PROP_ZONED);
1238bc4c0ff1SAndy Fiddaman zonedb = zfs_prop_get_int(zb, ZFS_PROP_ZONED);
1239bc4c0ff1SAndy Fiddaman if (zoneda && !zonedb)
1240bc4c0ff1SAndy Fiddaman return (1);
1241bc4c0ff1SAndy Fiddaman if (!zoneda && zonedb)
1242bc4c0ff1SAndy Fiddaman return (-1);
1243f3861e1aSahl
1244591e0e13SSebastien Roy gota = (zfs_get_type(za) == ZFS_TYPE_FILESYSTEM);
1245591e0e13SSebastien Roy if (gota) {
1246591e0e13SSebastien Roy verify(zfs_prop_get(za, ZFS_PROP_MOUNTPOINT, mounta,
1247f3861e1aSahl sizeof (mounta), NULL, NULL, 0, B_FALSE) == 0);
1248591e0e13SSebastien Roy }
1249591e0e13SSebastien Roy gotb = (zfs_get_type(zb) == ZFS_TYPE_FILESYSTEM);
1250591e0e13SSebastien Roy if (gotb) {
1251591e0e13SSebastien Roy verify(zfs_prop_get(zb, ZFS_PROP_MOUNTPOINT, mountb,
1252f3861e1aSahl sizeof (mountb), NULL, NULL, 0, B_FALSE) == 0);
1253591e0e13SSebastien Roy }
1254f3861e1aSahl
1255591e0e13SSebastien Roy if (gota && gotb) {
1256591e0e13SSebastien Roy while (*a != '\0' && (*a == *b)) {
1257591e0e13SSebastien Roy a++;
1258591e0e13SSebastien Roy b++;
1259591e0e13SSebastien Roy }
1260591e0e13SSebastien Roy if (*a == *b)
1261591e0e13SSebastien Roy return (0);
1262591e0e13SSebastien Roy if (*a == '\0')
1263591e0e13SSebastien Roy return (-1);
1264591e0e13SSebastien Roy if (*b == '\0')
1265591e0e13SSebastien Roy return (1);
1266591e0e13SSebastien Roy if (*a == '/')
1267591e0e13SSebastien Roy return (-1);
1268591e0e13SSebastien Roy if (*b == '/')
1269591e0e13SSebastien Roy return (1);
1270591e0e13SSebastien Roy return (*a < *b ? -1 : *a > *b);
1271591e0e13SSebastien Roy }
12723bb79becSeschrock
1273f3861e1aSahl if (gota)
1274f3861e1aSahl return (-1);
1275f3861e1aSahl if (gotb)
1276f3861e1aSahl return (1);
12773bb79becSeschrock
1278591e0e13SSebastien Roy /*
1279591e0e13SSebastien Roy * If neither filesystem has a mountpoint, revert to sorting by
1280591e0e13SSebastien Roy * dataset name.
1281591e0e13SSebastien Roy */
1282591e0e13SSebastien Roy return (strcmp(zfs_get_name(za), zfs_get_name(zb)));
1283591e0e13SSebastien Roy }
1284591e0e13SSebastien Roy
1285591e0e13SSebastien Roy /*
1286591e0e13SSebastien Roy * Return true if path2 is a child of path1.
1287591e0e13SSebastien Roy */
1288591e0e13SSebastien Roy static boolean_t
libzfs_path_contains(const char * path1,const char * path2)1289591e0e13SSebastien Roy libzfs_path_contains(const char *path1, const char *path2)
1290591e0e13SSebastien Roy {
1291591e0e13SSebastien Roy return (strstr(path2, path1) == path2 && path2[strlen(path1)] == '/');
1292591e0e13SSebastien Roy }
1293591e0e13SSebastien Roy
1294591e0e13SSebastien Roy /*
1295591e0e13SSebastien Roy * Given a mountpoint specified by idx in the handles array, find the first
1296591e0e13SSebastien Roy * non-descendent of that mountpoint and return its index. Descendant paths
1297591e0e13SSebastien Roy * start with the parent's path. This function relies on the ordering
1298591e0e13SSebastien Roy * enforced by mountpoint_cmp().
1299591e0e13SSebastien Roy */
1300591e0e13SSebastien Roy static int
non_descendant_idx(zfs_handle_t ** handles,size_t num_handles,int idx)1301591e0e13SSebastien Roy non_descendant_idx(zfs_handle_t **handles, size_t num_handles, int idx)
1302591e0e13SSebastien Roy {
1303591e0e13SSebastien Roy char parent[ZFS_MAXPROPLEN];
1304591e0e13SSebastien Roy char child[ZFS_MAXPROPLEN];
1305591e0e13SSebastien Roy int i;
1306591e0e13SSebastien Roy
1307591e0e13SSebastien Roy verify(zfs_prop_get(handles[idx], ZFS_PROP_MOUNTPOINT, parent,
1308591e0e13SSebastien Roy sizeof (parent), NULL, NULL, 0, B_FALSE) == 0);
1309591e0e13SSebastien Roy
1310591e0e13SSebastien Roy for (i = idx + 1; i < num_handles; i++) {
1311591e0e13SSebastien Roy verify(zfs_prop_get(handles[i], ZFS_PROP_MOUNTPOINT, child,
1312591e0e13SSebastien Roy sizeof (child), NULL, NULL, 0, B_FALSE) == 0);
1313591e0e13SSebastien Roy if (!libzfs_path_contains(parent, child))
1314591e0e13SSebastien Roy break;
1315591e0e13SSebastien Roy }
1316591e0e13SSebastien Roy return (i);
1317591e0e13SSebastien Roy }
1318591e0e13SSebastien Roy
1319591e0e13SSebastien Roy typedef struct mnt_param {
1320591e0e13SSebastien Roy libzfs_handle_t *mnt_hdl;
1321591e0e13SSebastien Roy zfs_taskq_t *mnt_tq;
1322591e0e13SSebastien Roy zfs_handle_t **mnt_zhps; /* filesystems to mount */
1323591e0e13SSebastien Roy size_t mnt_num_handles;
1324591e0e13SSebastien Roy int mnt_idx; /* Index of selected entry to mount */
1325591e0e13SSebastien Roy zfs_iter_f mnt_func;
1326591e0e13SSebastien Roy void *mnt_data;
1327591e0e13SSebastien Roy } mnt_param_t;
1328591e0e13SSebastien Roy
1329591e0e13SSebastien Roy /*
1330591e0e13SSebastien Roy * Allocate and populate the parameter struct for mount function, and
1331591e0e13SSebastien Roy * schedule mounting of the entry selected by idx.
1332591e0e13SSebastien Roy */
1333591e0e13SSebastien Roy static void
zfs_dispatch_mount(libzfs_handle_t * hdl,zfs_handle_t ** handles,size_t num_handles,int idx,zfs_iter_f func,void * data,zfs_taskq_t * tq)1334591e0e13SSebastien Roy zfs_dispatch_mount(libzfs_handle_t *hdl, zfs_handle_t **handles,
1335591e0e13SSebastien Roy size_t num_handles, int idx, zfs_iter_f func, void *data, zfs_taskq_t *tq)
1336591e0e13SSebastien Roy {
1337591e0e13SSebastien Roy mnt_param_t *mnt_param = zfs_alloc(hdl, sizeof (mnt_param_t));
1338591e0e13SSebastien Roy
1339591e0e13SSebastien Roy mnt_param->mnt_hdl = hdl;
1340591e0e13SSebastien Roy mnt_param->mnt_tq = tq;
1341591e0e13SSebastien Roy mnt_param->mnt_zhps = handles;
1342591e0e13SSebastien Roy mnt_param->mnt_num_handles = num_handles;
1343591e0e13SSebastien Roy mnt_param->mnt_idx = idx;
1344591e0e13SSebastien Roy mnt_param->mnt_func = func;
1345591e0e13SSebastien Roy mnt_param->mnt_data = data;
1346591e0e13SSebastien Roy
1347591e0e13SSebastien Roy (void) zfs_taskq_dispatch(tq, zfs_mount_task, (void*)mnt_param,
1348591e0e13SSebastien Roy ZFS_TQ_SLEEP);
1349591e0e13SSebastien Roy }
1350591e0e13SSebastien Roy
1351591e0e13SSebastien Roy /*
1352591e0e13SSebastien Roy * This is the structure used to keep state of mounting or sharing operations
1353591e0e13SSebastien Roy * during a call to zpool_enable_datasets().
1354591e0e13SSebastien Roy */
1355591e0e13SSebastien Roy typedef struct mount_state {
1356591e0e13SSebastien Roy /*
1357591e0e13SSebastien Roy * ms_mntstatus is set to -1 if any mount fails. While multiple threads
1358591e0e13SSebastien Roy * could update this variable concurrently, no synchronization is
1359591e0e13SSebastien Roy * needed as it's only ever set to -1.
1360591e0e13SSebastien Roy */
1361591e0e13SSebastien Roy int ms_mntstatus;
1362591e0e13SSebastien Roy int ms_mntflags;
1363591e0e13SSebastien Roy const char *ms_mntopts;
1364591e0e13SSebastien Roy } mount_state_t;
1365591e0e13SSebastien Roy
1366591e0e13SSebastien Roy static int
zfs_mount_one(zfs_handle_t * zhp,void * arg)1367591e0e13SSebastien Roy zfs_mount_one(zfs_handle_t *zhp, void *arg)
1368591e0e13SSebastien Roy {
1369591e0e13SSebastien Roy mount_state_t *ms = arg;
1370591e0e13SSebastien Roy int ret = 0;
1371591e0e13SSebastien Roy
1372eb633035STom Caputi if (zfs_prop_get_int(zhp, ZFS_PROP_KEYSTATUS) ==
1373eb633035STom Caputi ZFS_KEYSTATUS_UNAVAILABLE)
1374eb633035STom Caputi return (0);
1375eb633035STom Caputi
1376591e0e13SSebastien Roy if (zfs_mount(zhp, ms->ms_mntopts, ms->ms_mntflags) != 0)
1377591e0e13SSebastien Roy ret = ms->ms_mntstatus = -1;
1378591e0e13SSebastien Roy return (ret);
1379591e0e13SSebastien Roy }
1380591e0e13SSebastien Roy
1381591e0e13SSebastien Roy static int
zfs_share_one(zfs_handle_t * zhp,void * arg)1382591e0e13SSebastien Roy zfs_share_one(zfs_handle_t *zhp, void *arg)
1383591e0e13SSebastien Roy {
1384591e0e13SSebastien Roy mount_state_t *ms = arg;
1385591e0e13SSebastien Roy int ret = 0;
1386591e0e13SSebastien Roy
1387591e0e13SSebastien Roy if (zfs_share(zhp) != 0)
1388591e0e13SSebastien Roy ret = ms->ms_mntstatus = -1;
1389591e0e13SSebastien Roy return (ret);
1390591e0e13SSebastien Roy }
1391591e0e13SSebastien Roy
1392591e0e13SSebastien Roy /*
1393591e0e13SSebastien Roy * Task queue function to mount one file system. On completion, it finds and
1394591e0e13SSebastien Roy * schedules its children to be mounted. This depends on the sorting done in
1395591e0e13SSebastien Roy * zfs_foreach_mountpoint(). Note that the degenerate case (chain of entries
1396591e0e13SSebastien Roy * each descending from the previous) will have no parallelism since we always
1397591e0e13SSebastien Roy * have to wait for the parent to finish mounting before we can schedule
1398591e0e13SSebastien Roy * its children.
1399591e0e13SSebastien Roy */
1400591e0e13SSebastien Roy static void
zfs_mount_task(void * arg)1401591e0e13SSebastien Roy zfs_mount_task(void *arg)
1402591e0e13SSebastien Roy {
1403591e0e13SSebastien Roy mnt_param_t *mp = arg;
1404591e0e13SSebastien Roy int idx = mp->mnt_idx;
1405591e0e13SSebastien Roy zfs_handle_t **handles = mp->mnt_zhps;
1406591e0e13SSebastien Roy size_t num_handles = mp->mnt_num_handles;
1407591e0e13SSebastien Roy char mountpoint[ZFS_MAXPROPLEN];
1408591e0e13SSebastien Roy
1409591e0e13SSebastien Roy verify(zfs_prop_get(handles[idx], ZFS_PROP_MOUNTPOINT, mountpoint,
1410591e0e13SSebastien Roy sizeof (mountpoint), NULL, NULL, 0, B_FALSE) == 0);
1411591e0e13SSebastien Roy
1412591e0e13SSebastien Roy if (mp->mnt_func(handles[idx], mp->mnt_data) != 0)
1413591e0e13SSebastien Roy return;
1414591e0e13SSebastien Roy
1415591e0e13SSebastien Roy /*
1416591e0e13SSebastien Roy * We dispatch tasks to mount filesystems with mountpoints underneath
1417591e0e13SSebastien Roy * this one. We do this by dispatching the next filesystem with a
1418591e0e13SSebastien Roy * descendant mountpoint of the one we just mounted, then skip all of
1419591e0e13SSebastien Roy * its descendants, dispatch the next descendant mountpoint, and so on.
1420591e0e13SSebastien Roy * The non_descendant_idx() function skips over filesystems that are
1421591e0e13SSebastien Roy * descendants of the filesystem we just dispatched.
1422591e0e13SSebastien Roy */
1423591e0e13SSebastien Roy for (int i = idx + 1; i < num_handles;
1424591e0e13SSebastien Roy i = non_descendant_idx(handles, num_handles, i)) {
1425591e0e13SSebastien Roy char child[ZFS_MAXPROPLEN];
1426591e0e13SSebastien Roy verify(zfs_prop_get(handles[i], ZFS_PROP_MOUNTPOINT,
1427591e0e13SSebastien Roy child, sizeof (child), NULL, NULL, 0, B_FALSE) == 0);
1428591e0e13SSebastien Roy
1429591e0e13SSebastien Roy if (!libzfs_path_contains(mountpoint, child))
1430591e0e13SSebastien Roy break; /* not a descendant, return */
1431591e0e13SSebastien Roy zfs_dispatch_mount(mp->mnt_hdl, handles, num_handles, i,
1432591e0e13SSebastien Roy mp->mnt_func, mp->mnt_data, mp->mnt_tq);
1433591e0e13SSebastien Roy }
1434591e0e13SSebastien Roy free(mp);
1435591e0e13SSebastien Roy }
1436591e0e13SSebastien Roy
1437591e0e13SSebastien Roy /*
1438591e0e13SSebastien Roy * Issue the func callback for each ZFS handle contained in the handles
1439591e0e13SSebastien Roy * array. This function is used to mount all datasets, and so this function
1440591e0e13SSebastien Roy * guarantees that filesystems for parent mountpoints are called before their
1441591e0e13SSebastien Roy * children. As such, before issuing any callbacks, we first sort the array
1442591e0e13SSebastien Roy * of handles by mountpoint.
1443591e0e13SSebastien Roy *
1444591e0e13SSebastien Roy * Callbacks are issued in one of two ways:
1445591e0e13SSebastien Roy *
1446591e0e13SSebastien Roy * 1. Sequentially: If the parallel argument is B_FALSE or the ZFS_SERIAL_MOUNT
1447591e0e13SSebastien Roy * environment variable is set, then we issue callbacks sequentially.
1448591e0e13SSebastien Roy *
1449591e0e13SSebastien Roy * 2. In parallel: If the parallel argument is B_TRUE and the ZFS_SERIAL_MOUNT
1450591e0e13SSebastien Roy * environment variable is not set, then we use a taskq to dispatch threads
1451591e0e13SSebastien Roy * to mount filesystems is parallel. This function dispatches tasks to mount
1452591e0e13SSebastien Roy * the filesystems at the top-level mountpoints, and these tasks in turn
1453591e0e13SSebastien Roy * are responsible for recursively mounting filesystems in their children
1454591e0e13SSebastien Roy * mountpoints.
1455591e0e13SSebastien Roy */
1456591e0e13SSebastien Roy void
zfs_foreach_mountpoint(libzfs_handle_t * hdl,zfs_handle_t ** handles,size_t num_handles,zfs_iter_f func,void * data,boolean_t parallel)1457591e0e13SSebastien Roy zfs_foreach_mountpoint(libzfs_handle_t *hdl, zfs_handle_t **handles,
1458591e0e13SSebastien Roy size_t num_handles, zfs_iter_f func, void *data, boolean_t parallel)
1459591e0e13SSebastien Roy {
1460bc4c0ff1SAndy Fiddaman zoneid_t zoneid = getzoneid();
1461bc4c0ff1SAndy Fiddaman
1462591e0e13SSebastien Roy /*
1463591e0e13SSebastien Roy * The ZFS_SERIAL_MOUNT environment variable is an undocumented
1464591e0e13SSebastien Roy * variable that can be used as a convenience to do a/b comparison
1465591e0e13SSebastien Roy * of serial vs. parallel mounting.
1466591e0e13SSebastien Roy */
1467591e0e13SSebastien Roy boolean_t serial_mount = !parallel ||
1468591e0e13SSebastien Roy (getenv("ZFS_SERIAL_MOUNT") != NULL);
1469591e0e13SSebastien Roy
1470591e0e13SSebastien Roy /*
1471591e0e13SSebastien Roy * Sort the datasets by mountpoint. See mountpoint_cmp for details
1472591e0e13SSebastien Roy * of how these are sorted.
1473591e0e13SSebastien Roy */
1474591e0e13SSebastien Roy qsort(handles, num_handles, sizeof (zfs_handle_t *), mountpoint_cmp);
1475591e0e13SSebastien Roy
1476591e0e13SSebastien Roy if (serial_mount) {
1477591e0e13SSebastien Roy for (int i = 0; i < num_handles; i++) {
1478591e0e13SSebastien Roy func(handles[i], data);
1479591e0e13SSebastien Roy }
1480591e0e13SSebastien Roy return;
1481591e0e13SSebastien Roy }
1482591e0e13SSebastien Roy
1483591e0e13SSebastien Roy /*
1484591e0e13SSebastien Roy * Issue the callback function for each dataset using a parallel
1485591e0e13SSebastien Roy * algorithm that uses a taskq to manage threads.
1486591e0e13SSebastien Roy */
1487591e0e13SSebastien Roy zfs_taskq_t *tq = zfs_taskq_create("mount_taskq", mount_tq_nthr, 0,
1488591e0e13SSebastien Roy mount_tq_nthr, mount_tq_nthr, ZFS_TASKQ_PREPOPULATE);
1489591e0e13SSebastien Roy
1490591e0e13SSebastien Roy /*
1491591e0e13SSebastien Roy * There may be multiple "top level" mountpoints outside of the pool's
1492591e0e13SSebastien Roy * root mountpoint, e.g.: /foo /bar. Dispatch a mount task for each of
1493591e0e13SSebastien Roy * these.
1494591e0e13SSebastien Roy */
1495591e0e13SSebastien Roy for (int i = 0; i < num_handles;
1496591e0e13SSebastien Roy i = non_descendant_idx(handles, num_handles, i)) {
1497bc4c0ff1SAndy Fiddaman /*
1498bc4c0ff1SAndy Fiddaman * Since the mountpoints have been sorted so that the zoned
1499bc4c0ff1SAndy Fiddaman * filesystems are at the end, a zoned filesystem seen from
1500bc4c0ff1SAndy Fiddaman * the global zone means that we're done.
1501bc4c0ff1SAndy Fiddaman */
1502bc4c0ff1SAndy Fiddaman if (zoneid == GLOBAL_ZONEID &&
1503bc4c0ff1SAndy Fiddaman zfs_prop_get_int(handles[i], ZFS_PROP_ZONED))
1504bc4c0ff1SAndy Fiddaman break;
1505591e0e13SSebastien Roy zfs_dispatch_mount(hdl, handles, num_handles, i, func, data,
1506591e0e13SSebastien Roy tq);
1507591e0e13SSebastien Roy }
1508591e0e13SSebastien Roy
1509591e0e13SSebastien Roy zfs_taskq_wait(tq); /* wait for all scheduled mounts to complete */
1510591e0e13SSebastien Roy zfs_taskq_destroy(tq);
15113bb79becSeschrock }
15123bb79becSeschrock
1513f3861e1aSahl /*
1514f3861e1aSahl * Mount and share all datasets within the given pool. This assumes that no
1515591e0e13SSebastien Roy * datasets within the pool are currently mounted.
1516f3861e1aSahl */
1517f3861e1aSahl #pragma weak zpool_mount_datasets = zpool_enable_datasets
15183bb79becSeschrock int
zpool_enable_datasets(zpool_handle_t * zhp,const char * mntopts,int flags)1519f3861e1aSahl zpool_enable_datasets(zpool_handle_t *zhp, const char *mntopts, int flags)
15203bb79becSeschrock {
15219d9a58e3SEric Taylor get_all_cb_t cb = { 0 };
1522591e0e13SSebastien Roy mount_state_t ms = { 0 };
15233bb79becSeschrock zfs_handle_t *zfsp;
1524591e0e13SSebastien Roy sa_init_selective_arg_t sharearg;
1525591e0e13SSebastien Roy int ret = 0;
15263bb79becSeschrock
1527591e0e13SSebastien Roy if ((zfsp = zfs_open(zhp->zpool_hdl, zhp->zpool_name,
1528591e0e13SSebastien Roy ZFS_TYPE_DATASET)) == NULL)
15293bb79becSeschrock goto out;
15303bb79becSeschrock
15313bb79becSeschrock
15323bb79becSeschrock /*
1533591e0e13SSebastien Roy * Gather all non-snapshot datasets within the pool. Start by adding
1534591e0e13SSebastien Roy * the root filesystem for this pool to the list, and then iterate
1535591e0e13SSebastien Roy * over all child filesystems.
15363bb79becSeschrock */
1537591e0e13SSebastien Roy libzfs_add_handle(&cb, zfsp);
1538591e0e13SSebastien Roy if (zfs_iter_filesystems(zfsp, zfs_iter_cb, &cb) != 0)
15396e77af0aSDavid Pacheco goto out;
15406e77af0aSDavid Pacheco
1541591e0e13SSebastien Roy ms.ms_mntopts = mntopts;
1542591e0e13SSebastien Roy ms.ms_mntflags = flags;
1543591e0e13SSebastien Roy zfs_foreach_mountpoint(zhp->zpool_hdl, cb.cb_handles, cb.cb_used,
1544591e0e13SSebastien Roy zfs_mount_one, &ms, B_TRUE);
1545591e0e13SSebastien Roy if (ms.ms_mntstatus != 0)
1546591e0e13SSebastien Roy ret = ms.ms_mntstatus;
15475b6e0c46Sdougm
154867331909Sdougm /*
1549b8dc1b43SJoyce McIntosh * Initialize libshare SA_INIT_SHARE_API_SELECTIVE here
1550b8dc1b43SJoyce McIntosh * to avoid unnecessary load/unload of the libshare API
1551b8dc1b43SJoyce McIntosh * per shared dataset downstream.
155267331909Sdougm */
1553591e0e13SSebastien Roy sharearg.zhandle_arr = cb.cb_handles;
1554591e0e13SSebastien Roy sharearg.zhandle_len = cb.cb_used;
1555591e0e13SSebastien Roy if ((ret = zfs_init_libshare_arg(zhp->zpool_hdl,
1556591e0e13SSebastien Roy SA_INIT_SHARE_API_SELECTIVE, &sharearg)) != 0)
1557591e0e13SSebastien Roy goto out;
155867331909Sdougm
1559591e0e13SSebastien Roy ms.ms_mntstatus = 0;
1560591e0e13SSebastien Roy zfs_foreach_mountpoint(zhp->zpool_hdl, cb.cb_handles, cb.cb_used,
1561591e0e13SSebastien Roy zfs_share_one, &ms, B_FALSE);
1562591e0e13SSebastien Roy if (ms.ms_mntstatus != 0)
1563591e0e13SSebastien Roy ret = ms.ms_mntstatus;
15643bb79becSeschrock
15653bb79becSeschrock out:
1566591e0e13SSebastien Roy for (int i = 0; i < cb.cb_used; i++)
15679d9a58e3SEric Taylor zfs_close(cb.cb_handles[i]);
15689d9a58e3SEric Taylor free(cb.cb_handles);
15693bb79becSeschrock
15703bb79becSeschrock return (ret);
15713bb79becSeschrock }
15723bb79becSeschrock
15733bb79becSeschrock static int
mountpoint_compare(const void * a,const void * b)15743bb79becSeschrock mountpoint_compare(const void *a, const void *b)
15753bb79becSeschrock {
15763bb79becSeschrock const char *mounta = *((char **)a);
15773bb79becSeschrock const char *mountb = *((char **)b);
15783bb79becSeschrock
15793bb79becSeschrock return (strcmp(mountb, mounta));
15803bb79becSeschrock }
15813bb79becSeschrock
1582681d9761SEric Taylor /* alias for 2002/240 */
1583681d9761SEric Taylor #pragma weak zpool_unmount_datasets = zpool_disable_datasets
1584f3861e1aSahl /*
1585f3861e1aSahl * Unshare and unmount all datasets within the given pool. We don't want to
1586f3861e1aSahl * rely on traversing the DSL to discover the filesystems within the pool,
1587f3861e1aSahl * because this may be expensive (if not all of them are mounted), and can fail
1588f3861e1aSahl * arbitrarily (on I/O error, for example). Instead, we walk /etc/mnttab and
1589f3861e1aSahl * gather all the filesystems that are currently mounted.
1590f3861e1aSahl */
15913bb79becSeschrock int
zpool_disable_datasets(zpool_handle_t * zhp,boolean_t force)1592f3861e1aSahl zpool_disable_datasets(zpool_handle_t *zhp, boolean_t force)
15933bb79becSeschrock {
15943bb79becSeschrock int used, alloc;
15953bb79becSeschrock struct mnttab entry;
15963bb79becSeschrock size_t namelen;
15973bb79becSeschrock char **mountpoints = NULL;
15983bb79becSeschrock zfs_handle_t **datasets = NULL;
15993bb79becSeschrock libzfs_handle_t *hdl = zhp->zpool_hdl;
16003bb79becSeschrock int i;
16013bb79becSeschrock int ret = -1;
16023bb79becSeschrock int flags = (force ? MS_FORCE : 0);
16038a981c33SDaniel Hoffman sa_init_selective_arg_t sharearg;
16043bb79becSeschrock
16053bb79becSeschrock namelen = strlen(zhp->zpool_name);
16063bb79becSeschrock
16073bb79becSeschrock rewind(hdl->libzfs_mnttab);
16083bb79becSeschrock used = alloc = 0;
16093bb79becSeschrock while (getmntent(hdl->libzfs_mnttab, &entry) == 0) {
16103bb79becSeschrock /*
16113bb79becSeschrock * Ignore non-ZFS entries.
16123bb79becSeschrock */
16133bb79becSeschrock if (entry.mnt_fstype == NULL ||
16143bb79becSeschrock strcmp(entry.mnt_fstype, MNTTYPE_ZFS) != 0)
16153bb79becSeschrock continue;
16163bb79becSeschrock
16173bb79becSeschrock /*
16183bb79becSeschrock * Ignore filesystems not within this pool.
16193bb79becSeschrock */
16203bb79becSeschrock if (entry.mnt_mountp == NULL ||
16213bb79becSeschrock strncmp(entry.mnt_special, zhp->zpool_name, namelen) != 0 ||
16223bb79becSeschrock (entry.mnt_special[namelen] != '/' &&
16233bb79becSeschrock entry.mnt_special[namelen] != '\0'))
16243bb79becSeschrock continue;
16253bb79becSeschrock
16263bb79becSeschrock /*
16273bb79becSeschrock * At this point we've found a filesystem within our pool. Add
16283bb79becSeschrock * it to our growing list.
16293bb79becSeschrock */
16303bb79becSeschrock if (used == alloc) {
16313bb79becSeschrock if (alloc == 0) {
16323bb79becSeschrock if ((mountpoints = zfs_alloc(hdl,
16333bb79becSeschrock 8 * sizeof (void *))) == NULL)
16343bb79becSeschrock goto out;
16353bb79becSeschrock
16363bb79becSeschrock if ((datasets = zfs_alloc(hdl,
16373bb79becSeschrock 8 * sizeof (void *))) == NULL)
16383bb79becSeschrock goto out;
16393bb79becSeschrock
16403bb79becSeschrock alloc = 8;
16413bb79becSeschrock } else {
1642e9dbad6fSeschrock void *ptr;
16433bb79becSeschrock
1644e9dbad6fSeschrock if ((ptr = zfs_realloc(hdl, mountpoints,
1645e9dbad6fSeschrock alloc * sizeof (void *),
16463bb79becSeschrock alloc * 2 * sizeof (void *))) == NULL)
16473bb79becSeschrock goto out;
1648e9dbad6fSeschrock mountpoints = ptr;
16493bb79becSeschrock
1650e9dbad6fSeschrock if ((ptr = zfs_realloc(hdl, datasets,
1651e9dbad6fSeschrock alloc * sizeof (void *),
16523bb79becSeschrock alloc * 2 * sizeof (void *))) == NULL)
16533bb79becSeschrock goto out;
1654e9dbad6fSeschrock datasets = ptr;
16553bb79becSeschrock
16563bb79becSeschrock alloc *= 2;
16573bb79becSeschrock }
16583bb79becSeschrock }
16593bb79becSeschrock
16603bb79becSeschrock if ((mountpoints[used] = zfs_strdup(hdl,
16613bb79becSeschrock entry.mnt_mountp)) == NULL)
16623bb79becSeschrock goto out;
16633bb79becSeschrock
16643bb79becSeschrock /*
16653bb79becSeschrock * This is allowed to fail, in case there is some I/O error. It
16663bb79becSeschrock * is only used to determine if we need to remove the underlying
16673bb79becSeschrock * mountpoint, so failure is not fatal.
16683bb79becSeschrock */
16693bb79becSeschrock datasets[used] = make_dataset_handle(hdl, entry.mnt_special);
16703bb79becSeschrock
16713bb79becSeschrock used++;
16723bb79becSeschrock }
16733bb79becSeschrock
16743bb79becSeschrock /*
16753bb79becSeschrock * At this point, we have the entire list of filesystems, so sort it by
16763bb79becSeschrock * mountpoint.
16773bb79becSeschrock */
16788a981c33SDaniel Hoffman sharearg.zhandle_arr = datasets;
16798a981c33SDaniel Hoffman sharearg.zhandle_len = used;
16808a981c33SDaniel Hoffman ret = zfs_init_libshare_arg(hdl, SA_INIT_SHARE_API_SELECTIVE,
16818a981c33SDaniel Hoffman &sharearg);
16828a981c33SDaniel Hoffman if (ret != 0)
16838a981c33SDaniel Hoffman goto out;
16843bb79becSeschrock qsort(mountpoints, used, sizeof (char *), mountpoint_compare);
16853bb79becSeschrock
16863bb79becSeschrock /*
16873bb79becSeschrock * Walk through and first unshare everything.
16883bb79becSeschrock */
16893bb79becSeschrock for (i = 0; i < used; i++) {
1690da6c28aaSamw zfs_share_proto_t *curr_proto;
1691da6c28aaSamw for (curr_proto = share_all_proto; *curr_proto != PROTO_END;
1692da6c28aaSamw curr_proto++) {
1693da6c28aaSamw if (is_shared(hdl, mountpoints[i], *curr_proto) &&
1694da6c28aaSamw unshare_one(hdl, mountpoints[i],
1695da6c28aaSamw mountpoints[i], *curr_proto) != 0)
1696da6c28aaSamw goto out;
1697da6c28aaSamw }
16983bb79becSeschrock }
16993bb79becSeschrock
17003bb79becSeschrock /*
17013bb79becSeschrock * Now unmount everything, removing the underlying directories as
17023bb79becSeschrock * appropriate.
17033bb79becSeschrock */
17043bb79becSeschrock for (i = 0; i < used; i++) {
17053bb79becSeschrock if (unmount_one(hdl, mountpoints[i], flags) != 0)
17063bb79becSeschrock goto out;
1707e9dbad6fSeschrock }
17083bb79becSeschrock
1709e9dbad6fSeschrock for (i = 0; i < used; i++) {
17103bb79becSeschrock if (datasets[i])
17113bb79becSeschrock remove_mountpoint(datasets[i]);
17123bb79becSeschrock }
17133bb79becSeschrock
17143bb79becSeschrock ret = 0;
17153bb79becSeschrock out:
17163bb79becSeschrock for (i = 0; i < used; i++) {
17173bb79becSeschrock if (datasets[i])
17183bb79becSeschrock zfs_close(datasets[i]);
17193bb79becSeschrock free(mountpoints[i]);
17203bb79becSeschrock }
17213bb79becSeschrock free(datasets);
17223bb79becSeschrock free(mountpoints);
17233bb79becSeschrock
17243bb79becSeschrock return (ret);
17253bb79becSeschrock }
1726