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 /* 2311d2789dSgw * Copyright 2007 Sun Microsystems, Inc. All rights reserved. 24fa9e4066Sahrens * Use is subject to license terms. 25fa9e4066Sahrens */ 26fa9e4066Sahrens 27fa9e4066Sahrens #pragma ident "%Z%%M% %I% %E% SMI" 28fa9e4066Sahrens 29fa9e4066Sahrens /* 30fa9e4066Sahrens * Routines to manage ZFS mounts. We separate all the nasty routines that have 31f3861e1aSahl * to deal with the OS. The following functions are the main entry points -- 32f3861e1aSahl * they are used by mount and unmount and when changing a filesystem's 33f3861e1aSahl * mountpoint. 34fa9e4066Sahrens * 35fa9e4066Sahrens * zfs_is_mounted() 36fa9e4066Sahrens * zfs_mount() 37fa9e4066Sahrens * zfs_unmount() 38fa9e4066Sahrens * zfs_unmountall() 39fa9e4066Sahrens * 40f3861e1aSahl * This file also contains the functions used to manage sharing filesystems via 41f3861e1aSahl * NFS and iSCSI: 42fa9e4066Sahrens * 43fa9e4066Sahrens * zfs_is_shared() 44fa9e4066Sahrens * zfs_share() 45fa9e4066Sahrens * zfs_unshare() 46f3861e1aSahl * 47f3861e1aSahl * zfs_is_shared_nfs() 48f3861e1aSahl * zfs_share_nfs() 49f3861e1aSahl * zfs_unshare_nfs() 50f3861e1aSahl * zfs_unshareall_nfs() 51f3861e1aSahl * zfs_is_shared_iscsi() 52f3861e1aSahl * zfs_share_iscsi() 53f3861e1aSahl * zfs_unshare_iscsi() 543bb79becSeschrock * 553bb79becSeschrock * The following functions are available for pool consumers, and will 56f3861e1aSahl * mount/unmount and share/unshare all datasets within pool: 573bb79becSeschrock * 58f3861e1aSahl * zpool_enable_datasets() 59f3861e1aSahl * zpool_disable_datasets() 60fa9e4066Sahrens */ 61fa9e4066Sahrens 62fa9e4066Sahrens #include <dirent.h> 63d8d59944Sahl #include <dlfcn.h> 64fa9e4066Sahrens #include <errno.h> 65fa9e4066Sahrens #include <libgen.h> 66fa9e4066Sahrens #include <libintl.h> 67fa9e4066Sahrens #include <stdio.h> 68fa9e4066Sahrens #include <stdlib.h> 69fa9e4066Sahrens #include <strings.h> 70fa9e4066Sahrens #include <unistd.h> 71fa9e4066Sahrens #include <zone.h> 72fa9e4066Sahrens #include <sys/mntent.h> 73fa9e4066Sahrens #include <sys/mnttab.h> 74fa9e4066Sahrens #include <sys/mount.h> 75fa9e4066Sahrens #include <sys/stat.h> 76fa9e4066Sahrens 77fa9e4066Sahrens #include <libzfs.h> 78fa9e4066Sahrens 79fa9e4066Sahrens #include "libzfs_impl.h" 80fa9e4066Sahrens 81*67331909Sdougm #include <libshare.h> 82*67331909Sdougm #include <sys/systeminfo.h> 83*67331909Sdougm #define MAXISALEN 257 /* based on sysinfo(2) man page */ 84*67331909Sdougm 85d8d59944Sahl static int (*iscsitgt_zfs_share)(const char *); 86d8d59944Sahl static int (*iscsitgt_zfs_unshare)(const char *); 87d8d59944Sahl static int (*iscsitgt_zfs_is_shared)(const char *); 88d8d59944Sahl 89d8d59944Sahl #pragma init(zfs_iscsi_init) 90d8d59944Sahl static void 91d8d59944Sahl zfs_iscsi_init(void) 92d8d59944Sahl { 93d8d59944Sahl void *libiscsitgt; 94d8d59944Sahl 95d8d59944Sahl if ((libiscsitgt = dlopen("/lib/libiscsitgt.so.1", 96d8d59944Sahl RTLD_LAZY | RTLD_GLOBAL)) == NULL || 97d8d59944Sahl (iscsitgt_zfs_share = (int (*)(const char *))dlsym(libiscsitgt, 98d8d59944Sahl "iscsitgt_zfs_share")) == NULL || 99d8d59944Sahl (iscsitgt_zfs_unshare = (int (*)(const char *))dlsym(libiscsitgt, 100d8d59944Sahl "iscsitgt_zfs_unshare")) == NULL || 101d8d59944Sahl (iscsitgt_zfs_is_shared = (int (*)(const char *))dlsym(libiscsitgt, 102d8d59944Sahl "iscsitgt_zfs_is_shared")) == NULL) { 103d8d59944Sahl iscsitgt_zfs_share = NULL; 104d8d59944Sahl iscsitgt_zfs_unshare = NULL; 105d8d59944Sahl iscsitgt_zfs_is_shared = NULL; 106d8d59944Sahl } 107d8d59944Sahl } 108d8d59944Sahl 109fa9e4066Sahrens /* 11099653d4eSeschrock * Search the sharetab for the given mountpoint, returning true if it is found. 111fa9e4066Sahrens */ 11299653d4eSeschrock static boolean_t 11399653d4eSeschrock is_shared(libzfs_handle_t *hdl, const char *mountpoint) 114fa9e4066Sahrens { 115fa9e4066Sahrens char buf[MAXPATHLEN], *tab; 116fa9e4066Sahrens 11799653d4eSeschrock if (hdl->libzfs_sharetab == NULL) 118fa9e4066Sahrens return (0); 119fa9e4066Sahrens 12099653d4eSeschrock (void) fseek(hdl->libzfs_sharetab, 0, SEEK_SET); 121fa9e4066Sahrens 12299653d4eSeschrock while (fgets(buf, sizeof (buf), hdl->libzfs_sharetab) != NULL) { 123fa9e4066Sahrens 124fa9e4066Sahrens /* the mountpoint is the first entry on each line */ 125fa9e4066Sahrens if ((tab = strchr(buf, '\t')) != NULL) { 126fa9e4066Sahrens *tab = '\0'; 127fa9e4066Sahrens if (strcmp(buf, mountpoint) == 0) 12899653d4eSeschrock return (B_TRUE); 129fa9e4066Sahrens } 130fa9e4066Sahrens } 131fa9e4066Sahrens 13299653d4eSeschrock return (B_FALSE); 133fa9e4066Sahrens } 134fa9e4066Sahrens 135fa9e4066Sahrens /* 13699653d4eSeschrock * Returns true if the specified directory is empty. If we can't open the 13799653d4eSeschrock * directory at all, return true so that the mount can fail with a more 138fa9e4066Sahrens * informative error message. 139fa9e4066Sahrens */ 14099653d4eSeschrock static boolean_t 141fa9e4066Sahrens dir_is_empty(const char *dirname) 142fa9e4066Sahrens { 143fa9e4066Sahrens DIR *dirp; 144fa9e4066Sahrens struct dirent64 *dp; 145fa9e4066Sahrens 146fa9e4066Sahrens if ((dirp = opendir(dirname)) == NULL) 14799653d4eSeschrock return (B_TRUE); 148fa9e4066Sahrens 149fa9e4066Sahrens while ((dp = readdir64(dirp)) != NULL) { 150fa9e4066Sahrens 151fa9e4066Sahrens if (strcmp(dp->d_name, ".") == 0 || 152fa9e4066Sahrens strcmp(dp->d_name, "..") == 0) 153fa9e4066Sahrens continue; 154fa9e4066Sahrens 155fa9e4066Sahrens (void) closedir(dirp); 15699653d4eSeschrock return (B_FALSE); 157fa9e4066Sahrens } 158fa9e4066Sahrens 159fa9e4066Sahrens (void) closedir(dirp); 16099653d4eSeschrock return (B_TRUE); 161fa9e4066Sahrens } 162fa9e4066Sahrens 163fa9e4066Sahrens /* 164fa9e4066Sahrens * Checks to see if the mount is active. If the filesystem is mounted, we fill 165fa9e4066Sahrens * in 'where' with the current mountpoint, and return 1. Otherwise, we return 166fa9e4066Sahrens * 0. 167fa9e4066Sahrens */ 16899653d4eSeschrock boolean_t 16955434c77Sek is_mounted(libzfs_handle_t *zfs_hdl, const char *special, char **where) 170fa9e4066Sahrens { 171fa9e4066Sahrens struct mnttab search = { 0 }, entry; 172fa9e4066Sahrens 173fa9e4066Sahrens /* 174fa9e4066Sahrens * Search for the entry in /etc/mnttab. We don't bother getting the 175fa9e4066Sahrens * mountpoint, as we can just search for the special device. This will 176fa9e4066Sahrens * also let us find mounts when the mountpoint is 'legacy'. 177fa9e4066Sahrens */ 17855434c77Sek search.mnt_special = (char *)special; 17996dedd18Snd search.mnt_fstype = MNTTYPE_ZFS; 180fa9e4066Sahrens 18155434c77Sek rewind(zfs_hdl->libzfs_mnttab); 18255434c77Sek if (getmntany(zfs_hdl->libzfs_mnttab, &entry, &search) != 0) 18399653d4eSeschrock return (B_FALSE); 184fa9e4066Sahrens 185fa9e4066Sahrens if (where != NULL) 18655434c77Sek *where = zfs_strdup(zfs_hdl, entry.mnt_mountp); 187fa9e4066Sahrens 18899653d4eSeschrock return (B_TRUE); 189fa9e4066Sahrens } 190fa9e4066Sahrens 19155434c77Sek boolean_t 19255434c77Sek zfs_is_mounted(zfs_handle_t *zhp, char **where) 19355434c77Sek { 19455434c77Sek return (is_mounted(zhp->zfs_hdl, zfs_get_name(zhp), where)); 19555434c77Sek } 19655434c77Sek 197e9dbad6fSeschrock /* 198e9dbad6fSeschrock * Returns true if the given dataset is mountable, false otherwise. Returns the 199e9dbad6fSeschrock * mountpoint in 'buf'. 200e9dbad6fSeschrock */ 201e9dbad6fSeschrock static boolean_t 202e9dbad6fSeschrock zfs_is_mountable(zfs_handle_t *zhp, char *buf, size_t buflen, 203e9dbad6fSeschrock zfs_source_t *source) 204e9dbad6fSeschrock { 205e9dbad6fSeschrock char sourceloc[ZFS_MAXNAMELEN]; 206e9dbad6fSeschrock zfs_source_t sourcetype; 207e9dbad6fSeschrock 208e9dbad6fSeschrock if (!zfs_prop_valid_for_type(ZFS_PROP_MOUNTPOINT, zhp->zfs_type)) 209e9dbad6fSeschrock return (B_FALSE); 210e9dbad6fSeschrock 211e9dbad6fSeschrock verify(zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, buf, buflen, 212e9dbad6fSeschrock &sourcetype, sourceloc, sizeof (sourceloc), B_FALSE) == 0); 213e9dbad6fSeschrock 214e9dbad6fSeschrock if (strcmp(buf, ZFS_MOUNTPOINT_NONE) == 0 || 215e9dbad6fSeschrock strcmp(buf, ZFS_MOUNTPOINT_LEGACY) == 0) 216e9dbad6fSeschrock return (B_FALSE); 217e9dbad6fSeschrock 218e9dbad6fSeschrock if (!zfs_prop_get_int(zhp, ZFS_PROP_CANMOUNT)) 219e9dbad6fSeschrock return (B_FALSE); 220e9dbad6fSeschrock 221e9dbad6fSeschrock if (zfs_prop_get_int(zhp, ZFS_PROP_ZONED) && 222e9dbad6fSeschrock getzoneid() == GLOBAL_ZONEID) 223e9dbad6fSeschrock return (B_FALSE); 224e9dbad6fSeschrock 225e9dbad6fSeschrock if (source) 226e9dbad6fSeschrock *source = sourcetype; 227e9dbad6fSeschrock 228e9dbad6fSeschrock return (B_TRUE); 229e9dbad6fSeschrock } 230e9dbad6fSeschrock 231fa9e4066Sahrens /* 232fa9e4066Sahrens * Mount the given filesystem. 233fa9e4066Sahrens */ 234fa9e4066Sahrens int 235fa9e4066Sahrens zfs_mount(zfs_handle_t *zhp, const char *options, int flags) 236fa9e4066Sahrens { 237fa9e4066Sahrens struct stat buf; 238fa9e4066Sahrens char mountpoint[ZFS_MAXPROPLEN]; 239fa9e4066Sahrens char mntopts[MNT_LINE_MAX]; 24099653d4eSeschrock libzfs_handle_t *hdl = zhp->zfs_hdl; 241fa9e4066Sahrens 242fa9e4066Sahrens if (options == NULL) 243fa9e4066Sahrens mntopts[0] = '\0'; 244fa9e4066Sahrens else 245fa9e4066Sahrens (void) strlcpy(mntopts, options, sizeof (mntopts)); 246fa9e4066Sahrens 247e9dbad6fSeschrock if (!zfs_is_mountable(zhp, mountpoint, sizeof (mountpoint), NULL)) 24899653d4eSeschrock return (0); 249fa9e4066Sahrens 250fa9e4066Sahrens /* Create the directory if it doesn't already exist */ 251fa9e4066Sahrens if (lstat(mountpoint, &buf) != 0) { 252fa9e4066Sahrens if (mkdirp(mountpoint, 0755) != 0) { 25399653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 25499653d4eSeschrock "failed to create mountpoint")); 255ece3d9b3Slling return (zfs_error_fmt(hdl, EZFS_MOUNTFAILED, 25699653d4eSeschrock dgettext(TEXT_DOMAIN, "cannot mount '%s'"), 25799653d4eSeschrock mountpoint)); 258fa9e4066Sahrens } 259fa9e4066Sahrens } 260fa9e4066Sahrens 261fa9e4066Sahrens /* 262fa9e4066Sahrens * Determine if the mountpoint is empty. If so, refuse to perform the 263fa9e4066Sahrens * mount. We don't perform this check if MS_OVERLAY is specified, which 264fa9e4066Sahrens * would defeat the point. We also avoid this check if 'remount' is 265fa9e4066Sahrens * specified. 266fa9e4066Sahrens */ 267fa9e4066Sahrens if ((flags & MS_OVERLAY) == 0 && 268fa9e4066Sahrens strstr(mntopts, MNTOPT_REMOUNT) == NULL && 269fa9e4066Sahrens !dir_is_empty(mountpoint)) { 27099653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 27199653d4eSeschrock "directory is not empty")); 272ece3d9b3Slling return (zfs_error_fmt(hdl, EZFS_MOUNTFAILED, 27399653d4eSeschrock dgettext(TEXT_DOMAIN, "cannot mount '%s'"), mountpoint)); 274fa9e4066Sahrens } 275fa9e4066Sahrens 276fa9e4066Sahrens /* perform the mount */ 277fa9e4066Sahrens if (mount(zfs_get_name(zhp), mountpoint, MS_OPTIONSTR | flags, 278fa9e4066Sahrens MNTTYPE_ZFS, NULL, 0, mntopts, sizeof (mntopts)) != 0) { 279fa9e4066Sahrens /* 280fa9e4066Sahrens * Generic errors are nasty, but there are just way too many 281fa9e4066Sahrens * from mount(), and they're well-understood. We pick a few 282fa9e4066Sahrens * common ones to improve upon. 283fa9e4066Sahrens */ 28499653d4eSeschrock if (errno == EBUSY) 28599653d4eSeschrock zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 28699653d4eSeschrock "mountpoint or dataset is busy")); 28799653d4eSeschrock else 28899653d4eSeschrock zfs_error_aux(hdl, strerror(errno)); 28999653d4eSeschrock 290ece3d9b3Slling return (zfs_error_fmt(hdl, EZFS_MOUNTFAILED, 29199653d4eSeschrock dgettext(TEXT_DOMAIN, "cannot mount '%s'"), 29299653d4eSeschrock zhp->zfs_name)); 293fa9e4066Sahrens } 294fa9e4066Sahrens 295fa9e4066Sahrens return (0); 296fa9e4066Sahrens } 297fa9e4066Sahrens 2983bb79becSeschrock /* 2993bb79becSeschrock * Unmount a single filesystem. 3003bb79becSeschrock */ 3013bb79becSeschrock static int 3023bb79becSeschrock unmount_one(libzfs_handle_t *hdl, const char *mountpoint, int flags) 3033bb79becSeschrock { 3043bb79becSeschrock if (umount2(mountpoint, flags) != 0) { 3053bb79becSeschrock zfs_error_aux(hdl, strerror(errno)); 306ece3d9b3Slling return (zfs_error_fmt(hdl, EZFS_UMOUNTFAILED, 3073bb79becSeschrock dgettext(TEXT_DOMAIN, "cannot unmount '%s'"), 3083bb79becSeschrock mountpoint)); 3093bb79becSeschrock } 3103bb79becSeschrock 3113bb79becSeschrock return (0); 3123bb79becSeschrock } 3133bb79becSeschrock 314fa9e4066Sahrens /* 315fa9e4066Sahrens * Unmount the given filesystem. 316fa9e4066Sahrens */ 317fa9e4066Sahrens int 318fa9e4066Sahrens zfs_unmount(zfs_handle_t *zhp, const char *mountpoint, int flags) 319fa9e4066Sahrens { 320fa9e4066Sahrens struct mnttab search = { 0 }, entry; 321*67331909Sdougm char *mntpt = NULL; 322fa9e4066Sahrens 323fa9e4066Sahrens /* check to see if need to unmount the filesystem */ 3243bb79becSeschrock search.mnt_special = zhp->zfs_name; 32596dedd18Snd search.mnt_fstype = MNTTYPE_ZFS; 32699653d4eSeschrock rewind(zhp->zfs_hdl->libzfs_mnttab); 327fa9e4066Sahrens if (mountpoint != NULL || ((zfs_get_type(zhp) == ZFS_TYPE_FILESYSTEM) && 32899653d4eSeschrock getmntany(zhp->zfs_hdl->libzfs_mnttab, &entry, &search) == 0)) { 329fa9e4066Sahrens 330*67331909Sdougm /* 331*67331909Sdougm * mountpoint may have come from a call to 332*67331909Sdougm * getmnt/getmntany if it isn't NULL. If it is NULL, 333*67331909Sdougm * we know it comes from getmntany which can then get 334*67331909Sdougm * overwritten later. We strdup it to play it safe. 335*67331909Sdougm */ 336fa9e4066Sahrens if (mountpoint == NULL) 337*67331909Sdougm mntpt = zfs_strdup(zhp->zfs_hdl, entry.mnt_mountp); 338*67331909Sdougm else 339*67331909Sdougm mntpt = zfs_strdup(zhp->zfs_hdl, mountpoint); 340fa9e4066Sahrens 341fa9e4066Sahrens /* 3423bb79becSeschrock * Unshare and unmount the filesystem 343fa9e4066Sahrens */ 344*67331909Sdougm if (zfs_unshare_nfs(zhp, mntpt) != 0 || 345*67331909Sdougm unmount_one(zhp->zfs_hdl, mntpt, flags) != 0) { 346*67331909Sdougm free(mntpt); 347fa9e4066Sahrens return (-1); 348*67331909Sdougm } 349*67331909Sdougm free(mntpt); 350fa9e4066Sahrens } 351fa9e4066Sahrens 352fa9e4066Sahrens return (0); 353fa9e4066Sahrens } 354fa9e4066Sahrens 355fa9e4066Sahrens /* 356fa9e4066Sahrens * Unmount this filesystem and any children inheriting the mountpoint property. 357fa9e4066Sahrens * To do this, just act like we're changing the mountpoint property, but don't 358fa9e4066Sahrens * remount the filesystems afterwards. 359fa9e4066Sahrens */ 360fa9e4066Sahrens int 361fa9e4066Sahrens zfs_unmountall(zfs_handle_t *zhp, int flags) 362fa9e4066Sahrens { 363fa9e4066Sahrens prop_changelist_t *clp; 364fa9e4066Sahrens int ret; 365fa9e4066Sahrens 366fa9e4066Sahrens clp = changelist_gather(zhp, ZFS_PROP_MOUNTPOINT, flags); 367fa9e4066Sahrens if (clp == NULL) 368fa9e4066Sahrens return (-1); 369fa9e4066Sahrens 370fa9e4066Sahrens ret = changelist_prefix(clp); 371fa9e4066Sahrens changelist_free(clp); 372fa9e4066Sahrens 373fa9e4066Sahrens return (ret); 374fa9e4066Sahrens } 375fa9e4066Sahrens 376f3861e1aSahl boolean_t 377f3861e1aSahl zfs_is_shared(zfs_handle_t *zhp) 378f3861e1aSahl { 379f3861e1aSahl if (ZFS_IS_VOLUME(zhp)) 380f3861e1aSahl return (zfs_is_shared_iscsi(zhp)); 381f3861e1aSahl 382f3861e1aSahl return (zfs_is_shared_nfs(zhp, NULL)); 383f3861e1aSahl } 384f3861e1aSahl 385f3861e1aSahl int 386f3861e1aSahl zfs_share(zfs_handle_t *zhp) 387f3861e1aSahl { 388f3861e1aSahl if (ZFS_IS_VOLUME(zhp)) 389f3861e1aSahl return (zfs_share_iscsi(zhp)); 390f3861e1aSahl 391f3861e1aSahl return (zfs_share_nfs(zhp)); 392f3861e1aSahl } 393f3861e1aSahl 394f3861e1aSahl int 395f3861e1aSahl zfs_unshare(zfs_handle_t *zhp) 396f3861e1aSahl { 397f3861e1aSahl if (ZFS_IS_VOLUME(zhp)) 398f3861e1aSahl return (zfs_unshare_iscsi(zhp)); 399f3861e1aSahl 400f3861e1aSahl return (zfs_unshare_nfs(zhp, NULL)); 401f3861e1aSahl } 402f3861e1aSahl 403fa9e4066Sahrens /* 404fa9e4066Sahrens * Check to see if the filesystem is currently shared. 405fa9e4066Sahrens */ 40699653d4eSeschrock boolean_t 407f3861e1aSahl zfs_is_shared_nfs(zfs_handle_t *zhp, char **where) 408fa9e4066Sahrens { 409fa9e4066Sahrens char *mountpoint; 410fa9e4066Sahrens 411fa9e4066Sahrens if (!zfs_is_mounted(zhp, &mountpoint)) 41299653d4eSeschrock return (B_FALSE); 413fa9e4066Sahrens 41499653d4eSeschrock if (is_shared(zhp->zfs_hdl, mountpoint)) { 415fa9e4066Sahrens if (where != NULL) 416fa9e4066Sahrens *where = mountpoint; 417fa9e4066Sahrens else 418fa9e4066Sahrens free(mountpoint); 41999653d4eSeschrock return (B_TRUE); 420fa9e4066Sahrens } else { 421fa9e4066Sahrens free(mountpoint); 42299653d4eSeschrock return (B_FALSE); 423fa9e4066Sahrens } 424fa9e4066Sahrens } 425fa9e4066Sahrens 426*67331909Sdougm /* 427*67331909Sdougm * Make sure things will work if libshare isn't installed by using 428*67331909Sdougm * wrapper functions that check to see that the pointers to functions 429*67331909Sdougm * initialized in _zfs_init_libshare() are actually present. 430*67331909Sdougm */ 431*67331909Sdougm 432*67331909Sdougm static sa_handle_t (*_sa_init)(int); 433*67331909Sdougm static void (*_sa_fini)(sa_handle_t); 434*67331909Sdougm static sa_share_t (*_sa_find_share)(sa_handle_t, char *); 435*67331909Sdougm static int (*_sa_enable_share)(sa_share_t, char *); 436*67331909Sdougm static int (*_sa_disable_share)(sa_share_t, char *); 437*67331909Sdougm static char *(*_sa_errorstr)(int); 438*67331909Sdougm static int (*_sa_parse_legacy_options)(sa_group_t, char *, char *); 439*67331909Sdougm 440*67331909Sdougm /* 441*67331909Sdougm * _zfs_init_libshare() 442*67331909Sdougm * 443*67331909Sdougm * Find the libshare.so.1 entry points that we use here and save the 444*67331909Sdougm * values to be used later. This is triggered by the runtime loader. 445*67331909Sdougm * Make sure the correct ISA version is loaded. 446*67331909Sdougm */ 447*67331909Sdougm 448*67331909Sdougm #pragma init(_zfs_init_libshare) 449*67331909Sdougm static void 450*67331909Sdougm _zfs_init_libshare(void) 451*67331909Sdougm { 452*67331909Sdougm void *libshare; 453*67331909Sdougm char path[MAXPATHLEN]; 454*67331909Sdougm char isa[MAXISALEN]; 455*67331909Sdougm 456*67331909Sdougm #if defined(_LP64) 457*67331909Sdougm if (sysinfo(SI_ARCHITECTURE_64, isa, MAXISALEN) == -1) 458*67331909Sdougm isa[0] = '\0'; 459*67331909Sdougm #else 460*67331909Sdougm isa[0] = '\0'; 461*67331909Sdougm #endif 462*67331909Sdougm (void) snprintf(path, MAXPATHLEN, 463*67331909Sdougm "/usr/lib/%s/libshare.so.1", isa); 464*67331909Sdougm 465*67331909Sdougm if ((libshare = dlopen(path, RTLD_LAZY | RTLD_GLOBAL)) != NULL) { 466*67331909Sdougm _sa_init = (sa_handle_t (*)(int))dlsym(libshare, "sa_init"); 467*67331909Sdougm _sa_fini = (void (*)(sa_handle_t))dlsym(libshare, "sa_fini"); 468*67331909Sdougm _sa_find_share = (sa_share_t (*)(sa_handle_t, char *)) 469*67331909Sdougm dlsym(libshare, "sa_find_share"); 470*67331909Sdougm _sa_enable_share = (int (*)(sa_share_t, char *))dlsym(libshare, 471*67331909Sdougm "sa_enable_share"); 472*67331909Sdougm _sa_disable_share = (int (*)(sa_share_t, char *))dlsym(libshare, 473*67331909Sdougm "sa_disable_share"); 474*67331909Sdougm _sa_errorstr = (char *(*)(int))dlsym(libshare, "sa_errorstr"); 475*67331909Sdougm _sa_parse_legacy_options = (int (*)(sa_group_t, char *, char *)) 476*67331909Sdougm dlsym(libshare, "sa_parse_legacy_options"); 477*67331909Sdougm } 478*67331909Sdougm } 479*67331909Sdougm 480*67331909Sdougm /* 481*67331909Sdougm * zfs_init_libshare(zhandle, service) 482*67331909Sdougm * 483*67331909Sdougm * Initialize the libshare API if it hasn't already been initialized. 484*67331909Sdougm * In all cases it returns 0 if it succeeded and an error if not. The 485*67331909Sdougm * service value is which part(s) of the API to initialize and is a 486*67331909Sdougm * direct map to the libshare sa_init(service) interface. 487*67331909Sdougm */ 488*67331909Sdougm 489*67331909Sdougm int 490*67331909Sdougm zfs_init_libshare(libzfs_handle_t *zhandle, int service) 491*67331909Sdougm { 492*67331909Sdougm int ret = SA_OK; 493*67331909Sdougm 494*67331909Sdougm if (_sa_init == NULL) { 495*67331909Sdougm ret = SA_CONFIG_ERR; 496*67331909Sdougm } 497*67331909Sdougm if (ret == SA_OK && zhandle && zhandle->libzfs_sharehdl == NULL) { 498*67331909Sdougm zhandle->libzfs_sharehdl = _sa_init(service); 499*67331909Sdougm } 500*67331909Sdougm if (ret == SA_OK && zhandle->libzfs_sharehdl == NULL) { 501*67331909Sdougm ret = SA_NO_MEMORY; 502*67331909Sdougm } 503*67331909Sdougm return (ret); 504*67331909Sdougm } 505*67331909Sdougm 506*67331909Sdougm /* 507*67331909Sdougm * zfs_uninit_libshare(zhandle) 508*67331909Sdougm * 509*67331909Sdougm * Uninitialize the libshare API if it hasn't already been 510*67331909Sdougm * uninitialized. It is OK to call multiple times. 511*67331909Sdougm */ 512*67331909Sdougm 513*67331909Sdougm void 514*67331909Sdougm zfs_uninit_libshare(libzfs_handle_t *zhandle) 515*67331909Sdougm { 516*67331909Sdougm 517*67331909Sdougm if (zhandle != NULL && zhandle->libzfs_sharehdl != NULL) { 518*67331909Sdougm if (_sa_fini != NULL) 519*67331909Sdougm _sa_fini(zhandle->libzfs_sharehdl); 520*67331909Sdougm zhandle->libzfs_sharehdl = NULL; 521*67331909Sdougm } 522*67331909Sdougm } 523*67331909Sdougm 524*67331909Sdougm /* 525*67331909Sdougm * zfs_parse_options(options, proto) 526*67331909Sdougm * 527*67331909Sdougm * Call the legacy parse interface to get the protocol specific 528*67331909Sdougm * options using the NULL arg to indicate that this is a "parse" only. 529*67331909Sdougm */ 530*67331909Sdougm 531*67331909Sdougm int 532*67331909Sdougm zfs_parse_options(char *options, char *proto) 533*67331909Sdougm { 534*67331909Sdougm int ret; 535*67331909Sdougm 536*67331909Sdougm if (_sa_parse_legacy_options != NULL) 537*67331909Sdougm ret = _sa_parse_legacy_options(NULL, options, proto); 538*67331909Sdougm else 539*67331909Sdougm ret = SA_CONFIG_ERR; 540*67331909Sdougm return (ret); 541*67331909Sdougm } 542*67331909Sdougm 543*67331909Sdougm /* 544*67331909Sdougm * zfs_sa_find_share(handle, path) 545*67331909Sdougm * 546*67331909Sdougm * wrapper around sa_find_share to find a share path in the 547*67331909Sdougm * configuration. 548*67331909Sdougm */ 549*67331909Sdougm 550*67331909Sdougm static sa_share_t 551*67331909Sdougm zfs_sa_find_share(sa_handle_t handle, char *path) 552*67331909Sdougm { 553*67331909Sdougm if (_sa_find_share != NULL) 554*67331909Sdougm return (_sa_find_share(handle, path)); 555*67331909Sdougm return (NULL); 556*67331909Sdougm } 557*67331909Sdougm 558*67331909Sdougm /* 559*67331909Sdougm * zfs_sa_enable_share(share, proto) 560*67331909Sdougm * 561*67331909Sdougm * Wrapper for sa_enable_share which enables a share for a specified 562*67331909Sdougm * protocol. 563*67331909Sdougm */ 564*67331909Sdougm 565*67331909Sdougm static int 566*67331909Sdougm zfs_sa_enable_share(sa_share_t share, char *proto) 567*67331909Sdougm { 568*67331909Sdougm if (_sa_enable_share != NULL) 569*67331909Sdougm return (_sa_enable_share(share, proto)); 570*67331909Sdougm return (SA_CONFIG_ERR); 571*67331909Sdougm } 572*67331909Sdougm 573*67331909Sdougm /* 574*67331909Sdougm * zfs_sa_disable_share(share, proto) 575*67331909Sdougm * 576*67331909Sdougm * Wrapper for sa_enable_share which disables a share for a specified 577*67331909Sdougm * protocol. 578*67331909Sdougm */ 579*67331909Sdougm 580*67331909Sdougm static int 581*67331909Sdougm zfs_sa_disable_share(sa_share_t share, char *proto) 582*67331909Sdougm { 583*67331909Sdougm if (_sa_disable_share != NULL) 584*67331909Sdougm return (_sa_disable_share(share, proto)); 585*67331909Sdougm return (SA_CONFIG_ERR); 586*67331909Sdougm } 587*67331909Sdougm 588fa9e4066Sahrens /* 589fa9e4066Sahrens * Share the given filesystem according to the options in 'sharenfs'. We rely 590*67331909Sdougm * on "libshare" to the dirty work for us. 591fa9e4066Sahrens */ 592*67331909Sdougm 593fa9e4066Sahrens int 594f3861e1aSahl zfs_share_nfs(zfs_handle_t *zhp) 595fa9e4066Sahrens { 596fa9e4066Sahrens char mountpoint[ZFS_MAXPROPLEN]; 597fa9e4066Sahrens char shareopts[ZFS_MAXPROPLEN]; 59899653d4eSeschrock libzfs_handle_t *hdl = zhp->zfs_hdl; 599*67331909Sdougm sa_share_t share; 600*67331909Sdougm int ret; 601fa9e4066Sahrens 602e9dbad6fSeschrock if (!zfs_is_mountable(zhp, mountpoint, sizeof (mountpoint), NULL)) 603fa9e4066Sahrens return (0); 604fa9e4066Sahrens 605f3861e1aSahl /* 606f3861e1aSahl * Return success if there are no share options. 607f3861e1aSahl */ 608fa9e4066Sahrens if (zfs_prop_get(zhp, ZFS_PROP_SHARENFS, shareopts, sizeof (shareopts), 60999653d4eSeschrock NULL, NULL, 0, B_FALSE) != 0 || 610fa9e4066Sahrens strcmp(shareopts, "off") == 0) 611fa9e4066Sahrens return (0); 612fa9e4066Sahrens 613fa9e4066Sahrens /* 614e9dbad6fSeschrock * If the 'zoned' property is set, then zfs_is_mountable() will have 615e9dbad6fSeschrock * already bailed out if we are in the global zone. But local 616e9dbad6fSeschrock * zones cannot be NFS servers, so we ignore it for local zones as well. 617fa9e4066Sahrens */ 618e9dbad6fSeschrock if (zfs_prop_get_int(zhp, ZFS_PROP_ZONED)) 619fa9e4066Sahrens return (0); 620fa9e4066Sahrens 621*67331909Sdougm if ((ret = zfs_init_libshare(hdl, SA_INIT_SHARE_API)) != SA_OK) { 622*67331909Sdougm (void) zfs_error_fmt(hdl, EZFS_SHARENFSFAILED, 623*67331909Sdougm dgettext(TEXT_DOMAIN, "cannot share '%s': %s"), 624*67331909Sdougm zfs_get_name(zhp), _sa_errorstr(ret)); 625*67331909Sdougm return (-1); 626*67331909Sdougm } 627*67331909Sdougm share = zfs_sa_find_share(hdl->libzfs_sharehdl, mountpoint); 628*67331909Sdougm if (share != NULL) { 629*67331909Sdougm int err; 630*67331909Sdougm err = zfs_sa_enable_share(share, "nfs"); 631*67331909Sdougm if (err != SA_OK) { 632ece3d9b3Slling (void) zfs_error_fmt(hdl, EZFS_SHARENFSFAILED, 633*67331909Sdougm dgettext(TEXT_DOMAIN, "cannot share '%s'"), 634*67331909Sdougm zfs_get_name(zhp)); 635*67331909Sdougm return (-1); 636*67331909Sdougm } 637*67331909Sdougm } else { 638*67331909Sdougm (void) zfs_error_fmt(hdl, EZFS_SHARENFSFAILED, 639*67331909Sdougm dgettext(TEXT_DOMAIN, "cannot share '%s'"), 640*67331909Sdougm zfs_get_name(zhp)); 641fa9e4066Sahrens return (-1); 642fa9e4066Sahrens } 643fa9e4066Sahrens 644fa9e4066Sahrens return (0); 645fa9e4066Sahrens } 646fa9e4066Sahrens 6473bb79becSeschrock /* 6483bb79becSeschrock * Unshare a filesystem by mountpoint. 6493bb79becSeschrock */ 6503bb79becSeschrock static int 6513bb79becSeschrock unshare_one(libzfs_handle_t *hdl, const char *name, const char *mountpoint) 6523bb79becSeschrock { 653*67331909Sdougm sa_share_t share; 654*67331909Sdougm int err; 655*67331909Sdougm char *mntpt; 6563bb79becSeschrock 6573bb79becSeschrock /* 658*67331909Sdougm * Mountpoint could get trashed if libshare calls getmntany 659*67331909Sdougm * which id does during API initialization, so strdup the 660*67331909Sdougm * value. 6613bb79becSeschrock */ 662*67331909Sdougm mntpt = zfs_strdup(hdl, mountpoint); 6633bb79becSeschrock 664*67331909Sdougm /* make sure libshare initialized */ 665*67331909Sdougm if ((err = zfs_init_libshare(hdl, SA_INIT_SHARE_API)) != SA_OK) { 666*67331909Sdougm free(mntpt); /* don't need the copy anymore */ 667*67331909Sdougm return (zfs_error_fmt(hdl, EZFS_SHARENFSFAILED, 668*67331909Sdougm dgettext(TEXT_DOMAIN, 669*67331909Sdougm "cannot unshare '%s': %s"), 670*67331909Sdougm name, _sa_errorstr(err))); 671*67331909Sdougm } 6723bb79becSeschrock 673*67331909Sdougm share = zfs_sa_find_share(hdl->libzfs_sharehdl, mntpt); 674*67331909Sdougm free(mntpt); /* don't need the copy anymore */ 6753bb79becSeschrock 676*67331909Sdougm if (share != NULL) { 677*67331909Sdougm err = zfs_sa_disable_share(share, "nfs"); 678*67331909Sdougm if (err != SA_OK) { 679*67331909Sdougm return (zfs_error_fmt(hdl, EZFS_UNSHARENFSFAILED, 680*67331909Sdougm dgettext(TEXT_DOMAIN, 681*67331909Sdougm "cannot unshare '%s': %s"), name, 682*67331909Sdougm _sa_errorstr(err))); 683*67331909Sdougm } 684*67331909Sdougm } else { 685ece3d9b3Slling return (zfs_error_fmt(hdl, EZFS_UNSHARENFSFAILED, 686*67331909Sdougm dgettext(TEXT_DOMAIN, 687*67331909Sdougm "cannot unshare '%s': not found"), name)); 6883bb79becSeschrock } 6893bb79becSeschrock return (0); 6903bb79becSeschrock } 6913bb79becSeschrock 692fa9e4066Sahrens /* 693fa9e4066Sahrens * Unshare the given filesystem. 694fa9e4066Sahrens */ 695fa9e4066Sahrens int 696f3861e1aSahl zfs_unshare_nfs(zfs_handle_t *zhp, const char *mountpoint) 697fa9e4066Sahrens { 698fa9e4066Sahrens struct mnttab search = { 0 }, entry; 699*67331909Sdougm char *mntpt = NULL; 700fa9e4066Sahrens 701fa9e4066Sahrens /* check to see if need to unmount the filesystem */ 702fa9e4066Sahrens search.mnt_special = (char *)zfs_get_name(zhp); 70396dedd18Snd search.mnt_fstype = MNTTYPE_ZFS; 70499653d4eSeschrock rewind(zhp->zfs_hdl->libzfs_mnttab); 705*67331909Sdougm if (mountpoint != NULL) { 706*67331909Sdougm mountpoint = mntpt = zfs_strdup(zhp->zfs_hdl, mountpoint); 707*67331909Sdougm } 708fa9e4066Sahrens if (mountpoint != NULL || ((zfs_get_type(zhp) == ZFS_TYPE_FILESYSTEM) && 70999653d4eSeschrock getmntany(zhp->zfs_hdl->libzfs_mnttab, &entry, &search) == 0)) { 710fa9e4066Sahrens 711fa9e4066Sahrens if (mountpoint == NULL) 712fa9e4066Sahrens mountpoint = entry.mnt_mountp; 713fa9e4066Sahrens 7143bb79becSeschrock if (is_shared(zhp->zfs_hdl, mountpoint) && 715*67331909Sdougm unshare_one(zhp->zfs_hdl, zhp->zfs_name, mountpoint) != 0) { 716*67331909Sdougm if (mntpt != NULL) 717*67331909Sdougm free(mntpt); 7183bb79becSeschrock return (-1); 719*67331909Sdougm } 720fa9e4066Sahrens } 721*67331909Sdougm if (mntpt != NULL) 722*67331909Sdougm free(mntpt); 723fa9e4066Sahrens 724fa9e4066Sahrens return (0); 725fa9e4066Sahrens } 726fa9e4066Sahrens 727fa9e4066Sahrens /* 728f3861e1aSahl * Same as zfs_unmountall(), but for NFS unshares. 729fa9e4066Sahrens */ 730fa9e4066Sahrens int 731f3861e1aSahl zfs_unshareall_nfs(zfs_handle_t *zhp) 732fa9e4066Sahrens { 733fa9e4066Sahrens prop_changelist_t *clp; 734fa9e4066Sahrens int ret; 735fa9e4066Sahrens 736fa9e4066Sahrens clp = changelist_gather(zhp, ZFS_PROP_SHARENFS, 0); 737fa9e4066Sahrens if (clp == NULL) 738fa9e4066Sahrens return (-1); 739fa9e4066Sahrens 740fa9e4066Sahrens ret = changelist_unshare(clp); 741fa9e4066Sahrens changelist_free(clp); 742fa9e4066Sahrens 743fa9e4066Sahrens return (ret); 744fa9e4066Sahrens } 745fa9e4066Sahrens 746fa9e4066Sahrens /* 747fa9e4066Sahrens * Remove the mountpoint associated with the current dataset, if necessary. 748fa9e4066Sahrens * We only remove the underlying directory if: 749fa9e4066Sahrens * 750fa9e4066Sahrens * - The mountpoint is not 'none' or 'legacy' 751fa9e4066Sahrens * - The mountpoint is non-empty 752fa9e4066Sahrens * - The mountpoint is the default or inherited 753fa9e4066Sahrens * - The 'zoned' property is set, or we're in a local zone 754fa9e4066Sahrens * 755fa9e4066Sahrens * Any other directories we leave alone. 756fa9e4066Sahrens */ 757fa9e4066Sahrens void 758fa9e4066Sahrens remove_mountpoint(zfs_handle_t *zhp) 759fa9e4066Sahrens { 760fa9e4066Sahrens char mountpoint[ZFS_MAXPROPLEN]; 761e9dbad6fSeschrock zfs_source_t source; 762fa9e4066Sahrens 763e9dbad6fSeschrock if (!zfs_is_mountable(zhp, mountpoint, sizeof (mountpoint), 764e9dbad6fSeschrock &source)) 765fa9e4066Sahrens return; 766fa9e4066Sahrens 767e9dbad6fSeschrock if (source == ZFS_SRC_DEFAULT || 768e9dbad6fSeschrock source == ZFS_SRC_INHERITED) { 769fa9e4066Sahrens /* 770fa9e4066Sahrens * Try to remove the directory, silently ignoring any errors. 771fa9e4066Sahrens * The filesystem may have since been removed or moved around, 772e9dbad6fSeschrock * and this error isn't really useful to the administrator in 773e9dbad6fSeschrock * any way. 774fa9e4066Sahrens */ 775fa9e4066Sahrens (void) rmdir(mountpoint); 776fa9e4066Sahrens } 777fa9e4066Sahrens } 7783bb79becSeschrock 779f3861e1aSahl boolean_t 780f3861e1aSahl zfs_is_shared_iscsi(zfs_handle_t *zhp) 781f3861e1aSahl { 782d8d59944Sahl return (iscsitgt_zfs_is_shared != NULL && 783d8d59944Sahl iscsitgt_zfs_is_shared(zhp->zfs_name) != 0); 784f3861e1aSahl } 785f3861e1aSahl 786f3861e1aSahl int 787f3861e1aSahl zfs_share_iscsi(zfs_handle_t *zhp) 788f3861e1aSahl { 789f3861e1aSahl char shareopts[ZFS_MAXPROPLEN]; 790f3861e1aSahl const char *dataset = zhp->zfs_name; 791f3861e1aSahl libzfs_handle_t *hdl = zhp->zfs_hdl; 792f3861e1aSahl 793f3861e1aSahl /* 794f3861e1aSahl * Return success if there are no share options. 795f3861e1aSahl */ 796f3861e1aSahl if (zfs_prop_get(zhp, ZFS_PROP_SHAREISCSI, shareopts, 797f3861e1aSahl sizeof (shareopts), NULL, NULL, 0, B_FALSE) != 0 || 798f3861e1aSahl strcmp(shareopts, "off") == 0) 799f3861e1aSahl return (0); 800f3861e1aSahl 801d8d59944Sahl if (iscsitgt_zfs_share == NULL || iscsitgt_zfs_share(dataset) != 0) 802ece3d9b3Slling return (zfs_error_fmt(hdl, EZFS_SHAREISCSIFAILED, 803f3861e1aSahl dgettext(TEXT_DOMAIN, "cannot share '%s'"), dataset)); 804f3861e1aSahl 805f3861e1aSahl return (0); 806f3861e1aSahl } 807f3861e1aSahl 808f3861e1aSahl int 809f3861e1aSahl zfs_unshare_iscsi(zfs_handle_t *zhp) 810f3861e1aSahl { 811f3861e1aSahl const char *dataset = zfs_get_name(zhp); 812f3861e1aSahl libzfs_handle_t *hdl = zhp->zfs_hdl; 813f3861e1aSahl 81411d2789dSgw /* 81511d2789dSgw * Return if the volume is not shared 81611d2789dSgw */ 81711d2789dSgw if (!zfs_is_shared_iscsi(zhp)) 81811d2789dSgw return (0); 81911d2789dSgw 820f3861e1aSahl /* 821f3861e1aSahl * If this fails with ENODEV it indicates that zvol wasn't shared so 822f3861e1aSahl * we should return success in that case. 823f3861e1aSahl */ 824d8d59944Sahl if (iscsitgt_zfs_unshare == NULL || 825d8d59944Sahl (iscsitgt_zfs_unshare(dataset) != 0 && errno != ENODEV)) 826ece3d9b3Slling return (zfs_error_fmt(hdl, EZFS_UNSHAREISCSIFAILED, 827f3861e1aSahl dgettext(TEXT_DOMAIN, "cannot unshare '%s'"), dataset)); 828f3861e1aSahl 829f3861e1aSahl return (0); 830f3861e1aSahl } 831f3861e1aSahl 8323bb79becSeschrock typedef struct mount_cbdata { 8333bb79becSeschrock zfs_handle_t **cb_datasets; 8343bb79becSeschrock int cb_used; 8353bb79becSeschrock int cb_alloc; 8363bb79becSeschrock } mount_cbdata_t; 8373bb79becSeschrock 8383bb79becSeschrock static int 8393bb79becSeschrock mount_cb(zfs_handle_t *zhp, void *data) 8403bb79becSeschrock { 8413bb79becSeschrock mount_cbdata_t *cbp = data; 8423bb79becSeschrock 843f3861e1aSahl if (!(zfs_get_type(zhp) & (ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME))) { 8443bb79becSeschrock zfs_close(zhp); 8453bb79becSeschrock return (0); 8463bb79becSeschrock } 8473bb79becSeschrock 8483bb79becSeschrock if (cbp->cb_alloc == cbp->cb_used) { 849e9dbad6fSeschrock void *ptr; 8503bb79becSeschrock 851e9dbad6fSeschrock if ((ptr = zfs_realloc(zhp->zfs_hdl, 852e9dbad6fSeschrock cbp->cb_datasets, cbp->cb_alloc * sizeof (void *), 853e9dbad6fSeschrock cbp->cb_alloc * 2 * sizeof (void *))) == NULL) 8543bb79becSeschrock return (-1); 855e9dbad6fSeschrock cbp->cb_datasets = ptr; 8563bb79becSeschrock 857e9dbad6fSeschrock cbp->cb_alloc *= 2; 8583bb79becSeschrock } 8593bb79becSeschrock 8603bb79becSeschrock cbp->cb_datasets[cbp->cb_used++] = zhp; 861f3861e1aSahl 862f3861e1aSahl return (zfs_iter_children(zhp, mount_cb, cbp)); 8633bb79becSeschrock } 8643bb79becSeschrock 8653bb79becSeschrock static int 866f3861e1aSahl dataset_cmp(const void *a, const void *b) 8673bb79becSeschrock { 8683bb79becSeschrock zfs_handle_t **za = (zfs_handle_t **)a; 8693bb79becSeschrock zfs_handle_t **zb = (zfs_handle_t **)b; 8703bb79becSeschrock char mounta[MAXPATHLEN]; 8713bb79becSeschrock char mountb[MAXPATHLEN]; 872f3861e1aSahl boolean_t gota, gotb; 873f3861e1aSahl 874f3861e1aSahl if ((gota = (zfs_get_type(*za) == ZFS_TYPE_FILESYSTEM)) != 0) 875f3861e1aSahl verify(zfs_prop_get(*za, ZFS_PROP_MOUNTPOINT, mounta, 876f3861e1aSahl sizeof (mounta), NULL, NULL, 0, B_FALSE) == 0); 877f3861e1aSahl if ((gotb = (zfs_get_type(*zb) == ZFS_TYPE_FILESYSTEM)) != 0) 878f3861e1aSahl verify(zfs_prop_get(*zb, ZFS_PROP_MOUNTPOINT, mountb, 879f3861e1aSahl sizeof (mountb), NULL, NULL, 0, B_FALSE) == 0); 880f3861e1aSahl 881f3861e1aSahl if (gota && gotb) 882f3861e1aSahl return (strcmp(mounta, mountb)); 8833bb79becSeschrock 884f3861e1aSahl if (gota) 885f3861e1aSahl return (-1); 886f3861e1aSahl if (gotb) 887f3861e1aSahl return (1); 8883bb79becSeschrock 889f3861e1aSahl return (strcmp(zfs_get_name(a), zfs_get_name(b))); 8903bb79becSeschrock } 8913bb79becSeschrock 892f3861e1aSahl /* 893f3861e1aSahl * Mount and share all datasets within the given pool. This assumes that no 894f3861e1aSahl * datasets within the pool are currently mounted. Because users can create 895f3861e1aSahl * complicated nested hierarchies of mountpoints, we first gather all the 896f3861e1aSahl * datasets and mountpoints within the pool, and sort them by mountpoint. Once 897f3861e1aSahl * we have the list of all filesystems, we iterate over them in order and mount 898f3861e1aSahl * and/or share each one. 899f3861e1aSahl */ 900f3861e1aSahl #pragma weak zpool_mount_datasets = zpool_enable_datasets 9013bb79becSeschrock int 902f3861e1aSahl zpool_enable_datasets(zpool_handle_t *zhp, const char *mntopts, int flags) 9033bb79becSeschrock { 9043bb79becSeschrock mount_cbdata_t cb = { 0 }; 9053bb79becSeschrock libzfs_handle_t *hdl = zhp->zpool_hdl; 9063bb79becSeschrock zfs_handle_t *zfsp; 9073bb79becSeschrock int i, ret = -1; 908*67331909Sdougm int *good; 9093bb79becSeschrock 9103bb79becSeschrock /* 9113bb79becSeschrock * Gather all datasets within the pool. 9123bb79becSeschrock */ 9133bb79becSeschrock if ((cb.cb_datasets = zfs_alloc(hdl, 4 * sizeof (void *))) == NULL) 9143bb79becSeschrock return (-1); 9153bb79becSeschrock cb.cb_alloc = 4; 9163bb79becSeschrock 9173bb79becSeschrock if ((zfsp = zfs_open(hdl, zhp->zpool_name, ZFS_TYPE_ANY)) == NULL) 9183bb79becSeschrock goto out; 9193bb79becSeschrock 9203bb79becSeschrock cb.cb_datasets[0] = zfsp; 9213bb79becSeschrock cb.cb_used = 1; 9223bb79becSeschrock 9233bb79becSeschrock if (zfs_iter_children(zfsp, mount_cb, &cb) != 0) 9243bb79becSeschrock goto out; 9253bb79becSeschrock 9263bb79becSeschrock /* 9273bb79becSeschrock * Sort the datasets by mountpoint. 9283bb79becSeschrock */ 929f3861e1aSahl qsort(cb.cb_datasets, cb.cb_used, sizeof (void *), dataset_cmp); 9303bb79becSeschrock 9313bb79becSeschrock /* 932*67331909Sdougm * And mount all the datasets, keeping track of which ones 933*67331909Sdougm * succeeded or failed. By using zfs_alloc(), the good pointer 934*67331909Sdougm * will always be non-NULL. 9353bb79becSeschrock */ 936*67331909Sdougm good = zfs_alloc(zhp->zpool_hdl, cb.cb_used * sizeof (int)); 9373bb79becSeschrock ret = 0; 9383bb79becSeschrock for (i = 0; i < cb.cb_used; i++) { 939*67331909Sdougm if (zfs_mount(cb.cb_datasets[i], mntopts, flags) != 0) { 9403bb79becSeschrock ret = -1; 941*67331909Sdougm } else { 942*67331909Sdougm good[i] = 1; 943*67331909Sdougm } 9443bb79becSeschrock } 945*67331909Sdougm /* 946*67331909Sdougm * Then share all the ones that need to be shared. This needs 947*67331909Sdougm * to be a separate pass in order to avoid excessive reloading 948*67331909Sdougm * of the configuration. Good should never be NULL since 949*67331909Sdougm * zfs_alloc is supposed to exit if memory isn't available. 950*67331909Sdougm */ 951*67331909Sdougm zfs_uninit_libshare(hdl); 952*67331909Sdougm for (i = 0; i < cb.cb_used; i++) { 953*67331909Sdougm if (good[i] && zfs_share(cb.cb_datasets[i]) != 0) 954*67331909Sdougm ret = -1; 955*67331909Sdougm } 956*67331909Sdougm 957*67331909Sdougm free(good); 9583bb79becSeschrock 9593bb79becSeschrock out: 9603bb79becSeschrock for (i = 0; i < cb.cb_used; i++) 9613bb79becSeschrock zfs_close(cb.cb_datasets[i]); 9623bb79becSeschrock free(cb.cb_datasets); 9633bb79becSeschrock 9643bb79becSeschrock return (ret); 9653bb79becSeschrock } 9663bb79becSeschrock 967f3861e1aSahl 968f3861e1aSahl static int 969f3861e1aSahl zvol_cb(const char *dataset, void *data) 970f3861e1aSahl { 971f3861e1aSahl libzfs_handle_t *hdl = data; 972f3861e1aSahl zfs_handle_t *zhp; 973f3861e1aSahl 974f3861e1aSahl /* 975f3861e1aSahl * Ignore snapshots and ignore failures from non-existant datasets. 976f3861e1aSahl */ 977f3861e1aSahl if (strchr(dataset, '@') != NULL || 978f3861e1aSahl (zhp = zfs_open(hdl, dataset, ZFS_TYPE_VOLUME)) == NULL) 979f3861e1aSahl return (0); 980f3861e1aSahl 981f3861e1aSahl (void) zfs_unshare_iscsi(zhp); 982f3861e1aSahl 983f3861e1aSahl zfs_close(zhp); 984f3861e1aSahl 985f3861e1aSahl return (0); 986f3861e1aSahl } 987f3861e1aSahl 9883bb79becSeschrock static int 9893bb79becSeschrock mountpoint_compare(const void *a, const void *b) 9903bb79becSeschrock { 9913bb79becSeschrock const char *mounta = *((char **)a); 9923bb79becSeschrock const char *mountb = *((char **)b); 9933bb79becSeschrock 9943bb79becSeschrock return (strcmp(mountb, mounta)); 9953bb79becSeschrock } 9963bb79becSeschrock 997f3861e1aSahl /* 998f3861e1aSahl * Unshare and unmount all datasets within the given pool. We don't want to 999f3861e1aSahl * rely on traversing the DSL to discover the filesystems within the pool, 1000f3861e1aSahl * because this may be expensive (if not all of them are mounted), and can fail 1001f3861e1aSahl * arbitrarily (on I/O error, for example). Instead, we walk /etc/mnttab and 1002f3861e1aSahl * gather all the filesystems that are currently mounted. 1003f3861e1aSahl */ 1004f3861e1aSahl #pragma weak zpool_unmount_datasets = zpool_disable_datasets 10053bb79becSeschrock int 1006f3861e1aSahl zpool_disable_datasets(zpool_handle_t *zhp, boolean_t force) 10073bb79becSeschrock { 10083bb79becSeschrock int used, alloc; 10093bb79becSeschrock struct mnttab entry; 10103bb79becSeschrock size_t namelen; 10113bb79becSeschrock char **mountpoints = NULL; 10123bb79becSeschrock zfs_handle_t **datasets = NULL; 10133bb79becSeschrock libzfs_handle_t *hdl = zhp->zpool_hdl; 10143bb79becSeschrock int i; 10153bb79becSeschrock int ret = -1; 10163bb79becSeschrock int flags = (force ? MS_FORCE : 0); 10173bb79becSeschrock 1018f3861e1aSahl /* 1019f3861e1aSahl * First unshare all zvols. 1020f3861e1aSahl */ 1021f3861e1aSahl if (zpool_iter_zvol(zhp, zvol_cb, hdl) != 0) 1022f3861e1aSahl return (-1); 1023f3861e1aSahl 10243bb79becSeschrock namelen = strlen(zhp->zpool_name); 10253bb79becSeschrock 10263bb79becSeschrock rewind(hdl->libzfs_mnttab); 10273bb79becSeschrock used = alloc = 0; 10283bb79becSeschrock while (getmntent(hdl->libzfs_mnttab, &entry) == 0) { 10293bb79becSeschrock /* 10303bb79becSeschrock * Ignore non-ZFS entries. 10313bb79becSeschrock */ 10323bb79becSeschrock if (entry.mnt_fstype == NULL || 10333bb79becSeschrock strcmp(entry.mnt_fstype, MNTTYPE_ZFS) != 0) 10343bb79becSeschrock continue; 10353bb79becSeschrock 10363bb79becSeschrock /* 10373bb79becSeschrock * Ignore filesystems not within this pool. 10383bb79becSeschrock */ 10393bb79becSeschrock if (entry.mnt_mountp == NULL || 10403bb79becSeschrock strncmp(entry.mnt_special, zhp->zpool_name, namelen) != 0 || 10413bb79becSeschrock (entry.mnt_special[namelen] != '/' && 10423bb79becSeschrock entry.mnt_special[namelen] != '\0')) 10433bb79becSeschrock continue; 10443bb79becSeschrock 10453bb79becSeschrock /* 10463bb79becSeschrock * At this point we've found a filesystem within our pool. Add 10473bb79becSeschrock * it to our growing list. 10483bb79becSeschrock */ 10493bb79becSeschrock if (used == alloc) { 10503bb79becSeschrock if (alloc == 0) { 10513bb79becSeschrock if ((mountpoints = zfs_alloc(hdl, 10523bb79becSeschrock 8 * sizeof (void *))) == NULL) 10533bb79becSeschrock goto out; 10543bb79becSeschrock 10553bb79becSeschrock if ((datasets = zfs_alloc(hdl, 10563bb79becSeschrock 8 * sizeof (void *))) == NULL) 10573bb79becSeschrock goto out; 10583bb79becSeschrock 10593bb79becSeschrock alloc = 8; 10603bb79becSeschrock } else { 1061e9dbad6fSeschrock void *ptr; 10623bb79becSeschrock 1063e9dbad6fSeschrock if ((ptr = zfs_realloc(hdl, mountpoints, 1064e9dbad6fSeschrock alloc * sizeof (void *), 10653bb79becSeschrock alloc * 2 * sizeof (void *))) == NULL) 10663bb79becSeschrock goto out; 1067e9dbad6fSeschrock mountpoints = ptr; 10683bb79becSeschrock 1069e9dbad6fSeschrock if ((ptr = zfs_realloc(hdl, datasets, 1070e9dbad6fSeschrock alloc * sizeof (void *), 10713bb79becSeschrock alloc * 2 * sizeof (void *))) == NULL) 10723bb79becSeschrock goto out; 1073e9dbad6fSeschrock datasets = ptr; 10743bb79becSeschrock 10753bb79becSeschrock alloc *= 2; 10763bb79becSeschrock } 10773bb79becSeschrock } 10783bb79becSeschrock 10793bb79becSeschrock if ((mountpoints[used] = zfs_strdup(hdl, 10803bb79becSeschrock entry.mnt_mountp)) == NULL) 10813bb79becSeschrock goto out; 10823bb79becSeschrock 10833bb79becSeschrock /* 10843bb79becSeschrock * This is allowed to fail, in case there is some I/O error. It 10853bb79becSeschrock * is only used to determine if we need to remove the underlying 10863bb79becSeschrock * mountpoint, so failure is not fatal. 10873bb79becSeschrock */ 10883bb79becSeschrock datasets[used] = make_dataset_handle(hdl, entry.mnt_special); 10893bb79becSeschrock 10903bb79becSeschrock used++; 10913bb79becSeschrock } 10923bb79becSeschrock 10933bb79becSeschrock /* 10943bb79becSeschrock * At this point, we have the entire list of filesystems, so sort it by 10953bb79becSeschrock * mountpoint. 10963bb79becSeschrock */ 10973bb79becSeschrock qsort(mountpoints, used, sizeof (char *), mountpoint_compare); 10983bb79becSeschrock 10993bb79becSeschrock /* 11003bb79becSeschrock * Walk through and first unshare everything. 11013bb79becSeschrock */ 11023bb79becSeschrock for (i = 0; i < used; i++) { 11033bb79becSeschrock if (is_shared(hdl, mountpoints[i]) && 1104e9dbad6fSeschrock unshare_one(hdl, mountpoints[i], mountpoints[i]) != 0) 11053bb79becSeschrock goto out; 11063bb79becSeschrock } 11073bb79becSeschrock 11083bb79becSeschrock /* 11093bb79becSeschrock * Now unmount everything, removing the underlying directories as 11103bb79becSeschrock * appropriate. 11113bb79becSeschrock */ 11123bb79becSeschrock for (i = 0; i < used; i++) { 11133bb79becSeschrock if (unmount_one(hdl, mountpoints[i], flags) != 0) 11143bb79becSeschrock goto out; 1115e9dbad6fSeschrock } 11163bb79becSeschrock 1117e9dbad6fSeschrock for (i = 0; i < used; i++) { 11183bb79becSeschrock if (datasets[i]) 11193bb79becSeschrock remove_mountpoint(datasets[i]); 11203bb79becSeschrock } 11213bb79becSeschrock 11223bb79becSeschrock ret = 0; 11233bb79becSeschrock out: 11243bb79becSeschrock for (i = 0; i < used; i++) { 11253bb79becSeschrock if (datasets[i]) 11263bb79becSeschrock zfs_close(datasets[i]); 11273bb79becSeschrock free(mountpoints[i]); 11283bb79becSeschrock } 11293bb79becSeschrock free(datasets); 11303bb79becSeschrock free(mountpoints); 11313bb79becSeschrock 11323bb79becSeschrock return (ret); 11333bb79becSeschrock } 1134