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 5fb03efaaSdp * Common Development and Distribution License (the "License"). 6fb03efaaSdp * 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 /* 236d4d1c0dSbatschul * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved. 247c478bd9Sstevel@tonic-gate */ 257c478bd9Sstevel@tonic-gate 267c478bd9Sstevel@tonic-gate /* 277c478bd9Sstevel@tonic-gate * zonecfg is a lex/yacc based command interpreter used to manage zone 287c478bd9Sstevel@tonic-gate * configurations. The lexer (see zonecfg_lex.l) builds up tokens, which 297c478bd9Sstevel@tonic-gate * the grammar (see zonecfg_grammar.y) builds up into commands, some of 307c478bd9Sstevel@tonic-gate * which takes resources and/or properties as arguments. See the block 317c478bd9Sstevel@tonic-gate * comments near the end of zonecfg_grammar.y for how the data structures 327c478bd9Sstevel@tonic-gate * which keep track of these resources and properties are built up. 337c478bd9Sstevel@tonic-gate * 347c478bd9Sstevel@tonic-gate * The resource/property data structures are inserted into a command 357c478bd9Sstevel@tonic-gate * structure (see zonecfg.h), which also keeps track of command names, 367c478bd9Sstevel@tonic-gate * miscellaneous arguments, and function handlers. The grammar selects 377c478bd9Sstevel@tonic-gate * the appropriate function handler, each of which takes a pointer to a 387c478bd9Sstevel@tonic-gate * command structure as its sole argument, and invokes it. The grammar 397c478bd9Sstevel@tonic-gate * itself is "entered" (a la the Matrix) by yyparse(), which is called 407c478bd9Sstevel@tonic-gate * from read_input(), our main driving function. That in turn is called 417c478bd9Sstevel@tonic-gate * by one of do_interactive(), cmd_file() or one_command_at_a_time(), each 427c478bd9Sstevel@tonic-gate * of which is called from main() depending on how the program was invoked. 437c478bd9Sstevel@tonic-gate * 447c478bd9Sstevel@tonic-gate * The rest of this module consists of the various function handlers and 457c478bd9Sstevel@tonic-gate * their helper functions. Some of these functions, particularly the 467c478bd9Sstevel@tonic-gate * X_to_str() functions, which maps command, resource and property numbers 477c478bd9Sstevel@tonic-gate * to strings, are used quite liberally, as doing so results in a better 487c478bd9Sstevel@tonic-gate * program w/rt I18N, reducing the need for translation notes. 497c478bd9Sstevel@tonic-gate */ 507c478bd9Sstevel@tonic-gate 517c478bd9Sstevel@tonic-gate #include <sys/mntent.h> 527c478bd9Sstevel@tonic-gate #include <sys/varargs.h> 537c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h> 547c478bd9Sstevel@tonic-gate 557c478bd9Sstevel@tonic-gate #include <errno.h> 569acbbeafSnn #include <fcntl.h> 577c478bd9Sstevel@tonic-gate #include <strings.h> 587c478bd9Sstevel@tonic-gate #include <unistd.h> 597c478bd9Sstevel@tonic-gate #include <ctype.h> 607c478bd9Sstevel@tonic-gate #include <stdlib.h> 617c478bd9Sstevel@tonic-gate #include <assert.h> 627c478bd9Sstevel@tonic-gate #include <sys/stat.h> 637c478bd9Sstevel@tonic-gate #include <zone.h> 647c478bd9Sstevel@tonic-gate #include <arpa/inet.h> 657c478bd9Sstevel@tonic-gate #include <netdb.h> 667c478bd9Sstevel@tonic-gate #include <locale.h> 677c478bd9Sstevel@tonic-gate #include <libintl.h> 687c478bd9Sstevel@tonic-gate #include <alloca.h> 697c478bd9Sstevel@tonic-gate #include <signal.h> 709acbbeafSnn #include <wait.h> 717c478bd9Sstevel@tonic-gate #include <libtecla.h> 72fa9e4066Sahrens #include <libzfs.h> 739acbbeafSnn #include <sys/brand.h> 749acbbeafSnn #include <libbrand.h> 755679c89fSjv #include <sys/systeminfo.h> 76c9f134eaSjv #include <libdladm.h> 77c9f134eaSjv #include <libinetutil.h> 78cb8a054bSGlenn Faden #include <pwd.h> 797c478bd9Sstevel@tonic-gate 807c478bd9Sstevel@tonic-gate #include <libzonecfg.h> 817c478bd9Sstevel@tonic-gate #include "zonecfg.h" 827c478bd9Sstevel@tonic-gate 837c478bd9Sstevel@tonic-gate #if !defined(TEXT_DOMAIN) /* should be defined by cc -D */ 847c478bd9Sstevel@tonic-gate #define TEXT_DOMAIN "SYS_TEST" /* Use this only if it wasn't */ 857c478bd9Sstevel@tonic-gate #endif 867c478bd9Sstevel@tonic-gate 877c478bd9Sstevel@tonic-gate #define PAGER "/usr/bin/more" 889acbbeafSnn #define EXEC_PREFIX "exec " 899acbbeafSnn #define EXEC_LEN (strlen(EXEC_PREFIX)) 907c478bd9Sstevel@tonic-gate 917c478bd9Sstevel@tonic-gate struct help { 927c478bd9Sstevel@tonic-gate uint_t cmd_num; 937c478bd9Sstevel@tonic-gate char *cmd_name; 947c478bd9Sstevel@tonic-gate uint_t flags; 957c478bd9Sstevel@tonic-gate char *short_usage; 967c478bd9Sstevel@tonic-gate }; 977c478bd9Sstevel@tonic-gate 987c478bd9Sstevel@tonic-gate extern int yyparse(void); 997c478bd9Sstevel@tonic-gate extern int lex_lineno; 1007c478bd9Sstevel@tonic-gate 1017c478bd9Sstevel@tonic-gate #define MAX_LINE_LEN 1024 1027c478bd9Sstevel@tonic-gate #define MAX_CMD_HIST 1024 1039acbbeafSnn #define MAX_CMD_LEN 1024 1047c478bd9Sstevel@tonic-gate 1050209230bSgjelinek #define ONE_MB 1048576 1060209230bSgjelinek 1077c478bd9Sstevel@tonic-gate /* 1087c478bd9Sstevel@tonic-gate * Each SHELP_ should be a simple string. 1097c478bd9Sstevel@tonic-gate */ 1107c478bd9Sstevel@tonic-gate 1117c478bd9Sstevel@tonic-gate #define SHELP_ADD "add <resource-type>\n\t(global scope)\n" \ 1127c478bd9Sstevel@tonic-gate "add <property-name> <property-value>\n\t(resource scope)" 1137c478bd9Sstevel@tonic-gate #define SHELP_CANCEL "cancel" 1140209230bSgjelinek #define SHELP_CLEAR "clear <property-name>" 1157c478bd9Sstevel@tonic-gate #define SHELP_COMMIT "commit" 116ee519a1fSgjelinek #define SHELP_CREATE "create [-F] [ -a <path> | -b | -t <template> ]" 1177c478bd9Sstevel@tonic-gate #define SHELP_DELETE "delete [-F]" 1187c478bd9Sstevel@tonic-gate #define SHELP_END "end" 1197c478bd9Sstevel@tonic-gate #define SHELP_EXIT "exit [-F]" 1207c478bd9Sstevel@tonic-gate #define SHELP_EXPORT "export [-f output-file]" 1217c478bd9Sstevel@tonic-gate #define SHELP_HELP "help [commands] [syntax] [usage] [<command-name>]" 1227c478bd9Sstevel@tonic-gate #define SHELP_INFO "info [<resource-type> [property-name=property-value]*]" 1230209230bSgjelinek #define SHELP_REMOVE "remove [-F] <resource-type> " \ 1240209230bSgjelinek "[ <property-name>=<property-value> ]*\n" \ 1250209230bSgjelinek "\t(global scope)\n" \ 1260209230bSgjelinek "remove <property-name> <property-value>\n" \ 1270209230bSgjelinek "\t(resource scope)" 1287c478bd9Sstevel@tonic-gate #define SHELP_REVERT "revert [-F]" 1297c478bd9Sstevel@tonic-gate #define SHELP_SELECT "select <resource-type> { <property-name>=" \ 1307c478bd9Sstevel@tonic-gate "<property-value> }" 1317c478bd9Sstevel@tonic-gate #define SHELP_SET "set <property-name>=<property-value>" 1327c478bd9Sstevel@tonic-gate #define SHELP_VERIFY "verify" 1337c478bd9Sstevel@tonic-gate 1347c478bd9Sstevel@tonic-gate static struct help helptab[] = { 1357c478bd9Sstevel@tonic-gate { CMD_ADD, "add", HELP_RES_PROPS, SHELP_ADD, }, 1367c478bd9Sstevel@tonic-gate { CMD_CANCEL, "cancel", 0, SHELP_CANCEL, }, 1370209230bSgjelinek { CMD_CLEAR, "clear", HELP_PROPS, SHELP_CLEAR, }, 1387c478bd9Sstevel@tonic-gate { CMD_COMMIT, "commit", 0, SHELP_COMMIT, }, 1397c478bd9Sstevel@tonic-gate { CMD_CREATE, "create", 0, SHELP_CREATE, }, 1407c478bd9Sstevel@tonic-gate { CMD_DELETE, "delete", 0, SHELP_DELETE, }, 1417c478bd9Sstevel@tonic-gate { CMD_END, "end", 0, SHELP_END, }, 1427c478bd9Sstevel@tonic-gate { CMD_EXIT, "exit", 0, SHELP_EXIT, }, 1437c478bd9Sstevel@tonic-gate { CMD_EXPORT, "export", 0, SHELP_EXPORT, }, 1447c478bd9Sstevel@tonic-gate { CMD_HELP, "help", 0, SHELP_HELP }, 1457c478bd9Sstevel@tonic-gate { CMD_INFO, "info", HELP_RES_PROPS, SHELP_INFO, }, 1467c478bd9Sstevel@tonic-gate { CMD_REMOVE, "remove", HELP_RES_PROPS, SHELP_REMOVE, }, 1477c478bd9Sstevel@tonic-gate { CMD_REVERT, "revert", 0, SHELP_REVERT, }, 1487c478bd9Sstevel@tonic-gate { CMD_SELECT, "select", HELP_RES_PROPS, SHELP_SELECT, }, 1497c478bd9Sstevel@tonic-gate { CMD_SET, "set", HELP_PROPS, SHELP_SET, }, 1507c478bd9Sstevel@tonic-gate { CMD_VERIFY, "verify", 0, SHELP_VERIFY, }, 1517c478bd9Sstevel@tonic-gate { 0 }, 1527c478bd9Sstevel@tonic-gate }; 1537c478bd9Sstevel@tonic-gate 1547c478bd9Sstevel@tonic-gate #define MAX_RT_STRLEN 16 1557c478bd9Sstevel@tonic-gate 1567c478bd9Sstevel@tonic-gate /* These *must* match the order of the RT_ define's from zonecfg.h */ 157c94c1ef0Sjv char *res_types[] = { 1587c478bd9Sstevel@tonic-gate "unknown", 159087719fdSdp "zonename", 1607c478bd9Sstevel@tonic-gate "zonepath", 1617c478bd9Sstevel@tonic-gate "autoboot", 1627c478bd9Sstevel@tonic-gate "pool", 1637c478bd9Sstevel@tonic-gate "fs", 1647c478bd9Sstevel@tonic-gate "inherit-pkg-dir", 1657c478bd9Sstevel@tonic-gate "net", 1667c478bd9Sstevel@tonic-gate "device", 1677c478bd9Sstevel@tonic-gate "rctl", 1687c478bd9Sstevel@tonic-gate "attr", 169fa9e4066Sahrens "dataset", 170ffbafc53Scomay "limitpriv", 1713f2f09c1Sdp "bootargs", 1729acbbeafSnn "brand", 1730209230bSgjelinek "dedicated-cpu", 1740209230bSgjelinek "capped-memory", 1750209230bSgjelinek ALIAS_MAXLWPS, 1760209230bSgjelinek ALIAS_MAXSHMMEM, 1770209230bSgjelinek ALIAS_MAXSHMIDS, 1780209230bSgjelinek ALIAS_MAXMSGIDS, 1790209230bSgjelinek ALIAS_MAXSEMIDS, 1800209230bSgjelinek ALIAS_SHARES, 1810209230bSgjelinek "scheduling-class", 182f4b3ec61Sdh "ip-type", 183c97ad5cdSakolb "capped-cpu", 1845679c89fSjv "hostid", 185cb8a054bSGlenn Faden "admin", 1860fbb751dSJohn Levon "fs-allowed", 187*ff19e029SMenno Lageman ALIAS_MAXPROCS, 1887c478bd9Sstevel@tonic-gate NULL 1897c478bd9Sstevel@tonic-gate }; 1907c478bd9Sstevel@tonic-gate 1917c478bd9Sstevel@tonic-gate /* These *must* match the order of the PT_ define's from zonecfg.h */ 192c94c1ef0Sjv char *prop_types[] = { 1937c478bd9Sstevel@tonic-gate "unknown", 194087719fdSdp "zonename", 1957c478bd9Sstevel@tonic-gate "zonepath", 1967c478bd9Sstevel@tonic-gate "autoboot", 1977c478bd9Sstevel@tonic-gate "pool", 1987c478bd9Sstevel@tonic-gate "dir", 1997c478bd9Sstevel@tonic-gate "special", 2007c478bd9Sstevel@tonic-gate "type", 2017c478bd9Sstevel@tonic-gate "options", 2027c478bd9Sstevel@tonic-gate "address", 2037c478bd9Sstevel@tonic-gate "physical", 2047c478bd9Sstevel@tonic-gate "name", 2057c478bd9Sstevel@tonic-gate "value", 2067c478bd9Sstevel@tonic-gate "match", 2077c478bd9Sstevel@tonic-gate "priv", 2087c478bd9Sstevel@tonic-gate "limit", 2097c478bd9Sstevel@tonic-gate "action", 2107c478bd9Sstevel@tonic-gate "raw", 211ffbafc53Scomay "limitpriv", 2123f2f09c1Sdp "bootargs", 2139acbbeafSnn "brand", 2140209230bSgjelinek "ncpus", 2150209230bSgjelinek "importance", 2160209230bSgjelinek "swap", 2170209230bSgjelinek "locked", 2180209230bSgjelinek ALIAS_SHARES, 2190209230bSgjelinek ALIAS_MAXLWPS, 2200209230bSgjelinek ALIAS_MAXSHMMEM, 2210209230bSgjelinek ALIAS_MAXSHMIDS, 2220209230bSgjelinek ALIAS_MAXMSGIDS, 2230209230bSgjelinek ALIAS_MAXSEMIDS, 2240209230bSgjelinek ALIAS_MAXLOCKEDMEM, 2250209230bSgjelinek ALIAS_MAXSWAP, 2260209230bSgjelinek "scheduling-class", 227f4b3ec61Sdh "ip-type", 228de860bd9Sgfaden "defrouter", 2295679c89fSjv "hostid", 230cb8a054bSGlenn Faden "user", 231cb8a054bSGlenn Faden "auths", 2320fbb751dSJohn Levon "fs-allowed", 233*ff19e029SMenno Lageman ALIAS_MAXPROCS, 2347c478bd9Sstevel@tonic-gate NULL 2357c478bd9Sstevel@tonic-gate }; 2367c478bd9Sstevel@tonic-gate 237ffbafc53Scomay /* These *must* match the order of the PROP_VAL_ define's from zonecfg.h */ 2387c478bd9Sstevel@tonic-gate static char *prop_val_types[] = { 2397c478bd9Sstevel@tonic-gate "simple", 2407c478bd9Sstevel@tonic-gate "complex", 2417c478bd9Sstevel@tonic-gate "list", 2427c478bd9Sstevel@tonic-gate }; 2437c478bd9Sstevel@tonic-gate 2447c478bd9Sstevel@tonic-gate /* 2457c478bd9Sstevel@tonic-gate * The various _cmds[] lists below are for command tab-completion. 2467c478bd9Sstevel@tonic-gate */ 2477c478bd9Sstevel@tonic-gate 2487c478bd9Sstevel@tonic-gate /* 2497c478bd9Sstevel@tonic-gate * remove has a space afterwards because it has qualifiers; the other commands 2500209230bSgjelinek * that have qualifiers (add, select, etc.) don't need a space here because 2517c478bd9Sstevel@tonic-gate * they have their own _cmds[] lists below. 2527c478bd9Sstevel@tonic-gate */ 2537c478bd9Sstevel@tonic-gate static const char *global_scope_cmds[] = { 2547c478bd9Sstevel@tonic-gate "add", 2550209230bSgjelinek "clear", 2567c478bd9Sstevel@tonic-gate "commit", 2577c478bd9Sstevel@tonic-gate "create", 2587c478bd9Sstevel@tonic-gate "delete", 2597c478bd9Sstevel@tonic-gate "exit", 2607c478bd9Sstevel@tonic-gate "export", 2617c478bd9Sstevel@tonic-gate "help", 2627c478bd9Sstevel@tonic-gate "info", 2637c478bd9Sstevel@tonic-gate "remove ", 2647c478bd9Sstevel@tonic-gate "revert", 2657c478bd9Sstevel@tonic-gate "select", 2667c478bd9Sstevel@tonic-gate "set", 2677c478bd9Sstevel@tonic-gate "verify", 2687c478bd9Sstevel@tonic-gate NULL 2697c478bd9Sstevel@tonic-gate }; 2707c478bd9Sstevel@tonic-gate 2717c478bd9Sstevel@tonic-gate static const char *add_cmds[] = { 2727c478bd9Sstevel@tonic-gate "add fs", 2737c478bd9Sstevel@tonic-gate "add inherit-pkg-dir", 2747c478bd9Sstevel@tonic-gate "add net", 2757c478bd9Sstevel@tonic-gate "add device", 2767c478bd9Sstevel@tonic-gate "add rctl", 2777c478bd9Sstevel@tonic-gate "add attr", 278fa9e4066Sahrens "add dataset", 2790209230bSgjelinek "add dedicated-cpu", 280c97ad5cdSakolb "add capped-cpu", 2810209230bSgjelinek "add capped-memory", 282cb8a054bSGlenn Faden "add admin", 2830209230bSgjelinek NULL 2840209230bSgjelinek }; 2850209230bSgjelinek 2860209230bSgjelinek static const char *clear_cmds[] = { 2870209230bSgjelinek "clear autoboot", 2880209230bSgjelinek "clear pool", 2890209230bSgjelinek "clear limitpriv", 2900209230bSgjelinek "clear bootargs", 2910209230bSgjelinek "clear scheduling-class", 292f4b3ec61Sdh "clear ip-type", 2930209230bSgjelinek "clear " ALIAS_MAXLWPS, 2940209230bSgjelinek "clear " ALIAS_MAXSHMMEM, 2950209230bSgjelinek "clear " ALIAS_MAXSHMIDS, 2960209230bSgjelinek "clear " ALIAS_MAXMSGIDS, 2970209230bSgjelinek "clear " ALIAS_MAXSEMIDS, 2980209230bSgjelinek "clear " ALIAS_SHARES, 299*ff19e029SMenno Lageman "clear " ALIAS_MAXPROCS, 3007c478bd9Sstevel@tonic-gate NULL 3017c478bd9Sstevel@tonic-gate }; 3027c478bd9Sstevel@tonic-gate 3039e7542f4Sdp static const char *remove_cmds[] = { 3049e7542f4Sdp "remove fs ", 3059e7542f4Sdp "remove inherit-pkg-dir ", 3069e7542f4Sdp "remove net ", 3079e7542f4Sdp "remove device ", 3089e7542f4Sdp "remove rctl ", 3099e7542f4Sdp "remove attr ", 3109e7542f4Sdp "remove dataset ", 3110209230bSgjelinek "remove dedicated-cpu ", 312c97ad5cdSakolb "remove capped-cpu ", 3130209230bSgjelinek "remove capped-memory ", 314cb8a054bSGlenn Faden "remove admin ", 3159e7542f4Sdp NULL 3169e7542f4Sdp }; 3179e7542f4Sdp 3187c478bd9Sstevel@tonic-gate static const char *select_cmds[] = { 319087719fdSdp "select fs ", 320087719fdSdp "select inherit-pkg-dir ", 321087719fdSdp "select net ", 322087719fdSdp "select device ", 323087719fdSdp "select rctl ", 324087719fdSdp "select attr ", 325fa9e4066Sahrens "select dataset ", 3260209230bSgjelinek "select dedicated-cpu", 327c97ad5cdSakolb "select capped-cpu", 3280209230bSgjelinek "select capped-memory", 329cb8a054bSGlenn Faden "select admin", 3307c478bd9Sstevel@tonic-gate NULL 3317c478bd9Sstevel@tonic-gate }; 3327c478bd9Sstevel@tonic-gate 3337c478bd9Sstevel@tonic-gate static const char *set_cmds[] = { 334087719fdSdp "set zonename=", 335087719fdSdp "set zonepath=", 3369acbbeafSnn "set brand=", 337087719fdSdp "set autoboot=", 338087719fdSdp "set pool=", 339ffbafc53Scomay "set limitpriv=", 3403f2f09c1Sdp "set bootargs=", 3410209230bSgjelinek "set scheduling-class=", 342f4b3ec61Sdh "set ip-type=", 3430209230bSgjelinek "set " ALIAS_MAXLWPS "=", 3440209230bSgjelinek "set " ALIAS_MAXSHMMEM "=", 3450209230bSgjelinek "set " ALIAS_MAXSHMIDS "=", 3460209230bSgjelinek "set " ALIAS_MAXMSGIDS "=", 3470209230bSgjelinek "set " ALIAS_MAXSEMIDS "=", 3480209230bSgjelinek "set " ALIAS_SHARES "=", 3495679c89fSjv "set hostid=", 3500fbb751dSJohn Levon "set fs-allowed=", 351*ff19e029SMenno Lageman "set " ALIAS_MAXPROCS "=", 3527c478bd9Sstevel@tonic-gate NULL 3537c478bd9Sstevel@tonic-gate }; 3547c478bd9Sstevel@tonic-gate 3559e7542f4Sdp static const char *info_cmds[] = { 3569e7542f4Sdp "info fs ", 3579e7542f4Sdp "info inherit-pkg-dir ", 3589e7542f4Sdp "info net ", 3599e7542f4Sdp "info device ", 3609e7542f4Sdp "info rctl ", 3619e7542f4Sdp "info attr ", 3629e7542f4Sdp "info dataset ", 3630209230bSgjelinek "info capped-memory", 3640209230bSgjelinek "info dedicated-cpu", 365c97ad5cdSakolb "info capped-cpu", 3669e7542f4Sdp "info zonename", 3679e7542f4Sdp "info zonepath", 3689e7542f4Sdp "info autoboot", 3699e7542f4Sdp "info pool", 3709e7542f4Sdp "info limitpriv", 3719e7542f4Sdp "info bootargs", 3720209230bSgjelinek "info brand", 3730209230bSgjelinek "info scheduling-class", 374f4b3ec61Sdh "info ip-type", 3750209230bSgjelinek "info max-lwps", 3760209230bSgjelinek "info max-shm-memory", 3770209230bSgjelinek "info max-shm-ids", 3780209230bSgjelinek "info max-msg-ids", 3790209230bSgjelinek "info max-sem-ids", 3800209230bSgjelinek "info cpu-shares", 3815679c89fSjv "info hostid", 382cb8a054bSGlenn Faden "info admin", 3830fbb751dSJohn Levon "info fs-allowed", 384*ff19e029SMenno Lageman "info max-processes", 3859e7542f4Sdp NULL 3869e7542f4Sdp }; 3879e7542f4Sdp 3887c478bd9Sstevel@tonic-gate static const char *fs_res_scope_cmds[] = { 3897c478bd9Sstevel@tonic-gate "add options ", 3907c478bd9Sstevel@tonic-gate "cancel", 3917c478bd9Sstevel@tonic-gate "end", 3927c478bd9Sstevel@tonic-gate "exit", 3937c478bd9Sstevel@tonic-gate "help", 3947c478bd9Sstevel@tonic-gate "info", 395ffbafc53Scomay "remove options ", 3967c478bd9Sstevel@tonic-gate "set dir=", 3977c478bd9Sstevel@tonic-gate "set raw=", 3987c478bd9Sstevel@tonic-gate "set special=", 3997c478bd9Sstevel@tonic-gate "set type=", 4000209230bSgjelinek "clear raw", 4017c478bd9Sstevel@tonic-gate NULL 4027c478bd9Sstevel@tonic-gate }; 4037c478bd9Sstevel@tonic-gate 4047c478bd9Sstevel@tonic-gate static const char *net_res_scope_cmds[] = { 4057c478bd9Sstevel@tonic-gate "cancel", 4067c478bd9Sstevel@tonic-gate "end", 4077c478bd9Sstevel@tonic-gate "exit", 4087c478bd9Sstevel@tonic-gate "help", 4097c478bd9Sstevel@tonic-gate "info", 4107c478bd9Sstevel@tonic-gate "set address=", 4117c478bd9Sstevel@tonic-gate "set physical=", 4121b3281c0SGerald Jelinek "set defrouter=", 4137c478bd9Sstevel@tonic-gate NULL 4147c478bd9Sstevel@tonic-gate }; 4157c478bd9Sstevel@tonic-gate 4167c478bd9Sstevel@tonic-gate static const char *ipd_res_scope_cmds[] = { 4177c478bd9Sstevel@tonic-gate "cancel", 4187c478bd9Sstevel@tonic-gate "end", 4197c478bd9Sstevel@tonic-gate "exit", 4207c478bd9Sstevel@tonic-gate "help", 4217c478bd9Sstevel@tonic-gate "info", 4227c478bd9Sstevel@tonic-gate "set dir=", 4237c478bd9Sstevel@tonic-gate NULL 4247c478bd9Sstevel@tonic-gate }; 4257c478bd9Sstevel@tonic-gate 4267c478bd9Sstevel@tonic-gate static const char *device_res_scope_cmds[] = { 4277c478bd9Sstevel@tonic-gate "cancel", 4287c478bd9Sstevel@tonic-gate "end", 4297c478bd9Sstevel@tonic-gate "exit", 4307c478bd9Sstevel@tonic-gate "help", 4317c478bd9Sstevel@tonic-gate "info", 4327c478bd9Sstevel@tonic-gate "set match=", 4337c478bd9Sstevel@tonic-gate NULL 4347c478bd9Sstevel@tonic-gate }; 4357c478bd9Sstevel@tonic-gate 4367c478bd9Sstevel@tonic-gate static const char *attr_res_scope_cmds[] = { 4377c478bd9Sstevel@tonic-gate "cancel", 4387c478bd9Sstevel@tonic-gate "end", 4397c478bd9Sstevel@tonic-gate "exit", 4407c478bd9Sstevel@tonic-gate "help", 4417c478bd9Sstevel@tonic-gate "info", 4427c478bd9Sstevel@tonic-gate "set name=", 4437c478bd9Sstevel@tonic-gate "set type=", 4447c478bd9Sstevel@tonic-gate "set value=", 4457c478bd9Sstevel@tonic-gate NULL 4467c478bd9Sstevel@tonic-gate }; 4477c478bd9Sstevel@tonic-gate 4487c478bd9Sstevel@tonic-gate static const char *rctl_res_scope_cmds[] = { 4497c478bd9Sstevel@tonic-gate "add value ", 4507c478bd9Sstevel@tonic-gate "cancel", 4517c478bd9Sstevel@tonic-gate "end", 4527c478bd9Sstevel@tonic-gate "exit", 4537c478bd9Sstevel@tonic-gate "help", 4547c478bd9Sstevel@tonic-gate "info", 455ffbafc53Scomay "remove value ", 4567c478bd9Sstevel@tonic-gate "set name=", 4577c478bd9Sstevel@tonic-gate NULL 4587c478bd9Sstevel@tonic-gate }; 4597c478bd9Sstevel@tonic-gate 460fa9e4066Sahrens static const char *dataset_res_scope_cmds[] = { 461fa9e4066Sahrens "cancel", 462fa9e4066Sahrens "end", 463fa9e4066Sahrens "exit", 464fa9e4066Sahrens "help", 465fa9e4066Sahrens "info", 466fa9e4066Sahrens "set name=", 467fa9e4066Sahrens NULL 468fa9e4066Sahrens }; 469fa9e4066Sahrens 4700209230bSgjelinek static const char *pset_res_scope_cmds[] = { 4710209230bSgjelinek "cancel", 4720209230bSgjelinek "end", 4730209230bSgjelinek "exit", 4740209230bSgjelinek "help", 4750209230bSgjelinek "info", 4760209230bSgjelinek "set ncpus=", 4770209230bSgjelinek "set importance=", 4780209230bSgjelinek "clear importance", 4790209230bSgjelinek NULL 4800209230bSgjelinek }; 4810209230bSgjelinek 482c97ad5cdSakolb static const char *pcap_res_scope_cmds[] = { 483c97ad5cdSakolb "cancel", 484c97ad5cdSakolb "end", 485c97ad5cdSakolb "exit", 486c97ad5cdSakolb "help", 487c97ad5cdSakolb "info", 488c97ad5cdSakolb "set ncpus=", 489c97ad5cdSakolb NULL 490c97ad5cdSakolb }; 491c97ad5cdSakolb 4920209230bSgjelinek static const char *mcap_res_scope_cmds[] = { 4930209230bSgjelinek "cancel", 4940209230bSgjelinek "end", 4950209230bSgjelinek "exit", 4960209230bSgjelinek "help", 4970209230bSgjelinek "info", 4980209230bSgjelinek "set physical=", 4990209230bSgjelinek "set swap=", 5000209230bSgjelinek "set locked=", 5010209230bSgjelinek "clear physical", 5020209230bSgjelinek "clear swap", 5030209230bSgjelinek "clear locked", 5040209230bSgjelinek NULL 5050209230bSgjelinek }; 5060209230bSgjelinek 507cb8a054bSGlenn Faden static const char *admin_res_scope_cmds[] = { 508cb8a054bSGlenn Faden "cancel", 509cb8a054bSGlenn Faden "end", 510cb8a054bSGlenn Faden "exit", 511cb8a054bSGlenn Faden "help", 512cb8a054bSGlenn Faden "info", 513cb8a054bSGlenn Faden "set user=", 514cb8a054bSGlenn Faden "set auths=", 515cb8a054bSGlenn Faden NULL 516cb8a054bSGlenn Faden }; 517cb8a054bSGlenn Faden 5187c478bd9Sstevel@tonic-gate /* Global variables */ 5197c478bd9Sstevel@tonic-gate 5207c478bd9Sstevel@tonic-gate /* set early in main(), never modified thereafter, used all over the place */ 5217c478bd9Sstevel@tonic-gate static char *execname; 5227c478bd9Sstevel@tonic-gate 5237c478bd9Sstevel@tonic-gate /* set in main(), used all over the place */ 5247c478bd9Sstevel@tonic-gate static zone_dochandle_t handle; 5257c478bd9Sstevel@tonic-gate 5267c478bd9Sstevel@tonic-gate /* used all over the place */ 527087719fdSdp static char zone[ZONENAME_MAX]; 528087719fdSdp static char revert_zone[ZONENAME_MAX]; 5297c478bd9Sstevel@tonic-gate 5309acbbeafSnn /* global brand operations */ 531123807fbSedp static brand_handle_t brand; 5329acbbeafSnn 5337c478bd9Sstevel@tonic-gate /* set in modifying functions, checked in read_input() */ 534bbec428eSgjelinek static boolean_t need_to_commit = B_FALSE; 535bbec428eSgjelinek boolean_t saw_error; 5367c478bd9Sstevel@tonic-gate 5377c478bd9Sstevel@tonic-gate /* set in yacc parser, checked in read_input() */ 538bbec428eSgjelinek boolean_t newline_terminated; 5397c478bd9Sstevel@tonic-gate 5407c478bd9Sstevel@tonic-gate /* set in main(), checked in lex error handler */ 541bbec428eSgjelinek boolean_t cmd_file_mode; 5427c478bd9Sstevel@tonic-gate 5437c478bd9Sstevel@tonic-gate /* set in exit_func(), checked in read_input() */ 544bbec428eSgjelinek static boolean_t time_to_exit = B_FALSE, force_exit = B_FALSE; 5457c478bd9Sstevel@tonic-gate 5467c478bd9Sstevel@tonic-gate /* used in short_usage() and zerr() */ 5477c478bd9Sstevel@tonic-gate static char *cmd_file_name = NULL; 5487c478bd9Sstevel@tonic-gate 5497c478bd9Sstevel@tonic-gate /* checked in read_input() and other places */ 550bbec428eSgjelinek static boolean_t ok_to_prompt = B_FALSE; 5517c478bd9Sstevel@tonic-gate 5527c478bd9Sstevel@tonic-gate /* set and checked in initialize() */ 553bbec428eSgjelinek static boolean_t got_handle = B_FALSE; 5547c478bd9Sstevel@tonic-gate 5557c478bd9Sstevel@tonic-gate /* initialized in do_interactive(), checked in initialize() */ 556bbec428eSgjelinek static boolean_t interactive_mode; 5577c478bd9Sstevel@tonic-gate 5580209230bSgjelinek /* set if configuring the global zone */ 559bbec428eSgjelinek static boolean_t global_zone = B_FALSE; 5600209230bSgjelinek 5617c478bd9Sstevel@tonic-gate /* set in main(), checked in multiple places */ 562bbec428eSgjelinek static boolean_t read_only_mode; 5637c478bd9Sstevel@tonic-gate 564bbec428eSgjelinek /* scope is outer/global or inner/resource */ 565bbec428eSgjelinek static boolean_t global_scope = B_TRUE; 5667c478bd9Sstevel@tonic-gate static int resource_scope; /* should be in the RT_ list from zonecfg.h */ 5677c478bd9Sstevel@tonic-gate static int end_op = -1; /* operation on end is either add or modify */ 5687c478bd9Sstevel@tonic-gate 5697c478bd9Sstevel@tonic-gate int num_prop_vals; /* for grammar */ 5707c478bd9Sstevel@tonic-gate 5717c478bd9Sstevel@tonic-gate /* 5727c478bd9Sstevel@tonic-gate * These are for keeping track of resources as they are specified as part of 5737c478bd9Sstevel@tonic-gate * the multi-step process. They should be initialized by add_resource() or 5747c478bd9Sstevel@tonic-gate * select_func() and filled in by add_property() or set_func(). 5757c478bd9Sstevel@tonic-gate */ 5767c478bd9Sstevel@tonic-gate static struct zone_fstab old_fstab, in_progress_fstab; 5777c478bd9Sstevel@tonic-gate static struct zone_fstab old_ipdtab, in_progress_ipdtab; 5787c478bd9Sstevel@tonic-gate static struct zone_nwiftab old_nwiftab, in_progress_nwiftab; 5797c478bd9Sstevel@tonic-gate static struct zone_devtab old_devtab, in_progress_devtab; 5807c478bd9Sstevel@tonic-gate static struct zone_rctltab old_rctltab, in_progress_rctltab; 5817c478bd9Sstevel@tonic-gate static struct zone_attrtab old_attrtab, in_progress_attrtab; 582fa9e4066Sahrens static struct zone_dstab old_dstab, in_progress_dstab; 5830209230bSgjelinek static struct zone_psettab old_psettab, in_progress_psettab; 5840209230bSgjelinek static struct zone_mcaptab old_mcaptab, in_progress_mcaptab; 585cb8a054bSGlenn Faden static struct zone_admintab old_admintab, in_progress_admintab; 5867c478bd9Sstevel@tonic-gate 5877c478bd9Sstevel@tonic-gate static GetLine *gl; /* The gl_get_line() resource object */ 5887c478bd9Sstevel@tonic-gate 5890209230bSgjelinek static void bytes_to_units(char *str, char *buf, int bufsize); 5900209230bSgjelinek 5917c478bd9Sstevel@tonic-gate /* Functions begin here */ 5927c478bd9Sstevel@tonic-gate 593bbec428eSgjelinek static boolean_t 5947c478bd9Sstevel@tonic-gate initial_match(const char *line1, const char *line2, int word_end) 5957c478bd9Sstevel@tonic-gate { 5967c478bd9Sstevel@tonic-gate if (word_end <= 0) 597bbec428eSgjelinek return (B_TRUE); 5987c478bd9Sstevel@tonic-gate return (strncmp(line1, line2, word_end) == 0); 5997c478bd9Sstevel@tonic-gate } 6007c478bd9Sstevel@tonic-gate 6017c478bd9Sstevel@tonic-gate static int 6027c478bd9Sstevel@tonic-gate add_stuff(WordCompletion *cpl, const char *line1, const char **list, 6037c478bd9Sstevel@tonic-gate int word_end) 6047c478bd9Sstevel@tonic-gate { 6057c478bd9Sstevel@tonic-gate int i, err; 6067c478bd9Sstevel@tonic-gate 6077c478bd9Sstevel@tonic-gate for (i = 0; list[i] != NULL; i++) { 6087c478bd9Sstevel@tonic-gate if (initial_match(line1, list[i], word_end)) { 6097c478bd9Sstevel@tonic-gate err = cpl_add_completion(cpl, line1, 0, word_end, 6107c478bd9Sstevel@tonic-gate list[i] + word_end, "", ""); 6117c478bd9Sstevel@tonic-gate if (err != 0) 6127c478bd9Sstevel@tonic-gate return (err); 6137c478bd9Sstevel@tonic-gate } 6147c478bd9Sstevel@tonic-gate } 6157c478bd9Sstevel@tonic-gate return (0); 6167c478bd9Sstevel@tonic-gate } 6177c478bd9Sstevel@tonic-gate 6187c478bd9Sstevel@tonic-gate static 6197c478bd9Sstevel@tonic-gate /* ARGSUSED */ 6207c478bd9Sstevel@tonic-gate CPL_MATCH_FN(cmd_cpl_fn) 6217c478bd9Sstevel@tonic-gate { 6227c478bd9Sstevel@tonic-gate if (global_scope) { 6237c478bd9Sstevel@tonic-gate /* 6247c478bd9Sstevel@tonic-gate * The MAX/MIN tests below are to make sure we have at least 6257c478bd9Sstevel@tonic-gate * enough characters to distinguish from other prefixes (MAX) 6267c478bd9Sstevel@tonic-gate * but only check MIN(what we have, what we're checking). 6277c478bd9Sstevel@tonic-gate */ 6287c478bd9Sstevel@tonic-gate if (strncmp(line, "add ", MAX(MIN(word_end, 4), 1)) == 0) 6297c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, add_cmds, word_end)); 6300209230bSgjelinek if (strncmp(line, "clear ", MAX(MIN(word_end, 6), 2)) == 0) 6310209230bSgjelinek return (add_stuff(cpl, line, clear_cmds, word_end)); 6327c478bd9Sstevel@tonic-gate if (strncmp(line, "select ", MAX(MIN(word_end, 7), 3)) == 0) 6337c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, select_cmds, word_end)); 6347c478bd9Sstevel@tonic-gate if (strncmp(line, "set ", MAX(MIN(word_end, 4), 3)) == 0) 6357c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, set_cmds, word_end)); 6369e7542f4Sdp if (strncmp(line, "remove ", MAX(MIN(word_end, 7), 1)) == 0) 6379e7542f4Sdp return (add_stuff(cpl, line, remove_cmds, word_end)); 6389e7542f4Sdp if (strncmp(line, "info ", MAX(MIN(word_end, 5), 1)) == 0) 6399e7542f4Sdp return (add_stuff(cpl, line, info_cmds, word_end)); 6407c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, global_scope_cmds, word_end)); 6417c478bd9Sstevel@tonic-gate } 6427c478bd9Sstevel@tonic-gate switch (resource_scope) { 6437c478bd9Sstevel@tonic-gate case RT_FS: 6447c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, fs_res_scope_cmds, word_end)); 6457c478bd9Sstevel@tonic-gate case RT_IPD: 6467c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, ipd_res_scope_cmds, word_end)); 6477c478bd9Sstevel@tonic-gate case RT_NET: 6487c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, net_res_scope_cmds, word_end)); 6497c478bd9Sstevel@tonic-gate case RT_DEVICE: 6507c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, device_res_scope_cmds, word_end)); 6517c478bd9Sstevel@tonic-gate case RT_RCTL: 6527c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, rctl_res_scope_cmds, word_end)); 6537c478bd9Sstevel@tonic-gate case RT_ATTR: 6547c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, attr_res_scope_cmds, word_end)); 655fa9e4066Sahrens case RT_DATASET: 656fa9e4066Sahrens return (add_stuff(cpl, line, dataset_res_scope_cmds, word_end)); 6570209230bSgjelinek case RT_DCPU: 6580209230bSgjelinek return (add_stuff(cpl, line, pset_res_scope_cmds, word_end)); 659c97ad5cdSakolb case RT_PCAP: 660c97ad5cdSakolb return (add_stuff(cpl, line, pcap_res_scope_cmds, word_end)); 6610209230bSgjelinek case RT_MCAP: 6620209230bSgjelinek return (add_stuff(cpl, line, mcap_res_scope_cmds, word_end)); 663cb8a054bSGlenn Faden case RT_ADMIN: 664cb8a054bSGlenn Faden return (add_stuff(cpl, line, admin_res_scope_cmds, word_end)); 6657c478bd9Sstevel@tonic-gate } 6667c478bd9Sstevel@tonic-gate return (0); 6677c478bd9Sstevel@tonic-gate } 6687c478bd9Sstevel@tonic-gate 6697c478bd9Sstevel@tonic-gate /* 6707c478bd9Sstevel@tonic-gate * For the main CMD_func() functions below, several of them call getopt() 6717c478bd9Sstevel@tonic-gate * then check optind against argc to make sure an extra parameter was not 6727c478bd9Sstevel@tonic-gate * passed in. The reason this is not caught in the grammar is that the 6737c478bd9Sstevel@tonic-gate * grammar just checks for a miscellaneous TOKEN, which is *expected* to 6747c478bd9Sstevel@tonic-gate * be "-F" (for example), but could be anything. So (for example) this 6757c478bd9Sstevel@tonic-gate * check will prevent "create bogus". 6767c478bd9Sstevel@tonic-gate */ 6777c478bd9Sstevel@tonic-gate 6787c478bd9Sstevel@tonic-gate cmd_t * 6797c478bd9Sstevel@tonic-gate alloc_cmd(void) 6807c478bd9Sstevel@tonic-gate { 6817c478bd9Sstevel@tonic-gate return (calloc(1, sizeof (cmd_t))); 6827c478bd9Sstevel@tonic-gate } 6837c478bd9Sstevel@tonic-gate 6847c478bd9Sstevel@tonic-gate void 6857c478bd9Sstevel@tonic-gate free_cmd(cmd_t *cmd) 6867c478bd9Sstevel@tonic-gate { 6877c478bd9Sstevel@tonic-gate int i; 6887c478bd9Sstevel@tonic-gate 6897c478bd9Sstevel@tonic-gate for (i = 0; i < MAX_EQ_PROP_PAIRS; i++) 6907c478bd9Sstevel@tonic-gate if (cmd->cmd_property_ptr[i] != NULL) { 6917c478bd9Sstevel@tonic-gate property_value_ptr_t pp = cmd->cmd_property_ptr[i]; 6927c478bd9Sstevel@tonic-gate 6937c478bd9Sstevel@tonic-gate switch (pp->pv_type) { 6947c478bd9Sstevel@tonic-gate case PROP_VAL_SIMPLE: 6957c478bd9Sstevel@tonic-gate free(pp->pv_simple); 6967c478bd9Sstevel@tonic-gate break; 6977c478bd9Sstevel@tonic-gate case PROP_VAL_COMPLEX: 6987c478bd9Sstevel@tonic-gate free_complex(pp->pv_complex); 6997c478bd9Sstevel@tonic-gate break; 7007c478bd9Sstevel@tonic-gate case PROP_VAL_LIST: 7017c478bd9Sstevel@tonic-gate free_list(pp->pv_list); 7027c478bd9Sstevel@tonic-gate break; 7037c478bd9Sstevel@tonic-gate } 7047c478bd9Sstevel@tonic-gate } 7057c478bd9Sstevel@tonic-gate for (i = 0; i < cmd->cmd_argc; i++) 7067c478bd9Sstevel@tonic-gate free(cmd->cmd_argv[i]); 7077c478bd9Sstevel@tonic-gate free(cmd); 7087c478bd9Sstevel@tonic-gate } 7097c478bd9Sstevel@tonic-gate 7107c478bd9Sstevel@tonic-gate complex_property_ptr_t 7117c478bd9Sstevel@tonic-gate alloc_complex(void) 7127c478bd9Sstevel@tonic-gate { 7137c478bd9Sstevel@tonic-gate return (calloc(1, sizeof (complex_property_t))); 7147c478bd9Sstevel@tonic-gate } 7157c478bd9Sstevel@tonic-gate 7167c478bd9Sstevel@tonic-gate void 7177c478bd9Sstevel@tonic-gate free_complex(complex_property_ptr_t complex) 7187c478bd9Sstevel@tonic-gate { 7197c478bd9Sstevel@tonic-gate if (complex == NULL) 7207c478bd9Sstevel@tonic-gate return; 7217c478bd9Sstevel@tonic-gate free_complex(complex->cp_next); 7227c478bd9Sstevel@tonic-gate if (complex->cp_value != NULL) 7237c478bd9Sstevel@tonic-gate free(complex->cp_value); 7247c478bd9Sstevel@tonic-gate free(complex); 7257c478bd9Sstevel@tonic-gate } 7267c478bd9Sstevel@tonic-gate 7277c478bd9Sstevel@tonic-gate list_property_ptr_t 7287c478bd9Sstevel@tonic-gate alloc_list(void) 7297c478bd9Sstevel@tonic-gate { 7307c478bd9Sstevel@tonic-gate return (calloc(1, sizeof (list_property_t))); 7317c478bd9Sstevel@tonic-gate } 7327c478bd9Sstevel@tonic-gate 7337c478bd9Sstevel@tonic-gate void 7347c478bd9Sstevel@tonic-gate free_list(list_property_ptr_t list) 7357c478bd9Sstevel@tonic-gate { 7367c478bd9Sstevel@tonic-gate if (list == NULL) 7377c478bd9Sstevel@tonic-gate return; 7387c478bd9Sstevel@tonic-gate if (list->lp_simple != NULL) 7397c478bd9Sstevel@tonic-gate free(list->lp_simple); 7407c478bd9Sstevel@tonic-gate free_complex(list->lp_complex); 7417c478bd9Sstevel@tonic-gate free_list(list->lp_next); 7427c478bd9Sstevel@tonic-gate free(list); 7437c478bd9Sstevel@tonic-gate } 7447c478bd9Sstevel@tonic-gate 7457c478bd9Sstevel@tonic-gate void 7467c478bd9Sstevel@tonic-gate free_outer_list(list_property_ptr_t list) 7477c478bd9Sstevel@tonic-gate { 7487c478bd9Sstevel@tonic-gate if (list == NULL) 7497c478bd9Sstevel@tonic-gate return; 7507c478bd9Sstevel@tonic-gate free_outer_list(list->lp_next); 7517c478bd9Sstevel@tonic-gate free(list); 7527c478bd9Sstevel@tonic-gate } 7537c478bd9Sstevel@tonic-gate 7547c478bd9Sstevel@tonic-gate static struct zone_rctlvaltab * 7557c478bd9Sstevel@tonic-gate alloc_rctlvaltab(void) 7567c478bd9Sstevel@tonic-gate { 7577c478bd9Sstevel@tonic-gate return (calloc(1, sizeof (struct zone_rctlvaltab))); 7587c478bd9Sstevel@tonic-gate } 7597c478bd9Sstevel@tonic-gate 7607c478bd9Sstevel@tonic-gate static char * 7617c478bd9Sstevel@tonic-gate rt_to_str(int res_type) 7627c478bd9Sstevel@tonic-gate { 7637c478bd9Sstevel@tonic-gate assert(res_type >= RT_MIN && res_type <= RT_MAX); 7647c478bd9Sstevel@tonic-gate return (res_types[res_type]); 7657c478bd9Sstevel@tonic-gate } 7667c478bd9Sstevel@tonic-gate 7677c478bd9Sstevel@tonic-gate static char * 7687c478bd9Sstevel@tonic-gate pt_to_str(int prop_type) 7697c478bd9Sstevel@tonic-gate { 7707c478bd9Sstevel@tonic-gate assert(prop_type >= PT_MIN && prop_type <= PT_MAX); 7717c478bd9Sstevel@tonic-gate return (prop_types[prop_type]); 7727c478bd9Sstevel@tonic-gate } 7737c478bd9Sstevel@tonic-gate 7747c478bd9Sstevel@tonic-gate static char * 7757c478bd9Sstevel@tonic-gate pvt_to_str(int pv_type) 7767c478bd9Sstevel@tonic-gate { 7777c478bd9Sstevel@tonic-gate assert(pv_type >= PROP_VAL_MIN && pv_type <= PROP_VAL_MAX); 7787c478bd9Sstevel@tonic-gate return (prop_val_types[pv_type]); 7797c478bd9Sstevel@tonic-gate } 7807c478bd9Sstevel@tonic-gate 7817c478bd9Sstevel@tonic-gate static char * 7827c478bd9Sstevel@tonic-gate cmd_to_str(int cmd_num) 7837c478bd9Sstevel@tonic-gate { 7847c478bd9Sstevel@tonic-gate assert(cmd_num >= CMD_MIN && cmd_num <= CMD_MAX); 7857c478bd9Sstevel@tonic-gate return (helptab[cmd_num].cmd_name); 7867c478bd9Sstevel@tonic-gate } 7877c478bd9Sstevel@tonic-gate 7883042b8b5Sbatschul /* PRINTFLIKE1 */ 7893042b8b5Sbatschul static void 7903042b8b5Sbatschul zerr(const char *fmt, ...) 7913042b8b5Sbatschul { 7923042b8b5Sbatschul va_list alist; 7933042b8b5Sbatschul static int last_lineno; 7943042b8b5Sbatschul 7953042b8b5Sbatschul /* lex_lineno has already been incremented in the lexer; compensate */ 7963042b8b5Sbatschul if (cmd_file_mode && lex_lineno > last_lineno) { 7973042b8b5Sbatschul if (strcmp(cmd_file_name, "-") == 0) 7983042b8b5Sbatschul (void) fprintf(stderr, gettext("On line %d:\n"), 7993042b8b5Sbatschul lex_lineno - 1); 8003042b8b5Sbatschul else 8013042b8b5Sbatschul (void) fprintf(stderr, gettext("On line %d of %s:\n"), 8023042b8b5Sbatschul lex_lineno - 1, cmd_file_name); 8033042b8b5Sbatschul last_lineno = lex_lineno; 8043042b8b5Sbatschul } 8053042b8b5Sbatschul va_start(alist, fmt); 8063042b8b5Sbatschul (void) vfprintf(stderr, fmt, alist); 8073042b8b5Sbatschul (void) fprintf(stderr, "\n"); 8083042b8b5Sbatschul va_end(alist); 8093042b8b5Sbatschul } 8103042b8b5Sbatschul 8117c478bd9Sstevel@tonic-gate /* 8127c478bd9Sstevel@tonic-gate * This is a separate function rather than a set of define's because of the 8137c478bd9Sstevel@tonic-gate * gettext() wrapping. 8147c478bd9Sstevel@tonic-gate */ 8157c478bd9Sstevel@tonic-gate 8167c478bd9Sstevel@tonic-gate /* 8177c478bd9Sstevel@tonic-gate * TRANSLATION_NOTE 8187c478bd9Sstevel@tonic-gate * Each string below should have \t follow \n whenever needed; the 8197c478bd9Sstevel@tonic-gate * initial \t and the terminal \n will be provided by the calling function. 8207c478bd9Sstevel@tonic-gate */ 8217c478bd9Sstevel@tonic-gate 8227c478bd9Sstevel@tonic-gate static char * 8237c478bd9Sstevel@tonic-gate long_help(int cmd_num) 8247c478bd9Sstevel@tonic-gate { 8257c478bd9Sstevel@tonic-gate static char line[1024]; /* arbitrary large amount */ 8267c478bd9Sstevel@tonic-gate 8277c478bd9Sstevel@tonic-gate assert(cmd_num >= CMD_MIN && cmd_num <= CMD_MAX); 8287c478bd9Sstevel@tonic-gate switch (cmd_num) { 8297c478bd9Sstevel@tonic-gate case CMD_HELP: 8307c478bd9Sstevel@tonic-gate return (gettext("Prints help message.")); 8317c478bd9Sstevel@tonic-gate case CMD_CREATE: 8327c478bd9Sstevel@tonic-gate (void) snprintf(line, sizeof (line), 8337c478bd9Sstevel@tonic-gate gettext("Creates a configuration for the " 8347c478bd9Sstevel@tonic-gate "specified zone. %s should be\n\tused to " 8357c478bd9Sstevel@tonic-gate "begin configuring a new zone. If overwriting an " 8367c478bd9Sstevel@tonic-gate "existing\n\tconfiguration, the -F flag can be " 8377c478bd9Sstevel@tonic-gate "used to force the action. If\n\t-t template is " 8387c478bd9Sstevel@tonic-gate "given, creates a configuration identical to the\n" 8397c478bd9Sstevel@tonic-gate "\tspecified template, except that the zone name " 8409e518655Sgjelinek "is changed from\n\ttemplate to zonename. '%s -a' " 8419e518655Sgjelinek "creates a configuration from a\n\tdetached " 8429e518655Sgjelinek "zonepath. '%s -b' results in a blank " 8439e518655Sgjelinek "configuration.\n\t'%s' with no arguments applies " 8449e518655Sgjelinek "the Sun default settings."), 8457c478bd9Sstevel@tonic-gate cmd_to_str(CMD_CREATE), cmd_to_str(CMD_CREATE), 8469e518655Sgjelinek cmd_to_str(CMD_CREATE), cmd_to_str(CMD_CREATE)); 8477c478bd9Sstevel@tonic-gate return (line); 8487c478bd9Sstevel@tonic-gate case CMD_EXIT: 8497c478bd9Sstevel@tonic-gate return (gettext("Exits the program. The -F flag can " 8507c478bd9Sstevel@tonic-gate "be used to force the action.")); 8517c478bd9Sstevel@tonic-gate case CMD_EXPORT: 8527c478bd9Sstevel@tonic-gate return (gettext("Prints configuration to standard " 8537c478bd9Sstevel@tonic-gate "output, or to output-file if\n\tspecified, in " 8547c478bd9Sstevel@tonic-gate "a form suitable for use in a command-file.")); 8557c478bd9Sstevel@tonic-gate case CMD_ADD: 8567c478bd9Sstevel@tonic-gate return (gettext("Add specified resource to " 8577c478bd9Sstevel@tonic-gate "configuration.")); 8587c478bd9Sstevel@tonic-gate case CMD_DELETE: 8597c478bd9Sstevel@tonic-gate return (gettext("Deletes the specified zone. The -F " 8607c478bd9Sstevel@tonic-gate "flag can be used to force the\n\taction.")); 8617c478bd9Sstevel@tonic-gate case CMD_REMOVE: 8627c478bd9Sstevel@tonic-gate return (gettext("Remove specified resource from " 8630209230bSgjelinek "configuration. The -F flag can be used\n\tto " 8640209230bSgjelinek "force the action.")); 8657c478bd9Sstevel@tonic-gate case CMD_SELECT: 8667c478bd9Sstevel@tonic-gate (void) snprintf(line, sizeof (line), 8677c478bd9Sstevel@tonic-gate gettext("Selects a resource to modify. " 8687c478bd9Sstevel@tonic-gate "Resource modification is completed\n\twith the " 8697c478bd9Sstevel@tonic-gate "command \"%s\". The property name/value pairs " 8707c478bd9Sstevel@tonic-gate "must uniquely\n\tidentify a resource. Note that " 8717c478bd9Sstevel@tonic-gate "the curly braces ('{', '}') mean one\n\tor more " 8727c478bd9Sstevel@tonic-gate "of whatever is between them."), 8737c478bd9Sstevel@tonic-gate cmd_to_str(CMD_END)); 8747c478bd9Sstevel@tonic-gate return (line); 8757c478bd9Sstevel@tonic-gate case CMD_SET: 8767c478bd9Sstevel@tonic-gate return (gettext("Sets property values.")); 8770209230bSgjelinek case CMD_CLEAR: 8780209230bSgjelinek return (gettext("Clears property values.")); 8797c478bd9Sstevel@tonic-gate case CMD_INFO: 8807c478bd9Sstevel@tonic-gate return (gettext("Displays information about the " 8817c478bd9Sstevel@tonic-gate "current configuration. If resource\n\ttype is " 8827c478bd9Sstevel@tonic-gate "specified, displays only information about " 8837c478bd9Sstevel@tonic-gate "resources of\n\tthe relevant type. If resource " 8847c478bd9Sstevel@tonic-gate "id is specified, displays only\n\tinformation " 8857c478bd9Sstevel@tonic-gate "about that resource.")); 8867c478bd9Sstevel@tonic-gate case CMD_VERIFY: 8877c478bd9Sstevel@tonic-gate return (gettext("Verifies current configuration " 8887c478bd9Sstevel@tonic-gate "for correctness (some resource types\n\thave " 8897c478bd9Sstevel@tonic-gate "required properties).")); 8907c478bd9Sstevel@tonic-gate case CMD_COMMIT: 8917c478bd9Sstevel@tonic-gate (void) snprintf(line, sizeof (line), 8927c478bd9Sstevel@tonic-gate gettext("Commits current configuration. " 8937c478bd9Sstevel@tonic-gate "Configuration must be committed to\n\tbe used by " 8947c478bd9Sstevel@tonic-gate "%s. Until the configuration is committed, " 8957c478bd9Sstevel@tonic-gate "changes \n\tcan be removed with the %s " 8967c478bd9Sstevel@tonic-gate "command. This operation is\n\tattempted " 8977c478bd9Sstevel@tonic-gate "automatically upon completion of a %s " 8987c478bd9Sstevel@tonic-gate "session."), "zoneadm", cmd_to_str(CMD_REVERT), 8997c478bd9Sstevel@tonic-gate "zonecfg"); 9007c478bd9Sstevel@tonic-gate return (line); 9017c478bd9Sstevel@tonic-gate case CMD_REVERT: 9027c478bd9Sstevel@tonic-gate return (gettext("Reverts configuration back to the " 9037c478bd9Sstevel@tonic-gate "last committed state. The -F flag\n\tcan be " 9047c478bd9Sstevel@tonic-gate "used to force the action.")); 9057c478bd9Sstevel@tonic-gate case CMD_CANCEL: 9067c478bd9Sstevel@tonic-gate return (gettext("Cancels resource/property " 9077c478bd9Sstevel@tonic-gate "specification.")); 9087c478bd9Sstevel@tonic-gate case CMD_END: 9097c478bd9Sstevel@tonic-gate return (gettext("Ends resource/property " 9107c478bd9Sstevel@tonic-gate "specification.")); 9117c478bd9Sstevel@tonic-gate } 9127c478bd9Sstevel@tonic-gate /* NOTREACHED */ 9137e362f58Scomay return (NULL); 9147c478bd9Sstevel@tonic-gate } 9157c478bd9Sstevel@tonic-gate 9167c478bd9Sstevel@tonic-gate /* 9177c478bd9Sstevel@tonic-gate * Called with verbose TRUE when help is explicitly requested, FALSE for 9187c478bd9Sstevel@tonic-gate * unexpected errors. 9197c478bd9Sstevel@tonic-gate */ 9207c478bd9Sstevel@tonic-gate 9217c478bd9Sstevel@tonic-gate void 922bbec428eSgjelinek usage(boolean_t verbose, uint_t flags) 9237c478bd9Sstevel@tonic-gate { 9243042b8b5Sbatschul FILE *fp = verbose ? stdout : stderr; 9253042b8b5Sbatschul FILE *newfp; 926bbec428eSgjelinek boolean_t need_to_close = B_FALSE; 9277c478bd9Sstevel@tonic-gate char *pager; 9287c478bd9Sstevel@tonic-gate int i; 9293042b8b5Sbatschul struct stat statbuf; 9307c478bd9Sstevel@tonic-gate 9317c478bd9Sstevel@tonic-gate /* don't page error output */ 9327c478bd9Sstevel@tonic-gate if (verbose && interactive_mode) { 9337c478bd9Sstevel@tonic-gate if ((pager = getenv("PAGER")) == NULL) 9347c478bd9Sstevel@tonic-gate pager = PAGER; 9353042b8b5Sbatschul 9363042b8b5Sbatschul if (stat(pager, &statbuf) == 0) { 9373042b8b5Sbatschul if ((newfp = popen(pager, "w")) != NULL) { 9383042b8b5Sbatschul need_to_close = B_TRUE; 9393042b8b5Sbatschul fp = newfp; 9403042b8b5Sbatschul } 9413042b8b5Sbatschul } else { 9423042b8b5Sbatschul zerr(gettext("PAGER %s does not exist (%s)."), 9433042b8b5Sbatschul pager, strerror(errno)); 9447c478bd9Sstevel@tonic-gate } 9457c478bd9Sstevel@tonic-gate } 9463042b8b5Sbatschul 9477c478bd9Sstevel@tonic-gate if (flags & HELP_META) { 9487c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("More help is available for the " 9497c478bd9Sstevel@tonic-gate "following:\n")); 9507c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\n\tcommands ('%s commands')\n", 9517c478bd9Sstevel@tonic-gate cmd_to_str(CMD_HELP)); 9527c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\tsyntax ('%s syntax')\n", 9537c478bd9Sstevel@tonic-gate cmd_to_str(CMD_HELP)); 9547c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\tusage ('%s usage')\n\n", 9557c478bd9Sstevel@tonic-gate cmd_to_str(CMD_HELP)); 9567c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("You may also obtain help on any " 9577c478bd9Sstevel@tonic-gate "command by typing '%s <command-name>.'\n"), 9587c478bd9Sstevel@tonic-gate cmd_to_str(CMD_HELP)); 9597c478bd9Sstevel@tonic-gate } 9607c478bd9Sstevel@tonic-gate if (flags & HELP_RES_SCOPE) { 9617c478bd9Sstevel@tonic-gate switch (resource_scope) { 9627c478bd9Sstevel@tonic-gate case RT_FS: 9637c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("The '%s' resource scope is " 9647c478bd9Sstevel@tonic-gate "used to configure a file-system.\n"), 9657c478bd9Sstevel@tonic-gate rt_to_str(resource_scope)); 9667c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("Valid commands:\n")); 9677c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 9687c478bd9Sstevel@tonic-gate pt_to_str(PT_DIR), gettext("<path>")); 9697c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 9707c478bd9Sstevel@tonic-gate pt_to_str(PT_SPECIAL), gettext("<path>")); 9717c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 9727c478bd9Sstevel@tonic-gate pt_to_str(PT_RAW), gettext("<raw-device>")); 9737c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 9747c478bd9Sstevel@tonic-gate pt_to_str(PT_TYPE), gettext("<file-system type>")); 9757c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s %s\n", cmd_to_str(CMD_ADD), 9767c478bd9Sstevel@tonic-gate pt_to_str(PT_OPTIONS), 9777c478bd9Sstevel@tonic-gate gettext("<file-system options>")); 978ffbafc53Scomay (void) fprintf(fp, "\t%s %s %s\n", 979ffbafc53Scomay cmd_to_str(CMD_REMOVE), pt_to_str(PT_OPTIONS), 980ffbafc53Scomay gettext("<file-system options>")); 9817c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("Consult the file-system " 9827c478bd9Sstevel@tonic-gate "specific manual page, such as mount_ufs(1M), " 9837c478bd9Sstevel@tonic-gate "for\ndetails about file-system options. Note " 9847c478bd9Sstevel@tonic-gate "that any file-system options with an\nembedded " 9857c478bd9Sstevel@tonic-gate "'=' character must be enclosed in double quotes, " 9867c478bd9Sstevel@tonic-gate /*CSTYLED*/ 9877c478bd9Sstevel@tonic-gate "such as \"%s=5\".\n"), MNTOPT_RETRY); 9887c478bd9Sstevel@tonic-gate break; 9897c478bd9Sstevel@tonic-gate case RT_IPD: 9907c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("The '%s' resource scope is " 9917c478bd9Sstevel@tonic-gate "used to configure a directory\ninherited from the " 9927c478bd9Sstevel@tonic-gate "global zone into a non-global zone in read-only " 9937c478bd9Sstevel@tonic-gate "mode.\n"), rt_to_str(resource_scope)); 9947c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("Valid commands:\n")); 9957c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 9967c478bd9Sstevel@tonic-gate pt_to_str(PT_DIR), gettext("<path>")); 9977c478bd9Sstevel@tonic-gate break; 9987c478bd9Sstevel@tonic-gate case RT_NET: 9997c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("The '%s' resource scope is " 10007c478bd9Sstevel@tonic-gate "used to configure a network interface.\n"), 10017c478bd9Sstevel@tonic-gate rt_to_str(resource_scope)); 10027c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("Valid commands:\n")); 10037c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 10047c478bd9Sstevel@tonic-gate pt_to_str(PT_ADDRESS), gettext("<IP-address>")); 10057c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 10067c478bd9Sstevel@tonic-gate pt_to_str(PT_PHYSICAL), gettext("<interface>")); 10077c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("See ifconfig(1M) for " 10087c478bd9Sstevel@tonic-gate "details of the <interface> string.\n")); 1009de860bd9Sgfaden (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 1010de860bd9Sgfaden pt_to_str(PT_DEFROUTER), gettext("<IP-address>")); 1011de860bd9Sgfaden (void) fprintf(fp, gettext("%s %s and %s %s are valid " 1012de860bd9Sgfaden "if the %s property is set to %s, otherwise they " 1013de860bd9Sgfaden "must not be set.\n"), 1014f4b3ec61Sdh cmd_to_str(CMD_SET), pt_to_str(PT_ADDRESS), 1015de860bd9Sgfaden cmd_to_str(CMD_SET), pt_to_str(PT_DEFROUTER), 1016f4b3ec61Sdh pt_to_str(PT_IPTYPE), "shared"); 10177c478bd9Sstevel@tonic-gate break; 10187c478bd9Sstevel@tonic-gate case RT_DEVICE: 10197c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("The '%s' resource scope is " 10207c478bd9Sstevel@tonic-gate "used to configure a device node.\n"), 10217c478bd9Sstevel@tonic-gate rt_to_str(resource_scope)); 10227c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("Valid commands:\n")); 10237c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 10247c478bd9Sstevel@tonic-gate pt_to_str(PT_MATCH), gettext("<device-path>")); 10257c478bd9Sstevel@tonic-gate break; 10267c478bd9Sstevel@tonic-gate case RT_RCTL: 10277c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("The '%s' resource scope is " 10287c478bd9Sstevel@tonic-gate "used to configure a resource control.\n"), 10297c478bd9Sstevel@tonic-gate rt_to_str(resource_scope)); 10307c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("Valid commands:\n")); 10317c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 10327c478bd9Sstevel@tonic-gate pt_to_str(PT_NAME), gettext("<string>")); 10337c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s (%s=%s,%s=%s,%s=%s)\n", 10347c478bd9Sstevel@tonic-gate cmd_to_str(CMD_ADD), pt_to_str(PT_VALUE), 10357c478bd9Sstevel@tonic-gate pt_to_str(PT_PRIV), gettext("<priv-value>"), 10367c478bd9Sstevel@tonic-gate pt_to_str(PT_LIMIT), gettext("<number>"), 10377c478bd9Sstevel@tonic-gate pt_to_str(PT_ACTION), gettext("<action-value>")); 1038ffbafc53Scomay (void) fprintf(fp, "\t%s %s (%s=%s,%s=%s,%s=%s)\n", 1039ffbafc53Scomay cmd_to_str(CMD_REMOVE), pt_to_str(PT_VALUE), 1040ffbafc53Scomay pt_to_str(PT_PRIV), gettext("<priv-value>"), 1041ffbafc53Scomay pt_to_str(PT_LIMIT), gettext("<number>"), 1042ffbafc53Scomay pt_to_str(PT_ACTION), gettext("<action-value>")); 10437c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s\n\t%s := privileged\n" 10447c478bd9Sstevel@tonic-gate "\t%s := none | deny\n", gettext("Where"), 10457c478bd9Sstevel@tonic-gate gettext("<priv-value>"), gettext("<action-value>")); 10467c478bd9Sstevel@tonic-gate break; 10477c478bd9Sstevel@tonic-gate case RT_ATTR: 10487c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("The '%s' resource scope is " 10497c478bd9Sstevel@tonic-gate "used to configure a generic attribute.\n"), 10507c478bd9Sstevel@tonic-gate rt_to_str(resource_scope)); 10517c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("Valid commands:\n")); 10527c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 10537c478bd9Sstevel@tonic-gate pt_to_str(PT_NAME), gettext("<name>")); 10547c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=boolean\n", 10557c478bd9Sstevel@tonic-gate cmd_to_str(CMD_SET), pt_to_str(PT_TYPE)); 10567c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=true | false\n", 10577c478bd9Sstevel@tonic-gate cmd_to_str(CMD_SET), pt_to_str(PT_VALUE)); 10587c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("or\n")); 10597c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=int\n", cmd_to_str(CMD_SET), 10607c478bd9Sstevel@tonic-gate pt_to_str(PT_TYPE)); 10617c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 10627c478bd9Sstevel@tonic-gate pt_to_str(PT_VALUE), gettext("<integer>")); 10637c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("or\n")); 10647c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=string\n", 10657c478bd9Sstevel@tonic-gate cmd_to_str(CMD_SET), pt_to_str(PT_TYPE)); 10667c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 10677c478bd9Sstevel@tonic-gate pt_to_str(PT_VALUE), gettext("<string>")); 10687c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("or\n")); 10697c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=uint\n", 10707c478bd9Sstevel@tonic-gate cmd_to_str(CMD_SET), pt_to_str(PT_TYPE)); 10717c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 10727c478bd9Sstevel@tonic-gate pt_to_str(PT_VALUE), gettext("<unsigned integer>")); 10737c478bd9Sstevel@tonic-gate break; 1074fa9e4066Sahrens case RT_DATASET: 1075fa9e4066Sahrens (void) fprintf(fp, gettext("The '%s' resource scope is " 1076fa9e4066Sahrens "used to export ZFS datasets.\n"), 1077fa9e4066Sahrens rt_to_str(resource_scope)); 1078fa9e4066Sahrens (void) fprintf(fp, gettext("Valid commands:\n")); 1079fa9e4066Sahrens (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 1080fa9e4066Sahrens pt_to_str(PT_NAME), gettext("<name>")); 1081fa9e4066Sahrens break; 10820209230bSgjelinek case RT_DCPU: 10830209230bSgjelinek (void) fprintf(fp, gettext("The '%s' resource scope " 10840209230bSgjelinek "configures the 'pools' facility to dedicate\na " 10850209230bSgjelinek "subset of the system's processors to this zone " 10860209230bSgjelinek "while it is running.\n"), 10870209230bSgjelinek rt_to_str(resource_scope)); 10880209230bSgjelinek (void) fprintf(fp, gettext("Valid commands:\n")); 10890209230bSgjelinek (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 10900209230bSgjelinek pt_to_str(PT_NCPUS), 10910209230bSgjelinek gettext("<unsigned integer | range>")); 10920209230bSgjelinek (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 10930209230bSgjelinek pt_to_str(PT_IMPORTANCE), 10940209230bSgjelinek gettext("<unsigned integer>")); 10950209230bSgjelinek break; 1096c97ad5cdSakolb case RT_PCAP: 1097c97ad5cdSakolb (void) fprintf(fp, gettext("The '%s' resource scope is " 1098c97ad5cdSakolb "used to set an upper limit (a cap) on the\n" 1099c97ad5cdSakolb "percentage of CPU that can be used by this zone. " 1100c97ad5cdSakolb "A '%s' value of 1\ncorresponds to one cpu. The " 1101c97ad5cdSakolb "value can be set higher than 1, up to the total\n" 1102c97ad5cdSakolb "number of CPUs on the system. The value can " 1103c97ad5cdSakolb "also be less than 1,\nrepresenting a fraction of " 1104c97ad5cdSakolb "a cpu.\n"), 1105c97ad5cdSakolb rt_to_str(resource_scope), pt_to_str(PT_NCPUS)); 1106c97ad5cdSakolb (void) fprintf(fp, gettext("Valid commands:\n")); 1107c97ad5cdSakolb (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 1108c97ad5cdSakolb pt_to_str(PT_NCPUS), gettext("<unsigned decimal>")); 1109c97ad5cdSakolb break; 11100209230bSgjelinek case RT_MCAP: 11110209230bSgjelinek (void) fprintf(fp, gettext("The '%s' resource scope is " 11120209230bSgjelinek "used to set an upper limit (a cap) on the\n" 11130209230bSgjelinek "amount of physical memory, swap space and locked " 11140209230bSgjelinek "memory that can be used by\nthis zone.\n"), 11150209230bSgjelinek rt_to_str(resource_scope)); 11160209230bSgjelinek (void) fprintf(fp, gettext("Valid commands:\n")); 11170209230bSgjelinek (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 11180209230bSgjelinek pt_to_str(PT_PHYSICAL), 11190209230bSgjelinek gettext("<qualified unsigned decimal>")); 11200209230bSgjelinek (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 11210209230bSgjelinek pt_to_str(PT_SWAP), 11220209230bSgjelinek gettext("<qualified unsigned decimal>")); 11230209230bSgjelinek (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 11240209230bSgjelinek pt_to_str(PT_LOCKED), 11250209230bSgjelinek gettext("<qualified unsigned decimal>")); 11260209230bSgjelinek break; 1127cb8a054bSGlenn Faden case RT_ADMIN: 1128cb8a054bSGlenn Faden (void) fprintf(fp, gettext("The '%s' resource scope is " 1129cb8a054bSGlenn Faden "used to delegate specific zone management\n" 1130cb8a054bSGlenn Faden "rights to users and roles. These rights are " 1131cb8a054bSGlenn Faden "only applicable to this zone.\n"), 1132cb8a054bSGlenn Faden rt_to_str(resource_scope)); 1133cb8a054bSGlenn Faden (void) fprintf(fp, gettext("Valid commands:\n")); 1134cb8a054bSGlenn Faden (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 1135cb8a054bSGlenn Faden pt_to_str(PT_USER), 1136cb8a054bSGlenn Faden gettext("<single user or role name>")); 1137cb8a054bSGlenn Faden (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 1138cb8a054bSGlenn Faden pt_to_str(PT_AUTHS), 1139cb8a054bSGlenn Faden gettext("<comma separated list>")); 1140cb8a054bSGlenn Faden break; 11417c478bd9Sstevel@tonic-gate } 11427c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("And from any resource scope, you " 11437c478bd9Sstevel@tonic-gate "can:\n")); 11447c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t%s\n", cmd_to_str(CMD_END), 11457c478bd9Sstevel@tonic-gate gettext("(to conclude this operation)")); 11467c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t%s\n", cmd_to_str(CMD_CANCEL), 11477c478bd9Sstevel@tonic-gate gettext("(to cancel this operation)")); 11487c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t%s\n", cmd_to_str(CMD_EXIT), 11497c478bd9Sstevel@tonic-gate gettext("(to exit the zonecfg utility)")); 11507c478bd9Sstevel@tonic-gate } 11517c478bd9Sstevel@tonic-gate if (flags & HELP_USAGE) { 11527c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s:\t%s %s\n", gettext("usage"), 11537c478bd9Sstevel@tonic-gate execname, cmd_to_str(CMD_HELP)); 11547c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s -z <zone>\t\t\t(%s)\n", 11557c478bd9Sstevel@tonic-gate execname, gettext("interactive")); 11567c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s -z <zone> <command>\n", execname); 11577c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s -z <zone> -f <command-file>\n", 11587c478bd9Sstevel@tonic-gate execname); 11597c478bd9Sstevel@tonic-gate } 11607c478bd9Sstevel@tonic-gate if (flags & HELP_SUBCMDS) { 11617c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s:\n\n", gettext("Commands")); 11627c478bd9Sstevel@tonic-gate for (i = 0; i <= CMD_MAX; i++) { 11637c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s\n", helptab[i].short_usage); 11647c478bd9Sstevel@tonic-gate if (verbose) 11657c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\n\n", long_help(i)); 11667c478bd9Sstevel@tonic-gate } 11677c478bd9Sstevel@tonic-gate } 11687c478bd9Sstevel@tonic-gate if (flags & HELP_SYNTAX) { 11697c478bd9Sstevel@tonic-gate if (!verbose) 11707c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\n"); 11717c478bd9Sstevel@tonic-gate (void) fprintf(fp, "<zone> := [A-Za-z0-9][A-Za-z0-9_.-]*\n"); 11727c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("\t(except the reserved words " 11737c478bd9Sstevel@tonic-gate "'%s' and anything starting with '%s')\n"), "global", 11747c478bd9Sstevel@tonic-gate "SUNW"); 11757c478bd9Sstevel@tonic-gate (void) fprintf(fp, 11767c478bd9Sstevel@tonic-gate gettext("\tName must be less than %d characters.\n"), 11777c478bd9Sstevel@tonic-gate ZONENAME_MAX); 11787c478bd9Sstevel@tonic-gate if (verbose) 11797c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\n"); 11807c478bd9Sstevel@tonic-gate } 11817c478bd9Sstevel@tonic-gate if (flags & HELP_NETADDR) { 11827c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("\n<net-addr> :=")); 11837c478bd9Sstevel@tonic-gate (void) fprintf(fp, 11847c478bd9Sstevel@tonic-gate gettext("\t<IPv4-address>[/<IPv4-prefix-length>] |\n")); 11857c478bd9Sstevel@tonic-gate (void) fprintf(fp, 11867c478bd9Sstevel@tonic-gate gettext("\t\t<IPv6-address>/<IPv6-prefix-length> |\n")); 11877c478bd9Sstevel@tonic-gate (void) fprintf(fp, 11887c478bd9Sstevel@tonic-gate gettext("\t\t<hostname>[/<IPv4-prefix-length>]\n")); 11897c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("See inet(3SOCKET) for IPv4 and " 11907c478bd9Sstevel@tonic-gate "IPv6 address syntax.\n")); 11917c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("<IPv4-prefix-length> := [0-32]\n")); 11927c478bd9Sstevel@tonic-gate (void) fprintf(fp, 11937c478bd9Sstevel@tonic-gate gettext("<IPv6-prefix-length> := [0-128]\n")); 11947c478bd9Sstevel@tonic-gate (void) fprintf(fp, 11957c478bd9Sstevel@tonic-gate gettext("<hostname> := [A-Za-z0-9][A-Za-z0-9-.]*\n")); 11967c478bd9Sstevel@tonic-gate } 11977c478bd9Sstevel@tonic-gate if (flags & HELP_RESOURCES) { 11989e7542f4Sdp (void) fprintf(fp, "<%s> := %s | %s | %s | %s | %s | %s |\n\t" 1199cb8a054bSGlenn Faden "%s | %s | %s | %s | %s\n\n", 12007c478bd9Sstevel@tonic-gate gettext("resource type"), rt_to_str(RT_FS), 12017c478bd9Sstevel@tonic-gate rt_to_str(RT_IPD), rt_to_str(RT_NET), rt_to_str(RT_DEVICE), 12029e7542f4Sdp rt_to_str(RT_RCTL), rt_to_str(RT_ATTR), 12030209230bSgjelinek rt_to_str(RT_DATASET), rt_to_str(RT_DCPU), 1204cb8a054bSGlenn Faden rt_to_str(RT_PCAP), rt_to_str(RT_MCAP), 1205cb8a054bSGlenn Faden rt_to_str(RT_ADMIN)); 12067c478bd9Sstevel@tonic-gate } 12077c478bd9Sstevel@tonic-gate if (flags & HELP_PROPS) { 12087c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("For resource type ... there are " 12097c478bd9Sstevel@tonic-gate "property types ...:\n")); 1210087719fdSdp (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 1211087719fdSdp pt_to_str(PT_ZONENAME)); 12127c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 12137c478bd9Sstevel@tonic-gate pt_to_str(PT_ZONEPATH)); 12149acbbeafSnn (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 12159acbbeafSnn pt_to_str(PT_BRAND)); 12167c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 12177c478bd9Sstevel@tonic-gate pt_to_str(PT_AUTOBOOT)); 12183f2f09c1Sdp (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 12193f2f09c1Sdp pt_to_str(PT_BOOTARGS)); 12207c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 12217c478bd9Sstevel@tonic-gate pt_to_str(PT_POOL)); 1222ffbafc53Scomay (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 1223ffbafc53Scomay pt_to_str(PT_LIMITPRIV)); 12240209230bSgjelinek (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 12250209230bSgjelinek pt_to_str(PT_SCHED)); 1226f4b3ec61Sdh (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 1227f4b3ec61Sdh pt_to_str(PT_IPTYPE)); 12285679c89fSjv (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 12295679c89fSjv pt_to_str(PT_HOSTID)); 12300fbb751dSJohn Levon (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 12310fbb751dSJohn Levon pt_to_str(PT_FS_ALLOWED)); 12320209230bSgjelinek (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 12330209230bSgjelinek pt_to_str(PT_MAXLWPS)); 1234*ff19e029SMenno Lageman (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 1235*ff19e029SMenno Lageman pt_to_str(PT_MAXPROCS)); 12360209230bSgjelinek (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 12370209230bSgjelinek pt_to_str(PT_MAXSHMMEM)); 12380209230bSgjelinek (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 12390209230bSgjelinek pt_to_str(PT_MAXSHMIDS)); 12400209230bSgjelinek (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 12410209230bSgjelinek pt_to_str(PT_MAXMSGIDS)); 12420209230bSgjelinek (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 12430209230bSgjelinek pt_to_str(PT_MAXSEMIDS)); 12440209230bSgjelinek (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 12450209230bSgjelinek pt_to_str(PT_SHARES)); 12466d4d1c0dSbatschul (void) fprintf(fp, "\t%s\t\t%s, %s, %s, %s, %s\n", 12476d4d1c0dSbatschul rt_to_str(RT_FS), pt_to_str(PT_DIR), 12486d4d1c0dSbatschul pt_to_str(PT_SPECIAL), pt_to_str(PT_RAW), 12496d4d1c0dSbatschul pt_to_str(PT_TYPE), pt_to_str(PT_OPTIONS)); 12507c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t%s\n", rt_to_str(RT_IPD), 12517c478bd9Sstevel@tonic-gate pt_to_str(PT_DIR)); 1252de860bd9Sgfaden (void) fprintf(fp, "\t%s\t\t%s, %s, %s\n", rt_to_str(RT_NET), 1253de860bd9Sgfaden pt_to_str(PT_ADDRESS), pt_to_str(PT_PHYSICAL), 1254de860bd9Sgfaden pt_to_str(PT_DEFROUTER)); 12557c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t\t%s\n", rt_to_str(RT_DEVICE), 12567c478bd9Sstevel@tonic-gate pt_to_str(PT_MATCH)); 12577c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t\t%s, %s\n", rt_to_str(RT_RCTL), 12587c478bd9Sstevel@tonic-gate pt_to_str(PT_NAME), pt_to_str(PT_VALUE)); 12597c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t\t%s, %s, %s\n", rt_to_str(RT_ATTR), 12607c478bd9Sstevel@tonic-gate pt_to_str(PT_NAME), pt_to_str(PT_TYPE), 12617c478bd9Sstevel@tonic-gate pt_to_str(PT_VALUE)); 1262fa9e4066Sahrens (void) fprintf(fp, "\t%s\t\t%s\n", rt_to_str(RT_DATASET), 1263fa9e4066Sahrens pt_to_str(PT_NAME)); 12640209230bSgjelinek (void) fprintf(fp, "\t%s\t%s, %s\n", rt_to_str(RT_DCPU), 12650209230bSgjelinek pt_to_str(PT_NCPUS), pt_to_str(PT_IMPORTANCE)); 1266c97ad5cdSakolb (void) fprintf(fp, "\t%s\t%s\n", rt_to_str(RT_PCAP), 1267c97ad5cdSakolb pt_to_str(PT_NCPUS)); 12680209230bSgjelinek (void) fprintf(fp, "\t%s\t%s, %s, %s\n", rt_to_str(RT_MCAP), 12690209230bSgjelinek pt_to_str(PT_PHYSICAL), pt_to_str(PT_SWAP), 12700209230bSgjelinek pt_to_str(PT_LOCKED)); 1271cb8a054bSGlenn Faden (void) fprintf(fp, "\t%s\t\t%s, %s\n", rt_to_str(RT_ADMIN), 1272cb8a054bSGlenn Faden pt_to_str(PT_USER), pt_to_str(PT_AUTHS)); 12737c478bd9Sstevel@tonic-gate } 12747c478bd9Sstevel@tonic-gate if (need_to_close) 12757c478bd9Sstevel@tonic-gate (void) pclose(fp); 12767c478bd9Sstevel@tonic-gate } 12777c478bd9Sstevel@tonic-gate 12787c478bd9Sstevel@tonic-gate static void 1279bbec428eSgjelinek zone_perror(char *prefix, int err, boolean_t set_saw) 12807c478bd9Sstevel@tonic-gate { 12817c478bd9Sstevel@tonic-gate zerr("%s: %s", prefix, zonecfg_strerror(err)); 12827c478bd9Sstevel@tonic-gate if (set_saw) 1283bbec428eSgjelinek saw_error = B_TRUE; 12847c478bd9Sstevel@tonic-gate } 12857c478bd9Sstevel@tonic-gate 12867c478bd9Sstevel@tonic-gate /* 12877c478bd9Sstevel@tonic-gate * zone_perror() expects a single string, but for remove and select 12887c478bd9Sstevel@tonic-gate * we have both the command and the resource type, so this wrapper 12897c478bd9Sstevel@tonic-gate * function serves the same purpose in a slightly different way. 12907c478bd9Sstevel@tonic-gate */ 12917c478bd9Sstevel@tonic-gate 12927c478bd9Sstevel@tonic-gate static void 1293bbec428eSgjelinek z_cmd_rt_perror(int cmd_num, int res_num, int err, boolean_t set_saw) 12947c478bd9Sstevel@tonic-gate { 12957c478bd9Sstevel@tonic-gate zerr("%s %s: %s", cmd_to_str(cmd_num), rt_to_str(res_num), 12967c478bd9Sstevel@tonic-gate zonecfg_strerror(err)); 12977c478bd9Sstevel@tonic-gate if (set_saw) 1298bbec428eSgjelinek saw_error = B_TRUE; 12997c478bd9Sstevel@tonic-gate } 13007c478bd9Sstevel@tonic-gate 13017c478bd9Sstevel@tonic-gate /* returns Z_OK if successful, Z_foo from <libzonecfg.h> otherwise */ 13027c478bd9Sstevel@tonic-gate static int 1303bbec428eSgjelinek initialize(boolean_t handle_expected) 13047c478bd9Sstevel@tonic-gate { 13057c478bd9Sstevel@tonic-gate int err; 13069acbbeafSnn char brandname[MAXNAMELEN]; 13077c478bd9Sstevel@tonic-gate 13087c478bd9Sstevel@tonic-gate if (zonecfg_check_handle(handle) != Z_OK) { 13097c478bd9Sstevel@tonic-gate if ((err = zonecfg_get_handle(zone, handle)) == Z_OK) { 1310bbec428eSgjelinek got_handle = B_TRUE; 13119acbbeafSnn if (zonecfg_get_brand(handle, brandname, 13129acbbeafSnn sizeof (brandname)) != Z_OK) { 13139acbbeafSnn zerr("Zone %s is inconsistent: missing " 13149acbbeafSnn "brand attribute", zone); 13159acbbeafSnn exit(Z_ERR); 13169acbbeafSnn } 13179acbbeafSnn if ((brand = brand_open(brandname)) == NULL) { 13189acbbeafSnn zerr("Zone %s uses non-existent brand \"%s\"." 13199acbbeafSnn " Unable to continue", zone, brandname); 13209acbbeafSnn exit(Z_ERR); 13219acbbeafSnn } 1322cb8a054bSGlenn Faden /* 1323cb8a054bSGlenn Faden * If the user_attr file is newer than 1324cb8a054bSGlenn Faden * the zone config file, the admins 1325cb8a054bSGlenn Faden * may need to be updated since the 1326cb8a054bSGlenn Faden * RBAC files are authoritative for 1327cb8a054bSGlenn Faden * authorization checks. 1328cb8a054bSGlenn Faden */ 1329cb8a054bSGlenn Faden err = zonecfg_update_userauths(handle, zone); 1330cb8a054bSGlenn Faden if (err == Z_OK) { 1331cb8a054bSGlenn Faden zerr(gettext("The administrative rights " 1332cb8a054bSGlenn Faden "were updated to match " 1333cb8a054bSGlenn Faden "the current RBAC configuration.\n" 1334cb8a054bSGlenn Faden "Use \"info admin\" and \"revert\" to " 1335cb8a054bSGlenn Faden "compare with the previous settings.")); 1336cb8a054bSGlenn Faden need_to_commit = B_TRUE; 1337cb8a054bSGlenn Faden } else if (err != Z_NO_ENTRY) { 1338cb8a054bSGlenn Faden zerr(gettext("failed to update " 1339cb8a054bSGlenn Faden "admin rights.")); 1340cb8a054bSGlenn Faden exit(Z_ERR); 1341cb8a054bSGlenn Faden } else if (need_to_commit) { 1342cb8a054bSGlenn Faden zerr(gettext("admin rights were updated " 1343cb8a054bSGlenn Faden "to match RBAC configuration.")); 1344cb8a054bSGlenn Faden } 1345cb8a054bSGlenn Faden 13460209230bSgjelinek } else if (global_zone && err == Z_NO_ZONE && !got_handle && 13470209230bSgjelinek !read_only_mode) { 13480209230bSgjelinek /* 13490209230bSgjelinek * We implicitly create the global zone config if it 13500209230bSgjelinek * doesn't exist. 13510209230bSgjelinek */ 13520209230bSgjelinek zone_dochandle_t tmphandle; 13530209230bSgjelinek 13540209230bSgjelinek if ((tmphandle = zonecfg_init_handle()) == NULL) { 1355bbec428eSgjelinek zone_perror(execname, Z_NOMEM, B_TRUE); 13560209230bSgjelinek exit(Z_ERR); 13570209230bSgjelinek } 13580209230bSgjelinek 13590209230bSgjelinek err = zonecfg_get_template_handle("SUNWblank", zone, 13600209230bSgjelinek tmphandle); 13610209230bSgjelinek 13620209230bSgjelinek if (err != Z_OK) { 13630209230bSgjelinek zonecfg_fini_handle(tmphandle); 1364bbec428eSgjelinek zone_perror("SUNWblank", err, B_TRUE); 13650209230bSgjelinek return (err); 13660209230bSgjelinek } 13670209230bSgjelinek 1368bbec428eSgjelinek need_to_commit = B_TRUE; 13690209230bSgjelinek zonecfg_fini_handle(handle); 13700209230bSgjelinek handle = tmphandle; 1371bbec428eSgjelinek got_handle = B_TRUE; 13720209230bSgjelinek 13737c478bd9Sstevel@tonic-gate } else { 13747c478bd9Sstevel@tonic-gate zone_perror(zone, err, handle_expected || got_handle); 13757c478bd9Sstevel@tonic-gate if (err == Z_NO_ZONE && !got_handle && 13767c478bd9Sstevel@tonic-gate interactive_mode && !read_only_mode) 13777c478bd9Sstevel@tonic-gate (void) printf(gettext("Use '%s' to begin " 13787c478bd9Sstevel@tonic-gate "configuring a new zone.\n"), 13797c478bd9Sstevel@tonic-gate cmd_to_str(CMD_CREATE)); 13807c478bd9Sstevel@tonic-gate return (err); 13817c478bd9Sstevel@tonic-gate } 13827c478bd9Sstevel@tonic-gate } 13837c478bd9Sstevel@tonic-gate return (Z_OK); 13847c478bd9Sstevel@tonic-gate } 13857c478bd9Sstevel@tonic-gate 1386bbec428eSgjelinek static boolean_t 1387087719fdSdp state_atleast(zone_state_t state) 1388087719fdSdp { 1389087719fdSdp zone_state_t state_num; 1390087719fdSdp int err; 1391087719fdSdp 1392087719fdSdp if ((err = zone_get_state(zone, &state_num)) != Z_OK) { 1393087719fdSdp /* all states are greater than "non-existent" */ 1394087719fdSdp if (err == Z_NO_ZONE) 1395087719fdSdp return (B_FALSE); 1396087719fdSdp zerr(gettext("Unexpectedly failed to determine state " 1397087719fdSdp "of zone %s: %s"), zone, zonecfg_strerror(err)); 1398087719fdSdp exit(Z_ERR); 1399087719fdSdp } 1400087719fdSdp return (state_num >= state); 1401087719fdSdp } 1402087719fdSdp 14037c478bd9Sstevel@tonic-gate /* 14047c478bd9Sstevel@tonic-gate * short_usage() is for bad syntax: getopt() issues, too many arguments, etc. 14057c478bd9Sstevel@tonic-gate */ 14067c478bd9Sstevel@tonic-gate 14077c478bd9Sstevel@tonic-gate void 14087c478bd9Sstevel@tonic-gate short_usage(int command) 14097c478bd9Sstevel@tonic-gate { 14107c478bd9Sstevel@tonic-gate /* lex_lineno has already been incremented in the lexer; compensate */ 14117c478bd9Sstevel@tonic-gate if (cmd_file_mode) { 14127c478bd9Sstevel@tonic-gate if (strcmp(cmd_file_name, "-") == 0) 14137c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 14147c478bd9Sstevel@tonic-gate gettext("syntax error on line %d\n"), 14157c478bd9Sstevel@tonic-gate lex_lineno - 1); 14167c478bd9Sstevel@tonic-gate else 14177c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 14187c478bd9Sstevel@tonic-gate gettext("syntax error on line %d of %s\n"), 14197c478bd9Sstevel@tonic-gate lex_lineno - 1, cmd_file_name); 14207c478bd9Sstevel@tonic-gate } 14217c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "%s:\n%s\n", gettext("usage"), 14227c478bd9Sstevel@tonic-gate helptab[command].short_usage); 1423bbec428eSgjelinek saw_error = B_TRUE; 14247c478bd9Sstevel@tonic-gate } 14257c478bd9Sstevel@tonic-gate 14267c478bd9Sstevel@tonic-gate /* 14277c478bd9Sstevel@tonic-gate * long_usage() is for bad semantics: e.g., wrong property type for a given 14287c478bd9Sstevel@tonic-gate * resource type. It is also used by longer_usage() below. 14297c478bd9Sstevel@tonic-gate */ 14307c478bd9Sstevel@tonic-gate 14317c478bd9Sstevel@tonic-gate void 1432bbec428eSgjelinek long_usage(uint_t cmd_num, boolean_t set_saw) 14337c478bd9Sstevel@tonic-gate { 14347c478bd9Sstevel@tonic-gate (void) fprintf(set_saw ? stderr : stdout, "%s:\n%s\n", gettext("usage"), 14357c478bd9Sstevel@tonic-gate helptab[cmd_num].short_usage); 14367c478bd9Sstevel@tonic-gate (void) fprintf(set_saw ? stderr : stdout, "\t%s\n", long_help(cmd_num)); 14377c478bd9Sstevel@tonic-gate if (set_saw) 1438bbec428eSgjelinek saw_error = B_TRUE; 14397c478bd9Sstevel@tonic-gate } 14407c478bd9Sstevel@tonic-gate 14417c478bd9Sstevel@tonic-gate /* 14427c478bd9Sstevel@tonic-gate * longer_usage() is for 'help foo' and 'foo -?': call long_usage() and also 14437c478bd9Sstevel@tonic-gate * any extra usage() flags as appropriate for whatever command. 14447c478bd9Sstevel@tonic-gate */ 14457c478bd9Sstevel@tonic-gate 14467c478bd9Sstevel@tonic-gate void 14477c478bd9Sstevel@tonic-gate longer_usage(uint_t cmd_num) 14487c478bd9Sstevel@tonic-gate { 1449bbec428eSgjelinek long_usage(cmd_num, B_FALSE); 14507c478bd9Sstevel@tonic-gate if (helptab[cmd_num].flags != 0) { 14517c478bd9Sstevel@tonic-gate (void) printf("\n"); 1452bbec428eSgjelinek usage(B_TRUE, helptab[cmd_num].flags); 14537c478bd9Sstevel@tonic-gate } 14547c478bd9Sstevel@tonic-gate } 14557c478bd9Sstevel@tonic-gate 14567c478bd9Sstevel@tonic-gate /* 14577c478bd9Sstevel@tonic-gate * scope_usage() is simply used when a command is called from the wrong scope. 14587c478bd9Sstevel@tonic-gate */ 14597c478bd9Sstevel@tonic-gate 14607c478bd9Sstevel@tonic-gate static void 14617c478bd9Sstevel@tonic-gate scope_usage(uint_t cmd_num) 14627c478bd9Sstevel@tonic-gate { 14637c478bd9Sstevel@tonic-gate zerr(gettext("The %s command only makes sense in the %s scope."), 14647c478bd9Sstevel@tonic-gate cmd_to_str(cmd_num), 14657c478bd9Sstevel@tonic-gate global_scope ? gettext("resource") : gettext("global")); 1466bbec428eSgjelinek saw_error = B_TRUE; 14677c478bd9Sstevel@tonic-gate } 14687c478bd9Sstevel@tonic-gate 14697c478bd9Sstevel@tonic-gate /* 1470bbec428eSgjelinek * On input, B_TRUE => yes, B_FALSE => no. 1471bbec428eSgjelinek * On return, B_TRUE => 1, B_FALSE => no, could not ask => -1. 14727c478bd9Sstevel@tonic-gate */ 14737c478bd9Sstevel@tonic-gate 14747c478bd9Sstevel@tonic-gate static int 1475bbec428eSgjelinek ask_yesno(boolean_t default_answer, const char *question) 14767c478bd9Sstevel@tonic-gate { 14777c478bd9Sstevel@tonic-gate char line[64]; /* should be enough to answer yes or no */ 14787c478bd9Sstevel@tonic-gate 14797c478bd9Sstevel@tonic-gate if (!ok_to_prompt) { 1480bbec428eSgjelinek saw_error = B_TRUE; 14817c478bd9Sstevel@tonic-gate return (-1); 14827c478bd9Sstevel@tonic-gate } 14837c478bd9Sstevel@tonic-gate for (;;) { 1484087719fdSdp if (printf("%s (%s)? ", question, 1485087719fdSdp default_answer ? "[y]/n" : "y/[n]") < 0) 1486087719fdSdp return (-1); 1487087719fdSdp if (fgets(line, sizeof (line), stdin) == NULL) 1488087719fdSdp return (-1); 1489087719fdSdp 1490087719fdSdp if (line[0] == '\n') 14917c478bd9Sstevel@tonic-gate return (default_answer ? 1 : 0); 14927c478bd9Sstevel@tonic-gate if (tolower(line[0]) == 'y') 14937c478bd9Sstevel@tonic-gate return (1); 14947c478bd9Sstevel@tonic-gate if (tolower(line[0]) == 'n') 14957c478bd9Sstevel@tonic-gate return (0); 14967c478bd9Sstevel@tonic-gate } 14977c478bd9Sstevel@tonic-gate } 14987c478bd9Sstevel@tonic-gate 14997c478bd9Sstevel@tonic-gate /* 15007c478bd9Sstevel@tonic-gate * Prints warning if zone already exists. 15017c478bd9Sstevel@tonic-gate * In interactive mode, prompts if we should continue anyway and returns Z_OK 15027c478bd9Sstevel@tonic-gate * if so, Z_ERR if not. In non-interactive mode, exits with Z_ERR. 15037c478bd9Sstevel@tonic-gate * 15047c478bd9Sstevel@tonic-gate * Note that if a zone exists and its state is >= INSTALLED, an error message 15057c478bd9Sstevel@tonic-gate * will be printed and this function will return Z_ERR regardless of mode. 15067c478bd9Sstevel@tonic-gate */ 15077c478bd9Sstevel@tonic-gate 15087c478bd9Sstevel@tonic-gate static int 1509bbec428eSgjelinek check_if_zone_already_exists(boolean_t force) 15107c478bd9Sstevel@tonic-gate { 15117c478bd9Sstevel@tonic-gate char line[ZONENAME_MAX + 128]; /* enough to ask a question */ 15127c478bd9Sstevel@tonic-gate zone_dochandle_t tmphandle; 15137c478bd9Sstevel@tonic-gate int res, answer; 15147c478bd9Sstevel@tonic-gate 15157c478bd9Sstevel@tonic-gate if ((tmphandle = zonecfg_init_handle()) == NULL) { 1516bbec428eSgjelinek zone_perror(execname, Z_NOMEM, B_TRUE); 15177c478bd9Sstevel@tonic-gate exit(Z_ERR); 15187c478bd9Sstevel@tonic-gate } 15197c478bd9Sstevel@tonic-gate res = zonecfg_get_handle(zone, tmphandle); 15207c478bd9Sstevel@tonic-gate zonecfg_fini_handle(tmphandle); 1521087719fdSdp if (res != Z_OK) 15227c478bd9Sstevel@tonic-gate return (Z_OK); 1523087719fdSdp 1524087719fdSdp if (state_atleast(ZONE_STATE_INSTALLED)) { 15257c478bd9Sstevel@tonic-gate zerr(gettext("Zone %s already installed; %s not allowed."), 15267c478bd9Sstevel@tonic-gate zone, cmd_to_str(CMD_CREATE)); 15277c478bd9Sstevel@tonic-gate return (Z_ERR); 15287c478bd9Sstevel@tonic-gate } 15297c478bd9Sstevel@tonic-gate 15307c478bd9Sstevel@tonic-gate if (force) { 15317c478bd9Sstevel@tonic-gate (void) printf(gettext("Zone %s already exists; overwriting.\n"), 15327c478bd9Sstevel@tonic-gate zone); 15337c478bd9Sstevel@tonic-gate return (Z_OK); 15347c478bd9Sstevel@tonic-gate } 15357c478bd9Sstevel@tonic-gate (void) snprintf(line, sizeof (line), 15367c478bd9Sstevel@tonic-gate gettext("Zone %s already exists; %s anyway"), zone, 15377c478bd9Sstevel@tonic-gate cmd_to_str(CMD_CREATE)); 1538bbec428eSgjelinek if ((answer = ask_yesno(B_FALSE, line)) == -1) { 15397c478bd9Sstevel@tonic-gate zerr(gettext("Zone exists, input not from terminal and -F not " 15407c478bd9Sstevel@tonic-gate "specified:\n%s command ignored, exiting."), 15417c478bd9Sstevel@tonic-gate cmd_to_str(CMD_CREATE)); 15427c478bd9Sstevel@tonic-gate exit(Z_ERR); 15437c478bd9Sstevel@tonic-gate } 15447c478bd9Sstevel@tonic-gate return (answer == 1 ? Z_OK : Z_ERR); 15457c478bd9Sstevel@tonic-gate } 15467c478bd9Sstevel@tonic-gate 1547bbec428eSgjelinek static boolean_t 15487c478bd9Sstevel@tonic-gate zone_is_read_only(int cmd_num) 15497c478bd9Sstevel@tonic-gate { 15507c478bd9Sstevel@tonic-gate if (strncmp(zone, "SUNW", 4) == 0) { 15517c478bd9Sstevel@tonic-gate zerr(gettext("%s: zones beginning with SUNW are read-only."), 15527c478bd9Sstevel@tonic-gate zone); 1553bbec428eSgjelinek saw_error = B_TRUE; 1554bbec428eSgjelinek return (B_TRUE); 15557c478bd9Sstevel@tonic-gate } 15567c478bd9Sstevel@tonic-gate if (read_only_mode) { 15577c478bd9Sstevel@tonic-gate zerr(gettext("%s: cannot %s in read-only mode."), zone, 15587c478bd9Sstevel@tonic-gate cmd_to_str(cmd_num)); 1559bbec428eSgjelinek saw_error = B_TRUE; 1560bbec428eSgjelinek return (B_TRUE); 15617c478bd9Sstevel@tonic-gate } 1562bbec428eSgjelinek return (B_FALSE); 15637c478bd9Sstevel@tonic-gate } 15647c478bd9Sstevel@tonic-gate 15657c478bd9Sstevel@tonic-gate /* 15667c478bd9Sstevel@tonic-gate * Create a new configuration. 15677c478bd9Sstevel@tonic-gate */ 15687c478bd9Sstevel@tonic-gate void 15697c478bd9Sstevel@tonic-gate create_func(cmd_t *cmd) 15707c478bd9Sstevel@tonic-gate { 15717c478bd9Sstevel@tonic-gate int err, arg; 15727c478bd9Sstevel@tonic-gate char zone_template[ZONENAME_MAX]; 1573ee519a1fSgjelinek char attach_path[MAXPATHLEN]; 15747c478bd9Sstevel@tonic-gate zone_dochandle_t tmphandle; 1575bbec428eSgjelinek boolean_t force = B_FALSE; 1576bbec428eSgjelinek boolean_t attach = B_FALSE; 1577bbec428eSgjelinek boolean_t arg_err = B_FALSE; 15787c478bd9Sstevel@tonic-gate 15797c478bd9Sstevel@tonic-gate assert(cmd != NULL); 15807c478bd9Sstevel@tonic-gate 15817c478bd9Sstevel@tonic-gate /* This is the default if no arguments are given. */ 15827c478bd9Sstevel@tonic-gate (void) strlcpy(zone_template, "SUNWdefault", sizeof (zone_template)); 15837c478bd9Sstevel@tonic-gate 15847c478bd9Sstevel@tonic-gate optind = 0; 15859acbbeafSnn while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?a:bFt:")) 15869acbbeafSnn != EOF) { 15877c478bd9Sstevel@tonic-gate switch (arg) { 15887c478bd9Sstevel@tonic-gate case '?': 15897c478bd9Sstevel@tonic-gate if (optopt == '?') 15907c478bd9Sstevel@tonic-gate longer_usage(CMD_CREATE); 15917c478bd9Sstevel@tonic-gate else 15927c478bd9Sstevel@tonic-gate short_usage(CMD_CREATE); 1593bbec428eSgjelinek arg_err = B_TRUE; 15947ec75eb8Sgjelinek break; 1595ee519a1fSgjelinek case 'a': 1596ee519a1fSgjelinek (void) strlcpy(attach_path, optarg, 1597ee519a1fSgjelinek sizeof (attach_path)); 1598bbec428eSgjelinek attach = B_TRUE; 1599ee519a1fSgjelinek break; 16007c478bd9Sstevel@tonic-gate case 'b': 16017c478bd9Sstevel@tonic-gate (void) strlcpy(zone_template, "SUNWblank", 16027c478bd9Sstevel@tonic-gate sizeof (zone_template)); 16037c478bd9Sstevel@tonic-gate break; 16047c478bd9Sstevel@tonic-gate case 'F': 1605bbec428eSgjelinek force = B_TRUE; 16067c478bd9Sstevel@tonic-gate break; 16077c478bd9Sstevel@tonic-gate case 't': 16087c478bd9Sstevel@tonic-gate (void) strlcpy(zone_template, optarg, 16097c478bd9Sstevel@tonic-gate sizeof (zone_template)); 16107c478bd9Sstevel@tonic-gate break; 16117c478bd9Sstevel@tonic-gate default: 16127c478bd9Sstevel@tonic-gate short_usage(CMD_CREATE); 1613bbec428eSgjelinek arg_err = B_TRUE; 16147ec75eb8Sgjelinek break; 16157c478bd9Sstevel@tonic-gate } 16167c478bd9Sstevel@tonic-gate } 16177ec75eb8Sgjelinek if (arg_err) 16187ec75eb8Sgjelinek return; 16197ec75eb8Sgjelinek 16207c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 16217c478bd9Sstevel@tonic-gate short_usage(CMD_CREATE); 16227c478bd9Sstevel@tonic-gate return; 16237c478bd9Sstevel@tonic-gate } 16247c478bd9Sstevel@tonic-gate 16257c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_CREATE)) 16267c478bd9Sstevel@tonic-gate return; 16277c478bd9Sstevel@tonic-gate 16287c478bd9Sstevel@tonic-gate if (check_if_zone_already_exists(force) != Z_OK) 16297c478bd9Sstevel@tonic-gate return; 16307c478bd9Sstevel@tonic-gate 16317c478bd9Sstevel@tonic-gate /* 16327c478bd9Sstevel@tonic-gate * Get a temporary handle first. If that fails, the old handle 16337c478bd9Sstevel@tonic-gate * will not be lost. Then finish whichever one we don't need, 16347c478bd9Sstevel@tonic-gate * to avoid leaks. Then get the handle for zone_template, and 16357c478bd9Sstevel@tonic-gate * set the name to zone: this "copy, rename" method is how 16367c478bd9Sstevel@tonic-gate * create -[b|t] works. 16377c478bd9Sstevel@tonic-gate */ 16387c478bd9Sstevel@tonic-gate if ((tmphandle = zonecfg_init_handle()) == NULL) { 1639bbec428eSgjelinek zone_perror(execname, Z_NOMEM, B_TRUE); 16407c478bd9Sstevel@tonic-gate exit(Z_ERR); 16417c478bd9Sstevel@tonic-gate } 1642ee519a1fSgjelinek 1643ee519a1fSgjelinek if (attach) 164416ab8c7bSgjelinek err = zonecfg_get_attach_handle(attach_path, ZONE_DETACHED, 164516ab8c7bSgjelinek zone, B_FALSE, tmphandle); 1646ee519a1fSgjelinek else 1647ee519a1fSgjelinek err = zonecfg_get_template_handle(zone_template, zone, 1648ee519a1fSgjelinek tmphandle); 1649ee519a1fSgjelinek 1650ee519a1fSgjelinek if (err != Z_OK) { 16517c478bd9Sstevel@tonic-gate zonecfg_fini_handle(tmphandle); 1652ee519a1fSgjelinek if (attach && err == Z_NO_ZONE) 1653ee519a1fSgjelinek (void) fprintf(stderr, gettext("invalid path to " 1654ee519a1fSgjelinek "detached zone\n")); 1655ee519a1fSgjelinek else if (attach && err == Z_INVALID_DOCUMENT) 1656ee519a1fSgjelinek (void) fprintf(stderr, gettext("Cannot attach to an " 1657ee519a1fSgjelinek "earlier release of the operating system\n")); 1658ee519a1fSgjelinek else 1659bbec428eSgjelinek zone_perror(zone_template, err, B_TRUE); 16607c478bd9Sstevel@tonic-gate return; 16617c478bd9Sstevel@tonic-gate } 1662087719fdSdp 1663bbec428eSgjelinek need_to_commit = B_TRUE; 16647c478bd9Sstevel@tonic-gate zonecfg_fini_handle(handle); 16657c478bd9Sstevel@tonic-gate handle = tmphandle; 1666bbec428eSgjelinek got_handle = B_TRUE; 16677c478bd9Sstevel@tonic-gate } 16687c478bd9Sstevel@tonic-gate 16697c478bd9Sstevel@tonic-gate /* 16707c478bd9Sstevel@tonic-gate * This malloc()'s memory, which must be freed by the caller. 16717c478bd9Sstevel@tonic-gate */ 16727c478bd9Sstevel@tonic-gate static char * 16737c478bd9Sstevel@tonic-gate quoteit(char *instr) 16747c478bd9Sstevel@tonic-gate { 16757c478bd9Sstevel@tonic-gate char *outstr; 16767c478bd9Sstevel@tonic-gate size_t outstrsize = strlen(instr) + 3; /* 2 quotes + '\0' */ 16777c478bd9Sstevel@tonic-gate 16787c478bd9Sstevel@tonic-gate if ((outstr = malloc(outstrsize)) == NULL) { 1679bbec428eSgjelinek zone_perror(zone, Z_NOMEM, B_FALSE); 16807c478bd9Sstevel@tonic-gate exit(Z_ERR); 16817c478bd9Sstevel@tonic-gate } 16827c478bd9Sstevel@tonic-gate if (strchr(instr, ' ') == NULL) { 16837c478bd9Sstevel@tonic-gate (void) strlcpy(outstr, instr, outstrsize); 16847c478bd9Sstevel@tonic-gate return (outstr); 16857c478bd9Sstevel@tonic-gate } 16867c478bd9Sstevel@tonic-gate (void) snprintf(outstr, outstrsize, "\"%s\"", instr); 16877c478bd9Sstevel@tonic-gate return (outstr); 16887c478bd9Sstevel@tonic-gate } 16897c478bd9Sstevel@tonic-gate 16907c478bd9Sstevel@tonic-gate static void 16917c478bd9Sstevel@tonic-gate export_prop(FILE *of, int prop_num, char *prop_id) 16927c478bd9Sstevel@tonic-gate { 16937c478bd9Sstevel@tonic-gate char *quote_str; 16947c478bd9Sstevel@tonic-gate 16957c478bd9Sstevel@tonic-gate if (strlen(prop_id) == 0) 16967c478bd9Sstevel@tonic-gate return; 16977c478bd9Sstevel@tonic-gate quote_str = quoteit(prop_id); 16987c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 16997c478bd9Sstevel@tonic-gate pt_to_str(prop_num), quote_str); 17007c478bd9Sstevel@tonic-gate free(quote_str); 17017c478bd9Sstevel@tonic-gate } 17027c478bd9Sstevel@tonic-gate 17037c478bd9Sstevel@tonic-gate void 17047c478bd9Sstevel@tonic-gate export_func(cmd_t *cmd) 17057c478bd9Sstevel@tonic-gate { 17067c478bd9Sstevel@tonic-gate struct zone_nwiftab nwiftab; 17077c478bd9Sstevel@tonic-gate struct zone_fstab fstab; 17087c478bd9Sstevel@tonic-gate struct zone_devtab devtab; 17097c478bd9Sstevel@tonic-gate struct zone_attrtab attrtab; 17107c478bd9Sstevel@tonic-gate struct zone_rctltab rctltab; 1711fa9e4066Sahrens struct zone_dstab dstab; 17120209230bSgjelinek struct zone_psettab psettab; 17130209230bSgjelinek struct zone_mcaptab mcaptab; 17147c478bd9Sstevel@tonic-gate struct zone_rctlvaltab *valptr; 1715cb8a054bSGlenn Faden struct zone_admintab admintab; 17167c478bd9Sstevel@tonic-gate int err, arg; 17177c478bd9Sstevel@tonic-gate char zonepath[MAXPATHLEN], outfile[MAXPATHLEN], pool[MAXNAMELEN]; 17183f2f09c1Sdp char bootargs[BOOTARGS_MAX]; 17190209230bSgjelinek char sched[MAXNAMELEN]; 17209acbbeafSnn char brand[MAXNAMELEN]; 17215679c89fSjv char hostidp[HW_HOSTID_LEN]; 17220fbb751dSJohn Levon char fsallowedp[ZONE_FS_ALLOWED_MAX]; 1723ffbafc53Scomay char *limitpriv; 17247c478bd9Sstevel@tonic-gate FILE *of; 17257c478bd9Sstevel@tonic-gate boolean_t autoboot; 1726f4b3ec61Sdh zone_iptype_t iptype; 1727bbec428eSgjelinek boolean_t need_to_close = B_FALSE; 1728bbec428eSgjelinek boolean_t arg_err = B_FALSE; 17297c478bd9Sstevel@tonic-gate 17307c478bd9Sstevel@tonic-gate assert(cmd != NULL); 17317c478bd9Sstevel@tonic-gate 17327c478bd9Sstevel@tonic-gate outfile[0] = '\0'; 17337c478bd9Sstevel@tonic-gate optind = 0; 17347c478bd9Sstevel@tonic-gate while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?f:")) != EOF) { 17357c478bd9Sstevel@tonic-gate switch (arg) { 17367c478bd9Sstevel@tonic-gate case '?': 17377c478bd9Sstevel@tonic-gate if (optopt == '?') 17387c478bd9Sstevel@tonic-gate longer_usage(CMD_EXPORT); 17397c478bd9Sstevel@tonic-gate else 17407c478bd9Sstevel@tonic-gate short_usage(CMD_EXPORT); 1741bbec428eSgjelinek arg_err = B_TRUE; 17427ec75eb8Sgjelinek break; 17437c478bd9Sstevel@tonic-gate case 'f': 17447c478bd9Sstevel@tonic-gate (void) strlcpy(outfile, optarg, sizeof (outfile)); 17457c478bd9Sstevel@tonic-gate break; 17467c478bd9Sstevel@tonic-gate default: 17477c478bd9Sstevel@tonic-gate short_usage(CMD_EXPORT); 1748bbec428eSgjelinek arg_err = B_TRUE; 17497ec75eb8Sgjelinek break; 17507c478bd9Sstevel@tonic-gate } 17517c478bd9Sstevel@tonic-gate } 17527ec75eb8Sgjelinek if (arg_err) 17537ec75eb8Sgjelinek return; 17547ec75eb8Sgjelinek 17557c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 17567c478bd9Sstevel@tonic-gate short_usage(CMD_EXPORT); 17577c478bd9Sstevel@tonic-gate return; 17587c478bd9Sstevel@tonic-gate } 17597c478bd9Sstevel@tonic-gate if (strlen(outfile) == 0) { 17607c478bd9Sstevel@tonic-gate of = stdout; 17617c478bd9Sstevel@tonic-gate } else { 17627c478bd9Sstevel@tonic-gate if ((of = fopen(outfile, "w")) == NULL) { 17637c478bd9Sstevel@tonic-gate zerr(gettext("opening file %s: %s"), 17647c478bd9Sstevel@tonic-gate outfile, strerror(errno)); 17657c478bd9Sstevel@tonic-gate goto done; 17667c478bd9Sstevel@tonic-gate } 17677c478bd9Sstevel@tonic-gate setbuf(of, NULL); 1768bbec428eSgjelinek need_to_close = B_TRUE; 17697c478bd9Sstevel@tonic-gate } 17707c478bd9Sstevel@tonic-gate 1771bbec428eSgjelinek if ((err = initialize(B_TRUE)) != Z_OK) 17727c478bd9Sstevel@tonic-gate goto done; 17737c478bd9Sstevel@tonic-gate 17747c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s -b\n", cmd_to_str(CMD_CREATE)); 17757c478bd9Sstevel@tonic-gate 17767c478bd9Sstevel@tonic-gate if (zonecfg_get_zonepath(handle, zonepath, sizeof (zonepath)) == Z_OK && 17777c478bd9Sstevel@tonic-gate strlen(zonepath) > 0) 17787c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 17797c478bd9Sstevel@tonic-gate pt_to_str(PT_ZONEPATH), zonepath); 17807c478bd9Sstevel@tonic-gate 17819acbbeafSnn if ((zone_get_brand(zone, brand, sizeof (brand)) == Z_OK) && 17829acbbeafSnn (strcmp(brand, NATIVE_BRAND_NAME) != 0)) 17839acbbeafSnn (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 17849acbbeafSnn pt_to_str(PT_BRAND), brand); 17859acbbeafSnn 17867c478bd9Sstevel@tonic-gate if (zonecfg_get_autoboot(handle, &autoboot) == Z_OK) 17877c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 17887c478bd9Sstevel@tonic-gate pt_to_str(PT_AUTOBOOT), autoboot ? "true" : "false"); 17897c478bd9Sstevel@tonic-gate 17903f2f09c1Sdp if (zonecfg_get_bootargs(handle, bootargs, sizeof (bootargs)) == Z_OK && 17913f2f09c1Sdp strlen(bootargs) > 0) { 17923f2f09c1Sdp (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 17933f2f09c1Sdp pt_to_str(PT_BOOTARGS), bootargs); 17943f2f09c1Sdp } 17953f2f09c1Sdp 17967c478bd9Sstevel@tonic-gate if (zonecfg_get_pool(handle, pool, sizeof (pool)) == Z_OK && 17977c478bd9Sstevel@tonic-gate strlen(pool) > 0) 17987c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 17997c478bd9Sstevel@tonic-gate pt_to_str(PT_POOL), pool); 18007c478bd9Sstevel@tonic-gate 1801ffbafc53Scomay if (zonecfg_get_limitpriv(handle, &limitpriv) == Z_OK && 1802ffbafc53Scomay strlen(limitpriv) > 0) { 1803ffbafc53Scomay (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 1804ffbafc53Scomay pt_to_str(PT_LIMITPRIV), limitpriv); 1805ffbafc53Scomay free(limitpriv); 1806ffbafc53Scomay } 1807ffbafc53Scomay 18080209230bSgjelinek if (zonecfg_get_sched_class(handle, sched, sizeof (sched)) == Z_OK && 18090209230bSgjelinek strlen(sched) > 0) 18100209230bSgjelinek (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 18110209230bSgjelinek pt_to_str(PT_SCHED), sched); 18123f2f09c1Sdp 1813f4b3ec61Sdh if (zonecfg_get_iptype(handle, &iptype) == Z_OK) { 1814f4b3ec61Sdh switch (iptype) { 1815f4b3ec61Sdh case ZS_SHARED: 1816f4b3ec61Sdh (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 1817f4b3ec61Sdh pt_to_str(PT_IPTYPE), "shared"); 1818f4b3ec61Sdh break; 1819f4b3ec61Sdh case ZS_EXCLUSIVE: 1820f4b3ec61Sdh (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 1821f4b3ec61Sdh pt_to_str(PT_IPTYPE), "exclusive"); 1822f4b3ec61Sdh break; 1823f4b3ec61Sdh } 1824f4b3ec61Sdh } 1825f4b3ec61Sdh 18265679c89fSjv if (zonecfg_get_hostid(handle, hostidp, sizeof (hostidp)) == Z_OK) { 18275679c89fSjv (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 18285679c89fSjv pt_to_str(PT_HOSTID), hostidp); 18295679c89fSjv } 18305679c89fSjv 18310fbb751dSJohn Levon if (zonecfg_get_fs_allowed(handle, fsallowedp, 18320fbb751dSJohn Levon sizeof (fsallowedp)) == Z_OK) { 18330fbb751dSJohn Levon (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 18340fbb751dSJohn Levon pt_to_str(PT_FS_ALLOWED), fsallowedp); 18350fbb751dSJohn Levon } 18360fbb751dSJohn Levon 18377c478bd9Sstevel@tonic-gate if ((err = zonecfg_setipdent(handle)) != Z_OK) { 1838bbec428eSgjelinek zone_perror(zone, err, B_FALSE); 18397c478bd9Sstevel@tonic-gate goto done; 18407c478bd9Sstevel@tonic-gate } 18417c478bd9Sstevel@tonic-gate while (zonecfg_getipdent(handle, &fstab) == Z_OK) { 18427c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 18437c478bd9Sstevel@tonic-gate rt_to_str(RT_IPD)); 18447c478bd9Sstevel@tonic-gate export_prop(of, PT_DIR, fstab.zone_fs_dir); 18457c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 18467c478bd9Sstevel@tonic-gate } 18477c478bd9Sstevel@tonic-gate (void) zonecfg_endipdent(handle); 18487c478bd9Sstevel@tonic-gate 18497c478bd9Sstevel@tonic-gate if ((err = zonecfg_setfsent(handle)) != Z_OK) { 1850bbec428eSgjelinek zone_perror(zone, err, B_FALSE); 18517c478bd9Sstevel@tonic-gate goto done; 18527c478bd9Sstevel@tonic-gate } 18537c478bd9Sstevel@tonic-gate while (zonecfg_getfsent(handle, &fstab) == Z_OK) { 18547c478bd9Sstevel@tonic-gate zone_fsopt_t *optptr; 18557c478bd9Sstevel@tonic-gate 18567c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 18577c478bd9Sstevel@tonic-gate rt_to_str(RT_FS)); 18587c478bd9Sstevel@tonic-gate export_prop(of, PT_DIR, fstab.zone_fs_dir); 18597c478bd9Sstevel@tonic-gate export_prop(of, PT_SPECIAL, fstab.zone_fs_special); 18607c478bd9Sstevel@tonic-gate export_prop(of, PT_RAW, fstab.zone_fs_raw); 18617c478bd9Sstevel@tonic-gate export_prop(of, PT_TYPE, fstab.zone_fs_type); 18627c478bd9Sstevel@tonic-gate for (optptr = fstab.zone_fs_options; optptr != NULL; 18637c478bd9Sstevel@tonic-gate optptr = optptr->zone_fsopt_next) { 18647c478bd9Sstevel@tonic-gate /* 18657c478bd9Sstevel@tonic-gate * Simple property values with embedded equal signs 18667c478bd9Sstevel@tonic-gate * need to be quoted to prevent the lexer from 18677c478bd9Sstevel@tonic-gate * mis-parsing them as complex name=value pairs. 18687c478bd9Sstevel@tonic-gate */ 18697c478bd9Sstevel@tonic-gate if (strchr(optptr->zone_fsopt_opt, '=')) 18707c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s \"%s\"\n", 18717c478bd9Sstevel@tonic-gate cmd_to_str(CMD_ADD), 18727c478bd9Sstevel@tonic-gate pt_to_str(PT_OPTIONS), 18737c478bd9Sstevel@tonic-gate optptr->zone_fsopt_opt); 18747c478bd9Sstevel@tonic-gate else 18757c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s %s\n", 18767c478bd9Sstevel@tonic-gate cmd_to_str(CMD_ADD), 18777c478bd9Sstevel@tonic-gate pt_to_str(PT_OPTIONS), 18787c478bd9Sstevel@tonic-gate optptr->zone_fsopt_opt); 18797c478bd9Sstevel@tonic-gate } 18807c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 18817c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(fstab.zone_fs_options); 18827c478bd9Sstevel@tonic-gate } 18837c478bd9Sstevel@tonic-gate (void) zonecfg_endfsent(handle); 18847c478bd9Sstevel@tonic-gate 18857c478bd9Sstevel@tonic-gate if ((err = zonecfg_setnwifent(handle)) != Z_OK) { 1886bbec428eSgjelinek zone_perror(zone, err, B_FALSE); 18877c478bd9Sstevel@tonic-gate goto done; 18887c478bd9Sstevel@tonic-gate } 18897c478bd9Sstevel@tonic-gate while (zonecfg_getnwifent(handle, &nwiftab) == Z_OK) { 18907c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 18917c478bd9Sstevel@tonic-gate rt_to_str(RT_NET)); 18927c478bd9Sstevel@tonic-gate export_prop(of, PT_ADDRESS, nwiftab.zone_nwif_address); 18937c478bd9Sstevel@tonic-gate export_prop(of, PT_PHYSICAL, nwiftab.zone_nwif_physical); 1894de860bd9Sgfaden export_prop(of, PT_DEFROUTER, nwiftab.zone_nwif_defrouter); 18957c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 18967c478bd9Sstevel@tonic-gate } 18977c478bd9Sstevel@tonic-gate (void) zonecfg_endnwifent(handle); 18987c478bd9Sstevel@tonic-gate 18997c478bd9Sstevel@tonic-gate if ((err = zonecfg_setdevent(handle)) != Z_OK) { 1900bbec428eSgjelinek zone_perror(zone, err, B_FALSE); 19017c478bd9Sstevel@tonic-gate goto done; 19027c478bd9Sstevel@tonic-gate } 19037c478bd9Sstevel@tonic-gate while (zonecfg_getdevent(handle, &devtab) == Z_OK) { 19047c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 19057c478bd9Sstevel@tonic-gate rt_to_str(RT_DEVICE)); 19067c478bd9Sstevel@tonic-gate export_prop(of, PT_MATCH, devtab.zone_dev_match); 19077c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 19087c478bd9Sstevel@tonic-gate } 19097c478bd9Sstevel@tonic-gate (void) zonecfg_enddevent(handle); 19107c478bd9Sstevel@tonic-gate 19111b3281c0SGerald Jelinek if (zonecfg_getmcapent(handle, &mcaptab) == Z_OK) { 19121b3281c0SGerald Jelinek char buf[128]; 19131b3281c0SGerald Jelinek 19141b3281c0SGerald Jelinek (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 19151b3281c0SGerald Jelinek rt_to_str(RT_MCAP)); 19161b3281c0SGerald Jelinek bytes_to_units(mcaptab.zone_physmem_cap, buf, sizeof (buf)); 19171b3281c0SGerald Jelinek (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 19181b3281c0SGerald Jelinek pt_to_str(PT_PHYSICAL), buf); 19191b3281c0SGerald Jelinek (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 19201b3281c0SGerald Jelinek } 19211b3281c0SGerald Jelinek 19227c478bd9Sstevel@tonic-gate if ((err = zonecfg_setrctlent(handle)) != Z_OK) { 1923bbec428eSgjelinek zone_perror(zone, err, B_FALSE); 19247c478bd9Sstevel@tonic-gate goto done; 19257c478bd9Sstevel@tonic-gate } 19267c478bd9Sstevel@tonic-gate while (zonecfg_getrctlent(handle, &rctltab) == Z_OK) { 19277c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s rctl\n", cmd_to_str(CMD_ADD)); 19287c478bd9Sstevel@tonic-gate export_prop(of, PT_NAME, rctltab.zone_rctl_name); 19297c478bd9Sstevel@tonic-gate for (valptr = rctltab.zone_rctl_valptr; valptr != NULL; 19307c478bd9Sstevel@tonic-gate valptr = valptr->zone_rctlval_next) { 19317c478bd9Sstevel@tonic-gate fprintf(of, "%s %s (%s=%s,%s=%s,%s=%s)\n", 19327c478bd9Sstevel@tonic-gate cmd_to_str(CMD_ADD), pt_to_str(PT_VALUE), 19337c478bd9Sstevel@tonic-gate pt_to_str(PT_PRIV), valptr->zone_rctlval_priv, 19347c478bd9Sstevel@tonic-gate pt_to_str(PT_LIMIT), valptr->zone_rctlval_limit, 19357c478bd9Sstevel@tonic-gate pt_to_str(PT_ACTION), valptr->zone_rctlval_action); 19367c478bd9Sstevel@tonic-gate } 19377c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 19387c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctltab.zone_rctl_valptr); 19397c478bd9Sstevel@tonic-gate } 19407c478bd9Sstevel@tonic-gate (void) zonecfg_endrctlent(handle); 19417c478bd9Sstevel@tonic-gate 19427c478bd9Sstevel@tonic-gate if ((err = zonecfg_setattrent(handle)) != Z_OK) { 1943bbec428eSgjelinek zone_perror(zone, err, B_FALSE); 19447c478bd9Sstevel@tonic-gate goto done; 19457c478bd9Sstevel@tonic-gate } 19467c478bd9Sstevel@tonic-gate while (zonecfg_getattrent(handle, &attrtab) == Z_OK) { 19477c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 19487c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR)); 19497c478bd9Sstevel@tonic-gate export_prop(of, PT_NAME, attrtab.zone_attr_name); 19507c478bd9Sstevel@tonic-gate export_prop(of, PT_TYPE, attrtab.zone_attr_type); 19517c478bd9Sstevel@tonic-gate export_prop(of, PT_VALUE, attrtab.zone_attr_value); 19527c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 19537c478bd9Sstevel@tonic-gate } 19547c478bd9Sstevel@tonic-gate (void) zonecfg_endattrent(handle); 19557c478bd9Sstevel@tonic-gate 1956fa9e4066Sahrens if ((err = zonecfg_setdsent(handle)) != Z_OK) { 1957bbec428eSgjelinek zone_perror(zone, err, B_FALSE); 1958fa9e4066Sahrens goto done; 1959fa9e4066Sahrens } 1960fa9e4066Sahrens while (zonecfg_getdsent(handle, &dstab) == Z_OK) { 1961fa9e4066Sahrens (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 1962fa9e4066Sahrens rt_to_str(RT_DATASET)); 1963fa9e4066Sahrens export_prop(of, PT_NAME, dstab.zone_dataset_name); 1964fa9e4066Sahrens (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 1965fa9e4066Sahrens } 1966fa9e4066Sahrens (void) zonecfg_enddsent(handle); 1967fa9e4066Sahrens 19680209230bSgjelinek if (zonecfg_getpsetent(handle, &psettab) == Z_OK) { 19690209230bSgjelinek (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 19700209230bSgjelinek rt_to_str(RT_DCPU)); 19710209230bSgjelinek if (strcmp(psettab.zone_ncpu_min, psettab.zone_ncpu_max) == 0) 19720209230bSgjelinek (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 19730209230bSgjelinek pt_to_str(PT_NCPUS), psettab.zone_ncpu_max); 19740209230bSgjelinek else 19750209230bSgjelinek (void) fprintf(of, "%s %s=%s-%s\n", cmd_to_str(CMD_SET), 19760209230bSgjelinek pt_to_str(PT_NCPUS), psettab.zone_ncpu_min, 19770209230bSgjelinek psettab.zone_ncpu_max); 19780209230bSgjelinek if (psettab.zone_importance[0] != '\0') 19790209230bSgjelinek (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 19800209230bSgjelinek pt_to_str(PT_IMPORTANCE), psettab.zone_importance); 19810209230bSgjelinek (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 19820209230bSgjelinek } 19830209230bSgjelinek 1984cb8a054bSGlenn Faden if ((err = zonecfg_setadminent(handle)) != Z_OK) { 1985cb8a054bSGlenn Faden zone_perror(zone, err, B_FALSE); 1986cb8a054bSGlenn Faden goto done; 1987cb8a054bSGlenn Faden } 1988cb8a054bSGlenn Faden while (zonecfg_getadminent(handle, &admintab) == Z_OK) { 1989cb8a054bSGlenn Faden (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 1990cb8a054bSGlenn Faden rt_to_str(RT_ADMIN)); 1991cb8a054bSGlenn Faden export_prop(of, PT_USER, admintab.zone_admin_user); 1992cb8a054bSGlenn Faden export_prop(of, PT_AUTHS, admintab.zone_admin_auths); 1993cb8a054bSGlenn Faden (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 1994cb8a054bSGlenn Faden } 1995cb8a054bSGlenn Faden (void) zonecfg_endadminent(handle); 1996cb8a054bSGlenn Faden 1997c97ad5cdSakolb /* 1998c97ad5cdSakolb * There is nothing to export for pcap since this resource is just 1999c97ad5cdSakolb * a container for an rctl alias. 2000c97ad5cdSakolb */ 2001c97ad5cdSakolb 20027c478bd9Sstevel@tonic-gate done: 20037c478bd9Sstevel@tonic-gate if (need_to_close) 20047c478bd9Sstevel@tonic-gate (void) fclose(of); 20057c478bd9Sstevel@tonic-gate } 20067c478bd9Sstevel@tonic-gate 20077c478bd9Sstevel@tonic-gate void 20087c478bd9Sstevel@tonic-gate exit_func(cmd_t *cmd) 20097c478bd9Sstevel@tonic-gate { 20107c478bd9Sstevel@tonic-gate int arg, answer; 2011bbec428eSgjelinek boolean_t arg_err = B_FALSE; 20127c478bd9Sstevel@tonic-gate 20137c478bd9Sstevel@tonic-gate optind = 0; 20147c478bd9Sstevel@tonic-gate while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?F")) != EOF) { 20157c478bd9Sstevel@tonic-gate switch (arg) { 20167c478bd9Sstevel@tonic-gate case '?': 20177c478bd9Sstevel@tonic-gate longer_usage(CMD_EXIT); 2018bbec428eSgjelinek arg_err = B_TRUE; 20197ec75eb8Sgjelinek break; 20207c478bd9Sstevel@tonic-gate case 'F': 2021bbec428eSgjelinek force_exit = B_TRUE; 20227c478bd9Sstevel@tonic-gate break; 20237c478bd9Sstevel@tonic-gate default: 20247c478bd9Sstevel@tonic-gate short_usage(CMD_EXIT); 2025bbec428eSgjelinek arg_err = B_TRUE; 20267ec75eb8Sgjelinek break; 20277c478bd9Sstevel@tonic-gate } 20287c478bd9Sstevel@tonic-gate } 20297ec75eb8Sgjelinek if (arg_err) 20307ec75eb8Sgjelinek return; 20317ec75eb8Sgjelinek 20327c478bd9Sstevel@tonic-gate if (optind < cmd->cmd_argc) { 20337c478bd9Sstevel@tonic-gate short_usage(CMD_EXIT); 20347c478bd9Sstevel@tonic-gate return; 20357c478bd9Sstevel@tonic-gate } 20367c478bd9Sstevel@tonic-gate 20377c478bd9Sstevel@tonic-gate if (global_scope || force_exit) { 2038bbec428eSgjelinek time_to_exit = B_TRUE; 20397c478bd9Sstevel@tonic-gate return; 20407c478bd9Sstevel@tonic-gate } 20417c478bd9Sstevel@tonic-gate 2042bbec428eSgjelinek answer = ask_yesno(B_FALSE, "Resource incomplete; really quit"); 20437c478bd9Sstevel@tonic-gate if (answer == -1) { 20447c478bd9Sstevel@tonic-gate zerr(gettext("Resource incomplete, input " 20457c478bd9Sstevel@tonic-gate "not from terminal and -F not specified:\n%s command " 20467c478bd9Sstevel@tonic-gate "ignored, but exiting anyway."), cmd_to_str(CMD_EXIT)); 20477c478bd9Sstevel@tonic-gate exit(Z_ERR); 20487c478bd9Sstevel@tonic-gate } else if (answer == 1) { 2049bbec428eSgjelinek time_to_exit = B_TRUE; 20507c478bd9Sstevel@tonic-gate } 20517c478bd9Sstevel@tonic-gate /* (answer == 0) => just return */ 20527c478bd9Sstevel@tonic-gate } 20537c478bd9Sstevel@tonic-gate 20547c478bd9Sstevel@tonic-gate static int 20557c478bd9Sstevel@tonic-gate validate_zonepath_syntax(char *path) 20567c478bd9Sstevel@tonic-gate { 20577c478bd9Sstevel@tonic-gate if (path[0] != '/') { 20587c478bd9Sstevel@tonic-gate zerr(gettext("%s is not an absolute path."), path); 20597c478bd9Sstevel@tonic-gate return (Z_ERR); 20607c478bd9Sstevel@tonic-gate } 20616fb06a2bSSusan Kamm-Worrell /* If path is all slashes, then fail */ 20626fb06a2bSSusan Kamm-Worrell if (strspn(path, "/") == strlen(path)) { 20637c478bd9Sstevel@tonic-gate zerr(gettext("/ is not allowed as a %s."), 20647c478bd9Sstevel@tonic-gate pt_to_str(PT_ZONEPATH)); 20657c478bd9Sstevel@tonic-gate return (Z_ERR); 20667c478bd9Sstevel@tonic-gate } 20677c478bd9Sstevel@tonic-gate return (Z_OK); 20687c478bd9Sstevel@tonic-gate } 20697c478bd9Sstevel@tonic-gate 20707c478bd9Sstevel@tonic-gate static void 20717c478bd9Sstevel@tonic-gate add_resource(cmd_t *cmd) 20727c478bd9Sstevel@tonic-gate { 20737c478bd9Sstevel@tonic-gate int type; 20740209230bSgjelinek struct zone_psettab tmp_psettab; 20750209230bSgjelinek struct zone_mcaptab tmp_mcaptab; 2076c97ad5cdSakolb uint64_t tmp; 20770209230bSgjelinek uint64_t tmp_mcap; 20780209230bSgjelinek char pool[MAXNAMELEN]; 20797c478bd9Sstevel@tonic-gate 20807c478bd9Sstevel@tonic-gate if ((type = cmd->cmd_res_type) == RT_UNKNOWN) { 2081bbec428eSgjelinek long_usage(CMD_ADD, B_TRUE); 20827c478bd9Sstevel@tonic-gate goto bad; 20837c478bd9Sstevel@tonic-gate } 20847c478bd9Sstevel@tonic-gate 20857c478bd9Sstevel@tonic-gate switch (type) { 20867c478bd9Sstevel@tonic-gate case RT_FS: 20877c478bd9Sstevel@tonic-gate bzero(&in_progress_fstab, sizeof (in_progress_fstab)); 20887c478bd9Sstevel@tonic-gate return; 20897c478bd9Sstevel@tonic-gate case RT_IPD: 2090087719fdSdp if (state_atleast(ZONE_STATE_INSTALLED)) { 20917c478bd9Sstevel@tonic-gate zerr(gettext("Zone %s already installed; %s %s not " 20927c478bd9Sstevel@tonic-gate "allowed."), zone, cmd_to_str(CMD_ADD), 20937c478bd9Sstevel@tonic-gate rt_to_str(RT_IPD)); 20947c478bd9Sstevel@tonic-gate goto bad; 20957c478bd9Sstevel@tonic-gate } 20967c478bd9Sstevel@tonic-gate bzero(&in_progress_ipdtab, sizeof (in_progress_ipdtab)); 20977c478bd9Sstevel@tonic-gate return; 20987c478bd9Sstevel@tonic-gate case RT_NET: 20997c478bd9Sstevel@tonic-gate bzero(&in_progress_nwiftab, sizeof (in_progress_nwiftab)); 21007c478bd9Sstevel@tonic-gate return; 21017c478bd9Sstevel@tonic-gate case RT_DEVICE: 21027c478bd9Sstevel@tonic-gate bzero(&in_progress_devtab, sizeof (in_progress_devtab)); 21037c478bd9Sstevel@tonic-gate return; 21047c478bd9Sstevel@tonic-gate case RT_RCTL: 21050209230bSgjelinek if (global_zone) 21060209230bSgjelinek zerr(gettext("WARNING: Setting a global zone resource " 21070209230bSgjelinek "control too low could deny\nservice " 21080209230bSgjelinek "to even the root user; " 21090209230bSgjelinek "this could render the system impossible\n" 21100209230bSgjelinek "to administer. Please use caution.")); 21117c478bd9Sstevel@tonic-gate bzero(&in_progress_rctltab, sizeof (in_progress_rctltab)); 21127c478bd9Sstevel@tonic-gate return; 21137c478bd9Sstevel@tonic-gate case RT_ATTR: 21147c478bd9Sstevel@tonic-gate bzero(&in_progress_attrtab, sizeof (in_progress_attrtab)); 21157c478bd9Sstevel@tonic-gate return; 2116fa9e4066Sahrens case RT_DATASET: 2117fa9e4066Sahrens bzero(&in_progress_dstab, sizeof (in_progress_dstab)); 2118fa9e4066Sahrens return; 21190209230bSgjelinek case RT_DCPU: 2120c97ad5cdSakolb /* Make sure there isn't already a cpu-set or cpu-cap entry. */ 21210209230bSgjelinek if (zonecfg_lookup_pset(handle, &tmp_psettab) == Z_OK) { 21220209230bSgjelinek zerr(gettext("The %s resource already exists."), 21230209230bSgjelinek rt_to_str(RT_DCPU)); 21240209230bSgjelinek goto bad; 21250209230bSgjelinek } 2126c97ad5cdSakolb if (zonecfg_get_aliased_rctl(handle, ALIAS_CPUCAP, &tmp) != 2127c97ad5cdSakolb Z_NO_ENTRY) { 2128c97ad5cdSakolb zerr(gettext("The %s resource already exists."), 2129c97ad5cdSakolb rt_to_str(RT_PCAP)); 2130c97ad5cdSakolb goto bad; 2131c97ad5cdSakolb } 21320209230bSgjelinek 21330209230bSgjelinek /* Make sure the pool property isn't set. */ 21340209230bSgjelinek if (zonecfg_get_pool(handle, pool, sizeof (pool)) == Z_OK && 21350209230bSgjelinek strlen(pool) > 0) { 21360209230bSgjelinek zerr(gettext("The %s property is already set. " 21370209230bSgjelinek "A persistent pool is incompatible with\nthe %s " 21380209230bSgjelinek "resource."), 21390209230bSgjelinek pt_to_str(PT_POOL), rt_to_str(RT_DCPU)); 21400209230bSgjelinek goto bad; 21410209230bSgjelinek } 21420209230bSgjelinek 21430209230bSgjelinek bzero(&in_progress_psettab, sizeof (in_progress_psettab)); 21440209230bSgjelinek return; 2145c97ad5cdSakolb case RT_PCAP: 2146c97ad5cdSakolb /* 2147c97ad5cdSakolb * Make sure there isn't already a cpu-set or incompatible 2148c97ad5cdSakolb * cpu-cap rctls. 2149c97ad5cdSakolb */ 2150c97ad5cdSakolb if (zonecfg_lookup_pset(handle, &tmp_psettab) == Z_OK) { 2151c97ad5cdSakolb zerr(gettext("The %s resource already exists."), 2152c97ad5cdSakolb rt_to_str(RT_DCPU)); 2153c97ad5cdSakolb goto bad; 2154c97ad5cdSakolb } 2155c97ad5cdSakolb 2156c97ad5cdSakolb switch (zonecfg_get_aliased_rctl(handle, ALIAS_CPUCAP, &tmp)) { 2157c97ad5cdSakolb case Z_ALIAS_DISALLOW: 2158c97ad5cdSakolb zone_perror(rt_to_str(RT_PCAP), Z_ALIAS_DISALLOW, 2159bbec428eSgjelinek B_FALSE); 2160c97ad5cdSakolb goto bad; 2161c97ad5cdSakolb 2162c97ad5cdSakolb case Z_OK: 2163c97ad5cdSakolb zerr(gettext("The %s resource already exists."), 2164c97ad5cdSakolb rt_to_str(RT_PCAP)); 2165c97ad5cdSakolb goto bad; 2166c97ad5cdSakolb 2167c97ad5cdSakolb default: 2168c97ad5cdSakolb break; 2169c97ad5cdSakolb } 2170c97ad5cdSakolb return; 21710209230bSgjelinek case RT_MCAP: 21720209230bSgjelinek /* 21730209230bSgjelinek * Make sure there isn't already a mem-cap entry or max-swap 21740209230bSgjelinek * or max-locked rctl. 21750209230bSgjelinek */ 21760209230bSgjelinek if (zonecfg_lookup_mcap(handle, &tmp_mcaptab) == Z_OK || 21770209230bSgjelinek zonecfg_get_aliased_rctl(handle, ALIAS_MAXSWAP, &tmp_mcap) 21780209230bSgjelinek == Z_OK || 21790209230bSgjelinek zonecfg_get_aliased_rctl(handle, ALIAS_MAXLOCKEDMEM, 21800209230bSgjelinek &tmp_mcap) == Z_OK) { 21810209230bSgjelinek zerr(gettext("The %s resource or a related resource " 21820209230bSgjelinek "control already exists."), rt_to_str(RT_MCAP)); 21830209230bSgjelinek goto bad; 21840209230bSgjelinek } 21850209230bSgjelinek if (global_zone) 21860209230bSgjelinek zerr(gettext("WARNING: Setting a global zone memory " 21870209230bSgjelinek "cap too low could deny\nservice " 21880209230bSgjelinek "to even the root user; " 21890209230bSgjelinek "this could render the system impossible\n" 21900209230bSgjelinek "to administer. Please use caution.")); 21910209230bSgjelinek bzero(&in_progress_mcaptab, sizeof (in_progress_mcaptab)); 21920209230bSgjelinek return; 2193cb8a054bSGlenn Faden case RT_ADMIN: 2194cb8a054bSGlenn Faden bzero(&in_progress_admintab, sizeof (in_progress_admintab)); 2195cb8a054bSGlenn Faden return; 21967c478bd9Sstevel@tonic-gate default: 2197bbec428eSgjelinek zone_perror(rt_to_str(type), Z_NO_RESOURCE_TYPE, B_TRUE); 2198bbec428eSgjelinek long_usage(CMD_ADD, B_TRUE); 2199bbec428eSgjelinek usage(B_FALSE, HELP_RESOURCES); 22007c478bd9Sstevel@tonic-gate } 22017c478bd9Sstevel@tonic-gate bad: 2202bbec428eSgjelinek global_scope = B_TRUE; 22037c478bd9Sstevel@tonic-gate end_op = -1; 22047c478bd9Sstevel@tonic-gate } 22057c478bd9Sstevel@tonic-gate 22067c478bd9Sstevel@tonic-gate static void 22077c478bd9Sstevel@tonic-gate do_complex_rctl_val(complex_property_ptr_t cp) 22087c478bd9Sstevel@tonic-gate { 22097c478bd9Sstevel@tonic-gate struct zone_rctlvaltab *rctlvaltab; 22107c478bd9Sstevel@tonic-gate complex_property_ptr_t cx; 2211bbec428eSgjelinek boolean_t seen_priv = B_FALSE, seen_limit = B_FALSE, 2212bbec428eSgjelinek seen_action = B_FALSE; 22137c478bd9Sstevel@tonic-gate rctlblk_t *rctlblk; 22147c478bd9Sstevel@tonic-gate int err; 22157c478bd9Sstevel@tonic-gate 22167c478bd9Sstevel@tonic-gate if ((rctlvaltab = alloc_rctlvaltab()) == NULL) { 2217bbec428eSgjelinek zone_perror(zone, Z_NOMEM, B_TRUE); 22187c478bd9Sstevel@tonic-gate exit(Z_ERR); 22197c478bd9Sstevel@tonic-gate } 22207c478bd9Sstevel@tonic-gate for (cx = cp; cx != NULL; cx = cx->cp_next) { 22217c478bd9Sstevel@tonic-gate switch (cx->cp_type) { 22227c478bd9Sstevel@tonic-gate case PT_PRIV: 22237c478bd9Sstevel@tonic-gate if (seen_priv) { 22247c478bd9Sstevel@tonic-gate zerr(gettext("%s already specified"), 22257c478bd9Sstevel@tonic-gate pt_to_str(PT_PRIV)); 22267c478bd9Sstevel@tonic-gate goto bad; 22277c478bd9Sstevel@tonic-gate } 22287c478bd9Sstevel@tonic-gate (void) strlcpy(rctlvaltab->zone_rctlval_priv, 22297c478bd9Sstevel@tonic-gate cx->cp_value, 22307c478bd9Sstevel@tonic-gate sizeof (rctlvaltab->zone_rctlval_priv)); 2231bbec428eSgjelinek seen_priv = B_TRUE; 22327c478bd9Sstevel@tonic-gate break; 22337c478bd9Sstevel@tonic-gate case PT_LIMIT: 22347c478bd9Sstevel@tonic-gate if (seen_limit) { 22357c478bd9Sstevel@tonic-gate zerr(gettext("%s already specified"), 22367c478bd9Sstevel@tonic-gate pt_to_str(PT_LIMIT)); 22377c478bd9Sstevel@tonic-gate goto bad; 22387c478bd9Sstevel@tonic-gate } 22397c478bd9Sstevel@tonic-gate (void) strlcpy(rctlvaltab->zone_rctlval_limit, 22407c478bd9Sstevel@tonic-gate cx->cp_value, 22417c478bd9Sstevel@tonic-gate sizeof (rctlvaltab->zone_rctlval_limit)); 2242bbec428eSgjelinek seen_limit = B_TRUE; 22437c478bd9Sstevel@tonic-gate break; 22447c478bd9Sstevel@tonic-gate case PT_ACTION: 22457c478bd9Sstevel@tonic-gate if (seen_action) { 22467c478bd9Sstevel@tonic-gate zerr(gettext("%s already specified"), 22477c478bd9Sstevel@tonic-gate pt_to_str(PT_ACTION)); 22487c478bd9Sstevel@tonic-gate goto bad; 22497c478bd9Sstevel@tonic-gate } 22507c478bd9Sstevel@tonic-gate (void) strlcpy(rctlvaltab->zone_rctlval_action, 22517c478bd9Sstevel@tonic-gate cx->cp_value, 22527c478bd9Sstevel@tonic-gate sizeof (rctlvaltab->zone_rctlval_action)); 2253bbec428eSgjelinek seen_action = B_TRUE; 22547c478bd9Sstevel@tonic-gate break; 22557c478bd9Sstevel@tonic-gate default: 22567c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(PT_VALUE), 2257bbec428eSgjelinek Z_NO_PROPERTY_TYPE, B_TRUE); 2258bbec428eSgjelinek long_usage(CMD_ADD, B_TRUE); 2259bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 22607c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctlvaltab); 22617c478bd9Sstevel@tonic-gate return; 22627c478bd9Sstevel@tonic-gate } 22637c478bd9Sstevel@tonic-gate } 22647c478bd9Sstevel@tonic-gate if (!seen_priv) 22657c478bd9Sstevel@tonic-gate zerr(gettext("%s not specified"), pt_to_str(PT_PRIV)); 22667c478bd9Sstevel@tonic-gate if (!seen_limit) 22677c478bd9Sstevel@tonic-gate zerr(gettext("%s not specified"), pt_to_str(PT_LIMIT)); 22687c478bd9Sstevel@tonic-gate if (!seen_action) 22697c478bd9Sstevel@tonic-gate zerr(gettext("%s not specified"), pt_to_str(PT_ACTION)); 22707c478bd9Sstevel@tonic-gate if (!seen_priv || !seen_limit || !seen_action) 22717c478bd9Sstevel@tonic-gate goto bad; 22727c478bd9Sstevel@tonic-gate rctlvaltab->zone_rctlval_next = NULL; 22737c478bd9Sstevel@tonic-gate rctlblk = alloca(rctlblk_size()); 22747c478bd9Sstevel@tonic-gate /* 22757c478bd9Sstevel@tonic-gate * Make sure the rctl value looks roughly correct; we won't know if 22767c478bd9Sstevel@tonic-gate * it's truly OK until we verify the configuration on the target 22777c478bd9Sstevel@tonic-gate * system. 22787c478bd9Sstevel@tonic-gate */ 22797c478bd9Sstevel@tonic-gate if (zonecfg_construct_rctlblk(rctlvaltab, rctlblk) != Z_OK || 22807c478bd9Sstevel@tonic-gate !zonecfg_valid_rctlblk(rctlblk)) { 22817c478bd9Sstevel@tonic-gate zerr(gettext("Invalid %s %s specification"), rt_to_str(RT_RCTL), 22827c478bd9Sstevel@tonic-gate pt_to_str(PT_VALUE)); 22837c478bd9Sstevel@tonic-gate goto bad; 22847c478bd9Sstevel@tonic-gate } 22857c478bd9Sstevel@tonic-gate err = zonecfg_add_rctl_value(&in_progress_rctltab, rctlvaltab); 22867c478bd9Sstevel@tonic-gate if (err != Z_OK) 2287bbec428eSgjelinek zone_perror(pt_to_str(PT_VALUE), err, B_TRUE); 22887c478bd9Sstevel@tonic-gate return; 22897c478bd9Sstevel@tonic-gate 22907c478bd9Sstevel@tonic-gate bad: 22917c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctlvaltab); 22927c478bd9Sstevel@tonic-gate } 22937c478bd9Sstevel@tonic-gate 22947c478bd9Sstevel@tonic-gate static void 22957c478bd9Sstevel@tonic-gate add_property(cmd_t *cmd) 22967c478bd9Sstevel@tonic-gate { 22977c478bd9Sstevel@tonic-gate char *prop_id; 22987c478bd9Sstevel@tonic-gate int err, res_type, prop_type; 22997c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 23007c478bd9Sstevel@tonic-gate list_property_ptr_t l; 23017c478bd9Sstevel@tonic-gate 23027c478bd9Sstevel@tonic-gate res_type = resource_scope; 23037c478bd9Sstevel@tonic-gate prop_type = cmd->cmd_prop_name[0]; 23047c478bd9Sstevel@tonic-gate if (res_type == RT_UNKNOWN || prop_type == PT_UNKNOWN) { 2305bbec428eSgjelinek long_usage(CMD_ADD, B_TRUE); 23067c478bd9Sstevel@tonic-gate return; 23077c478bd9Sstevel@tonic-gate } 23087c478bd9Sstevel@tonic-gate 23097c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs != 1) { 2310bbec428eSgjelinek long_usage(CMD_ADD, B_TRUE); 23117c478bd9Sstevel@tonic-gate return; 23127c478bd9Sstevel@tonic-gate } 23137c478bd9Sstevel@tonic-gate 2314bbec428eSgjelinek if (initialize(B_TRUE) != Z_OK) 23157c478bd9Sstevel@tonic-gate return; 23167c478bd9Sstevel@tonic-gate 23177c478bd9Sstevel@tonic-gate switch (res_type) { 23187c478bd9Sstevel@tonic-gate case RT_FS: 23197c478bd9Sstevel@tonic-gate if (prop_type != PT_OPTIONS) { 23207c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 2321bbec428eSgjelinek B_TRUE); 2322bbec428eSgjelinek long_usage(CMD_ADD, B_TRUE); 2323bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 23247c478bd9Sstevel@tonic-gate return; 23257c478bd9Sstevel@tonic-gate } 23267c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[0]; 23277c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE && 23287c478bd9Sstevel@tonic-gate pp->pv_type != PROP_VAL_LIST) { 23297c478bd9Sstevel@tonic-gate zerr(gettext("A %s or %s value was expected here."), 23307c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_SIMPLE), 23317c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_LIST)); 2332bbec428eSgjelinek saw_error = B_TRUE; 23337c478bd9Sstevel@tonic-gate return; 23347c478bd9Sstevel@tonic-gate } 23357c478bd9Sstevel@tonic-gate if (pp->pv_type == PROP_VAL_SIMPLE) { 23367c478bd9Sstevel@tonic-gate if (pp->pv_simple == NULL) { 2337bbec428eSgjelinek long_usage(CMD_ADD, B_TRUE); 23387c478bd9Sstevel@tonic-gate return; 23397c478bd9Sstevel@tonic-gate } 23407c478bd9Sstevel@tonic-gate prop_id = pp->pv_simple; 23417c478bd9Sstevel@tonic-gate err = zonecfg_add_fs_option(&in_progress_fstab, 23427c478bd9Sstevel@tonic-gate prop_id); 23437c478bd9Sstevel@tonic-gate if (err != Z_OK) 2344bbec428eSgjelinek zone_perror(pt_to_str(prop_type), err, B_TRUE); 23457c478bd9Sstevel@tonic-gate } else { 23467c478bd9Sstevel@tonic-gate list_property_ptr_t list; 23477c478bd9Sstevel@tonic-gate 23487c478bd9Sstevel@tonic-gate for (list = pp->pv_list; list != NULL; 23497c478bd9Sstevel@tonic-gate list = list->lp_next) { 23507c478bd9Sstevel@tonic-gate prop_id = list->lp_simple; 23517c478bd9Sstevel@tonic-gate if (prop_id == NULL) 23527c478bd9Sstevel@tonic-gate break; 23537c478bd9Sstevel@tonic-gate err = zonecfg_add_fs_option( 23547c478bd9Sstevel@tonic-gate &in_progress_fstab, prop_id); 23557c478bd9Sstevel@tonic-gate if (err != Z_OK) 23567c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), err, 2357bbec428eSgjelinek B_TRUE); 23587c478bd9Sstevel@tonic-gate } 23597c478bd9Sstevel@tonic-gate } 23607c478bd9Sstevel@tonic-gate return; 23617c478bd9Sstevel@tonic-gate case RT_RCTL: 23627c478bd9Sstevel@tonic-gate if (prop_type != PT_VALUE) { 23637c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 2364bbec428eSgjelinek B_TRUE); 2365bbec428eSgjelinek long_usage(CMD_ADD, B_TRUE); 2366bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 23677c478bd9Sstevel@tonic-gate return; 23687c478bd9Sstevel@tonic-gate } 23697c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[0]; 23707c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_COMPLEX && 23717c478bd9Sstevel@tonic-gate pp->pv_type != PROP_VAL_LIST) { 23727c478bd9Sstevel@tonic-gate zerr(gettext("A %s or %s value was expected here."), 23737c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_COMPLEX), 23747c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_LIST)); 2375bbec428eSgjelinek saw_error = B_TRUE; 23767c478bd9Sstevel@tonic-gate return; 23777c478bd9Sstevel@tonic-gate } 23787c478bd9Sstevel@tonic-gate if (pp->pv_type == PROP_VAL_COMPLEX) { 23797c478bd9Sstevel@tonic-gate do_complex_rctl_val(pp->pv_complex); 23807c478bd9Sstevel@tonic-gate return; 23817c478bd9Sstevel@tonic-gate } 23827c478bd9Sstevel@tonic-gate for (l = pp->pv_list; l != NULL; l = l->lp_next) 23837c478bd9Sstevel@tonic-gate do_complex_rctl_val(l->lp_complex); 23847c478bd9Sstevel@tonic-gate return; 23857c478bd9Sstevel@tonic-gate default: 2386bbec428eSgjelinek zone_perror(rt_to_str(res_type), Z_NO_RESOURCE_TYPE, B_TRUE); 2387bbec428eSgjelinek long_usage(CMD_ADD, B_TRUE); 2388bbec428eSgjelinek usage(B_FALSE, HELP_RESOURCES); 23897c478bd9Sstevel@tonic-gate return; 23907c478bd9Sstevel@tonic-gate } 23917c478bd9Sstevel@tonic-gate } 23927c478bd9Sstevel@tonic-gate 23930209230bSgjelinek static boolean_t 23940209230bSgjelinek gz_invalid_resource(int type) 23950209230bSgjelinek { 23960209230bSgjelinek return (global_zone && (type == RT_FS || type == RT_IPD || 23970209230bSgjelinek type == RT_NET || type == RT_DEVICE || type == RT_ATTR || 23980209230bSgjelinek type == RT_DATASET)); 23990209230bSgjelinek } 24000209230bSgjelinek 24010209230bSgjelinek static boolean_t 24020209230bSgjelinek gz_invalid_rt_property(int type) 24030209230bSgjelinek { 24040209230bSgjelinek return (global_zone && (type == RT_ZONENAME || type == RT_ZONEPATH || 24050209230bSgjelinek type == RT_AUTOBOOT || type == RT_LIMITPRIV || 2406f4b3ec61Sdh type == RT_BOOTARGS || type == RT_BRAND || type == RT_SCHED || 24070fbb751dSJohn Levon type == RT_IPTYPE || type == RT_HOSTID || type == RT_FS_ALLOWED)); 24080209230bSgjelinek } 24090209230bSgjelinek 24100209230bSgjelinek static boolean_t 24110209230bSgjelinek gz_invalid_property(int type) 24120209230bSgjelinek { 24130209230bSgjelinek return (global_zone && (type == PT_ZONENAME || type == PT_ZONEPATH || 24140209230bSgjelinek type == PT_AUTOBOOT || type == PT_LIMITPRIV || 2415f4b3ec61Sdh type == PT_BOOTARGS || type == PT_BRAND || type == PT_SCHED || 24160fbb751dSJohn Levon type == PT_IPTYPE || type == PT_HOSTID || type == PT_FS_ALLOWED)); 24170209230bSgjelinek } 24180209230bSgjelinek 24197c478bd9Sstevel@tonic-gate void 24207c478bd9Sstevel@tonic-gate add_func(cmd_t *cmd) 24217c478bd9Sstevel@tonic-gate { 24227c478bd9Sstevel@tonic-gate int arg; 2423bbec428eSgjelinek boolean_t arg_err = B_FALSE; 24247c478bd9Sstevel@tonic-gate 24257c478bd9Sstevel@tonic-gate assert(cmd != NULL); 24267c478bd9Sstevel@tonic-gate 24277c478bd9Sstevel@tonic-gate optind = 0; 24287ec75eb8Sgjelinek while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?")) != EOF) { 24297c478bd9Sstevel@tonic-gate switch (arg) { 24307c478bd9Sstevel@tonic-gate case '?': 24317c478bd9Sstevel@tonic-gate longer_usage(CMD_ADD); 2432bbec428eSgjelinek arg_err = B_TRUE; 24337ec75eb8Sgjelinek break; 24347c478bd9Sstevel@tonic-gate default: 24357c478bd9Sstevel@tonic-gate short_usage(CMD_ADD); 2436bbec428eSgjelinek arg_err = B_TRUE; 24377ec75eb8Sgjelinek break; 24387c478bd9Sstevel@tonic-gate } 24397c478bd9Sstevel@tonic-gate } 24407ec75eb8Sgjelinek if (arg_err) 24417ec75eb8Sgjelinek return; 24427ec75eb8Sgjelinek 24437c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 24447c478bd9Sstevel@tonic-gate short_usage(CMD_ADD); 24457c478bd9Sstevel@tonic-gate return; 24467c478bd9Sstevel@tonic-gate } 24477c478bd9Sstevel@tonic-gate 24487c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_ADD)) 24497c478bd9Sstevel@tonic-gate return; 24507c478bd9Sstevel@tonic-gate 2451bbec428eSgjelinek if (initialize(B_TRUE) != Z_OK) 24527c478bd9Sstevel@tonic-gate return; 24537c478bd9Sstevel@tonic-gate if (global_scope) { 24540209230bSgjelinek if (gz_invalid_resource(cmd->cmd_res_type)) { 24550209230bSgjelinek zerr(gettext("Cannot add a %s resource to the " 24560209230bSgjelinek "global zone."), rt_to_str(cmd->cmd_res_type)); 2457bbec428eSgjelinek saw_error = B_TRUE; 24580209230bSgjelinek return; 24590209230bSgjelinek } 24600209230bSgjelinek 2461bbec428eSgjelinek global_scope = B_FALSE; 24627c478bd9Sstevel@tonic-gate resource_scope = cmd->cmd_res_type; 24637c478bd9Sstevel@tonic-gate end_op = CMD_ADD; 24647c478bd9Sstevel@tonic-gate add_resource(cmd); 24657c478bd9Sstevel@tonic-gate } else 24667c478bd9Sstevel@tonic-gate add_property(cmd); 24677c478bd9Sstevel@tonic-gate } 24687c478bd9Sstevel@tonic-gate 2469087719fdSdp /* 2470087719fdSdp * This routine has an unusual implementation, because it tries very 2471087719fdSdp * hard to succeed in the face of a variety of failure modes. 2472087719fdSdp * The most common and most vexing occurs when the index file and 2473087719fdSdp * the /etc/zones/<zonename.xml> file are not both present. In 2474087719fdSdp * this case, delete must eradicate as much of the zone state as is left 2475087719fdSdp * so that the user can later create a new zone with the same name. 2476087719fdSdp */ 24777c478bd9Sstevel@tonic-gate void 24787c478bd9Sstevel@tonic-gate delete_func(cmd_t *cmd) 24797c478bd9Sstevel@tonic-gate { 24807c478bd9Sstevel@tonic-gate int err, arg, answer; 24817c478bd9Sstevel@tonic-gate char line[ZONENAME_MAX + 128]; /* enough to ask a question */ 2482bbec428eSgjelinek boolean_t force = B_FALSE; 2483bbec428eSgjelinek boolean_t arg_err = B_FALSE; 24847c478bd9Sstevel@tonic-gate 24857c478bd9Sstevel@tonic-gate optind = 0; 24867c478bd9Sstevel@tonic-gate while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?F")) != EOF) { 24877c478bd9Sstevel@tonic-gate switch (arg) { 24887c478bd9Sstevel@tonic-gate case '?': 24897c478bd9Sstevel@tonic-gate longer_usage(CMD_DELETE); 2490bbec428eSgjelinek arg_err = B_TRUE; 24917ec75eb8Sgjelinek break; 24927c478bd9Sstevel@tonic-gate case 'F': 2493bbec428eSgjelinek force = B_TRUE; 24947c478bd9Sstevel@tonic-gate break; 24957c478bd9Sstevel@tonic-gate default: 24967c478bd9Sstevel@tonic-gate short_usage(CMD_DELETE); 2497bbec428eSgjelinek arg_err = B_TRUE; 24987ec75eb8Sgjelinek break; 24997c478bd9Sstevel@tonic-gate } 25007c478bd9Sstevel@tonic-gate } 25017ec75eb8Sgjelinek if (arg_err) 25027ec75eb8Sgjelinek return; 25037ec75eb8Sgjelinek 25047c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 25057c478bd9Sstevel@tonic-gate short_usage(CMD_DELETE); 25067c478bd9Sstevel@tonic-gate return; 25077c478bd9Sstevel@tonic-gate } 25087c478bd9Sstevel@tonic-gate 25097c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_DELETE)) 25107c478bd9Sstevel@tonic-gate return; 25117c478bd9Sstevel@tonic-gate 25127c478bd9Sstevel@tonic-gate if (!force) { 2513087719fdSdp /* 2514087719fdSdp * Initialize sets up the global called "handle" and warns the 2515087719fdSdp * user if the zone is not configured. In force mode, we don't 2516087719fdSdp * trust that evaluation, and hence skip it. (We don't need the 2517087719fdSdp * handle to be loaded anyway, since zonecfg_destroy is done by 2518cb8a054bSGlenn Faden * zonename). However, we also have to take care to emulate the 2519087719fdSdp * messages spit out by initialize; see below. 2520087719fdSdp */ 2521bbec428eSgjelinek if (initialize(B_TRUE) != Z_OK) 2522087719fdSdp return; 2523087719fdSdp 25247c478bd9Sstevel@tonic-gate (void) snprintf(line, sizeof (line), 25257c478bd9Sstevel@tonic-gate gettext("Are you sure you want to delete zone %s"), zone); 2526bbec428eSgjelinek if ((answer = ask_yesno(B_FALSE, line)) == -1) { 2527087719fdSdp zerr(gettext("Input not from terminal and -F not " 2528087719fdSdp "specified:\n%s command ignored, exiting."), 2529087719fdSdp cmd_to_str(CMD_DELETE)); 25307c478bd9Sstevel@tonic-gate exit(Z_ERR); 25317c478bd9Sstevel@tonic-gate } 25327c478bd9Sstevel@tonic-gate if (answer != 1) 25337c478bd9Sstevel@tonic-gate return; 25347c478bd9Sstevel@tonic-gate } 25357c478bd9Sstevel@tonic-gate 2536cb8a054bSGlenn Faden /* 2537cb8a054bSGlenn Faden * This function removes the authorizations from user_attr 2538cb8a054bSGlenn Faden * that correspond to those specified in the configuration 2539cb8a054bSGlenn Faden */ 2540cb8a054bSGlenn Faden if (initialize(B_TRUE) == Z_OK) { 2541cb8a054bSGlenn Faden (void) zonecfg_deauthorize_users(handle, zone); 2542cb8a054bSGlenn Faden } 2543087719fdSdp if ((err = zonecfg_destroy(zone, force)) != Z_OK) { 2544087719fdSdp if ((err == Z_BAD_ZONE_STATE) && !force) { 2545087719fdSdp zerr(gettext("Zone %s not in %s state; %s not " 2546087719fdSdp "allowed. Use -F to force %s."), 2547087719fdSdp zone, zone_state_str(ZONE_STATE_CONFIGURED), 2548087719fdSdp cmd_to_str(CMD_DELETE), cmd_to_str(CMD_DELETE)); 2549087719fdSdp } else { 2550bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 2551087719fdSdp } 25527c478bd9Sstevel@tonic-gate } 2553bbec428eSgjelinek need_to_commit = B_FALSE; 2554087719fdSdp 2555087719fdSdp /* 2556087719fdSdp * Emulate initialize's messaging; if there wasn't a valid handle to 2557087719fdSdp * begin with, then user had typed delete (or delete -F) multiple 2558087719fdSdp * times. So we emit a message. 2559087719fdSdp * 2560087719fdSdp * We only do this in the 'force' case because normally, initialize() 2561087719fdSdp * takes care of this for us. 2562087719fdSdp */ 2563087719fdSdp if (force && zonecfg_check_handle(handle) != Z_OK && interactive_mode) 2564087719fdSdp (void) printf(gettext("Use '%s' to begin " 2565087719fdSdp "configuring a new zone.\n"), cmd_to_str(CMD_CREATE)); 25667c478bd9Sstevel@tonic-gate 25677c478bd9Sstevel@tonic-gate /* 25687c478bd9Sstevel@tonic-gate * Time for a new handle: finish the old one off first 25697c478bd9Sstevel@tonic-gate * then get a new one properly to avoid leaks. 25707c478bd9Sstevel@tonic-gate */ 2571087719fdSdp if (got_handle) { 2572087719fdSdp zonecfg_fini_handle(handle); 2573087719fdSdp if ((handle = zonecfg_init_handle()) == NULL) { 2574bbec428eSgjelinek zone_perror(execname, Z_NOMEM, B_TRUE); 2575087719fdSdp exit(Z_ERR); 2576087719fdSdp } 2577087719fdSdp if ((err = zonecfg_get_handle(zone, handle)) != Z_OK) { 2578087719fdSdp /* If there was no zone before, that's OK */ 2579087719fdSdp if (err != Z_NO_ZONE) 2580bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 2581bbec428eSgjelinek got_handle = B_FALSE; 2582087719fdSdp } 25837c478bd9Sstevel@tonic-gate } 25847c478bd9Sstevel@tonic-gate } 25857c478bd9Sstevel@tonic-gate 25867c478bd9Sstevel@tonic-gate static int 2587bbec428eSgjelinek fill_in_fstab(cmd_t *cmd, struct zone_fstab *fstab, boolean_t fill_in_only) 25887c478bd9Sstevel@tonic-gate { 25897c478bd9Sstevel@tonic-gate int err, i; 25907c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 25917c478bd9Sstevel@tonic-gate 2592bbec428eSgjelinek if ((err = initialize(B_TRUE)) != Z_OK) 25937c478bd9Sstevel@tonic-gate return (err); 25947c478bd9Sstevel@tonic-gate 2595e193d1e6Svp bzero(fstab, sizeof (*fstab)); 25967c478bd9Sstevel@tonic-gate for (i = 0; i < cmd->cmd_prop_nv_pairs; i++) { 25977c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[i]; 25987c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE || pp->pv_simple == NULL) { 25997c478bd9Sstevel@tonic-gate zerr(gettext("A simple value was expected here.")); 2600bbec428eSgjelinek saw_error = B_TRUE; 26017c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 26027c478bd9Sstevel@tonic-gate } 26037c478bd9Sstevel@tonic-gate switch (cmd->cmd_prop_name[i]) { 26047c478bd9Sstevel@tonic-gate case PT_DIR: 26057c478bd9Sstevel@tonic-gate (void) strlcpy(fstab->zone_fs_dir, pp->pv_simple, 26067c478bd9Sstevel@tonic-gate sizeof (fstab->zone_fs_dir)); 26077c478bd9Sstevel@tonic-gate break; 26087c478bd9Sstevel@tonic-gate case PT_SPECIAL: 26097c478bd9Sstevel@tonic-gate (void) strlcpy(fstab->zone_fs_special, pp->pv_simple, 26107c478bd9Sstevel@tonic-gate sizeof (fstab->zone_fs_special)); 26117c478bd9Sstevel@tonic-gate break; 26127c478bd9Sstevel@tonic-gate case PT_RAW: 26137c478bd9Sstevel@tonic-gate (void) strlcpy(fstab->zone_fs_raw, pp->pv_simple, 26147c478bd9Sstevel@tonic-gate sizeof (fstab->zone_fs_raw)); 26157c478bd9Sstevel@tonic-gate break; 26167c478bd9Sstevel@tonic-gate case PT_TYPE: 26177c478bd9Sstevel@tonic-gate (void) strlcpy(fstab->zone_fs_type, pp->pv_simple, 26187c478bd9Sstevel@tonic-gate sizeof (fstab->zone_fs_type)); 26197c478bd9Sstevel@tonic-gate break; 26207c478bd9Sstevel@tonic-gate default: 26217c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(cmd->cmd_prop_name[i]), 2622bbec428eSgjelinek Z_NO_PROPERTY_TYPE, B_TRUE); 26237c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 26247c478bd9Sstevel@tonic-gate } 26257c478bd9Sstevel@tonic-gate } 26267c478bd9Sstevel@tonic-gate if (fill_in_only) 26277c478bd9Sstevel@tonic-gate return (Z_OK); 26287c478bd9Sstevel@tonic-gate return (zonecfg_lookup_filesystem(handle, fstab)); 26297c478bd9Sstevel@tonic-gate } 26307c478bd9Sstevel@tonic-gate 26317c478bd9Sstevel@tonic-gate static int 2632bbec428eSgjelinek fill_in_ipdtab(cmd_t *cmd, struct zone_fstab *ipdtab, boolean_t fill_in_only) 26337c478bd9Sstevel@tonic-gate { 26347c478bd9Sstevel@tonic-gate int err, i; 26357c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 26367c478bd9Sstevel@tonic-gate 2637bbec428eSgjelinek if ((err = initialize(B_TRUE)) != Z_OK) 26387c478bd9Sstevel@tonic-gate return (err); 26397c478bd9Sstevel@tonic-gate 2640e193d1e6Svp bzero(ipdtab, sizeof (*ipdtab)); 26417c478bd9Sstevel@tonic-gate for (i = 0; i < cmd->cmd_prop_nv_pairs; i++) { 26427c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[i]; 26437c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE || pp->pv_simple == NULL) { 26447c478bd9Sstevel@tonic-gate zerr(gettext("A simple value was expected here.")); 2645bbec428eSgjelinek saw_error = B_TRUE; 26467c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 26477c478bd9Sstevel@tonic-gate } 26487c478bd9Sstevel@tonic-gate switch (cmd->cmd_prop_name[i]) { 26497c478bd9Sstevel@tonic-gate case PT_DIR: 26507c478bd9Sstevel@tonic-gate (void) strlcpy(ipdtab->zone_fs_dir, pp->pv_simple, 26517c478bd9Sstevel@tonic-gate sizeof (ipdtab->zone_fs_dir)); 26527c478bd9Sstevel@tonic-gate break; 26537c478bd9Sstevel@tonic-gate default: 26547c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(cmd->cmd_prop_name[i]), 2655bbec428eSgjelinek Z_NO_PROPERTY_TYPE, B_TRUE); 26567c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 26577c478bd9Sstevel@tonic-gate } 26587c478bd9Sstevel@tonic-gate } 26597c478bd9Sstevel@tonic-gate if (fill_in_only) 26607c478bd9Sstevel@tonic-gate return (Z_OK); 26617c478bd9Sstevel@tonic-gate return (zonecfg_lookup_ipd(handle, ipdtab)); 26627c478bd9Sstevel@tonic-gate } 26637c478bd9Sstevel@tonic-gate 26647c478bd9Sstevel@tonic-gate static int 2665bbec428eSgjelinek fill_in_nwiftab(cmd_t *cmd, struct zone_nwiftab *nwiftab, 2666bbec428eSgjelinek boolean_t fill_in_only) 26677c478bd9Sstevel@tonic-gate { 26687c478bd9Sstevel@tonic-gate int err, i; 26697c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 26707c478bd9Sstevel@tonic-gate 2671bbec428eSgjelinek if ((err = initialize(B_TRUE)) != Z_OK) 26727c478bd9Sstevel@tonic-gate return (err); 26737c478bd9Sstevel@tonic-gate 2674e193d1e6Svp bzero(nwiftab, sizeof (*nwiftab)); 26757c478bd9Sstevel@tonic-gate for (i = 0; i < cmd->cmd_prop_nv_pairs; i++) { 26767c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[i]; 26777c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE || pp->pv_simple == NULL) { 26787c478bd9Sstevel@tonic-gate zerr(gettext("A simple value was expected here.")); 2679bbec428eSgjelinek saw_error = B_TRUE; 26807c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 26817c478bd9Sstevel@tonic-gate } 26827c478bd9Sstevel@tonic-gate switch (cmd->cmd_prop_name[i]) { 26837c478bd9Sstevel@tonic-gate case PT_ADDRESS: 26847c478bd9Sstevel@tonic-gate (void) strlcpy(nwiftab->zone_nwif_address, 26857c478bd9Sstevel@tonic-gate pp->pv_simple, sizeof (nwiftab->zone_nwif_address)); 26867c478bd9Sstevel@tonic-gate break; 26877c478bd9Sstevel@tonic-gate case PT_PHYSICAL: 26887c478bd9Sstevel@tonic-gate (void) strlcpy(nwiftab->zone_nwif_physical, 26897c478bd9Sstevel@tonic-gate pp->pv_simple, 26907c478bd9Sstevel@tonic-gate sizeof (nwiftab->zone_nwif_physical)); 26917c478bd9Sstevel@tonic-gate break; 2692de860bd9Sgfaden case PT_DEFROUTER: 2693de860bd9Sgfaden (void) strlcpy(nwiftab->zone_nwif_defrouter, 2694de860bd9Sgfaden pp->pv_simple, 2695de860bd9Sgfaden sizeof (nwiftab->zone_nwif_defrouter)); 2696de860bd9Sgfaden break; 26977c478bd9Sstevel@tonic-gate default: 26987c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(cmd->cmd_prop_name[i]), 2699bbec428eSgjelinek Z_NO_PROPERTY_TYPE, B_TRUE); 27007c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 27017c478bd9Sstevel@tonic-gate } 27027c478bd9Sstevel@tonic-gate } 27037c478bd9Sstevel@tonic-gate if (fill_in_only) 27047c478bd9Sstevel@tonic-gate return (Z_OK); 27057c478bd9Sstevel@tonic-gate err = zonecfg_lookup_nwif(handle, nwiftab); 27067c478bd9Sstevel@tonic-gate return (err); 27077c478bd9Sstevel@tonic-gate } 27087c478bd9Sstevel@tonic-gate 27097c478bd9Sstevel@tonic-gate static int 2710bbec428eSgjelinek fill_in_devtab(cmd_t *cmd, struct zone_devtab *devtab, boolean_t fill_in_only) 27117c478bd9Sstevel@tonic-gate { 27127c478bd9Sstevel@tonic-gate int err, i; 27137c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 27147c478bd9Sstevel@tonic-gate 2715bbec428eSgjelinek if ((err = initialize(B_TRUE)) != Z_OK) 27167c478bd9Sstevel@tonic-gate return (err); 27177c478bd9Sstevel@tonic-gate 2718e193d1e6Svp bzero(devtab, sizeof (*devtab)); 27197c478bd9Sstevel@tonic-gate for (i = 0; i < cmd->cmd_prop_nv_pairs; i++) { 27207c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[i]; 27217c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE || pp->pv_simple == NULL) { 27227c478bd9Sstevel@tonic-gate zerr(gettext("A simple value was expected here.")); 2723bbec428eSgjelinek saw_error = B_TRUE; 27247c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 27257c478bd9Sstevel@tonic-gate } 27267c478bd9Sstevel@tonic-gate switch (cmd->cmd_prop_name[i]) { 27277c478bd9Sstevel@tonic-gate case PT_MATCH: 27287c478bd9Sstevel@tonic-gate (void) strlcpy(devtab->zone_dev_match, pp->pv_simple, 27297c478bd9Sstevel@tonic-gate sizeof (devtab->zone_dev_match)); 27307c478bd9Sstevel@tonic-gate break; 27317c478bd9Sstevel@tonic-gate default: 27327c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(cmd->cmd_prop_name[i]), 2733bbec428eSgjelinek Z_NO_PROPERTY_TYPE, B_TRUE); 27347c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 27357c478bd9Sstevel@tonic-gate } 27367c478bd9Sstevel@tonic-gate } 27377c478bd9Sstevel@tonic-gate if (fill_in_only) 27387c478bd9Sstevel@tonic-gate return (Z_OK); 27397c478bd9Sstevel@tonic-gate err = zonecfg_lookup_dev(handle, devtab); 27407c478bd9Sstevel@tonic-gate return (err); 27417c478bd9Sstevel@tonic-gate } 27427c478bd9Sstevel@tonic-gate 27437c478bd9Sstevel@tonic-gate static int 2744bbec428eSgjelinek fill_in_rctltab(cmd_t *cmd, struct zone_rctltab *rctltab, 2745bbec428eSgjelinek boolean_t fill_in_only) 27467c478bd9Sstevel@tonic-gate { 27477c478bd9Sstevel@tonic-gate int err, i; 27487c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 27497c478bd9Sstevel@tonic-gate 2750bbec428eSgjelinek if ((err = initialize(B_TRUE)) != Z_OK) 27517c478bd9Sstevel@tonic-gate return (err); 27527c478bd9Sstevel@tonic-gate 2753e193d1e6Svp bzero(rctltab, sizeof (*rctltab)); 27547c478bd9Sstevel@tonic-gate for (i = 0; i < cmd->cmd_prop_nv_pairs; i++) { 27557c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[i]; 27567c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE || pp->pv_simple == NULL) { 27577c478bd9Sstevel@tonic-gate zerr(gettext("A simple value was expected here.")); 2758bbec428eSgjelinek saw_error = B_TRUE; 27597c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 27607c478bd9Sstevel@tonic-gate } 27617c478bd9Sstevel@tonic-gate switch (cmd->cmd_prop_name[i]) { 27627c478bd9Sstevel@tonic-gate case PT_NAME: 27637c478bd9Sstevel@tonic-gate (void) strlcpy(rctltab->zone_rctl_name, pp->pv_simple, 27647c478bd9Sstevel@tonic-gate sizeof (rctltab->zone_rctl_name)); 27657c478bd9Sstevel@tonic-gate break; 27667c478bd9Sstevel@tonic-gate default: 27677c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(cmd->cmd_prop_name[i]), 2768bbec428eSgjelinek Z_NO_PROPERTY_TYPE, B_TRUE); 27697c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 27707c478bd9Sstevel@tonic-gate } 27717c478bd9Sstevel@tonic-gate } 27727c478bd9Sstevel@tonic-gate if (fill_in_only) 27737c478bd9Sstevel@tonic-gate return (Z_OK); 27747c478bd9Sstevel@tonic-gate err = zonecfg_lookup_rctl(handle, rctltab); 27757c478bd9Sstevel@tonic-gate return (err); 27767c478bd9Sstevel@tonic-gate } 27777c478bd9Sstevel@tonic-gate 27787c478bd9Sstevel@tonic-gate static int 2779bbec428eSgjelinek fill_in_attrtab(cmd_t *cmd, struct zone_attrtab *attrtab, 2780bbec428eSgjelinek boolean_t fill_in_only) 27817c478bd9Sstevel@tonic-gate { 27827c478bd9Sstevel@tonic-gate int err, i; 27837c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 27847c478bd9Sstevel@tonic-gate 2785bbec428eSgjelinek if ((err = initialize(B_TRUE)) != Z_OK) 27867c478bd9Sstevel@tonic-gate return (err); 27877c478bd9Sstevel@tonic-gate 2788e193d1e6Svp bzero(attrtab, sizeof (*attrtab)); 27897c478bd9Sstevel@tonic-gate for (i = 0; i < cmd->cmd_prop_nv_pairs; i++) { 27907c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[i]; 27917c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE || pp->pv_simple == NULL) { 27927c478bd9Sstevel@tonic-gate zerr(gettext("A simple value was expected here.")); 2793bbec428eSgjelinek saw_error = B_TRUE; 27947c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 27957c478bd9Sstevel@tonic-gate } 27967c478bd9Sstevel@tonic-gate switch (cmd->cmd_prop_name[i]) { 27977c478bd9Sstevel@tonic-gate case PT_NAME: 27987c478bd9Sstevel@tonic-gate (void) strlcpy(attrtab->zone_attr_name, pp->pv_simple, 27997c478bd9Sstevel@tonic-gate sizeof (attrtab->zone_attr_name)); 28007c478bd9Sstevel@tonic-gate break; 28017c478bd9Sstevel@tonic-gate case PT_TYPE: 28027c478bd9Sstevel@tonic-gate (void) strlcpy(attrtab->zone_attr_type, pp->pv_simple, 28037c478bd9Sstevel@tonic-gate sizeof (attrtab->zone_attr_type)); 28047c478bd9Sstevel@tonic-gate break; 28057c478bd9Sstevel@tonic-gate case PT_VALUE: 28067c478bd9Sstevel@tonic-gate (void) strlcpy(attrtab->zone_attr_value, pp->pv_simple, 28077c478bd9Sstevel@tonic-gate sizeof (attrtab->zone_attr_value)); 28087c478bd9Sstevel@tonic-gate break; 28097c478bd9Sstevel@tonic-gate default: 28107c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(cmd->cmd_prop_name[i]), 2811bbec428eSgjelinek Z_NO_PROPERTY_TYPE, B_TRUE); 28127c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 28137c478bd9Sstevel@tonic-gate } 28147c478bd9Sstevel@tonic-gate } 28157c478bd9Sstevel@tonic-gate if (fill_in_only) 28167c478bd9Sstevel@tonic-gate return (Z_OK); 28177c478bd9Sstevel@tonic-gate err = zonecfg_lookup_attr(handle, attrtab); 28187c478bd9Sstevel@tonic-gate return (err); 28197c478bd9Sstevel@tonic-gate } 28207c478bd9Sstevel@tonic-gate 2821fa9e4066Sahrens static int 2822bbec428eSgjelinek fill_in_dstab(cmd_t *cmd, struct zone_dstab *dstab, boolean_t fill_in_only) 2823fa9e4066Sahrens { 2824fa9e4066Sahrens int err, i; 2825fa9e4066Sahrens property_value_ptr_t pp; 2826fa9e4066Sahrens 2827bbec428eSgjelinek if ((err = initialize(B_TRUE)) != Z_OK) 2828fa9e4066Sahrens return (err); 2829fa9e4066Sahrens 2830fa9e4066Sahrens dstab->zone_dataset_name[0] = '\0'; 2831fa9e4066Sahrens for (i = 0; i < cmd->cmd_prop_nv_pairs; i++) { 2832fa9e4066Sahrens pp = cmd->cmd_property_ptr[i]; 2833fa9e4066Sahrens if (pp->pv_type != PROP_VAL_SIMPLE || pp->pv_simple == NULL) { 2834fa9e4066Sahrens zerr(gettext("A simple value was expected here.")); 2835bbec428eSgjelinek saw_error = B_TRUE; 2836fa9e4066Sahrens return (Z_INSUFFICIENT_SPEC); 2837fa9e4066Sahrens } 2838fa9e4066Sahrens switch (cmd->cmd_prop_name[i]) { 2839fa9e4066Sahrens case PT_NAME: 2840fa9e4066Sahrens (void) strlcpy(dstab->zone_dataset_name, pp->pv_simple, 2841fa9e4066Sahrens sizeof (dstab->zone_dataset_name)); 2842fa9e4066Sahrens break; 2843fa9e4066Sahrens default: 2844fa9e4066Sahrens zone_perror(pt_to_str(cmd->cmd_prop_name[i]), 2845bbec428eSgjelinek Z_NO_PROPERTY_TYPE, B_TRUE); 2846fa9e4066Sahrens return (Z_INSUFFICIENT_SPEC); 2847fa9e4066Sahrens } 2848fa9e4066Sahrens } 2849fa9e4066Sahrens if (fill_in_only) 2850fa9e4066Sahrens return (Z_OK); 2851fa9e4066Sahrens return (zonecfg_lookup_ds(handle, dstab)); 2852fa9e4066Sahrens } 2853fa9e4066Sahrens 2854cb8a054bSGlenn Faden static int 2855cb8a054bSGlenn Faden fill_in_admintab(cmd_t *cmd, struct zone_admintab *admintab, 2856cb8a054bSGlenn Faden boolean_t fill_in_only) 2857cb8a054bSGlenn Faden { 2858cb8a054bSGlenn Faden int err, i; 2859cb8a054bSGlenn Faden property_value_ptr_t pp; 2860cb8a054bSGlenn Faden 2861cb8a054bSGlenn Faden if ((err = initialize(B_TRUE)) != Z_OK) 2862cb8a054bSGlenn Faden return (err); 2863cb8a054bSGlenn Faden 2864cb8a054bSGlenn Faden bzero(admintab, sizeof (*admintab)); 2865cb8a054bSGlenn Faden for (i = 0; i < cmd->cmd_prop_nv_pairs; i++) { 2866cb8a054bSGlenn Faden pp = cmd->cmd_property_ptr[i]; 2867cb8a054bSGlenn Faden if (pp->pv_type != PROP_VAL_SIMPLE || pp->pv_simple == NULL) { 2868cb8a054bSGlenn Faden zerr(gettext("A simple value was expected here.")); 2869cb8a054bSGlenn Faden saw_error = B_TRUE; 2870cb8a054bSGlenn Faden return (Z_INSUFFICIENT_SPEC); 2871cb8a054bSGlenn Faden } 2872cb8a054bSGlenn Faden switch (cmd->cmd_prop_name[i]) { 2873cb8a054bSGlenn Faden case PT_USER: 2874cb8a054bSGlenn Faden (void) strlcpy(admintab->zone_admin_user, pp->pv_simple, 2875cb8a054bSGlenn Faden sizeof (admintab->zone_admin_user)); 2876cb8a054bSGlenn Faden break; 2877cb8a054bSGlenn Faden case PT_AUTHS: 2878cb8a054bSGlenn Faden (void) strlcpy(admintab->zone_admin_auths, 2879cb8a054bSGlenn Faden pp->pv_simple, sizeof (admintab->zone_admin_auths)); 2880cb8a054bSGlenn Faden break; 2881cb8a054bSGlenn Faden default: 2882cb8a054bSGlenn Faden zone_perror(pt_to_str(cmd->cmd_prop_name[i]), 2883cb8a054bSGlenn Faden Z_NO_PROPERTY_TYPE, B_TRUE); 2884cb8a054bSGlenn Faden return (Z_INSUFFICIENT_SPEC); 2885cb8a054bSGlenn Faden } 2886cb8a054bSGlenn Faden } 2887cb8a054bSGlenn Faden if (fill_in_only) 2888cb8a054bSGlenn Faden return (Z_OK); 2889cb8a054bSGlenn Faden err = zonecfg_lookup_admin(handle, admintab); 2890cb8a054bSGlenn Faden return (err); 2891cb8a054bSGlenn Faden } 2892cb8a054bSGlenn Faden 28937c478bd9Sstevel@tonic-gate static void 28940209230bSgjelinek remove_aliased_rctl(int type, char *name) 28957c478bd9Sstevel@tonic-gate { 28960209230bSgjelinek int err; 28970209230bSgjelinek uint64_t tmp; 28987c478bd9Sstevel@tonic-gate 28990209230bSgjelinek if ((err = zonecfg_get_aliased_rctl(handle, name, &tmp)) != Z_OK) { 29000209230bSgjelinek zerr("%s %s: %s", cmd_to_str(CMD_CLEAR), pt_to_str(type), 29010209230bSgjelinek zonecfg_strerror(err)); 2902bbec428eSgjelinek saw_error = B_TRUE; 29037c478bd9Sstevel@tonic-gate return; 29047c478bd9Sstevel@tonic-gate } 29050209230bSgjelinek if ((err = zonecfg_rm_aliased_rctl(handle, name)) != Z_OK) { 29060209230bSgjelinek zerr("%s %s: %s", cmd_to_str(CMD_CLEAR), pt_to_str(type), 29070209230bSgjelinek zonecfg_strerror(err)); 2908bbec428eSgjelinek saw_error = B_TRUE; 29090209230bSgjelinek } else { 2910bbec428eSgjelinek need_to_commit = B_TRUE; 29110209230bSgjelinek } 29120209230bSgjelinek } 29137c478bd9Sstevel@tonic-gate 29140209230bSgjelinek static boolean_t 29150209230bSgjelinek prompt_remove_resource(cmd_t *cmd, char *rsrc) 29160209230bSgjelinek { 29170209230bSgjelinek int num; 29180209230bSgjelinek int answer; 29190209230bSgjelinek int arg; 29200209230bSgjelinek boolean_t force = B_FALSE; 29210209230bSgjelinek char prompt[128]; 2922bbec428eSgjelinek boolean_t arg_err = B_FALSE; 29230209230bSgjelinek 29240209230bSgjelinek optind = 0; 29250209230bSgjelinek while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "F")) != EOF) { 29260209230bSgjelinek switch (arg) { 29270209230bSgjelinek case 'F': 29280209230bSgjelinek force = B_TRUE; 29290209230bSgjelinek break; 29300209230bSgjelinek default: 2931bbec428eSgjelinek arg_err = B_TRUE; 29327ec75eb8Sgjelinek break; 29330209230bSgjelinek } 29340209230bSgjelinek } 29357ec75eb8Sgjelinek if (arg_err) 29367ec75eb8Sgjelinek return (B_FALSE); 29377ec75eb8Sgjelinek 29380209230bSgjelinek 29390209230bSgjelinek num = zonecfg_num_resources(handle, rsrc); 29400209230bSgjelinek 29410209230bSgjelinek if (num == 0) { 29420209230bSgjelinek z_cmd_rt_perror(CMD_REMOVE, cmd->cmd_res_type, Z_NO_ENTRY, 2943bbec428eSgjelinek B_TRUE); 29440209230bSgjelinek return (B_FALSE); 29450209230bSgjelinek } 29460209230bSgjelinek if (num > 1 && !force) { 29470209230bSgjelinek if (!interactive_mode) { 29480209230bSgjelinek zerr(gettext("There are multiple instances of this " 29490209230bSgjelinek "resource. Either qualify the resource to\n" 29500209230bSgjelinek "remove a single instance or use the -F option to " 29510209230bSgjelinek "remove all instances.")); 2952bbec428eSgjelinek saw_error = B_TRUE; 29530209230bSgjelinek return (B_FALSE); 29540209230bSgjelinek } 29550209230bSgjelinek (void) snprintf(prompt, sizeof (prompt), gettext( 29560209230bSgjelinek "Are you sure you want to remove ALL '%s' resources"), 29570209230bSgjelinek rsrc); 2958bbec428eSgjelinek answer = ask_yesno(B_FALSE, prompt); 29590209230bSgjelinek if (answer == -1) { 29600209230bSgjelinek zerr(gettext("Resource incomplete.")); 29610209230bSgjelinek return (B_FALSE); 29620209230bSgjelinek } 29630209230bSgjelinek if (answer != 1) 29640209230bSgjelinek return (B_FALSE); 29650209230bSgjelinek } 29660209230bSgjelinek return (B_TRUE); 29670209230bSgjelinek } 29680209230bSgjelinek 29690209230bSgjelinek static void 29700209230bSgjelinek remove_fs(cmd_t *cmd) 29710209230bSgjelinek { 29720209230bSgjelinek int err; 29730209230bSgjelinek 29740209230bSgjelinek /* traditional, qualified fs removal */ 29750209230bSgjelinek if (cmd->cmd_prop_nv_pairs > 0) { 29760209230bSgjelinek struct zone_fstab fstab; 29777c478bd9Sstevel@tonic-gate 2978bbec428eSgjelinek if ((err = fill_in_fstab(cmd, &fstab, B_FALSE)) != Z_OK) { 2979bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_FS, err, B_TRUE); 29807c478bd9Sstevel@tonic-gate return; 29817c478bd9Sstevel@tonic-gate } 29827c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_filesystem(handle, &fstab)) != Z_OK) 2983bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_FS, err, B_TRUE); 29847c478bd9Sstevel@tonic-gate else 2985bbec428eSgjelinek need_to_commit = B_TRUE; 29867c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(fstab.zone_fs_options); 29877c478bd9Sstevel@tonic-gate return; 29880209230bSgjelinek } 29890209230bSgjelinek 29900209230bSgjelinek /* 29910209230bSgjelinek * unqualified fs removal. remove all fs's but prompt if more 29920209230bSgjelinek * than one. 29930209230bSgjelinek */ 29940209230bSgjelinek if (!prompt_remove_resource(cmd, "fs")) 29950209230bSgjelinek return; 29960209230bSgjelinek 29970209230bSgjelinek if ((err = zonecfg_del_all_resources(handle, "fs")) != Z_OK) 2998bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_FS, err, B_TRUE); 29990209230bSgjelinek else 3000bbec428eSgjelinek need_to_commit = B_TRUE; 30010209230bSgjelinek } 30020209230bSgjelinek 30030209230bSgjelinek static void 30040209230bSgjelinek remove_ipd(cmd_t *cmd) 30050209230bSgjelinek { 30060209230bSgjelinek int err; 30070209230bSgjelinek 30080209230bSgjelinek if (state_atleast(ZONE_STATE_INSTALLED)) { 30090209230bSgjelinek zerr(gettext("Zone %s already installed; %s %s not allowed."), 30100209230bSgjelinek zone, cmd_to_str(CMD_REMOVE), rt_to_str(RT_IPD)); 30110209230bSgjelinek return; 30120209230bSgjelinek } 30130209230bSgjelinek 30140209230bSgjelinek /* traditional, qualified ipd removal */ 30150209230bSgjelinek if (cmd->cmd_prop_nv_pairs > 0) { 30160209230bSgjelinek struct zone_fstab fstab; 30170209230bSgjelinek 3018bbec428eSgjelinek if ((err = fill_in_ipdtab(cmd, &fstab, B_FALSE)) != Z_OK) { 3019bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_IPD, err, B_TRUE); 30207c478bd9Sstevel@tonic-gate return; 30217c478bd9Sstevel@tonic-gate } 30227c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_ipd(handle, &fstab)) != Z_OK) 3023bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_IPD, err, B_TRUE); 30247c478bd9Sstevel@tonic-gate else 3025bbec428eSgjelinek need_to_commit = B_TRUE; 30267c478bd9Sstevel@tonic-gate return; 30270209230bSgjelinek } 30280209230bSgjelinek 30290209230bSgjelinek /* 30300209230bSgjelinek * unqualified ipd removal. remove all ipds but prompt if more 30310209230bSgjelinek * than one. 30320209230bSgjelinek */ 30330209230bSgjelinek if (!prompt_remove_resource(cmd, "inherit-pkg-dir")) 30340209230bSgjelinek return; 30350209230bSgjelinek 30360209230bSgjelinek if ((err = zonecfg_del_all_resources(handle, "inherit-pkg-dir")) 30370209230bSgjelinek != Z_OK) 3038bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_IPD, err, B_TRUE); 30390209230bSgjelinek else 3040bbec428eSgjelinek need_to_commit = B_TRUE; 30410209230bSgjelinek } 30420209230bSgjelinek 30430209230bSgjelinek static void 30440209230bSgjelinek remove_net(cmd_t *cmd) 30450209230bSgjelinek { 30460209230bSgjelinek int err; 30470209230bSgjelinek 30480209230bSgjelinek /* traditional, qualified net removal */ 30490209230bSgjelinek if (cmd->cmd_prop_nv_pairs > 0) { 30500209230bSgjelinek struct zone_nwiftab nwiftab; 30510209230bSgjelinek 3052bbec428eSgjelinek if ((err = fill_in_nwiftab(cmd, &nwiftab, B_FALSE)) != Z_OK) { 3053bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_NET, err, B_TRUE); 30547c478bd9Sstevel@tonic-gate return; 30557c478bd9Sstevel@tonic-gate } 30567c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_nwif(handle, &nwiftab)) != Z_OK) 3057bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_NET, err, B_TRUE); 30587c478bd9Sstevel@tonic-gate else 3059bbec428eSgjelinek need_to_commit = B_TRUE; 30607c478bd9Sstevel@tonic-gate return; 30610209230bSgjelinek } 30620209230bSgjelinek 30630209230bSgjelinek /* 30640209230bSgjelinek * unqualified net removal. remove all nets but prompt if more 30650209230bSgjelinek * than one. 30660209230bSgjelinek */ 30670209230bSgjelinek if (!prompt_remove_resource(cmd, "net")) 30680209230bSgjelinek return; 30690209230bSgjelinek 30700209230bSgjelinek if ((err = zonecfg_del_all_resources(handle, "net")) != Z_OK) 3071bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_NET, err, B_TRUE); 30720209230bSgjelinek else 3073bbec428eSgjelinek need_to_commit = B_TRUE; 30740209230bSgjelinek } 30750209230bSgjelinek 30760209230bSgjelinek static void 30770209230bSgjelinek remove_device(cmd_t *cmd) 30780209230bSgjelinek { 30790209230bSgjelinek int err; 30800209230bSgjelinek 30810209230bSgjelinek /* traditional, qualified device removal */ 30820209230bSgjelinek if (cmd->cmd_prop_nv_pairs > 0) { 30830209230bSgjelinek struct zone_devtab devtab; 30840209230bSgjelinek 3085bbec428eSgjelinek if ((err = fill_in_devtab(cmd, &devtab, B_FALSE)) != Z_OK) { 3086bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_DEVICE, err, B_TRUE); 30877c478bd9Sstevel@tonic-gate return; 30887c478bd9Sstevel@tonic-gate } 30897c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_dev(handle, &devtab)) != Z_OK) 3090bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_DEVICE, err, B_TRUE); 30917c478bd9Sstevel@tonic-gate else 3092bbec428eSgjelinek need_to_commit = B_TRUE; 30937c478bd9Sstevel@tonic-gate return; 30940209230bSgjelinek } 30950209230bSgjelinek 30960209230bSgjelinek /* 30970209230bSgjelinek * unqualified device removal. remove all devices but prompt if more 30980209230bSgjelinek * than one. 30990209230bSgjelinek */ 31000209230bSgjelinek if (!prompt_remove_resource(cmd, "device")) 31017c478bd9Sstevel@tonic-gate return; 31020209230bSgjelinek 31030209230bSgjelinek if ((err = zonecfg_del_all_resources(handle, "device")) != Z_OK) 3104bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_DEVICE, err, B_TRUE); 31050209230bSgjelinek else 3106bbec428eSgjelinek need_to_commit = B_TRUE; 31070209230bSgjelinek } 31080209230bSgjelinek 31090209230bSgjelinek static void 31100209230bSgjelinek remove_attr(cmd_t *cmd) 31110209230bSgjelinek { 31120209230bSgjelinek int err; 31130209230bSgjelinek 31140209230bSgjelinek /* traditional, qualified attr removal */ 31150209230bSgjelinek if (cmd->cmd_prop_nv_pairs > 0) { 31160209230bSgjelinek struct zone_attrtab attrtab; 31170209230bSgjelinek 3118bbec428eSgjelinek if ((err = fill_in_attrtab(cmd, &attrtab, B_FALSE)) != Z_OK) { 3119bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_ATTR, err, B_TRUE); 31207c478bd9Sstevel@tonic-gate return; 31217c478bd9Sstevel@tonic-gate } 31227c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_attr(handle, &attrtab)) != Z_OK) 3123bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_ATTR, err, B_TRUE); 31247c478bd9Sstevel@tonic-gate else 3125bbec428eSgjelinek need_to_commit = B_TRUE; 31267c478bd9Sstevel@tonic-gate return; 31270209230bSgjelinek } 31280209230bSgjelinek 31290209230bSgjelinek /* 31300209230bSgjelinek * unqualified attr removal. remove all attrs but prompt if more 31310209230bSgjelinek * than one. 31320209230bSgjelinek */ 31330209230bSgjelinek if (!prompt_remove_resource(cmd, "attr")) 31340209230bSgjelinek return; 31350209230bSgjelinek 31360209230bSgjelinek if ((err = zonecfg_del_all_resources(handle, "attr")) != Z_OK) 3137bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_ATTR, err, B_TRUE); 31380209230bSgjelinek else 3139bbec428eSgjelinek need_to_commit = B_TRUE; 31400209230bSgjelinek } 31410209230bSgjelinek 31420209230bSgjelinek static void 31430209230bSgjelinek remove_dataset(cmd_t *cmd) 31440209230bSgjelinek { 31450209230bSgjelinek int err; 31460209230bSgjelinek 31470209230bSgjelinek /* traditional, qualified dataset removal */ 31480209230bSgjelinek if (cmd->cmd_prop_nv_pairs > 0) { 31490209230bSgjelinek struct zone_dstab dstab; 31500209230bSgjelinek 3151bbec428eSgjelinek if ((err = fill_in_dstab(cmd, &dstab, B_FALSE)) != Z_OK) { 3152bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_DATASET, err, B_TRUE); 3153fa9e4066Sahrens return; 3154fa9e4066Sahrens } 3155fa9e4066Sahrens if ((err = zonecfg_delete_ds(handle, &dstab)) != Z_OK) 3156bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_DATASET, err, B_TRUE); 3157fa9e4066Sahrens else 3158bbec428eSgjelinek need_to_commit = B_TRUE; 3159fa9e4066Sahrens return; 31607c478bd9Sstevel@tonic-gate } 31610209230bSgjelinek 31620209230bSgjelinek /* 31630209230bSgjelinek * unqualified dataset removal. remove all datasets but prompt if more 31640209230bSgjelinek * than one. 31650209230bSgjelinek */ 31660209230bSgjelinek if (!prompt_remove_resource(cmd, "dataset")) 31670209230bSgjelinek return; 31680209230bSgjelinek 31690209230bSgjelinek if ((err = zonecfg_del_all_resources(handle, "dataset")) != Z_OK) 3170bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_DATASET, err, B_TRUE); 31710209230bSgjelinek else 3172bbec428eSgjelinek need_to_commit = B_TRUE; 31730209230bSgjelinek } 31740209230bSgjelinek 31750209230bSgjelinek static void 31760209230bSgjelinek remove_rctl(cmd_t *cmd) 31770209230bSgjelinek { 31780209230bSgjelinek int err; 31790209230bSgjelinek 31800209230bSgjelinek /* traditional, qualified rctl removal */ 31810209230bSgjelinek if (cmd->cmd_prop_nv_pairs > 0) { 31820209230bSgjelinek struct zone_rctltab rctltab; 31830209230bSgjelinek 3184bbec428eSgjelinek if ((err = fill_in_rctltab(cmd, &rctltab, B_FALSE)) != Z_OK) { 3185bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_RCTL, err, B_TRUE); 31860209230bSgjelinek return; 31870209230bSgjelinek } 31880209230bSgjelinek if ((err = zonecfg_delete_rctl(handle, &rctltab)) != Z_OK) 3189bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_RCTL, err, B_TRUE); 31900209230bSgjelinek else 3191bbec428eSgjelinek need_to_commit = B_TRUE; 31920209230bSgjelinek zonecfg_free_rctl_value_list(rctltab.zone_rctl_valptr); 31930209230bSgjelinek return; 31940209230bSgjelinek } 31950209230bSgjelinek 31960209230bSgjelinek /* 31970209230bSgjelinek * unqualified rctl removal. remove all rctls but prompt if more 31980209230bSgjelinek * than one. 31990209230bSgjelinek */ 32000209230bSgjelinek if (!prompt_remove_resource(cmd, "rctl")) 32010209230bSgjelinek return; 32020209230bSgjelinek 32030209230bSgjelinek if ((err = zonecfg_del_all_resources(handle, "rctl")) != Z_OK) 3204bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_RCTL, err, B_TRUE); 32050209230bSgjelinek else 3206bbec428eSgjelinek need_to_commit = B_TRUE; 32070209230bSgjelinek } 32080209230bSgjelinek 32090209230bSgjelinek static void 32100209230bSgjelinek remove_pset() 32110209230bSgjelinek { 32120209230bSgjelinek int err; 32130209230bSgjelinek struct zone_psettab psettab; 32140209230bSgjelinek 32150209230bSgjelinek if ((err = zonecfg_lookup_pset(handle, &psettab)) != Z_OK) { 3216bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_DCPU, err, B_TRUE); 32170209230bSgjelinek return; 32180209230bSgjelinek } 32190209230bSgjelinek if ((err = zonecfg_delete_pset(handle)) != Z_OK) 3220bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_DCPU, err, B_TRUE); 32210209230bSgjelinek else 3222bbec428eSgjelinek need_to_commit = B_TRUE; 32230209230bSgjelinek } 32240209230bSgjelinek 3225c97ad5cdSakolb static void 3226c97ad5cdSakolb remove_pcap() 3227c97ad5cdSakolb { 3228c97ad5cdSakolb int err; 3229c97ad5cdSakolb uint64_t tmp; 3230c97ad5cdSakolb 3231c97ad5cdSakolb if (zonecfg_get_aliased_rctl(handle, ALIAS_CPUCAP, &tmp) != Z_OK) { 3232c97ad5cdSakolb zerr("%s %s: %s", cmd_to_str(CMD_REMOVE), rt_to_str(RT_PCAP), 3233c97ad5cdSakolb zonecfg_strerror(Z_NO_RESOURCE_TYPE)); 3234bbec428eSgjelinek saw_error = B_TRUE; 3235c97ad5cdSakolb return; 3236c97ad5cdSakolb } 3237c97ad5cdSakolb 3238c97ad5cdSakolb if ((err = zonecfg_rm_aliased_rctl(handle, ALIAS_CPUCAP)) != Z_OK) 3239bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_PCAP, err, B_TRUE); 3240c97ad5cdSakolb else 3241bbec428eSgjelinek need_to_commit = B_TRUE; 3242c97ad5cdSakolb } 3243c97ad5cdSakolb 32440209230bSgjelinek static void 32450209230bSgjelinek remove_mcap() 32460209230bSgjelinek { 32470209230bSgjelinek int err, res1, res2, res3; 32480209230bSgjelinek uint64_t tmp; 32490209230bSgjelinek struct zone_mcaptab mcaptab; 32500209230bSgjelinek boolean_t revert = B_FALSE; 32510209230bSgjelinek 32520209230bSgjelinek res1 = zonecfg_lookup_mcap(handle, &mcaptab); 32530209230bSgjelinek res2 = zonecfg_get_aliased_rctl(handle, ALIAS_MAXSWAP, &tmp); 32540209230bSgjelinek res3 = zonecfg_get_aliased_rctl(handle, ALIAS_MAXLOCKEDMEM, &tmp); 32550209230bSgjelinek 32560209230bSgjelinek /* if none of these exist, there is no resource to remove */ 32570209230bSgjelinek if (res1 != Z_OK && res2 != Z_OK && res3 != Z_OK) { 32580209230bSgjelinek zerr("%s %s: %s", cmd_to_str(CMD_REMOVE), rt_to_str(RT_MCAP), 32590209230bSgjelinek zonecfg_strerror(Z_NO_RESOURCE_TYPE)); 3260bbec428eSgjelinek saw_error = B_TRUE; 32610209230bSgjelinek return; 32620209230bSgjelinek } 32630209230bSgjelinek if (res1 == Z_OK) { 32640209230bSgjelinek if ((err = zonecfg_delete_mcap(handle)) != Z_OK) { 3265bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_MCAP, err, B_TRUE); 32660209230bSgjelinek revert = B_TRUE; 32670209230bSgjelinek } else { 3268bbec428eSgjelinek need_to_commit = B_TRUE; 32690209230bSgjelinek } 32700209230bSgjelinek } 32710209230bSgjelinek if (res2 == Z_OK) { 32720209230bSgjelinek if ((err = zonecfg_rm_aliased_rctl(handle, ALIAS_MAXSWAP)) 32730209230bSgjelinek != Z_OK) { 3274bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_MCAP, err, B_TRUE); 32750209230bSgjelinek revert = B_TRUE; 32760209230bSgjelinek } else { 3277bbec428eSgjelinek need_to_commit = B_TRUE; 32780209230bSgjelinek } 32790209230bSgjelinek } 32800209230bSgjelinek if (res3 == Z_OK) { 32810209230bSgjelinek if ((err = zonecfg_rm_aliased_rctl(handle, ALIAS_MAXLOCKEDMEM)) 32820209230bSgjelinek != Z_OK) { 3283bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_MCAP, err, B_TRUE); 32840209230bSgjelinek revert = B_TRUE; 32850209230bSgjelinek } else { 3286bbec428eSgjelinek need_to_commit = B_TRUE; 32870209230bSgjelinek } 32880209230bSgjelinek } 32890209230bSgjelinek 32900209230bSgjelinek if (revert) 3291bbec428eSgjelinek need_to_commit = B_FALSE; 32920209230bSgjelinek } 32930209230bSgjelinek 3294cb8a054bSGlenn Faden static void 3295cb8a054bSGlenn Faden remove_admin(cmd_t *cmd) 3296cb8a054bSGlenn Faden { 3297cb8a054bSGlenn Faden int err; 3298cb8a054bSGlenn Faden 3299cb8a054bSGlenn Faden /* traditional, qualified attr removal */ 3300cb8a054bSGlenn Faden if (cmd->cmd_prop_nv_pairs > 0) { 3301cb8a054bSGlenn Faden struct zone_admintab admintab; 3302cb8a054bSGlenn Faden 3303cb8a054bSGlenn Faden if ((err = fill_in_admintab(cmd, &admintab, B_FALSE)) != Z_OK) { 3304cb8a054bSGlenn Faden z_cmd_rt_perror(CMD_REMOVE, RT_ADMIN, 3305cb8a054bSGlenn Faden err, B_TRUE); 3306cb8a054bSGlenn Faden return; 3307cb8a054bSGlenn Faden } 3308cb8a054bSGlenn Faden if ((err = zonecfg_delete_admin(handle, &admintab, 3309cb8a054bSGlenn Faden zone)) 3310cb8a054bSGlenn Faden != Z_OK) 3311cb8a054bSGlenn Faden z_cmd_rt_perror(CMD_REMOVE, RT_ADMIN, 3312cb8a054bSGlenn Faden err, B_TRUE); 3313cb8a054bSGlenn Faden else 3314cb8a054bSGlenn Faden need_to_commit = B_TRUE; 3315cb8a054bSGlenn Faden return; 3316cb8a054bSGlenn Faden } else { 3317cb8a054bSGlenn Faden /* 3318cb8a054bSGlenn Faden * unqualified admin removal. 3319cb8a054bSGlenn Faden * remove all admins but prompt if more 3320cb8a054bSGlenn Faden * than one. 3321cb8a054bSGlenn Faden */ 3322cb8a054bSGlenn Faden if (!prompt_remove_resource(cmd, "admin")) 3323cb8a054bSGlenn Faden return; 3324cb8a054bSGlenn Faden 3325cb8a054bSGlenn Faden if ((err = zonecfg_delete_admins(handle, zone)) 3326cb8a054bSGlenn Faden != Z_OK) 3327cb8a054bSGlenn Faden z_cmd_rt_perror(CMD_REMOVE, RT_ADMIN, 3328cb8a054bSGlenn Faden err, B_TRUE); 3329cb8a054bSGlenn Faden else 3330cb8a054bSGlenn Faden need_to_commit = B_TRUE; 3331cb8a054bSGlenn Faden } 3332cb8a054bSGlenn Faden } 3333cb8a054bSGlenn Faden 33340209230bSgjelinek static void 33350209230bSgjelinek remove_resource(cmd_t *cmd) 33360209230bSgjelinek { 33370209230bSgjelinek int type; 33380209230bSgjelinek int arg; 3339bbec428eSgjelinek boolean_t arg_err = B_FALSE; 33400209230bSgjelinek 33410209230bSgjelinek if ((type = cmd->cmd_res_type) == RT_UNKNOWN) { 3342bbec428eSgjelinek long_usage(CMD_REMOVE, B_TRUE); 33430209230bSgjelinek return; 33440209230bSgjelinek } 33450209230bSgjelinek 33460209230bSgjelinek optind = 0; 33470209230bSgjelinek while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?F")) != EOF) { 33480209230bSgjelinek switch (arg) { 33490209230bSgjelinek case '?': 33500209230bSgjelinek longer_usage(CMD_REMOVE); 3351bbec428eSgjelinek arg_err = B_TRUE; 33527ec75eb8Sgjelinek break; 33530209230bSgjelinek case 'F': 33540209230bSgjelinek break; 33550209230bSgjelinek default: 33560209230bSgjelinek short_usage(CMD_REMOVE); 3357bbec428eSgjelinek arg_err = B_TRUE; 33587ec75eb8Sgjelinek break; 33590209230bSgjelinek } 33600209230bSgjelinek } 33617ec75eb8Sgjelinek if (arg_err) 33627ec75eb8Sgjelinek return; 33630209230bSgjelinek 3364bbec428eSgjelinek if (initialize(B_TRUE) != Z_OK) 33650209230bSgjelinek return; 33660209230bSgjelinek 33670209230bSgjelinek switch (type) { 33680209230bSgjelinek case RT_FS: 33690209230bSgjelinek remove_fs(cmd); 33700209230bSgjelinek return; 33710209230bSgjelinek case RT_IPD: 33720209230bSgjelinek remove_ipd(cmd); 33730209230bSgjelinek return; 33740209230bSgjelinek case RT_NET: 33750209230bSgjelinek remove_net(cmd); 33760209230bSgjelinek return; 33770209230bSgjelinek case RT_DEVICE: 33780209230bSgjelinek remove_device(cmd); 33790209230bSgjelinek return; 33800209230bSgjelinek case RT_RCTL: 33810209230bSgjelinek remove_rctl(cmd); 33820209230bSgjelinek return; 33830209230bSgjelinek case RT_ATTR: 33840209230bSgjelinek remove_attr(cmd); 33850209230bSgjelinek return; 33860209230bSgjelinek case RT_DATASET: 33870209230bSgjelinek remove_dataset(cmd); 33880209230bSgjelinek return; 33890209230bSgjelinek case RT_DCPU: 33900209230bSgjelinek remove_pset(); 33910209230bSgjelinek return; 3392c97ad5cdSakolb case RT_PCAP: 3393c97ad5cdSakolb remove_pcap(); 3394c97ad5cdSakolb return; 33950209230bSgjelinek case RT_MCAP: 33960209230bSgjelinek remove_mcap(); 33970209230bSgjelinek return; 3398cb8a054bSGlenn Faden case RT_ADMIN: 3399cb8a054bSGlenn Faden remove_admin(cmd); 3400cb8a054bSGlenn Faden return; 34010209230bSgjelinek default: 3402bbec428eSgjelinek zone_perror(rt_to_str(type), Z_NO_RESOURCE_TYPE, B_TRUE); 3403bbec428eSgjelinek long_usage(CMD_REMOVE, B_TRUE); 3404bbec428eSgjelinek usage(B_FALSE, HELP_RESOURCES); 34050209230bSgjelinek return; 34060209230bSgjelinek } 34070209230bSgjelinek } 34087c478bd9Sstevel@tonic-gate 34097c478bd9Sstevel@tonic-gate static void 34107c478bd9Sstevel@tonic-gate remove_property(cmd_t *cmd) 34117c478bd9Sstevel@tonic-gate { 34127c478bd9Sstevel@tonic-gate char *prop_id; 34137c478bd9Sstevel@tonic-gate int err, res_type, prop_type; 34147c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 34157c478bd9Sstevel@tonic-gate struct zone_rctlvaltab *rctlvaltab; 34167c478bd9Sstevel@tonic-gate complex_property_ptr_t cx; 34177c478bd9Sstevel@tonic-gate 34187c478bd9Sstevel@tonic-gate res_type = resource_scope; 34197c478bd9Sstevel@tonic-gate prop_type = cmd->cmd_prop_name[0]; 34207c478bd9Sstevel@tonic-gate if (res_type == RT_UNKNOWN || prop_type == PT_UNKNOWN) { 3421bbec428eSgjelinek long_usage(CMD_REMOVE, B_TRUE); 34227c478bd9Sstevel@tonic-gate return; 34237c478bd9Sstevel@tonic-gate } 34247c478bd9Sstevel@tonic-gate 34257c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs != 1) { 3426bbec428eSgjelinek long_usage(CMD_ADD, B_TRUE); 34277c478bd9Sstevel@tonic-gate return; 34287c478bd9Sstevel@tonic-gate } 34297c478bd9Sstevel@tonic-gate 3430bbec428eSgjelinek if (initialize(B_TRUE) != Z_OK) 34317c478bd9Sstevel@tonic-gate return; 34327c478bd9Sstevel@tonic-gate 34337c478bd9Sstevel@tonic-gate switch (res_type) { 34347c478bd9Sstevel@tonic-gate case RT_FS: 34357c478bd9Sstevel@tonic-gate if (prop_type != PT_OPTIONS) { 34367c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 3437bbec428eSgjelinek B_TRUE); 3438bbec428eSgjelinek long_usage(CMD_REMOVE, B_TRUE); 3439bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 34407c478bd9Sstevel@tonic-gate return; 34417c478bd9Sstevel@tonic-gate } 34427c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[0]; 34437c478bd9Sstevel@tonic-gate if (pp->pv_type == PROP_VAL_COMPLEX) { 34447c478bd9Sstevel@tonic-gate zerr(gettext("A %s or %s value was expected here."), 34457c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_SIMPLE), 34467c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_LIST)); 3447bbec428eSgjelinek saw_error = B_TRUE; 34487c478bd9Sstevel@tonic-gate return; 34497c478bd9Sstevel@tonic-gate } 34507c478bd9Sstevel@tonic-gate if (pp->pv_type == PROP_VAL_SIMPLE) { 34517c478bd9Sstevel@tonic-gate if (pp->pv_simple == NULL) { 3452bbec428eSgjelinek long_usage(CMD_ADD, B_TRUE); 34537c478bd9Sstevel@tonic-gate return; 34547c478bd9Sstevel@tonic-gate } 34557c478bd9Sstevel@tonic-gate prop_id = pp->pv_simple; 34567c478bd9Sstevel@tonic-gate err = zonecfg_remove_fs_option(&in_progress_fstab, 34577c478bd9Sstevel@tonic-gate prop_id); 34587c478bd9Sstevel@tonic-gate if (err != Z_OK) 3459bbec428eSgjelinek zone_perror(pt_to_str(prop_type), err, B_TRUE); 34607c478bd9Sstevel@tonic-gate } else { 34617c478bd9Sstevel@tonic-gate list_property_ptr_t list; 34627c478bd9Sstevel@tonic-gate 34637c478bd9Sstevel@tonic-gate for (list = pp->pv_list; list != NULL; 34647c478bd9Sstevel@tonic-gate list = list->lp_next) { 34657c478bd9Sstevel@tonic-gate prop_id = list->lp_simple; 34667c478bd9Sstevel@tonic-gate if (prop_id == NULL) 34677c478bd9Sstevel@tonic-gate break; 34687c478bd9Sstevel@tonic-gate err = zonecfg_remove_fs_option( 34697c478bd9Sstevel@tonic-gate &in_progress_fstab, prop_id); 34707c478bd9Sstevel@tonic-gate if (err != Z_OK) 34717c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), err, 3472bbec428eSgjelinek B_TRUE); 34737c478bd9Sstevel@tonic-gate } 34747c478bd9Sstevel@tonic-gate } 34757c478bd9Sstevel@tonic-gate return; 34767c478bd9Sstevel@tonic-gate case RT_RCTL: 34777c478bd9Sstevel@tonic-gate if (prop_type != PT_VALUE) { 34787c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 3479bbec428eSgjelinek B_TRUE); 3480bbec428eSgjelinek long_usage(CMD_REMOVE, B_TRUE); 3481bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 34827c478bd9Sstevel@tonic-gate return; 34837c478bd9Sstevel@tonic-gate } 34847c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[0]; 34857c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_COMPLEX) { 34867c478bd9Sstevel@tonic-gate zerr(gettext("A %s value was expected here."), 34877c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_COMPLEX)); 3488bbec428eSgjelinek saw_error = B_TRUE; 34897c478bd9Sstevel@tonic-gate return; 34907c478bd9Sstevel@tonic-gate } 34917c478bd9Sstevel@tonic-gate if ((rctlvaltab = alloc_rctlvaltab()) == NULL) { 3492bbec428eSgjelinek zone_perror(zone, Z_NOMEM, B_TRUE); 34937c478bd9Sstevel@tonic-gate exit(Z_ERR); 34947c478bd9Sstevel@tonic-gate } 34957c478bd9Sstevel@tonic-gate for (cx = pp->pv_complex; cx != NULL; cx = cx->cp_next) { 34967c478bd9Sstevel@tonic-gate switch (cx->cp_type) { 34977c478bd9Sstevel@tonic-gate case PT_PRIV: 34987c478bd9Sstevel@tonic-gate (void) strlcpy(rctlvaltab->zone_rctlval_priv, 34997c478bd9Sstevel@tonic-gate cx->cp_value, 35007c478bd9Sstevel@tonic-gate sizeof (rctlvaltab->zone_rctlval_priv)); 35017c478bd9Sstevel@tonic-gate break; 35027c478bd9Sstevel@tonic-gate case PT_LIMIT: 35037c478bd9Sstevel@tonic-gate (void) strlcpy(rctlvaltab->zone_rctlval_limit, 35047c478bd9Sstevel@tonic-gate cx->cp_value, 35057c478bd9Sstevel@tonic-gate sizeof (rctlvaltab->zone_rctlval_limit)); 35067c478bd9Sstevel@tonic-gate break; 35077c478bd9Sstevel@tonic-gate case PT_ACTION: 35087c478bd9Sstevel@tonic-gate (void) strlcpy(rctlvaltab->zone_rctlval_action, 35097c478bd9Sstevel@tonic-gate cx->cp_value, 35107c478bd9Sstevel@tonic-gate sizeof (rctlvaltab->zone_rctlval_action)); 35117c478bd9Sstevel@tonic-gate break; 35127c478bd9Sstevel@tonic-gate default: 35137c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), 3514bbec428eSgjelinek Z_NO_PROPERTY_TYPE, B_TRUE); 3515bbec428eSgjelinek long_usage(CMD_ADD, B_TRUE); 3516bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 35177c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctlvaltab); 35187c478bd9Sstevel@tonic-gate return; 35197c478bd9Sstevel@tonic-gate } 35207c478bd9Sstevel@tonic-gate } 35217c478bd9Sstevel@tonic-gate rctlvaltab->zone_rctlval_next = NULL; 35227c478bd9Sstevel@tonic-gate err = zonecfg_remove_rctl_value(&in_progress_rctltab, 35237c478bd9Sstevel@tonic-gate rctlvaltab); 35247c478bd9Sstevel@tonic-gate if (err != Z_OK) 3525bbec428eSgjelinek zone_perror(pt_to_str(prop_type), err, B_TRUE); 35267c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctlvaltab); 35277c478bd9Sstevel@tonic-gate return; 3528de860bd9Sgfaden case RT_NET: 3529de860bd9Sgfaden if (prop_type != PT_DEFROUTER) { 3530de860bd9Sgfaden zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 3531bbec428eSgjelinek B_TRUE); 3532bbec428eSgjelinek long_usage(CMD_REMOVE, B_TRUE); 3533bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 3534de860bd9Sgfaden return; 3535de860bd9Sgfaden } else { 3536de860bd9Sgfaden bzero(&in_progress_nwiftab.zone_nwif_defrouter, 3537de860bd9Sgfaden sizeof (in_progress_nwiftab.zone_nwif_defrouter)); 3538de860bd9Sgfaden return; 3539de860bd9Sgfaden } 35407c478bd9Sstevel@tonic-gate default: 3541bbec428eSgjelinek zone_perror(rt_to_str(res_type), Z_NO_RESOURCE_TYPE, B_TRUE); 3542bbec428eSgjelinek long_usage(CMD_REMOVE, B_TRUE); 3543bbec428eSgjelinek usage(B_FALSE, HELP_RESOURCES); 35447c478bd9Sstevel@tonic-gate return; 35457c478bd9Sstevel@tonic-gate } 35467c478bd9Sstevel@tonic-gate } 35477c478bd9Sstevel@tonic-gate 35487c478bd9Sstevel@tonic-gate void 35497c478bd9Sstevel@tonic-gate remove_func(cmd_t *cmd) 35507c478bd9Sstevel@tonic-gate { 35517c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_REMOVE)) 35527c478bd9Sstevel@tonic-gate return; 35537c478bd9Sstevel@tonic-gate 35547c478bd9Sstevel@tonic-gate assert(cmd != NULL); 35557c478bd9Sstevel@tonic-gate 35560209230bSgjelinek if (global_scope) { 35570209230bSgjelinek if (gz_invalid_resource(cmd->cmd_res_type)) { 35580209230bSgjelinek zerr(gettext("%s is not a valid resource for the " 35590209230bSgjelinek "global zone."), rt_to_str(cmd->cmd_res_type)); 3560bbec428eSgjelinek saw_error = B_TRUE; 35610209230bSgjelinek return; 35620209230bSgjelinek } 35637c478bd9Sstevel@tonic-gate remove_resource(cmd); 35640209230bSgjelinek } else { 35657c478bd9Sstevel@tonic-gate remove_property(cmd); 35660209230bSgjelinek } 35670209230bSgjelinek } 35680209230bSgjelinek 35690209230bSgjelinek static void 35700209230bSgjelinek clear_property(cmd_t *cmd) 35710209230bSgjelinek { 35720209230bSgjelinek int res_type, prop_type; 35730209230bSgjelinek 35740209230bSgjelinek res_type = resource_scope; 35750209230bSgjelinek prop_type = cmd->cmd_res_type; 35760209230bSgjelinek if (res_type == RT_UNKNOWN || prop_type == PT_UNKNOWN) { 3577bbec428eSgjelinek long_usage(CMD_CLEAR, B_TRUE); 35780209230bSgjelinek return; 35790209230bSgjelinek } 35800209230bSgjelinek 3581bbec428eSgjelinek if (initialize(B_TRUE) != Z_OK) 35820209230bSgjelinek return; 35830209230bSgjelinek 35840209230bSgjelinek switch (res_type) { 35850209230bSgjelinek case RT_FS: 35860209230bSgjelinek if (prop_type == PT_RAW) { 35870209230bSgjelinek in_progress_fstab.zone_fs_raw[0] = '\0'; 3588bbec428eSgjelinek need_to_commit = B_TRUE; 35890209230bSgjelinek return; 35900209230bSgjelinek } 35910209230bSgjelinek break; 35920209230bSgjelinek case RT_DCPU: 35930209230bSgjelinek if (prop_type == PT_IMPORTANCE) { 35940209230bSgjelinek in_progress_psettab.zone_importance[0] = '\0'; 3595bbec428eSgjelinek need_to_commit = B_TRUE; 35960209230bSgjelinek return; 35970209230bSgjelinek } 35980209230bSgjelinek break; 35990209230bSgjelinek case RT_MCAP: 36000209230bSgjelinek switch (prop_type) { 36010209230bSgjelinek case PT_PHYSICAL: 36020209230bSgjelinek in_progress_mcaptab.zone_physmem_cap[0] = '\0'; 3603bbec428eSgjelinek need_to_commit = B_TRUE; 36040209230bSgjelinek return; 36050209230bSgjelinek case PT_SWAP: 36060209230bSgjelinek remove_aliased_rctl(PT_SWAP, ALIAS_MAXSWAP); 36070209230bSgjelinek return; 36080209230bSgjelinek case PT_LOCKED: 36090209230bSgjelinek remove_aliased_rctl(PT_LOCKED, ALIAS_MAXLOCKEDMEM); 36100209230bSgjelinek return; 36110209230bSgjelinek } 36120209230bSgjelinek break; 36130209230bSgjelinek default: 36140209230bSgjelinek break; 36150209230bSgjelinek } 36160209230bSgjelinek 3617bbec428eSgjelinek zone_perror(pt_to_str(prop_type), Z_CLEAR_DISALLOW, B_TRUE); 36180209230bSgjelinek } 36190209230bSgjelinek 36200209230bSgjelinek static void 36210209230bSgjelinek clear_global(cmd_t *cmd) 36220209230bSgjelinek { 36230209230bSgjelinek int err, type; 36240209230bSgjelinek 36250209230bSgjelinek if ((type = cmd->cmd_res_type) == RT_UNKNOWN) { 3626bbec428eSgjelinek long_usage(CMD_CLEAR, B_TRUE); 36270209230bSgjelinek return; 36280209230bSgjelinek } 36290209230bSgjelinek 3630bbec428eSgjelinek if (initialize(B_TRUE) != Z_OK) 36310209230bSgjelinek return; 36320209230bSgjelinek 36330209230bSgjelinek switch (type) { 36340209230bSgjelinek case PT_ZONENAME: 36350209230bSgjelinek /* FALLTHRU */ 36360209230bSgjelinek case PT_ZONEPATH: 36370209230bSgjelinek /* FALLTHRU */ 36380209230bSgjelinek case PT_BRAND: 3639bbec428eSgjelinek zone_perror(pt_to_str(type), Z_CLEAR_DISALLOW, B_TRUE); 36400209230bSgjelinek return; 36410209230bSgjelinek case PT_AUTOBOOT: 36420209230bSgjelinek /* false is default; we'll treat as equivalent to clearing */ 36430209230bSgjelinek if ((err = zonecfg_set_autoboot(handle, B_FALSE)) != Z_OK) 3644bbec428eSgjelinek z_cmd_rt_perror(CMD_CLEAR, RT_AUTOBOOT, err, B_TRUE); 36450209230bSgjelinek else 3646bbec428eSgjelinek need_to_commit = B_TRUE; 36470209230bSgjelinek return; 36480209230bSgjelinek case PT_POOL: 36490209230bSgjelinek if ((err = zonecfg_set_pool(handle, NULL)) != Z_OK) 3650bbec428eSgjelinek z_cmd_rt_perror(CMD_CLEAR, RT_POOL, err, B_TRUE); 36510209230bSgjelinek else 3652bbec428eSgjelinek need_to_commit = B_TRUE; 36530209230bSgjelinek return; 36540209230bSgjelinek case PT_LIMITPRIV: 36550209230bSgjelinek if ((err = zonecfg_set_limitpriv(handle, NULL)) != Z_OK) 3656bbec428eSgjelinek z_cmd_rt_perror(CMD_CLEAR, RT_LIMITPRIV, err, B_TRUE); 36570209230bSgjelinek else 3658bbec428eSgjelinek need_to_commit = B_TRUE; 36590209230bSgjelinek return; 36600209230bSgjelinek case PT_BOOTARGS: 36610209230bSgjelinek if ((err = zonecfg_set_bootargs(handle, NULL)) != Z_OK) 3662bbec428eSgjelinek z_cmd_rt_perror(CMD_CLEAR, RT_BOOTARGS, err, B_TRUE); 36630209230bSgjelinek else 3664bbec428eSgjelinek need_to_commit = B_TRUE; 36650209230bSgjelinek return; 36660209230bSgjelinek case PT_SCHED: 36670209230bSgjelinek if ((err = zonecfg_set_sched(handle, NULL)) != Z_OK) 3668bbec428eSgjelinek z_cmd_rt_perror(CMD_CLEAR, RT_SCHED, err, B_TRUE); 36690209230bSgjelinek else 3670bbec428eSgjelinek need_to_commit = B_TRUE; 36710209230bSgjelinek return; 3672f4b3ec61Sdh case PT_IPTYPE: 3673f4b3ec61Sdh /* shared is default; we'll treat as equivalent to clearing */ 3674f4b3ec61Sdh if ((err = zonecfg_set_iptype(handle, ZS_SHARED)) != Z_OK) 3675bbec428eSgjelinek z_cmd_rt_perror(CMD_CLEAR, RT_IPTYPE, err, B_TRUE); 3676f4b3ec61Sdh else 3677bbec428eSgjelinek need_to_commit = B_TRUE; 3678f4b3ec61Sdh return; 36790209230bSgjelinek case PT_MAXLWPS: 36800209230bSgjelinek remove_aliased_rctl(PT_MAXLWPS, ALIAS_MAXLWPS); 36810209230bSgjelinek return; 3682*ff19e029SMenno Lageman case PT_MAXPROCS: 3683*ff19e029SMenno Lageman remove_aliased_rctl(PT_MAXPROCS, ALIAS_MAXPROCS); 3684*ff19e029SMenno Lageman return; 36850209230bSgjelinek case PT_MAXSHMMEM: 36860209230bSgjelinek remove_aliased_rctl(PT_MAXSHMMEM, ALIAS_MAXSHMMEM); 36870209230bSgjelinek return; 36880209230bSgjelinek case PT_MAXSHMIDS: 36890209230bSgjelinek remove_aliased_rctl(PT_MAXSHMIDS, ALIAS_MAXSHMIDS); 36900209230bSgjelinek return; 36910209230bSgjelinek case PT_MAXMSGIDS: 36920209230bSgjelinek remove_aliased_rctl(PT_MAXMSGIDS, ALIAS_MAXMSGIDS); 36930209230bSgjelinek return; 36940209230bSgjelinek case PT_MAXSEMIDS: 36950209230bSgjelinek remove_aliased_rctl(PT_MAXSEMIDS, ALIAS_MAXSEMIDS); 36960209230bSgjelinek return; 36970209230bSgjelinek case PT_SHARES: 36980209230bSgjelinek remove_aliased_rctl(PT_SHARES, ALIAS_SHARES); 36990209230bSgjelinek return; 37005679c89fSjv case PT_HOSTID: 37015679c89fSjv if ((err = zonecfg_set_hostid(handle, NULL)) != Z_OK) 37025679c89fSjv z_cmd_rt_perror(CMD_CLEAR, RT_HOSTID, err, B_TRUE); 37035679c89fSjv else 37045679c89fSjv need_to_commit = B_TRUE; 37055679c89fSjv return; 37060fbb751dSJohn Levon case PT_FS_ALLOWED: 37070fbb751dSJohn Levon if ((err = zonecfg_set_fs_allowed(handle, NULL)) != Z_OK) 37080fbb751dSJohn Levon z_cmd_rt_perror(CMD_CLEAR, RT_FS_ALLOWED, err, B_TRUE); 37090fbb751dSJohn Levon else 37100fbb751dSJohn Levon need_to_commit = B_TRUE; 37110fbb751dSJohn Levon return; 37120209230bSgjelinek default: 3713bbec428eSgjelinek zone_perror(pt_to_str(type), Z_NO_PROPERTY_TYPE, B_TRUE); 3714bbec428eSgjelinek long_usage(CMD_CLEAR, B_TRUE); 3715bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 37160209230bSgjelinek return; 37170209230bSgjelinek } 37180209230bSgjelinek } 37190209230bSgjelinek 37200209230bSgjelinek void 37210209230bSgjelinek clear_func(cmd_t *cmd) 37220209230bSgjelinek { 37230209230bSgjelinek if (zone_is_read_only(CMD_CLEAR)) 37240209230bSgjelinek return; 37250209230bSgjelinek 37260209230bSgjelinek assert(cmd != NULL); 37270209230bSgjelinek 37280209230bSgjelinek if (global_scope) { 37290209230bSgjelinek if (gz_invalid_property(cmd->cmd_res_type)) { 37300209230bSgjelinek zerr(gettext("%s is not a valid property for the " 37310209230bSgjelinek "global zone."), pt_to_str(cmd->cmd_res_type)); 3732bbec428eSgjelinek saw_error = B_TRUE; 37330209230bSgjelinek return; 37340209230bSgjelinek } 37350209230bSgjelinek 37360209230bSgjelinek clear_global(cmd); 37370209230bSgjelinek } else { 37380209230bSgjelinek clear_property(cmd); 37390209230bSgjelinek } 37407c478bd9Sstevel@tonic-gate } 37417c478bd9Sstevel@tonic-gate 37427c478bd9Sstevel@tonic-gate void 37437c478bd9Sstevel@tonic-gate select_func(cmd_t *cmd) 37447c478bd9Sstevel@tonic-gate { 37450209230bSgjelinek int type, err, res; 37460209230bSgjelinek uint64_t limit; 3747c97ad5cdSakolb uint64_t tmp; 37487c478bd9Sstevel@tonic-gate 37497c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_SELECT)) 37507c478bd9Sstevel@tonic-gate return; 37517c478bd9Sstevel@tonic-gate 37527c478bd9Sstevel@tonic-gate assert(cmd != NULL); 37537c478bd9Sstevel@tonic-gate 37547c478bd9Sstevel@tonic-gate if (global_scope) { 3755bbec428eSgjelinek global_scope = B_FALSE; 37567c478bd9Sstevel@tonic-gate resource_scope = cmd->cmd_res_type; 37577c478bd9Sstevel@tonic-gate end_op = CMD_SELECT; 37587c478bd9Sstevel@tonic-gate } else { 37597c478bd9Sstevel@tonic-gate scope_usage(CMD_SELECT); 37607c478bd9Sstevel@tonic-gate return; 37617c478bd9Sstevel@tonic-gate } 37627c478bd9Sstevel@tonic-gate 37637c478bd9Sstevel@tonic-gate if ((type = cmd->cmd_res_type) == RT_UNKNOWN) { 3764bbec428eSgjelinek long_usage(CMD_SELECT, B_TRUE); 37657c478bd9Sstevel@tonic-gate return; 37667c478bd9Sstevel@tonic-gate } 37677c478bd9Sstevel@tonic-gate 3768bbec428eSgjelinek if (initialize(B_TRUE) != Z_OK) 37697c478bd9Sstevel@tonic-gate return; 37707c478bd9Sstevel@tonic-gate 37717c478bd9Sstevel@tonic-gate switch (type) { 37727c478bd9Sstevel@tonic-gate case RT_FS: 3773bbec428eSgjelinek if ((err = fill_in_fstab(cmd, &old_fstab, B_FALSE)) != Z_OK) { 3774bbec428eSgjelinek z_cmd_rt_perror(CMD_SELECT, RT_FS, err, B_TRUE); 3775bbec428eSgjelinek global_scope = B_TRUE; 37767c478bd9Sstevel@tonic-gate } 37777c478bd9Sstevel@tonic-gate bcopy(&old_fstab, &in_progress_fstab, 37787c478bd9Sstevel@tonic-gate sizeof (struct zone_fstab)); 37797c478bd9Sstevel@tonic-gate return; 37807c478bd9Sstevel@tonic-gate case RT_IPD: 3781087719fdSdp if (state_atleast(ZONE_STATE_INCOMPLETE)) { 37827c478bd9Sstevel@tonic-gate zerr(gettext("Zone %s not in %s state; %s %s not " 37837c478bd9Sstevel@tonic-gate "allowed."), zone, 37847c478bd9Sstevel@tonic-gate zone_state_str(ZONE_STATE_CONFIGURED), 37857c478bd9Sstevel@tonic-gate cmd_to_str(CMD_SELECT), rt_to_str(RT_IPD)); 3786bbec428eSgjelinek global_scope = B_TRUE; 37877c478bd9Sstevel@tonic-gate end_op = -1; 37887c478bd9Sstevel@tonic-gate return; 37897c478bd9Sstevel@tonic-gate } 3790bbec428eSgjelinek if ((err = fill_in_ipdtab(cmd, &old_ipdtab, B_FALSE)) != Z_OK) { 3791bbec428eSgjelinek z_cmd_rt_perror(CMD_SELECT, RT_IPD, err, B_TRUE); 3792bbec428eSgjelinek global_scope = B_TRUE; 37937c478bd9Sstevel@tonic-gate } 37947c478bd9Sstevel@tonic-gate bcopy(&old_ipdtab, &in_progress_ipdtab, 37957c478bd9Sstevel@tonic-gate sizeof (struct zone_fstab)); 37967c478bd9Sstevel@tonic-gate return; 37977c478bd9Sstevel@tonic-gate case RT_NET: 3798bbec428eSgjelinek if ((err = fill_in_nwiftab(cmd, &old_nwiftab, B_FALSE)) 3799bbec428eSgjelinek != Z_OK) { 3800bbec428eSgjelinek z_cmd_rt_perror(CMD_SELECT, RT_NET, err, B_TRUE); 3801bbec428eSgjelinek global_scope = B_TRUE; 38027c478bd9Sstevel@tonic-gate } 38037c478bd9Sstevel@tonic-gate bcopy(&old_nwiftab, &in_progress_nwiftab, 38047c478bd9Sstevel@tonic-gate sizeof (struct zone_nwiftab)); 38057c478bd9Sstevel@tonic-gate return; 38067c478bd9Sstevel@tonic-gate case RT_DEVICE: 3807bbec428eSgjelinek if ((err = fill_in_devtab(cmd, &old_devtab, B_FALSE)) != Z_OK) { 3808bbec428eSgjelinek z_cmd_rt_perror(CMD_SELECT, RT_DEVICE, err, B_TRUE); 3809bbec428eSgjelinek global_scope = B_TRUE; 38107c478bd9Sstevel@tonic-gate } 38117c478bd9Sstevel@tonic-gate bcopy(&old_devtab, &in_progress_devtab, 38127c478bd9Sstevel@tonic-gate sizeof (struct zone_devtab)); 38137c478bd9Sstevel@tonic-gate return; 38147c478bd9Sstevel@tonic-gate case RT_RCTL: 3815bbec428eSgjelinek if ((err = fill_in_rctltab(cmd, &old_rctltab, B_FALSE)) 3816bbec428eSgjelinek != Z_OK) { 3817bbec428eSgjelinek z_cmd_rt_perror(CMD_SELECT, RT_RCTL, err, B_TRUE); 3818bbec428eSgjelinek global_scope = B_TRUE; 38197c478bd9Sstevel@tonic-gate } 38207c478bd9Sstevel@tonic-gate bcopy(&old_rctltab, &in_progress_rctltab, 38217c478bd9Sstevel@tonic-gate sizeof (struct zone_rctltab)); 38227c478bd9Sstevel@tonic-gate return; 38237c478bd9Sstevel@tonic-gate case RT_ATTR: 3824bbec428eSgjelinek if ((err = fill_in_attrtab(cmd, &old_attrtab, B_FALSE)) 3825bbec428eSgjelinek != Z_OK) { 3826bbec428eSgjelinek z_cmd_rt_perror(CMD_SELECT, RT_ATTR, err, B_TRUE); 3827bbec428eSgjelinek global_scope = B_TRUE; 38287c478bd9Sstevel@tonic-gate } 38297c478bd9Sstevel@tonic-gate bcopy(&old_attrtab, &in_progress_attrtab, 38307c478bd9Sstevel@tonic-gate sizeof (struct zone_attrtab)); 38317c478bd9Sstevel@tonic-gate return; 3832fa9e4066Sahrens case RT_DATASET: 3833bbec428eSgjelinek if ((err = fill_in_dstab(cmd, &old_dstab, B_FALSE)) != Z_OK) { 3834bbec428eSgjelinek z_cmd_rt_perror(CMD_SELECT, RT_DATASET, err, B_TRUE); 3835bbec428eSgjelinek global_scope = B_TRUE; 3836fa9e4066Sahrens } 3837fa9e4066Sahrens bcopy(&old_dstab, &in_progress_dstab, 3838fa9e4066Sahrens sizeof (struct zone_dstab)); 3839fa9e4066Sahrens return; 38400209230bSgjelinek case RT_DCPU: 38410209230bSgjelinek if ((err = zonecfg_lookup_pset(handle, &old_psettab)) != Z_OK) { 3842bbec428eSgjelinek z_cmd_rt_perror(CMD_SELECT, RT_DCPU, err, B_TRUE); 3843bbec428eSgjelinek global_scope = B_TRUE; 38440209230bSgjelinek } 38450209230bSgjelinek bcopy(&old_psettab, &in_progress_psettab, 38460209230bSgjelinek sizeof (struct zone_psettab)); 38470209230bSgjelinek return; 3848c97ad5cdSakolb case RT_PCAP: 3849c97ad5cdSakolb if ((err = zonecfg_get_aliased_rctl(handle, ALIAS_CPUCAP, &tmp)) 3850c97ad5cdSakolb != Z_OK) { 3851bbec428eSgjelinek z_cmd_rt_perror(CMD_SELECT, RT_PCAP, err, B_TRUE); 3852bbec428eSgjelinek global_scope = B_TRUE; 3853c97ad5cdSakolb } 3854c97ad5cdSakolb return; 38550209230bSgjelinek case RT_MCAP: 38560209230bSgjelinek /* if none of these exist, there is no resource to select */ 38570209230bSgjelinek if ((res = zonecfg_lookup_mcap(handle, &old_mcaptab)) != Z_OK && 38580209230bSgjelinek zonecfg_get_aliased_rctl(handle, ALIAS_MAXSWAP, &limit) 38590209230bSgjelinek != Z_OK && 38600209230bSgjelinek zonecfg_get_aliased_rctl(handle, ALIAS_MAXLOCKEDMEM, &limit) 38610209230bSgjelinek != Z_OK) { 38620209230bSgjelinek z_cmd_rt_perror(CMD_SELECT, RT_MCAP, Z_NO_RESOURCE_TYPE, 3863bbec428eSgjelinek B_TRUE); 3864bbec428eSgjelinek global_scope = B_TRUE; 38650209230bSgjelinek } 38660209230bSgjelinek if (res == Z_OK) 38670209230bSgjelinek bcopy(&old_mcaptab, &in_progress_mcaptab, 38680209230bSgjelinek sizeof (struct zone_mcaptab)); 38690209230bSgjelinek else 38700209230bSgjelinek bzero(&in_progress_mcaptab, 38710209230bSgjelinek sizeof (in_progress_mcaptab)); 38720209230bSgjelinek return; 3873cb8a054bSGlenn Faden case RT_ADMIN: 3874cb8a054bSGlenn Faden if ((err = fill_in_admintab(cmd, &old_admintab, B_FALSE)) 3875cb8a054bSGlenn Faden != Z_OK) { 3876cb8a054bSGlenn Faden z_cmd_rt_perror(CMD_SELECT, RT_ADMIN, err, 3877cb8a054bSGlenn Faden B_TRUE); 3878cb8a054bSGlenn Faden global_scope = B_TRUE; 3879cb8a054bSGlenn Faden } 3880cb8a054bSGlenn Faden bcopy(&old_admintab, &in_progress_admintab, 3881cb8a054bSGlenn Faden sizeof (struct zone_admintab)); 3882cb8a054bSGlenn Faden return; 38837c478bd9Sstevel@tonic-gate default: 3884bbec428eSgjelinek zone_perror(rt_to_str(type), Z_NO_RESOURCE_TYPE, B_TRUE); 3885bbec428eSgjelinek long_usage(CMD_SELECT, B_TRUE); 3886bbec428eSgjelinek usage(B_FALSE, HELP_RESOURCES); 38877c478bd9Sstevel@tonic-gate return; 38887c478bd9Sstevel@tonic-gate } 38897c478bd9Sstevel@tonic-gate } 38907c478bd9Sstevel@tonic-gate 38917c478bd9Sstevel@tonic-gate /* 38927c478bd9Sstevel@tonic-gate * Network "addresses" can be one of the following forms: 38937c478bd9Sstevel@tonic-gate * <IPv4 address> 38947c478bd9Sstevel@tonic-gate * <IPv4 address>/<prefix length> 38957c478bd9Sstevel@tonic-gate * <IPv6 address>/<prefix length> 38967c478bd9Sstevel@tonic-gate * <host name> 38977c478bd9Sstevel@tonic-gate * <host name>/<prefix length> 38987c478bd9Sstevel@tonic-gate * In other words, the "/" followed by a prefix length is allowed but not 38997c478bd9Sstevel@tonic-gate * required for IPv4 addresses and host names, and required for IPv6 addresses. 39007c478bd9Sstevel@tonic-gate * If a prefix length is given, it must be in the allowable range: 0 to 32 for 39017c478bd9Sstevel@tonic-gate * IPv4 addresses and host names, 0 to 128 for IPv6 addresses. 39027c478bd9Sstevel@tonic-gate * Host names must start with an alpha-numeric character, and all subsequent 39037c478bd9Sstevel@tonic-gate * characters must be either alpha-numeric or "-". 39047c478bd9Sstevel@tonic-gate */ 39057c478bd9Sstevel@tonic-gate 39067c478bd9Sstevel@tonic-gate static int 39077c478bd9Sstevel@tonic-gate validate_net_address_syntax(char *address) 39087c478bd9Sstevel@tonic-gate { 39097c478bd9Sstevel@tonic-gate char *slashp, part1[MAXHOSTNAMELEN]; 39107c478bd9Sstevel@tonic-gate struct in6_addr in6; 39117c478bd9Sstevel@tonic-gate struct in_addr in4; 39127c478bd9Sstevel@tonic-gate int prefixlen, i; 39137c478bd9Sstevel@tonic-gate 39147c478bd9Sstevel@tonic-gate /* 39157c478bd9Sstevel@tonic-gate * Copy the part before any '/' into part1 or copy the whole 39167c478bd9Sstevel@tonic-gate * thing if there is no '/'. 39177c478bd9Sstevel@tonic-gate */ 39187c478bd9Sstevel@tonic-gate if ((slashp = strchr(address, '/')) != NULL) { 39197c478bd9Sstevel@tonic-gate *slashp = '\0'; 39207c478bd9Sstevel@tonic-gate (void) strlcpy(part1, address, sizeof (part1)); 39217c478bd9Sstevel@tonic-gate *slashp = '/'; 39227c478bd9Sstevel@tonic-gate prefixlen = atoi(++slashp); 39237c478bd9Sstevel@tonic-gate } else { 39247c478bd9Sstevel@tonic-gate (void) strlcpy(part1, address, sizeof (part1)); 39257c478bd9Sstevel@tonic-gate } 39267c478bd9Sstevel@tonic-gate 39277c478bd9Sstevel@tonic-gate if (inet_pton(AF_INET6, part1, &in6) == 1) { 39287c478bd9Sstevel@tonic-gate if (slashp == NULL) { 39297c478bd9Sstevel@tonic-gate zerr(gettext("%s: IPv6 addresses " 39307c478bd9Sstevel@tonic-gate "require /prefix-length suffix."), address); 39317c478bd9Sstevel@tonic-gate return (Z_ERR); 39327c478bd9Sstevel@tonic-gate } 39337c478bd9Sstevel@tonic-gate if (prefixlen < 0 || prefixlen > 128) { 39347c478bd9Sstevel@tonic-gate zerr(gettext("%s: IPv6 address " 39357c478bd9Sstevel@tonic-gate "prefix lengths must be 0 - 128."), address); 39367c478bd9Sstevel@tonic-gate return (Z_ERR); 39377c478bd9Sstevel@tonic-gate } 39387c478bd9Sstevel@tonic-gate return (Z_OK); 39397c478bd9Sstevel@tonic-gate } 39407c478bd9Sstevel@tonic-gate 39417c478bd9Sstevel@tonic-gate /* At this point, any /prefix must be for IPv4. */ 39427c478bd9Sstevel@tonic-gate if (slashp != NULL) { 39437c478bd9Sstevel@tonic-gate if (prefixlen < 0 || prefixlen > 32) { 39447c478bd9Sstevel@tonic-gate zerr(gettext("%s: IPv4 address " 39457c478bd9Sstevel@tonic-gate "prefix lengths must be 0 - 32."), address); 39467c478bd9Sstevel@tonic-gate return (Z_ERR); 39477c478bd9Sstevel@tonic-gate } 39487c478bd9Sstevel@tonic-gate } 39497c478bd9Sstevel@tonic-gate if (inet_pton(AF_INET, part1, &in4) == 1) 39507c478bd9Sstevel@tonic-gate return (Z_OK); 39517c478bd9Sstevel@tonic-gate 39527c478bd9Sstevel@tonic-gate /* address may also be a host name */ 39537c478bd9Sstevel@tonic-gate if (!isalnum(part1[0])) { 39547c478bd9Sstevel@tonic-gate zerr(gettext("%s: bogus host name or network address syntax"), 39557c478bd9Sstevel@tonic-gate part1); 3956bbec428eSgjelinek saw_error = B_TRUE; 3957bbec428eSgjelinek usage(B_FALSE, HELP_NETADDR); 39587c478bd9Sstevel@tonic-gate return (Z_ERR); 39597c478bd9Sstevel@tonic-gate } 39607c478bd9Sstevel@tonic-gate for (i = 1; part1[i]; i++) 39617c478bd9Sstevel@tonic-gate if (!isalnum(part1[i]) && part1[i] != '-' && part1[i] != '.') { 39627c478bd9Sstevel@tonic-gate zerr(gettext("%s: bogus host name or " 39637c478bd9Sstevel@tonic-gate "network address syntax"), part1); 3964bbec428eSgjelinek saw_error = B_TRUE; 3965bbec428eSgjelinek usage(B_FALSE, HELP_NETADDR); 39667c478bd9Sstevel@tonic-gate return (Z_ERR); 39677c478bd9Sstevel@tonic-gate } 39687c478bd9Sstevel@tonic-gate return (Z_OK); 39697c478bd9Sstevel@tonic-gate } 39707c478bd9Sstevel@tonic-gate 39717c478bd9Sstevel@tonic-gate static int 3972c9f134eaSjv validate_net_physical_syntax(const char *ifname) 39737c478bd9Sstevel@tonic-gate { 3974c9f134eaSjv ifspec_t ifnameprop; 3975c9f134eaSjv zone_iptype_t iptype; 3976c9f134eaSjv 397737b210dcSjv if (zonecfg_get_iptype(handle, &iptype) != Z_OK) { 3978c9f134eaSjv zerr(gettext("zone configuration has an invalid or nonexistent " 3979c9f134eaSjv "ip-type property")); 3980c9f134eaSjv return (Z_ERR); 3981c9f134eaSjv } 3982c9f134eaSjv switch (iptype) { 3983c9f134eaSjv case ZS_SHARED: 3984c9f134eaSjv if (ifparse_ifspec(ifname, &ifnameprop) == B_FALSE) { 3985c9f134eaSjv zerr(gettext("%s: invalid physical interface name"), 3986c9f134eaSjv ifname); 3987c9f134eaSjv return (Z_ERR); 3988c9f134eaSjv } 3989c9f134eaSjv if (ifnameprop.ifsp_lunvalid) { 3990c9f134eaSjv zerr(gettext("%s: LUNs not allowed in physical " 3991c9f134eaSjv "interface names"), ifname); 3992c9f134eaSjv return (Z_ERR); 3993c9f134eaSjv } 3994c9f134eaSjv break; 3995c9f134eaSjv case ZS_EXCLUSIVE: 3996c9f134eaSjv if (dladm_valid_linkname(ifname) == B_FALSE) { 3997c9f134eaSjv if (strchr(ifname, ':') != NULL) 3998c9f134eaSjv zerr(gettext("%s: physical interface name " 3999c9f134eaSjv "required; logical interface name not " 4000c9f134eaSjv "allowed"), ifname); 4001c9f134eaSjv else 4002c9f134eaSjv zerr(gettext("%s: invalid physical interface " 4003c9f134eaSjv "name"), ifname); 4004c9f134eaSjv return (Z_ERR); 4005c9f134eaSjv } 4006c9f134eaSjv break; 4007c9f134eaSjv } 4008c9f134eaSjv return (Z_OK); 40097c478bd9Sstevel@tonic-gate } 40107c478bd9Sstevel@tonic-gate 40117c478bd9Sstevel@tonic-gate static boolean_t 40127c478bd9Sstevel@tonic-gate valid_fs_type(const char *type) 40137c478bd9Sstevel@tonic-gate { 40147c478bd9Sstevel@tonic-gate /* 40157c478bd9Sstevel@tonic-gate * Is this a valid path component? 40167c478bd9Sstevel@tonic-gate */ 40177c478bd9Sstevel@tonic-gate if (strlen(type) + 1 > MAXNAMELEN) 40187c478bd9Sstevel@tonic-gate return (B_FALSE); 40197c478bd9Sstevel@tonic-gate /* 40207c478bd9Sstevel@tonic-gate * Make sure a bad value for "type" doesn't make 40217c478bd9Sstevel@tonic-gate * /usr/lib/fs/<type>/mount turn into something else. 40227c478bd9Sstevel@tonic-gate */ 40237c478bd9Sstevel@tonic-gate if (strchr(type, '/') != NULL || type[0] == '\0' || 40247c478bd9Sstevel@tonic-gate strcmp(type, ".") == 0 || strcmp(type, "..") == 0) 4025087719fdSdp return (B_FALSE); 40267c478bd9Sstevel@tonic-gate /* 40277c478bd9Sstevel@tonic-gate * More detailed verification happens later by zoneadm(1m). 40287c478bd9Sstevel@tonic-gate */ 40297c478bd9Sstevel@tonic-gate return (B_TRUE); 40307c478bd9Sstevel@tonic-gate } 40317c478bd9Sstevel@tonic-gate 4032f4b3ec61Sdh static boolean_t 4033f4b3ec61Sdh allow_exclusive() 4034f4b3ec61Sdh { 4035f4b3ec61Sdh brand_handle_t bh; 4036f4b3ec61Sdh char brand[MAXNAMELEN]; 4037f4b3ec61Sdh boolean_t ret; 4038f4b3ec61Sdh 4039f4b3ec61Sdh if (zonecfg_get_brand(handle, brand, sizeof (brand)) != Z_OK) { 4040f4b3ec61Sdh zerr("%s: %s\n", zone, gettext("could not get zone brand")); 4041f4b3ec61Sdh return (B_FALSE); 4042f4b3ec61Sdh } 4043f4b3ec61Sdh if ((bh = brand_open(brand)) == NULL) { 4044f4b3ec61Sdh zerr("%s: %s\n", zone, gettext("unknown brand.")); 4045f4b3ec61Sdh return (B_FALSE); 4046f4b3ec61Sdh } 4047f4b3ec61Sdh ret = brand_allow_exclusive_ip(bh); 4048f4b3ec61Sdh brand_close(bh); 4049f4b3ec61Sdh if (!ret) 4050f4b3ec61Sdh zerr(gettext("%s cannot be '%s' when %s is '%s'."), 4051f4b3ec61Sdh pt_to_str(PT_IPTYPE), "exclusive", 4052f4b3ec61Sdh pt_to_str(PT_BRAND), brand); 4053f4b3ec61Sdh return (ret); 4054f4b3ec61Sdh } 4055f4b3ec61Sdh 40560209230bSgjelinek static void 40570209230bSgjelinek set_aliased_rctl(char *alias, int prop_type, char *s) 40580209230bSgjelinek { 40590209230bSgjelinek uint64_t limit; 40600209230bSgjelinek int err; 40610209230bSgjelinek char tmp[128]; 40620209230bSgjelinek 40630209230bSgjelinek if (global_zone && strcmp(alias, ALIAS_SHARES) != 0) 40640209230bSgjelinek zerr(gettext("WARNING: Setting a global zone resource " 40650209230bSgjelinek "control too low could deny\nservice " 40660209230bSgjelinek "to even the root user; " 40670209230bSgjelinek "this could render the system impossible\n" 40680209230bSgjelinek "to administer. Please use caution.")); 40690209230bSgjelinek 40700209230bSgjelinek /* convert memory based properties */ 40710209230bSgjelinek if (prop_type == PT_MAXSHMMEM) { 40720209230bSgjelinek if (!zonecfg_valid_memlimit(s, &limit)) { 40730209230bSgjelinek zerr(gettext("A non-negative number with a required " 40740209230bSgjelinek "scale suffix (K, M, G or T) was expected\nhere.")); 4075bbec428eSgjelinek saw_error = B_TRUE; 40760209230bSgjelinek return; 40770209230bSgjelinek } 40780209230bSgjelinek 40790209230bSgjelinek (void) snprintf(tmp, sizeof (tmp), "%llu", limit); 40800209230bSgjelinek s = tmp; 40810209230bSgjelinek } 40820209230bSgjelinek 40830209230bSgjelinek if (!zonecfg_aliased_rctl_ok(handle, alias)) { 4084bbec428eSgjelinek zone_perror(pt_to_str(prop_type), Z_ALIAS_DISALLOW, B_FALSE); 4085bbec428eSgjelinek saw_error = B_TRUE; 40860209230bSgjelinek } else if (!zonecfg_valid_alias_limit(alias, s, &limit)) { 40870209230bSgjelinek zerr(gettext("%s property is out of range."), 40880209230bSgjelinek pt_to_str(prop_type)); 4089bbec428eSgjelinek saw_error = B_TRUE; 40900209230bSgjelinek } else if ((err = zonecfg_set_aliased_rctl(handle, alias, limit)) 40910209230bSgjelinek != Z_OK) { 4092bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 4093bbec428eSgjelinek saw_error = B_TRUE; 40940209230bSgjelinek } else { 4095bbec428eSgjelinek need_to_commit = B_TRUE; 40960209230bSgjelinek } 40970209230bSgjelinek } 40980209230bSgjelinek 40997c478bd9Sstevel@tonic-gate void 41007c478bd9Sstevel@tonic-gate set_func(cmd_t *cmd) 41017c478bd9Sstevel@tonic-gate { 41027c478bd9Sstevel@tonic-gate char *prop_id; 4103555afedfScarlsonj int arg, err, res_type, prop_type; 41047c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 41057c478bd9Sstevel@tonic-gate boolean_t autoboot; 4106f4b3ec61Sdh zone_iptype_t iptype; 4107bbec428eSgjelinek boolean_t force_set = B_FALSE; 41080209230bSgjelinek size_t physmem_size = sizeof (in_progress_mcaptab.zone_physmem_cap); 41090209230bSgjelinek uint64_t mem_cap, mem_limit; 4110c97ad5cdSakolb float cap; 4111c97ad5cdSakolb char *unitp; 41120209230bSgjelinek struct zone_psettab tmp_psettab; 4113bbec428eSgjelinek boolean_t arg_err = B_FALSE; 41147c478bd9Sstevel@tonic-gate 41157c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_SET)) 41167c478bd9Sstevel@tonic-gate return; 41177c478bd9Sstevel@tonic-gate 41187c478bd9Sstevel@tonic-gate assert(cmd != NULL); 41197c478bd9Sstevel@tonic-gate 4120555afedfScarlsonj optind = opterr = 0; 4121555afedfScarlsonj while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "F")) != EOF) { 4122555afedfScarlsonj switch (arg) { 4123555afedfScarlsonj case 'F': 4124bbec428eSgjelinek force_set = B_TRUE; 4125555afedfScarlsonj break; 4126555afedfScarlsonj default: 4127555afedfScarlsonj if (optopt == '?') 4128555afedfScarlsonj longer_usage(CMD_SET); 4129555afedfScarlsonj else 4130555afedfScarlsonj short_usage(CMD_SET); 4131bbec428eSgjelinek arg_err = B_TRUE; 41327ec75eb8Sgjelinek break; 4133555afedfScarlsonj } 4134555afedfScarlsonj } 41357ec75eb8Sgjelinek if (arg_err) 41367ec75eb8Sgjelinek return; 4137555afedfScarlsonj 41387c478bd9Sstevel@tonic-gate prop_type = cmd->cmd_prop_name[0]; 41397c478bd9Sstevel@tonic-gate if (global_scope) { 41400209230bSgjelinek if (gz_invalid_property(prop_type)) { 41410209230bSgjelinek zerr(gettext("%s is not a valid property for the " 41420209230bSgjelinek "global zone."), pt_to_str(prop_type)); 4143bbec428eSgjelinek saw_error = B_TRUE; 41440209230bSgjelinek return; 41450209230bSgjelinek } 41460209230bSgjelinek 4147087719fdSdp if (prop_type == PT_ZONENAME) { 4148087719fdSdp res_type = RT_ZONENAME; 4149087719fdSdp } else if (prop_type == PT_ZONEPATH) { 41507c478bd9Sstevel@tonic-gate res_type = RT_ZONEPATH; 41517c478bd9Sstevel@tonic-gate } else if (prop_type == PT_AUTOBOOT) { 41527c478bd9Sstevel@tonic-gate res_type = RT_AUTOBOOT; 41539acbbeafSnn } else if (prop_type == PT_BRAND) { 41549acbbeafSnn res_type = RT_BRAND; 41557c478bd9Sstevel@tonic-gate } else if (prop_type == PT_POOL) { 41567c478bd9Sstevel@tonic-gate res_type = RT_POOL; 4157ffbafc53Scomay } else if (prop_type == PT_LIMITPRIV) { 4158ffbafc53Scomay res_type = RT_LIMITPRIV; 41593f2f09c1Sdp } else if (prop_type == PT_BOOTARGS) { 41603f2f09c1Sdp res_type = RT_BOOTARGS; 41610209230bSgjelinek } else if (prop_type == PT_SCHED) { 41620209230bSgjelinek res_type = RT_SCHED; 4163f4b3ec61Sdh } else if (prop_type == PT_IPTYPE) { 4164f4b3ec61Sdh res_type = RT_IPTYPE; 41650209230bSgjelinek } else if (prop_type == PT_MAXLWPS) { 41660209230bSgjelinek res_type = RT_MAXLWPS; 4167*ff19e029SMenno Lageman } else if (prop_type == PT_MAXPROCS) { 4168*ff19e029SMenno Lageman res_type = RT_MAXPROCS; 41690209230bSgjelinek } else if (prop_type == PT_MAXSHMMEM) { 41700209230bSgjelinek res_type = RT_MAXSHMMEM; 41710209230bSgjelinek } else if (prop_type == PT_MAXSHMIDS) { 41720209230bSgjelinek res_type = RT_MAXSHMIDS; 41730209230bSgjelinek } else if (prop_type == PT_MAXMSGIDS) { 41740209230bSgjelinek res_type = RT_MAXMSGIDS; 41750209230bSgjelinek } else if (prop_type == PT_MAXSEMIDS) { 41760209230bSgjelinek res_type = RT_MAXSEMIDS; 41770209230bSgjelinek } else if (prop_type == PT_SHARES) { 41780209230bSgjelinek res_type = RT_SHARES; 41795679c89fSjv } else if (prop_type == PT_HOSTID) { 41805679c89fSjv res_type = RT_HOSTID; 41810fbb751dSJohn Levon } else if (prop_type == PT_FS_ALLOWED) { 41820fbb751dSJohn Levon res_type = RT_FS_ALLOWED; 41837c478bd9Sstevel@tonic-gate } else { 41847c478bd9Sstevel@tonic-gate zerr(gettext("Cannot set a resource-specific property " 41857c478bd9Sstevel@tonic-gate "from the global scope.")); 4186bbec428eSgjelinek saw_error = B_TRUE; 41877c478bd9Sstevel@tonic-gate return; 41887c478bd9Sstevel@tonic-gate } 41897c478bd9Sstevel@tonic-gate } else { 41907c478bd9Sstevel@tonic-gate res_type = resource_scope; 41917c478bd9Sstevel@tonic-gate } 41927c478bd9Sstevel@tonic-gate 4193555afedfScarlsonj if (force_set) { 4194555afedfScarlsonj if (res_type != RT_ZONEPATH) { 4195555afedfScarlsonj zerr(gettext("Only zonepath setting can be forced.")); 4196bbec428eSgjelinek saw_error = B_TRUE; 4197555afedfScarlsonj return; 4198555afedfScarlsonj } 4199555afedfScarlsonj if (!zonecfg_in_alt_root()) { 4200555afedfScarlsonj zerr(gettext("Zonepath is changeable only in an " 4201555afedfScarlsonj "alternate root.")); 4202bbec428eSgjelinek saw_error = B_TRUE; 4203555afedfScarlsonj return; 4204555afedfScarlsonj } 4205555afedfScarlsonj } 4206555afedfScarlsonj 42077c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[0]; 42087c478bd9Sstevel@tonic-gate /* 42097c478bd9Sstevel@tonic-gate * A nasty expression but not that complicated: 42107c478bd9Sstevel@tonic-gate * 1. fs options are simple or list (tested below) 42117c478bd9Sstevel@tonic-gate * 2. rctl value's are complex or list (tested below) 42127c478bd9Sstevel@tonic-gate * Anything else should be simple. 42137c478bd9Sstevel@tonic-gate */ 42147c478bd9Sstevel@tonic-gate if (!(res_type == RT_FS && prop_type == PT_OPTIONS) && 42157c478bd9Sstevel@tonic-gate !(res_type == RT_RCTL && prop_type == PT_VALUE) && 42167c478bd9Sstevel@tonic-gate (pp->pv_type != PROP_VAL_SIMPLE || 42177c478bd9Sstevel@tonic-gate (prop_id = pp->pv_simple) == NULL)) { 42187c478bd9Sstevel@tonic-gate zerr(gettext("A %s value was expected here."), 42197c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_SIMPLE)); 4220bbec428eSgjelinek saw_error = B_TRUE; 42217c478bd9Sstevel@tonic-gate return; 42227c478bd9Sstevel@tonic-gate } 42237c478bd9Sstevel@tonic-gate if (prop_type == PT_UNKNOWN) { 4224bbec428eSgjelinek long_usage(CMD_SET, B_TRUE); 42257c478bd9Sstevel@tonic-gate return; 42267c478bd9Sstevel@tonic-gate } 42277c478bd9Sstevel@tonic-gate 4228087719fdSdp /* 4229087719fdSdp * Special case: the user can change the zone name prior to 'create'; 4230087719fdSdp * if the zone already exists, we fall through letting initialize() 4231087719fdSdp * and the rest of the logic run. 4232087719fdSdp */ 4233bbec428eSgjelinek if (res_type == RT_ZONENAME && got_handle == B_FALSE && 4234087719fdSdp !state_atleast(ZONE_STATE_CONFIGURED)) { 4235fb03efaaSdp if ((err = zonecfg_validate_zonename(prop_id)) != Z_OK) { 4236bbec428eSgjelinek zone_perror(prop_id, err, B_TRUE); 4237bbec428eSgjelinek usage(B_FALSE, HELP_SYNTAX); 4238fb03efaaSdp return; 4239fb03efaaSdp } 4240087719fdSdp (void) strlcpy(zone, prop_id, sizeof (zone)); 4241087719fdSdp return; 4242087719fdSdp } 4243087719fdSdp 4244bbec428eSgjelinek if (initialize(B_TRUE) != Z_OK) 42457c478bd9Sstevel@tonic-gate return; 42467c478bd9Sstevel@tonic-gate 42477c478bd9Sstevel@tonic-gate switch (res_type) { 4248087719fdSdp case RT_ZONENAME: 4249087719fdSdp if ((err = zonecfg_set_name(handle, prop_id)) != Z_OK) { 4250087719fdSdp /* 4251087719fdSdp * Use prop_id instead of 'zone' here, since we're 4252087719fdSdp * reporting a problem about the *new* zonename. 4253087719fdSdp */ 4254bbec428eSgjelinek zone_perror(prop_id, err, B_TRUE); 4255bbec428eSgjelinek usage(B_FALSE, HELP_SYNTAX); 4256087719fdSdp } else { 4257bbec428eSgjelinek need_to_commit = B_TRUE; 4258087719fdSdp (void) strlcpy(zone, prop_id, sizeof (zone)); 4259087719fdSdp } 4260087719fdSdp return; 42617c478bd9Sstevel@tonic-gate case RT_ZONEPATH: 4262555afedfScarlsonj if (!force_set && state_atleast(ZONE_STATE_INSTALLED)) { 42637c478bd9Sstevel@tonic-gate zerr(gettext("Zone %s already installed; %s %s not " 42647c478bd9Sstevel@tonic-gate "allowed."), zone, cmd_to_str(CMD_SET), 42657c478bd9Sstevel@tonic-gate rt_to_str(RT_ZONEPATH)); 42667c478bd9Sstevel@tonic-gate return; 42677c478bd9Sstevel@tonic-gate } 42687c478bd9Sstevel@tonic-gate if (validate_zonepath_syntax(prop_id) != Z_OK) { 4269bbec428eSgjelinek saw_error = B_TRUE; 42707c478bd9Sstevel@tonic-gate return; 42717c478bd9Sstevel@tonic-gate } 42727c478bd9Sstevel@tonic-gate if ((err = zonecfg_set_zonepath(handle, prop_id)) != Z_OK) 4273bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 42747c478bd9Sstevel@tonic-gate else 4275bbec428eSgjelinek need_to_commit = B_TRUE; 42767c478bd9Sstevel@tonic-gate return; 42779acbbeafSnn case RT_BRAND: 42789acbbeafSnn if (state_atleast(ZONE_STATE_INSTALLED)) { 42799acbbeafSnn zerr(gettext("Zone %s already installed; %s %s not " 42809acbbeafSnn "allowed."), zone, cmd_to_str(CMD_SET), 42819acbbeafSnn rt_to_str(RT_BRAND)); 42829acbbeafSnn return; 42839acbbeafSnn } 42849acbbeafSnn if ((err = zonecfg_set_brand(handle, prop_id)) != Z_OK) 4285bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 42869acbbeafSnn else 4287bbec428eSgjelinek need_to_commit = B_TRUE; 42889acbbeafSnn return; 42897c478bd9Sstevel@tonic-gate case RT_AUTOBOOT: 42907c478bd9Sstevel@tonic-gate if (strcmp(prop_id, "true") == 0) { 42917c478bd9Sstevel@tonic-gate autoboot = B_TRUE; 42927c478bd9Sstevel@tonic-gate } else if (strcmp(prop_id, "false") == 0) { 42937c478bd9Sstevel@tonic-gate autoboot = B_FALSE; 42947c478bd9Sstevel@tonic-gate } else { 42957c478bd9Sstevel@tonic-gate zerr(gettext("%s value must be '%s' or '%s'."), 42967c478bd9Sstevel@tonic-gate pt_to_str(PT_AUTOBOOT), "true", "false"); 4297bbec428eSgjelinek saw_error = B_TRUE; 42987c478bd9Sstevel@tonic-gate return; 42997c478bd9Sstevel@tonic-gate } 43007c478bd9Sstevel@tonic-gate if ((err = zonecfg_set_autoboot(handle, autoboot)) != Z_OK) 4301bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 43027c478bd9Sstevel@tonic-gate else 4303bbec428eSgjelinek need_to_commit = B_TRUE; 43047c478bd9Sstevel@tonic-gate return; 43057c478bd9Sstevel@tonic-gate case RT_POOL: 43060209230bSgjelinek /* don't allow use of the reserved temporary pool names */ 43070209230bSgjelinek if (strncmp("SUNW", prop_id, 4) == 0) { 43080209230bSgjelinek zerr(gettext("pool names starting with SUNW are " 43090209230bSgjelinek "reserved.")); 4310bbec428eSgjelinek saw_error = B_TRUE; 43110209230bSgjelinek return; 43120209230bSgjelinek } 43130209230bSgjelinek 43140209230bSgjelinek /* can't set pool if dedicated-cpu exists */ 43150209230bSgjelinek if (zonecfg_lookup_pset(handle, &tmp_psettab) == Z_OK) { 43160209230bSgjelinek zerr(gettext("The %s resource already exists. " 43170209230bSgjelinek "A persistent pool is incompatible\nwith the %s " 43180209230bSgjelinek "resource."), rt_to_str(RT_DCPU), 43190209230bSgjelinek rt_to_str(RT_DCPU)); 4320bbec428eSgjelinek saw_error = B_TRUE; 43210209230bSgjelinek return; 43220209230bSgjelinek } 43230209230bSgjelinek 43247c478bd9Sstevel@tonic-gate if ((err = zonecfg_set_pool(handle, prop_id)) != Z_OK) 4325bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 43267c478bd9Sstevel@tonic-gate else 4327bbec428eSgjelinek need_to_commit = B_TRUE; 43287c478bd9Sstevel@tonic-gate return; 4329ffbafc53Scomay case RT_LIMITPRIV: 4330ffbafc53Scomay if ((err = zonecfg_set_limitpriv(handle, prop_id)) != Z_OK) 4331bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 4332ffbafc53Scomay else 4333bbec428eSgjelinek need_to_commit = B_TRUE; 4334ffbafc53Scomay return; 43353f2f09c1Sdp case RT_BOOTARGS: 43363f2f09c1Sdp if ((err = zonecfg_set_bootargs(handle, prop_id)) != Z_OK) 4337bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 43383f2f09c1Sdp else 4339bbec428eSgjelinek need_to_commit = B_TRUE; 43403f2f09c1Sdp return; 43410209230bSgjelinek case RT_SCHED: 43420209230bSgjelinek if ((err = zonecfg_set_sched(handle, prop_id)) != Z_OK) 4343bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 43440209230bSgjelinek else 4345bbec428eSgjelinek need_to_commit = B_TRUE; 43460209230bSgjelinek return; 4347f4b3ec61Sdh case RT_IPTYPE: 4348f4b3ec61Sdh if (strcmp(prop_id, "shared") == 0) { 4349f4b3ec61Sdh iptype = ZS_SHARED; 4350f4b3ec61Sdh } else if (strcmp(prop_id, "exclusive") == 0) { 4351f4b3ec61Sdh iptype = ZS_EXCLUSIVE; 4352f4b3ec61Sdh } else { 4353f4b3ec61Sdh zerr(gettext("%s value must be '%s' or '%s'."), 4354f4b3ec61Sdh pt_to_str(PT_IPTYPE), "shared", "exclusive"); 4355bbec428eSgjelinek saw_error = B_TRUE; 4356f4b3ec61Sdh return; 4357f4b3ec61Sdh } 4358f4b3ec61Sdh if (iptype == ZS_EXCLUSIVE && !allow_exclusive()) { 4359bbec428eSgjelinek saw_error = B_TRUE; 4360f4b3ec61Sdh return; 4361f4b3ec61Sdh } 4362f4b3ec61Sdh if ((err = zonecfg_set_iptype(handle, iptype)) != Z_OK) 4363bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 4364f4b3ec61Sdh else 4365bbec428eSgjelinek need_to_commit = B_TRUE; 4366f4b3ec61Sdh return; 43670209230bSgjelinek case RT_MAXLWPS: 43680209230bSgjelinek set_aliased_rctl(ALIAS_MAXLWPS, prop_type, prop_id); 43690209230bSgjelinek return; 4370*ff19e029SMenno Lageman case RT_MAXPROCS: 4371*ff19e029SMenno Lageman set_aliased_rctl(ALIAS_MAXPROCS, prop_type, prop_id); 4372*ff19e029SMenno Lageman return; 43730209230bSgjelinek case RT_MAXSHMMEM: 43740209230bSgjelinek set_aliased_rctl(ALIAS_MAXSHMMEM, prop_type, prop_id); 43750209230bSgjelinek return; 43760209230bSgjelinek case RT_MAXSHMIDS: 43770209230bSgjelinek set_aliased_rctl(ALIAS_MAXSHMIDS, prop_type, prop_id); 43780209230bSgjelinek return; 43790209230bSgjelinek case RT_MAXMSGIDS: 43800209230bSgjelinek set_aliased_rctl(ALIAS_MAXMSGIDS, prop_type, prop_id); 43810209230bSgjelinek return; 43820209230bSgjelinek case RT_MAXSEMIDS: 43830209230bSgjelinek set_aliased_rctl(ALIAS_MAXSEMIDS, prop_type, prop_id); 43840209230bSgjelinek return; 43850209230bSgjelinek case RT_SHARES: 43860209230bSgjelinek set_aliased_rctl(ALIAS_SHARES, prop_type, prop_id); 43870209230bSgjelinek return; 43885679c89fSjv case RT_HOSTID: 43895679c89fSjv if ((err = zonecfg_set_hostid(handle, prop_id)) != Z_OK) { 43905679c89fSjv if (err == Z_TOO_BIG) { 43915679c89fSjv zerr(gettext("hostid string is too large: %s"), 43925679c89fSjv prop_id); 43935679c89fSjv saw_error = B_TRUE; 43945679c89fSjv } else { 43955679c89fSjv zone_perror(pt_to_str(prop_type), err, B_TRUE); 43965679c89fSjv } 43975679c89fSjv return; 43985679c89fSjv } 43995679c89fSjv need_to_commit = B_TRUE; 44005679c89fSjv return; 44010fbb751dSJohn Levon case RT_FS_ALLOWED: 44020fbb751dSJohn Levon if ((err = zonecfg_set_fs_allowed(handle, prop_id)) != Z_OK) 44030fbb751dSJohn Levon zone_perror(zone, err, B_TRUE); 44040fbb751dSJohn Levon else 44050fbb751dSJohn Levon need_to_commit = B_TRUE; 44060fbb751dSJohn Levon return; 44077c478bd9Sstevel@tonic-gate case RT_FS: 44087c478bd9Sstevel@tonic-gate switch (prop_type) { 44097c478bd9Sstevel@tonic-gate case PT_DIR: 44107c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_fstab.zone_fs_dir, prop_id, 44117c478bd9Sstevel@tonic-gate sizeof (in_progress_fstab.zone_fs_dir)); 44127c478bd9Sstevel@tonic-gate return; 44137c478bd9Sstevel@tonic-gate case PT_SPECIAL: 44147c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_fstab.zone_fs_special, 44157c478bd9Sstevel@tonic-gate prop_id, 44167c478bd9Sstevel@tonic-gate sizeof (in_progress_fstab.zone_fs_special)); 44177c478bd9Sstevel@tonic-gate return; 44187c478bd9Sstevel@tonic-gate case PT_RAW: 44197c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_fstab.zone_fs_raw, 44207c478bd9Sstevel@tonic-gate prop_id, sizeof (in_progress_fstab.zone_fs_raw)); 44217c478bd9Sstevel@tonic-gate return; 44227c478bd9Sstevel@tonic-gate case PT_TYPE: 44237c478bd9Sstevel@tonic-gate if (!valid_fs_type(prop_id)) { 44247c478bd9Sstevel@tonic-gate zerr(gettext("\"%s\" is not a valid %s."), 44257c478bd9Sstevel@tonic-gate prop_id, pt_to_str(PT_TYPE)); 4426bbec428eSgjelinek saw_error = B_TRUE; 44277c478bd9Sstevel@tonic-gate return; 44287c478bd9Sstevel@tonic-gate } 44297c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_fstab.zone_fs_type, prop_id, 44307c478bd9Sstevel@tonic-gate sizeof (in_progress_fstab.zone_fs_type)); 44317c478bd9Sstevel@tonic-gate return; 44327c478bd9Sstevel@tonic-gate case PT_OPTIONS: 44337c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE && 44347c478bd9Sstevel@tonic-gate pp->pv_type != PROP_VAL_LIST) { 44357c478bd9Sstevel@tonic-gate zerr(gettext("A %s or %s value was expected " 44367c478bd9Sstevel@tonic-gate "here."), pvt_to_str(PROP_VAL_SIMPLE), 44377c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_LIST)); 4438bbec428eSgjelinek saw_error = B_TRUE; 44397c478bd9Sstevel@tonic-gate return; 44407c478bd9Sstevel@tonic-gate } 44417c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list( 44427c478bd9Sstevel@tonic-gate in_progress_fstab.zone_fs_options); 44437c478bd9Sstevel@tonic-gate in_progress_fstab.zone_fs_options = NULL; 44447c478bd9Sstevel@tonic-gate if (!(pp->pv_type == PROP_VAL_LIST && 44457c478bd9Sstevel@tonic-gate pp->pv_list == NULL)) 44467c478bd9Sstevel@tonic-gate add_property(cmd); 44477c478bd9Sstevel@tonic-gate return; 44487c478bd9Sstevel@tonic-gate default: 44497c478bd9Sstevel@tonic-gate break; 44507c478bd9Sstevel@tonic-gate } 4451bbec428eSgjelinek zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, B_TRUE); 4452bbec428eSgjelinek long_usage(CMD_SET, B_TRUE); 4453bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 44547c478bd9Sstevel@tonic-gate return; 44557c478bd9Sstevel@tonic-gate case RT_IPD: 44567c478bd9Sstevel@tonic-gate switch (prop_type) { 44577c478bd9Sstevel@tonic-gate case PT_DIR: 44587c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_ipdtab.zone_fs_dir, prop_id, 44597c478bd9Sstevel@tonic-gate sizeof (in_progress_ipdtab.zone_fs_dir)); 44607c478bd9Sstevel@tonic-gate return; 44617c478bd9Sstevel@tonic-gate default: 44627c478bd9Sstevel@tonic-gate break; 44637c478bd9Sstevel@tonic-gate } 4464bbec428eSgjelinek zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, B_TRUE); 4465bbec428eSgjelinek long_usage(CMD_SET, B_TRUE); 4466bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 44677c478bd9Sstevel@tonic-gate return; 44687c478bd9Sstevel@tonic-gate case RT_NET: 44697c478bd9Sstevel@tonic-gate switch (prop_type) { 44707c478bd9Sstevel@tonic-gate case PT_ADDRESS: 44717c478bd9Sstevel@tonic-gate if (validate_net_address_syntax(prop_id) != Z_OK) { 4472bbec428eSgjelinek saw_error = B_TRUE; 44737c478bd9Sstevel@tonic-gate return; 44747c478bd9Sstevel@tonic-gate } 44757c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_nwiftab.zone_nwif_address, 44767c478bd9Sstevel@tonic-gate prop_id, 44777c478bd9Sstevel@tonic-gate sizeof (in_progress_nwiftab.zone_nwif_address)); 44787c478bd9Sstevel@tonic-gate break; 44797c478bd9Sstevel@tonic-gate case PT_PHYSICAL: 44807c478bd9Sstevel@tonic-gate if (validate_net_physical_syntax(prop_id) != Z_OK) { 4481bbec428eSgjelinek saw_error = B_TRUE; 44827c478bd9Sstevel@tonic-gate return; 44837c478bd9Sstevel@tonic-gate } 44847c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_nwiftab.zone_nwif_physical, 44857c478bd9Sstevel@tonic-gate prop_id, 44867c478bd9Sstevel@tonic-gate sizeof (in_progress_nwiftab.zone_nwif_physical)); 44877c478bd9Sstevel@tonic-gate break; 4488de860bd9Sgfaden case PT_DEFROUTER: 4489de860bd9Sgfaden if (validate_net_address_syntax(prop_id) != Z_OK) { 4490bbec428eSgjelinek saw_error = B_TRUE; 4491de860bd9Sgfaden return; 4492de860bd9Sgfaden } 4493de860bd9Sgfaden (void) strlcpy(in_progress_nwiftab.zone_nwif_defrouter, 4494de860bd9Sgfaden prop_id, 4495de860bd9Sgfaden sizeof (in_progress_nwiftab.zone_nwif_defrouter)); 4496de860bd9Sgfaden break; 44977c478bd9Sstevel@tonic-gate default: 44987c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 4499bbec428eSgjelinek B_TRUE); 4500bbec428eSgjelinek long_usage(CMD_SET, B_TRUE); 4501bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 45027c478bd9Sstevel@tonic-gate return; 45037c478bd9Sstevel@tonic-gate } 45047c478bd9Sstevel@tonic-gate return; 45057c478bd9Sstevel@tonic-gate case RT_DEVICE: 45067c478bd9Sstevel@tonic-gate switch (prop_type) { 45077c478bd9Sstevel@tonic-gate case PT_MATCH: 45087c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_devtab.zone_dev_match, 45097c478bd9Sstevel@tonic-gate prop_id, 45107c478bd9Sstevel@tonic-gate sizeof (in_progress_devtab.zone_dev_match)); 45117c478bd9Sstevel@tonic-gate break; 45127c478bd9Sstevel@tonic-gate default: 45137c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 4514bbec428eSgjelinek B_TRUE); 4515bbec428eSgjelinek long_usage(CMD_SET, B_TRUE); 4516bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 45177c478bd9Sstevel@tonic-gate return; 45187c478bd9Sstevel@tonic-gate } 45197c478bd9Sstevel@tonic-gate return; 45207c478bd9Sstevel@tonic-gate case RT_RCTL: 45217c478bd9Sstevel@tonic-gate switch (prop_type) { 45227c478bd9Sstevel@tonic-gate case PT_NAME: 45237c478bd9Sstevel@tonic-gate if (!zonecfg_valid_rctlname(prop_id)) { 45247c478bd9Sstevel@tonic-gate zerr(gettext("'%s' is not a valid zone %s " 45257c478bd9Sstevel@tonic-gate "name."), prop_id, rt_to_str(RT_RCTL)); 45267c478bd9Sstevel@tonic-gate return; 45277c478bd9Sstevel@tonic-gate } 45287c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_rctltab.zone_rctl_name, 45297c478bd9Sstevel@tonic-gate prop_id, 45307c478bd9Sstevel@tonic-gate sizeof (in_progress_rctltab.zone_rctl_name)); 45317c478bd9Sstevel@tonic-gate break; 45327c478bd9Sstevel@tonic-gate case PT_VALUE: 45337c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_COMPLEX && 45347c478bd9Sstevel@tonic-gate pp->pv_type != PROP_VAL_LIST) { 45357c478bd9Sstevel@tonic-gate zerr(gettext("A %s or %s value was expected " 45367c478bd9Sstevel@tonic-gate "here."), pvt_to_str(PROP_VAL_COMPLEX), 45377c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_LIST)); 4538bbec428eSgjelinek saw_error = B_TRUE; 45397c478bd9Sstevel@tonic-gate return; 45407c478bd9Sstevel@tonic-gate } 45417c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list( 45427c478bd9Sstevel@tonic-gate in_progress_rctltab.zone_rctl_valptr); 45437c478bd9Sstevel@tonic-gate in_progress_rctltab.zone_rctl_valptr = NULL; 45447c478bd9Sstevel@tonic-gate if (!(pp->pv_type == PROP_VAL_LIST && 45457c478bd9Sstevel@tonic-gate pp->pv_list == NULL)) 45467c478bd9Sstevel@tonic-gate add_property(cmd); 45477c478bd9Sstevel@tonic-gate break; 45487c478bd9Sstevel@tonic-gate default: 45497c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 4550bbec428eSgjelinek B_TRUE); 4551bbec428eSgjelinek long_usage(CMD_SET, B_TRUE); 4552bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 45537c478bd9Sstevel@tonic-gate return; 45547c478bd9Sstevel@tonic-gate } 45557c478bd9Sstevel@tonic-gate return; 45567c478bd9Sstevel@tonic-gate case RT_ATTR: 45577c478bd9Sstevel@tonic-gate switch (prop_type) { 45587c478bd9Sstevel@tonic-gate case PT_NAME: 45597c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_attrtab.zone_attr_name, 45607c478bd9Sstevel@tonic-gate prop_id, 45617c478bd9Sstevel@tonic-gate sizeof (in_progress_attrtab.zone_attr_name)); 45627c478bd9Sstevel@tonic-gate break; 45637c478bd9Sstevel@tonic-gate case PT_TYPE: 45647c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_attrtab.zone_attr_type, 45657c478bd9Sstevel@tonic-gate prop_id, 45667c478bd9Sstevel@tonic-gate sizeof (in_progress_attrtab.zone_attr_type)); 45677c478bd9Sstevel@tonic-gate break; 45687c478bd9Sstevel@tonic-gate case PT_VALUE: 45697c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_attrtab.zone_attr_value, 45707c478bd9Sstevel@tonic-gate prop_id, 45717c478bd9Sstevel@tonic-gate sizeof (in_progress_attrtab.zone_attr_value)); 45727c478bd9Sstevel@tonic-gate break; 45737c478bd9Sstevel@tonic-gate default: 45747c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 4575bbec428eSgjelinek B_TRUE); 4576bbec428eSgjelinek long_usage(CMD_SET, B_TRUE); 4577bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 45787c478bd9Sstevel@tonic-gate return; 45797c478bd9Sstevel@tonic-gate } 45807c478bd9Sstevel@tonic-gate return; 4581fa9e4066Sahrens case RT_DATASET: 4582fa9e4066Sahrens switch (prop_type) { 4583fa9e4066Sahrens case PT_NAME: 4584fa9e4066Sahrens (void) strlcpy(in_progress_dstab.zone_dataset_name, 4585fa9e4066Sahrens prop_id, 4586fa9e4066Sahrens sizeof (in_progress_dstab.zone_dataset_name)); 4587fa9e4066Sahrens return; 4588fa9e4066Sahrens default: 4589fa9e4066Sahrens break; 4590fa9e4066Sahrens } 4591bbec428eSgjelinek zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, B_TRUE); 4592bbec428eSgjelinek long_usage(CMD_SET, B_TRUE); 4593bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 45940209230bSgjelinek return; 45950209230bSgjelinek case RT_DCPU: 45960209230bSgjelinek switch (prop_type) { 45970209230bSgjelinek char *lowp, *highp; 45980209230bSgjelinek 45990209230bSgjelinek case PT_NCPUS: 46000209230bSgjelinek lowp = prop_id; 46010209230bSgjelinek if ((highp = strchr(prop_id, '-')) != NULL) 46020209230bSgjelinek *highp++ = '\0'; 46030209230bSgjelinek else 46040209230bSgjelinek highp = lowp; 46050209230bSgjelinek 46060209230bSgjelinek /* Make sure the input makes sense. */ 46070209230bSgjelinek if (!zonecfg_valid_ncpus(lowp, highp)) { 46080209230bSgjelinek zerr(gettext("%s property is out of range."), 46090209230bSgjelinek pt_to_str(PT_NCPUS)); 4610bbec428eSgjelinek saw_error = B_TRUE; 46110209230bSgjelinek return; 46120209230bSgjelinek } 46130209230bSgjelinek 46140209230bSgjelinek (void) strlcpy( 46150209230bSgjelinek in_progress_psettab.zone_ncpu_min, lowp, 46160209230bSgjelinek sizeof (in_progress_psettab.zone_ncpu_min)); 46170209230bSgjelinek (void) strlcpy( 46180209230bSgjelinek in_progress_psettab.zone_ncpu_max, highp, 46190209230bSgjelinek sizeof (in_progress_psettab.zone_ncpu_max)); 46200209230bSgjelinek return; 46210209230bSgjelinek case PT_IMPORTANCE: 46220209230bSgjelinek /* Make sure the value makes sense. */ 46230209230bSgjelinek if (!zonecfg_valid_importance(prop_id)) { 46240209230bSgjelinek zerr(gettext("%s property is out of range."), 46250209230bSgjelinek pt_to_str(PT_IMPORTANCE)); 4626bbec428eSgjelinek saw_error = B_TRUE; 46270209230bSgjelinek return; 46280209230bSgjelinek } 46290209230bSgjelinek 46300209230bSgjelinek (void) strlcpy(in_progress_psettab.zone_importance, 46310209230bSgjelinek prop_id, 46320209230bSgjelinek sizeof (in_progress_psettab.zone_importance)); 46330209230bSgjelinek return; 46340209230bSgjelinek default: 46350209230bSgjelinek break; 46360209230bSgjelinek } 4637bbec428eSgjelinek zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, B_TRUE); 4638bbec428eSgjelinek long_usage(CMD_SET, B_TRUE); 4639bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 46400209230bSgjelinek return; 4641c97ad5cdSakolb case RT_PCAP: 4642c97ad5cdSakolb if (prop_type != PT_NCPUS) { 4643c97ad5cdSakolb zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 4644bbec428eSgjelinek B_TRUE); 4645bbec428eSgjelinek long_usage(CMD_SET, B_TRUE); 4646bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 4647c97ad5cdSakolb return; 4648c97ad5cdSakolb } 4649c97ad5cdSakolb 4650c97ad5cdSakolb /* 4651c97ad5cdSakolb * We already checked that an rctl alias is allowed in 4652c97ad5cdSakolb * the add_resource() function. 4653c97ad5cdSakolb */ 4654c97ad5cdSakolb 4655c97ad5cdSakolb if ((cap = strtof(prop_id, &unitp)) <= 0 || *unitp != '\0' || 4656c97ad5cdSakolb (int)(cap * 100) < 1) { 4657c97ad5cdSakolb zerr(gettext("%s property is out of range."), 4658c97ad5cdSakolb pt_to_str(PT_NCPUS)); 4659bbec428eSgjelinek saw_error = B_TRUE; 4660c97ad5cdSakolb return; 4661c97ad5cdSakolb } 4662c97ad5cdSakolb 4663c97ad5cdSakolb if ((err = zonecfg_set_aliased_rctl(handle, ALIAS_CPUCAP, 4664c97ad5cdSakolb (int)(cap * 100))) != Z_OK) 4665bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 4666c97ad5cdSakolb else 4667bbec428eSgjelinek need_to_commit = B_TRUE; 4668c97ad5cdSakolb return; 46690209230bSgjelinek case RT_MCAP: 46700209230bSgjelinek switch (prop_type) { 46710209230bSgjelinek case PT_PHYSICAL: 46720209230bSgjelinek if (!zonecfg_valid_memlimit(prop_id, &mem_cap)) { 46730209230bSgjelinek zerr(gettext("A positive number with a " 46740209230bSgjelinek "required scale suffix (K, M, G or T) was " 46750209230bSgjelinek "expected here.")); 4676bbec428eSgjelinek saw_error = B_TRUE; 46770209230bSgjelinek } else if (mem_cap < ONE_MB) { 46780209230bSgjelinek zerr(gettext("%s value is too small. It must " 46790209230bSgjelinek "be at least 1M."), pt_to_str(PT_PHYSICAL)); 4680bbec428eSgjelinek saw_error = B_TRUE; 46810209230bSgjelinek } else { 46820209230bSgjelinek snprintf(in_progress_mcaptab.zone_physmem_cap, 46830209230bSgjelinek physmem_size, "%llu", mem_cap); 46840209230bSgjelinek } 46850209230bSgjelinek break; 46860209230bSgjelinek case PT_SWAP: 46870209230bSgjelinek /* 46880209230bSgjelinek * We have to check if an rctl is allowed here since 46890209230bSgjelinek * there might already be a rctl defined that blocks 46900209230bSgjelinek * the alias. 46910209230bSgjelinek */ 46920209230bSgjelinek if (!zonecfg_aliased_rctl_ok(handle, ALIAS_MAXSWAP)) { 46930209230bSgjelinek zone_perror(pt_to_str(PT_MAXSWAP), 4694bbec428eSgjelinek Z_ALIAS_DISALLOW, B_FALSE); 4695bbec428eSgjelinek saw_error = B_TRUE; 46960209230bSgjelinek return; 46970209230bSgjelinek } 46980209230bSgjelinek 46990209230bSgjelinek if (global_zone) 47000209230bSgjelinek mem_limit = ONE_MB * 100; 47010209230bSgjelinek else 47020209230bSgjelinek mem_limit = ONE_MB * 50; 47030209230bSgjelinek 47040209230bSgjelinek if (!zonecfg_valid_memlimit(prop_id, &mem_cap)) { 47050209230bSgjelinek zerr(gettext("A positive number with a " 47060209230bSgjelinek "required scale suffix (K, M, G or T) was " 47070209230bSgjelinek "expected here.")); 4708bbec428eSgjelinek saw_error = B_TRUE; 47090209230bSgjelinek } else if (mem_cap < mem_limit) { 47100209230bSgjelinek char buf[128]; 47110209230bSgjelinek 47120209230bSgjelinek (void) snprintf(buf, sizeof (buf), "%llu", 47130209230bSgjelinek mem_limit); 47140209230bSgjelinek bytes_to_units(buf, buf, sizeof (buf)); 47150209230bSgjelinek zerr(gettext("%s value is too small. It must " 47160209230bSgjelinek "be at least %s."), pt_to_str(PT_SWAP), 47170209230bSgjelinek buf); 4718bbec428eSgjelinek saw_error = B_TRUE; 47190209230bSgjelinek } else { 47200209230bSgjelinek if ((err = zonecfg_set_aliased_rctl(handle, 47210209230bSgjelinek ALIAS_MAXSWAP, mem_cap)) != Z_OK) 4722bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 47230209230bSgjelinek else 4724bbec428eSgjelinek need_to_commit = B_TRUE; 47250209230bSgjelinek } 47260209230bSgjelinek break; 47270209230bSgjelinek case PT_LOCKED: 47280209230bSgjelinek /* 47290209230bSgjelinek * We have to check if an rctl is allowed here since 47300209230bSgjelinek * there might already be a rctl defined that blocks 47310209230bSgjelinek * the alias. 47320209230bSgjelinek */ 47330209230bSgjelinek if (!zonecfg_aliased_rctl_ok(handle, 47340209230bSgjelinek ALIAS_MAXLOCKEDMEM)) { 47350209230bSgjelinek zone_perror(pt_to_str(PT_LOCKED), 4736bbec428eSgjelinek Z_ALIAS_DISALLOW, B_FALSE); 4737bbec428eSgjelinek saw_error = B_TRUE; 47380209230bSgjelinek return; 47390209230bSgjelinek } 47400209230bSgjelinek 47410209230bSgjelinek if (!zonecfg_valid_memlimit(prop_id, &mem_cap)) { 47420209230bSgjelinek zerr(gettext("A non-negative number with a " 47430209230bSgjelinek "required scale suffix (K, M, G or T) was " 47440209230bSgjelinek "expected\nhere.")); 4745bbec428eSgjelinek saw_error = B_TRUE; 47460209230bSgjelinek } else { 47470209230bSgjelinek if ((err = zonecfg_set_aliased_rctl(handle, 47480209230bSgjelinek ALIAS_MAXLOCKEDMEM, mem_cap)) != Z_OK) 4749bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 47500209230bSgjelinek else 4751bbec428eSgjelinek need_to_commit = B_TRUE; 47520209230bSgjelinek } 47530209230bSgjelinek break; 47540209230bSgjelinek default: 47550209230bSgjelinek zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 4756bbec428eSgjelinek B_TRUE); 4757bbec428eSgjelinek long_usage(CMD_SET, B_TRUE); 4758bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 47590209230bSgjelinek return; 47600209230bSgjelinek } 4761fa9e4066Sahrens return; 4762cb8a054bSGlenn Faden case RT_ADMIN: 4763cb8a054bSGlenn Faden switch (prop_type) { 4764cb8a054bSGlenn Faden case PT_USER: 4765cb8a054bSGlenn Faden (void) strlcpy(in_progress_admintab.zone_admin_user, 4766cb8a054bSGlenn Faden prop_id, 4767cb8a054bSGlenn Faden sizeof (in_progress_admintab.zone_admin_user)); 4768cb8a054bSGlenn Faden return; 4769cb8a054bSGlenn Faden case PT_AUTHS: 4770cb8a054bSGlenn Faden (void) strlcpy(in_progress_admintab.zone_admin_auths, 4771cb8a054bSGlenn Faden prop_id, 4772cb8a054bSGlenn Faden sizeof (in_progress_admintab.zone_admin_auths)); 4773cb8a054bSGlenn Faden return; 4774cb8a054bSGlenn Faden default: 4775cb8a054bSGlenn Faden zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 4776cb8a054bSGlenn Faden B_TRUE); 4777cb8a054bSGlenn Faden long_usage(CMD_SET, B_TRUE); 4778cb8a054bSGlenn Faden usage(B_FALSE, HELP_PROPS); 4779cb8a054bSGlenn Faden return; 4780cb8a054bSGlenn Faden } 47817c478bd9Sstevel@tonic-gate default: 4782bbec428eSgjelinek zone_perror(rt_to_str(res_type), Z_NO_RESOURCE_TYPE, B_TRUE); 4783bbec428eSgjelinek long_usage(CMD_SET, B_TRUE); 4784bbec428eSgjelinek usage(B_FALSE, HELP_RESOURCES); 47857c478bd9Sstevel@tonic-gate return; 47867c478bd9Sstevel@tonic-gate } 47877c478bd9Sstevel@tonic-gate } 47887c478bd9Sstevel@tonic-gate 47897c478bd9Sstevel@tonic-gate static void 4790bbec428eSgjelinek output_prop(FILE *fp, int pnum, char *pval, boolean_t print_notspec) 47917c478bd9Sstevel@tonic-gate { 47927c478bd9Sstevel@tonic-gate char *qstr; 47937c478bd9Sstevel@tonic-gate 47947c478bd9Sstevel@tonic-gate if (*pval != '\0') { 47957c478bd9Sstevel@tonic-gate qstr = quoteit(pval); 47960209230bSgjelinek if (pnum == PT_SWAP || pnum == PT_LOCKED) 47970209230bSgjelinek (void) fprintf(fp, "\t[%s: %s]\n", pt_to_str(pnum), 47980209230bSgjelinek qstr); 47990209230bSgjelinek else 48000209230bSgjelinek (void) fprintf(fp, "\t%s: %s\n", pt_to_str(pnum), qstr); 48017c478bd9Sstevel@tonic-gate free(qstr); 48027c478bd9Sstevel@tonic-gate } else if (print_notspec) 4803087719fdSdp (void) fprintf(fp, gettext("\t%s not specified\n"), 4804087719fdSdp pt_to_str(pnum)); 4805087719fdSdp } 4806087719fdSdp 4807087719fdSdp static void 4808087719fdSdp info_zonename(zone_dochandle_t handle, FILE *fp) 4809087719fdSdp { 4810087719fdSdp char zonename[ZONENAME_MAX]; 4811087719fdSdp 4812087719fdSdp if (zonecfg_get_name(handle, zonename, sizeof (zonename)) == Z_OK) 4813087719fdSdp (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_ZONENAME), 4814087719fdSdp zonename); 4815087719fdSdp else 4816087719fdSdp (void) fprintf(fp, gettext("%s not specified\n"), 4817087719fdSdp pt_to_str(PT_ZONENAME)); 48187c478bd9Sstevel@tonic-gate } 48197c478bd9Sstevel@tonic-gate 48207c478bd9Sstevel@tonic-gate static void 48217c478bd9Sstevel@tonic-gate info_zonepath(zone_dochandle_t handle, FILE *fp) 48227c478bd9Sstevel@tonic-gate { 48237c478bd9Sstevel@tonic-gate char zonepath[MAXPATHLEN]; 48247c478bd9Sstevel@tonic-gate 48257c478bd9Sstevel@tonic-gate if (zonecfg_get_zonepath(handle, zonepath, sizeof (zonepath)) == Z_OK) 48267c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_ZONEPATH), 48277c478bd9Sstevel@tonic-gate zonepath); 4828087719fdSdp else { 4829087719fdSdp (void) fprintf(fp, gettext("%s not specified\n"), 4830087719fdSdp pt_to_str(PT_ZONEPATH)); 4831087719fdSdp } 48327c478bd9Sstevel@tonic-gate } 48337c478bd9Sstevel@tonic-gate 48349acbbeafSnn static void 48359acbbeafSnn info_brand(zone_dochandle_t handle, FILE *fp) 48369acbbeafSnn { 48379acbbeafSnn char brand[MAXNAMELEN]; 48389acbbeafSnn 48399acbbeafSnn if (zonecfg_get_brand(handle, brand, sizeof (brand)) == Z_OK) 48409acbbeafSnn (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_BRAND), 48419acbbeafSnn brand); 48429acbbeafSnn else 48439acbbeafSnn (void) fprintf(fp, "%s %s\n", pt_to_str(PT_BRAND), 48449acbbeafSnn gettext("not specified")); 48459acbbeafSnn } 48469acbbeafSnn 48477c478bd9Sstevel@tonic-gate static void 48487c478bd9Sstevel@tonic-gate info_autoboot(zone_dochandle_t handle, FILE *fp) 48497c478bd9Sstevel@tonic-gate { 48507c478bd9Sstevel@tonic-gate boolean_t autoboot; 48517c478bd9Sstevel@tonic-gate int err; 48527c478bd9Sstevel@tonic-gate 48537c478bd9Sstevel@tonic-gate if ((err = zonecfg_get_autoboot(handle, &autoboot)) == Z_OK) 48547c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_AUTOBOOT), 48557c478bd9Sstevel@tonic-gate autoboot ? "true" : "false"); 48567c478bd9Sstevel@tonic-gate else 4857bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 48587c478bd9Sstevel@tonic-gate } 48597c478bd9Sstevel@tonic-gate 48607c478bd9Sstevel@tonic-gate static void 48617c478bd9Sstevel@tonic-gate info_pool(zone_dochandle_t handle, FILE *fp) 48627c478bd9Sstevel@tonic-gate { 48637c478bd9Sstevel@tonic-gate char pool[MAXNAMELEN]; 48647c478bd9Sstevel@tonic-gate int err; 48657c478bd9Sstevel@tonic-gate 48667c478bd9Sstevel@tonic-gate if ((err = zonecfg_get_pool(handle, pool, sizeof (pool))) == Z_OK) 48677c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_POOL), pool); 48687c478bd9Sstevel@tonic-gate else 4869bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 48707c478bd9Sstevel@tonic-gate } 48717c478bd9Sstevel@tonic-gate 4872ffbafc53Scomay static void 4873ffbafc53Scomay info_limitpriv(zone_dochandle_t handle, FILE *fp) 4874ffbafc53Scomay { 4875ffbafc53Scomay char *limitpriv; 4876ffbafc53Scomay int err; 4877ffbafc53Scomay 4878ffbafc53Scomay if ((err = zonecfg_get_limitpriv(handle, &limitpriv)) == Z_OK) { 4879ffbafc53Scomay (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_LIMITPRIV), 4880ffbafc53Scomay limitpriv); 4881ffbafc53Scomay free(limitpriv); 4882ffbafc53Scomay } else { 4883bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 4884ffbafc53Scomay } 4885ffbafc53Scomay } 4886ffbafc53Scomay 48873f2f09c1Sdp static void 48883f2f09c1Sdp info_bootargs(zone_dochandle_t handle, FILE *fp) 48893f2f09c1Sdp { 48903f2f09c1Sdp char bootargs[BOOTARGS_MAX]; 48913f2f09c1Sdp int err; 48923f2f09c1Sdp 48933f2f09c1Sdp if ((err = zonecfg_get_bootargs(handle, bootargs, 48943f2f09c1Sdp sizeof (bootargs))) == Z_OK) { 48953f2f09c1Sdp (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_BOOTARGS), 48963f2f09c1Sdp bootargs); 48973f2f09c1Sdp } else { 4898bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 48993f2f09c1Sdp } 49003f2f09c1Sdp } 49013f2f09c1Sdp 49020209230bSgjelinek static void 49030209230bSgjelinek info_sched(zone_dochandle_t handle, FILE *fp) 49040209230bSgjelinek { 49050209230bSgjelinek char sched[MAXNAMELEN]; 49060209230bSgjelinek int err; 49070209230bSgjelinek 49080209230bSgjelinek if ((err = zonecfg_get_sched_class(handle, sched, sizeof (sched))) 49090209230bSgjelinek == Z_OK) { 49100209230bSgjelinek (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_SCHED), sched); 49110209230bSgjelinek } else { 4912bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 49130209230bSgjelinek } 49140209230bSgjelinek } 49150209230bSgjelinek 4916f4b3ec61Sdh static void 4917f4b3ec61Sdh info_iptype(zone_dochandle_t handle, FILE *fp) 4918f4b3ec61Sdh { 4919f4b3ec61Sdh zone_iptype_t iptype; 4920f4b3ec61Sdh int err; 4921f4b3ec61Sdh 4922f4b3ec61Sdh if ((err = zonecfg_get_iptype(handle, &iptype)) == Z_OK) { 4923f4b3ec61Sdh switch (iptype) { 4924f4b3ec61Sdh case ZS_SHARED: 4925f4b3ec61Sdh (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_IPTYPE), 4926f4b3ec61Sdh "shared"); 4927f4b3ec61Sdh break; 4928f4b3ec61Sdh case ZS_EXCLUSIVE: 4929f4b3ec61Sdh (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_IPTYPE), 4930f4b3ec61Sdh "exclusive"); 4931f4b3ec61Sdh break; 4932f4b3ec61Sdh } 4933f4b3ec61Sdh } else { 4934bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 4935f4b3ec61Sdh } 4936f4b3ec61Sdh } 4937f4b3ec61Sdh 49385679c89fSjv static void 49395679c89fSjv info_hostid(zone_dochandle_t handle, FILE *fp) 49405679c89fSjv { 49415679c89fSjv char hostidp[HW_HOSTID_LEN]; 49420fbb751dSJohn Levon int err; 49435679c89fSjv 49440fbb751dSJohn Levon if ((err = zonecfg_get_hostid(handle, hostidp, 49450fbb751dSJohn Levon sizeof (hostidp))) == Z_OK) { 49460fbb751dSJohn Levon (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_HOSTID), hostidp); 49470fbb751dSJohn Levon } else if (err == Z_BAD_PROPERTY) { 49480fbb751dSJohn Levon (void) fprintf(fp, "%s: \n", pt_to_str(PT_HOSTID)); 49490fbb751dSJohn Levon } else { 49500fbb751dSJohn Levon zone_perror(zone, err, B_TRUE); 49510fbb751dSJohn Levon } 49520fbb751dSJohn Levon } 49530fbb751dSJohn Levon 49540fbb751dSJohn Levon static void 49550fbb751dSJohn Levon info_fs_allowed(zone_dochandle_t handle, FILE *fp) 49560fbb751dSJohn Levon { 49570fbb751dSJohn Levon char fsallowedp[ZONE_FS_ALLOWED_MAX]; 49580fbb751dSJohn Levon int err; 49590fbb751dSJohn Levon 49600fbb751dSJohn Levon if ((err = zonecfg_get_fs_allowed(handle, fsallowedp, 49610fbb751dSJohn Levon sizeof (fsallowedp))) == Z_OK) { 49620fbb751dSJohn Levon (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_FS_ALLOWED), 49630fbb751dSJohn Levon fsallowedp); 49640fbb751dSJohn Levon } else if (err == Z_BAD_PROPERTY) { 49650fbb751dSJohn Levon (void) fprintf(fp, "%s: \n", pt_to_str(PT_FS_ALLOWED)); 49660fbb751dSJohn Levon } else { 49670fbb751dSJohn Levon zone_perror(zone, err, B_TRUE); 49680fbb751dSJohn Levon } 49695679c89fSjv } 49705679c89fSjv 49717c478bd9Sstevel@tonic-gate static void 49727c478bd9Sstevel@tonic-gate output_fs(FILE *fp, struct zone_fstab *fstab) 49737c478bd9Sstevel@tonic-gate { 49747c478bd9Sstevel@tonic-gate zone_fsopt_t *this; 49757c478bd9Sstevel@tonic-gate 49767c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s:\n", rt_to_str(RT_FS)); 49777c478bd9Sstevel@tonic-gate output_prop(fp, PT_DIR, fstab->zone_fs_dir, B_TRUE); 49787c478bd9Sstevel@tonic-gate output_prop(fp, PT_SPECIAL, fstab->zone_fs_special, B_TRUE); 49797c478bd9Sstevel@tonic-gate output_prop(fp, PT_RAW, fstab->zone_fs_raw, B_TRUE); 49807c478bd9Sstevel@tonic-gate output_prop(fp, PT_TYPE, fstab->zone_fs_type, B_TRUE); 49817c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s: [", pt_to_str(PT_OPTIONS)); 49827c478bd9Sstevel@tonic-gate for (this = fstab->zone_fs_options; this != NULL; 49837c478bd9Sstevel@tonic-gate this = this->zone_fsopt_next) { 49847c478bd9Sstevel@tonic-gate if (strchr(this->zone_fsopt_opt, '=')) 49857c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\"%s\"", this->zone_fsopt_opt); 49867c478bd9Sstevel@tonic-gate else 49877c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s", this->zone_fsopt_opt); 49887c478bd9Sstevel@tonic-gate if (this->zone_fsopt_next != NULL) 49897c478bd9Sstevel@tonic-gate (void) fprintf(fp, ","); 49907c478bd9Sstevel@tonic-gate } 49917c478bd9Sstevel@tonic-gate (void) fprintf(fp, "]\n"); 49927c478bd9Sstevel@tonic-gate } 49937c478bd9Sstevel@tonic-gate 49947c478bd9Sstevel@tonic-gate static void 49957c478bd9Sstevel@tonic-gate output_ipd(FILE *fp, struct zone_fstab *ipdtab) 49967c478bd9Sstevel@tonic-gate { 49977c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s:\n", rt_to_str(RT_IPD)); 49987c478bd9Sstevel@tonic-gate output_prop(fp, PT_DIR, ipdtab->zone_fs_dir, B_TRUE); 49997c478bd9Sstevel@tonic-gate } 50007c478bd9Sstevel@tonic-gate 50017c478bd9Sstevel@tonic-gate static void 50027c478bd9Sstevel@tonic-gate info_fs(zone_dochandle_t handle, FILE *fp, cmd_t *cmd) 50037c478bd9Sstevel@tonic-gate { 50047c478bd9Sstevel@tonic-gate struct zone_fstab lookup, user; 5005bbec428eSgjelinek boolean_t output = B_FALSE; 50067c478bd9Sstevel@tonic-gate 50077c478bd9Sstevel@tonic-gate if (zonecfg_setfsent(handle) != Z_OK) 50087c478bd9Sstevel@tonic-gate return; 50097c478bd9Sstevel@tonic-gate while (zonecfg_getfsent(handle, &lookup) == Z_OK) { 50107c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs == 0) { 50117c478bd9Sstevel@tonic-gate output_fs(fp, &lookup); 50127c478bd9Sstevel@tonic-gate goto loopend; 50137c478bd9Sstevel@tonic-gate } 5014bbec428eSgjelinek if (fill_in_fstab(cmd, &user, B_TRUE) != Z_OK) 50157c478bd9Sstevel@tonic-gate goto loopend; 50167c478bd9Sstevel@tonic-gate if (strlen(user.zone_fs_dir) > 0 && 50177c478bd9Sstevel@tonic-gate strcmp(user.zone_fs_dir, lookup.zone_fs_dir) != 0) 50187c478bd9Sstevel@tonic-gate goto loopend; /* no match */ 50197c478bd9Sstevel@tonic-gate if (strlen(user.zone_fs_special) > 0 && 50207c478bd9Sstevel@tonic-gate strcmp(user.zone_fs_special, lookup.zone_fs_special) != 0) 50217c478bd9Sstevel@tonic-gate goto loopend; /* no match */ 50227c478bd9Sstevel@tonic-gate if (strlen(user.zone_fs_type) > 0 && 50237c478bd9Sstevel@tonic-gate strcmp(user.zone_fs_type, lookup.zone_fs_type) != 0) 50247c478bd9Sstevel@tonic-gate goto loopend; /* no match */ 50257c478bd9Sstevel@tonic-gate output_fs(fp, &lookup); 5026bbec428eSgjelinek output = B_TRUE; 50277c478bd9Sstevel@tonic-gate loopend: 50287c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(lookup.zone_fs_options); 50297c478bd9Sstevel@tonic-gate } 50307c478bd9Sstevel@tonic-gate (void) zonecfg_endfsent(handle); 50317c478bd9Sstevel@tonic-gate /* 50327c478bd9Sstevel@tonic-gate * If a property n/v pair was specified, warn the user if there was 50337c478bd9Sstevel@tonic-gate * nothing to output. 50347c478bd9Sstevel@tonic-gate */ 50357c478bd9Sstevel@tonic-gate if (!output && cmd->cmd_prop_nv_pairs > 0) 50367c478bd9Sstevel@tonic-gate (void) printf(gettext("No such %s resource.\n"), 50377c478bd9Sstevel@tonic-gate rt_to_str(RT_FS)); 50387c478bd9Sstevel@tonic-gate } 50397c478bd9Sstevel@tonic-gate 50407c478bd9Sstevel@tonic-gate static void 50417c478bd9Sstevel@tonic-gate info_ipd(zone_dochandle_t handle, FILE *fp, cmd_t *cmd) 50427c478bd9Sstevel@tonic-gate { 50437c478bd9Sstevel@tonic-gate struct zone_fstab lookup, user; 5044bbec428eSgjelinek boolean_t output = B_FALSE; 50457c478bd9Sstevel@tonic-gate 50467c478bd9Sstevel@tonic-gate if (zonecfg_setipdent(handle) != Z_OK) 50477c478bd9Sstevel@tonic-gate return; 50487c478bd9Sstevel@tonic-gate while (zonecfg_getipdent(handle, &lookup) == Z_OK) { 50497c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs == 0) { 50507c478bd9Sstevel@tonic-gate output_ipd(fp, &lookup); 50517c478bd9Sstevel@tonic-gate continue; 50527c478bd9Sstevel@tonic-gate } 5053bbec428eSgjelinek if (fill_in_ipdtab(cmd, &user, B_TRUE) != Z_OK) 50547c478bd9Sstevel@tonic-gate continue; 50557c478bd9Sstevel@tonic-gate if (strlen(user.zone_fs_dir) > 0 && 50567c478bd9Sstevel@tonic-gate strcmp(user.zone_fs_dir, lookup.zone_fs_dir) != 0) 50577c478bd9Sstevel@tonic-gate continue; /* no match */ 50587c478bd9Sstevel@tonic-gate output_ipd(fp, &lookup); 5059bbec428eSgjelinek output = B_TRUE; 50607c478bd9Sstevel@tonic-gate } 50617c478bd9Sstevel@tonic-gate (void) zonecfg_endipdent(handle); 50627c478bd9Sstevel@tonic-gate /* 50637c478bd9Sstevel@tonic-gate * If a property n/v pair was specified, warn the user if there was 50647c478bd9Sstevel@tonic-gate * nothing to output. 50657c478bd9Sstevel@tonic-gate */ 50667c478bd9Sstevel@tonic-gate if (!output && cmd->cmd_prop_nv_pairs > 0) 50677c478bd9Sstevel@tonic-gate (void) printf(gettext("No such %s resource.\n"), 50687c478bd9Sstevel@tonic-gate rt_to_str(RT_IPD)); 50697c478bd9Sstevel@tonic-gate } 50707c478bd9Sstevel@tonic-gate 50717c478bd9Sstevel@tonic-gate static void 50727c478bd9Sstevel@tonic-gate output_net(FILE *fp, struct zone_nwiftab *nwiftab) 50737c478bd9Sstevel@tonic-gate { 50747c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s:\n", rt_to_str(RT_NET)); 50757c478bd9Sstevel@tonic-gate output_prop(fp, PT_ADDRESS, nwiftab->zone_nwif_address, B_TRUE); 50767c478bd9Sstevel@tonic-gate output_prop(fp, PT_PHYSICAL, nwiftab->zone_nwif_physical, B_TRUE); 5077de860bd9Sgfaden output_prop(fp, PT_DEFROUTER, nwiftab->zone_nwif_defrouter, B_TRUE); 50787c478bd9Sstevel@tonic-gate } 50797c478bd9Sstevel@tonic-gate 50807c478bd9Sstevel@tonic-gate static void 50817c478bd9Sstevel@tonic-gate info_net(zone_dochandle_t handle, FILE *fp, cmd_t *cmd) 50827c478bd9Sstevel@tonic-gate { 50837c478bd9Sstevel@tonic-gate struct zone_nwiftab lookup, user; 5084bbec428eSgjelinek boolean_t output = B_FALSE; 50857c478bd9Sstevel@tonic-gate 50867c478bd9Sstevel@tonic-gate if (zonecfg_setnwifent(handle) != Z_OK) 50877c478bd9Sstevel@tonic-gate return; 50887c478bd9Sstevel@tonic-gate while (zonecfg_getnwifent(handle, &lookup) == Z_OK) { 50897c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs == 0) { 50907c478bd9Sstevel@tonic-gate output_net(fp, &lookup); 50917c478bd9Sstevel@tonic-gate continue; 50927c478bd9Sstevel@tonic-gate } 5093bbec428eSgjelinek if (fill_in_nwiftab(cmd, &user, B_TRUE) != Z_OK) 50947c478bd9Sstevel@tonic-gate continue; 50957c478bd9Sstevel@tonic-gate if (strlen(user.zone_nwif_physical) > 0 && 50967c478bd9Sstevel@tonic-gate strcmp(user.zone_nwif_physical, 50977c478bd9Sstevel@tonic-gate lookup.zone_nwif_physical) != 0) 50987c478bd9Sstevel@tonic-gate continue; /* no match */ 5099f4b3ec61Sdh /* If present make sure it matches */ 51007c478bd9Sstevel@tonic-gate if (strlen(user.zone_nwif_address) > 0 && 51017c478bd9Sstevel@tonic-gate !zonecfg_same_net_address(user.zone_nwif_address, 51027c478bd9Sstevel@tonic-gate lookup.zone_nwif_address)) 51037c478bd9Sstevel@tonic-gate continue; /* no match */ 51047c478bd9Sstevel@tonic-gate output_net(fp, &lookup); 5105bbec428eSgjelinek output = B_TRUE; 51067c478bd9Sstevel@tonic-gate } 51077c478bd9Sstevel@tonic-gate (void) zonecfg_endnwifent(handle); 51087c478bd9Sstevel@tonic-gate /* 51097c478bd9Sstevel@tonic-gate * If a property n/v pair was specified, warn the user if there was 51107c478bd9Sstevel@tonic-gate * nothing to output. 51117c478bd9Sstevel@tonic-gate */ 51127c478bd9Sstevel@tonic-gate if (!output && cmd->cmd_prop_nv_pairs > 0) 51137c478bd9Sstevel@tonic-gate (void) printf(gettext("No such %s resource.\n"), 51147c478bd9Sstevel@tonic-gate rt_to_str(RT_NET)); 51157c478bd9Sstevel@tonic-gate } 51167c478bd9Sstevel@tonic-gate 51177c478bd9Sstevel@tonic-gate static void 51187c478bd9Sstevel@tonic-gate output_dev(FILE *fp, struct zone_devtab *devtab) 51197c478bd9Sstevel@tonic-gate { 512027e6fb21Sdp (void) fprintf(fp, "%s:\n", rt_to_str(RT_DEVICE)); 51217c478bd9Sstevel@tonic-gate output_prop(fp, PT_MATCH, devtab->zone_dev_match, B_TRUE); 51227c478bd9Sstevel@tonic-gate } 51237c478bd9Sstevel@tonic-gate 51247c478bd9Sstevel@tonic-gate static void 51257c478bd9Sstevel@tonic-gate info_dev(zone_dochandle_t handle, FILE *fp, cmd_t *cmd) 51267c478bd9Sstevel@tonic-gate { 51277c478bd9Sstevel@tonic-gate struct zone_devtab lookup, user; 5128bbec428eSgjelinek boolean_t output = B_FALSE; 51297c478bd9Sstevel@tonic-gate 51307c478bd9Sstevel@tonic-gate if (zonecfg_setdevent(handle) != Z_OK) 51317c478bd9Sstevel@tonic-gate return; 51327c478bd9Sstevel@tonic-gate while (zonecfg_getdevent(handle, &lookup) == Z_OK) { 51337c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs == 0) { 51347c478bd9Sstevel@tonic-gate output_dev(fp, &lookup); 51357c478bd9Sstevel@tonic-gate continue; 51367c478bd9Sstevel@tonic-gate } 5137bbec428eSgjelinek if (fill_in_devtab(cmd, &user, B_TRUE) != Z_OK) 51387c478bd9Sstevel@tonic-gate continue; 51397c478bd9Sstevel@tonic-gate if (strlen(user.zone_dev_match) > 0 && 51407c478bd9Sstevel@tonic-gate strcmp(user.zone_dev_match, lookup.zone_dev_match) != 0) 51417c478bd9Sstevel@tonic-gate continue; /* no match */ 51427c478bd9Sstevel@tonic-gate output_dev(fp, &lookup); 5143bbec428eSgjelinek output = B_TRUE; 51447c478bd9Sstevel@tonic-gate } 51457c478bd9Sstevel@tonic-gate (void) zonecfg_enddevent(handle); 51467c478bd9Sstevel@tonic-gate /* 51477c478bd9Sstevel@tonic-gate * If a property n/v pair was specified, warn the user if there was 51487c478bd9Sstevel@tonic-gate * nothing to output. 51497c478bd9Sstevel@tonic-gate */ 51507c478bd9Sstevel@tonic-gate if (!output && cmd->cmd_prop_nv_pairs > 0) 51517c478bd9Sstevel@tonic-gate (void) printf(gettext("No such %s resource.\n"), 51527c478bd9Sstevel@tonic-gate rt_to_str(RT_DEVICE)); 51537c478bd9Sstevel@tonic-gate } 51547c478bd9Sstevel@tonic-gate 51557c478bd9Sstevel@tonic-gate static void 51567c478bd9Sstevel@tonic-gate output_rctl(FILE *fp, struct zone_rctltab *rctltab) 51577c478bd9Sstevel@tonic-gate { 51587c478bd9Sstevel@tonic-gate struct zone_rctlvaltab *valptr; 51597c478bd9Sstevel@tonic-gate 51607c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s:\n", rt_to_str(RT_RCTL)); 51617c478bd9Sstevel@tonic-gate output_prop(fp, PT_NAME, rctltab->zone_rctl_name, B_TRUE); 51627c478bd9Sstevel@tonic-gate for (valptr = rctltab->zone_rctl_valptr; valptr != NULL; 51637c478bd9Sstevel@tonic-gate valptr = valptr->zone_rctlval_next) { 51647c478bd9Sstevel@tonic-gate fprintf(fp, "\t%s: (%s=%s,%s=%s,%s=%s)\n", 51657c478bd9Sstevel@tonic-gate pt_to_str(PT_VALUE), 51667c478bd9Sstevel@tonic-gate pt_to_str(PT_PRIV), valptr->zone_rctlval_priv, 51677c478bd9Sstevel@tonic-gate pt_to_str(PT_LIMIT), valptr->zone_rctlval_limit, 51687c478bd9Sstevel@tonic-gate pt_to_str(PT_ACTION), valptr->zone_rctlval_action); 51697c478bd9Sstevel@tonic-gate } 51707c478bd9Sstevel@tonic-gate } 51717c478bd9Sstevel@tonic-gate 51727c478bd9Sstevel@tonic-gate static void 51737c478bd9Sstevel@tonic-gate info_rctl(zone_dochandle_t handle, FILE *fp, cmd_t *cmd) 51747c478bd9Sstevel@tonic-gate { 51757c478bd9Sstevel@tonic-gate struct zone_rctltab lookup, user; 5176bbec428eSgjelinek boolean_t output = B_FALSE; 51777c478bd9Sstevel@tonic-gate 51787c478bd9Sstevel@tonic-gate if (zonecfg_setrctlent(handle) != Z_OK) 51797c478bd9Sstevel@tonic-gate return; 51807c478bd9Sstevel@tonic-gate while (zonecfg_getrctlent(handle, &lookup) == Z_OK) { 51817c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs == 0) { 51827c478bd9Sstevel@tonic-gate output_rctl(fp, &lookup); 5183bbec428eSgjelinek } else if (fill_in_rctltab(cmd, &user, B_TRUE) == Z_OK && 51847c478bd9Sstevel@tonic-gate (strlen(user.zone_rctl_name) == 0 || 51857c478bd9Sstevel@tonic-gate strcmp(user.zone_rctl_name, lookup.zone_rctl_name) == 0)) { 51867c478bd9Sstevel@tonic-gate output_rctl(fp, &lookup); 5187bbec428eSgjelinek output = B_TRUE; 51887c478bd9Sstevel@tonic-gate } 51897c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(lookup.zone_rctl_valptr); 51907c478bd9Sstevel@tonic-gate } 51917c478bd9Sstevel@tonic-gate (void) zonecfg_endrctlent(handle); 51927c478bd9Sstevel@tonic-gate /* 51937c478bd9Sstevel@tonic-gate * If a property n/v pair was specified, warn the user if there was 51947c478bd9Sstevel@tonic-gate * nothing to output. 51957c478bd9Sstevel@tonic-gate */ 51967c478bd9Sstevel@tonic-gate if (!output && cmd->cmd_prop_nv_pairs > 0) 51977c478bd9Sstevel@tonic-gate (void) printf(gettext("No such %s resource.\n"), 51987c478bd9Sstevel@tonic-gate rt_to_str(RT_RCTL)); 51997c478bd9Sstevel@tonic-gate } 52007c478bd9Sstevel@tonic-gate 52017c478bd9Sstevel@tonic-gate static void 52027c478bd9Sstevel@tonic-gate output_attr(FILE *fp, struct zone_attrtab *attrtab) 52037c478bd9Sstevel@tonic-gate { 52047c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s:\n", rt_to_str(RT_ATTR)); 52057c478bd9Sstevel@tonic-gate output_prop(fp, PT_NAME, attrtab->zone_attr_name, B_TRUE); 52067c478bd9Sstevel@tonic-gate output_prop(fp, PT_TYPE, attrtab->zone_attr_type, B_TRUE); 52077c478bd9Sstevel@tonic-gate output_prop(fp, PT_VALUE, attrtab->zone_attr_value, B_TRUE); 52087c478bd9Sstevel@tonic-gate } 52097c478bd9Sstevel@tonic-gate 52107c478bd9Sstevel@tonic-gate static void 52117c478bd9Sstevel@tonic-gate info_attr(zone_dochandle_t handle, FILE *fp, cmd_t *cmd) 52127c478bd9Sstevel@tonic-gate { 52137c478bd9Sstevel@tonic-gate struct zone_attrtab lookup, user; 5214bbec428eSgjelinek boolean_t output = B_FALSE; 52157c478bd9Sstevel@tonic-gate 52167c478bd9Sstevel@tonic-gate if (zonecfg_setattrent(handle) != Z_OK) 52177c478bd9Sstevel@tonic-gate return; 52187c478bd9Sstevel@tonic-gate while (zonecfg_getattrent(handle, &lookup) == Z_OK) { 52197c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs == 0) { 52207c478bd9Sstevel@tonic-gate output_attr(fp, &lookup); 52217c478bd9Sstevel@tonic-gate continue; 52227c478bd9Sstevel@tonic-gate } 5223bbec428eSgjelinek if (fill_in_attrtab(cmd, &user, B_TRUE) != Z_OK) 52247c478bd9Sstevel@tonic-gate continue; 52257c478bd9Sstevel@tonic-gate if (strlen(user.zone_attr_name) > 0 && 52267c478bd9Sstevel@tonic-gate strcmp(user.zone_attr_name, lookup.zone_attr_name) != 0) 52277c478bd9Sstevel@tonic-gate continue; /* no match */ 52287c478bd9Sstevel@tonic-gate if (strlen(user.zone_attr_type) > 0 && 52297c478bd9Sstevel@tonic-gate strcmp(user.zone_attr_type, lookup.zone_attr_type) != 0) 52307c478bd9Sstevel@tonic-gate continue; /* no match */ 52317c478bd9Sstevel@tonic-gate if (strlen(user.zone_attr_value) > 0 && 52327c478bd9Sstevel@tonic-gate strcmp(user.zone_attr_value, lookup.zone_attr_value) != 0) 52337c478bd9Sstevel@tonic-gate continue; /* no match */ 52347c478bd9Sstevel@tonic-gate output_attr(fp, &lookup); 5235bbec428eSgjelinek output = B_TRUE; 52367c478bd9Sstevel@tonic-gate } 52377c478bd9Sstevel@tonic-gate (void) zonecfg_endattrent(handle); 52387c478bd9Sstevel@tonic-gate /* 52397c478bd9Sstevel@tonic-gate * If a property n/v pair was specified, warn the user if there was 52407c478bd9Sstevel@tonic-gate * nothing to output. 52417c478bd9Sstevel@tonic-gate */ 52427c478bd9Sstevel@tonic-gate if (!output && cmd->cmd_prop_nv_pairs > 0) 52437c478bd9Sstevel@tonic-gate (void) printf(gettext("No such %s resource.\n"), 52447c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR)); 52457c478bd9Sstevel@tonic-gate } 52467c478bd9Sstevel@tonic-gate 5247fa9e4066Sahrens static void 5248fa9e4066Sahrens output_ds(FILE *fp, struct zone_dstab *dstab) 5249fa9e4066Sahrens { 5250fa9e4066Sahrens (void) fprintf(fp, "%s:\n", rt_to_str(RT_DATASET)); 5251fa9e4066Sahrens output_prop(fp, PT_NAME, dstab->zone_dataset_name, B_TRUE); 5252fa9e4066Sahrens } 5253fa9e4066Sahrens 5254fa9e4066Sahrens static void 5255fa9e4066Sahrens info_ds(zone_dochandle_t handle, FILE *fp, cmd_t *cmd) 5256fa9e4066Sahrens { 5257fa9e4066Sahrens struct zone_dstab lookup, user; 5258bbec428eSgjelinek boolean_t output = B_FALSE; 5259fa9e4066Sahrens 52600209230bSgjelinek if (zonecfg_setdsent(handle) != Z_OK) 5261fa9e4066Sahrens return; 5262fa9e4066Sahrens while (zonecfg_getdsent(handle, &lookup) == Z_OK) { 5263fa9e4066Sahrens if (cmd->cmd_prop_nv_pairs == 0) { 5264fa9e4066Sahrens output_ds(fp, &lookup); 5265fa9e4066Sahrens continue; 5266fa9e4066Sahrens } 5267bbec428eSgjelinek if (fill_in_dstab(cmd, &user, B_TRUE) != Z_OK) 5268fa9e4066Sahrens continue; 5269fa9e4066Sahrens if (strlen(user.zone_dataset_name) > 0 && 5270fa9e4066Sahrens strcmp(user.zone_dataset_name, 5271fa9e4066Sahrens lookup.zone_dataset_name) != 0) 5272fa9e4066Sahrens continue; /* no match */ 5273fa9e4066Sahrens output_ds(fp, &lookup); 5274bbec428eSgjelinek output = B_TRUE; 5275fa9e4066Sahrens } 5276fa9e4066Sahrens (void) zonecfg_enddsent(handle); 5277fa9e4066Sahrens /* 5278fa9e4066Sahrens * If a property n/v pair was specified, warn the user if there was 5279fa9e4066Sahrens * nothing to output. 5280fa9e4066Sahrens */ 5281fa9e4066Sahrens if (!output && cmd->cmd_prop_nv_pairs > 0) 5282fa9e4066Sahrens (void) printf(gettext("No such %s resource.\n"), 5283fa9e4066Sahrens rt_to_str(RT_DATASET)); 5284fa9e4066Sahrens } 5285fa9e4066Sahrens 52860209230bSgjelinek static void 52870209230bSgjelinek output_pset(FILE *fp, struct zone_psettab *psettab) 52880209230bSgjelinek { 52890209230bSgjelinek (void) fprintf(fp, "%s:\n", rt_to_str(RT_DCPU)); 52900209230bSgjelinek if (strcmp(psettab->zone_ncpu_min, psettab->zone_ncpu_max) == 0) 52910209230bSgjelinek (void) fprintf(fp, "\t%s: %s\n", pt_to_str(PT_NCPUS), 52920209230bSgjelinek psettab->zone_ncpu_max); 52930209230bSgjelinek else 52940209230bSgjelinek (void) fprintf(fp, "\t%s: %s-%s\n", pt_to_str(PT_NCPUS), 52950209230bSgjelinek psettab->zone_ncpu_min, psettab->zone_ncpu_max); 52960209230bSgjelinek if (psettab->zone_importance[0] != '\0') 52970209230bSgjelinek (void) fprintf(fp, "\t%s: %s\n", pt_to_str(PT_IMPORTANCE), 52980209230bSgjelinek psettab->zone_importance); 52990209230bSgjelinek } 53000209230bSgjelinek 53010209230bSgjelinek static void 53020209230bSgjelinek info_pset(zone_dochandle_t handle, FILE *fp) 53030209230bSgjelinek { 53040209230bSgjelinek struct zone_psettab lookup; 53050209230bSgjelinek 53060209230bSgjelinek if (zonecfg_getpsetent(handle, &lookup) == Z_OK) 53070209230bSgjelinek output_pset(fp, &lookup); 53080209230bSgjelinek } 53090209230bSgjelinek 5310c97ad5cdSakolb static void 5311c97ad5cdSakolb output_pcap(FILE *fp) 5312c97ad5cdSakolb { 5313c97ad5cdSakolb uint64_t cap; 5314c97ad5cdSakolb 5315c97ad5cdSakolb if (zonecfg_get_aliased_rctl(handle, ALIAS_CPUCAP, &cap) == Z_OK) { 5316c97ad5cdSakolb float scaled = (float)cap / 100; 5317c97ad5cdSakolb (void) fprintf(fp, "%s:\n", rt_to_str(RT_PCAP)); 5318c97ad5cdSakolb (void) fprintf(fp, "\t[%s: %.2f]\n", pt_to_str(PT_NCPUS), 5319c97ad5cdSakolb scaled); 5320c97ad5cdSakolb } 5321c97ad5cdSakolb } 5322c97ad5cdSakolb 5323c97ad5cdSakolb static void 5324c97ad5cdSakolb info_pcap(FILE *fp) 5325c97ad5cdSakolb { 5326c97ad5cdSakolb output_pcap(fp); 5327c97ad5cdSakolb } 5328c97ad5cdSakolb 5329c97ad5cdSakolb 53300209230bSgjelinek static void 53310209230bSgjelinek info_aliased_rctl(zone_dochandle_t handle, FILE *fp, char *alias) 53320209230bSgjelinek { 53330209230bSgjelinek uint64_t limit; 53340209230bSgjelinek 53350209230bSgjelinek if (zonecfg_get_aliased_rctl(handle, alias, &limit) == Z_OK) { 53360209230bSgjelinek /* convert memory based properties */ 53370209230bSgjelinek if (strcmp(alias, ALIAS_MAXSHMMEM) == 0) { 53380209230bSgjelinek char buf[128]; 53390209230bSgjelinek 53400209230bSgjelinek (void) snprintf(buf, sizeof (buf), "%llu", limit); 53410209230bSgjelinek bytes_to_units(buf, buf, sizeof (buf)); 53420209230bSgjelinek (void) fprintf(fp, "[%s: %s]\n", alias, buf); 53430209230bSgjelinek return; 53440209230bSgjelinek } 53450209230bSgjelinek 53460209230bSgjelinek (void) fprintf(fp, "[%s: %llu]\n", alias, limit); 53470209230bSgjelinek } 53480209230bSgjelinek } 53490209230bSgjelinek 53500209230bSgjelinek static void 53510209230bSgjelinek bytes_to_units(char *str, char *buf, int bufsize) 53520209230bSgjelinek { 53530209230bSgjelinek unsigned long long num; 53540209230bSgjelinek unsigned long long save = 0; 53550209230bSgjelinek char *units = "BKMGT"; 53560209230bSgjelinek char *up = units; 53570209230bSgjelinek 53580209230bSgjelinek num = strtoll(str, NULL, 10); 53590209230bSgjelinek 53600209230bSgjelinek if (num < 1024) { 53610209230bSgjelinek (void) snprintf(buf, bufsize, "%llu", num); 53620209230bSgjelinek return; 53630209230bSgjelinek } 53640209230bSgjelinek 53650209230bSgjelinek while ((num >= 1024) && (*up != 'T')) { 53660209230bSgjelinek up++; /* next unit of measurement */ 53670209230bSgjelinek save = num; 53680209230bSgjelinek num = (num + 512) >> 10; 53690209230bSgjelinek } 53700209230bSgjelinek 53710209230bSgjelinek /* check if we should output a fraction. snprintf will round for us */ 53720209230bSgjelinek if (save % 1024 != 0 && ((save >> 10) < 10)) 53730209230bSgjelinek (void) snprintf(buf, bufsize, "%2.1f%c", ((float)save / 1024), 53740209230bSgjelinek *up); 53750209230bSgjelinek else 53760209230bSgjelinek (void) snprintf(buf, bufsize, "%llu%c", num, *up); 53770209230bSgjelinek } 53780209230bSgjelinek 53790209230bSgjelinek static void 53800209230bSgjelinek output_mcap(FILE *fp, struct zone_mcaptab *mcaptab, int showswap, 53810209230bSgjelinek uint64_t maxswap, int showlocked, uint64_t maxlocked) 53820209230bSgjelinek { 53830209230bSgjelinek char buf[128]; 53840209230bSgjelinek 53850209230bSgjelinek (void) fprintf(fp, "%s:\n", rt_to_str(RT_MCAP)); 53860209230bSgjelinek if (mcaptab->zone_physmem_cap[0] != '\0') { 53870209230bSgjelinek bytes_to_units(mcaptab->zone_physmem_cap, buf, sizeof (buf)); 53880209230bSgjelinek output_prop(fp, PT_PHYSICAL, buf, B_TRUE); 53890209230bSgjelinek } 53900209230bSgjelinek 53910209230bSgjelinek if (showswap == Z_OK) { 53920209230bSgjelinek (void) snprintf(buf, sizeof (buf), "%llu", maxswap); 53930209230bSgjelinek bytes_to_units(buf, buf, sizeof (buf)); 53940209230bSgjelinek output_prop(fp, PT_SWAP, buf, B_TRUE); 53950209230bSgjelinek } 53960209230bSgjelinek 53970209230bSgjelinek if (showlocked == Z_OK) { 53980209230bSgjelinek (void) snprintf(buf, sizeof (buf), "%llu", maxlocked); 53990209230bSgjelinek bytes_to_units(buf, buf, sizeof (buf)); 54000209230bSgjelinek output_prop(fp, PT_LOCKED, buf, B_TRUE); 54010209230bSgjelinek } 54020209230bSgjelinek } 54030209230bSgjelinek 54040209230bSgjelinek static void 54050209230bSgjelinek info_mcap(zone_dochandle_t handle, FILE *fp) 54060209230bSgjelinek { 54070209230bSgjelinek int res1, res2, res3; 54080209230bSgjelinek uint64_t swap_limit; 54090209230bSgjelinek uint64_t locked_limit; 54100209230bSgjelinek struct zone_mcaptab lookup; 54110209230bSgjelinek 54120209230bSgjelinek bzero(&lookup, sizeof (lookup)); 54130209230bSgjelinek res1 = zonecfg_getmcapent(handle, &lookup); 54140209230bSgjelinek res2 = zonecfg_get_aliased_rctl(handle, ALIAS_MAXSWAP, &swap_limit); 54150209230bSgjelinek res3 = zonecfg_get_aliased_rctl(handle, ALIAS_MAXLOCKEDMEM, 54160209230bSgjelinek &locked_limit); 54170209230bSgjelinek 54180209230bSgjelinek if (res1 == Z_OK || res2 == Z_OK || res3 == Z_OK) 54190209230bSgjelinek output_mcap(fp, &lookup, res2, swap_limit, res3, locked_limit); 54200209230bSgjelinek } 54210209230bSgjelinek 5422cb8a054bSGlenn Faden static void 5423cb8a054bSGlenn Faden output_auth(FILE *fp, struct zone_admintab *admintab) 5424cb8a054bSGlenn Faden { 5425cb8a054bSGlenn Faden (void) fprintf(fp, "%s:\n", rt_to_str(RT_ADMIN)); 5426cb8a054bSGlenn Faden output_prop(fp, PT_USER, admintab->zone_admin_user, B_TRUE); 5427cb8a054bSGlenn Faden output_prop(fp, PT_AUTHS, admintab->zone_admin_auths, B_TRUE); 5428cb8a054bSGlenn Faden } 5429cb8a054bSGlenn Faden 5430cb8a054bSGlenn Faden static void 5431cb8a054bSGlenn Faden info_auth(zone_dochandle_t handle, FILE *fp, cmd_t *cmd) 5432cb8a054bSGlenn Faden { 5433cb8a054bSGlenn Faden struct zone_admintab lookup, user; 5434cb8a054bSGlenn Faden boolean_t output = B_FALSE; 5435cb8a054bSGlenn Faden int err; 5436cb8a054bSGlenn Faden 5437cb8a054bSGlenn Faden if ((err = zonecfg_setadminent(handle)) != Z_OK) { 5438cb8a054bSGlenn Faden zone_perror(zone, err, B_TRUE); 5439cb8a054bSGlenn Faden return; 5440cb8a054bSGlenn Faden } 5441cb8a054bSGlenn Faden while (zonecfg_getadminent(handle, &lookup) == Z_OK) { 5442cb8a054bSGlenn Faden if (cmd->cmd_prop_nv_pairs == 0) { 5443cb8a054bSGlenn Faden output_auth(fp, &lookup); 5444cb8a054bSGlenn Faden continue; 5445cb8a054bSGlenn Faden } 5446cb8a054bSGlenn Faden if (fill_in_admintab(cmd, &user, B_TRUE) != Z_OK) 5447cb8a054bSGlenn Faden continue; 5448cb8a054bSGlenn Faden if (strlen(user.zone_admin_user) > 0 && 5449cb8a054bSGlenn Faden strcmp(user.zone_admin_user, lookup.zone_admin_user) != 0) 5450cb8a054bSGlenn Faden continue; /* no match */ 5451cb8a054bSGlenn Faden output_auth(fp, &lookup); 5452cb8a054bSGlenn Faden output = B_TRUE; 5453cb8a054bSGlenn Faden } 5454cb8a054bSGlenn Faden (void) zonecfg_endadminent(handle); 5455cb8a054bSGlenn Faden /* 5456cb8a054bSGlenn Faden * If a property n/v pair was specified, warn the user if there was 5457cb8a054bSGlenn Faden * nothing to output. 5458cb8a054bSGlenn Faden */ 5459cb8a054bSGlenn Faden if (!output && cmd->cmd_prop_nv_pairs > 0) 5460cb8a054bSGlenn Faden (void) printf(gettext("No such %s resource.\n"), 5461cb8a054bSGlenn Faden rt_to_str(RT_ADMIN)); 5462cb8a054bSGlenn Faden } 5463cb8a054bSGlenn Faden 54647c478bd9Sstevel@tonic-gate void 54657c478bd9Sstevel@tonic-gate info_func(cmd_t *cmd) 54667c478bd9Sstevel@tonic-gate { 54677c478bd9Sstevel@tonic-gate FILE *fp = stdout; 5468bbec428eSgjelinek boolean_t need_to_close = B_FALSE; 54697c478bd9Sstevel@tonic-gate char *pager; 54700209230bSgjelinek int type; 54710209230bSgjelinek int res1, res2; 54720209230bSgjelinek uint64_t swap_limit; 54730209230bSgjelinek uint64_t locked_limit; 54743042b8b5Sbatschul struct stat statbuf; 54757c478bd9Sstevel@tonic-gate 54767c478bd9Sstevel@tonic-gate assert(cmd != NULL); 54777c478bd9Sstevel@tonic-gate 5478bbec428eSgjelinek if (initialize(B_TRUE) != Z_OK) 54797c478bd9Sstevel@tonic-gate return; 54807c478bd9Sstevel@tonic-gate 54817c478bd9Sstevel@tonic-gate /* don't page error output */ 54827c478bd9Sstevel@tonic-gate if (interactive_mode) { 54837c478bd9Sstevel@tonic-gate if ((pager = getenv("PAGER")) == NULL) 54847c478bd9Sstevel@tonic-gate pager = PAGER; 54853042b8b5Sbatschul 54863042b8b5Sbatschul if (stat(pager, &statbuf) == 0) { 54873042b8b5Sbatschul if ((fp = popen(pager, "w")) != NULL) 54883042b8b5Sbatschul need_to_close = B_TRUE; 54893042b8b5Sbatschul else 54903042b8b5Sbatschul fp = stdout; 54913042b8b5Sbatschul } else { 54923042b8b5Sbatschul zerr(gettext("PAGER %s does not exist (%s)."), 54933042b8b5Sbatschul pager, strerror(errno)); 54943042b8b5Sbatschul } 54953042b8b5Sbatschul 54967c478bd9Sstevel@tonic-gate setbuf(fp, NULL); 54977c478bd9Sstevel@tonic-gate } 54987c478bd9Sstevel@tonic-gate 54997c478bd9Sstevel@tonic-gate if (!global_scope) { 55007c478bd9Sstevel@tonic-gate switch (resource_scope) { 55017c478bd9Sstevel@tonic-gate case RT_FS: 55027c478bd9Sstevel@tonic-gate output_fs(fp, &in_progress_fstab); 55037c478bd9Sstevel@tonic-gate break; 55047c478bd9Sstevel@tonic-gate case RT_IPD: 55057c478bd9Sstevel@tonic-gate output_ipd(fp, &in_progress_ipdtab); 55067c478bd9Sstevel@tonic-gate break; 55077c478bd9Sstevel@tonic-gate case RT_NET: 55087c478bd9Sstevel@tonic-gate output_net(fp, &in_progress_nwiftab); 55097c478bd9Sstevel@tonic-gate break; 55107c478bd9Sstevel@tonic-gate case RT_DEVICE: 55117c478bd9Sstevel@tonic-gate output_dev(fp, &in_progress_devtab); 55127c478bd9Sstevel@tonic-gate break; 55137c478bd9Sstevel@tonic-gate case RT_RCTL: 55147c478bd9Sstevel@tonic-gate output_rctl(fp, &in_progress_rctltab); 55157c478bd9Sstevel@tonic-gate break; 55167c478bd9Sstevel@tonic-gate case RT_ATTR: 55177c478bd9Sstevel@tonic-gate output_attr(fp, &in_progress_attrtab); 55187c478bd9Sstevel@tonic-gate break; 5519fa9e4066Sahrens case RT_DATASET: 5520fa9e4066Sahrens output_ds(fp, &in_progress_dstab); 5521fa9e4066Sahrens break; 55220209230bSgjelinek case RT_DCPU: 55230209230bSgjelinek output_pset(fp, &in_progress_psettab); 55240209230bSgjelinek break; 5525c97ad5cdSakolb case RT_PCAP: 5526c97ad5cdSakolb output_pcap(fp); 5527c97ad5cdSakolb break; 55280209230bSgjelinek case RT_MCAP: 55290209230bSgjelinek res1 = zonecfg_get_aliased_rctl(handle, ALIAS_MAXSWAP, 55300209230bSgjelinek &swap_limit); 55310209230bSgjelinek res2 = zonecfg_get_aliased_rctl(handle, 55320209230bSgjelinek ALIAS_MAXLOCKEDMEM, &locked_limit); 55330209230bSgjelinek output_mcap(fp, &in_progress_mcaptab, res1, swap_limit, 55340209230bSgjelinek res2, locked_limit); 55350209230bSgjelinek break; 5536cb8a054bSGlenn Faden case RT_ADMIN: 5537cb8a054bSGlenn Faden output_auth(fp, &in_progress_admintab); 5538cb8a054bSGlenn Faden break; 55397c478bd9Sstevel@tonic-gate } 55407c478bd9Sstevel@tonic-gate goto cleanup; 55417c478bd9Sstevel@tonic-gate } 55427c478bd9Sstevel@tonic-gate 55430209230bSgjelinek type = cmd->cmd_res_type; 55440209230bSgjelinek 55450209230bSgjelinek if (gz_invalid_rt_property(type)) { 55460209230bSgjelinek zerr(gettext("%s is not a valid property for the global zone."), 55470209230bSgjelinek rt_to_str(type)); 55480209230bSgjelinek goto cleanup; 55490209230bSgjelinek } 55500209230bSgjelinek 55510209230bSgjelinek if (gz_invalid_resource(type)) { 55520209230bSgjelinek zerr(gettext("%s is not a valid resource for the global zone."), 55530209230bSgjelinek rt_to_str(type)); 55540209230bSgjelinek goto cleanup; 55550209230bSgjelinek } 55560209230bSgjelinek 55577c478bd9Sstevel@tonic-gate switch (cmd->cmd_res_type) { 55587c478bd9Sstevel@tonic-gate case RT_UNKNOWN: 5559087719fdSdp info_zonename(handle, fp); 55600209230bSgjelinek if (!global_zone) { 55610209230bSgjelinek info_zonepath(handle, fp); 55620209230bSgjelinek info_brand(handle, fp); 55630209230bSgjelinek info_autoboot(handle, fp); 55640209230bSgjelinek info_bootargs(handle, fp); 55650209230bSgjelinek } 55667c478bd9Sstevel@tonic-gate info_pool(handle, fp); 55670209230bSgjelinek if (!global_zone) { 55680209230bSgjelinek info_limitpriv(handle, fp); 55690209230bSgjelinek info_sched(handle, fp); 5570f4b3ec61Sdh info_iptype(handle, fp); 55715679c89fSjv info_hostid(handle, fp); 55720fbb751dSJohn Levon info_fs_allowed(handle, fp); 55730209230bSgjelinek } 55740209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXLWPS); 5575*ff19e029SMenno Lageman info_aliased_rctl(handle, fp, ALIAS_MAXPROCS); 55760209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXSHMMEM); 55770209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXSHMIDS); 55780209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXMSGIDS); 55790209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXSEMIDS); 55800209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_SHARES); 55810209230bSgjelinek if (!global_zone) { 55820209230bSgjelinek info_ipd(handle, fp, cmd); 55830209230bSgjelinek info_fs(handle, fp, cmd); 55840209230bSgjelinek info_net(handle, fp, cmd); 55850209230bSgjelinek info_dev(handle, fp, cmd); 55860209230bSgjelinek } 55870209230bSgjelinek info_pset(handle, fp); 5588c97ad5cdSakolb info_pcap(fp); 55890209230bSgjelinek info_mcap(handle, fp); 55900209230bSgjelinek if (!global_zone) { 55910209230bSgjelinek info_attr(handle, fp, cmd); 55920209230bSgjelinek info_ds(handle, fp, cmd); 5593cb8a054bSGlenn Faden info_auth(handle, fp, cmd); 55940209230bSgjelinek } 55957c478bd9Sstevel@tonic-gate info_rctl(handle, fp, cmd); 55967c478bd9Sstevel@tonic-gate break; 5597087719fdSdp case RT_ZONENAME: 5598087719fdSdp info_zonename(handle, fp); 5599087719fdSdp break; 56007c478bd9Sstevel@tonic-gate case RT_ZONEPATH: 56017c478bd9Sstevel@tonic-gate info_zonepath(handle, fp); 56027c478bd9Sstevel@tonic-gate break; 56039acbbeafSnn case RT_BRAND: 56049acbbeafSnn info_brand(handle, fp); 56059acbbeafSnn break; 56067c478bd9Sstevel@tonic-gate case RT_AUTOBOOT: 56077c478bd9Sstevel@tonic-gate info_autoboot(handle, fp); 56087c478bd9Sstevel@tonic-gate break; 56097c478bd9Sstevel@tonic-gate case RT_POOL: 56107c478bd9Sstevel@tonic-gate info_pool(handle, fp); 56117c478bd9Sstevel@tonic-gate break; 5612ffbafc53Scomay case RT_LIMITPRIV: 5613ffbafc53Scomay info_limitpriv(handle, fp); 5614ffbafc53Scomay break; 56153f2f09c1Sdp case RT_BOOTARGS: 56163f2f09c1Sdp info_bootargs(handle, fp); 56173f2f09c1Sdp break; 56180209230bSgjelinek case RT_SCHED: 56190209230bSgjelinek info_sched(handle, fp); 56200209230bSgjelinek break; 5621f4b3ec61Sdh case RT_IPTYPE: 5622f4b3ec61Sdh info_iptype(handle, fp); 5623f4b3ec61Sdh break; 56240209230bSgjelinek case RT_MAXLWPS: 56250209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXLWPS); 56260209230bSgjelinek break; 5627*ff19e029SMenno Lageman case RT_MAXPROCS: 5628*ff19e029SMenno Lageman info_aliased_rctl(handle, fp, ALIAS_MAXPROCS); 5629*ff19e029SMenno Lageman break; 56300209230bSgjelinek case RT_MAXSHMMEM: 56310209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXSHMMEM); 56320209230bSgjelinek break; 56330209230bSgjelinek case RT_MAXSHMIDS: 56340209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXSHMIDS); 56350209230bSgjelinek break; 56360209230bSgjelinek case RT_MAXMSGIDS: 56370209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXMSGIDS); 56380209230bSgjelinek break; 56390209230bSgjelinek case RT_MAXSEMIDS: 56400209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXSEMIDS); 56410209230bSgjelinek break; 56420209230bSgjelinek case RT_SHARES: 56430209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_SHARES); 56440209230bSgjelinek break; 56457c478bd9Sstevel@tonic-gate case RT_FS: 56467c478bd9Sstevel@tonic-gate info_fs(handle, fp, cmd); 56477c478bd9Sstevel@tonic-gate break; 56487c478bd9Sstevel@tonic-gate case RT_IPD: 56497c478bd9Sstevel@tonic-gate info_ipd(handle, fp, cmd); 56507c478bd9Sstevel@tonic-gate break; 56517c478bd9Sstevel@tonic-gate case RT_NET: 56527c478bd9Sstevel@tonic-gate info_net(handle, fp, cmd); 56537c478bd9Sstevel@tonic-gate break; 56547c478bd9Sstevel@tonic-gate case RT_DEVICE: 56557c478bd9Sstevel@tonic-gate info_dev(handle, fp, cmd); 56567c478bd9Sstevel@tonic-gate break; 56577c478bd9Sstevel@tonic-gate case RT_RCTL: 56587c478bd9Sstevel@tonic-gate info_rctl(handle, fp, cmd); 56597c478bd9Sstevel@tonic-gate break; 56607c478bd9Sstevel@tonic-gate case RT_ATTR: 56617c478bd9Sstevel@tonic-gate info_attr(handle, fp, cmd); 56627c478bd9Sstevel@tonic-gate break; 5663fa9e4066Sahrens case RT_DATASET: 5664fa9e4066Sahrens info_ds(handle, fp, cmd); 5665fa9e4066Sahrens break; 56660209230bSgjelinek case RT_DCPU: 56670209230bSgjelinek info_pset(handle, fp); 56680209230bSgjelinek break; 5669c97ad5cdSakolb case RT_PCAP: 5670c97ad5cdSakolb info_pcap(fp); 5671c97ad5cdSakolb break; 56720209230bSgjelinek case RT_MCAP: 56730209230bSgjelinek info_mcap(handle, fp); 56740209230bSgjelinek break; 56755679c89fSjv case RT_HOSTID: 56765679c89fSjv info_hostid(handle, fp); 56775679c89fSjv break; 5678cb8a054bSGlenn Faden case RT_ADMIN: 5679cb8a054bSGlenn Faden info_auth(handle, fp, cmd); 5680cb8a054bSGlenn Faden break; 56810fbb751dSJohn Levon case RT_FS_ALLOWED: 56820fbb751dSJohn Levon info_fs_allowed(handle, fp); 56830fbb751dSJohn Levon break; 56847c478bd9Sstevel@tonic-gate default: 56857c478bd9Sstevel@tonic-gate zone_perror(rt_to_str(cmd->cmd_res_type), Z_NO_RESOURCE_TYPE, 5686bbec428eSgjelinek B_TRUE); 56877c478bd9Sstevel@tonic-gate } 56887c478bd9Sstevel@tonic-gate 56897c478bd9Sstevel@tonic-gate cleanup: 56907c478bd9Sstevel@tonic-gate if (need_to_close) 56917c478bd9Sstevel@tonic-gate (void) pclose(fp); 56927c478bd9Sstevel@tonic-gate } 56937c478bd9Sstevel@tonic-gate 5694087719fdSdp /* 5695087719fdSdp * Helper function for verify-- checks that a required string property 5696087719fdSdp * exists. 5697087719fdSdp */ 5698087719fdSdp static void 5699087719fdSdp check_reqd_prop(char *attr, int rt, int pt, int *ret_val) 57007c478bd9Sstevel@tonic-gate { 5701087719fdSdp if (strlen(attr) == 0) { 5702087719fdSdp zerr(gettext("%s: %s not specified"), rt_to_str(rt), 5703087719fdSdp pt_to_str(pt)); 5704bbec428eSgjelinek saw_error = B_TRUE; 5705087719fdSdp if (*ret_val == Z_OK) 5706087719fdSdp *ret_val = Z_REQD_PROPERTY_MISSING; 57077c478bd9Sstevel@tonic-gate } 57087c478bd9Sstevel@tonic-gate } 57097c478bd9Sstevel@tonic-gate 57109acbbeafSnn static int 57119acbbeafSnn do_subproc(char *cmdbuf) 57129acbbeafSnn { 57139acbbeafSnn char inbuf[MAX_CMD_LEN]; 57149acbbeafSnn FILE *file; 57159acbbeafSnn int status; 57169acbbeafSnn 57179acbbeafSnn file = popen(cmdbuf, "r"); 57189acbbeafSnn if (file == NULL) { 57199acbbeafSnn zerr(gettext("Could not launch: %s"), cmdbuf); 57209acbbeafSnn return (-1); 57219acbbeafSnn } 57229acbbeafSnn 57239acbbeafSnn while (fgets(inbuf, sizeof (inbuf), file) != NULL) 57249acbbeafSnn fprintf(stderr, "%s", inbuf); 57259acbbeafSnn status = pclose(file); 57269acbbeafSnn 57279acbbeafSnn if (WIFSIGNALED(status)) { 57289acbbeafSnn zerr(gettext("%s unexpectedly terminated due to signal %d"), 57299acbbeafSnn cmdbuf, WTERMSIG(status)); 57309acbbeafSnn return (-1); 57319acbbeafSnn } 57329acbbeafSnn assert(WIFEXITED(status)); 57339acbbeafSnn return (WEXITSTATUS(status)); 57349acbbeafSnn } 57359acbbeafSnn 57369acbbeafSnn static int 57379acbbeafSnn brand_verify(zone_dochandle_t handle) 57389acbbeafSnn { 57396e65f9afSnn char xml_file[32]; 57409acbbeafSnn char cmdbuf[MAX_CMD_LEN]; 5741123807fbSedp brand_handle_t bh; 57429acbbeafSnn char brand[MAXNAMELEN]; 57439acbbeafSnn int err; 57449acbbeafSnn 57459acbbeafSnn if (zonecfg_get_brand(handle, brand, sizeof (brand)) != Z_OK) { 57469acbbeafSnn zerr("%s: %s\n", zone, gettext("could not get zone brand")); 57479acbbeafSnn return (Z_INVALID_DOCUMENT); 57489acbbeafSnn } 5749123807fbSedp if ((bh = brand_open(brand)) == NULL) { 57509acbbeafSnn zerr("%s: %s\n", zone, gettext("unknown brand.")); 57519acbbeafSnn return (Z_INVALID_DOCUMENT); 57529acbbeafSnn } 57539acbbeafSnn 57549acbbeafSnn /* 57559acbbeafSnn * Fetch the verify command, if any, from the brand configuration 57569acbbeafSnn * and build the command line to execute it. 57579acbbeafSnn */ 57589acbbeafSnn strcpy(cmdbuf, EXEC_PREFIX); 5759123807fbSedp err = brand_get_verify_cfg(bh, cmdbuf + EXEC_LEN, 57609acbbeafSnn sizeof (cmdbuf) - (EXEC_LEN + (strlen(xml_file) + 1))); 5761123807fbSedp brand_close(bh); 57629acbbeafSnn if (err != Z_OK) { 57639acbbeafSnn zerr("%s: %s\n", zone, 57649acbbeafSnn gettext("could not get brand verification command")); 57659acbbeafSnn return (Z_INVALID_DOCUMENT); 57669acbbeafSnn } 57679acbbeafSnn 57689acbbeafSnn /* 57699acbbeafSnn * If the brand doesn't provide a verification routine, we just 57709acbbeafSnn * return success. 57719acbbeafSnn */ 57729acbbeafSnn if (strlen(cmdbuf) == EXEC_LEN) 57739acbbeafSnn return (Z_OK); 57749acbbeafSnn 57759acbbeafSnn /* 57769acbbeafSnn * Dump the current config information for this zone to a file. 57779acbbeafSnn */ 57786e65f9afSnn strcpy(xml_file, "/tmp/zonecfg_verify.XXXXXX"); 57799acbbeafSnn if (mkstemp(xml_file) == NULL) 57809acbbeafSnn return (Z_TEMP_FILE); 57819acbbeafSnn if ((err = zonecfg_verify_save(handle, xml_file)) != Z_OK) { 57829acbbeafSnn (void) unlink(xml_file); 57839acbbeafSnn return (err); 57849acbbeafSnn } 57859acbbeafSnn 57869acbbeafSnn /* 57879acbbeafSnn * Execute the verification command. 57889acbbeafSnn */ 57899acbbeafSnn if ((strlcat(cmdbuf, " ", MAX_CMD_LEN) >= MAX_CMD_LEN) || 57909acbbeafSnn (strlcat(cmdbuf, xml_file, MAX_CMD_LEN) >= MAX_CMD_LEN)) { 57919acbbeafSnn err = Z_BRAND_ERROR; 57929acbbeafSnn } else { 57939acbbeafSnn err = do_subproc(cmdbuf); 57949acbbeafSnn } 57959acbbeafSnn 57969acbbeafSnn (void) unlink(xml_file); 57979acbbeafSnn return ((err == Z_OK) ? Z_OK : Z_BRAND_ERROR); 57989acbbeafSnn } 57999acbbeafSnn 58007c478bd9Sstevel@tonic-gate /* 58017c478bd9Sstevel@tonic-gate * See the DTD for which attributes are required for which resources. 58027c478bd9Sstevel@tonic-gate * 58037c478bd9Sstevel@tonic-gate * This function can be called by commit_func(), which needs to save things, 58047c478bd9Sstevel@tonic-gate * in addition to the general call from parse_and_run(), which doesn't need 58057c478bd9Sstevel@tonic-gate * things saved. Since the parameters are standardized, we distinguish by 58067c478bd9Sstevel@tonic-gate * having commit_func() call here with cmd->cmd_arg set to "save" to indicate 58077c478bd9Sstevel@tonic-gate * that a save is needed. 58087c478bd9Sstevel@tonic-gate */ 58097c478bd9Sstevel@tonic-gate void 58107c478bd9Sstevel@tonic-gate verify_func(cmd_t *cmd) 58117c478bd9Sstevel@tonic-gate { 58127c478bd9Sstevel@tonic-gate struct zone_nwiftab nwiftab; 58137c478bd9Sstevel@tonic-gate struct zone_fstab fstab; 58147c478bd9Sstevel@tonic-gate struct zone_attrtab attrtab; 58157c478bd9Sstevel@tonic-gate struct zone_rctltab rctltab; 5816fa9e4066Sahrens struct zone_dstab dstab; 58170209230bSgjelinek struct zone_psettab psettab; 5818cb8a054bSGlenn Faden struct zone_admintab admintab; 58197c478bd9Sstevel@tonic-gate char zonepath[MAXPATHLEN]; 58200209230bSgjelinek char sched[MAXNAMELEN]; 58219acbbeafSnn char brand[MAXNAMELEN]; 58225679c89fSjv char hostidp[HW_HOSTID_LEN]; 58230fbb751dSJohn Levon char fsallowedp[ZONE_FS_ALLOWED_MAX]; 58247c478bd9Sstevel@tonic-gate int err, ret_val = Z_OK, arg; 5825c97ad5cdSakolb int pset_res; 5826bbec428eSgjelinek boolean_t save = B_FALSE; 5827bbec428eSgjelinek boolean_t arg_err = B_FALSE; 5828f4b3ec61Sdh zone_iptype_t iptype; 58290209230bSgjelinek boolean_t has_cpu_shares = B_FALSE; 5830c97ad5cdSakolb boolean_t has_cpu_cap = B_FALSE; 58317c478bd9Sstevel@tonic-gate 58327c478bd9Sstevel@tonic-gate optind = 0; 58337ec75eb8Sgjelinek while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?")) != EOF) { 58347c478bd9Sstevel@tonic-gate switch (arg) { 58357c478bd9Sstevel@tonic-gate case '?': 58367c478bd9Sstevel@tonic-gate longer_usage(CMD_VERIFY); 5837bbec428eSgjelinek arg_err = B_TRUE; 58387ec75eb8Sgjelinek break; 58397c478bd9Sstevel@tonic-gate default: 58407c478bd9Sstevel@tonic-gate short_usage(CMD_VERIFY); 5841bbec428eSgjelinek arg_err = B_TRUE; 58427ec75eb8Sgjelinek break; 58437c478bd9Sstevel@tonic-gate } 58447c478bd9Sstevel@tonic-gate } 58457ec75eb8Sgjelinek if (arg_err) 58467ec75eb8Sgjelinek return; 58477ec75eb8Sgjelinek 58487c478bd9Sstevel@tonic-gate if (optind > cmd->cmd_argc) { 58497c478bd9Sstevel@tonic-gate short_usage(CMD_VERIFY); 58507c478bd9Sstevel@tonic-gate return; 58517c478bd9Sstevel@tonic-gate } 58527c478bd9Sstevel@tonic-gate 58537c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_VERIFY)) 58547c478bd9Sstevel@tonic-gate return; 58557c478bd9Sstevel@tonic-gate 58567c478bd9Sstevel@tonic-gate assert(cmd != NULL); 58577c478bd9Sstevel@tonic-gate 58587c478bd9Sstevel@tonic-gate if (cmd->cmd_argc > 0 && (strcmp(cmd->cmd_argv[0], "save") == 0)) 5859bbec428eSgjelinek save = B_TRUE; 5860bbec428eSgjelinek if (initialize(B_TRUE) != Z_OK) 58617c478bd9Sstevel@tonic-gate return; 58627c478bd9Sstevel@tonic-gate 58630209230bSgjelinek if (zonecfg_get_zonepath(handle, zonepath, sizeof (zonepath)) != Z_OK && 58640209230bSgjelinek !global_zone) { 5865087719fdSdp zerr(gettext("%s not specified"), pt_to_str(PT_ZONEPATH)); 58667c478bd9Sstevel@tonic-gate ret_val = Z_REQD_RESOURCE_MISSING; 5867bbec428eSgjelinek saw_error = B_TRUE; 58687c478bd9Sstevel@tonic-gate } 58690209230bSgjelinek if (strlen(zonepath) == 0 && !global_zone) { 5870087719fdSdp zerr(gettext("%s cannot be empty."), pt_to_str(PT_ZONEPATH)); 58717c478bd9Sstevel@tonic-gate ret_val = Z_REQD_RESOURCE_MISSING; 5872bbec428eSgjelinek saw_error = B_TRUE; 58737c478bd9Sstevel@tonic-gate } 58747c478bd9Sstevel@tonic-gate 58759acbbeafSnn if ((err = zonecfg_get_brand(handle, brand, sizeof (brand))) != Z_OK) { 5876bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 58779acbbeafSnn return; 58789acbbeafSnn } 5879a46da47fSEdward Pilatowicz if ((err = brand_verify(handle)) != Z_OK) { 5880a46da47fSEdward Pilatowicz zone_perror(zone, err, B_TRUE); 5881a46da47fSEdward Pilatowicz return; 58829acbbeafSnn } 58839acbbeafSnn 5884f4b3ec61Sdh if (zonecfg_get_iptype(handle, &iptype) != Z_OK) { 5885f4b3ec61Sdh zerr("%s %s", gettext("cannot get"), pt_to_str(PT_IPTYPE)); 5886f4b3ec61Sdh ret_val = Z_REQD_RESOURCE_MISSING; 5887bbec428eSgjelinek saw_error = B_TRUE; 5888f4b3ec61Sdh } 58897c478bd9Sstevel@tonic-gate if ((err = zonecfg_setipdent(handle)) != Z_OK) { 5890bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 58917c478bd9Sstevel@tonic-gate return; 58927c478bd9Sstevel@tonic-gate } 58937c478bd9Sstevel@tonic-gate while (zonecfg_getipdent(handle, &fstab) == Z_OK) { 5894087719fdSdp check_reqd_prop(fstab.zone_fs_dir, RT_IPD, PT_DIR, &ret_val); 58957c478bd9Sstevel@tonic-gate } 58967c478bd9Sstevel@tonic-gate (void) zonecfg_endipdent(handle); 58977c478bd9Sstevel@tonic-gate 58980fbb751dSJohn Levon if (zonecfg_get_hostid(handle, hostidp, 58990fbb751dSJohn Levon sizeof (hostidp)) == Z_INVALID_PROPERTY) { 59000fbb751dSJohn Levon zerr(gettext("%s: invalid hostid: %s"), 59010fbb751dSJohn Levon zone, hostidp); 59020fbb751dSJohn Levon return; 59030fbb751dSJohn Levon } 59040fbb751dSJohn Levon 59050fbb751dSJohn Levon if (zonecfg_get_fs_allowed(handle, fsallowedp, 59060fbb751dSJohn Levon sizeof (fsallowedp)) == Z_INVALID_PROPERTY) { 59070fbb751dSJohn Levon zerr(gettext("%s: invalid fs-allowed: %s"), 59080fbb751dSJohn Levon zone, fsallowedp); 59095679c89fSjv return; 59105679c89fSjv } 59115679c89fSjv 59127c478bd9Sstevel@tonic-gate if ((err = zonecfg_setfsent(handle)) != Z_OK) { 5913bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 59147c478bd9Sstevel@tonic-gate return; 59157c478bd9Sstevel@tonic-gate } 59167c478bd9Sstevel@tonic-gate while (zonecfg_getfsent(handle, &fstab) == Z_OK) { 5917087719fdSdp check_reqd_prop(fstab.zone_fs_dir, RT_FS, PT_DIR, &ret_val); 5918087719fdSdp check_reqd_prop(fstab.zone_fs_special, RT_FS, PT_SPECIAL, 5919087719fdSdp &ret_val); 5920087719fdSdp check_reqd_prop(fstab.zone_fs_type, RT_FS, PT_TYPE, &ret_val); 5921087719fdSdp 59227c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(fstab.zone_fs_options); 59237c478bd9Sstevel@tonic-gate } 59247c478bd9Sstevel@tonic-gate (void) zonecfg_endfsent(handle); 59257c478bd9Sstevel@tonic-gate 59267c478bd9Sstevel@tonic-gate if ((err = zonecfg_setnwifent(handle)) != Z_OK) { 5927bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 59287c478bd9Sstevel@tonic-gate return; 59297c478bd9Sstevel@tonic-gate } 59307c478bd9Sstevel@tonic-gate while (zonecfg_getnwifent(handle, &nwiftab) == Z_OK) { 5931f4b3ec61Sdh /* 5932f4b3ec61Sdh * physical is required in all cases. 5933de860bd9Sgfaden * A shared IP requires an address, 5934de860bd9Sgfaden * and may include a default router, while 5935de860bd9Sgfaden * an exclusive IP must have neither an address 5936de860bd9Sgfaden * nor a default router. 593701b4bc23Sjv * The physical interface name must be valid in all cases. 5938f4b3ec61Sdh */ 5939087719fdSdp check_reqd_prop(nwiftab.zone_nwif_physical, RT_NET, 5940087719fdSdp PT_PHYSICAL, &ret_val); 594101b4bc23Sjv if (validate_net_physical_syntax(nwiftab.zone_nwif_physical) != 594201b4bc23Sjv Z_OK) { 594301b4bc23Sjv saw_error = B_TRUE; 594401b4bc23Sjv if (ret_val == Z_OK) 594501b4bc23Sjv ret_val = Z_INVAL; 594601b4bc23Sjv } 5947f4b3ec61Sdh 5948f4b3ec61Sdh switch (iptype) { 5949f4b3ec61Sdh case ZS_SHARED: 5950f4b3ec61Sdh check_reqd_prop(nwiftab.zone_nwif_address, RT_NET, 5951f4b3ec61Sdh PT_ADDRESS, &ret_val); 5952f4b3ec61Sdh break; 5953f4b3ec61Sdh case ZS_EXCLUSIVE: 5954f4b3ec61Sdh if (strlen(nwiftab.zone_nwif_address) > 0) { 5955f4b3ec61Sdh zerr(gettext("%s: %s cannot be specified " 5956f4b3ec61Sdh "for an exclusive IP type"), 5957f4b3ec61Sdh rt_to_str(RT_NET), pt_to_str(PT_ADDRESS)); 5958bbec428eSgjelinek saw_error = B_TRUE; 5959f4b3ec61Sdh if (ret_val == Z_OK) 5960f4b3ec61Sdh ret_val = Z_INVAL; 5961f4b3ec61Sdh } 5962de860bd9Sgfaden if (strlen(nwiftab.zone_nwif_defrouter) > 0) { 5963de860bd9Sgfaden zerr(gettext("%s: %s cannot be specified " 5964de860bd9Sgfaden "for an exclusive IP type"), 5965de860bd9Sgfaden rt_to_str(RT_NET), pt_to_str(PT_DEFROUTER)); 5966bbec428eSgjelinek saw_error = B_TRUE; 5967de860bd9Sgfaden if (ret_val == Z_OK) 5968de860bd9Sgfaden ret_val = Z_INVAL; 5969de860bd9Sgfaden } 5970f4b3ec61Sdh break; 5971f4b3ec61Sdh } 59727c478bd9Sstevel@tonic-gate } 59737c478bd9Sstevel@tonic-gate (void) zonecfg_endnwifent(handle); 59747c478bd9Sstevel@tonic-gate 59757c478bd9Sstevel@tonic-gate if ((err = zonecfg_setrctlent(handle)) != Z_OK) { 5976bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 59777c478bd9Sstevel@tonic-gate return; 59787c478bd9Sstevel@tonic-gate } 59797c478bd9Sstevel@tonic-gate while (zonecfg_getrctlent(handle, &rctltab) == Z_OK) { 5980087719fdSdp check_reqd_prop(rctltab.zone_rctl_name, RT_RCTL, PT_NAME, 5981087719fdSdp &ret_val); 5982087719fdSdp 59830209230bSgjelinek if (strcmp(rctltab.zone_rctl_name, "zone.cpu-shares") == 0) 59840209230bSgjelinek has_cpu_shares = B_TRUE; 59850209230bSgjelinek 5986c97ad5cdSakolb if (strcmp(rctltab.zone_rctl_name, "zone.cpu-cap") == 0) 5987c97ad5cdSakolb has_cpu_cap = B_TRUE; 5988c97ad5cdSakolb 59897c478bd9Sstevel@tonic-gate if (rctltab.zone_rctl_valptr == NULL) { 59907c478bd9Sstevel@tonic-gate zerr(gettext("%s: no %s specified"), 59917c478bd9Sstevel@tonic-gate rt_to_str(RT_RCTL), pt_to_str(PT_VALUE)); 5992bbec428eSgjelinek saw_error = B_TRUE; 59937c478bd9Sstevel@tonic-gate if (ret_val == Z_OK) 59947c478bd9Sstevel@tonic-gate ret_val = Z_REQD_PROPERTY_MISSING; 59957c478bd9Sstevel@tonic-gate } else { 59967c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctltab.zone_rctl_valptr); 59977c478bd9Sstevel@tonic-gate } 59987c478bd9Sstevel@tonic-gate } 59997c478bd9Sstevel@tonic-gate (void) zonecfg_endrctlent(handle); 60007c478bd9Sstevel@tonic-gate 6001c97ad5cdSakolb if ((pset_res = zonecfg_lookup_pset(handle, &psettab)) == Z_OK && 6002c97ad5cdSakolb has_cpu_shares) { 60030209230bSgjelinek zerr(gettext("%s zone.cpu-shares and %s are incompatible."), 60040209230bSgjelinek rt_to_str(RT_RCTL), rt_to_str(RT_DCPU)); 6005bbec428eSgjelinek saw_error = B_TRUE; 60060209230bSgjelinek if (ret_val == Z_OK) 60070209230bSgjelinek ret_val = Z_INCOMPATIBLE; 60080209230bSgjelinek } 60090209230bSgjelinek 60100209230bSgjelinek if (has_cpu_shares && zonecfg_get_sched_class(handle, sched, 60110209230bSgjelinek sizeof (sched)) == Z_OK && strlen(sched) > 0 && 60120209230bSgjelinek strcmp(sched, "FSS") != 0) { 60130209230bSgjelinek zerr(gettext("WARNING: %s zone.cpu-shares and %s=%s are " 60140209230bSgjelinek "incompatible"), 60150209230bSgjelinek rt_to_str(RT_RCTL), rt_to_str(RT_SCHED), sched); 6016bbec428eSgjelinek saw_error = B_TRUE; 60170209230bSgjelinek if (ret_val == Z_OK) 60180209230bSgjelinek ret_val = Z_INCOMPATIBLE; 60190209230bSgjelinek } 60200209230bSgjelinek 6021c97ad5cdSakolb if (pset_res == Z_OK && has_cpu_cap) { 6022c97ad5cdSakolb zerr(gettext("%s zone.cpu-cap and the %s are incompatible."), 6023c97ad5cdSakolb rt_to_str(RT_RCTL), rt_to_str(RT_DCPU)); 6024bbec428eSgjelinek saw_error = B_TRUE; 6025c97ad5cdSakolb if (ret_val == Z_OK) 6026c97ad5cdSakolb ret_val = Z_INCOMPATIBLE; 6027c97ad5cdSakolb } 6028c97ad5cdSakolb 60297c478bd9Sstevel@tonic-gate if ((err = zonecfg_setattrent(handle)) != Z_OK) { 6030bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 60317c478bd9Sstevel@tonic-gate return; 60327c478bd9Sstevel@tonic-gate } 60337c478bd9Sstevel@tonic-gate while (zonecfg_getattrent(handle, &attrtab) == Z_OK) { 6034087719fdSdp check_reqd_prop(attrtab.zone_attr_name, RT_ATTR, PT_NAME, 6035087719fdSdp &ret_val); 6036087719fdSdp check_reqd_prop(attrtab.zone_attr_type, RT_ATTR, PT_TYPE, 6037087719fdSdp &ret_val); 6038087719fdSdp check_reqd_prop(attrtab.zone_attr_value, RT_ATTR, PT_VALUE, 6039087719fdSdp &ret_val); 60407c478bd9Sstevel@tonic-gate } 60417c478bd9Sstevel@tonic-gate (void) zonecfg_endattrent(handle); 60427c478bd9Sstevel@tonic-gate 6043fa9e4066Sahrens if ((err = zonecfg_setdsent(handle)) != Z_OK) { 6044bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 6045fa9e4066Sahrens return; 6046fa9e4066Sahrens } 6047fa9e4066Sahrens while (zonecfg_getdsent(handle, &dstab) == Z_OK) { 6048fa9e4066Sahrens if (strlen(dstab.zone_dataset_name) == 0) { 6049fa9e4066Sahrens zerr("%s: %s %s", rt_to_str(RT_DATASET), 6050fa9e4066Sahrens pt_to_str(PT_NAME), gettext("not specified")); 6051bbec428eSgjelinek saw_error = B_TRUE; 6052fa9e4066Sahrens if (ret_val == Z_OK) 6053fa9e4066Sahrens ret_val = Z_REQD_PROPERTY_MISSING; 6054fa9e4066Sahrens } else if (!zfs_name_valid(dstab.zone_dataset_name, 6055fa9e4066Sahrens ZFS_TYPE_FILESYSTEM)) { 6056fa9e4066Sahrens zerr("%s: %s %s", rt_to_str(RT_DATASET), 6057fa9e4066Sahrens pt_to_str(PT_NAME), gettext("invalid")); 6058bbec428eSgjelinek saw_error = B_TRUE; 6059fa9e4066Sahrens if (ret_val == Z_OK) 6060fa9e4066Sahrens ret_val = Z_BAD_PROPERTY; 6061fa9e4066Sahrens } 6062fa9e4066Sahrens 6063fa9e4066Sahrens } 6064fa9e4066Sahrens (void) zonecfg_enddsent(handle); 6065fa9e4066Sahrens 6066cb8a054bSGlenn Faden if ((err = zonecfg_setadminent(handle)) != Z_OK) { 6067cb8a054bSGlenn Faden zone_perror(zone, err, B_TRUE); 6068cb8a054bSGlenn Faden return; 6069cb8a054bSGlenn Faden } 6070cb8a054bSGlenn Faden while (zonecfg_getadminent(handle, &admintab) == Z_OK) { 6071cb8a054bSGlenn Faden check_reqd_prop(admintab.zone_admin_user, RT_ADMIN, 6072cb8a054bSGlenn Faden PT_USER, &ret_val); 6073cb8a054bSGlenn Faden check_reqd_prop(admintab.zone_admin_auths, RT_ADMIN, 6074cb8a054bSGlenn Faden PT_AUTHS, &ret_val); 6075cb8a054bSGlenn Faden if ((ret_val == Z_OK) && (getpwnam(admintab.zone_admin_user) 6076cb8a054bSGlenn Faden == NULL)) { 6077cb8a054bSGlenn Faden zerr(gettext("%s %s is not a valid username"), 6078cb8a054bSGlenn Faden pt_to_str(PT_USER), 6079cb8a054bSGlenn Faden admintab.zone_admin_user); 6080cb8a054bSGlenn Faden ret_val = Z_BAD_PROPERTY; 6081cb8a054bSGlenn Faden } 6082cb8a054bSGlenn Faden if ((ret_val == Z_OK) && (!zonecfg_valid_auths( 6083cb8a054bSGlenn Faden admintab.zone_admin_auths, zone))) { 6084cb8a054bSGlenn Faden ret_val = Z_BAD_PROPERTY; 6085cb8a054bSGlenn Faden } 6086cb8a054bSGlenn Faden } 6087cb8a054bSGlenn Faden (void) zonecfg_endadminent(handle); 6088cb8a054bSGlenn Faden 60897c478bd9Sstevel@tonic-gate if (!global_scope) { 60907c478bd9Sstevel@tonic-gate zerr(gettext("resource specification incomplete")); 6091bbec428eSgjelinek saw_error = B_TRUE; 60927c478bd9Sstevel@tonic-gate if (ret_val == Z_OK) 60937c478bd9Sstevel@tonic-gate ret_val = Z_INSUFFICIENT_SPEC; 60947c478bd9Sstevel@tonic-gate } 60957c478bd9Sstevel@tonic-gate 60967c478bd9Sstevel@tonic-gate if (save) { 6097087719fdSdp if (ret_val == Z_OK) { 6098087719fdSdp if ((ret_val = zonecfg_save(handle)) == Z_OK) { 6099bbec428eSgjelinek need_to_commit = B_FALSE; 6100087719fdSdp (void) strlcpy(revert_zone, zone, 6101087719fdSdp sizeof (revert_zone)); 6102087719fdSdp } 6103087719fdSdp } else { 6104087719fdSdp zerr(gettext("Zone %s failed to verify"), zone); 6105087719fdSdp } 61067c478bd9Sstevel@tonic-gate } 61077c478bd9Sstevel@tonic-gate if (ret_val != Z_OK) 6108bbec428eSgjelinek zone_perror(zone, ret_val, B_TRUE); 61097c478bd9Sstevel@tonic-gate } 61107c478bd9Sstevel@tonic-gate 61117c478bd9Sstevel@tonic-gate void 61127c478bd9Sstevel@tonic-gate cancel_func(cmd_t *cmd) 61137c478bd9Sstevel@tonic-gate { 61147c478bd9Sstevel@tonic-gate int arg; 6115bbec428eSgjelinek boolean_t arg_err = B_FALSE; 61167c478bd9Sstevel@tonic-gate 61177c478bd9Sstevel@tonic-gate assert(cmd != NULL); 61187c478bd9Sstevel@tonic-gate 61197c478bd9Sstevel@tonic-gate optind = 0; 61207ec75eb8Sgjelinek while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?")) != EOF) { 61217c478bd9Sstevel@tonic-gate switch (arg) { 61227c478bd9Sstevel@tonic-gate case '?': 61237c478bd9Sstevel@tonic-gate longer_usage(CMD_CANCEL); 6124bbec428eSgjelinek arg_err = B_TRUE; 61257ec75eb8Sgjelinek break; 61267c478bd9Sstevel@tonic-gate default: 61277c478bd9Sstevel@tonic-gate short_usage(CMD_CANCEL); 6128bbec428eSgjelinek arg_err = B_TRUE; 61297ec75eb8Sgjelinek break; 61307c478bd9Sstevel@tonic-gate } 61317c478bd9Sstevel@tonic-gate } 61327ec75eb8Sgjelinek if (arg_err) 61337ec75eb8Sgjelinek return; 61347ec75eb8Sgjelinek 61357c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 61367c478bd9Sstevel@tonic-gate short_usage(CMD_CANCEL); 61377c478bd9Sstevel@tonic-gate return; 61387c478bd9Sstevel@tonic-gate } 61397c478bd9Sstevel@tonic-gate 61407c478bd9Sstevel@tonic-gate if (global_scope) 61417c478bd9Sstevel@tonic-gate scope_usage(CMD_CANCEL); 6142bbec428eSgjelinek global_scope = B_TRUE; 61437c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(in_progress_fstab.zone_fs_options); 61447c478bd9Sstevel@tonic-gate bzero(&in_progress_fstab, sizeof (in_progress_fstab)); 61457c478bd9Sstevel@tonic-gate bzero(&in_progress_nwiftab, sizeof (in_progress_nwiftab)); 6146fa9e4066Sahrens bzero(&in_progress_ipdtab, sizeof (in_progress_ipdtab)); 61477c478bd9Sstevel@tonic-gate bzero(&in_progress_devtab, sizeof (in_progress_devtab)); 61487c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(in_progress_rctltab.zone_rctl_valptr); 61497c478bd9Sstevel@tonic-gate bzero(&in_progress_rctltab, sizeof (in_progress_rctltab)); 61507c478bd9Sstevel@tonic-gate bzero(&in_progress_attrtab, sizeof (in_progress_attrtab)); 6151fa9e4066Sahrens bzero(&in_progress_dstab, sizeof (in_progress_dstab)); 61527c478bd9Sstevel@tonic-gate } 61537c478bd9Sstevel@tonic-gate 61547c478bd9Sstevel@tonic-gate static int 61557c478bd9Sstevel@tonic-gate validate_attr_name(char *name) 61567c478bd9Sstevel@tonic-gate { 61577c478bd9Sstevel@tonic-gate int i; 61587c478bd9Sstevel@tonic-gate 61597c478bd9Sstevel@tonic-gate if (!isalnum(name[0])) { 61607c478bd9Sstevel@tonic-gate zerr(gettext("Invalid %s %s %s: must start with an alpha-" 61617c478bd9Sstevel@tonic-gate "numeric character."), rt_to_str(RT_ATTR), 61627c478bd9Sstevel@tonic-gate pt_to_str(PT_NAME), name); 61637c478bd9Sstevel@tonic-gate return (Z_INVAL); 61647c478bd9Sstevel@tonic-gate } 61657c478bd9Sstevel@tonic-gate for (i = 1; name[i]; i++) 61667c478bd9Sstevel@tonic-gate if (!isalnum(name[i]) && name[i] != '-' && name[i] != '.') { 61677c478bd9Sstevel@tonic-gate zerr(gettext("Invalid %s %s %s: can only contain " 61687c478bd9Sstevel@tonic-gate "alpha-numeric characters, plus '-' and '.'."), 61697c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR), pt_to_str(PT_NAME), name); 61707c478bd9Sstevel@tonic-gate return (Z_INVAL); 61717c478bd9Sstevel@tonic-gate } 61727c478bd9Sstevel@tonic-gate return (Z_OK); 61737c478bd9Sstevel@tonic-gate } 61747c478bd9Sstevel@tonic-gate 61757c478bd9Sstevel@tonic-gate static int 61767c478bd9Sstevel@tonic-gate validate_attr_type_val(struct zone_attrtab *attrtab) 61777c478bd9Sstevel@tonic-gate { 61787c478bd9Sstevel@tonic-gate boolean_t boolval; 61797c478bd9Sstevel@tonic-gate int64_t intval; 61807c478bd9Sstevel@tonic-gate char strval[MAXNAMELEN]; 61817c478bd9Sstevel@tonic-gate uint64_t uintval; 61827c478bd9Sstevel@tonic-gate 61837c478bd9Sstevel@tonic-gate if (strcmp(attrtab->zone_attr_type, "boolean") == 0) { 61847c478bd9Sstevel@tonic-gate if (zonecfg_get_attr_boolean(attrtab, &boolval) == Z_OK) 61857c478bd9Sstevel@tonic-gate return (Z_OK); 61867c478bd9Sstevel@tonic-gate zerr(gettext("invalid %s value for %s=%s"), 61877c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR), pt_to_str(PT_TYPE), "boolean"); 61887c478bd9Sstevel@tonic-gate return (Z_ERR); 61897c478bd9Sstevel@tonic-gate } 61907c478bd9Sstevel@tonic-gate 61917c478bd9Sstevel@tonic-gate if (strcmp(attrtab->zone_attr_type, "int") == 0) { 61927c478bd9Sstevel@tonic-gate if (zonecfg_get_attr_int(attrtab, &intval) == Z_OK) 61937c478bd9Sstevel@tonic-gate return (Z_OK); 61947c478bd9Sstevel@tonic-gate zerr(gettext("invalid %s value for %s=%s"), 61957c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR), pt_to_str(PT_TYPE), "int"); 61967c478bd9Sstevel@tonic-gate return (Z_ERR); 61977c478bd9Sstevel@tonic-gate } 61987c478bd9Sstevel@tonic-gate 61997c478bd9Sstevel@tonic-gate if (strcmp(attrtab->zone_attr_type, "string") == 0) { 62007c478bd9Sstevel@tonic-gate if (zonecfg_get_attr_string(attrtab, strval, 62017c478bd9Sstevel@tonic-gate sizeof (strval)) == Z_OK) 62027c478bd9Sstevel@tonic-gate return (Z_OK); 62037c478bd9Sstevel@tonic-gate zerr(gettext("invalid %s value for %s=%s"), 62047c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR), pt_to_str(PT_TYPE), "string"); 62057c478bd9Sstevel@tonic-gate return (Z_ERR); 62067c478bd9Sstevel@tonic-gate } 62077c478bd9Sstevel@tonic-gate 62087c478bd9Sstevel@tonic-gate if (strcmp(attrtab->zone_attr_type, "uint") == 0) { 62097c478bd9Sstevel@tonic-gate if (zonecfg_get_attr_uint(attrtab, &uintval) == Z_OK) 62107c478bd9Sstevel@tonic-gate return (Z_OK); 62117c478bd9Sstevel@tonic-gate zerr(gettext("invalid %s value for %s=%s"), 62127c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR), pt_to_str(PT_TYPE), "uint"); 62137c478bd9Sstevel@tonic-gate return (Z_ERR); 62147c478bd9Sstevel@tonic-gate } 62157c478bd9Sstevel@tonic-gate 62167c478bd9Sstevel@tonic-gate zerr(gettext("invalid %s %s '%s'"), rt_to_str(RT_ATTR), 62177c478bd9Sstevel@tonic-gate pt_to_str(PT_TYPE), attrtab->zone_attr_type); 62187c478bd9Sstevel@tonic-gate return (Z_ERR); 62197c478bd9Sstevel@tonic-gate } 62207c478bd9Sstevel@tonic-gate 6221087719fdSdp /* 6222087719fdSdp * Helper function for end_func-- checks the existence of a given property 6223087719fdSdp * and emits a message if not specified. 6224087719fdSdp */ 6225087719fdSdp static int 6226bbec428eSgjelinek end_check_reqd(char *attr, int pt, boolean_t *validation_failed) 6227087719fdSdp { 6228087719fdSdp if (strlen(attr) == 0) { 6229bbec428eSgjelinek *validation_failed = B_TRUE; 6230087719fdSdp zerr(gettext("%s not specified"), pt_to_str(pt)); 6231087719fdSdp return (Z_ERR); 6232087719fdSdp } 6233087719fdSdp return (Z_OK); 6234087719fdSdp } 6235087719fdSdp 62367c478bd9Sstevel@tonic-gate void 62377c478bd9Sstevel@tonic-gate end_func(cmd_t *cmd) 62387c478bd9Sstevel@tonic-gate { 6239bbec428eSgjelinek boolean_t validation_failed = B_FALSE; 6240bbec428eSgjelinek boolean_t arg_err = B_FALSE; 62417c478bd9Sstevel@tonic-gate struct zone_fstab tmp_fstab; 62427c478bd9Sstevel@tonic-gate struct zone_nwiftab tmp_nwiftab; 62437c478bd9Sstevel@tonic-gate struct zone_devtab tmp_devtab; 62447c478bd9Sstevel@tonic-gate struct zone_rctltab tmp_rctltab; 62457c478bd9Sstevel@tonic-gate struct zone_attrtab tmp_attrtab; 6246fa9e4066Sahrens struct zone_dstab tmp_dstab; 6247cb8a054bSGlenn Faden struct zone_admintab tmp_admintab; 62480209230bSgjelinek int err, arg, res1, res2, res3; 62490209230bSgjelinek uint64_t swap_limit; 62500209230bSgjelinek uint64_t locked_limit; 6251c97ad5cdSakolb uint64_t proc_cap; 62527c478bd9Sstevel@tonic-gate 62537c478bd9Sstevel@tonic-gate assert(cmd != NULL); 62547c478bd9Sstevel@tonic-gate 62557c478bd9Sstevel@tonic-gate optind = 0; 62567ec75eb8Sgjelinek while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?")) != EOF) { 62577c478bd9Sstevel@tonic-gate switch (arg) { 62587c478bd9Sstevel@tonic-gate case '?': 62597c478bd9Sstevel@tonic-gate longer_usage(CMD_END); 6260bbec428eSgjelinek arg_err = B_TRUE; 62617ec75eb8Sgjelinek break; 62627c478bd9Sstevel@tonic-gate default: 62637c478bd9Sstevel@tonic-gate short_usage(CMD_END); 6264bbec428eSgjelinek arg_err = B_TRUE; 62657ec75eb8Sgjelinek break; 62667c478bd9Sstevel@tonic-gate } 62677c478bd9Sstevel@tonic-gate } 62687ec75eb8Sgjelinek if (arg_err) 62697ec75eb8Sgjelinek return; 62707ec75eb8Sgjelinek 62717c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 62727c478bd9Sstevel@tonic-gate short_usage(CMD_END); 62737c478bd9Sstevel@tonic-gate return; 62747c478bd9Sstevel@tonic-gate } 62757c478bd9Sstevel@tonic-gate 62767c478bd9Sstevel@tonic-gate if (global_scope) { 62777c478bd9Sstevel@tonic-gate scope_usage(CMD_END); 62787c478bd9Sstevel@tonic-gate return; 62797c478bd9Sstevel@tonic-gate } 62807c478bd9Sstevel@tonic-gate 62817c478bd9Sstevel@tonic-gate assert(end_op == CMD_ADD || end_op == CMD_SELECT); 62827c478bd9Sstevel@tonic-gate 62837c478bd9Sstevel@tonic-gate switch (resource_scope) { 62847c478bd9Sstevel@tonic-gate case RT_FS: 62857c478bd9Sstevel@tonic-gate /* First make sure everything was filled in. */ 6286087719fdSdp if (end_check_reqd(in_progress_fstab.zone_fs_dir, 6287087719fdSdp PT_DIR, &validation_failed) == Z_OK) { 6288087719fdSdp if (in_progress_fstab.zone_fs_dir[0] != '/') { 6289087719fdSdp zerr(gettext("%s %s is not an absolute path."), 6290087719fdSdp pt_to_str(PT_DIR), 6291087719fdSdp in_progress_fstab.zone_fs_dir); 6292bbec428eSgjelinek validation_failed = B_TRUE; 6293087719fdSdp } 62947c478bd9Sstevel@tonic-gate } 6295087719fdSdp 6296087719fdSdp (void) end_check_reqd(in_progress_fstab.zone_fs_special, 6297087719fdSdp PT_SPECIAL, &validation_failed); 6298087719fdSdp 62997c478bd9Sstevel@tonic-gate if (in_progress_fstab.zone_fs_raw[0] != '\0' && 63007c478bd9Sstevel@tonic-gate in_progress_fstab.zone_fs_raw[0] != '/') { 6301087719fdSdp zerr(gettext("%s %s is not an absolute path."), 6302087719fdSdp pt_to_str(PT_RAW), 6303087719fdSdp in_progress_fstab.zone_fs_raw); 6304bbec428eSgjelinek validation_failed = B_TRUE; 63057c478bd9Sstevel@tonic-gate } 6306087719fdSdp 6307087719fdSdp (void) end_check_reqd(in_progress_fstab.zone_fs_type, PT_TYPE, 6308087719fdSdp &validation_failed); 6309087719fdSdp 6310087719fdSdp if (validation_failed) { 6311bbec428eSgjelinek saw_error = B_TRUE; 63127c478bd9Sstevel@tonic-gate return; 6313087719fdSdp } 6314087719fdSdp 63157c478bd9Sstevel@tonic-gate if (end_op == CMD_ADD) { 63167c478bd9Sstevel@tonic-gate /* Make sure there isn't already one like this. */ 63177c478bd9Sstevel@tonic-gate bzero(&tmp_fstab, sizeof (tmp_fstab)); 63187c478bd9Sstevel@tonic-gate (void) strlcpy(tmp_fstab.zone_fs_dir, 63197c478bd9Sstevel@tonic-gate in_progress_fstab.zone_fs_dir, 63207c478bd9Sstevel@tonic-gate sizeof (tmp_fstab.zone_fs_dir)); 63217c478bd9Sstevel@tonic-gate err = zonecfg_lookup_filesystem(handle, &tmp_fstab); 63227c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(tmp_fstab.zone_fs_options); 63237c478bd9Sstevel@tonic-gate if (err == Z_OK) { 63247c478bd9Sstevel@tonic-gate zerr(gettext("A %s resource " 63257c478bd9Sstevel@tonic-gate "with the %s '%s' already exists."), 63267c478bd9Sstevel@tonic-gate rt_to_str(RT_FS), pt_to_str(PT_DIR), 63277c478bd9Sstevel@tonic-gate in_progress_fstab.zone_fs_dir); 6328bbec428eSgjelinek saw_error = B_TRUE; 63297c478bd9Sstevel@tonic-gate return; 63307c478bd9Sstevel@tonic-gate } 63317c478bd9Sstevel@tonic-gate err = zonecfg_add_filesystem(handle, 63327c478bd9Sstevel@tonic-gate &in_progress_fstab); 63337c478bd9Sstevel@tonic-gate } else { 63347c478bd9Sstevel@tonic-gate err = zonecfg_modify_filesystem(handle, &old_fstab, 63357c478bd9Sstevel@tonic-gate &in_progress_fstab); 63367c478bd9Sstevel@tonic-gate } 63377c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(in_progress_fstab.zone_fs_options); 63387c478bd9Sstevel@tonic-gate in_progress_fstab.zone_fs_options = NULL; 63397c478bd9Sstevel@tonic-gate break; 6340087719fdSdp 63417c478bd9Sstevel@tonic-gate case RT_IPD: 63427c478bd9Sstevel@tonic-gate /* First make sure everything was filled in. */ 6343087719fdSdp if (end_check_reqd(in_progress_ipdtab.zone_fs_dir, PT_DIR, 6344087719fdSdp &validation_failed) == Z_OK) { 6345087719fdSdp if (in_progress_ipdtab.zone_fs_dir[0] != '/') { 6346087719fdSdp zerr(gettext("%s %s is not an absolute path."), 6347087719fdSdp pt_to_str(PT_DIR), 6348087719fdSdp in_progress_ipdtab.zone_fs_dir); 6349bbec428eSgjelinek validation_failed = B_TRUE; 6350087719fdSdp } 63517c478bd9Sstevel@tonic-gate } 6352087719fdSdp if (validation_failed) { 6353bbec428eSgjelinek saw_error = B_TRUE; 63547c478bd9Sstevel@tonic-gate return; 6355087719fdSdp } 6356087719fdSdp 63577c478bd9Sstevel@tonic-gate if (end_op == CMD_ADD) { 63587c478bd9Sstevel@tonic-gate /* Make sure there isn't already one like this. */ 63597c478bd9Sstevel@tonic-gate bzero(&tmp_fstab, sizeof (tmp_fstab)); 63607c478bd9Sstevel@tonic-gate (void) strlcpy(tmp_fstab.zone_fs_dir, 63617c478bd9Sstevel@tonic-gate in_progress_ipdtab.zone_fs_dir, 63627c478bd9Sstevel@tonic-gate sizeof (tmp_fstab.zone_fs_dir)); 63637c478bd9Sstevel@tonic-gate err = zonecfg_lookup_ipd(handle, &tmp_fstab); 63647c478bd9Sstevel@tonic-gate if (err == Z_OK) { 63657c478bd9Sstevel@tonic-gate zerr(gettext("An %s resource " 63667c478bd9Sstevel@tonic-gate "with the %s '%s' already exists."), 63677c478bd9Sstevel@tonic-gate rt_to_str(RT_IPD), pt_to_str(PT_DIR), 63687c478bd9Sstevel@tonic-gate in_progress_ipdtab.zone_fs_dir); 6369bbec428eSgjelinek saw_error = B_TRUE; 63707c478bd9Sstevel@tonic-gate return; 63717c478bd9Sstevel@tonic-gate } 63727c478bd9Sstevel@tonic-gate err = zonecfg_add_ipd(handle, &in_progress_ipdtab); 63737c478bd9Sstevel@tonic-gate } else { 63747c478bd9Sstevel@tonic-gate err = zonecfg_modify_ipd(handle, &old_ipdtab, 63757c478bd9Sstevel@tonic-gate &in_progress_ipdtab); 63767c478bd9Sstevel@tonic-gate } 63777c478bd9Sstevel@tonic-gate break; 63787c478bd9Sstevel@tonic-gate case RT_NET: 6379f4b3ec61Sdh /* 6380f4b3ec61Sdh * First make sure everything was filled in. 6381f4b3ec61Sdh * Since we don't know whether IP will be shared 6382f4b3ec61Sdh * or exclusive here, some checks are deferred until 6383f4b3ec61Sdh * the verify command. 6384f4b3ec61Sdh */ 6385087719fdSdp (void) end_check_reqd(in_progress_nwiftab.zone_nwif_physical, 6386087719fdSdp PT_PHYSICAL, &validation_failed); 6387087719fdSdp 6388087719fdSdp if (validation_failed) { 6389bbec428eSgjelinek saw_error = B_TRUE; 63907c478bd9Sstevel@tonic-gate return; 6391087719fdSdp } 63927c478bd9Sstevel@tonic-gate if (end_op == CMD_ADD) { 63937c478bd9Sstevel@tonic-gate /* Make sure there isn't already one like this. */ 63947c478bd9Sstevel@tonic-gate bzero(&tmp_nwiftab, sizeof (tmp_nwiftab)); 6395f4b3ec61Sdh (void) strlcpy(tmp_nwiftab.zone_nwif_physical, 6396f4b3ec61Sdh in_progress_nwiftab.zone_nwif_physical, 6397f4b3ec61Sdh sizeof (tmp_nwiftab.zone_nwif_physical)); 63987c478bd9Sstevel@tonic-gate (void) strlcpy(tmp_nwiftab.zone_nwif_address, 63997c478bd9Sstevel@tonic-gate in_progress_nwiftab.zone_nwif_address, 64007c478bd9Sstevel@tonic-gate sizeof (tmp_nwiftab.zone_nwif_address)); 64017c478bd9Sstevel@tonic-gate if (zonecfg_lookup_nwif(handle, &tmp_nwiftab) == Z_OK) { 6402f4b3ec61Sdh zerr(gettext("A %s resource with the %s '%s', " 6403f4b3ec61Sdh "and %s '%s' already exists."), 6404f4b3ec61Sdh rt_to_str(RT_NET), 6405f4b3ec61Sdh pt_to_str(PT_PHYSICAL), 6406f4b3ec61Sdh in_progress_nwiftab.zone_nwif_physical, 6407f4b3ec61Sdh pt_to_str(PT_ADDRESS), 64087c478bd9Sstevel@tonic-gate in_progress_nwiftab.zone_nwif_address); 6409bbec428eSgjelinek saw_error = B_TRUE; 64107c478bd9Sstevel@tonic-gate return; 64117c478bd9Sstevel@tonic-gate } 64127c478bd9Sstevel@tonic-gate err = zonecfg_add_nwif(handle, &in_progress_nwiftab); 64137c478bd9Sstevel@tonic-gate } else { 64147c478bd9Sstevel@tonic-gate err = zonecfg_modify_nwif(handle, &old_nwiftab, 64157c478bd9Sstevel@tonic-gate &in_progress_nwiftab); 64167c478bd9Sstevel@tonic-gate } 64177c478bd9Sstevel@tonic-gate break; 6418087719fdSdp 64197c478bd9Sstevel@tonic-gate case RT_DEVICE: 64207c478bd9Sstevel@tonic-gate /* First make sure everything was filled in. */ 6421087719fdSdp (void) end_check_reqd(in_progress_devtab.zone_dev_match, 6422087719fdSdp PT_MATCH, &validation_failed); 6423087719fdSdp 6424087719fdSdp if (validation_failed) { 6425bbec428eSgjelinek saw_error = B_TRUE; 64267c478bd9Sstevel@tonic-gate return; 6427087719fdSdp } 6428087719fdSdp 64297c478bd9Sstevel@tonic-gate if (end_op == CMD_ADD) { 64307c478bd9Sstevel@tonic-gate /* Make sure there isn't already one like this. */ 64317c478bd9Sstevel@tonic-gate (void) strlcpy(tmp_devtab.zone_dev_match, 64327c478bd9Sstevel@tonic-gate in_progress_devtab.zone_dev_match, 64337c478bd9Sstevel@tonic-gate sizeof (tmp_devtab.zone_dev_match)); 64347c478bd9Sstevel@tonic-gate if (zonecfg_lookup_dev(handle, &tmp_devtab) == Z_OK) { 64357c478bd9Sstevel@tonic-gate zerr(gettext("A %s resource with the %s '%s' " 64367c478bd9Sstevel@tonic-gate "already exists."), rt_to_str(RT_DEVICE), 64377c478bd9Sstevel@tonic-gate pt_to_str(PT_MATCH), 64387c478bd9Sstevel@tonic-gate in_progress_devtab.zone_dev_match); 6439bbec428eSgjelinek saw_error = B_TRUE; 64407c478bd9Sstevel@tonic-gate return; 64417c478bd9Sstevel@tonic-gate } 64427c478bd9Sstevel@tonic-gate err = zonecfg_add_dev(handle, &in_progress_devtab); 64437c478bd9Sstevel@tonic-gate } else { 64447c478bd9Sstevel@tonic-gate err = zonecfg_modify_dev(handle, &old_devtab, 64457c478bd9Sstevel@tonic-gate &in_progress_devtab); 64467c478bd9Sstevel@tonic-gate } 64477c478bd9Sstevel@tonic-gate break; 6448087719fdSdp 64497c478bd9Sstevel@tonic-gate case RT_RCTL: 64507c478bd9Sstevel@tonic-gate /* First make sure everything was filled in. */ 6451087719fdSdp (void) end_check_reqd(in_progress_rctltab.zone_rctl_name, 6452087719fdSdp PT_NAME, &validation_failed); 6453087719fdSdp 64547c478bd9Sstevel@tonic-gate if (in_progress_rctltab.zone_rctl_valptr == NULL) { 64557c478bd9Sstevel@tonic-gate zerr(gettext("no %s specified"), pt_to_str(PT_VALUE)); 6456bbec428eSgjelinek validation_failed = B_TRUE; 64577c478bd9Sstevel@tonic-gate } 6458087719fdSdp 6459087719fdSdp if (validation_failed) { 6460bbec428eSgjelinek saw_error = B_TRUE; 64617c478bd9Sstevel@tonic-gate return; 6462087719fdSdp } 6463087719fdSdp 64647c478bd9Sstevel@tonic-gate if (end_op == CMD_ADD) { 64657c478bd9Sstevel@tonic-gate /* Make sure there isn't already one like this. */ 64667c478bd9Sstevel@tonic-gate (void) strlcpy(tmp_rctltab.zone_rctl_name, 64677c478bd9Sstevel@tonic-gate in_progress_rctltab.zone_rctl_name, 64687c478bd9Sstevel@tonic-gate sizeof (tmp_rctltab.zone_rctl_name)); 64697c478bd9Sstevel@tonic-gate tmp_rctltab.zone_rctl_valptr = NULL; 64707c478bd9Sstevel@tonic-gate err = zonecfg_lookup_rctl(handle, &tmp_rctltab); 64717c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list( 64727c478bd9Sstevel@tonic-gate tmp_rctltab.zone_rctl_valptr); 64737c478bd9Sstevel@tonic-gate if (err == Z_OK) { 64747c478bd9Sstevel@tonic-gate zerr(gettext("A %s resource " 64757c478bd9Sstevel@tonic-gate "with the %s '%s' already exists."), 64767c478bd9Sstevel@tonic-gate rt_to_str(RT_RCTL), pt_to_str(PT_NAME), 64777c478bd9Sstevel@tonic-gate in_progress_rctltab.zone_rctl_name); 6478bbec428eSgjelinek saw_error = B_TRUE; 64797c478bd9Sstevel@tonic-gate return; 64807c478bd9Sstevel@tonic-gate } 64817c478bd9Sstevel@tonic-gate err = zonecfg_add_rctl(handle, &in_progress_rctltab); 64827c478bd9Sstevel@tonic-gate } else { 64837c478bd9Sstevel@tonic-gate err = zonecfg_modify_rctl(handle, &old_rctltab, 64847c478bd9Sstevel@tonic-gate &in_progress_rctltab); 64857c478bd9Sstevel@tonic-gate } 64867c478bd9Sstevel@tonic-gate if (err == Z_OK) { 64877c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list( 64887c478bd9Sstevel@tonic-gate in_progress_rctltab.zone_rctl_valptr); 64897c478bd9Sstevel@tonic-gate in_progress_rctltab.zone_rctl_valptr = NULL; 64907c478bd9Sstevel@tonic-gate } 64917c478bd9Sstevel@tonic-gate break; 6492087719fdSdp 64937c478bd9Sstevel@tonic-gate case RT_ATTR: 64947c478bd9Sstevel@tonic-gate /* First make sure everything was filled in. */ 6495087719fdSdp (void) end_check_reqd(in_progress_attrtab.zone_attr_name, 6496087719fdSdp PT_NAME, &validation_failed); 6497087719fdSdp (void) end_check_reqd(in_progress_attrtab.zone_attr_type, 6498087719fdSdp PT_TYPE, &validation_failed); 6499087719fdSdp (void) end_check_reqd(in_progress_attrtab.zone_attr_value, 6500087719fdSdp PT_VALUE, &validation_failed); 6501087719fdSdp 65027c478bd9Sstevel@tonic-gate if (validate_attr_name(in_progress_attrtab.zone_attr_name) != 6503087719fdSdp Z_OK) 6504bbec428eSgjelinek validation_failed = B_TRUE; 6505087719fdSdp 6506087719fdSdp if (validate_attr_type_val(&in_progress_attrtab) != Z_OK) 6507bbec428eSgjelinek validation_failed = B_TRUE; 6508087719fdSdp 6509087719fdSdp if (validation_failed) { 6510bbec428eSgjelinek saw_error = B_TRUE; 65117c478bd9Sstevel@tonic-gate return; 6512087719fdSdp } 65137c478bd9Sstevel@tonic-gate if (end_op == CMD_ADD) { 65147c478bd9Sstevel@tonic-gate /* Make sure there isn't already one like this. */ 65157c478bd9Sstevel@tonic-gate bzero(&tmp_attrtab, sizeof (tmp_attrtab)); 65167c478bd9Sstevel@tonic-gate (void) strlcpy(tmp_attrtab.zone_attr_name, 65177c478bd9Sstevel@tonic-gate in_progress_attrtab.zone_attr_name, 65187c478bd9Sstevel@tonic-gate sizeof (tmp_attrtab.zone_attr_name)); 65197c478bd9Sstevel@tonic-gate if (zonecfg_lookup_attr(handle, &tmp_attrtab) == Z_OK) { 65207c478bd9Sstevel@tonic-gate zerr(gettext("An %s resource " 65217c478bd9Sstevel@tonic-gate "with the %s '%s' already exists."), 65227c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR), pt_to_str(PT_NAME), 65237c478bd9Sstevel@tonic-gate in_progress_attrtab.zone_attr_name); 6524bbec428eSgjelinek saw_error = B_TRUE; 65257c478bd9Sstevel@tonic-gate return; 65267c478bd9Sstevel@tonic-gate } 65277c478bd9Sstevel@tonic-gate err = zonecfg_add_attr(handle, &in_progress_attrtab); 65287c478bd9Sstevel@tonic-gate } else { 65297c478bd9Sstevel@tonic-gate err = zonecfg_modify_attr(handle, &old_attrtab, 65307c478bd9Sstevel@tonic-gate &in_progress_attrtab); 65317c478bd9Sstevel@tonic-gate } 65327c478bd9Sstevel@tonic-gate break; 6533fa9e4066Sahrens case RT_DATASET: 6534fa9e4066Sahrens /* First make sure everything was filled in. */ 6535fa9e4066Sahrens if (strlen(in_progress_dstab.zone_dataset_name) == 0) { 6536fa9e4066Sahrens zerr("%s %s", pt_to_str(PT_NAME), 6537fa9e4066Sahrens gettext("not specified")); 6538bbec428eSgjelinek saw_error = B_TRUE; 6539bbec428eSgjelinek validation_failed = B_TRUE; 6540fa9e4066Sahrens } 6541fa9e4066Sahrens if (validation_failed) 6542fa9e4066Sahrens return; 6543fa9e4066Sahrens if (end_op == CMD_ADD) { 6544fa9e4066Sahrens /* Make sure there isn't already one like this. */ 6545fa9e4066Sahrens bzero(&tmp_dstab, sizeof (tmp_dstab)); 6546fa9e4066Sahrens (void) strlcpy(tmp_dstab.zone_dataset_name, 6547fa9e4066Sahrens in_progress_dstab.zone_dataset_name, 6548fa9e4066Sahrens sizeof (tmp_dstab.zone_dataset_name)); 6549fa9e4066Sahrens err = zonecfg_lookup_ds(handle, &tmp_dstab); 6550fa9e4066Sahrens if (err == Z_OK) { 6551fa9e4066Sahrens zerr(gettext("A %s resource " 6552fa9e4066Sahrens "with the %s '%s' already exists."), 6553fa9e4066Sahrens rt_to_str(RT_DATASET), pt_to_str(PT_NAME), 6554fa9e4066Sahrens in_progress_dstab.zone_dataset_name); 6555bbec428eSgjelinek saw_error = B_TRUE; 6556fa9e4066Sahrens return; 6557fa9e4066Sahrens } 6558fa9e4066Sahrens err = zonecfg_add_ds(handle, &in_progress_dstab); 6559fa9e4066Sahrens } else { 6560fa9e4066Sahrens err = zonecfg_modify_ds(handle, &old_dstab, 6561fa9e4066Sahrens &in_progress_dstab); 6562fa9e4066Sahrens } 6563fa9e4066Sahrens break; 65640209230bSgjelinek case RT_DCPU: 65650209230bSgjelinek /* Make sure everything was filled in. */ 65660209230bSgjelinek if (end_check_reqd(in_progress_psettab.zone_ncpu_min, 65670209230bSgjelinek PT_NCPUS, &validation_failed) != Z_OK) { 6568bbec428eSgjelinek saw_error = B_TRUE; 65690209230bSgjelinek return; 65700209230bSgjelinek } 65710209230bSgjelinek 65720209230bSgjelinek if (end_op == CMD_ADD) { 65730209230bSgjelinek err = zonecfg_add_pset(handle, &in_progress_psettab); 65740209230bSgjelinek } else { 65750209230bSgjelinek err = zonecfg_modify_pset(handle, &in_progress_psettab); 65760209230bSgjelinek } 65770209230bSgjelinek break; 6578c97ad5cdSakolb case RT_PCAP: 6579c97ad5cdSakolb /* Make sure everything was filled in. */ 6580c97ad5cdSakolb if (zonecfg_get_aliased_rctl(handle, ALIAS_CPUCAP, &proc_cap) 6581c97ad5cdSakolb != Z_OK) { 6582c97ad5cdSakolb zerr(gettext("%s not specified"), pt_to_str(PT_NCPUS)); 6583bbec428eSgjelinek saw_error = B_TRUE; 6584bbec428eSgjelinek validation_failed = B_TRUE; 6585c97ad5cdSakolb return; 6586c97ad5cdSakolb } 6587c97ad5cdSakolb err = Z_OK; 6588c97ad5cdSakolb break; 65890209230bSgjelinek case RT_MCAP: 65900209230bSgjelinek /* Make sure everything was filled in. */ 65910209230bSgjelinek res1 = strlen(in_progress_mcaptab.zone_physmem_cap) == 0 ? 65920209230bSgjelinek Z_ERR : Z_OK; 65930209230bSgjelinek res2 = zonecfg_get_aliased_rctl(handle, ALIAS_MAXSWAP, 65940209230bSgjelinek &swap_limit); 65950209230bSgjelinek res3 = zonecfg_get_aliased_rctl(handle, ALIAS_MAXLOCKEDMEM, 65960209230bSgjelinek &locked_limit); 65970209230bSgjelinek 65980209230bSgjelinek if (res1 != Z_OK && res2 != Z_OK && res3 != Z_OK) { 65990209230bSgjelinek zerr(gettext("No property was specified. One of %s, " 66000209230bSgjelinek "%s or %s is required."), pt_to_str(PT_PHYSICAL), 66010209230bSgjelinek pt_to_str(PT_SWAP), pt_to_str(PT_LOCKED)); 6602bbec428eSgjelinek saw_error = B_TRUE; 66030209230bSgjelinek return; 66040209230bSgjelinek } 66050209230bSgjelinek 66060209230bSgjelinek /* if phys & locked are both set, verify locked <= phys */ 66070209230bSgjelinek if (res1 == Z_OK && res3 == Z_OK) { 66080209230bSgjelinek uint64_t phys_limit; 66090209230bSgjelinek char *endp; 66100209230bSgjelinek 66110209230bSgjelinek phys_limit = strtoull( 66120209230bSgjelinek in_progress_mcaptab.zone_physmem_cap, &endp, 10); 66130209230bSgjelinek if (phys_limit < locked_limit) { 66140209230bSgjelinek zerr(gettext("The %s cap must be less than or " 66150209230bSgjelinek "equal to the %s cap."), 66160209230bSgjelinek pt_to_str(PT_LOCKED), 66170209230bSgjelinek pt_to_str(PT_PHYSICAL)); 6618bbec428eSgjelinek saw_error = B_TRUE; 66190209230bSgjelinek return; 66200209230bSgjelinek } 66210209230bSgjelinek } 66220209230bSgjelinek 66230209230bSgjelinek err = Z_OK; 66240209230bSgjelinek if (res1 == Z_OK) { 66250209230bSgjelinek /* 66260209230bSgjelinek * We could be ending from either an add operation 66270209230bSgjelinek * or a select operation. Since all of the properties 66280209230bSgjelinek * within this resource are optional, we always use 66290209230bSgjelinek * modify on the mcap entry. zonecfg_modify_mcap() 66300209230bSgjelinek * will handle both adding and modifying a memory cap. 66310209230bSgjelinek */ 66320209230bSgjelinek err = zonecfg_modify_mcap(handle, &in_progress_mcaptab); 66330209230bSgjelinek } else if (end_op == CMD_SELECT) { 66340209230bSgjelinek /* 66350209230bSgjelinek * If we're ending from a select and the physical 66360209230bSgjelinek * memory cap is empty then the user could have cleared 66370209230bSgjelinek * the physical cap value, so try to delete the entry. 66380209230bSgjelinek */ 66390209230bSgjelinek (void) zonecfg_delete_mcap(handle); 66400209230bSgjelinek } 66410209230bSgjelinek break; 6642cb8a054bSGlenn Faden case RT_ADMIN: 6643cb8a054bSGlenn Faden /* First make sure everything was filled in. */ 6644cb8a054bSGlenn Faden if (end_check_reqd(in_progress_admintab.zone_admin_user, 6645cb8a054bSGlenn Faden PT_USER, &validation_failed) == Z_OK) { 6646cb8a054bSGlenn Faden if (getpwnam(in_progress_admintab.zone_admin_user) 6647cb8a054bSGlenn Faden == NULL) { 6648cb8a054bSGlenn Faden zerr(gettext("%s %s is not a valid username"), 6649cb8a054bSGlenn Faden pt_to_str(PT_USER), 6650cb8a054bSGlenn Faden in_progress_admintab.zone_admin_user); 6651cb8a054bSGlenn Faden validation_failed = B_TRUE; 6652cb8a054bSGlenn Faden } 6653cb8a054bSGlenn Faden } 6654cb8a054bSGlenn Faden 6655cb8a054bSGlenn Faden if (end_check_reqd(in_progress_admintab.zone_admin_auths, 6656cb8a054bSGlenn Faden PT_AUTHS, &validation_failed) == Z_OK) { 6657cb8a054bSGlenn Faden if (!zonecfg_valid_auths( 6658cb8a054bSGlenn Faden in_progress_admintab.zone_admin_auths, 6659cb8a054bSGlenn Faden zone)) { 6660cb8a054bSGlenn Faden validation_failed = B_TRUE; 6661cb8a054bSGlenn Faden } 6662cb8a054bSGlenn Faden } 6663cb8a054bSGlenn Faden 6664cb8a054bSGlenn Faden if (validation_failed) { 6665cb8a054bSGlenn Faden saw_error = B_TRUE; 6666cb8a054bSGlenn Faden return; 6667cb8a054bSGlenn Faden } 6668cb8a054bSGlenn Faden 6669cb8a054bSGlenn Faden if (end_op == CMD_ADD) { 6670cb8a054bSGlenn Faden /* Make sure there isn't already one like this. */ 6671cb8a054bSGlenn Faden bzero(&tmp_admintab, sizeof (tmp_admintab)); 6672cb8a054bSGlenn Faden (void) strlcpy(tmp_admintab.zone_admin_user, 6673cb8a054bSGlenn Faden in_progress_admintab.zone_admin_user, 6674cb8a054bSGlenn Faden sizeof (tmp_admintab.zone_admin_user)); 6675cb8a054bSGlenn Faden err = zonecfg_lookup_admin( 6676cb8a054bSGlenn Faden handle, &tmp_admintab); 6677cb8a054bSGlenn Faden if (err == Z_OK) { 6678cb8a054bSGlenn Faden zerr(gettext("A %s resource " 6679cb8a054bSGlenn Faden "with the %s '%s' already exists."), 6680cb8a054bSGlenn Faden rt_to_str(RT_ADMIN), 6681cb8a054bSGlenn Faden pt_to_str(PT_USER), 6682cb8a054bSGlenn Faden in_progress_admintab.zone_admin_user); 6683cb8a054bSGlenn Faden saw_error = B_TRUE; 6684cb8a054bSGlenn Faden return; 6685cb8a054bSGlenn Faden } 6686cb8a054bSGlenn Faden err = zonecfg_add_admin(handle, 6687cb8a054bSGlenn Faden &in_progress_admintab, zone); 6688cb8a054bSGlenn Faden } else { 6689cb8a054bSGlenn Faden err = zonecfg_modify_admin(handle, 6690cb8a054bSGlenn Faden &old_admintab, &in_progress_admintab, 6691cb8a054bSGlenn Faden zone); 6692cb8a054bSGlenn Faden } 6693cb8a054bSGlenn Faden break; 66947c478bd9Sstevel@tonic-gate default: 66957c478bd9Sstevel@tonic-gate zone_perror(rt_to_str(resource_scope), Z_NO_RESOURCE_TYPE, 6696bbec428eSgjelinek B_TRUE); 6697bbec428eSgjelinek saw_error = B_TRUE; 66987c478bd9Sstevel@tonic-gate return; 66997c478bd9Sstevel@tonic-gate } 67007c478bd9Sstevel@tonic-gate 67017c478bd9Sstevel@tonic-gate if (err != Z_OK) { 6702bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 67037c478bd9Sstevel@tonic-gate } else { 6704bbec428eSgjelinek need_to_commit = B_TRUE; 6705bbec428eSgjelinek global_scope = B_TRUE; 67067c478bd9Sstevel@tonic-gate end_op = -1; 67077c478bd9Sstevel@tonic-gate } 67087c478bd9Sstevel@tonic-gate } 67097c478bd9Sstevel@tonic-gate 67107c478bd9Sstevel@tonic-gate void 67117c478bd9Sstevel@tonic-gate commit_func(cmd_t *cmd) 67127c478bd9Sstevel@tonic-gate { 67137c478bd9Sstevel@tonic-gate int arg; 6714bbec428eSgjelinek boolean_t arg_err = B_FALSE; 67157c478bd9Sstevel@tonic-gate 67167c478bd9Sstevel@tonic-gate optind = 0; 67177ec75eb8Sgjelinek while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?")) != EOF) { 67187c478bd9Sstevel@tonic-gate switch (arg) { 67197c478bd9Sstevel@tonic-gate case '?': 67207c478bd9Sstevel@tonic-gate longer_usage(CMD_COMMIT); 6721bbec428eSgjelinek arg_err = B_TRUE; 67227ec75eb8Sgjelinek break; 67237c478bd9Sstevel@tonic-gate default: 67247c478bd9Sstevel@tonic-gate short_usage(CMD_COMMIT); 6725bbec428eSgjelinek arg_err = B_TRUE; 67267ec75eb8Sgjelinek break; 67277c478bd9Sstevel@tonic-gate } 67287c478bd9Sstevel@tonic-gate } 67297ec75eb8Sgjelinek if (arg_err) 67307ec75eb8Sgjelinek return; 67317ec75eb8Sgjelinek 67327c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 67337c478bd9Sstevel@tonic-gate short_usage(CMD_COMMIT); 67347c478bd9Sstevel@tonic-gate return; 67357c478bd9Sstevel@tonic-gate } 67367c478bd9Sstevel@tonic-gate 67377c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_COMMIT)) 67387c478bd9Sstevel@tonic-gate return; 67397c478bd9Sstevel@tonic-gate 67407c478bd9Sstevel@tonic-gate assert(cmd != NULL); 67417c478bd9Sstevel@tonic-gate 67427c478bd9Sstevel@tonic-gate cmd->cmd_argc = 1; 67437c478bd9Sstevel@tonic-gate /* 67447c478bd9Sstevel@tonic-gate * cmd_arg normally comes from a strdup() in the lexer, and the 67457c478bd9Sstevel@tonic-gate * whole cmd structure and its (char *) attributes are freed at 67467c478bd9Sstevel@tonic-gate * the completion of each command, so the strdup() below is needed 67477c478bd9Sstevel@tonic-gate * to match this and prevent a core dump from trying to free() 67487c478bd9Sstevel@tonic-gate * something that can't be. 67497c478bd9Sstevel@tonic-gate */ 67507c478bd9Sstevel@tonic-gate if ((cmd->cmd_argv[0] = strdup("save")) == NULL) { 6751bbec428eSgjelinek zone_perror(zone, Z_NOMEM, B_TRUE); 67527c478bd9Sstevel@tonic-gate exit(Z_ERR); 67537c478bd9Sstevel@tonic-gate } 67547c478bd9Sstevel@tonic-gate cmd->cmd_argv[1] = NULL; 67557c478bd9Sstevel@tonic-gate verify_func(cmd); 67567c478bd9Sstevel@tonic-gate } 67577c478bd9Sstevel@tonic-gate 67587c478bd9Sstevel@tonic-gate void 67597c478bd9Sstevel@tonic-gate revert_func(cmd_t *cmd) 67607c478bd9Sstevel@tonic-gate { 67617c478bd9Sstevel@tonic-gate char line[128]; /* enough to ask a question */ 6762bbec428eSgjelinek boolean_t force = B_FALSE; 6763bbec428eSgjelinek boolean_t arg_err = B_FALSE; 67647c478bd9Sstevel@tonic-gate int err, arg, answer; 67657c478bd9Sstevel@tonic-gate 67667c478bd9Sstevel@tonic-gate optind = 0; 67677c478bd9Sstevel@tonic-gate while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?F")) != EOF) { 67687c478bd9Sstevel@tonic-gate switch (arg) { 67697c478bd9Sstevel@tonic-gate case '?': 67707c478bd9Sstevel@tonic-gate longer_usage(CMD_REVERT); 6771bbec428eSgjelinek arg_err = B_TRUE; 67727ec75eb8Sgjelinek break; 67737c478bd9Sstevel@tonic-gate case 'F': 6774bbec428eSgjelinek force = B_TRUE; 67757c478bd9Sstevel@tonic-gate break; 67767c478bd9Sstevel@tonic-gate default: 67777c478bd9Sstevel@tonic-gate short_usage(CMD_REVERT); 6778bbec428eSgjelinek arg_err = B_TRUE; 67797ec75eb8Sgjelinek break; 67807c478bd9Sstevel@tonic-gate } 67817c478bd9Sstevel@tonic-gate } 67827ec75eb8Sgjelinek if (arg_err) 67837ec75eb8Sgjelinek return; 67847ec75eb8Sgjelinek 67857c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 67867c478bd9Sstevel@tonic-gate short_usage(CMD_REVERT); 67877c478bd9Sstevel@tonic-gate return; 67887c478bd9Sstevel@tonic-gate } 67897c478bd9Sstevel@tonic-gate 67907c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_REVERT)) 67917c478bd9Sstevel@tonic-gate return; 67927c478bd9Sstevel@tonic-gate 67935b418297Sjv if (!global_scope) { 67945b418297Sjv zerr(gettext("You can only use %s in the global scope.\nUse" 67955b418297Sjv " '%s' to cancel changes to a resource specification."), 67965b418297Sjv cmd_to_str(CMD_REVERT), cmd_to_str(CMD_CANCEL)); 67975b418297Sjv saw_error = B_TRUE; 67985b418297Sjv return; 67995b418297Sjv } 68005b418297Sjv 68017c478bd9Sstevel@tonic-gate if (zonecfg_check_handle(handle) != Z_OK) { 68027c478bd9Sstevel@tonic-gate zerr(gettext("No changes to revert.")); 6803bbec428eSgjelinek saw_error = B_TRUE; 68047c478bd9Sstevel@tonic-gate return; 68057c478bd9Sstevel@tonic-gate } 68067c478bd9Sstevel@tonic-gate 68077c478bd9Sstevel@tonic-gate if (!force) { 68087c478bd9Sstevel@tonic-gate (void) snprintf(line, sizeof (line), 68097c478bd9Sstevel@tonic-gate gettext("Are you sure you want to revert")); 6810bbec428eSgjelinek if ((answer = ask_yesno(B_FALSE, line)) == -1) { 68117c478bd9Sstevel@tonic-gate zerr(gettext("Input not from terminal and -F not " 68127c478bd9Sstevel@tonic-gate "specified:\n%s command ignored, exiting."), 68137c478bd9Sstevel@tonic-gate cmd_to_str(CMD_REVERT)); 68147c478bd9Sstevel@tonic-gate exit(Z_ERR); 68157c478bd9Sstevel@tonic-gate } 68167c478bd9Sstevel@tonic-gate if (answer != 1) 68177c478bd9Sstevel@tonic-gate return; 68187c478bd9Sstevel@tonic-gate } 68197c478bd9Sstevel@tonic-gate 6820cb8a054bSGlenn Faden /* 6821cb8a054bSGlenn Faden * Reset any pending admins that were 6822cb8a054bSGlenn Faden * removed from the previous zone 6823cb8a054bSGlenn Faden */ 6824cb8a054bSGlenn Faden zonecfg_remove_userauths(handle, "", zone, B_FALSE); 6825cb8a054bSGlenn Faden 68267c478bd9Sstevel@tonic-gate /* 68277c478bd9Sstevel@tonic-gate * Time for a new handle: finish the old one off first 68287c478bd9Sstevel@tonic-gate * then get a new one properly to avoid leaks. 68297c478bd9Sstevel@tonic-gate */ 68307c478bd9Sstevel@tonic-gate zonecfg_fini_handle(handle); 68317c478bd9Sstevel@tonic-gate if ((handle = zonecfg_init_handle()) == NULL) { 6832bbec428eSgjelinek zone_perror(execname, Z_NOMEM, B_TRUE); 68337c478bd9Sstevel@tonic-gate exit(Z_ERR); 68347c478bd9Sstevel@tonic-gate } 6835cb8a054bSGlenn Faden 6836087719fdSdp if ((err = zonecfg_get_handle(revert_zone, handle)) != Z_OK) { 6837bbec428eSgjelinek saw_error = B_TRUE; 6838bbec428eSgjelinek got_handle = B_FALSE; 68397c478bd9Sstevel@tonic-gate if (err == Z_NO_ZONE) 68407c478bd9Sstevel@tonic-gate zerr(gettext("%s: no such saved zone to revert to."), 6841087719fdSdp revert_zone); 68427c478bd9Sstevel@tonic-gate else 6843bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 68447c478bd9Sstevel@tonic-gate } 6845087719fdSdp (void) strlcpy(zone, revert_zone, sizeof (zone)); 68467c478bd9Sstevel@tonic-gate } 68477c478bd9Sstevel@tonic-gate 68487c478bd9Sstevel@tonic-gate void 68497c478bd9Sstevel@tonic-gate help_func(cmd_t *cmd) 68507c478bd9Sstevel@tonic-gate { 68517c478bd9Sstevel@tonic-gate int i; 68527c478bd9Sstevel@tonic-gate 68537c478bd9Sstevel@tonic-gate assert(cmd != NULL); 68547c478bd9Sstevel@tonic-gate 68557c478bd9Sstevel@tonic-gate if (cmd->cmd_argc == 0) { 6856bbec428eSgjelinek usage(B_TRUE, global_scope ? HELP_SUBCMDS : HELP_RES_SCOPE); 68577c478bd9Sstevel@tonic-gate return; 68587c478bd9Sstevel@tonic-gate } 68597c478bd9Sstevel@tonic-gate if (strcmp(cmd->cmd_argv[0], "usage") == 0) { 6860bbec428eSgjelinek usage(B_TRUE, HELP_USAGE); 68617c478bd9Sstevel@tonic-gate return; 68627c478bd9Sstevel@tonic-gate } 68637c478bd9Sstevel@tonic-gate if (strcmp(cmd->cmd_argv[0], "commands") == 0) { 6864bbec428eSgjelinek usage(B_TRUE, HELP_SUBCMDS); 68657c478bd9Sstevel@tonic-gate return; 68667c478bd9Sstevel@tonic-gate } 68677c478bd9Sstevel@tonic-gate if (strcmp(cmd->cmd_argv[0], "syntax") == 0) { 6868bbec428eSgjelinek usage(B_TRUE, HELP_SYNTAX | HELP_RES_PROPS); 68697c478bd9Sstevel@tonic-gate return; 68707c478bd9Sstevel@tonic-gate } 68717c478bd9Sstevel@tonic-gate if (strcmp(cmd->cmd_argv[0], "-?") == 0) { 68727c478bd9Sstevel@tonic-gate longer_usage(CMD_HELP); 68737c478bd9Sstevel@tonic-gate return; 68747c478bd9Sstevel@tonic-gate } 68757c478bd9Sstevel@tonic-gate 68767c478bd9Sstevel@tonic-gate for (i = 0; i <= CMD_MAX; i++) { 68777c478bd9Sstevel@tonic-gate if (strcmp(cmd->cmd_argv[0], cmd_to_str(i)) == 0) { 68787c478bd9Sstevel@tonic-gate longer_usage(i); 68797c478bd9Sstevel@tonic-gate return; 68807c478bd9Sstevel@tonic-gate } 68817c478bd9Sstevel@tonic-gate } 68827c478bd9Sstevel@tonic-gate /* We do not use zerr() here because we do not want its extra \n. */ 68837c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("Unknown help subject %s. "), 68847c478bd9Sstevel@tonic-gate cmd->cmd_argv[0]); 6885bbec428eSgjelinek usage(B_FALSE, HELP_META); 68867c478bd9Sstevel@tonic-gate } 68877c478bd9Sstevel@tonic-gate 68887c478bd9Sstevel@tonic-gate static int 68897c478bd9Sstevel@tonic-gate string_to_yyin(char *string) 68907c478bd9Sstevel@tonic-gate { 68917c478bd9Sstevel@tonic-gate if ((yyin = tmpfile()) == NULL) { 6892bbec428eSgjelinek zone_perror(execname, Z_TEMP_FILE, B_TRUE); 68937c478bd9Sstevel@tonic-gate return (Z_ERR); 68947c478bd9Sstevel@tonic-gate } 68957c478bd9Sstevel@tonic-gate if (fwrite(string, strlen(string), 1, yyin) != 1) { 6896bbec428eSgjelinek zone_perror(execname, Z_TEMP_FILE, B_TRUE); 68977c478bd9Sstevel@tonic-gate return (Z_ERR); 68987c478bd9Sstevel@tonic-gate } 68997c478bd9Sstevel@tonic-gate if (fseek(yyin, 0, SEEK_SET) != 0) { 6900bbec428eSgjelinek zone_perror(execname, Z_TEMP_FILE, B_TRUE); 69017c478bd9Sstevel@tonic-gate return (Z_ERR); 69027c478bd9Sstevel@tonic-gate } 69037c478bd9Sstevel@tonic-gate return (Z_OK); 69047c478bd9Sstevel@tonic-gate } 69057c478bd9Sstevel@tonic-gate 69067c478bd9Sstevel@tonic-gate /* This is the back-end helper function for read_input() below. */ 69077c478bd9Sstevel@tonic-gate 69087c478bd9Sstevel@tonic-gate static int 69097c478bd9Sstevel@tonic-gate cleanup() 69107c478bd9Sstevel@tonic-gate { 69117c478bd9Sstevel@tonic-gate int answer; 69127c478bd9Sstevel@tonic-gate cmd_t *cmd; 69137c478bd9Sstevel@tonic-gate 69147c478bd9Sstevel@tonic-gate if (!interactive_mode && !cmd_file_mode) { 69157c478bd9Sstevel@tonic-gate /* 69167c478bd9Sstevel@tonic-gate * If we're not in interactive mode, and we're not in command 69177c478bd9Sstevel@tonic-gate * file mode, then we must be in commands-from-the-command-line 69187c478bd9Sstevel@tonic-gate * mode. As such, we can't loop back and ask for more input. 69197c478bd9Sstevel@tonic-gate * It was OK to prompt for such things as whether or not to 69207c478bd9Sstevel@tonic-gate * really delete a zone in the command handler called from 69217c478bd9Sstevel@tonic-gate * yyparse() above, but "really quit?" makes no sense in this 69227c478bd9Sstevel@tonic-gate * context. So disable prompting. 69237c478bd9Sstevel@tonic-gate */ 6924bbec428eSgjelinek ok_to_prompt = B_FALSE; 69257c478bd9Sstevel@tonic-gate } 69267c478bd9Sstevel@tonic-gate if (!global_scope) { 69277c478bd9Sstevel@tonic-gate if (!time_to_exit) { 69287c478bd9Sstevel@tonic-gate /* 69297c478bd9Sstevel@tonic-gate * Just print a simple error message in the -1 case, 69307c478bd9Sstevel@tonic-gate * since exit_func() already handles that case, and 69317c478bd9Sstevel@tonic-gate * EOF means we are finished anyway. 69327c478bd9Sstevel@tonic-gate */ 6933bbec428eSgjelinek answer = ask_yesno(B_FALSE, 69347c478bd9Sstevel@tonic-gate gettext("Resource incomplete; really quit")); 69357c478bd9Sstevel@tonic-gate if (answer == -1) { 69367c478bd9Sstevel@tonic-gate zerr(gettext("Resource incomplete.")); 69377c478bd9Sstevel@tonic-gate return (Z_ERR); 69387c478bd9Sstevel@tonic-gate } 69397c478bd9Sstevel@tonic-gate if (answer != 1) { 69407c478bd9Sstevel@tonic-gate yyin = stdin; 69417c478bd9Sstevel@tonic-gate return (Z_REPEAT); 69427c478bd9Sstevel@tonic-gate } 69437c478bd9Sstevel@tonic-gate } else { 6944bbec428eSgjelinek saw_error = B_TRUE; 69457c478bd9Sstevel@tonic-gate } 69467c478bd9Sstevel@tonic-gate } 69477c478bd9Sstevel@tonic-gate /* 69487c478bd9Sstevel@tonic-gate * Make sure we tried something and that the handle checks 69497c478bd9Sstevel@tonic-gate * out, or we would get a false error trying to commit. 69507c478bd9Sstevel@tonic-gate */ 69517c478bd9Sstevel@tonic-gate if (need_to_commit && zonecfg_check_handle(handle) == Z_OK) { 69527c478bd9Sstevel@tonic-gate if ((cmd = alloc_cmd()) == NULL) { 6953bbec428eSgjelinek zone_perror(zone, Z_NOMEM, B_TRUE); 69547c478bd9Sstevel@tonic-gate return (Z_ERR); 69557c478bd9Sstevel@tonic-gate } 69567c478bd9Sstevel@tonic-gate cmd->cmd_argc = 0; 69577c478bd9Sstevel@tonic-gate cmd->cmd_argv[0] = NULL; 69587c478bd9Sstevel@tonic-gate commit_func(cmd); 69597c478bd9Sstevel@tonic-gate free_cmd(cmd); 69607c478bd9Sstevel@tonic-gate /* 69617c478bd9Sstevel@tonic-gate * need_to_commit will get set back to FALSE if the 69627c478bd9Sstevel@tonic-gate * configuration is saved successfully. 69637c478bd9Sstevel@tonic-gate */ 69647c478bd9Sstevel@tonic-gate if (need_to_commit) { 69657c478bd9Sstevel@tonic-gate if (force_exit) { 69667c478bd9Sstevel@tonic-gate zerr(gettext("Configuration not saved.")); 69677c478bd9Sstevel@tonic-gate return (Z_ERR); 69687c478bd9Sstevel@tonic-gate } 6969bbec428eSgjelinek answer = ask_yesno(B_FALSE, 69707c478bd9Sstevel@tonic-gate gettext("Configuration not saved; really quit")); 69717c478bd9Sstevel@tonic-gate if (answer == -1) { 69727c478bd9Sstevel@tonic-gate zerr(gettext("Configuration not saved.")); 69737c478bd9Sstevel@tonic-gate return (Z_ERR); 69747c478bd9Sstevel@tonic-gate } 69757c478bd9Sstevel@tonic-gate if (answer != 1) { 6976bbec428eSgjelinek time_to_exit = B_FALSE; 69777c478bd9Sstevel@tonic-gate yyin = stdin; 69787c478bd9Sstevel@tonic-gate return (Z_REPEAT); 69797c478bd9Sstevel@tonic-gate } 69807c478bd9Sstevel@tonic-gate } 69817c478bd9Sstevel@tonic-gate } 69827c478bd9Sstevel@tonic-gate return ((need_to_commit || saw_error) ? Z_ERR : Z_OK); 69837c478bd9Sstevel@tonic-gate } 69847c478bd9Sstevel@tonic-gate 69857c478bd9Sstevel@tonic-gate /* 69867c478bd9Sstevel@tonic-gate * read_input() is the driver of this program. It is a wrapper around 69877c478bd9Sstevel@tonic-gate * yyparse(), printing appropriate prompts when needed, checking for 69887c478bd9Sstevel@tonic-gate * exit conditions and reacting appropriately [the latter in its cleanup() 69897c478bd9Sstevel@tonic-gate * helper function]. 69907c478bd9Sstevel@tonic-gate * 69917c478bd9Sstevel@tonic-gate * Like most zonecfg functions, it returns Z_OK or Z_ERR, *or* Z_REPEAT 69927c478bd9Sstevel@tonic-gate * so do_interactive() knows that we are not really done (i.e, we asked 69937c478bd9Sstevel@tonic-gate * the user if we should really quit and the user said no). 69947c478bd9Sstevel@tonic-gate */ 69957c478bd9Sstevel@tonic-gate static int 69967c478bd9Sstevel@tonic-gate read_input() 69977c478bd9Sstevel@tonic-gate { 6998bbec428eSgjelinek boolean_t yyin_is_a_tty = isatty(fileno(yyin)); 69997c478bd9Sstevel@tonic-gate /* 70007c478bd9Sstevel@tonic-gate * The prompt is "e:z> " or "e:z:r> " where e is execname, z is zone 70017c478bd9Sstevel@tonic-gate * and r is resource_scope: 5 is for the two ":"s + "> " + terminator. 70027c478bd9Sstevel@tonic-gate */ 70037c478bd9Sstevel@tonic-gate char prompt[MAXPATHLEN + ZONENAME_MAX + MAX_RT_STRLEN + 5], *line; 70047c478bd9Sstevel@tonic-gate 70057c478bd9Sstevel@tonic-gate /* yyin should have been set to the appropriate (FILE *) if not stdin */ 7006bbec428eSgjelinek newline_terminated = B_TRUE; 70077c478bd9Sstevel@tonic-gate for (;;) { 70087c478bd9Sstevel@tonic-gate if (yyin_is_a_tty) { 70097c478bd9Sstevel@tonic-gate if (newline_terminated) { 70107c478bd9Sstevel@tonic-gate if (global_scope) 70117c478bd9Sstevel@tonic-gate (void) snprintf(prompt, sizeof (prompt), 70127c478bd9Sstevel@tonic-gate "%s:%s> ", execname, zone); 70137c478bd9Sstevel@tonic-gate else 70147c478bd9Sstevel@tonic-gate (void) snprintf(prompt, sizeof (prompt), 70157c478bd9Sstevel@tonic-gate "%s:%s:%s> ", execname, zone, 70167c478bd9Sstevel@tonic-gate rt_to_str(resource_scope)); 70177c478bd9Sstevel@tonic-gate } 70187c478bd9Sstevel@tonic-gate /* 70197c478bd9Sstevel@tonic-gate * If the user hits ^C then we want to catch it and 70207c478bd9Sstevel@tonic-gate * start over. If the user hits EOF then we want to 70217c478bd9Sstevel@tonic-gate * bail out. 70227c478bd9Sstevel@tonic-gate */ 70237c478bd9Sstevel@tonic-gate line = gl_get_line(gl, prompt, NULL, -1); 70247c478bd9Sstevel@tonic-gate if (gl_return_status(gl) == GLR_SIGNAL) { 70257c478bd9Sstevel@tonic-gate gl_abandon_line(gl); 70267c478bd9Sstevel@tonic-gate continue; 70277c478bd9Sstevel@tonic-gate } 70287c478bd9Sstevel@tonic-gate if (line == NULL) 70297c478bd9Sstevel@tonic-gate break; 70307c478bd9Sstevel@tonic-gate (void) string_to_yyin(line); 70317c478bd9Sstevel@tonic-gate while (!feof(yyin)) 70327c478bd9Sstevel@tonic-gate yyparse(); 70337c478bd9Sstevel@tonic-gate } else { 70347c478bd9Sstevel@tonic-gate yyparse(); 70357c478bd9Sstevel@tonic-gate } 70367c478bd9Sstevel@tonic-gate /* Bail out on an error in command file mode. */ 70377c478bd9Sstevel@tonic-gate if (saw_error && cmd_file_mode && !interactive_mode) 7038bbec428eSgjelinek time_to_exit = B_TRUE; 70397c478bd9Sstevel@tonic-gate if (time_to_exit || (!yyin_is_a_tty && feof(yyin))) 70407c478bd9Sstevel@tonic-gate break; 70417c478bd9Sstevel@tonic-gate } 70427c478bd9Sstevel@tonic-gate return (cleanup()); 70437c478bd9Sstevel@tonic-gate } 70447c478bd9Sstevel@tonic-gate 70457c478bd9Sstevel@tonic-gate /* 70467c478bd9Sstevel@tonic-gate * This function is used in the zonecfg-interactive-mode scenario: it just 70477c478bd9Sstevel@tonic-gate * calls read_input() until we are done. 70487c478bd9Sstevel@tonic-gate */ 70497c478bd9Sstevel@tonic-gate 70507c478bd9Sstevel@tonic-gate static int 70517c478bd9Sstevel@tonic-gate do_interactive(void) 70527c478bd9Sstevel@tonic-gate { 70537c478bd9Sstevel@tonic-gate int err; 70547c478bd9Sstevel@tonic-gate 7055bbec428eSgjelinek interactive_mode = B_TRUE; 70567c478bd9Sstevel@tonic-gate if (!read_only_mode) { 70577c478bd9Sstevel@tonic-gate /* 70587c478bd9Sstevel@tonic-gate * Try to set things up proactively in interactive mode, so 70597c478bd9Sstevel@tonic-gate * that if the zone in question does not exist yet, we can 70607c478bd9Sstevel@tonic-gate * provide the user with a clue. 70617c478bd9Sstevel@tonic-gate */ 7062bbec428eSgjelinek (void) initialize(B_FALSE); 70637c478bd9Sstevel@tonic-gate } 7064087719fdSdp do { 70657c478bd9Sstevel@tonic-gate err = read_input(); 7066087719fdSdp } while (err == Z_REPEAT); 70677c478bd9Sstevel@tonic-gate return (err); 70687c478bd9Sstevel@tonic-gate } 70697c478bd9Sstevel@tonic-gate 70707c478bd9Sstevel@tonic-gate /* 70717c478bd9Sstevel@tonic-gate * cmd_file is slightly more complicated, as it has to open the command file 70727c478bd9Sstevel@tonic-gate * and set yyin appropriately. Once that is done, though, it just calls 70737c478bd9Sstevel@tonic-gate * read_input(), and only once, since prompting is not possible. 70747c478bd9Sstevel@tonic-gate */ 70757c478bd9Sstevel@tonic-gate 70767c478bd9Sstevel@tonic-gate static int 70777c478bd9Sstevel@tonic-gate cmd_file(char *file) 70787c478bd9Sstevel@tonic-gate { 70797c478bd9Sstevel@tonic-gate FILE *infile; 70807c478bd9Sstevel@tonic-gate int err; 70817c478bd9Sstevel@tonic-gate struct stat statbuf; 7082bbec428eSgjelinek boolean_t using_real_file = (strcmp(file, "-") != 0); 70837c478bd9Sstevel@tonic-gate 70847c478bd9Sstevel@tonic-gate if (using_real_file) { 70857c478bd9Sstevel@tonic-gate /* 70867c478bd9Sstevel@tonic-gate * zerr() prints a line number in cmd_file_mode, which we do 70877c478bd9Sstevel@tonic-gate * not want here, so temporarily unset it. 70887c478bd9Sstevel@tonic-gate */ 7089bbec428eSgjelinek cmd_file_mode = B_FALSE; 70907c478bd9Sstevel@tonic-gate if ((infile = fopen(file, "r")) == NULL) { 70917c478bd9Sstevel@tonic-gate zerr(gettext("could not open file %s: %s"), 70927c478bd9Sstevel@tonic-gate file, strerror(errno)); 70937c478bd9Sstevel@tonic-gate return (Z_ERR); 70947c478bd9Sstevel@tonic-gate } 70957c478bd9Sstevel@tonic-gate if ((err = fstat(fileno(infile), &statbuf)) != 0) { 70967c478bd9Sstevel@tonic-gate zerr(gettext("could not stat file %s: %s"), 70977c478bd9Sstevel@tonic-gate file, strerror(errno)); 70987c478bd9Sstevel@tonic-gate err = Z_ERR; 70997c478bd9Sstevel@tonic-gate goto done; 71007c478bd9Sstevel@tonic-gate } 71017c478bd9Sstevel@tonic-gate if (!S_ISREG(statbuf.st_mode)) { 71027c478bd9Sstevel@tonic-gate zerr(gettext("%s is not a regular file."), file); 71037c478bd9Sstevel@tonic-gate err = Z_ERR; 71047c478bd9Sstevel@tonic-gate goto done; 71057c478bd9Sstevel@tonic-gate } 71067c478bd9Sstevel@tonic-gate yyin = infile; 7107bbec428eSgjelinek cmd_file_mode = B_TRUE; 7108bbec428eSgjelinek ok_to_prompt = B_FALSE; 71097c478bd9Sstevel@tonic-gate } else { 71107c478bd9Sstevel@tonic-gate /* 71117c478bd9Sstevel@tonic-gate * "-f -" is essentially the same as interactive mode, 71127c478bd9Sstevel@tonic-gate * so treat it that way. 71137c478bd9Sstevel@tonic-gate */ 7114bbec428eSgjelinek interactive_mode = B_TRUE; 71157c478bd9Sstevel@tonic-gate } 71167c478bd9Sstevel@tonic-gate /* Z_REPEAT is for interactive mode; treat it like Z_ERR here. */ 71177c478bd9Sstevel@tonic-gate if ((err = read_input()) == Z_REPEAT) 71187c478bd9Sstevel@tonic-gate err = Z_ERR; 71197c478bd9Sstevel@tonic-gate done: 71207c478bd9Sstevel@tonic-gate if (using_real_file) 71217c478bd9Sstevel@tonic-gate (void) fclose(infile); 71227c478bd9Sstevel@tonic-gate return (err); 71237c478bd9Sstevel@tonic-gate } 71247c478bd9Sstevel@tonic-gate 71257c478bd9Sstevel@tonic-gate /* 71267c478bd9Sstevel@tonic-gate * Since yacc is based on reading from a (FILE *) whereas what we get from 71277c478bd9Sstevel@tonic-gate * the command line is in argv format, we need to convert when the user 71287c478bd9Sstevel@tonic-gate * gives us commands directly from the command line. That is done here by 71297c478bd9Sstevel@tonic-gate * concatenating the argv list into a space-separated string, writing it 71307c478bd9Sstevel@tonic-gate * to a temp file, and rewinding the file so yyin can be set to it. Then 71317c478bd9Sstevel@tonic-gate * we call read_input(), and only once, since prompting about whether to 71327c478bd9Sstevel@tonic-gate * continue or quit would make no sense in this context. 71337c478bd9Sstevel@tonic-gate */ 71347c478bd9Sstevel@tonic-gate 71357c478bd9Sstevel@tonic-gate static int 71367c478bd9Sstevel@tonic-gate one_command_at_a_time(int argc, char *argv[]) 71377c478bd9Sstevel@tonic-gate { 71387c478bd9Sstevel@tonic-gate char *command; 71397c478bd9Sstevel@tonic-gate size_t len = 2; /* terminal \n\0 */ 71407c478bd9Sstevel@tonic-gate int i, err; 71417c478bd9Sstevel@tonic-gate 71427c478bd9Sstevel@tonic-gate for (i = 0; i < argc; i++) 71437c478bd9Sstevel@tonic-gate len += strlen(argv[i]) + 1; 71447c478bd9Sstevel@tonic-gate if ((command = malloc(len)) == NULL) { 7145bbec428eSgjelinek zone_perror(execname, Z_NOMEM, B_TRUE); 71467c478bd9Sstevel@tonic-gate return (Z_ERR); 71477c478bd9Sstevel@tonic-gate } 71487c478bd9Sstevel@tonic-gate (void) strlcpy(command, argv[0], len); 71497c478bd9Sstevel@tonic-gate for (i = 1; i < argc; i++) { 71507c478bd9Sstevel@tonic-gate (void) strlcat(command, " ", len); 71517c478bd9Sstevel@tonic-gate (void) strlcat(command, argv[i], len); 71527c478bd9Sstevel@tonic-gate } 71537c478bd9Sstevel@tonic-gate (void) strlcat(command, "\n", len); 71547c478bd9Sstevel@tonic-gate err = string_to_yyin(command); 71557c478bd9Sstevel@tonic-gate free(command); 71567c478bd9Sstevel@tonic-gate if (err != Z_OK) 71577c478bd9Sstevel@tonic-gate return (err); 71587c478bd9Sstevel@tonic-gate while (!feof(yyin)) 71597c478bd9Sstevel@tonic-gate yyparse(); 71607c478bd9Sstevel@tonic-gate return (cleanup()); 71617c478bd9Sstevel@tonic-gate } 71627c478bd9Sstevel@tonic-gate 71637c478bd9Sstevel@tonic-gate static char * 71647c478bd9Sstevel@tonic-gate get_execbasename(char *execfullname) 71657c478bd9Sstevel@tonic-gate { 71667c478bd9Sstevel@tonic-gate char *last_slash, *execbasename; 71677c478bd9Sstevel@tonic-gate 71687c478bd9Sstevel@tonic-gate /* guard against '/' at end of command invocation */ 71697c478bd9Sstevel@tonic-gate for (;;) { 71707c478bd9Sstevel@tonic-gate last_slash = strrchr(execfullname, '/'); 71717c478bd9Sstevel@tonic-gate if (last_slash == NULL) { 71727c478bd9Sstevel@tonic-gate execbasename = execfullname; 71737c478bd9Sstevel@tonic-gate break; 71747c478bd9Sstevel@tonic-gate } else { 71757c478bd9Sstevel@tonic-gate execbasename = last_slash + 1; 71767c478bd9Sstevel@tonic-gate if (*execbasename == '\0') { 71777c478bd9Sstevel@tonic-gate *last_slash = '\0'; 71787c478bd9Sstevel@tonic-gate continue; 71797c478bd9Sstevel@tonic-gate } 71807c478bd9Sstevel@tonic-gate break; 71817c478bd9Sstevel@tonic-gate } 71827c478bd9Sstevel@tonic-gate } 71837c478bd9Sstevel@tonic-gate return (execbasename); 71847c478bd9Sstevel@tonic-gate } 71857c478bd9Sstevel@tonic-gate 71867c478bd9Sstevel@tonic-gate int 71877c478bd9Sstevel@tonic-gate main(int argc, char *argv[]) 71887c478bd9Sstevel@tonic-gate { 71897c478bd9Sstevel@tonic-gate int err, arg; 7190555afedfScarlsonj struct stat st; 71917c478bd9Sstevel@tonic-gate 71927c478bd9Sstevel@tonic-gate /* This must be before anything goes to stdout. */ 71937c478bd9Sstevel@tonic-gate setbuf(stdout, NULL); 71947c478bd9Sstevel@tonic-gate 7195bbec428eSgjelinek saw_error = B_FALSE; 7196bbec428eSgjelinek cmd_file_mode = B_FALSE; 71977c478bd9Sstevel@tonic-gate execname = get_execbasename(argv[0]); 71987c478bd9Sstevel@tonic-gate 71997c478bd9Sstevel@tonic-gate (void) setlocale(LC_ALL, ""); 72007c478bd9Sstevel@tonic-gate (void) textdomain(TEXT_DOMAIN); 72017c478bd9Sstevel@tonic-gate 72027c478bd9Sstevel@tonic-gate if (getzoneid() != GLOBAL_ZONEID) { 72037c478bd9Sstevel@tonic-gate zerr(gettext("%s can only be run from the global zone."), 72047c478bd9Sstevel@tonic-gate execname); 72057c478bd9Sstevel@tonic-gate exit(Z_ERR); 72067c478bd9Sstevel@tonic-gate } 72077c478bd9Sstevel@tonic-gate 72087c478bd9Sstevel@tonic-gate if (argc < 2) { 7209bbec428eSgjelinek usage(B_FALSE, HELP_USAGE | HELP_SUBCMDS); 72107c478bd9Sstevel@tonic-gate exit(Z_USAGE); 72117c478bd9Sstevel@tonic-gate } 72127c478bd9Sstevel@tonic-gate if (strcmp(argv[1], cmd_to_str(CMD_HELP)) == 0) { 72137c478bd9Sstevel@tonic-gate (void) one_command_at_a_time(argc - 1, &(argv[1])); 72147c478bd9Sstevel@tonic-gate exit(Z_OK); 72157c478bd9Sstevel@tonic-gate } 72167c478bd9Sstevel@tonic-gate 7217555afedfScarlsonj while ((arg = getopt(argc, argv, "?f:R:z:")) != EOF) { 72187c478bd9Sstevel@tonic-gate switch (arg) { 72197c478bd9Sstevel@tonic-gate case '?': 72207c478bd9Sstevel@tonic-gate if (optopt == '?') 7221bbec428eSgjelinek usage(B_TRUE, HELP_USAGE | HELP_SUBCMDS); 72227c478bd9Sstevel@tonic-gate else 7223bbec428eSgjelinek usage(B_FALSE, HELP_USAGE); 72247c478bd9Sstevel@tonic-gate exit(Z_USAGE); 72257c478bd9Sstevel@tonic-gate /* NOTREACHED */ 72267c478bd9Sstevel@tonic-gate case 'f': 72277c478bd9Sstevel@tonic-gate cmd_file_name = optarg; 7228bbec428eSgjelinek cmd_file_mode = B_TRUE; 72297c478bd9Sstevel@tonic-gate break; 7230555afedfScarlsonj case 'R': 7231555afedfScarlsonj if (*optarg != '/') { 7232555afedfScarlsonj zerr(gettext("root path must be absolute: %s"), 7233555afedfScarlsonj optarg); 7234555afedfScarlsonj exit(Z_USAGE); 7235555afedfScarlsonj } 7236555afedfScarlsonj if (stat(optarg, &st) == -1 || !S_ISDIR(st.st_mode)) { 7237555afedfScarlsonj zerr(gettext( 7238555afedfScarlsonj "root path must be a directory: %s"), 7239555afedfScarlsonj optarg); 7240555afedfScarlsonj exit(Z_USAGE); 7241555afedfScarlsonj } 7242555afedfScarlsonj zonecfg_set_root(optarg); 7243555afedfScarlsonj break; 72447c478bd9Sstevel@tonic-gate case 'z': 72450209230bSgjelinek if (strcmp(optarg, GLOBAL_ZONENAME) == 0) { 7246bbec428eSgjelinek global_zone = B_TRUE; 72470209230bSgjelinek } else if (zonecfg_validate_zonename(optarg) != Z_OK) { 7248bbec428eSgjelinek zone_perror(optarg, Z_BOGUS_ZONE_NAME, B_TRUE); 7249bbec428eSgjelinek usage(B_FALSE, HELP_SYNTAX); 7250087719fdSdp exit(Z_USAGE); 7251087719fdSdp } 7252087719fdSdp (void) strlcpy(zone, optarg, sizeof (zone)); 7253087719fdSdp (void) strlcpy(revert_zone, optarg, sizeof (zone)); 72547c478bd9Sstevel@tonic-gate break; 72557c478bd9Sstevel@tonic-gate default: 7256bbec428eSgjelinek usage(B_FALSE, HELP_USAGE); 72577c478bd9Sstevel@tonic-gate exit(Z_USAGE); 72587c478bd9Sstevel@tonic-gate } 72597c478bd9Sstevel@tonic-gate } 72607c478bd9Sstevel@tonic-gate 7261087719fdSdp if (optind > argc || strcmp(zone, "") == 0) { 7262bbec428eSgjelinek usage(B_FALSE, HELP_USAGE); 72637c478bd9Sstevel@tonic-gate exit(Z_USAGE); 72647c478bd9Sstevel@tonic-gate } 72657c478bd9Sstevel@tonic-gate 7266087719fdSdp if ((err = zonecfg_access(zone, W_OK)) == Z_OK) { 7267bbec428eSgjelinek read_only_mode = B_FALSE; 7268087719fdSdp } else if (err == Z_ACCES) { 7269bbec428eSgjelinek read_only_mode = B_TRUE; 72707c478bd9Sstevel@tonic-gate /* skip this message in one-off from command line mode */ 72717c478bd9Sstevel@tonic-gate if (optind == argc) 72727c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("WARNING: you do not " 72737c478bd9Sstevel@tonic-gate "have write access to this zone's configuration " 72747c478bd9Sstevel@tonic-gate "file;\ngoing into read-only mode.\n")); 7275087719fdSdp } else { 7276087719fdSdp fprintf(stderr, "%s: Could not access zone configuration " 7277087719fdSdp "store: %s\n", execname, zonecfg_strerror(err)); 7278087719fdSdp exit(Z_ERR); 72797c478bd9Sstevel@tonic-gate } 72807c478bd9Sstevel@tonic-gate 72817c478bd9Sstevel@tonic-gate if ((handle = zonecfg_init_handle()) == NULL) { 7282bbec428eSgjelinek zone_perror(execname, Z_NOMEM, B_TRUE); 72837c478bd9Sstevel@tonic-gate exit(Z_ERR); 72847c478bd9Sstevel@tonic-gate } 72857c478bd9Sstevel@tonic-gate 72867c478bd9Sstevel@tonic-gate /* 72877c478bd9Sstevel@tonic-gate * This may get set back to FALSE again in cmd_file() if cmd_file_name 72887c478bd9Sstevel@tonic-gate * is a "real" file as opposed to "-" (i.e. meaning use stdin). 72897c478bd9Sstevel@tonic-gate */ 72907c478bd9Sstevel@tonic-gate if (isatty(STDIN_FILENO)) 7291bbec428eSgjelinek ok_to_prompt = B_TRUE; 72927c478bd9Sstevel@tonic-gate if ((gl = new_GetLine(MAX_LINE_LEN, MAX_CMD_HIST)) == NULL) 72937c478bd9Sstevel@tonic-gate exit(Z_ERR); 72947c478bd9Sstevel@tonic-gate if (gl_customize_completion(gl, NULL, cmd_cpl_fn) != 0) 72957c478bd9Sstevel@tonic-gate exit(Z_ERR); 72967c478bd9Sstevel@tonic-gate (void) sigset(SIGINT, SIG_IGN); 72977c478bd9Sstevel@tonic-gate if (optind == argc) { 72987c478bd9Sstevel@tonic-gate if (!cmd_file_mode) 72997c478bd9Sstevel@tonic-gate err = do_interactive(); 73007c478bd9Sstevel@tonic-gate else 73017c478bd9Sstevel@tonic-gate err = cmd_file(cmd_file_name); 73027c478bd9Sstevel@tonic-gate } else { 73037c478bd9Sstevel@tonic-gate err = one_command_at_a_time(argc - optind, &(argv[optind])); 73047c478bd9Sstevel@tonic-gate } 73057c478bd9Sstevel@tonic-gate zonecfg_fini_handle(handle); 73069acbbeafSnn if (brand != NULL) 73079acbbeafSnn brand_close(brand); 73087c478bd9Sstevel@tonic-gate (void) del_GetLine(gl); 73097c478bd9Sstevel@tonic-gate return (err); 73107c478bd9Sstevel@tonic-gate } 7311