1fa9e4066Sahrens /*
2fa9e4066Sahrens * CDDL HEADER START
3fa9e4066Sahrens *
4fa9e4066Sahrens * The contents of this file are subject to the terms of the
599653d4eSeschrock * Common Development and Distribution License (the "License").
699653d4eSeschrock * 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 /*
23ab003da8SJim Dunham * Copyright 2010 Sun Microsystems, Inc. All rights reserved.
24fa9e4066Sahrens * Use is subject to license terms.
252b61b799Smmusante *
262b61b799Smmusante * Portions Copyright 2007 Ramprakash Jelari
278a981c33SDaniel Hoffman * Copyright (c) 2014, 2016 by Delphix. All rights reserved.
2888f61deeSIgor Kozhukhov * Copyright 2016 Igor Kozhukhov <ikozhukhov@gmail.com>
29fa9e4066Sahrens */
30fa9e4066Sahrens
31fa9e4066Sahrens #include <libintl.h>
32fa9e4066Sahrens #include <libuutil.h>
33fa9e4066Sahrens #include <stddef.h>
34fa9e4066Sahrens #include <stdlib.h>
35fa9e4066Sahrens #include <string.h>
36fa9e4066Sahrens #include <unistd.h>
37fa9e4066Sahrens #include <zone.h>
38fa9e4066Sahrens
39fa9e4066Sahrens #include <libzfs.h>
40fa9e4066Sahrens
41fa9e4066Sahrens #include "libzfs_impl.h"
42fa9e4066Sahrens
43fa9e4066Sahrens /*
44fa9e4066Sahrens * Structure to keep track of dataset state. Before changing the 'sharenfs' or
45fa9e4066Sahrens * 'mountpoint' property, we record whether the filesystem was previously
46fa9e4066Sahrens * mounted/shared. This prior state dictates whether we remount/reshare the
47fa9e4066Sahrens * dataset after the property has been changed.
48fa9e4066Sahrens *
49fa9e4066Sahrens * The interface consists of the following sequence of functions:
50fa9e4066Sahrens *
51fa9e4066Sahrens * changelist_gather()
52fa9e4066Sahrens * changelist_prefix()
53fa9e4066Sahrens * < change property >
54fa9e4066Sahrens * changelist_postfix()
55fa9e4066Sahrens * changelist_free()
56fa9e4066Sahrens *
57fa9e4066Sahrens * Other interfaces:
58fa9e4066Sahrens *
59b12a1c38Slling * changelist_remove() - remove a node from a gathered list
60fa9e4066Sahrens * changelist_rename() - renames all datasets appropriately when doing a rename
61fa9e4066Sahrens * changelist_unshare() - unshares all the nodes in a given changelist
62fa9e4066Sahrens * changelist_haszonedchild() - check if there is any child exported to
63fa9e4066Sahrens * a local zone
64fa9e4066Sahrens */
65fa9e4066Sahrens typedef struct prop_changenode {
66fa9e4066Sahrens zfs_handle_t *cn_handle;
67fa9e4066Sahrens int cn_shared;
68fa9e4066Sahrens int cn_mounted;
69fa9e4066Sahrens int cn_zoned;
702b61b799Smmusante boolean_t cn_needpost; /* is postfix() needed? */
71fa9e4066Sahrens uu_list_node_t cn_listnode;
72fa9e4066Sahrens } prop_changenode_t;
73fa9e4066Sahrens
74fa9e4066Sahrens struct prop_changelist {
75fa9e4066Sahrens zfs_prop_t cl_prop;
76fa9e4066Sahrens zfs_prop_t cl_realprop;
77da6c28aaSamw zfs_prop_t cl_shareprop; /* used with sharenfs/sharesmb */
78fa9e4066Sahrens uu_list_pool_t *cl_pool;
79fa9e4066Sahrens uu_list_t *cl_list;
8099653d4eSeschrock boolean_t cl_waslegacy;
8199653d4eSeschrock boolean_t cl_allchildren;
8299653d4eSeschrock boolean_t cl_alldependents;
830069fd67STim Haley int cl_mflags; /* Mount flags */
840069fd67STim Haley int cl_gflags; /* Gather request flags */
8599653d4eSeschrock boolean_t cl_haszonedchild;
863bb79becSeschrock boolean_t cl_sorted;
87fa9e4066Sahrens };
88fa9e4066Sahrens
89fa9e4066Sahrens /*
90fa9e4066Sahrens * If the property is 'mountpoint', go through and unmount filesystems as
91fa9e4066Sahrens * necessary. We don't do the same for 'sharenfs', because we can just re-share
92d5b4fe4dSdougm * with different options without interrupting service. We do handle 'sharesmb'
93d5b4fe4dSdougm * since there may be old resource names that need to be removed.
94fa9e4066Sahrens */
95fa9e4066Sahrens int
changelist_prefix(prop_changelist_t * clp)96fa9e4066Sahrens changelist_prefix(prop_changelist_t *clp)
97fa9e4066Sahrens {
98fa9e4066Sahrens prop_changenode_t *cn;
99fa9e4066Sahrens int ret = 0;
100fa9e4066Sahrens
101d5b4fe4dSdougm if (clp->cl_prop != ZFS_PROP_MOUNTPOINT &&
102d5b4fe4dSdougm clp->cl_prop != ZFS_PROP_SHARESMB)
103fa9e4066Sahrens return (0);
104fa9e4066Sahrens
105fa9e4066Sahrens for (cn = uu_list_first(clp->cl_list); cn != NULL;
106fa9e4066Sahrens cn = uu_list_next(clp->cl_list, cn)) {
107cc4231e5Smmusante
108cc4231e5Smmusante /* if a previous loop failed, set the remaining to false */
109cc4231e5Smmusante if (ret == -1) {
110cc4231e5Smmusante cn->cn_needpost = B_FALSE;
111cc4231e5Smmusante continue;
112cc4231e5Smmusante }
113cc4231e5Smmusante
114fa9e4066Sahrens /*
115f3861e1aSahl * If we are in the global zone, but this dataset is exported
116f3861e1aSahl * to a local zone, do nothing.
117fa9e4066Sahrens */
118f3861e1aSahl if (getzoneid() == GLOBAL_ZONEID && cn->cn_zoned)
119fa9e4066Sahrens continue;
120fa9e4066Sahrens
121ab003da8SJim Dunham if (!ZFS_IS_VOLUME(cn->cn_handle)) {
122d5b4fe4dSdougm /*
123d5b4fe4dSdougm * Do the property specific processing.
124d5b4fe4dSdougm */
125d5b4fe4dSdougm switch (clp->cl_prop) {
126d5b4fe4dSdougm case ZFS_PROP_MOUNTPOINT:
127d5b4fe4dSdougm if (zfs_unmount(cn->cn_handle, NULL,
1280069fd67STim Haley clp->cl_mflags) != 0) {
129fa9e4066Sahrens ret = -1;
130cc4231e5Smmusante cn->cn_needpost = B_FALSE;
131fa9e4066Sahrens }
132d5b4fe4dSdougm break;
133d5b4fe4dSdougm case ZFS_PROP_SHARESMB:
134d5b4fe4dSdougm (void) zfs_unshare_smb(cn->cn_handle, NULL);
135d5b4fe4dSdougm break;
13688f61deeSIgor Kozhukhov
13788f61deeSIgor Kozhukhov default:
13888f61deeSIgor Kozhukhov break;
139d5b4fe4dSdougm }
140d5b4fe4dSdougm }
141e7437265Sahrens }
142fa9e4066Sahrens
1432b61b799Smmusante if (ret == -1)
1442b61b799Smmusante (void) changelist_postfix(clp);
1452b61b799Smmusante
146fa9e4066Sahrens return (ret);
147fa9e4066Sahrens }
148fa9e4066Sahrens
149fa9e4066Sahrens /*
150f3861e1aSahl * If the property is 'mountpoint' or 'sharenfs', go through and remount and/or
151fa9e4066Sahrens * reshare the filesystems as necessary. In changelist_gather() we recorded
152fa9e4066Sahrens * whether the filesystem was previously shared or mounted. The action we take
153fa9e4066Sahrens * depends on the previous state, and whether the value was previously 'legacy'.
154fa9e4066Sahrens * For non-legacy properties, we only remount/reshare the filesystem if it was
155fa9e4066Sahrens * previously mounted/shared. Otherwise, we always remount/reshare the
156fa9e4066Sahrens * filesystem.
157fa9e4066Sahrens */
158fa9e4066Sahrens int
changelist_postfix(prop_changelist_t * clp)159fa9e4066Sahrens changelist_postfix(prop_changelist_t *clp)
160fa9e4066Sahrens {
161fa9e4066Sahrens prop_changenode_t *cn;
162f3861e1aSahl char shareopts[ZFS_MAXPROPLEN];
1633d7934e1Srm160521 int errors = 0;
16467331909Sdougm libzfs_handle_t *hdl;
1658a981c33SDaniel Hoffman size_t num_datasets = 0, i;
1668a981c33SDaniel Hoffman zfs_handle_t **zhandle_arr;
1678a981c33SDaniel Hoffman sa_init_selective_arg_t sharearg;
168fa9e4066Sahrens
169fa9e4066Sahrens /*
170fa9e4066Sahrens * If we're changing the mountpoint, attempt to destroy the underlying
171fa9e4066Sahrens * mountpoint. All other datasets will have inherited from this dataset
172fa9e4066Sahrens * (in which case their mountpoints exist in the filesystem in the new
173fa9e4066Sahrens * location), or have explicit mountpoints set (in which case they won't
174fa9e4066Sahrens * be in the changelist).
175fa9e4066Sahrens */
176fa9e4066Sahrens if ((cn = uu_list_last(clp->cl_list)) == NULL)
177fa9e4066Sahrens return (0);
178fa9e4066Sahrens
179fa9e4066Sahrens if (clp->cl_prop == ZFS_PROP_MOUNTPOINT)
180fa9e4066Sahrens remove_mountpoint(cn->cn_handle);
181fa9e4066Sahrens
182fa9e4066Sahrens /*
18367331909Sdougm * It is possible that the changelist_prefix() used libshare
18467331909Sdougm * to unshare some entries. Since libshare caches data, an
18567331909Sdougm * attempt to reshare during postfix can fail unless libshare
18667331909Sdougm * is uninitialized here so that it will reinitialize later.
18767331909Sdougm */
18867331909Sdougm if (cn->cn_handle != NULL) {
18967331909Sdougm hdl = cn->cn_handle->zfs_hdl;
19067331909Sdougm assert(hdl != NULL);
19167331909Sdougm zfs_uninit_libshare(hdl);
1928a981c33SDaniel Hoffman
1938a981c33SDaniel Hoffman /*
1948a981c33SDaniel Hoffman * For efficiencies sake, we initialize libshare for only a few
1958a981c33SDaniel Hoffman * shares (the ones affected here). Future initializations in
1968a981c33SDaniel Hoffman * this process should just use the cached initialization.
1978a981c33SDaniel Hoffman */
1988a981c33SDaniel Hoffman for (cn = uu_list_last(clp->cl_list); cn != NULL;
1998a981c33SDaniel Hoffman cn = uu_list_prev(clp->cl_list, cn)) {
2008a981c33SDaniel Hoffman num_datasets++;
20167331909Sdougm }
20267331909Sdougm
2038a981c33SDaniel Hoffman zhandle_arr = zfs_alloc(hdl,
2048a981c33SDaniel Hoffman num_datasets * sizeof (zfs_handle_t *));
2058a981c33SDaniel Hoffman for (i = 0, cn = uu_list_last(clp->cl_list); cn != NULL;
2068a981c33SDaniel Hoffman cn = uu_list_prev(clp->cl_list, cn)) {
2078a981c33SDaniel Hoffman zhandle_arr[i++] = cn->cn_handle;
2088a981c33SDaniel Hoffman zfs_refresh_properties(cn->cn_handle);
2098a981c33SDaniel Hoffman }
2108a981c33SDaniel Hoffman assert(i == num_datasets);
2118a981c33SDaniel Hoffman sharearg.zhandle_arr = zhandle_arr;
2128a981c33SDaniel Hoffman sharearg.zhandle_len = num_datasets;
2138a981c33SDaniel Hoffman errors = zfs_init_libshare_arg(hdl, SA_INIT_SHARE_API_SELECTIVE,
2148a981c33SDaniel Hoffman &sharearg);
2158a981c33SDaniel Hoffman free(zhandle_arr);
2168a981c33SDaniel Hoffman }
21767331909Sdougm /*
218fa9e4066Sahrens * We walk the datasets in reverse, because we want to mount any parent
2193d7934e1Srm160521 * datasets before mounting the children. We walk all datasets even if
2203d7934e1Srm160521 * there are errors.
221fa9e4066Sahrens */
222fa9e4066Sahrens for (cn = uu_list_last(clp->cl_list); cn != NULL;
223fa9e4066Sahrens cn = uu_list_prev(clp->cl_list, cn)) {
2243a55fc6bSrm160521
2253a55fc6bSrm160521 boolean_t sharenfs;
226da6c28aaSamw boolean_t sharesmb;
227d96d4407SWilliam Gorrell boolean_t mounted;
228*eb633035STom Caputi boolean_t needs_key;
2293a55fc6bSrm160521
230fa9e4066Sahrens /*
231f3861e1aSahl * If we are in the global zone, but this dataset is exported
232f3861e1aSahl * to a local zone, do nothing.
233fa9e4066Sahrens */
234f3861e1aSahl if (getzoneid() == GLOBAL_ZONEID && cn->cn_zoned)
235fa9e4066Sahrens continue;
236fa9e4066Sahrens
237cc4231e5Smmusante /* Only do post-processing if it's required */
2382b61b799Smmusante if (!cn->cn_needpost)
2392b61b799Smmusante continue;
2402b61b799Smmusante cn->cn_needpost = B_FALSE;
2412b61b799Smmusante
242ab003da8SJim Dunham if (ZFS_IS_VOLUME(cn->cn_handle))
243fa9e4066Sahrens continue;
244fa9e4066Sahrens
2453a55fc6bSrm160521 /*
2463a55fc6bSrm160521 * Remount if previously mounted or mountpoint was legacy,
247da6c28aaSamw * or sharenfs or sharesmb property is set.
2483a55fc6bSrm160521 */
2493a55fc6bSrm160521 sharenfs = ((zfs_prop_get(cn->cn_handle, ZFS_PROP_SHARENFS,
2503a55fc6bSrm160521 shareopts, sizeof (shareopts), NULL, NULL, 0,
2513a55fc6bSrm160521 B_FALSE) == 0) && (strcmp(shareopts, "off") != 0));
2523a55fc6bSrm160521
253da6c28aaSamw sharesmb = ((zfs_prop_get(cn->cn_handle, ZFS_PROP_SHARESMB,
254da6c28aaSamw shareopts, sizeof (shareopts), NULL, NULL, 0,
255da6c28aaSamw B_FALSE) == 0) && (strcmp(shareopts, "off") != 0));
256da6c28aaSamw
257*eb633035STom Caputi needs_key = (zfs_prop_get_int(cn->cn_handle,
258*eb633035STom Caputi ZFS_PROP_KEYSTATUS) == ZFS_KEYSTATUS_UNAVAILABLE);
259*eb633035STom Caputi
260d96d4407SWilliam Gorrell mounted = zfs_is_mounted(cn->cn_handle, NULL);
261d96d4407SWilliam Gorrell
262*eb633035STom Caputi if (!mounted && !needs_key && (cn->cn_mounted ||
263d96d4407SWilliam Gorrell ((sharenfs || sharesmb || clp->cl_waslegacy) &&
264d96d4407SWilliam Gorrell (zfs_prop_get_int(cn->cn_handle,
265d96d4407SWilliam Gorrell ZFS_PROP_CANMOUNT) == ZFS_CANMOUNT_ON)))) {
266d96d4407SWilliam Gorrell
267d96d4407SWilliam Gorrell if (zfs_mount(cn->cn_handle, NULL, 0) != 0)
2683d7934e1Srm160521 errors++;
269d96d4407SWilliam Gorrell else
270d96d4407SWilliam Gorrell mounted = TRUE;
271d96d4407SWilliam Gorrell }
272fa9e4066Sahrens
273fa9e4066Sahrens /*
274d96d4407SWilliam Gorrell * If the file system is mounted we always re-share even
275d96d4407SWilliam Gorrell * if the filesystem is currently shared, so that we can
276d96d4407SWilliam Gorrell * adopt any new options.
277fa9e4066Sahrens */
278d96d4407SWilliam Gorrell if (sharenfs && mounted)
2793d7934e1Srm160521 errors += zfs_share_nfs(cn->cn_handle);
2803d7934e1Srm160521 else if (cn->cn_shared || clp->cl_waslegacy)
2813d7934e1Srm160521 errors += zfs_unshare_nfs(cn->cn_handle, NULL);
282d96d4407SWilliam Gorrell if (sharesmb && mounted)
2833d7934e1Srm160521 errors += zfs_share_smb(cn->cn_handle);
2843d7934e1Srm160521 else if (cn->cn_shared || clp->cl_waslegacy)
2853d7934e1Srm160521 errors += zfs_unshare_smb(cn->cn_handle, NULL);
286fa9e4066Sahrens }
287fa9e4066Sahrens
2883d7934e1Srm160521 return (errors ? -1 : 0);
289fa9e4066Sahrens }
290fa9e4066Sahrens
291fa9e4066Sahrens /*
292b12a1c38Slling * Is this "dataset" a child of "parent"?
293b12a1c38Slling */
294d87468daSrm160521 boolean_t
isa_child_of(const char * dataset,const char * parent)29555406565Smmusante isa_child_of(const char *dataset, const char *parent)
296b12a1c38Slling {
297b12a1c38Slling int len;
298b12a1c38Slling
299b12a1c38Slling len = strlen(parent);
300b12a1c38Slling
301b12a1c38Slling if (strncmp(dataset, parent, len) == 0 &&
30255406565Smmusante (dataset[len] == '@' || dataset[len] == '/' ||
30355406565Smmusante dataset[len] == '\0'))
30499653d4eSeschrock return (B_TRUE);
305b12a1c38Slling else
30699653d4eSeschrock return (B_FALSE);
307b12a1c38Slling
308b12a1c38Slling }
309b12a1c38Slling
310b12a1c38Slling /*
311f3861e1aSahl * If we rename a filesystem, child filesystem handles are no longer valid
312f3861e1aSahl * since we identify each dataset by its name in the ZFS namespace. As a
313f3861e1aSahl * result, we have to go through and fix up all the names appropriately. We
314f3861e1aSahl * could do this automatically if libzfs kept track of all open handles, but
315f3861e1aSahl * this is a lot less work.
316fa9e4066Sahrens */
317fa9e4066Sahrens void
changelist_rename(prop_changelist_t * clp,const char * src,const char * dst)318fa9e4066Sahrens changelist_rename(prop_changelist_t *clp, const char *src, const char *dst)
319fa9e4066Sahrens {
320fa9e4066Sahrens prop_changenode_t *cn;
3219adfa60dSMatthew Ahrens char newname[ZFS_MAX_DATASET_NAME_LEN];
322fa9e4066Sahrens
323fa9e4066Sahrens for (cn = uu_list_first(clp->cl_list); cn != NULL;
324fa9e4066Sahrens cn = uu_list_next(clp->cl_list, cn)) {
325fa9e4066Sahrens /*
326b12a1c38Slling * Do not rename a clone that's not in the source hierarchy.
327b12a1c38Slling */
328b12a1c38Slling if (!isa_child_of(cn->cn_handle->zfs_name, src))
329b12a1c38Slling continue;
330b12a1c38Slling
331b12a1c38Slling /*
332fa9e4066Sahrens * Destroy the previous mountpoint if needed.
333fa9e4066Sahrens */
334fa9e4066Sahrens remove_mountpoint(cn->cn_handle);
335fa9e4066Sahrens
336fa9e4066Sahrens (void) strlcpy(newname, dst, sizeof (newname));
337fa9e4066Sahrens (void) strcat(newname, cn->cn_handle->zfs_name + strlen(src));
338fa9e4066Sahrens
339fa9e4066Sahrens (void) strlcpy(cn->cn_handle->zfs_name, newname,
340fa9e4066Sahrens sizeof (cn->cn_handle->zfs_name));
341fa9e4066Sahrens }
342fa9e4066Sahrens }
343fa9e4066Sahrens
344fa9e4066Sahrens /*
345da6c28aaSamw * Given a gathered changelist for the 'sharenfs' or 'sharesmb' property,
346da6c28aaSamw * unshare all the datasets in the list.
347fa9e4066Sahrens */
348fa9e4066Sahrens int
changelist_unshare(prop_changelist_t * clp,zfs_share_proto_t * proto)349da6c28aaSamw changelist_unshare(prop_changelist_t *clp, zfs_share_proto_t *proto)
350fa9e4066Sahrens {
351fa9e4066Sahrens prop_changenode_t *cn;
352fa9e4066Sahrens int ret = 0;
353fa9e4066Sahrens
354da6c28aaSamw if (clp->cl_prop != ZFS_PROP_SHARENFS &&
355da6c28aaSamw clp->cl_prop != ZFS_PROP_SHARESMB)
356fa9e4066Sahrens return (0);
357fa9e4066Sahrens
358fa9e4066Sahrens for (cn = uu_list_first(clp->cl_list); cn != NULL;
359fa9e4066Sahrens cn = uu_list_next(clp->cl_list, cn)) {
360da6c28aaSamw if (zfs_unshare_proto(cn->cn_handle, NULL, proto) != 0)
361fa9e4066Sahrens ret = -1;
362fa9e4066Sahrens }
363fa9e4066Sahrens
364fa9e4066Sahrens return (ret);
365fa9e4066Sahrens }
366fa9e4066Sahrens
367fa9e4066Sahrens /*
368f3861e1aSahl * Check if there is any child exported to a local zone in a given changelist.
369f3861e1aSahl * This information has already been recorded while gathering the changelist
370f3861e1aSahl * via changelist_gather().
371fa9e4066Sahrens */
372fa9e4066Sahrens int
changelist_haszonedchild(prop_changelist_t * clp)373fa9e4066Sahrens changelist_haszonedchild(prop_changelist_t *clp)
374fa9e4066Sahrens {
375fa9e4066Sahrens return (clp->cl_haszonedchild);
376fa9e4066Sahrens }
377fa9e4066Sahrens
378fa9e4066Sahrens /*
379b12a1c38Slling * Remove a node from a gathered list.
380b12a1c38Slling */
381b12a1c38Slling void
changelist_remove(prop_changelist_t * clp,const char * name)3823cb34c60Sahrens changelist_remove(prop_changelist_t *clp, const char *name)
383b12a1c38Slling {
384b12a1c38Slling prop_changenode_t *cn;
385b12a1c38Slling
386b12a1c38Slling for (cn = uu_list_first(clp->cl_list); cn != NULL;
387b12a1c38Slling cn = uu_list_next(clp->cl_list, cn)) {
388b12a1c38Slling
3893cb34c60Sahrens if (strcmp(cn->cn_handle->zfs_name, name) == 0) {
390b12a1c38Slling uu_list_remove(clp->cl_list, cn);
391b12a1c38Slling zfs_close(cn->cn_handle);
392b12a1c38Slling free(cn);
393b12a1c38Slling return;
394b12a1c38Slling }
395b12a1c38Slling }
396b12a1c38Slling }
397b12a1c38Slling
398b12a1c38Slling /*
399fa9e4066Sahrens * Release any memory associated with a changelist.
400fa9e4066Sahrens */
401fa9e4066Sahrens void
changelist_free(prop_changelist_t * clp)402fa9e4066Sahrens changelist_free(prop_changelist_t *clp)
403fa9e4066Sahrens {
404fa9e4066Sahrens prop_changenode_t *cn;
40568f944b7Seschrock void *cookie;
406fa9e4066Sahrens
40794de1d4cSeschrock if (clp->cl_list) {
40868f944b7Seschrock cookie = NULL;
40968f944b7Seschrock while ((cn = uu_list_teardown(clp->cl_list, &cookie)) != NULL) {
410fa9e4066Sahrens zfs_close(cn->cn_handle);
411fa9e4066Sahrens free(cn);
412fa9e4066Sahrens }
413fa9e4066Sahrens
41499653d4eSeschrock uu_list_destroy(clp->cl_list);
41594de1d4cSeschrock }
41694de1d4cSeschrock if (clp->cl_pool)
417fa9e4066Sahrens uu_list_pool_destroy(clp->cl_pool);
418fa9e4066Sahrens
419fa9e4066Sahrens free(clp);
420fa9e4066Sahrens }
421fa9e4066Sahrens
422fa9e4066Sahrens static int
change_one(zfs_handle_t * zhp,void * data)423fa9e4066Sahrens change_one(zfs_handle_t *zhp, void *data)
424fa9e4066Sahrens {
425fa9e4066Sahrens prop_changelist_t *clp = data;
426fa9e4066Sahrens char property[ZFS_MAXPROPLEN];
427fa9e4066Sahrens char where[64];
428fa9e4066Sahrens prop_changenode_t *cn;
429990b4856Slling zprop_source_t sourcetype;
430da6c28aaSamw zprop_source_t share_sourcetype;
431fa9e4066Sahrens
432fa9e4066Sahrens /*
433f3861e1aSahl * We only want to unmount/unshare those filesystems that may inherit
434f3861e1aSahl * from the target filesystem. If we find any filesystem with a
435f3861e1aSahl * locally set mountpoint, we ignore any children since changing the
436f3861e1aSahl * property will not affect them. If this is a rename, we iterate
437f3861e1aSahl * over all children regardless, since we need them unmounted in
438f3861e1aSahl * order to do the rename. Also, if this is a volume and we're doing
439f3861e1aSahl * a rename, then always add it to the changelist.
440fa9e4066Sahrens */
441fa9e4066Sahrens
442e9dbad6fSeschrock if (!(ZFS_IS_VOLUME(zhp) && clp->cl_realprop == ZFS_PROP_NAME) &&
443fa9e4066Sahrens zfs_prop_get(zhp, clp->cl_prop, property,
444fa9e4066Sahrens sizeof (property), &sourcetype, where, sizeof (where),
44599653d4eSeschrock B_FALSE) != 0) {
44699653d4eSeschrock zfs_close(zhp);
447fa9e4066Sahrens return (0);
44899653d4eSeschrock }
449fa9e4066Sahrens
450da6c28aaSamw /*
451da6c28aaSamw * If we are "watching" sharenfs or sharesmb
452da6c28aaSamw * then check out the companion property which is tracked
453da6c28aaSamw * in cl_shareprop
454da6c28aaSamw */
455da6c28aaSamw if (clp->cl_shareprop != ZPROP_INVAL &&
456da6c28aaSamw zfs_prop_get(zhp, clp->cl_shareprop, property,
457da6c28aaSamw sizeof (property), &share_sourcetype, where, sizeof (where),
458da6c28aaSamw B_FALSE) != 0) {
459da6c28aaSamw zfs_close(zhp);
460da6c28aaSamw return (0);
461da6c28aaSamw }
462da6c28aaSamw
463b12a1c38Slling if (clp->cl_alldependents || clp->cl_allchildren ||
464990b4856Slling sourcetype == ZPROP_SRC_DEFAULT ||
465da6c28aaSamw sourcetype == ZPROP_SRC_INHERITED ||
466da6c28aaSamw (clp->cl_shareprop != ZPROP_INVAL &&
467da6c28aaSamw (share_sourcetype == ZPROP_SRC_DEFAULT ||
468da6c28aaSamw share_sourcetype == ZPROP_SRC_INHERITED))) {
46999653d4eSeschrock if ((cn = zfs_alloc(zfs_get_handle(zhp),
47099653d4eSeschrock sizeof (prop_changenode_t))) == NULL) {
47199653d4eSeschrock zfs_close(zhp);
47299653d4eSeschrock return (-1);
47399653d4eSeschrock }
474fa9e4066Sahrens
475fa9e4066Sahrens cn->cn_handle = zhp;
4760069fd67STim Haley cn->cn_mounted = (clp->cl_gflags & CL_GATHER_MOUNT_ALWAYS) ||
4770069fd67STim Haley zfs_is_mounted(zhp, NULL);
478f3861e1aSahl cn->cn_shared = zfs_is_shared(zhp);
479fa9e4066Sahrens cn->cn_zoned = zfs_prop_get_int(zhp, ZFS_PROP_ZONED);
480cc4231e5Smmusante cn->cn_needpost = B_TRUE;
481fa9e4066Sahrens
482f3861e1aSahl /* Indicate if any child is exported to a local zone. */
483f3861e1aSahl if (getzoneid() == GLOBAL_ZONEID && cn->cn_zoned)
48499653d4eSeschrock clp->cl_haszonedchild = B_TRUE;
485fa9e4066Sahrens
486fa9e4066Sahrens uu_list_node_init(cn, &cn->cn_listnode, clp->cl_pool);
487b12a1c38Slling
4883bb79becSeschrock if (clp->cl_sorted) {
4893bb79becSeschrock uu_list_index_t idx;
4903bb79becSeschrock
4913bb79becSeschrock (void) uu_list_find(clp->cl_list, cn, NULL,
4923bb79becSeschrock &idx);
4933bb79becSeschrock uu_list_insert(clp->cl_list, cn, idx);
494b12a1c38Slling } else {
4953cc4a792SWilliam Gorrell /*
4963cc4a792SWilliam Gorrell * Add this child to beginning of the list. Children
4973cc4a792SWilliam Gorrell * below this one in the hierarchy will get added above
4983cc4a792SWilliam Gorrell * this one in the list. This produces a list in
4993cc4a792SWilliam Gorrell * reverse dataset name order.
5003cc4a792SWilliam Gorrell * This is necessary when the original mountpoint
5013cc4a792SWilliam Gorrell * is legacy or none.
5023cc4a792SWilliam Gorrell */
5033bb79becSeschrock ASSERT(!clp->cl_alldependents);
504fa9e4066Sahrens verify(uu_list_insert_before(clp->cl_list,
505fa9e4066Sahrens uu_list_first(clp->cl_list), cn) == 0);
506b12a1c38Slling }
5073bb79becSeschrock
5083bb79becSeschrock if (!clp->cl_alldependents)
5093bb79becSeschrock return (zfs_iter_children(zhp, change_one, data));
510fa9e4066Sahrens } else {
511fa9e4066Sahrens zfs_close(zhp);
512fa9e4066Sahrens }
513fa9e4066Sahrens
514fa9e4066Sahrens return (0);
515fa9e4066Sahrens }
516fa9e4066Sahrens
5173bb79becSeschrock /*ARGSUSED*/
5183bb79becSeschrock static int
compare_mountpoints(const void * a,const void * b,void * unused)5193bb79becSeschrock compare_mountpoints(const void *a, const void *b, void *unused)
5203bb79becSeschrock {
5213bb79becSeschrock const prop_changenode_t *ca = a;
5223bb79becSeschrock const prop_changenode_t *cb = b;
5233bb79becSeschrock
5243bb79becSeschrock char mounta[MAXPATHLEN];
5253bb79becSeschrock char mountb[MAXPATHLEN];
5263bb79becSeschrock
5273bb79becSeschrock boolean_t hasmounta, hasmountb;
5283bb79becSeschrock
5293bb79becSeschrock /*
5303bb79becSeschrock * When unsharing or unmounting filesystems, we need to do it in
5313bb79becSeschrock * mountpoint order. This allows the user to have a mountpoint
5323bb79becSeschrock * hierarchy that is different from the dataset hierarchy, and still
5333bb79becSeschrock * allow it to be changed. However, if either dataset doesn't have a
5343bb79becSeschrock * mountpoint (because it is a volume or a snapshot), we place it at the
5353bb79becSeschrock * end of the list, because it doesn't affect our change at all.
5363bb79becSeschrock */
5373bb79becSeschrock hasmounta = (zfs_prop_get(ca->cn_handle, ZFS_PROP_MOUNTPOINT, mounta,
5383bb79becSeschrock sizeof (mounta), NULL, NULL, 0, B_FALSE) == 0);
5393bb79becSeschrock hasmountb = (zfs_prop_get(cb->cn_handle, ZFS_PROP_MOUNTPOINT, mountb,
5403bb79becSeschrock sizeof (mountb), NULL, NULL, 0, B_FALSE) == 0);
5413bb79becSeschrock
5423bb79becSeschrock if (!hasmounta && hasmountb)
5433bb79becSeschrock return (-1);
5443bb79becSeschrock else if (hasmounta && !hasmountb)
5453bb79becSeschrock return (1);
5463bb79becSeschrock else if (!hasmounta && !hasmountb)
5473bb79becSeschrock return (0);
5483bb79becSeschrock else
5493bb79becSeschrock return (strcmp(mountb, mounta));
5503bb79becSeschrock }
551fa9e4066Sahrens
552fa9e4066Sahrens /*
553f3861e1aSahl * Given a ZFS handle and a property, construct a complete list of datasets
554f3861e1aSahl * that need to be modified as part of this process. For anything but the
555fa9e4066Sahrens * 'mountpoint' and 'sharenfs' properties, this just returns an empty list.
556f3861e1aSahl * Otherwise, we iterate over all children and look for any datasets that
557f3861e1aSahl * inherit the property. For each such dataset, we add it to the list and
558f3861e1aSahl * mark whether it was shared beforehand.
559fa9e4066Sahrens */
560fa9e4066Sahrens prop_changelist_t *
changelist_gather(zfs_handle_t * zhp,zfs_prop_t prop,int gather_flags,int mnt_flags)5610069fd67STim Haley changelist_gather(zfs_handle_t *zhp, zfs_prop_t prop, int gather_flags,
5620069fd67STim Haley int mnt_flags)
563fa9e4066Sahrens {
56499653d4eSeschrock prop_changelist_t *clp;
565fa9e4066Sahrens prop_changenode_t *cn;
566fa9e4066Sahrens zfs_handle_t *temp;
567fa9e4066Sahrens char property[ZFS_MAXPROPLEN];
5683bb79becSeschrock uu_compare_fn_t *compare = NULL;
5693cc4a792SWilliam Gorrell boolean_t legacy = B_FALSE;
570fa9e4066Sahrens
57199653d4eSeschrock if ((clp = zfs_alloc(zhp->zfs_hdl, sizeof (prop_changelist_t))) == NULL)
57299653d4eSeschrock return (NULL);
57399653d4eSeschrock
5743bb79becSeschrock /*
5753bb79becSeschrock * For mountpoint-related tasks, we want to sort everything by
5763bb79becSeschrock * mountpoint, so that we mount and unmount them in the appropriate
5773bb79becSeschrock * order, regardless of their position in the hierarchy.
5783bb79becSeschrock */
5793bb79becSeschrock if (prop == ZFS_PROP_NAME || prop == ZFS_PROP_ZONED ||
580da6c28aaSamw prop == ZFS_PROP_MOUNTPOINT || prop == ZFS_PROP_SHARENFS ||
581da6c28aaSamw prop == ZFS_PROP_SHARESMB) {
5823cc4a792SWilliam Gorrell
5833cc4a792SWilliam Gorrell if (zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT,
5843cc4a792SWilliam Gorrell property, sizeof (property),
5853cc4a792SWilliam Gorrell NULL, NULL, 0, B_FALSE) == 0 &&
5863cc4a792SWilliam Gorrell (strcmp(property, "legacy") == 0 ||
5873cc4a792SWilliam Gorrell strcmp(property, "none") == 0)) {
5883cc4a792SWilliam Gorrell
5893cc4a792SWilliam Gorrell legacy = B_TRUE;
5903cc4a792SWilliam Gorrell }
5913cc4a792SWilliam Gorrell if (!legacy) {
5923bb79becSeschrock compare = compare_mountpoints;
5933bb79becSeschrock clp->cl_sorted = B_TRUE;
5943bb79becSeschrock }
5953cc4a792SWilliam Gorrell }
5963bb79becSeschrock
597fa9e4066Sahrens clp->cl_pool = uu_list_pool_create("changelist_pool",
598fa9e4066Sahrens sizeof (prop_changenode_t),
599fa9e4066Sahrens offsetof(prop_changenode_t, cn_listnode),
6003bb79becSeschrock compare, 0);
60194de1d4cSeschrock if (clp->cl_pool == NULL) {
60294de1d4cSeschrock assert(uu_error() == UU_ERROR_NO_MEMORY);
60394de1d4cSeschrock (void) zfs_error(zhp->zfs_hdl, EZFS_NOMEM, "internal error");
60494de1d4cSeschrock changelist_free(clp);
60594de1d4cSeschrock return (NULL);
60694de1d4cSeschrock }
607fa9e4066Sahrens
6083bb79becSeschrock clp->cl_list = uu_list_create(clp->cl_pool, NULL,
6093bb79becSeschrock clp->cl_sorted ? UU_LIST_SORTED : 0);
6100069fd67STim Haley clp->cl_gflags = gather_flags;
6110069fd67STim Haley clp->cl_mflags = mnt_flags;
612fa9e4066Sahrens
61394de1d4cSeschrock if (clp->cl_list == NULL) {
61494de1d4cSeschrock assert(uu_error() == UU_ERROR_NO_MEMORY);
61594de1d4cSeschrock (void) zfs_error(zhp->zfs_hdl, EZFS_NOMEM, "internal error");
61694de1d4cSeschrock changelist_free(clp);
61794de1d4cSeschrock return (NULL);
61894de1d4cSeschrock }
61994de1d4cSeschrock
620fa9e4066Sahrens /*
621fa9e4066Sahrens * If this is a rename or the 'zoned' property, we pretend we're
622fa9e4066Sahrens * changing the mountpoint and flag it so we can catch all children in
623fa9e4066Sahrens * change_one().
624b12a1c38Slling *
625f3861e1aSahl * Flag cl_alldependents to catch all children plus the dependents
626f3861e1aSahl * (clones) that are not in the hierarchy.
627fa9e4066Sahrens */
628b12a1c38Slling if (prop == ZFS_PROP_NAME) {
629b12a1c38Slling clp->cl_prop = ZFS_PROP_MOUNTPOINT;
63099653d4eSeschrock clp->cl_alldependents = B_TRUE;
631b12a1c38Slling } else if (prop == ZFS_PROP_ZONED) {
632fa9e4066Sahrens clp->cl_prop = ZFS_PROP_MOUNTPOINT;
63399653d4eSeschrock clp->cl_allchildren = B_TRUE;
634e9dbad6fSeschrock } else if (prop == ZFS_PROP_CANMOUNT) {
635e9dbad6fSeschrock clp->cl_prop = ZFS_PROP_MOUNTPOINT;
636f3861e1aSahl } else if (prop == ZFS_PROP_VOLSIZE) {
637f3861e1aSahl clp->cl_prop = ZFS_PROP_MOUNTPOINT;
638fa9e4066Sahrens } else {
639fa9e4066Sahrens clp->cl_prop = prop;
640fa9e4066Sahrens }
641fa9e4066Sahrens clp->cl_realprop = prop;
642fa9e4066Sahrens
643fa9e4066Sahrens if (clp->cl_prop != ZFS_PROP_MOUNTPOINT &&
644f3861e1aSahl clp->cl_prop != ZFS_PROP_SHARENFS &&
645ab003da8SJim Dunham clp->cl_prop != ZFS_PROP_SHARESMB)
646fa9e4066Sahrens return (clp);
647fa9e4066Sahrens
648da6c28aaSamw /*
649da6c28aaSamw * If watching SHARENFS or SHARESMB then
650da6c28aaSamw * also watch its companion property.
651da6c28aaSamw */
652da6c28aaSamw if (clp->cl_prop == ZFS_PROP_SHARENFS)
653da6c28aaSamw clp->cl_shareprop = ZFS_PROP_SHARESMB;
654da6c28aaSamw else if (clp->cl_prop == ZFS_PROP_SHARESMB)
655da6c28aaSamw clp->cl_shareprop = ZFS_PROP_SHARENFS;
656da6c28aaSamw
657b12a1c38Slling if (clp->cl_alldependents) {
6583bb79becSeschrock if (zfs_iter_dependents(zhp, B_TRUE, change_one, clp) != 0) {
659b12a1c38Slling changelist_free(clp);
660b12a1c38Slling return (NULL);
661b12a1c38Slling }
662b12a1c38Slling } else if (zfs_iter_children(zhp, change_one, clp) != 0) {
663fa9e4066Sahrens changelist_free(clp);
664fa9e4066Sahrens return (NULL);
665fa9e4066Sahrens }
666fa9e4066Sahrens
667fa9e4066Sahrens /*
668fa9e4066Sahrens * We have to re-open ourselves because we auto-close all the handles
669fa9e4066Sahrens * and can't tell the difference.
670fa9e4066Sahrens */
67199653d4eSeschrock if ((temp = zfs_open(zhp->zfs_hdl, zfs_get_name(zhp),
672990b4856Slling ZFS_TYPE_DATASET)) == NULL) {
67399653d4eSeschrock changelist_free(clp);
674fa9e4066Sahrens return (NULL);
675fa9e4066Sahrens }
676fa9e4066Sahrens
677fa9e4066Sahrens /*
678fa9e4066Sahrens * Always add ourself to the list. We add ourselves to the end so that
679fa9e4066Sahrens * we're the last to be unmounted.
680fa9e4066Sahrens */
68199653d4eSeschrock if ((cn = zfs_alloc(zhp->zfs_hdl,
68299653d4eSeschrock sizeof (prop_changenode_t))) == NULL) {
68399653d4eSeschrock zfs_close(temp);
68499653d4eSeschrock changelist_free(clp);
68599653d4eSeschrock return (NULL);
68699653d4eSeschrock }
68799653d4eSeschrock
688fa9e4066Sahrens cn->cn_handle = temp;
6890069fd67STim Haley cn->cn_mounted = (clp->cl_gflags & CL_GATHER_MOUNT_ALWAYS) ||
6900069fd67STim Haley zfs_is_mounted(temp, NULL);
691f3861e1aSahl cn->cn_shared = zfs_is_shared(temp);
692fa9e4066Sahrens cn->cn_zoned = zfs_prop_get_int(zhp, ZFS_PROP_ZONED);
693cc4231e5Smmusante cn->cn_needpost = B_TRUE;
694fa9e4066Sahrens
695fa9e4066Sahrens uu_list_node_init(cn, &cn->cn_listnode, clp->cl_pool);
6963bb79becSeschrock if (clp->cl_sorted) {
6973bb79becSeschrock uu_list_index_t idx;
6983bb79becSeschrock (void) uu_list_find(clp->cl_list, cn, NULL, &idx);
6993bb79becSeschrock uu_list_insert(clp->cl_list, cn, idx);
7003bb79becSeschrock } else {
7013cc4a792SWilliam Gorrell /*
7023cc4a792SWilliam Gorrell * Add the target dataset to the end of the list.
7033cc4a792SWilliam Gorrell * The list is not really unsorted. The list will be
7043cc4a792SWilliam Gorrell * in reverse dataset name order. This is necessary
7053cc4a792SWilliam Gorrell * when the original mountpoint is legacy or none.
7063cc4a792SWilliam Gorrell */
707fa9e4066Sahrens verify(uu_list_insert_after(clp->cl_list,
708fa9e4066Sahrens uu_list_last(clp->cl_list), cn) == 0);
7093bb79becSeschrock }
710fa9e4066Sahrens
711fa9e4066Sahrens /*
7123a55fc6bSrm160521 * If the mountpoint property was previously 'legacy', or 'none',
7133a55fc6bSrm160521 * record it as the behavior of changelist_postfix() will be different.
714fa9e4066Sahrens */
7153cc4a792SWilliam Gorrell if ((clp->cl_prop == ZFS_PROP_MOUNTPOINT) && legacy) {
716a227b7f4Shs24103 /*
717a227b7f4Shs24103 * do not automatically mount ex-legacy datasets if
718a227b7f4Shs24103 * we specifically set canmount to noauto
719a227b7f4Shs24103 */
720a227b7f4Shs24103 if (zfs_prop_get_int(zhp, ZFS_PROP_CANMOUNT) !=
721a227b7f4Shs24103 ZFS_CANMOUNT_NOAUTO)
72299653d4eSeschrock clp->cl_waslegacy = B_TRUE;
723a227b7f4Shs24103 }
724fa9e4066Sahrens
725fa9e4066Sahrens return (clp);
726fa9e4066Sahrens }
727