1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
24 */
25 /*
26 * Copyright 2013 Nexenta Systems, Inc. All rights reserved.
27 */
28
29 /*
30 * System includes
31 */
32 #include <assert.h>
33 #include <errno.h>
34 #include <libgen.h>
35 #include <libintl.h>
36 #include <libnvpair.h>
37 #include <libzfs.h>
38 #include <stdio.h>
39 #include <stdlib.h>
40 #include <string.h>
41 #include <sys/mntent.h>
42 #include <sys/mnttab.h>
43 #include <sys/mount.h>
44 #include <sys/stat.h>
45 #include <sys/types.h>
46 #include <sys/vfstab.h>
47 #include <sys/zone.h>
48 #include <sys/mkdev.h>
49 #include <unistd.h>
50
51 #include <libbe.h>
52 #include <libbe_priv.h>
53
54 #define BE_TMP_MNTPNT "/tmp/.be.XXXXXX"
55
56 typedef struct dir_data {
57 char *dir;
58 char *ds;
59 } dir_data_t;
60
61 /* Private function prototypes */
62 static int be_mount_callback(zfs_handle_t *, void *);
63 static int be_unmount_callback(zfs_handle_t *, void *);
64 static int be_get_legacy_fs_callback(zfs_handle_t *, void *);
65 static int fix_mountpoint(zfs_handle_t *);
66 static int fix_mountpoint_callback(zfs_handle_t *, void *);
67 static int get_mountpoint_from_vfstab(char *, const char *, char *, size_t,
68 boolean_t);
69 static int loopback_mount_shared_fs(zfs_handle_t *, be_mount_data_t *);
70 static int loopback_mount_zonepath(const char *, be_mount_data_t *);
71 static int iter_shared_fs_callback(zfs_handle_t *, void *);
72 static int zpool_shared_fs_callback(zpool_handle_t *, void *);
73 static int unmount_shared_fs(be_unmount_data_t *);
74 static int add_to_fs_list(be_fs_list_data_t *, const char *);
75 static int be_mount_root(zfs_handle_t *, char *);
76 static int be_unmount_root(zfs_handle_t *, be_unmount_data_t *);
77 static int be_mount_zones(zfs_handle_t *, be_mount_data_t *);
78 static int be_unmount_zones(be_unmount_data_t *);
79 static int be_mount_one_zone(zfs_handle_t *, be_mount_data_t *, char *, char *,
80 char *);
81 static int be_unmount_one_zone(be_unmount_data_t *, char *, char *, char *);
82 static int be_get_ds_from_dir_callback(zfs_handle_t *, void *);
83
84
85 /* ******************************************************************** */
86 /* Public Functions */
87 /* ******************************************************************** */
88
89 /*
90 * Function: be_mount
91 * Description: Mounts a BE and its subordinate datasets at a given mountpoint.
92 * Parameters:
93 * be_attrs - pointer to nvlist_t of attributes being passed in.
94 * The following attributes are used by this function:
95 *
96 * BE_ATTR_ORIG_BE_NAME *required
97 * BE_ATTR_MOUNTPOINT *required
98 * BE_ATTR_MOUNT_FLAGS *optional
99 * Return:
100 * BE_SUCCESS - Success
101 * be_errno_t - Failure
102 * Scope:
103 * Public
104 */
105 int
106 be_mount(nvlist_t *be_attrs)
107 {
108 char *be_name = NULL;
109 char *mountpoint = NULL;
110 uint16_t flags = 0;
111 int ret = BE_SUCCESS;
112
113 /* Initialize libzfs handle */
114 if (!be_zfs_init())
115 return (BE_ERR_INIT);
116
117 /* Get original BE name */
118 if (nvlist_lookup_string(be_attrs, BE_ATTR_ORIG_BE_NAME, &be_name)
119 != 0) {
120 be_print_err(gettext("be_mount: failed to lookup "
121 "BE_ATTR_ORIG_BE_NAME attribute\n"));
122 return (BE_ERR_INVAL);
123 }
124
125 /* Validate original BE name */
126 if (!be_valid_be_name(be_name)) {
127 be_print_err(gettext("be_mount: invalid BE name %s\n"),
128 be_name);
129 return (BE_ERR_INVAL);
130 }
131
132 /* Get mountpoint */
133 if (nvlist_lookup_string(be_attrs, BE_ATTR_MOUNTPOINT, &mountpoint)
134 != 0) {
135 be_print_err(gettext("be_mount: failed to lookup "
136 "BE_ATTR_MOUNTPOINT attribute\n"));
137 return (BE_ERR_INVAL);
138 }
139
140 /* Get flags */
141 if (nvlist_lookup_pairs(be_attrs, NV_FLAG_NOENTOK,
142 BE_ATTR_MOUNT_FLAGS, DATA_TYPE_UINT16, &flags, NULL) != 0) {
143 be_print_err(gettext("be_mount: failed to lookup "
144 "BE_ATTR_MOUNT_FLAGS attribute\n"));
145 return (BE_ERR_INVAL);
146 }
147
148 ret = _be_mount(be_name, &mountpoint, flags);
149
150 be_zfs_fini();
151
152 return (ret);
153 }
154
155 /*
156 * Function: be_unmount
157 * Description: Unmounts a BE and its subordinate datasets.
158 * Parameters:
159 * be_attrs - pointer to nvlist_t of attributes being passed in.
160 * The following attributes are used by this function:
161 *
162 * BE_ATTR_ORIG_BE_NAME *required
163 * BE_ATTR_UNMOUNT_FLAGS *optional
164 * Return:
165 * BE_SUCCESS - Success
166 * be_errno_t - Failure
167 * Scope:
168 * Public
169 */
170 int
171 be_unmount(nvlist_t *be_attrs)
172 {
173 char *be_name = NULL;
174 char *be_name_mnt = NULL;
175 char *ds = NULL;
176 uint16_t flags = 0;
177 int ret = BE_SUCCESS;
178
179 /* Initialize libzfs handle */
180 if (!be_zfs_init())
181 return (BE_ERR_INIT);
182
183 /* Get original BE name */
184 if (nvlist_lookup_string(be_attrs, BE_ATTR_ORIG_BE_NAME, &be_name)
185 != 0) {
186 be_print_err(gettext("be_unmount: failed to lookup "
187 "BE_ATTR_ORIG_BE_NAME attribute\n"));
188 return (BE_ERR_INVAL);
189 }
190
191 /* Check if we have mountpoint argument instead of BE name */
192 if (be_name[0] == '/') {
193 if ((ds = be_get_ds_from_dir(be_name)) != NULL) {
194 if ((be_name_mnt = strrchr(ds, '/')) != NULL) {
195 free(be_name);
196 be_name = be_name_mnt + 1;
197 }
198 } else {
199 be_print_err(gettext("be_unmount: no datasets mounted "
200 "at '%s'\n"), be_name);
201 return (BE_ERR_INVAL);
202 }
203 }
204
205 /* Validate original BE name */
206 if (!be_valid_be_name(be_name)) {
207 be_print_err(gettext("be_unmount: invalid BE name %s\n"),
208 be_name);
209 return (BE_ERR_INVAL);
210 }
211
212 /* Get unmount flags */
213 if (nvlist_lookup_pairs(be_attrs, NV_FLAG_NOENTOK,
214 BE_ATTR_UNMOUNT_FLAGS, DATA_TYPE_UINT16, &flags, NULL) != 0) {
215 be_print_err(gettext("be_unmount: failed to loookup "
216 "BE_ATTR_UNMOUNT_FLAGS attribute\n"));
217 return (BE_ERR_INVAL);
218 }
219
220 ret = _be_unmount(be_name, flags);
221
222 be_zfs_fini();
223
224 return (ret);
225 }
226
227 /* ******************************************************************** */
228 /* Semi-Private Functions */
229 /* ******************************************************************** */
230
231 /*
232 * Function: _be_mount
233 * Description: Mounts a BE. If the altroot is not provided, this function
234 * will generate a temporary mountpoint to mount the BE at. It
235 * will return this temporary mountpoint to the caller via the
236 * altroot reference pointer passed in. This returned value is
237 * allocated on heap storage and is the repsonsibility of the
238 * caller to free.
239 * Parameters:
240 * be_name - pointer to name of BE to mount.
241 * altroot - reference pointer to altroot of where to mount BE.
242 * flags - flag indicating special handling for mounting the BE
243 * Return:
244 * BE_SUCCESS - Success
245 * be_errno_t - Failure
246 * Scope:
247 * Semi-private (library wide use only)
248 */
249 int
250 _be_mount(char *be_name, char **altroot, int flags)
251 {
252 be_transaction_data_t bt = { 0 };
253 be_mount_data_t md = { 0 };
254 zfs_handle_t *zhp;
255 char obe_root_ds[MAXPATHLEN];
256 char *mp = NULL;
257 char *tmp_altroot = NULL;
258 int ret = BE_SUCCESS, err = 0;
259 uuid_t uu = { 0 };
260 boolean_t gen_tmp_altroot = B_FALSE;
261
262 if (be_name == NULL || altroot == NULL)
263 return (BE_ERR_INVAL);
264
265 /* Set be_name as obe_name in bt structure */
266 bt.obe_name = be_name;
267
268 /* Find which zpool obe_name lives in */
269 if ((err = zpool_iter(g_zfs, be_find_zpool_callback, &bt)) == 0) {
270 be_print_err(gettext("be_mount: failed to "
271 "find zpool for BE (%s)\n"), bt.obe_name);
272 return (BE_ERR_BE_NOENT);
273 } else if (err < 0) {
274 be_print_err(gettext("be_mount: zpool_iter failed: %s\n"),
275 libzfs_error_description(g_zfs));
276 return (zfs_err_to_be_err(g_zfs));
277 }
278
279 /* Generate string for obe_name's root dataset */
280 be_make_root_ds(bt.obe_zpool, bt.obe_name, obe_root_ds,
281 sizeof (obe_root_ds));
282 bt.obe_root_ds = obe_root_ds;
283
284 /* Get handle to BE's root dataset */
285 if ((zhp = zfs_open(g_zfs, bt.obe_root_ds, ZFS_TYPE_FILESYSTEM)) ==
286 NULL) {
287 be_print_err(gettext("be_mount: failed to "
288 "open BE root dataset (%s): %s\n"), bt.obe_root_ds,
289 libzfs_error_description(g_zfs));
290 return (zfs_err_to_be_err(g_zfs));
291 }
292
293 /* Make sure BE's root dataset isn't already mounted somewhere */
294 if (zfs_is_mounted(zhp, &mp)) {
295 ZFS_CLOSE(zhp);
296 be_print_err(gettext("be_mount: %s is already mounted "
297 "at %s\n"), bt.obe_name, mp != NULL ? mp : "");
298 free(mp);
299 return (BE_ERR_MOUNTED);
300 }
301
302 /*
303 * Fix this BE's mountpoint if its root dataset isn't set to
304 * either 'legacy' or '/'.
305 */
306 if ((ret = fix_mountpoint(zhp)) != BE_SUCCESS) {
307 be_print_err(gettext("be_mount: mountpoint check "
308 "failed for %s\n"), bt.obe_root_ds);
309 ZFS_CLOSE(zhp);
310 return (ret);
311 }
312
313 /*
314 * If altroot not provided, create a temporary alternate root
315 * to mount on
316 */
317 if (*altroot == NULL) {
318 if ((ret = be_make_tmp_mountpoint(&tmp_altroot))
319 != BE_SUCCESS) {
320 be_print_err(gettext("be_mount: failed to "
321 "make temporary mountpoint\n"));
322 ZFS_CLOSE(zhp);
323 return (ret);
324 }
325 gen_tmp_altroot = B_TRUE;
326 } else {
327 tmp_altroot = *altroot;
328 }
329
330 md.altroot = tmp_altroot;
331 md.shared_fs = flags & BE_MOUNT_FLAG_SHARED_FS;
332 md.shared_rw = flags & BE_MOUNT_FLAG_SHARED_RW;
333
334 /* Mount the BE's root file system */
335 if (getzoneid() == GLOBAL_ZONEID) {
336 if ((ret = be_mount_root(zhp, tmp_altroot)) != BE_SUCCESS) {
337 be_print_err(gettext("be_mount: failed to "
338 "mount BE root file system\n"));
339 if (gen_tmp_altroot)
340 free(tmp_altroot);
341 ZFS_CLOSE(zhp);
342 return (ret);
343 }
344 } else {
345 /* Legacy mount the zone root dataset */
346 if ((ret = be_mount_zone_root(zhp, &md)) != BE_SUCCESS) {
347 be_print_err(gettext("be_mount: failed to "
348 "mount BE zone root file system\n"));
349 free(md.altroot);
350 ZFS_CLOSE(zhp);
351 return (ret);
352 }
353 }
354
355 /* Iterate through BE's children filesystems */
356 if ((err = zfs_iter_filesystems(zhp, be_mount_callback,
357 tmp_altroot)) != 0) {
358 be_print_err(gettext("be_mount: failed to "
359 "mount BE (%s) on %s\n"), bt.obe_name, tmp_altroot);
360 if (gen_tmp_altroot)
361 free(tmp_altroot);
362 ZFS_CLOSE(zhp);
363 return (err);
364 }
365
366 /*
367 * Mount shared file systems if mount flag says so.
368 */
369 if (md.shared_fs) {
370 /*
371 * Mount all ZFS file systems not under the BE's root dataset
372 */
373 (void) zpool_iter(g_zfs, zpool_shared_fs_callback, &md);
374
375 /* TODO: Mount all non-ZFS file systems - Not supported yet */
376 }
377
378 /*
379 * If we're in the global zone and the global zone has a valid uuid,
380 * mount all supported non-global zones.
381 */
382 if (getzoneid() == GLOBAL_ZONEID &&
383 !(flags & BE_MOUNT_FLAG_NO_ZONES) &&
384 be_get_uuid(bt.obe_root_ds, &uu) == BE_SUCCESS) {
385 if (be_mount_zones(zhp, &md) != BE_SUCCESS) {
386 ret = BE_ERR_NO_MOUNTED_ZONE;
387 }
388 }
389
390 ZFS_CLOSE(zhp);
391
392 /*
393 * If a NULL altroot was passed in, pass the generated altroot
394 * back to the caller in altroot.
395 */
396 if (gen_tmp_altroot) {
397 if (ret == BE_SUCCESS || ret == BE_ERR_NO_MOUNTED_ZONE)
398 *altroot = tmp_altroot;
399 else
400 free(tmp_altroot);
401 }
402
403 return (ret);
404 }
405
406 /*
407 * Function: _be_unmount
408 * Description: Unmount a BE.
409 * Parameters:
410 * be_name - pointer to name of BE to unmount.
411 * flags - flags for unmounting the BE.
412 * Returns:
413 * BE_SUCCESS - Success
414 * be_errno_t - Failure
415 * Scope:
416 * Semi-private (library wide use only)
417 */
418 int
419 _be_unmount(char *be_name, int flags)
420 {
421 be_transaction_data_t bt = { 0 };
422 be_unmount_data_t ud = { 0 };
423 zfs_handle_t *zhp;
424 uuid_t uu = { 0 };
425 char obe_root_ds[MAXPATHLEN];
426 char mountpoint[MAXPATHLEN];
427 char *mp = NULL;
428 int ret = BE_SUCCESS;
429 int zret = 0;
430
431 if (be_name == NULL)
432 return (BE_ERR_INVAL);
433
434 /* Set be_name as obe_name in bt structure */
435 bt.obe_name = be_name;
436
437 /* Find which zpool obe_name lives in */
438 if ((zret = zpool_iter(g_zfs, be_find_zpool_callback, &bt)) == 0) {
439 be_print_err(gettext("be_unmount: failed to "
440 "find zpool for BE (%s)\n"), bt.obe_name);
441 return (BE_ERR_BE_NOENT);
442 } else if (zret < 0) {
443 be_print_err(gettext("be_unmount: "
444 "zpool_iter failed: %s\n"),
445 libzfs_error_description(g_zfs));
446 ret = zfs_err_to_be_err(g_zfs);
447 return (ret);
448 }
449
450 /* Generate string for obe_name's root dataset */
451 be_make_root_ds(bt.obe_zpool, bt.obe_name, obe_root_ds,
452 sizeof (obe_root_ds));
453 bt.obe_root_ds = obe_root_ds;
454
455 /* Get handle to BE's root dataset */
456 if ((zhp = zfs_open(g_zfs, bt.obe_root_ds, ZFS_TYPE_FILESYSTEM)) ==
457 NULL) {
458 be_print_err(gettext("be_unmount: failed to "
459 "open BE root dataset (%s): %s\n"), bt.obe_root_ds,
460 libzfs_error_description(g_zfs));
461 ret = zfs_err_to_be_err(g_zfs);
462 return (ret);
463 }
464
465 /* Make sure BE's root dataset is mounted somewhere */
466 if (!zfs_is_mounted(zhp, &mp)) {
467
468 be_print_err(gettext("be_unmount: "
469 "(%s) not mounted\n"), bt.obe_name);
470
471 /*
472 * BE is not mounted, fix this BE's mountpoint if its root
473 * dataset isn't set to either 'legacy' or '/'.
474 */
475 if ((ret = fix_mountpoint(zhp)) != BE_SUCCESS) {
476 be_print_err(gettext("be_unmount: mountpoint check "
477 "failed for %s\n"), bt.obe_root_ds);
478 ZFS_CLOSE(zhp);
479 return (ret);
480 }
481
482 ZFS_CLOSE(zhp);
483 return (BE_ERR_NOTMOUNTED);
484 }
485
486 /*
487 * If we didn't get a mountpoint from the zfs_is_mounted call,
488 * try and get it from its property.
489 */
490 if (mp == NULL) {
491 if (zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, mountpoint,
492 sizeof (mountpoint), NULL, NULL, 0, B_FALSE) != 0) {
493 be_print_err(gettext("be_unmount: failed to "
494 "get mountpoint of (%s)\n"), bt.obe_name);
495 ZFS_CLOSE(zhp);
496 return (BE_ERR_ZFS);
497 }
498 } else {
499 (void) strlcpy(mountpoint, mp, sizeof (mountpoint));
500 free(mp);
501 }
502
503 /* If BE mounted as current root, fail */
504 if (strcmp(mountpoint, "/") == 0) {
505 be_print_err(gettext("be_unmount: "
506 "cannot unmount currently running BE\n"));
507 ZFS_CLOSE(zhp);
508 return (BE_ERR_UMOUNT_CURR_BE);
509 }
510
511 ud.altroot = mountpoint;
512 ud.force = flags & BE_UNMOUNT_FLAG_FORCE;
513
514 /* Unmount all supported non-global zones if we're in the global zone */
515 if (getzoneid() == GLOBAL_ZONEID &&
516 be_get_uuid(bt.obe_root_ds, &uu) == BE_SUCCESS) {
517 if ((ret = be_unmount_zones(&ud)) != BE_SUCCESS) {
518 ZFS_CLOSE(zhp);
519 return (ret);
520 }
521 }
522
523 /* TODO: Unmount all non-ZFS file systems - Not supported yet */
524
525 /* Unmount all ZFS file systems not under the BE root dataset */
526 if ((ret = unmount_shared_fs(&ud)) != BE_SUCCESS) {
527 be_print_err(gettext("be_unmount: failed to "
528 "unmount shared file systems\n"));
529 ZFS_CLOSE(zhp);
530 return (ret);
531 }
532
533 /* Unmount all children datasets under the BE's root dataset */
534 if ((zret = zfs_iter_filesystems(zhp, be_unmount_callback,
535 &ud)) != 0) {
536 be_print_err(gettext("be_unmount: failed to "
537 "unmount BE (%s)\n"), bt.obe_name);
538 ZFS_CLOSE(zhp);
539 return (zret);
540 }
541
542 /* Unmount this BE's root filesystem */
543 if (getzoneid() == GLOBAL_ZONEID) {
544 if ((ret = be_unmount_root(zhp, &ud)) != BE_SUCCESS) {
545 ZFS_CLOSE(zhp);
546 return (ret);
547 }
548 } else {
549 if ((ret = be_unmount_zone_root(zhp, &ud)) != BE_SUCCESS) {
550 ZFS_CLOSE(zhp);
551 return (ret);
552 }
553 }
554
555 ZFS_CLOSE(zhp);
556
557 return (BE_SUCCESS);
558 }
559
560 /*
561 * Function: be_mount_zone_root
562 * Description: Mounts the zone root dataset for a zone.
563 * Parameters:
564 * zfs - zfs_handle_t pointer to zone root dataset
565 * md - be_mount_data_t pointer to data for zone to be mounted
566 * Returns:
567 * BE_SUCCESS - Success
568 * be_errno_t - Failure
569 * Scope:
570 * Semi-private (library wide use only)
571 */
572 int
573 be_mount_zone_root(zfs_handle_t *zhp, be_mount_data_t *md)
574 {
575 struct stat buf;
576 char mountpoint[MAXPATHLEN];
577 int err = 0;
578
579 /* Get mountpoint property of dataset */
580 if (zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, mountpoint,
581 sizeof (mountpoint), NULL, NULL, 0, B_FALSE) != 0) {
582 be_print_err(gettext("be_mount_zone_root: failed to "
583 "get mountpoint property for %s: %s\n"), zfs_get_name(zhp),
584 libzfs_error_description(g_zfs));
585 return (zfs_err_to_be_err(g_zfs));
586 }
587
588 /*
589 * Make sure zone's root dataset is set to 'legacy'. This is
590 * currently a requirement in this implementation of zones
591 * support.
592 */
593 if (strcmp(mountpoint, ZFS_MOUNTPOINT_LEGACY) != 0) {
594 be_print_err(gettext("be_mount_zone_root: "
595 "zone root dataset mountpoint is not 'legacy'\n"));
596 return (BE_ERR_ZONE_ROOT_NOT_LEGACY);
597 }
598
599 /* Create the mountpoint if it doesn't exist */
600 if (lstat(md->altroot, &buf) != 0) {
601 if (mkdirp(md->altroot, 0755) != 0) {
602 err = errno;
603 be_print_err(gettext("be_mount_zone_root: failed "
604 "to create mountpoint %s\n"), md->altroot);
605 return (errno_to_be_err(err));
606 }
607 }
608
609 /*
610 * Legacy mount the zone root dataset.
611 *
612 * As a workaround for 6176743, we mount the zone's root with the
613 * MS_OVERLAY option in case an alternate BE is mounted, and we're
614 * mounting the root for the zone from the current BE here. When an
615 * alternate BE is mounted, it ties up the zone's zoneroot directory
616 * for the current BE since the zone's zonepath is loopback mounted
617 * from the current BE.
618 *
619 * TODO: The MS_OVERLAY option needs to be removed when 6176743
620 * is fixed.
621 */
622 if (mount(zfs_get_name(zhp), md->altroot, MS_OVERLAY, MNTTYPE_ZFS,
623 NULL, 0, NULL, 0) != 0) {
624 err = errno;
625 be_print_err(gettext("be_mount_zone_root: failed to "
626 "legacy mount zone root dataset (%s) at %s\n"),
627 zfs_get_name(zhp), md->altroot);
628 return (errno_to_be_err(err));
629 }
630
631 return (BE_SUCCESS);
632 }
633
634 /*
635 * Function: be_unmount_zone_root
636 * Description: Unmounts the zone root dataset for a zone.
637 * Parameters:
638 * zhp - zfs_handle_t pointer to zone root dataset
639 * ud - be_unmount_data_t pointer to data for zone to be unmounted
640 * Returns:
641 * BE_SUCCESS - Success
642 * be_errno_t - Failure
643 * Scope:
644 * Semi-private (library wise use only)
645 */
646 int
647 be_unmount_zone_root(zfs_handle_t *zhp, be_unmount_data_t *ud)
648 {
649 char mountpoint[MAXPATHLEN];
650
651 /* Unmount the dataset */
652 if (zfs_unmount(zhp, NULL, ud->force ? MS_FORCE : 0) != 0) {
653 be_print_err(gettext("be_unmount_zone_root: failed to "
654 "unmount zone root dataset %s: %s\n"), zfs_get_name(zhp),
655 libzfs_error_description(g_zfs));
656 return (zfs_err_to_be_err(g_zfs));
657 }
658
659 /* Get the current mountpoint property for the zone root dataset */
660 if (zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, mountpoint,
661 sizeof (mountpoint), NULL, NULL, 0, B_FALSE) != 0) {
662 be_print_err(gettext("be_unmount_zone_root: failed to "
663 "get mountpoint property for zone root dataset (%s): %s\n"),
664 zfs_get_name(zhp), libzfs_error_description(g_zfs));
665 return (zfs_err_to_be_err(g_zfs));
666 }
667
668 /* If mountpoint not already set to 'legacy', set it to 'legacy' */
669 if (strcmp(mountpoint, ZFS_MOUNTPOINT_LEGACY) != 0) {
670 if (zfs_prop_set(zhp, zfs_prop_to_name(ZFS_PROP_MOUNTPOINT),
671 ZFS_MOUNTPOINT_LEGACY) != 0) {
672 be_print_err(gettext("be_unmount_zone_root: "
673 "failed to set mountpoint of zone root dataset "
674 "%s to 'legacy': %s\n"), zfs_get_name(zhp),
675 libzfs_error_description(g_zfs));
676 return (zfs_err_to_be_err(g_zfs));
677 }
678 }
679
680 return (BE_SUCCESS);
681 }
682
683 /*
684 * Function: be_get_legacy_fs
685 * Description: This function iterates through all non-shared file systems
686 * of a BE and finds the ones with a legacy mountpoint. For
687 * those file systems, it reads the BE's vfstab to get the
688 * mountpoint. If found, it adds that file system to the
689 * be_fs_list_data_t passed in.
690 *
691 * This function can be used to gather legacy mounted file systems
692 * for both global BEs and non-global zone BEs. To get data for
693 * a non-global zone BE, the zoneroot_ds and zoneroot parameters
694 * will be specified, otherwise they should be set to NULL.
695 * Parameters:
696 * be_name - global BE name from which to get legacy file
697 * system list.
698 * be_root_ds - root dataset of global BE.
699 * zoneroot_ds - root dataset of zone.
700 * zoneroot - zoneroot path of zone.
701 * fld - be_fs_list_data_t pointer.
702 * Returns:
703 * BE_SUCCESS - Success
704 * be_errno_t - Failure
705 * Scope:
706 * Semi-private (library wide use only)
707 */
708 int
709 be_get_legacy_fs(char *be_name, char *be_root_ds, char *zoneroot_ds,
710 char *zoneroot, be_fs_list_data_t *fld)
711 {
712 zfs_handle_t *zhp = NULL;
713 char mountpoint[MAXPATHLEN];
714 boolean_t mounted_here = B_FALSE;
715 boolean_t zone_mounted_here = B_FALSE;
716 int ret = BE_SUCCESS, err = 0;
717
718 if (be_name == NULL || be_root_ds == NULL || fld == NULL)
719 return (BE_ERR_INVAL);
720
721 /* Get handle to BE's root dataset */
722 if ((zhp = zfs_open(g_zfs, be_root_ds, ZFS_TYPE_FILESYSTEM))
723 == NULL) {
724 be_print_err(gettext("be_get_legacy_fs: failed to "
725 "open BE root dataset (%s): %s\n"), be_root_ds,
726 libzfs_error_description(g_zfs));
727 ret = zfs_err_to_be_err(g_zfs);
728 return (ret);
729 }
730
731 /* If BE is not already mounted, mount it. */
732 if (!zfs_is_mounted(zhp, &fld->altroot)) {
733 if ((ret = _be_mount(be_name, &fld->altroot,
734 zoneroot_ds ? BE_MOUNT_FLAG_NULL :
735 BE_MOUNT_FLAG_NO_ZONES)) != BE_SUCCESS) {
736 be_print_err(gettext("be_get_legacy_fs: "
737 "failed to mount BE %s\n"), be_name);
738 goto cleanup;
739 }
740
741 mounted_here = B_TRUE;
742 } else if (fld->altroot == NULL) {
743 be_print_err(gettext("be_get_legacy_fs: failed to "
744 "get altroot of mounted BE %s: %s\n"),
745 be_name, libzfs_error_description(g_zfs));
746 ret = zfs_err_to_be_err(g_zfs);
747 goto cleanup;
748 }
749
750 /*
751 * If a zone root dataset was passed in, we're wanting to get
752 * legacy mounted file systems for that zone, not the global
753 * BE.
754 */
755 if (zoneroot_ds != NULL) {
756 be_mount_data_t zone_md = { 0 };
757
758 /* Close off handle to global BE's root dataset */
759 ZFS_CLOSE(zhp);
760
761 /* Get handle to zone's root dataset */
762 if ((zhp = zfs_open(g_zfs, zoneroot_ds,
763 ZFS_TYPE_FILESYSTEM)) == NULL) {
764 be_print_err(gettext("be_get_legacy_fs: failed to "
765 "open zone BE root dataset (%s): %s\n"),
766 zoneroot_ds, libzfs_error_description(g_zfs));
767 ret = zfs_err_to_be_err(g_zfs);
768 goto cleanup;
769 }
770
771 /* Make sure the zone we're looking for is mounted */
772 if (!zfs_is_mounted(zhp, &zone_md.altroot)) {
773 char zone_altroot[MAXPATHLEN];
774
775 /* Generate alternate root path for zone */
776 (void) snprintf(zone_altroot, sizeof (zone_altroot),
777 "%s%s", fld->altroot, zoneroot);
778 if ((zone_md.altroot = strdup(zone_altroot)) == NULL) {
779 be_print_err(gettext("be_get_legacy_fs: "
780 "memory allocation failed\n"));
781 ret = BE_ERR_NOMEM;
782 goto cleanup;
783 }
784
785 if ((ret = be_mount_zone_root(zhp, &zone_md))
786 != BE_SUCCESS) {
787 be_print_err(gettext("be_get_legacy_fs: "
788 "failed to mount zone root %s\n"),
789 zoneroot_ds);
790 free(zone_md.altroot);
791 zone_md.altroot = NULL;
792 goto cleanup;
793 }
794 zone_mounted_here = B_TRUE;
795 }
796
797 free(fld->altroot);
798 fld->altroot = zone_md.altroot;
799 }
800
801 /*
802 * If the root dataset is in the vfstab with a mountpoint of "/",
803 * add it to the list
804 */
805 if (get_mountpoint_from_vfstab(fld->altroot, zfs_get_name(zhp),
806 mountpoint, sizeof (mountpoint), B_FALSE) == BE_SUCCESS) {
807 if (strcmp(mountpoint, "/") == 0) {
808 if (add_to_fs_list(fld, zfs_get_name(zhp))
809 != BE_SUCCESS) {
810 be_print_err(gettext("be_get_legacy_fs: "
811 "failed to add %s to fs list\n"),
812 zfs_get_name(zhp));
813 ret = BE_ERR_INVAL;
814 goto cleanup;
815 }
816 }
817 }
818
819 /* Iterate subordinate file systems looking for legacy mounts */
820 if ((ret = zfs_iter_filesystems(zhp, be_get_legacy_fs_callback,
821 fld)) != 0) {
822 be_print_err(gettext("be_get_legacy_fs: "
823 "failed to iterate %s to get legacy mounts\n"),
824 zfs_get_name(zhp));
825 }
826
827 cleanup:
828 /* If we mounted the zone BE, unmount it */
829 if (zone_mounted_here) {
830 be_unmount_data_t zone_ud = { 0 };
831
832 zone_ud.altroot = fld->altroot;
833 zone_ud.force = B_TRUE;
834 if ((err = be_unmount_zone_root(zhp, &zone_ud)) != BE_SUCCESS) {
835 be_print_err(gettext("be_get_legacy_fs: "
836 "failed to unmount zone root %s\n"),
837 zoneroot_ds);
838 if (ret == BE_SUCCESS)
839 ret = err;
840 }
841 }
842
843 /* If we mounted this BE, unmount it */
844 if (mounted_here) {
845 if ((err = _be_unmount(be_name, 0)) != BE_SUCCESS) {
846 be_print_err(gettext("be_get_legacy_fs: "
847 "failed to unmount %s\n"), be_name);
848 if (ret == BE_SUCCESS)
849 ret = err;
850 }
851 }
852
853 ZFS_CLOSE(zhp);
854
855 free(fld->altroot);
856 fld->altroot = NULL;
857
858 return (ret);
859 }
860
861 /*
862 * Function: be_free_fs_list
863 * Description: Function used to free the members of a be_fs_list_data_t
864 * structure.
865 * Parameters:
866 * fld - be_fs_list_data_t pointer to free.
867 * Returns:
868 * None
869 * Scope:
870 * Semi-private (library wide use only)
871 */
872 void
873 be_free_fs_list(be_fs_list_data_t *fld)
874 {
875 int i;
876
877 if (fld == NULL)
878 return;
879
880 free(fld->altroot);
881
882 if (fld->fs_list == NULL)
883 return;
884
885 for (i = 0; i < fld->fs_num; i++)
886 free(fld->fs_list[i]);
887
888 free(fld->fs_list);
889 }
890
891 /*
892 * Function: be_get_ds_from_dir(char *dir)
893 * Description: Given a directory path, find the underlying dataset mounted
894 * at that directory path if there is one. The returned name
895 * is allocated in heap storage, so the caller is responsible
896 * for freeing it.
897 * Parameters:
898 * dir - char pointer of directory to find.
899 * Returns:
900 * NULL - if directory is not mounted from a dataset.
901 * name of dataset mounted at dir.
902 * Scope:
903 * Semi-private (library wide use only)
904 */
905 char *
906 be_get_ds_from_dir(char *dir)
907 {
908 dir_data_t dd = { 0 };
909 char resolved_dir[MAXPATHLEN];
910
911 /* Make sure length of dir is within the max length */
912 if (dir == NULL || strlen(dir) >= MAXPATHLEN)
913 return (NULL);
914
915 /* Resolve dir in case its lofs mounted */
916 (void) strlcpy(resolved_dir, dir, sizeof (resolved_dir));
917 z_resolve_lofs(resolved_dir, sizeof (resolved_dir));
918
919 dd.dir = resolved_dir;
920
921 (void) zfs_iter_root(g_zfs, be_get_ds_from_dir_callback, &dd);
922
923 return (dd.ds);
924 }
925
926 /*
927 * Function: be_make_tmp_mountpoint
928 * Description: This function generates a random temporary mountpoint
929 * and creates that mountpoint directory. It returns the
930 * mountpoint in heap storage, so the caller is responsible
931 * for freeing it.
932 * Parameters:
933 * tmp_mp - reference to pointer of where to store generated
934 * temporary mountpoint.
935 * Returns:
936 * BE_SUCCESS - Success
937 * be_errno_t - Failure
938 * Scope:
939 * Semi-private (library wide use only)
940 */
941 int
942 be_make_tmp_mountpoint(char **tmp_mp)
943 {
944 int err = 0;
945
946 if ((*tmp_mp = (char *)calloc(1, sizeof (BE_TMP_MNTPNT) + 1)) == NULL) {
947 be_print_err(gettext("be_make_tmp_mountpoint: "
948 "malloc failed\n"));
949 return (BE_ERR_NOMEM);
950 }
951 (void) strlcpy(*tmp_mp, BE_TMP_MNTPNT, sizeof (BE_TMP_MNTPNT) + 1);
952 if (mkdtemp(*tmp_mp) == NULL) {
953 err = errno;
954 be_print_err(gettext("be_make_tmp_mountpoint: mkdtemp() failed "
955 "for %s: %s\n"), *tmp_mp, strerror(err));
956 free(*tmp_mp);
957 *tmp_mp = NULL;
958 return (errno_to_be_err(err));
959 }
960
961 return (BE_SUCCESS);
962 }
963
964 /*
965 * Function: be_mount_pool
966 * Description: This function determines if the pool's datase is mounted
967 * and if not it is used to mount the pool's dataset. The
968 * function returns the current mountpoint if we are able
969 * to mount the dataset.
970 * Parameters:
971 * zhp - handle to the pool's dataset
972 * tmp_mntpnt - The temporary mountpoint that the pool's
973 * dataset is mounted on. This is set only
974 * if the attempt to mount the dataset at it's
975 * set mountpoint fails, and we've used a
976 * temporary mount point for this dataset. It
977 * is expected that the caller will free this
978 * memory.
979 * orig_mntpnt - The original mountpoint for the pool. If a
980 * temporary mount point was needed this will
981 * be used to reset the mountpoint property to
982 * it's original mountpoint. It is expected that
983 * the caller will free this memory.
984 * pool_mounted - This flag indicates that the pool was mounted
985 * in this function.
986 * Returns:
987 * BE_SUCCESS - Success
988 * be_errno_t - Failure
989 * Scope:
990 * Semi-private (library wide use only)
991 */
992 int
993 be_mount_pool(
994 zfs_handle_t *zhp,
995 char **tmp_mntpnt,
996 char **orig_mntpnt,
997 boolean_t *pool_mounted)
998 {
999
1000 char mountpoint[MAXPATHLEN];
1001 int ret = 0;
1002
1003 *tmp_mntpnt = NULL;
1004 *orig_mntpnt = NULL;
1005 *pool_mounted = B_FALSE;
1006
1007 if (!zfs_is_mounted(zhp, NULL)) {
1008 if (zfs_mount(zhp, NULL, 0) != 0) {
1009 if (zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, mountpoint,
1010 sizeof (mountpoint), NULL, NULL, 0, B_FALSE) != 0) {
1011 be_print_err(gettext("be_mount_pool: failed to "
1012 "get mountpoint of (%s): %s\n"),
1013 zfs_get_name(zhp),
1014 libzfs_error_description(g_zfs));
1015 return (zfs_err_to_be_err(g_zfs));
1016 }
1017 if ((*orig_mntpnt = strdup(mountpoint)) == NULL) {
1018 be_print_err(gettext("be_mount_pool: memory "
1019 "allocation failed\n"));
1020 return (BE_ERR_NOMEM);
1021 }
1022 /*
1023 * attempt to mount on a temp mountpoint
1024 */
1025 if ((ret = be_make_tmp_mountpoint(tmp_mntpnt))
1026 != BE_SUCCESS) {
1027 be_print_err(gettext("be_mount_pool: failed "
1028 "to make temporary mountpoint\n"));
1029 free(*orig_mntpnt);
1030 *orig_mntpnt = NULL;
1031 return (ret);
1032 }
1033
1034 if (zfs_prop_set(zhp,
1035 zfs_prop_to_name(ZFS_PROP_MOUNTPOINT),
1036 *tmp_mntpnt) != 0) {
1037 be_print_err(gettext("be_mount_pool: failed "
1038 "to set mountpoint of pool dataset %s to "
1039 "%s: %s\n"), zfs_get_name(zhp),
1040 *orig_mntpnt,
1041 libzfs_error_description(g_zfs));
1042 free(*tmp_mntpnt);
1043 free(*orig_mntpnt);
1044 *orig_mntpnt = NULL;
1045 *tmp_mntpnt = NULL;
1046 return (zfs_err_to_be_err(g_zfs));
1047 }
1048
1049 if (zfs_mount(zhp, NULL, 0) != 0) {
1050 be_print_err(gettext("be_mount_pool: failed "
1051 "to mount dataset %s at %s: %s\n"),
1052 zfs_get_name(zhp), *tmp_mntpnt,
1053 libzfs_error_description(g_zfs));
1054 ret = zfs_err_to_be_err(g_zfs);
1055 if (zfs_prop_set(zhp,
1056 zfs_prop_to_name(ZFS_PROP_MOUNTPOINT),
1057 mountpoint) != 0) {
1058 be_print_err(gettext("be_mount_pool: "
1059 "failed to set mountpoint of pool "
1060 "dataset %s to %s: %s\n"),
1061 zfs_get_name(zhp), *tmp_mntpnt,
1062 libzfs_error_description(g_zfs));
1063 }
1064 free(*tmp_mntpnt);
1065 free(*orig_mntpnt);
1066 *orig_mntpnt = NULL;
1067 *tmp_mntpnt = NULL;
1068 return (ret);
1069 }
1070 }
1071 *pool_mounted = B_TRUE;
1072 }
1073
1074 return (BE_SUCCESS);
1075 }
1076
1077 /*
1078 * Function: be_unmount_pool
1079 * Description: This function is used to unmount the pool's dataset if we
1080 * mounted it previously using be_mount_pool().
1081 * Parameters:
1082 * zhp - handle to the pool's dataset
1083 * tmp_mntpnt - If a temprary mount point was used this will
1084 * be set. Since this was created in be_mount_pool
1085 * we will need to clean it up here.
1086 * orig_mntpnt - The original mountpoint for the pool. This is
1087 * used to set the dataset mountpoint property
1088 * back to it's original value in the case where a
1089 * temporary mountpoint was used.
1090 * Returns:
1091 * BE_SUCCESS - Success
1092 * be_errno_t - Failure
1093 * Scope:
1094 * Semi-private (library wide use only)
1095 */
1096 int
1097 be_unmount_pool(
1098 zfs_handle_t *zhp,
1099 char *tmp_mntpnt,
1100 char *orig_mntpnt)
1101 {
1102 if (zfs_unmount(zhp, NULL, 0) != 0) {
1103 be_print_err(gettext("be_unmount_pool: failed to "
1104 "unmount pool (%s): %s\n"), zfs_get_name(zhp),
1105 libzfs_error_description(g_zfs));
1106 return (zfs_err_to_be_err(g_zfs));
1107 }
1108 if (orig_mntpnt != NULL) {
1109 if (tmp_mntpnt != NULL &&
1110 strcmp(orig_mntpnt, tmp_mntpnt) != 0) {
1111 (void) rmdir(tmp_mntpnt);
1112 }
1113 if (zfs_prop_set(zhp,
1114 zfs_prop_to_name(ZFS_PROP_MOUNTPOINT),
1115 orig_mntpnt) != 0) {
1116 be_print_err(gettext("be_unmount_pool: failed "
1117 "to set the mountpoint for dataset (%s) to "
1118 "%s: %s\n"), zfs_get_name(zhp), orig_mntpnt,
1119 libzfs_error_description(g_zfs));
1120 return (zfs_err_to_be_err(g_zfs));
1121 }
1122 }
1123
1124 return (BE_SUCCESS);
1125 }
1126
1127 /* ******************************************************************** */
1128 /* Private Functions */
1129 /* ******************************************************************** */
1130
1131 /*
1132 * Function: be_mount_callback
1133 * Description: Callback function used to iterate through all of a BE's
1134 * subordinate file systems and to mount them accordingly.
1135 * Parameters:
1136 * zhp - zfs_handle_t pointer to current file system being
1137 * processed.
1138 * data - pointer to the altroot of where to mount BE.
1139 * Returns:
1140 * 0 - Success
1141 * be_errno_t - Failure
1142 * Scope:
1143 * Private
1144 */
1145 static int
1146 be_mount_callback(zfs_handle_t *zhp, void *data)
1147 {
1148 zprop_source_t sourcetype;
1149 const char *fs_name = zfs_get_name(zhp);
1150 char source[ZFS_MAXNAMELEN];
1151 char *altroot = data;
1152 char zhp_mountpoint[MAXPATHLEN];
1153 char mountpoint[MAXPATHLEN];
1154 int ret = 0;
1155
1156 /* Get dataset's mountpoint and source values */
1157 if (zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, zhp_mountpoint,
1158 sizeof (zhp_mountpoint), &sourcetype, source, sizeof (source),
1159 B_FALSE) != 0) {
1160 be_print_err(gettext("be_mount_callback: failed to "
1161 "get mountpoint and sourcetype for %s\n"),
1162 fs_name);
1163 ZFS_CLOSE(zhp);
1164 return (BE_ERR_ZFS);
1165 }
1166
1167 /*
1168 * Set this filesystem's 'canmount' property to 'noauto' just incase
1169 * it's been set 'on'. We do this so that when we change its
1170 * mountpoint zfs won't immediately try to mount it.
1171 */
1172 if (zfs_prop_set(zhp, zfs_prop_to_name(ZFS_PROP_CANMOUNT), "noauto")) {
1173 be_print_err(gettext("be_mount_callback: failed to "
1174 "set canmount to 'noauto' (%s)\n"), fs_name);
1175 ZFS_CLOSE(zhp);
1176 return (BE_ERR_ZFS);
1177 }
1178
1179 /*
1180 * If the mountpoint is none, there's nothing to do, goto next.
1181 * If the mountpoint is legacy, legacy mount it with mount(2).
1182 * If the mountpoint is inherited, its mountpoint should
1183 * already be set. If it's not, then explicitly fix-up
1184 * the mountpoint now by appending its explicitly set
1185 * mountpoint value to the BE mountpoint.
1186 */
1187 if (strcmp(zhp_mountpoint, ZFS_MOUNTPOINT_NONE) == 0) {
1188 goto next;
1189 } else if (strcmp(zhp_mountpoint, ZFS_MOUNTPOINT_LEGACY) == 0) {
1190 /*
1191 * If the mountpoint is set to 'legacy', we need to
1192 * dig into this BE's vfstab to figure out where to
1193 * mount it, and just mount it via mount(2).
1194 */
1195 if (get_mountpoint_from_vfstab(altroot, fs_name,
1196 mountpoint, sizeof (mountpoint), B_TRUE) == BE_SUCCESS) {
1197
1198 /* Legacy mount the file system */
1199 if (mount(fs_name, mountpoint, MS_DATA,
1200 MNTTYPE_ZFS, NULL, 0, NULL, 0) != 0) {
1201 be_print_err(
1202 gettext("be_mount_callback: "
1203 "failed to mount %s on %s\n"),
1204 fs_name, mountpoint);
1205 }
1206 } else {
1207 be_print_err(
1208 gettext("be_mount_callback: "
1209 "no entry for %s in vfstab, "
1210 "skipping ...\n"), fs_name);
1211 }
1212
1213 goto next;
1214
1215 } else if (sourcetype & ZPROP_SRC_INHERITED) {
1216 /*
1217 * If the mountpoint is inherited, its parent should have
1218 * already been processed so its current mountpoint value
1219 * is what its mountpoint ought to be.
1220 */
1221 (void) strlcpy(mountpoint, zhp_mountpoint, sizeof (mountpoint));
1222 } else if (sourcetype & ZPROP_SRC_LOCAL) {
1223 /*
1224 * Else process dataset with explicitly set mountpoint.
1225 */
1226 (void) snprintf(mountpoint, sizeof (mountpoint),
1227 "%s%s", altroot, zhp_mountpoint);
1228
1229 /* Set the new mountpoint for the dataset */
1230 if (zfs_prop_set(zhp,
1231 zfs_prop_to_name(ZFS_PROP_MOUNTPOINT),
1232 mountpoint)) {
1233 be_print_err(gettext("be_mount_callback: "
1234 "failed to set mountpoint for %s to "
1235 "%s\n"), fs_name, mountpoint);
1236 ZFS_CLOSE(zhp);
1237 return (BE_ERR_ZFS);
1238 }
1239 } else {
1240 be_print_err(gettext("be_mount_callback: "
1241 "mountpoint sourcetype of %s is %d, skipping ...\n"),
1242 fs_name, sourcetype);
1243
1244 goto next;
1245 }
1246
1247 /* Mount this filesystem */
1248 if (zfs_mount(zhp, NULL, 0) != 0) {
1249 be_print_err(gettext("be_mount_callback: failed to "
1250 "mount dataset %s at %s: %s\n"), fs_name, mountpoint,
1251 libzfs_error_description(g_zfs));
1252 /*
1253 * Set this filesystem's 'mountpoint' property back to what
1254 * it was
1255 */
1256 if (sourcetype & ZPROP_SRC_LOCAL &&
1257 strcmp(zhp_mountpoint, ZFS_MOUNTPOINT_LEGACY) != 0) {
1258 (void) zfs_prop_set(zhp,
1259 zfs_prop_to_name(ZFS_PROP_MOUNTPOINT),
1260 zhp_mountpoint);
1261 }
1262
1263 ZFS_CLOSE(zhp);
1264 return (BE_ERR_MOUNT);
1265 }
1266
1267 next:
1268 /* Iterate through this dataset's children and mount them */
1269 if ((ret = zfs_iter_filesystems(zhp, be_mount_callback,
1270 altroot)) != 0) {
1271 ZFS_CLOSE(zhp);
1272 return (ret);
1273 }
1274
1275
1276 ZFS_CLOSE(zhp);
1277 return (0);
1278 }
1279
1280 /*
1281 * Function: be_unmount_callback
1282 * Description: Callback function used to iterate through all of a BE's
1283 * subordinate file systems and to unmount them.
1284 * Parameters:
1285 * zhp - zfs_handle_t pointer to current file system being
1286 * processed.
1287 * data - pointer to the mountpoint of where BE is mounted.
1288 * Returns:
1289 * 0 - Success
1290 * be_errno_t - Failure
1291 * Scope:
1292 * Private
1293 */
1294 static int
1295 be_unmount_callback(zfs_handle_t *zhp, void *data)
1296 {
1297 be_unmount_data_t *ud = data;
1298 zprop_source_t sourcetype;
1299 const char *fs_name = zfs_get_name(zhp);
1300 char source[ZFS_MAXNAMELEN];
1301 char mountpoint[MAXPATHLEN];
1302 char *zhp_mountpoint;
1303 int ret = 0;
1304
1305 /* Iterate down this dataset's children first */
1306 if (zfs_iter_filesystems(zhp, be_unmount_callback, ud)) {
1307 ret = BE_ERR_UMOUNT;
1308 goto done;
1309 }
1310
1311 /* Is dataset even mounted ? */
1312 if (!zfs_is_mounted(zhp, NULL))
1313 goto done;
1314
1315 /* Unmount this file system */
1316 if (zfs_unmount(zhp, NULL, ud->force ? MS_FORCE : 0) != 0) {
1317 be_print_err(gettext("be_unmount_callback: "
1318 "failed to unmount %s: %s\n"), fs_name,
1319 libzfs_error_description(g_zfs));
1320 ret = zfs_err_to_be_err(g_zfs);
1321 goto done;
1322 }
1323
1324 /* Get dataset's current mountpoint and source value */
1325 if (zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, mountpoint,
1326 sizeof (mountpoint), &sourcetype, source, sizeof (source),
1327 B_FALSE) != 0) {
1328 be_print_err(gettext("be_unmount_callback: "
1329 "failed to get mountpoint and sourcetype for %s: %s\n"),
1330 fs_name, libzfs_error_description(g_zfs));
1331 ret = zfs_err_to_be_err(g_zfs);
1332 goto done;
1333 }
1334
1335 if (sourcetype & ZPROP_SRC_INHERITED) {
1336 /*
1337 * If the mountpoint is inherited we don't need to
1338 * do anything. When its parent gets processed
1339 * its mountpoint will be set accordingly.
1340 */
1341 goto done;
1342 } else if (sourcetype & ZPROP_SRC_LOCAL) {
1343
1344 if (strcmp(mountpoint, ZFS_MOUNTPOINT_LEGACY) == 0) {
1345 /*
1346 * If the mountpoint is set to 'legacy', its already
1347 * been unmounted (from above call to zfs_unmount), and
1348 * we don't need to do anything else with it.
1349 */
1350 goto done;
1351
1352 } else {
1353 /*
1354 * Else process dataset with explicitly set mountpoint.
1355 */
1356
1357 /*
1358 * Get this dataset's mountpoint relative to
1359 * the BE's mountpoint.
1360 */
1361 if ((strncmp(mountpoint, ud->altroot,
1362 strlen(ud->altroot)) == 0) &&
1363 (mountpoint[strlen(ud->altroot)] == '/')) {
1364
1365 zhp_mountpoint = mountpoint +
1366 strlen(ud->altroot);
1367
1368 /* Set this dataset's mountpoint value */
1369 if (zfs_prop_set(zhp,
1370 zfs_prop_to_name(ZFS_PROP_MOUNTPOINT),
1371 zhp_mountpoint)) {
1372 be_print_err(
1373 gettext("be_unmount_callback: "
1374 "failed to set mountpoint for "
1375 "%s to %s: %s\n"), fs_name,
1376 zhp_mountpoint,
1377 libzfs_error_description(g_zfs));
1378 ret = zfs_err_to_be_err(g_zfs);
1379 }
1380 } else {
1381 be_print_err(
1382 gettext("be_unmount_callback: "
1383 "%s not mounted under BE's altroot %s, "
1384 "skipping ...\n"), fs_name, ud->altroot);
1385 /*
1386 * fs_name is mounted but not under the
1387 * root for this BE.
1388 */
1389 ret = BE_ERR_INVALMOUNTPOINT;
1390 }
1391 }
1392 } else {
1393 be_print_err(gettext("be_unmount_callback: "
1394 "mountpoint sourcetype of %s is %d, skipping ...\n"),
1395 fs_name, sourcetype);
1396 ret = BE_ERR_ZFS;
1397 }
1398
1399 done:
1400 /* Set this filesystem's 'canmount' property to 'noauto' */
1401 if (zfs_prop_set(zhp, zfs_prop_to_name(ZFS_PROP_CANMOUNT), "noauto")) {
1402 be_print_err(gettext("be_unmount_callback: "
1403 "failed to set canmount to 'noauto' (%s)\n"), fs_name);
1404 if (ret == 0)
1405 ret = BE_ERR_ZFS;
1406 }
1407
1408 ZFS_CLOSE(zhp);
1409 return (ret);
1410 }
1411
1412 /*
1413 * Function: be_get_legacy_fs_callback
1414 * Description: The callback function is used to iterate through all
1415 * non-shared file systems of a BE, finding ones that have
1416 * a legacy mountpoint and an entry in the BE's vfstab.
1417 * It adds these file systems to the callback data.
1418 * Parameters:
1419 * zhp - zfs_handle_t pointer to current file system being
1420 * processed.
1421 * data - be_fs_list_data_t pointer
1422 * Returns:
1423 * 0 - Success
1424 * be_errno_t - Failure
1425 * Scope:
1426 * Private
1427 */
1428 static int
1429 be_get_legacy_fs_callback(zfs_handle_t *zhp, void *data)
1430 {
1431 be_fs_list_data_t *fld = data;
1432 const char *fs_name = zfs_get_name(zhp);
1433 char zhp_mountpoint[MAXPATHLEN];
1434 char mountpoint[MAXPATHLEN];
1435 int ret = 0;
1436
1437 /* Get this dataset's mountpoint property */
1438 if (zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, zhp_mountpoint,
1439 sizeof (zhp_mountpoint), NULL, NULL, 0, B_FALSE) != 0) {
1440 be_print_err(gettext("be_get_legacy_fs_callback: "
1441 "failed to get mountpoint for %s: %s\n"),
1442 fs_name, libzfs_error_description(g_zfs));
1443 ret = zfs_err_to_be_err(g_zfs);
1444 ZFS_CLOSE(zhp);
1445 return (ret);
1446 }
1447
1448 /*
1449 * If mountpoint is legacy, try to get its mountpoint from this BE's
1450 * vfstab. If it exists in the vfstab, add this file system to the
1451 * callback data.
1452 */
1453 if (strcmp(zhp_mountpoint, ZFS_MOUNTPOINT_LEGACY) == 0) {
1454 if (get_mountpoint_from_vfstab(fld->altroot, fs_name,
1455 mountpoint, sizeof (mountpoint), B_FALSE) != BE_SUCCESS) {
1456 be_print_err(gettext("be_get_legacy_fs_callback: "
1457 "no entry for %s in vfstab, "
1458 "skipping ...\n"), fs_name);
1459
1460 goto next;
1461 }
1462
1463 /* Record file system into the callback data. */
1464 if (add_to_fs_list(fld, zfs_get_name(zhp)) != BE_SUCCESS) {
1465 be_print_err(gettext("be_get_legacy_fs_callback: "
1466 "failed to add %s to fs list\n"), mountpoint);
1467 ZFS_CLOSE(zhp);
1468 return (BE_ERR_NOMEM);
1469 }
1470 }
1471
1472 next:
1473 /* Iterate through this dataset's children file systems */
1474 if ((ret = zfs_iter_filesystems(zhp, be_get_legacy_fs_callback,
1475 fld)) != 0) {
1476 ZFS_CLOSE(zhp);
1477 return (ret);
1478 }
1479 ZFS_CLOSE(zhp);
1480 return (0);
1481 }
1482
1483 /*
1484 * Function: add_to_fs_list
1485 * Description: Function used to add a file system to the fs_list array in
1486 * a be_fs_list_data_t structure.
1487 * Parameters:
1488 * fld - be_fs_list_data_t pointer
1489 * fs - file system to add
1490 * Returns:
1491 * BE_SUCCESS - Success
1492 * 1 - Failure
1493 * Scope:
1494 * Private
1495 */
1496 static int
1497 add_to_fs_list(be_fs_list_data_t *fld, const char *fs)
1498 {
1499 if (fld == NULL || fs == NULL)
1500 return (1);
1501
1502 if ((fld->fs_list = (char **)realloc(fld->fs_list,
1503 sizeof (char *)*(fld->fs_num + 1))) == NULL) {
1504 be_print_err(gettext("add_to_fs_list: "
1505 "memory allocation failed\n"));
1506 return (1);
1507 }
1508
1509 if ((fld->fs_list[fld->fs_num++] = strdup(fs)) == NULL) {
1510 be_print_err(gettext("add_to_fs_list: "
1511 "memory allocation failed\n"));
1512 return (1);
1513 }
1514
1515 return (BE_SUCCESS);
1516 }
1517
1518 /*
1519 * Function: zpool_shared_fs_callback
1520 * Description: Callback function used to iterate through all existing pools
1521 * to find and mount all shared filesystems. This function
1522 * processes the pool's "pool data" dataset, then uses
1523 * iter_shared_fs_callback to iterate through the pool's
1524 * datasets.
1525 * Parameters:
1526 * zlp - zpool_handle_t pointer to the current pool being
1527 * looked at.
1528 * data - be_mount_data_t pointer
1529 * Returns:
1530 * 0 - Success
1531 * be_errno_t - Failure
1532 * Scope:
1533 * Private
1534 */
1535 static int
1536 zpool_shared_fs_callback(zpool_handle_t *zlp, void *data)
1537 {
1538 be_mount_data_t *md = data;
1539 zfs_handle_t *zhp = NULL;
1540 const char *zpool = zpool_get_name(zlp);
1541 int ret = 0;
1542
1543 /*
1544 * Get handle to pool's "pool data" dataset
1545 */
1546 if ((zhp = zfs_open(g_zfs, zpool, ZFS_TYPE_FILESYSTEM)) == NULL) {
1547 be_print_err(gettext("zpool_shared_fs: "
1548 "failed to open pool dataset %s: %s\n"), zpool,
1549 libzfs_error_description(g_zfs));
1550 ret = zfs_err_to_be_err(g_zfs);
1551 zpool_close(zlp);
1552 return (ret);
1553 }
1554
1555 /* Process this pool's "pool data" dataset */
1556 (void) loopback_mount_shared_fs(zhp, md);
1557
1558 /* Interate through this pool's children */
1559 (void) zfs_iter_filesystems(zhp, iter_shared_fs_callback, md);
1560
1561 ZFS_CLOSE(zhp);
1562 zpool_close(zlp);
1563
1564 return (0);
1565 }
1566
1567 /*
1568 * Function: iter_shared_fs_callback
1569 * Description: Callback function used to iterate through a pool's datasets
1570 * to find and mount all shared filesystems. It makes sure to
1571 * find the BE container dataset of the pool, if it exists, and
1572 * does not process and iterate down that path.
1573 *
1574 * Note - This function iterates linearly down the
1575 * hierarchical dataset paths and mounts things as it goes
1576 * along. It does not make sure that something deeper down
1577 * a dataset path has an interim mountpoint for something
1578 * processed earlier.
1579 *
1580 * Parameters:
1581 * zhp - zfs_handle_t pointer to the current dataset being
1582 * processed.
1583 * data - be_mount_data_t pointer
1584 * Returns:
1585 * 0 - Success
1586 * be_errno_t - Failure
1587 * Scope:
1588 * Private
1589 */
1590 static int
1591 iter_shared_fs_callback(zfs_handle_t *zhp, void *data)
1592 {
1593 be_mount_data_t *md = data;
1594 const char *name = zfs_get_name(zhp);
1595 char container_ds[MAXPATHLEN];
1596 char tmp_name[MAXPATHLEN];
1597 char *pool;
1598
1599 /* Get the pool's name */
1600 (void) strlcpy(tmp_name, name, sizeof (tmp_name));
1601 pool = strtok(tmp_name, "/");
1602
1603 if (pool) {
1604 /* Get the name of this pool's container dataset */
1605 be_make_container_ds(pool, container_ds,
1606 sizeof (container_ds));
1607
1608 /*
1609 * If what we're processing is this pool's BE container
1610 * dataset, skip it.
1611 */
1612 if (strcmp(name, container_ds) == 0) {
1613 ZFS_CLOSE(zhp);
1614 return (0);
1615 }
1616 } else {
1617 /* Getting the pool name failed, return error */
1618 be_print_err(gettext("iter_shared_fs_callback: "
1619 "failed to get pool name from %s\n"), name);
1620 ZFS_CLOSE(zhp);
1621 return (BE_ERR_POOL_NOENT);
1622 }
1623
1624 /* Mount this shared filesystem */
1625 (void) loopback_mount_shared_fs(zhp, md);
1626
1627 /* Iterate this dataset's children file systems */
1628 (void) zfs_iter_filesystems(zhp, iter_shared_fs_callback, md);
1629 ZFS_CLOSE(zhp);
1630
1631 return (0);
1632 }
1633
1634 /*
1635 * Function: loopback_mount_shared_fs
1636 * Description: This function loopback mounts a file system into the altroot
1637 * area of the BE being mounted. Since these are shared file
1638 * systems, they are expected to be already mounted for the
1639 * current BE, and this function just loopback mounts them into
1640 * the BE mountpoint. If they are not mounted for the current
1641 * live system, they are skipped and not mounted into the BE
1642 * we're mounting.
1643 * Parameters:
1644 * zhp - zfs_handle_t pointer to the dataset to loopback mount
1645 * md - be_mount_data_t pointer
1646 * Returns:
1647 * BE_SUCCESS - Success
1648 * be_errno_t - Failure
1649 * Scope:
1650 * Private
1651 */
1652 static int
1653 loopback_mount_shared_fs(zfs_handle_t *zhp, be_mount_data_t *md)
1654 {
1655 char zhp_mountpoint[MAXPATHLEN];
1656 char mountpoint[MAXPATHLEN];
1657 char *mp = NULL;
1658 char optstr[MAX_MNTOPT_STR];
1659 int mflag = MS_OPTIONSTR;
1660 int err;
1661
1662 /*
1663 * Check if file system is currently mounted and not delegated
1664 * to a non-global zone (if we're in the global zone)
1665 */
1666 if (zfs_is_mounted(zhp, &mp) && (getzoneid() != GLOBAL_ZONEID ||
1667 !zfs_prop_get_int(zhp, ZFS_PROP_ZONED))) {
1668 /*
1669 * If we didn't get a mountpoint from the zfs_is_mounted call,
1670 * get it from the mountpoint property.
1671 */
1672 if (mp == NULL) {
1673 if (zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT,
1674 zhp_mountpoint, sizeof (zhp_mountpoint), NULL,
1675 NULL, 0, B_FALSE) != 0) {
1676 be_print_err(
1677 gettext("loopback_mount_shared_fs: "
1678 "failed to get mountpoint property\n"));
1679 return (BE_ERR_ZFS);
1680 }
1681 } else {
1682 (void) strlcpy(zhp_mountpoint, mp,
1683 sizeof (zhp_mountpoint));
1684 free(mp);
1685 }
1686
1687 (void) snprintf(mountpoint, sizeof (mountpoint), "%s%s",
1688 md->altroot, zhp_mountpoint);
1689
1690 /* Mount it read-only if read-write was not requested */
1691 if (!md->shared_rw) {
1692 mflag |= MS_RDONLY;
1693 }
1694
1695 /* Add the "nosub" option to the mount options string */
1696 (void) strlcpy(optstr, MNTOPT_NOSUB, sizeof (optstr));
1697
1698 /* Loopback mount this dataset at the altroot */
1699 if (mount(zhp_mountpoint, mountpoint, mflag, MNTTYPE_LOFS,
1700 NULL, 0, optstr, sizeof (optstr)) != 0) {
1701 err = errno;
1702 be_print_err(gettext("loopback_mount_shared_fs: "
1703 "failed to loopback mount %s at %s: %s\n"),
1704 zhp_mountpoint, mountpoint, strerror(err));
1705 return (BE_ERR_MOUNT);
1706 }
1707 }
1708
1709 return (BE_SUCCESS);
1710 }
1711
1712 /*
1713 * Function: loopback_mount_zonepath
1714 * Description: This function loopback mounts a zonepath into the altroot
1715 * area of the BE being mounted.
1716 * Parameters:
1717 * zonepath - pointer to zone path in the current BE
1718 * md - be_mount_data_t pointer
1719 * Returns:
1720 * BE_SUCCESS - Success
1721 * be_errno_t - Failure
1722 * Scope:
1723 * Private
1724 */
1725 static int
1726 loopback_mount_zonepath(const char *zonepath, be_mount_data_t *md)
1727 {
1728 FILE *fp = (FILE *)NULL;
1729 struct stat st;
1730 char *p;
1731 char *p1;
1732 char *parent_dir;
1733 struct extmnttab extmtab;
1734 dev_t dev = NODEV;
1735 char *parentmnt;
1736 char alt_parentmnt[MAXPATHLEN];
1737 struct mnttab mntref;
1738 char altzonepath[MAXPATHLEN];
1739 char optstr[MAX_MNTOPT_STR];
1740 int mflag = MS_OPTIONSTR;
1741 int ret;
1742 int err;
1743
1744 fp = fopen(MNTTAB, "r");
1745 if (fp == NULL) {
1746 err = errno;
1747 be_print_err(gettext("loopback_mount_zonepath: "
1748 "failed to open /etc/mnttab\n"));
1749 return (errno_to_be_err(err));
1750 }
1751
1752 /*
1753 * before attempting the loopback mount of zonepath under altroot,
1754 * we need to make sure that all intermediate file systems in the
1755 * zone path are also mounted under altroot
1756 */
1757
1758 /* get the parent directory for zonepath */
1759 p = strrchr(zonepath, '/');
1760 if (p != NULL && p != zonepath) {
1761 if ((parent_dir = (char *)calloc(sizeof (char),
1762 p - zonepath + 1)) == NULL) {
1763 ret = BE_ERR_NOMEM;
1764 goto done;
1765 }
1766 (void) strlcpy(parent_dir, zonepath, p - zonepath + 1);
1767 if (stat(parent_dir, &st) < 0) {
1768 ret = errno_to_be_err(errno);
1769 be_print_err(gettext("loopback_mount_zonepath: "
1770 "failed to stat %s"),
1771 parent_dir);
1772 free(parent_dir);
1773 goto done;
1774 }
1775 free(parent_dir);
1776
1777 /*
1778 * After the above stat call, st.st_dev contains ID of the
1779 * device over which parent dir resides.
1780 * Now, search mnttab and find mount point of parent dir device.
1781 */
1782
1783 resetmnttab(fp);
1784 while (getextmntent(fp, &extmtab, sizeof (extmtab)) == 0) {
1785 dev = makedev(extmtab.mnt_major, extmtab.mnt_minor);
1786 if (st.st_dev == dev && strcmp(extmtab.mnt_fstype,
1787 MNTTYPE_ZFS) == 0) {
1788 p1 = strchr(extmtab.mnt_special, '/');
1789 if (p1 == NULL || strncmp(p1 + 1,
1790 BE_CONTAINER_DS_NAME, 4) != 0 ||
1791 (*(p1 + 5) != '/' && *(p1 + 5) != '\0')) {
1792 /*
1793 * if parent dir is in a shared file
1794 * system, check whether it is already
1795 * loopback mounted under altroot or
1796 * not. It would have been mounted
1797 * already under altroot if it is in
1798 * a non-shared filesystem.
1799 */
1800 parentmnt = strdup(extmtab.mnt_mountp);
1801 (void) snprintf(alt_parentmnt,
1802 sizeof (alt_parentmnt), "%s%s",
1803 md->altroot, parentmnt);
1804 mntref.mnt_mountp = alt_parentmnt;
1805 mntref.mnt_special = parentmnt;
1806 mntref.mnt_fstype = MNTTYPE_LOFS;
1807 mntref.mnt_mntopts = NULL;
1808 mntref.mnt_time = NULL;
1809 resetmnttab(fp);
1810 if (getmntany(fp, (struct mnttab *)
1811 &extmtab, &mntref) != 0) {
1812 ret = loopback_mount_zonepath(
1813 parentmnt, md);
1814 if (ret != BE_SUCCESS) {
1815 free(parentmnt);
1816 goto done;
1817 }
1818 }
1819 free(parentmnt);
1820 }
1821 break;
1822 }
1823 }
1824 }
1825
1826
1827 if (!md->shared_rw) {
1828 mflag |= MS_RDONLY;
1829 }
1830
1831 (void) snprintf(altzonepath, sizeof (altzonepath), "%s%s",
1832 md->altroot, zonepath);
1833
1834 /* Add the "nosub" option to the mount options string */
1835 (void) strlcpy(optstr, MNTOPT_NOSUB, sizeof (optstr));
1836
1837 /* Loopback mount this dataset at the altroot */
1838 if (mount(zonepath, altzonepath, mflag, MNTTYPE_LOFS,
1839 NULL, 0, optstr, sizeof (optstr)) != 0) {
1840 err = errno;
1841 be_print_err(gettext("loopback_mount_zonepath: "
1842 "failed to loopback mount %s at %s: %s\n"),
1843 zonepath, altzonepath, strerror(err));
1844 ret = BE_ERR_MOUNT;
1845 goto done;
1846 }
1847 ret = BE_SUCCESS;
1848
1849 done :
1850 (void) fclose(fp);
1851 return (ret);
1852 }
1853
1854 /*
1855 * Function: unmount_shared_fs
1856 * Description: This function iterates through the mnttab and finds all
1857 * loopback mount entries that reside within the altroot of
1858 * where the BE is mounted, and unmounts it.
1859 * Parameters:
1860 * ud - be_unmount_data_t pointer
1861 * Returns:
1862 * BE_SUCCESS - Success
1863 * be_errno_t - Failure
1864 * Scope:
1865 * Private
1866 */
1867 static int
1868 unmount_shared_fs(be_unmount_data_t *ud)
1869 {
1870 FILE *fp = NULL;
1871 struct mnttab *table = NULL;
1872 struct mnttab ent;
1873 struct mnttab *entp = NULL;
1874 size_t size = 0;
1875 int read_chunk = 32;
1876 int i;
1877 int altroot_len;
1878 int err = 0;
1879
1880 errno = 0;
1881
1882 /* Read in the mnttab into a table */
1883 if ((fp = fopen(MNTTAB, "r")) == NULL) {
1884 err = errno;
1885 be_print_err(gettext("unmount_shared_fs: "
1886 "failed to open mnttab\n"));
1887 return (errno_to_be_err(err));
1888 }
1889
1890 while (getmntent(fp, &ent) == 0) {
1891 if (size % read_chunk == 0) {
1892 table = (struct mnttab *)realloc(table,
1893 (size + read_chunk) * sizeof (ent));
1894 }
1895 entp = &table[size++];
1896
1897 /*
1898 * Copy over the current mnttab entry into our table,
1899 * copying only the fields that we care about.
1900 */
1901 (void) memset(entp, 0, sizeof (*entp));
1902 if ((entp->mnt_mountp = strdup(ent.mnt_mountp)) == NULL ||
1903 (entp->mnt_fstype = strdup(ent.mnt_fstype)) == NULL) {
1904 be_print_err(gettext("unmount_shared_fs: "
1905 "memory allocation failed\n"));
1906 return (BE_ERR_NOMEM);
1907 }
1908 }
1909 (void) fclose(fp);
1910
1911 /*
1912 * Process the mnttab entries in reverse order, looking for
1913 * loopback mount entries mounted under our altroot.
1914 */
1915 altroot_len = strlen(ud->altroot);
1916 for (i = size; i > 0; i--) {
1917 entp = &table[i - 1];
1918
1919 /* If not of type lofs, skip */
1920 if (strcmp(entp->mnt_fstype, MNTTYPE_LOFS) != 0)
1921 continue;
1922
1923 /* If inside the altroot, unmount it */
1924 if (strncmp(entp->mnt_mountp, ud->altroot, altroot_len) == 0 &&
1925 entp->mnt_mountp[altroot_len] == '/') {
1926 if (umount(entp->mnt_mountp) != 0) {
1927 err = errno;
1928 if (err == EBUSY) {
1929 (void) sleep(1);
1930 err = errno = 0;
1931 if (umount(entp->mnt_mountp) != 0)
1932 err = errno;
1933 }
1934 if (err != 0) {
1935 be_print_err(gettext(
1936 "unmount_shared_fs: "
1937 "failed to unmount shared file "
1938 "system %s: %s\n"),
1939 entp->mnt_mountp, strerror(err));
1940 return (errno_to_be_err(err));
1941 }
1942 }
1943 }
1944 }
1945
1946 return (BE_SUCCESS);
1947 }
1948
1949 /*
1950 * Function: get_mountpoint_from_vfstab
1951 * Description: This function digs into the vfstab in the given altroot,
1952 * and searches for an entry for the fs passed in. If found,
1953 * it returns the mountpoint of that fs in the mountpoint
1954 * buffer passed in. If the get_alt_mountpoint flag is set,
1955 * it returns the mountpoint with the altroot prepended.
1956 * Parameters:
1957 * altroot - pointer to the alternate root location
1958 * fs - pointer to the file system name to look for in the
1959 * vfstab in altroot
1960 * mountpoint - pointer to buffer of where the mountpoint of
1961 * fs will be returned.
1962 * size_mp - size of mountpoint argument
1963 * get_alt_mountpoint - flag to indicate whether or not the
1964 * mountpoint should be populated with the altroot
1965 * prepended.
1966 * Returns:
1967 * BE_SUCCESS - Success
1968 * 1 - Failure
1969 * Scope:
1970 * Private
1971 */
1972 static int
1973 get_mountpoint_from_vfstab(char *altroot, const char *fs, char *mountpoint,
1974 size_t size_mp, boolean_t get_alt_mountpoint)
1975 {
1976 struct vfstab vp;
1977 FILE *fp = NULL;
1978 char alt_vfstab[MAXPATHLEN];
1979
1980 /* Generate path to alternate root vfstab */
1981 (void) snprintf(alt_vfstab, sizeof (alt_vfstab), "%s/etc/vfstab",
1982 altroot);
1983
1984 /* Open alternate root vfstab */
1985 if ((fp = fopen(alt_vfstab, "r")) == NULL) {
1986 be_print_err(gettext("get_mountpoint_from_vfstab: "
1987 "failed to open vfstab (%s)\n"), alt_vfstab);
1988 return (1);
1989 }
1990
1991 if (getvfsspec(fp, &vp, (char *)fs) == 0) {
1992 /*
1993 * Found entry for fs, grab its mountpoint.
1994 * If the flag to prepend the altroot into the mountpoint
1995 * is set, prepend it. Otherwise, just return the mountpoint.
1996 */
1997 if (get_alt_mountpoint) {
1998 (void) snprintf(mountpoint, size_mp, "%s%s", altroot,
1999 vp.vfs_mountp);
2000 } else {
2001 (void) strlcpy(mountpoint, vp.vfs_mountp, size_mp);
2002 }
2003 } else {
2004 (void) fclose(fp);
2005 return (1);
2006 }
2007
2008 (void) fclose(fp);
2009
2010 return (BE_SUCCESS);
2011 }
2012
2013 /*
2014 * Function: fix_mountpoint_callback
2015 * Description: This callback function is used to iterate through a BE's
2016 * children filesystems to check if its mountpoint is currently
2017 * set to be mounted at some specified altroot. If so, fix it by
2018 * removing altroot from the beginning of its mountpoint.
2019 *
2020 * Note - There's no way to tell if a child filesystem's
2021 * mountpoint isn't broken, and just happens to begin with
2022 * the altroot we're looking for. In this case, this function
2023 * will errantly remove the altroot portion from the beginning
2024 * of this filesystem's mountpoint.
2025 *
2026 * Parameters:
2027 * zhp - zfs_handle_t pointer to filesystem being processed.
2028 * data - altroot of where BE is to be mounted.
2029 * Returns:
2030 * 0 - Success
2031 * be_errno_t - Failure
2032 * Scope:
2033 * Private
2034 */
2035 static int
2036 fix_mountpoint_callback(zfs_handle_t *zhp, void *data)
2037 {
2038 zprop_source_t sourcetype;
2039 char source[ZFS_MAXNAMELEN];
2040 char mountpoint[MAXPATHLEN];
2041 char *zhp_mountpoint = NULL;
2042 char *altroot = data;
2043 int ret = 0;
2044
2045 /* Get dataset's mountpoint and source values */
2046 if (zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, mountpoint,
2047 sizeof (mountpoint), &sourcetype, source, sizeof (source),
2048 B_FALSE) != 0) {
2049 be_print_err(gettext("fix_mountpoint_callback: "
2050 "failed to get mountpoint and sourcetype for %s\n"),
2051 zfs_get_name(zhp));
2052 ZFS_CLOSE(zhp);
2053 return (BE_ERR_ZFS);
2054 }
2055
2056 /*
2057 * If the mountpoint is not inherited and the mountpoint is not
2058 * 'legacy', this file system potentially needs its mountpoint
2059 * fixed.
2060 */
2061 if (!(sourcetype & ZPROP_SRC_INHERITED) &&
2062 strcmp(mountpoint, ZFS_MOUNTPOINT_LEGACY) != 0) {
2063
2064 /*
2065 * Check if this file system's current mountpoint is
2066 * under the altroot we're fixing it against.
2067 */
2068 if (strncmp(mountpoint, altroot, strlen(altroot)) == 0 &&
2069 mountpoint[strlen(altroot)] == '/') {
2070
2071 /*
2072 * Get this dataset's mountpoint relative to the
2073 * altroot.
2074 */
2075 zhp_mountpoint = mountpoint + strlen(altroot);
2076
2077 /* Fix this dataset's mountpoint value */
2078 if (zfs_prop_set(zhp,
2079 zfs_prop_to_name(ZFS_PROP_MOUNTPOINT),
2080 zhp_mountpoint)) {
2081 be_print_err(gettext("fix_mountpoint_callback: "
2082 "failed to set mountpoint for %s to "
2083 "%s: %s\n"), zfs_get_name(zhp),
2084 zhp_mountpoint,
2085 libzfs_error_description(g_zfs));
2086 ret = zfs_err_to_be_err(g_zfs);
2087 ZFS_CLOSE(zhp);
2088 return (ret);
2089 }
2090 }
2091 }
2092
2093 /* Iterate through this dataset's children and fix them */
2094 if ((ret = zfs_iter_filesystems(zhp, fix_mountpoint_callback,
2095 altroot)) != 0) {
2096 ZFS_CLOSE(zhp);
2097 return (ret);
2098 }
2099
2100
2101 ZFS_CLOSE(zhp);
2102 return (0);
2103 }
2104
2105 /*
2106 * Function: be_mount_root
2107 * Description: This function mounts the root dataset of a BE at the
2108 * specified altroot.
2109 * Parameters:
2110 * zhp - zfs_handle_t pointer to root dataset of a BE that is
2111 * to be mounted at altroot.
2112 * altroot - location of where to mount the BE root.
2113 * Return:
2114 * BE_SUCCESS - Success
2115 * be_errno_t - Failure
2116 * Scope:
2117 * Private
2118 */
2119 static int
2120 be_mount_root(zfs_handle_t *zhp, char *altroot)
2121 {
2122 char mountpoint[MAXPATHLEN];
2123
2124 /* Get mountpoint property of dataset */
2125 if (zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, mountpoint,
2126 sizeof (mountpoint), NULL, NULL, 0, B_FALSE) != 0) {
2127 be_print_err(gettext("be_mount_root: failed to "
2128 "get mountpoint property for %s: %s\n"), zfs_get_name(zhp),
2129 libzfs_error_description(g_zfs));
2130 return (zfs_err_to_be_err(g_zfs));
2131 }
2132
2133 /*
2134 * Set the canmount property for the BE's root dataset to 'noauto' just
2135 * in case it's been set to 'on'. We do this so that when we change its
2136 * mountpoint, zfs won't immediately try to mount it.
2137 */
2138 if (zfs_prop_set(zhp, zfs_prop_to_name(ZFS_PROP_CANMOUNT), "noauto")
2139 != 0) {
2140 be_print_err(gettext("be_mount_root: failed to "
2141 "set canmount property to 'noauto' (%s): %s\n"),
2142 zfs_get_name(zhp), libzfs_error_description(g_zfs));
2143 return (zfs_err_to_be_err(g_zfs));
2144 }
2145
2146 /* Set mountpoint for BE's root filesystem */
2147 if (zfs_prop_set(zhp, zfs_prop_to_name(ZFS_PROP_MOUNTPOINT), altroot)
2148 != 0) {
2149 be_print_err(gettext("be_mount_root: failed to "
2150 "set mountpoint of %s to %s: %s\n"),
2151 zfs_get_name(zhp), altroot,
2152 libzfs_error_description(g_zfs));
2153 return (zfs_err_to_be_err(g_zfs));
2154 }
2155
2156 /* Mount the BE's root filesystem */
2157 if (zfs_mount(zhp, NULL, 0) != 0) {
2158 be_print_err(gettext("be_mount_root: failed to "
2159 "mount dataset %s at %s: %s\n"), zfs_get_name(zhp),
2160 altroot, libzfs_error_description(g_zfs));
2161 /*
2162 * Set this BE's root filesystem 'mountpoint' property
2163 * back to what it was before.
2164 */
2165 (void) zfs_prop_set(zhp, zfs_prop_to_name(ZFS_PROP_MOUNTPOINT),
2166 mountpoint);
2167 return (zfs_err_to_be_err(g_zfs));
2168 }
2169
2170 return (BE_SUCCESS);
2171 }
2172
2173 /*
2174 * Function: be_unmount_root
2175 * Description: This function unmounts the root dataset of a BE, but before
2176 * unmounting, it looks at the BE's vfstab to determine
2177 * if the root dataset mountpoint should be left as 'legacy'
2178 * or '/'. If the vfstab contains an entry for this root
2179 * dataset with a mountpoint of '/', it sets the mountpoint
2180 * property to 'legacy'.
2181 *
2182 * Parameters:
2183 * zhp - zfs_handle_t pointer of the BE root dataset that
2184 * is currently mounted.
2185 * ud - be_unmount_data_t pointer providing unmount data
2186 * for the given BE root dataset.
2187 * Returns:
2188 * BE_SUCCESS - Success
2189 * be_errno_t - Failure
2190 * Scope:
2191 * Private
2192 */
2193 static int
2194 be_unmount_root(zfs_handle_t *zhp, be_unmount_data_t *ud)
2195 {
2196 char mountpoint[MAXPATHLEN];
2197 boolean_t is_legacy = B_FALSE;
2198
2199 /* See if this is a legacy mounted root */
2200 if (get_mountpoint_from_vfstab(ud->altroot, zfs_get_name(zhp),
2201 mountpoint, sizeof (mountpoint), B_FALSE) == BE_SUCCESS &&
2202 strcmp(mountpoint, "/") == 0) {
2203 is_legacy = B_TRUE;
2204 }
2205
2206 /* Unmount the dataset */
2207 if (zfs_unmount(zhp, NULL, ud->force ? MS_FORCE : 0) != 0) {
2208 be_print_err(gettext("be_unmount_root: failed to "
2209 "unmount BE root dataset %s: %s\n"), zfs_get_name(zhp),
2210 libzfs_error_description(g_zfs));
2211 return (zfs_err_to_be_err(g_zfs));
2212 }
2213
2214 /* Set canmount property for this BE's root filesystem to noauto */
2215 if (zfs_prop_set(zhp, zfs_prop_to_name(ZFS_PROP_CANMOUNT), "noauto")
2216 != 0) {
2217 be_print_err(gettext("be_unmount_root: failed to "
2218 "set canmount property for %s to 'noauto': %s\n"),
2219 zfs_get_name(zhp), libzfs_error_description(g_zfs));
2220 return (zfs_err_to_be_err(g_zfs));
2221 }
2222
2223 /*
2224 * Set mountpoint for BE's root dataset back to '/', or 'legacy'
2225 * if its a legacy mounted root.
2226 */
2227 if (zfs_prop_set(zhp, zfs_prop_to_name(ZFS_PROP_MOUNTPOINT),
2228 is_legacy ? ZFS_MOUNTPOINT_LEGACY : "/") != 0) {
2229 be_print_err(gettext("be_unmount_root: failed to "
2230 "set mountpoint of %s to %s\n"), zfs_get_name(zhp),
2231 is_legacy ? ZFS_MOUNTPOINT_LEGACY : "/");
2232 return (zfs_err_to_be_err(g_zfs));
2233 }
2234
2235 return (BE_SUCCESS);
2236 }
2237
2238 /*
2239 * Function: fix_mountpoint
2240 * Description: This function checks the mountpoint of an unmounted BE to make
2241 * sure that it is set to either 'legacy' or '/'. If it's not,
2242 * then we're in a situation where an unmounted BE has some random
2243 * mountpoint set for it. (This could happen if the system was
2244 * rebooted while an inactive BE was mounted). This function
2245 * attempts to fix its mountpoints.
2246 * Parameters:
2247 * zhp - zfs_handle_t pointer to root dataset of the BE
2248 * whose mountpoint needs to be checked.
2249 * Return:
2250 * BE_SUCCESS - Success
2251 * be_errno_t - Failure
2252 * Scope:
2253 * Private
2254 */
2255 static int
2256 fix_mountpoint(zfs_handle_t *zhp)
2257 {
2258 be_unmount_data_t ud = { 0 };
2259 char *altroot = NULL;
2260 char mountpoint[MAXPATHLEN];
2261 int ret = BE_SUCCESS;
2262
2263 /*
2264 * Record what this BE's root dataset mountpoint property is currently
2265 * set to.
2266 */
2267 if (zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, mountpoint,
2268 sizeof (mountpoint), NULL, NULL, 0, B_FALSE) != 0) {
2269 be_print_err(gettext("fix_mountpoint: failed to get "
2270 "mountpoint property of (%s): %s\n"), zfs_get_name(zhp),
2271 libzfs_error_description(g_zfs));
2272 return (BE_ERR_ZFS);
2273 }
2274
2275 /*
2276 * If the root dataset mountpoint is set to 'legacy' or '/', we're okay.
2277 */
2278 if (strcmp(mountpoint, ZFS_MOUNTPOINT_LEGACY) == 0 ||
2279 strcmp(mountpoint, "/") == 0) {
2280 return (BE_SUCCESS);
2281 }
2282
2283 /*
2284 * Iterate through this BE's children datasets and fix
2285 * them if they need fixing.
2286 */
2287 if (zfs_iter_filesystems(zhp, fix_mountpoint_callback, mountpoint)
2288 != 0) {
2289 return (BE_ERR_ZFS);
2290 }
2291
2292 /*
2293 * The process of mounting and unmounting the root file system
2294 * will fix its mountpoint to correctly be either 'legacy' or '/'
2295 * since be_unmount_root will do the right thing by looking at
2296 * its vfstab.
2297 */
2298
2299 /* Generate temporary altroot to mount the root file system */
2300 if ((ret = be_make_tmp_mountpoint(&altroot)) != BE_SUCCESS) {
2301 be_print_err(gettext("fix_mountpoint: failed to "
2302 "make temporary mountpoint\n"));
2303 return (ret);
2304 }
2305
2306 /* Mount and unmount the root. */
2307 if ((ret = be_mount_root(zhp, altroot)) != BE_SUCCESS) {
2308 be_print_err(gettext("fix_mountpoint: failed to "
2309 "mount BE root file system\n"));
2310 goto cleanup;
2311 }
2312 ud.altroot = altroot;
2313 if ((ret = be_unmount_root(zhp, &ud)) != BE_SUCCESS) {
2314 be_print_err(gettext("fix_mountpoint: failed to "
2315 "unmount BE root file system\n"));
2316 goto cleanup;
2317 }
2318
2319 cleanup:
2320 free(altroot);
2321
2322 return (ret);
2323 }
2324
2325 /*
2326 * Function: be_mount_zones
2327 * Description: This function finds all supported non-global zones in the
2328 * given global BE and mounts them with respect to where the
2329 * global BE is currently mounted. The global BE datasets
2330 * (including its shared datasets) are expected to already
2331 * be mounted.
2332 * Parameters:
2333 * be_zhp - zfs_handle_t pointer to the root dataset of the
2334 * global BE.
2335 * md - be_mount_data_t pointer to data for global BE.
2336 * Returns:
2337 * BE_SUCCESS - Success
2338 * be_errno_t - Failure
2339 * Scope:
2340 * Private
2341 */
2342 static int
2343 be_mount_zones(zfs_handle_t *be_zhp, be_mount_data_t *md)
2344 {
2345 zoneBrandList_t *brands = NULL;
2346 zoneList_t zlst = NULL;
2347 char *zonename = NULL;
2348 char *zonepath = NULL;
2349 char *zonepath_ds = NULL;
2350 int k;
2351 int ret = BE_SUCCESS;
2352
2353 z_set_zone_root(md->altroot);
2354
2355 if ((brands = be_get_supported_brandlist()) == NULL) {
2356 be_print_err(gettext("be_mount_zones: "
2357 "no supported brands\n"));
2358 return (BE_SUCCESS);
2359 }
2360
2361 zlst = z_get_nonglobal_zone_list_by_brand(brands);
2362 if (zlst == NULL) {
2363 z_free_brand_list(brands);
2364 return (BE_SUCCESS);
2365 }
2366
2367 for (k = 0; (zonename = z_zlist_get_zonename(zlst, k)) != NULL; k++) {
2368 if (z_zlist_get_current_state(zlst, k) ==
2369 ZONE_STATE_INSTALLED) {
2370 zonepath = z_zlist_get_zonepath(zlst, k);
2371
2372 /*
2373 * Get the dataset of this zonepath in current BE.
2374 * If its not a dataset, skip it.
2375 */
2376 if ((zonepath_ds = be_get_ds_from_dir(zonepath))
2377 == NULL)
2378 continue;
2379
2380 /*
2381 * Check if this zone is supported based on
2382 * the dataset of its zonepath
2383 */
2384 if (!be_zone_supported(zonepath_ds)) {
2385 free(zonepath_ds);
2386 zonepath_ds = NULL;
2387 continue;
2388 }
2389
2390 /*
2391 * if BE's shared file systems are already mounted,
2392 * zone path dataset would have already been lofs
2393 * mounted under altroot. Otherwise, we need to do
2394 * it here.
2395 */
2396 if (!md->shared_fs) {
2397 ret = loopback_mount_zonepath(zonepath, md);
2398 if (ret != BE_SUCCESS)
2399 goto done;
2400 }
2401
2402
2403 /* Mount this zone */
2404 ret = be_mount_one_zone(be_zhp, md, zonename,
2405 zonepath, zonepath_ds);
2406
2407 free(zonepath_ds);
2408 zonepath_ds = NULL;
2409
2410 if (ret != BE_SUCCESS) {
2411 be_print_err(gettext("be_mount_zones: "
2412 "failed to mount zone %s under "
2413 "altroot %s\n"), zonename, md->altroot);
2414 goto done;
2415 }
2416 }
2417 }
2418
2419 done:
2420 z_free_brand_list(brands);
2421 z_free_zone_list(zlst);
2422 /*
2423 * libinstzones caches mnttab and uses cached version for resolving lofs
2424 * mounts when we call z_resolve_lofs. It creates the cached version
2425 * when the first call to z_resolve_lofs happens. So, library's cached
2426 * mnttab doesn't contain entries for lofs mounts created in the above
2427 * loop. Because of this, subsequent calls to z_resolve_lofs would fail
2428 * to resolve these lofs mounts. So, here we destroy library's cached
2429 * mnttab to force its recreation when the next call to z_resolve_lofs
2430 * happens.
2431 */
2432 z_destroyMountTable();
2433 return (ret);
2434 }
2435
2436 /*
2437 * Function: be_unmount_zones
2438 * Description: This function finds all supported non-global zones in the
2439 * given mounted global BE and unmounts them.
2440 * Parameters:
2441 * ud - unmount_data_t pointer data for the global BE.
2442 * Returns:
2443 * BE_SUCCESS - Success
2444 * be_errno_t - Failure
2445 * Scope:
2446 * Private
2447 */
2448 static int
2449 be_unmount_zones(be_unmount_data_t *ud)
2450 {
2451 zoneBrandList_t *brands = NULL;
2452 zoneList_t zlst = NULL;
2453 char *zonename = NULL;
2454 char *zonepath = NULL;
2455 char alt_zonepath[MAXPATHLEN];
2456 char *zonepath_ds = NULL;
2457 int k;
2458 int ret = BE_SUCCESS;
2459
2460 z_set_zone_root(ud->altroot);
2461
2462 if ((brands = be_get_supported_brandlist()) == NULL) {
2463 be_print_err(gettext("be_unmount_zones: "
2464 "no supported brands\n"));
2465 return (BE_SUCCESS);
2466 }
2467
2468 zlst = z_get_nonglobal_zone_list_by_brand(brands);
2469 if (zlst == NULL) {
2470 z_free_brand_list(brands);
2471 return (BE_SUCCESS);
2472 }
2473
2474 for (k = 0; (zonename = z_zlist_get_zonename(zlst, k)) != NULL; k++) {
2475 if (z_zlist_get_current_state(zlst, k) ==
2476 ZONE_STATE_INSTALLED) {
2477 zonepath = z_zlist_get_zonepath(zlst, k);
2478
2479 /* Build zone's zonepath wrt the global BE altroot */
2480 (void) snprintf(alt_zonepath, sizeof (alt_zonepath),
2481 "%s%s", ud->altroot, zonepath);
2482
2483 /*
2484 * Get the dataset of this zonepath. If its not
2485 * a dataset, skip it.
2486 */
2487 if ((zonepath_ds = be_get_ds_from_dir(alt_zonepath))
2488 == NULL)
2489 continue;
2490
2491 /*
2492 * Check if this zone is supported based on the
2493 * dataset of its zonepath.
2494 */
2495 if (!be_zone_supported(zonepath_ds)) {
2496 free(zonepath_ds);
2497 zonepath_ds = NULL;
2498 continue;
2499 }
2500
2501 /* Unmount this zone */
2502 ret = be_unmount_one_zone(ud, zonename, zonepath,
2503 zonepath_ds);
2504
2505 free(zonepath_ds);
2506 zonepath_ds = NULL;
2507
2508 if (ret != BE_SUCCESS) {
2509 be_print_err(gettext("be_unmount_zones:"
2510 " failed to unmount zone %s from "
2511 "altroot %s\n"), zonename, ud->altroot);
2512 goto done;
2513 }
2514 }
2515 }
2516
2517 done:
2518 z_free_brand_list(brands);
2519 z_free_zone_list(zlst);
2520 return (ret);
2521 }
2522
2523 /*
2524 * Function: be_mount_one_zone
2525 * Description: This function is called to mount one zone for a given
2526 * global BE.
2527 * Parameters:
2528 * be_zhp - zfs_handle_t pointer to the root dataset of the
2529 * global BE
2530 * md - be_mount_data_t pointer to data for global BE
2531 * zonename - name of zone to mount
2532 * zonepath - zonepath of zone to mount
2533 * zonepath_ds - dataset for the zonepath
2534 * Returns:
2535 * BE_SUCCESS - Success
2536 * be_errno_t - Failure
2537 * Scope:
2538 * Private
2539 */
2540 static int
2541 be_mount_one_zone(zfs_handle_t *be_zhp, be_mount_data_t *md, char *zonename,
2542 char *zonepath, char *zonepath_ds)
2543 {
2544 be_mount_data_t zone_md = { 0 };
2545 zfs_handle_t *zone_zhp = NULL;
2546 char zone_altroot[MAXPATHLEN];
2547 char zoneroot[MAXPATHLEN];
2548 char zoneroot_ds[MAXPATHLEN];
2549 int ret = BE_SUCCESS;
2550
2551 /* Find the active zone root dataset for this zone for this BE */
2552 if ((ret = be_find_active_zone_root(be_zhp, zonepath_ds, zoneroot_ds,
2553 sizeof (zoneroot_ds))) == BE_ERR_ZONE_NO_ACTIVE_ROOT) {
2554 be_print_err(gettext("be_mount_one_zone: did not "
2555 "find active zone root for zone %s, skipping ...\n"),
2556 zonename);
2557 return (BE_SUCCESS);
2558 } else if (ret != BE_SUCCESS) {
2559 be_print_err(gettext("be_mount_one_zone: failed to "
2560 "find active zone root for zone %s\n"), zonename);
2561 return (ret);
2562 }
2563
2564 /* Get handle to active zoneroot dataset */
2565 if ((zone_zhp = zfs_open(g_zfs, zoneroot_ds, ZFS_TYPE_FILESYSTEM))
2566 == NULL) {
2567 be_print_err(gettext("be_mount_one_zone: failed to "
2568 "open zone root dataset (%s): %s\n"), zoneroot_ds,
2569 libzfs_error_description(g_zfs));
2570 return (zfs_err_to_be_err(g_zfs));
2571 }
2572
2573 /* Generate string for zone's altroot path */
2574 be_make_zoneroot(zonepath, zoneroot, sizeof (zoneroot));
2575 (void) strlcpy(zone_altroot, md->altroot, sizeof (zone_altroot));
2576 (void) strlcat(zone_altroot, zoneroot, sizeof (zone_altroot));
2577
2578 /* Build mount_data for the zone */
2579 zone_md.altroot = zone_altroot;
2580 zone_md.shared_fs = md->shared_fs;
2581 zone_md.shared_rw = md->shared_rw;
2582
2583 /* Mount the zone's root file system */
2584 if ((ret = be_mount_zone_root(zone_zhp, &zone_md)) != BE_SUCCESS) {
2585 be_print_err(gettext("be_mount_one_zone: failed to "
2586 "mount zone root file system at %s\n"), zone_altroot);
2587 goto done;
2588 }
2589
2590 /* Iterate through zone's children filesystems */
2591 if ((ret = zfs_iter_filesystems(zone_zhp, be_mount_callback,
2592 zone_altroot)) != 0) {
2593 be_print_err(gettext("be_mount_one_zone: failed to "
2594 "mount zone subordinate file systems at %s\n"),
2595 zone_altroot);
2596 goto done;
2597 }
2598
2599 /* TODO: Mount all shared file systems for this zone */
2600
2601 done:
2602 ZFS_CLOSE(zone_zhp);
2603 return (ret);
2604 }
2605
2606 /*
2607 * Function: be_unmount_one_zone
2608 * Description: This function unmount one zone for a give global BE.
2609 * Parameters:
2610 * ud - be_unmount_data_t pointer to data for global BE
2611 * zonename - name of zone to unmount
2612 * zonepath - zonepath of the zone to unmount
2613 * zonepath_ds - dataset for the zonepath
2614 * Returns:
2615 * BE_SUCCESS - Success
2616 * be_errno_t - Failure
2617 * Scope:
2618 * Private
2619 */
2620 static int
2621 be_unmount_one_zone(be_unmount_data_t *ud, char *zonename, char *zonepath,
2622 char *zonepath_ds)
2623 {
2624 be_unmount_data_t zone_ud = { 0 };
2625 zfs_handle_t *zone_zhp = NULL;
2626 char zone_altroot[MAXPATHLEN];
2627 char zoneroot[MAXPATHLEN];
2628 char zoneroot_ds[MAXPATHLEN];
2629 int ret = BE_SUCCESS;
2630
2631 /* Generate string for zone's alternate root path */
2632 be_make_zoneroot(zonepath, zoneroot, sizeof (zoneroot));
2633 (void) strlcpy(zone_altroot, ud->altroot, sizeof (zone_altroot));
2634 (void) strlcat(zone_altroot, zoneroot, sizeof (zone_altroot));
2635
2636 /* Build be_unmount_data for zone */
2637 zone_ud.altroot = zone_altroot;
2638 zone_ud.force = ud->force;
2639
2640 /* Find the mounted zone root dataset for this zone for this BE */
2641 if ((ret = be_find_mounted_zone_root(zone_altroot, zonepath_ds,
2642 zoneroot_ds, sizeof (zoneroot_ds))) == BE_ERR_NO_MOUNTED_ZONE) {
2643 be_print_err(gettext("be_unmount_one_zone: did not "
2644 "find any zone root mounted for zone %s\n"), zonename);
2645 return (BE_SUCCESS);
2646 } else if (ret != BE_SUCCESS) {
2647 be_print_err(gettext("be_unmount_one_zone: failed to "
2648 "find mounted zone root for zone %s\n"), zonename);
2649 return (ret);
2650 }
2651
2652 /* Get handle to zoneroot dataset mounted for this BE */
2653 if ((zone_zhp = zfs_open(g_zfs, zoneroot_ds, ZFS_TYPE_FILESYSTEM))
2654 == NULL) {
2655 be_print_err(gettext("be_unmount_one_zone: failed to "
2656 "open mounted zone root dataset (%s): %s\n"), zoneroot_ds,
2657 libzfs_error_description(g_zfs));
2658 return (zfs_err_to_be_err(g_zfs));
2659 }
2660
2661 /* TODO: Unmount all shared file systems for this zone */
2662
2663 /* Iterate through zone's children filesystems and unmount them */
2664 if ((ret = zfs_iter_filesystems(zone_zhp, be_unmount_callback,
2665 &zone_ud)) != 0) {
2666 be_print_err(gettext("be_unmount_one_zone: failed to "
2667 "unmount zone subordinate file systems at %s\n"),
2668 zone_altroot);
2669 goto done;
2670 }
2671
2672 /* Unmount the zone's root filesystem */
2673 if ((ret = be_unmount_zone_root(zone_zhp, &zone_ud)) != BE_SUCCESS) {
2674 be_print_err(gettext("be_unmount_one_zone: failed to "
2675 "unmount zone root file system at %s\n"), zone_altroot);
2676 goto done;
2677 }
2678
2679 done:
2680 ZFS_CLOSE(zone_zhp);
2681 return (ret);
2682 }
2683
2684 /*
2685 * Function: be_get_ds_from_dir_callback
2686 * Description: This is a callback function used to iterate all datasets
2687 * to find the one that is currently mounted at the directory
2688 * being searched for. If matched, the name of the dataset is
2689 * returned in heap storage, so the caller is responsible for
2690 * freeing it.
2691 * Parameters:
2692 * zhp - zfs_handle_t pointer to current dataset being processed.
2693 * data - dir_data_t pointer providing name of directory being
2694 * searched for.
2695 * Returns:
2696 * 1 - This dataset is mounted at directory being searched for.
2697 * 0 - This dataset is not mounted at directory being searched for.
2698 * Scope:
2699 * Private
2700 */
2701 static int
2702 be_get_ds_from_dir_callback(zfs_handle_t *zhp, void *data)
2703 {
2704 dir_data_t *dd = data;
2705 char *mp = NULL;
2706 int zret = 0;
2707
2708 if (zfs_get_type(zhp) != ZFS_TYPE_FILESYSTEM) {
2709 ZFS_CLOSE(zhp);
2710 return (0);
2711 }
2712
2713 if (zfs_is_mounted(zhp, &mp) && mp != NULL &&
2714 strcmp(mp, dd->dir) == 0) {
2715 if ((dd->ds = strdup(zfs_get_name(zhp))) == NULL) {
2716 be_print_err(gettext("be_get_ds_from_dir_callback: "
2717 "memory allocation failed\n"));
2718 ZFS_CLOSE(zhp);
2719 return (0);
2720 }
2721 ZFS_CLOSE(zhp);
2722 return (1);
2723 }
2724
2725 zret = zfs_iter_filesystems(zhp, be_get_ds_from_dir_callback, dd);
2726
2727 ZFS_CLOSE(zhp);
2728
2729 return (zret);
2730 }