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. 24*f93d2c19SAlexander Eremin * Copyright 2014 Nexenta Systems, Inc. All rights reserved. 257c478bd9Sstevel@tonic-gate */ 267c478bd9Sstevel@tonic-gate 277c478bd9Sstevel@tonic-gate /* 287c478bd9Sstevel@tonic-gate * zonecfg is a lex/yacc based command interpreter used to manage zone 297c478bd9Sstevel@tonic-gate * configurations. The lexer (see zonecfg_lex.l) builds up tokens, which 307c478bd9Sstevel@tonic-gate * the grammar (see zonecfg_grammar.y) builds up into commands, some of 317c478bd9Sstevel@tonic-gate * which takes resources and/or properties as arguments. See the block 327c478bd9Sstevel@tonic-gate * comments near the end of zonecfg_grammar.y for how the data structures 337c478bd9Sstevel@tonic-gate * which keep track of these resources and properties are built up. 347c478bd9Sstevel@tonic-gate * 357c478bd9Sstevel@tonic-gate * The resource/property data structures are inserted into a command 367c478bd9Sstevel@tonic-gate * structure (see zonecfg.h), which also keeps track of command names, 377c478bd9Sstevel@tonic-gate * miscellaneous arguments, and function handlers. The grammar selects 387c478bd9Sstevel@tonic-gate * the appropriate function handler, each of which takes a pointer to a 397c478bd9Sstevel@tonic-gate * command structure as its sole argument, and invokes it. The grammar 407c478bd9Sstevel@tonic-gate * itself is "entered" (a la the Matrix) by yyparse(), which is called 417c478bd9Sstevel@tonic-gate * from read_input(), our main driving function. That in turn is called 427c478bd9Sstevel@tonic-gate * by one of do_interactive(), cmd_file() or one_command_at_a_time(), each 437c478bd9Sstevel@tonic-gate * of which is called from main() depending on how the program was invoked. 447c478bd9Sstevel@tonic-gate * 457c478bd9Sstevel@tonic-gate * The rest of this module consists of the various function handlers and 467c478bd9Sstevel@tonic-gate * their helper functions. Some of these functions, particularly the 477c478bd9Sstevel@tonic-gate * X_to_str() functions, which maps command, resource and property numbers 487c478bd9Sstevel@tonic-gate * to strings, are used quite liberally, as doing so results in a better 497c478bd9Sstevel@tonic-gate * program w/rt I18N, reducing the need for translation notes. 507c478bd9Sstevel@tonic-gate */ 517c478bd9Sstevel@tonic-gate 527c478bd9Sstevel@tonic-gate #include <sys/mntent.h> 537c478bd9Sstevel@tonic-gate #include <sys/varargs.h> 547c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h> 557c478bd9Sstevel@tonic-gate 567c478bd9Sstevel@tonic-gate #include <errno.h> 579acbbeafSnn35248 #include <fcntl.h> 587c478bd9Sstevel@tonic-gate #include <strings.h> 597c478bd9Sstevel@tonic-gate #include <unistd.h> 607c478bd9Sstevel@tonic-gate #include <ctype.h> 617c478bd9Sstevel@tonic-gate #include <stdlib.h> 627c478bd9Sstevel@tonic-gate #include <assert.h> 637c478bd9Sstevel@tonic-gate #include <sys/stat.h> 647c478bd9Sstevel@tonic-gate #include <zone.h> 657c478bd9Sstevel@tonic-gate #include <arpa/inet.h> 667c478bd9Sstevel@tonic-gate #include <netdb.h> 677c478bd9Sstevel@tonic-gate #include <locale.h> 687c478bd9Sstevel@tonic-gate #include <libintl.h> 697c478bd9Sstevel@tonic-gate #include <alloca.h> 707c478bd9Sstevel@tonic-gate #include <signal.h> 719acbbeafSnn35248 #include <wait.h> 727c478bd9Sstevel@tonic-gate #include <libtecla.h> 73fa9e4066Sahrens #include <libzfs.h> 749acbbeafSnn35248 #include <sys/brand.h> 759acbbeafSnn35248 #include <libbrand.h> 765679c89fSjv227347 #include <sys/systeminfo.h> 77c9f134eaSjv227347 #include <libdladm.h> 78c9f134eaSjv227347 #include <libinetutil.h> 79cb8a054bSGlenn Faden #include <pwd.h> 80550b6e40SSowmini Varadhan #include <inet/ip.h> 817c478bd9Sstevel@tonic-gate 827c478bd9Sstevel@tonic-gate #include <libzonecfg.h> 837c478bd9Sstevel@tonic-gate #include "zonecfg.h" 847c478bd9Sstevel@tonic-gate 857c478bd9Sstevel@tonic-gate #if !defined(TEXT_DOMAIN) /* should be defined by cc -D */ 867c478bd9Sstevel@tonic-gate #define TEXT_DOMAIN "SYS_TEST" /* Use this only if it wasn't */ 877c478bd9Sstevel@tonic-gate #endif 887c478bd9Sstevel@tonic-gate 897c478bd9Sstevel@tonic-gate #define PAGER "/usr/bin/more" 909acbbeafSnn35248 #define EXEC_PREFIX "exec " 919acbbeafSnn35248 #define EXEC_LEN (strlen(EXEC_PREFIX)) 927c478bd9Sstevel@tonic-gate 937c478bd9Sstevel@tonic-gate struct help { 947c478bd9Sstevel@tonic-gate uint_t cmd_num; 957c478bd9Sstevel@tonic-gate char *cmd_name; 967c478bd9Sstevel@tonic-gate uint_t flags; 977c478bd9Sstevel@tonic-gate char *short_usage; 987c478bd9Sstevel@tonic-gate }; 997c478bd9Sstevel@tonic-gate 1007c478bd9Sstevel@tonic-gate extern int yyparse(void); 1017c478bd9Sstevel@tonic-gate extern int lex_lineno; 1027c478bd9Sstevel@tonic-gate 1037c478bd9Sstevel@tonic-gate #define MAX_LINE_LEN 1024 1047c478bd9Sstevel@tonic-gate #define MAX_CMD_HIST 1024 1059acbbeafSnn35248 #define MAX_CMD_LEN 1024 1067c478bd9Sstevel@tonic-gate 1070209230bSgjelinek #define ONE_MB 1048576 1080209230bSgjelinek 1097c478bd9Sstevel@tonic-gate /* 1107c478bd9Sstevel@tonic-gate * Each SHELP_ should be a simple string. 1117c478bd9Sstevel@tonic-gate */ 1127c478bd9Sstevel@tonic-gate 1137c478bd9Sstevel@tonic-gate #define SHELP_ADD "add <resource-type>\n\t(global scope)\n" \ 1147c478bd9Sstevel@tonic-gate "add <property-name> <property-value>\n\t(resource scope)" 1157c478bd9Sstevel@tonic-gate #define SHELP_CANCEL "cancel" 1160209230bSgjelinek #define SHELP_CLEAR "clear <property-name>" 1177c478bd9Sstevel@tonic-gate #define SHELP_COMMIT "commit" 118ee519a1fSgjelinek #define SHELP_CREATE "create [-F] [ -a <path> | -b | -t <template> ]" 1197c478bd9Sstevel@tonic-gate #define SHELP_DELETE "delete [-F]" 1207c478bd9Sstevel@tonic-gate #define SHELP_END "end" 1217c478bd9Sstevel@tonic-gate #define SHELP_EXIT "exit [-F]" 1227c478bd9Sstevel@tonic-gate #define SHELP_EXPORT "export [-f output-file]" 1237c478bd9Sstevel@tonic-gate #define SHELP_HELP "help [commands] [syntax] [usage] [<command-name>]" 1247c478bd9Sstevel@tonic-gate #define SHELP_INFO "info [<resource-type> [property-name=property-value]*]" 1250209230bSgjelinek #define SHELP_REMOVE "remove [-F] <resource-type> " \ 1260209230bSgjelinek "[ <property-name>=<property-value> ]*\n" \ 1270209230bSgjelinek "\t(global scope)\n" \ 1280209230bSgjelinek "remove <property-name> <property-value>\n" \ 1290209230bSgjelinek "\t(resource scope)" 1307c478bd9Sstevel@tonic-gate #define SHELP_REVERT "revert [-F]" 1317c478bd9Sstevel@tonic-gate #define SHELP_SELECT "select <resource-type> { <property-name>=" \ 1327c478bd9Sstevel@tonic-gate "<property-value> }" 1337c478bd9Sstevel@tonic-gate #define SHELP_SET "set <property-name>=<property-value>" 1347c478bd9Sstevel@tonic-gate #define SHELP_VERIFY "verify" 1357c478bd9Sstevel@tonic-gate 1367c478bd9Sstevel@tonic-gate static struct help helptab[] = { 1377c478bd9Sstevel@tonic-gate { CMD_ADD, "add", HELP_RES_PROPS, SHELP_ADD, }, 1387c478bd9Sstevel@tonic-gate { CMD_CANCEL, "cancel", 0, SHELP_CANCEL, }, 1390209230bSgjelinek { CMD_CLEAR, "clear", HELP_PROPS, SHELP_CLEAR, }, 1407c478bd9Sstevel@tonic-gate { CMD_COMMIT, "commit", 0, SHELP_COMMIT, }, 1417c478bd9Sstevel@tonic-gate { CMD_CREATE, "create", 0, SHELP_CREATE, }, 1427c478bd9Sstevel@tonic-gate { CMD_DELETE, "delete", 0, SHELP_DELETE, }, 1437c478bd9Sstevel@tonic-gate { CMD_END, "end", 0, SHELP_END, }, 1447c478bd9Sstevel@tonic-gate { CMD_EXIT, "exit", 0, SHELP_EXIT, }, 1457c478bd9Sstevel@tonic-gate { CMD_EXPORT, "export", 0, SHELP_EXPORT, }, 1467c478bd9Sstevel@tonic-gate { CMD_HELP, "help", 0, SHELP_HELP }, 1477c478bd9Sstevel@tonic-gate { CMD_INFO, "info", HELP_RES_PROPS, SHELP_INFO, }, 1487c478bd9Sstevel@tonic-gate { CMD_REMOVE, "remove", HELP_RES_PROPS, SHELP_REMOVE, }, 1497c478bd9Sstevel@tonic-gate { CMD_REVERT, "revert", 0, SHELP_REVERT, }, 1507c478bd9Sstevel@tonic-gate { CMD_SELECT, "select", HELP_RES_PROPS, SHELP_SELECT, }, 1517c478bd9Sstevel@tonic-gate { CMD_SET, "set", HELP_PROPS, SHELP_SET, }, 1527c478bd9Sstevel@tonic-gate { CMD_VERIFY, "verify", 0, SHELP_VERIFY, }, 1537c478bd9Sstevel@tonic-gate { 0 }, 1547c478bd9Sstevel@tonic-gate }; 1557c478bd9Sstevel@tonic-gate 1567c478bd9Sstevel@tonic-gate #define MAX_RT_STRLEN 16 1577c478bd9Sstevel@tonic-gate 1587c478bd9Sstevel@tonic-gate /* These *must* match the order of the RT_ define's from zonecfg.h */ 159c94c1ef0Sjv227347 char *res_types[] = { 1607c478bd9Sstevel@tonic-gate "unknown", 161087719fdSdp "zonename", 1627c478bd9Sstevel@tonic-gate "zonepath", 1637c478bd9Sstevel@tonic-gate "autoboot", 1647c478bd9Sstevel@tonic-gate "pool", 1657c478bd9Sstevel@tonic-gate "fs", 1667c478bd9Sstevel@tonic-gate "net", 1677c478bd9Sstevel@tonic-gate "device", 1687c478bd9Sstevel@tonic-gate "rctl", 1697c478bd9Sstevel@tonic-gate "attr", 170fa9e4066Sahrens "dataset", 171ffbafc53Scomay "limitpriv", 1723f2f09c1Sdp "bootargs", 1739acbbeafSnn35248 "brand", 1740209230bSgjelinek "dedicated-cpu", 1750209230bSgjelinek "capped-memory", 1760209230bSgjelinek ALIAS_MAXLWPS, 1770209230bSgjelinek ALIAS_MAXSHMMEM, 1780209230bSgjelinek ALIAS_MAXSHMIDS, 1790209230bSgjelinek ALIAS_MAXMSGIDS, 1800209230bSgjelinek ALIAS_MAXSEMIDS, 1810209230bSgjelinek ALIAS_SHARES, 1820209230bSgjelinek "scheduling-class", 183f4b3ec61Sdh155122 "ip-type", 184c97ad5cdSakolb "capped-cpu", 1855679c89fSjv227347 "hostid", 186cb8a054bSGlenn Faden "admin", 1870fbb751dSJohn Levon "fs-allowed", 188ff19e029SMenno Lageman ALIAS_MAXPROCS, 1897c478bd9Sstevel@tonic-gate NULL 1907c478bd9Sstevel@tonic-gate }; 1917c478bd9Sstevel@tonic-gate 1927c478bd9Sstevel@tonic-gate /* These *must* match the order of the PT_ define's from zonecfg.h */ 193c94c1ef0Sjv227347 char *prop_types[] = { 1947c478bd9Sstevel@tonic-gate "unknown", 195087719fdSdp "zonename", 1967c478bd9Sstevel@tonic-gate "zonepath", 1977c478bd9Sstevel@tonic-gate "autoboot", 1987c478bd9Sstevel@tonic-gate "pool", 1997c478bd9Sstevel@tonic-gate "dir", 2007c478bd9Sstevel@tonic-gate "special", 2017c478bd9Sstevel@tonic-gate "type", 2027c478bd9Sstevel@tonic-gate "options", 2037c478bd9Sstevel@tonic-gate "address", 2047c478bd9Sstevel@tonic-gate "physical", 2057c478bd9Sstevel@tonic-gate "name", 2067c478bd9Sstevel@tonic-gate "value", 2077c478bd9Sstevel@tonic-gate "match", 2087c478bd9Sstevel@tonic-gate "priv", 2097c478bd9Sstevel@tonic-gate "limit", 2107c478bd9Sstevel@tonic-gate "action", 2117c478bd9Sstevel@tonic-gate "raw", 212ffbafc53Scomay "limitpriv", 2133f2f09c1Sdp "bootargs", 2149acbbeafSnn35248 "brand", 2150209230bSgjelinek "ncpus", 2160209230bSgjelinek "importance", 2170209230bSgjelinek "swap", 2180209230bSgjelinek "locked", 2190209230bSgjelinek ALIAS_SHARES, 2200209230bSgjelinek ALIAS_MAXLWPS, 2210209230bSgjelinek ALIAS_MAXSHMMEM, 2220209230bSgjelinek ALIAS_MAXSHMIDS, 2230209230bSgjelinek ALIAS_MAXMSGIDS, 2240209230bSgjelinek ALIAS_MAXSEMIDS, 2250209230bSgjelinek ALIAS_MAXLOCKEDMEM, 2260209230bSgjelinek ALIAS_MAXSWAP, 2270209230bSgjelinek "scheduling-class", 228f4b3ec61Sdh155122 "ip-type", 229de860bd9Sgfaden "defrouter", 2305679c89fSjv227347 "hostid", 231cb8a054bSGlenn Faden "user", 232cb8a054bSGlenn Faden "auths", 2330fbb751dSJohn Levon "fs-allowed", 234ff19e029SMenno Lageman ALIAS_MAXPROCS, 235550b6e40SSowmini Varadhan "allowed-address", 2367c478bd9Sstevel@tonic-gate NULL 2377c478bd9Sstevel@tonic-gate }; 2387c478bd9Sstevel@tonic-gate 239ffbafc53Scomay /* These *must* match the order of the PROP_VAL_ define's from zonecfg.h */ 2407c478bd9Sstevel@tonic-gate static char *prop_val_types[] = { 2417c478bd9Sstevel@tonic-gate "simple", 2427c478bd9Sstevel@tonic-gate "complex", 2437c478bd9Sstevel@tonic-gate "list", 2447c478bd9Sstevel@tonic-gate }; 2457c478bd9Sstevel@tonic-gate 2467c478bd9Sstevel@tonic-gate /* 2477c478bd9Sstevel@tonic-gate * The various _cmds[] lists below are for command tab-completion. 2487c478bd9Sstevel@tonic-gate */ 2497c478bd9Sstevel@tonic-gate 2507c478bd9Sstevel@tonic-gate /* 2517c478bd9Sstevel@tonic-gate * remove has a space afterwards because it has qualifiers; the other commands 2520209230bSgjelinek * that have qualifiers (add, select, etc.) don't need a space here because 2537c478bd9Sstevel@tonic-gate * they have their own _cmds[] lists below. 2547c478bd9Sstevel@tonic-gate */ 2557c478bd9Sstevel@tonic-gate static const char *global_scope_cmds[] = { 2567c478bd9Sstevel@tonic-gate "add", 2570209230bSgjelinek "clear", 2587c478bd9Sstevel@tonic-gate "commit", 2597c478bd9Sstevel@tonic-gate "create", 2607c478bd9Sstevel@tonic-gate "delete", 2617c478bd9Sstevel@tonic-gate "exit", 2627c478bd9Sstevel@tonic-gate "export", 2637c478bd9Sstevel@tonic-gate "help", 2647c478bd9Sstevel@tonic-gate "info", 2657c478bd9Sstevel@tonic-gate "remove ", 2667c478bd9Sstevel@tonic-gate "revert", 2677c478bd9Sstevel@tonic-gate "select", 2687c478bd9Sstevel@tonic-gate "set", 2697c478bd9Sstevel@tonic-gate "verify", 2707c478bd9Sstevel@tonic-gate NULL 2717c478bd9Sstevel@tonic-gate }; 2727c478bd9Sstevel@tonic-gate 2737c478bd9Sstevel@tonic-gate static const char *add_cmds[] = { 2747c478bd9Sstevel@tonic-gate "add fs", 2757c478bd9Sstevel@tonic-gate "add net", 2767c478bd9Sstevel@tonic-gate "add device", 2777c478bd9Sstevel@tonic-gate "add rctl", 2787c478bd9Sstevel@tonic-gate "add attr", 279fa9e4066Sahrens "add dataset", 2800209230bSgjelinek "add dedicated-cpu", 281c97ad5cdSakolb "add capped-cpu", 2820209230bSgjelinek "add capped-memory", 283cb8a054bSGlenn Faden "add admin", 2840209230bSgjelinek NULL 2850209230bSgjelinek }; 2860209230bSgjelinek 2870209230bSgjelinek static const char *clear_cmds[] = { 2880209230bSgjelinek "clear autoboot", 2890209230bSgjelinek "clear pool", 2900209230bSgjelinek "clear limitpriv", 2910209230bSgjelinek "clear bootargs", 2920209230bSgjelinek "clear scheduling-class", 293f4b3ec61Sdh155122 "clear ip-type", 2940209230bSgjelinek "clear " ALIAS_MAXLWPS, 2950209230bSgjelinek "clear " ALIAS_MAXSHMMEM, 2960209230bSgjelinek "clear " ALIAS_MAXSHMIDS, 2970209230bSgjelinek "clear " ALIAS_MAXMSGIDS, 2980209230bSgjelinek "clear " ALIAS_MAXSEMIDS, 2990209230bSgjelinek "clear " ALIAS_SHARES, 300ff19e029SMenno Lageman "clear " ALIAS_MAXPROCS, 3017c478bd9Sstevel@tonic-gate NULL 3027c478bd9Sstevel@tonic-gate }; 3037c478bd9Sstevel@tonic-gate 3049e7542f4Sdp static const char *remove_cmds[] = { 3059e7542f4Sdp "remove fs ", 3069e7542f4Sdp "remove net ", 3079e7542f4Sdp "remove device ", 3089e7542f4Sdp "remove rctl ", 3099e7542f4Sdp "remove attr ", 3109e7542f4Sdp "remove dataset ", 3110209230bSgjelinek "remove dedicated-cpu ", 312c97ad5cdSakolb "remove capped-cpu ", 3130209230bSgjelinek "remove capped-memory ", 314cb8a054bSGlenn Faden "remove admin ", 3159e7542f4Sdp NULL 3169e7542f4Sdp }; 3179e7542f4Sdp 3187c478bd9Sstevel@tonic-gate static const char *select_cmds[] = { 3197c478bd9Sstevel@tonic-gate "select fs ", 3207c478bd9Sstevel@tonic-gate "select net ", 3217c478bd9Sstevel@tonic-gate "select device ", 3227c478bd9Sstevel@tonic-gate "select rctl ", 3237c478bd9Sstevel@tonic-gate "select attr ", 324fa9e4066Sahrens "select dataset ", 3250209230bSgjelinek "select dedicated-cpu", 326c97ad5cdSakolb "select capped-cpu", 3270209230bSgjelinek "select capped-memory", 328cb8a054bSGlenn Faden "select admin", 3297c478bd9Sstevel@tonic-gate NULL 3307c478bd9Sstevel@tonic-gate }; 3317c478bd9Sstevel@tonic-gate 3327c478bd9Sstevel@tonic-gate static const char *set_cmds[] = { 333087719fdSdp "set zonename=", 334087719fdSdp "set zonepath=", 3359acbbeafSnn35248 "set brand=", 336087719fdSdp "set autoboot=", 337087719fdSdp "set pool=", 338ffbafc53Scomay "set limitpriv=", 3393f2f09c1Sdp "set bootargs=", 3400209230bSgjelinek "set scheduling-class=", 341f4b3ec61Sdh155122 "set ip-type=", 3420209230bSgjelinek "set " ALIAS_MAXLWPS "=", 3430209230bSgjelinek "set " ALIAS_MAXSHMMEM "=", 3440209230bSgjelinek "set " ALIAS_MAXSHMIDS "=", 3450209230bSgjelinek "set " ALIAS_MAXMSGIDS "=", 3460209230bSgjelinek "set " ALIAS_MAXSEMIDS "=", 3470209230bSgjelinek "set " ALIAS_SHARES "=", 3485679c89fSjv227347 "set hostid=", 3490fbb751dSJohn Levon "set fs-allowed=", 350ff19e029SMenno Lageman "set " ALIAS_MAXPROCS "=", 3517c478bd9Sstevel@tonic-gate NULL 3527c478bd9Sstevel@tonic-gate }; 3537c478bd9Sstevel@tonic-gate 3549e7542f4Sdp static const char *info_cmds[] = { 3559e7542f4Sdp "info fs ", 3569e7542f4Sdp "info net ", 3579e7542f4Sdp "info device ", 3589e7542f4Sdp "info rctl ", 3599e7542f4Sdp "info attr ", 3609e7542f4Sdp "info dataset ", 3610209230bSgjelinek "info capped-memory", 3620209230bSgjelinek "info dedicated-cpu", 363c97ad5cdSakolb "info capped-cpu", 3649e7542f4Sdp "info zonename", 3659e7542f4Sdp "info zonepath", 3669e7542f4Sdp "info autoboot", 3679e7542f4Sdp "info pool", 3689e7542f4Sdp "info limitpriv", 3699e7542f4Sdp "info bootargs", 3700209230bSgjelinek "info brand", 3710209230bSgjelinek "info scheduling-class", 372f4b3ec61Sdh155122 "info ip-type", 3730209230bSgjelinek "info max-lwps", 3740209230bSgjelinek "info max-shm-memory", 3750209230bSgjelinek "info max-shm-ids", 3760209230bSgjelinek "info max-msg-ids", 3770209230bSgjelinek "info max-sem-ids", 3780209230bSgjelinek "info cpu-shares", 3795679c89fSjv227347 "info hostid", 380cb8a054bSGlenn Faden "info admin", 3810fbb751dSJohn Levon "info fs-allowed", 382ff19e029SMenno Lageman "info max-processes", 3839e7542f4Sdp NULL 3849e7542f4Sdp }; 3859e7542f4Sdp 3867c478bd9Sstevel@tonic-gate static const char *fs_res_scope_cmds[] = { 3877c478bd9Sstevel@tonic-gate "add options ", 3887c478bd9Sstevel@tonic-gate "cancel", 3897c478bd9Sstevel@tonic-gate "end", 3907c478bd9Sstevel@tonic-gate "exit", 3917c478bd9Sstevel@tonic-gate "help", 3927c478bd9Sstevel@tonic-gate "info", 393ffbafc53Scomay "remove options ", 3947c478bd9Sstevel@tonic-gate "set dir=", 3957c478bd9Sstevel@tonic-gate "set raw=", 3967c478bd9Sstevel@tonic-gate "set special=", 3977c478bd9Sstevel@tonic-gate "set type=", 3980209230bSgjelinek "clear raw", 3997c478bd9Sstevel@tonic-gate NULL 4007c478bd9Sstevel@tonic-gate }; 4017c478bd9Sstevel@tonic-gate 4027c478bd9Sstevel@tonic-gate static const char *net_res_scope_cmds[] = { 4037c478bd9Sstevel@tonic-gate "cancel", 4047c478bd9Sstevel@tonic-gate "end", 4057c478bd9Sstevel@tonic-gate "exit", 4067c478bd9Sstevel@tonic-gate "help", 4077c478bd9Sstevel@tonic-gate "info", 4087c478bd9Sstevel@tonic-gate "set address=", 4097c478bd9Sstevel@tonic-gate "set physical=", 4101b3281c0SGerald Jelinek "set defrouter=", 4117c478bd9Sstevel@tonic-gate NULL 4127c478bd9Sstevel@tonic-gate }; 4137c478bd9Sstevel@tonic-gate 4147c478bd9Sstevel@tonic-gate static const char *device_res_scope_cmds[] = { 4157c478bd9Sstevel@tonic-gate "cancel", 4167c478bd9Sstevel@tonic-gate "end", 4177c478bd9Sstevel@tonic-gate "exit", 4187c478bd9Sstevel@tonic-gate "help", 4197c478bd9Sstevel@tonic-gate "info", 4207c478bd9Sstevel@tonic-gate "set match=", 4217c478bd9Sstevel@tonic-gate NULL 4227c478bd9Sstevel@tonic-gate }; 4237c478bd9Sstevel@tonic-gate 4247c478bd9Sstevel@tonic-gate static const char *attr_res_scope_cmds[] = { 4257c478bd9Sstevel@tonic-gate "cancel", 4267c478bd9Sstevel@tonic-gate "end", 4277c478bd9Sstevel@tonic-gate "exit", 4287c478bd9Sstevel@tonic-gate "help", 4297c478bd9Sstevel@tonic-gate "info", 4307c478bd9Sstevel@tonic-gate "set name=", 4317c478bd9Sstevel@tonic-gate "set type=", 4327c478bd9Sstevel@tonic-gate "set value=", 4337c478bd9Sstevel@tonic-gate NULL 4347c478bd9Sstevel@tonic-gate }; 4357c478bd9Sstevel@tonic-gate 4367c478bd9Sstevel@tonic-gate static const char *rctl_res_scope_cmds[] = { 4377c478bd9Sstevel@tonic-gate "add value ", 4387c478bd9Sstevel@tonic-gate "cancel", 4397c478bd9Sstevel@tonic-gate "end", 4407c478bd9Sstevel@tonic-gate "exit", 4417c478bd9Sstevel@tonic-gate "help", 4427c478bd9Sstevel@tonic-gate "info", 443ffbafc53Scomay "remove value ", 4447c478bd9Sstevel@tonic-gate "set name=", 4457c478bd9Sstevel@tonic-gate NULL 4467c478bd9Sstevel@tonic-gate }; 4477c478bd9Sstevel@tonic-gate 448fa9e4066Sahrens static const char *dataset_res_scope_cmds[] = { 449fa9e4066Sahrens "cancel", 450fa9e4066Sahrens "end", 451fa9e4066Sahrens "exit", 452fa9e4066Sahrens "help", 453fa9e4066Sahrens "info", 454fa9e4066Sahrens "set name=", 455fa9e4066Sahrens NULL 456fa9e4066Sahrens }; 457fa9e4066Sahrens 4580209230bSgjelinek static const char *pset_res_scope_cmds[] = { 4590209230bSgjelinek "cancel", 4600209230bSgjelinek "end", 4610209230bSgjelinek "exit", 4620209230bSgjelinek "help", 4630209230bSgjelinek "info", 4640209230bSgjelinek "set ncpus=", 4650209230bSgjelinek "set importance=", 4660209230bSgjelinek "clear importance", 4670209230bSgjelinek NULL 4680209230bSgjelinek }; 4690209230bSgjelinek 470c97ad5cdSakolb static const char *pcap_res_scope_cmds[] = { 471c97ad5cdSakolb "cancel", 472c97ad5cdSakolb "end", 473c97ad5cdSakolb "exit", 474c97ad5cdSakolb "help", 475c97ad5cdSakolb "info", 476c97ad5cdSakolb "set ncpus=", 477c97ad5cdSakolb NULL 478c97ad5cdSakolb }; 479c97ad5cdSakolb 4800209230bSgjelinek static const char *mcap_res_scope_cmds[] = { 4810209230bSgjelinek "cancel", 4820209230bSgjelinek "end", 4830209230bSgjelinek "exit", 4840209230bSgjelinek "help", 4850209230bSgjelinek "info", 4860209230bSgjelinek "set physical=", 4870209230bSgjelinek "set swap=", 4880209230bSgjelinek "set locked=", 4890209230bSgjelinek "clear physical", 4900209230bSgjelinek "clear swap", 4910209230bSgjelinek "clear locked", 4920209230bSgjelinek NULL 4930209230bSgjelinek }; 4940209230bSgjelinek 495cb8a054bSGlenn Faden static const char *admin_res_scope_cmds[] = { 496cb8a054bSGlenn Faden "cancel", 497cb8a054bSGlenn Faden "end", 498cb8a054bSGlenn Faden "exit", 499cb8a054bSGlenn Faden "help", 500cb8a054bSGlenn Faden "info", 501cb8a054bSGlenn Faden "set user=", 502cb8a054bSGlenn Faden "set auths=", 503cb8a054bSGlenn Faden NULL 504cb8a054bSGlenn Faden }; 505cb8a054bSGlenn Faden 506550b6e40SSowmini Varadhan struct xif { 507550b6e40SSowmini Varadhan struct xif *xif_next; 508550b6e40SSowmini Varadhan char xif_name[LIFNAMSIZ]; 509550b6e40SSowmini Varadhan boolean_t xif_has_address; 510550b6e40SSowmini Varadhan boolean_t xif_has_defrouter; 511550b6e40SSowmini Varadhan }; 512550b6e40SSowmini Varadhan 5137c478bd9Sstevel@tonic-gate /* Global variables */ 5147c478bd9Sstevel@tonic-gate 515550b6e40SSowmini Varadhan /* list of network interfaces specified for exclusive IP zone */ 516550b6e40SSowmini Varadhan struct xif *xif; 517550b6e40SSowmini Varadhan 5187c478bd9Sstevel@tonic-gate /* set early in main(), never modified thereafter, used all over the place */ 5197c478bd9Sstevel@tonic-gate static char *execname; 5207c478bd9Sstevel@tonic-gate 5217c478bd9Sstevel@tonic-gate /* set in main(), used all over the place */ 5227c478bd9Sstevel@tonic-gate static zone_dochandle_t handle; 5237c478bd9Sstevel@tonic-gate 5247c478bd9Sstevel@tonic-gate /* used all over the place */ 525087719fdSdp static char zone[ZONENAME_MAX]; 526087719fdSdp static char revert_zone[ZONENAME_MAX]; 5277c478bd9Sstevel@tonic-gate 5289acbbeafSnn35248 /* global brand operations */ 529123807fbSedp static brand_handle_t brand; 5309acbbeafSnn35248 5317c478bd9Sstevel@tonic-gate /* set in modifying functions, checked in read_input() */ 532bbec428eSgjelinek static boolean_t need_to_commit = B_FALSE; 533bbec428eSgjelinek boolean_t saw_error; 5347c478bd9Sstevel@tonic-gate 5357c478bd9Sstevel@tonic-gate /* set in yacc parser, checked in read_input() */ 536bbec428eSgjelinek boolean_t newline_terminated; 5377c478bd9Sstevel@tonic-gate 5387c478bd9Sstevel@tonic-gate /* set in main(), checked in lex error handler */ 539bbec428eSgjelinek boolean_t cmd_file_mode; 5407c478bd9Sstevel@tonic-gate 5417c478bd9Sstevel@tonic-gate /* set in exit_func(), checked in read_input() */ 542bbec428eSgjelinek static boolean_t time_to_exit = B_FALSE, force_exit = B_FALSE; 5437c478bd9Sstevel@tonic-gate 5447c478bd9Sstevel@tonic-gate /* used in short_usage() and zerr() */ 5457c478bd9Sstevel@tonic-gate static char *cmd_file_name = NULL; 5467c478bd9Sstevel@tonic-gate 5477c478bd9Sstevel@tonic-gate /* checked in read_input() and other places */ 548bbec428eSgjelinek static boolean_t ok_to_prompt = B_FALSE; 5497c478bd9Sstevel@tonic-gate 5507c478bd9Sstevel@tonic-gate /* set and checked in initialize() */ 551bbec428eSgjelinek static boolean_t got_handle = B_FALSE; 5527c478bd9Sstevel@tonic-gate 5537c478bd9Sstevel@tonic-gate /* initialized in do_interactive(), checked in initialize() */ 554bbec428eSgjelinek static boolean_t interactive_mode; 5557c478bd9Sstevel@tonic-gate 5560209230bSgjelinek /* set if configuring the global zone */ 557bbec428eSgjelinek static boolean_t global_zone = B_FALSE; 5580209230bSgjelinek 5597c478bd9Sstevel@tonic-gate /* set in main(), checked in multiple places */ 560bbec428eSgjelinek static boolean_t read_only_mode; 5617c478bd9Sstevel@tonic-gate 562bbec428eSgjelinek /* scope is outer/global or inner/resource */ 563bbec428eSgjelinek static boolean_t global_scope = B_TRUE; 5647c478bd9Sstevel@tonic-gate static int resource_scope; /* should be in the RT_ list from zonecfg.h */ 5657c478bd9Sstevel@tonic-gate static int end_op = -1; /* operation on end is either add or modify */ 5667c478bd9Sstevel@tonic-gate 5677c478bd9Sstevel@tonic-gate int num_prop_vals; /* for grammar */ 5687c478bd9Sstevel@tonic-gate 5697c478bd9Sstevel@tonic-gate /* 5707c478bd9Sstevel@tonic-gate * These are for keeping track of resources as they are specified as part of 5717c478bd9Sstevel@tonic-gate * the multi-step process. They should be initialized by add_resource() or 5727c478bd9Sstevel@tonic-gate * select_func() and filled in by add_property() or set_func(). 5737c478bd9Sstevel@tonic-gate */ 5747c478bd9Sstevel@tonic-gate static struct zone_fstab old_fstab, in_progress_fstab; 5757c478bd9Sstevel@tonic-gate static struct zone_nwiftab old_nwiftab, in_progress_nwiftab; 5767c478bd9Sstevel@tonic-gate static struct zone_devtab old_devtab, in_progress_devtab; 5777c478bd9Sstevel@tonic-gate static struct zone_rctltab old_rctltab, in_progress_rctltab; 5787c478bd9Sstevel@tonic-gate static struct zone_attrtab old_attrtab, in_progress_attrtab; 579fa9e4066Sahrens static struct zone_dstab old_dstab, in_progress_dstab; 5800209230bSgjelinek static struct zone_psettab old_psettab, in_progress_psettab; 5810209230bSgjelinek static struct zone_mcaptab old_mcaptab, in_progress_mcaptab; 582cb8a054bSGlenn Faden static struct zone_admintab old_admintab, in_progress_admintab; 5837c478bd9Sstevel@tonic-gate 5847c478bd9Sstevel@tonic-gate static GetLine *gl; /* The gl_get_line() resource object */ 5857c478bd9Sstevel@tonic-gate 5860209230bSgjelinek static void bytes_to_units(char *str, char *buf, int bufsize); 5870209230bSgjelinek 5887c478bd9Sstevel@tonic-gate /* Functions begin here */ 5897c478bd9Sstevel@tonic-gate 590bbec428eSgjelinek static boolean_t 5917c478bd9Sstevel@tonic-gate initial_match(const char *line1, const char *line2, int word_end) 5927c478bd9Sstevel@tonic-gate { 5937c478bd9Sstevel@tonic-gate if (word_end <= 0) 594bbec428eSgjelinek return (B_TRUE); 5957c478bd9Sstevel@tonic-gate return (strncmp(line1, line2, word_end) == 0); 5967c478bd9Sstevel@tonic-gate } 5977c478bd9Sstevel@tonic-gate 5987c478bd9Sstevel@tonic-gate static int 5997c478bd9Sstevel@tonic-gate add_stuff(WordCompletion *cpl, const char *line1, const char **list, 6007c478bd9Sstevel@tonic-gate int word_end) 6017c478bd9Sstevel@tonic-gate { 6027c478bd9Sstevel@tonic-gate int i, err; 6037c478bd9Sstevel@tonic-gate 6047c478bd9Sstevel@tonic-gate for (i = 0; list[i] != NULL; i++) { 6057c478bd9Sstevel@tonic-gate if (initial_match(line1, list[i], word_end)) { 6067c478bd9Sstevel@tonic-gate err = cpl_add_completion(cpl, line1, 0, word_end, 6077c478bd9Sstevel@tonic-gate list[i] + word_end, "", ""); 6087c478bd9Sstevel@tonic-gate if (err != 0) 6097c478bd9Sstevel@tonic-gate return (err); 6107c478bd9Sstevel@tonic-gate } 6117c478bd9Sstevel@tonic-gate } 6127c478bd9Sstevel@tonic-gate return (0); 6137c478bd9Sstevel@tonic-gate } 6147c478bd9Sstevel@tonic-gate 6157c478bd9Sstevel@tonic-gate static 6167c478bd9Sstevel@tonic-gate /* ARGSUSED */ 6177c478bd9Sstevel@tonic-gate CPL_MATCH_FN(cmd_cpl_fn) 6187c478bd9Sstevel@tonic-gate { 6197c478bd9Sstevel@tonic-gate if (global_scope) { 6207c478bd9Sstevel@tonic-gate /* 6217c478bd9Sstevel@tonic-gate * The MAX/MIN tests below are to make sure we have at least 6227c478bd9Sstevel@tonic-gate * enough characters to distinguish from other prefixes (MAX) 6237c478bd9Sstevel@tonic-gate * but only check MIN(what we have, what we're checking). 6247c478bd9Sstevel@tonic-gate */ 6257c478bd9Sstevel@tonic-gate if (strncmp(line, "add ", MAX(MIN(word_end, 4), 1)) == 0) 6267c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, add_cmds, word_end)); 6270209230bSgjelinek if (strncmp(line, "clear ", MAX(MIN(word_end, 6), 2)) == 0) 6280209230bSgjelinek return (add_stuff(cpl, line, clear_cmds, word_end)); 6297c478bd9Sstevel@tonic-gate if (strncmp(line, "select ", MAX(MIN(word_end, 7), 3)) == 0) 6307c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, select_cmds, word_end)); 6317c478bd9Sstevel@tonic-gate if (strncmp(line, "set ", MAX(MIN(word_end, 4), 3)) == 0) 6327c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, set_cmds, word_end)); 6339e7542f4Sdp if (strncmp(line, "remove ", MAX(MIN(word_end, 7), 1)) == 0) 6349e7542f4Sdp return (add_stuff(cpl, line, remove_cmds, word_end)); 6359e7542f4Sdp if (strncmp(line, "info ", MAX(MIN(word_end, 5), 1)) == 0) 6369e7542f4Sdp return (add_stuff(cpl, line, info_cmds, word_end)); 6377c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, global_scope_cmds, word_end)); 6387c478bd9Sstevel@tonic-gate } 6397c478bd9Sstevel@tonic-gate switch (resource_scope) { 6407c478bd9Sstevel@tonic-gate case RT_FS: 6417c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, fs_res_scope_cmds, word_end)); 6427c478bd9Sstevel@tonic-gate case RT_NET: 6437c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, net_res_scope_cmds, word_end)); 6447c478bd9Sstevel@tonic-gate case RT_DEVICE: 6457c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, device_res_scope_cmds, word_end)); 6467c478bd9Sstevel@tonic-gate case RT_RCTL: 6477c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, rctl_res_scope_cmds, word_end)); 6487c478bd9Sstevel@tonic-gate case RT_ATTR: 6497c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, attr_res_scope_cmds, word_end)); 650fa9e4066Sahrens case RT_DATASET: 651fa9e4066Sahrens return (add_stuff(cpl, line, dataset_res_scope_cmds, word_end)); 6520209230bSgjelinek case RT_DCPU: 6530209230bSgjelinek return (add_stuff(cpl, line, pset_res_scope_cmds, word_end)); 654c97ad5cdSakolb case RT_PCAP: 655c97ad5cdSakolb return (add_stuff(cpl, line, pcap_res_scope_cmds, word_end)); 6560209230bSgjelinek case RT_MCAP: 6570209230bSgjelinek return (add_stuff(cpl, line, mcap_res_scope_cmds, word_end)); 658cb8a054bSGlenn Faden case RT_ADMIN: 659cb8a054bSGlenn Faden return (add_stuff(cpl, line, admin_res_scope_cmds, word_end)); 6607c478bd9Sstevel@tonic-gate } 6617c478bd9Sstevel@tonic-gate return (0); 6627c478bd9Sstevel@tonic-gate } 6637c478bd9Sstevel@tonic-gate 6647c478bd9Sstevel@tonic-gate /* 6657c478bd9Sstevel@tonic-gate * For the main CMD_func() functions below, several of them call getopt() 6667c478bd9Sstevel@tonic-gate * then check optind against argc to make sure an extra parameter was not 6677c478bd9Sstevel@tonic-gate * passed in. The reason this is not caught in the grammar is that the 6687c478bd9Sstevel@tonic-gate * grammar just checks for a miscellaneous TOKEN, which is *expected* to 6697c478bd9Sstevel@tonic-gate * be "-F" (for example), but could be anything. So (for example) this 6707c478bd9Sstevel@tonic-gate * check will prevent "create bogus". 6717c478bd9Sstevel@tonic-gate */ 6727c478bd9Sstevel@tonic-gate 6737c478bd9Sstevel@tonic-gate cmd_t * 6747c478bd9Sstevel@tonic-gate alloc_cmd(void) 6757c478bd9Sstevel@tonic-gate { 6767c478bd9Sstevel@tonic-gate return (calloc(1, sizeof (cmd_t))); 6777c478bd9Sstevel@tonic-gate } 6787c478bd9Sstevel@tonic-gate 6797c478bd9Sstevel@tonic-gate void 6807c478bd9Sstevel@tonic-gate free_cmd(cmd_t *cmd) 6817c478bd9Sstevel@tonic-gate { 6827c478bd9Sstevel@tonic-gate int i; 6837c478bd9Sstevel@tonic-gate 6847c478bd9Sstevel@tonic-gate for (i = 0; i < MAX_EQ_PROP_PAIRS; i++) 6857c478bd9Sstevel@tonic-gate if (cmd->cmd_property_ptr[i] != NULL) { 6867c478bd9Sstevel@tonic-gate property_value_ptr_t pp = cmd->cmd_property_ptr[i]; 6877c478bd9Sstevel@tonic-gate 6887c478bd9Sstevel@tonic-gate switch (pp->pv_type) { 6897c478bd9Sstevel@tonic-gate case PROP_VAL_SIMPLE: 6907c478bd9Sstevel@tonic-gate free(pp->pv_simple); 6917c478bd9Sstevel@tonic-gate break; 6927c478bd9Sstevel@tonic-gate case PROP_VAL_COMPLEX: 6937c478bd9Sstevel@tonic-gate free_complex(pp->pv_complex); 6947c478bd9Sstevel@tonic-gate break; 6957c478bd9Sstevel@tonic-gate case PROP_VAL_LIST: 6967c478bd9Sstevel@tonic-gate free_list(pp->pv_list); 6977c478bd9Sstevel@tonic-gate break; 6987c478bd9Sstevel@tonic-gate } 6997c478bd9Sstevel@tonic-gate } 7007c478bd9Sstevel@tonic-gate for (i = 0; i < cmd->cmd_argc; i++) 7017c478bd9Sstevel@tonic-gate free(cmd->cmd_argv[i]); 7027c478bd9Sstevel@tonic-gate free(cmd); 7037c478bd9Sstevel@tonic-gate } 7047c478bd9Sstevel@tonic-gate 7057c478bd9Sstevel@tonic-gate complex_property_ptr_t 7067c478bd9Sstevel@tonic-gate alloc_complex(void) 7077c478bd9Sstevel@tonic-gate { 7087c478bd9Sstevel@tonic-gate return (calloc(1, sizeof (complex_property_t))); 7097c478bd9Sstevel@tonic-gate } 7107c478bd9Sstevel@tonic-gate 7117c478bd9Sstevel@tonic-gate void 7127c478bd9Sstevel@tonic-gate free_complex(complex_property_ptr_t complex) 7137c478bd9Sstevel@tonic-gate { 7147c478bd9Sstevel@tonic-gate if (complex == NULL) 7157c478bd9Sstevel@tonic-gate return; 7167c478bd9Sstevel@tonic-gate free_complex(complex->cp_next); 7177c478bd9Sstevel@tonic-gate if (complex->cp_value != NULL) 7187c478bd9Sstevel@tonic-gate free(complex->cp_value); 7197c478bd9Sstevel@tonic-gate free(complex); 7207c478bd9Sstevel@tonic-gate } 7217c478bd9Sstevel@tonic-gate 7227c478bd9Sstevel@tonic-gate list_property_ptr_t 7237c478bd9Sstevel@tonic-gate alloc_list(void) 7247c478bd9Sstevel@tonic-gate { 7257c478bd9Sstevel@tonic-gate return (calloc(1, sizeof (list_property_t))); 7267c478bd9Sstevel@tonic-gate } 7277c478bd9Sstevel@tonic-gate 7287c478bd9Sstevel@tonic-gate void 7297c478bd9Sstevel@tonic-gate free_list(list_property_ptr_t list) 7307c478bd9Sstevel@tonic-gate { 7317c478bd9Sstevel@tonic-gate if (list == NULL) 7327c478bd9Sstevel@tonic-gate return; 7337c478bd9Sstevel@tonic-gate if (list->lp_simple != NULL) 7347c478bd9Sstevel@tonic-gate free(list->lp_simple); 7357c478bd9Sstevel@tonic-gate free_complex(list->lp_complex); 7367c478bd9Sstevel@tonic-gate free_list(list->lp_next); 7377c478bd9Sstevel@tonic-gate free(list); 7387c478bd9Sstevel@tonic-gate } 7397c478bd9Sstevel@tonic-gate 7407c478bd9Sstevel@tonic-gate void 7417c478bd9Sstevel@tonic-gate free_outer_list(list_property_ptr_t list) 7427c478bd9Sstevel@tonic-gate { 7437c478bd9Sstevel@tonic-gate if (list == NULL) 7447c478bd9Sstevel@tonic-gate return; 7457c478bd9Sstevel@tonic-gate free_outer_list(list->lp_next); 7467c478bd9Sstevel@tonic-gate free(list); 7477c478bd9Sstevel@tonic-gate } 7487c478bd9Sstevel@tonic-gate 7497c478bd9Sstevel@tonic-gate static struct zone_rctlvaltab * 7507c478bd9Sstevel@tonic-gate alloc_rctlvaltab(void) 7517c478bd9Sstevel@tonic-gate { 7527c478bd9Sstevel@tonic-gate return (calloc(1, sizeof (struct zone_rctlvaltab))); 7537c478bd9Sstevel@tonic-gate } 7547c478bd9Sstevel@tonic-gate 7557c478bd9Sstevel@tonic-gate static char * 7567c478bd9Sstevel@tonic-gate rt_to_str(int res_type) 7577c478bd9Sstevel@tonic-gate { 7587c478bd9Sstevel@tonic-gate assert(res_type >= RT_MIN && res_type <= RT_MAX); 7597c478bd9Sstevel@tonic-gate return (res_types[res_type]); 7607c478bd9Sstevel@tonic-gate } 7617c478bd9Sstevel@tonic-gate 7627c478bd9Sstevel@tonic-gate static char * 7637c478bd9Sstevel@tonic-gate pt_to_str(int prop_type) 7647c478bd9Sstevel@tonic-gate { 7657c478bd9Sstevel@tonic-gate assert(prop_type >= PT_MIN && prop_type <= PT_MAX); 7667c478bd9Sstevel@tonic-gate return (prop_types[prop_type]); 7677c478bd9Sstevel@tonic-gate } 7687c478bd9Sstevel@tonic-gate 7697c478bd9Sstevel@tonic-gate static char * 7707c478bd9Sstevel@tonic-gate pvt_to_str(int pv_type) 7717c478bd9Sstevel@tonic-gate { 7727c478bd9Sstevel@tonic-gate assert(pv_type >= PROP_VAL_MIN && pv_type <= PROP_VAL_MAX); 7737c478bd9Sstevel@tonic-gate return (prop_val_types[pv_type]); 7747c478bd9Sstevel@tonic-gate } 7757c478bd9Sstevel@tonic-gate 7767c478bd9Sstevel@tonic-gate static char * 7777c478bd9Sstevel@tonic-gate cmd_to_str(int cmd_num) 7787c478bd9Sstevel@tonic-gate { 7797c478bd9Sstevel@tonic-gate assert(cmd_num >= CMD_MIN && cmd_num <= CMD_MAX); 7807c478bd9Sstevel@tonic-gate return (helptab[cmd_num].cmd_name); 7817c478bd9Sstevel@tonic-gate } 7827c478bd9Sstevel@tonic-gate 7833042b8b5Sbatschul /* PRINTFLIKE1 */ 7843042b8b5Sbatschul static void 7853042b8b5Sbatschul zerr(const char *fmt, ...) 7863042b8b5Sbatschul { 7873042b8b5Sbatschul va_list alist; 7883042b8b5Sbatschul static int last_lineno; 7893042b8b5Sbatschul 7903042b8b5Sbatschul /* lex_lineno has already been incremented in the lexer; compensate */ 7913042b8b5Sbatschul if (cmd_file_mode && lex_lineno > last_lineno) { 7923042b8b5Sbatschul if (strcmp(cmd_file_name, "-") == 0) 7933042b8b5Sbatschul (void) fprintf(stderr, gettext("On line %d:\n"), 7943042b8b5Sbatschul lex_lineno - 1); 7953042b8b5Sbatschul else 7963042b8b5Sbatschul (void) fprintf(stderr, gettext("On line %d of %s:\n"), 7973042b8b5Sbatschul lex_lineno - 1, cmd_file_name); 7983042b8b5Sbatschul last_lineno = lex_lineno; 7993042b8b5Sbatschul } 8003042b8b5Sbatschul va_start(alist, fmt); 8013042b8b5Sbatschul (void) vfprintf(stderr, fmt, alist); 8023042b8b5Sbatschul (void) fprintf(stderr, "\n"); 8033042b8b5Sbatschul va_end(alist); 8043042b8b5Sbatschul } 8053042b8b5Sbatschul 8067c478bd9Sstevel@tonic-gate /* 8077c478bd9Sstevel@tonic-gate * This is a separate function rather than a set of define's because of the 8087c478bd9Sstevel@tonic-gate * gettext() wrapping. 8097c478bd9Sstevel@tonic-gate */ 8107c478bd9Sstevel@tonic-gate 8117c478bd9Sstevel@tonic-gate /* 8127c478bd9Sstevel@tonic-gate * TRANSLATION_NOTE 8137c478bd9Sstevel@tonic-gate * Each string below should have \t follow \n whenever needed; the 8147c478bd9Sstevel@tonic-gate * initial \t and the terminal \n will be provided by the calling function. 8157c478bd9Sstevel@tonic-gate */ 8167c478bd9Sstevel@tonic-gate 8177c478bd9Sstevel@tonic-gate static char * 8187c478bd9Sstevel@tonic-gate long_help(int cmd_num) 8197c478bd9Sstevel@tonic-gate { 8207c478bd9Sstevel@tonic-gate static char line[1024]; /* arbitrary large amount */ 8217c478bd9Sstevel@tonic-gate 8227c478bd9Sstevel@tonic-gate assert(cmd_num >= CMD_MIN && cmd_num <= CMD_MAX); 8237c478bd9Sstevel@tonic-gate switch (cmd_num) { 8247c478bd9Sstevel@tonic-gate case CMD_HELP: 8257c478bd9Sstevel@tonic-gate return (gettext("Prints help message.")); 8267c478bd9Sstevel@tonic-gate case CMD_CREATE: 8277c478bd9Sstevel@tonic-gate (void) snprintf(line, sizeof (line), 8287c478bd9Sstevel@tonic-gate gettext("Creates a configuration for the " 8297c478bd9Sstevel@tonic-gate "specified zone. %s should be\n\tused to " 8307c478bd9Sstevel@tonic-gate "begin configuring a new zone. If overwriting an " 8317c478bd9Sstevel@tonic-gate "existing\n\tconfiguration, the -F flag can be " 8327c478bd9Sstevel@tonic-gate "used to force the action. If\n\t-t template is " 8337c478bd9Sstevel@tonic-gate "given, creates a configuration identical to the\n" 8347c478bd9Sstevel@tonic-gate "\tspecified template, except that the zone name " 8359e518655Sgjelinek "is changed from\n\ttemplate to zonename. '%s -a' " 8369e518655Sgjelinek "creates a configuration from a\n\tdetached " 8379e518655Sgjelinek "zonepath. '%s -b' results in a blank " 8389e518655Sgjelinek "configuration.\n\t'%s' with no arguments applies " 8399e518655Sgjelinek "the Sun default settings."), 8407c478bd9Sstevel@tonic-gate cmd_to_str(CMD_CREATE), cmd_to_str(CMD_CREATE), 8419e518655Sgjelinek cmd_to_str(CMD_CREATE), cmd_to_str(CMD_CREATE)); 8427c478bd9Sstevel@tonic-gate return (line); 8437c478bd9Sstevel@tonic-gate case CMD_EXIT: 8447c478bd9Sstevel@tonic-gate return (gettext("Exits the program. The -F flag can " 8457c478bd9Sstevel@tonic-gate "be used to force the action.")); 8467c478bd9Sstevel@tonic-gate case CMD_EXPORT: 8477c478bd9Sstevel@tonic-gate return (gettext("Prints configuration to standard " 8487c478bd9Sstevel@tonic-gate "output, or to output-file if\n\tspecified, in " 8497c478bd9Sstevel@tonic-gate "a form suitable for use in a command-file.")); 8507c478bd9Sstevel@tonic-gate case CMD_ADD: 8517c478bd9Sstevel@tonic-gate return (gettext("Add specified resource to " 8527c478bd9Sstevel@tonic-gate "configuration.")); 8537c478bd9Sstevel@tonic-gate case CMD_DELETE: 8547c478bd9Sstevel@tonic-gate return (gettext("Deletes the specified zone. The -F " 8557c478bd9Sstevel@tonic-gate "flag can be used to force the\n\taction.")); 8567c478bd9Sstevel@tonic-gate case CMD_REMOVE: 8577c478bd9Sstevel@tonic-gate return (gettext("Remove specified resource from " 8580209230bSgjelinek "configuration. The -F flag can be used\n\tto " 8590209230bSgjelinek "force the action.")); 8607c478bd9Sstevel@tonic-gate case CMD_SELECT: 8617c478bd9Sstevel@tonic-gate (void) snprintf(line, sizeof (line), 8627c478bd9Sstevel@tonic-gate gettext("Selects a resource to modify. " 8637c478bd9Sstevel@tonic-gate "Resource modification is completed\n\twith the " 8647c478bd9Sstevel@tonic-gate "command \"%s\". The property name/value pairs " 8657c478bd9Sstevel@tonic-gate "must uniquely\n\tidentify a resource. Note that " 8667c478bd9Sstevel@tonic-gate "the curly braces ('{', '}') mean one\n\tor more " 8677c478bd9Sstevel@tonic-gate "of whatever is between them."), 8687c478bd9Sstevel@tonic-gate cmd_to_str(CMD_END)); 8697c478bd9Sstevel@tonic-gate return (line); 8707c478bd9Sstevel@tonic-gate case CMD_SET: 8717c478bd9Sstevel@tonic-gate return (gettext("Sets property values.")); 8720209230bSgjelinek case CMD_CLEAR: 8730209230bSgjelinek return (gettext("Clears property values.")); 8747c478bd9Sstevel@tonic-gate case CMD_INFO: 8757c478bd9Sstevel@tonic-gate return (gettext("Displays information about the " 8767c478bd9Sstevel@tonic-gate "current configuration. If resource\n\ttype is " 8777c478bd9Sstevel@tonic-gate "specified, displays only information about " 8787c478bd9Sstevel@tonic-gate "resources of\n\tthe relevant type. If resource " 8797c478bd9Sstevel@tonic-gate "id is specified, displays only\n\tinformation " 8807c478bd9Sstevel@tonic-gate "about that resource.")); 8817c478bd9Sstevel@tonic-gate case CMD_VERIFY: 8827c478bd9Sstevel@tonic-gate return (gettext("Verifies current configuration " 8837c478bd9Sstevel@tonic-gate "for correctness (some resource types\n\thave " 8847c478bd9Sstevel@tonic-gate "required properties).")); 8857c478bd9Sstevel@tonic-gate case CMD_COMMIT: 8867c478bd9Sstevel@tonic-gate (void) snprintf(line, sizeof (line), 8877c478bd9Sstevel@tonic-gate gettext("Commits current configuration. " 8887c478bd9Sstevel@tonic-gate "Configuration must be committed to\n\tbe used by " 8897c478bd9Sstevel@tonic-gate "%s. Until the configuration is committed, " 8907c478bd9Sstevel@tonic-gate "changes \n\tcan be removed with the %s " 8917c478bd9Sstevel@tonic-gate "command. This operation is\n\tattempted " 8927c478bd9Sstevel@tonic-gate "automatically upon completion of a %s " 8937c478bd9Sstevel@tonic-gate "session."), "zoneadm", cmd_to_str(CMD_REVERT), 8947c478bd9Sstevel@tonic-gate "zonecfg"); 8957c478bd9Sstevel@tonic-gate return (line); 8967c478bd9Sstevel@tonic-gate case CMD_REVERT: 8977c478bd9Sstevel@tonic-gate return (gettext("Reverts configuration back to the " 8987c478bd9Sstevel@tonic-gate "last committed state. The -F flag\n\tcan be " 8997c478bd9Sstevel@tonic-gate "used to force the action.")); 9007c478bd9Sstevel@tonic-gate case CMD_CANCEL: 9017c478bd9Sstevel@tonic-gate return (gettext("Cancels resource/property " 9027c478bd9Sstevel@tonic-gate "specification.")); 9037c478bd9Sstevel@tonic-gate case CMD_END: 9047c478bd9Sstevel@tonic-gate return (gettext("Ends resource/property " 9057c478bd9Sstevel@tonic-gate "specification.")); 9067c478bd9Sstevel@tonic-gate } 9077c478bd9Sstevel@tonic-gate /* NOTREACHED */ 9087e362f58Scomay return (NULL); 9097c478bd9Sstevel@tonic-gate } 9107c478bd9Sstevel@tonic-gate 9117c478bd9Sstevel@tonic-gate /* 9127c478bd9Sstevel@tonic-gate * Called with verbose TRUE when help is explicitly requested, FALSE for 9137c478bd9Sstevel@tonic-gate * unexpected errors. 9147c478bd9Sstevel@tonic-gate */ 9157c478bd9Sstevel@tonic-gate 9167c478bd9Sstevel@tonic-gate void 917bbec428eSgjelinek usage(boolean_t verbose, uint_t flags) 9187c478bd9Sstevel@tonic-gate { 9193042b8b5Sbatschul FILE *fp = verbose ? stdout : stderr; 9203042b8b5Sbatschul FILE *newfp; 921bbec428eSgjelinek boolean_t need_to_close = B_FALSE; 92212a8b243SSusan Kamm-Worrell char *pager, *space; 9237c478bd9Sstevel@tonic-gate int i; 9243042b8b5Sbatschul struct stat statbuf; 9257c478bd9Sstevel@tonic-gate 9267c478bd9Sstevel@tonic-gate /* don't page error output */ 9277c478bd9Sstevel@tonic-gate if (verbose && interactive_mode) { 9287c478bd9Sstevel@tonic-gate if ((pager = getenv("PAGER")) == NULL) 9297c478bd9Sstevel@tonic-gate pager = PAGER; 9303042b8b5Sbatschul 93112a8b243SSusan Kamm-Worrell space = strchr(pager, ' '); 93212a8b243SSusan Kamm-Worrell if (space) 93312a8b243SSusan Kamm-Worrell *space = '\0'; 9343042b8b5Sbatschul if (stat(pager, &statbuf) == 0) { 93512a8b243SSusan Kamm-Worrell if (space) 93612a8b243SSusan Kamm-Worrell *space = ' '; 9377c478bd9Sstevel@tonic-gate if ((newfp = popen(pager, "w")) != NULL) { 938bbec428eSgjelinek need_to_close = B_TRUE; 9397c478bd9Sstevel@tonic-gate fp = newfp; 9407c478bd9Sstevel@tonic-gate } 9413042b8b5Sbatschul } else { 9423042b8b5Sbatschul zerr(gettext("PAGER %s does not exist (%s)."), 9433042b8b5Sbatschul pager, strerror(errno)); 9447c478bd9Sstevel@tonic-gate } 9453042b8b5Sbatschul } 9463042b8b5Sbatschul 9477c478bd9Sstevel@tonic-gate if (flags & HELP_META) { 9487c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("More help is available for the " 9497c478bd9Sstevel@tonic-gate "following:\n")); 9507c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\n\tcommands ('%s commands')\n", 9517c478bd9Sstevel@tonic-gate cmd_to_str(CMD_HELP)); 9527c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\tsyntax ('%s syntax')\n", 9537c478bd9Sstevel@tonic-gate cmd_to_str(CMD_HELP)); 9547c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\tusage ('%s usage')\n\n", 9557c478bd9Sstevel@tonic-gate cmd_to_str(CMD_HELP)); 9567c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("You may also obtain help on any " 9577c478bd9Sstevel@tonic-gate "command by typing '%s <command-name>.'\n"), 9587c478bd9Sstevel@tonic-gate cmd_to_str(CMD_HELP)); 9597c478bd9Sstevel@tonic-gate } 9607c478bd9Sstevel@tonic-gate if (flags & HELP_RES_SCOPE) { 9617c478bd9Sstevel@tonic-gate switch (resource_scope) { 9627c478bd9Sstevel@tonic-gate case RT_FS: 9637c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("The '%s' resource scope is " 9647c478bd9Sstevel@tonic-gate "used to configure a file-system.\n"), 9657c478bd9Sstevel@tonic-gate rt_to_str(resource_scope)); 9667c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("Valid commands:\n")); 9677c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 9687c478bd9Sstevel@tonic-gate pt_to_str(PT_DIR), gettext("<path>")); 9697c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 9707c478bd9Sstevel@tonic-gate pt_to_str(PT_SPECIAL), gettext("<path>")); 9717c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 9727c478bd9Sstevel@tonic-gate pt_to_str(PT_RAW), gettext("<raw-device>")); 9737c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 9747c478bd9Sstevel@tonic-gate pt_to_str(PT_TYPE), gettext("<file-system type>")); 9757c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s %s\n", cmd_to_str(CMD_ADD), 9767c478bd9Sstevel@tonic-gate pt_to_str(PT_OPTIONS), 9777c478bd9Sstevel@tonic-gate gettext("<file-system options>")); 978ffbafc53Scomay (void) fprintf(fp, "\t%s %s %s\n", 979ffbafc53Scomay cmd_to_str(CMD_REMOVE), pt_to_str(PT_OPTIONS), 980ffbafc53Scomay gettext("<file-system options>")); 9817c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("Consult the file-system " 9827c478bd9Sstevel@tonic-gate "specific manual page, such as mount_ufs(1M), " 9837c478bd9Sstevel@tonic-gate "for\ndetails about file-system options. Note " 9847c478bd9Sstevel@tonic-gate "that any file-system options with an\nembedded " 9857c478bd9Sstevel@tonic-gate "'=' character must be enclosed in double quotes, " 9867c478bd9Sstevel@tonic-gate /*CSTYLED*/ 9877c478bd9Sstevel@tonic-gate "such as \"%s=5\".\n"), MNTOPT_RETRY); 9887c478bd9Sstevel@tonic-gate break; 9897c478bd9Sstevel@tonic-gate case RT_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), 997550b6e40SSowmini Varadhan pt_to_str(PT_ALLOWED_ADDRESS), 998550b6e40SSowmini Varadhan gettext("<IP-address>")); 999550b6e40SSowmini Varadhan (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 10007c478bd9Sstevel@tonic-gate pt_to_str(PT_PHYSICAL), gettext("<interface>")); 10017c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("See ifconfig(1M) for " 10027c478bd9Sstevel@tonic-gate "details of the <interface> string.\n")); 1003550b6e40SSowmini Varadhan (void) fprintf(fp, gettext("%s %s is valid " 1004550b6e40SSowmini Varadhan "if the %s property is set to %s, otherwise it " 1005de860bd9Sgfaden "must not be set.\n"), 1006f4b3ec61Sdh155122 cmd_to_str(CMD_SET), pt_to_str(PT_ADDRESS), 1007550b6e40SSowmini Varadhan pt_to_str(PT_IPTYPE), gettext("shared")); 1008550b6e40SSowmini Varadhan (void) fprintf(fp, gettext("%s %s is valid " 1009550b6e40SSowmini Varadhan "if the %s property is set to %s, otherwise it " 1010550b6e40SSowmini Varadhan "must not be set.\n"), 1011550b6e40SSowmini Varadhan cmd_to_str(CMD_SET), pt_to_str(PT_ALLOWED_ADDRESS), 1012550b6e40SSowmini Varadhan pt_to_str(PT_IPTYPE), gettext("exclusive")); 1013550b6e40SSowmini Varadhan (void) fprintf(fp, gettext("\t%s %s=%s\n%s %s " 1014550b6e40SSowmini Varadhan "is valid if the %s or %s property is set, " 1015550b6e40SSowmini Varadhan "otherwise it must not be set\n"), 1016550b6e40SSowmini Varadhan cmd_to_str(CMD_SET), 1017550b6e40SSowmini Varadhan pt_to_str(PT_DEFROUTER), gettext("<IP-address>"), 1018de860bd9Sgfaden cmd_to_str(CMD_SET), pt_to_str(PT_DEFROUTER), 1019550b6e40SSowmini Varadhan gettext(pt_to_str(PT_ADDRESS)), 1020550b6e40SSowmini Varadhan gettext(pt_to_str(PT_ALLOWED_ADDRESS))); 10217c478bd9Sstevel@tonic-gate break; 10227c478bd9Sstevel@tonic-gate case RT_DEVICE: 10237c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("The '%s' resource scope is " 10247c478bd9Sstevel@tonic-gate "used to configure a device node.\n"), 10257c478bd9Sstevel@tonic-gate rt_to_str(resource_scope)); 10267c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("Valid commands:\n")); 10277c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 10287c478bd9Sstevel@tonic-gate pt_to_str(PT_MATCH), gettext("<device-path>")); 10297c478bd9Sstevel@tonic-gate break; 10307c478bd9Sstevel@tonic-gate case RT_RCTL: 10317c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("The '%s' resource scope is " 10327c478bd9Sstevel@tonic-gate "used to configure a resource control.\n"), 10337c478bd9Sstevel@tonic-gate rt_to_str(resource_scope)); 10347c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("Valid commands:\n")); 10357c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 10367c478bd9Sstevel@tonic-gate pt_to_str(PT_NAME), gettext("<string>")); 10377c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s (%s=%s,%s=%s,%s=%s)\n", 10387c478bd9Sstevel@tonic-gate cmd_to_str(CMD_ADD), pt_to_str(PT_VALUE), 10397c478bd9Sstevel@tonic-gate pt_to_str(PT_PRIV), gettext("<priv-value>"), 10407c478bd9Sstevel@tonic-gate pt_to_str(PT_LIMIT), gettext("<number>"), 10417c478bd9Sstevel@tonic-gate pt_to_str(PT_ACTION), gettext("<action-value>")); 1042ffbafc53Scomay (void) fprintf(fp, "\t%s %s (%s=%s,%s=%s,%s=%s)\n", 1043ffbafc53Scomay cmd_to_str(CMD_REMOVE), pt_to_str(PT_VALUE), 1044ffbafc53Scomay pt_to_str(PT_PRIV), gettext("<priv-value>"), 1045ffbafc53Scomay pt_to_str(PT_LIMIT), gettext("<number>"), 1046ffbafc53Scomay pt_to_str(PT_ACTION), gettext("<action-value>")); 10477c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s\n\t%s := privileged\n" 10487c478bd9Sstevel@tonic-gate "\t%s := none | deny\n", gettext("Where"), 10497c478bd9Sstevel@tonic-gate gettext("<priv-value>"), gettext("<action-value>")); 10507c478bd9Sstevel@tonic-gate break; 10517c478bd9Sstevel@tonic-gate case RT_ATTR: 10527c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("The '%s' resource scope is " 10537c478bd9Sstevel@tonic-gate "used to configure a generic attribute.\n"), 10547c478bd9Sstevel@tonic-gate rt_to_str(resource_scope)); 10557c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("Valid commands:\n")); 10567c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 10577c478bd9Sstevel@tonic-gate pt_to_str(PT_NAME), gettext("<name>")); 10587c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=boolean\n", 10597c478bd9Sstevel@tonic-gate cmd_to_str(CMD_SET), pt_to_str(PT_TYPE)); 10607c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=true | false\n", 10617c478bd9Sstevel@tonic-gate cmd_to_str(CMD_SET), pt_to_str(PT_VALUE)); 10627c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("or\n")); 10637c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=int\n", cmd_to_str(CMD_SET), 10647c478bd9Sstevel@tonic-gate pt_to_str(PT_TYPE)); 10657c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 10667c478bd9Sstevel@tonic-gate pt_to_str(PT_VALUE), gettext("<integer>")); 10677c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("or\n")); 10687c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=string\n", 10697c478bd9Sstevel@tonic-gate cmd_to_str(CMD_SET), pt_to_str(PT_TYPE)); 10707c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 10717c478bd9Sstevel@tonic-gate pt_to_str(PT_VALUE), gettext("<string>")); 10727c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("or\n")); 10737c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=uint\n", 10747c478bd9Sstevel@tonic-gate cmd_to_str(CMD_SET), pt_to_str(PT_TYPE)); 10757c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 10767c478bd9Sstevel@tonic-gate pt_to_str(PT_VALUE), gettext("<unsigned integer>")); 10777c478bd9Sstevel@tonic-gate break; 1078fa9e4066Sahrens case RT_DATASET: 1079fa9e4066Sahrens (void) fprintf(fp, gettext("The '%s' resource scope is " 1080fa9e4066Sahrens "used to export ZFS datasets.\n"), 1081fa9e4066Sahrens rt_to_str(resource_scope)); 1082fa9e4066Sahrens (void) fprintf(fp, gettext("Valid commands:\n")); 1083fa9e4066Sahrens (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 1084fa9e4066Sahrens pt_to_str(PT_NAME), gettext("<name>")); 1085fa9e4066Sahrens break; 10860209230bSgjelinek case RT_DCPU: 10870209230bSgjelinek (void) fprintf(fp, gettext("The '%s' resource scope " 10880209230bSgjelinek "configures the 'pools' facility to dedicate\na " 10890209230bSgjelinek "subset of the system's processors to this zone " 10900209230bSgjelinek "while it is running.\n"), 10910209230bSgjelinek rt_to_str(resource_scope)); 10920209230bSgjelinek (void) fprintf(fp, gettext("Valid commands:\n")); 10930209230bSgjelinek (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 10940209230bSgjelinek pt_to_str(PT_NCPUS), 10950209230bSgjelinek gettext("<unsigned integer | range>")); 10960209230bSgjelinek (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 10970209230bSgjelinek pt_to_str(PT_IMPORTANCE), 10980209230bSgjelinek gettext("<unsigned integer>")); 10990209230bSgjelinek break; 1100c97ad5cdSakolb case RT_PCAP: 1101c97ad5cdSakolb (void) fprintf(fp, gettext("The '%s' resource scope is " 1102c97ad5cdSakolb "used to set an upper limit (a cap) on the\n" 1103c97ad5cdSakolb "percentage of CPU that can be used by this zone. " 1104c97ad5cdSakolb "A '%s' value of 1\ncorresponds to one cpu. The " 1105c97ad5cdSakolb "value can be set higher than 1, up to the total\n" 1106c97ad5cdSakolb "number of CPUs on the system. The value can " 1107c97ad5cdSakolb "also be less than 1,\nrepresenting a fraction of " 1108c97ad5cdSakolb "a cpu.\n"), 1109c97ad5cdSakolb rt_to_str(resource_scope), pt_to_str(PT_NCPUS)); 1110c97ad5cdSakolb (void) fprintf(fp, gettext("Valid commands:\n")); 1111c97ad5cdSakolb (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 1112c97ad5cdSakolb pt_to_str(PT_NCPUS), gettext("<unsigned decimal>")); 1113c97ad5cdSakolb break; 11140209230bSgjelinek case RT_MCAP: 11150209230bSgjelinek (void) fprintf(fp, gettext("The '%s' resource scope is " 11160209230bSgjelinek "used to set an upper limit (a cap) on the\n" 11170209230bSgjelinek "amount of physical memory, swap space and locked " 11180209230bSgjelinek "memory that can be used by\nthis zone.\n"), 11190209230bSgjelinek rt_to_str(resource_scope)); 11200209230bSgjelinek (void) fprintf(fp, gettext("Valid commands:\n")); 11210209230bSgjelinek (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 11220209230bSgjelinek pt_to_str(PT_PHYSICAL), 11230209230bSgjelinek gettext("<qualified unsigned decimal>")); 11240209230bSgjelinek (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 11250209230bSgjelinek pt_to_str(PT_SWAP), 11260209230bSgjelinek gettext("<qualified unsigned decimal>")); 11270209230bSgjelinek (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 11280209230bSgjelinek pt_to_str(PT_LOCKED), 11290209230bSgjelinek gettext("<qualified unsigned decimal>")); 11300209230bSgjelinek break; 1131cb8a054bSGlenn Faden case RT_ADMIN: 1132cb8a054bSGlenn Faden (void) fprintf(fp, gettext("The '%s' resource scope is " 1133cb8a054bSGlenn Faden "used to delegate specific zone management\n" 1134cb8a054bSGlenn Faden "rights to users and roles. These rights are " 1135cb8a054bSGlenn Faden "only applicable to this zone.\n"), 1136cb8a054bSGlenn Faden rt_to_str(resource_scope)); 1137cb8a054bSGlenn Faden (void) fprintf(fp, gettext("Valid commands:\n")); 1138cb8a054bSGlenn Faden (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 1139cb8a054bSGlenn Faden pt_to_str(PT_USER), 1140cb8a054bSGlenn Faden gettext("<single user or role name>")); 1141cb8a054bSGlenn Faden (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 1142cb8a054bSGlenn Faden pt_to_str(PT_AUTHS), 1143cb8a054bSGlenn Faden gettext("<comma separated list>")); 1144cb8a054bSGlenn Faden break; 11457c478bd9Sstevel@tonic-gate } 11467c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("And from any resource scope, you " 11477c478bd9Sstevel@tonic-gate "can:\n")); 11487c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t%s\n", cmd_to_str(CMD_END), 11497c478bd9Sstevel@tonic-gate gettext("(to conclude this operation)")); 11507c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t%s\n", cmd_to_str(CMD_CANCEL), 11517c478bd9Sstevel@tonic-gate gettext("(to cancel this operation)")); 11527c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t%s\n", cmd_to_str(CMD_EXIT), 11537c478bd9Sstevel@tonic-gate gettext("(to exit the zonecfg utility)")); 11547c478bd9Sstevel@tonic-gate } 11557c478bd9Sstevel@tonic-gate if (flags & HELP_USAGE) { 11567c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s:\t%s %s\n", gettext("usage"), 11577c478bd9Sstevel@tonic-gate execname, cmd_to_str(CMD_HELP)); 11587c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s -z <zone>\t\t\t(%s)\n", 11597c478bd9Sstevel@tonic-gate execname, gettext("interactive")); 11607c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s -z <zone> <command>\n", execname); 11617c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s -z <zone> -f <command-file>\n", 11627c478bd9Sstevel@tonic-gate execname); 11637c478bd9Sstevel@tonic-gate } 11647c478bd9Sstevel@tonic-gate if (flags & HELP_SUBCMDS) { 11657c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s:\n\n", gettext("Commands")); 11667c478bd9Sstevel@tonic-gate for (i = 0; i <= CMD_MAX; i++) { 11677c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s\n", helptab[i].short_usage); 11687c478bd9Sstevel@tonic-gate if (verbose) 11697c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\n\n", long_help(i)); 11707c478bd9Sstevel@tonic-gate } 11717c478bd9Sstevel@tonic-gate } 11727c478bd9Sstevel@tonic-gate if (flags & HELP_SYNTAX) { 11737c478bd9Sstevel@tonic-gate if (!verbose) 11747c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\n"); 11757c478bd9Sstevel@tonic-gate (void) fprintf(fp, "<zone> := [A-Za-z0-9][A-Za-z0-9_.-]*\n"); 11767c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("\t(except the reserved words " 11777c478bd9Sstevel@tonic-gate "'%s' and anything starting with '%s')\n"), "global", 11787c478bd9Sstevel@tonic-gate "SUNW"); 11797c478bd9Sstevel@tonic-gate (void) fprintf(fp, 11807c478bd9Sstevel@tonic-gate gettext("\tName must be less than %d characters.\n"), 11817c478bd9Sstevel@tonic-gate ZONENAME_MAX); 11827c478bd9Sstevel@tonic-gate if (verbose) 11837c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\n"); 11847c478bd9Sstevel@tonic-gate } 11857c478bd9Sstevel@tonic-gate if (flags & HELP_NETADDR) { 11867c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("\n<net-addr> :=")); 11877c478bd9Sstevel@tonic-gate (void) fprintf(fp, 11887c478bd9Sstevel@tonic-gate gettext("\t<IPv4-address>[/<IPv4-prefix-length>] |\n")); 11897c478bd9Sstevel@tonic-gate (void) fprintf(fp, 11907c478bd9Sstevel@tonic-gate gettext("\t\t<IPv6-address>/<IPv6-prefix-length> |\n")); 11917c478bd9Sstevel@tonic-gate (void) fprintf(fp, 11927c478bd9Sstevel@tonic-gate gettext("\t\t<hostname>[/<IPv4-prefix-length>]\n")); 11937c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("See inet(3SOCKET) for IPv4 and " 11947c478bd9Sstevel@tonic-gate "IPv6 address syntax.\n")); 11957c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("<IPv4-prefix-length> := [0-32]\n")); 11967c478bd9Sstevel@tonic-gate (void) fprintf(fp, 11977c478bd9Sstevel@tonic-gate gettext("<IPv6-prefix-length> := [0-128]\n")); 11987c478bd9Sstevel@tonic-gate (void) fprintf(fp, 11997c478bd9Sstevel@tonic-gate gettext("<hostname> := [A-Za-z0-9][A-Za-z0-9-.]*\n")); 12007c478bd9Sstevel@tonic-gate } 12017c478bd9Sstevel@tonic-gate if (flags & HELP_RESOURCES) { 12026e1ae2a3SGary Pennington (void) fprintf(fp, "<%s> := %s | %s | %s | %s | %s |\n\t" 1203cb8a054bSGlenn Faden "%s | %s | %s | %s | %s\n\n", 12047c478bd9Sstevel@tonic-gate gettext("resource type"), rt_to_str(RT_FS), 12056e1ae2a3SGary Pennington rt_to_str(RT_NET), rt_to_str(RT_DEVICE), 12069e7542f4Sdp rt_to_str(RT_RCTL), rt_to_str(RT_ATTR), 12070209230bSgjelinek rt_to_str(RT_DATASET), rt_to_str(RT_DCPU), 1208cb8a054bSGlenn Faden rt_to_str(RT_PCAP), rt_to_str(RT_MCAP), 1209cb8a054bSGlenn Faden rt_to_str(RT_ADMIN)); 12107c478bd9Sstevel@tonic-gate } 12117c478bd9Sstevel@tonic-gate if (flags & HELP_PROPS) { 12127c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("For resource type ... there are " 12137c478bd9Sstevel@tonic-gate "property types ...:\n")); 12147c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 1215087719fdSdp pt_to_str(PT_ZONENAME)); 1216087719fdSdp (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 12177c478bd9Sstevel@tonic-gate pt_to_str(PT_ZONEPATH)); 12187c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 12199acbbeafSnn35248 pt_to_str(PT_BRAND)); 12209acbbeafSnn35248 (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 12217c478bd9Sstevel@tonic-gate pt_to_str(PT_AUTOBOOT)); 12227c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 12233f2f09c1Sdp pt_to_str(PT_BOOTARGS)); 12243f2f09c1Sdp (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 12257c478bd9Sstevel@tonic-gate pt_to_str(PT_POOL)); 1226ffbafc53Scomay (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 1227ffbafc53Scomay pt_to_str(PT_LIMITPRIV)); 12280209230bSgjelinek (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 12290209230bSgjelinek pt_to_str(PT_SCHED)); 12300209230bSgjelinek (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 1231f4b3ec61Sdh155122 pt_to_str(PT_IPTYPE)); 1232f4b3ec61Sdh155122 (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 12335679c89fSjv227347 pt_to_str(PT_HOSTID)); 12345679c89fSjv227347 (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 12350fbb751dSJohn Levon pt_to_str(PT_FS_ALLOWED)); 12360fbb751dSJohn Levon (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 12370209230bSgjelinek pt_to_str(PT_MAXLWPS)); 12380209230bSgjelinek (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 1239ff19e029SMenno Lageman pt_to_str(PT_MAXPROCS)); 1240ff19e029SMenno Lageman (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 12410209230bSgjelinek pt_to_str(PT_MAXSHMMEM)); 12420209230bSgjelinek (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 12430209230bSgjelinek pt_to_str(PT_MAXSHMIDS)); 12440209230bSgjelinek (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 12450209230bSgjelinek pt_to_str(PT_MAXMSGIDS)); 12460209230bSgjelinek (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 12470209230bSgjelinek pt_to_str(PT_MAXSEMIDS)); 12480209230bSgjelinek (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 12490209230bSgjelinek pt_to_str(PT_SHARES)); 12506d4d1c0dSbatschul (void) fprintf(fp, "\t%s\t\t%s, %s, %s, %s, %s\n", 12516d4d1c0dSbatschul rt_to_str(RT_FS), pt_to_str(PT_DIR), 12526d4d1c0dSbatschul pt_to_str(PT_SPECIAL), pt_to_str(PT_RAW), 12536d4d1c0dSbatschul pt_to_str(PT_TYPE), pt_to_str(PT_OPTIONS)); 1254550b6e40SSowmini Varadhan (void) fprintf(fp, "\t%s\t\t%s, %s, %s|%s\n", rt_to_str(RT_NET), 1255550b6e40SSowmini Varadhan pt_to_str(PT_ADDRESS), pt_to_str(PT_ALLOWED_ADDRESS), 1256550b6e40SSowmini Varadhan pt_to_str(PT_PHYSICAL), pt_to_str(PT_DEFROUTER)); 12577c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t\t%s\n", rt_to_str(RT_DEVICE), 12587c478bd9Sstevel@tonic-gate pt_to_str(PT_MATCH)); 12597c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t\t%s, %s\n", rt_to_str(RT_RCTL), 12607c478bd9Sstevel@tonic-gate pt_to_str(PT_NAME), pt_to_str(PT_VALUE)); 12617c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t\t%s, %s, %s\n", rt_to_str(RT_ATTR), 12627c478bd9Sstevel@tonic-gate pt_to_str(PT_NAME), pt_to_str(PT_TYPE), 12637c478bd9Sstevel@tonic-gate pt_to_str(PT_VALUE)); 1264fa9e4066Sahrens (void) fprintf(fp, "\t%s\t\t%s\n", rt_to_str(RT_DATASET), 1265fa9e4066Sahrens pt_to_str(PT_NAME)); 12660209230bSgjelinek (void) fprintf(fp, "\t%s\t%s, %s\n", rt_to_str(RT_DCPU), 12670209230bSgjelinek pt_to_str(PT_NCPUS), pt_to_str(PT_IMPORTANCE)); 1268c97ad5cdSakolb (void) fprintf(fp, "\t%s\t%s\n", rt_to_str(RT_PCAP), 1269c97ad5cdSakolb pt_to_str(PT_NCPUS)); 12700209230bSgjelinek (void) fprintf(fp, "\t%s\t%s, %s, %s\n", rt_to_str(RT_MCAP), 12710209230bSgjelinek pt_to_str(PT_PHYSICAL), pt_to_str(PT_SWAP), 12720209230bSgjelinek pt_to_str(PT_LOCKED)); 1273cb8a054bSGlenn Faden (void) fprintf(fp, "\t%s\t\t%s, %s\n", rt_to_str(RT_ADMIN), 1274cb8a054bSGlenn Faden pt_to_str(PT_USER), pt_to_str(PT_AUTHS)); 12757c478bd9Sstevel@tonic-gate } 12767c478bd9Sstevel@tonic-gate if (need_to_close) 12777c478bd9Sstevel@tonic-gate (void) pclose(fp); 12787c478bd9Sstevel@tonic-gate } 12797c478bd9Sstevel@tonic-gate 12807c478bd9Sstevel@tonic-gate static void 1281bbec428eSgjelinek zone_perror(char *prefix, int err, boolean_t set_saw) 12827c478bd9Sstevel@tonic-gate { 12837c478bd9Sstevel@tonic-gate zerr("%s: %s", prefix, zonecfg_strerror(err)); 12847c478bd9Sstevel@tonic-gate if (set_saw) 1285bbec428eSgjelinek saw_error = B_TRUE; 12867c478bd9Sstevel@tonic-gate } 12877c478bd9Sstevel@tonic-gate 12887c478bd9Sstevel@tonic-gate /* 12897c478bd9Sstevel@tonic-gate * zone_perror() expects a single string, but for remove and select 12907c478bd9Sstevel@tonic-gate * we have both the command and the resource type, so this wrapper 12917c478bd9Sstevel@tonic-gate * function serves the same purpose in a slightly different way. 12927c478bd9Sstevel@tonic-gate */ 12937c478bd9Sstevel@tonic-gate 12947c478bd9Sstevel@tonic-gate static void 1295bbec428eSgjelinek z_cmd_rt_perror(int cmd_num, int res_num, int err, boolean_t set_saw) 12967c478bd9Sstevel@tonic-gate { 12977c478bd9Sstevel@tonic-gate zerr("%s %s: %s", cmd_to_str(cmd_num), rt_to_str(res_num), 12987c478bd9Sstevel@tonic-gate zonecfg_strerror(err)); 12997c478bd9Sstevel@tonic-gate if (set_saw) 1300bbec428eSgjelinek saw_error = B_TRUE; 13017c478bd9Sstevel@tonic-gate } 13027c478bd9Sstevel@tonic-gate 13037c478bd9Sstevel@tonic-gate /* returns Z_OK if successful, Z_foo from <libzonecfg.h> otherwise */ 13047c478bd9Sstevel@tonic-gate static int 1305bbec428eSgjelinek initialize(boolean_t handle_expected) 13067c478bd9Sstevel@tonic-gate { 13077c478bd9Sstevel@tonic-gate int err; 13089acbbeafSnn35248 char brandname[MAXNAMELEN]; 13097c478bd9Sstevel@tonic-gate 13107c478bd9Sstevel@tonic-gate if (zonecfg_check_handle(handle) != Z_OK) { 13117c478bd9Sstevel@tonic-gate if ((err = zonecfg_get_handle(zone, handle)) == Z_OK) { 1312bbec428eSgjelinek got_handle = B_TRUE; 13139acbbeafSnn35248 if (zonecfg_get_brand(handle, brandname, 13149acbbeafSnn35248 sizeof (brandname)) != Z_OK) { 13159acbbeafSnn35248 zerr("Zone %s is inconsistent: missing " 13169acbbeafSnn35248 "brand attribute", zone); 13179acbbeafSnn35248 exit(Z_ERR); 13189acbbeafSnn35248 } 13199acbbeafSnn35248 if ((brand = brand_open(brandname)) == NULL) { 13209acbbeafSnn35248 zerr("Zone %s uses non-existent brand \"%s\"." 13219acbbeafSnn35248 " Unable to continue", zone, brandname); 13229acbbeafSnn35248 exit(Z_ERR); 13239acbbeafSnn35248 } 1324cb8a054bSGlenn Faden /* 1325cb8a054bSGlenn Faden * If the user_attr file is newer than 1326cb8a054bSGlenn Faden * the zone config file, the admins 1327cb8a054bSGlenn Faden * may need to be updated since the 1328cb8a054bSGlenn Faden * RBAC files are authoritative for 1329cb8a054bSGlenn Faden * authorization checks. 1330cb8a054bSGlenn Faden */ 1331cb8a054bSGlenn Faden err = zonecfg_update_userauths(handle, zone); 1332cb8a054bSGlenn Faden if (err == Z_OK) { 1333cb8a054bSGlenn Faden zerr(gettext("The administrative rights " 1334cb8a054bSGlenn Faden "were updated to match " 1335cb8a054bSGlenn Faden "the current RBAC configuration.\n" 1336cb8a054bSGlenn Faden "Use \"info admin\" and \"revert\" to " 1337cb8a054bSGlenn Faden "compare with the previous settings.")); 1338cb8a054bSGlenn Faden need_to_commit = B_TRUE; 1339cb8a054bSGlenn Faden } else if (err != Z_NO_ENTRY) { 1340cb8a054bSGlenn Faden zerr(gettext("failed to update " 1341cb8a054bSGlenn Faden "admin rights.")); 1342cb8a054bSGlenn Faden exit(Z_ERR); 1343cb8a054bSGlenn Faden } else if (need_to_commit) { 1344cb8a054bSGlenn Faden zerr(gettext("admin rights were updated " 1345cb8a054bSGlenn Faden "to match RBAC configuration.")); 1346cb8a054bSGlenn Faden } 1347cb8a054bSGlenn Faden 13480209230bSgjelinek } else if (global_zone && err == Z_NO_ZONE && !got_handle && 13490209230bSgjelinek !read_only_mode) { 13500209230bSgjelinek /* 13510209230bSgjelinek * We implicitly create the global zone config if it 13520209230bSgjelinek * doesn't exist. 13530209230bSgjelinek */ 13540209230bSgjelinek zone_dochandle_t tmphandle; 13550209230bSgjelinek 13560209230bSgjelinek if ((tmphandle = zonecfg_init_handle()) == NULL) { 1357bbec428eSgjelinek zone_perror(execname, Z_NOMEM, B_TRUE); 13580209230bSgjelinek exit(Z_ERR); 13590209230bSgjelinek } 13600209230bSgjelinek 13610209230bSgjelinek err = zonecfg_get_template_handle("SUNWblank", zone, 13620209230bSgjelinek tmphandle); 13630209230bSgjelinek 13640209230bSgjelinek if (err != Z_OK) { 13650209230bSgjelinek zonecfg_fini_handle(tmphandle); 1366bbec428eSgjelinek zone_perror("SUNWblank", err, B_TRUE); 13670209230bSgjelinek return (err); 13680209230bSgjelinek } 13690209230bSgjelinek 1370bbec428eSgjelinek need_to_commit = B_TRUE; 13710209230bSgjelinek zonecfg_fini_handle(handle); 13720209230bSgjelinek handle = tmphandle; 1373bbec428eSgjelinek got_handle = B_TRUE; 13740209230bSgjelinek 13757c478bd9Sstevel@tonic-gate } else { 13767c478bd9Sstevel@tonic-gate zone_perror(zone, err, handle_expected || got_handle); 13777c478bd9Sstevel@tonic-gate if (err == Z_NO_ZONE && !got_handle && 13787c478bd9Sstevel@tonic-gate interactive_mode && !read_only_mode) 13797c478bd9Sstevel@tonic-gate (void) printf(gettext("Use '%s' to begin " 13807c478bd9Sstevel@tonic-gate "configuring a new zone.\n"), 13817c478bd9Sstevel@tonic-gate cmd_to_str(CMD_CREATE)); 13827c478bd9Sstevel@tonic-gate return (err); 13837c478bd9Sstevel@tonic-gate } 13847c478bd9Sstevel@tonic-gate } 13857c478bd9Sstevel@tonic-gate return (Z_OK); 13867c478bd9Sstevel@tonic-gate } 13877c478bd9Sstevel@tonic-gate 1388bbec428eSgjelinek static boolean_t 1389087719fdSdp state_atleast(zone_state_t state) 1390087719fdSdp { 1391087719fdSdp zone_state_t state_num; 1392087719fdSdp int err; 1393087719fdSdp 1394087719fdSdp if ((err = zone_get_state(zone, &state_num)) != Z_OK) { 1395087719fdSdp /* all states are greater than "non-existent" */ 1396087719fdSdp if (err == Z_NO_ZONE) 1397087719fdSdp return (B_FALSE); 1398087719fdSdp zerr(gettext("Unexpectedly failed to determine state " 1399087719fdSdp "of zone %s: %s"), zone, zonecfg_strerror(err)); 1400087719fdSdp exit(Z_ERR); 1401087719fdSdp } 1402087719fdSdp return (state_num >= state); 1403087719fdSdp } 1404087719fdSdp 14057c478bd9Sstevel@tonic-gate /* 14067c478bd9Sstevel@tonic-gate * short_usage() is for bad syntax: getopt() issues, too many arguments, etc. 14077c478bd9Sstevel@tonic-gate */ 14087c478bd9Sstevel@tonic-gate 14097c478bd9Sstevel@tonic-gate void 14107c478bd9Sstevel@tonic-gate short_usage(int command) 14117c478bd9Sstevel@tonic-gate { 14127c478bd9Sstevel@tonic-gate /* lex_lineno has already been incremented in the lexer; compensate */ 14137c478bd9Sstevel@tonic-gate if (cmd_file_mode) { 14147c478bd9Sstevel@tonic-gate if (strcmp(cmd_file_name, "-") == 0) 14157c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 14167c478bd9Sstevel@tonic-gate gettext("syntax error on line %d\n"), 14177c478bd9Sstevel@tonic-gate lex_lineno - 1); 14187c478bd9Sstevel@tonic-gate else 14197c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 14207c478bd9Sstevel@tonic-gate gettext("syntax error on line %d of %s\n"), 14217c478bd9Sstevel@tonic-gate lex_lineno - 1, cmd_file_name); 14227c478bd9Sstevel@tonic-gate } 14237c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "%s:\n%s\n", gettext("usage"), 14247c478bd9Sstevel@tonic-gate helptab[command].short_usage); 1425bbec428eSgjelinek saw_error = B_TRUE; 14267c478bd9Sstevel@tonic-gate } 14277c478bd9Sstevel@tonic-gate 14287c478bd9Sstevel@tonic-gate /* 14297c478bd9Sstevel@tonic-gate * long_usage() is for bad semantics: e.g., wrong property type for a given 14307c478bd9Sstevel@tonic-gate * resource type. It is also used by longer_usage() below. 14317c478bd9Sstevel@tonic-gate */ 14327c478bd9Sstevel@tonic-gate 14337c478bd9Sstevel@tonic-gate void 1434bbec428eSgjelinek long_usage(uint_t cmd_num, boolean_t set_saw) 14357c478bd9Sstevel@tonic-gate { 14367c478bd9Sstevel@tonic-gate (void) fprintf(set_saw ? stderr : stdout, "%s:\n%s\n", gettext("usage"), 14377c478bd9Sstevel@tonic-gate helptab[cmd_num].short_usage); 14387c478bd9Sstevel@tonic-gate (void) fprintf(set_saw ? stderr : stdout, "\t%s\n", long_help(cmd_num)); 14397c478bd9Sstevel@tonic-gate if (set_saw) 1440bbec428eSgjelinek saw_error = B_TRUE; 14417c478bd9Sstevel@tonic-gate } 14427c478bd9Sstevel@tonic-gate 14437c478bd9Sstevel@tonic-gate /* 14447c478bd9Sstevel@tonic-gate * longer_usage() is for 'help foo' and 'foo -?': call long_usage() and also 14457c478bd9Sstevel@tonic-gate * any extra usage() flags as appropriate for whatever command. 14467c478bd9Sstevel@tonic-gate */ 14477c478bd9Sstevel@tonic-gate 14487c478bd9Sstevel@tonic-gate void 14497c478bd9Sstevel@tonic-gate longer_usage(uint_t cmd_num) 14507c478bd9Sstevel@tonic-gate { 1451bbec428eSgjelinek long_usage(cmd_num, B_FALSE); 14527c478bd9Sstevel@tonic-gate if (helptab[cmd_num].flags != 0) { 14537c478bd9Sstevel@tonic-gate (void) printf("\n"); 1454bbec428eSgjelinek usage(B_TRUE, helptab[cmd_num].flags); 14557c478bd9Sstevel@tonic-gate } 14567c478bd9Sstevel@tonic-gate } 14577c478bd9Sstevel@tonic-gate 14587c478bd9Sstevel@tonic-gate /* 14597c478bd9Sstevel@tonic-gate * scope_usage() is simply used when a command is called from the wrong scope. 14607c478bd9Sstevel@tonic-gate */ 14617c478bd9Sstevel@tonic-gate 14627c478bd9Sstevel@tonic-gate static void 14637c478bd9Sstevel@tonic-gate scope_usage(uint_t cmd_num) 14647c478bd9Sstevel@tonic-gate { 14657c478bd9Sstevel@tonic-gate zerr(gettext("The %s command only makes sense in the %s scope."), 14667c478bd9Sstevel@tonic-gate cmd_to_str(cmd_num), 14677c478bd9Sstevel@tonic-gate global_scope ? gettext("resource") : gettext("global")); 1468bbec428eSgjelinek saw_error = B_TRUE; 14697c478bd9Sstevel@tonic-gate } 14707c478bd9Sstevel@tonic-gate 14717c478bd9Sstevel@tonic-gate /* 1472bbec428eSgjelinek * On input, B_TRUE => yes, B_FALSE => no. 1473bbec428eSgjelinek * On return, B_TRUE => 1, B_FALSE => no, could not ask => -1. 14747c478bd9Sstevel@tonic-gate */ 14757c478bd9Sstevel@tonic-gate 14767c478bd9Sstevel@tonic-gate static int 1477bbec428eSgjelinek ask_yesno(boolean_t default_answer, const char *question) 14787c478bd9Sstevel@tonic-gate { 14797c478bd9Sstevel@tonic-gate char line[64]; /* should be enough to answer yes or no */ 14807c478bd9Sstevel@tonic-gate 14817c478bd9Sstevel@tonic-gate if (!ok_to_prompt) { 1482bbec428eSgjelinek saw_error = B_TRUE; 14837c478bd9Sstevel@tonic-gate return (-1); 14847c478bd9Sstevel@tonic-gate } 14857c478bd9Sstevel@tonic-gate for (;;) { 1486087719fdSdp if (printf("%s (%s)? ", question, 1487087719fdSdp default_answer ? "[y]/n" : "y/[n]") < 0) 1488087719fdSdp return (-1); 1489087719fdSdp if (fgets(line, sizeof (line), stdin) == NULL) 1490087719fdSdp return (-1); 1491087719fdSdp 1492087719fdSdp if (line[0] == '\n') 14937c478bd9Sstevel@tonic-gate return (default_answer ? 1 : 0); 14947c478bd9Sstevel@tonic-gate if (tolower(line[0]) == 'y') 14957c478bd9Sstevel@tonic-gate return (1); 14967c478bd9Sstevel@tonic-gate if (tolower(line[0]) == 'n') 14977c478bd9Sstevel@tonic-gate return (0); 14987c478bd9Sstevel@tonic-gate } 14997c478bd9Sstevel@tonic-gate } 15007c478bd9Sstevel@tonic-gate 15017c478bd9Sstevel@tonic-gate /* 15027c478bd9Sstevel@tonic-gate * Prints warning if zone already exists. 15037c478bd9Sstevel@tonic-gate * In interactive mode, prompts if we should continue anyway and returns Z_OK 15047c478bd9Sstevel@tonic-gate * if so, Z_ERR if not. In non-interactive mode, exits with Z_ERR. 15057c478bd9Sstevel@tonic-gate * 15067c478bd9Sstevel@tonic-gate * Note that if a zone exists and its state is >= INSTALLED, an error message 15077c478bd9Sstevel@tonic-gate * will be printed and this function will return Z_ERR regardless of mode. 15087c478bd9Sstevel@tonic-gate */ 15097c478bd9Sstevel@tonic-gate 15107c478bd9Sstevel@tonic-gate static int 1511bbec428eSgjelinek check_if_zone_already_exists(boolean_t force) 15127c478bd9Sstevel@tonic-gate { 15137c478bd9Sstevel@tonic-gate char line[ZONENAME_MAX + 128]; /* enough to ask a question */ 15147c478bd9Sstevel@tonic-gate zone_dochandle_t tmphandle; 15157c478bd9Sstevel@tonic-gate int res, answer; 15167c478bd9Sstevel@tonic-gate 15177c478bd9Sstevel@tonic-gate if ((tmphandle = zonecfg_init_handle()) == NULL) { 1518bbec428eSgjelinek zone_perror(execname, Z_NOMEM, B_TRUE); 15197c478bd9Sstevel@tonic-gate exit(Z_ERR); 15207c478bd9Sstevel@tonic-gate } 15217c478bd9Sstevel@tonic-gate res = zonecfg_get_handle(zone, tmphandle); 15227c478bd9Sstevel@tonic-gate zonecfg_fini_handle(tmphandle); 1523087719fdSdp if (res != Z_OK) 15247c478bd9Sstevel@tonic-gate return (Z_OK); 1525087719fdSdp 1526087719fdSdp if (state_atleast(ZONE_STATE_INSTALLED)) { 15277c478bd9Sstevel@tonic-gate zerr(gettext("Zone %s already installed; %s not allowed."), 15287c478bd9Sstevel@tonic-gate zone, cmd_to_str(CMD_CREATE)); 15297c478bd9Sstevel@tonic-gate return (Z_ERR); 15307c478bd9Sstevel@tonic-gate } 15317c478bd9Sstevel@tonic-gate 15327c478bd9Sstevel@tonic-gate if (force) { 15337c478bd9Sstevel@tonic-gate (void) printf(gettext("Zone %s already exists; overwriting.\n"), 15347c478bd9Sstevel@tonic-gate zone); 15357c478bd9Sstevel@tonic-gate return (Z_OK); 15367c478bd9Sstevel@tonic-gate } 15377c478bd9Sstevel@tonic-gate (void) snprintf(line, sizeof (line), 15387c478bd9Sstevel@tonic-gate gettext("Zone %s already exists; %s anyway"), zone, 15397c478bd9Sstevel@tonic-gate cmd_to_str(CMD_CREATE)); 1540bbec428eSgjelinek if ((answer = ask_yesno(B_FALSE, line)) == -1) { 15417c478bd9Sstevel@tonic-gate zerr(gettext("Zone exists, input not from terminal and -F not " 15427c478bd9Sstevel@tonic-gate "specified:\n%s command ignored, exiting."), 15437c478bd9Sstevel@tonic-gate cmd_to_str(CMD_CREATE)); 15447c478bd9Sstevel@tonic-gate exit(Z_ERR); 15457c478bd9Sstevel@tonic-gate } 15467c478bd9Sstevel@tonic-gate return (answer == 1 ? Z_OK : Z_ERR); 15477c478bd9Sstevel@tonic-gate } 15487c478bd9Sstevel@tonic-gate 1549bbec428eSgjelinek static boolean_t 15507c478bd9Sstevel@tonic-gate zone_is_read_only(int cmd_num) 15517c478bd9Sstevel@tonic-gate { 15527c478bd9Sstevel@tonic-gate if (strncmp(zone, "SUNW", 4) == 0) { 15537c478bd9Sstevel@tonic-gate zerr(gettext("%s: zones beginning with SUNW are read-only."), 15547c478bd9Sstevel@tonic-gate zone); 1555bbec428eSgjelinek saw_error = B_TRUE; 1556bbec428eSgjelinek return (B_TRUE); 15577c478bd9Sstevel@tonic-gate } 15587c478bd9Sstevel@tonic-gate if (read_only_mode) { 15597c478bd9Sstevel@tonic-gate zerr(gettext("%s: cannot %s in read-only mode."), zone, 15607c478bd9Sstevel@tonic-gate cmd_to_str(cmd_num)); 1561bbec428eSgjelinek saw_error = B_TRUE; 1562bbec428eSgjelinek return (B_TRUE); 15637c478bd9Sstevel@tonic-gate } 1564bbec428eSgjelinek return (B_FALSE); 15657c478bd9Sstevel@tonic-gate } 15667c478bd9Sstevel@tonic-gate 15677c478bd9Sstevel@tonic-gate /* 15687c478bd9Sstevel@tonic-gate * Create a new configuration. 15697c478bd9Sstevel@tonic-gate */ 15707c478bd9Sstevel@tonic-gate void 15717c478bd9Sstevel@tonic-gate create_func(cmd_t *cmd) 15727c478bd9Sstevel@tonic-gate { 15737c478bd9Sstevel@tonic-gate int err, arg; 15747c478bd9Sstevel@tonic-gate char zone_template[ZONENAME_MAX]; 1575ee519a1fSgjelinek char attach_path[MAXPATHLEN]; 15767c478bd9Sstevel@tonic-gate zone_dochandle_t tmphandle; 1577bbec428eSgjelinek boolean_t force = B_FALSE; 1578bbec428eSgjelinek boolean_t attach = B_FALSE; 1579bbec428eSgjelinek boolean_t arg_err = B_FALSE; 15807c478bd9Sstevel@tonic-gate 15817c478bd9Sstevel@tonic-gate assert(cmd != NULL); 15827c478bd9Sstevel@tonic-gate 15837c478bd9Sstevel@tonic-gate /* This is the default if no arguments are given. */ 15847c478bd9Sstevel@tonic-gate (void) strlcpy(zone_template, "SUNWdefault", sizeof (zone_template)); 15857c478bd9Sstevel@tonic-gate 15867c478bd9Sstevel@tonic-gate optind = 0; 15879acbbeafSnn35248 while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?a:bFt:")) 15889acbbeafSnn35248 != EOF) { 15897c478bd9Sstevel@tonic-gate switch (arg) { 15907c478bd9Sstevel@tonic-gate case '?': 15917c478bd9Sstevel@tonic-gate if (optopt == '?') 15927c478bd9Sstevel@tonic-gate longer_usage(CMD_CREATE); 15937c478bd9Sstevel@tonic-gate else 15947c478bd9Sstevel@tonic-gate short_usage(CMD_CREATE); 1595bbec428eSgjelinek arg_err = B_TRUE; 15967ec75eb8Sgjelinek break; 1597ee519a1fSgjelinek case 'a': 1598ee519a1fSgjelinek (void) strlcpy(attach_path, optarg, 1599ee519a1fSgjelinek sizeof (attach_path)); 1600bbec428eSgjelinek attach = B_TRUE; 1601ee519a1fSgjelinek break; 16027c478bd9Sstevel@tonic-gate case 'b': 16037c478bd9Sstevel@tonic-gate (void) strlcpy(zone_template, "SUNWblank", 16047c478bd9Sstevel@tonic-gate sizeof (zone_template)); 16057c478bd9Sstevel@tonic-gate break; 16067c478bd9Sstevel@tonic-gate case 'F': 1607bbec428eSgjelinek force = B_TRUE; 16087c478bd9Sstevel@tonic-gate break; 16097c478bd9Sstevel@tonic-gate case 't': 16107c478bd9Sstevel@tonic-gate (void) strlcpy(zone_template, optarg, 16117c478bd9Sstevel@tonic-gate sizeof (zone_template)); 16127c478bd9Sstevel@tonic-gate break; 16137c478bd9Sstevel@tonic-gate default: 16147c478bd9Sstevel@tonic-gate short_usage(CMD_CREATE); 1615bbec428eSgjelinek arg_err = B_TRUE; 16167ec75eb8Sgjelinek break; 16177ec75eb8Sgjelinek } 16187ec75eb8Sgjelinek } 16197ec75eb8Sgjelinek if (arg_err) 16207c478bd9Sstevel@tonic-gate return; 16217ec75eb8Sgjelinek 16227c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 16237c478bd9Sstevel@tonic-gate short_usage(CMD_CREATE); 16247c478bd9Sstevel@tonic-gate return; 16257c478bd9Sstevel@tonic-gate } 16267c478bd9Sstevel@tonic-gate 16277c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_CREATE)) 16287c478bd9Sstevel@tonic-gate return; 16297c478bd9Sstevel@tonic-gate 16307c478bd9Sstevel@tonic-gate if (check_if_zone_already_exists(force) != Z_OK) 16317c478bd9Sstevel@tonic-gate return; 16327c478bd9Sstevel@tonic-gate 16337c478bd9Sstevel@tonic-gate /* 16347c478bd9Sstevel@tonic-gate * Get a temporary handle first. If that fails, the old handle 16357c478bd9Sstevel@tonic-gate * will not be lost. Then finish whichever one we don't need, 16367c478bd9Sstevel@tonic-gate * to avoid leaks. Then get the handle for zone_template, and 16377c478bd9Sstevel@tonic-gate * set the name to zone: this "copy, rename" method is how 16387c478bd9Sstevel@tonic-gate * create -[b|t] works. 16397c478bd9Sstevel@tonic-gate */ 16407c478bd9Sstevel@tonic-gate if ((tmphandle = zonecfg_init_handle()) == NULL) { 1641bbec428eSgjelinek zone_perror(execname, Z_NOMEM, B_TRUE); 16427c478bd9Sstevel@tonic-gate exit(Z_ERR); 16437c478bd9Sstevel@tonic-gate } 1644ee519a1fSgjelinek 1645ee519a1fSgjelinek if (attach) 164616ab8c7bSgjelinek err = zonecfg_get_attach_handle(attach_path, ZONE_DETACHED, 164716ab8c7bSgjelinek zone, B_FALSE, tmphandle); 1648ee519a1fSgjelinek else 1649ee519a1fSgjelinek err = zonecfg_get_template_handle(zone_template, zone, 1650ee519a1fSgjelinek tmphandle); 1651ee519a1fSgjelinek 1652ee519a1fSgjelinek if (err != Z_OK) { 16537c478bd9Sstevel@tonic-gate zonecfg_fini_handle(tmphandle); 1654ee519a1fSgjelinek if (attach && err == Z_NO_ZONE) 1655ee519a1fSgjelinek (void) fprintf(stderr, gettext("invalid path to " 1656ee519a1fSgjelinek "detached zone\n")); 1657ee519a1fSgjelinek else if (attach && err == Z_INVALID_DOCUMENT) 1658ee519a1fSgjelinek (void) fprintf(stderr, gettext("Cannot attach to an " 1659ee519a1fSgjelinek "earlier release of the operating system\n")); 1660ee519a1fSgjelinek else 1661bbec428eSgjelinek zone_perror(zone_template, err, B_TRUE); 16627c478bd9Sstevel@tonic-gate return; 16637c478bd9Sstevel@tonic-gate } 1664087719fdSdp 1665bbec428eSgjelinek need_to_commit = B_TRUE; 16667c478bd9Sstevel@tonic-gate zonecfg_fini_handle(handle); 16677c478bd9Sstevel@tonic-gate handle = tmphandle; 1668bbec428eSgjelinek got_handle = B_TRUE; 16697c478bd9Sstevel@tonic-gate } 16707c478bd9Sstevel@tonic-gate 16717c478bd9Sstevel@tonic-gate /* 16727c478bd9Sstevel@tonic-gate * This malloc()'s memory, which must be freed by the caller. 16737c478bd9Sstevel@tonic-gate */ 16747c478bd9Sstevel@tonic-gate static char * 16757c478bd9Sstevel@tonic-gate quoteit(char *instr) 16767c478bd9Sstevel@tonic-gate { 16777c478bd9Sstevel@tonic-gate char *outstr; 16787c478bd9Sstevel@tonic-gate size_t outstrsize = strlen(instr) + 3; /* 2 quotes + '\0' */ 16797c478bd9Sstevel@tonic-gate 16807c478bd9Sstevel@tonic-gate if ((outstr = malloc(outstrsize)) == NULL) { 1681bbec428eSgjelinek zone_perror(zone, Z_NOMEM, B_FALSE); 16827c478bd9Sstevel@tonic-gate exit(Z_ERR); 16837c478bd9Sstevel@tonic-gate } 16847c478bd9Sstevel@tonic-gate if (strchr(instr, ' ') == NULL) { 16857c478bd9Sstevel@tonic-gate (void) strlcpy(outstr, instr, outstrsize); 16867c478bd9Sstevel@tonic-gate return (outstr); 16877c478bd9Sstevel@tonic-gate } 16887c478bd9Sstevel@tonic-gate (void) snprintf(outstr, outstrsize, "\"%s\"", instr); 16897c478bd9Sstevel@tonic-gate return (outstr); 16907c478bd9Sstevel@tonic-gate } 16917c478bd9Sstevel@tonic-gate 16927c478bd9Sstevel@tonic-gate static void 16937c478bd9Sstevel@tonic-gate export_prop(FILE *of, int prop_num, char *prop_id) 16947c478bd9Sstevel@tonic-gate { 16957c478bd9Sstevel@tonic-gate char *quote_str; 16967c478bd9Sstevel@tonic-gate 16977c478bd9Sstevel@tonic-gate if (strlen(prop_id) == 0) 16987c478bd9Sstevel@tonic-gate return; 16997c478bd9Sstevel@tonic-gate quote_str = quoteit(prop_id); 17007c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 17017c478bd9Sstevel@tonic-gate pt_to_str(prop_num), quote_str); 17027c478bd9Sstevel@tonic-gate free(quote_str); 17037c478bd9Sstevel@tonic-gate } 17047c478bd9Sstevel@tonic-gate 17057c478bd9Sstevel@tonic-gate void 17067c478bd9Sstevel@tonic-gate export_func(cmd_t *cmd) 17077c478bd9Sstevel@tonic-gate { 17087c478bd9Sstevel@tonic-gate struct zone_nwiftab nwiftab; 17097c478bd9Sstevel@tonic-gate struct zone_fstab fstab; 17107c478bd9Sstevel@tonic-gate struct zone_devtab devtab; 17117c478bd9Sstevel@tonic-gate struct zone_attrtab attrtab; 17127c478bd9Sstevel@tonic-gate struct zone_rctltab rctltab; 1713fa9e4066Sahrens struct zone_dstab dstab; 17140209230bSgjelinek struct zone_psettab psettab; 17150209230bSgjelinek struct zone_mcaptab mcaptab; 17167c478bd9Sstevel@tonic-gate struct zone_rctlvaltab *valptr; 1717cb8a054bSGlenn Faden struct zone_admintab admintab; 17187c478bd9Sstevel@tonic-gate int err, arg; 17197c478bd9Sstevel@tonic-gate char zonepath[MAXPATHLEN], outfile[MAXPATHLEN], pool[MAXNAMELEN]; 17203f2f09c1Sdp char bootargs[BOOTARGS_MAX]; 17210209230bSgjelinek char sched[MAXNAMELEN]; 17229acbbeafSnn35248 char brand[MAXNAMELEN]; 17235679c89fSjv227347 char hostidp[HW_HOSTID_LEN]; 17240fbb751dSJohn Levon char fsallowedp[ZONE_FS_ALLOWED_MAX]; 1725ffbafc53Scomay char *limitpriv; 17267c478bd9Sstevel@tonic-gate FILE *of; 17277c478bd9Sstevel@tonic-gate boolean_t autoboot; 1728f4b3ec61Sdh155122 zone_iptype_t iptype; 1729bbec428eSgjelinek boolean_t need_to_close = B_FALSE; 1730bbec428eSgjelinek boolean_t arg_err = B_FALSE; 17317c478bd9Sstevel@tonic-gate 17327c478bd9Sstevel@tonic-gate assert(cmd != NULL); 17337c478bd9Sstevel@tonic-gate 17347c478bd9Sstevel@tonic-gate outfile[0] = '\0'; 17357c478bd9Sstevel@tonic-gate optind = 0; 17367c478bd9Sstevel@tonic-gate while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?f:")) != EOF) { 17377c478bd9Sstevel@tonic-gate switch (arg) { 17387c478bd9Sstevel@tonic-gate case '?': 17397c478bd9Sstevel@tonic-gate if (optopt == '?') 17407c478bd9Sstevel@tonic-gate longer_usage(CMD_EXPORT); 17417c478bd9Sstevel@tonic-gate else 17427c478bd9Sstevel@tonic-gate short_usage(CMD_EXPORT); 1743bbec428eSgjelinek arg_err = B_TRUE; 17447ec75eb8Sgjelinek break; 17457c478bd9Sstevel@tonic-gate case 'f': 17467c478bd9Sstevel@tonic-gate (void) strlcpy(outfile, optarg, sizeof (outfile)); 17477c478bd9Sstevel@tonic-gate break; 17487c478bd9Sstevel@tonic-gate default: 17497c478bd9Sstevel@tonic-gate short_usage(CMD_EXPORT); 1750bbec428eSgjelinek arg_err = B_TRUE; 17517ec75eb8Sgjelinek break; 17527ec75eb8Sgjelinek } 17537ec75eb8Sgjelinek } 17547ec75eb8Sgjelinek if (arg_err) 17557c478bd9Sstevel@tonic-gate return; 17567ec75eb8Sgjelinek 17577c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 17587c478bd9Sstevel@tonic-gate short_usage(CMD_EXPORT); 17597c478bd9Sstevel@tonic-gate return; 17607c478bd9Sstevel@tonic-gate } 17617c478bd9Sstevel@tonic-gate if (strlen(outfile) == 0) { 17627c478bd9Sstevel@tonic-gate of = stdout; 17637c478bd9Sstevel@tonic-gate } else { 17647c478bd9Sstevel@tonic-gate if ((of = fopen(outfile, "w")) == NULL) { 17657c478bd9Sstevel@tonic-gate zerr(gettext("opening file %s: %s"), 17667c478bd9Sstevel@tonic-gate outfile, strerror(errno)); 17677c478bd9Sstevel@tonic-gate goto done; 17687c478bd9Sstevel@tonic-gate } 17697c478bd9Sstevel@tonic-gate setbuf(of, NULL); 1770bbec428eSgjelinek need_to_close = B_TRUE; 17717c478bd9Sstevel@tonic-gate } 17727c478bd9Sstevel@tonic-gate 1773bbec428eSgjelinek if ((err = initialize(B_TRUE)) != Z_OK) 17747c478bd9Sstevel@tonic-gate goto done; 17757c478bd9Sstevel@tonic-gate 17767c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s -b\n", cmd_to_str(CMD_CREATE)); 17777c478bd9Sstevel@tonic-gate 17787c478bd9Sstevel@tonic-gate if (zonecfg_get_zonepath(handle, zonepath, sizeof (zonepath)) == Z_OK && 17797c478bd9Sstevel@tonic-gate strlen(zonepath) > 0) 17807c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 17817c478bd9Sstevel@tonic-gate pt_to_str(PT_ZONEPATH), zonepath); 17827c478bd9Sstevel@tonic-gate 17839acbbeafSnn35248 if ((zone_get_brand(zone, brand, sizeof (brand)) == Z_OK) && 17849acbbeafSnn35248 (strcmp(brand, NATIVE_BRAND_NAME) != 0)) 17859acbbeafSnn35248 (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 17869acbbeafSnn35248 pt_to_str(PT_BRAND), brand); 17879acbbeafSnn35248 17887c478bd9Sstevel@tonic-gate if (zonecfg_get_autoboot(handle, &autoboot) == Z_OK) 17897c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 17907c478bd9Sstevel@tonic-gate pt_to_str(PT_AUTOBOOT), autoboot ? "true" : "false"); 17917c478bd9Sstevel@tonic-gate 17923f2f09c1Sdp if (zonecfg_get_bootargs(handle, bootargs, sizeof (bootargs)) == Z_OK && 17933f2f09c1Sdp strlen(bootargs) > 0) { 17943f2f09c1Sdp (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 17953f2f09c1Sdp pt_to_str(PT_BOOTARGS), bootargs); 17963f2f09c1Sdp } 17973f2f09c1Sdp 17987c478bd9Sstevel@tonic-gate if (zonecfg_get_pool(handle, pool, sizeof (pool)) == Z_OK && 17997c478bd9Sstevel@tonic-gate strlen(pool) > 0) 18007c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 18017c478bd9Sstevel@tonic-gate pt_to_str(PT_POOL), pool); 18027c478bd9Sstevel@tonic-gate 1803ffbafc53Scomay if (zonecfg_get_limitpriv(handle, &limitpriv) == Z_OK && 1804ffbafc53Scomay strlen(limitpriv) > 0) { 1805ffbafc53Scomay (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 1806ffbafc53Scomay pt_to_str(PT_LIMITPRIV), limitpriv); 1807ffbafc53Scomay free(limitpriv); 1808ffbafc53Scomay } 1809ffbafc53Scomay 18100209230bSgjelinek if (zonecfg_get_sched_class(handle, sched, sizeof (sched)) == Z_OK && 18110209230bSgjelinek strlen(sched) > 0) 18120209230bSgjelinek (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 18130209230bSgjelinek pt_to_str(PT_SCHED), sched); 18143f2f09c1Sdp 1815f4b3ec61Sdh155122 if (zonecfg_get_iptype(handle, &iptype) == Z_OK) { 1816f4b3ec61Sdh155122 switch (iptype) { 1817f4b3ec61Sdh155122 case ZS_SHARED: 1818f4b3ec61Sdh155122 (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 1819f4b3ec61Sdh155122 pt_to_str(PT_IPTYPE), "shared"); 1820f4b3ec61Sdh155122 break; 1821f4b3ec61Sdh155122 case ZS_EXCLUSIVE: 1822f4b3ec61Sdh155122 (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 1823f4b3ec61Sdh155122 pt_to_str(PT_IPTYPE), "exclusive"); 1824f4b3ec61Sdh155122 break; 1825f4b3ec61Sdh155122 } 1826f4b3ec61Sdh155122 } 1827f4b3ec61Sdh155122 18285679c89fSjv227347 if (zonecfg_get_hostid(handle, hostidp, sizeof (hostidp)) == Z_OK) { 18295679c89fSjv227347 (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 18305679c89fSjv227347 pt_to_str(PT_HOSTID), hostidp); 18315679c89fSjv227347 } 18325679c89fSjv227347 18330fbb751dSJohn Levon if (zonecfg_get_fs_allowed(handle, fsallowedp, 18340fbb751dSJohn Levon sizeof (fsallowedp)) == Z_OK) { 18350fbb751dSJohn Levon (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 18360fbb751dSJohn Levon pt_to_str(PT_FS_ALLOWED), fsallowedp); 18370fbb751dSJohn Levon } 18380fbb751dSJohn Levon 18397c478bd9Sstevel@tonic-gate if ((err = zonecfg_setfsent(handle)) != Z_OK) { 1840bbec428eSgjelinek zone_perror(zone, err, B_FALSE); 18417c478bd9Sstevel@tonic-gate goto done; 18427c478bd9Sstevel@tonic-gate } 18437c478bd9Sstevel@tonic-gate while (zonecfg_getfsent(handle, &fstab) == Z_OK) { 18447c478bd9Sstevel@tonic-gate zone_fsopt_t *optptr; 18457c478bd9Sstevel@tonic-gate 18467c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 18477c478bd9Sstevel@tonic-gate rt_to_str(RT_FS)); 18487c478bd9Sstevel@tonic-gate export_prop(of, PT_DIR, fstab.zone_fs_dir); 18497c478bd9Sstevel@tonic-gate export_prop(of, PT_SPECIAL, fstab.zone_fs_special); 18507c478bd9Sstevel@tonic-gate export_prop(of, PT_RAW, fstab.zone_fs_raw); 18517c478bd9Sstevel@tonic-gate export_prop(of, PT_TYPE, fstab.zone_fs_type); 18527c478bd9Sstevel@tonic-gate for (optptr = fstab.zone_fs_options; optptr != NULL; 18537c478bd9Sstevel@tonic-gate optptr = optptr->zone_fsopt_next) { 18547c478bd9Sstevel@tonic-gate /* 18557c478bd9Sstevel@tonic-gate * Simple property values with embedded equal signs 18567c478bd9Sstevel@tonic-gate * need to be quoted to prevent the lexer from 18577c478bd9Sstevel@tonic-gate * mis-parsing them as complex name=value pairs. 18587c478bd9Sstevel@tonic-gate */ 18597c478bd9Sstevel@tonic-gate if (strchr(optptr->zone_fsopt_opt, '=')) 18607c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s \"%s\"\n", 18617c478bd9Sstevel@tonic-gate cmd_to_str(CMD_ADD), 18627c478bd9Sstevel@tonic-gate pt_to_str(PT_OPTIONS), 18637c478bd9Sstevel@tonic-gate optptr->zone_fsopt_opt); 18647c478bd9Sstevel@tonic-gate else 18657c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s %s\n", 18667c478bd9Sstevel@tonic-gate cmd_to_str(CMD_ADD), 18677c478bd9Sstevel@tonic-gate pt_to_str(PT_OPTIONS), 18687c478bd9Sstevel@tonic-gate optptr->zone_fsopt_opt); 18697c478bd9Sstevel@tonic-gate } 18707c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 18717c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(fstab.zone_fs_options); 18727c478bd9Sstevel@tonic-gate } 18737c478bd9Sstevel@tonic-gate (void) zonecfg_endfsent(handle); 18747c478bd9Sstevel@tonic-gate 18757c478bd9Sstevel@tonic-gate if ((err = zonecfg_setnwifent(handle)) != Z_OK) { 1876bbec428eSgjelinek zone_perror(zone, err, B_FALSE); 18777c478bd9Sstevel@tonic-gate goto done; 18787c478bd9Sstevel@tonic-gate } 18797c478bd9Sstevel@tonic-gate while (zonecfg_getnwifent(handle, &nwiftab) == Z_OK) { 18807c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 18817c478bd9Sstevel@tonic-gate rt_to_str(RT_NET)); 18827c478bd9Sstevel@tonic-gate export_prop(of, PT_ADDRESS, nwiftab.zone_nwif_address); 1883550b6e40SSowmini Varadhan export_prop(of, PT_ALLOWED_ADDRESS, 1884550b6e40SSowmini Varadhan nwiftab.zone_nwif_allowed_address); 18857c478bd9Sstevel@tonic-gate export_prop(of, PT_PHYSICAL, nwiftab.zone_nwif_physical); 1886de860bd9Sgfaden export_prop(of, PT_DEFROUTER, nwiftab.zone_nwif_defrouter); 18877c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 18887c478bd9Sstevel@tonic-gate } 18897c478bd9Sstevel@tonic-gate (void) zonecfg_endnwifent(handle); 18907c478bd9Sstevel@tonic-gate 18917c478bd9Sstevel@tonic-gate if ((err = zonecfg_setdevent(handle)) != Z_OK) { 1892bbec428eSgjelinek zone_perror(zone, err, B_FALSE); 18937c478bd9Sstevel@tonic-gate goto done; 18947c478bd9Sstevel@tonic-gate } 18957c478bd9Sstevel@tonic-gate while (zonecfg_getdevent(handle, &devtab) == Z_OK) { 18967c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 18977c478bd9Sstevel@tonic-gate rt_to_str(RT_DEVICE)); 18987c478bd9Sstevel@tonic-gate export_prop(of, PT_MATCH, devtab.zone_dev_match); 18997c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 19007c478bd9Sstevel@tonic-gate } 19017c478bd9Sstevel@tonic-gate (void) zonecfg_enddevent(handle); 19027c478bd9Sstevel@tonic-gate 19031b3281c0SGerald Jelinek if (zonecfg_getmcapent(handle, &mcaptab) == Z_OK) { 19041b3281c0SGerald Jelinek char buf[128]; 19051b3281c0SGerald Jelinek 19061b3281c0SGerald Jelinek (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 19071b3281c0SGerald Jelinek rt_to_str(RT_MCAP)); 19081b3281c0SGerald Jelinek bytes_to_units(mcaptab.zone_physmem_cap, buf, sizeof (buf)); 19091b3281c0SGerald Jelinek (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 19101b3281c0SGerald Jelinek pt_to_str(PT_PHYSICAL), buf); 19111b3281c0SGerald Jelinek (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 19121b3281c0SGerald Jelinek } 19131b3281c0SGerald Jelinek 19147c478bd9Sstevel@tonic-gate if ((err = zonecfg_setrctlent(handle)) != Z_OK) { 1915bbec428eSgjelinek zone_perror(zone, err, B_FALSE); 19167c478bd9Sstevel@tonic-gate goto done; 19177c478bd9Sstevel@tonic-gate } 19187c478bd9Sstevel@tonic-gate while (zonecfg_getrctlent(handle, &rctltab) == Z_OK) { 19197c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s rctl\n", cmd_to_str(CMD_ADD)); 19207c478bd9Sstevel@tonic-gate export_prop(of, PT_NAME, rctltab.zone_rctl_name); 19217c478bd9Sstevel@tonic-gate for (valptr = rctltab.zone_rctl_valptr; valptr != NULL; 19227c478bd9Sstevel@tonic-gate valptr = valptr->zone_rctlval_next) { 19237c478bd9Sstevel@tonic-gate fprintf(of, "%s %s (%s=%s,%s=%s,%s=%s)\n", 19247c478bd9Sstevel@tonic-gate cmd_to_str(CMD_ADD), pt_to_str(PT_VALUE), 19257c478bd9Sstevel@tonic-gate pt_to_str(PT_PRIV), valptr->zone_rctlval_priv, 19267c478bd9Sstevel@tonic-gate pt_to_str(PT_LIMIT), valptr->zone_rctlval_limit, 19277c478bd9Sstevel@tonic-gate pt_to_str(PT_ACTION), valptr->zone_rctlval_action); 19287c478bd9Sstevel@tonic-gate } 19297c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 19307c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctltab.zone_rctl_valptr); 19317c478bd9Sstevel@tonic-gate } 19327c478bd9Sstevel@tonic-gate (void) zonecfg_endrctlent(handle); 19337c478bd9Sstevel@tonic-gate 19347c478bd9Sstevel@tonic-gate if ((err = zonecfg_setattrent(handle)) != Z_OK) { 1935bbec428eSgjelinek zone_perror(zone, err, B_FALSE); 19367c478bd9Sstevel@tonic-gate goto done; 19377c478bd9Sstevel@tonic-gate } 19387c478bd9Sstevel@tonic-gate while (zonecfg_getattrent(handle, &attrtab) == Z_OK) { 19397c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 19407c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR)); 19417c478bd9Sstevel@tonic-gate export_prop(of, PT_NAME, attrtab.zone_attr_name); 19427c478bd9Sstevel@tonic-gate export_prop(of, PT_TYPE, attrtab.zone_attr_type); 19437c478bd9Sstevel@tonic-gate export_prop(of, PT_VALUE, attrtab.zone_attr_value); 19447c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 19457c478bd9Sstevel@tonic-gate } 19467c478bd9Sstevel@tonic-gate (void) zonecfg_endattrent(handle); 19477c478bd9Sstevel@tonic-gate 1948fa9e4066Sahrens if ((err = zonecfg_setdsent(handle)) != Z_OK) { 1949bbec428eSgjelinek zone_perror(zone, err, B_FALSE); 1950fa9e4066Sahrens goto done; 1951fa9e4066Sahrens } 1952fa9e4066Sahrens while (zonecfg_getdsent(handle, &dstab) == Z_OK) { 1953fa9e4066Sahrens (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 1954fa9e4066Sahrens rt_to_str(RT_DATASET)); 1955fa9e4066Sahrens export_prop(of, PT_NAME, dstab.zone_dataset_name); 1956fa9e4066Sahrens (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 1957fa9e4066Sahrens } 1958fa9e4066Sahrens (void) zonecfg_enddsent(handle); 1959fa9e4066Sahrens 19600209230bSgjelinek if (zonecfg_getpsetent(handle, &psettab) == Z_OK) { 19610209230bSgjelinek (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 19620209230bSgjelinek rt_to_str(RT_DCPU)); 19630209230bSgjelinek if (strcmp(psettab.zone_ncpu_min, psettab.zone_ncpu_max) == 0) 19640209230bSgjelinek (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 19650209230bSgjelinek pt_to_str(PT_NCPUS), psettab.zone_ncpu_max); 19660209230bSgjelinek else 19670209230bSgjelinek (void) fprintf(of, "%s %s=%s-%s\n", cmd_to_str(CMD_SET), 19680209230bSgjelinek pt_to_str(PT_NCPUS), psettab.zone_ncpu_min, 19690209230bSgjelinek psettab.zone_ncpu_max); 19700209230bSgjelinek if (psettab.zone_importance[0] != '\0') 19710209230bSgjelinek (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 19720209230bSgjelinek pt_to_str(PT_IMPORTANCE), psettab.zone_importance); 19730209230bSgjelinek (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 19740209230bSgjelinek } 19750209230bSgjelinek 1976cb8a054bSGlenn Faden if ((err = zonecfg_setadminent(handle)) != Z_OK) { 1977cb8a054bSGlenn Faden zone_perror(zone, err, B_FALSE); 1978cb8a054bSGlenn Faden goto done; 1979cb8a054bSGlenn Faden } 1980cb8a054bSGlenn Faden while (zonecfg_getadminent(handle, &admintab) == Z_OK) { 1981cb8a054bSGlenn Faden (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 1982cb8a054bSGlenn Faden rt_to_str(RT_ADMIN)); 1983cb8a054bSGlenn Faden export_prop(of, PT_USER, admintab.zone_admin_user); 1984cb8a054bSGlenn Faden export_prop(of, PT_AUTHS, admintab.zone_admin_auths); 1985cb8a054bSGlenn Faden (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 1986cb8a054bSGlenn Faden } 1987cb8a054bSGlenn Faden (void) zonecfg_endadminent(handle); 1988cb8a054bSGlenn Faden 1989c97ad5cdSakolb /* 1990c97ad5cdSakolb * There is nothing to export for pcap since this resource is just 1991c97ad5cdSakolb * a container for an rctl alias. 1992c97ad5cdSakolb */ 1993c97ad5cdSakolb 19947c478bd9Sstevel@tonic-gate done: 19957c478bd9Sstevel@tonic-gate if (need_to_close) 19967c478bd9Sstevel@tonic-gate (void) fclose(of); 19977c478bd9Sstevel@tonic-gate } 19987c478bd9Sstevel@tonic-gate 19997c478bd9Sstevel@tonic-gate void 20007c478bd9Sstevel@tonic-gate exit_func(cmd_t *cmd) 20017c478bd9Sstevel@tonic-gate { 20027c478bd9Sstevel@tonic-gate int arg, answer; 2003bbec428eSgjelinek boolean_t arg_err = B_FALSE; 20047c478bd9Sstevel@tonic-gate 20057c478bd9Sstevel@tonic-gate optind = 0; 20067c478bd9Sstevel@tonic-gate while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?F")) != EOF) { 20077c478bd9Sstevel@tonic-gate switch (arg) { 20087c478bd9Sstevel@tonic-gate case '?': 20097c478bd9Sstevel@tonic-gate longer_usage(CMD_EXIT); 2010bbec428eSgjelinek arg_err = B_TRUE; 20117ec75eb8Sgjelinek break; 20127c478bd9Sstevel@tonic-gate case 'F': 2013bbec428eSgjelinek force_exit = B_TRUE; 20147c478bd9Sstevel@tonic-gate break; 20157c478bd9Sstevel@tonic-gate default: 20167c478bd9Sstevel@tonic-gate short_usage(CMD_EXIT); 2017bbec428eSgjelinek arg_err = B_TRUE; 20187ec75eb8Sgjelinek break; 20197ec75eb8Sgjelinek } 20207ec75eb8Sgjelinek } 20217ec75eb8Sgjelinek if (arg_err) 20227c478bd9Sstevel@tonic-gate return; 20237ec75eb8Sgjelinek 20247c478bd9Sstevel@tonic-gate if (optind < cmd->cmd_argc) { 20257c478bd9Sstevel@tonic-gate short_usage(CMD_EXIT); 20267c478bd9Sstevel@tonic-gate return; 20277c478bd9Sstevel@tonic-gate } 20287c478bd9Sstevel@tonic-gate 20297c478bd9Sstevel@tonic-gate if (global_scope || force_exit) { 2030bbec428eSgjelinek time_to_exit = B_TRUE; 20317c478bd9Sstevel@tonic-gate return; 20327c478bd9Sstevel@tonic-gate } 20337c478bd9Sstevel@tonic-gate 2034bbec428eSgjelinek answer = ask_yesno(B_FALSE, "Resource incomplete; really quit"); 20357c478bd9Sstevel@tonic-gate if (answer == -1) { 20367c478bd9Sstevel@tonic-gate zerr(gettext("Resource incomplete, input " 20377c478bd9Sstevel@tonic-gate "not from terminal and -F not specified:\n%s command " 20387c478bd9Sstevel@tonic-gate "ignored, but exiting anyway."), cmd_to_str(CMD_EXIT)); 20397c478bd9Sstevel@tonic-gate exit(Z_ERR); 20407c478bd9Sstevel@tonic-gate } else if (answer == 1) { 2041bbec428eSgjelinek time_to_exit = B_TRUE; 20427c478bd9Sstevel@tonic-gate } 20437c478bd9Sstevel@tonic-gate /* (answer == 0) => just return */ 20447c478bd9Sstevel@tonic-gate } 20457c478bd9Sstevel@tonic-gate 20467c478bd9Sstevel@tonic-gate static int 20477c478bd9Sstevel@tonic-gate validate_zonepath_syntax(char *path) 20487c478bd9Sstevel@tonic-gate { 20497c478bd9Sstevel@tonic-gate if (path[0] != '/') { 20507c478bd9Sstevel@tonic-gate zerr(gettext("%s is not an absolute path."), path); 20517c478bd9Sstevel@tonic-gate return (Z_ERR); 20527c478bd9Sstevel@tonic-gate } 20536fb06a2bSSusan Kamm-Worrell /* If path is all slashes, then fail */ 20546fb06a2bSSusan Kamm-Worrell if (strspn(path, "/") == strlen(path)) { 20557c478bd9Sstevel@tonic-gate zerr(gettext("/ is not allowed as a %s."), 20567c478bd9Sstevel@tonic-gate pt_to_str(PT_ZONEPATH)); 20577c478bd9Sstevel@tonic-gate return (Z_ERR); 20587c478bd9Sstevel@tonic-gate } 20597c478bd9Sstevel@tonic-gate return (Z_OK); 20607c478bd9Sstevel@tonic-gate } 20617c478bd9Sstevel@tonic-gate 20627c478bd9Sstevel@tonic-gate static void 20637c478bd9Sstevel@tonic-gate add_resource(cmd_t *cmd) 20647c478bd9Sstevel@tonic-gate { 20657c478bd9Sstevel@tonic-gate int type; 20660209230bSgjelinek struct zone_psettab tmp_psettab; 20670209230bSgjelinek struct zone_mcaptab tmp_mcaptab; 2068c97ad5cdSakolb uint64_t tmp; 20690209230bSgjelinek uint64_t tmp_mcap; 20700209230bSgjelinek char pool[MAXNAMELEN]; 20717c478bd9Sstevel@tonic-gate 20727c478bd9Sstevel@tonic-gate if ((type = cmd->cmd_res_type) == RT_UNKNOWN) { 2073bbec428eSgjelinek long_usage(CMD_ADD, B_TRUE); 20747c478bd9Sstevel@tonic-gate goto bad; 20757c478bd9Sstevel@tonic-gate } 20767c478bd9Sstevel@tonic-gate 20777c478bd9Sstevel@tonic-gate switch (type) { 20787c478bd9Sstevel@tonic-gate case RT_FS: 20797c478bd9Sstevel@tonic-gate bzero(&in_progress_fstab, sizeof (in_progress_fstab)); 20807c478bd9Sstevel@tonic-gate return; 20817c478bd9Sstevel@tonic-gate case RT_NET: 20827c478bd9Sstevel@tonic-gate bzero(&in_progress_nwiftab, sizeof (in_progress_nwiftab)); 20837c478bd9Sstevel@tonic-gate return; 20847c478bd9Sstevel@tonic-gate case RT_DEVICE: 20857c478bd9Sstevel@tonic-gate bzero(&in_progress_devtab, sizeof (in_progress_devtab)); 20867c478bd9Sstevel@tonic-gate return; 20877c478bd9Sstevel@tonic-gate case RT_RCTL: 20880209230bSgjelinek if (global_zone) 20890209230bSgjelinek zerr(gettext("WARNING: Setting a global zone resource " 20900209230bSgjelinek "control too low could deny\nservice " 20910209230bSgjelinek "to even the root user; " 20920209230bSgjelinek "this could render the system impossible\n" 20930209230bSgjelinek "to administer. Please use caution.")); 20947c478bd9Sstevel@tonic-gate bzero(&in_progress_rctltab, sizeof (in_progress_rctltab)); 20957c478bd9Sstevel@tonic-gate return; 20967c478bd9Sstevel@tonic-gate case RT_ATTR: 20977c478bd9Sstevel@tonic-gate bzero(&in_progress_attrtab, sizeof (in_progress_attrtab)); 20987c478bd9Sstevel@tonic-gate return; 2099fa9e4066Sahrens case RT_DATASET: 2100fa9e4066Sahrens bzero(&in_progress_dstab, sizeof (in_progress_dstab)); 2101fa9e4066Sahrens return; 21020209230bSgjelinek case RT_DCPU: 2103c97ad5cdSakolb /* Make sure there isn't already a cpu-set or cpu-cap entry. */ 21040209230bSgjelinek if (zonecfg_lookup_pset(handle, &tmp_psettab) == Z_OK) { 21050209230bSgjelinek zerr(gettext("The %s resource already exists."), 21060209230bSgjelinek rt_to_str(RT_DCPU)); 21070209230bSgjelinek goto bad; 21080209230bSgjelinek } 2109c97ad5cdSakolb if (zonecfg_get_aliased_rctl(handle, ALIAS_CPUCAP, &tmp) != 2110c97ad5cdSakolb Z_NO_ENTRY) { 2111c97ad5cdSakolb zerr(gettext("The %s resource already exists."), 2112c97ad5cdSakolb rt_to_str(RT_PCAP)); 2113c97ad5cdSakolb goto bad; 2114c97ad5cdSakolb } 21150209230bSgjelinek 21160209230bSgjelinek /* Make sure the pool property isn't set. */ 21170209230bSgjelinek if (zonecfg_get_pool(handle, pool, sizeof (pool)) == Z_OK && 21180209230bSgjelinek strlen(pool) > 0) { 21190209230bSgjelinek zerr(gettext("The %s property is already set. " 21200209230bSgjelinek "A persistent pool is incompatible with\nthe %s " 21210209230bSgjelinek "resource."), 21220209230bSgjelinek pt_to_str(PT_POOL), rt_to_str(RT_DCPU)); 21230209230bSgjelinek goto bad; 21240209230bSgjelinek } 21250209230bSgjelinek 21260209230bSgjelinek bzero(&in_progress_psettab, sizeof (in_progress_psettab)); 21270209230bSgjelinek return; 2128c97ad5cdSakolb case RT_PCAP: 2129c97ad5cdSakolb /* 2130c97ad5cdSakolb * Make sure there isn't already a cpu-set or incompatible 2131c97ad5cdSakolb * cpu-cap rctls. 2132c97ad5cdSakolb */ 2133c97ad5cdSakolb if (zonecfg_lookup_pset(handle, &tmp_psettab) == Z_OK) { 2134c97ad5cdSakolb zerr(gettext("The %s resource already exists."), 2135c97ad5cdSakolb rt_to_str(RT_DCPU)); 2136c97ad5cdSakolb goto bad; 2137c97ad5cdSakolb } 2138c97ad5cdSakolb 2139c97ad5cdSakolb switch (zonecfg_get_aliased_rctl(handle, ALIAS_CPUCAP, &tmp)) { 2140c97ad5cdSakolb case Z_ALIAS_DISALLOW: 2141c97ad5cdSakolb zone_perror(rt_to_str(RT_PCAP), Z_ALIAS_DISALLOW, 2142bbec428eSgjelinek B_FALSE); 2143c97ad5cdSakolb goto bad; 2144c97ad5cdSakolb 2145c97ad5cdSakolb case Z_OK: 2146c97ad5cdSakolb zerr(gettext("The %s resource already exists."), 2147c97ad5cdSakolb rt_to_str(RT_PCAP)); 2148c97ad5cdSakolb goto bad; 2149c97ad5cdSakolb 2150c97ad5cdSakolb default: 2151c97ad5cdSakolb break; 2152c97ad5cdSakolb } 2153c97ad5cdSakolb return; 21540209230bSgjelinek case RT_MCAP: 21550209230bSgjelinek /* 21560209230bSgjelinek * Make sure there isn't already a mem-cap entry or max-swap 21570209230bSgjelinek * or max-locked rctl. 21580209230bSgjelinek */ 21590209230bSgjelinek if (zonecfg_lookup_mcap(handle, &tmp_mcaptab) == Z_OK || 21600209230bSgjelinek zonecfg_get_aliased_rctl(handle, ALIAS_MAXSWAP, &tmp_mcap) 21610209230bSgjelinek == Z_OK || 21620209230bSgjelinek zonecfg_get_aliased_rctl(handle, ALIAS_MAXLOCKEDMEM, 21630209230bSgjelinek &tmp_mcap) == Z_OK) { 21640209230bSgjelinek zerr(gettext("The %s resource or a related resource " 21650209230bSgjelinek "control already exists."), rt_to_str(RT_MCAP)); 21660209230bSgjelinek goto bad; 21670209230bSgjelinek } 21680209230bSgjelinek if (global_zone) 21690209230bSgjelinek zerr(gettext("WARNING: Setting a global zone memory " 21700209230bSgjelinek "cap too low could deny\nservice " 21710209230bSgjelinek "to even the root user; " 21720209230bSgjelinek "this could render the system impossible\n" 21730209230bSgjelinek "to administer. Please use caution.")); 21740209230bSgjelinek bzero(&in_progress_mcaptab, sizeof (in_progress_mcaptab)); 21750209230bSgjelinek return; 2176cb8a054bSGlenn Faden case RT_ADMIN: 2177cb8a054bSGlenn Faden bzero(&in_progress_admintab, sizeof (in_progress_admintab)); 2178cb8a054bSGlenn Faden return; 21797c478bd9Sstevel@tonic-gate default: 2180bbec428eSgjelinek zone_perror(rt_to_str(type), Z_NO_RESOURCE_TYPE, B_TRUE); 2181bbec428eSgjelinek long_usage(CMD_ADD, B_TRUE); 2182bbec428eSgjelinek usage(B_FALSE, HELP_RESOURCES); 21837c478bd9Sstevel@tonic-gate } 21847c478bd9Sstevel@tonic-gate bad: 2185bbec428eSgjelinek global_scope = B_TRUE; 21867c478bd9Sstevel@tonic-gate end_op = -1; 21877c478bd9Sstevel@tonic-gate } 21887c478bd9Sstevel@tonic-gate 21897c478bd9Sstevel@tonic-gate static void 21907c478bd9Sstevel@tonic-gate do_complex_rctl_val(complex_property_ptr_t cp) 21917c478bd9Sstevel@tonic-gate { 21927c478bd9Sstevel@tonic-gate struct zone_rctlvaltab *rctlvaltab; 21937c478bd9Sstevel@tonic-gate complex_property_ptr_t cx; 2194bbec428eSgjelinek boolean_t seen_priv = B_FALSE, seen_limit = B_FALSE, 2195bbec428eSgjelinek seen_action = B_FALSE; 21967c478bd9Sstevel@tonic-gate rctlblk_t *rctlblk; 21977c478bd9Sstevel@tonic-gate int err; 21987c478bd9Sstevel@tonic-gate 21997c478bd9Sstevel@tonic-gate if ((rctlvaltab = alloc_rctlvaltab()) == NULL) { 2200bbec428eSgjelinek zone_perror(zone, Z_NOMEM, B_TRUE); 22017c478bd9Sstevel@tonic-gate exit(Z_ERR); 22027c478bd9Sstevel@tonic-gate } 22037c478bd9Sstevel@tonic-gate for (cx = cp; cx != NULL; cx = cx->cp_next) { 22047c478bd9Sstevel@tonic-gate switch (cx->cp_type) { 22057c478bd9Sstevel@tonic-gate case PT_PRIV: 22067c478bd9Sstevel@tonic-gate if (seen_priv) { 22077c478bd9Sstevel@tonic-gate zerr(gettext("%s already specified"), 22087c478bd9Sstevel@tonic-gate pt_to_str(PT_PRIV)); 22097c478bd9Sstevel@tonic-gate goto bad; 22107c478bd9Sstevel@tonic-gate } 22117c478bd9Sstevel@tonic-gate (void) strlcpy(rctlvaltab->zone_rctlval_priv, 22127c478bd9Sstevel@tonic-gate cx->cp_value, 22137c478bd9Sstevel@tonic-gate sizeof (rctlvaltab->zone_rctlval_priv)); 2214bbec428eSgjelinek seen_priv = B_TRUE; 22157c478bd9Sstevel@tonic-gate break; 22167c478bd9Sstevel@tonic-gate case PT_LIMIT: 22177c478bd9Sstevel@tonic-gate if (seen_limit) { 22187c478bd9Sstevel@tonic-gate zerr(gettext("%s already specified"), 22197c478bd9Sstevel@tonic-gate pt_to_str(PT_LIMIT)); 22207c478bd9Sstevel@tonic-gate goto bad; 22217c478bd9Sstevel@tonic-gate } 22227c478bd9Sstevel@tonic-gate (void) strlcpy(rctlvaltab->zone_rctlval_limit, 22237c478bd9Sstevel@tonic-gate cx->cp_value, 22247c478bd9Sstevel@tonic-gate sizeof (rctlvaltab->zone_rctlval_limit)); 2225bbec428eSgjelinek seen_limit = B_TRUE; 22267c478bd9Sstevel@tonic-gate break; 22277c478bd9Sstevel@tonic-gate case PT_ACTION: 22287c478bd9Sstevel@tonic-gate if (seen_action) { 22297c478bd9Sstevel@tonic-gate zerr(gettext("%s already specified"), 22307c478bd9Sstevel@tonic-gate pt_to_str(PT_ACTION)); 22317c478bd9Sstevel@tonic-gate goto bad; 22327c478bd9Sstevel@tonic-gate } 22337c478bd9Sstevel@tonic-gate (void) strlcpy(rctlvaltab->zone_rctlval_action, 22347c478bd9Sstevel@tonic-gate cx->cp_value, 22357c478bd9Sstevel@tonic-gate sizeof (rctlvaltab->zone_rctlval_action)); 2236bbec428eSgjelinek seen_action = B_TRUE; 22377c478bd9Sstevel@tonic-gate break; 22387c478bd9Sstevel@tonic-gate default: 22397c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(PT_VALUE), 2240bbec428eSgjelinek Z_NO_PROPERTY_TYPE, B_TRUE); 2241bbec428eSgjelinek long_usage(CMD_ADD, B_TRUE); 2242bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 22437c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctlvaltab); 22447c478bd9Sstevel@tonic-gate return; 22457c478bd9Sstevel@tonic-gate } 22467c478bd9Sstevel@tonic-gate } 22477c478bd9Sstevel@tonic-gate if (!seen_priv) 22487c478bd9Sstevel@tonic-gate zerr(gettext("%s not specified"), pt_to_str(PT_PRIV)); 22497c478bd9Sstevel@tonic-gate if (!seen_limit) 22507c478bd9Sstevel@tonic-gate zerr(gettext("%s not specified"), pt_to_str(PT_LIMIT)); 22517c478bd9Sstevel@tonic-gate if (!seen_action) 22527c478bd9Sstevel@tonic-gate zerr(gettext("%s not specified"), pt_to_str(PT_ACTION)); 22537c478bd9Sstevel@tonic-gate if (!seen_priv || !seen_limit || !seen_action) 22547c478bd9Sstevel@tonic-gate goto bad; 22557c478bd9Sstevel@tonic-gate rctlvaltab->zone_rctlval_next = NULL; 22567c478bd9Sstevel@tonic-gate rctlblk = alloca(rctlblk_size()); 22577c478bd9Sstevel@tonic-gate /* 22587c478bd9Sstevel@tonic-gate * Make sure the rctl value looks roughly correct; we won't know if 22597c478bd9Sstevel@tonic-gate * it's truly OK until we verify the configuration on the target 22607c478bd9Sstevel@tonic-gate * system. 22617c478bd9Sstevel@tonic-gate */ 22627c478bd9Sstevel@tonic-gate if (zonecfg_construct_rctlblk(rctlvaltab, rctlblk) != Z_OK || 22637c478bd9Sstevel@tonic-gate !zonecfg_valid_rctlblk(rctlblk)) { 22647c478bd9Sstevel@tonic-gate zerr(gettext("Invalid %s %s specification"), rt_to_str(RT_RCTL), 22657c478bd9Sstevel@tonic-gate pt_to_str(PT_VALUE)); 22667c478bd9Sstevel@tonic-gate goto bad; 22677c478bd9Sstevel@tonic-gate } 22687c478bd9Sstevel@tonic-gate err = zonecfg_add_rctl_value(&in_progress_rctltab, rctlvaltab); 22697c478bd9Sstevel@tonic-gate if (err != Z_OK) 2270bbec428eSgjelinek zone_perror(pt_to_str(PT_VALUE), err, B_TRUE); 22717c478bd9Sstevel@tonic-gate return; 22727c478bd9Sstevel@tonic-gate 22737c478bd9Sstevel@tonic-gate bad: 22747c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctlvaltab); 22757c478bd9Sstevel@tonic-gate } 22767c478bd9Sstevel@tonic-gate 22777c478bd9Sstevel@tonic-gate static void 22787c478bd9Sstevel@tonic-gate add_property(cmd_t *cmd) 22797c478bd9Sstevel@tonic-gate { 22807c478bd9Sstevel@tonic-gate char *prop_id; 22817c478bd9Sstevel@tonic-gate int err, res_type, prop_type; 22827c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 22837c478bd9Sstevel@tonic-gate list_property_ptr_t l; 22847c478bd9Sstevel@tonic-gate 22857c478bd9Sstevel@tonic-gate res_type = resource_scope; 22867c478bd9Sstevel@tonic-gate prop_type = cmd->cmd_prop_name[0]; 22877c478bd9Sstevel@tonic-gate if (res_type == RT_UNKNOWN || prop_type == PT_UNKNOWN) { 2288bbec428eSgjelinek long_usage(CMD_ADD, B_TRUE); 22897c478bd9Sstevel@tonic-gate return; 22907c478bd9Sstevel@tonic-gate } 22917c478bd9Sstevel@tonic-gate 22927c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs != 1) { 2293bbec428eSgjelinek long_usage(CMD_ADD, B_TRUE); 22947c478bd9Sstevel@tonic-gate return; 22957c478bd9Sstevel@tonic-gate } 22967c478bd9Sstevel@tonic-gate 2297bbec428eSgjelinek if (initialize(B_TRUE) != Z_OK) 22987c478bd9Sstevel@tonic-gate return; 22997c478bd9Sstevel@tonic-gate 23007c478bd9Sstevel@tonic-gate switch (res_type) { 23017c478bd9Sstevel@tonic-gate case RT_FS: 23027c478bd9Sstevel@tonic-gate if (prop_type != PT_OPTIONS) { 23037c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 2304bbec428eSgjelinek B_TRUE); 2305bbec428eSgjelinek long_usage(CMD_ADD, B_TRUE); 2306bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 23077c478bd9Sstevel@tonic-gate return; 23087c478bd9Sstevel@tonic-gate } 23097c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[0]; 23107c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE && 23117c478bd9Sstevel@tonic-gate pp->pv_type != PROP_VAL_LIST) { 23127c478bd9Sstevel@tonic-gate zerr(gettext("A %s or %s value was expected here."), 23137c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_SIMPLE), 23147c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_LIST)); 2315bbec428eSgjelinek saw_error = B_TRUE; 23167c478bd9Sstevel@tonic-gate return; 23177c478bd9Sstevel@tonic-gate } 23187c478bd9Sstevel@tonic-gate if (pp->pv_type == PROP_VAL_SIMPLE) { 23197c478bd9Sstevel@tonic-gate if (pp->pv_simple == NULL) { 2320bbec428eSgjelinek long_usage(CMD_ADD, B_TRUE); 23217c478bd9Sstevel@tonic-gate return; 23227c478bd9Sstevel@tonic-gate } 23237c478bd9Sstevel@tonic-gate prop_id = pp->pv_simple; 23247c478bd9Sstevel@tonic-gate err = zonecfg_add_fs_option(&in_progress_fstab, 23257c478bd9Sstevel@tonic-gate prop_id); 23267c478bd9Sstevel@tonic-gate if (err != Z_OK) 2327bbec428eSgjelinek zone_perror(pt_to_str(prop_type), err, B_TRUE); 23287c478bd9Sstevel@tonic-gate } else { 23297c478bd9Sstevel@tonic-gate list_property_ptr_t list; 23307c478bd9Sstevel@tonic-gate 23317c478bd9Sstevel@tonic-gate for (list = pp->pv_list; list != NULL; 23327c478bd9Sstevel@tonic-gate list = list->lp_next) { 23337c478bd9Sstevel@tonic-gate prop_id = list->lp_simple; 23347c478bd9Sstevel@tonic-gate if (prop_id == NULL) 23357c478bd9Sstevel@tonic-gate break; 23367c478bd9Sstevel@tonic-gate err = zonecfg_add_fs_option( 23377c478bd9Sstevel@tonic-gate &in_progress_fstab, prop_id); 23387c478bd9Sstevel@tonic-gate if (err != Z_OK) 23397c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), err, 2340bbec428eSgjelinek B_TRUE); 23417c478bd9Sstevel@tonic-gate } 23427c478bd9Sstevel@tonic-gate } 23437c478bd9Sstevel@tonic-gate return; 23447c478bd9Sstevel@tonic-gate case RT_RCTL: 23457c478bd9Sstevel@tonic-gate if (prop_type != PT_VALUE) { 23467c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 2347bbec428eSgjelinek B_TRUE); 2348bbec428eSgjelinek long_usage(CMD_ADD, B_TRUE); 2349bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 23507c478bd9Sstevel@tonic-gate return; 23517c478bd9Sstevel@tonic-gate } 23527c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[0]; 23537c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_COMPLEX && 23547c478bd9Sstevel@tonic-gate pp->pv_type != PROP_VAL_LIST) { 23557c478bd9Sstevel@tonic-gate zerr(gettext("A %s or %s value was expected here."), 23567c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_COMPLEX), 23577c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_LIST)); 2358bbec428eSgjelinek saw_error = B_TRUE; 23597c478bd9Sstevel@tonic-gate return; 23607c478bd9Sstevel@tonic-gate } 23617c478bd9Sstevel@tonic-gate if (pp->pv_type == PROP_VAL_COMPLEX) { 23627c478bd9Sstevel@tonic-gate do_complex_rctl_val(pp->pv_complex); 23637c478bd9Sstevel@tonic-gate return; 23647c478bd9Sstevel@tonic-gate } 23657c478bd9Sstevel@tonic-gate for (l = pp->pv_list; l != NULL; l = l->lp_next) 23667c478bd9Sstevel@tonic-gate do_complex_rctl_val(l->lp_complex); 23677c478bd9Sstevel@tonic-gate return; 23687c478bd9Sstevel@tonic-gate default: 2369bbec428eSgjelinek zone_perror(rt_to_str(res_type), Z_NO_RESOURCE_TYPE, B_TRUE); 2370bbec428eSgjelinek long_usage(CMD_ADD, B_TRUE); 2371bbec428eSgjelinek usage(B_FALSE, HELP_RESOURCES); 23727c478bd9Sstevel@tonic-gate return; 23737c478bd9Sstevel@tonic-gate } 23747c478bd9Sstevel@tonic-gate } 23757c478bd9Sstevel@tonic-gate 23760209230bSgjelinek static boolean_t 23770209230bSgjelinek gz_invalid_resource(int type) 23780209230bSgjelinek { 23796e1ae2a3SGary Pennington return (global_zone && (type == RT_FS || 23800209230bSgjelinek type == RT_NET || type == RT_DEVICE || type == RT_ATTR || 23810209230bSgjelinek type == RT_DATASET)); 23820209230bSgjelinek } 23830209230bSgjelinek 23840209230bSgjelinek static boolean_t 23850209230bSgjelinek gz_invalid_rt_property(int type) 23860209230bSgjelinek { 23870209230bSgjelinek return (global_zone && (type == RT_ZONENAME || type == RT_ZONEPATH || 23880209230bSgjelinek type == RT_AUTOBOOT || type == RT_LIMITPRIV || 2389f4b3ec61Sdh155122 type == RT_BOOTARGS || type == RT_BRAND || type == RT_SCHED || 23900fbb751dSJohn Levon type == RT_IPTYPE || type == RT_HOSTID || type == RT_FS_ALLOWED)); 23910209230bSgjelinek } 23920209230bSgjelinek 23930209230bSgjelinek static boolean_t 23940209230bSgjelinek gz_invalid_property(int type) 23950209230bSgjelinek { 23960209230bSgjelinek return (global_zone && (type == PT_ZONENAME || type == PT_ZONEPATH || 23970209230bSgjelinek type == PT_AUTOBOOT || type == PT_LIMITPRIV || 2398f4b3ec61Sdh155122 type == PT_BOOTARGS || type == PT_BRAND || type == PT_SCHED || 23990fbb751dSJohn Levon type == PT_IPTYPE || type == PT_HOSTID || type == PT_FS_ALLOWED)); 24000209230bSgjelinek } 24010209230bSgjelinek 24027c478bd9Sstevel@tonic-gate void 24037c478bd9Sstevel@tonic-gate add_func(cmd_t *cmd) 24047c478bd9Sstevel@tonic-gate { 24057c478bd9Sstevel@tonic-gate int arg; 2406bbec428eSgjelinek boolean_t arg_err = B_FALSE; 24077c478bd9Sstevel@tonic-gate 24087c478bd9Sstevel@tonic-gate assert(cmd != NULL); 24097c478bd9Sstevel@tonic-gate 24107c478bd9Sstevel@tonic-gate optind = 0; 24117ec75eb8Sgjelinek while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?")) != EOF) { 24127c478bd9Sstevel@tonic-gate switch (arg) { 24137c478bd9Sstevel@tonic-gate case '?': 24147c478bd9Sstevel@tonic-gate longer_usage(CMD_ADD); 2415bbec428eSgjelinek arg_err = B_TRUE; 24167ec75eb8Sgjelinek break; 24177c478bd9Sstevel@tonic-gate default: 24187c478bd9Sstevel@tonic-gate short_usage(CMD_ADD); 2419bbec428eSgjelinek arg_err = B_TRUE; 24207ec75eb8Sgjelinek break; 24217ec75eb8Sgjelinek } 24227ec75eb8Sgjelinek } 24237ec75eb8Sgjelinek if (arg_err) 24247c478bd9Sstevel@tonic-gate return; 24257ec75eb8Sgjelinek 24267c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 24277c478bd9Sstevel@tonic-gate short_usage(CMD_ADD); 24287c478bd9Sstevel@tonic-gate return; 24297c478bd9Sstevel@tonic-gate } 24307c478bd9Sstevel@tonic-gate 24317c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_ADD)) 24327c478bd9Sstevel@tonic-gate return; 24337c478bd9Sstevel@tonic-gate 2434bbec428eSgjelinek if (initialize(B_TRUE) != Z_OK) 24357c478bd9Sstevel@tonic-gate return; 24367c478bd9Sstevel@tonic-gate if (global_scope) { 24370209230bSgjelinek if (gz_invalid_resource(cmd->cmd_res_type)) { 24380209230bSgjelinek zerr(gettext("Cannot add a %s resource to the " 24390209230bSgjelinek "global zone."), rt_to_str(cmd->cmd_res_type)); 2440bbec428eSgjelinek saw_error = B_TRUE; 24410209230bSgjelinek return; 24420209230bSgjelinek } 24430209230bSgjelinek 2444bbec428eSgjelinek global_scope = B_FALSE; 24457c478bd9Sstevel@tonic-gate resource_scope = cmd->cmd_res_type; 24467c478bd9Sstevel@tonic-gate end_op = CMD_ADD; 24477c478bd9Sstevel@tonic-gate add_resource(cmd); 24487c478bd9Sstevel@tonic-gate } else 24497c478bd9Sstevel@tonic-gate add_property(cmd); 24507c478bd9Sstevel@tonic-gate } 24517c478bd9Sstevel@tonic-gate 2452087719fdSdp /* 2453087719fdSdp * This routine has an unusual implementation, because it tries very 2454087719fdSdp * hard to succeed in the face of a variety of failure modes. 2455087719fdSdp * The most common and most vexing occurs when the index file and 2456087719fdSdp * the /etc/zones/<zonename.xml> file are not both present. In 2457087719fdSdp * this case, delete must eradicate as much of the zone state as is left 2458087719fdSdp * so that the user can later create a new zone with the same name. 2459087719fdSdp */ 24607c478bd9Sstevel@tonic-gate void 24617c478bd9Sstevel@tonic-gate delete_func(cmd_t *cmd) 24627c478bd9Sstevel@tonic-gate { 24637c478bd9Sstevel@tonic-gate int err, arg, answer; 24647c478bd9Sstevel@tonic-gate char line[ZONENAME_MAX + 128]; /* enough to ask a question */ 2465bbec428eSgjelinek boolean_t force = B_FALSE; 2466bbec428eSgjelinek boolean_t arg_err = B_FALSE; 24677c478bd9Sstevel@tonic-gate 24687c478bd9Sstevel@tonic-gate optind = 0; 24697c478bd9Sstevel@tonic-gate while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?F")) != EOF) { 24707c478bd9Sstevel@tonic-gate switch (arg) { 24717c478bd9Sstevel@tonic-gate case '?': 24727c478bd9Sstevel@tonic-gate longer_usage(CMD_DELETE); 2473bbec428eSgjelinek arg_err = B_TRUE; 24747ec75eb8Sgjelinek break; 24757c478bd9Sstevel@tonic-gate case 'F': 2476bbec428eSgjelinek force = B_TRUE; 24777c478bd9Sstevel@tonic-gate break; 24787c478bd9Sstevel@tonic-gate default: 24797c478bd9Sstevel@tonic-gate short_usage(CMD_DELETE); 2480bbec428eSgjelinek arg_err = B_TRUE; 24817ec75eb8Sgjelinek break; 24827ec75eb8Sgjelinek } 24837ec75eb8Sgjelinek } 24847ec75eb8Sgjelinek if (arg_err) 24857c478bd9Sstevel@tonic-gate return; 24867ec75eb8Sgjelinek 24877c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 24887c478bd9Sstevel@tonic-gate short_usage(CMD_DELETE); 24897c478bd9Sstevel@tonic-gate return; 24907c478bd9Sstevel@tonic-gate } 24917c478bd9Sstevel@tonic-gate 24927c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_DELETE)) 24937c478bd9Sstevel@tonic-gate return; 24947c478bd9Sstevel@tonic-gate 2495087719fdSdp if (!force) { 2496087719fdSdp /* 2497087719fdSdp * Initialize sets up the global called "handle" and warns the 2498087719fdSdp * user if the zone is not configured. In force mode, we don't 2499087719fdSdp * trust that evaluation, and hence skip it. (We don't need the 2500087719fdSdp * handle to be loaded anyway, since zonecfg_destroy is done by 2501087719fdSdp * zonename). However, we also have to take care to emulate the 2502087719fdSdp * messages spit out by initialize; see below. 2503087719fdSdp */ 2504bbec428eSgjelinek if (initialize(B_TRUE) != Z_OK) 25057c478bd9Sstevel@tonic-gate return; 25067c478bd9Sstevel@tonic-gate 25077c478bd9Sstevel@tonic-gate (void) snprintf(line, sizeof (line), 25087c478bd9Sstevel@tonic-gate gettext("Are you sure you want to delete zone %s"), zone); 2509bbec428eSgjelinek if ((answer = ask_yesno(B_FALSE, line)) == -1) { 2510087719fdSdp zerr(gettext("Input not from terminal and -F not " 2511087719fdSdp "specified:\n%s command ignored, exiting."), 2512087719fdSdp cmd_to_str(CMD_DELETE)); 25137c478bd9Sstevel@tonic-gate exit(Z_ERR); 25147c478bd9Sstevel@tonic-gate } 25157c478bd9Sstevel@tonic-gate if (answer != 1) 25167c478bd9Sstevel@tonic-gate return; 25177c478bd9Sstevel@tonic-gate } 25187c478bd9Sstevel@tonic-gate 2519cb8a054bSGlenn Faden /* 2520cb8a054bSGlenn Faden * This function removes the authorizations from user_attr 2521cb8a054bSGlenn Faden * that correspond to those specified in the configuration 2522cb8a054bSGlenn Faden */ 2523cb8a054bSGlenn Faden if (initialize(B_TRUE) == Z_OK) { 2524cb8a054bSGlenn Faden (void) zonecfg_deauthorize_users(handle, zone); 2525cb8a054bSGlenn Faden } 2526087719fdSdp if ((err = zonecfg_destroy(zone, force)) != Z_OK) { 2527087719fdSdp if ((err == Z_BAD_ZONE_STATE) && !force) { 2528087719fdSdp zerr(gettext("Zone %s not in %s state; %s not " 2529087719fdSdp "allowed. Use -F to force %s."), 2530087719fdSdp zone, zone_state_str(ZONE_STATE_CONFIGURED), 2531087719fdSdp cmd_to_str(CMD_DELETE), cmd_to_str(CMD_DELETE)); 2532087719fdSdp } else { 2533bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 25347c478bd9Sstevel@tonic-gate } 2535087719fdSdp } 2536bbec428eSgjelinek need_to_commit = B_FALSE; 2537087719fdSdp 2538087719fdSdp /* 2539087719fdSdp * Emulate initialize's messaging; if there wasn't a valid handle to 2540087719fdSdp * begin with, then user had typed delete (or delete -F) multiple 2541087719fdSdp * times. So we emit a message. 2542087719fdSdp * 2543087719fdSdp * We only do this in the 'force' case because normally, initialize() 2544087719fdSdp * takes care of this for us. 2545087719fdSdp */ 2546087719fdSdp if (force && zonecfg_check_handle(handle) != Z_OK && interactive_mode) 2547087719fdSdp (void) printf(gettext("Use '%s' to begin " 2548087719fdSdp "configuring a new zone.\n"), cmd_to_str(CMD_CREATE)); 25497c478bd9Sstevel@tonic-gate 25507c478bd9Sstevel@tonic-gate /* 25517c478bd9Sstevel@tonic-gate * Time for a new handle: finish the old one off first 25527c478bd9Sstevel@tonic-gate * then get a new one properly to avoid leaks. 25537c478bd9Sstevel@tonic-gate */ 2554087719fdSdp if (got_handle) { 25557c478bd9Sstevel@tonic-gate zonecfg_fini_handle(handle); 25567c478bd9Sstevel@tonic-gate if ((handle = zonecfg_init_handle()) == NULL) { 2557bbec428eSgjelinek zone_perror(execname, Z_NOMEM, B_TRUE); 25587c478bd9Sstevel@tonic-gate exit(Z_ERR); 25597c478bd9Sstevel@tonic-gate } 25607c478bd9Sstevel@tonic-gate if ((err = zonecfg_get_handle(zone, handle)) != Z_OK) { 25617c478bd9Sstevel@tonic-gate /* If there was no zone before, that's OK */ 25627c478bd9Sstevel@tonic-gate if (err != Z_NO_ZONE) 2563bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 2564bbec428eSgjelinek got_handle = B_FALSE; 25657c478bd9Sstevel@tonic-gate } 25667c478bd9Sstevel@tonic-gate } 2567087719fdSdp } 25687c478bd9Sstevel@tonic-gate 25697c478bd9Sstevel@tonic-gate static int 2570bbec428eSgjelinek fill_in_fstab(cmd_t *cmd, struct zone_fstab *fstab, boolean_t fill_in_only) 25717c478bd9Sstevel@tonic-gate { 25727c478bd9Sstevel@tonic-gate int err, i; 25737c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 25747c478bd9Sstevel@tonic-gate 2575bbec428eSgjelinek if ((err = initialize(B_TRUE)) != Z_OK) 25767c478bd9Sstevel@tonic-gate return (err); 25777c478bd9Sstevel@tonic-gate 2578e193d1e6Svp157776 bzero(fstab, sizeof (*fstab)); 25797c478bd9Sstevel@tonic-gate for (i = 0; i < cmd->cmd_prop_nv_pairs; i++) { 25807c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[i]; 25817c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE || pp->pv_simple == NULL) { 25827c478bd9Sstevel@tonic-gate zerr(gettext("A simple value was expected here.")); 2583bbec428eSgjelinek saw_error = B_TRUE; 25847c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 25857c478bd9Sstevel@tonic-gate } 25867c478bd9Sstevel@tonic-gate switch (cmd->cmd_prop_name[i]) { 25877c478bd9Sstevel@tonic-gate case PT_DIR: 25887c478bd9Sstevel@tonic-gate (void) strlcpy(fstab->zone_fs_dir, pp->pv_simple, 25897c478bd9Sstevel@tonic-gate sizeof (fstab->zone_fs_dir)); 25907c478bd9Sstevel@tonic-gate break; 25917c478bd9Sstevel@tonic-gate case PT_SPECIAL: 25927c478bd9Sstevel@tonic-gate (void) strlcpy(fstab->zone_fs_special, pp->pv_simple, 25937c478bd9Sstevel@tonic-gate sizeof (fstab->zone_fs_special)); 25947c478bd9Sstevel@tonic-gate break; 25957c478bd9Sstevel@tonic-gate case PT_RAW: 25967c478bd9Sstevel@tonic-gate (void) strlcpy(fstab->zone_fs_raw, pp->pv_simple, 25977c478bd9Sstevel@tonic-gate sizeof (fstab->zone_fs_raw)); 25987c478bd9Sstevel@tonic-gate break; 25997c478bd9Sstevel@tonic-gate case PT_TYPE: 26007c478bd9Sstevel@tonic-gate (void) strlcpy(fstab->zone_fs_type, pp->pv_simple, 26017c478bd9Sstevel@tonic-gate sizeof (fstab->zone_fs_type)); 26027c478bd9Sstevel@tonic-gate break; 26037c478bd9Sstevel@tonic-gate default: 26047c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(cmd->cmd_prop_name[i]), 2605bbec428eSgjelinek Z_NO_PROPERTY_TYPE, B_TRUE); 26067c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 26077c478bd9Sstevel@tonic-gate } 26087c478bd9Sstevel@tonic-gate } 26097c478bd9Sstevel@tonic-gate if (fill_in_only) 26107c478bd9Sstevel@tonic-gate return (Z_OK); 26117c478bd9Sstevel@tonic-gate return (zonecfg_lookup_filesystem(handle, fstab)); 26127c478bd9Sstevel@tonic-gate } 26137c478bd9Sstevel@tonic-gate 26147c478bd9Sstevel@tonic-gate static int 2615bbec428eSgjelinek fill_in_nwiftab(cmd_t *cmd, struct zone_nwiftab *nwiftab, 2616bbec428eSgjelinek boolean_t fill_in_only) 26177c478bd9Sstevel@tonic-gate { 26187c478bd9Sstevel@tonic-gate int err, i; 26197c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 26207c478bd9Sstevel@tonic-gate 2621bbec428eSgjelinek if ((err = initialize(B_TRUE)) != Z_OK) 26227c478bd9Sstevel@tonic-gate return (err); 26237c478bd9Sstevel@tonic-gate 2624e193d1e6Svp157776 bzero(nwiftab, sizeof (*nwiftab)); 26257c478bd9Sstevel@tonic-gate for (i = 0; i < cmd->cmd_prop_nv_pairs; i++) { 26267c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[i]; 26277c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE || pp->pv_simple == NULL) { 26287c478bd9Sstevel@tonic-gate zerr(gettext("A simple value was expected here.")); 2629bbec428eSgjelinek saw_error = B_TRUE; 26307c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 26317c478bd9Sstevel@tonic-gate } 26327c478bd9Sstevel@tonic-gate switch (cmd->cmd_prop_name[i]) { 26337c478bd9Sstevel@tonic-gate case PT_ADDRESS: 26347c478bd9Sstevel@tonic-gate (void) strlcpy(nwiftab->zone_nwif_address, 26357c478bd9Sstevel@tonic-gate pp->pv_simple, sizeof (nwiftab->zone_nwif_address)); 26367c478bd9Sstevel@tonic-gate break; 2637550b6e40SSowmini Varadhan case PT_ALLOWED_ADDRESS: 2638550b6e40SSowmini Varadhan (void) strlcpy(nwiftab->zone_nwif_allowed_address, 2639550b6e40SSowmini Varadhan pp->pv_simple, 2640550b6e40SSowmini Varadhan sizeof (nwiftab->zone_nwif_allowed_address)); 2641550b6e40SSowmini Varadhan break; 26427c478bd9Sstevel@tonic-gate case PT_PHYSICAL: 26437c478bd9Sstevel@tonic-gate (void) strlcpy(nwiftab->zone_nwif_physical, 26447c478bd9Sstevel@tonic-gate pp->pv_simple, 26457c478bd9Sstevel@tonic-gate sizeof (nwiftab->zone_nwif_physical)); 26467c478bd9Sstevel@tonic-gate break; 2647de860bd9Sgfaden case PT_DEFROUTER: 2648de860bd9Sgfaden (void) strlcpy(nwiftab->zone_nwif_defrouter, 2649de860bd9Sgfaden pp->pv_simple, 2650de860bd9Sgfaden sizeof (nwiftab->zone_nwif_defrouter)); 2651de860bd9Sgfaden break; 26527c478bd9Sstevel@tonic-gate default: 26537c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(cmd->cmd_prop_name[i]), 2654bbec428eSgjelinek Z_NO_PROPERTY_TYPE, B_TRUE); 26557c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 26567c478bd9Sstevel@tonic-gate } 26577c478bd9Sstevel@tonic-gate } 26587c478bd9Sstevel@tonic-gate if (fill_in_only) 26597c478bd9Sstevel@tonic-gate return (Z_OK); 26607c478bd9Sstevel@tonic-gate err = zonecfg_lookup_nwif(handle, nwiftab); 26617c478bd9Sstevel@tonic-gate return (err); 26627c478bd9Sstevel@tonic-gate } 26637c478bd9Sstevel@tonic-gate 26647c478bd9Sstevel@tonic-gate static int 2665bbec428eSgjelinek fill_in_devtab(cmd_t *cmd, struct zone_devtab *devtab, boolean_t fill_in_only) 26667c478bd9Sstevel@tonic-gate { 26677c478bd9Sstevel@tonic-gate int err, i; 26687c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 26697c478bd9Sstevel@tonic-gate 2670bbec428eSgjelinek if ((err = initialize(B_TRUE)) != Z_OK) 26717c478bd9Sstevel@tonic-gate return (err); 26727c478bd9Sstevel@tonic-gate 2673e193d1e6Svp157776 bzero(devtab, sizeof (*devtab)); 26747c478bd9Sstevel@tonic-gate for (i = 0; i < cmd->cmd_prop_nv_pairs; i++) { 26757c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[i]; 26767c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE || pp->pv_simple == NULL) { 26777c478bd9Sstevel@tonic-gate zerr(gettext("A simple value was expected here.")); 2678bbec428eSgjelinek saw_error = B_TRUE; 26797c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 26807c478bd9Sstevel@tonic-gate } 26817c478bd9Sstevel@tonic-gate switch (cmd->cmd_prop_name[i]) { 26827c478bd9Sstevel@tonic-gate case PT_MATCH: 26837c478bd9Sstevel@tonic-gate (void) strlcpy(devtab->zone_dev_match, pp->pv_simple, 26847c478bd9Sstevel@tonic-gate sizeof (devtab->zone_dev_match)); 26857c478bd9Sstevel@tonic-gate break; 26867c478bd9Sstevel@tonic-gate default: 26877c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(cmd->cmd_prop_name[i]), 2688bbec428eSgjelinek Z_NO_PROPERTY_TYPE, B_TRUE); 26897c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 26907c478bd9Sstevel@tonic-gate } 26917c478bd9Sstevel@tonic-gate } 26927c478bd9Sstevel@tonic-gate if (fill_in_only) 26937c478bd9Sstevel@tonic-gate return (Z_OK); 26947c478bd9Sstevel@tonic-gate err = zonecfg_lookup_dev(handle, devtab); 26957c478bd9Sstevel@tonic-gate return (err); 26967c478bd9Sstevel@tonic-gate } 26977c478bd9Sstevel@tonic-gate 26987c478bd9Sstevel@tonic-gate static int 2699bbec428eSgjelinek fill_in_rctltab(cmd_t *cmd, struct zone_rctltab *rctltab, 2700bbec428eSgjelinek boolean_t fill_in_only) 27017c478bd9Sstevel@tonic-gate { 27027c478bd9Sstevel@tonic-gate int err, i; 27037c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 27047c478bd9Sstevel@tonic-gate 2705bbec428eSgjelinek if ((err = initialize(B_TRUE)) != Z_OK) 27067c478bd9Sstevel@tonic-gate return (err); 27077c478bd9Sstevel@tonic-gate 2708e193d1e6Svp157776 bzero(rctltab, sizeof (*rctltab)); 27097c478bd9Sstevel@tonic-gate for (i = 0; i < cmd->cmd_prop_nv_pairs; i++) { 27107c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[i]; 27117c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE || pp->pv_simple == NULL) { 27127c478bd9Sstevel@tonic-gate zerr(gettext("A simple value was expected here.")); 2713bbec428eSgjelinek saw_error = B_TRUE; 27147c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 27157c478bd9Sstevel@tonic-gate } 27167c478bd9Sstevel@tonic-gate switch (cmd->cmd_prop_name[i]) { 27177c478bd9Sstevel@tonic-gate case PT_NAME: 27187c478bd9Sstevel@tonic-gate (void) strlcpy(rctltab->zone_rctl_name, pp->pv_simple, 27197c478bd9Sstevel@tonic-gate sizeof (rctltab->zone_rctl_name)); 27207c478bd9Sstevel@tonic-gate break; 27217c478bd9Sstevel@tonic-gate default: 27227c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(cmd->cmd_prop_name[i]), 2723bbec428eSgjelinek Z_NO_PROPERTY_TYPE, B_TRUE); 27247c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 27257c478bd9Sstevel@tonic-gate } 27267c478bd9Sstevel@tonic-gate } 27277c478bd9Sstevel@tonic-gate if (fill_in_only) 27287c478bd9Sstevel@tonic-gate return (Z_OK); 27297c478bd9Sstevel@tonic-gate err = zonecfg_lookup_rctl(handle, rctltab); 27307c478bd9Sstevel@tonic-gate return (err); 27317c478bd9Sstevel@tonic-gate } 27327c478bd9Sstevel@tonic-gate 27337c478bd9Sstevel@tonic-gate static int 2734bbec428eSgjelinek fill_in_attrtab(cmd_t *cmd, struct zone_attrtab *attrtab, 2735bbec428eSgjelinek boolean_t fill_in_only) 27367c478bd9Sstevel@tonic-gate { 27377c478bd9Sstevel@tonic-gate int err, i; 27387c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 27397c478bd9Sstevel@tonic-gate 2740bbec428eSgjelinek if ((err = initialize(B_TRUE)) != Z_OK) 27417c478bd9Sstevel@tonic-gate return (err); 27427c478bd9Sstevel@tonic-gate 2743e193d1e6Svp157776 bzero(attrtab, sizeof (*attrtab)); 27447c478bd9Sstevel@tonic-gate for (i = 0; i < cmd->cmd_prop_nv_pairs; i++) { 27457c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[i]; 27467c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE || pp->pv_simple == NULL) { 27477c478bd9Sstevel@tonic-gate zerr(gettext("A simple value was expected here.")); 2748bbec428eSgjelinek saw_error = B_TRUE; 27497c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 27507c478bd9Sstevel@tonic-gate } 27517c478bd9Sstevel@tonic-gate switch (cmd->cmd_prop_name[i]) { 27527c478bd9Sstevel@tonic-gate case PT_NAME: 27537c478bd9Sstevel@tonic-gate (void) strlcpy(attrtab->zone_attr_name, pp->pv_simple, 27547c478bd9Sstevel@tonic-gate sizeof (attrtab->zone_attr_name)); 27557c478bd9Sstevel@tonic-gate break; 27567c478bd9Sstevel@tonic-gate case PT_TYPE: 27577c478bd9Sstevel@tonic-gate (void) strlcpy(attrtab->zone_attr_type, pp->pv_simple, 27587c478bd9Sstevel@tonic-gate sizeof (attrtab->zone_attr_type)); 27597c478bd9Sstevel@tonic-gate break; 27607c478bd9Sstevel@tonic-gate case PT_VALUE: 27617c478bd9Sstevel@tonic-gate (void) strlcpy(attrtab->zone_attr_value, pp->pv_simple, 27627c478bd9Sstevel@tonic-gate sizeof (attrtab->zone_attr_value)); 27637c478bd9Sstevel@tonic-gate break; 27647c478bd9Sstevel@tonic-gate default: 27657c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(cmd->cmd_prop_name[i]), 2766bbec428eSgjelinek Z_NO_PROPERTY_TYPE, B_TRUE); 27677c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 27687c478bd9Sstevel@tonic-gate } 27697c478bd9Sstevel@tonic-gate } 27707c478bd9Sstevel@tonic-gate if (fill_in_only) 27717c478bd9Sstevel@tonic-gate return (Z_OK); 27727c478bd9Sstevel@tonic-gate err = zonecfg_lookup_attr(handle, attrtab); 27737c478bd9Sstevel@tonic-gate return (err); 27747c478bd9Sstevel@tonic-gate } 27757c478bd9Sstevel@tonic-gate 2776fa9e4066Sahrens static int 2777bbec428eSgjelinek fill_in_dstab(cmd_t *cmd, struct zone_dstab *dstab, boolean_t fill_in_only) 2778fa9e4066Sahrens { 2779fa9e4066Sahrens int err, i; 2780fa9e4066Sahrens property_value_ptr_t pp; 2781fa9e4066Sahrens 2782bbec428eSgjelinek if ((err = initialize(B_TRUE)) != Z_OK) 2783fa9e4066Sahrens return (err); 2784fa9e4066Sahrens 2785fa9e4066Sahrens dstab->zone_dataset_name[0] = '\0'; 2786fa9e4066Sahrens for (i = 0; i < cmd->cmd_prop_nv_pairs; i++) { 2787fa9e4066Sahrens pp = cmd->cmd_property_ptr[i]; 2788fa9e4066Sahrens if (pp->pv_type != PROP_VAL_SIMPLE || pp->pv_simple == NULL) { 2789fa9e4066Sahrens zerr(gettext("A simple value was expected here.")); 2790bbec428eSgjelinek saw_error = B_TRUE; 2791fa9e4066Sahrens return (Z_INSUFFICIENT_SPEC); 2792fa9e4066Sahrens } 2793fa9e4066Sahrens switch (cmd->cmd_prop_name[i]) { 2794fa9e4066Sahrens case PT_NAME: 2795fa9e4066Sahrens (void) strlcpy(dstab->zone_dataset_name, pp->pv_simple, 2796fa9e4066Sahrens sizeof (dstab->zone_dataset_name)); 2797fa9e4066Sahrens break; 2798fa9e4066Sahrens default: 2799fa9e4066Sahrens zone_perror(pt_to_str(cmd->cmd_prop_name[i]), 2800bbec428eSgjelinek Z_NO_PROPERTY_TYPE, B_TRUE); 2801fa9e4066Sahrens return (Z_INSUFFICIENT_SPEC); 2802fa9e4066Sahrens } 2803fa9e4066Sahrens } 2804fa9e4066Sahrens if (fill_in_only) 2805fa9e4066Sahrens return (Z_OK); 2806fa9e4066Sahrens return (zonecfg_lookup_ds(handle, dstab)); 2807fa9e4066Sahrens } 2808fa9e4066Sahrens 2809cb8a054bSGlenn Faden static int 2810cb8a054bSGlenn Faden fill_in_admintab(cmd_t *cmd, struct zone_admintab *admintab, 2811cb8a054bSGlenn Faden boolean_t fill_in_only) 2812cb8a054bSGlenn Faden { 2813cb8a054bSGlenn Faden int err, i; 2814cb8a054bSGlenn Faden property_value_ptr_t pp; 2815cb8a054bSGlenn Faden 2816cb8a054bSGlenn Faden if ((err = initialize(B_TRUE)) != Z_OK) 2817cb8a054bSGlenn Faden return (err); 2818cb8a054bSGlenn Faden 2819cb8a054bSGlenn Faden bzero(admintab, sizeof (*admintab)); 2820cb8a054bSGlenn Faden for (i = 0; i < cmd->cmd_prop_nv_pairs; i++) { 2821cb8a054bSGlenn Faden pp = cmd->cmd_property_ptr[i]; 2822cb8a054bSGlenn Faden if (pp->pv_type != PROP_VAL_SIMPLE || pp->pv_simple == NULL) { 2823cb8a054bSGlenn Faden zerr(gettext("A simple value was expected here.")); 2824cb8a054bSGlenn Faden saw_error = B_TRUE; 2825cb8a054bSGlenn Faden return (Z_INSUFFICIENT_SPEC); 2826cb8a054bSGlenn Faden } 2827cb8a054bSGlenn Faden switch (cmd->cmd_prop_name[i]) { 2828cb8a054bSGlenn Faden case PT_USER: 2829cb8a054bSGlenn Faden (void) strlcpy(admintab->zone_admin_user, pp->pv_simple, 2830cb8a054bSGlenn Faden sizeof (admintab->zone_admin_user)); 2831cb8a054bSGlenn Faden break; 2832cb8a054bSGlenn Faden case PT_AUTHS: 2833cb8a054bSGlenn Faden (void) strlcpy(admintab->zone_admin_auths, 2834cb8a054bSGlenn Faden pp->pv_simple, sizeof (admintab->zone_admin_auths)); 2835cb8a054bSGlenn Faden break; 2836cb8a054bSGlenn Faden default: 2837cb8a054bSGlenn Faden zone_perror(pt_to_str(cmd->cmd_prop_name[i]), 2838cb8a054bSGlenn Faden Z_NO_PROPERTY_TYPE, B_TRUE); 2839cb8a054bSGlenn Faden return (Z_INSUFFICIENT_SPEC); 2840cb8a054bSGlenn Faden } 2841cb8a054bSGlenn Faden } 2842cb8a054bSGlenn Faden if (fill_in_only) 2843cb8a054bSGlenn Faden return (Z_OK); 2844cb8a054bSGlenn Faden err = zonecfg_lookup_admin(handle, admintab); 2845cb8a054bSGlenn Faden return (err); 2846cb8a054bSGlenn Faden } 2847cb8a054bSGlenn Faden 28487c478bd9Sstevel@tonic-gate static void 28490209230bSgjelinek remove_aliased_rctl(int type, char *name) 28507c478bd9Sstevel@tonic-gate { 28510209230bSgjelinek int err; 28520209230bSgjelinek uint64_t tmp; 28537c478bd9Sstevel@tonic-gate 28540209230bSgjelinek if ((err = zonecfg_get_aliased_rctl(handle, name, &tmp)) != Z_OK) { 28550209230bSgjelinek zerr("%s %s: %s", cmd_to_str(CMD_CLEAR), pt_to_str(type), 28560209230bSgjelinek zonecfg_strerror(err)); 2857bbec428eSgjelinek saw_error = B_TRUE; 28587c478bd9Sstevel@tonic-gate return; 28597c478bd9Sstevel@tonic-gate } 28600209230bSgjelinek if ((err = zonecfg_rm_aliased_rctl(handle, name)) != Z_OK) { 28610209230bSgjelinek zerr("%s %s: %s", cmd_to_str(CMD_CLEAR), pt_to_str(type), 28620209230bSgjelinek zonecfg_strerror(err)); 2863bbec428eSgjelinek saw_error = B_TRUE; 28640209230bSgjelinek } else { 2865bbec428eSgjelinek need_to_commit = B_TRUE; 28660209230bSgjelinek } 28670209230bSgjelinek } 28687c478bd9Sstevel@tonic-gate 28690209230bSgjelinek static boolean_t 28700209230bSgjelinek prompt_remove_resource(cmd_t *cmd, char *rsrc) 28710209230bSgjelinek { 28720209230bSgjelinek int num; 28730209230bSgjelinek int answer; 28740209230bSgjelinek int arg; 28750209230bSgjelinek boolean_t force = B_FALSE; 28760209230bSgjelinek char prompt[128]; 2877bbec428eSgjelinek boolean_t arg_err = B_FALSE; 28787c478bd9Sstevel@tonic-gate 28790209230bSgjelinek optind = 0; 28800209230bSgjelinek while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "F")) != EOF) { 28810209230bSgjelinek switch (arg) { 28820209230bSgjelinek case 'F': 28830209230bSgjelinek force = B_TRUE; 28840209230bSgjelinek break; 28850209230bSgjelinek default: 2886bbec428eSgjelinek arg_err = B_TRUE; 28877ec75eb8Sgjelinek break; 28887ec75eb8Sgjelinek } 28897ec75eb8Sgjelinek } 28907ec75eb8Sgjelinek if (arg_err) 28910209230bSgjelinek return (B_FALSE); 28927ec75eb8Sgjelinek 28930209230bSgjelinek 28940209230bSgjelinek num = zonecfg_num_resources(handle, rsrc); 28950209230bSgjelinek 28960209230bSgjelinek if (num == 0) { 28970209230bSgjelinek z_cmd_rt_perror(CMD_REMOVE, cmd->cmd_res_type, Z_NO_ENTRY, 2898bbec428eSgjelinek B_TRUE); 28990209230bSgjelinek return (B_FALSE); 29000209230bSgjelinek } 29010209230bSgjelinek if (num > 1 && !force) { 29020209230bSgjelinek if (!interactive_mode) { 29030209230bSgjelinek zerr(gettext("There are multiple instances of this " 29040209230bSgjelinek "resource. Either qualify the resource to\n" 29050209230bSgjelinek "remove a single instance or use the -F option to " 29060209230bSgjelinek "remove all instances.")); 2907bbec428eSgjelinek saw_error = B_TRUE; 29080209230bSgjelinek return (B_FALSE); 29090209230bSgjelinek } 29100209230bSgjelinek (void) snprintf(prompt, sizeof (prompt), gettext( 29110209230bSgjelinek "Are you sure you want to remove ALL '%s' resources"), 29120209230bSgjelinek rsrc); 2913bbec428eSgjelinek answer = ask_yesno(B_FALSE, prompt); 29140209230bSgjelinek if (answer == -1) { 29150209230bSgjelinek zerr(gettext("Resource incomplete.")); 29160209230bSgjelinek return (B_FALSE); 29170209230bSgjelinek } 29180209230bSgjelinek if (answer != 1) 29190209230bSgjelinek return (B_FALSE); 29200209230bSgjelinek } 29210209230bSgjelinek return (B_TRUE); 29220209230bSgjelinek } 29230209230bSgjelinek 29240209230bSgjelinek static void 29250209230bSgjelinek remove_fs(cmd_t *cmd) 29260209230bSgjelinek { 29270209230bSgjelinek int err; 29280209230bSgjelinek 29290209230bSgjelinek /* traditional, qualified fs removal */ 29300209230bSgjelinek if (cmd->cmd_prop_nv_pairs > 0) { 29310209230bSgjelinek struct zone_fstab fstab; 29320209230bSgjelinek 2933bbec428eSgjelinek if ((err = fill_in_fstab(cmd, &fstab, B_FALSE)) != Z_OK) { 2934bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_FS, err, B_TRUE); 29357c478bd9Sstevel@tonic-gate return; 29367c478bd9Sstevel@tonic-gate } 29377c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_filesystem(handle, &fstab)) != Z_OK) 2938bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_FS, err, B_TRUE); 29397c478bd9Sstevel@tonic-gate else 2940bbec428eSgjelinek need_to_commit = B_TRUE; 29417c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(fstab.zone_fs_options); 29427c478bd9Sstevel@tonic-gate return; 29430209230bSgjelinek } 29440209230bSgjelinek 29450209230bSgjelinek /* 29460209230bSgjelinek * unqualified fs removal. remove all fs's but prompt if more 29470209230bSgjelinek * than one. 29480209230bSgjelinek */ 29490209230bSgjelinek if (!prompt_remove_resource(cmd, "fs")) 29500209230bSgjelinek return; 29510209230bSgjelinek 29520209230bSgjelinek if ((err = zonecfg_del_all_resources(handle, "fs")) != Z_OK) 2953bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_FS, err, B_TRUE); 29540209230bSgjelinek else 2955bbec428eSgjelinek need_to_commit = B_TRUE; 29560209230bSgjelinek } 29570209230bSgjelinek 29580209230bSgjelinek static void 29590209230bSgjelinek remove_net(cmd_t *cmd) 29600209230bSgjelinek { 29610209230bSgjelinek int err; 29620209230bSgjelinek 29630209230bSgjelinek /* traditional, qualified net removal */ 29640209230bSgjelinek if (cmd->cmd_prop_nv_pairs > 0) { 29650209230bSgjelinek struct zone_nwiftab nwiftab; 29660209230bSgjelinek 2967bbec428eSgjelinek if ((err = fill_in_nwiftab(cmd, &nwiftab, B_FALSE)) != Z_OK) { 2968bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_NET, err, B_TRUE); 29697c478bd9Sstevel@tonic-gate return; 29707c478bd9Sstevel@tonic-gate } 29717c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_nwif(handle, &nwiftab)) != Z_OK) 2972bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_NET, err, B_TRUE); 29737c478bd9Sstevel@tonic-gate else 2974bbec428eSgjelinek need_to_commit = B_TRUE; 29757c478bd9Sstevel@tonic-gate return; 29760209230bSgjelinek } 29770209230bSgjelinek 29780209230bSgjelinek /* 29790209230bSgjelinek * unqualified net removal. remove all nets but prompt if more 29800209230bSgjelinek * than one. 29810209230bSgjelinek */ 29820209230bSgjelinek if (!prompt_remove_resource(cmd, "net")) 29830209230bSgjelinek return; 29840209230bSgjelinek 29850209230bSgjelinek if ((err = zonecfg_del_all_resources(handle, "net")) != Z_OK) 2986bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_NET, err, B_TRUE); 29870209230bSgjelinek else 2988bbec428eSgjelinek need_to_commit = B_TRUE; 29890209230bSgjelinek } 29900209230bSgjelinek 29910209230bSgjelinek static void 29920209230bSgjelinek remove_device(cmd_t *cmd) 29930209230bSgjelinek { 29940209230bSgjelinek int err; 29950209230bSgjelinek 29960209230bSgjelinek /* traditional, qualified device removal */ 29970209230bSgjelinek if (cmd->cmd_prop_nv_pairs > 0) { 29980209230bSgjelinek struct zone_devtab devtab; 29990209230bSgjelinek 3000bbec428eSgjelinek if ((err = fill_in_devtab(cmd, &devtab, B_FALSE)) != Z_OK) { 3001bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_DEVICE, err, B_TRUE); 30027c478bd9Sstevel@tonic-gate return; 30037c478bd9Sstevel@tonic-gate } 30047c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_dev(handle, &devtab)) != Z_OK) 3005bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_DEVICE, err, B_TRUE); 30067c478bd9Sstevel@tonic-gate else 3007bbec428eSgjelinek need_to_commit = B_TRUE; 30087c478bd9Sstevel@tonic-gate return; 30090209230bSgjelinek } 30100209230bSgjelinek 30110209230bSgjelinek /* 30120209230bSgjelinek * unqualified device removal. remove all devices but prompt if more 30130209230bSgjelinek * than one. 30140209230bSgjelinek */ 30150209230bSgjelinek if (!prompt_remove_resource(cmd, "device")) 30160209230bSgjelinek return; 30170209230bSgjelinek 30180209230bSgjelinek if ((err = zonecfg_del_all_resources(handle, "device")) != Z_OK) 3019bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_DEVICE, err, B_TRUE); 30200209230bSgjelinek else 3021bbec428eSgjelinek need_to_commit = B_TRUE; 30220209230bSgjelinek } 30230209230bSgjelinek 30240209230bSgjelinek static void 30250209230bSgjelinek remove_attr(cmd_t *cmd) 30260209230bSgjelinek { 30270209230bSgjelinek int err; 30280209230bSgjelinek 30290209230bSgjelinek /* traditional, qualified attr removal */ 30300209230bSgjelinek if (cmd->cmd_prop_nv_pairs > 0) { 30310209230bSgjelinek struct zone_attrtab attrtab; 30320209230bSgjelinek 3033bbec428eSgjelinek if ((err = fill_in_attrtab(cmd, &attrtab, B_FALSE)) != Z_OK) { 3034bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_ATTR, err, B_TRUE); 30350209230bSgjelinek return; 30360209230bSgjelinek } 30370209230bSgjelinek if ((err = zonecfg_delete_attr(handle, &attrtab)) != Z_OK) 3038bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_ATTR, err, B_TRUE); 30390209230bSgjelinek else 3040bbec428eSgjelinek need_to_commit = B_TRUE; 30410209230bSgjelinek return; 30420209230bSgjelinek } 30430209230bSgjelinek 30440209230bSgjelinek /* 30450209230bSgjelinek * unqualified attr removal. remove all attrs but prompt if more 30460209230bSgjelinek * than one. 30470209230bSgjelinek */ 30480209230bSgjelinek if (!prompt_remove_resource(cmd, "attr")) 30490209230bSgjelinek return; 30500209230bSgjelinek 30510209230bSgjelinek if ((err = zonecfg_del_all_resources(handle, "attr")) != Z_OK) 3052bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_ATTR, err, B_TRUE); 30530209230bSgjelinek else 3054bbec428eSgjelinek need_to_commit = B_TRUE; 30550209230bSgjelinek } 30560209230bSgjelinek 30570209230bSgjelinek static void 30580209230bSgjelinek remove_dataset(cmd_t *cmd) 30590209230bSgjelinek { 30600209230bSgjelinek int err; 30610209230bSgjelinek 30620209230bSgjelinek /* traditional, qualified dataset removal */ 30630209230bSgjelinek if (cmd->cmd_prop_nv_pairs > 0) { 30640209230bSgjelinek struct zone_dstab dstab; 30650209230bSgjelinek 3066bbec428eSgjelinek if ((err = fill_in_dstab(cmd, &dstab, B_FALSE)) != Z_OK) { 3067bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_DATASET, err, B_TRUE); 30680209230bSgjelinek return; 30690209230bSgjelinek } 30700209230bSgjelinek if ((err = zonecfg_delete_ds(handle, &dstab)) != Z_OK) 3071bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_DATASET, err, B_TRUE); 30720209230bSgjelinek else 3073bbec428eSgjelinek need_to_commit = B_TRUE; 30740209230bSgjelinek return; 30750209230bSgjelinek } 30760209230bSgjelinek 30770209230bSgjelinek /* 30780209230bSgjelinek * unqualified dataset removal. remove all datasets but prompt if more 30790209230bSgjelinek * than one. 30800209230bSgjelinek */ 30810209230bSgjelinek if (!prompt_remove_resource(cmd, "dataset")) 30820209230bSgjelinek return; 30830209230bSgjelinek 30840209230bSgjelinek if ((err = zonecfg_del_all_resources(handle, "dataset")) != Z_OK) 3085bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_DATASET, err, B_TRUE); 30860209230bSgjelinek else 3087bbec428eSgjelinek need_to_commit = B_TRUE; 30880209230bSgjelinek } 30890209230bSgjelinek 30900209230bSgjelinek static void 30910209230bSgjelinek remove_rctl(cmd_t *cmd) 30920209230bSgjelinek { 30930209230bSgjelinek int err; 30940209230bSgjelinek 30950209230bSgjelinek /* traditional, qualified rctl removal */ 30960209230bSgjelinek if (cmd->cmd_prop_nv_pairs > 0) { 30970209230bSgjelinek struct zone_rctltab rctltab; 30980209230bSgjelinek 3099bbec428eSgjelinek if ((err = fill_in_rctltab(cmd, &rctltab, B_FALSE)) != Z_OK) { 3100bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_RCTL, err, B_TRUE); 31017c478bd9Sstevel@tonic-gate return; 31027c478bd9Sstevel@tonic-gate } 31037c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_rctl(handle, &rctltab)) != Z_OK) 3104bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_RCTL, err, B_TRUE); 31057c478bd9Sstevel@tonic-gate else 3106bbec428eSgjelinek need_to_commit = B_TRUE; 31077c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctltab.zone_rctl_valptr); 31087c478bd9Sstevel@tonic-gate return; 31097c478bd9Sstevel@tonic-gate } 31100209230bSgjelinek 31110209230bSgjelinek /* 31120209230bSgjelinek * unqualified rctl removal. remove all rctls but prompt if more 31130209230bSgjelinek * than one. 31140209230bSgjelinek */ 31150209230bSgjelinek if (!prompt_remove_resource(cmd, "rctl")) 31160209230bSgjelinek return; 31170209230bSgjelinek 31180209230bSgjelinek if ((err = zonecfg_del_all_resources(handle, "rctl")) != Z_OK) 3119bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_RCTL, err, B_TRUE); 31207c478bd9Sstevel@tonic-gate else 3121bbec428eSgjelinek need_to_commit = B_TRUE; 31220209230bSgjelinek } 31230209230bSgjelinek 31240209230bSgjelinek static void 31250209230bSgjelinek remove_pset() 31260209230bSgjelinek { 31270209230bSgjelinek int err; 31280209230bSgjelinek struct zone_psettab psettab; 31290209230bSgjelinek 31300209230bSgjelinek if ((err = zonecfg_lookup_pset(handle, &psettab)) != Z_OK) { 3131bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_DCPU, err, B_TRUE); 31320209230bSgjelinek return; 31330209230bSgjelinek } 31340209230bSgjelinek if ((err = zonecfg_delete_pset(handle)) != Z_OK) 3135bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_DCPU, err, B_TRUE); 31360209230bSgjelinek else 3137bbec428eSgjelinek need_to_commit = B_TRUE; 31380209230bSgjelinek } 31390209230bSgjelinek 31400209230bSgjelinek static void 3141c97ad5cdSakolb remove_pcap() 3142c97ad5cdSakolb { 3143c97ad5cdSakolb int err; 3144c97ad5cdSakolb uint64_t tmp; 3145c97ad5cdSakolb 3146c97ad5cdSakolb if (zonecfg_get_aliased_rctl(handle, ALIAS_CPUCAP, &tmp) != Z_OK) { 3147c97ad5cdSakolb zerr("%s %s: %s", cmd_to_str(CMD_REMOVE), rt_to_str(RT_PCAP), 3148c97ad5cdSakolb zonecfg_strerror(Z_NO_RESOURCE_TYPE)); 3149bbec428eSgjelinek saw_error = B_TRUE; 3150c97ad5cdSakolb return; 3151c97ad5cdSakolb } 3152c97ad5cdSakolb 3153c97ad5cdSakolb if ((err = zonecfg_rm_aliased_rctl(handle, ALIAS_CPUCAP)) != Z_OK) 3154bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_PCAP, err, B_TRUE); 3155c97ad5cdSakolb else 3156bbec428eSgjelinek need_to_commit = B_TRUE; 3157c97ad5cdSakolb } 3158c97ad5cdSakolb 3159c97ad5cdSakolb static void 31600209230bSgjelinek remove_mcap() 31610209230bSgjelinek { 31620209230bSgjelinek int err, res1, res2, res3; 31630209230bSgjelinek uint64_t tmp; 31640209230bSgjelinek struct zone_mcaptab mcaptab; 31650209230bSgjelinek boolean_t revert = B_FALSE; 31660209230bSgjelinek 31670209230bSgjelinek res1 = zonecfg_lookup_mcap(handle, &mcaptab); 31680209230bSgjelinek res2 = zonecfg_get_aliased_rctl(handle, ALIAS_MAXSWAP, &tmp); 31690209230bSgjelinek res3 = zonecfg_get_aliased_rctl(handle, ALIAS_MAXLOCKEDMEM, &tmp); 31700209230bSgjelinek 31710209230bSgjelinek /* if none of these exist, there is no resource to remove */ 31720209230bSgjelinek if (res1 != Z_OK && res2 != Z_OK && res3 != Z_OK) { 31730209230bSgjelinek zerr("%s %s: %s", cmd_to_str(CMD_REMOVE), rt_to_str(RT_MCAP), 31740209230bSgjelinek zonecfg_strerror(Z_NO_RESOURCE_TYPE)); 3175bbec428eSgjelinek saw_error = B_TRUE; 31760209230bSgjelinek return; 31770209230bSgjelinek } 31780209230bSgjelinek if (res1 == Z_OK) { 31790209230bSgjelinek if ((err = zonecfg_delete_mcap(handle)) != Z_OK) { 3180bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_MCAP, err, B_TRUE); 31810209230bSgjelinek revert = B_TRUE; 31820209230bSgjelinek } else { 3183bbec428eSgjelinek need_to_commit = B_TRUE; 31840209230bSgjelinek } 31850209230bSgjelinek } 31860209230bSgjelinek if (res2 == Z_OK) { 31870209230bSgjelinek if ((err = zonecfg_rm_aliased_rctl(handle, ALIAS_MAXSWAP)) 31880209230bSgjelinek != Z_OK) { 3189bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_MCAP, err, B_TRUE); 31900209230bSgjelinek revert = B_TRUE; 31910209230bSgjelinek } else { 3192bbec428eSgjelinek need_to_commit = B_TRUE; 31930209230bSgjelinek } 31940209230bSgjelinek } 31950209230bSgjelinek if (res3 == Z_OK) { 31960209230bSgjelinek if ((err = zonecfg_rm_aliased_rctl(handle, ALIAS_MAXLOCKEDMEM)) 31970209230bSgjelinek != Z_OK) { 3198bbec428eSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_MCAP, err, B_TRUE); 31990209230bSgjelinek revert = B_TRUE; 32000209230bSgjelinek } else { 3201bbec428eSgjelinek need_to_commit = B_TRUE; 32020209230bSgjelinek } 32030209230bSgjelinek } 32040209230bSgjelinek 32050209230bSgjelinek if (revert) 3206bbec428eSgjelinek need_to_commit = B_FALSE; 32070209230bSgjelinek } 32080209230bSgjelinek 32090209230bSgjelinek static void 3210cb8a054bSGlenn Faden remove_admin(cmd_t *cmd) 3211cb8a054bSGlenn Faden { 3212cb8a054bSGlenn Faden int err; 3213cb8a054bSGlenn Faden 3214cb8a054bSGlenn Faden /* traditional, qualified attr removal */ 3215cb8a054bSGlenn Faden if (cmd->cmd_prop_nv_pairs > 0) { 3216cb8a054bSGlenn Faden struct zone_admintab admintab; 3217cb8a054bSGlenn Faden 3218cb8a054bSGlenn Faden if ((err = fill_in_admintab(cmd, &admintab, B_FALSE)) != Z_OK) { 3219cb8a054bSGlenn Faden z_cmd_rt_perror(CMD_REMOVE, RT_ADMIN, 3220cb8a054bSGlenn Faden err, B_TRUE); 3221cb8a054bSGlenn Faden return; 3222cb8a054bSGlenn Faden } 3223cb8a054bSGlenn Faden if ((err = zonecfg_delete_admin(handle, &admintab, 3224cb8a054bSGlenn Faden zone)) 3225cb8a054bSGlenn Faden != Z_OK) 3226cb8a054bSGlenn Faden z_cmd_rt_perror(CMD_REMOVE, RT_ADMIN, 3227cb8a054bSGlenn Faden err, B_TRUE); 3228cb8a054bSGlenn Faden else 3229cb8a054bSGlenn Faden need_to_commit = B_TRUE; 3230cb8a054bSGlenn Faden return; 3231cb8a054bSGlenn Faden } else { 3232cb8a054bSGlenn Faden /* 3233cb8a054bSGlenn Faden * unqualified admin removal. 3234cb8a054bSGlenn Faden * remove all admins but prompt if more 3235cb8a054bSGlenn Faden * than one. 3236cb8a054bSGlenn Faden */ 3237cb8a054bSGlenn Faden if (!prompt_remove_resource(cmd, "admin")) 3238cb8a054bSGlenn Faden return; 3239cb8a054bSGlenn Faden 3240cb8a054bSGlenn Faden if ((err = zonecfg_delete_admins(handle, zone)) 3241cb8a054bSGlenn Faden != Z_OK) 3242cb8a054bSGlenn Faden z_cmd_rt_perror(CMD_REMOVE, RT_ADMIN, 3243cb8a054bSGlenn Faden err, B_TRUE); 3244cb8a054bSGlenn Faden else 3245cb8a054bSGlenn Faden need_to_commit = B_TRUE; 3246cb8a054bSGlenn Faden } 3247cb8a054bSGlenn Faden } 3248cb8a054bSGlenn Faden 3249cb8a054bSGlenn Faden static void 32500209230bSgjelinek remove_resource(cmd_t *cmd) 32510209230bSgjelinek { 32520209230bSgjelinek int type; 32530209230bSgjelinek int arg; 3254bbec428eSgjelinek boolean_t arg_err = B_FALSE; 32550209230bSgjelinek 32560209230bSgjelinek if ((type = cmd->cmd_res_type) == RT_UNKNOWN) { 3257bbec428eSgjelinek long_usage(CMD_REMOVE, B_TRUE); 32580209230bSgjelinek return; 32590209230bSgjelinek } 32600209230bSgjelinek 32610209230bSgjelinek optind = 0; 32620209230bSgjelinek while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?F")) != EOF) { 32630209230bSgjelinek switch (arg) { 32640209230bSgjelinek case '?': 32650209230bSgjelinek longer_usage(CMD_REMOVE); 3266bbec428eSgjelinek arg_err = B_TRUE; 32677ec75eb8Sgjelinek break; 32680209230bSgjelinek case 'F': 32690209230bSgjelinek break; 32700209230bSgjelinek default: 32710209230bSgjelinek short_usage(CMD_REMOVE); 3272bbec428eSgjelinek arg_err = B_TRUE; 32737ec75eb8Sgjelinek break; 32747ec75eb8Sgjelinek } 32757ec75eb8Sgjelinek } 32767ec75eb8Sgjelinek if (arg_err) 32770209230bSgjelinek return; 32780209230bSgjelinek 3279bbec428eSgjelinek if (initialize(B_TRUE) != Z_OK) 32800209230bSgjelinek return; 32810209230bSgjelinek 32820209230bSgjelinek switch (type) { 32830209230bSgjelinek case RT_FS: 32840209230bSgjelinek remove_fs(cmd); 32850209230bSgjelinek return; 32860209230bSgjelinek case RT_NET: 32870209230bSgjelinek remove_net(cmd); 32880209230bSgjelinek return; 32890209230bSgjelinek case RT_DEVICE: 32900209230bSgjelinek remove_device(cmd); 32910209230bSgjelinek return; 32920209230bSgjelinek case RT_RCTL: 32930209230bSgjelinek remove_rctl(cmd); 32940209230bSgjelinek return; 32950209230bSgjelinek case RT_ATTR: 32960209230bSgjelinek remove_attr(cmd); 32977c478bd9Sstevel@tonic-gate return; 3298fa9e4066Sahrens case RT_DATASET: 32990209230bSgjelinek remove_dataset(cmd); 3300fa9e4066Sahrens return; 33010209230bSgjelinek case RT_DCPU: 33020209230bSgjelinek remove_pset(); 33030209230bSgjelinek return; 3304c97ad5cdSakolb case RT_PCAP: 3305c97ad5cdSakolb remove_pcap(); 3306c97ad5cdSakolb return; 33070209230bSgjelinek case RT_MCAP: 33080209230bSgjelinek remove_mcap(); 3309fa9e4066Sahrens return; 3310cb8a054bSGlenn Faden case RT_ADMIN: 3311cb8a054bSGlenn Faden remove_admin(cmd); 3312cb8a054bSGlenn Faden return; 33137c478bd9Sstevel@tonic-gate default: 3314bbec428eSgjelinek zone_perror(rt_to_str(type), Z_NO_RESOURCE_TYPE, B_TRUE); 3315bbec428eSgjelinek long_usage(CMD_REMOVE, B_TRUE); 3316bbec428eSgjelinek usage(B_FALSE, HELP_RESOURCES); 33177c478bd9Sstevel@tonic-gate return; 33187c478bd9Sstevel@tonic-gate } 33197c478bd9Sstevel@tonic-gate } 33207c478bd9Sstevel@tonic-gate 33217c478bd9Sstevel@tonic-gate static void 33227c478bd9Sstevel@tonic-gate remove_property(cmd_t *cmd) 33237c478bd9Sstevel@tonic-gate { 33247c478bd9Sstevel@tonic-gate char *prop_id; 33257c478bd9Sstevel@tonic-gate int err, res_type, prop_type; 33267c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 33277c478bd9Sstevel@tonic-gate struct zone_rctlvaltab *rctlvaltab; 33287c478bd9Sstevel@tonic-gate complex_property_ptr_t cx; 33297c478bd9Sstevel@tonic-gate 33307c478bd9Sstevel@tonic-gate res_type = resource_scope; 33317c478bd9Sstevel@tonic-gate prop_type = cmd->cmd_prop_name[0]; 33327c478bd9Sstevel@tonic-gate if (res_type == RT_UNKNOWN || prop_type == PT_UNKNOWN) { 3333bbec428eSgjelinek long_usage(CMD_REMOVE, B_TRUE); 33347c478bd9Sstevel@tonic-gate return; 33357c478bd9Sstevel@tonic-gate } 33367c478bd9Sstevel@tonic-gate 33377c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs != 1) { 3338bbec428eSgjelinek long_usage(CMD_ADD, B_TRUE); 33397c478bd9Sstevel@tonic-gate return; 33407c478bd9Sstevel@tonic-gate } 33417c478bd9Sstevel@tonic-gate 3342bbec428eSgjelinek if (initialize(B_TRUE) != Z_OK) 33437c478bd9Sstevel@tonic-gate return; 33447c478bd9Sstevel@tonic-gate 33457c478bd9Sstevel@tonic-gate switch (res_type) { 33467c478bd9Sstevel@tonic-gate case RT_FS: 33477c478bd9Sstevel@tonic-gate if (prop_type != PT_OPTIONS) { 33487c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 3349bbec428eSgjelinek B_TRUE); 3350bbec428eSgjelinek long_usage(CMD_REMOVE, B_TRUE); 3351bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 33527c478bd9Sstevel@tonic-gate return; 33537c478bd9Sstevel@tonic-gate } 33547c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[0]; 33557c478bd9Sstevel@tonic-gate if (pp->pv_type == PROP_VAL_COMPLEX) { 33567c478bd9Sstevel@tonic-gate zerr(gettext("A %s or %s value was expected here."), 33577c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_SIMPLE), 33587c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_LIST)); 3359bbec428eSgjelinek saw_error = B_TRUE; 33607c478bd9Sstevel@tonic-gate return; 33617c478bd9Sstevel@tonic-gate } 33627c478bd9Sstevel@tonic-gate if (pp->pv_type == PROP_VAL_SIMPLE) { 33637c478bd9Sstevel@tonic-gate if (pp->pv_simple == NULL) { 3364bbec428eSgjelinek long_usage(CMD_ADD, B_TRUE); 33657c478bd9Sstevel@tonic-gate return; 33667c478bd9Sstevel@tonic-gate } 33677c478bd9Sstevel@tonic-gate prop_id = pp->pv_simple; 33687c478bd9Sstevel@tonic-gate err = zonecfg_remove_fs_option(&in_progress_fstab, 33697c478bd9Sstevel@tonic-gate prop_id); 33707c478bd9Sstevel@tonic-gate if (err != Z_OK) 3371bbec428eSgjelinek zone_perror(pt_to_str(prop_type), err, B_TRUE); 33727c478bd9Sstevel@tonic-gate } else { 33737c478bd9Sstevel@tonic-gate list_property_ptr_t list; 33747c478bd9Sstevel@tonic-gate 33757c478bd9Sstevel@tonic-gate for (list = pp->pv_list; list != NULL; 33767c478bd9Sstevel@tonic-gate list = list->lp_next) { 33777c478bd9Sstevel@tonic-gate prop_id = list->lp_simple; 33787c478bd9Sstevel@tonic-gate if (prop_id == NULL) 33797c478bd9Sstevel@tonic-gate break; 33807c478bd9Sstevel@tonic-gate err = zonecfg_remove_fs_option( 33817c478bd9Sstevel@tonic-gate &in_progress_fstab, prop_id); 33827c478bd9Sstevel@tonic-gate if (err != Z_OK) 33837c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), err, 3384bbec428eSgjelinek B_TRUE); 33857c478bd9Sstevel@tonic-gate } 33867c478bd9Sstevel@tonic-gate } 33877c478bd9Sstevel@tonic-gate return; 33887c478bd9Sstevel@tonic-gate case RT_RCTL: 33897c478bd9Sstevel@tonic-gate if (prop_type != PT_VALUE) { 33907c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 3391bbec428eSgjelinek B_TRUE); 3392bbec428eSgjelinek long_usage(CMD_REMOVE, B_TRUE); 3393bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 33947c478bd9Sstevel@tonic-gate return; 33957c478bd9Sstevel@tonic-gate } 33967c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[0]; 33977c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_COMPLEX) { 33987c478bd9Sstevel@tonic-gate zerr(gettext("A %s value was expected here."), 33997c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_COMPLEX)); 3400bbec428eSgjelinek saw_error = B_TRUE; 34017c478bd9Sstevel@tonic-gate return; 34027c478bd9Sstevel@tonic-gate } 34037c478bd9Sstevel@tonic-gate if ((rctlvaltab = alloc_rctlvaltab()) == NULL) { 3404bbec428eSgjelinek zone_perror(zone, Z_NOMEM, B_TRUE); 34057c478bd9Sstevel@tonic-gate exit(Z_ERR); 34067c478bd9Sstevel@tonic-gate } 34077c478bd9Sstevel@tonic-gate for (cx = pp->pv_complex; cx != NULL; cx = cx->cp_next) { 34087c478bd9Sstevel@tonic-gate switch (cx->cp_type) { 34097c478bd9Sstevel@tonic-gate case PT_PRIV: 34107c478bd9Sstevel@tonic-gate (void) strlcpy(rctlvaltab->zone_rctlval_priv, 34117c478bd9Sstevel@tonic-gate cx->cp_value, 34127c478bd9Sstevel@tonic-gate sizeof (rctlvaltab->zone_rctlval_priv)); 34137c478bd9Sstevel@tonic-gate break; 34147c478bd9Sstevel@tonic-gate case PT_LIMIT: 34157c478bd9Sstevel@tonic-gate (void) strlcpy(rctlvaltab->zone_rctlval_limit, 34167c478bd9Sstevel@tonic-gate cx->cp_value, 34177c478bd9Sstevel@tonic-gate sizeof (rctlvaltab->zone_rctlval_limit)); 34187c478bd9Sstevel@tonic-gate break; 34197c478bd9Sstevel@tonic-gate case PT_ACTION: 34207c478bd9Sstevel@tonic-gate (void) strlcpy(rctlvaltab->zone_rctlval_action, 34217c478bd9Sstevel@tonic-gate cx->cp_value, 34227c478bd9Sstevel@tonic-gate sizeof (rctlvaltab->zone_rctlval_action)); 34237c478bd9Sstevel@tonic-gate break; 34247c478bd9Sstevel@tonic-gate default: 34257c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), 3426bbec428eSgjelinek Z_NO_PROPERTY_TYPE, B_TRUE); 3427bbec428eSgjelinek long_usage(CMD_ADD, B_TRUE); 3428bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 34297c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctlvaltab); 34307c478bd9Sstevel@tonic-gate return; 34317c478bd9Sstevel@tonic-gate } 34327c478bd9Sstevel@tonic-gate } 34337c478bd9Sstevel@tonic-gate rctlvaltab->zone_rctlval_next = NULL; 34347c478bd9Sstevel@tonic-gate err = zonecfg_remove_rctl_value(&in_progress_rctltab, 34357c478bd9Sstevel@tonic-gate rctlvaltab); 34367c478bd9Sstevel@tonic-gate if (err != Z_OK) 3437bbec428eSgjelinek zone_perror(pt_to_str(prop_type), err, B_TRUE); 34387c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctlvaltab); 34397c478bd9Sstevel@tonic-gate return; 3440de860bd9Sgfaden case RT_NET: 3441de860bd9Sgfaden if (prop_type != PT_DEFROUTER) { 3442de860bd9Sgfaden zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 3443bbec428eSgjelinek B_TRUE); 3444bbec428eSgjelinek long_usage(CMD_REMOVE, B_TRUE); 3445bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 3446de860bd9Sgfaden return; 3447de860bd9Sgfaden } else { 3448de860bd9Sgfaden bzero(&in_progress_nwiftab.zone_nwif_defrouter, 3449de860bd9Sgfaden sizeof (in_progress_nwiftab.zone_nwif_defrouter)); 3450de860bd9Sgfaden return; 3451de860bd9Sgfaden } 34527c478bd9Sstevel@tonic-gate default: 3453bbec428eSgjelinek zone_perror(rt_to_str(res_type), Z_NO_RESOURCE_TYPE, B_TRUE); 3454bbec428eSgjelinek long_usage(CMD_REMOVE, B_TRUE); 3455bbec428eSgjelinek usage(B_FALSE, HELP_RESOURCES); 34567c478bd9Sstevel@tonic-gate return; 34577c478bd9Sstevel@tonic-gate } 34587c478bd9Sstevel@tonic-gate } 34597c478bd9Sstevel@tonic-gate 34607c478bd9Sstevel@tonic-gate void 34617c478bd9Sstevel@tonic-gate remove_func(cmd_t *cmd) 34627c478bd9Sstevel@tonic-gate { 34637c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_REMOVE)) 34647c478bd9Sstevel@tonic-gate return; 34657c478bd9Sstevel@tonic-gate 34667c478bd9Sstevel@tonic-gate assert(cmd != NULL); 34677c478bd9Sstevel@tonic-gate 34680209230bSgjelinek if (global_scope) { 34690209230bSgjelinek if (gz_invalid_resource(cmd->cmd_res_type)) { 34700209230bSgjelinek zerr(gettext("%s is not a valid resource for the " 34710209230bSgjelinek "global zone."), rt_to_str(cmd->cmd_res_type)); 3472bbec428eSgjelinek saw_error = B_TRUE; 34730209230bSgjelinek return; 34740209230bSgjelinek } 34757c478bd9Sstevel@tonic-gate remove_resource(cmd); 34760209230bSgjelinek } else { 34777c478bd9Sstevel@tonic-gate remove_property(cmd); 34787c478bd9Sstevel@tonic-gate } 34790209230bSgjelinek } 34800209230bSgjelinek 34810209230bSgjelinek static void 34820209230bSgjelinek clear_property(cmd_t *cmd) 34830209230bSgjelinek { 34840209230bSgjelinek int res_type, prop_type; 34850209230bSgjelinek 34860209230bSgjelinek res_type = resource_scope; 34870209230bSgjelinek prop_type = cmd->cmd_res_type; 34880209230bSgjelinek if (res_type == RT_UNKNOWN || prop_type == PT_UNKNOWN) { 3489bbec428eSgjelinek long_usage(CMD_CLEAR, B_TRUE); 34900209230bSgjelinek return; 34910209230bSgjelinek } 34920209230bSgjelinek 3493bbec428eSgjelinek if (initialize(B_TRUE) != Z_OK) 34940209230bSgjelinek return; 34950209230bSgjelinek 34960209230bSgjelinek switch (res_type) { 34970209230bSgjelinek case RT_FS: 34980209230bSgjelinek if (prop_type == PT_RAW) { 34990209230bSgjelinek in_progress_fstab.zone_fs_raw[0] = '\0'; 3500bbec428eSgjelinek need_to_commit = B_TRUE; 35010209230bSgjelinek return; 35020209230bSgjelinek } 35030209230bSgjelinek break; 35040209230bSgjelinek case RT_DCPU: 35050209230bSgjelinek if (prop_type == PT_IMPORTANCE) { 35060209230bSgjelinek in_progress_psettab.zone_importance[0] = '\0'; 3507bbec428eSgjelinek need_to_commit = B_TRUE; 35080209230bSgjelinek return; 35090209230bSgjelinek } 35100209230bSgjelinek break; 35110209230bSgjelinek case RT_MCAP: 35120209230bSgjelinek switch (prop_type) { 35130209230bSgjelinek case PT_PHYSICAL: 35140209230bSgjelinek in_progress_mcaptab.zone_physmem_cap[0] = '\0'; 3515bbec428eSgjelinek need_to_commit = B_TRUE; 35160209230bSgjelinek return; 35170209230bSgjelinek case PT_SWAP: 35180209230bSgjelinek remove_aliased_rctl(PT_SWAP, ALIAS_MAXSWAP); 35190209230bSgjelinek return; 35200209230bSgjelinek case PT_LOCKED: 35210209230bSgjelinek remove_aliased_rctl(PT_LOCKED, ALIAS_MAXLOCKEDMEM); 35220209230bSgjelinek return; 35230209230bSgjelinek } 35240209230bSgjelinek break; 35250209230bSgjelinek default: 35260209230bSgjelinek break; 35270209230bSgjelinek } 35280209230bSgjelinek 3529bbec428eSgjelinek zone_perror(pt_to_str(prop_type), Z_CLEAR_DISALLOW, B_TRUE); 35300209230bSgjelinek } 35310209230bSgjelinek 35320209230bSgjelinek static void 35330209230bSgjelinek clear_global(cmd_t *cmd) 35340209230bSgjelinek { 35350209230bSgjelinek int err, type; 35360209230bSgjelinek 35370209230bSgjelinek if ((type = cmd->cmd_res_type) == RT_UNKNOWN) { 3538bbec428eSgjelinek long_usage(CMD_CLEAR, B_TRUE); 35390209230bSgjelinek return; 35400209230bSgjelinek } 35410209230bSgjelinek 3542bbec428eSgjelinek if (initialize(B_TRUE) != Z_OK) 35430209230bSgjelinek return; 35440209230bSgjelinek 35450209230bSgjelinek switch (type) { 35460209230bSgjelinek case PT_ZONENAME: 35470209230bSgjelinek /* FALLTHRU */ 35480209230bSgjelinek case PT_ZONEPATH: 35490209230bSgjelinek /* FALLTHRU */ 35500209230bSgjelinek case PT_BRAND: 3551bbec428eSgjelinek zone_perror(pt_to_str(type), Z_CLEAR_DISALLOW, B_TRUE); 35520209230bSgjelinek return; 35530209230bSgjelinek case PT_AUTOBOOT: 35540209230bSgjelinek /* false is default; we'll treat as equivalent to clearing */ 35550209230bSgjelinek if ((err = zonecfg_set_autoboot(handle, B_FALSE)) != Z_OK) 3556bbec428eSgjelinek z_cmd_rt_perror(CMD_CLEAR, RT_AUTOBOOT, err, B_TRUE); 35570209230bSgjelinek else 3558bbec428eSgjelinek need_to_commit = B_TRUE; 35590209230bSgjelinek return; 35600209230bSgjelinek case PT_POOL: 35610209230bSgjelinek if ((err = zonecfg_set_pool(handle, NULL)) != Z_OK) 3562bbec428eSgjelinek z_cmd_rt_perror(CMD_CLEAR, RT_POOL, err, B_TRUE); 35630209230bSgjelinek else 3564bbec428eSgjelinek need_to_commit = B_TRUE; 35650209230bSgjelinek return; 35660209230bSgjelinek case PT_LIMITPRIV: 35670209230bSgjelinek if ((err = zonecfg_set_limitpriv(handle, NULL)) != Z_OK) 3568bbec428eSgjelinek z_cmd_rt_perror(CMD_CLEAR, RT_LIMITPRIV, err, B_TRUE); 35690209230bSgjelinek else 3570bbec428eSgjelinek need_to_commit = B_TRUE; 35710209230bSgjelinek return; 35720209230bSgjelinek case PT_BOOTARGS: 35730209230bSgjelinek if ((err = zonecfg_set_bootargs(handle, NULL)) != Z_OK) 3574bbec428eSgjelinek z_cmd_rt_perror(CMD_CLEAR, RT_BOOTARGS, err, B_TRUE); 35750209230bSgjelinek else 3576bbec428eSgjelinek need_to_commit = B_TRUE; 35770209230bSgjelinek return; 35780209230bSgjelinek case PT_SCHED: 35790209230bSgjelinek if ((err = zonecfg_set_sched(handle, NULL)) != Z_OK) 3580bbec428eSgjelinek z_cmd_rt_perror(CMD_CLEAR, RT_SCHED, err, B_TRUE); 35810209230bSgjelinek else 3582bbec428eSgjelinek need_to_commit = B_TRUE; 35830209230bSgjelinek return; 3584f4b3ec61Sdh155122 case PT_IPTYPE: 3585f4b3ec61Sdh155122 /* shared is default; we'll treat as equivalent to clearing */ 3586f4b3ec61Sdh155122 if ((err = zonecfg_set_iptype(handle, ZS_SHARED)) != Z_OK) 3587bbec428eSgjelinek z_cmd_rt_perror(CMD_CLEAR, RT_IPTYPE, err, B_TRUE); 3588f4b3ec61Sdh155122 else 3589bbec428eSgjelinek need_to_commit = B_TRUE; 3590f4b3ec61Sdh155122 return; 35910209230bSgjelinek case PT_MAXLWPS: 35920209230bSgjelinek remove_aliased_rctl(PT_MAXLWPS, ALIAS_MAXLWPS); 35930209230bSgjelinek return; 3594ff19e029SMenno Lageman case PT_MAXPROCS: 3595ff19e029SMenno Lageman remove_aliased_rctl(PT_MAXPROCS, ALIAS_MAXPROCS); 3596ff19e029SMenno Lageman return; 35970209230bSgjelinek case PT_MAXSHMMEM: 35980209230bSgjelinek remove_aliased_rctl(PT_MAXSHMMEM, ALIAS_MAXSHMMEM); 35990209230bSgjelinek return; 36000209230bSgjelinek case PT_MAXSHMIDS: 36010209230bSgjelinek remove_aliased_rctl(PT_MAXSHMIDS, ALIAS_MAXSHMIDS); 36020209230bSgjelinek return; 36030209230bSgjelinek case PT_MAXMSGIDS: 36040209230bSgjelinek remove_aliased_rctl(PT_MAXMSGIDS, ALIAS_MAXMSGIDS); 36050209230bSgjelinek return; 36060209230bSgjelinek case PT_MAXSEMIDS: 36070209230bSgjelinek remove_aliased_rctl(PT_MAXSEMIDS, ALIAS_MAXSEMIDS); 36080209230bSgjelinek return; 36090209230bSgjelinek case PT_SHARES: 36100209230bSgjelinek remove_aliased_rctl(PT_SHARES, ALIAS_SHARES); 36110209230bSgjelinek return; 36125679c89fSjv227347 case PT_HOSTID: 36135679c89fSjv227347 if ((err = zonecfg_set_hostid(handle, NULL)) != Z_OK) 36145679c89fSjv227347 z_cmd_rt_perror(CMD_CLEAR, RT_HOSTID, err, B_TRUE); 36155679c89fSjv227347 else 36165679c89fSjv227347 need_to_commit = B_TRUE; 36175679c89fSjv227347 return; 36180fbb751dSJohn Levon case PT_FS_ALLOWED: 36190fbb751dSJohn Levon if ((err = zonecfg_set_fs_allowed(handle, NULL)) != Z_OK) 36200fbb751dSJohn Levon z_cmd_rt_perror(CMD_CLEAR, RT_FS_ALLOWED, err, B_TRUE); 36210fbb751dSJohn Levon else 36220fbb751dSJohn Levon need_to_commit = B_TRUE; 36230fbb751dSJohn Levon return; 36240209230bSgjelinek default: 3625bbec428eSgjelinek zone_perror(pt_to_str(type), Z_NO_PROPERTY_TYPE, B_TRUE); 3626bbec428eSgjelinek long_usage(CMD_CLEAR, B_TRUE); 3627bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 36280209230bSgjelinek return; 36290209230bSgjelinek } 36300209230bSgjelinek } 36310209230bSgjelinek 36320209230bSgjelinek void 36330209230bSgjelinek clear_func(cmd_t *cmd) 36340209230bSgjelinek { 36350209230bSgjelinek if (zone_is_read_only(CMD_CLEAR)) 36360209230bSgjelinek return; 36370209230bSgjelinek 36380209230bSgjelinek assert(cmd != NULL); 36390209230bSgjelinek 36400209230bSgjelinek if (global_scope) { 36410209230bSgjelinek if (gz_invalid_property(cmd->cmd_res_type)) { 36420209230bSgjelinek zerr(gettext("%s is not a valid property for the " 36430209230bSgjelinek "global zone."), pt_to_str(cmd->cmd_res_type)); 3644bbec428eSgjelinek saw_error = B_TRUE; 36450209230bSgjelinek return; 36460209230bSgjelinek } 36470209230bSgjelinek 36480209230bSgjelinek clear_global(cmd); 36490209230bSgjelinek } else { 36500209230bSgjelinek clear_property(cmd); 36510209230bSgjelinek } 36520209230bSgjelinek } 36537c478bd9Sstevel@tonic-gate 36547c478bd9Sstevel@tonic-gate void 36557c478bd9Sstevel@tonic-gate select_func(cmd_t *cmd) 36567c478bd9Sstevel@tonic-gate { 36570209230bSgjelinek int type, err, res; 36580209230bSgjelinek uint64_t limit; 3659c97ad5cdSakolb uint64_t tmp; 36607c478bd9Sstevel@tonic-gate 36617c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_SELECT)) 36627c478bd9Sstevel@tonic-gate return; 36637c478bd9Sstevel@tonic-gate 36647c478bd9Sstevel@tonic-gate assert(cmd != NULL); 36657c478bd9Sstevel@tonic-gate 36667c478bd9Sstevel@tonic-gate if (global_scope) { 3667bbec428eSgjelinek global_scope = B_FALSE; 36687c478bd9Sstevel@tonic-gate resource_scope = cmd->cmd_res_type; 36697c478bd9Sstevel@tonic-gate end_op = CMD_SELECT; 36707c478bd9Sstevel@tonic-gate } else { 36717c478bd9Sstevel@tonic-gate scope_usage(CMD_SELECT); 36727c478bd9Sstevel@tonic-gate return; 36737c478bd9Sstevel@tonic-gate } 36747c478bd9Sstevel@tonic-gate 36757c478bd9Sstevel@tonic-gate if ((type = cmd->cmd_res_type) == RT_UNKNOWN) { 3676bbec428eSgjelinek long_usage(CMD_SELECT, B_TRUE); 36777c478bd9Sstevel@tonic-gate return; 36787c478bd9Sstevel@tonic-gate } 36797c478bd9Sstevel@tonic-gate 3680bbec428eSgjelinek if (initialize(B_TRUE) != Z_OK) 36817c478bd9Sstevel@tonic-gate return; 36827c478bd9Sstevel@tonic-gate 36837c478bd9Sstevel@tonic-gate switch (type) { 36847c478bd9Sstevel@tonic-gate case RT_FS: 3685bbec428eSgjelinek if ((err = fill_in_fstab(cmd, &old_fstab, B_FALSE)) != Z_OK) { 3686bbec428eSgjelinek z_cmd_rt_perror(CMD_SELECT, RT_FS, err, B_TRUE); 3687bbec428eSgjelinek global_scope = B_TRUE; 36887c478bd9Sstevel@tonic-gate } 36897c478bd9Sstevel@tonic-gate bcopy(&old_fstab, &in_progress_fstab, 36907c478bd9Sstevel@tonic-gate sizeof (struct zone_fstab)); 36917c478bd9Sstevel@tonic-gate return; 36927c478bd9Sstevel@tonic-gate case RT_NET: 3693bbec428eSgjelinek if ((err = fill_in_nwiftab(cmd, &old_nwiftab, B_FALSE)) 3694bbec428eSgjelinek != Z_OK) { 3695bbec428eSgjelinek z_cmd_rt_perror(CMD_SELECT, RT_NET, err, B_TRUE); 3696bbec428eSgjelinek global_scope = B_TRUE; 36977c478bd9Sstevel@tonic-gate } 36987c478bd9Sstevel@tonic-gate bcopy(&old_nwiftab, &in_progress_nwiftab, 36997c478bd9Sstevel@tonic-gate sizeof (struct zone_nwiftab)); 37007c478bd9Sstevel@tonic-gate return; 37017c478bd9Sstevel@tonic-gate case RT_DEVICE: 3702bbec428eSgjelinek if ((err = fill_in_devtab(cmd, &old_devtab, B_FALSE)) != Z_OK) { 3703bbec428eSgjelinek z_cmd_rt_perror(CMD_SELECT, RT_DEVICE, err, B_TRUE); 3704bbec428eSgjelinek global_scope = B_TRUE; 37057c478bd9Sstevel@tonic-gate } 37067c478bd9Sstevel@tonic-gate bcopy(&old_devtab, &in_progress_devtab, 37077c478bd9Sstevel@tonic-gate sizeof (struct zone_devtab)); 37087c478bd9Sstevel@tonic-gate return; 37097c478bd9Sstevel@tonic-gate case RT_RCTL: 3710bbec428eSgjelinek if ((err = fill_in_rctltab(cmd, &old_rctltab, B_FALSE)) 3711bbec428eSgjelinek != Z_OK) { 3712bbec428eSgjelinek z_cmd_rt_perror(CMD_SELECT, RT_RCTL, err, B_TRUE); 3713bbec428eSgjelinek global_scope = B_TRUE; 37147c478bd9Sstevel@tonic-gate } 37157c478bd9Sstevel@tonic-gate bcopy(&old_rctltab, &in_progress_rctltab, 37167c478bd9Sstevel@tonic-gate sizeof (struct zone_rctltab)); 37177c478bd9Sstevel@tonic-gate return; 37187c478bd9Sstevel@tonic-gate case RT_ATTR: 3719bbec428eSgjelinek if ((err = fill_in_attrtab(cmd, &old_attrtab, B_FALSE)) 3720bbec428eSgjelinek != Z_OK) { 3721bbec428eSgjelinek z_cmd_rt_perror(CMD_SELECT, RT_ATTR, err, B_TRUE); 3722bbec428eSgjelinek global_scope = B_TRUE; 37237c478bd9Sstevel@tonic-gate } 37247c478bd9Sstevel@tonic-gate bcopy(&old_attrtab, &in_progress_attrtab, 37257c478bd9Sstevel@tonic-gate sizeof (struct zone_attrtab)); 37267c478bd9Sstevel@tonic-gate return; 3727fa9e4066Sahrens case RT_DATASET: 3728bbec428eSgjelinek if ((err = fill_in_dstab(cmd, &old_dstab, B_FALSE)) != Z_OK) { 3729bbec428eSgjelinek z_cmd_rt_perror(CMD_SELECT, RT_DATASET, err, B_TRUE); 3730bbec428eSgjelinek global_scope = B_TRUE; 3731fa9e4066Sahrens } 3732fa9e4066Sahrens bcopy(&old_dstab, &in_progress_dstab, 3733fa9e4066Sahrens sizeof (struct zone_dstab)); 3734fa9e4066Sahrens return; 37350209230bSgjelinek case RT_DCPU: 37360209230bSgjelinek if ((err = zonecfg_lookup_pset(handle, &old_psettab)) != Z_OK) { 3737bbec428eSgjelinek z_cmd_rt_perror(CMD_SELECT, RT_DCPU, err, B_TRUE); 3738bbec428eSgjelinek global_scope = B_TRUE; 37390209230bSgjelinek } 37400209230bSgjelinek bcopy(&old_psettab, &in_progress_psettab, 37410209230bSgjelinek sizeof (struct zone_psettab)); 37420209230bSgjelinek return; 3743c97ad5cdSakolb case RT_PCAP: 3744c97ad5cdSakolb if ((err = zonecfg_get_aliased_rctl(handle, ALIAS_CPUCAP, &tmp)) 3745c97ad5cdSakolb != Z_OK) { 3746bbec428eSgjelinek z_cmd_rt_perror(CMD_SELECT, RT_PCAP, err, B_TRUE); 3747bbec428eSgjelinek global_scope = B_TRUE; 3748c97ad5cdSakolb } 3749c97ad5cdSakolb return; 37500209230bSgjelinek case RT_MCAP: 37510209230bSgjelinek /* if none of these exist, there is no resource to select */ 37520209230bSgjelinek if ((res = zonecfg_lookup_mcap(handle, &old_mcaptab)) != Z_OK && 37530209230bSgjelinek zonecfg_get_aliased_rctl(handle, ALIAS_MAXSWAP, &limit) 37540209230bSgjelinek != Z_OK && 37550209230bSgjelinek zonecfg_get_aliased_rctl(handle, ALIAS_MAXLOCKEDMEM, &limit) 37560209230bSgjelinek != Z_OK) { 37570209230bSgjelinek z_cmd_rt_perror(CMD_SELECT, RT_MCAP, Z_NO_RESOURCE_TYPE, 3758bbec428eSgjelinek B_TRUE); 3759bbec428eSgjelinek global_scope = B_TRUE; 37600209230bSgjelinek } 37610209230bSgjelinek if (res == Z_OK) 37620209230bSgjelinek bcopy(&old_mcaptab, &in_progress_mcaptab, 37630209230bSgjelinek sizeof (struct zone_mcaptab)); 37640209230bSgjelinek else 37650209230bSgjelinek bzero(&in_progress_mcaptab, 37660209230bSgjelinek sizeof (in_progress_mcaptab)); 37670209230bSgjelinek return; 3768cb8a054bSGlenn Faden case RT_ADMIN: 3769cb8a054bSGlenn Faden if ((err = fill_in_admintab(cmd, &old_admintab, B_FALSE)) 3770cb8a054bSGlenn Faden != Z_OK) { 3771cb8a054bSGlenn Faden z_cmd_rt_perror(CMD_SELECT, RT_ADMIN, err, 3772cb8a054bSGlenn Faden B_TRUE); 3773cb8a054bSGlenn Faden global_scope = B_TRUE; 3774cb8a054bSGlenn Faden } 3775cb8a054bSGlenn Faden bcopy(&old_admintab, &in_progress_admintab, 3776cb8a054bSGlenn Faden sizeof (struct zone_admintab)); 3777cb8a054bSGlenn Faden return; 37787c478bd9Sstevel@tonic-gate default: 3779bbec428eSgjelinek zone_perror(rt_to_str(type), Z_NO_RESOURCE_TYPE, B_TRUE); 3780bbec428eSgjelinek long_usage(CMD_SELECT, B_TRUE); 3781bbec428eSgjelinek usage(B_FALSE, HELP_RESOURCES); 37827c478bd9Sstevel@tonic-gate return; 37837c478bd9Sstevel@tonic-gate } 37847c478bd9Sstevel@tonic-gate } 37857c478bd9Sstevel@tonic-gate 37867c478bd9Sstevel@tonic-gate /* 37877c478bd9Sstevel@tonic-gate * Network "addresses" can be one of the following forms: 37887c478bd9Sstevel@tonic-gate * <IPv4 address> 37897c478bd9Sstevel@tonic-gate * <IPv4 address>/<prefix length> 37907c478bd9Sstevel@tonic-gate * <IPv6 address>/<prefix length> 37917c478bd9Sstevel@tonic-gate * <host name> 37927c478bd9Sstevel@tonic-gate * <host name>/<prefix length> 37937c478bd9Sstevel@tonic-gate * In other words, the "/" followed by a prefix length is allowed but not 37947c478bd9Sstevel@tonic-gate * required for IPv4 addresses and host names, and required for IPv6 addresses. 37957c478bd9Sstevel@tonic-gate * If a prefix length is given, it must be in the allowable range: 0 to 32 for 37967c478bd9Sstevel@tonic-gate * IPv4 addresses and host names, 0 to 128 for IPv6 addresses. 37977c478bd9Sstevel@tonic-gate * Host names must start with an alpha-numeric character, and all subsequent 37987c478bd9Sstevel@tonic-gate * characters must be either alpha-numeric or "-". 3799550b6e40SSowmini Varadhan * 3800550b6e40SSowmini Varadhan * In some cases, e.g., the nexthop for the defrouter, the context indicates 3801550b6e40SSowmini Varadhan * that this is the IPV4_ABITS or IPV6_ABITS netmask, in which case we don't 3802550b6e40SSowmini Varadhan * require the /<prefix length> (and should ignore it if provided). 38037c478bd9Sstevel@tonic-gate */ 38047c478bd9Sstevel@tonic-gate 38057c478bd9Sstevel@tonic-gate static int 3806550b6e40SSowmini Varadhan validate_net_address_syntax(char *address, boolean_t ishost) 38077c478bd9Sstevel@tonic-gate { 38087c478bd9Sstevel@tonic-gate char *slashp, part1[MAXHOSTNAMELEN]; 38097c478bd9Sstevel@tonic-gate struct in6_addr in6; 38107c478bd9Sstevel@tonic-gate struct in_addr in4; 38117c478bd9Sstevel@tonic-gate int prefixlen, i; 38127c478bd9Sstevel@tonic-gate 38137c478bd9Sstevel@tonic-gate /* 38147c478bd9Sstevel@tonic-gate * Copy the part before any '/' into part1 or copy the whole 38157c478bd9Sstevel@tonic-gate * thing if there is no '/'. 38167c478bd9Sstevel@tonic-gate */ 38177c478bd9Sstevel@tonic-gate if ((slashp = strchr(address, '/')) != NULL) { 38187c478bd9Sstevel@tonic-gate *slashp = '\0'; 38197c478bd9Sstevel@tonic-gate (void) strlcpy(part1, address, sizeof (part1)); 38207c478bd9Sstevel@tonic-gate *slashp = '/'; 38217c478bd9Sstevel@tonic-gate prefixlen = atoi(++slashp); 38227c478bd9Sstevel@tonic-gate } else { 38237c478bd9Sstevel@tonic-gate (void) strlcpy(part1, address, sizeof (part1)); 38247c478bd9Sstevel@tonic-gate } 38257c478bd9Sstevel@tonic-gate 3826550b6e40SSowmini Varadhan if (ishost && slashp != NULL) { 3827550b6e40SSowmini Varadhan zerr(gettext("Warning: prefix length in %s is not required and " 3828550b6e40SSowmini Varadhan "will be ignored. The default host-prefix length " 3829550b6e40SSowmini Varadhan "will be used"), address); 3830550b6e40SSowmini Varadhan } 3831550b6e40SSowmini Varadhan 3832550b6e40SSowmini Varadhan 38337c478bd9Sstevel@tonic-gate if (inet_pton(AF_INET6, part1, &in6) == 1) { 3834550b6e40SSowmini Varadhan if (ishost) { 3835550b6e40SSowmini Varadhan prefixlen = IPV6_ABITS; 3836550b6e40SSowmini Varadhan } else if (slashp == NULL) { 38377c478bd9Sstevel@tonic-gate zerr(gettext("%s: IPv6 addresses " 38387c478bd9Sstevel@tonic-gate "require /prefix-length suffix."), address); 38397c478bd9Sstevel@tonic-gate return (Z_ERR); 38407c478bd9Sstevel@tonic-gate } 38417c478bd9Sstevel@tonic-gate if (prefixlen < 0 || prefixlen > 128) { 38427c478bd9Sstevel@tonic-gate zerr(gettext("%s: IPv6 address " 38437c478bd9Sstevel@tonic-gate "prefix lengths must be 0 - 128."), address); 38447c478bd9Sstevel@tonic-gate return (Z_ERR); 38457c478bd9Sstevel@tonic-gate } 38467c478bd9Sstevel@tonic-gate return (Z_OK); 38477c478bd9Sstevel@tonic-gate } 38487c478bd9Sstevel@tonic-gate 38497c478bd9Sstevel@tonic-gate /* At this point, any /prefix must be for IPv4. */ 3850550b6e40SSowmini Varadhan if (ishost) 3851550b6e40SSowmini Varadhan prefixlen = IPV4_ABITS; 3852550b6e40SSowmini Varadhan else if (slashp != NULL) { 38537c478bd9Sstevel@tonic-gate if (prefixlen < 0 || prefixlen > 32) { 38547c478bd9Sstevel@tonic-gate zerr(gettext("%s: IPv4 address " 38557c478bd9Sstevel@tonic-gate "prefix lengths must be 0 - 32."), address); 38567c478bd9Sstevel@tonic-gate return (Z_ERR); 38577c478bd9Sstevel@tonic-gate } 38587c478bd9Sstevel@tonic-gate } 3859550b6e40SSowmini Varadhan 38607c478bd9Sstevel@tonic-gate if (inet_pton(AF_INET, part1, &in4) == 1) 38617c478bd9Sstevel@tonic-gate return (Z_OK); 38627c478bd9Sstevel@tonic-gate 38637c478bd9Sstevel@tonic-gate /* address may also be a host name */ 38647c478bd9Sstevel@tonic-gate if (!isalnum(part1[0])) { 38657c478bd9Sstevel@tonic-gate zerr(gettext("%s: bogus host name or network address syntax"), 38667c478bd9Sstevel@tonic-gate part1); 3867bbec428eSgjelinek saw_error = B_TRUE; 3868bbec428eSgjelinek usage(B_FALSE, HELP_NETADDR); 38697c478bd9Sstevel@tonic-gate return (Z_ERR); 38707c478bd9Sstevel@tonic-gate } 38717c478bd9Sstevel@tonic-gate for (i = 1; part1[i]; i++) 38727c478bd9Sstevel@tonic-gate if (!isalnum(part1[i]) && part1[i] != '-' && part1[i] != '.') { 38737c478bd9Sstevel@tonic-gate zerr(gettext("%s: bogus host name or " 38747c478bd9Sstevel@tonic-gate "network address syntax"), part1); 3875bbec428eSgjelinek saw_error = B_TRUE; 3876bbec428eSgjelinek usage(B_FALSE, HELP_NETADDR); 38777c478bd9Sstevel@tonic-gate return (Z_ERR); 38787c478bd9Sstevel@tonic-gate } 38797c478bd9Sstevel@tonic-gate return (Z_OK); 38807c478bd9Sstevel@tonic-gate } 38817c478bd9Sstevel@tonic-gate 38827c478bd9Sstevel@tonic-gate static int 3883c9f134eaSjv227347 validate_net_physical_syntax(const char *ifname) 38847c478bd9Sstevel@tonic-gate { 3885c9f134eaSjv227347 ifspec_t ifnameprop; 3886c9f134eaSjv227347 zone_iptype_t iptype; 3887c9f134eaSjv227347 388837b210dcSjv227347 if (zonecfg_get_iptype(handle, &iptype) != Z_OK) { 3889c9f134eaSjv227347 zerr(gettext("zone configuration has an invalid or nonexistent " 3890c9f134eaSjv227347 "ip-type property")); 38917c478bd9Sstevel@tonic-gate return (Z_ERR); 38927c478bd9Sstevel@tonic-gate } 3893c9f134eaSjv227347 switch (iptype) { 3894c9f134eaSjv227347 case ZS_SHARED: 3895c9f134eaSjv227347 if (ifparse_ifspec(ifname, &ifnameprop) == B_FALSE) { 3896c9f134eaSjv227347 zerr(gettext("%s: invalid physical interface name"), 3897c9f134eaSjv227347 ifname); 3898c9f134eaSjv227347 return (Z_ERR); 3899c9f134eaSjv227347 } 3900c9f134eaSjv227347 if (ifnameprop.ifsp_lunvalid) { 3901c9f134eaSjv227347 zerr(gettext("%s: LUNs not allowed in physical " 3902c9f134eaSjv227347 "interface names"), ifname); 3903c9f134eaSjv227347 return (Z_ERR); 3904c9f134eaSjv227347 } 3905c9f134eaSjv227347 break; 3906c9f134eaSjv227347 case ZS_EXCLUSIVE: 3907c9f134eaSjv227347 if (dladm_valid_linkname(ifname) == B_FALSE) { 3908c9f134eaSjv227347 if (strchr(ifname, ':') != NULL) 3909c9f134eaSjv227347 zerr(gettext("%s: physical interface name " 3910c9f134eaSjv227347 "required; logical interface name not " 3911c9f134eaSjv227347 "allowed"), ifname); 3912c9f134eaSjv227347 else 3913c9f134eaSjv227347 zerr(gettext("%s: invalid physical interface " 3914c9f134eaSjv227347 "name"), ifname); 3915c9f134eaSjv227347 return (Z_ERR); 3916c9f134eaSjv227347 } 3917c9f134eaSjv227347 break; 3918c9f134eaSjv227347 } 3919c9f134eaSjv227347 return (Z_OK); 3920c9f134eaSjv227347 } 39217c478bd9Sstevel@tonic-gate 39227c478bd9Sstevel@tonic-gate static boolean_t 39237c478bd9Sstevel@tonic-gate valid_fs_type(const char *type) 39247c478bd9Sstevel@tonic-gate { 39257c478bd9Sstevel@tonic-gate /* 39267c478bd9Sstevel@tonic-gate * Is this a valid path component? 39277c478bd9Sstevel@tonic-gate */ 39287c478bd9Sstevel@tonic-gate if (strlen(type) + 1 > MAXNAMELEN) 39297c478bd9Sstevel@tonic-gate return (B_FALSE); 39307c478bd9Sstevel@tonic-gate /* 39317c478bd9Sstevel@tonic-gate * Make sure a bad value for "type" doesn't make 39327c478bd9Sstevel@tonic-gate * /usr/lib/fs/<type>/mount turn into something else. 39337c478bd9Sstevel@tonic-gate */ 39347c478bd9Sstevel@tonic-gate if (strchr(type, '/') != NULL || type[0] == '\0' || 39357c478bd9Sstevel@tonic-gate strcmp(type, ".") == 0 || strcmp(type, "..") == 0) 39367c478bd9Sstevel@tonic-gate return (B_FALSE); 39377c478bd9Sstevel@tonic-gate /* 39387c478bd9Sstevel@tonic-gate * More detailed verification happens later by zoneadm(1m). 39397c478bd9Sstevel@tonic-gate */ 39407c478bd9Sstevel@tonic-gate return (B_TRUE); 39417c478bd9Sstevel@tonic-gate } 39427c478bd9Sstevel@tonic-gate 3943f4b3ec61Sdh155122 static boolean_t 3944f4b3ec61Sdh155122 allow_exclusive() 3945f4b3ec61Sdh155122 { 3946f4b3ec61Sdh155122 brand_handle_t bh; 3947f4b3ec61Sdh155122 char brand[MAXNAMELEN]; 3948f4b3ec61Sdh155122 boolean_t ret; 3949f4b3ec61Sdh155122 3950f4b3ec61Sdh155122 if (zonecfg_get_brand(handle, brand, sizeof (brand)) != Z_OK) { 3951f4b3ec61Sdh155122 zerr("%s: %s\n", zone, gettext("could not get zone brand")); 3952f4b3ec61Sdh155122 return (B_FALSE); 3953f4b3ec61Sdh155122 } 3954f4b3ec61Sdh155122 if ((bh = brand_open(brand)) == NULL) { 3955f4b3ec61Sdh155122 zerr("%s: %s\n", zone, gettext("unknown brand.")); 3956f4b3ec61Sdh155122 return (B_FALSE); 3957f4b3ec61Sdh155122 } 3958f4b3ec61Sdh155122 ret = brand_allow_exclusive_ip(bh); 3959f4b3ec61Sdh155122 brand_close(bh); 3960f4b3ec61Sdh155122 if (!ret) 3961f4b3ec61Sdh155122 zerr(gettext("%s cannot be '%s' when %s is '%s'."), 3962f4b3ec61Sdh155122 pt_to_str(PT_IPTYPE), "exclusive", 3963f4b3ec61Sdh155122 pt_to_str(PT_BRAND), brand); 3964f4b3ec61Sdh155122 return (ret); 3965f4b3ec61Sdh155122 } 3966f4b3ec61Sdh155122 39670209230bSgjelinek static void 39680209230bSgjelinek set_aliased_rctl(char *alias, int prop_type, char *s) 39690209230bSgjelinek { 39700209230bSgjelinek uint64_t limit; 39710209230bSgjelinek int err; 39720209230bSgjelinek char tmp[128]; 39730209230bSgjelinek 39740209230bSgjelinek if (global_zone && strcmp(alias, ALIAS_SHARES) != 0) 39750209230bSgjelinek zerr(gettext("WARNING: Setting a global zone resource " 39760209230bSgjelinek "control too low could deny\nservice " 39770209230bSgjelinek "to even the root user; " 39780209230bSgjelinek "this could render the system impossible\n" 39790209230bSgjelinek "to administer. Please use caution.")); 39800209230bSgjelinek 39810209230bSgjelinek /* convert memory based properties */ 39820209230bSgjelinek if (prop_type == PT_MAXSHMMEM) { 39830209230bSgjelinek if (!zonecfg_valid_memlimit(s, &limit)) { 39840209230bSgjelinek zerr(gettext("A non-negative number with a required " 39850209230bSgjelinek "scale suffix (K, M, G or T) was expected\nhere.")); 3986bbec428eSgjelinek saw_error = B_TRUE; 39870209230bSgjelinek return; 39880209230bSgjelinek } 39890209230bSgjelinek 39900209230bSgjelinek (void) snprintf(tmp, sizeof (tmp), "%llu", limit); 39910209230bSgjelinek s = tmp; 39920209230bSgjelinek } 39930209230bSgjelinek 39940209230bSgjelinek if (!zonecfg_aliased_rctl_ok(handle, alias)) { 3995bbec428eSgjelinek zone_perror(pt_to_str(prop_type), Z_ALIAS_DISALLOW, B_FALSE); 3996bbec428eSgjelinek saw_error = B_TRUE; 39970209230bSgjelinek } else if (!zonecfg_valid_alias_limit(alias, s, &limit)) { 39980209230bSgjelinek zerr(gettext("%s property is out of range."), 39990209230bSgjelinek pt_to_str(prop_type)); 4000bbec428eSgjelinek saw_error = B_TRUE; 40010209230bSgjelinek } else if ((err = zonecfg_set_aliased_rctl(handle, alias, limit)) 40020209230bSgjelinek != Z_OK) { 4003bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 4004bbec428eSgjelinek saw_error = B_TRUE; 40050209230bSgjelinek } else { 4006bbec428eSgjelinek need_to_commit = B_TRUE; 40070209230bSgjelinek } 40080209230bSgjelinek } 40090209230bSgjelinek 4010550b6e40SSowmini Varadhan static void 4011550b6e40SSowmini Varadhan set_in_progress_nwiftab_address(char *prop_id, int prop_type) 4012550b6e40SSowmini Varadhan { 4013550b6e40SSowmini Varadhan if (prop_type == PT_ADDRESS) { 4014550b6e40SSowmini Varadhan (void) strlcpy(in_progress_nwiftab.zone_nwif_address, prop_id, 4015550b6e40SSowmini Varadhan sizeof (in_progress_nwiftab.zone_nwif_address)); 4016550b6e40SSowmini Varadhan } else { 4017550b6e40SSowmini Varadhan assert(prop_type == PT_ALLOWED_ADDRESS); 4018550b6e40SSowmini Varadhan (void) strlcpy(in_progress_nwiftab.zone_nwif_allowed_address, 4019550b6e40SSowmini Varadhan prop_id, 4020550b6e40SSowmini Varadhan sizeof (in_progress_nwiftab.zone_nwif_allowed_address)); 4021550b6e40SSowmini Varadhan } 4022550b6e40SSowmini Varadhan } 4023550b6e40SSowmini Varadhan 40247c478bd9Sstevel@tonic-gate void 40257c478bd9Sstevel@tonic-gate set_func(cmd_t *cmd) 40267c478bd9Sstevel@tonic-gate { 40277c478bd9Sstevel@tonic-gate char *prop_id; 4028555afedfScarlsonj int arg, err, res_type, prop_type; 40297c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 40307c478bd9Sstevel@tonic-gate boolean_t autoboot; 4031f4b3ec61Sdh155122 zone_iptype_t iptype; 4032bbec428eSgjelinek boolean_t force_set = B_FALSE; 40330209230bSgjelinek size_t physmem_size = sizeof (in_progress_mcaptab.zone_physmem_cap); 40340209230bSgjelinek uint64_t mem_cap, mem_limit; 4035c97ad5cdSakolb float cap; 4036c97ad5cdSakolb char *unitp; 40370209230bSgjelinek struct zone_psettab tmp_psettab; 4038bbec428eSgjelinek boolean_t arg_err = B_FALSE; 40397c478bd9Sstevel@tonic-gate 40407c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_SET)) 40417c478bd9Sstevel@tonic-gate return; 40427c478bd9Sstevel@tonic-gate 40437c478bd9Sstevel@tonic-gate assert(cmd != NULL); 40447c478bd9Sstevel@tonic-gate 4045555afedfScarlsonj optind = opterr = 0; 4046555afedfScarlsonj while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "F")) != EOF) { 4047555afedfScarlsonj switch (arg) { 4048555afedfScarlsonj case 'F': 4049bbec428eSgjelinek force_set = B_TRUE; 4050555afedfScarlsonj break; 4051555afedfScarlsonj default: 4052555afedfScarlsonj if (optopt == '?') 4053555afedfScarlsonj longer_usage(CMD_SET); 4054555afedfScarlsonj else 4055555afedfScarlsonj short_usage(CMD_SET); 4056bbec428eSgjelinek arg_err = B_TRUE; 40577ec75eb8Sgjelinek break; 40587ec75eb8Sgjelinek } 40597ec75eb8Sgjelinek } 40607ec75eb8Sgjelinek if (arg_err) 4061555afedfScarlsonj return; 4062555afedfScarlsonj 40637c478bd9Sstevel@tonic-gate prop_type = cmd->cmd_prop_name[0]; 40647c478bd9Sstevel@tonic-gate if (global_scope) { 40650209230bSgjelinek if (gz_invalid_property(prop_type)) { 40660209230bSgjelinek zerr(gettext("%s is not a valid property for the " 40670209230bSgjelinek "global zone."), pt_to_str(prop_type)); 4068bbec428eSgjelinek saw_error = B_TRUE; 40690209230bSgjelinek return; 40700209230bSgjelinek } 40710209230bSgjelinek 4072087719fdSdp if (prop_type == PT_ZONENAME) { 4073087719fdSdp res_type = RT_ZONENAME; 4074087719fdSdp } else if (prop_type == PT_ZONEPATH) { 40757c478bd9Sstevel@tonic-gate res_type = RT_ZONEPATH; 40767c478bd9Sstevel@tonic-gate } else if (prop_type == PT_AUTOBOOT) { 40777c478bd9Sstevel@tonic-gate res_type = RT_AUTOBOOT; 40789acbbeafSnn35248 } else if (prop_type == PT_BRAND) { 40799acbbeafSnn35248 res_type = RT_BRAND; 40807c478bd9Sstevel@tonic-gate } else if (prop_type == PT_POOL) { 40817c478bd9Sstevel@tonic-gate res_type = RT_POOL; 4082ffbafc53Scomay } else if (prop_type == PT_LIMITPRIV) { 4083ffbafc53Scomay res_type = RT_LIMITPRIV; 40843f2f09c1Sdp } else if (prop_type == PT_BOOTARGS) { 40853f2f09c1Sdp res_type = RT_BOOTARGS; 40860209230bSgjelinek } else if (prop_type == PT_SCHED) { 40870209230bSgjelinek res_type = RT_SCHED; 4088f4b3ec61Sdh155122 } else if (prop_type == PT_IPTYPE) { 4089f4b3ec61Sdh155122 res_type = RT_IPTYPE; 40900209230bSgjelinek } else if (prop_type == PT_MAXLWPS) { 40910209230bSgjelinek res_type = RT_MAXLWPS; 4092ff19e029SMenno Lageman } else if (prop_type == PT_MAXPROCS) { 4093ff19e029SMenno Lageman res_type = RT_MAXPROCS; 40940209230bSgjelinek } else if (prop_type == PT_MAXSHMMEM) { 40950209230bSgjelinek res_type = RT_MAXSHMMEM; 40960209230bSgjelinek } else if (prop_type == PT_MAXSHMIDS) { 40970209230bSgjelinek res_type = RT_MAXSHMIDS; 40980209230bSgjelinek } else if (prop_type == PT_MAXMSGIDS) { 40990209230bSgjelinek res_type = RT_MAXMSGIDS; 41000209230bSgjelinek } else if (prop_type == PT_MAXSEMIDS) { 41010209230bSgjelinek res_type = RT_MAXSEMIDS; 41020209230bSgjelinek } else if (prop_type == PT_SHARES) { 41030209230bSgjelinek res_type = RT_SHARES; 41045679c89fSjv227347 } else if (prop_type == PT_HOSTID) { 41055679c89fSjv227347 res_type = RT_HOSTID; 41060fbb751dSJohn Levon } else if (prop_type == PT_FS_ALLOWED) { 41070fbb751dSJohn Levon res_type = RT_FS_ALLOWED; 41087c478bd9Sstevel@tonic-gate } else { 41097c478bd9Sstevel@tonic-gate zerr(gettext("Cannot set a resource-specific property " 41107c478bd9Sstevel@tonic-gate "from the global scope.")); 4111bbec428eSgjelinek saw_error = B_TRUE; 41127c478bd9Sstevel@tonic-gate return; 41137c478bd9Sstevel@tonic-gate } 41147c478bd9Sstevel@tonic-gate } else { 41157c478bd9Sstevel@tonic-gate res_type = resource_scope; 41167c478bd9Sstevel@tonic-gate } 41177c478bd9Sstevel@tonic-gate 4118555afedfScarlsonj if (force_set) { 4119555afedfScarlsonj if (res_type != RT_ZONEPATH) { 4120555afedfScarlsonj zerr(gettext("Only zonepath setting can be forced.")); 4121bbec428eSgjelinek saw_error = B_TRUE; 4122555afedfScarlsonj return; 4123555afedfScarlsonj } 4124555afedfScarlsonj if (!zonecfg_in_alt_root()) { 4125555afedfScarlsonj zerr(gettext("Zonepath is changeable only in an " 4126555afedfScarlsonj "alternate root.")); 4127bbec428eSgjelinek saw_error = B_TRUE; 4128555afedfScarlsonj return; 4129555afedfScarlsonj } 4130555afedfScarlsonj } 4131555afedfScarlsonj 41327c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[0]; 41337c478bd9Sstevel@tonic-gate /* 41347c478bd9Sstevel@tonic-gate * A nasty expression but not that complicated: 41357c478bd9Sstevel@tonic-gate * 1. fs options are simple or list (tested below) 41367c478bd9Sstevel@tonic-gate * 2. rctl value's are complex or list (tested below) 41377c478bd9Sstevel@tonic-gate * Anything else should be simple. 41387c478bd9Sstevel@tonic-gate */ 41397c478bd9Sstevel@tonic-gate if (!(res_type == RT_FS && prop_type == PT_OPTIONS) && 41407c478bd9Sstevel@tonic-gate !(res_type == RT_RCTL && prop_type == PT_VALUE) && 41417c478bd9Sstevel@tonic-gate (pp->pv_type != PROP_VAL_SIMPLE || 41427c478bd9Sstevel@tonic-gate (prop_id = pp->pv_simple) == NULL)) { 41437c478bd9Sstevel@tonic-gate zerr(gettext("A %s value was expected here."), 41447c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_SIMPLE)); 4145bbec428eSgjelinek saw_error = B_TRUE; 41467c478bd9Sstevel@tonic-gate return; 41477c478bd9Sstevel@tonic-gate } 41487c478bd9Sstevel@tonic-gate if (prop_type == PT_UNKNOWN) { 4149bbec428eSgjelinek long_usage(CMD_SET, B_TRUE); 41507c478bd9Sstevel@tonic-gate return; 41517c478bd9Sstevel@tonic-gate } 41527c478bd9Sstevel@tonic-gate 4153087719fdSdp /* 4154087719fdSdp * Special case: the user can change the zone name prior to 'create'; 4155087719fdSdp * if the zone already exists, we fall through letting initialize() 4156087719fdSdp * and the rest of the logic run. 4157087719fdSdp */ 4158bbec428eSgjelinek if (res_type == RT_ZONENAME && got_handle == B_FALSE && 4159087719fdSdp !state_atleast(ZONE_STATE_CONFIGURED)) { 4160fb03efaaSdp if ((err = zonecfg_validate_zonename(prop_id)) != Z_OK) { 4161bbec428eSgjelinek zone_perror(prop_id, err, B_TRUE); 4162bbec428eSgjelinek usage(B_FALSE, HELP_SYNTAX); 4163fb03efaaSdp return; 4164fb03efaaSdp } 4165087719fdSdp (void) strlcpy(zone, prop_id, sizeof (zone)); 4166087719fdSdp return; 4167087719fdSdp } 4168087719fdSdp 4169bbec428eSgjelinek if (initialize(B_TRUE) != Z_OK) 41707c478bd9Sstevel@tonic-gate return; 41717c478bd9Sstevel@tonic-gate 41727c478bd9Sstevel@tonic-gate switch (res_type) { 4173087719fdSdp case RT_ZONENAME: 4174087719fdSdp if ((err = zonecfg_set_name(handle, prop_id)) != Z_OK) { 4175087719fdSdp /* 4176087719fdSdp * Use prop_id instead of 'zone' here, since we're 4177087719fdSdp * reporting a problem about the *new* zonename. 4178087719fdSdp */ 4179bbec428eSgjelinek zone_perror(prop_id, err, B_TRUE); 4180bbec428eSgjelinek usage(B_FALSE, HELP_SYNTAX); 4181087719fdSdp } else { 4182bbec428eSgjelinek need_to_commit = B_TRUE; 4183087719fdSdp (void) strlcpy(zone, prop_id, sizeof (zone)); 4184087719fdSdp } 4185087719fdSdp return; 41867c478bd9Sstevel@tonic-gate case RT_ZONEPATH: 4187555afedfScarlsonj if (!force_set && state_atleast(ZONE_STATE_INSTALLED)) { 41887c478bd9Sstevel@tonic-gate zerr(gettext("Zone %s already installed; %s %s not " 41897c478bd9Sstevel@tonic-gate "allowed."), zone, cmd_to_str(CMD_SET), 41907c478bd9Sstevel@tonic-gate rt_to_str(RT_ZONEPATH)); 41917c478bd9Sstevel@tonic-gate return; 41927c478bd9Sstevel@tonic-gate } 41937c478bd9Sstevel@tonic-gate if (validate_zonepath_syntax(prop_id) != Z_OK) { 4194bbec428eSgjelinek saw_error = B_TRUE; 41957c478bd9Sstevel@tonic-gate return; 41967c478bd9Sstevel@tonic-gate } 41977c478bd9Sstevel@tonic-gate if ((err = zonecfg_set_zonepath(handle, prop_id)) != Z_OK) 4198bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 41997c478bd9Sstevel@tonic-gate else 4200bbec428eSgjelinek need_to_commit = B_TRUE; 42017c478bd9Sstevel@tonic-gate return; 42029acbbeafSnn35248 case RT_BRAND: 42039acbbeafSnn35248 if (state_atleast(ZONE_STATE_INSTALLED)) { 42049acbbeafSnn35248 zerr(gettext("Zone %s already installed; %s %s not " 42059acbbeafSnn35248 "allowed."), zone, cmd_to_str(CMD_SET), 42069acbbeafSnn35248 rt_to_str(RT_BRAND)); 42079acbbeafSnn35248 return; 42089acbbeafSnn35248 } 42099acbbeafSnn35248 if ((err = zonecfg_set_brand(handle, prop_id)) != Z_OK) 4210bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 42119acbbeafSnn35248 else 4212bbec428eSgjelinek need_to_commit = B_TRUE; 42139acbbeafSnn35248 return; 42147c478bd9Sstevel@tonic-gate case RT_AUTOBOOT: 42157c478bd9Sstevel@tonic-gate if (strcmp(prop_id, "true") == 0) { 42167c478bd9Sstevel@tonic-gate autoboot = B_TRUE; 42177c478bd9Sstevel@tonic-gate } else if (strcmp(prop_id, "false") == 0) { 42187c478bd9Sstevel@tonic-gate autoboot = B_FALSE; 42197c478bd9Sstevel@tonic-gate } else { 42207c478bd9Sstevel@tonic-gate zerr(gettext("%s value must be '%s' or '%s'."), 42217c478bd9Sstevel@tonic-gate pt_to_str(PT_AUTOBOOT), "true", "false"); 4222bbec428eSgjelinek saw_error = B_TRUE; 42237c478bd9Sstevel@tonic-gate return; 42247c478bd9Sstevel@tonic-gate } 42257c478bd9Sstevel@tonic-gate if ((err = zonecfg_set_autoboot(handle, autoboot)) != Z_OK) 4226bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 42277c478bd9Sstevel@tonic-gate else 4228bbec428eSgjelinek need_to_commit = B_TRUE; 42297c478bd9Sstevel@tonic-gate return; 42307c478bd9Sstevel@tonic-gate case RT_POOL: 42310209230bSgjelinek /* don't allow use of the reserved temporary pool names */ 42320209230bSgjelinek if (strncmp("SUNW", prop_id, 4) == 0) { 42330209230bSgjelinek zerr(gettext("pool names starting with SUNW are " 42340209230bSgjelinek "reserved.")); 4235bbec428eSgjelinek saw_error = B_TRUE; 42360209230bSgjelinek return; 42370209230bSgjelinek } 42380209230bSgjelinek 42390209230bSgjelinek /* can't set pool if dedicated-cpu exists */ 42400209230bSgjelinek if (zonecfg_lookup_pset(handle, &tmp_psettab) == Z_OK) { 42410209230bSgjelinek zerr(gettext("The %s resource already exists. " 42420209230bSgjelinek "A persistent pool is incompatible\nwith the %s " 42430209230bSgjelinek "resource."), rt_to_str(RT_DCPU), 42440209230bSgjelinek rt_to_str(RT_DCPU)); 4245bbec428eSgjelinek saw_error = B_TRUE; 42460209230bSgjelinek return; 42470209230bSgjelinek } 42480209230bSgjelinek 42497c478bd9Sstevel@tonic-gate if ((err = zonecfg_set_pool(handle, prop_id)) != Z_OK) 4250bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 42517c478bd9Sstevel@tonic-gate else 4252bbec428eSgjelinek need_to_commit = B_TRUE; 42537c478bd9Sstevel@tonic-gate return; 4254ffbafc53Scomay case RT_LIMITPRIV: 4255ffbafc53Scomay if ((err = zonecfg_set_limitpriv(handle, prop_id)) != Z_OK) 4256bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 4257ffbafc53Scomay else 4258bbec428eSgjelinek need_to_commit = B_TRUE; 4259ffbafc53Scomay return; 42603f2f09c1Sdp case RT_BOOTARGS: 42613f2f09c1Sdp if ((err = zonecfg_set_bootargs(handle, prop_id)) != Z_OK) 4262bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 42633f2f09c1Sdp else 4264bbec428eSgjelinek need_to_commit = B_TRUE; 42653f2f09c1Sdp return; 42660209230bSgjelinek case RT_SCHED: 42670209230bSgjelinek if ((err = zonecfg_set_sched(handle, prop_id)) != Z_OK) 4268bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 42690209230bSgjelinek else 4270bbec428eSgjelinek need_to_commit = B_TRUE; 42710209230bSgjelinek return; 4272f4b3ec61Sdh155122 case RT_IPTYPE: 4273f4b3ec61Sdh155122 if (strcmp(prop_id, "shared") == 0) { 4274f4b3ec61Sdh155122 iptype = ZS_SHARED; 4275f4b3ec61Sdh155122 } else if (strcmp(prop_id, "exclusive") == 0) { 4276f4b3ec61Sdh155122 iptype = ZS_EXCLUSIVE; 4277f4b3ec61Sdh155122 } else { 4278f4b3ec61Sdh155122 zerr(gettext("%s value must be '%s' or '%s'."), 4279f4b3ec61Sdh155122 pt_to_str(PT_IPTYPE), "shared", "exclusive"); 4280bbec428eSgjelinek saw_error = B_TRUE; 4281f4b3ec61Sdh155122 return; 4282f4b3ec61Sdh155122 } 4283f4b3ec61Sdh155122 if (iptype == ZS_EXCLUSIVE && !allow_exclusive()) { 4284bbec428eSgjelinek saw_error = B_TRUE; 4285f4b3ec61Sdh155122 return; 4286f4b3ec61Sdh155122 } 4287f4b3ec61Sdh155122 if ((err = zonecfg_set_iptype(handle, iptype)) != Z_OK) 4288bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 4289f4b3ec61Sdh155122 else 4290bbec428eSgjelinek need_to_commit = B_TRUE; 4291f4b3ec61Sdh155122 return; 42920209230bSgjelinek case RT_MAXLWPS: 42930209230bSgjelinek set_aliased_rctl(ALIAS_MAXLWPS, prop_type, prop_id); 42940209230bSgjelinek return; 4295ff19e029SMenno Lageman case RT_MAXPROCS: 4296ff19e029SMenno Lageman set_aliased_rctl(ALIAS_MAXPROCS, prop_type, prop_id); 4297ff19e029SMenno Lageman return; 42980209230bSgjelinek case RT_MAXSHMMEM: 42990209230bSgjelinek set_aliased_rctl(ALIAS_MAXSHMMEM, prop_type, prop_id); 43000209230bSgjelinek return; 43010209230bSgjelinek case RT_MAXSHMIDS: 43020209230bSgjelinek set_aliased_rctl(ALIAS_MAXSHMIDS, prop_type, prop_id); 43030209230bSgjelinek return; 43040209230bSgjelinek case RT_MAXMSGIDS: 43050209230bSgjelinek set_aliased_rctl(ALIAS_MAXMSGIDS, prop_type, prop_id); 43060209230bSgjelinek return; 43070209230bSgjelinek case RT_MAXSEMIDS: 43080209230bSgjelinek set_aliased_rctl(ALIAS_MAXSEMIDS, prop_type, prop_id); 43090209230bSgjelinek return; 43100209230bSgjelinek case RT_SHARES: 43110209230bSgjelinek set_aliased_rctl(ALIAS_SHARES, prop_type, prop_id); 43120209230bSgjelinek return; 43135679c89fSjv227347 case RT_HOSTID: 43145679c89fSjv227347 if ((err = zonecfg_set_hostid(handle, prop_id)) != Z_OK) { 43155679c89fSjv227347 if (err == Z_TOO_BIG) { 43165679c89fSjv227347 zerr(gettext("hostid string is too large: %s"), 43175679c89fSjv227347 prop_id); 43185679c89fSjv227347 saw_error = B_TRUE; 43195679c89fSjv227347 } else { 43205679c89fSjv227347 zone_perror(pt_to_str(prop_type), err, B_TRUE); 43215679c89fSjv227347 } 43225679c89fSjv227347 return; 43235679c89fSjv227347 } 43245679c89fSjv227347 need_to_commit = B_TRUE; 43255679c89fSjv227347 return; 43260fbb751dSJohn Levon case RT_FS_ALLOWED: 43270fbb751dSJohn Levon if ((err = zonecfg_set_fs_allowed(handle, prop_id)) != Z_OK) 43280fbb751dSJohn Levon zone_perror(zone, err, B_TRUE); 43290fbb751dSJohn Levon else 43300fbb751dSJohn Levon need_to_commit = B_TRUE; 43310fbb751dSJohn Levon return; 43327c478bd9Sstevel@tonic-gate case RT_FS: 43337c478bd9Sstevel@tonic-gate switch (prop_type) { 43347c478bd9Sstevel@tonic-gate case PT_DIR: 43357c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_fstab.zone_fs_dir, prop_id, 43367c478bd9Sstevel@tonic-gate sizeof (in_progress_fstab.zone_fs_dir)); 43377c478bd9Sstevel@tonic-gate return; 43387c478bd9Sstevel@tonic-gate case PT_SPECIAL: 43397c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_fstab.zone_fs_special, 43407c478bd9Sstevel@tonic-gate prop_id, 43417c478bd9Sstevel@tonic-gate sizeof (in_progress_fstab.zone_fs_special)); 43427c478bd9Sstevel@tonic-gate return; 43437c478bd9Sstevel@tonic-gate case PT_RAW: 43447c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_fstab.zone_fs_raw, 43457c478bd9Sstevel@tonic-gate prop_id, sizeof (in_progress_fstab.zone_fs_raw)); 43467c478bd9Sstevel@tonic-gate return; 43477c478bd9Sstevel@tonic-gate case PT_TYPE: 43487c478bd9Sstevel@tonic-gate if (!valid_fs_type(prop_id)) { 43497c478bd9Sstevel@tonic-gate zerr(gettext("\"%s\" is not a valid %s."), 43507c478bd9Sstevel@tonic-gate prop_id, pt_to_str(PT_TYPE)); 4351bbec428eSgjelinek saw_error = B_TRUE; 43527c478bd9Sstevel@tonic-gate return; 43537c478bd9Sstevel@tonic-gate } 43547c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_fstab.zone_fs_type, prop_id, 43557c478bd9Sstevel@tonic-gate sizeof (in_progress_fstab.zone_fs_type)); 43567c478bd9Sstevel@tonic-gate return; 43577c478bd9Sstevel@tonic-gate case PT_OPTIONS: 43587c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE && 43597c478bd9Sstevel@tonic-gate pp->pv_type != PROP_VAL_LIST) { 43607c478bd9Sstevel@tonic-gate zerr(gettext("A %s or %s value was expected " 43617c478bd9Sstevel@tonic-gate "here."), pvt_to_str(PROP_VAL_SIMPLE), 43627c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_LIST)); 4363bbec428eSgjelinek saw_error = B_TRUE; 43647c478bd9Sstevel@tonic-gate return; 43657c478bd9Sstevel@tonic-gate } 43667c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list( 43677c478bd9Sstevel@tonic-gate in_progress_fstab.zone_fs_options); 43687c478bd9Sstevel@tonic-gate in_progress_fstab.zone_fs_options = NULL; 43697c478bd9Sstevel@tonic-gate if (!(pp->pv_type == PROP_VAL_LIST && 43707c478bd9Sstevel@tonic-gate pp->pv_list == NULL)) 43717c478bd9Sstevel@tonic-gate add_property(cmd); 43727c478bd9Sstevel@tonic-gate return; 43737c478bd9Sstevel@tonic-gate default: 43747c478bd9Sstevel@tonic-gate break; 43757c478bd9Sstevel@tonic-gate } 4376bbec428eSgjelinek zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, B_TRUE); 4377bbec428eSgjelinek long_usage(CMD_SET, B_TRUE); 4378bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 43797c478bd9Sstevel@tonic-gate return; 43807c478bd9Sstevel@tonic-gate case RT_NET: 43817c478bd9Sstevel@tonic-gate switch (prop_type) { 43827c478bd9Sstevel@tonic-gate case PT_ADDRESS: 4383550b6e40SSowmini Varadhan case PT_ALLOWED_ADDRESS: 4384550b6e40SSowmini Varadhan if (validate_net_address_syntax(prop_id, B_FALSE) 4385550b6e40SSowmini Varadhan != Z_OK) { 4386bbec428eSgjelinek saw_error = B_TRUE; 43877c478bd9Sstevel@tonic-gate return; 43887c478bd9Sstevel@tonic-gate } 4389550b6e40SSowmini Varadhan set_in_progress_nwiftab_address(prop_id, prop_type); 43907c478bd9Sstevel@tonic-gate break; 43917c478bd9Sstevel@tonic-gate case PT_PHYSICAL: 43927c478bd9Sstevel@tonic-gate if (validate_net_physical_syntax(prop_id) != Z_OK) { 4393bbec428eSgjelinek saw_error = B_TRUE; 43947c478bd9Sstevel@tonic-gate return; 43957c478bd9Sstevel@tonic-gate } 43967c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_nwiftab.zone_nwif_physical, 43977c478bd9Sstevel@tonic-gate prop_id, 43987c478bd9Sstevel@tonic-gate sizeof (in_progress_nwiftab.zone_nwif_physical)); 43997c478bd9Sstevel@tonic-gate break; 4400de860bd9Sgfaden case PT_DEFROUTER: 4401550b6e40SSowmini Varadhan if (validate_net_address_syntax(prop_id, B_TRUE) 4402550b6e40SSowmini Varadhan != Z_OK) { 4403bbec428eSgjelinek saw_error = B_TRUE; 4404de860bd9Sgfaden return; 4405de860bd9Sgfaden } 4406de860bd9Sgfaden (void) strlcpy(in_progress_nwiftab.zone_nwif_defrouter, 4407de860bd9Sgfaden prop_id, 4408de860bd9Sgfaden sizeof (in_progress_nwiftab.zone_nwif_defrouter)); 4409de860bd9Sgfaden break; 44107c478bd9Sstevel@tonic-gate default: 44117c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 4412bbec428eSgjelinek B_TRUE); 4413bbec428eSgjelinek long_usage(CMD_SET, B_TRUE); 4414bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 44157c478bd9Sstevel@tonic-gate return; 44167c478bd9Sstevel@tonic-gate } 44177c478bd9Sstevel@tonic-gate return; 44187c478bd9Sstevel@tonic-gate case RT_DEVICE: 44197c478bd9Sstevel@tonic-gate switch (prop_type) { 44207c478bd9Sstevel@tonic-gate case PT_MATCH: 44217c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_devtab.zone_dev_match, 44227c478bd9Sstevel@tonic-gate prop_id, 44237c478bd9Sstevel@tonic-gate sizeof (in_progress_devtab.zone_dev_match)); 44247c478bd9Sstevel@tonic-gate break; 44257c478bd9Sstevel@tonic-gate default: 44267c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 4427bbec428eSgjelinek B_TRUE); 4428bbec428eSgjelinek long_usage(CMD_SET, B_TRUE); 4429bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 44307c478bd9Sstevel@tonic-gate return; 44317c478bd9Sstevel@tonic-gate } 44327c478bd9Sstevel@tonic-gate return; 44337c478bd9Sstevel@tonic-gate case RT_RCTL: 44347c478bd9Sstevel@tonic-gate switch (prop_type) { 44357c478bd9Sstevel@tonic-gate case PT_NAME: 44367c478bd9Sstevel@tonic-gate if (!zonecfg_valid_rctlname(prop_id)) { 44377c478bd9Sstevel@tonic-gate zerr(gettext("'%s' is not a valid zone %s " 44387c478bd9Sstevel@tonic-gate "name."), prop_id, rt_to_str(RT_RCTL)); 44397c478bd9Sstevel@tonic-gate return; 44407c478bd9Sstevel@tonic-gate } 44417c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_rctltab.zone_rctl_name, 44427c478bd9Sstevel@tonic-gate prop_id, 44437c478bd9Sstevel@tonic-gate sizeof (in_progress_rctltab.zone_rctl_name)); 44447c478bd9Sstevel@tonic-gate break; 44457c478bd9Sstevel@tonic-gate case PT_VALUE: 44467c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_COMPLEX && 44477c478bd9Sstevel@tonic-gate pp->pv_type != PROP_VAL_LIST) { 44487c478bd9Sstevel@tonic-gate zerr(gettext("A %s or %s value was expected " 44497c478bd9Sstevel@tonic-gate "here."), pvt_to_str(PROP_VAL_COMPLEX), 44507c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_LIST)); 4451bbec428eSgjelinek saw_error = B_TRUE; 44527c478bd9Sstevel@tonic-gate return; 44537c478bd9Sstevel@tonic-gate } 44547c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list( 44557c478bd9Sstevel@tonic-gate in_progress_rctltab.zone_rctl_valptr); 44567c478bd9Sstevel@tonic-gate in_progress_rctltab.zone_rctl_valptr = NULL; 44577c478bd9Sstevel@tonic-gate if (!(pp->pv_type == PROP_VAL_LIST && 44587c478bd9Sstevel@tonic-gate pp->pv_list == NULL)) 44597c478bd9Sstevel@tonic-gate add_property(cmd); 44607c478bd9Sstevel@tonic-gate break; 44617c478bd9Sstevel@tonic-gate default: 44627c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 4463bbec428eSgjelinek B_TRUE); 4464bbec428eSgjelinek long_usage(CMD_SET, B_TRUE); 4465bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 44667c478bd9Sstevel@tonic-gate return; 44677c478bd9Sstevel@tonic-gate } 44687c478bd9Sstevel@tonic-gate return; 44697c478bd9Sstevel@tonic-gate case RT_ATTR: 44707c478bd9Sstevel@tonic-gate switch (prop_type) { 44717c478bd9Sstevel@tonic-gate case PT_NAME: 44727c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_attrtab.zone_attr_name, 44737c478bd9Sstevel@tonic-gate prop_id, 44747c478bd9Sstevel@tonic-gate sizeof (in_progress_attrtab.zone_attr_name)); 44757c478bd9Sstevel@tonic-gate break; 44767c478bd9Sstevel@tonic-gate case PT_TYPE: 44777c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_attrtab.zone_attr_type, 44787c478bd9Sstevel@tonic-gate prop_id, 44797c478bd9Sstevel@tonic-gate sizeof (in_progress_attrtab.zone_attr_type)); 44807c478bd9Sstevel@tonic-gate break; 44817c478bd9Sstevel@tonic-gate case PT_VALUE: 44827c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_attrtab.zone_attr_value, 44837c478bd9Sstevel@tonic-gate prop_id, 44847c478bd9Sstevel@tonic-gate sizeof (in_progress_attrtab.zone_attr_value)); 44857c478bd9Sstevel@tonic-gate break; 44867c478bd9Sstevel@tonic-gate default: 44877c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 4488bbec428eSgjelinek B_TRUE); 4489bbec428eSgjelinek long_usage(CMD_SET, B_TRUE); 4490bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 44917c478bd9Sstevel@tonic-gate return; 44927c478bd9Sstevel@tonic-gate } 44937c478bd9Sstevel@tonic-gate return; 4494fa9e4066Sahrens case RT_DATASET: 4495fa9e4066Sahrens switch (prop_type) { 4496fa9e4066Sahrens case PT_NAME: 4497fa9e4066Sahrens (void) strlcpy(in_progress_dstab.zone_dataset_name, 4498fa9e4066Sahrens prop_id, 4499fa9e4066Sahrens sizeof (in_progress_dstab.zone_dataset_name)); 4500fa9e4066Sahrens return; 4501fa9e4066Sahrens default: 4502fa9e4066Sahrens break; 4503fa9e4066Sahrens } 4504bbec428eSgjelinek zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, B_TRUE); 4505bbec428eSgjelinek long_usage(CMD_SET, B_TRUE); 4506bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 4507fa9e4066Sahrens return; 45080209230bSgjelinek case RT_DCPU: 45090209230bSgjelinek switch (prop_type) { 45100209230bSgjelinek char *lowp, *highp; 45110209230bSgjelinek 45120209230bSgjelinek case PT_NCPUS: 45130209230bSgjelinek lowp = prop_id; 45140209230bSgjelinek if ((highp = strchr(prop_id, '-')) != NULL) 45150209230bSgjelinek *highp++ = '\0'; 45160209230bSgjelinek else 45170209230bSgjelinek highp = lowp; 45180209230bSgjelinek 45190209230bSgjelinek /* Make sure the input makes sense. */ 45200209230bSgjelinek if (!zonecfg_valid_ncpus(lowp, highp)) { 45210209230bSgjelinek zerr(gettext("%s property is out of range."), 45220209230bSgjelinek pt_to_str(PT_NCPUS)); 4523bbec428eSgjelinek saw_error = B_TRUE; 45240209230bSgjelinek return; 45250209230bSgjelinek } 45260209230bSgjelinek 45270209230bSgjelinek (void) strlcpy( 45280209230bSgjelinek in_progress_psettab.zone_ncpu_min, lowp, 45290209230bSgjelinek sizeof (in_progress_psettab.zone_ncpu_min)); 45300209230bSgjelinek (void) strlcpy( 45310209230bSgjelinek in_progress_psettab.zone_ncpu_max, highp, 45320209230bSgjelinek sizeof (in_progress_psettab.zone_ncpu_max)); 45330209230bSgjelinek return; 45340209230bSgjelinek case PT_IMPORTANCE: 45350209230bSgjelinek /* Make sure the value makes sense. */ 45360209230bSgjelinek if (!zonecfg_valid_importance(prop_id)) { 45370209230bSgjelinek zerr(gettext("%s property is out of range."), 45380209230bSgjelinek pt_to_str(PT_IMPORTANCE)); 4539bbec428eSgjelinek saw_error = B_TRUE; 45400209230bSgjelinek return; 45410209230bSgjelinek } 45420209230bSgjelinek 45430209230bSgjelinek (void) strlcpy(in_progress_psettab.zone_importance, 45440209230bSgjelinek prop_id, 45450209230bSgjelinek sizeof (in_progress_psettab.zone_importance)); 45460209230bSgjelinek return; 45470209230bSgjelinek default: 45480209230bSgjelinek break; 45490209230bSgjelinek } 4550bbec428eSgjelinek zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, B_TRUE); 4551bbec428eSgjelinek long_usage(CMD_SET, B_TRUE); 4552bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 45530209230bSgjelinek return; 4554c97ad5cdSakolb case RT_PCAP: 4555c97ad5cdSakolb if (prop_type != PT_NCPUS) { 4556c97ad5cdSakolb zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 4557bbec428eSgjelinek B_TRUE); 4558bbec428eSgjelinek long_usage(CMD_SET, B_TRUE); 4559bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 4560c97ad5cdSakolb return; 4561c97ad5cdSakolb } 4562c97ad5cdSakolb 4563c97ad5cdSakolb /* 4564c97ad5cdSakolb * We already checked that an rctl alias is allowed in 4565c97ad5cdSakolb * the add_resource() function. 4566c97ad5cdSakolb */ 4567c97ad5cdSakolb 4568c97ad5cdSakolb if ((cap = strtof(prop_id, &unitp)) <= 0 || *unitp != '\0' || 4569c97ad5cdSakolb (int)(cap * 100) < 1) { 4570c97ad5cdSakolb zerr(gettext("%s property is out of range."), 4571c97ad5cdSakolb pt_to_str(PT_NCPUS)); 4572bbec428eSgjelinek saw_error = B_TRUE; 4573c97ad5cdSakolb return; 4574c97ad5cdSakolb } 4575c97ad5cdSakolb 4576c97ad5cdSakolb if ((err = zonecfg_set_aliased_rctl(handle, ALIAS_CPUCAP, 4577c97ad5cdSakolb (int)(cap * 100))) != Z_OK) 4578bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 4579c97ad5cdSakolb else 4580bbec428eSgjelinek need_to_commit = B_TRUE; 4581c97ad5cdSakolb return; 45820209230bSgjelinek case RT_MCAP: 45830209230bSgjelinek switch (prop_type) { 45840209230bSgjelinek case PT_PHYSICAL: 45850209230bSgjelinek if (!zonecfg_valid_memlimit(prop_id, &mem_cap)) { 45860209230bSgjelinek zerr(gettext("A positive number with a " 45870209230bSgjelinek "required scale suffix (K, M, G or T) was " 45880209230bSgjelinek "expected here.")); 4589bbec428eSgjelinek saw_error = B_TRUE; 45900209230bSgjelinek } else if (mem_cap < ONE_MB) { 45910209230bSgjelinek zerr(gettext("%s value is too small. It must " 45920209230bSgjelinek "be at least 1M."), pt_to_str(PT_PHYSICAL)); 4593bbec428eSgjelinek saw_error = B_TRUE; 45940209230bSgjelinek } else { 45950209230bSgjelinek snprintf(in_progress_mcaptab.zone_physmem_cap, 45960209230bSgjelinek physmem_size, "%llu", mem_cap); 45970209230bSgjelinek } 45980209230bSgjelinek break; 45990209230bSgjelinek case PT_SWAP: 46000209230bSgjelinek /* 46010209230bSgjelinek * We have to check if an rctl is allowed here since 46020209230bSgjelinek * there might already be a rctl defined that blocks 46030209230bSgjelinek * the alias. 46040209230bSgjelinek */ 46050209230bSgjelinek if (!zonecfg_aliased_rctl_ok(handle, ALIAS_MAXSWAP)) { 46060209230bSgjelinek zone_perror(pt_to_str(PT_MAXSWAP), 4607bbec428eSgjelinek Z_ALIAS_DISALLOW, B_FALSE); 4608bbec428eSgjelinek saw_error = B_TRUE; 46090209230bSgjelinek return; 46100209230bSgjelinek } 46110209230bSgjelinek 46120209230bSgjelinek if (global_zone) 46130209230bSgjelinek mem_limit = ONE_MB * 100; 46140209230bSgjelinek else 46150209230bSgjelinek mem_limit = ONE_MB * 50; 46160209230bSgjelinek 46170209230bSgjelinek if (!zonecfg_valid_memlimit(prop_id, &mem_cap)) { 46180209230bSgjelinek zerr(gettext("A positive number with a " 46190209230bSgjelinek "required scale suffix (K, M, G or T) was " 46200209230bSgjelinek "expected here.")); 4621bbec428eSgjelinek saw_error = B_TRUE; 46220209230bSgjelinek } else if (mem_cap < mem_limit) { 46230209230bSgjelinek char buf[128]; 46240209230bSgjelinek 46250209230bSgjelinek (void) snprintf(buf, sizeof (buf), "%llu", 46260209230bSgjelinek mem_limit); 46270209230bSgjelinek bytes_to_units(buf, buf, sizeof (buf)); 46280209230bSgjelinek zerr(gettext("%s value is too small. It must " 46290209230bSgjelinek "be at least %s."), pt_to_str(PT_SWAP), 46300209230bSgjelinek buf); 4631bbec428eSgjelinek saw_error = B_TRUE; 46320209230bSgjelinek } else { 46330209230bSgjelinek if ((err = zonecfg_set_aliased_rctl(handle, 46340209230bSgjelinek ALIAS_MAXSWAP, mem_cap)) != Z_OK) 4635bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 46360209230bSgjelinek else 4637bbec428eSgjelinek need_to_commit = B_TRUE; 46380209230bSgjelinek } 46390209230bSgjelinek break; 46400209230bSgjelinek case PT_LOCKED: 46410209230bSgjelinek /* 46420209230bSgjelinek * We have to check if an rctl is allowed here since 46430209230bSgjelinek * there might already be a rctl defined that blocks 46440209230bSgjelinek * the alias. 46450209230bSgjelinek */ 46460209230bSgjelinek if (!zonecfg_aliased_rctl_ok(handle, 46470209230bSgjelinek ALIAS_MAXLOCKEDMEM)) { 46480209230bSgjelinek zone_perror(pt_to_str(PT_LOCKED), 4649bbec428eSgjelinek Z_ALIAS_DISALLOW, B_FALSE); 4650bbec428eSgjelinek saw_error = B_TRUE; 46510209230bSgjelinek return; 46520209230bSgjelinek } 46530209230bSgjelinek 46540209230bSgjelinek if (!zonecfg_valid_memlimit(prop_id, &mem_cap)) { 46550209230bSgjelinek zerr(gettext("A non-negative number with a " 46560209230bSgjelinek "required scale suffix (K, M, G or T) was " 46570209230bSgjelinek "expected\nhere.")); 4658bbec428eSgjelinek saw_error = B_TRUE; 46590209230bSgjelinek } else { 46600209230bSgjelinek if ((err = zonecfg_set_aliased_rctl(handle, 46610209230bSgjelinek ALIAS_MAXLOCKEDMEM, mem_cap)) != Z_OK) 4662bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 46630209230bSgjelinek else 4664bbec428eSgjelinek need_to_commit = B_TRUE; 46650209230bSgjelinek } 46660209230bSgjelinek break; 46670209230bSgjelinek default: 46680209230bSgjelinek zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 4669bbec428eSgjelinek B_TRUE); 4670bbec428eSgjelinek long_usage(CMD_SET, B_TRUE); 4671bbec428eSgjelinek usage(B_FALSE, HELP_PROPS); 46720209230bSgjelinek return; 46730209230bSgjelinek } 46740209230bSgjelinek return; 4675cb8a054bSGlenn Faden case RT_ADMIN: 4676cb8a054bSGlenn Faden switch (prop_type) { 4677cb8a054bSGlenn Faden case PT_USER: 4678cb8a054bSGlenn Faden (void) strlcpy(in_progress_admintab.zone_admin_user, 4679cb8a054bSGlenn Faden prop_id, 4680cb8a054bSGlenn Faden sizeof (in_progress_admintab.zone_admin_user)); 4681cb8a054bSGlenn Faden return; 4682cb8a054bSGlenn Faden case PT_AUTHS: 4683cb8a054bSGlenn Faden (void) strlcpy(in_progress_admintab.zone_admin_auths, 4684cb8a054bSGlenn Faden prop_id, 4685cb8a054bSGlenn Faden sizeof (in_progress_admintab.zone_admin_auths)); 4686cb8a054bSGlenn Faden return; 4687cb8a054bSGlenn Faden default: 4688cb8a054bSGlenn Faden zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 4689cb8a054bSGlenn Faden B_TRUE); 4690cb8a054bSGlenn Faden long_usage(CMD_SET, B_TRUE); 4691cb8a054bSGlenn Faden usage(B_FALSE, HELP_PROPS); 4692cb8a054bSGlenn Faden return; 4693cb8a054bSGlenn Faden } 46947c478bd9Sstevel@tonic-gate default: 4695bbec428eSgjelinek zone_perror(rt_to_str(res_type), Z_NO_RESOURCE_TYPE, B_TRUE); 4696bbec428eSgjelinek long_usage(CMD_SET, B_TRUE); 4697bbec428eSgjelinek usage(B_FALSE, HELP_RESOURCES); 46987c478bd9Sstevel@tonic-gate return; 46997c478bd9Sstevel@tonic-gate } 47007c478bd9Sstevel@tonic-gate } 47017c478bd9Sstevel@tonic-gate 47027c478bd9Sstevel@tonic-gate static void 4703bbec428eSgjelinek output_prop(FILE *fp, int pnum, char *pval, boolean_t print_notspec) 47047c478bd9Sstevel@tonic-gate { 47057c478bd9Sstevel@tonic-gate char *qstr; 47067c478bd9Sstevel@tonic-gate 47077c478bd9Sstevel@tonic-gate if (*pval != '\0') { 47087c478bd9Sstevel@tonic-gate qstr = quoteit(pval); 47090209230bSgjelinek if (pnum == PT_SWAP || pnum == PT_LOCKED) 47100209230bSgjelinek (void) fprintf(fp, "\t[%s: %s]\n", pt_to_str(pnum), 47110209230bSgjelinek qstr); 47120209230bSgjelinek else 47137c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s: %s\n", pt_to_str(pnum), qstr); 47147c478bd9Sstevel@tonic-gate free(qstr); 47157c478bd9Sstevel@tonic-gate } else if (print_notspec) 4716087719fdSdp (void) fprintf(fp, gettext("\t%s not specified\n"), 4717087719fdSdp pt_to_str(pnum)); 4718087719fdSdp } 4719087719fdSdp 4720087719fdSdp static void 4721087719fdSdp info_zonename(zone_dochandle_t handle, FILE *fp) 4722087719fdSdp { 4723087719fdSdp char zonename[ZONENAME_MAX]; 4724087719fdSdp 4725087719fdSdp if (zonecfg_get_name(handle, zonename, sizeof (zonename)) == Z_OK) 4726087719fdSdp (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_ZONENAME), 4727087719fdSdp zonename); 4728087719fdSdp else 4729087719fdSdp (void) fprintf(fp, gettext("%s not specified\n"), 4730087719fdSdp pt_to_str(PT_ZONENAME)); 47317c478bd9Sstevel@tonic-gate } 47327c478bd9Sstevel@tonic-gate 47337c478bd9Sstevel@tonic-gate static void 47347c478bd9Sstevel@tonic-gate info_zonepath(zone_dochandle_t handle, FILE *fp) 47357c478bd9Sstevel@tonic-gate { 47367c478bd9Sstevel@tonic-gate char zonepath[MAXPATHLEN]; 47377c478bd9Sstevel@tonic-gate 47387c478bd9Sstevel@tonic-gate if (zonecfg_get_zonepath(handle, zonepath, sizeof (zonepath)) == Z_OK) 47397c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_ZONEPATH), 47407c478bd9Sstevel@tonic-gate zonepath); 4741087719fdSdp else { 4742087719fdSdp (void) fprintf(fp, gettext("%s not specified\n"), 4743087719fdSdp pt_to_str(PT_ZONEPATH)); 4744087719fdSdp } 47457c478bd9Sstevel@tonic-gate } 47467c478bd9Sstevel@tonic-gate 47477c478bd9Sstevel@tonic-gate static void 47489acbbeafSnn35248 info_brand(zone_dochandle_t handle, FILE *fp) 47499acbbeafSnn35248 { 47509acbbeafSnn35248 char brand[MAXNAMELEN]; 47519acbbeafSnn35248 47529acbbeafSnn35248 if (zonecfg_get_brand(handle, brand, sizeof (brand)) == Z_OK) 47539acbbeafSnn35248 (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_BRAND), 47549acbbeafSnn35248 brand); 47559acbbeafSnn35248 else 47569acbbeafSnn35248 (void) fprintf(fp, "%s %s\n", pt_to_str(PT_BRAND), 47579acbbeafSnn35248 gettext("not specified")); 47589acbbeafSnn35248 } 47599acbbeafSnn35248 47609acbbeafSnn35248 static void 47617c478bd9Sstevel@tonic-gate info_autoboot(zone_dochandle_t handle, FILE *fp) 47627c478bd9Sstevel@tonic-gate { 47637c478bd9Sstevel@tonic-gate boolean_t autoboot; 47647c478bd9Sstevel@tonic-gate int err; 47657c478bd9Sstevel@tonic-gate 47667c478bd9Sstevel@tonic-gate if ((err = zonecfg_get_autoboot(handle, &autoboot)) == Z_OK) 47677c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_AUTOBOOT), 47687c478bd9Sstevel@tonic-gate autoboot ? "true" : "false"); 47697c478bd9Sstevel@tonic-gate else 4770bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 47717c478bd9Sstevel@tonic-gate } 47727c478bd9Sstevel@tonic-gate 47737c478bd9Sstevel@tonic-gate static void 47747c478bd9Sstevel@tonic-gate info_pool(zone_dochandle_t handle, FILE *fp) 47757c478bd9Sstevel@tonic-gate { 47767c478bd9Sstevel@tonic-gate char pool[MAXNAMELEN]; 47777c478bd9Sstevel@tonic-gate int err; 47787c478bd9Sstevel@tonic-gate 47797c478bd9Sstevel@tonic-gate if ((err = zonecfg_get_pool(handle, pool, sizeof (pool))) == Z_OK) 47807c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_POOL), pool); 47817c478bd9Sstevel@tonic-gate else 4782bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 47837c478bd9Sstevel@tonic-gate } 47847c478bd9Sstevel@tonic-gate 47857c478bd9Sstevel@tonic-gate static void 4786ffbafc53Scomay info_limitpriv(zone_dochandle_t handle, FILE *fp) 4787ffbafc53Scomay { 4788ffbafc53Scomay char *limitpriv; 4789ffbafc53Scomay int err; 4790ffbafc53Scomay 4791ffbafc53Scomay if ((err = zonecfg_get_limitpriv(handle, &limitpriv)) == Z_OK) { 4792ffbafc53Scomay (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_LIMITPRIV), 4793ffbafc53Scomay limitpriv); 4794ffbafc53Scomay free(limitpriv); 4795ffbafc53Scomay } else { 4796bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 4797ffbafc53Scomay } 4798ffbafc53Scomay } 4799ffbafc53Scomay 4800ffbafc53Scomay static void 48013f2f09c1Sdp info_bootargs(zone_dochandle_t handle, FILE *fp) 48023f2f09c1Sdp { 48033f2f09c1Sdp char bootargs[BOOTARGS_MAX]; 48043f2f09c1Sdp int err; 48053f2f09c1Sdp 48063f2f09c1Sdp if ((err = zonecfg_get_bootargs(handle, bootargs, 48073f2f09c1Sdp sizeof (bootargs))) == Z_OK) { 48083f2f09c1Sdp (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_BOOTARGS), 48093f2f09c1Sdp bootargs); 48103f2f09c1Sdp } else { 4811bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 48123f2f09c1Sdp } 48133f2f09c1Sdp } 48143f2f09c1Sdp 48153f2f09c1Sdp static void 48160209230bSgjelinek info_sched(zone_dochandle_t handle, FILE *fp) 48170209230bSgjelinek { 48180209230bSgjelinek char sched[MAXNAMELEN]; 48190209230bSgjelinek int err; 48200209230bSgjelinek 48210209230bSgjelinek if ((err = zonecfg_get_sched_class(handle, sched, sizeof (sched))) 48220209230bSgjelinek == Z_OK) { 48230209230bSgjelinek (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_SCHED), sched); 48240209230bSgjelinek } else { 4825bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 48260209230bSgjelinek } 48270209230bSgjelinek } 48280209230bSgjelinek 48290209230bSgjelinek static void 4830f4b3ec61Sdh155122 info_iptype(zone_dochandle_t handle, FILE *fp) 4831f4b3ec61Sdh155122 { 4832f4b3ec61Sdh155122 zone_iptype_t iptype; 4833f4b3ec61Sdh155122 int err; 4834f4b3ec61Sdh155122 4835f4b3ec61Sdh155122 if ((err = zonecfg_get_iptype(handle, &iptype)) == Z_OK) { 4836f4b3ec61Sdh155122 switch (iptype) { 4837f4b3ec61Sdh155122 case ZS_SHARED: 4838f4b3ec61Sdh155122 (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_IPTYPE), 4839f4b3ec61Sdh155122 "shared"); 4840f4b3ec61Sdh155122 break; 4841f4b3ec61Sdh155122 case ZS_EXCLUSIVE: 4842f4b3ec61Sdh155122 (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_IPTYPE), 4843f4b3ec61Sdh155122 "exclusive"); 4844f4b3ec61Sdh155122 break; 4845f4b3ec61Sdh155122 } 4846f4b3ec61Sdh155122 } else { 4847bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 4848f4b3ec61Sdh155122 } 4849f4b3ec61Sdh155122 } 4850f4b3ec61Sdh155122 4851f4b3ec61Sdh155122 static void 48525679c89fSjv227347 info_hostid(zone_dochandle_t handle, FILE *fp) 48535679c89fSjv227347 { 48545679c89fSjv227347 char hostidp[HW_HOSTID_LEN]; 48550fbb751dSJohn Levon int err; 48565679c89fSjv227347 48570fbb751dSJohn Levon if ((err = zonecfg_get_hostid(handle, hostidp, 48580fbb751dSJohn Levon sizeof (hostidp))) == Z_OK) { 48595679c89fSjv227347 (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_HOSTID), hostidp); 48600fbb751dSJohn Levon } else if (err == Z_BAD_PROPERTY) { 48610fbb751dSJohn Levon (void) fprintf(fp, "%s: \n", pt_to_str(PT_HOSTID)); 48620fbb751dSJohn Levon } else { 48630fbb751dSJohn Levon zone_perror(zone, err, B_TRUE); 48640fbb751dSJohn Levon } 48650fbb751dSJohn Levon } 48660fbb751dSJohn Levon 48670fbb751dSJohn Levon static void 48680fbb751dSJohn Levon info_fs_allowed(zone_dochandle_t handle, FILE *fp) 48690fbb751dSJohn Levon { 48700fbb751dSJohn Levon char fsallowedp[ZONE_FS_ALLOWED_MAX]; 48710fbb751dSJohn Levon int err; 48720fbb751dSJohn Levon 48730fbb751dSJohn Levon if ((err = zonecfg_get_fs_allowed(handle, fsallowedp, 48740fbb751dSJohn Levon sizeof (fsallowedp))) == Z_OK) { 48750fbb751dSJohn Levon (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_FS_ALLOWED), 48760fbb751dSJohn Levon fsallowedp); 48770fbb751dSJohn Levon } else if (err == Z_BAD_PROPERTY) { 48780fbb751dSJohn Levon (void) fprintf(fp, "%s: \n", pt_to_str(PT_FS_ALLOWED)); 48790fbb751dSJohn Levon } else { 48800fbb751dSJohn Levon zone_perror(zone, err, B_TRUE); 48810fbb751dSJohn Levon } 48825679c89fSjv227347 } 48835679c89fSjv227347 48845679c89fSjv227347 static void 48857c478bd9Sstevel@tonic-gate output_fs(FILE *fp, struct zone_fstab *fstab) 48867c478bd9Sstevel@tonic-gate { 48877c478bd9Sstevel@tonic-gate zone_fsopt_t *this; 48887c478bd9Sstevel@tonic-gate 48897c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s:\n", rt_to_str(RT_FS)); 48907c478bd9Sstevel@tonic-gate output_prop(fp, PT_DIR, fstab->zone_fs_dir, B_TRUE); 48917c478bd9Sstevel@tonic-gate output_prop(fp, PT_SPECIAL, fstab->zone_fs_special, B_TRUE); 48927c478bd9Sstevel@tonic-gate output_prop(fp, PT_RAW, fstab->zone_fs_raw, B_TRUE); 48937c478bd9Sstevel@tonic-gate output_prop(fp, PT_TYPE, fstab->zone_fs_type, B_TRUE); 48947c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s: [", pt_to_str(PT_OPTIONS)); 48957c478bd9Sstevel@tonic-gate for (this = fstab->zone_fs_options; this != NULL; 48967c478bd9Sstevel@tonic-gate this = this->zone_fsopt_next) { 48977c478bd9Sstevel@tonic-gate if (strchr(this->zone_fsopt_opt, '=')) 48987c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\"%s\"", this->zone_fsopt_opt); 48997c478bd9Sstevel@tonic-gate else 49007c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s", this->zone_fsopt_opt); 49017c478bd9Sstevel@tonic-gate if (this->zone_fsopt_next != NULL) 49027c478bd9Sstevel@tonic-gate (void) fprintf(fp, ","); 49037c478bd9Sstevel@tonic-gate } 49047c478bd9Sstevel@tonic-gate (void) fprintf(fp, "]\n"); 49057c478bd9Sstevel@tonic-gate } 49067c478bd9Sstevel@tonic-gate 49077c478bd9Sstevel@tonic-gate static void 49087c478bd9Sstevel@tonic-gate info_fs(zone_dochandle_t handle, FILE *fp, cmd_t *cmd) 49097c478bd9Sstevel@tonic-gate { 49107c478bd9Sstevel@tonic-gate struct zone_fstab lookup, user; 4911bbec428eSgjelinek boolean_t output = B_FALSE; 49127c478bd9Sstevel@tonic-gate 49137c478bd9Sstevel@tonic-gate if (zonecfg_setfsent(handle) != Z_OK) 49147c478bd9Sstevel@tonic-gate return; 49157c478bd9Sstevel@tonic-gate while (zonecfg_getfsent(handle, &lookup) == Z_OK) { 49167c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs == 0) { 49177c478bd9Sstevel@tonic-gate output_fs(fp, &lookup); 49187c478bd9Sstevel@tonic-gate goto loopend; 49197c478bd9Sstevel@tonic-gate } 4920bbec428eSgjelinek if (fill_in_fstab(cmd, &user, B_TRUE) != Z_OK) 49217c478bd9Sstevel@tonic-gate goto loopend; 49227c478bd9Sstevel@tonic-gate if (strlen(user.zone_fs_dir) > 0 && 49237c478bd9Sstevel@tonic-gate strcmp(user.zone_fs_dir, lookup.zone_fs_dir) != 0) 49247c478bd9Sstevel@tonic-gate goto loopend; /* no match */ 49257c478bd9Sstevel@tonic-gate if (strlen(user.zone_fs_special) > 0 && 49267c478bd9Sstevel@tonic-gate strcmp(user.zone_fs_special, lookup.zone_fs_special) != 0) 49277c478bd9Sstevel@tonic-gate goto loopend; /* no match */ 49287c478bd9Sstevel@tonic-gate if (strlen(user.zone_fs_type) > 0 && 49297c478bd9Sstevel@tonic-gate strcmp(user.zone_fs_type, lookup.zone_fs_type) != 0) 49307c478bd9Sstevel@tonic-gate goto loopend; /* no match */ 49317c478bd9Sstevel@tonic-gate output_fs(fp, &lookup); 4932bbec428eSgjelinek output = B_TRUE; 49337c478bd9Sstevel@tonic-gate loopend: 49347c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(lookup.zone_fs_options); 49357c478bd9Sstevel@tonic-gate } 49367c478bd9Sstevel@tonic-gate (void) zonecfg_endfsent(handle); 49377c478bd9Sstevel@tonic-gate /* 49387c478bd9Sstevel@tonic-gate * If a property n/v pair was specified, warn the user if there was 49397c478bd9Sstevel@tonic-gate * nothing to output. 49407c478bd9Sstevel@tonic-gate */ 49417c478bd9Sstevel@tonic-gate if (!output && cmd->cmd_prop_nv_pairs > 0) 49427c478bd9Sstevel@tonic-gate (void) printf(gettext("No such %s resource.\n"), 49437c478bd9Sstevel@tonic-gate rt_to_str(RT_FS)); 49447c478bd9Sstevel@tonic-gate } 49457c478bd9Sstevel@tonic-gate 49467c478bd9Sstevel@tonic-gate static void 49477c478bd9Sstevel@tonic-gate output_net(FILE *fp, struct zone_nwiftab *nwiftab) 49487c478bd9Sstevel@tonic-gate { 49497c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s:\n", rt_to_str(RT_NET)); 49507c478bd9Sstevel@tonic-gate output_prop(fp, PT_ADDRESS, nwiftab->zone_nwif_address, B_TRUE); 4951550b6e40SSowmini Varadhan output_prop(fp, PT_ALLOWED_ADDRESS, 4952550b6e40SSowmini Varadhan nwiftab->zone_nwif_allowed_address, B_TRUE); 49537c478bd9Sstevel@tonic-gate output_prop(fp, PT_PHYSICAL, nwiftab->zone_nwif_physical, B_TRUE); 4954de860bd9Sgfaden output_prop(fp, PT_DEFROUTER, nwiftab->zone_nwif_defrouter, B_TRUE); 49557c478bd9Sstevel@tonic-gate } 49567c478bd9Sstevel@tonic-gate 49577c478bd9Sstevel@tonic-gate static void 49587c478bd9Sstevel@tonic-gate info_net(zone_dochandle_t handle, FILE *fp, cmd_t *cmd) 49597c478bd9Sstevel@tonic-gate { 49607c478bd9Sstevel@tonic-gate struct zone_nwiftab lookup, user; 4961bbec428eSgjelinek boolean_t output = B_FALSE; 49627c478bd9Sstevel@tonic-gate 49637c478bd9Sstevel@tonic-gate if (zonecfg_setnwifent(handle) != Z_OK) 49647c478bd9Sstevel@tonic-gate return; 49657c478bd9Sstevel@tonic-gate while (zonecfg_getnwifent(handle, &lookup) == Z_OK) { 49667c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs == 0) { 49677c478bd9Sstevel@tonic-gate output_net(fp, &lookup); 49687c478bd9Sstevel@tonic-gate continue; 49697c478bd9Sstevel@tonic-gate } 4970bbec428eSgjelinek if (fill_in_nwiftab(cmd, &user, B_TRUE) != Z_OK) 49717c478bd9Sstevel@tonic-gate continue; 49727c478bd9Sstevel@tonic-gate if (strlen(user.zone_nwif_physical) > 0 && 49737c478bd9Sstevel@tonic-gate strcmp(user.zone_nwif_physical, 49747c478bd9Sstevel@tonic-gate lookup.zone_nwif_physical) != 0) 49757c478bd9Sstevel@tonic-gate continue; /* no match */ 4976f4b3ec61Sdh155122 /* If present make sure it matches */ 49777c478bd9Sstevel@tonic-gate if (strlen(user.zone_nwif_address) > 0 && 49787c478bd9Sstevel@tonic-gate !zonecfg_same_net_address(user.zone_nwif_address, 49797c478bd9Sstevel@tonic-gate lookup.zone_nwif_address)) 49807c478bd9Sstevel@tonic-gate continue; /* no match */ 49817c478bd9Sstevel@tonic-gate output_net(fp, &lookup); 4982bbec428eSgjelinek output = B_TRUE; 49837c478bd9Sstevel@tonic-gate } 49847c478bd9Sstevel@tonic-gate (void) zonecfg_endnwifent(handle); 49857c478bd9Sstevel@tonic-gate /* 49867c478bd9Sstevel@tonic-gate * If a property n/v pair was specified, warn the user if there was 49877c478bd9Sstevel@tonic-gate * nothing to output. 49887c478bd9Sstevel@tonic-gate */ 49897c478bd9Sstevel@tonic-gate if (!output && cmd->cmd_prop_nv_pairs > 0) 49907c478bd9Sstevel@tonic-gate (void) printf(gettext("No such %s resource.\n"), 49917c478bd9Sstevel@tonic-gate rt_to_str(RT_NET)); 49927c478bd9Sstevel@tonic-gate } 49937c478bd9Sstevel@tonic-gate 49947c478bd9Sstevel@tonic-gate static void 49957c478bd9Sstevel@tonic-gate output_dev(FILE *fp, struct zone_devtab *devtab) 49967c478bd9Sstevel@tonic-gate { 499727e6fb21Sdp (void) fprintf(fp, "%s:\n", rt_to_str(RT_DEVICE)); 49987c478bd9Sstevel@tonic-gate output_prop(fp, PT_MATCH, devtab->zone_dev_match, B_TRUE); 49997c478bd9Sstevel@tonic-gate } 50007c478bd9Sstevel@tonic-gate 50017c478bd9Sstevel@tonic-gate static void 50027c478bd9Sstevel@tonic-gate info_dev(zone_dochandle_t handle, FILE *fp, cmd_t *cmd) 50037c478bd9Sstevel@tonic-gate { 50047c478bd9Sstevel@tonic-gate struct zone_devtab lookup, user; 5005bbec428eSgjelinek boolean_t output = B_FALSE; 50067c478bd9Sstevel@tonic-gate 50077c478bd9Sstevel@tonic-gate if (zonecfg_setdevent(handle) != Z_OK) 50087c478bd9Sstevel@tonic-gate return; 50097c478bd9Sstevel@tonic-gate while (zonecfg_getdevent(handle, &lookup) == Z_OK) { 50107c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs == 0) { 50117c478bd9Sstevel@tonic-gate output_dev(fp, &lookup); 50127c478bd9Sstevel@tonic-gate continue; 50137c478bd9Sstevel@tonic-gate } 5014bbec428eSgjelinek if (fill_in_devtab(cmd, &user, B_TRUE) != Z_OK) 50157c478bd9Sstevel@tonic-gate continue; 50167c478bd9Sstevel@tonic-gate if (strlen(user.zone_dev_match) > 0 && 50177c478bd9Sstevel@tonic-gate strcmp(user.zone_dev_match, lookup.zone_dev_match) != 0) 50187c478bd9Sstevel@tonic-gate continue; /* no match */ 50197c478bd9Sstevel@tonic-gate output_dev(fp, &lookup); 5020bbec428eSgjelinek output = B_TRUE; 50217c478bd9Sstevel@tonic-gate } 50227c478bd9Sstevel@tonic-gate (void) zonecfg_enddevent(handle); 50237c478bd9Sstevel@tonic-gate /* 50247c478bd9Sstevel@tonic-gate * If a property n/v pair was specified, warn the user if there was 50257c478bd9Sstevel@tonic-gate * nothing to output. 50267c478bd9Sstevel@tonic-gate */ 50277c478bd9Sstevel@tonic-gate if (!output && cmd->cmd_prop_nv_pairs > 0) 50287c478bd9Sstevel@tonic-gate (void) printf(gettext("No such %s resource.\n"), 50297c478bd9Sstevel@tonic-gate rt_to_str(RT_DEVICE)); 50307c478bd9Sstevel@tonic-gate } 50317c478bd9Sstevel@tonic-gate 50327c478bd9Sstevel@tonic-gate static void 50337c478bd9Sstevel@tonic-gate output_rctl(FILE *fp, struct zone_rctltab *rctltab) 50347c478bd9Sstevel@tonic-gate { 50357c478bd9Sstevel@tonic-gate struct zone_rctlvaltab *valptr; 50367c478bd9Sstevel@tonic-gate 50377c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s:\n", rt_to_str(RT_RCTL)); 50387c478bd9Sstevel@tonic-gate output_prop(fp, PT_NAME, rctltab->zone_rctl_name, B_TRUE); 50397c478bd9Sstevel@tonic-gate for (valptr = rctltab->zone_rctl_valptr; valptr != NULL; 50407c478bd9Sstevel@tonic-gate valptr = valptr->zone_rctlval_next) { 50417c478bd9Sstevel@tonic-gate fprintf(fp, "\t%s: (%s=%s,%s=%s,%s=%s)\n", 50427c478bd9Sstevel@tonic-gate pt_to_str(PT_VALUE), 50437c478bd9Sstevel@tonic-gate pt_to_str(PT_PRIV), valptr->zone_rctlval_priv, 50447c478bd9Sstevel@tonic-gate pt_to_str(PT_LIMIT), valptr->zone_rctlval_limit, 50457c478bd9Sstevel@tonic-gate pt_to_str(PT_ACTION), valptr->zone_rctlval_action); 50467c478bd9Sstevel@tonic-gate } 50477c478bd9Sstevel@tonic-gate } 50487c478bd9Sstevel@tonic-gate 50497c478bd9Sstevel@tonic-gate static void 50507c478bd9Sstevel@tonic-gate info_rctl(zone_dochandle_t handle, FILE *fp, cmd_t *cmd) 50517c478bd9Sstevel@tonic-gate { 50527c478bd9Sstevel@tonic-gate struct zone_rctltab lookup, user; 5053bbec428eSgjelinek boolean_t output = B_FALSE; 50547c478bd9Sstevel@tonic-gate 50557c478bd9Sstevel@tonic-gate if (zonecfg_setrctlent(handle) != Z_OK) 50567c478bd9Sstevel@tonic-gate return; 50577c478bd9Sstevel@tonic-gate while (zonecfg_getrctlent(handle, &lookup) == Z_OK) { 50587c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs == 0) { 50597c478bd9Sstevel@tonic-gate output_rctl(fp, &lookup); 5060bbec428eSgjelinek } else if (fill_in_rctltab(cmd, &user, B_TRUE) == Z_OK && 50617c478bd9Sstevel@tonic-gate (strlen(user.zone_rctl_name) == 0 || 50627c478bd9Sstevel@tonic-gate strcmp(user.zone_rctl_name, lookup.zone_rctl_name) == 0)) { 50637c478bd9Sstevel@tonic-gate output_rctl(fp, &lookup); 5064bbec428eSgjelinek output = B_TRUE; 50657c478bd9Sstevel@tonic-gate } 50667c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(lookup.zone_rctl_valptr); 50677c478bd9Sstevel@tonic-gate } 50687c478bd9Sstevel@tonic-gate (void) zonecfg_endrctlent(handle); 50697c478bd9Sstevel@tonic-gate /* 50707c478bd9Sstevel@tonic-gate * If a property n/v pair was specified, warn the user if there was 50717c478bd9Sstevel@tonic-gate * nothing to output. 50727c478bd9Sstevel@tonic-gate */ 50737c478bd9Sstevel@tonic-gate if (!output && cmd->cmd_prop_nv_pairs > 0) 50747c478bd9Sstevel@tonic-gate (void) printf(gettext("No such %s resource.\n"), 50757c478bd9Sstevel@tonic-gate rt_to_str(RT_RCTL)); 50767c478bd9Sstevel@tonic-gate } 50777c478bd9Sstevel@tonic-gate 50787c478bd9Sstevel@tonic-gate static void 50797c478bd9Sstevel@tonic-gate output_attr(FILE *fp, struct zone_attrtab *attrtab) 50807c478bd9Sstevel@tonic-gate { 50817c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s:\n", rt_to_str(RT_ATTR)); 50827c478bd9Sstevel@tonic-gate output_prop(fp, PT_NAME, attrtab->zone_attr_name, B_TRUE); 50837c478bd9Sstevel@tonic-gate output_prop(fp, PT_TYPE, attrtab->zone_attr_type, B_TRUE); 50847c478bd9Sstevel@tonic-gate output_prop(fp, PT_VALUE, attrtab->zone_attr_value, B_TRUE); 50857c478bd9Sstevel@tonic-gate } 50867c478bd9Sstevel@tonic-gate 50877c478bd9Sstevel@tonic-gate static void 50887c478bd9Sstevel@tonic-gate info_attr(zone_dochandle_t handle, FILE *fp, cmd_t *cmd) 50897c478bd9Sstevel@tonic-gate { 50907c478bd9Sstevel@tonic-gate struct zone_attrtab lookup, user; 5091bbec428eSgjelinek boolean_t output = B_FALSE; 50927c478bd9Sstevel@tonic-gate 50937c478bd9Sstevel@tonic-gate if (zonecfg_setattrent(handle) != Z_OK) 50947c478bd9Sstevel@tonic-gate return; 50957c478bd9Sstevel@tonic-gate while (zonecfg_getattrent(handle, &lookup) == Z_OK) { 50967c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs == 0) { 50977c478bd9Sstevel@tonic-gate output_attr(fp, &lookup); 50987c478bd9Sstevel@tonic-gate continue; 50997c478bd9Sstevel@tonic-gate } 5100bbec428eSgjelinek if (fill_in_attrtab(cmd, &user, B_TRUE) != Z_OK) 51017c478bd9Sstevel@tonic-gate continue; 51027c478bd9Sstevel@tonic-gate if (strlen(user.zone_attr_name) > 0 && 51037c478bd9Sstevel@tonic-gate strcmp(user.zone_attr_name, lookup.zone_attr_name) != 0) 51047c478bd9Sstevel@tonic-gate continue; /* no match */ 51057c478bd9Sstevel@tonic-gate if (strlen(user.zone_attr_type) > 0 && 51067c478bd9Sstevel@tonic-gate strcmp(user.zone_attr_type, lookup.zone_attr_type) != 0) 51077c478bd9Sstevel@tonic-gate continue; /* no match */ 51087c478bd9Sstevel@tonic-gate if (strlen(user.zone_attr_value) > 0 && 51097c478bd9Sstevel@tonic-gate strcmp(user.zone_attr_value, lookup.zone_attr_value) != 0) 51107c478bd9Sstevel@tonic-gate continue; /* no match */ 51117c478bd9Sstevel@tonic-gate output_attr(fp, &lookup); 5112bbec428eSgjelinek output = B_TRUE; 51137c478bd9Sstevel@tonic-gate } 51147c478bd9Sstevel@tonic-gate (void) zonecfg_endattrent(handle); 51157c478bd9Sstevel@tonic-gate /* 51167c478bd9Sstevel@tonic-gate * If a property n/v pair was specified, warn the user if there was 51177c478bd9Sstevel@tonic-gate * nothing to output. 51187c478bd9Sstevel@tonic-gate */ 51197c478bd9Sstevel@tonic-gate if (!output && cmd->cmd_prop_nv_pairs > 0) 51207c478bd9Sstevel@tonic-gate (void) printf(gettext("No such %s resource.\n"), 51217c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR)); 51227c478bd9Sstevel@tonic-gate } 51237c478bd9Sstevel@tonic-gate 5124fa9e4066Sahrens static void 5125fa9e4066Sahrens output_ds(FILE *fp, struct zone_dstab *dstab) 5126fa9e4066Sahrens { 5127fa9e4066Sahrens (void) fprintf(fp, "%s:\n", rt_to_str(RT_DATASET)); 5128fa9e4066Sahrens output_prop(fp, PT_NAME, dstab->zone_dataset_name, B_TRUE); 5129fa9e4066Sahrens } 5130fa9e4066Sahrens 5131fa9e4066Sahrens static void 5132fa9e4066Sahrens info_ds(zone_dochandle_t handle, FILE *fp, cmd_t *cmd) 5133fa9e4066Sahrens { 5134fa9e4066Sahrens struct zone_dstab lookup, user; 5135bbec428eSgjelinek boolean_t output = B_FALSE; 5136fa9e4066Sahrens 51370209230bSgjelinek if (zonecfg_setdsent(handle) != Z_OK) 5138fa9e4066Sahrens return; 5139fa9e4066Sahrens while (zonecfg_getdsent(handle, &lookup) == Z_OK) { 5140fa9e4066Sahrens if (cmd->cmd_prop_nv_pairs == 0) { 5141fa9e4066Sahrens output_ds(fp, &lookup); 5142fa9e4066Sahrens continue; 5143fa9e4066Sahrens } 5144bbec428eSgjelinek if (fill_in_dstab(cmd, &user, B_TRUE) != Z_OK) 5145fa9e4066Sahrens continue; 5146fa9e4066Sahrens if (strlen(user.zone_dataset_name) > 0 && 5147fa9e4066Sahrens strcmp(user.zone_dataset_name, 5148fa9e4066Sahrens lookup.zone_dataset_name) != 0) 5149fa9e4066Sahrens continue; /* no match */ 5150fa9e4066Sahrens output_ds(fp, &lookup); 5151bbec428eSgjelinek output = B_TRUE; 5152fa9e4066Sahrens } 5153fa9e4066Sahrens (void) zonecfg_enddsent(handle); 5154fa9e4066Sahrens /* 5155fa9e4066Sahrens * If a property n/v pair was specified, warn the user if there was 5156fa9e4066Sahrens * nothing to output. 5157fa9e4066Sahrens */ 5158fa9e4066Sahrens if (!output && cmd->cmd_prop_nv_pairs > 0) 5159fa9e4066Sahrens (void) printf(gettext("No such %s resource.\n"), 5160fa9e4066Sahrens rt_to_str(RT_DATASET)); 5161fa9e4066Sahrens } 5162fa9e4066Sahrens 51630209230bSgjelinek static void 51640209230bSgjelinek output_pset(FILE *fp, struct zone_psettab *psettab) 51650209230bSgjelinek { 51660209230bSgjelinek (void) fprintf(fp, "%s:\n", rt_to_str(RT_DCPU)); 51670209230bSgjelinek if (strcmp(psettab->zone_ncpu_min, psettab->zone_ncpu_max) == 0) 51680209230bSgjelinek (void) fprintf(fp, "\t%s: %s\n", pt_to_str(PT_NCPUS), 51690209230bSgjelinek psettab->zone_ncpu_max); 51700209230bSgjelinek else 51710209230bSgjelinek (void) fprintf(fp, "\t%s: %s-%s\n", pt_to_str(PT_NCPUS), 51720209230bSgjelinek psettab->zone_ncpu_min, psettab->zone_ncpu_max); 51730209230bSgjelinek if (psettab->zone_importance[0] != '\0') 51740209230bSgjelinek (void) fprintf(fp, "\t%s: %s\n", pt_to_str(PT_IMPORTANCE), 51750209230bSgjelinek psettab->zone_importance); 51760209230bSgjelinek } 51770209230bSgjelinek 51780209230bSgjelinek static void 51790209230bSgjelinek info_pset(zone_dochandle_t handle, FILE *fp) 51800209230bSgjelinek { 51810209230bSgjelinek struct zone_psettab lookup; 51820209230bSgjelinek 51830209230bSgjelinek if (zonecfg_getpsetent(handle, &lookup) == Z_OK) 51840209230bSgjelinek output_pset(fp, &lookup); 51850209230bSgjelinek } 51860209230bSgjelinek 51870209230bSgjelinek static void 5188c97ad5cdSakolb output_pcap(FILE *fp) 5189c97ad5cdSakolb { 5190c97ad5cdSakolb uint64_t cap; 5191c97ad5cdSakolb 5192c97ad5cdSakolb if (zonecfg_get_aliased_rctl(handle, ALIAS_CPUCAP, &cap) == Z_OK) { 5193c97ad5cdSakolb float scaled = (float)cap / 100; 5194c97ad5cdSakolb (void) fprintf(fp, "%s:\n", rt_to_str(RT_PCAP)); 5195c97ad5cdSakolb (void) fprintf(fp, "\t[%s: %.2f]\n", pt_to_str(PT_NCPUS), 5196c97ad5cdSakolb scaled); 5197c97ad5cdSakolb } 5198c97ad5cdSakolb } 5199c97ad5cdSakolb 5200c97ad5cdSakolb static void 5201c97ad5cdSakolb info_pcap(FILE *fp) 5202c97ad5cdSakolb { 5203c97ad5cdSakolb output_pcap(fp); 5204c97ad5cdSakolb } 5205c97ad5cdSakolb 5206c97ad5cdSakolb 5207c97ad5cdSakolb static void 52080209230bSgjelinek info_aliased_rctl(zone_dochandle_t handle, FILE *fp, char *alias) 52090209230bSgjelinek { 52100209230bSgjelinek uint64_t limit; 52110209230bSgjelinek 52120209230bSgjelinek if (zonecfg_get_aliased_rctl(handle, alias, &limit) == Z_OK) { 52130209230bSgjelinek /* convert memory based properties */ 52140209230bSgjelinek if (strcmp(alias, ALIAS_MAXSHMMEM) == 0) { 52150209230bSgjelinek char buf[128]; 52160209230bSgjelinek 52170209230bSgjelinek (void) snprintf(buf, sizeof (buf), "%llu", limit); 52180209230bSgjelinek bytes_to_units(buf, buf, sizeof (buf)); 52190209230bSgjelinek (void) fprintf(fp, "[%s: %s]\n", alias, buf); 52200209230bSgjelinek return; 52210209230bSgjelinek } 52220209230bSgjelinek 52230209230bSgjelinek (void) fprintf(fp, "[%s: %llu]\n", alias, limit); 52240209230bSgjelinek } 52250209230bSgjelinek } 52260209230bSgjelinek 52270209230bSgjelinek static void 52280209230bSgjelinek bytes_to_units(char *str, char *buf, int bufsize) 52290209230bSgjelinek { 52300209230bSgjelinek unsigned long long num; 52310209230bSgjelinek unsigned long long save = 0; 52320209230bSgjelinek char *units = "BKMGT"; 52330209230bSgjelinek char *up = units; 52340209230bSgjelinek 52350209230bSgjelinek num = strtoll(str, NULL, 10); 52360209230bSgjelinek 52370209230bSgjelinek if (num < 1024) { 52380209230bSgjelinek (void) snprintf(buf, bufsize, "%llu", num); 52390209230bSgjelinek return; 52400209230bSgjelinek } 52410209230bSgjelinek 52420209230bSgjelinek while ((num >= 1024) && (*up != 'T')) { 52430209230bSgjelinek up++; /* next unit of measurement */ 52440209230bSgjelinek save = num; 52450209230bSgjelinek num = (num + 512) >> 10; 52460209230bSgjelinek } 52470209230bSgjelinek 52480209230bSgjelinek /* check if we should output a fraction. snprintf will round for us */ 52490209230bSgjelinek if (save % 1024 != 0 && ((save >> 10) < 10)) 52500209230bSgjelinek (void) snprintf(buf, bufsize, "%2.1f%c", ((float)save / 1024), 52510209230bSgjelinek *up); 52520209230bSgjelinek else 52530209230bSgjelinek (void) snprintf(buf, bufsize, "%llu%c", num, *up); 52540209230bSgjelinek } 52550209230bSgjelinek 52560209230bSgjelinek static void 52570209230bSgjelinek output_mcap(FILE *fp, struct zone_mcaptab *mcaptab, int showswap, 52580209230bSgjelinek uint64_t maxswap, int showlocked, uint64_t maxlocked) 52590209230bSgjelinek { 52600209230bSgjelinek char buf[128]; 52610209230bSgjelinek 52620209230bSgjelinek (void) fprintf(fp, "%s:\n", rt_to_str(RT_MCAP)); 52630209230bSgjelinek if (mcaptab->zone_physmem_cap[0] != '\0') { 52640209230bSgjelinek bytes_to_units(mcaptab->zone_physmem_cap, buf, sizeof (buf)); 52650209230bSgjelinek output_prop(fp, PT_PHYSICAL, buf, B_TRUE); 52660209230bSgjelinek } 52670209230bSgjelinek 52680209230bSgjelinek if (showswap == Z_OK) { 52690209230bSgjelinek (void) snprintf(buf, sizeof (buf), "%llu", maxswap); 52700209230bSgjelinek bytes_to_units(buf, buf, sizeof (buf)); 52710209230bSgjelinek output_prop(fp, PT_SWAP, buf, B_TRUE); 52720209230bSgjelinek } 52730209230bSgjelinek 52740209230bSgjelinek if (showlocked == Z_OK) { 52750209230bSgjelinek (void) snprintf(buf, sizeof (buf), "%llu", maxlocked); 52760209230bSgjelinek bytes_to_units(buf, buf, sizeof (buf)); 52770209230bSgjelinek output_prop(fp, PT_LOCKED, buf, B_TRUE); 52780209230bSgjelinek } 52790209230bSgjelinek } 52800209230bSgjelinek 52810209230bSgjelinek static void 52820209230bSgjelinek info_mcap(zone_dochandle_t handle, FILE *fp) 52830209230bSgjelinek { 52840209230bSgjelinek int res1, res2, res3; 52850209230bSgjelinek uint64_t swap_limit; 52860209230bSgjelinek uint64_t locked_limit; 52870209230bSgjelinek struct zone_mcaptab lookup; 52880209230bSgjelinek 52890209230bSgjelinek bzero(&lookup, sizeof (lookup)); 52900209230bSgjelinek res1 = zonecfg_getmcapent(handle, &lookup); 52910209230bSgjelinek res2 = zonecfg_get_aliased_rctl(handle, ALIAS_MAXSWAP, &swap_limit); 52920209230bSgjelinek res3 = zonecfg_get_aliased_rctl(handle, ALIAS_MAXLOCKEDMEM, 52930209230bSgjelinek &locked_limit); 52940209230bSgjelinek 52950209230bSgjelinek if (res1 == Z_OK || res2 == Z_OK || res3 == Z_OK) 52960209230bSgjelinek output_mcap(fp, &lookup, res2, swap_limit, res3, locked_limit); 52970209230bSgjelinek } 52980209230bSgjelinek 5299cb8a054bSGlenn Faden static void 5300cb8a054bSGlenn Faden output_auth(FILE *fp, struct zone_admintab *admintab) 5301cb8a054bSGlenn Faden { 5302cb8a054bSGlenn Faden (void) fprintf(fp, "%s:\n", rt_to_str(RT_ADMIN)); 5303cb8a054bSGlenn Faden output_prop(fp, PT_USER, admintab->zone_admin_user, B_TRUE); 5304cb8a054bSGlenn Faden output_prop(fp, PT_AUTHS, admintab->zone_admin_auths, B_TRUE); 5305cb8a054bSGlenn Faden } 5306cb8a054bSGlenn Faden 5307cb8a054bSGlenn Faden static void 5308cb8a054bSGlenn Faden info_auth(zone_dochandle_t handle, FILE *fp, cmd_t *cmd) 5309cb8a054bSGlenn Faden { 5310cb8a054bSGlenn Faden struct zone_admintab lookup, user; 5311cb8a054bSGlenn Faden boolean_t output = B_FALSE; 5312cb8a054bSGlenn Faden int err; 5313cb8a054bSGlenn Faden 5314cb8a054bSGlenn Faden if ((err = zonecfg_setadminent(handle)) != Z_OK) { 5315cb8a054bSGlenn Faden zone_perror(zone, err, B_TRUE); 5316cb8a054bSGlenn Faden return; 5317cb8a054bSGlenn Faden } 5318cb8a054bSGlenn Faden while (zonecfg_getadminent(handle, &lookup) == Z_OK) { 5319cb8a054bSGlenn Faden if (cmd->cmd_prop_nv_pairs == 0) { 5320cb8a054bSGlenn Faden output_auth(fp, &lookup); 5321cb8a054bSGlenn Faden continue; 5322cb8a054bSGlenn Faden } 5323cb8a054bSGlenn Faden if (fill_in_admintab(cmd, &user, B_TRUE) != Z_OK) 5324cb8a054bSGlenn Faden continue; 5325cb8a054bSGlenn Faden if (strlen(user.zone_admin_user) > 0 && 5326cb8a054bSGlenn Faden strcmp(user.zone_admin_user, lookup.zone_admin_user) != 0) 5327cb8a054bSGlenn Faden continue; /* no match */ 5328cb8a054bSGlenn Faden output_auth(fp, &lookup); 5329cb8a054bSGlenn Faden output = B_TRUE; 5330cb8a054bSGlenn Faden } 5331cb8a054bSGlenn Faden (void) zonecfg_endadminent(handle); 5332cb8a054bSGlenn Faden /* 5333cb8a054bSGlenn Faden * If a property n/v pair was specified, warn the user if there was 5334cb8a054bSGlenn Faden * nothing to output. 5335cb8a054bSGlenn Faden */ 5336cb8a054bSGlenn Faden if (!output && cmd->cmd_prop_nv_pairs > 0) 5337cb8a054bSGlenn Faden (void) printf(gettext("No such %s resource.\n"), 5338cb8a054bSGlenn Faden rt_to_str(RT_ADMIN)); 5339cb8a054bSGlenn Faden } 5340cb8a054bSGlenn Faden 53417c478bd9Sstevel@tonic-gate void 53427c478bd9Sstevel@tonic-gate info_func(cmd_t *cmd) 53437c478bd9Sstevel@tonic-gate { 53447c478bd9Sstevel@tonic-gate FILE *fp = stdout; 5345bbec428eSgjelinek boolean_t need_to_close = B_FALSE; 534612a8b243SSusan Kamm-Worrell char *pager, *space; 53470209230bSgjelinek int type; 53480209230bSgjelinek int res1, res2; 53490209230bSgjelinek uint64_t swap_limit; 53500209230bSgjelinek uint64_t locked_limit; 53513042b8b5Sbatschul struct stat statbuf; 53527c478bd9Sstevel@tonic-gate 53537c478bd9Sstevel@tonic-gate assert(cmd != NULL); 53547c478bd9Sstevel@tonic-gate 5355bbec428eSgjelinek if (initialize(B_TRUE) != Z_OK) 53567c478bd9Sstevel@tonic-gate return; 53577c478bd9Sstevel@tonic-gate 53587c478bd9Sstevel@tonic-gate /* don't page error output */ 53597c478bd9Sstevel@tonic-gate if (interactive_mode) { 53607c478bd9Sstevel@tonic-gate if ((pager = getenv("PAGER")) == NULL) 53617c478bd9Sstevel@tonic-gate pager = PAGER; 536212a8b243SSusan Kamm-Worrell space = strchr(pager, ' '); 536312a8b243SSusan Kamm-Worrell if (space) 536412a8b243SSusan Kamm-Worrell *space = '\0'; 53653042b8b5Sbatschul if (stat(pager, &statbuf) == 0) { 536612a8b243SSusan Kamm-Worrell if (space) 536712a8b243SSusan Kamm-Worrell *space = ' '; 53687c478bd9Sstevel@tonic-gate if ((fp = popen(pager, "w")) != NULL) 5369bbec428eSgjelinek need_to_close = B_TRUE; 53703042b8b5Sbatschul else 53713042b8b5Sbatschul fp = stdout; 53723042b8b5Sbatschul } else { 53733042b8b5Sbatschul zerr(gettext("PAGER %s does not exist (%s)."), 53743042b8b5Sbatschul pager, strerror(errno)); 53753042b8b5Sbatschul } 53763042b8b5Sbatschul 53777c478bd9Sstevel@tonic-gate setbuf(fp, NULL); 53787c478bd9Sstevel@tonic-gate } 53797c478bd9Sstevel@tonic-gate 53807c478bd9Sstevel@tonic-gate if (!global_scope) { 53817c478bd9Sstevel@tonic-gate switch (resource_scope) { 53827c478bd9Sstevel@tonic-gate case RT_FS: 53837c478bd9Sstevel@tonic-gate output_fs(fp, &in_progress_fstab); 53847c478bd9Sstevel@tonic-gate break; 53857c478bd9Sstevel@tonic-gate case RT_NET: 53867c478bd9Sstevel@tonic-gate output_net(fp, &in_progress_nwiftab); 53877c478bd9Sstevel@tonic-gate break; 53887c478bd9Sstevel@tonic-gate case RT_DEVICE: 53897c478bd9Sstevel@tonic-gate output_dev(fp, &in_progress_devtab); 53907c478bd9Sstevel@tonic-gate break; 53917c478bd9Sstevel@tonic-gate case RT_RCTL: 53927c478bd9Sstevel@tonic-gate output_rctl(fp, &in_progress_rctltab); 53937c478bd9Sstevel@tonic-gate break; 53947c478bd9Sstevel@tonic-gate case RT_ATTR: 53957c478bd9Sstevel@tonic-gate output_attr(fp, &in_progress_attrtab); 53967c478bd9Sstevel@tonic-gate break; 5397fa9e4066Sahrens case RT_DATASET: 5398fa9e4066Sahrens output_ds(fp, &in_progress_dstab); 5399fa9e4066Sahrens break; 54000209230bSgjelinek case RT_DCPU: 54010209230bSgjelinek output_pset(fp, &in_progress_psettab); 54020209230bSgjelinek break; 5403c97ad5cdSakolb case RT_PCAP: 5404c97ad5cdSakolb output_pcap(fp); 5405c97ad5cdSakolb break; 54060209230bSgjelinek case RT_MCAP: 54070209230bSgjelinek res1 = zonecfg_get_aliased_rctl(handle, ALIAS_MAXSWAP, 54080209230bSgjelinek &swap_limit); 54090209230bSgjelinek res2 = zonecfg_get_aliased_rctl(handle, 54100209230bSgjelinek ALIAS_MAXLOCKEDMEM, &locked_limit); 54110209230bSgjelinek output_mcap(fp, &in_progress_mcaptab, res1, swap_limit, 54120209230bSgjelinek res2, locked_limit); 54130209230bSgjelinek break; 5414cb8a054bSGlenn Faden case RT_ADMIN: 5415cb8a054bSGlenn Faden output_auth(fp, &in_progress_admintab); 5416cb8a054bSGlenn Faden break; 54177c478bd9Sstevel@tonic-gate } 54187c478bd9Sstevel@tonic-gate goto cleanup; 54197c478bd9Sstevel@tonic-gate } 54207c478bd9Sstevel@tonic-gate 54210209230bSgjelinek type = cmd->cmd_res_type; 54220209230bSgjelinek 54230209230bSgjelinek if (gz_invalid_rt_property(type)) { 54240209230bSgjelinek zerr(gettext("%s is not a valid property for the global zone."), 54250209230bSgjelinek rt_to_str(type)); 54260209230bSgjelinek goto cleanup; 54270209230bSgjelinek } 54280209230bSgjelinek 54290209230bSgjelinek if (gz_invalid_resource(type)) { 54300209230bSgjelinek zerr(gettext("%s is not a valid resource for the global zone."), 54310209230bSgjelinek rt_to_str(type)); 54320209230bSgjelinek goto cleanup; 54330209230bSgjelinek } 54340209230bSgjelinek 54357c478bd9Sstevel@tonic-gate switch (cmd->cmd_res_type) { 54367c478bd9Sstevel@tonic-gate case RT_UNKNOWN: 5437087719fdSdp info_zonename(handle, fp); 54380209230bSgjelinek if (!global_zone) { 54397c478bd9Sstevel@tonic-gate info_zonepath(handle, fp); 54409acbbeafSnn35248 info_brand(handle, fp); 54417c478bd9Sstevel@tonic-gate info_autoboot(handle, fp); 54423f2f09c1Sdp info_bootargs(handle, fp); 54430209230bSgjelinek } 54447c478bd9Sstevel@tonic-gate info_pool(handle, fp); 54450209230bSgjelinek if (!global_zone) { 5446ffbafc53Scomay info_limitpriv(handle, fp); 54470209230bSgjelinek info_sched(handle, fp); 5448f4b3ec61Sdh155122 info_iptype(handle, fp); 54495679c89fSjv227347 info_hostid(handle, fp); 54500fbb751dSJohn Levon info_fs_allowed(handle, fp); 54510209230bSgjelinek } 54520209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXLWPS); 5453ff19e029SMenno Lageman info_aliased_rctl(handle, fp, ALIAS_MAXPROCS); 54540209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXSHMMEM); 54550209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXSHMIDS); 54560209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXMSGIDS); 54570209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXSEMIDS); 54580209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_SHARES); 54590209230bSgjelinek if (!global_zone) { 54607c478bd9Sstevel@tonic-gate info_fs(handle, fp, cmd); 54617c478bd9Sstevel@tonic-gate info_net(handle, fp, cmd); 54627c478bd9Sstevel@tonic-gate info_dev(handle, fp, cmd); 54630209230bSgjelinek } 54640209230bSgjelinek info_pset(handle, fp); 5465c97ad5cdSakolb info_pcap(fp); 54660209230bSgjelinek info_mcap(handle, fp); 54670209230bSgjelinek if (!global_zone) { 54687c478bd9Sstevel@tonic-gate info_attr(handle, fp, cmd); 5469fa9e4066Sahrens info_ds(handle, fp, cmd); 5470cb8a054bSGlenn Faden info_auth(handle, fp, cmd); 54710209230bSgjelinek } 54720209230bSgjelinek info_rctl(handle, fp, cmd); 54737c478bd9Sstevel@tonic-gate break; 5474087719fdSdp case RT_ZONENAME: 5475087719fdSdp info_zonename(handle, fp); 5476087719fdSdp break; 54777c478bd9Sstevel@tonic-gate case RT_ZONEPATH: 54787c478bd9Sstevel@tonic-gate info_zonepath(handle, fp); 54797c478bd9Sstevel@tonic-gate break; 54809acbbeafSnn35248 case RT_BRAND: 54819acbbeafSnn35248 info_brand(handle, fp); 54829acbbeafSnn35248 break; 54837c478bd9Sstevel@tonic-gate case RT_AUTOBOOT: 54847c478bd9Sstevel@tonic-gate info_autoboot(handle, fp); 54857c478bd9Sstevel@tonic-gate break; 54867c478bd9Sstevel@tonic-gate case RT_POOL: 54877c478bd9Sstevel@tonic-gate info_pool(handle, fp); 54887c478bd9Sstevel@tonic-gate break; 5489ffbafc53Scomay case RT_LIMITPRIV: 5490ffbafc53Scomay info_limitpriv(handle, fp); 5491ffbafc53Scomay break; 54923f2f09c1Sdp case RT_BOOTARGS: 54933f2f09c1Sdp info_bootargs(handle, fp); 54943f2f09c1Sdp break; 54950209230bSgjelinek case RT_SCHED: 54960209230bSgjelinek info_sched(handle, fp); 54970209230bSgjelinek break; 5498f4b3ec61Sdh155122 case RT_IPTYPE: 5499f4b3ec61Sdh155122 info_iptype(handle, fp); 5500f4b3ec61Sdh155122 break; 55010209230bSgjelinek case RT_MAXLWPS: 55020209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXLWPS); 55030209230bSgjelinek break; 5504ff19e029SMenno Lageman case RT_MAXPROCS: 5505ff19e029SMenno Lageman info_aliased_rctl(handle, fp, ALIAS_MAXPROCS); 5506ff19e029SMenno Lageman break; 55070209230bSgjelinek case RT_MAXSHMMEM: 55080209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXSHMMEM); 55090209230bSgjelinek break; 55100209230bSgjelinek case RT_MAXSHMIDS: 55110209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXSHMIDS); 55120209230bSgjelinek break; 55130209230bSgjelinek case RT_MAXMSGIDS: 55140209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXMSGIDS); 55150209230bSgjelinek break; 55160209230bSgjelinek case RT_MAXSEMIDS: 55170209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXSEMIDS); 55180209230bSgjelinek break; 55190209230bSgjelinek case RT_SHARES: 55200209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_SHARES); 55210209230bSgjelinek break; 55227c478bd9Sstevel@tonic-gate case RT_FS: 55237c478bd9Sstevel@tonic-gate info_fs(handle, fp, cmd); 55247c478bd9Sstevel@tonic-gate break; 55257c478bd9Sstevel@tonic-gate case RT_NET: 55267c478bd9Sstevel@tonic-gate info_net(handle, fp, cmd); 55277c478bd9Sstevel@tonic-gate break; 55287c478bd9Sstevel@tonic-gate case RT_DEVICE: 55297c478bd9Sstevel@tonic-gate info_dev(handle, fp, cmd); 55307c478bd9Sstevel@tonic-gate break; 55317c478bd9Sstevel@tonic-gate case RT_RCTL: 55327c478bd9Sstevel@tonic-gate info_rctl(handle, fp, cmd); 55337c478bd9Sstevel@tonic-gate break; 55347c478bd9Sstevel@tonic-gate case RT_ATTR: 55357c478bd9Sstevel@tonic-gate info_attr(handle, fp, cmd); 55367c478bd9Sstevel@tonic-gate break; 5537fa9e4066Sahrens case RT_DATASET: 5538fa9e4066Sahrens info_ds(handle, fp, cmd); 5539fa9e4066Sahrens break; 55400209230bSgjelinek case RT_DCPU: 55410209230bSgjelinek info_pset(handle, fp); 55420209230bSgjelinek break; 5543c97ad5cdSakolb case RT_PCAP: 5544c97ad5cdSakolb info_pcap(fp); 5545c97ad5cdSakolb break; 55460209230bSgjelinek case RT_MCAP: 55470209230bSgjelinek info_mcap(handle, fp); 55480209230bSgjelinek break; 55495679c89fSjv227347 case RT_HOSTID: 55505679c89fSjv227347 info_hostid(handle, fp); 55515679c89fSjv227347 break; 5552cb8a054bSGlenn Faden case RT_ADMIN: 5553cb8a054bSGlenn Faden info_auth(handle, fp, cmd); 5554cb8a054bSGlenn Faden break; 55550fbb751dSJohn Levon case RT_FS_ALLOWED: 55560fbb751dSJohn Levon info_fs_allowed(handle, fp); 55570fbb751dSJohn Levon break; 55587c478bd9Sstevel@tonic-gate default: 55597c478bd9Sstevel@tonic-gate zone_perror(rt_to_str(cmd->cmd_res_type), Z_NO_RESOURCE_TYPE, 5560bbec428eSgjelinek B_TRUE); 55617c478bd9Sstevel@tonic-gate } 55627c478bd9Sstevel@tonic-gate 55637c478bd9Sstevel@tonic-gate cleanup: 55647c478bd9Sstevel@tonic-gate if (need_to_close) 55657c478bd9Sstevel@tonic-gate (void) pclose(fp); 55667c478bd9Sstevel@tonic-gate } 55677c478bd9Sstevel@tonic-gate 5568087719fdSdp /* 5569087719fdSdp * Helper function for verify-- checks that a required string property 5570087719fdSdp * exists. 5571087719fdSdp */ 5572087719fdSdp static void 5573087719fdSdp check_reqd_prop(char *attr, int rt, int pt, int *ret_val) 55747c478bd9Sstevel@tonic-gate { 5575087719fdSdp if (strlen(attr) == 0) { 5576087719fdSdp zerr(gettext("%s: %s not specified"), rt_to_str(rt), 5577087719fdSdp pt_to_str(pt)); 5578bbec428eSgjelinek saw_error = B_TRUE; 5579087719fdSdp if (*ret_val == Z_OK) 5580087719fdSdp *ret_val = Z_REQD_PROPERTY_MISSING; 55817c478bd9Sstevel@tonic-gate } 55827c478bd9Sstevel@tonic-gate } 55837c478bd9Sstevel@tonic-gate 55849acbbeafSnn35248 static int 55859acbbeafSnn35248 do_subproc(char *cmdbuf) 55869acbbeafSnn35248 { 55879acbbeafSnn35248 char inbuf[MAX_CMD_LEN]; 55889acbbeafSnn35248 FILE *file; 55899acbbeafSnn35248 int status; 55909acbbeafSnn35248 55919acbbeafSnn35248 file = popen(cmdbuf, "r"); 55929acbbeafSnn35248 if (file == NULL) { 55939acbbeafSnn35248 zerr(gettext("Could not launch: %s"), cmdbuf); 55949acbbeafSnn35248 return (-1); 55959acbbeafSnn35248 } 55969acbbeafSnn35248 55979acbbeafSnn35248 while (fgets(inbuf, sizeof (inbuf), file) != NULL) 55989acbbeafSnn35248 fprintf(stderr, "%s", inbuf); 55999acbbeafSnn35248 status = pclose(file); 56009acbbeafSnn35248 56019acbbeafSnn35248 if (WIFSIGNALED(status)) { 56029acbbeafSnn35248 zerr(gettext("%s unexpectedly terminated due to signal %d"), 56039acbbeafSnn35248 cmdbuf, WTERMSIG(status)); 56049acbbeafSnn35248 return (-1); 56059acbbeafSnn35248 } 56069acbbeafSnn35248 assert(WIFEXITED(status)); 56079acbbeafSnn35248 return (WEXITSTATUS(status)); 56089acbbeafSnn35248 } 56099acbbeafSnn35248 56109acbbeafSnn35248 static int 56119acbbeafSnn35248 brand_verify(zone_dochandle_t handle) 56129acbbeafSnn35248 { 56136e65f9afSnn35248 char xml_file[32]; 56149acbbeafSnn35248 char cmdbuf[MAX_CMD_LEN]; 5615123807fbSedp brand_handle_t bh; 56169acbbeafSnn35248 char brand[MAXNAMELEN]; 56179acbbeafSnn35248 int err; 56189acbbeafSnn35248 56199acbbeafSnn35248 if (zonecfg_get_brand(handle, brand, sizeof (brand)) != Z_OK) { 56209acbbeafSnn35248 zerr("%s: %s\n", zone, gettext("could not get zone brand")); 56219acbbeafSnn35248 return (Z_INVALID_DOCUMENT); 56229acbbeafSnn35248 } 5623123807fbSedp if ((bh = brand_open(brand)) == NULL) { 56249acbbeafSnn35248 zerr("%s: %s\n", zone, gettext("unknown brand.")); 56259acbbeafSnn35248 return (Z_INVALID_DOCUMENT); 56269acbbeafSnn35248 } 56279acbbeafSnn35248 56289acbbeafSnn35248 /* 56299acbbeafSnn35248 * Fetch the verify command, if any, from the brand configuration 56309acbbeafSnn35248 * and build the command line to execute it. 56319acbbeafSnn35248 */ 56329acbbeafSnn35248 strcpy(cmdbuf, EXEC_PREFIX); 5633123807fbSedp err = brand_get_verify_cfg(bh, cmdbuf + EXEC_LEN, 56349acbbeafSnn35248 sizeof (cmdbuf) - (EXEC_LEN + (strlen(xml_file) + 1))); 5635123807fbSedp brand_close(bh); 56369acbbeafSnn35248 if (err != Z_OK) { 56379acbbeafSnn35248 zerr("%s: %s\n", zone, 56389acbbeafSnn35248 gettext("could not get brand verification command")); 56399acbbeafSnn35248 return (Z_INVALID_DOCUMENT); 56409acbbeafSnn35248 } 56419acbbeafSnn35248 56429acbbeafSnn35248 /* 56439acbbeafSnn35248 * If the brand doesn't provide a verification routine, we just 56449acbbeafSnn35248 * return success. 56459acbbeafSnn35248 */ 56469acbbeafSnn35248 if (strlen(cmdbuf) == EXEC_LEN) 56479acbbeafSnn35248 return (Z_OK); 56489acbbeafSnn35248 56499acbbeafSnn35248 /* 56509acbbeafSnn35248 * Dump the current config information for this zone to a file. 56519acbbeafSnn35248 */ 56526e65f9afSnn35248 strcpy(xml_file, "/tmp/zonecfg_verify.XXXXXX"); 56539acbbeafSnn35248 if (mkstemp(xml_file) == NULL) 56549acbbeafSnn35248 return (Z_TEMP_FILE); 56559acbbeafSnn35248 if ((err = zonecfg_verify_save(handle, xml_file)) != Z_OK) { 56569acbbeafSnn35248 (void) unlink(xml_file); 56579acbbeafSnn35248 return (err); 56589acbbeafSnn35248 } 56599acbbeafSnn35248 56609acbbeafSnn35248 /* 56619acbbeafSnn35248 * Execute the verification command. 56629acbbeafSnn35248 */ 56639acbbeafSnn35248 if ((strlcat(cmdbuf, " ", MAX_CMD_LEN) >= MAX_CMD_LEN) || 56649acbbeafSnn35248 (strlcat(cmdbuf, xml_file, MAX_CMD_LEN) >= MAX_CMD_LEN)) { 56659acbbeafSnn35248 err = Z_BRAND_ERROR; 56669acbbeafSnn35248 } else { 56679acbbeafSnn35248 err = do_subproc(cmdbuf); 56689acbbeafSnn35248 } 56699acbbeafSnn35248 56709acbbeafSnn35248 (void) unlink(xml_file); 56719acbbeafSnn35248 return ((err == Z_OK) ? Z_OK : Z_BRAND_ERROR); 56729acbbeafSnn35248 } 56739acbbeafSnn35248 56747c478bd9Sstevel@tonic-gate /* 5675550b6e40SSowmini Varadhan * Track the network interfaces listed in zonecfg(1m) in a linked list 5676550b6e40SSowmini Varadhan * so that we can later check that defrouter is specified for an exclusive IP 5677550b6e40SSowmini Varadhan * zone if and only if at least one allowed-address has been specified. 5678550b6e40SSowmini Varadhan */ 5679550b6e40SSowmini Varadhan static boolean_t 5680550b6e40SSowmini Varadhan add_nwif(struct zone_nwiftab *nwif) 5681550b6e40SSowmini Varadhan { 5682550b6e40SSowmini Varadhan struct xif *tmp; 5683550b6e40SSowmini Varadhan 5684550b6e40SSowmini Varadhan for (tmp = xif; tmp != NULL; tmp = tmp->xif_next) { 5685550b6e40SSowmini Varadhan if (strcmp(tmp->xif_name, nwif->zone_nwif_physical) == 0) { 5686550b6e40SSowmini Varadhan if (strlen(nwif->zone_nwif_allowed_address) > 0) 5687550b6e40SSowmini Varadhan tmp->xif_has_address = B_TRUE; 5688550b6e40SSowmini Varadhan if (strlen(nwif->zone_nwif_defrouter) > 0) 5689550b6e40SSowmini Varadhan tmp->xif_has_defrouter = B_TRUE; 5690550b6e40SSowmini Varadhan return (B_TRUE); 5691550b6e40SSowmini Varadhan } 5692550b6e40SSowmini Varadhan } 5693550b6e40SSowmini Varadhan 5694550b6e40SSowmini Varadhan tmp = malloc(sizeof (*tmp)); 5695550b6e40SSowmini Varadhan if (tmp == NULL) { 5696550b6e40SSowmini Varadhan zerr(gettext("memory allocation failed for %s"), 5697550b6e40SSowmini Varadhan nwif->zone_nwif_physical); 5698550b6e40SSowmini Varadhan return (B_FALSE); 5699550b6e40SSowmini Varadhan } 5700550b6e40SSowmini Varadhan strlcpy(tmp->xif_name, nwif->zone_nwif_physical, 5701550b6e40SSowmini Varadhan sizeof (tmp->xif_name)); 5702550b6e40SSowmini Varadhan tmp->xif_has_defrouter = (strlen(nwif->zone_nwif_defrouter) > 0); 5703550b6e40SSowmini Varadhan tmp->xif_has_address = (strlen(nwif->zone_nwif_allowed_address) > 0); 5704550b6e40SSowmini Varadhan tmp->xif_next = xif; 5705550b6e40SSowmini Varadhan xif = tmp; 5706550b6e40SSowmini Varadhan return (B_TRUE); 5707550b6e40SSowmini Varadhan } 5708550b6e40SSowmini Varadhan 5709550b6e40SSowmini Varadhan /* 57107c478bd9Sstevel@tonic-gate * See the DTD for which attributes are required for which resources. 57117c478bd9Sstevel@tonic-gate * 57127c478bd9Sstevel@tonic-gate * This function can be called by commit_func(), which needs to save things, 57137c478bd9Sstevel@tonic-gate * in addition to the general call from parse_and_run(), which doesn't need 57147c478bd9Sstevel@tonic-gate * things saved. Since the parameters are standardized, we distinguish by 57157c478bd9Sstevel@tonic-gate * having commit_func() call here with cmd->cmd_arg set to "save" to indicate 57167c478bd9Sstevel@tonic-gate * that a save is needed. 57177c478bd9Sstevel@tonic-gate */ 57187c478bd9Sstevel@tonic-gate void 57197c478bd9Sstevel@tonic-gate verify_func(cmd_t *cmd) 57207c478bd9Sstevel@tonic-gate { 57217c478bd9Sstevel@tonic-gate struct zone_nwiftab nwiftab; 57227c478bd9Sstevel@tonic-gate struct zone_fstab fstab; 57237c478bd9Sstevel@tonic-gate struct zone_attrtab attrtab; 57247c478bd9Sstevel@tonic-gate struct zone_rctltab rctltab; 5725fa9e4066Sahrens struct zone_dstab dstab; 57260209230bSgjelinek struct zone_psettab psettab; 5727cb8a054bSGlenn Faden struct zone_admintab admintab; 57287c478bd9Sstevel@tonic-gate char zonepath[MAXPATHLEN]; 57290209230bSgjelinek char sched[MAXNAMELEN]; 57309acbbeafSnn35248 char brand[MAXNAMELEN]; 57315679c89fSjv227347 char hostidp[HW_HOSTID_LEN]; 57320fbb751dSJohn Levon char fsallowedp[ZONE_FS_ALLOWED_MAX]; 5733*f93d2c19SAlexander Eremin priv_set_t *privs; 5734*f93d2c19SAlexander Eremin char *privname = NULL; 57357c478bd9Sstevel@tonic-gate int err, ret_val = Z_OK, arg; 5736c97ad5cdSakolb int pset_res; 5737bbec428eSgjelinek boolean_t save = B_FALSE; 5738bbec428eSgjelinek boolean_t arg_err = B_FALSE; 5739f4b3ec61Sdh155122 zone_iptype_t iptype; 57400209230bSgjelinek boolean_t has_cpu_shares = B_FALSE; 5741c97ad5cdSakolb boolean_t has_cpu_cap = B_FALSE; 5742550b6e40SSowmini Varadhan struct xif *tmp; 57437c478bd9Sstevel@tonic-gate 57447c478bd9Sstevel@tonic-gate optind = 0; 57457ec75eb8Sgjelinek while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?")) != EOF) { 57467c478bd9Sstevel@tonic-gate switch (arg) { 57477c478bd9Sstevel@tonic-gate case '?': 57487c478bd9Sstevel@tonic-gate longer_usage(CMD_VERIFY); 5749bbec428eSgjelinek arg_err = B_TRUE; 57507ec75eb8Sgjelinek break; 57517c478bd9Sstevel@tonic-gate default: 57527c478bd9Sstevel@tonic-gate short_usage(CMD_VERIFY); 5753bbec428eSgjelinek arg_err = B_TRUE; 57547ec75eb8Sgjelinek break; 57557ec75eb8Sgjelinek } 57567ec75eb8Sgjelinek } 57577ec75eb8Sgjelinek if (arg_err) 57587c478bd9Sstevel@tonic-gate return; 57597ec75eb8Sgjelinek 57607c478bd9Sstevel@tonic-gate if (optind > cmd->cmd_argc) { 57617c478bd9Sstevel@tonic-gate short_usage(CMD_VERIFY); 57627c478bd9Sstevel@tonic-gate return; 57637c478bd9Sstevel@tonic-gate } 57647c478bd9Sstevel@tonic-gate 57657c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_VERIFY)) 57667c478bd9Sstevel@tonic-gate return; 57677c478bd9Sstevel@tonic-gate 57687c478bd9Sstevel@tonic-gate assert(cmd != NULL); 57697c478bd9Sstevel@tonic-gate 57707c478bd9Sstevel@tonic-gate if (cmd->cmd_argc > 0 && (strcmp(cmd->cmd_argv[0], "save") == 0)) 5771bbec428eSgjelinek save = B_TRUE; 5772bbec428eSgjelinek if (initialize(B_TRUE) != Z_OK) 57737c478bd9Sstevel@tonic-gate return; 57747c478bd9Sstevel@tonic-gate 57750209230bSgjelinek if (zonecfg_get_zonepath(handle, zonepath, sizeof (zonepath)) != Z_OK && 57760209230bSgjelinek !global_zone) { 5777087719fdSdp zerr(gettext("%s not specified"), pt_to_str(PT_ZONEPATH)); 57787c478bd9Sstevel@tonic-gate ret_val = Z_REQD_RESOURCE_MISSING; 5779bbec428eSgjelinek saw_error = B_TRUE; 57807c478bd9Sstevel@tonic-gate } 57810209230bSgjelinek if (strlen(zonepath) == 0 && !global_zone) { 5782087719fdSdp zerr(gettext("%s cannot be empty."), pt_to_str(PT_ZONEPATH)); 57837c478bd9Sstevel@tonic-gate ret_val = Z_REQD_RESOURCE_MISSING; 5784bbec428eSgjelinek saw_error = B_TRUE; 57857c478bd9Sstevel@tonic-gate } 57867c478bd9Sstevel@tonic-gate 57879acbbeafSnn35248 if ((err = zonecfg_get_brand(handle, brand, sizeof (brand))) != Z_OK) { 5788bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 57899acbbeafSnn35248 return; 57909acbbeafSnn35248 } 57919acbbeafSnn35248 if ((err = brand_verify(handle)) != Z_OK) { 5792bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 57939acbbeafSnn35248 return; 57949acbbeafSnn35248 } 57959acbbeafSnn35248 5796f4b3ec61Sdh155122 if (zonecfg_get_iptype(handle, &iptype) != Z_OK) { 5797f4b3ec61Sdh155122 zerr("%s %s", gettext("cannot get"), pt_to_str(PT_IPTYPE)); 5798f4b3ec61Sdh155122 ret_val = Z_REQD_RESOURCE_MISSING; 5799bbec428eSgjelinek saw_error = B_TRUE; 5800f4b3ec61Sdh155122 } 58017c478bd9Sstevel@tonic-gate 5802*f93d2c19SAlexander Eremin if ((privs = priv_allocset()) == NULL) { 5803*f93d2c19SAlexander Eremin zerr(gettext("%s: priv_allocset failed"), zone); 5804*f93d2c19SAlexander Eremin return; 5805*f93d2c19SAlexander Eremin } 5806*f93d2c19SAlexander Eremin if (zonecfg_get_privset(handle, privs, &privname) != Z_OK) { 5807*f93d2c19SAlexander Eremin zerr(gettext("%s: invalid privilege: %s"), zone, privname); 5808*f93d2c19SAlexander Eremin priv_freeset(privs); 5809*f93d2c19SAlexander Eremin free(privname); 5810*f93d2c19SAlexander Eremin return; 5811*f93d2c19SAlexander Eremin } 5812*f93d2c19SAlexander Eremin priv_freeset(privs); 5813*f93d2c19SAlexander Eremin 58140fbb751dSJohn Levon if (zonecfg_get_hostid(handle, hostidp, 58150fbb751dSJohn Levon sizeof (hostidp)) == Z_INVALID_PROPERTY) { 58160fbb751dSJohn Levon zerr(gettext("%s: invalid hostid: %s"), 58170fbb751dSJohn Levon zone, hostidp); 58180fbb751dSJohn Levon return; 58190fbb751dSJohn Levon } 58200fbb751dSJohn Levon 58210fbb751dSJohn Levon if (zonecfg_get_fs_allowed(handle, fsallowedp, 58220fbb751dSJohn Levon sizeof (fsallowedp)) == Z_INVALID_PROPERTY) { 58230fbb751dSJohn Levon zerr(gettext("%s: invalid fs-allowed: %s"), 58240fbb751dSJohn Levon zone, fsallowedp); 58255679c89fSjv227347 return; 58265679c89fSjv227347 } 58275679c89fSjv227347 58287c478bd9Sstevel@tonic-gate if ((err = zonecfg_setfsent(handle)) != Z_OK) { 5829bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 58307c478bd9Sstevel@tonic-gate return; 58317c478bd9Sstevel@tonic-gate } 58327c478bd9Sstevel@tonic-gate while (zonecfg_getfsent(handle, &fstab) == Z_OK) { 5833087719fdSdp check_reqd_prop(fstab.zone_fs_dir, RT_FS, PT_DIR, &ret_val); 5834087719fdSdp check_reqd_prop(fstab.zone_fs_special, RT_FS, PT_SPECIAL, 5835087719fdSdp &ret_val); 5836087719fdSdp check_reqd_prop(fstab.zone_fs_type, RT_FS, PT_TYPE, &ret_val); 5837087719fdSdp 58387c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(fstab.zone_fs_options); 58397c478bd9Sstevel@tonic-gate } 58407c478bd9Sstevel@tonic-gate (void) zonecfg_endfsent(handle); 58417c478bd9Sstevel@tonic-gate 58427c478bd9Sstevel@tonic-gate if ((err = zonecfg_setnwifent(handle)) != Z_OK) { 5843bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 58447c478bd9Sstevel@tonic-gate return; 58457c478bd9Sstevel@tonic-gate } 58467c478bd9Sstevel@tonic-gate while (zonecfg_getnwifent(handle, &nwiftab) == Z_OK) { 5847f4b3ec61Sdh155122 /* 5848f4b3ec61Sdh155122 * physical is required in all cases. 5849de860bd9Sgfaden * A shared IP requires an address, 5850de860bd9Sgfaden * and may include a default router, while 5851de860bd9Sgfaden * an exclusive IP must have neither an address 5852de860bd9Sgfaden * nor a default router. 585301b4bc23Sjv227347 * The physical interface name must be valid in all cases. 5854f4b3ec61Sdh155122 */ 5855087719fdSdp check_reqd_prop(nwiftab.zone_nwif_physical, RT_NET, 5856087719fdSdp PT_PHYSICAL, &ret_val); 585701b4bc23Sjv227347 if (validate_net_physical_syntax(nwiftab.zone_nwif_physical) != 585801b4bc23Sjv227347 Z_OK) { 585901b4bc23Sjv227347 saw_error = B_TRUE; 586001b4bc23Sjv227347 if (ret_val == Z_OK) 586101b4bc23Sjv227347 ret_val = Z_INVAL; 586201b4bc23Sjv227347 } 5863f4b3ec61Sdh155122 5864f4b3ec61Sdh155122 switch (iptype) { 5865f4b3ec61Sdh155122 case ZS_SHARED: 5866f4b3ec61Sdh155122 check_reqd_prop(nwiftab.zone_nwif_address, RT_NET, 5867f4b3ec61Sdh155122 PT_ADDRESS, &ret_val); 5868550b6e40SSowmini Varadhan if (strlen(nwiftab.zone_nwif_allowed_address) > 0) { 5869550b6e40SSowmini Varadhan zerr(gettext("%s: %s cannot be specified " 5870550b6e40SSowmini Varadhan "for a shared IP type"), 5871550b6e40SSowmini Varadhan rt_to_str(RT_NET), 5872550b6e40SSowmini Varadhan pt_to_str(PT_ALLOWED_ADDRESS)); 5873550b6e40SSowmini Varadhan saw_error = B_TRUE; 5874550b6e40SSowmini Varadhan if (ret_val == Z_OK) 5875550b6e40SSowmini Varadhan ret_val = Z_INVAL; 5876550b6e40SSowmini Varadhan } 5877f4b3ec61Sdh155122 break; 5878f4b3ec61Sdh155122 case ZS_EXCLUSIVE: 5879f4b3ec61Sdh155122 if (strlen(nwiftab.zone_nwif_address) > 0) { 5880f4b3ec61Sdh155122 zerr(gettext("%s: %s cannot be specified " 5881f4b3ec61Sdh155122 "for an exclusive IP type"), 5882f4b3ec61Sdh155122 rt_to_str(RT_NET), pt_to_str(PT_ADDRESS)); 5883bbec428eSgjelinek saw_error = B_TRUE; 5884f4b3ec61Sdh155122 if (ret_val == Z_OK) 5885f4b3ec61Sdh155122 ret_val = Z_INVAL; 5886550b6e40SSowmini Varadhan } else { 5887550b6e40SSowmini Varadhan if (!add_nwif(&nwiftab)) { 5888bbec428eSgjelinek saw_error = B_TRUE; 5889de860bd9Sgfaden if (ret_val == Z_OK) 5890de860bd9Sgfaden ret_val = Z_INVAL; 5891de860bd9Sgfaden } 5892550b6e40SSowmini Varadhan } 5893f4b3ec61Sdh155122 break; 5894f4b3ec61Sdh155122 } 58957c478bd9Sstevel@tonic-gate } 5896550b6e40SSowmini Varadhan for (tmp = xif; tmp != NULL; tmp = tmp->xif_next) { 5897550b6e40SSowmini Varadhan if (!tmp->xif_has_address && tmp->xif_has_defrouter) { 5898550b6e40SSowmini Varadhan zerr(gettext("%s: %s for %s cannot be specified " 5899550b6e40SSowmini Varadhan "without %s for an exclusive IP type"), 5900550b6e40SSowmini Varadhan rt_to_str(RT_NET), pt_to_str(PT_DEFROUTER), 5901550b6e40SSowmini Varadhan tmp->xif_name, pt_to_str(PT_ALLOWED_ADDRESS)); 5902550b6e40SSowmini Varadhan saw_error = B_TRUE; 5903550b6e40SSowmini Varadhan ret_val = Z_INVAL; 5904550b6e40SSowmini Varadhan } 5905550b6e40SSowmini Varadhan } 5906550b6e40SSowmini Varadhan free(xif); 5907550b6e40SSowmini Varadhan xif = NULL; 59087c478bd9Sstevel@tonic-gate (void) zonecfg_endnwifent(handle); 59097c478bd9Sstevel@tonic-gate 59107c478bd9Sstevel@tonic-gate if ((err = zonecfg_setrctlent(handle)) != Z_OK) { 5911bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 59127c478bd9Sstevel@tonic-gate return; 59137c478bd9Sstevel@tonic-gate } 59147c478bd9Sstevel@tonic-gate while (zonecfg_getrctlent(handle, &rctltab) == Z_OK) { 5915087719fdSdp check_reqd_prop(rctltab.zone_rctl_name, RT_RCTL, PT_NAME, 5916087719fdSdp &ret_val); 5917087719fdSdp 59180209230bSgjelinek if (strcmp(rctltab.zone_rctl_name, "zone.cpu-shares") == 0) 59190209230bSgjelinek has_cpu_shares = B_TRUE; 59200209230bSgjelinek 5921c97ad5cdSakolb if (strcmp(rctltab.zone_rctl_name, "zone.cpu-cap") == 0) 5922c97ad5cdSakolb has_cpu_cap = B_TRUE; 5923c97ad5cdSakolb 59247c478bd9Sstevel@tonic-gate if (rctltab.zone_rctl_valptr == NULL) { 59257c478bd9Sstevel@tonic-gate zerr(gettext("%s: no %s specified"), 59267c478bd9Sstevel@tonic-gate rt_to_str(RT_RCTL), pt_to_str(PT_VALUE)); 5927bbec428eSgjelinek saw_error = B_TRUE; 59287c478bd9Sstevel@tonic-gate if (ret_val == Z_OK) 59297c478bd9Sstevel@tonic-gate ret_val = Z_REQD_PROPERTY_MISSING; 59307c478bd9Sstevel@tonic-gate } else { 59317c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctltab.zone_rctl_valptr); 59327c478bd9Sstevel@tonic-gate } 59337c478bd9Sstevel@tonic-gate } 59347c478bd9Sstevel@tonic-gate (void) zonecfg_endrctlent(handle); 59357c478bd9Sstevel@tonic-gate 5936c97ad5cdSakolb if ((pset_res = zonecfg_lookup_pset(handle, &psettab)) == Z_OK && 5937c97ad5cdSakolb has_cpu_shares) { 59380209230bSgjelinek zerr(gettext("%s zone.cpu-shares and %s are incompatible."), 59390209230bSgjelinek rt_to_str(RT_RCTL), rt_to_str(RT_DCPU)); 5940bbec428eSgjelinek saw_error = B_TRUE; 59410209230bSgjelinek if (ret_val == Z_OK) 59420209230bSgjelinek ret_val = Z_INCOMPATIBLE; 59430209230bSgjelinek } 59440209230bSgjelinek 59450209230bSgjelinek if (has_cpu_shares && zonecfg_get_sched_class(handle, sched, 59460209230bSgjelinek sizeof (sched)) == Z_OK && strlen(sched) > 0 && 59470209230bSgjelinek strcmp(sched, "FSS") != 0) { 59480209230bSgjelinek zerr(gettext("WARNING: %s zone.cpu-shares and %s=%s are " 59490209230bSgjelinek "incompatible"), 59500209230bSgjelinek rt_to_str(RT_RCTL), rt_to_str(RT_SCHED), sched); 5951bbec428eSgjelinek saw_error = B_TRUE; 59520209230bSgjelinek if (ret_val == Z_OK) 59530209230bSgjelinek ret_val = Z_INCOMPATIBLE; 59540209230bSgjelinek } 59550209230bSgjelinek 5956c97ad5cdSakolb if (pset_res == Z_OK && has_cpu_cap) { 5957c97ad5cdSakolb zerr(gettext("%s zone.cpu-cap and the %s are incompatible."), 5958c97ad5cdSakolb rt_to_str(RT_RCTL), rt_to_str(RT_DCPU)); 5959bbec428eSgjelinek saw_error = B_TRUE; 5960c97ad5cdSakolb if (ret_val == Z_OK) 5961c97ad5cdSakolb ret_val = Z_INCOMPATIBLE; 5962c97ad5cdSakolb } 5963c97ad5cdSakolb 59647c478bd9Sstevel@tonic-gate if ((err = zonecfg_setattrent(handle)) != Z_OK) { 5965bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 59667c478bd9Sstevel@tonic-gate return; 59677c478bd9Sstevel@tonic-gate } 59687c478bd9Sstevel@tonic-gate while (zonecfg_getattrent(handle, &attrtab) == Z_OK) { 5969087719fdSdp check_reqd_prop(attrtab.zone_attr_name, RT_ATTR, PT_NAME, 5970087719fdSdp &ret_val); 5971087719fdSdp check_reqd_prop(attrtab.zone_attr_type, RT_ATTR, PT_TYPE, 5972087719fdSdp &ret_val); 5973087719fdSdp check_reqd_prop(attrtab.zone_attr_value, RT_ATTR, PT_VALUE, 5974087719fdSdp &ret_val); 59757c478bd9Sstevel@tonic-gate } 59767c478bd9Sstevel@tonic-gate (void) zonecfg_endattrent(handle); 59777c478bd9Sstevel@tonic-gate 5978fa9e4066Sahrens if ((err = zonecfg_setdsent(handle)) != Z_OK) { 5979bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 5980fa9e4066Sahrens return; 5981fa9e4066Sahrens } 5982fa9e4066Sahrens while (zonecfg_getdsent(handle, &dstab) == Z_OK) { 5983fa9e4066Sahrens if (strlen(dstab.zone_dataset_name) == 0) { 5984fa9e4066Sahrens zerr("%s: %s %s", rt_to_str(RT_DATASET), 5985fa9e4066Sahrens pt_to_str(PT_NAME), gettext("not specified")); 5986bbec428eSgjelinek saw_error = B_TRUE; 5987fa9e4066Sahrens if (ret_val == Z_OK) 5988fa9e4066Sahrens ret_val = Z_REQD_PROPERTY_MISSING; 5989fa9e4066Sahrens } else if (!zfs_name_valid(dstab.zone_dataset_name, 5990fa9e4066Sahrens ZFS_TYPE_FILESYSTEM)) { 5991fa9e4066Sahrens zerr("%s: %s %s", rt_to_str(RT_DATASET), 5992fa9e4066Sahrens pt_to_str(PT_NAME), gettext("invalid")); 5993bbec428eSgjelinek saw_error = B_TRUE; 5994fa9e4066Sahrens if (ret_val == Z_OK) 5995fa9e4066Sahrens ret_val = Z_BAD_PROPERTY; 5996fa9e4066Sahrens } 5997fa9e4066Sahrens 5998fa9e4066Sahrens } 5999fa9e4066Sahrens (void) zonecfg_enddsent(handle); 6000fa9e4066Sahrens 6001cb8a054bSGlenn Faden if ((err = zonecfg_setadminent(handle)) != Z_OK) { 6002cb8a054bSGlenn Faden zone_perror(zone, err, B_TRUE); 6003cb8a054bSGlenn Faden return; 6004cb8a054bSGlenn Faden } 6005cb8a054bSGlenn Faden while (zonecfg_getadminent(handle, &admintab) == Z_OK) { 6006cb8a054bSGlenn Faden check_reqd_prop(admintab.zone_admin_user, RT_ADMIN, 6007cb8a054bSGlenn Faden PT_USER, &ret_val); 6008cb8a054bSGlenn Faden check_reqd_prop(admintab.zone_admin_auths, RT_ADMIN, 6009cb8a054bSGlenn Faden PT_AUTHS, &ret_val); 6010cb8a054bSGlenn Faden if ((ret_val == Z_OK) && (getpwnam(admintab.zone_admin_user) 6011cb8a054bSGlenn Faden == NULL)) { 6012cb8a054bSGlenn Faden zerr(gettext("%s %s is not a valid username"), 6013cb8a054bSGlenn Faden pt_to_str(PT_USER), 6014cb8a054bSGlenn Faden admintab.zone_admin_user); 6015cb8a054bSGlenn Faden ret_val = Z_BAD_PROPERTY; 6016cb8a054bSGlenn Faden } 6017cb8a054bSGlenn Faden if ((ret_val == Z_OK) && (!zonecfg_valid_auths( 6018cb8a054bSGlenn Faden admintab.zone_admin_auths, zone))) { 6019cb8a054bSGlenn Faden ret_val = Z_BAD_PROPERTY; 6020cb8a054bSGlenn Faden } 6021cb8a054bSGlenn Faden } 6022cb8a054bSGlenn Faden (void) zonecfg_endadminent(handle); 6023cb8a054bSGlenn Faden 60247c478bd9Sstevel@tonic-gate if (!global_scope) { 60257c478bd9Sstevel@tonic-gate zerr(gettext("resource specification incomplete")); 6026bbec428eSgjelinek saw_error = B_TRUE; 60277c478bd9Sstevel@tonic-gate if (ret_val == Z_OK) 60287c478bd9Sstevel@tonic-gate ret_val = Z_INSUFFICIENT_SPEC; 60297c478bd9Sstevel@tonic-gate } 60307c478bd9Sstevel@tonic-gate 60317c478bd9Sstevel@tonic-gate if (save) { 6032087719fdSdp if (ret_val == Z_OK) { 6033087719fdSdp if ((ret_val = zonecfg_save(handle)) == Z_OK) { 6034bbec428eSgjelinek need_to_commit = B_FALSE; 6035087719fdSdp (void) strlcpy(revert_zone, zone, 6036087719fdSdp sizeof (revert_zone)); 6037087719fdSdp } 6038087719fdSdp } else { 6039087719fdSdp zerr(gettext("Zone %s failed to verify"), zone); 6040087719fdSdp } 60417c478bd9Sstevel@tonic-gate } 60427c478bd9Sstevel@tonic-gate if (ret_val != Z_OK) 6043bbec428eSgjelinek zone_perror(zone, ret_val, B_TRUE); 60447c478bd9Sstevel@tonic-gate } 60457c478bd9Sstevel@tonic-gate 60467c478bd9Sstevel@tonic-gate void 60477c478bd9Sstevel@tonic-gate cancel_func(cmd_t *cmd) 60487c478bd9Sstevel@tonic-gate { 60497c478bd9Sstevel@tonic-gate int arg; 6050bbec428eSgjelinek boolean_t arg_err = B_FALSE; 60517c478bd9Sstevel@tonic-gate 60527c478bd9Sstevel@tonic-gate assert(cmd != NULL); 60537c478bd9Sstevel@tonic-gate 60547c478bd9Sstevel@tonic-gate optind = 0; 60557ec75eb8Sgjelinek while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?")) != EOF) { 60567c478bd9Sstevel@tonic-gate switch (arg) { 60577c478bd9Sstevel@tonic-gate case '?': 60587c478bd9Sstevel@tonic-gate longer_usage(CMD_CANCEL); 6059bbec428eSgjelinek arg_err = B_TRUE; 60607ec75eb8Sgjelinek break; 60617c478bd9Sstevel@tonic-gate default: 60627c478bd9Sstevel@tonic-gate short_usage(CMD_CANCEL); 6063bbec428eSgjelinek arg_err = B_TRUE; 60647ec75eb8Sgjelinek break; 60657ec75eb8Sgjelinek } 60667ec75eb8Sgjelinek } 60677ec75eb8Sgjelinek if (arg_err) 60687c478bd9Sstevel@tonic-gate return; 60697ec75eb8Sgjelinek 60707c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 60717c478bd9Sstevel@tonic-gate short_usage(CMD_CANCEL); 60727c478bd9Sstevel@tonic-gate return; 60737c478bd9Sstevel@tonic-gate } 60747c478bd9Sstevel@tonic-gate 60757c478bd9Sstevel@tonic-gate if (global_scope) 60767c478bd9Sstevel@tonic-gate scope_usage(CMD_CANCEL); 6077bbec428eSgjelinek global_scope = B_TRUE; 60787c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(in_progress_fstab.zone_fs_options); 60797c478bd9Sstevel@tonic-gate bzero(&in_progress_fstab, sizeof (in_progress_fstab)); 60807c478bd9Sstevel@tonic-gate bzero(&in_progress_nwiftab, sizeof (in_progress_nwiftab)); 60817c478bd9Sstevel@tonic-gate bzero(&in_progress_devtab, sizeof (in_progress_devtab)); 60827c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(in_progress_rctltab.zone_rctl_valptr); 60837c478bd9Sstevel@tonic-gate bzero(&in_progress_rctltab, sizeof (in_progress_rctltab)); 60847c478bd9Sstevel@tonic-gate bzero(&in_progress_attrtab, sizeof (in_progress_attrtab)); 6085fa9e4066Sahrens bzero(&in_progress_dstab, sizeof (in_progress_dstab)); 60867c478bd9Sstevel@tonic-gate } 60877c478bd9Sstevel@tonic-gate 60887c478bd9Sstevel@tonic-gate static int 60897c478bd9Sstevel@tonic-gate validate_attr_name(char *name) 60907c478bd9Sstevel@tonic-gate { 60917c478bd9Sstevel@tonic-gate int i; 60927c478bd9Sstevel@tonic-gate 60937c478bd9Sstevel@tonic-gate if (!isalnum(name[0])) { 60947c478bd9Sstevel@tonic-gate zerr(gettext("Invalid %s %s %s: must start with an alpha-" 60957c478bd9Sstevel@tonic-gate "numeric character."), rt_to_str(RT_ATTR), 60967c478bd9Sstevel@tonic-gate pt_to_str(PT_NAME), name); 60977c478bd9Sstevel@tonic-gate return (Z_INVAL); 60987c478bd9Sstevel@tonic-gate } 60997c478bd9Sstevel@tonic-gate for (i = 1; name[i]; i++) 61007c478bd9Sstevel@tonic-gate if (!isalnum(name[i]) && name[i] != '-' && name[i] != '.') { 61017c478bd9Sstevel@tonic-gate zerr(gettext("Invalid %s %s %s: can only contain " 61027c478bd9Sstevel@tonic-gate "alpha-numeric characters, plus '-' and '.'."), 61037c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR), pt_to_str(PT_NAME), name); 61047c478bd9Sstevel@tonic-gate return (Z_INVAL); 61057c478bd9Sstevel@tonic-gate } 61067c478bd9Sstevel@tonic-gate return (Z_OK); 61077c478bd9Sstevel@tonic-gate } 61087c478bd9Sstevel@tonic-gate 61097c478bd9Sstevel@tonic-gate static int 61107c478bd9Sstevel@tonic-gate validate_attr_type_val(struct zone_attrtab *attrtab) 61117c478bd9Sstevel@tonic-gate { 61127c478bd9Sstevel@tonic-gate boolean_t boolval; 61137c478bd9Sstevel@tonic-gate int64_t intval; 61147c478bd9Sstevel@tonic-gate char strval[MAXNAMELEN]; 61157c478bd9Sstevel@tonic-gate uint64_t uintval; 61167c478bd9Sstevel@tonic-gate 61177c478bd9Sstevel@tonic-gate if (strcmp(attrtab->zone_attr_type, "boolean") == 0) { 61187c478bd9Sstevel@tonic-gate if (zonecfg_get_attr_boolean(attrtab, &boolval) == Z_OK) 61197c478bd9Sstevel@tonic-gate return (Z_OK); 61207c478bd9Sstevel@tonic-gate zerr(gettext("invalid %s value for %s=%s"), 61217c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR), pt_to_str(PT_TYPE), "boolean"); 61227c478bd9Sstevel@tonic-gate return (Z_ERR); 61237c478bd9Sstevel@tonic-gate } 61247c478bd9Sstevel@tonic-gate 61257c478bd9Sstevel@tonic-gate if (strcmp(attrtab->zone_attr_type, "int") == 0) { 61267c478bd9Sstevel@tonic-gate if (zonecfg_get_attr_int(attrtab, &intval) == Z_OK) 61277c478bd9Sstevel@tonic-gate return (Z_OK); 61287c478bd9Sstevel@tonic-gate zerr(gettext("invalid %s value for %s=%s"), 61297c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR), pt_to_str(PT_TYPE), "int"); 61307c478bd9Sstevel@tonic-gate return (Z_ERR); 61317c478bd9Sstevel@tonic-gate } 61327c478bd9Sstevel@tonic-gate 61337c478bd9Sstevel@tonic-gate if (strcmp(attrtab->zone_attr_type, "string") == 0) { 61347c478bd9Sstevel@tonic-gate if (zonecfg_get_attr_string(attrtab, strval, 61357c478bd9Sstevel@tonic-gate sizeof (strval)) == Z_OK) 61367c478bd9Sstevel@tonic-gate return (Z_OK); 61377c478bd9Sstevel@tonic-gate zerr(gettext("invalid %s value for %s=%s"), 61387c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR), pt_to_str(PT_TYPE), "string"); 61397c478bd9Sstevel@tonic-gate return (Z_ERR); 61407c478bd9Sstevel@tonic-gate } 61417c478bd9Sstevel@tonic-gate 61427c478bd9Sstevel@tonic-gate if (strcmp(attrtab->zone_attr_type, "uint") == 0) { 61437c478bd9Sstevel@tonic-gate if (zonecfg_get_attr_uint(attrtab, &uintval) == Z_OK) 61447c478bd9Sstevel@tonic-gate return (Z_OK); 61457c478bd9Sstevel@tonic-gate zerr(gettext("invalid %s value for %s=%s"), 61467c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR), pt_to_str(PT_TYPE), "uint"); 61477c478bd9Sstevel@tonic-gate return (Z_ERR); 61487c478bd9Sstevel@tonic-gate } 61497c478bd9Sstevel@tonic-gate 61507c478bd9Sstevel@tonic-gate zerr(gettext("invalid %s %s '%s'"), rt_to_str(RT_ATTR), 61517c478bd9Sstevel@tonic-gate pt_to_str(PT_TYPE), attrtab->zone_attr_type); 61527c478bd9Sstevel@tonic-gate return (Z_ERR); 61537c478bd9Sstevel@tonic-gate } 61547c478bd9Sstevel@tonic-gate 6155087719fdSdp /* 6156087719fdSdp * Helper function for end_func-- checks the existence of a given property 6157087719fdSdp * and emits a message if not specified. 6158087719fdSdp */ 6159087719fdSdp static int 6160bbec428eSgjelinek end_check_reqd(char *attr, int pt, boolean_t *validation_failed) 6161087719fdSdp { 6162087719fdSdp if (strlen(attr) == 0) { 6163bbec428eSgjelinek *validation_failed = B_TRUE; 6164087719fdSdp zerr(gettext("%s not specified"), pt_to_str(pt)); 6165087719fdSdp return (Z_ERR); 6166087719fdSdp } 6167087719fdSdp return (Z_OK); 6168087719fdSdp } 6169087719fdSdp 6170550b6e40SSowmini Varadhan static void 6171550b6e40SSowmini Varadhan net_exists_error(struct zone_nwiftab nwif) 6172550b6e40SSowmini Varadhan { 6173550b6e40SSowmini Varadhan if (strlen(nwif.zone_nwif_address) > 0) { 6174550b6e40SSowmini Varadhan zerr(gettext("A %s resource with the %s '%s', " 6175550b6e40SSowmini Varadhan "and %s '%s' already exists."), 6176550b6e40SSowmini Varadhan rt_to_str(RT_NET), 6177550b6e40SSowmini Varadhan pt_to_str(PT_PHYSICAL), 6178550b6e40SSowmini Varadhan nwif.zone_nwif_physical, 6179550b6e40SSowmini Varadhan pt_to_str(PT_ADDRESS), 6180550b6e40SSowmini Varadhan in_progress_nwiftab.zone_nwif_address); 6181550b6e40SSowmini Varadhan } else { 6182550b6e40SSowmini Varadhan zerr(gettext("A %s resource with the %s '%s', " 6183550b6e40SSowmini Varadhan "and %s '%s' already exists."), 6184550b6e40SSowmini Varadhan rt_to_str(RT_NET), 6185550b6e40SSowmini Varadhan pt_to_str(PT_PHYSICAL), 6186550b6e40SSowmini Varadhan nwif.zone_nwif_physical, 6187550b6e40SSowmini Varadhan pt_to_str(PT_ALLOWED_ADDRESS), 6188550b6e40SSowmini Varadhan nwif.zone_nwif_allowed_address); 6189550b6e40SSowmini Varadhan } 6190550b6e40SSowmini Varadhan } 6191550b6e40SSowmini Varadhan 61927c478bd9Sstevel@tonic-gate void 61937c478bd9Sstevel@tonic-gate end_func(cmd_t *cmd) 61947c478bd9Sstevel@tonic-gate { 6195bbec428eSgjelinek boolean_t validation_failed = B_FALSE; 6196bbec428eSgjelinek boolean_t arg_err = B_FALSE; 61977c478bd9Sstevel@tonic-gate struct zone_fstab tmp_fstab; 61987c478bd9Sstevel@tonic-gate struct zone_nwiftab tmp_nwiftab; 61997c478bd9Sstevel@tonic-gate struct zone_devtab tmp_devtab; 62007c478bd9Sstevel@tonic-gate struct zone_rctltab tmp_rctltab; 62017c478bd9Sstevel@tonic-gate struct zone_attrtab tmp_attrtab; 6202fa9e4066Sahrens struct zone_dstab tmp_dstab; 6203cb8a054bSGlenn Faden struct zone_admintab tmp_admintab; 62040209230bSgjelinek int err, arg, res1, res2, res3; 62050209230bSgjelinek uint64_t swap_limit; 62060209230bSgjelinek uint64_t locked_limit; 6207c97ad5cdSakolb uint64_t proc_cap; 62087c478bd9Sstevel@tonic-gate 62097c478bd9Sstevel@tonic-gate assert(cmd != NULL); 62107c478bd9Sstevel@tonic-gate 62117c478bd9Sstevel@tonic-gate optind = 0; 62127ec75eb8Sgjelinek while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?")) != EOF) { 62137c478bd9Sstevel@tonic-gate switch (arg) { 62147c478bd9Sstevel@tonic-gate case '?': 62157c478bd9Sstevel@tonic-gate longer_usage(CMD_END); 6216bbec428eSgjelinek arg_err = B_TRUE; 62177ec75eb8Sgjelinek break; 62187c478bd9Sstevel@tonic-gate default: 62197c478bd9Sstevel@tonic-gate short_usage(CMD_END); 6220bbec428eSgjelinek arg_err = B_TRUE; 62217ec75eb8Sgjelinek break; 62227ec75eb8Sgjelinek } 62237ec75eb8Sgjelinek } 62247ec75eb8Sgjelinek if (arg_err) 62257c478bd9Sstevel@tonic-gate return; 62267ec75eb8Sgjelinek 62277c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 62287c478bd9Sstevel@tonic-gate short_usage(CMD_END); 62297c478bd9Sstevel@tonic-gate return; 62307c478bd9Sstevel@tonic-gate } 62317c478bd9Sstevel@tonic-gate 62327c478bd9Sstevel@tonic-gate if (global_scope) { 62337c478bd9Sstevel@tonic-gate scope_usage(CMD_END); 62347c478bd9Sstevel@tonic-gate return; 62357c478bd9Sstevel@tonic-gate } 62367c478bd9Sstevel@tonic-gate 62377c478bd9Sstevel@tonic-gate assert(end_op == CMD_ADD || end_op == CMD_SELECT); 62387c478bd9Sstevel@tonic-gate 62397c478bd9Sstevel@tonic-gate switch (resource_scope) { 62407c478bd9Sstevel@tonic-gate case RT_FS: 62417c478bd9Sstevel@tonic-gate /* First make sure everything was filled in. */ 6242087719fdSdp if (end_check_reqd(in_progress_fstab.zone_fs_dir, 6243087719fdSdp PT_DIR, &validation_failed) == Z_OK) { 6244087719fdSdp if (in_progress_fstab.zone_fs_dir[0] != '/') { 6245087719fdSdp zerr(gettext("%s %s is not an absolute path."), 6246087719fdSdp pt_to_str(PT_DIR), 6247087719fdSdp in_progress_fstab.zone_fs_dir); 6248bbec428eSgjelinek validation_failed = B_TRUE; 62497c478bd9Sstevel@tonic-gate } 62507c478bd9Sstevel@tonic-gate } 6251087719fdSdp 6252087719fdSdp (void) end_check_reqd(in_progress_fstab.zone_fs_special, 6253087719fdSdp PT_SPECIAL, &validation_failed); 6254087719fdSdp 62557c478bd9Sstevel@tonic-gate if (in_progress_fstab.zone_fs_raw[0] != '\0' && 62567c478bd9Sstevel@tonic-gate in_progress_fstab.zone_fs_raw[0] != '/') { 6257087719fdSdp zerr(gettext("%s %s is not an absolute path."), 6258087719fdSdp pt_to_str(PT_RAW), 6259087719fdSdp in_progress_fstab.zone_fs_raw); 6260bbec428eSgjelinek validation_failed = B_TRUE; 62617c478bd9Sstevel@tonic-gate } 6262087719fdSdp 6263087719fdSdp (void) end_check_reqd(in_progress_fstab.zone_fs_type, PT_TYPE, 6264087719fdSdp &validation_failed); 6265087719fdSdp 6266087719fdSdp if (validation_failed) { 6267bbec428eSgjelinek saw_error = B_TRUE; 62687c478bd9Sstevel@tonic-gate return; 6269087719fdSdp } 6270087719fdSdp 62717c478bd9Sstevel@tonic-gate if (end_op == CMD_ADD) { 62727c478bd9Sstevel@tonic-gate /* Make sure there isn't already one like this. */ 62737c478bd9Sstevel@tonic-gate bzero(&tmp_fstab, sizeof (tmp_fstab)); 62747c478bd9Sstevel@tonic-gate (void) strlcpy(tmp_fstab.zone_fs_dir, 62757c478bd9Sstevel@tonic-gate in_progress_fstab.zone_fs_dir, 62767c478bd9Sstevel@tonic-gate sizeof (tmp_fstab.zone_fs_dir)); 62777c478bd9Sstevel@tonic-gate err = zonecfg_lookup_filesystem(handle, &tmp_fstab); 62787c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(tmp_fstab.zone_fs_options); 62797c478bd9Sstevel@tonic-gate if (err == Z_OK) { 62807c478bd9Sstevel@tonic-gate zerr(gettext("A %s resource " 62817c478bd9Sstevel@tonic-gate "with the %s '%s' already exists."), 62827c478bd9Sstevel@tonic-gate rt_to_str(RT_FS), pt_to_str(PT_DIR), 62837c478bd9Sstevel@tonic-gate in_progress_fstab.zone_fs_dir); 6284bbec428eSgjelinek saw_error = B_TRUE; 62857c478bd9Sstevel@tonic-gate return; 62867c478bd9Sstevel@tonic-gate } 62877c478bd9Sstevel@tonic-gate err = zonecfg_add_filesystem(handle, 62887c478bd9Sstevel@tonic-gate &in_progress_fstab); 62897c478bd9Sstevel@tonic-gate } else { 62907c478bd9Sstevel@tonic-gate err = zonecfg_modify_filesystem(handle, &old_fstab, 62917c478bd9Sstevel@tonic-gate &in_progress_fstab); 62927c478bd9Sstevel@tonic-gate } 62937c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(in_progress_fstab.zone_fs_options); 62947c478bd9Sstevel@tonic-gate in_progress_fstab.zone_fs_options = NULL; 62957c478bd9Sstevel@tonic-gate break; 6296087719fdSdp 62977c478bd9Sstevel@tonic-gate case RT_NET: 6298f4b3ec61Sdh155122 /* 6299f4b3ec61Sdh155122 * First make sure everything was filled in. 6300f4b3ec61Sdh155122 * Since we don't know whether IP will be shared 6301f4b3ec61Sdh155122 * or exclusive here, some checks are deferred until 6302f4b3ec61Sdh155122 * the verify command. 6303f4b3ec61Sdh155122 */ 6304087719fdSdp (void) end_check_reqd(in_progress_nwiftab.zone_nwif_physical, 6305087719fdSdp PT_PHYSICAL, &validation_failed); 6306087719fdSdp 6307087719fdSdp if (validation_failed) { 6308bbec428eSgjelinek saw_error = B_TRUE; 63097c478bd9Sstevel@tonic-gate return; 6310087719fdSdp } 63117c478bd9Sstevel@tonic-gate if (end_op == CMD_ADD) { 63127c478bd9Sstevel@tonic-gate /* Make sure there isn't already one like this. */ 63137c478bd9Sstevel@tonic-gate bzero(&tmp_nwiftab, sizeof (tmp_nwiftab)); 6314f4b3ec61Sdh155122 (void) strlcpy(tmp_nwiftab.zone_nwif_physical, 6315f4b3ec61Sdh155122 in_progress_nwiftab.zone_nwif_physical, 6316f4b3ec61Sdh155122 sizeof (tmp_nwiftab.zone_nwif_physical)); 63177c478bd9Sstevel@tonic-gate (void) strlcpy(tmp_nwiftab.zone_nwif_address, 63187c478bd9Sstevel@tonic-gate in_progress_nwiftab.zone_nwif_address, 63197c478bd9Sstevel@tonic-gate sizeof (tmp_nwiftab.zone_nwif_address)); 6320550b6e40SSowmini Varadhan (void) strlcpy(tmp_nwiftab.zone_nwif_allowed_address, 6321550b6e40SSowmini Varadhan in_progress_nwiftab.zone_nwif_allowed_address, 6322550b6e40SSowmini Varadhan sizeof (tmp_nwiftab.zone_nwif_allowed_address)); 6323550b6e40SSowmini Varadhan (void) strlcpy(tmp_nwiftab.zone_nwif_defrouter, 6324550b6e40SSowmini Varadhan in_progress_nwiftab.zone_nwif_defrouter, 6325550b6e40SSowmini Varadhan sizeof (tmp_nwiftab.zone_nwif_defrouter)); 63267c478bd9Sstevel@tonic-gate if (zonecfg_lookup_nwif(handle, &tmp_nwiftab) == Z_OK) { 6327550b6e40SSowmini Varadhan net_exists_error(in_progress_nwiftab); 6328bbec428eSgjelinek saw_error = B_TRUE; 63297c478bd9Sstevel@tonic-gate return; 63307c478bd9Sstevel@tonic-gate } 63317c478bd9Sstevel@tonic-gate err = zonecfg_add_nwif(handle, &in_progress_nwiftab); 63327c478bd9Sstevel@tonic-gate } else { 63337c478bd9Sstevel@tonic-gate err = zonecfg_modify_nwif(handle, &old_nwiftab, 63347c478bd9Sstevel@tonic-gate &in_progress_nwiftab); 63357c478bd9Sstevel@tonic-gate } 63367c478bd9Sstevel@tonic-gate break; 6337087719fdSdp 63387c478bd9Sstevel@tonic-gate case RT_DEVICE: 63397c478bd9Sstevel@tonic-gate /* First make sure everything was filled in. */ 6340087719fdSdp (void) end_check_reqd(in_progress_devtab.zone_dev_match, 6341087719fdSdp PT_MATCH, &validation_failed); 6342087719fdSdp 6343087719fdSdp if (validation_failed) { 6344bbec428eSgjelinek saw_error = B_TRUE; 63457c478bd9Sstevel@tonic-gate return; 6346087719fdSdp } 6347087719fdSdp 63487c478bd9Sstevel@tonic-gate if (end_op == CMD_ADD) { 63497c478bd9Sstevel@tonic-gate /* Make sure there isn't already one like this. */ 63507c478bd9Sstevel@tonic-gate (void) strlcpy(tmp_devtab.zone_dev_match, 63517c478bd9Sstevel@tonic-gate in_progress_devtab.zone_dev_match, 63527c478bd9Sstevel@tonic-gate sizeof (tmp_devtab.zone_dev_match)); 63537c478bd9Sstevel@tonic-gate if (zonecfg_lookup_dev(handle, &tmp_devtab) == Z_OK) { 63547c478bd9Sstevel@tonic-gate zerr(gettext("A %s resource with the %s '%s' " 63557c478bd9Sstevel@tonic-gate "already exists."), rt_to_str(RT_DEVICE), 63567c478bd9Sstevel@tonic-gate pt_to_str(PT_MATCH), 63577c478bd9Sstevel@tonic-gate in_progress_devtab.zone_dev_match); 6358bbec428eSgjelinek saw_error = B_TRUE; 63597c478bd9Sstevel@tonic-gate return; 63607c478bd9Sstevel@tonic-gate } 63617c478bd9Sstevel@tonic-gate err = zonecfg_add_dev(handle, &in_progress_devtab); 63627c478bd9Sstevel@tonic-gate } else { 63637c478bd9Sstevel@tonic-gate err = zonecfg_modify_dev(handle, &old_devtab, 63647c478bd9Sstevel@tonic-gate &in_progress_devtab); 63657c478bd9Sstevel@tonic-gate } 63667c478bd9Sstevel@tonic-gate break; 6367087719fdSdp 63687c478bd9Sstevel@tonic-gate case RT_RCTL: 63697c478bd9Sstevel@tonic-gate /* First make sure everything was filled in. */ 6370087719fdSdp (void) end_check_reqd(in_progress_rctltab.zone_rctl_name, 6371087719fdSdp PT_NAME, &validation_failed); 6372087719fdSdp 63737c478bd9Sstevel@tonic-gate if (in_progress_rctltab.zone_rctl_valptr == NULL) { 63747c478bd9Sstevel@tonic-gate zerr(gettext("no %s specified"), pt_to_str(PT_VALUE)); 6375bbec428eSgjelinek validation_failed = B_TRUE; 63767c478bd9Sstevel@tonic-gate } 6377087719fdSdp 6378087719fdSdp if (validation_failed) { 6379bbec428eSgjelinek saw_error = B_TRUE; 63807c478bd9Sstevel@tonic-gate return; 6381087719fdSdp } 6382087719fdSdp 63837c478bd9Sstevel@tonic-gate if (end_op == CMD_ADD) { 63847c478bd9Sstevel@tonic-gate /* Make sure there isn't already one like this. */ 63857c478bd9Sstevel@tonic-gate (void) strlcpy(tmp_rctltab.zone_rctl_name, 63867c478bd9Sstevel@tonic-gate in_progress_rctltab.zone_rctl_name, 63877c478bd9Sstevel@tonic-gate sizeof (tmp_rctltab.zone_rctl_name)); 63887c478bd9Sstevel@tonic-gate tmp_rctltab.zone_rctl_valptr = NULL; 63897c478bd9Sstevel@tonic-gate err = zonecfg_lookup_rctl(handle, &tmp_rctltab); 63907c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list( 63917c478bd9Sstevel@tonic-gate tmp_rctltab.zone_rctl_valptr); 63927c478bd9Sstevel@tonic-gate if (err == Z_OK) { 63937c478bd9Sstevel@tonic-gate zerr(gettext("A %s resource " 63947c478bd9Sstevel@tonic-gate "with the %s '%s' already exists."), 63957c478bd9Sstevel@tonic-gate rt_to_str(RT_RCTL), pt_to_str(PT_NAME), 63967c478bd9Sstevel@tonic-gate in_progress_rctltab.zone_rctl_name); 6397bbec428eSgjelinek saw_error = B_TRUE; 63987c478bd9Sstevel@tonic-gate return; 63997c478bd9Sstevel@tonic-gate } 64007c478bd9Sstevel@tonic-gate err = zonecfg_add_rctl(handle, &in_progress_rctltab); 64017c478bd9Sstevel@tonic-gate } else { 64027c478bd9Sstevel@tonic-gate err = zonecfg_modify_rctl(handle, &old_rctltab, 64037c478bd9Sstevel@tonic-gate &in_progress_rctltab); 64047c478bd9Sstevel@tonic-gate } 64057c478bd9Sstevel@tonic-gate if (err == Z_OK) { 64067c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list( 64077c478bd9Sstevel@tonic-gate in_progress_rctltab.zone_rctl_valptr); 64087c478bd9Sstevel@tonic-gate in_progress_rctltab.zone_rctl_valptr = NULL; 64097c478bd9Sstevel@tonic-gate } 64107c478bd9Sstevel@tonic-gate break; 6411087719fdSdp 64127c478bd9Sstevel@tonic-gate case RT_ATTR: 64137c478bd9Sstevel@tonic-gate /* First make sure everything was filled in. */ 6414087719fdSdp (void) end_check_reqd(in_progress_attrtab.zone_attr_name, 6415087719fdSdp PT_NAME, &validation_failed); 6416087719fdSdp (void) end_check_reqd(in_progress_attrtab.zone_attr_type, 6417087719fdSdp PT_TYPE, &validation_failed); 6418087719fdSdp (void) end_check_reqd(in_progress_attrtab.zone_attr_value, 6419087719fdSdp PT_VALUE, &validation_failed); 6420087719fdSdp 64217c478bd9Sstevel@tonic-gate if (validate_attr_name(in_progress_attrtab.zone_attr_name) != 6422087719fdSdp Z_OK) 6423bbec428eSgjelinek validation_failed = B_TRUE; 6424087719fdSdp 6425087719fdSdp if (validate_attr_type_val(&in_progress_attrtab) != Z_OK) 6426bbec428eSgjelinek validation_failed = B_TRUE; 6427087719fdSdp 6428087719fdSdp if (validation_failed) { 6429bbec428eSgjelinek saw_error = B_TRUE; 64307c478bd9Sstevel@tonic-gate return; 6431087719fdSdp } 64327c478bd9Sstevel@tonic-gate if (end_op == CMD_ADD) { 64337c478bd9Sstevel@tonic-gate /* Make sure there isn't already one like this. */ 64347c478bd9Sstevel@tonic-gate bzero(&tmp_attrtab, sizeof (tmp_attrtab)); 64357c478bd9Sstevel@tonic-gate (void) strlcpy(tmp_attrtab.zone_attr_name, 64367c478bd9Sstevel@tonic-gate in_progress_attrtab.zone_attr_name, 64377c478bd9Sstevel@tonic-gate sizeof (tmp_attrtab.zone_attr_name)); 64387c478bd9Sstevel@tonic-gate if (zonecfg_lookup_attr(handle, &tmp_attrtab) == Z_OK) { 64397c478bd9Sstevel@tonic-gate zerr(gettext("An %s resource " 64407c478bd9Sstevel@tonic-gate "with the %s '%s' already exists."), 64417c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR), pt_to_str(PT_NAME), 64427c478bd9Sstevel@tonic-gate in_progress_attrtab.zone_attr_name); 6443bbec428eSgjelinek saw_error = B_TRUE; 64447c478bd9Sstevel@tonic-gate return; 64457c478bd9Sstevel@tonic-gate } 64467c478bd9Sstevel@tonic-gate err = zonecfg_add_attr(handle, &in_progress_attrtab); 64477c478bd9Sstevel@tonic-gate } else { 64487c478bd9Sstevel@tonic-gate err = zonecfg_modify_attr(handle, &old_attrtab, 64497c478bd9Sstevel@tonic-gate &in_progress_attrtab); 64507c478bd9Sstevel@tonic-gate } 64517c478bd9Sstevel@tonic-gate break; 6452fa9e4066Sahrens case RT_DATASET: 6453fa9e4066Sahrens /* First make sure everything was filled in. */ 6454fa9e4066Sahrens if (strlen(in_progress_dstab.zone_dataset_name) == 0) { 6455fa9e4066Sahrens zerr("%s %s", pt_to_str(PT_NAME), 6456fa9e4066Sahrens gettext("not specified")); 6457bbec428eSgjelinek saw_error = B_TRUE; 6458bbec428eSgjelinek validation_failed = B_TRUE; 6459fa9e4066Sahrens } 6460fa9e4066Sahrens if (validation_failed) 6461fa9e4066Sahrens return; 6462fa9e4066Sahrens if (end_op == CMD_ADD) { 6463fa9e4066Sahrens /* Make sure there isn't already one like this. */ 6464fa9e4066Sahrens bzero(&tmp_dstab, sizeof (tmp_dstab)); 6465fa9e4066Sahrens (void) strlcpy(tmp_dstab.zone_dataset_name, 6466fa9e4066Sahrens in_progress_dstab.zone_dataset_name, 6467fa9e4066Sahrens sizeof (tmp_dstab.zone_dataset_name)); 6468fa9e4066Sahrens err = zonecfg_lookup_ds(handle, &tmp_dstab); 6469fa9e4066Sahrens if (err == Z_OK) { 6470fa9e4066Sahrens zerr(gettext("A %s resource " 6471fa9e4066Sahrens "with the %s '%s' already exists."), 6472fa9e4066Sahrens rt_to_str(RT_DATASET), pt_to_str(PT_NAME), 6473fa9e4066Sahrens in_progress_dstab.zone_dataset_name); 6474bbec428eSgjelinek saw_error = B_TRUE; 6475fa9e4066Sahrens return; 6476fa9e4066Sahrens } 6477fa9e4066Sahrens err = zonecfg_add_ds(handle, &in_progress_dstab); 6478fa9e4066Sahrens } else { 6479fa9e4066Sahrens err = zonecfg_modify_ds(handle, &old_dstab, 6480fa9e4066Sahrens &in_progress_dstab); 6481fa9e4066Sahrens } 6482fa9e4066Sahrens break; 64830209230bSgjelinek case RT_DCPU: 64840209230bSgjelinek /* Make sure everything was filled in. */ 64850209230bSgjelinek if (end_check_reqd(in_progress_psettab.zone_ncpu_min, 64860209230bSgjelinek PT_NCPUS, &validation_failed) != Z_OK) { 6487bbec428eSgjelinek saw_error = B_TRUE; 64880209230bSgjelinek return; 64890209230bSgjelinek } 64900209230bSgjelinek 64910209230bSgjelinek if (end_op == CMD_ADD) { 64920209230bSgjelinek err = zonecfg_add_pset(handle, &in_progress_psettab); 64930209230bSgjelinek } else { 64940209230bSgjelinek err = zonecfg_modify_pset(handle, &in_progress_psettab); 64950209230bSgjelinek } 64960209230bSgjelinek break; 6497c97ad5cdSakolb case RT_PCAP: 6498c97ad5cdSakolb /* Make sure everything was filled in. */ 6499c97ad5cdSakolb if (zonecfg_get_aliased_rctl(handle, ALIAS_CPUCAP, &proc_cap) 6500c97ad5cdSakolb != Z_OK) { 6501c97ad5cdSakolb zerr(gettext("%s not specified"), pt_to_str(PT_NCPUS)); 6502bbec428eSgjelinek saw_error = B_TRUE; 6503bbec428eSgjelinek validation_failed = B_TRUE; 6504c97ad5cdSakolb return; 6505c97ad5cdSakolb } 6506c97ad5cdSakolb err = Z_OK; 6507c97ad5cdSakolb break; 65080209230bSgjelinek case RT_MCAP: 65090209230bSgjelinek /* Make sure everything was filled in. */ 65100209230bSgjelinek res1 = strlen(in_progress_mcaptab.zone_physmem_cap) == 0 ? 65110209230bSgjelinek Z_ERR : Z_OK; 65120209230bSgjelinek res2 = zonecfg_get_aliased_rctl(handle, ALIAS_MAXSWAP, 65130209230bSgjelinek &swap_limit); 65140209230bSgjelinek res3 = zonecfg_get_aliased_rctl(handle, ALIAS_MAXLOCKEDMEM, 65150209230bSgjelinek &locked_limit); 65160209230bSgjelinek 65170209230bSgjelinek if (res1 != Z_OK && res2 != Z_OK && res3 != Z_OK) { 65180209230bSgjelinek zerr(gettext("No property was specified. One of %s, " 65190209230bSgjelinek "%s or %s is required."), pt_to_str(PT_PHYSICAL), 65200209230bSgjelinek pt_to_str(PT_SWAP), pt_to_str(PT_LOCKED)); 6521bbec428eSgjelinek saw_error = B_TRUE; 65220209230bSgjelinek return; 65230209230bSgjelinek } 65240209230bSgjelinek 65250209230bSgjelinek /* if phys & locked are both set, verify locked <= phys */ 65260209230bSgjelinek if (res1 == Z_OK && res3 == Z_OK) { 65270209230bSgjelinek uint64_t phys_limit; 65280209230bSgjelinek char *endp; 65290209230bSgjelinek 65300209230bSgjelinek phys_limit = strtoull( 65310209230bSgjelinek in_progress_mcaptab.zone_physmem_cap, &endp, 10); 65320209230bSgjelinek if (phys_limit < locked_limit) { 65330209230bSgjelinek zerr(gettext("The %s cap must be less than or " 65340209230bSgjelinek "equal to the %s cap."), 65350209230bSgjelinek pt_to_str(PT_LOCKED), 65360209230bSgjelinek pt_to_str(PT_PHYSICAL)); 6537bbec428eSgjelinek saw_error = B_TRUE; 65380209230bSgjelinek return; 65390209230bSgjelinek } 65400209230bSgjelinek } 65410209230bSgjelinek 65420209230bSgjelinek err = Z_OK; 65430209230bSgjelinek if (res1 == Z_OK) { 65440209230bSgjelinek /* 65450209230bSgjelinek * We could be ending from either an add operation 65460209230bSgjelinek * or a select operation. Since all of the properties 65470209230bSgjelinek * within this resource are optional, we always use 65480209230bSgjelinek * modify on the mcap entry. zonecfg_modify_mcap() 65490209230bSgjelinek * will handle both adding and modifying a memory cap. 65500209230bSgjelinek */ 65510209230bSgjelinek err = zonecfg_modify_mcap(handle, &in_progress_mcaptab); 65520209230bSgjelinek } else if (end_op == CMD_SELECT) { 65530209230bSgjelinek /* 65540209230bSgjelinek * If we're ending from a select and the physical 65550209230bSgjelinek * memory cap is empty then the user could have cleared 65560209230bSgjelinek * the physical cap value, so try to delete the entry. 65570209230bSgjelinek */ 65580209230bSgjelinek (void) zonecfg_delete_mcap(handle); 65590209230bSgjelinek } 65600209230bSgjelinek break; 6561cb8a054bSGlenn Faden case RT_ADMIN: 6562cb8a054bSGlenn Faden /* First make sure everything was filled in. */ 6563cb8a054bSGlenn Faden if (end_check_reqd(in_progress_admintab.zone_admin_user, 6564cb8a054bSGlenn Faden PT_USER, &validation_failed) == Z_OK) { 6565cb8a054bSGlenn Faden if (getpwnam(in_progress_admintab.zone_admin_user) 6566cb8a054bSGlenn Faden == NULL) { 6567cb8a054bSGlenn Faden zerr(gettext("%s %s is not a valid username"), 6568cb8a054bSGlenn Faden pt_to_str(PT_USER), 6569cb8a054bSGlenn Faden in_progress_admintab.zone_admin_user); 6570cb8a054bSGlenn Faden validation_failed = B_TRUE; 6571cb8a054bSGlenn Faden } 6572cb8a054bSGlenn Faden } 6573cb8a054bSGlenn Faden 6574cb8a054bSGlenn Faden if (end_check_reqd(in_progress_admintab.zone_admin_auths, 6575cb8a054bSGlenn Faden PT_AUTHS, &validation_failed) == Z_OK) { 6576cb8a054bSGlenn Faden if (!zonecfg_valid_auths( 6577cb8a054bSGlenn Faden in_progress_admintab.zone_admin_auths, 6578cb8a054bSGlenn Faden zone)) { 6579cb8a054bSGlenn Faden validation_failed = B_TRUE; 6580cb8a054bSGlenn Faden } 6581cb8a054bSGlenn Faden } 6582cb8a054bSGlenn Faden 6583cb8a054bSGlenn Faden if (validation_failed) { 6584cb8a054bSGlenn Faden saw_error = B_TRUE; 6585cb8a054bSGlenn Faden return; 6586cb8a054bSGlenn Faden } 6587cb8a054bSGlenn Faden 6588cb8a054bSGlenn Faden if (end_op == CMD_ADD) { 6589cb8a054bSGlenn Faden /* Make sure there isn't already one like this. */ 6590cb8a054bSGlenn Faden bzero(&tmp_admintab, sizeof (tmp_admintab)); 6591cb8a054bSGlenn Faden (void) strlcpy(tmp_admintab.zone_admin_user, 6592cb8a054bSGlenn Faden in_progress_admintab.zone_admin_user, 6593cb8a054bSGlenn Faden sizeof (tmp_admintab.zone_admin_user)); 6594cb8a054bSGlenn Faden err = zonecfg_lookup_admin( 6595cb8a054bSGlenn Faden handle, &tmp_admintab); 6596cb8a054bSGlenn Faden if (err == Z_OK) { 6597cb8a054bSGlenn Faden zerr(gettext("A %s resource " 6598cb8a054bSGlenn Faden "with the %s '%s' already exists."), 6599cb8a054bSGlenn Faden rt_to_str(RT_ADMIN), 6600cb8a054bSGlenn Faden pt_to_str(PT_USER), 6601cb8a054bSGlenn Faden in_progress_admintab.zone_admin_user); 6602cb8a054bSGlenn Faden saw_error = B_TRUE; 6603cb8a054bSGlenn Faden return; 6604cb8a054bSGlenn Faden } 6605cb8a054bSGlenn Faden err = zonecfg_add_admin(handle, 6606cb8a054bSGlenn Faden &in_progress_admintab, zone); 6607cb8a054bSGlenn Faden } else { 6608cb8a054bSGlenn Faden err = zonecfg_modify_admin(handle, 6609cb8a054bSGlenn Faden &old_admintab, &in_progress_admintab, 6610cb8a054bSGlenn Faden zone); 6611cb8a054bSGlenn Faden } 6612cb8a054bSGlenn Faden break; 66137c478bd9Sstevel@tonic-gate default: 66147c478bd9Sstevel@tonic-gate zone_perror(rt_to_str(resource_scope), Z_NO_RESOURCE_TYPE, 6615bbec428eSgjelinek B_TRUE); 6616bbec428eSgjelinek saw_error = B_TRUE; 66177c478bd9Sstevel@tonic-gate return; 66187c478bd9Sstevel@tonic-gate } 66197c478bd9Sstevel@tonic-gate 66207c478bd9Sstevel@tonic-gate if (err != Z_OK) { 6621bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 66227c478bd9Sstevel@tonic-gate } else { 6623bbec428eSgjelinek need_to_commit = B_TRUE; 6624bbec428eSgjelinek global_scope = B_TRUE; 66257c478bd9Sstevel@tonic-gate end_op = -1; 66267c478bd9Sstevel@tonic-gate } 66277c478bd9Sstevel@tonic-gate } 66287c478bd9Sstevel@tonic-gate 66297c478bd9Sstevel@tonic-gate void 66307c478bd9Sstevel@tonic-gate commit_func(cmd_t *cmd) 66317c478bd9Sstevel@tonic-gate { 66327c478bd9Sstevel@tonic-gate int arg; 6633bbec428eSgjelinek boolean_t arg_err = B_FALSE; 66347c478bd9Sstevel@tonic-gate 66357c478bd9Sstevel@tonic-gate optind = 0; 66367ec75eb8Sgjelinek while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?")) != EOF) { 66377c478bd9Sstevel@tonic-gate switch (arg) { 66387c478bd9Sstevel@tonic-gate case '?': 66397c478bd9Sstevel@tonic-gate longer_usage(CMD_COMMIT); 6640bbec428eSgjelinek arg_err = B_TRUE; 66417ec75eb8Sgjelinek break; 66427c478bd9Sstevel@tonic-gate default: 66437c478bd9Sstevel@tonic-gate short_usage(CMD_COMMIT); 6644bbec428eSgjelinek arg_err = B_TRUE; 66457ec75eb8Sgjelinek break; 66467ec75eb8Sgjelinek } 66477ec75eb8Sgjelinek } 66487ec75eb8Sgjelinek if (arg_err) 66497c478bd9Sstevel@tonic-gate return; 66507ec75eb8Sgjelinek 66517c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 66527c478bd9Sstevel@tonic-gate short_usage(CMD_COMMIT); 66537c478bd9Sstevel@tonic-gate return; 66547c478bd9Sstevel@tonic-gate } 66557c478bd9Sstevel@tonic-gate 66567c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_COMMIT)) 66577c478bd9Sstevel@tonic-gate return; 66587c478bd9Sstevel@tonic-gate 66597c478bd9Sstevel@tonic-gate assert(cmd != NULL); 66607c478bd9Sstevel@tonic-gate 66617c478bd9Sstevel@tonic-gate cmd->cmd_argc = 1; 66627c478bd9Sstevel@tonic-gate /* 66637c478bd9Sstevel@tonic-gate * cmd_arg normally comes from a strdup() in the lexer, and the 66647c478bd9Sstevel@tonic-gate * whole cmd structure and its (char *) attributes are freed at 66657c478bd9Sstevel@tonic-gate * the completion of each command, so the strdup() below is needed 66667c478bd9Sstevel@tonic-gate * to match this and prevent a core dump from trying to free() 66677c478bd9Sstevel@tonic-gate * something that can't be. 66687c478bd9Sstevel@tonic-gate */ 66697c478bd9Sstevel@tonic-gate if ((cmd->cmd_argv[0] = strdup("save")) == NULL) { 6670bbec428eSgjelinek zone_perror(zone, Z_NOMEM, B_TRUE); 66717c478bd9Sstevel@tonic-gate exit(Z_ERR); 66727c478bd9Sstevel@tonic-gate } 66737c478bd9Sstevel@tonic-gate cmd->cmd_argv[1] = NULL; 66747c478bd9Sstevel@tonic-gate verify_func(cmd); 66757c478bd9Sstevel@tonic-gate } 66767c478bd9Sstevel@tonic-gate 66777c478bd9Sstevel@tonic-gate void 66787c478bd9Sstevel@tonic-gate revert_func(cmd_t *cmd) 66797c478bd9Sstevel@tonic-gate { 66807c478bd9Sstevel@tonic-gate char line[128]; /* enough to ask a question */ 6681bbec428eSgjelinek boolean_t force = B_FALSE; 6682bbec428eSgjelinek boolean_t arg_err = B_FALSE; 66837c478bd9Sstevel@tonic-gate int err, arg, answer; 66847c478bd9Sstevel@tonic-gate 66857c478bd9Sstevel@tonic-gate optind = 0; 66867c478bd9Sstevel@tonic-gate while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?F")) != EOF) { 66877c478bd9Sstevel@tonic-gate switch (arg) { 66887c478bd9Sstevel@tonic-gate case '?': 66897c478bd9Sstevel@tonic-gate longer_usage(CMD_REVERT); 6690bbec428eSgjelinek arg_err = B_TRUE; 66917ec75eb8Sgjelinek break; 66927c478bd9Sstevel@tonic-gate case 'F': 6693bbec428eSgjelinek force = B_TRUE; 66947c478bd9Sstevel@tonic-gate break; 66957c478bd9Sstevel@tonic-gate default: 66967c478bd9Sstevel@tonic-gate short_usage(CMD_REVERT); 6697bbec428eSgjelinek arg_err = B_TRUE; 66987ec75eb8Sgjelinek break; 66997ec75eb8Sgjelinek } 67007ec75eb8Sgjelinek } 67017ec75eb8Sgjelinek if (arg_err) 67027c478bd9Sstevel@tonic-gate return; 67037ec75eb8Sgjelinek 67047c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 67057c478bd9Sstevel@tonic-gate short_usage(CMD_REVERT); 67067c478bd9Sstevel@tonic-gate return; 67077c478bd9Sstevel@tonic-gate } 67087c478bd9Sstevel@tonic-gate 67097c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_REVERT)) 67107c478bd9Sstevel@tonic-gate return; 67117c478bd9Sstevel@tonic-gate 67125b418297Sjv227347 if (!global_scope) { 67135b418297Sjv227347 zerr(gettext("You can only use %s in the global scope.\nUse" 67145b418297Sjv227347 " '%s' to cancel changes to a resource specification."), 67155b418297Sjv227347 cmd_to_str(CMD_REVERT), cmd_to_str(CMD_CANCEL)); 67165b418297Sjv227347 saw_error = B_TRUE; 67175b418297Sjv227347 return; 67185b418297Sjv227347 } 67195b418297Sjv227347 67207c478bd9Sstevel@tonic-gate if (zonecfg_check_handle(handle) != Z_OK) { 67217c478bd9Sstevel@tonic-gate zerr(gettext("No changes to revert.")); 6722bbec428eSgjelinek saw_error = B_TRUE; 67237c478bd9Sstevel@tonic-gate return; 67247c478bd9Sstevel@tonic-gate } 67257c478bd9Sstevel@tonic-gate 67267c478bd9Sstevel@tonic-gate if (!force) { 67277c478bd9Sstevel@tonic-gate (void) snprintf(line, sizeof (line), 67287c478bd9Sstevel@tonic-gate gettext("Are you sure you want to revert")); 6729bbec428eSgjelinek if ((answer = ask_yesno(B_FALSE, line)) == -1) { 67307c478bd9Sstevel@tonic-gate zerr(gettext("Input not from terminal and -F not " 67317c478bd9Sstevel@tonic-gate "specified:\n%s command ignored, exiting."), 67327c478bd9Sstevel@tonic-gate cmd_to_str(CMD_REVERT)); 67337c478bd9Sstevel@tonic-gate exit(Z_ERR); 67347c478bd9Sstevel@tonic-gate } 67357c478bd9Sstevel@tonic-gate if (answer != 1) 67367c478bd9Sstevel@tonic-gate return; 67377c478bd9Sstevel@tonic-gate } 67387c478bd9Sstevel@tonic-gate 67397c478bd9Sstevel@tonic-gate /* 6740cb8a054bSGlenn Faden * Reset any pending admins that were 6741cb8a054bSGlenn Faden * removed from the previous zone 6742cb8a054bSGlenn Faden */ 6743cb8a054bSGlenn Faden zonecfg_remove_userauths(handle, "", zone, B_FALSE); 6744cb8a054bSGlenn Faden 6745cb8a054bSGlenn Faden /* 67467c478bd9Sstevel@tonic-gate * Time for a new handle: finish the old one off first 67477c478bd9Sstevel@tonic-gate * then get a new one properly to avoid leaks. 67487c478bd9Sstevel@tonic-gate */ 67497c478bd9Sstevel@tonic-gate zonecfg_fini_handle(handle); 67507c478bd9Sstevel@tonic-gate if ((handle = zonecfg_init_handle()) == NULL) { 6751bbec428eSgjelinek zone_perror(execname, Z_NOMEM, B_TRUE); 67527c478bd9Sstevel@tonic-gate exit(Z_ERR); 67537c478bd9Sstevel@tonic-gate } 6754cb8a054bSGlenn Faden 6755087719fdSdp if ((err = zonecfg_get_handle(revert_zone, handle)) != Z_OK) { 6756bbec428eSgjelinek saw_error = B_TRUE; 6757bbec428eSgjelinek got_handle = B_FALSE; 67587c478bd9Sstevel@tonic-gate if (err == Z_NO_ZONE) 67597c478bd9Sstevel@tonic-gate zerr(gettext("%s: no such saved zone to revert to."), 6760087719fdSdp revert_zone); 67617c478bd9Sstevel@tonic-gate else 6762bbec428eSgjelinek zone_perror(zone, err, B_TRUE); 67637c478bd9Sstevel@tonic-gate } 6764087719fdSdp (void) strlcpy(zone, revert_zone, sizeof (zone)); 67657c478bd9Sstevel@tonic-gate } 67667c478bd9Sstevel@tonic-gate 67677c478bd9Sstevel@tonic-gate void 67687c478bd9Sstevel@tonic-gate help_func(cmd_t *cmd) 67697c478bd9Sstevel@tonic-gate { 67707c478bd9Sstevel@tonic-gate int i; 67717c478bd9Sstevel@tonic-gate 67727c478bd9Sstevel@tonic-gate assert(cmd != NULL); 67737c478bd9Sstevel@tonic-gate 67747c478bd9Sstevel@tonic-gate if (cmd->cmd_argc == 0) { 6775bbec428eSgjelinek usage(B_TRUE, global_scope ? HELP_SUBCMDS : HELP_RES_SCOPE); 67767c478bd9Sstevel@tonic-gate return; 67777c478bd9Sstevel@tonic-gate } 67787c478bd9Sstevel@tonic-gate if (strcmp(cmd->cmd_argv[0], "usage") == 0) { 6779bbec428eSgjelinek usage(B_TRUE, HELP_USAGE); 67807c478bd9Sstevel@tonic-gate return; 67817c478bd9Sstevel@tonic-gate } 67827c478bd9Sstevel@tonic-gate if (strcmp(cmd->cmd_argv[0], "commands") == 0) { 6783bbec428eSgjelinek usage(B_TRUE, HELP_SUBCMDS); 67847c478bd9Sstevel@tonic-gate return; 67857c478bd9Sstevel@tonic-gate } 67867c478bd9Sstevel@tonic-gate if (strcmp(cmd->cmd_argv[0], "syntax") == 0) { 6787bbec428eSgjelinek usage(B_TRUE, HELP_SYNTAX | HELP_RES_PROPS); 67887c478bd9Sstevel@tonic-gate return; 67897c478bd9Sstevel@tonic-gate } 67907c478bd9Sstevel@tonic-gate if (strcmp(cmd->cmd_argv[0], "-?") == 0) { 67917c478bd9Sstevel@tonic-gate longer_usage(CMD_HELP); 67927c478bd9Sstevel@tonic-gate return; 67937c478bd9Sstevel@tonic-gate } 67947c478bd9Sstevel@tonic-gate 67957c478bd9Sstevel@tonic-gate for (i = 0; i <= CMD_MAX; i++) { 67967c478bd9Sstevel@tonic-gate if (strcmp(cmd->cmd_argv[0], cmd_to_str(i)) == 0) { 67977c478bd9Sstevel@tonic-gate longer_usage(i); 67987c478bd9Sstevel@tonic-gate return; 67997c478bd9Sstevel@tonic-gate } 68007c478bd9Sstevel@tonic-gate } 68017c478bd9Sstevel@tonic-gate /* We do not use zerr() here because we do not want its extra \n. */ 68027c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("Unknown help subject %s. "), 68037c478bd9Sstevel@tonic-gate cmd->cmd_argv[0]); 6804bbec428eSgjelinek usage(B_FALSE, HELP_META); 68057c478bd9Sstevel@tonic-gate } 68067c478bd9Sstevel@tonic-gate 68077c478bd9Sstevel@tonic-gate static int 68087c478bd9Sstevel@tonic-gate string_to_yyin(char *string) 68097c478bd9Sstevel@tonic-gate { 68107c478bd9Sstevel@tonic-gate if ((yyin = tmpfile()) == NULL) { 6811bbec428eSgjelinek zone_perror(execname, Z_TEMP_FILE, B_TRUE); 68127c478bd9Sstevel@tonic-gate return (Z_ERR); 68137c478bd9Sstevel@tonic-gate } 68147c478bd9Sstevel@tonic-gate if (fwrite(string, strlen(string), 1, yyin) != 1) { 6815bbec428eSgjelinek zone_perror(execname, Z_TEMP_FILE, B_TRUE); 68167c478bd9Sstevel@tonic-gate return (Z_ERR); 68177c478bd9Sstevel@tonic-gate } 68187c478bd9Sstevel@tonic-gate if (fseek(yyin, 0, SEEK_SET) != 0) { 6819bbec428eSgjelinek zone_perror(execname, Z_TEMP_FILE, B_TRUE); 68207c478bd9Sstevel@tonic-gate return (Z_ERR); 68217c478bd9Sstevel@tonic-gate } 68227c478bd9Sstevel@tonic-gate return (Z_OK); 68237c478bd9Sstevel@tonic-gate } 68247c478bd9Sstevel@tonic-gate 68257c478bd9Sstevel@tonic-gate /* This is the back-end helper function for read_input() below. */ 68267c478bd9Sstevel@tonic-gate 68277c478bd9Sstevel@tonic-gate static int 68287c478bd9Sstevel@tonic-gate cleanup() 68297c478bd9Sstevel@tonic-gate { 68307c478bd9Sstevel@tonic-gate int answer; 68317c478bd9Sstevel@tonic-gate cmd_t *cmd; 68327c478bd9Sstevel@tonic-gate 68337c478bd9Sstevel@tonic-gate if (!interactive_mode && !cmd_file_mode) { 68347c478bd9Sstevel@tonic-gate /* 68357c478bd9Sstevel@tonic-gate * If we're not in interactive mode, and we're not in command 68367c478bd9Sstevel@tonic-gate * file mode, then we must be in commands-from-the-command-line 68377c478bd9Sstevel@tonic-gate * mode. As such, we can't loop back and ask for more input. 68387c478bd9Sstevel@tonic-gate * It was OK to prompt for such things as whether or not to 68397c478bd9Sstevel@tonic-gate * really delete a zone in the command handler called from 68407c478bd9Sstevel@tonic-gate * yyparse() above, but "really quit?" makes no sense in this 68417c478bd9Sstevel@tonic-gate * context. So disable prompting. 68427c478bd9Sstevel@tonic-gate */ 6843bbec428eSgjelinek ok_to_prompt = B_FALSE; 68447c478bd9Sstevel@tonic-gate } 68457c478bd9Sstevel@tonic-gate if (!global_scope) { 68467c478bd9Sstevel@tonic-gate if (!time_to_exit) { 68477c478bd9Sstevel@tonic-gate /* 68487c478bd9Sstevel@tonic-gate * Just print a simple error message in the -1 case, 68497c478bd9Sstevel@tonic-gate * since exit_func() already handles that case, and 68507c478bd9Sstevel@tonic-gate * EOF means we are finished anyway. 68517c478bd9Sstevel@tonic-gate */ 6852bbec428eSgjelinek answer = ask_yesno(B_FALSE, 68537c478bd9Sstevel@tonic-gate gettext("Resource incomplete; really quit")); 68547c478bd9Sstevel@tonic-gate if (answer == -1) { 68557c478bd9Sstevel@tonic-gate zerr(gettext("Resource incomplete.")); 68567c478bd9Sstevel@tonic-gate return (Z_ERR); 68577c478bd9Sstevel@tonic-gate } 68587c478bd9Sstevel@tonic-gate if (answer != 1) { 68597c478bd9Sstevel@tonic-gate yyin = stdin; 68607c478bd9Sstevel@tonic-gate return (Z_REPEAT); 68617c478bd9Sstevel@tonic-gate } 68627c478bd9Sstevel@tonic-gate } else { 6863bbec428eSgjelinek saw_error = B_TRUE; 68647c478bd9Sstevel@tonic-gate } 68657c478bd9Sstevel@tonic-gate } 68667c478bd9Sstevel@tonic-gate /* 68677c478bd9Sstevel@tonic-gate * Make sure we tried something and that the handle checks 68687c478bd9Sstevel@tonic-gate * out, or we would get a false error trying to commit. 68697c478bd9Sstevel@tonic-gate */ 68707c478bd9Sstevel@tonic-gate if (need_to_commit && zonecfg_check_handle(handle) == Z_OK) { 68717c478bd9Sstevel@tonic-gate if ((cmd = alloc_cmd()) == NULL) { 6872bbec428eSgjelinek zone_perror(zone, Z_NOMEM, B_TRUE); 68737c478bd9Sstevel@tonic-gate return (Z_ERR); 68747c478bd9Sstevel@tonic-gate } 68757c478bd9Sstevel@tonic-gate cmd->cmd_argc = 0; 68767c478bd9Sstevel@tonic-gate cmd->cmd_argv[0] = NULL; 68777c478bd9Sstevel@tonic-gate commit_func(cmd); 68787c478bd9Sstevel@tonic-gate free_cmd(cmd); 68797c478bd9Sstevel@tonic-gate /* 68807c478bd9Sstevel@tonic-gate * need_to_commit will get set back to FALSE if the 68817c478bd9Sstevel@tonic-gate * configuration is saved successfully. 68827c478bd9Sstevel@tonic-gate */ 68837c478bd9Sstevel@tonic-gate if (need_to_commit) { 68847c478bd9Sstevel@tonic-gate if (force_exit) { 68857c478bd9Sstevel@tonic-gate zerr(gettext("Configuration not saved.")); 68867c478bd9Sstevel@tonic-gate return (Z_ERR); 68877c478bd9Sstevel@tonic-gate } 6888bbec428eSgjelinek answer = ask_yesno(B_FALSE, 68897c478bd9Sstevel@tonic-gate gettext("Configuration not saved; really quit")); 68907c478bd9Sstevel@tonic-gate if (answer == -1) { 68917c478bd9Sstevel@tonic-gate zerr(gettext("Configuration not saved.")); 68927c478bd9Sstevel@tonic-gate return (Z_ERR); 68937c478bd9Sstevel@tonic-gate } 68947c478bd9Sstevel@tonic-gate if (answer != 1) { 6895bbec428eSgjelinek time_to_exit = B_FALSE; 68967c478bd9Sstevel@tonic-gate yyin = stdin; 68977c478bd9Sstevel@tonic-gate return (Z_REPEAT); 68987c478bd9Sstevel@tonic-gate } 68997c478bd9Sstevel@tonic-gate } 69007c478bd9Sstevel@tonic-gate } 69017c478bd9Sstevel@tonic-gate return ((need_to_commit || saw_error) ? Z_ERR : Z_OK); 69027c478bd9Sstevel@tonic-gate } 69037c478bd9Sstevel@tonic-gate 69047c478bd9Sstevel@tonic-gate /* 69057c478bd9Sstevel@tonic-gate * read_input() is the driver of this program. It is a wrapper around 69067c478bd9Sstevel@tonic-gate * yyparse(), printing appropriate prompts when needed, checking for 69077c478bd9Sstevel@tonic-gate * exit conditions and reacting appropriately [the latter in its cleanup() 69087c478bd9Sstevel@tonic-gate * helper function]. 69097c478bd9Sstevel@tonic-gate * 69107c478bd9Sstevel@tonic-gate * Like most zonecfg functions, it returns Z_OK or Z_ERR, *or* Z_REPEAT 69117c478bd9Sstevel@tonic-gate * so do_interactive() knows that we are not really done (i.e, we asked 69127c478bd9Sstevel@tonic-gate * the user if we should really quit and the user said no). 69137c478bd9Sstevel@tonic-gate */ 69147c478bd9Sstevel@tonic-gate static int 69157c478bd9Sstevel@tonic-gate read_input() 69167c478bd9Sstevel@tonic-gate { 6917bbec428eSgjelinek boolean_t yyin_is_a_tty = isatty(fileno(yyin)); 69187c478bd9Sstevel@tonic-gate /* 69197c478bd9Sstevel@tonic-gate * The prompt is "e:z> " or "e:z:r> " where e is execname, z is zone 69207c478bd9Sstevel@tonic-gate * and r is resource_scope: 5 is for the two ":"s + "> " + terminator. 69217c478bd9Sstevel@tonic-gate */ 69227c478bd9Sstevel@tonic-gate char prompt[MAXPATHLEN + ZONENAME_MAX + MAX_RT_STRLEN + 5], *line; 69237c478bd9Sstevel@tonic-gate 69247c478bd9Sstevel@tonic-gate /* yyin should have been set to the appropriate (FILE *) if not stdin */ 6925bbec428eSgjelinek newline_terminated = B_TRUE; 69267c478bd9Sstevel@tonic-gate for (;;) { 69277c478bd9Sstevel@tonic-gate if (yyin_is_a_tty) { 69287c478bd9Sstevel@tonic-gate if (newline_terminated) { 69297c478bd9Sstevel@tonic-gate if (global_scope) 69307c478bd9Sstevel@tonic-gate (void) snprintf(prompt, sizeof (prompt), 69317c478bd9Sstevel@tonic-gate "%s:%s> ", execname, zone); 69327c478bd9Sstevel@tonic-gate else 69337c478bd9Sstevel@tonic-gate (void) snprintf(prompt, sizeof (prompt), 69347c478bd9Sstevel@tonic-gate "%s:%s:%s> ", execname, zone, 69357c478bd9Sstevel@tonic-gate rt_to_str(resource_scope)); 69367c478bd9Sstevel@tonic-gate } 69377c478bd9Sstevel@tonic-gate /* 69387c478bd9Sstevel@tonic-gate * If the user hits ^C then we want to catch it and 69397c478bd9Sstevel@tonic-gate * start over. If the user hits EOF then we want to 69407c478bd9Sstevel@tonic-gate * bail out. 69417c478bd9Sstevel@tonic-gate */ 69427c478bd9Sstevel@tonic-gate line = gl_get_line(gl, prompt, NULL, -1); 69437c478bd9Sstevel@tonic-gate if (gl_return_status(gl) == GLR_SIGNAL) { 69447c478bd9Sstevel@tonic-gate gl_abandon_line(gl); 69457c478bd9Sstevel@tonic-gate continue; 69467c478bd9Sstevel@tonic-gate } 69477c478bd9Sstevel@tonic-gate if (line == NULL) 69487c478bd9Sstevel@tonic-gate break; 69497c478bd9Sstevel@tonic-gate (void) string_to_yyin(line); 69507c478bd9Sstevel@tonic-gate while (!feof(yyin)) 69517c478bd9Sstevel@tonic-gate yyparse(); 69527c478bd9Sstevel@tonic-gate } else { 69537c478bd9Sstevel@tonic-gate yyparse(); 69547c478bd9Sstevel@tonic-gate } 69557c478bd9Sstevel@tonic-gate /* Bail out on an error in command file mode. */ 69567c478bd9Sstevel@tonic-gate if (saw_error && cmd_file_mode && !interactive_mode) 6957bbec428eSgjelinek time_to_exit = B_TRUE; 69587c478bd9Sstevel@tonic-gate if (time_to_exit || (!yyin_is_a_tty && feof(yyin))) 69597c478bd9Sstevel@tonic-gate break; 69607c478bd9Sstevel@tonic-gate } 69617c478bd9Sstevel@tonic-gate return (cleanup()); 69627c478bd9Sstevel@tonic-gate } 69637c478bd9Sstevel@tonic-gate 69647c478bd9Sstevel@tonic-gate /* 69657c478bd9Sstevel@tonic-gate * This function is used in the zonecfg-interactive-mode scenario: it just 69667c478bd9Sstevel@tonic-gate * calls read_input() until we are done. 69677c478bd9Sstevel@tonic-gate */ 69687c478bd9Sstevel@tonic-gate 69697c478bd9Sstevel@tonic-gate static int 69707c478bd9Sstevel@tonic-gate do_interactive(void) 69717c478bd9Sstevel@tonic-gate { 69727c478bd9Sstevel@tonic-gate int err; 69737c478bd9Sstevel@tonic-gate 6974bbec428eSgjelinek interactive_mode = B_TRUE; 69757c478bd9Sstevel@tonic-gate if (!read_only_mode) { 69767c478bd9Sstevel@tonic-gate /* 69777c478bd9Sstevel@tonic-gate * Try to set things up proactively in interactive mode, so 69787c478bd9Sstevel@tonic-gate * that if the zone in question does not exist yet, we can 69797c478bd9Sstevel@tonic-gate * provide the user with a clue. 69807c478bd9Sstevel@tonic-gate */ 6981bbec428eSgjelinek (void) initialize(B_FALSE); 69827c478bd9Sstevel@tonic-gate } 6983087719fdSdp do { 69847c478bd9Sstevel@tonic-gate err = read_input(); 6985087719fdSdp } while (err == Z_REPEAT); 69867c478bd9Sstevel@tonic-gate return (err); 69877c478bd9Sstevel@tonic-gate } 69887c478bd9Sstevel@tonic-gate 69897c478bd9Sstevel@tonic-gate /* 69907c478bd9Sstevel@tonic-gate * cmd_file is slightly more complicated, as it has to open the command file 69917c478bd9Sstevel@tonic-gate * and set yyin appropriately. Once that is done, though, it just calls 69927c478bd9Sstevel@tonic-gate * read_input(), and only once, since prompting is not possible. 69937c478bd9Sstevel@tonic-gate */ 69947c478bd9Sstevel@tonic-gate 69957c478bd9Sstevel@tonic-gate static int 69967c478bd9Sstevel@tonic-gate cmd_file(char *file) 69977c478bd9Sstevel@tonic-gate { 69987c478bd9Sstevel@tonic-gate FILE *infile; 69997c478bd9Sstevel@tonic-gate int err; 70007c478bd9Sstevel@tonic-gate struct stat statbuf; 7001bbec428eSgjelinek boolean_t using_real_file = (strcmp(file, "-") != 0); 70027c478bd9Sstevel@tonic-gate 70037c478bd9Sstevel@tonic-gate if (using_real_file) { 70047c478bd9Sstevel@tonic-gate /* 70057c478bd9Sstevel@tonic-gate * zerr() prints a line number in cmd_file_mode, which we do 70067c478bd9Sstevel@tonic-gate * not want here, so temporarily unset it. 70077c478bd9Sstevel@tonic-gate */ 7008bbec428eSgjelinek cmd_file_mode = B_FALSE; 70097c478bd9Sstevel@tonic-gate if ((infile = fopen(file, "r")) == NULL) { 70107c478bd9Sstevel@tonic-gate zerr(gettext("could not open file %s: %s"), 70117c478bd9Sstevel@tonic-gate file, strerror(errno)); 70127c478bd9Sstevel@tonic-gate return (Z_ERR); 70137c478bd9Sstevel@tonic-gate } 70147c478bd9Sstevel@tonic-gate if ((err = fstat(fileno(infile), &statbuf)) != 0) { 70157c478bd9Sstevel@tonic-gate zerr(gettext("could not stat file %s: %s"), 70167c478bd9Sstevel@tonic-gate file, strerror(errno)); 70177c478bd9Sstevel@tonic-gate err = Z_ERR; 70187c478bd9Sstevel@tonic-gate goto done; 70197c478bd9Sstevel@tonic-gate } 70207c478bd9Sstevel@tonic-gate if (!S_ISREG(statbuf.st_mode)) { 70217c478bd9Sstevel@tonic-gate zerr(gettext("%s is not a regular file."), file); 70227c478bd9Sstevel@tonic-gate err = Z_ERR; 70237c478bd9Sstevel@tonic-gate goto done; 70247c478bd9Sstevel@tonic-gate } 70257c478bd9Sstevel@tonic-gate yyin = infile; 7026bbec428eSgjelinek cmd_file_mode = B_TRUE; 7027bbec428eSgjelinek ok_to_prompt = B_FALSE; 70287c478bd9Sstevel@tonic-gate } else { 70297c478bd9Sstevel@tonic-gate /* 70307c478bd9Sstevel@tonic-gate * "-f -" is essentially the same as interactive mode, 70317c478bd9Sstevel@tonic-gate * so treat it that way. 70327c478bd9Sstevel@tonic-gate */ 7033bbec428eSgjelinek interactive_mode = B_TRUE; 70347c478bd9Sstevel@tonic-gate } 70357c478bd9Sstevel@tonic-gate /* Z_REPEAT is for interactive mode; treat it like Z_ERR here. */ 70367c478bd9Sstevel@tonic-gate if ((err = read_input()) == Z_REPEAT) 70377c478bd9Sstevel@tonic-gate err = Z_ERR; 70387c478bd9Sstevel@tonic-gate done: 70397c478bd9Sstevel@tonic-gate if (using_real_file) 70407c478bd9Sstevel@tonic-gate (void) fclose(infile); 70417c478bd9Sstevel@tonic-gate return (err); 70427c478bd9Sstevel@tonic-gate } 70437c478bd9Sstevel@tonic-gate 70447c478bd9Sstevel@tonic-gate /* 70457c478bd9Sstevel@tonic-gate * Since yacc is based on reading from a (FILE *) whereas what we get from 70467c478bd9Sstevel@tonic-gate * the command line is in argv format, we need to convert when the user 70477c478bd9Sstevel@tonic-gate * gives us commands directly from the command line. That is done here by 70487c478bd9Sstevel@tonic-gate * concatenating the argv list into a space-separated string, writing it 70497c478bd9Sstevel@tonic-gate * to a temp file, and rewinding the file so yyin can be set to it. Then 70507c478bd9Sstevel@tonic-gate * we call read_input(), and only once, since prompting about whether to 70517c478bd9Sstevel@tonic-gate * continue or quit would make no sense in this context. 70527c478bd9Sstevel@tonic-gate */ 70537c478bd9Sstevel@tonic-gate 70547c478bd9Sstevel@tonic-gate static int 70557c478bd9Sstevel@tonic-gate one_command_at_a_time(int argc, char *argv[]) 70567c478bd9Sstevel@tonic-gate { 70577c478bd9Sstevel@tonic-gate char *command; 70587c478bd9Sstevel@tonic-gate size_t len = 2; /* terminal \n\0 */ 70597c478bd9Sstevel@tonic-gate int i, err; 70607c478bd9Sstevel@tonic-gate 70617c478bd9Sstevel@tonic-gate for (i = 0; i < argc; i++) 70627c478bd9Sstevel@tonic-gate len += strlen(argv[i]) + 1; 70637c478bd9Sstevel@tonic-gate if ((command = malloc(len)) == NULL) { 7064bbec428eSgjelinek zone_perror(execname, Z_NOMEM, B_TRUE); 70657c478bd9Sstevel@tonic-gate return (Z_ERR); 70667c478bd9Sstevel@tonic-gate } 70677c478bd9Sstevel@tonic-gate (void) strlcpy(command, argv[0], len); 70687c478bd9Sstevel@tonic-gate for (i = 1; i < argc; i++) { 70697c478bd9Sstevel@tonic-gate (void) strlcat(command, " ", len); 70707c478bd9Sstevel@tonic-gate (void) strlcat(command, argv[i], len); 70717c478bd9Sstevel@tonic-gate } 70727c478bd9Sstevel@tonic-gate (void) strlcat(command, "\n", len); 70737c478bd9Sstevel@tonic-gate err = string_to_yyin(command); 70747c478bd9Sstevel@tonic-gate free(command); 70757c478bd9Sstevel@tonic-gate if (err != Z_OK) 70767c478bd9Sstevel@tonic-gate return (err); 70777c478bd9Sstevel@tonic-gate while (!feof(yyin)) 70787c478bd9Sstevel@tonic-gate yyparse(); 70797c478bd9Sstevel@tonic-gate return (cleanup()); 70807c478bd9Sstevel@tonic-gate } 70817c478bd9Sstevel@tonic-gate 70827c478bd9Sstevel@tonic-gate static char * 70837c478bd9Sstevel@tonic-gate get_execbasename(char *execfullname) 70847c478bd9Sstevel@tonic-gate { 70857c478bd9Sstevel@tonic-gate char *last_slash, *execbasename; 70867c478bd9Sstevel@tonic-gate 70877c478bd9Sstevel@tonic-gate /* guard against '/' at end of command invocation */ 70887c478bd9Sstevel@tonic-gate for (;;) { 70897c478bd9Sstevel@tonic-gate last_slash = strrchr(execfullname, '/'); 70907c478bd9Sstevel@tonic-gate if (last_slash == NULL) { 70917c478bd9Sstevel@tonic-gate execbasename = execfullname; 70927c478bd9Sstevel@tonic-gate break; 70937c478bd9Sstevel@tonic-gate } else { 70947c478bd9Sstevel@tonic-gate execbasename = last_slash + 1; 70957c478bd9Sstevel@tonic-gate if (*execbasename == '\0') { 70967c478bd9Sstevel@tonic-gate *last_slash = '\0'; 70977c478bd9Sstevel@tonic-gate continue; 70987c478bd9Sstevel@tonic-gate } 70997c478bd9Sstevel@tonic-gate break; 71007c478bd9Sstevel@tonic-gate } 71017c478bd9Sstevel@tonic-gate } 71027c478bd9Sstevel@tonic-gate return (execbasename); 71037c478bd9Sstevel@tonic-gate } 71047c478bd9Sstevel@tonic-gate 71057c478bd9Sstevel@tonic-gate int 71067c478bd9Sstevel@tonic-gate main(int argc, char *argv[]) 71077c478bd9Sstevel@tonic-gate { 71087c478bd9Sstevel@tonic-gate int err, arg; 7109555afedfScarlsonj struct stat st; 71107c478bd9Sstevel@tonic-gate 71117c478bd9Sstevel@tonic-gate /* This must be before anything goes to stdout. */ 71127c478bd9Sstevel@tonic-gate setbuf(stdout, NULL); 71137c478bd9Sstevel@tonic-gate 7114bbec428eSgjelinek saw_error = B_FALSE; 7115bbec428eSgjelinek cmd_file_mode = B_FALSE; 71167c478bd9Sstevel@tonic-gate execname = get_execbasename(argv[0]); 71177c478bd9Sstevel@tonic-gate 71187c478bd9Sstevel@tonic-gate (void) setlocale(LC_ALL, ""); 71197c478bd9Sstevel@tonic-gate (void) textdomain(TEXT_DOMAIN); 71207c478bd9Sstevel@tonic-gate 71217c478bd9Sstevel@tonic-gate if (getzoneid() != GLOBAL_ZONEID) { 71227c478bd9Sstevel@tonic-gate zerr(gettext("%s can only be run from the global zone."), 71237c478bd9Sstevel@tonic-gate execname); 71247c478bd9Sstevel@tonic-gate exit(Z_ERR); 71257c478bd9Sstevel@tonic-gate } 71267c478bd9Sstevel@tonic-gate 71277c478bd9Sstevel@tonic-gate if (argc < 2) { 7128bbec428eSgjelinek usage(B_FALSE, HELP_USAGE | HELP_SUBCMDS); 71297c478bd9Sstevel@tonic-gate exit(Z_USAGE); 71307c478bd9Sstevel@tonic-gate } 71317c478bd9Sstevel@tonic-gate if (strcmp(argv[1], cmd_to_str(CMD_HELP)) == 0) { 71327c478bd9Sstevel@tonic-gate (void) one_command_at_a_time(argc - 1, &(argv[1])); 71337c478bd9Sstevel@tonic-gate exit(Z_OK); 71347c478bd9Sstevel@tonic-gate } 71357c478bd9Sstevel@tonic-gate 7136555afedfScarlsonj while ((arg = getopt(argc, argv, "?f:R:z:")) != EOF) { 71377c478bd9Sstevel@tonic-gate switch (arg) { 71387c478bd9Sstevel@tonic-gate case '?': 71397c478bd9Sstevel@tonic-gate if (optopt == '?') 7140bbec428eSgjelinek usage(B_TRUE, HELP_USAGE | HELP_SUBCMDS); 71417c478bd9Sstevel@tonic-gate else 7142bbec428eSgjelinek usage(B_FALSE, HELP_USAGE); 71437c478bd9Sstevel@tonic-gate exit(Z_USAGE); 71447c478bd9Sstevel@tonic-gate /* NOTREACHED */ 71457c478bd9Sstevel@tonic-gate case 'f': 71467c478bd9Sstevel@tonic-gate cmd_file_name = optarg; 7147bbec428eSgjelinek cmd_file_mode = B_TRUE; 71487c478bd9Sstevel@tonic-gate break; 7149555afedfScarlsonj case 'R': 7150555afedfScarlsonj if (*optarg != '/') { 7151555afedfScarlsonj zerr(gettext("root path must be absolute: %s"), 7152555afedfScarlsonj optarg); 7153555afedfScarlsonj exit(Z_USAGE); 7154555afedfScarlsonj } 7155555afedfScarlsonj if (stat(optarg, &st) == -1 || !S_ISDIR(st.st_mode)) { 7156555afedfScarlsonj zerr(gettext( 7157555afedfScarlsonj "root path must be a directory: %s"), 7158555afedfScarlsonj optarg); 7159555afedfScarlsonj exit(Z_USAGE); 7160555afedfScarlsonj } 7161555afedfScarlsonj zonecfg_set_root(optarg); 7162555afedfScarlsonj break; 71637c478bd9Sstevel@tonic-gate case 'z': 71640209230bSgjelinek if (strcmp(optarg, GLOBAL_ZONENAME) == 0) { 7165bbec428eSgjelinek global_zone = B_TRUE; 71660209230bSgjelinek } else if (zonecfg_validate_zonename(optarg) != Z_OK) { 7167bbec428eSgjelinek zone_perror(optarg, Z_BOGUS_ZONE_NAME, B_TRUE); 7168bbec428eSgjelinek usage(B_FALSE, HELP_SYNTAX); 7169087719fdSdp exit(Z_USAGE); 7170087719fdSdp } 7171087719fdSdp (void) strlcpy(zone, optarg, sizeof (zone)); 7172087719fdSdp (void) strlcpy(revert_zone, optarg, sizeof (zone)); 71737c478bd9Sstevel@tonic-gate break; 71747c478bd9Sstevel@tonic-gate default: 7175bbec428eSgjelinek usage(B_FALSE, HELP_USAGE); 71767c478bd9Sstevel@tonic-gate exit(Z_USAGE); 71777c478bd9Sstevel@tonic-gate } 71787c478bd9Sstevel@tonic-gate } 71797c478bd9Sstevel@tonic-gate 7180087719fdSdp if (optind > argc || strcmp(zone, "") == 0) { 7181bbec428eSgjelinek usage(B_FALSE, HELP_USAGE); 71827c478bd9Sstevel@tonic-gate exit(Z_USAGE); 71837c478bd9Sstevel@tonic-gate } 71847c478bd9Sstevel@tonic-gate 7185087719fdSdp if ((err = zonecfg_access(zone, W_OK)) == Z_OK) { 7186bbec428eSgjelinek read_only_mode = B_FALSE; 7187087719fdSdp } else if (err == Z_ACCES) { 7188bbec428eSgjelinek read_only_mode = B_TRUE; 71897c478bd9Sstevel@tonic-gate /* skip this message in one-off from command line mode */ 71907c478bd9Sstevel@tonic-gate if (optind == argc) 71917c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("WARNING: you do not " 71927c478bd9Sstevel@tonic-gate "have write access to this zone's configuration " 71937c478bd9Sstevel@tonic-gate "file;\ngoing into read-only mode.\n")); 7194087719fdSdp } else { 7195087719fdSdp fprintf(stderr, "%s: Could not access zone configuration " 7196087719fdSdp "store: %s\n", execname, zonecfg_strerror(err)); 7197087719fdSdp exit(Z_ERR); 71987c478bd9Sstevel@tonic-gate } 71997c478bd9Sstevel@tonic-gate 72007c478bd9Sstevel@tonic-gate if ((handle = zonecfg_init_handle()) == NULL) { 7201bbec428eSgjelinek zone_perror(execname, Z_NOMEM, B_TRUE); 72027c478bd9Sstevel@tonic-gate exit(Z_ERR); 72037c478bd9Sstevel@tonic-gate } 72047c478bd9Sstevel@tonic-gate 72057c478bd9Sstevel@tonic-gate /* 72067c478bd9Sstevel@tonic-gate * This may get set back to FALSE again in cmd_file() if cmd_file_name 72077c478bd9Sstevel@tonic-gate * is a "real" file as opposed to "-" (i.e. meaning use stdin). 72087c478bd9Sstevel@tonic-gate */ 72097c478bd9Sstevel@tonic-gate if (isatty(STDIN_FILENO)) 7210bbec428eSgjelinek ok_to_prompt = B_TRUE; 72117c478bd9Sstevel@tonic-gate if ((gl = new_GetLine(MAX_LINE_LEN, MAX_CMD_HIST)) == NULL) 72127c478bd9Sstevel@tonic-gate exit(Z_ERR); 72137c478bd9Sstevel@tonic-gate if (gl_customize_completion(gl, NULL, cmd_cpl_fn) != 0) 72147c478bd9Sstevel@tonic-gate exit(Z_ERR); 72157c478bd9Sstevel@tonic-gate (void) sigset(SIGINT, SIG_IGN); 72167c478bd9Sstevel@tonic-gate if (optind == argc) { 72177c478bd9Sstevel@tonic-gate if (!cmd_file_mode) 72187c478bd9Sstevel@tonic-gate err = do_interactive(); 72197c478bd9Sstevel@tonic-gate else 72207c478bd9Sstevel@tonic-gate err = cmd_file(cmd_file_name); 72217c478bd9Sstevel@tonic-gate } else { 72227c478bd9Sstevel@tonic-gate err = one_command_at_a_time(argc - optind, &(argv[optind])); 72237c478bd9Sstevel@tonic-gate } 72247c478bd9Sstevel@tonic-gate zonecfg_fini_handle(handle); 72259acbbeafSnn35248 if (brand != NULL) 72269acbbeafSnn35248 brand_close(brand); 72277c478bd9Sstevel@tonic-gate (void) del_GetLine(gl); 72287c478bd9Sstevel@tonic-gate return (err); 72297c478bd9Sstevel@tonic-gate } 7230