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 ((ret = be_mount_zones(zhp, &md)) != BE_SUCCESS) {
386 (void) _be_unmount(bt.obe_name, 0);
387 if (gen_tmp_altroot)
388 free(tmp_altroot);
389 ZFS_CLOSE(zhp);
390 return (ret);
391 }
392 }
393
394 ZFS_CLOSE(zhp);
395
396 /*
397 * If a NULL altroot was passed in, pass the generated altroot
398 * back to the caller in altroot.
399 */
400 if (gen_tmp_altroot)
401 *altroot = tmp_altroot;
402
403 return (BE_SUCCESS);
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. Since these are shared file
1716 * systems, they are expected to be already mounted for the
1717 * current BE, and this function just loopback mounts them into
1718 * the BE mountpoint.
1719 * Parameters:
1720 * zonepath - pointer to zone path in the current BE
1721 * md - be_mount_data_t pointer
1722 * Returns:
1723 * BE_SUCCESS - Success
1724 * be_errno_t - Failure
1725 * Scope:
1726 * Private
1727 */
1728 static int
1729 loopback_mount_zonepath(const char *zonepath, be_mount_data_t *md)
1730 {
1731 FILE *fp = (FILE *)NULL;
1732 struct stat st;
1733 char *p;
1734 char *p1;
1735 char *parent_dir;
1736 struct extmnttab extmtab;
1737 dev_t dev = NODEV;
1738 char *parentmnt;
1739 char alt_parentmnt[MAXPATHLEN];
1740 struct mnttab mntref;
1741 char altzonepath[MAXPATHLEN];
1742 char optstr[MAX_MNTOPT_STR];
1743 int mflag = MS_OPTIONSTR;
1744 int ret;
1745 int err;
1746
1747 fp = fopen(MNTTAB, "r");
1748 if (fp == NULL) {
1749 err = errno;
1750 be_print_err(gettext("loopback_mount_zonepath: "
1751 "failed to open /etc/mnttab\n"));
1752 return (errno_to_be_err(err));
1753 }
1754
1755 /*
1756 * before attempting the loopback mount of zonepath under altroot,
1757 * we need to make sure that all intermediate file systems in the
1758 * zone path are also mounted under altroot
1759 */
1760
1761 /* get the parent directory for zonepath */
1762 p = strrchr(zonepath, '/');
1763 if (p != NULL && p != zonepath) {
1764 if ((parent_dir = (char *)calloc(sizeof (char),
1765 p - zonepath + 1)) == NULL) {
1766 ret = BE_ERR_NOMEM;
1767 goto done;
1768 }
1769 (void) strlcpy(parent_dir, zonepath, p - zonepath + 1);
1770 if (stat(parent_dir, &st) < 0) {
1771 ret = errno_to_be_err(errno);
1772 be_print_err(gettext("loopback_mount_zonepath: "
1773 "failed to stat %s"),
1774 parent_dir);
1775 free(parent_dir);
1776 goto done;
1777 }
1778 free(parent_dir);
1779
1780 /*
1781 * After the above stat call, st.st_dev contains ID of the
1782 * device over which parent dir resides.
1783 * Now, search mnttab and find mount point of parent dir device.
1784 */
1785
1786 resetmnttab(fp);
1787 while (getextmntent(fp, &extmtab, sizeof (extmtab)) == 0) {
1788 dev = makedev(extmtab.mnt_major, extmtab.mnt_minor);
1789 if (st.st_dev == dev && strcmp(extmtab.mnt_fstype,
1790 MNTTYPE_ZFS) == 0) {
1791 p1 = strchr(extmtab.mnt_special, '/');
1792 if (p1 == NULL || strncmp(p1 + 1,
1793 BE_CONTAINER_DS_NAME, 4) != 0 ||
1794 (*(p1 + 5) != '/' && *(p1 + 5) != '\0')) {
1795 /*
1796 * if parent dir is in a shared file
1797 * system, check whether it is already
1798 * loopback mounted under altroot or
1799 * not. It would have been mounted
1800 * already under altroot if it is in
1801 * a non-shared filesystem.
1802 */
1803 parentmnt = strdup(extmtab.mnt_mountp);
1804 (void) snprintf(alt_parentmnt,
1805 sizeof (alt_parentmnt), "%s%s",
1806 md->altroot, parentmnt);
1807 mntref.mnt_mountp = alt_parentmnt;
1808 mntref.mnt_special = parentmnt;
1809 mntref.mnt_fstype = MNTTYPE_LOFS;
1810 mntref.mnt_mntopts = NULL;
1811 mntref.mnt_time = NULL;
1812 resetmnttab(fp);
1813 if (getmntany(fp, (struct mnttab *)
1814 &extmtab, &mntref) != 0) {
1815 ret = loopback_mount_zonepath(
1816 parentmnt, md);
1817 if (ret != BE_SUCCESS) {
1818 free(parentmnt);
1819 goto done;
1820 }
1821 }
1822 free(parentmnt);
1823 }
1824 break;
1825 }
1826 }
1827 }
1828
1829
1830 if (!md->shared_rw) {
1831 mflag |= MS_RDONLY;
1832 }
1833
1834 (void) snprintf(altzonepath, sizeof (altzonepath), "%s%s",
1835 md->altroot, zonepath);
1836
1837 /* Add the "nosub" option to the mount options string */
1838 (void) strlcpy(optstr, MNTOPT_NOSUB, sizeof (optstr));
1839
1840 /* Loopback mount this dataset at the altroot */
1841 if (mount(zonepath, altzonepath, mflag, MNTTYPE_LOFS,
1842 NULL, 0, optstr, sizeof (optstr)) != 0) {
1843 err = errno;
1844 be_print_err(gettext("loopback_mount_zonepath: "
1845 "failed to loopback mount %s at %s: %s\n"),
1846 zonepath, altzonepath, strerror(err));
1847 ret = BE_ERR_MOUNT;
1848 goto done;
1849 }
1850 ret = BE_SUCCESS;
1851
1852 done :
1853 (void) fclose(fp);
1854 return (ret);
1855 }
1856
1857 /*
1858 * Function: unmount_shared_fs
1859 * Description: This function iterates through the mnttab and finds all
1860 * loopback mount entries that reside within the altroot of
1861 * where the BE is mounted, and unmounts it.
1862 * Parameters:
1863 * ud - be_unmount_data_t pointer
1864 * Returns:
1865 * BE_SUCCESS - Success
1866 * be_errno_t - Failure
1867 * Scope:
1868 * Private
1869 */
1870 static int
1871 unmount_shared_fs(be_unmount_data_t *ud)
1872 {
1873 FILE *fp = NULL;
1874 struct mnttab *table = NULL;
1875 struct mnttab ent;
1876 struct mnttab *entp = NULL;
1877 size_t size = 0;
1878 int read_chunk = 32;
1879 int i;
1880 int altroot_len;
1881 int err = 0;
1882
1883 errno = 0;
1884
1885 /* Read in the mnttab into a table */
1886 if ((fp = fopen(MNTTAB, "r")) == NULL) {
1887 err = errno;
1888 be_print_err(gettext("unmount_shared_fs: "
1889 "failed to open mnttab\n"));
1890 return (errno_to_be_err(err));
1891 }
1892
1893 while (getmntent(fp, &ent) == 0) {
1894 if (size % read_chunk == 0) {
1895 table = (struct mnttab *)realloc(table,
1896 (size + read_chunk) * sizeof (ent));
1897 }
1898 entp = &table[size++];
1899
1900 /*
1901 * Copy over the current mnttab entry into our table,
1902 * copying only the fields that we care about.
1903 */
1904 (void) memset(entp, 0, sizeof (*entp));
1905 if ((entp->mnt_mountp = strdup(ent.mnt_mountp)) == NULL ||
1906 (entp->mnt_fstype = strdup(ent.mnt_fstype)) == NULL) {
1907 be_print_err(gettext("unmount_shared_fs: "
1908 "memory allocation failed\n"));
1909 return (BE_ERR_NOMEM);
1910 }
1911 }
1912 (void) fclose(fp);
1913
1914 /*
1915 * Process the mnttab entries in reverse order, looking for
1916 * loopback mount entries mounted under our altroot.
1917 */
1918 altroot_len = strlen(ud->altroot);
1919 for (i = size; i > 0; i--) {
1920 entp = &table[i - 1];
1921
1922 /* If not of type lofs, skip */
1923 if (strcmp(entp->mnt_fstype, MNTTYPE_LOFS) != 0)
1924 continue;
1925
1926 /* If inside the altroot, unmount it */
1927 if (strncmp(entp->mnt_mountp, ud->altroot, altroot_len) == 0 &&
1928 entp->mnt_mountp[altroot_len] == '/') {
1929 if (umount(entp->mnt_mountp) != 0) {
1930 err = errno;
1931 if (err == EBUSY) {
1932 (void) sleep(1);
1933 err = errno = 0;
1934 if (umount(entp->mnt_mountp) != 0)
1935 err = errno;
1936 }
1937 if (err != 0) {
1938 be_print_err(gettext(
1939 "unmount_shared_fs: "
1940 "failed to unmount shared file "
1941 "system %s: %s\n"),
1942 entp->mnt_mountp, strerror(err));
1943 return (errno_to_be_err(err));
1944 }
1945 }
1946 }
1947 }
1948
1949 return (BE_SUCCESS);
1950 }
1951
1952 /*
1953 * Function: get_mountpoint_from_vfstab
1954 * Description: This function digs into the vfstab in the given altroot,
1955 * and searches for an entry for the fs passed in. If found,
1956 * it returns the mountpoint of that fs in the mountpoint
1957 * buffer passed in. If the get_alt_mountpoint flag is set,
1958 * it returns the mountpoint with the altroot prepended.
1959 * Parameters:
1960 * altroot - pointer to the alternate root location
1961 * fs - pointer to the file system name to look for in the
1962 * vfstab in altroot
1963 * mountpoint - pointer to buffer of where the mountpoint of
1964 * fs will be returned.
1965 * size_mp - size of mountpoint argument
1966 * get_alt_mountpoint - flag to indicate whether or not the
1967 * mountpoint should be populated with the altroot
1968 * prepended.
1969 * Returns:
1970 * BE_SUCCESS - Success
1971 * 1 - Failure
1972 * Scope:
1973 * Private
1974 */
1975 static int
1976 get_mountpoint_from_vfstab(char *altroot, const char *fs, char *mountpoint,
1977 size_t size_mp, boolean_t get_alt_mountpoint)
1978 {
1979 struct vfstab vp;
1980 FILE *fp = NULL;
1981 char alt_vfstab[MAXPATHLEN];
1982
1983 /* Generate path to alternate root vfstab */
1984 (void) snprintf(alt_vfstab, sizeof (alt_vfstab), "%s/etc/vfstab",
1985 altroot);
1986
1987 /* Open alternate root vfstab */
1988 if ((fp = fopen(alt_vfstab, "r")) == NULL) {
1989 be_print_err(gettext("get_mountpoint_from_vfstab: "
1990 "failed to open vfstab (%s)\n"), alt_vfstab);
1991 return (1);
1992 }
1993
1994 if (getvfsspec(fp, &vp, (char *)fs) == 0) {
1995 /*
1996 * Found entry for fs, grab its mountpoint.
1997 * If the flag to prepend the altroot into the mountpoint
1998 * is set, prepend it. Otherwise, just return the mountpoint.
1999 */
2000 if (get_alt_mountpoint) {
2001 (void) snprintf(mountpoint, size_mp, "%s%s", altroot,
2002 vp.vfs_mountp);
2003 } else {
2004 (void) strlcpy(mountpoint, vp.vfs_mountp, size_mp);
2005 }
2006 } else {
2007 (void) fclose(fp);
2008 return (1);
2009 }
2010
2011 (void) fclose(fp);
2012
2013 return (BE_SUCCESS);
2014 }
2015
2016 /*
2017 * Function: fix_mountpoint_callback
2018 * Description: This callback function is used to iterate through a BE's
2019 * children filesystems to check if its mountpoint is currently
2020 * set to be mounted at some specified altroot. If so, fix it by
2021 * removing altroot from the beginning of its mountpoint.
2022 *
2023 * Note - There's no way to tell if a child filesystem's
2024 * mountpoint isn't broken, and just happens to begin with
2025 * the altroot we're looking for. In this case, this function
2026 * will errantly remove the altroot portion from the beginning
2027 * of this filesystem's mountpoint.
2028 *
2029 * Parameters:
2030 * zhp - zfs_handle_t pointer to filesystem being processed.
2031 * data - altroot of where BE is to be mounted.
2032 * Returns:
2033 * 0 - Success
2034 * be_errno_t - Failure
2035 * Scope:
2036 * Private
2037 */
2038 static int
2039 fix_mountpoint_callback(zfs_handle_t *zhp, void *data)
2040 {
2041 zprop_source_t sourcetype;
2042 char source[ZFS_MAXNAMELEN];
2043 char mountpoint[MAXPATHLEN];
2044 char *zhp_mountpoint = NULL;
2045 char *altroot = data;
2046 int ret = 0;
2047
2048 /* Get dataset's mountpoint and source values */
2049 if (zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, mountpoint,
2050 sizeof (mountpoint), &sourcetype, source, sizeof (source),
2051 B_FALSE) != 0) {
2052 be_print_err(gettext("fix_mountpoint_callback: "
2053 "failed to get mountpoint and sourcetype for %s\n"),
2054 zfs_get_name(zhp));
2055 ZFS_CLOSE(zhp);
2056 return (BE_ERR_ZFS);
2057 }
2058
2059 /*
2060 * If the mountpoint is not inherited and the mountpoint is not
2061 * 'legacy', this file system potentially needs its mountpoint
2062 * fixed.
2063 */
2064 if (!(sourcetype & ZPROP_SRC_INHERITED) &&
2065 strcmp(mountpoint, ZFS_MOUNTPOINT_LEGACY) != 0) {
2066
2067 /*
2068 * Check if this file system's current mountpoint is
2069 * under the altroot we're fixing it against.
2070 */
2071 if (strncmp(mountpoint, altroot, strlen(altroot)) == 0 &&
2072 mountpoint[strlen(altroot)] == '/') {
2073
2074 /*
2075 * Get this dataset's mountpoint relative to the
2076 * altroot.
2077 */
2078 zhp_mountpoint = mountpoint + strlen(altroot);
2079
2080 /* Fix this dataset's mountpoint value */
2081 if (zfs_prop_set(zhp,
2082 zfs_prop_to_name(ZFS_PROP_MOUNTPOINT),
2083 zhp_mountpoint)) {
2084 be_print_err(gettext("fix_mountpoint_callback: "
2085 "failed to set mountpoint for %s to "
2086 "%s: %s\n"), zfs_get_name(zhp),
2087 zhp_mountpoint,
2088 libzfs_error_description(g_zfs));
2089 ret = zfs_err_to_be_err(g_zfs);
2090 ZFS_CLOSE(zhp);
2091 return (ret);
2092 }
2093 }
2094 }
2095
2096 /* Iterate through this dataset's children and fix them */
2097 if ((ret = zfs_iter_filesystems(zhp, fix_mountpoint_callback,
2098 altroot)) != 0) {
2099 ZFS_CLOSE(zhp);
2100 return (ret);
2101 }
2102
2103
2104 ZFS_CLOSE(zhp);
2105 return (0);
2106 }
2107
2108 /*
2109 * Function: be_mount_root
2110 * Description: This function mounts the root dataset of a BE at the
2111 * specified altroot.
2112 * Parameters:
2113 * zhp - zfs_handle_t pointer to root dataset of a BE that is
2114 * to be mounted at altroot.
2115 * altroot - location of where to mount the BE root.
2116 * Return:
2117 * BE_SUCCESS - Success
2118 * be_errno_t - Failure
2119 * Scope:
2120 * Private
2121 */
2122 static int
2123 be_mount_root(zfs_handle_t *zhp, char *altroot)
2124 {
2125 char mountpoint[MAXPATHLEN];
2126
2127 /* Get mountpoint property of dataset */
2128 if (zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, mountpoint,
2129 sizeof (mountpoint), NULL, NULL, 0, B_FALSE) != 0) {
2130 be_print_err(gettext("be_mount_root: failed to "
2131 "get mountpoint property for %s: %s\n"), zfs_get_name(zhp),
2132 libzfs_error_description(g_zfs));
2133 return (zfs_err_to_be_err(g_zfs));
2134 }
2135
2136 /*
2137 * Set the canmount property for the BE's root dataset to 'noauto' just
2138 * in case it's been set to 'on'. We do this so that when we change its
2139 * mountpoint, zfs won't immediately try to mount it.
2140 */
2141 if (zfs_prop_set(zhp, zfs_prop_to_name(ZFS_PROP_CANMOUNT), "noauto")
2142 != 0) {
2143 be_print_err(gettext("be_mount_root: failed to "
2144 "set canmount property to 'noauto' (%s): %s\n"),
2145 zfs_get_name(zhp), libzfs_error_description(g_zfs));
2146 return (zfs_err_to_be_err(g_zfs));
2147 }
2148
2149 /* Set mountpoint for BE's root filesystem */
2150 if (zfs_prop_set(zhp, zfs_prop_to_name(ZFS_PROP_MOUNTPOINT), altroot)
2151 != 0) {
2152 be_print_err(gettext("be_mount_root: failed to "
2153 "set mountpoint of %s to %s: %s\n"),
2154 zfs_get_name(zhp), altroot,
2155 libzfs_error_description(g_zfs));
2156 return (zfs_err_to_be_err(g_zfs));
2157 }
2158
2159 /* Mount the BE's root filesystem */
2160 if (zfs_mount(zhp, NULL, 0) != 0) {
2161 be_print_err(gettext("be_mount_root: failed to "
2162 "mount dataset %s at %s: %s\n"), zfs_get_name(zhp),
2163 altroot, libzfs_error_description(g_zfs));
2164 /*
2165 * Set this BE's root filesystem 'mountpoint' property
2166 * back to what it was before.
2167 */
2168 (void) zfs_prop_set(zhp, zfs_prop_to_name(ZFS_PROP_MOUNTPOINT),
2169 mountpoint);
2170 return (zfs_err_to_be_err(g_zfs));
2171 }
2172
2173 return (BE_SUCCESS);
2174 }
2175
2176 /*
2177 * Function: be_unmount_root
2178 * Description: This function unmounts the root dataset of a BE, but before
2179 * unmounting, it looks at the BE's vfstab to determine
2180 * if the root dataset mountpoint should be left as 'legacy'
2181 * or '/'. If the vfstab contains an entry for this root
2182 * dataset with a mountpoint of '/', it sets the mountpoint
2183 * property to 'legacy'.
2184 *
2185 * Parameters:
2186 * zhp - zfs_handle_t pointer of the BE root dataset that
2187 * is currently mounted.
2188 * ud - be_unmount_data_t pointer providing unmount data
2189 * for the given BE root dataset.
2190 * Returns:
2191 * BE_SUCCESS - Success
2192 * be_errno_t - Failure
2193 * Scope:
2194 * Private
2195 */
2196 static int
2197 be_unmount_root(zfs_handle_t *zhp, be_unmount_data_t *ud)
2198 {
2199 char mountpoint[MAXPATHLEN];
2200 boolean_t is_legacy = B_FALSE;
2201
2202 /* See if this is a legacy mounted root */
2203 if (get_mountpoint_from_vfstab(ud->altroot, zfs_get_name(zhp),
2204 mountpoint, sizeof (mountpoint), B_FALSE) == BE_SUCCESS &&
2205 strcmp(mountpoint, "/") == 0) {
2206 is_legacy = B_TRUE;
2207 }
2208
2209 /* Unmount the dataset */
2210 if (zfs_unmount(zhp, NULL, ud->force ? MS_FORCE : 0) != 0) {
2211 be_print_err(gettext("be_unmount_root: failed to "
2212 "unmount BE root dataset %s: %s\n"), zfs_get_name(zhp),
2213 libzfs_error_description(g_zfs));
2214 return (zfs_err_to_be_err(g_zfs));
2215 }
2216
2217 /* Set canmount property for this BE's root filesystem to noauto */
2218 if (zfs_prop_set(zhp, zfs_prop_to_name(ZFS_PROP_CANMOUNT), "noauto")
2219 != 0) {
2220 be_print_err(gettext("be_unmount_root: failed to "
2221 "set canmount property for %s to 'noauto': %s\n"),
2222 zfs_get_name(zhp), libzfs_error_description(g_zfs));
2223 return (zfs_err_to_be_err(g_zfs));
2224 }
2225
2226 /*
2227 * Set mountpoint for BE's root dataset back to '/', or 'legacy'
2228 * if its a legacy mounted root.
2229 */
2230 if (zfs_prop_set(zhp, zfs_prop_to_name(ZFS_PROP_MOUNTPOINT),
2231 is_legacy ? ZFS_MOUNTPOINT_LEGACY : "/") != 0) {
2232 be_print_err(gettext("be_unmount_root: failed to "
2233 "set mountpoint of %s to %s\n"), zfs_get_name(zhp),
2234 is_legacy ? ZFS_MOUNTPOINT_LEGACY : "/");
2235 return (zfs_err_to_be_err(g_zfs));
2236 }
2237
2238 return (BE_SUCCESS);
2239 }
2240
2241 /*
2242 * Function: fix_mountpoint
2243 * Description: This function checks the mountpoint of an unmounted BE to make
2244 * sure that it is set to either 'legacy' or '/'. If it's not,
2245 * then we're in a situation where an unmounted BE has some random
2246 * mountpoint set for it. (This could happen if the system was
2247 * rebooted while an inactive BE was mounted). This function
2248 * attempts to fix its mountpoints.
2249 * Parameters:
2250 * zhp - zfs_handle_t pointer to root dataset of the BE
2251 * whose mountpoint needs to be checked.
2252 * Return:
2253 * BE_SUCCESS - Success
2254 * be_errno_t - Failure
2255 * Scope:
2256 * Private
2257 */
2258 static int
2259 fix_mountpoint(zfs_handle_t *zhp)
2260 {
2261 be_unmount_data_t ud = { 0 };
2262 char *altroot = NULL;
2263 char mountpoint[MAXPATHLEN];
2264 int ret = BE_SUCCESS;
2265
2266 /*
2267 * Record what this BE's root dataset mountpoint property is currently
2268 * set to.
2269 */
2270 if (zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, mountpoint,
2271 sizeof (mountpoint), NULL, NULL, 0, B_FALSE) != 0) {
2272 be_print_err(gettext("fix_mountpoint: failed to get "
2273 "mountpoint property of (%s): %s\n"), zfs_get_name(zhp),
2274 libzfs_error_description(g_zfs));
2275 return (BE_ERR_ZFS);
2276 }
2277
2278 /*
2279 * If the root dataset mountpoint is set to 'legacy' or '/', we're okay.
2280 */
2281 if (strcmp(mountpoint, ZFS_MOUNTPOINT_LEGACY) == 0 ||
2282 strcmp(mountpoint, "/") == 0) {
2283 return (BE_SUCCESS);
2284 }
2285
2286 /*
2287 * Iterate through this BE's children datasets and fix
2288 * them if they need fixing.
2289 */
2290 if (zfs_iter_filesystems(zhp, fix_mountpoint_callback, mountpoint)
2291 != 0) {
2292 return (BE_ERR_ZFS);
2293 }
2294
2295 /*
2296 * The process of mounting and unmounting the root file system
2297 * will fix its mountpoint to correctly be either 'legacy' or '/'
2298 * since be_unmount_root will do the right thing by looking at
2299 * its vfstab.
2300 */
2301
2302 /* Generate temporary altroot to mount the root file system */
2303 if ((ret = be_make_tmp_mountpoint(&altroot)) != BE_SUCCESS) {
2304 be_print_err(gettext("fix_mountpoint: failed to "
2305 "make temporary mountpoint\n"));
2306 return (ret);
2307 }
2308
2309 /* Mount and unmount the root. */
2310 if ((ret = be_mount_root(zhp, altroot)) != BE_SUCCESS) {
2311 be_print_err(gettext("fix_mountpoint: failed to "
2312 "mount BE root file system\n"));
2313 goto cleanup;
2314 }
2315 ud.altroot = altroot;
2316 if ((ret = be_unmount_root(zhp, &ud)) != BE_SUCCESS) {
2317 be_print_err(gettext("fix_mountpoint: failed to "
2318 "unmount BE root file system\n"));
2319 goto cleanup;
2320 }
2321
2322 cleanup:
2323 free(altroot);
2324
2325 return (ret);
2326 }
2327
2328 /*
2329 * Function: be_mount_zones
2330 * Description: This function finds all supported non-global zones in the
2331 * given global BE and mounts them with respect to where the
2332 * global BE is currently mounted. The global BE datasets
2333 * (including its shared datasets) are expected to already
2334 * be mounted.
2335 * Parameters:
2336 * be_zhp - zfs_handle_t pointer to the root dataset of the
2337 * global BE.
2338 * md - be_mount_data_t pointer to data for global BE.
2339 * Returns:
2340 * BE_SUCCESS - Success
2341 * be_errno_t - Failure
2342 * Scope:
2343 * Private
2344 */
2345 static int
2346 be_mount_zones(zfs_handle_t *be_zhp, be_mount_data_t *md)
2347 {
2348 zoneBrandList_t *brands = NULL;
2349 zoneList_t zlst = NULL;
2350 char *zonename = NULL;
2351 char *zonepath = NULL;
2352 char *zonepath_ds = NULL;
2353 int k;
2354 int ret = BE_SUCCESS;
2355
2356 z_set_zone_root(md->altroot);
2357
2358 if ((brands = be_get_supported_brandlist()) == NULL) {
2359 be_print_err(gettext("be_mount_zones: "
2360 "no supported brands\n"));
2361 return (BE_SUCCESS);
2362 }
2363
2364 zlst = z_get_nonglobal_zone_list_by_brand(brands);
2365 if (zlst == NULL) {
2366 z_free_brand_list(brands);
2367 return (BE_SUCCESS);
2368 }
2369
2370 for (k = 0; (zonename = z_zlist_get_zonename(zlst, k)) != NULL; k++) {
2371 if (z_zlist_get_current_state(zlst, k) ==
2372 ZONE_STATE_INSTALLED) {
2373 zonepath = z_zlist_get_zonepath(zlst, k);
2374
2375 /*
2376 * Get the dataset of this zonepath in current BE.
2377 * If its not a dataset, skip it.
2378 */
2379 if ((zonepath_ds = be_get_ds_from_dir(zonepath))
2380 == NULL)
2381 continue;
2382
2383 /*
2384 * Check if this zone is supported based on
2385 * the dataset of its zonepath
2386 */
2387 if (!be_zone_supported(zonepath_ds)) {
2388 free(zonepath_ds);
2389 zonepath_ds = NULL;
2390 continue;
2391 }
2392
2393 /*
2394 * if BE's shared file systems are already mounted,
2395 * zone path dataset would have already been lofs
2396 * mounted under altroot. Otherwise, we need to do
2397 * it here.
2398 */
2399 if (!md->shared_fs) {
2400 ret = loopback_mount_zonepath(zonepath, md);
2401 if (ret != BE_SUCCESS)
2402 goto done;
2403 }
2404
2405
2406 /* Mount this zone */
2407 ret = be_mount_one_zone(be_zhp, md, zonename,
2408 zonepath, zonepath_ds);
2409
2410 free(zonepath_ds);
2411 zonepath_ds = NULL;
2412
2413 if (ret != BE_SUCCESS) {
2414 be_print_err(gettext("be_mount_zones: "
2415 "failed to mount zone %s under "
2416 "altroot %s\n"), zonename, md->altroot);
2417 goto done;
2418 }
2419 }
2420 }
2421
2422 done:
2423 z_free_brand_list(brands);
2424 z_free_zone_list(zlst);
2425 /*
2426 * libinstzones caches mnttab and uses cached version for resolving lofs
2427 * mounts when we call z_resolve_lofs. It creates the cached version
2428 * when the first call to z_resolve_lofs happens. So, library's cached
2429 * mnttab doesn't contain entries for lofs mounts created in the above
2430 * loop. Because of this, subsequent calls to z_resolve_lofs would fail
2431 * to resolve these lofs mounts. So, here we destroy library's cached
2432 * mnttab to force its recreation when the next call to z_resolve_lofs
2433 * happens.
2434 */
2435 z_destroyMountTable();
2436 return (ret);
2437 }
2438
2439 /*
2440 * Function: be_unmount_zones
2441 * Description: This function finds all supported non-global zones in the
2442 * given mounted global BE and unmounts them.
2443 * Parameters:
2444 * ud - unmount_data_t pointer data for the global BE.
2445 * Returns:
2446 * BE_SUCCESS - Success
2447 * be_errno_t - Failure
2448 * Scope:
2449 * Private
2450 */
2451 static int
2452 be_unmount_zones(be_unmount_data_t *ud)
2453 {
2454 zoneBrandList_t *brands = NULL;
2455 zoneList_t zlst = NULL;
2456 char *zonename = NULL;
2457 char *zonepath = NULL;
2458 char alt_zonepath[MAXPATHLEN];
2459 char *zonepath_ds = NULL;
2460 int k;
2461 int ret = BE_SUCCESS;
2462
2463 z_set_zone_root(ud->altroot);
2464
2465 if ((brands = be_get_supported_brandlist()) == NULL) {
2466 be_print_err(gettext("be_unmount_zones: "
2467 "no supported brands\n"));
2468 return (BE_SUCCESS);
2469 }
2470
2471 zlst = z_get_nonglobal_zone_list_by_brand(brands);
2472 if (zlst == NULL) {
2473 z_free_brand_list(brands);
2474 return (BE_SUCCESS);
2475 }
2476
2477 for (k = 0; (zonename = z_zlist_get_zonename(zlst, k)) != NULL; k++) {
2478 if (z_zlist_get_current_state(zlst, k) ==
2479 ZONE_STATE_INSTALLED) {
2480 zonepath = z_zlist_get_zonepath(zlst, k);
2481
2482 /* Build zone's zonepath wrt the global BE altroot */
2483 (void) snprintf(alt_zonepath, sizeof (alt_zonepath),
2484 "%s%s", ud->altroot, zonepath);
2485
2486 /*
2487 * Get the dataset of this zonepath. If its not
2488 * a dataset, skip it.
2489 */
2490 if ((zonepath_ds = be_get_ds_from_dir(alt_zonepath))
2491 == NULL)
2492 continue;
2493
2494 /*
2495 * Check if this zone is supported based on the
2496 * dataset of its zonepath.
2497 */
2498 if (!be_zone_supported(zonepath_ds)) {
2499 free(zonepath_ds);
2500 zonepath_ds = NULL;
2501 continue;
2502 }
2503
2504 /* Unmount this zone */
2505 ret = be_unmount_one_zone(ud, zonename, zonepath,
2506 zonepath_ds);
2507
2508 free(zonepath_ds);
2509 zonepath_ds = NULL;
2510
2511 if (ret != BE_SUCCESS) {
2512 be_print_err(gettext("be_unmount_zones:"
2513 " failed to unmount zone %s from "
2514 "altroot %s\n"), zonename, ud->altroot);
2515 goto done;
2516 }
2517 }
2518 }
2519
2520 done:
2521 z_free_brand_list(brands);
2522 z_free_zone_list(zlst);
2523 return (ret);
2524 }
2525
2526 /*
2527 * Function: be_mount_one_zone
2528 * Description: This function is called to mount one zone for a given
2529 * global BE.
2530 * Parameters:
2531 * be_zhp - zfs_handle_t pointer to the root dataset of the
2532 * global BE
2533 * md - be_mount_data_t pointer to data for global BE
2534 * zonename - name of zone to mount
2535 * zonepath - zonepath of zone to mount
2536 * zonepath_ds - dataset for the zonepath
2537 * Returns:
2538 * BE_SUCCESS - Success
2539 * be_errno_t - Failure
2540 * Scope:
2541 * Private
2542 */
2543 static int
2544 be_mount_one_zone(zfs_handle_t *be_zhp, be_mount_data_t *md, char *zonename,
2545 char *zonepath, char *zonepath_ds)
2546 {
2547 be_mount_data_t zone_md = { 0 };
2548 zfs_handle_t *zone_zhp = NULL;
2549 char zone_altroot[MAXPATHLEN];
2550 char zoneroot[MAXPATHLEN];
2551 char zoneroot_ds[MAXPATHLEN];
2552 int ret = BE_SUCCESS;
2553
2554 /* Find the active zone root dataset for this zone for this BE */
2555 if ((ret = be_find_active_zone_root(be_zhp, zonepath_ds, zoneroot_ds,
2556 sizeof (zoneroot_ds))) == BE_ERR_ZONE_NO_ACTIVE_ROOT) {
2557 be_print_err(gettext("be_mount_one_zone: did not "
2558 "find active zone root for zone %s, skipping ...\n"),
2559 zonename);
2560 return (BE_SUCCESS);
2561 } else if (ret != BE_SUCCESS) {
2562 be_print_err(gettext("be_mount_one_zone: failed to "
2563 "find active zone root for zone %s\n"), zonename);
2564 return (ret);
2565 }
2566
2567 /* Get handle to active zoneroot dataset */
2568 if ((zone_zhp = zfs_open(g_zfs, zoneroot_ds, ZFS_TYPE_FILESYSTEM))
2569 == NULL) {
2570 be_print_err(gettext("be_mount_one_zone: failed to "
2571 "open zone root dataset (%s): %s\n"), zoneroot_ds,
2572 libzfs_error_description(g_zfs));
2573 return (zfs_err_to_be_err(g_zfs));
2574 }
2575
2576 /* Generate string for zone's altroot path */
2577 be_make_zoneroot(zonepath, zoneroot, sizeof (zoneroot));
2578 (void) strlcpy(zone_altroot, md->altroot, sizeof (zone_altroot));
2579 (void) strlcat(zone_altroot, zoneroot, sizeof (zone_altroot));
2580
2581 /* Build mount_data for the zone */
2582 zone_md.altroot = zone_altroot;
2583 zone_md.shared_fs = md->shared_fs;
2584 zone_md.shared_rw = md->shared_rw;
2585
2586 /* Mount the zone's root file system */
2587 if ((ret = be_mount_zone_root(zone_zhp, &zone_md)) != BE_SUCCESS) {
2588 be_print_err(gettext("be_mount_one_zone: failed to "
2589 "mount zone root file system at %s\n"), zone_altroot);
2590 goto done;
2591 }
2592
2593 /* Iterate through zone's children filesystems */
2594 if ((ret = zfs_iter_filesystems(zone_zhp, be_mount_callback,
2595 zone_altroot)) != 0) {
2596 be_print_err(gettext("be_mount_one_zone: failed to "
2597 "mount zone subordinate file systems at %s\n"),
2598 zone_altroot);
2599 goto done;
2600 }
2601
2602 /* TODO: Mount all shared file systems for this zone */
2603
2604 done:
2605 ZFS_CLOSE(zone_zhp);
2606 return (ret);
2607 }
2608
2609 /*
2610 * Function: be_unmount_one_zone
2611 * Description: This function unmount one zone for a give global BE.
2612 * Parameters:
2613 * ud - be_unmount_data_t pointer to data for global BE
2614 * zonename - name of zone to unmount
2615 * zonepath - zonepath of the zone to unmount
2616 * zonepath_ds - dataset for the zonepath
2617 * Returns:
2618 * BE_SUCCESS - Success
2619 * be_errno_t - Failure
2620 * Scope:
2621 * Private
2622 */
2623 static int
2624 be_unmount_one_zone(be_unmount_data_t *ud, char *zonename, char *zonepath,
2625 char *zonepath_ds)
2626 {
2627 be_unmount_data_t zone_ud = { 0 };
2628 zfs_handle_t *zone_zhp = NULL;
2629 char zone_altroot[MAXPATHLEN];
2630 char zoneroot[MAXPATHLEN];
2631 char zoneroot_ds[MAXPATHLEN];
2632 int ret = BE_SUCCESS;
2633
2634 /* Generate string for zone's alternate root path */
2635 be_make_zoneroot(zonepath, zoneroot, sizeof (zoneroot));
2636 (void) strlcpy(zone_altroot, ud->altroot, sizeof (zone_altroot));
2637 (void) strlcat(zone_altroot, zoneroot, sizeof (zone_altroot));
2638
2639 /* Build be_unmount_data for zone */
2640 zone_ud.altroot = zone_altroot;
2641 zone_ud.force = ud->force;
2642
2643 /* Find the mounted zone root dataset for this zone for this BE */
2644 if ((ret = be_find_mounted_zone_root(zone_altroot, zonepath_ds,
2645 zoneroot_ds, sizeof (zoneroot_ds))) == BE_ERR_NO_MOUNTED_ZONE) {
2646 be_print_err(gettext("be_unmount_one_zone: did not "
2647 "find any zone root mounted for zone %s\n"), zonename);
2648 return (BE_SUCCESS);
2649 } else if (ret != BE_SUCCESS) {
2650 be_print_err(gettext("be_unmount_one_zone: failed to "
2651 "find mounted zone root for zone %s\n"), zonename);
2652 return (ret);
2653 }
2654
2655 /* Get handle to zoneroot dataset mounted for this BE */
2656 if ((zone_zhp = zfs_open(g_zfs, zoneroot_ds, ZFS_TYPE_FILESYSTEM))
2657 == NULL) {
2658 be_print_err(gettext("be_unmount_one_zone: failed to "
2659 "open mounted zone root dataset (%s): %s\n"), zoneroot_ds,
2660 libzfs_error_description(g_zfs));
2661 return (zfs_err_to_be_err(g_zfs));
2662 }
2663
2664 /* TODO: Unmount all shared file systems for this zone */
2665
2666 /* Iterate through zone's children filesystems and unmount them */
2667 if ((ret = zfs_iter_filesystems(zone_zhp, be_unmount_callback,
2668 &zone_ud)) != 0) {
2669 be_print_err(gettext("be_unmount_one_zone: failed to "
2670 "unmount zone subordinate file systems at %s\n"),
2671 zone_altroot);
2672 goto done;
2673 }
2674
2675 /* Unmount the zone's root filesystem */
2676 if ((ret = be_unmount_zone_root(zone_zhp, &zone_ud)) != BE_SUCCESS) {
2677 be_print_err(gettext("be_unmount_one_zone: failed to "
2678 "unmount zone root file system at %s\n"), zone_altroot);
2679 goto done;
2680 }
2681
2682 done:
2683 ZFS_CLOSE(zone_zhp);
2684 return (ret);
2685 }
2686
2687 /*
2688 * Function: be_get_ds_from_dir_callback
2689 * Description: This is a callback function used to iterate all datasets
2690 * to find the one that is currently mounted at the directory
2691 * being searched for. If matched, the name of the dataset is
2692 * returned in heap storage, so the caller is responsible for
2693 * freeing it.
2694 * Parameters:
2695 * zhp - zfs_handle_t pointer to current dataset being processed.
2696 * data - dir_data_t pointer providing name of directory being
2697 * searched for.
2698 * Returns:
2699 * 1 - This dataset is mounted at directory being searched for.
2700 * 0 - This dataset is not mounted at directory being searched for.
2701 * Scope:
2702 * Private
2703 */
2704 static int
2705 be_get_ds_from_dir_callback(zfs_handle_t *zhp, void *data)
2706 {
2707 dir_data_t *dd = data;
2708 char *mp = NULL;
2709 int zret = 0;
2710
2711 if (zfs_get_type(zhp) != ZFS_TYPE_FILESYSTEM) {
2712 ZFS_CLOSE(zhp);
2713 return (0);
2714 }
2715
2716 if (zfs_is_mounted(zhp, &mp) && mp != NULL &&
2717 strcmp(mp, dd->dir) == 0) {
2718 if ((dd->ds = strdup(zfs_get_name(zhp))) == NULL) {
2719 be_print_err(gettext("be_get_ds_from_dir_callback: "
2720 "memory allocation failed\n"));
2721 ZFS_CLOSE(zhp);
2722 return (0);
2723 }
2724 ZFS_CLOSE(zhp);
2725 return (1);
2726 }
2727
2728 zret = zfs_iter_filesystems(zhp, be_get_ds_from_dir_callback, dd);
2729
2730 ZFS_CLOSE(zhp);
2731
2732 return (zret);
2733 }