17c478bd9Sstevel@tonic-gate /* 27c478bd9Sstevel@tonic-gate * CDDL HEADER START 37c478bd9Sstevel@tonic-gate * 47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the 5ee519a1fSgjelinek * Common Development and Distribution License (the "License"). 6ee519a1fSgjelinek * You may not use this file except in compliance with the License. 77c478bd9Sstevel@tonic-gate * 87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 117c478bd9Sstevel@tonic-gate * and limitations under the License. 127c478bd9Sstevel@tonic-gate * 137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 187c478bd9Sstevel@tonic-gate * 197c478bd9Sstevel@tonic-gate * CDDL HEADER END 207c478bd9Sstevel@tonic-gate */ 217e362f58Scomay 227c478bd9Sstevel@tonic-gate /* 237ef01d19Sgjelinek * Copyright 2007 Sun Microsystems, Inc. All rights reserved. 247c478bd9Sstevel@tonic-gate * Use is subject to license terms. 257c478bd9Sstevel@tonic-gate */ 267c478bd9Sstevel@tonic-gate 277c478bd9Sstevel@tonic-gate #pragma ident "%Z%%M% %I% %E% SMI" 287c478bd9Sstevel@tonic-gate 297c478bd9Sstevel@tonic-gate /* 307c478bd9Sstevel@tonic-gate * zoneadm is a command interpreter for zone administration. It is all in 317c478bd9Sstevel@tonic-gate * C (i.e., no lex/yacc), and all the argument passing is argc/argv based. 327c478bd9Sstevel@tonic-gate * main() calls parse_and_run() which calls cmd_match(), then invokes the 337c478bd9Sstevel@tonic-gate * appropriate command's handler function. The rest of the program is the 347c478bd9Sstevel@tonic-gate * handler functions and their helper functions. 357c478bd9Sstevel@tonic-gate * 367c478bd9Sstevel@tonic-gate * Some of the helper functions are used largely to simplify I18N: reducing 377c478bd9Sstevel@tonic-gate * the need for translation notes. This is particularly true of many of 387c478bd9Sstevel@tonic-gate * the zerror() calls: doing e.g. zerror(gettext("%s failed"), "foo") rather 397c478bd9Sstevel@tonic-gate * than zerror(gettext("foo failed")) with a translation note indicating 407c478bd9Sstevel@tonic-gate * that "foo" need not be translated. 417c478bd9Sstevel@tonic-gate */ 427c478bd9Sstevel@tonic-gate 437c478bd9Sstevel@tonic-gate #include <stdio.h> 447c478bd9Sstevel@tonic-gate #include <errno.h> 457c478bd9Sstevel@tonic-gate #include <unistd.h> 467c478bd9Sstevel@tonic-gate #include <signal.h> 477c478bd9Sstevel@tonic-gate #include <stdarg.h> 487c478bd9Sstevel@tonic-gate #include <ctype.h> 497c478bd9Sstevel@tonic-gate #include <stdlib.h> 507c478bd9Sstevel@tonic-gate #include <string.h> 517c478bd9Sstevel@tonic-gate #include <wait.h> 527c478bd9Sstevel@tonic-gate #include <zone.h> 537c478bd9Sstevel@tonic-gate #include <priv.h> 547c478bd9Sstevel@tonic-gate #include <locale.h> 557c478bd9Sstevel@tonic-gate #include <libintl.h> 567c478bd9Sstevel@tonic-gate #include <libzonecfg.h> 577c478bd9Sstevel@tonic-gate #include <bsm/adt.h> 589acbbeafSnn35248 #include <sys/brand.h> 597c478bd9Sstevel@tonic-gate #include <sys/param.h> 607c478bd9Sstevel@tonic-gate #include <sys/types.h> 617c478bd9Sstevel@tonic-gate #include <sys/stat.h> 627c478bd9Sstevel@tonic-gate #include <sys/statvfs.h> 637c478bd9Sstevel@tonic-gate #include <assert.h> 647c478bd9Sstevel@tonic-gate #include <sys/sockio.h> 657c478bd9Sstevel@tonic-gate #include <sys/mntent.h> 667c478bd9Sstevel@tonic-gate #include <limits.h> 670b5de56dSgjelinek #include <dirent.h> 68555afedfScarlsonj #include <uuid/uuid.h> 697c478bd9Sstevel@tonic-gate 707c478bd9Sstevel@tonic-gate #include <fcntl.h> 717c478bd9Sstevel@tonic-gate #include <door.h> 727c478bd9Sstevel@tonic-gate #include <macros.h> 737c478bd9Sstevel@tonic-gate #include <libgen.h> 74865e09a4Sgjelinek #include <fnmatch.h> 75e7f3c547Sgjelinek #include <sys/modctl.h> 769acbbeafSnn35248 #include <libbrand.h> 770209230bSgjelinek #include <libscf.h> 787ef01d19Sgjelinek #include <procfs.h> 79d9e728a2Sgjelinek #include <strings.h> 807c478bd9Sstevel@tonic-gate 817c478bd9Sstevel@tonic-gate #include <pool.h> 827c478bd9Sstevel@tonic-gate #include <sys/pool.h> 830209230bSgjelinek #include <sys/priocntl.h> 840209230bSgjelinek #include <sys/fsspriocntl.h> 857c478bd9Sstevel@tonic-gate 860b5de56dSgjelinek #include "zoneadm.h" 870b5de56dSgjelinek 887c478bd9Sstevel@tonic-gate #define MAXARGS 8 897c478bd9Sstevel@tonic-gate 907c478bd9Sstevel@tonic-gate /* Reflects kernel zone entries */ 917c478bd9Sstevel@tonic-gate typedef struct zone_entry { 927c478bd9Sstevel@tonic-gate zoneid_t zid; 937c478bd9Sstevel@tonic-gate char zname[ZONENAME_MAX]; 947c478bd9Sstevel@tonic-gate char *zstate_str; 957c478bd9Sstevel@tonic-gate zone_state_t zstate_num; 969acbbeafSnn35248 char zbrand[MAXNAMELEN]; 977c478bd9Sstevel@tonic-gate char zroot[MAXPATHLEN]; 98555afedfScarlsonj char zuuid[UUID_PRINTABLE_STRING_LENGTH]; 99f4b3ec61Sdh155122 zone_iptype_t ziptype; 1007c478bd9Sstevel@tonic-gate } zone_entry_t; 1017c478bd9Sstevel@tonic-gate 1027c478bd9Sstevel@tonic-gate static zone_entry_t *zents; 1037c478bd9Sstevel@tonic-gate static size_t nzents; 1049acbbeafSnn35248 static boolean_t is_native_zone = B_TRUE; 1057c478bd9Sstevel@tonic-gate 1061390a385Sgjelinek #define LOOPBACK_IF "lo0" 1071390a385Sgjelinek #define SOCKET_AF(af) (((af) == AF_UNSPEC) ? AF_INET : (af)) 1081390a385Sgjelinek 1091390a385Sgjelinek struct net_if { 1101390a385Sgjelinek char *name; 1111390a385Sgjelinek int af; 1121390a385Sgjelinek }; 1131390a385Sgjelinek 1147c478bd9Sstevel@tonic-gate /* 0755 is the default directory mode. */ 1157c478bd9Sstevel@tonic-gate #define DEFAULT_DIR_MODE \ 1167c478bd9Sstevel@tonic-gate (S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH) 1177c478bd9Sstevel@tonic-gate 1187c478bd9Sstevel@tonic-gate struct cmd { 1197c478bd9Sstevel@tonic-gate uint_t cmd_num; /* command number */ 1207c478bd9Sstevel@tonic-gate char *cmd_name; /* command name */ 1217c478bd9Sstevel@tonic-gate char *short_usage; /* short form help */ 1227c478bd9Sstevel@tonic-gate int (*handler)(int argc, char *argv[]); /* function to call */ 1237c478bd9Sstevel@tonic-gate 1247c478bd9Sstevel@tonic-gate }; 1257c478bd9Sstevel@tonic-gate 1267c478bd9Sstevel@tonic-gate #define SHELP_HELP "help" 1273f2f09c1Sdp #define SHELP_BOOT "boot [-- boot_arguments]" 1287c478bd9Sstevel@tonic-gate #define SHELP_HALT "halt" 1297c478bd9Sstevel@tonic-gate #define SHELP_READY "ready" 1303f2f09c1Sdp #define SHELP_REBOOT "reboot [-- boot_arguments]" 1317c478bd9Sstevel@tonic-gate #define SHELP_LIST "list [-cipv]" 1327c478bd9Sstevel@tonic-gate #define SHELP_VERIFY "verify" 1339acbbeafSnn35248 #define SHELP_INSTALL "install [-x nodataset] [brand-specific args]" 1347c478bd9Sstevel@tonic-gate #define SHELP_UNINSTALL "uninstall [-F]" 1350b5de56dSgjelinek #define SHELP_CLONE "clone [-m method] [-s <ZFS snapshot>] zonename" 136865e09a4Sgjelinek #define SHELP_MOVE "move zonepath" 1378cd327d5Sgjelinek #define SHELP_DETACH "detach [-n]" 1388cd327d5Sgjelinek #define SHELP_ATTACH "attach [-F] [-n <path>]" 139555afedfScarlsonj #define SHELP_MARK "mark incomplete" 1407c478bd9Sstevel@tonic-gate 1419acbbeafSnn35248 #define EXEC_PREFIX "exec " 1429acbbeafSnn35248 #define EXEC_LEN (strlen(EXEC_PREFIX)) 1439acbbeafSnn35248 #define RMCOMMAND "/usr/bin/rm -rf" 1449acbbeafSnn35248 1459acbbeafSnn35248 static int cleanup_zonepath(char *, boolean_t); 1469acbbeafSnn35248 147f4b3ec61Sdh155122 extern int ifname_open(char *); 148f4b3ec61Sdh155122 1497c478bd9Sstevel@tonic-gate static int help_func(int argc, char *argv[]); 1507c478bd9Sstevel@tonic-gate static int ready_func(int argc, char *argv[]); 1517c478bd9Sstevel@tonic-gate static int boot_func(int argc, char *argv[]); 1527c478bd9Sstevel@tonic-gate static int halt_func(int argc, char *argv[]); 1537c478bd9Sstevel@tonic-gate static int reboot_func(int argc, char *argv[]); 1547c478bd9Sstevel@tonic-gate static int list_func(int argc, char *argv[]); 1557c478bd9Sstevel@tonic-gate static int verify_func(int argc, char *argv[]); 1567c478bd9Sstevel@tonic-gate static int install_func(int argc, char *argv[]); 1577c478bd9Sstevel@tonic-gate static int uninstall_func(int argc, char *argv[]); 158108322fbScarlsonj static int mount_func(int argc, char *argv[]); 159108322fbScarlsonj static int unmount_func(int argc, char *argv[]); 160865e09a4Sgjelinek static int clone_func(int argc, char *argv[]); 161865e09a4Sgjelinek static int move_func(int argc, char *argv[]); 162ee519a1fSgjelinek static int detach_func(int argc, char *argv[]); 163ee519a1fSgjelinek static int attach_func(int argc, char *argv[]); 164555afedfScarlsonj static int mark_func(int argc, char *argv[]); 1650209230bSgjelinek static int apply_func(int argc, char *argv[]); 1667c478bd9Sstevel@tonic-gate static int sanity_check(char *zone, int cmd_num, boolean_t running, 1679acbbeafSnn35248 boolean_t unsafe_when_running, boolean_t force); 1687c478bd9Sstevel@tonic-gate static int cmd_match(char *cmd); 169ce28b40eSzt129084 static int verify_details(int, char *argv[]); 170ce28b40eSzt129084 static int verify_brand(zone_dochandle_t, int, char *argv[]); 171ce28b40eSzt129084 static int invoke_brand_handler(int, char *argv[]); 1727c478bd9Sstevel@tonic-gate 1737c478bd9Sstevel@tonic-gate static struct cmd cmdtab[] = { 1747c478bd9Sstevel@tonic-gate { CMD_HELP, "help", SHELP_HELP, help_func }, 1757c478bd9Sstevel@tonic-gate { CMD_BOOT, "boot", SHELP_BOOT, boot_func }, 1767c478bd9Sstevel@tonic-gate { CMD_HALT, "halt", SHELP_HALT, halt_func }, 1777c478bd9Sstevel@tonic-gate { CMD_READY, "ready", SHELP_READY, ready_func }, 1787c478bd9Sstevel@tonic-gate { CMD_REBOOT, "reboot", SHELP_REBOOT, reboot_func }, 1797c478bd9Sstevel@tonic-gate { CMD_LIST, "list", SHELP_LIST, list_func }, 1807c478bd9Sstevel@tonic-gate { CMD_VERIFY, "verify", SHELP_VERIFY, verify_func }, 1817c478bd9Sstevel@tonic-gate { CMD_INSTALL, "install", SHELP_INSTALL, install_func }, 1827c478bd9Sstevel@tonic-gate { CMD_UNINSTALL, "uninstall", SHELP_UNINSTALL, 183108322fbScarlsonj uninstall_func }, 184865e09a4Sgjelinek /* mount and unmount are private commands for admin/install */ 185108322fbScarlsonj { CMD_MOUNT, "mount", NULL, mount_func }, 186865e09a4Sgjelinek { CMD_UNMOUNT, "unmount", NULL, unmount_func }, 187865e09a4Sgjelinek { CMD_CLONE, "clone", SHELP_CLONE, clone_func }, 188ee519a1fSgjelinek { CMD_MOVE, "move", SHELP_MOVE, move_func }, 189ee519a1fSgjelinek { CMD_DETACH, "detach", SHELP_DETACH, detach_func }, 190555afedfScarlsonj { CMD_ATTACH, "attach", SHELP_ATTACH, attach_func }, 1910209230bSgjelinek { CMD_MARK, "mark", SHELP_MARK, mark_func }, 1920209230bSgjelinek { CMD_APPLY, "apply", NULL, apply_func } 1937c478bd9Sstevel@tonic-gate }; 1947c478bd9Sstevel@tonic-gate 1957c478bd9Sstevel@tonic-gate /* global variables */ 1967c478bd9Sstevel@tonic-gate 1977c478bd9Sstevel@tonic-gate /* set early in main(), never modified thereafter, used all over the place */ 1987c478bd9Sstevel@tonic-gate static char *execname; 1999acbbeafSnn35248 static char target_brand[MAXNAMELEN]; 2007c478bd9Sstevel@tonic-gate static char *locale; 2010b5de56dSgjelinek char *target_zone; 202555afedfScarlsonj static char *target_uuid; 2037c478bd9Sstevel@tonic-gate 2047c478bd9Sstevel@tonic-gate /* used in do_subproc() and signal handler */ 2057c478bd9Sstevel@tonic-gate static volatile boolean_t child_killed; 2069acbbeafSnn35248 static int do_subproc_cnt = 0; 2079acbbeafSnn35248 2089acbbeafSnn35248 /* 2099acbbeafSnn35248 * Used to indicate whether this zoneadm instance has another zoneadm 2109acbbeafSnn35248 * instance in its ancestry. 2119acbbeafSnn35248 */ 2129acbbeafSnn35248 static boolean_t zoneadm_is_nested = B_FALSE; 2139acbbeafSnn35248 2149acbbeafSnn35248 /* used to track nested zone-lock operations */ 2159acbbeafSnn35248 static int zone_lock_cnt = 0; 2169acbbeafSnn35248 2179acbbeafSnn35248 /* used to communicate lock status to children */ 2189acbbeafSnn35248 #define LOCK_ENV_VAR "_ZONEADM_LOCK_HELD" 2199acbbeafSnn35248 static char zoneadm_lock_held[] = LOCK_ENV_VAR"=1"; 2209acbbeafSnn35248 static char zoneadm_lock_not_held[] = LOCK_ENV_VAR"=0"; 2217c478bd9Sstevel@tonic-gate 2220b5de56dSgjelinek char * 2237c478bd9Sstevel@tonic-gate cmd_to_str(int cmd_num) 2247c478bd9Sstevel@tonic-gate { 2257c478bd9Sstevel@tonic-gate assert(cmd_num >= CMD_MIN && cmd_num <= CMD_MAX); 2267c478bd9Sstevel@tonic-gate return (cmdtab[cmd_num].cmd_name); 2277c478bd9Sstevel@tonic-gate } 2287c478bd9Sstevel@tonic-gate 2297c478bd9Sstevel@tonic-gate /* This is a separate function because of gettext() wrapping. */ 2307c478bd9Sstevel@tonic-gate static char * 2317c478bd9Sstevel@tonic-gate long_help(int cmd_num) 2327c478bd9Sstevel@tonic-gate { 2337e362f58Scomay assert(cmd_num >= CMD_MIN && cmd_num <= CMD_MAX); 2347c478bd9Sstevel@tonic-gate switch (cmd_num) { 2357c478bd9Sstevel@tonic-gate case CMD_HELP: 2367c478bd9Sstevel@tonic-gate return (gettext("Print usage message.")); 2377c478bd9Sstevel@tonic-gate case CMD_BOOT: 2383f2f09c1Sdp return (gettext("Activates (boots) specified zone. See " 2393f2f09c1Sdp "zoneadm(1m) for valid boot\n\targuments.")); 2407c478bd9Sstevel@tonic-gate case CMD_HALT: 2419e518655Sgjelinek return (gettext("Halts specified zone, bypassing shutdown " 2429e518655Sgjelinek "scripts and removing runtime\n\tresources of the zone.")); 2437c478bd9Sstevel@tonic-gate case CMD_READY: 2449e518655Sgjelinek return (gettext("Prepares a zone for running applications but " 2459e518655Sgjelinek "does not start any user\n\tprocesses in the zone.")); 2467c478bd9Sstevel@tonic-gate case CMD_REBOOT: 2479e518655Sgjelinek return (gettext("Restarts the zone (equivalent to a halt / " 2483f2f09c1Sdp "boot sequence).\n\tFails if the zone is not active. " 2493f2f09c1Sdp "See zoneadm(1m) for valid boot\n\targuments.")); 2507c478bd9Sstevel@tonic-gate case CMD_LIST: 2517c478bd9Sstevel@tonic-gate return (gettext("Lists the current zones, or a " 2527c478bd9Sstevel@tonic-gate "specific zone if indicated. By default,\n\tall " 2537c478bd9Sstevel@tonic-gate "running zones are listed, though this can be " 2547c478bd9Sstevel@tonic-gate "expanded to all\n\tinstalled zones with the -i " 2557c478bd9Sstevel@tonic-gate "option or all configured zones with the\n\t-c " 256555afedfScarlsonj "option. When used with the general -z <zone> and/or -u " 257555afedfScarlsonj "<uuid-match>\n\toptions, lists only the specified " 258555afedfScarlsonj "matching zone, but lists it\n\tregardless of its state, " 259555afedfScarlsonj "and the -i and -c options are disallowed. The\n\t-v " 260555afedfScarlsonj "option can be used to display verbose information: zone " 261555afedfScarlsonj "name, id,\n\tcurrent state, root directory and options. " 262555afedfScarlsonj "The -p option can be used\n\tto request machine-parsable " 263555afedfScarlsonj "output. The -v and -p options are mutually\n\texclusive." 264555afedfScarlsonj " If neither -v nor -p is used, just the zone name is " 265555afedfScarlsonj "listed.")); 2667c478bd9Sstevel@tonic-gate case CMD_VERIFY: 2677c478bd9Sstevel@tonic-gate return (gettext("Check to make sure the configuration " 2687c478bd9Sstevel@tonic-gate "can safely be instantiated\n\ton the machine: " 2697c478bd9Sstevel@tonic-gate "physical network interfaces exist, etc.")); 2707c478bd9Sstevel@tonic-gate case CMD_INSTALL: 2710b5de56dSgjelinek return (gettext("Install the configuration on to the system. " 2720b5de56dSgjelinek "The -x nodataset option\n\tcan be used to prevent the " 2730b5de56dSgjelinek "creation of a new ZFS file system for the\n\tzone " 2749acbbeafSnn35248 "(assuming the zonepath is within a ZFS file system).\n\t" 2759acbbeafSnn35248 "All other arguments are passed to the brand installation " 2769acbbeafSnn35248 "function;\n\tsee brand(4) for more information.")); 2777c478bd9Sstevel@tonic-gate case CMD_UNINSTALL: 2789e518655Sgjelinek return (gettext("Uninstall the configuration from the system. " 2799e518655Sgjelinek "The -F flag can be used\n\tto force the action.")); 280865e09a4Sgjelinek case CMD_CLONE: 2810b5de56dSgjelinek return (gettext("Clone the installation of another zone. " 2820b5de56dSgjelinek "The -m option can be used to\n\tspecify 'copy' which " 2830b5de56dSgjelinek "forces a copy of the source zone. The -s option\n\t" 2840b5de56dSgjelinek "can be used to specify the name of a ZFS snapshot " 2850b5de56dSgjelinek "that was taken from\n\ta previous clone command. The " 2860b5de56dSgjelinek "snapshot will be used as the source\n\tinstead of " 2870b5de56dSgjelinek "creating a new ZFS snapshot.")); 288865e09a4Sgjelinek case CMD_MOVE: 289865e09a4Sgjelinek return (gettext("Move the zone to a new zonepath.")); 2909e518655Sgjelinek case CMD_DETACH: 2919e518655Sgjelinek return (gettext("Detach the zone from the system. The zone " 2929e518655Sgjelinek "state is changed to\n\t'configured' (but the files under " 2939e518655Sgjelinek "the zonepath are untouched).\n\tThe zone can subsequently " 2949e518655Sgjelinek "be attached, or can be moved to another\n\tsystem and " 2958cd327d5Sgjelinek "attached there. The -n option can be used to specify\n\t" 2968cd327d5Sgjelinek "'no-execute' mode. When -n is used, the information " 2978cd327d5Sgjelinek "needed to attach\n\tthe zone is sent to standard output " 2988cd327d5Sgjelinek "but the zone is not actually\n\tdetached.")); 2999e518655Sgjelinek case CMD_ATTACH: 3009e518655Sgjelinek return (gettext("Attach the zone to the system. The zone " 3019e518655Sgjelinek "state must be 'configured'\n\tprior to attach; upon " 3029e518655Sgjelinek "successful completion, the zone state will be\n\t" 3039e518655Sgjelinek "'installed'. The system software on the current " 3049e518655Sgjelinek "system must be\n\tcompatible with the software on the " 3059e518655Sgjelinek "zone's original system.\n\tSpecify -F to force the attach " 3068cd327d5Sgjelinek "and skip software compatibility tests.\n\tThe -n option " 3078cd327d5Sgjelinek "can be used to specify 'no-execute' mode. When -n is\n\t" 3088cd327d5Sgjelinek "used, the information needed to attach the zone is read " 3098cd327d5Sgjelinek "from the\n\tspecified path and the configuration is only " 3108cd327d5Sgjelinek "validated. The path can\n\tbe '-' to specify standard " 3118cd327d5Sgjelinek "input.")); 312555afedfScarlsonj case CMD_MARK: 313555afedfScarlsonj return (gettext("Set the state of the zone. This can be used " 314555afedfScarlsonj "to force the zone\n\tstate to 'incomplete' " 315555afedfScarlsonj "administratively if some activity has rendered\n\tthe " 316555afedfScarlsonj "zone permanently unusable. The only valid state that " 317555afedfScarlsonj "may be\n\tspecified is 'incomplete'.")); 318108322fbScarlsonj default: 319108322fbScarlsonj return (""); 3207c478bd9Sstevel@tonic-gate } 3217c478bd9Sstevel@tonic-gate /* NOTREACHED */ 3227e362f58Scomay return (NULL); 3237c478bd9Sstevel@tonic-gate } 3247c478bd9Sstevel@tonic-gate 3257c478bd9Sstevel@tonic-gate /* 3267c478bd9Sstevel@tonic-gate * Called with explicit B_TRUE when help is explicitly requested, B_FALSE for 3277c478bd9Sstevel@tonic-gate * unexpected errors. 3287c478bd9Sstevel@tonic-gate */ 3297c478bd9Sstevel@tonic-gate 3307c478bd9Sstevel@tonic-gate static int 3317c478bd9Sstevel@tonic-gate usage(boolean_t explicit) 3327c478bd9Sstevel@tonic-gate { 3337c478bd9Sstevel@tonic-gate int i; 3347c478bd9Sstevel@tonic-gate FILE *fd = explicit ? stdout : stderr; 3357c478bd9Sstevel@tonic-gate 3367c478bd9Sstevel@tonic-gate (void) fprintf(fd, "%s:\t%s help\n", gettext("usage"), execname); 337555afedfScarlsonj (void) fprintf(fd, "\t%s [-z <zone>] [-u <uuid-match>] list\n", 338555afedfScarlsonj execname); 339555afedfScarlsonj (void) fprintf(fd, "\t%s {-z <zone>|-u <uuid-match>} <%s>\n", execname, 3407c478bd9Sstevel@tonic-gate gettext("subcommand")); 3417c478bd9Sstevel@tonic-gate (void) fprintf(fd, "\n%s:\n\n", gettext("Subcommands")); 3427c478bd9Sstevel@tonic-gate for (i = CMD_MIN; i <= CMD_MAX; i++) { 343108322fbScarlsonj if (cmdtab[i].short_usage == NULL) 344108322fbScarlsonj continue; 3457c478bd9Sstevel@tonic-gate (void) fprintf(fd, "%s\n", cmdtab[i].short_usage); 3467c478bd9Sstevel@tonic-gate if (explicit) 3477c478bd9Sstevel@tonic-gate (void) fprintf(fd, "\t%s\n\n", long_help(i)); 3487c478bd9Sstevel@tonic-gate } 3497c478bd9Sstevel@tonic-gate if (!explicit) 3507c478bd9Sstevel@tonic-gate (void) fputs("\n", fd); 3517c478bd9Sstevel@tonic-gate return (Z_USAGE); 3527c478bd9Sstevel@tonic-gate } 3537c478bd9Sstevel@tonic-gate 3547c478bd9Sstevel@tonic-gate static void 3557c478bd9Sstevel@tonic-gate sub_usage(char *short_usage, int cmd_num) 3567c478bd9Sstevel@tonic-gate { 3577c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "%s:\t%s\n", gettext("usage"), short_usage); 3587c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "\t%s\n", long_help(cmd_num)); 3597c478bd9Sstevel@tonic-gate } 3607c478bd9Sstevel@tonic-gate 3617c478bd9Sstevel@tonic-gate /* 3627c478bd9Sstevel@tonic-gate * zperror() is like perror(3c) except that this also prints the executable 3637c478bd9Sstevel@tonic-gate * name at the start of the message, and takes a boolean indicating whether 3647c478bd9Sstevel@tonic-gate * to call libc'c strerror() or that from libzonecfg. 3657c478bd9Sstevel@tonic-gate */ 3667c478bd9Sstevel@tonic-gate 3670b5de56dSgjelinek void 3687c478bd9Sstevel@tonic-gate zperror(const char *str, boolean_t zonecfg_error) 3697c478bd9Sstevel@tonic-gate { 3707c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "%s: %s: %s\n", execname, str, 3717c478bd9Sstevel@tonic-gate zonecfg_error ? zonecfg_strerror(errno) : strerror(errno)); 3727c478bd9Sstevel@tonic-gate } 3737c478bd9Sstevel@tonic-gate 3747c478bd9Sstevel@tonic-gate /* 3757c478bd9Sstevel@tonic-gate * zperror2() is very similar to zperror() above, except it also prints a 3767c478bd9Sstevel@tonic-gate * supplied zone name after the executable. 3777c478bd9Sstevel@tonic-gate * 3787c478bd9Sstevel@tonic-gate * All current consumers of this function want libzonecfg's strerror() rather 3797c478bd9Sstevel@tonic-gate * than libc's; if this ever changes, this function can be made more generic 3807c478bd9Sstevel@tonic-gate * like zperror() above. 3817c478bd9Sstevel@tonic-gate */ 3827c478bd9Sstevel@tonic-gate 3830b5de56dSgjelinek void 3847c478bd9Sstevel@tonic-gate zperror2(const char *zone, const char *str) 3857c478bd9Sstevel@tonic-gate { 3867c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "%s: %s: %s: %s\n", execname, zone, str, 3877c478bd9Sstevel@tonic-gate zonecfg_strerror(errno)); 3887c478bd9Sstevel@tonic-gate } 3897c478bd9Sstevel@tonic-gate 3907c478bd9Sstevel@tonic-gate /* PRINTFLIKE1 */ 3910b5de56dSgjelinek void 3927c478bd9Sstevel@tonic-gate zerror(const char *fmt, ...) 3937c478bd9Sstevel@tonic-gate { 3947c478bd9Sstevel@tonic-gate va_list alist; 3957c478bd9Sstevel@tonic-gate 3967c478bd9Sstevel@tonic-gate va_start(alist, fmt); 3977c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "%s: ", execname); 3987c478bd9Sstevel@tonic-gate if (target_zone != NULL) 3997c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "zone '%s': ", target_zone); 4007c478bd9Sstevel@tonic-gate (void) vfprintf(stderr, fmt, alist); 4017c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "\n"); 4027c478bd9Sstevel@tonic-gate va_end(alist); 4037c478bd9Sstevel@tonic-gate } 4047c478bd9Sstevel@tonic-gate 4057c478bd9Sstevel@tonic-gate static void * 4067c478bd9Sstevel@tonic-gate safe_calloc(size_t nelem, size_t elsize) 4077c478bd9Sstevel@tonic-gate { 4087c478bd9Sstevel@tonic-gate void *r = calloc(nelem, elsize); 4097c478bd9Sstevel@tonic-gate 4107c478bd9Sstevel@tonic-gate if (r == NULL) { 4117c478bd9Sstevel@tonic-gate zerror(gettext("failed to allocate %lu bytes: %s"), 4127c478bd9Sstevel@tonic-gate (ulong_t)nelem * elsize, strerror(errno)); 4137c478bd9Sstevel@tonic-gate exit(Z_ERR); 4147c478bd9Sstevel@tonic-gate } 4157c478bd9Sstevel@tonic-gate return (r); 4167c478bd9Sstevel@tonic-gate } 4177c478bd9Sstevel@tonic-gate 4187c478bd9Sstevel@tonic-gate static void 4197c478bd9Sstevel@tonic-gate zone_print(zone_entry_t *zent, boolean_t verbose, boolean_t parsable) 4207c478bd9Sstevel@tonic-gate { 4217c478bd9Sstevel@tonic-gate static boolean_t firsttime = B_TRUE; 422f4b3ec61Sdh155122 char *ip_type_str; 423f4b3ec61Sdh155122 424f4b3ec61Sdh155122 if (zent->ziptype == ZS_EXCLUSIVE) 425f4b3ec61Sdh155122 ip_type_str = "excl"; 426f4b3ec61Sdh155122 else 427f4b3ec61Sdh155122 ip_type_str = "shared"; 4287c478bd9Sstevel@tonic-gate 4297c478bd9Sstevel@tonic-gate assert(!(verbose && parsable)); 4307c478bd9Sstevel@tonic-gate if (firsttime && verbose) { 4317c478bd9Sstevel@tonic-gate firsttime = B_FALSE; 432f4b3ec61Sdh155122 (void) printf("%*s %-16s %-10s %-30s %-8s %-6s\n", 433f4b3ec61Sdh155122 ZONEID_WIDTH, "ID", "NAME", "STATUS", "PATH", "BRAND", 434f4b3ec61Sdh155122 "IP"); 4357c478bd9Sstevel@tonic-gate } 4367c478bd9Sstevel@tonic-gate if (!verbose) { 437555afedfScarlsonj char *cp, *clim; 438555afedfScarlsonj 4397c478bd9Sstevel@tonic-gate if (!parsable) { 4407c478bd9Sstevel@tonic-gate (void) printf("%s\n", zent->zname); 4417c478bd9Sstevel@tonic-gate return; 4427c478bd9Sstevel@tonic-gate } 4437c478bd9Sstevel@tonic-gate if (zent->zid == ZONE_ID_UNDEFINED) 4447c478bd9Sstevel@tonic-gate (void) printf("-"); 4457c478bd9Sstevel@tonic-gate else 4467c478bd9Sstevel@tonic-gate (void) printf("%lu", zent->zid); 447555afedfScarlsonj (void) printf(":%s:%s:", zent->zname, zent->zstate_str); 448555afedfScarlsonj cp = zent->zroot; 449555afedfScarlsonj while ((clim = strchr(cp, ':')) != NULL) { 450555afedfScarlsonj (void) printf("%.*s\\:", clim - cp, cp); 451555afedfScarlsonj cp = clim + 1; 452555afedfScarlsonj } 453f4b3ec61Sdh155122 (void) printf("%s:%s:%s:%s\n", cp, zent->zuuid, zent->zbrand, 454f4b3ec61Sdh155122 ip_type_str); 4557c478bd9Sstevel@tonic-gate return; 4567c478bd9Sstevel@tonic-gate } 4577c478bd9Sstevel@tonic-gate if (zent->zstate_str != NULL) { 4587c478bd9Sstevel@tonic-gate if (zent->zid == ZONE_ID_UNDEFINED) 4597c478bd9Sstevel@tonic-gate (void) printf("%*s", ZONEID_WIDTH, "-"); 4607c478bd9Sstevel@tonic-gate else 4617c478bd9Sstevel@tonic-gate (void) printf("%*lu", ZONEID_WIDTH, zent->zid); 462f4b3ec61Sdh155122 (void) printf(" %-16s %-10s %-30s %-8s %-6s\n", zent->zname, 463f4b3ec61Sdh155122 zent->zstate_str, zent->zroot, zent->zbrand, ip_type_str); 4647c478bd9Sstevel@tonic-gate } 4657c478bd9Sstevel@tonic-gate } 4667c478bd9Sstevel@tonic-gate 4677c478bd9Sstevel@tonic-gate static int 468108322fbScarlsonj lookup_zone_info(const char *zone_name, zoneid_t zid, zone_entry_t *zent) 4697c478bd9Sstevel@tonic-gate { 47045916cd2Sjpk char root[MAXPATHLEN], *cp; 4717c478bd9Sstevel@tonic-gate int err; 472555afedfScarlsonj uuid_t uuid; 4737c478bd9Sstevel@tonic-gate 4747c478bd9Sstevel@tonic-gate (void) strlcpy(zent->zname, zone_name, sizeof (zent->zname)); 4757c478bd9Sstevel@tonic-gate (void) strlcpy(zent->zroot, "???", sizeof (zent->zroot)); 4769acbbeafSnn35248 (void) strlcpy(zent->zbrand, "???", sizeof (zent->zbrand)); 4777c478bd9Sstevel@tonic-gate zent->zstate_str = "???"; 4787c478bd9Sstevel@tonic-gate 479108322fbScarlsonj zent->zid = zid; 4807c478bd9Sstevel@tonic-gate 481555afedfScarlsonj if (zonecfg_get_uuid(zone_name, uuid) == Z_OK && 482555afedfScarlsonj !uuid_is_null(uuid)) 483555afedfScarlsonj uuid_unparse(uuid, zent->zuuid); 484555afedfScarlsonj else 485555afedfScarlsonj zent->zuuid[0] = '\0'; 486555afedfScarlsonj 48745916cd2Sjpk /* 48845916cd2Sjpk * For labeled zones which query the zone path of lower-level 48945916cd2Sjpk * zones, the path needs to be adjusted to drop the final 49045916cd2Sjpk * "/root" component. This adjusted path is then useful 49145916cd2Sjpk * for reading down any exported directories from the 49245916cd2Sjpk * lower-level zone. 49345916cd2Sjpk */ 49445916cd2Sjpk if (is_system_labeled() && zent->zid != ZONE_ID_UNDEFINED) { 49545916cd2Sjpk if (zone_getattr(zent->zid, ZONE_ATTR_ROOT, zent->zroot, 49645916cd2Sjpk sizeof (zent->zroot)) == -1) { 49745916cd2Sjpk zperror2(zent->zname, 49845916cd2Sjpk gettext("could not get zone path.")); 49945916cd2Sjpk return (Z_ERR); 50045916cd2Sjpk } 50145916cd2Sjpk cp = zent->zroot + strlen(zent->zroot) - 5; 50245916cd2Sjpk if (cp > zent->zroot && strcmp(cp, "/root") == 0) 50345916cd2Sjpk *cp = 0; 50445916cd2Sjpk } else { 50545916cd2Sjpk if ((err = zone_get_zonepath(zent->zname, root, 50645916cd2Sjpk sizeof (root))) != Z_OK) { 5077c478bd9Sstevel@tonic-gate errno = err; 50845916cd2Sjpk zperror2(zent->zname, 50945916cd2Sjpk gettext("could not get zone path.")); 5107c478bd9Sstevel@tonic-gate return (Z_ERR); 5117c478bd9Sstevel@tonic-gate } 5127c478bd9Sstevel@tonic-gate (void) strlcpy(zent->zroot, root, sizeof (zent->zroot)); 51345916cd2Sjpk } 5147c478bd9Sstevel@tonic-gate 5157c478bd9Sstevel@tonic-gate if ((err = zone_get_state(zent->zname, &zent->zstate_num)) != Z_OK) { 5167c478bd9Sstevel@tonic-gate errno = err; 5177c478bd9Sstevel@tonic-gate zperror2(zent->zname, gettext("could not get state")); 5187c478bd9Sstevel@tonic-gate return (Z_ERR); 5197c478bd9Sstevel@tonic-gate } 5207c478bd9Sstevel@tonic-gate zent->zstate_str = zone_state_str(zent->zstate_num); 521bafa7067Snn35248 522bafa7067Snn35248 /* 523bafa7067Snn35248 * A zone's brand is only available in the .xml file describing it, 524bafa7067Snn35248 * which is only visible to the global zone. This causes 525bafa7067Snn35248 * zone_get_brand() to fail when called from within a non-global 526bafa7067Snn35248 * zone. Fortunately we only do this on labeled systems, where we 527bafa7067Snn35248 * know all zones are native. 528bafa7067Snn35248 */ 529bafa7067Snn35248 if (getzoneid() != GLOBAL_ZONEID) { 530bafa7067Snn35248 assert(is_system_labeled() != 0); 531bafa7067Snn35248 (void) strlcpy(zent->zbrand, NATIVE_BRAND_NAME, 532bafa7067Snn35248 sizeof (zent->zbrand)); 533bafa7067Snn35248 } else if (zone_get_brand(zent->zname, zent->zbrand, 5349acbbeafSnn35248 sizeof (zent->zbrand)) != Z_OK) { 5359acbbeafSnn35248 zperror2(zent->zname, gettext("could not get brand name")); 5369acbbeafSnn35248 return (Z_ERR); 5379acbbeafSnn35248 } 5387c478bd9Sstevel@tonic-gate 539f4b3ec61Sdh155122 /* 540f4b3ec61Sdh155122 * Get ip type of the zone. 541f4b3ec61Sdh155122 * Note for global zone, ZS_SHARED is set always. 542f4b3ec61Sdh155122 */ 543f4b3ec61Sdh155122 if (zid == GLOBAL_ZONEID) { 544f4b3ec61Sdh155122 zent->ziptype = ZS_SHARED; 545f4b3ec61Sdh155122 } else { 546f4b3ec61Sdh155122 547f4b3ec61Sdh155122 if (zent->zstate_num == ZONE_STATE_RUNNING) { 548f4b3ec61Sdh155122 ushort_t flags; 549f4b3ec61Sdh155122 550f4b3ec61Sdh155122 if (zone_getattr(zid, ZONE_ATTR_FLAGS, &flags, 551f4b3ec61Sdh155122 sizeof (flags)) < 0) { 552f4b3ec61Sdh155122 zperror2(zent->zname, 553f4b3ec61Sdh155122 gettext("could not get zone flags")); 554f4b3ec61Sdh155122 return (Z_ERR); 555f4b3ec61Sdh155122 } 556f4b3ec61Sdh155122 if (flags & ZF_NET_EXCL) 557f4b3ec61Sdh155122 zent->ziptype = ZS_EXCLUSIVE; 558f4b3ec61Sdh155122 else 559f4b3ec61Sdh155122 zent->ziptype = ZS_SHARED; 560f4b3ec61Sdh155122 } else { 561f4b3ec61Sdh155122 zone_dochandle_t handle; 562f4b3ec61Sdh155122 563f4b3ec61Sdh155122 if ((handle = zonecfg_init_handle()) == NULL) { 564f4b3ec61Sdh155122 zperror2(zent->zname, 565f4b3ec61Sdh155122 gettext("could not init handle")); 566f4b3ec61Sdh155122 return (Z_ERR); 567f4b3ec61Sdh155122 } 568f4b3ec61Sdh155122 if ((err = zonecfg_get_handle(zent->zname, handle)) 569f4b3ec61Sdh155122 != Z_OK) { 570f4b3ec61Sdh155122 zperror2(zent->zname, 571f4b3ec61Sdh155122 gettext("could not get handle")); 572f4b3ec61Sdh155122 zonecfg_fini_handle(handle); 573f4b3ec61Sdh155122 return (Z_ERR); 574f4b3ec61Sdh155122 } 575f4b3ec61Sdh155122 576f4b3ec61Sdh155122 if ((err = zonecfg_get_iptype(handle, &zent->ziptype)) 577f4b3ec61Sdh155122 != Z_OK) { 578f4b3ec61Sdh155122 zperror2(zent->zname, 579f4b3ec61Sdh155122 gettext("could not get ip-type")); 580f4b3ec61Sdh155122 zonecfg_fini_handle(handle); 581f4b3ec61Sdh155122 return (Z_ERR); 582f4b3ec61Sdh155122 } 583f4b3ec61Sdh155122 zonecfg_fini_handle(handle); 584f4b3ec61Sdh155122 } 585f4b3ec61Sdh155122 } 586f4b3ec61Sdh155122 5877c478bd9Sstevel@tonic-gate return (Z_OK); 5887c478bd9Sstevel@tonic-gate } 5897c478bd9Sstevel@tonic-gate 5907c478bd9Sstevel@tonic-gate /* 5917c478bd9Sstevel@tonic-gate * fetch_zents() calls zone_list(2) to find out how many zones are running 5927c478bd9Sstevel@tonic-gate * (which is stored in the global nzents), then calls zone_list(2) again 5937c478bd9Sstevel@tonic-gate * to fetch the list of running zones (stored in the global zents). This 5947c478bd9Sstevel@tonic-gate * function may be called multiple times, so if zents is already set, we 5957c478bd9Sstevel@tonic-gate * return immediately to save work. 5967c478bd9Sstevel@tonic-gate */ 5977c478bd9Sstevel@tonic-gate 5987c478bd9Sstevel@tonic-gate static int 599108322fbScarlsonj fetch_zents(void) 6007c478bd9Sstevel@tonic-gate { 6017c478bd9Sstevel@tonic-gate zoneid_t *zids = NULL; 6027c478bd9Sstevel@tonic-gate uint_t nzents_saved; 603108322fbScarlsonj int i, retv; 604108322fbScarlsonj FILE *fp; 605108322fbScarlsonj boolean_t inaltroot; 606108322fbScarlsonj zone_entry_t *zentp; 6077c478bd9Sstevel@tonic-gate 6087c478bd9Sstevel@tonic-gate if (nzents > 0) 6097c478bd9Sstevel@tonic-gate return (Z_OK); 6107c478bd9Sstevel@tonic-gate 6117c478bd9Sstevel@tonic-gate if (zone_list(NULL, &nzents) != 0) { 6127c478bd9Sstevel@tonic-gate zperror(gettext("failed to get zoneid list"), B_FALSE); 6137c478bd9Sstevel@tonic-gate return (Z_ERR); 6147c478bd9Sstevel@tonic-gate } 6157c478bd9Sstevel@tonic-gate 6167c478bd9Sstevel@tonic-gate again: 6177c478bd9Sstevel@tonic-gate if (nzents == 0) 6187c478bd9Sstevel@tonic-gate return (Z_OK); 6197c478bd9Sstevel@tonic-gate 6207c478bd9Sstevel@tonic-gate zids = safe_calloc(nzents, sizeof (zoneid_t)); 6217c478bd9Sstevel@tonic-gate nzents_saved = nzents; 6227c478bd9Sstevel@tonic-gate 6237c478bd9Sstevel@tonic-gate if (zone_list(zids, &nzents) != 0) { 6247c478bd9Sstevel@tonic-gate zperror(gettext("failed to get zone list"), B_FALSE); 6257c478bd9Sstevel@tonic-gate free(zids); 6267c478bd9Sstevel@tonic-gate return (Z_ERR); 6277c478bd9Sstevel@tonic-gate } 6287c478bd9Sstevel@tonic-gate if (nzents != nzents_saved) { 6297c478bd9Sstevel@tonic-gate /* list changed, try again */ 6307c478bd9Sstevel@tonic-gate free(zids); 6317c478bd9Sstevel@tonic-gate goto again; 6327c478bd9Sstevel@tonic-gate } 6337c478bd9Sstevel@tonic-gate 6347c478bd9Sstevel@tonic-gate zents = safe_calloc(nzents, sizeof (zone_entry_t)); 6357c478bd9Sstevel@tonic-gate 636108322fbScarlsonj inaltroot = zonecfg_in_alt_root(); 637108322fbScarlsonj if (inaltroot) 638108322fbScarlsonj fp = zonecfg_open_scratch("", B_FALSE); 639108322fbScarlsonj else 640108322fbScarlsonj fp = NULL; 641108322fbScarlsonj zentp = zents; 642108322fbScarlsonj retv = Z_OK; 6437c478bd9Sstevel@tonic-gate for (i = 0; i < nzents; i++) { 6447c478bd9Sstevel@tonic-gate char name[ZONENAME_MAX]; 645108322fbScarlsonj char altname[ZONENAME_MAX]; 6467c478bd9Sstevel@tonic-gate 647108322fbScarlsonj if (getzonenamebyid(zids[i], name, sizeof (name)) < 0) { 6487c478bd9Sstevel@tonic-gate zperror(gettext("failed to get zone name"), B_FALSE); 649108322fbScarlsonj retv = Z_ERR; 650108322fbScarlsonj continue; 6517c478bd9Sstevel@tonic-gate } 652108322fbScarlsonj if (zonecfg_is_scratch(name)) { 653108322fbScarlsonj /* Ignore scratch zones by default */ 654108322fbScarlsonj if (!inaltroot) 655108322fbScarlsonj continue; 656108322fbScarlsonj if (fp == NULL || 657108322fbScarlsonj zonecfg_reverse_scratch(fp, name, altname, 658108322fbScarlsonj sizeof (altname), NULL, 0) == -1) { 6595ee84fbdSgjelinek zerror(gettext("could not resolve scratch " 660108322fbScarlsonj "zone %s"), name); 661108322fbScarlsonj retv = Z_ERR; 662108322fbScarlsonj continue; 663108322fbScarlsonj } 664108322fbScarlsonj (void) strcpy(name, altname); 665108322fbScarlsonj } else { 666108322fbScarlsonj /* Ignore non-scratch when in an alternate root */ 667108322fbScarlsonj if (inaltroot && strcmp(name, GLOBAL_ZONENAME) != 0) 668108322fbScarlsonj continue; 669108322fbScarlsonj } 670108322fbScarlsonj if (lookup_zone_info(name, zids[i], zentp) != Z_OK) { 671108322fbScarlsonj zerror(gettext("failed to get zone data")); 672108322fbScarlsonj retv = Z_ERR; 673108322fbScarlsonj continue; 674108322fbScarlsonj } 675108322fbScarlsonj zentp++; 676108322fbScarlsonj } 677108322fbScarlsonj nzents = zentp - zents; 678108322fbScarlsonj if (fp != NULL) 679108322fbScarlsonj zonecfg_close_scratch(fp); 6807c478bd9Sstevel@tonic-gate 6817c478bd9Sstevel@tonic-gate free(zids); 682108322fbScarlsonj return (retv); 6837c478bd9Sstevel@tonic-gate } 6847c478bd9Sstevel@tonic-gate 685108322fbScarlsonj static int 6867c478bd9Sstevel@tonic-gate zone_print_list(zone_state_t min_state, boolean_t verbose, boolean_t parsable) 6877c478bd9Sstevel@tonic-gate { 6887c478bd9Sstevel@tonic-gate int i; 6897c478bd9Sstevel@tonic-gate zone_entry_t zent; 6907c478bd9Sstevel@tonic-gate FILE *cookie; 6917c478bd9Sstevel@tonic-gate char *name; 6927c478bd9Sstevel@tonic-gate 6937c478bd9Sstevel@tonic-gate /* 6947c478bd9Sstevel@tonic-gate * First get the list of running zones from the kernel and print them. 6957c478bd9Sstevel@tonic-gate * If that is all we need, then return. 6967c478bd9Sstevel@tonic-gate */ 697108322fbScarlsonj if ((i = fetch_zents()) != Z_OK) { 6987c478bd9Sstevel@tonic-gate /* 6997c478bd9Sstevel@tonic-gate * No need for error messages; fetch_zents() has already taken 7007c478bd9Sstevel@tonic-gate * care of this. 7017c478bd9Sstevel@tonic-gate */ 702108322fbScarlsonj return (i); 7037c478bd9Sstevel@tonic-gate } 704108322fbScarlsonj for (i = 0; i < nzents; i++) 7057c478bd9Sstevel@tonic-gate zone_print(&zents[i], verbose, parsable); 7067c478bd9Sstevel@tonic-gate if (min_state >= ZONE_STATE_RUNNING) 707108322fbScarlsonj return (Z_OK); 7087c478bd9Sstevel@tonic-gate /* 7097c478bd9Sstevel@tonic-gate * Next, get the full list of zones from the configuration, skipping 7107c478bd9Sstevel@tonic-gate * any we have already printed. 7117c478bd9Sstevel@tonic-gate */ 7127c478bd9Sstevel@tonic-gate cookie = setzoneent(); 7137c478bd9Sstevel@tonic-gate while ((name = getzoneent(cookie)) != NULL) { 7147c478bd9Sstevel@tonic-gate for (i = 0; i < nzents; i++) { 7157c478bd9Sstevel@tonic-gate if (strcmp(zents[i].zname, name) == 0) 7167c478bd9Sstevel@tonic-gate break; 7177c478bd9Sstevel@tonic-gate } 7187c478bd9Sstevel@tonic-gate if (i < nzents) { 7197c478bd9Sstevel@tonic-gate free(name); 7207c478bd9Sstevel@tonic-gate continue; 7217c478bd9Sstevel@tonic-gate } 722108322fbScarlsonj if (lookup_zone_info(name, ZONE_ID_UNDEFINED, &zent) != Z_OK) { 7237c478bd9Sstevel@tonic-gate free(name); 7247c478bd9Sstevel@tonic-gate continue; 7257c478bd9Sstevel@tonic-gate } 7267c478bd9Sstevel@tonic-gate free(name); 7277c478bd9Sstevel@tonic-gate if (zent.zstate_num >= min_state) 7287c478bd9Sstevel@tonic-gate zone_print(&zent, verbose, parsable); 7297c478bd9Sstevel@tonic-gate } 7307c478bd9Sstevel@tonic-gate endzoneent(cookie); 731108322fbScarlsonj return (Z_OK); 7327c478bd9Sstevel@tonic-gate } 7337c478bd9Sstevel@tonic-gate 7347c478bd9Sstevel@tonic-gate static zone_entry_t * 7357c478bd9Sstevel@tonic-gate lookup_running_zone(char *str) 7367c478bd9Sstevel@tonic-gate { 7377c478bd9Sstevel@tonic-gate zoneid_t zoneid; 7387c478bd9Sstevel@tonic-gate char *cp; 7397c478bd9Sstevel@tonic-gate int i; 7407c478bd9Sstevel@tonic-gate 7417c478bd9Sstevel@tonic-gate if (fetch_zents() != Z_OK) 7427c478bd9Sstevel@tonic-gate return (NULL); 7437c478bd9Sstevel@tonic-gate 7447c478bd9Sstevel@tonic-gate for (i = 0; i < nzents; i++) { 7457c478bd9Sstevel@tonic-gate if (strcmp(str, zents[i].zname) == 0) 7467c478bd9Sstevel@tonic-gate return (&zents[i]); 7477c478bd9Sstevel@tonic-gate } 7487c478bd9Sstevel@tonic-gate errno = 0; 7497c478bd9Sstevel@tonic-gate zoneid = strtol(str, &cp, 0); 7507c478bd9Sstevel@tonic-gate if (zoneid < MIN_ZONEID || zoneid > MAX_ZONEID || 7517c478bd9Sstevel@tonic-gate errno != 0 || *cp != '\0') 7527c478bd9Sstevel@tonic-gate return (NULL); 7537c478bd9Sstevel@tonic-gate for (i = 0; i < nzents; i++) { 7547c478bd9Sstevel@tonic-gate if (zoneid == zents[i].zid) 7557c478bd9Sstevel@tonic-gate return (&zents[i]); 7567c478bd9Sstevel@tonic-gate } 7577c478bd9Sstevel@tonic-gate return (NULL); 7587c478bd9Sstevel@tonic-gate } 7597c478bd9Sstevel@tonic-gate 7607c478bd9Sstevel@tonic-gate /* 7617c478bd9Sstevel@tonic-gate * Check a bit in a mode_t: if on is B_TRUE, that bit should be on; if 7627c478bd9Sstevel@tonic-gate * B_FALSE, it should be off. Return B_TRUE if the mode is bad (incorrect). 7637c478bd9Sstevel@tonic-gate */ 7647c478bd9Sstevel@tonic-gate static boolean_t 7657c478bd9Sstevel@tonic-gate bad_mode_bit(mode_t mode, mode_t bit, boolean_t on, char *file) 7667c478bd9Sstevel@tonic-gate { 7677c478bd9Sstevel@tonic-gate char *str; 7687c478bd9Sstevel@tonic-gate 7697c478bd9Sstevel@tonic-gate assert(bit == S_IRUSR || bit == S_IWUSR || bit == S_IXUSR || 7707c478bd9Sstevel@tonic-gate bit == S_IRGRP || bit == S_IWGRP || bit == S_IXGRP || 7717c478bd9Sstevel@tonic-gate bit == S_IROTH || bit == S_IWOTH || bit == S_IXOTH); 7727c478bd9Sstevel@tonic-gate /* 7737c478bd9Sstevel@tonic-gate * TRANSLATION_NOTE 7747c478bd9Sstevel@tonic-gate * The strings below will be used as part of a larger message, 7757c478bd9Sstevel@tonic-gate * either: 7767c478bd9Sstevel@tonic-gate * (file name) must be (owner|group|world) (read|writ|execut)able 7777c478bd9Sstevel@tonic-gate * or 7787c478bd9Sstevel@tonic-gate * (file name) must not be (owner|group|world) (read|writ|execut)able 7797c478bd9Sstevel@tonic-gate */ 7807c478bd9Sstevel@tonic-gate switch (bit) { 7817c478bd9Sstevel@tonic-gate case S_IRUSR: 7827c478bd9Sstevel@tonic-gate str = gettext("owner readable"); 7837c478bd9Sstevel@tonic-gate break; 7847c478bd9Sstevel@tonic-gate case S_IWUSR: 7857c478bd9Sstevel@tonic-gate str = gettext("owner writable"); 7867c478bd9Sstevel@tonic-gate break; 7877c478bd9Sstevel@tonic-gate case S_IXUSR: 7887c478bd9Sstevel@tonic-gate str = gettext("owner executable"); 7897c478bd9Sstevel@tonic-gate break; 7907c478bd9Sstevel@tonic-gate case S_IRGRP: 7917c478bd9Sstevel@tonic-gate str = gettext("group readable"); 7927c478bd9Sstevel@tonic-gate break; 7937c478bd9Sstevel@tonic-gate case S_IWGRP: 7947c478bd9Sstevel@tonic-gate str = gettext("group writable"); 7957c478bd9Sstevel@tonic-gate break; 7967c478bd9Sstevel@tonic-gate case S_IXGRP: 7977c478bd9Sstevel@tonic-gate str = gettext("group executable"); 7987c478bd9Sstevel@tonic-gate break; 7997c478bd9Sstevel@tonic-gate case S_IROTH: 8007c478bd9Sstevel@tonic-gate str = gettext("world readable"); 8017c478bd9Sstevel@tonic-gate break; 8027c478bd9Sstevel@tonic-gate case S_IWOTH: 8037c478bd9Sstevel@tonic-gate str = gettext("world writable"); 8047c478bd9Sstevel@tonic-gate break; 8057c478bd9Sstevel@tonic-gate case S_IXOTH: 8067c478bd9Sstevel@tonic-gate str = gettext("world executable"); 8077c478bd9Sstevel@tonic-gate break; 8087c478bd9Sstevel@tonic-gate } 8097c478bd9Sstevel@tonic-gate if ((mode & bit) == (on ? 0 : bit)) { 8107c478bd9Sstevel@tonic-gate /* 8117c478bd9Sstevel@tonic-gate * TRANSLATION_NOTE 8127c478bd9Sstevel@tonic-gate * The first parameter below is a file name; the second 8137c478bd9Sstevel@tonic-gate * is one of the "(owner|group|world) (read|writ|execut)able" 8147c478bd9Sstevel@tonic-gate * strings from above. 8157c478bd9Sstevel@tonic-gate */ 8167c478bd9Sstevel@tonic-gate /* 8177c478bd9Sstevel@tonic-gate * The code below could be simplified but not in a way 8187c478bd9Sstevel@tonic-gate * that would easily translate to non-English locales. 8197c478bd9Sstevel@tonic-gate */ 8207c478bd9Sstevel@tonic-gate if (on) { 8217c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("%s must be %s.\n"), 8227c478bd9Sstevel@tonic-gate file, str); 8237c478bd9Sstevel@tonic-gate } else { 8247c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("%s must not be %s.\n"), 8257c478bd9Sstevel@tonic-gate file, str); 8267c478bd9Sstevel@tonic-gate } 8277c478bd9Sstevel@tonic-gate return (B_TRUE); 8287c478bd9Sstevel@tonic-gate } 8297c478bd9Sstevel@tonic-gate return (B_FALSE); 8307c478bd9Sstevel@tonic-gate } 8317c478bd9Sstevel@tonic-gate 8327c478bd9Sstevel@tonic-gate /* 8337c478bd9Sstevel@tonic-gate * We want to make sure that no zone has its zone path as a child node 8347c478bd9Sstevel@tonic-gate * (in the directory sense) of any other. We do that by comparing this 8357c478bd9Sstevel@tonic-gate * zone's path to the path of all other (non-global) zones. The comparison 8367c478bd9Sstevel@tonic-gate * in each case is simple: add '/' to the end of the path, then do a 8377c478bd9Sstevel@tonic-gate * strncmp() of the two paths, using the length of the shorter one. 8387c478bd9Sstevel@tonic-gate */ 8397c478bd9Sstevel@tonic-gate 8407c478bd9Sstevel@tonic-gate static int 8417c478bd9Sstevel@tonic-gate crosscheck_zonepaths(char *path) 8427c478bd9Sstevel@tonic-gate { 8437c478bd9Sstevel@tonic-gate char rpath[MAXPATHLEN]; /* resolved path */ 8447c478bd9Sstevel@tonic-gate char path_copy[MAXPATHLEN]; /* copy of original path */ 8457c478bd9Sstevel@tonic-gate char rpath_copy[MAXPATHLEN]; /* copy of original rpath */ 8467c478bd9Sstevel@tonic-gate struct zoneent *ze; 8477c478bd9Sstevel@tonic-gate int res, err; 8487c478bd9Sstevel@tonic-gate FILE *cookie; 8497c478bd9Sstevel@tonic-gate 8507c478bd9Sstevel@tonic-gate cookie = setzoneent(); 8517c478bd9Sstevel@tonic-gate while ((ze = getzoneent_private(cookie)) != NULL) { 8527c478bd9Sstevel@tonic-gate /* Skip zones which are not installed. */ 8537c478bd9Sstevel@tonic-gate if (ze->zone_state < ZONE_STATE_INSTALLED) { 8547c478bd9Sstevel@tonic-gate free(ze); 8557c478bd9Sstevel@tonic-gate continue; 8567c478bd9Sstevel@tonic-gate } 8577c478bd9Sstevel@tonic-gate /* Skip the global zone and the current target zone. */ 8587c478bd9Sstevel@tonic-gate if (strcmp(ze->zone_name, GLOBAL_ZONENAME) == 0 || 8597c478bd9Sstevel@tonic-gate strcmp(ze->zone_name, target_zone) == 0) { 8607c478bd9Sstevel@tonic-gate free(ze); 8617c478bd9Sstevel@tonic-gate continue; 8627c478bd9Sstevel@tonic-gate } 8637c478bd9Sstevel@tonic-gate if (strlen(ze->zone_path) == 0) { 8647c478bd9Sstevel@tonic-gate /* old index file without path, fall back */ 8657c478bd9Sstevel@tonic-gate if ((err = zone_get_zonepath(ze->zone_name, 8667c478bd9Sstevel@tonic-gate ze->zone_path, sizeof (ze->zone_path))) != Z_OK) { 8677c478bd9Sstevel@tonic-gate errno = err; 8687c478bd9Sstevel@tonic-gate zperror2(ze->zone_name, 8697c478bd9Sstevel@tonic-gate gettext("could not get zone path")); 8707c478bd9Sstevel@tonic-gate free(ze); 8717c478bd9Sstevel@tonic-gate continue; 8727c478bd9Sstevel@tonic-gate } 8737c478bd9Sstevel@tonic-gate } 874108322fbScarlsonj (void) snprintf(path_copy, sizeof (path_copy), "%s%s", 875108322fbScarlsonj zonecfg_get_root(), ze->zone_path); 876108322fbScarlsonj res = resolvepath(path_copy, rpath, sizeof (rpath)); 8777c478bd9Sstevel@tonic-gate if (res == -1) { 8787c478bd9Sstevel@tonic-gate if (errno != ENOENT) { 879108322fbScarlsonj zperror(path_copy, B_FALSE); 8807c478bd9Sstevel@tonic-gate free(ze); 8817c478bd9Sstevel@tonic-gate return (Z_ERR); 8827c478bd9Sstevel@tonic-gate } 8837c478bd9Sstevel@tonic-gate (void) printf(gettext("WARNING: zone %s is installed, " 8847c478bd9Sstevel@tonic-gate "but its %s %s does not exist.\n"), ze->zone_name, 885108322fbScarlsonj "zonepath", path_copy); 8867c478bd9Sstevel@tonic-gate free(ze); 8877c478bd9Sstevel@tonic-gate continue; 8887c478bd9Sstevel@tonic-gate } 8897c478bd9Sstevel@tonic-gate rpath[res] = '\0'; 8907c478bd9Sstevel@tonic-gate (void) snprintf(path_copy, sizeof (path_copy), "%s/", path); 8917c478bd9Sstevel@tonic-gate (void) snprintf(rpath_copy, sizeof (rpath_copy), "%s/", rpath); 8927c478bd9Sstevel@tonic-gate if (strncmp(path_copy, rpath_copy, 8937c478bd9Sstevel@tonic-gate min(strlen(path_copy), strlen(rpath_copy))) == 0) { 8945ee84fbdSgjelinek /* 8955ee84fbdSgjelinek * TRANSLATION_NOTE 8965ee84fbdSgjelinek * zonepath is a literal that should not be translated. 8975ee84fbdSgjelinek */ 8987c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("%s zonepath (%s) and " 8997c478bd9Sstevel@tonic-gate "%s zonepath (%s) overlap.\n"), 9007c478bd9Sstevel@tonic-gate target_zone, path, ze->zone_name, rpath); 9017c478bd9Sstevel@tonic-gate free(ze); 9027c478bd9Sstevel@tonic-gate return (Z_ERR); 9037c478bd9Sstevel@tonic-gate } 9047c478bd9Sstevel@tonic-gate free(ze); 9057c478bd9Sstevel@tonic-gate } 9067c478bd9Sstevel@tonic-gate endzoneent(cookie); 9077c478bd9Sstevel@tonic-gate return (Z_OK); 9087c478bd9Sstevel@tonic-gate } 9097c478bd9Sstevel@tonic-gate 9107c478bd9Sstevel@tonic-gate static int 9117c478bd9Sstevel@tonic-gate validate_zonepath(char *path, int cmd_num) 9127c478bd9Sstevel@tonic-gate { 9137c478bd9Sstevel@tonic-gate int res; /* result of last library/system call */ 9147c478bd9Sstevel@tonic-gate boolean_t err = B_FALSE; /* have we run into an error? */ 9157c478bd9Sstevel@tonic-gate struct stat stbuf; 9163f2f09c1Sdp struct statvfs64 vfsbuf; 9177c478bd9Sstevel@tonic-gate char rpath[MAXPATHLEN]; /* resolved path */ 9187c478bd9Sstevel@tonic-gate char ppath[MAXPATHLEN]; /* parent path */ 9197c478bd9Sstevel@tonic-gate char rppath[MAXPATHLEN]; /* resolved parent path */ 9207c478bd9Sstevel@tonic-gate char rootpath[MAXPATHLEN]; /* root path */ 9217c478bd9Sstevel@tonic-gate zone_state_t state; 9227c478bd9Sstevel@tonic-gate 9237c478bd9Sstevel@tonic-gate if (path[0] != '/') { 9247c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 9257c478bd9Sstevel@tonic-gate gettext("%s is not an absolute path.\n"), path); 9267c478bd9Sstevel@tonic-gate return (Z_ERR); 9277c478bd9Sstevel@tonic-gate } 9287c478bd9Sstevel@tonic-gate if ((res = resolvepath(path, rpath, sizeof (rpath))) == -1) { 9297c478bd9Sstevel@tonic-gate if ((errno != ENOENT) || 930865e09a4Sgjelinek (cmd_num != CMD_VERIFY && cmd_num != CMD_INSTALL && 931865e09a4Sgjelinek cmd_num != CMD_CLONE && cmd_num != CMD_MOVE)) { 9327c478bd9Sstevel@tonic-gate zperror(path, B_FALSE); 9337c478bd9Sstevel@tonic-gate return (Z_ERR); 9347c478bd9Sstevel@tonic-gate } 9357c478bd9Sstevel@tonic-gate if (cmd_num == CMD_VERIFY) { 9365ee84fbdSgjelinek /* 9375ee84fbdSgjelinek * TRANSLATION_NOTE 9385ee84fbdSgjelinek * zoneadm is a literal that should not be translated. 9395ee84fbdSgjelinek */ 9407c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("WARNING: %s does not " 9415ee84fbdSgjelinek "exist, so it could not be verified.\nWhen " 9425ee84fbdSgjelinek "'zoneadm %s' is run, '%s' will try to create\n%s, " 9435ee84fbdSgjelinek "and '%s' will be tried again,\nbut the '%s' may " 9445ee84fbdSgjelinek "fail if:\nthe parent directory of %s is group- or " 9455ee84fbdSgjelinek "other-writable\nor\n%s overlaps with any other " 9467c478bd9Sstevel@tonic-gate "installed zones.\n"), path, 9477c478bd9Sstevel@tonic-gate cmd_to_str(CMD_INSTALL), cmd_to_str(CMD_INSTALL), 9487c478bd9Sstevel@tonic-gate path, cmd_to_str(CMD_VERIFY), 9497c478bd9Sstevel@tonic-gate cmd_to_str(CMD_VERIFY), path, path); 9507c478bd9Sstevel@tonic-gate return (Z_OK); 9517c478bd9Sstevel@tonic-gate } 9527c478bd9Sstevel@tonic-gate /* 9537c478bd9Sstevel@tonic-gate * The zonepath is supposed to be mode 700 but its 9547c478bd9Sstevel@tonic-gate * parent(s) 755. So use 755 on the mkdirp() then 9557c478bd9Sstevel@tonic-gate * chmod() the zonepath itself to 700. 9567c478bd9Sstevel@tonic-gate */ 9577c478bd9Sstevel@tonic-gate if (mkdirp(path, DEFAULT_DIR_MODE) < 0) { 9587c478bd9Sstevel@tonic-gate zperror(path, B_FALSE); 9597c478bd9Sstevel@tonic-gate return (Z_ERR); 9607c478bd9Sstevel@tonic-gate } 9617c478bd9Sstevel@tonic-gate /* 9627c478bd9Sstevel@tonic-gate * If the chmod() fails, report the error, but might 9637c478bd9Sstevel@tonic-gate * as well continue the verify procedure. 9647c478bd9Sstevel@tonic-gate */ 9657c478bd9Sstevel@tonic-gate if (chmod(path, S_IRWXU) != 0) 9667c478bd9Sstevel@tonic-gate zperror(path, B_FALSE); 9677c478bd9Sstevel@tonic-gate /* 9687c478bd9Sstevel@tonic-gate * Since the mkdir() succeeded, we should not have to 9697c478bd9Sstevel@tonic-gate * worry about a subsequent ENOENT, thus this should 9707c478bd9Sstevel@tonic-gate * only recurse once. 9717c478bd9Sstevel@tonic-gate */ 972865e09a4Sgjelinek return (validate_zonepath(path, cmd_num)); 9737c478bd9Sstevel@tonic-gate } 9747c478bd9Sstevel@tonic-gate rpath[res] = '\0'; 9757c478bd9Sstevel@tonic-gate if (strcmp(path, rpath) != 0) { 9767c478bd9Sstevel@tonic-gate errno = Z_RESOLVED_PATH; 9777c478bd9Sstevel@tonic-gate zperror(path, B_TRUE); 9787c478bd9Sstevel@tonic-gate return (Z_ERR); 9797c478bd9Sstevel@tonic-gate } 9807c478bd9Sstevel@tonic-gate if ((res = stat(rpath, &stbuf)) != 0) { 9817c478bd9Sstevel@tonic-gate zperror(rpath, B_FALSE); 9827c478bd9Sstevel@tonic-gate return (Z_ERR); 9837c478bd9Sstevel@tonic-gate } 9847c478bd9Sstevel@tonic-gate if (!S_ISDIR(stbuf.st_mode)) { 9857c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("%s is not a directory.\n"), 9867c478bd9Sstevel@tonic-gate rpath); 9877c478bd9Sstevel@tonic-gate return (Z_ERR); 9887c478bd9Sstevel@tonic-gate } 9894fceebdfSblakej if (strcmp(stbuf.st_fstype, MNTTYPE_TMPFS) == 0) { 9907c478bd9Sstevel@tonic-gate (void) printf(gettext("WARNING: %s is on a temporary " 9910b5de56dSgjelinek "file system.\n"), rpath); 9927c478bd9Sstevel@tonic-gate } 9937c478bd9Sstevel@tonic-gate if (crosscheck_zonepaths(rpath) != Z_OK) 9947c478bd9Sstevel@tonic-gate return (Z_ERR); 9957c478bd9Sstevel@tonic-gate /* 9967c478bd9Sstevel@tonic-gate * Try to collect and report as many minor errors as possible 9977c478bd9Sstevel@tonic-gate * before returning, so the user can learn everything that needs 9987c478bd9Sstevel@tonic-gate * to be fixed up front. 9997c478bd9Sstevel@tonic-gate */ 10007c478bd9Sstevel@tonic-gate if (stbuf.st_uid != 0) { 10017c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("%s is not owned by root.\n"), 10027c478bd9Sstevel@tonic-gate rpath); 10037c478bd9Sstevel@tonic-gate err = B_TRUE; 10047c478bd9Sstevel@tonic-gate } 10057c478bd9Sstevel@tonic-gate err |= bad_mode_bit(stbuf.st_mode, S_IRUSR, B_TRUE, rpath); 10067c478bd9Sstevel@tonic-gate err |= bad_mode_bit(stbuf.st_mode, S_IWUSR, B_TRUE, rpath); 10077c478bd9Sstevel@tonic-gate err |= bad_mode_bit(stbuf.st_mode, S_IXUSR, B_TRUE, rpath); 10087c478bd9Sstevel@tonic-gate err |= bad_mode_bit(stbuf.st_mode, S_IRGRP, B_FALSE, rpath); 10097c478bd9Sstevel@tonic-gate err |= bad_mode_bit(stbuf.st_mode, S_IWGRP, B_FALSE, rpath); 10107c478bd9Sstevel@tonic-gate err |= bad_mode_bit(stbuf.st_mode, S_IXGRP, B_FALSE, rpath); 10117c478bd9Sstevel@tonic-gate err |= bad_mode_bit(stbuf.st_mode, S_IROTH, B_FALSE, rpath); 10127c478bd9Sstevel@tonic-gate err |= bad_mode_bit(stbuf.st_mode, S_IWOTH, B_FALSE, rpath); 10137c478bd9Sstevel@tonic-gate err |= bad_mode_bit(stbuf.st_mode, S_IXOTH, B_FALSE, rpath); 10147c478bd9Sstevel@tonic-gate 10157c478bd9Sstevel@tonic-gate (void) snprintf(ppath, sizeof (ppath), "%s/..", path); 10167c478bd9Sstevel@tonic-gate if ((res = resolvepath(ppath, rppath, sizeof (rppath))) == -1) { 10177c478bd9Sstevel@tonic-gate zperror(ppath, B_FALSE); 10187c478bd9Sstevel@tonic-gate return (Z_ERR); 10197c478bd9Sstevel@tonic-gate } 10207c478bd9Sstevel@tonic-gate rppath[res] = '\0'; 10217c478bd9Sstevel@tonic-gate if ((res = stat(rppath, &stbuf)) != 0) { 10227c478bd9Sstevel@tonic-gate zperror(rppath, B_FALSE); 10237c478bd9Sstevel@tonic-gate return (Z_ERR); 10247c478bd9Sstevel@tonic-gate } 10257c478bd9Sstevel@tonic-gate /* theoretically impossible */ 10267c478bd9Sstevel@tonic-gate if (!S_ISDIR(stbuf.st_mode)) { 10277c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("%s is not a directory.\n"), 10287c478bd9Sstevel@tonic-gate rppath); 10297c478bd9Sstevel@tonic-gate return (Z_ERR); 10307c478bd9Sstevel@tonic-gate } 10317c478bd9Sstevel@tonic-gate if (stbuf.st_uid != 0) { 10327c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("%s is not owned by root.\n"), 10337c478bd9Sstevel@tonic-gate rppath); 10347c478bd9Sstevel@tonic-gate err = B_TRUE; 10357c478bd9Sstevel@tonic-gate } 10367c478bd9Sstevel@tonic-gate err |= bad_mode_bit(stbuf.st_mode, S_IRUSR, B_TRUE, rppath); 10377c478bd9Sstevel@tonic-gate err |= bad_mode_bit(stbuf.st_mode, S_IWUSR, B_TRUE, rppath); 10387c478bd9Sstevel@tonic-gate err |= bad_mode_bit(stbuf.st_mode, S_IXUSR, B_TRUE, rppath); 10397c478bd9Sstevel@tonic-gate err |= bad_mode_bit(stbuf.st_mode, S_IWGRP, B_FALSE, rppath); 10407c478bd9Sstevel@tonic-gate err |= bad_mode_bit(stbuf.st_mode, S_IWOTH, B_FALSE, rppath); 10417c478bd9Sstevel@tonic-gate if (strcmp(rpath, rppath) == 0) { 10427c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("%s is its own parent.\n"), 10437c478bd9Sstevel@tonic-gate rppath); 10447c478bd9Sstevel@tonic-gate err = B_TRUE; 10457c478bd9Sstevel@tonic-gate } 10467c478bd9Sstevel@tonic-gate 10473f2f09c1Sdp if (statvfs64(rpath, &vfsbuf) != 0) { 10487c478bd9Sstevel@tonic-gate zperror(rpath, B_FALSE); 10497c478bd9Sstevel@tonic-gate return (Z_ERR); 10507c478bd9Sstevel@tonic-gate } 1051b5abaf04Sgjelinek if (strcmp(vfsbuf.f_basetype, MNTTYPE_NFS) == 0) { 10525ee84fbdSgjelinek /* 10535ee84fbdSgjelinek * TRANSLATION_NOTE 10545ee84fbdSgjelinek * Zonepath and NFS are literals that should not be translated. 10555ee84fbdSgjelinek */ 10565ee84fbdSgjelinek (void) fprintf(stderr, gettext("Zonepath %s is on an NFS " 10570b5de56dSgjelinek "mounted file system.\n" 10580b5de56dSgjelinek "\tA local file system must be used.\n"), rpath); 1059b5abaf04Sgjelinek return (Z_ERR); 1060b5abaf04Sgjelinek } 1061b5abaf04Sgjelinek if (vfsbuf.f_flag & ST_NOSUID) { 10625ee84fbdSgjelinek /* 10635ee84fbdSgjelinek * TRANSLATION_NOTE 10645ee84fbdSgjelinek * Zonepath and nosuid are literals that should not be 10655ee84fbdSgjelinek * translated. 10665ee84fbdSgjelinek */ 1067b5abaf04Sgjelinek (void) fprintf(stderr, gettext("Zonepath %s is on a nosuid " 10680b5de56dSgjelinek "file system.\n"), rpath); 10697c478bd9Sstevel@tonic-gate return (Z_ERR); 10707c478bd9Sstevel@tonic-gate } 10717c478bd9Sstevel@tonic-gate 10727c478bd9Sstevel@tonic-gate if ((res = zone_get_state(target_zone, &state)) != Z_OK) { 10737c478bd9Sstevel@tonic-gate errno = res; 10747c478bd9Sstevel@tonic-gate zperror2(target_zone, gettext("could not get state")); 10757c478bd9Sstevel@tonic-gate return (Z_ERR); 10767c478bd9Sstevel@tonic-gate } 10777c478bd9Sstevel@tonic-gate /* 10787c478bd9Sstevel@tonic-gate * The existence of the root path is only bad in the configured state, 10797c478bd9Sstevel@tonic-gate * as it is *supposed* to be there at the installed and later states. 1080ee519a1fSgjelinek * However, the root path is expected to be there if the zone is 1081ee519a1fSgjelinek * detached. 10827c478bd9Sstevel@tonic-gate * State/command mismatches are caught earlier in verify_details(). 10837c478bd9Sstevel@tonic-gate */ 1084ee519a1fSgjelinek if (state == ZONE_STATE_CONFIGURED && cmd_num != CMD_ATTACH) { 10857c478bd9Sstevel@tonic-gate if (snprintf(rootpath, sizeof (rootpath), "%s/root", rpath) >= 10867c478bd9Sstevel@tonic-gate sizeof (rootpath)) { 10875ee84fbdSgjelinek /* 10885ee84fbdSgjelinek * TRANSLATION_NOTE 10895ee84fbdSgjelinek * Zonepath is a literal that should not be translated. 10905ee84fbdSgjelinek */ 10917c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 10927c478bd9Sstevel@tonic-gate gettext("Zonepath %s is too long.\n"), rpath); 10937c478bd9Sstevel@tonic-gate return (Z_ERR); 10947c478bd9Sstevel@tonic-gate } 10957c478bd9Sstevel@tonic-gate if ((res = stat(rootpath, &stbuf)) == 0) { 1096ee519a1fSgjelinek if (zonecfg_detached(rpath)) 1097ee519a1fSgjelinek (void) fprintf(stderr, 1098ee519a1fSgjelinek gettext("Cannot %s detached " 1099ee519a1fSgjelinek "zone.\nUse attach or remove %s " 1100ee519a1fSgjelinek "directory.\n"), cmd_to_str(cmd_num), 1101ee519a1fSgjelinek rpath); 1102ee519a1fSgjelinek else 1103ee519a1fSgjelinek (void) fprintf(stderr, 1104ee519a1fSgjelinek gettext("Rootpath %s exists; " 1105ee519a1fSgjelinek "remove or move aside prior to %s.\n"), 1106ee519a1fSgjelinek rootpath, cmd_to_str(cmd_num)); 11077c478bd9Sstevel@tonic-gate return (Z_ERR); 11087c478bd9Sstevel@tonic-gate } 11097c478bd9Sstevel@tonic-gate } 11107c478bd9Sstevel@tonic-gate 11117c478bd9Sstevel@tonic-gate return (err ? Z_ERR : Z_OK); 11127c478bd9Sstevel@tonic-gate } 11137c478bd9Sstevel@tonic-gate 11149acbbeafSnn35248 /* 11159acbbeafSnn35248 * The following two routines implement a simple locking mechanism to 11169acbbeafSnn35248 * ensure that only one instance of zoneadm at a time is able to manipulate 11179acbbeafSnn35248 * a given zone. The lock is built on top of an fcntl(2) lock of 11189acbbeafSnn35248 * [<altroot>]/var/run/zones/<zonename>.zoneadm.lock. If a zoneadm instance 11199acbbeafSnn35248 * can grab that lock, it is allowed to manipulate the zone. 11209acbbeafSnn35248 * 11219acbbeafSnn35248 * Since zoneadm may call external applications which in turn invoke 11229acbbeafSnn35248 * zoneadm again, we introduce the notion of "lock inheritance". Any 11239acbbeafSnn35248 * instance of zoneadm that has another instance in its ancestry is assumed 11249acbbeafSnn35248 * to be acting on behalf of the original zoneadm, and is thus allowed to 11259acbbeafSnn35248 * manipulate its zone. 11269acbbeafSnn35248 * 11279acbbeafSnn35248 * This inheritance is implemented via the _ZONEADM_LOCK_HELD environment 11289acbbeafSnn35248 * variable. When zoneadm is granted a lock on its zone, this environment 11299acbbeafSnn35248 * variable is set to 1. When it releases the lock, the variable is set to 11309acbbeafSnn35248 * 0. Since a child process inherits its parent's environment, checking 11319acbbeafSnn35248 * the state of this variable indicates whether or not any ancestor owns 11329acbbeafSnn35248 * the lock. 11339acbbeafSnn35248 */ 11347c478bd9Sstevel@tonic-gate static void 11357c478bd9Sstevel@tonic-gate release_lock_file(int lockfd) 11367c478bd9Sstevel@tonic-gate { 11379acbbeafSnn35248 /* 11389acbbeafSnn35248 * If we are cleaning up from a failed attempt to lock the zone for 11399acbbeafSnn35248 * the first time, we might have a zone_lock_cnt of 0. In that 11409acbbeafSnn35248 * error case, we don't want to do anything but close the lock 11419acbbeafSnn35248 * file. 11429acbbeafSnn35248 */ 11439acbbeafSnn35248 assert(zone_lock_cnt >= 0); 11449acbbeafSnn35248 if (zone_lock_cnt > 0) { 11459acbbeafSnn35248 assert(getenv(LOCK_ENV_VAR) != NULL); 11469acbbeafSnn35248 assert(atoi(getenv(LOCK_ENV_VAR)) == 1); 11479acbbeafSnn35248 if (--zone_lock_cnt > 0) { 11489acbbeafSnn35248 assert(lockfd == -1); 11499acbbeafSnn35248 return; 11509acbbeafSnn35248 } 11519acbbeafSnn35248 if (putenv(zoneadm_lock_not_held) != 0) { 11529acbbeafSnn35248 zperror(target_zone, B_TRUE); 11539acbbeafSnn35248 exit(Z_ERR); 11549acbbeafSnn35248 } 11559acbbeafSnn35248 } 11569acbbeafSnn35248 assert(lockfd >= 0); 11577c478bd9Sstevel@tonic-gate (void) close(lockfd); 11587c478bd9Sstevel@tonic-gate } 11597c478bd9Sstevel@tonic-gate 11607c478bd9Sstevel@tonic-gate static int 11617c478bd9Sstevel@tonic-gate grab_lock_file(const char *zone_name, int *lockfd) 11627c478bd9Sstevel@tonic-gate { 11637c478bd9Sstevel@tonic-gate char pathbuf[PATH_MAX]; 11647c478bd9Sstevel@tonic-gate struct flock flock; 11657c478bd9Sstevel@tonic-gate 11669acbbeafSnn35248 /* 11679acbbeafSnn35248 * If we already have the lock, we can skip this expensive song 11689acbbeafSnn35248 * and dance. 11699acbbeafSnn35248 */ 11709acbbeafSnn35248 if (zone_lock_cnt > 0) { 11719acbbeafSnn35248 zone_lock_cnt++; 11729acbbeafSnn35248 *lockfd = -1; 11739acbbeafSnn35248 return (Z_OK); 11749acbbeafSnn35248 } 11759acbbeafSnn35248 assert(getenv(LOCK_ENV_VAR) != NULL); 11769acbbeafSnn35248 assert(atoi(getenv(LOCK_ENV_VAR)) == 0); 11779acbbeafSnn35248 1178108322fbScarlsonj if (snprintf(pathbuf, sizeof (pathbuf), "%s%s", zonecfg_get_root(), 1179108322fbScarlsonj ZONES_TMPDIR) >= sizeof (pathbuf)) { 1180108322fbScarlsonj zerror(gettext("alternate root path is too long")); 1181108322fbScarlsonj return (Z_ERR); 1182108322fbScarlsonj } 1183108322fbScarlsonj if (mkdir(pathbuf, S_IRWXU) < 0 && errno != EEXIST) { 1184108322fbScarlsonj zerror(gettext("could not mkdir %s: %s"), pathbuf, 11857c478bd9Sstevel@tonic-gate strerror(errno)); 11867c478bd9Sstevel@tonic-gate return (Z_ERR); 11877c478bd9Sstevel@tonic-gate } 1188108322fbScarlsonj (void) chmod(pathbuf, S_IRWXU); 11897c478bd9Sstevel@tonic-gate 11907c478bd9Sstevel@tonic-gate /* 11917c478bd9Sstevel@tonic-gate * One of these lock files is created for each zone (when needed). 11927c478bd9Sstevel@tonic-gate * The lock files are not cleaned up (except on system reboot), 11937c478bd9Sstevel@tonic-gate * but since there is only one per zone, there is no resource 11947c478bd9Sstevel@tonic-gate * starvation issue. 11957c478bd9Sstevel@tonic-gate */ 1196108322fbScarlsonj if (snprintf(pathbuf, sizeof (pathbuf), "%s%s/%s.zoneadm.lock", 1197108322fbScarlsonj zonecfg_get_root(), ZONES_TMPDIR, zone_name) >= sizeof (pathbuf)) { 1198108322fbScarlsonj zerror(gettext("alternate root path is too long")); 1199108322fbScarlsonj return (Z_ERR); 1200108322fbScarlsonj } 12017c478bd9Sstevel@tonic-gate if ((*lockfd = open(pathbuf, O_RDWR|O_CREAT, S_IRUSR|S_IWUSR)) < 0) { 12027c478bd9Sstevel@tonic-gate zerror(gettext("could not open %s: %s"), pathbuf, 12037c478bd9Sstevel@tonic-gate strerror(errno)); 12047c478bd9Sstevel@tonic-gate return (Z_ERR); 12057c478bd9Sstevel@tonic-gate } 12067c478bd9Sstevel@tonic-gate /* 12077c478bd9Sstevel@tonic-gate * Lock the file to synchronize with other zoneadmds 12087c478bd9Sstevel@tonic-gate */ 12097c478bd9Sstevel@tonic-gate flock.l_type = F_WRLCK; 12107c478bd9Sstevel@tonic-gate flock.l_whence = SEEK_SET; 12117c478bd9Sstevel@tonic-gate flock.l_start = (off_t)0; 12127c478bd9Sstevel@tonic-gate flock.l_len = (off_t)0; 12139acbbeafSnn35248 if ((fcntl(*lockfd, F_SETLKW, &flock) < 0) || 12149acbbeafSnn35248 (putenv(zoneadm_lock_held) != 0)) { 12157c478bd9Sstevel@tonic-gate zerror(gettext("unable to lock %s: %s"), pathbuf, 12167c478bd9Sstevel@tonic-gate strerror(errno)); 12177c478bd9Sstevel@tonic-gate release_lock_file(*lockfd); 12187c478bd9Sstevel@tonic-gate return (Z_ERR); 12197c478bd9Sstevel@tonic-gate } 12209acbbeafSnn35248 zone_lock_cnt = 1; 12217c478bd9Sstevel@tonic-gate return (Z_OK); 12227c478bd9Sstevel@tonic-gate } 12237c478bd9Sstevel@tonic-gate 1224108322fbScarlsonj static boolean_t 12257c478bd9Sstevel@tonic-gate get_doorname(const char *zone_name, char *buffer) 12267c478bd9Sstevel@tonic-gate { 1227108322fbScarlsonj return (snprintf(buffer, PATH_MAX, "%s" ZONE_DOOR_PATH, 1228108322fbScarlsonj zonecfg_get_root(), zone_name) < PATH_MAX); 12297c478bd9Sstevel@tonic-gate } 12307c478bd9Sstevel@tonic-gate 12317c478bd9Sstevel@tonic-gate /* 12327c478bd9Sstevel@tonic-gate * system daemons are not audited. For the global zone, this occurs 12337c478bd9Sstevel@tonic-gate * "naturally" since init is started with the default audit 12347c478bd9Sstevel@tonic-gate * characteristics. Since zoneadmd is a system daemon and it starts 12357c478bd9Sstevel@tonic-gate * init for a zone, it is necessary to clear out the audit 12367c478bd9Sstevel@tonic-gate * characteristics inherited from whomever started zoneadmd. This is 12377c478bd9Sstevel@tonic-gate * indicated by the audit id, which is set from the ruid parameter of 12387c478bd9Sstevel@tonic-gate * adt_set_user(), below. 12397c478bd9Sstevel@tonic-gate */ 12407c478bd9Sstevel@tonic-gate 12417c478bd9Sstevel@tonic-gate static void 12427c478bd9Sstevel@tonic-gate prepare_audit_context() 12437c478bd9Sstevel@tonic-gate { 12447c478bd9Sstevel@tonic-gate adt_session_data_t *ah; 12457c478bd9Sstevel@tonic-gate char *failure = gettext("audit failure: %s"); 12467c478bd9Sstevel@tonic-gate 12477c478bd9Sstevel@tonic-gate if (adt_start_session(&ah, NULL, 0)) { 12487c478bd9Sstevel@tonic-gate zerror(failure, strerror(errno)); 12497c478bd9Sstevel@tonic-gate return; 12507c478bd9Sstevel@tonic-gate } 12517c478bd9Sstevel@tonic-gate if (adt_set_user(ah, ADT_NO_AUDIT, ADT_NO_AUDIT, 12527c478bd9Sstevel@tonic-gate ADT_NO_AUDIT, ADT_NO_AUDIT, NULL, ADT_NEW)) { 12537c478bd9Sstevel@tonic-gate zerror(failure, strerror(errno)); 12547c478bd9Sstevel@tonic-gate (void) adt_end_session(ah); 12557c478bd9Sstevel@tonic-gate return; 12567c478bd9Sstevel@tonic-gate } 12577c478bd9Sstevel@tonic-gate if (adt_set_proc(ah)) 12587c478bd9Sstevel@tonic-gate zerror(failure, strerror(errno)); 12597c478bd9Sstevel@tonic-gate 12607c478bd9Sstevel@tonic-gate (void) adt_end_session(ah); 12617c478bd9Sstevel@tonic-gate } 12627c478bd9Sstevel@tonic-gate 12637c478bd9Sstevel@tonic-gate static int 12647c478bd9Sstevel@tonic-gate start_zoneadmd(const char *zone_name) 12657c478bd9Sstevel@tonic-gate { 12667c478bd9Sstevel@tonic-gate char doorpath[PATH_MAX]; 12677c478bd9Sstevel@tonic-gate pid_t child_pid; 12687c478bd9Sstevel@tonic-gate int error = Z_ERR; 12697c478bd9Sstevel@tonic-gate int doorfd, lockfd; 12707c478bd9Sstevel@tonic-gate struct door_info info; 12717c478bd9Sstevel@tonic-gate 1272108322fbScarlsonj if (!get_doorname(zone_name, doorpath)) 1273108322fbScarlsonj return (Z_ERR); 12747c478bd9Sstevel@tonic-gate 12757c478bd9Sstevel@tonic-gate if (grab_lock_file(zone_name, &lockfd) != Z_OK) 12767c478bd9Sstevel@tonic-gate return (Z_ERR); 12777c478bd9Sstevel@tonic-gate 12787c478bd9Sstevel@tonic-gate /* 12797c478bd9Sstevel@tonic-gate * Now that we have the lock, re-confirm that the daemon is 12807c478bd9Sstevel@tonic-gate * *not* up and working fine. If it is still down, we have a green 12817c478bd9Sstevel@tonic-gate * light to start it. 12827c478bd9Sstevel@tonic-gate */ 12837c478bd9Sstevel@tonic-gate if ((doorfd = open(doorpath, O_RDONLY)) < 0) { 12847c478bd9Sstevel@tonic-gate if (errno != ENOENT) { 12857c478bd9Sstevel@tonic-gate zperror(doorpath, B_FALSE); 12867c478bd9Sstevel@tonic-gate goto out; 12877c478bd9Sstevel@tonic-gate } 12887c478bd9Sstevel@tonic-gate } else { 12897c478bd9Sstevel@tonic-gate if (door_info(doorfd, &info) == 0 && 12907c478bd9Sstevel@tonic-gate ((info.di_attributes & DOOR_REVOKED) == 0)) { 12917c478bd9Sstevel@tonic-gate error = Z_OK; 12927c478bd9Sstevel@tonic-gate (void) close(doorfd); 12937c478bd9Sstevel@tonic-gate goto out; 12947c478bd9Sstevel@tonic-gate } 12957c478bd9Sstevel@tonic-gate (void) close(doorfd); 12967c478bd9Sstevel@tonic-gate } 12977c478bd9Sstevel@tonic-gate 12987c478bd9Sstevel@tonic-gate if ((child_pid = fork()) == -1) { 12997c478bd9Sstevel@tonic-gate zperror(gettext("could not fork"), B_FALSE); 13007c478bd9Sstevel@tonic-gate goto out; 13017c478bd9Sstevel@tonic-gate } else if (child_pid == 0) { 1302108322fbScarlsonj const char *argv[6], **ap; 13037c478bd9Sstevel@tonic-gate 1304108322fbScarlsonj /* child process */ 13057c478bd9Sstevel@tonic-gate prepare_audit_context(); 13067c478bd9Sstevel@tonic-gate 1307108322fbScarlsonj ap = argv; 1308108322fbScarlsonj *ap++ = "zoneadmd"; 1309108322fbScarlsonj *ap++ = "-z"; 1310108322fbScarlsonj *ap++ = zone_name; 1311108322fbScarlsonj if (zonecfg_in_alt_root()) { 1312108322fbScarlsonj *ap++ = "-R"; 1313108322fbScarlsonj *ap++ = zonecfg_get_root(); 1314108322fbScarlsonj } 1315108322fbScarlsonj *ap = NULL; 1316108322fbScarlsonj 1317108322fbScarlsonj (void) execv("/usr/lib/zones/zoneadmd", (char * const *)argv); 13185ee84fbdSgjelinek /* 13195ee84fbdSgjelinek * TRANSLATION_NOTE 13205ee84fbdSgjelinek * zoneadmd is a literal that should not be translated. 13215ee84fbdSgjelinek */ 13227c478bd9Sstevel@tonic-gate zperror(gettext("could not exec zoneadmd"), B_FALSE); 13237c478bd9Sstevel@tonic-gate _exit(Z_ERR); 13247c478bd9Sstevel@tonic-gate } else { 13257c478bd9Sstevel@tonic-gate /* parent process */ 13267c478bd9Sstevel@tonic-gate pid_t retval; 13277c478bd9Sstevel@tonic-gate int pstatus = 0; 13287c478bd9Sstevel@tonic-gate 13297c478bd9Sstevel@tonic-gate do { 13307c478bd9Sstevel@tonic-gate retval = waitpid(child_pid, &pstatus, 0); 13317c478bd9Sstevel@tonic-gate } while (retval != child_pid); 13327c478bd9Sstevel@tonic-gate if (WIFSIGNALED(pstatus) || (WIFEXITED(pstatus) && 13337c478bd9Sstevel@tonic-gate WEXITSTATUS(pstatus) != 0)) { 13347c478bd9Sstevel@tonic-gate zerror(gettext("could not start %s"), "zoneadmd"); 13357c478bd9Sstevel@tonic-gate goto out; 13367c478bd9Sstevel@tonic-gate } 13377c478bd9Sstevel@tonic-gate } 13387c478bd9Sstevel@tonic-gate error = Z_OK; 13397c478bd9Sstevel@tonic-gate out: 13407c478bd9Sstevel@tonic-gate release_lock_file(lockfd); 13417c478bd9Sstevel@tonic-gate return (error); 13427c478bd9Sstevel@tonic-gate } 13437c478bd9Sstevel@tonic-gate 13447c478bd9Sstevel@tonic-gate static int 13457c478bd9Sstevel@tonic-gate ping_zoneadmd(const char *zone_name) 13467c478bd9Sstevel@tonic-gate { 13477c478bd9Sstevel@tonic-gate char doorpath[PATH_MAX]; 13487c478bd9Sstevel@tonic-gate int doorfd; 13497c478bd9Sstevel@tonic-gate struct door_info info; 13507c478bd9Sstevel@tonic-gate 1351108322fbScarlsonj if (!get_doorname(zone_name, doorpath)) 1352108322fbScarlsonj return (Z_ERR); 13537c478bd9Sstevel@tonic-gate 13547c478bd9Sstevel@tonic-gate if ((doorfd = open(doorpath, O_RDONLY)) < 0) { 13557c478bd9Sstevel@tonic-gate return (Z_ERR); 13567c478bd9Sstevel@tonic-gate } 13577c478bd9Sstevel@tonic-gate if (door_info(doorfd, &info) == 0 && 13587c478bd9Sstevel@tonic-gate ((info.di_attributes & DOOR_REVOKED) == 0)) { 13597c478bd9Sstevel@tonic-gate (void) close(doorfd); 13607c478bd9Sstevel@tonic-gate return (Z_OK); 13617c478bd9Sstevel@tonic-gate } 13627c478bd9Sstevel@tonic-gate (void) close(doorfd); 13637c478bd9Sstevel@tonic-gate return (Z_ERR); 13647c478bd9Sstevel@tonic-gate } 13657c478bd9Sstevel@tonic-gate 13667c478bd9Sstevel@tonic-gate static int 13677c478bd9Sstevel@tonic-gate call_zoneadmd(const char *zone_name, zone_cmd_arg_t *arg) 13687c478bd9Sstevel@tonic-gate { 13697c478bd9Sstevel@tonic-gate char doorpath[PATH_MAX]; 13707c478bd9Sstevel@tonic-gate int doorfd, result; 13717c478bd9Sstevel@tonic-gate door_arg_t darg; 13727c478bd9Sstevel@tonic-gate 13737c478bd9Sstevel@tonic-gate zoneid_t zoneid; 13747c478bd9Sstevel@tonic-gate uint64_t uniqid = 0; 13757c478bd9Sstevel@tonic-gate 13767c478bd9Sstevel@tonic-gate zone_cmd_rval_t *rvalp; 13777c478bd9Sstevel@tonic-gate size_t rlen; 13787c478bd9Sstevel@tonic-gate char *cp, *errbuf; 13797c478bd9Sstevel@tonic-gate 13807c478bd9Sstevel@tonic-gate rlen = getpagesize(); 13817c478bd9Sstevel@tonic-gate if ((rvalp = malloc(rlen)) == NULL) { 13827c478bd9Sstevel@tonic-gate zerror(gettext("failed to allocate %lu bytes: %s"), rlen, 13837c478bd9Sstevel@tonic-gate strerror(errno)); 13847c478bd9Sstevel@tonic-gate return (-1); 13857c478bd9Sstevel@tonic-gate } 13867c478bd9Sstevel@tonic-gate 13877c478bd9Sstevel@tonic-gate if ((zoneid = getzoneidbyname(zone_name)) != ZONE_ID_UNDEFINED) { 13887c478bd9Sstevel@tonic-gate (void) zone_getattr(zoneid, ZONE_ATTR_UNIQID, &uniqid, 13897c478bd9Sstevel@tonic-gate sizeof (uniqid)); 13907c478bd9Sstevel@tonic-gate } 13917c478bd9Sstevel@tonic-gate arg->uniqid = uniqid; 13927c478bd9Sstevel@tonic-gate (void) strlcpy(arg->locale, locale, sizeof (arg->locale)); 1393108322fbScarlsonj if (!get_doorname(zone_name, doorpath)) { 1394108322fbScarlsonj zerror(gettext("alternate root path is too long")); 1395108322fbScarlsonj free(rvalp); 1396108322fbScarlsonj return (-1); 1397108322fbScarlsonj } 13987c478bd9Sstevel@tonic-gate 13997c478bd9Sstevel@tonic-gate /* 14007c478bd9Sstevel@tonic-gate * Loop trying to start zoneadmd; if something goes seriously 14017c478bd9Sstevel@tonic-gate * wrong we break out and fail. 14027c478bd9Sstevel@tonic-gate */ 14037c478bd9Sstevel@tonic-gate for (;;) { 14047c478bd9Sstevel@tonic-gate if (start_zoneadmd(zone_name) != Z_OK) 14057c478bd9Sstevel@tonic-gate break; 14067c478bd9Sstevel@tonic-gate 14077c478bd9Sstevel@tonic-gate if ((doorfd = open(doorpath, O_RDONLY)) < 0) { 14087c478bd9Sstevel@tonic-gate zperror(gettext("failed to open zone door"), B_FALSE); 14097c478bd9Sstevel@tonic-gate break; 14107c478bd9Sstevel@tonic-gate } 14117c478bd9Sstevel@tonic-gate 14127c478bd9Sstevel@tonic-gate darg.data_ptr = (char *)arg; 14137c478bd9Sstevel@tonic-gate darg.data_size = sizeof (*arg); 14147c478bd9Sstevel@tonic-gate darg.desc_ptr = NULL; 14157c478bd9Sstevel@tonic-gate darg.desc_num = 0; 14167c478bd9Sstevel@tonic-gate darg.rbuf = (char *)rvalp; 14177c478bd9Sstevel@tonic-gate darg.rsize = rlen; 14187c478bd9Sstevel@tonic-gate if (door_call(doorfd, &darg) != 0) { 14197c478bd9Sstevel@tonic-gate (void) close(doorfd); 14207c478bd9Sstevel@tonic-gate /* 14217c478bd9Sstevel@tonic-gate * We'll get EBADF if the door has been revoked. 14227c478bd9Sstevel@tonic-gate */ 14237c478bd9Sstevel@tonic-gate if (errno != EBADF) { 14247c478bd9Sstevel@tonic-gate zperror(gettext("door_call failed"), B_FALSE); 14257c478bd9Sstevel@tonic-gate break; 14267c478bd9Sstevel@tonic-gate } 14277c478bd9Sstevel@tonic-gate continue; /* take another lap */ 14287c478bd9Sstevel@tonic-gate } 14297c478bd9Sstevel@tonic-gate (void) close(doorfd); 14307c478bd9Sstevel@tonic-gate 14317c478bd9Sstevel@tonic-gate if (darg.data_size == 0) { 14327c478bd9Sstevel@tonic-gate /* Door server is going away; kick it again. */ 14337c478bd9Sstevel@tonic-gate continue; 14347c478bd9Sstevel@tonic-gate } 14357c478bd9Sstevel@tonic-gate 14367c478bd9Sstevel@tonic-gate errbuf = rvalp->errbuf; 14377c478bd9Sstevel@tonic-gate while (*errbuf != '\0') { 14387c478bd9Sstevel@tonic-gate /* 14397c478bd9Sstevel@tonic-gate * Remove any newlines since zerror() 14407c478bd9Sstevel@tonic-gate * will append one automatically. 14417c478bd9Sstevel@tonic-gate */ 14427c478bd9Sstevel@tonic-gate cp = strchr(errbuf, '\n'); 14437c478bd9Sstevel@tonic-gate if (cp != NULL) 14447c478bd9Sstevel@tonic-gate *cp = '\0'; 14457c478bd9Sstevel@tonic-gate zerror("%s", errbuf); 14467c478bd9Sstevel@tonic-gate if (cp == NULL) 14477c478bd9Sstevel@tonic-gate break; 14487c478bd9Sstevel@tonic-gate errbuf = cp + 1; 14497c478bd9Sstevel@tonic-gate } 14507c478bd9Sstevel@tonic-gate result = rvalp->rval == 0 ? 0 : -1; 14517c478bd9Sstevel@tonic-gate free(rvalp); 14527c478bd9Sstevel@tonic-gate return (result); 14537c478bd9Sstevel@tonic-gate } 14547c478bd9Sstevel@tonic-gate 14557c478bd9Sstevel@tonic-gate free(rvalp); 14567c478bd9Sstevel@tonic-gate return (-1); 14577c478bd9Sstevel@tonic-gate } 14587c478bd9Sstevel@tonic-gate 14597c478bd9Sstevel@tonic-gate static int 1460ce28b40eSzt129084 invoke_brand_handler(int cmd_num, char *argv[]) 1461ce28b40eSzt129084 { 1462ce28b40eSzt129084 zone_dochandle_t handle; 1463ce28b40eSzt129084 int err; 1464ce28b40eSzt129084 1465ce28b40eSzt129084 if ((handle = zonecfg_init_handle()) == NULL) { 1466ce28b40eSzt129084 zperror(cmd_to_str(cmd_num), B_TRUE); 1467ce28b40eSzt129084 return (Z_ERR); 1468ce28b40eSzt129084 } 1469ce28b40eSzt129084 if ((err = zonecfg_get_handle(target_zone, handle)) != Z_OK) { 1470ce28b40eSzt129084 errno = err; 1471ce28b40eSzt129084 zperror(cmd_to_str(cmd_num), B_TRUE); 1472ce28b40eSzt129084 zonecfg_fini_handle(handle); 1473ce28b40eSzt129084 return (Z_ERR); 1474ce28b40eSzt129084 } 1475ce28b40eSzt129084 if (verify_brand(handle, cmd_num, argv) != Z_OK) { 1476ce28b40eSzt129084 zonecfg_fini_handle(handle); 1477ce28b40eSzt129084 return (Z_ERR); 1478ce28b40eSzt129084 } 1479ce28b40eSzt129084 zonecfg_fini_handle(handle); 1480ce28b40eSzt129084 return (Z_OK); 1481ce28b40eSzt129084 } 1482ce28b40eSzt129084 1483ce28b40eSzt129084 static int 14847c478bd9Sstevel@tonic-gate ready_func(int argc, char *argv[]) 14857c478bd9Sstevel@tonic-gate { 14867c478bd9Sstevel@tonic-gate zone_cmd_arg_t zarg; 14877c478bd9Sstevel@tonic-gate int arg; 14887c478bd9Sstevel@tonic-gate 1489108322fbScarlsonj if (zonecfg_in_alt_root()) { 1490108322fbScarlsonj zerror(gettext("cannot ready zone in alternate root")); 1491108322fbScarlsonj return (Z_ERR); 1492108322fbScarlsonj } 1493108322fbScarlsonj 14947c478bd9Sstevel@tonic-gate optind = 0; 14957c478bd9Sstevel@tonic-gate if ((arg = getopt(argc, argv, "?")) != EOF) { 14967c478bd9Sstevel@tonic-gate switch (arg) { 14977c478bd9Sstevel@tonic-gate case '?': 14987c478bd9Sstevel@tonic-gate sub_usage(SHELP_READY, CMD_READY); 14997c478bd9Sstevel@tonic-gate return (optopt == '?' ? Z_OK : Z_USAGE); 15007c478bd9Sstevel@tonic-gate default: 15017c478bd9Sstevel@tonic-gate sub_usage(SHELP_READY, CMD_READY); 15027c478bd9Sstevel@tonic-gate return (Z_USAGE); 15037c478bd9Sstevel@tonic-gate } 15047c478bd9Sstevel@tonic-gate } 15057c478bd9Sstevel@tonic-gate if (argc > optind) { 15067c478bd9Sstevel@tonic-gate sub_usage(SHELP_READY, CMD_READY); 15077c478bd9Sstevel@tonic-gate return (Z_USAGE); 15087c478bd9Sstevel@tonic-gate } 15099acbbeafSnn35248 if (sanity_check(target_zone, CMD_READY, B_FALSE, B_FALSE, B_FALSE) 15109acbbeafSnn35248 != Z_OK) 15117c478bd9Sstevel@tonic-gate return (Z_ERR); 1512ce28b40eSzt129084 if (verify_details(CMD_READY, argv) != Z_OK) 15137c478bd9Sstevel@tonic-gate return (Z_ERR); 15147c478bd9Sstevel@tonic-gate 15157c478bd9Sstevel@tonic-gate zarg.cmd = Z_READY; 15167c478bd9Sstevel@tonic-gate if (call_zoneadmd(target_zone, &zarg) != 0) { 15177c478bd9Sstevel@tonic-gate zerror(gettext("call to %s failed"), "zoneadmd"); 15187c478bd9Sstevel@tonic-gate return (Z_ERR); 15197c478bd9Sstevel@tonic-gate } 15207c478bd9Sstevel@tonic-gate return (Z_OK); 15217c478bd9Sstevel@tonic-gate } 15227c478bd9Sstevel@tonic-gate 15237c478bd9Sstevel@tonic-gate static int 15247c478bd9Sstevel@tonic-gate boot_func(int argc, char *argv[]) 15257c478bd9Sstevel@tonic-gate { 15267c478bd9Sstevel@tonic-gate zone_cmd_arg_t zarg; 15279acbbeafSnn35248 boolean_t force = B_FALSE; 15287c478bd9Sstevel@tonic-gate int arg; 15297c478bd9Sstevel@tonic-gate 1530108322fbScarlsonj if (zonecfg_in_alt_root()) { 1531108322fbScarlsonj zerror(gettext("cannot boot zone in alternate root")); 1532108322fbScarlsonj return (Z_ERR); 1533108322fbScarlsonj } 1534108322fbScarlsonj 15357c478bd9Sstevel@tonic-gate zarg.bootbuf[0] = '\0'; 15367c478bd9Sstevel@tonic-gate 15377c478bd9Sstevel@tonic-gate /* 15383f2f09c1Sdp * The following getopt processes arguments to zone boot; that 15393f2f09c1Sdp * is to say, the [here] portion of the argument string: 15403f2f09c1Sdp * 15413f2f09c1Sdp * zoneadm -z myzone boot [here] -- -v -m verbose 15423f2f09c1Sdp * 15433f2f09c1Sdp * Where [here] can either be nothing, -? (in which case we bail 15449acbbeafSnn35248 * and print usage), -f (a private option to indicate that the 15459acbbeafSnn35248 * boot operation should be 'forced'), or -s. Support for -s is 15469acbbeafSnn35248 * vestigal and obsolete, but is retained because it was a 15479acbbeafSnn35248 * documented interface and there are known consumers including 15489acbbeafSnn35248 * admin/install; the proper way to specify boot arguments like -s 15499acbbeafSnn35248 * is: 15503f2f09c1Sdp * 15513f2f09c1Sdp * zoneadm -z myzone boot -- -s -v -m verbose. 15527c478bd9Sstevel@tonic-gate */ 15537c478bd9Sstevel@tonic-gate optind = 0; 15549acbbeafSnn35248 while ((arg = getopt(argc, argv, "?fs")) != EOF) { 15557c478bd9Sstevel@tonic-gate switch (arg) { 15567c478bd9Sstevel@tonic-gate case '?': 15577c478bd9Sstevel@tonic-gate sub_usage(SHELP_BOOT, CMD_BOOT); 15587c478bd9Sstevel@tonic-gate return (optopt == '?' ? Z_OK : Z_USAGE); 15597c478bd9Sstevel@tonic-gate case 's': 15607c478bd9Sstevel@tonic-gate (void) strlcpy(zarg.bootbuf, "-s", 15617c478bd9Sstevel@tonic-gate sizeof (zarg.bootbuf)); 15627c478bd9Sstevel@tonic-gate break; 15639acbbeafSnn35248 case 'f': 15649acbbeafSnn35248 force = B_TRUE; 15659acbbeafSnn35248 break; 15667c478bd9Sstevel@tonic-gate default: 15677c478bd9Sstevel@tonic-gate sub_usage(SHELP_BOOT, CMD_BOOT); 15687c478bd9Sstevel@tonic-gate return (Z_USAGE); 15697c478bd9Sstevel@tonic-gate } 15707c478bd9Sstevel@tonic-gate } 15713f2f09c1Sdp 15723f2f09c1Sdp for (; optind < argc; optind++) { 15733f2f09c1Sdp if (strlcat(zarg.bootbuf, argv[optind], 15743f2f09c1Sdp sizeof (zarg.bootbuf)) >= sizeof (zarg.bootbuf)) { 15753f2f09c1Sdp zerror(gettext("Boot argument list too long")); 15763f2f09c1Sdp return (Z_ERR); 15777c478bd9Sstevel@tonic-gate } 15783f2f09c1Sdp if (optind < argc - 1) 15793f2f09c1Sdp if (strlcat(zarg.bootbuf, " ", sizeof (zarg.bootbuf)) >= 15803f2f09c1Sdp sizeof (zarg.bootbuf)) { 15813f2f09c1Sdp zerror(gettext("Boot argument list too long")); 15823f2f09c1Sdp return (Z_ERR); 15833f2f09c1Sdp } 15843f2f09c1Sdp } 15859acbbeafSnn35248 if (sanity_check(target_zone, CMD_BOOT, B_FALSE, B_FALSE, force) 15869acbbeafSnn35248 != Z_OK) 15877c478bd9Sstevel@tonic-gate return (Z_ERR); 1588ce28b40eSzt129084 if (verify_details(CMD_BOOT, argv) != Z_OK) 15897c478bd9Sstevel@tonic-gate return (Z_ERR); 15909acbbeafSnn35248 zarg.cmd = force ? Z_FORCEBOOT : Z_BOOT; 15917c478bd9Sstevel@tonic-gate if (call_zoneadmd(target_zone, &zarg) != 0) { 15927c478bd9Sstevel@tonic-gate zerror(gettext("call to %s failed"), "zoneadmd"); 15937c478bd9Sstevel@tonic-gate return (Z_ERR); 15947c478bd9Sstevel@tonic-gate } 15950209230bSgjelinek 15967c478bd9Sstevel@tonic-gate return (Z_OK); 15977c478bd9Sstevel@tonic-gate } 15987c478bd9Sstevel@tonic-gate 15997c478bd9Sstevel@tonic-gate static void 16007c478bd9Sstevel@tonic-gate fake_up_local_zone(zoneid_t zid, zone_entry_t *zeptr) 16017c478bd9Sstevel@tonic-gate { 16027c478bd9Sstevel@tonic-gate ssize_t result; 1603555afedfScarlsonj uuid_t uuid; 1604555afedfScarlsonj FILE *fp; 1605f4b3ec61Sdh155122 ushort_t flags; 1606555afedfScarlsonj 1607555afedfScarlsonj (void) memset(zeptr, 0, sizeof (*zeptr)); 16087c478bd9Sstevel@tonic-gate 16097c478bd9Sstevel@tonic-gate zeptr->zid = zid; 1610555afedfScarlsonj 16117c478bd9Sstevel@tonic-gate /* 16127c478bd9Sstevel@tonic-gate * Since we're looking up our own (non-global) zone name, 16137c478bd9Sstevel@tonic-gate * we can be assured that it will succeed. 16147c478bd9Sstevel@tonic-gate */ 16157c478bd9Sstevel@tonic-gate result = getzonenamebyid(zid, zeptr->zname, sizeof (zeptr->zname)); 16167c478bd9Sstevel@tonic-gate assert(result >= 0); 1617555afedfScarlsonj if (zonecfg_is_scratch(zeptr->zname) && 1618555afedfScarlsonj (fp = zonecfg_open_scratch("", B_FALSE)) != NULL) { 1619555afedfScarlsonj (void) zonecfg_reverse_scratch(fp, zeptr->zname, zeptr->zname, 1620555afedfScarlsonj sizeof (zeptr->zname), NULL, 0); 1621555afedfScarlsonj zonecfg_close_scratch(fp); 1622555afedfScarlsonj } 1623555afedfScarlsonj 1624555afedfScarlsonj if (is_system_labeled()) { 162545916cd2Sjpk (void) zone_getattr(zid, ZONE_ATTR_ROOT, zeptr->zroot, 162645916cd2Sjpk sizeof (zeptr->zroot)); 16279acbbeafSnn35248 (void) strlcpy(zeptr->zbrand, NATIVE_BRAND_NAME, 16289acbbeafSnn35248 sizeof (zeptr->zbrand)); 1629555afedfScarlsonj } else { 1630555afedfScarlsonj (void) strlcpy(zeptr->zroot, "/", sizeof (zeptr->zroot)); 16319acbbeafSnn35248 (void) zone_getattr(zid, ZONE_ATTR_BRAND, zeptr->zbrand, 16329acbbeafSnn35248 sizeof (zeptr->zbrand)); 163345916cd2Sjpk } 1634555afedfScarlsonj 16357c478bd9Sstevel@tonic-gate zeptr->zstate_str = "running"; 1636555afedfScarlsonj if (zonecfg_get_uuid(zeptr->zname, uuid) == Z_OK && 1637555afedfScarlsonj !uuid_is_null(uuid)) 1638555afedfScarlsonj uuid_unparse(uuid, zeptr->zuuid); 1639f4b3ec61Sdh155122 1640f4b3ec61Sdh155122 if (zone_getattr(zid, ZONE_ATTR_FLAGS, &flags, sizeof (flags)) < 0) { 1641f4b3ec61Sdh155122 zperror2(zeptr->zname, gettext("could not get zone flags")); 1642f4b3ec61Sdh155122 exit(Z_ERR); 1643f4b3ec61Sdh155122 } 1644f4b3ec61Sdh155122 if (flags & ZF_NET_EXCL) 1645f4b3ec61Sdh155122 zeptr->ziptype = ZS_EXCLUSIVE; 1646f4b3ec61Sdh155122 else 1647f4b3ec61Sdh155122 zeptr->ziptype = ZS_SHARED; 16487c478bd9Sstevel@tonic-gate } 16497c478bd9Sstevel@tonic-gate 16507c478bd9Sstevel@tonic-gate static int 16517c478bd9Sstevel@tonic-gate list_func(int argc, char *argv[]) 16527c478bd9Sstevel@tonic-gate { 16537c478bd9Sstevel@tonic-gate zone_entry_t *zentp, zent; 1654108322fbScarlsonj int arg, retv; 16557c478bd9Sstevel@tonic-gate boolean_t output = B_FALSE, verbose = B_FALSE, parsable = B_FALSE; 16567c478bd9Sstevel@tonic-gate zone_state_t min_state = ZONE_STATE_RUNNING; 16577c478bd9Sstevel@tonic-gate zoneid_t zone_id = getzoneid(); 16587c478bd9Sstevel@tonic-gate 16597c478bd9Sstevel@tonic-gate if (target_zone == NULL) { 16607c478bd9Sstevel@tonic-gate /* all zones: default view to running but allow override */ 16617c478bd9Sstevel@tonic-gate optind = 0; 16627c478bd9Sstevel@tonic-gate while ((arg = getopt(argc, argv, "?cipv")) != EOF) { 16637c478bd9Sstevel@tonic-gate switch (arg) { 16647c478bd9Sstevel@tonic-gate case '?': 16657c478bd9Sstevel@tonic-gate sub_usage(SHELP_LIST, CMD_LIST); 16667c478bd9Sstevel@tonic-gate return (optopt == '?' ? Z_OK : Z_USAGE); 1667475d78a4Sjonb /* 1668475d78a4Sjonb * The 'i' and 'c' options are not mutually 1669475d78a4Sjonb * exclusive so if 'c' is given, then min_state 1670475d78a4Sjonb * is set to 0 (ZONE_STATE_CONFIGURED) which is 1671475d78a4Sjonb * the lowest possible state. If 'i' is given, 1672475d78a4Sjonb * then min_state is set to be the lowest state 1673475d78a4Sjonb * so far. 1674475d78a4Sjonb */ 16757c478bd9Sstevel@tonic-gate case 'c': 16767c478bd9Sstevel@tonic-gate min_state = ZONE_STATE_CONFIGURED; 16777c478bd9Sstevel@tonic-gate break; 16787c478bd9Sstevel@tonic-gate case 'i': 1679475d78a4Sjonb min_state = min(ZONE_STATE_INSTALLED, 1680475d78a4Sjonb min_state); 1681475d78a4Sjonb 16827c478bd9Sstevel@tonic-gate break; 16837c478bd9Sstevel@tonic-gate case 'p': 16847c478bd9Sstevel@tonic-gate parsable = B_TRUE; 16857c478bd9Sstevel@tonic-gate break; 16867c478bd9Sstevel@tonic-gate case 'v': 16877c478bd9Sstevel@tonic-gate verbose = B_TRUE; 16887c478bd9Sstevel@tonic-gate break; 16897c478bd9Sstevel@tonic-gate default: 16907c478bd9Sstevel@tonic-gate sub_usage(SHELP_LIST, CMD_LIST); 16917c478bd9Sstevel@tonic-gate return (Z_USAGE); 16927c478bd9Sstevel@tonic-gate } 16937c478bd9Sstevel@tonic-gate } 16947c478bd9Sstevel@tonic-gate if (parsable && verbose) { 16957c478bd9Sstevel@tonic-gate zerror(gettext("%s -p and -v are mutually exclusive."), 16967c478bd9Sstevel@tonic-gate cmd_to_str(CMD_LIST)); 16977c478bd9Sstevel@tonic-gate return (Z_ERR); 16987c478bd9Sstevel@tonic-gate } 169945916cd2Sjpk if (zone_id == GLOBAL_ZONEID || is_system_labeled()) { 1700108322fbScarlsonj retv = zone_print_list(min_state, verbose, parsable); 17017c478bd9Sstevel@tonic-gate } else { 17027c478bd9Sstevel@tonic-gate fake_up_local_zone(zone_id, &zent); 17039acbbeafSnn35248 retv = Z_OK; 17047c478bd9Sstevel@tonic-gate zone_print(&zent, verbose, parsable); 17057c478bd9Sstevel@tonic-gate } 1706108322fbScarlsonj return (retv); 17077c478bd9Sstevel@tonic-gate } 17087c478bd9Sstevel@tonic-gate 17097c478bd9Sstevel@tonic-gate /* 17107c478bd9Sstevel@tonic-gate * Specific target zone: disallow -i/-c suboptions. 17117c478bd9Sstevel@tonic-gate */ 17127c478bd9Sstevel@tonic-gate optind = 0; 17137c478bd9Sstevel@tonic-gate while ((arg = getopt(argc, argv, "?pv")) != EOF) { 17147c478bd9Sstevel@tonic-gate switch (arg) { 17157c478bd9Sstevel@tonic-gate case '?': 17167c478bd9Sstevel@tonic-gate sub_usage(SHELP_LIST, CMD_LIST); 17177c478bd9Sstevel@tonic-gate return (optopt == '?' ? Z_OK : Z_USAGE); 17187c478bd9Sstevel@tonic-gate case 'p': 17197c478bd9Sstevel@tonic-gate parsable = B_TRUE; 17207c478bd9Sstevel@tonic-gate break; 17217c478bd9Sstevel@tonic-gate case 'v': 17227c478bd9Sstevel@tonic-gate verbose = B_TRUE; 17237c478bd9Sstevel@tonic-gate break; 17247c478bd9Sstevel@tonic-gate default: 17257c478bd9Sstevel@tonic-gate sub_usage(SHELP_LIST, CMD_LIST); 17267c478bd9Sstevel@tonic-gate return (Z_USAGE); 17277c478bd9Sstevel@tonic-gate } 17287c478bd9Sstevel@tonic-gate } 17297c478bd9Sstevel@tonic-gate if (parsable && verbose) { 17307c478bd9Sstevel@tonic-gate zerror(gettext("%s -p and -v are mutually exclusive."), 17317c478bd9Sstevel@tonic-gate cmd_to_str(CMD_LIST)); 17327c478bd9Sstevel@tonic-gate return (Z_ERR); 17337c478bd9Sstevel@tonic-gate } 17347c478bd9Sstevel@tonic-gate if (argc > optind) { 17357c478bd9Sstevel@tonic-gate sub_usage(SHELP_LIST, CMD_LIST); 17367c478bd9Sstevel@tonic-gate return (Z_USAGE); 17377c478bd9Sstevel@tonic-gate } 1738*2ec67e04Sgjelinek if (zone_id != GLOBAL_ZONEID && !is_system_labeled()) { 17397c478bd9Sstevel@tonic-gate fake_up_local_zone(zone_id, &zent); 17407c478bd9Sstevel@tonic-gate /* 17417c478bd9Sstevel@tonic-gate * main() will issue a Z_NO_ZONE error if it cannot get an 17427c478bd9Sstevel@tonic-gate * id for target_zone, which in a non-global zone should 17437c478bd9Sstevel@tonic-gate * happen for any zone name except `zonename`. Thus we 17447c478bd9Sstevel@tonic-gate * assert() that here but don't otherwise check. 17457c478bd9Sstevel@tonic-gate */ 17467c478bd9Sstevel@tonic-gate assert(strcmp(zent.zname, target_zone) == 0); 17477c478bd9Sstevel@tonic-gate zone_print(&zent, verbose, parsable); 17487c478bd9Sstevel@tonic-gate output = B_TRUE; 17497c478bd9Sstevel@tonic-gate } else if ((zentp = lookup_running_zone(target_zone)) != NULL) { 17507c478bd9Sstevel@tonic-gate zone_print(zentp, verbose, parsable); 17517c478bd9Sstevel@tonic-gate output = B_TRUE; 1752108322fbScarlsonj } else if (lookup_zone_info(target_zone, ZONE_ID_UNDEFINED, 1753108322fbScarlsonj &zent) == Z_OK) { 17547c478bd9Sstevel@tonic-gate zone_print(&zent, verbose, parsable); 17557c478bd9Sstevel@tonic-gate output = B_TRUE; 17567c478bd9Sstevel@tonic-gate } 1757ce28b40eSzt129084 1758ce28b40eSzt129084 /* 1759ce28b40eSzt129084 * Invoke brand-specific handler. Note that we do this 1760db628066Sgjelinek * only if we're in the global zone, and target_zone is specified 1761db628066Sgjelinek * and it is not the global zone. 1762ce28b40eSzt129084 */ 1763db628066Sgjelinek if (zone_id == GLOBAL_ZONEID && target_zone != NULL && 1764db628066Sgjelinek strcmp(target_zone, GLOBAL_ZONENAME) != 0) 1765ce28b40eSzt129084 if (invoke_brand_handler(CMD_LIST, argv) != Z_OK) 1766ce28b40eSzt129084 return (Z_ERR); 1767ce28b40eSzt129084 17687c478bd9Sstevel@tonic-gate return (output ? Z_OK : Z_ERR); 17697c478bd9Sstevel@tonic-gate } 17707c478bd9Sstevel@tonic-gate 17717c478bd9Sstevel@tonic-gate static void 17727c478bd9Sstevel@tonic-gate sigterm(int sig) 17737c478bd9Sstevel@tonic-gate { 17747c478bd9Sstevel@tonic-gate /* 17757c478bd9Sstevel@tonic-gate * Ignore SIG{INT,TERM}, so we don't end up in an infinite loop, 17767c478bd9Sstevel@tonic-gate * then propagate the signal to our process group. 17777c478bd9Sstevel@tonic-gate */ 17789acbbeafSnn35248 assert(sig == SIGINT || sig == SIGTERM); 17797c478bd9Sstevel@tonic-gate (void) sigset(SIGINT, SIG_IGN); 17807c478bd9Sstevel@tonic-gate (void) sigset(SIGTERM, SIG_IGN); 17817c478bd9Sstevel@tonic-gate (void) kill(0, sig); 17827c478bd9Sstevel@tonic-gate child_killed = B_TRUE; 17837c478bd9Sstevel@tonic-gate } 17847c478bd9Sstevel@tonic-gate 17857c478bd9Sstevel@tonic-gate static int 17867c478bd9Sstevel@tonic-gate do_subproc(char *cmdbuf) 17877c478bd9Sstevel@tonic-gate { 17887c478bd9Sstevel@tonic-gate char inbuf[1024]; /* arbitrary large amount */ 17897c478bd9Sstevel@tonic-gate FILE *file; 17907c478bd9Sstevel@tonic-gate 17919acbbeafSnn35248 do_subproc_cnt++; 17927c478bd9Sstevel@tonic-gate child_killed = B_FALSE; 17937c478bd9Sstevel@tonic-gate /* 17947c478bd9Sstevel@tonic-gate * We use popen(3c) to launch child processes for [un]install; 17957c478bd9Sstevel@tonic-gate * this library call does not return a PID, so we have to kill 17967c478bd9Sstevel@tonic-gate * the whole process group. To avoid killing our parent, we 17977c478bd9Sstevel@tonic-gate * become a process group leader here. But doing so can wreak 17987c478bd9Sstevel@tonic-gate * havoc with reading from stdin when launched by a non-job-control 17997c478bd9Sstevel@tonic-gate * shell, so we close stdin and reopen it as /dev/null first. 18007c478bd9Sstevel@tonic-gate */ 18017c478bd9Sstevel@tonic-gate (void) close(STDIN_FILENO); 18029acbbeafSnn35248 (void) openat(STDIN_FILENO, "/dev/null", O_RDONLY); 18039acbbeafSnn35248 if (!zoneadm_is_nested) 18047c478bd9Sstevel@tonic-gate (void) setpgid(0, 0); 18057c478bd9Sstevel@tonic-gate (void) sigset(SIGINT, sigterm); 18067c478bd9Sstevel@tonic-gate (void) sigset(SIGTERM, sigterm); 18077c478bd9Sstevel@tonic-gate file = popen(cmdbuf, "r"); 18087c478bd9Sstevel@tonic-gate for (;;) { 18097c478bd9Sstevel@tonic-gate if (child_killed || fgets(inbuf, sizeof (inbuf), file) == NULL) 18107c478bd9Sstevel@tonic-gate break; 18117c478bd9Sstevel@tonic-gate (void) fputs(inbuf, stdout); 18127c478bd9Sstevel@tonic-gate } 18137c478bd9Sstevel@tonic-gate (void) sigset(SIGINT, SIG_DFL); 18147c478bd9Sstevel@tonic-gate (void) sigset(SIGTERM, SIG_DFL); 18157c478bd9Sstevel@tonic-gate return (pclose(file)); 18167c478bd9Sstevel@tonic-gate } 18177c478bd9Sstevel@tonic-gate 18187c478bd9Sstevel@tonic-gate static int 18199acbbeafSnn35248 do_subproc_interactive(char *cmdbuf) 18209acbbeafSnn35248 { 18219acbbeafSnn35248 void (*saveint)(int); 18229acbbeafSnn35248 void (*saveterm)(int); 18239acbbeafSnn35248 void (*savequit)(int); 18249acbbeafSnn35248 void (*savehup)(int); 18259acbbeafSnn35248 int pid, child, status; 18269acbbeafSnn35248 18279acbbeafSnn35248 /* 18289acbbeafSnn35248 * do_subproc() links stdin to /dev/null, which would break any 18299acbbeafSnn35248 * interactive subprocess we try to launch here. Similarly, we 18309acbbeafSnn35248 * can't have been launched as a subprocess ourselves. 18319acbbeafSnn35248 */ 18329acbbeafSnn35248 assert(do_subproc_cnt == 0 && !zoneadm_is_nested); 18339acbbeafSnn35248 18349acbbeafSnn35248 if ((child = vfork()) == 0) { 18359acbbeafSnn35248 (void) execl("/bin/sh", "sh", "-c", cmdbuf, (char *)NULL); 18369acbbeafSnn35248 } 18379acbbeafSnn35248 18389acbbeafSnn35248 if (child == -1) 18399acbbeafSnn35248 return (-1); 18409acbbeafSnn35248 18419acbbeafSnn35248 saveint = sigset(SIGINT, SIG_IGN); 18429acbbeafSnn35248 saveterm = sigset(SIGTERM, SIG_IGN); 18439acbbeafSnn35248 savequit = sigset(SIGQUIT, SIG_IGN); 18449acbbeafSnn35248 savehup = sigset(SIGHUP, SIG_IGN); 18459acbbeafSnn35248 18469acbbeafSnn35248 while ((pid = waitpid(child, &status, 0)) != child && pid != -1) 18479acbbeafSnn35248 ; 18489acbbeafSnn35248 18499acbbeafSnn35248 (void) sigset(SIGINT, saveint); 18509acbbeafSnn35248 (void) sigset(SIGTERM, saveterm); 18519acbbeafSnn35248 (void) sigset(SIGQUIT, savequit); 18529acbbeafSnn35248 (void) sigset(SIGHUP, savehup); 18539acbbeafSnn35248 18549acbbeafSnn35248 return (pid == -1 ? -1 : status); 18559acbbeafSnn35248 } 18569acbbeafSnn35248 18579acbbeafSnn35248 static int 18589acbbeafSnn35248 subproc_status(const char *cmd, int status, boolean_t verbose_failure) 18597c478bd9Sstevel@tonic-gate { 18607c478bd9Sstevel@tonic-gate if (WIFEXITED(status)) { 18617c478bd9Sstevel@tonic-gate int exit_code = WEXITSTATUS(status); 18627c478bd9Sstevel@tonic-gate 18639acbbeafSnn35248 if ((verbose_failure) && (exit_code != ZONE_SUBPROC_OK)) 18647c478bd9Sstevel@tonic-gate zerror(gettext("'%s' failed with exit code %d."), cmd, 18657c478bd9Sstevel@tonic-gate exit_code); 18669acbbeafSnn35248 18679acbbeafSnn35248 return (exit_code); 18687c478bd9Sstevel@tonic-gate } else if (WIFSIGNALED(status)) { 18697c478bd9Sstevel@tonic-gate int signal = WTERMSIG(status); 18707c478bd9Sstevel@tonic-gate char sigstr[SIG2STR_MAX]; 18717c478bd9Sstevel@tonic-gate 18727c478bd9Sstevel@tonic-gate if (sig2str(signal, sigstr) == 0) { 18737c478bd9Sstevel@tonic-gate zerror(gettext("'%s' terminated by signal SIG%s."), cmd, 18747c478bd9Sstevel@tonic-gate sigstr); 18757c478bd9Sstevel@tonic-gate } else { 18767c478bd9Sstevel@tonic-gate zerror(gettext("'%s' terminated by an unknown signal."), 18777c478bd9Sstevel@tonic-gate cmd); 18787c478bd9Sstevel@tonic-gate } 18797c478bd9Sstevel@tonic-gate } else { 18807c478bd9Sstevel@tonic-gate zerror(gettext("'%s' failed for unknown reasons."), cmd); 18817c478bd9Sstevel@tonic-gate } 18829acbbeafSnn35248 18839acbbeafSnn35248 /* 18849acbbeafSnn35248 * Assume a subprocess that died due to a signal or an unknown error 18859acbbeafSnn35248 * should be considered an exit code of ZONE_SUBPROC_FATAL, as the 18869acbbeafSnn35248 * user will likely need to do some manual cleanup. 18879acbbeafSnn35248 */ 18889acbbeafSnn35248 return (ZONE_SUBPROC_FATAL); 18897c478bd9Sstevel@tonic-gate } 18907c478bd9Sstevel@tonic-gate 18917c478bd9Sstevel@tonic-gate /* 18927c478bd9Sstevel@tonic-gate * Various sanity checks; make sure: 18937c478bd9Sstevel@tonic-gate * 1. We're in the global zone. 18947c478bd9Sstevel@tonic-gate * 2. The calling user has sufficient privilege. 18957c478bd9Sstevel@tonic-gate * 3. The target zone is neither the global zone nor anything starting with 18967c478bd9Sstevel@tonic-gate * "SUNW". 18977c478bd9Sstevel@tonic-gate * 4a. If we're looking for a 'not running' (i.e., configured or installed) 18987c478bd9Sstevel@tonic-gate * zone, the name service knows about it. 18997c478bd9Sstevel@tonic-gate * 4b. For some operations which expect a zone not to be running, that it is 19007c478bd9Sstevel@tonic-gate * not already running (or ready). 19017c478bd9Sstevel@tonic-gate */ 19027c478bd9Sstevel@tonic-gate static int 19037c478bd9Sstevel@tonic-gate sanity_check(char *zone, int cmd_num, boolean_t running, 19049acbbeafSnn35248 boolean_t unsafe_when_running, boolean_t force) 19057c478bd9Sstevel@tonic-gate { 19067c478bd9Sstevel@tonic-gate zone_entry_t *zent; 19077c478bd9Sstevel@tonic-gate priv_set_t *privset; 19089acbbeafSnn35248 zone_state_t state, min_state; 1909108322fbScarlsonj char kernzone[ZONENAME_MAX]; 1910108322fbScarlsonj FILE *fp; 19117c478bd9Sstevel@tonic-gate 19127c478bd9Sstevel@tonic-gate if (getzoneid() != GLOBAL_ZONEID) { 1913ffbafc53Scomay switch (cmd_num) { 1914ffbafc53Scomay case CMD_HALT: 1915ffbafc53Scomay zerror(gettext("use %s to %s this zone."), "halt(1M)", 19167c478bd9Sstevel@tonic-gate cmd_to_str(cmd_num)); 1917ffbafc53Scomay break; 1918ffbafc53Scomay case CMD_REBOOT: 1919ffbafc53Scomay zerror(gettext("use %s to %s this zone."), 1920ffbafc53Scomay "reboot(1M)", cmd_to_str(cmd_num)); 1921ffbafc53Scomay break; 1922ffbafc53Scomay default: 1923ffbafc53Scomay zerror(gettext("must be in the global zone to %s a " 1924ffbafc53Scomay "zone."), cmd_to_str(cmd_num)); 1925ffbafc53Scomay break; 1926ffbafc53Scomay } 19277c478bd9Sstevel@tonic-gate return (Z_ERR); 19287c478bd9Sstevel@tonic-gate } 19297c478bd9Sstevel@tonic-gate 19307c478bd9Sstevel@tonic-gate if ((privset = priv_allocset()) == NULL) { 19317c478bd9Sstevel@tonic-gate zerror(gettext("%s failed"), "priv_allocset"); 19327c478bd9Sstevel@tonic-gate return (Z_ERR); 19337c478bd9Sstevel@tonic-gate } 19347c478bd9Sstevel@tonic-gate 19357c478bd9Sstevel@tonic-gate if (getppriv(PRIV_EFFECTIVE, privset) != 0) { 19367c478bd9Sstevel@tonic-gate zerror(gettext("%s failed"), "getppriv"); 19377c478bd9Sstevel@tonic-gate priv_freeset(privset); 19387c478bd9Sstevel@tonic-gate return (Z_ERR); 19397c478bd9Sstevel@tonic-gate } 19407c478bd9Sstevel@tonic-gate 19417c478bd9Sstevel@tonic-gate if (priv_isfullset(privset) == B_FALSE) { 19427c478bd9Sstevel@tonic-gate zerror(gettext("only a privileged user may %s a zone."), 19437c478bd9Sstevel@tonic-gate cmd_to_str(cmd_num)); 19447c478bd9Sstevel@tonic-gate priv_freeset(privset); 19457c478bd9Sstevel@tonic-gate return (Z_ERR); 19467c478bd9Sstevel@tonic-gate } 19477c478bd9Sstevel@tonic-gate priv_freeset(privset); 19487c478bd9Sstevel@tonic-gate 19497c478bd9Sstevel@tonic-gate if (zone == NULL) { 19507c478bd9Sstevel@tonic-gate zerror(gettext("no zone specified")); 19517c478bd9Sstevel@tonic-gate return (Z_ERR); 19527c478bd9Sstevel@tonic-gate } 19537c478bd9Sstevel@tonic-gate 19547c478bd9Sstevel@tonic-gate if (strcmp(zone, GLOBAL_ZONENAME) == 0) { 19557c478bd9Sstevel@tonic-gate zerror(gettext("%s operation is invalid for the global zone."), 19567c478bd9Sstevel@tonic-gate cmd_to_str(cmd_num)); 19577c478bd9Sstevel@tonic-gate return (Z_ERR); 19587c478bd9Sstevel@tonic-gate } 19597c478bd9Sstevel@tonic-gate 19607c478bd9Sstevel@tonic-gate if (strncmp(zone, "SUNW", 4) == 0) { 19617c478bd9Sstevel@tonic-gate zerror(gettext("%s operation is invalid for zones starting " 19627c478bd9Sstevel@tonic-gate "with SUNW."), cmd_to_str(cmd_num)); 19637c478bd9Sstevel@tonic-gate return (Z_ERR); 19647c478bd9Sstevel@tonic-gate } 19657c478bd9Sstevel@tonic-gate 19669acbbeafSnn35248 if (!is_native_zone && cmd_num == CMD_MOUNT) { 19679acbbeafSnn35248 zerror(gettext("%s operation is invalid for branded zones."), 19689acbbeafSnn35248 cmd_to_str(cmd_num)); 19699acbbeafSnn35248 return (Z_ERR); 19709acbbeafSnn35248 } 19719acbbeafSnn35248 1972108322fbScarlsonj if (!zonecfg_in_alt_root()) { 1973108322fbScarlsonj zent = lookup_running_zone(zone); 1974108322fbScarlsonj } else if ((fp = zonecfg_open_scratch("", B_FALSE)) == NULL) { 1975108322fbScarlsonj zent = NULL; 1976108322fbScarlsonj } else { 1977108322fbScarlsonj if (zonecfg_find_scratch(fp, zone, zonecfg_get_root(), 1978108322fbScarlsonj kernzone, sizeof (kernzone)) == 0) 1979108322fbScarlsonj zent = lookup_running_zone(kernzone); 1980108322fbScarlsonj else 1981108322fbScarlsonj zent = NULL; 1982108322fbScarlsonj zonecfg_close_scratch(fp); 1983108322fbScarlsonj } 1984108322fbScarlsonj 19857c478bd9Sstevel@tonic-gate /* 19867c478bd9Sstevel@tonic-gate * Look up from the kernel for 'running' zones. 19877c478bd9Sstevel@tonic-gate */ 19889acbbeafSnn35248 if (running && !force) { 19897c478bd9Sstevel@tonic-gate if (zent == NULL) { 19907c478bd9Sstevel@tonic-gate zerror(gettext("not running")); 19917c478bd9Sstevel@tonic-gate return (Z_ERR); 19927c478bd9Sstevel@tonic-gate } 19937c478bd9Sstevel@tonic-gate } else { 19947c478bd9Sstevel@tonic-gate int err; 19957c478bd9Sstevel@tonic-gate 19967c478bd9Sstevel@tonic-gate if (unsafe_when_running && zent != NULL) { 19977c478bd9Sstevel@tonic-gate /* check whether the zone is ready or running */ 19987c478bd9Sstevel@tonic-gate if ((err = zone_get_state(zent->zname, 19997c478bd9Sstevel@tonic-gate &zent->zstate_num)) != Z_OK) { 20007c478bd9Sstevel@tonic-gate errno = err; 20017c478bd9Sstevel@tonic-gate zperror2(zent->zname, 20027c478bd9Sstevel@tonic-gate gettext("could not get state")); 20037c478bd9Sstevel@tonic-gate /* can't tell, so hedge */ 20047c478bd9Sstevel@tonic-gate zent->zstate_str = "ready/running"; 20057c478bd9Sstevel@tonic-gate } else { 20067c478bd9Sstevel@tonic-gate zent->zstate_str = 20077c478bd9Sstevel@tonic-gate zone_state_str(zent->zstate_num); 20087c478bd9Sstevel@tonic-gate } 20097c478bd9Sstevel@tonic-gate zerror(gettext("%s operation is invalid for %s zones."), 20107c478bd9Sstevel@tonic-gate cmd_to_str(cmd_num), zent->zstate_str); 20117c478bd9Sstevel@tonic-gate return (Z_ERR); 20127c478bd9Sstevel@tonic-gate } 20137c478bd9Sstevel@tonic-gate if ((err = zone_get_state(zone, &state)) != Z_OK) { 20147c478bd9Sstevel@tonic-gate errno = err; 20157c478bd9Sstevel@tonic-gate zperror2(zone, gettext("could not get state")); 20167c478bd9Sstevel@tonic-gate return (Z_ERR); 20177c478bd9Sstevel@tonic-gate } 20187c478bd9Sstevel@tonic-gate switch (cmd_num) { 20197c478bd9Sstevel@tonic-gate case CMD_UNINSTALL: 20207c478bd9Sstevel@tonic-gate if (state == ZONE_STATE_CONFIGURED) { 20217c478bd9Sstevel@tonic-gate zerror(gettext("is already in state '%s'."), 20227c478bd9Sstevel@tonic-gate zone_state_str(ZONE_STATE_CONFIGURED)); 20237c478bd9Sstevel@tonic-gate return (Z_ERR); 20247c478bd9Sstevel@tonic-gate } 20257c478bd9Sstevel@tonic-gate break; 2026ee519a1fSgjelinek case CMD_ATTACH: 2027865e09a4Sgjelinek case CMD_CLONE: 20287c478bd9Sstevel@tonic-gate case CMD_INSTALL: 20297c478bd9Sstevel@tonic-gate if (state == ZONE_STATE_INSTALLED) { 20307c478bd9Sstevel@tonic-gate zerror(gettext("is already %s."), 20317c478bd9Sstevel@tonic-gate zone_state_str(ZONE_STATE_INSTALLED)); 20327c478bd9Sstevel@tonic-gate return (Z_ERR); 20337c478bd9Sstevel@tonic-gate } else if (state == ZONE_STATE_INCOMPLETE) { 20347c478bd9Sstevel@tonic-gate zerror(gettext("zone is %s; %s required."), 20357c478bd9Sstevel@tonic-gate zone_state_str(ZONE_STATE_INCOMPLETE), 20367c478bd9Sstevel@tonic-gate cmd_to_str(CMD_UNINSTALL)); 20377c478bd9Sstevel@tonic-gate return (Z_ERR); 20387c478bd9Sstevel@tonic-gate } 20397c478bd9Sstevel@tonic-gate break; 2040ee519a1fSgjelinek case CMD_DETACH: 2041865e09a4Sgjelinek case CMD_MOVE: 20427c478bd9Sstevel@tonic-gate case CMD_READY: 20437c478bd9Sstevel@tonic-gate case CMD_BOOT: 2044108322fbScarlsonj case CMD_MOUNT: 2045555afedfScarlsonj case CMD_MARK: 20469acbbeafSnn35248 if ((cmd_num == CMD_BOOT || cmd_num == CMD_MOUNT) && 20479acbbeafSnn35248 force) 20489acbbeafSnn35248 min_state = ZONE_STATE_INCOMPLETE; 20499acbbeafSnn35248 else 20509acbbeafSnn35248 min_state = ZONE_STATE_INSTALLED; 20519acbbeafSnn35248 20529acbbeafSnn35248 if (force && cmd_num == CMD_BOOT && is_native_zone) { 20539acbbeafSnn35248 zerror(gettext("Only branded zones may be " 20549acbbeafSnn35248 "force-booted.")); 20559acbbeafSnn35248 return (Z_ERR); 20569acbbeafSnn35248 } 20579acbbeafSnn35248 20589acbbeafSnn35248 if (state < min_state) { 20597c478bd9Sstevel@tonic-gate zerror(gettext("must be %s before %s."), 20609acbbeafSnn35248 zone_state_str(min_state), 20617c478bd9Sstevel@tonic-gate cmd_to_str(cmd_num)); 20627c478bd9Sstevel@tonic-gate return (Z_ERR); 20637c478bd9Sstevel@tonic-gate } 20647c478bd9Sstevel@tonic-gate break; 20657c478bd9Sstevel@tonic-gate case CMD_VERIFY: 20667c478bd9Sstevel@tonic-gate if (state == ZONE_STATE_INCOMPLETE) { 20677c478bd9Sstevel@tonic-gate zerror(gettext("zone is %s; %s required."), 20687c478bd9Sstevel@tonic-gate zone_state_str(ZONE_STATE_INCOMPLETE), 20697c478bd9Sstevel@tonic-gate cmd_to_str(CMD_UNINSTALL)); 20707c478bd9Sstevel@tonic-gate return (Z_ERR); 20717c478bd9Sstevel@tonic-gate } 20727c478bd9Sstevel@tonic-gate break; 2073108322fbScarlsonj case CMD_UNMOUNT: 2074108322fbScarlsonj if (state != ZONE_STATE_MOUNTED) { 2075108322fbScarlsonj zerror(gettext("must be %s before %s."), 2076108322fbScarlsonj zone_state_str(ZONE_STATE_MOUNTED), 2077108322fbScarlsonj cmd_to_str(cmd_num)); 2078108322fbScarlsonj return (Z_ERR); 2079108322fbScarlsonj } 2080108322fbScarlsonj break; 20817c478bd9Sstevel@tonic-gate } 20827c478bd9Sstevel@tonic-gate } 20837c478bd9Sstevel@tonic-gate return (Z_OK); 20847c478bd9Sstevel@tonic-gate } 20857c478bd9Sstevel@tonic-gate 20867c478bd9Sstevel@tonic-gate static int 20877c478bd9Sstevel@tonic-gate halt_func(int argc, char *argv[]) 20887c478bd9Sstevel@tonic-gate { 20897c478bd9Sstevel@tonic-gate zone_cmd_arg_t zarg; 20907c478bd9Sstevel@tonic-gate int arg; 20917c478bd9Sstevel@tonic-gate 2092108322fbScarlsonj if (zonecfg_in_alt_root()) { 2093108322fbScarlsonj zerror(gettext("cannot halt zone in alternate root")); 2094108322fbScarlsonj return (Z_ERR); 2095108322fbScarlsonj } 2096108322fbScarlsonj 20977c478bd9Sstevel@tonic-gate optind = 0; 20987c478bd9Sstevel@tonic-gate if ((arg = getopt(argc, argv, "?")) != EOF) { 20997c478bd9Sstevel@tonic-gate switch (arg) { 21007c478bd9Sstevel@tonic-gate case '?': 21017c478bd9Sstevel@tonic-gate sub_usage(SHELP_HALT, CMD_HALT); 21027c478bd9Sstevel@tonic-gate return (optopt == '?' ? Z_OK : Z_USAGE); 21037c478bd9Sstevel@tonic-gate default: 21047c478bd9Sstevel@tonic-gate sub_usage(SHELP_HALT, CMD_HALT); 21057c478bd9Sstevel@tonic-gate return (Z_USAGE); 21067c478bd9Sstevel@tonic-gate } 21077c478bd9Sstevel@tonic-gate } 21087c478bd9Sstevel@tonic-gate if (argc > optind) { 21097c478bd9Sstevel@tonic-gate sub_usage(SHELP_HALT, CMD_HALT); 21107c478bd9Sstevel@tonic-gate return (Z_USAGE); 21117c478bd9Sstevel@tonic-gate } 21127c478bd9Sstevel@tonic-gate /* 21137c478bd9Sstevel@tonic-gate * zoneadmd should be the one to decide whether or not to proceed, 21147c478bd9Sstevel@tonic-gate * so even though it seems that the fourth parameter below should 21157c478bd9Sstevel@tonic-gate * perhaps be B_TRUE, it really shouldn't be. 21167c478bd9Sstevel@tonic-gate */ 21179acbbeafSnn35248 if (sanity_check(target_zone, CMD_HALT, B_FALSE, B_FALSE, B_FALSE) 21189acbbeafSnn35248 != Z_OK) 21197c478bd9Sstevel@tonic-gate return (Z_ERR); 21207c478bd9Sstevel@tonic-gate 2121ce28b40eSzt129084 /* 2122ce28b40eSzt129084 * Invoke brand-specific handler. 2123ce28b40eSzt129084 */ 2124ce28b40eSzt129084 if (invoke_brand_handler(CMD_HALT, argv) != Z_OK) 2125ce28b40eSzt129084 return (Z_ERR); 2126ce28b40eSzt129084 21277c478bd9Sstevel@tonic-gate zarg.cmd = Z_HALT; 21287c478bd9Sstevel@tonic-gate return ((call_zoneadmd(target_zone, &zarg) == 0) ? Z_OK : Z_ERR); 21297c478bd9Sstevel@tonic-gate } 21307c478bd9Sstevel@tonic-gate 21317c478bd9Sstevel@tonic-gate static int 21327c478bd9Sstevel@tonic-gate reboot_func(int argc, char *argv[]) 21337c478bd9Sstevel@tonic-gate { 21347c478bd9Sstevel@tonic-gate zone_cmd_arg_t zarg; 21357c478bd9Sstevel@tonic-gate int arg; 21367c478bd9Sstevel@tonic-gate 2137108322fbScarlsonj if (zonecfg_in_alt_root()) { 2138108322fbScarlsonj zerror(gettext("cannot reboot zone in alternate root")); 2139108322fbScarlsonj return (Z_ERR); 2140108322fbScarlsonj } 2141108322fbScarlsonj 21427c478bd9Sstevel@tonic-gate optind = 0; 21437c478bd9Sstevel@tonic-gate if ((arg = getopt(argc, argv, "?")) != EOF) { 21447c478bd9Sstevel@tonic-gate switch (arg) { 21457c478bd9Sstevel@tonic-gate case '?': 21467c478bd9Sstevel@tonic-gate sub_usage(SHELP_REBOOT, CMD_REBOOT); 21477c478bd9Sstevel@tonic-gate return (optopt == '?' ? Z_OK : Z_USAGE); 21487c478bd9Sstevel@tonic-gate default: 21497c478bd9Sstevel@tonic-gate sub_usage(SHELP_REBOOT, CMD_REBOOT); 21507c478bd9Sstevel@tonic-gate return (Z_USAGE); 21517c478bd9Sstevel@tonic-gate } 21527c478bd9Sstevel@tonic-gate } 21533f2f09c1Sdp 21543f2f09c1Sdp zarg.bootbuf[0] = '\0'; 21553f2f09c1Sdp for (; optind < argc; optind++) { 21563f2f09c1Sdp if (strlcat(zarg.bootbuf, argv[optind], 21573f2f09c1Sdp sizeof (zarg.bootbuf)) >= sizeof (zarg.bootbuf)) { 21583f2f09c1Sdp zerror(gettext("Boot argument list too long")); 21593f2f09c1Sdp return (Z_ERR); 21607c478bd9Sstevel@tonic-gate } 21613f2f09c1Sdp if (optind < argc - 1) 21623f2f09c1Sdp if (strlcat(zarg.bootbuf, " ", sizeof (zarg.bootbuf)) >= 21633f2f09c1Sdp sizeof (zarg.bootbuf)) { 21643f2f09c1Sdp zerror(gettext("Boot argument list too long")); 21653f2f09c1Sdp return (Z_ERR); 21663f2f09c1Sdp } 21673f2f09c1Sdp } 21683f2f09c1Sdp 21693f2f09c1Sdp 21707c478bd9Sstevel@tonic-gate /* 21717c478bd9Sstevel@tonic-gate * zoneadmd should be the one to decide whether or not to proceed, 21727c478bd9Sstevel@tonic-gate * so even though it seems that the fourth parameter below should 21737c478bd9Sstevel@tonic-gate * perhaps be B_TRUE, it really shouldn't be. 21747c478bd9Sstevel@tonic-gate */ 21759acbbeafSnn35248 if (sanity_check(target_zone, CMD_REBOOT, B_TRUE, B_FALSE, B_FALSE) 21769acbbeafSnn35248 != Z_OK) 21777c478bd9Sstevel@tonic-gate return (Z_ERR); 2178ce28b40eSzt129084 if (verify_details(CMD_REBOOT, argv) != Z_OK) 2179b5abaf04Sgjelinek return (Z_ERR); 21807c478bd9Sstevel@tonic-gate 21817c478bd9Sstevel@tonic-gate zarg.cmd = Z_REBOOT; 21827c478bd9Sstevel@tonic-gate return ((call_zoneadmd(target_zone, &zarg) == 0) ? Z_OK : Z_ERR); 21837c478bd9Sstevel@tonic-gate } 21847c478bd9Sstevel@tonic-gate 21857c478bd9Sstevel@tonic-gate static int 2186ce28b40eSzt129084 verify_brand(zone_dochandle_t handle, int cmd_num, char *argv[]) 21879acbbeafSnn35248 { 21889acbbeafSnn35248 char cmdbuf[MAXPATHLEN]; 21899acbbeafSnn35248 int err; 21909acbbeafSnn35248 char zonepath[MAXPATHLEN]; 2191123807fbSedp brand_handle_t bh = NULL; 2192ce28b40eSzt129084 int status, i; 21939acbbeafSnn35248 21949acbbeafSnn35248 /* 21959acbbeafSnn35248 * Fetch the verify command from the brand configuration. 21969acbbeafSnn35248 * "exec" the command so that the returned status is that of 21979acbbeafSnn35248 * the command and not the shell. 21989acbbeafSnn35248 */ 21999acbbeafSnn35248 if ((err = zonecfg_get_zonepath(handle, zonepath, sizeof (zonepath))) != 22009acbbeafSnn35248 Z_OK) { 22019acbbeafSnn35248 errno = err; 2202ce28b40eSzt129084 zperror(cmd_to_str(cmd_num), B_TRUE); 22039acbbeafSnn35248 return (Z_ERR); 22049acbbeafSnn35248 } 2205123807fbSedp if ((bh = brand_open(target_brand)) == NULL) { 22069acbbeafSnn35248 zerror(gettext("missing or invalid brand")); 22079acbbeafSnn35248 return (Z_ERR); 22089acbbeafSnn35248 } 22099acbbeafSnn35248 22109acbbeafSnn35248 /* 22119acbbeafSnn35248 * If the brand has its own verification routine, execute it now. 2212ce28b40eSzt129084 * The verification routine validates the intended zoneadm 2213ce28b40eSzt129084 * operation for the specific brand. The zoneadm subcommand and 2214ce28b40eSzt129084 * all its arguments are passed to the routine. 22159acbbeafSnn35248 */ 22169acbbeafSnn35248 (void) strcpy(cmdbuf, EXEC_PREFIX); 2217123807fbSedp err = brand_get_verify_adm(bh, target_zone, zonepath, 22189acbbeafSnn35248 cmdbuf + EXEC_LEN, sizeof (cmdbuf) - EXEC_LEN, 0, NULL); 2219123807fbSedp brand_close(bh); 2220ce28b40eSzt129084 if (err != 0) 2221ce28b40eSzt129084 return (Z_BRAND_ERROR); 2222ce28b40eSzt129084 if (strlen(cmdbuf) <= EXEC_LEN) 2223ce28b40eSzt129084 return (Z_OK); 2224ce28b40eSzt129084 2225ce28b40eSzt129084 if (strlcat(cmdbuf, cmd_to_str(cmd_num), 2226ce28b40eSzt129084 sizeof (cmdbuf)) >= sizeof (cmdbuf)) 2227ce28b40eSzt129084 return (Z_ERR); 2228ce28b40eSzt129084 2229ce28b40eSzt129084 /* Build the argv string */ 2230ce28b40eSzt129084 i = 0; 2231ce28b40eSzt129084 while (argv[i] != NULL) { 2232ce28b40eSzt129084 if ((strlcat(cmdbuf, " ", 2233ce28b40eSzt129084 sizeof (cmdbuf)) >= sizeof (cmdbuf)) || 2234ce28b40eSzt129084 (strlcat(cmdbuf, argv[i++], 2235ce28b40eSzt129084 sizeof (cmdbuf)) >= sizeof (cmdbuf))) 2236ce28b40eSzt129084 return (Z_ERR); 2237ce28b40eSzt129084 } 2238ce28b40eSzt129084 2239d9e728a2Sgjelinek if (zoneadm_is_nested) 2240d9e728a2Sgjelinek status = do_subproc(cmdbuf); 2241d9e728a2Sgjelinek else 22429acbbeafSnn35248 status = do_subproc_interactive(cmdbuf); 22439acbbeafSnn35248 err = subproc_status(gettext("brand-specific verification"), 22449acbbeafSnn35248 status, B_FALSE); 22459acbbeafSnn35248 2246ce28b40eSzt129084 return ((err == ZONE_SUBPROC_OK) ? Z_OK : Z_BRAND_ERROR); 22479acbbeafSnn35248 } 22489acbbeafSnn35248 22499acbbeafSnn35248 static int 22507c478bd9Sstevel@tonic-gate verify_rctls(zone_dochandle_t handle) 22517c478bd9Sstevel@tonic-gate { 22527c478bd9Sstevel@tonic-gate struct zone_rctltab rctltab; 22537c478bd9Sstevel@tonic-gate size_t rbs = rctlblk_size(); 22547c478bd9Sstevel@tonic-gate rctlblk_t *rctlblk; 22557c478bd9Sstevel@tonic-gate int error = Z_INVAL; 22567c478bd9Sstevel@tonic-gate 22577c478bd9Sstevel@tonic-gate if ((rctlblk = malloc(rbs)) == NULL) { 22587c478bd9Sstevel@tonic-gate zerror(gettext("failed to allocate %lu bytes: %s"), rbs, 22597c478bd9Sstevel@tonic-gate strerror(errno)); 22607c478bd9Sstevel@tonic-gate return (Z_NOMEM); 22617c478bd9Sstevel@tonic-gate } 22627c478bd9Sstevel@tonic-gate 22637c478bd9Sstevel@tonic-gate if (zonecfg_setrctlent(handle) != Z_OK) { 22647c478bd9Sstevel@tonic-gate zerror(gettext("zonecfg_setrctlent failed")); 22657c478bd9Sstevel@tonic-gate free(rctlblk); 22667c478bd9Sstevel@tonic-gate return (error); 22677c478bd9Sstevel@tonic-gate } 22687c478bd9Sstevel@tonic-gate 22697c478bd9Sstevel@tonic-gate rctltab.zone_rctl_valptr = NULL; 22707c478bd9Sstevel@tonic-gate while (zonecfg_getrctlent(handle, &rctltab) == Z_OK) { 22717c478bd9Sstevel@tonic-gate struct zone_rctlvaltab *rctlval; 22727c478bd9Sstevel@tonic-gate const char *name = rctltab.zone_rctl_name; 22737c478bd9Sstevel@tonic-gate 22747c478bd9Sstevel@tonic-gate if (!zonecfg_is_rctl(name)) { 22757c478bd9Sstevel@tonic-gate zerror(gettext("WARNING: Ignoring unrecognized rctl " 22767c478bd9Sstevel@tonic-gate "'%s'."), name); 22777c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctltab.zone_rctl_valptr); 22787c478bd9Sstevel@tonic-gate rctltab.zone_rctl_valptr = NULL; 22797c478bd9Sstevel@tonic-gate continue; 22807c478bd9Sstevel@tonic-gate } 22817c478bd9Sstevel@tonic-gate 22827c478bd9Sstevel@tonic-gate for (rctlval = rctltab.zone_rctl_valptr; rctlval != NULL; 22837c478bd9Sstevel@tonic-gate rctlval = rctlval->zone_rctlval_next) { 22847c478bd9Sstevel@tonic-gate if (zonecfg_construct_rctlblk(rctlval, rctlblk) 22857c478bd9Sstevel@tonic-gate != Z_OK) { 22867c478bd9Sstevel@tonic-gate zerror(gettext("invalid rctl value: " 22877c478bd9Sstevel@tonic-gate "(priv=%s,limit=%s,action%s)"), 22887c478bd9Sstevel@tonic-gate rctlval->zone_rctlval_priv, 22897c478bd9Sstevel@tonic-gate rctlval->zone_rctlval_limit, 22907c478bd9Sstevel@tonic-gate rctlval->zone_rctlval_action); 22917c478bd9Sstevel@tonic-gate goto out; 22927c478bd9Sstevel@tonic-gate } 22937c478bd9Sstevel@tonic-gate if (!zonecfg_valid_rctl(name, rctlblk)) { 22947c478bd9Sstevel@tonic-gate zerror(gettext("(priv=%s,limit=%s,action=%s) " 22957c478bd9Sstevel@tonic-gate "is not a valid value for rctl '%s'"), 22967c478bd9Sstevel@tonic-gate rctlval->zone_rctlval_priv, 22977c478bd9Sstevel@tonic-gate rctlval->zone_rctlval_limit, 22987c478bd9Sstevel@tonic-gate rctlval->zone_rctlval_action, 22997c478bd9Sstevel@tonic-gate name); 23007c478bd9Sstevel@tonic-gate goto out; 23017c478bd9Sstevel@tonic-gate } 23027c478bd9Sstevel@tonic-gate } 23037c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctltab.zone_rctl_valptr); 23047c478bd9Sstevel@tonic-gate } 23057c478bd9Sstevel@tonic-gate rctltab.zone_rctl_valptr = NULL; 23067c478bd9Sstevel@tonic-gate error = Z_OK; 23077c478bd9Sstevel@tonic-gate out: 23087c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctltab.zone_rctl_valptr); 23097c478bd9Sstevel@tonic-gate (void) zonecfg_endrctlent(handle); 23107c478bd9Sstevel@tonic-gate free(rctlblk); 23117c478bd9Sstevel@tonic-gate return (error); 23127c478bd9Sstevel@tonic-gate } 23137c478bd9Sstevel@tonic-gate 23147c478bd9Sstevel@tonic-gate static int 23157c478bd9Sstevel@tonic-gate verify_pool(zone_dochandle_t handle) 23167c478bd9Sstevel@tonic-gate { 23177c478bd9Sstevel@tonic-gate char poolname[MAXPATHLEN]; 23187c478bd9Sstevel@tonic-gate pool_conf_t *poolconf; 23197c478bd9Sstevel@tonic-gate pool_t *pool; 23207c478bd9Sstevel@tonic-gate int status; 23217c478bd9Sstevel@tonic-gate int error; 23227c478bd9Sstevel@tonic-gate 23237c478bd9Sstevel@tonic-gate /* 23247c478bd9Sstevel@tonic-gate * This ends up being very similar to the check done in zoneadmd. 23257c478bd9Sstevel@tonic-gate */ 23267c478bd9Sstevel@tonic-gate error = zonecfg_get_pool(handle, poolname, sizeof (poolname)); 23277c478bd9Sstevel@tonic-gate if (error == Z_NO_ENTRY || (error == Z_OK && strlen(poolname) == 0)) { 23287c478bd9Sstevel@tonic-gate /* 23297c478bd9Sstevel@tonic-gate * No pool specified. 23307c478bd9Sstevel@tonic-gate */ 23317c478bd9Sstevel@tonic-gate return (0); 23327c478bd9Sstevel@tonic-gate } 23337c478bd9Sstevel@tonic-gate if (error != Z_OK) { 23347c478bd9Sstevel@tonic-gate zperror(gettext("Unable to retrieve pool name from " 23357c478bd9Sstevel@tonic-gate "configuration"), B_TRUE); 23367c478bd9Sstevel@tonic-gate return (error); 23377c478bd9Sstevel@tonic-gate } 23387c478bd9Sstevel@tonic-gate /* 23397c478bd9Sstevel@tonic-gate * Don't do anything if pools aren't enabled. 23407c478bd9Sstevel@tonic-gate */ 23417c478bd9Sstevel@tonic-gate if (pool_get_status(&status) != PO_SUCCESS || status != POOL_ENABLED) { 23427c478bd9Sstevel@tonic-gate zerror(gettext("WARNING: pools facility not active; " 23437c478bd9Sstevel@tonic-gate "zone will not be bound to pool '%s'."), poolname); 23447c478bd9Sstevel@tonic-gate return (Z_OK); 23457c478bd9Sstevel@tonic-gate } 23467c478bd9Sstevel@tonic-gate /* 23477c478bd9Sstevel@tonic-gate * Try to provide a sane error message if the requested pool doesn't 23487c478bd9Sstevel@tonic-gate * exist. It isn't clear that pools-related failures should 23497c478bd9Sstevel@tonic-gate * necessarily translate to a failure to verify the zone configuration, 23507c478bd9Sstevel@tonic-gate * hence they are not considered errors. 23517c478bd9Sstevel@tonic-gate */ 23527c478bd9Sstevel@tonic-gate if ((poolconf = pool_conf_alloc()) == NULL) { 23537c478bd9Sstevel@tonic-gate zerror(gettext("WARNING: pool_conf_alloc failed; " 23547c478bd9Sstevel@tonic-gate "using default pool")); 23557c478bd9Sstevel@tonic-gate return (Z_OK); 23567c478bd9Sstevel@tonic-gate } 23577c478bd9Sstevel@tonic-gate if (pool_conf_open(poolconf, pool_dynamic_location(), PO_RDONLY) != 23587c478bd9Sstevel@tonic-gate PO_SUCCESS) { 23597c478bd9Sstevel@tonic-gate zerror(gettext("WARNING: pool_conf_open failed; " 23607c478bd9Sstevel@tonic-gate "using default pool")); 23617c478bd9Sstevel@tonic-gate pool_conf_free(poolconf); 23627c478bd9Sstevel@tonic-gate return (Z_OK); 23637c478bd9Sstevel@tonic-gate } 23647c478bd9Sstevel@tonic-gate pool = pool_get_pool(poolconf, poolname); 23657c478bd9Sstevel@tonic-gate (void) pool_conf_close(poolconf); 23667c478bd9Sstevel@tonic-gate pool_conf_free(poolconf); 23677c478bd9Sstevel@tonic-gate if (pool == NULL) { 23687c478bd9Sstevel@tonic-gate zerror(gettext("WARNING: pool '%s' not found. " 23697c478bd9Sstevel@tonic-gate "using default pool"), poolname); 23707c478bd9Sstevel@tonic-gate } 23717c478bd9Sstevel@tonic-gate 23727c478bd9Sstevel@tonic-gate return (Z_OK); 23737c478bd9Sstevel@tonic-gate } 23747c478bd9Sstevel@tonic-gate 23757c478bd9Sstevel@tonic-gate static int 2376b5abaf04Sgjelinek verify_ipd(zone_dochandle_t handle) 2377b5abaf04Sgjelinek { 2378b5abaf04Sgjelinek int return_code = Z_OK; 2379b5abaf04Sgjelinek struct zone_fstab fstab; 2380b5abaf04Sgjelinek struct stat st; 2381b5abaf04Sgjelinek char specdir[MAXPATHLEN]; 2382b5abaf04Sgjelinek 2383b5abaf04Sgjelinek if (zonecfg_setipdent(handle) != Z_OK) { 23845ee84fbdSgjelinek /* 23855ee84fbdSgjelinek * TRANSLATION_NOTE 23865ee84fbdSgjelinek * inherit-pkg-dirs is a literal that should not be translated. 23875ee84fbdSgjelinek */ 23885ee84fbdSgjelinek (void) fprintf(stderr, gettext("could not verify " 2389b5abaf04Sgjelinek "inherit-pkg-dirs: unable to enumerate mounts\n")); 2390b5abaf04Sgjelinek return (Z_ERR); 2391b5abaf04Sgjelinek } 2392b5abaf04Sgjelinek while (zonecfg_getipdent(handle, &fstab) == Z_OK) { 2393b5abaf04Sgjelinek /* 2394b5abaf04Sgjelinek * Verify fs_dir exists. 2395b5abaf04Sgjelinek */ 2396b5abaf04Sgjelinek (void) snprintf(specdir, sizeof (specdir), "%s%s", 2397b5abaf04Sgjelinek zonecfg_get_root(), fstab.zone_fs_dir); 2398b5abaf04Sgjelinek if (stat(specdir, &st) != 0) { 23995ee84fbdSgjelinek /* 24005ee84fbdSgjelinek * TRANSLATION_NOTE 24015ee84fbdSgjelinek * inherit-pkg-dir is a literal that should not be 24025ee84fbdSgjelinek * translated. 24035ee84fbdSgjelinek */ 24045ee84fbdSgjelinek (void) fprintf(stderr, gettext("could not verify " 2405b5abaf04Sgjelinek "inherit-pkg-dir %s: %s\n"), 2406b5abaf04Sgjelinek fstab.zone_fs_dir, strerror(errno)); 2407b5abaf04Sgjelinek return_code = Z_ERR; 2408b5abaf04Sgjelinek } 2409b5abaf04Sgjelinek if (strcmp(st.st_fstype, MNTTYPE_NFS) == 0) { 24105ee84fbdSgjelinek /* 24115ee84fbdSgjelinek * TRANSLATION_NOTE 24125ee84fbdSgjelinek * inherit-pkg-dir and NFS are literals that should 24135ee84fbdSgjelinek * not be translated. 24145ee84fbdSgjelinek */ 2415b5abaf04Sgjelinek (void) fprintf(stderr, gettext("cannot verify " 24160b5de56dSgjelinek "inherit-pkg-dir %s: NFS mounted file system.\n" 24170b5de56dSgjelinek "\tA local file system must be used.\n"), 2418b5abaf04Sgjelinek fstab.zone_fs_dir); 2419b5abaf04Sgjelinek return_code = Z_ERR; 2420b5abaf04Sgjelinek } 2421b5abaf04Sgjelinek } 2422b5abaf04Sgjelinek (void) zonecfg_endipdent(handle); 2423b5abaf04Sgjelinek 2424b5abaf04Sgjelinek return (return_code); 2425b5abaf04Sgjelinek } 2426b5abaf04Sgjelinek 242720c8013fSlling /* 242820c8013fSlling * Verify that the special device/file system exists and is valid. 242920c8013fSlling */ 243020c8013fSlling static int 243120c8013fSlling verify_fs_special(struct zone_fstab *fstab) 243220c8013fSlling { 243320c8013fSlling struct stat st; 243420c8013fSlling 24356cc813faSgjelinek /* 24366cc813faSgjelinek * This validation is really intended for standard zone administration. 24376cc813faSgjelinek * If we are in a mini-root or some other upgrade situation where 24386cc813faSgjelinek * we are using the scratch zone, just by-pass this. 24396cc813faSgjelinek */ 24406cc813faSgjelinek if (zonecfg_in_alt_root()) 24416cc813faSgjelinek return (Z_OK); 24426cc813faSgjelinek 244320c8013fSlling if (strcmp(fstab->zone_fs_type, MNTTYPE_ZFS) == 0) 244420c8013fSlling return (verify_fs_zfs(fstab)); 244520c8013fSlling 244620c8013fSlling if (stat(fstab->zone_fs_special, &st) != 0) { 24475c358068Slling (void) fprintf(stderr, gettext("could not verify fs " 244820c8013fSlling "%s: could not access %s: %s\n"), fstab->zone_fs_dir, 244920c8013fSlling fstab->zone_fs_special, strerror(errno)); 245020c8013fSlling return (Z_ERR); 245120c8013fSlling } 245220c8013fSlling 245320c8013fSlling if (strcmp(st.st_fstype, MNTTYPE_NFS) == 0) { 245420c8013fSlling /* 245520c8013fSlling * TRANSLATION_NOTE 245620c8013fSlling * fs and NFS are literals that should 245720c8013fSlling * not be translated. 245820c8013fSlling */ 245920c8013fSlling (void) fprintf(stderr, gettext("cannot verify " 24600b5de56dSgjelinek "fs %s: NFS mounted file system.\n" 24610b5de56dSgjelinek "\tA local file system must be used.\n"), 246220c8013fSlling fstab->zone_fs_special); 246320c8013fSlling return (Z_ERR); 246420c8013fSlling } 246520c8013fSlling 246620c8013fSlling return (Z_OK); 246720c8013fSlling } 246820c8013fSlling 2469b5abaf04Sgjelinek static int 24707c478bd9Sstevel@tonic-gate verify_filesystems(zone_dochandle_t handle) 24717c478bd9Sstevel@tonic-gate { 24727c478bd9Sstevel@tonic-gate int return_code = Z_OK; 24737c478bd9Sstevel@tonic-gate struct zone_fstab fstab; 24747c478bd9Sstevel@tonic-gate char cmdbuf[MAXPATHLEN]; 24757c478bd9Sstevel@tonic-gate struct stat st; 24767c478bd9Sstevel@tonic-gate 24777c478bd9Sstevel@tonic-gate /* 24787c478bd9Sstevel@tonic-gate * No need to verify inherit-pkg-dir fs types, as their type is 24797c478bd9Sstevel@tonic-gate * implicitly lofs, which is known. Therefore, the types are only 24807c478bd9Sstevel@tonic-gate * verified for regular file systems below. 24817c478bd9Sstevel@tonic-gate * 24827c478bd9Sstevel@tonic-gate * Since the actual mount point is not known until the dependent mounts 24837c478bd9Sstevel@tonic-gate * are performed, we don't attempt any path validation here: that will 24847c478bd9Sstevel@tonic-gate * happen later when zoneadmd actually does the mounts. 24857c478bd9Sstevel@tonic-gate */ 24867c478bd9Sstevel@tonic-gate if (zonecfg_setfsent(handle) != Z_OK) { 24870b5de56dSgjelinek (void) fprintf(stderr, gettext("could not verify file systems: " 24887c478bd9Sstevel@tonic-gate "unable to enumerate mounts\n")); 24897c478bd9Sstevel@tonic-gate return (Z_ERR); 24907c478bd9Sstevel@tonic-gate } 24917c478bd9Sstevel@tonic-gate while (zonecfg_getfsent(handle, &fstab) == Z_OK) { 24927c478bd9Sstevel@tonic-gate if (!zonecfg_valid_fs_type(fstab.zone_fs_type)) { 24937c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("cannot verify fs %s: " 24947c478bd9Sstevel@tonic-gate "type %s is not allowed.\n"), fstab.zone_fs_dir, 24957c478bd9Sstevel@tonic-gate fstab.zone_fs_type); 24967c478bd9Sstevel@tonic-gate return_code = Z_ERR; 24977c478bd9Sstevel@tonic-gate goto next_fs; 24987c478bd9Sstevel@tonic-gate } 24997c478bd9Sstevel@tonic-gate /* 25007c478bd9Sstevel@tonic-gate * Verify /usr/lib/fs/<fstype>/mount exists. 25017c478bd9Sstevel@tonic-gate */ 25027c478bd9Sstevel@tonic-gate if (snprintf(cmdbuf, sizeof (cmdbuf), "/usr/lib/fs/%s/mount", 25037c478bd9Sstevel@tonic-gate fstab.zone_fs_type) > sizeof (cmdbuf)) { 25047c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("cannot verify fs %s: " 25057c478bd9Sstevel@tonic-gate "type %s is too long.\n"), fstab.zone_fs_dir, 25067c478bd9Sstevel@tonic-gate fstab.zone_fs_type); 25077c478bd9Sstevel@tonic-gate return_code = Z_ERR; 25087c478bd9Sstevel@tonic-gate goto next_fs; 25097c478bd9Sstevel@tonic-gate } 25107c478bd9Sstevel@tonic-gate if (stat(cmdbuf, &st) != 0) { 25115ee84fbdSgjelinek (void) fprintf(stderr, gettext("could not verify fs " 25125ee84fbdSgjelinek "%s: could not access %s: %s\n"), fstab.zone_fs_dir, 25137c478bd9Sstevel@tonic-gate cmdbuf, strerror(errno)); 25147c478bd9Sstevel@tonic-gate return_code = Z_ERR; 25157c478bd9Sstevel@tonic-gate goto next_fs; 25167c478bd9Sstevel@tonic-gate } 25177c478bd9Sstevel@tonic-gate if (!S_ISREG(st.st_mode)) { 25185ee84fbdSgjelinek (void) fprintf(stderr, gettext("could not verify fs " 25195ee84fbdSgjelinek "%s: %s is not a regular file\n"), 25205ee84fbdSgjelinek fstab.zone_fs_dir, cmdbuf); 25217c478bd9Sstevel@tonic-gate return_code = Z_ERR; 25227c478bd9Sstevel@tonic-gate goto next_fs; 25237c478bd9Sstevel@tonic-gate } 25247c478bd9Sstevel@tonic-gate /* 25257c478bd9Sstevel@tonic-gate * Verify /usr/lib/fs/<fstype>/fsck exists iff zone_fs_raw is 25267c478bd9Sstevel@tonic-gate * set. 25277c478bd9Sstevel@tonic-gate */ 25287c478bd9Sstevel@tonic-gate if (snprintf(cmdbuf, sizeof (cmdbuf), "/usr/lib/fs/%s/fsck", 25297c478bd9Sstevel@tonic-gate fstab.zone_fs_type) > sizeof (cmdbuf)) { 25307c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("cannot verify fs %s: " 25317c478bd9Sstevel@tonic-gate "type %s is too long.\n"), fstab.zone_fs_dir, 25327c478bd9Sstevel@tonic-gate fstab.zone_fs_type); 25337c478bd9Sstevel@tonic-gate return_code = Z_ERR; 25347c478bd9Sstevel@tonic-gate goto next_fs; 25357c478bd9Sstevel@tonic-gate } 25367c478bd9Sstevel@tonic-gate if (fstab.zone_fs_raw[0] == '\0' && stat(cmdbuf, &st) == 0) { 25375ee84fbdSgjelinek (void) fprintf(stderr, gettext("could not verify fs " 25385ee84fbdSgjelinek "%s: must specify 'raw' device for %s " 25390b5de56dSgjelinek "file systems\n"), 25407c478bd9Sstevel@tonic-gate fstab.zone_fs_dir, fstab.zone_fs_type); 25417c478bd9Sstevel@tonic-gate return_code = Z_ERR; 25427c478bd9Sstevel@tonic-gate goto next_fs; 25437c478bd9Sstevel@tonic-gate } 25447c478bd9Sstevel@tonic-gate if (fstab.zone_fs_raw[0] != '\0' && 25457c478bd9Sstevel@tonic-gate (stat(cmdbuf, &st) != 0 || !S_ISREG(st.st_mode))) { 25467c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("cannot verify fs %s: " 25477c478bd9Sstevel@tonic-gate "'raw' device specified but " 25487c478bd9Sstevel@tonic-gate "no fsck executable exists for %s\n"), 25497c478bd9Sstevel@tonic-gate fstab.zone_fs_dir, fstab.zone_fs_type); 25507c478bd9Sstevel@tonic-gate return_code = Z_ERR; 25517c478bd9Sstevel@tonic-gate goto next_fs; 25527c478bd9Sstevel@tonic-gate } 255320c8013fSlling 255420c8013fSlling /* Verify fs_special. */ 255520c8013fSlling if ((return_code = verify_fs_special(&fstab)) != Z_OK) 2556b5abaf04Sgjelinek goto next_fs; 255720c8013fSlling 255820c8013fSlling /* Verify fs_raw. */ 2559b5abaf04Sgjelinek if (fstab.zone_fs_raw[0] != '\0' && 2560b5abaf04Sgjelinek stat(fstab.zone_fs_raw, &st) != 0) { 25615ee84fbdSgjelinek /* 25625ee84fbdSgjelinek * TRANSLATION_NOTE 25635ee84fbdSgjelinek * fs is a literal that should not be translated. 25645ee84fbdSgjelinek */ 25655ee84fbdSgjelinek (void) fprintf(stderr, gettext("could not verify fs " 25665ee84fbdSgjelinek "%s: could not access %s: %s\n"), fstab.zone_fs_dir, 2567b5abaf04Sgjelinek fstab.zone_fs_raw, strerror(errno)); 2568b5abaf04Sgjelinek return_code = Z_ERR; 2569b5abaf04Sgjelinek goto next_fs; 2570b5abaf04Sgjelinek } 25717c478bd9Sstevel@tonic-gate next_fs: 25727c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(fstab.zone_fs_options); 25737c478bd9Sstevel@tonic-gate } 25747c478bd9Sstevel@tonic-gate (void) zonecfg_endfsent(handle); 25757c478bd9Sstevel@tonic-gate 25767c478bd9Sstevel@tonic-gate return (return_code); 25777c478bd9Sstevel@tonic-gate } 25787c478bd9Sstevel@tonic-gate 25797c478bd9Sstevel@tonic-gate static int 2580ffbafc53Scomay verify_limitpriv(zone_dochandle_t handle) 2581ffbafc53Scomay { 2582ffbafc53Scomay char *privname = NULL; 2583ffbafc53Scomay int err; 2584ffbafc53Scomay priv_set_t *privs; 2585ffbafc53Scomay 2586ffbafc53Scomay if ((privs = priv_allocset()) == NULL) { 2587ffbafc53Scomay zperror(gettext("failed to allocate privilege set"), B_FALSE); 2588ffbafc53Scomay return (Z_NOMEM); 2589ffbafc53Scomay } 2590ffbafc53Scomay err = zonecfg_get_privset(handle, privs, &privname); 2591ffbafc53Scomay switch (err) { 2592ffbafc53Scomay case Z_OK: 2593ffbafc53Scomay break; 2594ffbafc53Scomay case Z_PRIV_PROHIBITED: 2595ffbafc53Scomay (void) fprintf(stderr, gettext("privilege \"%s\" is not " 2596ffbafc53Scomay "permitted within the zone's privilege set\n"), privname); 2597ffbafc53Scomay break; 2598ffbafc53Scomay case Z_PRIV_REQUIRED: 2599ffbafc53Scomay (void) fprintf(stderr, gettext("required privilege \"%s\" is " 2600ffbafc53Scomay "missing from the zone's privilege set\n"), privname); 2601ffbafc53Scomay break; 2602ffbafc53Scomay case Z_PRIV_UNKNOWN: 2603ffbafc53Scomay (void) fprintf(stderr, gettext("unknown privilege \"%s\" " 2604ffbafc53Scomay "specified in the zone's privilege set\n"), privname); 2605ffbafc53Scomay break; 2606ffbafc53Scomay default: 2607ffbafc53Scomay zperror( 2608ffbafc53Scomay gettext("failed to determine the zone's privilege set"), 2609ffbafc53Scomay B_TRUE); 2610ffbafc53Scomay break; 2611ffbafc53Scomay } 2612ffbafc53Scomay free(privname); 2613ffbafc53Scomay priv_freeset(privs); 2614ffbafc53Scomay return (err); 2615ffbafc53Scomay } 2616ffbafc53Scomay 26171390a385Sgjelinek static void 26181390a385Sgjelinek free_local_netifs(int if_cnt, struct net_if **if_list) 26191390a385Sgjelinek { 26201390a385Sgjelinek int i; 26211390a385Sgjelinek 26221390a385Sgjelinek for (i = 0; i < if_cnt; i++) { 26231390a385Sgjelinek free(if_list[i]->name); 26241390a385Sgjelinek free(if_list[i]); 26251390a385Sgjelinek } 26261390a385Sgjelinek free(if_list); 26271390a385Sgjelinek } 26281390a385Sgjelinek 26291390a385Sgjelinek /* 26301390a385Sgjelinek * Get a list of the network interfaces, along with their address families, 26311390a385Sgjelinek * that are plumbed in the global zone. See if_tcp(7p) for a description 26321390a385Sgjelinek * of the ioctls used here. 26331390a385Sgjelinek */ 26341390a385Sgjelinek static int 26351390a385Sgjelinek get_local_netifs(int *if_cnt, struct net_if ***if_list) 26361390a385Sgjelinek { 26371390a385Sgjelinek int s; 26381390a385Sgjelinek int i; 26391390a385Sgjelinek int res = Z_OK; 26401390a385Sgjelinek int space_needed; 26411390a385Sgjelinek int cnt = 0; 26421390a385Sgjelinek struct lifnum if_num; 26431390a385Sgjelinek struct lifconf if_conf; 26441390a385Sgjelinek struct lifreq *if_reqp; 26451390a385Sgjelinek char *if_buf; 26461390a385Sgjelinek struct net_if **local_ifs = NULL; 26471390a385Sgjelinek 26481390a385Sgjelinek *if_cnt = 0; 26491390a385Sgjelinek *if_list = NULL; 26501390a385Sgjelinek 26511390a385Sgjelinek if ((s = socket(SOCKET_AF(AF_INET), SOCK_DGRAM, 0)) < 0) 26521390a385Sgjelinek return (Z_ERR); 26531390a385Sgjelinek 26541390a385Sgjelinek /* 26551390a385Sgjelinek * Come back here in the unlikely event that the number of interfaces 26561390a385Sgjelinek * increases between the time we get the count and the time we do the 26571390a385Sgjelinek * SIOCGLIFCONF ioctl. 26581390a385Sgjelinek */ 26591390a385Sgjelinek retry: 26601390a385Sgjelinek /* Get the number of interfaces. */ 26611390a385Sgjelinek if_num.lifn_family = AF_UNSPEC; 26621390a385Sgjelinek if_num.lifn_flags = LIFC_NOXMIT; 26631390a385Sgjelinek if (ioctl(s, SIOCGLIFNUM, &if_num) < 0) { 26641390a385Sgjelinek (void) close(s); 26651390a385Sgjelinek return (Z_ERR); 26661390a385Sgjelinek } 26671390a385Sgjelinek 26681390a385Sgjelinek /* Get the interface configuration list. */ 26691390a385Sgjelinek space_needed = if_num.lifn_count * sizeof (struct lifreq); 26701390a385Sgjelinek if ((if_buf = malloc(space_needed)) == NULL) { 26711390a385Sgjelinek (void) close(s); 26721390a385Sgjelinek return (Z_ERR); 26731390a385Sgjelinek } 26741390a385Sgjelinek if_conf.lifc_family = AF_UNSPEC; 26751390a385Sgjelinek if_conf.lifc_flags = LIFC_NOXMIT; 26761390a385Sgjelinek if_conf.lifc_len = space_needed; 26771390a385Sgjelinek if_conf.lifc_buf = if_buf; 26781390a385Sgjelinek if (ioctl(s, SIOCGLIFCONF, &if_conf) < 0) { 26791390a385Sgjelinek free(if_buf); 26801390a385Sgjelinek /* 26811390a385Sgjelinek * SIOCGLIFCONF returns EINVAL if the buffer we passed in is 26821390a385Sgjelinek * too small. In this case go back and get the new if cnt. 26831390a385Sgjelinek */ 26841390a385Sgjelinek if (errno == EINVAL) 26851390a385Sgjelinek goto retry; 26861390a385Sgjelinek 26871390a385Sgjelinek (void) close(s); 26881390a385Sgjelinek return (Z_ERR); 26891390a385Sgjelinek } 26901390a385Sgjelinek (void) close(s); 26911390a385Sgjelinek 26921390a385Sgjelinek /* Get the name and address family for each interface. */ 26931390a385Sgjelinek if_reqp = if_conf.lifc_req; 26941390a385Sgjelinek for (i = 0; i < (if_conf.lifc_len / sizeof (struct lifreq)); i++) { 26951390a385Sgjelinek struct net_if **p; 26961390a385Sgjelinek struct lifreq req; 26971390a385Sgjelinek 26981390a385Sgjelinek if (strcmp(LOOPBACK_IF, if_reqp->lifr_name) == 0) { 26991390a385Sgjelinek if_reqp++; 27001390a385Sgjelinek continue; 27011390a385Sgjelinek } 27021390a385Sgjelinek 27031390a385Sgjelinek if ((s = socket(SOCKET_AF(if_reqp->lifr_addr.ss_family), 27041390a385Sgjelinek SOCK_DGRAM, 0)) == -1) { 27051390a385Sgjelinek res = Z_ERR; 27061390a385Sgjelinek break; 27071390a385Sgjelinek } 27081390a385Sgjelinek 27091390a385Sgjelinek (void) strncpy(req.lifr_name, if_reqp->lifr_name, 27101390a385Sgjelinek sizeof (req.lifr_name)); 27111390a385Sgjelinek if (ioctl(s, SIOCGLIFADDR, &req) < 0) { 27121390a385Sgjelinek (void) close(s); 27131390a385Sgjelinek if_reqp++; 27141390a385Sgjelinek continue; 27151390a385Sgjelinek } 27161390a385Sgjelinek 27171390a385Sgjelinek if ((p = (struct net_if **)realloc(local_ifs, 27181390a385Sgjelinek sizeof (struct net_if *) * (cnt + 1))) == NULL) { 27191390a385Sgjelinek res = Z_ERR; 27201390a385Sgjelinek break; 27211390a385Sgjelinek } 27221390a385Sgjelinek local_ifs = p; 27231390a385Sgjelinek 27241390a385Sgjelinek if ((local_ifs[cnt] = malloc(sizeof (struct net_if))) == NULL) { 27251390a385Sgjelinek res = Z_ERR; 27261390a385Sgjelinek break; 27271390a385Sgjelinek } 27281390a385Sgjelinek 27291390a385Sgjelinek if ((local_ifs[cnt]->name = strdup(if_reqp->lifr_name)) 27301390a385Sgjelinek == NULL) { 27311390a385Sgjelinek free(local_ifs[cnt]); 27321390a385Sgjelinek res = Z_ERR; 27331390a385Sgjelinek break; 27341390a385Sgjelinek } 27351390a385Sgjelinek local_ifs[cnt]->af = req.lifr_addr.ss_family; 27361390a385Sgjelinek cnt++; 27371390a385Sgjelinek 27381390a385Sgjelinek (void) close(s); 27391390a385Sgjelinek if_reqp++; 27401390a385Sgjelinek } 27411390a385Sgjelinek 27421390a385Sgjelinek free(if_buf); 27431390a385Sgjelinek 27441390a385Sgjelinek if (res != Z_OK) { 27451390a385Sgjelinek free_local_netifs(cnt, local_ifs); 27461390a385Sgjelinek } else { 27471390a385Sgjelinek *if_cnt = cnt; 27481390a385Sgjelinek *if_list = local_ifs; 27491390a385Sgjelinek } 27501390a385Sgjelinek 27511390a385Sgjelinek return (res); 27521390a385Sgjelinek } 27531390a385Sgjelinek 27541390a385Sgjelinek static char * 27551390a385Sgjelinek af2str(int af) 27561390a385Sgjelinek { 27571390a385Sgjelinek switch (af) { 27581390a385Sgjelinek case AF_INET: 27591390a385Sgjelinek return ("IPv4"); 27601390a385Sgjelinek case AF_INET6: 27611390a385Sgjelinek return ("IPv6"); 27621390a385Sgjelinek default: 27631390a385Sgjelinek return ("Unknown"); 27641390a385Sgjelinek } 27651390a385Sgjelinek } 27661390a385Sgjelinek 27671390a385Sgjelinek /* 27681390a385Sgjelinek * Cross check the network interface name and address family with the 27691390a385Sgjelinek * interfaces that are set up in the global zone so that we can print the 27701390a385Sgjelinek * appropriate error message. 27711390a385Sgjelinek */ 27721390a385Sgjelinek static void 27731390a385Sgjelinek print_net_err(char *phys, char *addr, int af, char *msg) 27741390a385Sgjelinek { 27751390a385Sgjelinek int i; 27761390a385Sgjelinek int local_if_cnt = 0; 27771390a385Sgjelinek struct net_if **local_ifs = NULL; 27781390a385Sgjelinek boolean_t found_if = B_FALSE; 27791390a385Sgjelinek boolean_t found_af = B_FALSE; 27801390a385Sgjelinek 27811390a385Sgjelinek if (get_local_netifs(&local_if_cnt, &local_ifs) != Z_OK) { 27821390a385Sgjelinek (void) fprintf(stderr, 27831390a385Sgjelinek gettext("could not verify %s %s=%s %s=%s\n\t%s\n"), 27841390a385Sgjelinek "net", "address", addr, "physical", phys, msg); 27851390a385Sgjelinek return; 27861390a385Sgjelinek } 27871390a385Sgjelinek 27881390a385Sgjelinek for (i = 0; i < local_if_cnt; i++) { 27891390a385Sgjelinek if (strcmp(phys, local_ifs[i]->name) == 0) { 27901390a385Sgjelinek found_if = B_TRUE; 27911390a385Sgjelinek if (af == local_ifs[i]->af) { 27921390a385Sgjelinek found_af = B_TRUE; 27931390a385Sgjelinek break; 27941390a385Sgjelinek } 27951390a385Sgjelinek } 27961390a385Sgjelinek } 27971390a385Sgjelinek 27981390a385Sgjelinek free_local_netifs(local_if_cnt, local_ifs); 27991390a385Sgjelinek 28001390a385Sgjelinek if (!found_if) { 28011390a385Sgjelinek (void) fprintf(stderr, 28021390a385Sgjelinek gettext("could not verify %s %s=%s\n\t" 28031390a385Sgjelinek "network interface %s is not plumbed in the global zone\n"), 28041390a385Sgjelinek "net", "physical", phys, phys); 28051390a385Sgjelinek return; 28061390a385Sgjelinek } 28071390a385Sgjelinek 28081390a385Sgjelinek /* 28091390a385Sgjelinek * Print this error if we were unable to find the address family 28101390a385Sgjelinek * for this interface. If the af variable is not initialized to 28111390a385Sgjelinek * to something meaningful by the caller (not AF_UNSPEC) then we 28121390a385Sgjelinek * also skip this message since it wouldn't be informative. 28131390a385Sgjelinek */ 28141390a385Sgjelinek if (!found_af && af != AF_UNSPEC) { 28151390a385Sgjelinek (void) fprintf(stderr, 28161390a385Sgjelinek gettext("could not verify %s %s=%s %s=%s\n\tthe %s address " 2817f4b3ec61Sdh155122 "family is not configured on this network interface in " 2818f4b3ec61Sdh155122 "the\n\tglobal zone\n"), 28191390a385Sgjelinek "net", "address", addr, "physical", phys, af2str(af)); 28201390a385Sgjelinek return; 28211390a385Sgjelinek } 28221390a385Sgjelinek 28231390a385Sgjelinek (void) fprintf(stderr, 28241390a385Sgjelinek gettext("could not verify %s %s=%s %s=%s\n\t%s\n"), 28251390a385Sgjelinek "net", "address", addr, "physical", phys, msg); 28261390a385Sgjelinek } 28271390a385Sgjelinek 2828ffbafc53Scomay static int 2829ce28b40eSzt129084 verify_handle(int cmd_num, zone_dochandle_t handle, char *argv[]) 28307c478bd9Sstevel@tonic-gate { 28317c478bd9Sstevel@tonic-gate struct zone_nwiftab nwiftab; 28327c478bd9Sstevel@tonic-gate int return_code = Z_OK; 28337c478bd9Sstevel@tonic-gate int err; 2834108322fbScarlsonj boolean_t in_alt_root; 2835f4b3ec61Sdh155122 zone_iptype_t iptype; 2836f4b3ec61Sdh155122 int fd; 28377c478bd9Sstevel@tonic-gate 2838108322fbScarlsonj in_alt_root = zonecfg_in_alt_root(); 2839108322fbScarlsonj if (in_alt_root) 2840108322fbScarlsonj goto no_net; 2841108322fbScarlsonj 2842f4b3ec61Sdh155122 if ((err = zonecfg_get_iptype(handle, &iptype)) != Z_OK) { 2843f4b3ec61Sdh155122 errno = err; 2844f4b3ec61Sdh155122 zperror(cmd_to_str(cmd_num), B_TRUE); 2845f4b3ec61Sdh155122 zonecfg_fini_handle(handle); 2846f4b3ec61Sdh155122 return (Z_ERR); 2847f4b3ec61Sdh155122 } 28487c478bd9Sstevel@tonic-gate if ((err = zonecfg_setnwifent(handle)) != Z_OK) { 28497c478bd9Sstevel@tonic-gate errno = err; 28507c478bd9Sstevel@tonic-gate zperror(cmd_to_str(cmd_num), B_TRUE); 28517c478bd9Sstevel@tonic-gate zonecfg_fini_handle(handle); 28527c478bd9Sstevel@tonic-gate return (Z_ERR); 28537c478bd9Sstevel@tonic-gate } 28547c478bd9Sstevel@tonic-gate while (zonecfg_getnwifent(handle, &nwiftab) == Z_OK) { 28557c478bd9Sstevel@tonic-gate struct lifreq lifr; 28561390a385Sgjelinek sa_family_t af = AF_UNSPEC; 2857f4b3ec61Sdh155122 char dl_owner_zname[ZONENAME_MAX]; 2858f4b3ec61Sdh155122 zoneid_t dl_owner_zid; 2859f4b3ec61Sdh155122 zoneid_t target_zid; 2860f4b3ec61Sdh155122 int res; 28617c478bd9Sstevel@tonic-gate 28627c478bd9Sstevel@tonic-gate /* skip any loopback interfaces */ 28637c478bd9Sstevel@tonic-gate if (strcmp(nwiftab.zone_nwif_physical, "lo0") == 0) 28647c478bd9Sstevel@tonic-gate continue; 2865f4b3ec61Sdh155122 switch (iptype) { 2866f4b3ec61Sdh155122 case ZS_SHARED: 2867f4b3ec61Sdh155122 if ((res = zonecfg_valid_net_address( 2868f4b3ec61Sdh155122 nwiftab.zone_nwif_address, &lifr)) != Z_OK) { 28691390a385Sgjelinek print_net_err(nwiftab.zone_nwif_physical, 28701390a385Sgjelinek nwiftab.zone_nwif_address, af, 28711390a385Sgjelinek zonecfg_strerror(res)); 28727c478bd9Sstevel@tonic-gate return_code = Z_ERR; 28737c478bd9Sstevel@tonic-gate continue; 28747c478bd9Sstevel@tonic-gate } 28757c478bd9Sstevel@tonic-gate af = lifr.lifr_addr.ss_family; 2876f4b3ec61Sdh155122 if (!zonecfg_ifname_exists(af, 2877f4b3ec61Sdh155122 nwiftab.zone_nwif_physical)) { 287822321485Svp157776 /* 2879f4b3ec61Sdh155122 * The interface failed to come up. We continue 2880f4b3ec61Sdh155122 * on anyway for the sake of consistency: a 2881f4b3ec61Sdh155122 * zone is not shut down if the interface fails 2882f4b3ec61Sdh155122 * any time after boot, nor does the global zone 2883f4b3ec61Sdh155122 * fail to boot if an interface fails. 288422321485Svp157776 */ 288522321485Svp157776 (void) fprintf(stderr, 2886f4b3ec61Sdh155122 gettext("WARNING: skipping network " 2887f4b3ec61Sdh155122 "interface '%s' which may not be " 2888f4b3ec61Sdh155122 "present/plumbed in the global " 2889f4b3ec61Sdh155122 "zone.\n"), 289022321485Svp157776 nwiftab.zone_nwif_physical); 28917c478bd9Sstevel@tonic-gate } 2892f4b3ec61Sdh155122 break; 2893f4b3ec61Sdh155122 case ZS_EXCLUSIVE: 2894f4b3ec61Sdh155122 /* Warning if it exists for either IPv4 or IPv6 */ 2895f4b3ec61Sdh155122 2896f4b3ec61Sdh155122 if (zonecfg_ifname_exists(AF_INET, 2897f4b3ec61Sdh155122 nwiftab.zone_nwif_physical) || 2898f4b3ec61Sdh155122 zonecfg_ifname_exists(AF_INET6, 2899f4b3ec61Sdh155122 nwiftab.zone_nwif_physical)) { 2900f4b3ec61Sdh155122 (void) fprintf(stderr, 2901f4b3ec61Sdh155122 gettext("WARNING: skipping network " 2902f4b3ec61Sdh155122 "interface '%s' which is used in the " 2903f4b3ec61Sdh155122 "global zone.\n"), 2904f4b3ec61Sdh155122 nwiftab.zone_nwif_physical); 2905f4b3ec61Sdh155122 break; 2906f4b3ec61Sdh155122 } 2907f4b3ec61Sdh155122 /* 2908f4b3ec61Sdh155122 * Verify that the physical interface can 2909f4b3ec61Sdh155122 * be opened 2910f4b3ec61Sdh155122 */ 2911f4b3ec61Sdh155122 fd = ifname_open(nwiftab.zone_nwif_physical); 2912f4b3ec61Sdh155122 if (fd == -1) { 2913f4b3ec61Sdh155122 (void) fprintf(stderr, 2914f4b3ec61Sdh155122 gettext("WARNING: skipping network " 2915f4b3ec61Sdh155122 "interface '%s' which cannot be opened.\n"), 2916f4b3ec61Sdh155122 nwiftab.zone_nwif_physical); 2917f4b3ec61Sdh155122 break; 2918f4b3ec61Sdh155122 } else { 2919f4b3ec61Sdh155122 (void) close(fd); 2920f4b3ec61Sdh155122 } 2921f4b3ec61Sdh155122 /* 2922f4b3ec61Sdh155122 * Verify whether the physical interface is already 2923f4b3ec61Sdh155122 * used by a zone. 2924f4b3ec61Sdh155122 */ 2925f4b3ec61Sdh155122 dl_owner_zid = ALL_ZONES; 2926f4b3ec61Sdh155122 if (zone_check_datalink(&dl_owner_zid, 2927f4b3ec61Sdh155122 nwiftab.zone_nwif_physical) != 0) 2928f4b3ec61Sdh155122 break; 2929f4b3ec61Sdh155122 2930f4b3ec61Sdh155122 /* 2931f4b3ec61Sdh155122 * If the zone being verified is 2932f4b3ec61Sdh155122 * running and owns the interface 2933f4b3ec61Sdh155122 */ 2934f4b3ec61Sdh155122 target_zid = getzoneidbyname(target_zone); 2935f4b3ec61Sdh155122 if (target_zid == dl_owner_zid) 2936f4b3ec61Sdh155122 break; 2937f4b3ec61Sdh155122 2938f4b3ec61Sdh155122 /* Zone id match failed, use name to check */ 2939f4b3ec61Sdh155122 if (getzonenamebyid(dl_owner_zid, dl_owner_zname, 2940f4b3ec61Sdh155122 ZONENAME_MAX) < 0) { 2941f4b3ec61Sdh155122 /* No name, show ID instead */ 2942f4b3ec61Sdh155122 (void) snprintf(dl_owner_zname, ZONENAME_MAX, 2943f4b3ec61Sdh155122 "<%d>", dl_owner_zid); 2944f4b3ec61Sdh155122 } else if (strcmp(dl_owner_zname, target_zone) == 0) 2945f4b3ec61Sdh155122 break; 2946f4b3ec61Sdh155122 2947f4b3ec61Sdh155122 /* 2948f4b3ec61Sdh155122 * Note here we only report a warning that 2949f4b3ec61Sdh155122 * the interface is already in use by another 2950f4b3ec61Sdh155122 * running zone, and the verify process just 2951f4b3ec61Sdh155122 * goes on, if the interface is still in use 2952f4b3ec61Sdh155122 * when this zone really boots up, zoneadmd 2953f4b3ec61Sdh155122 * will find it. If the name of the zone which 2954f4b3ec61Sdh155122 * owns this interface cannot be determined, 2955f4b3ec61Sdh155122 * then it is not possible to determine if there 2956f4b3ec61Sdh155122 * is a conflict so just report it as a warning. 2957f4b3ec61Sdh155122 */ 2958f4b3ec61Sdh155122 (void) fprintf(stderr, 2959f4b3ec61Sdh155122 gettext("WARNING: skipping network interface " 2960f4b3ec61Sdh155122 "'%s' which is used by the non-global zone " 2961f4b3ec61Sdh155122 "'%s'.\n"), nwiftab.zone_nwif_physical, 2962f4b3ec61Sdh155122 dl_owner_zname); 2963f4b3ec61Sdh155122 break; 2964f4b3ec61Sdh155122 } 29657c478bd9Sstevel@tonic-gate } 29667c478bd9Sstevel@tonic-gate (void) zonecfg_endnwifent(handle); 2967108322fbScarlsonj no_net: 29687c478bd9Sstevel@tonic-gate 2969e7f3c547Sgjelinek /* verify that lofs has not been excluded from the kernel */ 29708cd327d5Sgjelinek if (!(cmd_num == CMD_DETACH || cmd_num == CMD_ATTACH || 29718cd327d5Sgjelinek cmd_num == CMD_MOVE || cmd_num == CMD_CLONE) && 29728cd327d5Sgjelinek modctl(MODLOAD, 1, "fs/lofs", NULL) != 0) { 2973e7f3c547Sgjelinek if (errno == ENXIO) 2974e7f3c547Sgjelinek (void) fprintf(stderr, gettext("could not verify " 2975e7f3c547Sgjelinek "lofs(7FS): possibly excluded in /etc/system\n")); 2976e7f3c547Sgjelinek else 2977e7f3c547Sgjelinek (void) fprintf(stderr, gettext("could not verify " 2978e7f3c547Sgjelinek "lofs(7FS): %s\n"), strerror(errno)); 2979e7f3c547Sgjelinek return_code = Z_ERR; 2980e7f3c547Sgjelinek } 2981e7f3c547Sgjelinek 29827c478bd9Sstevel@tonic-gate if (verify_filesystems(handle) != Z_OK) 29837c478bd9Sstevel@tonic-gate return_code = Z_ERR; 2984b5abaf04Sgjelinek if (verify_ipd(handle) != Z_OK) 2985b5abaf04Sgjelinek return_code = Z_ERR; 2986108322fbScarlsonj if (!in_alt_root && verify_rctls(handle) != Z_OK) 29877c478bd9Sstevel@tonic-gate return_code = Z_ERR; 2988108322fbScarlsonj if (!in_alt_root && verify_pool(handle) != Z_OK) 29897c478bd9Sstevel@tonic-gate return_code = Z_ERR; 2990ce28b40eSzt129084 if (!in_alt_root && verify_brand(handle, cmd_num, argv) != Z_OK) 29919acbbeafSnn35248 return_code = Z_ERR; 2992fa9e4066Sahrens if (!in_alt_root && verify_datasets(handle) != Z_OK) 2993fa9e4066Sahrens return_code = Z_ERR; 2994ffbafc53Scomay 2995ffbafc53Scomay /* 2996ffbafc53Scomay * As the "mount" command is used for patching/upgrading of zones 2997ffbafc53Scomay * or other maintenance processes, the zone's privilege set is not 2998ffbafc53Scomay * checked in this case. Instead, the default, safe set of 2999ffbafc53Scomay * privileges will be used when this zone is created in the 3000ffbafc53Scomay * kernel. 3001ffbafc53Scomay */ 3002ffbafc53Scomay if (!in_alt_root && cmd_num != CMD_MOUNT && 3003ffbafc53Scomay verify_limitpriv(handle) != Z_OK) 3004ffbafc53Scomay return_code = Z_ERR; 30058cd327d5Sgjelinek 30068cd327d5Sgjelinek return (return_code); 30078cd327d5Sgjelinek } 30088cd327d5Sgjelinek 30098cd327d5Sgjelinek static int 3010ce28b40eSzt129084 verify_details(int cmd_num, char *argv[]) 30118cd327d5Sgjelinek { 30128cd327d5Sgjelinek zone_dochandle_t handle; 30138cd327d5Sgjelinek char zonepath[MAXPATHLEN], checkpath[MAXPATHLEN]; 30148cd327d5Sgjelinek int return_code = Z_OK; 30158cd327d5Sgjelinek int err; 30168cd327d5Sgjelinek 30178cd327d5Sgjelinek if ((handle = zonecfg_init_handle()) == NULL) { 30188cd327d5Sgjelinek zperror(cmd_to_str(cmd_num), B_TRUE); 30198cd327d5Sgjelinek return (Z_ERR); 30208cd327d5Sgjelinek } 30218cd327d5Sgjelinek if ((err = zonecfg_get_handle(target_zone, handle)) != Z_OK) { 30228cd327d5Sgjelinek errno = err; 30238cd327d5Sgjelinek zperror(cmd_to_str(cmd_num), B_TRUE); 30248cd327d5Sgjelinek zonecfg_fini_handle(handle); 30258cd327d5Sgjelinek return (Z_ERR); 30268cd327d5Sgjelinek } 30278cd327d5Sgjelinek if ((err = zonecfg_get_zonepath(handle, zonepath, sizeof (zonepath))) != 30288cd327d5Sgjelinek Z_OK) { 30298cd327d5Sgjelinek errno = err; 30308cd327d5Sgjelinek zperror(cmd_to_str(cmd_num), B_TRUE); 30318cd327d5Sgjelinek zonecfg_fini_handle(handle); 30328cd327d5Sgjelinek return (Z_ERR); 30338cd327d5Sgjelinek } 30348cd327d5Sgjelinek /* 30358cd327d5Sgjelinek * zonecfg_get_zonepath() gets its data from the XML repository. 30368cd327d5Sgjelinek * Verify this against the index file, which is checked first by 30378cd327d5Sgjelinek * zone_get_zonepath(). If they don't match, bail out. 30388cd327d5Sgjelinek */ 30398cd327d5Sgjelinek if ((err = zone_get_zonepath(target_zone, checkpath, 30408cd327d5Sgjelinek sizeof (checkpath))) != Z_OK) { 30418cd327d5Sgjelinek errno = err; 30428cd327d5Sgjelinek zperror2(target_zone, gettext("could not get zone path")); 3043e767a340Sgjelinek zonecfg_fini_handle(handle); 30448cd327d5Sgjelinek return (Z_ERR); 30458cd327d5Sgjelinek } 30468cd327d5Sgjelinek if (strcmp(zonepath, checkpath) != 0) { 30478cd327d5Sgjelinek /* 30488cd327d5Sgjelinek * TRANSLATION_NOTE 30498cd327d5Sgjelinek * XML and zonepath are literals that should not be translated. 30508cd327d5Sgjelinek */ 30518cd327d5Sgjelinek (void) fprintf(stderr, gettext("The XML repository has " 30528cd327d5Sgjelinek "zonepath '%s',\nbut the index file has zonepath '%s'.\n" 30538cd327d5Sgjelinek "These must match, so fix the incorrect entry.\n"), 30548cd327d5Sgjelinek zonepath, checkpath); 3055e767a340Sgjelinek zonecfg_fini_handle(handle); 30568cd327d5Sgjelinek return (Z_ERR); 30578cd327d5Sgjelinek } 30588cd327d5Sgjelinek if (validate_zonepath(zonepath, cmd_num) != Z_OK) { 30598cd327d5Sgjelinek (void) fprintf(stderr, gettext("could not verify zonepath %s " 30608cd327d5Sgjelinek "because of the above errors.\n"), zonepath); 30618cd327d5Sgjelinek return_code = Z_ERR; 30628cd327d5Sgjelinek } 30638cd327d5Sgjelinek 3064ce28b40eSzt129084 if (verify_handle(cmd_num, handle, argv) != Z_OK) 30658cd327d5Sgjelinek return_code = Z_ERR; 30668cd327d5Sgjelinek 30677c478bd9Sstevel@tonic-gate zonecfg_fini_handle(handle); 30687c478bd9Sstevel@tonic-gate if (return_code == Z_ERR) 30697c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 30707c478bd9Sstevel@tonic-gate gettext("%s: zone %s failed to verify\n"), 30717c478bd9Sstevel@tonic-gate execname, target_zone); 30727c478bd9Sstevel@tonic-gate return (return_code); 30737c478bd9Sstevel@tonic-gate } 30747c478bd9Sstevel@tonic-gate 30757c478bd9Sstevel@tonic-gate static int 30767c478bd9Sstevel@tonic-gate verify_func(int argc, char *argv[]) 30777c478bd9Sstevel@tonic-gate { 30787c478bd9Sstevel@tonic-gate int arg; 30797c478bd9Sstevel@tonic-gate 30807c478bd9Sstevel@tonic-gate optind = 0; 30817c478bd9Sstevel@tonic-gate if ((arg = getopt(argc, argv, "?")) != EOF) { 30827c478bd9Sstevel@tonic-gate switch (arg) { 30837c478bd9Sstevel@tonic-gate case '?': 30847c478bd9Sstevel@tonic-gate sub_usage(SHELP_VERIFY, CMD_VERIFY); 30857c478bd9Sstevel@tonic-gate return (optopt == '?' ? Z_OK : Z_USAGE); 30867c478bd9Sstevel@tonic-gate default: 30877c478bd9Sstevel@tonic-gate sub_usage(SHELP_VERIFY, CMD_VERIFY); 30887c478bd9Sstevel@tonic-gate return (Z_USAGE); 30897c478bd9Sstevel@tonic-gate } 30907c478bd9Sstevel@tonic-gate } 30917c478bd9Sstevel@tonic-gate if (argc > optind) { 30927c478bd9Sstevel@tonic-gate sub_usage(SHELP_VERIFY, CMD_VERIFY); 30937c478bd9Sstevel@tonic-gate return (Z_USAGE); 30947c478bd9Sstevel@tonic-gate } 30959acbbeafSnn35248 if (sanity_check(target_zone, CMD_VERIFY, B_FALSE, B_FALSE, B_FALSE) 30969acbbeafSnn35248 != Z_OK) 30977c478bd9Sstevel@tonic-gate return (Z_ERR); 3098ce28b40eSzt129084 return (verify_details(CMD_VERIFY, argv)); 30997c478bd9Sstevel@tonic-gate } 31007c478bd9Sstevel@tonic-gate 31019acbbeafSnn35248 static int 31029acbbeafSnn35248 addopt(char *buf, int opt, char *optarg, size_t bufsize) 31039acbbeafSnn35248 { 31049acbbeafSnn35248 char optstring[4]; 31059acbbeafSnn35248 31069acbbeafSnn35248 if (opt > 0) 31079acbbeafSnn35248 (void) sprintf(optstring, " -%c", opt); 31089acbbeafSnn35248 else 31099acbbeafSnn35248 (void) strcpy(optstring, " "); 31109acbbeafSnn35248 31119acbbeafSnn35248 if ((strlcat(buf, optstring, bufsize) > bufsize)) 31129acbbeafSnn35248 return (Z_ERR); 31139acbbeafSnn35248 if ((optarg != NULL) && (strlcat(buf, optarg, bufsize) > bufsize)) 31149acbbeafSnn35248 return (Z_ERR); 31159acbbeafSnn35248 return (Z_OK); 31169acbbeafSnn35248 } 31177c478bd9Sstevel@tonic-gate 31187c478bd9Sstevel@tonic-gate static int 31197c478bd9Sstevel@tonic-gate install_func(int argc, char *argv[]) 31207c478bd9Sstevel@tonic-gate { 31219acbbeafSnn35248 char cmdbuf[MAXPATHLEN]; 31227c478bd9Sstevel@tonic-gate int lockfd; 31239acbbeafSnn35248 int arg, err, subproc_err; 31247c478bd9Sstevel@tonic-gate char zonepath[MAXPATHLEN]; 3125123807fbSedp brand_handle_t bh = NULL; 31267c478bd9Sstevel@tonic-gate int status; 31270b5de56dSgjelinek boolean_t nodataset = B_FALSE; 31289acbbeafSnn35248 char opts[128]; 31299acbbeafSnn35248 31309acbbeafSnn35248 if (target_zone == NULL) { 31319acbbeafSnn35248 sub_usage(SHELP_INSTALL, CMD_INSTALL); 31329acbbeafSnn35248 return (Z_USAGE); 31339acbbeafSnn35248 } 31347c478bd9Sstevel@tonic-gate 3135108322fbScarlsonj if (zonecfg_in_alt_root()) { 3136108322fbScarlsonj zerror(gettext("cannot install zone in alternate root")); 3137108322fbScarlsonj return (Z_ERR); 3138108322fbScarlsonj } 3139108322fbScarlsonj 31409acbbeafSnn35248 if ((err = zone_get_zonepath(target_zone, zonepath, 31419acbbeafSnn35248 sizeof (zonepath))) != Z_OK) { 31429acbbeafSnn35248 errno = err; 31439acbbeafSnn35248 zperror2(target_zone, gettext("could not get zone path")); 31449acbbeafSnn35248 return (Z_ERR); 31459acbbeafSnn35248 } 31469acbbeafSnn35248 31479acbbeafSnn35248 /* Fetch the install command from the brand configuration. */ 3148123807fbSedp if ((bh = brand_open(target_brand)) == NULL) { 31499acbbeafSnn35248 zerror(gettext("missing or invalid brand")); 31509acbbeafSnn35248 return (Z_ERR); 31519acbbeafSnn35248 } 31529acbbeafSnn35248 31539acbbeafSnn35248 (void) strcpy(cmdbuf, EXEC_PREFIX); 3154123807fbSedp if (brand_get_install(bh, target_zone, zonepath, cmdbuf + EXEC_LEN, 31559acbbeafSnn35248 sizeof (cmdbuf) - EXEC_LEN, 0, NULL) != 0) { 31569acbbeafSnn35248 zerror("invalid brand configuration: missing install resource"); 3157123807fbSedp brand_close(bh); 31589acbbeafSnn35248 return (Z_ERR); 31599acbbeafSnn35248 } 31609acbbeafSnn35248 31619acbbeafSnn35248 (void) strcpy(opts, "?x:"); 31629acbbeafSnn35248 if (!is_native_zone) { 31639acbbeafSnn35248 /* 31649acbbeafSnn35248 * Fetch the list of recognized command-line options from 31659acbbeafSnn35248 * the brand configuration file. 31669acbbeafSnn35248 */ 3167123807fbSedp if (brand_get_installopts(bh, opts + strlen(opts), 31689acbbeafSnn35248 sizeof (opts) - strlen(opts)) != 0) { 31699acbbeafSnn35248 zerror("invalid brand configuration: missing " 31709acbbeafSnn35248 "install options resource"); 3171123807fbSedp brand_close(bh); 31729acbbeafSnn35248 return (Z_ERR); 31739acbbeafSnn35248 } 31749acbbeafSnn35248 } 3175123807fbSedp brand_close(bh); 31769acbbeafSnn35248 31777c478bd9Sstevel@tonic-gate optind = 0; 31789acbbeafSnn35248 while ((arg = getopt(argc, argv, opts)) != EOF) { 31797c478bd9Sstevel@tonic-gate switch (arg) { 31807c478bd9Sstevel@tonic-gate case '?': 31817c478bd9Sstevel@tonic-gate sub_usage(SHELP_INSTALL, CMD_INSTALL); 31827c478bd9Sstevel@tonic-gate return (optopt == '?' ? Z_OK : Z_USAGE); 31830b5de56dSgjelinek case 'x': 31840b5de56dSgjelinek if (strcmp(optarg, "nodataset") != 0) { 31850b5de56dSgjelinek sub_usage(SHELP_INSTALL, CMD_INSTALL); 31860b5de56dSgjelinek return (Z_USAGE); 31870b5de56dSgjelinek } 31880b5de56dSgjelinek nodataset = B_TRUE; 31890b5de56dSgjelinek break; 31907c478bd9Sstevel@tonic-gate default: 31919acbbeafSnn35248 if (is_native_zone) { 31927c478bd9Sstevel@tonic-gate sub_usage(SHELP_INSTALL, CMD_INSTALL); 31937c478bd9Sstevel@tonic-gate return (Z_USAGE); 31947c478bd9Sstevel@tonic-gate } 31959acbbeafSnn35248 31969acbbeafSnn35248 /* 31979acbbeafSnn35248 * This option isn't for zoneadm, so append it to 31989acbbeafSnn35248 * the command line passed to the brand-specific 31999acbbeafSnn35248 * install routine. 32009acbbeafSnn35248 */ 32019acbbeafSnn35248 if (addopt(cmdbuf, optopt, optarg, 32029acbbeafSnn35248 sizeof (cmdbuf)) != Z_OK) { 32039acbbeafSnn35248 zerror("Install command line too long"); 32049acbbeafSnn35248 return (Z_ERR); 32057c478bd9Sstevel@tonic-gate } 32069acbbeafSnn35248 break; 32077c478bd9Sstevel@tonic-gate } 32089acbbeafSnn35248 } 32099acbbeafSnn35248 32109acbbeafSnn35248 if (!is_native_zone) { 32119acbbeafSnn35248 for (; optind < argc; optind++) { 32129acbbeafSnn35248 if (addopt(cmdbuf, 0, argv[optind], 32139acbbeafSnn35248 sizeof (cmdbuf)) != Z_OK) { 32149acbbeafSnn35248 zerror("Install command line too long"); 32159acbbeafSnn35248 return (Z_ERR); 32169acbbeafSnn35248 } 32179acbbeafSnn35248 } 32189acbbeafSnn35248 } 32199acbbeafSnn35248 32209acbbeafSnn35248 if (sanity_check(target_zone, CMD_INSTALL, B_FALSE, B_TRUE, B_FALSE) 32219acbbeafSnn35248 != Z_OK) 32227c478bd9Sstevel@tonic-gate return (Z_ERR); 3223ce28b40eSzt129084 if (verify_details(CMD_INSTALL, argv) != Z_OK) 32247c478bd9Sstevel@tonic-gate return (Z_ERR); 32257c478bd9Sstevel@tonic-gate 32267c478bd9Sstevel@tonic-gate if (grab_lock_file(target_zone, &lockfd) != Z_OK) { 32277c478bd9Sstevel@tonic-gate zerror(gettext("another %s may have an operation in progress."), 3228865e09a4Sgjelinek "zoneadm"); 32297c478bd9Sstevel@tonic-gate return (Z_ERR); 32307c478bd9Sstevel@tonic-gate } 32317c478bd9Sstevel@tonic-gate err = zone_set_state(target_zone, ZONE_STATE_INCOMPLETE); 32327c478bd9Sstevel@tonic-gate if (err != Z_OK) { 32337c478bd9Sstevel@tonic-gate errno = err; 32347c478bd9Sstevel@tonic-gate zperror2(target_zone, gettext("could not set state")); 32357c478bd9Sstevel@tonic-gate goto done; 32367c478bd9Sstevel@tonic-gate } 32377c478bd9Sstevel@tonic-gate 32389acbbeafSnn35248 if (!nodataset) 32399acbbeafSnn35248 create_zfs_zonepath(zonepath); 32409acbbeafSnn35248 32417c478bd9Sstevel@tonic-gate /* 32427c478bd9Sstevel@tonic-gate * According to the Application Packaging Developer's Guide, a 32437c478bd9Sstevel@tonic-gate * "checkinstall" script when included in a package is executed as 32447c478bd9Sstevel@tonic-gate * the user "install", if such a user exists, or by the user 32457c478bd9Sstevel@tonic-gate * "nobody". In order to support this dubious behavior, the path 32467c478bd9Sstevel@tonic-gate * to the zone being constructed is opened up during the life of 32477c478bd9Sstevel@tonic-gate * the command laying down the zone's root file system. Once this 32487c478bd9Sstevel@tonic-gate * has completed, regardless of whether it was successful, the 32497c478bd9Sstevel@tonic-gate * path to the zone is again restricted. 32507c478bd9Sstevel@tonic-gate */ 32517c478bd9Sstevel@tonic-gate if (chmod(zonepath, DEFAULT_DIR_MODE) != 0) { 32527c478bd9Sstevel@tonic-gate zperror(zonepath, B_FALSE); 32537c478bd9Sstevel@tonic-gate err = Z_ERR; 32547c478bd9Sstevel@tonic-gate goto done; 32557c478bd9Sstevel@tonic-gate } 32567c478bd9Sstevel@tonic-gate 32579acbbeafSnn35248 if (is_native_zone) 32587c478bd9Sstevel@tonic-gate status = do_subproc(cmdbuf); 32599acbbeafSnn35248 else 32609acbbeafSnn35248 status = do_subproc_interactive(cmdbuf); 32619acbbeafSnn35248 32627c478bd9Sstevel@tonic-gate if (chmod(zonepath, S_IRWXU) != 0) { 32637c478bd9Sstevel@tonic-gate zperror(zonepath, B_FALSE); 32647c478bd9Sstevel@tonic-gate err = Z_ERR; 32657c478bd9Sstevel@tonic-gate goto done; 32667c478bd9Sstevel@tonic-gate } 32679acbbeafSnn35248 if ((subproc_err = 32689acbbeafSnn35248 subproc_status(gettext("brand-specific installation"), status, 32699acbbeafSnn35248 B_FALSE)) != ZONE_SUBPROC_OK) { 32709acbbeafSnn35248 err = Z_ERR; 32717c478bd9Sstevel@tonic-gate goto done; 32729acbbeafSnn35248 } 32737c478bd9Sstevel@tonic-gate 32747c478bd9Sstevel@tonic-gate if ((err = zone_set_state(target_zone, ZONE_STATE_INSTALLED)) != Z_OK) { 32757c478bd9Sstevel@tonic-gate errno = err; 32767c478bd9Sstevel@tonic-gate zperror2(target_zone, gettext("could not set state")); 32777c478bd9Sstevel@tonic-gate goto done; 32787c478bd9Sstevel@tonic-gate } 32797c478bd9Sstevel@tonic-gate 32807c478bd9Sstevel@tonic-gate done: 32819acbbeafSnn35248 /* 32829acbbeafSnn35248 * If the install script exited with ZONE_SUBPROC_USAGE or 32839acbbeafSnn35248 * ZONE_SUBPROC_NOTCOMPLETE, try to clean up the zone and leave the 32849acbbeafSnn35248 * zone in the CONFIGURED state so that another install can be 32859acbbeafSnn35248 * attempted without requiring an uninstall first. 32869acbbeafSnn35248 */ 32879acbbeafSnn35248 if ((subproc_err == ZONE_SUBPROC_USAGE) || 32889acbbeafSnn35248 (subproc_err == ZONE_SUBPROC_NOTCOMPLETE)) { 32899acbbeafSnn35248 if ((err = cleanup_zonepath(zonepath, B_FALSE)) != Z_OK) { 32909acbbeafSnn35248 errno = err; 32919acbbeafSnn35248 zperror2(target_zone, 32929acbbeafSnn35248 gettext("cleaning up zonepath failed")); 32939acbbeafSnn35248 } else if ((err = zone_set_state(target_zone, 32949acbbeafSnn35248 ZONE_STATE_CONFIGURED)) != Z_OK) { 32959acbbeafSnn35248 errno = err; 32969acbbeafSnn35248 zperror2(target_zone, gettext("could not set state")); 32979acbbeafSnn35248 } 32989acbbeafSnn35248 } 32999acbbeafSnn35248 33007c478bd9Sstevel@tonic-gate release_lock_file(lockfd); 33017c478bd9Sstevel@tonic-gate return ((err == Z_OK) ? Z_OK : Z_ERR); 33027c478bd9Sstevel@tonic-gate } 33037c478bd9Sstevel@tonic-gate 33047c478bd9Sstevel@tonic-gate /* 3305865e09a4Sgjelinek * Check that the inherited pkg dirs are the same for the clone and its source. 3306865e09a4Sgjelinek * The easiest way to do that is check that the list of ipds is the same 3307865e09a4Sgjelinek * by matching each one against the other. This algorithm should be fine since 3308865e09a4Sgjelinek * the list of ipds should not be that long. 3309865e09a4Sgjelinek */ 3310865e09a4Sgjelinek static int 3311865e09a4Sgjelinek valid_ipd_clone(zone_dochandle_t s_handle, char *source_zone, 3312865e09a4Sgjelinek zone_dochandle_t t_handle, char *target_zone) 3313865e09a4Sgjelinek { 3314865e09a4Sgjelinek int err; 3315865e09a4Sgjelinek int res = Z_OK; 3316865e09a4Sgjelinek int s_cnt = 0; 3317865e09a4Sgjelinek int t_cnt = 0; 3318865e09a4Sgjelinek struct zone_fstab s_fstab; 3319865e09a4Sgjelinek struct zone_fstab t_fstab; 3320865e09a4Sgjelinek 3321865e09a4Sgjelinek /* 3322865e09a4Sgjelinek * First check the source of the clone against the target. 3323865e09a4Sgjelinek */ 3324865e09a4Sgjelinek if ((err = zonecfg_setipdent(s_handle)) != Z_OK) { 3325865e09a4Sgjelinek errno = err; 3326865e09a4Sgjelinek zperror2(source_zone, gettext("could not enumerate " 3327865e09a4Sgjelinek "inherit-pkg-dirs")); 3328865e09a4Sgjelinek return (Z_ERR); 3329865e09a4Sgjelinek } 3330865e09a4Sgjelinek 3331865e09a4Sgjelinek while (zonecfg_getipdent(s_handle, &s_fstab) == Z_OK) { 3332865e09a4Sgjelinek boolean_t match = B_FALSE; 3333865e09a4Sgjelinek 3334865e09a4Sgjelinek s_cnt++; 3335865e09a4Sgjelinek 3336865e09a4Sgjelinek if ((err = zonecfg_setipdent(t_handle)) != Z_OK) { 3337865e09a4Sgjelinek errno = err; 3338865e09a4Sgjelinek zperror2(target_zone, gettext("could not enumerate " 3339865e09a4Sgjelinek "inherit-pkg-dirs")); 3340865e09a4Sgjelinek (void) zonecfg_endipdent(s_handle); 3341865e09a4Sgjelinek return (Z_ERR); 3342865e09a4Sgjelinek } 3343865e09a4Sgjelinek 3344865e09a4Sgjelinek while (zonecfg_getipdent(t_handle, &t_fstab) == Z_OK) { 3345865e09a4Sgjelinek if (strcmp(s_fstab.zone_fs_dir, t_fstab.zone_fs_dir) 3346865e09a4Sgjelinek == 0) { 3347865e09a4Sgjelinek match = B_TRUE; 3348865e09a4Sgjelinek break; 3349865e09a4Sgjelinek } 3350865e09a4Sgjelinek } 3351865e09a4Sgjelinek (void) zonecfg_endipdent(t_handle); 3352865e09a4Sgjelinek 3353865e09a4Sgjelinek if (!match) { 3354865e09a4Sgjelinek (void) fprintf(stderr, gettext("inherit-pkg-dir " 3355865e09a4Sgjelinek "'%s' is not configured in zone %s.\n"), 3356865e09a4Sgjelinek s_fstab.zone_fs_dir, target_zone); 3357865e09a4Sgjelinek res = Z_ERR; 3358865e09a4Sgjelinek } 3359865e09a4Sgjelinek } 3360865e09a4Sgjelinek 3361865e09a4Sgjelinek (void) zonecfg_endipdent(s_handle); 3362865e09a4Sgjelinek 3363865e09a4Sgjelinek /* skip the next check if we already have errors */ 3364865e09a4Sgjelinek if (res == Z_ERR) 3365865e09a4Sgjelinek return (res); 3366865e09a4Sgjelinek 3367865e09a4Sgjelinek /* 3368865e09a4Sgjelinek * Now check the number of ipds in the target so we can verify 3369865e09a4Sgjelinek * that the source is not a subset of the target. 3370865e09a4Sgjelinek */ 3371865e09a4Sgjelinek if ((err = zonecfg_setipdent(t_handle)) != Z_OK) { 3372865e09a4Sgjelinek errno = err; 3373865e09a4Sgjelinek zperror2(target_zone, gettext("could not enumerate " 3374865e09a4Sgjelinek "inherit-pkg-dirs")); 3375865e09a4Sgjelinek return (Z_ERR); 3376865e09a4Sgjelinek } 3377865e09a4Sgjelinek 3378865e09a4Sgjelinek while (zonecfg_getipdent(t_handle, &t_fstab) == Z_OK) 3379865e09a4Sgjelinek t_cnt++; 3380865e09a4Sgjelinek 3381865e09a4Sgjelinek (void) zonecfg_endipdent(t_handle); 3382865e09a4Sgjelinek 3383865e09a4Sgjelinek if (t_cnt != s_cnt) { 3384865e09a4Sgjelinek (void) fprintf(stderr, gettext("Zone %s is configured " 3385865e09a4Sgjelinek "with inherit-pkg-dirs that are not configured in zone " 3386865e09a4Sgjelinek "%s.\n"), target_zone, source_zone); 3387865e09a4Sgjelinek res = Z_ERR; 3388865e09a4Sgjelinek } 3389865e09a4Sgjelinek 3390865e09a4Sgjelinek return (res); 3391865e09a4Sgjelinek } 3392865e09a4Sgjelinek 3393865e09a4Sgjelinek static void 3394865e09a4Sgjelinek warn_dev_match(zone_dochandle_t s_handle, char *source_zone, 3395865e09a4Sgjelinek zone_dochandle_t t_handle, char *target_zone) 3396865e09a4Sgjelinek { 3397865e09a4Sgjelinek int err; 3398865e09a4Sgjelinek struct zone_devtab s_devtab; 3399865e09a4Sgjelinek struct zone_devtab t_devtab; 3400865e09a4Sgjelinek 3401865e09a4Sgjelinek if ((err = zonecfg_setdevent(t_handle)) != Z_OK) { 3402865e09a4Sgjelinek errno = err; 3403865e09a4Sgjelinek zperror2(target_zone, gettext("could not enumerate devices")); 3404865e09a4Sgjelinek return; 3405865e09a4Sgjelinek } 3406865e09a4Sgjelinek 3407865e09a4Sgjelinek while (zonecfg_getdevent(t_handle, &t_devtab) == Z_OK) { 3408865e09a4Sgjelinek if ((err = zonecfg_setdevent(s_handle)) != Z_OK) { 3409865e09a4Sgjelinek errno = err; 3410865e09a4Sgjelinek zperror2(source_zone, 3411865e09a4Sgjelinek gettext("could not enumerate devices")); 3412865e09a4Sgjelinek (void) zonecfg_enddevent(t_handle); 3413865e09a4Sgjelinek return; 3414865e09a4Sgjelinek } 3415865e09a4Sgjelinek 3416865e09a4Sgjelinek while (zonecfg_getdevent(s_handle, &s_devtab) == Z_OK) { 3417865e09a4Sgjelinek /* 3418865e09a4Sgjelinek * Use fnmatch to catch the case where wildcards 3419865e09a4Sgjelinek * were used in one zone and the other has an 3420865e09a4Sgjelinek * explicit entry (e.g. /dev/dsk/c0t0d0s6 vs. 3421865e09a4Sgjelinek * /dev/\*dsk/c0t0d0s6). 3422865e09a4Sgjelinek */ 3423865e09a4Sgjelinek if (fnmatch(t_devtab.zone_dev_match, 3424865e09a4Sgjelinek s_devtab.zone_dev_match, FNM_PATHNAME) == 0 || 3425865e09a4Sgjelinek fnmatch(s_devtab.zone_dev_match, 3426865e09a4Sgjelinek t_devtab.zone_dev_match, FNM_PATHNAME) == 0) { 3427865e09a4Sgjelinek (void) fprintf(stderr, 3428865e09a4Sgjelinek gettext("WARNING: device '%s' " 3429865e09a4Sgjelinek "is configured in both zones.\n"), 3430865e09a4Sgjelinek t_devtab.zone_dev_match); 3431865e09a4Sgjelinek break; 3432865e09a4Sgjelinek } 3433865e09a4Sgjelinek } 3434865e09a4Sgjelinek (void) zonecfg_enddevent(s_handle); 3435865e09a4Sgjelinek } 3436865e09a4Sgjelinek 3437865e09a4Sgjelinek (void) zonecfg_enddevent(t_handle); 3438865e09a4Sgjelinek } 3439865e09a4Sgjelinek 3440865e09a4Sgjelinek /* 3441865e09a4Sgjelinek * Check if the specified mount option (opt) is contained within the 3442865e09a4Sgjelinek * options string. 3443865e09a4Sgjelinek */ 3444865e09a4Sgjelinek static boolean_t 3445865e09a4Sgjelinek opt_match(char *opt, char *options) 3446865e09a4Sgjelinek { 3447865e09a4Sgjelinek char *p; 3448865e09a4Sgjelinek char *lastp; 3449865e09a4Sgjelinek 3450865e09a4Sgjelinek if ((p = strtok_r(options, ",", &lastp)) != NULL) { 3451865e09a4Sgjelinek if (strcmp(p, opt) == 0) 3452865e09a4Sgjelinek return (B_TRUE); 3453865e09a4Sgjelinek while ((p = strtok_r(NULL, ",", &lastp)) != NULL) { 3454865e09a4Sgjelinek if (strcmp(p, opt) == 0) 3455865e09a4Sgjelinek return (B_TRUE); 3456865e09a4Sgjelinek } 3457865e09a4Sgjelinek } 3458865e09a4Sgjelinek 3459865e09a4Sgjelinek return (B_FALSE); 3460865e09a4Sgjelinek } 3461865e09a4Sgjelinek 34620b5de56dSgjelinek #define RW_LOFS "WARNING: read-write lofs file system on '%s' is configured " \ 3463865e09a4Sgjelinek "in both zones.\n" 3464865e09a4Sgjelinek 3465865e09a4Sgjelinek static void 3466865e09a4Sgjelinek print_fs_warnings(struct zone_fstab *s_fstab, struct zone_fstab *t_fstab) 3467865e09a4Sgjelinek { 3468865e09a4Sgjelinek /* 3469865e09a4Sgjelinek * It is ok to have shared lofs mounted fs but we want to warn if 3470865e09a4Sgjelinek * either is rw since this will effect the other zone. 3471865e09a4Sgjelinek */ 3472865e09a4Sgjelinek if (strcmp(t_fstab->zone_fs_type, "lofs") == 0) { 3473865e09a4Sgjelinek zone_fsopt_t *optp; 3474865e09a4Sgjelinek 3475865e09a4Sgjelinek /* The default is rw so no options means rw */ 3476865e09a4Sgjelinek if (t_fstab->zone_fs_options == NULL || 3477865e09a4Sgjelinek s_fstab->zone_fs_options == NULL) { 3478865e09a4Sgjelinek (void) fprintf(stderr, gettext(RW_LOFS), 3479865e09a4Sgjelinek t_fstab->zone_fs_special); 3480865e09a4Sgjelinek return; 3481865e09a4Sgjelinek } 3482865e09a4Sgjelinek 3483865e09a4Sgjelinek for (optp = s_fstab->zone_fs_options; optp != NULL; 3484865e09a4Sgjelinek optp = optp->zone_fsopt_next) { 3485865e09a4Sgjelinek if (opt_match("rw", optp->zone_fsopt_opt)) { 3486865e09a4Sgjelinek (void) fprintf(stderr, gettext(RW_LOFS), 3487865e09a4Sgjelinek s_fstab->zone_fs_special); 3488865e09a4Sgjelinek return; 3489865e09a4Sgjelinek } 3490865e09a4Sgjelinek } 3491865e09a4Sgjelinek 3492865e09a4Sgjelinek for (optp = t_fstab->zone_fs_options; optp != NULL; 3493865e09a4Sgjelinek optp = optp->zone_fsopt_next) { 3494865e09a4Sgjelinek if (opt_match("rw", optp->zone_fsopt_opt)) { 3495865e09a4Sgjelinek (void) fprintf(stderr, gettext(RW_LOFS), 3496865e09a4Sgjelinek t_fstab->zone_fs_special); 3497865e09a4Sgjelinek return; 3498865e09a4Sgjelinek } 3499865e09a4Sgjelinek } 3500865e09a4Sgjelinek 3501865e09a4Sgjelinek return; 3502865e09a4Sgjelinek } 3503865e09a4Sgjelinek 3504865e09a4Sgjelinek /* 3505865e09a4Sgjelinek * TRANSLATION_NOTE 35060b5de56dSgjelinek * The first variable is the file system type and the second is 35070b5de56dSgjelinek * the file system special device. For example, 35080b5de56dSgjelinek * WARNING: ufs file system on '/dev/dsk/c0t0d0s0' ... 3509865e09a4Sgjelinek */ 35100b5de56dSgjelinek (void) fprintf(stderr, gettext("WARNING: %s file system on '%s' " 3511865e09a4Sgjelinek "is configured in both zones.\n"), t_fstab->zone_fs_type, 3512865e09a4Sgjelinek t_fstab->zone_fs_special); 3513865e09a4Sgjelinek } 3514865e09a4Sgjelinek 3515865e09a4Sgjelinek static void 3516865e09a4Sgjelinek warn_fs_match(zone_dochandle_t s_handle, char *source_zone, 3517865e09a4Sgjelinek zone_dochandle_t t_handle, char *target_zone) 3518865e09a4Sgjelinek { 3519865e09a4Sgjelinek int err; 3520865e09a4Sgjelinek struct zone_fstab s_fstab; 3521865e09a4Sgjelinek struct zone_fstab t_fstab; 3522865e09a4Sgjelinek 3523865e09a4Sgjelinek if ((err = zonecfg_setfsent(t_handle)) != Z_OK) { 3524865e09a4Sgjelinek errno = err; 3525865e09a4Sgjelinek zperror2(target_zone, 35260b5de56dSgjelinek gettext("could not enumerate file systems")); 3527865e09a4Sgjelinek return; 3528865e09a4Sgjelinek } 3529865e09a4Sgjelinek 3530865e09a4Sgjelinek while (zonecfg_getfsent(t_handle, &t_fstab) == Z_OK) { 3531865e09a4Sgjelinek if ((err = zonecfg_setfsent(s_handle)) != Z_OK) { 3532865e09a4Sgjelinek errno = err; 3533865e09a4Sgjelinek zperror2(source_zone, 35340b5de56dSgjelinek gettext("could not enumerate file systems")); 3535865e09a4Sgjelinek (void) zonecfg_endfsent(t_handle); 3536865e09a4Sgjelinek return; 3537865e09a4Sgjelinek } 3538865e09a4Sgjelinek 3539865e09a4Sgjelinek while (zonecfg_getfsent(s_handle, &s_fstab) == Z_OK) { 3540865e09a4Sgjelinek if (strcmp(t_fstab.zone_fs_special, 3541865e09a4Sgjelinek s_fstab.zone_fs_special) == 0) { 3542865e09a4Sgjelinek print_fs_warnings(&s_fstab, &t_fstab); 3543865e09a4Sgjelinek break; 3544865e09a4Sgjelinek } 3545865e09a4Sgjelinek } 3546865e09a4Sgjelinek (void) zonecfg_endfsent(s_handle); 3547865e09a4Sgjelinek } 3548865e09a4Sgjelinek 3549865e09a4Sgjelinek (void) zonecfg_endfsent(t_handle); 3550865e09a4Sgjelinek } 3551865e09a4Sgjelinek 3552865e09a4Sgjelinek /* 3553865e09a4Sgjelinek * We don't catch the case where you used the same IP address but 3554865e09a4Sgjelinek * it is not an exact string match. For example, 192.9.0.128 vs. 192.09.0.128. 3555865e09a4Sgjelinek * However, we're not going to worry about that but we will check for 3556865e09a4Sgjelinek * a possible netmask on one of the addresses (e.g. 10.0.0.1 and 10.0.0.1/24) 3557865e09a4Sgjelinek * and handle that case as a match. 3558865e09a4Sgjelinek */ 3559865e09a4Sgjelinek static void 3560865e09a4Sgjelinek warn_ip_match(zone_dochandle_t s_handle, char *source_zone, 3561865e09a4Sgjelinek zone_dochandle_t t_handle, char *target_zone) 3562865e09a4Sgjelinek { 3563865e09a4Sgjelinek int err; 3564865e09a4Sgjelinek struct zone_nwiftab s_nwiftab; 3565865e09a4Sgjelinek struct zone_nwiftab t_nwiftab; 3566865e09a4Sgjelinek 3567865e09a4Sgjelinek if ((err = zonecfg_setnwifent(t_handle)) != Z_OK) { 3568865e09a4Sgjelinek errno = err; 3569865e09a4Sgjelinek zperror2(target_zone, 3570865e09a4Sgjelinek gettext("could not enumerate network interfaces")); 3571865e09a4Sgjelinek return; 3572865e09a4Sgjelinek } 3573865e09a4Sgjelinek 3574865e09a4Sgjelinek while (zonecfg_getnwifent(t_handle, &t_nwiftab) == Z_OK) { 3575865e09a4Sgjelinek char *p; 3576865e09a4Sgjelinek 3577865e09a4Sgjelinek /* remove an (optional) netmask from the address */ 3578865e09a4Sgjelinek if ((p = strchr(t_nwiftab.zone_nwif_address, '/')) != NULL) 3579865e09a4Sgjelinek *p = '\0'; 3580865e09a4Sgjelinek 3581865e09a4Sgjelinek if ((err = zonecfg_setnwifent(s_handle)) != Z_OK) { 3582865e09a4Sgjelinek errno = err; 3583865e09a4Sgjelinek zperror2(source_zone, 3584865e09a4Sgjelinek gettext("could not enumerate network interfaces")); 3585865e09a4Sgjelinek (void) zonecfg_endnwifent(t_handle); 3586865e09a4Sgjelinek return; 3587865e09a4Sgjelinek } 3588865e09a4Sgjelinek 3589865e09a4Sgjelinek while (zonecfg_getnwifent(s_handle, &s_nwiftab) == Z_OK) { 3590865e09a4Sgjelinek /* remove an (optional) netmask from the address */ 3591865e09a4Sgjelinek if ((p = strchr(s_nwiftab.zone_nwif_address, '/')) 3592865e09a4Sgjelinek != NULL) 3593865e09a4Sgjelinek *p = '\0'; 3594865e09a4Sgjelinek 3595f4b3ec61Sdh155122 /* For exclusive-IP zones, address is not specified. */ 3596f4b3ec61Sdh155122 if (strlen(s_nwiftab.zone_nwif_address) == 0) 3597f4b3ec61Sdh155122 continue; 3598f4b3ec61Sdh155122 3599865e09a4Sgjelinek if (strcmp(t_nwiftab.zone_nwif_address, 3600865e09a4Sgjelinek s_nwiftab.zone_nwif_address) == 0) { 3601865e09a4Sgjelinek (void) fprintf(stderr, 3602865e09a4Sgjelinek gettext("WARNING: network address '%s' " 3603865e09a4Sgjelinek "is configured in both zones.\n"), 3604865e09a4Sgjelinek t_nwiftab.zone_nwif_address); 3605865e09a4Sgjelinek break; 3606865e09a4Sgjelinek } 3607865e09a4Sgjelinek } 3608865e09a4Sgjelinek (void) zonecfg_endnwifent(s_handle); 3609865e09a4Sgjelinek } 3610865e09a4Sgjelinek 3611865e09a4Sgjelinek (void) zonecfg_endnwifent(t_handle); 3612865e09a4Sgjelinek } 3613865e09a4Sgjelinek 3614865e09a4Sgjelinek static void 36159acbbeafSnn35248 warn_dataset_match(zone_dochandle_t s_handle, char *source, 36169acbbeafSnn35248 zone_dochandle_t t_handle, char *target) 3617865e09a4Sgjelinek { 3618865e09a4Sgjelinek int err; 3619865e09a4Sgjelinek struct zone_dstab s_dstab; 3620865e09a4Sgjelinek struct zone_dstab t_dstab; 3621865e09a4Sgjelinek 3622865e09a4Sgjelinek if ((err = zonecfg_setdsent(t_handle)) != Z_OK) { 3623865e09a4Sgjelinek errno = err; 36249acbbeafSnn35248 zperror2(target, gettext("could not enumerate datasets")); 3625865e09a4Sgjelinek return; 3626865e09a4Sgjelinek } 3627865e09a4Sgjelinek 3628865e09a4Sgjelinek while (zonecfg_getdsent(t_handle, &t_dstab) == Z_OK) { 3629865e09a4Sgjelinek if ((err = zonecfg_setdsent(s_handle)) != Z_OK) { 3630865e09a4Sgjelinek errno = err; 36319acbbeafSnn35248 zperror2(source, 3632865e09a4Sgjelinek gettext("could not enumerate datasets")); 3633865e09a4Sgjelinek (void) zonecfg_enddsent(t_handle); 3634865e09a4Sgjelinek return; 3635865e09a4Sgjelinek } 3636865e09a4Sgjelinek 3637865e09a4Sgjelinek while (zonecfg_getdsent(s_handle, &s_dstab) == Z_OK) { 3638865e09a4Sgjelinek if (strcmp(t_dstab.zone_dataset_name, 3639865e09a4Sgjelinek s_dstab.zone_dataset_name) == 0) { 36409acbbeafSnn35248 target_zone = source; 36419acbbeafSnn35248 zerror(gettext("WARNING: dataset '%s' " 3642865e09a4Sgjelinek "is configured in both zones.\n"), 3643865e09a4Sgjelinek t_dstab.zone_dataset_name); 3644865e09a4Sgjelinek break; 3645865e09a4Sgjelinek } 3646865e09a4Sgjelinek } 3647865e09a4Sgjelinek (void) zonecfg_enddsent(s_handle); 3648865e09a4Sgjelinek } 3649865e09a4Sgjelinek 3650865e09a4Sgjelinek (void) zonecfg_enddsent(t_handle); 3651865e09a4Sgjelinek } 3652865e09a4Sgjelinek 36539acbbeafSnn35248 /* 36549acbbeafSnn35248 * Check that the clone and its source have the same brand type. 36559acbbeafSnn35248 */ 36569acbbeafSnn35248 static int 36579acbbeafSnn35248 valid_brand_clone(char *source_zone, char *target_zone) 36589acbbeafSnn35248 { 3659123807fbSedp brand_handle_t bh; 36609acbbeafSnn35248 char source_brand[MAXNAMELEN]; 36619acbbeafSnn35248 36629acbbeafSnn35248 if ((zone_get_brand(source_zone, source_brand, 36639acbbeafSnn35248 sizeof (source_brand))) != Z_OK) { 36649acbbeafSnn35248 (void) fprintf(stderr, "%s: zone '%s': %s\n", 36659acbbeafSnn35248 execname, source_zone, gettext("missing or invalid brand")); 36669acbbeafSnn35248 return (Z_ERR); 36679acbbeafSnn35248 } 36689acbbeafSnn35248 36699acbbeafSnn35248 if (strcmp(source_brand, target_brand) != NULL) { 36709acbbeafSnn35248 (void) fprintf(stderr, 36719acbbeafSnn35248 gettext("%s: Zones '%s' and '%s' have different brand " 36729acbbeafSnn35248 "types.\n"), execname, source_zone, target_zone); 36739acbbeafSnn35248 return (Z_ERR); 36749acbbeafSnn35248 } 36759acbbeafSnn35248 3676123807fbSedp if ((bh = brand_open(target_brand)) == NULL) { 36779acbbeafSnn35248 zerror(gettext("missing or invalid brand")); 36789acbbeafSnn35248 return (Z_ERR); 36799acbbeafSnn35248 } 3680123807fbSedp brand_close(bh); 36819acbbeafSnn35248 return (Z_OK); 36829acbbeafSnn35248 } 36839acbbeafSnn35248 3684865e09a4Sgjelinek static int 3685865e09a4Sgjelinek validate_clone(char *source_zone, char *target_zone) 3686865e09a4Sgjelinek { 3687865e09a4Sgjelinek int err = Z_OK; 3688865e09a4Sgjelinek zone_dochandle_t s_handle; 3689865e09a4Sgjelinek zone_dochandle_t t_handle; 3690865e09a4Sgjelinek 3691865e09a4Sgjelinek if ((t_handle = zonecfg_init_handle()) == NULL) { 3692865e09a4Sgjelinek zperror(cmd_to_str(CMD_CLONE), B_TRUE); 3693865e09a4Sgjelinek return (Z_ERR); 3694865e09a4Sgjelinek } 3695865e09a4Sgjelinek if ((err = zonecfg_get_handle(target_zone, t_handle)) != Z_OK) { 3696865e09a4Sgjelinek errno = err; 3697865e09a4Sgjelinek zperror(cmd_to_str(CMD_CLONE), B_TRUE); 3698865e09a4Sgjelinek zonecfg_fini_handle(t_handle); 3699865e09a4Sgjelinek return (Z_ERR); 3700865e09a4Sgjelinek } 3701865e09a4Sgjelinek 3702865e09a4Sgjelinek if ((s_handle = zonecfg_init_handle()) == NULL) { 3703865e09a4Sgjelinek zperror(cmd_to_str(CMD_CLONE), B_TRUE); 3704865e09a4Sgjelinek zonecfg_fini_handle(t_handle); 3705865e09a4Sgjelinek return (Z_ERR); 3706865e09a4Sgjelinek } 3707865e09a4Sgjelinek if ((err = zonecfg_get_handle(source_zone, s_handle)) != Z_OK) { 3708865e09a4Sgjelinek errno = err; 3709865e09a4Sgjelinek zperror(cmd_to_str(CMD_CLONE), B_TRUE); 3710865e09a4Sgjelinek goto done; 3711865e09a4Sgjelinek } 3712865e09a4Sgjelinek 37139acbbeafSnn35248 /* verify new zone has same brand type */ 37149acbbeafSnn35248 err = valid_brand_clone(source_zone, target_zone); 37159acbbeafSnn35248 if (err != Z_OK) 37169acbbeafSnn35248 goto done; 37179acbbeafSnn35248 3718865e09a4Sgjelinek /* verify new zone has same inherit-pkg-dirs */ 3719865e09a4Sgjelinek err = valid_ipd_clone(s_handle, source_zone, t_handle, target_zone); 3720865e09a4Sgjelinek 3721865e09a4Sgjelinek /* warn about imported fs's which are the same */ 3722865e09a4Sgjelinek warn_fs_match(s_handle, source_zone, t_handle, target_zone); 3723865e09a4Sgjelinek 3724865e09a4Sgjelinek /* warn about imported IP addresses which are the same */ 3725865e09a4Sgjelinek warn_ip_match(s_handle, source_zone, t_handle, target_zone); 3726865e09a4Sgjelinek 3727865e09a4Sgjelinek /* warn about imported devices which are the same */ 3728865e09a4Sgjelinek warn_dev_match(s_handle, source_zone, t_handle, target_zone); 3729865e09a4Sgjelinek 3730865e09a4Sgjelinek /* warn about imported datasets which are the same */ 3731865e09a4Sgjelinek warn_dataset_match(s_handle, source_zone, t_handle, target_zone); 3732865e09a4Sgjelinek 3733865e09a4Sgjelinek done: 3734865e09a4Sgjelinek zonecfg_fini_handle(t_handle); 3735865e09a4Sgjelinek zonecfg_fini_handle(s_handle); 3736865e09a4Sgjelinek 3737865e09a4Sgjelinek return ((err == Z_OK) ? Z_OK : Z_ERR); 3738865e09a4Sgjelinek } 3739865e09a4Sgjelinek 3740865e09a4Sgjelinek static int 3741865e09a4Sgjelinek copy_zone(char *src, char *dst) 3742865e09a4Sgjelinek { 3743865e09a4Sgjelinek boolean_t out_null = B_FALSE; 3744865e09a4Sgjelinek int status; 3745865e09a4Sgjelinek char *outfile; 3746865e09a4Sgjelinek char cmdbuf[MAXPATHLEN * 2 + 128]; 3747865e09a4Sgjelinek 3748865e09a4Sgjelinek if ((outfile = tempnam("/var/log", "zone")) == NULL) { 3749865e09a4Sgjelinek outfile = "/dev/null"; 3750865e09a4Sgjelinek out_null = B_TRUE; 3751865e09a4Sgjelinek } 3752865e09a4Sgjelinek 37530b5de56dSgjelinek /* 37540b5de56dSgjelinek * Use find to get the list of files to copy. We need to skip 37550b5de56dSgjelinek * files of type "socket" since cpio can't handle those but that 37560b5de56dSgjelinek * should be ok since the app will recreate the socket when it runs. 37570b5de56dSgjelinek * We also need to filter out anything under the .zfs subdir. Since 37580b5de56dSgjelinek * find is running depth-first, we need the extra egrep to filter .zfs. 37590b5de56dSgjelinek */ 3760865e09a4Sgjelinek (void) snprintf(cmdbuf, sizeof (cmdbuf), 37610b5de56dSgjelinek "cd %s && /usr/bin/find . -type s -prune -o -depth -print | " 376207b574eeSgjelinek "/usr/bin/egrep -v '^\\./\\.zfs$|^\\./\\.zfs/' | " 3763865e09a4Sgjelinek "/usr/bin/cpio -pdmuP@ %s > %s 2>&1", 3764865e09a4Sgjelinek src, dst, outfile); 3765865e09a4Sgjelinek 3766865e09a4Sgjelinek status = do_subproc(cmdbuf); 3767865e09a4Sgjelinek 37689acbbeafSnn35248 if (subproc_status("copy", status, B_TRUE) != ZONE_SUBPROC_OK) { 3769865e09a4Sgjelinek if (!out_null) 3770865e09a4Sgjelinek (void) fprintf(stderr, gettext("\nThe copy failed.\n" 3771865e09a4Sgjelinek "More information can be found in %s\n"), outfile); 37729acbbeafSnn35248 return (Z_ERR); 3773865e09a4Sgjelinek } 3774865e09a4Sgjelinek 3775865e09a4Sgjelinek if (!out_null) 3776865e09a4Sgjelinek (void) unlink(outfile); 3777865e09a4Sgjelinek 3778865e09a4Sgjelinek return (Z_OK); 3779865e09a4Sgjelinek } 3780865e09a4Sgjelinek 3781865e09a4Sgjelinek static int 37829acbbeafSnn35248 zone_postclone(char *zonepath) 3783865e09a4Sgjelinek { 37849acbbeafSnn35248 char cmdbuf[MAXPATHLEN]; 3785865e09a4Sgjelinek int status; 3786123807fbSedp brand_handle_t bh; 37879acbbeafSnn35248 int err = Z_OK; 37885cd08338Sgjelinek 37895cd08338Sgjelinek /* 37909acbbeafSnn35248 * Fetch the post-clone command, if any, from the brand 37919acbbeafSnn35248 * configuration. 379245916cd2Sjpk */ 3793123807fbSedp if ((bh = brand_open(target_brand)) == NULL) { 37949acbbeafSnn35248 zerror(gettext("missing or invalid brand")); 37955cd08338Sgjelinek return (Z_ERR); 3796865e09a4Sgjelinek } 37979acbbeafSnn35248 (void) strcpy(cmdbuf, EXEC_PREFIX); 3798123807fbSedp err = brand_get_postclone(bh, target_zone, zonepath, cmdbuf + EXEC_LEN, 37999acbbeafSnn35248 sizeof (cmdbuf) - EXEC_LEN, 0, NULL); 3800123807fbSedp brand_close(bh); 3801865e09a4Sgjelinek 38029acbbeafSnn35248 if (err == 0 && strlen(cmdbuf) > EXEC_LEN) { 38035cd08338Sgjelinek status = do_subproc(cmdbuf); 38049acbbeafSnn35248 if ((err = subproc_status("postclone", status, B_FALSE)) 38059acbbeafSnn35248 != ZONE_SUBPROC_OK) { 38069acbbeafSnn35248 zerror(gettext("post-clone configuration failed.")); 38079acbbeafSnn35248 err = Z_ERR; 38089acbbeafSnn35248 } 3809865e09a4Sgjelinek } 3810865e09a4Sgjelinek 38119acbbeafSnn35248 return (err); 38125cd08338Sgjelinek } 3813865e09a4Sgjelinek 3814865e09a4Sgjelinek /* ARGSUSED */ 38150b5de56dSgjelinek static int 3816865e09a4Sgjelinek zfm_print(const char *p, void *r) { 3817865e09a4Sgjelinek zerror(" %s\n", p); 3818865e09a4Sgjelinek return (0); 3819865e09a4Sgjelinek } 3820865e09a4Sgjelinek 38210b5de56dSgjelinek int 38220b5de56dSgjelinek clone_copy(char *source_zonepath, char *zonepath) 38230b5de56dSgjelinek { 38240b5de56dSgjelinek int err; 38250b5de56dSgjelinek 38260b5de56dSgjelinek /* Don't clone the zone if anything is still mounted there */ 38270b5de56dSgjelinek if (zonecfg_find_mounts(source_zonepath, NULL, NULL)) { 38280b5de56dSgjelinek zerror(gettext("These file systems are mounted on " 38290b5de56dSgjelinek "subdirectories of %s.\n"), source_zonepath); 38300b5de56dSgjelinek (void) zonecfg_find_mounts(source_zonepath, zfm_print, NULL); 38310b5de56dSgjelinek return (Z_ERR); 38320b5de56dSgjelinek } 38330b5de56dSgjelinek 38340b5de56dSgjelinek /* 38350b5de56dSgjelinek * Attempt to create a ZFS fs for the zonepath. As usual, we don't 38360b5de56dSgjelinek * care if this works or not since we always have the default behavior 38370b5de56dSgjelinek * of a simple directory for the zonepath. 38380b5de56dSgjelinek */ 38390b5de56dSgjelinek create_zfs_zonepath(zonepath); 38400b5de56dSgjelinek 38410b5de56dSgjelinek (void) printf(gettext("Copying %s..."), source_zonepath); 38420b5de56dSgjelinek (void) fflush(stdout); 38430b5de56dSgjelinek 38440b5de56dSgjelinek err = copy_zone(source_zonepath, zonepath); 38450b5de56dSgjelinek 38460b5de56dSgjelinek (void) printf("\n"); 38470b5de56dSgjelinek 38480b5de56dSgjelinek return (err); 38490b5de56dSgjelinek } 38500b5de56dSgjelinek 3851865e09a4Sgjelinek static int 3852865e09a4Sgjelinek clone_func(int argc, char *argv[]) 3853865e09a4Sgjelinek { 3854865e09a4Sgjelinek char *source_zone = NULL; 3855865e09a4Sgjelinek int lockfd; 3856865e09a4Sgjelinek int err, arg; 3857865e09a4Sgjelinek char zonepath[MAXPATHLEN]; 3858865e09a4Sgjelinek char source_zonepath[MAXPATHLEN]; 3859865e09a4Sgjelinek zone_state_t state; 3860865e09a4Sgjelinek zone_entry_t *zent; 38610b5de56dSgjelinek char *method = NULL; 38620b5de56dSgjelinek char *snapshot = NULL; 3863865e09a4Sgjelinek 3864865e09a4Sgjelinek if (zonecfg_in_alt_root()) { 3865865e09a4Sgjelinek zerror(gettext("cannot clone zone in alternate root")); 3866865e09a4Sgjelinek return (Z_ERR); 3867865e09a4Sgjelinek } 3868865e09a4Sgjelinek 3869865e09a4Sgjelinek optind = 0; 38700b5de56dSgjelinek if ((arg = getopt(argc, argv, "?m:s:")) != EOF) { 3871865e09a4Sgjelinek switch (arg) { 3872865e09a4Sgjelinek case '?': 3873865e09a4Sgjelinek sub_usage(SHELP_CLONE, CMD_CLONE); 3874865e09a4Sgjelinek return (optopt == '?' ? Z_OK : Z_USAGE); 3875865e09a4Sgjelinek case 'm': 3876865e09a4Sgjelinek method = optarg; 3877865e09a4Sgjelinek break; 38780b5de56dSgjelinek case 's': 38790b5de56dSgjelinek snapshot = optarg; 38800b5de56dSgjelinek break; 3881865e09a4Sgjelinek default: 3882865e09a4Sgjelinek sub_usage(SHELP_CLONE, CMD_CLONE); 3883865e09a4Sgjelinek return (Z_USAGE); 3884865e09a4Sgjelinek } 3885865e09a4Sgjelinek } 38860b5de56dSgjelinek if (argc != (optind + 1) || 38870b5de56dSgjelinek (method != NULL && strcmp(method, "copy") != 0)) { 3888865e09a4Sgjelinek sub_usage(SHELP_CLONE, CMD_CLONE); 3889865e09a4Sgjelinek return (Z_USAGE); 3890865e09a4Sgjelinek } 3891865e09a4Sgjelinek source_zone = argv[optind]; 38929acbbeafSnn35248 if (sanity_check(target_zone, CMD_CLONE, B_FALSE, B_TRUE, B_FALSE) 38939acbbeafSnn35248 != Z_OK) 3894865e09a4Sgjelinek return (Z_ERR); 3895ce28b40eSzt129084 if (verify_details(CMD_CLONE, argv) != Z_OK) 3896865e09a4Sgjelinek return (Z_ERR); 3897865e09a4Sgjelinek 3898865e09a4Sgjelinek /* 3899865e09a4Sgjelinek * We also need to do some extra validation on the source zone. 3900865e09a4Sgjelinek */ 3901865e09a4Sgjelinek if (strcmp(source_zone, GLOBAL_ZONENAME) == 0) { 3902865e09a4Sgjelinek zerror(gettext("%s operation is invalid for the global zone."), 3903865e09a4Sgjelinek cmd_to_str(CMD_CLONE)); 3904865e09a4Sgjelinek return (Z_ERR); 3905865e09a4Sgjelinek } 3906865e09a4Sgjelinek 3907865e09a4Sgjelinek if (strncmp(source_zone, "SUNW", 4) == 0) { 3908865e09a4Sgjelinek zerror(gettext("%s operation is invalid for zones starting " 3909865e09a4Sgjelinek "with SUNW."), cmd_to_str(CMD_CLONE)); 3910865e09a4Sgjelinek return (Z_ERR); 3911865e09a4Sgjelinek } 3912865e09a4Sgjelinek 3913865e09a4Sgjelinek zent = lookup_running_zone(source_zone); 3914865e09a4Sgjelinek if (zent != NULL) { 3915865e09a4Sgjelinek /* check whether the zone is ready or running */ 3916865e09a4Sgjelinek if ((err = zone_get_state(zent->zname, &zent->zstate_num)) 3917865e09a4Sgjelinek != Z_OK) { 3918865e09a4Sgjelinek errno = err; 3919865e09a4Sgjelinek zperror2(zent->zname, gettext("could not get state")); 3920865e09a4Sgjelinek /* can't tell, so hedge */ 3921865e09a4Sgjelinek zent->zstate_str = "ready/running"; 3922865e09a4Sgjelinek } else { 3923865e09a4Sgjelinek zent->zstate_str = zone_state_str(zent->zstate_num); 3924865e09a4Sgjelinek } 3925865e09a4Sgjelinek zerror(gettext("%s operation is invalid for %s zones."), 3926865e09a4Sgjelinek cmd_to_str(CMD_CLONE), zent->zstate_str); 3927865e09a4Sgjelinek return (Z_ERR); 3928865e09a4Sgjelinek } 3929865e09a4Sgjelinek 3930865e09a4Sgjelinek if ((err = zone_get_state(source_zone, &state)) != Z_OK) { 3931865e09a4Sgjelinek errno = err; 3932865e09a4Sgjelinek zperror2(source_zone, gettext("could not get state")); 3933865e09a4Sgjelinek return (Z_ERR); 3934865e09a4Sgjelinek } 3935865e09a4Sgjelinek if (state != ZONE_STATE_INSTALLED) { 3936865e09a4Sgjelinek (void) fprintf(stderr, 3937865e09a4Sgjelinek gettext("%s: zone %s is %s; %s is required.\n"), 3938865e09a4Sgjelinek execname, source_zone, zone_state_str(state), 3939865e09a4Sgjelinek zone_state_str(ZONE_STATE_INSTALLED)); 3940865e09a4Sgjelinek return (Z_ERR); 3941865e09a4Sgjelinek } 3942865e09a4Sgjelinek 3943865e09a4Sgjelinek /* 3944865e09a4Sgjelinek * The source zone checks out ok, continue with the clone. 3945865e09a4Sgjelinek */ 3946865e09a4Sgjelinek 3947865e09a4Sgjelinek if (validate_clone(source_zone, target_zone) != Z_OK) 3948865e09a4Sgjelinek return (Z_ERR); 3949865e09a4Sgjelinek 3950865e09a4Sgjelinek if (grab_lock_file(target_zone, &lockfd) != Z_OK) { 3951865e09a4Sgjelinek zerror(gettext("another %s may have an operation in progress."), 3952865e09a4Sgjelinek "zoneadm"); 3953865e09a4Sgjelinek return (Z_ERR); 3954865e09a4Sgjelinek } 3955865e09a4Sgjelinek 3956865e09a4Sgjelinek if ((err = zone_get_zonepath(source_zone, source_zonepath, 3957865e09a4Sgjelinek sizeof (source_zonepath))) != Z_OK) { 3958865e09a4Sgjelinek errno = err; 3959865e09a4Sgjelinek zperror2(source_zone, gettext("could not get zone path")); 3960865e09a4Sgjelinek goto done; 3961865e09a4Sgjelinek } 3962865e09a4Sgjelinek 3963865e09a4Sgjelinek if ((err = zone_get_zonepath(target_zone, zonepath, sizeof (zonepath))) 3964865e09a4Sgjelinek != Z_OK) { 3965865e09a4Sgjelinek errno = err; 3966865e09a4Sgjelinek zperror2(target_zone, gettext("could not get zone path")); 3967865e09a4Sgjelinek goto done; 3968865e09a4Sgjelinek } 3969865e09a4Sgjelinek 3970865e09a4Sgjelinek if ((err = zone_set_state(target_zone, ZONE_STATE_INCOMPLETE)) 3971865e09a4Sgjelinek != Z_OK) { 3972865e09a4Sgjelinek errno = err; 3973865e09a4Sgjelinek zperror2(target_zone, gettext("could not set state")); 3974865e09a4Sgjelinek goto done; 3975865e09a4Sgjelinek } 3976865e09a4Sgjelinek 39770b5de56dSgjelinek if (snapshot != NULL) { 39780b5de56dSgjelinek err = clone_snapshot_zfs(snapshot, zonepath); 39790b5de56dSgjelinek } else { 39800b5de56dSgjelinek /* 39810b5de56dSgjelinek * We always copy the clone unless the source is ZFS and a 39820b5de56dSgjelinek * ZFS clone worked. We fallback to copying if the ZFS clone 39830b5de56dSgjelinek * fails for some reason. 39840b5de56dSgjelinek */ 39850b5de56dSgjelinek err = Z_ERR; 39860b5de56dSgjelinek if (method == NULL && is_zonepath_zfs(source_zonepath)) 39870b5de56dSgjelinek err = clone_zfs(source_zone, source_zonepath, zonepath); 3988865e09a4Sgjelinek 39895cd08338Sgjelinek if (err != Z_OK) 39900b5de56dSgjelinek err = clone_copy(source_zonepath, zonepath); 39910b5de56dSgjelinek } 3992865e09a4Sgjelinek 39939acbbeafSnn35248 /* 39949acbbeafSnn35248 * Trusted Extensions requires that cloned zones use the same sysid 39959acbbeafSnn35248 * configuration, so it is not appropriate to perform any 39969acbbeafSnn35248 * post-clone reconfiguration. 39979acbbeafSnn35248 */ 39989acbbeafSnn35248 if ((err == Z_OK) && !is_system_labeled()) 39999acbbeafSnn35248 err = zone_postclone(zonepath); 4000865e09a4Sgjelinek 4001865e09a4Sgjelinek done: 40029acbbeafSnn35248 /* 40039acbbeafSnn35248 * If everything went well, we mark the zone as installed. 40049acbbeafSnn35248 */ 40059acbbeafSnn35248 if (err == Z_OK) { 40069acbbeafSnn35248 err = zone_set_state(target_zone, ZONE_STATE_INSTALLED); 40079acbbeafSnn35248 if (err != Z_OK) { 40089acbbeafSnn35248 errno = err; 40099acbbeafSnn35248 zperror2(target_zone, gettext("could not set state")); 40109acbbeafSnn35248 } 40119acbbeafSnn35248 } 4012865e09a4Sgjelinek release_lock_file(lockfd); 4013865e09a4Sgjelinek return ((err == Z_OK) ? Z_OK : Z_ERR); 4014865e09a4Sgjelinek } 4015865e09a4Sgjelinek 401607b574eeSgjelinek /* 40170b5de56dSgjelinek * Used when removing a zonepath after uninstalling or cleaning up after 40180b5de56dSgjelinek * the move subcommand. This handles a zonepath that has non-standard 40190b5de56dSgjelinek * contents so that we will only cleanup the stuff we know about and leave 40200b5de56dSgjelinek * any user data alone. 402107b574eeSgjelinek * 40220b5de56dSgjelinek * If the "all" parameter is true then we should remove the whole zonepath 40230b5de56dSgjelinek * even if it has non-standard files/directories in it. This can be used when 40240b5de56dSgjelinek * we need to cleanup after moving the zonepath across file systems. 40250b5de56dSgjelinek * 40260b5de56dSgjelinek * We "exec" the RMCOMMAND so that the returned status is that of RMCOMMAND 40270b5de56dSgjelinek * and not the shell. 402807b574eeSgjelinek */ 402907b574eeSgjelinek static int 40300b5de56dSgjelinek cleanup_zonepath(char *zonepath, boolean_t all) 403107b574eeSgjelinek { 403207b574eeSgjelinek int status; 40330b5de56dSgjelinek int i; 40340b5de56dSgjelinek boolean_t non_std = B_FALSE; 40350b5de56dSgjelinek struct dirent *dp; 40360b5de56dSgjelinek DIR *dirp; 4037d9e728a2Sgjelinek /* 4038d9e728a2Sgjelinek * The SUNWattached.xml file is expected since it might 4039d9e728a2Sgjelinek * exist if the zone was force-attached after a 4040d9e728a2Sgjelinek * migration. 4041d9e728a2Sgjelinek */ 4042d9e728a2Sgjelinek char *std_entries[] = {"dev", "lu", "root", 4043d9e728a2Sgjelinek "SUNWattached.xml", NULL}; 40440b5de56dSgjelinek /* (MAXPATHLEN * 3) is for the 3 std_entries dirs */ 40450b5de56dSgjelinek char cmdbuf[sizeof (RMCOMMAND) + (MAXPATHLEN * 3) + 64]; 404607b574eeSgjelinek 404707b574eeSgjelinek /* 40480b5de56dSgjelinek * We shouldn't need these checks but lets be paranoid since we 40490b5de56dSgjelinek * could blow away the whole system here if we got the wrong zonepath. 405007b574eeSgjelinek */ 40510b5de56dSgjelinek if (*zonepath == NULL || strcmp(zonepath, "/") == 0) { 40520b5de56dSgjelinek (void) fprintf(stderr, "invalid zonepath '%s'\n", zonepath); 40530b5de56dSgjelinek return (Z_INVAL); 40540b5de56dSgjelinek } 40550b5de56dSgjelinek 405607b574eeSgjelinek /* 40570b5de56dSgjelinek * If the dirpath is already gone (maybe it was manually removed) then 40580b5de56dSgjelinek * we just return Z_OK so that the cleanup is successful. 405907b574eeSgjelinek */ 40600b5de56dSgjelinek if ((dirp = opendir(zonepath)) == NULL) 40610b5de56dSgjelinek return (Z_OK); 40620b5de56dSgjelinek 40630b5de56dSgjelinek /* 40640b5de56dSgjelinek * Look through the zonepath directory to see if there are any 40650b5de56dSgjelinek * non-standard files/dirs. Also skip .zfs since that might be 40660b5de56dSgjelinek * there but we'll handle ZFS file systems as a special case. 40670b5de56dSgjelinek */ 40680b5de56dSgjelinek while ((dp = readdir(dirp)) != NULL) { 40690b5de56dSgjelinek if (strcmp(dp->d_name, ".") == 0 || 40700b5de56dSgjelinek strcmp(dp->d_name, "..") == 0 || 40710b5de56dSgjelinek strcmp(dp->d_name, ".zfs") == 0) 40720b5de56dSgjelinek continue; 40730b5de56dSgjelinek 40740b5de56dSgjelinek for (i = 0; std_entries[i] != NULL; i++) 40750b5de56dSgjelinek if (strcmp(dp->d_name, std_entries[i]) == 0) 40760b5de56dSgjelinek break; 40770b5de56dSgjelinek 40780b5de56dSgjelinek if (std_entries[i] == NULL) 40790b5de56dSgjelinek non_std = B_TRUE; 40800b5de56dSgjelinek } 40810b5de56dSgjelinek (void) closedir(dirp); 40820b5de56dSgjelinek 40830b5de56dSgjelinek if (!all && non_std) { 40840b5de56dSgjelinek /* 40850b5de56dSgjelinek * There are extra, non-standard directories/files in the 40860b5de56dSgjelinek * zonepath so we don't want to remove the zonepath. We 40870b5de56dSgjelinek * just want to remove the standard directories and leave 40880b5de56dSgjelinek * the user data alone. 40890b5de56dSgjelinek */ 40900b5de56dSgjelinek (void) snprintf(cmdbuf, sizeof (cmdbuf), "exec " RMCOMMAND); 40910b5de56dSgjelinek 40920b5de56dSgjelinek for (i = 0; std_entries[i] != NULL; i++) { 40930b5de56dSgjelinek char tmpbuf[MAXPATHLEN]; 40940b5de56dSgjelinek 40950b5de56dSgjelinek if (snprintf(tmpbuf, sizeof (tmpbuf), " %s/%s", 40960b5de56dSgjelinek zonepath, std_entries[i]) >= sizeof (tmpbuf) || 40970b5de56dSgjelinek strlcat(cmdbuf, tmpbuf, sizeof (cmdbuf)) >= 40980b5de56dSgjelinek sizeof (cmdbuf)) { 40990b5de56dSgjelinek (void) fprintf(stderr, 41000b5de56dSgjelinek gettext("path is too long\n")); 41010b5de56dSgjelinek return (Z_INVAL); 41020b5de56dSgjelinek } 410307b574eeSgjelinek } 410407b574eeSgjelinek 410507b574eeSgjelinek status = do_subproc(cmdbuf); 410607b574eeSgjelinek 41070b5de56dSgjelinek (void) fprintf(stderr, gettext("WARNING: Unable to completely " 41080b5de56dSgjelinek "remove %s\nbecause it contains additional user data. " 41090b5de56dSgjelinek "Only the standard directory\nentries have been " 41100b5de56dSgjelinek "removed.\n"), 41110b5de56dSgjelinek zonepath); 411207b574eeSgjelinek 41139acbbeafSnn35248 return ((subproc_status(RMCOMMAND, status, B_TRUE) == 41149acbbeafSnn35248 ZONE_SUBPROC_OK) ? Z_OK : Z_ERR); 41150b5de56dSgjelinek } 41160b5de56dSgjelinek 41170b5de56dSgjelinek /* 41180b5de56dSgjelinek * There is nothing unexpected in the zonepath, try to get rid of the 41190b5de56dSgjelinek * whole zonepath directory. 41200b5de56dSgjelinek * 41210b5de56dSgjelinek * If the zonepath is its own zfs file system, try to destroy the 41220b5de56dSgjelinek * file system. If that fails for some reason (e.g. it has clones) 41230b5de56dSgjelinek * then we'll just remove the contents of the zonepath. 41240b5de56dSgjelinek */ 41250b5de56dSgjelinek if (is_zonepath_zfs(zonepath)) { 41260b5de56dSgjelinek if (destroy_zfs(zonepath) == Z_OK) 41270b5de56dSgjelinek return (Z_OK); 41280b5de56dSgjelinek (void) snprintf(cmdbuf, sizeof (cmdbuf), "exec " RMCOMMAND 41290b5de56dSgjelinek " %s/*", zonepath); 41300b5de56dSgjelinek status = do_subproc(cmdbuf); 41319acbbeafSnn35248 return ((subproc_status(RMCOMMAND, status, B_TRUE) == 41329acbbeafSnn35248 ZONE_SUBPROC_OK) ? Z_OK : Z_ERR); 41330b5de56dSgjelinek } 41340b5de56dSgjelinek 41350b5de56dSgjelinek (void) snprintf(cmdbuf, sizeof (cmdbuf), "exec " RMCOMMAND " %s", 41360b5de56dSgjelinek zonepath); 41370b5de56dSgjelinek status = do_subproc(cmdbuf); 41389acbbeafSnn35248 41399acbbeafSnn35248 return ((subproc_status(RMCOMMAND, status, B_TRUE) == ZONE_SUBPROC_OK) 41409acbbeafSnn35248 ? Z_OK : Z_ERR); 414107b574eeSgjelinek } 414207b574eeSgjelinek 4143865e09a4Sgjelinek static int 4144865e09a4Sgjelinek move_func(int argc, char *argv[]) 4145865e09a4Sgjelinek { 4146865e09a4Sgjelinek char *new_zonepath = NULL; 4147865e09a4Sgjelinek int lockfd; 4148865e09a4Sgjelinek int err, arg; 4149865e09a4Sgjelinek char zonepath[MAXPATHLEN]; 4150865e09a4Sgjelinek zone_dochandle_t handle; 4151865e09a4Sgjelinek boolean_t fast; 41520b5de56dSgjelinek boolean_t is_zfs = B_FALSE; 41530b5de56dSgjelinek struct dirent *dp; 41540b5de56dSgjelinek DIR *dirp; 41550b5de56dSgjelinek boolean_t empty = B_TRUE; 4156865e09a4Sgjelinek boolean_t revert; 4157865e09a4Sgjelinek struct stat zonepath_buf; 4158865e09a4Sgjelinek struct stat new_zonepath_buf; 4159865e09a4Sgjelinek 4160865e09a4Sgjelinek if (zonecfg_in_alt_root()) { 4161865e09a4Sgjelinek zerror(gettext("cannot move zone in alternate root")); 4162865e09a4Sgjelinek return (Z_ERR); 4163865e09a4Sgjelinek } 4164865e09a4Sgjelinek 4165865e09a4Sgjelinek optind = 0; 4166865e09a4Sgjelinek if ((arg = getopt(argc, argv, "?")) != EOF) { 4167865e09a4Sgjelinek switch (arg) { 4168865e09a4Sgjelinek case '?': 4169865e09a4Sgjelinek sub_usage(SHELP_MOVE, CMD_MOVE); 4170865e09a4Sgjelinek return (optopt == '?' ? Z_OK : Z_USAGE); 4171865e09a4Sgjelinek default: 4172865e09a4Sgjelinek sub_usage(SHELP_MOVE, CMD_MOVE); 4173865e09a4Sgjelinek return (Z_USAGE); 4174865e09a4Sgjelinek } 4175865e09a4Sgjelinek } 4176865e09a4Sgjelinek if (argc != (optind + 1)) { 4177865e09a4Sgjelinek sub_usage(SHELP_MOVE, CMD_MOVE); 4178865e09a4Sgjelinek return (Z_USAGE); 4179865e09a4Sgjelinek } 4180865e09a4Sgjelinek new_zonepath = argv[optind]; 41819acbbeafSnn35248 if (sanity_check(target_zone, CMD_MOVE, B_FALSE, B_TRUE, B_FALSE) 41829acbbeafSnn35248 != Z_OK) 4183865e09a4Sgjelinek return (Z_ERR); 4184ce28b40eSzt129084 if (verify_details(CMD_MOVE, argv) != Z_OK) 4185865e09a4Sgjelinek return (Z_ERR); 4186865e09a4Sgjelinek 4187865e09a4Sgjelinek /* 4188865e09a4Sgjelinek * Check out the new zonepath. This has the side effect of creating 4189865e09a4Sgjelinek * a directory for the new zonepath. We depend on this later when we 41900b5de56dSgjelinek * stat to see if we are doing a cross file system move or not. 4191865e09a4Sgjelinek */ 4192865e09a4Sgjelinek if (validate_zonepath(new_zonepath, CMD_MOVE) != Z_OK) 4193865e09a4Sgjelinek return (Z_ERR); 4194865e09a4Sgjelinek 4195865e09a4Sgjelinek if ((err = zone_get_zonepath(target_zone, zonepath, sizeof (zonepath))) 4196865e09a4Sgjelinek != Z_OK) { 4197865e09a4Sgjelinek errno = err; 4198865e09a4Sgjelinek zperror2(target_zone, gettext("could not get zone path")); 4199865e09a4Sgjelinek return (Z_ERR); 4200865e09a4Sgjelinek } 4201865e09a4Sgjelinek 4202865e09a4Sgjelinek if (stat(zonepath, &zonepath_buf) == -1) { 4203865e09a4Sgjelinek zperror(gettext("could not stat zone path"), B_FALSE); 4204865e09a4Sgjelinek return (Z_ERR); 4205865e09a4Sgjelinek } 4206865e09a4Sgjelinek 4207865e09a4Sgjelinek if (stat(new_zonepath, &new_zonepath_buf) == -1) { 4208865e09a4Sgjelinek zperror(gettext("could not stat new zone path"), B_FALSE); 4209865e09a4Sgjelinek return (Z_ERR); 4210865e09a4Sgjelinek } 4211865e09a4Sgjelinek 42120b5de56dSgjelinek /* 42130b5de56dSgjelinek * Check if the destination directory is empty. 42140b5de56dSgjelinek */ 42150b5de56dSgjelinek if ((dirp = opendir(new_zonepath)) == NULL) { 42160b5de56dSgjelinek zperror(gettext("could not open new zone path"), B_FALSE); 42170b5de56dSgjelinek return (Z_ERR); 42180b5de56dSgjelinek } 42190b5de56dSgjelinek while ((dp = readdir(dirp)) != (struct dirent *)0) { 42200b5de56dSgjelinek if (strcmp(dp->d_name, ".") == 0 || 42210b5de56dSgjelinek strcmp(dp->d_name, "..") == 0) 42220b5de56dSgjelinek continue; 42230b5de56dSgjelinek empty = B_FALSE; 42240b5de56dSgjelinek break; 42250b5de56dSgjelinek } 42260b5de56dSgjelinek (void) closedir(dirp); 42270b5de56dSgjelinek 42280b5de56dSgjelinek /* Error if there is anything in the destination directory. */ 42290b5de56dSgjelinek if (!empty) { 42300b5de56dSgjelinek (void) fprintf(stderr, gettext("could not move zone to %s: " 42310b5de56dSgjelinek "directory not empty\n"), new_zonepath); 42320b5de56dSgjelinek return (Z_ERR); 42330b5de56dSgjelinek } 42340b5de56dSgjelinek 4235865e09a4Sgjelinek /* Don't move the zone if anything is still mounted there */ 4236865e09a4Sgjelinek if (zonecfg_find_mounts(zonepath, NULL, NULL)) { 42370b5de56dSgjelinek zerror(gettext("These file systems are mounted on " 4238865e09a4Sgjelinek "subdirectories of %s.\n"), zonepath); 4239865e09a4Sgjelinek (void) zonecfg_find_mounts(zonepath, zfm_print, NULL); 4240865e09a4Sgjelinek return (Z_ERR); 4241865e09a4Sgjelinek } 4242865e09a4Sgjelinek 4243865e09a4Sgjelinek /* 4244865e09a4Sgjelinek * Check if we are moving in the same file system and can do a fast 4245865e09a4Sgjelinek * move or if we are crossing file systems and have to copy the data. 4246865e09a4Sgjelinek */ 4247865e09a4Sgjelinek fast = (zonepath_buf.st_dev == new_zonepath_buf.st_dev); 4248865e09a4Sgjelinek 4249865e09a4Sgjelinek if ((handle = zonecfg_init_handle()) == NULL) { 4250865e09a4Sgjelinek zperror(cmd_to_str(CMD_MOVE), B_TRUE); 4251865e09a4Sgjelinek return (Z_ERR); 4252865e09a4Sgjelinek } 4253865e09a4Sgjelinek 4254865e09a4Sgjelinek if ((err = zonecfg_get_handle(target_zone, handle)) != Z_OK) { 4255865e09a4Sgjelinek errno = err; 4256865e09a4Sgjelinek zperror(cmd_to_str(CMD_MOVE), B_TRUE); 4257865e09a4Sgjelinek zonecfg_fini_handle(handle); 4258865e09a4Sgjelinek return (Z_ERR); 4259865e09a4Sgjelinek } 4260865e09a4Sgjelinek 4261865e09a4Sgjelinek if (grab_lock_file(target_zone, &lockfd) != Z_OK) { 4262865e09a4Sgjelinek zerror(gettext("another %s may have an operation in progress."), 4263865e09a4Sgjelinek "zoneadm"); 4264865e09a4Sgjelinek zonecfg_fini_handle(handle); 4265865e09a4Sgjelinek return (Z_ERR); 4266865e09a4Sgjelinek } 4267865e09a4Sgjelinek 4268865e09a4Sgjelinek /* 42690b5de56dSgjelinek * We're making some file system changes now so we have to clean up 42700b5de56dSgjelinek * the file system before we are done. This will either clean up the 4271865e09a4Sgjelinek * new zonepath if the zonecfg update failed or it will clean up the 4272865e09a4Sgjelinek * old zonepath if everything is ok. 4273865e09a4Sgjelinek */ 4274865e09a4Sgjelinek revert = B_TRUE; 4275865e09a4Sgjelinek 42760b5de56dSgjelinek if (is_zonepath_zfs(zonepath) && 42770b5de56dSgjelinek move_zfs(zonepath, new_zonepath) != Z_ERR) { 42780b5de56dSgjelinek is_zfs = B_TRUE; 42790b5de56dSgjelinek 42800b5de56dSgjelinek } else if (fast) { 4281865e09a4Sgjelinek /* same file system, use rename for a quick move */ 4282865e09a4Sgjelinek 4283865e09a4Sgjelinek /* 4284865e09a4Sgjelinek * Remove the new_zonepath directory that got created above 4285865e09a4Sgjelinek * during the validation. It gets in the way of the rename. 4286865e09a4Sgjelinek */ 4287865e09a4Sgjelinek if (rmdir(new_zonepath) != 0) { 4288865e09a4Sgjelinek zperror(gettext("could not rmdir new zone path"), 4289865e09a4Sgjelinek B_FALSE); 4290865e09a4Sgjelinek zonecfg_fini_handle(handle); 4291865e09a4Sgjelinek release_lock_file(lockfd); 4292865e09a4Sgjelinek return (Z_ERR); 4293865e09a4Sgjelinek } 4294865e09a4Sgjelinek 4295865e09a4Sgjelinek if (rename(zonepath, new_zonepath) != 0) { 4296865e09a4Sgjelinek /* 4297865e09a4Sgjelinek * If this fails we don't need to do all of the 4298865e09a4Sgjelinek * cleanup that happens for the rest of the code 4299865e09a4Sgjelinek * so just return from this error. 4300865e09a4Sgjelinek */ 4301865e09a4Sgjelinek zperror(gettext("could not move zone"), B_FALSE); 4302865e09a4Sgjelinek zonecfg_fini_handle(handle); 4303865e09a4Sgjelinek release_lock_file(lockfd); 4304865e09a4Sgjelinek return (Z_ERR); 4305865e09a4Sgjelinek } 4306865e09a4Sgjelinek 4307865e09a4Sgjelinek } else { 43080b5de56dSgjelinek /* 43090b5de56dSgjelinek * Attempt to create a ZFS fs for the new zonepath. As usual, 43100b5de56dSgjelinek * we don't care if this works or not since we always have the 43110b5de56dSgjelinek * default behavior of a simple directory for the zonepath. 43120b5de56dSgjelinek */ 43130b5de56dSgjelinek create_zfs_zonepath(new_zonepath); 43140b5de56dSgjelinek 4315865e09a4Sgjelinek (void) printf(gettext( 43160b5de56dSgjelinek "Moving across file systems; copying zonepath %s..."), 4317865e09a4Sgjelinek zonepath); 4318865e09a4Sgjelinek (void) fflush(stdout); 4319865e09a4Sgjelinek 4320865e09a4Sgjelinek err = copy_zone(zonepath, new_zonepath); 4321865e09a4Sgjelinek 4322865e09a4Sgjelinek (void) printf("\n"); 4323865e09a4Sgjelinek if (err != Z_OK) 4324865e09a4Sgjelinek goto done; 4325865e09a4Sgjelinek } 4326865e09a4Sgjelinek 4327865e09a4Sgjelinek if ((err = zonecfg_set_zonepath(handle, new_zonepath)) != Z_OK) { 4328865e09a4Sgjelinek errno = err; 4329865e09a4Sgjelinek zperror(gettext("could not set new zonepath"), B_TRUE); 4330865e09a4Sgjelinek goto done; 4331865e09a4Sgjelinek } 4332865e09a4Sgjelinek 4333865e09a4Sgjelinek if ((err = zonecfg_save(handle)) != Z_OK) { 4334865e09a4Sgjelinek errno = err; 4335865e09a4Sgjelinek zperror(gettext("zonecfg save failed"), B_TRUE); 4336865e09a4Sgjelinek goto done; 4337865e09a4Sgjelinek } 4338865e09a4Sgjelinek 4339865e09a4Sgjelinek revert = B_FALSE; 4340865e09a4Sgjelinek 4341865e09a4Sgjelinek done: 4342865e09a4Sgjelinek zonecfg_fini_handle(handle); 4343865e09a4Sgjelinek release_lock_file(lockfd); 4344865e09a4Sgjelinek 4345865e09a4Sgjelinek /* 43460b5de56dSgjelinek * Clean up the file system based on how things went. We either 4347865e09a4Sgjelinek * clean up the new zonepath if the operation failed for some reason 4348865e09a4Sgjelinek * or we clean up the old zonepath if everything is ok. 4349865e09a4Sgjelinek */ 4350865e09a4Sgjelinek if (revert) { 4351865e09a4Sgjelinek /* The zonecfg update failed, cleanup the new zonepath. */ 43520b5de56dSgjelinek if (is_zfs) { 43530b5de56dSgjelinek if (move_zfs(new_zonepath, zonepath) == Z_ERR) { 43540b5de56dSgjelinek (void) fprintf(stderr, gettext("could not " 43550b5de56dSgjelinek "restore zonepath, the zfs mountpoint is " 43560b5de56dSgjelinek "set as:\n%s\n"), new_zonepath); 43570b5de56dSgjelinek /* 43580b5de56dSgjelinek * err is already != Z_OK since we're reverting 43590b5de56dSgjelinek */ 43600b5de56dSgjelinek } 43610b5de56dSgjelinek 43620b5de56dSgjelinek } else if (fast) { 4363865e09a4Sgjelinek if (rename(new_zonepath, zonepath) != 0) { 4364865e09a4Sgjelinek zperror(gettext("could not restore zonepath"), 4365865e09a4Sgjelinek B_FALSE); 4366865e09a4Sgjelinek /* 4367865e09a4Sgjelinek * err is already != Z_OK since we're reverting 4368865e09a4Sgjelinek */ 4369865e09a4Sgjelinek } 4370865e09a4Sgjelinek } else { 4371865e09a4Sgjelinek (void) printf(gettext("Cleaning up zonepath %s..."), 4372865e09a4Sgjelinek new_zonepath); 4373865e09a4Sgjelinek (void) fflush(stdout); 43740b5de56dSgjelinek err = cleanup_zonepath(new_zonepath, B_TRUE); 4375865e09a4Sgjelinek (void) printf("\n"); 4376865e09a4Sgjelinek 437707b574eeSgjelinek if (err != Z_OK) { 4378865e09a4Sgjelinek errno = err; 4379865e09a4Sgjelinek zperror(gettext("could not remove new " 4380865e09a4Sgjelinek "zonepath"), B_TRUE); 4381865e09a4Sgjelinek } else { 4382865e09a4Sgjelinek /* 4383865e09a4Sgjelinek * Because we're reverting we know the mainline 4384865e09a4Sgjelinek * code failed but we just reused the err 4385865e09a4Sgjelinek * variable so we reset it back to Z_ERR. 4386865e09a4Sgjelinek */ 4387865e09a4Sgjelinek err = Z_ERR; 4388865e09a4Sgjelinek } 4389865e09a4Sgjelinek } 4390865e09a4Sgjelinek 4391865e09a4Sgjelinek } else { 4392865e09a4Sgjelinek /* The move was successful, cleanup the old zonepath. */ 43930b5de56dSgjelinek if (!is_zfs && !fast) { 4394865e09a4Sgjelinek (void) printf( 4395865e09a4Sgjelinek gettext("Cleaning up zonepath %s..."), zonepath); 4396865e09a4Sgjelinek (void) fflush(stdout); 43970b5de56dSgjelinek err = cleanup_zonepath(zonepath, B_TRUE); 4398865e09a4Sgjelinek (void) printf("\n"); 4399865e09a4Sgjelinek 440007b574eeSgjelinek if (err != Z_OK) { 4401865e09a4Sgjelinek errno = err; 4402865e09a4Sgjelinek zperror(gettext("could not remove zonepath"), 4403865e09a4Sgjelinek B_TRUE); 4404865e09a4Sgjelinek } 4405865e09a4Sgjelinek } 4406865e09a4Sgjelinek } 4407865e09a4Sgjelinek 4408865e09a4Sgjelinek return ((err == Z_OK) ? Z_OK : Z_ERR); 4409865e09a4Sgjelinek } 4410865e09a4Sgjelinek 4411ee519a1fSgjelinek static int 4412ee519a1fSgjelinek detach_func(int argc, char *argv[]) 4413ee519a1fSgjelinek { 4414ee519a1fSgjelinek int lockfd; 4415ee519a1fSgjelinek int err, arg; 4416ee519a1fSgjelinek char zonepath[MAXPATHLEN]; 4417ee519a1fSgjelinek zone_dochandle_t handle; 44188cd327d5Sgjelinek boolean_t execute = B_TRUE; 4419ee519a1fSgjelinek 4420ee519a1fSgjelinek if (zonecfg_in_alt_root()) { 4421ee519a1fSgjelinek zerror(gettext("cannot detach zone in alternate root")); 4422ee519a1fSgjelinek return (Z_ERR); 4423ee519a1fSgjelinek } 4424ee519a1fSgjelinek 4425ee519a1fSgjelinek optind = 0; 44268cd327d5Sgjelinek if ((arg = getopt(argc, argv, "?n")) != EOF) { 4427ee519a1fSgjelinek switch (arg) { 4428ee519a1fSgjelinek case '?': 4429ee519a1fSgjelinek sub_usage(SHELP_DETACH, CMD_DETACH); 4430ee519a1fSgjelinek return (optopt == '?' ? Z_OK : Z_USAGE); 44318cd327d5Sgjelinek case 'n': 44328cd327d5Sgjelinek execute = B_FALSE; 44338cd327d5Sgjelinek break; 4434ee519a1fSgjelinek default: 4435ee519a1fSgjelinek sub_usage(SHELP_DETACH, CMD_DETACH); 4436ee519a1fSgjelinek return (Z_USAGE); 4437ee519a1fSgjelinek } 4438ee519a1fSgjelinek } 44399acbbeafSnn35248 44408cd327d5Sgjelinek if (execute) { 44419acbbeafSnn35248 if (sanity_check(target_zone, CMD_DETACH, B_FALSE, B_TRUE, 44429acbbeafSnn35248 B_FALSE) != Z_OK) 4443ee519a1fSgjelinek return (Z_ERR); 4444ce28b40eSzt129084 if (verify_details(CMD_DETACH, argv) != Z_OK) 4445ee519a1fSgjelinek return (Z_ERR); 44468cd327d5Sgjelinek } else { 44478cd327d5Sgjelinek /* 44488cd327d5Sgjelinek * We want a dry-run to work for a non-privileged user so we 44498cd327d5Sgjelinek * only do minimal validation. 44508cd327d5Sgjelinek */ 44518cd327d5Sgjelinek if (target_zone == NULL) { 44528cd327d5Sgjelinek zerror(gettext("no zone specified")); 44538cd327d5Sgjelinek return (Z_ERR); 44548cd327d5Sgjelinek } 44558cd327d5Sgjelinek 44568cd327d5Sgjelinek if (strcmp(target_zone, GLOBAL_ZONENAME) == 0) { 44578cd327d5Sgjelinek zerror(gettext("%s operation is invalid for the " 44588cd327d5Sgjelinek "global zone."), cmd_to_str(CMD_DETACH)); 44598cd327d5Sgjelinek return (Z_ERR); 44608cd327d5Sgjelinek } 44618cd327d5Sgjelinek } 4462ee519a1fSgjelinek 4463ee519a1fSgjelinek if ((err = zone_get_zonepath(target_zone, zonepath, sizeof (zonepath))) 4464ee519a1fSgjelinek != Z_OK) { 4465ee519a1fSgjelinek errno = err; 4466ee519a1fSgjelinek zperror2(target_zone, gettext("could not get zone path")); 4467ee519a1fSgjelinek return (Z_ERR); 4468ee519a1fSgjelinek } 4469ee519a1fSgjelinek 4470ee519a1fSgjelinek /* Don't detach the zone if anything is still mounted there */ 44718cd327d5Sgjelinek if (execute && zonecfg_find_mounts(zonepath, NULL, NULL)) { 44720b5de56dSgjelinek zerror(gettext("These file systems are mounted on " 4473ee519a1fSgjelinek "subdirectories of %s.\n"), zonepath); 4474ee519a1fSgjelinek (void) zonecfg_find_mounts(zonepath, zfm_print, NULL); 4475ee519a1fSgjelinek return (Z_ERR); 4476ee519a1fSgjelinek } 4477ee519a1fSgjelinek 4478ee519a1fSgjelinek if ((handle = zonecfg_init_handle()) == NULL) { 4479ee519a1fSgjelinek zperror(cmd_to_str(CMD_DETACH), B_TRUE); 4480ee519a1fSgjelinek return (Z_ERR); 4481ee519a1fSgjelinek } 4482ee519a1fSgjelinek 4483ee519a1fSgjelinek if ((err = zonecfg_get_handle(target_zone, handle)) != Z_OK) { 4484ee519a1fSgjelinek errno = err; 4485ee519a1fSgjelinek zperror(cmd_to_str(CMD_DETACH), B_TRUE); 4486ee519a1fSgjelinek zonecfg_fini_handle(handle); 4487ee519a1fSgjelinek return (Z_ERR); 4488ee519a1fSgjelinek } 4489ee519a1fSgjelinek 44908cd327d5Sgjelinek if (execute && grab_lock_file(target_zone, &lockfd) != Z_OK) { 4491ee519a1fSgjelinek zerror(gettext("another %s may have an operation in progress."), 4492ee519a1fSgjelinek "zoneadm"); 4493ee519a1fSgjelinek zonecfg_fini_handle(handle); 4494ee519a1fSgjelinek return (Z_ERR); 4495ee519a1fSgjelinek } 4496ee519a1fSgjelinek 4497ee519a1fSgjelinek if ((err = zonecfg_get_detach_info(handle, B_TRUE)) != Z_OK) { 4498ee519a1fSgjelinek errno = err; 4499ee519a1fSgjelinek zperror(gettext("getting the detach information failed"), 4500ee519a1fSgjelinek B_TRUE); 4501ee519a1fSgjelinek goto done; 4502ee519a1fSgjelinek } 4503ee519a1fSgjelinek 45048cd327d5Sgjelinek if ((err = zonecfg_detach_save(handle, (execute ? 0 : ZONE_DRY_RUN))) 45058cd327d5Sgjelinek != Z_OK) { 4506ee519a1fSgjelinek errno = err; 4507ee519a1fSgjelinek zperror(gettext("saving the detach manifest failed"), B_TRUE); 4508ee519a1fSgjelinek goto done; 4509ee519a1fSgjelinek } 4510ee519a1fSgjelinek 45118cd327d5Sgjelinek /* 45128cd327d5Sgjelinek * Set the zone state back to configured unless we are running with the 45138cd327d5Sgjelinek * no-execute option. 45148cd327d5Sgjelinek */ 45158cd327d5Sgjelinek if (execute && (err = zone_set_state(target_zone, 45168cd327d5Sgjelinek ZONE_STATE_CONFIGURED)) != Z_OK) { 4517ee519a1fSgjelinek errno = err; 4518ee519a1fSgjelinek zperror(gettext("could not reset state"), B_TRUE); 4519ee519a1fSgjelinek } 4520ee519a1fSgjelinek 4521ee519a1fSgjelinek done: 4522ee519a1fSgjelinek zonecfg_fini_handle(handle); 45238cd327d5Sgjelinek if (execute) 4524ee519a1fSgjelinek release_lock_file(lockfd); 4525ee519a1fSgjelinek 4526ee519a1fSgjelinek return ((err == Z_OK) ? Z_OK : Z_ERR); 4527ee519a1fSgjelinek } 4528ee519a1fSgjelinek 4529ee519a1fSgjelinek /* 4530ee519a1fSgjelinek * During attach we go through and fix up the /dev entries for the zone 4531ee519a1fSgjelinek * we are attaching. In order to regenerate /dev with the correct devices, 4532ee519a1fSgjelinek * the old /dev will be removed, the zone readied (which generates a new 4533ee519a1fSgjelinek * /dev) then halted, then we use the info from the manifest to update 4534ee519a1fSgjelinek * the modes, owners, etc. on the new /dev. 4535ee519a1fSgjelinek */ 4536ee519a1fSgjelinek static int 4537ee519a1fSgjelinek dev_fix(zone_dochandle_t handle) 4538ee519a1fSgjelinek { 4539ee519a1fSgjelinek int res; 4540ee519a1fSgjelinek int err; 4541ee519a1fSgjelinek int status; 4542ee519a1fSgjelinek struct zone_devpermtab devtab; 4543ee519a1fSgjelinek zone_cmd_arg_t zarg; 4544ee519a1fSgjelinek char devpath[MAXPATHLEN]; 4545ee519a1fSgjelinek /* 6: "exec " and " " */ 4546ee519a1fSgjelinek char cmdbuf[sizeof (RMCOMMAND) + MAXPATHLEN + 6]; 4547ee519a1fSgjelinek 4548ee519a1fSgjelinek if ((res = zonecfg_get_zonepath(handle, devpath, sizeof (devpath))) 4549ee519a1fSgjelinek != Z_OK) 4550ee519a1fSgjelinek return (res); 4551ee519a1fSgjelinek 4552ee519a1fSgjelinek if (strlcat(devpath, "/dev", sizeof (devpath)) >= sizeof (devpath)) 4553ee519a1fSgjelinek return (Z_TOO_BIG); 4554ee519a1fSgjelinek 4555ee519a1fSgjelinek /* 4556ee519a1fSgjelinek * "exec" the command so that the returned status is that of 4557ee519a1fSgjelinek * RMCOMMAND and not the shell. 4558ee519a1fSgjelinek */ 45599acbbeafSnn35248 (void) snprintf(cmdbuf, sizeof (cmdbuf), EXEC_PREFIX RMCOMMAND " %s", 4560ee519a1fSgjelinek devpath); 4561ee519a1fSgjelinek status = do_subproc(cmdbuf); 45629acbbeafSnn35248 if ((err = subproc_status(RMCOMMAND, status, B_TRUE)) != 45639acbbeafSnn35248 ZONE_SUBPROC_OK) { 4564ee519a1fSgjelinek (void) fprintf(stderr, 4565ee519a1fSgjelinek gettext("could not remove existing /dev\n")); 4566ee519a1fSgjelinek return (Z_ERR); 4567ee519a1fSgjelinek } 4568ee519a1fSgjelinek 4569ee519a1fSgjelinek /* In order to ready the zone, it must be in the installed state */ 4570ee519a1fSgjelinek if ((err = zone_set_state(target_zone, ZONE_STATE_INSTALLED)) != Z_OK) { 4571ee519a1fSgjelinek errno = err; 4572ee519a1fSgjelinek zperror(gettext("could not reset state"), B_TRUE); 4573ee519a1fSgjelinek return (Z_ERR); 4574ee519a1fSgjelinek } 4575ee519a1fSgjelinek 4576ee519a1fSgjelinek /* We have to ready the zone to regen the dev tree */ 4577ee519a1fSgjelinek zarg.cmd = Z_READY; 4578ee519a1fSgjelinek if (call_zoneadmd(target_zone, &zarg) != 0) { 4579ee519a1fSgjelinek zerror(gettext("call to %s failed"), "zoneadmd"); 45800209230bSgjelinek /* attempt to restore zone to configured state */ 45810209230bSgjelinek (void) zone_set_state(target_zone, ZONE_STATE_CONFIGURED); 4582ee519a1fSgjelinek return (Z_ERR); 4583ee519a1fSgjelinek } 4584ee519a1fSgjelinek 4585ee519a1fSgjelinek zarg.cmd = Z_HALT; 4586ee519a1fSgjelinek if (call_zoneadmd(target_zone, &zarg) != 0) { 4587ee519a1fSgjelinek zerror(gettext("call to %s failed"), "zoneadmd"); 45880209230bSgjelinek /* attempt to restore zone to configured state */ 45890209230bSgjelinek (void) zone_set_state(target_zone, ZONE_STATE_CONFIGURED); 4590ee519a1fSgjelinek return (Z_ERR); 4591ee519a1fSgjelinek } 4592ee519a1fSgjelinek 45930209230bSgjelinek /* attempt to restore zone to configured state */ 45940209230bSgjelinek (void) zone_set_state(target_zone, ZONE_STATE_CONFIGURED); 45950209230bSgjelinek 4596ee519a1fSgjelinek if (zonecfg_setdevperment(handle) != Z_OK) { 4597ee519a1fSgjelinek (void) fprintf(stderr, 4598ee519a1fSgjelinek gettext("unable to enumerate device entries\n")); 4599ee519a1fSgjelinek return (Z_ERR); 4600ee519a1fSgjelinek } 4601ee519a1fSgjelinek 4602ee519a1fSgjelinek while (zonecfg_getdevperment(handle, &devtab) == Z_OK) { 4603ee519a1fSgjelinek int err; 4604ee519a1fSgjelinek 4605ee519a1fSgjelinek if ((err = zonecfg_devperms_apply(handle, 4606ee519a1fSgjelinek devtab.zone_devperm_name, devtab.zone_devperm_uid, 4607ee519a1fSgjelinek devtab.zone_devperm_gid, devtab.zone_devperm_mode, 4608ee519a1fSgjelinek devtab.zone_devperm_acl)) != Z_OK && err != Z_INVAL) 4609ee519a1fSgjelinek (void) fprintf(stderr, gettext("error updating device " 4610ee519a1fSgjelinek "%s: %s\n"), devtab.zone_devperm_name, 4611ee519a1fSgjelinek zonecfg_strerror(err)); 4612ee519a1fSgjelinek 4613ee519a1fSgjelinek free(devtab.zone_devperm_acl); 4614ee519a1fSgjelinek } 4615ee519a1fSgjelinek 4616ee519a1fSgjelinek (void) zonecfg_enddevperment(handle); 4617ee519a1fSgjelinek 4618ee519a1fSgjelinek return (Z_OK); 4619ee519a1fSgjelinek } 4620ee519a1fSgjelinek 46218cd327d5Sgjelinek /* 46228cd327d5Sgjelinek * Validate attaching a zone but don't actually do the work. The zone 46238cd327d5Sgjelinek * does not have to exist, so there is some complexity getting a new zone 46248cd327d5Sgjelinek * configuration set up so that we can perform the validation. This is 46258cd327d5Sgjelinek * handled within zonecfg_attach_manifest() which returns two handles; one 46268cd327d5Sgjelinek * for the the full configuration to validate (rem_handle) and the other 46278cd327d5Sgjelinek * (local_handle) containing only the zone configuration derived from the 46288cd327d5Sgjelinek * manifest. 46298cd327d5Sgjelinek */ 46308cd327d5Sgjelinek static int 4631ce28b40eSzt129084 dryrun_attach(char *manifest_path, char *argv[]) 46328cd327d5Sgjelinek { 46338cd327d5Sgjelinek int fd; 46348cd327d5Sgjelinek int err; 46358cd327d5Sgjelinek int res; 46368cd327d5Sgjelinek zone_dochandle_t local_handle; 46378cd327d5Sgjelinek zone_dochandle_t rem_handle = NULL; 46388cd327d5Sgjelinek 46398cd327d5Sgjelinek if (strcmp(manifest_path, "-") == 0) { 46408cd327d5Sgjelinek fd = 0; 46418cd327d5Sgjelinek } else if ((fd = open(manifest_path, O_RDONLY)) < 0) { 46428cd327d5Sgjelinek zperror(gettext("could not open manifest path"), B_FALSE); 46438cd327d5Sgjelinek return (Z_ERR); 46448cd327d5Sgjelinek } 46458cd327d5Sgjelinek 46468cd327d5Sgjelinek if ((local_handle = zonecfg_init_handle()) == NULL) { 46478cd327d5Sgjelinek zperror(cmd_to_str(CMD_ATTACH), B_TRUE); 46488cd327d5Sgjelinek res = Z_ERR; 46498cd327d5Sgjelinek goto done; 46508cd327d5Sgjelinek } 46518cd327d5Sgjelinek 46528cd327d5Sgjelinek if ((rem_handle = zonecfg_init_handle()) == NULL) { 46538cd327d5Sgjelinek zperror(cmd_to_str(CMD_ATTACH), B_TRUE); 46548cd327d5Sgjelinek res = Z_ERR; 46558cd327d5Sgjelinek goto done; 46568cd327d5Sgjelinek } 46578cd327d5Sgjelinek 46588cd327d5Sgjelinek if ((err = zonecfg_attach_manifest(fd, local_handle, rem_handle)) 46598cd327d5Sgjelinek != Z_OK) { 46608cd327d5Sgjelinek res = Z_ERR; 4661d9e728a2Sgjelinek 4662d9e728a2Sgjelinek if (err == Z_INVALID_DOCUMENT) { 4663d9e728a2Sgjelinek struct stat st; 4664d9e728a2Sgjelinek char buf[6]; 4665d9e728a2Sgjelinek 4666d9e728a2Sgjelinek if (strcmp(manifest_path, "-") == 0) { 4667d9e728a2Sgjelinek zerror(gettext("Input is not a valid XML " 4668d9e728a2Sgjelinek "file")); 4669d9e728a2Sgjelinek goto done; 4670d9e728a2Sgjelinek } 4671d9e728a2Sgjelinek 4672d9e728a2Sgjelinek if (fstat(fd, &st) == -1 || !S_ISREG(st.st_mode)) { 4673d9e728a2Sgjelinek zerror(gettext("%s is not an XML file"), 4674d9e728a2Sgjelinek manifest_path); 4675d9e728a2Sgjelinek goto done; 4676d9e728a2Sgjelinek } 4677d9e728a2Sgjelinek 4678d9e728a2Sgjelinek bzero(buf, sizeof (buf)); 4679d9e728a2Sgjelinek (void) lseek(fd, 0L, SEEK_SET); 4680d9e728a2Sgjelinek if (read(fd, buf, sizeof (buf) - 1) < 0 || 4681d9e728a2Sgjelinek strncmp(buf, "<?xml", 5) != 0) 4682d9e728a2Sgjelinek zerror(gettext("%s is not an XML file"), 4683d9e728a2Sgjelinek manifest_path); 4684d9e728a2Sgjelinek else 4685d9e728a2Sgjelinek zerror(gettext("Cannot attach to an earlier " 4686d9e728a2Sgjelinek "release of the operating system")); 4687d9e728a2Sgjelinek } else { 4688d9e728a2Sgjelinek zperror(cmd_to_str(CMD_ATTACH), B_TRUE); 4689d9e728a2Sgjelinek } 46908cd327d5Sgjelinek goto done; 46918cd327d5Sgjelinek } 46928cd327d5Sgjelinek 4693e2482d1aSgjelinek /* 4694e2482d1aSgjelinek * Retrieve remote handle brand type and determine whether it is 4695e2482d1aSgjelinek * native or not. 4696e2482d1aSgjelinek */ 4697e2482d1aSgjelinek if (zonecfg_get_brand(rem_handle, target_brand, sizeof (target_brand)) 4698e2482d1aSgjelinek != Z_OK) { 4699e2482d1aSgjelinek zerror(gettext("missing or invalid brand")); 4700e2482d1aSgjelinek exit(Z_ERR); 4701e2482d1aSgjelinek } 4702e2482d1aSgjelinek is_native_zone = (strcmp(target_brand, NATIVE_BRAND_NAME) == 0); 4703e2482d1aSgjelinek 4704ce28b40eSzt129084 res = verify_handle(CMD_ATTACH, local_handle, argv); 47058cd327d5Sgjelinek 47068cd327d5Sgjelinek /* Get the detach information for the locally defined zone. */ 47078cd327d5Sgjelinek if ((err = zonecfg_get_detach_info(local_handle, B_FALSE)) != Z_OK) { 47088cd327d5Sgjelinek errno = err; 47098cd327d5Sgjelinek zperror(gettext("getting the attach information failed"), 47108cd327d5Sgjelinek B_TRUE); 47118cd327d5Sgjelinek res = Z_ERR; 47128cd327d5Sgjelinek } else { 47138cd327d5Sgjelinek /* sw_cmp prints error msgs as necessary */ 47148cd327d5Sgjelinek if (sw_cmp(local_handle, rem_handle, SW_CMP_NONE) != Z_OK) 47158cd327d5Sgjelinek res = Z_ERR; 47168cd327d5Sgjelinek } 47178cd327d5Sgjelinek 47188cd327d5Sgjelinek done: 47198cd327d5Sgjelinek if (strcmp(manifest_path, "-") != 0) 47208cd327d5Sgjelinek (void) close(fd); 47218cd327d5Sgjelinek 47228cd327d5Sgjelinek zonecfg_fini_handle(local_handle); 47238cd327d5Sgjelinek zonecfg_fini_handle(rem_handle); 47248cd327d5Sgjelinek 47258cd327d5Sgjelinek return ((res == Z_OK) ? Z_OK : Z_ERR); 47268cd327d5Sgjelinek } 47278cd327d5Sgjelinek 4728f1adb09eSgjelinek /* 4729f1adb09eSgjelinek * Attempt to generate the information we need to make the zone look like 4730f1adb09eSgjelinek * it was properly detached by using the pkg information contained within 4731f1adb09eSgjelinek * the zone itself. 4732f1adb09eSgjelinek * 4733f1adb09eSgjelinek * We will perform a dry-run detach within the zone to generate the xml file. 4734f1adb09eSgjelinek * To do this we need to be able to get a handle on the zone so we can see 4735f1adb09eSgjelinek * how it is configured. In order to get a handle, we need a copy of the 4736f1adb09eSgjelinek * zone configuration within the zone. Since the zone's configuration is 4737f1adb09eSgjelinek * not available within the zone itself, we need to temporarily copy it into 4738f1adb09eSgjelinek * the zone. 4739f1adb09eSgjelinek * 4740f1adb09eSgjelinek * The sequence of actions we are doing is this: 4741f1adb09eSgjelinek * [set zone state to installed] 4742f1adb09eSgjelinek * [mount zone] 4743f1adb09eSgjelinek * zlogin {zone} </etc/zones/{zone}.xml 'cat >/etc/zones/{zone}.xml' 4744f1adb09eSgjelinek * zlogin {zone} 'zoneadm -z {zone} detach -n' >{zonepath}/SUNWdetached.xml 4745f1adb09eSgjelinek * zlogin {zone} 'rm -f /etc/zones/{zone}.xml' 4746f1adb09eSgjelinek * [unmount zone] 4747f1adb09eSgjelinek * [set zone state to configured] 4748f1adb09eSgjelinek * 4749f1adb09eSgjelinek * The successful result of this function is that we will have a 4750f1adb09eSgjelinek * SUNWdetached.xml file in the zonepath and we can use that to attach the zone. 4751f1adb09eSgjelinek */ 4752f1adb09eSgjelinek static boolean_t 4753f1adb09eSgjelinek gen_detach_info(char *zonepath) 4754f1adb09eSgjelinek { 4755f1adb09eSgjelinek int status; 4756f1adb09eSgjelinek boolean_t mounted = B_FALSE; 4757f1adb09eSgjelinek boolean_t res = B_FALSE; 4758f1adb09eSgjelinek char cmdbuf[2 * MAXPATHLEN]; 4759f1adb09eSgjelinek 4760f1adb09eSgjelinek /* 4761f1adb09eSgjelinek * The zone has to be installed to mount and zlogin. Temporarily set 4762f1adb09eSgjelinek * the state to 'installed'. 4763f1adb09eSgjelinek */ 4764f1adb09eSgjelinek if (zone_set_state(target_zone, ZONE_STATE_INSTALLED) != Z_OK) 4765f1adb09eSgjelinek return (B_FALSE); 4766f1adb09eSgjelinek 4767f1adb09eSgjelinek /* Mount the zone so we can zlogin. */ 4768f1adb09eSgjelinek if (mount_func(0, NULL) != Z_OK) 4769f1adb09eSgjelinek goto cleanup; 4770f1adb09eSgjelinek mounted = B_TRUE; 4771f1adb09eSgjelinek 4772f1adb09eSgjelinek /* 4773f1adb09eSgjelinek * We need to copy the zones xml configuration file into the 4774f1adb09eSgjelinek * zone so we can get a handle for the zone while running inside 4775f1adb09eSgjelinek * the zone. 4776f1adb09eSgjelinek */ 4777f1adb09eSgjelinek if (snprintf(cmdbuf, sizeof (cmdbuf), "/usr/sbin/zlogin -S %s " 4778f1adb09eSgjelinek "</etc/zones/%s.xml '/usr/bin/cat >/etc/zones/%s.xml'", 4779f1adb09eSgjelinek target_zone, target_zone, target_zone) >= sizeof (cmdbuf)) 4780f1adb09eSgjelinek goto cleanup; 4781f1adb09eSgjelinek 4782f1adb09eSgjelinek status = do_subproc_interactive(cmdbuf); 4783f1adb09eSgjelinek if (subproc_status("copy", status, B_TRUE) != ZONE_SUBPROC_OK) 4784f1adb09eSgjelinek goto cleanup; 4785f1adb09eSgjelinek 4786f1adb09eSgjelinek /* Now run the detach command within the mounted zone. */ 4787f1adb09eSgjelinek if (snprintf(cmdbuf, sizeof (cmdbuf), "/usr/sbin/zlogin -S %s " 4788f1adb09eSgjelinek "'/usr/sbin/zoneadm -z %s detach -n' >%s/SUNWdetached.xml", 4789f1adb09eSgjelinek target_zone, target_zone, zonepath) >= sizeof (cmdbuf)) 4790f1adb09eSgjelinek goto cleanup; 4791f1adb09eSgjelinek 4792f1adb09eSgjelinek status = do_subproc_interactive(cmdbuf); 4793f1adb09eSgjelinek if (subproc_status("detach", status, B_TRUE) != ZONE_SUBPROC_OK) 4794f1adb09eSgjelinek goto cleanup; 4795f1adb09eSgjelinek 4796f1adb09eSgjelinek res = B_TRUE; 4797f1adb09eSgjelinek 4798f1adb09eSgjelinek cleanup: 4799f1adb09eSgjelinek /* Cleanup from the previous actions. */ 4800f1adb09eSgjelinek if (mounted) { 4801f1adb09eSgjelinek if (snprintf(cmdbuf, sizeof (cmdbuf), 4802f1adb09eSgjelinek "/usr/sbin/zlogin -S %s '/usr/bin/rm -f /etc/zones/%s.xml'", 4803f1adb09eSgjelinek target_zone, target_zone) >= sizeof (cmdbuf)) { 4804f1adb09eSgjelinek res = B_FALSE; 4805f1adb09eSgjelinek } else { 4806f1adb09eSgjelinek status = do_subproc(cmdbuf); 4807f1adb09eSgjelinek if (subproc_status("rm", status, B_TRUE) 4808f1adb09eSgjelinek != ZONE_SUBPROC_OK) 4809f1adb09eSgjelinek res = B_FALSE; 4810f1adb09eSgjelinek } 4811f1adb09eSgjelinek 4812f1adb09eSgjelinek if (unmount_func(0, NULL) != Z_OK) 4813f1adb09eSgjelinek res = B_FALSE; 4814f1adb09eSgjelinek } 4815f1adb09eSgjelinek 4816f1adb09eSgjelinek if (zone_set_state(target_zone, ZONE_STATE_CONFIGURED) != Z_OK) 4817f1adb09eSgjelinek res = B_FALSE; 4818f1adb09eSgjelinek 4819f1adb09eSgjelinek return (res); 4820f1adb09eSgjelinek } 4821f1adb09eSgjelinek 4822ee519a1fSgjelinek static int 4823ee519a1fSgjelinek attach_func(int argc, char *argv[]) 4824ee519a1fSgjelinek { 4825ee519a1fSgjelinek int lockfd; 4826ee519a1fSgjelinek int err, arg; 4827ee519a1fSgjelinek boolean_t force = B_FALSE; 4828ee519a1fSgjelinek zone_dochandle_t handle; 4829ee519a1fSgjelinek zone_dochandle_t athandle = NULL; 4830ee519a1fSgjelinek char zonepath[MAXPATHLEN]; 48319acbbeafSnn35248 char brand[MAXNAMELEN], atbrand[MAXNAMELEN]; 48328cd327d5Sgjelinek boolean_t execute = B_TRUE; 4833f1adb09eSgjelinek boolean_t retried = B_FALSE; 48348cd327d5Sgjelinek char *manifest_path; 4835ee519a1fSgjelinek 4836ee519a1fSgjelinek if (zonecfg_in_alt_root()) { 4837ee519a1fSgjelinek zerror(gettext("cannot attach zone in alternate root")); 4838ee519a1fSgjelinek return (Z_ERR); 4839ee519a1fSgjelinek } 4840ee519a1fSgjelinek 4841ee519a1fSgjelinek optind = 0; 48428cd327d5Sgjelinek if ((arg = getopt(argc, argv, "?Fn:")) != EOF) { 4843ee519a1fSgjelinek switch (arg) { 4844ee519a1fSgjelinek case '?': 4845ee519a1fSgjelinek sub_usage(SHELP_ATTACH, CMD_ATTACH); 4846ee519a1fSgjelinek return (optopt == '?' ? Z_OK : Z_USAGE); 4847ee519a1fSgjelinek case 'F': 4848ee519a1fSgjelinek force = B_TRUE; 4849ee519a1fSgjelinek break; 48508cd327d5Sgjelinek case 'n': 48518cd327d5Sgjelinek execute = B_FALSE; 48528cd327d5Sgjelinek manifest_path = optarg; 48538cd327d5Sgjelinek break; 4854ee519a1fSgjelinek default: 4855ee519a1fSgjelinek sub_usage(SHELP_ATTACH, CMD_ATTACH); 4856ee519a1fSgjelinek return (Z_USAGE); 4857ee519a1fSgjelinek } 4858ee519a1fSgjelinek } 48598cd327d5Sgjelinek 48608cd327d5Sgjelinek /* 48618cd327d5Sgjelinek * If the no-execute option was specified, we need to branch down 48628cd327d5Sgjelinek * a completely different path since there is no zone required to be 48638cd327d5Sgjelinek * configured for this option. 48648cd327d5Sgjelinek */ 48658cd327d5Sgjelinek if (!execute) 4866ce28b40eSzt129084 return (dryrun_attach(manifest_path, argv)); 48678cd327d5Sgjelinek 48689acbbeafSnn35248 if (sanity_check(target_zone, CMD_ATTACH, B_FALSE, B_TRUE, B_FALSE) 48699acbbeafSnn35248 != Z_OK) 4870ee519a1fSgjelinek return (Z_ERR); 4871ce28b40eSzt129084 if (verify_details(CMD_ATTACH, argv) != Z_OK) 4872ee519a1fSgjelinek return (Z_ERR); 4873ee519a1fSgjelinek 4874ee519a1fSgjelinek if ((err = zone_get_zonepath(target_zone, zonepath, sizeof (zonepath))) 4875ee519a1fSgjelinek != Z_OK) { 4876ee519a1fSgjelinek errno = err; 4877ee519a1fSgjelinek zperror2(target_zone, gettext("could not get zone path")); 4878ee519a1fSgjelinek return (Z_ERR); 4879ee519a1fSgjelinek } 4880ee519a1fSgjelinek 4881ee519a1fSgjelinek if ((handle = zonecfg_init_handle()) == NULL) { 4882ee519a1fSgjelinek zperror(cmd_to_str(CMD_ATTACH), B_TRUE); 4883ee519a1fSgjelinek return (Z_ERR); 4884ee519a1fSgjelinek } 4885ee519a1fSgjelinek 4886ee519a1fSgjelinek if ((err = zonecfg_get_handle(target_zone, handle)) != Z_OK) { 4887ee519a1fSgjelinek errno = err; 4888ee519a1fSgjelinek zperror(cmd_to_str(CMD_ATTACH), B_TRUE); 4889ee519a1fSgjelinek zonecfg_fini_handle(handle); 4890ee519a1fSgjelinek return (Z_ERR); 4891ee519a1fSgjelinek } 4892ee519a1fSgjelinek 4893ee519a1fSgjelinek if (grab_lock_file(target_zone, &lockfd) != Z_OK) { 4894ee519a1fSgjelinek zerror(gettext("another %s may have an operation in progress."), 4895ee519a1fSgjelinek "zoneadm"); 4896ee519a1fSgjelinek zonecfg_fini_handle(handle); 4897ee519a1fSgjelinek return (Z_ERR); 4898ee519a1fSgjelinek } 4899ee519a1fSgjelinek 4900ee519a1fSgjelinek if (force) 4901ee519a1fSgjelinek goto forced; 4902ee519a1fSgjelinek 4903ee519a1fSgjelinek if ((athandle = zonecfg_init_handle()) == NULL) { 4904ee519a1fSgjelinek zperror(cmd_to_str(CMD_ATTACH), B_TRUE); 4905ee519a1fSgjelinek goto done; 4906ee519a1fSgjelinek } 4907ee519a1fSgjelinek 4908f1adb09eSgjelinek retry: 4909ee519a1fSgjelinek if ((err = zonecfg_get_attach_handle(zonepath, target_zone, B_TRUE, 4910ee519a1fSgjelinek athandle)) != Z_OK) { 4911f1adb09eSgjelinek if (err == Z_NO_ZONE) { 4912f1adb09eSgjelinek /* 4913f1adb09eSgjelinek * Zone was not detached. Try to fall back to getting 4914f1adb09eSgjelinek * the needed information from within the zone. 4915f1adb09eSgjelinek * However, we can only try to generate the attach 4916f1adb09eSgjelinek * information for native branded zones, so fail if the 4917f1adb09eSgjelinek * zone is not native. 4918f1adb09eSgjelinek */ 4919f1adb09eSgjelinek if (!is_native_zone) { 4920f1adb09eSgjelinek zerror(gettext("Not a detached zone.")); 4921f1adb09eSgjelinek goto done; 4922f1adb09eSgjelinek } 4923f1adb09eSgjelinek 4924f1adb09eSgjelinek if (!retried) { 4925f1adb09eSgjelinek zerror(gettext("The zone was not properly " 4926f1adb09eSgjelinek "detached.\n\tAttempting to attach " 4927f1adb09eSgjelinek "anyway.")); 4928f1adb09eSgjelinek if (gen_detach_info(zonepath)) { 4929f1adb09eSgjelinek retried = B_TRUE; 4930f1adb09eSgjelinek goto retry; 4931f1adb09eSgjelinek } 4932f1adb09eSgjelinek } 4933f1adb09eSgjelinek zerror(gettext("Cannot generate the information " 4934f1adb09eSgjelinek "needed to attach this zone.")); 4935f1adb09eSgjelinek } else if (err == Z_INVALID_DOCUMENT) { 4936ee519a1fSgjelinek zerror(gettext("Cannot attach to an earlier release " 4937ee519a1fSgjelinek "of the operating system")); 4938f1adb09eSgjelinek } else { 4939ee519a1fSgjelinek zperror(cmd_to_str(CMD_ATTACH), B_TRUE); 4940f1adb09eSgjelinek } 4941ee519a1fSgjelinek goto done; 4942ee519a1fSgjelinek } 4943ee519a1fSgjelinek 4944ee519a1fSgjelinek /* Get the detach information for the locally defined zone. */ 4945ee519a1fSgjelinek if ((err = zonecfg_get_detach_info(handle, B_FALSE)) != Z_OK) { 4946ee519a1fSgjelinek errno = err; 4947ee519a1fSgjelinek zperror(gettext("getting the attach information failed"), 4948ee519a1fSgjelinek B_TRUE); 4949ee519a1fSgjelinek goto done; 4950ee519a1fSgjelinek } 4951ee519a1fSgjelinek 49529acbbeafSnn35248 /* 49539acbbeafSnn35248 * Ensure that the detached and locally defined zones are both of 49549acbbeafSnn35248 * the same brand. 49559acbbeafSnn35248 */ 49569acbbeafSnn35248 if ((zonecfg_get_brand(handle, brand, sizeof (brand)) != 0) || 49579acbbeafSnn35248 (zonecfg_get_brand(athandle, atbrand, sizeof (atbrand)) != 0)) { 49589acbbeafSnn35248 err = Z_ERR; 49599acbbeafSnn35248 zerror(gettext("missing or invalid brand")); 49609acbbeafSnn35248 goto done; 49619acbbeafSnn35248 } 49629acbbeafSnn35248 49639acbbeafSnn35248 if (strcmp(atbrand, brand) != NULL) { 49649acbbeafSnn35248 err = Z_ERR; 49659acbbeafSnn35248 zerror(gettext("Trying to attach a '%s' zone to a '%s' " 49669acbbeafSnn35248 "configuration."), atbrand, brand); 49679acbbeafSnn35248 goto done; 49689acbbeafSnn35248 } 49699acbbeafSnn35248 4970ee519a1fSgjelinek /* sw_cmp prints error msgs as necessary */ 49710b5de56dSgjelinek if ((err = sw_cmp(handle, athandle, SW_CMP_NONE)) != Z_OK) 4972ee519a1fSgjelinek goto done; 4973ee519a1fSgjelinek 4974ee519a1fSgjelinek if ((err = dev_fix(athandle)) != Z_OK) 4975ee519a1fSgjelinek goto done; 4976ee519a1fSgjelinek 4977ee519a1fSgjelinek forced: 4978ee519a1fSgjelinek 4979ee519a1fSgjelinek zonecfg_rm_detached(handle, force); 4980ee519a1fSgjelinek 4981ee519a1fSgjelinek if ((err = zone_set_state(target_zone, ZONE_STATE_INSTALLED)) != Z_OK) { 4982ee519a1fSgjelinek errno = err; 4983ee519a1fSgjelinek zperror(gettext("could not reset state"), B_TRUE); 4984ee519a1fSgjelinek } 4985ee519a1fSgjelinek 4986ee519a1fSgjelinek done: 4987ee519a1fSgjelinek zonecfg_fini_handle(handle); 4988ee519a1fSgjelinek release_lock_file(lockfd); 4989ee519a1fSgjelinek if (athandle != NULL) 4990ee519a1fSgjelinek zonecfg_fini_handle(athandle); 4991ee519a1fSgjelinek 4992ee519a1fSgjelinek return ((err == Z_OK) ? Z_OK : Z_ERR); 4993ee519a1fSgjelinek } 4994ee519a1fSgjelinek 4995865e09a4Sgjelinek /* 49967c478bd9Sstevel@tonic-gate * On input, TRUE => yes, FALSE => no. 49977c478bd9Sstevel@tonic-gate * On return, TRUE => 1, FALSE => 0, could not ask => -1. 49987c478bd9Sstevel@tonic-gate */ 49997c478bd9Sstevel@tonic-gate 50007c478bd9Sstevel@tonic-gate static int 50017c478bd9Sstevel@tonic-gate ask_yesno(boolean_t default_answer, const char *question) 50027c478bd9Sstevel@tonic-gate { 50037c478bd9Sstevel@tonic-gate char line[64]; /* should be large enough to answer yes or no */ 50047c478bd9Sstevel@tonic-gate 50057c478bd9Sstevel@tonic-gate if (!isatty(STDIN_FILENO)) 50067c478bd9Sstevel@tonic-gate return (-1); 50077c478bd9Sstevel@tonic-gate for (;;) { 50087c478bd9Sstevel@tonic-gate (void) printf("%s (%s)? ", question, 50097c478bd9Sstevel@tonic-gate default_answer ? "[y]/n" : "y/[n]"); 50107c478bd9Sstevel@tonic-gate if (fgets(line, sizeof (line), stdin) == NULL || 50117c478bd9Sstevel@tonic-gate line[0] == '\n') 50127c478bd9Sstevel@tonic-gate return (default_answer ? 1 : 0); 50137c478bd9Sstevel@tonic-gate if (tolower(line[0]) == 'y') 50147c478bd9Sstevel@tonic-gate return (1); 50157c478bd9Sstevel@tonic-gate if (tolower(line[0]) == 'n') 50167c478bd9Sstevel@tonic-gate return (0); 50177c478bd9Sstevel@tonic-gate } 50187c478bd9Sstevel@tonic-gate } 50197c478bd9Sstevel@tonic-gate 50207c478bd9Sstevel@tonic-gate static int 50217c478bd9Sstevel@tonic-gate uninstall_func(int argc, char *argv[]) 50227c478bd9Sstevel@tonic-gate { 50237c478bd9Sstevel@tonic-gate char line[ZONENAME_MAX + 128]; /* Enough for "Are you sure ..." */ 50240b5de56dSgjelinek char rootpath[MAXPATHLEN], zonepath[MAXPATHLEN]; 50257c478bd9Sstevel@tonic-gate boolean_t force = B_FALSE; 50267c478bd9Sstevel@tonic-gate int lockfd, answer; 50277c478bd9Sstevel@tonic-gate int err, arg; 50287c478bd9Sstevel@tonic-gate 5029108322fbScarlsonj if (zonecfg_in_alt_root()) { 5030108322fbScarlsonj zerror(gettext("cannot uninstall zone in alternate root")); 5031108322fbScarlsonj return (Z_ERR); 5032108322fbScarlsonj } 5033108322fbScarlsonj 50347c478bd9Sstevel@tonic-gate optind = 0; 50357c478bd9Sstevel@tonic-gate while ((arg = getopt(argc, argv, "?F")) != EOF) { 50367c478bd9Sstevel@tonic-gate switch (arg) { 50377c478bd9Sstevel@tonic-gate case '?': 50387c478bd9Sstevel@tonic-gate sub_usage(SHELP_UNINSTALL, CMD_UNINSTALL); 50397c478bd9Sstevel@tonic-gate return (optopt == '?' ? Z_OK : Z_USAGE); 50407c478bd9Sstevel@tonic-gate case 'F': 50417c478bd9Sstevel@tonic-gate force = B_TRUE; 50427c478bd9Sstevel@tonic-gate break; 50437c478bd9Sstevel@tonic-gate default: 50447c478bd9Sstevel@tonic-gate sub_usage(SHELP_UNINSTALL, CMD_UNINSTALL); 50457c478bd9Sstevel@tonic-gate return (Z_USAGE); 50467c478bd9Sstevel@tonic-gate } 50477c478bd9Sstevel@tonic-gate } 50487c478bd9Sstevel@tonic-gate if (argc > optind) { 50497c478bd9Sstevel@tonic-gate sub_usage(SHELP_UNINSTALL, CMD_UNINSTALL); 50507c478bd9Sstevel@tonic-gate return (Z_USAGE); 50517c478bd9Sstevel@tonic-gate } 50527c478bd9Sstevel@tonic-gate 50539acbbeafSnn35248 if (sanity_check(target_zone, CMD_UNINSTALL, B_FALSE, B_TRUE, B_FALSE) 50549acbbeafSnn35248 != Z_OK) 50557c478bd9Sstevel@tonic-gate return (Z_ERR); 50567c478bd9Sstevel@tonic-gate 5057ce28b40eSzt129084 /* 5058ce28b40eSzt129084 * Invoke brand-specific handler. 5059ce28b40eSzt129084 */ 5060ce28b40eSzt129084 if (invoke_brand_handler(CMD_UNINSTALL, argv) != Z_OK) 5061ce28b40eSzt129084 return (Z_ERR); 5062ce28b40eSzt129084 50637c478bd9Sstevel@tonic-gate if (!force) { 50647c478bd9Sstevel@tonic-gate (void) snprintf(line, sizeof (line), 50657c478bd9Sstevel@tonic-gate gettext("Are you sure you want to %s zone %s"), 50667c478bd9Sstevel@tonic-gate cmd_to_str(CMD_UNINSTALL), target_zone); 50677c478bd9Sstevel@tonic-gate if ((answer = ask_yesno(B_FALSE, line)) == 0) { 50687c478bd9Sstevel@tonic-gate return (Z_OK); 50697c478bd9Sstevel@tonic-gate } else if (answer == -1) { 50707c478bd9Sstevel@tonic-gate zerror(gettext("Input not from terminal and -F " 50717c478bd9Sstevel@tonic-gate "not specified: %s not done."), 50727c478bd9Sstevel@tonic-gate cmd_to_str(CMD_UNINSTALL)); 50737c478bd9Sstevel@tonic-gate return (Z_ERR); 50747c478bd9Sstevel@tonic-gate } 50757c478bd9Sstevel@tonic-gate } 50767c478bd9Sstevel@tonic-gate 50770b5de56dSgjelinek if ((err = zone_get_zonepath(target_zone, zonepath, 50780b5de56dSgjelinek sizeof (zonepath))) != Z_OK) { 50797c478bd9Sstevel@tonic-gate errno = err; 50807c478bd9Sstevel@tonic-gate zperror2(target_zone, gettext("could not get zone path")); 50817c478bd9Sstevel@tonic-gate return (Z_ERR); 50827c478bd9Sstevel@tonic-gate } 50837c478bd9Sstevel@tonic-gate if ((err = zone_get_rootpath(target_zone, rootpath, 50847c478bd9Sstevel@tonic-gate sizeof (rootpath))) != Z_OK) { 50857c478bd9Sstevel@tonic-gate errno = err; 50867c478bd9Sstevel@tonic-gate zperror2(target_zone, gettext("could not get root path")); 50877c478bd9Sstevel@tonic-gate return (Z_ERR); 50887c478bd9Sstevel@tonic-gate } 50897c478bd9Sstevel@tonic-gate 50907c478bd9Sstevel@tonic-gate /* 50917c478bd9Sstevel@tonic-gate * If there seems to be a zoneadmd running for this zone, call it 50927c478bd9Sstevel@tonic-gate * to tell it that an uninstall is happening; if all goes well it 50937c478bd9Sstevel@tonic-gate * will then shut itself down. 50947c478bd9Sstevel@tonic-gate */ 50957c478bd9Sstevel@tonic-gate if (ping_zoneadmd(target_zone) == Z_OK) { 50967c478bd9Sstevel@tonic-gate zone_cmd_arg_t zarg; 50977c478bd9Sstevel@tonic-gate zarg.cmd = Z_NOTE_UNINSTALLING; 50987c478bd9Sstevel@tonic-gate /* we don't care too much if this fails... just plow on */ 50997c478bd9Sstevel@tonic-gate (void) call_zoneadmd(target_zone, &zarg); 51007c478bd9Sstevel@tonic-gate } 51017c478bd9Sstevel@tonic-gate 51027c478bd9Sstevel@tonic-gate if (grab_lock_file(target_zone, &lockfd) != Z_OK) { 51037c478bd9Sstevel@tonic-gate zerror(gettext("another %s may have an operation in progress."), 5104865e09a4Sgjelinek "zoneadm"); 51057c478bd9Sstevel@tonic-gate return (Z_ERR); 51067c478bd9Sstevel@tonic-gate } 51077c478bd9Sstevel@tonic-gate 51087c478bd9Sstevel@tonic-gate /* Don't uninstall the zone if anything is mounted there */ 51097c478bd9Sstevel@tonic-gate err = zonecfg_find_mounts(rootpath, NULL, NULL); 51107c478bd9Sstevel@tonic-gate if (err) { 51110b5de56dSgjelinek zerror(gettext("These file systems are mounted on " 51127c478bd9Sstevel@tonic-gate "subdirectories of %s.\n"), rootpath); 51137c478bd9Sstevel@tonic-gate (void) zonecfg_find_mounts(rootpath, zfm_print, NULL); 51147c478bd9Sstevel@tonic-gate return (Z_ERR); 51157c478bd9Sstevel@tonic-gate } 51167c478bd9Sstevel@tonic-gate 51177c478bd9Sstevel@tonic-gate err = zone_set_state(target_zone, ZONE_STATE_INCOMPLETE); 51187c478bd9Sstevel@tonic-gate if (err != Z_OK) { 51197c478bd9Sstevel@tonic-gate errno = err; 51207c478bd9Sstevel@tonic-gate zperror2(target_zone, gettext("could not set state")); 51217c478bd9Sstevel@tonic-gate goto bad; 51227c478bd9Sstevel@tonic-gate } 51237c478bd9Sstevel@tonic-gate 51240b5de56dSgjelinek if ((err = cleanup_zonepath(zonepath, B_FALSE)) != Z_OK) { 51250b5de56dSgjelinek errno = err; 51260b5de56dSgjelinek zperror2(target_zone, gettext("cleaning up zonepath failed")); 51277c478bd9Sstevel@tonic-gate goto bad; 51280b5de56dSgjelinek } 51290b5de56dSgjelinek 51307c478bd9Sstevel@tonic-gate err = zone_set_state(target_zone, ZONE_STATE_CONFIGURED); 51317c478bd9Sstevel@tonic-gate if (err != Z_OK) { 51327c478bd9Sstevel@tonic-gate errno = err; 51337c478bd9Sstevel@tonic-gate zperror2(target_zone, gettext("could not reset state")); 51347c478bd9Sstevel@tonic-gate } 51357c478bd9Sstevel@tonic-gate bad: 51367c478bd9Sstevel@tonic-gate release_lock_file(lockfd); 51377c478bd9Sstevel@tonic-gate return (err); 51387c478bd9Sstevel@tonic-gate } 51397c478bd9Sstevel@tonic-gate 5140108322fbScarlsonj /* ARGSUSED */ 5141108322fbScarlsonj static int 5142108322fbScarlsonj mount_func(int argc, char *argv[]) 5143108322fbScarlsonj { 5144108322fbScarlsonj zone_cmd_arg_t zarg; 51459acbbeafSnn35248 boolean_t force = B_FALSE; 51469acbbeafSnn35248 int arg; 5147108322fbScarlsonj 51489acbbeafSnn35248 /* 51499acbbeafSnn35248 * The only supported subargument to the "mount" subcommand is 51509acbbeafSnn35248 * "-f", which forces us to mount a zone in the INCOMPLETE state. 51519acbbeafSnn35248 */ 51529acbbeafSnn35248 optind = 0; 51539acbbeafSnn35248 if ((arg = getopt(argc, argv, "f")) != EOF) { 51549acbbeafSnn35248 switch (arg) { 51559acbbeafSnn35248 case 'f': 51569acbbeafSnn35248 force = B_TRUE; 51579acbbeafSnn35248 break; 51589acbbeafSnn35248 default: 5159108322fbScarlsonj return (Z_USAGE); 51609acbbeafSnn35248 } 51619acbbeafSnn35248 } 51629acbbeafSnn35248 if (argc > optind) 51639acbbeafSnn35248 return (Z_USAGE); 51649acbbeafSnn35248 51659acbbeafSnn35248 if (sanity_check(target_zone, CMD_MOUNT, B_FALSE, B_FALSE, force) 51669acbbeafSnn35248 != Z_OK) 5167108322fbScarlsonj return (Z_ERR); 5168ce28b40eSzt129084 if (verify_details(CMD_MOUNT, argv) != Z_OK) 5169108322fbScarlsonj return (Z_ERR); 5170108322fbScarlsonj 51719acbbeafSnn35248 zarg.cmd = force ? Z_FORCEMOUNT : Z_MOUNT; 5172108322fbScarlsonj if (call_zoneadmd(target_zone, &zarg) != 0) { 5173108322fbScarlsonj zerror(gettext("call to %s failed"), "zoneadmd"); 5174108322fbScarlsonj return (Z_ERR); 5175108322fbScarlsonj } 5176108322fbScarlsonj return (Z_OK); 5177108322fbScarlsonj } 5178108322fbScarlsonj 5179108322fbScarlsonj /* ARGSUSED */ 5180108322fbScarlsonj static int 5181108322fbScarlsonj unmount_func(int argc, char *argv[]) 5182108322fbScarlsonj { 5183108322fbScarlsonj zone_cmd_arg_t zarg; 5184108322fbScarlsonj 5185108322fbScarlsonj if (argc > 0) 5186108322fbScarlsonj return (Z_USAGE); 51879acbbeafSnn35248 if (sanity_check(target_zone, CMD_UNMOUNT, B_FALSE, B_FALSE, B_FALSE) 51889acbbeafSnn35248 != Z_OK) 5189108322fbScarlsonj return (Z_ERR); 5190108322fbScarlsonj 5191108322fbScarlsonj zarg.cmd = Z_UNMOUNT; 5192108322fbScarlsonj if (call_zoneadmd(target_zone, &zarg) != 0) { 5193108322fbScarlsonj zerror(gettext("call to %s failed"), "zoneadmd"); 5194108322fbScarlsonj return (Z_ERR); 5195108322fbScarlsonj } 5196108322fbScarlsonj return (Z_OK); 5197108322fbScarlsonj } 5198108322fbScarlsonj 51997c478bd9Sstevel@tonic-gate static int 5200555afedfScarlsonj mark_func(int argc, char *argv[]) 5201555afedfScarlsonj { 5202555afedfScarlsonj int err, lockfd; 5203555afedfScarlsonj 5204555afedfScarlsonj if (argc != 1 || strcmp(argv[0], "incomplete") != 0) 5205555afedfScarlsonj return (Z_USAGE); 52069acbbeafSnn35248 if (sanity_check(target_zone, CMD_MARK, B_FALSE, B_FALSE, B_FALSE) 52079acbbeafSnn35248 != Z_OK) 5208555afedfScarlsonj return (Z_ERR); 5209555afedfScarlsonj 5210ce28b40eSzt129084 /* 5211ce28b40eSzt129084 * Invoke brand-specific handler. 5212ce28b40eSzt129084 */ 5213ce28b40eSzt129084 if (invoke_brand_handler(CMD_MARK, argv) != Z_OK) 5214ce28b40eSzt129084 return (Z_ERR); 5215ce28b40eSzt129084 5216555afedfScarlsonj if (grab_lock_file(target_zone, &lockfd) != Z_OK) { 5217555afedfScarlsonj zerror(gettext("another %s may have an operation in progress."), 5218555afedfScarlsonj "zoneadm"); 5219555afedfScarlsonj return (Z_ERR); 5220555afedfScarlsonj } 5221555afedfScarlsonj 5222555afedfScarlsonj err = zone_set_state(target_zone, ZONE_STATE_INCOMPLETE); 5223555afedfScarlsonj if (err != Z_OK) { 5224555afedfScarlsonj errno = err; 5225555afedfScarlsonj zperror2(target_zone, gettext("could not set state")); 5226555afedfScarlsonj } 5227555afedfScarlsonj release_lock_file(lockfd); 5228555afedfScarlsonj 5229555afedfScarlsonj return (err); 5230555afedfScarlsonj } 5231555afedfScarlsonj 52320209230bSgjelinek /* 52330209230bSgjelinek * Check what scheduling class we're running under and print a warning if 52340209230bSgjelinek * we're not using FSS. 52350209230bSgjelinek */ 52360209230bSgjelinek static int 52370209230bSgjelinek check_sched_fss(zone_dochandle_t handle) 52380209230bSgjelinek { 52390209230bSgjelinek char class_name[PC_CLNMSZ]; 52400209230bSgjelinek 52410209230bSgjelinek if (zonecfg_get_dflt_sched_class(handle, class_name, 52420209230bSgjelinek sizeof (class_name)) != Z_OK) { 52430209230bSgjelinek zerror(gettext("WARNING: unable to determine the zone's " 52440209230bSgjelinek "scheduling class")); 52450209230bSgjelinek } else if (strcmp("FSS", class_name) != 0) { 52460209230bSgjelinek zerror(gettext("WARNING: The zone.cpu-shares rctl is set but\n" 52470209230bSgjelinek "FSS is not the default scheduling class for this zone. " 52480209230bSgjelinek "FSS will be\nused for processes in the zone but to get " 52490209230bSgjelinek "the full benefit of FSS,\nit should be the default " 52500209230bSgjelinek "scheduling class. See dispadmin(1M) for\nmore details.")); 52510209230bSgjelinek return (Z_SYSTEM); 52520209230bSgjelinek } 52530209230bSgjelinek 52540209230bSgjelinek return (Z_OK); 52550209230bSgjelinek } 52560209230bSgjelinek 52570209230bSgjelinek static int 52580209230bSgjelinek check_cpu_shares_sched(zone_dochandle_t handle) 52590209230bSgjelinek { 52600209230bSgjelinek int err; 52610209230bSgjelinek int res = Z_OK; 52620209230bSgjelinek struct zone_rctltab rctl; 52630209230bSgjelinek 52640209230bSgjelinek if ((err = zonecfg_setrctlent(handle)) != Z_OK) { 52650209230bSgjelinek errno = err; 52660209230bSgjelinek zperror(cmd_to_str(CMD_APPLY), B_TRUE); 52670209230bSgjelinek return (err); 52680209230bSgjelinek } 52690209230bSgjelinek 52700209230bSgjelinek while (zonecfg_getrctlent(handle, &rctl) == Z_OK) { 52710209230bSgjelinek if (strcmp(rctl.zone_rctl_name, "zone.cpu-shares") == 0) { 52720209230bSgjelinek if (check_sched_fss(handle) != Z_OK) 52730209230bSgjelinek res = Z_SYSTEM; 52740209230bSgjelinek break; 52750209230bSgjelinek } 52760209230bSgjelinek } 52770209230bSgjelinek 52780209230bSgjelinek (void) zonecfg_endrctlent(handle); 52790209230bSgjelinek 52800209230bSgjelinek return (res); 52810209230bSgjelinek } 52820209230bSgjelinek 52830209230bSgjelinek /* 52847ef01d19Sgjelinek * Check if there is a mix of processes running in different pools within the 52857ef01d19Sgjelinek * zone. This is currently only going to be called for the global zone from 52867ef01d19Sgjelinek * apply_func but that could be generalized in the future. 52877ef01d19Sgjelinek */ 52887ef01d19Sgjelinek static boolean_t 52897ef01d19Sgjelinek mixed_pools(zoneid_t zoneid) 52907ef01d19Sgjelinek { 52917ef01d19Sgjelinek DIR *dirp; 52927ef01d19Sgjelinek dirent_t *dent; 52937ef01d19Sgjelinek boolean_t mixed = B_FALSE; 52947ef01d19Sgjelinek boolean_t poolid_set = B_FALSE; 52957ef01d19Sgjelinek poolid_t last_poolid = 0; 52967ef01d19Sgjelinek 52977ef01d19Sgjelinek if ((dirp = opendir("/proc")) == NULL) { 52987ef01d19Sgjelinek zerror(gettext("could not open /proc")); 52997ef01d19Sgjelinek return (B_FALSE); 53007ef01d19Sgjelinek } 53017ef01d19Sgjelinek 53027ef01d19Sgjelinek while ((dent = readdir(dirp)) != NULL) { 53037ef01d19Sgjelinek int procfd; 53047ef01d19Sgjelinek psinfo_t ps; 53057ef01d19Sgjelinek char procpath[MAXPATHLEN]; 53067ef01d19Sgjelinek 53077ef01d19Sgjelinek if (dent->d_name[0] == '.') 53087ef01d19Sgjelinek continue; 53097ef01d19Sgjelinek 53107ef01d19Sgjelinek (void) snprintf(procpath, sizeof (procpath), "/proc/%s/psinfo", 53117ef01d19Sgjelinek dent->d_name); 53127ef01d19Sgjelinek 53137ef01d19Sgjelinek if ((procfd = open(procpath, O_RDONLY)) == -1) 53147ef01d19Sgjelinek continue; 53157ef01d19Sgjelinek 53167ef01d19Sgjelinek if (read(procfd, &ps, sizeof (ps)) == sizeof (psinfo_t)) { 53177ef01d19Sgjelinek /* skip processes in other zones and system processes */ 53187ef01d19Sgjelinek if (zoneid != ps.pr_zoneid || ps.pr_flag & SSYS) { 53197ef01d19Sgjelinek (void) close(procfd); 53207ef01d19Sgjelinek continue; 53217ef01d19Sgjelinek } 53227ef01d19Sgjelinek 53237ef01d19Sgjelinek if (poolid_set) { 53247ef01d19Sgjelinek if (ps.pr_poolid != last_poolid) 53257ef01d19Sgjelinek mixed = B_TRUE; 53267ef01d19Sgjelinek } else { 53277ef01d19Sgjelinek last_poolid = ps.pr_poolid; 53287ef01d19Sgjelinek poolid_set = B_TRUE; 53297ef01d19Sgjelinek } 53307ef01d19Sgjelinek } 53317ef01d19Sgjelinek 53327ef01d19Sgjelinek (void) close(procfd); 53337ef01d19Sgjelinek 53347ef01d19Sgjelinek if (mixed) 53357ef01d19Sgjelinek break; 53367ef01d19Sgjelinek } 53377ef01d19Sgjelinek 53387ef01d19Sgjelinek (void) closedir(dirp); 53397ef01d19Sgjelinek 53407ef01d19Sgjelinek return (mixed); 53417ef01d19Sgjelinek } 53427ef01d19Sgjelinek 53437ef01d19Sgjelinek /* 53447ef01d19Sgjelinek * Check if a persistent or temporary pool is configured for the zone. 53457ef01d19Sgjelinek * This is currently only going to be called for the global zone from 53467ef01d19Sgjelinek * apply_func but that could be generalized in the future. 53477ef01d19Sgjelinek */ 53487ef01d19Sgjelinek static boolean_t 53497ef01d19Sgjelinek pool_configured(zone_dochandle_t handle) 53507ef01d19Sgjelinek { 53517ef01d19Sgjelinek int err1, err2; 53527ef01d19Sgjelinek struct zone_psettab pset_tab; 53537ef01d19Sgjelinek char poolname[MAXPATHLEN]; 53547ef01d19Sgjelinek 53557ef01d19Sgjelinek err1 = zonecfg_lookup_pset(handle, &pset_tab); 53567ef01d19Sgjelinek err2 = zonecfg_get_pool(handle, poolname, sizeof (poolname)); 53577ef01d19Sgjelinek 53587ef01d19Sgjelinek if (err1 == Z_NO_ENTRY && 53597ef01d19Sgjelinek (err2 == Z_NO_ENTRY || (err2 == Z_OK && strlen(poolname) == 0))) 53607ef01d19Sgjelinek return (B_FALSE); 53617ef01d19Sgjelinek 53627ef01d19Sgjelinek return (B_TRUE); 53637ef01d19Sgjelinek } 53647ef01d19Sgjelinek 53657ef01d19Sgjelinek /* 53660209230bSgjelinek * This is an undocumented interface which is currently only used to apply 53670209230bSgjelinek * the global zone resource management settings when the system boots. 53680209230bSgjelinek * This function does not yet properly handle updating a running system so 53690209230bSgjelinek * any projects running in the zone would be trashed if this function 53700209230bSgjelinek * were to run after the zone had booted. It also does not reset any 53710209230bSgjelinek * rctl settings that were removed from zonecfg. There is still work to be 53720209230bSgjelinek * done before we can properly support dynamically updating the resource 53730209230bSgjelinek * management settings for a running zone (global or non-global). Thus, this 53740209230bSgjelinek * functionality is undocumented for now. 53750209230bSgjelinek */ 53760209230bSgjelinek /* ARGSUSED */ 53770209230bSgjelinek static int 53780209230bSgjelinek apply_func(int argc, char *argv[]) 53790209230bSgjelinek { 53800209230bSgjelinek int err; 53810209230bSgjelinek int res = Z_OK; 53820209230bSgjelinek priv_set_t *privset; 53830209230bSgjelinek zoneid_t zoneid; 53840209230bSgjelinek zone_dochandle_t handle; 53850209230bSgjelinek struct zone_mcaptab mcap; 53860209230bSgjelinek char pool_err[128]; 53870209230bSgjelinek 53880209230bSgjelinek zoneid = getzoneid(); 53890209230bSgjelinek 53900209230bSgjelinek if (zonecfg_in_alt_root() || zoneid != GLOBAL_ZONEID || 53910209230bSgjelinek target_zone == NULL || strcmp(target_zone, GLOBAL_ZONENAME) != 0) 53920209230bSgjelinek return (usage(B_FALSE)); 53930209230bSgjelinek 53940209230bSgjelinek if ((privset = priv_allocset()) == NULL) { 53950209230bSgjelinek zerror(gettext("%s failed"), "priv_allocset"); 53960209230bSgjelinek return (Z_ERR); 53970209230bSgjelinek } 53980209230bSgjelinek 53990209230bSgjelinek if (getppriv(PRIV_EFFECTIVE, privset) != 0) { 54000209230bSgjelinek zerror(gettext("%s failed"), "getppriv"); 54010209230bSgjelinek priv_freeset(privset); 54020209230bSgjelinek return (Z_ERR); 54030209230bSgjelinek } 54040209230bSgjelinek 54050209230bSgjelinek if (priv_isfullset(privset) == B_FALSE) { 54060209230bSgjelinek (void) usage(B_FALSE); 54070209230bSgjelinek priv_freeset(privset); 54080209230bSgjelinek return (Z_ERR); 54090209230bSgjelinek } 54100209230bSgjelinek priv_freeset(privset); 54110209230bSgjelinek 54120209230bSgjelinek if ((handle = zonecfg_init_handle()) == NULL) { 54130209230bSgjelinek zperror(cmd_to_str(CMD_APPLY), B_TRUE); 54140209230bSgjelinek return (Z_ERR); 54150209230bSgjelinek } 54160209230bSgjelinek 54170209230bSgjelinek if ((err = zonecfg_get_handle(target_zone, handle)) != Z_OK) { 54180209230bSgjelinek errno = err; 54190209230bSgjelinek zperror(cmd_to_str(CMD_APPLY), B_TRUE); 54200209230bSgjelinek zonecfg_fini_handle(handle); 54210209230bSgjelinek return (Z_ERR); 54220209230bSgjelinek } 54230209230bSgjelinek 54240209230bSgjelinek /* specific error msgs are printed within apply_rctls */ 54250209230bSgjelinek if ((err = zonecfg_apply_rctls(target_zone, handle)) != Z_OK) { 54260209230bSgjelinek errno = err; 54270209230bSgjelinek zperror(cmd_to_str(CMD_APPLY), B_TRUE); 54280209230bSgjelinek res = Z_ERR; 54290209230bSgjelinek } 54300209230bSgjelinek 54310209230bSgjelinek if ((err = check_cpu_shares_sched(handle)) != Z_OK) 54320209230bSgjelinek res = Z_ERR; 54330209230bSgjelinek 54347ef01d19Sgjelinek if (pool_configured(handle)) { 54357ef01d19Sgjelinek if (mixed_pools(zoneid)) { 54367ef01d19Sgjelinek zerror(gettext("Zone is using multiple resource " 54377ef01d19Sgjelinek "pools. The pool\nconfiguration cannot be " 54387ef01d19Sgjelinek "applied without rebooting.")); 54397ef01d19Sgjelinek res = Z_ERR; 54407ef01d19Sgjelinek } else { 54417ef01d19Sgjelinek 54420209230bSgjelinek /* 54437ef01d19Sgjelinek * The next two blocks of code attempt to set up 54447ef01d19Sgjelinek * temporary pools as well as persistent pools. In 54457ef01d19Sgjelinek * both cases we call the functions unconditionally. 54467ef01d19Sgjelinek * Within each funtion the code will check if the zone 54477ef01d19Sgjelinek * is actually configured for a temporary pool or 54487ef01d19Sgjelinek * persistent pool and just return if there is nothing 54497ef01d19Sgjelinek * to do. 54500209230bSgjelinek */ 54517ef01d19Sgjelinek if ((err = zonecfg_bind_tmp_pool(handle, zoneid, 54527ef01d19Sgjelinek pool_err, sizeof (pool_err))) != Z_OK) { 54537ef01d19Sgjelinek if (err == Z_POOL || err == Z_POOL_CREATE || 54547ef01d19Sgjelinek err == Z_POOL_BIND) 54557ef01d19Sgjelinek zerror("%s: %s", zonecfg_strerror(err), 54567ef01d19Sgjelinek pool_err); 54570209230bSgjelinek else 54587ef01d19Sgjelinek zerror(gettext("could not bind zone to " 54597ef01d19Sgjelinek "temporary pool: %s"), 54607ef01d19Sgjelinek zonecfg_strerror(err)); 54610209230bSgjelinek res = Z_ERR; 54620209230bSgjelinek } 54630209230bSgjelinek 54640209230bSgjelinek if ((err = zonecfg_bind_pool(handle, zoneid, pool_err, 54650209230bSgjelinek sizeof (pool_err))) != Z_OK) { 54660209230bSgjelinek if (err == Z_POOL || err == Z_POOL_BIND) 54677ef01d19Sgjelinek zerror("%s: %s", zonecfg_strerror(err), 54687ef01d19Sgjelinek pool_err); 54690209230bSgjelinek else 54700209230bSgjelinek zerror("%s", zonecfg_strerror(err)); 54710209230bSgjelinek } 54727ef01d19Sgjelinek } 54737ef01d19Sgjelinek } 54740209230bSgjelinek 54750209230bSgjelinek /* 54760209230bSgjelinek * If a memory cap is configured, set the cap in the kernel using 54770209230bSgjelinek * zone_setattr() and make sure the rcapd SMF service is enabled. 54780209230bSgjelinek */ 54790209230bSgjelinek if (zonecfg_getmcapent(handle, &mcap) == Z_OK) { 54800209230bSgjelinek uint64_t num; 54810209230bSgjelinek char smf_err[128]; 54820209230bSgjelinek 54830209230bSgjelinek num = (uint64_t)strtoll(mcap.zone_physmem_cap, NULL, 10); 54840209230bSgjelinek if (zone_setattr(zoneid, ZONE_ATTR_PHYS_MCAP, &num, 0) == -1) { 54850209230bSgjelinek zerror(gettext("could not set zone memory cap")); 54860209230bSgjelinek res = Z_ERR; 54870209230bSgjelinek } 54880209230bSgjelinek 54890209230bSgjelinek if (zonecfg_enable_rcapd(smf_err, sizeof (smf_err)) != Z_OK) { 54900209230bSgjelinek zerror(gettext("enabling system/rcap service failed: " 54910209230bSgjelinek "%s"), smf_err); 54920209230bSgjelinek res = Z_ERR; 54930209230bSgjelinek } 54940209230bSgjelinek } 54950209230bSgjelinek 54960209230bSgjelinek zonecfg_fini_handle(handle); 54970209230bSgjelinek 54980209230bSgjelinek return (res); 54990209230bSgjelinek } 55000209230bSgjelinek 5501555afedfScarlsonj static int 55027c478bd9Sstevel@tonic-gate help_func(int argc, char *argv[]) 55037c478bd9Sstevel@tonic-gate { 55047c478bd9Sstevel@tonic-gate int arg, cmd_num; 55057c478bd9Sstevel@tonic-gate 55067c478bd9Sstevel@tonic-gate if (argc == 0) { 55077c478bd9Sstevel@tonic-gate (void) usage(B_TRUE); 55087c478bd9Sstevel@tonic-gate return (Z_OK); 55097c478bd9Sstevel@tonic-gate } 55107c478bd9Sstevel@tonic-gate optind = 0; 55117c478bd9Sstevel@tonic-gate if ((arg = getopt(argc, argv, "?")) != EOF) { 55127c478bd9Sstevel@tonic-gate switch (arg) { 55137c478bd9Sstevel@tonic-gate case '?': 55147c478bd9Sstevel@tonic-gate sub_usage(SHELP_HELP, CMD_HELP); 55157c478bd9Sstevel@tonic-gate return (optopt == '?' ? Z_OK : Z_USAGE); 55167c478bd9Sstevel@tonic-gate default: 55177c478bd9Sstevel@tonic-gate sub_usage(SHELP_HELP, CMD_HELP); 55187c478bd9Sstevel@tonic-gate return (Z_USAGE); 55197c478bd9Sstevel@tonic-gate } 55207c478bd9Sstevel@tonic-gate } 55217c478bd9Sstevel@tonic-gate while (optind < argc) { 5522394a25e2Scarlsonj /* Private commands have NULL short_usage; omit them */ 5523394a25e2Scarlsonj if ((cmd_num = cmd_match(argv[optind])) < 0 || 5524394a25e2Scarlsonj cmdtab[cmd_num].short_usage == NULL) { 55257c478bd9Sstevel@tonic-gate sub_usage(SHELP_HELP, CMD_HELP); 55267c478bd9Sstevel@tonic-gate return (Z_USAGE); 55277c478bd9Sstevel@tonic-gate } 55287c478bd9Sstevel@tonic-gate sub_usage(cmdtab[cmd_num].short_usage, cmd_num); 55297c478bd9Sstevel@tonic-gate optind++; 55307c478bd9Sstevel@tonic-gate } 55317c478bd9Sstevel@tonic-gate return (Z_OK); 55327c478bd9Sstevel@tonic-gate } 55337c478bd9Sstevel@tonic-gate 55347c478bd9Sstevel@tonic-gate /* 55357c478bd9Sstevel@tonic-gate * Returns: CMD_MIN thru CMD_MAX on success, -1 on error 55367c478bd9Sstevel@tonic-gate */ 55377c478bd9Sstevel@tonic-gate 55387c478bd9Sstevel@tonic-gate static int 55397c478bd9Sstevel@tonic-gate cmd_match(char *cmd) 55407c478bd9Sstevel@tonic-gate { 55417c478bd9Sstevel@tonic-gate int i; 55427c478bd9Sstevel@tonic-gate 55437c478bd9Sstevel@tonic-gate for (i = CMD_MIN; i <= CMD_MAX; i++) { 55447c478bd9Sstevel@tonic-gate /* return only if there is an exact match */ 55457c478bd9Sstevel@tonic-gate if (strcmp(cmd, cmdtab[i].cmd_name) == 0) 55467c478bd9Sstevel@tonic-gate return (cmdtab[i].cmd_num); 55477c478bd9Sstevel@tonic-gate } 55487c478bd9Sstevel@tonic-gate return (-1); 55497c478bd9Sstevel@tonic-gate } 55507c478bd9Sstevel@tonic-gate 55517c478bd9Sstevel@tonic-gate static int 55527c478bd9Sstevel@tonic-gate parse_and_run(int argc, char *argv[]) 55537c478bd9Sstevel@tonic-gate { 55547c478bd9Sstevel@tonic-gate int i = cmd_match(argv[0]); 55557c478bd9Sstevel@tonic-gate 55567c478bd9Sstevel@tonic-gate if (i < 0) 55577c478bd9Sstevel@tonic-gate return (usage(B_FALSE)); 55587c478bd9Sstevel@tonic-gate return (cmdtab[i].handler(argc - 1, &(argv[1]))); 55597c478bd9Sstevel@tonic-gate } 55607c478bd9Sstevel@tonic-gate 55617c478bd9Sstevel@tonic-gate static char * 55627c478bd9Sstevel@tonic-gate get_execbasename(char *execfullname) 55637c478bd9Sstevel@tonic-gate { 55647c478bd9Sstevel@tonic-gate char *last_slash, *execbasename; 55657c478bd9Sstevel@tonic-gate 55667c478bd9Sstevel@tonic-gate /* guard against '/' at end of command invocation */ 55677c478bd9Sstevel@tonic-gate for (;;) { 55687c478bd9Sstevel@tonic-gate last_slash = strrchr(execfullname, '/'); 55697c478bd9Sstevel@tonic-gate if (last_slash == NULL) { 55707c478bd9Sstevel@tonic-gate execbasename = execfullname; 55717c478bd9Sstevel@tonic-gate break; 55727c478bd9Sstevel@tonic-gate } else { 55737c478bd9Sstevel@tonic-gate execbasename = last_slash + 1; 55747c478bd9Sstevel@tonic-gate if (*execbasename == '\0') { 55757c478bd9Sstevel@tonic-gate *last_slash = '\0'; 55767c478bd9Sstevel@tonic-gate continue; 55777c478bd9Sstevel@tonic-gate } 55787c478bd9Sstevel@tonic-gate break; 55797c478bd9Sstevel@tonic-gate } 55807c478bd9Sstevel@tonic-gate } 55817c478bd9Sstevel@tonic-gate return (execbasename); 55827c478bd9Sstevel@tonic-gate } 55837c478bd9Sstevel@tonic-gate 55847c478bd9Sstevel@tonic-gate int 55857c478bd9Sstevel@tonic-gate main(int argc, char **argv) 55867c478bd9Sstevel@tonic-gate { 55877c478bd9Sstevel@tonic-gate int arg; 55887c478bd9Sstevel@tonic-gate zoneid_t zid; 5589108322fbScarlsonj struct stat st; 55909acbbeafSnn35248 char *zone_lock_env; 55919acbbeafSnn35248 int err; 55927c478bd9Sstevel@tonic-gate 55937c478bd9Sstevel@tonic-gate if ((locale = setlocale(LC_ALL, "")) == NULL) 55947c478bd9Sstevel@tonic-gate locale = "C"; 55957c478bd9Sstevel@tonic-gate (void) textdomain(TEXT_DOMAIN); 55967c478bd9Sstevel@tonic-gate setbuf(stdout, NULL); 55977c478bd9Sstevel@tonic-gate (void) sigset(SIGHUP, SIG_IGN); 55987c478bd9Sstevel@tonic-gate execname = get_execbasename(argv[0]); 55997c478bd9Sstevel@tonic-gate target_zone = NULL; 56007c478bd9Sstevel@tonic-gate if (chdir("/") != 0) { 56017c478bd9Sstevel@tonic-gate zerror(gettext("could not change directory to /.")); 56027c478bd9Sstevel@tonic-gate exit(Z_ERR); 56037c478bd9Sstevel@tonic-gate } 56047c478bd9Sstevel@tonic-gate 560599653d4eSeschrock if (init_zfs() != Z_OK) 560699653d4eSeschrock exit(Z_ERR); 560799653d4eSeschrock 5608555afedfScarlsonj while ((arg = getopt(argc, argv, "?u:z:R:")) != EOF) { 56097c478bd9Sstevel@tonic-gate switch (arg) { 56107c478bd9Sstevel@tonic-gate case '?': 56117c478bd9Sstevel@tonic-gate return (usage(B_TRUE)); 5612555afedfScarlsonj case 'u': 5613555afedfScarlsonj target_uuid = optarg; 5614555afedfScarlsonj break; 56157c478bd9Sstevel@tonic-gate case 'z': 56167c478bd9Sstevel@tonic-gate target_zone = optarg; 56177c478bd9Sstevel@tonic-gate break; 5618108322fbScarlsonj case 'R': /* private option for admin/install use */ 5619108322fbScarlsonj if (*optarg != '/') { 5620108322fbScarlsonj zerror(gettext("root path must be absolute.")); 5621108322fbScarlsonj exit(Z_ERR); 5622108322fbScarlsonj } 5623108322fbScarlsonj if (stat(optarg, &st) == -1 || !S_ISDIR(st.st_mode)) { 5624108322fbScarlsonj zerror( 5625108322fbScarlsonj gettext("root path must be a directory.")); 5626108322fbScarlsonj exit(Z_ERR); 5627108322fbScarlsonj } 5628108322fbScarlsonj zonecfg_set_root(optarg); 5629108322fbScarlsonj break; 56307c478bd9Sstevel@tonic-gate default: 56317c478bd9Sstevel@tonic-gate return (usage(B_FALSE)); 56327c478bd9Sstevel@tonic-gate } 56337c478bd9Sstevel@tonic-gate } 56347c478bd9Sstevel@tonic-gate 56357c478bd9Sstevel@tonic-gate if (optind >= argc) 56367c478bd9Sstevel@tonic-gate return (usage(B_FALSE)); 5637555afedfScarlsonj 5638555afedfScarlsonj if (target_uuid != NULL && *target_uuid != '\0') { 5639555afedfScarlsonj uuid_t uuid; 5640555afedfScarlsonj static char newtarget[ZONENAME_MAX]; 5641555afedfScarlsonj 5642555afedfScarlsonj if (uuid_parse(target_uuid, uuid) == -1) { 5643555afedfScarlsonj zerror(gettext("illegal UUID value specified")); 5644555afedfScarlsonj exit(Z_ERR); 5645555afedfScarlsonj } 5646555afedfScarlsonj if (zonecfg_get_name_by_uuid(uuid, newtarget, 5647555afedfScarlsonj sizeof (newtarget)) == Z_OK) 5648555afedfScarlsonj target_zone = newtarget; 5649555afedfScarlsonj } 5650555afedfScarlsonj 56517c478bd9Sstevel@tonic-gate if (target_zone != NULL && zone_get_id(target_zone, &zid) != 0) { 56527c478bd9Sstevel@tonic-gate errno = Z_NO_ZONE; 56537c478bd9Sstevel@tonic-gate zperror(target_zone, B_TRUE); 56547c478bd9Sstevel@tonic-gate exit(Z_ERR); 56557c478bd9Sstevel@tonic-gate } 56569acbbeafSnn35248 56579acbbeafSnn35248 /* 56589acbbeafSnn35248 * See if we have inherited the right to manipulate this zone from 56599acbbeafSnn35248 * a zoneadm instance in our ancestry. If so, set zone_lock_cnt to 56609acbbeafSnn35248 * indicate it. If not, make that explicit in our environment. 56619acbbeafSnn35248 */ 56629acbbeafSnn35248 zone_lock_env = getenv(LOCK_ENV_VAR); 56639acbbeafSnn35248 if (zone_lock_env == NULL) { 56649acbbeafSnn35248 if (putenv(zoneadm_lock_not_held) != 0) { 56659acbbeafSnn35248 zperror(target_zone, B_TRUE); 56669acbbeafSnn35248 exit(Z_ERR); 56679acbbeafSnn35248 } 56689acbbeafSnn35248 } else { 56699acbbeafSnn35248 zoneadm_is_nested = B_TRUE; 56709acbbeafSnn35248 if (atoi(zone_lock_env) == 1) 56719acbbeafSnn35248 zone_lock_cnt = 1; 56729acbbeafSnn35248 } 56739acbbeafSnn35248 56749acbbeafSnn35248 /* 56759acbbeafSnn35248 * If we are going to be operating on a single zone, retrieve its 56769acbbeafSnn35248 * brand type and determine whether it is native or not. 56779acbbeafSnn35248 */ 56789acbbeafSnn35248 if ((target_zone != NULL) && 56799acbbeafSnn35248 (strcmp(target_zone, GLOBAL_ZONENAME) != NULL)) { 56809acbbeafSnn35248 if (zone_get_brand(target_zone, target_brand, 56819acbbeafSnn35248 sizeof (target_brand)) != Z_OK) { 56829acbbeafSnn35248 zerror(gettext("missing or invalid brand")); 56839acbbeafSnn35248 exit(Z_ERR); 56849acbbeafSnn35248 } 56859acbbeafSnn35248 is_native_zone = (strcmp(target_brand, NATIVE_BRAND_NAME) == 0); 56869acbbeafSnn35248 } 56879acbbeafSnn35248 56889acbbeafSnn35248 err = parse_and_run(argc - optind, &argv[optind]); 56899acbbeafSnn35248 56909acbbeafSnn35248 return (err); 56917c478bd9Sstevel@tonic-gate } 5692