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 /*
27 * Copyright 2013 Nexenta Systems, Inc. All rights reserved.
28 */
29
30 /*
31 * System includes
32 */
33 #include <assert.h>
34 #include <errno.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 <unistd.h>
48
49 #include <libbe.h>
50 #include <libbe_priv.h>
51
52 typedef struct active_zone_root_data {
53 uuid_t parent_uuid;
54 char *zoneroot_ds;
55 } active_zone_root_data_t;
56
57 typedef struct mounted_zone_root_data {
58 char *zone_altroot;
59 char *zoneroot_ds;
60 } mounted_zone_root_data_t;
61
62 /* Private function prototypes */
63 static int be_find_active_zone_root_callback(zfs_handle_t *, void *);
64 static int be_find_mounted_zone_root_callback(zfs_handle_t *, void *);
65 static boolean_t be_zone_get_active(zfs_handle_t *);
66
67
68 /* ******************************************************************** */
69 /* Semi-Private Functions */
70 /* ******************************************************************** */
71
72 /*
73 * Function: be_make_zoneroot
74 * Description: Generate a string for a zone's zoneroot given the
75 * zone's zonepath.
76 * Parameters:
77 * zonepath - pointer to zonepath
78 * zoneroot - pointer to buffer to retrn zoneroot in.
79 * zoneroot_size - size of zoneroot
80 * Returns:
81 * None
82 * Scope:
83 * Semi-private (library wise use only)
84 */
85 void
86 be_make_zoneroot(char *zonepath, char *zoneroot, int zoneroot_size)
87 {
88 (void) snprintf(zoneroot, zoneroot_size, "%s/root", zonepath);
89 }
90
91 /*
92 * Function: be_find_active_zone_root
93 * Description: This function will find the active zone root of a zone for
94 * a given global BE. It will iterate all of the zone roots
95 * under a zonepath, find the zone roots that belong to the
96 * specified global BE, and return the one that is active.
97 * Parameters:
98 * be_zhp - zfs handle to global BE root dataset.
99 * zonepath_ds - pointer to zone's zonepath dataset.
100 * zoneroot_ds - pointer to a buffer to store the dataset name of
101 * the zone's zoneroot that's currently active for this
102 * given global BE..
103 * zoneroot-ds_size - size of zoneroot_ds.
104 * Returns:
105 * BE_SUCCESS - Success
106 * be_errno_t - Failure
107 * Scope:
108 * Semi-private (library wide use only)
109 */
110 int
111 be_find_active_zone_root(zfs_handle_t *be_zhp, char *zonepath_ds,
112 char *zoneroot_ds, int zoneroot_ds_size)
113 {
114 active_zone_root_data_t azr_data = { 0 };
115 zfs_handle_t *zhp;
116 char zone_container_ds[MAXPATHLEN];
117 int ret = BE_SUCCESS;
118
119 /* Get the uuid of the parent global BE */
120 if (getzoneid() == GLOBAL_ZONEID) {
121 if ((ret = be_get_uuid(zfs_get_name(be_zhp),
122 &azr_data.parent_uuid)) != BE_SUCCESS) {
123 be_print_err(gettext("be_find_active_zone_root: failed "
124 "to get uuid for BE root dataset %s\n"),
125 zfs_get_name(be_zhp));
126 return (ret);
127 }
128 } else {
129 if ((ret = be_zone_get_parent_uuid(zfs_get_name(be_zhp),
130 &azr_data.parent_uuid)) != BE_SUCCESS) {
131 be_print_err(gettext("be_find_active_zone_root: failed "
132 "to get parentbe uuid for zone root dataset %s\n"),
133 zfs_get_name(be_zhp));
134 return (ret);
135 }
136 }
137
138 /* Generate string for the root container dataset for this zone. */
139 be_make_container_ds(zonepath_ds, zone_container_ds,
140 sizeof (zone_container_ds));
141
142 /* Get handle to this zone's root container dataset */
143 if ((zhp = zfs_open(g_zfs, zone_container_ds, ZFS_TYPE_FILESYSTEM))
144 == NULL) {
145 be_print_err(gettext("be_find_active_zone_root: failed to "
146 "open zone root container dataset (%s): %s\n"),
147 zone_container_ds, libzfs_error_description(g_zfs));
148 return (zfs_err_to_be_err(g_zfs));
149 }
150
151 /*
152 * Iterate through all of this zone's BEs, looking for ones
153 * that belong to the parent global BE, and finding the one
154 * that is marked active.
155 */
156 if ((ret = zfs_iter_filesystems(zhp, be_find_active_zone_root_callback,
157 &azr_data)) != 0) {
158 be_print_err(gettext("be_find_active_zone_root: failed to "
159 "find active zone root in zonepath dataset %s: %s\n"),
160 zonepath_ds, be_err_to_str(ret));
161 goto done;
162 }
163
164 if (azr_data.zoneroot_ds != NULL) {
165 (void) strlcpy(zoneroot_ds, azr_data.zoneroot_ds,
166 zoneroot_ds_size);
167 free(azr_data.zoneroot_ds);
168 } else {
169 be_print_err(gettext("be_find_active_zone_root: failed to "
170 "find active zone root in zonepath dataset %s\n"),
171 zonepath_ds);
172 ret = BE_ERR_ZONE_NO_ACTIVE_ROOT;
173 }
174
175 done:
176 ZFS_CLOSE(zhp);
177 return (ret);
178 }
179
180 /*
181 * Function: be_find_mounted_zone_root
182 * Description: This function will find the dataset mounted as the zoneroot
183 * of a zone for a given mounted global BE.
184 * Parameters:
185 * zone_altroot - path of zoneroot wrt the mounted global BE.
186 * zonepath_ds - dataset of the zone's zonepath.
187 * zoneroot_ds - pointer to a buffer to store the dataset of
188 * the zoneroot that currently mounted for this zone
189 * in the mounted global BE.
190 * zoneroot_ds_size - size of zoneroot_ds
191 * Returns:
192 * BE_SUCCESS - Success
193 * be_errno_t - Failure
194 * Scope:
195 * Semi-private (library wide use only)
196 */
197 int
198 be_find_mounted_zone_root(char *zone_altroot, char *zonepath_ds,
199 char *zoneroot_ds, int zoneroot_ds_size)
200 {
201 mounted_zone_root_data_t mzr_data = { 0 };
202 zfs_handle_t *zhp = NULL;
203 char zone_container_ds[MAXPATHLEN];
204 int ret = BE_SUCCESS;
205 int zret = 0;
206
207 /* Generate string for the root container dataset for this zone. */
208 be_make_container_ds(zonepath_ds, zone_container_ds,
209 sizeof (zone_container_ds));
210
211 /* Get handle to this zone's root container dataset. */
212 if ((zhp = zfs_open(g_zfs, zone_container_ds, ZFS_TYPE_FILESYSTEM))
213 == NULL) {
214 be_print_err(gettext("be_find_mounted_zone_root: failed to "
215 "open zone root container dataset (%s): %s\n"),
216 zone_container_ds, libzfs_error_description(g_zfs));
217 return (zfs_err_to_be_err(g_zfs));
218 }
219
220 mzr_data.zone_altroot = zone_altroot;
221
222 /*
223 * Iterate through all of the zone's BEs, looking for the one
224 * that is currently mounted at the zone altroot in the mounted
225 * global BE.
226 */
227 if ((zret = zfs_iter_filesystems(zhp,
228 be_find_mounted_zone_root_callback, &mzr_data)) == 0) {
229 be_print_err(gettext("be_find_mounted_zone_root: did not "
230 "find mounted zone under altroot zonepath %s\n"),
231 zonepath_ds);
232 ret = BE_ERR_NO_MOUNTED_ZONE;
233 goto done;
234 } else if (zret < 0) {
235 be_print_err(gettext("be_find_mounted_zone_root: "
236 "zfs_iter_filesystems failed: %s\n"),
237 libzfs_error_description(g_zfs));
238 ret = zfs_err_to_be_err(g_zfs);
239 goto done;
240 }
241
242 if (mzr_data.zoneroot_ds != NULL) {
243 (void) strlcpy(zoneroot_ds, mzr_data.zoneroot_ds,
244 zoneroot_ds_size);
245 free(mzr_data.zoneroot_ds);
246 }
247
248 done:
249 ZFS_CLOSE(zhp);
250 return (ret);
251 }
252
253 /*
254 * Function: be_zone_supported
255 * Description: This function will determine if a zone is supported
256 * based on its zonepath dataset. The zonepath dataset
257 * must:
258 * - not be under any global BE root dataset.
259 * - have a root container dataset underneath it.
260 *
261 * Parameters:
262 * zonepath_ds - name of dataset of the zonepath of the
263 * zone to check.
264 * Returns:
265 * B_TRUE - zone is supported
266 * B_FALSE - zone is not supported
267 * Scope:
268 * Semi-private (library wide use only)
269 */
270 boolean_t
271 be_zone_supported(char *zonepath_ds)
272 {
273 char zone_container_ds[MAXPATHLEN];
274 int ret = 0;
275
276 /*
277 * Make sure the dataset for the zonepath is not hierarchically
278 * under any reserved BE root container dataset of any pool.
279 */
280 if ((ret = zpool_iter(g_zfs, be_check_be_roots_callback,
281 zonepath_ds)) > 0) {
282 be_print_err(gettext("be_zone_supported: "
283 "zonepath dataset %s not supported\n"), zonepath_ds);
284 return (B_FALSE);
285 } else if (ret < 0) {
286 be_print_err(gettext("be_zone_supported: "
287 "zpool_iter failed: %s\n"),
288 libzfs_error_description(g_zfs));
289 return (B_FALSE);
290 }
291
292 /*
293 * Make sure the zonepath has a zone root container dataset
294 * underneath it.
295 */
296 be_make_container_ds(zonepath_ds, zone_container_ds,
297 sizeof (zone_container_ds));
298
299 if (!zfs_dataset_exists(g_zfs, zone_container_ds,
300 ZFS_TYPE_FILESYSTEM)) {
301 be_print_err(gettext("be_zone_supported: "
302 "zonepath dataset (%s) does not have a zone root container "
303 "dataset, zone is not supported, skipping ...\n"),
304 zonepath_ds);
305 return (B_FALSE);
306 }
307
308 return (B_TRUE);
309 }
310
311 /*
312 * Function: be_get_supported_brandlist
313 * Desciption: This functions retuns a list of supported brands in
314 * a zoneBrandList_t object.
315 * Parameters:
316 * None
317 * Returns:
318 * Failure - NULL if no supported brands found.
319 * Success - pointer to zoneBrandList structure.
320 * Scope:
321 * Semi-private (library wide use only)
322 */
323 zoneBrandList_t *
324 be_get_supported_brandlist(void)
325 {
326 return (z_make_brand_list(BE_ZONE_SUPPORTED_BRANDS,
327 BE_ZONE_SUPPORTED_BRANDS_DELIM));
328 }
329
330 /*
331 * Function: be_zone_get_parent_uuid
332 * Description: This function gets the parentbe property of a zone root
333 * dataset, parsed it into internal uuid format, and returns
334 * it in the uuid_t reference pointer passed in.
335 * Parameters:
336 * root_ds - dataset name of a zone root dataset
337 * uu - pointer to a uuid_t to return the parentbe uuid in
338 * Returns:
339 * BE_SUCCESS - Success
340 * be_errno_t - Failure
341 * Scope:
342 * Private
343 */
344 int
345 be_zone_get_parent_uuid(const char *root_ds, uuid_t *uu)
346 {
347 zfs_handle_t *zhp = NULL;
348 nvlist_t *userprops = NULL;
349 nvlist_t *propname = NULL;
350 char *uu_string = NULL;
351 int ret = BE_SUCCESS;
352
353 /* Get handle to zone root dataset */
354 if ((zhp = zfs_open(g_zfs, root_ds, ZFS_TYPE_FILESYSTEM)) == NULL) {
355 be_print_err(gettext("be_zone_get_parent_uuid: failed to "
356 "open zone root dataset (%s): %s\n"), root_ds,
357 libzfs_error_description(g_zfs));
358 return (zfs_err_to_be_err(g_zfs));
359 }
360
361 /* Get user properties for zone root dataset */
362 if ((userprops = zfs_get_user_props(zhp)) == NULL) {
363 be_print_err(gettext("be_zone_get_parent_uuid: "
364 "failed to get user properties for zone root "
365 "dataset (%s): %s\n"), root_ds,
366 libzfs_error_description(g_zfs));
367 ret = zfs_err_to_be_err(g_zfs);
368 goto done;
369 }
370
371 /* Get UUID string from zone's root dataset user properties */
372 if (nvlist_lookup_nvlist(userprops, BE_ZONE_PARENTBE_PROPERTY,
373 &propname) != 0 || nvlist_lookup_string(propname, ZPROP_VALUE,
374 &uu_string) != 0) {
375 be_print_err(gettext("be_zone_get_parent_uuid: failed to "
376 "get parent uuid property from zone root dataset user "
377 "properties.\n"));
378 ret = BE_ERR_ZONE_NO_PARENTBE;
379 goto done;
380 }
381
382 /* Parse the uuid string into internal format */
383 if (uuid_parse(uu_string, *uu) != 0 || uuid_is_null(*uu)) {
384 be_print_err(gettext("be_zone_get_parent_uuid: failed to "
385 "parse parentuuid\n"));
386 ret = BE_ERR_PARSE_UUID;
387 }
388
389 done:
390 ZFS_CLOSE(zhp);
391 return (ret);
392 }
393
394 /*
395 * Function: be_zone_set_parent_uuid
396 * Description: This function sets parentbe uuid into
397 * a zfs user property for a root zone dataset.
398 * Parameters:
399 * root_ds - Root zone dataset of the BE to set a uuid on.
400 * Return:
401 * be_errno_t - Failure
402 * BE_SUCCESS - Success
403 * Scope:
404 * Semi-private (library wide uses only)
405 */
406 int
407 be_zone_set_parent_uuid(char *root_ds, uuid_t uu)
408 {
409 zfs_handle_t *zhp = NULL;
410 char uu_string[UUID_PRINTABLE_STRING_LENGTH];
411 int ret = BE_SUCCESS;
412
413 uuid_unparse(uu, uu_string);
414
415 /* Get handle to the root zone dataset. */
416 if ((zhp = zfs_open(g_zfs, root_ds, ZFS_TYPE_FILESYSTEM)) == NULL) {
417 be_print_err(gettext("be_zone_set_parent_uuid: failed to "
418 "open root zone dataset (%s): %s\n"), root_ds,
419 libzfs_error_description(g_zfs));
420 return (zfs_err_to_be_err(g_zfs));
421 }
422
423 /* Set parentbe uuid property for the root zone dataset */
424 if (zfs_prop_set(zhp, BE_ZONE_PARENTBE_PROPERTY, uu_string) != 0) {
425 be_print_err(gettext("be_zone_set_parent_uuid: failed to "
426 "set parentbe uuid property for root zone dataset: %s\n"),
427 libzfs_error_description(g_zfs));
428 ret = zfs_err_to_be_err(g_zfs);
429 }
430
431 ZFS_CLOSE(zhp);
432 return (ret);
433 }
434
435 /*
436 * Function: be_zone_compare_uuids
437 * Description: This function compare the parentbe uuid of the
438 * current running root zone dataset with the parentbe
439 * uuid of the given root zone dataset.
440 * Parameters:
441 * root_ds - Root zone dataset of the BE to compare.
442 * Return:
443 * B_TRUE - root dataset has right parentbe uuid
444 * B_FALSE - root dataset has wrong parentbe uuid
445 * Scope:
446 * Semi-private (library wide uses only)
447 */
448 boolean_t
449 be_zone_compare_uuids(char *root_ds)
450 {
451 char *active_ds;
452 uuid_t parent_uuid = {0};
453 uuid_t cur_parent_uuid = {0};
454
455 /* Get parentbe uuid from given zone root dataset */
456 if ((be_zone_get_parent_uuid(root_ds,
457 &parent_uuid)) != BE_SUCCESS) {
458 be_print_err(gettext("be_zone_compare_uuids: failed to get "
459 "parentbe uuid from the given BE\n"));
460 return (B_FALSE);
461 }
462
463 /*
464 * Find current running zone root dataset and get it's parentbe
465 * uuid property.
466 */
467 if ((active_ds = be_get_ds_from_dir("/")) != NULL) {
468 if ((be_zone_get_parent_uuid(active_ds,
469 &cur_parent_uuid)) != BE_SUCCESS) {
470 be_print_err(gettext("be_zone_compare_uuids: failed "
471 "to get parentbe uuid from the current running zone "
472 "root dataset\n"));
473 return (B_FALSE);
474 }
475 } else {
476 be_print_err(gettext("be_zone_compare_uuids: zone root dataset "
477 "is not mounted\n"));
478 return (B_FALSE);
479 }
480
481 if (uuid_compare(parent_uuid, cur_parent_uuid) != 0) {
482 return (B_FALSE);
483 }
484
485 return (B_TRUE);
486 }
487
488 /* ******************************************************************** */
489 /* Private Functions */
490 /* ******************************************************************** */
491
492 /*
493 * Function: be_find_active_zone_root_callback
494 * Description: This function is used as a callback to iterate over all of
495 * a zone's root datasets, finding the one that is marked active
496 * for the parent BE specified in the data passed in. The name
497 * of the zone's active root dataset is returned in heap storage
498 * in the active_zone_root_data_t structure passed in, so the
499 * caller is responsible for freeing it.
500 * Parameters:
501 * zhp - zfs_handle_t pointer to current dataset being processed
502 * data - active_zone_root_data_t pointer
503 * Returns:
504 * 0 - Success
505 * >0 - Failure
506 * Scope:
507 * Private
508 */
509 static int
510 be_find_active_zone_root_callback(zfs_handle_t *zhp, void *data)
511 {
512 active_zone_root_data_t *azr_data = data;
513 uuid_t parent_uuid = { 0 };
514 int iret = 0;
515 int ret = 0;
516
517 if ((iret = be_zone_get_parent_uuid(zfs_get_name(zhp), &parent_uuid))
518 != BE_SUCCESS) {
519 be_print_err(gettext("be_find_active_zone_root_callback: "
520 "skipping zone root dataset (%s): %s\n"),
521 zfs_get_name(zhp), be_err_to_str(iret));
522 goto done;
523 }
524
525 if (uuid_compare(azr_data->parent_uuid, parent_uuid) == 0) {
526 /*
527 * Found a zone root dataset belonging to the right parent,
528 * check if its active.
529 */
530 if (be_zone_get_active(zhp)) {
531 /*
532 * Found active zone root dataset, if its already
533 * set in the callback data, that means this
534 * is the second one we've found. Return error.
535 */
536 if (azr_data->zoneroot_ds != NULL) {
537 ret = BE_ERR_ZONE_MULTIPLE_ACTIVE;
538 goto done;
539 }
540
541 azr_data->zoneroot_ds = strdup(zfs_get_name(zhp));
542 if (azr_data->zoneroot_ds == NULL) {
543 ret = BE_ERR_NOMEM;
544 }
545 }
546 }
547
548 done:
549 ZFS_CLOSE(zhp);
550 return (ret);
551 }
552
553 /*
554 * Function: be_find_mounted_zone_root_callback
555 * Description: This function is used as a callback to iterate over all of
556 * a zone's root datasets, find the one that is currently
557 * mounted for the parent BE specified in the data passed in.
558 * The name of the zone's mounted root dataset is returned in
559 * heap storage the mounted_zone_data_t structure passed in,
560 * so the caller is responsible for freeing it.
561 * Parameters:
562 * zhp - zfs_handle_t pointer to the current dataset being
563 * processed
564 * data - mounted_zone_data_t pointer
565 * Returns:
566 * 0 - not mounted as zone's root
567 * 1 - this dataset is mounted as zone's root
568 * Scope:
569 * Private
570 */
571 static int
572 be_find_mounted_zone_root_callback(zfs_handle_t *zhp, void *data)
573 {
574 mounted_zone_root_data_t *mzr_data = data;
575 char *mp = NULL;
576
577 if (zfs_is_mounted(zhp, &mp) && mp != NULL &&
578 strcmp(mp, mzr_data->zone_altroot) == 0) {
579 mzr_data->zoneroot_ds = strdup(zfs_get_name(zhp));
580 free(mp);
581 return (1);
582 }
583
584 free(mp);
585 return (0);
586 }
587
588 /*
589 * Function: be_zone_get_active
590 * Description: This function gets the active property of a zone root
591 * dataset, and returns true if active property is on.
592 * Parameters:
593 * zfs - zfs_handle_t pointer to zone root dataset to check
594 * Returns:
595 * B_TRUE - zone root dataset is active
596 * B_FALSE - zone root dataset is not active
597 * Scope:
598 * Private
599 */
600 static boolean_t
601 be_zone_get_active(zfs_handle_t *zhp)
602 {
603 nvlist_t *userprops = NULL;
604 nvlist_t *propname = NULL;
605 char *active_str = NULL;
606
607 /* Get user properties for the zone root dataset */
608 if ((userprops = zfs_get_user_props(zhp)) == NULL) {
609 be_print_err(gettext("be_zone_get_active: "
610 "failed to get user properties for zone root "
611 "dataset (%s): %s\n"), zfs_get_name(zhp),
612 libzfs_error_description(g_zfs));
613 return (B_FALSE);
614 }
615
616 /* Get active property from the zone root dataset user properties */
617 if (nvlist_lookup_nvlist(userprops, BE_ZONE_ACTIVE_PROPERTY, &propname)
618 != 0 || nvlist_lookup_string(propname, ZPROP_VALUE, &active_str)
619 != 0) {
620 return (B_FALSE);
621 }
622
623 if (strcmp(active_str, "on") == 0)
624 return (B_TRUE);
625
626 return (B_FALSE);
627 }