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> 569acbbeafSnn35248 #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> 709acbbeafSnn35248 #include <wait.h> 717c478bd9Sstevel@tonic-gate #include <libtecla.h> 72fa9e4066Sahrens #include <libzfs.h> 739acbbeafSnn35248 #include <sys/brand.h> 749acbbeafSnn35248 #include <libbrand.h> 755679c89fSjv227347 #include <sys/systeminfo.h> 76c9f134eaSjv227347 #include <libdladm.h> 77c9f134eaSjv227347 #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" 889acbbeafSnn35248 #define EXEC_PREFIX "exec " 899acbbeafSnn35248 #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 1039acbbeafSnn35248 #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 */ 157c94c1ef0Sjv227347 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", 1729acbbeafSnn35248 "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", 182f4b3ec61Sdh155122 "ip-type", 183c97ad5cdSakolb "capped-cpu", 1845679c89fSjv227347 "hostid", 185cb8a054bSGlenn Faden "admin", 1867c478bd9Sstevel@tonic-gate NULL 1877c478bd9Sstevel@tonic-gate }; 1887c478bd9Sstevel@tonic-gate 1897c478bd9Sstevel@tonic-gate /* These *must* match the order of the PT_ define's from zonecfg.h */ 190c94c1ef0Sjv227347 char *prop_types[] = { 1917c478bd9Sstevel@tonic-gate "unknown", 192087719fdSdp "zonename", 1937c478bd9Sstevel@tonic-gate "zonepath", 1947c478bd9Sstevel@tonic-gate "autoboot", 1957c478bd9Sstevel@tonic-gate "pool", 1967c478bd9Sstevel@tonic-gate "dir", 1977c478bd9Sstevel@tonic-gate "special", 1987c478bd9Sstevel@tonic-gate "type", 1997c478bd9Sstevel@tonic-gate "options", 2007c478bd9Sstevel@tonic-gate "address", 2017c478bd9Sstevel@tonic-gate "physical", 2027c478bd9Sstevel@tonic-gate "name", 2037c478bd9Sstevel@tonic-gate "value", 2047c478bd9Sstevel@tonic-gate "match", 2057c478bd9Sstevel@tonic-gate "priv", 2067c478bd9Sstevel@tonic-gate "limit", 2077c478bd9Sstevel@tonic-gate "action", 2087c478bd9Sstevel@tonic-gate "raw", 209ffbafc53Scomay "limitpriv", 2103f2f09c1Sdp "bootargs", 2119acbbeafSnn35248 "brand", 2120209230bSgjelinek "ncpus", 2130209230bSgjelinek "importance", 2140209230bSgjelinek "swap", 2150209230bSgjelinek "locked", 2160209230bSgjelinek ALIAS_SHARES, 2170209230bSgjelinek ALIAS_MAXLWPS, 2180209230bSgjelinek ALIAS_MAXSHMMEM, 2190209230bSgjelinek ALIAS_MAXSHMIDS, 2200209230bSgjelinek ALIAS_MAXMSGIDS, 2210209230bSgjelinek ALIAS_MAXSEMIDS, 2220209230bSgjelinek ALIAS_MAXLOCKEDMEM, 2230209230bSgjelinek ALIAS_MAXSWAP, 2240209230bSgjelinek "scheduling-class", 225f4b3ec61Sdh155122 "ip-type", 226de860bd9Sgfaden "defrouter", 2275679c89fSjv227347 "hostid", 228cb8a054bSGlenn Faden "user", 229cb8a054bSGlenn Faden "auths", 2307c478bd9Sstevel@tonic-gate NULL 2317c478bd9Sstevel@tonic-gate }; 2327c478bd9Sstevel@tonic-gate 233ffbafc53Scomay /* These *must* match the order of the PROP_VAL_ define's from zonecfg.h */ 2347c478bd9Sstevel@tonic-gate static char *prop_val_types[] = { 2357c478bd9Sstevel@tonic-gate "simple", 2367c478bd9Sstevel@tonic-gate "complex", 2377c478bd9Sstevel@tonic-gate "list", 2387c478bd9Sstevel@tonic-gate }; 2397c478bd9Sstevel@tonic-gate 2407c478bd9Sstevel@tonic-gate /* 2417c478bd9Sstevel@tonic-gate * The various _cmds[] lists below are for command tab-completion. 2427c478bd9Sstevel@tonic-gate */ 2437c478bd9Sstevel@tonic-gate 2447c478bd9Sstevel@tonic-gate /* 2457c478bd9Sstevel@tonic-gate * remove has a space afterwards because it has qualifiers; the other commands 2460209230bSgjelinek * that have qualifiers (add, select, etc.) don't need a space here because 2477c478bd9Sstevel@tonic-gate * they have their own _cmds[] lists below. 2487c478bd9Sstevel@tonic-gate */ 2497c478bd9Sstevel@tonic-gate static const char *global_scope_cmds[] = { 2507c478bd9Sstevel@tonic-gate "add", 2510209230bSgjelinek "clear", 2527c478bd9Sstevel@tonic-gate "commit", 2537c478bd9Sstevel@tonic-gate "create", 2547c478bd9Sstevel@tonic-gate "delete", 2557c478bd9Sstevel@tonic-gate "exit", 2567c478bd9Sstevel@tonic-gate "export", 2577c478bd9Sstevel@tonic-gate "help", 2587c478bd9Sstevel@tonic-gate "info", 2597c478bd9Sstevel@tonic-gate "remove ", 2607c478bd9Sstevel@tonic-gate "revert", 2617c478bd9Sstevel@tonic-gate "select", 2627c478bd9Sstevel@tonic-gate "set", 2637c478bd9Sstevel@tonic-gate "verify", 2647c478bd9Sstevel@tonic-gate NULL 2657c478bd9Sstevel@tonic-gate }; 2667c478bd9Sstevel@tonic-gate 2677c478bd9Sstevel@tonic-gate static const char *add_cmds[] = { 2687c478bd9Sstevel@tonic-gate "add fs", 2697c478bd9Sstevel@tonic-gate "add inherit-pkg-dir", 2707c478bd9Sstevel@tonic-gate "add net", 2717c478bd9Sstevel@tonic-gate "add device", 2727c478bd9Sstevel@tonic-gate "add rctl", 2737c478bd9Sstevel@tonic-gate "add attr", 274fa9e4066Sahrens "add dataset", 2750209230bSgjelinek "add dedicated-cpu", 276c97ad5cdSakolb "add capped-cpu", 2770209230bSgjelinek "add capped-memory", 278cb8a054bSGlenn Faden "add admin", 2790209230bSgjelinek NULL 2800209230bSgjelinek }; 2810209230bSgjelinek 2820209230bSgjelinek static const char *clear_cmds[] = { 2830209230bSgjelinek "clear autoboot", 2840209230bSgjelinek "clear pool", 2850209230bSgjelinek "clear limitpriv", 2860209230bSgjelinek "clear bootargs", 2870209230bSgjelinek "clear scheduling-class", 288f4b3ec61Sdh155122 "clear ip-type", 2890209230bSgjelinek "clear " ALIAS_MAXLWPS, 2900209230bSgjelinek "clear " ALIAS_MAXSHMMEM, 2910209230bSgjelinek "clear " ALIAS_MAXSHMIDS, 2920209230bSgjelinek "clear " ALIAS_MAXMSGIDS, 2930209230bSgjelinek "clear " ALIAS_MAXSEMIDS, 2940209230bSgjelinek "clear " ALIAS_SHARES, 2957c478bd9Sstevel@tonic-gate NULL 2967c478bd9Sstevel@tonic-gate }; 2977c478bd9Sstevel@tonic-gate 2989e7542f4Sdp static const char *remove_cmds[] = { 2999e7542f4Sdp "remove fs ", 3009e7542f4Sdp "remove inherit-pkg-dir ", 3019e7542f4Sdp "remove net ", 3029e7542f4Sdp "remove device ", 3039e7542f4Sdp "remove rctl ", 3049e7542f4Sdp "remove attr ", 3059e7542f4Sdp "remove dataset ", 3060209230bSgjelinek "remove dedicated-cpu ", 307c97ad5cdSakolb "remove capped-cpu ", 3080209230bSgjelinek "remove capped-memory ", 309cb8a054bSGlenn Faden "remove admin ", 3109e7542f4Sdp NULL 3119e7542f4Sdp }; 3129e7542f4Sdp 3137c478bd9Sstevel@tonic-gate static const char *select_cmds[] = { 3147c478bd9Sstevel@tonic-gate "select fs ", 3157c478bd9Sstevel@tonic-gate "select inherit-pkg-dir ", 3167c478bd9Sstevel@tonic-gate "select net ", 3177c478bd9Sstevel@tonic-gate "select device ", 3187c478bd9Sstevel@tonic-gate "select rctl ", 3197c478bd9Sstevel@tonic-gate "select attr ", 320fa9e4066Sahrens "select dataset ", 3210209230bSgjelinek "select dedicated-cpu", 322c97ad5cdSakolb "select capped-cpu", 3230209230bSgjelinek "select capped-memory", 324cb8a054bSGlenn Faden "select admin", 3257c478bd9Sstevel@tonic-gate NULL 3267c478bd9Sstevel@tonic-gate }; 3277c478bd9Sstevel@tonic-gate 3287c478bd9Sstevel@tonic-gate static const char *set_cmds[] = { 329087719fdSdp "set zonename=", 330087719fdSdp "set zonepath=", 3319acbbeafSnn35248 "set brand=", 332087719fdSdp "set autoboot=", 333087719fdSdp "set pool=", 334ffbafc53Scomay "set limitpriv=", 3353f2f09c1Sdp "set bootargs=", 3360209230bSgjelinek "set scheduling-class=", 337f4b3ec61Sdh155122 "set ip-type=", 3380209230bSgjelinek "set " ALIAS_MAXLWPS "=", 3390209230bSgjelinek "set " ALIAS_MAXSHMMEM "=", 3400209230bSgjelinek "set " ALIAS_MAXSHMIDS "=", 3410209230bSgjelinek "set " ALIAS_MAXMSGIDS "=", 3420209230bSgjelinek "set " ALIAS_MAXSEMIDS "=", 3430209230bSgjelinek "set " ALIAS_SHARES "=", 3445679c89fSjv227347 "set hostid=", 3457c478bd9Sstevel@tonic-gate NULL 3467c478bd9Sstevel@tonic-gate }; 3477c478bd9Sstevel@tonic-gate 3489e7542f4Sdp static const char *info_cmds[] = { 3499e7542f4Sdp "info fs ", 3509e7542f4Sdp "info inherit-pkg-dir ", 3519e7542f4Sdp "info net ", 3529e7542f4Sdp "info device ", 3539e7542f4Sdp "info rctl ", 3549e7542f4Sdp "info attr ", 3559e7542f4Sdp "info dataset ", 3560209230bSgjelinek "info capped-memory", 3570209230bSgjelinek "info dedicated-cpu", 358c97ad5cdSakolb "info capped-cpu", 3599e7542f4Sdp "info zonename", 3609e7542f4Sdp "info zonepath", 3619e7542f4Sdp "info autoboot", 3629e7542f4Sdp "info pool", 3639e7542f4Sdp "info limitpriv", 3649e7542f4Sdp "info bootargs", 3650209230bSgjelinek "info brand", 3660209230bSgjelinek "info scheduling-class", 367f4b3ec61Sdh155122 "info ip-type", 3680209230bSgjelinek "info max-lwps", 3690209230bSgjelinek "info max-shm-memory", 3700209230bSgjelinek "info max-shm-ids", 3710209230bSgjelinek "info max-msg-ids", 3720209230bSgjelinek "info max-sem-ids", 3730209230bSgjelinek "info cpu-shares", 3745679c89fSjv227347 "info hostid", 375cb8a054bSGlenn Faden "info admin", 3769e7542f4Sdp NULL 3779e7542f4Sdp }; 3789e7542f4Sdp 3797c478bd9Sstevel@tonic-gate static const char *fs_res_scope_cmds[] = { 3807c478bd9Sstevel@tonic-gate "add options ", 3817c478bd9Sstevel@tonic-gate "cancel", 3827c478bd9Sstevel@tonic-gate "end", 3837c478bd9Sstevel@tonic-gate "exit", 3847c478bd9Sstevel@tonic-gate "help", 3857c478bd9Sstevel@tonic-gate "info", 386ffbafc53Scomay "remove options ", 3877c478bd9Sstevel@tonic-gate "set dir=", 3887c478bd9Sstevel@tonic-gate "set raw=", 3897c478bd9Sstevel@tonic-gate "set special=", 3907c478bd9Sstevel@tonic-gate "set type=", 3910209230bSgjelinek "clear raw", 3927c478bd9Sstevel@tonic-gate NULL 3937c478bd9Sstevel@tonic-gate }; 3947c478bd9Sstevel@tonic-gate 3957c478bd9Sstevel@tonic-gate static const char *net_res_scope_cmds[] = { 3967c478bd9Sstevel@tonic-gate "cancel", 3977c478bd9Sstevel@tonic-gate "end", 3987c478bd9Sstevel@tonic-gate "exit", 3997c478bd9Sstevel@tonic-gate "help", 4007c478bd9Sstevel@tonic-gate "info", 4017c478bd9Sstevel@tonic-gate "set address=", 4027c478bd9Sstevel@tonic-gate "set physical=", 403*1b3281c0SGerald Jelinek "set defrouter=", 4047c478bd9Sstevel@tonic-gate NULL 4057c478bd9Sstevel@tonic-gate }; 4067c478bd9Sstevel@tonic-gate 4077c478bd9Sstevel@tonic-gate static const char *ipd_res_scope_cmds[] = { 4087c478bd9Sstevel@tonic-gate "cancel", 4097c478bd9Sstevel@tonic-gate "end", 4107c478bd9Sstevel@tonic-gate "exit", 4117c478bd9Sstevel@tonic-gate "help", 4127c478bd9Sstevel@tonic-gate "info", 4137c478bd9Sstevel@tonic-gate "set dir=", 4147c478bd9Sstevel@tonic-gate NULL 4157c478bd9Sstevel@tonic-gate }; 4167c478bd9Sstevel@tonic-gate 4177c478bd9Sstevel@tonic-gate static const char *device_res_scope_cmds[] = { 4187c478bd9Sstevel@tonic-gate "cancel", 4197c478bd9Sstevel@tonic-gate "end", 4207c478bd9Sstevel@tonic-gate "exit", 4217c478bd9Sstevel@tonic-gate "help", 4227c478bd9Sstevel@tonic-gate "info", 4237c478bd9Sstevel@tonic-gate "set match=", 4247c478bd9Sstevel@tonic-gate NULL 4257c478bd9Sstevel@tonic-gate }; 4267c478bd9Sstevel@tonic-gate 4277c478bd9Sstevel@tonic-gate static const char *attr_res_scope_cmds[] = { 4287c478bd9Sstevel@tonic-gate "cancel", 4297c478bd9Sstevel@tonic-gate "end", 4307c478bd9Sstevel@tonic-gate "exit", 4317c478bd9Sstevel@tonic-gate "help", 4327c478bd9Sstevel@tonic-gate "info", 4337c478bd9Sstevel@tonic-gate "set name=", 4347c478bd9Sstevel@tonic-gate "set type=", 4357c478bd9Sstevel@tonic-gate "set value=", 4367c478bd9Sstevel@tonic-gate NULL 4377c478bd9Sstevel@tonic-gate }; 4387c478bd9Sstevel@tonic-gate 4397c478bd9Sstevel@tonic-gate static const char *rctl_res_scope_cmds[] = { 4407c478bd9Sstevel@tonic-gate "add value ", 4417c478bd9Sstevel@tonic-gate "cancel", 4427c478bd9Sstevel@tonic-gate "end", 4437c478bd9Sstevel@tonic-gate "exit", 4447c478bd9Sstevel@tonic-gate "help", 4457c478bd9Sstevel@tonic-gate "info", 446ffbafc53Scomay "remove value ", 4477c478bd9Sstevel@tonic-gate "set name=", 4487c478bd9Sstevel@tonic-gate NULL 4497c478bd9Sstevel@tonic-gate }; 4507c478bd9Sstevel@tonic-gate 451fa9e4066Sahrens static const char *dataset_res_scope_cmds[] = { 452fa9e4066Sahrens "cancel", 453fa9e4066Sahrens "end", 454fa9e4066Sahrens "exit", 455fa9e4066Sahrens "help", 456fa9e4066Sahrens "info", 457fa9e4066Sahrens "set name=", 458fa9e4066Sahrens NULL 459fa9e4066Sahrens }; 460fa9e4066Sahrens 4610209230bSgjelinek static const char *pset_res_scope_cmds[] = { 4620209230bSgjelinek "cancel", 4630209230bSgjelinek "end", 4640209230bSgjelinek "exit", 4650209230bSgjelinek "help", 4660209230bSgjelinek "info", 4670209230bSgjelinek "set ncpus=", 4680209230bSgjelinek "set importance=", 4690209230bSgjelinek "clear importance", 4700209230bSgjelinek NULL 4710209230bSgjelinek }; 4720209230bSgjelinek 473c97ad5cdSakolb static const char *pcap_res_scope_cmds[] = { 474c97ad5cdSakolb "cancel", 475c97ad5cdSakolb "end", 476c97ad5cdSakolb "exit", 477c97ad5cdSakolb "help", 478c97ad5cdSakolb "info", 479c97ad5cdSakolb "set ncpus=", 480c97ad5cdSakolb NULL 481c97ad5cdSakolb }; 482c97ad5cdSakolb 4830209230bSgjelinek static const char *mcap_res_scope_cmds[] = { 4840209230bSgjelinek "cancel", 4850209230bSgjelinek "end", 4860209230bSgjelinek "exit", 4870209230bSgjelinek "help", 4880209230bSgjelinek "info", 4890209230bSgjelinek "set physical=", 4900209230bSgjelinek "set swap=", 4910209230bSgjelinek "set locked=", 4920209230bSgjelinek "clear physical", 4930209230bSgjelinek "clear swap", 4940209230bSgjelinek "clear locked", 4950209230bSgjelinek NULL 4960209230bSgjelinek }; 4970209230bSgjelinek 498cb8a054bSGlenn Faden static const char *admin_res_scope_cmds[] = { 499cb8a054bSGlenn Faden "cancel", 500cb8a054bSGlenn Faden "end", 501cb8a054bSGlenn Faden "exit", 502cb8a054bSGlenn Faden "help", 503cb8a054bSGlenn Faden "info", 504cb8a054bSGlenn Faden "set user=", 505cb8a054bSGlenn Faden "set auths=", 506cb8a054bSGlenn Faden NULL 507cb8a054bSGlenn Faden }; 508cb8a054bSGlenn Faden 5097c478bd9Sstevel@tonic-gate /* Global variables */ 5107c478bd9Sstevel@tonic-gate 5117c478bd9Sstevel@tonic-gate /* set early in main(), never modified thereafter, used all over the place */ 5127c478bd9Sstevel@tonic-gate static char *execname; 5137c478bd9Sstevel@tonic-gate 5147c478bd9Sstevel@tonic-gate /* set in main(), used all over the place */ 5157c478bd9Sstevel@tonic-gate static zone_dochandle_t handle; 5167c478bd9Sstevel@tonic-gate 5177c478bd9Sstevel@tonic-gate /* used all over the place */ 518087719fdSdp static char zone[ZONENAME_MAX]; 519087719fdSdp static char revert_zone[ZONENAME_MAX]; 5207c478bd9Sstevel@tonic-gate 5219acbbeafSnn35248 /* global brand operations */ 522123807fbSedp static brand_handle_t brand; 5239acbbeafSnn35248 5247c478bd9Sstevel@tonic-gate /* set in modifying functions, checked in read_input() */ 525bbec428eSgjelinek static boolean_t need_to_commit = B_FALSE; 526bbec428eSgjelinek boolean_t saw_error; 5277c478bd9Sstevel@tonic-gate 5287c478bd9Sstevel@tonic-gate /* set in yacc parser, checked in read_input() */ 529bbec428eSgjelinek boolean_t newline_terminated; 5307c478bd9Sstevel@tonic-gate 5317c478bd9Sstevel@tonic-gate /* set in main(), checked in lex error handler */ 532bbec428eSgjelinek boolean_t cmd_file_mode; 5337c478bd9Sstevel@tonic-gate 5347c478bd9Sstevel@tonic-gate /* set in exit_func(), checked in read_input() */ 535bbec428eSgjelinek static boolean_t time_to_exit = B_FALSE, force_exit = B_FALSE; 5367c478bd9Sstevel@tonic-gate 5377c478bd9Sstevel@tonic-gate /* used in short_usage() and zerr() */ 5387c478bd9Sstevel@tonic-gate static char *cmd_file_name = NULL; 5397c478bd9Sstevel@tonic-gate 5407c478bd9Sstevel@tonic-gate /* checked in read_input() and other places */ 541bbec428eSgjelinek static boolean_t ok_to_prompt = B_FALSE; 5427c478bd9Sstevel@tonic-gate 5437c478bd9Sstevel@tonic-gate /* set and checked in initialize() */ 544bbec428eSgjelinek static boolean_t got_handle = B_FALSE; 5457c478bd9Sstevel@tonic-gate 5467c478bd9Sstevel@tonic-gate /* initialized in do_interactive(), checked in initialize() */ 547bbec428eSgjelinek static boolean_t interactive_mode; 5487c478bd9Sstevel@tonic-gate 5490209230bSgjelinek /* set if configuring the global zone */ 550bbec428eSgjelinek static boolean_t global_zone = B_FALSE; 5510209230bSgjelinek 5527c478bd9Sstevel@tonic-gate /* set in main(), checked in multiple places */ 553bbec428eSgjelinek static boolean_t read_only_mode; 5547c478bd9Sstevel@tonic-gate 555bbec428eSgjelinek /* scope is outer/global or inner/resource */ 556bbec428eSgjelinek static boolean_t global_scope = B_TRUE; 5577c478bd9Sstevel@tonic-gate static int resource_scope; /* should be in the RT_ list from zonecfg.h */ 5587c478bd9Sstevel@tonic-gate static int end_op = -1; /* operation on end is either add or modify */ 5597c478bd9Sstevel@tonic-gate 5607c478bd9Sstevel@tonic-gate int num_prop_vals; /* for grammar */ 5617c478bd9Sstevel@tonic-gate 5627c478bd9Sstevel@tonic-gate /* 5637c478bd9Sstevel@tonic-gate * These are for keeping track of resources as they are specified as part of 5647c478bd9Sstevel@tonic-gate * the multi-step process. They should be initialized by add_resource() or 5657c478bd9Sstevel@tonic-gate * select_func() and filled in by add_property() or set_func(). 5667c478bd9Sstevel@tonic-gate */ 5677c478bd9Sstevel@tonic-gate static struct zone_fstab old_fstab, in_progress_fstab; 5687c478bd9Sstevel@tonic-gate static struct zone_fstab old_ipdtab, in_progress_ipdtab; 5697c478bd9Sstevel@tonic-gate static struct zone_nwiftab old_nwiftab, in_progress_nwiftab; 5707c478bd9Sstevel@tonic-gate static struct zone_devtab old_devtab, in_progress_devtab; 5717c478bd9Sstevel@tonic-gate static struct zone_rctltab old_rctltab, in_progress_rctltab; 5727c478bd9Sstevel@tonic-gate static struct zone_attrtab old_attrtab, in_progress_attrtab; 573fa9e4066Sahrens static struct zone_dstab old_dstab, in_progress_dstab; 5740209230bSgjelinek static struct zone_psettab old_psettab, in_progress_psettab; 5750209230bSgjelinek static struct zone_mcaptab old_mcaptab, in_progress_mcaptab; 576cb8a054bSGlenn Faden static struct zone_admintab old_admintab, in_progress_admintab; 5777c478bd9Sstevel@tonic-gate 5787c478bd9Sstevel@tonic-gate static GetLine *gl; /* The gl_get_line() resource object */ 5797c478bd9Sstevel@tonic-gate 5800209230bSgjelinek static void bytes_to_units(char *str, char *buf, int bufsize); 5810209230bSgjelinek 5827c478bd9Sstevel@tonic-gate /* Functions begin here */ 5837c478bd9Sstevel@tonic-gate 584bbec428eSgjelinek static boolean_t 5857c478bd9Sstevel@tonic-gate initial_match(const char *line1, const char *line2, int word_end) 5867c478bd9Sstevel@tonic-gate { 5877c478bd9Sstevel@tonic-gate if (word_end <= 0) 588bbec428eSgjelinek return (B_TRUE); 5897c478bd9Sstevel@tonic-gate return (strncmp(line1, line2, word_end) == 0); 5907c478bd9Sstevel@tonic-gate } 5917c478bd9Sstevel@tonic-gate 5927c478bd9Sstevel@tonic-gate static int 5937c478bd9Sstevel@tonic-gate add_stuff(WordCompletion *cpl, const char *line1, const char **list, 5947c478bd9Sstevel@tonic-gate int word_end) 5957c478bd9Sstevel@tonic-gate { 5967c478bd9Sstevel@tonic-gate int i, err; 5977c478bd9Sstevel@tonic-gate 5987c478bd9Sstevel@tonic-gate for (i = 0; list[i] != NULL; i++) { 5997c478bd9Sstevel@tonic-gate if (initial_match(line1, list[i], word_end)) { 6007c478bd9Sstevel@tonic-gate err = cpl_add_completion(cpl, line1, 0, word_end, 6017c478bd9Sstevel@tonic-gate list[i] + word_end, "", ""); 6027c478bd9Sstevel@tonic-gate if (err != 0) 6037c478bd9Sstevel@tonic-gate return (err); 6047c478bd9Sstevel@tonic-gate } 6057c478bd9Sstevel@tonic-gate } 6067c478bd9Sstevel@tonic-gate return (0); 6077c478bd9Sstevel@tonic-gate } 6087c478bd9Sstevel@tonic-gate 6097c478bd9Sstevel@tonic-gate static 6107c478bd9Sstevel@tonic-gate /* ARGSUSED */ 6117c478bd9Sstevel@tonic-gate CPL_MATCH_FN(cmd_cpl_fn) 6127c478bd9Sstevel@tonic-gate { 6137c478bd9Sstevel@tonic-gate if (global_scope) { 6147c478bd9Sstevel@tonic-gate /* 6157c478bd9Sstevel@tonic-gate * The MAX/MIN tests below are to make sure we have at least 6167c478bd9Sstevel@tonic-gate * enough characters to distinguish from other prefixes (MAX) 6177c478bd9Sstevel@tonic-gate * but only check MIN(what we have, what we're checking). 6187c478bd9Sstevel@tonic-gate */ 6197c478bd9Sstevel@tonic-gate if (strncmp(line, "add ", MAX(MIN(word_end, 4), 1)) == 0) 6207c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, add_cmds, word_end)); 6210209230bSgjelinek if (strncmp(line, "clear ", MAX(MIN(word_end, 6), 2)) == 0) 6220209230bSgjelinek return (add_stuff(cpl, line, clear_cmds, word_end)); 6237c478bd9Sstevel@tonic-gate if (strncmp(line, "select ", MAX(MIN(word_end, 7), 3)) == 0) 6247c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, select_cmds, word_end)); 6257c478bd9Sstevel@tonic-gate if (strncmp(line, "set ", MAX(MIN(word_end, 4), 3)) == 0) 6267c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, set_cmds, word_end)); 6279e7542f4Sdp if (strncmp(line, "remove ", MAX(MIN(word_end, 7), 1)) == 0) 6289e7542f4Sdp return (add_stuff(cpl, line, remove_cmds, word_end)); 6299e7542f4Sdp if (strncmp(line, "info ", MAX(MIN(word_end, 5), 1)) == 0) 6309e7542f4Sdp return (add_stuff(cpl, line, info_cmds, word_end)); 6317c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, global_scope_cmds, word_end)); 6327c478bd9Sstevel@tonic-gate } 6337c478bd9Sstevel@tonic-gate switch (resource_scope) { 6347c478bd9Sstevel@tonic-gate case RT_FS: 6357c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, fs_res_scope_cmds, word_end)); 6367c478bd9Sstevel@tonic-gate case RT_IPD: 6377c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, ipd_res_scope_cmds, word_end)); 6387c478bd9Sstevel@tonic-gate case RT_NET: 6397c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, net_res_scope_cmds, word_end)); 6407c478bd9Sstevel@tonic-gate case RT_DEVICE: 6417c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, device_res_scope_cmds, word_end)); 6427c478bd9Sstevel@tonic-gate case RT_RCTL: 6437c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, rctl_res_scope_cmds, word_end)); 6447c478bd9Sstevel@tonic-gate case RT_ATTR: 6457c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, attr_res_scope_cmds, word_end)); 646fa9e4066Sahrens case RT_DATASET: 647fa9e4066Sahrens return (add_stuff(cpl, line, dataset_res_scope_cmds, word_end)); 6480209230bSgjelinek case RT_DCPU: 6490209230bSgjelinek return (add_stuff(cpl, line, pset_res_scope_cmds, word_end)); 650c97ad5cdSakolb case RT_PCAP: 651c97ad5cdSakolb return (add_stuff(cpl, line, pcap_res_scope_cmds, word_end)); 6520209230bSgjelinek case RT_MCAP: 6530209230bSgjelinek return (add_stuff(cpl, line, mcap_res_scope_cmds, word_end)); 654cb8a054bSGlenn Faden case RT_ADMIN: 655cb8a054bSGlenn Faden return (add_stuff(cpl, line, admin_res_scope_cmds, word_end)); 6567c478bd9Sstevel@tonic-gate } 6577c478bd9Sstevel@tonic-gate return (0); 6587c478bd9Sstevel@tonic-gate } 6597c478bd9Sstevel@tonic-gate 6607c478bd9Sstevel@tonic-gate /* 6617c478bd9Sstevel@tonic-gate * For the main CMD_func() functions below, several of them call getopt() 6627c478bd9Sstevel@tonic-gate * then check optind against argc to make sure an extra parameter was not 6637c478bd9Sstevel@tonic-gate * passed in. The reason this is not caught in the grammar is that the 6647c478bd9Sstevel@tonic-gate * grammar just checks for a miscellaneous TOKEN, which is *expected* to 6657c478bd9Sstevel@tonic-gate * be "-F" (for example), but could be anything. So (for example) this 6667c478bd9Sstevel@tonic-gate * check will prevent "create bogus". 6677c478bd9Sstevel@tonic-gate */ 6687c478bd9Sstevel@tonic-gate 6697c478bd9Sstevel@tonic-gate cmd_t * 6707c478bd9Sstevel@tonic-gate alloc_cmd(void) 6717c478bd9Sstevel@tonic-gate { 6727c478bd9Sstevel@tonic-gate return (calloc(1, sizeof (cmd_t))); 6737c478bd9Sstevel@tonic-gate } 6747c478bd9Sstevel@tonic-gate 6757c478bd9Sstevel@tonic-gate void 6767c478bd9Sstevel@tonic-gate free_cmd(cmd_t *cmd) 6777c478bd9Sstevel@tonic-gate { 6787c478bd9Sstevel@tonic-gate int i; 6797c478bd9Sstevel@tonic-gate 6807c478bd9Sstevel@tonic-gate for (i = 0; i < MAX_EQ_PROP_PAIRS; i++) 6817c478bd9Sstevel@tonic-gate if (cmd->cmd_property_ptr[i] != NULL) { 6827c478bd9Sstevel@tonic-gate property_value_ptr_t pp = cmd->cmd_property_ptr[i]; 6837c478bd9Sstevel@tonic-gate 6847c478bd9Sstevel@tonic-gate switch (pp->pv_type) { 6857c478bd9Sstevel@tonic-gate case PROP_VAL_SIMPLE: 6867c478bd9Sstevel@tonic-gate free(pp->pv_simple); 6877c478bd9Sstevel@tonic-gate break; 6887c478bd9Sstevel@tonic-gate case PROP_VAL_COMPLEX: 6897c478bd9Sstevel@tonic-gate free_complex(pp->pv_complex); 6907c478bd9Sstevel@tonic-gate break; 6917c478bd9Sstevel@tonic-gate case PROP_VAL_LIST: 6927c478bd9Sstevel@tonic-gate free_list(pp->pv_list); 6937c478bd9Sstevel@tonic-gate break; 6947c478bd9Sstevel@tonic-gate } 6957c478bd9Sstevel@tonic-gate } 6967c478bd9Sstevel@tonic-gate for (i = 0; i < cmd->cmd_argc; i++) 6977c478bd9Sstevel@tonic-gate free(cmd->cmd_argv[i]); 6987c478bd9Sstevel@tonic-gate free(cmd); 6997c478bd9Sstevel@tonic-gate } 7007c478bd9Sstevel@tonic-gate 7017c478bd9Sstevel@tonic-gate complex_property_ptr_t 7027c478bd9Sstevel@tonic-gate alloc_complex(void) 7037c478bd9Sstevel@tonic-gate { 7047c478bd9Sstevel@tonic-gate return (calloc(1, sizeof (complex_property_t))); 7057c478bd9Sstevel@tonic-gate } 7067c478bd9Sstevel@tonic-gate 7077c478bd9Sstevel@tonic-gate void 7087c478bd9Sstevel@tonic-gate free_complex(complex_property_ptr_t complex) 7097c478bd9Sstevel@tonic-gate { 7107c478bd9Sstevel@tonic-gate if (complex == NULL) 7117c478bd9Sstevel@tonic-gate return; 7127c478bd9Sstevel@tonic-gate free_complex(complex->cp_next); 7137c478bd9Sstevel@tonic-gate if (complex->cp_value != NULL) 7147c478bd9Sstevel@tonic-gate free(complex->cp_value); 7157c478bd9Sstevel@tonic-gate free(complex); 7167c478bd9Sstevel@tonic-gate } 7177c478bd9Sstevel@tonic-gate 7187c478bd9Sstevel@tonic-gate list_property_ptr_t 7197c478bd9Sstevel@tonic-gate alloc_list(void) 7207c478bd9Sstevel@tonic-gate { 7217c478bd9Sstevel@tonic-gate return (calloc(1, sizeof (list_property_t))); 7227c478bd9Sstevel@tonic-gate } 7237c478bd9Sstevel@tonic-gate 7247c478bd9Sstevel@tonic-gate void 7257c478bd9Sstevel@tonic-gate free_list(list_property_ptr_t list) 7267c478bd9Sstevel@tonic-gate { 7277c478bd9Sstevel@tonic-gate if (list == NULL) 7287c478bd9Sstevel@tonic-gate return; 7297c478bd9Sstevel@tonic-gate if (list->lp_simple != NULL) 7307c478bd9Sstevel@tonic-gate free(list->lp_simple); 7317c478bd9Sstevel@tonic-gate free_complex(list->lp_complex); 7327c478bd9Sstevel@tonic-gate free_list(list->lp_next); 7337c478bd9Sstevel@tonic-gate free(list); 7347c478bd9Sstevel@tonic-gate } 7357c478bd9Sstevel@tonic-gate 7367c478bd9Sstevel@tonic-gate void 7377c478bd9Sstevel@tonic-gate free_outer_list(list_property_ptr_t list) 7387c478bd9Sstevel@tonic-gate { 7397c478bd9Sstevel@tonic-gate if (list == NULL) 7407c478bd9Sstevel@tonic-gate return; 7417c478bd9Sstevel@tonic-gate free_outer_list(list->lp_next); 7427c478bd9Sstevel@tonic-gate free(list); 7437c478bd9Sstevel@tonic-gate } 7447c478bd9Sstevel@tonic-gate 7457c478bd9Sstevel@tonic-gate static struct zone_rctlvaltab * 7467c478bd9Sstevel@tonic-gate alloc_rctlvaltab(void) 7477c478bd9Sstevel@tonic-gate { 7487c478bd9Sstevel@tonic-gate return (calloc(1, sizeof (struct zone_rctlvaltab))); 7497c478bd9Sstevel@tonic-gate } 7507c478bd9Sstevel@tonic-gate 7517c478bd9Sstevel@tonic-gate static char * 7527c478bd9Sstevel@tonic-gate rt_to_str(int res_type) 7537c478bd9Sstevel@tonic-gate { 7547c478bd9Sstevel@tonic-gate assert(res_type >= RT_MIN && res_type <= RT_MAX); 7557c478bd9Sstevel@tonic-gate return (res_types[res_type]); 7567c478bd9Sstevel@tonic-gate } 7577c478bd9Sstevel@tonic-gate 7587c478bd9Sstevel@tonic-gate static char * 7597c478bd9Sstevel@tonic-gate pt_to_str(int prop_type) 7607c478bd9Sstevel@tonic-gate { 7617c478bd9Sstevel@tonic-gate assert(prop_type >= PT_MIN && prop_type <= PT_MAX); 7627c478bd9Sstevel@tonic-gate return (prop_types[prop_type]); 7637c478bd9Sstevel@tonic-gate } 7647c478bd9Sstevel@tonic-gate 7657c478bd9Sstevel@tonic-gate static char * 7667c478bd9Sstevel@tonic-gate pvt_to_str(int pv_type) 7677c478bd9Sstevel@tonic-gate { 7687c478bd9Sstevel@tonic-gate assert(pv_type >= PROP_VAL_MIN && pv_type <= PROP_VAL_MAX); 7697c478bd9Sstevel@tonic-gate return (prop_val_types[pv_type]); 7707c478bd9Sstevel@tonic-gate } 7717c478bd9Sstevel@tonic-gate 7727c478bd9Sstevel@tonic-gate static char * 7737c478bd9Sstevel@tonic-gate cmd_to_str(int cmd_num) 7747c478bd9Sstevel@tonic-gate { 7757c478bd9Sstevel@tonic-gate assert(cmd_num >= CMD_MIN && cmd_num <= CMD_MAX); 7767c478bd9Sstevel@tonic-gate return (helptab[cmd_num].cmd_name); 7777c478bd9Sstevel@tonic-gate } 7787c478bd9Sstevel@tonic-gate 7793042b8b5Sbatschul /* PRINTFLIKE1 */ 7803042b8b5Sbatschul static void 7813042b8b5Sbatschul zerr(const char *fmt, ...) 7823042b8b5Sbatschul { 7833042b8b5Sbatschul va_list alist; 7843042b8b5Sbatschul static int last_lineno; 7853042b8b5Sbatschul 7863042b8b5Sbatschul /* lex_lineno has already been incremented in the lexer; compensate */ 7873042b8b5Sbatschul if (cmd_file_mode && lex_lineno > last_lineno) { 7883042b8b5Sbatschul if (strcmp(cmd_file_name, "-") == 0) 7893042b8b5Sbatschul (void) fprintf(stderr, gettext("On line %d:\n"), 7903042b8b5Sbatschul lex_lineno - 1); 7913042b8b5Sbatschul else 7923042b8b5Sbatschul (void) fprintf(stderr, gettext("On line %d of %s:\n"), 7933042b8b5Sbatschul lex_lineno - 1, cmd_file_name); 7943042b8b5Sbatschul last_lineno = lex_lineno; 7953042b8b5Sbatschul } 7963042b8b5Sbatschul va_start(alist, fmt); 7973042b8b5Sbatschul (void) vfprintf(stderr, fmt, alist); 7983042b8b5Sbatschul (void) fprintf(stderr, "\n"); 7993042b8b5Sbatschul va_end(alist); 8003042b8b5Sbatschul } 8013042b8b5Sbatschul 8027c478bd9Sstevel@tonic-gate /* 8037c478bd9Sstevel@tonic-gate * This is a separate function rather than a set of define's because of the 8047c478bd9Sstevel@tonic-gate * gettext() wrapping. 8057c478bd9Sstevel@tonic-gate */ 8067c478bd9Sstevel@tonic-gate 8077c478bd9Sstevel@tonic-gate /* 8087c478bd9Sstevel@tonic-gate * TRANSLATION_NOTE 8097c478bd9Sstevel@tonic-gate * Each string below should have \t follow \n whenever needed; the 8107c478bd9Sstevel@tonic-gate * initial \t and the terminal \n will be provided by the calling function. 8117c478bd9Sstevel@tonic-gate */ 8127c478bd9Sstevel@tonic-gate 8137c478bd9Sstevel@tonic-gate static char * 8147c478bd9Sstevel@tonic-gate long_help(int cmd_num) 8157c478bd9Sstevel@tonic-gate { 8167c478bd9Sstevel@tonic-gate static char line[1024]; /* arbitrary large amount */ 8177c478bd9Sstevel@tonic-gate 8187c478bd9Sstevel@tonic-gate assert(cmd_num >= CMD_MIN && cmd_num <= CMD_MAX); 8197c478bd9Sstevel@tonic-gate switch (cmd_num) { 8207c478bd9Sstevel@tonic-gate case CMD_HELP: 8217c478bd9Sstevel@tonic-gate return (gettext("Prints help message.")); 8227c478bd9Sstevel@tonic-gate case CMD_CREATE: 8237c478bd9Sstevel@tonic-gate (void) snprintf(line, sizeof (line), 8247c478bd9Sstevel@tonic-gate gettext("Creates a configuration for the " 8257c478bd9Sstevel@tonic-gate "specified zone. %s should be\n\tused to " 8267c478bd9Sstevel@tonic-gate "begin configuring a new zone. If overwriting an " 8277c478bd9Sstevel@tonic-gate "existing\n\tconfiguration, the -F flag can be " 8287c478bd9Sstevel@tonic-gate "used to force the action. If\n\t-t template is " 8297c478bd9Sstevel@tonic-gate "given, creates a configuration identical to the\n" 8307c478bd9Sstevel@tonic-gate "\tspecified template, except that the zone name " 8319e518655Sgjelinek "is changed from\n\ttemplate to zonename. '%s -a' " 8329e518655Sgjelinek "creates a configuration from a\n\tdetached " 8339e518655Sgjelinek "zonepath. '%s -b' results in a blank " 8349e518655Sgjelinek "configuration.\n\t'%s' with no arguments applies " 8359e518655Sgjelinek "the Sun default settings."), 8367c478bd9Sstevel@tonic-gate cmd_to_str(CMD_CREATE), cmd_to_str(CMD_CREATE), 8379e518655Sgjelinek cmd_to_str(CMD_CREATE), cmd_to_str(CMD_CREATE)); 8387c478bd9Sstevel@tonic-gate return (line); 8397c478bd9Sstevel@tonic-gate case CMD_EXIT: 8407c478bd9Sstevel@tonic-gate return (gettext("Exits the program. The -F flag can " 8417c478bd9Sstevel@tonic-gate "be used to force the action.")); 8427c478bd9Sstevel@tonic-gate case CMD_EXPORT: 8437c478bd9Sstevel@tonic-gate return (gettext("Prints configuration to standard " 8447c478bd9Sstevel@tonic-gate "output, or to output-file if\n\tspecified, in " 8457c478bd9Sstevel@tonic-gate "a form suitable for use in a command-file.")); 8467c478bd9Sstevel@tonic-gate case CMD_ADD: 8477c478bd9Sstevel@tonic-gate return (gettext("Add specified resource to " 8487c478bd9Sstevel@tonic-gate "configuration.")); 8497c478bd9Sstevel@tonic-gate case CMD_DELETE: 8507c478bd9Sstevel@tonic-gate return (gettext("Deletes the specified zone. The -F " 8517c478bd9Sstevel@tonic-gate "flag can be used to force the\n\taction.")); 8527c478bd9Sstevel@tonic-gate case CMD_REMOVE: 8537c478bd9Sstevel@tonic-gate return (gettext("Remove specified resource from " 8540209230bSgjelinek "configuration. The -F flag can be used\n\tto " 8550209230bSgjelinek "force the action.")); 8567c478bd9Sstevel@tonic-gate case CMD_SELECT: 8577c478bd9Sstevel@tonic-gate (void) snprintf(line, sizeof (line), 8587c478bd9Sstevel@tonic-gate gettext("Selects a resource to modify. " 8597c478bd9Sstevel@tonic-gate "Resource modification is completed\n\twith the " 8607c478bd9Sstevel@tonic-gate "command \"%s\". The property name/value pairs " 8617c478bd9Sstevel@tonic-gate "must uniquely\n\tidentify a resource. Note that " 8627c478bd9Sstevel@tonic-gate "the curly braces ('{', '}') mean one\n\tor more " 8637c478bd9Sstevel@tonic-gate "of whatever is between them."), 8647c478bd9Sstevel@tonic-gate cmd_to_str(CMD_END)); 8657c478bd9Sstevel@tonic-gate return (line); 8667c478bd9Sstevel@tonic-gate case CMD_SET: 8677c478bd9Sstevel@tonic-gate return (gettext("Sets property values.")); 8680209230bSgjelinek case CMD_CLEAR: 8690209230bSgjelinek return (gettext("Clears property values.")); 8707c478bd9Sstevel@tonic-gate case CMD_INFO: 8717c478bd9Sstevel@tonic-gate return (gettext("Displays information about the " 8727c478bd9Sstevel@tonic-gate "current configuration. If resource\n\ttype is " 8737c478bd9Sstevel@tonic-gate "specified, displays only information about " 8747c478bd9Sstevel@tonic-gate "resources of\n\tthe relevant type. If resource " 8757c478bd9Sstevel@tonic-gate "id is specified, displays only\n\tinformation " 8767c478bd9Sstevel@tonic-gate "about that resource.")); 8777c478bd9Sstevel@tonic-gate case CMD_VERIFY: 8787c478bd9Sstevel@tonic-gate return (gettext("Verifies current configuration " 8797c478bd9Sstevel@tonic-gate "for correctness (some resource types\n\thave " 8807c478bd9Sstevel@tonic-gate "required properties).")); 8817c478bd9Sstevel@tonic-gate case CMD_COMMIT: 8827c478bd9Sstevel@tonic-gate (void) snprintf(line, sizeof (line), 8837c478bd9Sstevel@tonic-gate gettext("Commits current configuration. " 8847c478bd9Sstevel@tonic-gate "Configuration must be committed to\n\tbe used by " 8857c478bd9Sstevel@tonic-gate "%s. Until the configuration is committed, " 8867c478bd9Sstevel@tonic-gate "changes \n\tcan be removed with the %s " 8877c478bd9Sstevel@tonic-gate "command. This operation is\n\tattempted " 8887c478bd9Sstevel@tonic-gate "automatically upon completion of a %s " 8897c478bd9Sstevel@tonic-gate "session."), "zoneadm", cmd_to_str(CMD_REVERT), 8907c478bd9Sstevel@tonic-gate "zonecfg"); 8917c478bd9Sstevel@tonic-gate return (line); 8927c478bd9Sstevel@tonic-gate case CMD_REVERT: 8937c478bd9Sstevel@tonic-gate return (gettext("Reverts configuration back to the " 8947c478bd9Sstevel@tonic-gate "last committed state. The -F flag\n\tcan be " 8957c478bd9Sstevel@tonic-gate "used to force the action.")); 8967c478bd9Sstevel@tonic-gate case CMD_CANCEL: 8977c478bd9Sstevel@tonic-gate return (gettext("Cancels resource/property " 8987c478bd9Sstevel@tonic-gate "specification.")); 8997c478bd9Sstevel@tonic-gate case CMD_END: 9007c478bd9Sstevel@tonic-gate return (gettext("Ends resource/property " 9017c478bd9Sstevel@tonic-gate "specification.")); 9027c478bd9Sstevel@tonic-gate } 9037c478bd9Sstevel@tonic-gate /* NOTREACHED */ 9047e362f58Scomay return (NULL); 9057c478bd9Sstevel@tonic-gate } 9067c478bd9Sstevel@tonic-gate 9077c478bd9Sstevel@tonic-gate /* 9087c478bd9Sstevel@tonic-gate * Called with verbose TRUE when help is explicitly requested, FALSE for 9097c478bd9Sstevel@tonic-gate * unexpected errors. 9107c478bd9Sstevel@tonic-gate */ 9117c478bd9Sstevel@tonic-gate 9127c478bd9Sstevel@tonic-gate void 913bbec428eSgjelinek usage(boolean_t verbose, uint_t flags) 9147c478bd9Sstevel@tonic-gate { 9153042b8b5Sbatschul FILE *fp = verbose ? stdout : stderr; 9163042b8b5Sbatschul FILE *newfp; 917bbec428eSgjelinek boolean_t need_to_close = B_FALSE; 9187c478bd9Sstevel@tonic-gate char *pager; 9197c478bd9Sstevel@tonic-gate int i; 9203042b8b5Sbatschul struct stat statbuf; 9217c478bd9Sstevel@tonic-gate 9227c478bd9Sstevel@tonic-gate /* don't page error output */ 9237c478bd9Sstevel@tonic-gate if (verbose && interactive_mode) { 9247c478bd9Sstevel@tonic-gate if ((pager = getenv("PAGER")) == NULL) 9257c478bd9Sstevel@tonic-gate pager = PAGER; 9263042b8b5Sbatschul 9273042b8b5Sbatschul if (stat(pager, &statbuf) == 0) { 9287c478bd9Sstevel@tonic-gate if ((newfp = popen(pager, "w")) != NULL) { 929bbec428eSgjelinek need_to_close = B_TRUE; 9307c478bd9Sstevel@tonic-gate fp = newfp; 9317c478bd9Sstevel@tonic-gate } 9323042b8b5Sbatschul } else { 9333042b8b5Sbatschul zerr(gettext("PAGER %s does not exist (%s)."), 9343042b8b5Sbatschul pager, strerror(errno)); 9357c478bd9Sstevel@tonic-gate } 9363042b8b5Sbatschul } 9373042b8b5Sbatschul 9387c478bd9Sstevel@tonic-gate if (flags & HELP_META) { 9397c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("More help is available for the " 9407c478bd9Sstevel@tonic-gate "following:\n")); 9417c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\n\tcommands ('%s commands')\n", 9427c478bd9Sstevel@tonic-gate cmd_to_str(CMD_HELP)); 9437c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\tsyntax ('%s syntax')\n", 9447c478bd9Sstevel@tonic-gate cmd_to_str(CMD_HELP)); 9457c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\tusage ('%s usage')\n\n", 9467c478bd9Sstevel@tonic-gate cmd_to_str(CMD_HELP)); 9477c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("You may also obtain help on any " 9487c478bd9Sstevel@tonic-gate "command by typing '%s <command-name>.'\n"), 9497c478bd9Sstevel@tonic-gate cmd_to_str(CMD_HELP)); 9507c478bd9Sstevel@tonic-gate } 9517c478bd9Sstevel@tonic-gate if (flags & HELP_RES_SCOPE) { 9527c478bd9Sstevel@tonic-gate switch (resource_scope) { 9537c478bd9Sstevel@tonic-gate case RT_FS: 9547c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("The '%s' resource scope is " 9557c478bd9Sstevel@tonic-gate "used to configure a file-system.\n"), 9567c478bd9Sstevel@tonic-gate rt_to_str(resource_scope)); 9577c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("Valid commands:\n")); 9587c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 9597c478bd9Sstevel@tonic-gate pt_to_str(PT_DIR), gettext("<path>")); 9607c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 9617c478bd9Sstevel@tonic-gate pt_to_str(PT_SPECIAL), gettext("<path>")); 9627c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 9637c478bd9Sstevel@tonic-gate pt_to_str(PT_RAW), gettext("<raw-device>")); 9647c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 9657c478bd9Sstevel@tonic-gate pt_to_str(PT_TYPE), gettext("<file-system type>")); 9667c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s %s\n", cmd_to_str(CMD_ADD), 9677c478bd9Sstevel@tonic-gate pt_to_str(PT_OPTIONS), 9687c478bd9Sstevel@tonic-gate gettext("<file-system options>")); 969ffbafc53Scomay (void) fprintf(fp, "\t%s %s %s\n", 970ffbafc53Scomay cmd_to_str(CMD_REMOVE), pt_to_str(PT_OPTIONS), 971ffbafc53Scomay gettext("<file-system options>")); 9727c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("Consult the file-system " 9737c478bd9Sstevel@tonic-gate "specific manual page, such as mount_ufs(1M), " 9747c478bd9Sstevel@tonic-gate "for\ndetails about file-system options. Note " 9757c478bd9Sstevel@tonic-gate "that any file-system options with an\nembedded " 9767c478bd9Sstevel@tonic-gate "'=' character must be enclosed in double quotes, " 9777c478bd9Sstevel@tonic-gate /*CSTYLED*/ 9787c478bd9Sstevel@tonic-gate "such as \"%s=5\".\n"), MNTOPT_RETRY); 9797c478bd9Sstevel@tonic-gate break; 9807c478bd9Sstevel@tonic-gate case RT_IPD: 9817c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("The '%s' resource scope is " 9827c478bd9Sstevel@tonic-gate "used to configure a directory\ninherited from the " 9837c478bd9Sstevel@tonic-gate "global zone into a non-global zone in read-only " 9847c478bd9Sstevel@tonic-gate "mode.\n"), rt_to_str(resource_scope)); 9857c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("Valid commands:\n")); 9867c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 9877c478bd9Sstevel@tonic-gate pt_to_str(PT_DIR), gettext("<path>")); 9887c478bd9Sstevel@tonic-gate break; 9897c478bd9Sstevel@tonic-gate case RT_NET: 9907c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("The '%s' resource scope is " 9917c478bd9Sstevel@tonic-gate "used to configure a network interface.\n"), 9927c478bd9Sstevel@tonic-gate rt_to_str(resource_scope)); 9937c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("Valid commands:\n")); 9947c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 9957c478bd9Sstevel@tonic-gate pt_to_str(PT_ADDRESS), gettext("<IP-address>")); 9967c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 9977c478bd9Sstevel@tonic-gate pt_to_str(PT_PHYSICAL), gettext("<interface>")); 9987c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("See ifconfig(1M) for " 9997c478bd9Sstevel@tonic-gate "details of the <interface> string.\n")); 1000de860bd9Sgfaden (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 1001de860bd9Sgfaden pt_to_str(PT_DEFROUTER), gettext("<IP-address>")); 1002de860bd9Sgfaden (void) fprintf(fp, gettext("%s %s and %s %s are valid " 1003de860bd9Sgfaden "if the %s property is set to %s, otherwise they " 1004de860bd9Sgfaden "must not be set.\n"), 1005f4b3ec61Sdh155122 cmd_to_str(CMD_SET), pt_to_str(PT_ADDRESS), 1006de860bd9Sgfaden cmd_to_str(CMD_SET), pt_to_str(PT_DEFROUTER), 1007f4b3ec61Sdh155122 pt_to_str(PT_IPTYPE), "shared"); 10087c478bd9Sstevel@tonic-gate break; 10097c478bd9Sstevel@tonic-gate case RT_DEVICE: 10107c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("The '%s' resource scope is " 10117c478bd9Sstevel@tonic-gate "used to configure a device node.\n"), 10127c478bd9Sstevel@tonic-gate rt_to_str(resource_scope)); 10137c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("Valid commands:\n")); 10147c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 10157c478bd9Sstevel@tonic-gate pt_to_str(PT_MATCH), gettext("<device-path>")); 10167c478bd9Sstevel@tonic-gate break; 10177c478bd9Sstevel@tonic-gate case RT_RCTL: 10187c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("The '%s' resource scope is " 10197c478bd9Sstevel@tonic-gate "used to configure a resource control.\n"), 10207c478bd9Sstevel@tonic-gate rt_to_str(resource_scope)); 10217c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("Valid commands:\n")); 10227c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 10237c478bd9Sstevel@tonic-gate pt_to_str(PT_NAME), gettext("<string>")); 10247c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s (%s=%s,%s=%s,%s=%s)\n", 10257c478bd9Sstevel@tonic-gate cmd_to_str(CMD_ADD), pt_to_str(PT_VALUE), 10267c478bd9Sstevel@tonic-gate pt_to_str(PT_PRIV), gettext("<priv-value>"), 10277c478bd9Sstevel@tonic-gate pt_to_str(PT_LIMIT), gettext("<number>"), 10287c478bd9Sstevel@tonic-gate pt_to_str(PT_ACTION), gettext("<action-value>")); 1029ffbafc53Scomay (void) fprintf(fp, "\t%s %s (%s=%s,%s=%s,%s=%s)\n", 1030ffbafc53Scomay cmd_to_str(CMD_REMOVE), pt_to_str(PT_VALUE), 1031ffbafc53Scomay pt_to_str(PT_PRIV), gettext("<priv-value>"), 1032ffbafc53Scomay pt_to_str(PT_LIMIT), gettext("<number>"), 1033ffbafc53Scomay pt_to_str(PT_ACTION), gettext("<action-value>")); 10347c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s\n\t%s := privileged\n" 10357c478bd9Sstevel@tonic-gate "\t%s := none | deny\n", gettext("Where"), 10367c478bd9Sstevel@tonic-gate gettext("<priv-value>"), gettext("<action-value>")); 10377c478bd9Sstevel@tonic-gate break; 10387c478bd9Sstevel@tonic-gate case RT_ATTR: 10397c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("The '%s' resource scope is " 10407c478bd9Sstevel@tonic-gate "used to configure a generic attribute.\n"), 10417c478bd9Sstevel@tonic-gate rt_to_str(resource_scope)); 10427c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("Valid commands:\n")); 10437c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 10447c478bd9Sstevel@tonic-gate pt_to_str(PT_NAME), gettext("<name>")); 10457c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=boolean\n", 10467c478bd9Sstevel@tonic-gate cmd_to_str(CMD_SET), pt_to_str(PT_TYPE)); 10477c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=true | false\n", 10487c478bd9Sstevel@tonic-gate cmd_to_str(CMD_SET), pt_to_str(PT_VALUE)); 10497c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("or\n")); 10507c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=int\n", cmd_to_str(CMD_SET), 10517c478bd9Sstevel@tonic-gate pt_to_str(PT_TYPE)); 10527c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 10537c478bd9Sstevel@tonic-gate pt_to_str(PT_VALUE), gettext("<integer>")); 10547c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("or\n")); 10557c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=string\n", 10567c478bd9Sstevel@tonic-gate cmd_to_str(CMD_SET), pt_to_str(PT_TYPE)); 10577c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 10587c478bd9Sstevel@tonic-gate pt_to_str(PT_VALUE), gettext("<string>")); 10597c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("or\n")); 10607c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=uint\n", 10617c478bd9Sstevel@tonic-gate cmd_to_str(CMD_SET), pt_to_str(PT_TYPE)); 10627c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 10637c478bd9Sstevel@tonic-gate pt_to_str(PT_VALUE), gettext("<unsigned integer>")); 10647c478bd9Sstevel@tonic-gate break; 1065fa9e4066Sahrens case RT_DATASET: 1066fa9e4066Sahrens (void) fprintf(fp, gettext("The '%s' resource scope is " 1067fa9e4066Sahrens "used to export ZFS datasets.\n"), 1068fa9e4066Sahrens rt_to_str(resource_scope)); 1069fa9e4066Sahrens (void) fprintf(fp, gettext("Valid commands:\n")); 1070fa9e4066Sahrens (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 1071fa9e4066Sahrens pt_to_str(PT_NAME), gettext("<name>")); 1072fa9e4066Sahrens break; 10730209230bSgjelinek case RT_DCPU: 10740209230bSgjelinek (void) fprintf(fp, gettext("The '%s' resource scope " 10750209230bSgjelinek "configures the 'pools' facility to dedicate\na " 10760209230bSgjelinek "subset of the system's processors to this zone " 10770209230bSgjelinek "while it is running.\n"), 10780209230bSgjelinek rt_to_str(resource_scope)); 10790209230bSgjelinek (void) fprintf(fp, gettext("Valid commands:\n")); 10800209230bSgjelinek (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 10810209230bSgjelinek pt_to_str(PT_NCPUS), 10820209230bSgjelinek gettext("<unsigned integer | range>")); 10830209230bSgjelinek (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 10840209230bSgjelinek pt_to_str(PT_IMPORTANCE), 10850209230bSgjelinek gettext("<unsigned integer>")); 10860209230bSgjelinek break; 1087c97ad5cdSakolb case RT_PCAP: 1088c97ad5cdSakolb (void) fprintf(fp, gettext("The '%s' resource scope is " 1089c97ad5cdSakolb "used to set an upper limit (a cap) on the\n" 1090c97ad5cdSakolb "percentage of CPU that can be used by this zone. " 1091c97ad5cdSakolb "A '%s' value of 1\ncorresponds to one cpu. The " 1092c97ad5cdSakolb "value can be set higher than 1, up to the total\n" 1093c97ad5cdSakolb "number of CPUs on the system. The value can " 1094c97ad5cdSakolb "also be less than 1,\nrepresenting a fraction of " 1095c97ad5cdSakolb "a cpu.\n"), 1096c97ad5cdSakolb rt_to_str(resource_scope), pt_to_str(PT_NCPUS)); 1097c97ad5cdSakolb (void) fprintf(fp, gettext("Valid commands:\n")); 1098c97ad5cdSakolb (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 1099c97ad5cdSakolb pt_to_str(PT_NCPUS), gettext("<unsigned decimal>")); 1100c97ad5cdSakolb break; 11010209230bSgjelinek case RT_MCAP: 11020209230bSgjelinek (void) fprintf(fp, gettext("The '%s' resource scope is " 11030209230bSgjelinek "used to set an upper limit (a cap) on the\n" 11040209230bSgjelinek "amount of physical memory, swap space and locked " 11050209230bSgjelinek "memory that can be used by\nthis zone.\n"), 11060209230bSgjelinek rt_to_str(resource_scope)); 11070209230bSgjelinek (void) fprintf(fp, gettext("Valid commands:\n")); 11080209230bSgjelinek (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 11090209230bSgjelinek pt_to_str(PT_PHYSICAL), 11100209230bSgjelinek gettext("<qualified unsigned decimal>")); 11110209230bSgjelinek (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 11120209230bSgjelinek pt_to_str(PT_SWAP), 11130209230bSgjelinek gettext("<qualified unsigned decimal>")); 11140209230bSgjelinek (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 11150209230bSgjelinek pt_to_str(PT_LOCKED), 11160209230bSgjelinek gettext("<qualified unsigned decimal>")); 11170209230bSgjelinek break; 1118cb8a054bSGlenn Faden case RT_ADMIN: 1119cb8a054bSGlenn Faden (void) fprintf(fp, gettext("The '%s' resource scope is " 1120cb8a054bSGlenn Faden "used to delegate specific zone management\n" 1121cb8a054bSGlenn Faden "rights to users and roles. These rights are " 1122cb8a054bSGlenn Faden "only applicable to this zone.\n"), 1123cb8a054bSGlenn Faden rt_to_str(resource_scope)); 1124cb8a054bSGlenn Faden (void) fprintf(fp, gettext("Valid commands:\n")); 1125cb8a054bSGlenn Faden (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 1126cb8a054bSGlenn Faden pt_to_str(PT_USER), 1127cb8a054bSGlenn Faden gettext("<single user or role name>")); 1128cb8a054bSGlenn Faden (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 1129cb8a054bSGlenn Faden pt_to_str(PT_AUTHS), 1130cb8a054bSGlenn Faden gettext("<comma separated list>")); 1131cb8a054bSGlenn Faden break; 11327c478bd9Sstevel@tonic-gate } 11337c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("And from any resource scope, you " 11347c478bd9Sstevel@tonic-gate "can:\n")); 11357c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t%s\n", cmd_to_str(CMD_END), 11367c478bd9Sstevel@tonic-gate gettext("(to conclude this operation)")); 11377c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t%s\n", cmd_to_str(CMD_CANCEL), 11387c478bd9Sstevel@tonic-gate gettext("(to cancel this operation)")); 11397c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t%s\n", cmd_to_str(CMD_EXIT), 11407c478bd9Sstevel@tonic-gate gettext("(to exit the zonecfg utility)")); 11417c478bd9Sstevel@tonic-gate } 11427c478bd9Sstevel@tonic-gate if (flags & HELP_USAGE) { 11437c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s:\t%s %s\n", gettext("usage"), 11447c478bd9Sstevel@tonic-gate execname, cmd_to_str(CMD_HELP)); 11457c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s -z <zone>\t\t\t(%s)\n", 11467c478bd9Sstevel@tonic-gate execname, gettext("interactive")); 11477c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s -z <zone> <command>\n", execname); 11487c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s -z <zone> -f <command-file>\n", 11497c478bd9Sstevel@tonic-gate execname); 11507c478bd9Sstevel@tonic-gate } 11517c478bd9Sstevel@tonic-gate if (flags & HELP_SUBCMDS) { 11527c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s:\n\n", gettext("Commands")); 11537c478bd9Sstevel@tonic-gate for (i = 0; i <= CMD_MAX; i++) { 11547c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s\n", helptab[i].short_usage); 11557c478bd9Sstevel@tonic-gate if (verbose) 11567c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\n\n", long_help(i)); 11577c478bd9Sstevel@tonic-gate } 11587c478bd9Sstevel@tonic-gate } 11597c478bd9Sstevel@tonic-gate if (flags & HELP_SYNTAX) { 11607c478bd9Sstevel@tonic-gate if (!verbose) 11617c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\n"); 11627c478bd9Sstevel@tonic-gate (void) fprintf(fp, "<zone> := [A-Za-z0-9][A-Za-z0-9_.-]*\n"); 11637c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("\t(except the reserved words " 11647c478bd9Sstevel@tonic-gate "'%s' and anything starting with '%s')\n"), "global", 11657c478bd9Sstevel@tonic-gate "SUNW"); 11667c478bd9Sstevel@tonic-gate (void) fprintf(fp, 11677c478bd9Sstevel@tonic-gate gettext("\tName must be less than %d characters.\n"), 11687c478bd9Sstevel@tonic-gate ZONENAME_MAX); 11697c478bd9Sstevel@tonic-gate if (verbose) 11707c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\n"); 11717c478bd9Sstevel@tonic-gate } 11727c478bd9Sstevel@tonic-gate if (flags & HELP_NETADDR) { 11737c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("\n<net-addr> :=")); 11747c478bd9Sstevel@tonic-gate (void) fprintf(fp, 11757c478bd9Sstevel@tonic-gate gettext("\t<IPv4-address>[/<IPv4-prefix-length>] |\n")); 11767c478bd9Sstevel@tonic-gate (void) fprintf(fp, 11777c478bd9Sstevel@tonic-gate gettext("\t\t<IPv6-address>/<IPv6-prefix-length> |\n")); 11787c478bd9Sstevel@tonic-gate (void) fprintf(fp, 11797c478bd9Sstevel@tonic-gate gettext("\t\t<hostname>[/<IPv4-prefix-length>]\n")); 11807c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("See inet(3SOCKET) for IPv4 and " 11817c478bd9Sstevel@tonic-gate "IPv6 address syntax.\n")); 11827c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("<IPv4-prefix-length> := [0-32]\n")); 11837c478bd9Sstevel@tonic-gate (void) fprintf(fp, 11847c478bd9Sstevel@tonic-gate gettext("<IPv6-prefix-length> := [0-128]\n")); 11857c478bd9Sstevel@tonic-gate (void) fprintf(fp, 11867c478bd9Sstevel@tonic-gate gettext("<hostname> := [A-Za-z0-9][A-Za-z0-9-.]*\n")); 11877c478bd9Sstevel@tonic-gate } 11887c478bd9Sstevel@tonic-gate if (flags & HELP_RESOURCES) { 11899e7542f4Sdp (void) fprintf(fp, "<%s> := %s | %s | %s | %s | %s | %s |\n\t" 1190cb8a054bSGlenn Faden "%s | %s | %s | %s | %s\n\n", 11917c478bd9Sstevel@tonic-gate gettext("resource type"), rt_to_str(RT_FS), 11927c478bd9Sstevel@tonic-gate rt_to_str(RT_IPD), rt_to_str(RT_NET), rt_to_str(RT_DEVICE), 11939e7542f4Sdp rt_to_str(RT_RCTL), rt_to_str(RT_ATTR), 11940209230bSgjelinek rt_to_str(RT_DATASET), rt_to_str(RT_DCPU), 1195cb8a054bSGlenn Faden rt_to_str(RT_PCAP), rt_to_str(RT_MCAP), 1196cb8a054bSGlenn Faden rt_to_str(RT_ADMIN)); 11977c478bd9Sstevel@tonic-gate } 11987c478bd9Sstevel@tonic-gate if (flags & HELP_PROPS) { 11997c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("For resource type ... there are " 12007c478bd9Sstevel@tonic-gate "property types ...:\n")); 12017c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 1202087719fdSdp pt_to_str(PT_ZONENAME)); 1203087719fdSdp (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 12047c478bd9Sstevel@tonic-gate pt_to_str(PT_ZONEPATH)); 12057c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 12069acbbeafSnn35248 pt_to_str(PT_BRAND)); 12079acbbeafSnn35248 (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 12087c478bd9Sstevel@tonic-gate pt_to_str(PT_AUTOBOOT)); 12097c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 12103f2f09c1Sdp pt_to_str(PT_BOOTARGS)); 12113f2f09c1Sdp (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 12127c478bd9Sstevel@tonic-gate pt_to_str(PT_POOL)); 1213ffbafc53Scomay (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 1214ffbafc53Scomay pt_to_str(PT_LIMITPRIV)); 12150209230bSgjelinek (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 12160209230bSgjelinek pt_to_str(PT_SCHED)); 12170209230bSgjelinek (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 1218f4b3ec61Sdh155122 pt_to_str(PT_IPTYPE)); 1219f4b3ec61Sdh155122 (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 12205679c89fSjv227347 pt_to_str(PT_HOSTID)); 12215679c89fSjv227347 (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 12220209230bSgjelinek pt_to_str(PT_MAXLWPS)); 12230209230bSgjelinek (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 12240209230bSgjelinek pt_to_str(PT_MAXSHMMEM)); 12250209230bSgjelinek (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 12260209230bSgjelinek pt_to_str(PT_MAXSHMIDS)); 12270209230bSgjelinek (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 12280209230bSgjelinek pt_to_str(PT_MAXMSGIDS)); 12290209230bSgjelinek (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 12300209230bSgjelinek pt_to_str(PT_MAXSEMIDS)); 12310209230bSgjelinek (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 12320209230bSgjelinek pt_to_str(PT_SHARES)); 12336d4d1c0dSbatschul (void) fprintf(fp, "\t%s\t\t%s, %s, %s, %s, %s\n", 12346d4d1c0dSbatschul rt_to_str(RT_FS), pt_to_str(PT_DIR), 12356d4d1c0dSbatschul pt_to_str(PT_SPECIAL), pt_to_str(PT_RAW), 12366d4d1c0dSbatschul pt_to_str(PT_TYPE), pt_to_str(PT_OPTIONS)); 12377c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t%s\n", rt_to_str(RT_IPD), 12387c478bd9Sstevel@tonic-gate pt_to_str(PT_DIR)); 1239de860bd9Sgfaden (void) fprintf(fp, "\t%s\t\t%s, %s, %s\n", rt_to_str(RT_NET), 1240de860bd9Sgfaden pt_to_str(PT_ADDRESS), pt_to_str(PT_PHYSICAL), 1241de860bd9Sgfaden pt_to_str(PT_DEFROUTER)); 12427c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t\t%s\n", rt_to_str(RT_DEVICE), 12437c478bd9Sstevel@tonic-gate pt_to_str(PT_MATCH)); 12447c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t\t%s, %s\n", rt_to_str(RT_RCTL), 12457c478bd9Sstevel@tonic-gate pt_to_str(PT_NAME), pt_to_str(PT_VALUE)); 12467c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t\t%s, %s, %s\n", rt_to_str(RT_ATTR), 12477c478bd9Sstevel@tonic-gate pt_to_str(PT_NAME), pt_to_str(PT_TYPE), 12487c478bd9Sstevel@tonic-gate pt_to_str(PT_VALUE)); 1249fa9e4066Sahrens (void) fprintf(fp, "\t%s\t\t%s\n", rt_to_str(RT_DATASET), 1250fa9e4066Sahrens pt_to_str(PT_NAME)); 12510209230bSgjelinek (void) fprintf(fp, "\t%s\t%s, %s\n", rt_to_str(RT_DCPU), 12520209230bSgjelinek pt_to_str(PT_NCPUS), pt_to_str(PT_IMPORTANCE)); 1253c97ad5cdSakolb (void) fprintf(fp, "\t%s\t%s\n", rt_to_str(RT_PCAP), 1254c97ad5cdSakolb pt_to_str(PT_NCPUS)); 12550209230bSgjelinek (void) fprintf(fp, "\t%s\t%s, %s, %s\n", rt_to_str(RT_MCAP), 12560209230bSgjelinek pt_to_str(PT_PHYSICAL), pt_to_str(PT_SWAP), 12570209230bSgjelinek pt_to_str(PT_LOCKED)); 1258cb8a054bSGlenn Faden (void) fprintf(fp, "\t%s\t\t%s, %s\n", rt_to_str(RT_ADMIN), 1259cb8a054bSGlenn Faden pt_to_str(PT_USER), pt_to_str(PT_AUTHS)); 12607c478bd9Sstevel@tonic-gate } 12617c478bd9Sstevel@tonic-gate if (need_to_close) 12627c478bd9Sstevel@tonic-gate (void) pclose(fp); 12637c478bd9Sstevel@tonic-gate } 12647c478bd9Sstevel@tonic-gate 12657c478bd9Sstevel@tonic-gate static void 1266bbec428eSgjelinek zone_perror(char *prefix, int err, boolean_t set_saw) 12677c478bd9Sstevel@tonic-gate { 12687c478bd9Sstevel@tonic-gate zerr("%s: %s", prefix, zonecfg_strerror(err)); 12697c478bd9Sstevel@tonic-gate if (set_saw) 1270bbec428eSgjelinek saw_error = B_TRUE; 12717c478bd9Sstevel@tonic-gate } 12727c478bd9Sstevel@tonic-gate 12737c478bd9Sstevel@tonic-gate /* 12747c478bd9Sstevel@tonic-gate * zone_perror() expects a single string, but for remove and select 12757c478bd9Sstevel@tonic-gate * we have both the command and the resource type, so this wrapper 12767c478bd9Sstevel@tonic-gate * function serves the same purpose in a slightly different way. 12777c478bd9Sstevel@tonic-gate */ 12787c478bd9Sstevel@tonic-gate 12797c478bd9Sstevel@tonic-gate static void 1280bbec428eSgjelinek z_cmd_rt_perror(int cmd_num, int res_num, int err, boolean_t set_saw) 12817c478bd9Sstevel@tonic-gate { 12827c478bd9Sstevel@tonic-gate zerr("%s %s: %s", cmd_to_str(cmd_num), rt_to_str(res_num), 12837c478bd9Sstevel@tonic-gate zonecfg_strerror(err)); 12847c478bd9Sstevel@tonic-gate if (set_saw) 1285bbec428eSgjelinek saw_error = B_TRUE; 12867c478bd9Sstevel@tonic-gate } 12877c478bd9Sstevel@tonic-gate 12887c478bd9Sstevel@tonic-gate /* returns Z_OK if successful, Z_foo from <libzonecfg.h> otherwise */ 12897c478bd9Sstevel@tonic-gate static int 1290bbec428eSgjelinek initialize(boolean_t handle_expected) 12917c478bd9Sstevel@tonic-gate { 12927c478bd9Sstevel@tonic-gate int err; 12939acbbeafSnn35248 char brandname[MAXNAMELEN]; 12947c478bd9Sstevel@tonic-gate 12957c478bd9Sstevel@tonic-gate if (zonecfg_check_handle(handle) != Z_OK) { 12967c478bd9Sstevel@tonic-gate if ((err = zonecfg_get_handle(zone, handle)) == Z_OK) { 1297bbec428eSgjelinek got_handle = B_TRUE; 12989acbbeafSnn35248 if (zonecfg_get_brand(handle, brandname, 12999acbbeafSnn35248 sizeof (brandname)) != Z_OK) { 13009acbbeafSnn35248 zerr("Zone %s is inconsistent: missing " 13019acbbeafSnn35248 "brand attribute", zone); 13029acbbeafSnn35248 exit(Z_ERR); 13039acbbeafSnn35248 } 13049acbbeafSnn35248 if ((brand = brand_open(brandname)) == NULL) { 13059acbbeafSnn35248 zerr("Zone %s uses non-existent brand \"%s\"." 13069acbbeafSnn35248 " Unable to continue", zone, brandname); 13079acbbeafSnn35248 exit(Z_ERR); 13089acbbeafSnn35248 } 1309cb8a054bSGlenn Faden /* 1310cb8a054bSGlenn Faden * If the user_attr file is newer than 1311cb8a054bSGlenn Faden * the zone config file, the admins 1312cb8a054bSGlenn Faden * may need to be updated since the 1313cb8a054bSGlenn Faden * RBAC files are authoritative for 1314cb8a054bSGlenn Faden * authorization checks. 1315cb8a054bSGlenn Faden */ 1316cb8a054bSGlenn Faden err = zonecfg_update_userauths(handle, zone); 1317cb8a054bSGlenn Faden if (err == Z_OK) { 1318cb8a054bSGlenn Faden zerr(gettext("The administrative rights " 1319cb8a054bSGlenn Faden "were updated to match " 1320cb8a054bSGlenn Faden "the current RBAC configuration.\n" 1321cb8a054bSGlenn Faden "Use \"info admin\" and \"revert\" to " 1322cb8a054bSGlenn Faden "compare with the previous settings.")); 1323cb8a054bSGlenn Faden need_to_commit = B_TRUE; 1324cb8a054bSGlenn Faden } else if (err != Z_NO_ENTRY) { 1325cb8a054bSGlenn Faden zerr(gettext("failed to update " 1326cb8a054bSGlenn Faden "admin rights.")); 1327cb8a054bSGlenn Faden exit(Z_ERR); 1328cb8a054bSGlenn Faden } else if (need_to_commit) { 1329cb8a054bSGlenn Faden zerr(gettext("admin rights were updated " 1330cb8a054bSGlenn Faden "to match RBAC configuration.")); 1331cb8a054bSGlenn Faden } 1332cb8a054bSGlenn Faden 13330209230bSgjelinek } else if (global_zone && err == Z_NO_ZONE && !got_handle && 13340209230bSgjelinek !read_only_mode) { 13350209230bSgjelinek /* 13360209230bSgjelinek * We implicitly create the global zone config if it 13370209230bSgjelinek * doesn't exist. 13380209230bSgjelinek */ 13390209230bSgjelinek zone_dochandle_t tmphandle; 13400209230bSgjelinek 13410209230bSgjelinek if ((tmphandle = zonecfg_init_handle()) == NULL) { 1342bbec428eSgjelinek zone_perror(execname, Z_NOMEM, B_TRUE); 13430209230bSgjelinek exit(Z_ERR); 13440209230bSgjelinek } 13450209230bSgjelinek 13460209230bSgjelinek err = zonecfg_get_template_handle("SUNWblank", zone, 13470209230bSgjelinek tmphandle); 13480209230bSgjelinek 13490209230bSgjelinek if (err != Z_OK) { 13500209230bSgjelinek zonecfg_fini_handle(tmphandle); 1351bbec428eSgjelinek zone_perror("SUNWblank", err, B_TRUE); 13520209230bSgjelinek return (err); 13530209230bSgjelinek } 13540209230bSgjelinek 1355bbec428eSgjelinek need_to_commit = B_TRUE; 13560209230bSgjelinek zonecfg_fini_handle(handle); 13570209230bSgjelinek handle = tmphandle; 1358bbec428eSgjelinek got_handle = B_TRUE; 13590209230bSgjelinek 13607c478bd9Sstevel@tonic-gate } else { 13617c478bd9Sstevel@tonic-gate zone_perror(zone, err, handle_expected || got_handle); 13627c478bd9Sstevel@tonic-gate if (err == Z_NO_ZONE && !got_handle && 13637c478bd9Sstevel@tonic-gate interactive_mode && !read_only_mode) 13647c478bd9Sstevel@tonic-gate (void) printf(gettext("Use '%s' to begin " 13657c478bd9Sstevel@tonic-gate "configuring a new zone.\n"), 13667c478bd9Sstevel@tonic-gate cmd_to_str(CMD_CREATE)); 13677c478bd9Sstevel@tonic-gate return (err); 13687c478bd9Sstevel@tonic-gate } 13697c478bd9Sstevel@tonic-gate } 13707c478bd9Sstevel@tonic-gate return (Z_OK); 13717c478bd9Sstevel@tonic-gate } 13727c478bd9Sstevel@tonic-gate 1373bbec428eSgjelinek static boolean_t 1374087719fdSdp state_atleast(zone_state_t state) 1375087719fdSdp { 1376087719fdSdp zone_state_t state_num; 1377087719fdSdp int err; 1378087719fdSdp 1379087719fdSdp if ((err = zone_get_state(zone, &state_num)) != Z_OK) { 1380087719fdSdp /* all states are greater than "non-existent" */ 1381087719fdSdp if (err == Z_NO_ZONE) 1382087719fdSdp return (B_FALSE); 1383087719fdSdp zerr(gettext("Unexpectedly failed to determine state " 1384087719fdSdp "of zone %s: %s"), zone, zonecfg_strerror(err)); 1385087719fdSdp exit(Z_ERR); 1386087719fdSdp } 1387087719fdSdp return (state_num >= state); 1388087719fdSdp } 1389087719fdSdp 13907c478bd9Sstevel@tonic-gate /* 13917c478bd9Sstevel@tonic-gate * short_usage() is for bad syntax: getopt() issues, too many arguments, etc. 13927c478bd9Sstevel@tonic-gate */ 13937c478bd9Sstevel@tonic-gate 13947c478bd9Sstevel@tonic-gate void 13957c478bd9Sstevel@tonic-gate short_usage(int command) 13967c478bd9Sstevel@tonic-gate { 13977c478bd9Sstevel@tonic-gate /* lex_lineno has already been incremented in the lexer; compensate */ 13987c478bd9Sstevel@tonic-gate if (cmd_file_mode) { 13997c478bd9Sstevel@tonic-gate if (strcmp(cmd_file_name, "-") == 0) 14007c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 14017c478bd9Sstevel@tonic-gate gettext("syntax error on line %d\n"), 14027c478bd9Sstevel@tonic-gate lex_lineno - 1); 14037c478bd9Sstevel@tonic-gate else 14047c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 14057c478bd9Sstevel@tonic-gate gettext("syntax error on line %d of %s\n"), 14067c478bd9Sstevel@tonic-gate lex_lineno - 1, cmd_file_name); 14077c478bd9Sstevel@tonic-gate } 14087c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "%s:\n%s\n", gettext("usage"), 14097c478bd9Sstevel@tonic-gate helptab[command].short_usage); 1410bbec428eSgjelinek saw_error = B_TRUE; 14117c478bd9Sstevel@tonic-gate } 14127c478bd9Sstevel@tonic-gate 14137c478bd9Sstevel@tonic-gate /* 14147c478bd9Sstevel@tonic-gate * long_usage() is for bad semantics: e.g., wrong property type for a given 14157c478bd9Sstevel@tonic-gate * resource type. It is also used by longer_usage() below. 14167c478bd9Sstevel@tonic-gate */ 14177c478bd9Sstevel@tonic-gate 14187c478bd9Sstevel@tonic-gate void 1419bbec428eSgjelinek long_usage(uint_t cmd_num, boolean_t set_saw) 14207c478bd9Sstevel@tonic-gate { 14217c478bd9Sstevel@tonic-gate (void) fprintf(set_saw ? stderr : stdout, "%s:\n%s\n", gettext("usage"), 14227c478bd9Sstevel@tonic-gate helptab[cmd_num].short_usage); 14237c478bd9Sstevel@tonic-gate (void) fprintf(set_saw ? stderr : stdout, "\t%s\n", long_help(cmd_num)); 14247c478bd9Sstevel@tonic-gate if (set_saw) 1425bbec428eSgjelinek saw_error = B_TRUE; 14267c478bd9Sstevel@tonic-gate } 14277c478bd9Sstevel@tonic-gate 14287c478bd9Sstevel@tonic-gate /* 14297c478bd9Sstevel@tonic-gate * longer_usage() is for 'help foo' and 'foo -?': call long_usage() and also 14307c478bd9Sstevel@tonic-gate * any extra usage() flags as appropriate for whatever command. 14317c478bd9Sstevel@tonic-gate */ 14327c478bd9Sstevel@tonic-gate 14337c478bd9Sstevel@tonic-gate void 14347c478bd9Sstevel@tonic-gate longer_usage(uint_t cmd_num) 14357c478bd9Sstevel@tonic-gate { 1436bbec428eSgjelinek long_usage(cmd_num, B_FALSE); 14377c478bd9Sstevel@tonic-gate if (helptab[cmd_num].flags != 0) { 14387c478bd9Sstevel@tonic-gate (void) printf("\n"); 1439bbec428eSgjelinek usage(B_TRUE, helptab[cmd_num].flags); 14407c478bd9Sstevel@tonic-gate } 14417c478bd9Sstevel@tonic-gate } 14427c478bd9Sstevel@tonic-gate 14437c478bd9Sstevel@tonic-gate /* 14447c478bd9Sstevel@tonic-gate * scope_usage() is simply used when a command is called from the wrong scope. 14457c478bd9Sstevel@tonic-gate */ 14467c478bd9Sstevel@tonic-gate 14477c478bd9Sstevel@tonic-gate static void 14487c478bd9Sstevel@tonic-gate scope_usage(uint_t cmd_num) 14497c478bd9Sstevel@tonic-gate { 14507c478bd9Sstevel@tonic-gate zerr(gettext("The %s command only makes sense in the %s scope."), 14517c478bd9Sstevel@tonic-gate cmd_to_str(cmd_num), 14527c478bd9Sstevel@tonic-gate global_scope ? gettext("resource") : gettext("global")); 1453bbec428eSgjelinek saw_error = B_TRUE; 14547c478bd9Sstevel@tonic-gate } 14557c478bd9Sstevel@tonic-gate 14567c478bd9Sstevel@tonic-gate /* 1457bbec428eSgjelinek * On input, B_TRUE => yes, B_FALSE => no. 1458bbec428eSgjelinek * On return, B_TRUE => 1, B_FALSE => no, could not ask => -1. 14597c478bd9Sstevel@tonic-gate */ 14607c478bd9Sstevel@tonic-gate 14617c478bd9Sstevel@tonic-gate static int 1462bbec428eSgjelinek ask_yesno(boolean_t default_answer, const char *question) 14637c478bd9Sstevel@tonic-gate { 14647c478bd9Sstevel@tonic-gate char line[64]; /* should be enough to answer yes or no */ 14657c478bd9Sstevel@tonic-gate 14667c478bd9Sstevel@tonic-gate if (!ok_to_prompt) { 1467bbec428eSgjelinek saw_error = B_TRUE; 14687c478bd9Sstevel@tonic-gate return (-1); 14697c478bd9Sstevel@tonic-gate } 14707c478bd9Sstevel@tonic-gate for (;;) { 1471087719fdSdp if (printf("%s (%s)? ", question, 1472087719fdSdp default_answer ? "[y]/n" : "y/[n]") < 0) 1473087719fdSdp return (-1); 1474087719fdSdp if (fgets(line, sizeof (line), stdin) == NULL) 1475087719fdSdp return (-1); 1476087719fdSdp 1477087719fdSdp if (line[0] == '\n') 14787c478bd9Sstevel@tonic-gate return (default_answer ? 1 : 0); 14797c478bd9Sstevel@tonic-gate if (tolower(line[0]) == 'y') 14807c478bd9Sstevel@tonic-gate return (1); 14817c478bd9Sstevel@tonic-gate if (tolower(line[0]) == 'n') 14827c478bd9Sstevel@tonic-gate return (0); 14837c478bd9Sstevel@tonic-gate } 14847c478bd9Sstevel@tonic-gate } 14857c478bd9Sstevel@tonic-gate 14867c478bd9Sstevel@tonic-gate /* 14877c478bd9Sstevel@tonic-gate * Prints warning if zone already exists. 14887c478bd9Sstevel@tonic-gate * In interactive mode, prompts if we should continue anyway and returns Z_OK 14897c478bd9Sstevel@tonic-gate * if so, Z_ERR if not. In non-interactive mode, exits with Z_ERR. 14907c478bd9Sstevel@tonic-gate * 14917c478bd9Sstevel@tonic-gate * Note that if a zone exists and its state is >= INSTALLED, an error message 14927c478bd9Sstevel@tonic-gate * will be printed and this function will return Z_ERR regardless of mode. 14937c478bd9Sstevel@tonic-gate */ 14947c478bd9Sstevel@tonic-gate 14957c478bd9Sstevel@tonic-gate static int 1496bbec428eSgjelinek check_if_zone_already_exists(boolean_t force) 14977c478bd9Sstevel@tonic-gate { 14987c478bd9Sstevel@tonic-gate char line[ZONENAME_MAX + 128]; /* enough to ask a question */ 14997c478bd9Sstevel@tonic-gate zone_dochandle_t tmphandle; 15007c478bd9Sstevel@tonic-gate int res, answer; 15017c478bd9Sstevel@tonic-gate 15027c478bd9Sstevel@tonic-gate if ((tmphandle = zonecfg_init_handle()) == NULL) { 1503bbec428eSgjelinek zone_perror(execname, Z_NOMEM, B_TRUE); 15047c478bd9Sstevel@tonic-gate exit(Z_ERR); 15057c478bd9Sstevel@tonic-gate } 15067c478bd9Sstevel@tonic-gate res = zonecfg_get_handle(zone, tmphandle); 15077c478bd9Sstevel@tonic-gate zonecfg_fini_handle(tmphandle); 1508087719fdSdp if (res != Z_OK) 15097c478bd9Sstevel@tonic-gate return (Z_OK); 1510087719fdSdp 1511087719fdSdp if (state_atleast(ZONE_STATE_INSTALLED)) { 15127c478bd9Sstevel@tonic-gate zerr(gettext("Zone %s already installed; %s not allowed."), 15137c478bd9Sstevel@tonic-gate zone, cmd_to_str(CMD_CREATE)); 15147c478bd9Sstevel@tonic-gate return (Z_ERR); 15157c478bd9Sstevel@tonic-gate } 15167c478bd9Sstevel@tonic-gate 15177c478bd9Sstevel@tonic-gate if (force) { 15187c478bd9Sstevel@tonic-gate (void) printf(gettext("Zone %s already exists; overwriting.\n"), 15197c478bd9Sstevel@tonic-gate zone); 15207c478bd9Sstevel@tonic-gate return (Z_OK); 15217c478bd9Sstevel@tonic-gate } 15227c478bd9Sstevel@tonic-gate (void) snprintf(line, sizeof (line), 15237c478bd9Sstevel@tonic-gate gettext("Zone %s already exists; %s anyway"), zone, 15247c478bd9Sstevel@tonic-gate cmd_to_str(CMD_CREATE)); 1525bbec428eSgjelinek if ((answer = ask_yesno(B_FALSE, line)) == -1) { 15267c478bd9Sstevel@tonic-gate zerr(gettext("Zone exists, input not from terminal and -F not " 15277c478bd9Sstevel@tonic-gate "specified:\n%s command ignored, exiting."), 15287c478bd9Sstevel@tonic-gate cmd_to_str(CMD_CREATE)); 15297c478bd9Sstevel@tonic-gate exit(Z_ERR); 15307c478bd9Sstevel@tonic-gate } 15317c478bd9Sstevel@tonic-gate return (answer == 1 ? Z_OK : Z_ERR); 15327c478bd9Sstevel@tonic-gate } 15337c478bd9Sstevel@tonic-gate 1534bbec428eSgjelinek static boolean_t 15357c478bd9Sstevel@tonic-gate zone_is_read_only(int cmd_num) 15367c478bd9Sstevel@tonic-gate { 15377c478bd9Sstevel@tonic-gate if (strncmp(zone, "SUNW", 4) == 0) { 15387c478bd9Sstevel@tonic-gate zerr(gettext("%s: zones beginning with SUNW are read-only."), 15397c478bd9Sstevel@tonic-gate zone); 1540bbec428eSgjelinek saw_error = B_TRUE; 1541bbec428eSgjelinek return (B_TRUE); 15427c478bd9Sstevel@tonic-gate } 15437c478bd9Sstevel@tonic-gate if (read_only_mode) { 15447c478bd9Sstevel@tonic-gate zerr(gettext("%s: cannot %s in read-only mode."), zone, 15457c478bd9Sstevel@tonic-gate cmd_to_str(cmd_num)); 1546bbec428eSgjelinek saw_error = B_TRUE; 1547bbec428eSgjelinek return (B_TRUE); 15487c478bd9Sstevel@tonic-gate } 1549bbec428eSgjelinek return (B_FALSE); 15507c478bd9Sstevel@tonic-gate } 15517c478bd9Sstevel@tonic-gate 15527c478bd9Sstevel@tonic-gate /* 15537c478bd9Sstevel@tonic-gate * Create a new configuration. 15547c478bd9Sstevel@tonic-gate */ 15557c478bd9Sstevel@tonic-gate void 15567c478bd9Sstevel@tonic-gate create_func(cmd_t *cmd) 15577c478bd9Sstevel@tonic-gate { 15587c478bd9Sstevel@tonic-gate int err, arg; 15597c478bd9Sstevel@tonic-gate char zone_template[ZONENAME_MAX]; 1560ee519a1fSgjelinek char attach_path[MAXPATHLEN]; 15617c478bd9Sstevel@tonic-gate zone_dochandle_t tmphandle; 1562bbec428eSgjelinek boolean_t force = B_FALSE; 1563bbec428eSgjelinek boolean_t attach = B_FALSE; 1564bbec428eSgjelinek boolean_t arg_err = B_FALSE; 15657c478bd9Sstevel@tonic-gate 15667c478bd9Sstevel@tonic-gate assert(cmd != NULL); 15677c478bd9Sstevel@tonic-gate 15687c478bd9Sstevel@tonic-gate /* This is the default if no arguments are given. */ 15697c478bd9Sstevel@tonic-gate (void) strlcpy(zone_template, "SUNWdefault", sizeof (zone_template)); 15707c478bd9Sstevel@tonic-gate 15717c478bd9Sstevel@tonic-gate optind = 0; 15729acbbeafSnn35248 while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?a:bFt:")) 15739acbbeafSnn35248 != EOF) { 15747c478bd9Sstevel@tonic-gate switch (arg) { 15757c478bd9Sstevel@tonic-gate case '?': 15767c478bd9Sstevel@tonic-gate if (optopt == '?') 15777c478bd9Sstevel@tonic-gate longer_usage(CMD_CREATE); 15787c478bd9Sstevel@tonic-gate else 15797c478bd9Sstevel@tonic-gate short_usage(CMD_CREATE); 1580bbec428eSgjelinek arg_err = B_TRUE; 15817ec75eb8Sgjelinek break; 1582ee519a1fSgjelinek case 'a': 1583ee519a1fSgjelinek (void) strlcpy(attach_path, optarg, 1584ee519a1fSgjelinek sizeof (attach_path)); 1585bbec428eSgjelinek attach = B_TRUE; 1586ee519a1fSgjelinek break; 15877c478bd9Sstevel@tonic-gate case 'b': 15887c478bd9Sstevel@tonic-gate (void) strlcpy(zone_template, "SUNWblank", 15897c478bd9Sstevel@tonic-gate sizeof (zone_template)); 15907c478bd9Sstevel@tonic-gate break; 15917c478bd9Sstevel@tonic-gate case 'F': 1592bbec428eSgjelinek force = B_TRUE; 15937c478bd9Sstevel@tonic-gate break; 15947c478bd9Sstevel@tonic-gate case 't': 15957c478bd9Sstevel@tonic-gate (void) strlcpy(zone_template, optarg, 15967c478bd9Sstevel@tonic-gate sizeof (zone_template)); 15977c478bd9Sstevel@tonic-gate break; 15987c478bd9Sstevel@tonic-gate default: 15997c478bd9Sstevel@tonic-gate short_usage(CMD_CREATE); 1600bbec428eSgjelinek arg_err = B_TRUE; 16017ec75eb8Sgjelinek break; 16027ec75eb8Sgjelinek } 16037ec75eb8Sgjelinek } 16047ec75eb8Sgjelinek if (arg_err) 16057c478bd9Sstevel@tonic-gate return; 16067ec75eb8Sgjelinek 16077c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 16087c478bd9Sstevel@tonic-gate short_usage(CMD_CREATE); 16097c478bd9Sstevel@tonic-gate return; 16107c478bd9Sstevel@tonic-gate } 16117c478bd9Sstevel@tonic-gate 16127c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_CREATE)) 16137c478bd9Sstevel@tonic-gate return; 16147c478bd9Sstevel@tonic-gate 16157c478bd9Sstevel@tonic-gate if (check_if_zone_already_exists(force) != Z_OK) 16167c478bd9Sstevel@tonic-gate return; 16177c478bd9Sstevel@tonic-gate 16187c478bd9Sstevel@tonic-gate /* 16197c478bd9Sstevel@tonic-gate * Get a temporary handle first. If that fails, the old handle 16207c478bd9Sstevel@tonic-gate * will not be lost. Then finish whichever one we don't need, 16217c478bd9Sstevel@tonic-gate * to avoid leaks. Then get the handle for zone_template, and 16227c478bd9Sstevel@tonic-gate * set the name to zone: this "copy, rename" method is how 16237c478bd9Sstevel@tonic-gate * create -[b|t] works. 16247c478bd9Sstevel@tonic-gate */ 16257c478bd9Sstevel@tonic-gate if ((tmphandle = zonecfg_init_handle()) == NULL) { 1626bbec428eSgjelinek zone_perror(execname, Z_NOMEM, B_TRUE); 16277c478bd9Sstevel@tonic-gate exit(Z_ERR); 16287c478bd9Sstevel@tonic-gate } 1629ee519a1fSgjelinek 1630ee519a1fSgjelinek if (attach) 163116ab8c7bSgjelinek err = zonecfg_get_attach_handle(attach_path, ZONE_DETACHED, 163216ab8c7bSgjelinek zone, B_FALSE, tmphandle); 1633ee519a1fSgjelinek else 1634ee519a1fSgjelinek err = zonecfg_get_template_handle(zone_template, zone, 1635ee519a1fSgjelinek tmphandle); 1636ee519a1fSgjelinek 1637ee519a1fSgjelinek if (err != Z_OK) { 16387c478bd9Sstevel@tonic-gate zonecfg_fini_handle(tmphandle); 1639ee519a1fSgjelinek if (attach && err == Z_NO_ZONE) 1640ee519a1fSgjelinek (void) fprintf(stderr, gettext("invalid path to " 1641ee519a1fSgjelinek "detached zone\n")); 1642ee519a1fSgjelinek else if (attach && err == Z_INVALID_DOCUMENT) 1643ee519a1fSgjelinek (void) fprintf(stderr, gettext("Cannot attach to an " 1644ee519a1fSgjelinek "earlier release of the operating system\n")); 1645ee519a1fSgjelinek else 1646bbec428eSgjelinek zone_perror(zone_template, err, B_TRUE); 16477c478bd9Sstevel@tonic-gate return; 16487c478bd9Sstevel@tonic-gate } 1649087719fdSdp 1650bbec428eSgjelinek need_to_commit = B_TRUE; 16517c478bd9Sstevel@tonic-gate zonecfg_fini_handle(handle); 16527c478bd9Sstevel@tonic-gate handle = tmphandle; 1653bbec428eSgjelinek got_handle = B_TRUE; 16547c478bd9Sstevel@tonic-gate } 16557c478bd9Sstevel@tonic-gate 16567c478bd9Sstevel@tonic-gate /* 16577c478bd9Sstevel@tonic-gate * This malloc()'s memory, which must be freed by the caller. 16587c478bd9Sstevel@tonic-gate */ 16597c478bd9Sstevel@tonic-gate static char * 16607c478bd9Sstevel@tonic-gate quoteit(char *instr) 16617c478bd9Sstevel@tonic-gate { 16627c478bd9Sstevel@tonic-gate char *outstr; 16637c478bd9Sstevel@tonic-gate size_t outstrsize = strlen(instr) + 3; /* 2 quotes + '\0' */ 16647c478bd9Sstevel@tonic-gate 16657c478bd9Sstevel@tonic-gate if ((outstr = malloc(outstrsize)) == NULL) { 1666bbec428eSgjelinek zone_perror(zone, Z_NOMEM, B_FALSE); 16677c478bd9Sstevel@tonic-gate exit(Z_ERR); 16687c478bd9Sstevel@tonic-gate } 16697c478bd9Sstevel@tonic-gate if (strchr(instr, ' ') == NULL) { 16707c478bd9Sstevel@tonic-gate (void) strlcpy(outstr, instr, outstrsize); 16717c478bd9Sstevel@tonic-gate return (outstr); 16727c478bd9Sstevel@tonic-gate } 16737c478bd9Sstevel@tonic-gate (void) snprintf(outstr, outstrsize, "\"%s\"", instr); 16747c478bd9Sstevel@tonic-gate return (outstr); 16757c478bd9Sstevel@tonic-gate } 16767c478bd9Sstevel@tonic-gate 16777c478bd9Sstevel@tonic-gate static void 16787c478bd9Sstevel@tonic-gate export_prop(FILE *of, int prop_num, char *prop_id) 16797c478bd9Sstevel@tonic-gate { 16807c478bd9Sstevel@tonic-gate char *quote_str; 16817c478bd9Sstevel@tonic-gate 16827c478bd9Sstevel@tonic-gate if (strlen(prop_id) == 0) 16837c478bd9Sstevel@tonic-gate return; 16847c478bd9Sstevel@tonic-gate quote_str = quoteit(prop_id); 16857c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 16867c478bd9Sstevel@tonic-gate pt_to_str(prop_num), quote_str); 16877c478bd9Sstevel@tonic-gate free(quote_str); 16887c478bd9Sstevel@tonic-gate } 16897c478bd9Sstevel@tonic-gate 16907c478bd9Sstevel@tonic-gate void 16917c478bd9Sstevel@tonic-gate export_func(cmd_t *cmd) 16927c478bd9Sstevel@tonic-gate { 16937c478bd9Sstevel@tonic-gate struct zone_nwiftab nwiftab; 16947c478bd9Sstevel@tonic-gate struct zone_fstab fstab; 16957c478bd9Sstevel@tonic-gate struct zone_devtab devtab; 16967c478bd9Sstevel@tonic-gate struct zone_attrtab attrtab; 16977c478bd9Sstevel@tonic-gate struct zone_rctltab rctltab; 1698fa9e4066Sahrens struct zone_dstab dstab; 16990209230bSgjelinek struct zone_psettab psettab; 17000209230bSgjelinek struct zone_mcaptab mcaptab; 17017c478bd9Sstevel@tonic-gate struct zone_rctlvaltab *valptr; 1702cb8a054bSGlenn Faden struct zone_admintab admintab; 17037c478bd9Sstevel@tonic-gate int err, arg; 17047c478bd9Sstevel@tonic-gate char zonepath[MAXPATHLEN], outfile[MAXPATHLEN], pool[MAXNAMELEN]; 17053f2f09c1Sdp char bootargs[BOOTARGS_MAX]; 17060209230bSgjelinek char sched[MAXNAMELEN]; 17079acbbeafSnn35248 char brand[MAXNAMELEN]; 17085679c89fSjv227347 char hostidp[HW_HOSTID_LEN]; 1709ffbafc53Scomay char *limitpriv; 17107c478bd9Sstevel@tonic-gate FILE *of; 17117c478bd9Sstevel@tonic-gate boolean_t autoboot; 1712f4b3ec61Sdh155122 zone_iptype_t iptype; 1713bbec428eSgjelinek boolean_t need_to_close = B_FALSE; 1714bbec428eSgjelinek boolean_t arg_err = B_FALSE; 17157c478bd9Sstevel@tonic-gate 17167c478bd9Sstevel@tonic-gate assert(cmd != NULL); 17177c478bd9Sstevel@tonic-gate 17187c478bd9Sstevel@tonic-gate outfile[0] = '\0'; 17197c478bd9Sstevel@tonic-gate optind = 0; 17207c478bd9Sstevel@tonic-gate while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?f:")) != EOF) { 17217c478bd9Sstevel@tonic-gate switch (arg) { 17227c478bd9Sstevel@tonic-gate case '?': 17237c478bd9Sstevel@tonic-gate if (optopt == '?') 17247c478bd9Sstevel@tonic-gate longer_usage(CMD_EXPORT); 17257c478bd9Sstevel@tonic-gate else 17267c478bd9Sstevel@tonic-gate short_usage(CMD_EXPORT); 1727bbec428eSgjelinek arg_err = B_TRUE; 17287ec75eb8Sgjelinek break; 17297c478bd9Sstevel@tonic-gate case 'f': 17307c478bd9Sstevel@tonic-gate (void) strlcpy(outfile, optarg, sizeof (outfile)); 17317c478bd9Sstevel@tonic-gate break; 17327c478bd9Sstevel@tonic-gate default: 17337c478bd9Sstevel@tonic-gate short_usage(CMD_EXPORT); 1734bbec428eSgjelinek arg_err = B_TRUE; 17357ec75eb8Sgjelinek break; 17367ec75eb8Sgjelinek } 17377ec75eb8Sgjelinek } 17387ec75eb8Sgjelinek if (arg_err) 17397c478bd9Sstevel@tonic-gate return; 17407ec75eb8Sgjelinek 17417c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 17427c478bd9Sstevel@tonic-gate short_usage(CMD_EXPORT); 17437c478bd9Sstevel@tonic-gate return; 17447c478bd9Sstevel@tonic-gate } 17457c478bd9Sstevel@tonic-gate if (strlen(outfile) == 0) { 17467c478bd9Sstevel@tonic-gate of = stdout; 17477c478bd9Sstevel@tonic-gate } else { 17487c478bd9Sstevel@tonic-gate if ((of = fopen(outfile, "w")) == NULL) { 17497c478bd9Sstevel@tonic-gate zerr(gettext("opening file %s: %s"), 17507c478bd9Sstevel@tonic-gate outfile, strerror(errno)); 17517c478bd9Sstevel@tonic-gate goto done; 17527c478bd9Sstevel@tonic-gate } 17537c478bd9Sstevel@tonic-gate setbuf(of, NULL); 1754bbec428eSgjelinek need_to_close = B_TRUE; 17557c478bd9Sstevel@tonic-gate } 17567c478bd9Sstevel@tonic-gate 1757bbec428eSgjelinek if ((err = initialize(B_TRUE)) != Z_OK) 17587c478bd9Sstevel@tonic-gate goto done; 17597c478bd9Sstevel@tonic-gate 17607c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s -b\n", cmd_to_str(CMD_CREATE)); 17617c478bd9Sstevel@tonic-gate 17627c478bd9Sstevel@tonic-gate if (zonecfg_get_zonepath(handle, zonepath, sizeof (zonepath)) == Z_OK && 17637c478bd9Sstevel@tonic-gate strlen(zonepath) > 0) 17647c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 17657c478bd9Sstevel@tonic-gate pt_to_str(PT_ZONEPATH), zonepath); 17667c478bd9Sstevel@tonic-gate 17679acbbeafSnn35248 if ((zone_get_brand(zone, brand, sizeof (brand)) == Z_OK) && 17689acbbeafSnn35248 (strcmp(brand, NATIVE_BRAND_NAME) != 0)) 17699acbbeafSnn35248 (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 17709acbbeafSnn35248 pt_to_str(PT_BRAND), brand); 17719acbbeafSnn35248 17727c478bd9Sstevel@tonic-gate if (zonecfg_get_autoboot(handle, &autoboot) == Z_OK) 17737c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 17747c478bd9Sstevel@tonic-gate pt_to_str(PT_AUTOBOOT), autoboot ? "true" : "false"); 17757c478bd9Sstevel@tonic-gate 17763f2f09c1Sdp if (zonecfg_get_bootargs(handle, bootargs, sizeof (bootargs)) == Z_OK && 17773f2f09c1Sdp strlen(bootargs) > 0) { 17783f2f09c1Sdp (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 17793f2f09c1Sdp pt_to_str(PT_BOOTARGS), bootargs); 17803f2f09c1Sdp } 17813f2f09c1Sdp 17827c478bd9Sstevel@tonic-gate if (zonecfg_get_pool(handle, pool, sizeof (pool)) == Z_OK && 17837c478bd9Sstevel@tonic-gate strlen(pool) > 0) 17847c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 17857c478bd9Sstevel@tonic-gate pt_to_str(PT_POOL), pool); 17867c478bd9Sstevel@tonic-gate 1787ffbafc53Scomay if (zonecfg_get_limitpriv(handle, &limitpriv) == Z_OK && 1788ffbafc53Scomay strlen(limitpriv) > 0) { 1789ffbafc53Scomay (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 1790ffbafc53Scomay pt_to_str(PT_LIMITPRIV), limitpriv); 1791ffbafc53Scomay free(limitpriv); 1792ffbafc53Scomay } 1793ffbafc53Scomay 17940209230bSgjelinek if (zonecfg_get_sched_class(handle, sched, sizeof (sched)) == Z_OK && 17950209230bSgjelinek strlen(sched) > 0) 17960209230bSgjelinek (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 17970209230bSgjelinek pt_to_str(PT_SCHED), sched); 17983f2f09c1Sdp 1799f4b3ec61Sdh155122 if (zonecfg_get_iptype(handle, &iptype) == Z_OK) { 1800f4b3ec61Sdh155122 switch (iptype) { 1801f4b3ec61Sdh155122 case ZS_SHARED: 1802f4b3ec61Sdh155122 (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 1803f4b3ec61Sdh155122 pt_to_str(PT_IPTYPE), "shared"); 1804f4b3ec61Sdh155122 break; 1805f4b3ec61Sdh155122 case ZS_EXCLUSIVE: 1806f4b3ec61Sdh155122 (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 1807f4b3ec61Sdh155122 pt_to_str(PT_IPTYPE), "exclusive"); 1808f4b3ec61Sdh155122 break; 1809f4b3ec61Sdh155122 } 1810f4b3ec61Sdh155122 } 1811f4b3ec61Sdh155122 18125679c89fSjv227347 if (zonecfg_get_hostid(handle, hostidp, sizeof (hostidp)) == Z_OK) { 18135679c89fSjv227347 (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 18145679c89fSjv227347 pt_to_str(PT_HOSTID), hostidp); 18155679c89fSjv227347 } 18165679c89fSjv227347 18177c478bd9Sstevel@tonic-gate if ((err = zonecfg_setipdent(handle)) != Z_OK) { 1818bbec428eSgjelinek zone_perror(zone, err, B_FALSE); 18197c478bd9Sstevel@tonic-gate goto done; 18207c478bd9Sstevel@tonic-gate } 18217c478bd9Sstevel@tonic-gate while (zonecfg_getipdent(handle, &fstab) == Z_OK) { 18227c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 18237c478bd9Sstevel@tonic-gate rt_to_str(RT_IPD)); 18247c478bd9Sstevel@tonic-gate export_prop(of, PT_DIR, fstab.zone_fs_dir); 18257c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 18267c478bd9Sstevel@tonic-gate } 18277c478bd9Sstevel@tonic-gate (void) zonecfg_endipdent(handle); 18287c478bd9Sstevel@tonic-gate 18297c478bd9Sstevel@tonic-gate if ((err = zonecfg_setfsent(handle)) != Z_OK) { 1830bbec428eSgjelinek zone_perror(zone, err, B_FALSE); 18317c478bd9Sstevel@tonic-gate goto done; 18327c478bd9Sstevel@tonic-gate } 18337c478bd9Sstevel@tonic-gate while (zonecfg_getfsent(handle, &fstab) == Z_OK) { 18347c478bd9Sstevel@tonic-gate zone_fsopt_t *optptr; 18357c478bd9Sstevel@tonic-gate 18367c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 18377c478bd9Sstevel@tonic-gate rt_to_str(RT_FS)); 18387c478bd9Sstevel@tonic-gate export_prop(of, PT_DIR, fstab.zone_fs_dir); 18397c478bd9Sstevel@tonic-gate export_prop(of, PT_SPECIAL, fstab.zone_fs_special); 18407c478bd9Sstevel@tonic-gate export_prop(of, PT_RAW, fstab.zone_fs_raw); 18417c478bd9Sstevel@tonic-gate export_prop(of, PT_TYPE, fstab.zone_fs_type); 18427c478bd9Sstevel@tonic-gate for (optptr = fstab.zone_fs_options; optptr != NULL; 18437c478bd9Sstevel@tonic-gate optptr = optptr->zone_fsopt_next) { 18447c478bd9Sstevel@tonic-gate /* 18457c478bd9Sstevel@tonic-gate * Simple property values with embedded equal signs 18467c478bd9Sstevel@tonic-gate * need to be quoted to prevent the lexer from 18477c478bd9Sstevel@tonic-gate * mis-parsing them as complex name=value pairs. 18487c478bd9Sstevel@tonic-gate */ 18497c478bd9Sstevel@tonic-gate if (strchr(optptr->zone_fsopt_opt, '=')) 18507c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s \"%s\"\n", 18517c478bd9Sstevel@tonic-gate cmd_to_str(CMD_ADD), 18527c478bd9Sstevel@tonic-gate pt_to_str(PT_OPTIONS), 18537c478bd9Sstevel@tonic-gate optptr->zone_fsopt_opt); 18547c478bd9Sstevel@tonic-gate else 18557c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s %s\n", 18567c478bd9Sstevel@tonic-gate cmd_to_str(CMD_ADD), 18577c478bd9Sstevel@tonic-gate pt_to_str(PT_OPTIONS), 18587c478bd9Sstevel@tonic-gate optptr->zone_fsopt_opt); 18597c478bd9Sstevel@tonic-gate } 18607c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 18617c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(fstab.zone_fs_options); 18627c478bd9Sstevel@tonic-gate } 18637c478bd9Sstevel@tonic-gate (void) zonecfg_endfsent(handle); 18647c478bd9Sstevel@tonic-gate 18657c478bd9Sstevel@tonic-gate if ((err = zonecfg_setnwifent(handle)) != Z_OK) { 1866bbec428eSgjelinek zone_perror(zone, err, B_FALSE); 18677c478bd9Sstevel@tonic-gate goto done; 18687c478bd9Sstevel@tonic-gate } 18697c478bd9Sstevel@tonic-gate while (zonecfg_getnwifent(handle, &nwiftab) == Z_OK) { 18707c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 18717c478bd9Sstevel@tonic-gate rt_to_str(RT_NET)); 18727c478bd9Sstevel@tonic-gate export_prop(of, PT_ADDRESS, nwiftab.zone_nwif_address); 18737c478bd9Sstevel@tonic-gate export_prop(of, PT_PHYSICAL, nwiftab.zone_nwif_physical); 1874de860bd9Sgfaden export_prop(of, PT_DEFROUTER, nwiftab.zone_nwif_defrouter); 18757c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 18767c478bd9Sstevel@tonic-gate } 18777c478bd9Sstevel@tonic-gate (void) zonecfg_endnwifent(handle); 18787c478bd9Sstevel@tonic-gate 18797c478bd9Sstevel@tonic-gate if ((err = zonecfg_setdevent(handle)) != Z_OK) { 1880bbec428eSgjelinek zone_perror(zone, err, B_FALSE); 18817c478bd9Sstevel@tonic-gate goto done; 18827c478bd9Sstevel@tonic-gate } 18837c478bd9Sstevel@tonic-gate while (zonecfg_getdevent(handle, &devtab) == Z_OK) { 18847c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 18857c478bd9Sstevel@tonic-gate rt_to_str(RT_DEVICE)); 18867c478bd9Sstevel@tonic-gate export_prop(of, PT_MATCH, devtab.zone_dev_match); 18877c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 18887c478bd9Sstevel@tonic-gate } 18897c478bd9Sstevel@tonic-gate (void) zonecfg_enddevent(handle); 18907c478bd9Sstevel@tonic-gate 1891*1b3281c0SGerald Jelinek if (zonecfg_getmcapent(handle, &mcaptab) == Z_OK) { 1892*1b3281c0SGerald Jelinek char buf[128]; 1893*1b3281c0SGerald Jelinek 1894*1b3281c0SGerald Jelinek (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 1895*1b3281c0SGerald Jelinek rt_to_str(RT_MCAP)); 1896*1b3281c0SGerald Jelinek bytes_to_units(mcaptab.zone_physmem_cap, buf, sizeof (buf)); 1897*1b3281c0SGerald Jelinek (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 1898*1b3281c0SGerald Jelinek pt_to_str(PT_PHYSICAL), buf); 1899*1b3281c0SGerald Jelinek (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 1900*1b3281c0SGerald Jelinek } 1901*1b3281c0SGerald Jelinek 19027c478bd9Sstevel@tonic-gate if ((err = zonecfg_setrctlent(handle)) != Z_OK) { 1903bbec428eSgjelinek zone_perror(zone, err, B_FALSE); 19047c478bd9Sstevel@tonic-gate goto done; 19057c478bd9Sstevel@tonic-gate } 19067c478bd9Sstevel@tonic-gate while (zonecfg_getrctlent(handle, &rctltab) == Z_OK) { 19077c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s rctl\n", cmd_to_str(CMD_ADD)); 19087c478bd9Sstevel@tonic-gate export_prop(of, PT_NAME, rctltab.zone_rctl_name); 19097c478bd9Sstevel@tonic-gate for (valptr = rctltab.zone_rctl_valptr; valptr != NULL; 19107c478bd9Sstevel@tonic-gate valptr = valptr->zone_rctlval_next) { 19117c478bd9Sstevel@tonic-gate fprintf(of, "%s %s (%s=%s,%s=%s,%s=%s)\n", 19127c478bd9Sstevel@tonic-gate cmd_to_str(CMD_ADD), pt_to_str(PT_VALUE), 19137c478bd9Sstevel@tonic-gate pt_to_str(PT_PRIV), valptr->zone_rctlval_priv, 19147c478bd9Sstevel@tonic-gate pt_to_str(PT_LIMIT), valptr->zone_rctlval_limit, 19157c478bd9Sstevel@tonic-gate pt_to_str(PT_ACTION), valptr->zone_rctlval_action); 19167c478bd9Sstevel@tonic-gate } 19177c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 19187c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctltab.zone_rctl_valptr); 19197c478bd9Sstevel@tonic-gate } 19207c478bd9Sstevel@tonic-gate (void) zonecfg_endrctlent(handle); 19217c478bd9Sstevel@tonic-gate 19227c478bd9Sstevel@tonic-gate if ((err = zonecfg_setattrent(handle)) != Z_OK) { 1923bbec428eSgjelinek zone_perror(zone, err, B_FALSE); 19247c478bd9Sstevel@tonic-gate goto done; 19257c478bd9Sstevel@tonic-gate } 19267c478bd9Sstevel@tonic-gate while (zonecfg_getattrent(handle, &attrtab) == Z_OK) { 19277c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 19287c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR)); 19297c478bd9Sstevel@tonic-gate export_prop(of, PT_NAME, attrtab.zone_attr_name); 19307c478bd9Sstevel@tonic-gate export_prop(of, PT_TYPE, attrtab.zone_attr_type); 19317c478bd9Sstevel@tonic-gate export_prop(of, PT_VALUE, attrtab.zone_attr_value); 19327c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 19337c478bd9Sstevel@tonic-gate } 19347c478bd9Sstevel@tonic-gate (void) zonecfg_endattrent(handle); 19357c478bd9Sstevel@tonic-gate 1936fa9e4066Sahrens if ((err = zonecfg_setdsent(handle)) != Z_OK) { 1937bbec428eSgjelinek zone_perror(zone, err, B_FALSE); 1938fa9e4066Sahrens goto done; 1939fa9e4066Sahrens } 1940fa9e4066Sahrens while (zonecfg_getdsent(handle, &dstab) == Z_OK) { 1941fa9e4066Sahrens (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 1942fa9e4066Sahrens rt_to_str(RT_DATASET)); 1943fa9e4066Sahrens export_prop(of, PT_NAME, dstab.zone_dataset_name); 1944fa9e4066Sahrens (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 1945fa9e4066Sahrens } 1946fa9e4066Sahrens (void) zonecfg_enddsent(handle); 1947fa9e4066Sahrens 19480209230bSgjelinek if (zonecfg_getpsetent(handle, &psettab) == Z_OK) { 19490209230bSgjelinek (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 19500209230bSgjelinek rt_to_str(RT_DCPU)); 19510209230bSgjelinek if (strcmp(psettab.zone_ncpu_min, psettab.zone_ncpu_max) == 0) 19520209230bSgjelinek (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 19530209230bSgjelinek pt_to_str(PT_NCPUS), psettab.zone_ncpu_max); 19540209230bSgjelinek else 19550209230bSgjelinek (void) fprintf(of, "%s %s=%s-%s\n", cmd_to_str(CMD_SET), 19560209230bSgjelinek pt_to_str(PT_NCPUS), psettab.zone_ncpu_min, 19570209230bSgjelinek psettab.zone_ncpu_max); 19580209230bSgjelinek if (psettab.zone_importance[0] != '\0') 19590209230bSgjelinek (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 19600209230bSgjelinek pt_to_str(PT_IMPORTANCE), psettab.zone_importance); 19610209230bSgjelinek (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 19620209230bSgjelinek } 19630209230bSgjelinek 1964cb8a054bSGlenn Faden if ((err = zonecfg_setadminent(handle)) != Z_OK) { 1965cb8a054bSGlenn Faden zone_perror(zone, err, B_FALSE); 1966cb8a054bSGlenn Faden goto done; 1967cb8a054bSGlenn Faden } 1968cb8a054bSGlenn Faden while (zonecfg_getadminent(handle, &admintab) == Z_OK) { 1969cb8a054bSGlenn Faden (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 1970cb8a054bSGlenn Faden rt_to_str(RT_ADMIN)); 1971cb8a054bSGlenn Faden export_prop(of, PT_USER, admintab.zone_admin_user); 1972cb8a054bSGlenn Faden export_prop(of, PT_AUTHS, admintab.zone_admin_auths); 1973cb8a054bSGlenn Faden (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 1974cb8a054bSGlenn Faden } 1975cb8a054bSGlenn Faden (void) zonecfg_endadminent(handle); 1976cb8a054bSGlenn Faden 1977c97ad5cdSakolb /* 1978c97ad5cdSakolb * There is nothing to export for pcap since this resource is just 1979c97ad5cdSakolb * a container for an rctl alias. 1980c97ad5cdSakolb */ 1981c97ad5cdSakolb 19827c478bd9Sstevel@tonic-gate done: 19837c478bd9Sstevel@tonic-gate if (need_to_close) 19847c478bd9Sstevel@tonic-gate (void) fclose(of); 19857c478bd9Sstevel@tonic-gate } 19867c478bd9Sstevel@tonic-gate 19877c478bd9Sstevel@tonic-gate void 19887c478bd9Sstevel@tonic-gate exit_func(cmd_t *cmd) 19897c478bd9Sstevel@tonic-gate { 19907c478bd9Sstevel@tonic-gate int arg, answer; 1991bbec428eSgjelinek boolean_t arg_err = B_FALSE; 19927c478bd9Sstevel@tonic-gate 19937c478bd9Sstevel@tonic-gate optind = 0; 19947c478bd9Sstevel@tonic-gate while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?F")) != EOF) { 19957c478bd9Sstevel@tonic-gate switch (arg) { 19967c478bd9Sstevel@tonic-gate case '?': 19977c478bd9Sstevel@tonic-gate longer_usage(CMD_EXIT); 1998bbec428eSgjelinek arg_err = B_TRUE; 19997ec75eb8Sgjelinek break; 20007c478bd9Sstevel@tonic-gate case 'F': 2001bbec428eSgjelinek force_exit = B_TRUE; 20027c478bd9Sstevel@tonic-gate break; 20037c478bd9Sstevel@tonic-gate default: 20047c478bd9Sstevel@tonic-gate short_usage(CMD_EXIT); 2005bbec428eSgjelinek arg_err = B_TRUE; 20067ec75eb8Sgjelinek break; 20077ec75eb8Sgjelinek } 20087ec75eb8Sgjelinek } 20097ec75eb8Sgjelinek if (arg_err) 20107c478bd9Sstevel@tonic-gate return; 20117ec75eb8Sgjelinek 20127c478bd9Sstevel@tonic-gate if (optind < cmd->cmd_argc) { 20137c478bd9Sstevel@tonic-gate short_usage(CMD_EXIT); 20147c478bd9Sstevel@tonic-gate return; 20157c478bd9Sstevel@tonic-gate } 20167c478bd9Sstevel@tonic-gate 20177c478bd9Sstevel@tonic-gate if (global_scope || force_exit) { 2018bbec428eSgjelinek time_to_exit = B_TRUE; 20197c478bd9Sstevel@tonic-gate return; 20207c478bd9Sstevel@tonic-gate } 20217c478bd9Sstevel@tonic-gate 2022bbec428eSgjelinek answer = ask_yesno(B_FALSE, "Resource incomplete; really quit"); 20237c478bd9Sstevel@tonic-gate if (answer == -1) { 20247c478bd9Sstevel@tonic-gate zerr(gettext("Resource incomplete, input " 20257c478bd9Sstevel@tonic-gate "not from terminal and -F not specified:\n%s command " 20267c478bd9Sstevel@tonic-gate "ignored, but exiting anyway."), cmd_to_str(CMD_EXIT)); 20277c478bd9Sstevel@tonic-gate exit(Z_ERR); 20287c478bd9Sstevel@tonic-gate } else if (answer == 1) { 2029bbec428eSgjelinek time_to_exit = B_TRUE; 20307c478bd9Sstevel@tonic-gate } 20317c478bd9Sstevel@tonic-gate /* (answer == 0) => just return */ 20327c478bd9Sstevel@tonic-gate } 20337c478bd9Sstevel@tonic-gate 20347c478bd9Sstevel@tonic-gate static int 20357c478bd9Sstevel@tonic-gate validate_zonepath_syntax(char *path) 20367c478bd9Sstevel@tonic-gate { 20377c478bd9Sstevel@tonic-gate if (path[0] != '/') { 20387c478bd9Sstevel@tonic-gate zerr(gettext("%s is not an absolute path."), path); 20397c478bd9Sstevel@tonic-gate return (Z_ERR); 20407c478bd9Sstevel@tonic-gate } 20417c478bd9Sstevel@tonic-gate if (strcmp(path, "/") == 0) { 20427c478bd9Sstevel@tonic-gate zerr(gettext("/ is not allowed as a %s."), 20437c478bd9Sstevel@tonic-gate pt_to_str(PT_ZONEPATH)); 20447c478bd9Sstevel@tonic-gate return (Z_ERR); 20457c478bd9Sstevel@tonic-gate } 20467c478bd9Sstevel@tonic-gate return (Z_OK); 20477c478bd9Sstevel@tonic-gate } 20487c478bd9Sstevel@tonic-gate 20497c478bd9Sstevel@tonic-gate static void 20507c478bd9Sstevel@tonic-gate add_resource(cmd_t *cmd) 20517c478bd9Sstevel@tonic-gate { 20527c478bd9Sstevel@tonic-gate int type; 20530209230bSgjelinek struct zone_psettab tmp_psettab; 20540209230bSgjelinek struct zone_mcaptab tmp_mcaptab; 2055c97ad5cdSakolb uint64_t tmp; 20560209230bSgjelinek uint64_t tmp_mcap; 20570209230bSgjelinek char pool[MAXNAMELEN]; 20587c478bd9Sstevel@tonic-gate 20597c478bd9Sstevel@tonic-gate if ((type = cmd->cmd_res_type) == RT_UNKNOWN) { 2060bbec428eSgjelinek long_usage(CMD_ADD, B_TRUE); 20617c478bd9Sstevel@tonic-gate goto bad; 20627c478bd9Sstevel@tonic-gate } 20637c478bd9Sstevel@tonic-gate 20647c478bd9Sstevel@tonic-gate switch (type) { 20657c478bd9Sstevel@tonic-gate case RT_FS: 20667c478bd9Sstevel@tonic-gate bzero(&in_progress_fstab, sizeof (in_progress_fstab)); 20677c478bd9Sstevel@tonic-gate return; 20687c478bd9Sstevel@tonic-gate case RT_IPD: 2069087719fdSdp if (state_atleast(ZONE_STATE_INSTALLED)) { 20707c478bd9Sstevel@tonic-gate zerr(gettext("Zone %s already installed; %s %s not " 20717c478bd9Sstevel@tonic-gate "allowed."), zone, cmd_to_str(CMD_ADD), 20727c478bd9Sstevel@tonic-gate rt_to_str(RT_IPD)); 20737c478bd9Sstevel@tonic-gate goto bad; 20747c478bd9Sstevel@tonic-gate } 20757c478bd9Sstevel@tonic-gate bzero(&in_progress_ipdtab, sizeof (in_progress_ipdtab)); 20767c478bd9Sstevel@tonic-gate return; 20777c478bd9Sstevel@tonic-gate case RT_NET: 20787c478bd9Sstevel@tonic-gate bzero(&in_progress_nwiftab, sizeof (in_progress_nwiftab)); 20797c478bd9Sstevel@tonic-gate return; 20807c478bd9Sstevel@tonic-gate case RT_DEVICE: 20817c478bd9Sstevel@tonic-gate bzero(&in_progress_devtab, sizeof (in_progress_devtab)); 20827c478bd9Sstevel@tonic-gate return; 20837c478bd9Sstevel@tonic-gate case RT_RCTL: 20840209230bSgjelinek if (global_zone) 20850209230bSgjelinek zerr(gettext("WARNING: Setting a global zone resource " 20860209230bSgjelinek "control too low could deny\nservice " 20870209230bSgjelinek "to even the root user; " 20880209230bSgjelinek "this could render the system impossible\n" 20890209230bSgjelinek "to administer. Please use caution.")); 20907c478bd9Sstevel@tonic-gate bzero(&in_progress_rctltab, sizeof (in_progress_rctltab)); 20917c478bd9Sstevel@tonic-gate return; 20927c478bd9Sstevel@tonic-gate case RT_ATTR: 20937c478bd9Sstevel@tonic-gate bzero(&in_progress_attrtab, sizeof (in_progress_attrtab)); 20947c478bd9Sstevel@tonic-gate return; 2095fa9e4066Sahrens case RT_DATASET: 2096fa9e4066Sahrens bzero(&in_progress_dstab, sizeof (in_progress_dstab)); 2097fa9e4066Sahrens return; 20980209230bSgjelinek case RT_DCPU: 2099c97ad5cdSakolb /* Make sure there isn't already a cpu-set or cpu-cap entry. */ 21000209230bSgjelinek if (zonecfg_lookup_pset(handle, &tmp_psettab) == Z_OK) { 21010209230bSgjelinek zerr(gettext("The %s resource already exists."), 21020209230bSgjelinek rt_to_str(RT_DCPU)); 21030209230bSgjelinek goto bad; 21040209230bSgjelinek } 2105c97ad5cdSakolb if (zonecfg_get_aliased_rctl(handle, ALIAS_CPUCAP, &tmp) != 2106c97ad5cdSakolb Z_NO_ENTRY) { 2107c97ad5cdSakolb zerr(gettext("The %s resource already exists."), 2108c97ad5cdSakolb rt_to_str(RT_PCAP)); 2109c97ad5cdSakolb goto bad; 2110c97ad5cdSakolb } 21110209230bSgjelinek 21120209230bSgjelinek /* Make sure the pool property isn't set. */ 21130209230bSgjelinek if (zonecfg_get_pool(handle, pool, sizeof (pool)) == Z_OK && 21140209230bSgjelinek strlen(pool) > 0) { 21150209230bSgjelinek zerr(gettext("The %s property is already set. " 21160209230bSgjelinek "A persistent pool is incompatible with\nthe %s " 21170209230bSgjelinek "resource."), 21180209230bSgjelinek pt_to_str(PT_POOL), rt_to_str(RT_DCPU)); 21190209230bSgjelinek goto bad; 21200209230bSgjelinek } 21210209230bSgjelinek 21220209230bSgjelinek bzero(&in_progress_psettab, sizeof (in_progress_psettab)); 21230209230bSgjelinek return; 2124c97ad5cdSakolb case RT_PCAP: 2125c97ad5cdSakolb /* 2126c97ad5cdSakolb * Make sure there isn't already a cpu-set or incompatible 2127c97ad5cdSakolb * cpu-cap rctls. 2128c97ad5cdSakolb */ 2129c97ad5cdSakolb if (zonecfg_lookup_pset(handle, &tmp_psettab) == Z_OK) { 2130c97ad5cdSakolb zerr(gettext("The %s resource already exists."), 2131c97ad5cdSakolb rt_to_str(RT_DCPU)); 2132c97ad5cdSakolb goto bad; 2133c97ad5cdSakolb } 2134c97ad5cdSakolb 2135c97ad5cdSakolb switch (zonecfg_get_aliased_rctl(handle, ALIAS_CPUCAP, &tmp)) { 2136c97ad5cdSakolb case Z_ALIAS_DISALLOW: 2137c97ad5cdSakolb zone_perror(rt_to_str(RT_PCAP), Z_ALIAS_DISALLOW, 2138bbec428eSgjelinek B_FALSE); 2139c97ad5cdSakolb goto bad; 2140c97ad5cdSakolb 2141c97ad5cdSakolb case Z_OK: 2142c97ad5cdSakolb zerr(gettext("The %s resource already exists."), 2143c97ad5cdSakolb rt_to_str(RT_PCAP)); 2144c97ad5cdSakolb goto bad; 2145c97ad5cdSakolb 2146c97ad5cdSakolb default: 2147c97ad5cdSakolb break; 2148c97ad5cdSakolb } 2149c97ad5cdSakolb return; 21500209230bSgjelinek case RT_MCAP: 21510209230bSgjelinek /* 21520209230bSgjelinek * Make sure there isn't already a mem-cap entry or max-swap 21530209230bSgjelinek * or max-locked rctl. 21540209230bSgjelinek */ 21550209230bSgjelinek if (zonecfg_lookup_mcap(handle, &tmp_mcaptab) == Z_OK || 21560209230bSgjelinek zonecfg_get_aliased_rctl(handle, ALIAS_MAXSWAP, &tmp_mcap) 21570209230bSgjelinek == Z_OK || 21580209230bSgjelinek zonecfg_get_aliased_rctl(handle, ALIAS_MAXLOCKEDMEM, 21590209230bSgjelinek &tmp_mcap) == Z_OK) { 21600209230bSgjelinek zerr(gettext("The %s resource or a related resource " 21610209230bSgjelinek "control already exists."), rt_to_str(RT_MCAP)); 21620209230bSgjelinek goto bad; 21630209230bSgjelinek } 21640209230bSgjelinek if (global_zone) 21650209230bSgjelinek zerr(gettext("WARNING: Setting a global zone memory " 21660209230bSgjelinek "cap too low could deny\nservice " 21670209230bSgjelinek "to even the root user; " 21680209230bSgjelinek "this could render the system impossible\n" 21690209230bSgjelinek "to administer. Please use caution.")); 21700209230bSgjelinek bzero(&in_progress_mcaptab, sizeof (in_progress_mcaptab)); 21710209230bSgjelinek return; 2172cb8a054bSGlenn Faden case RT_ADMIN: 2173cb8a054bSGlenn Faden bzero(&in_progress_admintab, sizeof (in_progress_admintab)); 2174cb8a054bSGlenn Faden return; 21757c478bd9Sstevel@tonic-gate default: 2176bbec428eSgjelinek zone_perror(rt_to_str(type), Z_NO_RESOURCE_TYPE, B_TRUE); 2177bbec428eSgjelinek long_usage(CMD_ADD, B_TRUE); 2178bbec428eSgjelinek usage(B_FALSE, HELP_RESOURCES); 21797c478bd9Sstevel@tonic-gate } 21807c478bd9Sstevel@tonic-gate bad: 2181bbec428eSgjelinek global_scope = B_TRUE; 21827c478bd9Sstevel@tonic-gate end_op = -1; 21837c478bd9Sstevel@tonic-gate } 21847c478bd9Sstevel@tonic-gate 21857c478bd9Sstevel@tonic-gate static void 21867c478bd9Sstevel@tonic-gate do_complex_rctl_val(complex_property_ptr_t cp) 21877c478bd9Sstevel@tonic-gate { 21887c478bd9Sstevel@tonic-gate struct zone_rctlvaltab *rctlvaltab; 21897c478bd9Sstevel@tonic-gate complex_property_ptr_t cx; 2190bbec428eSgjelinek boolean_t seen_priv = B_FALSE, seen_limit = B_FALSE, 2191bbec428eSgjelinek seen_action = B_FALSE; 21927c478bd9Sstevel@tonic-gate rctlblk_t *rctlblk; 21937c478bd9Sstevel@tonic-gate int err; 21947c478bd9Sstevel@tonic-gate 21957c478bd9Sstevel@tonic-gate if ((rctlvaltab = alloc_rctlvaltab()) == NULL) { 2196bbec428eSgjelinek zone_perror(zone, Z_NOMEM, B_TRUE); 21977c478bd9Sstevel@tonic-gate exit(Z_ERR); 21987c478bd9Sstevel@tonic-gate } 21997c478bd9Sstevel@tonic-gate for (cx = cp; cx != NULL; cx = cx->cp_next) { 22007c478bd9Sstevel@tonic-gate switch (cx->cp_type) { 22017c478bd9Sstevel@tonic-gate case PT_PRIV: 22027c478bd9Sstevel@tonic-gate if (seen_priv) { 22037c478bd9Sstevel@tonic-gate zerr(gettext("%s already specified"), 22047c478bd9Sstevel@tonic-gate pt_to_str(PT_PRIV)); 22057c478bd9Sstevel@tonic-gate goto bad; 22067c478bd9Sstevel@tonic-gate } 22077c478bd9Sstevel@tonic-gate (void) strlcpy(rctlvaltab->zone_rctlval_priv, 22087c478bd9Sstevel@tonic-gate cx->cp_value, 22097c478bd9Sstevel@tonic-gate sizeof (rctlvaltab->zone_rctlval_priv)); 2210bbec428eSgjelinek seen_priv = B_TRUE; 22117c478bd9Sstevel@tonic-gate break; 22127c478bd9Sstevel@tonic-gate case PT_LIMIT: 22137c478bd9Sstevel@tonic-gate if (seen_limit) { 22147c478bd9Sstevel@tonic-gate zerr(gettext("%s already specified"), 22157c478bd9Sstevel@tonic-gate pt_to_str(PT_LIMIT)); 22167c478bd9Sstevel@tonic-gate goto bad; 22177c478bd9Sstevel@tonic-gate } 22187c478bd9Sstevel@tonic-gate (void) strlcpy(rctlvaltab->zone_rctlval_limit, 22197c478bd9Sstevel@tonic-gate cx->cp_value, 22207c478bd9Sstevel@tonic-gate sizeof (rctlvaltab->zone_rctlval_limit)); 2221bbec428eSgjelinek seen_limit = B_TRUE; 22227c478bd9Sstevel@tonic-gate break; 22237c478bd9Sstevel@tonic-gate case PT_ACTION: 22247c478bd9Sstevel@tonic-gate if (seen_action) { 22257c478bd9Sstevel@tonic-gate zerr(gettext("%s already specified"), 22267c478bd9Sstevel@tonic-gate pt_to_str(PT_ACTION)); 22277c478bd9Sstevel@tonic-gate goto bad; 22287c478bd9Sstevel@tonic-gate } 22297c478bd9Sstevel@tonic-gate (void) strlcpy(rctlvaltab->zone_rctlval_action, 22307c478bd9Sstevel@tonic-gate cx->cp_value, 22317c478bd9Sstevel@tonic-gate sizeof (rctlvaltab->zone_rctlval_action)); 2232bbec428eSgjelinek seen_action = B_TRUE; 22337c478bd9Sstevel@tonic-gate break; 22347c478bd9Sstevel@tonic-gate default: 22357c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(PT_VALUE), 2236bbec428eSgjelinek Z_NO_PROPERTY_TYPE, B_TRUE); 2237bbec428eSgjelinek long_usage(CMD_ADD, B_TRUE); 2238bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 22397c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctlvaltab); 22407c478bd9Sstevel@tonic-gate return; 22417c478bd9Sstevel@tonic-gate } 22427c478bd9Sstevel@tonic-gate } 22437c478bd9Sstevel@tonic-gate if (!seen_priv) 22447c478bd9Sstevel@tonic-gate zerr(gettext("%s not specified"), pt_to_str(PT_PRIV)); 22457c478bd9Sstevel@tonic-gate if (!seen_limit) 22467c478bd9Sstevel@tonic-gate zerr(gettext("%s not specified"), pt_to_str(PT_LIMIT)); 22477c478bd9Sstevel@tonic-gate if (!seen_action) 22487c478bd9Sstevel@tonic-gate zerr(gettext("%s not specified"), pt_to_str(PT_ACTION)); 22497c478bd9Sstevel@tonic-gate if (!seen_priv || !seen_limit || !seen_action) 22507c478bd9Sstevel@tonic-gate goto bad; 22517c478bd9Sstevel@tonic-gate rctlvaltab->zone_rctlval_next = NULL; 22527c478bd9Sstevel@tonic-gate rctlblk = alloca(rctlblk_size()); 22537c478bd9Sstevel@tonic-gate /* 22547c478bd9Sstevel@tonic-gate * Make sure the rctl value looks roughly correct; we won't know if 22557c478bd9Sstevel@tonic-gate * it's truly OK until we verify the configuration on the target 22567c478bd9Sstevel@tonic-gate * system. 22577c478bd9Sstevel@tonic-gate */ 22587c478bd9Sstevel@tonic-gate if (zonecfg_construct_rctlblk(rctlvaltab, rctlblk) != Z_OK || 22597c478bd9Sstevel@tonic-gate !zonecfg_valid_rctlblk(rctlblk)) { 22607c478bd9Sstevel@tonic-gate zerr(gettext("Invalid %s %s specification"), rt_to_str(RT_RCTL), 22617c478bd9Sstevel@tonic-gate pt_to_str(PT_VALUE)); 22627c478bd9Sstevel@tonic-gate goto bad; 22637c478bd9Sstevel@tonic-gate } 22647c478bd9Sstevel@tonic-gate err = zonecfg_add_rctl_value(&in_progress_rctltab, rctlvaltab); 22657c478bd9Sstevel@tonic-gate if (err != Z_OK) 2266bbec428eSgjelinek zone_perror(pt_to_str(PT_VALUE), err, B_TRUE); 22677c478bd9Sstevel@tonic-gate return; 22687c478bd9Sstevel@tonic-gate 22697c478bd9Sstevel@tonic-gate bad: 22707c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctlvaltab); 22717c478bd9Sstevel@tonic-gate } 22727c478bd9Sstevel@tonic-gate 22737c478bd9Sstevel@tonic-gate static void 22747c478bd9Sstevel@tonic-gate add_property(cmd_t *cmd) 22757c478bd9Sstevel@tonic-gate { 22767c478bd9Sstevel@tonic-gate char *prop_id; 22777c478bd9Sstevel@tonic-gate int err, res_type, prop_type; 22787c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 22797c478bd9Sstevel@tonic-gate list_property_ptr_t l; 22807c478bd9Sstevel@tonic-gate 22817c478bd9Sstevel@tonic-gate res_type = resource_scope; 22827c478bd9Sstevel@tonic-gate prop_type = cmd->cmd_prop_name[0]; 22837c478bd9Sstevel@tonic-gate if (res_type == RT_UNKNOWN || prop_type == PT_UNKNOWN) { 2284bbec428eSgjelinek long_usage(CMD_ADD, B_TRUE); 22857c478bd9Sstevel@tonic-gate return; 22867c478bd9Sstevel@tonic-gate } 22877c478bd9Sstevel@tonic-gate 22887c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs != 1) { 2289bbec428eSgjelinek long_usage(CMD_ADD, B_TRUE); 22907c478bd9Sstevel@tonic-gate return; 22917c478bd9Sstevel@tonic-gate } 22927c478bd9Sstevel@tonic-gate 2293bbec428eSgjelinek if (initialize(B_TRUE) != Z_OK) 22947c478bd9Sstevel@tonic-gate return; 22957c478bd9Sstevel@tonic-gate 22967c478bd9Sstevel@tonic-gate switch (res_type) { 22977c478bd9Sstevel@tonic-gate case RT_FS: 22987c478bd9Sstevel@tonic-gate if (prop_type != PT_OPTIONS) { 22997c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 2300bbec428eSgjelinek B_TRUE); 2301bbec428eSgjelinek long_usage(CMD_ADD, B_TRUE); 2302bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 23037c478bd9Sstevel@tonic-gate return; 23047c478bd9Sstevel@tonic-gate } 23057c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[0]; 23067c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE && 23077c478bd9Sstevel@tonic-gate pp->pv_type != PROP_VAL_LIST) { 23087c478bd9Sstevel@tonic-gate zerr(gettext("A %s or %s value was expected here."), 23097c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_SIMPLE), 23107c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_LIST)); 2311bbec428eSgjelinek saw_error = B_TRUE; 23127c478bd9Sstevel@tonic-gate return; 23137c478bd9Sstevel@tonic-gate } 23147c478bd9Sstevel@tonic-gate if (pp->pv_type == PROP_VAL_SIMPLE) { 23157c478bd9Sstevel@tonic-gate if (pp->pv_simple == NULL) { 2316bbec428eSgjelinek long_usage(CMD_ADD, B_TRUE); 23177c478bd9Sstevel@tonic-gate return; 23187c478bd9Sstevel@tonic-gate } 23197c478bd9Sstevel@tonic-gate prop_id = pp->pv_simple; 23207c478bd9Sstevel@tonic-gate err = zonecfg_add_fs_option(&in_progress_fstab, 23217c478bd9Sstevel@tonic-gate prop_id); 23227c478bd9Sstevel@tonic-gate if (err != Z_OK) 2323bbec428eSgjelinek zone_perror(pt_to_str(prop_type), err, B_TRUE); 23247c478bd9Sstevel@tonic-gate } else { 23257c478bd9Sstevel@tonic-gate list_property_ptr_t list; 23267c478bd9Sstevel@tonic-gate 23277c478bd9Sstevel@tonic-gate for (list = pp->pv_list; list != NULL; 23287c478bd9Sstevel@tonic-gate list = list->lp_next) { 23297c478bd9Sstevel@tonic-gate prop_id = list->lp_simple; 23307c478bd9Sstevel@tonic-gate if (prop_id == NULL) 23317c478bd9Sstevel@tonic-gate break; 23327c478bd9Sstevel@tonic-gate err = zonecfg_add_fs_option( 23337c478bd9Sstevel@tonic-gate &in_progress_fstab, prop_id); 23347c478bd9Sstevel@tonic-gate if (err != Z_OK) 23357c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), err, 2336bbec428eSgjelinek B_TRUE); 23377c478bd9Sstevel@tonic-gate } 23387c478bd9Sstevel@tonic-gate } 23397c478bd9Sstevel@tonic-gate return; 23407c478bd9Sstevel@tonic-gate case RT_RCTL: 23417c478bd9Sstevel@tonic-gate if (prop_type != PT_VALUE) { 23427c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 2343bbec428eSgjelinek B_TRUE); 2344bbec428eSgjelinek long_usage(CMD_ADD, B_TRUE); 2345bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 23467c478bd9Sstevel@tonic-gate return; 23477c478bd9Sstevel@tonic-gate } 23487c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[0]; 23497c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_COMPLEX && 23507c478bd9Sstevel@tonic-gate pp->pv_type != PROP_VAL_LIST) { 23517c478bd9Sstevel@tonic-gate zerr(gettext("A %s or %s value was expected here."), 23527c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_COMPLEX), 23537c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_LIST)); 2354bbec428eSgjelinek saw_error = B_TRUE; 23557c478bd9Sstevel@tonic-gate return; 23567c478bd9Sstevel@tonic-gate } 23577c478bd9Sstevel@tonic-gate if (pp->pv_type == PROP_VAL_COMPLEX) { 23587c478bd9Sstevel@tonic-gate do_complex_rctl_val(pp->pv_complex); 23597c478bd9Sstevel@tonic-gate return; 23607c478bd9Sstevel@tonic-gate } 23617c478bd9Sstevel@tonic-gate for (l = pp->pv_list; l != NULL; l = l->lp_next) 23627c478bd9Sstevel@tonic-gate do_complex_rctl_val(l->lp_complex); 23637c478bd9Sstevel@tonic-gate return; 23647c478bd9Sstevel@tonic-gate default: 2365bbec428eSgjelinek zone_perror(rt_to_str(res_type), Z_NO_RESOURCE_TYPE, B_TRUE); 2366bbec428eSgjelinek long_usage(CMD_ADD, B_TRUE); 2367bbec428eSgjelinek usage(B_FALSE, HELP_RESOURCES); 23687c478bd9Sstevel@tonic-gate return; 23697c478bd9Sstevel@tonic-gate } 23707c478bd9Sstevel@tonic-gate } 23717c478bd9Sstevel@tonic-gate 23720209230bSgjelinek static boolean_t 23730209230bSgjelinek gz_invalid_resource(int type) 23740209230bSgjelinek { 23750209230bSgjelinek return (global_zone && (type == RT_FS || type == RT_IPD || 23760209230bSgjelinek type == RT_NET || type == RT_DEVICE || type == RT_ATTR || 23770209230bSgjelinek type == RT_DATASET)); 23780209230bSgjelinek } 23790209230bSgjelinek 23800209230bSgjelinek static boolean_t 23810209230bSgjelinek gz_invalid_rt_property(int type) 23820209230bSgjelinek { 23830209230bSgjelinek return (global_zone && (type == RT_ZONENAME || type == RT_ZONEPATH || 23840209230bSgjelinek type == RT_AUTOBOOT || type == RT_LIMITPRIV || 2385f4b3ec61Sdh155122 type == RT_BOOTARGS || type == RT_BRAND || type == RT_SCHED || 23865679c89fSjv227347 type == RT_IPTYPE || type == RT_HOSTID)); 23870209230bSgjelinek } 23880209230bSgjelinek 23890209230bSgjelinek static boolean_t 23900209230bSgjelinek gz_invalid_property(int type) 23910209230bSgjelinek { 23920209230bSgjelinek return (global_zone && (type == PT_ZONENAME || type == PT_ZONEPATH || 23930209230bSgjelinek type == PT_AUTOBOOT || type == PT_LIMITPRIV || 2394f4b3ec61Sdh155122 type == PT_BOOTARGS || type == PT_BRAND || type == PT_SCHED || 23955679c89fSjv227347 type == PT_IPTYPE || type == PT_HOSTID)); 23960209230bSgjelinek } 23970209230bSgjelinek 23987c478bd9Sstevel@tonic-gate void 23997c478bd9Sstevel@tonic-gate add_func(cmd_t *cmd) 24007c478bd9Sstevel@tonic-gate { 24017c478bd9Sstevel@tonic-gate int arg; 2402bbec428eSgjelinek boolean_t arg_err = B_FALSE; 24037c478bd9Sstevel@tonic-gate 24047c478bd9Sstevel@tonic-gate assert(cmd != NULL); 24057c478bd9Sstevel@tonic-gate 24067c478bd9Sstevel@tonic-gate optind = 0; 24077ec75eb8Sgjelinek while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?")) != EOF) { 24087c478bd9Sstevel@tonic-gate switch (arg) { 24097c478bd9Sstevel@tonic-gate case '?': 24107c478bd9Sstevel@tonic-gate longer_usage(CMD_ADD); 2411bbec428eSgjelinek arg_err = B_TRUE; 24127ec75eb8Sgjelinek break; 24137c478bd9Sstevel@tonic-gate default: 24147c478bd9Sstevel@tonic-gate short_usage(CMD_ADD); 2415bbec428eSgjelinek arg_err = B_TRUE; 24167ec75eb8Sgjelinek break; 24177ec75eb8Sgjelinek } 24187ec75eb8Sgjelinek } 24197ec75eb8Sgjelinek if (arg_err) 24207c478bd9Sstevel@tonic-gate return; 24217ec75eb8Sgjelinek 24227c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 24237c478bd9Sstevel@tonic-gate short_usage(CMD_ADD); 24247c478bd9Sstevel@tonic-gate return; 24257c478bd9Sstevel@tonic-gate } 24267c478bd9Sstevel@tonic-gate 24277c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_ADD)) 24287c478bd9Sstevel@tonic-gate return; 24297c478bd9Sstevel@tonic-gate 2430bbec428eSgjelinek if (initialize(B_TRUE) != Z_OK) 24317c478bd9Sstevel@tonic-gate return; 24327c478bd9Sstevel@tonic-gate if (global_scope) { 24330209230bSgjelinek if (gz_invalid_resource(cmd->cmd_res_type)) { 24340209230bSgjelinek zerr(gettext("Cannot add a %s resource to the " 24350209230bSgjelinek "global zone."), rt_to_str(cmd->cmd_res_type)); 2436bbec428eSgjelinek saw_error = B_TRUE; 24370209230bSgjelinek return; 24380209230bSgjelinek } 24390209230bSgjelinek 2440bbec428eSgjelinek global_scope = B_FALSE; 24417c478bd9Sstevel@tonic-gate resource_scope = cmd->cmd_res_type; 24427c478bd9Sstevel@tonic-gate end_op = CMD_ADD; 24437c478bd9Sstevel@tonic-gate add_resource(cmd); 24447c478bd9Sstevel@tonic-gate } else 24457c478bd9Sstevel@tonic-gate add_property(cmd); 24467c478bd9Sstevel@tonic-gate } 24477c478bd9Sstevel@tonic-gate 2448087719fdSdp /* 2449087719fdSdp * This routine has an unusual implementation, because it tries very 2450087719fdSdp * hard to succeed in the face of a variety of failure modes. 2451087719fdSdp * The most common and most vexing occurs when the index file and 2452087719fdSdp * the /etc/zones/<zonename.xml> file are not both present. In 2453087719fdSdp * this case, delete must eradicate as much of the zone state as is left 2454087719fdSdp * so that the user can later create a new zone with the same name. 2455087719fdSdp */ 24567c478bd9Sstevel@tonic-gate void 24577c478bd9Sstevel@tonic-gate delete_func(cmd_t *cmd) 24587c478bd9Sstevel@tonic-gate { 24597c478bd9Sstevel@tonic-gate int err, arg, answer; 24607c478bd9Sstevel@tonic-gate char line[ZONENAME_MAX + 128]; /* enough to ask a question */ 2461bbec428eSgjelinek boolean_t force = B_FALSE; 2462bbec428eSgjelinek boolean_t arg_err = B_FALSE; 24637c478bd9Sstevel@tonic-gate 24647c478bd9Sstevel@tonic-gate optind = 0; 24657c478bd9Sstevel@tonic-gate while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?F")) != EOF) { 24667c478bd9Sstevel@tonic-gate switch (arg) { 24677c478bd9Sstevel@tonic-gate case '?': 24687c478bd9Sstevel@tonic-gate longer_usage(CMD_DELETE); 2469bbec428eSgjelinek arg_err = B_TRUE; 24707ec75eb8Sgjelinek break; 24717c478bd9Sstevel@tonic-gate case 'F': 2472bbec428eSgjelinek force = B_TRUE; 24737c478bd9Sstevel@tonic-gate break; 24747c478bd9Sstevel@tonic-gate default: 24757c478bd9Sstevel@tonic-gate short_usage(CMD_DELETE); 2476bbec428eSgjelinek arg_err = B_TRUE; 24777ec75eb8Sgjelinek break; 24787ec75eb8Sgjelinek } 24797ec75eb8Sgjelinek } 24807ec75eb8Sgjelinek if (arg_err) 24817c478bd9Sstevel@tonic-gate return; 24827ec75eb8Sgjelinek 24837c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 24847c478bd9Sstevel@tonic-gate short_usage(CMD_DELETE); 24857c478bd9Sstevel@tonic-gate return; 24867c478bd9Sstevel@tonic-gate } 24877c478bd9Sstevel@tonic-gate 24887c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_DELETE)) 24897c478bd9Sstevel@tonic-gate return; 24907c478bd9Sstevel@tonic-gate 2491087719fdSdp if (!force) { 2492087719fdSdp /* 2493087719fdSdp * Initialize sets up the global called "handle" and warns the 2494087719fdSdp * user if the zone is not configured. In force mode, we don't 2495087719fdSdp * trust that evaluation, and hence skip it. (We don't need the 2496087719fdSdp * handle to be loaded anyway, since zonecfg_destroy is done by 2497087719fdSdp * zonename). However, we also have to take care to emulate the 2498087719fdSdp * messages spit out by initialize; see below. 2499087719fdSdp */ 2500bbec428eSgjelinek if (initialize(B_TRUE) != Z_OK) 25017c478bd9Sstevel@tonic-gate return; 25027c478bd9Sstevel@tonic-gate 25037c478bd9Sstevel@tonic-gate (void) snprintf(line, sizeof (line), 25047c478bd9Sstevel@tonic-gate gettext("Are you sure you want to delete zone %s"), zone); 2505bbec428eSgjelinek if ((answer = ask_yesno(B_FALSE, line)) == -1) { 2506087719fdSdp zerr(gettext("Input not from terminal and -F not " 2507087719fdSdp "specified:\n%s command ignored, exiting."), 2508087719fdSdp cmd_to_str(CMD_DELETE)); 25097c478bd9Sstevel@tonic-gate exit(Z_ERR); 25107c478bd9Sstevel@tonic-gate } 25117c478bd9Sstevel@tonic-gate if (answer != 1) 25127c478bd9Sstevel@tonic-gate return; 25137c478bd9Sstevel@tonic-gate } 25147c478bd9Sstevel@tonic-gate 2515cb8a054bSGlenn Faden /* 2516cb8a054bSGlenn Faden * This function removes the authorizations from user_attr 2517cb8a054bSGlenn Faden * that correspond to those specified in the configuration 2518cb8a054bSGlenn Faden */ 2519cb8a054bSGlenn Faden if (initialize(B_TRUE) == Z_OK) { 2520cb8a054bSGlenn Faden (void) zonecfg_deauthorize_users(handle, zone); 2521cb8a054bSGlenn Faden } 2522087719fdSdp if ((err = zonecfg_destroy(zone, force)) != Z_OK) { 2523087719fdSdp if ((err == Z_BAD_ZONE_STATE) && !force) { 2524087719fdSdp zerr(gettext("Zone %s not in %s state; %s not " 2525087719fdSdp "allowed. Use -F to force %s."), 2526087719fdSdp zone, zone_state_str(ZONE_STATE_CONFIGURED), 2527087719fdSdp cmd_to_str(CMD_DELETE), cmd_to_str(CMD_DELETE)); 2528087719fdSdp } else { 2529bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 25307c478bd9Sstevel@tonic-gate } 2531087719fdSdp } 2532bbec428eSgjelinek need_to_commit = B_FALSE; 2533087719fdSdp 2534087719fdSdp /* 2535087719fdSdp * Emulate initialize's messaging; if there wasn't a valid handle to 2536087719fdSdp * begin with, then user had typed delete (or delete -F) multiple 2537087719fdSdp * times. So we emit a message. 2538087719fdSdp * 2539087719fdSdp * We only do this in the 'force' case because normally, initialize() 2540087719fdSdp * takes care of this for us. 2541087719fdSdp */ 2542087719fdSdp if (force && zonecfg_check_handle(handle) != Z_OK && interactive_mode) 2543087719fdSdp (void) printf(gettext("Use '%s' to begin " 2544087719fdSdp "configuring a new zone.\n"), cmd_to_str(CMD_CREATE)); 25457c478bd9Sstevel@tonic-gate 25467c478bd9Sstevel@tonic-gate /* 25477c478bd9Sstevel@tonic-gate * Time for a new handle: finish the old one off first 25487c478bd9Sstevel@tonic-gate * then get a new one properly to avoid leaks. 25497c478bd9Sstevel@tonic-gate */ 2550087719fdSdp if (got_handle) { 25517c478bd9Sstevel@tonic-gate zonecfg_fini_handle(handle); 25527c478bd9Sstevel@tonic-gate if ((handle = zonecfg_init_handle()) == NULL) { 2553bbec428eSgjelinek zone_perror(execname, Z_NOMEM, B_TRUE); 25547c478bd9Sstevel@tonic-gate exit(Z_ERR); 25557c478bd9Sstevel@tonic-gate } 25567c478bd9Sstevel@tonic-gate if ((err = zonecfg_get_handle(zone, handle)) != Z_OK) { 25577c478bd9Sstevel@tonic-gate /* If there was no zone before, that's OK */ 25587c478bd9Sstevel@tonic-gate if (err != Z_NO_ZONE) 2559bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 2560bbec428eSgjelinek got_handle = B_FALSE; 25617c478bd9Sstevel@tonic-gate } 25627c478bd9Sstevel@tonic-gate } 2563087719fdSdp } 25647c478bd9Sstevel@tonic-gate 25657c478bd9Sstevel@tonic-gate static int 2566bbec428eSgjelinek fill_in_fstab(cmd_t *cmd, struct zone_fstab *fstab, boolean_t fill_in_only) 25677c478bd9Sstevel@tonic-gate { 25687c478bd9Sstevel@tonic-gate int err, i; 25697c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 25707c478bd9Sstevel@tonic-gate 2571bbec428eSgjelinek if ((err = initialize(B_TRUE)) != Z_OK) 25727c478bd9Sstevel@tonic-gate return (err); 25737c478bd9Sstevel@tonic-gate 2574e193d1e6Svp157776 bzero(fstab, sizeof (*fstab)); 25757c478bd9Sstevel@tonic-gate for (i = 0; i < cmd->cmd_prop_nv_pairs; i++) { 25767c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[i]; 25777c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE || pp->pv_simple == NULL) { 25787c478bd9Sstevel@tonic-gate zerr(gettext("A simple value was expected here.")); 2579bbec428eSgjelinek saw_error = B_TRUE; 25807c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 25817c478bd9Sstevel@tonic-gate } 25827c478bd9Sstevel@tonic-gate switch (cmd->cmd_prop_name[i]) { 25837c478bd9Sstevel@tonic-gate case PT_DIR: 25847c478bd9Sstevel@tonic-gate (void) strlcpy(fstab->zone_fs_dir, pp->pv_simple, 25857c478bd9Sstevel@tonic-gate sizeof (fstab->zone_fs_dir)); 25867c478bd9Sstevel@tonic-gate break; 25877c478bd9Sstevel@tonic-gate case PT_SPECIAL: 25887c478bd9Sstevel@tonic-gate (void) strlcpy(fstab->zone_fs_special, pp->pv_simple, 25897c478bd9Sstevel@tonic-gate sizeof (fstab->zone_fs_special)); 25907c478bd9Sstevel@tonic-gate break; 25917c478bd9Sstevel@tonic-gate case PT_RAW: 25927c478bd9Sstevel@tonic-gate (void) strlcpy(fstab->zone_fs_raw, pp->pv_simple, 25937c478bd9Sstevel@tonic-gate sizeof (fstab->zone_fs_raw)); 25947c478bd9Sstevel@tonic-gate break; 25957c478bd9Sstevel@tonic-gate case PT_TYPE: 25967c478bd9Sstevel@tonic-gate (void) strlcpy(fstab->zone_fs_type, pp->pv_simple, 25977c478bd9Sstevel@tonic-gate sizeof (fstab->zone_fs_type)); 25987c478bd9Sstevel@tonic-gate break; 25997c478bd9Sstevel@tonic-gate default: 26007c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(cmd->cmd_prop_name[i]), 2601bbec428eSgjelinek Z_NO_PROPERTY_TYPE, B_TRUE); 26027c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 26037c478bd9Sstevel@tonic-gate } 26047c478bd9Sstevel@tonic-gate } 26057c478bd9Sstevel@tonic-gate if (fill_in_only) 26067c478bd9Sstevel@tonic-gate return (Z_OK); 26077c478bd9Sstevel@tonic-gate return (zonecfg_lookup_filesystem(handle, fstab)); 26087c478bd9Sstevel@tonic-gate } 26097c478bd9Sstevel@tonic-gate 26107c478bd9Sstevel@tonic-gate static int 2611bbec428eSgjelinek fill_in_ipdtab(cmd_t *cmd, struct zone_fstab *ipdtab, boolean_t fill_in_only) 26127c478bd9Sstevel@tonic-gate { 26137c478bd9Sstevel@tonic-gate int err, i; 26147c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 26157c478bd9Sstevel@tonic-gate 2616bbec428eSgjelinek if ((err = initialize(B_TRUE)) != Z_OK) 26177c478bd9Sstevel@tonic-gate return (err); 26187c478bd9Sstevel@tonic-gate 2619e193d1e6Svp157776 bzero(ipdtab, sizeof (*ipdtab)); 26207c478bd9Sstevel@tonic-gate for (i = 0; i < cmd->cmd_prop_nv_pairs; i++) { 26217c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[i]; 26227c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE || pp->pv_simple == NULL) { 26237c478bd9Sstevel@tonic-gate zerr(gettext("A simple value was expected here.")); 2624bbec428eSgjelinek saw_error = B_TRUE; 26257c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 26267c478bd9Sstevel@tonic-gate } 26277c478bd9Sstevel@tonic-gate switch (cmd->cmd_prop_name[i]) { 26287c478bd9Sstevel@tonic-gate case PT_DIR: 26297c478bd9Sstevel@tonic-gate (void) strlcpy(ipdtab->zone_fs_dir, pp->pv_simple, 26307c478bd9Sstevel@tonic-gate sizeof (ipdtab->zone_fs_dir)); 26317c478bd9Sstevel@tonic-gate break; 26327c478bd9Sstevel@tonic-gate default: 26337c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(cmd->cmd_prop_name[i]), 2634bbec428eSgjelinek Z_NO_PROPERTY_TYPE, B_TRUE); 26357c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 26367c478bd9Sstevel@tonic-gate } 26377c478bd9Sstevel@tonic-gate } 26387c478bd9Sstevel@tonic-gate if (fill_in_only) 26397c478bd9Sstevel@tonic-gate return (Z_OK); 26407c478bd9Sstevel@tonic-gate return (zonecfg_lookup_ipd(handle, ipdtab)); 26417c478bd9Sstevel@tonic-gate } 26427c478bd9Sstevel@tonic-gate 26437c478bd9Sstevel@tonic-gate static int 2644bbec428eSgjelinek fill_in_nwiftab(cmd_t *cmd, struct zone_nwiftab *nwiftab, 2645bbec428eSgjelinek boolean_t fill_in_only) 26467c478bd9Sstevel@tonic-gate { 26477c478bd9Sstevel@tonic-gate int err, i; 26487c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 26497c478bd9Sstevel@tonic-gate 2650bbec428eSgjelinek if ((err = initialize(B_TRUE)) != Z_OK) 26517c478bd9Sstevel@tonic-gate return (err); 26527c478bd9Sstevel@tonic-gate 2653e193d1e6Svp157776 bzero(nwiftab, sizeof (*nwiftab)); 26547c478bd9Sstevel@tonic-gate for (i = 0; i < cmd->cmd_prop_nv_pairs; i++) { 26557c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[i]; 26567c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE || pp->pv_simple == NULL) { 26577c478bd9Sstevel@tonic-gate zerr(gettext("A simple value was expected here.")); 2658bbec428eSgjelinek saw_error = B_TRUE; 26597c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 26607c478bd9Sstevel@tonic-gate } 26617c478bd9Sstevel@tonic-gate switch (cmd->cmd_prop_name[i]) { 26627c478bd9Sstevel@tonic-gate case PT_ADDRESS: 26637c478bd9Sstevel@tonic-gate (void) strlcpy(nwiftab->zone_nwif_address, 26647c478bd9Sstevel@tonic-gate pp->pv_simple, sizeof (nwiftab->zone_nwif_address)); 26657c478bd9Sstevel@tonic-gate break; 26667c478bd9Sstevel@tonic-gate case PT_PHYSICAL: 26677c478bd9Sstevel@tonic-gate (void) strlcpy(nwiftab->zone_nwif_physical, 26687c478bd9Sstevel@tonic-gate pp->pv_simple, 26697c478bd9Sstevel@tonic-gate sizeof (nwiftab->zone_nwif_physical)); 26707c478bd9Sstevel@tonic-gate break; 2671de860bd9Sgfaden case PT_DEFROUTER: 2672de860bd9Sgfaden (void) strlcpy(nwiftab->zone_nwif_defrouter, 2673de860bd9Sgfaden pp->pv_simple, 2674de860bd9Sgfaden sizeof (nwiftab->zone_nwif_defrouter)); 2675de860bd9Sgfaden break; 26767c478bd9Sstevel@tonic-gate default: 26777c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(cmd->cmd_prop_name[i]), 2678bbec428eSgjelinek Z_NO_PROPERTY_TYPE, B_TRUE); 26797c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 26807c478bd9Sstevel@tonic-gate } 26817c478bd9Sstevel@tonic-gate } 26827c478bd9Sstevel@tonic-gate if (fill_in_only) 26837c478bd9Sstevel@tonic-gate return (Z_OK); 26847c478bd9Sstevel@tonic-gate err = zonecfg_lookup_nwif(handle, nwiftab); 26857c478bd9Sstevel@tonic-gate return (err); 26867c478bd9Sstevel@tonic-gate } 26877c478bd9Sstevel@tonic-gate 26887c478bd9Sstevel@tonic-gate static int 2689bbec428eSgjelinek fill_in_devtab(cmd_t *cmd, struct zone_devtab *devtab, boolean_t fill_in_only) 26907c478bd9Sstevel@tonic-gate { 26917c478bd9Sstevel@tonic-gate int err, i; 26927c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 26937c478bd9Sstevel@tonic-gate 2694bbec428eSgjelinek if ((err = initialize(B_TRUE)) != Z_OK) 26957c478bd9Sstevel@tonic-gate return (err); 26967c478bd9Sstevel@tonic-gate 2697e193d1e6Svp157776 bzero(devtab, sizeof (*devtab)); 26987c478bd9Sstevel@tonic-gate for (i = 0; i < cmd->cmd_prop_nv_pairs; i++) { 26997c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[i]; 27007c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE || pp->pv_simple == NULL) { 27017c478bd9Sstevel@tonic-gate zerr(gettext("A simple value was expected here.")); 2702bbec428eSgjelinek saw_error = B_TRUE; 27037c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 27047c478bd9Sstevel@tonic-gate } 27057c478bd9Sstevel@tonic-gate switch (cmd->cmd_prop_name[i]) { 27067c478bd9Sstevel@tonic-gate case PT_MATCH: 27077c478bd9Sstevel@tonic-gate (void) strlcpy(devtab->zone_dev_match, pp->pv_simple, 27087c478bd9Sstevel@tonic-gate sizeof (devtab->zone_dev_match)); 27097c478bd9Sstevel@tonic-gate break; 27107c478bd9Sstevel@tonic-gate default: 27117c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(cmd->cmd_prop_name[i]), 2712bbec428eSgjelinek Z_NO_PROPERTY_TYPE, B_TRUE); 27137c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 27147c478bd9Sstevel@tonic-gate } 27157c478bd9Sstevel@tonic-gate } 27167c478bd9Sstevel@tonic-gate if (fill_in_only) 27177c478bd9Sstevel@tonic-gate return (Z_OK); 27187c478bd9Sstevel@tonic-gate err = zonecfg_lookup_dev(handle, devtab); 27197c478bd9Sstevel@tonic-gate return (err); 27207c478bd9Sstevel@tonic-gate } 27217c478bd9Sstevel@tonic-gate 27227c478bd9Sstevel@tonic-gate static int 2723bbec428eSgjelinek fill_in_rctltab(cmd_t *cmd, struct zone_rctltab *rctltab, 2724bbec428eSgjelinek boolean_t fill_in_only) 27257c478bd9Sstevel@tonic-gate { 27267c478bd9Sstevel@tonic-gate int err, i; 27277c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 27287c478bd9Sstevel@tonic-gate 2729bbec428eSgjelinek if ((err = initialize(B_TRUE)) != Z_OK) 27307c478bd9Sstevel@tonic-gate return (err); 27317c478bd9Sstevel@tonic-gate 2732e193d1e6Svp157776 bzero(rctltab, sizeof (*rctltab)); 27337c478bd9Sstevel@tonic-gate for (i = 0; i < cmd->cmd_prop_nv_pairs; i++) { 27347c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[i]; 27357c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE || pp->pv_simple == NULL) { 27367c478bd9Sstevel@tonic-gate zerr(gettext("A simple value was expected here.")); 2737bbec428eSgjelinek saw_error = B_TRUE; 27387c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 27397c478bd9Sstevel@tonic-gate } 27407c478bd9Sstevel@tonic-gate switch (cmd->cmd_prop_name[i]) { 27417c478bd9Sstevel@tonic-gate case PT_NAME: 27427c478bd9Sstevel@tonic-gate (void) strlcpy(rctltab->zone_rctl_name, pp->pv_simple, 27437c478bd9Sstevel@tonic-gate sizeof (rctltab->zone_rctl_name)); 27447c478bd9Sstevel@tonic-gate break; 27457c478bd9Sstevel@tonic-gate default: 27467c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(cmd->cmd_prop_name[i]), 2747bbec428eSgjelinek Z_NO_PROPERTY_TYPE, B_TRUE); 27487c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 27497c478bd9Sstevel@tonic-gate } 27507c478bd9Sstevel@tonic-gate } 27517c478bd9Sstevel@tonic-gate if (fill_in_only) 27527c478bd9Sstevel@tonic-gate return (Z_OK); 27537c478bd9Sstevel@tonic-gate err = zonecfg_lookup_rctl(handle, rctltab); 27547c478bd9Sstevel@tonic-gate return (err); 27557c478bd9Sstevel@tonic-gate } 27567c478bd9Sstevel@tonic-gate 27577c478bd9Sstevel@tonic-gate static int 2758bbec428eSgjelinek fill_in_attrtab(cmd_t *cmd, struct zone_attrtab *attrtab, 2759bbec428eSgjelinek boolean_t fill_in_only) 27607c478bd9Sstevel@tonic-gate { 27617c478bd9Sstevel@tonic-gate int err, i; 27627c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 27637c478bd9Sstevel@tonic-gate 2764bbec428eSgjelinek if ((err = initialize(B_TRUE)) != Z_OK) 27657c478bd9Sstevel@tonic-gate return (err); 27667c478bd9Sstevel@tonic-gate 2767e193d1e6Svp157776 bzero(attrtab, sizeof (*attrtab)); 27687c478bd9Sstevel@tonic-gate for (i = 0; i < cmd->cmd_prop_nv_pairs; i++) { 27697c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[i]; 27707c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE || pp->pv_simple == NULL) { 27717c478bd9Sstevel@tonic-gate zerr(gettext("A simple value was expected here.")); 2772bbec428eSgjelinek saw_error = B_TRUE; 27737c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 27747c478bd9Sstevel@tonic-gate } 27757c478bd9Sstevel@tonic-gate switch (cmd->cmd_prop_name[i]) { 27767c478bd9Sstevel@tonic-gate case PT_NAME: 27777c478bd9Sstevel@tonic-gate (void) strlcpy(attrtab->zone_attr_name, pp->pv_simple, 27787c478bd9Sstevel@tonic-gate sizeof (attrtab->zone_attr_name)); 27797c478bd9Sstevel@tonic-gate break; 27807c478bd9Sstevel@tonic-gate case PT_TYPE: 27817c478bd9Sstevel@tonic-gate (void) strlcpy(attrtab->zone_attr_type, pp->pv_simple, 27827c478bd9Sstevel@tonic-gate sizeof (attrtab->zone_attr_type)); 27837c478bd9Sstevel@tonic-gate break; 27847c478bd9Sstevel@tonic-gate case PT_VALUE: 27857c478bd9Sstevel@tonic-gate (void) strlcpy(attrtab->zone_attr_value, pp->pv_simple, 27867c478bd9Sstevel@tonic-gate sizeof (attrtab->zone_attr_value)); 27877c478bd9Sstevel@tonic-gate break; 27887c478bd9Sstevel@tonic-gate default: 27897c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(cmd->cmd_prop_name[i]), 2790bbec428eSgjelinek Z_NO_PROPERTY_TYPE, B_TRUE); 27917c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 27927c478bd9Sstevel@tonic-gate } 27937c478bd9Sstevel@tonic-gate } 27947c478bd9Sstevel@tonic-gate if (fill_in_only) 27957c478bd9Sstevel@tonic-gate return (Z_OK); 27967c478bd9Sstevel@tonic-gate err = zonecfg_lookup_attr(handle, attrtab); 27977c478bd9Sstevel@tonic-gate return (err); 27987c478bd9Sstevel@tonic-gate } 27997c478bd9Sstevel@tonic-gate 2800fa9e4066Sahrens static int 2801bbec428eSgjelinek fill_in_dstab(cmd_t *cmd, struct zone_dstab *dstab, boolean_t fill_in_only) 2802fa9e4066Sahrens { 2803fa9e4066Sahrens int err, i; 2804fa9e4066Sahrens property_value_ptr_t pp; 2805fa9e4066Sahrens 2806bbec428eSgjelinek if ((err = initialize(B_TRUE)) != Z_OK) 2807fa9e4066Sahrens return (err); 2808fa9e4066Sahrens 2809fa9e4066Sahrens dstab->zone_dataset_name[0] = '\0'; 2810fa9e4066Sahrens for (i = 0; i < cmd->cmd_prop_nv_pairs; i++) { 2811fa9e4066Sahrens pp = cmd->cmd_property_ptr[i]; 2812fa9e4066Sahrens if (pp->pv_type != PROP_VAL_SIMPLE || pp->pv_simple == NULL) { 2813fa9e4066Sahrens zerr(gettext("A simple value was expected here.")); 2814bbec428eSgjelinek saw_error = B_TRUE; 2815fa9e4066Sahrens return (Z_INSUFFICIENT_SPEC); 2816fa9e4066Sahrens } 2817fa9e4066Sahrens switch (cmd->cmd_prop_name[i]) { 2818fa9e4066Sahrens case PT_NAME: 2819fa9e4066Sahrens (void) strlcpy(dstab->zone_dataset_name, pp->pv_simple, 2820fa9e4066Sahrens sizeof (dstab->zone_dataset_name)); 2821fa9e4066Sahrens break; 2822fa9e4066Sahrens default: 2823fa9e4066Sahrens zone_perror(pt_to_str(cmd->cmd_prop_name[i]), 2824bbec428eSgjelinek Z_NO_PROPERTY_TYPE, B_TRUE); 2825fa9e4066Sahrens return (Z_INSUFFICIENT_SPEC); 2826fa9e4066Sahrens } 2827fa9e4066Sahrens } 2828fa9e4066Sahrens if (fill_in_only) 2829fa9e4066Sahrens return (Z_OK); 2830fa9e4066Sahrens return (zonecfg_lookup_ds(handle, dstab)); 2831fa9e4066Sahrens } 2832fa9e4066Sahrens 2833cb8a054bSGlenn Faden static int 2834cb8a054bSGlenn Faden fill_in_admintab(cmd_t *cmd, struct zone_admintab *admintab, 2835cb8a054bSGlenn Faden boolean_t fill_in_only) 2836cb8a054bSGlenn Faden { 2837cb8a054bSGlenn Faden int err, i; 2838cb8a054bSGlenn Faden property_value_ptr_t pp; 2839cb8a054bSGlenn Faden 2840cb8a054bSGlenn Faden if ((err = initialize(B_TRUE)) != Z_OK) 2841cb8a054bSGlenn Faden return (err); 2842cb8a054bSGlenn Faden 2843cb8a054bSGlenn Faden bzero(admintab, sizeof (*admintab)); 2844cb8a054bSGlenn Faden for (i = 0; i < cmd->cmd_prop_nv_pairs; i++) { 2845cb8a054bSGlenn Faden pp = cmd->cmd_property_ptr[i]; 2846cb8a054bSGlenn Faden if (pp->pv_type != PROP_VAL_SIMPLE || pp->pv_simple == NULL) { 2847cb8a054bSGlenn Faden zerr(gettext("A simple value was expected here.")); 2848cb8a054bSGlenn Faden saw_error = B_TRUE; 2849cb8a054bSGlenn Faden return (Z_INSUFFICIENT_SPEC); 2850cb8a054bSGlenn Faden } 2851cb8a054bSGlenn Faden switch (cmd->cmd_prop_name[i]) { 2852cb8a054bSGlenn Faden case PT_USER: 2853cb8a054bSGlenn Faden (void) strlcpy(admintab->zone_admin_user, pp->pv_simple, 2854cb8a054bSGlenn Faden sizeof (admintab->zone_admin_user)); 2855cb8a054bSGlenn Faden break; 2856cb8a054bSGlenn Faden case PT_AUTHS: 2857cb8a054bSGlenn Faden (void) strlcpy(admintab->zone_admin_auths, 2858cb8a054bSGlenn Faden pp->pv_simple, sizeof (admintab->zone_admin_auths)); 2859cb8a054bSGlenn Faden break; 2860cb8a054bSGlenn Faden default: 2861cb8a054bSGlenn Faden zone_perror(pt_to_str(cmd->cmd_prop_name[i]), 2862cb8a054bSGlenn Faden Z_NO_PROPERTY_TYPE, B_TRUE); 2863cb8a054bSGlenn Faden return (Z_INSUFFICIENT_SPEC); 2864cb8a054bSGlenn Faden } 2865cb8a054bSGlenn Faden } 2866cb8a054bSGlenn Faden if (fill_in_only) 2867cb8a054bSGlenn Faden return (Z_OK); 2868cb8a054bSGlenn Faden err = zonecfg_lookup_admin(handle, admintab); 2869cb8a054bSGlenn Faden return (err); 2870cb8a054bSGlenn Faden } 2871cb8a054bSGlenn Faden 28727c478bd9Sstevel@tonic-gate static void 28730209230bSgjelinek remove_aliased_rctl(int type, char *name) 28747c478bd9Sstevel@tonic-gate { 28750209230bSgjelinek int err; 28760209230bSgjelinek uint64_t tmp; 28777c478bd9Sstevel@tonic-gate 28780209230bSgjelinek if ((err = zonecfg_get_aliased_rctl(handle, name, &tmp)) != Z_OK) { 28790209230bSgjelinek zerr("%s %s: %s", cmd_to_str(CMD_CLEAR), pt_to_str(type), 28800209230bSgjelinek zonecfg_strerror(err)); 2881bbec428eSgjelinek saw_error = B_TRUE; 28827c478bd9Sstevel@tonic-gate return; 28837c478bd9Sstevel@tonic-gate } 28840209230bSgjelinek if ((err = zonecfg_rm_aliased_rctl(handle, name)) != Z_OK) { 28850209230bSgjelinek zerr("%s %s: %s", cmd_to_str(CMD_CLEAR), pt_to_str(type), 28860209230bSgjelinek zonecfg_strerror(err)); 2887bbec428eSgjelinek saw_error = B_TRUE; 28880209230bSgjelinek } else { 2889bbec428eSgjelinek need_to_commit = B_TRUE; 28900209230bSgjelinek } 28910209230bSgjelinek } 28927c478bd9Sstevel@tonic-gate 28930209230bSgjelinek static boolean_t 28940209230bSgjelinek prompt_remove_resource(cmd_t *cmd, char *rsrc) 28950209230bSgjelinek { 28960209230bSgjelinek int num; 28970209230bSgjelinek int answer; 28980209230bSgjelinek int arg; 28990209230bSgjelinek boolean_t force = B_FALSE; 29000209230bSgjelinek char prompt[128]; 2901bbec428eSgjelinek boolean_t arg_err = B_FALSE; 29027c478bd9Sstevel@tonic-gate 29030209230bSgjelinek optind = 0; 29040209230bSgjelinek while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "F")) != EOF) { 29050209230bSgjelinek switch (arg) { 29060209230bSgjelinek case 'F': 29070209230bSgjelinek force = B_TRUE; 29080209230bSgjelinek break; 29090209230bSgjelinek default: 2910bbec428eSgjelinek arg_err = B_TRUE; 29117ec75eb8Sgjelinek break; 29127ec75eb8Sgjelinek } 29137ec75eb8Sgjelinek } 29147ec75eb8Sgjelinek if (arg_err) 29150209230bSgjelinek return (B_FALSE); 29167ec75eb8Sgjelinek 29170209230bSgjelinek 29180209230bSgjelinek num = zonecfg_num_resources(handle, rsrc); 29190209230bSgjelinek 29200209230bSgjelinek if (num == 0) { 29210209230bSgjelinek z_cmd_rt_perror(CMD_REMOVE, cmd->cmd_res_type, Z_NO_ENTRY, 2922bbec428eSgjelinek B_TRUE); 29230209230bSgjelinek return (B_FALSE); 29240209230bSgjelinek } 29250209230bSgjelinek if (num > 1 && !force) { 29260209230bSgjelinek if (!interactive_mode) { 29270209230bSgjelinek zerr(gettext("There are multiple instances of this " 29280209230bSgjelinek "resource. Either qualify the resource to\n" 29290209230bSgjelinek "remove a single instance or use the -F option to " 29300209230bSgjelinek "remove all instances.")); 2931bbec428eSgjelinek saw_error = B_TRUE; 29320209230bSgjelinek return (B_FALSE); 29330209230bSgjelinek } 29340209230bSgjelinek (void) snprintf(prompt, sizeof (prompt), gettext( 29350209230bSgjelinek "Are you sure you want to remove ALL '%s' resources"), 29360209230bSgjelinek rsrc); 2937bbec428eSgjelinek answer = ask_yesno(B_FALSE, prompt); 29380209230bSgjelinek if (answer == -1) { 29390209230bSgjelinek zerr(gettext("Resource incomplete.")); 29400209230bSgjelinek return (B_FALSE); 29410209230bSgjelinek } 29420209230bSgjelinek if (answer != 1) 29430209230bSgjelinek return (B_FALSE); 29440209230bSgjelinek } 29450209230bSgjelinek return (B_TRUE); 29460209230bSgjelinek } 29470209230bSgjelinek 29480209230bSgjelinek static void 29490209230bSgjelinek remove_fs(cmd_t *cmd) 29500209230bSgjelinek { 29510209230bSgjelinek int err; 29520209230bSgjelinek 29530209230bSgjelinek /* traditional, qualified fs removal */ 29540209230bSgjelinek if (cmd->cmd_prop_nv_pairs > 0) { 29550209230bSgjelinek struct zone_fstab fstab; 29560209230bSgjelinek 2957bbec428eSgjelinek if ((err = fill_in_fstab(cmd, &fstab, B_FALSE)) != Z_OK) { 2958bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_FS, err, B_TRUE); 29597c478bd9Sstevel@tonic-gate return; 29607c478bd9Sstevel@tonic-gate } 29617c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_filesystem(handle, &fstab)) != Z_OK) 2962bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_FS, err, B_TRUE); 29637c478bd9Sstevel@tonic-gate else 2964bbec428eSgjelinek need_to_commit = B_TRUE; 29657c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(fstab.zone_fs_options); 29667c478bd9Sstevel@tonic-gate return; 29670209230bSgjelinek } 29680209230bSgjelinek 29690209230bSgjelinek /* 29700209230bSgjelinek * unqualified fs removal. remove all fs's but prompt if more 29710209230bSgjelinek * than one. 29720209230bSgjelinek */ 29730209230bSgjelinek if (!prompt_remove_resource(cmd, "fs")) 29740209230bSgjelinek return; 29750209230bSgjelinek 29760209230bSgjelinek if ((err = zonecfg_del_all_resources(handle, "fs")) != Z_OK) 2977bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_FS, err, B_TRUE); 29780209230bSgjelinek else 2979bbec428eSgjelinek need_to_commit = B_TRUE; 29800209230bSgjelinek } 29810209230bSgjelinek 29820209230bSgjelinek static void 29830209230bSgjelinek remove_ipd(cmd_t *cmd) 29840209230bSgjelinek { 29850209230bSgjelinek int err; 29860209230bSgjelinek 2987087719fdSdp if (state_atleast(ZONE_STATE_INSTALLED)) { 29880209230bSgjelinek zerr(gettext("Zone %s already installed; %s %s not allowed."), 29890209230bSgjelinek zone, cmd_to_str(CMD_REMOVE), rt_to_str(RT_IPD)); 29907c478bd9Sstevel@tonic-gate return; 29917c478bd9Sstevel@tonic-gate } 29920209230bSgjelinek 29930209230bSgjelinek /* traditional, qualified ipd removal */ 29940209230bSgjelinek if (cmd->cmd_prop_nv_pairs > 0) { 29950209230bSgjelinek struct zone_fstab fstab; 29960209230bSgjelinek 2997bbec428eSgjelinek if ((err = fill_in_ipdtab(cmd, &fstab, B_FALSE)) != Z_OK) { 2998bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_IPD, err, B_TRUE); 29997c478bd9Sstevel@tonic-gate return; 30007c478bd9Sstevel@tonic-gate } 30017c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_ipd(handle, &fstab)) != Z_OK) 3002bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_IPD, err, B_TRUE); 30037c478bd9Sstevel@tonic-gate else 3004bbec428eSgjelinek need_to_commit = B_TRUE; 30057c478bd9Sstevel@tonic-gate return; 30060209230bSgjelinek } 30070209230bSgjelinek 30080209230bSgjelinek /* 30090209230bSgjelinek * unqualified ipd removal. remove all ipds but prompt if more 30100209230bSgjelinek * than one. 30110209230bSgjelinek */ 30120209230bSgjelinek if (!prompt_remove_resource(cmd, "inherit-pkg-dir")) 30130209230bSgjelinek return; 30140209230bSgjelinek 30150209230bSgjelinek if ((err = zonecfg_del_all_resources(handle, "inherit-pkg-dir")) 30160209230bSgjelinek != Z_OK) 3017bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_IPD, err, B_TRUE); 30180209230bSgjelinek else 3019bbec428eSgjelinek need_to_commit = B_TRUE; 30200209230bSgjelinek } 30210209230bSgjelinek 30220209230bSgjelinek static void 30230209230bSgjelinek remove_net(cmd_t *cmd) 30240209230bSgjelinek { 30250209230bSgjelinek int err; 30260209230bSgjelinek 30270209230bSgjelinek /* traditional, qualified net removal */ 30280209230bSgjelinek if (cmd->cmd_prop_nv_pairs > 0) { 30290209230bSgjelinek struct zone_nwiftab nwiftab; 30300209230bSgjelinek 3031bbec428eSgjelinek if ((err = fill_in_nwiftab(cmd, &nwiftab, B_FALSE)) != Z_OK) { 3032bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_NET, err, B_TRUE); 30337c478bd9Sstevel@tonic-gate return; 30347c478bd9Sstevel@tonic-gate } 30357c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_nwif(handle, &nwiftab)) != Z_OK) 3036bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_NET, err, B_TRUE); 30377c478bd9Sstevel@tonic-gate else 3038bbec428eSgjelinek need_to_commit = B_TRUE; 30397c478bd9Sstevel@tonic-gate return; 30400209230bSgjelinek } 30410209230bSgjelinek 30420209230bSgjelinek /* 30430209230bSgjelinek * unqualified net removal. remove all nets but prompt if more 30440209230bSgjelinek * than one. 30450209230bSgjelinek */ 30460209230bSgjelinek if (!prompt_remove_resource(cmd, "net")) 30470209230bSgjelinek return; 30480209230bSgjelinek 30490209230bSgjelinek if ((err = zonecfg_del_all_resources(handle, "net")) != Z_OK) 3050bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_NET, err, B_TRUE); 30510209230bSgjelinek else 3052bbec428eSgjelinek need_to_commit = B_TRUE; 30530209230bSgjelinek } 30540209230bSgjelinek 30550209230bSgjelinek static void 30560209230bSgjelinek remove_device(cmd_t *cmd) 30570209230bSgjelinek { 30580209230bSgjelinek int err; 30590209230bSgjelinek 30600209230bSgjelinek /* traditional, qualified device removal */ 30610209230bSgjelinek if (cmd->cmd_prop_nv_pairs > 0) { 30620209230bSgjelinek struct zone_devtab devtab; 30630209230bSgjelinek 3064bbec428eSgjelinek if ((err = fill_in_devtab(cmd, &devtab, B_FALSE)) != Z_OK) { 3065bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_DEVICE, err, B_TRUE); 30667c478bd9Sstevel@tonic-gate return; 30677c478bd9Sstevel@tonic-gate } 30687c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_dev(handle, &devtab)) != Z_OK) 3069bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_DEVICE, err, B_TRUE); 30707c478bd9Sstevel@tonic-gate else 3071bbec428eSgjelinek need_to_commit = B_TRUE; 30727c478bd9Sstevel@tonic-gate return; 30730209230bSgjelinek } 30740209230bSgjelinek 30750209230bSgjelinek /* 30760209230bSgjelinek * unqualified device removal. remove all devices but prompt if more 30770209230bSgjelinek * than one. 30780209230bSgjelinek */ 30790209230bSgjelinek if (!prompt_remove_resource(cmd, "device")) 30800209230bSgjelinek return; 30810209230bSgjelinek 30820209230bSgjelinek if ((err = zonecfg_del_all_resources(handle, "device")) != Z_OK) 3083bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_DEVICE, err, B_TRUE); 30840209230bSgjelinek else 3085bbec428eSgjelinek need_to_commit = B_TRUE; 30860209230bSgjelinek } 30870209230bSgjelinek 30880209230bSgjelinek static void 30890209230bSgjelinek remove_attr(cmd_t *cmd) 30900209230bSgjelinek { 30910209230bSgjelinek int err; 30920209230bSgjelinek 30930209230bSgjelinek /* traditional, qualified attr removal */ 30940209230bSgjelinek if (cmd->cmd_prop_nv_pairs > 0) { 30950209230bSgjelinek struct zone_attrtab attrtab; 30960209230bSgjelinek 3097bbec428eSgjelinek if ((err = fill_in_attrtab(cmd, &attrtab, B_FALSE)) != Z_OK) { 3098bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_ATTR, err, B_TRUE); 30990209230bSgjelinek return; 31000209230bSgjelinek } 31010209230bSgjelinek if ((err = zonecfg_delete_attr(handle, &attrtab)) != Z_OK) 3102bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_ATTR, err, B_TRUE); 31030209230bSgjelinek else 3104bbec428eSgjelinek need_to_commit = B_TRUE; 31050209230bSgjelinek return; 31060209230bSgjelinek } 31070209230bSgjelinek 31080209230bSgjelinek /* 31090209230bSgjelinek * unqualified attr removal. remove all attrs but prompt if more 31100209230bSgjelinek * than one. 31110209230bSgjelinek */ 31120209230bSgjelinek if (!prompt_remove_resource(cmd, "attr")) 31130209230bSgjelinek return; 31140209230bSgjelinek 31150209230bSgjelinek if ((err = zonecfg_del_all_resources(handle, "attr")) != Z_OK) 3116bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_ATTR, err, B_TRUE); 31170209230bSgjelinek else 3118bbec428eSgjelinek need_to_commit = B_TRUE; 31190209230bSgjelinek } 31200209230bSgjelinek 31210209230bSgjelinek static void 31220209230bSgjelinek remove_dataset(cmd_t *cmd) 31230209230bSgjelinek { 31240209230bSgjelinek int err; 31250209230bSgjelinek 31260209230bSgjelinek /* traditional, qualified dataset removal */ 31270209230bSgjelinek if (cmd->cmd_prop_nv_pairs > 0) { 31280209230bSgjelinek struct zone_dstab dstab; 31290209230bSgjelinek 3130bbec428eSgjelinek if ((err = fill_in_dstab(cmd, &dstab, B_FALSE)) != Z_OK) { 3131bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_DATASET, err, B_TRUE); 31320209230bSgjelinek return; 31330209230bSgjelinek } 31340209230bSgjelinek if ((err = zonecfg_delete_ds(handle, &dstab)) != Z_OK) 3135bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_DATASET, err, B_TRUE); 31360209230bSgjelinek else 3137bbec428eSgjelinek need_to_commit = B_TRUE; 31380209230bSgjelinek return; 31390209230bSgjelinek } 31400209230bSgjelinek 31410209230bSgjelinek /* 31420209230bSgjelinek * unqualified dataset removal. remove all datasets but prompt if more 31430209230bSgjelinek * than one. 31440209230bSgjelinek */ 31450209230bSgjelinek if (!prompt_remove_resource(cmd, "dataset")) 31460209230bSgjelinek return; 31470209230bSgjelinek 31480209230bSgjelinek if ((err = zonecfg_del_all_resources(handle, "dataset")) != Z_OK) 3149bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_DATASET, err, B_TRUE); 31500209230bSgjelinek else 3151bbec428eSgjelinek need_to_commit = B_TRUE; 31520209230bSgjelinek } 31530209230bSgjelinek 31540209230bSgjelinek static void 31550209230bSgjelinek remove_rctl(cmd_t *cmd) 31560209230bSgjelinek { 31570209230bSgjelinek int err; 31580209230bSgjelinek 31590209230bSgjelinek /* traditional, qualified rctl removal */ 31600209230bSgjelinek if (cmd->cmd_prop_nv_pairs > 0) { 31610209230bSgjelinek struct zone_rctltab rctltab; 31620209230bSgjelinek 3163bbec428eSgjelinek if ((err = fill_in_rctltab(cmd, &rctltab, B_FALSE)) != Z_OK) { 3164bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_RCTL, err, B_TRUE); 31657c478bd9Sstevel@tonic-gate return; 31667c478bd9Sstevel@tonic-gate } 31677c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_rctl(handle, &rctltab)) != Z_OK) 3168bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_RCTL, err, B_TRUE); 31697c478bd9Sstevel@tonic-gate else 3170bbec428eSgjelinek need_to_commit = B_TRUE; 31717c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctltab.zone_rctl_valptr); 31727c478bd9Sstevel@tonic-gate return; 31737c478bd9Sstevel@tonic-gate } 31740209230bSgjelinek 31750209230bSgjelinek /* 31760209230bSgjelinek * unqualified rctl removal. remove all rctls but prompt if more 31770209230bSgjelinek * than one. 31780209230bSgjelinek */ 31790209230bSgjelinek if (!prompt_remove_resource(cmd, "rctl")) 31800209230bSgjelinek return; 31810209230bSgjelinek 31820209230bSgjelinek if ((err = zonecfg_del_all_resources(handle, "rctl")) != Z_OK) 3183bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_RCTL, err, B_TRUE); 31847c478bd9Sstevel@tonic-gate else 3185bbec428eSgjelinek need_to_commit = B_TRUE; 31860209230bSgjelinek } 31870209230bSgjelinek 31880209230bSgjelinek static void 31890209230bSgjelinek remove_pset() 31900209230bSgjelinek { 31910209230bSgjelinek int err; 31920209230bSgjelinek struct zone_psettab psettab; 31930209230bSgjelinek 31940209230bSgjelinek if ((err = zonecfg_lookup_pset(handle, &psettab)) != Z_OK) { 3195bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_DCPU, err, B_TRUE); 31960209230bSgjelinek return; 31970209230bSgjelinek } 31980209230bSgjelinek if ((err = zonecfg_delete_pset(handle)) != Z_OK) 3199bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_DCPU, err, B_TRUE); 32000209230bSgjelinek else 3201bbec428eSgjelinek need_to_commit = B_TRUE; 32020209230bSgjelinek } 32030209230bSgjelinek 32040209230bSgjelinek static void 3205c97ad5cdSakolb remove_pcap() 3206c97ad5cdSakolb { 3207c97ad5cdSakolb int err; 3208c97ad5cdSakolb uint64_t tmp; 3209c97ad5cdSakolb 3210c97ad5cdSakolb if (zonecfg_get_aliased_rctl(handle, ALIAS_CPUCAP, &tmp) != Z_OK) { 3211c97ad5cdSakolb zerr("%s %s: %s", cmd_to_str(CMD_REMOVE), rt_to_str(RT_PCAP), 3212c97ad5cdSakolb zonecfg_strerror(Z_NO_RESOURCE_TYPE)); 3213bbec428eSgjelinek saw_error = B_TRUE; 3214c97ad5cdSakolb return; 3215c97ad5cdSakolb } 3216c97ad5cdSakolb 3217c97ad5cdSakolb if ((err = zonecfg_rm_aliased_rctl(handle, ALIAS_CPUCAP)) != Z_OK) 3218bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_PCAP, err, B_TRUE); 3219c97ad5cdSakolb else 3220bbec428eSgjelinek need_to_commit = B_TRUE; 3221c97ad5cdSakolb } 3222c97ad5cdSakolb 3223c97ad5cdSakolb static void 32240209230bSgjelinek remove_mcap() 32250209230bSgjelinek { 32260209230bSgjelinek int err, res1, res2, res3; 32270209230bSgjelinek uint64_t tmp; 32280209230bSgjelinek struct zone_mcaptab mcaptab; 32290209230bSgjelinek boolean_t revert = B_FALSE; 32300209230bSgjelinek 32310209230bSgjelinek res1 = zonecfg_lookup_mcap(handle, &mcaptab); 32320209230bSgjelinek res2 = zonecfg_get_aliased_rctl(handle, ALIAS_MAXSWAP, &tmp); 32330209230bSgjelinek res3 = zonecfg_get_aliased_rctl(handle, ALIAS_MAXLOCKEDMEM, &tmp); 32340209230bSgjelinek 32350209230bSgjelinek /* if none of these exist, there is no resource to remove */ 32360209230bSgjelinek if (res1 != Z_OK && res2 != Z_OK && res3 != Z_OK) { 32370209230bSgjelinek zerr("%s %s: %s", cmd_to_str(CMD_REMOVE), rt_to_str(RT_MCAP), 32380209230bSgjelinek zonecfg_strerror(Z_NO_RESOURCE_TYPE)); 3239bbec428eSgjelinek saw_error = B_TRUE; 32400209230bSgjelinek return; 32410209230bSgjelinek } 32420209230bSgjelinek if (res1 == Z_OK) { 32430209230bSgjelinek if ((err = zonecfg_delete_mcap(handle)) != Z_OK) { 3244bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_MCAP, err, B_TRUE); 32450209230bSgjelinek revert = B_TRUE; 32460209230bSgjelinek } else { 3247bbec428eSgjelinek need_to_commit = B_TRUE; 32480209230bSgjelinek } 32490209230bSgjelinek } 32500209230bSgjelinek if (res2 == Z_OK) { 32510209230bSgjelinek if ((err = zonecfg_rm_aliased_rctl(handle, ALIAS_MAXSWAP)) 32520209230bSgjelinek != Z_OK) { 3253bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_MCAP, err, B_TRUE); 32540209230bSgjelinek revert = B_TRUE; 32550209230bSgjelinek } else { 3256bbec428eSgjelinek need_to_commit = B_TRUE; 32570209230bSgjelinek } 32580209230bSgjelinek } 32590209230bSgjelinek if (res3 == Z_OK) { 32600209230bSgjelinek if ((err = zonecfg_rm_aliased_rctl(handle, ALIAS_MAXLOCKEDMEM)) 32610209230bSgjelinek != Z_OK) { 3262bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_MCAP, err, B_TRUE); 32630209230bSgjelinek revert = B_TRUE; 32640209230bSgjelinek } else { 3265bbec428eSgjelinek need_to_commit = B_TRUE; 32660209230bSgjelinek } 32670209230bSgjelinek } 32680209230bSgjelinek 32690209230bSgjelinek if (revert) 3270bbec428eSgjelinek need_to_commit = B_FALSE; 32710209230bSgjelinek } 32720209230bSgjelinek 32730209230bSgjelinek static void 3274cb8a054bSGlenn Faden remove_admin(cmd_t *cmd) 3275cb8a054bSGlenn Faden { 3276cb8a054bSGlenn Faden int err; 3277cb8a054bSGlenn Faden 3278cb8a054bSGlenn Faden /* traditional, qualified attr removal */ 3279cb8a054bSGlenn Faden if (cmd->cmd_prop_nv_pairs > 0) { 3280cb8a054bSGlenn Faden struct zone_admintab admintab; 3281cb8a054bSGlenn Faden 3282cb8a054bSGlenn Faden if ((err = fill_in_admintab(cmd, &admintab, B_FALSE)) != Z_OK) { 3283cb8a054bSGlenn Faden z_cmd_rt_perror(CMD_REMOVE, RT_ADMIN, 3284cb8a054bSGlenn Faden err, B_TRUE); 3285cb8a054bSGlenn Faden return; 3286cb8a054bSGlenn Faden } 3287cb8a054bSGlenn Faden if ((err = zonecfg_delete_admin(handle, &admintab, 3288cb8a054bSGlenn Faden zone)) 3289cb8a054bSGlenn Faden != Z_OK) 3290cb8a054bSGlenn Faden z_cmd_rt_perror(CMD_REMOVE, RT_ADMIN, 3291cb8a054bSGlenn Faden err, B_TRUE); 3292cb8a054bSGlenn Faden else 3293cb8a054bSGlenn Faden need_to_commit = B_TRUE; 3294cb8a054bSGlenn Faden return; 3295cb8a054bSGlenn Faden } else { 3296cb8a054bSGlenn Faden /* 3297cb8a054bSGlenn Faden * unqualified admin removal. 3298cb8a054bSGlenn Faden * remove all admins but prompt if more 3299cb8a054bSGlenn Faden * than one. 3300cb8a054bSGlenn Faden */ 3301cb8a054bSGlenn Faden if (!prompt_remove_resource(cmd, "admin")) 3302cb8a054bSGlenn Faden return; 3303cb8a054bSGlenn Faden 3304cb8a054bSGlenn Faden if ((err = zonecfg_delete_admins(handle, zone)) 3305cb8a054bSGlenn Faden != Z_OK) 3306cb8a054bSGlenn Faden z_cmd_rt_perror(CMD_REMOVE, RT_ADMIN, 3307cb8a054bSGlenn Faden err, B_TRUE); 3308cb8a054bSGlenn Faden else 3309cb8a054bSGlenn Faden need_to_commit = B_TRUE; 3310cb8a054bSGlenn Faden } 3311cb8a054bSGlenn Faden } 3312cb8a054bSGlenn Faden 3313cb8a054bSGlenn Faden static void 33140209230bSgjelinek remove_resource(cmd_t *cmd) 33150209230bSgjelinek { 33160209230bSgjelinek int type; 33170209230bSgjelinek int arg; 3318bbec428eSgjelinek boolean_t arg_err = B_FALSE; 33190209230bSgjelinek 33200209230bSgjelinek if ((type = cmd->cmd_res_type) == RT_UNKNOWN) { 3321bbec428eSgjelinek long_usage(CMD_REMOVE, B_TRUE); 33220209230bSgjelinek return; 33230209230bSgjelinek } 33240209230bSgjelinek 33250209230bSgjelinek optind = 0; 33260209230bSgjelinek while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?F")) != EOF) { 33270209230bSgjelinek switch (arg) { 33280209230bSgjelinek case '?': 33290209230bSgjelinek longer_usage(CMD_REMOVE); 3330bbec428eSgjelinek arg_err = B_TRUE; 33317ec75eb8Sgjelinek break; 33320209230bSgjelinek case 'F': 33330209230bSgjelinek break; 33340209230bSgjelinek default: 33350209230bSgjelinek short_usage(CMD_REMOVE); 3336bbec428eSgjelinek arg_err = B_TRUE; 33377ec75eb8Sgjelinek break; 33387ec75eb8Sgjelinek } 33397ec75eb8Sgjelinek } 33407ec75eb8Sgjelinek if (arg_err) 33410209230bSgjelinek return; 33420209230bSgjelinek 3343bbec428eSgjelinek if (initialize(B_TRUE) != Z_OK) 33440209230bSgjelinek return; 33450209230bSgjelinek 33460209230bSgjelinek switch (type) { 33470209230bSgjelinek case RT_FS: 33480209230bSgjelinek remove_fs(cmd); 33490209230bSgjelinek return; 33500209230bSgjelinek case RT_IPD: 33510209230bSgjelinek remove_ipd(cmd); 33520209230bSgjelinek return; 33530209230bSgjelinek case RT_NET: 33540209230bSgjelinek remove_net(cmd); 33550209230bSgjelinek return; 33560209230bSgjelinek case RT_DEVICE: 33570209230bSgjelinek remove_device(cmd); 33580209230bSgjelinek return; 33590209230bSgjelinek case RT_RCTL: 33600209230bSgjelinek remove_rctl(cmd); 33610209230bSgjelinek return; 33620209230bSgjelinek case RT_ATTR: 33630209230bSgjelinek remove_attr(cmd); 33647c478bd9Sstevel@tonic-gate return; 3365fa9e4066Sahrens case RT_DATASET: 33660209230bSgjelinek remove_dataset(cmd); 3367fa9e4066Sahrens return; 33680209230bSgjelinek case RT_DCPU: 33690209230bSgjelinek remove_pset(); 33700209230bSgjelinek return; 3371c97ad5cdSakolb case RT_PCAP: 3372c97ad5cdSakolb remove_pcap(); 3373c97ad5cdSakolb return; 33740209230bSgjelinek case RT_MCAP: 33750209230bSgjelinek remove_mcap(); 3376fa9e4066Sahrens return; 3377cb8a054bSGlenn Faden case RT_ADMIN: 3378cb8a054bSGlenn Faden remove_admin(cmd); 3379cb8a054bSGlenn Faden return; 33807c478bd9Sstevel@tonic-gate default: 3381bbec428eSgjelinek zone_perror(rt_to_str(type), Z_NO_RESOURCE_TYPE, B_TRUE); 3382bbec428eSgjelinek long_usage(CMD_REMOVE, B_TRUE); 3383bbec428eSgjelinek usage(B_FALSE, HELP_RESOURCES); 33847c478bd9Sstevel@tonic-gate return; 33857c478bd9Sstevel@tonic-gate } 33867c478bd9Sstevel@tonic-gate } 33877c478bd9Sstevel@tonic-gate 33887c478bd9Sstevel@tonic-gate static void 33897c478bd9Sstevel@tonic-gate remove_property(cmd_t *cmd) 33907c478bd9Sstevel@tonic-gate { 33917c478bd9Sstevel@tonic-gate char *prop_id; 33927c478bd9Sstevel@tonic-gate int err, res_type, prop_type; 33937c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 33947c478bd9Sstevel@tonic-gate struct zone_rctlvaltab *rctlvaltab; 33957c478bd9Sstevel@tonic-gate complex_property_ptr_t cx; 33967c478bd9Sstevel@tonic-gate 33977c478bd9Sstevel@tonic-gate res_type = resource_scope; 33987c478bd9Sstevel@tonic-gate prop_type = cmd->cmd_prop_name[0]; 33997c478bd9Sstevel@tonic-gate if (res_type == RT_UNKNOWN || prop_type == PT_UNKNOWN) { 3400bbec428eSgjelinek long_usage(CMD_REMOVE, B_TRUE); 34017c478bd9Sstevel@tonic-gate return; 34027c478bd9Sstevel@tonic-gate } 34037c478bd9Sstevel@tonic-gate 34047c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs != 1) { 3405bbec428eSgjelinek long_usage(CMD_ADD, B_TRUE); 34067c478bd9Sstevel@tonic-gate return; 34077c478bd9Sstevel@tonic-gate } 34087c478bd9Sstevel@tonic-gate 3409bbec428eSgjelinek if (initialize(B_TRUE) != Z_OK) 34107c478bd9Sstevel@tonic-gate return; 34117c478bd9Sstevel@tonic-gate 34127c478bd9Sstevel@tonic-gate switch (res_type) { 34137c478bd9Sstevel@tonic-gate case RT_FS: 34147c478bd9Sstevel@tonic-gate if (prop_type != PT_OPTIONS) { 34157c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 3416bbec428eSgjelinek B_TRUE); 3417bbec428eSgjelinek long_usage(CMD_REMOVE, B_TRUE); 3418bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 34197c478bd9Sstevel@tonic-gate return; 34207c478bd9Sstevel@tonic-gate } 34217c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[0]; 34227c478bd9Sstevel@tonic-gate if (pp->pv_type == PROP_VAL_COMPLEX) { 34237c478bd9Sstevel@tonic-gate zerr(gettext("A %s or %s value was expected here."), 34247c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_SIMPLE), 34257c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_LIST)); 3426bbec428eSgjelinek saw_error = B_TRUE; 34277c478bd9Sstevel@tonic-gate return; 34287c478bd9Sstevel@tonic-gate } 34297c478bd9Sstevel@tonic-gate if (pp->pv_type == PROP_VAL_SIMPLE) { 34307c478bd9Sstevel@tonic-gate if (pp->pv_simple == NULL) { 3431bbec428eSgjelinek long_usage(CMD_ADD, B_TRUE); 34327c478bd9Sstevel@tonic-gate return; 34337c478bd9Sstevel@tonic-gate } 34347c478bd9Sstevel@tonic-gate prop_id = pp->pv_simple; 34357c478bd9Sstevel@tonic-gate err = zonecfg_remove_fs_option(&in_progress_fstab, 34367c478bd9Sstevel@tonic-gate prop_id); 34377c478bd9Sstevel@tonic-gate if (err != Z_OK) 3438bbec428eSgjelinek zone_perror(pt_to_str(prop_type), err, B_TRUE); 34397c478bd9Sstevel@tonic-gate } else { 34407c478bd9Sstevel@tonic-gate list_property_ptr_t list; 34417c478bd9Sstevel@tonic-gate 34427c478bd9Sstevel@tonic-gate for (list = pp->pv_list; list != NULL; 34437c478bd9Sstevel@tonic-gate list = list->lp_next) { 34447c478bd9Sstevel@tonic-gate prop_id = list->lp_simple; 34457c478bd9Sstevel@tonic-gate if (prop_id == NULL) 34467c478bd9Sstevel@tonic-gate break; 34477c478bd9Sstevel@tonic-gate err = zonecfg_remove_fs_option( 34487c478bd9Sstevel@tonic-gate &in_progress_fstab, prop_id); 34497c478bd9Sstevel@tonic-gate if (err != Z_OK) 34507c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), err, 3451bbec428eSgjelinek B_TRUE); 34527c478bd9Sstevel@tonic-gate } 34537c478bd9Sstevel@tonic-gate } 34547c478bd9Sstevel@tonic-gate return; 34557c478bd9Sstevel@tonic-gate case RT_RCTL: 34567c478bd9Sstevel@tonic-gate if (prop_type != PT_VALUE) { 34577c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 3458bbec428eSgjelinek B_TRUE); 3459bbec428eSgjelinek long_usage(CMD_REMOVE, B_TRUE); 3460bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 34617c478bd9Sstevel@tonic-gate return; 34627c478bd9Sstevel@tonic-gate } 34637c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[0]; 34647c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_COMPLEX) { 34657c478bd9Sstevel@tonic-gate zerr(gettext("A %s value was expected here."), 34667c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_COMPLEX)); 3467bbec428eSgjelinek saw_error = B_TRUE; 34687c478bd9Sstevel@tonic-gate return; 34697c478bd9Sstevel@tonic-gate } 34707c478bd9Sstevel@tonic-gate if ((rctlvaltab = alloc_rctlvaltab()) == NULL) { 3471bbec428eSgjelinek zone_perror(zone, Z_NOMEM, B_TRUE); 34727c478bd9Sstevel@tonic-gate exit(Z_ERR); 34737c478bd9Sstevel@tonic-gate } 34747c478bd9Sstevel@tonic-gate for (cx = pp->pv_complex; cx != NULL; cx = cx->cp_next) { 34757c478bd9Sstevel@tonic-gate switch (cx->cp_type) { 34767c478bd9Sstevel@tonic-gate case PT_PRIV: 34777c478bd9Sstevel@tonic-gate (void) strlcpy(rctlvaltab->zone_rctlval_priv, 34787c478bd9Sstevel@tonic-gate cx->cp_value, 34797c478bd9Sstevel@tonic-gate sizeof (rctlvaltab->zone_rctlval_priv)); 34807c478bd9Sstevel@tonic-gate break; 34817c478bd9Sstevel@tonic-gate case PT_LIMIT: 34827c478bd9Sstevel@tonic-gate (void) strlcpy(rctlvaltab->zone_rctlval_limit, 34837c478bd9Sstevel@tonic-gate cx->cp_value, 34847c478bd9Sstevel@tonic-gate sizeof (rctlvaltab->zone_rctlval_limit)); 34857c478bd9Sstevel@tonic-gate break; 34867c478bd9Sstevel@tonic-gate case PT_ACTION: 34877c478bd9Sstevel@tonic-gate (void) strlcpy(rctlvaltab->zone_rctlval_action, 34887c478bd9Sstevel@tonic-gate cx->cp_value, 34897c478bd9Sstevel@tonic-gate sizeof (rctlvaltab->zone_rctlval_action)); 34907c478bd9Sstevel@tonic-gate break; 34917c478bd9Sstevel@tonic-gate default: 34927c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), 3493bbec428eSgjelinek Z_NO_PROPERTY_TYPE, B_TRUE); 3494bbec428eSgjelinek long_usage(CMD_ADD, B_TRUE); 3495bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 34967c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctlvaltab); 34977c478bd9Sstevel@tonic-gate return; 34987c478bd9Sstevel@tonic-gate } 34997c478bd9Sstevel@tonic-gate } 35007c478bd9Sstevel@tonic-gate rctlvaltab->zone_rctlval_next = NULL; 35017c478bd9Sstevel@tonic-gate err = zonecfg_remove_rctl_value(&in_progress_rctltab, 35027c478bd9Sstevel@tonic-gate rctlvaltab); 35037c478bd9Sstevel@tonic-gate if (err != Z_OK) 3504bbec428eSgjelinek zone_perror(pt_to_str(prop_type), err, B_TRUE); 35057c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctlvaltab); 35067c478bd9Sstevel@tonic-gate return; 3507de860bd9Sgfaden case RT_NET: 3508de860bd9Sgfaden if (prop_type != PT_DEFROUTER) { 3509de860bd9Sgfaden zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 3510bbec428eSgjelinek B_TRUE); 3511bbec428eSgjelinek long_usage(CMD_REMOVE, B_TRUE); 3512bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 3513de860bd9Sgfaden return; 3514de860bd9Sgfaden } else { 3515de860bd9Sgfaden bzero(&in_progress_nwiftab.zone_nwif_defrouter, 3516de860bd9Sgfaden sizeof (in_progress_nwiftab.zone_nwif_defrouter)); 3517de860bd9Sgfaden return; 3518de860bd9Sgfaden } 35197c478bd9Sstevel@tonic-gate default: 3520bbec428eSgjelinek zone_perror(rt_to_str(res_type), Z_NO_RESOURCE_TYPE, B_TRUE); 3521bbec428eSgjelinek long_usage(CMD_REMOVE, B_TRUE); 3522bbec428eSgjelinek usage(B_FALSE, HELP_RESOURCES); 35237c478bd9Sstevel@tonic-gate return; 35247c478bd9Sstevel@tonic-gate } 35257c478bd9Sstevel@tonic-gate } 35267c478bd9Sstevel@tonic-gate 35277c478bd9Sstevel@tonic-gate void 35287c478bd9Sstevel@tonic-gate remove_func(cmd_t *cmd) 35297c478bd9Sstevel@tonic-gate { 35307c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_REMOVE)) 35317c478bd9Sstevel@tonic-gate return; 35327c478bd9Sstevel@tonic-gate 35337c478bd9Sstevel@tonic-gate assert(cmd != NULL); 35347c478bd9Sstevel@tonic-gate 35350209230bSgjelinek if (global_scope) { 35360209230bSgjelinek if (gz_invalid_resource(cmd->cmd_res_type)) { 35370209230bSgjelinek zerr(gettext("%s is not a valid resource for the " 35380209230bSgjelinek "global zone."), rt_to_str(cmd->cmd_res_type)); 3539bbec428eSgjelinek saw_error = B_TRUE; 35400209230bSgjelinek return; 35410209230bSgjelinek } 35427c478bd9Sstevel@tonic-gate remove_resource(cmd); 35430209230bSgjelinek } else { 35447c478bd9Sstevel@tonic-gate remove_property(cmd); 35457c478bd9Sstevel@tonic-gate } 35460209230bSgjelinek } 35470209230bSgjelinek 35480209230bSgjelinek static void 35490209230bSgjelinek clear_property(cmd_t *cmd) 35500209230bSgjelinek { 35510209230bSgjelinek int res_type, prop_type; 35520209230bSgjelinek 35530209230bSgjelinek res_type = resource_scope; 35540209230bSgjelinek prop_type = cmd->cmd_res_type; 35550209230bSgjelinek if (res_type == RT_UNKNOWN || prop_type == PT_UNKNOWN) { 3556bbec428eSgjelinek long_usage(CMD_CLEAR, B_TRUE); 35570209230bSgjelinek return; 35580209230bSgjelinek } 35590209230bSgjelinek 3560bbec428eSgjelinek if (initialize(B_TRUE) != Z_OK) 35610209230bSgjelinek return; 35620209230bSgjelinek 35630209230bSgjelinek switch (res_type) { 35640209230bSgjelinek case RT_FS: 35650209230bSgjelinek if (prop_type == PT_RAW) { 35660209230bSgjelinek in_progress_fstab.zone_fs_raw[0] = '\0'; 3567bbec428eSgjelinek need_to_commit = B_TRUE; 35680209230bSgjelinek return; 35690209230bSgjelinek } 35700209230bSgjelinek break; 35710209230bSgjelinek case RT_DCPU: 35720209230bSgjelinek if (prop_type == PT_IMPORTANCE) { 35730209230bSgjelinek in_progress_psettab.zone_importance[0] = '\0'; 3574bbec428eSgjelinek need_to_commit = B_TRUE; 35750209230bSgjelinek return; 35760209230bSgjelinek } 35770209230bSgjelinek break; 35780209230bSgjelinek case RT_MCAP: 35790209230bSgjelinek switch (prop_type) { 35800209230bSgjelinek case PT_PHYSICAL: 35810209230bSgjelinek in_progress_mcaptab.zone_physmem_cap[0] = '\0'; 3582bbec428eSgjelinek need_to_commit = B_TRUE; 35830209230bSgjelinek return; 35840209230bSgjelinek case PT_SWAP: 35850209230bSgjelinek remove_aliased_rctl(PT_SWAP, ALIAS_MAXSWAP); 35860209230bSgjelinek return; 35870209230bSgjelinek case PT_LOCKED: 35880209230bSgjelinek remove_aliased_rctl(PT_LOCKED, ALIAS_MAXLOCKEDMEM); 35890209230bSgjelinek return; 35900209230bSgjelinek } 35910209230bSgjelinek break; 35920209230bSgjelinek default: 35930209230bSgjelinek break; 35940209230bSgjelinek } 35950209230bSgjelinek 3596bbec428eSgjelinek zone_perror(pt_to_str(prop_type), Z_CLEAR_DISALLOW, B_TRUE); 35970209230bSgjelinek } 35980209230bSgjelinek 35990209230bSgjelinek static void 36000209230bSgjelinek clear_global(cmd_t *cmd) 36010209230bSgjelinek { 36020209230bSgjelinek int err, type; 36030209230bSgjelinek 36040209230bSgjelinek if ((type = cmd->cmd_res_type) == RT_UNKNOWN) { 3605bbec428eSgjelinek long_usage(CMD_CLEAR, B_TRUE); 36060209230bSgjelinek return; 36070209230bSgjelinek } 36080209230bSgjelinek 3609bbec428eSgjelinek if (initialize(B_TRUE) != Z_OK) 36100209230bSgjelinek return; 36110209230bSgjelinek 36120209230bSgjelinek switch (type) { 36130209230bSgjelinek case PT_ZONENAME: 36140209230bSgjelinek /* FALLTHRU */ 36150209230bSgjelinek case PT_ZONEPATH: 36160209230bSgjelinek /* FALLTHRU */ 36170209230bSgjelinek case PT_BRAND: 3618bbec428eSgjelinek zone_perror(pt_to_str(type), Z_CLEAR_DISALLOW, B_TRUE); 36190209230bSgjelinek return; 36200209230bSgjelinek case PT_AUTOBOOT: 36210209230bSgjelinek /* false is default; we'll treat as equivalent to clearing */ 36220209230bSgjelinek if ((err = zonecfg_set_autoboot(handle, B_FALSE)) != Z_OK) 3623bbec428eSgjelinek z_cmd_rt_perror(CMD_CLEAR, RT_AUTOBOOT, err, B_TRUE); 36240209230bSgjelinek else 3625bbec428eSgjelinek need_to_commit = B_TRUE; 36260209230bSgjelinek return; 36270209230bSgjelinek case PT_POOL: 36280209230bSgjelinek if ((err = zonecfg_set_pool(handle, NULL)) != Z_OK) 3629bbec428eSgjelinek z_cmd_rt_perror(CMD_CLEAR, RT_POOL, err, B_TRUE); 36300209230bSgjelinek else 3631bbec428eSgjelinek need_to_commit = B_TRUE; 36320209230bSgjelinek return; 36330209230bSgjelinek case PT_LIMITPRIV: 36340209230bSgjelinek if ((err = zonecfg_set_limitpriv(handle, NULL)) != Z_OK) 3635bbec428eSgjelinek z_cmd_rt_perror(CMD_CLEAR, RT_LIMITPRIV, err, B_TRUE); 36360209230bSgjelinek else 3637bbec428eSgjelinek need_to_commit = B_TRUE; 36380209230bSgjelinek return; 36390209230bSgjelinek case PT_BOOTARGS: 36400209230bSgjelinek if ((err = zonecfg_set_bootargs(handle, NULL)) != Z_OK) 3641bbec428eSgjelinek z_cmd_rt_perror(CMD_CLEAR, RT_BOOTARGS, err, B_TRUE); 36420209230bSgjelinek else 3643bbec428eSgjelinek need_to_commit = B_TRUE; 36440209230bSgjelinek return; 36450209230bSgjelinek case PT_SCHED: 36460209230bSgjelinek if ((err = zonecfg_set_sched(handle, NULL)) != Z_OK) 3647bbec428eSgjelinek z_cmd_rt_perror(CMD_CLEAR, RT_SCHED, err, B_TRUE); 36480209230bSgjelinek else 3649bbec428eSgjelinek need_to_commit = B_TRUE; 36500209230bSgjelinek return; 3651f4b3ec61Sdh155122 case PT_IPTYPE: 3652f4b3ec61Sdh155122 /* shared is default; we'll treat as equivalent to clearing */ 3653f4b3ec61Sdh155122 if ((err = zonecfg_set_iptype(handle, ZS_SHARED)) != Z_OK) 3654bbec428eSgjelinek z_cmd_rt_perror(CMD_CLEAR, RT_IPTYPE, err, B_TRUE); 3655f4b3ec61Sdh155122 else 3656bbec428eSgjelinek need_to_commit = B_TRUE; 3657f4b3ec61Sdh155122 return; 36580209230bSgjelinek case PT_MAXLWPS: 36590209230bSgjelinek remove_aliased_rctl(PT_MAXLWPS, ALIAS_MAXLWPS); 36600209230bSgjelinek return; 36610209230bSgjelinek case PT_MAXSHMMEM: 36620209230bSgjelinek remove_aliased_rctl(PT_MAXSHMMEM, ALIAS_MAXSHMMEM); 36630209230bSgjelinek return; 36640209230bSgjelinek case PT_MAXSHMIDS: 36650209230bSgjelinek remove_aliased_rctl(PT_MAXSHMIDS, ALIAS_MAXSHMIDS); 36660209230bSgjelinek return; 36670209230bSgjelinek case PT_MAXMSGIDS: 36680209230bSgjelinek remove_aliased_rctl(PT_MAXMSGIDS, ALIAS_MAXMSGIDS); 36690209230bSgjelinek return; 36700209230bSgjelinek case PT_MAXSEMIDS: 36710209230bSgjelinek remove_aliased_rctl(PT_MAXSEMIDS, ALIAS_MAXSEMIDS); 36720209230bSgjelinek return; 36730209230bSgjelinek case PT_SHARES: 36740209230bSgjelinek remove_aliased_rctl(PT_SHARES, ALIAS_SHARES); 36750209230bSgjelinek return; 36765679c89fSjv227347 case PT_HOSTID: 36775679c89fSjv227347 if ((err = zonecfg_set_hostid(handle, NULL)) != Z_OK) 36785679c89fSjv227347 z_cmd_rt_perror(CMD_CLEAR, RT_HOSTID, err, B_TRUE); 36795679c89fSjv227347 else 36805679c89fSjv227347 need_to_commit = B_TRUE; 36815679c89fSjv227347 return; 36820209230bSgjelinek default: 3683bbec428eSgjelinek zone_perror(pt_to_str(type), Z_NO_PROPERTY_TYPE, B_TRUE); 3684bbec428eSgjelinek long_usage(CMD_CLEAR, B_TRUE); 3685bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 36860209230bSgjelinek return; 36870209230bSgjelinek } 36880209230bSgjelinek } 36890209230bSgjelinek 36900209230bSgjelinek void 36910209230bSgjelinek clear_func(cmd_t *cmd) 36920209230bSgjelinek { 36930209230bSgjelinek if (zone_is_read_only(CMD_CLEAR)) 36940209230bSgjelinek return; 36950209230bSgjelinek 36960209230bSgjelinek assert(cmd != NULL); 36970209230bSgjelinek 36980209230bSgjelinek if (global_scope) { 36990209230bSgjelinek if (gz_invalid_property(cmd->cmd_res_type)) { 37000209230bSgjelinek zerr(gettext("%s is not a valid property for the " 37010209230bSgjelinek "global zone."), pt_to_str(cmd->cmd_res_type)); 3702bbec428eSgjelinek saw_error = B_TRUE; 37030209230bSgjelinek return; 37040209230bSgjelinek } 37050209230bSgjelinek 37060209230bSgjelinek clear_global(cmd); 37070209230bSgjelinek } else { 37080209230bSgjelinek clear_property(cmd); 37090209230bSgjelinek } 37100209230bSgjelinek } 37117c478bd9Sstevel@tonic-gate 37127c478bd9Sstevel@tonic-gate void 37137c478bd9Sstevel@tonic-gate select_func(cmd_t *cmd) 37147c478bd9Sstevel@tonic-gate { 37150209230bSgjelinek int type, err, res; 37160209230bSgjelinek uint64_t limit; 3717c97ad5cdSakolb uint64_t tmp; 37187c478bd9Sstevel@tonic-gate 37197c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_SELECT)) 37207c478bd9Sstevel@tonic-gate return; 37217c478bd9Sstevel@tonic-gate 37227c478bd9Sstevel@tonic-gate assert(cmd != NULL); 37237c478bd9Sstevel@tonic-gate 37247c478bd9Sstevel@tonic-gate if (global_scope) { 3725bbec428eSgjelinek global_scope = B_FALSE; 37267c478bd9Sstevel@tonic-gate resource_scope = cmd->cmd_res_type; 37277c478bd9Sstevel@tonic-gate end_op = CMD_SELECT; 37287c478bd9Sstevel@tonic-gate } else { 37297c478bd9Sstevel@tonic-gate scope_usage(CMD_SELECT); 37307c478bd9Sstevel@tonic-gate return; 37317c478bd9Sstevel@tonic-gate } 37327c478bd9Sstevel@tonic-gate 37337c478bd9Sstevel@tonic-gate if ((type = cmd->cmd_res_type) == RT_UNKNOWN) { 3734bbec428eSgjelinek long_usage(CMD_SELECT, B_TRUE); 37357c478bd9Sstevel@tonic-gate return; 37367c478bd9Sstevel@tonic-gate } 37377c478bd9Sstevel@tonic-gate 3738bbec428eSgjelinek if (initialize(B_TRUE) != Z_OK) 37397c478bd9Sstevel@tonic-gate return; 37407c478bd9Sstevel@tonic-gate 37417c478bd9Sstevel@tonic-gate switch (type) { 37427c478bd9Sstevel@tonic-gate case RT_FS: 3743bbec428eSgjelinek if ((err = fill_in_fstab(cmd, &old_fstab, B_FALSE)) != Z_OK) { 3744bbec428eSgjelinek z_cmd_rt_perror(CMD_SELECT, RT_FS, err, B_TRUE); 3745bbec428eSgjelinek global_scope = B_TRUE; 37467c478bd9Sstevel@tonic-gate } 37477c478bd9Sstevel@tonic-gate bcopy(&old_fstab, &in_progress_fstab, 37487c478bd9Sstevel@tonic-gate sizeof (struct zone_fstab)); 37497c478bd9Sstevel@tonic-gate return; 37507c478bd9Sstevel@tonic-gate case RT_IPD: 3751087719fdSdp if (state_atleast(ZONE_STATE_INCOMPLETE)) { 37527c478bd9Sstevel@tonic-gate zerr(gettext("Zone %s not in %s state; %s %s not " 37537c478bd9Sstevel@tonic-gate "allowed."), zone, 37547c478bd9Sstevel@tonic-gate zone_state_str(ZONE_STATE_CONFIGURED), 37557c478bd9Sstevel@tonic-gate cmd_to_str(CMD_SELECT), rt_to_str(RT_IPD)); 3756bbec428eSgjelinek global_scope = B_TRUE; 37577c478bd9Sstevel@tonic-gate end_op = -1; 37587c478bd9Sstevel@tonic-gate return; 37597c478bd9Sstevel@tonic-gate } 3760bbec428eSgjelinek if ((err = fill_in_ipdtab(cmd, &old_ipdtab, B_FALSE)) != Z_OK) { 3761bbec428eSgjelinek z_cmd_rt_perror(CMD_SELECT, RT_IPD, err, B_TRUE); 3762bbec428eSgjelinek global_scope = B_TRUE; 37637c478bd9Sstevel@tonic-gate } 37647c478bd9Sstevel@tonic-gate bcopy(&old_ipdtab, &in_progress_ipdtab, 37657c478bd9Sstevel@tonic-gate sizeof (struct zone_fstab)); 37667c478bd9Sstevel@tonic-gate return; 37677c478bd9Sstevel@tonic-gate case RT_NET: 3768bbec428eSgjelinek if ((err = fill_in_nwiftab(cmd, &old_nwiftab, B_FALSE)) 3769bbec428eSgjelinek != Z_OK) { 3770bbec428eSgjelinek z_cmd_rt_perror(CMD_SELECT, RT_NET, err, B_TRUE); 3771bbec428eSgjelinek global_scope = B_TRUE; 37727c478bd9Sstevel@tonic-gate } 37737c478bd9Sstevel@tonic-gate bcopy(&old_nwiftab, &in_progress_nwiftab, 37747c478bd9Sstevel@tonic-gate sizeof (struct zone_nwiftab)); 37757c478bd9Sstevel@tonic-gate return; 37767c478bd9Sstevel@tonic-gate case RT_DEVICE: 3777bbec428eSgjelinek if ((err = fill_in_devtab(cmd, &old_devtab, B_FALSE)) != Z_OK) { 3778bbec428eSgjelinek z_cmd_rt_perror(CMD_SELECT, RT_DEVICE, err, B_TRUE); 3779bbec428eSgjelinek global_scope = B_TRUE; 37807c478bd9Sstevel@tonic-gate } 37817c478bd9Sstevel@tonic-gate bcopy(&old_devtab, &in_progress_devtab, 37827c478bd9Sstevel@tonic-gate sizeof (struct zone_devtab)); 37837c478bd9Sstevel@tonic-gate return; 37847c478bd9Sstevel@tonic-gate case RT_RCTL: 3785bbec428eSgjelinek if ((err = fill_in_rctltab(cmd, &old_rctltab, B_FALSE)) 3786bbec428eSgjelinek != Z_OK) { 3787bbec428eSgjelinek z_cmd_rt_perror(CMD_SELECT, RT_RCTL, err, B_TRUE); 3788bbec428eSgjelinek global_scope = B_TRUE; 37897c478bd9Sstevel@tonic-gate } 37907c478bd9Sstevel@tonic-gate bcopy(&old_rctltab, &in_progress_rctltab, 37917c478bd9Sstevel@tonic-gate sizeof (struct zone_rctltab)); 37927c478bd9Sstevel@tonic-gate return; 37937c478bd9Sstevel@tonic-gate case RT_ATTR: 3794bbec428eSgjelinek if ((err = fill_in_attrtab(cmd, &old_attrtab, B_FALSE)) 3795bbec428eSgjelinek != Z_OK) { 3796bbec428eSgjelinek z_cmd_rt_perror(CMD_SELECT, RT_ATTR, err, B_TRUE); 3797bbec428eSgjelinek global_scope = B_TRUE; 37987c478bd9Sstevel@tonic-gate } 37997c478bd9Sstevel@tonic-gate bcopy(&old_attrtab, &in_progress_attrtab, 38007c478bd9Sstevel@tonic-gate sizeof (struct zone_attrtab)); 38017c478bd9Sstevel@tonic-gate return; 3802fa9e4066Sahrens case RT_DATASET: 3803bbec428eSgjelinek if ((err = fill_in_dstab(cmd, &old_dstab, B_FALSE)) != Z_OK) { 3804bbec428eSgjelinek z_cmd_rt_perror(CMD_SELECT, RT_DATASET, err, B_TRUE); 3805bbec428eSgjelinek global_scope = B_TRUE; 3806fa9e4066Sahrens } 3807fa9e4066Sahrens bcopy(&old_dstab, &in_progress_dstab, 3808fa9e4066Sahrens sizeof (struct zone_dstab)); 3809fa9e4066Sahrens return; 38100209230bSgjelinek case RT_DCPU: 38110209230bSgjelinek if ((err = zonecfg_lookup_pset(handle, &old_psettab)) != Z_OK) { 3812bbec428eSgjelinek z_cmd_rt_perror(CMD_SELECT, RT_DCPU, err, B_TRUE); 3813bbec428eSgjelinek global_scope = B_TRUE; 38140209230bSgjelinek } 38150209230bSgjelinek bcopy(&old_psettab, &in_progress_psettab, 38160209230bSgjelinek sizeof (struct zone_psettab)); 38170209230bSgjelinek return; 3818c97ad5cdSakolb case RT_PCAP: 3819c97ad5cdSakolb if ((err = zonecfg_get_aliased_rctl(handle, ALIAS_CPUCAP, &tmp)) 3820c97ad5cdSakolb != Z_OK) { 3821bbec428eSgjelinek z_cmd_rt_perror(CMD_SELECT, RT_PCAP, err, B_TRUE); 3822bbec428eSgjelinek global_scope = B_TRUE; 3823c97ad5cdSakolb } 3824c97ad5cdSakolb return; 38250209230bSgjelinek case RT_MCAP: 38260209230bSgjelinek /* if none of these exist, there is no resource to select */ 38270209230bSgjelinek if ((res = zonecfg_lookup_mcap(handle, &old_mcaptab)) != Z_OK && 38280209230bSgjelinek zonecfg_get_aliased_rctl(handle, ALIAS_MAXSWAP, &limit) 38290209230bSgjelinek != Z_OK && 38300209230bSgjelinek zonecfg_get_aliased_rctl(handle, ALIAS_MAXLOCKEDMEM, &limit) 38310209230bSgjelinek != Z_OK) { 38320209230bSgjelinek z_cmd_rt_perror(CMD_SELECT, RT_MCAP, Z_NO_RESOURCE_TYPE, 3833bbec428eSgjelinek B_TRUE); 3834bbec428eSgjelinek global_scope = B_TRUE; 38350209230bSgjelinek } 38360209230bSgjelinek if (res == Z_OK) 38370209230bSgjelinek bcopy(&old_mcaptab, &in_progress_mcaptab, 38380209230bSgjelinek sizeof (struct zone_mcaptab)); 38390209230bSgjelinek else 38400209230bSgjelinek bzero(&in_progress_mcaptab, 38410209230bSgjelinek sizeof (in_progress_mcaptab)); 38420209230bSgjelinek return; 3843cb8a054bSGlenn Faden case RT_ADMIN: 3844cb8a054bSGlenn Faden if ((err = fill_in_admintab(cmd, &old_admintab, B_FALSE)) 3845cb8a054bSGlenn Faden != Z_OK) { 3846cb8a054bSGlenn Faden z_cmd_rt_perror(CMD_SELECT, RT_ADMIN, err, 3847cb8a054bSGlenn Faden B_TRUE); 3848cb8a054bSGlenn Faden global_scope = B_TRUE; 3849cb8a054bSGlenn Faden } 3850cb8a054bSGlenn Faden bcopy(&old_admintab, &in_progress_admintab, 3851cb8a054bSGlenn Faden sizeof (struct zone_admintab)); 3852cb8a054bSGlenn Faden return; 38537c478bd9Sstevel@tonic-gate default: 3854bbec428eSgjelinek zone_perror(rt_to_str(type), Z_NO_RESOURCE_TYPE, B_TRUE); 3855bbec428eSgjelinek long_usage(CMD_SELECT, B_TRUE); 3856bbec428eSgjelinek usage(B_FALSE, HELP_RESOURCES); 38577c478bd9Sstevel@tonic-gate return; 38587c478bd9Sstevel@tonic-gate } 38597c478bd9Sstevel@tonic-gate } 38607c478bd9Sstevel@tonic-gate 38617c478bd9Sstevel@tonic-gate /* 38627c478bd9Sstevel@tonic-gate * Network "addresses" can be one of the following forms: 38637c478bd9Sstevel@tonic-gate * <IPv4 address> 38647c478bd9Sstevel@tonic-gate * <IPv4 address>/<prefix length> 38657c478bd9Sstevel@tonic-gate * <IPv6 address>/<prefix length> 38667c478bd9Sstevel@tonic-gate * <host name> 38677c478bd9Sstevel@tonic-gate * <host name>/<prefix length> 38687c478bd9Sstevel@tonic-gate * In other words, the "/" followed by a prefix length is allowed but not 38697c478bd9Sstevel@tonic-gate * required for IPv4 addresses and host names, and required for IPv6 addresses. 38707c478bd9Sstevel@tonic-gate * If a prefix length is given, it must be in the allowable range: 0 to 32 for 38717c478bd9Sstevel@tonic-gate * IPv4 addresses and host names, 0 to 128 for IPv6 addresses. 38727c478bd9Sstevel@tonic-gate * Host names must start with an alpha-numeric character, and all subsequent 38737c478bd9Sstevel@tonic-gate * characters must be either alpha-numeric or "-". 38747c478bd9Sstevel@tonic-gate */ 38757c478bd9Sstevel@tonic-gate 38767c478bd9Sstevel@tonic-gate static int 38777c478bd9Sstevel@tonic-gate validate_net_address_syntax(char *address) 38787c478bd9Sstevel@tonic-gate { 38797c478bd9Sstevel@tonic-gate char *slashp, part1[MAXHOSTNAMELEN]; 38807c478bd9Sstevel@tonic-gate struct in6_addr in6; 38817c478bd9Sstevel@tonic-gate struct in_addr in4; 38827c478bd9Sstevel@tonic-gate int prefixlen, i; 38837c478bd9Sstevel@tonic-gate 38847c478bd9Sstevel@tonic-gate /* 38857c478bd9Sstevel@tonic-gate * Copy the part before any '/' into part1 or copy the whole 38867c478bd9Sstevel@tonic-gate * thing if there is no '/'. 38877c478bd9Sstevel@tonic-gate */ 38887c478bd9Sstevel@tonic-gate if ((slashp = strchr(address, '/')) != NULL) { 38897c478bd9Sstevel@tonic-gate *slashp = '\0'; 38907c478bd9Sstevel@tonic-gate (void) strlcpy(part1, address, sizeof (part1)); 38917c478bd9Sstevel@tonic-gate *slashp = '/'; 38927c478bd9Sstevel@tonic-gate prefixlen = atoi(++slashp); 38937c478bd9Sstevel@tonic-gate } else { 38947c478bd9Sstevel@tonic-gate (void) strlcpy(part1, address, sizeof (part1)); 38957c478bd9Sstevel@tonic-gate } 38967c478bd9Sstevel@tonic-gate 38977c478bd9Sstevel@tonic-gate if (inet_pton(AF_INET6, part1, &in6) == 1) { 38987c478bd9Sstevel@tonic-gate if (slashp == NULL) { 38997c478bd9Sstevel@tonic-gate zerr(gettext("%s: IPv6 addresses " 39007c478bd9Sstevel@tonic-gate "require /prefix-length suffix."), address); 39017c478bd9Sstevel@tonic-gate return (Z_ERR); 39027c478bd9Sstevel@tonic-gate } 39037c478bd9Sstevel@tonic-gate if (prefixlen < 0 || prefixlen > 128) { 39047c478bd9Sstevel@tonic-gate zerr(gettext("%s: IPv6 address " 39057c478bd9Sstevel@tonic-gate "prefix lengths must be 0 - 128."), address); 39067c478bd9Sstevel@tonic-gate return (Z_ERR); 39077c478bd9Sstevel@tonic-gate } 39087c478bd9Sstevel@tonic-gate return (Z_OK); 39097c478bd9Sstevel@tonic-gate } 39107c478bd9Sstevel@tonic-gate 39117c478bd9Sstevel@tonic-gate /* At this point, any /prefix must be for IPv4. */ 39127c478bd9Sstevel@tonic-gate if (slashp != NULL) { 39137c478bd9Sstevel@tonic-gate if (prefixlen < 0 || prefixlen > 32) { 39147c478bd9Sstevel@tonic-gate zerr(gettext("%s: IPv4 address " 39157c478bd9Sstevel@tonic-gate "prefix lengths must be 0 - 32."), address); 39167c478bd9Sstevel@tonic-gate return (Z_ERR); 39177c478bd9Sstevel@tonic-gate } 39187c478bd9Sstevel@tonic-gate } 39197c478bd9Sstevel@tonic-gate if (inet_pton(AF_INET, part1, &in4) == 1) 39207c478bd9Sstevel@tonic-gate return (Z_OK); 39217c478bd9Sstevel@tonic-gate 39227c478bd9Sstevel@tonic-gate /* address may also be a host name */ 39237c478bd9Sstevel@tonic-gate if (!isalnum(part1[0])) { 39247c478bd9Sstevel@tonic-gate zerr(gettext("%s: bogus host name or network address syntax"), 39257c478bd9Sstevel@tonic-gate part1); 3926bbec428eSgjelinek saw_error = B_TRUE; 3927bbec428eSgjelinek usage(B_FALSE, HELP_NETADDR); 39287c478bd9Sstevel@tonic-gate return (Z_ERR); 39297c478bd9Sstevel@tonic-gate } 39307c478bd9Sstevel@tonic-gate for (i = 1; part1[i]; i++) 39317c478bd9Sstevel@tonic-gate if (!isalnum(part1[i]) && part1[i] != '-' && part1[i] != '.') { 39327c478bd9Sstevel@tonic-gate zerr(gettext("%s: bogus host name or " 39337c478bd9Sstevel@tonic-gate "network address syntax"), part1); 3934bbec428eSgjelinek saw_error = B_TRUE; 3935bbec428eSgjelinek usage(B_FALSE, HELP_NETADDR); 39367c478bd9Sstevel@tonic-gate return (Z_ERR); 39377c478bd9Sstevel@tonic-gate } 39387c478bd9Sstevel@tonic-gate return (Z_OK); 39397c478bd9Sstevel@tonic-gate } 39407c478bd9Sstevel@tonic-gate 39417c478bd9Sstevel@tonic-gate static int 3942c9f134eaSjv227347 validate_net_physical_syntax(const char *ifname) 39437c478bd9Sstevel@tonic-gate { 3944c9f134eaSjv227347 ifspec_t ifnameprop; 3945c9f134eaSjv227347 zone_iptype_t iptype; 3946c9f134eaSjv227347 394737b210dcSjv227347 if (zonecfg_get_iptype(handle, &iptype) != Z_OK) { 3948c9f134eaSjv227347 zerr(gettext("zone configuration has an invalid or nonexistent " 3949c9f134eaSjv227347 "ip-type property")); 39507c478bd9Sstevel@tonic-gate return (Z_ERR); 39517c478bd9Sstevel@tonic-gate } 3952c9f134eaSjv227347 switch (iptype) { 3953c9f134eaSjv227347 case ZS_SHARED: 3954c9f134eaSjv227347 if (ifparse_ifspec(ifname, &ifnameprop) == B_FALSE) { 3955c9f134eaSjv227347 zerr(gettext("%s: invalid physical interface name"), 3956c9f134eaSjv227347 ifname); 3957c9f134eaSjv227347 return (Z_ERR); 3958c9f134eaSjv227347 } 3959c9f134eaSjv227347 if (ifnameprop.ifsp_lunvalid) { 3960c9f134eaSjv227347 zerr(gettext("%s: LUNs not allowed in physical " 3961c9f134eaSjv227347 "interface names"), ifname); 3962c9f134eaSjv227347 return (Z_ERR); 3963c9f134eaSjv227347 } 3964c9f134eaSjv227347 break; 3965c9f134eaSjv227347 case ZS_EXCLUSIVE: 3966c9f134eaSjv227347 if (dladm_valid_linkname(ifname) == B_FALSE) { 3967c9f134eaSjv227347 if (strchr(ifname, ':') != NULL) 3968c9f134eaSjv227347 zerr(gettext("%s: physical interface name " 3969c9f134eaSjv227347 "required; logical interface name not " 3970c9f134eaSjv227347 "allowed"), ifname); 3971c9f134eaSjv227347 else 3972c9f134eaSjv227347 zerr(gettext("%s: invalid physical interface " 3973c9f134eaSjv227347 "name"), ifname); 3974c9f134eaSjv227347 return (Z_ERR); 3975c9f134eaSjv227347 } 3976c9f134eaSjv227347 break; 3977c9f134eaSjv227347 } 3978c9f134eaSjv227347 return (Z_OK); 3979c9f134eaSjv227347 } 39807c478bd9Sstevel@tonic-gate 39817c478bd9Sstevel@tonic-gate static boolean_t 39827c478bd9Sstevel@tonic-gate valid_fs_type(const char *type) 39837c478bd9Sstevel@tonic-gate { 39847c478bd9Sstevel@tonic-gate /* 39857c478bd9Sstevel@tonic-gate * Is this a valid path component? 39867c478bd9Sstevel@tonic-gate */ 39877c478bd9Sstevel@tonic-gate if (strlen(type) + 1 > MAXNAMELEN) 39887c478bd9Sstevel@tonic-gate return (B_FALSE); 39897c478bd9Sstevel@tonic-gate /* 39907c478bd9Sstevel@tonic-gate * Make sure a bad value for "type" doesn't make 39917c478bd9Sstevel@tonic-gate * /usr/lib/fs/<type>/mount turn into something else. 39927c478bd9Sstevel@tonic-gate */ 39937c478bd9Sstevel@tonic-gate if (strchr(type, '/') != NULL || type[0] == '\0' || 39947c478bd9Sstevel@tonic-gate strcmp(type, ".") == 0 || strcmp(type, "..") == 0) 39957c478bd9Sstevel@tonic-gate return (B_FALSE); 39967c478bd9Sstevel@tonic-gate /* 39977c478bd9Sstevel@tonic-gate * More detailed verification happens later by zoneadm(1m). 39987c478bd9Sstevel@tonic-gate */ 39997c478bd9Sstevel@tonic-gate return (B_TRUE); 40007c478bd9Sstevel@tonic-gate } 40017c478bd9Sstevel@tonic-gate 4002f4b3ec61Sdh155122 static boolean_t 4003f4b3ec61Sdh155122 allow_exclusive() 4004f4b3ec61Sdh155122 { 4005f4b3ec61Sdh155122 brand_handle_t bh; 4006f4b3ec61Sdh155122 char brand[MAXNAMELEN]; 4007f4b3ec61Sdh155122 boolean_t ret; 4008f4b3ec61Sdh155122 4009f4b3ec61Sdh155122 if (zonecfg_get_brand(handle, brand, sizeof (brand)) != Z_OK) { 4010f4b3ec61Sdh155122 zerr("%s: %s\n", zone, gettext("could not get zone brand")); 4011f4b3ec61Sdh155122 return (B_FALSE); 4012f4b3ec61Sdh155122 } 4013f4b3ec61Sdh155122 if ((bh = brand_open(brand)) == NULL) { 4014f4b3ec61Sdh155122 zerr("%s: %s\n", zone, gettext("unknown brand.")); 4015f4b3ec61Sdh155122 return (B_FALSE); 4016f4b3ec61Sdh155122 } 4017f4b3ec61Sdh155122 ret = brand_allow_exclusive_ip(bh); 4018f4b3ec61Sdh155122 brand_close(bh); 4019f4b3ec61Sdh155122 if (!ret) 4020f4b3ec61Sdh155122 zerr(gettext("%s cannot be '%s' when %s is '%s'."), 4021f4b3ec61Sdh155122 pt_to_str(PT_IPTYPE), "exclusive", 4022f4b3ec61Sdh155122 pt_to_str(PT_BRAND), brand); 4023f4b3ec61Sdh155122 return (ret); 4024f4b3ec61Sdh155122 } 4025f4b3ec61Sdh155122 40260209230bSgjelinek static void 40270209230bSgjelinek set_aliased_rctl(char *alias, int prop_type, char *s) 40280209230bSgjelinek { 40290209230bSgjelinek uint64_t limit; 40300209230bSgjelinek int err; 40310209230bSgjelinek char tmp[128]; 40320209230bSgjelinek 40330209230bSgjelinek if (global_zone && strcmp(alias, ALIAS_SHARES) != 0) 40340209230bSgjelinek zerr(gettext("WARNING: Setting a global zone resource " 40350209230bSgjelinek "control too low could deny\nservice " 40360209230bSgjelinek "to even the root user; " 40370209230bSgjelinek "this could render the system impossible\n" 40380209230bSgjelinek "to administer. Please use caution.")); 40390209230bSgjelinek 40400209230bSgjelinek /* convert memory based properties */ 40410209230bSgjelinek if (prop_type == PT_MAXSHMMEM) { 40420209230bSgjelinek if (!zonecfg_valid_memlimit(s, &limit)) { 40430209230bSgjelinek zerr(gettext("A non-negative number with a required " 40440209230bSgjelinek "scale suffix (K, M, G or T) was expected\nhere.")); 4045bbec428eSgjelinek saw_error = B_TRUE; 40460209230bSgjelinek return; 40470209230bSgjelinek } 40480209230bSgjelinek 40490209230bSgjelinek (void) snprintf(tmp, sizeof (tmp), "%llu", limit); 40500209230bSgjelinek s = tmp; 40510209230bSgjelinek } 40520209230bSgjelinek 40530209230bSgjelinek if (!zonecfg_aliased_rctl_ok(handle, alias)) { 4054bbec428eSgjelinek zone_perror(pt_to_str(prop_type), Z_ALIAS_DISALLOW, B_FALSE); 4055bbec428eSgjelinek saw_error = B_TRUE; 40560209230bSgjelinek } else if (!zonecfg_valid_alias_limit(alias, s, &limit)) { 40570209230bSgjelinek zerr(gettext("%s property is out of range."), 40580209230bSgjelinek pt_to_str(prop_type)); 4059bbec428eSgjelinek saw_error = B_TRUE; 40600209230bSgjelinek } else if ((err = zonecfg_set_aliased_rctl(handle, alias, limit)) 40610209230bSgjelinek != Z_OK) { 4062bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 4063bbec428eSgjelinek saw_error = B_TRUE; 40640209230bSgjelinek } else { 4065bbec428eSgjelinek need_to_commit = B_TRUE; 40660209230bSgjelinek } 40670209230bSgjelinek } 40680209230bSgjelinek 40697c478bd9Sstevel@tonic-gate void 40707c478bd9Sstevel@tonic-gate set_func(cmd_t *cmd) 40717c478bd9Sstevel@tonic-gate { 40727c478bd9Sstevel@tonic-gate char *prop_id; 4073555afedfScarlsonj int arg, err, res_type, prop_type; 40747c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 40757c478bd9Sstevel@tonic-gate boolean_t autoboot; 4076f4b3ec61Sdh155122 zone_iptype_t iptype; 4077bbec428eSgjelinek boolean_t force_set = B_FALSE; 40780209230bSgjelinek size_t physmem_size = sizeof (in_progress_mcaptab.zone_physmem_cap); 40790209230bSgjelinek uint64_t mem_cap, mem_limit; 4080c97ad5cdSakolb float cap; 4081c97ad5cdSakolb char *unitp; 40820209230bSgjelinek struct zone_psettab tmp_psettab; 4083bbec428eSgjelinek boolean_t arg_err = B_FALSE; 40847c478bd9Sstevel@tonic-gate 40857c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_SET)) 40867c478bd9Sstevel@tonic-gate return; 40877c478bd9Sstevel@tonic-gate 40887c478bd9Sstevel@tonic-gate assert(cmd != NULL); 40897c478bd9Sstevel@tonic-gate 4090555afedfScarlsonj optind = opterr = 0; 4091555afedfScarlsonj while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "F")) != EOF) { 4092555afedfScarlsonj switch (arg) { 4093555afedfScarlsonj case 'F': 4094bbec428eSgjelinek force_set = B_TRUE; 4095555afedfScarlsonj break; 4096555afedfScarlsonj default: 4097555afedfScarlsonj if (optopt == '?') 4098555afedfScarlsonj longer_usage(CMD_SET); 4099555afedfScarlsonj else 4100555afedfScarlsonj short_usage(CMD_SET); 4101bbec428eSgjelinek arg_err = B_TRUE; 41027ec75eb8Sgjelinek break; 41037ec75eb8Sgjelinek } 41047ec75eb8Sgjelinek } 41057ec75eb8Sgjelinek if (arg_err) 4106555afedfScarlsonj return; 4107555afedfScarlsonj 41087c478bd9Sstevel@tonic-gate prop_type = cmd->cmd_prop_name[0]; 41097c478bd9Sstevel@tonic-gate if (global_scope) { 41100209230bSgjelinek if (gz_invalid_property(prop_type)) { 41110209230bSgjelinek zerr(gettext("%s is not a valid property for the " 41120209230bSgjelinek "global zone."), pt_to_str(prop_type)); 4113bbec428eSgjelinek saw_error = B_TRUE; 41140209230bSgjelinek return; 41150209230bSgjelinek } 41160209230bSgjelinek 4117087719fdSdp if (prop_type == PT_ZONENAME) { 4118087719fdSdp res_type = RT_ZONENAME; 4119087719fdSdp } else if (prop_type == PT_ZONEPATH) { 41207c478bd9Sstevel@tonic-gate res_type = RT_ZONEPATH; 41217c478bd9Sstevel@tonic-gate } else if (prop_type == PT_AUTOBOOT) { 41227c478bd9Sstevel@tonic-gate res_type = RT_AUTOBOOT; 41239acbbeafSnn35248 } else if (prop_type == PT_BRAND) { 41249acbbeafSnn35248 res_type = RT_BRAND; 41257c478bd9Sstevel@tonic-gate } else if (prop_type == PT_POOL) { 41267c478bd9Sstevel@tonic-gate res_type = RT_POOL; 4127ffbafc53Scomay } else if (prop_type == PT_LIMITPRIV) { 4128ffbafc53Scomay res_type = RT_LIMITPRIV; 41293f2f09c1Sdp } else if (prop_type == PT_BOOTARGS) { 41303f2f09c1Sdp res_type = RT_BOOTARGS; 41310209230bSgjelinek } else if (prop_type == PT_SCHED) { 41320209230bSgjelinek res_type = RT_SCHED; 4133f4b3ec61Sdh155122 } else if (prop_type == PT_IPTYPE) { 4134f4b3ec61Sdh155122 res_type = RT_IPTYPE; 41350209230bSgjelinek } else if (prop_type == PT_MAXLWPS) { 41360209230bSgjelinek res_type = RT_MAXLWPS; 41370209230bSgjelinek } else if (prop_type == PT_MAXSHMMEM) { 41380209230bSgjelinek res_type = RT_MAXSHMMEM; 41390209230bSgjelinek } else if (prop_type == PT_MAXSHMIDS) { 41400209230bSgjelinek res_type = RT_MAXSHMIDS; 41410209230bSgjelinek } else if (prop_type == PT_MAXMSGIDS) { 41420209230bSgjelinek res_type = RT_MAXMSGIDS; 41430209230bSgjelinek } else if (prop_type == PT_MAXSEMIDS) { 41440209230bSgjelinek res_type = RT_MAXSEMIDS; 41450209230bSgjelinek } else if (prop_type == PT_SHARES) { 41460209230bSgjelinek res_type = RT_SHARES; 41475679c89fSjv227347 } else if (prop_type == PT_HOSTID) { 41485679c89fSjv227347 res_type = RT_HOSTID; 41497c478bd9Sstevel@tonic-gate } else { 41507c478bd9Sstevel@tonic-gate zerr(gettext("Cannot set a resource-specific property " 41517c478bd9Sstevel@tonic-gate "from the global scope.")); 4152bbec428eSgjelinek saw_error = B_TRUE; 41537c478bd9Sstevel@tonic-gate return; 41547c478bd9Sstevel@tonic-gate } 41557c478bd9Sstevel@tonic-gate } else { 41567c478bd9Sstevel@tonic-gate res_type = resource_scope; 41577c478bd9Sstevel@tonic-gate } 41587c478bd9Sstevel@tonic-gate 4159555afedfScarlsonj if (force_set) { 4160555afedfScarlsonj if (res_type != RT_ZONEPATH) { 4161555afedfScarlsonj zerr(gettext("Only zonepath setting can be forced.")); 4162bbec428eSgjelinek saw_error = B_TRUE; 4163555afedfScarlsonj return; 4164555afedfScarlsonj } 4165555afedfScarlsonj if (!zonecfg_in_alt_root()) { 4166555afedfScarlsonj zerr(gettext("Zonepath is changeable only in an " 4167555afedfScarlsonj "alternate root.")); 4168bbec428eSgjelinek saw_error = B_TRUE; 4169555afedfScarlsonj return; 4170555afedfScarlsonj } 4171555afedfScarlsonj } 4172555afedfScarlsonj 41737c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[0]; 41747c478bd9Sstevel@tonic-gate /* 41757c478bd9Sstevel@tonic-gate * A nasty expression but not that complicated: 41767c478bd9Sstevel@tonic-gate * 1. fs options are simple or list (tested below) 41777c478bd9Sstevel@tonic-gate * 2. rctl value's are complex or list (tested below) 41787c478bd9Sstevel@tonic-gate * Anything else should be simple. 41797c478bd9Sstevel@tonic-gate */ 41807c478bd9Sstevel@tonic-gate if (!(res_type == RT_FS && prop_type == PT_OPTIONS) && 41817c478bd9Sstevel@tonic-gate !(res_type == RT_RCTL && prop_type == PT_VALUE) && 41827c478bd9Sstevel@tonic-gate (pp->pv_type != PROP_VAL_SIMPLE || 41837c478bd9Sstevel@tonic-gate (prop_id = pp->pv_simple) == NULL)) { 41847c478bd9Sstevel@tonic-gate zerr(gettext("A %s value was expected here."), 41857c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_SIMPLE)); 4186bbec428eSgjelinek saw_error = B_TRUE; 41877c478bd9Sstevel@tonic-gate return; 41887c478bd9Sstevel@tonic-gate } 41897c478bd9Sstevel@tonic-gate if (prop_type == PT_UNKNOWN) { 4190bbec428eSgjelinek long_usage(CMD_SET, B_TRUE); 41917c478bd9Sstevel@tonic-gate return; 41927c478bd9Sstevel@tonic-gate } 41937c478bd9Sstevel@tonic-gate 4194087719fdSdp /* 4195087719fdSdp * Special case: the user can change the zone name prior to 'create'; 4196087719fdSdp * if the zone already exists, we fall through letting initialize() 4197087719fdSdp * and the rest of the logic run. 4198087719fdSdp */ 4199bbec428eSgjelinek if (res_type == RT_ZONENAME && got_handle == B_FALSE && 4200087719fdSdp !state_atleast(ZONE_STATE_CONFIGURED)) { 4201fb03efaaSdp if ((err = zonecfg_validate_zonename(prop_id)) != Z_OK) { 4202bbec428eSgjelinek zone_perror(prop_id, err, B_TRUE); 4203bbec428eSgjelinek usage(B_FALSE, HELP_SYNTAX); 4204fb03efaaSdp return; 4205fb03efaaSdp } 4206087719fdSdp (void) strlcpy(zone, prop_id, sizeof (zone)); 4207087719fdSdp return; 4208087719fdSdp } 4209087719fdSdp 4210bbec428eSgjelinek if (initialize(B_TRUE) != Z_OK) 42117c478bd9Sstevel@tonic-gate return; 42127c478bd9Sstevel@tonic-gate 42137c478bd9Sstevel@tonic-gate switch (res_type) { 4214087719fdSdp case RT_ZONENAME: 4215087719fdSdp if ((err = zonecfg_set_name(handle, prop_id)) != Z_OK) { 4216087719fdSdp /* 4217087719fdSdp * Use prop_id instead of 'zone' here, since we're 4218087719fdSdp * reporting a problem about the *new* zonename. 4219087719fdSdp */ 4220bbec428eSgjelinek zone_perror(prop_id, err, B_TRUE); 4221bbec428eSgjelinek usage(B_FALSE, HELP_SYNTAX); 4222087719fdSdp } else { 4223bbec428eSgjelinek need_to_commit = B_TRUE; 4224087719fdSdp (void) strlcpy(zone, prop_id, sizeof (zone)); 4225087719fdSdp } 4226087719fdSdp return; 42277c478bd9Sstevel@tonic-gate case RT_ZONEPATH: 4228555afedfScarlsonj if (!force_set && state_atleast(ZONE_STATE_INSTALLED)) { 42297c478bd9Sstevel@tonic-gate zerr(gettext("Zone %s already installed; %s %s not " 42307c478bd9Sstevel@tonic-gate "allowed."), zone, cmd_to_str(CMD_SET), 42317c478bd9Sstevel@tonic-gate rt_to_str(RT_ZONEPATH)); 42327c478bd9Sstevel@tonic-gate return; 42337c478bd9Sstevel@tonic-gate } 42347c478bd9Sstevel@tonic-gate if (validate_zonepath_syntax(prop_id) != Z_OK) { 4235bbec428eSgjelinek saw_error = B_TRUE; 42367c478bd9Sstevel@tonic-gate return; 42377c478bd9Sstevel@tonic-gate } 42387c478bd9Sstevel@tonic-gate if ((err = zonecfg_set_zonepath(handle, prop_id)) != Z_OK) 4239bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 42407c478bd9Sstevel@tonic-gate else 4241bbec428eSgjelinek need_to_commit = B_TRUE; 42427c478bd9Sstevel@tonic-gate return; 42439acbbeafSnn35248 case RT_BRAND: 42449acbbeafSnn35248 if (state_atleast(ZONE_STATE_INSTALLED)) { 42459acbbeafSnn35248 zerr(gettext("Zone %s already installed; %s %s not " 42469acbbeafSnn35248 "allowed."), zone, cmd_to_str(CMD_SET), 42479acbbeafSnn35248 rt_to_str(RT_BRAND)); 42489acbbeafSnn35248 return; 42499acbbeafSnn35248 } 42509acbbeafSnn35248 if ((err = zonecfg_set_brand(handle, prop_id)) != Z_OK) 4251bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 42529acbbeafSnn35248 else 4253bbec428eSgjelinek need_to_commit = B_TRUE; 42549acbbeafSnn35248 return; 42557c478bd9Sstevel@tonic-gate case RT_AUTOBOOT: 42567c478bd9Sstevel@tonic-gate if (strcmp(prop_id, "true") == 0) { 42577c478bd9Sstevel@tonic-gate autoboot = B_TRUE; 42587c478bd9Sstevel@tonic-gate } else if (strcmp(prop_id, "false") == 0) { 42597c478bd9Sstevel@tonic-gate autoboot = B_FALSE; 42607c478bd9Sstevel@tonic-gate } else { 42617c478bd9Sstevel@tonic-gate zerr(gettext("%s value must be '%s' or '%s'."), 42627c478bd9Sstevel@tonic-gate pt_to_str(PT_AUTOBOOT), "true", "false"); 4263bbec428eSgjelinek saw_error = B_TRUE; 42647c478bd9Sstevel@tonic-gate return; 42657c478bd9Sstevel@tonic-gate } 42667c478bd9Sstevel@tonic-gate if ((err = zonecfg_set_autoboot(handle, autoboot)) != Z_OK) 4267bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 42687c478bd9Sstevel@tonic-gate else 4269bbec428eSgjelinek need_to_commit = B_TRUE; 42707c478bd9Sstevel@tonic-gate return; 42717c478bd9Sstevel@tonic-gate case RT_POOL: 42720209230bSgjelinek /* don't allow use of the reserved temporary pool names */ 42730209230bSgjelinek if (strncmp("SUNW", prop_id, 4) == 0) { 42740209230bSgjelinek zerr(gettext("pool names starting with SUNW are " 42750209230bSgjelinek "reserved.")); 4276bbec428eSgjelinek saw_error = B_TRUE; 42770209230bSgjelinek return; 42780209230bSgjelinek } 42790209230bSgjelinek 42800209230bSgjelinek /* can't set pool if dedicated-cpu exists */ 42810209230bSgjelinek if (zonecfg_lookup_pset(handle, &tmp_psettab) == Z_OK) { 42820209230bSgjelinek zerr(gettext("The %s resource already exists. " 42830209230bSgjelinek "A persistent pool is incompatible\nwith the %s " 42840209230bSgjelinek "resource."), rt_to_str(RT_DCPU), 42850209230bSgjelinek rt_to_str(RT_DCPU)); 4286bbec428eSgjelinek saw_error = B_TRUE; 42870209230bSgjelinek return; 42880209230bSgjelinek } 42890209230bSgjelinek 42907c478bd9Sstevel@tonic-gate if ((err = zonecfg_set_pool(handle, prop_id)) != Z_OK) 4291bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 42927c478bd9Sstevel@tonic-gate else 4293bbec428eSgjelinek need_to_commit = B_TRUE; 42947c478bd9Sstevel@tonic-gate return; 4295ffbafc53Scomay case RT_LIMITPRIV: 4296ffbafc53Scomay if ((err = zonecfg_set_limitpriv(handle, prop_id)) != Z_OK) 4297bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 4298ffbafc53Scomay else 4299bbec428eSgjelinek need_to_commit = B_TRUE; 4300ffbafc53Scomay return; 43013f2f09c1Sdp case RT_BOOTARGS: 43023f2f09c1Sdp if ((err = zonecfg_set_bootargs(handle, prop_id)) != Z_OK) 4303bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 43043f2f09c1Sdp else 4305bbec428eSgjelinek need_to_commit = B_TRUE; 43063f2f09c1Sdp return; 43070209230bSgjelinek case RT_SCHED: 43080209230bSgjelinek if ((err = zonecfg_set_sched(handle, prop_id)) != Z_OK) 4309bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 43100209230bSgjelinek else 4311bbec428eSgjelinek need_to_commit = B_TRUE; 43120209230bSgjelinek return; 4313f4b3ec61Sdh155122 case RT_IPTYPE: 4314f4b3ec61Sdh155122 if (strcmp(prop_id, "shared") == 0) { 4315f4b3ec61Sdh155122 iptype = ZS_SHARED; 4316f4b3ec61Sdh155122 } else if (strcmp(prop_id, "exclusive") == 0) { 4317f4b3ec61Sdh155122 iptype = ZS_EXCLUSIVE; 4318f4b3ec61Sdh155122 } else { 4319f4b3ec61Sdh155122 zerr(gettext("%s value must be '%s' or '%s'."), 4320f4b3ec61Sdh155122 pt_to_str(PT_IPTYPE), "shared", "exclusive"); 4321bbec428eSgjelinek saw_error = B_TRUE; 4322f4b3ec61Sdh155122 return; 4323f4b3ec61Sdh155122 } 4324f4b3ec61Sdh155122 if (iptype == ZS_EXCLUSIVE && !allow_exclusive()) { 4325bbec428eSgjelinek saw_error = B_TRUE; 4326f4b3ec61Sdh155122 return; 4327f4b3ec61Sdh155122 } 4328f4b3ec61Sdh155122 if ((err = zonecfg_set_iptype(handle, iptype)) != Z_OK) 4329bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 4330f4b3ec61Sdh155122 else 4331bbec428eSgjelinek need_to_commit = B_TRUE; 4332f4b3ec61Sdh155122 return; 43330209230bSgjelinek case RT_MAXLWPS: 43340209230bSgjelinek set_aliased_rctl(ALIAS_MAXLWPS, prop_type, prop_id); 43350209230bSgjelinek return; 43360209230bSgjelinek case RT_MAXSHMMEM: 43370209230bSgjelinek set_aliased_rctl(ALIAS_MAXSHMMEM, prop_type, prop_id); 43380209230bSgjelinek return; 43390209230bSgjelinek case RT_MAXSHMIDS: 43400209230bSgjelinek set_aliased_rctl(ALIAS_MAXSHMIDS, prop_type, prop_id); 43410209230bSgjelinek return; 43420209230bSgjelinek case RT_MAXMSGIDS: 43430209230bSgjelinek set_aliased_rctl(ALIAS_MAXMSGIDS, prop_type, prop_id); 43440209230bSgjelinek return; 43450209230bSgjelinek case RT_MAXSEMIDS: 43460209230bSgjelinek set_aliased_rctl(ALIAS_MAXSEMIDS, prop_type, prop_id); 43470209230bSgjelinek return; 43480209230bSgjelinek case RT_SHARES: 43490209230bSgjelinek set_aliased_rctl(ALIAS_SHARES, prop_type, prop_id); 43500209230bSgjelinek return; 43515679c89fSjv227347 case RT_HOSTID: 43525679c89fSjv227347 if ((err = zonecfg_set_hostid(handle, prop_id)) != Z_OK) { 43535679c89fSjv227347 if (err == Z_TOO_BIG) { 43545679c89fSjv227347 zerr(gettext("hostid string is too large: %s"), 43555679c89fSjv227347 prop_id); 43565679c89fSjv227347 saw_error = B_TRUE; 43575679c89fSjv227347 } else { 43585679c89fSjv227347 zone_perror(pt_to_str(prop_type), err, B_TRUE); 43595679c89fSjv227347 } 43605679c89fSjv227347 return; 43615679c89fSjv227347 } 43625679c89fSjv227347 need_to_commit = B_TRUE; 43635679c89fSjv227347 return; 43647c478bd9Sstevel@tonic-gate case RT_FS: 43657c478bd9Sstevel@tonic-gate switch (prop_type) { 43667c478bd9Sstevel@tonic-gate case PT_DIR: 43677c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_fstab.zone_fs_dir, prop_id, 43687c478bd9Sstevel@tonic-gate sizeof (in_progress_fstab.zone_fs_dir)); 43697c478bd9Sstevel@tonic-gate return; 43707c478bd9Sstevel@tonic-gate case PT_SPECIAL: 43717c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_fstab.zone_fs_special, 43727c478bd9Sstevel@tonic-gate prop_id, 43737c478bd9Sstevel@tonic-gate sizeof (in_progress_fstab.zone_fs_special)); 43747c478bd9Sstevel@tonic-gate return; 43757c478bd9Sstevel@tonic-gate case PT_RAW: 43767c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_fstab.zone_fs_raw, 43777c478bd9Sstevel@tonic-gate prop_id, sizeof (in_progress_fstab.zone_fs_raw)); 43787c478bd9Sstevel@tonic-gate return; 43797c478bd9Sstevel@tonic-gate case PT_TYPE: 43807c478bd9Sstevel@tonic-gate if (!valid_fs_type(prop_id)) { 43817c478bd9Sstevel@tonic-gate zerr(gettext("\"%s\" is not a valid %s."), 43827c478bd9Sstevel@tonic-gate prop_id, pt_to_str(PT_TYPE)); 4383bbec428eSgjelinek saw_error = B_TRUE; 43847c478bd9Sstevel@tonic-gate return; 43857c478bd9Sstevel@tonic-gate } 43867c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_fstab.zone_fs_type, prop_id, 43877c478bd9Sstevel@tonic-gate sizeof (in_progress_fstab.zone_fs_type)); 43887c478bd9Sstevel@tonic-gate return; 43897c478bd9Sstevel@tonic-gate case PT_OPTIONS: 43907c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE && 43917c478bd9Sstevel@tonic-gate pp->pv_type != PROP_VAL_LIST) { 43927c478bd9Sstevel@tonic-gate zerr(gettext("A %s or %s value was expected " 43937c478bd9Sstevel@tonic-gate "here."), pvt_to_str(PROP_VAL_SIMPLE), 43947c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_LIST)); 4395bbec428eSgjelinek saw_error = B_TRUE; 43967c478bd9Sstevel@tonic-gate return; 43977c478bd9Sstevel@tonic-gate } 43987c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list( 43997c478bd9Sstevel@tonic-gate in_progress_fstab.zone_fs_options); 44007c478bd9Sstevel@tonic-gate in_progress_fstab.zone_fs_options = NULL; 44017c478bd9Sstevel@tonic-gate if (!(pp->pv_type == PROP_VAL_LIST && 44027c478bd9Sstevel@tonic-gate pp->pv_list == NULL)) 44037c478bd9Sstevel@tonic-gate add_property(cmd); 44047c478bd9Sstevel@tonic-gate return; 44057c478bd9Sstevel@tonic-gate default: 44067c478bd9Sstevel@tonic-gate break; 44077c478bd9Sstevel@tonic-gate } 4408bbec428eSgjelinek zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, B_TRUE); 4409bbec428eSgjelinek long_usage(CMD_SET, B_TRUE); 4410bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 44117c478bd9Sstevel@tonic-gate return; 44127c478bd9Sstevel@tonic-gate case RT_IPD: 44137c478bd9Sstevel@tonic-gate switch (prop_type) { 44147c478bd9Sstevel@tonic-gate case PT_DIR: 44157c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_ipdtab.zone_fs_dir, prop_id, 44167c478bd9Sstevel@tonic-gate sizeof (in_progress_ipdtab.zone_fs_dir)); 44177c478bd9Sstevel@tonic-gate return; 44187c478bd9Sstevel@tonic-gate default: 44197c478bd9Sstevel@tonic-gate break; 44207c478bd9Sstevel@tonic-gate } 4421bbec428eSgjelinek zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, B_TRUE); 4422bbec428eSgjelinek long_usage(CMD_SET, B_TRUE); 4423bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 44247c478bd9Sstevel@tonic-gate return; 44257c478bd9Sstevel@tonic-gate case RT_NET: 44267c478bd9Sstevel@tonic-gate switch (prop_type) { 44277c478bd9Sstevel@tonic-gate case PT_ADDRESS: 44287c478bd9Sstevel@tonic-gate if (validate_net_address_syntax(prop_id) != Z_OK) { 4429bbec428eSgjelinek saw_error = B_TRUE; 44307c478bd9Sstevel@tonic-gate return; 44317c478bd9Sstevel@tonic-gate } 44327c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_nwiftab.zone_nwif_address, 44337c478bd9Sstevel@tonic-gate prop_id, 44347c478bd9Sstevel@tonic-gate sizeof (in_progress_nwiftab.zone_nwif_address)); 44357c478bd9Sstevel@tonic-gate break; 44367c478bd9Sstevel@tonic-gate case PT_PHYSICAL: 44377c478bd9Sstevel@tonic-gate if (validate_net_physical_syntax(prop_id) != Z_OK) { 4438bbec428eSgjelinek saw_error = B_TRUE; 44397c478bd9Sstevel@tonic-gate return; 44407c478bd9Sstevel@tonic-gate } 44417c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_nwiftab.zone_nwif_physical, 44427c478bd9Sstevel@tonic-gate prop_id, 44437c478bd9Sstevel@tonic-gate sizeof (in_progress_nwiftab.zone_nwif_physical)); 44447c478bd9Sstevel@tonic-gate break; 4445de860bd9Sgfaden case PT_DEFROUTER: 4446de860bd9Sgfaden if (validate_net_address_syntax(prop_id) != Z_OK) { 4447bbec428eSgjelinek saw_error = B_TRUE; 4448de860bd9Sgfaden return; 4449de860bd9Sgfaden } 4450de860bd9Sgfaden (void) strlcpy(in_progress_nwiftab.zone_nwif_defrouter, 4451de860bd9Sgfaden prop_id, 4452de860bd9Sgfaden sizeof (in_progress_nwiftab.zone_nwif_defrouter)); 4453de860bd9Sgfaden break; 44547c478bd9Sstevel@tonic-gate default: 44557c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 4456bbec428eSgjelinek B_TRUE); 4457bbec428eSgjelinek long_usage(CMD_SET, B_TRUE); 4458bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 44597c478bd9Sstevel@tonic-gate return; 44607c478bd9Sstevel@tonic-gate } 44617c478bd9Sstevel@tonic-gate return; 44627c478bd9Sstevel@tonic-gate case RT_DEVICE: 44637c478bd9Sstevel@tonic-gate switch (prop_type) { 44647c478bd9Sstevel@tonic-gate case PT_MATCH: 44657c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_devtab.zone_dev_match, 44667c478bd9Sstevel@tonic-gate prop_id, 44677c478bd9Sstevel@tonic-gate sizeof (in_progress_devtab.zone_dev_match)); 44687c478bd9Sstevel@tonic-gate break; 44697c478bd9Sstevel@tonic-gate default: 44707c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 4471bbec428eSgjelinek B_TRUE); 4472bbec428eSgjelinek long_usage(CMD_SET, B_TRUE); 4473bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 44747c478bd9Sstevel@tonic-gate return; 44757c478bd9Sstevel@tonic-gate } 44767c478bd9Sstevel@tonic-gate return; 44777c478bd9Sstevel@tonic-gate case RT_RCTL: 44787c478bd9Sstevel@tonic-gate switch (prop_type) { 44797c478bd9Sstevel@tonic-gate case PT_NAME: 44807c478bd9Sstevel@tonic-gate if (!zonecfg_valid_rctlname(prop_id)) { 44817c478bd9Sstevel@tonic-gate zerr(gettext("'%s' is not a valid zone %s " 44827c478bd9Sstevel@tonic-gate "name."), prop_id, rt_to_str(RT_RCTL)); 44837c478bd9Sstevel@tonic-gate return; 44847c478bd9Sstevel@tonic-gate } 44857c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_rctltab.zone_rctl_name, 44867c478bd9Sstevel@tonic-gate prop_id, 44877c478bd9Sstevel@tonic-gate sizeof (in_progress_rctltab.zone_rctl_name)); 44887c478bd9Sstevel@tonic-gate break; 44897c478bd9Sstevel@tonic-gate case PT_VALUE: 44907c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_COMPLEX && 44917c478bd9Sstevel@tonic-gate pp->pv_type != PROP_VAL_LIST) { 44927c478bd9Sstevel@tonic-gate zerr(gettext("A %s or %s value was expected " 44937c478bd9Sstevel@tonic-gate "here."), pvt_to_str(PROP_VAL_COMPLEX), 44947c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_LIST)); 4495bbec428eSgjelinek saw_error = B_TRUE; 44967c478bd9Sstevel@tonic-gate return; 44977c478bd9Sstevel@tonic-gate } 44987c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list( 44997c478bd9Sstevel@tonic-gate in_progress_rctltab.zone_rctl_valptr); 45007c478bd9Sstevel@tonic-gate in_progress_rctltab.zone_rctl_valptr = NULL; 45017c478bd9Sstevel@tonic-gate if (!(pp->pv_type == PROP_VAL_LIST && 45027c478bd9Sstevel@tonic-gate pp->pv_list == NULL)) 45037c478bd9Sstevel@tonic-gate add_property(cmd); 45047c478bd9Sstevel@tonic-gate break; 45057c478bd9Sstevel@tonic-gate default: 45067c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 4507bbec428eSgjelinek B_TRUE); 4508bbec428eSgjelinek long_usage(CMD_SET, B_TRUE); 4509bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 45107c478bd9Sstevel@tonic-gate return; 45117c478bd9Sstevel@tonic-gate } 45127c478bd9Sstevel@tonic-gate return; 45137c478bd9Sstevel@tonic-gate case RT_ATTR: 45147c478bd9Sstevel@tonic-gate switch (prop_type) { 45157c478bd9Sstevel@tonic-gate case PT_NAME: 45167c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_attrtab.zone_attr_name, 45177c478bd9Sstevel@tonic-gate prop_id, 45187c478bd9Sstevel@tonic-gate sizeof (in_progress_attrtab.zone_attr_name)); 45197c478bd9Sstevel@tonic-gate break; 45207c478bd9Sstevel@tonic-gate case PT_TYPE: 45217c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_attrtab.zone_attr_type, 45227c478bd9Sstevel@tonic-gate prop_id, 45237c478bd9Sstevel@tonic-gate sizeof (in_progress_attrtab.zone_attr_type)); 45247c478bd9Sstevel@tonic-gate break; 45257c478bd9Sstevel@tonic-gate case PT_VALUE: 45267c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_attrtab.zone_attr_value, 45277c478bd9Sstevel@tonic-gate prop_id, 45287c478bd9Sstevel@tonic-gate sizeof (in_progress_attrtab.zone_attr_value)); 45297c478bd9Sstevel@tonic-gate break; 45307c478bd9Sstevel@tonic-gate default: 45317c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 4532bbec428eSgjelinek B_TRUE); 4533bbec428eSgjelinek long_usage(CMD_SET, B_TRUE); 4534bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 45357c478bd9Sstevel@tonic-gate return; 45367c478bd9Sstevel@tonic-gate } 45377c478bd9Sstevel@tonic-gate return; 4538fa9e4066Sahrens case RT_DATASET: 4539fa9e4066Sahrens switch (prop_type) { 4540fa9e4066Sahrens case PT_NAME: 4541fa9e4066Sahrens (void) strlcpy(in_progress_dstab.zone_dataset_name, 4542fa9e4066Sahrens prop_id, 4543fa9e4066Sahrens sizeof (in_progress_dstab.zone_dataset_name)); 4544fa9e4066Sahrens return; 4545fa9e4066Sahrens default: 4546fa9e4066Sahrens break; 4547fa9e4066Sahrens } 4548bbec428eSgjelinek zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, B_TRUE); 4549bbec428eSgjelinek long_usage(CMD_SET, B_TRUE); 4550bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 4551fa9e4066Sahrens return; 45520209230bSgjelinek case RT_DCPU: 45530209230bSgjelinek switch (prop_type) { 45540209230bSgjelinek char *lowp, *highp; 45550209230bSgjelinek 45560209230bSgjelinek case PT_NCPUS: 45570209230bSgjelinek lowp = prop_id; 45580209230bSgjelinek if ((highp = strchr(prop_id, '-')) != NULL) 45590209230bSgjelinek *highp++ = '\0'; 45600209230bSgjelinek else 45610209230bSgjelinek highp = lowp; 45620209230bSgjelinek 45630209230bSgjelinek /* Make sure the input makes sense. */ 45640209230bSgjelinek if (!zonecfg_valid_ncpus(lowp, highp)) { 45650209230bSgjelinek zerr(gettext("%s property is out of range."), 45660209230bSgjelinek pt_to_str(PT_NCPUS)); 4567bbec428eSgjelinek saw_error = B_TRUE; 45680209230bSgjelinek return; 45690209230bSgjelinek } 45700209230bSgjelinek 45710209230bSgjelinek (void) strlcpy( 45720209230bSgjelinek in_progress_psettab.zone_ncpu_min, lowp, 45730209230bSgjelinek sizeof (in_progress_psettab.zone_ncpu_min)); 45740209230bSgjelinek (void) strlcpy( 45750209230bSgjelinek in_progress_psettab.zone_ncpu_max, highp, 45760209230bSgjelinek sizeof (in_progress_psettab.zone_ncpu_max)); 45770209230bSgjelinek return; 45780209230bSgjelinek case PT_IMPORTANCE: 45790209230bSgjelinek /* Make sure the value makes sense. */ 45800209230bSgjelinek if (!zonecfg_valid_importance(prop_id)) { 45810209230bSgjelinek zerr(gettext("%s property is out of range."), 45820209230bSgjelinek pt_to_str(PT_IMPORTANCE)); 4583bbec428eSgjelinek saw_error = B_TRUE; 45840209230bSgjelinek return; 45850209230bSgjelinek } 45860209230bSgjelinek 45870209230bSgjelinek (void) strlcpy(in_progress_psettab.zone_importance, 45880209230bSgjelinek prop_id, 45890209230bSgjelinek sizeof (in_progress_psettab.zone_importance)); 45900209230bSgjelinek return; 45910209230bSgjelinek default: 45920209230bSgjelinek break; 45930209230bSgjelinek } 4594bbec428eSgjelinek zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, B_TRUE); 4595bbec428eSgjelinek long_usage(CMD_SET, B_TRUE); 4596bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 45970209230bSgjelinek return; 4598c97ad5cdSakolb case RT_PCAP: 4599c97ad5cdSakolb if (prop_type != PT_NCPUS) { 4600c97ad5cdSakolb zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 4601bbec428eSgjelinek B_TRUE); 4602bbec428eSgjelinek long_usage(CMD_SET, B_TRUE); 4603bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 4604c97ad5cdSakolb return; 4605c97ad5cdSakolb } 4606c97ad5cdSakolb 4607c97ad5cdSakolb /* 4608c97ad5cdSakolb * We already checked that an rctl alias is allowed in 4609c97ad5cdSakolb * the add_resource() function. 4610c97ad5cdSakolb */ 4611c97ad5cdSakolb 4612c97ad5cdSakolb if ((cap = strtof(prop_id, &unitp)) <= 0 || *unitp != '\0' || 4613c97ad5cdSakolb (int)(cap * 100) < 1) { 4614c97ad5cdSakolb zerr(gettext("%s property is out of range."), 4615c97ad5cdSakolb pt_to_str(PT_NCPUS)); 4616bbec428eSgjelinek saw_error = B_TRUE; 4617c97ad5cdSakolb return; 4618c97ad5cdSakolb } 4619c97ad5cdSakolb 4620c97ad5cdSakolb if ((err = zonecfg_set_aliased_rctl(handle, ALIAS_CPUCAP, 4621c97ad5cdSakolb (int)(cap * 100))) != Z_OK) 4622bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 4623c97ad5cdSakolb else 4624bbec428eSgjelinek need_to_commit = B_TRUE; 4625c97ad5cdSakolb return; 46260209230bSgjelinek case RT_MCAP: 46270209230bSgjelinek switch (prop_type) { 46280209230bSgjelinek case PT_PHYSICAL: 46290209230bSgjelinek if (!zonecfg_valid_memlimit(prop_id, &mem_cap)) { 46300209230bSgjelinek zerr(gettext("A positive number with a " 46310209230bSgjelinek "required scale suffix (K, M, G or T) was " 46320209230bSgjelinek "expected here.")); 4633bbec428eSgjelinek saw_error = B_TRUE; 46340209230bSgjelinek } else if (mem_cap < ONE_MB) { 46350209230bSgjelinek zerr(gettext("%s value is too small. It must " 46360209230bSgjelinek "be at least 1M."), pt_to_str(PT_PHYSICAL)); 4637bbec428eSgjelinek saw_error = B_TRUE; 46380209230bSgjelinek } else { 46390209230bSgjelinek snprintf(in_progress_mcaptab.zone_physmem_cap, 46400209230bSgjelinek physmem_size, "%llu", mem_cap); 46410209230bSgjelinek } 46420209230bSgjelinek break; 46430209230bSgjelinek case PT_SWAP: 46440209230bSgjelinek /* 46450209230bSgjelinek * We have to check if an rctl is allowed here since 46460209230bSgjelinek * there might already be a rctl defined that blocks 46470209230bSgjelinek * the alias. 46480209230bSgjelinek */ 46490209230bSgjelinek if (!zonecfg_aliased_rctl_ok(handle, ALIAS_MAXSWAP)) { 46500209230bSgjelinek zone_perror(pt_to_str(PT_MAXSWAP), 4651bbec428eSgjelinek Z_ALIAS_DISALLOW, B_FALSE); 4652bbec428eSgjelinek saw_error = B_TRUE; 46530209230bSgjelinek return; 46540209230bSgjelinek } 46550209230bSgjelinek 46560209230bSgjelinek if (global_zone) 46570209230bSgjelinek mem_limit = ONE_MB * 100; 46580209230bSgjelinek else 46590209230bSgjelinek mem_limit = ONE_MB * 50; 46600209230bSgjelinek 46610209230bSgjelinek if (!zonecfg_valid_memlimit(prop_id, &mem_cap)) { 46620209230bSgjelinek zerr(gettext("A positive number with a " 46630209230bSgjelinek "required scale suffix (K, M, G or T) was " 46640209230bSgjelinek "expected here.")); 4665bbec428eSgjelinek saw_error = B_TRUE; 46660209230bSgjelinek } else if (mem_cap < mem_limit) { 46670209230bSgjelinek char buf[128]; 46680209230bSgjelinek 46690209230bSgjelinek (void) snprintf(buf, sizeof (buf), "%llu", 46700209230bSgjelinek mem_limit); 46710209230bSgjelinek bytes_to_units(buf, buf, sizeof (buf)); 46720209230bSgjelinek zerr(gettext("%s value is too small. It must " 46730209230bSgjelinek "be at least %s."), pt_to_str(PT_SWAP), 46740209230bSgjelinek buf); 4675bbec428eSgjelinek saw_error = B_TRUE; 46760209230bSgjelinek } else { 46770209230bSgjelinek if ((err = zonecfg_set_aliased_rctl(handle, 46780209230bSgjelinek ALIAS_MAXSWAP, mem_cap)) != Z_OK) 4679bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 46800209230bSgjelinek else 4681bbec428eSgjelinek need_to_commit = B_TRUE; 46820209230bSgjelinek } 46830209230bSgjelinek break; 46840209230bSgjelinek case PT_LOCKED: 46850209230bSgjelinek /* 46860209230bSgjelinek * We have to check if an rctl is allowed here since 46870209230bSgjelinek * there might already be a rctl defined that blocks 46880209230bSgjelinek * the alias. 46890209230bSgjelinek */ 46900209230bSgjelinek if (!zonecfg_aliased_rctl_ok(handle, 46910209230bSgjelinek ALIAS_MAXLOCKEDMEM)) { 46920209230bSgjelinek zone_perror(pt_to_str(PT_LOCKED), 4693bbec428eSgjelinek Z_ALIAS_DISALLOW, B_FALSE); 4694bbec428eSgjelinek saw_error = B_TRUE; 46950209230bSgjelinek return; 46960209230bSgjelinek } 46970209230bSgjelinek 46980209230bSgjelinek if (!zonecfg_valid_memlimit(prop_id, &mem_cap)) { 46990209230bSgjelinek zerr(gettext("A non-negative number with a " 47000209230bSgjelinek "required scale suffix (K, M, G or T) was " 47010209230bSgjelinek "expected\nhere.")); 4702bbec428eSgjelinek saw_error = B_TRUE; 47030209230bSgjelinek } else { 47040209230bSgjelinek if ((err = zonecfg_set_aliased_rctl(handle, 47050209230bSgjelinek ALIAS_MAXLOCKEDMEM, mem_cap)) != Z_OK) 4706bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 47070209230bSgjelinek else 4708bbec428eSgjelinek need_to_commit = B_TRUE; 47090209230bSgjelinek } 47100209230bSgjelinek break; 47110209230bSgjelinek default: 47120209230bSgjelinek zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 4713bbec428eSgjelinek B_TRUE); 4714bbec428eSgjelinek long_usage(CMD_SET, B_TRUE); 4715bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 47160209230bSgjelinek return; 47170209230bSgjelinek } 47180209230bSgjelinek return; 4719cb8a054bSGlenn Faden case RT_ADMIN: 4720cb8a054bSGlenn Faden switch (prop_type) { 4721cb8a054bSGlenn Faden case PT_USER: 4722cb8a054bSGlenn Faden (void) strlcpy(in_progress_admintab.zone_admin_user, 4723cb8a054bSGlenn Faden prop_id, 4724cb8a054bSGlenn Faden sizeof (in_progress_admintab.zone_admin_user)); 4725cb8a054bSGlenn Faden return; 4726cb8a054bSGlenn Faden case PT_AUTHS: 4727cb8a054bSGlenn Faden (void) strlcpy(in_progress_admintab.zone_admin_auths, 4728cb8a054bSGlenn Faden prop_id, 4729cb8a054bSGlenn Faden sizeof (in_progress_admintab.zone_admin_auths)); 4730cb8a054bSGlenn Faden return; 4731cb8a054bSGlenn Faden default: 4732cb8a054bSGlenn Faden zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 4733cb8a054bSGlenn Faden B_TRUE); 4734cb8a054bSGlenn Faden long_usage(CMD_SET, B_TRUE); 4735cb8a054bSGlenn Faden usage(B_FALSE, HELP_PROPS); 4736cb8a054bSGlenn Faden return; 4737cb8a054bSGlenn Faden } 47387c478bd9Sstevel@tonic-gate default: 4739bbec428eSgjelinek zone_perror(rt_to_str(res_type), Z_NO_RESOURCE_TYPE, B_TRUE); 4740bbec428eSgjelinek long_usage(CMD_SET, B_TRUE); 4741bbec428eSgjelinek usage(B_FALSE, HELP_RESOURCES); 47427c478bd9Sstevel@tonic-gate return; 47437c478bd9Sstevel@tonic-gate } 47447c478bd9Sstevel@tonic-gate } 47457c478bd9Sstevel@tonic-gate 47467c478bd9Sstevel@tonic-gate static void 4747bbec428eSgjelinek output_prop(FILE *fp, int pnum, char *pval, boolean_t print_notspec) 47487c478bd9Sstevel@tonic-gate { 47497c478bd9Sstevel@tonic-gate char *qstr; 47507c478bd9Sstevel@tonic-gate 47517c478bd9Sstevel@tonic-gate if (*pval != '\0') { 47527c478bd9Sstevel@tonic-gate qstr = quoteit(pval); 47530209230bSgjelinek if (pnum == PT_SWAP || pnum == PT_LOCKED) 47540209230bSgjelinek (void) fprintf(fp, "\t[%s: %s]\n", pt_to_str(pnum), 47550209230bSgjelinek qstr); 47560209230bSgjelinek else 47577c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s: %s\n", pt_to_str(pnum), qstr); 47587c478bd9Sstevel@tonic-gate free(qstr); 47597c478bd9Sstevel@tonic-gate } else if (print_notspec) 4760087719fdSdp (void) fprintf(fp, gettext("\t%s not specified\n"), 4761087719fdSdp pt_to_str(pnum)); 4762087719fdSdp } 4763087719fdSdp 4764087719fdSdp static void 4765087719fdSdp info_zonename(zone_dochandle_t handle, FILE *fp) 4766087719fdSdp { 4767087719fdSdp char zonename[ZONENAME_MAX]; 4768087719fdSdp 4769087719fdSdp if (zonecfg_get_name(handle, zonename, sizeof (zonename)) == Z_OK) 4770087719fdSdp (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_ZONENAME), 4771087719fdSdp zonename); 4772087719fdSdp else 4773087719fdSdp (void) fprintf(fp, gettext("%s not specified\n"), 4774087719fdSdp pt_to_str(PT_ZONENAME)); 47757c478bd9Sstevel@tonic-gate } 47767c478bd9Sstevel@tonic-gate 47777c478bd9Sstevel@tonic-gate static void 47787c478bd9Sstevel@tonic-gate info_zonepath(zone_dochandle_t handle, FILE *fp) 47797c478bd9Sstevel@tonic-gate { 47807c478bd9Sstevel@tonic-gate char zonepath[MAXPATHLEN]; 47817c478bd9Sstevel@tonic-gate 47827c478bd9Sstevel@tonic-gate if (zonecfg_get_zonepath(handle, zonepath, sizeof (zonepath)) == Z_OK) 47837c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_ZONEPATH), 47847c478bd9Sstevel@tonic-gate zonepath); 4785087719fdSdp else { 4786087719fdSdp (void) fprintf(fp, gettext("%s not specified\n"), 4787087719fdSdp pt_to_str(PT_ZONEPATH)); 4788087719fdSdp } 47897c478bd9Sstevel@tonic-gate } 47907c478bd9Sstevel@tonic-gate 47917c478bd9Sstevel@tonic-gate static void 47929acbbeafSnn35248 info_brand(zone_dochandle_t handle, FILE *fp) 47939acbbeafSnn35248 { 47949acbbeafSnn35248 char brand[MAXNAMELEN]; 47959acbbeafSnn35248 47969acbbeafSnn35248 if (zonecfg_get_brand(handle, brand, sizeof (brand)) == Z_OK) 47979acbbeafSnn35248 (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_BRAND), 47989acbbeafSnn35248 brand); 47999acbbeafSnn35248 else 48009acbbeafSnn35248 (void) fprintf(fp, "%s %s\n", pt_to_str(PT_BRAND), 48019acbbeafSnn35248 gettext("not specified")); 48029acbbeafSnn35248 } 48039acbbeafSnn35248 48049acbbeafSnn35248 static void 48057c478bd9Sstevel@tonic-gate info_autoboot(zone_dochandle_t handle, FILE *fp) 48067c478bd9Sstevel@tonic-gate { 48077c478bd9Sstevel@tonic-gate boolean_t autoboot; 48087c478bd9Sstevel@tonic-gate int err; 48097c478bd9Sstevel@tonic-gate 48107c478bd9Sstevel@tonic-gate if ((err = zonecfg_get_autoboot(handle, &autoboot)) == Z_OK) 48117c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_AUTOBOOT), 48127c478bd9Sstevel@tonic-gate autoboot ? "true" : "false"); 48137c478bd9Sstevel@tonic-gate else 4814bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 48157c478bd9Sstevel@tonic-gate } 48167c478bd9Sstevel@tonic-gate 48177c478bd9Sstevel@tonic-gate static void 48187c478bd9Sstevel@tonic-gate info_pool(zone_dochandle_t handle, FILE *fp) 48197c478bd9Sstevel@tonic-gate { 48207c478bd9Sstevel@tonic-gate char pool[MAXNAMELEN]; 48217c478bd9Sstevel@tonic-gate int err; 48227c478bd9Sstevel@tonic-gate 48237c478bd9Sstevel@tonic-gate if ((err = zonecfg_get_pool(handle, pool, sizeof (pool))) == Z_OK) 48247c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_POOL), pool); 48257c478bd9Sstevel@tonic-gate else 4826bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 48277c478bd9Sstevel@tonic-gate } 48287c478bd9Sstevel@tonic-gate 48297c478bd9Sstevel@tonic-gate static void 4830ffbafc53Scomay info_limitpriv(zone_dochandle_t handle, FILE *fp) 4831ffbafc53Scomay { 4832ffbafc53Scomay char *limitpriv; 4833ffbafc53Scomay int err; 4834ffbafc53Scomay 4835ffbafc53Scomay if ((err = zonecfg_get_limitpriv(handle, &limitpriv)) == Z_OK) { 4836ffbafc53Scomay (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_LIMITPRIV), 4837ffbafc53Scomay limitpriv); 4838ffbafc53Scomay free(limitpriv); 4839ffbafc53Scomay } else { 4840bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 4841ffbafc53Scomay } 4842ffbafc53Scomay } 4843ffbafc53Scomay 4844ffbafc53Scomay static void 48453f2f09c1Sdp info_bootargs(zone_dochandle_t handle, FILE *fp) 48463f2f09c1Sdp { 48473f2f09c1Sdp char bootargs[BOOTARGS_MAX]; 48483f2f09c1Sdp int err; 48493f2f09c1Sdp 48503f2f09c1Sdp if ((err = zonecfg_get_bootargs(handle, bootargs, 48513f2f09c1Sdp sizeof (bootargs))) == Z_OK) { 48523f2f09c1Sdp (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_BOOTARGS), 48533f2f09c1Sdp bootargs); 48543f2f09c1Sdp } else { 4855bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 48563f2f09c1Sdp } 48573f2f09c1Sdp } 48583f2f09c1Sdp 48593f2f09c1Sdp static void 48600209230bSgjelinek info_sched(zone_dochandle_t handle, FILE *fp) 48610209230bSgjelinek { 48620209230bSgjelinek char sched[MAXNAMELEN]; 48630209230bSgjelinek int err; 48640209230bSgjelinek 48650209230bSgjelinek if ((err = zonecfg_get_sched_class(handle, sched, sizeof (sched))) 48660209230bSgjelinek == Z_OK) { 48670209230bSgjelinek (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_SCHED), sched); 48680209230bSgjelinek } else { 4869bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 48700209230bSgjelinek } 48710209230bSgjelinek } 48720209230bSgjelinek 48730209230bSgjelinek static void 4874f4b3ec61Sdh155122 info_iptype(zone_dochandle_t handle, FILE *fp) 4875f4b3ec61Sdh155122 { 4876f4b3ec61Sdh155122 zone_iptype_t iptype; 4877f4b3ec61Sdh155122 int err; 4878f4b3ec61Sdh155122 4879f4b3ec61Sdh155122 if ((err = zonecfg_get_iptype(handle, &iptype)) == Z_OK) { 4880f4b3ec61Sdh155122 switch (iptype) { 4881f4b3ec61Sdh155122 case ZS_SHARED: 4882f4b3ec61Sdh155122 (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_IPTYPE), 4883f4b3ec61Sdh155122 "shared"); 4884f4b3ec61Sdh155122 break; 4885f4b3ec61Sdh155122 case ZS_EXCLUSIVE: 4886f4b3ec61Sdh155122 (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_IPTYPE), 4887f4b3ec61Sdh155122 "exclusive"); 4888f4b3ec61Sdh155122 break; 4889f4b3ec61Sdh155122 } 4890f4b3ec61Sdh155122 } else { 4891bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 4892f4b3ec61Sdh155122 } 4893f4b3ec61Sdh155122 } 4894f4b3ec61Sdh155122 4895f4b3ec61Sdh155122 static void 48965679c89fSjv227347 info_hostid(zone_dochandle_t handle, FILE *fp) 48975679c89fSjv227347 { 48985679c89fSjv227347 char hostidp[HW_HOSTID_LEN]; 48995679c89fSjv227347 49005679c89fSjv227347 /* 49015679c89fSjv227347 * This will display "hostid: " if there isn't a hostid or an 49025679c89fSjv227347 * error occurs while retrieving the hostid from the configuration 49035679c89fSjv227347 * file. 49045679c89fSjv227347 */ 49055679c89fSjv227347 if (zonecfg_get_hostid(handle, hostidp, sizeof (hostidp)) != Z_OK) 49065679c89fSjv227347 hostidp[0] = '\0'; 49075679c89fSjv227347 (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_HOSTID), hostidp); 49085679c89fSjv227347 } 49095679c89fSjv227347 49105679c89fSjv227347 static void 49117c478bd9Sstevel@tonic-gate output_fs(FILE *fp, struct zone_fstab *fstab) 49127c478bd9Sstevel@tonic-gate { 49137c478bd9Sstevel@tonic-gate zone_fsopt_t *this; 49147c478bd9Sstevel@tonic-gate 49157c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s:\n", rt_to_str(RT_FS)); 49167c478bd9Sstevel@tonic-gate output_prop(fp, PT_DIR, fstab->zone_fs_dir, B_TRUE); 49177c478bd9Sstevel@tonic-gate output_prop(fp, PT_SPECIAL, fstab->zone_fs_special, B_TRUE); 49187c478bd9Sstevel@tonic-gate output_prop(fp, PT_RAW, fstab->zone_fs_raw, B_TRUE); 49197c478bd9Sstevel@tonic-gate output_prop(fp, PT_TYPE, fstab->zone_fs_type, B_TRUE); 49207c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s: [", pt_to_str(PT_OPTIONS)); 49217c478bd9Sstevel@tonic-gate for (this = fstab->zone_fs_options; this != NULL; 49227c478bd9Sstevel@tonic-gate this = this->zone_fsopt_next) { 49237c478bd9Sstevel@tonic-gate if (strchr(this->zone_fsopt_opt, '=')) 49247c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\"%s\"", this->zone_fsopt_opt); 49257c478bd9Sstevel@tonic-gate else 49267c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s", this->zone_fsopt_opt); 49277c478bd9Sstevel@tonic-gate if (this->zone_fsopt_next != NULL) 49287c478bd9Sstevel@tonic-gate (void) fprintf(fp, ","); 49297c478bd9Sstevel@tonic-gate } 49307c478bd9Sstevel@tonic-gate (void) fprintf(fp, "]\n"); 49317c478bd9Sstevel@tonic-gate } 49327c478bd9Sstevel@tonic-gate 49337c478bd9Sstevel@tonic-gate static void 49347c478bd9Sstevel@tonic-gate output_ipd(FILE *fp, struct zone_fstab *ipdtab) 49357c478bd9Sstevel@tonic-gate { 49367c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s:\n", rt_to_str(RT_IPD)); 49377c478bd9Sstevel@tonic-gate output_prop(fp, PT_DIR, ipdtab->zone_fs_dir, B_TRUE); 49387c478bd9Sstevel@tonic-gate } 49397c478bd9Sstevel@tonic-gate 49407c478bd9Sstevel@tonic-gate static void 49417c478bd9Sstevel@tonic-gate info_fs(zone_dochandle_t handle, FILE *fp, cmd_t *cmd) 49427c478bd9Sstevel@tonic-gate { 49437c478bd9Sstevel@tonic-gate struct zone_fstab lookup, user; 4944bbec428eSgjelinek boolean_t output = B_FALSE; 49457c478bd9Sstevel@tonic-gate 49467c478bd9Sstevel@tonic-gate if (zonecfg_setfsent(handle) != Z_OK) 49477c478bd9Sstevel@tonic-gate return; 49487c478bd9Sstevel@tonic-gate while (zonecfg_getfsent(handle, &lookup) == Z_OK) { 49497c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs == 0) { 49507c478bd9Sstevel@tonic-gate output_fs(fp, &lookup); 49517c478bd9Sstevel@tonic-gate goto loopend; 49527c478bd9Sstevel@tonic-gate } 4953bbec428eSgjelinek if (fill_in_fstab(cmd, &user, B_TRUE) != Z_OK) 49547c478bd9Sstevel@tonic-gate goto loopend; 49557c478bd9Sstevel@tonic-gate if (strlen(user.zone_fs_dir) > 0 && 49567c478bd9Sstevel@tonic-gate strcmp(user.zone_fs_dir, lookup.zone_fs_dir) != 0) 49577c478bd9Sstevel@tonic-gate goto loopend; /* no match */ 49587c478bd9Sstevel@tonic-gate if (strlen(user.zone_fs_special) > 0 && 49597c478bd9Sstevel@tonic-gate strcmp(user.zone_fs_special, lookup.zone_fs_special) != 0) 49607c478bd9Sstevel@tonic-gate goto loopend; /* no match */ 49617c478bd9Sstevel@tonic-gate if (strlen(user.zone_fs_type) > 0 && 49627c478bd9Sstevel@tonic-gate strcmp(user.zone_fs_type, lookup.zone_fs_type) != 0) 49637c478bd9Sstevel@tonic-gate goto loopend; /* no match */ 49647c478bd9Sstevel@tonic-gate output_fs(fp, &lookup); 4965bbec428eSgjelinek output = B_TRUE; 49667c478bd9Sstevel@tonic-gate loopend: 49677c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(lookup.zone_fs_options); 49687c478bd9Sstevel@tonic-gate } 49697c478bd9Sstevel@tonic-gate (void) zonecfg_endfsent(handle); 49707c478bd9Sstevel@tonic-gate /* 49717c478bd9Sstevel@tonic-gate * If a property n/v pair was specified, warn the user if there was 49727c478bd9Sstevel@tonic-gate * nothing to output. 49737c478bd9Sstevel@tonic-gate */ 49747c478bd9Sstevel@tonic-gate if (!output && cmd->cmd_prop_nv_pairs > 0) 49757c478bd9Sstevel@tonic-gate (void) printf(gettext("No such %s resource.\n"), 49767c478bd9Sstevel@tonic-gate rt_to_str(RT_FS)); 49777c478bd9Sstevel@tonic-gate } 49787c478bd9Sstevel@tonic-gate 49797c478bd9Sstevel@tonic-gate static void 49807c478bd9Sstevel@tonic-gate info_ipd(zone_dochandle_t handle, FILE *fp, cmd_t *cmd) 49817c478bd9Sstevel@tonic-gate { 49827c478bd9Sstevel@tonic-gate struct zone_fstab lookup, user; 4983bbec428eSgjelinek boolean_t output = B_FALSE; 49847c478bd9Sstevel@tonic-gate 49857c478bd9Sstevel@tonic-gate if (zonecfg_setipdent(handle) != Z_OK) 49867c478bd9Sstevel@tonic-gate return; 49877c478bd9Sstevel@tonic-gate while (zonecfg_getipdent(handle, &lookup) == Z_OK) { 49887c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs == 0) { 49897c478bd9Sstevel@tonic-gate output_ipd(fp, &lookup); 49907c478bd9Sstevel@tonic-gate continue; 49917c478bd9Sstevel@tonic-gate } 4992bbec428eSgjelinek if (fill_in_ipdtab(cmd, &user, B_TRUE) != Z_OK) 49937c478bd9Sstevel@tonic-gate continue; 49947c478bd9Sstevel@tonic-gate if (strlen(user.zone_fs_dir) > 0 && 49957c478bd9Sstevel@tonic-gate strcmp(user.zone_fs_dir, lookup.zone_fs_dir) != 0) 49967c478bd9Sstevel@tonic-gate continue; /* no match */ 49977c478bd9Sstevel@tonic-gate output_ipd(fp, &lookup); 4998bbec428eSgjelinek output = B_TRUE; 49997c478bd9Sstevel@tonic-gate } 50007c478bd9Sstevel@tonic-gate (void) zonecfg_endipdent(handle); 50017c478bd9Sstevel@tonic-gate /* 50027c478bd9Sstevel@tonic-gate * If a property n/v pair was specified, warn the user if there was 50037c478bd9Sstevel@tonic-gate * nothing to output. 50047c478bd9Sstevel@tonic-gate */ 50057c478bd9Sstevel@tonic-gate if (!output && cmd->cmd_prop_nv_pairs > 0) 50067c478bd9Sstevel@tonic-gate (void) printf(gettext("No such %s resource.\n"), 50077c478bd9Sstevel@tonic-gate rt_to_str(RT_IPD)); 50087c478bd9Sstevel@tonic-gate } 50097c478bd9Sstevel@tonic-gate 50107c478bd9Sstevel@tonic-gate static void 50117c478bd9Sstevel@tonic-gate output_net(FILE *fp, struct zone_nwiftab *nwiftab) 50127c478bd9Sstevel@tonic-gate { 50137c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s:\n", rt_to_str(RT_NET)); 50147c478bd9Sstevel@tonic-gate output_prop(fp, PT_ADDRESS, nwiftab->zone_nwif_address, B_TRUE); 50157c478bd9Sstevel@tonic-gate output_prop(fp, PT_PHYSICAL, nwiftab->zone_nwif_physical, B_TRUE); 5016de860bd9Sgfaden output_prop(fp, PT_DEFROUTER, nwiftab->zone_nwif_defrouter, B_TRUE); 50177c478bd9Sstevel@tonic-gate } 50187c478bd9Sstevel@tonic-gate 50197c478bd9Sstevel@tonic-gate static void 50207c478bd9Sstevel@tonic-gate info_net(zone_dochandle_t handle, FILE *fp, cmd_t *cmd) 50217c478bd9Sstevel@tonic-gate { 50227c478bd9Sstevel@tonic-gate struct zone_nwiftab lookup, user; 5023bbec428eSgjelinek boolean_t output = B_FALSE; 50247c478bd9Sstevel@tonic-gate 50257c478bd9Sstevel@tonic-gate if (zonecfg_setnwifent(handle) != Z_OK) 50267c478bd9Sstevel@tonic-gate return; 50277c478bd9Sstevel@tonic-gate while (zonecfg_getnwifent(handle, &lookup) == Z_OK) { 50287c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs == 0) { 50297c478bd9Sstevel@tonic-gate output_net(fp, &lookup); 50307c478bd9Sstevel@tonic-gate continue; 50317c478bd9Sstevel@tonic-gate } 5032bbec428eSgjelinek if (fill_in_nwiftab(cmd, &user, B_TRUE) != Z_OK) 50337c478bd9Sstevel@tonic-gate continue; 50347c478bd9Sstevel@tonic-gate if (strlen(user.zone_nwif_physical) > 0 && 50357c478bd9Sstevel@tonic-gate strcmp(user.zone_nwif_physical, 50367c478bd9Sstevel@tonic-gate lookup.zone_nwif_physical) != 0) 50377c478bd9Sstevel@tonic-gate continue; /* no match */ 5038f4b3ec61Sdh155122 /* If present make sure it matches */ 50397c478bd9Sstevel@tonic-gate if (strlen(user.zone_nwif_address) > 0 && 50407c478bd9Sstevel@tonic-gate !zonecfg_same_net_address(user.zone_nwif_address, 50417c478bd9Sstevel@tonic-gate lookup.zone_nwif_address)) 50427c478bd9Sstevel@tonic-gate continue; /* no match */ 50437c478bd9Sstevel@tonic-gate output_net(fp, &lookup); 5044bbec428eSgjelinek output = B_TRUE; 50457c478bd9Sstevel@tonic-gate } 50467c478bd9Sstevel@tonic-gate (void) zonecfg_endnwifent(handle); 50477c478bd9Sstevel@tonic-gate /* 50487c478bd9Sstevel@tonic-gate * If a property n/v pair was specified, warn the user if there was 50497c478bd9Sstevel@tonic-gate * nothing to output. 50507c478bd9Sstevel@tonic-gate */ 50517c478bd9Sstevel@tonic-gate if (!output && cmd->cmd_prop_nv_pairs > 0) 50527c478bd9Sstevel@tonic-gate (void) printf(gettext("No such %s resource.\n"), 50537c478bd9Sstevel@tonic-gate rt_to_str(RT_NET)); 50547c478bd9Sstevel@tonic-gate } 50557c478bd9Sstevel@tonic-gate 50567c478bd9Sstevel@tonic-gate static void 50577c478bd9Sstevel@tonic-gate output_dev(FILE *fp, struct zone_devtab *devtab) 50587c478bd9Sstevel@tonic-gate { 505927e6fb21Sdp (void) fprintf(fp, "%s:\n", rt_to_str(RT_DEVICE)); 50607c478bd9Sstevel@tonic-gate output_prop(fp, PT_MATCH, devtab->zone_dev_match, B_TRUE); 50617c478bd9Sstevel@tonic-gate } 50627c478bd9Sstevel@tonic-gate 50637c478bd9Sstevel@tonic-gate static void 50647c478bd9Sstevel@tonic-gate info_dev(zone_dochandle_t handle, FILE *fp, cmd_t *cmd) 50657c478bd9Sstevel@tonic-gate { 50667c478bd9Sstevel@tonic-gate struct zone_devtab lookup, user; 5067bbec428eSgjelinek boolean_t output = B_FALSE; 50687c478bd9Sstevel@tonic-gate 50697c478bd9Sstevel@tonic-gate if (zonecfg_setdevent(handle) != Z_OK) 50707c478bd9Sstevel@tonic-gate return; 50717c478bd9Sstevel@tonic-gate while (zonecfg_getdevent(handle, &lookup) == Z_OK) { 50727c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs == 0) { 50737c478bd9Sstevel@tonic-gate output_dev(fp, &lookup); 50747c478bd9Sstevel@tonic-gate continue; 50757c478bd9Sstevel@tonic-gate } 5076bbec428eSgjelinek if (fill_in_devtab(cmd, &user, B_TRUE) != Z_OK) 50777c478bd9Sstevel@tonic-gate continue; 50787c478bd9Sstevel@tonic-gate if (strlen(user.zone_dev_match) > 0 && 50797c478bd9Sstevel@tonic-gate strcmp(user.zone_dev_match, lookup.zone_dev_match) != 0) 50807c478bd9Sstevel@tonic-gate continue; /* no match */ 50817c478bd9Sstevel@tonic-gate output_dev(fp, &lookup); 5082bbec428eSgjelinek output = B_TRUE; 50837c478bd9Sstevel@tonic-gate } 50847c478bd9Sstevel@tonic-gate (void) zonecfg_enddevent(handle); 50857c478bd9Sstevel@tonic-gate /* 50867c478bd9Sstevel@tonic-gate * If a property n/v pair was specified, warn the user if there was 50877c478bd9Sstevel@tonic-gate * nothing to output. 50887c478bd9Sstevel@tonic-gate */ 50897c478bd9Sstevel@tonic-gate if (!output && cmd->cmd_prop_nv_pairs > 0) 50907c478bd9Sstevel@tonic-gate (void) printf(gettext("No such %s resource.\n"), 50917c478bd9Sstevel@tonic-gate rt_to_str(RT_DEVICE)); 50927c478bd9Sstevel@tonic-gate } 50937c478bd9Sstevel@tonic-gate 50947c478bd9Sstevel@tonic-gate static void 50957c478bd9Sstevel@tonic-gate output_rctl(FILE *fp, struct zone_rctltab *rctltab) 50967c478bd9Sstevel@tonic-gate { 50977c478bd9Sstevel@tonic-gate struct zone_rctlvaltab *valptr; 50987c478bd9Sstevel@tonic-gate 50997c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s:\n", rt_to_str(RT_RCTL)); 51007c478bd9Sstevel@tonic-gate output_prop(fp, PT_NAME, rctltab->zone_rctl_name, B_TRUE); 51017c478bd9Sstevel@tonic-gate for (valptr = rctltab->zone_rctl_valptr; valptr != NULL; 51027c478bd9Sstevel@tonic-gate valptr = valptr->zone_rctlval_next) { 51037c478bd9Sstevel@tonic-gate fprintf(fp, "\t%s: (%s=%s,%s=%s,%s=%s)\n", 51047c478bd9Sstevel@tonic-gate pt_to_str(PT_VALUE), 51057c478bd9Sstevel@tonic-gate pt_to_str(PT_PRIV), valptr->zone_rctlval_priv, 51067c478bd9Sstevel@tonic-gate pt_to_str(PT_LIMIT), valptr->zone_rctlval_limit, 51077c478bd9Sstevel@tonic-gate pt_to_str(PT_ACTION), valptr->zone_rctlval_action); 51087c478bd9Sstevel@tonic-gate } 51097c478bd9Sstevel@tonic-gate } 51107c478bd9Sstevel@tonic-gate 51117c478bd9Sstevel@tonic-gate static void 51127c478bd9Sstevel@tonic-gate info_rctl(zone_dochandle_t handle, FILE *fp, cmd_t *cmd) 51137c478bd9Sstevel@tonic-gate { 51147c478bd9Sstevel@tonic-gate struct zone_rctltab lookup, user; 5115bbec428eSgjelinek boolean_t output = B_FALSE; 51167c478bd9Sstevel@tonic-gate 51177c478bd9Sstevel@tonic-gate if (zonecfg_setrctlent(handle) != Z_OK) 51187c478bd9Sstevel@tonic-gate return; 51197c478bd9Sstevel@tonic-gate while (zonecfg_getrctlent(handle, &lookup) == Z_OK) { 51207c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs == 0) { 51217c478bd9Sstevel@tonic-gate output_rctl(fp, &lookup); 5122bbec428eSgjelinek } else if (fill_in_rctltab(cmd, &user, B_TRUE) == Z_OK && 51237c478bd9Sstevel@tonic-gate (strlen(user.zone_rctl_name) == 0 || 51247c478bd9Sstevel@tonic-gate strcmp(user.zone_rctl_name, lookup.zone_rctl_name) == 0)) { 51257c478bd9Sstevel@tonic-gate output_rctl(fp, &lookup); 5126bbec428eSgjelinek output = B_TRUE; 51277c478bd9Sstevel@tonic-gate } 51287c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(lookup.zone_rctl_valptr); 51297c478bd9Sstevel@tonic-gate } 51307c478bd9Sstevel@tonic-gate (void) zonecfg_endrctlent(handle); 51317c478bd9Sstevel@tonic-gate /* 51327c478bd9Sstevel@tonic-gate * If a property n/v pair was specified, warn the user if there was 51337c478bd9Sstevel@tonic-gate * nothing to output. 51347c478bd9Sstevel@tonic-gate */ 51357c478bd9Sstevel@tonic-gate if (!output && cmd->cmd_prop_nv_pairs > 0) 51367c478bd9Sstevel@tonic-gate (void) printf(gettext("No such %s resource.\n"), 51377c478bd9Sstevel@tonic-gate rt_to_str(RT_RCTL)); 51387c478bd9Sstevel@tonic-gate } 51397c478bd9Sstevel@tonic-gate 51407c478bd9Sstevel@tonic-gate static void 51417c478bd9Sstevel@tonic-gate output_attr(FILE *fp, struct zone_attrtab *attrtab) 51427c478bd9Sstevel@tonic-gate { 51437c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s:\n", rt_to_str(RT_ATTR)); 51447c478bd9Sstevel@tonic-gate output_prop(fp, PT_NAME, attrtab->zone_attr_name, B_TRUE); 51457c478bd9Sstevel@tonic-gate output_prop(fp, PT_TYPE, attrtab->zone_attr_type, B_TRUE); 51467c478bd9Sstevel@tonic-gate output_prop(fp, PT_VALUE, attrtab->zone_attr_value, B_TRUE); 51477c478bd9Sstevel@tonic-gate } 51487c478bd9Sstevel@tonic-gate 51497c478bd9Sstevel@tonic-gate static void 51507c478bd9Sstevel@tonic-gate info_attr(zone_dochandle_t handle, FILE *fp, cmd_t *cmd) 51517c478bd9Sstevel@tonic-gate { 51527c478bd9Sstevel@tonic-gate struct zone_attrtab lookup, user; 5153bbec428eSgjelinek boolean_t output = B_FALSE; 51547c478bd9Sstevel@tonic-gate 51557c478bd9Sstevel@tonic-gate if (zonecfg_setattrent(handle) != Z_OK) 51567c478bd9Sstevel@tonic-gate return; 51577c478bd9Sstevel@tonic-gate while (zonecfg_getattrent(handle, &lookup) == Z_OK) { 51587c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs == 0) { 51597c478bd9Sstevel@tonic-gate output_attr(fp, &lookup); 51607c478bd9Sstevel@tonic-gate continue; 51617c478bd9Sstevel@tonic-gate } 5162bbec428eSgjelinek if (fill_in_attrtab(cmd, &user, B_TRUE) != Z_OK) 51637c478bd9Sstevel@tonic-gate continue; 51647c478bd9Sstevel@tonic-gate if (strlen(user.zone_attr_name) > 0 && 51657c478bd9Sstevel@tonic-gate strcmp(user.zone_attr_name, lookup.zone_attr_name) != 0) 51667c478bd9Sstevel@tonic-gate continue; /* no match */ 51677c478bd9Sstevel@tonic-gate if (strlen(user.zone_attr_type) > 0 && 51687c478bd9Sstevel@tonic-gate strcmp(user.zone_attr_type, lookup.zone_attr_type) != 0) 51697c478bd9Sstevel@tonic-gate continue; /* no match */ 51707c478bd9Sstevel@tonic-gate if (strlen(user.zone_attr_value) > 0 && 51717c478bd9Sstevel@tonic-gate strcmp(user.zone_attr_value, lookup.zone_attr_value) != 0) 51727c478bd9Sstevel@tonic-gate continue; /* no match */ 51737c478bd9Sstevel@tonic-gate output_attr(fp, &lookup); 5174bbec428eSgjelinek output = B_TRUE; 51757c478bd9Sstevel@tonic-gate } 51767c478bd9Sstevel@tonic-gate (void) zonecfg_endattrent(handle); 51777c478bd9Sstevel@tonic-gate /* 51787c478bd9Sstevel@tonic-gate * If a property n/v pair was specified, warn the user if there was 51797c478bd9Sstevel@tonic-gate * nothing to output. 51807c478bd9Sstevel@tonic-gate */ 51817c478bd9Sstevel@tonic-gate if (!output && cmd->cmd_prop_nv_pairs > 0) 51827c478bd9Sstevel@tonic-gate (void) printf(gettext("No such %s resource.\n"), 51837c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR)); 51847c478bd9Sstevel@tonic-gate } 51857c478bd9Sstevel@tonic-gate 5186fa9e4066Sahrens static void 5187fa9e4066Sahrens output_ds(FILE *fp, struct zone_dstab *dstab) 5188fa9e4066Sahrens { 5189fa9e4066Sahrens (void) fprintf(fp, "%s:\n", rt_to_str(RT_DATASET)); 5190fa9e4066Sahrens output_prop(fp, PT_NAME, dstab->zone_dataset_name, B_TRUE); 5191fa9e4066Sahrens } 5192fa9e4066Sahrens 5193fa9e4066Sahrens static void 5194fa9e4066Sahrens info_ds(zone_dochandle_t handle, FILE *fp, cmd_t *cmd) 5195fa9e4066Sahrens { 5196fa9e4066Sahrens struct zone_dstab lookup, user; 5197bbec428eSgjelinek boolean_t output = B_FALSE; 5198fa9e4066Sahrens 51990209230bSgjelinek if (zonecfg_setdsent(handle) != Z_OK) 5200fa9e4066Sahrens return; 5201fa9e4066Sahrens while (zonecfg_getdsent(handle, &lookup) == Z_OK) { 5202fa9e4066Sahrens if (cmd->cmd_prop_nv_pairs == 0) { 5203fa9e4066Sahrens output_ds(fp, &lookup); 5204fa9e4066Sahrens continue; 5205fa9e4066Sahrens } 5206bbec428eSgjelinek if (fill_in_dstab(cmd, &user, B_TRUE) != Z_OK) 5207fa9e4066Sahrens continue; 5208fa9e4066Sahrens if (strlen(user.zone_dataset_name) > 0 && 5209fa9e4066Sahrens strcmp(user.zone_dataset_name, 5210fa9e4066Sahrens lookup.zone_dataset_name) != 0) 5211fa9e4066Sahrens continue; /* no match */ 5212fa9e4066Sahrens output_ds(fp, &lookup); 5213bbec428eSgjelinek output = B_TRUE; 5214fa9e4066Sahrens } 5215fa9e4066Sahrens (void) zonecfg_enddsent(handle); 5216fa9e4066Sahrens /* 5217fa9e4066Sahrens * If a property n/v pair was specified, warn the user if there was 5218fa9e4066Sahrens * nothing to output. 5219fa9e4066Sahrens */ 5220fa9e4066Sahrens if (!output && cmd->cmd_prop_nv_pairs > 0) 5221fa9e4066Sahrens (void) printf(gettext("No such %s resource.\n"), 5222fa9e4066Sahrens rt_to_str(RT_DATASET)); 5223fa9e4066Sahrens } 5224fa9e4066Sahrens 52250209230bSgjelinek static void 52260209230bSgjelinek output_pset(FILE *fp, struct zone_psettab *psettab) 52270209230bSgjelinek { 52280209230bSgjelinek (void) fprintf(fp, "%s:\n", rt_to_str(RT_DCPU)); 52290209230bSgjelinek if (strcmp(psettab->zone_ncpu_min, psettab->zone_ncpu_max) == 0) 52300209230bSgjelinek (void) fprintf(fp, "\t%s: %s\n", pt_to_str(PT_NCPUS), 52310209230bSgjelinek psettab->zone_ncpu_max); 52320209230bSgjelinek else 52330209230bSgjelinek (void) fprintf(fp, "\t%s: %s-%s\n", pt_to_str(PT_NCPUS), 52340209230bSgjelinek psettab->zone_ncpu_min, psettab->zone_ncpu_max); 52350209230bSgjelinek if (psettab->zone_importance[0] != '\0') 52360209230bSgjelinek (void) fprintf(fp, "\t%s: %s\n", pt_to_str(PT_IMPORTANCE), 52370209230bSgjelinek psettab->zone_importance); 52380209230bSgjelinek } 52390209230bSgjelinek 52400209230bSgjelinek static void 52410209230bSgjelinek info_pset(zone_dochandle_t handle, FILE *fp) 52420209230bSgjelinek { 52430209230bSgjelinek struct zone_psettab lookup; 52440209230bSgjelinek 52450209230bSgjelinek if (zonecfg_getpsetent(handle, &lookup) == Z_OK) 52460209230bSgjelinek output_pset(fp, &lookup); 52470209230bSgjelinek } 52480209230bSgjelinek 52490209230bSgjelinek static void 5250c97ad5cdSakolb output_pcap(FILE *fp) 5251c97ad5cdSakolb { 5252c97ad5cdSakolb uint64_t cap; 5253c97ad5cdSakolb 5254c97ad5cdSakolb if (zonecfg_get_aliased_rctl(handle, ALIAS_CPUCAP, &cap) == Z_OK) { 5255c97ad5cdSakolb float scaled = (float)cap / 100; 5256c97ad5cdSakolb (void) fprintf(fp, "%s:\n", rt_to_str(RT_PCAP)); 5257c97ad5cdSakolb (void) fprintf(fp, "\t[%s: %.2f]\n", pt_to_str(PT_NCPUS), 5258c97ad5cdSakolb scaled); 5259c97ad5cdSakolb } 5260c97ad5cdSakolb } 5261c97ad5cdSakolb 5262c97ad5cdSakolb static void 5263c97ad5cdSakolb info_pcap(FILE *fp) 5264c97ad5cdSakolb { 5265c97ad5cdSakolb output_pcap(fp); 5266c97ad5cdSakolb } 5267c97ad5cdSakolb 5268c97ad5cdSakolb 5269c97ad5cdSakolb static void 52700209230bSgjelinek info_aliased_rctl(zone_dochandle_t handle, FILE *fp, char *alias) 52710209230bSgjelinek { 52720209230bSgjelinek uint64_t limit; 52730209230bSgjelinek 52740209230bSgjelinek if (zonecfg_get_aliased_rctl(handle, alias, &limit) == Z_OK) { 52750209230bSgjelinek /* convert memory based properties */ 52760209230bSgjelinek if (strcmp(alias, ALIAS_MAXSHMMEM) == 0) { 52770209230bSgjelinek char buf[128]; 52780209230bSgjelinek 52790209230bSgjelinek (void) snprintf(buf, sizeof (buf), "%llu", limit); 52800209230bSgjelinek bytes_to_units(buf, buf, sizeof (buf)); 52810209230bSgjelinek (void) fprintf(fp, "[%s: %s]\n", alias, buf); 52820209230bSgjelinek return; 52830209230bSgjelinek } 52840209230bSgjelinek 52850209230bSgjelinek (void) fprintf(fp, "[%s: %llu]\n", alias, limit); 52860209230bSgjelinek } 52870209230bSgjelinek } 52880209230bSgjelinek 52890209230bSgjelinek static void 52900209230bSgjelinek bytes_to_units(char *str, char *buf, int bufsize) 52910209230bSgjelinek { 52920209230bSgjelinek unsigned long long num; 52930209230bSgjelinek unsigned long long save = 0; 52940209230bSgjelinek char *units = "BKMGT"; 52950209230bSgjelinek char *up = units; 52960209230bSgjelinek 52970209230bSgjelinek num = strtoll(str, NULL, 10); 52980209230bSgjelinek 52990209230bSgjelinek if (num < 1024) { 53000209230bSgjelinek (void) snprintf(buf, bufsize, "%llu", num); 53010209230bSgjelinek return; 53020209230bSgjelinek } 53030209230bSgjelinek 53040209230bSgjelinek while ((num >= 1024) && (*up != 'T')) { 53050209230bSgjelinek up++; /* next unit of measurement */ 53060209230bSgjelinek save = num; 53070209230bSgjelinek num = (num + 512) >> 10; 53080209230bSgjelinek } 53090209230bSgjelinek 53100209230bSgjelinek /* check if we should output a fraction. snprintf will round for us */ 53110209230bSgjelinek if (save % 1024 != 0 && ((save >> 10) < 10)) 53120209230bSgjelinek (void) snprintf(buf, bufsize, "%2.1f%c", ((float)save / 1024), 53130209230bSgjelinek *up); 53140209230bSgjelinek else 53150209230bSgjelinek (void) snprintf(buf, bufsize, "%llu%c", num, *up); 53160209230bSgjelinek } 53170209230bSgjelinek 53180209230bSgjelinek static void 53190209230bSgjelinek output_mcap(FILE *fp, struct zone_mcaptab *mcaptab, int showswap, 53200209230bSgjelinek uint64_t maxswap, int showlocked, uint64_t maxlocked) 53210209230bSgjelinek { 53220209230bSgjelinek char buf[128]; 53230209230bSgjelinek 53240209230bSgjelinek (void) fprintf(fp, "%s:\n", rt_to_str(RT_MCAP)); 53250209230bSgjelinek if (mcaptab->zone_physmem_cap[0] != '\0') { 53260209230bSgjelinek bytes_to_units(mcaptab->zone_physmem_cap, buf, sizeof (buf)); 53270209230bSgjelinek output_prop(fp, PT_PHYSICAL, buf, B_TRUE); 53280209230bSgjelinek } 53290209230bSgjelinek 53300209230bSgjelinek if (showswap == Z_OK) { 53310209230bSgjelinek (void) snprintf(buf, sizeof (buf), "%llu", maxswap); 53320209230bSgjelinek bytes_to_units(buf, buf, sizeof (buf)); 53330209230bSgjelinek output_prop(fp, PT_SWAP, buf, B_TRUE); 53340209230bSgjelinek } 53350209230bSgjelinek 53360209230bSgjelinek if (showlocked == Z_OK) { 53370209230bSgjelinek (void) snprintf(buf, sizeof (buf), "%llu", maxlocked); 53380209230bSgjelinek bytes_to_units(buf, buf, sizeof (buf)); 53390209230bSgjelinek output_prop(fp, PT_LOCKED, buf, B_TRUE); 53400209230bSgjelinek } 53410209230bSgjelinek } 53420209230bSgjelinek 53430209230bSgjelinek static void 53440209230bSgjelinek info_mcap(zone_dochandle_t handle, FILE *fp) 53450209230bSgjelinek { 53460209230bSgjelinek int res1, res2, res3; 53470209230bSgjelinek uint64_t swap_limit; 53480209230bSgjelinek uint64_t locked_limit; 53490209230bSgjelinek struct zone_mcaptab lookup; 53500209230bSgjelinek 53510209230bSgjelinek bzero(&lookup, sizeof (lookup)); 53520209230bSgjelinek res1 = zonecfg_getmcapent(handle, &lookup); 53530209230bSgjelinek res2 = zonecfg_get_aliased_rctl(handle, ALIAS_MAXSWAP, &swap_limit); 53540209230bSgjelinek res3 = zonecfg_get_aliased_rctl(handle, ALIAS_MAXLOCKEDMEM, 53550209230bSgjelinek &locked_limit); 53560209230bSgjelinek 53570209230bSgjelinek if (res1 == Z_OK || res2 == Z_OK || res3 == Z_OK) 53580209230bSgjelinek output_mcap(fp, &lookup, res2, swap_limit, res3, locked_limit); 53590209230bSgjelinek } 53600209230bSgjelinek 5361cb8a054bSGlenn Faden static void 5362cb8a054bSGlenn Faden output_auth(FILE *fp, struct zone_admintab *admintab) 5363cb8a054bSGlenn Faden { 5364cb8a054bSGlenn Faden (void) fprintf(fp, "%s:\n", rt_to_str(RT_ADMIN)); 5365cb8a054bSGlenn Faden output_prop(fp, PT_USER, admintab->zone_admin_user, B_TRUE); 5366cb8a054bSGlenn Faden output_prop(fp, PT_AUTHS, admintab->zone_admin_auths, B_TRUE); 5367cb8a054bSGlenn Faden } 5368cb8a054bSGlenn Faden 5369cb8a054bSGlenn Faden static void 5370cb8a054bSGlenn Faden info_auth(zone_dochandle_t handle, FILE *fp, cmd_t *cmd) 5371cb8a054bSGlenn Faden { 5372cb8a054bSGlenn Faden struct zone_admintab lookup, user; 5373cb8a054bSGlenn Faden boolean_t output = B_FALSE; 5374cb8a054bSGlenn Faden int err; 5375cb8a054bSGlenn Faden 5376cb8a054bSGlenn Faden if ((err = zonecfg_setadminent(handle)) != Z_OK) { 5377cb8a054bSGlenn Faden zone_perror(zone, err, B_TRUE); 5378cb8a054bSGlenn Faden return; 5379cb8a054bSGlenn Faden } 5380cb8a054bSGlenn Faden while (zonecfg_getadminent(handle, &lookup) == Z_OK) { 5381cb8a054bSGlenn Faden if (cmd->cmd_prop_nv_pairs == 0) { 5382cb8a054bSGlenn Faden output_auth(fp, &lookup); 5383cb8a054bSGlenn Faden continue; 5384cb8a054bSGlenn Faden } 5385cb8a054bSGlenn Faden if (fill_in_admintab(cmd, &user, B_TRUE) != Z_OK) 5386cb8a054bSGlenn Faden continue; 5387cb8a054bSGlenn Faden if (strlen(user.zone_admin_user) > 0 && 5388cb8a054bSGlenn Faden strcmp(user.zone_admin_user, lookup.zone_admin_user) != 0) 5389cb8a054bSGlenn Faden continue; /* no match */ 5390cb8a054bSGlenn Faden output_auth(fp, &lookup); 5391cb8a054bSGlenn Faden output = B_TRUE; 5392cb8a054bSGlenn Faden } 5393cb8a054bSGlenn Faden (void) zonecfg_endadminent(handle); 5394cb8a054bSGlenn Faden /* 5395cb8a054bSGlenn Faden * If a property n/v pair was specified, warn the user if there was 5396cb8a054bSGlenn Faden * nothing to output. 5397cb8a054bSGlenn Faden */ 5398cb8a054bSGlenn Faden if (!output && cmd->cmd_prop_nv_pairs > 0) 5399cb8a054bSGlenn Faden (void) printf(gettext("No such %s resource.\n"), 5400cb8a054bSGlenn Faden rt_to_str(RT_ADMIN)); 5401cb8a054bSGlenn Faden } 5402cb8a054bSGlenn Faden 54037c478bd9Sstevel@tonic-gate void 54047c478bd9Sstevel@tonic-gate info_func(cmd_t *cmd) 54057c478bd9Sstevel@tonic-gate { 54067c478bd9Sstevel@tonic-gate FILE *fp = stdout; 5407bbec428eSgjelinek boolean_t need_to_close = B_FALSE; 54087c478bd9Sstevel@tonic-gate char *pager; 54090209230bSgjelinek int type; 54100209230bSgjelinek int res1, res2; 54110209230bSgjelinek uint64_t swap_limit; 54120209230bSgjelinek uint64_t locked_limit; 54133042b8b5Sbatschul struct stat statbuf; 54147c478bd9Sstevel@tonic-gate 54157c478bd9Sstevel@tonic-gate assert(cmd != NULL); 54167c478bd9Sstevel@tonic-gate 5417bbec428eSgjelinek if (initialize(B_TRUE) != Z_OK) 54187c478bd9Sstevel@tonic-gate return; 54197c478bd9Sstevel@tonic-gate 54207c478bd9Sstevel@tonic-gate /* don't page error output */ 54217c478bd9Sstevel@tonic-gate if (interactive_mode) { 54227c478bd9Sstevel@tonic-gate if ((pager = getenv("PAGER")) == NULL) 54237c478bd9Sstevel@tonic-gate pager = PAGER; 54243042b8b5Sbatschul 54253042b8b5Sbatschul if (stat(pager, &statbuf) == 0) { 54267c478bd9Sstevel@tonic-gate if ((fp = popen(pager, "w")) != NULL) 5427bbec428eSgjelinek need_to_close = B_TRUE; 54283042b8b5Sbatschul else 54293042b8b5Sbatschul fp = stdout; 54303042b8b5Sbatschul } else { 54313042b8b5Sbatschul zerr(gettext("PAGER %s does not exist (%s)."), 54323042b8b5Sbatschul pager, strerror(errno)); 54333042b8b5Sbatschul } 54343042b8b5Sbatschul 54357c478bd9Sstevel@tonic-gate setbuf(fp, NULL); 54367c478bd9Sstevel@tonic-gate } 54377c478bd9Sstevel@tonic-gate 54387c478bd9Sstevel@tonic-gate if (!global_scope) { 54397c478bd9Sstevel@tonic-gate switch (resource_scope) { 54407c478bd9Sstevel@tonic-gate case RT_FS: 54417c478bd9Sstevel@tonic-gate output_fs(fp, &in_progress_fstab); 54427c478bd9Sstevel@tonic-gate break; 54437c478bd9Sstevel@tonic-gate case RT_IPD: 54447c478bd9Sstevel@tonic-gate output_ipd(fp, &in_progress_ipdtab); 54457c478bd9Sstevel@tonic-gate break; 54467c478bd9Sstevel@tonic-gate case RT_NET: 54477c478bd9Sstevel@tonic-gate output_net(fp, &in_progress_nwiftab); 54487c478bd9Sstevel@tonic-gate break; 54497c478bd9Sstevel@tonic-gate case RT_DEVICE: 54507c478bd9Sstevel@tonic-gate output_dev(fp, &in_progress_devtab); 54517c478bd9Sstevel@tonic-gate break; 54527c478bd9Sstevel@tonic-gate case RT_RCTL: 54537c478bd9Sstevel@tonic-gate output_rctl(fp, &in_progress_rctltab); 54547c478bd9Sstevel@tonic-gate break; 54557c478bd9Sstevel@tonic-gate case RT_ATTR: 54567c478bd9Sstevel@tonic-gate output_attr(fp, &in_progress_attrtab); 54577c478bd9Sstevel@tonic-gate break; 5458fa9e4066Sahrens case RT_DATASET: 5459fa9e4066Sahrens output_ds(fp, &in_progress_dstab); 5460fa9e4066Sahrens break; 54610209230bSgjelinek case RT_DCPU: 54620209230bSgjelinek output_pset(fp, &in_progress_psettab); 54630209230bSgjelinek break; 5464c97ad5cdSakolb case RT_PCAP: 5465c97ad5cdSakolb output_pcap(fp); 5466c97ad5cdSakolb break; 54670209230bSgjelinek case RT_MCAP: 54680209230bSgjelinek res1 = zonecfg_get_aliased_rctl(handle, ALIAS_MAXSWAP, 54690209230bSgjelinek &swap_limit); 54700209230bSgjelinek res2 = zonecfg_get_aliased_rctl(handle, 54710209230bSgjelinek ALIAS_MAXLOCKEDMEM, &locked_limit); 54720209230bSgjelinek output_mcap(fp, &in_progress_mcaptab, res1, swap_limit, 54730209230bSgjelinek res2, locked_limit); 54740209230bSgjelinek break; 5475cb8a054bSGlenn Faden case RT_ADMIN: 5476cb8a054bSGlenn Faden output_auth(fp, &in_progress_admintab); 5477cb8a054bSGlenn Faden break; 54787c478bd9Sstevel@tonic-gate } 54797c478bd9Sstevel@tonic-gate goto cleanup; 54807c478bd9Sstevel@tonic-gate } 54817c478bd9Sstevel@tonic-gate 54820209230bSgjelinek type = cmd->cmd_res_type; 54830209230bSgjelinek 54840209230bSgjelinek if (gz_invalid_rt_property(type)) { 54850209230bSgjelinek zerr(gettext("%s is not a valid property for the global zone."), 54860209230bSgjelinek rt_to_str(type)); 54870209230bSgjelinek goto cleanup; 54880209230bSgjelinek } 54890209230bSgjelinek 54900209230bSgjelinek if (gz_invalid_resource(type)) { 54910209230bSgjelinek zerr(gettext("%s is not a valid resource for the global zone."), 54920209230bSgjelinek rt_to_str(type)); 54930209230bSgjelinek goto cleanup; 54940209230bSgjelinek } 54950209230bSgjelinek 54967c478bd9Sstevel@tonic-gate switch (cmd->cmd_res_type) { 54977c478bd9Sstevel@tonic-gate case RT_UNKNOWN: 5498087719fdSdp info_zonename(handle, fp); 54990209230bSgjelinek if (!global_zone) { 55007c478bd9Sstevel@tonic-gate info_zonepath(handle, fp); 55019acbbeafSnn35248 info_brand(handle, fp); 55027c478bd9Sstevel@tonic-gate info_autoboot(handle, fp); 55033f2f09c1Sdp info_bootargs(handle, fp); 55040209230bSgjelinek } 55057c478bd9Sstevel@tonic-gate info_pool(handle, fp); 55060209230bSgjelinek if (!global_zone) { 5507ffbafc53Scomay info_limitpriv(handle, fp); 55080209230bSgjelinek info_sched(handle, fp); 5509f4b3ec61Sdh155122 info_iptype(handle, fp); 55105679c89fSjv227347 info_hostid(handle, fp); 55110209230bSgjelinek } 55120209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXLWPS); 55130209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXSHMMEM); 55140209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXSHMIDS); 55150209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXMSGIDS); 55160209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXSEMIDS); 55170209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_SHARES); 55180209230bSgjelinek if (!global_zone) { 55197c478bd9Sstevel@tonic-gate info_ipd(handle, fp, cmd); 55207c478bd9Sstevel@tonic-gate info_fs(handle, fp, cmd); 55217c478bd9Sstevel@tonic-gate info_net(handle, fp, cmd); 55227c478bd9Sstevel@tonic-gate info_dev(handle, fp, cmd); 55230209230bSgjelinek } 55240209230bSgjelinek info_pset(handle, fp); 5525c97ad5cdSakolb info_pcap(fp); 55260209230bSgjelinek info_mcap(handle, fp); 55270209230bSgjelinek if (!global_zone) { 55287c478bd9Sstevel@tonic-gate info_attr(handle, fp, cmd); 5529fa9e4066Sahrens info_ds(handle, fp, cmd); 5530cb8a054bSGlenn Faden info_auth(handle, fp, cmd); 55310209230bSgjelinek } 55320209230bSgjelinek info_rctl(handle, fp, cmd); 55337c478bd9Sstevel@tonic-gate break; 5534087719fdSdp case RT_ZONENAME: 5535087719fdSdp info_zonename(handle, fp); 5536087719fdSdp break; 55377c478bd9Sstevel@tonic-gate case RT_ZONEPATH: 55387c478bd9Sstevel@tonic-gate info_zonepath(handle, fp); 55397c478bd9Sstevel@tonic-gate break; 55409acbbeafSnn35248 case RT_BRAND: 55419acbbeafSnn35248 info_brand(handle, fp); 55429acbbeafSnn35248 break; 55437c478bd9Sstevel@tonic-gate case RT_AUTOBOOT: 55447c478bd9Sstevel@tonic-gate info_autoboot(handle, fp); 55457c478bd9Sstevel@tonic-gate break; 55467c478bd9Sstevel@tonic-gate case RT_POOL: 55477c478bd9Sstevel@tonic-gate info_pool(handle, fp); 55487c478bd9Sstevel@tonic-gate break; 5549ffbafc53Scomay case RT_LIMITPRIV: 5550ffbafc53Scomay info_limitpriv(handle, fp); 5551ffbafc53Scomay break; 55523f2f09c1Sdp case RT_BOOTARGS: 55533f2f09c1Sdp info_bootargs(handle, fp); 55543f2f09c1Sdp break; 55550209230bSgjelinek case RT_SCHED: 55560209230bSgjelinek info_sched(handle, fp); 55570209230bSgjelinek break; 5558f4b3ec61Sdh155122 case RT_IPTYPE: 5559f4b3ec61Sdh155122 info_iptype(handle, fp); 5560f4b3ec61Sdh155122 break; 55610209230bSgjelinek case RT_MAXLWPS: 55620209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXLWPS); 55630209230bSgjelinek break; 55640209230bSgjelinek case RT_MAXSHMMEM: 55650209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXSHMMEM); 55660209230bSgjelinek break; 55670209230bSgjelinek case RT_MAXSHMIDS: 55680209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXSHMIDS); 55690209230bSgjelinek break; 55700209230bSgjelinek case RT_MAXMSGIDS: 55710209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXMSGIDS); 55720209230bSgjelinek break; 55730209230bSgjelinek case RT_MAXSEMIDS: 55740209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXSEMIDS); 55750209230bSgjelinek break; 55760209230bSgjelinek case RT_SHARES: 55770209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_SHARES); 55780209230bSgjelinek break; 55797c478bd9Sstevel@tonic-gate case RT_FS: 55807c478bd9Sstevel@tonic-gate info_fs(handle, fp, cmd); 55817c478bd9Sstevel@tonic-gate break; 55827c478bd9Sstevel@tonic-gate case RT_IPD: 55837c478bd9Sstevel@tonic-gate info_ipd(handle, fp, cmd); 55847c478bd9Sstevel@tonic-gate break; 55857c478bd9Sstevel@tonic-gate case RT_NET: 55867c478bd9Sstevel@tonic-gate info_net(handle, fp, cmd); 55877c478bd9Sstevel@tonic-gate break; 55887c478bd9Sstevel@tonic-gate case RT_DEVICE: 55897c478bd9Sstevel@tonic-gate info_dev(handle, fp, cmd); 55907c478bd9Sstevel@tonic-gate break; 55917c478bd9Sstevel@tonic-gate case RT_RCTL: 55927c478bd9Sstevel@tonic-gate info_rctl(handle, fp, cmd); 55937c478bd9Sstevel@tonic-gate break; 55947c478bd9Sstevel@tonic-gate case RT_ATTR: 55957c478bd9Sstevel@tonic-gate info_attr(handle, fp, cmd); 55967c478bd9Sstevel@tonic-gate break; 5597fa9e4066Sahrens case RT_DATASET: 5598fa9e4066Sahrens info_ds(handle, fp, cmd); 5599fa9e4066Sahrens break; 56000209230bSgjelinek case RT_DCPU: 56010209230bSgjelinek info_pset(handle, fp); 56020209230bSgjelinek break; 5603c97ad5cdSakolb case RT_PCAP: 5604c97ad5cdSakolb info_pcap(fp); 5605c97ad5cdSakolb break; 56060209230bSgjelinek case RT_MCAP: 56070209230bSgjelinek info_mcap(handle, fp); 56080209230bSgjelinek break; 56095679c89fSjv227347 case RT_HOSTID: 56105679c89fSjv227347 info_hostid(handle, fp); 56115679c89fSjv227347 break; 5612cb8a054bSGlenn Faden case RT_ADMIN: 5613cb8a054bSGlenn Faden info_auth(handle, fp, cmd); 5614cb8a054bSGlenn Faden break; 56157c478bd9Sstevel@tonic-gate default: 56167c478bd9Sstevel@tonic-gate zone_perror(rt_to_str(cmd->cmd_res_type), Z_NO_RESOURCE_TYPE, 5617bbec428eSgjelinek B_TRUE); 56187c478bd9Sstevel@tonic-gate } 56197c478bd9Sstevel@tonic-gate 56207c478bd9Sstevel@tonic-gate cleanup: 56217c478bd9Sstevel@tonic-gate if (need_to_close) 56227c478bd9Sstevel@tonic-gate (void) pclose(fp); 56237c478bd9Sstevel@tonic-gate } 56247c478bd9Sstevel@tonic-gate 5625087719fdSdp /* 5626087719fdSdp * Helper function for verify-- checks that a required string property 5627087719fdSdp * exists. 5628087719fdSdp */ 5629087719fdSdp static void 5630087719fdSdp check_reqd_prop(char *attr, int rt, int pt, int *ret_val) 56317c478bd9Sstevel@tonic-gate { 5632087719fdSdp if (strlen(attr) == 0) { 5633087719fdSdp zerr(gettext("%s: %s not specified"), rt_to_str(rt), 5634087719fdSdp pt_to_str(pt)); 5635bbec428eSgjelinek saw_error = B_TRUE; 5636087719fdSdp if (*ret_val == Z_OK) 5637087719fdSdp *ret_val = Z_REQD_PROPERTY_MISSING; 56387c478bd9Sstevel@tonic-gate } 56397c478bd9Sstevel@tonic-gate } 56407c478bd9Sstevel@tonic-gate 56419acbbeafSnn35248 static int 56429acbbeafSnn35248 do_subproc(char *cmdbuf) 56439acbbeafSnn35248 { 56449acbbeafSnn35248 char inbuf[MAX_CMD_LEN]; 56459acbbeafSnn35248 FILE *file; 56469acbbeafSnn35248 int status; 56479acbbeafSnn35248 56489acbbeafSnn35248 file = popen(cmdbuf, "r"); 56499acbbeafSnn35248 if (file == NULL) { 56509acbbeafSnn35248 zerr(gettext("Could not launch: %s"), cmdbuf); 56519acbbeafSnn35248 return (-1); 56529acbbeafSnn35248 } 56539acbbeafSnn35248 56549acbbeafSnn35248 while (fgets(inbuf, sizeof (inbuf), file) != NULL) 56559acbbeafSnn35248 fprintf(stderr, "%s", inbuf); 56569acbbeafSnn35248 status = pclose(file); 56579acbbeafSnn35248 56589acbbeafSnn35248 if (WIFSIGNALED(status)) { 56599acbbeafSnn35248 zerr(gettext("%s unexpectedly terminated due to signal %d"), 56609acbbeafSnn35248 cmdbuf, WTERMSIG(status)); 56619acbbeafSnn35248 return (-1); 56629acbbeafSnn35248 } 56639acbbeafSnn35248 assert(WIFEXITED(status)); 56649acbbeafSnn35248 return (WEXITSTATUS(status)); 56659acbbeafSnn35248 } 56669acbbeafSnn35248 56679acbbeafSnn35248 static int 56689acbbeafSnn35248 brand_verify(zone_dochandle_t handle) 56699acbbeafSnn35248 { 56706e65f9afSnn35248 char xml_file[32]; 56719acbbeafSnn35248 char cmdbuf[MAX_CMD_LEN]; 5672123807fbSedp brand_handle_t bh; 56739acbbeafSnn35248 char brand[MAXNAMELEN]; 56749acbbeafSnn35248 int err; 56759acbbeafSnn35248 56769acbbeafSnn35248 if (zonecfg_get_brand(handle, brand, sizeof (brand)) != Z_OK) { 56779acbbeafSnn35248 zerr("%s: %s\n", zone, gettext("could not get zone brand")); 56789acbbeafSnn35248 return (Z_INVALID_DOCUMENT); 56799acbbeafSnn35248 } 5680123807fbSedp if ((bh = brand_open(brand)) == NULL) { 56819acbbeafSnn35248 zerr("%s: %s\n", zone, gettext("unknown brand.")); 56829acbbeafSnn35248 return (Z_INVALID_DOCUMENT); 56839acbbeafSnn35248 } 56849acbbeafSnn35248 56859acbbeafSnn35248 /* 56869acbbeafSnn35248 * Fetch the verify command, if any, from the brand configuration 56879acbbeafSnn35248 * and build the command line to execute it. 56889acbbeafSnn35248 */ 56899acbbeafSnn35248 strcpy(cmdbuf, EXEC_PREFIX); 5690123807fbSedp err = brand_get_verify_cfg(bh, cmdbuf + EXEC_LEN, 56919acbbeafSnn35248 sizeof (cmdbuf) - (EXEC_LEN + (strlen(xml_file) + 1))); 5692123807fbSedp brand_close(bh); 56939acbbeafSnn35248 if (err != Z_OK) { 56949acbbeafSnn35248 zerr("%s: %s\n", zone, 56959acbbeafSnn35248 gettext("could not get brand verification command")); 56969acbbeafSnn35248 return (Z_INVALID_DOCUMENT); 56979acbbeafSnn35248 } 56989acbbeafSnn35248 56999acbbeafSnn35248 /* 57009acbbeafSnn35248 * If the brand doesn't provide a verification routine, we just 57019acbbeafSnn35248 * return success. 57029acbbeafSnn35248 */ 57039acbbeafSnn35248 if (strlen(cmdbuf) == EXEC_LEN) 57049acbbeafSnn35248 return (Z_OK); 57059acbbeafSnn35248 57069acbbeafSnn35248 /* 57079acbbeafSnn35248 * Dump the current config information for this zone to a file. 57089acbbeafSnn35248 */ 57096e65f9afSnn35248 strcpy(xml_file, "/tmp/zonecfg_verify.XXXXXX"); 57109acbbeafSnn35248 if (mkstemp(xml_file) == NULL) 57119acbbeafSnn35248 return (Z_TEMP_FILE); 57129acbbeafSnn35248 if ((err = zonecfg_verify_save(handle, xml_file)) != Z_OK) { 57139acbbeafSnn35248 (void) unlink(xml_file); 57149acbbeafSnn35248 return (err); 57159acbbeafSnn35248 } 57169acbbeafSnn35248 57179acbbeafSnn35248 /* 57189acbbeafSnn35248 * Execute the verification command. 57199acbbeafSnn35248 */ 57209acbbeafSnn35248 if ((strlcat(cmdbuf, " ", MAX_CMD_LEN) >= MAX_CMD_LEN) || 57219acbbeafSnn35248 (strlcat(cmdbuf, xml_file, MAX_CMD_LEN) >= MAX_CMD_LEN)) { 57229acbbeafSnn35248 err = Z_BRAND_ERROR; 57239acbbeafSnn35248 } else { 57249acbbeafSnn35248 err = do_subproc(cmdbuf); 57259acbbeafSnn35248 } 57269acbbeafSnn35248 57279acbbeafSnn35248 (void) unlink(xml_file); 57289acbbeafSnn35248 return ((err == Z_OK) ? Z_OK : Z_BRAND_ERROR); 57299acbbeafSnn35248 } 57309acbbeafSnn35248 57317c478bd9Sstevel@tonic-gate /* 57327c478bd9Sstevel@tonic-gate * See the DTD for which attributes are required for which resources. 57337c478bd9Sstevel@tonic-gate * 57347c478bd9Sstevel@tonic-gate * This function can be called by commit_func(), which needs to save things, 57357c478bd9Sstevel@tonic-gate * in addition to the general call from parse_and_run(), which doesn't need 57367c478bd9Sstevel@tonic-gate * things saved. Since the parameters are standardized, we distinguish by 57377c478bd9Sstevel@tonic-gate * having commit_func() call here with cmd->cmd_arg set to "save" to indicate 57387c478bd9Sstevel@tonic-gate * that a save is needed. 57397c478bd9Sstevel@tonic-gate */ 57407c478bd9Sstevel@tonic-gate void 57417c478bd9Sstevel@tonic-gate verify_func(cmd_t *cmd) 57427c478bd9Sstevel@tonic-gate { 57437c478bd9Sstevel@tonic-gate struct zone_nwiftab nwiftab; 57447c478bd9Sstevel@tonic-gate struct zone_fstab fstab; 57457c478bd9Sstevel@tonic-gate struct zone_attrtab attrtab; 57467c478bd9Sstevel@tonic-gate struct zone_rctltab rctltab; 5747fa9e4066Sahrens struct zone_dstab dstab; 57480209230bSgjelinek struct zone_psettab psettab; 5749cb8a054bSGlenn Faden struct zone_admintab admintab; 57507c478bd9Sstevel@tonic-gate char zonepath[MAXPATHLEN]; 57510209230bSgjelinek char sched[MAXNAMELEN]; 57529acbbeafSnn35248 char brand[MAXNAMELEN]; 57535679c89fSjv227347 char hostidp[HW_HOSTID_LEN]; 57547c478bd9Sstevel@tonic-gate int err, ret_val = Z_OK, arg; 5755c97ad5cdSakolb int pset_res; 5756bbec428eSgjelinek boolean_t save = B_FALSE; 5757bbec428eSgjelinek boolean_t arg_err = B_FALSE; 5758f4b3ec61Sdh155122 zone_iptype_t iptype; 57590209230bSgjelinek boolean_t has_cpu_shares = B_FALSE; 5760c97ad5cdSakolb boolean_t has_cpu_cap = B_FALSE; 57617c478bd9Sstevel@tonic-gate 57627c478bd9Sstevel@tonic-gate optind = 0; 57637ec75eb8Sgjelinek while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?")) != EOF) { 57647c478bd9Sstevel@tonic-gate switch (arg) { 57657c478bd9Sstevel@tonic-gate case '?': 57667c478bd9Sstevel@tonic-gate longer_usage(CMD_VERIFY); 5767bbec428eSgjelinek arg_err = B_TRUE; 57687ec75eb8Sgjelinek break; 57697c478bd9Sstevel@tonic-gate default: 57707c478bd9Sstevel@tonic-gate short_usage(CMD_VERIFY); 5771bbec428eSgjelinek arg_err = B_TRUE; 57727ec75eb8Sgjelinek break; 57737ec75eb8Sgjelinek } 57747ec75eb8Sgjelinek } 57757ec75eb8Sgjelinek if (arg_err) 57767c478bd9Sstevel@tonic-gate return; 57777ec75eb8Sgjelinek 57787c478bd9Sstevel@tonic-gate if (optind > cmd->cmd_argc) { 57797c478bd9Sstevel@tonic-gate short_usage(CMD_VERIFY); 57807c478bd9Sstevel@tonic-gate return; 57817c478bd9Sstevel@tonic-gate } 57827c478bd9Sstevel@tonic-gate 57837c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_VERIFY)) 57847c478bd9Sstevel@tonic-gate return; 57857c478bd9Sstevel@tonic-gate 57867c478bd9Sstevel@tonic-gate assert(cmd != NULL); 57877c478bd9Sstevel@tonic-gate 57887c478bd9Sstevel@tonic-gate if (cmd->cmd_argc > 0 && (strcmp(cmd->cmd_argv[0], "save") == 0)) 5789bbec428eSgjelinek save = B_TRUE; 5790bbec428eSgjelinek if (initialize(B_TRUE) != Z_OK) 57917c478bd9Sstevel@tonic-gate return; 57927c478bd9Sstevel@tonic-gate 57930209230bSgjelinek if (zonecfg_get_zonepath(handle, zonepath, sizeof (zonepath)) != Z_OK && 57940209230bSgjelinek !global_zone) { 5795087719fdSdp zerr(gettext("%s not specified"), pt_to_str(PT_ZONEPATH)); 57967c478bd9Sstevel@tonic-gate ret_val = Z_REQD_RESOURCE_MISSING; 5797bbec428eSgjelinek saw_error = B_TRUE; 57987c478bd9Sstevel@tonic-gate } 57990209230bSgjelinek if (strlen(zonepath) == 0 && !global_zone) { 5800087719fdSdp zerr(gettext("%s cannot be empty."), pt_to_str(PT_ZONEPATH)); 58017c478bd9Sstevel@tonic-gate ret_val = Z_REQD_RESOURCE_MISSING; 5802bbec428eSgjelinek saw_error = B_TRUE; 58037c478bd9Sstevel@tonic-gate } 58047c478bd9Sstevel@tonic-gate 58059acbbeafSnn35248 if ((err = zonecfg_get_brand(handle, brand, sizeof (brand))) != Z_OK) { 5806bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 58079acbbeafSnn35248 return; 58089acbbeafSnn35248 } 58099acbbeafSnn35248 if ((err = brand_verify(handle)) != Z_OK) { 5810bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 58119acbbeafSnn35248 return; 58129acbbeafSnn35248 } 58139acbbeafSnn35248 5814f4b3ec61Sdh155122 if (zonecfg_get_iptype(handle, &iptype) != Z_OK) { 5815f4b3ec61Sdh155122 zerr("%s %s", gettext("cannot get"), pt_to_str(PT_IPTYPE)); 5816f4b3ec61Sdh155122 ret_val = Z_REQD_RESOURCE_MISSING; 5817bbec428eSgjelinek saw_error = B_TRUE; 5818f4b3ec61Sdh155122 } 58197c478bd9Sstevel@tonic-gate if ((err = zonecfg_setipdent(handle)) != Z_OK) { 5820bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 58217c478bd9Sstevel@tonic-gate return; 58227c478bd9Sstevel@tonic-gate } 58237c478bd9Sstevel@tonic-gate while (zonecfg_getipdent(handle, &fstab) == Z_OK) { 5824087719fdSdp check_reqd_prop(fstab.zone_fs_dir, RT_IPD, PT_DIR, &ret_val); 58257c478bd9Sstevel@tonic-gate } 58267c478bd9Sstevel@tonic-gate (void) zonecfg_endipdent(handle); 58277c478bd9Sstevel@tonic-gate 58285679c89fSjv227347 if (zonecfg_get_hostid(handle, hostidp, sizeof (hostidp)) == Z_OK && 58295679c89fSjv227347 (err = zonecfg_valid_hostid(hostidp)) != Z_OK) { 58305679c89fSjv227347 zone_perror(zone, err, B_TRUE); 58315679c89fSjv227347 return; 58325679c89fSjv227347 } 58335679c89fSjv227347 58347c478bd9Sstevel@tonic-gate if ((err = zonecfg_setfsent(handle)) != Z_OK) { 5835bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 58367c478bd9Sstevel@tonic-gate return; 58377c478bd9Sstevel@tonic-gate } 58387c478bd9Sstevel@tonic-gate while (zonecfg_getfsent(handle, &fstab) == Z_OK) { 5839087719fdSdp check_reqd_prop(fstab.zone_fs_dir, RT_FS, PT_DIR, &ret_val); 5840087719fdSdp check_reqd_prop(fstab.zone_fs_special, RT_FS, PT_SPECIAL, 5841087719fdSdp &ret_val); 5842087719fdSdp check_reqd_prop(fstab.zone_fs_type, RT_FS, PT_TYPE, &ret_val); 5843087719fdSdp 58447c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(fstab.zone_fs_options); 58457c478bd9Sstevel@tonic-gate } 58467c478bd9Sstevel@tonic-gate (void) zonecfg_endfsent(handle); 58477c478bd9Sstevel@tonic-gate 58487c478bd9Sstevel@tonic-gate if ((err = zonecfg_setnwifent(handle)) != Z_OK) { 5849bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 58507c478bd9Sstevel@tonic-gate return; 58517c478bd9Sstevel@tonic-gate } 58527c478bd9Sstevel@tonic-gate while (zonecfg_getnwifent(handle, &nwiftab) == Z_OK) { 5853f4b3ec61Sdh155122 /* 5854f4b3ec61Sdh155122 * physical is required in all cases. 5855de860bd9Sgfaden * A shared IP requires an address, 5856de860bd9Sgfaden * and may include a default router, while 5857de860bd9Sgfaden * an exclusive IP must have neither an address 5858de860bd9Sgfaden * nor a default router. 585901b4bc23Sjv227347 * The physical interface name must be valid in all cases. 5860f4b3ec61Sdh155122 */ 5861087719fdSdp check_reqd_prop(nwiftab.zone_nwif_physical, RT_NET, 5862087719fdSdp PT_PHYSICAL, &ret_val); 586301b4bc23Sjv227347 if (validate_net_physical_syntax(nwiftab.zone_nwif_physical) != 586401b4bc23Sjv227347 Z_OK) { 586501b4bc23Sjv227347 saw_error = B_TRUE; 586601b4bc23Sjv227347 if (ret_val == Z_OK) 586701b4bc23Sjv227347 ret_val = Z_INVAL; 586801b4bc23Sjv227347 } 5869f4b3ec61Sdh155122 5870f4b3ec61Sdh155122 switch (iptype) { 5871f4b3ec61Sdh155122 case ZS_SHARED: 5872f4b3ec61Sdh155122 check_reqd_prop(nwiftab.zone_nwif_address, RT_NET, 5873f4b3ec61Sdh155122 PT_ADDRESS, &ret_val); 5874f4b3ec61Sdh155122 break; 5875f4b3ec61Sdh155122 case ZS_EXCLUSIVE: 5876f4b3ec61Sdh155122 if (strlen(nwiftab.zone_nwif_address) > 0) { 5877f4b3ec61Sdh155122 zerr(gettext("%s: %s cannot be specified " 5878f4b3ec61Sdh155122 "for an exclusive IP type"), 5879f4b3ec61Sdh155122 rt_to_str(RT_NET), pt_to_str(PT_ADDRESS)); 5880bbec428eSgjelinek saw_error = B_TRUE; 5881f4b3ec61Sdh155122 if (ret_val == Z_OK) 5882f4b3ec61Sdh155122 ret_val = Z_INVAL; 5883f4b3ec61Sdh155122 } 5884de860bd9Sgfaden if (strlen(nwiftab.zone_nwif_defrouter) > 0) { 5885de860bd9Sgfaden zerr(gettext("%s: %s cannot be specified " 5886de860bd9Sgfaden "for an exclusive IP type"), 5887de860bd9Sgfaden rt_to_str(RT_NET), pt_to_str(PT_DEFROUTER)); 5888bbec428eSgjelinek saw_error = B_TRUE; 5889de860bd9Sgfaden if (ret_val == Z_OK) 5890de860bd9Sgfaden ret_val = Z_INVAL; 5891de860bd9Sgfaden } 5892f4b3ec61Sdh155122 break; 5893f4b3ec61Sdh155122 } 58947c478bd9Sstevel@tonic-gate } 58957c478bd9Sstevel@tonic-gate (void) zonecfg_endnwifent(handle); 58967c478bd9Sstevel@tonic-gate 58977c478bd9Sstevel@tonic-gate if ((err = zonecfg_setrctlent(handle)) != Z_OK) { 5898bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 58997c478bd9Sstevel@tonic-gate return; 59007c478bd9Sstevel@tonic-gate } 59017c478bd9Sstevel@tonic-gate while (zonecfg_getrctlent(handle, &rctltab) == Z_OK) { 5902087719fdSdp check_reqd_prop(rctltab.zone_rctl_name, RT_RCTL, PT_NAME, 5903087719fdSdp &ret_val); 5904087719fdSdp 59050209230bSgjelinek if (strcmp(rctltab.zone_rctl_name, "zone.cpu-shares") == 0) 59060209230bSgjelinek has_cpu_shares = B_TRUE; 59070209230bSgjelinek 5908c97ad5cdSakolb if (strcmp(rctltab.zone_rctl_name, "zone.cpu-cap") == 0) 5909c97ad5cdSakolb has_cpu_cap = B_TRUE; 5910c97ad5cdSakolb 59117c478bd9Sstevel@tonic-gate if (rctltab.zone_rctl_valptr == NULL) { 59127c478bd9Sstevel@tonic-gate zerr(gettext("%s: no %s specified"), 59137c478bd9Sstevel@tonic-gate rt_to_str(RT_RCTL), pt_to_str(PT_VALUE)); 5914bbec428eSgjelinek saw_error = B_TRUE; 59157c478bd9Sstevel@tonic-gate if (ret_val == Z_OK) 59167c478bd9Sstevel@tonic-gate ret_val = Z_REQD_PROPERTY_MISSING; 59177c478bd9Sstevel@tonic-gate } else { 59187c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctltab.zone_rctl_valptr); 59197c478bd9Sstevel@tonic-gate } 59207c478bd9Sstevel@tonic-gate } 59217c478bd9Sstevel@tonic-gate (void) zonecfg_endrctlent(handle); 59227c478bd9Sstevel@tonic-gate 5923c97ad5cdSakolb if ((pset_res = zonecfg_lookup_pset(handle, &psettab)) == Z_OK && 5924c97ad5cdSakolb has_cpu_shares) { 59250209230bSgjelinek zerr(gettext("%s zone.cpu-shares and %s are incompatible."), 59260209230bSgjelinek rt_to_str(RT_RCTL), rt_to_str(RT_DCPU)); 5927bbec428eSgjelinek saw_error = B_TRUE; 59280209230bSgjelinek if (ret_val == Z_OK) 59290209230bSgjelinek ret_val = Z_INCOMPATIBLE; 59300209230bSgjelinek } 59310209230bSgjelinek 59320209230bSgjelinek if (has_cpu_shares && zonecfg_get_sched_class(handle, sched, 59330209230bSgjelinek sizeof (sched)) == Z_OK && strlen(sched) > 0 && 59340209230bSgjelinek strcmp(sched, "FSS") != 0) { 59350209230bSgjelinek zerr(gettext("WARNING: %s zone.cpu-shares and %s=%s are " 59360209230bSgjelinek "incompatible"), 59370209230bSgjelinek rt_to_str(RT_RCTL), rt_to_str(RT_SCHED), sched); 5938bbec428eSgjelinek saw_error = B_TRUE; 59390209230bSgjelinek if (ret_val == Z_OK) 59400209230bSgjelinek ret_val = Z_INCOMPATIBLE; 59410209230bSgjelinek } 59420209230bSgjelinek 5943c97ad5cdSakolb if (pset_res == Z_OK && has_cpu_cap) { 5944c97ad5cdSakolb zerr(gettext("%s zone.cpu-cap and the %s are incompatible."), 5945c97ad5cdSakolb rt_to_str(RT_RCTL), rt_to_str(RT_DCPU)); 5946bbec428eSgjelinek saw_error = B_TRUE; 5947c97ad5cdSakolb if (ret_val == Z_OK) 5948c97ad5cdSakolb ret_val = Z_INCOMPATIBLE; 5949c97ad5cdSakolb } 5950c97ad5cdSakolb 59517c478bd9Sstevel@tonic-gate if ((err = zonecfg_setattrent(handle)) != Z_OK) { 5952bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 59537c478bd9Sstevel@tonic-gate return; 59547c478bd9Sstevel@tonic-gate } 59557c478bd9Sstevel@tonic-gate while (zonecfg_getattrent(handle, &attrtab) == Z_OK) { 5956087719fdSdp check_reqd_prop(attrtab.zone_attr_name, RT_ATTR, PT_NAME, 5957087719fdSdp &ret_val); 5958087719fdSdp check_reqd_prop(attrtab.zone_attr_type, RT_ATTR, PT_TYPE, 5959087719fdSdp &ret_val); 5960087719fdSdp check_reqd_prop(attrtab.zone_attr_value, RT_ATTR, PT_VALUE, 5961087719fdSdp &ret_val); 59627c478bd9Sstevel@tonic-gate } 59637c478bd9Sstevel@tonic-gate (void) zonecfg_endattrent(handle); 59647c478bd9Sstevel@tonic-gate 5965fa9e4066Sahrens if ((err = zonecfg_setdsent(handle)) != Z_OK) { 5966bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 5967fa9e4066Sahrens return; 5968fa9e4066Sahrens } 5969fa9e4066Sahrens while (zonecfg_getdsent(handle, &dstab) == Z_OK) { 5970fa9e4066Sahrens if (strlen(dstab.zone_dataset_name) == 0) { 5971fa9e4066Sahrens zerr("%s: %s %s", rt_to_str(RT_DATASET), 5972fa9e4066Sahrens pt_to_str(PT_NAME), gettext("not specified")); 5973bbec428eSgjelinek saw_error = B_TRUE; 5974fa9e4066Sahrens if (ret_val == Z_OK) 5975fa9e4066Sahrens ret_val = Z_REQD_PROPERTY_MISSING; 5976fa9e4066Sahrens } else if (!zfs_name_valid(dstab.zone_dataset_name, 5977fa9e4066Sahrens ZFS_TYPE_FILESYSTEM)) { 5978fa9e4066Sahrens zerr("%s: %s %s", rt_to_str(RT_DATASET), 5979fa9e4066Sahrens pt_to_str(PT_NAME), gettext("invalid")); 5980bbec428eSgjelinek saw_error = B_TRUE; 5981fa9e4066Sahrens if (ret_val == Z_OK) 5982fa9e4066Sahrens ret_val = Z_BAD_PROPERTY; 5983fa9e4066Sahrens } 5984fa9e4066Sahrens 5985fa9e4066Sahrens } 5986fa9e4066Sahrens (void) zonecfg_enddsent(handle); 5987fa9e4066Sahrens 5988cb8a054bSGlenn Faden if ((err = zonecfg_setadminent(handle)) != Z_OK) { 5989cb8a054bSGlenn Faden zone_perror(zone, err, B_TRUE); 5990cb8a054bSGlenn Faden return; 5991cb8a054bSGlenn Faden } 5992cb8a054bSGlenn Faden while (zonecfg_getadminent(handle, &admintab) == Z_OK) { 5993cb8a054bSGlenn Faden check_reqd_prop(admintab.zone_admin_user, RT_ADMIN, 5994cb8a054bSGlenn Faden PT_USER, &ret_val); 5995cb8a054bSGlenn Faden check_reqd_prop(admintab.zone_admin_auths, RT_ADMIN, 5996cb8a054bSGlenn Faden PT_AUTHS, &ret_val); 5997cb8a054bSGlenn Faden if ((ret_val == Z_OK) && (getpwnam(admintab.zone_admin_user) 5998cb8a054bSGlenn Faden == NULL)) { 5999cb8a054bSGlenn Faden zerr(gettext("%s %s is not a valid username"), 6000cb8a054bSGlenn Faden pt_to_str(PT_USER), 6001cb8a054bSGlenn Faden admintab.zone_admin_user); 6002cb8a054bSGlenn Faden ret_val = Z_BAD_PROPERTY; 6003cb8a054bSGlenn Faden } 6004cb8a054bSGlenn Faden if ((ret_val == Z_OK) && (!zonecfg_valid_auths( 6005cb8a054bSGlenn Faden admintab.zone_admin_auths, zone))) { 6006cb8a054bSGlenn Faden ret_val = Z_BAD_PROPERTY; 6007cb8a054bSGlenn Faden } 6008cb8a054bSGlenn Faden } 6009cb8a054bSGlenn Faden (void) zonecfg_endadminent(handle); 6010cb8a054bSGlenn Faden 60117c478bd9Sstevel@tonic-gate if (!global_scope) { 60127c478bd9Sstevel@tonic-gate zerr(gettext("resource specification incomplete")); 6013bbec428eSgjelinek saw_error = B_TRUE; 60147c478bd9Sstevel@tonic-gate if (ret_val == Z_OK) 60157c478bd9Sstevel@tonic-gate ret_val = Z_INSUFFICIENT_SPEC; 60167c478bd9Sstevel@tonic-gate } 60177c478bd9Sstevel@tonic-gate 60187c478bd9Sstevel@tonic-gate if (save) { 6019087719fdSdp if (ret_val == Z_OK) { 6020087719fdSdp if ((ret_val = zonecfg_save(handle)) == Z_OK) { 6021bbec428eSgjelinek need_to_commit = B_FALSE; 6022087719fdSdp (void) strlcpy(revert_zone, zone, 6023087719fdSdp sizeof (revert_zone)); 6024087719fdSdp } 6025087719fdSdp } else { 6026087719fdSdp zerr(gettext("Zone %s failed to verify"), zone); 6027087719fdSdp } 60287c478bd9Sstevel@tonic-gate } 60297c478bd9Sstevel@tonic-gate if (ret_val != Z_OK) 6030bbec428eSgjelinek zone_perror(zone, ret_val, B_TRUE); 60317c478bd9Sstevel@tonic-gate } 60327c478bd9Sstevel@tonic-gate 60337c478bd9Sstevel@tonic-gate void 60347c478bd9Sstevel@tonic-gate cancel_func(cmd_t *cmd) 60357c478bd9Sstevel@tonic-gate { 60367c478bd9Sstevel@tonic-gate int arg; 6037bbec428eSgjelinek boolean_t arg_err = B_FALSE; 60387c478bd9Sstevel@tonic-gate 60397c478bd9Sstevel@tonic-gate assert(cmd != NULL); 60407c478bd9Sstevel@tonic-gate 60417c478bd9Sstevel@tonic-gate optind = 0; 60427ec75eb8Sgjelinek while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?")) != EOF) { 60437c478bd9Sstevel@tonic-gate switch (arg) { 60447c478bd9Sstevel@tonic-gate case '?': 60457c478bd9Sstevel@tonic-gate longer_usage(CMD_CANCEL); 6046bbec428eSgjelinek arg_err = B_TRUE; 60477ec75eb8Sgjelinek break; 60487c478bd9Sstevel@tonic-gate default: 60497c478bd9Sstevel@tonic-gate short_usage(CMD_CANCEL); 6050bbec428eSgjelinek arg_err = B_TRUE; 60517ec75eb8Sgjelinek break; 60527ec75eb8Sgjelinek } 60537ec75eb8Sgjelinek } 60547ec75eb8Sgjelinek if (arg_err) 60557c478bd9Sstevel@tonic-gate return; 60567ec75eb8Sgjelinek 60577c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 60587c478bd9Sstevel@tonic-gate short_usage(CMD_CANCEL); 60597c478bd9Sstevel@tonic-gate return; 60607c478bd9Sstevel@tonic-gate } 60617c478bd9Sstevel@tonic-gate 60627c478bd9Sstevel@tonic-gate if (global_scope) 60637c478bd9Sstevel@tonic-gate scope_usage(CMD_CANCEL); 6064bbec428eSgjelinek global_scope = B_TRUE; 60657c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(in_progress_fstab.zone_fs_options); 60667c478bd9Sstevel@tonic-gate bzero(&in_progress_fstab, sizeof (in_progress_fstab)); 60677c478bd9Sstevel@tonic-gate bzero(&in_progress_nwiftab, sizeof (in_progress_nwiftab)); 6068fa9e4066Sahrens bzero(&in_progress_ipdtab, sizeof (in_progress_ipdtab)); 60697c478bd9Sstevel@tonic-gate bzero(&in_progress_devtab, sizeof (in_progress_devtab)); 60707c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(in_progress_rctltab.zone_rctl_valptr); 60717c478bd9Sstevel@tonic-gate bzero(&in_progress_rctltab, sizeof (in_progress_rctltab)); 60727c478bd9Sstevel@tonic-gate bzero(&in_progress_attrtab, sizeof (in_progress_attrtab)); 6073fa9e4066Sahrens bzero(&in_progress_dstab, sizeof (in_progress_dstab)); 60747c478bd9Sstevel@tonic-gate } 60757c478bd9Sstevel@tonic-gate 60767c478bd9Sstevel@tonic-gate static int 60777c478bd9Sstevel@tonic-gate validate_attr_name(char *name) 60787c478bd9Sstevel@tonic-gate { 60797c478bd9Sstevel@tonic-gate int i; 60807c478bd9Sstevel@tonic-gate 60817c478bd9Sstevel@tonic-gate if (!isalnum(name[0])) { 60827c478bd9Sstevel@tonic-gate zerr(gettext("Invalid %s %s %s: must start with an alpha-" 60837c478bd9Sstevel@tonic-gate "numeric character."), rt_to_str(RT_ATTR), 60847c478bd9Sstevel@tonic-gate pt_to_str(PT_NAME), name); 60857c478bd9Sstevel@tonic-gate return (Z_INVAL); 60867c478bd9Sstevel@tonic-gate } 60877c478bd9Sstevel@tonic-gate for (i = 1; name[i]; i++) 60887c478bd9Sstevel@tonic-gate if (!isalnum(name[i]) && name[i] != '-' && name[i] != '.') { 60897c478bd9Sstevel@tonic-gate zerr(gettext("Invalid %s %s %s: can only contain " 60907c478bd9Sstevel@tonic-gate "alpha-numeric characters, plus '-' and '.'."), 60917c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR), pt_to_str(PT_NAME), name); 60927c478bd9Sstevel@tonic-gate return (Z_INVAL); 60937c478bd9Sstevel@tonic-gate } 60947c478bd9Sstevel@tonic-gate return (Z_OK); 60957c478bd9Sstevel@tonic-gate } 60967c478bd9Sstevel@tonic-gate 60977c478bd9Sstevel@tonic-gate static int 60987c478bd9Sstevel@tonic-gate validate_attr_type_val(struct zone_attrtab *attrtab) 60997c478bd9Sstevel@tonic-gate { 61007c478bd9Sstevel@tonic-gate boolean_t boolval; 61017c478bd9Sstevel@tonic-gate int64_t intval; 61027c478bd9Sstevel@tonic-gate char strval[MAXNAMELEN]; 61037c478bd9Sstevel@tonic-gate uint64_t uintval; 61047c478bd9Sstevel@tonic-gate 61057c478bd9Sstevel@tonic-gate if (strcmp(attrtab->zone_attr_type, "boolean") == 0) { 61067c478bd9Sstevel@tonic-gate if (zonecfg_get_attr_boolean(attrtab, &boolval) == Z_OK) 61077c478bd9Sstevel@tonic-gate return (Z_OK); 61087c478bd9Sstevel@tonic-gate zerr(gettext("invalid %s value for %s=%s"), 61097c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR), pt_to_str(PT_TYPE), "boolean"); 61107c478bd9Sstevel@tonic-gate return (Z_ERR); 61117c478bd9Sstevel@tonic-gate } 61127c478bd9Sstevel@tonic-gate 61137c478bd9Sstevel@tonic-gate if (strcmp(attrtab->zone_attr_type, "int") == 0) { 61147c478bd9Sstevel@tonic-gate if (zonecfg_get_attr_int(attrtab, &intval) == Z_OK) 61157c478bd9Sstevel@tonic-gate return (Z_OK); 61167c478bd9Sstevel@tonic-gate zerr(gettext("invalid %s value for %s=%s"), 61177c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR), pt_to_str(PT_TYPE), "int"); 61187c478bd9Sstevel@tonic-gate return (Z_ERR); 61197c478bd9Sstevel@tonic-gate } 61207c478bd9Sstevel@tonic-gate 61217c478bd9Sstevel@tonic-gate if (strcmp(attrtab->zone_attr_type, "string") == 0) { 61227c478bd9Sstevel@tonic-gate if (zonecfg_get_attr_string(attrtab, strval, 61237c478bd9Sstevel@tonic-gate sizeof (strval)) == Z_OK) 61247c478bd9Sstevel@tonic-gate return (Z_OK); 61257c478bd9Sstevel@tonic-gate zerr(gettext("invalid %s value for %s=%s"), 61267c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR), pt_to_str(PT_TYPE), "string"); 61277c478bd9Sstevel@tonic-gate return (Z_ERR); 61287c478bd9Sstevel@tonic-gate } 61297c478bd9Sstevel@tonic-gate 61307c478bd9Sstevel@tonic-gate if (strcmp(attrtab->zone_attr_type, "uint") == 0) { 61317c478bd9Sstevel@tonic-gate if (zonecfg_get_attr_uint(attrtab, &uintval) == Z_OK) 61327c478bd9Sstevel@tonic-gate return (Z_OK); 61337c478bd9Sstevel@tonic-gate zerr(gettext("invalid %s value for %s=%s"), 61347c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR), pt_to_str(PT_TYPE), "uint"); 61357c478bd9Sstevel@tonic-gate return (Z_ERR); 61367c478bd9Sstevel@tonic-gate } 61377c478bd9Sstevel@tonic-gate 61387c478bd9Sstevel@tonic-gate zerr(gettext("invalid %s %s '%s'"), rt_to_str(RT_ATTR), 61397c478bd9Sstevel@tonic-gate pt_to_str(PT_TYPE), attrtab->zone_attr_type); 61407c478bd9Sstevel@tonic-gate return (Z_ERR); 61417c478bd9Sstevel@tonic-gate } 61427c478bd9Sstevel@tonic-gate 6143087719fdSdp /* 6144087719fdSdp * Helper function for end_func-- checks the existence of a given property 6145087719fdSdp * and emits a message if not specified. 6146087719fdSdp */ 6147087719fdSdp static int 6148bbec428eSgjelinek end_check_reqd(char *attr, int pt, boolean_t *validation_failed) 6149087719fdSdp { 6150087719fdSdp if (strlen(attr) == 0) { 6151bbec428eSgjelinek *validation_failed = B_TRUE; 6152087719fdSdp zerr(gettext("%s not specified"), pt_to_str(pt)); 6153087719fdSdp return (Z_ERR); 6154087719fdSdp } 6155087719fdSdp return (Z_OK); 6156087719fdSdp } 6157087719fdSdp 61587c478bd9Sstevel@tonic-gate void 61597c478bd9Sstevel@tonic-gate end_func(cmd_t *cmd) 61607c478bd9Sstevel@tonic-gate { 6161bbec428eSgjelinek boolean_t validation_failed = B_FALSE; 6162bbec428eSgjelinek boolean_t arg_err = B_FALSE; 61637c478bd9Sstevel@tonic-gate struct zone_fstab tmp_fstab; 61647c478bd9Sstevel@tonic-gate struct zone_nwiftab tmp_nwiftab; 61657c478bd9Sstevel@tonic-gate struct zone_devtab tmp_devtab; 61667c478bd9Sstevel@tonic-gate struct zone_rctltab tmp_rctltab; 61677c478bd9Sstevel@tonic-gate struct zone_attrtab tmp_attrtab; 6168fa9e4066Sahrens struct zone_dstab tmp_dstab; 6169cb8a054bSGlenn Faden struct zone_admintab tmp_admintab; 61700209230bSgjelinek int err, arg, res1, res2, res3; 61710209230bSgjelinek uint64_t swap_limit; 61720209230bSgjelinek uint64_t locked_limit; 6173c97ad5cdSakolb uint64_t proc_cap; 61747c478bd9Sstevel@tonic-gate 61757c478bd9Sstevel@tonic-gate assert(cmd != NULL); 61767c478bd9Sstevel@tonic-gate 61777c478bd9Sstevel@tonic-gate optind = 0; 61787ec75eb8Sgjelinek while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?")) != EOF) { 61797c478bd9Sstevel@tonic-gate switch (arg) { 61807c478bd9Sstevel@tonic-gate case '?': 61817c478bd9Sstevel@tonic-gate longer_usage(CMD_END); 6182bbec428eSgjelinek arg_err = B_TRUE; 61837ec75eb8Sgjelinek break; 61847c478bd9Sstevel@tonic-gate default: 61857c478bd9Sstevel@tonic-gate short_usage(CMD_END); 6186bbec428eSgjelinek arg_err = B_TRUE; 61877ec75eb8Sgjelinek break; 61887ec75eb8Sgjelinek } 61897ec75eb8Sgjelinek } 61907ec75eb8Sgjelinek if (arg_err) 61917c478bd9Sstevel@tonic-gate return; 61927ec75eb8Sgjelinek 61937c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 61947c478bd9Sstevel@tonic-gate short_usage(CMD_END); 61957c478bd9Sstevel@tonic-gate return; 61967c478bd9Sstevel@tonic-gate } 61977c478bd9Sstevel@tonic-gate 61987c478bd9Sstevel@tonic-gate if (global_scope) { 61997c478bd9Sstevel@tonic-gate scope_usage(CMD_END); 62007c478bd9Sstevel@tonic-gate return; 62017c478bd9Sstevel@tonic-gate } 62027c478bd9Sstevel@tonic-gate 62037c478bd9Sstevel@tonic-gate assert(end_op == CMD_ADD || end_op == CMD_SELECT); 62047c478bd9Sstevel@tonic-gate 62057c478bd9Sstevel@tonic-gate switch (resource_scope) { 62067c478bd9Sstevel@tonic-gate case RT_FS: 62077c478bd9Sstevel@tonic-gate /* First make sure everything was filled in. */ 6208087719fdSdp if (end_check_reqd(in_progress_fstab.zone_fs_dir, 6209087719fdSdp PT_DIR, &validation_failed) == Z_OK) { 6210087719fdSdp if (in_progress_fstab.zone_fs_dir[0] != '/') { 6211087719fdSdp zerr(gettext("%s %s is not an absolute path."), 6212087719fdSdp pt_to_str(PT_DIR), 6213087719fdSdp in_progress_fstab.zone_fs_dir); 6214bbec428eSgjelinek validation_failed = B_TRUE; 62157c478bd9Sstevel@tonic-gate } 62167c478bd9Sstevel@tonic-gate } 6217087719fdSdp 6218087719fdSdp (void) end_check_reqd(in_progress_fstab.zone_fs_special, 6219087719fdSdp PT_SPECIAL, &validation_failed); 6220087719fdSdp 62217c478bd9Sstevel@tonic-gate if (in_progress_fstab.zone_fs_raw[0] != '\0' && 62227c478bd9Sstevel@tonic-gate in_progress_fstab.zone_fs_raw[0] != '/') { 6223087719fdSdp zerr(gettext("%s %s is not an absolute path."), 6224087719fdSdp pt_to_str(PT_RAW), 6225087719fdSdp in_progress_fstab.zone_fs_raw); 6226bbec428eSgjelinek validation_failed = B_TRUE; 62277c478bd9Sstevel@tonic-gate } 6228087719fdSdp 6229087719fdSdp (void) end_check_reqd(in_progress_fstab.zone_fs_type, PT_TYPE, 6230087719fdSdp &validation_failed); 6231087719fdSdp 6232087719fdSdp if (validation_failed) { 6233bbec428eSgjelinek saw_error = B_TRUE; 62347c478bd9Sstevel@tonic-gate return; 6235087719fdSdp } 6236087719fdSdp 62377c478bd9Sstevel@tonic-gate if (end_op == CMD_ADD) { 62387c478bd9Sstevel@tonic-gate /* Make sure there isn't already one like this. */ 62397c478bd9Sstevel@tonic-gate bzero(&tmp_fstab, sizeof (tmp_fstab)); 62407c478bd9Sstevel@tonic-gate (void) strlcpy(tmp_fstab.zone_fs_dir, 62417c478bd9Sstevel@tonic-gate in_progress_fstab.zone_fs_dir, 62427c478bd9Sstevel@tonic-gate sizeof (tmp_fstab.zone_fs_dir)); 62437c478bd9Sstevel@tonic-gate err = zonecfg_lookup_filesystem(handle, &tmp_fstab); 62447c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(tmp_fstab.zone_fs_options); 62457c478bd9Sstevel@tonic-gate if (err == Z_OK) { 62467c478bd9Sstevel@tonic-gate zerr(gettext("A %s resource " 62477c478bd9Sstevel@tonic-gate "with the %s '%s' already exists."), 62487c478bd9Sstevel@tonic-gate rt_to_str(RT_FS), pt_to_str(PT_DIR), 62497c478bd9Sstevel@tonic-gate in_progress_fstab.zone_fs_dir); 6250bbec428eSgjelinek saw_error = B_TRUE; 62517c478bd9Sstevel@tonic-gate return; 62527c478bd9Sstevel@tonic-gate } 62537c478bd9Sstevel@tonic-gate err = zonecfg_add_filesystem(handle, 62547c478bd9Sstevel@tonic-gate &in_progress_fstab); 62557c478bd9Sstevel@tonic-gate } else { 62567c478bd9Sstevel@tonic-gate err = zonecfg_modify_filesystem(handle, &old_fstab, 62577c478bd9Sstevel@tonic-gate &in_progress_fstab); 62587c478bd9Sstevel@tonic-gate } 62597c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(in_progress_fstab.zone_fs_options); 62607c478bd9Sstevel@tonic-gate in_progress_fstab.zone_fs_options = NULL; 62617c478bd9Sstevel@tonic-gate break; 6262087719fdSdp 62637c478bd9Sstevel@tonic-gate case RT_IPD: 62647c478bd9Sstevel@tonic-gate /* First make sure everything was filled in. */ 6265087719fdSdp if (end_check_reqd(in_progress_ipdtab.zone_fs_dir, PT_DIR, 6266087719fdSdp &validation_failed) == Z_OK) { 6267087719fdSdp if (in_progress_ipdtab.zone_fs_dir[0] != '/') { 6268087719fdSdp zerr(gettext("%s %s is not an absolute path."), 6269087719fdSdp pt_to_str(PT_DIR), 6270087719fdSdp in_progress_ipdtab.zone_fs_dir); 6271bbec428eSgjelinek validation_failed = B_TRUE; 62727c478bd9Sstevel@tonic-gate } 6273087719fdSdp } 6274087719fdSdp if (validation_failed) { 6275bbec428eSgjelinek saw_error = B_TRUE; 62767c478bd9Sstevel@tonic-gate return; 6277087719fdSdp } 6278087719fdSdp 62797c478bd9Sstevel@tonic-gate if (end_op == CMD_ADD) { 62807c478bd9Sstevel@tonic-gate /* Make sure there isn't already one like this. */ 62817c478bd9Sstevel@tonic-gate bzero(&tmp_fstab, sizeof (tmp_fstab)); 62827c478bd9Sstevel@tonic-gate (void) strlcpy(tmp_fstab.zone_fs_dir, 62837c478bd9Sstevel@tonic-gate in_progress_ipdtab.zone_fs_dir, 62847c478bd9Sstevel@tonic-gate sizeof (tmp_fstab.zone_fs_dir)); 62857c478bd9Sstevel@tonic-gate err = zonecfg_lookup_ipd(handle, &tmp_fstab); 62867c478bd9Sstevel@tonic-gate if (err == Z_OK) { 62877c478bd9Sstevel@tonic-gate zerr(gettext("An %s resource " 62887c478bd9Sstevel@tonic-gate "with the %s '%s' already exists."), 62897c478bd9Sstevel@tonic-gate rt_to_str(RT_IPD), pt_to_str(PT_DIR), 62907c478bd9Sstevel@tonic-gate in_progress_ipdtab.zone_fs_dir); 6291bbec428eSgjelinek saw_error = B_TRUE; 62927c478bd9Sstevel@tonic-gate return; 62937c478bd9Sstevel@tonic-gate } 62947c478bd9Sstevel@tonic-gate err = zonecfg_add_ipd(handle, &in_progress_ipdtab); 62957c478bd9Sstevel@tonic-gate } else { 62967c478bd9Sstevel@tonic-gate err = zonecfg_modify_ipd(handle, &old_ipdtab, 62977c478bd9Sstevel@tonic-gate &in_progress_ipdtab); 62987c478bd9Sstevel@tonic-gate } 62997c478bd9Sstevel@tonic-gate break; 63007c478bd9Sstevel@tonic-gate case RT_NET: 6301f4b3ec61Sdh155122 /* 6302f4b3ec61Sdh155122 * First make sure everything was filled in. 6303f4b3ec61Sdh155122 * Since we don't know whether IP will be shared 6304f4b3ec61Sdh155122 * or exclusive here, some checks are deferred until 6305f4b3ec61Sdh155122 * the verify command. 6306f4b3ec61Sdh155122 */ 6307087719fdSdp (void) end_check_reqd(in_progress_nwiftab.zone_nwif_physical, 6308087719fdSdp PT_PHYSICAL, &validation_failed); 6309087719fdSdp 6310087719fdSdp if (validation_failed) { 6311bbec428eSgjelinek saw_error = B_TRUE; 63127c478bd9Sstevel@tonic-gate return; 6313087719fdSdp } 63147c478bd9Sstevel@tonic-gate if (end_op == CMD_ADD) { 63157c478bd9Sstevel@tonic-gate /* Make sure there isn't already one like this. */ 63167c478bd9Sstevel@tonic-gate bzero(&tmp_nwiftab, sizeof (tmp_nwiftab)); 6317f4b3ec61Sdh155122 (void) strlcpy(tmp_nwiftab.zone_nwif_physical, 6318f4b3ec61Sdh155122 in_progress_nwiftab.zone_nwif_physical, 6319f4b3ec61Sdh155122 sizeof (tmp_nwiftab.zone_nwif_physical)); 63207c478bd9Sstevel@tonic-gate (void) strlcpy(tmp_nwiftab.zone_nwif_address, 63217c478bd9Sstevel@tonic-gate in_progress_nwiftab.zone_nwif_address, 63227c478bd9Sstevel@tonic-gate sizeof (tmp_nwiftab.zone_nwif_address)); 63237c478bd9Sstevel@tonic-gate if (zonecfg_lookup_nwif(handle, &tmp_nwiftab) == Z_OK) { 6324f4b3ec61Sdh155122 zerr(gettext("A %s resource with the %s '%s', " 6325f4b3ec61Sdh155122 "and %s '%s' already exists."), 6326f4b3ec61Sdh155122 rt_to_str(RT_NET), 6327f4b3ec61Sdh155122 pt_to_str(PT_PHYSICAL), 6328f4b3ec61Sdh155122 in_progress_nwiftab.zone_nwif_physical, 6329f4b3ec61Sdh155122 pt_to_str(PT_ADDRESS), 63307c478bd9Sstevel@tonic-gate in_progress_nwiftab.zone_nwif_address); 6331bbec428eSgjelinek saw_error = B_TRUE; 63327c478bd9Sstevel@tonic-gate return; 63337c478bd9Sstevel@tonic-gate } 63347c478bd9Sstevel@tonic-gate err = zonecfg_add_nwif(handle, &in_progress_nwiftab); 63357c478bd9Sstevel@tonic-gate } else { 63367c478bd9Sstevel@tonic-gate err = zonecfg_modify_nwif(handle, &old_nwiftab, 63377c478bd9Sstevel@tonic-gate &in_progress_nwiftab); 63387c478bd9Sstevel@tonic-gate } 63397c478bd9Sstevel@tonic-gate break; 6340087719fdSdp 63417c478bd9Sstevel@tonic-gate case RT_DEVICE: 63427c478bd9Sstevel@tonic-gate /* First make sure everything was filled in. */ 6343087719fdSdp (void) end_check_reqd(in_progress_devtab.zone_dev_match, 6344087719fdSdp PT_MATCH, &validation_failed); 6345087719fdSdp 6346087719fdSdp if (validation_failed) { 6347bbec428eSgjelinek saw_error = B_TRUE; 63487c478bd9Sstevel@tonic-gate return; 6349087719fdSdp } 6350087719fdSdp 63517c478bd9Sstevel@tonic-gate if (end_op == CMD_ADD) { 63527c478bd9Sstevel@tonic-gate /* Make sure there isn't already one like this. */ 63537c478bd9Sstevel@tonic-gate (void) strlcpy(tmp_devtab.zone_dev_match, 63547c478bd9Sstevel@tonic-gate in_progress_devtab.zone_dev_match, 63557c478bd9Sstevel@tonic-gate sizeof (tmp_devtab.zone_dev_match)); 63567c478bd9Sstevel@tonic-gate if (zonecfg_lookup_dev(handle, &tmp_devtab) == Z_OK) { 63577c478bd9Sstevel@tonic-gate zerr(gettext("A %s resource with the %s '%s' " 63587c478bd9Sstevel@tonic-gate "already exists."), rt_to_str(RT_DEVICE), 63597c478bd9Sstevel@tonic-gate pt_to_str(PT_MATCH), 63607c478bd9Sstevel@tonic-gate in_progress_devtab.zone_dev_match); 6361bbec428eSgjelinek saw_error = B_TRUE; 63627c478bd9Sstevel@tonic-gate return; 63637c478bd9Sstevel@tonic-gate } 63647c478bd9Sstevel@tonic-gate err = zonecfg_add_dev(handle, &in_progress_devtab); 63657c478bd9Sstevel@tonic-gate } else { 63667c478bd9Sstevel@tonic-gate err = zonecfg_modify_dev(handle, &old_devtab, 63677c478bd9Sstevel@tonic-gate &in_progress_devtab); 63687c478bd9Sstevel@tonic-gate } 63697c478bd9Sstevel@tonic-gate break; 6370087719fdSdp 63717c478bd9Sstevel@tonic-gate case RT_RCTL: 63727c478bd9Sstevel@tonic-gate /* First make sure everything was filled in. */ 6373087719fdSdp (void) end_check_reqd(in_progress_rctltab.zone_rctl_name, 6374087719fdSdp PT_NAME, &validation_failed); 6375087719fdSdp 63767c478bd9Sstevel@tonic-gate if (in_progress_rctltab.zone_rctl_valptr == NULL) { 63777c478bd9Sstevel@tonic-gate zerr(gettext("no %s specified"), pt_to_str(PT_VALUE)); 6378bbec428eSgjelinek validation_failed = B_TRUE; 63797c478bd9Sstevel@tonic-gate } 6380087719fdSdp 6381087719fdSdp if (validation_failed) { 6382bbec428eSgjelinek saw_error = B_TRUE; 63837c478bd9Sstevel@tonic-gate return; 6384087719fdSdp } 6385087719fdSdp 63867c478bd9Sstevel@tonic-gate if (end_op == CMD_ADD) { 63877c478bd9Sstevel@tonic-gate /* Make sure there isn't already one like this. */ 63887c478bd9Sstevel@tonic-gate (void) strlcpy(tmp_rctltab.zone_rctl_name, 63897c478bd9Sstevel@tonic-gate in_progress_rctltab.zone_rctl_name, 63907c478bd9Sstevel@tonic-gate sizeof (tmp_rctltab.zone_rctl_name)); 63917c478bd9Sstevel@tonic-gate tmp_rctltab.zone_rctl_valptr = NULL; 63927c478bd9Sstevel@tonic-gate err = zonecfg_lookup_rctl(handle, &tmp_rctltab); 63937c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list( 63947c478bd9Sstevel@tonic-gate tmp_rctltab.zone_rctl_valptr); 63957c478bd9Sstevel@tonic-gate if (err == Z_OK) { 63967c478bd9Sstevel@tonic-gate zerr(gettext("A %s resource " 63977c478bd9Sstevel@tonic-gate "with the %s '%s' already exists."), 63987c478bd9Sstevel@tonic-gate rt_to_str(RT_RCTL), pt_to_str(PT_NAME), 63997c478bd9Sstevel@tonic-gate in_progress_rctltab.zone_rctl_name); 6400bbec428eSgjelinek saw_error = B_TRUE; 64017c478bd9Sstevel@tonic-gate return; 64027c478bd9Sstevel@tonic-gate } 64037c478bd9Sstevel@tonic-gate err = zonecfg_add_rctl(handle, &in_progress_rctltab); 64047c478bd9Sstevel@tonic-gate } else { 64057c478bd9Sstevel@tonic-gate err = zonecfg_modify_rctl(handle, &old_rctltab, 64067c478bd9Sstevel@tonic-gate &in_progress_rctltab); 64077c478bd9Sstevel@tonic-gate } 64087c478bd9Sstevel@tonic-gate if (err == Z_OK) { 64097c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list( 64107c478bd9Sstevel@tonic-gate in_progress_rctltab.zone_rctl_valptr); 64117c478bd9Sstevel@tonic-gate in_progress_rctltab.zone_rctl_valptr = NULL; 64127c478bd9Sstevel@tonic-gate } 64137c478bd9Sstevel@tonic-gate break; 6414087719fdSdp 64157c478bd9Sstevel@tonic-gate case RT_ATTR: 64167c478bd9Sstevel@tonic-gate /* First make sure everything was filled in. */ 6417087719fdSdp (void) end_check_reqd(in_progress_attrtab.zone_attr_name, 6418087719fdSdp PT_NAME, &validation_failed); 6419087719fdSdp (void) end_check_reqd(in_progress_attrtab.zone_attr_type, 6420087719fdSdp PT_TYPE, &validation_failed); 6421087719fdSdp (void) end_check_reqd(in_progress_attrtab.zone_attr_value, 6422087719fdSdp PT_VALUE, &validation_failed); 6423087719fdSdp 64247c478bd9Sstevel@tonic-gate if (validate_attr_name(in_progress_attrtab.zone_attr_name) != 6425087719fdSdp Z_OK) 6426bbec428eSgjelinek validation_failed = B_TRUE; 6427087719fdSdp 6428087719fdSdp if (validate_attr_type_val(&in_progress_attrtab) != Z_OK) 6429bbec428eSgjelinek validation_failed = B_TRUE; 6430087719fdSdp 6431087719fdSdp if (validation_failed) { 6432bbec428eSgjelinek saw_error = B_TRUE; 64337c478bd9Sstevel@tonic-gate return; 6434087719fdSdp } 64357c478bd9Sstevel@tonic-gate if (end_op == CMD_ADD) { 64367c478bd9Sstevel@tonic-gate /* Make sure there isn't already one like this. */ 64377c478bd9Sstevel@tonic-gate bzero(&tmp_attrtab, sizeof (tmp_attrtab)); 64387c478bd9Sstevel@tonic-gate (void) strlcpy(tmp_attrtab.zone_attr_name, 64397c478bd9Sstevel@tonic-gate in_progress_attrtab.zone_attr_name, 64407c478bd9Sstevel@tonic-gate sizeof (tmp_attrtab.zone_attr_name)); 64417c478bd9Sstevel@tonic-gate if (zonecfg_lookup_attr(handle, &tmp_attrtab) == Z_OK) { 64427c478bd9Sstevel@tonic-gate zerr(gettext("An %s resource " 64437c478bd9Sstevel@tonic-gate "with the %s '%s' already exists."), 64447c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR), pt_to_str(PT_NAME), 64457c478bd9Sstevel@tonic-gate in_progress_attrtab.zone_attr_name); 6446bbec428eSgjelinek saw_error = B_TRUE; 64477c478bd9Sstevel@tonic-gate return; 64487c478bd9Sstevel@tonic-gate } 64497c478bd9Sstevel@tonic-gate err = zonecfg_add_attr(handle, &in_progress_attrtab); 64507c478bd9Sstevel@tonic-gate } else { 64517c478bd9Sstevel@tonic-gate err = zonecfg_modify_attr(handle, &old_attrtab, 64527c478bd9Sstevel@tonic-gate &in_progress_attrtab); 64537c478bd9Sstevel@tonic-gate } 64547c478bd9Sstevel@tonic-gate break; 6455fa9e4066Sahrens case RT_DATASET: 6456fa9e4066Sahrens /* First make sure everything was filled in. */ 6457fa9e4066Sahrens if (strlen(in_progress_dstab.zone_dataset_name) == 0) { 6458fa9e4066Sahrens zerr("%s %s", pt_to_str(PT_NAME), 6459fa9e4066Sahrens gettext("not specified")); 6460bbec428eSgjelinek saw_error = B_TRUE; 6461bbec428eSgjelinek validation_failed = B_TRUE; 6462fa9e4066Sahrens } 6463fa9e4066Sahrens if (validation_failed) 6464fa9e4066Sahrens return; 6465fa9e4066Sahrens if (end_op == CMD_ADD) { 6466fa9e4066Sahrens /* Make sure there isn't already one like this. */ 6467fa9e4066Sahrens bzero(&tmp_dstab, sizeof (tmp_dstab)); 6468fa9e4066Sahrens (void) strlcpy(tmp_dstab.zone_dataset_name, 6469fa9e4066Sahrens in_progress_dstab.zone_dataset_name, 6470fa9e4066Sahrens sizeof (tmp_dstab.zone_dataset_name)); 6471fa9e4066Sahrens err = zonecfg_lookup_ds(handle, &tmp_dstab); 6472fa9e4066Sahrens if (err == Z_OK) { 6473fa9e4066Sahrens zerr(gettext("A %s resource " 6474fa9e4066Sahrens "with the %s '%s' already exists."), 6475fa9e4066Sahrens rt_to_str(RT_DATASET), pt_to_str(PT_NAME), 6476fa9e4066Sahrens in_progress_dstab.zone_dataset_name); 6477bbec428eSgjelinek saw_error = B_TRUE; 6478fa9e4066Sahrens return; 6479fa9e4066Sahrens } 6480fa9e4066Sahrens err = zonecfg_add_ds(handle, &in_progress_dstab); 6481fa9e4066Sahrens } else { 6482fa9e4066Sahrens err = zonecfg_modify_ds(handle, &old_dstab, 6483fa9e4066Sahrens &in_progress_dstab); 6484fa9e4066Sahrens } 6485fa9e4066Sahrens break; 64860209230bSgjelinek case RT_DCPU: 64870209230bSgjelinek /* Make sure everything was filled in. */ 64880209230bSgjelinek if (end_check_reqd(in_progress_psettab.zone_ncpu_min, 64890209230bSgjelinek PT_NCPUS, &validation_failed) != Z_OK) { 6490bbec428eSgjelinek saw_error = B_TRUE; 64910209230bSgjelinek return; 64920209230bSgjelinek } 64930209230bSgjelinek 64940209230bSgjelinek if (end_op == CMD_ADD) { 64950209230bSgjelinek err = zonecfg_add_pset(handle, &in_progress_psettab); 64960209230bSgjelinek } else { 64970209230bSgjelinek err = zonecfg_modify_pset(handle, &in_progress_psettab); 64980209230bSgjelinek } 64990209230bSgjelinek break; 6500c97ad5cdSakolb case RT_PCAP: 6501c97ad5cdSakolb /* Make sure everything was filled in. */ 6502c97ad5cdSakolb if (zonecfg_get_aliased_rctl(handle, ALIAS_CPUCAP, &proc_cap) 6503c97ad5cdSakolb != Z_OK) { 6504c97ad5cdSakolb zerr(gettext("%s not specified"), pt_to_str(PT_NCPUS)); 6505bbec428eSgjelinek saw_error = B_TRUE; 6506bbec428eSgjelinek validation_failed = B_TRUE; 6507c97ad5cdSakolb return; 6508c97ad5cdSakolb } 6509c97ad5cdSakolb err = Z_OK; 6510c97ad5cdSakolb break; 65110209230bSgjelinek case RT_MCAP: 65120209230bSgjelinek /* Make sure everything was filled in. */ 65130209230bSgjelinek res1 = strlen(in_progress_mcaptab.zone_physmem_cap) == 0 ? 65140209230bSgjelinek Z_ERR : Z_OK; 65150209230bSgjelinek res2 = zonecfg_get_aliased_rctl(handle, ALIAS_MAXSWAP, 65160209230bSgjelinek &swap_limit); 65170209230bSgjelinek res3 = zonecfg_get_aliased_rctl(handle, ALIAS_MAXLOCKEDMEM, 65180209230bSgjelinek &locked_limit); 65190209230bSgjelinek 65200209230bSgjelinek if (res1 != Z_OK && res2 != Z_OK && res3 != Z_OK) { 65210209230bSgjelinek zerr(gettext("No property was specified. One of %s, " 65220209230bSgjelinek "%s or %s is required."), pt_to_str(PT_PHYSICAL), 65230209230bSgjelinek pt_to_str(PT_SWAP), pt_to_str(PT_LOCKED)); 6524bbec428eSgjelinek saw_error = B_TRUE; 65250209230bSgjelinek return; 65260209230bSgjelinek } 65270209230bSgjelinek 65280209230bSgjelinek /* if phys & locked are both set, verify locked <= phys */ 65290209230bSgjelinek if (res1 == Z_OK && res3 == Z_OK) { 65300209230bSgjelinek uint64_t phys_limit; 65310209230bSgjelinek char *endp; 65320209230bSgjelinek 65330209230bSgjelinek phys_limit = strtoull( 65340209230bSgjelinek in_progress_mcaptab.zone_physmem_cap, &endp, 10); 65350209230bSgjelinek if (phys_limit < locked_limit) { 65360209230bSgjelinek zerr(gettext("The %s cap must be less than or " 65370209230bSgjelinek "equal to the %s cap."), 65380209230bSgjelinek pt_to_str(PT_LOCKED), 65390209230bSgjelinek pt_to_str(PT_PHYSICAL)); 6540bbec428eSgjelinek saw_error = B_TRUE; 65410209230bSgjelinek return; 65420209230bSgjelinek } 65430209230bSgjelinek } 65440209230bSgjelinek 65450209230bSgjelinek err = Z_OK; 65460209230bSgjelinek if (res1 == Z_OK) { 65470209230bSgjelinek /* 65480209230bSgjelinek * We could be ending from either an add operation 65490209230bSgjelinek * or a select operation. Since all of the properties 65500209230bSgjelinek * within this resource are optional, we always use 65510209230bSgjelinek * modify on the mcap entry. zonecfg_modify_mcap() 65520209230bSgjelinek * will handle both adding and modifying a memory cap. 65530209230bSgjelinek */ 65540209230bSgjelinek err = zonecfg_modify_mcap(handle, &in_progress_mcaptab); 65550209230bSgjelinek } else if (end_op == CMD_SELECT) { 65560209230bSgjelinek /* 65570209230bSgjelinek * If we're ending from a select and the physical 65580209230bSgjelinek * memory cap is empty then the user could have cleared 65590209230bSgjelinek * the physical cap value, so try to delete the entry. 65600209230bSgjelinek */ 65610209230bSgjelinek (void) zonecfg_delete_mcap(handle); 65620209230bSgjelinek } 65630209230bSgjelinek break; 6564cb8a054bSGlenn Faden case RT_ADMIN: 6565cb8a054bSGlenn Faden /* First make sure everything was filled in. */ 6566cb8a054bSGlenn Faden if (end_check_reqd(in_progress_admintab.zone_admin_user, 6567cb8a054bSGlenn Faden PT_USER, &validation_failed) == Z_OK) { 6568cb8a054bSGlenn Faden if (getpwnam(in_progress_admintab.zone_admin_user) 6569cb8a054bSGlenn Faden == NULL) { 6570cb8a054bSGlenn Faden zerr(gettext("%s %s is not a valid username"), 6571cb8a054bSGlenn Faden pt_to_str(PT_USER), 6572cb8a054bSGlenn Faden in_progress_admintab.zone_admin_user); 6573cb8a054bSGlenn Faden validation_failed = B_TRUE; 6574cb8a054bSGlenn Faden } 6575cb8a054bSGlenn Faden } 6576cb8a054bSGlenn Faden 6577cb8a054bSGlenn Faden if (end_check_reqd(in_progress_admintab.zone_admin_auths, 6578cb8a054bSGlenn Faden PT_AUTHS, &validation_failed) == Z_OK) { 6579cb8a054bSGlenn Faden if (!zonecfg_valid_auths( 6580cb8a054bSGlenn Faden in_progress_admintab.zone_admin_auths, 6581cb8a054bSGlenn Faden zone)) { 6582cb8a054bSGlenn Faden validation_failed = B_TRUE; 6583cb8a054bSGlenn Faden } 6584cb8a054bSGlenn Faden } 6585cb8a054bSGlenn Faden 6586cb8a054bSGlenn Faden if (validation_failed) { 6587cb8a054bSGlenn Faden saw_error = B_TRUE; 6588cb8a054bSGlenn Faden return; 6589cb8a054bSGlenn Faden } 6590cb8a054bSGlenn Faden 6591cb8a054bSGlenn Faden if (end_op == CMD_ADD) { 6592cb8a054bSGlenn Faden /* Make sure there isn't already one like this. */ 6593cb8a054bSGlenn Faden bzero(&tmp_admintab, sizeof (tmp_admintab)); 6594cb8a054bSGlenn Faden (void) strlcpy(tmp_admintab.zone_admin_user, 6595cb8a054bSGlenn Faden in_progress_admintab.zone_admin_user, 6596cb8a054bSGlenn Faden sizeof (tmp_admintab.zone_admin_user)); 6597cb8a054bSGlenn Faden err = zonecfg_lookup_admin( 6598cb8a054bSGlenn Faden handle, &tmp_admintab); 6599cb8a054bSGlenn Faden if (err == Z_OK) { 6600cb8a054bSGlenn Faden zerr(gettext("A %s resource " 6601cb8a054bSGlenn Faden "with the %s '%s' already exists."), 6602cb8a054bSGlenn Faden rt_to_str(RT_ADMIN), 6603cb8a054bSGlenn Faden pt_to_str(PT_USER), 6604cb8a054bSGlenn Faden in_progress_admintab.zone_admin_user); 6605cb8a054bSGlenn Faden saw_error = B_TRUE; 6606cb8a054bSGlenn Faden return; 6607cb8a054bSGlenn Faden } 6608cb8a054bSGlenn Faden err = zonecfg_add_admin(handle, 6609cb8a054bSGlenn Faden &in_progress_admintab, zone); 6610cb8a054bSGlenn Faden } else { 6611cb8a054bSGlenn Faden err = zonecfg_modify_admin(handle, 6612cb8a054bSGlenn Faden &old_admintab, &in_progress_admintab, 6613cb8a054bSGlenn Faden zone); 6614cb8a054bSGlenn Faden } 6615cb8a054bSGlenn Faden break; 66167c478bd9Sstevel@tonic-gate default: 66177c478bd9Sstevel@tonic-gate zone_perror(rt_to_str(resource_scope), Z_NO_RESOURCE_TYPE, 6618bbec428eSgjelinek B_TRUE); 6619bbec428eSgjelinek saw_error = B_TRUE; 66207c478bd9Sstevel@tonic-gate return; 66217c478bd9Sstevel@tonic-gate } 66227c478bd9Sstevel@tonic-gate 66237c478bd9Sstevel@tonic-gate if (err != Z_OK) { 6624bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 66257c478bd9Sstevel@tonic-gate } else { 6626bbec428eSgjelinek need_to_commit = B_TRUE; 6627bbec428eSgjelinek global_scope = B_TRUE; 66287c478bd9Sstevel@tonic-gate end_op = -1; 66297c478bd9Sstevel@tonic-gate } 66307c478bd9Sstevel@tonic-gate } 66317c478bd9Sstevel@tonic-gate 66327c478bd9Sstevel@tonic-gate void 66337c478bd9Sstevel@tonic-gate commit_func(cmd_t *cmd) 66347c478bd9Sstevel@tonic-gate { 66357c478bd9Sstevel@tonic-gate int arg; 6636bbec428eSgjelinek boolean_t arg_err = B_FALSE; 66377c478bd9Sstevel@tonic-gate 66387c478bd9Sstevel@tonic-gate optind = 0; 66397ec75eb8Sgjelinek while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?")) != EOF) { 66407c478bd9Sstevel@tonic-gate switch (arg) { 66417c478bd9Sstevel@tonic-gate case '?': 66427c478bd9Sstevel@tonic-gate longer_usage(CMD_COMMIT); 6643bbec428eSgjelinek arg_err = B_TRUE; 66447ec75eb8Sgjelinek break; 66457c478bd9Sstevel@tonic-gate default: 66467c478bd9Sstevel@tonic-gate short_usage(CMD_COMMIT); 6647bbec428eSgjelinek arg_err = B_TRUE; 66487ec75eb8Sgjelinek break; 66497ec75eb8Sgjelinek } 66507ec75eb8Sgjelinek } 66517ec75eb8Sgjelinek if (arg_err) 66527c478bd9Sstevel@tonic-gate return; 66537ec75eb8Sgjelinek 66547c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 66557c478bd9Sstevel@tonic-gate short_usage(CMD_COMMIT); 66567c478bd9Sstevel@tonic-gate return; 66577c478bd9Sstevel@tonic-gate } 66587c478bd9Sstevel@tonic-gate 66597c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_COMMIT)) 66607c478bd9Sstevel@tonic-gate return; 66617c478bd9Sstevel@tonic-gate 66627c478bd9Sstevel@tonic-gate assert(cmd != NULL); 66637c478bd9Sstevel@tonic-gate 66647c478bd9Sstevel@tonic-gate cmd->cmd_argc = 1; 66657c478bd9Sstevel@tonic-gate /* 66667c478bd9Sstevel@tonic-gate * cmd_arg normally comes from a strdup() in the lexer, and the 66677c478bd9Sstevel@tonic-gate * whole cmd structure and its (char *) attributes are freed at 66687c478bd9Sstevel@tonic-gate * the completion of each command, so the strdup() below is needed 66697c478bd9Sstevel@tonic-gate * to match this and prevent a core dump from trying to free() 66707c478bd9Sstevel@tonic-gate * something that can't be. 66717c478bd9Sstevel@tonic-gate */ 66727c478bd9Sstevel@tonic-gate if ((cmd->cmd_argv[0] = strdup("save")) == NULL) { 6673bbec428eSgjelinek zone_perror(zone, Z_NOMEM, B_TRUE); 66747c478bd9Sstevel@tonic-gate exit(Z_ERR); 66757c478bd9Sstevel@tonic-gate } 66767c478bd9Sstevel@tonic-gate cmd->cmd_argv[1] = NULL; 66777c478bd9Sstevel@tonic-gate verify_func(cmd); 66787c478bd9Sstevel@tonic-gate } 66797c478bd9Sstevel@tonic-gate 66807c478bd9Sstevel@tonic-gate void 66817c478bd9Sstevel@tonic-gate revert_func(cmd_t *cmd) 66827c478bd9Sstevel@tonic-gate { 66837c478bd9Sstevel@tonic-gate char line[128]; /* enough to ask a question */ 6684bbec428eSgjelinek boolean_t force = B_FALSE; 6685bbec428eSgjelinek boolean_t arg_err = B_FALSE; 66867c478bd9Sstevel@tonic-gate int err, arg, answer; 66877c478bd9Sstevel@tonic-gate 66887c478bd9Sstevel@tonic-gate optind = 0; 66897c478bd9Sstevel@tonic-gate while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?F")) != EOF) { 66907c478bd9Sstevel@tonic-gate switch (arg) { 66917c478bd9Sstevel@tonic-gate case '?': 66927c478bd9Sstevel@tonic-gate longer_usage(CMD_REVERT); 6693bbec428eSgjelinek arg_err = B_TRUE; 66947ec75eb8Sgjelinek break; 66957c478bd9Sstevel@tonic-gate case 'F': 6696bbec428eSgjelinek force = B_TRUE; 66977c478bd9Sstevel@tonic-gate break; 66987c478bd9Sstevel@tonic-gate default: 66997c478bd9Sstevel@tonic-gate short_usage(CMD_REVERT); 6700bbec428eSgjelinek arg_err = B_TRUE; 67017ec75eb8Sgjelinek break; 67027ec75eb8Sgjelinek } 67037ec75eb8Sgjelinek } 67047ec75eb8Sgjelinek if (arg_err) 67057c478bd9Sstevel@tonic-gate return; 67067ec75eb8Sgjelinek 67077c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 67087c478bd9Sstevel@tonic-gate short_usage(CMD_REVERT); 67097c478bd9Sstevel@tonic-gate return; 67107c478bd9Sstevel@tonic-gate } 67117c478bd9Sstevel@tonic-gate 67127c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_REVERT)) 67137c478bd9Sstevel@tonic-gate return; 67147c478bd9Sstevel@tonic-gate 67155b418297Sjv227347 if (!global_scope) { 67165b418297Sjv227347 zerr(gettext("You can only use %s in the global scope.\nUse" 67175b418297Sjv227347 " '%s' to cancel changes to a resource specification."), 67185b418297Sjv227347 cmd_to_str(CMD_REVERT), cmd_to_str(CMD_CANCEL)); 67195b418297Sjv227347 saw_error = B_TRUE; 67205b418297Sjv227347 return; 67215b418297Sjv227347 } 67225b418297Sjv227347 67237c478bd9Sstevel@tonic-gate if (zonecfg_check_handle(handle) != Z_OK) { 67247c478bd9Sstevel@tonic-gate zerr(gettext("No changes to revert.")); 6725bbec428eSgjelinek saw_error = B_TRUE; 67267c478bd9Sstevel@tonic-gate return; 67277c478bd9Sstevel@tonic-gate } 67287c478bd9Sstevel@tonic-gate 67297c478bd9Sstevel@tonic-gate if (!force) { 67307c478bd9Sstevel@tonic-gate (void) snprintf(line, sizeof (line), 67317c478bd9Sstevel@tonic-gate gettext("Are you sure you want to revert")); 6732bbec428eSgjelinek if ((answer = ask_yesno(B_FALSE, line)) == -1) { 67337c478bd9Sstevel@tonic-gate zerr(gettext("Input not from terminal and -F not " 67347c478bd9Sstevel@tonic-gate "specified:\n%s command ignored, exiting."), 67357c478bd9Sstevel@tonic-gate cmd_to_str(CMD_REVERT)); 67367c478bd9Sstevel@tonic-gate exit(Z_ERR); 67377c478bd9Sstevel@tonic-gate } 67387c478bd9Sstevel@tonic-gate if (answer != 1) 67397c478bd9Sstevel@tonic-gate return; 67407c478bd9Sstevel@tonic-gate } 67417c478bd9Sstevel@tonic-gate 67427c478bd9Sstevel@tonic-gate /* 6743cb8a054bSGlenn Faden * Reset any pending admins that were 6744cb8a054bSGlenn Faden * removed from the previous zone 6745cb8a054bSGlenn Faden */ 6746cb8a054bSGlenn Faden zonecfg_remove_userauths(handle, "", zone, B_FALSE); 6747cb8a054bSGlenn Faden 6748cb8a054bSGlenn Faden /* 67497c478bd9Sstevel@tonic-gate * Time for a new handle: finish the old one off first 67507c478bd9Sstevel@tonic-gate * then get a new one properly to avoid leaks. 67517c478bd9Sstevel@tonic-gate */ 67527c478bd9Sstevel@tonic-gate zonecfg_fini_handle(handle); 67537c478bd9Sstevel@tonic-gate if ((handle = zonecfg_init_handle()) == NULL) { 6754bbec428eSgjelinek zone_perror(execname, Z_NOMEM, B_TRUE); 67557c478bd9Sstevel@tonic-gate exit(Z_ERR); 67567c478bd9Sstevel@tonic-gate } 6757cb8a054bSGlenn Faden 6758087719fdSdp if ((err = zonecfg_get_handle(revert_zone, handle)) != Z_OK) { 6759bbec428eSgjelinek saw_error = B_TRUE; 6760bbec428eSgjelinek got_handle = B_FALSE; 67617c478bd9Sstevel@tonic-gate if (err == Z_NO_ZONE) 67627c478bd9Sstevel@tonic-gate zerr(gettext("%s: no such saved zone to revert to."), 6763087719fdSdp revert_zone); 67647c478bd9Sstevel@tonic-gate else 6765bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 67667c478bd9Sstevel@tonic-gate } 6767087719fdSdp (void) strlcpy(zone, revert_zone, sizeof (zone)); 67687c478bd9Sstevel@tonic-gate } 67697c478bd9Sstevel@tonic-gate 67707c478bd9Sstevel@tonic-gate void 67717c478bd9Sstevel@tonic-gate help_func(cmd_t *cmd) 67727c478bd9Sstevel@tonic-gate { 67737c478bd9Sstevel@tonic-gate int i; 67747c478bd9Sstevel@tonic-gate 67757c478bd9Sstevel@tonic-gate assert(cmd != NULL); 67767c478bd9Sstevel@tonic-gate 67777c478bd9Sstevel@tonic-gate if (cmd->cmd_argc == 0) { 6778bbec428eSgjelinek usage(B_TRUE, global_scope ? HELP_SUBCMDS : HELP_RES_SCOPE); 67797c478bd9Sstevel@tonic-gate return; 67807c478bd9Sstevel@tonic-gate } 67817c478bd9Sstevel@tonic-gate if (strcmp(cmd->cmd_argv[0], "usage") == 0) { 6782bbec428eSgjelinek usage(B_TRUE, HELP_USAGE); 67837c478bd9Sstevel@tonic-gate return; 67847c478bd9Sstevel@tonic-gate } 67857c478bd9Sstevel@tonic-gate if (strcmp(cmd->cmd_argv[0], "commands") == 0) { 6786bbec428eSgjelinek usage(B_TRUE, HELP_SUBCMDS); 67877c478bd9Sstevel@tonic-gate return; 67887c478bd9Sstevel@tonic-gate } 67897c478bd9Sstevel@tonic-gate if (strcmp(cmd->cmd_argv[0], "syntax") == 0) { 6790bbec428eSgjelinek usage(B_TRUE, HELP_SYNTAX | HELP_RES_PROPS); 67917c478bd9Sstevel@tonic-gate return; 67927c478bd9Sstevel@tonic-gate } 67937c478bd9Sstevel@tonic-gate if (strcmp(cmd->cmd_argv[0], "-?") == 0) { 67947c478bd9Sstevel@tonic-gate longer_usage(CMD_HELP); 67957c478bd9Sstevel@tonic-gate return; 67967c478bd9Sstevel@tonic-gate } 67977c478bd9Sstevel@tonic-gate 67987c478bd9Sstevel@tonic-gate for (i = 0; i <= CMD_MAX; i++) { 67997c478bd9Sstevel@tonic-gate if (strcmp(cmd->cmd_argv[0], cmd_to_str(i)) == 0) { 68007c478bd9Sstevel@tonic-gate longer_usage(i); 68017c478bd9Sstevel@tonic-gate return; 68027c478bd9Sstevel@tonic-gate } 68037c478bd9Sstevel@tonic-gate } 68047c478bd9Sstevel@tonic-gate /* We do not use zerr() here because we do not want its extra \n. */ 68057c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("Unknown help subject %s. "), 68067c478bd9Sstevel@tonic-gate cmd->cmd_argv[0]); 6807bbec428eSgjelinek usage(B_FALSE, HELP_META); 68087c478bd9Sstevel@tonic-gate } 68097c478bd9Sstevel@tonic-gate 68107c478bd9Sstevel@tonic-gate static int 68117c478bd9Sstevel@tonic-gate string_to_yyin(char *string) 68127c478bd9Sstevel@tonic-gate { 68137c478bd9Sstevel@tonic-gate if ((yyin = tmpfile()) == NULL) { 6814bbec428eSgjelinek zone_perror(execname, Z_TEMP_FILE, B_TRUE); 68157c478bd9Sstevel@tonic-gate return (Z_ERR); 68167c478bd9Sstevel@tonic-gate } 68177c478bd9Sstevel@tonic-gate if (fwrite(string, strlen(string), 1, yyin) != 1) { 6818bbec428eSgjelinek zone_perror(execname, Z_TEMP_FILE, B_TRUE); 68197c478bd9Sstevel@tonic-gate return (Z_ERR); 68207c478bd9Sstevel@tonic-gate } 68217c478bd9Sstevel@tonic-gate if (fseek(yyin, 0, SEEK_SET) != 0) { 6822bbec428eSgjelinek zone_perror(execname, Z_TEMP_FILE, B_TRUE); 68237c478bd9Sstevel@tonic-gate return (Z_ERR); 68247c478bd9Sstevel@tonic-gate } 68257c478bd9Sstevel@tonic-gate return (Z_OK); 68267c478bd9Sstevel@tonic-gate } 68277c478bd9Sstevel@tonic-gate 68287c478bd9Sstevel@tonic-gate /* This is the back-end helper function for read_input() below. */ 68297c478bd9Sstevel@tonic-gate 68307c478bd9Sstevel@tonic-gate static int 68317c478bd9Sstevel@tonic-gate cleanup() 68327c478bd9Sstevel@tonic-gate { 68337c478bd9Sstevel@tonic-gate int answer; 68347c478bd9Sstevel@tonic-gate cmd_t *cmd; 68357c478bd9Sstevel@tonic-gate 68367c478bd9Sstevel@tonic-gate if (!interactive_mode && !cmd_file_mode) { 68377c478bd9Sstevel@tonic-gate /* 68387c478bd9Sstevel@tonic-gate * If we're not in interactive mode, and we're not in command 68397c478bd9Sstevel@tonic-gate * file mode, then we must be in commands-from-the-command-line 68407c478bd9Sstevel@tonic-gate * mode. As such, we can't loop back and ask for more input. 68417c478bd9Sstevel@tonic-gate * It was OK to prompt for such things as whether or not to 68427c478bd9Sstevel@tonic-gate * really delete a zone in the command handler called from 68437c478bd9Sstevel@tonic-gate * yyparse() above, but "really quit?" makes no sense in this 68447c478bd9Sstevel@tonic-gate * context. So disable prompting. 68457c478bd9Sstevel@tonic-gate */ 6846bbec428eSgjelinek ok_to_prompt = B_FALSE; 68477c478bd9Sstevel@tonic-gate } 68487c478bd9Sstevel@tonic-gate if (!global_scope) { 68497c478bd9Sstevel@tonic-gate if (!time_to_exit) { 68507c478bd9Sstevel@tonic-gate /* 68517c478bd9Sstevel@tonic-gate * Just print a simple error message in the -1 case, 68527c478bd9Sstevel@tonic-gate * since exit_func() already handles that case, and 68537c478bd9Sstevel@tonic-gate * EOF means we are finished anyway. 68547c478bd9Sstevel@tonic-gate */ 6855bbec428eSgjelinek answer = ask_yesno(B_FALSE, 68567c478bd9Sstevel@tonic-gate gettext("Resource incomplete; really quit")); 68577c478bd9Sstevel@tonic-gate if (answer == -1) { 68587c478bd9Sstevel@tonic-gate zerr(gettext("Resource incomplete.")); 68597c478bd9Sstevel@tonic-gate return (Z_ERR); 68607c478bd9Sstevel@tonic-gate } 68617c478bd9Sstevel@tonic-gate if (answer != 1) { 68627c478bd9Sstevel@tonic-gate yyin = stdin; 68637c478bd9Sstevel@tonic-gate return (Z_REPEAT); 68647c478bd9Sstevel@tonic-gate } 68657c478bd9Sstevel@tonic-gate } else { 6866bbec428eSgjelinek saw_error = B_TRUE; 68677c478bd9Sstevel@tonic-gate } 68687c478bd9Sstevel@tonic-gate } 68697c478bd9Sstevel@tonic-gate /* 68707c478bd9Sstevel@tonic-gate * Make sure we tried something and that the handle checks 68717c478bd9Sstevel@tonic-gate * out, or we would get a false error trying to commit. 68727c478bd9Sstevel@tonic-gate */ 68737c478bd9Sstevel@tonic-gate if (need_to_commit && zonecfg_check_handle(handle) == Z_OK) { 68747c478bd9Sstevel@tonic-gate if ((cmd = alloc_cmd()) == NULL) { 6875bbec428eSgjelinek zone_perror(zone, Z_NOMEM, B_TRUE); 68767c478bd9Sstevel@tonic-gate return (Z_ERR); 68777c478bd9Sstevel@tonic-gate } 68787c478bd9Sstevel@tonic-gate cmd->cmd_argc = 0; 68797c478bd9Sstevel@tonic-gate cmd->cmd_argv[0] = NULL; 68807c478bd9Sstevel@tonic-gate commit_func(cmd); 68817c478bd9Sstevel@tonic-gate free_cmd(cmd); 68827c478bd9Sstevel@tonic-gate /* 68837c478bd9Sstevel@tonic-gate * need_to_commit will get set back to FALSE if the 68847c478bd9Sstevel@tonic-gate * configuration is saved successfully. 68857c478bd9Sstevel@tonic-gate */ 68867c478bd9Sstevel@tonic-gate if (need_to_commit) { 68877c478bd9Sstevel@tonic-gate if (force_exit) { 68887c478bd9Sstevel@tonic-gate zerr(gettext("Configuration not saved.")); 68897c478bd9Sstevel@tonic-gate return (Z_ERR); 68907c478bd9Sstevel@tonic-gate } 6891bbec428eSgjelinek answer = ask_yesno(B_FALSE, 68927c478bd9Sstevel@tonic-gate gettext("Configuration not saved; really quit")); 68937c478bd9Sstevel@tonic-gate if (answer == -1) { 68947c478bd9Sstevel@tonic-gate zerr(gettext("Configuration not saved.")); 68957c478bd9Sstevel@tonic-gate return (Z_ERR); 68967c478bd9Sstevel@tonic-gate } 68977c478bd9Sstevel@tonic-gate if (answer != 1) { 6898bbec428eSgjelinek time_to_exit = B_FALSE; 68997c478bd9Sstevel@tonic-gate yyin = stdin; 69007c478bd9Sstevel@tonic-gate return (Z_REPEAT); 69017c478bd9Sstevel@tonic-gate } 69027c478bd9Sstevel@tonic-gate } 69037c478bd9Sstevel@tonic-gate } 69047c478bd9Sstevel@tonic-gate return ((need_to_commit || saw_error) ? Z_ERR : Z_OK); 69057c478bd9Sstevel@tonic-gate } 69067c478bd9Sstevel@tonic-gate 69077c478bd9Sstevel@tonic-gate /* 69087c478bd9Sstevel@tonic-gate * read_input() is the driver of this program. It is a wrapper around 69097c478bd9Sstevel@tonic-gate * yyparse(), printing appropriate prompts when needed, checking for 69107c478bd9Sstevel@tonic-gate * exit conditions and reacting appropriately [the latter in its cleanup() 69117c478bd9Sstevel@tonic-gate * helper function]. 69127c478bd9Sstevel@tonic-gate * 69137c478bd9Sstevel@tonic-gate * Like most zonecfg functions, it returns Z_OK or Z_ERR, *or* Z_REPEAT 69147c478bd9Sstevel@tonic-gate * so do_interactive() knows that we are not really done (i.e, we asked 69157c478bd9Sstevel@tonic-gate * the user if we should really quit and the user said no). 69167c478bd9Sstevel@tonic-gate */ 69177c478bd9Sstevel@tonic-gate static int 69187c478bd9Sstevel@tonic-gate read_input() 69197c478bd9Sstevel@tonic-gate { 6920bbec428eSgjelinek boolean_t yyin_is_a_tty = isatty(fileno(yyin)); 69217c478bd9Sstevel@tonic-gate /* 69227c478bd9Sstevel@tonic-gate * The prompt is "e:z> " or "e:z:r> " where e is execname, z is zone 69237c478bd9Sstevel@tonic-gate * and r is resource_scope: 5 is for the two ":"s + "> " + terminator. 69247c478bd9Sstevel@tonic-gate */ 69257c478bd9Sstevel@tonic-gate char prompt[MAXPATHLEN + ZONENAME_MAX + MAX_RT_STRLEN + 5], *line; 69267c478bd9Sstevel@tonic-gate 69277c478bd9Sstevel@tonic-gate /* yyin should have been set to the appropriate (FILE *) if not stdin */ 6928bbec428eSgjelinek newline_terminated = B_TRUE; 69297c478bd9Sstevel@tonic-gate for (;;) { 69307c478bd9Sstevel@tonic-gate if (yyin_is_a_tty) { 69317c478bd9Sstevel@tonic-gate if (newline_terminated) { 69327c478bd9Sstevel@tonic-gate if (global_scope) 69337c478bd9Sstevel@tonic-gate (void) snprintf(prompt, sizeof (prompt), 69347c478bd9Sstevel@tonic-gate "%s:%s> ", execname, zone); 69357c478bd9Sstevel@tonic-gate else 69367c478bd9Sstevel@tonic-gate (void) snprintf(prompt, sizeof (prompt), 69377c478bd9Sstevel@tonic-gate "%s:%s:%s> ", execname, zone, 69387c478bd9Sstevel@tonic-gate rt_to_str(resource_scope)); 69397c478bd9Sstevel@tonic-gate } 69407c478bd9Sstevel@tonic-gate /* 69417c478bd9Sstevel@tonic-gate * If the user hits ^C then we want to catch it and 69427c478bd9Sstevel@tonic-gate * start over. If the user hits EOF then we want to 69437c478bd9Sstevel@tonic-gate * bail out. 69447c478bd9Sstevel@tonic-gate */ 69457c478bd9Sstevel@tonic-gate line = gl_get_line(gl, prompt, NULL, -1); 69467c478bd9Sstevel@tonic-gate if (gl_return_status(gl) == GLR_SIGNAL) { 69477c478bd9Sstevel@tonic-gate gl_abandon_line(gl); 69487c478bd9Sstevel@tonic-gate continue; 69497c478bd9Sstevel@tonic-gate } 69507c478bd9Sstevel@tonic-gate if (line == NULL) 69517c478bd9Sstevel@tonic-gate break; 69527c478bd9Sstevel@tonic-gate (void) string_to_yyin(line); 69537c478bd9Sstevel@tonic-gate while (!feof(yyin)) 69547c478bd9Sstevel@tonic-gate yyparse(); 69557c478bd9Sstevel@tonic-gate } else { 69567c478bd9Sstevel@tonic-gate yyparse(); 69577c478bd9Sstevel@tonic-gate } 69587c478bd9Sstevel@tonic-gate /* Bail out on an error in command file mode. */ 69597c478bd9Sstevel@tonic-gate if (saw_error && cmd_file_mode && !interactive_mode) 6960bbec428eSgjelinek time_to_exit = B_TRUE; 69617c478bd9Sstevel@tonic-gate if (time_to_exit || (!yyin_is_a_tty && feof(yyin))) 69627c478bd9Sstevel@tonic-gate break; 69637c478bd9Sstevel@tonic-gate } 69647c478bd9Sstevel@tonic-gate return (cleanup()); 69657c478bd9Sstevel@tonic-gate } 69667c478bd9Sstevel@tonic-gate 69677c478bd9Sstevel@tonic-gate /* 69687c478bd9Sstevel@tonic-gate * This function is used in the zonecfg-interactive-mode scenario: it just 69697c478bd9Sstevel@tonic-gate * calls read_input() until we are done. 69707c478bd9Sstevel@tonic-gate */ 69717c478bd9Sstevel@tonic-gate 69727c478bd9Sstevel@tonic-gate static int 69737c478bd9Sstevel@tonic-gate do_interactive(void) 69747c478bd9Sstevel@tonic-gate { 69757c478bd9Sstevel@tonic-gate int err; 69767c478bd9Sstevel@tonic-gate 6977bbec428eSgjelinek interactive_mode = B_TRUE; 69787c478bd9Sstevel@tonic-gate if (!read_only_mode) { 69797c478bd9Sstevel@tonic-gate /* 69807c478bd9Sstevel@tonic-gate * Try to set things up proactively in interactive mode, so 69817c478bd9Sstevel@tonic-gate * that if the zone in question does not exist yet, we can 69827c478bd9Sstevel@tonic-gate * provide the user with a clue. 69837c478bd9Sstevel@tonic-gate */ 6984bbec428eSgjelinek (void) initialize(B_FALSE); 69857c478bd9Sstevel@tonic-gate } 6986087719fdSdp do { 69877c478bd9Sstevel@tonic-gate err = read_input(); 6988087719fdSdp } while (err == Z_REPEAT); 69897c478bd9Sstevel@tonic-gate return (err); 69907c478bd9Sstevel@tonic-gate } 69917c478bd9Sstevel@tonic-gate 69927c478bd9Sstevel@tonic-gate /* 69937c478bd9Sstevel@tonic-gate * cmd_file is slightly more complicated, as it has to open the command file 69947c478bd9Sstevel@tonic-gate * and set yyin appropriately. Once that is done, though, it just calls 69957c478bd9Sstevel@tonic-gate * read_input(), and only once, since prompting is not possible. 69967c478bd9Sstevel@tonic-gate */ 69977c478bd9Sstevel@tonic-gate 69987c478bd9Sstevel@tonic-gate static int 69997c478bd9Sstevel@tonic-gate cmd_file(char *file) 70007c478bd9Sstevel@tonic-gate { 70017c478bd9Sstevel@tonic-gate FILE *infile; 70027c478bd9Sstevel@tonic-gate int err; 70037c478bd9Sstevel@tonic-gate struct stat statbuf; 7004bbec428eSgjelinek boolean_t using_real_file = (strcmp(file, "-") != 0); 70057c478bd9Sstevel@tonic-gate 70067c478bd9Sstevel@tonic-gate if (using_real_file) { 70077c478bd9Sstevel@tonic-gate /* 70087c478bd9Sstevel@tonic-gate * zerr() prints a line number in cmd_file_mode, which we do 70097c478bd9Sstevel@tonic-gate * not want here, so temporarily unset it. 70107c478bd9Sstevel@tonic-gate */ 7011bbec428eSgjelinek cmd_file_mode = B_FALSE; 70127c478bd9Sstevel@tonic-gate if ((infile = fopen(file, "r")) == NULL) { 70137c478bd9Sstevel@tonic-gate zerr(gettext("could not open file %s: %s"), 70147c478bd9Sstevel@tonic-gate file, strerror(errno)); 70157c478bd9Sstevel@tonic-gate return (Z_ERR); 70167c478bd9Sstevel@tonic-gate } 70177c478bd9Sstevel@tonic-gate if ((err = fstat(fileno(infile), &statbuf)) != 0) { 70187c478bd9Sstevel@tonic-gate zerr(gettext("could not stat file %s: %s"), 70197c478bd9Sstevel@tonic-gate file, strerror(errno)); 70207c478bd9Sstevel@tonic-gate err = Z_ERR; 70217c478bd9Sstevel@tonic-gate goto done; 70227c478bd9Sstevel@tonic-gate } 70237c478bd9Sstevel@tonic-gate if (!S_ISREG(statbuf.st_mode)) { 70247c478bd9Sstevel@tonic-gate zerr(gettext("%s is not a regular file."), file); 70257c478bd9Sstevel@tonic-gate err = Z_ERR; 70267c478bd9Sstevel@tonic-gate goto done; 70277c478bd9Sstevel@tonic-gate } 70287c478bd9Sstevel@tonic-gate yyin = infile; 7029bbec428eSgjelinek cmd_file_mode = B_TRUE; 7030bbec428eSgjelinek ok_to_prompt = B_FALSE; 70317c478bd9Sstevel@tonic-gate } else { 70327c478bd9Sstevel@tonic-gate /* 70337c478bd9Sstevel@tonic-gate * "-f -" is essentially the same as interactive mode, 70347c478bd9Sstevel@tonic-gate * so treat it that way. 70357c478bd9Sstevel@tonic-gate */ 7036bbec428eSgjelinek interactive_mode = B_TRUE; 70377c478bd9Sstevel@tonic-gate } 70387c478bd9Sstevel@tonic-gate /* Z_REPEAT is for interactive mode; treat it like Z_ERR here. */ 70397c478bd9Sstevel@tonic-gate if ((err = read_input()) == Z_REPEAT) 70407c478bd9Sstevel@tonic-gate err = Z_ERR; 70417c478bd9Sstevel@tonic-gate done: 70427c478bd9Sstevel@tonic-gate if (using_real_file) 70437c478bd9Sstevel@tonic-gate (void) fclose(infile); 70447c478bd9Sstevel@tonic-gate return (err); 70457c478bd9Sstevel@tonic-gate } 70467c478bd9Sstevel@tonic-gate 70477c478bd9Sstevel@tonic-gate /* 70487c478bd9Sstevel@tonic-gate * Since yacc is based on reading from a (FILE *) whereas what we get from 70497c478bd9Sstevel@tonic-gate * the command line is in argv format, we need to convert when the user 70507c478bd9Sstevel@tonic-gate * gives us commands directly from the command line. That is done here by 70517c478bd9Sstevel@tonic-gate * concatenating the argv list into a space-separated string, writing it 70527c478bd9Sstevel@tonic-gate * to a temp file, and rewinding the file so yyin can be set to it. Then 70537c478bd9Sstevel@tonic-gate * we call read_input(), and only once, since prompting about whether to 70547c478bd9Sstevel@tonic-gate * continue or quit would make no sense in this context. 70557c478bd9Sstevel@tonic-gate */ 70567c478bd9Sstevel@tonic-gate 70577c478bd9Sstevel@tonic-gate static int 70587c478bd9Sstevel@tonic-gate one_command_at_a_time(int argc, char *argv[]) 70597c478bd9Sstevel@tonic-gate { 70607c478bd9Sstevel@tonic-gate char *command; 70617c478bd9Sstevel@tonic-gate size_t len = 2; /* terminal \n\0 */ 70627c478bd9Sstevel@tonic-gate int i, err; 70637c478bd9Sstevel@tonic-gate 70647c478bd9Sstevel@tonic-gate for (i = 0; i < argc; i++) 70657c478bd9Sstevel@tonic-gate len += strlen(argv[i]) + 1; 70667c478bd9Sstevel@tonic-gate if ((command = malloc(len)) == NULL) { 7067bbec428eSgjelinek zone_perror(execname, Z_NOMEM, B_TRUE); 70687c478bd9Sstevel@tonic-gate return (Z_ERR); 70697c478bd9Sstevel@tonic-gate } 70707c478bd9Sstevel@tonic-gate (void) strlcpy(command, argv[0], len); 70717c478bd9Sstevel@tonic-gate for (i = 1; i < argc; i++) { 70727c478bd9Sstevel@tonic-gate (void) strlcat(command, " ", len); 70737c478bd9Sstevel@tonic-gate (void) strlcat(command, argv[i], len); 70747c478bd9Sstevel@tonic-gate } 70757c478bd9Sstevel@tonic-gate (void) strlcat(command, "\n", len); 70767c478bd9Sstevel@tonic-gate err = string_to_yyin(command); 70777c478bd9Sstevel@tonic-gate free(command); 70787c478bd9Sstevel@tonic-gate if (err != Z_OK) 70797c478bd9Sstevel@tonic-gate return (err); 70807c478bd9Sstevel@tonic-gate while (!feof(yyin)) 70817c478bd9Sstevel@tonic-gate yyparse(); 70827c478bd9Sstevel@tonic-gate return (cleanup()); 70837c478bd9Sstevel@tonic-gate } 70847c478bd9Sstevel@tonic-gate 70857c478bd9Sstevel@tonic-gate static char * 70867c478bd9Sstevel@tonic-gate get_execbasename(char *execfullname) 70877c478bd9Sstevel@tonic-gate { 70887c478bd9Sstevel@tonic-gate char *last_slash, *execbasename; 70897c478bd9Sstevel@tonic-gate 70907c478bd9Sstevel@tonic-gate /* guard against '/' at end of command invocation */ 70917c478bd9Sstevel@tonic-gate for (;;) { 70927c478bd9Sstevel@tonic-gate last_slash = strrchr(execfullname, '/'); 70937c478bd9Sstevel@tonic-gate if (last_slash == NULL) { 70947c478bd9Sstevel@tonic-gate execbasename = execfullname; 70957c478bd9Sstevel@tonic-gate break; 70967c478bd9Sstevel@tonic-gate } else { 70977c478bd9Sstevel@tonic-gate execbasename = last_slash + 1; 70987c478bd9Sstevel@tonic-gate if (*execbasename == '\0') { 70997c478bd9Sstevel@tonic-gate *last_slash = '\0'; 71007c478bd9Sstevel@tonic-gate continue; 71017c478bd9Sstevel@tonic-gate } 71027c478bd9Sstevel@tonic-gate break; 71037c478bd9Sstevel@tonic-gate } 71047c478bd9Sstevel@tonic-gate } 71057c478bd9Sstevel@tonic-gate return (execbasename); 71067c478bd9Sstevel@tonic-gate } 71077c478bd9Sstevel@tonic-gate 71087c478bd9Sstevel@tonic-gate int 71097c478bd9Sstevel@tonic-gate main(int argc, char *argv[]) 71107c478bd9Sstevel@tonic-gate { 71117c478bd9Sstevel@tonic-gate int err, arg; 7112555afedfScarlsonj struct stat st; 71137c478bd9Sstevel@tonic-gate 71147c478bd9Sstevel@tonic-gate /* This must be before anything goes to stdout. */ 71157c478bd9Sstevel@tonic-gate setbuf(stdout, NULL); 71167c478bd9Sstevel@tonic-gate 7117bbec428eSgjelinek saw_error = B_FALSE; 7118bbec428eSgjelinek cmd_file_mode = B_FALSE; 71197c478bd9Sstevel@tonic-gate execname = get_execbasename(argv[0]); 71207c478bd9Sstevel@tonic-gate 71217c478bd9Sstevel@tonic-gate (void) setlocale(LC_ALL, ""); 71227c478bd9Sstevel@tonic-gate (void) textdomain(TEXT_DOMAIN); 71237c478bd9Sstevel@tonic-gate 71247c478bd9Sstevel@tonic-gate if (getzoneid() != GLOBAL_ZONEID) { 71257c478bd9Sstevel@tonic-gate zerr(gettext("%s can only be run from the global zone."), 71267c478bd9Sstevel@tonic-gate execname); 71277c478bd9Sstevel@tonic-gate exit(Z_ERR); 71287c478bd9Sstevel@tonic-gate } 71297c478bd9Sstevel@tonic-gate 71307c478bd9Sstevel@tonic-gate if (argc < 2) { 7131bbec428eSgjelinek usage(B_FALSE, HELP_USAGE | HELP_SUBCMDS); 71327c478bd9Sstevel@tonic-gate exit(Z_USAGE); 71337c478bd9Sstevel@tonic-gate } 71347c478bd9Sstevel@tonic-gate if (strcmp(argv[1], cmd_to_str(CMD_HELP)) == 0) { 71357c478bd9Sstevel@tonic-gate (void) one_command_at_a_time(argc - 1, &(argv[1])); 71367c478bd9Sstevel@tonic-gate exit(Z_OK); 71377c478bd9Sstevel@tonic-gate } 71387c478bd9Sstevel@tonic-gate 7139555afedfScarlsonj while ((arg = getopt(argc, argv, "?f:R:z:")) != EOF) { 71407c478bd9Sstevel@tonic-gate switch (arg) { 71417c478bd9Sstevel@tonic-gate case '?': 71427c478bd9Sstevel@tonic-gate if (optopt == '?') 7143bbec428eSgjelinek usage(B_TRUE, HELP_USAGE | HELP_SUBCMDS); 71447c478bd9Sstevel@tonic-gate else 7145bbec428eSgjelinek usage(B_FALSE, HELP_USAGE); 71467c478bd9Sstevel@tonic-gate exit(Z_USAGE); 71477c478bd9Sstevel@tonic-gate /* NOTREACHED */ 71487c478bd9Sstevel@tonic-gate case 'f': 71497c478bd9Sstevel@tonic-gate cmd_file_name = optarg; 7150bbec428eSgjelinek cmd_file_mode = B_TRUE; 71517c478bd9Sstevel@tonic-gate break; 7152555afedfScarlsonj case 'R': 7153555afedfScarlsonj if (*optarg != '/') { 7154555afedfScarlsonj zerr(gettext("root path must be absolute: %s"), 7155555afedfScarlsonj optarg); 7156555afedfScarlsonj exit(Z_USAGE); 7157555afedfScarlsonj } 7158555afedfScarlsonj if (stat(optarg, &st) == -1 || !S_ISDIR(st.st_mode)) { 7159555afedfScarlsonj zerr(gettext( 7160555afedfScarlsonj "root path must be a directory: %s"), 7161555afedfScarlsonj optarg); 7162555afedfScarlsonj exit(Z_USAGE); 7163555afedfScarlsonj } 7164555afedfScarlsonj zonecfg_set_root(optarg); 7165555afedfScarlsonj break; 71667c478bd9Sstevel@tonic-gate case 'z': 71670209230bSgjelinek if (strcmp(optarg, GLOBAL_ZONENAME) == 0) { 7168bbec428eSgjelinek global_zone = B_TRUE; 71690209230bSgjelinek } else if (zonecfg_validate_zonename(optarg) != Z_OK) { 7170bbec428eSgjelinek zone_perror(optarg, Z_BOGUS_ZONE_NAME, B_TRUE); 7171bbec428eSgjelinek usage(B_FALSE, HELP_SYNTAX); 7172087719fdSdp exit(Z_USAGE); 7173087719fdSdp } 7174087719fdSdp (void) strlcpy(zone, optarg, sizeof (zone)); 7175087719fdSdp (void) strlcpy(revert_zone, optarg, sizeof (zone)); 71767c478bd9Sstevel@tonic-gate break; 71777c478bd9Sstevel@tonic-gate default: 7178bbec428eSgjelinek usage(B_FALSE, HELP_USAGE); 71797c478bd9Sstevel@tonic-gate exit(Z_USAGE); 71807c478bd9Sstevel@tonic-gate } 71817c478bd9Sstevel@tonic-gate } 71827c478bd9Sstevel@tonic-gate 7183087719fdSdp if (optind > argc || strcmp(zone, "") == 0) { 7184bbec428eSgjelinek usage(B_FALSE, HELP_USAGE); 71857c478bd9Sstevel@tonic-gate exit(Z_USAGE); 71867c478bd9Sstevel@tonic-gate } 71877c478bd9Sstevel@tonic-gate 7188087719fdSdp if ((err = zonecfg_access(zone, W_OK)) == Z_OK) { 7189bbec428eSgjelinek read_only_mode = B_FALSE; 7190087719fdSdp } else if (err == Z_ACCES) { 7191bbec428eSgjelinek read_only_mode = B_TRUE; 71927c478bd9Sstevel@tonic-gate /* skip this message in one-off from command line mode */ 71937c478bd9Sstevel@tonic-gate if (optind == argc) 71947c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("WARNING: you do not " 71957c478bd9Sstevel@tonic-gate "have write access to this zone's configuration " 71967c478bd9Sstevel@tonic-gate "file;\ngoing into read-only mode.\n")); 7197087719fdSdp } else { 7198087719fdSdp fprintf(stderr, "%s: Could not access zone configuration " 7199087719fdSdp "store: %s\n", execname, zonecfg_strerror(err)); 7200087719fdSdp exit(Z_ERR); 72017c478bd9Sstevel@tonic-gate } 72027c478bd9Sstevel@tonic-gate 72037c478bd9Sstevel@tonic-gate if ((handle = zonecfg_init_handle()) == NULL) { 7204bbec428eSgjelinek zone_perror(execname, Z_NOMEM, B_TRUE); 72057c478bd9Sstevel@tonic-gate exit(Z_ERR); 72067c478bd9Sstevel@tonic-gate } 72077c478bd9Sstevel@tonic-gate 72087c478bd9Sstevel@tonic-gate /* 72097c478bd9Sstevel@tonic-gate * This may get set back to FALSE again in cmd_file() if cmd_file_name 72107c478bd9Sstevel@tonic-gate * is a "real" file as opposed to "-" (i.e. meaning use stdin). 72117c478bd9Sstevel@tonic-gate */ 72127c478bd9Sstevel@tonic-gate if (isatty(STDIN_FILENO)) 7213bbec428eSgjelinek ok_to_prompt = B_TRUE; 72147c478bd9Sstevel@tonic-gate if ((gl = new_GetLine(MAX_LINE_LEN, MAX_CMD_HIST)) == NULL) 72157c478bd9Sstevel@tonic-gate exit(Z_ERR); 72167c478bd9Sstevel@tonic-gate if (gl_customize_completion(gl, NULL, cmd_cpl_fn) != 0) 72177c478bd9Sstevel@tonic-gate exit(Z_ERR); 72187c478bd9Sstevel@tonic-gate (void) sigset(SIGINT, SIG_IGN); 72197c478bd9Sstevel@tonic-gate if (optind == argc) { 72207c478bd9Sstevel@tonic-gate if (!cmd_file_mode) 72217c478bd9Sstevel@tonic-gate err = do_interactive(); 72227c478bd9Sstevel@tonic-gate else 72237c478bd9Sstevel@tonic-gate err = cmd_file(cmd_file_name); 72247c478bd9Sstevel@tonic-gate } else { 72257c478bd9Sstevel@tonic-gate err = one_command_at_a_time(argc - optind, &(argv[optind])); 72267c478bd9Sstevel@tonic-gate } 72277c478bd9Sstevel@tonic-gate zonecfg_fini_handle(handle); 72289acbbeafSnn35248 if (brand != NULL) 72299acbbeafSnn35248 brand_close(brand); 72307c478bd9Sstevel@tonic-gate (void) del_GetLine(gl); 72317c478bd9Sstevel@tonic-gate return (err); 72327c478bd9Sstevel@tonic-gate } 7233