?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
8322 nl: misleading-indentation
[unleashed/tickless.git] / usr / src / lib / libinstzones / common / zones.c
blob9abb397381284e1f963e8fc48f39cfa7cab514c2
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) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
24 */
25
26
27 /*
28 * Module: zones.c
29 * Group: libinstzones
30 * Description: Provide "zones" interface for install consolidation code
31 *
32 * Public Methods:
33 * z_create_zone_admin_file - Given a location to create the file, and
34 * optionally an existing administration file, generate an
35 * administration file that can be used to perform "non-interactive"
36 * operations in a non-global zone.
37 * z_free_zone_list - free contents of zoneList_t object
38 * z_get_nonglobal_zone_list - return zoneList_t object describing all
39 * non-global native zones
40 * z_get_nonglobal_zone_list_by_brand - return zoneList_t object describing
41 * all non-global zones matching the list of zone brands passed in.
42 * z_free_brand_list - free contents of a zoneBrandList_t object
43 * z_make_brand_list - return a zoneBrandList_t object describing the list
44 * of all zone brands passed in.
45 * z_get_zonename - return the name of the current zone
46 * z_global_only - Determine if the global zone is only zone on the spec list
47 * z_lock_this_zone - lock this zone
48 * z_lock_zones - lock specified zones
49 * z_mount_in_lz - Mount global zone directory in specified zone's root file
50 * system
51 * z_non_global_zones_exist - Determine if any non-global native zones exist
52 * z_on_zone_spec - Determine if named zone is on the zone_spec list
53 * z_running_in_global_zone - Determine if running in the "global" zone
54 * z_set_output_functions - Link program specific output functions
55 * z_set_zone_root - Set root for zones library operations
56 * z_set_zone_spec - Set list of zones on which actions will be performed
57 * z_umount_lz_mount - Unmount directory mounted with z_mount_in_lz
58 * z_unlock_this_zone - unlock this zone
59 * z_unlock_zones - unlock specified zones
60 * z_verify_zone_spec - Verify list of zones on which actions will be performed
61 * z_zlist_change_zone_state - Change the current state of the specified zone
62 * z_zlist_get_current_state - Determine the current kernel state of the
63 * specified zone
64 * z_zlist_get_original_state - Return the original kernal state of the
65 * specified zone
66 * z_zlist_get_scratch - Determine name of scratch zone
67 * z_zlist_get_zonename - Determine name of specified zone
68 * z_zlist_get_zonepath - Determine zonepath of specified zone
69 * z_zlist_restore_zone_state - Return the zone to the state it was originally
70 * in
71 * z_zone_exec - Execute a Unix command in a specified zone and return results
72 * z_zones_are_implemented - Determine if any zone operations can be performed
73 * z_is_zone_branded - determine if zone has a non-native brand
74 * z_is_zone_brand_in_list - determine if the zone's brand matches the
75 * brand list passed in.
76 * z_brands_are_implemented - determine if branded zones are implemented on
77 * this system
78 */
79
80 /*
81 * System includes
82 */
83
84 #include <stdio.h>
85 #include <stdlib.h>
86 #include <unistd.h>
87 #include <fcntl.h>
88 #include <ctype.h>
89 #include <sys/types.h>
90 #include <sys/param.h>
91 #include <sys/sysmacros.h>
92 #include <string.h>
93 #include <strings.h>
94 #include <sys/stat.h>
95 #include <stdarg.h>
96 #include <limits.h>
97 #include <errno.h>
98 #include <time.h>
99 #include <signal.h>
100 #include <stropts.h>
101 #include <wait.h>
102 #include <zone.h>
103 #include <sys/brand.h>
104 #include <libintl.h>
105 #include <locale.h>
106 #include <libzonecfg.h>
107 #include <libcontract.h>
108 #include <sys/contract/process.h>
109 #include <sys/ctfs.h>
110 #include <assert.h>
111 #include <dlfcn.h>
112 #include <link.h>
113 #include <time.h>
114
115 /*
116 * local includes
117 */
118
119 /*
120 * When _INSTZONES_LIB_Z_DEFINE_GLOBAL_DATA is defined,
121 * instzones_lib.h will define the z_global_data structure.
122 * Otherwise an extern to the structure is inserted.
123 */
124
125 #define _INSTZONES_LIB_Z_DEFINE_GLOBAL_DATA
126 #include "instzones_lib.h"
127 #include "zones_strings.h"
128
129 /*
130 * Private structures
131 */
132
133 #define CLUSTER_BRAND_NAME "cluster"
134
135 /* maximum number of arguments to exec() call */
136
137 #define UUID_FORMAT "%02d%02d%02d%03d-%02d%02d%02d%d-%016llx"
138
139 /*
140 * Library Function Prototypes
141 */
142
143 #define streq(a, b) (strcmp((a), (b)) == 0)
144
145 /*
146 * Local Function Prototypes
147 */
148
149 /*
150 * global internal (private) declarations
151 */
152
153 /*
154 * *****************************************************************************
155 * global external (public) functions
156 * *****************************************************************************
157 */
158
159 /*
160 * Name: z_create_zone_admin_file
161 * Description: Given a location to create the file, and optionally an existing
162 * administration file, generate an administration file that
163 * can be used to perform "non-interactive" operations in a
164 * non-global zone.
165 * Arguments: a_zoneAdminFilename - pointer to string representing the
166 * full path of zone admin file to create
167 * a_userAdminFilename - pointer to string representing the path
168 * to an existing "user" administration file - the
169 * administration file created will contain the
170 * settings contained in this file, modified as
171 * appropriate to supress any interaction;
172 * If this is == NULL then the administration file
173 * created will not contain any extra settings
174 * Returns: boolean_t
175 * == B_TRUE - admin file created
176 * == B_FALSE - failed to create admin file
177 */
178
179 boolean_t
180 z_create_zone_admin_file(char *a_zoneAdminFilename, char *a_userAdminFilename)
181 {
182 FILE *zFp;
183 FILE *uFp = (FILE *)NULL;
184
185 /* entry assertions */
186
187 assert(a_zoneAdminFilename != NULL);
188 assert(*a_zoneAdminFilename != '\0');
189
190 /* create temporary zone admin file */
191
192 zFp = fopen(a_zoneAdminFilename, "w");
193 if (zFp == (FILE *)NULL) {
194 return (B_FALSE);
195 }
196
197 /* open user admin file if specified */
198
199 if (a_userAdminFilename != (char *)NULL) {
200 uFp = fopen(a_userAdminFilename, "r");
201 }
202
203 /* create default admin file for zone pkg ops if no user admin file */
204
205 if (uFp == (FILE *)NULL) {
206 /* create default admin file */
207 (void) fprintf(zFp, "action=nocheck\nauthentication=nocheck\n"
208 "basedir=default\nconflict=nocheck\nidepend=nocheck\n"
209 "instance=unique\npartial=nocheck\nrdepend=nocheck\n"
210 "runlevel=nocheck\nsetuid=nocheck\nspace=nocheck\n"
211 "mail=\n");
212 } else for (;;) {
213 /* copy user admin file substitute/change appropriate entries */
214 char buf[LINE_MAX+1];
215 char *p;
216
217 /* read next line of user admin file */
218
219 p = fgets(buf, sizeof (buf), uFp);
220 if (p == (char *)NULL) {
221 (void) fclose(uFp);
222 break;
223 }
224
225 /* modify / replace / accept as appropriate */
226
227 if (strncmp(buf, "instance=quit", 13) == 0) {
228 (void) fprintf(zFp, "%s", "instance=unique\n");
229 /*LINTED*/
230 } else if (strncmp(buf, "keystore=", 9) == 0) {
231 } else if (strncmp(buf, "action=", 7) == 0) {
232 (void) fprintf(zFp, "action=nocheck\n");
233 } else if (strncmp(buf, "authentication=", 15) == 0) {
234 (void) fprintf(zFp, "authentication=nocheck\n");
235 } else if (strncmp(buf, "conflict=", 9) == 0) {
236 (void) fprintf(zFp, "conflict=nocheck\n");
237 } else if (strncmp(buf, "idepend=", 8) == 0) {
238 (void) fprintf(zFp, "idepend=nocheck\n");
239 } else if (strncmp(buf, "mail=", 5) == 0) {
240 (void) fprintf(zFp, "mail=\n");
241 } else if (strncmp(buf, "partial=", 8) == 0) {
242 (void) fprintf(zFp, "partial=nocheck\n");
243 } else if (strncmp(buf, "rdepend=", 8) == 0) {
244 (void) fprintf(zFp, "rdepend=nocheck\n");
245 } else if (strncmp(buf, "runlevel=", 9) == 0) {
246 (void) fprintf(zFp, "runlevel=nocheck\n");
247 } else if (strncmp(buf, "setuid=", 7) == 0) {
248 (void) fprintf(zFp, "setuid=nocheck\n");
249 } else if (strncmp(buf, "space=", 6) == 0) {
250 (void) fprintf(zFp, "space=nocheck\n");
251 } else {
252 (void) fprintf(zFp, "%s", buf);
253 }
254 }
255
256 /* close admin file and return success */
257
258 (void) fclose(zFp);
259 return (B_TRUE);
260 }
261
262 /*
263 * Name: z_brands_are_implemented
264 * Description: Determine if any branded zones may be present
265 * Arguments: void
266 * Returns: boolean_t
267 * == B_TRUE - branded zones are supported
268 * == B_FALSE - branded zones are not supported
269 */
270
271 boolean_t
272 z_brands_are_implemented(void)
273 {
274 static boolean_t _brandsImplementedDetermined = B_FALSE;
275 static boolean_t _brandsAreImplemented = B_FALSE;
276
277 /* if availability has not been determined, cache it now */
278
279 if (!_brandsImplementedDetermined) {
280 _brandsImplementedDetermined = B_TRUE;
281 _brandsAreImplemented = _z_brands_are_implemented();
282 if (_brandsAreImplemented) {
283 _z_echoDebug(DBG_BRANDS_ARE_IMPLEMENTED);
284 } else {
285 _z_echoDebug(DBG_BRANDS_NOT_IMPLEMENTED);
286 }
287 }
288
289 /* return cached answer */
290
291 return (_brandsAreImplemented);
292 }
293
294 /*
295 * Name: z_free_zone_list
296 * Description: free contents of zoneList_t object
297 * Arguments: a_zlst - handle to zoneList_t object to free
298 * Returns: void
299 */
300
301 void
302 z_free_zone_list(zoneList_t a_zlst)
303 {
304 int numzones;
305
306 /* ignore empty list */
307
308 if (a_zlst == (zoneList_t)NULL) {
309 return;
310 }
311
312 /* free each entry in the zone list */
313
314 for (numzones = 0; a_zlst[numzones]._zlName != (char *)NULL;
315 numzones++) {
316 zoneListElement_t *zelm = &a_zlst[numzones];
317
318 /* free zone name string */
319
320 free(zelm->_zlName);
321
322 /* free zonepath string */
323
324 if (zelm->_zlPath != (char *)NULL) {
325 free(zelm->_zlPath);
326 }
327
328 }
329
330 /* free handle to the list */
331
332 free(a_zlst);
333 }
334
335 /*
336 * Name: z_get_nonglobal_zone_list
337 * Description: return zoneList_t object describing all non-global
338 * native zones - branded zones are not included in list
339 * Arguments: None.
340 * Returns: zoneList_t
341 * == NULL - error, list could not be generated
342 * != NULL - success, list returned
343 * NOTE: Any zoneList_t returned is placed in new storage for the
344 * calling function. The caller must use 'z_free_zone_list' to
345 * dispose of the storage once the list is no longer needed.
346 */
347
348 zoneList_t
349 z_get_nonglobal_zone_list(void)
350 {
351 zoneList_t zones;
352 zoneBrandList_t *brands = NULL;
353
354 if ((brands = z_make_brand_list("native cluster", " ")) == NULL)
355 return (NULL);
356
357 zones = z_get_nonglobal_zone_list_by_brand(brands);
358
359 z_free_brand_list(brands);
360
361 return (zones);
362 }
363
364 /*
365 * Name: z_free_brand_list
366 * Description: Free contents of zoneBrandList_t object
367 * Arguments: brands - pointer to zoneBrandList_t object to free
368 * Returns: void
369 */
370 void
371 z_free_brand_list(zoneBrandList_t *brands)
372 {
373 while (brands != NULL) {
374 zoneBrandList_t *temp = brands;
375 free(brands->string_ptr);
376 brands = brands->next;
377 free(temp);
378 }
379 }
380
381 /*
382 * Name: z_make_brand_list
383 * Description: Given a string with a list of brand name delimited by
384 * the delimeter passed in, build a zoneBrandList_t structure
385 * with the list of brand names and return it to the caller.
386 * Arguments:
387 * brands - const char pointer to string list of brand names
388 * delim - const char pointer to string representing the
389 * delimeter for brands string.
390 * Returns: zoneBrandList_t *
391 * == NULL - error, list could not be generated
392 * != NULL - success, list returned
393 * NOTE: Any zoneBrandList_t returned is placed in new storage for the
394 * calling function. The caller must use 'z_free_brand_list' to
395 * dispose of the storage once the list is no longer needed.
396 */
397 zoneBrandList_t *
398 z_make_brand_list(const char *brands, const char *delim)
399 {
400 zoneBrandList_t *brand = NULL, *head = NULL;
401 char *blist = NULL;
402 char *str = NULL;
403
404 if ((blist = strdup(brands)) == NULL)
405 return (NULL);
406
407 if ((str = strtok(blist, delim)) != NULL) {
408 if ((brand = (zoneBrandList_t *)
409 malloc(sizeof (struct _zoneBrandList))) == NULL) {
410 return (NULL);
411 }
412
413 head = brand;
414 brand->string_ptr = strdup(str);
415 brand->next = NULL;
416
417 while ((str = strtok(NULL, delim)) != NULL) {
418 if ((brand->next = (zoneBrandList_t *)
419 malloc(sizeof (struct _zoneBrandList))) == NULL) {
420 return (NULL);
421 }
422
423 brand = brand->next;
424 brand->string_ptr = strdup(str);
425 brand->next = NULL;
426 }
427 }
428
429 free(blist);
430 return (head);
431 }
432
433 /*
434 * Name: z_get_nonglobal_zone_list_by_brand
435 * Description: return zoneList_t object describing all non-global
436 * zones matching the list of brands passed in.
437 * Arguments: brands - The list of zone brands to look for.
438 * Returns: zoneList_t
439 * == NULL - error, list could not be generated
440 * != NULL - success, list returned
441 * NOTE: Any zoneList_t returned is placed in new storage for the
442 * calling function. The caller must use 'z_free_zone_list' to
443 * dispose of the storage once the list is no longer needed.
444 */
445 zoneList_t
446 z_get_nonglobal_zone_list_by_brand(zoneBrandList_t *brands)
447 {
448 FILE *zoneIndexFP;
449 int numzones = 0;
450 struct zoneent *ze;
451 zoneList_t zlst = NULL;
452 FILE *mapFP;
453 char zonename[ZONENAME_MAX];
454 zone_spec_t *zent;
455
456 /* if zones are not implemented, return empty list */
457
458 if (!z_zones_are_implemented()) {
459 return ((zoneList_t)NULL);
460 }
461
462 /*
463 * Open the zone index file. Note that getzoneent_private() handles
464 * NULL.
465 */
466 zoneIndexFP = setzoneent();
467
468 mapFP = zonecfg_open_scratch("", B_FALSE);
469
470 /* index file open; scan all zones; see if any are at least installed */
471
472 while ((ze = getzoneent_private(zoneIndexFP)) != NULL) {
473 zone_state_t st;
474
475 /* skip the global zone */
476
477 if (strcmp(ze->zone_name, GLOBAL_ZONENAME) == 0) {
478 free(ze);
479 continue;
480 }
481
482 /*
483 * skip any zones with brands not on the brand list
484 */
485 if (!z_is_zone_brand_in_list(ze->zone_name, brands)) {
486 free(ze);
487 continue;
488 }
489
490 /*
491 * If the user specified an explicit zone list, then ignore any
492 * zones that aren't on that list.
493 */
494 if ((zent = _z_global_data._zone_spec) != NULL) {
495 while (zent != NULL) {
496 if (strcmp(zent->zl_name, ze->zone_name) == 0)
497 break;
498 zent = zent->zl_next;
499 }
500 if (zent == NULL) {
501 free(ze);
502 continue;
503 }
504 }
505
506 /* non-global zone: create entry for this zone */
507
508 if (numzones == 0) {
509 zlst = (zoneList_t)_z_calloc(
510 sizeof (zoneListElement_t)*2);
511 } else {
512 zlst = (zoneList_t)_z_realloc(zlst,
513 sizeof (zoneListElement_t)*(numzones+2));
514 (void) memset(&zlst[numzones], 0L,
515 sizeof (zoneListElement_t)*2);
516 }
517
518 /*
519 * remember the zone name, zonepath and the current
520 * zone state of the zone.
521 */
522 zlst[numzones]._zlName = _z_strdup(ze->zone_name);
523 zlst[numzones]._zlPath = _z_strdup(ze->zone_path);
524 zlst[numzones]._zlOrigInstallState = ze->zone_state;
525 zlst[numzones]._zlCurrInstallState = ze->zone_state;
526
527 /* get the zone kernel status */
528
529 if (zone_get_state(ze->zone_name, &st) != Z_OK) {
530 st = ZONE_STATE_INCOMPLETE;
531 }
532
533 _z_echoDebug(DBG_ZONES_NGZ_LIST_STATES,
534 ze->zone_name, ze->zone_state, st);
535
536 /*
537 * For a scratch zone, we need to know the kernel zone name.
538 */
539 if (zonecfg_in_alt_root() && mapFP != NULL &&
540 zonecfg_find_scratch(mapFP, ze->zone_name,
541 zonecfg_get_root(), zonename, sizeof (zonename)) != -1) {
542 free(zlst[numzones]._zlScratchName);
543 zlst[numzones]._zlScratchName = _z_strdup(zonename);
544 }
545
546 /*
547 * remember the current kernel status of the zone.
548 */
549
550 zlst[numzones]._zlOrigKernelStatus = st;
551 zlst[numzones]._zlCurrKernelStatus = st;
552
553 numzones++;
554 free(ze);
555 }
556
557 /* close the index file */
558 endzoneent(zoneIndexFP);
559
560 if (mapFP != NULL)
561 zonecfg_close_scratch(mapFP);
562
563 /* return generated list */
564
565 return (zlst);
566 }
567
568 /*
569 * Name: z_get_zonename
570 * Description: return the name of the current zone
571 * Arguments: void
572 * Returns: char *
573 * - pointer to string representing the name of the current
574 * zone
575 * NOTE: Any string returned is placed in new storage for the
576 * calling function. The caller must use 'Free' to dispose
577 * of the storage once the string is no longer needed.
578 */
579
580 char *
581 z_get_zonename(void)
582 {
583 ssize_t zonenameLen;
584 char zonename[ZONENAME_MAX];
585 zoneid_t zoneid = (zoneid_t)-1;
586
587 /* if zones are not implemented, return "" */
588
589 if (!z_zones_are_implemented()) {
590 return (_z_strdup(""));
591 }
592
593 /* get the zone i.d. of the current zone */
594
595 zoneid = getzoneid();
596
597 /* get the name of the current zone */
598
599 zonenameLen = getzonenamebyid(zoneid, zonename, sizeof (zonename));
600
601 /* return "" if could not get zonename */
602
603 if (zonenameLen < 1) {
604 return (_z_strdup(""));
605 }
606
607 return (_z_strdup(zonename));
608 }
609
610 /*
611 * Name: z_global_only
612 * Description: Determine if the global zone is only zone on the spec list.
613 * Arguments: None
614 * Returns: B_TRUE if global zone is the only zone on the list,
615 * B_FALSE otherwise.
616 */
617
618 boolean_t
619 z_global_only(void)
620 {
621 /* return true if zones are not implemented - treate as global zone */
622
623 if (!z_zones_are_implemented()) {
624 return (B_TRUE);
625 }
626
627 /* return true if this is the global zone */
628
629 if (_z_global_data._zone_spec != NULL &&
630 _z_global_data._zone_spec->zl_next == NULL &&
631 strcmp(_z_global_data._zone_spec->zl_name, GLOBAL_ZONENAME) == 0) {
632 return (B_TRUE);
633 }
634
635 /* return false - not the global zone */
636
637 return (B_FALSE);
638 }
639
640 /*
641 * Name: z_lock_this_zone
642 * Description: lock this zone
643 * Arguments: a_lflags - [RO, *RO] - (ZLOCKS_T)
644 * Flags indicating which locks to acquire
645 * Returns: boolean_t
646 * == B_TRUE - success specified locks acquired
647 * == B_FALSE - failure specified locks not acquired
648 * NOTE: the lock objects for "this zone" are maintained internally.
649 */
650
651 boolean_t
652 z_lock_this_zone(ZLOCKS_T a_lflags)
653 {
654 boolean_t b;
655 char *zoneName;
656 pid_t pid = (pid_t)0;
657
658 /* entry assertions */
659
660 assert(a_lflags != ZLOCKS_NONE);
661
662 /* entry debugging info */
663
664 _z_echoDebug(DBG_ZONES_LCK_THIS, a_lflags);
665
666 zoneName = z_get_zonename();
667 pid = getpid();
668
669 /* lock zone administration */
670
671 if (a_lflags & ZLOCKS_ZONE_ADMIN) {
672 b = _z_lock_zone_object(&_z_global_data._z_ObjectLocks,
673 zoneName, LOBJ_ZONEADMIN, pid,
674 MSG_ZONES_LCK_THIS_ZONEADM,
675 ERR_ZONES_LCK_THIS_ZONEADM);
676 if (!b) {
677 (void) free(zoneName);
678 return (B_FALSE);
679 }
680 }
681
682 /* lock package administration always */
683
684 if (a_lflags & ZLOCKS_PKG_ADMIN) {
685 b = _z_lock_zone_object(&_z_global_data._z_ObjectLocks,
686 zoneName, LOBJ_PKGADMIN, pid,
687 MSG_ZONES_LCK_THIS_PKGADM,
688 ERR_ZONES_LCK_THIS_PKGADM);
689 if (!b) {
690 (void) z_unlock_this_zone(a_lflags);
691 (void) free(zoneName);
692 return (B_FALSE);
693 }
694 }
695
696 (void) free(zoneName);
697
698 return (B_TRUE);
699 }
700
701 /*
702 * Name: z_lock_zones
703 * Description: lock specified zones
704 * Arguments: a_zlst - zoneList_t object describing zones to lock
705 * a_lflags - [RO, *RO] - (ZLOCKS_T)
706 * Flags indicating which locks to acquire
707 * Returns: boolean_t
708 * == B_TRUE - success, zones locked
709 * == B_FALSE - failure, zones not locked
710 */
711
712 boolean_t
713 z_lock_zones(zoneList_t a_zlst, ZLOCKS_T a_lflags)
714 {
715 boolean_t b;
716 int i;
717
718 /* entry assertions */
719
720 assert(a_lflags != ZLOCKS_NONE);
721
722 /* entry debugging info */
723
724 _z_echoDebug(DBG_ZONES_LCK_ZONES, a_lflags);
725
726 /* if zones are not implemented, return TRUE */
727
728 if (z_zones_are_implemented() == B_FALSE) {
729 _z_echoDebug(DBG_ZONES_LCK_ZONES_UNIMP);
730 return (B_TRUE);
731 }
732
733 /* lock this zone first before locking other zones */
734
735 b = z_lock_this_zone(a_lflags);
736 if (b == B_FALSE) {
737 return (b);
738 }
739
740 /* ignore empty list */
741
742 if (a_zlst == (zoneList_t)NULL) {
743 _z_echoDebug(DBG_ZONES_LCK_ZONES_NOZONES);
744 return (B_FALSE);
745 }
746
747 /* zones exist */
748
749 _z_echoDebug(DBG_ZONES_LCK_ZONES_EXIST);
750
751 /*
752 * lock each listed zone that is currently running
753 */
754
755 for (i = 0; (a_zlst[i]._zlName != (char *)NULL); i++) {
756 /* ignore zone if already locked */
757 if (a_zlst[i]._zlStatus & ZST_LOCKED) {
758 continue;
759 }
760
761 /* ignore zone if not running */
762 if (a_zlst[i]._zlCurrKernelStatus != ZONE_STATE_RUNNING &&
763 a_zlst[i]._zlCurrKernelStatus != ZONE_STATE_MOUNTED) {
764 continue;
765 }
766
767 /*
768 * mark zone locked - if interrupted out during lock, an attempt
769 * will be made to release the lock
770 */
771 a_zlst[i]._zlStatus |= ZST_LOCKED;
772
773 /* lock this zone */
774 b = _z_lock_zone(&a_zlst[i], a_lflags);
775
776 /* on failure unlock all zones and return error */
777 if (b != B_TRUE) {
778 _z_program_error(ERR_ZONES_LCK_ZONES_FAILED,
779 a_zlst[i]._zlName);
780 (void) z_unlock_zones(a_zlst, a_lflags);
781 return (B_FALSE);
782 }
783 }
784
785 /* success */
786
787 return (B_TRUE);
788 }
789
790 /*
791 * Name: z_mount_in_lz
792 * Description: Mount global zone directory in specified zone's root file system
793 * Arguments: r_lzMountPoint - pointer to handle to string - on success, the
794 * full path to the mount point relative to the global zone
795 * root file system is returned here - this is needed to
796 * unmount the directory when it is no longer needed
797 * r_lzRootPath - pointer to handle to string - on success, the
798 * full path to the mount point relative to the specified
799 * zone's root file system is returned here - this is
800 * passed to any command executing in the specified zone to
801 * access the directory mounted
802 * a_zoneName - pointer to string representing the name of the zone
803 * to mount the specified global zone directory in
804 * a_gzPath - pointer to string representing the full absolute path
805 * of the global zone directory to LOFS mount inside of the
806 * specified non-global zone
807 * a_mountPointPrefix - pointer to string representing the prefix
808 * to be used when creating the mount point name in the
809 * specified zone's root directory
810 * Returns: boolean_t
811 * == B_TRUE - global zone directory mounted successfully
812 * == B_FALSE - failed to mount directory in specified zone
813 * NOTE: Any strings returned is placed in new storage for the
814 * calling function. The caller must use 'Free' to dispose
815 * of the storage once the strings are no longer needed.
816 */
817
818 boolean_t
819 z_mount_in_lz(char **r_lzMountPoint, char **r_lzRootPath, char *a_zoneName,
820 char *a_gzPath, char *a_mountPointPrefix)
821 {
822 char lzRootPath[MAXPATHLEN] = {'\0'};
823 char uuid[MAXPATHLEN] = {'\0'};
824 char gzMountPoint[MAXPATHLEN] = {'\0'};
825 char lzMountPoint[MAXPATHLEN] = {'\0'};
826 hrtime_t hretime;
827 int err;
828 int slen;
829 struct tm tstruct;
830 time_t thetime;
831 zoneid_t zid;
832
833 /* entry assertions */
834
835 assert(a_zoneName != (char *)NULL);
836 assert(*a_zoneName != '\0');
837 assert(a_gzPath != (char *)NULL);
838 assert(*a_gzPath != '\0');
839 assert(r_lzMountPoint != (char **)NULL);
840 assert(r_lzRootPath != (char **)NULL);
841
842 /* entry debugging info */
843
844 _z_echoDebug(DBG_ZONES_MOUNT_IN_LZ_ENTRY, a_zoneName, a_gzPath);
845
846 /* reset returned non-global zone mount point path handle */
847
848 *r_lzMountPoint = (char *)NULL;
849 *r_lzRootPath = (char *)NULL;
850
851 /* if zones are not implemented, return FALSE */
852
853 if (z_zones_are_implemented() == B_FALSE) {
854 return (B_FALSE);
855 }
856
857 /* error if global zone path is not absolute */
858
859 if (*a_gzPath != '/') {
860 _z_program_error(ERR_GZPATH_NOT_ABSOLUTE, a_gzPath);
861 return (B_FALSE);
862 }
863
864 /* error if global zone path does not exist */
865
866 if (_z_is_directory(a_gzPath) != 0) {
867 _z_program_error(ERR_GZPATH_NOT_DIR, a_gzPath, strerror(errno));
868 return (B_FALSE);
869 }
870
871 /* verify that specified non-global zone exists */
872
873 err = zone_get_id(a_zoneName, &zid);
874 if (err != Z_OK) {
875 _z_program_error(ERR_GET_ZONEID, a_zoneName,
876 zonecfg_strerror(err));
877 return (B_FALSE);
878 }
879
880 /* obtain global zone path to non-global zones root file system */
881
882 err = zone_get_rootpath(a_zoneName, lzRootPath, sizeof (lzRootPath));
883 if (err != Z_OK) {
884 _z_program_error(ERR_NO_ZONE_ROOTPATH, a_zoneName,
885 zonecfg_strerror(err));
886 return (B_FALSE);
887 }
888
889 if (lzRootPath[0] == '\0') {
890 _z_program_error(ERR_ROOTPATH_EMPTY, a_zoneName);
891 return (B_FALSE);
892 }
893
894 /*
895 * lofs resolve the non-global zone's root path first in case
896 * its in a path that's been lofs mounted read-only.
897 */
898 z_resolve_lofs(lzRootPath, sizeof (lzRootPath));
899
900 /* verify that the root path exists */
901
902 if (_z_is_directory(lzRootPath) != 0) {
903 _z_program_error(ERR_LZROOT_NOTDIR, lzRootPath,
904 strerror(errno));
905 return (B_FALSE);
906 }
907
908 /*
909 * generate a unique key - the key is the same length as unique uid
910 * but contains different information that is as unique as can be made;
911 * include current hires time (nanosecond real timer). Such a unique
912 * i.d. will look like:
913 * 0203104092-1145345-0004e94d6af481a0
914 */
915
916 hretime = gethrtime();
917
918 thetime = time((time_t *)NULL);
919 (void) localtime_r(&thetime, &tstruct);
920
921 slen = snprintf(uuid, sizeof (uuid),
922 UUID_FORMAT,
923 tstruct.tm_mday, tstruct.tm_mon, tstruct.tm_year,
924 tstruct.tm_yday, tstruct.tm_hour, tstruct.tm_min,
925 tstruct.tm_sec, tstruct.tm_wday, hretime);
926 if (slen > sizeof (uuid)) {
927 _z_program_error(ERR_GZMOUNT_SNPRINTFUUID_FAILED,
928 UUID_FORMAT, sizeof (uuid));
929 return (B_FALSE);
930 }
931
932 /* create the global zone mount point */
933
934 slen = snprintf(gzMountPoint, sizeof (gzMountPoint), "%s/.SUNW_%s_%s",
935 lzRootPath,
936 a_mountPointPrefix ? a_mountPointPrefix : "zones", uuid);
937 if (slen > sizeof (gzMountPoint)) {
938 _z_program_error(ERR_GZMOUNT_SNPRINTFGMP_FAILED,
939 "%s/.SUNW_%s_%s", lzRootPath,
940 a_mountPointPrefix ? a_mountPointPrefix : "zones",
941 uuid, sizeof (gzMountPoint));
942 return (B_FALSE);
943 }
944
945 slen = snprintf(lzMountPoint, sizeof (lzMountPoint), "%s",
946 gzMountPoint+strlen(lzRootPath));
947 if (slen > sizeof (lzMountPoint)) {
948 _z_program_error(ERR_GZMOUNT_SNPRINTFLMP_FAILED,
949 "%s", gzMountPoint+strlen(lzRootPath),
950 sizeof (lzMountPoint));
951 return (B_FALSE);
952 }
953
954 _z_echoDebug(DBG_MNTPT_NAMES, a_gzPath, a_zoneName, gzMountPoint,
955 lzMountPoint);
956
957 /* error if the mount point already exists */
958
959 if (_z_is_directory(gzMountPoint) == 0) {
960 _z_program_error(ERR_ZONEROOT_NOTDIR, gzMountPoint,
961 a_zoneName, strerror(errno));
962 return (B_FALSE);
963 }
964
965 /* create the temporary mount point */
966
967 if (mkdir(gzMountPoint, 0600) != 0) {
968 _z_program_error(ERR_MNTPT_MKDIR, gzMountPoint, a_zoneName,
969 strerror(errno));
970 return (B_FALSE);
971 }
972
973 /* mount the global zone path on the non-global zone root file system */
974
975 err = mount(a_gzPath, gzMountPoint, MS_RDONLY|MS_DATA, "lofs",
976 (char *)NULL, 0, (char *)NULL, 0);
977 if (err != 0) {
978 _z_program_error(ERR_GZMOUNT_FAILED, a_gzPath,
979 gzMountPoint, a_zoneName, strerror(errno));
980 return (B_FALSE);
981 }
982
983 /* success - return both mountpoints to caller */
984
985 *r_lzMountPoint = _z_strdup(gzMountPoint);
986
987 *r_lzRootPath = _z_strdup(lzMountPoint);
988
989 /* return success */
990
991 return (B_TRUE);
992 }
993
994 /*
995 * Name: z_non_global_zones_exist
996 * Description: Determine if any non-global native zones exist
997 * Arguments: None.
998 * Returns: boolean_t
999 * == B_TRUE - at least one non-global native zone exists
1000 * == B_FALSE - no non-global native zone exists
1001 */
1002
1003 boolean_t
1004 z_non_global_zones_exist(void)
1005 {
1006 FILE *zoneIndexFP;
1007 boolean_t anyExist = B_FALSE;
1008 struct zoneent *ze;
1009 zone_spec_t *zent;
1010
1011 /* if zones are not implemented, return FALSE */
1012
1013 if (z_zones_are_implemented() == B_FALSE) {
1014 return (B_FALSE);
1015 }
1016
1017 /* determine if any zones are configured */
1018 zoneIndexFP = setzoneent();
1019 if (zoneIndexFP == NULL) {
1020 return (B_FALSE);
1021 }
1022
1023 /* index file open; scan all zones; see if any are at least installed */
1024
1025 while ((ze = getzoneent_private(zoneIndexFP)) != NULL) {
1026 /*
1027 * If the user specified an explicit zone list, then ignore any
1028 * zones that aren't on that list.
1029 */
1030 if ((zent = _z_global_data._zone_spec) != NULL) {
1031 while (zent != NULL) {
1032 if (strcmp(zent->zl_name, ze->zone_name) == 0)
1033 break;
1034 zent = zent->zl_next;
1035 }
1036 if (zent == NULL) {
1037 free(ze);
1038 continue;
1039 }
1040 }
1041
1042 /* skip the global zone */
1043 if (strcmp(ze->zone_name, GLOBAL_ZONENAME) == 0) {
1044 free(ze);
1045 continue;
1046 }
1047
1048 /* skip any branded zones */
1049 if (z_is_zone_branded(ze->zone_name)) {
1050 free(ze);
1051 continue;
1052 }
1053
1054 /* is this zone installed? */
1055 if (ze->zone_state >= ZONE_STATE_INSTALLED) {
1056 free(ze);
1057 anyExist = B_TRUE;
1058 break;
1059 }
1060 free(ze);
1061 }
1062
1063 /* close the index file */
1064
1065 endzoneent(zoneIndexFP);
1066
1067 /* return results */
1068
1069 return (anyExist);
1070 }
1071
1072 /*
1073 * Name: z_on_zone_spec
1074 * Description: Determine if named zone is on the zone_spec list.
1075 * Arguments: Pointer to name to test.
1076 * Returns: B_TRUE if named zone is on the list or if the user specified
1077 * no list at all (all zones is the default), B_FALSE otherwise.
1078 */
1079
1080 boolean_t
1081 z_on_zone_spec(const char *zonename)
1082 {
1083 zone_spec_t *zent;
1084
1085 /* entry assertions */
1086
1087 assert(zonename != NULL);
1088 assert(*zonename != '\0');
1089
1090 /* return true if zones not implemented or no zone spec list defined */
1091
1092 if (!z_zones_are_implemented() || _z_global_data._zone_spec == NULL) {
1093 return (B_TRUE);
1094 }
1095
1096 /* return true if named zone is on the zone spec list */
1097
1098 for (zent = _z_global_data._zone_spec;
1099 zent != NULL; zent = zent->zl_next) {
1100 if (strcmp(zent->zl_name, zonename) == 0)
1101 return (B_TRUE);
1102 }
1103
1104 /* named zone is not on the zone spec list */
1105
1106 return (B_FALSE);
1107 }
1108
1109 /*
1110 * Name: z_running_in_global_zone
1111 * Description: Determine if running in the "global" zone
1112 * Arguments: void
1113 * Returns: boolean_t
1114 * == B_TRUE - running in global zone
1115 * == B_FALSE - not running in global zone
1116 */
1117
1118 boolean_t
1119 z_running_in_global_zone(void)
1120 {
1121 static boolean_t _zoneIdDetermined = B_FALSE;
1122 static boolean_t _zoneIsGlobal = B_FALSE;
1123
1124 /* if ID has not been determined, cache it now */
1125
1126 if (!_zoneIdDetermined) {
1127 _zoneIdDetermined = B_TRUE;
1128 _zoneIsGlobal = _z_running_in_global_zone();
1129 }
1130
1131 return (_zoneIsGlobal);
1132 }
1133
1134 /*
1135 * Name: z_set_output_functions
1136 * Description: Link program specific output functions to this library.
1137 * Arguments: a_echo_fcn - (_z_printf_fcn_t)
1138 * Function to call to cause "normal operation" messages
1139 * to be output/displayed
1140 * a_echo_debug_fcn - (_z_printf_fcn_t)
1141 * Function to call to cause "debugging" messages
1142 * to be output/displayed
1143 * a_progerr_fcn - (_z_printf_fcn_t)
1144 * Function to call to cause "program error" messages
1145 * to be output/displayed
1146 * Returns: void
1147 * NOTE: If NULL is specified for any function, then the functionality
1148 * associated with that function is disabled.
1149 * NOTE: The function pointers provided must call a function that
1150 * takes two arguments:
1151 * function(char *format, char *message)
1152 * Any registered function will be called like:
1153 * function("%s", "message")
1154 */
1155
1156 void
1157 z_set_output_functions(_z_printf_fcn_t a_echo_fcn,
1158 _z_printf_fcn_t a_echo_debug_fcn,
1159 _z_printf_fcn_t a_progerr_fcn)
1160 {
1161 _z_global_data._z_echo = a_echo_fcn;
1162 _z_global_data._z_echo_debug = a_echo_debug_fcn;
1163 _z_global_data._z_progerr = a_progerr_fcn;
1164 }
1165
1166 /*
1167 * Name: z_set_zone_root
1168 * Description: Set root for zones library operations
1169 * Arguments: Path to root of boot environment containing zone; must be
1170 * absolute.
1171 * Returns: None.
1172 * NOTE: Must be called before performing any zone-related operations.
1173 * (Currently called directly by set_inst_root() during -R
1174 * argument handling.)
1175 */
1176
1177 void
1178 z_set_zone_root(const char *zroot)
1179 {
1180 char *rootdir;
1181
1182 /* if zones are not implemented, just return */
1183
1184 if (!z_zones_are_implemented())
1185 return;
1186
1187 /* entry assertions */
1188
1189 assert(zroot != NULL);
1190
1191 rootdir = _z_strdup((char *)zroot);
1192 z_canoninplace(rootdir);
1193
1194 if (strcmp(rootdir, "/") == 0) {
1195 rootdir[0] = '\0';
1196 }
1197
1198 /* free any existing cached root path */
1199 if (*_z_global_data._z_root_dir != '\0') {
1200 free(_z_global_data._z_root_dir);
1201 _z_global_data._z_root_dir = NULL;
1202 }
1203
1204 /* store duplicate of new zone root path */
1205
1206 if (*rootdir != '\0') {
1207 _z_global_data._z_root_dir = _z_strdup(rootdir);
1208 } else {
1209 _z_global_data._z_root_dir = "";
1210 }
1211
1212 /* set zone root path */
1213
1214 zonecfg_set_root(rootdir);
1215
1216 free(rootdir);
1217 }
1218
1219 /*
1220 * Name: z_set_zone_spec
1221 * Description: Set list of zones on which actions will be performed.
1222 * Arguments: Whitespace-separated list of zone names.
1223 * Returns: 0 on success, -1 on error.
1224 * NOTES: Will call _z_program_error if argument can't be parsed or
1225 * memory not available.
1226 */
1227
1228 int
1229 z_set_zone_spec(const char *zlist)
1230 {
1231 const char *zend;
1232 ptrdiff_t zlen;
1233 zone_spec_t *zent;
1234 zone_spec_t *zhead;
1235 zone_spec_t **znextp = &zhead;
1236
1237 /* entry assertions */
1238
1239 assert(zlist != NULL);
1240
1241 /* parse list to zone_spec_t list, store in global data */
1242
1243 for (;;) {
1244 while (isspace(*zlist)) {
1245 zlist++;
1246 }
1247 if (*zlist == '\0') {
1248 break;
1249 }
1250 for (zend = zlist; *zend != '\0'; zend++) {
1251 if (isspace(*zend)) {
1252 break;
1253 }
1254 }
1255 zlen = ((ptrdiff_t)zend) - ((ptrdiff_t)zlist);
1256 if (zlen >= ZONENAME_MAX) {
1257 _z_program_error(ERR_ZONE_NAME_ILLEGAL, zlen, zlist);
1258 return (-1);
1259 }
1260 zent = _z_malloc(sizeof (*zent));
1261 (void) memcpy(zent->zl_name, zlist, zlen);
1262 zent->zl_name[zlen] = '\0';
1263 zent->zl_used = B_FALSE;
1264 *znextp = zent;
1265 znextp = &zent->zl_next;
1266 zlist = zend;
1267 }
1268 *znextp = NULL;
1269
1270 if (zhead == NULL) {
1271 _z_program_error(ERR_ZONE_LIST_EMPTY);
1272 return (-1);
1273 }
1274
1275 _z_global_data._zone_spec = zhead;
1276 return (0);
1277 }
1278
1279 /*
1280 * Name: z_umount_lz_mount
1281 * Description: Unmount directory mounted with z_mount_in_lz
1282 * Arguments: a_lzMountPointer - pointer to string returned by z_mount_in_lz
1283 * Returns: boolean_t
1284 * == B_TRUE - successfully unmounted directory
1285 * == B_FALSE - failed to unmount directory
1286 */
1287
1288 boolean_t
1289 z_umount_lz_mount(char *a_lzMountPoint)
1290 {
1291 int err;
1292
1293 /* entry assertions */
1294
1295 assert(a_lzMountPoint != (char *)NULL);
1296 assert(*a_lzMountPoint != '\0');
1297
1298 /* entry debugging info */
1299
1300 _z_echoDebug(DBG_ZONES_UNMOUNT_FROM_LZ_ENTRY, a_lzMountPoint);
1301
1302 /* if zones are not implemented, return TRUE */
1303
1304 if (z_zones_are_implemented() == B_FALSE) {
1305 return (B_FALSE);
1306 }
1307
1308 /* error if global zone path is not absolute */
1309
1310 if (*a_lzMountPoint != '/') {
1311 _z_program_error(ERR_LZMNTPT_NOT_ABSOLUTE, a_lzMountPoint);
1312 return (B_FALSE);
1313 }
1314
1315 /* verify mount point exists */
1316
1317 if (_z_is_directory(a_lzMountPoint) != 0) {
1318 _z_program_error(ERR_LZMNTPT_NOTDIR, a_lzMountPoint,
1319 strerror(errno));
1320 return (B_FALSE);
1321 }
1322
1323 /* unmount */
1324
1325 err = umount2(a_lzMountPoint, 0);
1326 if (err != 0) {
1327 _z_program_error(ERR_GZUMOUNT_FAILED, a_lzMountPoint,
1328 strerror(errno));
1329 return (B_FALSE);
1330 }
1331
1332 /* remove the mount point */
1333
1334 (void) remove(a_lzMountPoint);
1335
1336 /* return success */
1337
1338 return (B_TRUE);
1339 }
1340
1341 /*
1342 * Name: z_unlock_this_zone
1343 * Description: unlock this zone
1344 * Arguments: a_lflags - [RO, *RO] - (ZLOCKS_T)
1345 * Flags indicating which locks to release
1346 * Returns: boolean_t
1347 * == B_TRUE - success specified locks released
1348 * == B_FALSE - failure specified locks may not be released
1349 * NOTE: the lock objects for "this zone" are maintained internally.
1350 */
1351
1352 boolean_t
1353 z_unlock_this_zone(ZLOCKS_T a_lflags)
1354 {
1355 boolean_t b;
1356 boolean_t errors = B_FALSE;
1357 char *zoneName;
1358
1359 /* entry assertions */
1360
1361 assert(a_lflags != ZLOCKS_NONE);
1362
1363 /* entry debugging info */
1364
1365 _z_echoDebug(DBG_ZONES_ULK_THIS, a_lflags);
1366
1367 /* return if no objects locked */
1368
1369 if ((_z_global_data._z_ObjectLocks == (char *)NULL) ||
1370 (*_z_global_data._z_ObjectLocks == '\0')) {
1371 return (B_TRUE);
1372 }
1373
1374 zoneName = z_get_zonename();
1375
1376 /* unlock package administration */
1377
1378 if (a_lflags & ZLOCKS_PKG_ADMIN) {
1379 b = _z_unlock_zone_object(&_z_global_data._z_ObjectLocks,
1380 zoneName, LOBJ_PKGADMIN, ERR_ZONES_ULK_THIS_PACKAGE);
1381 if (!b) {
1382 errors = B_TRUE;
1383 }
1384 }
1385
1386 /* unlock zone administration */
1387
1388 if (a_lflags & ZLOCKS_ZONE_ADMIN) {
1389 b = _z_unlock_zone_object(&_z_global_data._z_ObjectLocks,
1390 zoneName, LOBJ_ZONEADMIN, ERR_ZONES_ULK_THIS_ZONES);
1391 if (!b) {
1392 errors = B_TRUE;
1393 }
1394 }
1395
1396 (void) free(zoneName);
1397 return (!errors);
1398 }
1399
1400 /*
1401 * Name: z_unlock_zones
1402 * Description: unlock specified zones
1403 * Arguments: a_zlst - zoneList_t object describing zones to unlock
1404 * a_lflags - [RO, *RO] - (ZLOCKS_T)
1405 * Flags indicating which locks to release
1406 * Returns: boolean_t
1407 * == B_TRUE - success, zones unlocked
1408 * == B_FALSE - failure, zones not unlocked
1409 */
1410
1411 boolean_t
1412 z_unlock_zones(zoneList_t a_zlst, ZLOCKS_T a_lflags)
1413 {
1414 boolean_t b;
1415 boolean_t errors = B_FALSE;
1416 int i;
1417
1418 /* entry assertions */
1419
1420 assert(a_lflags != ZLOCKS_NONE);
1421
1422 /* entry debugging info */
1423
1424 _z_echoDebug(DBG_ZONES_ULK_ZONES, a_lflags);
1425
1426 /* if zones are not implemented, return TRUE */
1427
1428 if (z_zones_are_implemented() == B_FALSE) {
1429 _z_echoDebug(DBG_ZONES_ULK_ZONES_UNIMP);
1430 return (B_TRUE);
1431 }
1432
1433 /* ignore empty list */
1434
1435 if (a_zlst == (zoneList_t)NULL) {
1436 _z_echoDebug(DBG_ZONES_ULK_ZONES_NOZONES);
1437 /* unlock this zone before returning */
1438 return (z_unlock_this_zone(a_lflags));
1439 }
1440
1441 /* zones exist */
1442
1443 _z_echoDebug(DBG_ZONES_ULK_ZONES_EXIST);
1444
1445 /*
1446 * unlock each listed zone that is currently running
1447 */
1448
1449 for (i = 0; (a_zlst[i]._zlName != (char *)NULL); i++) {
1450 /* ignore zone if not locked */
1451 if (!(a_zlst[i]._zlStatus & ZST_LOCKED)) {
1452 continue;
1453 }
1454
1455 /* ignore zone if not running */
1456 if (a_zlst[i]._zlCurrKernelStatus != ZONE_STATE_RUNNING &&
1457 a_zlst[i]._zlCurrKernelStatus != ZONE_STATE_MOUNTED) {
1458 continue;
1459 }
1460
1461 /* unlock this zone */
1462 b = _z_unlock_zone(&a_zlst[i], a_lflags);
1463
1464 if (b != B_TRUE) {
1465 errors = B_TRUE;
1466 } else {
1467 /* mark zone as unlocked */
1468 a_zlst[i]._zlStatus &= ~ZST_LOCKED;
1469 }
1470 }
1471
1472 /* unlock this zone */
1473
1474 if (z_unlock_this_zone(a_lflags) != B_TRUE) {
1475 errors = B_TRUE;
1476 }
1477
1478 return (errors);
1479 }
1480
1481 /*
1482 * Name: z_verify_zone_spec
1483 * Description: Verify list of zones on which actions will be performed.
1484 * Arguments: None.
1485 * Returns: 0 on success, -1 on error.
1486 * NOTES: Will call _z_program_error if there are zones on the specified
1487 * list that don't exist on the system. Requires that
1488 * z_set_zone_root is called first (if it is called at all).
1489 */
1490
1491 int
1492 z_verify_zone_spec(void)
1493 {
1494 FILE *zoneIndexFP;
1495 boolean_t errors;
1496 char zoneIndexPath[MAXPATHLEN];
1497 struct zoneent *ze;
1498 zone_spec_t *zent;
1499
1500 if (!z_zones_are_implemented()) {
1501 _z_program_error(ERR_ZONES_NOT_IMPLEMENTED);
1502 return (-1);
1503 }
1504
1505 zoneIndexFP = setzoneent();
1506 if (zoneIndexFP == NULL) {
1507 _z_program_error(ERR_ZONEINDEX_OPEN, zoneIndexPath,
1508 strerror(errno));
1509 return (-1);
1510 }
1511
1512 while ((ze = getzoneent_private(zoneIndexFP)) != NULL) {
1513 for (zent = _z_global_data._zone_spec;
1514 zent != NULL; zent = zent->zl_next) {
1515 if (strcmp(zent->zl_name, ze->zone_name) == 0) {
1516 zent->zl_used = B_TRUE;
1517 break;
1518 }
1519 }
1520 free(ze);
1521 }
1522 endzoneent(zoneIndexFP);
1523
1524 errors = B_FALSE;
1525 for (zent = _z_global_data._zone_spec;
1526 zent != NULL; zent = zent->zl_next) {
1527 if (!zent->zl_used) {
1528 _z_program_error(ERR_ZONE_NONEXISTENT, zent->zl_name);
1529 errors = B_TRUE;
1530 }
1531 }
1532 return (errors ? -1 : 0);
1533 }
1534
1535 /*
1536 * Name: z_zlist_change_zone_state
1537 * Description: Change the current state of the specified zone
1538 * Arguments: a_zlst - handle to zoneList_t object describing all zones
1539 * a_zoneIndex - index into a_zlst of the zone to return the
1540 * a_newState - the state to put the specified zone in
1541 * Returns: boolean_t
1542 * == B_TRUE - the zone is in the new state
1543 * == B_FALSE - unable to transition the zone to the
1544 * specified state
1545 * NOTE: This changes the "current kernel" state of the specified
1546 * zone. For example, to boot the zone, change the state
1547 * to "ZONE_STATE_RUNNING". To halt the zone, change the
1548 * state to "ZONE_STATE_INSTALLED".
1549 */
1550
1551 boolean_t
1552 z_zlist_change_zone_state(zoneList_t a_zlst, int a_zoneIndex,
1553 zone_state_t a_newState)
1554 {
1555 int i;
1556
1557 /* entry debugging info */
1558
1559 _z_echoDebug(DBG_ZONES_CHG_Z_STATE_ENTRY, a_zoneIndex, a_newState);
1560
1561 /* ignore empty list */
1562
1563 if (a_zlst == (zoneList_t)NULL) {
1564 return (B_FALSE);
1565 }
1566
1567 /* find the specified zone in the list */
1568
1569 for (i = 0; (i != a_zoneIndex) &&
1570 (a_zlst[i]._zlName != (char *)NULL); i++)
1571 ;
1572
1573 /* return error if the specified zone does not exist */
1574
1575 if (a_zlst[i]._zlName == (char *)NULL) {
1576 return (B_FALSE);
1577 }
1578
1579 /* return success if the zone is already in this state */
1580
1581 if (a_zlst[i]._zlCurrKernelStatus == a_newState) {
1582 return (B_TRUE);
1583 }
1584
1585 /* take action on new state to set zone to */
1586
1587 _z_echoDebug(DBG_ZONES_CHG_Z_STATE, a_zlst[i]._zlName,
1588 a_zlst[i]._zlCurrKernelStatus, a_newState);
1589
1590 switch (a_newState) {
1591 case ZONE_STATE_RUNNING:
1592 case ZONE_STATE_MOUNTED:
1593 /* these states mean "boot the zone" */
1594 return (_z_make_zone_running(&a_zlst[i]));
1595
1596 case ZONE_STATE_DOWN:
1597 case ZONE_STATE_INSTALLED:
1598 /* these states mean "halt the zone" */
1599 return (_z_make_zone_down(&a_zlst[i]));
1600
1601 case ZONE_STATE_READY:
1602 return (_z_make_zone_ready(&a_zlst[i]));
1603
1604 case ZONE_STATE_CONFIGURED:
1605 case ZONE_STATE_INCOMPLETE:
1606 case ZONE_STATE_SHUTTING_DOWN:
1607 default:
1608 /* do not know how to change zone to this state */
1609 return (B_FALSE);
1610 }
1611 }
1612
1613 /*
1614 * Name: z_is_zone_branded
1615 * Description: Determine whether zone has a non-native brand
1616 * Arguments: a_zoneName - name of the zone to check for branding
1617 * Returns: boolean_t
1618 * == B_TRUE - zone has a non-native brand
1619 * == B_FALSE - zone is native
1620 */
1621 boolean_t
1622 z_is_zone_branded(char *zoneName)
1623 {
1624 char brandname[MAXNAMELEN];
1625 int err;
1626
1627 /* if zones are not implemented, return FALSE */
1628 if (!z_zones_are_implemented()) {
1629 return (B_FALSE);
1630 }
1631
1632 /* if brands are not implemented, return FALSE */
1633 if (!z_brands_are_implemented()) {
1634 return (B_FALSE);
1635 }
1636
1637 err = zone_get_brand(zoneName, brandname, sizeof (brandname));
1638 if (err != Z_OK) {
1639 _z_program_error(ERR_BRAND_GETBRAND, zonecfg_strerror(err));
1640 return (B_FALSE);
1641 }
1642
1643 /*
1644 * Both "native" and "cluster" are native brands
1645 * that use the standard facilities in the areas
1646 * of packaging/installation/update.
1647 */
1648 if (streq(brandname, NATIVE_BRAND_NAME) ||
1649 streq(brandname, CLUSTER_BRAND_NAME)) {
1650 return (B_FALSE);
1651 } else {
1652 return (B_TRUE);
1653 }
1654 }
1655
1656 /*
1657 * Name: z_is_zone_brand_in_list
1658 * Description: Determine whether zone's brand has a match in the list
1659 * brands passed in.
1660 * Arguments: zoneName - name of the zone to check for branding
1661 * list - list of brands to check the zone against
1662 * Returns: boolean_t
1663 * == B_TRUE - zone has a matching brand
1664 * == B_FALSE - zone brand is not in list
1665 */
1666 boolean_t
1667 z_is_zone_brand_in_list(char *zoneName, zoneBrandList_t *list)
1668 {
1669 char brandname[MAXNAMELEN];
1670 int err;
1671 zoneBrandList_t *sp;
1672
1673 if (zoneName == NULL || list == NULL)
1674 return (B_FALSE);
1675
1676 /* if zones are not implemented, return FALSE */
1677 if (!z_zones_are_implemented()) {
1678 return (B_FALSE);
1679 }
1680
1681 /* if brands are not implemented, return FALSE */
1682 if (!z_brands_are_implemented()) {
1683 return (B_FALSE);
1684 }
1685
1686 err = zone_get_brand(zoneName, brandname, sizeof (brandname));
1687 if (err != Z_OK) {
1688 _z_program_error(ERR_BRAND_GETBRAND, zonecfg_strerror(err));
1689 return (B_FALSE);
1690 }
1691
1692 for (sp = list; sp != NULL; sp = sp->next) {
1693 if (sp->string_ptr != NULL &&
1694 strcmp(sp->string_ptr, brandname) == 0) {
1695 return (B_TRUE);
1696 }
1697 }
1698
1699 return (B_FALSE);
1700 }
1701
1702 /*
1703 * Name: z_zlist_get_current_state
1704 * Description: Determine the current kernel state of the specified zone
1705 * Arguments: a_zlst - handle to zoneList_t object describing all zones
1706 * a_zoneIndex - index into a_zlst of the zone to return
1707 * Returns: zone_state_t
1708 * The current state of the specified zone is returned
1709 */
1710
1711 zone_state_t
1712 z_zlist_get_current_state(zoneList_t a_zlst, int a_zoneIndex)
1713 {
1714 int i;
1715
1716 /* ignore empty list */
1717
1718 if (a_zlst == (zoneList_t)NULL) {
1719 return (ZONE_STATE_INCOMPLETE);
1720 }
1721
1722 /* find the specified zone in the list */
1723
1724 for (i = 0; (i != a_zoneIndex) &&
1725 (a_zlst[i]._zlName != (char *)NULL); i++)
1726 ;
1727
1728 /* return error if the specified zone does not exist */
1729
1730 if (a_zlst[i]._zlName == (char *)NULL) {
1731 return (ZONE_STATE_INCOMPLETE);
1732 }
1733
1734 /* return selected zone's current kernel state */
1735
1736 _z_echoDebug(DBG_ZONES_GET_ZONE_STATE,
1737 a_zlst[i]._zlName ? a_zlst[i]._zlName : "",
1738 a_zlst[i]._zlCurrKernelStatus);
1739
1740 return (a_zlst[i]._zlCurrKernelStatus);
1741 }
1742
1743 /*
1744 * Name: z_zlist_get_original_state
1745 * Description: Return the original kernal state of the specified zone
1746 * Arguments: a_zlst - handle to zoneList_t object describing all zones
1747 * a_zoneIndex - index into a_zlst of the zone to return the
1748 * Returns: zone_state_t
1749 * The original state of the specified zone is returned.
1750 * This is the state of the zone when the zoneList_t
1751 * object was first generated.
1752 */
1753
1754 zone_state_t
1755 z_zlist_get_original_state(zoneList_t a_zlst, int a_zoneIndex)
1756 {
1757 int i;
1758
1759 /* ignore empty list */
1760
1761 if (a_zlst == (zoneList_t)NULL) {
1762 return (ZONE_STATE_INCOMPLETE);
1763 }
1764
1765 /* find the specified zone in the list */
1766
1767 for (i = 0; (i != a_zoneIndex) &&
1768 (a_zlst[i]._zlName != (char *)NULL); i++)
1769 ;
1770
1771 /* return error if the specified zone does not exist */
1772
1773 if (a_zlst[i]._zlName == (char *)NULL) {
1774 return (ZONE_STATE_INCOMPLETE);
1775 }
1776
1777 /* return selected zone's original kernel state */
1778
1779 return (a_zlst[i]._zlOrigKernelStatus);
1780 }
1781
1782 /*
1783 * Name: z_zlist_get_scratch
1784 * Description: Determine name of scratch zone
1785 * Arguments: a_zlst - handle to zoneList_t object describing all zones
1786 * a_zoneIndex - index into a_zlst of the zone to use
1787 * Return: char *
1788 * == NULL - zone name could not be determined
1789 * != NULL - pointer to string representing scratch zone
1790 * NOTE: Any name returned is placed in static storage that must
1791 * NEVER be free()ed by the caller.
1792 */
1793
1794 char *
1795 z_zlist_get_scratch(zoneList_t a_zlst, int a_zoneIndex)
1796 {
1797 int i;
1798
1799 /* ignore empty list */
1800
1801 if (a_zlst == NULL)
1802 return (NULL);
1803
1804 /* find the specified zone in the list */
1805
1806 for (i = 0; i != a_zoneIndex; i++) {
1807 if (a_zlst[i]._zlName == NULL)
1808 return (NULL);
1809 }
1810
1811 /* return selected zone's scratch name */
1812
1813 return (a_zlst[i]._zlScratchName == NULL ? a_zlst[i]._zlName :
1814 a_zlst[i]._zlScratchName);
1815 }
1816
1817 /*
1818 * Name: z_zlist_get_zonename
1819 * Description: Determine name of specified zone
1820 * Arguments: a_zlst - handle to zoneList_t object describing all zones
1821 * a_zoneIndex - index into a_zlst of the zone to return the
1822 * Return: char *
1823 * == NULL - zone name could not be determined
1824 * != NULL - pointer to string representing zone name
1825 * NOTE: Any zoneList_t returned is placed in static storage that must
1826 * NEVER be free()ed by the caller.
1827 */
1828
1829 char *
1830 z_zlist_get_zonename(zoneList_t a_zlst, int a_zoneIndex)
1831 {
1832 int i;
1833
1834 /* ignore empty list */
1835
1836 if (a_zlst == (zoneList_t)NULL) {
1837 return ((char *)NULL);
1838 }
1839
1840 /* find the specified zone in the list */
1841
1842 for (i = 0; (i != a_zoneIndex) &&
1843 (a_zlst[i]._zlName != (char *)NULL); i++)
1844 ;
1845
1846 /* return error if the specified zone does not exist */
1847
1848 if (a_zlst[i]._zlName == (char *)NULL) {
1849 return (NULL);
1850 }
1851
1852 /* return selected zone's name */
1853
1854 return (a_zlst[i]._zlName);
1855 }
1856
1857 /*
1858 * Name: z_zlist_get_zonepath
1859 * Description: Determine zonepath of specified zone
1860 * Arguments: a_zlst - handle to zoneList_t object describing all zones
1861 * a_zoneIndex - index into a_zlst of the zone to return
1862 * Return: char *
1863 * == NULL - zonepath could not be determined
1864 * != NULL - pointer to string representing zonepath
1865 * NOTE: Any zoneList_t returned is placed in static storage that must
1866 * NEVER be free()ed by the caller.
1867 */
1868
1869 char *
1870 z_zlist_get_zonepath(zoneList_t a_zlst, int a_zoneIndex)
1871 {
1872 int i;
1873
1874 /* ignore empty list */
1875
1876 if (a_zlst == (zoneList_t)NULL) {
1877 return ((char *)NULL);
1878 }
1879
1880 /* find the specified zone in the list */
1881
1882 for (i = 0; (i != a_zoneIndex) &&
1883 (a_zlst[i]._zlName != (char *)NULL); i++)
1884 ;
1885
1886 /* return error if the specified zone does not exist */
1887
1888 if (a_zlst[i]._zlName == (char *)NULL) {
1889 return (NULL);
1890 }
1891
1892 /* return selected zone's zonepath */
1893
1894 return (a_zlst[i]._zlPath);
1895 }
1896
1897 boolean_t
1898 z_zlist_is_zone_runnable(zoneList_t a_zlst, int a_zoneIndex)
1899 {
1900 int i;
1901
1902 /* if zones are not implemented, return error */
1903
1904 if (z_zones_are_implemented() == B_FALSE) {
1905 return (B_FALSE);
1906 }
1907
1908 /* ignore empty list */
1909
1910 if (a_zlst == (zoneList_t)NULL) {
1911 return (B_FALSE);
1912 }
1913
1914 /* find the specified zone in the list */
1915
1916 for (i = 0; (i != a_zoneIndex) &&
1917 (a_zlst[i]._zlName != (char *)NULL); i++)
1918 ;
1919
1920 /* return error if the specified zone does not exist */
1921
1922 if (a_zlst[i]._zlName == (char *)NULL) {
1923 return (B_FALSE);
1924 }
1925
1926 /* choose based on current state */
1927
1928 switch (a_zlst[i]._zlCurrKernelStatus) {
1929 case ZONE_STATE_RUNNING:
1930 case ZONE_STATE_MOUNTED:
1931 /* already running */
1932 return (B_TRUE);
1933
1934 case ZONE_STATE_INSTALLED:
1935 case ZONE_STATE_DOWN:
1936 case ZONE_STATE_READY:
1937 case ZONE_STATE_SHUTTING_DOWN:
1938 /* return false if the zone cannot be booted */
1939
1940 if (a_zlst[i]._zlStatus & ZST_NOT_BOOTABLE) {
1941 return (B_FALSE);
1942 }
1943
1944 return (B_TRUE);
1945
1946 case ZONE_STATE_CONFIGURED:
1947 case ZONE_STATE_INCOMPLETE:
1948 default:
1949 /* cannot transition (boot) these states */
1950 return (B_FALSE);
1951 }
1952 }
1953
1954 /*
1955 * Name: z_zlist_restore_zone_state
1956 * Description: Return the zone to the state it was originally in
1957 * Arguments: a_zlst - handle to zoneList_t object describing all zones
1958 * a_zoneIndex - index into a_zlst of the zone to return the
1959 * Returns: boolean_t
1960 * == B_TRUE - the zone's state has been restored
1961 * == B_FALSE - unable to transition the zone to its
1962 * original state
1963 */
1964
1965 boolean_t
1966 z_zlist_restore_zone_state(zoneList_t a_zlst, int a_zoneIndex)
1967 {
1968 int i;
1969
1970 /* ignore empty list */
1971
1972 if (a_zlst == (zoneList_t)NULL) {
1973 return (B_FALSE);
1974 }
1975
1976 /* find the specified zone in the list */
1977
1978 for (i = 0; (i != a_zoneIndex) &&
1979 (a_zlst[i]._zlName != (char *)NULL); i++)
1980 ;
1981
1982 /* return error if the specified zone does not exist */
1983
1984 if (a_zlst[i]._zlName == (char *)NULL) {
1985 return (B_FALSE);
1986 }
1987
1988 /* transition the zone back to its original state */
1989
1990 return (z_zlist_change_zone_state(a_zlst,
1991 a_zoneIndex, a_zlst[i]._zlOrigKernelStatus));
1992 }
1993
1994 /*
1995 * Name: z_zone_exec
1996 * Description: Execute a Unix command in a specified zone and return results
1997 * Arguments: a_zoneName - pointer to string representing the name of the zone
1998 * to execute the specified command in
1999 * a_path - pointer to string representing the full path *in the
2000 * non-global zone named by a_zoneName* of the Unix command
2001 * to be executed
2002 * a_argv[] - Pointer to array of character strings representing
2003 * the arguments to be passed to the Unix command. The list
2004 * must be termianted with an element that is (char *)NULL
2005 * NOTE: a_argv[0] is the "command name" passed to the command
2006 * a_stdoutPath - Pointer to string representing the path to a file
2007 * into which all output to "stdout" from the Unix command
2008 * is placed.
2009 * == (char *)NULL - leave stdout open and pass through
2010 * == "/dev/null" - discard stdout output
2011 * a_strerrPath - Pointer to string representing the path to a file
2012 * into which all output to "stderr" from the Unix command
2013 * is placed.
2014 * == (char *)NULL - leave stderr open and pass through
2015 * == "/dev/null" - discard stderr output
2016 * a_fds - Pointer to array of integers representing file
2017 * descriptors to remain open during the call - all
2018 * file descriptors above STDERR_FILENO not in this
2019 * list will be closed.
2020 * Returns: int
2021 * The return (exit) code from the specified Unix command
2022 * Special return codes:
2023 * -1 : failure to exec process
2024 * -2 : could not create contract for greenline
2025 * -3 : fork() failed
2026 * -4 : could not open stdout capture file
2027 * -5 : error from 'waitpid' other than EINTR
2028 * -6 : zones are not supported
2029 * NOTE: All file descriptores other than 0, 1 and 2 are closed except
2030 * for those file descriptors listed in the a_fds array.
2031 */
2032
2033 int
2034 z_zone_exec(const char *a_zoneName, const char *a_path, char *a_argv[],
2035 char *a_stdoutPath, char *a_stderrPath, int *a_fds)
2036 {
2037 int final_status;
2038 int lerrno;
2039 int status;
2040 int tmpl_fd;
2041 pid_t child_pid;
2042 pid_t result_pid;
2043 struct sigaction nact;
2044 struct sigaction oact;
2045 void (*funcSighup)();
2046 void (*funcSigint)();
2047
2048 /* if zones are not implemented, return TRUE */
2049
2050 if (z_zones_are_implemented() == B_FALSE) {
2051 return (-6); /* -6 : zones are not supported */
2052 }
2053
2054 if ((tmpl_fd = _zexec_init_template()) == -1) {
2055 _z_program_error(ERR_CANNOT_CREATE_CONTRACT, strerror(errno));
2056 return (-2); /* -2 : could not create greenline contract */
2057 }
2058
2059 /*
2060 * hold SIGINT/SIGHUP signals and reset signal received counter;
2061 * after the fork1() the parent and child need to setup their respective
2062 * interrupt handling and release the hold on the signals
2063 */
2064
2065 (void) sighold(SIGINT);
2066 (void) sighold(SIGHUP);
2067
2068 _z_global_data._z_SigReceived = 0; /* no signals received */
2069
2070 /*
2071 * fork off a new process to execute command in;
2072 * fork1() is used instead of vfork() so the child process can
2073 * perform operations that would modify the parent process if
2074 * vfork() were used
2075 */
2076
2077 child_pid = fork1();
2078
2079 if (child_pid < 0) {
2080 /*
2081 * *************************************************************
2082 * fork failed!
2083 * *************************************************************
2084 */
2085
2086 (void) ct_tmpl_clear(tmpl_fd);
2087 (void) close(tmpl_fd);
2088 _z_program_error(ERR_FORK, strerror(errno));
2089
2090 /* release hold on signals */
2091
2092 (void) sigrelse(SIGHUP);
2093 (void) sigrelse(SIGINT);
2094
2095 return (-3); /* -3 : fork() failed */
2096 }
2097
2098 if (child_pid == 0) {
2099 int i;
2100
2101 /*
2102 * *************************************************************
2103 * This is the forked (child) process
2104 * *************************************************************
2105 */
2106
2107 (void) ct_tmpl_clear(tmpl_fd);
2108 (void) close(tmpl_fd);
2109
2110 /* reset any signals to default */
2111
2112 for (i = 0; i < NSIG; i++) {
2113 (void) sigset(i, SIG_DFL);
2114 }
2115
2116 /*
2117 * close all file descriptors not in the a_fds list
2118 */
2119
2120 (void) fdwalk(&_z_close_file_descriptors, (void *)a_fds);
2121
2122 /*
2123 * if a file for stdout is present, open the file and use the
2124 * file to capture stdout from the _zexec process
2125 */
2126
2127 if (a_stdoutPath != (char *)NULL) {
2128 int stdoutfd;
2129
2130 stdoutfd = open(a_stdoutPath,
2131 O_WRONLY|O_CREAT|O_TRUNC, 0600);
2132 if (stdoutfd < 0) {
2133 _z_program_error(ERR_CAPTURE_FILE, a_stdoutPath,
2134 strerror(errno));
2135 return (-4);
2136 }
2137
2138 (void) dup2(stdoutfd, STDOUT_FILENO);
2139 (void) close(stdoutfd);
2140 }
2141
2142 /*
2143 * if a file for stderr is present, open the file and use the
2144 * file to capture stderr from the _zexec process
2145 */
2146
2147 if (a_stderrPath != (char *)NULL) {
2148 int stderrfd;
2149
2150 stderrfd = open(a_stderrPath,
2151 O_WRONLY|O_CREAT|O_TRUNC, 0600);
2152 if (stderrfd < 0) {
2153 _z_program_error(ERR_CAPTURE_FILE, a_stderrPath,
2154 strerror(errno));
2155 return (-4);
2156 }
2157
2158 (void) dup2(stderrfd, STDERR_FILENO);
2159 (void) close(stderrfd);
2160 }
2161
2162 /* release all held signals */
2163
2164 (void) sigrelse(SIGHUP);
2165 (void) sigrelse(SIGINT);
2166
2167 /* execute command in the specified non-global zone */
2168
2169 _exit(_zexec(a_zoneName, a_path, a_argv));
2170 }
2171
2172 /*
2173 * *********************************************************************
2174 * This is the forking (parent) process
2175 * *********************************************************************
2176 */
2177
2178 /* register child process i.d. so signal handlers can pass signal on */
2179
2180 _z_global_data._z_ChildProcessId = child_pid;
2181
2182 /*
2183 * setup signal handlers for SIGINT and SIGHUP and release hold
2184 */
2185
2186 /* hook SIGINT to _z_sig_trap() */
2187
2188 nact.sa_handler = _z_sig_trap;
2189 nact.sa_flags = SA_RESTART;
2190 (void) sigemptyset(&nact.sa_mask);
2191
2192 if (sigaction(SIGINT, &nact, &oact) < 0) {
2193 funcSigint = SIG_DFL;
2194 } else {
2195 funcSigint = oact.sa_handler;
2196 }
2197
2198 /* hook SIGHUP to _z_sig_trap() */
2199
2200 nact.sa_handler = _z_sig_trap;
2201 nact.sa_flags = SA_RESTART;
2202 (void) sigemptyset(&nact.sa_mask);
2203
2204 if (sigaction(SIGHUP, &nact, &oact) < 0) {
2205 funcSighup = SIG_DFL;
2206 } else {
2207 funcSighup = oact.sa_handler;
2208 }
2209
2210 /* release hold on signals */
2211
2212 (void) sigrelse(SIGHUP);
2213 (void) sigrelse(SIGINT);
2214
2215 (void) ct_tmpl_clear(tmpl_fd);
2216 (void) close(tmpl_fd);
2217
2218 /*
2219 * wait for the process to exit, reap child exit status
2220 */
2221
2222 for (;;) {
2223 result_pid = waitpid(child_pid, &status, 0L);
2224 lerrno = (result_pid == -1 ? errno : 0);
2225
2226 /* break loop if child process status reaped */
2227
2228 if (result_pid != -1) {
2229 break;
2230 }
2231
2232 /* break loop if not interrupted out of waitpid */
2233
2234 if (errno != EINTR) {
2235 break;
2236 }
2237 }
2238
2239 /* reset child process i.d. so signal handlers do not pass signals on */
2240
2241 _z_global_data._z_ChildProcessId = -1;
2242
2243 /*
2244 * If the child process terminated due to a call to exit(), then
2245 * set results equal to the 8-bit exit status of the child process;
2246 * otherwise, set the exit status to "-1" indicating that the child
2247 * exited via a signal.
2248 */
2249
2250 if (WIFEXITED(status)) {
2251 final_status = WEXITSTATUS(status);
2252 if ((_z_global_data._z_SigReceived != 0) &&
2253 (final_status == 0)) {
2254 final_status = 1;
2255 }
2256 } else {
2257 final_status = -1; /* -1 : failure to exec process */
2258 }
2259
2260 /* determine proper exit code */
2261
2262 if (result_pid == -1) {
2263 final_status = -5; /* -5 : error from waitpid not EINTR */
2264 } else if (_z_global_data._z_SigReceived != 0) {
2265 final_status = -7; /* -7 : interrupt received */
2266 }
2267
2268 /*
2269 * reset signal handlers
2270 */
2271
2272 /* reset SIGINT */
2273
2274 nact.sa_handler = funcSigint;
2275 nact.sa_flags = SA_RESTART;
2276 (void) sigemptyset(&nact.sa_mask);
2277
2278 (void) sigaction(SIGINT, &nact, (struct sigaction *)NULL);
2279
2280 /* reset SIGHUP */
2281
2282 nact.sa_handler = funcSighup;
2283 nact.sa_flags = SA_RESTART;
2284 (void) sigemptyset(&nact.sa_mask);
2285
2286 (void) sigaction(SIGHUP, &nact, (struct sigaction *)NULL);
2287
2288 /*
2289 * if signal received during command execution, interrupt
2290 * this process now.
2291 */
2292
2293 if (_z_global_data._z_SigReceived != 0) {
2294 (void) kill(getpid(), SIGINT);
2295 }
2296
2297 /* set errno and return */
2298
2299 errno = lerrno;
2300
2301 return (final_status);
2302 }
2303
2304 /*
2305 * Name: z_zones_are_implemented
2306 * Description: Determine if any zone operations can be performed
2307 * Arguments: void
2308 * Returns: boolean_t
2309 * == B_TRUE - zone operations are available
2310 * == B_FALSE - no zone operations can be done
2311 */
2312
2313 boolean_t
2314 z_zones_are_implemented(void)
2315 {
2316 static boolean_t _zonesImplementedDetermined = B_FALSE;
2317 static boolean_t _zonesAreImplemented = B_FALSE;
2318
2319 /* if availability has not been determined, cache it now */
2320
2321 if (!_zonesImplementedDetermined) {
2322 _zonesImplementedDetermined = B_TRUE;
2323 _zonesAreImplemented = _z_zones_are_implemented();
2324 if (!_zonesAreImplemented) {
2325 _z_echoDebug(DBG_ZONES_NOT_IMPLEMENTED);
2326 } else {
2327 _z_echoDebug(DBG_ZONES_ARE_IMPLEMENTED);
2328 }
2329 }
2330
2331 return (_zonesAreImplemented);
2332 }
unleashed repo fork