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 /* 23*de860bd9Sgfaden * Copyright 2008 Sun Microsystems, Inc. All rights reserved. 247c478bd9Sstevel@tonic-gate * Use is subject to license terms. 257c478bd9Sstevel@tonic-gate */ 267c478bd9Sstevel@tonic-gate 277c478bd9Sstevel@tonic-gate #pragma ident "%Z%%M% %I% %E% SMI" 287c478bd9Sstevel@tonic-gate 297c478bd9Sstevel@tonic-gate /* 307c478bd9Sstevel@tonic-gate * zonecfg is a lex/yacc based command interpreter used to manage zone 317c478bd9Sstevel@tonic-gate * configurations. The lexer (see zonecfg_lex.l) builds up tokens, which 327c478bd9Sstevel@tonic-gate * the grammar (see zonecfg_grammar.y) builds up into commands, some of 337c478bd9Sstevel@tonic-gate * which takes resources and/or properties as arguments. See the block 347c478bd9Sstevel@tonic-gate * comments near the end of zonecfg_grammar.y for how the data structures 357c478bd9Sstevel@tonic-gate * which keep track of these resources and properties are built up. 367c478bd9Sstevel@tonic-gate * 377c478bd9Sstevel@tonic-gate * The resource/property data structures are inserted into a command 387c478bd9Sstevel@tonic-gate * structure (see zonecfg.h), which also keeps track of command names, 397c478bd9Sstevel@tonic-gate * miscellaneous arguments, and function handlers. The grammar selects 407c478bd9Sstevel@tonic-gate * the appropriate function handler, each of which takes a pointer to a 417c478bd9Sstevel@tonic-gate * command structure as its sole argument, and invokes it. The grammar 427c478bd9Sstevel@tonic-gate * itself is "entered" (a la the Matrix) by yyparse(), which is called 437c478bd9Sstevel@tonic-gate * from read_input(), our main driving function. That in turn is called 447c478bd9Sstevel@tonic-gate * by one of do_interactive(), cmd_file() or one_command_at_a_time(), each 457c478bd9Sstevel@tonic-gate * of which is called from main() depending on how the program was invoked. 467c478bd9Sstevel@tonic-gate * 477c478bd9Sstevel@tonic-gate * The rest of this module consists of the various function handlers and 487c478bd9Sstevel@tonic-gate * their helper functions. Some of these functions, particularly the 497c478bd9Sstevel@tonic-gate * X_to_str() functions, which maps command, resource and property numbers 507c478bd9Sstevel@tonic-gate * to strings, are used quite liberally, as doing so results in a better 517c478bd9Sstevel@tonic-gate * program w/rt I18N, reducing the need for translation notes. 527c478bd9Sstevel@tonic-gate */ 537c478bd9Sstevel@tonic-gate 547c478bd9Sstevel@tonic-gate #include <sys/mntent.h> 557c478bd9Sstevel@tonic-gate #include <sys/varargs.h> 567c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h> 577c478bd9Sstevel@tonic-gate 587c478bd9Sstevel@tonic-gate #include <errno.h> 599acbbeafSnn #include <fcntl.h> 607c478bd9Sstevel@tonic-gate #include <strings.h> 617c478bd9Sstevel@tonic-gate #include <unistd.h> 627c478bd9Sstevel@tonic-gate #include <ctype.h> 637c478bd9Sstevel@tonic-gate #include <stdlib.h> 647c478bd9Sstevel@tonic-gate #include <assert.h> 657c478bd9Sstevel@tonic-gate #include <sys/stat.h> 667c478bd9Sstevel@tonic-gate #include <zone.h> 677c478bd9Sstevel@tonic-gate #include <arpa/inet.h> 687c478bd9Sstevel@tonic-gate #include <netdb.h> 697c478bd9Sstevel@tonic-gate #include <locale.h> 707c478bd9Sstevel@tonic-gate #include <libintl.h> 717c478bd9Sstevel@tonic-gate #include <alloca.h> 727c478bd9Sstevel@tonic-gate #include <signal.h> 739acbbeafSnn #include <wait.h> 747c478bd9Sstevel@tonic-gate #include <libtecla.h> 75fa9e4066Sahrens #include <libzfs.h> 769acbbeafSnn #include <sys/brand.h> 779acbbeafSnn #include <libbrand.h> 787c478bd9Sstevel@tonic-gate 797c478bd9Sstevel@tonic-gate #include <libzonecfg.h> 807c478bd9Sstevel@tonic-gate #include "zonecfg.h" 817c478bd9Sstevel@tonic-gate 827c478bd9Sstevel@tonic-gate #if !defined(TEXT_DOMAIN) /* should be defined by cc -D */ 837c478bd9Sstevel@tonic-gate #define TEXT_DOMAIN "SYS_TEST" /* Use this only if it wasn't */ 847c478bd9Sstevel@tonic-gate #endif 857c478bd9Sstevel@tonic-gate 867c478bd9Sstevel@tonic-gate #define PAGER "/usr/bin/more" 879acbbeafSnn #define EXEC_PREFIX "exec " 889acbbeafSnn #define EXEC_LEN (strlen(EXEC_PREFIX)) 897c478bd9Sstevel@tonic-gate 907c478bd9Sstevel@tonic-gate struct help { 917c478bd9Sstevel@tonic-gate uint_t cmd_num; 927c478bd9Sstevel@tonic-gate char *cmd_name; 937c478bd9Sstevel@tonic-gate uint_t flags; 947c478bd9Sstevel@tonic-gate char *short_usage; 957c478bd9Sstevel@tonic-gate }; 967c478bd9Sstevel@tonic-gate 977c478bd9Sstevel@tonic-gate extern int yyparse(void); 987c478bd9Sstevel@tonic-gate extern int lex_lineno; 997c478bd9Sstevel@tonic-gate 1007c478bd9Sstevel@tonic-gate #define MAX_LINE_LEN 1024 1017c478bd9Sstevel@tonic-gate #define MAX_CMD_HIST 1024 1029acbbeafSnn #define MAX_CMD_LEN 1024 1037c478bd9Sstevel@tonic-gate 1040209230bSgjelinek #define ONE_MB 1048576 1050209230bSgjelinek 1067c478bd9Sstevel@tonic-gate /* 1077c478bd9Sstevel@tonic-gate * Each SHELP_ should be a simple string. 1087c478bd9Sstevel@tonic-gate */ 1097c478bd9Sstevel@tonic-gate 1107c478bd9Sstevel@tonic-gate #define SHELP_ADD "add <resource-type>\n\t(global scope)\n" \ 1117c478bd9Sstevel@tonic-gate "add <property-name> <property-value>\n\t(resource scope)" 1127c478bd9Sstevel@tonic-gate #define SHELP_CANCEL "cancel" 1130209230bSgjelinek #define SHELP_CLEAR "clear <property-name>" 1147c478bd9Sstevel@tonic-gate #define SHELP_COMMIT "commit" 115ee519a1fSgjelinek #define SHELP_CREATE "create [-F] [ -a <path> | -b | -t <template> ]" 1167c478bd9Sstevel@tonic-gate #define SHELP_DELETE "delete [-F]" 1177c478bd9Sstevel@tonic-gate #define SHELP_END "end" 1187c478bd9Sstevel@tonic-gate #define SHELP_EXIT "exit [-F]" 1197c478bd9Sstevel@tonic-gate #define SHELP_EXPORT "export [-f output-file]" 1207c478bd9Sstevel@tonic-gate #define SHELP_HELP "help [commands] [syntax] [usage] [<command-name>]" 1217c478bd9Sstevel@tonic-gate #define SHELP_INFO "info [<resource-type> [property-name=property-value]*]" 1220209230bSgjelinek #define SHELP_REMOVE "remove [-F] <resource-type> " \ 1230209230bSgjelinek "[ <property-name>=<property-value> ]*\n" \ 1240209230bSgjelinek "\t(global scope)\n" \ 1250209230bSgjelinek "remove <property-name> <property-value>\n" \ 1260209230bSgjelinek "\t(resource scope)" 1277c478bd9Sstevel@tonic-gate #define SHELP_REVERT "revert [-F]" 1287c478bd9Sstevel@tonic-gate #define SHELP_SELECT "select <resource-type> { <property-name>=" \ 1297c478bd9Sstevel@tonic-gate "<property-value> }" 1307c478bd9Sstevel@tonic-gate #define SHELP_SET "set <property-name>=<property-value>" 1317c478bd9Sstevel@tonic-gate #define SHELP_VERIFY "verify" 1327c478bd9Sstevel@tonic-gate 1337c478bd9Sstevel@tonic-gate static struct help helptab[] = { 1347c478bd9Sstevel@tonic-gate { CMD_ADD, "add", HELP_RES_PROPS, SHELP_ADD, }, 1357c478bd9Sstevel@tonic-gate { CMD_CANCEL, "cancel", 0, SHELP_CANCEL, }, 1360209230bSgjelinek { CMD_CLEAR, "clear", HELP_PROPS, SHELP_CLEAR, }, 1377c478bd9Sstevel@tonic-gate { CMD_COMMIT, "commit", 0, SHELP_COMMIT, }, 1387c478bd9Sstevel@tonic-gate { CMD_CREATE, "create", 0, SHELP_CREATE, }, 1397c478bd9Sstevel@tonic-gate { CMD_DELETE, "delete", 0, SHELP_DELETE, }, 1407c478bd9Sstevel@tonic-gate { CMD_END, "end", 0, SHELP_END, }, 1417c478bd9Sstevel@tonic-gate { CMD_EXIT, "exit", 0, SHELP_EXIT, }, 1427c478bd9Sstevel@tonic-gate { CMD_EXPORT, "export", 0, SHELP_EXPORT, }, 1437c478bd9Sstevel@tonic-gate { CMD_HELP, "help", 0, SHELP_HELP }, 1447c478bd9Sstevel@tonic-gate { CMD_INFO, "info", HELP_RES_PROPS, SHELP_INFO, }, 1457c478bd9Sstevel@tonic-gate { CMD_REMOVE, "remove", HELP_RES_PROPS, SHELP_REMOVE, }, 1467c478bd9Sstevel@tonic-gate { CMD_REVERT, "revert", 0, SHELP_REVERT, }, 1477c478bd9Sstevel@tonic-gate { CMD_SELECT, "select", HELP_RES_PROPS, SHELP_SELECT, }, 1487c478bd9Sstevel@tonic-gate { CMD_SET, "set", HELP_PROPS, SHELP_SET, }, 1497c478bd9Sstevel@tonic-gate { CMD_VERIFY, "verify", 0, SHELP_VERIFY, }, 1507c478bd9Sstevel@tonic-gate { 0 }, 1517c478bd9Sstevel@tonic-gate }; 1527c478bd9Sstevel@tonic-gate 1537c478bd9Sstevel@tonic-gate #define MAX_RT_STRLEN 16 1547c478bd9Sstevel@tonic-gate 1557c478bd9Sstevel@tonic-gate /* These *must* match the order of the RT_ define's from zonecfg.h */ 1567c478bd9Sstevel@tonic-gate static char *res_types[] = { 1577c478bd9Sstevel@tonic-gate "unknown", 158087719fdSdp "zonename", 1597c478bd9Sstevel@tonic-gate "zonepath", 1607c478bd9Sstevel@tonic-gate "autoboot", 1617c478bd9Sstevel@tonic-gate "pool", 1627c478bd9Sstevel@tonic-gate "fs", 1637c478bd9Sstevel@tonic-gate "inherit-pkg-dir", 1647c478bd9Sstevel@tonic-gate "net", 1657c478bd9Sstevel@tonic-gate "device", 1667c478bd9Sstevel@tonic-gate "rctl", 1677c478bd9Sstevel@tonic-gate "attr", 168fa9e4066Sahrens "dataset", 169ffbafc53Scomay "limitpriv", 1703f2f09c1Sdp "bootargs", 1719acbbeafSnn "brand", 1720209230bSgjelinek "dedicated-cpu", 1730209230bSgjelinek "capped-memory", 1740209230bSgjelinek ALIAS_MAXLWPS, 1750209230bSgjelinek ALIAS_MAXSHMMEM, 1760209230bSgjelinek ALIAS_MAXSHMIDS, 1770209230bSgjelinek ALIAS_MAXMSGIDS, 1780209230bSgjelinek ALIAS_MAXSEMIDS, 1790209230bSgjelinek ALIAS_SHARES, 1800209230bSgjelinek "scheduling-class", 181f4b3ec61Sdh "ip-type", 182c97ad5cdSakolb "capped-cpu", 1837c478bd9Sstevel@tonic-gate NULL 1847c478bd9Sstevel@tonic-gate }; 1857c478bd9Sstevel@tonic-gate 1867c478bd9Sstevel@tonic-gate /* These *must* match the order of the PT_ define's from zonecfg.h */ 1877c478bd9Sstevel@tonic-gate static char *prop_types[] = { 1887c478bd9Sstevel@tonic-gate "unknown", 189087719fdSdp "zonename", 1907c478bd9Sstevel@tonic-gate "zonepath", 1917c478bd9Sstevel@tonic-gate "autoboot", 1927c478bd9Sstevel@tonic-gate "pool", 1937c478bd9Sstevel@tonic-gate "dir", 1947c478bd9Sstevel@tonic-gate "special", 1957c478bd9Sstevel@tonic-gate "type", 1967c478bd9Sstevel@tonic-gate "options", 1977c478bd9Sstevel@tonic-gate "address", 1987c478bd9Sstevel@tonic-gate "physical", 1997c478bd9Sstevel@tonic-gate "name", 2007c478bd9Sstevel@tonic-gate "value", 2017c478bd9Sstevel@tonic-gate "match", 2027c478bd9Sstevel@tonic-gate "priv", 2037c478bd9Sstevel@tonic-gate "limit", 2047c478bd9Sstevel@tonic-gate "action", 2057c478bd9Sstevel@tonic-gate "raw", 206ffbafc53Scomay "limitpriv", 2073f2f09c1Sdp "bootargs", 2089acbbeafSnn "brand", 2090209230bSgjelinek "ncpus", 2100209230bSgjelinek "importance", 2110209230bSgjelinek "swap", 2120209230bSgjelinek "locked", 2130209230bSgjelinek ALIAS_SHARES, 2140209230bSgjelinek ALIAS_MAXLWPS, 2150209230bSgjelinek ALIAS_MAXSHMMEM, 2160209230bSgjelinek ALIAS_MAXSHMIDS, 2170209230bSgjelinek ALIAS_MAXMSGIDS, 2180209230bSgjelinek ALIAS_MAXSEMIDS, 2190209230bSgjelinek ALIAS_MAXLOCKEDMEM, 2200209230bSgjelinek ALIAS_MAXSWAP, 2210209230bSgjelinek "scheduling-class", 222f4b3ec61Sdh "ip-type", 223*de860bd9Sgfaden "defrouter", 2247c478bd9Sstevel@tonic-gate NULL 2257c478bd9Sstevel@tonic-gate }; 2267c478bd9Sstevel@tonic-gate 227ffbafc53Scomay /* These *must* match the order of the PROP_VAL_ define's from zonecfg.h */ 2287c478bd9Sstevel@tonic-gate static char *prop_val_types[] = { 2297c478bd9Sstevel@tonic-gate "simple", 2307c478bd9Sstevel@tonic-gate "complex", 2317c478bd9Sstevel@tonic-gate "list", 2327c478bd9Sstevel@tonic-gate }; 2337c478bd9Sstevel@tonic-gate 2347c478bd9Sstevel@tonic-gate /* 2357c478bd9Sstevel@tonic-gate * The various _cmds[] lists below are for command tab-completion. 2367c478bd9Sstevel@tonic-gate */ 2377c478bd9Sstevel@tonic-gate 2387c478bd9Sstevel@tonic-gate /* 2397c478bd9Sstevel@tonic-gate * remove has a space afterwards because it has qualifiers; the other commands 2400209230bSgjelinek * that have qualifiers (add, select, etc.) don't need a space here because 2417c478bd9Sstevel@tonic-gate * they have their own _cmds[] lists below. 2427c478bd9Sstevel@tonic-gate */ 2437c478bd9Sstevel@tonic-gate static const char *global_scope_cmds[] = { 2447c478bd9Sstevel@tonic-gate "add", 2450209230bSgjelinek "clear", 2467c478bd9Sstevel@tonic-gate "commit", 2477c478bd9Sstevel@tonic-gate "create", 2487c478bd9Sstevel@tonic-gate "delete", 2497c478bd9Sstevel@tonic-gate "exit", 2507c478bd9Sstevel@tonic-gate "export", 2517c478bd9Sstevel@tonic-gate "help", 2527c478bd9Sstevel@tonic-gate "info", 2537c478bd9Sstevel@tonic-gate "remove ", 2547c478bd9Sstevel@tonic-gate "revert", 2557c478bd9Sstevel@tonic-gate "select", 2567c478bd9Sstevel@tonic-gate "set", 2577c478bd9Sstevel@tonic-gate "verify", 2587c478bd9Sstevel@tonic-gate NULL 2597c478bd9Sstevel@tonic-gate }; 2607c478bd9Sstevel@tonic-gate 2617c478bd9Sstevel@tonic-gate static const char *add_cmds[] = { 2627c478bd9Sstevel@tonic-gate "add fs", 2637c478bd9Sstevel@tonic-gate "add inherit-pkg-dir", 2647c478bd9Sstevel@tonic-gate "add net", 2657c478bd9Sstevel@tonic-gate "add device", 2667c478bd9Sstevel@tonic-gate "add rctl", 2677c478bd9Sstevel@tonic-gate "add attr", 268fa9e4066Sahrens "add dataset", 2690209230bSgjelinek "add dedicated-cpu", 270c97ad5cdSakolb "add capped-cpu", 2710209230bSgjelinek "add capped-memory", 2720209230bSgjelinek NULL 2730209230bSgjelinek }; 2740209230bSgjelinek 2750209230bSgjelinek static const char *clear_cmds[] = { 2760209230bSgjelinek "clear autoboot", 2770209230bSgjelinek "clear pool", 2780209230bSgjelinek "clear limitpriv", 2790209230bSgjelinek "clear bootargs", 2800209230bSgjelinek "clear scheduling-class", 281f4b3ec61Sdh "clear ip-type", 2820209230bSgjelinek "clear " ALIAS_MAXLWPS, 2830209230bSgjelinek "clear " ALIAS_MAXSHMMEM, 2840209230bSgjelinek "clear " ALIAS_MAXSHMIDS, 2850209230bSgjelinek "clear " ALIAS_MAXMSGIDS, 2860209230bSgjelinek "clear " ALIAS_MAXSEMIDS, 2870209230bSgjelinek "clear " ALIAS_SHARES, 2887c478bd9Sstevel@tonic-gate NULL 2897c478bd9Sstevel@tonic-gate }; 2907c478bd9Sstevel@tonic-gate 2919e7542f4Sdp static const char *remove_cmds[] = { 2929e7542f4Sdp "remove fs ", 2939e7542f4Sdp "remove inherit-pkg-dir ", 2949e7542f4Sdp "remove net ", 2959e7542f4Sdp "remove device ", 2969e7542f4Sdp "remove rctl ", 2979e7542f4Sdp "remove attr ", 2989e7542f4Sdp "remove dataset ", 2990209230bSgjelinek "remove dedicated-cpu ", 300c97ad5cdSakolb "remove capped-cpu ", 3010209230bSgjelinek "remove capped-memory ", 3029e7542f4Sdp NULL 3039e7542f4Sdp }; 3049e7542f4Sdp 3057c478bd9Sstevel@tonic-gate static const char *select_cmds[] = { 306087719fdSdp "select fs ", 307087719fdSdp "select inherit-pkg-dir ", 308087719fdSdp "select net ", 309087719fdSdp "select device ", 310087719fdSdp "select rctl ", 311087719fdSdp "select attr ", 312fa9e4066Sahrens "select dataset ", 3130209230bSgjelinek "select dedicated-cpu", 314c97ad5cdSakolb "select capped-cpu", 3150209230bSgjelinek "select capped-memory", 3167c478bd9Sstevel@tonic-gate NULL 3177c478bd9Sstevel@tonic-gate }; 3187c478bd9Sstevel@tonic-gate 3197c478bd9Sstevel@tonic-gate static const char *set_cmds[] = { 320087719fdSdp "set zonename=", 321087719fdSdp "set zonepath=", 3229acbbeafSnn "set brand=", 323087719fdSdp "set autoboot=", 324087719fdSdp "set pool=", 325ffbafc53Scomay "set limitpriv=", 3263f2f09c1Sdp "set bootargs=", 3270209230bSgjelinek "set scheduling-class=", 328f4b3ec61Sdh "set ip-type=", 3290209230bSgjelinek "set " ALIAS_MAXLWPS "=", 3300209230bSgjelinek "set " ALIAS_MAXSHMMEM "=", 3310209230bSgjelinek "set " ALIAS_MAXSHMIDS "=", 3320209230bSgjelinek "set " ALIAS_MAXMSGIDS "=", 3330209230bSgjelinek "set " ALIAS_MAXSEMIDS "=", 3340209230bSgjelinek "set " ALIAS_SHARES "=", 3357c478bd9Sstevel@tonic-gate NULL 3367c478bd9Sstevel@tonic-gate }; 3377c478bd9Sstevel@tonic-gate 3389e7542f4Sdp static const char *info_cmds[] = { 3399e7542f4Sdp "info fs ", 3409e7542f4Sdp "info inherit-pkg-dir ", 3419e7542f4Sdp "info net ", 3429e7542f4Sdp "info device ", 3439e7542f4Sdp "info rctl ", 3449e7542f4Sdp "info attr ", 3459e7542f4Sdp "info dataset ", 3460209230bSgjelinek "info capped-memory", 3470209230bSgjelinek "info dedicated-cpu", 348c97ad5cdSakolb "info capped-cpu", 3499e7542f4Sdp "info zonename", 3509e7542f4Sdp "info zonepath", 3519e7542f4Sdp "info autoboot", 3529e7542f4Sdp "info pool", 3539e7542f4Sdp "info limitpriv", 3549e7542f4Sdp "info bootargs", 3550209230bSgjelinek "info brand", 3560209230bSgjelinek "info scheduling-class", 357f4b3ec61Sdh "info ip-type", 3580209230bSgjelinek "info max-lwps", 3590209230bSgjelinek "info max-shm-memory", 3600209230bSgjelinek "info max-shm-ids", 3610209230bSgjelinek "info max-msg-ids", 3620209230bSgjelinek "info max-sem-ids", 3630209230bSgjelinek "info cpu-shares", 3649e7542f4Sdp NULL 3659e7542f4Sdp }; 3669e7542f4Sdp 3677c478bd9Sstevel@tonic-gate static const char *fs_res_scope_cmds[] = { 3687c478bd9Sstevel@tonic-gate "add options ", 3697c478bd9Sstevel@tonic-gate "cancel", 3707c478bd9Sstevel@tonic-gate "end", 3717c478bd9Sstevel@tonic-gate "exit", 3727c478bd9Sstevel@tonic-gate "help", 3737c478bd9Sstevel@tonic-gate "info", 374ffbafc53Scomay "remove options ", 3757c478bd9Sstevel@tonic-gate "set dir=", 3767c478bd9Sstevel@tonic-gate "set raw=", 3777c478bd9Sstevel@tonic-gate "set special=", 3787c478bd9Sstevel@tonic-gate "set type=", 3790209230bSgjelinek "clear raw", 3807c478bd9Sstevel@tonic-gate NULL 3817c478bd9Sstevel@tonic-gate }; 3827c478bd9Sstevel@tonic-gate 3837c478bd9Sstevel@tonic-gate static const char *net_res_scope_cmds[] = { 3847c478bd9Sstevel@tonic-gate "cancel", 3857c478bd9Sstevel@tonic-gate "end", 3867c478bd9Sstevel@tonic-gate "exit", 3877c478bd9Sstevel@tonic-gate "help", 3887c478bd9Sstevel@tonic-gate "info", 3897c478bd9Sstevel@tonic-gate "set address=", 3907c478bd9Sstevel@tonic-gate "set physical=", 3917c478bd9Sstevel@tonic-gate NULL 3927c478bd9Sstevel@tonic-gate }; 3937c478bd9Sstevel@tonic-gate 3947c478bd9Sstevel@tonic-gate static const char *ipd_res_scope_cmds[] = { 3957c478bd9Sstevel@tonic-gate "cancel", 3967c478bd9Sstevel@tonic-gate "end", 3977c478bd9Sstevel@tonic-gate "exit", 3987c478bd9Sstevel@tonic-gate "help", 3997c478bd9Sstevel@tonic-gate "info", 4007c478bd9Sstevel@tonic-gate "set dir=", 4017c478bd9Sstevel@tonic-gate NULL 4027c478bd9Sstevel@tonic-gate }; 4037c478bd9Sstevel@tonic-gate 4047c478bd9Sstevel@tonic-gate static const char *device_res_scope_cmds[] = { 4057c478bd9Sstevel@tonic-gate "cancel", 4067c478bd9Sstevel@tonic-gate "end", 4077c478bd9Sstevel@tonic-gate "exit", 4087c478bd9Sstevel@tonic-gate "help", 4097c478bd9Sstevel@tonic-gate "info", 4107c478bd9Sstevel@tonic-gate "set match=", 4117c478bd9Sstevel@tonic-gate NULL 4127c478bd9Sstevel@tonic-gate }; 4137c478bd9Sstevel@tonic-gate 4147c478bd9Sstevel@tonic-gate static const char *attr_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 name=", 4217c478bd9Sstevel@tonic-gate "set type=", 4227c478bd9Sstevel@tonic-gate "set value=", 4237c478bd9Sstevel@tonic-gate NULL 4247c478bd9Sstevel@tonic-gate }; 4257c478bd9Sstevel@tonic-gate 4267c478bd9Sstevel@tonic-gate static const char *rctl_res_scope_cmds[] = { 4277c478bd9Sstevel@tonic-gate "add value ", 4287c478bd9Sstevel@tonic-gate "cancel", 4297c478bd9Sstevel@tonic-gate "end", 4307c478bd9Sstevel@tonic-gate "exit", 4317c478bd9Sstevel@tonic-gate "help", 4327c478bd9Sstevel@tonic-gate "info", 433ffbafc53Scomay "remove value ", 4347c478bd9Sstevel@tonic-gate "set name=", 4357c478bd9Sstevel@tonic-gate NULL 4367c478bd9Sstevel@tonic-gate }; 4377c478bd9Sstevel@tonic-gate 438fa9e4066Sahrens static const char *dataset_res_scope_cmds[] = { 439fa9e4066Sahrens "cancel", 440fa9e4066Sahrens "end", 441fa9e4066Sahrens "exit", 442fa9e4066Sahrens "help", 443fa9e4066Sahrens "info", 444fa9e4066Sahrens "set name=", 445fa9e4066Sahrens NULL 446fa9e4066Sahrens }; 447fa9e4066Sahrens 4480209230bSgjelinek static const char *pset_res_scope_cmds[] = { 4490209230bSgjelinek "cancel", 4500209230bSgjelinek "end", 4510209230bSgjelinek "exit", 4520209230bSgjelinek "help", 4530209230bSgjelinek "info", 4540209230bSgjelinek "set ncpus=", 4550209230bSgjelinek "set importance=", 4560209230bSgjelinek "clear importance", 4570209230bSgjelinek NULL 4580209230bSgjelinek }; 4590209230bSgjelinek 460c97ad5cdSakolb static const char *pcap_res_scope_cmds[] = { 461c97ad5cdSakolb "cancel", 462c97ad5cdSakolb "end", 463c97ad5cdSakolb "exit", 464c97ad5cdSakolb "help", 465c97ad5cdSakolb "info", 466c97ad5cdSakolb "set ncpus=", 467c97ad5cdSakolb NULL 468c97ad5cdSakolb }; 469c97ad5cdSakolb 4700209230bSgjelinek static const char *mcap_res_scope_cmds[] = { 4710209230bSgjelinek "cancel", 4720209230bSgjelinek "end", 4730209230bSgjelinek "exit", 4740209230bSgjelinek "help", 4750209230bSgjelinek "info", 4760209230bSgjelinek "set physical=", 4770209230bSgjelinek "set swap=", 4780209230bSgjelinek "set locked=", 4790209230bSgjelinek "clear physical", 4800209230bSgjelinek "clear swap", 4810209230bSgjelinek "clear locked", 4820209230bSgjelinek NULL 4830209230bSgjelinek }; 4840209230bSgjelinek 4857c478bd9Sstevel@tonic-gate /* Global variables */ 4867c478bd9Sstevel@tonic-gate 4877c478bd9Sstevel@tonic-gate /* set early in main(), never modified thereafter, used all over the place */ 4887c478bd9Sstevel@tonic-gate static char *execname; 4897c478bd9Sstevel@tonic-gate 4907c478bd9Sstevel@tonic-gate /* set in main(), used all over the place */ 4917c478bd9Sstevel@tonic-gate static zone_dochandle_t handle; 4927c478bd9Sstevel@tonic-gate 4937c478bd9Sstevel@tonic-gate /* used all over the place */ 494087719fdSdp static char zone[ZONENAME_MAX]; 495087719fdSdp static char revert_zone[ZONENAME_MAX]; 4967c478bd9Sstevel@tonic-gate 4979acbbeafSnn /* global brand operations */ 498123807fbSedp static brand_handle_t brand; 4999acbbeafSnn 5007c478bd9Sstevel@tonic-gate /* set in modifying functions, checked in read_input() */ 5017c478bd9Sstevel@tonic-gate static bool need_to_commit = FALSE; 5027c478bd9Sstevel@tonic-gate bool saw_error; 5037c478bd9Sstevel@tonic-gate 5047c478bd9Sstevel@tonic-gate /* set in yacc parser, checked in read_input() */ 5057c478bd9Sstevel@tonic-gate bool newline_terminated; 5067c478bd9Sstevel@tonic-gate 5077c478bd9Sstevel@tonic-gate /* set in main(), checked in lex error handler */ 5087c478bd9Sstevel@tonic-gate bool cmd_file_mode; 5097c478bd9Sstevel@tonic-gate 5107c478bd9Sstevel@tonic-gate /* set in exit_func(), checked in read_input() */ 5117c478bd9Sstevel@tonic-gate static bool time_to_exit = FALSE, force_exit = FALSE; 5127c478bd9Sstevel@tonic-gate 5137c478bd9Sstevel@tonic-gate /* used in short_usage() and zerr() */ 5147c478bd9Sstevel@tonic-gate static char *cmd_file_name = NULL; 5157c478bd9Sstevel@tonic-gate 5167c478bd9Sstevel@tonic-gate /* checked in read_input() and other places */ 5177c478bd9Sstevel@tonic-gate static bool ok_to_prompt = FALSE; 5187c478bd9Sstevel@tonic-gate 5197c478bd9Sstevel@tonic-gate /* set and checked in initialize() */ 5207c478bd9Sstevel@tonic-gate static bool got_handle = FALSE; 5217c478bd9Sstevel@tonic-gate 5227c478bd9Sstevel@tonic-gate /* initialized in do_interactive(), checked in initialize() */ 5237c478bd9Sstevel@tonic-gate static bool interactive_mode; 5247c478bd9Sstevel@tonic-gate 5250209230bSgjelinek /* set if configuring the global zone */ 5260209230bSgjelinek static bool global_zone = FALSE; 5270209230bSgjelinek 5287c478bd9Sstevel@tonic-gate /* set in main(), checked in multiple places */ 5297c478bd9Sstevel@tonic-gate static bool read_only_mode; 5307c478bd9Sstevel@tonic-gate 5317c478bd9Sstevel@tonic-gate static bool global_scope = TRUE; /* scope is outer/global or inner/resource */ 5327c478bd9Sstevel@tonic-gate static int resource_scope; /* should be in the RT_ list from zonecfg.h */ 5337c478bd9Sstevel@tonic-gate static int end_op = -1; /* operation on end is either add or modify */ 5347c478bd9Sstevel@tonic-gate 5357c478bd9Sstevel@tonic-gate int num_prop_vals; /* for grammar */ 5367c478bd9Sstevel@tonic-gate 5377c478bd9Sstevel@tonic-gate /* 5387c478bd9Sstevel@tonic-gate * These are for keeping track of resources as they are specified as part of 5397c478bd9Sstevel@tonic-gate * the multi-step process. They should be initialized by add_resource() or 5407c478bd9Sstevel@tonic-gate * select_func() and filled in by add_property() or set_func(). 5417c478bd9Sstevel@tonic-gate */ 5427c478bd9Sstevel@tonic-gate static struct zone_fstab old_fstab, in_progress_fstab; 5437c478bd9Sstevel@tonic-gate static struct zone_fstab old_ipdtab, in_progress_ipdtab; 5447c478bd9Sstevel@tonic-gate static struct zone_nwiftab old_nwiftab, in_progress_nwiftab; 5457c478bd9Sstevel@tonic-gate static struct zone_devtab old_devtab, in_progress_devtab; 5467c478bd9Sstevel@tonic-gate static struct zone_rctltab old_rctltab, in_progress_rctltab; 5477c478bd9Sstevel@tonic-gate static struct zone_attrtab old_attrtab, in_progress_attrtab; 548fa9e4066Sahrens static struct zone_dstab old_dstab, in_progress_dstab; 5490209230bSgjelinek static struct zone_psettab old_psettab, in_progress_psettab; 5500209230bSgjelinek static struct zone_mcaptab old_mcaptab, in_progress_mcaptab; 5517c478bd9Sstevel@tonic-gate 5527c478bd9Sstevel@tonic-gate static GetLine *gl; /* The gl_get_line() resource object */ 5537c478bd9Sstevel@tonic-gate 5540209230bSgjelinek static void bytes_to_units(char *str, char *buf, int bufsize); 5550209230bSgjelinek 5567c478bd9Sstevel@tonic-gate /* Functions begin here */ 5577c478bd9Sstevel@tonic-gate 5587c478bd9Sstevel@tonic-gate static bool 5597c478bd9Sstevel@tonic-gate initial_match(const char *line1, const char *line2, int word_end) 5607c478bd9Sstevel@tonic-gate { 5617c478bd9Sstevel@tonic-gate if (word_end <= 0) 5627c478bd9Sstevel@tonic-gate return (TRUE); 5637c478bd9Sstevel@tonic-gate return (strncmp(line1, line2, word_end) == 0); 5647c478bd9Sstevel@tonic-gate } 5657c478bd9Sstevel@tonic-gate 5667c478bd9Sstevel@tonic-gate static int 5677c478bd9Sstevel@tonic-gate add_stuff(WordCompletion *cpl, const char *line1, const char **list, 5687c478bd9Sstevel@tonic-gate int word_end) 5697c478bd9Sstevel@tonic-gate { 5707c478bd9Sstevel@tonic-gate int i, err; 5717c478bd9Sstevel@tonic-gate 5727c478bd9Sstevel@tonic-gate for (i = 0; list[i] != NULL; i++) { 5737c478bd9Sstevel@tonic-gate if (initial_match(line1, list[i], word_end)) { 5747c478bd9Sstevel@tonic-gate err = cpl_add_completion(cpl, line1, 0, word_end, 5757c478bd9Sstevel@tonic-gate list[i] + word_end, "", ""); 5767c478bd9Sstevel@tonic-gate if (err != 0) 5777c478bd9Sstevel@tonic-gate return (err); 5787c478bd9Sstevel@tonic-gate } 5797c478bd9Sstevel@tonic-gate } 5807c478bd9Sstevel@tonic-gate return (0); 5817c478bd9Sstevel@tonic-gate } 5827c478bd9Sstevel@tonic-gate 5837c478bd9Sstevel@tonic-gate static 5847c478bd9Sstevel@tonic-gate /* ARGSUSED */ 5857c478bd9Sstevel@tonic-gate CPL_MATCH_FN(cmd_cpl_fn) 5867c478bd9Sstevel@tonic-gate { 5877c478bd9Sstevel@tonic-gate if (global_scope) { 5887c478bd9Sstevel@tonic-gate /* 5897c478bd9Sstevel@tonic-gate * The MAX/MIN tests below are to make sure we have at least 5907c478bd9Sstevel@tonic-gate * enough characters to distinguish from other prefixes (MAX) 5917c478bd9Sstevel@tonic-gate * but only check MIN(what we have, what we're checking). 5927c478bd9Sstevel@tonic-gate */ 5937c478bd9Sstevel@tonic-gate if (strncmp(line, "add ", MAX(MIN(word_end, 4), 1)) == 0) 5947c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, add_cmds, word_end)); 5950209230bSgjelinek if (strncmp(line, "clear ", MAX(MIN(word_end, 6), 2)) == 0) 5960209230bSgjelinek return (add_stuff(cpl, line, clear_cmds, word_end)); 5977c478bd9Sstevel@tonic-gate if (strncmp(line, "select ", MAX(MIN(word_end, 7), 3)) == 0) 5987c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, select_cmds, word_end)); 5997c478bd9Sstevel@tonic-gate if (strncmp(line, "set ", MAX(MIN(word_end, 4), 3)) == 0) 6007c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, set_cmds, word_end)); 6019e7542f4Sdp if (strncmp(line, "remove ", MAX(MIN(word_end, 7), 1)) == 0) 6029e7542f4Sdp return (add_stuff(cpl, line, remove_cmds, word_end)); 6039e7542f4Sdp if (strncmp(line, "info ", MAX(MIN(word_end, 5), 1)) == 0) 6049e7542f4Sdp return (add_stuff(cpl, line, info_cmds, word_end)); 6057c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, global_scope_cmds, word_end)); 6067c478bd9Sstevel@tonic-gate } 6077c478bd9Sstevel@tonic-gate switch (resource_scope) { 6087c478bd9Sstevel@tonic-gate case RT_FS: 6097c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, fs_res_scope_cmds, word_end)); 6107c478bd9Sstevel@tonic-gate case RT_IPD: 6117c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, ipd_res_scope_cmds, word_end)); 6127c478bd9Sstevel@tonic-gate case RT_NET: 6137c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, net_res_scope_cmds, word_end)); 6147c478bd9Sstevel@tonic-gate case RT_DEVICE: 6157c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, device_res_scope_cmds, word_end)); 6167c478bd9Sstevel@tonic-gate case RT_RCTL: 6177c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, rctl_res_scope_cmds, word_end)); 6187c478bd9Sstevel@tonic-gate case RT_ATTR: 6197c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, attr_res_scope_cmds, word_end)); 620fa9e4066Sahrens case RT_DATASET: 621fa9e4066Sahrens return (add_stuff(cpl, line, dataset_res_scope_cmds, word_end)); 6220209230bSgjelinek case RT_DCPU: 6230209230bSgjelinek return (add_stuff(cpl, line, pset_res_scope_cmds, word_end)); 624c97ad5cdSakolb case RT_PCAP: 625c97ad5cdSakolb return (add_stuff(cpl, line, pcap_res_scope_cmds, word_end)); 6260209230bSgjelinek case RT_MCAP: 6270209230bSgjelinek return (add_stuff(cpl, line, mcap_res_scope_cmds, word_end)); 6287c478bd9Sstevel@tonic-gate } 6297c478bd9Sstevel@tonic-gate return (0); 6307c478bd9Sstevel@tonic-gate } 6317c478bd9Sstevel@tonic-gate 6327c478bd9Sstevel@tonic-gate /* 6337c478bd9Sstevel@tonic-gate * For the main CMD_func() functions below, several of them call getopt() 6347c478bd9Sstevel@tonic-gate * then check optind against argc to make sure an extra parameter was not 6357c478bd9Sstevel@tonic-gate * passed in. The reason this is not caught in the grammar is that the 6367c478bd9Sstevel@tonic-gate * grammar just checks for a miscellaneous TOKEN, which is *expected* to 6377c478bd9Sstevel@tonic-gate * be "-F" (for example), but could be anything. So (for example) this 6387c478bd9Sstevel@tonic-gate * check will prevent "create bogus". 6397c478bd9Sstevel@tonic-gate */ 6407c478bd9Sstevel@tonic-gate 6417c478bd9Sstevel@tonic-gate cmd_t * 6427c478bd9Sstevel@tonic-gate alloc_cmd(void) 6437c478bd9Sstevel@tonic-gate { 6447c478bd9Sstevel@tonic-gate return (calloc(1, sizeof (cmd_t))); 6457c478bd9Sstevel@tonic-gate } 6467c478bd9Sstevel@tonic-gate 6477c478bd9Sstevel@tonic-gate void 6487c478bd9Sstevel@tonic-gate free_cmd(cmd_t *cmd) 6497c478bd9Sstevel@tonic-gate { 6507c478bd9Sstevel@tonic-gate int i; 6517c478bd9Sstevel@tonic-gate 6527c478bd9Sstevel@tonic-gate for (i = 0; i < MAX_EQ_PROP_PAIRS; i++) 6537c478bd9Sstevel@tonic-gate if (cmd->cmd_property_ptr[i] != NULL) { 6547c478bd9Sstevel@tonic-gate property_value_ptr_t pp = cmd->cmd_property_ptr[i]; 6557c478bd9Sstevel@tonic-gate 6567c478bd9Sstevel@tonic-gate switch (pp->pv_type) { 6577c478bd9Sstevel@tonic-gate case PROP_VAL_SIMPLE: 6587c478bd9Sstevel@tonic-gate free(pp->pv_simple); 6597c478bd9Sstevel@tonic-gate break; 6607c478bd9Sstevel@tonic-gate case PROP_VAL_COMPLEX: 6617c478bd9Sstevel@tonic-gate free_complex(pp->pv_complex); 6627c478bd9Sstevel@tonic-gate break; 6637c478bd9Sstevel@tonic-gate case PROP_VAL_LIST: 6647c478bd9Sstevel@tonic-gate free_list(pp->pv_list); 6657c478bd9Sstevel@tonic-gate break; 6667c478bd9Sstevel@tonic-gate } 6677c478bd9Sstevel@tonic-gate } 6687c478bd9Sstevel@tonic-gate for (i = 0; i < cmd->cmd_argc; i++) 6697c478bd9Sstevel@tonic-gate free(cmd->cmd_argv[i]); 6707c478bd9Sstevel@tonic-gate free(cmd); 6717c478bd9Sstevel@tonic-gate } 6727c478bd9Sstevel@tonic-gate 6737c478bd9Sstevel@tonic-gate complex_property_ptr_t 6747c478bd9Sstevel@tonic-gate alloc_complex(void) 6757c478bd9Sstevel@tonic-gate { 6767c478bd9Sstevel@tonic-gate return (calloc(1, sizeof (complex_property_t))); 6777c478bd9Sstevel@tonic-gate } 6787c478bd9Sstevel@tonic-gate 6797c478bd9Sstevel@tonic-gate void 6807c478bd9Sstevel@tonic-gate free_complex(complex_property_ptr_t complex) 6817c478bd9Sstevel@tonic-gate { 6827c478bd9Sstevel@tonic-gate if (complex == NULL) 6837c478bd9Sstevel@tonic-gate return; 6847c478bd9Sstevel@tonic-gate free_complex(complex->cp_next); 6857c478bd9Sstevel@tonic-gate if (complex->cp_value != NULL) 6867c478bd9Sstevel@tonic-gate free(complex->cp_value); 6877c478bd9Sstevel@tonic-gate free(complex); 6887c478bd9Sstevel@tonic-gate } 6897c478bd9Sstevel@tonic-gate 6907c478bd9Sstevel@tonic-gate list_property_ptr_t 6917c478bd9Sstevel@tonic-gate alloc_list(void) 6927c478bd9Sstevel@tonic-gate { 6937c478bd9Sstevel@tonic-gate return (calloc(1, sizeof (list_property_t))); 6947c478bd9Sstevel@tonic-gate } 6957c478bd9Sstevel@tonic-gate 6967c478bd9Sstevel@tonic-gate void 6977c478bd9Sstevel@tonic-gate free_list(list_property_ptr_t list) 6987c478bd9Sstevel@tonic-gate { 6997c478bd9Sstevel@tonic-gate if (list == NULL) 7007c478bd9Sstevel@tonic-gate return; 7017c478bd9Sstevel@tonic-gate if (list->lp_simple != NULL) 7027c478bd9Sstevel@tonic-gate free(list->lp_simple); 7037c478bd9Sstevel@tonic-gate free_complex(list->lp_complex); 7047c478bd9Sstevel@tonic-gate free_list(list->lp_next); 7057c478bd9Sstevel@tonic-gate free(list); 7067c478bd9Sstevel@tonic-gate } 7077c478bd9Sstevel@tonic-gate 7087c478bd9Sstevel@tonic-gate void 7097c478bd9Sstevel@tonic-gate free_outer_list(list_property_ptr_t list) 7107c478bd9Sstevel@tonic-gate { 7117c478bd9Sstevel@tonic-gate if (list == NULL) 7127c478bd9Sstevel@tonic-gate return; 7137c478bd9Sstevel@tonic-gate free_outer_list(list->lp_next); 7147c478bd9Sstevel@tonic-gate free(list); 7157c478bd9Sstevel@tonic-gate } 7167c478bd9Sstevel@tonic-gate 7177c478bd9Sstevel@tonic-gate static struct zone_rctlvaltab * 7187c478bd9Sstevel@tonic-gate alloc_rctlvaltab(void) 7197c478bd9Sstevel@tonic-gate { 7207c478bd9Sstevel@tonic-gate return (calloc(1, sizeof (struct zone_rctlvaltab))); 7217c478bd9Sstevel@tonic-gate } 7227c478bd9Sstevel@tonic-gate 7237c478bd9Sstevel@tonic-gate static char * 7247c478bd9Sstevel@tonic-gate rt_to_str(int res_type) 7257c478bd9Sstevel@tonic-gate { 7267c478bd9Sstevel@tonic-gate assert(res_type >= RT_MIN && res_type <= RT_MAX); 7277c478bd9Sstevel@tonic-gate return (res_types[res_type]); 7287c478bd9Sstevel@tonic-gate } 7297c478bd9Sstevel@tonic-gate 7307c478bd9Sstevel@tonic-gate static char * 7317c478bd9Sstevel@tonic-gate pt_to_str(int prop_type) 7327c478bd9Sstevel@tonic-gate { 7337c478bd9Sstevel@tonic-gate assert(prop_type >= PT_MIN && prop_type <= PT_MAX); 7347c478bd9Sstevel@tonic-gate return (prop_types[prop_type]); 7357c478bd9Sstevel@tonic-gate } 7367c478bd9Sstevel@tonic-gate 7377c478bd9Sstevel@tonic-gate static char * 7387c478bd9Sstevel@tonic-gate pvt_to_str(int pv_type) 7397c478bd9Sstevel@tonic-gate { 7407c478bd9Sstevel@tonic-gate assert(pv_type >= PROP_VAL_MIN && pv_type <= PROP_VAL_MAX); 7417c478bd9Sstevel@tonic-gate return (prop_val_types[pv_type]); 7427c478bd9Sstevel@tonic-gate } 7437c478bd9Sstevel@tonic-gate 7447c478bd9Sstevel@tonic-gate static char * 7457c478bd9Sstevel@tonic-gate cmd_to_str(int cmd_num) 7467c478bd9Sstevel@tonic-gate { 7477c478bd9Sstevel@tonic-gate assert(cmd_num >= CMD_MIN && cmd_num <= CMD_MAX); 7487c478bd9Sstevel@tonic-gate return (helptab[cmd_num].cmd_name); 7497c478bd9Sstevel@tonic-gate } 7507c478bd9Sstevel@tonic-gate 7517c478bd9Sstevel@tonic-gate /* 7527c478bd9Sstevel@tonic-gate * This is a separate function rather than a set of define's because of the 7537c478bd9Sstevel@tonic-gate * gettext() wrapping. 7547c478bd9Sstevel@tonic-gate */ 7557c478bd9Sstevel@tonic-gate 7567c478bd9Sstevel@tonic-gate /* 7577c478bd9Sstevel@tonic-gate * TRANSLATION_NOTE 7587c478bd9Sstevel@tonic-gate * Each string below should have \t follow \n whenever needed; the 7597c478bd9Sstevel@tonic-gate * initial \t and the terminal \n will be provided by the calling function. 7607c478bd9Sstevel@tonic-gate */ 7617c478bd9Sstevel@tonic-gate 7627c478bd9Sstevel@tonic-gate static char * 7637c478bd9Sstevel@tonic-gate long_help(int cmd_num) 7647c478bd9Sstevel@tonic-gate { 7657c478bd9Sstevel@tonic-gate static char line[1024]; /* arbitrary large amount */ 7667c478bd9Sstevel@tonic-gate 7677c478bd9Sstevel@tonic-gate assert(cmd_num >= CMD_MIN && cmd_num <= CMD_MAX); 7687c478bd9Sstevel@tonic-gate switch (cmd_num) { 7697c478bd9Sstevel@tonic-gate case CMD_HELP: 7707c478bd9Sstevel@tonic-gate return (gettext("Prints help message.")); 7717c478bd9Sstevel@tonic-gate case CMD_CREATE: 7727c478bd9Sstevel@tonic-gate (void) snprintf(line, sizeof (line), 7737c478bd9Sstevel@tonic-gate gettext("Creates a configuration for the " 7747c478bd9Sstevel@tonic-gate "specified zone. %s should be\n\tused to " 7757c478bd9Sstevel@tonic-gate "begin configuring a new zone. If overwriting an " 7767c478bd9Sstevel@tonic-gate "existing\n\tconfiguration, the -F flag can be " 7777c478bd9Sstevel@tonic-gate "used to force the action. If\n\t-t template is " 7787c478bd9Sstevel@tonic-gate "given, creates a configuration identical to the\n" 7797c478bd9Sstevel@tonic-gate "\tspecified template, except that the zone name " 7809e518655Sgjelinek "is changed from\n\ttemplate to zonename. '%s -a' " 7819e518655Sgjelinek "creates a configuration from a\n\tdetached " 7829e518655Sgjelinek "zonepath. '%s -b' results in a blank " 7839e518655Sgjelinek "configuration.\n\t'%s' with no arguments applies " 7849e518655Sgjelinek "the Sun default settings."), 7857c478bd9Sstevel@tonic-gate cmd_to_str(CMD_CREATE), cmd_to_str(CMD_CREATE), 7869e518655Sgjelinek cmd_to_str(CMD_CREATE), cmd_to_str(CMD_CREATE)); 7877c478bd9Sstevel@tonic-gate return (line); 7887c478bd9Sstevel@tonic-gate case CMD_EXIT: 7897c478bd9Sstevel@tonic-gate return (gettext("Exits the program. The -F flag can " 7907c478bd9Sstevel@tonic-gate "be used to force the action.")); 7917c478bd9Sstevel@tonic-gate case CMD_EXPORT: 7927c478bd9Sstevel@tonic-gate return (gettext("Prints configuration to standard " 7937c478bd9Sstevel@tonic-gate "output, or to output-file if\n\tspecified, in " 7947c478bd9Sstevel@tonic-gate "a form suitable for use in a command-file.")); 7957c478bd9Sstevel@tonic-gate case CMD_ADD: 7967c478bd9Sstevel@tonic-gate return (gettext("Add specified resource to " 7977c478bd9Sstevel@tonic-gate "configuration.")); 7987c478bd9Sstevel@tonic-gate case CMD_DELETE: 7997c478bd9Sstevel@tonic-gate return (gettext("Deletes the specified zone. The -F " 8007c478bd9Sstevel@tonic-gate "flag can be used to force the\n\taction.")); 8017c478bd9Sstevel@tonic-gate case CMD_REMOVE: 8027c478bd9Sstevel@tonic-gate return (gettext("Remove specified resource from " 8030209230bSgjelinek "configuration. The -F flag can be used\n\tto " 8040209230bSgjelinek "force the action.")); 8057c478bd9Sstevel@tonic-gate case CMD_SELECT: 8067c478bd9Sstevel@tonic-gate (void) snprintf(line, sizeof (line), 8077c478bd9Sstevel@tonic-gate gettext("Selects a resource to modify. " 8087c478bd9Sstevel@tonic-gate "Resource modification is completed\n\twith the " 8097c478bd9Sstevel@tonic-gate "command \"%s\". The property name/value pairs " 8107c478bd9Sstevel@tonic-gate "must uniquely\n\tidentify a resource. Note that " 8117c478bd9Sstevel@tonic-gate "the curly braces ('{', '}') mean one\n\tor more " 8127c478bd9Sstevel@tonic-gate "of whatever is between them."), 8137c478bd9Sstevel@tonic-gate cmd_to_str(CMD_END)); 8147c478bd9Sstevel@tonic-gate return (line); 8157c478bd9Sstevel@tonic-gate case CMD_SET: 8167c478bd9Sstevel@tonic-gate return (gettext("Sets property values.")); 8170209230bSgjelinek case CMD_CLEAR: 8180209230bSgjelinek return (gettext("Clears property values.")); 8197c478bd9Sstevel@tonic-gate case CMD_INFO: 8207c478bd9Sstevel@tonic-gate return (gettext("Displays information about the " 8217c478bd9Sstevel@tonic-gate "current configuration. If resource\n\ttype is " 8227c478bd9Sstevel@tonic-gate "specified, displays only information about " 8237c478bd9Sstevel@tonic-gate "resources of\n\tthe relevant type. If resource " 8247c478bd9Sstevel@tonic-gate "id is specified, displays only\n\tinformation " 8257c478bd9Sstevel@tonic-gate "about that resource.")); 8267c478bd9Sstevel@tonic-gate case CMD_VERIFY: 8277c478bd9Sstevel@tonic-gate return (gettext("Verifies current configuration " 8287c478bd9Sstevel@tonic-gate "for correctness (some resource types\n\thave " 8297c478bd9Sstevel@tonic-gate "required properties).")); 8307c478bd9Sstevel@tonic-gate case CMD_COMMIT: 8317c478bd9Sstevel@tonic-gate (void) snprintf(line, sizeof (line), 8327c478bd9Sstevel@tonic-gate gettext("Commits current configuration. " 8337c478bd9Sstevel@tonic-gate "Configuration must be committed to\n\tbe used by " 8347c478bd9Sstevel@tonic-gate "%s. Until the configuration is committed, " 8357c478bd9Sstevel@tonic-gate "changes \n\tcan be removed with the %s " 8367c478bd9Sstevel@tonic-gate "command. This operation is\n\tattempted " 8377c478bd9Sstevel@tonic-gate "automatically upon completion of a %s " 8387c478bd9Sstevel@tonic-gate "session."), "zoneadm", cmd_to_str(CMD_REVERT), 8397c478bd9Sstevel@tonic-gate "zonecfg"); 8407c478bd9Sstevel@tonic-gate return (line); 8417c478bd9Sstevel@tonic-gate case CMD_REVERT: 8427c478bd9Sstevel@tonic-gate return (gettext("Reverts configuration back to the " 8437c478bd9Sstevel@tonic-gate "last committed state. The -F flag\n\tcan be " 8447c478bd9Sstevel@tonic-gate "used to force the action.")); 8457c478bd9Sstevel@tonic-gate case CMD_CANCEL: 8467c478bd9Sstevel@tonic-gate return (gettext("Cancels resource/property " 8477c478bd9Sstevel@tonic-gate "specification.")); 8487c478bd9Sstevel@tonic-gate case CMD_END: 8497c478bd9Sstevel@tonic-gate return (gettext("Ends resource/property " 8507c478bd9Sstevel@tonic-gate "specification.")); 8517c478bd9Sstevel@tonic-gate } 8527c478bd9Sstevel@tonic-gate /* NOTREACHED */ 8537e362f58Scomay return (NULL); 8547c478bd9Sstevel@tonic-gate } 8557c478bd9Sstevel@tonic-gate 8567c478bd9Sstevel@tonic-gate /* 8577c478bd9Sstevel@tonic-gate * Called with verbose TRUE when help is explicitly requested, FALSE for 8587c478bd9Sstevel@tonic-gate * unexpected errors. 8597c478bd9Sstevel@tonic-gate */ 8607c478bd9Sstevel@tonic-gate 8617c478bd9Sstevel@tonic-gate void 8627c478bd9Sstevel@tonic-gate usage(bool verbose, uint_t flags) 8637c478bd9Sstevel@tonic-gate { 8647c478bd9Sstevel@tonic-gate FILE *fp = verbose ? stdout : stderr, *newfp; 8657c478bd9Sstevel@tonic-gate bool need_to_close = FALSE; 8667c478bd9Sstevel@tonic-gate char *pager; 8677c478bd9Sstevel@tonic-gate int i; 8687c478bd9Sstevel@tonic-gate 8697c478bd9Sstevel@tonic-gate /* don't page error output */ 8707c478bd9Sstevel@tonic-gate if (verbose && interactive_mode) { 8717c478bd9Sstevel@tonic-gate if ((pager = getenv("PAGER")) == NULL) 8727c478bd9Sstevel@tonic-gate pager = PAGER; 8737c478bd9Sstevel@tonic-gate if ((newfp = popen(pager, "w")) != NULL) { 8747c478bd9Sstevel@tonic-gate need_to_close = TRUE; 8757c478bd9Sstevel@tonic-gate fp = newfp; 8767c478bd9Sstevel@tonic-gate } 8777c478bd9Sstevel@tonic-gate } 8787c478bd9Sstevel@tonic-gate if (flags & HELP_META) { 8797c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("More help is available for the " 8807c478bd9Sstevel@tonic-gate "following:\n")); 8817c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\n\tcommands ('%s commands')\n", 8827c478bd9Sstevel@tonic-gate cmd_to_str(CMD_HELP)); 8837c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\tsyntax ('%s syntax')\n", 8847c478bd9Sstevel@tonic-gate cmd_to_str(CMD_HELP)); 8857c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\tusage ('%s usage')\n\n", 8867c478bd9Sstevel@tonic-gate cmd_to_str(CMD_HELP)); 8877c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("You may also obtain help on any " 8887c478bd9Sstevel@tonic-gate "command by typing '%s <command-name>.'\n"), 8897c478bd9Sstevel@tonic-gate cmd_to_str(CMD_HELP)); 8907c478bd9Sstevel@tonic-gate } 8917c478bd9Sstevel@tonic-gate if (flags & HELP_RES_SCOPE) { 8927c478bd9Sstevel@tonic-gate switch (resource_scope) { 8937c478bd9Sstevel@tonic-gate case RT_FS: 8947c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("The '%s' resource scope is " 8957c478bd9Sstevel@tonic-gate "used to configure a file-system.\n"), 8967c478bd9Sstevel@tonic-gate rt_to_str(resource_scope)); 8977c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("Valid commands:\n")); 8987c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 8997c478bd9Sstevel@tonic-gate pt_to_str(PT_DIR), gettext("<path>")); 9007c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 9017c478bd9Sstevel@tonic-gate pt_to_str(PT_SPECIAL), gettext("<path>")); 9027c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 9037c478bd9Sstevel@tonic-gate pt_to_str(PT_RAW), gettext("<raw-device>")); 9047c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 9057c478bd9Sstevel@tonic-gate pt_to_str(PT_TYPE), gettext("<file-system type>")); 9067c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s %s\n", cmd_to_str(CMD_ADD), 9077c478bd9Sstevel@tonic-gate pt_to_str(PT_OPTIONS), 9087c478bd9Sstevel@tonic-gate gettext("<file-system options>")); 909ffbafc53Scomay (void) fprintf(fp, "\t%s %s %s\n", 910ffbafc53Scomay cmd_to_str(CMD_REMOVE), pt_to_str(PT_OPTIONS), 911ffbafc53Scomay gettext("<file-system options>")); 9127c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("Consult the file-system " 9137c478bd9Sstevel@tonic-gate "specific manual page, such as mount_ufs(1M), " 9147c478bd9Sstevel@tonic-gate "for\ndetails about file-system options. Note " 9157c478bd9Sstevel@tonic-gate "that any file-system options with an\nembedded " 9167c478bd9Sstevel@tonic-gate "'=' character must be enclosed in double quotes, " 9177c478bd9Sstevel@tonic-gate /*CSTYLED*/ 9187c478bd9Sstevel@tonic-gate "such as \"%s=5\".\n"), MNTOPT_RETRY); 9197c478bd9Sstevel@tonic-gate break; 9207c478bd9Sstevel@tonic-gate case RT_IPD: 9217c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("The '%s' resource scope is " 9227c478bd9Sstevel@tonic-gate "used to configure a directory\ninherited from the " 9237c478bd9Sstevel@tonic-gate "global zone into a non-global zone in read-only " 9247c478bd9Sstevel@tonic-gate "mode.\n"), rt_to_str(resource_scope)); 9257c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("Valid commands:\n")); 9267c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 9277c478bd9Sstevel@tonic-gate pt_to_str(PT_DIR), gettext("<path>")); 9287c478bd9Sstevel@tonic-gate break; 9297c478bd9Sstevel@tonic-gate case RT_NET: 9307c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("The '%s' resource scope is " 9317c478bd9Sstevel@tonic-gate "used to configure a network interface.\n"), 9327c478bd9Sstevel@tonic-gate rt_to_str(resource_scope)); 9337c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("Valid commands:\n")); 9347c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 9357c478bd9Sstevel@tonic-gate pt_to_str(PT_ADDRESS), gettext("<IP-address>")); 9367c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 9377c478bd9Sstevel@tonic-gate pt_to_str(PT_PHYSICAL), gettext("<interface>")); 9387c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("See ifconfig(1M) for " 9397c478bd9Sstevel@tonic-gate "details of the <interface> string.\n")); 940*de860bd9Sgfaden (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 941*de860bd9Sgfaden pt_to_str(PT_DEFROUTER), gettext("<IP-address>")); 942*de860bd9Sgfaden (void) fprintf(fp, gettext("%s %s and %s %s are valid " 943*de860bd9Sgfaden "if the %s property is set to %s, otherwise they " 944*de860bd9Sgfaden "must not be set.\n"), 945f4b3ec61Sdh cmd_to_str(CMD_SET), pt_to_str(PT_ADDRESS), 946*de860bd9Sgfaden cmd_to_str(CMD_SET), pt_to_str(PT_DEFROUTER), 947f4b3ec61Sdh pt_to_str(PT_IPTYPE), "shared"); 9487c478bd9Sstevel@tonic-gate break; 9497c478bd9Sstevel@tonic-gate case RT_DEVICE: 9507c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("The '%s' resource scope is " 9517c478bd9Sstevel@tonic-gate "used to configure a device node.\n"), 9527c478bd9Sstevel@tonic-gate rt_to_str(resource_scope)); 9537c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("Valid commands:\n")); 9547c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 9557c478bd9Sstevel@tonic-gate pt_to_str(PT_MATCH), gettext("<device-path>")); 9567c478bd9Sstevel@tonic-gate break; 9577c478bd9Sstevel@tonic-gate case RT_RCTL: 9587c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("The '%s' resource scope is " 9597c478bd9Sstevel@tonic-gate "used to configure a resource control.\n"), 9607c478bd9Sstevel@tonic-gate rt_to_str(resource_scope)); 9617c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("Valid commands:\n")); 9627c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 9637c478bd9Sstevel@tonic-gate pt_to_str(PT_NAME), gettext("<string>")); 9647c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s (%s=%s,%s=%s,%s=%s)\n", 9657c478bd9Sstevel@tonic-gate cmd_to_str(CMD_ADD), pt_to_str(PT_VALUE), 9667c478bd9Sstevel@tonic-gate pt_to_str(PT_PRIV), gettext("<priv-value>"), 9677c478bd9Sstevel@tonic-gate pt_to_str(PT_LIMIT), gettext("<number>"), 9687c478bd9Sstevel@tonic-gate pt_to_str(PT_ACTION), gettext("<action-value>")); 969ffbafc53Scomay (void) fprintf(fp, "\t%s %s (%s=%s,%s=%s,%s=%s)\n", 970ffbafc53Scomay cmd_to_str(CMD_REMOVE), pt_to_str(PT_VALUE), 971ffbafc53Scomay pt_to_str(PT_PRIV), gettext("<priv-value>"), 972ffbafc53Scomay pt_to_str(PT_LIMIT), gettext("<number>"), 973ffbafc53Scomay pt_to_str(PT_ACTION), gettext("<action-value>")); 9747c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s\n\t%s := privileged\n" 9757c478bd9Sstevel@tonic-gate "\t%s := none | deny\n", gettext("Where"), 9767c478bd9Sstevel@tonic-gate gettext("<priv-value>"), gettext("<action-value>")); 9777c478bd9Sstevel@tonic-gate break; 9787c478bd9Sstevel@tonic-gate case RT_ATTR: 9797c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("The '%s' resource scope is " 9807c478bd9Sstevel@tonic-gate "used to configure a generic attribute.\n"), 9817c478bd9Sstevel@tonic-gate rt_to_str(resource_scope)); 9827c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("Valid commands:\n")); 9837c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 9847c478bd9Sstevel@tonic-gate pt_to_str(PT_NAME), gettext("<name>")); 9857c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=boolean\n", 9867c478bd9Sstevel@tonic-gate cmd_to_str(CMD_SET), pt_to_str(PT_TYPE)); 9877c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=true | false\n", 9887c478bd9Sstevel@tonic-gate cmd_to_str(CMD_SET), pt_to_str(PT_VALUE)); 9897c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("or\n")); 9907c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=int\n", cmd_to_str(CMD_SET), 9917c478bd9Sstevel@tonic-gate pt_to_str(PT_TYPE)); 9927c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 9937c478bd9Sstevel@tonic-gate pt_to_str(PT_VALUE), gettext("<integer>")); 9947c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("or\n")); 9957c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=string\n", 9967c478bd9Sstevel@tonic-gate cmd_to_str(CMD_SET), pt_to_str(PT_TYPE)); 9977c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 9987c478bd9Sstevel@tonic-gate pt_to_str(PT_VALUE), gettext("<string>")); 9997c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("or\n")); 10007c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=uint\n", 10017c478bd9Sstevel@tonic-gate cmd_to_str(CMD_SET), pt_to_str(PT_TYPE)); 10027c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 10037c478bd9Sstevel@tonic-gate pt_to_str(PT_VALUE), gettext("<unsigned integer>")); 10047c478bd9Sstevel@tonic-gate break; 1005fa9e4066Sahrens case RT_DATASET: 1006fa9e4066Sahrens (void) fprintf(fp, gettext("The '%s' resource scope is " 1007fa9e4066Sahrens "used to export ZFS datasets.\n"), 1008fa9e4066Sahrens rt_to_str(resource_scope)); 1009fa9e4066Sahrens (void) fprintf(fp, gettext("Valid commands:\n")); 1010fa9e4066Sahrens (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 1011fa9e4066Sahrens pt_to_str(PT_NAME), gettext("<name>")); 1012fa9e4066Sahrens break; 10130209230bSgjelinek case RT_DCPU: 10140209230bSgjelinek (void) fprintf(fp, gettext("The '%s' resource scope " 10150209230bSgjelinek "configures the 'pools' facility to dedicate\na " 10160209230bSgjelinek "subset of the system's processors to this zone " 10170209230bSgjelinek "while it is running.\n"), 10180209230bSgjelinek rt_to_str(resource_scope)); 10190209230bSgjelinek (void) fprintf(fp, gettext("Valid commands:\n")); 10200209230bSgjelinek (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 10210209230bSgjelinek pt_to_str(PT_NCPUS), 10220209230bSgjelinek gettext("<unsigned integer | range>")); 10230209230bSgjelinek (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 10240209230bSgjelinek pt_to_str(PT_IMPORTANCE), 10250209230bSgjelinek gettext("<unsigned integer>")); 10260209230bSgjelinek break; 1027c97ad5cdSakolb case RT_PCAP: 1028c97ad5cdSakolb (void) fprintf(fp, gettext("The '%s' resource scope is " 1029c97ad5cdSakolb "used to set an upper limit (a cap) on the\n" 1030c97ad5cdSakolb "percentage of CPU that can be used by this zone. " 1031c97ad5cdSakolb "A '%s' value of 1\ncorresponds to one cpu. The " 1032c97ad5cdSakolb "value can be set higher than 1, up to the total\n" 1033c97ad5cdSakolb "number of CPUs on the system. The value can " 1034c97ad5cdSakolb "also be less than 1,\nrepresenting a fraction of " 1035c97ad5cdSakolb "a cpu.\n"), 1036c97ad5cdSakolb rt_to_str(resource_scope), pt_to_str(PT_NCPUS)); 1037c97ad5cdSakolb (void) fprintf(fp, gettext("Valid commands:\n")); 1038c97ad5cdSakolb (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 1039c97ad5cdSakolb pt_to_str(PT_NCPUS), gettext("<unsigned decimal>")); 1040c97ad5cdSakolb break; 10410209230bSgjelinek case RT_MCAP: 10420209230bSgjelinek (void) fprintf(fp, gettext("The '%s' resource scope is " 10430209230bSgjelinek "used to set an upper limit (a cap) on the\n" 10440209230bSgjelinek "amount of physical memory, swap space and locked " 10450209230bSgjelinek "memory that can be used by\nthis zone.\n"), 10460209230bSgjelinek rt_to_str(resource_scope)); 10470209230bSgjelinek (void) fprintf(fp, gettext("Valid commands:\n")); 10480209230bSgjelinek (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 10490209230bSgjelinek pt_to_str(PT_PHYSICAL), 10500209230bSgjelinek gettext("<qualified unsigned decimal>")); 10510209230bSgjelinek (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 10520209230bSgjelinek pt_to_str(PT_SWAP), 10530209230bSgjelinek gettext("<qualified unsigned decimal>")); 10540209230bSgjelinek (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 10550209230bSgjelinek pt_to_str(PT_LOCKED), 10560209230bSgjelinek gettext("<qualified unsigned decimal>")); 10570209230bSgjelinek break; 10587c478bd9Sstevel@tonic-gate } 10597c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("And from any resource scope, you " 10607c478bd9Sstevel@tonic-gate "can:\n")); 10617c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t%s\n", cmd_to_str(CMD_END), 10627c478bd9Sstevel@tonic-gate gettext("(to conclude this operation)")); 10637c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t%s\n", cmd_to_str(CMD_CANCEL), 10647c478bd9Sstevel@tonic-gate gettext("(to cancel this operation)")); 10657c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t%s\n", cmd_to_str(CMD_EXIT), 10667c478bd9Sstevel@tonic-gate gettext("(to exit the zonecfg utility)")); 10677c478bd9Sstevel@tonic-gate } 10687c478bd9Sstevel@tonic-gate if (flags & HELP_USAGE) { 10697c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s:\t%s %s\n", gettext("usage"), 10707c478bd9Sstevel@tonic-gate execname, cmd_to_str(CMD_HELP)); 10717c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s -z <zone>\t\t\t(%s)\n", 10727c478bd9Sstevel@tonic-gate execname, gettext("interactive")); 10737c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s -z <zone> <command>\n", execname); 10747c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s -z <zone> -f <command-file>\n", 10757c478bd9Sstevel@tonic-gate execname); 10767c478bd9Sstevel@tonic-gate } 10777c478bd9Sstevel@tonic-gate if (flags & HELP_SUBCMDS) { 10787c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s:\n\n", gettext("Commands")); 10797c478bd9Sstevel@tonic-gate for (i = 0; i <= CMD_MAX; i++) { 10807c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s\n", helptab[i].short_usage); 10817c478bd9Sstevel@tonic-gate if (verbose) 10827c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\n\n", long_help(i)); 10837c478bd9Sstevel@tonic-gate } 10847c478bd9Sstevel@tonic-gate } 10857c478bd9Sstevel@tonic-gate if (flags & HELP_SYNTAX) { 10867c478bd9Sstevel@tonic-gate if (!verbose) 10877c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\n"); 10887c478bd9Sstevel@tonic-gate (void) fprintf(fp, "<zone> := [A-Za-z0-9][A-Za-z0-9_.-]*\n"); 10897c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("\t(except the reserved words " 10907c478bd9Sstevel@tonic-gate "'%s' and anything starting with '%s')\n"), "global", 10917c478bd9Sstevel@tonic-gate "SUNW"); 10927c478bd9Sstevel@tonic-gate (void) fprintf(fp, 10937c478bd9Sstevel@tonic-gate gettext("\tName must be less than %d characters.\n"), 10947c478bd9Sstevel@tonic-gate ZONENAME_MAX); 10957c478bd9Sstevel@tonic-gate if (verbose) 10967c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\n"); 10977c478bd9Sstevel@tonic-gate } 10987c478bd9Sstevel@tonic-gate if (flags & HELP_NETADDR) { 10997c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("\n<net-addr> :=")); 11007c478bd9Sstevel@tonic-gate (void) fprintf(fp, 11017c478bd9Sstevel@tonic-gate gettext("\t<IPv4-address>[/<IPv4-prefix-length>] |\n")); 11027c478bd9Sstevel@tonic-gate (void) fprintf(fp, 11037c478bd9Sstevel@tonic-gate gettext("\t\t<IPv6-address>/<IPv6-prefix-length> |\n")); 11047c478bd9Sstevel@tonic-gate (void) fprintf(fp, 11057c478bd9Sstevel@tonic-gate gettext("\t\t<hostname>[/<IPv4-prefix-length>]\n")); 11067c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("See inet(3SOCKET) for IPv4 and " 11077c478bd9Sstevel@tonic-gate "IPv6 address syntax.\n")); 11087c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("<IPv4-prefix-length> := [0-32]\n")); 11097c478bd9Sstevel@tonic-gate (void) fprintf(fp, 11107c478bd9Sstevel@tonic-gate gettext("<IPv6-prefix-length> := [0-128]\n")); 11117c478bd9Sstevel@tonic-gate (void) fprintf(fp, 11127c478bd9Sstevel@tonic-gate gettext("<hostname> := [A-Za-z0-9][A-Za-z0-9-.]*\n")); 11137c478bd9Sstevel@tonic-gate } 11147c478bd9Sstevel@tonic-gate if (flags & HELP_RESOURCES) { 11159e7542f4Sdp (void) fprintf(fp, "<%s> := %s | %s | %s | %s | %s | %s |\n\t" 1116c97ad5cdSakolb "%s | %s | %s | %s\n\n", 11177c478bd9Sstevel@tonic-gate gettext("resource type"), rt_to_str(RT_FS), 11187c478bd9Sstevel@tonic-gate rt_to_str(RT_IPD), rt_to_str(RT_NET), rt_to_str(RT_DEVICE), 11199e7542f4Sdp rt_to_str(RT_RCTL), rt_to_str(RT_ATTR), 11200209230bSgjelinek rt_to_str(RT_DATASET), rt_to_str(RT_DCPU), 1121c97ad5cdSakolb rt_to_str(RT_PCAP), rt_to_str(RT_MCAP)); 11227c478bd9Sstevel@tonic-gate } 11237c478bd9Sstevel@tonic-gate if (flags & HELP_PROPS) { 11247c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("For resource type ... there are " 11257c478bd9Sstevel@tonic-gate "property types ...:\n")); 1126087719fdSdp (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 1127087719fdSdp pt_to_str(PT_ZONENAME)); 11287c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 11297c478bd9Sstevel@tonic-gate pt_to_str(PT_ZONEPATH)); 11309acbbeafSnn (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 11319acbbeafSnn pt_to_str(PT_BRAND)); 11327c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 11337c478bd9Sstevel@tonic-gate pt_to_str(PT_AUTOBOOT)); 11343f2f09c1Sdp (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 11353f2f09c1Sdp pt_to_str(PT_BOOTARGS)); 11367c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 11377c478bd9Sstevel@tonic-gate pt_to_str(PT_POOL)); 1138ffbafc53Scomay (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 1139ffbafc53Scomay pt_to_str(PT_LIMITPRIV)); 11400209230bSgjelinek (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 11410209230bSgjelinek pt_to_str(PT_SCHED)); 1142f4b3ec61Sdh (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 1143f4b3ec61Sdh pt_to_str(PT_IPTYPE)); 11440209230bSgjelinek (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 11450209230bSgjelinek pt_to_str(PT_MAXLWPS)); 11460209230bSgjelinek (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 11470209230bSgjelinek pt_to_str(PT_MAXSHMMEM)); 11480209230bSgjelinek (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 11490209230bSgjelinek pt_to_str(PT_MAXSHMIDS)); 11500209230bSgjelinek (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 11510209230bSgjelinek pt_to_str(PT_MAXMSGIDS)); 11520209230bSgjelinek (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 11530209230bSgjelinek pt_to_str(PT_MAXSEMIDS)); 11540209230bSgjelinek (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 11550209230bSgjelinek pt_to_str(PT_SHARES)); 11567c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t\t%s, %s, %s, %s\n", rt_to_str(RT_FS), 11577c478bd9Sstevel@tonic-gate pt_to_str(PT_DIR), pt_to_str(PT_SPECIAL), 11587c478bd9Sstevel@tonic-gate pt_to_str(PT_RAW), pt_to_str(PT_TYPE), 11597c478bd9Sstevel@tonic-gate pt_to_str(PT_OPTIONS)); 11607c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t%s\n", rt_to_str(RT_IPD), 11617c478bd9Sstevel@tonic-gate pt_to_str(PT_DIR)); 1162*de860bd9Sgfaden (void) fprintf(fp, "\t%s\t\t%s, %s, %s\n", rt_to_str(RT_NET), 1163*de860bd9Sgfaden pt_to_str(PT_ADDRESS), pt_to_str(PT_PHYSICAL), 1164*de860bd9Sgfaden pt_to_str(PT_DEFROUTER)); 11657c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t\t%s\n", rt_to_str(RT_DEVICE), 11667c478bd9Sstevel@tonic-gate pt_to_str(PT_MATCH)); 11677c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t\t%s, %s\n", rt_to_str(RT_RCTL), 11687c478bd9Sstevel@tonic-gate pt_to_str(PT_NAME), pt_to_str(PT_VALUE)); 11697c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t\t%s, %s, %s\n", rt_to_str(RT_ATTR), 11707c478bd9Sstevel@tonic-gate pt_to_str(PT_NAME), pt_to_str(PT_TYPE), 11717c478bd9Sstevel@tonic-gate pt_to_str(PT_VALUE)); 1172fa9e4066Sahrens (void) fprintf(fp, "\t%s\t\t%s\n", rt_to_str(RT_DATASET), 1173fa9e4066Sahrens pt_to_str(PT_NAME)); 11740209230bSgjelinek (void) fprintf(fp, "\t%s\t%s, %s\n", rt_to_str(RT_DCPU), 11750209230bSgjelinek pt_to_str(PT_NCPUS), pt_to_str(PT_IMPORTANCE)); 1176c97ad5cdSakolb (void) fprintf(fp, "\t%s\t%s\n", rt_to_str(RT_PCAP), 1177c97ad5cdSakolb pt_to_str(PT_NCPUS)); 11780209230bSgjelinek (void) fprintf(fp, "\t%s\t%s, %s, %s\n", rt_to_str(RT_MCAP), 11790209230bSgjelinek pt_to_str(PT_PHYSICAL), pt_to_str(PT_SWAP), 11800209230bSgjelinek pt_to_str(PT_LOCKED)); 11817c478bd9Sstevel@tonic-gate } 11827c478bd9Sstevel@tonic-gate if (need_to_close) 11837c478bd9Sstevel@tonic-gate (void) pclose(fp); 11847c478bd9Sstevel@tonic-gate } 11857c478bd9Sstevel@tonic-gate 11867c478bd9Sstevel@tonic-gate /* PRINTFLIKE1 */ 11877c478bd9Sstevel@tonic-gate static void 11887c478bd9Sstevel@tonic-gate zerr(const char *fmt, ...) 11897c478bd9Sstevel@tonic-gate { 11907c478bd9Sstevel@tonic-gate va_list alist; 11917c478bd9Sstevel@tonic-gate static int last_lineno; 11927c478bd9Sstevel@tonic-gate 11937c478bd9Sstevel@tonic-gate /* lex_lineno has already been incremented in the lexer; compensate */ 11947c478bd9Sstevel@tonic-gate if (cmd_file_mode && lex_lineno > last_lineno) { 11957c478bd9Sstevel@tonic-gate if (strcmp(cmd_file_name, "-") == 0) 11967c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("On line %d:\n"), 11977c478bd9Sstevel@tonic-gate lex_lineno - 1); 11987c478bd9Sstevel@tonic-gate else 11997c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("On line %d of %s:\n"), 12007c478bd9Sstevel@tonic-gate lex_lineno - 1, cmd_file_name); 12017c478bd9Sstevel@tonic-gate last_lineno = lex_lineno; 12027c478bd9Sstevel@tonic-gate } 12037c478bd9Sstevel@tonic-gate va_start(alist, fmt); 12047c478bd9Sstevel@tonic-gate (void) vfprintf(stderr, fmt, alist); 12057c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "\n"); 12067c478bd9Sstevel@tonic-gate va_end(alist); 12077c478bd9Sstevel@tonic-gate } 12087c478bd9Sstevel@tonic-gate 12097c478bd9Sstevel@tonic-gate static void 12107c478bd9Sstevel@tonic-gate zone_perror(char *prefix, int err, bool set_saw) 12117c478bd9Sstevel@tonic-gate { 12127c478bd9Sstevel@tonic-gate zerr("%s: %s", prefix, zonecfg_strerror(err)); 12137c478bd9Sstevel@tonic-gate if (set_saw) 12147c478bd9Sstevel@tonic-gate saw_error = TRUE; 12157c478bd9Sstevel@tonic-gate } 12167c478bd9Sstevel@tonic-gate 12177c478bd9Sstevel@tonic-gate /* 12187c478bd9Sstevel@tonic-gate * zone_perror() expects a single string, but for remove and select 12197c478bd9Sstevel@tonic-gate * we have both the command and the resource type, so this wrapper 12207c478bd9Sstevel@tonic-gate * function serves the same purpose in a slightly different way. 12217c478bd9Sstevel@tonic-gate */ 12227c478bd9Sstevel@tonic-gate 12237c478bd9Sstevel@tonic-gate static void 12247c478bd9Sstevel@tonic-gate z_cmd_rt_perror(int cmd_num, int res_num, int err, bool set_saw) 12257c478bd9Sstevel@tonic-gate { 12267c478bd9Sstevel@tonic-gate zerr("%s %s: %s", cmd_to_str(cmd_num), rt_to_str(res_num), 12277c478bd9Sstevel@tonic-gate zonecfg_strerror(err)); 12287c478bd9Sstevel@tonic-gate if (set_saw) 12297c478bd9Sstevel@tonic-gate saw_error = TRUE; 12307c478bd9Sstevel@tonic-gate } 12317c478bd9Sstevel@tonic-gate 12327c478bd9Sstevel@tonic-gate /* returns Z_OK if successful, Z_foo from <libzonecfg.h> otherwise */ 12337c478bd9Sstevel@tonic-gate static int 12347c478bd9Sstevel@tonic-gate initialize(bool handle_expected) 12357c478bd9Sstevel@tonic-gate { 12367c478bd9Sstevel@tonic-gate int err; 12379acbbeafSnn char brandname[MAXNAMELEN]; 12387c478bd9Sstevel@tonic-gate 12397c478bd9Sstevel@tonic-gate if (zonecfg_check_handle(handle) != Z_OK) { 12407c478bd9Sstevel@tonic-gate if ((err = zonecfg_get_handle(zone, handle)) == Z_OK) { 12417c478bd9Sstevel@tonic-gate got_handle = TRUE; 12429acbbeafSnn if (zonecfg_get_brand(handle, brandname, 12439acbbeafSnn sizeof (brandname)) != Z_OK) { 12449acbbeafSnn zerr("Zone %s is inconsistent: missing " 12459acbbeafSnn "brand attribute", zone); 12469acbbeafSnn exit(Z_ERR); 12479acbbeafSnn } 12489acbbeafSnn if ((brand = brand_open(brandname)) == NULL) { 12499acbbeafSnn zerr("Zone %s uses non-existent brand \"%s\"." 12509acbbeafSnn " Unable to continue", zone, brandname); 12519acbbeafSnn exit(Z_ERR); 12529acbbeafSnn } 12530209230bSgjelinek } else if (global_zone && err == Z_NO_ZONE && !got_handle && 12540209230bSgjelinek !read_only_mode) { 12550209230bSgjelinek /* 12560209230bSgjelinek * We implicitly create the global zone config if it 12570209230bSgjelinek * doesn't exist. 12580209230bSgjelinek */ 12590209230bSgjelinek zone_dochandle_t tmphandle; 12600209230bSgjelinek 12610209230bSgjelinek if ((tmphandle = zonecfg_init_handle()) == NULL) { 12620209230bSgjelinek zone_perror(execname, Z_NOMEM, TRUE); 12630209230bSgjelinek exit(Z_ERR); 12640209230bSgjelinek } 12650209230bSgjelinek 12660209230bSgjelinek err = zonecfg_get_template_handle("SUNWblank", zone, 12670209230bSgjelinek tmphandle); 12680209230bSgjelinek 12690209230bSgjelinek if (err != Z_OK) { 12700209230bSgjelinek zonecfg_fini_handle(tmphandle); 12710209230bSgjelinek zone_perror("SUNWblank", err, TRUE); 12720209230bSgjelinek return (err); 12730209230bSgjelinek } 12740209230bSgjelinek 12750209230bSgjelinek need_to_commit = TRUE; 12760209230bSgjelinek zonecfg_fini_handle(handle); 12770209230bSgjelinek handle = tmphandle; 12780209230bSgjelinek got_handle = TRUE; 12790209230bSgjelinek 12807c478bd9Sstevel@tonic-gate } else { 12817c478bd9Sstevel@tonic-gate zone_perror(zone, err, handle_expected || got_handle); 12827c478bd9Sstevel@tonic-gate if (err == Z_NO_ZONE && !got_handle && 12837c478bd9Sstevel@tonic-gate interactive_mode && !read_only_mode) 12847c478bd9Sstevel@tonic-gate (void) printf(gettext("Use '%s' to begin " 12857c478bd9Sstevel@tonic-gate "configuring a new zone.\n"), 12867c478bd9Sstevel@tonic-gate cmd_to_str(CMD_CREATE)); 12877c478bd9Sstevel@tonic-gate return (err); 12887c478bd9Sstevel@tonic-gate } 12897c478bd9Sstevel@tonic-gate } 12907c478bd9Sstevel@tonic-gate return (Z_OK); 12917c478bd9Sstevel@tonic-gate } 12927c478bd9Sstevel@tonic-gate 1293087719fdSdp static bool 1294087719fdSdp state_atleast(zone_state_t state) 1295087719fdSdp { 1296087719fdSdp zone_state_t state_num; 1297087719fdSdp int err; 1298087719fdSdp 1299087719fdSdp if ((err = zone_get_state(zone, &state_num)) != Z_OK) { 1300087719fdSdp /* all states are greater than "non-existent" */ 1301087719fdSdp if (err == Z_NO_ZONE) 1302087719fdSdp return (B_FALSE); 1303087719fdSdp zerr(gettext("Unexpectedly failed to determine state " 1304087719fdSdp "of zone %s: %s"), zone, zonecfg_strerror(err)); 1305087719fdSdp exit(Z_ERR); 1306087719fdSdp } 1307087719fdSdp return (state_num >= state); 1308087719fdSdp } 1309087719fdSdp 13107c478bd9Sstevel@tonic-gate /* 13117c478bd9Sstevel@tonic-gate * short_usage() is for bad syntax: getopt() issues, too many arguments, etc. 13127c478bd9Sstevel@tonic-gate */ 13137c478bd9Sstevel@tonic-gate 13147c478bd9Sstevel@tonic-gate void 13157c478bd9Sstevel@tonic-gate short_usage(int command) 13167c478bd9Sstevel@tonic-gate { 13177c478bd9Sstevel@tonic-gate /* lex_lineno has already been incremented in the lexer; compensate */ 13187c478bd9Sstevel@tonic-gate if (cmd_file_mode) { 13197c478bd9Sstevel@tonic-gate if (strcmp(cmd_file_name, "-") == 0) 13207c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 13217c478bd9Sstevel@tonic-gate gettext("syntax error on line %d\n"), 13227c478bd9Sstevel@tonic-gate lex_lineno - 1); 13237c478bd9Sstevel@tonic-gate else 13247c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 13257c478bd9Sstevel@tonic-gate gettext("syntax error on line %d of %s\n"), 13267c478bd9Sstevel@tonic-gate lex_lineno - 1, cmd_file_name); 13277c478bd9Sstevel@tonic-gate } 13287c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "%s:\n%s\n", gettext("usage"), 13297c478bd9Sstevel@tonic-gate helptab[command].short_usage); 13307c478bd9Sstevel@tonic-gate saw_error = TRUE; 13317c478bd9Sstevel@tonic-gate } 13327c478bd9Sstevel@tonic-gate 13337c478bd9Sstevel@tonic-gate /* 13347c478bd9Sstevel@tonic-gate * long_usage() is for bad semantics: e.g., wrong property type for a given 13357c478bd9Sstevel@tonic-gate * resource type. It is also used by longer_usage() below. 13367c478bd9Sstevel@tonic-gate */ 13377c478bd9Sstevel@tonic-gate 13387c478bd9Sstevel@tonic-gate void 13397c478bd9Sstevel@tonic-gate long_usage(uint_t cmd_num, bool set_saw) 13407c478bd9Sstevel@tonic-gate { 13417c478bd9Sstevel@tonic-gate (void) fprintf(set_saw ? stderr : stdout, "%s:\n%s\n", gettext("usage"), 13427c478bd9Sstevel@tonic-gate helptab[cmd_num].short_usage); 13437c478bd9Sstevel@tonic-gate (void) fprintf(set_saw ? stderr : stdout, "\t%s\n", long_help(cmd_num)); 13447c478bd9Sstevel@tonic-gate if (set_saw) 13457c478bd9Sstevel@tonic-gate saw_error = TRUE; 13467c478bd9Sstevel@tonic-gate } 13477c478bd9Sstevel@tonic-gate 13487c478bd9Sstevel@tonic-gate /* 13497c478bd9Sstevel@tonic-gate * longer_usage() is for 'help foo' and 'foo -?': call long_usage() and also 13507c478bd9Sstevel@tonic-gate * any extra usage() flags as appropriate for whatever command. 13517c478bd9Sstevel@tonic-gate */ 13527c478bd9Sstevel@tonic-gate 13537c478bd9Sstevel@tonic-gate void 13547c478bd9Sstevel@tonic-gate longer_usage(uint_t cmd_num) 13557c478bd9Sstevel@tonic-gate { 13567c478bd9Sstevel@tonic-gate long_usage(cmd_num, FALSE); 13577c478bd9Sstevel@tonic-gate if (helptab[cmd_num].flags != 0) { 13587c478bd9Sstevel@tonic-gate (void) printf("\n"); 13597c478bd9Sstevel@tonic-gate usage(TRUE, helptab[cmd_num].flags); 13607c478bd9Sstevel@tonic-gate } 13617c478bd9Sstevel@tonic-gate } 13627c478bd9Sstevel@tonic-gate 13637c478bd9Sstevel@tonic-gate /* 13647c478bd9Sstevel@tonic-gate * scope_usage() is simply used when a command is called from the wrong scope. 13657c478bd9Sstevel@tonic-gate */ 13667c478bd9Sstevel@tonic-gate 13677c478bd9Sstevel@tonic-gate static void 13687c478bd9Sstevel@tonic-gate scope_usage(uint_t cmd_num) 13697c478bd9Sstevel@tonic-gate { 13707c478bd9Sstevel@tonic-gate zerr(gettext("The %s command only makes sense in the %s scope."), 13717c478bd9Sstevel@tonic-gate cmd_to_str(cmd_num), 13727c478bd9Sstevel@tonic-gate global_scope ? gettext("resource") : gettext("global")); 13737c478bd9Sstevel@tonic-gate saw_error = TRUE; 13747c478bd9Sstevel@tonic-gate } 13757c478bd9Sstevel@tonic-gate 13767c478bd9Sstevel@tonic-gate /* 13777c478bd9Sstevel@tonic-gate * On input, TRUE => yes, FALSE => no. 13787c478bd9Sstevel@tonic-gate * On return, TRUE => 1, FALSE => no, could not ask => -1. 13797c478bd9Sstevel@tonic-gate */ 13807c478bd9Sstevel@tonic-gate 13817c478bd9Sstevel@tonic-gate static int 13827c478bd9Sstevel@tonic-gate ask_yesno(bool default_answer, const char *question) 13837c478bd9Sstevel@tonic-gate { 13847c478bd9Sstevel@tonic-gate char line[64]; /* should be enough to answer yes or no */ 13857c478bd9Sstevel@tonic-gate 13867c478bd9Sstevel@tonic-gate if (!ok_to_prompt) { 13877c478bd9Sstevel@tonic-gate saw_error = TRUE; 13887c478bd9Sstevel@tonic-gate return (-1); 13897c478bd9Sstevel@tonic-gate } 13907c478bd9Sstevel@tonic-gate for (;;) { 1391087719fdSdp if (printf("%s (%s)? ", question, 1392087719fdSdp default_answer ? "[y]/n" : "y/[n]") < 0) 1393087719fdSdp return (-1); 1394087719fdSdp if (fgets(line, sizeof (line), stdin) == NULL) 1395087719fdSdp return (-1); 1396087719fdSdp 1397087719fdSdp if (line[0] == '\n') 13987c478bd9Sstevel@tonic-gate return (default_answer ? 1 : 0); 13997c478bd9Sstevel@tonic-gate if (tolower(line[0]) == 'y') 14007c478bd9Sstevel@tonic-gate return (1); 14017c478bd9Sstevel@tonic-gate if (tolower(line[0]) == 'n') 14027c478bd9Sstevel@tonic-gate return (0); 14037c478bd9Sstevel@tonic-gate } 14047c478bd9Sstevel@tonic-gate } 14057c478bd9Sstevel@tonic-gate 14067c478bd9Sstevel@tonic-gate /* 14077c478bd9Sstevel@tonic-gate * Prints warning if zone already exists. 14087c478bd9Sstevel@tonic-gate * In interactive mode, prompts if we should continue anyway and returns Z_OK 14097c478bd9Sstevel@tonic-gate * if so, Z_ERR if not. In non-interactive mode, exits with Z_ERR. 14107c478bd9Sstevel@tonic-gate * 14117c478bd9Sstevel@tonic-gate * Note that if a zone exists and its state is >= INSTALLED, an error message 14127c478bd9Sstevel@tonic-gate * will be printed and this function will return Z_ERR regardless of mode. 14137c478bd9Sstevel@tonic-gate */ 14147c478bd9Sstevel@tonic-gate 14157c478bd9Sstevel@tonic-gate static int 14167c478bd9Sstevel@tonic-gate check_if_zone_already_exists(bool force) 14177c478bd9Sstevel@tonic-gate { 14187c478bd9Sstevel@tonic-gate char line[ZONENAME_MAX + 128]; /* enough to ask a question */ 14197c478bd9Sstevel@tonic-gate zone_dochandle_t tmphandle; 14207c478bd9Sstevel@tonic-gate int res, answer; 14217c478bd9Sstevel@tonic-gate 14227c478bd9Sstevel@tonic-gate if ((tmphandle = zonecfg_init_handle()) == NULL) { 14237c478bd9Sstevel@tonic-gate zone_perror(execname, Z_NOMEM, TRUE); 14247c478bd9Sstevel@tonic-gate exit(Z_ERR); 14257c478bd9Sstevel@tonic-gate } 14267c478bd9Sstevel@tonic-gate res = zonecfg_get_handle(zone, tmphandle); 14277c478bd9Sstevel@tonic-gate zonecfg_fini_handle(tmphandle); 1428087719fdSdp if (res != Z_OK) 14297c478bd9Sstevel@tonic-gate return (Z_OK); 1430087719fdSdp 1431087719fdSdp if (state_atleast(ZONE_STATE_INSTALLED)) { 14327c478bd9Sstevel@tonic-gate zerr(gettext("Zone %s already installed; %s not allowed."), 14337c478bd9Sstevel@tonic-gate zone, cmd_to_str(CMD_CREATE)); 14347c478bd9Sstevel@tonic-gate return (Z_ERR); 14357c478bd9Sstevel@tonic-gate } 14367c478bd9Sstevel@tonic-gate 14377c478bd9Sstevel@tonic-gate if (force) { 14387c478bd9Sstevel@tonic-gate (void) printf(gettext("Zone %s already exists; overwriting.\n"), 14397c478bd9Sstevel@tonic-gate zone); 14407c478bd9Sstevel@tonic-gate return (Z_OK); 14417c478bd9Sstevel@tonic-gate } 14427c478bd9Sstevel@tonic-gate (void) snprintf(line, sizeof (line), 14437c478bd9Sstevel@tonic-gate gettext("Zone %s already exists; %s anyway"), zone, 14447c478bd9Sstevel@tonic-gate cmd_to_str(CMD_CREATE)); 14457c478bd9Sstevel@tonic-gate if ((answer = ask_yesno(FALSE, line)) == -1) { 14467c478bd9Sstevel@tonic-gate zerr(gettext("Zone exists, input not from terminal and -F not " 14477c478bd9Sstevel@tonic-gate "specified:\n%s command ignored, exiting."), 14487c478bd9Sstevel@tonic-gate cmd_to_str(CMD_CREATE)); 14497c478bd9Sstevel@tonic-gate exit(Z_ERR); 14507c478bd9Sstevel@tonic-gate } 14517c478bd9Sstevel@tonic-gate return (answer == 1 ? Z_OK : Z_ERR); 14527c478bd9Sstevel@tonic-gate } 14537c478bd9Sstevel@tonic-gate 14547c478bd9Sstevel@tonic-gate static bool 14557c478bd9Sstevel@tonic-gate zone_is_read_only(int cmd_num) 14567c478bd9Sstevel@tonic-gate { 14577c478bd9Sstevel@tonic-gate if (strncmp(zone, "SUNW", 4) == 0) { 14587c478bd9Sstevel@tonic-gate zerr(gettext("%s: zones beginning with SUNW are read-only."), 14597c478bd9Sstevel@tonic-gate zone); 14607c478bd9Sstevel@tonic-gate saw_error = TRUE; 14617c478bd9Sstevel@tonic-gate return (TRUE); 14627c478bd9Sstevel@tonic-gate } 14637c478bd9Sstevel@tonic-gate if (read_only_mode) { 14647c478bd9Sstevel@tonic-gate zerr(gettext("%s: cannot %s in read-only mode."), zone, 14657c478bd9Sstevel@tonic-gate cmd_to_str(cmd_num)); 14667c478bd9Sstevel@tonic-gate saw_error = TRUE; 14677c478bd9Sstevel@tonic-gate return (TRUE); 14687c478bd9Sstevel@tonic-gate } 14697c478bd9Sstevel@tonic-gate return (FALSE); 14707c478bd9Sstevel@tonic-gate } 14717c478bd9Sstevel@tonic-gate 14727c478bd9Sstevel@tonic-gate /* 14737c478bd9Sstevel@tonic-gate * Create a new configuration. 14747c478bd9Sstevel@tonic-gate */ 14757c478bd9Sstevel@tonic-gate void 14767c478bd9Sstevel@tonic-gate create_func(cmd_t *cmd) 14777c478bd9Sstevel@tonic-gate { 14787c478bd9Sstevel@tonic-gate int err, arg; 14797c478bd9Sstevel@tonic-gate char zone_template[ZONENAME_MAX]; 1480ee519a1fSgjelinek char attach_path[MAXPATHLEN]; 14817c478bd9Sstevel@tonic-gate zone_dochandle_t tmphandle; 14827c478bd9Sstevel@tonic-gate bool force = FALSE; 1483ee519a1fSgjelinek bool attach = FALSE; 14847ec75eb8Sgjelinek bool arg_err = FALSE; 14857c478bd9Sstevel@tonic-gate 14867c478bd9Sstevel@tonic-gate assert(cmd != NULL); 14877c478bd9Sstevel@tonic-gate 14887c478bd9Sstevel@tonic-gate /* This is the default if no arguments are given. */ 14897c478bd9Sstevel@tonic-gate (void) strlcpy(zone_template, "SUNWdefault", sizeof (zone_template)); 14907c478bd9Sstevel@tonic-gate 14917c478bd9Sstevel@tonic-gate optind = 0; 14929acbbeafSnn while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?a:bFt:")) 14939acbbeafSnn != EOF) { 14947c478bd9Sstevel@tonic-gate switch (arg) { 14957c478bd9Sstevel@tonic-gate case '?': 14967c478bd9Sstevel@tonic-gate if (optopt == '?') 14977c478bd9Sstevel@tonic-gate longer_usage(CMD_CREATE); 14987c478bd9Sstevel@tonic-gate else 14997c478bd9Sstevel@tonic-gate short_usage(CMD_CREATE); 15007ec75eb8Sgjelinek arg_err = TRUE; 15017ec75eb8Sgjelinek break; 1502ee519a1fSgjelinek case 'a': 1503ee519a1fSgjelinek (void) strlcpy(attach_path, optarg, 1504ee519a1fSgjelinek sizeof (attach_path)); 1505ee519a1fSgjelinek attach = TRUE; 1506ee519a1fSgjelinek break; 15077c478bd9Sstevel@tonic-gate case 'b': 15087c478bd9Sstevel@tonic-gate (void) strlcpy(zone_template, "SUNWblank", 15097c478bd9Sstevel@tonic-gate sizeof (zone_template)); 15107c478bd9Sstevel@tonic-gate break; 15117c478bd9Sstevel@tonic-gate case 'F': 15127c478bd9Sstevel@tonic-gate force = TRUE; 15137c478bd9Sstevel@tonic-gate break; 15147c478bd9Sstevel@tonic-gate case 't': 15157c478bd9Sstevel@tonic-gate (void) strlcpy(zone_template, optarg, 15167c478bd9Sstevel@tonic-gate sizeof (zone_template)); 15177c478bd9Sstevel@tonic-gate break; 15187c478bd9Sstevel@tonic-gate default: 15197c478bd9Sstevel@tonic-gate short_usage(CMD_CREATE); 15207ec75eb8Sgjelinek arg_err = TRUE; 15217ec75eb8Sgjelinek break; 15227c478bd9Sstevel@tonic-gate } 15237c478bd9Sstevel@tonic-gate } 15247ec75eb8Sgjelinek if (arg_err) 15257ec75eb8Sgjelinek return; 15267ec75eb8Sgjelinek 15277c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 15287c478bd9Sstevel@tonic-gate short_usage(CMD_CREATE); 15297c478bd9Sstevel@tonic-gate return; 15307c478bd9Sstevel@tonic-gate } 15317c478bd9Sstevel@tonic-gate 15327c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_CREATE)) 15337c478bd9Sstevel@tonic-gate return; 15347c478bd9Sstevel@tonic-gate 15357c478bd9Sstevel@tonic-gate if (check_if_zone_already_exists(force) != Z_OK) 15367c478bd9Sstevel@tonic-gate return; 15377c478bd9Sstevel@tonic-gate 15387c478bd9Sstevel@tonic-gate /* 15397c478bd9Sstevel@tonic-gate * Get a temporary handle first. If that fails, the old handle 15407c478bd9Sstevel@tonic-gate * will not be lost. Then finish whichever one we don't need, 15417c478bd9Sstevel@tonic-gate * to avoid leaks. Then get the handle for zone_template, and 15427c478bd9Sstevel@tonic-gate * set the name to zone: this "copy, rename" method is how 15437c478bd9Sstevel@tonic-gate * create -[b|t] works. 15447c478bd9Sstevel@tonic-gate */ 15457c478bd9Sstevel@tonic-gate if ((tmphandle = zonecfg_init_handle()) == NULL) { 15467c478bd9Sstevel@tonic-gate zone_perror(execname, Z_NOMEM, TRUE); 15477c478bd9Sstevel@tonic-gate exit(Z_ERR); 15487c478bd9Sstevel@tonic-gate } 1549ee519a1fSgjelinek 1550ee519a1fSgjelinek if (attach) 1551ee519a1fSgjelinek err = zonecfg_get_attach_handle(attach_path, zone, B_FALSE, 1552ee519a1fSgjelinek tmphandle); 1553ee519a1fSgjelinek else 1554ee519a1fSgjelinek err = zonecfg_get_template_handle(zone_template, zone, 1555ee519a1fSgjelinek tmphandle); 1556ee519a1fSgjelinek 1557ee519a1fSgjelinek if (err != Z_OK) { 15587c478bd9Sstevel@tonic-gate zonecfg_fini_handle(tmphandle); 1559ee519a1fSgjelinek if (attach && err == Z_NO_ZONE) 1560ee519a1fSgjelinek (void) fprintf(stderr, gettext("invalid path to " 1561ee519a1fSgjelinek "detached zone\n")); 1562ee519a1fSgjelinek else if (attach && err == Z_INVALID_DOCUMENT) 1563ee519a1fSgjelinek (void) fprintf(stderr, gettext("Cannot attach to an " 1564ee519a1fSgjelinek "earlier release of the operating system\n")); 1565ee519a1fSgjelinek else 1566ee519a1fSgjelinek zone_perror(zone_template, err, TRUE); 15677c478bd9Sstevel@tonic-gate return; 15687c478bd9Sstevel@tonic-gate } 1569087719fdSdp 1570087719fdSdp need_to_commit = TRUE; 15717c478bd9Sstevel@tonic-gate zonecfg_fini_handle(handle); 15727c478bd9Sstevel@tonic-gate handle = tmphandle; 1573087719fdSdp got_handle = TRUE; 15747c478bd9Sstevel@tonic-gate } 15757c478bd9Sstevel@tonic-gate 15767c478bd9Sstevel@tonic-gate /* 15777c478bd9Sstevel@tonic-gate * This malloc()'s memory, which must be freed by the caller. 15787c478bd9Sstevel@tonic-gate */ 15797c478bd9Sstevel@tonic-gate static char * 15807c478bd9Sstevel@tonic-gate quoteit(char *instr) 15817c478bd9Sstevel@tonic-gate { 15827c478bd9Sstevel@tonic-gate char *outstr; 15837c478bd9Sstevel@tonic-gate size_t outstrsize = strlen(instr) + 3; /* 2 quotes + '\0' */ 15847c478bd9Sstevel@tonic-gate 15857c478bd9Sstevel@tonic-gate if ((outstr = malloc(outstrsize)) == NULL) { 15867c478bd9Sstevel@tonic-gate zone_perror(zone, Z_NOMEM, FALSE); 15877c478bd9Sstevel@tonic-gate exit(Z_ERR); 15887c478bd9Sstevel@tonic-gate } 15897c478bd9Sstevel@tonic-gate if (strchr(instr, ' ') == NULL) { 15907c478bd9Sstevel@tonic-gate (void) strlcpy(outstr, instr, outstrsize); 15917c478bd9Sstevel@tonic-gate return (outstr); 15927c478bd9Sstevel@tonic-gate } 15937c478bd9Sstevel@tonic-gate (void) snprintf(outstr, outstrsize, "\"%s\"", instr); 15947c478bd9Sstevel@tonic-gate return (outstr); 15957c478bd9Sstevel@tonic-gate } 15967c478bd9Sstevel@tonic-gate 15977c478bd9Sstevel@tonic-gate static void 15987c478bd9Sstevel@tonic-gate export_prop(FILE *of, int prop_num, char *prop_id) 15997c478bd9Sstevel@tonic-gate { 16007c478bd9Sstevel@tonic-gate char *quote_str; 16017c478bd9Sstevel@tonic-gate 16027c478bd9Sstevel@tonic-gate if (strlen(prop_id) == 0) 16037c478bd9Sstevel@tonic-gate return; 16047c478bd9Sstevel@tonic-gate quote_str = quoteit(prop_id); 16057c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 16067c478bd9Sstevel@tonic-gate pt_to_str(prop_num), quote_str); 16077c478bd9Sstevel@tonic-gate free(quote_str); 16087c478bd9Sstevel@tonic-gate } 16097c478bd9Sstevel@tonic-gate 16107c478bd9Sstevel@tonic-gate void 16117c478bd9Sstevel@tonic-gate export_func(cmd_t *cmd) 16127c478bd9Sstevel@tonic-gate { 16137c478bd9Sstevel@tonic-gate struct zone_nwiftab nwiftab; 16147c478bd9Sstevel@tonic-gate struct zone_fstab fstab; 16157c478bd9Sstevel@tonic-gate struct zone_devtab devtab; 16167c478bd9Sstevel@tonic-gate struct zone_attrtab attrtab; 16177c478bd9Sstevel@tonic-gate struct zone_rctltab rctltab; 1618fa9e4066Sahrens struct zone_dstab dstab; 16190209230bSgjelinek struct zone_psettab psettab; 16200209230bSgjelinek struct zone_mcaptab mcaptab; 16217c478bd9Sstevel@tonic-gate struct zone_rctlvaltab *valptr; 16227c478bd9Sstevel@tonic-gate int err, arg; 16237c478bd9Sstevel@tonic-gate char zonepath[MAXPATHLEN], outfile[MAXPATHLEN], pool[MAXNAMELEN]; 16243f2f09c1Sdp char bootargs[BOOTARGS_MAX]; 16250209230bSgjelinek char sched[MAXNAMELEN]; 16269acbbeafSnn char brand[MAXNAMELEN]; 1627ffbafc53Scomay char *limitpriv; 16287c478bd9Sstevel@tonic-gate FILE *of; 16297c478bd9Sstevel@tonic-gate boolean_t autoboot; 1630f4b3ec61Sdh zone_iptype_t iptype; 16317c478bd9Sstevel@tonic-gate bool need_to_close = FALSE; 16327ec75eb8Sgjelinek bool arg_err = FALSE; 16337c478bd9Sstevel@tonic-gate 16347c478bd9Sstevel@tonic-gate assert(cmd != NULL); 16357c478bd9Sstevel@tonic-gate 16367c478bd9Sstevel@tonic-gate outfile[0] = '\0'; 16377c478bd9Sstevel@tonic-gate optind = 0; 16387c478bd9Sstevel@tonic-gate while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?f:")) != EOF) { 16397c478bd9Sstevel@tonic-gate switch (arg) { 16407c478bd9Sstevel@tonic-gate case '?': 16417c478bd9Sstevel@tonic-gate if (optopt == '?') 16427c478bd9Sstevel@tonic-gate longer_usage(CMD_EXPORT); 16437c478bd9Sstevel@tonic-gate else 16447c478bd9Sstevel@tonic-gate short_usage(CMD_EXPORT); 16457ec75eb8Sgjelinek arg_err = TRUE; 16467ec75eb8Sgjelinek break; 16477c478bd9Sstevel@tonic-gate case 'f': 16487c478bd9Sstevel@tonic-gate (void) strlcpy(outfile, optarg, sizeof (outfile)); 16497c478bd9Sstevel@tonic-gate break; 16507c478bd9Sstevel@tonic-gate default: 16517c478bd9Sstevel@tonic-gate short_usage(CMD_EXPORT); 16527ec75eb8Sgjelinek arg_err = TRUE; 16537ec75eb8Sgjelinek break; 16547c478bd9Sstevel@tonic-gate } 16557c478bd9Sstevel@tonic-gate } 16567ec75eb8Sgjelinek if (arg_err) 16577ec75eb8Sgjelinek return; 16587ec75eb8Sgjelinek 16597c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 16607c478bd9Sstevel@tonic-gate short_usage(CMD_EXPORT); 16617c478bd9Sstevel@tonic-gate return; 16627c478bd9Sstevel@tonic-gate } 16637c478bd9Sstevel@tonic-gate if (strlen(outfile) == 0) { 16647c478bd9Sstevel@tonic-gate of = stdout; 16657c478bd9Sstevel@tonic-gate } else { 16667c478bd9Sstevel@tonic-gate if ((of = fopen(outfile, "w")) == NULL) { 16677c478bd9Sstevel@tonic-gate zerr(gettext("opening file %s: %s"), 16687c478bd9Sstevel@tonic-gate outfile, strerror(errno)); 16697c478bd9Sstevel@tonic-gate goto done; 16707c478bd9Sstevel@tonic-gate } 16717c478bd9Sstevel@tonic-gate setbuf(of, NULL); 16727c478bd9Sstevel@tonic-gate need_to_close = TRUE; 16737c478bd9Sstevel@tonic-gate } 16747c478bd9Sstevel@tonic-gate 16757c478bd9Sstevel@tonic-gate if ((err = initialize(TRUE)) != Z_OK) 16767c478bd9Sstevel@tonic-gate goto done; 16777c478bd9Sstevel@tonic-gate 16787c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s -b\n", cmd_to_str(CMD_CREATE)); 16797c478bd9Sstevel@tonic-gate 16807c478bd9Sstevel@tonic-gate if (zonecfg_get_zonepath(handle, zonepath, sizeof (zonepath)) == Z_OK && 16817c478bd9Sstevel@tonic-gate strlen(zonepath) > 0) 16827c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 16837c478bd9Sstevel@tonic-gate pt_to_str(PT_ZONEPATH), zonepath); 16847c478bd9Sstevel@tonic-gate 16859acbbeafSnn if ((zone_get_brand(zone, brand, sizeof (brand)) == Z_OK) && 16869acbbeafSnn (strcmp(brand, NATIVE_BRAND_NAME) != 0)) 16879acbbeafSnn (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 16889acbbeafSnn pt_to_str(PT_BRAND), brand); 16899acbbeafSnn 16907c478bd9Sstevel@tonic-gate if (zonecfg_get_autoboot(handle, &autoboot) == Z_OK) 16917c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 16927c478bd9Sstevel@tonic-gate pt_to_str(PT_AUTOBOOT), autoboot ? "true" : "false"); 16937c478bd9Sstevel@tonic-gate 16943f2f09c1Sdp if (zonecfg_get_bootargs(handle, bootargs, sizeof (bootargs)) == Z_OK && 16953f2f09c1Sdp strlen(bootargs) > 0) { 16963f2f09c1Sdp (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 16973f2f09c1Sdp pt_to_str(PT_BOOTARGS), bootargs); 16983f2f09c1Sdp } 16993f2f09c1Sdp 17007c478bd9Sstevel@tonic-gate if (zonecfg_get_pool(handle, pool, sizeof (pool)) == Z_OK && 17017c478bd9Sstevel@tonic-gate strlen(pool) > 0) 17027c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 17037c478bd9Sstevel@tonic-gate pt_to_str(PT_POOL), pool); 17047c478bd9Sstevel@tonic-gate 1705ffbafc53Scomay if (zonecfg_get_limitpriv(handle, &limitpriv) == Z_OK && 1706ffbafc53Scomay strlen(limitpriv) > 0) { 1707ffbafc53Scomay (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 1708ffbafc53Scomay pt_to_str(PT_LIMITPRIV), limitpriv); 1709ffbafc53Scomay free(limitpriv); 1710ffbafc53Scomay } 1711ffbafc53Scomay 17120209230bSgjelinek if (zonecfg_get_sched_class(handle, sched, sizeof (sched)) == Z_OK && 17130209230bSgjelinek strlen(sched) > 0) 17140209230bSgjelinek (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 17150209230bSgjelinek pt_to_str(PT_SCHED), sched); 17163f2f09c1Sdp 1717f4b3ec61Sdh if (zonecfg_get_iptype(handle, &iptype) == Z_OK) { 1718f4b3ec61Sdh switch (iptype) { 1719f4b3ec61Sdh case ZS_SHARED: 1720f4b3ec61Sdh (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 1721f4b3ec61Sdh pt_to_str(PT_IPTYPE), "shared"); 1722f4b3ec61Sdh break; 1723f4b3ec61Sdh case ZS_EXCLUSIVE: 1724f4b3ec61Sdh (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 1725f4b3ec61Sdh pt_to_str(PT_IPTYPE), "exclusive"); 1726f4b3ec61Sdh break; 1727f4b3ec61Sdh } 1728f4b3ec61Sdh } 1729f4b3ec61Sdh 17307c478bd9Sstevel@tonic-gate if ((err = zonecfg_setipdent(handle)) != Z_OK) { 17317c478bd9Sstevel@tonic-gate zone_perror(zone, err, FALSE); 17327c478bd9Sstevel@tonic-gate goto done; 17337c478bd9Sstevel@tonic-gate } 17347c478bd9Sstevel@tonic-gate while (zonecfg_getipdent(handle, &fstab) == Z_OK) { 17357c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 17367c478bd9Sstevel@tonic-gate rt_to_str(RT_IPD)); 17377c478bd9Sstevel@tonic-gate export_prop(of, PT_DIR, fstab.zone_fs_dir); 17387c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 17397c478bd9Sstevel@tonic-gate } 17407c478bd9Sstevel@tonic-gate (void) zonecfg_endipdent(handle); 17417c478bd9Sstevel@tonic-gate 17427c478bd9Sstevel@tonic-gate if ((err = zonecfg_setfsent(handle)) != Z_OK) { 17437c478bd9Sstevel@tonic-gate zone_perror(zone, err, FALSE); 17447c478bd9Sstevel@tonic-gate goto done; 17457c478bd9Sstevel@tonic-gate } 17467c478bd9Sstevel@tonic-gate while (zonecfg_getfsent(handle, &fstab) == Z_OK) { 17477c478bd9Sstevel@tonic-gate zone_fsopt_t *optptr; 17487c478bd9Sstevel@tonic-gate 17497c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 17507c478bd9Sstevel@tonic-gate rt_to_str(RT_FS)); 17517c478bd9Sstevel@tonic-gate export_prop(of, PT_DIR, fstab.zone_fs_dir); 17527c478bd9Sstevel@tonic-gate export_prop(of, PT_SPECIAL, fstab.zone_fs_special); 17537c478bd9Sstevel@tonic-gate export_prop(of, PT_RAW, fstab.zone_fs_raw); 17547c478bd9Sstevel@tonic-gate export_prop(of, PT_TYPE, fstab.zone_fs_type); 17557c478bd9Sstevel@tonic-gate for (optptr = fstab.zone_fs_options; optptr != NULL; 17567c478bd9Sstevel@tonic-gate optptr = optptr->zone_fsopt_next) { 17577c478bd9Sstevel@tonic-gate /* 17587c478bd9Sstevel@tonic-gate * Simple property values with embedded equal signs 17597c478bd9Sstevel@tonic-gate * need to be quoted to prevent the lexer from 17607c478bd9Sstevel@tonic-gate * mis-parsing them as complex name=value pairs. 17617c478bd9Sstevel@tonic-gate */ 17627c478bd9Sstevel@tonic-gate if (strchr(optptr->zone_fsopt_opt, '=')) 17637c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s \"%s\"\n", 17647c478bd9Sstevel@tonic-gate cmd_to_str(CMD_ADD), 17657c478bd9Sstevel@tonic-gate pt_to_str(PT_OPTIONS), 17667c478bd9Sstevel@tonic-gate optptr->zone_fsopt_opt); 17677c478bd9Sstevel@tonic-gate else 17687c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s %s\n", 17697c478bd9Sstevel@tonic-gate cmd_to_str(CMD_ADD), 17707c478bd9Sstevel@tonic-gate pt_to_str(PT_OPTIONS), 17717c478bd9Sstevel@tonic-gate optptr->zone_fsopt_opt); 17727c478bd9Sstevel@tonic-gate } 17737c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 17747c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(fstab.zone_fs_options); 17757c478bd9Sstevel@tonic-gate } 17767c478bd9Sstevel@tonic-gate (void) zonecfg_endfsent(handle); 17777c478bd9Sstevel@tonic-gate 17787c478bd9Sstevel@tonic-gate if ((err = zonecfg_setnwifent(handle)) != Z_OK) { 17797c478bd9Sstevel@tonic-gate zone_perror(zone, err, FALSE); 17807c478bd9Sstevel@tonic-gate goto done; 17817c478bd9Sstevel@tonic-gate } 17827c478bd9Sstevel@tonic-gate while (zonecfg_getnwifent(handle, &nwiftab) == Z_OK) { 17837c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 17847c478bd9Sstevel@tonic-gate rt_to_str(RT_NET)); 17857c478bd9Sstevel@tonic-gate export_prop(of, PT_ADDRESS, nwiftab.zone_nwif_address); 17867c478bd9Sstevel@tonic-gate export_prop(of, PT_PHYSICAL, nwiftab.zone_nwif_physical); 1787*de860bd9Sgfaden export_prop(of, PT_DEFROUTER, nwiftab.zone_nwif_defrouter); 17887c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 17897c478bd9Sstevel@tonic-gate } 17907c478bd9Sstevel@tonic-gate (void) zonecfg_endnwifent(handle); 17917c478bd9Sstevel@tonic-gate 17927c478bd9Sstevel@tonic-gate if ((err = zonecfg_setdevent(handle)) != Z_OK) { 17937c478bd9Sstevel@tonic-gate zone_perror(zone, err, FALSE); 17947c478bd9Sstevel@tonic-gate goto done; 17957c478bd9Sstevel@tonic-gate } 17967c478bd9Sstevel@tonic-gate while (zonecfg_getdevent(handle, &devtab) == Z_OK) { 17977c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 17987c478bd9Sstevel@tonic-gate rt_to_str(RT_DEVICE)); 17997c478bd9Sstevel@tonic-gate export_prop(of, PT_MATCH, devtab.zone_dev_match); 18007c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 18017c478bd9Sstevel@tonic-gate } 18027c478bd9Sstevel@tonic-gate (void) zonecfg_enddevent(handle); 18037c478bd9Sstevel@tonic-gate 18047c478bd9Sstevel@tonic-gate if ((err = zonecfg_setrctlent(handle)) != Z_OK) { 18057c478bd9Sstevel@tonic-gate zone_perror(zone, err, FALSE); 18067c478bd9Sstevel@tonic-gate goto done; 18077c478bd9Sstevel@tonic-gate } 18087c478bd9Sstevel@tonic-gate while (zonecfg_getrctlent(handle, &rctltab) == Z_OK) { 18097c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s rctl\n", cmd_to_str(CMD_ADD)); 18107c478bd9Sstevel@tonic-gate export_prop(of, PT_NAME, rctltab.zone_rctl_name); 18117c478bd9Sstevel@tonic-gate for (valptr = rctltab.zone_rctl_valptr; valptr != NULL; 18127c478bd9Sstevel@tonic-gate valptr = valptr->zone_rctlval_next) { 18137c478bd9Sstevel@tonic-gate fprintf(of, "%s %s (%s=%s,%s=%s,%s=%s)\n", 18147c478bd9Sstevel@tonic-gate cmd_to_str(CMD_ADD), pt_to_str(PT_VALUE), 18157c478bd9Sstevel@tonic-gate pt_to_str(PT_PRIV), valptr->zone_rctlval_priv, 18167c478bd9Sstevel@tonic-gate pt_to_str(PT_LIMIT), valptr->zone_rctlval_limit, 18177c478bd9Sstevel@tonic-gate pt_to_str(PT_ACTION), valptr->zone_rctlval_action); 18187c478bd9Sstevel@tonic-gate } 18197c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 18207c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctltab.zone_rctl_valptr); 18217c478bd9Sstevel@tonic-gate } 18227c478bd9Sstevel@tonic-gate (void) zonecfg_endrctlent(handle); 18237c478bd9Sstevel@tonic-gate 18247c478bd9Sstevel@tonic-gate if ((err = zonecfg_setattrent(handle)) != Z_OK) { 18257c478bd9Sstevel@tonic-gate zone_perror(zone, err, FALSE); 18267c478bd9Sstevel@tonic-gate goto done; 18277c478bd9Sstevel@tonic-gate } 18287c478bd9Sstevel@tonic-gate while (zonecfg_getattrent(handle, &attrtab) == Z_OK) { 18297c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 18307c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR)); 18317c478bd9Sstevel@tonic-gate export_prop(of, PT_NAME, attrtab.zone_attr_name); 18327c478bd9Sstevel@tonic-gate export_prop(of, PT_TYPE, attrtab.zone_attr_type); 18337c478bd9Sstevel@tonic-gate export_prop(of, PT_VALUE, attrtab.zone_attr_value); 18347c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 18357c478bd9Sstevel@tonic-gate } 18367c478bd9Sstevel@tonic-gate (void) zonecfg_endattrent(handle); 18377c478bd9Sstevel@tonic-gate 1838fa9e4066Sahrens if ((err = zonecfg_setdsent(handle)) != Z_OK) { 1839fa9e4066Sahrens zone_perror(zone, err, FALSE); 1840fa9e4066Sahrens goto done; 1841fa9e4066Sahrens } 1842fa9e4066Sahrens while (zonecfg_getdsent(handle, &dstab) == Z_OK) { 1843fa9e4066Sahrens (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 1844fa9e4066Sahrens rt_to_str(RT_DATASET)); 1845fa9e4066Sahrens export_prop(of, PT_NAME, dstab.zone_dataset_name); 1846fa9e4066Sahrens (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 1847fa9e4066Sahrens } 1848fa9e4066Sahrens (void) zonecfg_enddsent(handle); 1849fa9e4066Sahrens 18500209230bSgjelinek if (zonecfg_getpsetent(handle, &psettab) == Z_OK) { 18510209230bSgjelinek (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 18520209230bSgjelinek rt_to_str(RT_DCPU)); 18530209230bSgjelinek if (strcmp(psettab.zone_ncpu_min, psettab.zone_ncpu_max) == 0) 18540209230bSgjelinek (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 18550209230bSgjelinek pt_to_str(PT_NCPUS), psettab.zone_ncpu_max); 18560209230bSgjelinek else 18570209230bSgjelinek (void) fprintf(of, "%s %s=%s-%s\n", cmd_to_str(CMD_SET), 18580209230bSgjelinek pt_to_str(PT_NCPUS), psettab.zone_ncpu_min, 18590209230bSgjelinek psettab.zone_ncpu_max); 18600209230bSgjelinek if (psettab.zone_importance[0] != '\0') 18610209230bSgjelinek (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 18620209230bSgjelinek pt_to_str(PT_IMPORTANCE), psettab.zone_importance); 18630209230bSgjelinek (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 18640209230bSgjelinek } 18650209230bSgjelinek 18660209230bSgjelinek if (zonecfg_getmcapent(handle, &mcaptab) == Z_OK) { 18670209230bSgjelinek char buf[128]; 18680209230bSgjelinek 18690209230bSgjelinek (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 18700209230bSgjelinek rt_to_str(RT_MCAP)); 18710209230bSgjelinek bytes_to_units(mcaptab.zone_physmem_cap, buf, sizeof (buf)); 18720209230bSgjelinek (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 18730209230bSgjelinek pt_to_str(PT_PHYSICAL), buf); 18740209230bSgjelinek (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 18750209230bSgjelinek } 18760209230bSgjelinek 1877c97ad5cdSakolb /* 1878c97ad5cdSakolb * There is nothing to export for pcap since this resource is just 1879c97ad5cdSakolb * a container for an rctl alias. 1880c97ad5cdSakolb */ 1881c97ad5cdSakolb 18827c478bd9Sstevel@tonic-gate done: 18837c478bd9Sstevel@tonic-gate if (need_to_close) 18847c478bd9Sstevel@tonic-gate (void) fclose(of); 18857c478bd9Sstevel@tonic-gate } 18867c478bd9Sstevel@tonic-gate 18877c478bd9Sstevel@tonic-gate void 18887c478bd9Sstevel@tonic-gate exit_func(cmd_t *cmd) 18897c478bd9Sstevel@tonic-gate { 18907c478bd9Sstevel@tonic-gate int arg, answer; 18917ec75eb8Sgjelinek bool arg_err = FALSE; 18927c478bd9Sstevel@tonic-gate 18937c478bd9Sstevel@tonic-gate optind = 0; 18947c478bd9Sstevel@tonic-gate while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?F")) != EOF) { 18957c478bd9Sstevel@tonic-gate switch (arg) { 18967c478bd9Sstevel@tonic-gate case '?': 18977c478bd9Sstevel@tonic-gate longer_usage(CMD_EXIT); 18987ec75eb8Sgjelinek arg_err = TRUE; 18997ec75eb8Sgjelinek break; 19007c478bd9Sstevel@tonic-gate case 'F': 19017c478bd9Sstevel@tonic-gate force_exit = TRUE; 19027c478bd9Sstevel@tonic-gate break; 19037c478bd9Sstevel@tonic-gate default: 19047c478bd9Sstevel@tonic-gate short_usage(CMD_EXIT); 19057ec75eb8Sgjelinek arg_err = TRUE; 19067ec75eb8Sgjelinek break; 19077c478bd9Sstevel@tonic-gate } 19087c478bd9Sstevel@tonic-gate } 19097ec75eb8Sgjelinek if (arg_err) 19107ec75eb8Sgjelinek return; 19117ec75eb8Sgjelinek 19127c478bd9Sstevel@tonic-gate if (optind < cmd->cmd_argc) { 19137c478bd9Sstevel@tonic-gate short_usage(CMD_EXIT); 19147c478bd9Sstevel@tonic-gate return; 19157c478bd9Sstevel@tonic-gate } 19167c478bd9Sstevel@tonic-gate 19177c478bd9Sstevel@tonic-gate if (global_scope || force_exit) { 19187c478bd9Sstevel@tonic-gate time_to_exit = TRUE; 19197c478bd9Sstevel@tonic-gate return; 19207c478bd9Sstevel@tonic-gate } 19217c478bd9Sstevel@tonic-gate 19227c478bd9Sstevel@tonic-gate answer = ask_yesno(FALSE, "Resource incomplete; really quit"); 19237c478bd9Sstevel@tonic-gate if (answer == -1) { 19247c478bd9Sstevel@tonic-gate zerr(gettext("Resource incomplete, input " 19257c478bd9Sstevel@tonic-gate "not from terminal and -F not specified:\n%s command " 19267c478bd9Sstevel@tonic-gate "ignored, but exiting anyway."), cmd_to_str(CMD_EXIT)); 19277c478bd9Sstevel@tonic-gate exit(Z_ERR); 19287c478bd9Sstevel@tonic-gate } else if (answer == 1) { 19297c478bd9Sstevel@tonic-gate time_to_exit = TRUE; 19307c478bd9Sstevel@tonic-gate } 19317c478bd9Sstevel@tonic-gate /* (answer == 0) => just return */ 19327c478bd9Sstevel@tonic-gate } 19337c478bd9Sstevel@tonic-gate 19347c478bd9Sstevel@tonic-gate static int 19357c478bd9Sstevel@tonic-gate validate_zonepath_syntax(char *path) 19367c478bd9Sstevel@tonic-gate { 19377c478bd9Sstevel@tonic-gate if (path[0] != '/') { 19387c478bd9Sstevel@tonic-gate zerr(gettext("%s is not an absolute path."), path); 19397c478bd9Sstevel@tonic-gate return (Z_ERR); 19407c478bd9Sstevel@tonic-gate } 19417c478bd9Sstevel@tonic-gate if (strcmp(path, "/") == 0) { 19427c478bd9Sstevel@tonic-gate zerr(gettext("/ is not allowed as a %s."), 19437c478bd9Sstevel@tonic-gate pt_to_str(PT_ZONEPATH)); 19447c478bd9Sstevel@tonic-gate return (Z_ERR); 19457c478bd9Sstevel@tonic-gate } 19467c478bd9Sstevel@tonic-gate return (Z_OK); 19477c478bd9Sstevel@tonic-gate } 19487c478bd9Sstevel@tonic-gate 19497c478bd9Sstevel@tonic-gate static void 19507c478bd9Sstevel@tonic-gate add_resource(cmd_t *cmd) 19517c478bd9Sstevel@tonic-gate { 19527c478bd9Sstevel@tonic-gate int type; 19530209230bSgjelinek struct zone_psettab tmp_psettab; 19540209230bSgjelinek struct zone_mcaptab tmp_mcaptab; 1955c97ad5cdSakolb uint64_t tmp; 19560209230bSgjelinek uint64_t tmp_mcap; 19570209230bSgjelinek char pool[MAXNAMELEN]; 19587c478bd9Sstevel@tonic-gate 19597c478bd9Sstevel@tonic-gate if ((type = cmd->cmd_res_type) == RT_UNKNOWN) { 19607c478bd9Sstevel@tonic-gate long_usage(CMD_ADD, TRUE); 19617c478bd9Sstevel@tonic-gate goto bad; 19627c478bd9Sstevel@tonic-gate } 19637c478bd9Sstevel@tonic-gate 19647c478bd9Sstevel@tonic-gate switch (type) { 19657c478bd9Sstevel@tonic-gate case RT_FS: 19667c478bd9Sstevel@tonic-gate bzero(&in_progress_fstab, sizeof (in_progress_fstab)); 19677c478bd9Sstevel@tonic-gate return; 19687c478bd9Sstevel@tonic-gate case RT_IPD: 1969087719fdSdp if (state_atleast(ZONE_STATE_INSTALLED)) { 19707c478bd9Sstevel@tonic-gate zerr(gettext("Zone %s already installed; %s %s not " 19717c478bd9Sstevel@tonic-gate "allowed."), zone, cmd_to_str(CMD_ADD), 19727c478bd9Sstevel@tonic-gate rt_to_str(RT_IPD)); 19737c478bd9Sstevel@tonic-gate goto bad; 19747c478bd9Sstevel@tonic-gate } 19757c478bd9Sstevel@tonic-gate bzero(&in_progress_ipdtab, sizeof (in_progress_ipdtab)); 19767c478bd9Sstevel@tonic-gate return; 19777c478bd9Sstevel@tonic-gate case RT_NET: 19787c478bd9Sstevel@tonic-gate bzero(&in_progress_nwiftab, sizeof (in_progress_nwiftab)); 19797c478bd9Sstevel@tonic-gate return; 19807c478bd9Sstevel@tonic-gate case RT_DEVICE: 19817c478bd9Sstevel@tonic-gate bzero(&in_progress_devtab, sizeof (in_progress_devtab)); 19827c478bd9Sstevel@tonic-gate return; 19837c478bd9Sstevel@tonic-gate case RT_RCTL: 19840209230bSgjelinek if (global_zone) 19850209230bSgjelinek zerr(gettext("WARNING: Setting a global zone resource " 19860209230bSgjelinek "control too low could deny\nservice " 19870209230bSgjelinek "to even the root user; " 19880209230bSgjelinek "this could render the system impossible\n" 19890209230bSgjelinek "to administer. Please use caution.")); 19907c478bd9Sstevel@tonic-gate bzero(&in_progress_rctltab, sizeof (in_progress_rctltab)); 19917c478bd9Sstevel@tonic-gate return; 19927c478bd9Sstevel@tonic-gate case RT_ATTR: 19937c478bd9Sstevel@tonic-gate bzero(&in_progress_attrtab, sizeof (in_progress_attrtab)); 19947c478bd9Sstevel@tonic-gate return; 1995fa9e4066Sahrens case RT_DATASET: 1996fa9e4066Sahrens bzero(&in_progress_dstab, sizeof (in_progress_dstab)); 1997fa9e4066Sahrens return; 19980209230bSgjelinek case RT_DCPU: 1999c97ad5cdSakolb /* Make sure there isn't already a cpu-set or cpu-cap entry. */ 20000209230bSgjelinek if (zonecfg_lookup_pset(handle, &tmp_psettab) == Z_OK) { 20010209230bSgjelinek zerr(gettext("The %s resource already exists."), 20020209230bSgjelinek rt_to_str(RT_DCPU)); 20030209230bSgjelinek goto bad; 20040209230bSgjelinek } 2005c97ad5cdSakolb if (zonecfg_get_aliased_rctl(handle, ALIAS_CPUCAP, &tmp) != 2006c97ad5cdSakolb Z_NO_ENTRY) { 2007c97ad5cdSakolb zerr(gettext("The %s resource already exists."), 2008c97ad5cdSakolb rt_to_str(RT_PCAP)); 2009c97ad5cdSakolb goto bad; 2010c97ad5cdSakolb } 20110209230bSgjelinek 20120209230bSgjelinek /* Make sure the pool property isn't set. */ 20130209230bSgjelinek if (zonecfg_get_pool(handle, pool, sizeof (pool)) == Z_OK && 20140209230bSgjelinek strlen(pool) > 0) { 20150209230bSgjelinek zerr(gettext("The %s property is already set. " 20160209230bSgjelinek "A persistent pool is incompatible with\nthe %s " 20170209230bSgjelinek "resource."), 20180209230bSgjelinek pt_to_str(PT_POOL), rt_to_str(RT_DCPU)); 20190209230bSgjelinek goto bad; 20200209230bSgjelinek } 20210209230bSgjelinek 20220209230bSgjelinek bzero(&in_progress_psettab, sizeof (in_progress_psettab)); 20230209230bSgjelinek return; 2024c97ad5cdSakolb case RT_PCAP: 2025c97ad5cdSakolb /* 2026c97ad5cdSakolb * Make sure there isn't already a cpu-set or incompatible 2027c97ad5cdSakolb * cpu-cap rctls. 2028c97ad5cdSakolb */ 2029c97ad5cdSakolb if (zonecfg_lookup_pset(handle, &tmp_psettab) == Z_OK) { 2030c97ad5cdSakolb zerr(gettext("The %s resource already exists."), 2031c97ad5cdSakolb rt_to_str(RT_DCPU)); 2032c97ad5cdSakolb goto bad; 2033c97ad5cdSakolb } 2034c97ad5cdSakolb 2035c97ad5cdSakolb switch (zonecfg_get_aliased_rctl(handle, ALIAS_CPUCAP, &tmp)) { 2036c97ad5cdSakolb case Z_ALIAS_DISALLOW: 2037c97ad5cdSakolb zone_perror(rt_to_str(RT_PCAP), Z_ALIAS_DISALLOW, 2038c97ad5cdSakolb FALSE); 2039c97ad5cdSakolb goto bad; 2040c97ad5cdSakolb 2041c97ad5cdSakolb case Z_OK: 2042c97ad5cdSakolb zerr(gettext("The %s resource already exists."), 2043c97ad5cdSakolb rt_to_str(RT_PCAP)); 2044c97ad5cdSakolb goto bad; 2045c97ad5cdSakolb 2046c97ad5cdSakolb default: 2047c97ad5cdSakolb break; 2048c97ad5cdSakolb } 2049c97ad5cdSakolb return; 20500209230bSgjelinek case RT_MCAP: 20510209230bSgjelinek /* 20520209230bSgjelinek * Make sure there isn't already a mem-cap entry or max-swap 20530209230bSgjelinek * or max-locked rctl. 20540209230bSgjelinek */ 20550209230bSgjelinek if (zonecfg_lookup_mcap(handle, &tmp_mcaptab) == Z_OK || 20560209230bSgjelinek zonecfg_get_aliased_rctl(handle, ALIAS_MAXSWAP, &tmp_mcap) 20570209230bSgjelinek == Z_OK || 20580209230bSgjelinek zonecfg_get_aliased_rctl(handle, ALIAS_MAXLOCKEDMEM, 20590209230bSgjelinek &tmp_mcap) == Z_OK) { 20600209230bSgjelinek zerr(gettext("The %s resource or a related resource " 20610209230bSgjelinek "control already exists."), rt_to_str(RT_MCAP)); 20620209230bSgjelinek goto bad; 20630209230bSgjelinek } 20640209230bSgjelinek if (global_zone) 20650209230bSgjelinek zerr(gettext("WARNING: Setting a global zone memory " 20660209230bSgjelinek "cap too low could deny\nservice " 20670209230bSgjelinek "to even the root user; " 20680209230bSgjelinek "this could render the system impossible\n" 20690209230bSgjelinek "to administer. Please use caution.")); 20700209230bSgjelinek bzero(&in_progress_mcaptab, sizeof (in_progress_mcaptab)); 20710209230bSgjelinek return; 20727c478bd9Sstevel@tonic-gate default: 20737c478bd9Sstevel@tonic-gate zone_perror(rt_to_str(type), Z_NO_RESOURCE_TYPE, TRUE); 20747c478bd9Sstevel@tonic-gate long_usage(CMD_ADD, TRUE); 20757c478bd9Sstevel@tonic-gate usage(FALSE, HELP_RESOURCES); 20767c478bd9Sstevel@tonic-gate } 20777c478bd9Sstevel@tonic-gate bad: 20787c478bd9Sstevel@tonic-gate global_scope = TRUE; 20797c478bd9Sstevel@tonic-gate end_op = -1; 20807c478bd9Sstevel@tonic-gate } 20817c478bd9Sstevel@tonic-gate 20827c478bd9Sstevel@tonic-gate static void 20837c478bd9Sstevel@tonic-gate do_complex_rctl_val(complex_property_ptr_t cp) 20847c478bd9Sstevel@tonic-gate { 20857c478bd9Sstevel@tonic-gate struct zone_rctlvaltab *rctlvaltab; 20867c478bd9Sstevel@tonic-gate complex_property_ptr_t cx; 20877c478bd9Sstevel@tonic-gate bool seen_priv = FALSE, seen_limit = FALSE, seen_action = FALSE; 20887c478bd9Sstevel@tonic-gate rctlblk_t *rctlblk; 20897c478bd9Sstevel@tonic-gate int err; 20907c478bd9Sstevel@tonic-gate 20917c478bd9Sstevel@tonic-gate if ((rctlvaltab = alloc_rctlvaltab()) == NULL) { 20927c478bd9Sstevel@tonic-gate zone_perror(zone, Z_NOMEM, TRUE); 20937c478bd9Sstevel@tonic-gate exit(Z_ERR); 20947c478bd9Sstevel@tonic-gate } 20957c478bd9Sstevel@tonic-gate for (cx = cp; cx != NULL; cx = cx->cp_next) { 20967c478bd9Sstevel@tonic-gate switch (cx->cp_type) { 20977c478bd9Sstevel@tonic-gate case PT_PRIV: 20987c478bd9Sstevel@tonic-gate if (seen_priv) { 20997c478bd9Sstevel@tonic-gate zerr(gettext("%s already specified"), 21007c478bd9Sstevel@tonic-gate pt_to_str(PT_PRIV)); 21017c478bd9Sstevel@tonic-gate goto bad; 21027c478bd9Sstevel@tonic-gate } 21037c478bd9Sstevel@tonic-gate (void) strlcpy(rctlvaltab->zone_rctlval_priv, 21047c478bd9Sstevel@tonic-gate cx->cp_value, 21057c478bd9Sstevel@tonic-gate sizeof (rctlvaltab->zone_rctlval_priv)); 21067c478bd9Sstevel@tonic-gate seen_priv = TRUE; 21077c478bd9Sstevel@tonic-gate break; 21087c478bd9Sstevel@tonic-gate case PT_LIMIT: 21097c478bd9Sstevel@tonic-gate if (seen_limit) { 21107c478bd9Sstevel@tonic-gate zerr(gettext("%s already specified"), 21117c478bd9Sstevel@tonic-gate pt_to_str(PT_LIMIT)); 21127c478bd9Sstevel@tonic-gate goto bad; 21137c478bd9Sstevel@tonic-gate } 21147c478bd9Sstevel@tonic-gate (void) strlcpy(rctlvaltab->zone_rctlval_limit, 21157c478bd9Sstevel@tonic-gate cx->cp_value, 21167c478bd9Sstevel@tonic-gate sizeof (rctlvaltab->zone_rctlval_limit)); 21177c478bd9Sstevel@tonic-gate seen_limit = TRUE; 21187c478bd9Sstevel@tonic-gate break; 21197c478bd9Sstevel@tonic-gate case PT_ACTION: 21207c478bd9Sstevel@tonic-gate if (seen_action) { 21217c478bd9Sstevel@tonic-gate zerr(gettext("%s already specified"), 21227c478bd9Sstevel@tonic-gate pt_to_str(PT_ACTION)); 21237c478bd9Sstevel@tonic-gate goto bad; 21247c478bd9Sstevel@tonic-gate } 21257c478bd9Sstevel@tonic-gate (void) strlcpy(rctlvaltab->zone_rctlval_action, 21267c478bd9Sstevel@tonic-gate cx->cp_value, 21277c478bd9Sstevel@tonic-gate sizeof (rctlvaltab->zone_rctlval_action)); 21287c478bd9Sstevel@tonic-gate seen_action = TRUE; 21297c478bd9Sstevel@tonic-gate break; 21307c478bd9Sstevel@tonic-gate default: 21317c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(PT_VALUE), 21327c478bd9Sstevel@tonic-gate Z_NO_PROPERTY_TYPE, TRUE); 21337c478bd9Sstevel@tonic-gate long_usage(CMD_ADD, TRUE); 21347c478bd9Sstevel@tonic-gate usage(FALSE, HELP_PROPS); 21357c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctlvaltab); 21367c478bd9Sstevel@tonic-gate return; 21377c478bd9Sstevel@tonic-gate } 21387c478bd9Sstevel@tonic-gate } 21397c478bd9Sstevel@tonic-gate if (!seen_priv) 21407c478bd9Sstevel@tonic-gate zerr(gettext("%s not specified"), pt_to_str(PT_PRIV)); 21417c478bd9Sstevel@tonic-gate if (!seen_limit) 21427c478bd9Sstevel@tonic-gate zerr(gettext("%s not specified"), pt_to_str(PT_LIMIT)); 21437c478bd9Sstevel@tonic-gate if (!seen_action) 21447c478bd9Sstevel@tonic-gate zerr(gettext("%s not specified"), pt_to_str(PT_ACTION)); 21457c478bd9Sstevel@tonic-gate if (!seen_priv || !seen_limit || !seen_action) 21467c478bd9Sstevel@tonic-gate goto bad; 21477c478bd9Sstevel@tonic-gate rctlvaltab->zone_rctlval_next = NULL; 21487c478bd9Sstevel@tonic-gate rctlblk = alloca(rctlblk_size()); 21497c478bd9Sstevel@tonic-gate /* 21507c478bd9Sstevel@tonic-gate * Make sure the rctl value looks roughly correct; we won't know if 21517c478bd9Sstevel@tonic-gate * it's truly OK until we verify the configuration on the target 21527c478bd9Sstevel@tonic-gate * system. 21537c478bd9Sstevel@tonic-gate */ 21547c478bd9Sstevel@tonic-gate if (zonecfg_construct_rctlblk(rctlvaltab, rctlblk) != Z_OK || 21557c478bd9Sstevel@tonic-gate !zonecfg_valid_rctlblk(rctlblk)) { 21567c478bd9Sstevel@tonic-gate zerr(gettext("Invalid %s %s specification"), rt_to_str(RT_RCTL), 21577c478bd9Sstevel@tonic-gate pt_to_str(PT_VALUE)); 21587c478bd9Sstevel@tonic-gate goto bad; 21597c478bd9Sstevel@tonic-gate } 21607c478bd9Sstevel@tonic-gate err = zonecfg_add_rctl_value(&in_progress_rctltab, rctlvaltab); 21617c478bd9Sstevel@tonic-gate if (err != Z_OK) 21627c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(PT_VALUE), err, TRUE); 21637c478bd9Sstevel@tonic-gate return; 21647c478bd9Sstevel@tonic-gate 21657c478bd9Sstevel@tonic-gate bad: 21667c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctlvaltab); 21677c478bd9Sstevel@tonic-gate } 21687c478bd9Sstevel@tonic-gate 21697c478bd9Sstevel@tonic-gate static void 21707c478bd9Sstevel@tonic-gate add_property(cmd_t *cmd) 21717c478bd9Sstevel@tonic-gate { 21727c478bd9Sstevel@tonic-gate char *prop_id; 21737c478bd9Sstevel@tonic-gate int err, res_type, prop_type; 21747c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 21757c478bd9Sstevel@tonic-gate list_property_ptr_t l; 21767c478bd9Sstevel@tonic-gate 21777c478bd9Sstevel@tonic-gate res_type = resource_scope; 21787c478bd9Sstevel@tonic-gate prop_type = cmd->cmd_prop_name[0]; 21797c478bd9Sstevel@tonic-gate if (res_type == RT_UNKNOWN || prop_type == PT_UNKNOWN) { 21807c478bd9Sstevel@tonic-gate long_usage(CMD_ADD, TRUE); 21817c478bd9Sstevel@tonic-gate return; 21827c478bd9Sstevel@tonic-gate } 21837c478bd9Sstevel@tonic-gate 21847c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs != 1) { 21857c478bd9Sstevel@tonic-gate long_usage(CMD_ADD, TRUE); 21867c478bd9Sstevel@tonic-gate return; 21877c478bd9Sstevel@tonic-gate } 21887c478bd9Sstevel@tonic-gate 21897c478bd9Sstevel@tonic-gate if (initialize(TRUE) != Z_OK) 21907c478bd9Sstevel@tonic-gate return; 21917c478bd9Sstevel@tonic-gate 21927c478bd9Sstevel@tonic-gate switch (res_type) { 21937c478bd9Sstevel@tonic-gate case RT_FS: 21947c478bd9Sstevel@tonic-gate if (prop_type != PT_OPTIONS) { 21957c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 21967c478bd9Sstevel@tonic-gate TRUE); 21977c478bd9Sstevel@tonic-gate long_usage(CMD_ADD, TRUE); 21987c478bd9Sstevel@tonic-gate usage(FALSE, HELP_PROPS); 21997c478bd9Sstevel@tonic-gate return; 22007c478bd9Sstevel@tonic-gate } 22017c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[0]; 22027c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE && 22037c478bd9Sstevel@tonic-gate pp->pv_type != PROP_VAL_LIST) { 22047c478bd9Sstevel@tonic-gate zerr(gettext("A %s or %s value was expected here."), 22057c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_SIMPLE), 22067c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_LIST)); 22077c478bd9Sstevel@tonic-gate saw_error = TRUE; 22087c478bd9Sstevel@tonic-gate return; 22097c478bd9Sstevel@tonic-gate } 22107c478bd9Sstevel@tonic-gate if (pp->pv_type == PROP_VAL_SIMPLE) { 22117c478bd9Sstevel@tonic-gate if (pp->pv_simple == NULL) { 22127c478bd9Sstevel@tonic-gate long_usage(CMD_ADD, TRUE); 22137c478bd9Sstevel@tonic-gate return; 22147c478bd9Sstevel@tonic-gate } 22157c478bd9Sstevel@tonic-gate prop_id = pp->pv_simple; 22167c478bd9Sstevel@tonic-gate err = zonecfg_add_fs_option(&in_progress_fstab, 22177c478bd9Sstevel@tonic-gate prop_id); 22187c478bd9Sstevel@tonic-gate if (err != Z_OK) 22197c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), err, TRUE); 22207c478bd9Sstevel@tonic-gate } else { 22217c478bd9Sstevel@tonic-gate list_property_ptr_t list; 22227c478bd9Sstevel@tonic-gate 22237c478bd9Sstevel@tonic-gate for (list = pp->pv_list; list != NULL; 22247c478bd9Sstevel@tonic-gate list = list->lp_next) { 22257c478bd9Sstevel@tonic-gate prop_id = list->lp_simple; 22267c478bd9Sstevel@tonic-gate if (prop_id == NULL) 22277c478bd9Sstevel@tonic-gate break; 22287c478bd9Sstevel@tonic-gate err = zonecfg_add_fs_option( 22297c478bd9Sstevel@tonic-gate &in_progress_fstab, prop_id); 22307c478bd9Sstevel@tonic-gate if (err != Z_OK) 22317c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), err, 22327c478bd9Sstevel@tonic-gate TRUE); 22337c478bd9Sstevel@tonic-gate } 22347c478bd9Sstevel@tonic-gate } 22357c478bd9Sstevel@tonic-gate return; 22367c478bd9Sstevel@tonic-gate case RT_RCTL: 22377c478bd9Sstevel@tonic-gate if (prop_type != PT_VALUE) { 22387c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 22397c478bd9Sstevel@tonic-gate TRUE); 22407c478bd9Sstevel@tonic-gate long_usage(CMD_ADD, TRUE); 22417c478bd9Sstevel@tonic-gate usage(FALSE, HELP_PROPS); 22427c478bd9Sstevel@tonic-gate return; 22437c478bd9Sstevel@tonic-gate } 22447c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[0]; 22457c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_COMPLEX && 22467c478bd9Sstevel@tonic-gate pp->pv_type != PROP_VAL_LIST) { 22477c478bd9Sstevel@tonic-gate zerr(gettext("A %s or %s value was expected here."), 22487c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_COMPLEX), 22497c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_LIST)); 22507c478bd9Sstevel@tonic-gate saw_error = TRUE; 22517c478bd9Sstevel@tonic-gate return; 22527c478bd9Sstevel@tonic-gate } 22537c478bd9Sstevel@tonic-gate if (pp->pv_type == PROP_VAL_COMPLEX) { 22547c478bd9Sstevel@tonic-gate do_complex_rctl_val(pp->pv_complex); 22557c478bd9Sstevel@tonic-gate return; 22567c478bd9Sstevel@tonic-gate } 22577c478bd9Sstevel@tonic-gate for (l = pp->pv_list; l != NULL; l = l->lp_next) 22587c478bd9Sstevel@tonic-gate do_complex_rctl_val(l->lp_complex); 22597c478bd9Sstevel@tonic-gate return; 22607c478bd9Sstevel@tonic-gate default: 22617c478bd9Sstevel@tonic-gate zone_perror(rt_to_str(res_type), Z_NO_RESOURCE_TYPE, TRUE); 22627c478bd9Sstevel@tonic-gate long_usage(CMD_ADD, TRUE); 22637c478bd9Sstevel@tonic-gate usage(FALSE, HELP_RESOURCES); 22647c478bd9Sstevel@tonic-gate return; 22657c478bd9Sstevel@tonic-gate } 22667c478bd9Sstevel@tonic-gate } 22677c478bd9Sstevel@tonic-gate 22680209230bSgjelinek static boolean_t 22690209230bSgjelinek gz_invalid_resource(int type) 22700209230bSgjelinek { 22710209230bSgjelinek return (global_zone && (type == RT_FS || type == RT_IPD || 22720209230bSgjelinek type == RT_NET || type == RT_DEVICE || type == RT_ATTR || 22730209230bSgjelinek type == RT_DATASET)); 22740209230bSgjelinek } 22750209230bSgjelinek 22760209230bSgjelinek static boolean_t 22770209230bSgjelinek gz_invalid_rt_property(int type) 22780209230bSgjelinek { 22790209230bSgjelinek return (global_zone && (type == RT_ZONENAME || type == RT_ZONEPATH || 22800209230bSgjelinek type == RT_AUTOBOOT || type == RT_LIMITPRIV || 2281f4b3ec61Sdh type == RT_BOOTARGS || type == RT_BRAND || type == RT_SCHED || 2282f4b3ec61Sdh type == RT_IPTYPE)); 22830209230bSgjelinek } 22840209230bSgjelinek 22850209230bSgjelinek static boolean_t 22860209230bSgjelinek gz_invalid_property(int type) 22870209230bSgjelinek { 22880209230bSgjelinek return (global_zone && (type == PT_ZONENAME || type == PT_ZONEPATH || 22890209230bSgjelinek type == PT_AUTOBOOT || type == PT_LIMITPRIV || 2290f4b3ec61Sdh type == PT_BOOTARGS || type == PT_BRAND || type == PT_SCHED || 2291f4b3ec61Sdh type == PT_IPTYPE)); 22920209230bSgjelinek } 22930209230bSgjelinek 22947c478bd9Sstevel@tonic-gate void 22957c478bd9Sstevel@tonic-gate add_func(cmd_t *cmd) 22967c478bd9Sstevel@tonic-gate { 22977c478bd9Sstevel@tonic-gate int arg; 22987ec75eb8Sgjelinek bool arg_err = FALSE; 22997c478bd9Sstevel@tonic-gate 23007c478bd9Sstevel@tonic-gate assert(cmd != NULL); 23017c478bd9Sstevel@tonic-gate 23027c478bd9Sstevel@tonic-gate optind = 0; 23037ec75eb8Sgjelinek while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?")) != EOF) { 23047c478bd9Sstevel@tonic-gate switch (arg) { 23057c478bd9Sstevel@tonic-gate case '?': 23067c478bd9Sstevel@tonic-gate longer_usage(CMD_ADD); 23077ec75eb8Sgjelinek arg_err = TRUE; 23087ec75eb8Sgjelinek break; 23097c478bd9Sstevel@tonic-gate default: 23107c478bd9Sstevel@tonic-gate short_usage(CMD_ADD); 23117ec75eb8Sgjelinek arg_err = TRUE; 23127ec75eb8Sgjelinek break; 23137c478bd9Sstevel@tonic-gate } 23147c478bd9Sstevel@tonic-gate } 23157ec75eb8Sgjelinek if (arg_err) 23167ec75eb8Sgjelinek return; 23177ec75eb8Sgjelinek 23187c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 23197c478bd9Sstevel@tonic-gate short_usage(CMD_ADD); 23207c478bd9Sstevel@tonic-gate return; 23217c478bd9Sstevel@tonic-gate } 23227c478bd9Sstevel@tonic-gate 23237c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_ADD)) 23247c478bd9Sstevel@tonic-gate return; 23257c478bd9Sstevel@tonic-gate 23267c478bd9Sstevel@tonic-gate if (initialize(TRUE) != Z_OK) 23277c478bd9Sstevel@tonic-gate return; 23287c478bd9Sstevel@tonic-gate if (global_scope) { 23290209230bSgjelinek if (gz_invalid_resource(cmd->cmd_res_type)) { 23300209230bSgjelinek zerr(gettext("Cannot add a %s resource to the " 23310209230bSgjelinek "global zone."), rt_to_str(cmd->cmd_res_type)); 23320209230bSgjelinek saw_error = TRUE; 23330209230bSgjelinek return; 23340209230bSgjelinek } 23350209230bSgjelinek 23367c478bd9Sstevel@tonic-gate global_scope = FALSE; 23377c478bd9Sstevel@tonic-gate resource_scope = cmd->cmd_res_type; 23387c478bd9Sstevel@tonic-gate end_op = CMD_ADD; 23397c478bd9Sstevel@tonic-gate add_resource(cmd); 23407c478bd9Sstevel@tonic-gate } else 23417c478bd9Sstevel@tonic-gate add_property(cmd); 23427c478bd9Sstevel@tonic-gate } 23437c478bd9Sstevel@tonic-gate 2344087719fdSdp /* 2345087719fdSdp * This routine has an unusual implementation, because it tries very 2346087719fdSdp * hard to succeed in the face of a variety of failure modes. 2347087719fdSdp * The most common and most vexing occurs when the index file and 2348087719fdSdp * the /etc/zones/<zonename.xml> file are not both present. In 2349087719fdSdp * this case, delete must eradicate as much of the zone state as is left 2350087719fdSdp * so that the user can later create a new zone with the same name. 2351087719fdSdp */ 23527c478bd9Sstevel@tonic-gate void 23537c478bd9Sstevel@tonic-gate delete_func(cmd_t *cmd) 23547c478bd9Sstevel@tonic-gate { 23557c478bd9Sstevel@tonic-gate int err, arg, answer; 23567c478bd9Sstevel@tonic-gate char line[ZONENAME_MAX + 128]; /* enough to ask a question */ 23577c478bd9Sstevel@tonic-gate bool force = FALSE; 23587ec75eb8Sgjelinek bool arg_err = FALSE; 23597c478bd9Sstevel@tonic-gate 23607c478bd9Sstevel@tonic-gate optind = 0; 23617c478bd9Sstevel@tonic-gate while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?F")) != EOF) { 23627c478bd9Sstevel@tonic-gate switch (arg) { 23637c478bd9Sstevel@tonic-gate case '?': 23647c478bd9Sstevel@tonic-gate longer_usage(CMD_DELETE); 23657ec75eb8Sgjelinek arg_err = TRUE; 23667ec75eb8Sgjelinek break; 23677c478bd9Sstevel@tonic-gate case 'F': 23687c478bd9Sstevel@tonic-gate force = TRUE; 23697c478bd9Sstevel@tonic-gate break; 23707c478bd9Sstevel@tonic-gate default: 23717c478bd9Sstevel@tonic-gate short_usage(CMD_DELETE); 23727ec75eb8Sgjelinek arg_err = TRUE; 23737ec75eb8Sgjelinek break; 23747c478bd9Sstevel@tonic-gate } 23757c478bd9Sstevel@tonic-gate } 23767ec75eb8Sgjelinek if (arg_err) 23777ec75eb8Sgjelinek return; 23787ec75eb8Sgjelinek 23797c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 23807c478bd9Sstevel@tonic-gate short_usage(CMD_DELETE); 23817c478bd9Sstevel@tonic-gate return; 23827c478bd9Sstevel@tonic-gate } 23837c478bd9Sstevel@tonic-gate 23847c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_DELETE)) 23857c478bd9Sstevel@tonic-gate return; 23867c478bd9Sstevel@tonic-gate 23877c478bd9Sstevel@tonic-gate if (!force) { 2388087719fdSdp /* 2389087719fdSdp * Initialize sets up the global called "handle" and warns the 2390087719fdSdp * user if the zone is not configured. In force mode, we don't 2391087719fdSdp * trust that evaluation, and hence skip it. (We don't need the 2392087719fdSdp * handle to be loaded anyway, since zonecfg_destroy is done by 2393087719fdSdp * zonename). However, we also have to take care to emulate the 2394087719fdSdp * messages spit out by initialize; see below. 2395087719fdSdp */ 2396087719fdSdp if (initialize(TRUE) != Z_OK) 2397087719fdSdp return; 2398087719fdSdp 23997c478bd9Sstevel@tonic-gate (void) snprintf(line, sizeof (line), 24007c478bd9Sstevel@tonic-gate gettext("Are you sure you want to delete zone %s"), zone); 24017c478bd9Sstevel@tonic-gate if ((answer = ask_yesno(FALSE, line)) == -1) { 2402087719fdSdp zerr(gettext("Input not from terminal and -F not " 2403087719fdSdp "specified:\n%s command ignored, exiting."), 2404087719fdSdp cmd_to_str(CMD_DELETE)); 24057c478bd9Sstevel@tonic-gate exit(Z_ERR); 24067c478bd9Sstevel@tonic-gate } 24077c478bd9Sstevel@tonic-gate if (answer != 1) 24087c478bd9Sstevel@tonic-gate return; 24097c478bd9Sstevel@tonic-gate } 24107c478bd9Sstevel@tonic-gate 2411087719fdSdp if ((err = zonecfg_destroy(zone, force)) != Z_OK) { 2412087719fdSdp if ((err == Z_BAD_ZONE_STATE) && !force) { 2413087719fdSdp zerr(gettext("Zone %s not in %s state; %s not " 2414087719fdSdp "allowed. Use -F to force %s."), 2415087719fdSdp zone, zone_state_str(ZONE_STATE_CONFIGURED), 2416087719fdSdp cmd_to_str(CMD_DELETE), cmd_to_str(CMD_DELETE)); 2417087719fdSdp } else { 2418087719fdSdp zone_perror(zone, err, TRUE); 2419087719fdSdp } 24207c478bd9Sstevel@tonic-gate } 24217c478bd9Sstevel@tonic-gate need_to_commit = FALSE; 2422087719fdSdp 2423087719fdSdp /* 2424087719fdSdp * Emulate initialize's messaging; if there wasn't a valid handle to 2425087719fdSdp * begin with, then user had typed delete (or delete -F) multiple 2426087719fdSdp * times. So we emit a message. 2427087719fdSdp * 2428087719fdSdp * We only do this in the 'force' case because normally, initialize() 2429087719fdSdp * takes care of this for us. 2430087719fdSdp */ 2431087719fdSdp if (force && zonecfg_check_handle(handle) != Z_OK && interactive_mode) 2432087719fdSdp (void) printf(gettext("Use '%s' to begin " 2433087719fdSdp "configuring a new zone.\n"), cmd_to_str(CMD_CREATE)); 24347c478bd9Sstevel@tonic-gate 24357c478bd9Sstevel@tonic-gate /* 24367c478bd9Sstevel@tonic-gate * Time for a new handle: finish the old one off first 24377c478bd9Sstevel@tonic-gate * then get a new one properly to avoid leaks. 24387c478bd9Sstevel@tonic-gate */ 2439087719fdSdp if (got_handle) { 2440087719fdSdp zonecfg_fini_handle(handle); 2441087719fdSdp if ((handle = zonecfg_init_handle()) == NULL) { 2442087719fdSdp zone_perror(execname, Z_NOMEM, TRUE); 2443087719fdSdp exit(Z_ERR); 2444087719fdSdp } 2445087719fdSdp if ((err = zonecfg_get_handle(zone, handle)) != Z_OK) { 2446087719fdSdp /* If there was no zone before, that's OK */ 2447087719fdSdp if (err != Z_NO_ZONE) 2448087719fdSdp zone_perror(zone, err, TRUE); 2449087719fdSdp got_handle = FALSE; 2450087719fdSdp } 24517c478bd9Sstevel@tonic-gate } 24527c478bd9Sstevel@tonic-gate } 24537c478bd9Sstevel@tonic-gate 24547c478bd9Sstevel@tonic-gate static int 24557c478bd9Sstevel@tonic-gate fill_in_fstab(cmd_t *cmd, struct zone_fstab *fstab, bool fill_in_only) 24567c478bd9Sstevel@tonic-gate { 24577c478bd9Sstevel@tonic-gate int err, i; 24587c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 24597c478bd9Sstevel@tonic-gate 24607c478bd9Sstevel@tonic-gate if ((err = initialize(TRUE)) != Z_OK) 24617c478bd9Sstevel@tonic-gate return (err); 24627c478bd9Sstevel@tonic-gate 2463e193d1e6Svp bzero(fstab, sizeof (*fstab)); 24647c478bd9Sstevel@tonic-gate for (i = 0; i < cmd->cmd_prop_nv_pairs; i++) { 24657c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[i]; 24667c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE || pp->pv_simple == NULL) { 24677c478bd9Sstevel@tonic-gate zerr(gettext("A simple value was expected here.")); 24687c478bd9Sstevel@tonic-gate saw_error = TRUE; 24697c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 24707c478bd9Sstevel@tonic-gate } 24717c478bd9Sstevel@tonic-gate switch (cmd->cmd_prop_name[i]) { 24727c478bd9Sstevel@tonic-gate case PT_DIR: 24737c478bd9Sstevel@tonic-gate (void) strlcpy(fstab->zone_fs_dir, pp->pv_simple, 24747c478bd9Sstevel@tonic-gate sizeof (fstab->zone_fs_dir)); 24757c478bd9Sstevel@tonic-gate break; 24767c478bd9Sstevel@tonic-gate case PT_SPECIAL: 24777c478bd9Sstevel@tonic-gate (void) strlcpy(fstab->zone_fs_special, pp->pv_simple, 24787c478bd9Sstevel@tonic-gate sizeof (fstab->zone_fs_special)); 24797c478bd9Sstevel@tonic-gate break; 24807c478bd9Sstevel@tonic-gate case PT_RAW: 24817c478bd9Sstevel@tonic-gate (void) strlcpy(fstab->zone_fs_raw, pp->pv_simple, 24827c478bd9Sstevel@tonic-gate sizeof (fstab->zone_fs_raw)); 24837c478bd9Sstevel@tonic-gate break; 24847c478bd9Sstevel@tonic-gate case PT_TYPE: 24857c478bd9Sstevel@tonic-gate (void) strlcpy(fstab->zone_fs_type, pp->pv_simple, 24867c478bd9Sstevel@tonic-gate sizeof (fstab->zone_fs_type)); 24877c478bd9Sstevel@tonic-gate break; 24887c478bd9Sstevel@tonic-gate default: 24897c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(cmd->cmd_prop_name[i]), 24907c478bd9Sstevel@tonic-gate Z_NO_PROPERTY_TYPE, TRUE); 24917c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 24927c478bd9Sstevel@tonic-gate } 24937c478bd9Sstevel@tonic-gate } 24947c478bd9Sstevel@tonic-gate if (fill_in_only) 24957c478bd9Sstevel@tonic-gate return (Z_OK); 24967c478bd9Sstevel@tonic-gate return (zonecfg_lookup_filesystem(handle, fstab)); 24977c478bd9Sstevel@tonic-gate } 24987c478bd9Sstevel@tonic-gate 24997c478bd9Sstevel@tonic-gate static int 25007c478bd9Sstevel@tonic-gate fill_in_ipdtab(cmd_t *cmd, struct zone_fstab *ipdtab, bool fill_in_only) 25017c478bd9Sstevel@tonic-gate { 25027c478bd9Sstevel@tonic-gate int err, i; 25037c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 25047c478bd9Sstevel@tonic-gate 25057c478bd9Sstevel@tonic-gate if ((err = initialize(TRUE)) != Z_OK) 25067c478bd9Sstevel@tonic-gate return (err); 25077c478bd9Sstevel@tonic-gate 2508e193d1e6Svp bzero(ipdtab, sizeof (*ipdtab)); 25097c478bd9Sstevel@tonic-gate for (i = 0; i < cmd->cmd_prop_nv_pairs; i++) { 25107c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[i]; 25117c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE || pp->pv_simple == NULL) { 25127c478bd9Sstevel@tonic-gate zerr(gettext("A simple value was expected here.")); 25137c478bd9Sstevel@tonic-gate saw_error = TRUE; 25147c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 25157c478bd9Sstevel@tonic-gate } 25167c478bd9Sstevel@tonic-gate switch (cmd->cmd_prop_name[i]) { 25177c478bd9Sstevel@tonic-gate case PT_DIR: 25187c478bd9Sstevel@tonic-gate (void) strlcpy(ipdtab->zone_fs_dir, pp->pv_simple, 25197c478bd9Sstevel@tonic-gate sizeof (ipdtab->zone_fs_dir)); 25207c478bd9Sstevel@tonic-gate break; 25217c478bd9Sstevel@tonic-gate default: 25227c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(cmd->cmd_prop_name[i]), 25237c478bd9Sstevel@tonic-gate Z_NO_PROPERTY_TYPE, TRUE); 25247c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 25257c478bd9Sstevel@tonic-gate } 25267c478bd9Sstevel@tonic-gate } 25277c478bd9Sstevel@tonic-gate if (fill_in_only) 25287c478bd9Sstevel@tonic-gate return (Z_OK); 25297c478bd9Sstevel@tonic-gate return (zonecfg_lookup_ipd(handle, ipdtab)); 25307c478bd9Sstevel@tonic-gate } 25317c478bd9Sstevel@tonic-gate 25327c478bd9Sstevel@tonic-gate static int 25337c478bd9Sstevel@tonic-gate fill_in_nwiftab(cmd_t *cmd, struct zone_nwiftab *nwiftab, bool fill_in_only) 25347c478bd9Sstevel@tonic-gate { 25357c478bd9Sstevel@tonic-gate int err, i; 25367c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 25377c478bd9Sstevel@tonic-gate 25387c478bd9Sstevel@tonic-gate if ((err = initialize(TRUE)) != Z_OK) 25397c478bd9Sstevel@tonic-gate return (err); 25407c478bd9Sstevel@tonic-gate 2541e193d1e6Svp bzero(nwiftab, sizeof (*nwiftab)); 25427c478bd9Sstevel@tonic-gate for (i = 0; i < cmd->cmd_prop_nv_pairs; i++) { 25437c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[i]; 25447c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE || pp->pv_simple == NULL) { 25457c478bd9Sstevel@tonic-gate zerr(gettext("A simple value was expected here.")); 25467c478bd9Sstevel@tonic-gate saw_error = TRUE; 25477c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 25487c478bd9Sstevel@tonic-gate } 25497c478bd9Sstevel@tonic-gate switch (cmd->cmd_prop_name[i]) { 25507c478bd9Sstevel@tonic-gate case PT_ADDRESS: 25517c478bd9Sstevel@tonic-gate (void) strlcpy(nwiftab->zone_nwif_address, 25527c478bd9Sstevel@tonic-gate pp->pv_simple, sizeof (nwiftab->zone_nwif_address)); 25537c478bd9Sstevel@tonic-gate break; 25547c478bd9Sstevel@tonic-gate case PT_PHYSICAL: 25557c478bd9Sstevel@tonic-gate (void) strlcpy(nwiftab->zone_nwif_physical, 25567c478bd9Sstevel@tonic-gate pp->pv_simple, 25577c478bd9Sstevel@tonic-gate sizeof (nwiftab->zone_nwif_physical)); 25587c478bd9Sstevel@tonic-gate break; 2559*de860bd9Sgfaden case PT_DEFROUTER: 2560*de860bd9Sgfaden (void) strlcpy(nwiftab->zone_nwif_defrouter, 2561*de860bd9Sgfaden pp->pv_simple, 2562*de860bd9Sgfaden sizeof (nwiftab->zone_nwif_defrouter)); 2563*de860bd9Sgfaden break; 25647c478bd9Sstevel@tonic-gate default: 25657c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(cmd->cmd_prop_name[i]), 25667c478bd9Sstevel@tonic-gate Z_NO_PROPERTY_TYPE, TRUE); 25677c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 25687c478bd9Sstevel@tonic-gate } 25697c478bd9Sstevel@tonic-gate } 25707c478bd9Sstevel@tonic-gate if (fill_in_only) 25717c478bd9Sstevel@tonic-gate return (Z_OK); 25727c478bd9Sstevel@tonic-gate err = zonecfg_lookup_nwif(handle, nwiftab); 25737c478bd9Sstevel@tonic-gate return (err); 25747c478bd9Sstevel@tonic-gate } 25757c478bd9Sstevel@tonic-gate 25767c478bd9Sstevel@tonic-gate static int 25777c478bd9Sstevel@tonic-gate fill_in_devtab(cmd_t *cmd, struct zone_devtab *devtab, bool fill_in_only) 25787c478bd9Sstevel@tonic-gate { 25797c478bd9Sstevel@tonic-gate int err, i; 25807c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 25817c478bd9Sstevel@tonic-gate 25827c478bd9Sstevel@tonic-gate if ((err = initialize(TRUE)) != Z_OK) 25837c478bd9Sstevel@tonic-gate return (err); 25847c478bd9Sstevel@tonic-gate 2585e193d1e6Svp bzero(devtab, sizeof (*devtab)); 25867c478bd9Sstevel@tonic-gate for (i = 0; i < cmd->cmd_prop_nv_pairs; i++) { 25877c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[i]; 25887c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE || pp->pv_simple == NULL) { 25897c478bd9Sstevel@tonic-gate zerr(gettext("A simple value was expected here.")); 25907c478bd9Sstevel@tonic-gate saw_error = TRUE; 25917c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 25927c478bd9Sstevel@tonic-gate } 25937c478bd9Sstevel@tonic-gate switch (cmd->cmd_prop_name[i]) { 25947c478bd9Sstevel@tonic-gate case PT_MATCH: 25957c478bd9Sstevel@tonic-gate (void) strlcpy(devtab->zone_dev_match, pp->pv_simple, 25967c478bd9Sstevel@tonic-gate sizeof (devtab->zone_dev_match)); 25977c478bd9Sstevel@tonic-gate break; 25987c478bd9Sstevel@tonic-gate default: 25997c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(cmd->cmd_prop_name[i]), 26007c478bd9Sstevel@tonic-gate Z_NO_PROPERTY_TYPE, TRUE); 26017c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 26027c478bd9Sstevel@tonic-gate } 26037c478bd9Sstevel@tonic-gate } 26047c478bd9Sstevel@tonic-gate if (fill_in_only) 26057c478bd9Sstevel@tonic-gate return (Z_OK); 26067c478bd9Sstevel@tonic-gate err = zonecfg_lookup_dev(handle, devtab); 26077c478bd9Sstevel@tonic-gate return (err); 26087c478bd9Sstevel@tonic-gate } 26097c478bd9Sstevel@tonic-gate 26107c478bd9Sstevel@tonic-gate static int 26117c478bd9Sstevel@tonic-gate fill_in_rctltab(cmd_t *cmd, struct zone_rctltab *rctltab, bool fill_in_only) 26127c478bd9Sstevel@tonic-gate { 26137c478bd9Sstevel@tonic-gate int err, i; 26147c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 26157c478bd9Sstevel@tonic-gate 26167c478bd9Sstevel@tonic-gate if ((err = initialize(TRUE)) != Z_OK) 26177c478bd9Sstevel@tonic-gate return (err); 26187c478bd9Sstevel@tonic-gate 2619e193d1e6Svp bzero(rctltab, sizeof (*rctltab)); 26207c478bd9Sstevel@tonic-gate for (i = 0; i < cmd->cmd_prop_nv_pairs; i++) { 26217c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[i]; 26227c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE || pp->pv_simple == NULL) { 26237c478bd9Sstevel@tonic-gate zerr(gettext("A simple value was expected here.")); 26247c478bd9Sstevel@tonic-gate saw_error = TRUE; 26257c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 26267c478bd9Sstevel@tonic-gate } 26277c478bd9Sstevel@tonic-gate switch (cmd->cmd_prop_name[i]) { 26287c478bd9Sstevel@tonic-gate case PT_NAME: 26297c478bd9Sstevel@tonic-gate (void) strlcpy(rctltab->zone_rctl_name, pp->pv_simple, 26307c478bd9Sstevel@tonic-gate sizeof (rctltab->zone_rctl_name)); 26317c478bd9Sstevel@tonic-gate break; 26327c478bd9Sstevel@tonic-gate default: 26337c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(cmd->cmd_prop_name[i]), 26347c478bd9Sstevel@tonic-gate Z_NO_PROPERTY_TYPE, TRUE); 26357c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 26367c478bd9Sstevel@tonic-gate } 26377c478bd9Sstevel@tonic-gate } 26387c478bd9Sstevel@tonic-gate if (fill_in_only) 26397c478bd9Sstevel@tonic-gate return (Z_OK); 26407c478bd9Sstevel@tonic-gate err = zonecfg_lookup_rctl(handle, rctltab); 26417c478bd9Sstevel@tonic-gate return (err); 26427c478bd9Sstevel@tonic-gate } 26437c478bd9Sstevel@tonic-gate 26447c478bd9Sstevel@tonic-gate static int 26457c478bd9Sstevel@tonic-gate fill_in_attrtab(cmd_t *cmd, struct zone_attrtab *attrtab, bool fill_in_only) 26467c478bd9Sstevel@tonic-gate { 26477c478bd9Sstevel@tonic-gate int err, i; 26487c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 26497c478bd9Sstevel@tonic-gate 26507c478bd9Sstevel@tonic-gate if ((err = initialize(TRUE)) != Z_OK) 26517c478bd9Sstevel@tonic-gate return (err); 26527c478bd9Sstevel@tonic-gate 2653e193d1e6Svp bzero(attrtab, sizeof (*attrtab)); 26547c478bd9Sstevel@tonic-gate for (i = 0; i < cmd->cmd_prop_nv_pairs; i++) { 26557c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[i]; 26567c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE || pp->pv_simple == NULL) { 26577c478bd9Sstevel@tonic-gate zerr(gettext("A simple value was expected here.")); 26587c478bd9Sstevel@tonic-gate saw_error = TRUE; 26597c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 26607c478bd9Sstevel@tonic-gate } 26617c478bd9Sstevel@tonic-gate switch (cmd->cmd_prop_name[i]) { 26627c478bd9Sstevel@tonic-gate case PT_NAME: 26637c478bd9Sstevel@tonic-gate (void) strlcpy(attrtab->zone_attr_name, pp->pv_simple, 26647c478bd9Sstevel@tonic-gate sizeof (attrtab->zone_attr_name)); 26657c478bd9Sstevel@tonic-gate break; 26667c478bd9Sstevel@tonic-gate case PT_TYPE: 26677c478bd9Sstevel@tonic-gate (void) strlcpy(attrtab->zone_attr_type, pp->pv_simple, 26687c478bd9Sstevel@tonic-gate sizeof (attrtab->zone_attr_type)); 26697c478bd9Sstevel@tonic-gate break; 26707c478bd9Sstevel@tonic-gate case PT_VALUE: 26717c478bd9Sstevel@tonic-gate (void) strlcpy(attrtab->zone_attr_value, pp->pv_simple, 26727c478bd9Sstevel@tonic-gate sizeof (attrtab->zone_attr_value)); 26737c478bd9Sstevel@tonic-gate break; 26747c478bd9Sstevel@tonic-gate default: 26757c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(cmd->cmd_prop_name[i]), 26767c478bd9Sstevel@tonic-gate Z_NO_PROPERTY_TYPE, TRUE); 26777c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 26787c478bd9Sstevel@tonic-gate } 26797c478bd9Sstevel@tonic-gate } 26807c478bd9Sstevel@tonic-gate if (fill_in_only) 26817c478bd9Sstevel@tonic-gate return (Z_OK); 26827c478bd9Sstevel@tonic-gate err = zonecfg_lookup_attr(handle, attrtab); 26837c478bd9Sstevel@tonic-gate return (err); 26847c478bd9Sstevel@tonic-gate } 26857c478bd9Sstevel@tonic-gate 2686fa9e4066Sahrens static int 2687fa9e4066Sahrens fill_in_dstab(cmd_t *cmd, struct zone_dstab *dstab, bool fill_in_only) 2688fa9e4066Sahrens { 2689fa9e4066Sahrens int err, i; 2690fa9e4066Sahrens property_value_ptr_t pp; 2691fa9e4066Sahrens 2692fa9e4066Sahrens if ((err = initialize(TRUE)) != Z_OK) 2693fa9e4066Sahrens return (err); 2694fa9e4066Sahrens 2695fa9e4066Sahrens dstab->zone_dataset_name[0] = '\0'; 2696fa9e4066Sahrens for (i = 0; i < cmd->cmd_prop_nv_pairs; i++) { 2697fa9e4066Sahrens pp = cmd->cmd_property_ptr[i]; 2698fa9e4066Sahrens if (pp->pv_type != PROP_VAL_SIMPLE || pp->pv_simple == NULL) { 2699fa9e4066Sahrens zerr(gettext("A simple value was expected here.")); 2700fa9e4066Sahrens saw_error = TRUE; 2701fa9e4066Sahrens return (Z_INSUFFICIENT_SPEC); 2702fa9e4066Sahrens } 2703fa9e4066Sahrens switch (cmd->cmd_prop_name[i]) { 2704fa9e4066Sahrens case PT_NAME: 2705fa9e4066Sahrens (void) strlcpy(dstab->zone_dataset_name, pp->pv_simple, 2706fa9e4066Sahrens sizeof (dstab->zone_dataset_name)); 2707fa9e4066Sahrens break; 2708fa9e4066Sahrens default: 2709fa9e4066Sahrens zone_perror(pt_to_str(cmd->cmd_prop_name[i]), 2710fa9e4066Sahrens Z_NO_PROPERTY_TYPE, TRUE); 2711fa9e4066Sahrens return (Z_INSUFFICIENT_SPEC); 2712fa9e4066Sahrens } 2713fa9e4066Sahrens } 2714fa9e4066Sahrens if (fill_in_only) 2715fa9e4066Sahrens return (Z_OK); 2716fa9e4066Sahrens return (zonecfg_lookup_ds(handle, dstab)); 2717fa9e4066Sahrens } 2718fa9e4066Sahrens 27197c478bd9Sstevel@tonic-gate static void 27200209230bSgjelinek remove_aliased_rctl(int type, char *name) 27217c478bd9Sstevel@tonic-gate { 27220209230bSgjelinek int err; 27230209230bSgjelinek uint64_t tmp; 27247c478bd9Sstevel@tonic-gate 27250209230bSgjelinek if ((err = zonecfg_get_aliased_rctl(handle, name, &tmp)) != Z_OK) { 27260209230bSgjelinek zerr("%s %s: %s", cmd_to_str(CMD_CLEAR), pt_to_str(type), 27270209230bSgjelinek zonecfg_strerror(err)); 27280209230bSgjelinek saw_error = TRUE; 27297c478bd9Sstevel@tonic-gate return; 27307c478bd9Sstevel@tonic-gate } 27310209230bSgjelinek if ((err = zonecfg_rm_aliased_rctl(handle, name)) != Z_OK) { 27320209230bSgjelinek zerr("%s %s: %s", cmd_to_str(CMD_CLEAR), pt_to_str(type), 27330209230bSgjelinek zonecfg_strerror(err)); 27340209230bSgjelinek saw_error = TRUE; 27350209230bSgjelinek } else { 27360209230bSgjelinek need_to_commit = TRUE; 27370209230bSgjelinek } 27380209230bSgjelinek } 27397c478bd9Sstevel@tonic-gate 27400209230bSgjelinek static boolean_t 27410209230bSgjelinek prompt_remove_resource(cmd_t *cmd, char *rsrc) 27420209230bSgjelinek { 27430209230bSgjelinek int num; 27440209230bSgjelinek int answer; 27450209230bSgjelinek int arg; 27460209230bSgjelinek boolean_t force = B_FALSE; 27470209230bSgjelinek char prompt[128]; 27487ec75eb8Sgjelinek bool arg_err = FALSE; 27490209230bSgjelinek 27500209230bSgjelinek optind = 0; 27510209230bSgjelinek while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "F")) != EOF) { 27520209230bSgjelinek switch (arg) { 27530209230bSgjelinek case 'F': 27540209230bSgjelinek force = B_TRUE; 27550209230bSgjelinek break; 27560209230bSgjelinek default: 27577ec75eb8Sgjelinek arg_err = TRUE; 27587ec75eb8Sgjelinek break; 27590209230bSgjelinek } 27600209230bSgjelinek } 27617ec75eb8Sgjelinek if (arg_err) 27627ec75eb8Sgjelinek return (B_FALSE); 27637ec75eb8Sgjelinek 27640209230bSgjelinek 27650209230bSgjelinek num = zonecfg_num_resources(handle, rsrc); 27660209230bSgjelinek 27670209230bSgjelinek if (num == 0) { 27680209230bSgjelinek z_cmd_rt_perror(CMD_REMOVE, cmd->cmd_res_type, Z_NO_ENTRY, 27690209230bSgjelinek TRUE); 27700209230bSgjelinek return (B_FALSE); 27710209230bSgjelinek } 27720209230bSgjelinek if (num > 1 && !force) { 27730209230bSgjelinek if (!interactive_mode) { 27740209230bSgjelinek zerr(gettext("There are multiple instances of this " 27750209230bSgjelinek "resource. Either qualify the resource to\n" 27760209230bSgjelinek "remove a single instance or use the -F option to " 27770209230bSgjelinek "remove all instances.")); 27780209230bSgjelinek saw_error = TRUE; 27790209230bSgjelinek return (B_FALSE); 27800209230bSgjelinek } 27810209230bSgjelinek (void) snprintf(prompt, sizeof (prompt), gettext( 27820209230bSgjelinek "Are you sure you want to remove ALL '%s' resources"), 27830209230bSgjelinek rsrc); 27840209230bSgjelinek answer = ask_yesno(FALSE, prompt); 27850209230bSgjelinek if (answer == -1) { 27860209230bSgjelinek zerr(gettext("Resource incomplete.")); 27870209230bSgjelinek return (B_FALSE); 27880209230bSgjelinek } 27890209230bSgjelinek if (answer != 1) 27900209230bSgjelinek return (B_FALSE); 27910209230bSgjelinek } 27920209230bSgjelinek return (B_TRUE); 27930209230bSgjelinek } 27940209230bSgjelinek 27950209230bSgjelinek static void 27960209230bSgjelinek remove_fs(cmd_t *cmd) 27970209230bSgjelinek { 27980209230bSgjelinek int err; 27990209230bSgjelinek 28000209230bSgjelinek /* traditional, qualified fs removal */ 28010209230bSgjelinek if (cmd->cmd_prop_nv_pairs > 0) { 28020209230bSgjelinek struct zone_fstab fstab; 28037c478bd9Sstevel@tonic-gate 28047c478bd9Sstevel@tonic-gate if ((err = fill_in_fstab(cmd, &fstab, FALSE)) != Z_OK) { 28057c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_REMOVE, RT_FS, err, TRUE); 28067c478bd9Sstevel@tonic-gate return; 28077c478bd9Sstevel@tonic-gate } 28087c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_filesystem(handle, &fstab)) != Z_OK) 28097c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_REMOVE, RT_FS, err, TRUE); 28107c478bd9Sstevel@tonic-gate else 28117c478bd9Sstevel@tonic-gate need_to_commit = TRUE; 28127c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(fstab.zone_fs_options); 28137c478bd9Sstevel@tonic-gate return; 28140209230bSgjelinek } 28150209230bSgjelinek 28160209230bSgjelinek /* 28170209230bSgjelinek * unqualified fs removal. remove all fs's but prompt if more 28180209230bSgjelinek * than one. 28190209230bSgjelinek */ 28200209230bSgjelinek if (!prompt_remove_resource(cmd, "fs")) 28210209230bSgjelinek return; 28220209230bSgjelinek 28230209230bSgjelinek if ((err = zonecfg_del_all_resources(handle, "fs")) != Z_OK) 28240209230bSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_FS, err, TRUE); 28250209230bSgjelinek else 28260209230bSgjelinek need_to_commit = TRUE; 28270209230bSgjelinek } 28280209230bSgjelinek 28290209230bSgjelinek static void 28300209230bSgjelinek remove_ipd(cmd_t *cmd) 28310209230bSgjelinek { 28320209230bSgjelinek int err; 28330209230bSgjelinek 28340209230bSgjelinek if (state_atleast(ZONE_STATE_INSTALLED)) { 28350209230bSgjelinek zerr(gettext("Zone %s already installed; %s %s not allowed."), 28360209230bSgjelinek zone, cmd_to_str(CMD_REMOVE), rt_to_str(RT_IPD)); 28370209230bSgjelinek return; 28380209230bSgjelinek } 28390209230bSgjelinek 28400209230bSgjelinek /* traditional, qualified ipd removal */ 28410209230bSgjelinek if (cmd->cmd_prop_nv_pairs > 0) { 28420209230bSgjelinek struct zone_fstab fstab; 28430209230bSgjelinek 28447c478bd9Sstevel@tonic-gate if ((err = fill_in_ipdtab(cmd, &fstab, FALSE)) != Z_OK) { 28457c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_REMOVE, RT_IPD, err, TRUE); 28467c478bd9Sstevel@tonic-gate return; 28477c478bd9Sstevel@tonic-gate } 28487c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_ipd(handle, &fstab)) != Z_OK) 28497c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_REMOVE, RT_IPD, err, TRUE); 28507c478bd9Sstevel@tonic-gate else 28517c478bd9Sstevel@tonic-gate need_to_commit = TRUE; 28527c478bd9Sstevel@tonic-gate return; 28530209230bSgjelinek } 28540209230bSgjelinek 28550209230bSgjelinek /* 28560209230bSgjelinek * unqualified ipd removal. remove all ipds but prompt if more 28570209230bSgjelinek * than one. 28580209230bSgjelinek */ 28590209230bSgjelinek if (!prompt_remove_resource(cmd, "inherit-pkg-dir")) 28600209230bSgjelinek return; 28610209230bSgjelinek 28620209230bSgjelinek if ((err = zonecfg_del_all_resources(handle, "inherit-pkg-dir")) 28630209230bSgjelinek != Z_OK) 28640209230bSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_IPD, err, TRUE); 28650209230bSgjelinek else 28660209230bSgjelinek need_to_commit = TRUE; 28670209230bSgjelinek } 28680209230bSgjelinek 28690209230bSgjelinek static void 28700209230bSgjelinek remove_net(cmd_t *cmd) 28710209230bSgjelinek { 28720209230bSgjelinek int err; 28730209230bSgjelinek 28740209230bSgjelinek /* traditional, qualified net removal */ 28750209230bSgjelinek if (cmd->cmd_prop_nv_pairs > 0) { 28760209230bSgjelinek struct zone_nwiftab nwiftab; 28770209230bSgjelinek 28787c478bd9Sstevel@tonic-gate if ((err = fill_in_nwiftab(cmd, &nwiftab, FALSE)) != Z_OK) { 28797c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_REMOVE, RT_NET, err, TRUE); 28807c478bd9Sstevel@tonic-gate return; 28817c478bd9Sstevel@tonic-gate } 28827c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_nwif(handle, &nwiftab)) != Z_OK) 28837c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_REMOVE, RT_NET, err, TRUE); 28847c478bd9Sstevel@tonic-gate else 28857c478bd9Sstevel@tonic-gate need_to_commit = TRUE; 28867c478bd9Sstevel@tonic-gate return; 28870209230bSgjelinek } 28880209230bSgjelinek 28890209230bSgjelinek /* 28900209230bSgjelinek * unqualified net removal. remove all nets but prompt if more 28910209230bSgjelinek * than one. 28920209230bSgjelinek */ 28930209230bSgjelinek if (!prompt_remove_resource(cmd, "net")) 28940209230bSgjelinek return; 28950209230bSgjelinek 28960209230bSgjelinek if ((err = zonecfg_del_all_resources(handle, "net")) != Z_OK) 28970209230bSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_NET, err, TRUE); 28980209230bSgjelinek else 28990209230bSgjelinek need_to_commit = TRUE; 29000209230bSgjelinek } 29010209230bSgjelinek 29020209230bSgjelinek static void 29030209230bSgjelinek remove_device(cmd_t *cmd) 29040209230bSgjelinek { 29050209230bSgjelinek int err; 29060209230bSgjelinek 29070209230bSgjelinek /* traditional, qualified device removal */ 29080209230bSgjelinek if (cmd->cmd_prop_nv_pairs > 0) { 29090209230bSgjelinek struct zone_devtab devtab; 29100209230bSgjelinek 29117c478bd9Sstevel@tonic-gate if ((err = fill_in_devtab(cmd, &devtab, FALSE)) != Z_OK) { 29127c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_REMOVE, RT_DEVICE, err, TRUE); 29137c478bd9Sstevel@tonic-gate return; 29147c478bd9Sstevel@tonic-gate } 29157c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_dev(handle, &devtab)) != Z_OK) 29167c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_REMOVE, RT_DEVICE, err, TRUE); 29177c478bd9Sstevel@tonic-gate else 29187c478bd9Sstevel@tonic-gate need_to_commit = TRUE; 29197c478bd9Sstevel@tonic-gate return; 29200209230bSgjelinek } 29210209230bSgjelinek 29220209230bSgjelinek /* 29230209230bSgjelinek * unqualified device removal. remove all devices but prompt if more 29240209230bSgjelinek * than one. 29250209230bSgjelinek */ 29260209230bSgjelinek if (!prompt_remove_resource(cmd, "device")) 29277c478bd9Sstevel@tonic-gate return; 29280209230bSgjelinek 29290209230bSgjelinek if ((err = zonecfg_del_all_resources(handle, "device")) != Z_OK) 29300209230bSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_DEVICE, err, TRUE); 29310209230bSgjelinek else 29320209230bSgjelinek need_to_commit = TRUE; 29330209230bSgjelinek } 29340209230bSgjelinek 29350209230bSgjelinek static void 29360209230bSgjelinek remove_attr(cmd_t *cmd) 29370209230bSgjelinek { 29380209230bSgjelinek int err; 29390209230bSgjelinek 29400209230bSgjelinek /* traditional, qualified attr removal */ 29410209230bSgjelinek if (cmd->cmd_prop_nv_pairs > 0) { 29420209230bSgjelinek struct zone_attrtab attrtab; 29430209230bSgjelinek 29447c478bd9Sstevel@tonic-gate if ((err = fill_in_attrtab(cmd, &attrtab, FALSE)) != Z_OK) { 29457c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_REMOVE, RT_ATTR, err, TRUE); 29467c478bd9Sstevel@tonic-gate return; 29477c478bd9Sstevel@tonic-gate } 29487c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_attr(handle, &attrtab)) != Z_OK) 29497c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_REMOVE, RT_ATTR, err, TRUE); 29507c478bd9Sstevel@tonic-gate else 29517c478bd9Sstevel@tonic-gate need_to_commit = TRUE; 29527c478bd9Sstevel@tonic-gate return; 29530209230bSgjelinek } 29540209230bSgjelinek 29550209230bSgjelinek /* 29560209230bSgjelinek * unqualified attr removal. remove all attrs but prompt if more 29570209230bSgjelinek * than one. 29580209230bSgjelinek */ 29590209230bSgjelinek if (!prompt_remove_resource(cmd, "attr")) 29600209230bSgjelinek return; 29610209230bSgjelinek 29620209230bSgjelinek if ((err = zonecfg_del_all_resources(handle, "attr")) != Z_OK) 29630209230bSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_ATTR, err, TRUE); 29640209230bSgjelinek else 29650209230bSgjelinek need_to_commit = TRUE; 29660209230bSgjelinek } 29670209230bSgjelinek 29680209230bSgjelinek static void 29690209230bSgjelinek remove_dataset(cmd_t *cmd) 29700209230bSgjelinek { 29710209230bSgjelinek int err; 29720209230bSgjelinek 29730209230bSgjelinek /* traditional, qualified dataset removal */ 29740209230bSgjelinek if (cmd->cmd_prop_nv_pairs > 0) { 29750209230bSgjelinek struct zone_dstab dstab; 29760209230bSgjelinek 2977fa9e4066Sahrens if ((err = fill_in_dstab(cmd, &dstab, FALSE)) != Z_OK) { 2978fa9e4066Sahrens z_cmd_rt_perror(CMD_REMOVE, RT_DATASET, err, TRUE); 2979fa9e4066Sahrens return; 2980fa9e4066Sahrens } 2981fa9e4066Sahrens if ((err = zonecfg_delete_ds(handle, &dstab)) != Z_OK) 2982fa9e4066Sahrens z_cmd_rt_perror(CMD_REMOVE, RT_DATASET, err, TRUE); 2983fa9e4066Sahrens else 2984fa9e4066Sahrens need_to_commit = TRUE; 2985fa9e4066Sahrens return; 29867c478bd9Sstevel@tonic-gate } 29870209230bSgjelinek 29880209230bSgjelinek /* 29890209230bSgjelinek * unqualified dataset removal. remove all datasets but prompt if more 29900209230bSgjelinek * than one. 29910209230bSgjelinek */ 29920209230bSgjelinek if (!prompt_remove_resource(cmd, "dataset")) 29930209230bSgjelinek return; 29940209230bSgjelinek 29950209230bSgjelinek if ((err = zonecfg_del_all_resources(handle, "dataset")) != Z_OK) 29960209230bSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_DATASET, err, TRUE); 29970209230bSgjelinek else 29980209230bSgjelinek need_to_commit = TRUE; 29990209230bSgjelinek } 30000209230bSgjelinek 30010209230bSgjelinek static void 30020209230bSgjelinek remove_rctl(cmd_t *cmd) 30030209230bSgjelinek { 30040209230bSgjelinek int err; 30050209230bSgjelinek 30060209230bSgjelinek /* traditional, qualified rctl removal */ 30070209230bSgjelinek if (cmd->cmd_prop_nv_pairs > 0) { 30080209230bSgjelinek struct zone_rctltab rctltab; 30090209230bSgjelinek 30100209230bSgjelinek if ((err = fill_in_rctltab(cmd, &rctltab, FALSE)) != Z_OK) { 30110209230bSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_RCTL, err, TRUE); 30120209230bSgjelinek return; 30130209230bSgjelinek } 30140209230bSgjelinek if ((err = zonecfg_delete_rctl(handle, &rctltab)) != Z_OK) 30150209230bSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_RCTL, err, TRUE); 30160209230bSgjelinek else 30170209230bSgjelinek need_to_commit = TRUE; 30180209230bSgjelinek zonecfg_free_rctl_value_list(rctltab.zone_rctl_valptr); 30190209230bSgjelinek return; 30200209230bSgjelinek } 30210209230bSgjelinek 30220209230bSgjelinek /* 30230209230bSgjelinek * unqualified rctl removal. remove all rctls but prompt if more 30240209230bSgjelinek * than one. 30250209230bSgjelinek */ 30260209230bSgjelinek if (!prompt_remove_resource(cmd, "rctl")) 30270209230bSgjelinek return; 30280209230bSgjelinek 30290209230bSgjelinek if ((err = zonecfg_del_all_resources(handle, "rctl")) != Z_OK) 30300209230bSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_RCTL, err, TRUE); 30310209230bSgjelinek else 30320209230bSgjelinek need_to_commit = TRUE; 30330209230bSgjelinek } 30340209230bSgjelinek 30350209230bSgjelinek static void 30360209230bSgjelinek remove_pset() 30370209230bSgjelinek { 30380209230bSgjelinek int err; 30390209230bSgjelinek struct zone_psettab psettab; 30400209230bSgjelinek 30410209230bSgjelinek if ((err = zonecfg_lookup_pset(handle, &psettab)) != Z_OK) { 30420209230bSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_DCPU, err, TRUE); 30430209230bSgjelinek return; 30440209230bSgjelinek } 30450209230bSgjelinek if ((err = zonecfg_delete_pset(handle)) != Z_OK) 30460209230bSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_DCPU, err, TRUE); 30470209230bSgjelinek else 30480209230bSgjelinek need_to_commit = TRUE; 30490209230bSgjelinek } 30500209230bSgjelinek 3051c97ad5cdSakolb static void 3052c97ad5cdSakolb remove_pcap() 3053c97ad5cdSakolb { 3054c97ad5cdSakolb int err; 3055c97ad5cdSakolb uint64_t tmp; 3056c97ad5cdSakolb 3057c97ad5cdSakolb if (zonecfg_get_aliased_rctl(handle, ALIAS_CPUCAP, &tmp) != Z_OK) { 3058c97ad5cdSakolb zerr("%s %s: %s", cmd_to_str(CMD_REMOVE), rt_to_str(RT_PCAP), 3059c97ad5cdSakolb zonecfg_strerror(Z_NO_RESOURCE_TYPE)); 3060c97ad5cdSakolb saw_error = TRUE; 3061c97ad5cdSakolb return; 3062c97ad5cdSakolb } 3063c97ad5cdSakolb 3064c97ad5cdSakolb if ((err = zonecfg_rm_aliased_rctl(handle, ALIAS_CPUCAP)) != Z_OK) 3065c97ad5cdSakolb z_cmd_rt_perror(CMD_REMOVE, RT_PCAP, err, TRUE); 3066c97ad5cdSakolb else 3067c97ad5cdSakolb need_to_commit = TRUE; 3068c97ad5cdSakolb } 3069c97ad5cdSakolb 30700209230bSgjelinek static void 30710209230bSgjelinek remove_mcap() 30720209230bSgjelinek { 30730209230bSgjelinek int err, res1, res2, res3; 30740209230bSgjelinek uint64_t tmp; 30750209230bSgjelinek struct zone_mcaptab mcaptab; 30760209230bSgjelinek boolean_t revert = B_FALSE; 30770209230bSgjelinek 30780209230bSgjelinek res1 = zonecfg_lookup_mcap(handle, &mcaptab); 30790209230bSgjelinek res2 = zonecfg_get_aliased_rctl(handle, ALIAS_MAXSWAP, &tmp); 30800209230bSgjelinek res3 = zonecfg_get_aliased_rctl(handle, ALIAS_MAXLOCKEDMEM, &tmp); 30810209230bSgjelinek 30820209230bSgjelinek /* if none of these exist, there is no resource to remove */ 30830209230bSgjelinek if (res1 != Z_OK && res2 != Z_OK && res3 != Z_OK) { 30840209230bSgjelinek zerr("%s %s: %s", cmd_to_str(CMD_REMOVE), rt_to_str(RT_MCAP), 30850209230bSgjelinek zonecfg_strerror(Z_NO_RESOURCE_TYPE)); 30860209230bSgjelinek saw_error = TRUE; 30870209230bSgjelinek return; 30880209230bSgjelinek } 30890209230bSgjelinek if (res1 == Z_OK) { 30900209230bSgjelinek if ((err = zonecfg_delete_mcap(handle)) != Z_OK) { 30910209230bSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_MCAP, err, TRUE); 30920209230bSgjelinek revert = B_TRUE; 30930209230bSgjelinek } else { 30940209230bSgjelinek need_to_commit = TRUE; 30950209230bSgjelinek } 30960209230bSgjelinek } 30970209230bSgjelinek if (res2 == Z_OK) { 30980209230bSgjelinek if ((err = zonecfg_rm_aliased_rctl(handle, ALIAS_MAXSWAP)) 30990209230bSgjelinek != Z_OK) { 31000209230bSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_MCAP, err, TRUE); 31010209230bSgjelinek revert = B_TRUE; 31020209230bSgjelinek } else { 31030209230bSgjelinek need_to_commit = TRUE; 31040209230bSgjelinek } 31050209230bSgjelinek } 31060209230bSgjelinek if (res3 == Z_OK) { 31070209230bSgjelinek if ((err = zonecfg_rm_aliased_rctl(handle, ALIAS_MAXLOCKEDMEM)) 31080209230bSgjelinek != Z_OK) { 31090209230bSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_MCAP, err, TRUE); 31100209230bSgjelinek revert = B_TRUE; 31110209230bSgjelinek } else { 31120209230bSgjelinek need_to_commit = TRUE; 31130209230bSgjelinek } 31140209230bSgjelinek } 31150209230bSgjelinek 31160209230bSgjelinek if (revert) 31170209230bSgjelinek need_to_commit = FALSE; 31180209230bSgjelinek } 31190209230bSgjelinek 31200209230bSgjelinek static void 31210209230bSgjelinek remove_resource(cmd_t *cmd) 31220209230bSgjelinek { 31230209230bSgjelinek int type; 31240209230bSgjelinek int arg; 31257ec75eb8Sgjelinek bool arg_err = FALSE; 31260209230bSgjelinek 31270209230bSgjelinek if ((type = cmd->cmd_res_type) == RT_UNKNOWN) { 31280209230bSgjelinek long_usage(CMD_REMOVE, TRUE); 31290209230bSgjelinek return; 31300209230bSgjelinek } 31310209230bSgjelinek 31320209230bSgjelinek optind = 0; 31330209230bSgjelinek while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?F")) != EOF) { 31340209230bSgjelinek switch (arg) { 31350209230bSgjelinek case '?': 31360209230bSgjelinek longer_usage(CMD_REMOVE); 31377ec75eb8Sgjelinek arg_err = TRUE; 31387ec75eb8Sgjelinek break; 31390209230bSgjelinek case 'F': 31400209230bSgjelinek break; 31410209230bSgjelinek default: 31420209230bSgjelinek short_usage(CMD_REMOVE); 31437ec75eb8Sgjelinek arg_err = TRUE; 31447ec75eb8Sgjelinek break; 31450209230bSgjelinek } 31460209230bSgjelinek } 31477ec75eb8Sgjelinek if (arg_err) 31487ec75eb8Sgjelinek return; 31490209230bSgjelinek 31500209230bSgjelinek if (initialize(TRUE) != Z_OK) 31510209230bSgjelinek return; 31520209230bSgjelinek 31530209230bSgjelinek switch (type) { 31540209230bSgjelinek case RT_FS: 31550209230bSgjelinek remove_fs(cmd); 31560209230bSgjelinek return; 31570209230bSgjelinek case RT_IPD: 31580209230bSgjelinek remove_ipd(cmd); 31590209230bSgjelinek return; 31600209230bSgjelinek case RT_NET: 31610209230bSgjelinek remove_net(cmd); 31620209230bSgjelinek return; 31630209230bSgjelinek case RT_DEVICE: 31640209230bSgjelinek remove_device(cmd); 31650209230bSgjelinek return; 31660209230bSgjelinek case RT_RCTL: 31670209230bSgjelinek remove_rctl(cmd); 31680209230bSgjelinek return; 31690209230bSgjelinek case RT_ATTR: 31700209230bSgjelinek remove_attr(cmd); 31710209230bSgjelinek return; 31720209230bSgjelinek case RT_DATASET: 31730209230bSgjelinek remove_dataset(cmd); 31740209230bSgjelinek return; 31750209230bSgjelinek case RT_DCPU: 31760209230bSgjelinek remove_pset(); 31770209230bSgjelinek return; 3178c97ad5cdSakolb case RT_PCAP: 3179c97ad5cdSakolb remove_pcap(); 3180c97ad5cdSakolb return; 31810209230bSgjelinek case RT_MCAP: 31820209230bSgjelinek remove_mcap(); 31830209230bSgjelinek return; 31840209230bSgjelinek default: 31850209230bSgjelinek zone_perror(rt_to_str(type), Z_NO_RESOURCE_TYPE, TRUE); 31860209230bSgjelinek long_usage(CMD_REMOVE, TRUE); 31870209230bSgjelinek usage(FALSE, HELP_RESOURCES); 31880209230bSgjelinek return; 31890209230bSgjelinek } 31900209230bSgjelinek } 31917c478bd9Sstevel@tonic-gate 31927c478bd9Sstevel@tonic-gate static void 31937c478bd9Sstevel@tonic-gate remove_property(cmd_t *cmd) 31947c478bd9Sstevel@tonic-gate { 31957c478bd9Sstevel@tonic-gate char *prop_id; 31967c478bd9Sstevel@tonic-gate int err, res_type, prop_type; 31977c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 31987c478bd9Sstevel@tonic-gate struct zone_rctlvaltab *rctlvaltab; 31997c478bd9Sstevel@tonic-gate complex_property_ptr_t cx; 32007c478bd9Sstevel@tonic-gate 32017c478bd9Sstevel@tonic-gate res_type = resource_scope; 32027c478bd9Sstevel@tonic-gate prop_type = cmd->cmd_prop_name[0]; 32037c478bd9Sstevel@tonic-gate if (res_type == RT_UNKNOWN || prop_type == PT_UNKNOWN) { 32047c478bd9Sstevel@tonic-gate long_usage(CMD_REMOVE, TRUE); 32057c478bd9Sstevel@tonic-gate return; 32067c478bd9Sstevel@tonic-gate } 32077c478bd9Sstevel@tonic-gate 32087c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs != 1) { 32097c478bd9Sstevel@tonic-gate long_usage(CMD_ADD, TRUE); 32107c478bd9Sstevel@tonic-gate return; 32117c478bd9Sstevel@tonic-gate } 32127c478bd9Sstevel@tonic-gate 32137c478bd9Sstevel@tonic-gate if (initialize(TRUE) != Z_OK) 32147c478bd9Sstevel@tonic-gate return; 32157c478bd9Sstevel@tonic-gate 32167c478bd9Sstevel@tonic-gate switch (res_type) { 32177c478bd9Sstevel@tonic-gate case RT_FS: 32187c478bd9Sstevel@tonic-gate if (prop_type != PT_OPTIONS) { 32197c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 32207c478bd9Sstevel@tonic-gate TRUE); 32217c478bd9Sstevel@tonic-gate long_usage(CMD_REMOVE, TRUE); 32227c478bd9Sstevel@tonic-gate usage(FALSE, HELP_PROPS); 32237c478bd9Sstevel@tonic-gate return; 32247c478bd9Sstevel@tonic-gate } 32257c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[0]; 32267c478bd9Sstevel@tonic-gate if (pp->pv_type == PROP_VAL_COMPLEX) { 32277c478bd9Sstevel@tonic-gate zerr(gettext("A %s or %s value was expected here."), 32287c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_SIMPLE), 32297c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_LIST)); 32307c478bd9Sstevel@tonic-gate saw_error = TRUE; 32317c478bd9Sstevel@tonic-gate return; 32327c478bd9Sstevel@tonic-gate } 32337c478bd9Sstevel@tonic-gate if (pp->pv_type == PROP_VAL_SIMPLE) { 32347c478bd9Sstevel@tonic-gate if (pp->pv_simple == NULL) { 32357c478bd9Sstevel@tonic-gate long_usage(CMD_ADD, TRUE); 32367c478bd9Sstevel@tonic-gate return; 32377c478bd9Sstevel@tonic-gate } 32387c478bd9Sstevel@tonic-gate prop_id = pp->pv_simple; 32397c478bd9Sstevel@tonic-gate err = zonecfg_remove_fs_option(&in_progress_fstab, 32407c478bd9Sstevel@tonic-gate prop_id); 32417c478bd9Sstevel@tonic-gate if (err != Z_OK) 32427c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), err, TRUE); 32437c478bd9Sstevel@tonic-gate } else { 32447c478bd9Sstevel@tonic-gate list_property_ptr_t list; 32457c478bd9Sstevel@tonic-gate 32467c478bd9Sstevel@tonic-gate for (list = pp->pv_list; list != NULL; 32477c478bd9Sstevel@tonic-gate list = list->lp_next) { 32487c478bd9Sstevel@tonic-gate prop_id = list->lp_simple; 32497c478bd9Sstevel@tonic-gate if (prop_id == NULL) 32507c478bd9Sstevel@tonic-gate break; 32517c478bd9Sstevel@tonic-gate err = zonecfg_remove_fs_option( 32527c478bd9Sstevel@tonic-gate &in_progress_fstab, prop_id); 32537c478bd9Sstevel@tonic-gate if (err != Z_OK) 32547c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), err, 32557c478bd9Sstevel@tonic-gate TRUE); 32567c478bd9Sstevel@tonic-gate } 32577c478bd9Sstevel@tonic-gate } 32587c478bd9Sstevel@tonic-gate return; 32597c478bd9Sstevel@tonic-gate case RT_RCTL: 32607c478bd9Sstevel@tonic-gate if (prop_type != PT_VALUE) { 32617c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 32627c478bd9Sstevel@tonic-gate TRUE); 32637c478bd9Sstevel@tonic-gate long_usage(CMD_REMOVE, TRUE); 32647c478bd9Sstevel@tonic-gate usage(FALSE, HELP_PROPS); 32657c478bd9Sstevel@tonic-gate return; 32667c478bd9Sstevel@tonic-gate } 32677c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[0]; 32687c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_COMPLEX) { 32697c478bd9Sstevel@tonic-gate zerr(gettext("A %s value was expected here."), 32707c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_COMPLEX)); 32717c478bd9Sstevel@tonic-gate saw_error = TRUE; 32727c478bd9Sstevel@tonic-gate return; 32737c478bd9Sstevel@tonic-gate } 32747c478bd9Sstevel@tonic-gate if ((rctlvaltab = alloc_rctlvaltab()) == NULL) { 32757c478bd9Sstevel@tonic-gate zone_perror(zone, Z_NOMEM, TRUE); 32767c478bd9Sstevel@tonic-gate exit(Z_ERR); 32777c478bd9Sstevel@tonic-gate } 32787c478bd9Sstevel@tonic-gate for (cx = pp->pv_complex; cx != NULL; cx = cx->cp_next) { 32797c478bd9Sstevel@tonic-gate switch (cx->cp_type) { 32807c478bd9Sstevel@tonic-gate case PT_PRIV: 32817c478bd9Sstevel@tonic-gate (void) strlcpy(rctlvaltab->zone_rctlval_priv, 32827c478bd9Sstevel@tonic-gate cx->cp_value, 32837c478bd9Sstevel@tonic-gate sizeof (rctlvaltab->zone_rctlval_priv)); 32847c478bd9Sstevel@tonic-gate break; 32857c478bd9Sstevel@tonic-gate case PT_LIMIT: 32867c478bd9Sstevel@tonic-gate (void) strlcpy(rctlvaltab->zone_rctlval_limit, 32877c478bd9Sstevel@tonic-gate cx->cp_value, 32887c478bd9Sstevel@tonic-gate sizeof (rctlvaltab->zone_rctlval_limit)); 32897c478bd9Sstevel@tonic-gate break; 32907c478bd9Sstevel@tonic-gate case PT_ACTION: 32917c478bd9Sstevel@tonic-gate (void) strlcpy(rctlvaltab->zone_rctlval_action, 32927c478bd9Sstevel@tonic-gate cx->cp_value, 32937c478bd9Sstevel@tonic-gate sizeof (rctlvaltab->zone_rctlval_action)); 32947c478bd9Sstevel@tonic-gate break; 32957c478bd9Sstevel@tonic-gate default: 32967c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), 32977c478bd9Sstevel@tonic-gate Z_NO_PROPERTY_TYPE, TRUE); 32987c478bd9Sstevel@tonic-gate long_usage(CMD_ADD, TRUE); 32997c478bd9Sstevel@tonic-gate usage(FALSE, HELP_PROPS); 33007c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctlvaltab); 33017c478bd9Sstevel@tonic-gate return; 33027c478bd9Sstevel@tonic-gate } 33037c478bd9Sstevel@tonic-gate } 33047c478bd9Sstevel@tonic-gate rctlvaltab->zone_rctlval_next = NULL; 33057c478bd9Sstevel@tonic-gate err = zonecfg_remove_rctl_value(&in_progress_rctltab, 33067c478bd9Sstevel@tonic-gate rctlvaltab); 33077c478bd9Sstevel@tonic-gate if (err != Z_OK) 33087c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), err, TRUE); 33097c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctlvaltab); 33107c478bd9Sstevel@tonic-gate return; 3311*de860bd9Sgfaden case RT_NET: 3312*de860bd9Sgfaden if (prop_type != PT_DEFROUTER) { 3313*de860bd9Sgfaden zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 3314*de860bd9Sgfaden TRUE); 3315*de860bd9Sgfaden long_usage(CMD_REMOVE, TRUE); 3316*de860bd9Sgfaden usage(FALSE, HELP_PROPS); 3317*de860bd9Sgfaden return; 3318*de860bd9Sgfaden } else { 3319*de860bd9Sgfaden bzero(&in_progress_nwiftab.zone_nwif_defrouter, 3320*de860bd9Sgfaden sizeof (in_progress_nwiftab.zone_nwif_defrouter)); 3321*de860bd9Sgfaden return; 3322*de860bd9Sgfaden } 33237c478bd9Sstevel@tonic-gate default: 33247c478bd9Sstevel@tonic-gate zone_perror(rt_to_str(res_type), Z_NO_RESOURCE_TYPE, TRUE); 33257c478bd9Sstevel@tonic-gate long_usage(CMD_REMOVE, TRUE); 33267c478bd9Sstevel@tonic-gate usage(FALSE, HELP_RESOURCES); 33277c478bd9Sstevel@tonic-gate return; 33287c478bd9Sstevel@tonic-gate } 33297c478bd9Sstevel@tonic-gate } 33307c478bd9Sstevel@tonic-gate 33317c478bd9Sstevel@tonic-gate void 33327c478bd9Sstevel@tonic-gate remove_func(cmd_t *cmd) 33337c478bd9Sstevel@tonic-gate { 33347c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_REMOVE)) 33357c478bd9Sstevel@tonic-gate return; 33367c478bd9Sstevel@tonic-gate 33377c478bd9Sstevel@tonic-gate assert(cmd != NULL); 33387c478bd9Sstevel@tonic-gate 33390209230bSgjelinek if (global_scope) { 33400209230bSgjelinek if (gz_invalid_resource(cmd->cmd_res_type)) { 33410209230bSgjelinek zerr(gettext("%s is not a valid resource for the " 33420209230bSgjelinek "global zone."), rt_to_str(cmd->cmd_res_type)); 33430209230bSgjelinek saw_error = TRUE; 33440209230bSgjelinek return; 33450209230bSgjelinek } 33467c478bd9Sstevel@tonic-gate remove_resource(cmd); 33470209230bSgjelinek } else { 33487c478bd9Sstevel@tonic-gate remove_property(cmd); 33490209230bSgjelinek } 33500209230bSgjelinek } 33510209230bSgjelinek 33520209230bSgjelinek static void 33530209230bSgjelinek clear_property(cmd_t *cmd) 33540209230bSgjelinek { 33550209230bSgjelinek int res_type, prop_type; 33560209230bSgjelinek 33570209230bSgjelinek res_type = resource_scope; 33580209230bSgjelinek prop_type = cmd->cmd_res_type; 33590209230bSgjelinek if (res_type == RT_UNKNOWN || prop_type == PT_UNKNOWN) { 33600209230bSgjelinek long_usage(CMD_CLEAR, TRUE); 33610209230bSgjelinek return; 33620209230bSgjelinek } 33630209230bSgjelinek 33640209230bSgjelinek if (initialize(TRUE) != Z_OK) 33650209230bSgjelinek return; 33660209230bSgjelinek 33670209230bSgjelinek switch (res_type) { 33680209230bSgjelinek case RT_FS: 33690209230bSgjelinek if (prop_type == PT_RAW) { 33700209230bSgjelinek in_progress_fstab.zone_fs_raw[0] = '\0'; 33710209230bSgjelinek need_to_commit = TRUE; 33720209230bSgjelinek return; 33730209230bSgjelinek } 33740209230bSgjelinek break; 33750209230bSgjelinek case RT_DCPU: 33760209230bSgjelinek if (prop_type == PT_IMPORTANCE) { 33770209230bSgjelinek in_progress_psettab.zone_importance[0] = '\0'; 33780209230bSgjelinek need_to_commit = TRUE; 33790209230bSgjelinek return; 33800209230bSgjelinek } 33810209230bSgjelinek break; 33820209230bSgjelinek case RT_MCAP: 33830209230bSgjelinek switch (prop_type) { 33840209230bSgjelinek case PT_PHYSICAL: 33850209230bSgjelinek in_progress_mcaptab.zone_physmem_cap[0] = '\0'; 33860209230bSgjelinek need_to_commit = TRUE; 33870209230bSgjelinek return; 33880209230bSgjelinek case PT_SWAP: 33890209230bSgjelinek remove_aliased_rctl(PT_SWAP, ALIAS_MAXSWAP); 33900209230bSgjelinek return; 33910209230bSgjelinek case PT_LOCKED: 33920209230bSgjelinek remove_aliased_rctl(PT_LOCKED, ALIAS_MAXLOCKEDMEM); 33930209230bSgjelinek return; 33940209230bSgjelinek } 33950209230bSgjelinek break; 33960209230bSgjelinek default: 33970209230bSgjelinek break; 33980209230bSgjelinek } 33990209230bSgjelinek 34000209230bSgjelinek zone_perror(pt_to_str(prop_type), Z_CLEAR_DISALLOW, TRUE); 34010209230bSgjelinek } 34020209230bSgjelinek 34030209230bSgjelinek static void 34040209230bSgjelinek clear_global(cmd_t *cmd) 34050209230bSgjelinek { 34060209230bSgjelinek int err, type; 34070209230bSgjelinek 34080209230bSgjelinek if ((type = cmd->cmd_res_type) == RT_UNKNOWN) { 34090209230bSgjelinek long_usage(CMD_CLEAR, TRUE); 34100209230bSgjelinek return; 34110209230bSgjelinek } 34120209230bSgjelinek 34130209230bSgjelinek if (initialize(TRUE) != Z_OK) 34140209230bSgjelinek return; 34150209230bSgjelinek 34160209230bSgjelinek switch (type) { 34170209230bSgjelinek case PT_ZONENAME: 34180209230bSgjelinek /* FALLTHRU */ 34190209230bSgjelinek case PT_ZONEPATH: 34200209230bSgjelinek /* FALLTHRU */ 34210209230bSgjelinek case PT_BRAND: 34220209230bSgjelinek zone_perror(pt_to_str(type), Z_CLEAR_DISALLOW, TRUE); 34230209230bSgjelinek return; 34240209230bSgjelinek case PT_AUTOBOOT: 34250209230bSgjelinek /* false is default; we'll treat as equivalent to clearing */ 34260209230bSgjelinek if ((err = zonecfg_set_autoboot(handle, B_FALSE)) != Z_OK) 34270209230bSgjelinek z_cmd_rt_perror(CMD_CLEAR, RT_AUTOBOOT, err, TRUE); 34280209230bSgjelinek else 34290209230bSgjelinek need_to_commit = TRUE; 34300209230bSgjelinek return; 34310209230bSgjelinek case PT_POOL: 34320209230bSgjelinek if ((err = zonecfg_set_pool(handle, NULL)) != Z_OK) 34330209230bSgjelinek z_cmd_rt_perror(CMD_CLEAR, RT_POOL, err, TRUE); 34340209230bSgjelinek else 34350209230bSgjelinek need_to_commit = TRUE; 34360209230bSgjelinek return; 34370209230bSgjelinek case PT_LIMITPRIV: 34380209230bSgjelinek if ((err = zonecfg_set_limitpriv(handle, NULL)) != Z_OK) 34390209230bSgjelinek z_cmd_rt_perror(CMD_CLEAR, RT_LIMITPRIV, err, TRUE); 34400209230bSgjelinek else 34410209230bSgjelinek need_to_commit = TRUE; 34420209230bSgjelinek return; 34430209230bSgjelinek case PT_BOOTARGS: 34440209230bSgjelinek if ((err = zonecfg_set_bootargs(handle, NULL)) != Z_OK) 34450209230bSgjelinek z_cmd_rt_perror(CMD_CLEAR, RT_BOOTARGS, err, TRUE); 34460209230bSgjelinek else 34470209230bSgjelinek need_to_commit = TRUE; 34480209230bSgjelinek return; 34490209230bSgjelinek case PT_SCHED: 34500209230bSgjelinek if ((err = zonecfg_set_sched(handle, NULL)) != Z_OK) 34510209230bSgjelinek z_cmd_rt_perror(CMD_CLEAR, RT_SCHED, err, TRUE); 34520209230bSgjelinek else 34530209230bSgjelinek need_to_commit = TRUE; 34540209230bSgjelinek return; 3455f4b3ec61Sdh case PT_IPTYPE: 3456f4b3ec61Sdh /* shared is default; we'll treat as equivalent to clearing */ 3457f4b3ec61Sdh if ((err = zonecfg_set_iptype(handle, ZS_SHARED)) != Z_OK) 3458f4b3ec61Sdh z_cmd_rt_perror(CMD_CLEAR, RT_IPTYPE, err, TRUE); 3459f4b3ec61Sdh else 3460f4b3ec61Sdh need_to_commit = TRUE; 3461f4b3ec61Sdh return; 34620209230bSgjelinek case PT_MAXLWPS: 34630209230bSgjelinek remove_aliased_rctl(PT_MAXLWPS, ALIAS_MAXLWPS); 34640209230bSgjelinek return; 34650209230bSgjelinek case PT_MAXSHMMEM: 34660209230bSgjelinek remove_aliased_rctl(PT_MAXSHMMEM, ALIAS_MAXSHMMEM); 34670209230bSgjelinek return; 34680209230bSgjelinek case PT_MAXSHMIDS: 34690209230bSgjelinek remove_aliased_rctl(PT_MAXSHMIDS, ALIAS_MAXSHMIDS); 34700209230bSgjelinek return; 34710209230bSgjelinek case PT_MAXMSGIDS: 34720209230bSgjelinek remove_aliased_rctl(PT_MAXMSGIDS, ALIAS_MAXMSGIDS); 34730209230bSgjelinek return; 34740209230bSgjelinek case PT_MAXSEMIDS: 34750209230bSgjelinek remove_aliased_rctl(PT_MAXSEMIDS, ALIAS_MAXSEMIDS); 34760209230bSgjelinek return; 34770209230bSgjelinek case PT_SHARES: 34780209230bSgjelinek remove_aliased_rctl(PT_SHARES, ALIAS_SHARES); 34790209230bSgjelinek return; 34800209230bSgjelinek default: 34810209230bSgjelinek zone_perror(pt_to_str(type), Z_NO_PROPERTY_TYPE, TRUE); 34820209230bSgjelinek long_usage(CMD_CLEAR, TRUE); 34830209230bSgjelinek usage(FALSE, HELP_PROPS); 34840209230bSgjelinek return; 34850209230bSgjelinek } 34860209230bSgjelinek } 34870209230bSgjelinek 34880209230bSgjelinek void 34890209230bSgjelinek clear_func(cmd_t *cmd) 34900209230bSgjelinek { 34910209230bSgjelinek if (zone_is_read_only(CMD_CLEAR)) 34920209230bSgjelinek return; 34930209230bSgjelinek 34940209230bSgjelinek assert(cmd != NULL); 34950209230bSgjelinek 34960209230bSgjelinek if (global_scope) { 34970209230bSgjelinek if (gz_invalid_property(cmd->cmd_res_type)) { 34980209230bSgjelinek zerr(gettext("%s is not a valid property for the " 34990209230bSgjelinek "global zone."), pt_to_str(cmd->cmd_res_type)); 35000209230bSgjelinek saw_error = TRUE; 35010209230bSgjelinek return; 35020209230bSgjelinek } 35030209230bSgjelinek 35040209230bSgjelinek clear_global(cmd); 35050209230bSgjelinek } else { 35060209230bSgjelinek clear_property(cmd); 35070209230bSgjelinek } 35087c478bd9Sstevel@tonic-gate } 35097c478bd9Sstevel@tonic-gate 35107c478bd9Sstevel@tonic-gate void 35117c478bd9Sstevel@tonic-gate select_func(cmd_t *cmd) 35127c478bd9Sstevel@tonic-gate { 35130209230bSgjelinek int type, err, res; 35140209230bSgjelinek uint64_t limit; 3515c97ad5cdSakolb uint64_t tmp; 35167c478bd9Sstevel@tonic-gate 35177c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_SELECT)) 35187c478bd9Sstevel@tonic-gate return; 35197c478bd9Sstevel@tonic-gate 35207c478bd9Sstevel@tonic-gate assert(cmd != NULL); 35217c478bd9Sstevel@tonic-gate 35227c478bd9Sstevel@tonic-gate if (global_scope) { 35237c478bd9Sstevel@tonic-gate global_scope = FALSE; 35247c478bd9Sstevel@tonic-gate resource_scope = cmd->cmd_res_type; 35257c478bd9Sstevel@tonic-gate end_op = CMD_SELECT; 35267c478bd9Sstevel@tonic-gate } else { 35277c478bd9Sstevel@tonic-gate scope_usage(CMD_SELECT); 35287c478bd9Sstevel@tonic-gate return; 35297c478bd9Sstevel@tonic-gate } 35307c478bd9Sstevel@tonic-gate 35317c478bd9Sstevel@tonic-gate if ((type = cmd->cmd_res_type) == RT_UNKNOWN) { 35327c478bd9Sstevel@tonic-gate long_usage(CMD_SELECT, TRUE); 35337c478bd9Sstevel@tonic-gate return; 35347c478bd9Sstevel@tonic-gate } 35357c478bd9Sstevel@tonic-gate 35367c478bd9Sstevel@tonic-gate if (initialize(TRUE) != Z_OK) 35377c478bd9Sstevel@tonic-gate return; 35387c478bd9Sstevel@tonic-gate 35397c478bd9Sstevel@tonic-gate switch (type) { 35407c478bd9Sstevel@tonic-gate case RT_FS: 35417c478bd9Sstevel@tonic-gate if ((err = fill_in_fstab(cmd, &old_fstab, FALSE)) != Z_OK) { 35427c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_SELECT, RT_FS, err, TRUE); 35437c478bd9Sstevel@tonic-gate global_scope = TRUE; 35447c478bd9Sstevel@tonic-gate } 35457c478bd9Sstevel@tonic-gate bcopy(&old_fstab, &in_progress_fstab, 35467c478bd9Sstevel@tonic-gate sizeof (struct zone_fstab)); 35477c478bd9Sstevel@tonic-gate return; 35487c478bd9Sstevel@tonic-gate case RT_IPD: 3549087719fdSdp if (state_atleast(ZONE_STATE_INCOMPLETE)) { 35507c478bd9Sstevel@tonic-gate zerr(gettext("Zone %s not in %s state; %s %s not " 35517c478bd9Sstevel@tonic-gate "allowed."), zone, 35527c478bd9Sstevel@tonic-gate zone_state_str(ZONE_STATE_CONFIGURED), 35537c478bd9Sstevel@tonic-gate cmd_to_str(CMD_SELECT), rt_to_str(RT_IPD)); 35547c478bd9Sstevel@tonic-gate global_scope = TRUE; 35557c478bd9Sstevel@tonic-gate end_op = -1; 35567c478bd9Sstevel@tonic-gate return; 35577c478bd9Sstevel@tonic-gate } 35587c478bd9Sstevel@tonic-gate if ((err = fill_in_ipdtab(cmd, &old_ipdtab, FALSE)) != Z_OK) { 35597c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_SELECT, RT_IPD, err, TRUE); 35607c478bd9Sstevel@tonic-gate global_scope = TRUE; 35617c478bd9Sstevel@tonic-gate } 35627c478bd9Sstevel@tonic-gate bcopy(&old_ipdtab, &in_progress_ipdtab, 35637c478bd9Sstevel@tonic-gate sizeof (struct zone_fstab)); 35647c478bd9Sstevel@tonic-gate return; 35657c478bd9Sstevel@tonic-gate case RT_NET: 35667c478bd9Sstevel@tonic-gate if ((err = fill_in_nwiftab(cmd, &old_nwiftab, FALSE)) != Z_OK) { 35677c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_SELECT, RT_NET, err, TRUE); 35687c478bd9Sstevel@tonic-gate global_scope = TRUE; 35697c478bd9Sstevel@tonic-gate } 35707c478bd9Sstevel@tonic-gate bcopy(&old_nwiftab, &in_progress_nwiftab, 35717c478bd9Sstevel@tonic-gate sizeof (struct zone_nwiftab)); 35727c478bd9Sstevel@tonic-gate return; 35737c478bd9Sstevel@tonic-gate case RT_DEVICE: 35747c478bd9Sstevel@tonic-gate if ((err = fill_in_devtab(cmd, &old_devtab, FALSE)) != Z_OK) { 35757c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_SELECT, RT_DEVICE, err, TRUE); 35767c478bd9Sstevel@tonic-gate global_scope = TRUE; 35777c478bd9Sstevel@tonic-gate } 35787c478bd9Sstevel@tonic-gate bcopy(&old_devtab, &in_progress_devtab, 35797c478bd9Sstevel@tonic-gate sizeof (struct zone_devtab)); 35807c478bd9Sstevel@tonic-gate return; 35817c478bd9Sstevel@tonic-gate case RT_RCTL: 35827c478bd9Sstevel@tonic-gate if ((err = fill_in_rctltab(cmd, &old_rctltab, FALSE)) != Z_OK) { 35837c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_SELECT, RT_RCTL, err, TRUE); 35847c478bd9Sstevel@tonic-gate global_scope = TRUE; 35857c478bd9Sstevel@tonic-gate } 35867c478bd9Sstevel@tonic-gate bcopy(&old_rctltab, &in_progress_rctltab, 35877c478bd9Sstevel@tonic-gate sizeof (struct zone_rctltab)); 35887c478bd9Sstevel@tonic-gate return; 35897c478bd9Sstevel@tonic-gate case RT_ATTR: 35907c478bd9Sstevel@tonic-gate if ((err = fill_in_attrtab(cmd, &old_attrtab, FALSE)) != Z_OK) { 35917c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_SELECT, RT_ATTR, err, TRUE); 35927c478bd9Sstevel@tonic-gate global_scope = TRUE; 35937c478bd9Sstevel@tonic-gate } 35947c478bd9Sstevel@tonic-gate bcopy(&old_attrtab, &in_progress_attrtab, 35957c478bd9Sstevel@tonic-gate sizeof (struct zone_attrtab)); 35967c478bd9Sstevel@tonic-gate return; 3597fa9e4066Sahrens case RT_DATASET: 3598fa9e4066Sahrens if ((err = fill_in_dstab(cmd, &old_dstab, FALSE)) != Z_OK) { 3599fa9e4066Sahrens z_cmd_rt_perror(CMD_SELECT, RT_DATASET, err, TRUE); 3600fa9e4066Sahrens global_scope = TRUE; 3601fa9e4066Sahrens } 3602fa9e4066Sahrens bcopy(&old_dstab, &in_progress_dstab, 3603fa9e4066Sahrens sizeof (struct zone_dstab)); 3604fa9e4066Sahrens return; 36050209230bSgjelinek case RT_DCPU: 36060209230bSgjelinek if ((err = zonecfg_lookup_pset(handle, &old_psettab)) != Z_OK) { 36070209230bSgjelinek z_cmd_rt_perror(CMD_SELECT, RT_DCPU, err, TRUE); 36080209230bSgjelinek global_scope = TRUE; 36090209230bSgjelinek } 36100209230bSgjelinek bcopy(&old_psettab, &in_progress_psettab, 36110209230bSgjelinek sizeof (struct zone_psettab)); 36120209230bSgjelinek return; 3613c97ad5cdSakolb case RT_PCAP: 3614c97ad5cdSakolb if ((err = zonecfg_get_aliased_rctl(handle, ALIAS_CPUCAP, &tmp)) 3615c97ad5cdSakolb != Z_OK) { 3616c97ad5cdSakolb z_cmd_rt_perror(CMD_SELECT, RT_PCAP, err, TRUE); 3617c97ad5cdSakolb global_scope = TRUE; 3618c97ad5cdSakolb } 3619c97ad5cdSakolb return; 36200209230bSgjelinek case RT_MCAP: 36210209230bSgjelinek /* if none of these exist, there is no resource to select */ 36220209230bSgjelinek if ((res = zonecfg_lookup_mcap(handle, &old_mcaptab)) != Z_OK && 36230209230bSgjelinek zonecfg_get_aliased_rctl(handle, ALIAS_MAXSWAP, &limit) 36240209230bSgjelinek != Z_OK && 36250209230bSgjelinek zonecfg_get_aliased_rctl(handle, ALIAS_MAXLOCKEDMEM, &limit) 36260209230bSgjelinek != Z_OK) { 36270209230bSgjelinek z_cmd_rt_perror(CMD_SELECT, RT_MCAP, Z_NO_RESOURCE_TYPE, 36280209230bSgjelinek TRUE); 36290209230bSgjelinek global_scope = TRUE; 36300209230bSgjelinek } 36310209230bSgjelinek if (res == Z_OK) 36320209230bSgjelinek bcopy(&old_mcaptab, &in_progress_mcaptab, 36330209230bSgjelinek sizeof (struct zone_mcaptab)); 36340209230bSgjelinek else 36350209230bSgjelinek bzero(&in_progress_mcaptab, 36360209230bSgjelinek sizeof (in_progress_mcaptab)); 36370209230bSgjelinek return; 36387c478bd9Sstevel@tonic-gate default: 36397c478bd9Sstevel@tonic-gate zone_perror(rt_to_str(type), Z_NO_RESOURCE_TYPE, TRUE); 36407c478bd9Sstevel@tonic-gate long_usage(CMD_SELECT, TRUE); 36417c478bd9Sstevel@tonic-gate usage(FALSE, HELP_RESOURCES); 36427c478bd9Sstevel@tonic-gate return; 36437c478bd9Sstevel@tonic-gate } 36447c478bd9Sstevel@tonic-gate } 36457c478bd9Sstevel@tonic-gate 36467c478bd9Sstevel@tonic-gate /* 36477c478bd9Sstevel@tonic-gate * Network "addresses" can be one of the following forms: 36487c478bd9Sstevel@tonic-gate * <IPv4 address> 36497c478bd9Sstevel@tonic-gate * <IPv4 address>/<prefix length> 36507c478bd9Sstevel@tonic-gate * <IPv6 address>/<prefix length> 36517c478bd9Sstevel@tonic-gate * <host name> 36527c478bd9Sstevel@tonic-gate * <host name>/<prefix length> 36537c478bd9Sstevel@tonic-gate * In other words, the "/" followed by a prefix length is allowed but not 36547c478bd9Sstevel@tonic-gate * required for IPv4 addresses and host names, and required for IPv6 addresses. 36557c478bd9Sstevel@tonic-gate * If a prefix length is given, it must be in the allowable range: 0 to 32 for 36567c478bd9Sstevel@tonic-gate * IPv4 addresses and host names, 0 to 128 for IPv6 addresses. 36577c478bd9Sstevel@tonic-gate * Host names must start with an alpha-numeric character, and all subsequent 36587c478bd9Sstevel@tonic-gate * characters must be either alpha-numeric or "-". 36597c478bd9Sstevel@tonic-gate */ 36607c478bd9Sstevel@tonic-gate 36617c478bd9Sstevel@tonic-gate static int 36627c478bd9Sstevel@tonic-gate validate_net_address_syntax(char *address) 36637c478bd9Sstevel@tonic-gate { 36647c478bd9Sstevel@tonic-gate char *slashp, part1[MAXHOSTNAMELEN]; 36657c478bd9Sstevel@tonic-gate struct in6_addr in6; 36667c478bd9Sstevel@tonic-gate struct in_addr in4; 36677c478bd9Sstevel@tonic-gate int prefixlen, i; 36687c478bd9Sstevel@tonic-gate 36697c478bd9Sstevel@tonic-gate /* 36707c478bd9Sstevel@tonic-gate * Copy the part before any '/' into part1 or copy the whole 36717c478bd9Sstevel@tonic-gate * thing if there is no '/'. 36727c478bd9Sstevel@tonic-gate */ 36737c478bd9Sstevel@tonic-gate if ((slashp = strchr(address, '/')) != NULL) { 36747c478bd9Sstevel@tonic-gate *slashp = '\0'; 36757c478bd9Sstevel@tonic-gate (void) strlcpy(part1, address, sizeof (part1)); 36767c478bd9Sstevel@tonic-gate *slashp = '/'; 36777c478bd9Sstevel@tonic-gate prefixlen = atoi(++slashp); 36787c478bd9Sstevel@tonic-gate } else { 36797c478bd9Sstevel@tonic-gate (void) strlcpy(part1, address, sizeof (part1)); 36807c478bd9Sstevel@tonic-gate } 36817c478bd9Sstevel@tonic-gate 36827c478bd9Sstevel@tonic-gate if (inet_pton(AF_INET6, part1, &in6) == 1) { 36837c478bd9Sstevel@tonic-gate if (slashp == NULL) { 36847c478bd9Sstevel@tonic-gate zerr(gettext("%s: IPv6 addresses " 36857c478bd9Sstevel@tonic-gate "require /prefix-length suffix."), address); 36867c478bd9Sstevel@tonic-gate return (Z_ERR); 36877c478bd9Sstevel@tonic-gate } 36887c478bd9Sstevel@tonic-gate if (prefixlen < 0 || prefixlen > 128) { 36897c478bd9Sstevel@tonic-gate zerr(gettext("%s: IPv6 address " 36907c478bd9Sstevel@tonic-gate "prefix lengths must be 0 - 128."), address); 36917c478bd9Sstevel@tonic-gate return (Z_ERR); 36927c478bd9Sstevel@tonic-gate } 36937c478bd9Sstevel@tonic-gate return (Z_OK); 36947c478bd9Sstevel@tonic-gate } 36957c478bd9Sstevel@tonic-gate 36967c478bd9Sstevel@tonic-gate /* At this point, any /prefix must be for IPv4. */ 36977c478bd9Sstevel@tonic-gate if (slashp != NULL) { 36987c478bd9Sstevel@tonic-gate if (prefixlen < 0 || prefixlen > 32) { 36997c478bd9Sstevel@tonic-gate zerr(gettext("%s: IPv4 address " 37007c478bd9Sstevel@tonic-gate "prefix lengths must be 0 - 32."), address); 37017c478bd9Sstevel@tonic-gate return (Z_ERR); 37027c478bd9Sstevel@tonic-gate } 37037c478bd9Sstevel@tonic-gate } 37047c478bd9Sstevel@tonic-gate if (inet_pton(AF_INET, part1, &in4) == 1) 37057c478bd9Sstevel@tonic-gate return (Z_OK); 37067c478bd9Sstevel@tonic-gate 37077c478bd9Sstevel@tonic-gate /* address may also be a host name */ 37087c478bd9Sstevel@tonic-gate if (!isalnum(part1[0])) { 37097c478bd9Sstevel@tonic-gate zerr(gettext("%s: bogus host name or network address syntax"), 37107c478bd9Sstevel@tonic-gate part1); 37117c478bd9Sstevel@tonic-gate saw_error = TRUE; 37127c478bd9Sstevel@tonic-gate usage(FALSE, HELP_NETADDR); 37137c478bd9Sstevel@tonic-gate return (Z_ERR); 37147c478bd9Sstevel@tonic-gate } 37157c478bd9Sstevel@tonic-gate for (i = 1; part1[i]; i++) 37167c478bd9Sstevel@tonic-gate if (!isalnum(part1[i]) && part1[i] != '-' && part1[i] != '.') { 37177c478bd9Sstevel@tonic-gate zerr(gettext("%s: bogus host name or " 37187c478bd9Sstevel@tonic-gate "network address syntax"), part1); 37197c478bd9Sstevel@tonic-gate saw_error = TRUE; 37207c478bd9Sstevel@tonic-gate usage(FALSE, HELP_NETADDR); 37217c478bd9Sstevel@tonic-gate return (Z_ERR); 37227c478bd9Sstevel@tonic-gate } 37237c478bd9Sstevel@tonic-gate return (Z_OK); 37247c478bd9Sstevel@tonic-gate } 37257c478bd9Sstevel@tonic-gate 37267c478bd9Sstevel@tonic-gate static int 37277c478bd9Sstevel@tonic-gate validate_net_physical_syntax(char *ifname) 37287c478bd9Sstevel@tonic-gate { 37297c478bd9Sstevel@tonic-gate if (strchr(ifname, ':') == NULL) 37307c478bd9Sstevel@tonic-gate return (Z_OK); 37317c478bd9Sstevel@tonic-gate zerr(gettext("%s: physical interface name required; " 37327c478bd9Sstevel@tonic-gate "logical interface name not allowed"), ifname); 37337c478bd9Sstevel@tonic-gate return (Z_ERR); 37347c478bd9Sstevel@tonic-gate } 37357c478bd9Sstevel@tonic-gate 37367c478bd9Sstevel@tonic-gate static boolean_t 37377c478bd9Sstevel@tonic-gate valid_fs_type(const char *type) 37387c478bd9Sstevel@tonic-gate { 37397c478bd9Sstevel@tonic-gate /* 37407c478bd9Sstevel@tonic-gate * Is this a valid path component? 37417c478bd9Sstevel@tonic-gate */ 37427c478bd9Sstevel@tonic-gate if (strlen(type) + 1 > MAXNAMELEN) 37437c478bd9Sstevel@tonic-gate return (B_FALSE); 37447c478bd9Sstevel@tonic-gate /* 37457c478bd9Sstevel@tonic-gate * Make sure a bad value for "type" doesn't make 37467c478bd9Sstevel@tonic-gate * /usr/lib/fs/<type>/mount turn into something else. 37477c478bd9Sstevel@tonic-gate */ 37487c478bd9Sstevel@tonic-gate if (strchr(type, '/') != NULL || type[0] == '\0' || 37497c478bd9Sstevel@tonic-gate strcmp(type, ".") == 0 || strcmp(type, "..") == 0) 3750087719fdSdp return (B_FALSE); 37517c478bd9Sstevel@tonic-gate /* 37527c478bd9Sstevel@tonic-gate * More detailed verification happens later by zoneadm(1m). 37537c478bd9Sstevel@tonic-gate */ 37547c478bd9Sstevel@tonic-gate return (B_TRUE); 37557c478bd9Sstevel@tonic-gate } 37567c478bd9Sstevel@tonic-gate 3757f4b3ec61Sdh static boolean_t 3758f4b3ec61Sdh allow_exclusive() 3759f4b3ec61Sdh { 3760f4b3ec61Sdh brand_handle_t bh; 3761f4b3ec61Sdh char brand[MAXNAMELEN]; 3762f4b3ec61Sdh boolean_t ret; 3763f4b3ec61Sdh 3764f4b3ec61Sdh if (zonecfg_get_brand(handle, brand, sizeof (brand)) != Z_OK) { 3765f4b3ec61Sdh zerr("%s: %s\n", zone, gettext("could not get zone brand")); 3766f4b3ec61Sdh return (B_FALSE); 3767f4b3ec61Sdh } 3768f4b3ec61Sdh if ((bh = brand_open(brand)) == NULL) { 3769f4b3ec61Sdh zerr("%s: %s\n", zone, gettext("unknown brand.")); 3770f4b3ec61Sdh return (B_FALSE); 3771f4b3ec61Sdh } 3772f4b3ec61Sdh ret = brand_allow_exclusive_ip(bh); 3773f4b3ec61Sdh brand_close(bh); 3774f4b3ec61Sdh if (!ret) 3775f4b3ec61Sdh zerr(gettext("%s cannot be '%s' when %s is '%s'."), 3776f4b3ec61Sdh pt_to_str(PT_IPTYPE), "exclusive", 3777f4b3ec61Sdh pt_to_str(PT_BRAND), brand); 3778f4b3ec61Sdh return (ret); 3779f4b3ec61Sdh } 3780f4b3ec61Sdh 37810209230bSgjelinek static void 37820209230bSgjelinek set_aliased_rctl(char *alias, int prop_type, char *s) 37830209230bSgjelinek { 37840209230bSgjelinek uint64_t limit; 37850209230bSgjelinek int err; 37860209230bSgjelinek char tmp[128]; 37870209230bSgjelinek 37880209230bSgjelinek if (global_zone && strcmp(alias, ALIAS_SHARES) != 0) 37890209230bSgjelinek zerr(gettext("WARNING: Setting a global zone resource " 37900209230bSgjelinek "control too low could deny\nservice " 37910209230bSgjelinek "to even the root user; " 37920209230bSgjelinek "this could render the system impossible\n" 37930209230bSgjelinek "to administer. Please use caution.")); 37940209230bSgjelinek 37950209230bSgjelinek /* convert memory based properties */ 37960209230bSgjelinek if (prop_type == PT_MAXSHMMEM) { 37970209230bSgjelinek if (!zonecfg_valid_memlimit(s, &limit)) { 37980209230bSgjelinek zerr(gettext("A non-negative number with a required " 37990209230bSgjelinek "scale suffix (K, M, G or T) was expected\nhere.")); 38000209230bSgjelinek saw_error = TRUE; 38010209230bSgjelinek return; 38020209230bSgjelinek } 38030209230bSgjelinek 38040209230bSgjelinek (void) snprintf(tmp, sizeof (tmp), "%llu", limit); 38050209230bSgjelinek s = tmp; 38060209230bSgjelinek } 38070209230bSgjelinek 38080209230bSgjelinek if (!zonecfg_aliased_rctl_ok(handle, alias)) { 38090209230bSgjelinek zone_perror(pt_to_str(prop_type), Z_ALIAS_DISALLOW, FALSE); 38100209230bSgjelinek saw_error = TRUE; 38110209230bSgjelinek } else if (!zonecfg_valid_alias_limit(alias, s, &limit)) { 38120209230bSgjelinek zerr(gettext("%s property is out of range."), 38130209230bSgjelinek pt_to_str(prop_type)); 38140209230bSgjelinek saw_error = TRUE; 38150209230bSgjelinek } else if ((err = zonecfg_set_aliased_rctl(handle, alias, limit)) 38160209230bSgjelinek != Z_OK) { 38170209230bSgjelinek zone_perror(zone, err, TRUE); 38180209230bSgjelinek saw_error = TRUE; 38190209230bSgjelinek } else { 38200209230bSgjelinek need_to_commit = TRUE; 38210209230bSgjelinek } 38220209230bSgjelinek } 38230209230bSgjelinek 38247c478bd9Sstevel@tonic-gate void 38257c478bd9Sstevel@tonic-gate set_func(cmd_t *cmd) 38267c478bd9Sstevel@tonic-gate { 38277c478bd9Sstevel@tonic-gate char *prop_id; 3828555afedfScarlsonj int arg, err, res_type, prop_type; 38297c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 38307c478bd9Sstevel@tonic-gate boolean_t autoboot; 3831f4b3ec61Sdh zone_iptype_t iptype; 3832555afedfScarlsonj boolean_t force_set = FALSE; 38330209230bSgjelinek size_t physmem_size = sizeof (in_progress_mcaptab.zone_physmem_cap); 38340209230bSgjelinek uint64_t mem_cap, mem_limit; 3835c97ad5cdSakolb float cap; 3836c97ad5cdSakolb char *unitp; 38370209230bSgjelinek struct zone_psettab tmp_psettab; 38387ec75eb8Sgjelinek bool arg_err = FALSE; 38397c478bd9Sstevel@tonic-gate 38407c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_SET)) 38417c478bd9Sstevel@tonic-gate return; 38427c478bd9Sstevel@tonic-gate 38437c478bd9Sstevel@tonic-gate assert(cmd != NULL); 38447c478bd9Sstevel@tonic-gate 3845555afedfScarlsonj optind = opterr = 0; 3846555afedfScarlsonj while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "F")) != EOF) { 3847555afedfScarlsonj switch (arg) { 3848555afedfScarlsonj case 'F': 3849555afedfScarlsonj force_set = TRUE; 3850555afedfScarlsonj break; 3851555afedfScarlsonj default: 3852555afedfScarlsonj if (optopt == '?') 3853555afedfScarlsonj longer_usage(CMD_SET); 3854555afedfScarlsonj else 3855555afedfScarlsonj short_usage(CMD_SET); 38567ec75eb8Sgjelinek arg_err = TRUE; 38577ec75eb8Sgjelinek break; 3858555afedfScarlsonj } 3859555afedfScarlsonj } 38607ec75eb8Sgjelinek if (arg_err) 38617ec75eb8Sgjelinek return; 3862555afedfScarlsonj 38637c478bd9Sstevel@tonic-gate prop_type = cmd->cmd_prop_name[0]; 38647c478bd9Sstevel@tonic-gate if (global_scope) { 38650209230bSgjelinek if (gz_invalid_property(prop_type)) { 38660209230bSgjelinek zerr(gettext("%s is not a valid property for the " 38670209230bSgjelinek "global zone."), pt_to_str(prop_type)); 38680209230bSgjelinek saw_error = TRUE; 38690209230bSgjelinek return; 38700209230bSgjelinek } 38710209230bSgjelinek 3872087719fdSdp if (prop_type == PT_ZONENAME) { 3873087719fdSdp res_type = RT_ZONENAME; 3874087719fdSdp } else if (prop_type == PT_ZONEPATH) { 38757c478bd9Sstevel@tonic-gate res_type = RT_ZONEPATH; 38767c478bd9Sstevel@tonic-gate } else if (prop_type == PT_AUTOBOOT) { 38777c478bd9Sstevel@tonic-gate res_type = RT_AUTOBOOT; 38789acbbeafSnn } else if (prop_type == PT_BRAND) { 38799acbbeafSnn res_type = RT_BRAND; 38807c478bd9Sstevel@tonic-gate } else if (prop_type == PT_POOL) { 38817c478bd9Sstevel@tonic-gate res_type = RT_POOL; 3882ffbafc53Scomay } else if (prop_type == PT_LIMITPRIV) { 3883ffbafc53Scomay res_type = RT_LIMITPRIV; 38843f2f09c1Sdp } else if (prop_type == PT_BOOTARGS) { 38853f2f09c1Sdp res_type = RT_BOOTARGS; 38860209230bSgjelinek } else if (prop_type == PT_SCHED) { 38870209230bSgjelinek res_type = RT_SCHED; 3888f4b3ec61Sdh } else if (prop_type == PT_IPTYPE) { 3889f4b3ec61Sdh res_type = RT_IPTYPE; 38900209230bSgjelinek } else if (prop_type == PT_MAXLWPS) { 38910209230bSgjelinek res_type = RT_MAXLWPS; 38920209230bSgjelinek } else if (prop_type == PT_MAXSHMMEM) { 38930209230bSgjelinek res_type = RT_MAXSHMMEM; 38940209230bSgjelinek } else if (prop_type == PT_MAXSHMIDS) { 38950209230bSgjelinek res_type = RT_MAXSHMIDS; 38960209230bSgjelinek } else if (prop_type == PT_MAXMSGIDS) { 38970209230bSgjelinek res_type = RT_MAXMSGIDS; 38980209230bSgjelinek } else if (prop_type == PT_MAXSEMIDS) { 38990209230bSgjelinek res_type = RT_MAXSEMIDS; 39000209230bSgjelinek } else if (prop_type == PT_SHARES) { 39010209230bSgjelinek res_type = RT_SHARES; 39027c478bd9Sstevel@tonic-gate } else { 39037c478bd9Sstevel@tonic-gate zerr(gettext("Cannot set a resource-specific property " 39047c478bd9Sstevel@tonic-gate "from the global scope.")); 39057c478bd9Sstevel@tonic-gate saw_error = TRUE; 39067c478bd9Sstevel@tonic-gate return; 39077c478bd9Sstevel@tonic-gate } 39087c478bd9Sstevel@tonic-gate } else { 39097c478bd9Sstevel@tonic-gate res_type = resource_scope; 39107c478bd9Sstevel@tonic-gate } 39117c478bd9Sstevel@tonic-gate 3912555afedfScarlsonj if (force_set) { 3913555afedfScarlsonj if (res_type != RT_ZONEPATH) { 3914555afedfScarlsonj zerr(gettext("Only zonepath setting can be forced.")); 3915555afedfScarlsonj saw_error = TRUE; 3916555afedfScarlsonj return; 3917555afedfScarlsonj } 3918555afedfScarlsonj if (!zonecfg_in_alt_root()) { 3919555afedfScarlsonj zerr(gettext("Zonepath is changeable only in an " 3920555afedfScarlsonj "alternate root.")); 3921555afedfScarlsonj saw_error = TRUE; 3922555afedfScarlsonj return; 3923555afedfScarlsonj } 3924555afedfScarlsonj } 3925555afedfScarlsonj 39267c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[0]; 39277c478bd9Sstevel@tonic-gate /* 39287c478bd9Sstevel@tonic-gate * A nasty expression but not that complicated: 39297c478bd9Sstevel@tonic-gate * 1. fs options are simple or list (tested below) 39307c478bd9Sstevel@tonic-gate * 2. rctl value's are complex or list (tested below) 39317c478bd9Sstevel@tonic-gate * Anything else should be simple. 39327c478bd9Sstevel@tonic-gate */ 39337c478bd9Sstevel@tonic-gate if (!(res_type == RT_FS && prop_type == PT_OPTIONS) && 39347c478bd9Sstevel@tonic-gate !(res_type == RT_RCTL && prop_type == PT_VALUE) && 39357c478bd9Sstevel@tonic-gate (pp->pv_type != PROP_VAL_SIMPLE || 39367c478bd9Sstevel@tonic-gate (prop_id = pp->pv_simple) == NULL)) { 39377c478bd9Sstevel@tonic-gate zerr(gettext("A %s value was expected here."), 39387c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_SIMPLE)); 39397c478bd9Sstevel@tonic-gate saw_error = TRUE; 39407c478bd9Sstevel@tonic-gate return; 39417c478bd9Sstevel@tonic-gate } 39427c478bd9Sstevel@tonic-gate if (prop_type == PT_UNKNOWN) { 39437c478bd9Sstevel@tonic-gate long_usage(CMD_SET, TRUE); 39447c478bd9Sstevel@tonic-gate return; 39457c478bd9Sstevel@tonic-gate } 39467c478bd9Sstevel@tonic-gate 3947087719fdSdp /* 3948087719fdSdp * Special case: the user can change the zone name prior to 'create'; 3949087719fdSdp * if the zone already exists, we fall through letting initialize() 3950087719fdSdp * and the rest of the logic run. 3951087719fdSdp */ 3952087719fdSdp if (res_type == RT_ZONENAME && got_handle == FALSE && 3953087719fdSdp !state_atleast(ZONE_STATE_CONFIGURED)) { 3954fb03efaaSdp if ((err = zonecfg_validate_zonename(prop_id)) != Z_OK) { 3955fb03efaaSdp zone_perror(prop_id, err, TRUE); 3956fb03efaaSdp usage(FALSE, HELP_SYNTAX); 3957fb03efaaSdp return; 3958fb03efaaSdp } 3959087719fdSdp (void) strlcpy(zone, prop_id, sizeof (zone)); 3960087719fdSdp return; 3961087719fdSdp } 3962087719fdSdp 39637c478bd9Sstevel@tonic-gate if (initialize(TRUE) != Z_OK) 39647c478bd9Sstevel@tonic-gate return; 39657c478bd9Sstevel@tonic-gate 39667c478bd9Sstevel@tonic-gate switch (res_type) { 3967087719fdSdp case RT_ZONENAME: 3968087719fdSdp if ((err = zonecfg_set_name(handle, prop_id)) != Z_OK) { 3969087719fdSdp /* 3970087719fdSdp * Use prop_id instead of 'zone' here, since we're 3971087719fdSdp * reporting a problem about the *new* zonename. 3972087719fdSdp */ 3973087719fdSdp zone_perror(prop_id, err, TRUE); 3974fb03efaaSdp usage(FALSE, HELP_SYNTAX); 3975087719fdSdp } else { 3976087719fdSdp need_to_commit = TRUE; 3977087719fdSdp (void) strlcpy(zone, prop_id, sizeof (zone)); 3978087719fdSdp } 3979087719fdSdp return; 39807c478bd9Sstevel@tonic-gate case RT_ZONEPATH: 3981555afedfScarlsonj if (!force_set && state_atleast(ZONE_STATE_INSTALLED)) { 39827c478bd9Sstevel@tonic-gate zerr(gettext("Zone %s already installed; %s %s not " 39837c478bd9Sstevel@tonic-gate "allowed."), zone, cmd_to_str(CMD_SET), 39847c478bd9Sstevel@tonic-gate rt_to_str(RT_ZONEPATH)); 39857c478bd9Sstevel@tonic-gate return; 39867c478bd9Sstevel@tonic-gate } 39877c478bd9Sstevel@tonic-gate if (validate_zonepath_syntax(prop_id) != Z_OK) { 39887c478bd9Sstevel@tonic-gate saw_error = TRUE; 39897c478bd9Sstevel@tonic-gate return; 39907c478bd9Sstevel@tonic-gate } 39917c478bd9Sstevel@tonic-gate if ((err = zonecfg_set_zonepath(handle, prop_id)) != Z_OK) 39927c478bd9Sstevel@tonic-gate zone_perror(zone, err, TRUE); 39937c478bd9Sstevel@tonic-gate else 39947c478bd9Sstevel@tonic-gate need_to_commit = TRUE; 39957c478bd9Sstevel@tonic-gate return; 39969acbbeafSnn case RT_BRAND: 39979acbbeafSnn if (state_atleast(ZONE_STATE_INSTALLED)) { 39989acbbeafSnn zerr(gettext("Zone %s already installed; %s %s not " 39999acbbeafSnn "allowed."), zone, cmd_to_str(CMD_SET), 40009acbbeafSnn rt_to_str(RT_BRAND)); 40019acbbeafSnn return; 40029acbbeafSnn } 40039acbbeafSnn if ((err = zonecfg_set_brand(handle, prop_id)) != Z_OK) 40049acbbeafSnn zone_perror(zone, err, TRUE); 40059acbbeafSnn else 40069acbbeafSnn need_to_commit = TRUE; 40079acbbeafSnn return; 40087c478bd9Sstevel@tonic-gate case RT_AUTOBOOT: 40097c478bd9Sstevel@tonic-gate if (strcmp(prop_id, "true") == 0) { 40107c478bd9Sstevel@tonic-gate autoboot = B_TRUE; 40117c478bd9Sstevel@tonic-gate } else if (strcmp(prop_id, "false") == 0) { 40127c478bd9Sstevel@tonic-gate autoboot = B_FALSE; 40137c478bd9Sstevel@tonic-gate } else { 40147c478bd9Sstevel@tonic-gate zerr(gettext("%s value must be '%s' or '%s'."), 40157c478bd9Sstevel@tonic-gate pt_to_str(PT_AUTOBOOT), "true", "false"); 40167c478bd9Sstevel@tonic-gate saw_error = TRUE; 40177c478bd9Sstevel@tonic-gate return; 40187c478bd9Sstevel@tonic-gate } 40197c478bd9Sstevel@tonic-gate if ((err = zonecfg_set_autoboot(handle, autoboot)) != Z_OK) 40207c478bd9Sstevel@tonic-gate zone_perror(zone, err, TRUE); 40217c478bd9Sstevel@tonic-gate else 40227c478bd9Sstevel@tonic-gate need_to_commit = TRUE; 40237c478bd9Sstevel@tonic-gate return; 40247c478bd9Sstevel@tonic-gate case RT_POOL: 40250209230bSgjelinek /* don't allow use of the reserved temporary pool names */ 40260209230bSgjelinek if (strncmp("SUNW", prop_id, 4) == 0) { 40270209230bSgjelinek zerr(gettext("pool names starting with SUNW are " 40280209230bSgjelinek "reserved.")); 40290209230bSgjelinek saw_error = TRUE; 40300209230bSgjelinek return; 40310209230bSgjelinek } 40320209230bSgjelinek 40330209230bSgjelinek /* can't set pool if dedicated-cpu exists */ 40340209230bSgjelinek if (zonecfg_lookup_pset(handle, &tmp_psettab) == Z_OK) { 40350209230bSgjelinek zerr(gettext("The %s resource already exists. " 40360209230bSgjelinek "A persistent pool is incompatible\nwith the %s " 40370209230bSgjelinek "resource."), rt_to_str(RT_DCPU), 40380209230bSgjelinek rt_to_str(RT_DCPU)); 40390209230bSgjelinek saw_error = TRUE; 40400209230bSgjelinek return; 40410209230bSgjelinek } 40420209230bSgjelinek 40437c478bd9Sstevel@tonic-gate if ((err = zonecfg_set_pool(handle, prop_id)) != Z_OK) 40447c478bd9Sstevel@tonic-gate zone_perror(zone, err, TRUE); 40457c478bd9Sstevel@tonic-gate else 40467c478bd9Sstevel@tonic-gate need_to_commit = TRUE; 40477c478bd9Sstevel@tonic-gate return; 4048ffbafc53Scomay case RT_LIMITPRIV: 4049ffbafc53Scomay if ((err = zonecfg_set_limitpriv(handle, prop_id)) != Z_OK) 4050ffbafc53Scomay zone_perror(zone, err, TRUE); 4051ffbafc53Scomay else 4052ffbafc53Scomay need_to_commit = TRUE; 4053ffbafc53Scomay return; 40543f2f09c1Sdp case RT_BOOTARGS: 40553f2f09c1Sdp if ((err = zonecfg_set_bootargs(handle, prop_id)) != Z_OK) 40563f2f09c1Sdp zone_perror(zone, err, TRUE); 40573f2f09c1Sdp else 40583f2f09c1Sdp need_to_commit = TRUE; 40593f2f09c1Sdp return; 40600209230bSgjelinek case RT_SCHED: 40610209230bSgjelinek if ((err = zonecfg_set_sched(handle, prop_id)) != Z_OK) 40620209230bSgjelinek zone_perror(zone, err, TRUE); 40630209230bSgjelinek else 40640209230bSgjelinek need_to_commit = TRUE; 40650209230bSgjelinek return; 4066f4b3ec61Sdh case RT_IPTYPE: 4067f4b3ec61Sdh if (strcmp(prop_id, "shared") == 0) { 4068f4b3ec61Sdh iptype = ZS_SHARED; 4069f4b3ec61Sdh } else if (strcmp(prop_id, "exclusive") == 0) { 4070f4b3ec61Sdh iptype = ZS_EXCLUSIVE; 4071f4b3ec61Sdh } else { 4072f4b3ec61Sdh zerr(gettext("%s value must be '%s' or '%s'."), 4073f4b3ec61Sdh pt_to_str(PT_IPTYPE), "shared", "exclusive"); 4074f4b3ec61Sdh saw_error = TRUE; 4075f4b3ec61Sdh return; 4076f4b3ec61Sdh } 4077f4b3ec61Sdh if (iptype == ZS_EXCLUSIVE && !allow_exclusive()) { 4078f4b3ec61Sdh saw_error = TRUE; 4079f4b3ec61Sdh return; 4080f4b3ec61Sdh } 4081f4b3ec61Sdh if ((err = zonecfg_set_iptype(handle, iptype)) != Z_OK) 4082f4b3ec61Sdh zone_perror(zone, err, TRUE); 4083f4b3ec61Sdh else 4084f4b3ec61Sdh need_to_commit = TRUE; 4085f4b3ec61Sdh return; 40860209230bSgjelinek case RT_MAXLWPS: 40870209230bSgjelinek set_aliased_rctl(ALIAS_MAXLWPS, prop_type, prop_id); 40880209230bSgjelinek return; 40890209230bSgjelinek case RT_MAXSHMMEM: 40900209230bSgjelinek set_aliased_rctl(ALIAS_MAXSHMMEM, prop_type, prop_id); 40910209230bSgjelinek return; 40920209230bSgjelinek case RT_MAXSHMIDS: 40930209230bSgjelinek set_aliased_rctl(ALIAS_MAXSHMIDS, prop_type, prop_id); 40940209230bSgjelinek return; 40950209230bSgjelinek case RT_MAXMSGIDS: 40960209230bSgjelinek set_aliased_rctl(ALIAS_MAXMSGIDS, prop_type, prop_id); 40970209230bSgjelinek return; 40980209230bSgjelinek case RT_MAXSEMIDS: 40990209230bSgjelinek set_aliased_rctl(ALIAS_MAXSEMIDS, prop_type, prop_id); 41000209230bSgjelinek return; 41010209230bSgjelinek case RT_SHARES: 41020209230bSgjelinek set_aliased_rctl(ALIAS_SHARES, prop_type, prop_id); 41030209230bSgjelinek return; 41047c478bd9Sstevel@tonic-gate case RT_FS: 41057c478bd9Sstevel@tonic-gate switch (prop_type) { 41067c478bd9Sstevel@tonic-gate case PT_DIR: 41077c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_fstab.zone_fs_dir, prop_id, 41087c478bd9Sstevel@tonic-gate sizeof (in_progress_fstab.zone_fs_dir)); 41097c478bd9Sstevel@tonic-gate return; 41107c478bd9Sstevel@tonic-gate case PT_SPECIAL: 41117c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_fstab.zone_fs_special, 41127c478bd9Sstevel@tonic-gate prop_id, 41137c478bd9Sstevel@tonic-gate sizeof (in_progress_fstab.zone_fs_special)); 41147c478bd9Sstevel@tonic-gate return; 41157c478bd9Sstevel@tonic-gate case PT_RAW: 41167c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_fstab.zone_fs_raw, 41177c478bd9Sstevel@tonic-gate prop_id, sizeof (in_progress_fstab.zone_fs_raw)); 41187c478bd9Sstevel@tonic-gate return; 41197c478bd9Sstevel@tonic-gate case PT_TYPE: 41207c478bd9Sstevel@tonic-gate if (!valid_fs_type(prop_id)) { 41217c478bd9Sstevel@tonic-gate zerr(gettext("\"%s\" is not a valid %s."), 41227c478bd9Sstevel@tonic-gate prop_id, pt_to_str(PT_TYPE)); 41237c478bd9Sstevel@tonic-gate saw_error = TRUE; 41247c478bd9Sstevel@tonic-gate return; 41257c478bd9Sstevel@tonic-gate } 41267c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_fstab.zone_fs_type, prop_id, 41277c478bd9Sstevel@tonic-gate sizeof (in_progress_fstab.zone_fs_type)); 41287c478bd9Sstevel@tonic-gate return; 41297c478bd9Sstevel@tonic-gate case PT_OPTIONS: 41307c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE && 41317c478bd9Sstevel@tonic-gate pp->pv_type != PROP_VAL_LIST) { 41327c478bd9Sstevel@tonic-gate zerr(gettext("A %s or %s value was expected " 41337c478bd9Sstevel@tonic-gate "here."), pvt_to_str(PROP_VAL_SIMPLE), 41347c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_LIST)); 41357c478bd9Sstevel@tonic-gate saw_error = TRUE; 41367c478bd9Sstevel@tonic-gate return; 41377c478bd9Sstevel@tonic-gate } 41387c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list( 41397c478bd9Sstevel@tonic-gate in_progress_fstab.zone_fs_options); 41407c478bd9Sstevel@tonic-gate in_progress_fstab.zone_fs_options = NULL; 41417c478bd9Sstevel@tonic-gate if (!(pp->pv_type == PROP_VAL_LIST && 41427c478bd9Sstevel@tonic-gate pp->pv_list == NULL)) 41437c478bd9Sstevel@tonic-gate add_property(cmd); 41447c478bd9Sstevel@tonic-gate return; 41457c478bd9Sstevel@tonic-gate default: 41467c478bd9Sstevel@tonic-gate break; 41477c478bd9Sstevel@tonic-gate } 41487c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, TRUE); 41497c478bd9Sstevel@tonic-gate long_usage(CMD_SET, TRUE); 41507c478bd9Sstevel@tonic-gate usage(FALSE, HELP_PROPS); 41517c478bd9Sstevel@tonic-gate return; 41527c478bd9Sstevel@tonic-gate case RT_IPD: 41537c478bd9Sstevel@tonic-gate switch (prop_type) { 41547c478bd9Sstevel@tonic-gate case PT_DIR: 41557c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_ipdtab.zone_fs_dir, prop_id, 41567c478bd9Sstevel@tonic-gate sizeof (in_progress_ipdtab.zone_fs_dir)); 41577c478bd9Sstevel@tonic-gate return; 41587c478bd9Sstevel@tonic-gate default: 41597c478bd9Sstevel@tonic-gate break; 41607c478bd9Sstevel@tonic-gate } 41617c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, TRUE); 41627c478bd9Sstevel@tonic-gate long_usage(CMD_SET, TRUE); 41637c478bd9Sstevel@tonic-gate usage(FALSE, HELP_PROPS); 41647c478bd9Sstevel@tonic-gate return; 41657c478bd9Sstevel@tonic-gate case RT_NET: 41667c478bd9Sstevel@tonic-gate switch (prop_type) { 41677c478bd9Sstevel@tonic-gate case PT_ADDRESS: 41687c478bd9Sstevel@tonic-gate if (validate_net_address_syntax(prop_id) != Z_OK) { 41697c478bd9Sstevel@tonic-gate saw_error = TRUE; 41707c478bd9Sstevel@tonic-gate return; 41717c478bd9Sstevel@tonic-gate } 41727c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_nwiftab.zone_nwif_address, 41737c478bd9Sstevel@tonic-gate prop_id, 41747c478bd9Sstevel@tonic-gate sizeof (in_progress_nwiftab.zone_nwif_address)); 41757c478bd9Sstevel@tonic-gate break; 41767c478bd9Sstevel@tonic-gate case PT_PHYSICAL: 41777c478bd9Sstevel@tonic-gate if (validate_net_physical_syntax(prop_id) != Z_OK) { 41787c478bd9Sstevel@tonic-gate saw_error = TRUE; 41797c478bd9Sstevel@tonic-gate return; 41807c478bd9Sstevel@tonic-gate } 41817c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_nwiftab.zone_nwif_physical, 41827c478bd9Sstevel@tonic-gate prop_id, 41837c478bd9Sstevel@tonic-gate sizeof (in_progress_nwiftab.zone_nwif_physical)); 41847c478bd9Sstevel@tonic-gate break; 4185*de860bd9Sgfaden case PT_DEFROUTER: 4186*de860bd9Sgfaden if (validate_net_address_syntax(prop_id) != Z_OK) { 4187*de860bd9Sgfaden saw_error = TRUE; 4188*de860bd9Sgfaden return; 4189*de860bd9Sgfaden } 4190*de860bd9Sgfaden (void) strlcpy(in_progress_nwiftab.zone_nwif_defrouter, 4191*de860bd9Sgfaden prop_id, 4192*de860bd9Sgfaden sizeof (in_progress_nwiftab.zone_nwif_defrouter)); 4193*de860bd9Sgfaden break; 41947c478bd9Sstevel@tonic-gate default: 41957c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 41967c478bd9Sstevel@tonic-gate TRUE); 41977c478bd9Sstevel@tonic-gate long_usage(CMD_SET, TRUE); 41987c478bd9Sstevel@tonic-gate usage(FALSE, HELP_PROPS); 41997c478bd9Sstevel@tonic-gate return; 42007c478bd9Sstevel@tonic-gate } 42017c478bd9Sstevel@tonic-gate return; 42027c478bd9Sstevel@tonic-gate case RT_DEVICE: 42037c478bd9Sstevel@tonic-gate switch (prop_type) { 42047c478bd9Sstevel@tonic-gate case PT_MATCH: 42057c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_devtab.zone_dev_match, 42067c478bd9Sstevel@tonic-gate prop_id, 42077c478bd9Sstevel@tonic-gate sizeof (in_progress_devtab.zone_dev_match)); 42087c478bd9Sstevel@tonic-gate break; 42097c478bd9Sstevel@tonic-gate default: 42107c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 42117c478bd9Sstevel@tonic-gate TRUE); 42127c478bd9Sstevel@tonic-gate long_usage(CMD_SET, TRUE); 42137c478bd9Sstevel@tonic-gate usage(FALSE, HELP_PROPS); 42147c478bd9Sstevel@tonic-gate return; 42157c478bd9Sstevel@tonic-gate } 42167c478bd9Sstevel@tonic-gate return; 42177c478bd9Sstevel@tonic-gate case RT_RCTL: 42187c478bd9Sstevel@tonic-gate switch (prop_type) { 42197c478bd9Sstevel@tonic-gate case PT_NAME: 42207c478bd9Sstevel@tonic-gate if (!zonecfg_valid_rctlname(prop_id)) { 42217c478bd9Sstevel@tonic-gate zerr(gettext("'%s' is not a valid zone %s " 42227c478bd9Sstevel@tonic-gate "name."), prop_id, rt_to_str(RT_RCTL)); 42237c478bd9Sstevel@tonic-gate return; 42247c478bd9Sstevel@tonic-gate } 42257c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_rctltab.zone_rctl_name, 42267c478bd9Sstevel@tonic-gate prop_id, 42277c478bd9Sstevel@tonic-gate sizeof (in_progress_rctltab.zone_rctl_name)); 42287c478bd9Sstevel@tonic-gate break; 42297c478bd9Sstevel@tonic-gate case PT_VALUE: 42307c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_COMPLEX && 42317c478bd9Sstevel@tonic-gate pp->pv_type != PROP_VAL_LIST) { 42327c478bd9Sstevel@tonic-gate zerr(gettext("A %s or %s value was expected " 42337c478bd9Sstevel@tonic-gate "here."), pvt_to_str(PROP_VAL_COMPLEX), 42347c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_LIST)); 42357c478bd9Sstevel@tonic-gate saw_error = TRUE; 42367c478bd9Sstevel@tonic-gate return; 42377c478bd9Sstevel@tonic-gate } 42387c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list( 42397c478bd9Sstevel@tonic-gate in_progress_rctltab.zone_rctl_valptr); 42407c478bd9Sstevel@tonic-gate in_progress_rctltab.zone_rctl_valptr = NULL; 42417c478bd9Sstevel@tonic-gate if (!(pp->pv_type == PROP_VAL_LIST && 42427c478bd9Sstevel@tonic-gate pp->pv_list == NULL)) 42437c478bd9Sstevel@tonic-gate add_property(cmd); 42447c478bd9Sstevel@tonic-gate break; 42457c478bd9Sstevel@tonic-gate default: 42467c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 42477c478bd9Sstevel@tonic-gate TRUE); 42487c478bd9Sstevel@tonic-gate long_usage(CMD_SET, TRUE); 42497c478bd9Sstevel@tonic-gate usage(FALSE, HELP_PROPS); 42507c478bd9Sstevel@tonic-gate return; 42517c478bd9Sstevel@tonic-gate } 42527c478bd9Sstevel@tonic-gate return; 42537c478bd9Sstevel@tonic-gate case RT_ATTR: 42547c478bd9Sstevel@tonic-gate switch (prop_type) { 42557c478bd9Sstevel@tonic-gate case PT_NAME: 42567c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_attrtab.zone_attr_name, 42577c478bd9Sstevel@tonic-gate prop_id, 42587c478bd9Sstevel@tonic-gate sizeof (in_progress_attrtab.zone_attr_name)); 42597c478bd9Sstevel@tonic-gate break; 42607c478bd9Sstevel@tonic-gate case PT_TYPE: 42617c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_attrtab.zone_attr_type, 42627c478bd9Sstevel@tonic-gate prop_id, 42637c478bd9Sstevel@tonic-gate sizeof (in_progress_attrtab.zone_attr_type)); 42647c478bd9Sstevel@tonic-gate break; 42657c478bd9Sstevel@tonic-gate case PT_VALUE: 42667c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_attrtab.zone_attr_value, 42677c478bd9Sstevel@tonic-gate prop_id, 42687c478bd9Sstevel@tonic-gate sizeof (in_progress_attrtab.zone_attr_value)); 42697c478bd9Sstevel@tonic-gate break; 42707c478bd9Sstevel@tonic-gate default: 42717c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 42727c478bd9Sstevel@tonic-gate TRUE); 42737c478bd9Sstevel@tonic-gate long_usage(CMD_SET, TRUE); 42747c478bd9Sstevel@tonic-gate usage(FALSE, HELP_PROPS); 42757c478bd9Sstevel@tonic-gate return; 42767c478bd9Sstevel@tonic-gate } 42777c478bd9Sstevel@tonic-gate return; 4278fa9e4066Sahrens case RT_DATASET: 4279fa9e4066Sahrens switch (prop_type) { 4280fa9e4066Sahrens case PT_NAME: 4281fa9e4066Sahrens (void) strlcpy(in_progress_dstab.zone_dataset_name, 4282fa9e4066Sahrens prop_id, 4283fa9e4066Sahrens sizeof (in_progress_dstab.zone_dataset_name)); 4284fa9e4066Sahrens return; 4285fa9e4066Sahrens default: 4286fa9e4066Sahrens break; 4287fa9e4066Sahrens } 4288fa9e4066Sahrens zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, TRUE); 4289fa9e4066Sahrens long_usage(CMD_SET, TRUE); 4290fa9e4066Sahrens usage(FALSE, HELP_PROPS); 42910209230bSgjelinek return; 42920209230bSgjelinek case RT_DCPU: 42930209230bSgjelinek switch (prop_type) { 42940209230bSgjelinek char *lowp, *highp; 42950209230bSgjelinek 42960209230bSgjelinek case PT_NCPUS: 42970209230bSgjelinek lowp = prop_id; 42980209230bSgjelinek if ((highp = strchr(prop_id, '-')) != NULL) 42990209230bSgjelinek *highp++ = '\0'; 43000209230bSgjelinek else 43010209230bSgjelinek highp = lowp; 43020209230bSgjelinek 43030209230bSgjelinek /* Make sure the input makes sense. */ 43040209230bSgjelinek if (!zonecfg_valid_ncpus(lowp, highp)) { 43050209230bSgjelinek zerr(gettext("%s property is out of range."), 43060209230bSgjelinek pt_to_str(PT_NCPUS)); 43070209230bSgjelinek saw_error = TRUE; 43080209230bSgjelinek return; 43090209230bSgjelinek } 43100209230bSgjelinek 43110209230bSgjelinek (void) strlcpy( 43120209230bSgjelinek in_progress_psettab.zone_ncpu_min, lowp, 43130209230bSgjelinek sizeof (in_progress_psettab.zone_ncpu_min)); 43140209230bSgjelinek (void) strlcpy( 43150209230bSgjelinek in_progress_psettab.zone_ncpu_max, highp, 43160209230bSgjelinek sizeof (in_progress_psettab.zone_ncpu_max)); 43170209230bSgjelinek return; 43180209230bSgjelinek case PT_IMPORTANCE: 43190209230bSgjelinek /* Make sure the value makes sense. */ 43200209230bSgjelinek if (!zonecfg_valid_importance(prop_id)) { 43210209230bSgjelinek zerr(gettext("%s property is out of range."), 43220209230bSgjelinek pt_to_str(PT_IMPORTANCE)); 43230209230bSgjelinek saw_error = TRUE; 43240209230bSgjelinek return; 43250209230bSgjelinek } 43260209230bSgjelinek 43270209230bSgjelinek (void) strlcpy(in_progress_psettab.zone_importance, 43280209230bSgjelinek prop_id, 43290209230bSgjelinek sizeof (in_progress_psettab.zone_importance)); 43300209230bSgjelinek return; 43310209230bSgjelinek default: 43320209230bSgjelinek break; 43330209230bSgjelinek } 43340209230bSgjelinek zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, TRUE); 43350209230bSgjelinek long_usage(CMD_SET, TRUE); 43360209230bSgjelinek usage(FALSE, HELP_PROPS); 43370209230bSgjelinek return; 4338c97ad5cdSakolb case RT_PCAP: 4339c97ad5cdSakolb if (prop_type != PT_NCPUS) { 4340c97ad5cdSakolb zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 4341c97ad5cdSakolb TRUE); 4342c97ad5cdSakolb long_usage(CMD_SET, TRUE); 4343c97ad5cdSakolb usage(FALSE, HELP_PROPS); 4344c97ad5cdSakolb return; 4345c97ad5cdSakolb } 4346c97ad5cdSakolb 4347c97ad5cdSakolb /* 4348c97ad5cdSakolb * We already checked that an rctl alias is allowed in 4349c97ad5cdSakolb * the add_resource() function. 4350c97ad5cdSakolb */ 4351c97ad5cdSakolb 4352c97ad5cdSakolb if ((cap = strtof(prop_id, &unitp)) <= 0 || *unitp != '\0' || 4353c97ad5cdSakolb (int)(cap * 100) < 1) { 4354c97ad5cdSakolb zerr(gettext("%s property is out of range."), 4355c97ad5cdSakolb pt_to_str(PT_NCPUS)); 4356c97ad5cdSakolb saw_error = TRUE; 4357c97ad5cdSakolb return; 4358c97ad5cdSakolb } 4359c97ad5cdSakolb 4360c97ad5cdSakolb if ((err = zonecfg_set_aliased_rctl(handle, ALIAS_CPUCAP, 4361c97ad5cdSakolb (int)(cap * 100))) != Z_OK) 4362c97ad5cdSakolb zone_perror(zone, err, TRUE); 4363c97ad5cdSakolb else 4364c97ad5cdSakolb need_to_commit = TRUE; 4365c97ad5cdSakolb return; 43660209230bSgjelinek case RT_MCAP: 43670209230bSgjelinek switch (prop_type) { 43680209230bSgjelinek case PT_PHYSICAL: 43690209230bSgjelinek if (!zonecfg_valid_memlimit(prop_id, &mem_cap)) { 43700209230bSgjelinek zerr(gettext("A positive number with a " 43710209230bSgjelinek "required scale suffix (K, M, G or T) was " 43720209230bSgjelinek "expected here.")); 43730209230bSgjelinek saw_error = TRUE; 43740209230bSgjelinek } else if (mem_cap < ONE_MB) { 43750209230bSgjelinek zerr(gettext("%s value is too small. It must " 43760209230bSgjelinek "be at least 1M."), pt_to_str(PT_PHYSICAL)); 43770209230bSgjelinek saw_error = TRUE; 43780209230bSgjelinek } else { 43790209230bSgjelinek snprintf(in_progress_mcaptab.zone_physmem_cap, 43800209230bSgjelinek physmem_size, "%llu", mem_cap); 43810209230bSgjelinek } 43820209230bSgjelinek break; 43830209230bSgjelinek case PT_SWAP: 43840209230bSgjelinek /* 43850209230bSgjelinek * We have to check if an rctl is allowed here since 43860209230bSgjelinek * there might already be a rctl defined that blocks 43870209230bSgjelinek * the alias. 43880209230bSgjelinek */ 43890209230bSgjelinek if (!zonecfg_aliased_rctl_ok(handle, ALIAS_MAXSWAP)) { 43900209230bSgjelinek zone_perror(pt_to_str(PT_MAXSWAP), 43910209230bSgjelinek Z_ALIAS_DISALLOW, FALSE); 43920209230bSgjelinek saw_error = TRUE; 43930209230bSgjelinek return; 43940209230bSgjelinek } 43950209230bSgjelinek 43960209230bSgjelinek if (global_zone) 43970209230bSgjelinek mem_limit = ONE_MB * 100; 43980209230bSgjelinek else 43990209230bSgjelinek mem_limit = ONE_MB * 50; 44000209230bSgjelinek 44010209230bSgjelinek if (!zonecfg_valid_memlimit(prop_id, &mem_cap)) { 44020209230bSgjelinek zerr(gettext("A positive number with a " 44030209230bSgjelinek "required scale suffix (K, M, G or T) was " 44040209230bSgjelinek "expected here.")); 44050209230bSgjelinek saw_error = TRUE; 44060209230bSgjelinek } else if (mem_cap < mem_limit) { 44070209230bSgjelinek char buf[128]; 44080209230bSgjelinek 44090209230bSgjelinek (void) snprintf(buf, sizeof (buf), "%llu", 44100209230bSgjelinek mem_limit); 44110209230bSgjelinek bytes_to_units(buf, buf, sizeof (buf)); 44120209230bSgjelinek zerr(gettext("%s value is too small. It must " 44130209230bSgjelinek "be at least %s."), pt_to_str(PT_SWAP), 44140209230bSgjelinek buf); 44150209230bSgjelinek saw_error = TRUE; 44160209230bSgjelinek } else { 44170209230bSgjelinek if ((err = zonecfg_set_aliased_rctl(handle, 44180209230bSgjelinek ALIAS_MAXSWAP, mem_cap)) != Z_OK) 44190209230bSgjelinek zone_perror(zone, err, TRUE); 44200209230bSgjelinek else 44210209230bSgjelinek need_to_commit = TRUE; 44220209230bSgjelinek } 44230209230bSgjelinek break; 44240209230bSgjelinek case PT_LOCKED: 44250209230bSgjelinek /* 44260209230bSgjelinek * We have to check if an rctl is allowed here since 44270209230bSgjelinek * there might already be a rctl defined that blocks 44280209230bSgjelinek * the alias. 44290209230bSgjelinek */ 44300209230bSgjelinek if (!zonecfg_aliased_rctl_ok(handle, 44310209230bSgjelinek ALIAS_MAXLOCKEDMEM)) { 44320209230bSgjelinek zone_perror(pt_to_str(PT_LOCKED), 44330209230bSgjelinek Z_ALIAS_DISALLOW, FALSE); 44340209230bSgjelinek saw_error = TRUE; 44350209230bSgjelinek return; 44360209230bSgjelinek } 44370209230bSgjelinek 44380209230bSgjelinek if (!zonecfg_valid_memlimit(prop_id, &mem_cap)) { 44390209230bSgjelinek zerr(gettext("A non-negative number with a " 44400209230bSgjelinek "required scale suffix (K, M, G or T) was " 44410209230bSgjelinek "expected\nhere.")); 44420209230bSgjelinek saw_error = TRUE; 44430209230bSgjelinek } else { 44440209230bSgjelinek if ((err = zonecfg_set_aliased_rctl(handle, 44450209230bSgjelinek ALIAS_MAXLOCKEDMEM, mem_cap)) != Z_OK) 44460209230bSgjelinek zone_perror(zone, err, TRUE); 44470209230bSgjelinek else 44480209230bSgjelinek need_to_commit = TRUE; 44490209230bSgjelinek } 44500209230bSgjelinek break; 44510209230bSgjelinek default: 44520209230bSgjelinek zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 44530209230bSgjelinek TRUE); 44540209230bSgjelinek long_usage(CMD_SET, TRUE); 44550209230bSgjelinek usage(FALSE, HELP_PROPS); 44560209230bSgjelinek return; 44570209230bSgjelinek } 44580209230bSgjelinek 4459fa9e4066Sahrens return; 44607c478bd9Sstevel@tonic-gate default: 44617c478bd9Sstevel@tonic-gate zone_perror(rt_to_str(res_type), Z_NO_RESOURCE_TYPE, TRUE); 44627c478bd9Sstevel@tonic-gate long_usage(CMD_SET, TRUE); 44637c478bd9Sstevel@tonic-gate usage(FALSE, HELP_RESOURCES); 44647c478bd9Sstevel@tonic-gate return; 44657c478bd9Sstevel@tonic-gate } 44667c478bd9Sstevel@tonic-gate } 44677c478bd9Sstevel@tonic-gate 44687c478bd9Sstevel@tonic-gate static void 44697c478bd9Sstevel@tonic-gate output_prop(FILE *fp, int pnum, char *pval, bool print_notspec) 44707c478bd9Sstevel@tonic-gate { 44717c478bd9Sstevel@tonic-gate char *qstr; 44727c478bd9Sstevel@tonic-gate 44737c478bd9Sstevel@tonic-gate if (*pval != '\0') { 44747c478bd9Sstevel@tonic-gate qstr = quoteit(pval); 44750209230bSgjelinek if (pnum == PT_SWAP || pnum == PT_LOCKED) 44760209230bSgjelinek (void) fprintf(fp, "\t[%s: %s]\n", pt_to_str(pnum), 44770209230bSgjelinek qstr); 44780209230bSgjelinek else 44790209230bSgjelinek (void) fprintf(fp, "\t%s: %s\n", pt_to_str(pnum), qstr); 44807c478bd9Sstevel@tonic-gate free(qstr); 44817c478bd9Sstevel@tonic-gate } else if (print_notspec) 4482087719fdSdp (void) fprintf(fp, gettext("\t%s not specified\n"), 4483087719fdSdp pt_to_str(pnum)); 4484087719fdSdp } 4485087719fdSdp 4486087719fdSdp static void 4487087719fdSdp info_zonename(zone_dochandle_t handle, FILE *fp) 4488087719fdSdp { 4489087719fdSdp char zonename[ZONENAME_MAX]; 4490087719fdSdp 4491087719fdSdp if (zonecfg_get_name(handle, zonename, sizeof (zonename)) == Z_OK) 4492087719fdSdp (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_ZONENAME), 4493087719fdSdp zonename); 4494087719fdSdp else 4495087719fdSdp (void) fprintf(fp, gettext("%s not specified\n"), 4496087719fdSdp pt_to_str(PT_ZONENAME)); 44977c478bd9Sstevel@tonic-gate } 44987c478bd9Sstevel@tonic-gate 44997c478bd9Sstevel@tonic-gate static void 45007c478bd9Sstevel@tonic-gate info_zonepath(zone_dochandle_t handle, FILE *fp) 45017c478bd9Sstevel@tonic-gate { 45027c478bd9Sstevel@tonic-gate char zonepath[MAXPATHLEN]; 45037c478bd9Sstevel@tonic-gate 45047c478bd9Sstevel@tonic-gate if (zonecfg_get_zonepath(handle, zonepath, sizeof (zonepath)) == Z_OK) 45057c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_ZONEPATH), 45067c478bd9Sstevel@tonic-gate zonepath); 4507087719fdSdp else { 4508087719fdSdp (void) fprintf(fp, gettext("%s not specified\n"), 4509087719fdSdp pt_to_str(PT_ZONEPATH)); 4510087719fdSdp } 45117c478bd9Sstevel@tonic-gate } 45127c478bd9Sstevel@tonic-gate 45139acbbeafSnn static void 45149acbbeafSnn info_brand(zone_dochandle_t handle, FILE *fp) 45159acbbeafSnn { 45169acbbeafSnn char brand[MAXNAMELEN]; 45179acbbeafSnn 45189acbbeafSnn if (zonecfg_get_brand(handle, brand, sizeof (brand)) == Z_OK) 45199acbbeafSnn (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_BRAND), 45209acbbeafSnn brand); 45219acbbeafSnn else 45229acbbeafSnn (void) fprintf(fp, "%s %s\n", pt_to_str(PT_BRAND), 45239acbbeafSnn gettext("not specified")); 45249acbbeafSnn } 45259acbbeafSnn 45267c478bd9Sstevel@tonic-gate static void 45277c478bd9Sstevel@tonic-gate info_autoboot(zone_dochandle_t handle, FILE *fp) 45287c478bd9Sstevel@tonic-gate { 45297c478bd9Sstevel@tonic-gate boolean_t autoboot; 45307c478bd9Sstevel@tonic-gate int err; 45317c478bd9Sstevel@tonic-gate 45327c478bd9Sstevel@tonic-gate if ((err = zonecfg_get_autoboot(handle, &autoboot)) == Z_OK) 45337c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_AUTOBOOT), 45347c478bd9Sstevel@tonic-gate autoboot ? "true" : "false"); 45357c478bd9Sstevel@tonic-gate else 45367c478bd9Sstevel@tonic-gate zone_perror(zone, err, TRUE); 45377c478bd9Sstevel@tonic-gate } 45387c478bd9Sstevel@tonic-gate 45397c478bd9Sstevel@tonic-gate static void 45407c478bd9Sstevel@tonic-gate info_pool(zone_dochandle_t handle, FILE *fp) 45417c478bd9Sstevel@tonic-gate { 45427c478bd9Sstevel@tonic-gate char pool[MAXNAMELEN]; 45437c478bd9Sstevel@tonic-gate int err; 45447c478bd9Sstevel@tonic-gate 45457c478bd9Sstevel@tonic-gate if ((err = zonecfg_get_pool(handle, pool, sizeof (pool))) == Z_OK) 45467c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_POOL), pool); 45477c478bd9Sstevel@tonic-gate else 45487c478bd9Sstevel@tonic-gate zone_perror(zone, err, TRUE); 45497c478bd9Sstevel@tonic-gate } 45507c478bd9Sstevel@tonic-gate 4551ffbafc53Scomay static void 4552ffbafc53Scomay info_limitpriv(zone_dochandle_t handle, FILE *fp) 4553ffbafc53Scomay { 4554ffbafc53Scomay char *limitpriv; 4555ffbafc53Scomay int err; 4556ffbafc53Scomay 4557ffbafc53Scomay if ((err = zonecfg_get_limitpriv(handle, &limitpriv)) == Z_OK) { 4558ffbafc53Scomay (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_LIMITPRIV), 4559ffbafc53Scomay limitpriv); 4560ffbafc53Scomay free(limitpriv); 4561ffbafc53Scomay } else { 4562ffbafc53Scomay zone_perror(zone, err, TRUE); 4563ffbafc53Scomay } 4564ffbafc53Scomay } 4565ffbafc53Scomay 45663f2f09c1Sdp static void 45673f2f09c1Sdp info_bootargs(zone_dochandle_t handle, FILE *fp) 45683f2f09c1Sdp { 45693f2f09c1Sdp char bootargs[BOOTARGS_MAX]; 45703f2f09c1Sdp int err; 45713f2f09c1Sdp 45723f2f09c1Sdp if ((err = zonecfg_get_bootargs(handle, bootargs, 45733f2f09c1Sdp sizeof (bootargs))) == Z_OK) { 45743f2f09c1Sdp (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_BOOTARGS), 45753f2f09c1Sdp bootargs); 45763f2f09c1Sdp } else { 45773f2f09c1Sdp zone_perror(zone, err, TRUE); 45783f2f09c1Sdp } 45793f2f09c1Sdp } 45803f2f09c1Sdp 45810209230bSgjelinek static void 45820209230bSgjelinek info_sched(zone_dochandle_t handle, FILE *fp) 45830209230bSgjelinek { 45840209230bSgjelinek char sched[MAXNAMELEN]; 45850209230bSgjelinek int err; 45860209230bSgjelinek 45870209230bSgjelinek if ((err = zonecfg_get_sched_class(handle, sched, sizeof (sched))) 45880209230bSgjelinek == Z_OK) { 45890209230bSgjelinek (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_SCHED), sched); 45900209230bSgjelinek } else { 45910209230bSgjelinek zone_perror(zone, err, TRUE); 45920209230bSgjelinek } 45930209230bSgjelinek } 45940209230bSgjelinek 4595f4b3ec61Sdh static void 4596f4b3ec61Sdh info_iptype(zone_dochandle_t handle, FILE *fp) 4597f4b3ec61Sdh { 4598f4b3ec61Sdh zone_iptype_t iptype; 4599f4b3ec61Sdh int err; 4600f4b3ec61Sdh 4601f4b3ec61Sdh if ((err = zonecfg_get_iptype(handle, &iptype)) == Z_OK) { 4602f4b3ec61Sdh switch (iptype) { 4603f4b3ec61Sdh case ZS_SHARED: 4604f4b3ec61Sdh (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_IPTYPE), 4605f4b3ec61Sdh "shared"); 4606f4b3ec61Sdh break; 4607f4b3ec61Sdh case ZS_EXCLUSIVE: 4608f4b3ec61Sdh (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_IPTYPE), 4609f4b3ec61Sdh "exclusive"); 4610f4b3ec61Sdh break; 4611f4b3ec61Sdh } 4612f4b3ec61Sdh } else { 4613f4b3ec61Sdh zone_perror(zone, err, TRUE); 4614f4b3ec61Sdh } 4615f4b3ec61Sdh } 4616f4b3ec61Sdh 46177c478bd9Sstevel@tonic-gate static void 46187c478bd9Sstevel@tonic-gate output_fs(FILE *fp, struct zone_fstab *fstab) 46197c478bd9Sstevel@tonic-gate { 46207c478bd9Sstevel@tonic-gate zone_fsopt_t *this; 46217c478bd9Sstevel@tonic-gate 46227c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s:\n", rt_to_str(RT_FS)); 46237c478bd9Sstevel@tonic-gate output_prop(fp, PT_DIR, fstab->zone_fs_dir, B_TRUE); 46247c478bd9Sstevel@tonic-gate output_prop(fp, PT_SPECIAL, fstab->zone_fs_special, B_TRUE); 46257c478bd9Sstevel@tonic-gate output_prop(fp, PT_RAW, fstab->zone_fs_raw, B_TRUE); 46267c478bd9Sstevel@tonic-gate output_prop(fp, PT_TYPE, fstab->zone_fs_type, B_TRUE); 46277c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s: [", pt_to_str(PT_OPTIONS)); 46287c478bd9Sstevel@tonic-gate for (this = fstab->zone_fs_options; this != NULL; 46297c478bd9Sstevel@tonic-gate this = this->zone_fsopt_next) { 46307c478bd9Sstevel@tonic-gate if (strchr(this->zone_fsopt_opt, '=')) 46317c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\"%s\"", this->zone_fsopt_opt); 46327c478bd9Sstevel@tonic-gate else 46337c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s", this->zone_fsopt_opt); 46347c478bd9Sstevel@tonic-gate if (this->zone_fsopt_next != NULL) 46357c478bd9Sstevel@tonic-gate (void) fprintf(fp, ","); 46367c478bd9Sstevel@tonic-gate } 46377c478bd9Sstevel@tonic-gate (void) fprintf(fp, "]\n"); 46387c478bd9Sstevel@tonic-gate } 46397c478bd9Sstevel@tonic-gate 46407c478bd9Sstevel@tonic-gate static void 46417c478bd9Sstevel@tonic-gate output_ipd(FILE *fp, struct zone_fstab *ipdtab) 46427c478bd9Sstevel@tonic-gate { 46437c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s:\n", rt_to_str(RT_IPD)); 46447c478bd9Sstevel@tonic-gate output_prop(fp, PT_DIR, ipdtab->zone_fs_dir, B_TRUE); 46457c478bd9Sstevel@tonic-gate } 46467c478bd9Sstevel@tonic-gate 46477c478bd9Sstevel@tonic-gate static void 46487c478bd9Sstevel@tonic-gate info_fs(zone_dochandle_t handle, FILE *fp, cmd_t *cmd) 46497c478bd9Sstevel@tonic-gate { 46507c478bd9Sstevel@tonic-gate struct zone_fstab lookup, user; 46517c478bd9Sstevel@tonic-gate bool output = FALSE; 46527c478bd9Sstevel@tonic-gate 46537c478bd9Sstevel@tonic-gate if (zonecfg_setfsent(handle) != Z_OK) 46547c478bd9Sstevel@tonic-gate return; 46557c478bd9Sstevel@tonic-gate while (zonecfg_getfsent(handle, &lookup) == Z_OK) { 46567c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs == 0) { 46577c478bd9Sstevel@tonic-gate output_fs(fp, &lookup); 46587c478bd9Sstevel@tonic-gate goto loopend; 46597c478bd9Sstevel@tonic-gate } 46607c478bd9Sstevel@tonic-gate if (fill_in_fstab(cmd, &user, TRUE) != Z_OK) 46617c478bd9Sstevel@tonic-gate goto loopend; 46627c478bd9Sstevel@tonic-gate if (strlen(user.zone_fs_dir) > 0 && 46637c478bd9Sstevel@tonic-gate strcmp(user.zone_fs_dir, lookup.zone_fs_dir) != 0) 46647c478bd9Sstevel@tonic-gate goto loopend; /* no match */ 46657c478bd9Sstevel@tonic-gate if (strlen(user.zone_fs_special) > 0 && 46667c478bd9Sstevel@tonic-gate strcmp(user.zone_fs_special, lookup.zone_fs_special) != 0) 46677c478bd9Sstevel@tonic-gate goto loopend; /* no match */ 46687c478bd9Sstevel@tonic-gate if (strlen(user.zone_fs_type) > 0 && 46697c478bd9Sstevel@tonic-gate strcmp(user.zone_fs_type, lookup.zone_fs_type) != 0) 46707c478bd9Sstevel@tonic-gate goto loopend; /* no match */ 46717c478bd9Sstevel@tonic-gate output_fs(fp, &lookup); 46727c478bd9Sstevel@tonic-gate output = TRUE; 46737c478bd9Sstevel@tonic-gate loopend: 46747c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(lookup.zone_fs_options); 46757c478bd9Sstevel@tonic-gate } 46767c478bd9Sstevel@tonic-gate (void) zonecfg_endfsent(handle); 46777c478bd9Sstevel@tonic-gate /* 46787c478bd9Sstevel@tonic-gate * If a property n/v pair was specified, warn the user if there was 46797c478bd9Sstevel@tonic-gate * nothing to output. 46807c478bd9Sstevel@tonic-gate */ 46817c478bd9Sstevel@tonic-gate if (!output && cmd->cmd_prop_nv_pairs > 0) 46827c478bd9Sstevel@tonic-gate (void) printf(gettext("No such %s resource.\n"), 46837c478bd9Sstevel@tonic-gate rt_to_str(RT_FS)); 46847c478bd9Sstevel@tonic-gate } 46857c478bd9Sstevel@tonic-gate 46867c478bd9Sstevel@tonic-gate static void 46877c478bd9Sstevel@tonic-gate info_ipd(zone_dochandle_t handle, FILE *fp, cmd_t *cmd) 46887c478bd9Sstevel@tonic-gate { 46897c478bd9Sstevel@tonic-gate struct zone_fstab lookup, user; 46907c478bd9Sstevel@tonic-gate bool output = FALSE; 46917c478bd9Sstevel@tonic-gate 46927c478bd9Sstevel@tonic-gate if (zonecfg_setipdent(handle) != Z_OK) 46937c478bd9Sstevel@tonic-gate return; 46947c478bd9Sstevel@tonic-gate while (zonecfg_getipdent(handle, &lookup) == Z_OK) { 46957c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs == 0) { 46967c478bd9Sstevel@tonic-gate output_ipd(fp, &lookup); 46977c478bd9Sstevel@tonic-gate continue; 46987c478bd9Sstevel@tonic-gate } 46997c478bd9Sstevel@tonic-gate if (fill_in_ipdtab(cmd, &user, TRUE) != Z_OK) 47007c478bd9Sstevel@tonic-gate continue; 47017c478bd9Sstevel@tonic-gate if (strlen(user.zone_fs_dir) > 0 && 47027c478bd9Sstevel@tonic-gate strcmp(user.zone_fs_dir, lookup.zone_fs_dir) != 0) 47037c478bd9Sstevel@tonic-gate continue; /* no match */ 47047c478bd9Sstevel@tonic-gate output_ipd(fp, &lookup); 47057c478bd9Sstevel@tonic-gate output = TRUE; 47067c478bd9Sstevel@tonic-gate } 47077c478bd9Sstevel@tonic-gate (void) zonecfg_endipdent(handle); 47087c478bd9Sstevel@tonic-gate /* 47097c478bd9Sstevel@tonic-gate * If a property n/v pair was specified, warn the user if there was 47107c478bd9Sstevel@tonic-gate * nothing to output. 47117c478bd9Sstevel@tonic-gate */ 47127c478bd9Sstevel@tonic-gate if (!output && cmd->cmd_prop_nv_pairs > 0) 47137c478bd9Sstevel@tonic-gate (void) printf(gettext("No such %s resource.\n"), 47147c478bd9Sstevel@tonic-gate rt_to_str(RT_IPD)); 47157c478bd9Sstevel@tonic-gate } 47167c478bd9Sstevel@tonic-gate 47177c478bd9Sstevel@tonic-gate static void 47187c478bd9Sstevel@tonic-gate output_net(FILE *fp, struct zone_nwiftab *nwiftab) 47197c478bd9Sstevel@tonic-gate { 47207c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s:\n", rt_to_str(RT_NET)); 47217c478bd9Sstevel@tonic-gate output_prop(fp, PT_ADDRESS, nwiftab->zone_nwif_address, B_TRUE); 47227c478bd9Sstevel@tonic-gate output_prop(fp, PT_PHYSICAL, nwiftab->zone_nwif_physical, B_TRUE); 4723*de860bd9Sgfaden output_prop(fp, PT_DEFROUTER, nwiftab->zone_nwif_defrouter, B_TRUE); 47247c478bd9Sstevel@tonic-gate } 47257c478bd9Sstevel@tonic-gate 47267c478bd9Sstevel@tonic-gate static void 47277c478bd9Sstevel@tonic-gate info_net(zone_dochandle_t handle, FILE *fp, cmd_t *cmd) 47287c478bd9Sstevel@tonic-gate { 47297c478bd9Sstevel@tonic-gate struct zone_nwiftab lookup, user; 47307c478bd9Sstevel@tonic-gate bool output = FALSE; 47317c478bd9Sstevel@tonic-gate 47327c478bd9Sstevel@tonic-gate if (zonecfg_setnwifent(handle) != Z_OK) 47337c478bd9Sstevel@tonic-gate return; 47347c478bd9Sstevel@tonic-gate while (zonecfg_getnwifent(handle, &lookup) == Z_OK) { 47357c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs == 0) { 47367c478bd9Sstevel@tonic-gate output_net(fp, &lookup); 47377c478bd9Sstevel@tonic-gate continue; 47387c478bd9Sstevel@tonic-gate } 47397c478bd9Sstevel@tonic-gate if (fill_in_nwiftab(cmd, &user, TRUE) != Z_OK) 47407c478bd9Sstevel@tonic-gate continue; 47417c478bd9Sstevel@tonic-gate if (strlen(user.zone_nwif_physical) > 0 && 47427c478bd9Sstevel@tonic-gate strcmp(user.zone_nwif_physical, 47437c478bd9Sstevel@tonic-gate lookup.zone_nwif_physical) != 0) 47447c478bd9Sstevel@tonic-gate continue; /* no match */ 4745f4b3ec61Sdh /* If present make sure it matches */ 47467c478bd9Sstevel@tonic-gate if (strlen(user.zone_nwif_address) > 0 && 47477c478bd9Sstevel@tonic-gate !zonecfg_same_net_address(user.zone_nwif_address, 47487c478bd9Sstevel@tonic-gate lookup.zone_nwif_address)) 47497c478bd9Sstevel@tonic-gate continue; /* no match */ 47507c478bd9Sstevel@tonic-gate output_net(fp, &lookup); 47517c478bd9Sstevel@tonic-gate output = TRUE; 47527c478bd9Sstevel@tonic-gate } 47537c478bd9Sstevel@tonic-gate (void) zonecfg_endnwifent(handle); 47547c478bd9Sstevel@tonic-gate /* 47557c478bd9Sstevel@tonic-gate * If a property n/v pair was specified, warn the user if there was 47567c478bd9Sstevel@tonic-gate * nothing to output. 47577c478bd9Sstevel@tonic-gate */ 47587c478bd9Sstevel@tonic-gate if (!output && cmd->cmd_prop_nv_pairs > 0) 47597c478bd9Sstevel@tonic-gate (void) printf(gettext("No such %s resource.\n"), 47607c478bd9Sstevel@tonic-gate rt_to_str(RT_NET)); 47617c478bd9Sstevel@tonic-gate } 47627c478bd9Sstevel@tonic-gate 47637c478bd9Sstevel@tonic-gate static void 47647c478bd9Sstevel@tonic-gate output_dev(FILE *fp, struct zone_devtab *devtab) 47657c478bd9Sstevel@tonic-gate { 476627e6fb21Sdp (void) fprintf(fp, "%s:\n", rt_to_str(RT_DEVICE)); 47677c478bd9Sstevel@tonic-gate output_prop(fp, PT_MATCH, devtab->zone_dev_match, B_TRUE); 47687c478bd9Sstevel@tonic-gate } 47697c478bd9Sstevel@tonic-gate 47707c478bd9Sstevel@tonic-gate static void 47717c478bd9Sstevel@tonic-gate info_dev(zone_dochandle_t handle, FILE *fp, cmd_t *cmd) 47727c478bd9Sstevel@tonic-gate { 47737c478bd9Sstevel@tonic-gate struct zone_devtab lookup, user; 47747c478bd9Sstevel@tonic-gate bool output = FALSE; 47757c478bd9Sstevel@tonic-gate 47767c478bd9Sstevel@tonic-gate if (zonecfg_setdevent(handle) != Z_OK) 47777c478bd9Sstevel@tonic-gate return; 47787c478bd9Sstevel@tonic-gate while (zonecfg_getdevent(handle, &lookup) == Z_OK) { 47797c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs == 0) { 47807c478bd9Sstevel@tonic-gate output_dev(fp, &lookup); 47817c478bd9Sstevel@tonic-gate continue; 47827c478bd9Sstevel@tonic-gate } 47837c478bd9Sstevel@tonic-gate if (fill_in_devtab(cmd, &user, TRUE) != Z_OK) 47847c478bd9Sstevel@tonic-gate continue; 47857c478bd9Sstevel@tonic-gate if (strlen(user.zone_dev_match) > 0 && 47867c478bd9Sstevel@tonic-gate strcmp(user.zone_dev_match, lookup.zone_dev_match) != 0) 47877c478bd9Sstevel@tonic-gate continue; /* no match */ 47887c478bd9Sstevel@tonic-gate output_dev(fp, &lookup); 47897c478bd9Sstevel@tonic-gate output = TRUE; 47907c478bd9Sstevel@tonic-gate } 47917c478bd9Sstevel@tonic-gate (void) zonecfg_enddevent(handle); 47927c478bd9Sstevel@tonic-gate /* 47937c478bd9Sstevel@tonic-gate * If a property n/v pair was specified, warn the user if there was 47947c478bd9Sstevel@tonic-gate * nothing to output. 47957c478bd9Sstevel@tonic-gate */ 47967c478bd9Sstevel@tonic-gate if (!output && cmd->cmd_prop_nv_pairs > 0) 47977c478bd9Sstevel@tonic-gate (void) printf(gettext("No such %s resource.\n"), 47987c478bd9Sstevel@tonic-gate rt_to_str(RT_DEVICE)); 47997c478bd9Sstevel@tonic-gate } 48007c478bd9Sstevel@tonic-gate 48017c478bd9Sstevel@tonic-gate static void 48027c478bd9Sstevel@tonic-gate output_rctl(FILE *fp, struct zone_rctltab *rctltab) 48037c478bd9Sstevel@tonic-gate { 48047c478bd9Sstevel@tonic-gate struct zone_rctlvaltab *valptr; 48057c478bd9Sstevel@tonic-gate 48067c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s:\n", rt_to_str(RT_RCTL)); 48077c478bd9Sstevel@tonic-gate output_prop(fp, PT_NAME, rctltab->zone_rctl_name, B_TRUE); 48087c478bd9Sstevel@tonic-gate for (valptr = rctltab->zone_rctl_valptr; valptr != NULL; 48097c478bd9Sstevel@tonic-gate valptr = valptr->zone_rctlval_next) { 48107c478bd9Sstevel@tonic-gate fprintf(fp, "\t%s: (%s=%s,%s=%s,%s=%s)\n", 48117c478bd9Sstevel@tonic-gate pt_to_str(PT_VALUE), 48127c478bd9Sstevel@tonic-gate pt_to_str(PT_PRIV), valptr->zone_rctlval_priv, 48137c478bd9Sstevel@tonic-gate pt_to_str(PT_LIMIT), valptr->zone_rctlval_limit, 48147c478bd9Sstevel@tonic-gate pt_to_str(PT_ACTION), valptr->zone_rctlval_action); 48157c478bd9Sstevel@tonic-gate } 48167c478bd9Sstevel@tonic-gate } 48177c478bd9Sstevel@tonic-gate 48187c478bd9Sstevel@tonic-gate static void 48197c478bd9Sstevel@tonic-gate info_rctl(zone_dochandle_t handle, FILE *fp, cmd_t *cmd) 48207c478bd9Sstevel@tonic-gate { 48217c478bd9Sstevel@tonic-gate struct zone_rctltab lookup, user; 48227c478bd9Sstevel@tonic-gate bool output = FALSE; 48237c478bd9Sstevel@tonic-gate 48247c478bd9Sstevel@tonic-gate if (zonecfg_setrctlent(handle) != Z_OK) 48257c478bd9Sstevel@tonic-gate return; 48267c478bd9Sstevel@tonic-gate while (zonecfg_getrctlent(handle, &lookup) == Z_OK) { 48277c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs == 0) { 48287c478bd9Sstevel@tonic-gate output_rctl(fp, &lookup); 48297c478bd9Sstevel@tonic-gate } else if (fill_in_rctltab(cmd, &user, TRUE) == Z_OK && 48307c478bd9Sstevel@tonic-gate (strlen(user.zone_rctl_name) == 0 || 48317c478bd9Sstevel@tonic-gate strcmp(user.zone_rctl_name, lookup.zone_rctl_name) == 0)) { 48327c478bd9Sstevel@tonic-gate output_rctl(fp, &lookup); 48337c478bd9Sstevel@tonic-gate output = TRUE; 48347c478bd9Sstevel@tonic-gate } 48357c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(lookup.zone_rctl_valptr); 48367c478bd9Sstevel@tonic-gate } 48377c478bd9Sstevel@tonic-gate (void) zonecfg_endrctlent(handle); 48387c478bd9Sstevel@tonic-gate /* 48397c478bd9Sstevel@tonic-gate * If a property n/v pair was specified, warn the user if there was 48407c478bd9Sstevel@tonic-gate * nothing to output. 48417c478bd9Sstevel@tonic-gate */ 48427c478bd9Sstevel@tonic-gate if (!output && cmd->cmd_prop_nv_pairs > 0) 48437c478bd9Sstevel@tonic-gate (void) printf(gettext("No such %s resource.\n"), 48447c478bd9Sstevel@tonic-gate rt_to_str(RT_RCTL)); 48457c478bd9Sstevel@tonic-gate } 48467c478bd9Sstevel@tonic-gate 48477c478bd9Sstevel@tonic-gate static void 48487c478bd9Sstevel@tonic-gate output_attr(FILE *fp, struct zone_attrtab *attrtab) 48497c478bd9Sstevel@tonic-gate { 48507c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s:\n", rt_to_str(RT_ATTR)); 48517c478bd9Sstevel@tonic-gate output_prop(fp, PT_NAME, attrtab->zone_attr_name, B_TRUE); 48527c478bd9Sstevel@tonic-gate output_prop(fp, PT_TYPE, attrtab->zone_attr_type, B_TRUE); 48537c478bd9Sstevel@tonic-gate output_prop(fp, PT_VALUE, attrtab->zone_attr_value, B_TRUE); 48547c478bd9Sstevel@tonic-gate } 48557c478bd9Sstevel@tonic-gate 48567c478bd9Sstevel@tonic-gate static void 48577c478bd9Sstevel@tonic-gate info_attr(zone_dochandle_t handle, FILE *fp, cmd_t *cmd) 48587c478bd9Sstevel@tonic-gate { 48597c478bd9Sstevel@tonic-gate struct zone_attrtab lookup, user; 48607c478bd9Sstevel@tonic-gate bool output = FALSE; 48617c478bd9Sstevel@tonic-gate 48627c478bd9Sstevel@tonic-gate if (zonecfg_setattrent(handle) != Z_OK) 48637c478bd9Sstevel@tonic-gate return; 48647c478bd9Sstevel@tonic-gate while (zonecfg_getattrent(handle, &lookup) == Z_OK) { 48657c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs == 0) { 48667c478bd9Sstevel@tonic-gate output_attr(fp, &lookup); 48677c478bd9Sstevel@tonic-gate continue; 48687c478bd9Sstevel@tonic-gate } 48697c478bd9Sstevel@tonic-gate if (fill_in_attrtab(cmd, &user, TRUE) != Z_OK) 48707c478bd9Sstevel@tonic-gate continue; 48717c478bd9Sstevel@tonic-gate if (strlen(user.zone_attr_name) > 0 && 48727c478bd9Sstevel@tonic-gate strcmp(user.zone_attr_name, lookup.zone_attr_name) != 0) 48737c478bd9Sstevel@tonic-gate continue; /* no match */ 48747c478bd9Sstevel@tonic-gate if (strlen(user.zone_attr_type) > 0 && 48757c478bd9Sstevel@tonic-gate strcmp(user.zone_attr_type, lookup.zone_attr_type) != 0) 48767c478bd9Sstevel@tonic-gate continue; /* no match */ 48777c478bd9Sstevel@tonic-gate if (strlen(user.zone_attr_value) > 0 && 48787c478bd9Sstevel@tonic-gate strcmp(user.zone_attr_value, lookup.zone_attr_value) != 0) 48797c478bd9Sstevel@tonic-gate continue; /* no match */ 48807c478bd9Sstevel@tonic-gate output_attr(fp, &lookup); 48817c478bd9Sstevel@tonic-gate output = TRUE; 48827c478bd9Sstevel@tonic-gate } 48837c478bd9Sstevel@tonic-gate (void) zonecfg_endattrent(handle); 48847c478bd9Sstevel@tonic-gate /* 48857c478bd9Sstevel@tonic-gate * If a property n/v pair was specified, warn the user if there was 48867c478bd9Sstevel@tonic-gate * nothing to output. 48877c478bd9Sstevel@tonic-gate */ 48887c478bd9Sstevel@tonic-gate if (!output && cmd->cmd_prop_nv_pairs > 0) 48897c478bd9Sstevel@tonic-gate (void) printf(gettext("No such %s resource.\n"), 48907c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR)); 48917c478bd9Sstevel@tonic-gate } 48927c478bd9Sstevel@tonic-gate 4893fa9e4066Sahrens static void 4894fa9e4066Sahrens output_ds(FILE *fp, struct zone_dstab *dstab) 4895fa9e4066Sahrens { 4896fa9e4066Sahrens (void) fprintf(fp, "%s:\n", rt_to_str(RT_DATASET)); 4897fa9e4066Sahrens output_prop(fp, PT_NAME, dstab->zone_dataset_name, B_TRUE); 4898fa9e4066Sahrens } 4899fa9e4066Sahrens 4900fa9e4066Sahrens static void 4901fa9e4066Sahrens info_ds(zone_dochandle_t handle, FILE *fp, cmd_t *cmd) 4902fa9e4066Sahrens { 4903fa9e4066Sahrens struct zone_dstab lookup, user; 4904fa9e4066Sahrens bool output = FALSE; 4905fa9e4066Sahrens 49060209230bSgjelinek if (zonecfg_setdsent(handle) != Z_OK) 4907fa9e4066Sahrens return; 4908fa9e4066Sahrens while (zonecfg_getdsent(handle, &lookup) == Z_OK) { 4909fa9e4066Sahrens if (cmd->cmd_prop_nv_pairs == 0) { 4910fa9e4066Sahrens output_ds(fp, &lookup); 4911fa9e4066Sahrens continue; 4912fa9e4066Sahrens } 4913fa9e4066Sahrens if (fill_in_dstab(cmd, &user, TRUE) != Z_OK) 4914fa9e4066Sahrens continue; 4915fa9e4066Sahrens if (strlen(user.zone_dataset_name) > 0 && 4916fa9e4066Sahrens strcmp(user.zone_dataset_name, 4917fa9e4066Sahrens lookup.zone_dataset_name) != 0) 4918fa9e4066Sahrens continue; /* no match */ 4919fa9e4066Sahrens output_ds(fp, &lookup); 4920fa9e4066Sahrens output = TRUE; 4921fa9e4066Sahrens } 4922fa9e4066Sahrens (void) zonecfg_enddsent(handle); 4923fa9e4066Sahrens /* 4924fa9e4066Sahrens * If a property n/v pair was specified, warn the user if there was 4925fa9e4066Sahrens * nothing to output. 4926fa9e4066Sahrens */ 4927fa9e4066Sahrens if (!output && cmd->cmd_prop_nv_pairs > 0) 4928fa9e4066Sahrens (void) printf(gettext("No such %s resource.\n"), 4929fa9e4066Sahrens rt_to_str(RT_DATASET)); 4930fa9e4066Sahrens } 4931fa9e4066Sahrens 49320209230bSgjelinek static void 49330209230bSgjelinek output_pset(FILE *fp, struct zone_psettab *psettab) 49340209230bSgjelinek { 49350209230bSgjelinek (void) fprintf(fp, "%s:\n", rt_to_str(RT_DCPU)); 49360209230bSgjelinek if (strcmp(psettab->zone_ncpu_min, psettab->zone_ncpu_max) == 0) 49370209230bSgjelinek (void) fprintf(fp, "\t%s: %s\n", pt_to_str(PT_NCPUS), 49380209230bSgjelinek psettab->zone_ncpu_max); 49390209230bSgjelinek else 49400209230bSgjelinek (void) fprintf(fp, "\t%s: %s-%s\n", pt_to_str(PT_NCPUS), 49410209230bSgjelinek psettab->zone_ncpu_min, psettab->zone_ncpu_max); 49420209230bSgjelinek if (psettab->zone_importance[0] != '\0') 49430209230bSgjelinek (void) fprintf(fp, "\t%s: %s\n", pt_to_str(PT_IMPORTANCE), 49440209230bSgjelinek psettab->zone_importance); 49450209230bSgjelinek } 49460209230bSgjelinek 49470209230bSgjelinek static void 49480209230bSgjelinek info_pset(zone_dochandle_t handle, FILE *fp) 49490209230bSgjelinek { 49500209230bSgjelinek struct zone_psettab lookup; 49510209230bSgjelinek 49520209230bSgjelinek if (zonecfg_getpsetent(handle, &lookup) == Z_OK) 49530209230bSgjelinek output_pset(fp, &lookup); 49540209230bSgjelinek } 49550209230bSgjelinek 4956c97ad5cdSakolb static void 4957c97ad5cdSakolb output_pcap(FILE *fp) 4958c97ad5cdSakolb { 4959c97ad5cdSakolb uint64_t cap; 4960c97ad5cdSakolb 4961c97ad5cdSakolb if (zonecfg_get_aliased_rctl(handle, ALIAS_CPUCAP, &cap) == Z_OK) { 4962c97ad5cdSakolb float scaled = (float)cap / 100; 4963c97ad5cdSakolb (void) fprintf(fp, "%s:\n", rt_to_str(RT_PCAP)); 4964c97ad5cdSakolb (void) fprintf(fp, "\t[%s: %.2f]\n", pt_to_str(PT_NCPUS), 4965c97ad5cdSakolb scaled); 4966c97ad5cdSakolb } 4967c97ad5cdSakolb } 4968c97ad5cdSakolb 4969c97ad5cdSakolb static void 4970c97ad5cdSakolb info_pcap(FILE *fp) 4971c97ad5cdSakolb { 4972c97ad5cdSakolb output_pcap(fp); 4973c97ad5cdSakolb } 4974c97ad5cdSakolb 4975c97ad5cdSakolb 49760209230bSgjelinek static void 49770209230bSgjelinek info_aliased_rctl(zone_dochandle_t handle, FILE *fp, char *alias) 49780209230bSgjelinek { 49790209230bSgjelinek uint64_t limit; 49800209230bSgjelinek 49810209230bSgjelinek if (zonecfg_get_aliased_rctl(handle, alias, &limit) == Z_OK) { 49820209230bSgjelinek /* convert memory based properties */ 49830209230bSgjelinek if (strcmp(alias, ALIAS_MAXSHMMEM) == 0) { 49840209230bSgjelinek char buf[128]; 49850209230bSgjelinek 49860209230bSgjelinek (void) snprintf(buf, sizeof (buf), "%llu", limit); 49870209230bSgjelinek bytes_to_units(buf, buf, sizeof (buf)); 49880209230bSgjelinek (void) fprintf(fp, "[%s: %s]\n", alias, buf); 49890209230bSgjelinek return; 49900209230bSgjelinek } 49910209230bSgjelinek 49920209230bSgjelinek (void) fprintf(fp, "[%s: %llu]\n", alias, limit); 49930209230bSgjelinek } 49940209230bSgjelinek } 49950209230bSgjelinek 49960209230bSgjelinek static void 49970209230bSgjelinek bytes_to_units(char *str, char *buf, int bufsize) 49980209230bSgjelinek { 49990209230bSgjelinek unsigned long long num; 50000209230bSgjelinek unsigned long long save = 0; 50010209230bSgjelinek char *units = "BKMGT"; 50020209230bSgjelinek char *up = units; 50030209230bSgjelinek 50040209230bSgjelinek num = strtoll(str, NULL, 10); 50050209230bSgjelinek 50060209230bSgjelinek if (num < 1024) { 50070209230bSgjelinek (void) snprintf(buf, bufsize, "%llu", num); 50080209230bSgjelinek return; 50090209230bSgjelinek } 50100209230bSgjelinek 50110209230bSgjelinek while ((num >= 1024) && (*up != 'T')) { 50120209230bSgjelinek up++; /* next unit of measurement */ 50130209230bSgjelinek save = num; 50140209230bSgjelinek num = (num + 512) >> 10; 50150209230bSgjelinek } 50160209230bSgjelinek 50170209230bSgjelinek /* check if we should output a fraction. snprintf will round for us */ 50180209230bSgjelinek if (save % 1024 != 0 && ((save >> 10) < 10)) 50190209230bSgjelinek (void) snprintf(buf, bufsize, "%2.1f%c", ((float)save / 1024), 50200209230bSgjelinek *up); 50210209230bSgjelinek else 50220209230bSgjelinek (void) snprintf(buf, bufsize, "%llu%c", num, *up); 50230209230bSgjelinek } 50240209230bSgjelinek 50250209230bSgjelinek static void 50260209230bSgjelinek output_mcap(FILE *fp, struct zone_mcaptab *mcaptab, int showswap, 50270209230bSgjelinek uint64_t maxswap, int showlocked, uint64_t maxlocked) 50280209230bSgjelinek { 50290209230bSgjelinek char buf[128]; 50300209230bSgjelinek 50310209230bSgjelinek (void) fprintf(fp, "%s:\n", rt_to_str(RT_MCAP)); 50320209230bSgjelinek if (mcaptab->zone_physmem_cap[0] != '\0') { 50330209230bSgjelinek bytes_to_units(mcaptab->zone_physmem_cap, buf, sizeof (buf)); 50340209230bSgjelinek output_prop(fp, PT_PHYSICAL, buf, B_TRUE); 50350209230bSgjelinek } 50360209230bSgjelinek 50370209230bSgjelinek if (showswap == Z_OK) { 50380209230bSgjelinek (void) snprintf(buf, sizeof (buf), "%llu", maxswap); 50390209230bSgjelinek bytes_to_units(buf, buf, sizeof (buf)); 50400209230bSgjelinek output_prop(fp, PT_SWAP, buf, B_TRUE); 50410209230bSgjelinek } 50420209230bSgjelinek 50430209230bSgjelinek if (showlocked == Z_OK) { 50440209230bSgjelinek (void) snprintf(buf, sizeof (buf), "%llu", maxlocked); 50450209230bSgjelinek bytes_to_units(buf, buf, sizeof (buf)); 50460209230bSgjelinek output_prop(fp, PT_LOCKED, buf, B_TRUE); 50470209230bSgjelinek } 50480209230bSgjelinek } 50490209230bSgjelinek 50500209230bSgjelinek static void 50510209230bSgjelinek info_mcap(zone_dochandle_t handle, FILE *fp) 50520209230bSgjelinek { 50530209230bSgjelinek int res1, res2, res3; 50540209230bSgjelinek uint64_t swap_limit; 50550209230bSgjelinek uint64_t locked_limit; 50560209230bSgjelinek struct zone_mcaptab lookup; 50570209230bSgjelinek 50580209230bSgjelinek bzero(&lookup, sizeof (lookup)); 50590209230bSgjelinek res1 = zonecfg_getmcapent(handle, &lookup); 50600209230bSgjelinek res2 = zonecfg_get_aliased_rctl(handle, ALIAS_MAXSWAP, &swap_limit); 50610209230bSgjelinek res3 = zonecfg_get_aliased_rctl(handle, ALIAS_MAXLOCKEDMEM, 50620209230bSgjelinek &locked_limit); 50630209230bSgjelinek 50640209230bSgjelinek if (res1 == Z_OK || res2 == Z_OK || res3 == Z_OK) 50650209230bSgjelinek output_mcap(fp, &lookup, res2, swap_limit, res3, locked_limit); 50660209230bSgjelinek } 50670209230bSgjelinek 50687c478bd9Sstevel@tonic-gate void 50697c478bd9Sstevel@tonic-gate info_func(cmd_t *cmd) 50707c478bd9Sstevel@tonic-gate { 50717c478bd9Sstevel@tonic-gate FILE *fp = stdout; 50727c478bd9Sstevel@tonic-gate bool need_to_close = FALSE; 50737c478bd9Sstevel@tonic-gate char *pager; 50740209230bSgjelinek int type; 50750209230bSgjelinek int res1, res2; 50760209230bSgjelinek uint64_t swap_limit; 50770209230bSgjelinek uint64_t locked_limit; 50787c478bd9Sstevel@tonic-gate 50797c478bd9Sstevel@tonic-gate assert(cmd != NULL); 50807c478bd9Sstevel@tonic-gate 50817c478bd9Sstevel@tonic-gate if (initialize(TRUE) != Z_OK) 50827c478bd9Sstevel@tonic-gate return; 50837c478bd9Sstevel@tonic-gate 50847c478bd9Sstevel@tonic-gate /* don't page error output */ 50857c478bd9Sstevel@tonic-gate if (interactive_mode) { 50867c478bd9Sstevel@tonic-gate if ((pager = getenv("PAGER")) == NULL) 50877c478bd9Sstevel@tonic-gate pager = PAGER; 50887c478bd9Sstevel@tonic-gate if ((fp = popen(pager, "w")) != NULL) 50897c478bd9Sstevel@tonic-gate need_to_close = TRUE; 50907c478bd9Sstevel@tonic-gate setbuf(fp, NULL); 50917c478bd9Sstevel@tonic-gate } 50927c478bd9Sstevel@tonic-gate 50937c478bd9Sstevel@tonic-gate if (!global_scope) { 50947c478bd9Sstevel@tonic-gate switch (resource_scope) { 50957c478bd9Sstevel@tonic-gate case RT_FS: 50967c478bd9Sstevel@tonic-gate output_fs(fp, &in_progress_fstab); 50977c478bd9Sstevel@tonic-gate break; 50987c478bd9Sstevel@tonic-gate case RT_IPD: 50997c478bd9Sstevel@tonic-gate output_ipd(fp, &in_progress_ipdtab); 51007c478bd9Sstevel@tonic-gate break; 51017c478bd9Sstevel@tonic-gate case RT_NET: 51027c478bd9Sstevel@tonic-gate output_net(fp, &in_progress_nwiftab); 51037c478bd9Sstevel@tonic-gate break; 51047c478bd9Sstevel@tonic-gate case RT_DEVICE: 51057c478bd9Sstevel@tonic-gate output_dev(fp, &in_progress_devtab); 51067c478bd9Sstevel@tonic-gate break; 51077c478bd9Sstevel@tonic-gate case RT_RCTL: 51087c478bd9Sstevel@tonic-gate output_rctl(fp, &in_progress_rctltab); 51097c478bd9Sstevel@tonic-gate break; 51107c478bd9Sstevel@tonic-gate case RT_ATTR: 51117c478bd9Sstevel@tonic-gate output_attr(fp, &in_progress_attrtab); 51127c478bd9Sstevel@tonic-gate break; 5113fa9e4066Sahrens case RT_DATASET: 5114fa9e4066Sahrens output_ds(fp, &in_progress_dstab); 5115fa9e4066Sahrens break; 51160209230bSgjelinek case RT_DCPU: 51170209230bSgjelinek output_pset(fp, &in_progress_psettab); 51180209230bSgjelinek break; 5119c97ad5cdSakolb case RT_PCAP: 5120c97ad5cdSakolb output_pcap(fp); 5121c97ad5cdSakolb break; 51220209230bSgjelinek case RT_MCAP: 51230209230bSgjelinek res1 = zonecfg_get_aliased_rctl(handle, ALIAS_MAXSWAP, 51240209230bSgjelinek &swap_limit); 51250209230bSgjelinek res2 = zonecfg_get_aliased_rctl(handle, 51260209230bSgjelinek ALIAS_MAXLOCKEDMEM, &locked_limit); 51270209230bSgjelinek output_mcap(fp, &in_progress_mcaptab, res1, swap_limit, 51280209230bSgjelinek res2, locked_limit); 51290209230bSgjelinek break; 51307c478bd9Sstevel@tonic-gate } 51317c478bd9Sstevel@tonic-gate goto cleanup; 51327c478bd9Sstevel@tonic-gate } 51337c478bd9Sstevel@tonic-gate 51340209230bSgjelinek type = cmd->cmd_res_type; 51350209230bSgjelinek 51360209230bSgjelinek if (gz_invalid_rt_property(type)) { 51370209230bSgjelinek zerr(gettext("%s is not a valid property for the global zone."), 51380209230bSgjelinek rt_to_str(type)); 51390209230bSgjelinek goto cleanup; 51400209230bSgjelinek } 51410209230bSgjelinek 51420209230bSgjelinek if (gz_invalid_resource(type)) { 51430209230bSgjelinek zerr(gettext("%s is not a valid resource for the global zone."), 51440209230bSgjelinek rt_to_str(type)); 51450209230bSgjelinek goto cleanup; 51460209230bSgjelinek } 51470209230bSgjelinek 51487c478bd9Sstevel@tonic-gate switch (cmd->cmd_res_type) { 51497c478bd9Sstevel@tonic-gate case RT_UNKNOWN: 5150087719fdSdp info_zonename(handle, fp); 51510209230bSgjelinek if (!global_zone) { 51520209230bSgjelinek info_zonepath(handle, fp); 51530209230bSgjelinek info_brand(handle, fp); 51540209230bSgjelinek info_autoboot(handle, fp); 51550209230bSgjelinek info_bootargs(handle, fp); 51560209230bSgjelinek } 51577c478bd9Sstevel@tonic-gate info_pool(handle, fp); 51580209230bSgjelinek if (!global_zone) { 51590209230bSgjelinek info_limitpriv(handle, fp); 51600209230bSgjelinek info_sched(handle, fp); 5161f4b3ec61Sdh info_iptype(handle, fp); 51620209230bSgjelinek } 51630209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXLWPS); 51640209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXSHMMEM); 51650209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXSHMIDS); 51660209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXMSGIDS); 51670209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXSEMIDS); 51680209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_SHARES); 51690209230bSgjelinek if (!global_zone) { 51700209230bSgjelinek info_ipd(handle, fp, cmd); 51710209230bSgjelinek info_fs(handle, fp, cmd); 51720209230bSgjelinek info_net(handle, fp, cmd); 51730209230bSgjelinek info_dev(handle, fp, cmd); 51740209230bSgjelinek } 51750209230bSgjelinek info_pset(handle, fp); 5176c97ad5cdSakolb info_pcap(fp); 51770209230bSgjelinek info_mcap(handle, fp); 51780209230bSgjelinek if (!global_zone) { 51790209230bSgjelinek info_attr(handle, fp, cmd); 51800209230bSgjelinek info_ds(handle, fp, cmd); 51810209230bSgjelinek } 51827c478bd9Sstevel@tonic-gate info_rctl(handle, fp, cmd); 51837c478bd9Sstevel@tonic-gate break; 5184087719fdSdp case RT_ZONENAME: 5185087719fdSdp info_zonename(handle, fp); 5186087719fdSdp break; 51877c478bd9Sstevel@tonic-gate case RT_ZONEPATH: 51887c478bd9Sstevel@tonic-gate info_zonepath(handle, fp); 51897c478bd9Sstevel@tonic-gate break; 51909acbbeafSnn case RT_BRAND: 51919acbbeafSnn info_brand(handle, fp); 51929acbbeafSnn break; 51937c478bd9Sstevel@tonic-gate case RT_AUTOBOOT: 51947c478bd9Sstevel@tonic-gate info_autoboot(handle, fp); 51957c478bd9Sstevel@tonic-gate break; 51967c478bd9Sstevel@tonic-gate case RT_POOL: 51977c478bd9Sstevel@tonic-gate info_pool(handle, fp); 51987c478bd9Sstevel@tonic-gate break; 5199ffbafc53Scomay case RT_LIMITPRIV: 5200ffbafc53Scomay info_limitpriv(handle, fp); 5201ffbafc53Scomay break; 52023f2f09c1Sdp case RT_BOOTARGS: 52033f2f09c1Sdp info_bootargs(handle, fp); 52043f2f09c1Sdp break; 52050209230bSgjelinek case RT_SCHED: 52060209230bSgjelinek info_sched(handle, fp); 52070209230bSgjelinek break; 5208f4b3ec61Sdh case RT_IPTYPE: 5209f4b3ec61Sdh info_iptype(handle, fp); 5210f4b3ec61Sdh break; 52110209230bSgjelinek case RT_MAXLWPS: 52120209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXLWPS); 52130209230bSgjelinek break; 52140209230bSgjelinek case RT_MAXSHMMEM: 52150209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXSHMMEM); 52160209230bSgjelinek break; 52170209230bSgjelinek case RT_MAXSHMIDS: 52180209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXSHMIDS); 52190209230bSgjelinek break; 52200209230bSgjelinek case RT_MAXMSGIDS: 52210209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXMSGIDS); 52220209230bSgjelinek break; 52230209230bSgjelinek case RT_MAXSEMIDS: 52240209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXSEMIDS); 52250209230bSgjelinek break; 52260209230bSgjelinek case RT_SHARES: 52270209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_SHARES); 52280209230bSgjelinek break; 52297c478bd9Sstevel@tonic-gate case RT_FS: 52307c478bd9Sstevel@tonic-gate info_fs(handle, fp, cmd); 52317c478bd9Sstevel@tonic-gate break; 52327c478bd9Sstevel@tonic-gate case RT_IPD: 52337c478bd9Sstevel@tonic-gate info_ipd(handle, fp, cmd); 52347c478bd9Sstevel@tonic-gate break; 52357c478bd9Sstevel@tonic-gate case RT_NET: 52367c478bd9Sstevel@tonic-gate info_net(handle, fp, cmd); 52377c478bd9Sstevel@tonic-gate break; 52387c478bd9Sstevel@tonic-gate case RT_DEVICE: 52397c478bd9Sstevel@tonic-gate info_dev(handle, fp, cmd); 52407c478bd9Sstevel@tonic-gate break; 52417c478bd9Sstevel@tonic-gate case RT_RCTL: 52427c478bd9Sstevel@tonic-gate info_rctl(handle, fp, cmd); 52437c478bd9Sstevel@tonic-gate break; 52447c478bd9Sstevel@tonic-gate case RT_ATTR: 52457c478bd9Sstevel@tonic-gate info_attr(handle, fp, cmd); 52467c478bd9Sstevel@tonic-gate break; 5247fa9e4066Sahrens case RT_DATASET: 5248fa9e4066Sahrens info_ds(handle, fp, cmd); 5249fa9e4066Sahrens break; 52500209230bSgjelinek case RT_DCPU: 52510209230bSgjelinek info_pset(handle, fp); 52520209230bSgjelinek break; 5253c97ad5cdSakolb case RT_PCAP: 5254c97ad5cdSakolb info_pcap(fp); 5255c97ad5cdSakolb break; 52560209230bSgjelinek case RT_MCAP: 52570209230bSgjelinek info_mcap(handle, fp); 52580209230bSgjelinek break; 52597c478bd9Sstevel@tonic-gate default: 52607c478bd9Sstevel@tonic-gate zone_perror(rt_to_str(cmd->cmd_res_type), Z_NO_RESOURCE_TYPE, 52617c478bd9Sstevel@tonic-gate TRUE); 52627c478bd9Sstevel@tonic-gate } 52637c478bd9Sstevel@tonic-gate 52647c478bd9Sstevel@tonic-gate cleanup: 52657c478bd9Sstevel@tonic-gate if (need_to_close) 52667c478bd9Sstevel@tonic-gate (void) pclose(fp); 52677c478bd9Sstevel@tonic-gate } 52687c478bd9Sstevel@tonic-gate 5269087719fdSdp /* 5270087719fdSdp * Helper function for verify-- checks that a required string property 5271087719fdSdp * exists. 5272087719fdSdp */ 5273087719fdSdp static void 5274087719fdSdp check_reqd_prop(char *attr, int rt, int pt, int *ret_val) 52757c478bd9Sstevel@tonic-gate { 5276087719fdSdp if (strlen(attr) == 0) { 5277087719fdSdp zerr(gettext("%s: %s not specified"), rt_to_str(rt), 5278087719fdSdp pt_to_str(pt)); 5279087719fdSdp saw_error = TRUE; 5280087719fdSdp if (*ret_val == Z_OK) 5281087719fdSdp *ret_val = Z_REQD_PROPERTY_MISSING; 52827c478bd9Sstevel@tonic-gate } 52837c478bd9Sstevel@tonic-gate } 52847c478bd9Sstevel@tonic-gate 52859acbbeafSnn static int 52869acbbeafSnn do_subproc(char *cmdbuf) 52879acbbeafSnn { 52889acbbeafSnn char inbuf[MAX_CMD_LEN]; 52899acbbeafSnn FILE *file; 52909acbbeafSnn int status; 52919acbbeafSnn 52929acbbeafSnn file = popen(cmdbuf, "r"); 52939acbbeafSnn if (file == NULL) { 52949acbbeafSnn zerr(gettext("Could not launch: %s"), cmdbuf); 52959acbbeafSnn return (-1); 52969acbbeafSnn } 52979acbbeafSnn 52989acbbeafSnn while (fgets(inbuf, sizeof (inbuf), file) != NULL) 52999acbbeafSnn fprintf(stderr, "%s", inbuf); 53009acbbeafSnn status = pclose(file); 53019acbbeafSnn 53029acbbeafSnn if (WIFSIGNALED(status)) { 53039acbbeafSnn zerr(gettext("%s unexpectedly terminated due to signal %d"), 53049acbbeafSnn cmdbuf, WTERMSIG(status)); 53059acbbeafSnn return (-1); 53069acbbeafSnn } 53079acbbeafSnn assert(WIFEXITED(status)); 53089acbbeafSnn return (WEXITSTATUS(status)); 53099acbbeafSnn } 53109acbbeafSnn 53119acbbeafSnn static int 53129acbbeafSnn brand_verify(zone_dochandle_t handle) 53139acbbeafSnn { 53146e65f9afSnn char xml_file[32]; 53159acbbeafSnn char cmdbuf[MAX_CMD_LEN]; 5316123807fbSedp brand_handle_t bh; 53179acbbeafSnn char brand[MAXNAMELEN]; 53189acbbeafSnn int err; 53199acbbeafSnn 53209acbbeafSnn if (zonecfg_get_brand(handle, brand, sizeof (brand)) != Z_OK) { 53219acbbeafSnn zerr("%s: %s\n", zone, gettext("could not get zone brand")); 53229acbbeafSnn return (Z_INVALID_DOCUMENT); 53239acbbeafSnn } 5324123807fbSedp if ((bh = brand_open(brand)) == NULL) { 53259acbbeafSnn zerr("%s: %s\n", zone, gettext("unknown brand.")); 53269acbbeafSnn return (Z_INVALID_DOCUMENT); 53279acbbeafSnn } 53289acbbeafSnn 53299acbbeafSnn /* 53309acbbeafSnn * Fetch the verify command, if any, from the brand configuration 53319acbbeafSnn * and build the command line to execute it. 53329acbbeafSnn */ 53339acbbeafSnn strcpy(cmdbuf, EXEC_PREFIX); 5334123807fbSedp err = brand_get_verify_cfg(bh, cmdbuf + EXEC_LEN, 53359acbbeafSnn sizeof (cmdbuf) - (EXEC_LEN + (strlen(xml_file) + 1))); 5336123807fbSedp brand_close(bh); 53379acbbeafSnn if (err != Z_OK) { 53389acbbeafSnn zerr("%s: %s\n", zone, 53399acbbeafSnn gettext("could not get brand verification command")); 53409acbbeafSnn return (Z_INVALID_DOCUMENT); 53419acbbeafSnn } 53429acbbeafSnn 53439acbbeafSnn /* 53449acbbeafSnn * If the brand doesn't provide a verification routine, we just 53459acbbeafSnn * return success. 53469acbbeafSnn */ 53479acbbeafSnn if (strlen(cmdbuf) == EXEC_LEN) 53489acbbeafSnn return (Z_OK); 53499acbbeafSnn 53509acbbeafSnn /* 53519acbbeafSnn * Dump the current config information for this zone to a file. 53529acbbeafSnn */ 53536e65f9afSnn strcpy(xml_file, "/tmp/zonecfg_verify.XXXXXX"); 53549acbbeafSnn if (mkstemp(xml_file) == NULL) 53559acbbeafSnn return (Z_TEMP_FILE); 53569acbbeafSnn if ((err = zonecfg_verify_save(handle, xml_file)) != Z_OK) { 53579acbbeafSnn (void) unlink(xml_file); 53589acbbeafSnn return (err); 53599acbbeafSnn } 53609acbbeafSnn 53619acbbeafSnn /* 53629acbbeafSnn * Execute the verification command. 53639acbbeafSnn */ 53649acbbeafSnn if ((strlcat(cmdbuf, " ", MAX_CMD_LEN) >= MAX_CMD_LEN) || 53659acbbeafSnn (strlcat(cmdbuf, xml_file, MAX_CMD_LEN) >= MAX_CMD_LEN)) { 53669acbbeafSnn err = Z_BRAND_ERROR; 53679acbbeafSnn } else { 53689acbbeafSnn err = do_subproc(cmdbuf); 53699acbbeafSnn } 53709acbbeafSnn 53719acbbeafSnn (void) unlink(xml_file); 53729acbbeafSnn return ((err == Z_OK) ? Z_OK : Z_BRAND_ERROR); 53739acbbeafSnn } 53749acbbeafSnn 53757c478bd9Sstevel@tonic-gate /* 53767c478bd9Sstevel@tonic-gate * See the DTD for which attributes are required for which resources. 53777c478bd9Sstevel@tonic-gate * 53787c478bd9Sstevel@tonic-gate * This function can be called by commit_func(), which needs to save things, 53797c478bd9Sstevel@tonic-gate * in addition to the general call from parse_and_run(), which doesn't need 53807c478bd9Sstevel@tonic-gate * things saved. Since the parameters are standardized, we distinguish by 53817c478bd9Sstevel@tonic-gate * having commit_func() call here with cmd->cmd_arg set to "save" to indicate 53827c478bd9Sstevel@tonic-gate * that a save is needed. 53837c478bd9Sstevel@tonic-gate */ 53847c478bd9Sstevel@tonic-gate void 53857c478bd9Sstevel@tonic-gate verify_func(cmd_t *cmd) 53867c478bd9Sstevel@tonic-gate { 53877c478bd9Sstevel@tonic-gate struct zone_nwiftab nwiftab; 53887c478bd9Sstevel@tonic-gate struct zone_fstab fstab; 53897c478bd9Sstevel@tonic-gate struct zone_attrtab attrtab; 53907c478bd9Sstevel@tonic-gate struct zone_rctltab rctltab; 5391fa9e4066Sahrens struct zone_dstab dstab; 53920209230bSgjelinek struct zone_psettab psettab; 53937c478bd9Sstevel@tonic-gate char zonepath[MAXPATHLEN]; 53940209230bSgjelinek char sched[MAXNAMELEN]; 53959acbbeafSnn char brand[MAXNAMELEN]; 53967c478bd9Sstevel@tonic-gate int err, ret_val = Z_OK, arg; 5397c97ad5cdSakolb int pset_res; 53987c478bd9Sstevel@tonic-gate bool save = FALSE; 53997ec75eb8Sgjelinek bool arg_err = FALSE; 5400f4b3ec61Sdh zone_iptype_t iptype; 54010209230bSgjelinek boolean_t has_cpu_shares = B_FALSE; 5402c97ad5cdSakolb boolean_t has_cpu_cap = B_FALSE; 54037c478bd9Sstevel@tonic-gate 54047c478bd9Sstevel@tonic-gate optind = 0; 54057ec75eb8Sgjelinek while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?")) != EOF) { 54067c478bd9Sstevel@tonic-gate switch (arg) { 54077c478bd9Sstevel@tonic-gate case '?': 54087c478bd9Sstevel@tonic-gate longer_usage(CMD_VERIFY); 54097ec75eb8Sgjelinek arg_err = TRUE; 54107ec75eb8Sgjelinek break; 54117c478bd9Sstevel@tonic-gate default: 54127c478bd9Sstevel@tonic-gate short_usage(CMD_VERIFY); 54137ec75eb8Sgjelinek arg_err = TRUE; 54147ec75eb8Sgjelinek break; 54157c478bd9Sstevel@tonic-gate } 54167c478bd9Sstevel@tonic-gate } 54177ec75eb8Sgjelinek if (arg_err) 54187ec75eb8Sgjelinek return; 54197ec75eb8Sgjelinek 54207c478bd9Sstevel@tonic-gate if (optind > cmd->cmd_argc) { 54217c478bd9Sstevel@tonic-gate short_usage(CMD_VERIFY); 54227c478bd9Sstevel@tonic-gate return; 54237c478bd9Sstevel@tonic-gate } 54247c478bd9Sstevel@tonic-gate 54257c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_VERIFY)) 54267c478bd9Sstevel@tonic-gate return; 54277c478bd9Sstevel@tonic-gate 54287c478bd9Sstevel@tonic-gate assert(cmd != NULL); 54297c478bd9Sstevel@tonic-gate 54307c478bd9Sstevel@tonic-gate if (cmd->cmd_argc > 0 && (strcmp(cmd->cmd_argv[0], "save") == 0)) 54317c478bd9Sstevel@tonic-gate save = TRUE; 54327c478bd9Sstevel@tonic-gate if (initialize(TRUE) != Z_OK) 54337c478bd9Sstevel@tonic-gate return; 54347c478bd9Sstevel@tonic-gate 54350209230bSgjelinek if (zonecfg_get_zonepath(handle, zonepath, sizeof (zonepath)) != Z_OK && 54360209230bSgjelinek !global_zone) { 5437087719fdSdp zerr(gettext("%s not specified"), pt_to_str(PT_ZONEPATH)); 54387c478bd9Sstevel@tonic-gate ret_val = Z_REQD_RESOURCE_MISSING; 54397c478bd9Sstevel@tonic-gate saw_error = TRUE; 54407c478bd9Sstevel@tonic-gate } 54410209230bSgjelinek if (strlen(zonepath) == 0 && !global_zone) { 5442087719fdSdp zerr(gettext("%s cannot be empty."), pt_to_str(PT_ZONEPATH)); 54437c478bd9Sstevel@tonic-gate ret_val = Z_REQD_RESOURCE_MISSING; 54447c478bd9Sstevel@tonic-gate saw_error = TRUE; 54457c478bd9Sstevel@tonic-gate } 54467c478bd9Sstevel@tonic-gate 54479acbbeafSnn if ((err = zonecfg_get_brand(handle, brand, sizeof (brand))) != Z_OK) { 54489acbbeafSnn zone_perror(zone, err, TRUE); 54499acbbeafSnn return; 54509acbbeafSnn } 54519acbbeafSnn if (strcmp(brand, NATIVE_BRAND_NAME) != 0) { 54529acbbeafSnn if ((err = brand_verify(handle)) != Z_OK) { 54539acbbeafSnn zone_perror(zone, err, TRUE); 54549acbbeafSnn return; 54559acbbeafSnn } 54569acbbeafSnn } 54579acbbeafSnn 5458f4b3ec61Sdh if (zonecfg_get_iptype(handle, &iptype) != Z_OK) { 5459f4b3ec61Sdh zerr("%s %s", gettext("cannot get"), pt_to_str(PT_IPTYPE)); 5460f4b3ec61Sdh ret_val = Z_REQD_RESOURCE_MISSING; 5461f4b3ec61Sdh saw_error = TRUE; 5462f4b3ec61Sdh } 54637c478bd9Sstevel@tonic-gate if ((err = zonecfg_setipdent(handle)) != Z_OK) { 54647c478bd9Sstevel@tonic-gate zone_perror(zone, err, TRUE); 54657c478bd9Sstevel@tonic-gate return; 54667c478bd9Sstevel@tonic-gate } 54677c478bd9Sstevel@tonic-gate while (zonecfg_getipdent(handle, &fstab) == Z_OK) { 5468087719fdSdp check_reqd_prop(fstab.zone_fs_dir, RT_IPD, PT_DIR, &ret_val); 54697c478bd9Sstevel@tonic-gate } 54707c478bd9Sstevel@tonic-gate (void) zonecfg_endipdent(handle); 54717c478bd9Sstevel@tonic-gate 54727c478bd9Sstevel@tonic-gate if ((err = zonecfg_setfsent(handle)) != Z_OK) { 54737c478bd9Sstevel@tonic-gate zone_perror(zone, err, TRUE); 54747c478bd9Sstevel@tonic-gate return; 54757c478bd9Sstevel@tonic-gate } 54767c478bd9Sstevel@tonic-gate while (zonecfg_getfsent(handle, &fstab) == Z_OK) { 5477087719fdSdp check_reqd_prop(fstab.zone_fs_dir, RT_FS, PT_DIR, &ret_val); 5478087719fdSdp check_reqd_prop(fstab.zone_fs_special, RT_FS, PT_SPECIAL, 5479087719fdSdp &ret_val); 5480087719fdSdp check_reqd_prop(fstab.zone_fs_type, RT_FS, PT_TYPE, &ret_val); 5481087719fdSdp 54827c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(fstab.zone_fs_options); 54837c478bd9Sstevel@tonic-gate } 54847c478bd9Sstevel@tonic-gate (void) zonecfg_endfsent(handle); 54857c478bd9Sstevel@tonic-gate 54867c478bd9Sstevel@tonic-gate if ((err = zonecfg_setnwifent(handle)) != Z_OK) { 54877c478bd9Sstevel@tonic-gate zone_perror(zone, err, TRUE); 54887c478bd9Sstevel@tonic-gate return; 54897c478bd9Sstevel@tonic-gate } 54907c478bd9Sstevel@tonic-gate while (zonecfg_getnwifent(handle, &nwiftab) == Z_OK) { 5491f4b3ec61Sdh /* 5492f4b3ec61Sdh * physical is required in all cases. 5493*de860bd9Sgfaden * A shared IP requires an address, 5494*de860bd9Sgfaden * and may include a default router, while 5495*de860bd9Sgfaden * an exclusive IP must have neither an address 5496*de860bd9Sgfaden * nor a default router. 5497f4b3ec61Sdh */ 5498087719fdSdp check_reqd_prop(nwiftab.zone_nwif_physical, RT_NET, 5499087719fdSdp PT_PHYSICAL, &ret_val); 5500f4b3ec61Sdh 5501f4b3ec61Sdh switch (iptype) { 5502f4b3ec61Sdh case ZS_SHARED: 5503f4b3ec61Sdh check_reqd_prop(nwiftab.zone_nwif_address, RT_NET, 5504f4b3ec61Sdh PT_ADDRESS, &ret_val); 5505f4b3ec61Sdh break; 5506f4b3ec61Sdh case ZS_EXCLUSIVE: 5507f4b3ec61Sdh if (strlen(nwiftab.zone_nwif_address) > 0) { 5508f4b3ec61Sdh zerr(gettext("%s: %s cannot be specified " 5509f4b3ec61Sdh "for an exclusive IP type"), 5510f4b3ec61Sdh rt_to_str(RT_NET), pt_to_str(PT_ADDRESS)); 5511f4b3ec61Sdh saw_error = TRUE; 5512f4b3ec61Sdh if (ret_val == Z_OK) 5513f4b3ec61Sdh ret_val = Z_INVAL; 5514f4b3ec61Sdh } 5515*de860bd9Sgfaden if (strlen(nwiftab.zone_nwif_defrouter) > 0) { 5516*de860bd9Sgfaden zerr(gettext("%s: %s cannot be specified " 5517*de860bd9Sgfaden "for an exclusive IP type"), 5518*de860bd9Sgfaden rt_to_str(RT_NET), pt_to_str(PT_DEFROUTER)); 5519*de860bd9Sgfaden saw_error = TRUE; 5520*de860bd9Sgfaden if (ret_val == Z_OK) 5521*de860bd9Sgfaden ret_val = Z_INVAL; 5522*de860bd9Sgfaden } 5523f4b3ec61Sdh break; 5524f4b3ec61Sdh } 55257c478bd9Sstevel@tonic-gate } 55267c478bd9Sstevel@tonic-gate (void) zonecfg_endnwifent(handle); 55277c478bd9Sstevel@tonic-gate 55287c478bd9Sstevel@tonic-gate if ((err = zonecfg_setrctlent(handle)) != Z_OK) { 55297c478bd9Sstevel@tonic-gate zone_perror(zone, err, TRUE); 55307c478bd9Sstevel@tonic-gate return; 55317c478bd9Sstevel@tonic-gate } 55327c478bd9Sstevel@tonic-gate while (zonecfg_getrctlent(handle, &rctltab) == Z_OK) { 5533087719fdSdp check_reqd_prop(rctltab.zone_rctl_name, RT_RCTL, PT_NAME, 5534087719fdSdp &ret_val); 5535087719fdSdp 55360209230bSgjelinek if (strcmp(rctltab.zone_rctl_name, "zone.cpu-shares") == 0) 55370209230bSgjelinek has_cpu_shares = B_TRUE; 55380209230bSgjelinek 5539c97ad5cdSakolb if (strcmp(rctltab.zone_rctl_name, "zone.cpu-cap") == 0) 5540c97ad5cdSakolb has_cpu_cap = B_TRUE; 5541c97ad5cdSakolb 55427c478bd9Sstevel@tonic-gate if (rctltab.zone_rctl_valptr == NULL) { 55437c478bd9Sstevel@tonic-gate zerr(gettext("%s: no %s specified"), 55447c478bd9Sstevel@tonic-gate rt_to_str(RT_RCTL), pt_to_str(PT_VALUE)); 55457c478bd9Sstevel@tonic-gate saw_error = TRUE; 55467c478bd9Sstevel@tonic-gate if (ret_val == Z_OK) 55477c478bd9Sstevel@tonic-gate ret_val = Z_REQD_PROPERTY_MISSING; 55487c478bd9Sstevel@tonic-gate } else { 55497c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctltab.zone_rctl_valptr); 55507c478bd9Sstevel@tonic-gate } 55517c478bd9Sstevel@tonic-gate } 55527c478bd9Sstevel@tonic-gate (void) zonecfg_endrctlent(handle); 55537c478bd9Sstevel@tonic-gate 5554c97ad5cdSakolb if ((pset_res = zonecfg_lookup_pset(handle, &psettab)) == Z_OK && 5555c97ad5cdSakolb has_cpu_shares) { 55560209230bSgjelinek zerr(gettext("%s zone.cpu-shares and %s are incompatible."), 55570209230bSgjelinek rt_to_str(RT_RCTL), rt_to_str(RT_DCPU)); 55580209230bSgjelinek saw_error = TRUE; 55590209230bSgjelinek if (ret_val == Z_OK) 55600209230bSgjelinek ret_val = Z_INCOMPATIBLE; 55610209230bSgjelinek } 55620209230bSgjelinek 55630209230bSgjelinek if (has_cpu_shares && zonecfg_get_sched_class(handle, sched, 55640209230bSgjelinek sizeof (sched)) == Z_OK && strlen(sched) > 0 && 55650209230bSgjelinek strcmp(sched, "FSS") != 0) { 55660209230bSgjelinek zerr(gettext("WARNING: %s zone.cpu-shares and %s=%s are " 55670209230bSgjelinek "incompatible"), 55680209230bSgjelinek rt_to_str(RT_RCTL), rt_to_str(RT_SCHED), sched); 55690209230bSgjelinek saw_error = TRUE; 55700209230bSgjelinek if (ret_val == Z_OK) 55710209230bSgjelinek ret_val = Z_INCOMPATIBLE; 55720209230bSgjelinek } 55730209230bSgjelinek 5574c97ad5cdSakolb if (pset_res == Z_OK && has_cpu_cap) { 5575c97ad5cdSakolb zerr(gettext("%s zone.cpu-cap and the %s are incompatible."), 5576c97ad5cdSakolb rt_to_str(RT_RCTL), rt_to_str(RT_DCPU)); 5577c97ad5cdSakolb saw_error = TRUE; 5578c97ad5cdSakolb if (ret_val == Z_OK) 5579c97ad5cdSakolb ret_val = Z_INCOMPATIBLE; 5580c97ad5cdSakolb } 5581c97ad5cdSakolb 55827c478bd9Sstevel@tonic-gate if ((err = zonecfg_setattrent(handle)) != Z_OK) { 55837c478bd9Sstevel@tonic-gate zone_perror(zone, err, TRUE); 55847c478bd9Sstevel@tonic-gate return; 55857c478bd9Sstevel@tonic-gate } 55867c478bd9Sstevel@tonic-gate while (zonecfg_getattrent(handle, &attrtab) == Z_OK) { 5587087719fdSdp check_reqd_prop(attrtab.zone_attr_name, RT_ATTR, PT_NAME, 5588087719fdSdp &ret_val); 5589087719fdSdp check_reqd_prop(attrtab.zone_attr_type, RT_ATTR, PT_TYPE, 5590087719fdSdp &ret_val); 5591087719fdSdp check_reqd_prop(attrtab.zone_attr_value, RT_ATTR, PT_VALUE, 5592087719fdSdp &ret_val); 55937c478bd9Sstevel@tonic-gate } 55947c478bd9Sstevel@tonic-gate (void) zonecfg_endattrent(handle); 55957c478bd9Sstevel@tonic-gate 5596fa9e4066Sahrens if ((err = zonecfg_setdsent(handle)) != Z_OK) { 5597fa9e4066Sahrens zone_perror(zone, err, TRUE); 5598fa9e4066Sahrens return; 5599fa9e4066Sahrens } 5600fa9e4066Sahrens while (zonecfg_getdsent(handle, &dstab) == Z_OK) { 5601fa9e4066Sahrens if (strlen(dstab.zone_dataset_name) == 0) { 5602fa9e4066Sahrens zerr("%s: %s %s", rt_to_str(RT_DATASET), 5603fa9e4066Sahrens pt_to_str(PT_NAME), gettext("not specified")); 5604fa9e4066Sahrens saw_error = TRUE; 5605fa9e4066Sahrens if (ret_val == Z_OK) 5606fa9e4066Sahrens ret_val = Z_REQD_PROPERTY_MISSING; 5607fa9e4066Sahrens } else if (!zfs_name_valid(dstab.zone_dataset_name, 5608fa9e4066Sahrens ZFS_TYPE_FILESYSTEM)) { 5609fa9e4066Sahrens zerr("%s: %s %s", rt_to_str(RT_DATASET), 5610fa9e4066Sahrens pt_to_str(PT_NAME), gettext("invalid")); 5611fa9e4066Sahrens saw_error = TRUE; 5612fa9e4066Sahrens if (ret_val == Z_OK) 5613fa9e4066Sahrens ret_val = Z_BAD_PROPERTY; 5614fa9e4066Sahrens } 5615fa9e4066Sahrens 5616fa9e4066Sahrens } 5617fa9e4066Sahrens (void) zonecfg_enddsent(handle); 5618fa9e4066Sahrens 56197c478bd9Sstevel@tonic-gate if (!global_scope) { 56207c478bd9Sstevel@tonic-gate zerr(gettext("resource specification incomplete")); 56217c478bd9Sstevel@tonic-gate saw_error = TRUE; 56227c478bd9Sstevel@tonic-gate if (ret_val == Z_OK) 56237c478bd9Sstevel@tonic-gate ret_val = Z_INSUFFICIENT_SPEC; 56247c478bd9Sstevel@tonic-gate } 56257c478bd9Sstevel@tonic-gate 56267c478bd9Sstevel@tonic-gate if (save) { 5627087719fdSdp if (ret_val == Z_OK) { 5628087719fdSdp if ((ret_val = zonecfg_save(handle)) == Z_OK) { 5629087719fdSdp need_to_commit = FALSE; 5630087719fdSdp (void) strlcpy(revert_zone, zone, 5631087719fdSdp sizeof (revert_zone)); 5632087719fdSdp } 5633087719fdSdp } else { 5634087719fdSdp zerr(gettext("Zone %s failed to verify"), zone); 5635087719fdSdp } 56367c478bd9Sstevel@tonic-gate } 56377c478bd9Sstevel@tonic-gate if (ret_val != Z_OK) 56387c478bd9Sstevel@tonic-gate zone_perror(zone, ret_val, TRUE); 56397c478bd9Sstevel@tonic-gate } 56407c478bd9Sstevel@tonic-gate 56417c478bd9Sstevel@tonic-gate void 56427c478bd9Sstevel@tonic-gate cancel_func(cmd_t *cmd) 56437c478bd9Sstevel@tonic-gate { 56447c478bd9Sstevel@tonic-gate int arg; 56457ec75eb8Sgjelinek bool arg_err = FALSE; 56467c478bd9Sstevel@tonic-gate 56477c478bd9Sstevel@tonic-gate assert(cmd != NULL); 56487c478bd9Sstevel@tonic-gate 56497c478bd9Sstevel@tonic-gate optind = 0; 56507ec75eb8Sgjelinek while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?")) != EOF) { 56517c478bd9Sstevel@tonic-gate switch (arg) { 56527c478bd9Sstevel@tonic-gate case '?': 56537c478bd9Sstevel@tonic-gate longer_usage(CMD_CANCEL); 56547ec75eb8Sgjelinek arg_err = TRUE; 56557ec75eb8Sgjelinek break; 56567c478bd9Sstevel@tonic-gate default: 56577c478bd9Sstevel@tonic-gate short_usage(CMD_CANCEL); 56587ec75eb8Sgjelinek arg_err = TRUE; 56597ec75eb8Sgjelinek break; 56607c478bd9Sstevel@tonic-gate } 56617c478bd9Sstevel@tonic-gate } 56627ec75eb8Sgjelinek if (arg_err) 56637ec75eb8Sgjelinek return; 56647ec75eb8Sgjelinek 56657c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 56667c478bd9Sstevel@tonic-gate short_usage(CMD_CANCEL); 56677c478bd9Sstevel@tonic-gate return; 56687c478bd9Sstevel@tonic-gate } 56697c478bd9Sstevel@tonic-gate 56707c478bd9Sstevel@tonic-gate if (global_scope) 56717c478bd9Sstevel@tonic-gate scope_usage(CMD_CANCEL); 56727c478bd9Sstevel@tonic-gate global_scope = TRUE; 56737c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(in_progress_fstab.zone_fs_options); 56747c478bd9Sstevel@tonic-gate bzero(&in_progress_fstab, sizeof (in_progress_fstab)); 56757c478bd9Sstevel@tonic-gate bzero(&in_progress_nwiftab, sizeof (in_progress_nwiftab)); 5676fa9e4066Sahrens bzero(&in_progress_ipdtab, sizeof (in_progress_ipdtab)); 56777c478bd9Sstevel@tonic-gate bzero(&in_progress_devtab, sizeof (in_progress_devtab)); 56787c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(in_progress_rctltab.zone_rctl_valptr); 56797c478bd9Sstevel@tonic-gate bzero(&in_progress_rctltab, sizeof (in_progress_rctltab)); 56807c478bd9Sstevel@tonic-gate bzero(&in_progress_attrtab, sizeof (in_progress_attrtab)); 5681fa9e4066Sahrens bzero(&in_progress_dstab, sizeof (in_progress_dstab)); 56827c478bd9Sstevel@tonic-gate } 56837c478bd9Sstevel@tonic-gate 56847c478bd9Sstevel@tonic-gate static int 56857c478bd9Sstevel@tonic-gate validate_attr_name(char *name) 56867c478bd9Sstevel@tonic-gate { 56877c478bd9Sstevel@tonic-gate int i; 56887c478bd9Sstevel@tonic-gate 56897c478bd9Sstevel@tonic-gate if (!isalnum(name[0])) { 56907c478bd9Sstevel@tonic-gate zerr(gettext("Invalid %s %s %s: must start with an alpha-" 56917c478bd9Sstevel@tonic-gate "numeric character."), rt_to_str(RT_ATTR), 56927c478bd9Sstevel@tonic-gate pt_to_str(PT_NAME), name); 56937c478bd9Sstevel@tonic-gate return (Z_INVAL); 56947c478bd9Sstevel@tonic-gate } 56957c478bd9Sstevel@tonic-gate for (i = 1; name[i]; i++) 56967c478bd9Sstevel@tonic-gate if (!isalnum(name[i]) && name[i] != '-' && name[i] != '.') { 56977c478bd9Sstevel@tonic-gate zerr(gettext("Invalid %s %s %s: can only contain " 56987c478bd9Sstevel@tonic-gate "alpha-numeric characters, plus '-' and '.'."), 56997c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR), pt_to_str(PT_NAME), name); 57007c478bd9Sstevel@tonic-gate return (Z_INVAL); 57017c478bd9Sstevel@tonic-gate } 57027c478bd9Sstevel@tonic-gate return (Z_OK); 57037c478bd9Sstevel@tonic-gate } 57047c478bd9Sstevel@tonic-gate 57057c478bd9Sstevel@tonic-gate static int 57067c478bd9Sstevel@tonic-gate validate_attr_type_val(struct zone_attrtab *attrtab) 57077c478bd9Sstevel@tonic-gate { 57087c478bd9Sstevel@tonic-gate boolean_t boolval; 57097c478bd9Sstevel@tonic-gate int64_t intval; 57107c478bd9Sstevel@tonic-gate char strval[MAXNAMELEN]; 57117c478bd9Sstevel@tonic-gate uint64_t uintval; 57127c478bd9Sstevel@tonic-gate 57137c478bd9Sstevel@tonic-gate if (strcmp(attrtab->zone_attr_type, "boolean") == 0) { 57147c478bd9Sstevel@tonic-gate if (zonecfg_get_attr_boolean(attrtab, &boolval) == Z_OK) 57157c478bd9Sstevel@tonic-gate return (Z_OK); 57167c478bd9Sstevel@tonic-gate zerr(gettext("invalid %s value for %s=%s"), 57177c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR), pt_to_str(PT_TYPE), "boolean"); 57187c478bd9Sstevel@tonic-gate return (Z_ERR); 57197c478bd9Sstevel@tonic-gate } 57207c478bd9Sstevel@tonic-gate 57217c478bd9Sstevel@tonic-gate if (strcmp(attrtab->zone_attr_type, "int") == 0) { 57227c478bd9Sstevel@tonic-gate if (zonecfg_get_attr_int(attrtab, &intval) == Z_OK) 57237c478bd9Sstevel@tonic-gate return (Z_OK); 57247c478bd9Sstevel@tonic-gate zerr(gettext("invalid %s value for %s=%s"), 57257c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR), pt_to_str(PT_TYPE), "int"); 57267c478bd9Sstevel@tonic-gate return (Z_ERR); 57277c478bd9Sstevel@tonic-gate } 57287c478bd9Sstevel@tonic-gate 57297c478bd9Sstevel@tonic-gate if (strcmp(attrtab->zone_attr_type, "string") == 0) { 57307c478bd9Sstevel@tonic-gate if (zonecfg_get_attr_string(attrtab, strval, 57317c478bd9Sstevel@tonic-gate sizeof (strval)) == Z_OK) 57327c478bd9Sstevel@tonic-gate return (Z_OK); 57337c478bd9Sstevel@tonic-gate zerr(gettext("invalid %s value for %s=%s"), 57347c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR), pt_to_str(PT_TYPE), "string"); 57357c478bd9Sstevel@tonic-gate return (Z_ERR); 57367c478bd9Sstevel@tonic-gate } 57377c478bd9Sstevel@tonic-gate 57387c478bd9Sstevel@tonic-gate if (strcmp(attrtab->zone_attr_type, "uint") == 0) { 57397c478bd9Sstevel@tonic-gate if (zonecfg_get_attr_uint(attrtab, &uintval) == Z_OK) 57407c478bd9Sstevel@tonic-gate return (Z_OK); 57417c478bd9Sstevel@tonic-gate zerr(gettext("invalid %s value for %s=%s"), 57427c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR), pt_to_str(PT_TYPE), "uint"); 57437c478bd9Sstevel@tonic-gate return (Z_ERR); 57447c478bd9Sstevel@tonic-gate } 57457c478bd9Sstevel@tonic-gate 57467c478bd9Sstevel@tonic-gate zerr(gettext("invalid %s %s '%s'"), rt_to_str(RT_ATTR), 57477c478bd9Sstevel@tonic-gate pt_to_str(PT_TYPE), attrtab->zone_attr_type); 57487c478bd9Sstevel@tonic-gate return (Z_ERR); 57497c478bd9Sstevel@tonic-gate } 57507c478bd9Sstevel@tonic-gate 5751087719fdSdp /* 5752087719fdSdp * Helper function for end_func-- checks the existence of a given property 5753087719fdSdp * and emits a message if not specified. 5754087719fdSdp */ 5755087719fdSdp static int 5756087719fdSdp end_check_reqd(char *attr, int pt, bool *validation_failed) 5757087719fdSdp { 5758087719fdSdp if (strlen(attr) == 0) { 5759087719fdSdp *validation_failed = TRUE; 5760087719fdSdp zerr(gettext("%s not specified"), pt_to_str(pt)); 5761087719fdSdp return (Z_ERR); 5762087719fdSdp } 5763087719fdSdp return (Z_OK); 5764087719fdSdp } 5765087719fdSdp 57667c478bd9Sstevel@tonic-gate void 57677c478bd9Sstevel@tonic-gate end_func(cmd_t *cmd) 57687c478bd9Sstevel@tonic-gate { 57697c478bd9Sstevel@tonic-gate bool validation_failed = FALSE; 57707ec75eb8Sgjelinek bool arg_err = FALSE; 57717c478bd9Sstevel@tonic-gate struct zone_fstab tmp_fstab; 57727c478bd9Sstevel@tonic-gate struct zone_nwiftab tmp_nwiftab; 57737c478bd9Sstevel@tonic-gate struct zone_devtab tmp_devtab; 57747c478bd9Sstevel@tonic-gate struct zone_rctltab tmp_rctltab; 57757c478bd9Sstevel@tonic-gate struct zone_attrtab tmp_attrtab; 5776fa9e4066Sahrens struct zone_dstab tmp_dstab; 57770209230bSgjelinek int err, arg, res1, res2, res3; 57780209230bSgjelinek uint64_t swap_limit; 57790209230bSgjelinek uint64_t locked_limit; 5780c97ad5cdSakolb uint64_t proc_cap; 57817c478bd9Sstevel@tonic-gate 57827c478bd9Sstevel@tonic-gate assert(cmd != NULL); 57837c478bd9Sstevel@tonic-gate 57847c478bd9Sstevel@tonic-gate optind = 0; 57857ec75eb8Sgjelinek while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?")) != EOF) { 57867c478bd9Sstevel@tonic-gate switch (arg) { 57877c478bd9Sstevel@tonic-gate case '?': 57887c478bd9Sstevel@tonic-gate longer_usage(CMD_END); 57897ec75eb8Sgjelinek arg_err = TRUE; 57907ec75eb8Sgjelinek break; 57917c478bd9Sstevel@tonic-gate default: 57927c478bd9Sstevel@tonic-gate short_usage(CMD_END); 57937ec75eb8Sgjelinek arg_err = TRUE; 57947ec75eb8Sgjelinek break; 57957c478bd9Sstevel@tonic-gate } 57967c478bd9Sstevel@tonic-gate } 57977ec75eb8Sgjelinek if (arg_err) 57987ec75eb8Sgjelinek return; 57997ec75eb8Sgjelinek 58007c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 58017c478bd9Sstevel@tonic-gate short_usage(CMD_END); 58027c478bd9Sstevel@tonic-gate return; 58037c478bd9Sstevel@tonic-gate } 58047c478bd9Sstevel@tonic-gate 58057c478bd9Sstevel@tonic-gate if (global_scope) { 58067c478bd9Sstevel@tonic-gate scope_usage(CMD_END); 58077c478bd9Sstevel@tonic-gate return; 58087c478bd9Sstevel@tonic-gate } 58097c478bd9Sstevel@tonic-gate 58107c478bd9Sstevel@tonic-gate assert(end_op == CMD_ADD || end_op == CMD_SELECT); 58117c478bd9Sstevel@tonic-gate 58127c478bd9Sstevel@tonic-gate switch (resource_scope) { 58137c478bd9Sstevel@tonic-gate case RT_FS: 58147c478bd9Sstevel@tonic-gate /* First make sure everything was filled in. */ 5815087719fdSdp if (end_check_reqd(in_progress_fstab.zone_fs_dir, 5816087719fdSdp PT_DIR, &validation_failed) == Z_OK) { 5817087719fdSdp if (in_progress_fstab.zone_fs_dir[0] != '/') { 5818087719fdSdp zerr(gettext("%s %s is not an absolute path."), 5819087719fdSdp pt_to_str(PT_DIR), 5820087719fdSdp in_progress_fstab.zone_fs_dir); 5821087719fdSdp validation_failed = TRUE; 5822087719fdSdp } 58237c478bd9Sstevel@tonic-gate } 5824087719fdSdp 5825087719fdSdp (void) end_check_reqd(in_progress_fstab.zone_fs_special, 5826087719fdSdp PT_SPECIAL, &validation_failed); 5827087719fdSdp 58287c478bd9Sstevel@tonic-gate if (in_progress_fstab.zone_fs_raw[0] != '\0' && 58297c478bd9Sstevel@tonic-gate in_progress_fstab.zone_fs_raw[0] != '/') { 5830087719fdSdp zerr(gettext("%s %s is not an absolute path."), 5831087719fdSdp pt_to_str(PT_RAW), 5832087719fdSdp in_progress_fstab.zone_fs_raw); 58337c478bd9Sstevel@tonic-gate validation_failed = TRUE; 58347c478bd9Sstevel@tonic-gate } 5835087719fdSdp 5836087719fdSdp (void) end_check_reqd(in_progress_fstab.zone_fs_type, PT_TYPE, 5837087719fdSdp &validation_failed); 5838087719fdSdp 5839087719fdSdp if (validation_failed) { 58407c478bd9Sstevel@tonic-gate saw_error = TRUE; 58417c478bd9Sstevel@tonic-gate return; 5842087719fdSdp } 5843087719fdSdp 58447c478bd9Sstevel@tonic-gate if (end_op == CMD_ADD) { 58457c478bd9Sstevel@tonic-gate /* Make sure there isn't already one like this. */ 58467c478bd9Sstevel@tonic-gate bzero(&tmp_fstab, sizeof (tmp_fstab)); 58477c478bd9Sstevel@tonic-gate (void) strlcpy(tmp_fstab.zone_fs_dir, 58487c478bd9Sstevel@tonic-gate in_progress_fstab.zone_fs_dir, 58497c478bd9Sstevel@tonic-gate sizeof (tmp_fstab.zone_fs_dir)); 58507c478bd9Sstevel@tonic-gate err = zonecfg_lookup_filesystem(handle, &tmp_fstab); 58517c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(tmp_fstab.zone_fs_options); 58527c478bd9Sstevel@tonic-gate if (err == Z_OK) { 58537c478bd9Sstevel@tonic-gate zerr(gettext("A %s resource " 58547c478bd9Sstevel@tonic-gate "with the %s '%s' already exists."), 58557c478bd9Sstevel@tonic-gate rt_to_str(RT_FS), pt_to_str(PT_DIR), 58567c478bd9Sstevel@tonic-gate in_progress_fstab.zone_fs_dir); 58577c478bd9Sstevel@tonic-gate saw_error = TRUE; 58587c478bd9Sstevel@tonic-gate return; 58597c478bd9Sstevel@tonic-gate } 58607c478bd9Sstevel@tonic-gate err = zonecfg_add_filesystem(handle, 58617c478bd9Sstevel@tonic-gate &in_progress_fstab); 58627c478bd9Sstevel@tonic-gate } else { 58637c478bd9Sstevel@tonic-gate err = zonecfg_modify_filesystem(handle, &old_fstab, 58647c478bd9Sstevel@tonic-gate &in_progress_fstab); 58657c478bd9Sstevel@tonic-gate } 58667c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(in_progress_fstab.zone_fs_options); 58677c478bd9Sstevel@tonic-gate in_progress_fstab.zone_fs_options = NULL; 58687c478bd9Sstevel@tonic-gate break; 5869087719fdSdp 58707c478bd9Sstevel@tonic-gate case RT_IPD: 58717c478bd9Sstevel@tonic-gate /* First make sure everything was filled in. */ 5872087719fdSdp if (end_check_reqd(in_progress_ipdtab.zone_fs_dir, PT_DIR, 5873087719fdSdp &validation_failed) == Z_OK) { 5874087719fdSdp if (in_progress_ipdtab.zone_fs_dir[0] != '/') { 5875087719fdSdp zerr(gettext("%s %s is not an absolute path."), 5876087719fdSdp pt_to_str(PT_DIR), 5877087719fdSdp in_progress_ipdtab.zone_fs_dir); 5878087719fdSdp validation_failed = TRUE; 5879087719fdSdp } 58807c478bd9Sstevel@tonic-gate } 5881087719fdSdp if (validation_failed) { 5882087719fdSdp saw_error = TRUE; 58837c478bd9Sstevel@tonic-gate return; 5884087719fdSdp } 5885087719fdSdp 58867c478bd9Sstevel@tonic-gate if (end_op == CMD_ADD) { 58877c478bd9Sstevel@tonic-gate /* Make sure there isn't already one like this. */ 58887c478bd9Sstevel@tonic-gate bzero(&tmp_fstab, sizeof (tmp_fstab)); 58897c478bd9Sstevel@tonic-gate (void) strlcpy(tmp_fstab.zone_fs_dir, 58907c478bd9Sstevel@tonic-gate in_progress_ipdtab.zone_fs_dir, 58917c478bd9Sstevel@tonic-gate sizeof (tmp_fstab.zone_fs_dir)); 58927c478bd9Sstevel@tonic-gate err = zonecfg_lookup_ipd(handle, &tmp_fstab); 58937c478bd9Sstevel@tonic-gate if (err == Z_OK) { 58947c478bd9Sstevel@tonic-gate zerr(gettext("An %s resource " 58957c478bd9Sstevel@tonic-gate "with the %s '%s' already exists."), 58967c478bd9Sstevel@tonic-gate rt_to_str(RT_IPD), pt_to_str(PT_DIR), 58977c478bd9Sstevel@tonic-gate in_progress_ipdtab.zone_fs_dir); 58987c478bd9Sstevel@tonic-gate saw_error = TRUE; 58997c478bd9Sstevel@tonic-gate return; 59007c478bd9Sstevel@tonic-gate } 59017c478bd9Sstevel@tonic-gate err = zonecfg_add_ipd(handle, &in_progress_ipdtab); 59027c478bd9Sstevel@tonic-gate } else { 59037c478bd9Sstevel@tonic-gate err = zonecfg_modify_ipd(handle, &old_ipdtab, 59047c478bd9Sstevel@tonic-gate &in_progress_ipdtab); 59057c478bd9Sstevel@tonic-gate } 59067c478bd9Sstevel@tonic-gate break; 59077c478bd9Sstevel@tonic-gate case RT_NET: 5908f4b3ec61Sdh /* 5909f4b3ec61Sdh * First make sure everything was filled in. 5910f4b3ec61Sdh * Since we don't know whether IP will be shared 5911f4b3ec61Sdh * or exclusive here, some checks are deferred until 5912f4b3ec61Sdh * the verify command. 5913f4b3ec61Sdh */ 5914087719fdSdp (void) end_check_reqd(in_progress_nwiftab.zone_nwif_physical, 5915087719fdSdp PT_PHYSICAL, &validation_failed); 5916087719fdSdp 5917087719fdSdp if (validation_failed) { 59187c478bd9Sstevel@tonic-gate saw_error = TRUE; 59197c478bd9Sstevel@tonic-gate return; 5920087719fdSdp } 59217c478bd9Sstevel@tonic-gate if (end_op == CMD_ADD) { 59227c478bd9Sstevel@tonic-gate /* Make sure there isn't already one like this. */ 59237c478bd9Sstevel@tonic-gate bzero(&tmp_nwiftab, sizeof (tmp_nwiftab)); 5924f4b3ec61Sdh (void) strlcpy(tmp_nwiftab.zone_nwif_physical, 5925f4b3ec61Sdh in_progress_nwiftab.zone_nwif_physical, 5926f4b3ec61Sdh sizeof (tmp_nwiftab.zone_nwif_physical)); 59277c478bd9Sstevel@tonic-gate (void) strlcpy(tmp_nwiftab.zone_nwif_address, 59287c478bd9Sstevel@tonic-gate in_progress_nwiftab.zone_nwif_address, 59297c478bd9Sstevel@tonic-gate sizeof (tmp_nwiftab.zone_nwif_address)); 59307c478bd9Sstevel@tonic-gate if (zonecfg_lookup_nwif(handle, &tmp_nwiftab) == Z_OK) { 5931f4b3ec61Sdh zerr(gettext("A %s resource with the %s '%s', " 5932f4b3ec61Sdh "and %s '%s' already exists."), 5933f4b3ec61Sdh rt_to_str(RT_NET), 5934f4b3ec61Sdh pt_to_str(PT_PHYSICAL), 5935f4b3ec61Sdh in_progress_nwiftab.zone_nwif_physical, 5936f4b3ec61Sdh pt_to_str(PT_ADDRESS), 59377c478bd9Sstevel@tonic-gate in_progress_nwiftab.zone_nwif_address); 59387c478bd9Sstevel@tonic-gate saw_error = TRUE; 59397c478bd9Sstevel@tonic-gate return; 59407c478bd9Sstevel@tonic-gate } 59417c478bd9Sstevel@tonic-gate err = zonecfg_add_nwif(handle, &in_progress_nwiftab); 59427c478bd9Sstevel@tonic-gate } else { 59437c478bd9Sstevel@tonic-gate err = zonecfg_modify_nwif(handle, &old_nwiftab, 59447c478bd9Sstevel@tonic-gate &in_progress_nwiftab); 59457c478bd9Sstevel@tonic-gate } 59467c478bd9Sstevel@tonic-gate break; 5947087719fdSdp 59487c478bd9Sstevel@tonic-gate case RT_DEVICE: 59497c478bd9Sstevel@tonic-gate /* First make sure everything was filled in. */ 5950087719fdSdp (void) end_check_reqd(in_progress_devtab.zone_dev_match, 5951087719fdSdp PT_MATCH, &validation_failed); 5952087719fdSdp 5953087719fdSdp if (validation_failed) { 59547c478bd9Sstevel@tonic-gate saw_error = TRUE; 59557c478bd9Sstevel@tonic-gate return; 5956087719fdSdp } 5957087719fdSdp 59587c478bd9Sstevel@tonic-gate if (end_op == CMD_ADD) { 59597c478bd9Sstevel@tonic-gate /* Make sure there isn't already one like this. */ 59607c478bd9Sstevel@tonic-gate (void) strlcpy(tmp_devtab.zone_dev_match, 59617c478bd9Sstevel@tonic-gate in_progress_devtab.zone_dev_match, 59627c478bd9Sstevel@tonic-gate sizeof (tmp_devtab.zone_dev_match)); 59637c478bd9Sstevel@tonic-gate if (zonecfg_lookup_dev(handle, &tmp_devtab) == Z_OK) { 59647c478bd9Sstevel@tonic-gate zerr(gettext("A %s resource with the %s '%s' " 59657c478bd9Sstevel@tonic-gate "already exists."), rt_to_str(RT_DEVICE), 59667c478bd9Sstevel@tonic-gate pt_to_str(PT_MATCH), 59677c478bd9Sstevel@tonic-gate in_progress_devtab.zone_dev_match); 59687c478bd9Sstevel@tonic-gate saw_error = TRUE; 59697c478bd9Sstevel@tonic-gate return; 59707c478bd9Sstevel@tonic-gate } 59717c478bd9Sstevel@tonic-gate err = zonecfg_add_dev(handle, &in_progress_devtab); 59727c478bd9Sstevel@tonic-gate } else { 59737c478bd9Sstevel@tonic-gate err = zonecfg_modify_dev(handle, &old_devtab, 59747c478bd9Sstevel@tonic-gate &in_progress_devtab); 59757c478bd9Sstevel@tonic-gate } 59767c478bd9Sstevel@tonic-gate break; 5977087719fdSdp 59787c478bd9Sstevel@tonic-gate case RT_RCTL: 59797c478bd9Sstevel@tonic-gate /* First make sure everything was filled in. */ 5980087719fdSdp (void) end_check_reqd(in_progress_rctltab.zone_rctl_name, 5981087719fdSdp PT_NAME, &validation_failed); 5982087719fdSdp 59837c478bd9Sstevel@tonic-gate if (in_progress_rctltab.zone_rctl_valptr == NULL) { 59847c478bd9Sstevel@tonic-gate zerr(gettext("no %s specified"), pt_to_str(PT_VALUE)); 59857c478bd9Sstevel@tonic-gate validation_failed = TRUE; 59867c478bd9Sstevel@tonic-gate } 5987087719fdSdp 5988087719fdSdp if (validation_failed) { 5989087719fdSdp saw_error = TRUE; 59907c478bd9Sstevel@tonic-gate return; 5991087719fdSdp } 5992087719fdSdp 59937c478bd9Sstevel@tonic-gate if (end_op == CMD_ADD) { 59947c478bd9Sstevel@tonic-gate /* Make sure there isn't already one like this. */ 59957c478bd9Sstevel@tonic-gate (void) strlcpy(tmp_rctltab.zone_rctl_name, 59967c478bd9Sstevel@tonic-gate in_progress_rctltab.zone_rctl_name, 59977c478bd9Sstevel@tonic-gate sizeof (tmp_rctltab.zone_rctl_name)); 59987c478bd9Sstevel@tonic-gate tmp_rctltab.zone_rctl_valptr = NULL; 59997c478bd9Sstevel@tonic-gate err = zonecfg_lookup_rctl(handle, &tmp_rctltab); 60007c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list( 60017c478bd9Sstevel@tonic-gate tmp_rctltab.zone_rctl_valptr); 60027c478bd9Sstevel@tonic-gate if (err == Z_OK) { 60037c478bd9Sstevel@tonic-gate zerr(gettext("A %s resource " 60047c478bd9Sstevel@tonic-gate "with the %s '%s' already exists."), 60057c478bd9Sstevel@tonic-gate rt_to_str(RT_RCTL), pt_to_str(PT_NAME), 60067c478bd9Sstevel@tonic-gate in_progress_rctltab.zone_rctl_name); 60077c478bd9Sstevel@tonic-gate saw_error = TRUE; 60087c478bd9Sstevel@tonic-gate return; 60097c478bd9Sstevel@tonic-gate } 60107c478bd9Sstevel@tonic-gate err = zonecfg_add_rctl(handle, &in_progress_rctltab); 60117c478bd9Sstevel@tonic-gate } else { 60127c478bd9Sstevel@tonic-gate err = zonecfg_modify_rctl(handle, &old_rctltab, 60137c478bd9Sstevel@tonic-gate &in_progress_rctltab); 60147c478bd9Sstevel@tonic-gate } 60157c478bd9Sstevel@tonic-gate if (err == Z_OK) { 60167c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list( 60177c478bd9Sstevel@tonic-gate in_progress_rctltab.zone_rctl_valptr); 60187c478bd9Sstevel@tonic-gate in_progress_rctltab.zone_rctl_valptr = NULL; 60197c478bd9Sstevel@tonic-gate } 60207c478bd9Sstevel@tonic-gate break; 6021087719fdSdp 60227c478bd9Sstevel@tonic-gate case RT_ATTR: 60237c478bd9Sstevel@tonic-gate /* First make sure everything was filled in. */ 6024087719fdSdp (void) end_check_reqd(in_progress_attrtab.zone_attr_name, 6025087719fdSdp PT_NAME, &validation_failed); 6026087719fdSdp (void) end_check_reqd(in_progress_attrtab.zone_attr_type, 6027087719fdSdp PT_TYPE, &validation_failed); 6028087719fdSdp (void) end_check_reqd(in_progress_attrtab.zone_attr_value, 6029087719fdSdp PT_VALUE, &validation_failed); 6030087719fdSdp 60317c478bd9Sstevel@tonic-gate if (validate_attr_name(in_progress_attrtab.zone_attr_name) != 6032087719fdSdp Z_OK) 60337c478bd9Sstevel@tonic-gate validation_failed = TRUE; 6034087719fdSdp 6035087719fdSdp if (validate_attr_type_val(&in_progress_attrtab) != Z_OK) 60367c478bd9Sstevel@tonic-gate validation_failed = TRUE; 6037087719fdSdp 6038087719fdSdp if (validation_failed) { 6039087719fdSdp saw_error = TRUE; 60407c478bd9Sstevel@tonic-gate return; 6041087719fdSdp } 60427c478bd9Sstevel@tonic-gate if (end_op == CMD_ADD) { 60437c478bd9Sstevel@tonic-gate /* Make sure there isn't already one like this. */ 60447c478bd9Sstevel@tonic-gate bzero(&tmp_attrtab, sizeof (tmp_attrtab)); 60457c478bd9Sstevel@tonic-gate (void) strlcpy(tmp_attrtab.zone_attr_name, 60467c478bd9Sstevel@tonic-gate in_progress_attrtab.zone_attr_name, 60477c478bd9Sstevel@tonic-gate sizeof (tmp_attrtab.zone_attr_name)); 60487c478bd9Sstevel@tonic-gate if (zonecfg_lookup_attr(handle, &tmp_attrtab) == Z_OK) { 60497c478bd9Sstevel@tonic-gate zerr(gettext("An %s resource " 60507c478bd9Sstevel@tonic-gate "with the %s '%s' already exists."), 60517c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR), pt_to_str(PT_NAME), 60527c478bd9Sstevel@tonic-gate in_progress_attrtab.zone_attr_name); 60537c478bd9Sstevel@tonic-gate saw_error = TRUE; 60547c478bd9Sstevel@tonic-gate return; 60557c478bd9Sstevel@tonic-gate } 60567c478bd9Sstevel@tonic-gate err = zonecfg_add_attr(handle, &in_progress_attrtab); 60577c478bd9Sstevel@tonic-gate } else { 60587c478bd9Sstevel@tonic-gate err = zonecfg_modify_attr(handle, &old_attrtab, 60597c478bd9Sstevel@tonic-gate &in_progress_attrtab); 60607c478bd9Sstevel@tonic-gate } 60617c478bd9Sstevel@tonic-gate break; 6062fa9e4066Sahrens case RT_DATASET: 6063fa9e4066Sahrens /* First make sure everything was filled in. */ 6064fa9e4066Sahrens if (strlen(in_progress_dstab.zone_dataset_name) == 0) { 6065fa9e4066Sahrens zerr("%s %s", pt_to_str(PT_NAME), 6066fa9e4066Sahrens gettext("not specified")); 6067fa9e4066Sahrens saw_error = TRUE; 6068fa9e4066Sahrens validation_failed = TRUE; 6069fa9e4066Sahrens } 6070fa9e4066Sahrens if (validation_failed) 6071fa9e4066Sahrens return; 6072fa9e4066Sahrens if (end_op == CMD_ADD) { 6073fa9e4066Sahrens /* Make sure there isn't already one like this. */ 6074fa9e4066Sahrens bzero(&tmp_dstab, sizeof (tmp_dstab)); 6075fa9e4066Sahrens (void) strlcpy(tmp_dstab.zone_dataset_name, 6076fa9e4066Sahrens in_progress_dstab.zone_dataset_name, 6077fa9e4066Sahrens sizeof (tmp_dstab.zone_dataset_name)); 6078fa9e4066Sahrens err = zonecfg_lookup_ds(handle, &tmp_dstab); 6079fa9e4066Sahrens if (err == Z_OK) { 6080fa9e4066Sahrens zerr(gettext("A %s resource " 6081fa9e4066Sahrens "with the %s '%s' already exists."), 6082fa9e4066Sahrens rt_to_str(RT_DATASET), pt_to_str(PT_NAME), 6083fa9e4066Sahrens in_progress_dstab.zone_dataset_name); 6084fa9e4066Sahrens saw_error = TRUE; 6085fa9e4066Sahrens return; 6086fa9e4066Sahrens } 6087fa9e4066Sahrens err = zonecfg_add_ds(handle, &in_progress_dstab); 6088fa9e4066Sahrens } else { 6089fa9e4066Sahrens err = zonecfg_modify_ds(handle, &old_dstab, 6090fa9e4066Sahrens &in_progress_dstab); 6091fa9e4066Sahrens } 6092fa9e4066Sahrens break; 60930209230bSgjelinek case RT_DCPU: 60940209230bSgjelinek /* Make sure everything was filled in. */ 60950209230bSgjelinek if (end_check_reqd(in_progress_psettab.zone_ncpu_min, 60960209230bSgjelinek PT_NCPUS, &validation_failed) != Z_OK) { 60970209230bSgjelinek saw_error = TRUE; 60980209230bSgjelinek return; 60990209230bSgjelinek } 61000209230bSgjelinek 61010209230bSgjelinek if (end_op == CMD_ADD) { 61020209230bSgjelinek err = zonecfg_add_pset(handle, &in_progress_psettab); 61030209230bSgjelinek } else { 61040209230bSgjelinek err = zonecfg_modify_pset(handle, &in_progress_psettab); 61050209230bSgjelinek } 61060209230bSgjelinek break; 6107c97ad5cdSakolb case RT_PCAP: 6108c97ad5cdSakolb /* Make sure everything was filled in. */ 6109c97ad5cdSakolb if (zonecfg_get_aliased_rctl(handle, ALIAS_CPUCAP, &proc_cap) 6110c97ad5cdSakolb != Z_OK) { 6111c97ad5cdSakolb zerr(gettext("%s not specified"), pt_to_str(PT_NCPUS)); 6112c97ad5cdSakolb saw_error = TRUE; 6113c97ad5cdSakolb validation_failed = TRUE; 6114c97ad5cdSakolb return; 6115c97ad5cdSakolb } 6116c97ad5cdSakolb err = Z_OK; 6117c97ad5cdSakolb break; 61180209230bSgjelinek case RT_MCAP: 61190209230bSgjelinek /* Make sure everything was filled in. */ 61200209230bSgjelinek res1 = strlen(in_progress_mcaptab.zone_physmem_cap) == 0 ? 61210209230bSgjelinek Z_ERR : Z_OK; 61220209230bSgjelinek res2 = zonecfg_get_aliased_rctl(handle, ALIAS_MAXSWAP, 61230209230bSgjelinek &swap_limit); 61240209230bSgjelinek res3 = zonecfg_get_aliased_rctl(handle, ALIAS_MAXLOCKEDMEM, 61250209230bSgjelinek &locked_limit); 61260209230bSgjelinek 61270209230bSgjelinek if (res1 != Z_OK && res2 != Z_OK && res3 != Z_OK) { 61280209230bSgjelinek zerr(gettext("No property was specified. One of %s, " 61290209230bSgjelinek "%s or %s is required."), pt_to_str(PT_PHYSICAL), 61300209230bSgjelinek pt_to_str(PT_SWAP), pt_to_str(PT_LOCKED)); 61310209230bSgjelinek saw_error = TRUE; 61320209230bSgjelinek return; 61330209230bSgjelinek } 61340209230bSgjelinek 61350209230bSgjelinek /* if phys & locked are both set, verify locked <= phys */ 61360209230bSgjelinek if (res1 == Z_OK && res3 == Z_OK) { 61370209230bSgjelinek uint64_t phys_limit; 61380209230bSgjelinek char *endp; 61390209230bSgjelinek 61400209230bSgjelinek phys_limit = strtoull( 61410209230bSgjelinek in_progress_mcaptab.zone_physmem_cap, &endp, 10); 61420209230bSgjelinek if (phys_limit < locked_limit) { 61430209230bSgjelinek zerr(gettext("The %s cap must be less than or " 61440209230bSgjelinek "equal to the %s cap."), 61450209230bSgjelinek pt_to_str(PT_LOCKED), 61460209230bSgjelinek pt_to_str(PT_PHYSICAL)); 61470209230bSgjelinek saw_error = TRUE; 61480209230bSgjelinek return; 61490209230bSgjelinek } 61500209230bSgjelinek } 61510209230bSgjelinek 61520209230bSgjelinek err = Z_OK; 61530209230bSgjelinek if (res1 == Z_OK) { 61540209230bSgjelinek /* 61550209230bSgjelinek * We could be ending from either an add operation 61560209230bSgjelinek * or a select operation. Since all of the properties 61570209230bSgjelinek * within this resource are optional, we always use 61580209230bSgjelinek * modify on the mcap entry. zonecfg_modify_mcap() 61590209230bSgjelinek * will handle both adding and modifying a memory cap. 61600209230bSgjelinek */ 61610209230bSgjelinek err = zonecfg_modify_mcap(handle, &in_progress_mcaptab); 61620209230bSgjelinek } else if (end_op == CMD_SELECT) { 61630209230bSgjelinek /* 61640209230bSgjelinek * If we're ending from a select and the physical 61650209230bSgjelinek * memory cap is empty then the user could have cleared 61660209230bSgjelinek * the physical cap value, so try to delete the entry. 61670209230bSgjelinek */ 61680209230bSgjelinek (void) zonecfg_delete_mcap(handle); 61690209230bSgjelinek } 61700209230bSgjelinek break; 61717c478bd9Sstevel@tonic-gate default: 61727c478bd9Sstevel@tonic-gate zone_perror(rt_to_str(resource_scope), Z_NO_RESOURCE_TYPE, 61737c478bd9Sstevel@tonic-gate TRUE); 61747c478bd9Sstevel@tonic-gate saw_error = TRUE; 61757c478bd9Sstevel@tonic-gate return; 61767c478bd9Sstevel@tonic-gate } 61777c478bd9Sstevel@tonic-gate 61787c478bd9Sstevel@tonic-gate if (err != Z_OK) { 61797c478bd9Sstevel@tonic-gate zone_perror(zone, err, TRUE); 61807c478bd9Sstevel@tonic-gate } else { 61817c478bd9Sstevel@tonic-gate need_to_commit = TRUE; 61827c478bd9Sstevel@tonic-gate global_scope = TRUE; 61837c478bd9Sstevel@tonic-gate end_op = -1; 61847c478bd9Sstevel@tonic-gate } 61857c478bd9Sstevel@tonic-gate } 61867c478bd9Sstevel@tonic-gate 61877c478bd9Sstevel@tonic-gate void 61887c478bd9Sstevel@tonic-gate commit_func(cmd_t *cmd) 61897c478bd9Sstevel@tonic-gate { 61907c478bd9Sstevel@tonic-gate int arg; 61917ec75eb8Sgjelinek bool arg_err = FALSE; 61927c478bd9Sstevel@tonic-gate 61937c478bd9Sstevel@tonic-gate optind = 0; 61947ec75eb8Sgjelinek while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?")) != EOF) { 61957c478bd9Sstevel@tonic-gate switch (arg) { 61967c478bd9Sstevel@tonic-gate case '?': 61977c478bd9Sstevel@tonic-gate longer_usage(CMD_COMMIT); 61987ec75eb8Sgjelinek arg_err = TRUE; 61997ec75eb8Sgjelinek break; 62007c478bd9Sstevel@tonic-gate default: 62017c478bd9Sstevel@tonic-gate short_usage(CMD_COMMIT); 62027ec75eb8Sgjelinek arg_err = TRUE; 62037ec75eb8Sgjelinek break; 62047c478bd9Sstevel@tonic-gate } 62057c478bd9Sstevel@tonic-gate } 62067ec75eb8Sgjelinek if (arg_err) 62077ec75eb8Sgjelinek return; 62087ec75eb8Sgjelinek 62097c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 62107c478bd9Sstevel@tonic-gate short_usage(CMD_COMMIT); 62117c478bd9Sstevel@tonic-gate return; 62127c478bd9Sstevel@tonic-gate } 62137c478bd9Sstevel@tonic-gate 62147c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_COMMIT)) 62157c478bd9Sstevel@tonic-gate return; 62167c478bd9Sstevel@tonic-gate 62177c478bd9Sstevel@tonic-gate assert(cmd != NULL); 62187c478bd9Sstevel@tonic-gate 62197c478bd9Sstevel@tonic-gate cmd->cmd_argc = 1; 62207c478bd9Sstevel@tonic-gate /* 62217c478bd9Sstevel@tonic-gate * cmd_arg normally comes from a strdup() in the lexer, and the 62227c478bd9Sstevel@tonic-gate * whole cmd structure and its (char *) attributes are freed at 62237c478bd9Sstevel@tonic-gate * the completion of each command, so the strdup() below is needed 62247c478bd9Sstevel@tonic-gate * to match this and prevent a core dump from trying to free() 62257c478bd9Sstevel@tonic-gate * something that can't be. 62267c478bd9Sstevel@tonic-gate */ 62277c478bd9Sstevel@tonic-gate if ((cmd->cmd_argv[0] = strdup("save")) == NULL) { 62287c478bd9Sstevel@tonic-gate zone_perror(zone, Z_NOMEM, TRUE); 62297c478bd9Sstevel@tonic-gate exit(Z_ERR); 62307c478bd9Sstevel@tonic-gate } 62317c478bd9Sstevel@tonic-gate cmd->cmd_argv[1] = NULL; 62327c478bd9Sstevel@tonic-gate verify_func(cmd); 62337c478bd9Sstevel@tonic-gate } 62347c478bd9Sstevel@tonic-gate 62357c478bd9Sstevel@tonic-gate void 62367c478bd9Sstevel@tonic-gate revert_func(cmd_t *cmd) 62377c478bd9Sstevel@tonic-gate { 62387c478bd9Sstevel@tonic-gate char line[128]; /* enough to ask a question */ 62397c478bd9Sstevel@tonic-gate bool force = FALSE; 62407ec75eb8Sgjelinek bool arg_err = FALSE; 62417c478bd9Sstevel@tonic-gate int err, arg, answer; 62427c478bd9Sstevel@tonic-gate 62437c478bd9Sstevel@tonic-gate optind = 0; 62447c478bd9Sstevel@tonic-gate while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?F")) != EOF) { 62457c478bd9Sstevel@tonic-gate switch (arg) { 62467c478bd9Sstevel@tonic-gate case '?': 62477c478bd9Sstevel@tonic-gate longer_usage(CMD_REVERT); 62487ec75eb8Sgjelinek arg_err = TRUE; 62497ec75eb8Sgjelinek break; 62507c478bd9Sstevel@tonic-gate case 'F': 62517c478bd9Sstevel@tonic-gate force = TRUE; 62527c478bd9Sstevel@tonic-gate break; 62537c478bd9Sstevel@tonic-gate default: 62547c478bd9Sstevel@tonic-gate short_usage(CMD_REVERT); 62557ec75eb8Sgjelinek arg_err = TRUE; 62567ec75eb8Sgjelinek break; 62577c478bd9Sstevel@tonic-gate } 62587c478bd9Sstevel@tonic-gate } 62597ec75eb8Sgjelinek if (arg_err) 62607ec75eb8Sgjelinek return; 62617ec75eb8Sgjelinek 62627c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 62637c478bd9Sstevel@tonic-gate short_usage(CMD_REVERT); 62647c478bd9Sstevel@tonic-gate return; 62657c478bd9Sstevel@tonic-gate } 62667c478bd9Sstevel@tonic-gate 62677c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_REVERT)) 62687c478bd9Sstevel@tonic-gate return; 62697c478bd9Sstevel@tonic-gate 62707c478bd9Sstevel@tonic-gate if (zonecfg_check_handle(handle) != Z_OK) { 62717c478bd9Sstevel@tonic-gate zerr(gettext("No changes to revert.")); 62727c478bd9Sstevel@tonic-gate saw_error = TRUE; 62737c478bd9Sstevel@tonic-gate return; 62747c478bd9Sstevel@tonic-gate } 62757c478bd9Sstevel@tonic-gate 62767c478bd9Sstevel@tonic-gate if (!force) { 62777c478bd9Sstevel@tonic-gate (void) snprintf(line, sizeof (line), 62787c478bd9Sstevel@tonic-gate gettext("Are you sure you want to revert")); 62797c478bd9Sstevel@tonic-gate if ((answer = ask_yesno(FALSE, line)) == -1) { 62807c478bd9Sstevel@tonic-gate zerr(gettext("Input not from terminal and -F not " 62817c478bd9Sstevel@tonic-gate "specified:\n%s command ignored, exiting."), 62827c478bd9Sstevel@tonic-gate cmd_to_str(CMD_REVERT)); 62837c478bd9Sstevel@tonic-gate exit(Z_ERR); 62847c478bd9Sstevel@tonic-gate } 62857c478bd9Sstevel@tonic-gate if (answer != 1) 62867c478bd9Sstevel@tonic-gate return; 62877c478bd9Sstevel@tonic-gate } 62887c478bd9Sstevel@tonic-gate 62897c478bd9Sstevel@tonic-gate /* 62907c478bd9Sstevel@tonic-gate * Time for a new handle: finish the old one off first 62917c478bd9Sstevel@tonic-gate * then get a new one properly to avoid leaks. 62927c478bd9Sstevel@tonic-gate */ 62937c478bd9Sstevel@tonic-gate zonecfg_fini_handle(handle); 62947c478bd9Sstevel@tonic-gate if ((handle = zonecfg_init_handle()) == NULL) { 62957c478bd9Sstevel@tonic-gate zone_perror(execname, Z_NOMEM, TRUE); 62967c478bd9Sstevel@tonic-gate exit(Z_ERR); 62977c478bd9Sstevel@tonic-gate } 6298087719fdSdp if ((err = zonecfg_get_handle(revert_zone, handle)) != Z_OK) { 62997c478bd9Sstevel@tonic-gate saw_error = TRUE; 63007c478bd9Sstevel@tonic-gate got_handle = FALSE; 63017c478bd9Sstevel@tonic-gate if (err == Z_NO_ZONE) 63027c478bd9Sstevel@tonic-gate zerr(gettext("%s: no such saved zone to revert to."), 6303087719fdSdp revert_zone); 63047c478bd9Sstevel@tonic-gate else 63057c478bd9Sstevel@tonic-gate zone_perror(zone, err, TRUE); 63067c478bd9Sstevel@tonic-gate } 6307087719fdSdp (void) strlcpy(zone, revert_zone, sizeof (zone)); 63087c478bd9Sstevel@tonic-gate } 63097c478bd9Sstevel@tonic-gate 63107c478bd9Sstevel@tonic-gate void 63117c478bd9Sstevel@tonic-gate help_func(cmd_t *cmd) 63127c478bd9Sstevel@tonic-gate { 63137c478bd9Sstevel@tonic-gate int i; 63147c478bd9Sstevel@tonic-gate 63157c478bd9Sstevel@tonic-gate assert(cmd != NULL); 63167c478bd9Sstevel@tonic-gate 63177c478bd9Sstevel@tonic-gate if (cmd->cmd_argc == 0) { 63187c478bd9Sstevel@tonic-gate usage(TRUE, global_scope ? HELP_SUBCMDS : HELP_RES_SCOPE); 63197c478bd9Sstevel@tonic-gate return; 63207c478bd9Sstevel@tonic-gate } 63217c478bd9Sstevel@tonic-gate if (strcmp(cmd->cmd_argv[0], "usage") == 0) { 63227c478bd9Sstevel@tonic-gate usage(TRUE, HELP_USAGE); 63237c478bd9Sstevel@tonic-gate return; 63247c478bd9Sstevel@tonic-gate } 63257c478bd9Sstevel@tonic-gate if (strcmp(cmd->cmd_argv[0], "commands") == 0) { 63267c478bd9Sstevel@tonic-gate usage(TRUE, HELP_SUBCMDS); 63277c478bd9Sstevel@tonic-gate return; 63287c478bd9Sstevel@tonic-gate } 63297c478bd9Sstevel@tonic-gate if (strcmp(cmd->cmd_argv[0], "syntax") == 0) { 63307c478bd9Sstevel@tonic-gate usage(TRUE, HELP_SYNTAX | HELP_RES_PROPS); 63317c478bd9Sstevel@tonic-gate return; 63327c478bd9Sstevel@tonic-gate } 63337c478bd9Sstevel@tonic-gate if (strcmp(cmd->cmd_argv[0], "-?") == 0) { 63347c478bd9Sstevel@tonic-gate longer_usage(CMD_HELP); 63357c478bd9Sstevel@tonic-gate return; 63367c478bd9Sstevel@tonic-gate } 63377c478bd9Sstevel@tonic-gate 63387c478bd9Sstevel@tonic-gate for (i = 0; i <= CMD_MAX; i++) { 63397c478bd9Sstevel@tonic-gate if (strcmp(cmd->cmd_argv[0], cmd_to_str(i)) == 0) { 63407c478bd9Sstevel@tonic-gate longer_usage(i); 63417c478bd9Sstevel@tonic-gate return; 63427c478bd9Sstevel@tonic-gate } 63437c478bd9Sstevel@tonic-gate } 63447c478bd9Sstevel@tonic-gate /* We do not use zerr() here because we do not want its extra \n. */ 63457c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("Unknown help subject %s. "), 63467c478bd9Sstevel@tonic-gate cmd->cmd_argv[0]); 63477c478bd9Sstevel@tonic-gate usage(FALSE, HELP_META); 63487c478bd9Sstevel@tonic-gate } 63497c478bd9Sstevel@tonic-gate 63507c478bd9Sstevel@tonic-gate static int 63517c478bd9Sstevel@tonic-gate string_to_yyin(char *string) 63527c478bd9Sstevel@tonic-gate { 63537c478bd9Sstevel@tonic-gate if ((yyin = tmpfile()) == NULL) { 63547c478bd9Sstevel@tonic-gate zone_perror(execname, Z_TEMP_FILE, TRUE); 63557c478bd9Sstevel@tonic-gate return (Z_ERR); 63567c478bd9Sstevel@tonic-gate } 63577c478bd9Sstevel@tonic-gate if (fwrite(string, strlen(string), 1, yyin) != 1) { 63587c478bd9Sstevel@tonic-gate zone_perror(execname, Z_TEMP_FILE, TRUE); 63597c478bd9Sstevel@tonic-gate return (Z_ERR); 63607c478bd9Sstevel@tonic-gate } 63617c478bd9Sstevel@tonic-gate if (fseek(yyin, 0, SEEK_SET) != 0) { 63627c478bd9Sstevel@tonic-gate zone_perror(execname, Z_TEMP_FILE, TRUE); 63637c478bd9Sstevel@tonic-gate return (Z_ERR); 63647c478bd9Sstevel@tonic-gate } 63657c478bd9Sstevel@tonic-gate return (Z_OK); 63667c478bd9Sstevel@tonic-gate } 63677c478bd9Sstevel@tonic-gate 63687c478bd9Sstevel@tonic-gate /* This is the back-end helper function for read_input() below. */ 63697c478bd9Sstevel@tonic-gate 63707c478bd9Sstevel@tonic-gate static int 63717c478bd9Sstevel@tonic-gate cleanup() 63727c478bd9Sstevel@tonic-gate { 63737c478bd9Sstevel@tonic-gate int answer; 63747c478bd9Sstevel@tonic-gate cmd_t *cmd; 63757c478bd9Sstevel@tonic-gate 63767c478bd9Sstevel@tonic-gate if (!interactive_mode && !cmd_file_mode) { 63777c478bd9Sstevel@tonic-gate /* 63787c478bd9Sstevel@tonic-gate * If we're not in interactive mode, and we're not in command 63797c478bd9Sstevel@tonic-gate * file mode, then we must be in commands-from-the-command-line 63807c478bd9Sstevel@tonic-gate * mode. As such, we can't loop back and ask for more input. 63817c478bd9Sstevel@tonic-gate * It was OK to prompt for such things as whether or not to 63827c478bd9Sstevel@tonic-gate * really delete a zone in the command handler called from 63837c478bd9Sstevel@tonic-gate * yyparse() above, but "really quit?" makes no sense in this 63847c478bd9Sstevel@tonic-gate * context. So disable prompting. 63857c478bd9Sstevel@tonic-gate */ 63867c478bd9Sstevel@tonic-gate ok_to_prompt = FALSE; 63877c478bd9Sstevel@tonic-gate } 63887c478bd9Sstevel@tonic-gate if (!global_scope) { 63897c478bd9Sstevel@tonic-gate if (!time_to_exit) { 63907c478bd9Sstevel@tonic-gate /* 63917c478bd9Sstevel@tonic-gate * Just print a simple error message in the -1 case, 63927c478bd9Sstevel@tonic-gate * since exit_func() already handles that case, and 63937c478bd9Sstevel@tonic-gate * EOF means we are finished anyway. 63947c478bd9Sstevel@tonic-gate */ 63957c478bd9Sstevel@tonic-gate answer = ask_yesno(FALSE, 63967c478bd9Sstevel@tonic-gate gettext("Resource incomplete; really quit")); 63977c478bd9Sstevel@tonic-gate if (answer == -1) { 63987c478bd9Sstevel@tonic-gate zerr(gettext("Resource incomplete.")); 63997c478bd9Sstevel@tonic-gate return (Z_ERR); 64007c478bd9Sstevel@tonic-gate } 64017c478bd9Sstevel@tonic-gate if (answer != 1) { 64027c478bd9Sstevel@tonic-gate yyin = stdin; 64037c478bd9Sstevel@tonic-gate return (Z_REPEAT); 64047c478bd9Sstevel@tonic-gate } 64057c478bd9Sstevel@tonic-gate } else { 64067c478bd9Sstevel@tonic-gate saw_error = TRUE; 64077c478bd9Sstevel@tonic-gate } 64087c478bd9Sstevel@tonic-gate } 64097c478bd9Sstevel@tonic-gate /* 64107c478bd9Sstevel@tonic-gate * Make sure we tried something and that the handle checks 64117c478bd9Sstevel@tonic-gate * out, or we would get a false error trying to commit. 64127c478bd9Sstevel@tonic-gate */ 64137c478bd9Sstevel@tonic-gate if (need_to_commit && zonecfg_check_handle(handle) == Z_OK) { 64147c478bd9Sstevel@tonic-gate if ((cmd = alloc_cmd()) == NULL) { 64157c478bd9Sstevel@tonic-gate zone_perror(zone, Z_NOMEM, TRUE); 64167c478bd9Sstevel@tonic-gate return (Z_ERR); 64177c478bd9Sstevel@tonic-gate } 64187c478bd9Sstevel@tonic-gate cmd->cmd_argc = 0; 64197c478bd9Sstevel@tonic-gate cmd->cmd_argv[0] = NULL; 64207c478bd9Sstevel@tonic-gate commit_func(cmd); 64217c478bd9Sstevel@tonic-gate free_cmd(cmd); 64227c478bd9Sstevel@tonic-gate /* 64237c478bd9Sstevel@tonic-gate * need_to_commit will get set back to FALSE if the 64247c478bd9Sstevel@tonic-gate * configuration is saved successfully. 64257c478bd9Sstevel@tonic-gate */ 64267c478bd9Sstevel@tonic-gate if (need_to_commit) { 64277c478bd9Sstevel@tonic-gate if (force_exit) { 64287c478bd9Sstevel@tonic-gate zerr(gettext("Configuration not saved.")); 64297c478bd9Sstevel@tonic-gate return (Z_ERR); 64307c478bd9Sstevel@tonic-gate } 64317c478bd9Sstevel@tonic-gate answer = ask_yesno(FALSE, 64327c478bd9Sstevel@tonic-gate gettext("Configuration not saved; really quit")); 64337c478bd9Sstevel@tonic-gate if (answer == -1) { 64347c478bd9Sstevel@tonic-gate zerr(gettext("Configuration not saved.")); 64357c478bd9Sstevel@tonic-gate return (Z_ERR); 64367c478bd9Sstevel@tonic-gate } 64377c478bd9Sstevel@tonic-gate if (answer != 1) { 64387c478bd9Sstevel@tonic-gate time_to_exit = FALSE; 64397c478bd9Sstevel@tonic-gate yyin = stdin; 64407c478bd9Sstevel@tonic-gate return (Z_REPEAT); 64417c478bd9Sstevel@tonic-gate } 64427c478bd9Sstevel@tonic-gate } 64437c478bd9Sstevel@tonic-gate } 64447c478bd9Sstevel@tonic-gate return ((need_to_commit || saw_error) ? Z_ERR : Z_OK); 64457c478bd9Sstevel@tonic-gate } 64467c478bd9Sstevel@tonic-gate 64477c478bd9Sstevel@tonic-gate /* 64487c478bd9Sstevel@tonic-gate * read_input() is the driver of this program. It is a wrapper around 64497c478bd9Sstevel@tonic-gate * yyparse(), printing appropriate prompts when needed, checking for 64507c478bd9Sstevel@tonic-gate * exit conditions and reacting appropriately [the latter in its cleanup() 64517c478bd9Sstevel@tonic-gate * helper function]. 64527c478bd9Sstevel@tonic-gate * 64537c478bd9Sstevel@tonic-gate * Like most zonecfg functions, it returns Z_OK or Z_ERR, *or* Z_REPEAT 64547c478bd9Sstevel@tonic-gate * so do_interactive() knows that we are not really done (i.e, we asked 64557c478bd9Sstevel@tonic-gate * the user if we should really quit and the user said no). 64567c478bd9Sstevel@tonic-gate */ 64577c478bd9Sstevel@tonic-gate static int 64587c478bd9Sstevel@tonic-gate read_input() 64597c478bd9Sstevel@tonic-gate { 64607c478bd9Sstevel@tonic-gate bool yyin_is_a_tty = isatty(fileno(yyin)); 64617c478bd9Sstevel@tonic-gate /* 64627c478bd9Sstevel@tonic-gate * The prompt is "e:z> " or "e:z:r> " where e is execname, z is zone 64637c478bd9Sstevel@tonic-gate * and r is resource_scope: 5 is for the two ":"s + "> " + terminator. 64647c478bd9Sstevel@tonic-gate */ 64657c478bd9Sstevel@tonic-gate char prompt[MAXPATHLEN + ZONENAME_MAX + MAX_RT_STRLEN + 5], *line; 64667c478bd9Sstevel@tonic-gate 64677c478bd9Sstevel@tonic-gate /* yyin should have been set to the appropriate (FILE *) if not stdin */ 64687c478bd9Sstevel@tonic-gate newline_terminated = TRUE; 64697c478bd9Sstevel@tonic-gate for (;;) { 64707c478bd9Sstevel@tonic-gate if (yyin_is_a_tty) { 64717c478bd9Sstevel@tonic-gate if (newline_terminated) { 64727c478bd9Sstevel@tonic-gate if (global_scope) 64737c478bd9Sstevel@tonic-gate (void) snprintf(prompt, sizeof (prompt), 64747c478bd9Sstevel@tonic-gate "%s:%s> ", execname, zone); 64757c478bd9Sstevel@tonic-gate else 64767c478bd9Sstevel@tonic-gate (void) snprintf(prompt, sizeof (prompt), 64777c478bd9Sstevel@tonic-gate "%s:%s:%s> ", execname, zone, 64787c478bd9Sstevel@tonic-gate rt_to_str(resource_scope)); 64797c478bd9Sstevel@tonic-gate } 64807c478bd9Sstevel@tonic-gate /* 64817c478bd9Sstevel@tonic-gate * If the user hits ^C then we want to catch it and 64827c478bd9Sstevel@tonic-gate * start over. If the user hits EOF then we want to 64837c478bd9Sstevel@tonic-gate * bail out. 64847c478bd9Sstevel@tonic-gate */ 64857c478bd9Sstevel@tonic-gate line = gl_get_line(gl, prompt, NULL, -1); 64867c478bd9Sstevel@tonic-gate if (gl_return_status(gl) == GLR_SIGNAL) { 64877c478bd9Sstevel@tonic-gate gl_abandon_line(gl); 64887c478bd9Sstevel@tonic-gate continue; 64897c478bd9Sstevel@tonic-gate } 64907c478bd9Sstevel@tonic-gate if (line == NULL) 64917c478bd9Sstevel@tonic-gate break; 64927c478bd9Sstevel@tonic-gate (void) string_to_yyin(line); 64937c478bd9Sstevel@tonic-gate while (!feof(yyin)) 64947c478bd9Sstevel@tonic-gate yyparse(); 64957c478bd9Sstevel@tonic-gate } else { 64967c478bd9Sstevel@tonic-gate yyparse(); 64977c478bd9Sstevel@tonic-gate } 64987c478bd9Sstevel@tonic-gate /* Bail out on an error in command file mode. */ 64997c478bd9Sstevel@tonic-gate if (saw_error && cmd_file_mode && !interactive_mode) 65007c478bd9Sstevel@tonic-gate time_to_exit = TRUE; 65017c478bd9Sstevel@tonic-gate if (time_to_exit || (!yyin_is_a_tty && feof(yyin))) 65027c478bd9Sstevel@tonic-gate break; 65037c478bd9Sstevel@tonic-gate } 65047c478bd9Sstevel@tonic-gate return (cleanup()); 65057c478bd9Sstevel@tonic-gate } 65067c478bd9Sstevel@tonic-gate 65077c478bd9Sstevel@tonic-gate /* 65087c478bd9Sstevel@tonic-gate * This function is used in the zonecfg-interactive-mode scenario: it just 65097c478bd9Sstevel@tonic-gate * calls read_input() until we are done. 65107c478bd9Sstevel@tonic-gate */ 65117c478bd9Sstevel@tonic-gate 65127c478bd9Sstevel@tonic-gate static int 65137c478bd9Sstevel@tonic-gate do_interactive(void) 65147c478bd9Sstevel@tonic-gate { 65157c478bd9Sstevel@tonic-gate int err; 65167c478bd9Sstevel@tonic-gate 65177c478bd9Sstevel@tonic-gate interactive_mode = TRUE; 65187c478bd9Sstevel@tonic-gate if (!read_only_mode) { 65197c478bd9Sstevel@tonic-gate /* 65207c478bd9Sstevel@tonic-gate * Try to set things up proactively in interactive mode, so 65217c478bd9Sstevel@tonic-gate * that if the zone in question does not exist yet, we can 65227c478bd9Sstevel@tonic-gate * provide the user with a clue. 65237c478bd9Sstevel@tonic-gate */ 65247c478bd9Sstevel@tonic-gate (void) initialize(FALSE); 65257c478bd9Sstevel@tonic-gate } 6526087719fdSdp do { 65277c478bd9Sstevel@tonic-gate err = read_input(); 6528087719fdSdp } while (err == Z_REPEAT); 65297c478bd9Sstevel@tonic-gate return (err); 65307c478bd9Sstevel@tonic-gate } 65317c478bd9Sstevel@tonic-gate 65327c478bd9Sstevel@tonic-gate /* 65337c478bd9Sstevel@tonic-gate * cmd_file is slightly more complicated, as it has to open the command file 65347c478bd9Sstevel@tonic-gate * and set yyin appropriately. Once that is done, though, it just calls 65357c478bd9Sstevel@tonic-gate * read_input(), and only once, since prompting is not possible. 65367c478bd9Sstevel@tonic-gate */ 65377c478bd9Sstevel@tonic-gate 65387c478bd9Sstevel@tonic-gate static int 65397c478bd9Sstevel@tonic-gate cmd_file(char *file) 65407c478bd9Sstevel@tonic-gate { 65417c478bd9Sstevel@tonic-gate FILE *infile; 65427c478bd9Sstevel@tonic-gate int err; 65437c478bd9Sstevel@tonic-gate struct stat statbuf; 65447c478bd9Sstevel@tonic-gate bool using_real_file = (strcmp(file, "-") != 0); 65457c478bd9Sstevel@tonic-gate 65467c478bd9Sstevel@tonic-gate if (using_real_file) { 65477c478bd9Sstevel@tonic-gate /* 65487c478bd9Sstevel@tonic-gate * zerr() prints a line number in cmd_file_mode, which we do 65497c478bd9Sstevel@tonic-gate * not want here, so temporarily unset it. 65507c478bd9Sstevel@tonic-gate */ 65517c478bd9Sstevel@tonic-gate cmd_file_mode = FALSE; 65527c478bd9Sstevel@tonic-gate if ((infile = fopen(file, "r")) == NULL) { 65537c478bd9Sstevel@tonic-gate zerr(gettext("could not open file %s: %s"), 65547c478bd9Sstevel@tonic-gate file, strerror(errno)); 65557c478bd9Sstevel@tonic-gate return (Z_ERR); 65567c478bd9Sstevel@tonic-gate } 65577c478bd9Sstevel@tonic-gate if ((err = fstat(fileno(infile), &statbuf)) != 0) { 65587c478bd9Sstevel@tonic-gate zerr(gettext("could not stat file %s: %s"), 65597c478bd9Sstevel@tonic-gate file, strerror(errno)); 65607c478bd9Sstevel@tonic-gate err = Z_ERR; 65617c478bd9Sstevel@tonic-gate goto done; 65627c478bd9Sstevel@tonic-gate } 65637c478bd9Sstevel@tonic-gate if (!S_ISREG(statbuf.st_mode)) { 65647c478bd9Sstevel@tonic-gate zerr(gettext("%s is not a regular file."), file); 65657c478bd9Sstevel@tonic-gate err = Z_ERR; 65667c478bd9Sstevel@tonic-gate goto done; 65677c478bd9Sstevel@tonic-gate } 65687c478bd9Sstevel@tonic-gate yyin = infile; 65697c478bd9Sstevel@tonic-gate cmd_file_mode = TRUE; 65707c478bd9Sstevel@tonic-gate ok_to_prompt = FALSE; 65717c478bd9Sstevel@tonic-gate } else { 65727c478bd9Sstevel@tonic-gate /* 65737c478bd9Sstevel@tonic-gate * "-f -" is essentially the same as interactive mode, 65747c478bd9Sstevel@tonic-gate * so treat it that way. 65757c478bd9Sstevel@tonic-gate */ 65767c478bd9Sstevel@tonic-gate interactive_mode = TRUE; 65777c478bd9Sstevel@tonic-gate } 65787c478bd9Sstevel@tonic-gate /* Z_REPEAT is for interactive mode; treat it like Z_ERR here. */ 65797c478bd9Sstevel@tonic-gate if ((err = read_input()) == Z_REPEAT) 65807c478bd9Sstevel@tonic-gate err = Z_ERR; 65817c478bd9Sstevel@tonic-gate done: 65827c478bd9Sstevel@tonic-gate if (using_real_file) 65837c478bd9Sstevel@tonic-gate (void) fclose(infile); 65847c478bd9Sstevel@tonic-gate return (err); 65857c478bd9Sstevel@tonic-gate } 65867c478bd9Sstevel@tonic-gate 65877c478bd9Sstevel@tonic-gate /* 65887c478bd9Sstevel@tonic-gate * Since yacc is based on reading from a (FILE *) whereas what we get from 65897c478bd9Sstevel@tonic-gate * the command line is in argv format, we need to convert when the user 65907c478bd9Sstevel@tonic-gate * gives us commands directly from the command line. That is done here by 65917c478bd9Sstevel@tonic-gate * concatenating the argv list into a space-separated string, writing it 65927c478bd9Sstevel@tonic-gate * to a temp file, and rewinding the file so yyin can be set to it. Then 65937c478bd9Sstevel@tonic-gate * we call read_input(), and only once, since prompting about whether to 65947c478bd9Sstevel@tonic-gate * continue or quit would make no sense in this context. 65957c478bd9Sstevel@tonic-gate */ 65967c478bd9Sstevel@tonic-gate 65977c478bd9Sstevel@tonic-gate static int 65987c478bd9Sstevel@tonic-gate one_command_at_a_time(int argc, char *argv[]) 65997c478bd9Sstevel@tonic-gate { 66007c478bd9Sstevel@tonic-gate char *command; 66017c478bd9Sstevel@tonic-gate size_t len = 2; /* terminal \n\0 */ 66027c478bd9Sstevel@tonic-gate int i, err; 66037c478bd9Sstevel@tonic-gate 66047c478bd9Sstevel@tonic-gate for (i = 0; i < argc; i++) 66057c478bd9Sstevel@tonic-gate len += strlen(argv[i]) + 1; 66067c478bd9Sstevel@tonic-gate if ((command = malloc(len)) == NULL) { 66077c478bd9Sstevel@tonic-gate zone_perror(execname, Z_NOMEM, TRUE); 66087c478bd9Sstevel@tonic-gate return (Z_ERR); 66097c478bd9Sstevel@tonic-gate } 66107c478bd9Sstevel@tonic-gate (void) strlcpy(command, argv[0], len); 66117c478bd9Sstevel@tonic-gate for (i = 1; i < argc; i++) { 66127c478bd9Sstevel@tonic-gate (void) strlcat(command, " ", len); 66137c478bd9Sstevel@tonic-gate (void) strlcat(command, argv[i], len); 66147c478bd9Sstevel@tonic-gate } 66157c478bd9Sstevel@tonic-gate (void) strlcat(command, "\n", len); 66167c478bd9Sstevel@tonic-gate err = string_to_yyin(command); 66177c478bd9Sstevel@tonic-gate free(command); 66187c478bd9Sstevel@tonic-gate if (err != Z_OK) 66197c478bd9Sstevel@tonic-gate return (err); 66207c478bd9Sstevel@tonic-gate while (!feof(yyin)) 66217c478bd9Sstevel@tonic-gate yyparse(); 66227c478bd9Sstevel@tonic-gate return (cleanup()); 66237c478bd9Sstevel@tonic-gate } 66247c478bd9Sstevel@tonic-gate 66257c478bd9Sstevel@tonic-gate static char * 66267c478bd9Sstevel@tonic-gate get_execbasename(char *execfullname) 66277c478bd9Sstevel@tonic-gate { 66287c478bd9Sstevel@tonic-gate char *last_slash, *execbasename; 66297c478bd9Sstevel@tonic-gate 66307c478bd9Sstevel@tonic-gate /* guard against '/' at end of command invocation */ 66317c478bd9Sstevel@tonic-gate for (;;) { 66327c478bd9Sstevel@tonic-gate last_slash = strrchr(execfullname, '/'); 66337c478bd9Sstevel@tonic-gate if (last_slash == NULL) { 66347c478bd9Sstevel@tonic-gate execbasename = execfullname; 66357c478bd9Sstevel@tonic-gate break; 66367c478bd9Sstevel@tonic-gate } else { 66377c478bd9Sstevel@tonic-gate execbasename = last_slash + 1; 66387c478bd9Sstevel@tonic-gate if (*execbasename == '\0') { 66397c478bd9Sstevel@tonic-gate *last_slash = '\0'; 66407c478bd9Sstevel@tonic-gate continue; 66417c478bd9Sstevel@tonic-gate } 66427c478bd9Sstevel@tonic-gate break; 66437c478bd9Sstevel@tonic-gate } 66447c478bd9Sstevel@tonic-gate } 66457c478bd9Sstevel@tonic-gate return (execbasename); 66467c478bd9Sstevel@tonic-gate } 66477c478bd9Sstevel@tonic-gate 66487c478bd9Sstevel@tonic-gate int 66497c478bd9Sstevel@tonic-gate main(int argc, char *argv[]) 66507c478bd9Sstevel@tonic-gate { 66517c478bd9Sstevel@tonic-gate int err, arg; 6652555afedfScarlsonj struct stat st; 66537c478bd9Sstevel@tonic-gate 66547c478bd9Sstevel@tonic-gate /* This must be before anything goes to stdout. */ 66557c478bd9Sstevel@tonic-gate setbuf(stdout, NULL); 66567c478bd9Sstevel@tonic-gate 66577c478bd9Sstevel@tonic-gate saw_error = FALSE; 66587c478bd9Sstevel@tonic-gate cmd_file_mode = FALSE; 66597c478bd9Sstevel@tonic-gate execname = get_execbasename(argv[0]); 66607c478bd9Sstevel@tonic-gate 66617c478bd9Sstevel@tonic-gate (void) setlocale(LC_ALL, ""); 66627c478bd9Sstevel@tonic-gate (void) textdomain(TEXT_DOMAIN); 66637c478bd9Sstevel@tonic-gate 66647c478bd9Sstevel@tonic-gate if (getzoneid() != GLOBAL_ZONEID) { 66657c478bd9Sstevel@tonic-gate zerr(gettext("%s can only be run from the global zone."), 66667c478bd9Sstevel@tonic-gate execname); 66677c478bd9Sstevel@tonic-gate exit(Z_ERR); 66687c478bd9Sstevel@tonic-gate } 66697c478bd9Sstevel@tonic-gate 66707c478bd9Sstevel@tonic-gate if (argc < 2) { 66717c478bd9Sstevel@tonic-gate usage(FALSE, HELP_USAGE | HELP_SUBCMDS); 66727c478bd9Sstevel@tonic-gate exit(Z_USAGE); 66737c478bd9Sstevel@tonic-gate } 66747c478bd9Sstevel@tonic-gate if (strcmp(argv[1], cmd_to_str(CMD_HELP)) == 0) { 66757c478bd9Sstevel@tonic-gate (void) one_command_at_a_time(argc - 1, &(argv[1])); 66767c478bd9Sstevel@tonic-gate exit(Z_OK); 66777c478bd9Sstevel@tonic-gate } 66787c478bd9Sstevel@tonic-gate 6679555afedfScarlsonj while ((arg = getopt(argc, argv, "?f:R:z:")) != EOF) { 66807c478bd9Sstevel@tonic-gate switch (arg) { 66817c478bd9Sstevel@tonic-gate case '?': 66827c478bd9Sstevel@tonic-gate if (optopt == '?') 66837c478bd9Sstevel@tonic-gate usage(TRUE, HELP_USAGE | HELP_SUBCMDS); 66847c478bd9Sstevel@tonic-gate else 66857c478bd9Sstevel@tonic-gate usage(FALSE, HELP_USAGE); 66867c478bd9Sstevel@tonic-gate exit(Z_USAGE); 66877c478bd9Sstevel@tonic-gate /* NOTREACHED */ 66887c478bd9Sstevel@tonic-gate case 'f': 66897c478bd9Sstevel@tonic-gate cmd_file_name = optarg; 66907c478bd9Sstevel@tonic-gate cmd_file_mode = TRUE; 66917c478bd9Sstevel@tonic-gate break; 6692555afedfScarlsonj case 'R': 6693555afedfScarlsonj if (*optarg != '/') { 6694555afedfScarlsonj zerr(gettext("root path must be absolute: %s"), 6695555afedfScarlsonj optarg); 6696555afedfScarlsonj exit(Z_USAGE); 6697555afedfScarlsonj } 6698555afedfScarlsonj if (stat(optarg, &st) == -1 || !S_ISDIR(st.st_mode)) { 6699555afedfScarlsonj zerr(gettext( 6700555afedfScarlsonj "root path must be a directory: %s"), 6701555afedfScarlsonj optarg); 6702555afedfScarlsonj exit(Z_USAGE); 6703555afedfScarlsonj } 6704555afedfScarlsonj zonecfg_set_root(optarg); 6705555afedfScarlsonj break; 67067c478bd9Sstevel@tonic-gate case 'z': 67070209230bSgjelinek if (strcmp(optarg, GLOBAL_ZONENAME) == 0) { 67080209230bSgjelinek global_zone = TRUE; 67090209230bSgjelinek } else if (zonecfg_validate_zonename(optarg) != Z_OK) { 6710087719fdSdp zone_perror(optarg, Z_BOGUS_ZONE_NAME, TRUE); 6711087719fdSdp usage(FALSE, HELP_SYNTAX); 6712087719fdSdp exit(Z_USAGE); 6713087719fdSdp } 6714087719fdSdp (void) strlcpy(zone, optarg, sizeof (zone)); 6715087719fdSdp (void) strlcpy(revert_zone, optarg, sizeof (zone)); 67167c478bd9Sstevel@tonic-gate break; 67177c478bd9Sstevel@tonic-gate default: 67187c478bd9Sstevel@tonic-gate usage(FALSE, HELP_USAGE); 67197c478bd9Sstevel@tonic-gate exit(Z_USAGE); 67207c478bd9Sstevel@tonic-gate } 67217c478bd9Sstevel@tonic-gate } 67227c478bd9Sstevel@tonic-gate 6723087719fdSdp if (optind > argc || strcmp(zone, "") == 0) { 67247c478bd9Sstevel@tonic-gate usage(FALSE, HELP_USAGE); 67257c478bd9Sstevel@tonic-gate exit(Z_USAGE); 67267c478bd9Sstevel@tonic-gate } 67277c478bd9Sstevel@tonic-gate 6728087719fdSdp if ((err = zonecfg_access(zone, W_OK)) == Z_OK) { 67297c478bd9Sstevel@tonic-gate read_only_mode = FALSE; 6730087719fdSdp } else if (err == Z_ACCES) { 67317c478bd9Sstevel@tonic-gate read_only_mode = TRUE; 67327c478bd9Sstevel@tonic-gate /* skip this message in one-off from command line mode */ 67337c478bd9Sstevel@tonic-gate if (optind == argc) 67347c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("WARNING: you do not " 67357c478bd9Sstevel@tonic-gate "have write access to this zone's configuration " 67367c478bd9Sstevel@tonic-gate "file;\ngoing into read-only mode.\n")); 6737087719fdSdp } else { 6738087719fdSdp fprintf(stderr, "%s: Could not access zone configuration " 6739087719fdSdp "store: %s\n", execname, zonecfg_strerror(err)); 6740087719fdSdp exit(Z_ERR); 67417c478bd9Sstevel@tonic-gate } 67427c478bd9Sstevel@tonic-gate 67437c478bd9Sstevel@tonic-gate if ((handle = zonecfg_init_handle()) == NULL) { 67447c478bd9Sstevel@tonic-gate zone_perror(execname, Z_NOMEM, TRUE); 67457c478bd9Sstevel@tonic-gate exit(Z_ERR); 67467c478bd9Sstevel@tonic-gate } 67477c478bd9Sstevel@tonic-gate 67487c478bd9Sstevel@tonic-gate /* 67497c478bd9Sstevel@tonic-gate * This may get set back to FALSE again in cmd_file() if cmd_file_name 67507c478bd9Sstevel@tonic-gate * is a "real" file as opposed to "-" (i.e. meaning use stdin). 67517c478bd9Sstevel@tonic-gate */ 67527c478bd9Sstevel@tonic-gate if (isatty(STDIN_FILENO)) 67537c478bd9Sstevel@tonic-gate ok_to_prompt = TRUE; 67547c478bd9Sstevel@tonic-gate if ((gl = new_GetLine(MAX_LINE_LEN, MAX_CMD_HIST)) == NULL) 67557c478bd9Sstevel@tonic-gate exit(Z_ERR); 67567c478bd9Sstevel@tonic-gate if (gl_customize_completion(gl, NULL, cmd_cpl_fn) != 0) 67577c478bd9Sstevel@tonic-gate exit(Z_ERR); 67587c478bd9Sstevel@tonic-gate (void) sigset(SIGINT, SIG_IGN); 67597c478bd9Sstevel@tonic-gate if (optind == argc) { 67607c478bd9Sstevel@tonic-gate if (!cmd_file_mode) 67617c478bd9Sstevel@tonic-gate err = do_interactive(); 67627c478bd9Sstevel@tonic-gate else 67637c478bd9Sstevel@tonic-gate err = cmd_file(cmd_file_name); 67647c478bd9Sstevel@tonic-gate } else { 67657c478bd9Sstevel@tonic-gate err = one_command_at_a_time(argc - optind, &(argv[optind])); 67667c478bd9Sstevel@tonic-gate } 67677c478bd9Sstevel@tonic-gate zonecfg_fini_handle(handle); 67689acbbeafSnn if (brand != NULL) 67699acbbeafSnn brand_close(brand); 67707c478bd9Sstevel@tonic-gate (void) del_GetLine(gl); 67717c478bd9Sstevel@tonic-gate return (err); 67727c478bd9Sstevel@tonic-gate } 6773