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*f4b3ec61Sdh * Copyright 2007 Sun Microsystems, Inc. All rights reserved. 247c478bd9Sstevel@tonic-gate * Use is subject to license terms. 257c478bd9Sstevel@tonic-gate */ 267c478bd9Sstevel@tonic-gate 277c478bd9Sstevel@tonic-gate #pragma ident "%Z%%M% %I% %E% SMI" 287c478bd9Sstevel@tonic-gate 297c478bd9Sstevel@tonic-gate /* 307c478bd9Sstevel@tonic-gate * 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", 181*f4b3ec61Sdh "ip-type", 1827c478bd9Sstevel@tonic-gate NULL 1837c478bd9Sstevel@tonic-gate }; 1847c478bd9Sstevel@tonic-gate 1857c478bd9Sstevel@tonic-gate /* These *must* match the order of the PT_ define's from zonecfg.h */ 1867c478bd9Sstevel@tonic-gate static char *prop_types[] = { 1877c478bd9Sstevel@tonic-gate "unknown", 188087719fdSdp "zonename", 1897c478bd9Sstevel@tonic-gate "zonepath", 1907c478bd9Sstevel@tonic-gate "autoboot", 1917c478bd9Sstevel@tonic-gate "pool", 1927c478bd9Sstevel@tonic-gate "dir", 1937c478bd9Sstevel@tonic-gate "special", 1947c478bd9Sstevel@tonic-gate "type", 1957c478bd9Sstevel@tonic-gate "options", 1967c478bd9Sstevel@tonic-gate "address", 1977c478bd9Sstevel@tonic-gate "physical", 1987c478bd9Sstevel@tonic-gate "name", 1997c478bd9Sstevel@tonic-gate "value", 2007c478bd9Sstevel@tonic-gate "match", 2017c478bd9Sstevel@tonic-gate "priv", 2027c478bd9Sstevel@tonic-gate "limit", 2037c478bd9Sstevel@tonic-gate "action", 2047c478bd9Sstevel@tonic-gate "raw", 205ffbafc53Scomay "limitpriv", 2063f2f09c1Sdp "bootargs", 2079acbbeafSnn "brand", 2080209230bSgjelinek "ncpus", 2090209230bSgjelinek "importance", 2100209230bSgjelinek "swap", 2110209230bSgjelinek "locked", 2120209230bSgjelinek ALIAS_SHARES, 2130209230bSgjelinek ALIAS_MAXLWPS, 2140209230bSgjelinek ALIAS_MAXSHMMEM, 2150209230bSgjelinek ALIAS_MAXSHMIDS, 2160209230bSgjelinek ALIAS_MAXMSGIDS, 2170209230bSgjelinek ALIAS_MAXSEMIDS, 2180209230bSgjelinek ALIAS_MAXLOCKEDMEM, 2190209230bSgjelinek ALIAS_MAXSWAP, 2200209230bSgjelinek "scheduling-class", 221*f4b3ec61Sdh "ip-type", 2227c478bd9Sstevel@tonic-gate NULL 2237c478bd9Sstevel@tonic-gate }; 2247c478bd9Sstevel@tonic-gate 225ffbafc53Scomay /* These *must* match the order of the PROP_VAL_ define's from zonecfg.h */ 2267c478bd9Sstevel@tonic-gate static char *prop_val_types[] = { 2277c478bd9Sstevel@tonic-gate "simple", 2287c478bd9Sstevel@tonic-gate "complex", 2297c478bd9Sstevel@tonic-gate "list", 2307c478bd9Sstevel@tonic-gate }; 2317c478bd9Sstevel@tonic-gate 2327c478bd9Sstevel@tonic-gate /* 2337c478bd9Sstevel@tonic-gate * The various _cmds[] lists below are for command tab-completion. 2347c478bd9Sstevel@tonic-gate */ 2357c478bd9Sstevel@tonic-gate 2367c478bd9Sstevel@tonic-gate /* 2377c478bd9Sstevel@tonic-gate * remove has a space afterwards because it has qualifiers; the other commands 2380209230bSgjelinek * that have qualifiers (add, select, etc.) don't need a space here because 2397c478bd9Sstevel@tonic-gate * they have their own _cmds[] lists below. 2407c478bd9Sstevel@tonic-gate */ 2417c478bd9Sstevel@tonic-gate static const char *global_scope_cmds[] = { 2427c478bd9Sstevel@tonic-gate "add", 2430209230bSgjelinek "clear", 2447c478bd9Sstevel@tonic-gate "commit", 2457c478bd9Sstevel@tonic-gate "create", 2467c478bd9Sstevel@tonic-gate "delete", 2477c478bd9Sstevel@tonic-gate "exit", 2487c478bd9Sstevel@tonic-gate "export", 2497c478bd9Sstevel@tonic-gate "help", 2507c478bd9Sstevel@tonic-gate "info", 2517c478bd9Sstevel@tonic-gate "remove ", 2527c478bd9Sstevel@tonic-gate "revert", 2537c478bd9Sstevel@tonic-gate "select", 2547c478bd9Sstevel@tonic-gate "set", 2557c478bd9Sstevel@tonic-gate "verify", 2567c478bd9Sstevel@tonic-gate NULL 2577c478bd9Sstevel@tonic-gate }; 2587c478bd9Sstevel@tonic-gate 2597c478bd9Sstevel@tonic-gate static const char *add_cmds[] = { 2607c478bd9Sstevel@tonic-gate "add fs", 2617c478bd9Sstevel@tonic-gate "add inherit-pkg-dir", 2627c478bd9Sstevel@tonic-gate "add net", 2637c478bd9Sstevel@tonic-gate "add device", 2647c478bd9Sstevel@tonic-gate "add rctl", 2657c478bd9Sstevel@tonic-gate "add attr", 266fa9e4066Sahrens "add dataset", 2670209230bSgjelinek "add dedicated-cpu", 2680209230bSgjelinek "add capped-memory", 2690209230bSgjelinek NULL 2700209230bSgjelinek }; 2710209230bSgjelinek 2720209230bSgjelinek static const char *clear_cmds[] = { 2730209230bSgjelinek "clear autoboot", 2740209230bSgjelinek "clear pool", 2750209230bSgjelinek "clear limitpriv", 2760209230bSgjelinek "clear bootargs", 2770209230bSgjelinek "clear scheduling-class", 278*f4b3ec61Sdh "clear ip-type", 2790209230bSgjelinek "clear " ALIAS_MAXLWPS, 2800209230bSgjelinek "clear " ALIAS_MAXSHMMEM, 2810209230bSgjelinek "clear " ALIAS_MAXSHMIDS, 2820209230bSgjelinek "clear " ALIAS_MAXMSGIDS, 2830209230bSgjelinek "clear " ALIAS_MAXSEMIDS, 2840209230bSgjelinek "clear " ALIAS_SHARES, 2857c478bd9Sstevel@tonic-gate NULL 2867c478bd9Sstevel@tonic-gate }; 2877c478bd9Sstevel@tonic-gate 2889e7542f4Sdp static const char *remove_cmds[] = { 2899e7542f4Sdp "remove fs ", 2909e7542f4Sdp "remove inherit-pkg-dir ", 2919e7542f4Sdp "remove net ", 2929e7542f4Sdp "remove device ", 2939e7542f4Sdp "remove rctl ", 2949e7542f4Sdp "remove attr ", 2959e7542f4Sdp "remove dataset ", 2960209230bSgjelinek "remove dedicated-cpu ", 2970209230bSgjelinek "remove capped-memory ", 2989e7542f4Sdp NULL 2999e7542f4Sdp }; 3009e7542f4Sdp 3017c478bd9Sstevel@tonic-gate static const char *select_cmds[] = { 302087719fdSdp "select fs ", 303087719fdSdp "select inherit-pkg-dir ", 304087719fdSdp "select net ", 305087719fdSdp "select device ", 306087719fdSdp "select rctl ", 307087719fdSdp "select attr ", 308fa9e4066Sahrens "select dataset ", 3090209230bSgjelinek "select dedicated-cpu", 3100209230bSgjelinek "select capped-memory", 3117c478bd9Sstevel@tonic-gate NULL 3127c478bd9Sstevel@tonic-gate }; 3137c478bd9Sstevel@tonic-gate 3147c478bd9Sstevel@tonic-gate static const char *set_cmds[] = { 315087719fdSdp "set zonename=", 316087719fdSdp "set zonepath=", 3179acbbeafSnn "set brand=", 318087719fdSdp "set autoboot=", 319087719fdSdp "set pool=", 320ffbafc53Scomay "set limitpriv=", 3213f2f09c1Sdp "set bootargs=", 3220209230bSgjelinek "set scheduling-class=", 323*f4b3ec61Sdh "set ip-type=", 3240209230bSgjelinek "set " ALIAS_MAXLWPS "=", 3250209230bSgjelinek "set " ALIAS_MAXSHMMEM "=", 3260209230bSgjelinek "set " ALIAS_MAXSHMIDS "=", 3270209230bSgjelinek "set " ALIAS_MAXMSGIDS "=", 3280209230bSgjelinek "set " ALIAS_MAXSEMIDS "=", 3290209230bSgjelinek "set " ALIAS_SHARES "=", 3307c478bd9Sstevel@tonic-gate NULL 3317c478bd9Sstevel@tonic-gate }; 3327c478bd9Sstevel@tonic-gate 3339e7542f4Sdp static const char *info_cmds[] = { 3349e7542f4Sdp "info fs ", 3359e7542f4Sdp "info inherit-pkg-dir ", 3369e7542f4Sdp "info net ", 3379e7542f4Sdp "info device ", 3389e7542f4Sdp "info rctl ", 3399e7542f4Sdp "info attr ", 3409e7542f4Sdp "info dataset ", 3410209230bSgjelinek "info capped-memory", 3420209230bSgjelinek "info dedicated-cpu", 3439e7542f4Sdp "info zonename", 3449e7542f4Sdp "info zonepath", 3459e7542f4Sdp "info autoboot", 3469e7542f4Sdp "info pool", 3479e7542f4Sdp "info limitpriv", 3489e7542f4Sdp "info bootargs", 3490209230bSgjelinek "info brand", 3500209230bSgjelinek "info scheduling-class", 351*f4b3ec61Sdh "info ip-type", 3520209230bSgjelinek "info max-lwps", 3530209230bSgjelinek "info max-shm-memory", 3540209230bSgjelinek "info max-shm-ids", 3550209230bSgjelinek "info max-msg-ids", 3560209230bSgjelinek "info max-sem-ids", 3570209230bSgjelinek "info cpu-shares", 3589e7542f4Sdp NULL 3599e7542f4Sdp }; 3609e7542f4Sdp 3617c478bd9Sstevel@tonic-gate static const char *fs_res_scope_cmds[] = { 3627c478bd9Sstevel@tonic-gate "add options ", 3637c478bd9Sstevel@tonic-gate "cancel", 3647c478bd9Sstevel@tonic-gate "end", 3657c478bd9Sstevel@tonic-gate "exit", 3667c478bd9Sstevel@tonic-gate "help", 3677c478bd9Sstevel@tonic-gate "info", 368ffbafc53Scomay "remove options ", 3697c478bd9Sstevel@tonic-gate "set dir=", 3707c478bd9Sstevel@tonic-gate "set raw=", 3717c478bd9Sstevel@tonic-gate "set special=", 3727c478bd9Sstevel@tonic-gate "set type=", 3730209230bSgjelinek "clear raw", 3747c478bd9Sstevel@tonic-gate NULL 3757c478bd9Sstevel@tonic-gate }; 3767c478bd9Sstevel@tonic-gate 3777c478bd9Sstevel@tonic-gate static const char *net_res_scope_cmds[] = { 3787c478bd9Sstevel@tonic-gate "cancel", 3797c478bd9Sstevel@tonic-gate "end", 3807c478bd9Sstevel@tonic-gate "exit", 3817c478bd9Sstevel@tonic-gate "help", 3827c478bd9Sstevel@tonic-gate "info", 3837c478bd9Sstevel@tonic-gate "set address=", 3847c478bd9Sstevel@tonic-gate "set physical=", 3857c478bd9Sstevel@tonic-gate NULL 3867c478bd9Sstevel@tonic-gate }; 3877c478bd9Sstevel@tonic-gate 3887c478bd9Sstevel@tonic-gate static const char *ipd_res_scope_cmds[] = { 3897c478bd9Sstevel@tonic-gate "cancel", 3907c478bd9Sstevel@tonic-gate "end", 3917c478bd9Sstevel@tonic-gate "exit", 3927c478bd9Sstevel@tonic-gate "help", 3937c478bd9Sstevel@tonic-gate "info", 3947c478bd9Sstevel@tonic-gate "set dir=", 3957c478bd9Sstevel@tonic-gate NULL 3967c478bd9Sstevel@tonic-gate }; 3977c478bd9Sstevel@tonic-gate 3987c478bd9Sstevel@tonic-gate static const char *device_res_scope_cmds[] = { 3997c478bd9Sstevel@tonic-gate "cancel", 4007c478bd9Sstevel@tonic-gate "end", 4017c478bd9Sstevel@tonic-gate "exit", 4027c478bd9Sstevel@tonic-gate "help", 4037c478bd9Sstevel@tonic-gate "info", 4047c478bd9Sstevel@tonic-gate "set match=", 4057c478bd9Sstevel@tonic-gate NULL 4067c478bd9Sstevel@tonic-gate }; 4077c478bd9Sstevel@tonic-gate 4087c478bd9Sstevel@tonic-gate static const char *attr_res_scope_cmds[] = { 4097c478bd9Sstevel@tonic-gate "cancel", 4107c478bd9Sstevel@tonic-gate "end", 4117c478bd9Sstevel@tonic-gate "exit", 4127c478bd9Sstevel@tonic-gate "help", 4137c478bd9Sstevel@tonic-gate "info", 4147c478bd9Sstevel@tonic-gate "set name=", 4157c478bd9Sstevel@tonic-gate "set type=", 4167c478bd9Sstevel@tonic-gate "set value=", 4177c478bd9Sstevel@tonic-gate NULL 4187c478bd9Sstevel@tonic-gate }; 4197c478bd9Sstevel@tonic-gate 4207c478bd9Sstevel@tonic-gate static const char *rctl_res_scope_cmds[] = { 4217c478bd9Sstevel@tonic-gate "add value ", 4227c478bd9Sstevel@tonic-gate "cancel", 4237c478bd9Sstevel@tonic-gate "end", 4247c478bd9Sstevel@tonic-gate "exit", 4257c478bd9Sstevel@tonic-gate "help", 4267c478bd9Sstevel@tonic-gate "info", 427ffbafc53Scomay "remove value ", 4287c478bd9Sstevel@tonic-gate "set name=", 4297c478bd9Sstevel@tonic-gate NULL 4307c478bd9Sstevel@tonic-gate }; 4317c478bd9Sstevel@tonic-gate 432fa9e4066Sahrens static const char *dataset_res_scope_cmds[] = { 433fa9e4066Sahrens "cancel", 434fa9e4066Sahrens "end", 435fa9e4066Sahrens "exit", 436fa9e4066Sahrens "help", 437fa9e4066Sahrens "info", 438fa9e4066Sahrens "set name=", 439fa9e4066Sahrens NULL 440fa9e4066Sahrens }; 441fa9e4066Sahrens 4420209230bSgjelinek static const char *pset_res_scope_cmds[] = { 4430209230bSgjelinek "cancel", 4440209230bSgjelinek "end", 4450209230bSgjelinek "exit", 4460209230bSgjelinek "help", 4470209230bSgjelinek "info", 4480209230bSgjelinek "set ncpus=", 4490209230bSgjelinek "set importance=", 4500209230bSgjelinek "clear importance", 4510209230bSgjelinek NULL 4520209230bSgjelinek }; 4530209230bSgjelinek 4540209230bSgjelinek static const char *mcap_res_scope_cmds[] = { 4550209230bSgjelinek "cancel", 4560209230bSgjelinek "end", 4570209230bSgjelinek "exit", 4580209230bSgjelinek "help", 4590209230bSgjelinek "info", 4600209230bSgjelinek "set physical=", 4610209230bSgjelinek "set swap=", 4620209230bSgjelinek "set locked=", 4630209230bSgjelinek "clear physical", 4640209230bSgjelinek "clear swap", 4650209230bSgjelinek "clear locked", 4660209230bSgjelinek NULL 4670209230bSgjelinek }; 4680209230bSgjelinek 4697c478bd9Sstevel@tonic-gate /* Global variables */ 4707c478bd9Sstevel@tonic-gate 4717c478bd9Sstevel@tonic-gate /* set early in main(), never modified thereafter, used all over the place */ 4727c478bd9Sstevel@tonic-gate static char *execname; 4737c478bd9Sstevel@tonic-gate 4747c478bd9Sstevel@tonic-gate /* set in main(), used all over the place */ 4757c478bd9Sstevel@tonic-gate static zone_dochandle_t handle; 4767c478bd9Sstevel@tonic-gate 4777c478bd9Sstevel@tonic-gate /* used all over the place */ 478087719fdSdp static char zone[ZONENAME_MAX]; 479087719fdSdp static char revert_zone[ZONENAME_MAX]; 4807c478bd9Sstevel@tonic-gate 4819acbbeafSnn /* global brand operations */ 482123807fbSedp static brand_handle_t brand; 4839acbbeafSnn 4847c478bd9Sstevel@tonic-gate /* set in modifying functions, checked in read_input() */ 4857c478bd9Sstevel@tonic-gate static bool need_to_commit = FALSE; 4867c478bd9Sstevel@tonic-gate bool saw_error; 4877c478bd9Sstevel@tonic-gate 4887c478bd9Sstevel@tonic-gate /* set in yacc parser, checked in read_input() */ 4897c478bd9Sstevel@tonic-gate bool newline_terminated; 4907c478bd9Sstevel@tonic-gate 4917c478bd9Sstevel@tonic-gate /* set in main(), checked in lex error handler */ 4927c478bd9Sstevel@tonic-gate bool cmd_file_mode; 4937c478bd9Sstevel@tonic-gate 4947c478bd9Sstevel@tonic-gate /* set in exit_func(), checked in read_input() */ 4957c478bd9Sstevel@tonic-gate static bool time_to_exit = FALSE, force_exit = FALSE; 4967c478bd9Sstevel@tonic-gate 4977c478bd9Sstevel@tonic-gate /* used in short_usage() and zerr() */ 4987c478bd9Sstevel@tonic-gate static char *cmd_file_name = NULL; 4997c478bd9Sstevel@tonic-gate 5007c478bd9Sstevel@tonic-gate /* checked in read_input() and other places */ 5017c478bd9Sstevel@tonic-gate static bool ok_to_prompt = FALSE; 5027c478bd9Sstevel@tonic-gate 5037c478bd9Sstevel@tonic-gate /* set and checked in initialize() */ 5047c478bd9Sstevel@tonic-gate static bool got_handle = FALSE; 5057c478bd9Sstevel@tonic-gate 5067c478bd9Sstevel@tonic-gate /* initialized in do_interactive(), checked in initialize() */ 5077c478bd9Sstevel@tonic-gate static bool interactive_mode; 5087c478bd9Sstevel@tonic-gate 5090209230bSgjelinek /* set if configuring the global zone */ 5100209230bSgjelinek static bool global_zone = FALSE; 5110209230bSgjelinek 5127c478bd9Sstevel@tonic-gate /* set in main(), checked in multiple places */ 5137c478bd9Sstevel@tonic-gate static bool read_only_mode; 5147c478bd9Sstevel@tonic-gate 5157c478bd9Sstevel@tonic-gate static bool global_scope = TRUE; /* scope is outer/global or inner/resource */ 5167c478bd9Sstevel@tonic-gate static int resource_scope; /* should be in the RT_ list from zonecfg.h */ 5177c478bd9Sstevel@tonic-gate static int end_op = -1; /* operation on end is either add or modify */ 5187c478bd9Sstevel@tonic-gate 5197c478bd9Sstevel@tonic-gate int num_prop_vals; /* for grammar */ 5207c478bd9Sstevel@tonic-gate 5217c478bd9Sstevel@tonic-gate /* 5227c478bd9Sstevel@tonic-gate * These are for keeping track of resources as they are specified as part of 5237c478bd9Sstevel@tonic-gate * the multi-step process. They should be initialized by add_resource() or 5247c478bd9Sstevel@tonic-gate * select_func() and filled in by add_property() or set_func(). 5257c478bd9Sstevel@tonic-gate */ 5267c478bd9Sstevel@tonic-gate static struct zone_fstab old_fstab, in_progress_fstab; 5277c478bd9Sstevel@tonic-gate static struct zone_fstab old_ipdtab, in_progress_ipdtab; 5287c478bd9Sstevel@tonic-gate static struct zone_nwiftab old_nwiftab, in_progress_nwiftab; 5297c478bd9Sstevel@tonic-gate static struct zone_devtab old_devtab, in_progress_devtab; 5307c478bd9Sstevel@tonic-gate static struct zone_rctltab old_rctltab, in_progress_rctltab; 5317c478bd9Sstevel@tonic-gate static struct zone_attrtab old_attrtab, in_progress_attrtab; 532fa9e4066Sahrens static struct zone_dstab old_dstab, in_progress_dstab; 5330209230bSgjelinek static struct zone_psettab old_psettab, in_progress_psettab; 5340209230bSgjelinek static struct zone_mcaptab old_mcaptab, in_progress_mcaptab; 5357c478bd9Sstevel@tonic-gate 5367c478bd9Sstevel@tonic-gate static GetLine *gl; /* The gl_get_line() resource object */ 5377c478bd9Sstevel@tonic-gate 5380209230bSgjelinek static void bytes_to_units(char *str, char *buf, int bufsize); 5390209230bSgjelinek 5407c478bd9Sstevel@tonic-gate /* Functions begin here */ 5417c478bd9Sstevel@tonic-gate 5427c478bd9Sstevel@tonic-gate static bool 5437c478bd9Sstevel@tonic-gate initial_match(const char *line1, const char *line2, int word_end) 5447c478bd9Sstevel@tonic-gate { 5457c478bd9Sstevel@tonic-gate if (word_end <= 0) 5467c478bd9Sstevel@tonic-gate return (TRUE); 5477c478bd9Sstevel@tonic-gate return (strncmp(line1, line2, word_end) == 0); 5487c478bd9Sstevel@tonic-gate } 5497c478bd9Sstevel@tonic-gate 5507c478bd9Sstevel@tonic-gate static int 5517c478bd9Sstevel@tonic-gate add_stuff(WordCompletion *cpl, const char *line1, const char **list, 5527c478bd9Sstevel@tonic-gate int word_end) 5537c478bd9Sstevel@tonic-gate { 5547c478bd9Sstevel@tonic-gate int i, err; 5557c478bd9Sstevel@tonic-gate 5567c478bd9Sstevel@tonic-gate for (i = 0; list[i] != NULL; i++) { 5577c478bd9Sstevel@tonic-gate if (initial_match(line1, list[i], word_end)) { 5587c478bd9Sstevel@tonic-gate err = cpl_add_completion(cpl, line1, 0, word_end, 5597c478bd9Sstevel@tonic-gate list[i] + word_end, "", ""); 5607c478bd9Sstevel@tonic-gate if (err != 0) 5617c478bd9Sstevel@tonic-gate return (err); 5627c478bd9Sstevel@tonic-gate } 5637c478bd9Sstevel@tonic-gate } 5647c478bd9Sstevel@tonic-gate return (0); 5657c478bd9Sstevel@tonic-gate } 5667c478bd9Sstevel@tonic-gate 5677c478bd9Sstevel@tonic-gate static 5687c478bd9Sstevel@tonic-gate /* ARGSUSED */ 5697c478bd9Sstevel@tonic-gate CPL_MATCH_FN(cmd_cpl_fn) 5707c478bd9Sstevel@tonic-gate { 5717c478bd9Sstevel@tonic-gate if (global_scope) { 5727c478bd9Sstevel@tonic-gate /* 5737c478bd9Sstevel@tonic-gate * The MAX/MIN tests below are to make sure we have at least 5747c478bd9Sstevel@tonic-gate * enough characters to distinguish from other prefixes (MAX) 5757c478bd9Sstevel@tonic-gate * but only check MIN(what we have, what we're checking). 5767c478bd9Sstevel@tonic-gate */ 5777c478bd9Sstevel@tonic-gate if (strncmp(line, "add ", MAX(MIN(word_end, 4), 1)) == 0) 5787c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, add_cmds, word_end)); 5790209230bSgjelinek if (strncmp(line, "clear ", MAX(MIN(word_end, 6), 2)) == 0) 5800209230bSgjelinek return (add_stuff(cpl, line, clear_cmds, word_end)); 5817c478bd9Sstevel@tonic-gate if (strncmp(line, "select ", MAX(MIN(word_end, 7), 3)) == 0) 5827c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, select_cmds, word_end)); 5837c478bd9Sstevel@tonic-gate if (strncmp(line, "set ", MAX(MIN(word_end, 4), 3)) == 0) 5847c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, set_cmds, word_end)); 5859e7542f4Sdp if (strncmp(line, "remove ", MAX(MIN(word_end, 7), 1)) == 0) 5869e7542f4Sdp return (add_stuff(cpl, line, remove_cmds, word_end)); 5879e7542f4Sdp if (strncmp(line, "info ", MAX(MIN(word_end, 5), 1)) == 0) 5889e7542f4Sdp return (add_stuff(cpl, line, info_cmds, word_end)); 5897c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, global_scope_cmds, word_end)); 5907c478bd9Sstevel@tonic-gate } 5917c478bd9Sstevel@tonic-gate switch (resource_scope) { 5927c478bd9Sstevel@tonic-gate case RT_FS: 5937c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, fs_res_scope_cmds, word_end)); 5947c478bd9Sstevel@tonic-gate case RT_IPD: 5957c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, ipd_res_scope_cmds, word_end)); 5967c478bd9Sstevel@tonic-gate case RT_NET: 5977c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, net_res_scope_cmds, word_end)); 5987c478bd9Sstevel@tonic-gate case RT_DEVICE: 5997c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, device_res_scope_cmds, word_end)); 6007c478bd9Sstevel@tonic-gate case RT_RCTL: 6017c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, rctl_res_scope_cmds, word_end)); 6027c478bd9Sstevel@tonic-gate case RT_ATTR: 6037c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, attr_res_scope_cmds, word_end)); 604fa9e4066Sahrens case RT_DATASET: 605fa9e4066Sahrens return (add_stuff(cpl, line, dataset_res_scope_cmds, word_end)); 6060209230bSgjelinek case RT_DCPU: 6070209230bSgjelinek return (add_stuff(cpl, line, pset_res_scope_cmds, word_end)); 6080209230bSgjelinek case RT_MCAP: 6090209230bSgjelinek return (add_stuff(cpl, line, mcap_res_scope_cmds, word_end)); 6107c478bd9Sstevel@tonic-gate } 6117c478bd9Sstevel@tonic-gate return (0); 6127c478bd9Sstevel@tonic-gate } 6137c478bd9Sstevel@tonic-gate 6147c478bd9Sstevel@tonic-gate /* 6157c478bd9Sstevel@tonic-gate * For the main CMD_func() functions below, several of them call getopt() 6167c478bd9Sstevel@tonic-gate * then check optind against argc to make sure an extra parameter was not 6177c478bd9Sstevel@tonic-gate * passed in. The reason this is not caught in the grammar is that the 6187c478bd9Sstevel@tonic-gate * grammar just checks for a miscellaneous TOKEN, which is *expected* to 6197c478bd9Sstevel@tonic-gate * be "-F" (for example), but could be anything. So (for example) this 6207c478bd9Sstevel@tonic-gate * check will prevent "create bogus". 6217c478bd9Sstevel@tonic-gate */ 6227c478bd9Sstevel@tonic-gate 6237c478bd9Sstevel@tonic-gate cmd_t * 6247c478bd9Sstevel@tonic-gate alloc_cmd(void) 6257c478bd9Sstevel@tonic-gate { 6267c478bd9Sstevel@tonic-gate return (calloc(1, sizeof (cmd_t))); 6277c478bd9Sstevel@tonic-gate } 6287c478bd9Sstevel@tonic-gate 6297c478bd9Sstevel@tonic-gate void 6307c478bd9Sstevel@tonic-gate free_cmd(cmd_t *cmd) 6317c478bd9Sstevel@tonic-gate { 6327c478bd9Sstevel@tonic-gate int i; 6337c478bd9Sstevel@tonic-gate 6347c478bd9Sstevel@tonic-gate for (i = 0; i < MAX_EQ_PROP_PAIRS; i++) 6357c478bd9Sstevel@tonic-gate if (cmd->cmd_property_ptr[i] != NULL) { 6367c478bd9Sstevel@tonic-gate property_value_ptr_t pp = cmd->cmd_property_ptr[i]; 6377c478bd9Sstevel@tonic-gate 6387c478bd9Sstevel@tonic-gate switch (pp->pv_type) { 6397c478bd9Sstevel@tonic-gate case PROP_VAL_SIMPLE: 6407c478bd9Sstevel@tonic-gate free(pp->pv_simple); 6417c478bd9Sstevel@tonic-gate break; 6427c478bd9Sstevel@tonic-gate case PROP_VAL_COMPLEX: 6437c478bd9Sstevel@tonic-gate free_complex(pp->pv_complex); 6447c478bd9Sstevel@tonic-gate break; 6457c478bd9Sstevel@tonic-gate case PROP_VAL_LIST: 6467c478bd9Sstevel@tonic-gate free_list(pp->pv_list); 6477c478bd9Sstevel@tonic-gate break; 6487c478bd9Sstevel@tonic-gate } 6497c478bd9Sstevel@tonic-gate } 6507c478bd9Sstevel@tonic-gate for (i = 0; i < cmd->cmd_argc; i++) 6517c478bd9Sstevel@tonic-gate free(cmd->cmd_argv[i]); 6527c478bd9Sstevel@tonic-gate free(cmd); 6537c478bd9Sstevel@tonic-gate } 6547c478bd9Sstevel@tonic-gate 6557c478bd9Sstevel@tonic-gate complex_property_ptr_t 6567c478bd9Sstevel@tonic-gate alloc_complex(void) 6577c478bd9Sstevel@tonic-gate { 6587c478bd9Sstevel@tonic-gate return (calloc(1, sizeof (complex_property_t))); 6597c478bd9Sstevel@tonic-gate } 6607c478bd9Sstevel@tonic-gate 6617c478bd9Sstevel@tonic-gate void 6627c478bd9Sstevel@tonic-gate free_complex(complex_property_ptr_t complex) 6637c478bd9Sstevel@tonic-gate { 6647c478bd9Sstevel@tonic-gate if (complex == NULL) 6657c478bd9Sstevel@tonic-gate return; 6667c478bd9Sstevel@tonic-gate free_complex(complex->cp_next); 6677c478bd9Sstevel@tonic-gate if (complex->cp_value != NULL) 6687c478bd9Sstevel@tonic-gate free(complex->cp_value); 6697c478bd9Sstevel@tonic-gate free(complex); 6707c478bd9Sstevel@tonic-gate } 6717c478bd9Sstevel@tonic-gate 6727c478bd9Sstevel@tonic-gate list_property_ptr_t 6737c478bd9Sstevel@tonic-gate alloc_list(void) 6747c478bd9Sstevel@tonic-gate { 6757c478bd9Sstevel@tonic-gate return (calloc(1, sizeof (list_property_t))); 6767c478bd9Sstevel@tonic-gate } 6777c478bd9Sstevel@tonic-gate 6787c478bd9Sstevel@tonic-gate void 6797c478bd9Sstevel@tonic-gate free_list(list_property_ptr_t list) 6807c478bd9Sstevel@tonic-gate { 6817c478bd9Sstevel@tonic-gate if (list == NULL) 6827c478bd9Sstevel@tonic-gate return; 6837c478bd9Sstevel@tonic-gate if (list->lp_simple != NULL) 6847c478bd9Sstevel@tonic-gate free(list->lp_simple); 6857c478bd9Sstevel@tonic-gate free_complex(list->lp_complex); 6867c478bd9Sstevel@tonic-gate free_list(list->lp_next); 6877c478bd9Sstevel@tonic-gate free(list); 6887c478bd9Sstevel@tonic-gate } 6897c478bd9Sstevel@tonic-gate 6907c478bd9Sstevel@tonic-gate void 6917c478bd9Sstevel@tonic-gate free_outer_list(list_property_ptr_t list) 6927c478bd9Sstevel@tonic-gate { 6937c478bd9Sstevel@tonic-gate if (list == NULL) 6947c478bd9Sstevel@tonic-gate return; 6957c478bd9Sstevel@tonic-gate free_outer_list(list->lp_next); 6967c478bd9Sstevel@tonic-gate free(list); 6977c478bd9Sstevel@tonic-gate } 6987c478bd9Sstevel@tonic-gate 6997c478bd9Sstevel@tonic-gate static struct zone_rctlvaltab * 7007c478bd9Sstevel@tonic-gate alloc_rctlvaltab(void) 7017c478bd9Sstevel@tonic-gate { 7027c478bd9Sstevel@tonic-gate return (calloc(1, sizeof (struct zone_rctlvaltab))); 7037c478bd9Sstevel@tonic-gate } 7047c478bd9Sstevel@tonic-gate 7057c478bd9Sstevel@tonic-gate static char * 7067c478bd9Sstevel@tonic-gate rt_to_str(int res_type) 7077c478bd9Sstevel@tonic-gate { 7087c478bd9Sstevel@tonic-gate assert(res_type >= RT_MIN && res_type <= RT_MAX); 7097c478bd9Sstevel@tonic-gate return (res_types[res_type]); 7107c478bd9Sstevel@tonic-gate } 7117c478bd9Sstevel@tonic-gate 7127c478bd9Sstevel@tonic-gate static char * 7137c478bd9Sstevel@tonic-gate pt_to_str(int prop_type) 7147c478bd9Sstevel@tonic-gate { 7157c478bd9Sstevel@tonic-gate assert(prop_type >= PT_MIN && prop_type <= PT_MAX); 7167c478bd9Sstevel@tonic-gate return (prop_types[prop_type]); 7177c478bd9Sstevel@tonic-gate } 7187c478bd9Sstevel@tonic-gate 7197c478bd9Sstevel@tonic-gate static char * 7207c478bd9Sstevel@tonic-gate pvt_to_str(int pv_type) 7217c478bd9Sstevel@tonic-gate { 7227c478bd9Sstevel@tonic-gate assert(pv_type >= PROP_VAL_MIN && pv_type <= PROP_VAL_MAX); 7237c478bd9Sstevel@tonic-gate return (prop_val_types[pv_type]); 7247c478bd9Sstevel@tonic-gate } 7257c478bd9Sstevel@tonic-gate 7267c478bd9Sstevel@tonic-gate static char * 7277c478bd9Sstevel@tonic-gate cmd_to_str(int cmd_num) 7287c478bd9Sstevel@tonic-gate { 7297c478bd9Sstevel@tonic-gate assert(cmd_num >= CMD_MIN && cmd_num <= CMD_MAX); 7307c478bd9Sstevel@tonic-gate return (helptab[cmd_num].cmd_name); 7317c478bd9Sstevel@tonic-gate } 7327c478bd9Sstevel@tonic-gate 7337c478bd9Sstevel@tonic-gate /* 7347c478bd9Sstevel@tonic-gate * This is a separate function rather than a set of define's because of the 7357c478bd9Sstevel@tonic-gate * gettext() wrapping. 7367c478bd9Sstevel@tonic-gate */ 7377c478bd9Sstevel@tonic-gate 7387c478bd9Sstevel@tonic-gate /* 7397c478bd9Sstevel@tonic-gate * TRANSLATION_NOTE 7407c478bd9Sstevel@tonic-gate * Each string below should have \t follow \n whenever needed; the 7417c478bd9Sstevel@tonic-gate * initial \t and the terminal \n will be provided by the calling function. 7427c478bd9Sstevel@tonic-gate */ 7437c478bd9Sstevel@tonic-gate 7447c478bd9Sstevel@tonic-gate static char * 7457c478bd9Sstevel@tonic-gate long_help(int cmd_num) 7467c478bd9Sstevel@tonic-gate { 7477c478bd9Sstevel@tonic-gate static char line[1024]; /* arbitrary large amount */ 7487c478bd9Sstevel@tonic-gate 7497c478bd9Sstevel@tonic-gate assert(cmd_num >= CMD_MIN && cmd_num <= CMD_MAX); 7507c478bd9Sstevel@tonic-gate switch (cmd_num) { 7517c478bd9Sstevel@tonic-gate case CMD_HELP: 7527c478bd9Sstevel@tonic-gate return (gettext("Prints help message.")); 7537c478bd9Sstevel@tonic-gate case CMD_CREATE: 7547c478bd9Sstevel@tonic-gate (void) snprintf(line, sizeof (line), 7557c478bd9Sstevel@tonic-gate gettext("Creates a configuration for the " 7567c478bd9Sstevel@tonic-gate "specified zone. %s should be\n\tused to " 7577c478bd9Sstevel@tonic-gate "begin configuring a new zone. If overwriting an " 7587c478bd9Sstevel@tonic-gate "existing\n\tconfiguration, the -F flag can be " 7597c478bd9Sstevel@tonic-gate "used to force the action. If\n\t-t template is " 7607c478bd9Sstevel@tonic-gate "given, creates a configuration identical to the\n" 7617c478bd9Sstevel@tonic-gate "\tspecified template, except that the zone name " 7629e518655Sgjelinek "is changed from\n\ttemplate to zonename. '%s -a' " 7639e518655Sgjelinek "creates a configuration from a\n\tdetached " 7649e518655Sgjelinek "zonepath. '%s -b' results in a blank " 7659e518655Sgjelinek "configuration.\n\t'%s' with no arguments applies " 7669e518655Sgjelinek "the Sun default settings."), 7677c478bd9Sstevel@tonic-gate cmd_to_str(CMD_CREATE), cmd_to_str(CMD_CREATE), 7689e518655Sgjelinek cmd_to_str(CMD_CREATE), cmd_to_str(CMD_CREATE)); 7697c478bd9Sstevel@tonic-gate return (line); 7707c478bd9Sstevel@tonic-gate case CMD_EXIT: 7717c478bd9Sstevel@tonic-gate return (gettext("Exits the program. The -F flag can " 7727c478bd9Sstevel@tonic-gate "be used to force the action.")); 7737c478bd9Sstevel@tonic-gate case CMD_EXPORT: 7747c478bd9Sstevel@tonic-gate return (gettext("Prints configuration to standard " 7757c478bd9Sstevel@tonic-gate "output, or to output-file if\n\tspecified, in " 7767c478bd9Sstevel@tonic-gate "a form suitable for use in a command-file.")); 7777c478bd9Sstevel@tonic-gate case CMD_ADD: 7787c478bd9Sstevel@tonic-gate return (gettext("Add specified resource to " 7797c478bd9Sstevel@tonic-gate "configuration.")); 7807c478bd9Sstevel@tonic-gate case CMD_DELETE: 7817c478bd9Sstevel@tonic-gate return (gettext("Deletes the specified zone. The -F " 7827c478bd9Sstevel@tonic-gate "flag can be used to force the\n\taction.")); 7837c478bd9Sstevel@tonic-gate case CMD_REMOVE: 7847c478bd9Sstevel@tonic-gate return (gettext("Remove specified resource from " 7850209230bSgjelinek "configuration. The -F flag can be used\n\tto " 7860209230bSgjelinek "force the action.")); 7877c478bd9Sstevel@tonic-gate case CMD_SELECT: 7887c478bd9Sstevel@tonic-gate (void) snprintf(line, sizeof (line), 7897c478bd9Sstevel@tonic-gate gettext("Selects a resource to modify. " 7907c478bd9Sstevel@tonic-gate "Resource modification is completed\n\twith the " 7917c478bd9Sstevel@tonic-gate "command \"%s\". The property name/value pairs " 7927c478bd9Sstevel@tonic-gate "must uniquely\n\tidentify a resource. Note that " 7937c478bd9Sstevel@tonic-gate "the curly braces ('{', '}') mean one\n\tor more " 7947c478bd9Sstevel@tonic-gate "of whatever is between them."), 7957c478bd9Sstevel@tonic-gate cmd_to_str(CMD_END)); 7967c478bd9Sstevel@tonic-gate return (line); 7977c478bd9Sstevel@tonic-gate case CMD_SET: 7987c478bd9Sstevel@tonic-gate return (gettext("Sets property values.")); 7990209230bSgjelinek case CMD_CLEAR: 8000209230bSgjelinek return (gettext("Clears property values.")); 8017c478bd9Sstevel@tonic-gate case CMD_INFO: 8027c478bd9Sstevel@tonic-gate return (gettext("Displays information about the " 8037c478bd9Sstevel@tonic-gate "current configuration. If resource\n\ttype is " 8047c478bd9Sstevel@tonic-gate "specified, displays only information about " 8057c478bd9Sstevel@tonic-gate "resources of\n\tthe relevant type. If resource " 8067c478bd9Sstevel@tonic-gate "id is specified, displays only\n\tinformation " 8077c478bd9Sstevel@tonic-gate "about that resource.")); 8087c478bd9Sstevel@tonic-gate case CMD_VERIFY: 8097c478bd9Sstevel@tonic-gate return (gettext("Verifies current configuration " 8107c478bd9Sstevel@tonic-gate "for correctness (some resource types\n\thave " 8117c478bd9Sstevel@tonic-gate "required properties).")); 8127c478bd9Sstevel@tonic-gate case CMD_COMMIT: 8137c478bd9Sstevel@tonic-gate (void) snprintf(line, sizeof (line), 8147c478bd9Sstevel@tonic-gate gettext("Commits current configuration. " 8157c478bd9Sstevel@tonic-gate "Configuration must be committed to\n\tbe used by " 8167c478bd9Sstevel@tonic-gate "%s. Until the configuration is committed, " 8177c478bd9Sstevel@tonic-gate "changes \n\tcan be removed with the %s " 8187c478bd9Sstevel@tonic-gate "command. This operation is\n\tattempted " 8197c478bd9Sstevel@tonic-gate "automatically upon completion of a %s " 8207c478bd9Sstevel@tonic-gate "session."), "zoneadm", cmd_to_str(CMD_REVERT), 8217c478bd9Sstevel@tonic-gate "zonecfg"); 8227c478bd9Sstevel@tonic-gate return (line); 8237c478bd9Sstevel@tonic-gate case CMD_REVERT: 8247c478bd9Sstevel@tonic-gate return (gettext("Reverts configuration back to the " 8257c478bd9Sstevel@tonic-gate "last committed state. The -F flag\n\tcan be " 8267c478bd9Sstevel@tonic-gate "used to force the action.")); 8277c478bd9Sstevel@tonic-gate case CMD_CANCEL: 8287c478bd9Sstevel@tonic-gate return (gettext("Cancels resource/property " 8297c478bd9Sstevel@tonic-gate "specification.")); 8307c478bd9Sstevel@tonic-gate case CMD_END: 8317c478bd9Sstevel@tonic-gate return (gettext("Ends resource/property " 8327c478bd9Sstevel@tonic-gate "specification.")); 8337c478bd9Sstevel@tonic-gate } 8347c478bd9Sstevel@tonic-gate /* NOTREACHED */ 8357e362f58Scomay return (NULL); 8367c478bd9Sstevel@tonic-gate } 8377c478bd9Sstevel@tonic-gate 8387c478bd9Sstevel@tonic-gate /* 8397c478bd9Sstevel@tonic-gate * Called with verbose TRUE when help is explicitly requested, FALSE for 8407c478bd9Sstevel@tonic-gate * unexpected errors. 8417c478bd9Sstevel@tonic-gate */ 8427c478bd9Sstevel@tonic-gate 8437c478bd9Sstevel@tonic-gate void 8447c478bd9Sstevel@tonic-gate usage(bool verbose, uint_t flags) 8457c478bd9Sstevel@tonic-gate { 8467c478bd9Sstevel@tonic-gate FILE *fp = verbose ? stdout : stderr, *newfp; 8477c478bd9Sstevel@tonic-gate bool need_to_close = FALSE; 8487c478bd9Sstevel@tonic-gate char *pager; 8497c478bd9Sstevel@tonic-gate int i; 8507c478bd9Sstevel@tonic-gate 8517c478bd9Sstevel@tonic-gate /* don't page error output */ 8527c478bd9Sstevel@tonic-gate if (verbose && interactive_mode) { 8537c478bd9Sstevel@tonic-gate if ((pager = getenv("PAGER")) == NULL) 8547c478bd9Sstevel@tonic-gate pager = PAGER; 8557c478bd9Sstevel@tonic-gate if ((newfp = popen(pager, "w")) != NULL) { 8567c478bd9Sstevel@tonic-gate need_to_close = TRUE; 8577c478bd9Sstevel@tonic-gate fp = newfp; 8587c478bd9Sstevel@tonic-gate } 8597c478bd9Sstevel@tonic-gate } 8607c478bd9Sstevel@tonic-gate if (flags & HELP_META) { 8617c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("More help is available for the " 8627c478bd9Sstevel@tonic-gate "following:\n")); 8637c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\n\tcommands ('%s commands')\n", 8647c478bd9Sstevel@tonic-gate cmd_to_str(CMD_HELP)); 8657c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\tsyntax ('%s syntax')\n", 8667c478bd9Sstevel@tonic-gate cmd_to_str(CMD_HELP)); 8677c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\tusage ('%s usage')\n\n", 8687c478bd9Sstevel@tonic-gate cmd_to_str(CMD_HELP)); 8697c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("You may also obtain help on any " 8707c478bd9Sstevel@tonic-gate "command by typing '%s <command-name>.'\n"), 8717c478bd9Sstevel@tonic-gate cmd_to_str(CMD_HELP)); 8727c478bd9Sstevel@tonic-gate } 8737c478bd9Sstevel@tonic-gate if (flags & HELP_RES_SCOPE) { 8747c478bd9Sstevel@tonic-gate switch (resource_scope) { 8757c478bd9Sstevel@tonic-gate case RT_FS: 8767c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("The '%s' resource scope is " 8777c478bd9Sstevel@tonic-gate "used to configure a file-system.\n"), 8787c478bd9Sstevel@tonic-gate rt_to_str(resource_scope)); 8797c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("Valid commands:\n")); 8807c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 8817c478bd9Sstevel@tonic-gate pt_to_str(PT_DIR), gettext("<path>")); 8827c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 8837c478bd9Sstevel@tonic-gate pt_to_str(PT_SPECIAL), gettext("<path>")); 8847c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 8857c478bd9Sstevel@tonic-gate pt_to_str(PT_RAW), gettext("<raw-device>")); 8867c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 8877c478bd9Sstevel@tonic-gate pt_to_str(PT_TYPE), gettext("<file-system type>")); 8887c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s %s\n", cmd_to_str(CMD_ADD), 8897c478bd9Sstevel@tonic-gate pt_to_str(PT_OPTIONS), 8907c478bd9Sstevel@tonic-gate gettext("<file-system options>")); 891ffbafc53Scomay (void) fprintf(fp, "\t%s %s %s\n", 892ffbafc53Scomay cmd_to_str(CMD_REMOVE), pt_to_str(PT_OPTIONS), 893ffbafc53Scomay gettext("<file-system options>")); 8947c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("Consult the file-system " 8957c478bd9Sstevel@tonic-gate "specific manual page, such as mount_ufs(1M), " 8967c478bd9Sstevel@tonic-gate "for\ndetails about file-system options. Note " 8977c478bd9Sstevel@tonic-gate "that any file-system options with an\nembedded " 8987c478bd9Sstevel@tonic-gate "'=' character must be enclosed in double quotes, " 8997c478bd9Sstevel@tonic-gate /*CSTYLED*/ 9007c478bd9Sstevel@tonic-gate "such as \"%s=5\".\n"), MNTOPT_RETRY); 9017c478bd9Sstevel@tonic-gate break; 9027c478bd9Sstevel@tonic-gate case RT_IPD: 9037c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("The '%s' resource scope is " 9047c478bd9Sstevel@tonic-gate "used to configure a directory\ninherited from the " 9057c478bd9Sstevel@tonic-gate "global zone into a non-global zone in read-only " 9067c478bd9Sstevel@tonic-gate "mode.\n"), rt_to_str(resource_scope)); 9077c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("Valid commands:\n")); 9087c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 9097c478bd9Sstevel@tonic-gate pt_to_str(PT_DIR), gettext("<path>")); 9107c478bd9Sstevel@tonic-gate break; 9117c478bd9Sstevel@tonic-gate case RT_NET: 9127c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("The '%s' resource scope is " 9137c478bd9Sstevel@tonic-gate "used to configure a network interface.\n"), 9147c478bd9Sstevel@tonic-gate rt_to_str(resource_scope)); 9157c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("Valid commands:\n")); 9167c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 9177c478bd9Sstevel@tonic-gate pt_to_str(PT_ADDRESS), gettext("<IP-address>")); 9187c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 9197c478bd9Sstevel@tonic-gate pt_to_str(PT_PHYSICAL), gettext("<interface>")); 9207c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("See ifconfig(1M) for " 9217c478bd9Sstevel@tonic-gate "details of the <interface> string.\n")); 922*f4b3ec61Sdh (void) fprintf(fp, gettext("%s %s is valid if the %s " 923*f4b3ec61Sdh "property is set to %s, otherwise it must not be " 924*f4b3ec61Sdh "set.\n"), 925*f4b3ec61Sdh cmd_to_str(CMD_SET), pt_to_str(PT_ADDRESS), 926*f4b3ec61Sdh pt_to_str(PT_IPTYPE), "shared"); 9277c478bd9Sstevel@tonic-gate break; 9287c478bd9Sstevel@tonic-gate case RT_DEVICE: 9297c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("The '%s' resource scope is " 9307c478bd9Sstevel@tonic-gate "used to configure a device node.\n"), 9317c478bd9Sstevel@tonic-gate rt_to_str(resource_scope)); 9327c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("Valid commands:\n")); 9337c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 9347c478bd9Sstevel@tonic-gate pt_to_str(PT_MATCH), gettext("<device-path>")); 9357c478bd9Sstevel@tonic-gate break; 9367c478bd9Sstevel@tonic-gate case RT_RCTL: 9377c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("The '%s' resource scope is " 9387c478bd9Sstevel@tonic-gate "used to configure a resource control.\n"), 9397c478bd9Sstevel@tonic-gate rt_to_str(resource_scope)); 9407c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("Valid commands:\n")); 9417c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 9427c478bd9Sstevel@tonic-gate pt_to_str(PT_NAME), gettext("<string>")); 9437c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s (%s=%s,%s=%s,%s=%s)\n", 9447c478bd9Sstevel@tonic-gate cmd_to_str(CMD_ADD), pt_to_str(PT_VALUE), 9457c478bd9Sstevel@tonic-gate pt_to_str(PT_PRIV), gettext("<priv-value>"), 9467c478bd9Sstevel@tonic-gate pt_to_str(PT_LIMIT), gettext("<number>"), 9477c478bd9Sstevel@tonic-gate pt_to_str(PT_ACTION), gettext("<action-value>")); 948ffbafc53Scomay (void) fprintf(fp, "\t%s %s (%s=%s,%s=%s,%s=%s)\n", 949ffbafc53Scomay cmd_to_str(CMD_REMOVE), pt_to_str(PT_VALUE), 950ffbafc53Scomay pt_to_str(PT_PRIV), gettext("<priv-value>"), 951ffbafc53Scomay pt_to_str(PT_LIMIT), gettext("<number>"), 952ffbafc53Scomay pt_to_str(PT_ACTION), gettext("<action-value>")); 9537c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s\n\t%s := privileged\n" 9547c478bd9Sstevel@tonic-gate "\t%s := none | deny\n", gettext("Where"), 9557c478bd9Sstevel@tonic-gate gettext("<priv-value>"), gettext("<action-value>")); 9567c478bd9Sstevel@tonic-gate break; 9577c478bd9Sstevel@tonic-gate case RT_ATTR: 9587c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("The '%s' resource scope is " 9597c478bd9Sstevel@tonic-gate "used to configure a generic attribute.\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("<name>")); 9647c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=boolean\n", 9657c478bd9Sstevel@tonic-gate cmd_to_str(CMD_SET), pt_to_str(PT_TYPE)); 9667c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=true | false\n", 9677c478bd9Sstevel@tonic-gate cmd_to_str(CMD_SET), pt_to_str(PT_VALUE)); 9687c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("or\n")); 9697c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=int\n", cmd_to_str(CMD_SET), 9707c478bd9Sstevel@tonic-gate pt_to_str(PT_TYPE)); 9717c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 9727c478bd9Sstevel@tonic-gate pt_to_str(PT_VALUE), gettext("<integer>")); 9737c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("or\n")); 9747c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=string\n", 9757c478bd9Sstevel@tonic-gate cmd_to_str(CMD_SET), pt_to_str(PT_TYPE)); 9767c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 9777c478bd9Sstevel@tonic-gate pt_to_str(PT_VALUE), gettext("<string>")); 9787c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("or\n")); 9797c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=uint\n", 9807c478bd9Sstevel@tonic-gate cmd_to_str(CMD_SET), pt_to_str(PT_TYPE)); 9817c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 9827c478bd9Sstevel@tonic-gate pt_to_str(PT_VALUE), gettext("<unsigned integer>")); 9837c478bd9Sstevel@tonic-gate break; 984fa9e4066Sahrens case RT_DATASET: 985fa9e4066Sahrens (void) fprintf(fp, gettext("The '%s' resource scope is " 986fa9e4066Sahrens "used to export ZFS datasets.\n"), 987fa9e4066Sahrens rt_to_str(resource_scope)); 988fa9e4066Sahrens (void) fprintf(fp, gettext("Valid commands:\n")); 989fa9e4066Sahrens (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 990fa9e4066Sahrens pt_to_str(PT_NAME), gettext("<name>")); 991fa9e4066Sahrens break; 9920209230bSgjelinek case RT_DCPU: 9930209230bSgjelinek (void) fprintf(fp, gettext("The '%s' resource scope " 9940209230bSgjelinek "configures the 'pools' facility to dedicate\na " 9950209230bSgjelinek "subset of the system's processors to this zone " 9960209230bSgjelinek "while it is running.\n"), 9970209230bSgjelinek rt_to_str(resource_scope)); 9980209230bSgjelinek (void) fprintf(fp, gettext("Valid commands:\n")); 9990209230bSgjelinek (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 10000209230bSgjelinek pt_to_str(PT_NCPUS), 10010209230bSgjelinek gettext("<unsigned integer | range>")); 10020209230bSgjelinek (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 10030209230bSgjelinek pt_to_str(PT_IMPORTANCE), 10040209230bSgjelinek gettext("<unsigned integer>")); 10050209230bSgjelinek break; 10060209230bSgjelinek case RT_MCAP: 10070209230bSgjelinek (void) fprintf(fp, gettext("The '%s' resource scope is " 10080209230bSgjelinek "used to set an upper limit (a cap) on the\n" 10090209230bSgjelinek "amount of physical memory, swap space and locked " 10100209230bSgjelinek "memory that can be used by\nthis zone.\n"), 10110209230bSgjelinek rt_to_str(resource_scope)); 10120209230bSgjelinek (void) fprintf(fp, gettext("Valid commands:\n")); 10130209230bSgjelinek (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 10140209230bSgjelinek pt_to_str(PT_PHYSICAL), 10150209230bSgjelinek gettext("<qualified unsigned decimal>")); 10160209230bSgjelinek (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 10170209230bSgjelinek pt_to_str(PT_SWAP), 10180209230bSgjelinek gettext("<qualified unsigned decimal>")); 10190209230bSgjelinek (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 10200209230bSgjelinek pt_to_str(PT_LOCKED), 10210209230bSgjelinek gettext("<qualified unsigned decimal>")); 10220209230bSgjelinek break; 10237c478bd9Sstevel@tonic-gate } 10247c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("And from any resource scope, you " 10257c478bd9Sstevel@tonic-gate "can:\n")); 10267c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t%s\n", cmd_to_str(CMD_END), 10277c478bd9Sstevel@tonic-gate gettext("(to conclude this operation)")); 10287c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t%s\n", cmd_to_str(CMD_CANCEL), 10297c478bd9Sstevel@tonic-gate gettext("(to cancel this operation)")); 10307c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t%s\n", cmd_to_str(CMD_EXIT), 10317c478bd9Sstevel@tonic-gate gettext("(to exit the zonecfg utility)")); 10327c478bd9Sstevel@tonic-gate } 10337c478bd9Sstevel@tonic-gate if (flags & HELP_USAGE) { 10347c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s:\t%s %s\n", gettext("usage"), 10357c478bd9Sstevel@tonic-gate execname, cmd_to_str(CMD_HELP)); 10367c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s -z <zone>\t\t\t(%s)\n", 10377c478bd9Sstevel@tonic-gate execname, gettext("interactive")); 10387c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s -z <zone> <command>\n", execname); 10397c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s -z <zone> -f <command-file>\n", 10407c478bd9Sstevel@tonic-gate execname); 10417c478bd9Sstevel@tonic-gate } 10427c478bd9Sstevel@tonic-gate if (flags & HELP_SUBCMDS) { 10437c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s:\n\n", gettext("Commands")); 10447c478bd9Sstevel@tonic-gate for (i = 0; i <= CMD_MAX; i++) { 10457c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s\n", helptab[i].short_usage); 10467c478bd9Sstevel@tonic-gate if (verbose) 10477c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\n\n", long_help(i)); 10487c478bd9Sstevel@tonic-gate } 10497c478bd9Sstevel@tonic-gate } 10507c478bd9Sstevel@tonic-gate if (flags & HELP_SYNTAX) { 10517c478bd9Sstevel@tonic-gate if (!verbose) 10527c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\n"); 10537c478bd9Sstevel@tonic-gate (void) fprintf(fp, "<zone> := [A-Za-z0-9][A-Za-z0-9_.-]*\n"); 10547c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("\t(except the reserved words " 10557c478bd9Sstevel@tonic-gate "'%s' and anything starting with '%s')\n"), "global", 10567c478bd9Sstevel@tonic-gate "SUNW"); 10577c478bd9Sstevel@tonic-gate (void) fprintf(fp, 10587c478bd9Sstevel@tonic-gate gettext("\tName must be less than %d characters.\n"), 10597c478bd9Sstevel@tonic-gate ZONENAME_MAX); 10607c478bd9Sstevel@tonic-gate if (verbose) 10617c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\n"); 10627c478bd9Sstevel@tonic-gate } 10637c478bd9Sstevel@tonic-gate if (flags & HELP_NETADDR) { 10647c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("\n<net-addr> :=")); 10657c478bd9Sstevel@tonic-gate (void) fprintf(fp, 10667c478bd9Sstevel@tonic-gate gettext("\t<IPv4-address>[/<IPv4-prefix-length>] |\n")); 10677c478bd9Sstevel@tonic-gate (void) fprintf(fp, 10687c478bd9Sstevel@tonic-gate gettext("\t\t<IPv6-address>/<IPv6-prefix-length> |\n")); 10697c478bd9Sstevel@tonic-gate (void) fprintf(fp, 10707c478bd9Sstevel@tonic-gate gettext("\t\t<hostname>[/<IPv4-prefix-length>]\n")); 10717c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("See inet(3SOCKET) for IPv4 and " 10727c478bd9Sstevel@tonic-gate "IPv6 address syntax.\n")); 10737c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("<IPv4-prefix-length> := [0-32]\n")); 10747c478bd9Sstevel@tonic-gate (void) fprintf(fp, 10757c478bd9Sstevel@tonic-gate gettext("<IPv6-prefix-length> := [0-128]\n")); 10767c478bd9Sstevel@tonic-gate (void) fprintf(fp, 10777c478bd9Sstevel@tonic-gate gettext("<hostname> := [A-Za-z0-9][A-Za-z0-9-.]*\n")); 10787c478bd9Sstevel@tonic-gate } 10797c478bd9Sstevel@tonic-gate if (flags & HELP_RESOURCES) { 10809e7542f4Sdp (void) fprintf(fp, "<%s> := %s | %s | %s | %s | %s | %s |\n\t" 10810209230bSgjelinek "%s | %s | %s\n\n", 10827c478bd9Sstevel@tonic-gate gettext("resource type"), rt_to_str(RT_FS), 10837c478bd9Sstevel@tonic-gate rt_to_str(RT_IPD), rt_to_str(RT_NET), rt_to_str(RT_DEVICE), 10849e7542f4Sdp rt_to_str(RT_RCTL), rt_to_str(RT_ATTR), 10850209230bSgjelinek rt_to_str(RT_DATASET), rt_to_str(RT_DCPU), 10860209230bSgjelinek rt_to_str(RT_MCAP)); 10877c478bd9Sstevel@tonic-gate } 10887c478bd9Sstevel@tonic-gate if (flags & HELP_PROPS) { 10897c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("For resource type ... there are " 10907c478bd9Sstevel@tonic-gate "property types ...:\n")); 1091087719fdSdp (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 1092087719fdSdp pt_to_str(PT_ZONENAME)); 10937c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 10947c478bd9Sstevel@tonic-gate pt_to_str(PT_ZONEPATH)); 10959acbbeafSnn (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 10969acbbeafSnn pt_to_str(PT_BRAND)); 10977c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 10987c478bd9Sstevel@tonic-gate pt_to_str(PT_AUTOBOOT)); 10993f2f09c1Sdp (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 11003f2f09c1Sdp pt_to_str(PT_BOOTARGS)); 11017c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 11027c478bd9Sstevel@tonic-gate pt_to_str(PT_POOL)); 1103ffbafc53Scomay (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 1104ffbafc53Scomay pt_to_str(PT_LIMITPRIV)); 11050209230bSgjelinek (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 11060209230bSgjelinek pt_to_str(PT_SCHED)); 1107*f4b3ec61Sdh (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 1108*f4b3ec61Sdh pt_to_str(PT_IPTYPE)); 11090209230bSgjelinek (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 11100209230bSgjelinek pt_to_str(PT_MAXLWPS)); 11110209230bSgjelinek (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 11120209230bSgjelinek pt_to_str(PT_MAXSHMMEM)); 11130209230bSgjelinek (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 11140209230bSgjelinek pt_to_str(PT_MAXSHMIDS)); 11150209230bSgjelinek (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 11160209230bSgjelinek pt_to_str(PT_MAXMSGIDS)); 11170209230bSgjelinek (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 11180209230bSgjelinek pt_to_str(PT_MAXSEMIDS)); 11190209230bSgjelinek (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 11200209230bSgjelinek pt_to_str(PT_SHARES)); 11217c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t\t%s, %s, %s, %s\n", rt_to_str(RT_FS), 11227c478bd9Sstevel@tonic-gate pt_to_str(PT_DIR), pt_to_str(PT_SPECIAL), 11237c478bd9Sstevel@tonic-gate pt_to_str(PT_RAW), pt_to_str(PT_TYPE), 11247c478bd9Sstevel@tonic-gate pt_to_str(PT_OPTIONS)); 11257c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t%s\n", rt_to_str(RT_IPD), 11267c478bd9Sstevel@tonic-gate pt_to_str(PT_DIR)); 11277c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t\t%s, %s\n", rt_to_str(RT_NET), 11287c478bd9Sstevel@tonic-gate pt_to_str(PT_ADDRESS), pt_to_str(PT_PHYSICAL)); 11297c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t\t%s\n", rt_to_str(RT_DEVICE), 11307c478bd9Sstevel@tonic-gate pt_to_str(PT_MATCH)); 11317c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t\t%s, %s\n", rt_to_str(RT_RCTL), 11327c478bd9Sstevel@tonic-gate pt_to_str(PT_NAME), pt_to_str(PT_VALUE)); 11337c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t\t%s, %s, %s\n", rt_to_str(RT_ATTR), 11347c478bd9Sstevel@tonic-gate pt_to_str(PT_NAME), pt_to_str(PT_TYPE), 11357c478bd9Sstevel@tonic-gate pt_to_str(PT_VALUE)); 1136fa9e4066Sahrens (void) fprintf(fp, "\t%s\t\t%s\n", rt_to_str(RT_DATASET), 1137fa9e4066Sahrens pt_to_str(PT_NAME)); 11380209230bSgjelinek (void) fprintf(fp, "\t%s\t%s, %s\n", rt_to_str(RT_DCPU), 11390209230bSgjelinek pt_to_str(PT_NCPUS), pt_to_str(PT_IMPORTANCE)); 11400209230bSgjelinek (void) fprintf(fp, "\t%s\t%s, %s, %s\n", rt_to_str(RT_MCAP), 11410209230bSgjelinek pt_to_str(PT_PHYSICAL), pt_to_str(PT_SWAP), 11420209230bSgjelinek pt_to_str(PT_LOCKED)); 11437c478bd9Sstevel@tonic-gate } 11447c478bd9Sstevel@tonic-gate if (need_to_close) 11457c478bd9Sstevel@tonic-gate (void) pclose(fp); 11467c478bd9Sstevel@tonic-gate } 11477c478bd9Sstevel@tonic-gate 11487c478bd9Sstevel@tonic-gate /* PRINTFLIKE1 */ 11497c478bd9Sstevel@tonic-gate static void 11507c478bd9Sstevel@tonic-gate zerr(const char *fmt, ...) 11517c478bd9Sstevel@tonic-gate { 11527c478bd9Sstevel@tonic-gate va_list alist; 11537c478bd9Sstevel@tonic-gate static int last_lineno; 11547c478bd9Sstevel@tonic-gate 11557c478bd9Sstevel@tonic-gate /* lex_lineno has already been incremented in the lexer; compensate */ 11567c478bd9Sstevel@tonic-gate if (cmd_file_mode && lex_lineno > last_lineno) { 11577c478bd9Sstevel@tonic-gate if (strcmp(cmd_file_name, "-") == 0) 11587c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("On line %d:\n"), 11597c478bd9Sstevel@tonic-gate lex_lineno - 1); 11607c478bd9Sstevel@tonic-gate else 11617c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("On line %d of %s:\n"), 11627c478bd9Sstevel@tonic-gate lex_lineno - 1, cmd_file_name); 11637c478bd9Sstevel@tonic-gate last_lineno = lex_lineno; 11647c478bd9Sstevel@tonic-gate } 11657c478bd9Sstevel@tonic-gate va_start(alist, fmt); 11667c478bd9Sstevel@tonic-gate (void) vfprintf(stderr, fmt, alist); 11677c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "\n"); 11687c478bd9Sstevel@tonic-gate va_end(alist); 11697c478bd9Sstevel@tonic-gate } 11707c478bd9Sstevel@tonic-gate 11717c478bd9Sstevel@tonic-gate static void 11727c478bd9Sstevel@tonic-gate zone_perror(char *prefix, int err, bool set_saw) 11737c478bd9Sstevel@tonic-gate { 11747c478bd9Sstevel@tonic-gate zerr("%s: %s", prefix, zonecfg_strerror(err)); 11757c478bd9Sstevel@tonic-gate if (set_saw) 11767c478bd9Sstevel@tonic-gate saw_error = TRUE; 11777c478bd9Sstevel@tonic-gate } 11787c478bd9Sstevel@tonic-gate 11797c478bd9Sstevel@tonic-gate /* 11807c478bd9Sstevel@tonic-gate * zone_perror() expects a single string, but for remove and select 11817c478bd9Sstevel@tonic-gate * we have both the command and the resource type, so this wrapper 11827c478bd9Sstevel@tonic-gate * function serves the same purpose in a slightly different way. 11837c478bd9Sstevel@tonic-gate */ 11847c478bd9Sstevel@tonic-gate 11857c478bd9Sstevel@tonic-gate static void 11867c478bd9Sstevel@tonic-gate z_cmd_rt_perror(int cmd_num, int res_num, int err, bool set_saw) 11877c478bd9Sstevel@tonic-gate { 11887c478bd9Sstevel@tonic-gate zerr("%s %s: %s", cmd_to_str(cmd_num), rt_to_str(res_num), 11897c478bd9Sstevel@tonic-gate zonecfg_strerror(err)); 11907c478bd9Sstevel@tonic-gate if (set_saw) 11917c478bd9Sstevel@tonic-gate saw_error = TRUE; 11927c478bd9Sstevel@tonic-gate } 11937c478bd9Sstevel@tonic-gate 11947c478bd9Sstevel@tonic-gate /* returns Z_OK if successful, Z_foo from <libzonecfg.h> otherwise */ 11957c478bd9Sstevel@tonic-gate static int 11967c478bd9Sstevel@tonic-gate initialize(bool handle_expected) 11977c478bd9Sstevel@tonic-gate { 11987c478bd9Sstevel@tonic-gate int err; 11999acbbeafSnn char brandname[MAXNAMELEN]; 12007c478bd9Sstevel@tonic-gate 12017c478bd9Sstevel@tonic-gate if (zonecfg_check_handle(handle) != Z_OK) { 12027c478bd9Sstevel@tonic-gate if ((err = zonecfg_get_handle(zone, handle)) == Z_OK) { 12037c478bd9Sstevel@tonic-gate got_handle = TRUE; 12049acbbeafSnn if (zonecfg_get_brand(handle, brandname, 12059acbbeafSnn sizeof (brandname)) != Z_OK) { 12069acbbeafSnn zerr("Zone %s is inconsistent: missing " 12079acbbeafSnn "brand attribute", zone); 12089acbbeafSnn exit(Z_ERR); 12099acbbeafSnn } 12109acbbeafSnn if ((brand = brand_open(brandname)) == NULL) { 12119acbbeafSnn zerr("Zone %s uses non-existent brand \"%s\"." 12129acbbeafSnn " Unable to continue", zone, brandname); 12139acbbeafSnn exit(Z_ERR); 12149acbbeafSnn } 12150209230bSgjelinek } else if (global_zone && err == Z_NO_ZONE && !got_handle && 12160209230bSgjelinek !read_only_mode) { 12170209230bSgjelinek /* 12180209230bSgjelinek * We implicitly create the global zone config if it 12190209230bSgjelinek * doesn't exist. 12200209230bSgjelinek */ 12210209230bSgjelinek zone_dochandle_t tmphandle; 12220209230bSgjelinek 12230209230bSgjelinek if ((tmphandle = zonecfg_init_handle()) == NULL) { 12240209230bSgjelinek zone_perror(execname, Z_NOMEM, TRUE); 12250209230bSgjelinek exit(Z_ERR); 12260209230bSgjelinek } 12270209230bSgjelinek 12280209230bSgjelinek err = zonecfg_get_template_handle("SUNWblank", zone, 12290209230bSgjelinek tmphandle); 12300209230bSgjelinek 12310209230bSgjelinek if (err != Z_OK) { 12320209230bSgjelinek zonecfg_fini_handle(tmphandle); 12330209230bSgjelinek zone_perror("SUNWblank", err, TRUE); 12340209230bSgjelinek return (err); 12350209230bSgjelinek } 12360209230bSgjelinek 12370209230bSgjelinek need_to_commit = TRUE; 12380209230bSgjelinek zonecfg_fini_handle(handle); 12390209230bSgjelinek handle = tmphandle; 12400209230bSgjelinek got_handle = TRUE; 12410209230bSgjelinek 12427c478bd9Sstevel@tonic-gate } else { 12437c478bd9Sstevel@tonic-gate zone_perror(zone, err, handle_expected || got_handle); 12447c478bd9Sstevel@tonic-gate if (err == Z_NO_ZONE && !got_handle && 12457c478bd9Sstevel@tonic-gate interactive_mode && !read_only_mode) 12467c478bd9Sstevel@tonic-gate (void) printf(gettext("Use '%s' to begin " 12477c478bd9Sstevel@tonic-gate "configuring a new zone.\n"), 12487c478bd9Sstevel@tonic-gate cmd_to_str(CMD_CREATE)); 12497c478bd9Sstevel@tonic-gate return (err); 12507c478bd9Sstevel@tonic-gate } 12517c478bd9Sstevel@tonic-gate } 12527c478bd9Sstevel@tonic-gate return (Z_OK); 12537c478bd9Sstevel@tonic-gate } 12547c478bd9Sstevel@tonic-gate 1255087719fdSdp static bool 1256087719fdSdp state_atleast(zone_state_t state) 1257087719fdSdp { 1258087719fdSdp zone_state_t state_num; 1259087719fdSdp int err; 1260087719fdSdp 1261087719fdSdp if ((err = zone_get_state(zone, &state_num)) != Z_OK) { 1262087719fdSdp /* all states are greater than "non-existent" */ 1263087719fdSdp if (err == Z_NO_ZONE) 1264087719fdSdp return (B_FALSE); 1265087719fdSdp zerr(gettext("Unexpectedly failed to determine state " 1266087719fdSdp "of zone %s: %s"), zone, zonecfg_strerror(err)); 1267087719fdSdp exit(Z_ERR); 1268087719fdSdp } 1269087719fdSdp return (state_num >= state); 1270087719fdSdp } 1271087719fdSdp 12727c478bd9Sstevel@tonic-gate /* 12737c478bd9Sstevel@tonic-gate * short_usage() is for bad syntax: getopt() issues, too many arguments, etc. 12747c478bd9Sstevel@tonic-gate */ 12757c478bd9Sstevel@tonic-gate 12767c478bd9Sstevel@tonic-gate void 12777c478bd9Sstevel@tonic-gate short_usage(int command) 12787c478bd9Sstevel@tonic-gate { 12797c478bd9Sstevel@tonic-gate /* lex_lineno has already been incremented in the lexer; compensate */ 12807c478bd9Sstevel@tonic-gate if (cmd_file_mode) { 12817c478bd9Sstevel@tonic-gate if (strcmp(cmd_file_name, "-") == 0) 12827c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 12837c478bd9Sstevel@tonic-gate gettext("syntax error on line %d\n"), 12847c478bd9Sstevel@tonic-gate lex_lineno - 1); 12857c478bd9Sstevel@tonic-gate else 12867c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 12877c478bd9Sstevel@tonic-gate gettext("syntax error on line %d of %s\n"), 12887c478bd9Sstevel@tonic-gate lex_lineno - 1, cmd_file_name); 12897c478bd9Sstevel@tonic-gate } 12907c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "%s:\n%s\n", gettext("usage"), 12917c478bd9Sstevel@tonic-gate helptab[command].short_usage); 12927c478bd9Sstevel@tonic-gate saw_error = TRUE; 12937c478bd9Sstevel@tonic-gate } 12947c478bd9Sstevel@tonic-gate 12957c478bd9Sstevel@tonic-gate /* 12967c478bd9Sstevel@tonic-gate * long_usage() is for bad semantics: e.g., wrong property type for a given 12977c478bd9Sstevel@tonic-gate * resource type. It is also used by longer_usage() below. 12987c478bd9Sstevel@tonic-gate */ 12997c478bd9Sstevel@tonic-gate 13007c478bd9Sstevel@tonic-gate void 13017c478bd9Sstevel@tonic-gate long_usage(uint_t cmd_num, bool set_saw) 13027c478bd9Sstevel@tonic-gate { 13037c478bd9Sstevel@tonic-gate (void) fprintf(set_saw ? stderr : stdout, "%s:\n%s\n", gettext("usage"), 13047c478bd9Sstevel@tonic-gate helptab[cmd_num].short_usage); 13057c478bd9Sstevel@tonic-gate (void) fprintf(set_saw ? stderr : stdout, "\t%s\n", long_help(cmd_num)); 13067c478bd9Sstevel@tonic-gate if (set_saw) 13077c478bd9Sstevel@tonic-gate saw_error = TRUE; 13087c478bd9Sstevel@tonic-gate } 13097c478bd9Sstevel@tonic-gate 13107c478bd9Sstevel@tonic-gate /* 13117c478bd9Sstevel@tonic-gate * longer_usage() is for 'help foo' and 'foo -?': call long_usage() and also 13127c478bd9Sstevel@tonic-gate * any extra usage() flags as appropriate for whatever command. 13137c478bd9Sstevel@tonic-gate */ 13147c478bd9Sstevel@tonic-gate 13157c478bd9Sstevel@tonic-gate void 13167c478bd9Sstevel@tonic-gate longer_usage(uint_t cmd_num) 13177c478bd9Sstevel@tonic-gate { 13187c478bd9Sstevel@tonic-gate long_usage(cmd_num, FALSE); 13197c478bd9Sstevel@tonic-gate if (helptab[cmd_num].flags != 0) { 13207c478bd9Sstevel@tonic-gate (void) printf("\n"); 13217c478bd9Sstevel@tonic-gate usage(TRUE, helptab[cmd_num].flags); 13227c478bd9Sstevel@tonic-gate } 13237c478bd9Sstevel@tonic-gate } 13247c478bd9Sstevel@tonic-gate 13257c478bd9Sstevel@tonic-gate /* 13267c478bd9Sstevel@tonic-gate * scope_usage() is simply used when a command is called from the wrong scope. 13277c478bd9Sstevel@tonic-gate */ 13287c478bd9Sstevel@tonic-gate 13297c478bd9Sstevel@tonic-gate static void 13307c478bd9Sstevel@tonic-gate scope_usage(uint_t cmd_num) 13317c478bd9Sstevel@tonic-gate { 13327c478bd9Sstevel@tonic-gate zerr(gettext("The %s command only makes sense in the %s scope."), 13337c478bd9Sstevel@tonic-gate cmd_to_str(cmd_num), 13347c478bd9Sstevel@tonic-gate global_scope ? gettext("resource") : gettext("global")); 13357c478bd9Sstevel@tonic-gate saw_error = TRUE; 13367c478bd9Sstevel@tonic-gate } 13377c478bd9Sstevel@tonic-gate 13387c478bd9Sstevel@tonic-gate /* 13397c478bd9Sstevel@tonic-gate * On input, TRUE => yes, FALSE => no. 13407c478bd9Sstevel@tonic-gate * On return, TRUE => 1, FALSE => no, could not ask => -1. 13417c478bd9Sstevel@tonic-gate */ 13427c478bd9Sstevel@tonic-gate 13437c478bd9Sstevel@tonic-gate static int 13447c478bd9Sstevel@tonic-gate ask_yesno(bool default_answer, const char *question) 13457c478bd9Sstevel@tonic-gate { 13467c478bd9Sstevel@tonic-gate char line[64]; /* should be enough to answer yes or no */ 13477c478bd9Sstevel@tonic-gate 13487c478bd9Sstevel@tonic-gate if (!ok_to_prompt) { 13497c478bd9Sstevel@tonic-gate saw_error = TRUE; 13507c478bd9Sstevel@tonic-gate return (-1); 13517c478bd9Sstevel@tonic-gate } 13527c478bd9Sstevel@tonic-gate for (;;) { 1353087719fdSdp if (printf("%s (%s)? ", question, 1354087719fdSdp default_answer ? "[y]/n" : "y/[n]") < 0) 1355087719fdSdp return (-1); 1356087719fdSdp if (fgets(line, sizeof (line), stdin) == NULL) 1357087719fdSdp return (-1); 1358087719fdSdp 1359087719fdSdp if (line[0] == '\n') 13607c478bd9Sstevel@tonic-gate return (default_answer ? 1 : 0); 13617c478bd9Sstevel@tonic-gate if (tolower(line[0]) == 'y') 13627c478bd9Sstevel@tonic-gate return (1); 13637c478bd9Sstevel@tonic-gate if (tolower(line[0]) == 'n') 13647c478bd9Sstevel@tonic-gate return (0); 13657c478bd9Sstevel@tonic-gate } 13667c478bd9Sstevel@tonic-gate } 13677c478bd9Sstevel@tonic-gate 13687c478bd9Sstevel@tonic-gate /* 13697c478bd9Sstevel@tonic-gate * Prints warning if zone already exists. 13707c478bd9Sstevel@tonic-gate * In interactive mode, prompts if we should continue anyway and returns Z_OK 13717c478bd9Sstevel@tonic-gate * if so, Z_ERR if not. In non-interactive mode, exits with Z_ERR. 13727c478bd9Sstevel@tonic-gate * 13737c478bd9Sstevel@tonic-gate * Note that if a zone exists and its state is >= INSTALLED, an error message 13747c478bd9Sstevel@tonic-gate * will be printed and this function will return Z_ERR regardless of mode. 13757c478bd9Sstevel@tonic-gate */ 13767c478bd9Sstevel@tonic-gate 13777c478bd9Sstevel@tonic-gate static int 13787c478bd9Sstevel@tonic-gate check_if_zone_already_exists(bool force) 13797c478bd9Sstevel@tonic-gate { 13807c478bd9Sstevel@tonic-gate char line[ZONENAME_MAX + 128]; /* enough to ask a question */ 13817c478bd9Sstevel@tonic-gate zone_dochandle_t tmphandle; 13827c478bd9Sstevel@tonic-gate int res, answer; 13837c478bd9Sstevel@tonic-gate 13847c478bd9Sstevel@tonic-gate if ((tmphandle = zonecfg_init_handle()) == NULL) { 13857c478bd9Sstevel@tonic-gate zone_perror(execname, Z_NOMEM, TRUE); 13867c478bd9Sstevel@tonic-gate exit(Z_ERR); 13877c478bd9Sstevel@tonic-gate } 13887c478bd9Sstevel@tonic-gate res = zonecfg_get_handle(zone, tmphandle); 13897c478bd9Sstevel@tonic-gate zonecfg_fini_handle(tmphandle); 1390087719fdSdp if (res != Z_OK) 13917c478bd9Sstevel@tonic-gate return (Z_OK); 1392087719fdSdp 1393087719fdSdp if (state_atleast(ZONE_STATE_INSTALLED)) { 13947c478bd9Sstevel@tonic-gate zerr(gettext("Zone %s already installed; %s not allowed."), 13957c478bd9Sstevel@tonic-gate zone, cmd_to_str(CMD_CREATE)); 13967c478bd9Sstevel@tonic-gate return (Z_ERR); 13977c478bd9Sstevel@tonic-gate } 13987c478bd9Sstevel@tonic-gate 13997c478bd9Sstevel@tonic-gate if (force) { 14007c478bd9Sstevel@tonic-gate (void) printf(gettext("Zone %s already exists; overwriting.\n"), 14017c478bd9Sstevel@tonic-gate zone); 14027c478bd9Sstevel@tonic-gate return (Z_OK); 14037c478bd9Sstevel@tonic-gate } 14047c478bd9Sstevel@tonic-gate (void) snprintf(line, sizeof (line), 14057c478bd9Sstevel@tonic-gate gettext("Zone %s already exists; %s anyway"), zone, 14067c478bd9Sstevel@tonic-gate cmd_to_str(CMD_CREATE)); 14077c478bd9Sstevel@tonic-gate if ((answer = ask_yesno(FALSE, line)) == -1) { 14087c478bd9Sstevel@tonic-gate zerr(gettext("Zone exists, input not from terminal and -F not " 14097c478bd9Sstevel@tonic-gate "specified:\n%s command ignored, exiting."), 14107c478bd9Sstevel@tonic-gate cmd_to_str(CMD_CREATE)); 14117c478bd9Sstevel@tonic-gate exit(Z_ERR); 14127c478bd9Sstevel@tonic-gate } 14137c478bd9Sstevel@tonic-gate return (answer == 1 ? Z_OK : Z_ERR); 14147c478bd9Sstevel@tonic-gate } 14157c478bd9Sstevel@tonic-gate 14167c478bd9Sstevel@tonic-gate static bool 14177c478bd9Sstevel@tonic-gate zone_is_read_only(int cmd_num) 14187c478bd9Sstevel@tonic-gate { 14197c478bd9Sstevel@tonic-gate if (strncmp(zone, "SUNW", 4) == 0) { 14207c478bd9Sstevel@tonic-gate zerr(gettext("%s: zones beginning with SUNW are read-only."), 14217c478bd9Sstevel@tonic-gate zone); 14227c478bd9Sstevel@tonic-gate saw_error = TRUE; 14237c478bd9Sstevel@tonic-gate return (TRUE); 14247c478bd9Sstevel@tonic-gate } 14257c478bd9Sstevel@tonic-gate if (read_only_mode) { 14267c478bd9Sstevel@tonic-gate zerr(gettext("%s: cannot %s in read-only mode."), zone, 14277c478bd9Sstevel@tonic-gate cmd_to_str(cmd_num)); 14287c478bd9Sstevel@tonic-gate saw_error = TRUE; 14297c478bd9Sstevel@tonic-gate return (TRUE); 14307c478bd9Sstevel@tonic-gate } 14317c478bd9Sstevel@tonic-gate return (FALSE); 14327c478bd9Sstevel@tonic-gate } 14337c478bd9Sstevel@tonic-gate 14347c478bd9Sstevel@tonic-gate /* 14357c478bd9Sstevel@tonic-gate * Create a new configuration. 14367c478bd9Sstevel@tonic-gate */ 14377c478bd9Sstevel@tonic-gate void 14387c478bd9Sstevel@tonic-gate create_func(cmd_t *cmd) 14397c478bd9Sstevel@tonic-gate { 14407c478bd9Sstevel@tonic-gate int err, arg; 14417c478bd9Sstevel@tonic-gate char zone_template[ZONENAME_MAX]; 1442ee519a1fSgjelinek char attach_path[MAXPATHLEN]; 14437c478bd9Sstevel@tonic-gate zone_dochandle_t tmphandle; 14447c478bd9Sstevel@tonic-gate bool force = FALSE; 1445ee519a1fSgjelinek bool attach = FALSE; 14467c478bd9Sstevel@tonic-gate 14477c478bd9Sstevel@tonic-gate assert(cmd != NULL); 14487c478bd9Sstevel@tonic-gate 14497c478bd9Sstevel@tonic-gate /* This is the default if no arguments are given. */ 14507c478bd9Sstevel@tonic-gate (void) strlcpy(zone_template, "SUNWdefault", sizeof (zone_template)); 14517c478bd9Sstevel@tonic-gate 14527c478bd9Sstevel@tonic-gate optind = 0; 14539acbbeafSnn while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?a:bFt:")) 14549acbbeafSnn != EOF) { 14557c478bd9Sstevel@tonic-gate switch (arg) { 14567c478bd9Sstevel@tonic-gate case '?': 14577c478bd9Sstevel@tonic-gate if (optopt == '?') 14587c478bd9Sstevel@tonic-gate longer_usage(CMD_CREATE); 14597c478bd9Sstevel@tonic-gate else 14607c478bd9Sstevel@tonic-gate short_usage(CMD_CREATE); 14617c478bd9Sstevel@tonic-gate return; 1462ee519a1fSgjelinek case 'a': 1463ee519a1fSgjelinek (void) strlcpy(attach_path, optarg, 1464ee519a1fSgjelinek sizeof (attach_path)); 1465ee519a1fSgjelinek attach = TRUE; 1466ee519a1fSgjelinek break; 14677c478bd9Sstevel@tonic-gate case 'b': 14687c478bd9Sstevel@tonic-gate (void) strlcpy(zone_template, "SUNWblank", 14697c478bd9Sstevel@tonic-gate sizeof (zone_template)); 14707c478bd9Sstevel@tonic-gate break; 14717c478bd9Sstevel@tonic-gate case 'F': 14727c478bd9Sstevel@tonic-gate force = TRUE; 14737c478bd9Sstevel@tonic-gate break; 14747c478bd9Sstevel@tonic-gate case 't': 14757c478bd9Sstevel@tonic-gate (void) strlcpy(zone_template, optarg, 14767c478bd9Sstevel@tonic-gate sizeof (zone_template)); 14777c478bd9Sstevel@tonic-gate break; 14787c478bd9Sstevel@tonic-gate default: 14797c478bd9Sstevel@tonic-gate short_usage(CMD_CREATE); 14807c478bd9Sstevel@tonic-gate return; 14817c478bd9Sstevel@tonic-gate } 14827c478bd9Sstevel@tonic-gate } 14837c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 14847c478bd9Sstevel@tonic-gate short_usage(CMD_CREATE); 14857c478bd9Sstevel@tonic-gate return; 14867c478bd9Sstevel@tonic-gate } 14877c478bd9Sstevel@tonic-gate 14887c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_CREATE)) 14897c478bd9Sstevel@tonic-gate return; 14907c478bd9Sstevel@tonic-gate 14917c478bd9Sstevel@tonic-gate if (check_if_zone_already_exists(force) != Z_OK) 14927c478bd9Sstevel@tonic-gate return; 14937c478bd9Sstevel@tonic-gate 14947c478bd9Sstevel@tonic-gate /* 14957c478bd9Sstevel@tonic-gate * Get a temporary handle first. If that fails, the old handle 14967c478bd9Sstevel@tonic-gate * will not be lost. Then finish whichever one we don't need, 14977c478bd9Sstevel@tonic-gate * to avoid leaks. Then get the handle for zone_template, and 14987c478bd9Sstevel@tonic-gate * set the name to zone: this "copy, rename" method is how 14997c478bd9Sstevel@tonic-gate * create -[b|t] works. 15007c478bd9Sstevel@tonic-gate */ 15017c478bd9Sstevel@tonic-gate if ((tmphandle = zonecfg_init_handle()) == NULL) { 15027c478bd9Sstevel@tonic-gate zone_perror(execname, Z_NOMEM, TRUE); 15037c478bd9Sstevel@tonic-gate exit(Z_ERR); 15047c478bd9Sstevel@tonic-gate } 1505ee519a1fSgjelinek 1506ee519a1fSgjelinek if (attach) 1507ee519a1fSgjelinek err = zonecfg_get_attach_handle(attach_path, zone, B_FALSE, 1508ee519a1fSgjelinek tmphandle); 1509ee519a1fSgjelinek else 1510ee519a1fSgjelinek err = zonecfg_get_template_handle(zone_template, zone, 1511ee519a1fSgjelinek tmphandle); 1512ee519a1fSgjelinek 1513ee519a1fSgjelinek if (err != Z_OK) { 15147c478bd9Sstevel@tonic-gate zonecfg_fini_handle(tmphandle); 1515ee519a1fSgjelinek if (attach && err == Z_NO_ZONE) 1516ee519a1fSgjelinek (void) fprintf(stderr, gettext("invalid path to " 1517ee519a1fSgjelinek "detached zone\n")); 1518ee519a1fSgjelinek else if (attach && err == Z_INVALID_DOCUMENT) 1519ee519a1fSgjelinek (void) fprintf(stderr, gettext("Cannot attach to an " 1520ee519a1fSgjelinek "earlier release of the operating system\n")); 1521ee519a1fSgjelinek else 1522ee519a1fSgjelinek zone_perror(zone_template, err, TRUE); 15237c478bd9Sstevel@tonic-gate return; 15247c478bd9Sstevel@tonic-gate } 1525087719fdSdp 1526087719fdSdp need_to_commit = TRUE; 15277c478bd9Sstevel@tonic-gate zonecfg_fini_handle(handle); 15287c478bd9Sstevel@tonic-gate handle = tmphandle; 1529087719fdSdp got_handle = TRUE; 15307c478bd9Sstevel@tonic-gate } 15317c478bd9Sstevel@tonic-gate 15327c478bd9Sstevel@tonic-gate /* 15337c478bd9Sstevel@tonic-gate * This malloc()'s memory, which must be freed by the caller. 15347c478bd9Sstevel@tonic-gate */ 15357c478bd9Sstevel@tonic-gate static char * 15367c478bd9Sstevel@tonic-gate quoteit(char *instr) 15377c478bd9Sstevel@tonic-gate { 15387c478bd9Sstevel@tonic-gate char *outstr; 15397c478bd9Sstevel@tonic-gate size_t outstrsize = strlen(instr) + 3; /* 2 quotes + '\0' */ 15407c478bd9Sstevel@tonic-gate 15417c478bd9Sstevel@tonic-gate if ((outstr = malloc(outstrsize)) == NULL) { 15427c478bd9Sstevel@tonic-gate zone_perror(zone, Z_NOMEM, FALSE); 15437c478bd9Sstevel@tonic-gate exit(Z_ERR); 15447c478bd9Sstevel@tonic-gate } 15457c478bd9Sstevel@tonic-gate if (strchr(instr, ' ') == NULL) { 15467c478bd9Sstevel@tonic-gate (void) strlcpy(outstr, instr, outstrsize); 15477c478bd9Sstevel@tonic-gate return (outstr); 15487c478bd9Sstevel@tonic-gate } 15497c478bd9Sstevel@tonic-gate (void) snprintf(outstr, outstrsize, "\"%s\"", instr); 15507c478bd9Sstevel@tonic-gate return (outstr); 15517c478bd9Sstevel@tonic-gate } 15527c478bd9Sstevel@tonic-gate 15537c478bd9Sstevel@tonic-gate static void 15547c478bd9Sstevel@tonic-gate export_prop(FILE *of, int prop_num, char *prop_id) 15557c478bd9Sstevel@tonic-gate { 15567c478bd9Sstevel@tonic-gate char *quote_str; 15577c478bd9Sstevel@tonic-gate 15587c478bd9Sstevel@tonic-gate if (strlen(prop_id) == 0) 15597c478bd9Sstevel@tonic-gate return; 15607c478bd9Sstevel@tonic-gate quote_str = quoteit(prop_id); 15617c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 15627c478bd9Sstevel@tonic-gate pt_to_str(prop_num), quote_str); 15637c478bd9Sstevel@tonic-gate free(quote_str); 15647c478bd9Sstevel@tonic-gate } 15657c478bd9Sstevel@tonic-gate 15667c478bd9Sstevel@tonic-gate void 15677c478bd9Sstevel@tonic-gate export_func(cmd_t *cmd) 15687c478bd9Sstevel@tonic-gate { 15697c478bd9Sstevel@tonic-gate struct zone_nwiftab nwiftab; 15707c478bd9Sstevel@tonic-gate struct zone_fstab fstab; 15717c478bd9Sstevel@tonic-gate struct zone_devtab devtab; 15727c478bd9Sstevel@tonic-gate struct zone_attrtab attrtab; 15737c478bd9Sstevel@tonic-gate struct zone_rctltab rctltab; 1574fa9e4066Sahrens struct zone_dstab dstab; 15750209230bSgjelinek struct zone_psettab psettab; 15760209230bSgjelinek struct zone_mcaptab mcaptab; 15777c478bd9Sstevel@tonic-gate struct zone_rctlvaltab *valptr; 15787c478bd9Sstevel@tonic-gate int err, arg; 15797c478bd9Sstevel@tonic-gate char zonepath[MAXPATHLEN], outfile[MAXPATHLEN], pool[MAXNAMELEN]; 15803f2f09c1Sdp char bootargs[BOOTARGS_MAX]; 15810209230bSgjelinek char sched[MAXNAMELEN]; 15829acbbeafSnn char brand[MAXNAMELEN]; 1583ffbafc53Scomay char *limitpriv; 15847c478bd9Sstevel@tonic-gate FILE *of; 15857c478bd9Sstevel@tonic-gate boolean_t autoboot; 1586*f4b3ec61Sdh zone_iptype_t iptype; 15877c478bd9Sstevel@tonic-gate bool need_to_close = FALSE; 15887c478bd9Sstevel@tonic-gate 15897c478bd9Sstevel@tonic-gate assert(cmd != NULL); 15907c478bd9Sstevel@tonic-gate 15917c478bd9Sstevel@tonic-gate outfile[0] = '\0'; 15927c478bd9Sstevel@tonic-gate optind = 0; 15937c478bd9Sstevel@tonic-gate while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?f:")) != EOF) { 15947c478bd9Sstevel@tonic-gate switch (arg) { 15957c478bd9Sstevel@tonic-gate case '?': 15967c478bd9Sstevel@tonic-gate if (optopt == '?') 15977c478bd9Sstevel@tonic-gate longer_usage(CMD_EXPORT); 15987c478bd9Sstevel@tonic-gate else 15997c478bd9Sstevel@tonic-gate short_usage(CMD_EXPORT); 16007c478bd9Sstevel@tonic-gate return; 16017c478bd9Sstevel@tonic-gate case 'f': 16027c478bd9Sstevel@tonic-gate (void) strlcpy(outfile, optarg, sizeof (outfile)); 16037c478bd9Sstevel@tonic-gate break; 16047c478bd9Sstevel@tonic-gate default: 16057c478bd9Sstevel@tonic-gate short_usage(CMD_EXPORT); 16067c478bd9Sstevel@tonic-gate return; 16077c478bd9Sstevel@tonic-gate } 16087c478bd9Sstevel@tonic-gate } 16097c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 16107c478bd9Sstevel@tonic-gate short_usage(CMD_EXPORT); 16117c478bd9Sstevel@tonic-gate return; 16127c478bd9Sstevel@tonic-gate } 16137c478bd9Sstevel@tonic-gate if (strlen(outfile) == 0) { 16147c478bd9Sstevel@tonic-gate of = stdout; 16157c478bd9Sstevel@tonic-gate } else { 16167c478bd9Sstevel@tonic-gate if ((of = fopen(outfile, "w")) == NULL) { 16177c478bd9Sstevel@tonic-gate zerr(gettext("opening file %s: %s"), 16187c478bd9Sstevel@tonic-gate outfile, strerror(errno)); 16197c478bd9Sstevel@tonic-gate goto done; 16207c478bd9Sstevel@tonic-gate } 16217c478bd9Sstevel@tonic-gate setbuf(of, NULL); 16227c478bd9Sstevel@tonic-gate need_to_close = TRUE; 16237c478bd9Sstevel@tonic-gate } 16247c478bd9Sstevel@tonic-gate 16257c478bd9Sstevel@tonic-gate if ((err = initialize(TRUE)) != Z_OK) 16267c478bd9Sstevel@tonic-gate goto done; 16277c478bd9Sstevel@tonic-gate 16287c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s -b\n", cmd_to_str(CMD_CREATE)); 16297c478bd9Sstevel@tonic-gate 16307c478bd9Sstevel@tonic-gate if (zonecfg_get_zonepath(handle, zonepath, sizeof (zonepath)) == Z_OK && 16317c478bd9Sstevel@tonic-gate strlen(zonepath) > 0) 16327c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 16337c478bd9Sstevel@tonic-gate pt_to_str(PT_ZONEPATH), zonepath); 16347c478bd9Sstevel@tonic-gate 16359acbbeafSnn if ((zone_get_brand(zone, brand, sizeof (brand)) == Z_OK) && 16369acbbeafSnn (strcmp(brand, NATIVE_BRAND_NAME) != 0)) 16379acbbeafSnn (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 16389acbbeafSnn pt_to_str(PT_BRAND), brand); 16399acbbeafSnn 16407c478bd9Sstevel@tonic-gate if (zonecfg_get_autoboot(handle, &autoboot) == Z_OK) 16417c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 16427c478bd9Sstevel@tonic-gate pt_to_str(PT_AUTOBOOT), autoboot ? "true" : "false"); 16437c478bd9Sstevel@tonic-gate 16443f2f09c1Sdp if (zonecfg_get_bootargs(handle, bootargs, sizeof (bootargs)) == Z_OK && 16453f2f09c1Sdp strlen(bootargs) > 0) { 16463f2f09c1Sdp (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 16473f2f09c1Sdp pt_to_str(PT_BOOTARGS), bootargs); 16483f2f09c1Sdp } 16493f2f09c1Sdp 16507c478bd9Sstevel@tonic-gate if (zonecfg_get_pool(handle, pool, sizeof (pool)) == Z_OK && 16517c478bd9Sstevel@tonic-gate strlen(pool) > 0) 16527c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 16537c478bd9Sstevel@tonic-gate pt_to_str(PT_POOL), pool); 16547c478bd9Sstevel@tonic-gate 1655ffbafc53Scomay if (zonecfg_get_limitpriv(handle, &limitpriv) == Z_OK && 1656ffbafc53Scomay strlen(limitpriv) > 0) { 1657ffbafc53Scomay (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 1658ffbafc53Scomay pt_to_str(PT_LIMITPRIV), limitpriv); 1659ffbafc53Scomay free(limitpriv); 1660ffbafc53Scomay } 1661ffbafc53Scomay 16620209230bSgjelinek if (zonecfg_get_sched_class(handle, sched, sizeof (sched)) == Z_OK && 16630209230bSgjelinek strlen(sched) > 0) 16640209230bSgjelinek (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 16650209230bSgjelinek pt_to_str(PT_SCHED), sched); 16663f2f09c1Sdp 1667*f4b3ec61Sdh if (zonecfg_get_iptype(handle, &iptype) == Z_OK) { 1668*f4b3ec61Sdh switch (iptype) { 1669*f4b3ec61Sdh case ZS_SHARED: 1670*f4b3ec61Sdh (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 1671*f4b3ec61Sdh pt_to_str(PT_IPTYPE), "shared"); 1672*f4b3ec61Sdh break; 1673*f4b3ec61Sdh case ZS_EXCLUSIVE: 1674*f4b3ec61Sdh (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 1675*f4b3ec61Sdh pt_to_str(PT_IPTYPE), "exclusive"); 1676*f4b3ec61Sdh break; 1677*f4b3ec61Sdh } 1678*f4b3ec61Sdh } 1679*f4b3ec61Sdh 16807c478bd9Sstevel@tonic-gate if ((err = zonecfg_setipdent(handle)) != Z_OK) { 16817c478bd9Sstevel@tonic-gate zone_perror(zone, err, FALSE); 16827c478bd9Sstevel@tonic-gate goto done; 16837c478bd9Sstevel@tonic-gate } 16847c478bd9Sstevel@tonic-gate while (zonecfg_getipdent(handle, &fstab) == Z_OK) { 16857c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 16867c478bd9Sstevel@tonic-gate rt_to_str(RT_IPD)); 16877c478bd9Sstevel@tonic-gate export_prop(of, PT_DIR, fstab.zone_fs_dir); 16887c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 16897c478bd9Sstevel@tonic-gate } 16907c478bd9Sstevel@tonic-gate (void) zonecfg_endipdent(handle); 16917c478bd9Sstevel@tonic-gate 16927c478bd9Sstevel@tonic-gate if ((err = zonecfg_setfsent(handle)) != Z_OK) { 16937c478bd9Sstevel@tonic-gate zone_perror(zone, err, FALSE); 16947c478bd9Sstevel@tonic-gate goto done; 16957c478bd9Sstevel@tonic-gate } 16967c478bd9Sstevel@tonic-gate while (zonecfg_getfsent(handle, &fstab) == Z_OK) { 16977c478bd9Sstevel@tonic-gate zone_fsopt_t *optptr; 16987c478bd9Sstevel@tonic-gate 16997c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 17007c478bd9Sstevel@tonic-gate rt_to_str(RT_FS)); 17017c478bd9Sstevel@tonic-gate export_prop(of, PT_DIR, fstab.zone_fs_dir); 17027c478bd9Sstevel@tonic-gate export_prop(of, PT_SPECIAL, fstab.zone_fs_special); 17037c478bd9Sstevel@tonic-gate export_prop(of, PT_RAW, fstab.zone_fs_raw); 17047c478bd9Sstevel@tonic-gate export_prop(of, PT_TYPE, fstab.zone_fs_type); 17057c478bd9Sstevel@tonic-gate for (optptr = fstab.zone_fs_options; optptr != NULL; 17067c478bd9Sstevel@tonic-gate optptr = optptr->zone_fsopt_next) { 17077c478bd9Sstevel@tonic-gate /* 17087c478bd9Sstevel@tonic-gate * Simple property values with embedded equal signs 17097c478bd9Sstevel@tonic-gate * need to be quoted to prevent the lexer from 17107c478bd9Sstevel@tonic-gate * mis-parsing them as complex name=value pairs. 17117c478bd9Sstevel@tonic-gate */ 17127c478bd9Sstevel@tonic-gate if (strchr(optptr->zone_fsopt_opt, '=')) 17137c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s \"%s\"\n", 17147c478bd9Sstevel@tonic-gate cmd_to_str(CMD_ADD), 17157c478bd9Sstevel@tonic-gate pt_to_str(PT_OPTIONS), 17167c478bd9Sstevel@tonic-gate optptr->zone_fsopt_opt); 17177c478bd9Sstevel@tonic-gate else 17187c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s %s\n", 17197c478bd9Sstevel@tonic-gate cmd_to_str(CMD_ADD), 17207c478bd9Sstevel@tonic-gate pt_to_str(PT_OPTIONS), 17217c478bd9Sstevel@tonic-gate optptr->zone_fsopt_opt); 17227c478bd9Sstevel@tonic-gate } 17237c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 17247c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(fstab.zone_fs_options); 17257c478bd9Sstevel@tonic-gate } 17267c478bd9Sstevel@tonic-gate (void) zonecfg_endfsent(handle); 17277c478bd9Sstevel@tonic-gate 17287c478bd9Sstevel@tonic-gate if ((err = zonecfg_setnwifent(handle)) != Z_OK) { 17297c478bd9Sstevel@tonic-gate zone_perror(zone, err, FALSE); 17307c478bd9Sstevel@tonic-gate goto done; 17317c478bd9Sstevel@tonic-gate } 17327c478bd9Sstevel@tonic-gate while (zonecfg_getnwifent(handle, &nwiftab) == Z_OK) { 17337c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 17347c478bd9Sstevel@tonic-gate rt_to_str(RT_NET)); 17357c478bd9Sstevel@tonic-gate export_prop(of, PT_ADDRESS, nwiftab.zone_nwif_address); 17367c478bd9Sstevel@tonic-gate export_prop(of, PT_PHYSICAL, nwiftab.zone_nwif_physical); 17377c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 17387c478bd9Sstevel@tonic-gate } 17397c478bd9Sstevel@tonic-gate (void) zonecfg_endnwifent(handle); 17407c478bd9Sstevel@tonic-gate 17417c478bd9Sstevel@tonic-gate if ((err = zonecfg_setdevent(handle)) != Z_OK) { 17427c478bd9Sstevel@tonic-gate zone_perror(zone, err, FALSE); 17437c478bd9Sstevel@tonic-gate goto done; 17447c478bd9Sstevel@tonic-gate } 17457c478bd9Sstevel@tonic-gate while (zonecfg_getdevent(handle, &devtab) == Z_OK) { 17467c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 17477c478bd9Sstevel@tonic-gate rt_to_str(RT_DEVICE)); 17487c478bd9Sstevel@tonic-gate export_prop(of, PT_MATCH, devtab.zone_dev_match); 17497c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 17507c478bd9Sstevel@tonic-gate } 17517c478bd9Sstevel@tonic-gate (void) zonecfg_enddevent(handle); 17527c478bd9Sstevel@tonic-gate 17537c478bd9Sstevel@tonic-gate if ((err = zonecfg_setrctlent(handle)) != Z_OK) { 17547c478bd9Sstevel@tonic-gate zone_perror(zone, err, FALSE); 17557c478bd9Sstevel@tonic-gate goto done; 17567c478bd9Sstevel@tonic-gate } 17577c478bd9Sstevel@tonic-gate while (zonecfg_getrctlent(handle, &rctltab) == Z_OK) { 17587c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s rctl\n", cmd_to_str(CMD_ADD)); 17597c478bd9Sstevel@tonic-gate export_prop(of, PT_NAME, rctltab.zone_rctl_name); 17607c478bd9Sstevel@tonic-gate for (valptr = rctltab.zone_rctl_valptr; valptr != NULL; 17617c478bd9Sstevel@tonic-gate valptr = valptr->zone_rctlval_next) { 17627c478bd9Sstevel@tonic-gate fprintf(of, "%s %s (%s=%s,%s=%s,%s=%s)\n", 17637c478bd9Sstevel@tonic-gate cmd_to_str(CMD_ADD), pt_to_str(PT_VALUE), 17647c478bd9Sstevel@tonic-gate pt_to_str(PT_PRIV), valptr->zone_rctlval_priv, 17657c478bd9Sstevel@tonic-gate pt_to_str(PT_LIMIT), valptr->zone_rctlval_limit, 17667c478bd9Sstevel@tonic-gate pt_to_str(PT_ACTION), valptr->zone_rctlval_action); 17677c478bd9Sstevel@tonic-gate } 17687c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 17697c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctltab.zone_rctl_valptr); 17707c478bd9Sstevel@tonic-gate } 17717c478bd9Sstevel@tonic-gate (void) zonecfg_endrctlent(handle); 17727c478bd9Sstevel@tonic-gate 17737c478bd9Sstevel@tonic-gate if ((err = zonecfg_setattrent(handle)) != Z_OK) { 17747c478bd9Sstevel@tonic-gate zone_perror(zone, err, FALSE); 17757c478bd9Sstevel@tonic-gate goto done; 17767c478bd9Sstevel@tonic-gate } 17777c478bd9Sstevel@tonic-gate while (zonecfg_getattrent(handle, &attrtab) == Z_OK) { 17787c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 17797c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR)); 17807c478bd9Sstevel@tonic-gate export_prop(of, PT_NAME, attrtab.zone_attr_name); 17817c478bd9Sstevel@tonic-gate export_prop(of, PT_TYPE, attrtab.zone_attr_type); 17827c478bd9Sstevel@tonic-gate export_prop(of, PT_VALUE, attrtab.zone_attr_value); 17837c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 17847c478bd9Sstevel@tonic-gate } 17857c478bd9Sstevel@tonic-gate (void) zonecfg_endattrent(handle); 17867c478bd9Sstevel@tonic-gate 1787fa9e4066Sahrens if ((err = zonecfg_setdsent(handle)) != Z_OK) { 1788fa9e4066Sahrens zone_perror(zone, err, FALSE); 1789fa9e4066Sahrens goto done; 1790fa9e4066Sahrens } 1791fa9e4066Sahrens while (zonecfg_getdsent(handle, &dstab) == Z_OK) { 1792fa9e4066Sahrens (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 1793fa9e4066Sahrens rt_to_str(RT_DATASET)); 1794fa9e4066Sahrens export_prop(of, PT_NAME, dstab.zone_dataset_name); 1795fa9e4066Sahrens (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 1796fa9e4066Sahrens } 1797fa9e4066Sahrens (void) zonecfg_enddsent(handle); 1798fa9e4066Sahrens 17990209230bSgjelinek if (zonecfg_getpsetent(handle, &psettab) == Z_OK) { 18000209230bSgjelinek (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 18010209230bSgjelinek rt_to_str(RT_DCPU)); 18020209230bSgjelinek if (strcmp(psettab.zone_ncpu_min, psettab.zone_ncpu_max) == 0) 18030209230bSgjelinek (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 18040209230bSgjelinek pt_to_str(PT_NCPUS), psettab.zone_ncpu_max); 18050209230bSgjelinek else 18060209230bSgjelinek (void) fprintf(of, "%s %s=%s-%s\n", cmd_to_str(CMD_SET), 18070209230bSgjelinek pt_to_str(PT_NCPUS), psettab.zone_ncpu_min, 18080209230bSgjelinek psettab.zone_ncpu_max); 18090209230bSgjelinek if (psettab.zone_importance[0] != '\0') 18100209230bSgjelinek (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 18110209230bSgjelinek pt_to_str(PT_IMPORTANCE), psettab.zone_importance); 18120209230bSgjelinek (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 18130209230bSgjelinek } 18140209230bSgjelinek 18150209230bSgjelinek if (zonecfg_getmcapent(handle, &mcaptab) == Z_OK) { 18160209230bSgjelinek char buf[128]; 18170209230bSgjelinek 18180209230bSgjelinek (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 18190209230bSgjelinek rt_to_str(RT_MCAP)); 18200209230bSgjelinek bytes_to_units(mcaptab.zone_physmem_cap, buf, sizeof (buf)); 18210209230bSgjelinek (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 18220209230bSgjelinek pt_to_str(PT_PHYSICAL), buf); 18230209230bSgjelinek (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 18240209230bSgjelinek } 18250209230bSgjelinek 18267c478bd9Sstevel@tonic-gate done: 18277c478bd9Sstevel@tonic-gate if (need_to_close) 18287c478bd9Sstevel@tonic-gate (void) fclose(of); 18297c478bd9Sstevel@tonic-gate } 18307c478bd9Sstevel@tonic-gate 18317c478bd9Sstevel@tonic-gate void 18327c478bd9Sstevel@tonic-gate exit_func(cmd_t *cmd) 18337c478bd9Sstevel@tonic-gate { 18347c478bd9Sstevel@tonic-gate int arg, answer; 18357c478bd9Sstevel@tonic-gate 18367c478bd9Sstevel@tonic-gate optind = 0; 18377c478bd9Sstevel@tonic-gate while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?F")) != EOF) { 18387c478bd9Sstevel@tonic-gate switch (arg) { 18397c478bd9Sstevel@tonic-gate case '?': 18407c478bd9Sstevel@tonic-gate longer_usage(CMD_EXIT); 18417c478bd9Sstevel@tonic-gate return; 18427c478bd9Sstevel@tonic-gate case 'F': 18437c478bd9Sstevel@tonic-gate force_exit = TRUE; 18447c478bd9Sstevel@tonic-gate break; 18457c478bd9Sstevel@tonic-gate default: 18467c478bd9Sstevel@tonic-gate short_usage(CMD_EXIT); 18477c478bd9Sstevel@tonic-gate return; 18487c478bd9Sstevel@tonic-gate } 18497c478bd9Sstevel@tonic-gate } 18507c478bd9Sstevel@tonic-gate if (optind < cmd->cmd_argc) { 18517c478bd9Sstevel@tonic-gate short_usage(CMD_EXIT); 18527c478bd9Sstevel@tonic-gate return; 18537c478bd9Sstevel@tonic-gate } 18547c478bd9Sstevel@tonic-gate 18557c478bd9Sstevel@tonic-gate if (global_scope || force_exit) { 18567c478bd9Sstevel@tonic-gate time_to_exit = TRUE; 18577c478bd9Sstevel@tonic-gate return; 18587c478bd9Sstevel@tonic-gate } 18597c478bd9Sstevel@tonic-gate 18607c478bd9Sstevel@tonic-gate answer = ask_yesno(FALSE, "Resource incomplete; really quit"); 18617c478bd9Sstevel@tonic-gate if (answer == -1) { 18627c478bd9Sstevel@tonic-gate zerr(gettext("Resource incomplete, input " 18637c478bd9Sstevel@tonic-gate "not from terminal and -F not specified:\n%s command " 18647c478bd9Sstevel@tonic-gate "ignored, but exiting anyway."), cmd_to_str(CMD_EXIT)); 18657c478bd9Sstevel@tonic-gate exit(Z_ERR); 18667c478bd9Sstevel@tonic-gate } else if (answer == 1) { 18677c478bd9Sstevel@tonic-gate time_to_exit = TRUE; 18687c478bd9Sstevel@tonic-gate } 18697c478bd9Sstevel@tonic-gate /* (answer == 0) => just return */ 18707c478bd9Sstevel@tonic-gate } 18717c478bd9Sstevel@tonic-gate 18727c478bd9Sstevel@tonic-gate static int 18737c478bd9Sstevel@tonic-gate validate_zonepath_syntax(char *path) 18747c478bd9Sstevel@tonic-gate { 18757c478bd9Sstevel@tonic-gate if (path[0] != '/') { 18767c478bd9Sstevel@tonic-gate zerr(gettext("%s is not an absolute path."), path); 18777c478bd9Sstevel@tonic-gate return (Z_ERR); 18787c478bd9Sstevel@tonic-gate } 18797c478bd9Sstevel@tonic-gate if (strcmp(path, "/") == 0) { 18807c478bd9Sstevel@tonic-gate zerr(gettext("/ is not allowed as a %s."), 18817c478bd9Sstevel@tonic-gate pt_to_str(PT_ZONEPATH)); 18827c478bd9Sstevel@tonic-gate return (Z_ERR); 18837c478bd9Sstevel@tonic-gate } 18847c478bd9Sstevel@tonic-gate return (Z_OK); 18857c478bd9Sstevel@tonic-gate } 18867c478bd9Sstevel@tonic-gate 18877c478bd9Sstevel@tonic-gate static void 18887c478bd9Sstevel@tonic-gate add_resource(cmd_t *cmd) 18897c478bd9Sstevel@tonic-gate { 18907c478bd9Sstevel@tonic-gate int type; 18910209230bSgjelinek struct zone_psettab tmp_psettab; 18920209230bSgjelinek struct zone_mcaptab tmp_mcaptab; 18930209230bSgjelinek uint64_t tmp_mcap; 18940209230bSgjelinek char pool[MAXNAMELEN]; 18957c478bd9Sstevel@tonic-gate 18967c478bd9Sstevel@tonic-gate if ((type = cmd->cmd_res_type) == RT_UNKNOWN) { 18977c478bd9Sstevel@tonic-gate long_usage(CMD_ADD, TRUE); 18987c478bd9Sstevel@tonic-gate goto bad; 18997c478bd9Sstevel@tonic-gate } 19007c478bd9Sstevel@tonic-gate 19017c478bd9Sstevel@tonic-gate switch (type) { 19027c478bd9Sstevel@tonic-gate case RT_FS: 19037c478bd9Sstevel@tonic-gate bzero(&in_progress_fstab, sizeof (in_progress_fstab)); 19047c478bd9Sstevel@tonic-gate return; 19057c478bd9Sstevel@tonic-gate case RT_IPD: 1906087719fdSdp if (state_atleast(ZONE_STATE_INSTALLED)) { 19077c478bd9Sstevel@tonic-gate zerr(gettext("Zone %s already installed; %s %s not " 19087c478bd9Sstevel@tonic-gate "allowed."), zone, cmd_to_str(CMD_ADD), 19097c478bd9Sstevel@tonic-gate rt_to_str(RT_IPD)); 19107c478bd9Sstevel@tonic-gate goto bad; 19117c478bd9Sstevel@tonic-gate } 19127c478bd9Sstevel@tonic-gate bzero(&in_progress_ipdtab, sizeof (in_progress_ipdtab)); 19137c478bd9Sstevel@tonic-gate return; 19147c478bd9Sstevel@tonic-gate case RT_NET: 19157c478bd9Sstevel@tonic-gate bzero(&in_progress_nwiftab, sizeof (in_progress_nwiftab)); 19167c478bd9Sstevel@tonic-gate return; 19177c478bd9Sstevel@tonic-gate case RT_DEVICE: 19187c478bd9Sstevel@tonic-gate bzero(&in_progress_devtab, sizeof (in_progress_devtab)); 19197c478bd9Sstevel@tonic-gate return; 19207c478bd9Sstevel@tonic-gate case RT_RCTL: 19210209230bSgjelinek if (global_zone) 19220209230bSgjelinek zerr(gettext("WARNING: Setting a global zone resource " 19230209230bSgjelinek "control too low could deny\nservice " 19240209230bSgjelinek "to even the root user; " 19250209230bSgjelinek "this could render the system impossible\n" 19260209230bSgjelinek "to administer. Please use caution.")); 19277c478bd9Sstevel@tonic-gate bzero(&in_progress_rctltab, sizeof (in_progress_rctltab)); 19287c478bd9Sstevel@tonic-gate return; 19297c478bd9Sstevel@tonic-gate case RT_ATTR: 19307c478bd9Sstevel@tonic-gate bzero(&in_progress_attrtab, sizeof (in_progress_attrtab)); 19317c478bd9Sstevel@tonic-gate return; 1932fa9e4066Sahrens case RT_DATASET: 1933fa9e4066Sahrens bzero(&in_progress_dstab, sizeof (in_progress_dstab)); 1934fa9e4066Sahrens return; 19350209230bSgjelinek case RT_DCPU: 19360209230bSgjelinek /* Make sure there isn't already a cpu-set entry. */ 19370209230bSgjelinek if (zonecfg_lookup_pset(handle, &tmp_psettab) == Z_OK) { 19380209230bSgjelinek zerr(gettext("The %s resource already exists."), 19390209230bSgjelinek rt_to_str(RT_DCPU)); 19400209230bSgjelinek goto bad; 19410209230bSgjelinek } 19420209230bSgjelinek 19430209230bSgjelinek /* Make sure the pool property isn't set. */ 19440209230bSgjelinek if (zonecfg_get_pool(handle, pool, sizeof (pool)) == Z_OK && 19450209230bSgjelinek strlen(pool) > 0) { 19460209230bSgjelinek zerr(gettext("The %s property is already set. " 19470209230bSgjelinek "A persistent pool is incompatible with\nthe %s " 19480209230bSgjelinek "resource."), 19490209230bSgjelinek pt_to_str(PT_POOL), rt_to_str(RT_DCPU)); 19500209230bSgjelinek goto bad; 19510209230bSgjelinek } 19520209230bSgjelinek 19530209230bSgjelinek bzero(&in_progress_psettab, sizeof (in_progress_psettab)); 19540209230bSgjelinek return; 19550209230bSgjelinek case RT_MCAP: 19560209230bSgjelinek /* 19570209230bSgjelinek * Make sure there isn't already a mem-cap entry or max-swap 19580209230bSgjelinek * or max-locked rctl. 19590209230bSgjelinek */ 19600209230bSgjelinek if (zonecfg_lookup_mcap(handle, &tmp_mcaptab) == Z_OK || 19610209230bSgjelinek zonecfg_get_aliased_rctl(handle, ALIAS_MAXSWAP, &tmp_mcap) 19620209230bSgjelinek == Z_OK || 19630209230bSgjelinek zonecfg_get_aliased_rctl(handle, ALIAS_MAXLOCKEDMEM, 19640209230bSgjelinek &tmp_mcap) == Z_OK) { 19650209230bSgjelinek zerr(gettext("The %s resource or a related resource " 19660209230bSgjelinek "control already exists."), rt_to_str(RT_MCAP)); 19670209230bSgjelinek goto bad; 19680209230bSgjelinek } 19690209230bSgjelinek if (global_zone) 19700209230bSgjelinek zerr(gettext("WARNING: Setting a global zone memory " 19710209230bSgjelinek "cap too low could deny\nservice " 19720209230bSgjelinek "to even the root user; " 19730209230bSgjelinek "this could render the system impossible\n" 19740209230bSgjelinek "to administer. Please use caution.")); 19750209230bSgjelinek bzero(&in_progress_mcaptab, sizeof (in_progress_mcaptab)); 19760209230bSgjelinek return; 19777c478bd9Sstevel@tonic-gate default: 19787c478bd9Sstevel@tonic-gate zone_perror(rt_to_str(type), Z_NO_RESOURCE_TYPE, TRUE); 19797c478bd9Sstevel@tonic-gate long_usage(CMD_ADD, TRUE); 19807c478bd9Sstevel@tonic-gate usage(FALSE, HELP_RESOURCES); 19817c478bd9Sstevel@tonic-gate } 19827c478bd9Sstevel@tonic-gate bad: 19837c478bd9Sstevel@tonic-gate global_scope = TRUE; 19847c478bd9Sstevel@tonic-gate end_op = -1; 19857c478bd9Sstevel@tonic-gate } 19867c478bd9Sstevel@tonic-gate 19877c478bd9Sstevel@tonic-gate static void 19887c478bd9Sstevel@tonic-gate do_complex_rctl_val(complex_property_ptr_t cp) 19897c478bd9Sstevel@tonic-gate { 19907c478bd9Sstevel@tonic-gate struct zone_rctlvaltab *rctlvaltab; 19917c478bd9Sstevel@tonic-gate complex_property_ptr_t cx; 19927c478bd9Sstevel@tonic-gate bool seen_priv = FALSE, seen_limit = FALSE, seen_action = FALSE; 19937c478bd9Sstevel@tonic-gate rctlblk_t *rctlblk; 19947c478bd9Sstevel@tonic-gate int err; 19957c478bd9Sstevel@tonic-gate 19967c478bd9Sstevel@tonic-gate if ((rctlvaltab = alloc_rctlvaltab()) == NULL) { 19977c478bd9Sstevel@tonic-gate zone_perror(zone, Z_NOMEM, TRUE); 19987c478bd9Sstevel@tonic-gate exit(Z_ERR); 19997c478bd9Sstevel@tonic-gate } 20007c478bd9Sstevel@tonic-gate for (cx = cp; cx != NULL; cx = cx->cp_next) { 20017c478bd9Sstevel@tonic-gate switch (cx->cp_type) { 20027c478bd9Sstevel@tonic-gate case PT_PRIV: 20037c478bd9Sstevel@tonic-gate if (seen_priv) { 20047c478bd9Sstevel@tonic-gate zerr(gettext("%s already specified"), 20057c478bd9Sstevel@tonic-gate pt_to_str(PT_PRIV)); 20067c478bd9Sstevel@tonic-gate goto bad; 20077c478bd9Sstevel@tonic-gate } 20087c478bd9Sstevel@tonic-gate (void) strlcpy(rctlvaltab->zone_rctlval_priv, 20097c478bd9Sstevel@tonic-gate cx->cp_value, 20107c478bd9Sstevel@tonic-gate sizeof (rctlvaltab->zone_rctlval_priv)); 20117c478bd9Sstevel@tonic-gate seen_priv = TRUE; 20127c478bd9Sstevel@tonic-gate break; 20137c478bd9Sstevel@tonic-gate case PT_LIMIT: 20147c478bd9Sstevel@tonic-gate if (seen_limit) { 20157c478bd9Sstevel@tonic-gate zerr(gettext("%s already specified"), 20167c478bd9Sstevel@tonic-gate pt_to_str(PT_LIMIT)); 20177c478bd9Sstevel@tonic-gate goto bad; 20187c478bd9Sstevel@tonic-gate } 20197c478bd9Sstevel@tonic-gate (void) strlcpy(rctlvaltab->zone_rctlval_limit, 20207c478bd9Sstevel@tonic-gate cx->cp_value, 20217c478bd9Sstevel@tonic-gate sizeof (rctlvaltab->zone_rctlval_limit)); 20227c478bd9Sstevel@tonic-gate seen_limit = TRUE; 20237c478bd9Sstevel@tonic-gate break; 20247c478bd9Sstevel@tonic-gate case PT_ACTION: 20257c478bd9Sstevel@tonic-gate if (seen_action) { 20267c478bd9Sstevel@tonic-gate zerr(gettext("%s already specified"), 20277c478bd9Sstevel@tonic-gate pt_to_str(PT_ACTION)); 20287c478bd9Sstevel@tonic-gate goto bad; 20297c478bd9Sstevel@tonic-gate } 20307c478bd9Sstevel@tonic-gate (void) strlcpy(rctlvaltab->zone_rctlval_action, 20317c478bd9Sstevel@tonic-gate cx->cp_value, 20327c478bd9Sstevel@tonic-gate sizeof (rctlvaltab->zone_rctlval_action)); 20337c478bd9Sstevel@tonic-gate seen_action = TRUE; 20347c478bd9Sstevel@tonic-gate break; 20357c478bd9Sstevel@tonic-gate default: 20367c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(PT_VALUE), 20377c478bd9Sstevel@tonic-gate Z_NO_PROPERTY_TYPE, TRUE); 20387c478bd9Sstevel@tonic-gate long_usage(CMD_ADD, TRUE); 20397c478bd9Sstevel@tonic-gate usage(FALSE, HELP_PROPS); 20407c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctlvaltab); 20417c478bd9Sstevel@tonic-gate return; 20427c478bd9Sstevel@tonic-gate } 20437c478bd9Sstevel@tonic-gate } 20447c478bd9Sstevel@tonic-gate if (!seen_priv) 20457c478bd9Sstevel@tonic-gate zerr(gettext("%s not specified"), pt_to_str(PT_PRIV)); 20467c478bd9Sstevel@tonic-gate if (!seen_limit) 20477c478bd9Sstevel@tonic-gate zerr(gettext("%s not specified"), pt_to_str(PT_LIMIT)); 20487c478bd9Sstevel@tonic-gate if (!seen_action) 20497c478bd9Sstevel@tonic-gate zerr(gettext("%s not specified"), pt_to_str(PT_ACTION)); 20507c478bd9Sstevel@tonic-gate if (!seen_priv || !seen_limit || !seen_action) 20517c478bd9Sstevel@tonic-gate goto bad; 20527c478bd9Sstevel@tonic-gate rctlvaltab->zone_rctlval_next = NULL; 20537c478bd9Sstevel@tonic-gate rctlblk = alloca(rctlblk_size()); 20547c478bd9Sstevel@tonic-gate /* 20557c478bd9Sstevel@tonic-gate * Make sure the rctl value looks roughly correct; we won't know if 20567c478bd9Sstevel@tonic-gate * it's truly OK until we verify the configuration on the target 20577c478bd9Sstevel@tonic-gate * system. 20587c478bd9Sstevel@tonic-gate */ 20597c478bd9Sstevel@tonic-gate if (zonecfg_construct_rctlblk(rctlvaltab, rctlblk) != Z_OK || 20607c478bd9Sstevel@tonic-gate !zonecfg_valid_rctlblk(rctlblk)) { 20617c478bd9Sstevel@tonic-gate zerr(gettext("Invalid %s %s specification"), rt_to_str(RT_RCTL), 20627c478bd9Sstevel@tonic-gate pt_to_str(PT_VALUE)); 20637c478bd9Sstevel@tonic-gate goto bad; 20647c478bd9Sstevel@tonic-gate } 20657c478bd9Sstevel@tonic-gate err = zonecfg_add_rctl_value(&in_progress_rctltab, rctlvaltab); 20667c478bd9Sstevel@tonic-gate if (err != Z_OK) 20677c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(PT_VALUE), err, TRUE); 20687c478bd9Sstevel@tonic-gate return; 20697c478bd9Sstevel@tonic-gate 20707c478bd9Sstevel@tonic-gate bad: 20717c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctlvaltab); 20727c478bd9Sstevel@tonic-gate } 20737c478bd9Sstevel@tonic-gate 20747c478bd9Sstevel@tonic-gate static void 20757c478bd9Sstevel@tonic-gate add_property(cmd_t *cmd) 20767c478bd9Sstevel@tonic-gate { 20777c478bd9Sstevel@tonic-gate char *prop_id; 20787c478bd9Sstevel@tonic-gate int err, res_type, prop_type; 20797c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 20807c478bd9Sstevel@tonic-gate list_property_ptr_t l; 20817c478bd9Sstevel@tonic-gate 20827c478bd9Sstevel@tonic-gate res_type = resource_scope; 20837c478bd9Sstevel@tonic-gate prop_type = cmd->cmd_prop_name[0]; 20847c478bd9Sstevel@tonic-gate if (res_type == RT_UNKNOWN || prop_type == PT_UNKNOWN) { 20857c478bd9Sstevel@tonic-gate long_usage(CMD_ADD, TRUE); 20867c478bd9Sstevel@tonic-gate return; 20877c478bd9Sstevel@tonic-gate } 20887c478bd9Sstevel@tonic-gate 20897c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs != 1) { 20907c478bd9Sstevel@tonic-gate long_usage(CMD_ADD, TRUE); 20917c478bd9Sstevel@tonic-gate return; 20927c478bd9Sstevel@tonic-gate } 20937c478bd9Sstevel@tonic-gate 20947c478bd9Sstevel@tonic-gate if (initialize(TRUE) != Z_OK) 20957c478bd9Sstevel@tonic-gate return; 20967c478bd9Sstevel@tonic-gate 20977c478bd9Sstevel@tonic-gate switch (res_type) { 20987c478bd9Sstevel@tonic-gate case RT_FS: 20997c478bd9Sstevel@tonic-gate if (prop_type != PT_OPTIONS) { 21007c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 21017c478bd9Sstevel@tonic-gate TRUE); 21027c478bd9Sstevel@tonic-gate long_usage(CMD_ADD, TRUE); 21037c478bd9Sstevel@tonic-gate usage(FALSE, HELP_PROPS); 21047c478bd9Sstevel@tonic-gate return; 21057c478bd9Sstevel@tonic-gate } 21067c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[0]; 21077c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE && 21087c478bd9Sstevel@tonic-gate pp->pv_type != PROP_VAL_LIST) { 21097c478bd9Sstevel@tonic-gate zerr(gettext("A %s or %s value was expected here."), 21107c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_SIMPLE), 21117c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_LIST)); 21127c478bd9Sstevel@tonic-gate saw_error = TRUE; 21137c478bd9Sstevel@tonic-gate return; 21147c478bd9Sstevel@tonic-gate } 21157c478bd9Sstevel@tonic-gate if (pp->pv_type == PROP_VAL_SIMPLE) { 21167c478bd9Sstevel@tonic-gate if (pp->pv_simple == NULL) { 21177c478bd9Sstevel@tonic-gate long_usage(CMD_ADD, TRUE); 21187c478bd9Sstevel@tonic-gate return; 21197c478bd9Sstevel@tonic-gate } 21207c478bd9Sstevel@tonic-gate prop_id = pp->pv_simple; 21217c478bd9Sstevel@tonic-gate err = zonecfg_add_fs_option(&in_progress_fstab, 21227c478bd9Sstevel@tonic-gate prop_id); 21237c478bd9Sstevel@tonic-gate if (err != Z_OK) 21247c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), err, TRUE); 21257c478bd9Sstevel@tonic-gate } else { 21267c478bd9Sstevel@tonic-gate list_property_ptr_t list; 21277c478bd9Sstevel@tonic-gate 21287c478bd9Sstevel@tonic-gate for (list = pp->pv_list; list != NULL; 21297c478bd9Sstevel@tonic-gate list = list->lp_next) { 21307c478bd9Sstevel@tonic-gate prop_id = list->lp_simple; 21317c478bd9Sstevel@tonic-gate if (prop_id == NULL) 21327c478bd9Sstevel@tonic-gate break; 21337c478bd9Sstevel@tonic-gate err = zonecfg_add_fs_option( 21347c478bd9Sstevel@tonic-gate &in_progress_fstab, prop_id); 21357c478bd9Sstevel@tonic-gate if (err != Z_OK) 21367c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), err, 21377c478bd9Sstevel@tonic-gate TRUE); 21387c478bd9Sstevel@tonic-gate } 21397c478bd9Sstevel@tonic-gate } 21407c478bd9Sstevel@tonic-gate return; 21417c478bd9Sstevel@tonic-gate case RT_RCTL: 21427c478bd9Sstevel@tonic-gate if (prop_type != PT_VALUE) { 21437c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 21447c478bd9Sstevel@tonic-gate TRUE); 21457c478bd9Sstevel@tonic-gate long_usage(CMD_ADD, TRUE); 21467c478bd9Sstevel@tonic-gate usage(FALSE, HELP_PROPS); 21477c478bd9Sstevel@tonic-gate return; 21487c478bd9Sstevel@tonic-gate } 21497c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[0]; 21507c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_COMPLEX && 21517c478bd9Sstevel@tonic-gate pp->pv_type != PROP_VAL_LIST) { 21527c478bd9Sstevel@tonic-gate zerr(gettext("A %s or %s value was expected here."), 21537c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_COMPLEX), 21547c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_LIST)); 21557c478bd9Sstevel@tonic-gate saw_error = TRUE; 21567c478bd9Sstevel@tonic-gate return; 21577c478bd9Sstevel@tonic-gate } 21587c478bd9Sstevel@tonic-gate if (pp->pv_type == PROP_VAL_COMPLEX) { 21597c478bd9Sstevel@tonic-gate do_complex_rctl_val(pp->pv_complex); 21607c478bd9Sstevel@tonic-gate return; 21617c478bd9Sstevel@tonic-gate } 21627c478bd9Sstevel@tonic-gate for (l = pp->pv_list; l != NULL; l = l->lp_next) 21637c478bd9Sstevel@tonic-gate do_complex_rctl_val(l->lp_complex); 21647c478bd9Sstevel@tonic-gate return; 21657c478bd9Sstevel@tonic-gate default: 21667c478bd9Sstevel@tonic-gate zone_perror(rt_to_str(res_type), Z_NO_RESOURCE_TYPE, TRUE); 21677c478bd9Sstevel@tonic-gate long_usage(CMD_ADD, TRUE); 21687c478bd9Sstevel@tonic-gate usage(FALSE, HELP_RESOURCES); 21697c478bd9Sstevel@tonic-gate return; 21707c478bd9Sstevel@tonic-gate } 21717c478bd9Sstevel@tonic-gate } 21727c478bd9Sstevel@tonic-gate 21730209230bSgjelinek static boolean_t 21740209230bSgjelinek gz_invalid_resource(int type) 21750209230bSgjelinek { 21760209230bSgjelinek return (global_zone && (type == RT_FS || type == RT_IPD || 21770209230bSgjelinek type == RT_NET || type == RT_DEVICE || type == RT_ATTR || 21780209230bSgjelinek type == RT_DATASET)); 21790209230bSgjelinek } 21800209230bSgjelinek 21810209230bSgjelinek static boolean_t 21820209230bSgjelinek gz_invalid_rt_property(int type) 21830209230bSgjelinek { 21840209230bSgjelinek return (global_zone && (type == RT_ZONENAME || type == RT_ZONEPATH || 21850209230bSgjelinek type == RT_AUTOBOOT || type == RT_LIMITPRIV || 2186*f4b3ec61Sdh type == RT_BOOTARGS || type == RT_BRAND || type == RT_SCHED || 2187*f4b3ec61Sdh type == RT_IPTYPE)); 21880209230bSgjelinek } 21890209230bSgjelinek 21900209230bSgjelinek static boolean_t 21910209230bSgjelinek gz_invalid_property(int type) 21920209230bSgjelinek { 21930209230bSgjelinek return (global_zone && (type == PT_ZONENAME || type == PT_ZONEPATH || 21940209230bSgjelinek type == PT_AUTOBOOT || type == PT_LIMITPRIV || 2195*f4b3ec61Sdh type == PT_BOOTARGS || type == PT_BRAND || type == PT_SCHED || 2196*f4b3ec61Sdh type == PT_IPTYPE)); 21970209230bSgjelinek } 21980209230bSgjelinek 21997c478bd9Sstevel@tonic-gate void 22007c478bd9Sstevel@tonic-gate add_func(cmd_t *cmd) 22017c478bd9Sstevel@tonic-gate { 22027c478bd9Sstevel@tonic-gate int arg; 22037c478bd9Sstevel@tonic-gate 22047c478bd9Sstevel@tonic-gate assert(cmd != NULL); 22057c478bd9Sstevel@tonic-gate 22067c478bd9Sstevel@tonic-gate optind = 0; 22077c478bd9Sstevel@tonic-gate if ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?")) != EOF) { 22087c478bd9Sstevel@tonic-gate switch (arg) { 22097c478bd9Sstevel@tonic-gate case '?': 22107c478bd9Sstevel@tonic-gate longer_usage(CMD_ADD); 22117c478bd9Sstevel@tonic-gate return; 22127c478bd9Sstevel@tonic-gate default: 22137c478bd9Sstevel@tonic-gate short_usage(CMD_ADD); 22147c478bd9Sstevel@tonic-gate return; 22157c478bd9Sstevel@tonic-gate } 22167c478bd9Sstevel@tonic-gate } 22177c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 22187c478bd9Sstevel@tonic-gate short_usage(CMD_ADD); 22197c478bd9Sstevel@tonic-gate return; 22207c478bd9Sstevel@tonic-gate } 22217c478bd9Sstevel@tonic-gate 22227c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_ADD)) 22237c478bd9Sstevel@tonic-gate return; 22247c478bd9Sstevel@tonic-gate 22257c478bd9Sstevel@tonic-gate if (initialize(TRUE) != Z_OK) 22267c478bd9Sstevel@tonic-gate return; 22277c478bd9Sstevel@tonic-gate if (global_scope) { 22280209230bSgjelinek if (gz_invalid_resource(cmd->cmd_res_type)) { 22290209230bSgjelinek zerr(gettext("Cannot add a %s resource to the " 22300209230bSgjelinek "global zone."), rt_to_str(cmd->cmd_res_type)); 22310209230bSgjelinek saw_error = TRUE; 22320209230bSgjelinek return; 22330209230bSgjelinek } 22340209230bSgjelinek 22357c478bd9Sstevel@tonic-gate global_scope = FALSE; 22367c478bd9Sstevel@tonic-gate resource_scope = cmd->cmd_res_type; 22377c478bd9Sstevel@tonic-gate end_op = CMD_ADD; 22387c478bd9Sstevel@tonic-gate add_resource(cmd); 22397c478bd9Sstevel@tonic-gate } else 22407c478bd9Sstevel@tonic-gate add_property(cmd); 22417c478bd9Sstevel@tonic-gate } 22427c478bd9Sstevel@tonic-gate 2243087719fdSdp /* 2244087719fdSdp * This routine has an unusual implementation, because it tries very 2245087719fdSdp * hard to succeed in the face of a variety of failure modes. 2246087719fdSdp * The most common and most vexing occurs when the index file and 2247087719fdSdp * the /etc/zones/<zonename.xml> file are not both present. In 2248087719fdSdp * this case, delete must eradicate as much of the zone state as is left 2249087719fdSdp * so that the user can later create a new zone with the same name. 2250087719fdSdp */ 22517c478bd9Sstevel@tonic-gate void 22527c478bd9Sstevel@tonic-gate delete_func(cmd_t *cmd) 22537c478bd9Sstevel@tonic-gate { 22547c478bd9Sstevel@tonic-gate int err, arg, answer; 22557c478bd9Sstevel@tonic-gate char line[ZONENAME_MAX + 128]; /* enough to ask a question */ 22567c478bd9Sstevel@tonic-gate bool force = FALSE; 22577c478bd9Sstevel@tonic-gate 22587c478bd9Sstevel@tonic-gate optind = 0; 22597c478bd9Sstevel@tonic-gate while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?F")) != EOF) { 22607c478bd9Sstevel@tonic-gate switch (arg) { 22617c478bd9Sstevel@tonic-gate case '?': 22627c478bd9Sstevel@tonic-gate longer_usage(CMD_DELETE); 22637c478bd9Sstevel@tonic-gate return; 22647c478bd9Sstevel@tonic-gate case 'F': 22657c478bd9Sstevel@tonic-gate force = TRUE; 22667c478bd9Sstevel@tonic-gate break; 22677c478bd9Sstevel@tonic-gate default: 22687c478bd9Sstevel@tonic-gate short_usage(CMD_DELETE); 22697c478bd9Sstevel@tonic-gate return; 22707c478bd9Sstevel@tonic-gate } 22717c478bd9Sstevel@tonic-gate } 22727c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 22737c478bd9Sstevel@tonic-gate short_usage(CMD_DELETE); 22747c478bd9Sstevel@tonic-gate return; 22757c478bd9Sstevel@tonic-gate } 22767c478bd9Sstevel@tonic-gate 22777c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_DELETE)) 22787c478bd9Sstevel@tonic-gate return; 22797c478bd9Sstevel@tonic-gate 22807c478bd9Sstevel@tonic-gate if (!force) { 2281087719fdSdp /* 2282087719fdSdp * Initialize sets up the global called "handle" and warns the 2283087719fdSdp * user if the zone is not configured. In force mode, we don't 2284087719fdSdp * trust that evaluation, and hence skip it. (We don't need the 2285087719fdSdp * handle to be loaded anyway, since zonecfg_destroy is done by 2286087719fdSdp * zonename). However, we also have to take care to emulate the 2287087719fdSdp * messages spit out by initialize; see below. 2288087719fdSdp */ 2289087719fdSdp if (initialize(TRUE) != Z_OK) 2290087719fdSdp return; 2291087719fdSdp 22927c478bd9Sstevel@tonic-gate (void) snprintf(line, sizeof (line), 22937c478bd9Sstevel@tonic-gate gettext("Are you sure you want to delete zone %s"), zone); 22947c478bd9Sstevel@tonic-gate if ((answer = ask_yesno(FALSE, line)) == -1) { 2295087719fdSdp zerr(gettext("Input not from terminal and -F not " 2296087719fdSdp "specified:\n%s command ignored, exiting."), 2297087719fdSdp cmd_to_str(CMD_DELETE)); 22987c478bd9Sstevel@tonic-gate exit(Z_ERR); 22997c478bd9Sstevel@tonic-gate } 23007c478bd9Sstevel@tonic-gate if (answer != 1) 23017c478bd9Sstevel@tonic-gate return; 23027c478bd9Sstevel@tonic-gate } 23037c478bd9Sstevel@tonic-gate 2304087719fdSdp if ((err = zonecfg_destroy(zone, force)) != Z_OK) { 2305087719fdSdp if ((err == Z_BAD_ZONE_STATE) && !force) { 2306087719fdSdp zerr(gettext("Zone %s not in %s state; %s not " 2307087719fdSdp "allowed. Use -F to force %s."), 2308087719fdSdp zone, zone_state_str(ZONE_STATE_CONFIGURED), 2309087719fdSdp cmd_to_str(CMD_DELETE), cmd_to_str(CMD_DELETE)); 2310087719fdSdp } else { 2311087719fdSdp zone_perror(zone, err, TRUE); 2312087719fdSdp } 23137c478bd9Sstevel@tonic-gate } 23147c478bd9Sstevel@tonic-gate need_to_commit = FALSE; 2315087719fdSdp 2316087719fdSdp /* 2317087719fdSdp * Emulate initialize's messaging; if there wasn't a valid handle to 2318087719fdSdp * begin with, then user had typed delete (or delete -F) multiple 2319087719fdSdp * times. So we emit a message. 2320087719fdSdp * 2321087719fdSdp * We only do this in the 'force' case because normally, initialize() 2322087719fdSdp * takes care of this for us. 2323087719fdSdp */ 2324087719fdSdp if (force && zonecfg_check_handle(handle) != Z_OK && interactive_mode) 2325087719fdSdp (void) printf(gettext("Use '%s' to begin " 2326087719fdSdp "configuring a new zone.\n"), cmd_to_str(CMD_CREATE)); 23277c478bd9Sstevel@tonic-gate 23287c478bd9Sstevel@tonic-gate /* 23297c478bd9Sstevel@tonic-gate * Time for a new handle: finish the old one off first 23307c478bd9Sstevel@tonic-gate * then get a new one properly to avoid leaks. 23317c478bd9Sstevel@tonic-gate */ 2332087719fdSdp if (got_handle) { 2333087719fdSdp zonecfg_fini_handle(handle); 2334087719fdSdp if ((handle = zonecfg_init_handle()) == NULL) { 2335087719fdSdp zone_perror(execname, Z_NOMEM, TRUE); 2336087719fdSdp exit(Z_ERR); 2337087719fdSdp } 2338087719fdSdp if ((err = zonecfg_get_handle(zone, handle)) != Z_OK) { 2339087719fdSdp /* If there was no zone before, that's OK */ 2340087719fdSdp if (err != Z_NO_ZONE) 2341087719fdSdp zone_perror(zone, err, TRUE); 2342087719fdSdp got_handle = FALSE; 2343087719fdSdp } 23447c478bd9Sstevel@tonic-gate } 23457c478bd9Sstevel@tonic-gate } 23467c478bd9Sstevel@tonic-gate 23477c478bd9Sstevel@tonic-gate static int 23487c478bd9Sstevel@tonic-gate fill_in_fstab(cmd_t *cmd, struct zone_fstab *fstab, bool fill_in_only) 23497c478bd9Sstevel@tonic-gate { 23507c478bd9Sstevel@tonic-gate int err, i; 23517c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 23527c478bd9Sstevel@tonic-gate 23537c478bd9Sstevel@tonic-gate if ((err = initialize(TRUE)) != Z_OK) 23547c478bd9Sstevel@tonic-gate return (err); 23557c478bd9Sstevel@tonic-gate 2356e193d1e6Svp bzero(fstab, sizeof (*fstab)); 23577c478bd9Sstevel@tonic-gate for (i = 0; i < cmd->cmd_prop_nv_pairs; i++) { 23587c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[i]; 23597c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE || pp->pv_simple == NULL) { 23607c478bd9Sstevel@tonic-gate zerr(gettext("A simple value was expected here.")); 23617c478bd9Sstevel@tonic-gate saw_error = TRUE; 23627c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 23637c478bd9Sstevel@tonic-gate } 23647c478bd9Sstevel@tonic-gate switch (cmd->cmd_prop_name[i]) { 23657c478bd9Sstevel@tonic-gate case PT_DIR: 23667c478bd9Sstevel@tonic-gate (void) strlcpy(fstab->zone_fs_dir, pp->pv_simple, 23677c478bd9Sstevel@tonic-gate sizeof (fstab->zone_fs_dir)); 23687c478bd9Sstevel@tonic-gate break; 23697c478bd9Sstevel@tonic-gate case PT_SPECIAL: 23707c478bd9Sstevel@tonic-gate (void) strlcpy(fstab->zone_fs_special, pp->pv_simple, 23717c478bd9Sstevel@tonic-gate sizeof (fstab->zone_fs_special)); 23727c478bd9Sstevel@tonic-gate break; 23737c478bd9Sstevel@tonic-gate case PT_RAW: 23747c478bd9Sstevel@tonic-gate (void) strlcpy(fstab->zone_fs_raw, pp->pv_simple, 23757c478bd9Sstevel@tonic-gate sizeof (fstab->zone_fs_raw)); 23767c478bd9Sstevel@tonic-gate break; 23777c478bd9Sstevel@tonic-gate case PT_TYPE: 23787c478bd9Sstevel@tonic-gate (void) strlcpy(fstab->zone_fs_type, pp->pv_simple, 23797c478bd9Sstevel@tonic-gate sizeof (fstab->zone_fs_type)); 23807c478bd9Sstevel@tonic-gate break; 23817c478bd9Sstevel@tonic-gate default: 23827c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(cmd->cmd_prop_name[i]), 23837c478bd9Sstevel@tonic-gate Z_NO_PROPERTY_TYPE, TRUE); 23847c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 23857c478bd9Sstevel@tonic-gate } 23867c478bd9Sstevel@tonic-gate } 23877c478bd9Sstevel@tonic-gate if (fill_in_only) 23887c478bd9Sstevel@tonic-gate return (Z_OK); 23897c478bd9Sstevel@tonic-gate return (zonecfg_lookup_filesystem(handle, fstab)); 23907c478bd9Sstevel@tonic-gate } 23917c478bd9Sstevel@tonic-gate 23927c478bd9Sstevel@tonic-gate static int 23937c478bd9Sstevel@tonic-gate fill_in_ipdtab(cmd_t *cmd, struct zone_fstab *ipdtab, bool fill_in_only) 23947c478bd9Sstevel@tonic-gate { 23957c478bd9Sstevel@tonic-gate int err, i; 23967c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 23977c478bd9Sstevel@tonic-gate 23987c478bd9Sstevel@tonic-gate if ((err = initialize(TRUE)) != Z_OK) 23997c478bd9Sstevel@tonic-gate return (err); 24007c478bd9Sstevel@tonic-gate 2401e193d1e6Svp bzero(ipdtab, sizeof (*ipdtab)); 24027c478bd9Sstevel@tonic-gate for (i = 0; i < cmd->cmd_prop_nv_pairs; i++) { 24037c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[i]; 24047c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE || pp->pv_simple == NULL) { 24057c478bd9Sstevel@tonic-gate zerr(gettext("A simple value was expected here.")); 24067c478bd9Sstevel@tonic-gate saw_error = TRUE; 24077c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 24087c478bd9Sstevel@tonic-gate } 24097c478bd9Sstevel@tonic-gate switch (cmd->cmd_prop_name[i]) { 24107c478bd9Sstevel@tonic-gate case PT_DIR: 24117c478bd9Sstevel@tonic-gate (void) strlcpy(ipdtab->zone_fs_dir, pp->pv_simple, 24127c478bd9Sstevel@tonic-gate sizeof (ipdtab->zone_fs_dir)); 24137c478bd9Sstevel@tonic-gate break; 24147c478bd9Sstevel@tonic-gate default: 24157c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(cmd->cmd_prop_name[i]), 24167c478bd9Sstevel@tonic-gate Z_NO_PROPERTY_TYPE, TRUE); 24177c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 24187c478bd9Sstevel@tonic-gate } 24197c478bd9Sstevel@tonic-gate } 24207c478bd9Sstevel@tonic-gate if (fill_in_only) 24217c478bd9Sstevel@tonic-gate return (Z_OK); 24227c478bd9Sstevel@tonic-gate return (zonecfg_lookup_ipd(handle, ipdtab)); 24237c478bd9Sstevel@tonic-gate } 24247c478bd9Sstevel@tonic-gate 24257c478bd9Sstevel@tonic-gate static int 24267c478bd9Sstevel@tonic-gate fill_in_nwiftab(cmd_t *cmd, struct zone_nwiftab *nwiftab, bool fill_in_only) 24277c478bd9Sstevel@tonic-gate { 24287c478bd9Sstevel@tonic-gate int err, i; 24297c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 24307c478bd9Sstevel@tonic-gate 24317c478bd9Sstevel@tonic-gate if ((err = initialize(TRUE)) != Z_OK) 24327c478bd9Sstevel@tonic-gate return (err); 24337c478bd9Sstevel@tonic-gate 2434e193d1e6Svp bzero(nwiftab, sizeof (*nwiftab)); 24357c478bd9Sstevel@tonic-gate for (i = 0; i < cmd->cmd_prop_nv_pairs; i++) { 24367c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[i]; 24377c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE || pp->pv_simple == NULL) { 24387c478bd9Sstevel@tonic-gate zerr(gettext("A simple value was expected here.")); 24397c478bd9Sstevel@tonic-gate saw_error = TRUE; 24407c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 24417c478bd9Sstevel@tonic-gate } 24427c478bd9Sstevel@tonic-gate switch (cmd->cmd_prop_name[i]) { 24437c478bd9Sstevel@tonic-gate case PT_ADDRESS: 24447c478bd9Sstevel@tonic-gate (void) strlcpy(nwiftab->zone_nwif_address, 24457c478bd9Sstevel@tonic-gate pp->pv_simple, sizeof (nwiftab->zone_nwif_address)); 24467c478bd9Sstevel@tonic-gate break; 24477c478bd9Sstevel@tonic-gate case PT_PHYSICAL: 24487c478bd9Sstevel@tonic-gate (void) strlcpy(nwiftab->zone_nwif_physical, 24497c478bd9Sstevel@tonic-gate pp->pv_simple, 24507c478bd9Sstevel@tonic-gate sizeof (nwiftab->zone_nwif_physical)); 24517c478bd9Sstevel@tonic-gate break; 24527c478bd9Sstevel@tonic-gate default: 24537c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(cmd->cmd_prop_name[i]), 24547c478bd9Sstevel@tonic-gate Z_NO_PROPERTY_TYPE, TRUE); 24557c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 24567c478bd9Sstevel@tonic-gate } 24577c478bd9Sstevel@tonic-gate } 24587c478bd9Sstevel@tonic-gate if (fill_in_only) 24597c478bd9Sstevel@tonic-gate return (Z_OK); 24607c478bd9Sstevel@tonic-gate err = zonecfg_lookup_nwif(handle, nwiftab); 24617c478bd9Sstevel@tonic-gate return (err); 24627c478bd9Sstevel@tonic-gate } 24637c478bd9Sstevel@tonic-gate 24647c478bd9Sstevel@tonic-gate static int 24657c478bd9Sstevel@tonic-gate fill_in_devtab(cmd_t *cmd, struct zone_devtab *devtab, bool fill_in_only) 24667c478bd9Sstevel@tonic-gate { 24677c478bd9Sstevel@tonic-gate int err, i; 24687c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 24697c478bd9Sstevel@tonic-gate 24707c478bd9Sstevel@tonic-gate if ((err = initialize(TRUE)) != Z_OK) 24717c478bd9Sstevel@tonic-gate return (err); 24727c478bd9Sstevel@tonic-gate 2473e193d1e6Svp bzero(devtab, sizeof (*devtab)); 24747c478bd9Sstevel@tonic-gate for (i = 0; i < cmd->cmd_prop_nv_pairs; i++) { 24757c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[i]; 24767c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE || pp->pv_simple == NULL) { 24777c478bd9Sstevel@tonic-gate zerr(gettext("A simple value was expected here.")); 24787c478bd9Sstevel@tonic-gate saw_error = TRUE; 24797c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 24807c478bd9Sstevel@tonic-gate } 24817c478bd9Sstevel@tonic-gate switch (cmd->cmd_prop_name[i]) { 24827c478bd9Sstevel@tonic-gate case PT_MATCH: 24837c478bd9Sstevel@tonic-gate (void) strlcpy(devtab->zone_dev_match, pp->pv_simple, 24847c478bd9Sstevel@tonic-gate sizeof (devtab->zone_dev_match)); 24857c478bd9Sstevel@tonic-gate break; 24867c478bd9Sstevel@tonic-gate default: 24877c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(cmd->cmd_prop_name[i]), 24887c478bd9Sstevel@tonic-gate Z_NO_PROPERTY_TYPE, TRUE); 24897c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 24907c478bd9Sstevel@tonic-gate } 24917c478bd9Sstevel@tonic-gate } 24927c478bd9Sstevel@tonic-gate if (fill_in_only) 24937c478bd9Sstevel@tonic-gate return (Z_OK); 24947c478bd9Sstevel@tonic-gate err = zonecfg_lookup_dev(handle, devtab); 24957c478bd9Sstevel@tonic-gate return (err); 24967c478bd9Sstevel@tonic-gate } 24977c478bd9Sstevel@tonic-gate 24987c478bd9Sstevel@tonic-gate static int 24997c478bd9Sstevel@tonic-gate fill_in_rctltab(cmd_t *cmd, struct zone_rctltab *rctltab, bool fill_in_only) 25007c478bd9Sstevel@tonic-gate { 25017c478bd9Sstevel@tonic-gate int err, i; 25027c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 25037c478bd9Sstevel@tonic-gate 25047c478bd9Sstevel@tonic-gate if ((err = initialize(TRUE)) != Z_OK) 25057c478bd9Sstevel@tonic-gate return (err); 25067c478bd9Sstevel@tonic-gate 2507e193d1e6Svp bzero(rctltab, sizeof (*rctltab)); 25087c478bd9Sstevel@tonic-gate for (i = 0; i < cmd->cmd_prop_nv_pairs; i++) { 25097c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[i]; 25107c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE || pp->pv_simple == NULL) { 25117c478bd9Sstevel@tonic-gate zerr(gettext("A simple value was expected here.")); 25127c478bd9Sstevel@tonic-gate saw_error = TRUE; 25137c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 25147c478bd9Sstevel@tonic-gate } 25157c478bd9Sstevel@tonic-gate switch (cmd->cmd_prop_name[i]) { 25167c478bd9Sstevel@tonic-gate case PT_NAME: 25177c478bd9Sstevel@tonic-gate (void) strlcpy(rctltab->zone_rctl_name, pp->pv_simple, 25187c478bd9Sstevel@tonic-gate sizeof (rctltab->zone_rctl_name)); 25197c478bd9Sstevel@tonic-gate break; 25207c478bd9Sstevel@tonic-gate default: 25217c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(cmd->cmd_prop_name[i]), 25227c478bd9Sstevel@tonic-gate Z_NO_PROPERTY_TYPE, TRUE); 25237c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 25247c478bd9Sstevel@tonic-gate } 25257c478bd9Sstevel@tonic-gate } 25267c478bd9Sstevel@tonic-gate if (fill_in_only) 25277c478bd9Sstevel@tonic-gate return (Z_OK); 25287c478bd9Sstevel@tonic-gate err = zonecfg_lookup_rctl(handle, rctltab); 25297c478bd9Sstevel@tonic-gate return (err); 25307c478bd9Sstevel@tonic-gate } 25317c478bd9Sstevel@tonic-gate 25327c478bd9Sstevel@tonic-gate static int 25337c478bd9Sstevel@tonic-gate fill_in_attrtab(cmd_t *cmd, struct zone_attrtab *attrtab, 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(attrtab, sizeof (*attrtab)); 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_NAME: 25517c478bd9Sstevel@tonic-gate (void) strlcpy(attrtab->zone_attr_name, pp->pv_simple, 25527c478bd9Sstevel@tonic-gate sizeof (attrtab->zone_attr_name)); 25537c478bd9Sstevel@tonic-gate break; 25547c478bd9Sstevel@tonic-gate case PT_TYPE: 25557c478bd9Sstevel@tonic-gate (void) strlcpy(attrtab->zone_attr_type, pp->pv_simple, 25567c478bd9Sstevel@tonic-gate sizeof (attrtab->zone_attr_type)); 25577c478bd9Sstevel@tonic-gate break; 25587c478bd9Sstevel@tonic-gate case PT_VALUE: 25597c478bd9Sstevel@tonic-gate (void) strlcpy(attrtab->zone_attr_value, pp->pv_simple, 25607c478bd9Sstevel@tonic-gate sizeof (attrtab->zone_attr_value)); 25617c478bd9Sstevel@tonic-gate break; 25627c478bd9Sstevel@tonic-gate default: 25637c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(cmd->cmd_prop_name[i]), 25647c478bd9Sstevel@tonic-gate Z_NO_PROPERTY_TYPE, TRUE); 25657c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 25667c478bd9Sstevel@tonic-gate } 25677c478bd9Sstevel@tonic-gate } 25687c478bd9Sstevel@tonic-gate if (fill_in_only) 25697c478bd9Sstevel@tonic-gate return (Z_OK); 25707c478bd9Sstevel@tonic-gate err = zonecfg_lookup_attr(handle, attrtab); 25717c478bd9Sstevel@tonic-gate return (err); 25727c478bd9Sstevel@tonic-gate } 25737c478bd9Sstevel@tonic-gate 2574fa9e4066Sahrens static int 2575fa9e4066Sahrens fill_in_dstab(cmd_t *cmd, struct zone_dstab *dstab, bool fill_in_only) 2576fa9e4066Sahrens { 2577fa9e4066Sahrens int err, i; 2578fa9e4066Sahrens property_value_ptr_t pp; 2579fa9e4066Sahrens 2580fa9e4066Sahrens if ((err = initialize(TRUE)) != Z_OK) 2581fa9e4066Sahrens return (err); 2582fa9e4066Sahrens 2583fa9e4066Sahrens dstab->zone_dataset_name[0] = '\0'; 2584fa9e4066Sahrens for (i = 0; i < cmd->cmd_prop_nv_pairs; i++) { 2585fa9e4066Sahrens pp = cmd->cmd_property_ptr[i]; 2586fa9e4066Sahrens if (pp->pv_type != PROP_VAL_SIMPLE || pp->pv_simple == NULL) { 2587fa9e4066Sahrens zerr(gettext("A simple value was expected here.")); 2588fa9e4066Sahrens saw_error = TRUE; 2589fa9e4066Sahrens return (Z_INSUFFICIENT_SPEC); 2590fa9e4066Sahrens } 2591fa9e4066Sahrens switch (cmd->cmd_prop_name[i]) { 2592fa9e4066Sahrens case PT_NAME: 2593fa9e4066Sahrens (void) strlcpy(dstab->zone_dataset_name, pp->pv_simple, 2594fa9e4066Sahrens sizeof (dstab->zone_dataset_name)); 2595fa9e4066Sahrens break; 2596fa9e4066Sahrens default: 2597fa9e4066Sahrens zone_perror(pt_to_str(cmd->cmd_prop_name[i]), 2598fa9e4066Sahrens Z_NO_PROPERTY_TYPE, TRUE); 2599fa9e4066Sahrens return (Z_INSUFFICIENT_SPEC); 2600fa9e4066Sahrens } 2601fa9e4066Sahrens } 2602fa9e4066Sahrens if (fill_in_only) 2603fa9e4066Sahrens return (Z_OK); 2604fa9e4066Sahrens return (zonecfg_lookup_ds(handle, dstab)); 2605fa9e4066Sahrens } 2606fa9e4066Sahrens 26077c478bd9Sstevel@tonic-gate static void 26080209230bSgjelinek remove_aliased_rctl(int type, char *name) 26097c478bd9Sstevel@tonic-gate { 26100209230bSgjelinek int err; 26110209230bSgjelinek uint64_t tmp; 26127c478bd9Sstevel@tonic-gate 26130209230bSgjelinek if ((err = zonecfg_get_aliased_rctl(handle, name, &tmp)) != Z_OK) { 26140209230bSgjelinek zerr("%s %s: %s", cmd_to_str(CMD_CLEAR), pt_to_str(type), 26150209230bSgjelinek zonecfg_strerror(err)); 26160209230bSgjelinek saw_error = TRUE; 26177c478bd9Sstevel@tonic-gate return; 26187c478bd9Sstevel@tonic-gate } 26190209230bSgjelinek if ((err = zonecfg_rm_aliased_rctl(handle, name)) != Z_OK) { 26200209230bSgjelinek zerr("%s %s: %s", cmd_to_str(CMD_CLEAR), pt_to_str(type), 26210209230bSgjelinek zonecfg_strerror(err)); 26220209230bSgjelinek saw_error = TRUE; 26230209230bSgjelinek } else { 26240209230bSgjelinek need_to_commit = TRUE; 26250209230bSgjelinek } 26260209230bSgjelinek } 26277c478bd9Sstevel@tonic-gate 26280209230bSgjelinek static boolean_t 26290209230bSgjelinek prompt_remove_resource(cmd_t *cmd, char *rsrc) 26300209230bSgjelinek { 26310209230bSgjelinek int num; 26320209230bSgjelinek int answer; 26330209230bSgjelinek int arg; 26340209230bSgjelinek boolean_t force = B_FALSE; 26350209230bSgjelinek char prompt[128]; 26360209230bSgjelinek 26370209230bSgjelinek optind = 0; 26380209230bSgjelinek while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "F")) != EOF) { 26390209230bSgjelinek switch (arg) { 26400209230bSgjelinek case 'F': 26410209230bSgjelinek force = B_TRUE; 26420209230bSgjelinek break; 26430209230bSgjelinek default: 26440209230bSgjelinek return (B_FALSE); 26450209230bSgjelinek } 26460209230bSgjelinek } 26470209230bSgjelinek 26480209230bSgjelinek num = zonecfg_num_resources(handle, rsrc); 26490209230bSgjelinek 26500209230bSgjelinek if (num == 0) { 26510209230bSgjelinek z_cmd_rt_perror(CMD_REMOVE, cmd->cmd_res_type, Z_NO_ENTRY, 26520209230bSgjelinek TRUE); 26530209230bSgjelinek return (B_FALSE); 26540209230bSgjelinek } 26550209230bSgjelinek if (num > 1 && !force) { 26560209230bSgjelinek if (!interactive_mode) { 26570209230bSgjelinek zerr(gettext("There are multiple instances of this " 26580209230bSgjelinek "resource. Either qualify the resource to\n" 26590209230bSgjelinek "remove a single instance or use the -F option to " 26600209230bSgjelinek "remove all instances.")); 26610209230bSgjelinek saw_error = TRUE; 26620209230bSgjelinek return (B_FALSE); 26630209230bSgjelinek } 26640209230bSgjelinek (void) snprintf(prompt, sizeof (prompt), gettext( 26650209230bSgjelinek "Are you sure you want to remove ALL '%s' resources"), 26660209230bSgjelinek rsrc); 26670209230bSgjelinek answer = ask_yesno(FALSE, prompt); 26680209230bSgjelinek if (answer == -1) { 26690209230bSgjelinek zerr(gettext("Resource incomplete.")); 26700209230bSgjelinek return (B_FALSE); 26710209230bSgjelinek } 26720209230bSgjelinek if (answer != 1) 26730209230bSgjelinek return (B_FALSE); 26740209230bSgjelinek } 26750209230bSgjelinek return (B_TRUE); 26760209230bSgjelinek } 26770209230bSgjelinek 26780209230bSgjelinek static void 26790209230bSgjelinek remove_fs(cmd_t *cmd) 26800209230bSgjelinek { 26810209230bSgjelinek int err; 26820209230bSgjelinek 26830209230bSgjelinek /* traditional, qualified fs removal */ 26840209230bSgjelinek if (cmd->cmd_prop_nv_pairs > 0) { 26850209230bSgjelinek struct zone_fstab fstab; 26867c478bd9Sstevel@tonic-gate 26877c478bd9Sstevel@tonic-gate if ((err = fill_in_fstab(cmd, &fstab, FALSE)) != Z_OK) { 26887c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_REMOVE, RT_FS, err, TRUE); 26897c478bd9Sstevel@tonic-gate return; 26907c478bd9Sstevel@tonic-gate } 26917c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_filesystem(handle, &fstab)) != Z_OK) 26927c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_REMOVE, RT_FS, err, TRUE); 26937c478bd9Sstevel@tonic-gate else 26947c478bd9Sstevel@tonic-gate need_to_commit = TRUE; 26957c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(fstab.zone_fs_options); 26967c478bd9Sstevel@tonic-gate return; 26970209230bSgjelinek } 26980209230bSgjelinek 26990209230bSgjelinek /* 27000209230bSgjelinek * unqualified fs removal. remove all fs's but prompt if more 27010209230bSgjelinek * than one. 27020209230bSgjelinek */ 27030209230bSgjelinek if (!prompt_remove_resource(cmd, "fs")) 27040209230bSgjelinek return; 27050209230bSgjelinek 27060209230bSgjelinek if ((err = zonecfg_del_all_resources(handle, "fs")) != Z_OK) 27070209230bSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_FS, err, TRUE); 27080209230bSgjelinek else 27090209230bSgjelinek need_to_commit = TRUE; 27100209230bSgjelinek } 27110209230bSgjelinek 27120209230bSgjelinek static void 27130209230bSgjelinek remove_ipd(cmd_t *cmd) 27140209230bSgjelinek { 27150209230bSgjelinek int err; 27160209230bSgjelinek 27170209230bSgjelinek if (state_atleast(ZONE_STATE_INSTALLED)) { 27180209230bSgjelinek zerr(gettext("Zone %s already installed; %s %s not allowed."), 27190209230bSgjelinek zone, cmd_to_str(CMD_REMOVE), rt_to_str(RT_IPD)); 27200209230bSgjelinek return; 27210209230bSgjelinek } 27220209230bSgjelinek 27230209230bSgjelinek /* traditional, qualified ipd removal */ 27240209230bSgjelinek if (cmd->cmd_prop_nv_pairs > 0) { 27250209230bSgjelinek struct zone_fstab fstab; 27260209230bSgjelinek 27277c478bd9Sstevel@tonic-gate if ((err = fill_in_ipdtab(cmd, &fstab, FALSE)) != Z_OK) { 27287c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_REMOVE, RT_IPD, err, TRUE); 27297c478bd9Sstevel@tonic-gate return; 27307c478bd9Sstevel@tonic-gate } 27317c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_ipd(handle, &fstab)) != Z_OK) 27327c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_REMOVE, RT_IPD, err, TRUE); 27337c478bd9Sstevel@tonic-gate else 27347c478bd9Sstevel@tonic-gate need_to_commit = TRUE; 27357c478bd9Sstevel@tonic-gate return; 27360209230bSgjelinek } 27370209230bSgjelinek 27380209230bSgjelinek /* 27390209230bSgjelinek * unqualified ipd removal. remove all ipds but prompt if more 27400209230bSgjelinek * than one. 27410209230bSgjelinek */ 27420209230bSgjelinek if (!prompt_remove_resource(cmd, "inherit-pkg-dir")) 27430209230bSgjelinek return; 27440209230bSgjelinek 27450209230bSgjelinek if ((err = zonecfg_del_all_resources(handle, "inherit-pkg-dir")) 27460209230bSgjelinek != Z_OK) 27470209230bSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_IPD, err, TRUE); 27480209230bSgjelinek else 27490209230bSgjelinek need_to_commit = TRUE; 27500209230bSgjelinek } 27510209230bSgjelinek 27520209230bSgjelinek static void 27530209230bSgjelinek remove_net(cmd_t *cmd) 27540209230bSgjelinek { 27550209230bSgjelinek int err; 27560209230bSgjelinek 27570209230bSgjelinek /* traditional, qualified net removal */ 27580209230bSgjelinek if (cmd->cmd_prop_nv_pairs > 0) { 27590209230bSgjelinek struct zone_nwiftab nwiftab; 27600209230bSgjelinek 27617c478bd9Sstevel@tonic-gate if ((err = fill_in_nwiftab(cmd, &nwiftab, FALSE)) != Z_OK) { 27627c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_REMOVE, RT_NET, err, TRUE); 27637c478bd9Sstevel@tonic-gate return; 27647c478bd9Sstevel@tonic-gate } 27657c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_nwif(handle, &nwiftab)) != Z_OK) 27667c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_REMOVE, RT_NET, err, TRUE); 27677c478bd9Sstevel@tonic-gate else 27687c478bd9Sstevel@tonic-gate need_to_commit = TRUE; 27697c478bd9Sstevel@tonic-gate return; 27700209230bSgjelinek } 27710209230bSgjelinek 27720209230bSgjelinek /* 27730209230bSgjelinek * unqualified net removal. remove all nets but prompt if more 27740209230bSgjelinek * than one. 27750209230bSgjelinek */ 27760209230bSgjelinek if (!prompt_remove_resource(cmd, "net")) 27770209230bSgjelinek return; 27780209230bSgjelinek 27790209230bSgjelinek if ((err = zonecfg_del_all_resources(handle, "net")) != Z_OK) 27800209230bSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_NET, err, TRUE); 27810209230bSgjelinek else 27820209230bSgjelinek need_to_commit = TRUE; 27830209230bSgjelinek } 27840209230bSgjelinek 27850209230bSgjelinek static void 27860209230bSgjelinek remove_device(cmd_t *cmd) 27870209230bSgjelinek { 27880209230bSgjelinek int err; 27890209230bSgjelinek 27900209230bSgjelinek /* traditional, qualified device removal */ 27910209230bSgjelinek if (cmd->cmd_prop_nv_pairs > 0) { 27920209230bSgjelinek struct zone_devtab devtab; 27930209230bSgjelinek 27947c478bd9Sstevel@tonic-gate if ((err = fill_in_devtab(cmd, &devtab, FALSE)) != Z_OK) { 27957c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_REMOVE, RT_DEVICE, err, TRUE); 27967c478bd9Sstevel@tonic-gate return; 27977c478bd9Sstevel@tonic-gate } 27987c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_dev(handle, &devtab)) != Z_OK) 27997c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_REMOVE, RT_DEVICE, err, TRUE); 28007c478bd9Sstevel@tonic-gate else 28017c478bd9Sstevel@tonic-gate need_to_commit = TRUE; 28027c478bd9Sstevel@tonic-gate return; 28030209230bSgjelinek } 28040209230bSgjelinek 28050209230bSgjelinek /* 28060209230bSgjelinek * unqualified device removal. remove all devices but prompt if more 28070209230bSgjelinek * than one. 28080209230bSgjelinek */ 28090209230bSgjelinek if (!prompt_remove_resource(cmd, "device")) 28107c478bd9Sstevel@tonic-gate return; 28110209230bSgjelinek 28120209230bSgjelinek if ((err = zonecfg_del_all_resources(handle, "device")) != Z_OK) 28130209230bSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_DEVICE, err, TRUE); 28140209230bSgjelinek else 28150209230bSgjelinek need_to_commit = TRUE; 28160209230bSgjelinek } 28170209230bSgjelinek 28180209230bSgjelinek static void 28190209230bSgjelinek remove_attr(cmd_t *cmd) 28200209230bSgjelinek { 28210209230bSgjelinek int err; 28220209230bSgjelinek 28230209230bSgjelinek /* traditional, qualified attr removal */ 28240209230bSgjelinek if (cmd->cmd_prop_nv_pairs > 0) { 28250209230bSgjelinek struct zone_attrtab attrtab; 28260209230bSgjelinek 28277c478bd9Sstevel@tonic-gate if ((err = fill_in_attrtab(cmd, &attrtab, FALSE)) != Z_OK) { 28287c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_REMOVE, RT_ATTR, err, TRUE); 28297c478bd9Sstevel@tonic-gate return; 28307c478bd9Sstevel@tonic-gate } 28317c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_attr(handle, &attrtab)) != Z_OK) 28327c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_REMOVE, RT_ATTR, err, TRUE); 28337c478bd9Sstevel@tonic-gate else 28347c478bd9Sstevel@tonic-gate need_to_commit = TRUE; 28357c478bd9Sstevel@tonic-gate return; 28360209230bSgjelinek } 28370209230bSgjelinek 28380209230bSgjelinek /* 28390209230bSgjelinek * unqualified attr removal. remove all attrs but prompt if more 28400209230bSgjelinek * than one. 28410209230bSgjelinek */ 28420209230bSgjelinek if (!prompt_remove_resource(cmd, "attr")) 28430209230bSgjelinek return; 28440209230bSgjelinek 28450209230bSgjelinek if ((err = zonecfg_del_all_resources(handle, "attr")) != Z_OK) 28460209230bSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_ATTR, err, TRUE); 28470209230bSgjelinek else 28480209230bSgjelinek need_to_commit = TRUE; 28490209230bSgjelinek } 28500209230bSgjelinek 28510209230bSgjelinek static void 28520209230bSgjelinek remove_dataset(cmd_t *cmd) 28530209230bSgjelinek { 28540209230bSgjelinek int err; 28550209230bSgjelinek 28560209230bSgjelinek /* traditional, qualified dataset removal */ 28570209230bSgjelinek if (cmd->cmd_prop_nv_pairs > 0) { 28580209230bSgjelinek struct zone_dstab dstab; 28590209230bSgjelinek 2860fa9e4066Sahrens if ((err = fill_in_dstab(cmd, &dstab, FALSE)) != Z_OK) { 2861fa9e4066Sahrens z_cmd_rt_perror(CMD_REMOVE, RT_DATASET, err, TRUE); 2862fa9e4066Sahrens return; 2863fa9e4066Sahrens } 2864fa9e4066Sahrens if ((err = zonecfg_delete_ds(handle, &dstab)) != Z_OK) 2865fa9e4066Sahrens z_cmd_rt_perror(CMD_REMOVE, RT_DATASET, err, TRUE); 2866fa9e4066Sahrens else 2867fa9e4066Sahrens need_to_commit = TRUE; 2868fa9e4066Sahrens return; 28697c478bd9Sstevel@tonic-gate } 28700209230bSgjelinek 28710209230bSgjelinek /* 28720209230bSgjelinek * unqualified dataset removal. remove all datasets but prompt if more 28730209230bSgjelinek * than one. 28740209230bSgjelinek */ 28750209230bSgjelinek if (!prompt_remove_resource(cmd, "dataset")) 28760209230bSgjelinek return; 28770209230bSgjelinek 28780209230bSgjelinek if ((err = zonecfg_del_all_resources(handle, "dataset")) != Z_OK) 28790209230bSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_DATASET, err, TRUE); 28800209230bSgjelinek else 28810209230bSgjelinek need_to_commit = TRUE; 28820209230bSgjelinek } 28830209230bSgjelinek 28840209230bSgjelinek static void 28850209230bSgjelinek remove_rctl(cmd_t *cmd) 28860209230bSgjelinek { 28870209230bSgjelinek int err; 28880209230bSgjelinek 28890209230bSgjelinek /* traditional, qualified rctl removal */ 28900209230bSgjelinek if (cmd->cmd_prop_nv_pairs > 0) { 28910209230bSgjelinek struct zone_rctltab rctltab; 28920209230bSgjelinek 28930209230bSgjelinek if ((err = fill_in_rctltab(cmd, &rctltab, FALSE)) != Z_OK) { 28940209230bSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_RCTL, err, TRUE); 28950209230bSgjelinek return; 28960209230bSgjelinek } 28970209230bSgjelinek if ((err = zonecfg_delete_rctl(handle, &rctltab)) != Z_OK) 28980209230bSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_RCTL, err, TRUE); 28990209230bSgjelinek else 29000209230bSgjelinek need_to_commit = TRUE; 29010209230bSgjelinek zonecfg_free_rctl_value_list(rctltab.zone_rctl_valptr); 29020209230bSgjelinek return; 29030209230bSgjelinek } 29040209230bSgjelinek 29050209230bSgjelinek /* 29060209230bSgjelinek * unqualified rctl removal. remove all rctls but prompt if more 29070209230bSgjelinek * than one. 29080209230bSgjelinek */ 29090209230bSgjelinek if (!prompt_remove_resource(cmd, "rctl")) 29100209230bSgjelinek return; 29110209230bSgjelinek 29120209230bSgjelinek if ((err = zonecfg_del_all_resources(handle, "rctl")) != Z_OK) 29130209230bSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_RCTL, err, TRUE); 29140209230bSgjelinek else 29150209230bSgjelinek need_to_commit = TRUE; 29160209230bSgjelinek } 29170209230bSgjelinek 29180209230bSgjelinek static void 29190209230bSgjelinek remove_pset() 29200209230bSgjelinek { 29210209230bSgjelinek int err; 29220209230bSgjelinek struct zone_psettab psettab; 29230209230bSgjelinek 29240209230bSgjelinek if ((err = zonecfg_lookup_pset(handle, &psettab)) != Z_OK) { 29250209230bSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_DCPU, err, TRUE); 29260209230bSgjelinek return; 29270209230bSgjelinek } 29280209230bSgjelinek if ((err = zonecfg_delete_pset(handle)) != Z_OK) 29290209230bSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_DCPU, err, TRUE); 29300209230bSgjelinek else 29310209230bSgjelinek need_to_commit = TRUE; 29320209230bSgjelinek } 29330209230bSgjelinek 29340209230bSgjelinek static void 29350209230bSgjelinek remove_mcap() 29360209230bSgjelinek { 29370209230bSgjelinek int err, res1, res2, res3; 29380209230bSgjelinek uint64_t tmp; 29390209230bSgjelinek struct zone_mcaptab mcaptab; 29400209230bSgjelinek boolean_t revert = B_FALSE; 29410209230bSgjelinek 29420209230bSgjelinek res1 = zonecfg_lookup_mcap(handle, &mcaptab); 29430209230bSgjelinek res2 = zonecfg_get_aliased_rctl(handle, ALIAS_MAXSWAP, &tmp); 29440209230bSgjelinek res3 = zonecfg_get_aliased_rctl(handle, ALIAS_MAXLOCKEDMEM, &tmp); 29450209230bSgjelinek 29460209230bSgjelinek /* if none of these exist, there is no resource to remove */ 29470209230bSgjelinek if (res1 != Z_OK && res2 != Z_OK && res3 != Z_OK) { 29480209230bSgjelinek zerr("%s %s: %s", cmd_to_str(CMD_REMOVE), rt_to_str(RT_MCAP), 29490209230bSgjelinek zonecfg_strerror(Z_NO_RESOURCE_TYPE)); 29500209230bSgjelinek saw_error = TRUE; 29510209230bSgjelinek return; 29520209230bSgjelinek } 29530209230bSgjelinek if (res1 == Z_OK) { 29540209230bSgjelinek if ((err = zonecfg_delete_mcap(handle)) != Z_OK) { 29550209230bSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_MCAP, err, TRUE); 29560209230bSgjelinek revert = B_TRUE; 29570209230bSgjelinek } else { 29580209230bSgjelinek need_to_commit = TRUE; 29590209230bSgjelinek } 29600209230bSgjelinek } 29610209230bSgjelinek if (res2 == Z_OK) { 29620209230bSgjelinek if ((err = zonecfg_rm_aliased_rctl(handle, ALIAS_MAXSWAP)) 29630209230bSgjelinek != Z_OK) { 29640209230bSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_MCAP, err, TRUE); 29650209230bSgjelinek revert = B_TRUE; 29660209230bSgjelinek } else { 29670209230bSgjelinek need_to_commit = TRUE; 29680209230bSgjelinek } 29690209230bSgjelinek } 29700209230bSgjelinek if (res3 == Z_OK) { 29710209230bSgjelinek if ((err = zonecfg_rm_aliased_rctl(handle, ALIAS_MAXLOCKEDMEM)) 29720209230bSgjelinek != Z_OK) { 29730209230bSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_MCAP, err, TRUE); 29740209230bSgjelinek revert = B_TRUE; 29750209230bSgjelinek } else { 29760209230bSgjelinek need_to_commit = TRUE; 29770209230bSgjelinek } 29780209230bSgjelinek } 29790209230bSgjelinek 29800209230bSgjelinek if (revert) 29810209230bSgjelinek need_to_commit = FALSE; 29820209230bSgjelinek } 29830209230bSgjelinek 29840209230bSgjelinek static void 29850209230bSgjelinek remove_resource(cmd_t *cmd) 29860209230bSgjelinek { 29870209230bSgjelinek int type; 29880209230bSgjelinek int arg; 29890209230bSgjelinek 29900209230bSgjelinek if ((type = cmd->cmd_res_type) == RT_UNKNOWN) { 29910209230bSgjelinek long_usage(CMD_REMOVE, TRUE); 29920209230bSgjelinek return; 29930209230bSgjelinek } 29940209230bSgjelinek 29950209230bSgjelinek optind = 0; 29960209230bSgjelinek while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?F")) != EOF) { 29970209230bSgjelinek switch (arg) { 29980209230bSgjelinek case '?': 29990209230bSgjelinek longer_usage(CMD_REMOVE); 30000209230bSgjelinek return; 30010209230bSgjelinek case 'F': 30020209230bSgjelinek break; 30030209230bSgjelinek default: 30040209230bSgjelinek short_usage(CMD_REMOVE); 30050209230bSgjelinek return; 30060209230bSgjelinek } 30070209230bSgjelinek } 30080209230bSgjelinek 30090209230bSgjelinek if (initialize(TRUE) != Z_OK) 30100209230bSgjelinek return; 30110209230bSgjelinek 30120209230bSgjelinek switch (type) { 30130209230bSgjelinek case RT_FS: 30140209230bSgjelinek remove_fs(cmd); 30150209230bSgjelinek return; 30160209230bSgjelinek case RT_IPD: 30170209230bSgjelinek remove_ipd(cmd); 30180209230bSgjelinek return; 30190209230bSgjelinek case RT_NET: 30200209230bSgjelinek remove_net(cmd); 30210209230bSgjelinek return; 30220209230bSgjelinek case RT_DEVICE: 30230209230bSgjelinek remove_device(cmd); 30240209230bSgjelinek return; 30250209230bSgjelinek case RT_RCTL: 30260209230bSgjelinek remove_rctl(cmd); 30270209230bSgjelinek return; 30280209230bSgjelinek case RT_ATTR: 30290209230bSgjelinek remove_attr(cmd); 30300209230bSgjelinek return; 30310209230bSgjelinek case RT_DATASET: 30320209230bSgjelinek remove_dataset(cmd); 30330209230bSgjelinek return; 30340209230bSgjelinek case RT_DCPU: 30350209230bSgjelinek remove_pset(); 30360209230bSgjelinek return; 30370209230bSgjelinek case RT_MCAP: 30380209230bSgjelinek remove_mcap(); 30390209230bSgjelinek return; 30400209230bSgjelinek default: 30410209230bSgjelinek zone_perror(rt_to_str(type), Z_NO_RESOURCE_TYPE, TRUE); 30420209230bSgjelinek long_usage(CMD_REMOVE, TRUE); 30430209230bSgjelinek usage(FALSE, HELP_RESOURCES); 30440209230bSgjelinek return; 30450209230bSgjelinek } 30460209230bSgjelinek } 30477c478bd9Sstevel@tonic-gate 30487c478bd9Sstevel@tonic-gate static void 30497c478bd9Sstevel@tonic-gate remove_property(cmd_t *cmd) 30507c478bd9Sstevel@tonic-gate { 30517c478bd9Sstevel@tonic-gate char *prop_id; 30527c478bd9Sstevel@tonic-gate int err, res_type, prop_type; 30537c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 30547c478bd9Sstevel@tonic-gate struct zone_rctlvaltab *rctlvaltab; 30557c478bd9Sstevel@tonic-gate complex_property_ptr_t cx; 30567c478bd9Sstevel@tonic-gate 30577c478bd9Sstevel@tonic-gate res_type = resource_scope; 30587c478bd9Sstevel@tonic-gate prop_type = cmd->cmd_prop_name[0]; 30597c478bd9Sstevel@tonic-gate if (res_type == RT_UNKNOWN || prop_type == PT_UNKNOWN) { 30607c478bd9Sstevel@tonic-gate long_usage(CMD_REMOVE, TRUE); 30617c478bd9Sstevel@tonic-gate return; 30627c478bd9Sstevel@tonic-gate } 30637c478bd9Sstevel@tonic-gate 30647c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs != 1) { 30657c478bd9Sstevel@tonic-gate long_usage(CMD_ADD, TRUE); 30667c478bd9Sstevel@tonic-gate return; 30677c478bd9Sstevel@tonic-gate } 30687c478bd9Sstevel@tonic-gate 30697c478bd9Sstevel@tonic-gate if (initialize(TRUE) != Z_OK) 30707c478bd9Sstevel@tonic-gate return; 30717c478bd9Sstevel@tonic-gate 30727c478bd9Sstevel@tonic-gate switch (res_type) { 30737c478bd9Sstevel@tonic-gate case RT_FS: 30747c478bd9Sstevel@tonic-gate if (prop_type != PT_OPTIONS) { 30757c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 30767c478bd9Sstevel@tonic-gate TRUE); 30777c478bd9Sstevel@tonic-gate long_usage(CMD_REMOVE, TRUE); 30787c478bd9Sstevel@tonic-gate usage(FALSE, HELP_PROPS); 30797c478bd9Sstevel@tonic-gate return; 30807c478bd9Sstevel@tonic-gate } 30817c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[0]; 30827c478bd9Sstevel@tonic-gate if (pp->pv_type == PROP_VAL_COMPLEX) { 30837c478bd9Sstevel@tonic-gate zerr(gettext("A %s or %s value was expected here."), 30847c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_SIMPLE), 30857c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_LIST)); 30867c478bd9Sstevel@tonic-gate saw_error = TRUE; 30877c478bd9Sstevel@tonic-gate return; 30887c478bd9Sstevel@tonic-gate } 30897c478bd9Sstevel@tonic-gate if (pp->pv_type == PROP_VAL_SIMPLE) { 30907c478bd9Sstevel@tonic-gate if (pp->pv_simple == NULL) { 30917c478bd9Sstevel@tonic-gate long_usage(CMD_ADD, TRUE); 30927c478bd9Sstevel@tonic-gate return; 30937c478bd9Sstevel@tonic-gate } 30947c478bd9Sstevel@tonic-gate prop_id = pp->pv_simple; 30957c478bd9Sstevel@tonic-gate err = zonecfg_remove_fs_option(&in_progress_fstab, 30967c478bd9Sstevel@tonic-gate prop_id); 30977c478bd9Sstevel@tonic-gate if (err != Z_OK) 30987c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), err, TRUE); 30997c478bd9Sstevel@tonic-gate } else { 31007c478bd9Sstevel@tonic-gate list_property_ptr_t list; 31017c478bd9Sstevel@tonic-gate 31027c478bd9Sstevel@tonic-gate for (list = pp->pv_list; list != NULL; 31037c478bd9Sstevel@tonic-gate list = list->lp_next) { 31047c478bd9Sstevel@tonic-gate prop_id = list->lp_simple; 31057c478bd9Sstevel@tonic-gate if (prop_id == NULL) 31067c478bd9Sstevel@tonic-gate break; 31077c478bd9Sstevel@tonic-gate err = zonecfg_remove_fs_option( 31087c478bd9Sstevel@tonic-gate &in_progress_fstab, prop_id); 31097c478bd9Sstevel@tonic-gate if (err != Z_OK) 31107c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), err, 31117c478bd9Sstevel@tonic-gate TRUE); 31127c478bd9Sstevel@tonic-gate } 31137c478bd9Sstevel@tonic-gate } 31147c478bd9Sstevel@tonic-gate return; 31157c478bd9Sstevel@tonic-gate case RT_RCTL: 31167c478bd9Sstevel@tonic-gate if (prop_type != PT_VALUE) { 31177c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 31187c478bd9Sstevel@tonic-gate TRUE); 31197c478bd9Sstevel@tonic-gate long_usage(CMD_REMOVE, TRUE); 31207c478bd9Sstevel@tonic-gate usage(FALSE, HELP_PROPS); 31217c478bd9Sstevel@tonic-gate return; 31227c478bd9Sstevel@tonic-gate } 31237c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[0]; 31247c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_COMPLEX) { 31257c478bd9Sstevel@tonic-gate zerr(gettext("A %s value was expected here."), 31267c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_COMPLEX)); 31277c478bd9Sstevel@tonic-gate saw_error = TRUE; 31287c478bd9Sstevel@tonic-gate return; 31297c478bd9Sstevel@tonic-gate } 31307c478bd9Sstevel@tonic-gate if ((rctlvaltab = alloc_rctlvaltab()) == NULL) { 31317c478bd9Sstevel@tonic-gate zone_perror(zone, Z_NOMEM, TRUE); 31327c478bd9Sstevel@tonic-gate exit(Z_ERR); 31337c478bd9Sstevel@tonic-gate } 31347c478bd9Sstevel@tonic-gate for (cx = pp->pv_complex; cx != NULL; cx = cx->cp_next) { 31357c478bd9Sstevel@tonic-gate switch (cx->cp_type) { 31367c478bd9Sstevel@tonic-gate case PT_PRIV: 31377c478bd9Sstevel@tonic-gate (void) strlcpy(rctlvaltab->zone_rctlval_priv, 31387c478bd9Sstevel@tonic-gate cx->cp_value, 31397c478bd9Sstevel@tonic-gate sizeof (rctlvaltab->zone_rctlval_priv)); 31407c478bd9Sstevel@tonic-gate break; 31417c478bd9Sstevel@tonic-gate case PT_LIMIT: 31427c478bd9Sstevel@tonic-gate (void) strlcpy(rctlvaltab->zone_rctlval_limit, 31437c478bd9Sstevel@tonic-gate cx->cp_value, 31447c478bd9Sstevel@tonic-gate sizeof (rctlvaltab->zone_rctlval_limit)); 31457c478bd9Sstevel@tonic-gate break; 31467c478bd9Sstevel@tonic-gate case PT_ACTION: 31477c478bd9Sstevel@tonic-gate (void) strlcpy(rctlvaltab->zone_rctlval_action, 31487c478bd9Sstevel@tonic-gate cx->cp_value, 31497c478bd9Sstevel@tonic-gate sizeof (rctlvaltab->zone_rctlval_action)); 31507c478bd9Sstevel@tonic-gate break; 31517c478bd9Sstevel@tonic-gate default: 31527c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), 31537c478bd9Sstevel@tonic-gate Z_NO_PROPERTY_TYPE, TRUE); 31547c478bd9Sstevel@tonic-gate long_usage(CMD_ADD, TRUE); 31557c478bd9Sstevel@tonic-gate usage(FALSE, HELP_PROPS); 31567c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctlvaltab); 31577c478bd9Sstevel@tonic-gate return; 31587c478bd9Sstevel@tonic-gate } 31597c478bd9Sstevel@tonic-gate } 31607c478bd9Sstevel@tonic-gate rctlvaltab->zone_rctlval_next = NULL; 31617c478bd9Sstevel@tonic-gate err = zonecfg_remove_rctl_value(&in_progress_rctltab, 31627c478bd9Sstevel@tonic-gate rctlvaltab); 31637c478bd9Sstevel@tonic-gate if (err != Z_OK) 31647c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), err, TRUE); 31657c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctlvaltab); 31667c478bd9Sstevel@tonic-gate return; 31677c478bd9Sstevel@tonic-gate default: 31687c478bd9Sstevel@tonic-gate zone_perror(rt_to_str(res_type), Z_NO_RESOURCE_TYPE, TRUE); 31697c478bd9Sstevel@tonic-gate long_usage(CMD_REMOVE, TRUE); 31707c478bd9Sstevel@tonic-gate usage(FALSE, HELP_RESOURCES); 31717c478bd9Sstevel@tonic-gate return; 31727c478bd9Sstevel@tonic-gate } 31737c478bd9Sstevel@tonic-gate } 31747c478bd9Sstevel@tonic-gate 31757c478bd9Sstevel@tonic-gate void 31767c478bd9Sstevel@tonic-gate remove_func(cmd_t *cmd) 31777c478bd9Sstevel@tonic-gate { 31787c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_REMOVE)) 31797c478bd9Sstevel@tonic-gate return; 31807c478bd9Sstevel@tonic-gate 31817c478bd9Sstevel@tonic-gate assert(cmd != NULL); 31827c478bd9Sstevel@tonic-gate 31830209230bSgjelinek if (global_scope) { 31840209230bSgjelinek if (gz_invalid_resource(cmd->cmd_res_type)) { 31850209230bSgjelinek zerr(gettext("%s is not a valid resource for the " 31860209230bSgjelinek "global zone."), rt_to_str(cmd->cmd_res_type)); 31870209230bSgjelinek saw_error = TRUE; 31880209230bSgjelinek return; 31890209230bSgjelinek } 31907c478bd9Sstevel@tonic-gate remove_resource(cmd); 31910209230bSgjelinek } else { 31927c478bd9Sstevel@tonic-gate remove_property(cmd); 31930209230bSgjelinek } 31940209230bSgjelinek } 31950209230bSgjelinek 31960209230bSgjelinek static void 31970209230bSgjelinek clear_property(cmd_t *cmd) 31980209230bSgjelinek { 31990209230bSgjelinek int res_type, prop_type; 32000209230bSgjelinek 32010209230bSgjelinek res_type = resource_scope; 32020209230bSgjelinek prop_type = cmd->cmd_res_type; 32030209230bSgjelinek if (res_type == RT_UNKNOWN || prop_type == PT_UNKNOWN) { 32040209230bSgjelinek long_usage(CMD_CLEAR, TRUE); 32050209230bSgjelinek return; 32060209230bSgjelinek } 32070209230bSgjelinek 32080209230bSgjelinek if (initialize(TRUE) != Z_OK) 32090209230bSgjelinek return; 32100209230bSgjelinek 32110209230bSgjelinek switch (res_type) { 32120209230bSgjelinek case RT_FS: 32130209230bSgjelinek if (prop_type == PT_RAW) { 32140209230bSgjelinek in_progress_fstab.zone_fs_raw[0] = '\0'; 32150209230bSgjelinek need_to_commit = TRUE; 32160209230bSgjelinek return; 32170209230bSgjelinek } 32180209230bSgjelinek break; 32190209230bSgjelinek case RT_DCPU: 32200209230bSgjelinek if (prop_type == PT_IMPORTANCE) { 32210209230bSgjelinek in_progress_psettab.zone_importance[0] = '\0'; 32220209230bSgjelinek need_to_commit = TRUE; 32230209230bSgjelinek return; 32240209230bSgjelinek } 32250209230bSgjelinek break; 32260209230bSgjelinek case RT_MCAP: 32270209230bSgjelinek switch (prop_type) { 32280209230bSgjelinek case PT_PHYSICAL: 32290209230bSgjelinek in_progress_mcaptab.zone_physmem_cap[0] = '\0'; 32300209230bSgjelinek need_to_commit = TRUE; 32310209230bSgjelinek return; 32320209230bSgjelinek case PT_SWAP: 32330209230bSgjelinek remove_aliased_rctl(PT_SWAP, ALIAS_MAXSWAP); 32340209230bSgjelinek return; 32350209230bSgjelinek case PT_LOCKED: 32360209230bSgjelinek remove_aliased_rctl(PT_LOCKED, ALIAS_MAXLOCKEDMEM); 32370209230bSgjelinek return; 32380209230bSgjelinek } 32390209230bSgjelinek break; 32400209230bSgjelinek default: 32410209230bSgjelinek break; 32420209230bSgjelinek } 32430209230bSgjelinek 32440209230bSgjelinek zone_perror(pt_to_str(prop_type), Z_CLEAR_DISALLOW, TRUE); 32450209230bSgjelinek } 32460209230bSgjelinek 32470209230bSgjelinek static void 32480209230bSgjelinek clear_global(cmd_t *cmd) 32490209230bSgjelinek { 32500209230bSgjelinek int err, type; 32510209230bSgjelinek 32520209230bSgjelinek if ((type = cmd->cmd_res_type) == RT_UNKNOWN) { 32530209230bSgjelinek long_usage(CMD_CLEAR, TRUE); 32540209230bSgjelinek return; 32550209230bSgjelinek } 32560209230bSgjelinek 32570209230bSgjelinek if (initialize(TRUE) != Z_OK) 32580209230bSgjelinek return; 32590209230bSgjelinek 32600209230bSgjelinek switch (type) { 32610209230bSgjelinek case PT_ZONENAME: 32620209230bSgjelinek /* FALLTHRU */ 32630209230bSgjelinek case PT_ZONEPATH: 32640209230bSgjelinek /* FALLTHRU */ 32650209230bSgjelinek case PT_BRAND: 32660209230bSgjelinek zone_perror(pt_to_str(type), Z_CLEAR_DISALLOW, TRUE); 32670209230bSgjelinek return; 32680209230bSgjelinek case PT_AUTOBOOT: 32690209230bSgjelinek /* false is default; we'll treat as equivalent to clearing */ 32700209230bSgjelinek if ((err = zonecfg_set_autoboot(handle, B_FALSE)) != Z_OK) 32710209230bSgjelinek z_cmd_rt_perror(CMD_CLEAR, RT_AUTOBOOT, err, TRUE); 32720209230bSgjelinek else 32730209230bSgjelinek need_to_commit = TRUE; 32740209230bSgjelinek return; 32750209230bSgjelinek case PT_POOL: 32760209230bSgjelinek if ((err = zonecfg_set_pool(handle, NULL)) != Z_OK) 32770209230bSgjelinek z_cmd_rt_perror(CMD_CLEAR, RT_POOL, err, TRUE); 32780209230bSgjelinek else 32790209230bSgjelinek need_to_commit = TRUE; 32800209230bSgjelinek return; 32810209230bSgjelinek case PT_LIMITPRIV: 32820209230bSgjelinek if ((err = zonecfg_set_limitpriv(handle, NULL)) != Z_OK) 32830209230bSgjelinek z_cmd_rt_perror(CMD_CLEAR, RT_LIMITPRIV, err, TRUE); 32840209230bSgjelinek else 32850209230bSgjelinek need_to_commit = TRUE; 32860209230bSgjelinek return; 32870209230bSgjelinek case PT_BOOTARGS: 32880209230bSgjelinek if ((err = zonecfg_set_bootargs(handle, NULL)) != Z_OK) 32890209230bSgjelinek z_cmd_rt_perror(CMD_CLEAR, RT_BOOTARGS, err, TRUE); 32900209230bSgjelinek else 32910209230bSgjelinek need_to_commit = TRUE; 32920209230bSgjelinek return; 32930209230bSgjelinek case PT_SCHED: 32940209230bSgjelinek if ((err = zonecfg_set_sched(handle, NULL)) != Z_OK) 32950209230bSgjelinek z_cmd_rt_perror(CMD_CLEAR, RT_SCHED, err, TRUE); 32960209230bSgjelinek else 32970209230bSgjelinek need_to_commit = TRUE; 32980209230bSgjelinek return; 3299*f4b3ec61Sdh case PT_IPTYPE: 3300*f4b3ec61Sdh /* shared is default; we'll treat as equivalent to clearing */ 3301*f4b3ec61Sdh if ((err = zonecfg_set_iptype(handle, ZS_SHARED)) != Z_OK) 3302*f4b3ec61Sdh z_cmd_rt_perror(CMD_CLEAR, RT_IPTYPE, err, TRUE); 3303*f4b3ec61Sdh else 3304*f4b3ec61Sdh need_to_commit = TRUE; 3305*f4b3ec61Sdh return; 33060209230bSgjelinek case PT_MAXLWPS: 33070209230bSgjelinek remove_aliased_rctl(PT_MAXLWPS, ALIAS_MAXLWPS); 33080209230bSgjelinek return; 33090209230bSgjelinek case PT_MAXSHMMEM: 33100209230bSgjelinek remove_aliased_rctl(PT_MAXSHMMEM, ALIAS_MAXSHMMEM); 33110209230bSgjelinek return; 33120209230bSgjelinek case PT_MAXSHMIDS: 33130209230bSgjelinek remove_aliased_rctl(PT_MAXSHMIDS, ALIAS_MAXSHMIDS); 33140209230bSgjelinek return; 33150209230bSgjelinek case PT_MAXMSGIDS: 33160209230bSgjelinek remove_aliased_rctl(PT_MAXMSGIDS, ALIAS_MAXMSGIDS); 33170209230bSgjelinek return; 33180209230bSgjelinek case PT_MAXSEMIDS: 33190209230bSgjelinek remove_aliased_rctl(PT_MAXSEMIDS, ALIAS_MAXSEMIDS); 33200209230bSgjelinek return; 33210209230bSgjelinek case PT_SHARES: 33220209230bSgjelinek remove_aliased_rctl(PT_SHARES, ALIAS_SHARES); 33230209230bSgjelinek return; 33240209230bSgjelinek default: 33250209230bSgjelinek zone_perror(pt_to_str(type), Z_NO_PROPERTY_TYPE, TRUE); 33260209230bSgjelinek long_usage(CMD_CLEAR, TRUE); 33270209230bSgjelinek usage(FALSE, HELP_PROPS); 33280209230bSgjelinek return; 33290209230bSgjelinek } 33300209230bSgjelinek } 33310209230bSgjelinek 33320209230bSgjelinek void 33330209230bSgjelinek clear_func(cmd_t *cmd) 33340209230bSgjelinek { 33350209230bSgjelinek if (zone_is_read_only(CMD_CLEAR)) 33360209230bSgjelinek return; 33370209230bSgjelinek 33380209230bSgjelinek assert(cmd != NULL); 33390209230bSgjelinek 33400209230bSgjelinek if (global_scope) { 33410209230bSgjelinek if (gz_invalid_property(cmd->cmd_res_type)) { 33420209230bSgjelinek zerr(gettext("%s is not a valid property for the " 33430209230bSgjelinek "global zone."), pt_to_str(cmd->cmd_res_type)); 33440209230bSgjelinek saw_error = TRUE; 33450209230bSgjelinek return; 33460209230bSgjelinek } 33470209230bSgjelinek 33480209230bSgjelinek clear_global(cmd); 33490209230bSgjelinek } else { 33500209230bSgjelinek clear_property(cmd); 33510209230bSgjelinek } 33527c478bd9Sstevel@tonic-gate } 33537c478bd9Sstevel@tonic-gate 33547c478bd9Sstevel@tonic-gate void 33557c478bd9Sstevel@tonic-gate select_func(cmd_t *cmd) 33567c478bd9Sstevel@tonic-gate { 33570209230bSgjelinek int type, err, res; 33580209230bSgjelinek uint64_t limit; 33597c478bd9Sstevel@tonic-gate 33607c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_SELECT)) 33617c478bd9Sstevel@tonic-gate return; 33627c478bd9Sstevel@tonic-gate 33637c478bd9Sstevel@tonic-gate assert(cmd != NULL); 33647c478bd9Sstevel@tonic-gate 33657c478bd9Sstevel@tonic-gate if (global_scope) { 33667c478bd9Sstevel@tonic-gate global_scope = FALSE; 33677c478bd9Sstevel@tonic-gate resource_scope = cmd->cmd_res_type; 33687c478bd9Sstevel@tonic-gate end_op = CMD_SELECT; 33697c478bd9Sstevel@tonic-gate } else { 33707c478bd9Sstevel@tonic-gate scope_usage(CMD_SELECT); 33717c478bd9Sstevel@tonic-gate return; 33727c478bd9Sstevel@tonic-gate } 33737c478bd9Sstevel@tonic-gate 33747c478bd9Sstevel@tonic-gate if ((type = cmd->cmd_res_type) == RT_UNKNOWN) { 33757c478bd9Sstevel@tonic-gate long_usage(CMD_SELECT, TRUE); 33767c478bd9Sstevel@tonic-gate return; 33777c478bd9Sstevel@tonic-gate } 33787c478bd9Sstevel@tonic-gate 33797c478bd9Sstevel@tonic-gate if (initialize(TRUE) != Z_OK) 33807c478bd9Sstevel@tonic-gate return; 33817c478bd9Sstevel@tonic-gate 33827c478bd9Sstevel@tonic-gate switch (type) { 33837c478bd9Sstevel@tonic-gate case RT_FS: 33847c478bd9Sstevel@tonic-gate if ((err = fill_in_fstab(cmd, &old_fstab, FALSE)) != Z_OK) { 33857c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_SELECT, RT_FS, err, TRUE); 33867c478bd9Sstevel@tonic-gate global_scope = TRUE; 33877c478bd9Sstevel@tonic-gate } 33887c478bd9Sstevel@tonic-gate bcopy(&old_fstab, &in_progress_fstab, 33897c478bd9Sstevel@tonic-gate sizeof (struct zone_fstab)); 33907c478bd9Sstevel@tonic-gate return; 33917c478bd9Sstevel@tonic-gate case RT_IPD: 3392087719fdSdp if (state_atleast(ZONE_STATE_INCOMPLETE)) { 33937c478bd9Sstevel@tonic-gate zerr(gettext("Zone %s not in %s state; %s %s not " 33947c478bd9Sstevel@tonic-gate "allowed."), zone, 33957c478bd9Sstevel@tonic-gate zone_state_str(ZONE_STATE_CONFIGURED), 33967c478bd9Sstevel@tonic-gate cmd_to_str(CMD_SELECT), rt_to_str(RT_IPD)); 33977c478bd9Sstevel@tonic-gate global_scope = TRUE; 33987c478bd9Sstevel@tonic-gate end_op = -1; 33997c478bd9Sstevel@tonic-gate return; 34007c478bd9Sstevel@tonic-gate } 34017c478bd9Sstevel@tonic-gate if ((err = fill_in_ipdtab(cmd, &old_ipdtab, FALSE)) != Z_OK) { 34027c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_SELECT, RT_IPD, err, TRUE); 34037c478bd9Sstevel@tonic-gate global_scope = TRUE; 34047c478bd9Sstevel@tonic-gate } 34057c478bd9Sstevel@tonic-gate bcopy(&old_ipdtab, &in_progress_ipdtab, 34067c478bd9Sstevel@tonic-gate sizeof (struct zone_fstab)); 34077c478bd9Sstevel@tonic-gate return; 34087c478bd9Sstevel@tonic-gate case RT_NET: 34097c478bd9Sstevel@tonic-gate if ((err = fill_in_nwiftab(cmd, &old_nwiftab, FALSE)) != Z_OK) { 34107c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_SELECT, RT_NET, err, TRUE); 34117c478bd9Sstevel@tonic-gate global_scope = TRUE; 34127c478bd9Sstevel@tonic-gate } 34137c478bd9Sstevel@tonic-gate bcopy(&old_nwiftab, &in_progress_nwiftab, 34147c478bd9Sstevel@tonic-gate sizeof (struct zone_nwiftab)); 34157c478bd9Sstevel@tonic-gate return; 34167c478bd9Sstevel@tonic-gate case RT_DEVICE: 34177c478bd9Sstevel@tonic-gate if ((err = fill_in_devtab(cmd, &old_devtab, FALSE)) != Z_OK) { 34187c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_SELECT, RT_DEVICE, err, TRUE); 34197c478bd9Sstevel@tonic-gate global_scope = TRUE; 34207c478bd9Sstevel@tonic-gate } 34217c478bd9Sstevel@tonic-gate bcopy(&old_devtab, &in_progress_devtab, 34227c478bd9Sstevel@tonic-gate sizeof (struct zone_devtab)); 34237c478bd9Sstevel@tonic-gate return; 34247c478bd9Sstevel@tonic-gate case RT_RCTL: 34257c478bd9Sstevel@tonic-gate if ((err = fill_in_rctltab(cmd, &old_rctltab, FALSE)) != Z_OK) { 34267c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_SELECT, RT_RCTL, err, TRUE); 34277c478bd9Sstevel@tonic-gate global_scope = TRUE; 34287c478bd9Sstevel@tonic-gate } 34297c478bd9Sstevel@tonic-gate bcopy(&old_rctltab, &in_progress_rctltab, 34307c478bd9Sstevel@tonic-gate sizeof (struct zone_rctltab)); 34317c478bd9Sstevel@tonic-gate return; 34327c478bd9Sstevel@tonic-gate case RT_ATTR: 34337c478bd9Sstevel@tonic-gate if ((err = fill_in_attrtab(cmd, &old_attrtab, FALSE)) != Z_OK) { 34347c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_SELECT, RT_ATTR, err, TRUE); 34357c478bd9Sstevel@tonic-gate global_scope = TRUE; 34367c478bd9Sstevel@tonic-gate } 34377c478bd9Sstevel@tonic-gate bcopy(&old_attrtab, &in_progress_attrtab, 34387c478bd9Sstevel@tonic-gate sizeof (struct zone_attrtab)); 34397c478bd9Sstevel@tonic-gate return; 3440fa9e4066Sahrens case RT_DATASET: 3441fa9e4066Sahrens if ((err = fill_in_dstab(cmd, &old_dstab, FALSE)) != Z_OK) { 3442fa9e4066Sahrens z_cmd_rt_perror(CMD_SELECT, RT_DATASET, err, TRUE); 3443fa9e4066Sahrens global_scope = TRUE; 3444fa9e4066Sahrens } 3445fa9e4066Sahrens bcopy(&old_dstab, &in_progress_dstab, 3446fa9e4066Sahrens sizeof (struct zone_dstab)); 3447fa9e4066Sahrens return; 34480209230bSgjelinek case RT_DCPU: 34490209230bSgjelinek if ((err = zonecfg_lookup_pset(handle, &old_psettab)) != Z_OK) { 34500209230bSgjelinek z_cmd_rt_perror(CMD_SELECT, RT_DCPU, err, TRUE); 34510209230bSgjelinek global_scope = TRUE; 34520209230bSgjelinek } 34530209230bSgjelinek bcopy(&old_psettab, &in_progress_psettab, 34540209230bSgjelinek sizeof (struct zone_psettab)); 34550209230bSgjelinek return; 34560209230bSgjelinek case RT_MCAP: 34570209230bSgjelinek /* if none of these exist, there is no resource to select */ 34580209230bSgjelinek if ((res = zonecfg_lookup_mcap(handle, &old_mcaptab)) != Z_OK && 34590209230bSgjelinek zonecfg_get_aliased_rctl(handle, ALIAS_MAXSWAP, &limit) 34600209230bSgjelinek != Z_OK && 34610209230bSgjelinek zonecfg_get_aliased_rctl(handle, ALIAS_MAXLOCKEDMEM, &limit) 34620209230bSgjelinek != Z_OK) { 34630209230bSgjelinek z_cmd_rt_perror(CMD_SELECT, RT_MCAP, Z_NO_RESOURCE_TYPE, 34640209230bSgjelinek TRUE); 34650209230bSgjelinek global_scope = TRUE; 34660209230bSgjelinek } 34670209230bSgjelinek if (res == Z_OK) 34680209230bSgjelinek bcopy(&old_mcaptab, &in_progress_mcaptab, 34690209230bSgjelinek sizeof (struct zone_mcaptab)); 34700209230bSgjelinek else 34710209230bSgjelinek bzero(&in_progress_mcaptab, 34720209230bSgjelinek sizeof (in_progress_mcaptab)); 34730209230bSgjelinek return; 34747c478bd9Sstevel@tonic-gate default: 34757c478bd9Sstevel@tonic-gate zone_perror(rt_to_str(type), Z_NO_RESOURCE_TYPE, TRUE); 34767c478bd9Sstevel@tonic-gate long_usage(CMD_SELECT, TRUE); 34777c478bd9Sstevel@tonic-gate usage(FALSE, HELP_RESOURCES); 34787c478bd9Sstevel@tonic-gate return; 34797c478bd9Sstevel@tonic-gate } 34807c478bd9Sstevel@tonic-gate } 34817c478bd9Sstevel@tonic-gate 34827c478bd9Sstevel@tonic-gate /* 34837c478bd9Sstevel@tonic-gate * Network "addresses" can be one of the following forms: 34847c478bd9Sstevel@tonic-gate * <IPv4 address> 34857c478bd9Sstevel@tonic-gate * <IPv4 address>/<prefix length> 34867c478bd9Sstevel@tonic-gate * <IPv6 address>/<prefix length> 34877c478bd9Sstevel@tonic-gate * <host name> 34887c478bd9Sstevel@tonic-gate * <host name>/<prefix length> 34897c478bd9Sstevel@tonic-gate * In other words, the "/" followed by a prefix length is allowed but not 34907c478bd9Sstevel@tonic-gate * required for IPv4 addresses and host names, and required for IPv6 addresses. 34917c478bd9Sstevel@tonic-gate * If a prefix length is given, it must be in the allowable range: 0 to 32 for 34927c478bd9Sstevel@tonic-gate * IPv4 addresses and host names, 0 to 128 for IPv6 addresses. 34937c478bd9Sstevel@tonic-gate * Host names must start with an alpha-numeric character, and all subsequent 34947c478bd9Sstevel@tonic-gate * characters must be either alpha-numeric or "-". 34957c478bd9Sstevel@tonic-gate */ 34967c478bd9Sstevel@tonic-gate 34977c478bd9Sstevel@tonic-gate static int 34987c478bd9Sstevel@tonic-gate validate_net_address_syntax(char *address) 34997c478bd9Sstevel@tonic-gate { 35007c478bd9Sstevel@tonic-gate char *slashp, part1[MAXHOSTNAMELEN]; 35017c478bd9Sstevel@tonic-gate struct in6_addr in6; 35027c478bd9Sstevel@tonic-gate struct in_addr in4; 35037c478bd9Sstevel@tonic-gate int prefixlen, i; 35047c478bd9Sstevel@tonic-gate 35057c478bd9Sstevel@tonic-gate /* 35067c478bd9Sstevel@tonic-gate * Copy the part before any '/' into part1 or copy the whole 35077c478bd9Sstevel@tonic-gate * thing if there is no '/'. 35087c478bd9Sstevel@tonic-gate */ 35097c478bd9Sstevel@tonic-gate if ((slashp = strchr(address, '/')) != NULL) { 35107c478bd9Sstevel@tonic-gate *slashp = '\0'; 35117c478bd9Sstevel@tonic-gate (void) strlcpy(part1, address, sizeof (part1)); 35127c478bd9Sstevel@tonic-gate *slashp = '/'; 35137c478bd9Sstevel@tonic-gate prefixlen = atoi(++slashp); 35147c478bd9Sstevel@tonic-gate } else { 35157c478bd9Sstevel@tonic-gate (void) strlcpy(part1, address, sizeof (part1)); 35167c478bd9Sstevel@tonic-gate } 35177c478bd9Sstevel@tonic-gate 35187c478bd9Sstevel@tonic-gate if (inet_pton(AF_INET6, part1, &in6) == 1) { 35197c478bd9Sstevel@tonic-gate if (slashp == NULL) { 35207c478bd9Sstevel@tonic-gate zerr(gettext("%s: IPv6 addresses " 35217c478bd9Sstevel@tonic-gate "require /prefix-length suffix."), address); 35227c478bd9Sstevel@tonic-gate return (Z_ERR); 35237c478bd9Sstevel@tonic-gate } 35247c478bd9Sstevel@tonic-gate if (prefixlen < 0 || prefixlen > 128) { 35257c478bd9Sstevel@tonic-gate zerr(gettext("%s: IPv6 address " 35267c478bd9Sstevel@tonic-gate "prefix lengths must be 0 - 128."), address); 35277c478bd9Sstevel@tonic-gate return (Z_ERR); 35287c478bd9Sstevel@tonic-gate } 35297c478bd9Sstevel@tonic-gate return (Z_OK); 35307c478bd9Sstevel@tonic-gate } 35317c478bd9Sstevel@tonic-gate 35327c478bd9Sstevel@tonic-gate /* At this point, any /prefix must be for IPv4. */ 35337c478bd9Sstevel@tonic-gate if (slashp != NULL) { 35347c478bd9Sstevel@tonic-gate if (prefixlen < 0 || prefixlen > 32) { 35357c478bd9Sstevel@tonic-gate zerr(gettext("%s: IPv4 address " 35367c478bd9Sstevel@tonic-gate "prefix lengths must be 0 - 32."), address); 35377c478bd9Sstevel@tonic-gate return (Z_ERR); 35387c478bd9Sstevel@tonic-gate } 35397c478bd9Sstevel@tonic-gate } 35407c478bd9Sstevel@tonic-gate if (inet_pton(AF_INET, part1, &in4) == 1) 35417c478bd9Sstevel@tonic-gate return (Z_OK); 35427c478bd9Sstevel@tonic-gate 35437c478bd9Sstevel@tonic-gate /* address may also be a host name */ 35447c478bd9Sstevel@tonic-gate if (!isalnum(part1[0])) { 35457c478bd9Sstevel@tonic-gate zerr(gettext("%s: bogus host name or network address syntax"), 35467c478bd9Sstevel@tonic-gate part1); 35477c478bd9Sstevel@tonic-gate saw_error = TRUE; 35487c478bd9Sstevel@tonic-gate usage(FALSE, HELP_NETADDR); 35497c478bd9Sstevel@tonic-gate return (Z_ERR); 35507c478bd9Sstevel@tonic-gate } 35517c478bd9Sstevel@tonic-gate for (i = 1; part1[i]; i++) 35527c478bd9Sstevel@tonic-gate if (!isalnum(part1[i]) && part1[i] != '-' && part1[i] != '.') { 35537c478bd9Sstevel@tonic-gate zerr(gettext("%s: bogus host name or " 35547c478bd9Sstevel@tonic-gate "network address syntax"), part1); 35557c478bd9Sstevel@tonic-gate saw_error = TRUE; 35567c478bd9Sstevel@tonic-gate usage(FALSE, HELP_NETADDR); 35577c478bd9Sstevel@tonic-gate return (Z_ERR); 35587c478bd9Sstevel@tonic-gate } 35597c478bd9Sstevel@tonic-gate return (Z_OK); 35607c478bd9Sstevel@tonic-gate } 35617c478bd9Sstevel@tonic-gate 35627c478bd9Sstevel@tonic-gate static int 35637c478bd9Sstevel@tonic-gate validate_net_physical_syntax(char *ifname) 35647c478bd9Sstevel@tonic-gate { 35657c478bd9Sstevel@tonic-gate if (strchr(ifname, ':') == NULL) 35667c478bd9Sstevel@tonic-gate return (Z_OK); 35677c478bd9Sstevel@tonic-gate zerr(gettext("%s: physical interface name required; " 35687c478bd9Sstevel@tonic-gate "logical interface name not allowed"), ifname); 35697c478bd9Sstevel@tonic-gate return (Z_ERR); 35707c478bd9Sstevel@tonic-gate } 35717c478bd9Sstevel@tonic-gate 35727c478bd9Sstevel@tonic-gate static boolean_t 35737c478bd9Sstevel@tonic-gate valid_fs_type(const char *type) 35747c478bd9Sstevel@tonic-gate { 35757c478bd9Sstevel@tonic-gate /* 35767c478bd9Sstevel@tonic-gate * Is this a valid path component? 35777c478bd9Sstevel@tonic-gate */ 35787c478bd9Sstevel@tonic-gate if (strlen(type) + 1 > MAXNAMELEN) 35797c478bd9Sstevel@tonic-gate return (B_FALSE); 35807c478bd9Sstevel@tonic-gate /* 35817c478bd9Sstevel@tonic-gate * Make sure a bad value for "type" doesn't make 35827c478bd9Sstevel@tonic-gate * /usr/lib/fs/<type>/mount turn into something else. 35837c478bd9Sstevel@tonic-gate */ 35847c478bd9Sstevel@tonic-gate if (strchr(type, '/') != NULL || type[0] == '\0' || 35857c478bd9Sstevel@tonic-gate strcmp(type, ".") == 0 || strcmp(type, "..") == 0) 3586087719fdSdp return (B_FALSE); 35877c478bd9Sstevel@tonic-gate /* 35887c478bd9Sstevel@tonic-gate * More detailed verification happens later by zoneadm(1m). 35897c478bd9Sstevel@tonic-gate */ 35907c478bd9Sstevel@tonic-gate return (B_TRUE); 35917c478bd9Sstevel@tonic-gate } 35927c478bd9Sstevel@tonic-gate 3593*f4b3ec61Sdh static boolean_t 3594*f4b3ec61Sdh allow_exclusive() 3595*f4b3ec61Sdh { 3596*f4b3ec61Sdh brand_handle_t bh; 3597*f4b3ec61Sdh char brand[MAXNAMELEN]; 3598*f4b3ec61Sdh boolean_t ret; 3599*f4b3ec61Sdh 3600*f4b3ec61Sdh if (zonecfg_get_brand(handle, brand, sizeof (brand)) != Z_OK) { 3601*f4b3ec61Sdh zerr("%s: %s\n", zone, gettext("could not get zone brand")); 3602*f4b3ec61Sdh return (B_FALSE); 3603*f4b3ec61Sdh } 3604*f4b3ec61Sdh if ((bh = brand_open(brand)) == NULL) { 3605*f4b3ec61Sdh zerr("%s: %s\n", zone, gettext("unknown brand.")); 3606*f4b3ec61Sdh return (B_FALSE); 3607*f4b3ec61Sdh } 3608*f4b3ec61Sdh ret = brand_allow_exclusive_ip(bh); 3609*f4b3ec61Sdh brand_close(bh); 3610*f4b3ec61Sdh if (!ret) 3611*f4b3ec61Sdh zerr(gettext("%s cannot be '%s' when %s is '%s'."), 3612*f4b3ec61Sdh pt_to_str(PT_IPTYPE), "exclusive", 3613*f4b3ec61Sdh pt_to_str(PT_BRAND), brand); 3614*f4b3ec61Sdh return (ret); 3615*f4b3ec61Sdh } 3616*f4b3ec61Sdh 36170209230bSgjelinek static void 36180209230bSgjelinek set_aliased_rctl(char *alias, int prop_type, char *s) 36190209230bSgjelinek { 36200209230bSgjelinek uint64_t limit; 36210209230bSgjelinek int err; 36220209230bSgjelinek char tmp[128]; 36230209230bSgjelinek 36240209230bSgjelinek if (global_zone && strcmp(alias, ALIAS_SHARES) != 0) 36250209230bSgjelinek zerr(gettext("WARNING: Setting a global zone resource " 36260209230bSgjelinek "control too low could deny\nservice " 36270209230bSgjelinek "to even the root user; " 36280209230bSgjelinek "this could render the system impossible\n" 36290209230bSgjelinek "to administer. Please use caution.")); 36300209230bSgjelinek 36310209230bSgjelinek /* convert memory based properties */ 36320209230bSgjelinek if (prop_type == PT_MAXSHMMEM) { 36330209230bSgjelinek if (!zonecfg_valid_memlimit(s, &limit)) { 36340209230bSgjelinek zerr(gettext("A non-negative number with a required " 36350209230bSgjelinek "scale suffix (K, M, G or T) was expected\nhere.")); 36360209230bSgjelinek saw_error = TRUE; 36370209230bSgjelinek return; 36380209230bSgjelinek } 36390209230bSgjelinek 36400209230bSgjelinek (void) snprintf(tmp, sizeof (tmp), "%llu", limit); 36410209230bSgjelinek s = tmp; 36420209230bSgjelinek } 36430209230bSgjelinek 36440209230bSgjelinek if (!zonecfg_aliased_rctl_ok(handle, alias)) { 36450209230bSgjelinek zone_perror(pt_to_str(prop_type), Z_ALIAS_DISALLOW, FALSE); 36460209230bSgjelinek saw_error = TRUE; 36470209230bSgjelinek } else if (!zonecfg_valid_alias_limit(alias, s, &limit)) { 36480209230bSgjelinek zerr(gettext("%s property is out of range."), 36490209230bSgjelinek pt_to_str(prop_type)); 36500209230bSgjelinek saw_error = TRUE; 36510209230bSgjelinek } else if ((err = zonecfg_set_aliased_rctl(handle, alias, limit)) 36520209230bSgjelinek != Z_OK) { 36530209230bSgjelinek zone_perror(zone, err, TRUE); 36540209230bSgjelinek saw_error = TRUE; 36550209230bSgjelinek } else { 36560209230bSgjelinek need_to_commit = TRUE; 36570209230bSgjelinek } 36580209230bSgjelinek } 36590209230bSgjelinek 36607c478bd9Sstevel@tonic-gate void 36617c478bd9Sstevel@tonic-gate set_func(cmd_t *cmd) 36627c478bd9Sstevel@tonic-gate { 36637c478bd9Sstevel@tonic-gate char *prop_id; 3664555afedfScarlsonj int arg, err, res_type, prop_type; 36657c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 36667c478bd9Sstevel@tonic-gate boolean_t autoboot; 3667*f4b3ec61Sdh zone_iptype_t iptype; 3668555afedfScarlsonj boolean_t force_set = FALSE; 36690209230bSgjelinek size_t physmem_size = sizeof (in_progress_mcaptab.zone_physmem_cap); 36700209230bSgjelinek uint64_t mem_cap, mem_limit; 36710209230bSgjelinek struct zone_psettab tmp_psettab; 36727c478bd9Sstevel@tonic-gate 36737c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_SET)) 36747c478bd9Sstevel@tonic-gate return; 36757c478bd9Sstevel@tonic-gate 36767c478bd9Sstevel@tonic-gate assert(cmd != NULL); 36777c478bd9Sstevel@tonic-gate 3678555afedfScarlsonj optind = opterr = 0; 3679555afedfScarlsonj while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "F")) != EOF) { 3680555afedfScarlsonj switch (arg) { 3681555afedfScarlsonj case 'F': 3682555afedfScarlsonj force_set = TRUE; 3683555afedfScarlsonj break; 3684555afedfScarlsonj default: 3685555afedfScarlsonj if (optopt == '?') 3686555afedfScarlsonj longer_usage(CMD_SET); 3687555afedfScarlsonj else 3688555afedfScarlsonj short_usage(CMD_SET); 3689555afedfScarlsonj return; 3690555afedfScarlsonj } 3691555afedfScarlsonj } 3692555afedfScarlsonj 36937c478bd9Sstevel@tonic-gate prop_type = cmd->cmd_prop_name[0]; 36947c478bd9Sstevel@tonic-gate if (global_scope) { 36950209230bSgjelinek if (gz_invalid_property(prop_type)) { 36960209230bSgjelinek zerr(gettext("%s is not a valid property for the " 36970209230bSgjelinek "global zone."), pt_to_str(prop_type)); 36980209230bSgjelinek saw_error = TRUE; 36990209230bSgjelinek return; 37000209230bSgjelinek } 37010209230bSgjelinek 3702087719fdSdp if (prop_type == PT_ZONENAME) { 3703087719fdSdp res_type = RT_ZONENAME; 3704087719fdSdp } else if (prop_type == PT_ZONEPATH) { 37057c478bd9Sstevel@tonic-gate res_type = RT_ZONEPATH; 37067c478bd9Sstevel@tonic-gate } else if (prop_type == PT_AUTOBOOT) { 37077c478bd9Sstevel@tonic-gate res_type = RT_AUTOBOOT; 37089acbbeafSnn } else if (prop_type == PT_BRAND) { 37099acbbeafSnn res_type = RT_BRAND; 37107c478bd9Sstevel@tonic-gate } else if (prop_type == PT_POOL) { 37117c478bd9Sstevel@tonic-gate res_type = RT_POOL; 3712ffbafc53Scomay } else if (prop_type == PT_LIMITPRIV) { 3713ffbafc53Scomay res_type = RT_LIMITPRIV; 37143f2f09c1Sdp } else if (prop_type == PT_BOOTARGS) { 37153f2f09c1Sdp res_type = RT_BOOTARGS; 37160209230bSgjelinek } else if (prop_type == PT_SCHED) { 37170209230bSgjelinek res_type = RT_SCHED; 3718*f4b3ec61Sdh } else if (prop_type == PT_IPTYPE) { 3719*f4b3ec61Sdh res_type = RT_IPTYPE; 37200209230bSgjelinek } else if (prop_type == PT_MAXLWPS) { 37210209230bSgjelinek res_type = RT_MAXLWPS; 37220209230bSgjelinek } else if (prop_type == PT_MAXSHMMEM) { 37230209230bSgjelinek res_type = RT_MAXSHMMEM; 37240209230bSgjelinek } else if (prop_type == PT_MAXSHMIDS) { 37250209230bSgjelinek res_type = RT_MAXSHMIDS; 37260209230bSgjelinek } else if (prop_type == PT_MAXMSGIDS) { 37270209230bSgjelinek res_type = RT_MAXMSGIDS; 37280209230bSgjelinek } else if (prop_type == PT_MAXSEMIDS) { 37290209230bSgjelinek res_type = RT_MAXSEMIDS; 37300209230bSgjelinek } else if (prop_type == PT_SHARES) { 37310209230bSgjelinek res_type = RT_SHARES; 37327c478bd9Sstevel@tonic-gate } else { 37337c478bd9Sstevel@tonic-gate zerr(gettext("Cannot set a resource-specific property " 37347c478bd9Sstevel@tonic-gate "from the global scope.")); 37357c478bd9Sstevel@tonic-gate saw_error = TRUE; 37367c478bd9Sstevel@tonic-gate return; 37377c478bd9Sstevel@tonic-gate } 37387c478bd9Sstevel@tonic-gate } else { 37397c478bd9Sstevel@tonic-gate res_type = resource_scope; 37407c478bd9Sstevel@tonic-gate } 37417c478bd9Sstevel@tonic-gate 3742555afedfScarlsonj if (force_set) { 3743555afedfScarlsonj if (res_type != RT_ZONEPATH) { 3744555afedfScarlsonj zerr(gettext("Only zonepath setting can be forced.")); 3745555afedfScarlsonj saw_error = TRUE; 3746555afedfScarlsonj return; 3747555afedfScarlsonj } 3748555afedfScarlsonj if (!zonecfg_in_alt_root()) { 3749555afedfScarlsonj zerr(gettext("Zonepath is changeable only in an " 3750555afedfScarlsonj "alternate root.")); 3751555afedfScarlsonj saw_error = TRUE; 3752555afedfScarlsonj return; 3753555afedfScarlsonj } 3754555afedfScarlsonj } 3755555afedfScarlsonj 37567c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[0]; 37577c478bd9Sstevel@tonic-gate /* 37587c478bd9Sstevel@tonic-gate * A nasty expression but not that complicated: 37597c478bd9Sstevel@tonic-gate * 1. fs options are simple or list (tested below) 37607c478bd9Sstevel@tonic-gate * 2. rctl value's are complex or list (tested below) 37617c478bd9Sstevel@tonic-gate * Anything else should be simple. 37627c478bd9Sstevel@tonic-gate */ 37637c478bd9Sstevel@tonic-gate if (!(res_type == RT_FS && prop_type == PT_OPTIONS) && 37647c478bd9Sstevel@tonic-gate !(res_type == RT_RCTL && prop_type == PT_VALUE) && 37657c478bd9Sstevel@tonic-gate (pp->pv_type != PROP_VAL_SIMPLE || 37667c478bd9Sstevel@tonic-gate (prop_id = pp->pv_simple) == NULL)) { 37677c478bd9Sstevel@tonic-gate zerr(gettext("A %s value was expected here."), 37687c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_SIMPLE)); 37697c478bd9Sstevel@tonic-gate saw_error = TRUE; 37707c478bd9Sstevel@tonic-gate return; 37717c478bd9Sstevel@tonic-gate } 37727c478bd9Sstevel@tonic-gate if (prop_type == PT_UNKNOWN) { 37737c478bd9Sstevel@tonic-gate long_usage(CMD_SET, TRUE); 37747c478bd9Sstevel@tonic-gate return; 37757c478bd9Sstevel@tonic-gate } 37767c478bd9Sstevel@tonic-gate 3777087719fdSdp /* 3778087719fdSdp * Special case: the user can change the zone name prior to 'create'; 3779087719fdSdp * if the zone already exists, we fall through letting initialize() 3780087719fdSdp * and the rest of the logic run. 3781087719fdSdp */ 3782087719fdSdp if (res_type == RT_ZONENAME && got_handle == FALSE && 3783087719fdSdp !state_atleast(ZONE_STATE_CONFIGURED)) { 3784fb03efaaSdp if ((err = zonecfg_validate_zonename(prop_id)) != Z_OK) { 3785fb03efaaSdp zone_perror(prop_id, err, TRUE); 3786fb03efaaSdp usage(FALSE, HELP_SYNTAX); 3787fb03efaaSdp return; 3788fb03efaaSdp } 3789087719fdSdp (void) strlcpy(zone, prop_id, sizeof (zone)); 3790087719fdSdp return; 3791087719fdSdp } 3792087719fdSdp 37937c478bd9Sstevel@tonic-gate if (initialize(TRUE) != Z_OK) 37947c478bd9Sstevel@tonic-gate return; 37957c478bd9Sstevel@tonic-gate 37967c478bd9Sstevel@tonic-gate switch (res_type) { 3797087719fdSdp case RT_ZONENAME: 3798087719fdSdp if ((err = zonecfg_set_name(handle, prop_id)) != Z_OK) { 3799087719fdSdp /* 3800087719fdSdp * Use prop_id instead of 'zone' here, since we're 3801087719fdSdp * reporting a problem about the *new* zonename. 3802087719fdSdp */ 3803087719fdSdp zone_perror(prop_id, err, TRUE); 3804fb03efaaSdp usage(FALSE, HELP_SYNTAX); 3805087719fdSdp } else { 3806087719fdSdp need_to_commit = TRUE; 3807087719fdSdp (void) strlcpy(zone, prop_id, sizeof (zone)); 3808087719fdSdp } 3809087719fdSdp return; 38107c478bd9Sstevel@tonic-gate case RT_ZONEPATH: 3811555afedfScarlsonj if (!force_set && state_atleast(ZONE_STATE_INSTALLED)) { 38127c478bd9Sstevel@tonic-gate zerr(gettext("Zone %s already installed; %s %s not " 38137c478bd9Sstevel@tonic-gate "allowed."), zone, cmd_to_str(CMD_SET), 38147c478bd9Sstevel@tonic-gate rt_to_str(RT_ZONEPATH)); 38157c478bd9Sstevel@tonic-gate return; 38167c478bd9Sstevel@tonic-gate } 38177c478bd9Sstevel@tonic-gate if (validate_zonepath_syntax(prop_id) != Z_OK) { 38187c478bd9Sstevel@tonic-gate saw_error = TRUE; 38197c478bd9Sstevel@tonic-gate return; 38207c478bd9Sstevel@tonic-gate } 38217c478bd9Sstevel@tonic-gate if ((err = zonecfg_set_zonepath(handle, prop_id)) != Z_OK) 38227c478bd9Sstevel@tonic-gate zone_perror(zone, err, TRUE); 38237c478bd9Sstevel@tonic-gate else 38247c478bd9Sstevel@tonic-gate need_to_commit = TRUE; 38257c478bd9Sstevel@tonic-gate return; 38269acbbeafSnn case RT_BRAND: 38279acbbeafSnn if (state_atleast(ZONE_STATE_INSTALLED)) { 38289acbbeafSnn zerr(gettext("Zone %s already installed; %s %s not " 38299acbbeafSnn "allowed."), zone, cmd_to_str(CMD_SET), 38309acbbeafSnn rt_to_str(RT_BRAND)); 38319acbbeafSnn return; 38329acbbeafSnn } 38339acbbeafSnn if ((err = zonecfg_set_brand(handle, prop_id)) != Z_OK) 38349acbbeafSnn zone_perror(zone, err, TRUE); 38359acbbeafSnn else 38369acbbeafSnn need_to_commit = TRUE; 38379acbbeafSnn return; 38387c478bd9Sstevel@tonic-gate case RT_AUTOBOOT: 38397c478bd9Sstevel@tonic-gate if (strcmp(prop_id, "true") == 0) { 38407c478bd9Sstevel@tonic-gate autoboot = B_TRUE; 38417c478bd9Sstevel@tonic-gate } else if (strcmp(prop_id, "false") == 0) { 38427c478bd9Sstevel@tonic-gate autoboot = B_FALSE; 38437c478bd9Sstevel@tonic-gate } else { 38447c478bd9Sstevel@tonic-gate zerr(gettext("%s value must be '%s' or '%s'."), 38457c478bd9Sstevel@tonic-gate pt_to_str(PT_AUTOBOOT), "true", "false"); 38467c478bd9Sstevel@tonic-gate saw_error = TRUE; 38477c478bd9Sstevel@tonic-gate return; 38487c478bd9Sstevel@tonic-gate } 38497c478bd9Sstevel@tonic-gate if ((err = zonecfg_set_autoboot(handle, autoboot)) != Z_OK) 38507c478bd9Sstevel@tonic-gate zone_perror(zone, err, TRUE); 38517c478bd9Sstevel@tonic-gate else 38527c478bd9Sstevel@tonic-gate need_to_commit = TRUE; 38537c478bd9Sstevel@tonic-gate return; 38547c478bd9Sstevel@tonic-gate case RT_POOL: 38550209230bSgjelinek /* don't allow use of the reserved temporary pool names */ 38560209230bSgjelinek if (strncmp("SUNW", prop_id, 4) == 0) { 38570209230bSgjelinek zerr(gettext("pool names starting with SUNW are " 38580209230bSgjelinek "reserved.")); 38590209230bSgjelinek saw_error = TRUE; 38600209230bSgjelinek return; 38610209230bSgjelinek } 38620209230bSgjelinek 38630209230bSgjelinek /* can't set pool if dedicated-cpu exists */ 38640209230bSgjelinek if (zonecfg_lookup_pset(handle, &tmp_psettab) == Z_OK) { 38650209230bSgjelinek zerr(gettext("The %s resource already exists. " 38660209230bSgjelinek "A persistent pool is incompatible\nwith the %s " 38670209230bSgjelinek "resource."), rt_to_str(RT_DCPU), 38680209230bSgjelinek rt_to_str(RT_DCPU)); 38690209230bSgjelinek saw_error = TRUE; 38700209230bSgjelinek return; 38710209230bSgjelinek } 38720209230bSgjelinek 38737c478bd9Sstevel@tonic-gate if ((err = zonecfg_set_pool(handle, prop_id)) != Z_OK) 38747c478bd9Sstevel@tonic-gate zone_perror(zone, err, TRUE); 38757c478bd9Sstevel@tonic-gate else 38767c478bd9Sstevel@tonic-gate need_to_commit = TRUE; 38777c478bd9Sstevel@tonic-gate return; 3878ffbafc53Scomay case RT_LIMITPRIV: 3879ffbafc53Scomay if ((err = zonecfg_set_limitpriv(handle, prop_id)) != Z_OK) 3880ffbafc53Scomay zone_perror(zone, err, TRUE); 3881ffbafc53Scomay else 3882ffbafc53Scomay need_to_commit = TRUE; 3883ffbafc53Scomay return; 38843f2f09c1Sdp case RT_BOOTARGS: 38853f2f09c1Sdp if ((err = zonecfg_set_bootargs(handle, prop_id)) != Z_OK) 38863f2f09c1Sdp zone_perror(zone, err, TRUE); 38873f2f09c1Sdp else 38883f2f09c1Sdp need_to_commit = TRUE; 38893f2f09c1Sdp return; 38900209230bSgjelinek case RT_SCHED: 38910209230bSgjelinek if ((err = zonecfg_set_sched(handle, prop_id)) != Z_OK) 38920209230bSgjelinek zone_perror(zone, err, TRUE); 38930209230bSgjelinek else 38940209230bSgjelinek need_to_commit = TRUE; 38950209230bSgjelinek return; 3896*f4b3ec61Sdh case RT_IPTYPE: 3897*f4b3ec61Sdh if (strcmp(prop_id, "shared") == 0) { 3898*f4b3ec61Sdh iptype = ZS_SHARED; 3899*f4b3ec61Sdh } else if (strcmp(prop_id, "exclusive") == 0) { 3900*f4b3ec61Sdh iptype = ZS_EXCLUSIVE; 3901*f4b3ec61Sdh } else { 3902*f4b3ec61Sdh zerr(gettext("%s value must be '%s' or '%s'."), 3903*f4b3ec61Sdh pt_to_str(PT_IPTYPE), "shared", "exclusive"); 3904*f4b3ec61Sdh saw_error = TRUE; 3905*f4b3ec61Sdh return; 3906*f4b3ec61Sdh } 3907*f4b3ec61Sdh if (iptype == ZS_EXCLUSIVE && !allow_exclusive()) { 3908*f4b3ec61Sdh saw_error = TRUE; 3909*f4b3ec61Sdh return; 3910*f4b3ec61Sdh } 3911*f4b3ec61Sdh if ((err = zonecfg_set_iptype(handle, iptype)) != Z_OK) 3912*f4b3ec61Sdh zone_perror(zone, err, TRUE); 3913*f4b3ec61Sdh else 3914*f4b3ec61Sdh need_to_commit = TRUE; 3915*f4b3ec61Sdh return; 39160209230bSgjelinek case RT_MAXLWPS: 39170209230bSgjelinek set_aliased_rctl(ALIAS_MAXLWPS, prop_type, prop_id); 39180209230bSgjelinek return; 39190209230bSgjelinek case RT_MAXSHMMEM: 39200209230bSgjelinek set_aliased_rctl(ALIAS_MAXSHMMEM, prop_type, prop_id); 39210209230bSgjelinek return; 39220209230bSgjelinek case RT_MAXSHMIDS: 39230209230bSgjelinek set_aliased_rctl(ALIAS_MAXSHMIDS, prop_type, prop_id); 39240209230bSgjelinek return; 39250209230bSgjelinek case RT_MAXMSGIDS: 39260209230bSgjelinek set_aliased_rctl(ALIAS_MAXMSGIDS, prop_type, prop_id); 39270209230bSgjelinek return; 39280209230bSgjelinek case RT_MAXSEMIDS: 39290209230bSgjelinek set_aliased_rctl(ALIAS_MAXSEMIDS, prop_type, prop_id); 39300209230bSgjelinek return; 39310209230bSgjelinek case RT_SHARES: 39320209230bSgjelinek set_aliased_rctl(ALIAS_SHARES, prop_type, prop_id); 39330209230bSgjelinek return; 39347c478bd9Sstevel@tonic-gate case RT_FS: 39357c478bd9Sstevel@tonic-gate switch (prop_type) { 39367c478bd9Sstevel@tonic-gate case PT_DIR: 39377c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_fstab.zone_fs_dir, prop_id, 39387c478bd9Sstevel@tonic-gate sizeof (in_progress_fstab.zone_fs_dir)); 39397c478bd9Sstevel@tonic-gate return; 39407c478bd9Sstevel@tonic-gate case PT_SPECIAL: 39417c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_fstab.zone_fs_special, 39427c478bd9Sstevel@tonic-gate prop_id, 39437c478bd9Sstevel@tonic-gate sizeof (in_progress_fstab.zone_fs_special)); 39447c478bd9Sstevel@tonic-gate return; 39457c478bd9Sstevel@tonic-gate case PT_RAW: 39467c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_fstab.zone_fs_raw, 39477c478bd9Sstevel@tonic-gate prop_id, sizeof (in_progress_fstab.zone_fs_raw)); 39487c478bd9Sstevel@tonic-gate return; 39497c478bd9Sstevel@tonic-gate case PT_TYPE: 39507c478bd9Sstevel@tonic-gate if (!valid_fs_type(prop_id)) { 39517c478bd9Sstevel@tonic-gate zerr(gettext("\"%s\" is not a valid %s."), 39527c478bd9Sstevel@tonic-gate prop_id, pt_to_str(PT_TYPE)); 39537c478bd9Sstevel@tonic-gate saw_error = TRUE; 39547c478bd9Sstevel@tonic-gate return; 39557c478bd9Sstevel@tonic-gate } 39567c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_fstab.zone_fs_type, prop_id, 39577c478bd9Sstevel@tonic-gate sizeof (in_progress_fstab.zone_fs_type)); 39587c478bd9Sstevel@tonic-gate return; 39597c478bd9Sstevel@tonic-gate case PT_OPTIONS: 39607c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE && 39617c478bd9Sstevel@tonic-gate pp->pv_type != PROP_VAL_LIST) { 39627c478bd9Sstevel@tonic-gate zerr(gettext("A %s or %s value was expected " 39637c478bd9Sstevel@tonic-gate "here."), pvt_to_str(PROP_VAL_SIMPLE), 39647c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_LIST)); 39657c478bd9Sstevel@tonic-gate saw_error = TRUE; 39667c478bd9Sstevel@tonic-gate return; 39677c478bd9Sstevel@tonic-gate } 39687c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list( 39697c478bd9Sstevel@tonic-gate in_progress_fstab.zone_fs_options); 39707c478bd9Sstevel@tonic-gate in_progress_fstab.zone_fs_options = NULL; 39717c478bd9Sstevel@tonic-gate if (!(pp->pv_type == PROP_VAL_LIST && 39727c478bd9Sstevel@tonic-gate pp->pv_list == NULL)) 39737c478bd9Sstevel@tonic-gate add_property(cmd); 39747c478bd9Sstevel@tonic-gate return; 39757c478bd9Sstevel@tonic-gate default: 39767c478bd9Sstevel@tonic-gate break; 39777c478bd9Sstevel@tonic-gate } 39787c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, TRUE); 39797c478bd9Sstevel@tonic-gate long_usage(CMD_SET, TRUE); 39807c478bd9Sstevel@tonic-gate usage(FALSE, HELP_PROPS); 39817c478bd9Sstevel@tonic-gate return; 39827c478bd9Sstevel@tonic-gate case RT_IPD: 39837c478bd9Sstevel@tonic-gate switch (prop_type) { 39847c478bd9Sstevel@tonic-gate case PT_DIR: 39857c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_ipdtab.zone_fs_dir, prop_id, 39867c478bd9Sstevel@tonic-gate sizeof (in_progress_ipdtab.zone_fs_dir)); 39877c478bd9Sstevel@tonic-gate return; 39887c478bd9Sstevel@tonic-gate default: 39897c478bd9Sstevel@tonic-gate break; 39907c478bd9Sstevel@tonic-gate } 39917c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, TRUE); 39927c478bd9Sstevel@tonic-gate long_usage(CMD_SET, TRUE); 39937c478bd9Sstevel@tonic-gate usage(FALSE, HELP_PROPS); 39947c478bd9Sstevel@tonic-gate return; 39957c478bd9Sstevel@tonic-gate case RT_NET: 39967c478bd9Sstevel@tonic-gate switch (prop_type) { 39977c478bd9Sstevel@tonic-gate case PT_ADDRESS: 39987c478bd9Sstevel@tonic-gate if (validate_net_address_syntax(prop_id) != Z_OK) { 39997c478bd9Sstevel@tonic-gate saw_error = TRUE; 40007c478bd9Sstevel@tonic-gate return; 40017c478bd9Sstevel@tonic-gate } 40027c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_nwiftab.zone_nwif_address, 40037c478bd9Sstevel@tonic-gate prop_id, 40047c478bd9Sstevel@tonic-gate sizeof (in_progress_nwiftab.zone_nwif_address)); 40057c478bd9Sstevel@tonic-gate break; 40067c478bd9Sstevel@tonic-gate case PT_PHYSICAL: 40077c478bd9Sstevel@tonic-gate if (validate_net_physical_syntax(prop_id) != Z_OK) { 40087c478bd9Sstevel@tonic-gate saw_error = TRUE; 40097c478bd9Sstevel@tonic-gate return; 40107c478bd9Sstevel@tonic-gate } 40117c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_nwiftab.zone_nwif_physical, 40127c478bd9Sstevel@tonic-gate prop_id, 40137c478bd9Sstevel@tonic-gate sizeof (in_progress_nwiftab.zone_nwif_physical)); 40147c478bd9Sstevel@tonic-gate break; 40157c478bd9Sstevel@tonic-gate default: 40167c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 40177c478bd9Sstevel@tonic-gate TRUE); 40187c478bd9Sstevel@tonic-gate long_usage(CMD_SET, TRUE); 40197c478bd9Sstevel@tonic-gate usage(FALSE, HELP_PROPS); 40207c478bd9Sstevel@tonic-gate return; 40217c478bd9Sstevel@tonic-gate } 40227c478bd9Sstevel@tonic-gate return; 40237c478bd9Sstevel@tonic-gate case RT_DEVICE: 40247c478bd9Sstevel@tonic-gate switch (prop_type) { 40257c478bd9Sstevel@tonic-gate case PT_MATCH: 40267c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_devtab.zone_dev_match, 40277c478bd9Sstevel@tonic-gate prop_id, 40287c478bd9Sstevel@tonic-gate sizeof (in_progress_devtab.zone_dev_match)); 40297c478bd9Sstevel@tonic-gate break; 40307c478bd9Sstevel@tonic-gate default: 40317c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 40327c478bd9Sstevel@tonic-gate TRUE); 40337c478bd9Sstevel@tonic-gate long_usage(CMD_SET, TRUE); 40347c478bd9Sstevel@tonic-gate usage(FALSE, HELP_PROPS); 40357c478bd9Sstevel@tonic-gate return; 40367c478bd9Sstevel@tonic-gate } 40377c478bd9Sstevel@tonic-gate return; 40387c478bd9Sstevel@tonic-gate case RT_RCTL: 40397c478bd9Sstevel@tonic-gate switch (prop_type) { 40407c478bd9Sstevel@tonic-gate case PT_NAME: 40417c478bd9Sstevel@tonic-gate if (!zonecfg_valid_rctlname(prop_id)) { 40427c478bd9Sstevel@tonic-gate zerr(gettext("'%s' is not a valid zone %s " 40437c478bd9Sstevel@tonic-gate "name."), prop_id, rt_to_str(RT_RCTL)); 40447c478bd9Sstevel@tonic-gate return; 40457c478bd9Sstevel@tonic-gate } 40467c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_rctltab.zone_rctl_name, 40477c478bd9Sstevel@tonic-gate prop_id, 40487c478bd9Sstevel@tonic-gate sizeof (in_progress_rctltab.zone_rctl_name)); 40497c478bd9Sstevel@tonic-gate break; 40507c478bd9Sstevel@tonic-gate case PT_VALUE: 40517c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_COMPLEX && 40527c478bd9Sstevel@tonic-gate pp->pv_type != PROP_VAL_LIST) { 40537c478bd9Sstevel@tonic-gate zerr(gettext("A %s or %s value was expected " 40547c478bd9Sstevel@tonic-gate "here."), pvt_to_str(PROP_VAL_COMPLEX), 40557c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_LIST)); 40567c478bd9Sstevel@tonic-gate saw_error = TRUE; 40577c478bd9Sstevel@tonic-gate return; 40587c478bd9Sstevel@tonic-gate } 40597c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list( 40607c478bd9Sstevel@tonic-gate in_progress_rctltab.zone_rctl_valptr); 40617c478bd9Sstevel@tonic-gate in_progress_rctltab.zone_rctl_valptr = NULL; 40627c478bd9Sstevel@tonic-gate if (!(pp->pv_type == PROP_VAL_LIST && 40637c478bd9Sstevel@tonic-gate pp->pv_list == NULL)) 40647c478bd9Sstevel@tonic-gate add_property(cmd); 40657c478bd9Sstevel@tonic-gate break; 40667c478bd9Sstevel@tonic-gate default: 40677c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 40687c478bd9Sstevel@tonic-gate TRUE); 40697c478bd9Sstevel@tonic-gate long_usage(CMD_SET, TRUE); 40707c478bd9Sstevel@tonic-gate usage(FALSE, HELP_PROPS); 40717c478bd9Sstevel@tonic-gate return; 40727c478bd9Sstevel@tonic-gate } 40737c478bd9Sstevel@tonic-gate return; 40747c478bd9Sstevel@tonic-gate case RT_ATTR: 40757c478bd9Sstevel@tonic-gate switch (prop_type) { 40767c478bd9Sstevel@tonic-gate case PT_NAME: 40777c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_attrtab.zone_attr_name, 40787c478bd9Sstevel@tonic-gate prop_id, 40797c478bd9Sstevel@tonic-gate sizeof (in_progress_attrtab.zone_attr_name)); 40807c478bd9Sstevel@tonic-gate break; 40817c478bd9Sstevel@tonic-gate case PT_TYPE: 40827c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_attrtab.zone_attr_type, 40837c478bd9Sstevel@tonic-gate prop_id, 40847c478bd9Sstevel@tonic-gate sizeof (in_progress_attrtab.zone_attr_type)); 40857c478bd9Sstevel@tonic-gate break; 40867c478bd9Sstevel@tonic-gate case PT_VALUE: 40877c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_attrtab.zone_attr_value, 40887c478bd9Sstevel@tonic-gate prop_id, 40897c478bd9Sstevel@tonic-gate sizeof (in_progress_attrtab.zone_attr_value)); 40907c478bd9Sstevel@tonic-gate break; 40917c478bd9Sstevel@tonic-gate default: 40927c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 40937c478bd9Sstevel@tonic-gate TRUE); 40947c478bd9Sstevel@tonic-gate long_usage(CMD_SET, TRUE); 40957c478bd9Sstevel@tonic-gate usage(FALSE, HELP_PROPS); 40967c478bd9Sstevel@tonic-gate return; 40977c478bd9Sstevel@tonic-gate } 40987c478bd9Sstevel@tonic-gate return; 4099fa9e4066Sahrens case RT_DATASET: 4100fa9e4066Sahrens switch (prop_type) { 4101fa9e4066Sahrens case PT_NAME: 4102fa9e4066Sahrens (void) strlcpy(in_progress_dstab.zone_dataset_name, 4103fa9e4066Sahrens prop_id, 4104fa9e4066Sahrens sizeof (in_progress_dstab.zone_dataset_name)); 4105fa9e4066Sahrens return; 4106fa9e4066Sahrens default: 4107fa9e4066Sahrens break; 4108fa9e4066Sahrens } 4109fa9e4066Sahrens zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, TRUE); 4110fa9e4066Sahrens long_usage(CMD_SET, TRUE); 4111fa9e4066Sahrens usage(FALSE, HELP_PROPS); 41120209230bSgjelinek return; 41130209230bSgjelinek case RT_DCPU: 41140209230bSgjelinek switch (prop_type) { 41150209230bSgjelinek char *lowp, *highp; 41160209230bSgjelinek 41170209230bSgjelinek case PT_NCPUS: 41180209230bSgjelinek lowp = prop_id; 41190209230bSgjelinek if ((highp = strchr(prop_id, '-')) != NULL) 41200209230bSgjelinek *highp++ = '\0'; 41210209230bSgjelinek else 41220209230bSgjelinek highp = lowp; 41230209230bSgjelinek 41240209230bSgjelinek /* Make sure the input makes sense. */ 41250209230bSgjelinek if (!zonecfg_valid_ncpus(lowp, highp)) { 41260209230bSgjelinek zerr(gettext("%s property is out of range."), 41270209230bSgjelinek pt_to_str(PT_NCPUS)); 41280209230bSgjelinek saw_error = TRUE; 41290209230bSgjelinek return; 41300209230bSgjelinek } 41310209230bSgjelinek 41320209230bSgjelinek (void) strlcpy( 41330209230bSgjelinek in_progress_psettab.zone_ncpu_min, lowp, 41340209230bSgjelinek sizeof (in_progress_psettab.zone_ncpu_min)); 41350209230bSgjelinek (void) strlcpy( 41360209230bSgjelinek in_progress_psettab.zone_ncpu_max, highp, 41370209230bSgjelinek sizeof (in_progress_psettab.zone_ncpu_max)); 41380209230bSgjelinek return; 41390209230bSgjelinek case PT_IMPORTANCE: 41400209230bSgjelinek /* Make sure the value makes sense. */ 41410209230bSgjelinek if (!zonecfg_valid_importance(prop_id)) { 41420209230bSgjelinek zerr(gettext("%s property is out of range."), 41430209230bSgjelinek pt_to_str(PT_IMPORTANCE)); 41440209230bSgjelinek saw_error = TRUE; 41450209230bSgjelinek return; 41460209230bSgjelinek } 41470209230bSgjelinek 41480209230bSgjelinek (void) strlcpy(in_progress_psettab.zone_importance, 41490209230bSgjelinek prop_id, 41500209230bSgjelinek sizeof (in_progress_psettab.zone_importance)); 41510209230bSgjelinek return; 41520209230bSgjelinek default: 41530209230bSgjelinek break; 41540209230bSgjelinek } 41550209230bSgjelinek zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, TRUE); 41560209230bSgjelinek long_usage(CMD_SET, TRUE); 41570209230bSgjelinek usage(FALSE, HELP_PROPS); 41580209230bSgjelinek return; 41590209230bSgjelinek case RT_MCAP: 41600209230bSgjelinek switch (prop_type) { 41610209230bSgjelinek case PT_PHYSICAL: 41620209230bSgjelinek if (!zonecfg_valid_memlimit(prop_id, &mem_cap)) { 41630209230bSgjelinek zerr(gettext("A positive number with a " 41640209230bSgjelinek "required scale suffix (K, M, G or T) was " 41650209230bSgjelinek "expected here.")); 41660209230bSgjelinek saw_error = TRUE; 41670209230bSgjelinek } else if (mem_cap < ONE_MB) { 41680209230bSgjelinek zerr(gettext("%s value is too small. It must " 41690209230bSgjelinek "be at least 1M."), pt_to_str(PT_PHYSICAL)); 41700209230bSgjelinek saw_error = TRUE; 41710209230bSgjelinek } else { 41720209230bSgjelinek snprintf(in_progress_mcaptab.zone_physmem_cap, 41730209230bSgjelinek physmem_size, "%llu", mem_cap); 41740209230bSgjelinek } 41750209230bSgjelinek break; 41760209230bSgjelinek case PT_SWAP: 41770209230bSgjelinek /* 41780209230bSgjelinek * We have to check if an rctl is allowed here since 41790209230bSgjelinek * there might already be a rctl defined that blocks 41800209230bSgjelinek * the alias. 41810209230bSgjelinek */ 41820209230bSgjelinek if (!zonecfg_aliased_rctl_ok(handle, ALIAS_MAXSWAP)) { 41830209230bSgjelinek zone_perror(pt_to_str(PT_MAXSWAP), 41840209230bSgjelinek Z_ALIAS_DISALLOW, FALSE); 41850209230bSgjelinek saw_error = TRUE; 41860209230bSgjelinek return; 41870209230bSgjelinek } 41880209230bSgjelinek 41890209230bSgjelinek if (global_zone) 41900209230bSgjelinek mem_limit = ONE_MB * 100; 41910209230bSgjelinek else 41920209230bSgjelinek mem_limit = ONE_MB * 50; 41930209230bSgjelinek 41940209230bSgjelinek if (!zonecfg_valid_memlimit(prop_id, &mem_cap)) { 41950209230bSgjelinek zerr(gettext("A positive number with a " 41960209230bSgjelinek "required scale suffix (K, M, G or T) was " 41970209230bSgjelinek "expected here.")); 41980209230bSgjelinek saw_error = TRUE; 41990209230bSgjelinek } else if (mem_cap < mem_limit) { 42000209230bSgjelinek char buf[128]; 42010209230bSgjelinek 42020209230bSgjelinek (void) snprintf(buf, sizeof (buf), "%llu", 42030209230bSgjelinek mem_limit); 42040209230bSgjelinek bytes_to_units(buf, buf, sizeof (buf)); 42050209230bSgjelinek zerr(gettext("%s value is too small. It must " 42060209230bSgjelinek "be at least %s."), pt_to_str(PT_SWAP), 42070209230bSgjelinek buf); 42080209230bSgjelinek saw_error = TRUE; 42090209230bSgjelinek } else { 42100209230bSgjelinek if ((err = zonecfg_set_aliased_rctl(handle, 42110209230bSgjelinek ALIAS_MAXSWAP, mem_cap)) != Z_OK) 42120209230bSgjelinek zone_perror(zone, err, TRUE); 42130209230bSgjelinek else 42140209230bSgjelinek need_to_commit = TRUE; 42150209230bSgjelinek } 42160209230bSgjelinek break; 42170209230bSgjelinek case PT_LOCKED: 42180209230bSgjelinek /* 42190209230bSgjelinek * We have to check if an rctl is allowed here since 42200209230bSgjelinek * there might already be a rctl defined that blocks 42210209230bSgjelinek * the alias. 42220209230bSgjelinek */ 42230209230bSgjelinek if (!zonecfg_aliased_rctl_ok(handle, 42240209230bSgjelinek ALIAS_MAXLOCKEDMEM)) { 42250209230bSgjelinek zone_perror(pt_to_str(PT_LOCKED), 42260209230bSgjelinek Z_ALIAS_DISALLOW, FALSE); 42270209230bSgjelinek saw_error = TRUE; 42280209230bSgjelinek return; 42290209230bSgjelinek } 42300209230bSgjelinek 42310209230bSgjelinek if (!zonecfg_valid_memlimit(prop_id, &mem_cap)) { 42320209230bSgjelinek zerr(gettext("A non-negative number with a " 42330209230bSgjelinek "required scale suffix (K, M, G or T) was " 42340209230bSgjelinek "expected\nhere.")); 42350209230bSgjelinek saw_error = TRUE; 42360209230bSgjelinek } else { 42370209230bSgjelinek if ((err = zonecfg_set_aliased_rctl(handle, 42380209230bSgjelinek ALIAS_MAXLOCKEDMEM, mem_cap)) != Z_OK) 42390209230bSgjelinek zone_perror(zone, err, TRUE); 42400209230bSgjelinek else 42410209230bSgjelinek need_to_commit = TRUE; 42420209230bSgjelinek } 42430209230bSgjelinek break; 42440209230bSgjelinek default: 42450209230bSgjelinek zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 42460209230bSgjelinek TRUE); 42470209230bSgjelinek long_usage(CMD_SET, TRUE); 42480209230bSgjelinek usage(FALSE, HELP_PROPS); 42490209230bSgjelinek return; 42500209230bSgjelinek } 42510209230bSgjelinek 4252fa9e4066Sahrens return; 42537c478bd9Sstevel@tonic-gate default: 42547c478bd9Sstevel@tonic-gate zone_perror(rt_to_str(res_type), Z_NO_RESOURCE_TYPE, TRUE); 42557c478bd9Sstevel@tonic-gate long_usage(CMD_SET, TRUE); 42567c478bd9Sstevel@tonic-gate usage(FALSE, HELP_RESOURCES); 42577c478bd9Sstevel@tonic-gate return; 42587c478bd9Sstevel@tonic-gate } 42597c478bd9Sstevel@tonic-gate } 42607c478bd9Sstevel@tonic-gate 42617c478bd9Sstevel@tonic-gate static void 42627c478bd9Sstevel@tonic-gate output_prop(FILE *fp, int pnum, char *pval, bool print_notspec) 42637c478bd9Sstevel@tonic-gate { 42647c478bd9Sstevel@tonic-gate char *qstr; 42657c478bd9Sstevel@tonic-gate 42667c478bd9Sstevel@tonic-gate if (*pval != '\0') { 42677c478bd9Sstevel@tonic-gate qstr = quoteit(pval); 42680209230bSgjelinek if (pnum == PT_SWAP || pnum == PT_LOCKED) 42690209230bSgjelinek (void) fprintf(fp, "\t[%s: %s]\n", pt_to_str(pnum), 42700209230bSgjelinek qstr); 42710209230bSgjelinek else 42720209230bSgjelinek (void) fprintf(fp, "\t%s: %s\n", pt_to_str(pnum), qstr); 42737c478bd9Sstevel@tonic-gate free(qstr); 42747c478bd9Sstevel@tonic-gate } else if (print_notspec) 4275087719fdSdp (void) fprintf(fp, gettext("\t%s not specified\n"), 4276087719fdSdp pt_to_str(pnum)); 4277087719fdSdp } 4278087719fdSdp 4279087719fdSdp static void 4280087719fdSdp info_zonename(zone_dochandle_t handle, FILE *fp) 4281087719fdSdp { 4282087719fdSdp char zonename[ZONENAME_MAX]; 4283087719fdSdp 4284087719fdSdp if (zonecfg_get_name(handle, zonename, sizeof (zonename)) == Z_OK) 4285087719fdSdp (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_ZONENAME), 4286087719fdSdp zonename); 4287087719fdSdp else 4288087719fdSdp (void) fprintf(fp, gettext("%s not specified\n"), 4289087719fdSdp pt_to_str(PT_ZONENAME)); 42907c478bd9Sstevel@tonic-gate } 42917c478bd9Sstevel@tonic-gate 42927c478bd9Sstevel@tonic-gate static void 42937c478bd9Sstevel@tonic-gate info_zonepath(zone_dochandle_t handle, FILE *fp) 42947c478bd9Sstevel@tonic-gate { 42957c478bd9Sstevel@tonic-gate char zonepath[MAXPATHLEN]; 42967c478bd9Sstevel@tonic-gate 42977c478bd9Sstevel@tonic-gate if (zonecfg_get_zonepath(handle, zonepath, sizeof (zonepath)) == Z_OK) 42987c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_ZONEPATH), 42997c478bd9Sstevel@tonic-gate zonepath); 4300087719fdSdp else { 4301087719fdSdp (void) fprintf(fp, gettext("%s not specified\n"), 4302087719fdSdp pt_to_str(PT_ZONEPATH)); 4303087719fdSdp } 43047c478bd9Sstevel@tonic-gate } 43057c478bd9Sstevel@tonic-gate 43069acbbeafSnn static void 43079acbbeafSnn info_brand(zone_dochandle_t handle, FILE *fp) 43089acbbeafSnn { 43099acbbeafSnn char brand[MAXNAMELEN]; 43109acbbeafSnn 43119acbbeafSnn if (zonecfg_get_brand(handle, brand, sizeof (brand)) == Z_OK) 43129acbbeafSnn (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_BRAND), 43139acbbeafSnn brand); 43149acbbeafSnn else 43159acbbeafSnn (void) fprintf(fp, "%s %s\n", pt_to_str(PT_BRAND), 43169acbbeafSnn gettext("not specified")); 43179acbbeafSnn } 43189acbbeafSnn 43197c478bd9Sstevel@tonic-gate static void 43207c478bd9Sstevel@tonic-gate info_autoboot(zone_dochandle_t handle, FILE *fp) 43217c478bd9Sstevel@tonic-gate { 43227c478bd9Sstevel@tonic-gate boolean_t autoboot; 43237c478bd9Sstevel@tonic-gate int err; 43247c478bd9Sstevel@tonic-gate 43257c478bd9Sstevel@tonic-gate if ((err = zonecfg_get_autoboot(handle, &autoboot)) == Z_OK) 43267c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_AUTOBOOT), 43277c478bd9Sstevel@tonic-gate autoboot ? "true" : "false"); 43287c478bd9Sstevel@tonic-gate else 43297c478bd9Sstevel@tonic-gate zone_perror(zone, err, TRUE); 43307c478bd9Sstevel@tonic-gate } 43317c478bd9Sstevel@tonic-gate 43327c478bd9Sstevel@tonic-gate static void 43337c478bd9Sstevel@tonic-gate info_pool(zone_dochandle_t handle, FILE *fp) 43347c478bd9Sstevel@tonic-gate { 43357c478bd9Sstevel@tonic-gate char pool[MAXNAMELEN]; 43367c478bd9Sstevel@tonic-gate int err; 43377c478bd9Sstevel@tonic-gate 43387c478bd9Sstevel@tonic-gate if ((err = zonecfg_get_pool(handle, pool, sizeof (pool))) == Z_OK) 43397c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_POOL), pool); 43407c478bd9Sstevel@tonic-gate else 43417c478bd9Sstevel@tonic-gate zone_perror(zone, err, TRUE); 43427c478bd9Sstevel@tonic-gate } 43437c478bd9Sstevel@tonic-gate 4344ffbafc53Scomay static void 4345ffbafc53Scomay info_limitpriv(zone_dochandle_t handle, FILE *fp) 4346ffbafc53Scomay { 4347ffbafc53Scomay char *limitpriv; 4348ffbafc53Scomay int err; 4349ffbafc53Scomay 4350ffbafc53Scomay if ((err = zonecfg_get_limitpriv(handle, &limitpriv)) == Z_OK) { 4351ffbafc53Scomay (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_LIMITPRIV), 4352ffbafc53Scomay limitpriv); 4353ffbafc53Scomay free(limitpriv); 4354ffbafc53Scomay } else { 4355ffbafc53Scomay zone_perror(zone, err, TRUE); 4356ffbafc53Scomay } 4357ffbafc53Scomay } 4358ffbafc53Scomay 43593f2f09c1Sdp static void 43603f2f09c1Sdp info_bootargs(zone_dochandle_t handle, FILE *fp) 43613f2f09c1Sdp { 43623f2f09c1Sdp char bootargs[BOOTARGS_MAX]; 43633f2f09c1Sdp int err; 43643f2f09c1Sdp 43653f2f09c1Sdp if ((err = zonecfg_get_bootargs(handle, bootargs, 43663f2f09c1Sdp sizeof (bootargs))) == Z_OK) { 43673f2f09c1Sdp (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_BOOTARGS), 43683f2f09c1Sdp bootargs); 43693f2f09c1Sdp } else { 43703f2f09c1Sdp zone_perror(zone, err, TRUE); 43713f2f09c1Sdp } 43723f2f09c1Sdp } 43733f2f09c1Sdp 43740209230bSgjelinek static void 43750209230bSgjelinek info_sched(zone_dochandle_t handle, FILE *fp) 43760209230bSgjelinek { 43770209230bSgjelinek char sched[MAXNAMELEN]; 43780209230bSgjelinek int err; 43790209230bSgjelinek 43800209230bSgjelinek if ((err = zonecfg_get_sched_class(handle, sched, sizeof (sched))) 43810209230bSgjelinek == Z_OK) { 43820209230bSgjelinek (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_SCHED), sched); 43830209230bSgjelinek } else { 43840209230bSgjelinek zone_perror(zone, err, TRUE); 43850209230bSgjelinek } 43860209230bSgjelinek } 43870209230bSgjelinek 4388*f4b3ec61Sdh static void 4389*f4b3ec61Sdh info_iptype(zone_dochandle_t handle, FILE *fp) 4390*f4b3ec61Sdh { 4391*f4b3ec61Sdh zone_iptype_t iptype; 4392*f4b3ec61Sdh int err; 4393*f4b3ec61Sdh 4394*f4b3ec61Sdh if ((err = zonecfg_get_iptype(handle, &iptype)) == Z_OK) { 4395*f4b3ec61Sdh switch (iptype) { 4396*f4b3ec61Sdh case ZS_SHARED: 4397*f4b3ec61Sdh (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_IPTYPE), 4398*f4b3ec61Sdh "shared"); 4399*f4b3ec61Sdh break; 4400*f4b3ec61Sdh case ZS_EXCLUSIVE: 4401*f4b3ec61Sdh (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_IPTYPE), 4402*f4b3ec61Sdh "exclusive"); 4403*f4b3ec61Sdh break; 4404*f4b3ec61Sdh } 4405*f4b3ec61Sdh } else { 4406*f4b3ec61Sdh zone_perror(zone, err, TRUE); 4407*f4b3ec61Sdh } 4408*f4b3ec61Sdh } 4409*f4b3ec61Sdh 44107c478bd9Sstevel@tonic-gate static void 44117c478bd9Sstevel@tonic-gate output_fs(FILE *fp, struct zone_fstab *fstab) 44127c478bd9Sstevel@tonic-gate { 44137c478bd9Sstevel@tonic-gate zone_fsopt_t *this; 44147c478bd9Sstevel@tonic-gate 44157c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s:\n", rt_to_str(RT_FS)); 44167c478bd9Sstevel@tonic-gate output_prop(fp, PT_DIR, fstab->zone_fs_dir, B_TRUE); 44177c478bd9Sstevel@tonic-gate output_prop(fp, PT_SPECIAL, fstab->zone_fs_special, B_TRUE); 44187c478bd9Sstevel@tonic-gate output_prop(fp, PT_RAW, fstab->zone_fs_raw, B_TRUE); 44197c478bd9Sstevel@tonic-gate output_prop(fp, PT_TYPE, fstab->zone_fs_type, B_TRUE); 44207c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s: [", pt_to_str(PT_OPTIONS)); 44217c478bd9Sstevel@tonic-gate for (this = fstab->zone_fs_options; this != NULL; 44227c478bd9Sstevel@tonic-gate this = this->zone_fsopt_next) { 44237c478bd9Sstevel@tonic-gate if (strchr(this->zone_fsopt_opt, '=')) 44247c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\"%s\"", this->zone_fsopt_opt); 44257c478bd9Sstevel@tonic-gate else 44267c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s", this->zone_fsopt_opt); 44277c478bd9Sstevel@tonic-gate if (this->zone_fsopt_next != NULL) 44287c478bd9Sstevel@tonic-gate (void) fprintf(fp, ","); 44297c478bd9Sstevel@tonic-gate } 44307c478bd9Sstevel@tonic-gate (void) fprintf(fp, "]\n"); 44317c478bd9Sstevel@tonic-gate } 44327c478bd9Sstevel@tonic-gate 44337c478bd9Sstevel@tonic-gate static void 44347c478bd9Sstevel@tonic-gate output_ipd(FILE *fp, struct zone_fstab *ipdtab) 44357c478bd9Sstevel@tonic-gate { 44367c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s:\n", rt_to_str(RT_IPD)); 44377c478bd9Sstevel@tonic-gate output_prop(fp, PT_DIR, ipdtab->zone_fs_dir, B_TRUE); 44387c478bd9Sstevel@tonic-gate } 44397c478bd9Sstevel@tonic-gate 44407c478bd9Sstevel@tonic-gate static void 44417c478bd9Sstevel@tonic-gate info_fs(zone_dochandle_t handle, FILE *fp, cmd_t *cmd) 44427c478bd9Sstevel@tonic-gate { 44437c478bd9Sstevel@tonic-gate struct zone_fstab lookup, user; 44447c478bd9Sstevel@tonic-gate bool output = FALSE; 44457c478bd9Sstevel@tonic-gate 44467c478bd9Sstevel@tonic-gate if (zonecfg_setfsent(handle) != Z_OK) 44477c478bd9Sstevel@tonic-gate return; 44487c478bd9Sstevel@tonic-gate while (zonecfg_getfsent(handle, &lookup) == Z_OK) { 44497c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs == 0) { 44507c478bd9Sstevel@tonic-gate output_fs(fp, &lookup); 44517c478bd9Sstevel@tonic-gate goto loopend; 44527c478bd9Sstevel@tonic-gate } 44537c478bd9Sstevel@tonic-gate if (fill_in_fstab(cmd, &user, TRUE) != Z_OK) 44547c478bd9Sstevel@tonic-gate goto loopend; 44557c478bd9Sstevel@tonic-gate if (strlen(user.zone_fs_dir) > 0 && 44567c478bd9Sstevel@tonic-gate strcmp(user.zone_fs_dir, lookup.zone_fs_dir) != 0) 44577c478bd9Sstevel@tonic-gate goto loopend; /* no match */ 44587c478bd9Sstevel@tonic-gate if (strlen(user.zone_fs_special) > 0 && 44597c478bd9Sstevel@tonic-gate strcmp(user.zone_fs_special, lookup.zone_fs_special) != 0) 44607c478bd9Sstevel@tonic-gate goto loopend; /* no match */ 44617c478bd9Sstevel@tonic-gate if (strlen(user.zone_fs_type) > 0 && 44627c478bd9Sstevel@tonic-gate strcmp(user.zone_fs_type, lookup.zone_fs_type) != 0) 44637c478bd9Sstevel@tonic-gate goto loopend; /* no match */ 44647c478bd9Sstevel@tonic-gate output_fs(fp, &lookup); 44657c478bd9Sstevel@tonic-gate output = TRUE; 44667c478bd9Sstevel@tonic-gate loopend: 44677c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(lookup.zone_fs_options); 44687c478bd9Sstevel@tonic-gate } 44697c478bd9Sstevel@tonic-gate (void) zonecfg_endfsent(handle); 44707c478bd9Sstevel@tonic-gate /* 44717c478bd9Sstevel@tonic-gate * If a property n/v pair was specified, warn the user if there was 44727c478bd9Sstevel@tonic-gate * nothing to output. 44737c478bd9Sstevel@tonic-gate */ 44747c478bd9Sstevel@tonic-gate if (!output && cmd->cmd_prop_nv_pairs > 0) 44757c478bd9Sstevel@tonic-gate (void) printf(gettext("No such %s resource.\n"), 44767c478bd9Sstevel@tonic-gate rt_to_str(RT_FS)); 44777c478bd9Sstevel@tonic-gate } 44787c478bd9Sstevel@tonic-gate 44797c478bd9Sstevel@tonic-gate static void 44807c478bd9Sstevel@tonic-gate info_ipd(zone_dochandle_t handle, FILE *fp, cmd_t *cmd) 44817c478bd9Sstevel@tonic-gate { 44827c478bd9Sstevel@tonic-gate struct zone_fstab lookup, user; 44837c478bd9Sstevel@tonic-gate bool output = FALSE; 44847c478bd9Sstevel@tonic-gate 44857c478bd9Sstevel@tonic-gate if (zonecfg_setipdent(handle) != Z_OK) 44867c478bd9Sstevel@tonic-gate return; 44877c478bd9Sstevel@tonic-gate while (zonecfg_getipdent(handle, &lookup) == Z_OK) { 44887c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs == 0) { 44897c478bd9Sstevel@tonic-gate output_ipd(fp, &lookup); 44907c478bd9Sstevel@tonic-gate continue; 44917c478bd9Sstevel@tonic-gate } 44927c478bd9Sstevel@tonic-gate if (fill_in_ipdtab(cmd, &user, TRUE) != Z_OK) 44937c478bd9Sstevel@tonic-gate continue; 44947c478bd9Sstevel@tonic-gate if (strlen(user.zone_fs_dir) > 0 && 44957c478bd9Sstevel@tonic-gate strcmp(user.zone_fs_dir, lookup.zone_fs_dir) != 0) 44967c478bd9Sstevel@tonic-gate continue; /* no match */ 44977c478bd9Sstevel@tonic-gate output_ipd(fp, &lookup); 44987c478bd9Sstevel@tonic-gate output = TRUE; 44997c478bd9Sstevel@tonic-gate } 45007c478bd9Sstevel@tonic-gate (void) zonecfg_endipdent(handle); 45017c478bd9Sstevel@tonic-gate /* 45027c478bd9Sstevel@tonic-gate * If a property n/v pair was specified, warn the user if there was 45037c478bd9Sstevel@tonic-gate * nothing to output. 45047c478bd9Sstevel@tonic-gate */ 45057c478bd9Sstevel@tonic-gate if (!output && cmd->cmd_prop_nv_pairs > 0) 45067c478bd9Sstevel@tonic-gate (void) printf(gettext("No such %s resource.\n"), 45077c478bd9Sstevel@tonic-gate rt_to_str(RT_IPD)); 45087c478bd9Sstevel@tonic-gate } 45097c478bd9Sstevel@tonic-gate 45107c478bd9Sstevel@tonic-gate static void 45117c478bd9Sstevel@tonic-gate output_net(FILE *fp, struct zone_nwiftab *nwiftab) 45127c478bd9Sstevel@tonic-gate { 45137c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s:\n", rt_to_str(RT_NET)); 45147c478bd9Sstevel@tonic-gate output_prop(fp, PT_ADDRESS, nwiftab->zone_nwif_address, B_TRUE); 45157c478bd9Sstevel@tonic-gate output_prop(fp, PT_PHYSICAL, nwiftab->zone_nwif_physical, B_TRUE); 45167c478bd9Sstevel@tonic-gate } 45177c478bd9Sstevel@tonic-gate 45187c478bd9Sstevel@tonic-gate static void 45197c478bd9Sstevel@tonic-gate info_net(zone_dochandle_t handle, FILE *fp, cmd_t *cmd) 45207c478bd9Sstevel@tonic-gate { 45217c478bd9Sstevel@tonic-gate struct zone_nwiftab lookup, user; 45227c478bd9Sstevel@tonic-gate bool output = FALSE; 45237c478bd9Sstevel@tonic-gate 45247c478bd9Sstevel@tonic-gate if (zonecfg_setnwifent(handle) != Z_OK) 45257c478bd9Sstevel@tonic-gate return; 45267c478bd9Sstevel@tonic-gate while (zonecfg_getnwifent(handle, &lookup) == Z_OK) { 45277c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs == 0) { 45287c478bd9Sstevel@tonic-gate output_net(fp, &lookup); 45297c478bd9Sstevel@tonic-gate continue; 45307c478bd9Sstevel@tonic-gate } 45317c478bd9Sstevel@tonic-gate if (fill_in_nwiftab(cmd, &user, TRUE) != Z_OK) 45327c478bd9Sstevel@tonic-gate continue; 45337c478bd9Sstevel@tonic-gate if (strlen(user.zone_nwif_physical) > 0 && 45347c478bd9Sstevel@tonic-gate strcmp(user.zone_nwif_physical, 45357c478bd9Sstevel@tonic-gate lookup.zone_nwif_physical) != 0) 45367c478bd9Sstevel@tonic-gate continue; /* no match */ 4537*f4b3ec61Sdh /* If present make sure it matches */ 45387c478bd9Sstevel@tonic-gate if (strlen(user.zone_nwif_address) > 0 && 45397c478bd9Sstevel@tonic-gate !zonecfg_same_net_address(user.zone_nwif_address, 45407c478bd9Sstevel@tonic-gate lookup.zone_nwif_address)) 45417c478bd9Sstevel@tonic-gate continue; /* no match */ 45427c478bd9Sstevel@tonic-gate output_net(fp, &lookup); 45437c478bd9Sstevel@tonic-gate output = TRUE; 45447c478bd9Sstevel@tonic-gate } 45457c478bd9Sstevel@tonic-gate (void) zonecfg_endnwifent(handle); 45467c478bd9Sstevel@tonic-gate /* 45477c478bd9Sstevel@tonic-gate * If a property n/v pair was specified, warn the user if there was 45487c478bd9Sstevel@tonic-gate * nothing to output. 45497c478bd9Sstevel@tonic-gate */ 45507c478bd9Sstevel@tonic-gate if (!output && cmd->cmd_prop_nv_pairs > 0) 45517c478bd9Sstevel@tonic-gate (void) printf(gettext("No such %s resource.\n"), 45527c478bd9Sstevel@tonic-gate rt_to_str(RT_NET)); 45537c478bd9Sstevel@tonic-gate } 45547c478bd9Sstevel@tonic-gate 45557c478bd9Sstevel@tonic-gate static void 45567c478bd9Sstevel@tonic-gate output_dev(FILE *fp, struct zone_devtab *devtab) 45577c478bd9Sstevel@tonic-gate { 45587c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s\n", rt_to_str(RT_DEVICE)); 45597c478bd9Sstevel@tonic-gate output_prop(fp, PT_MATCH, devtab->zone_dev_match, B_TRUE); 45607c478bd9Sstevel@tonic-gate } 45617c478bd9Sstevel@tonic-gate 45627c478bd9Sstevel@tonic-gate static void 45637c478bd9Sstevel@tonic-gate info_dev(zone_dochandle_t handle, FILE *fp, cmd_t *cmd) 45647c478bd9Sstevel@tonic-gate { 45657c478bd9Sstevel@tonic-gate struct zone_devtab lookup, user; 45667c478bd9Sstevel@tonic-gate bool output = FALSE; 45677c478bd9Sstevel@tonic-gate 45687c478bd9Sstevel@tonic-gate if (zonecfg_setdevent(handle) != Z_OK) 45697c478bd9Sstevel@tonic-gate return; 45707c478bd9Sstevel@tonic-gate while (zonecfg_getdevent(handle, &lookup) == Z_OK) { 45717c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs == 0) { 45727c478bd9Sstevel@tonic-gate output_dev(fp, &lookup); 45737c478bd9Sstevel@tonic-gate continue; 45747c478bd9Sstevel@tonic-gate } 45757c478bd9Sstevel@tonic-gate if (fill_in_devtab(cmd, &user, TRUE) != Z_OK) 45767c478bd9Sstevel@tonic-gate continue; 45777c478bd9Sstevel@tonic-gate if (strlen(user.zone_dev_match) > 0 && 45787c478bd9Sstevel@tonic-gate strcmp(user.zone_dev_match, lookup.zone_dev_match) != 0) 45797c478bd9Sstevel@tonic-gate continue; /* no match */ 45807c478bd9Sstevel@tonic-gate output_dev(fp, &lookup); 45817c478bd9Sstevel@tonic-gate output = TRUE; 45827c478bd9Sstevel@tonic-gate } 45837c478bd9Sstevel@tonic-gate (void) zonecfg_enddevent(handle); 45847c478bd9Sstevel@tonic-gate /* 45857c478bd9Sstevel@tonic-gate * If a property n/v pair was specified, warn the user if there was 45867c478bd9Sstevel@tonic-gate * nothing to output. 45877c478bd9Sstevel@tonic-gate */ 45887c478bd9Sstevel@tonic-gate if (!output && cmd->cmd_prop_nv_pairs > 0) 45897c478bd9Sstevel@tonic-gate (void) printf(gettext("No such %s resource.\n"), 45907c478bd9Sstevel@tonic-gate rt_to_str(RT_DEVICE)); 45917c478bd9Sstevel@tonic-gate } 45927c478bd9Sstevel@tonic-gate 45937c478bd9Sstevel@tonic-gate static void 45947c478bd9Sstevel@tonic-gate output_rctl(FILE *fp, struct zone_rctltab *rctltab) 45957c478bd9Sstevel@tonic-gate { 45967c478bd9Sstevel@tonic-gate struct zone_rctlvaltab *valptr; 45977c478bd9Sstevel@tonic-gate 45987c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s:\n", rt_to_str(RT_RCTL)); 45997c478bd9Sstevel@tonic-gate output_prop(fp, PT_NAME, rctltab->zone_rctl_name, B_TRUE); 46007c478bd9Sstevel@tonic-gate for (valptr = rctltab->zone_rctl_valptr; valptr != NULL; 46017c478bd9Sstevel@tonic-gate valptr = valptr->zone_rctlval_next) { 46027c478bd9Sstevel@tonic-gate fprintf(fp, "\t%s: (%s=%s,%s=%s,%s=%s)\n", 46037c478bd9Sstevel@tonic-gate pt_to_str(PT_VALUE), 46047c478bd9Sstevel@tonic-gate pt_to_str(PT_PRIV), valptr->zone_rctlval_priv, 46057c478bd9Sstevel@tonic-gate pt_to_str(PT_LIMIT), valptr->zone_rctlval_limit, 46067c478bd9Sstevel@tonic-gate pt_to_str(PT_ACTION), valptr->zone_rctlval_action); 46077c478bd9Sstevel@tonic-gate } 46087c478bd9Sstevel@tonic-gate } 46097c478bd9Sstevel@tonic-gate 46107c478bd9Sstevel@tonic-gate static void 46117c478bd9Sstevel@tonic-gate info_rctl(zone_dochandle_t handle, FILE *fp, cmd_t *cmd) 46127c478bd9Sstevel@tonic-gate { 46137c478bd9Sstevel@tonic-gate struct zone_rctltab lookup, user; 46147c478bd9Sstevel@tonic-gate bool output = FALSE; 46157c478bd9Sstevel@tonic-gate 46167c478bd9Sstevel@tonic-gate if (zonecfg_setrctlent(handle) != Z_OK) 46177c478bd9Sstevel@tonic-gate return; 46187c478bd9Sstevel@tonic-gate while (zonecfg_getrctlent(handle, &lookup) == Z_OK) { 46197c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs == 0) { 46207c478bd9Sstevel@tonic-gate output_rctl(fp, &lookup); 46217c478bd9Sstevel@tonic-gate } else if (fill_in_rctltab(cmd, &user, TRUE) == Z_OK && 46227c478bd9Sstevel@tonic-gate (strlen(user.zone_rctl_name) == 0 || 46237c478bd9Sstevel@tonic-gate strcmp(user.zone_rctl_name, lookup.zone_rctl_name) == 0)) { 46247c478bd9Sstevel@tonic-gate output_rctl(fp, &lookup); 46257c478bd9Sstevel@tonic-gate output = TRUE; 46267c478bd9Sstevel@tonic-gate } 46277c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(lookup.zone_rctl_valptr); 46287c478bd9Sstevel@tonic-gate } 46297c478bd9Sstevel@tonic-gate (void) zonecfg_endrctlent(handle); 46307c478bd9Sstevel@tonic-gate /* 46317c478bd9Sstevel@tonic-gate * If a property n/v pair was specified, warn the user if there was 46327c478bd9Sstevel@tonic-gate * nothing to output. 46337c478bd9Sstevel@tonic-gate */ 46347c478bd9Sstevel@tonic-gate if (!output && cmd->cmd_prop_nv_pairs > 0) 46357c478bd9Sstevel@tonic-gate (void) printf(gettext("No such %s resource.\n"), 46367c478bd9Sstevel@tonic-gate rt_to_str(RT_RCTL)); 46377c478bd9Sstevel@tonic-gate } 46387c478bd9Sstevel@tonic-gate 46397c478bd9Sstevel@tonic-gate static void 46407c478bd9Sstevel@tonic-gate output_attr(FILE *fp, struct zone_attrtab *attrtab) 46417c478bd9Sstevel@tonic-gate { 46427c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s:\n", rt_to_str(RT_ATTR)); 46437c478bd9Sstevel@tonic-gate output_prop(fp, PT_NAME, attrtab->zone_attr_name, B_TRUE); 46447c478bd9Sstevel@tonic-gate output_prop(fp, PT_TYPE, attrtab->zone_attr_type, B_TRUE); 46457c478bd9Sstevel@tonic-gate output_prop(fp, PT_VALUE, attrtab->zone_attr_value, B_TRUE); 46467c478bd9Sstevel@tonic-gate } 46477c478bd9Sstevel@tonic-gate 46487c478bd9Sstevel@tonic-gate static void 46497c478bd9Sstevel@tonic-gate info_attr(zone_dochandle_t handle, FILE *fp, cmd_t *cmd) 46507c478bd9Sstevel@tonic-gate { 46517c478bd9Sstevel@tonic-gate struct zone_attrtab lookup, user; 46527c478bd9Sstevel@tonic-gate bool output = FALSE; 46537c478bd9Sstevel@tonic-gate 46547c478bd9Sstevel@tonic-gate if (zonecfg_setattrent(handle) != Z_OK) 46557c478bd9Sstevel@tonic-gate return; 46567c478bd9Sstevel@tonic-gate while (zonecfg_getattrent(handle, &lookup) == Z_OK) { 46577c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs == 0) { 46587c478bd9Sstevel@tonic-gate output_attr(fp, &lookup); 46597c478bd9Sstevel@tonic-gate continue; 46607c478bd9Sstevel@tonic-gate } 46617c478bd9Sstevel@tonic-gate if (fill_in_attrtab(cmd, &user, TRUE) != Z_OK) 46627c478bd9Sstevel@tonic-gate continue; 46637c478bd9Sstevel@tonic-gate if (strlen(user.zone_attr_name) > 0 && 46647c478bd9Sstevel@tonic-gate strcmp(user.zone_attr_name, lookup.zone_attr_name) != 0) 46657c478bd9Sstevel@tonic-gate continue; /* no match */ 46667c478bd9Sstevel@tonic-gate if (strlen(user.zone_attr_type) > 0 && 46677c478bd9Sstevel@tonic-gate strcmp(user.zone_attr_type, lookup.zone_attr_type) != 0) 46687c478bd9Sstevel@tonic-gate continue; /* no match */ 46697c478bd9Sstevel@tonic-gate if (strlen(user.zone_attr_value) > 0 && 46707c478bd9Sstevel@tonic-gate strcmp(user.zone_attr_value, lookup.zone_attr_value) != 0) 46717c478bd9Sstevel@tonic-gate continue; /* no match */ 46727c478bd9Sstevel@tonic-gate output_attr(fp, &lookup); 46737c478bd9Sstevel@tonic-gate output = TRUE; 46747c478bd9Sstevel@tonic-gate } 46757c478bd9Sstevel@tonic-gate (void) zonecfg_endattrent(handle); 46767c478bd9Sstevel@tonic-gate /* 46777c478bd9Sstevel@tonic-gate * If a property n/v pair was specified, warn the user if there was 46787c478bd9Sstevel@tonic-gate * nothing to output. 46797c478bd9Sstevel@tonic-gate */ 46807c478bd9Sstevel@tonic-gate if (!output && cmd->cmd_prop_nv_pairs > 0) 46817c478bd9Sstevel@tonic-gate (void) printf(gettext("No such %s resource.\n"), 46827c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR)); 46837c478bd9Sstevel@tonic-gate } 46847c478bd9Sstevel@tonic-gate 4685fa9e4066Sahrens static void 4686fa9e4066Sahrens output_ds(FILE *fp, struct zone_dstab *dstab) 4687fa9e4066Sahrens { 4688fa9e4066Sahrens (void) fprintf(fp, "%s:\n", rt_to_str(RT_DATASET)); 4689fa9e4066Sahrens output_prop(fp, PT_NAME, dstab->zone_dataset_name, B_TRUE); 4690fa9e4066Sahrens } 4691fa9e4066Sahrens 4692fa9e4066Sahrens static void 4693fa9e4066Sahrens info_ds(zone_dochandle_t handle, FILE *fp, cmd_t *cmd) 4694fa9e4066Sahrens { 4695fa9e4066Sahrens struct zone_dstab lookup, user; 4696fa9e4066Sahrens bool output = FALSE; 4697fa9e4066Sahrens 46980209230bSgjelinek if (zonecfg_setdsent(handle) != Z_OK) 4699fa9e4066Sahrens return; 4700fa9e4066Sahrens while (zonecfg_getdsent(handle, &lookup) == Z_OK) { 4701fa9e4066Sahrens if (cmd->cmd_prop_nv_pairs == 0) { 4702fa9e4066Sahrens output_ds(fp, &lookup); 4703fa9e4066Sahrens continue; 4704fa9e4066Sahrens } 4705fa9e4066Sahrens if (fill_in_dstab(cmd, &user, TRUE) != Z_OK) 4706fa9e4066Sahrens continue; 4707fa9e4066Sahrens if (strlen(user.zone_dataset_name) > 0 && 4708fa9e4066Sahrens strcmp(user.zone_dataset_name, 4709fa9e4066Sahrens lookup.zone_dataset_name) != 0) 4710fa9e4066Sahrens continue; /* no match */ 4711fa9e4066Sahrens output_ds(fp, &lookup); 4712fa9e4066Sahrens output = TRUE; 4713fa9e4066Sahrens } 4714fa9e4066Sahrens (void) zonecfg_enddsent(handle); 4715fa9e4066Sahrens /* 4716fa9e4066Sahrens * If a property n/v pair was specified, warn the user if there was 4717fa9e4066Sahrens * nothing to output. 4718fa9e4066Sahrens */ 4719fa9e4066Sahrens if (!output && cmd->cmd_prop_nv_pairs > 0) 4720fa9e4066Sahrens (void) printf(gettext("No such %s resource.\n"), 4721fa9e4066Sahrens rt_to_str(RT_DATASET)); 4722fa9e4066Sahrens } 4723fa9e4066Sahrens 47240209230bSgjelinek static void 47250209230bSgjelinek output_pset(FILE *fp, struct zone_psettab *psettab) 47260209230bSgjelinek { 47270209230bSgjelinek (void) fprintf(fp, "%s:\n", rt_to_str(RT_DCPU)); 47280209230bSgjelinek if (strcmp(psettab->zone_ncpu_min, psettab->zone_ncpu_max) == 0) 47290209230bSgjelinek (void) fprintf(fp, "\t%s: %s\n", pt_to_str(PT_NCPUS), 47300209230bSgjelinek psettab->zone_ncpu_max); 47310209230bSgjelinek else 47320209230bSgjelinek (void) fprintf(fp, "\t%s: %s-%s\n", pt_to_str(PT_NCPUS), 47330209230bSgjelinek psettab->zone_ncpu_min, psettab->zone_ncpu_max); 47340209230bSgjelinek if (psettab->zone_importance[0] != '\0') 47350209230bSgjelinek (void) fprintf(fp, "\t%s: %s\n", pt_to_str(PT_IMPORTANCE), 47360209230bSgjelinek psettab->zone_importance); 47370209230bSgjelinek } 47380209230bSgjelinek 47390209230bSgjelinek static void 47400209230bSgjelinek info_pset(zone_dochandle_t handle, FILE *fp) 47410209230bSgjelinek { 47420209230bSgjelinek struct zone_psettab lookup; 47430209230bSgjelinek 47440209230bSgjelinek if (zonecfg_getpsetent(handle, &lookup) == Z_OK) 47450209230bSgjelinek output_pset(fp, &lookup); 47460209230bSgjelinek } 47470209230bSgjelinek 47480209230bSgjelinek static void 47490209230bSgjelinek info_aliased_rctl(zone_dochandle_t handle, FILE *fp, char *alias) 47500209230bSgjelinek { 47510209230bSgjelinek uint64_t limit; 47520209230bSgjelinek 47530209230bSgjelinek if (zonecfg_get_aliased_rctl(handle, alias, &limit) == Z_OK) { 47540209230bSgjelinek /* convert memory based properties */ 47550209230bSgjelinek if (strcmp(alias, ALIAS_MAXSHMMEM) == 0) { 47560209230bSgjelinek char buf[128]; 47570209230bSgjelinek 47580209230bSgjelinek (void) snprintf(buf, sizeof (buf), "%llu", limit); 47590209230bSgjelinek bytes_to_units(buf, buf, sizeof (buf)); 47600209230bSgjelinek (void) fprintf(fp, "[%s: %s]\n", alias, buf); 47610209230bSgjelinek return; 47620209230bSgjelinek } 47630209230bSgjelinek 47640209230bSgjelinek (void) fprintf(fp, "[%s: %llu]\n", alias, limit); 47650209230bSgjelinek } 47660209230bSgjelinek } 47670209230bSgjelinek 47680209230bSgjelinek static void 47690209230bSgjelinek bytes_to_units(char *str, char *buf, int bufsize) 47700209230bSgjelinek { 47710209230bSgjelinek unsigned long long num; 47720209230bSgjelinek unsigned long long save = 0; 47730209230bSgjelinek char *units = "BKMGT"; 47740209230bSgjelinek char *up = units; 47750209230bSgjelinek 47760209230bSgjelinek num = strtoll(str, NULL, 10); 47770209230bSgjelinek 47780209230bSgjelinek if (num < 1024) { 47790209230bSgjelinek (void) snprintf(buf, bufsize, "%llu", num); 47800209230bSgjelinek return; 47810209230bSgjelinek } 47820209230bSgjelinek 47830209230bSgjelinek while ((num >= 1024) && (*up != 'T')) { 47840209230bSgjelinek up++; /* next unit of measurement */ 47850209230bSgjelinek save = num; 47860209230bSgjelinek num = (num + 512) >> 10; 47870209230bSgjelinek } 47880209230bSgjelinek 47890209230bSgjelinek /* check if we should output a fraction. snprintf will round for us */ 47900209230bSgjelinek if (save % 1024 != 0 && ((save >> 10) < 10)) 47910209230bSgjelinek (void) snprintf(buf, bufsize, "%2.1f%c", ((float)save / 1024), 47920209230bSgjelinek *up); 47930209230bSgjelinek else 47940209230bSgjelinek (void) snprintf(buf, bufsize, "%llu%c", num, *up); 47950209230bSgjelinek } 47960209230bSgjelinek 47970209230bSgjelinek static void 47980209230bSgjelinek output_mcap(FILE *fp, struct zone_mcaptab *mcaptab, int showswap, 47990209230bSgjelinek uint64_t maxswap, int showlocked, uint64_t maxlocked) 48000209230bSgjelinek { 48010209230bSgjelinek char buf[128]; 48020209230bSgjelinek 48030209230bSgjelinek (void) fprintf(fp, "%s:\n", rt_to_str(RT_MCAP)); 48040209230bSgjelinek if (mcaptab->zone_physmem_cap[0] != '\0') { 48050209230bSgjelinek bytes_to_units(mcaptab->zone_physmem_cap, buf, sizeof (buf)); 48060209230bSgjelinek output_prop(fp, PT_PHYSICAL, buf, B_TRUE); 48070209230bSgjelinek } 48080209230bSgjelinek 48090209230bSgjelinek if (showswap == Z_OK) { 48100209230bSgjelinek (void) snprintf(buf, sizeof (buf), "%llu", maxswap); 48110209230bSgjelinek bytes_to_units(buf, buf, sizeof (buf)); 48120209230bSgjelinek output_prop(fp, PT_SWAP, buf, B_TRUE); 48130209230bSgjelinek } 48140209230bSgjelinek 48150209230bSgjelinek if (showlocked == Z_OK) { 48160209230bSgjelinek (void) snprintf(buf, sizeof (buf), "%llu", maxlocked); 48170209230bSgjelinek bytes_to_units(buf, buf, sizeof (buf)); 48180209230bSgjelinek output_prop(fp, PT_LOCKED, buf, B_TRUE); 48190209230bSgjelinek } 48200209230bSgjelinek } 48210209230bSgjelinek 48220209230bSgjelinek static void 48230209230bSgjelinek info_mcap(zone_dochandle_t handle, FILE *fp) 48240209230bSgjelinek { 48250209230bSgjelinek int res1, res2, res3; 48260209230bSgjelinek uint64_t swap_limit; 48270209230bSgjelinek uint64_t locked_limit; 48280209230bSgjelinek struct zone_mcaptab lookup; 48290209230bSgjelinek 48300209230bSgjelinek bzero(&lookup, sizeof (lookup)); 48310209230bSgjelinek res1 = zonecfg_getmcapent(handle, &lookup); 48320209230bSgjelinek res2 = zonecfg_get_aliased_rctl(handle, ALIAS_MAXSWAP, &swap_limit); 48330209230bSgjelinek res3 = zonecfg_get_aliased_rctl(handle, ALIAS_MAXLOCKEDMEM, 48340209230bSgjelinek &locked_limit); 48350209230bSgjelinek 48360209230bSgjelinek if (res1 == Z_OK || res2 == Z_OK || res3 == Z_OK) 48370209230bSgjelinek output_mcap(fp, &lookup, res2, swap_limit, res3, locked_limit); 48380209230bSgjelinek } 48390209230bSgjelinek 48407c478bd9Sstevel@tonic-gate void 48417c478bd9Sstevel@tonic-gate info_func(cmd_t *cmd) 48427c478bd9Sstevel@tonic-gate { 48437c478bd9Sstevel@tonic-gate FILE *fp = stdout; 48447c478bd9Sstevel@tonic-gate bool need_to_close = FALSE; 48457c478bd9Sstevel@tonic-gate char *pager; 48460209230bSgjelinek int type; 48470209230bSgjelinek int res1, res2; 48480209230bSgjelinek uint64_t swap_limit; 48490209230bSgjelinek uint64_t locked_limit; 48507c478bd9Sstevel@tonic-gate 48517c478bd9Sstevel@tonic-gate assert(cmd != NULL); 48527c478bd9Sstevel@tonic-gate 48537c478bd9Sstevel@tonic-gate if (initialize(TRUE) != Z_OK) 48547c478bd9Sstevel@tonic-gate return; 48557c478bd9Sstevel@tonic-gate 48567c478bd9Sstevel@tonic-gate /* don't page error output */ 48577c478bd9Sstevel@tonic-gate if (interactive_mode) { 48587c478bd9Sstevel@tonic-gate if ((pager = getenv("PAGER")) == NULL) 48597c478bd9Sstevel@tonic-gate pager = PAGER; 48607c478bd9Sstevel@tonic-gate if ((fp = popen(pager, "w")) != NULL) 48617c478bd9Sstevel@tonic-gate need_to_close = TRUE; 48627c478bd9Sstevel@tonic-gate setbuf(fp, NULL); 48637c478bd9Sstevel@tonic-gate } 48647c478bd9Sstevel@tonic-gate 48657c478bd9Sstevel@tonic-gate if (!global_scope) { 48667c478bd9Sstevel@tonic-gate switch (resource_scope) { 48677c478bd9Sstevel@tonic-gate case RT_FS: 48687c478bd9Sstevel@tonic-gate output_fs(fp, &in_progress_fstab); 48697c478bd9Sstevel@tonic-gate break; 48707c478bd9Sstevel@tonic-gate case RT_IPD: 48717c478bd9Sstevel@tonic-gate output_ipd(fp, &in_progress_ipdtab); 48727c478bd9Sstevel@tonic-gate break; 48737c478bd9Sstevel@tonic-gate case RT_NET: 48747c478bd9Sstevel@tonic-gate output_net(fp, &in_progress_nwiftab); 48757c478bd9Sstevel@tonic-gate break; 48767c478bd9Sstevel@tonic-gate case RT_DEVICE: 48777c478bd9Sstevel@tonic-gate output_dev(fp, &in_progress_devtab); 48787c478bd9Sstevel@tonic-gate break; 48797c478bd9Sstevel@tonic-gate case RT_RCTL: 48807c478bd9Sstevel@tonic-gate output_rctl(fp, &in_progress_rctltab); 48817c478bd9Sstevel@tonic-gate break; 48827c478bd9Sstevel@tonic-gate case RT_ATTR: 48837c478bd9Sstevel@tonic-gate output_attr(fp, &in_progress_attrtab); 48847c478bd9Sstevel@tonic-gate break; 4885fa9e4066Sahrens case RT_DATASET: 4886fa9e4066Sahrens output_ds(fp, &in_progress_dstab); 4887fa9e4066Sahrens break; 48880209230bSgjelinek case RT_DCPU: 48890209230bSgjelinek output_pset(fp, &in_progress_psettab); 48900209230bSgjelinek break; 48910209230bSgjelinek case RT_MCAP: 48920209230bSgjelinek res1 = zonecfg_get_aliased_rctl(handle, ALIAS_MAXSWAP, 48930209230bSgjelinek &swap_limit); 48940209230bSgjelinek res2 = zonecfg_get_aliased_rctl(handle, 48950209230bSgjelinek ALIAS_MAXLOCKEDMEM, &locked_limit); 48960209230bSgjelinek output_mcap(fp, &in_progress_mcaptab, res1, swap_limit, 48970209230bSgjelinek res2, locked_limit); 48980209230bSgjelinek break; 48997c478bd9Sstevel@tonic-gate } 49007c478bd9Sstevel@tonic-gate goto cleanup; 49017c478bd9Sstevel@tonic-gate } 49027c478bd9Sstevel@tonic-gate 49030209230bSgjelinek type = cmd->cmd_res_type; 49040209230bSgjelinek 49050209230bSgjelinek if (gz_invalid_rt_property(type)) { 49060209230bSgjelinek zerr(gettext("%s is not a valid property for the global zone."), 49070209230bSgjelinek rt_to_str(type)); 49080209230bSgjelinek goto cleanup; 49090209230bSgjelinek } 49100209230bSgjelinek 49110209230bSgjelinek if (gz_invalid_resource(type)) { 49120209230bSgjelinek zerr(gettext("%s is not a valid resource for the global zone."), 49130209230bSgjelinek rt_to_str(type)); 49140209230bSgjelinek goto cleanup; 49150209230bSgjelinek } 49160209230bSgjelinek 49177c478bd9Sstevel@tonic-gate switch (cmd->cmd_res_type) { 49187c478bd9Sstevel@tonic-gate case RT_UNKNOWN: 4919087719fdSdp info_zonename(handle, fp); 49200209230bSgjelinek if (!global_zone) { 49210209230bSgjelinek info_zonepath(handle, fp); 49220209230bSgjelinek info_brand(handle, fp); 49230209230bSgjelinek info_autoboot(handle, fp); 49240209230bSgjelinek info_bootargs(handle, fp); 49250209230bSgjelinek } 49267c478bd9Sstevel@tonic-gate info_pool(handle, fp); 49270209230bSgjelinek if (!global_zone) { 49280209230bSgjelinek info_limitpriv(handle, fp); 49290209230bSgjelinek info_sched(handle, fp); 4930*f4b3ec61Sdh info_iptype(handle, fp); 49310209230bSgjelinek } 49320209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXLWPS); 49330209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXSHMMEM); 49340209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXSHMIDS); 49350209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXMSGIDS); 49360209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXSEMIDS); 49370209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_SHARES); 49380209230bSgjelinek if (!global_zone) { 49390209230bSgjelinek info_ipd(handle, fp, cmd); 49400209230bSgjelinek info_fs(handle, fp, cmd); 49410209230bSgjelinek info_net(handle, fp, cmd); 49420209230bSgjelinek info_dev(handle, fp, cmd); 49430209230bSgjelinek } 49440209230bSgjelinek info_pset(handle, fp); 49450209230bSgjelinek info_mcap(handle, fp); 49460209230bSgjelinek if (!global_zone) { 49470209230bSgjelinek info_attr(handle, fp, cmd); 49480209230bSgjelinek info_ds(handle, fp, cmd); 49490209230bSgjelinek } 49507c478bd9Sstevel@tonic-gate info_rctl(handle, fp, cmd); 49517c478bd9Sstevel@tonic-gate break; 4952087719fdSdp case RT_ZONENAME: 4953087719fdSdp info_zonename(handle, fp); 4954087719fdSdp break; 49557c478bd9Sstevel@tonic-gate case RT_ZONEPATH: 49567c478bd9Sstevel@tonic-gate info_zonepath(handle, fp); 49577c478bd9Sstevel@tonic-gate break; 49589acbbeafSnn case RT_BRAND: 49599acbbeafSnn info_brand(handle, fp); 49609acbbeafSnn break; 49617c478bd9Sstevel@tonic-gate case RT_AUTOBOOT: 49627c478bd9Sstevel@tonic-gate info_autoboot(handle, fp); 49637c478bd9Sstevel@tonic-gate break; 49647c478bd9Sstevel@tonic-gate case RT_POOL: 49657c478bd9Sstevel@tonic-gate info_pool(handle, fp); 49667c478bd9Sstevel@tonic-gate break; 4967ffbafc53Scomay case RT_LIMITPRIV: 4968ffbafc53Scomay info_limitpriv(handle, fp); 4969ffbafc53Scomay break; 49703f2f09c1Sdp case RT_BOOTARGS: 49713f2f09c1Sdp info_bootargs(handle, fp); 49723f2f09c1Sdp break; 49730209230bSgjelinek case RT_SCHED: 49740209230bSgjelinek info_sched(handle, fp); 49750209230bSgjelinek break; 4976*f4b3ec61Sdh case RT_IPTYPE: 4977*f4b3ec61Sdh info_iptype(handle, fp); 4978*f4b3ec61Sdh break; 49790209230bSgjelinek case RT_MAXLWPS: 49800209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXLWPS); 49810209230bSgjelinek break; 49820209230bSgjelinek case RT_MAXSHMMEM: 49830209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXSHMMEM); 49840209230bSgjelinek break; 49850209230bSgjelinek case RT_MAXSHMIDS: 49860209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXSHMIDS); 49870209230bSgjelinek break; 49880209230bSgjelinek case RT_MAXMSGIDS: 49890209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXMSGIDS); 49900209230bSgjelinek break; 49910209230bSgjelinek case RT_MAXSEMIDS: 49920209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXSEMIDS); 49930209230bSgjelinek break; 49940209230bSgjelinek case RT_SHARES: 49950209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_SHARES); 49960209230bSgjelinek break; 49977c478bd9Sstevel@tonic-gate case RT_FS: 49987c478bd9Sstevel@tonic-gate info_fs(handle, fp, cmd); 49997c478bd9Sstevel@tonic-gate break; 50007c478bd9Sstevel@tonic-gate case RT_IPD: 50017c478bd9Sstevel@tonic-gate info_ipd(handle, fp, cmd); 50027c478bd9Sstevel@tonic-gate break; 50037c478bd9Sstevel@tonic-gate case RT_NET: 50047c478bd9Sstevel@tonic-gate info_net(handle, fp, cmd); 50057c478bd9Sstevel@tonic-gate break; 50067c478bd9Sstevel@tonic-gate case RT_DEVICE: 50077c478bd9Sstevel@tonic-gate info_dev(handle, fp, cmd); 50087c478bd9Sstevel@tonic-gate break; 50097c478bd9Sstevel@tonic-gate case RT_RCTL: 50107c478bd9Sstevel@tonic-gate info_rctl(handle, fp, cmd); 50117c478bd9Sstevel@tonic-gate break; 50127c478bd9Sstevel@tonic-gate case RT_ATTR: 50137c478bd9Sstevel@tonic-gate info_attr(handle, fp, cmd); 50147c478bd9Sstevel@tonic-gate break; 5015fa9e4066Sahrens case RT_DATASET: 5016fa9e4066Sahrens info_ds(handle, fp, cmd); 5017fa9e4066Sahrens break; 50180209230bSgjelinek case RT_DCPU: 50190209230bSgjelinek info_pset(handle, fp); 50200209230bSgjelinek break; 50210209230bSgjelinek case RT_MCAP: 50220209230bSgjelinek info_mcap(handle, fp); 50230209230bSgjelinek break; 50247c478bd9Sstevel@tonic-gate default: 50257c478bd9Sstevel@tonic-gate zone_perror(rt_to_str(cmd->cmd_res_type), Z_NO_RESOURCE_TYPE, 50267c478bd9Sstevel@tonic-gate TRUE); 50277c478bd9Sstevel@tonic-gate } 50287c478bd9Sstevel@tonic-gate 50297c478bd9Sstevel@tonic-gate cleanup: 50307c478bd9Sstevel@tonic-gate if (need_to_close) 50317c478bd9Sstevel@tonic-gate (void) pclose(fp); 50327c478bd9Sstevel@tonic-gate } 50337c478bd9Sstevel@tonic-gate 5034087719fdSdp /* 5035087719fdSdp * Helper function for verify-- checks that a required string property 5036087719fdSdp * exists. 5037087719fdSdp */ 5038087719fdSdp static void 5039087719fdSdp check_reqd_prop(char *attr, int rt, int pt, int *ret_val) 50407c478bd9Sstevel@tonic-gate { 5041087719fdSdp if (strlen(attr) == 0) { 5042087719fdSdp zerr(gettext("%s: %s not specified"), rt_to_str(rt), 5043087719fdSdp pt_to_str(pt)); 5044087719fdSdp saw_error = TRUE; 5045087719fdSdp if (*ret_val == Z_OK) 5046087719fdSdp *ret_val = Z_REQD_PROPERTY_MISSING; 50477c478bd9Sstevel@tonic-gate } 50487c478bd9Sstevel@tonic-gate } 50497c478bd9Sstevel@tonic-gate 50509acbbeafSnn static int 50519acbbeafSnn do_subproc(char *cmdbuf) 50529acbbeafSnn { 50539acbbeafSnn char inbuf[MAX_CMD_LEN]; 50549acbbeafSnn FILE *file; 50559acbbeafSnn int status; 50569acbbeafSnn 50579acbbeafSnn file = popen(cmdbuf, "r"); 50589acbbeafSnn if (file == NULL) { 50599acbbeafSnn zerr(gettext("Could not launch: %s"), cmdbuf); 50609acbbeafSnn return (-1); 50619acbbeafSnn } 50629acbbeafSnn 50639acbbeafSnn while (fgets(inbuf, sizeof (inbuf), file) != NULL) 50649acbbeafSnn fprintf(stderr, "%s", inbuf); 50659acbbeafSnn status = pclose(file); 50669acbbeafSnn 50679acbbeafSnn if (WIFSIGNALED(status)) { 50689acbbeafSnn zerr(gettext("%s unexpectedly terminated due to signal %d"), 50699acbbeafSnn cmdbuf, WTERMSIG(status)); 50709acbbeafSnn return (-1); 50719acbbeafSnn } 50729acbbeafSnn assert(WIFEXITED(status)); 50739acbbeafSnn return (WEXITSTATUS(status)); 50749acbbeafSnn } 50759acbbeafSnn 50769acbbeafSnn static int 50779acbbeafSnn brand_verify(zone_dochandle_t handle) 50789acbbeafSnn { 50796e65f9afSnn char xml_file[32]; 50809acbbeafSnn char cmdbuf[MAX_CMD_LEN]; 5081123807fbSedp brand_handle_t bh; 50829acbbeafSnn char brand[MAXNAMELEN]; 50839acbbeafSnn int err; 50849acbbeafSnn 50859acbbeafSnn if (zonecfg_get_brand(handle, brand, sizeof (brand)) != Z_OK) { 50869acbbeafSnn zerr("%s: %s\n", zone, gettext("could not get zone brand")); 50879acbbeafSnn return (Z_INVALID_DOCUMENT); 50889acbbeafSnn } 5089123807fbSedp if ((bh = brand_open(brand)) == NULL) { 50909acbbeafSnn zerr("%s: %s\n", zone, gettext("unknown brand.")); 50919acbbeafSnn return (Z_INVALID_DOCUMENT); 50929acbbeafSnn } 50939acbbeafSnn 50949acbbeafSnn /* 50959acbbeafSnn * Fetch the verify command, if any, from the brand configuration 50969acbbeafSnn * and build the command line to execute it. 50979acbbeafSnn */ 50989acbbeafSnn strcpy(cmdbuf, EXEC_PREFIX); 5099123807fbSedp err = brand_get_verify_cfg(bh, cmdbuf + EXEC_LEN, 51009acbbeafSnn sizeof (cmdbuf) - (EXEC_LEN + (strlen(xml_file) + 1))); 5101123807fbSedp brand_close(bh); 51029acbbeafSnn if (err != Z_OK) { 51039acbbeafSnn zerr("%s: %s\n", zone, 51049acbbeafSnn gettext("could not get brand verification command")); 51059acbbeafSnn return (Z_INVALID_DOCUMENT); 51069acbbeafSnn } 51079acbbeafSnn 51089acbbeafSnn /* 51099acbbeafSnn * If the brand doesn't provide a verification routine, we just 51109acbbeafSnn * return success. 51119acbbeafSnn */ 51129acbbeafSnn if (strlen(cmdbuf) == EXEC_LEN) 51139acbbeafSnn return (Z_OK); 51149acbbeafSnn 51159acbbeafSnn /* 51169acbbeafSnn * Dump the current config information for this zone to a file. 51179acbbeafSnn */ 51186e65f9afSnn strcpy(xml_file, "/tmp/zonecfg_verify.XXXXXX"); 51199acbbeafSnn if (mkstemp(xml_file) == NULL) 51209acbbeafSnn return (Z_TEMP_FILE); 51219acbbeafSnn if ((err = zonecfg_verify_save(handle, xml_file)) != Z_OK) { 51229acbbeafSnn (void) unlink(xml_file); 51239acbbeafSnn return (err); 51249acbbeafSnn } 51259acbbeafSnn 51269acbbeafSnn /* 51279acbbeafSnn * Execute the verification command. 51289acbbeafSnn */ 51299acbbeafSnn if ((strlcat(cmdbuf, " ", MAX_CMD_LEN) >= MAX_CMD_LEN) || 51309acbbeafSnn (strlcat(cmdbuf, xml_file, MAX_CMD_LEN) >= MAX_CMD_LEN)) { 51319acbbeafSnn err = Z_BRAND_ERROR; 51329acbbeafSnn } else { 51339acbbeafSnn err = do_subproc(cmdbuf); 51349acbbeafSnn } 51359acbbeafSnn 51369acbbeafSnn (void) unlink(xml_file); 51379acbbeafSnn return ((err == Z_OK) ? Z_OK : Z_BRAND_ERROR); 51389acbbeafSnn } 51399acbbeafSnn 51407c478bd9Sstevel@tonic-gate /* 51417c478bd9Sstevel@tonic-gate * See the DTD for which attributes are required for which resources. 51427c478bd9Sstevel@tonic-gate * 51437c478bd9Sstevel@tonic-gate * This function can be called by commit_func(), which needs to save things, 51447c478bd9Sstevel@tonic-gate * in addition to the general call from parse_and_run(), which doesn't need 51457c478bd9Sstevel@tonic-gate * things saved. Since the parameters are standardized, we distinguish by 51467c478bd9Sstevel@tonic-gate * having commit_func() call here with cmd->cmd_arg set to "save" to indicate 51477c478bd9Sstevel@tonic-gate * that a save is needed. 51487c478bd9Sstevel@tonic-gate */ 51497c478bd9Sstevel@tonic-gate void 51507c478bd9Sstevel@tonic-gate verify_func(cmd_t *cmd) 51517c478bd9Sstevel@tonic-gate { 51527c478bd9Sstevel@tonic-gate struct zone_nwiftab nwiftab; 51537c478bd9Sstevel@tonic-gate struct zone_fstab fstab; 51547c478bd9Sstevel@tonic-gate struct zone_attrtab attrtab; 51557c478bd9Sstevel@tonic-gate struct zone_rctltab rctltab; 5156fa9e4066Sahrens struct zone_dstab dstab; 51570209230bSgjelinek struct zone_psettab psettab; 51587c478bd9Sstevel@tonic-gate char zonepath[MAXPATHLEN]; 51590209230bSgjelinek char sched[MAXNAMELEN]; 51609acbbeafSnn char brand[MAXNAMELEN]; 51617c478bd9Sstevel@tonic-gate int err, ret_val = Z_OK, arg; 51627c478bd9Sstevel@tonic-gate bool save = FALSE; 5163*f4b3ec61Sdh zone_iptype_t iptype; 51640209230bSgjelinek boolean_t has_cpu_shares = B_FALSE; 51657c478bd9Sstevel@tonic-gate 51667c478bd9Sstevel@tonic-gate optind = 0; 51677c478bd9Sstevel@tonic-gate if ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?")) != EOF) { 51687c478bd9Sstevel@tonic-gate switch (arg) { 51697c478bd9Sstevel@tonic-gate case '?': 51707c478bd9Sstevel@tonic-gate longer_usage(CMD_VERIFY); 51717c478bd9Sstevel@tonic-gate return; 51727c478bd9Sstevel@tonic-gate default: 51737c478bd9Sstevel@tonic-gate short_usage(CMD_VERIFY); 51747c478bd9Sstevel@tonic-gate return; 51757c478bd9Sstevel@tonic-gate } 51767c478bd9Sstevel@tonic-gate } 51777c478bd9Sstevel@tonic-gate if (optind > cmd->cmd_argc) { 51787c478bd9Sstevel@tonic-gate short_usage(CMD_VERIFY); 51797c478bd9Sstevel@tonic-gate return; 51807c478bd9Sstevel@tonic-gate } 51817c478bd9Sstevel@tonic-gate 51827c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_VERIFY)) 51837c478bd9Sstevel@tonic-gate return; 51847c478bd9Sstevel@tonic-gate 51857c478bd9Sstevel@tonic-gate assert(cmd != NULL); 51867c478bd9Sstevel@tonic-gate 51877c478bd9Sstevel@tonic-gate if (cmd->cmd_argc > 0 && (strcmp(cmd->cmd_argv[0], "save") == 0)) 51887c478bd9Sstevel@tonic-gate save = TRUE; 51897c478bd9Sstevel@tonic-gate if (initialize(TRUE) != Z_OK) 51907c478bd9Sstevel@tonic-gate return; 51917c478bd9Sstevel@tonic-gate 51920209230bSgjelinek if (zonecfg_get_zonepath(handle, zonepath, sizeof (zonepath)) != Z_OK && 51930209230bSgjelinek !global_zone) { 5194087719fdSdp zerr(gettext("%s not specified"), pt_to_str(PT_ZONEPATH)); 51957c478bd9Sstevel@tonic-gate ret_val = Z_REQD_RESOURCE_MISSING; 51967c478bd9Sstevel@tonic-gate saw_error = TRUE; 51977c478bd9Sstevel@tonic-gate } 51980209230bSgjelinek if (strlen(zonepath) == 0 && !global_zone) { 5199087719fdSdp zerr(gettext("%s cannot be empty."), pt_to_str(PT_ZONEPATH)); 52007c478bd9Sstevel@tonic-gate ret_val = Z_REQD_RESOURCE_MISSING; 52017c478bd9Sstevel@tonic-gate saw_error = TRUE; 52027c478bd9Sstevel@tonic-gate } 52037c478bd9Sstevel@tonic-gate 52049acbbeafSnn if ((err = zonecfg_get_brand(handle, brand, sizeof (brand))) != Z_OK) { 52059acbbeafSnn zone_perror(zone, err, TRUE); 52069acbbeafSnn return; 52079acbbeafSnn } 52089acbbeafSnn if (strcmp(brand, NATIVE_BRAND_NAME) != 0) { 52099acbbeafSnn if ((err = brand_verify(handle)) != Z_OK) { 52109acbbeafSnn zone_perror(zone, err, TRUE); 52119acbbeafSnn return; 52129acbbeafSnn } 52139acbbeafSnn } 52149acbbeafSnn 5215*f4b3ec61Sdh if (zonecfg_get_iptype(handle, &iptype) != Z_OK) { 5216*f4b3ec61Sdh zerr("%s %s", gettext("cannot get"), pt_to_str(PT_IPTYPE)); 5217*f4b3ec61Sdh ret_val = Z_REQD_RESOURCE_MISSING; 5218*f4b3ec61Sdh saw_error = TRUE; 5219*f4b3ec61Sdh } 52207c478bd9Sstevel@tonic-gate if ((err = zonecfg_setipdent(handle)) != Z_OK) { 52217c478bd9Sstevel@tonic-gate zone_perror(zone, err, TRUE); 52227c478bd9Sstevel@tonic-gate return; 52237c478bd9Sstevel@tonic-gate } 52247c478bd9Sstevel@tonic-gate while (zonecfg_getipdent(handle, &fstab) == Z_OK) { 5225087719fdSdp check_reqd_prop(fstab.zone_fs_dir, RT_IPD, PT_DIR, &ret_val); 52267c478bd9Sstevel@tonic-gate } 52277c478bd9Sstevel@tonic-gate (void) zonecfg_endipdent(handle); 52287c478bd9Sstevel@tonic-gate 52297c478bd9Sstevel@tonic-gate if ((err = zonecfg_setfsent(handle)) != Z_OK) { 52307c478bd9Sstevel@tonic-gate zone_perror(zone, err, TRUE); 52317c478bd9Sstevel@tonic-gate return; 52327c478bd9Sstevel@tonic-gate } 52337c478bd9Sstevel@tonic-gate while (zonecfg_getfsent(handle, &fstab) == Z_OK) { 5234087719fdSdp check_reqd_prop(fstab.zone_fs_dir, RT_FS, PT_DIR, &ret_val); 5235087719fdSdp check_reqd_prop(fstab.zone_fs_special, RT_FS, PT_SPECIAL, 5236087719fdSdp &ret_val); 5237087719fdSdp check_reqd_prop(fstab.zone_fs_type, RT_FS, PT_TYPE, &ret_val); 5238087719fdSdp 52397c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(fstab.zone_fs_options); 52407c478bd9Sstevel@tonic-gate } 52417c478bd9Sstevel@tonic-gate (void) zonecfg_endfsent(handle); 52427c478bd9Sstevel@tonic-gate 52437c478bd9Sstevel@tonic-gate if ((err = zonecfg_setnwifent(handle)) != Z_OK) { 52447c478bd9Sstevel@tonic-gate zone_perror(zone, err, TRUE); 52457c478bd9Sstevel@tonic-gate return; 52467c478bd9Sstevel@tonic-gate } 52477c478bd9Sstevel@tonic-gate while (zonecfg_getnwifent(handle, &nwiftab) == Z_OK) { 5248*f4b3ec61Sdh /* 5249*f4b3ec61Sdh * physical is required in all cases. 5250*f4b3ec61Sdh * A shared IP requires an address, while 5251*f4b3ec61Sdh * an exclusive IP must not have an address. 5252*f4b3ec61Sdh */ 5253087719fdSdp check_reqd_prop(nwiftab.zone_nwif_physical, RT_NET, 5254087719fdSdp PT_PHYSICAL, &ret_val); 5255*f4b3ec61Sdh 5256*f4b3ec61Sdh switch (iptype) { 5257*f4b3ec61Sdh case ZS_SHARED: 5258*f4b3ec61Sdh check_reqd_prop(nwiftab.zone_nwif_address, RT_NET, 5259*f4b3ec61Sdh PT_ADDRESS, &ret_val); 5260*f4b3ec61Sdh break; 5261*f4b3ec61Sdh case ZS_EXCLUSIVE: 5262*f4b3ec61Sdh if (strlen(nwiftab.zone_nwif_address) > 0) { 5263*f4b3ec61Sdh zerr(gettext("%s: %s cannot be specified " 5264*f4b3ec61Sdh "for an exclusive IP type"), 5265*f4b3ec61Sdh rt_to_str(RT_NET), pt_to_str(PT_ADDRESS)); 5266*f4b3ec61Sdh saw_error = TRUE; 5267*f4b3ec61Sdh if (ret_val == Z_OK) 5268*f4b3ec61Sdh ret_val = Z_INVAL; 5269*f4b3ec61Sdh } 5270*f4b3ec61Sdh break; 5271*f4b3ec61Sdh } 52727c478bd9Sstevel@tonic-gate } 52737c478bd9Sstevel@tonic-gate (void) zonecfg_endnwifent(handle); 52747c478bd9Sstevel@tonic-gate 52757c478bd9Sstevel@tonic-gate if ((err = zonecfg_setrctlent(handle)) != Z_OK) { 52767c478bd9Sstevel@tonic-gate zone_perror(zone, err, TRUE); 52777c478bd9Sstevel@tonic-gate return; 52787c478bd9Sstevel@tonic-gate } 52797c478bd9Sstevel@tonic-gate while (zonecfg_getrctlent(handle, &rctltab) == Z_OK) { 5280087719fdSdp check_reqd_prop(rctltab.zone_rctl_name, RT_RCTL, PT_NAME, 5281087719fdSdp &ret_val); 5282087719fdSdp 52830209230bSgjelinek if (strcmp(rctltab.zone_rctl_name, "zone.cpu-shares") == 0) 52840209230bSgjelinek has_cpu_shares = B_TRUE; 52850209230bSgjelinek 52867c478bd9Sstevel@tonic-gate if (rctltab.zone_rctl_valptr == NULL) { 52877c478bd9Sstevel@tonic-gate zerr(gettext("%s: no %s specified"), 52887c478bd9Sstevel@tonic-gate rt_to_str(RT_RCTL), pt_to_str(PT_VALUE)); 52897c478bd9Sstevel@tonic-gate saw_error = TRUE; 52907c478bd9Sstevel@tonic-gate if (ret_val == Z_OK) 52917c478bd9Sstevel@tonic-gate ret_val = Z_REQD_PROPERTY_MISSING; 52927c478bd9Sstevel@tonic-gate } else { 52937c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctltab.zone_rctl_valptr); 52947c478bd9Sstevel@tonic-gate } 52957c478bd9Sstevel@tonic-gate } 52967c478bd9Sstevel@tonic-gate (void) zonecfg_endrctlent(handle); 52977c478bd9Sstevel@tonic-gate 52980209230bSgjelinek if (zonecfg_lookup_pset(handle, &psettab) == Z_OK && has_cpu_shares) { 52990209230bSgjelinek zerr(gettext("%s zone.cpu-shares and %s are incompatible."), 53000209230bSgjelinek rt_to_str(RT_RCTL), rt_to_str(RT_DCPU)); 53010209230bSgjelinek saw_error = TRUE; 53020209230bSgjelinek if (ret_val == Z_OK) 53030209230bSgjelinek ret_val = Z_INCOMPATIBLE; 53040209230bSgjelinek } 53050209230bSgjelinek 53060209230bSgjelinek if (has_cpu_shares && zonecfg_get_sched_class(handle, sched, 53070209230bSgjelinek sizeof (sched)) == Z_OK && strlen(sched) > 0 && 53080209230bSgjelinek strcmp(sched, "FSS") != 0) { 53090209230bSgjelinek zerr(gettext("WARNING: %s zone.cpu-shares and %s=%s are " 53100209230bSgjelinek "incompatible"), 53110209230bSgjelinek rt_to_str(RT_RCTL), rt_to_str(RT_SCHED), sched); 53120209230bSgjelinek saw_error = TRUE; 53130209230bSgjelinek if (ret_val == Z_OK) 53140209230bSgjelinek ret_val = Z_INCOMPATIBLE; 53150209230bSgjelinek } 53160209230bSgjelinek 53177c478bd9Sstevel@tonic-gate if ((err = zonecfg_setattrent(handle)) != Z_OK) { 53187c478bd9Sstevel@tonic-gate zone_perror(zone, err, TRUE); 53197c478bd9Sstevel@tonic-gate return; 53207c478bd9Sstevel@tonic-gate } 53217c478bd9Sstevel@tonic-gate while (zonecfg_getattrent(handle, &attrtab) == Z_OK) { 5322087719fdSdp check_reqd_prop(attrtab.zone_attr_name, RT_ATTR, PT_NAME, 5323087719fdSdp &ret_val); 5324087719fdSdp check_reqd_prop(attrtab.zone_attr_type, RT_ATTR, PT_TYPE, 5325087719fdSdp &ret_val); 5326087719fdSdp check_reqd_prop(attrtab.zone_attr_value, RT_ATTR, PT_VALUE, 5327087719fdSdp &ret_val); 53287c478bd9Sstevel@tonic-gate } 53297c478bd9Sstevel@tonic-gate (void) zonecfg_endattrent(handle); 53307c478bd9Sstevel@tonic-gate 5331fa9e4066Sahrens if ((err = zonecfg_setdsent(handle)) != Z_OK) { 5332fa9e4066Sahrens zone_perror(zone, err, TRUE); 5333fa9e4066Sahrens return; 5334fa9e4066Sahrens } 5335fa9e4066Sahrens while (zonecfg_getdsent(handle, &dstab) == Z_OK) { 5336fa9e4066Sahrens if (strlen(dstab.zone_dataset_name) == 0) { 5337fa9e4066Sahrens zerr("%s: %s %s", rt_to_str(RT_DATASET), 5338fa9e4066Sahrens pt_to_str(PT_NAME), gettext("not specified")); 5339fa9e4066Sahrens saw_error = TRUE; 5340fa9e4066Sahrens if (ret_val == Z_OK) 5341fa9e4066Sahrens ret_val = Z_REQD_PROPERTY_MISSING; 5342fa9e4066Sahrens } else if (!zfs_name_valid(dstab.zone_dataset_name, 5343fa9e4066Sahrens ZFS_TYPE_FILESYSTEM)) { 5344fa9e4066Sahrens zerr("%s: %s %s", rt_to_str(RT_DATASET), 5345fa9e4066Sahrens pt_to_str(PT_NAME), gettext("invalid")); 5346fa9e4066Sahrens saw_error = TRUE; 5347fa9e4066Sahrens if (ret_val == Z_OK) 5348fa9e4066Sahrens ret_val = Z_BAD_PROPERTY; 5349fa9e4066Sahrens } 5350fa9e4066Sahrens 5351fa9e4066Sahrens } 5352fa9e4066Sahrens (void) zonecfg_enddsent(handle); 5353fa9e4066Sahrens 53547c478bd9Sstevel@tonic-gate if (!global_scope) { 53557c478bd9Sstevel@tonic-gate zerr(gettext("resource specification incomplete")); 53567c478bd9Sstevel@tonic-gate saw_error = TRUE; 53577c478bd9Sstevel@tonic-gate if (ret_val == Z_OK) 53587c478bd9Sstevel@tonic-gate ret_val = Z_INSUFFICIENT_SPEC; 53597c478bd9Sstevel@tonic-gate } 53607c478bd9Sstevel@tonic-gate 53617c478bd9Sstevel@tonic-gate if (save) { 5362087719fdSdp if (ret_val == Z_OK) { 5363087719fdSdp if ((ret_val = zonecfg_save(handle)) == Z_OK) { 5364087719fdSdp need_to_commit = FALSE; 5365087719fdSdp (void) strlcpy(revert_zone, zone, 5366087719fdSdp sizeof (revert_zone)); 5367087719fdSdp } 5368087719fdSdp } else { 5369087719fdSdp zerr(gettext("Zone %s failed to verify"), zone); 5370087719fdSdp } 53717c478bd9Sstevel@tonic-gate } 53727c478bd9Sstevel@tonic-gate if (ret_val != Z_OK) 53737c478bd9Sstevel@tonic-gate zone_perror(zone, ret_val, TRUE); 53747c478bd9Sstevel@tonic-gate } 53757c478bd9Sstevel@tonic-gate 53767c478bd9Sstevel@tonic-gate void 53777c478bd9Sstevel@tonic-gate cancel_func(cmd_t *cmd) 53787c478bd9Sstevel@tonic-gate { 53797c478bd9Sstevel@tonic-gate int arg; 53807c478bd9Sstevel@tonic-gate 53817c478bd9Sstevel@tonic-gate assert(cmd != NULL); 53827c478bd9Sstevel@tonic-gate 53837c478bd9Sstevel@tonic-gate optind = 0; 53847c478bd9Sstevel@tonic-gate if ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?")) != EOF) { 53857c478bd9Sstevel@tonic-gate switch (arg) { 53867c478bd9Sstevel@tonic-gate case '?': 53877c478bd9Sstevel@tonic-gate longer_usage(CMD_CANCEL); 53887c478bd9Sstevel@tonic-gate return; 53897c478bd9Sstevel@tonic-gate default: 53907c478bd9Sstevel@tonic-gate short_usage(CMD_CANCEL); 53917c478bd9Sstevel@tonic-gate return; 53927c478bd9Sstevel@tonic-gate } 53937c478bd9Sstevel@tonic-gate } 53947c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 53957c478bd9Sstevel@tonic-gate short_usage(CMD_CANCEL); 53967c478bd9Sstevel@tonic-gate return; 53977c478bd9Sstevel@tonic-gate } 53987c478bd9Sstevel@tonic-gate 53997c478bd9Sstevel@tonic-gate if (global_scope) 54007c478bd9Sstevel@tonic-gate scope_usage(CMD_CANCEL); 54017c478bd9Sstevel@tonic-gate global_scope = TRUE; 54027c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(in_progress_fstab.zone_fs_options); 54037c478bd9Sstevel@tonic-gate bzero(&in_progress_fstab, sizeof (in_progress_fstab)); 54047c478bd9Sstevel@tonic-gate bzero(&in_progress_nwiftab, sizeof (in_progress_nwiftab)); 5405fa9e4066Sahrens bzero(&in_progress_ipdtab, sizeof (in_progress_ipdtab)); 54067c478bd9Sstevel@tonic-gate bzero(&in_progress_devtab, sizeof (in_progress_devtab)); 54077c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(in_progress_rctltab.zone_rctl_valptr); 54087c478bd9Sstevel@tonic-gate bzero(&in_progress_rctltab, sizeof (in_progress_rctltab)); 54097c478bd9Sstevel@tonic-gate bzero(&in_progress_attrtab, sizeof (in_progress_attrtab)); 5410fa9e4066Sahrens bzero(&in_progress_dstab, sizeof (in_progress_dstab)); 54117c478bd9Sstevel@tonic-gate } 54127c478bd9Sstevel@tonic-gate 54137c478bd9Sstevel@tonic-gate static int 54147c478bd9Sstevel@tonic-gate validate_attr_name(char *name) 54157c478bd9Sstevel@tonic-gate { 54167c478bd9Sstevel@tonic-gate int i; 54177c478bd9Sstevel@tonic-gate 54187c478bd9Sstevel@tonic-gate if (!isalnum(name[0])) { 54197c478bd9Sstevel@tonic-gate zerr(gettext("Invalid %s %s %s: must start with an alpha-" 54207c478bd9Sstevel@tonic-gate "numeric character."), rt_to_str(RT_ATTR), 54217c478bd9Sstevel@tonic-gate pt_to_str(PT_NAME), name); 54227c478bd9Sstevel@tonic-gate return (Z_INVAL); 54237c478bd9Sstevel@tonic-gate } 54247c478bd9Sstevel@tonic-gate for (i = 1; name[i]; i++) 54257c478bd9Sstevel@tonic-gate if (!isalnum(name[i]) && name[i] != '-' && name[i] != '.') { 54267c478bd9Sstevel@tonic-gate zerr(gettext("Invalid %s %s %s: can only contain " 54277c478bd9Sstevel@tonic-gate "alpha-numeric characters, plus '-' and '.'."), 54287c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR), pt_to_str(PT_NAME), name); 54297c478bd9Sstevel@tonic-gate return (Z_INVAL); 54307c478bd9Sstevel@tonic-gate } 54317c478bd9Sstevel@tonic-gate return (Z_OK); 54327c478bd9Sstevel@tonic-gate } 54337c478bd9Sstevel@tonic-gate 54347c478bd9Sstevel@tonic-gate static int 54357c478bd9Sstevel@tonic-gate validate_attr_type_val(struct zone_attrtab *attrtab) 54367c478bd9Sstevel@tonic-gate { 54377c478bd9Sstevel@tonic-gate boolean_t boolval; 54387c478bd9Sstevel@tonic-gate int64_t intval; 54397c478bd9Sstevel@tonic-gate char strval[MAXNAMELEN]; 54407c478bd9Sstevel@tonic-gate uint64_t uintval; 54417c478bd9Sstevel@tonic-gate 54427c478bd9Sstevel@tonic-gate if (strcmp(attrtab->zone_attr_type, "boolean") == 0) { 54437c478bd9Sstevel@tonic-gate if (zonecfg_get_attr_boolean(attrtab, &boolval) == Z_OK) 54447c478bd9Sstevel@tonic-gate return (Z_OK); 54457c478bd9Sstevel@tonic-gate zerr(gettext("invalid %s value for %s=%s"), 54467c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR), pt_to_str(PT_TYPE), "boolean"); 54477c478bd9Sstevel@tonic-gate return (Z_ERR); 54487c478bd9Sstevel@tonic-gate } 54497c478bd9Sstevel@tonic-gate 54507c478bd9Sstevel@tonic-gate if (strcmp(attrtab->zone_attr_type, "int") == 0) { 54517c478bd9Sstevel@tonic-gate if (zonecfg_get_attr_int(attrtab, &intval) == Z_OK) 54527c478bd9Sstevel@tonic-gate return (Z_OK); 54537c478bd9Sstevel@tonic-gate zerr(gettext("invalid %s value for %s=%s"), 54547c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR), pt_to_str(PT_TYPE), "int"); 54557c478bd9Sstevel@tonic-gate return (Z_ERR); 54567c478bd9Sstevel@tonic-gate } 54577c478bd9Sstevel@tonic-gate 54587c478bd9Sstevel@tonic-gate if (strcmp(attrtab->zone_attr_type, "string") == 0) { 54597c478bd9Sstevel@tonic-gate if (zonecfg_get_attr_string(attrtab, strval, 54607c478bd9Sstevel@tonic-gate sizeof (strval)) == Z_OK) 54617c478bd9Sstevel@tonic-gate return (Z_OK); 54627c478bd9Sstevel@tonic-gate zerr(gettext("invalid %s value for %s=%s"), 54637c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR), pt_to_str(PT_TYPE), "string"); 54647c478bd9Sstevel@tonic-gate return (Z_ERR); 54657c478bd9Sstevel@tonic-gate } 54667c478bd9Sstevel@tonic-gate 54677c478bd9Sstevel@tonic-gate if (strcmp(attrtab->zone_attr_type, "uint") == 0) { 54687c478bd9Sstevel@tonic-gate if (zonecfg_get_attr_uint(attrtab, &uintval) == Z_OK) 54697c478bd9Sstevel@tonic-gate return (Z_OK); 54707c478bd9Sstevel@tonic-gate zerr(gettext("invalid %s value for %s=%s"), 54717c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR), pt_to_str(PT_TYPE), "uint"); 54727c478bd9Sstevel@tonic-gate return (Z_ERR); 54737c478bd9Sstevel@tonic-gate } 54747c478bd9Sstevel@tonic-gate 54757c478bd9Sstevel@tonic-gate zerr(gettext("invalid %s %s '%s'"), rt_to_str(RT_ATTR), 54767c478bd9Sstevel@tonic-gate pt_to_str(PT_TYPE), attrtab->zone_attr_type); 54777c478bd9Sstevel@tonic-gate return (Z_ERR); 54787c478bd9Sstevel@tonic-gate } 54797c478bd9Sstevel@tonic-gate 5480087719fdSdp /* 5481087719fdSdp * Helper function for end_func-- checks the existence of a given property 5482087719fdSdp * and emits a message if not specified. 5483087719fdSdp */ 5484087719fdSdp static int 5485087719fdSdp end_check_reqd(char *attr, int pt, bool *validation_failed) 5486087719fdSdp { 5487087719fdSdp if (strlen(attr) == 0) { 5488087719fdSdp *validation_failed = TRUE; 5489087719fdSdp zerr(gettext("%s not specified"), pt_to_str(pt)); 5490087719fdSdp return (Z_ERR); 5491087719fdSdp } 5492087719fdSdp return (Z_OK); 5493087719fdSdp } 5494087719fdSdp 54957c478bd9Sstevel@tonic-gate void 54967c478bd9Sstevel@tonic-gate end_func(cmd_t *cmd) 54977c478bd9Sstevel@tonic-gate { 54987c478bd9Sstevel@tonic-gate bool validation_failed = FALSE; 54997c478bd9Sstevel@tonic-gate struct zone_fstab tmp_fstab; 55007c478bd9Sstevel@tonic-gate struct zone_nwiftab tmp_nwiftab; 55017c478bd9Sstevel@tonic-gate struct zone_devtab tmp_devtab; 55027c478bd9Sstevel@tonic-gate struct zone_rctltab tmp_rctltab; 55037c478bd9Sstevel@tonic-gate struct zone_attrtab tmp_attrtab; 5504fa9e4066Sahrens struct zone_dstab tmp_dstab; 55050209230bSgjelinek int err, arg, res1, res2, res3; 55060209230bSgjelinek uint64_t swap_limit; 55070209230bSgjelinek uint64_t locked_limit; 55087c478bd9Sstevel@tonic-gate 55097c478bd9Sstevel@tonic-gate assert(cmd != NULL); 55107c478bd9Sstevel@tonic-gate 55117c478bd9Sstevel@tonic-gate optind = 0; 55127c478bd9Sstevel@tonic-gate if ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?")) != EOF) { 55137c478bd9Sstevel@tonic-gate switch (arg) { 55147c478bd9Sstevel@tonic-gate case '?': 55157c478bd9Sstevel@tonic-gate longer_usage(CMD_END); 55167c478bd9Sstevel@tonic-gate return; 55177c478bd9Sstevel@tonic-gate default: 55187c478bd9Sstevel@tonic-gate short_usage(CMD_END); 55197c478bd9Sstevel@tonic-gate return; 55207c478bd9Sstevel@tonic-gate } 55217c478bd9Sstevel@tonic-gate } 55227c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 55237c478bd9Sstevel@tonic-gate short_usage(CMD_END); 55247c478bd9Sstevel@tonic-gate return; 55257c478bd9Sstevel@tonic-gate } 55267c478bd9Sstevel@tonic-gate 55277c478bd9Sstevel@tonic-gate if (global_scope) { 55287c478bd9Sstevel@tonic-gate scope_usage(CMD_END); 55297c478bd9Sstevel@tonic-gate return; 55307c478bd9Sstevel@tonic-gate } 55317c478bd9Sstevel@tonic-gate 55327c478bd9Sstevel@tonic-gate assert(end_op == CMD_ADD || end_op == CMD_SELECT); 55337c478bd9Sstevel@tonic-gate 55347c478bd9Sstevel@tonic-gate switch (resource_scope) { 55357c478bd9Sstevel@tonic-gate case RT_FS: 55367c478bd9Sstevel@tonic-gate /* First make sure everything was filled in. */ 5537087719fdSdp if (end_check_reqd(in_progress_fstab.zone_fs_dir, 5538087719fdSdp PT_DIR, &validation_failed) == Z_OK) { 5539087719fdSdp if (in_progress_fstab.zone_fs_dir[0] != '/') { 5540087719fdSdp zerr(gettext("%s %s is not an absolute path."), 5541087719fdSdp pt_to_str(PT_DIR), 5542087719fdSdp in_progress_fstab.zone_fs_dir); 5543087719fdSdp validation_failed = TRUE; 5544087719fdSdp } 55457c478bd9Sstevel@tonic-gate } 5546087719fdSdp 5547087719fdSdp (void) end_check_reqd(in_progress_fstab.zone_fs_special, 5548087719fdSdp PT_SPECIAL, &validation_failed); 5549087719fdSdp 55507c478bd9Sstevel@tonic-gate if (in_progress_fstab.zone_fs_raw[0] != '\0' && 55517c478bd9Sstevel@tonic-gate in_progress_fstab.zone_fs_raw[0] != '/') { 5552087719fdSdp zerr(gettext("%s %s is not an absolute path."), 5553087719fdSdp pt_to_str(PT_RAW), 5554087719fdSdp in_progress_fstab.zone_fs_raw); 55557c478bd9Sstevel@tonic-gate validation_failed = TRUE; 55567c478bd9Sstevel@tonic-gate } 5557087719fdSdp 5558087719fdSdp (void) end_check_reqd(in_progress_fstab.zone_fs_type, PT_TYPE, 5559087719fdSdp &validation_failed); 5560087719fdSdp 5561087719fdSdp if (validation_failed) { 55627c478bd9Sstevel@tonic-gate saw_error = TRUE; 55637c478bd9Sstevel@tonic-gate return; 5564087719fdSdp } 5565087719fdSdp 55667c478bd9Sstevel@tonic-gate if (end_op == CMD_ADD) { 55677c478bd9Sstevel@tonic-gate /* Make sure there isn't already one like this. */ 55687c478bd9Sstevel@tonic-gate bzero(&tmp_fstab, sizeof (tmp_fstab)); 55697c478bd9Sstevel@tonic-gate (void) strlcpy(tmp_fstab.zone_fs_dir, 55707c478bd9Sstevel@tonic-gate in_progress_fstab.zone_fs_dir, 55717c478bd9Sstevel@tonic-gate sizeof (tmp_fstab.zone_fs_dir)); 55727c478bd9Sstevel@tonic-gate err = zonecfg_lookup_filesystem(handle, &tmp_fstab); 55737c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(tmp_fstab.zone_fs_options); 55747c478bd9Sstevel@tonic-gate if (err == Z_OK) { 55757c478bd9Sstevel@tonic-gate zerr(gettext("A %s resource " 55767c478bd9Sstevel@tonic-gate "with the %s '%s' already exists."), 55777c478bd9Sstevel@tonic-gate rt_to_str(RT_FS), pt_to_str(PT_DIR), 55787c478bd9Sstevel@tonic-gate in_progress_fstab.zone_fs_dir); 55797c478bd9Sstevel@tonic-gate saw_error = TRUE; 55807c478bd9Sstevel@tonic-gate return; 55817c478bd9Sstevel@tonic-gate } 55827c478bd9Sstevel@tonic-gate err = zonecfg_add_filesystem(handle, 55837c478bd9Sstevel@tonic-gate &in_progress_fstab); 55847c478bd9Sstevel@tonic-gate } else { 55857c478bd9Sstevel@tonic-gate err = zonecfg_modify_filesystem(handle, &old_fstab, 55867c478bd9Sstevel@tonic-gate &in_progress_fstab); 55877c478bd9Sstevel@tonic-gate } 55887c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(in_progress_fstab.zone_fs_options); 55897c478bd9Sstevel@tonic-gate in_progress_fstab.zone_fs_options = NULL; 55907c478bd9Sstevel@tonic-gate break; 5591087719fdSdp 55927c478bd9Sstevel@tonic-gate case RT_IPD: 55937c478bd9Sstevel@tonic-gate /* First make sure everything was filled in. */ 5594087719fdSdp if (end_check_reqd(in_progress_ipdtab.zone_fs_dir, PT_DIR, 5595087719fdSdp &validation_failed) == Z_OK) { 5596087719fdSdp if (in_progress_ipdtab.zone_fs_dir[0] != '/') { 5597087719fdSdp zerr(gettext("%s %s is not an absolute path."), 5598087719fdSdp pt_to_str(PT_DIR), 5599087719fdSdp in_progress_ipdtab.zone_fs_dir); 5600087719fdSdp validation_failed = TRUE; 5601087719fdSdp } 56027c478bd9Sstevel@tonic-gate } 5603087719fdSdp if (validation_failed) { 5604087719fdSdp saw_error = TRUE; 56057c478bd9Sstevel@tonic-gate return; 5606087719fdSdp } 5607087719fdSdp 56087c478bd9Sstevel@tonic-gate if (end_op == CMD_ADD) { 56097c478bd9Sstevel@tonic-gate /* Make sure there isn't already one like this. */ 56107c478bd9Sstevel@tonic-gate bzero(&tmp_fstab, sizeof (tmp_fstab)); 56117c478bd9Sstevel@tonic-gate (void) strlcpy(tmp_fstab.zone_fs_dir, 56127c478bd9Sstevel@tonic-gate in_progress_ipdtab.zone_fs_dir, 56137c478bd9Sstevel@tonic-gate sizeof (tmp_fstab.zone_fs_dir)); 56147c478bd9Sstevel@tonic-gate err = zonecfg_lookup_ipd(handle, &tmp_fstab); 56157c478bd9Sstevel@tonic-gate if (err == Z_OK) { 56167c478bd9Sstevel@tonic-gate zerr(gettext("An %s resource " 56177c478bd9Sstevel@tonic-gate "with the %s '%s' already exists."), 56187c478bd9Sstevel@tonic-gate rt_to_str(RT_IPD), pt_to_str(PT_DIR), 56197c478bd9Sstevel@tonic-gate in_progress_ipdtab.zone_fs_dir); 56207c478bd9Sstevel@tonic-gate saw_error = TRUE; 56217c478bd9Sstevel@tonic-gate return; 56227c478bd9Sstevel@tonic-gate } 56237c478bd9Sstevel@tonic-gate err = zonecfg_add_ipd(handle, &in_progress_ipdtab); 56247c478bd9Sstevel@tonic-gate } else { 56257c478bd9Sstevel@tonic-gate err = zonecfg_modify_ipd(handle, &old_ipdtab, 56267c478bd9Sstevel@tonic-gate &in_progress_ipdtab); 56277c478bd9Sstevel@tonic-gate } 56287c478bd9Sstevel@tonic-gate break; 56297c478bd9Sstevel@tonic-gate case RT_NET: 5630*f4b3ec61Sdh /* 5631*f4b3ec61Sdh * First make sure everything was filled in. 5632*f4b3ec61Sdh * Since we don't know whether IP will be shared 5633*f4b3ec61Sdh * or exclusive here, some checks are deferred until 5634*f4b3ec61Sdh * the verify command. 5635*f4b3ec61Sdh */ 5636087719fdSdp (void) end_check_reqd(in_progress_nwiftab.zone_nwif_physical, 5637087719fdSdp PT_PHYSICAL, &validation_failed); 5638087719fdSdp 5639087719fdSdp if (validation_failed) { 56407c478bd9Sstevel@tonic-gate saw_error = TRUE; 56417c478bd9Sstevel@tonic-gate return; 5642087719fdSdp } 56437c478bd9Sstevel@tonic-gate if (end_op == CMD_ADD) { 56447c478bd9Sstevel@tonic-gate /* Make sure there isn't already one like this. */ 56457c478bd9Sstevel@tonic-gate bzero(&tmp_nwiftab, sizeof (tmp_nwiftab)); 5646*f4b3ec61Sdh (void) strlcpy(tmp_nwiftab.zone_nwif_physical, 5647*f4b3ec61Sdh in_progress_nwiftab.zone_nwif_physical, 5648*f4b3ec61Sdh sizeof (tmp_nwiftab.zone_nwif_physical)); 56497c478bd9Sstevel@tonic-gate (void) strlcpy(tmp_nwiftab.zone_nwif_address, 56507c478bd9Sstevel@tonic-gate in_progress_nwiftab.zone_nwif_address, 56517c478bd9Sstevel@tonic-gate sizeof (tmp_nwiftab.zone_nwif_address)); 56527c478bd9Sstevel@tonic-gate if (zonecfg_lookup_nwif(handle, &tmp_nwiftab) == Z_OK) { 5653*f4b3ec61Sdh zerr(gettext("A %s resource with the %s '%s', " 5654*f4b3ec61Sdh "and %s '%s' already exists."), 5655*f4b3ec61Sdh rt_to_str(RT_NET), 5656*f4b3ec61Sdh pt_to_str(PT_PHYSICAL), 5657*f4b3ec61Sdh in_progress_nwiftab.zone_nwif_physical, 5658*f4b3ec61Sdh pt_to_str(PT_ADDRESS), 56597c478bd9Sstevel@tonic-gate in_progress_nwiftab.zone_nwif_address); 56607c478bd9Sstevel@tonic-gate saw_error = TRUE; 56617c478bd9Sstevel@tonic-gate return; 56627c478bd9Sstevel@tonic-gate } 56637c478bd9Sstevel@tonic-gate err = zonecfg_add_nwif(handle, &in_progress_nwiftab); 56647c478bd9Sstevel@tonic-gate } else { 56657c478bd9Sstevel@tonic-gate err = zonecfg_modify_nwif(handle, &old_nwiftab, 56667c478bd9Sstevel@tonic-gate &in_progress_nwiftab); 56677c478bd9Sstevel@tonic-gate } 56687c478bd9Sstevel@tonic-gate break; 5669087719fdSdp 56707c478bd9Sstevel@tonic-gate case RT_DEVICE: 56717c478bd9Sstevel@tonic-gate /* First make sure everything was filled in. */ 5672087719fdSdp (void) end_check_reqd(in_progress_devtab.zone_dev_match, 5673087719fdSdp PT_MATCH, &validation_failed); 5674087719fdSdp 5675087719fdSdp if (validation_failed) { 56767c478bd9Sstevel@tonic-gate saw_error = TRUE; 56777c478bd9Sstevel@tonic-gate return; 5678087719fdSdp } 5679087719fdSdp 56807c478bd9Sstevel@tonic-gate if (end_op == CMD_ADD) { 56817c478bd9Sstevel@tonic-gate /* Make sure there isn't already one like this. */ 56827c478bd9Sstevel@tonic-gate (void) strlcpy(tmp_devtab.zone_dev_match, 56837c478bd9Sstevel@tonic-gate in_progress_devtab.zone_dev_match, 56847c478bd9Sstevel@tonic-gate sizeof (tmp_devtab.zone_dev_match)); 56857c478bd9Sstevel@tonic-gate if (zonecfg_lookup_dev(handle, &tmp_devtab) == Z_OK) { 56867c478bd9Sstevel@tonic-gate zerr(gettext("A %s resource with the %s '%s' " 56877c478bd9Sstevel@tonic-gate "already exists."), rt_to_str(RT_DEVICE), 56887c478bd9Sstevel@tonic-gate pt_to_str(PT_MATCH), 56897c478bd9Sstevel@tonic-gate in_progress_devtab.zone_dev_match); 56907c478bd9Sstevel@tonic-gate saw_error = TRUE; 56917c478bd9Sstevel@tonic-gate return; 56927c478bd9Sstevel@tonic-gate } 56937c478bd9Sstevel@tonic-gate err = zonecfg_add_dev(handle, &in_progress_devtab); 56947c478bd9Sstevel@tonic-gate } else { 56957c478bd9Sstevel@tonic-gate err = zonecfg_modify_dev(handle, &old_devtab, 56967c478bd9Sstevel@tonic-gate &in_progress_devtab); 56977c478bd9Sstevel@tonic-gate } 56987c478bd9Sstevel@tonic-gate break; 5699087719fdSdp 57007c478bd9Sstevel@tonic-gate case RT_RCTL: 57017c478bd9Sstevel@tonic-gate /* First make sure everything was filled in. */ 5702087719fdSdp (void) end_check_reqd(in_progress_rctltab.zone_rctl_name, 5703087719fdSdp PT_NAME, &validation_failed); 5704087719fdSdp 57057c478bd9Sstevel@tonic-gate if (in_progress_rctltab.zone_rctl_valptr == NULL) { 57067c478bd9Sstevel@tonic-gate zerr(gettext("no %s specified"), pt_to_str(PT_VALUE)); 57077c478bd9Sstevel@tonic-gate validation_failed = TRUE; 57087c478bd9Sstevel@tonic-gate } 5709087719fdSdp 5710087719fdSdp if (validation_failed) { 5711087719fdSdp saw_error = TRUE; 57127c478bd9Sstevel@tonic-gate return; 5713087719fdSdp } 5714087719fdSdp 57157c478bd9Sstevel@tonic-gate if (end_op == CMD_ADD) { 57167c478bd9Sstevel@tonic-gate /* Make sure there isn't already one like this. */ 57177c478bd9Sstevel@tonic-gate (void) strlcpy(tmp_rctltab.zone_rctl_name, 57187c478bd9Sstevel@tonic-gate in_progress_rctltab.zone_rctl_name, 57197c478bd9Sstevel@tonic-gate sizeof (tmp_rctltab.zone_rctl_name)); 57207c478bd9Sstevel@tonic-gate tmp_rctltab.zone_rctl_valptr = NULL; 57217c478bd9Sstevel@tonic-gate err = zonecfg_lookup_rctl(handle, &tmp_rctltab); 57227c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list( 57237c478bd9Sstevel@tonic-gate tmp_rctltab.zone_rctl_valptr); 57247c478bd9Sstevel@tonic-gate if (err == Z_OK) { 57257c478bd9Sstevel@tonic-gate zerr(gettext("A %s resource " 57267c478bd9Sstevel@tonic-gate "with the %s '%s' already exists."), 57277c478bd9Sstevel@tonic-gate rt_to_str(RT_RCTL), pt_to_str(PT_NAME), 57287c478bd9Sstevel@tonic-gate in_progress_rctltab.zone_rctl_name); 57297c478bd9Sstevel@tonic-gate saw_error = TRUE; 57307c478bd9Sstevel@tonic-gate return; 57317c478bd9Sstevel@tonic-gate } 57327c478bd9Sstevel@tonic-gate err = zonecfg_add_rctl(handle, &in_progress_rctltab); 57337c478bd9Sstevel@tonic-gate } else { 57347c478bd9Sstevel@tonic-gate err = zonecfg_modify_rctl(handle, &old_rctltab, 57357c478bd9Sstevel@tonic-gate &in_progress_rctltab); 57367c478bd9Sstevel@tonic-gate } 57377c478bd9Sstevel@tonic-gate if (err == Z_OK) { 57387c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list( 57397c478bd9Sstevel@tonic-gate in_progress_rctltab.zone_rctl_valptr); 57407c478bd9Sstevel@tonic-gate in_progress_rctltab.zone_rctl_valptr = NULL; 57417c478bd9Sstevel@tonic-gate } 57427c478bd9Sstevel@tonic-gate break; 5743087719fdSdp 57447c478bd9Sstevel@tonic-gate case RT_ATTR: 57457c478bd9Sstevel@tonic-gate /* First make sure everything was filled in. */ 5746087719fdSdp (void) end_check_reqd(in_progress_attrtab.zone_attr_name, 5747087719fdSdp PT_NAME, &validation_failed); 5748087719fdSdp (void) end_check_reqd(in_progress_attrtab.zone_attr_type, 5749087719fdSdp PT_TYPE, &validation_failed); 5750087719fdSdp (void) end_check_reqd(in_progress_attrtab.zone_attr_value, 5751087719fdSdp PT_VALUE, &validation_failed); 5752087719fdSdp 57537c478bd9Sstevel@tonic-gate if (validate_attr_name(in_progress_attrtab.zone_attr_name) != 5754087719fdSdp Z_OK) 57557c478bd9Sstevel@tonic-gate validation_failed = TRUE; 5756087719fdSdp 5757087719fdSdp if (validate_attr_type_val(&in_progress_attrtab) != Z_OK) 57587c478bd9Sstevel@tonic-gate validation_failed = TRUE; 5759087719fdSdp 5760087719fdSdp if (validation_failed) { 5761087719fdSdp saw_error = TRUE; 57627c478bd9Sstevel@tonic-gate return; 5763087719fdSdp } 57647c478bd9Sstevel@tonic-gate if (end_op == CMD_ADD) { 57657c478bd9Sstevel@tonic-gate /* Make sure there isn't already one like this. */ 57667c478bd9Sstevel@tonic-gate bzero(&tmp_attrtab, sizeof (tmp_attrtab)); 57677c478bd9Sstevel@tonic-gate (void) strlcpy(tmp_attrtab.zone_attr_name, 57687c478bd9Sstevel@tonic-gate in_progress_attrtab.zone_attr_name, 57697c478bd9Sstevel@tonic-gate sizeof (tmp_attrtab.zone_attr_name)); 57707c478bd9Sstevel@tonic-gate if (zonecfg_lookup_attr(handle, &tmp_attrtab) == Z_OK) { 57717c478bd9Sstevel@tonic-gate zerr(gettext("An %s resource " 57727c478bd9Sstevel@tonic-gate "with the %s '%s' already exists."), 57737c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR), pt_to_str(PT_NAME), 57747c478bd9Sstevel@tonic-gate in_progress_attrtab.zone_attr_name); 57757c478bd9Sstevel@tonic-gate saw_error = TRUE; 57767c478bd9Sstevel@tonic-gate return; 57777c478bd9Sstevel@tonic-gate } 57787c478bd9Sstevel@tonic-gate err = zonecfg_add_attr(handle, &in_progress_attrtab); 57797c478bd9Sstevel@tonic-gate } else { 57807c478bd9Sstevel@tonic-gate err = zonecfg_modify_attr(handle, &old_attrtab, 57817c478bd9Sstevel@tonic-gate &in_progress_attrtab); 57827c478bd9Sstevel@tonic-gate } 57837c478bd9Sstevel@tonic-gate break; 5784fa9e4066Sahrens case RT_DATASET: 5785fa9e4066Sahrens /* First make sure everything was filled in. */ 5786fa9e4066Sahrens if (strlen(in_progress_dstab.zone_dataset_name) == 0) { 5787fa9e4066Sahrens zerr("%s %s", pt_to_str(PT_NAME), 5788fa9e4066Sahrens gettext("not specified")); 5789fa9e4066Sahrens saw_error = TRUE; 5790fa9e4066Sahrens validation_failed = TRUE; 5791fa9e4066Sahrens } 5792fa9e4066Sahrens if (validation_failed) 5793fa9e4066Sahrens return; 5794fa9e4066Sahrens if (end_op == CMD_ADD) { 5795fa9e4066Sahrens /* Make sure there isn't already one like this. */ 5796fa9e4066Sahrens bzero(&tmp_dstab, sizeof (tmp_dstab)); 5797fa9e4066Sahrens (void) strlcpy(tmp_dstab.zone_dataset_name, 5798fa9e4066Sahrens in_progress_dstab.zone_dataset_name, 5799fa9e4066Sahrens sizeof (tmp_dstab.zone_dataset_name)); 5800fa9e4066Sahrens err = zonecfg_lookup_ds(handle, &tmp_dstab); 5801fa9e4066Sahrens if (err == Z_OK) { 5802fa9e4066Sahrens zerr(gettext("A %s resource " 5803fa9e4066Sahrens "with the %s '%s' already exists."), 5804fa9e4066Sahrens rt_to_str(RT_DATASET), pt_to_str(PT_NAME), 5805fa9e4066Sahrens in_progress_dstab.zone_dataset_name); 5806fa9e4066Sahrens saw_error = TRUE; 5807fa9e4066Sahrens return; 5808fa9e4066Sahrens } 5809fa9e4066Sahrens err = zonecfg_add_ds(handle, &in_progress_dstab); 5810fa9e4066Sahrens } else { 5811fa9e4066Sahrens err = zonecfg_modify_ds(handle, &old_dstab, 5812fa9e4066Sahrens &in_progress_dstab); 5813fa9e4066Sahrens } 5814fa9e4066Sahrens break; 58150209230bSgjelinek case RT_DCPU: 58160209230bSgjelinek /* Make sure everything was filled in. */ 58170209230bSgjelinek if (end_check_reqd(in_progress_psettab.zone_ncpu_min, 58180209230bSgjelinek PT_NCPUS, &validation_failed) != Z_OK) { 58190209230bSgjelinek saw_error = TRUE; 58200209230bSgjelinek return; 58210209230bSgjelinek } 58220209230bSgjelinek 58230209230bSgjelinek if (end_op == CMD_ADD) { 58240209230bSgjelinek err = zonecfg_add_pset(handle, &in_progress_psettab); 58250209230bSgjelinek } else { 58260209230bSgjelinek err = zonecfg_modify_pset(handle, &in_progress_psettab); 58270209230bSgjelinek } 58280209230bSgjelinek break; 58290209230bSgjelinek case RT_MCAP: 58300209230bSgjelinek /* Make sure everything was filled in. */ 58310209230bSgjelinek res1 = strlen(in_progress_mcaptab.zone_physmem_cap) == 0 ? 58320209230bSgjelinek Z_ERR : Z_OK; 58330209230bSgjelinek res2 = zonecfg_get_aliased_rctl(handle, ALIAS_MAXSWAP, 58340209230bSgjelinek &swap_limit); 58350209230bSgjelinek res3 = zonecfg_get_aliased_rctl(handle, ALIAS_MAXLOCKEDMEM, 58360209230bSgjelinek &locked_limit); 58370209230bSgjelinek 58380209230bSgjelinek if (res1 != Z_OK && res2 != Z_OK && res3 != Z_OK) { 58390209230bSgjelinek zerr(gettext("No property was specified. One of %s, " 58400209230bSgjelinek "%s or %s is required."), pt_to_str(PT_PHYSICAL), 58410209230bSgjelinek pt_to_str(PT_SWAP), pt_to_str(PT_LOCKED)); 58420209230bSgjelinek saw_error = TRUE; 58430209230bSgjelinek return; 58440209230bSgjelinek } 58450209230bSgjelinek 58460209230bSgjelinek /* if phys & locked are both set, verify locked <= phys */ 58470209230bSgjelinek if (res1 == Z_OK && res3 == Z_OK) { 58480209230bSgjelinek uint64_t phys_limit; 58490209230bSgjelinek char *endp; 58500209230bSgjelinek 58510209230bSgjelinek phys_limit = strtoull( 58520209230bSgjelinek in_progress_mcaptab.zone_physmem_cap, &endp, 10); 58530209230bSgjelinek if (phys_limit < locked_limit) { 58540209230bSgjelinek zerr(gettext("The %s cap must be less than or " 58550209230bSgjelinek "equal to the %s cap."), 58560209230bSgjelinek pt_to_str(PT_LOCKED), 58570209230bSgjelinek pt_to_str(PT_PHYSICAL)); 58580209230bSgjelinek saw_error = TRUE; 58590209230bSgjelinek return; 58600209230bSgjelinek } 58610209230bSgjelinek } 58620209230bSgjelinek 58630209230bSgjelinek err = Z_OK; 58640209230bSgjelinek if (res1 == Z_OK) { 58650209230bSgjelinek /* 58660209230bSgjelinek * We could be ending from either an add operation 58670209230bSgjelinek * or a select operation. Since all of the properties 58680209230bSgjelinek * within this resource are optional, we always use 58690209230bSgjelinek * modify on the mcap entry. zonecfg_modify_mcap() 58700209230bSgjelinek * will handle both adding and modifying a memory cap. 58710209230bSgjelinek */ 58720209230bSgjelinek err = zonecfg_modify_mcap(handle, &in_progress_mcaptab); 58730209230bSgjelinek } else if (end_op == CMD_SELECT) { 58740209230bSgjelinek /* 58750209230bSgjelinek * If we're ending from a select and the physical 58760209230bSgjelinek * memory cap is empty then the user could have cleared 58770209230bSgjelinek * the physical cap value, so try to delete the entry. 58780209230bSgjelinek */ 58790209230bSgjelinek (void) zonecfg_delete_mcap(handle); 58800209230bSgjelinek } 58810209230bSgjelinek break; 58827c478bd9Sstevel@tonic-gate default: 58837c478bd9Sstevel@tonic-gate zone_perror(rt_to_str(resource_scope), Z_NO_RESOURCE_TYPE, 58847c478bd9Sstevel@tonic-gate TRUE); 58857c478bd9Sstevel@tonic-gate saw_error = TRUE; 58867c478bd9Sstevel@tonic-gate return; 58877c478bd9Sstevel@tonic-gate } 58887c478bd9Sstevel@tonic-gate 58897c478bd9Sstevel@tonic-gate if (err != Z_OK) { 58907c478bd9Sstevel@tonic-gate zone_perror(zone, err, TRUE); 58917c478bd9Sstevel@tonic-gate } else { 58927c478bd9Sstevel@tonic-gate need_to_commit = TRUE; 58937c478bd9Sstevel@tonic-gate global_scope = TRUE; 58947c478bd9Sstevel@tonic-gate end_op = -1; 58957c478bd9Sstevel@tonic-gate } 58967c478bd9Sstevel@tonic-gate } 58977c478bd9Sstevel@tonic-gate 58987c478bd9Sstevel@tonic-gate void 58997c478bd9Sstevel@tonic-gate commit_func(cmd_t *cmd) 59007c478bd9Sstevel@tonic-gate { 59017c478bd9Sstevel@tonic-gate int arg; 59027c478bd9Sstevel@tonic-gate 59037c478bd9Sstevel@tonic-gate optind = 0; 59047c478bd9Sstevel@tonic-gate if ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?")) != EOF) { 59057c478bd9Sstevel@tonic-gate switch (arg) { 59067c478bd9Sstevel@tonic-gate case '?': 59077c478bd9Sstevel@tonic-gate longer_usage(CMD_COMMIT); 59087c478bd9Sstevel@tonic-gate return; 59097c478bd9Sstevel@tonic-gate default: 59107c478bd9Sstevel@tonic-gate short_usage(CMD_COMMIT); 59117c478bd9Sstevel@tonic-gate return; 59127c478bd9Sstevel@tonic-gate } 59137c478bd9Sstevel@tonic-gate } 59147c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 59157c478bd9Sstevel@tonic-gate short_usage(CMD_COMMIT); 59167c478bd9Sstevel@tonic-gate return; 59177c478bd9Sstevel@tonic-gate } 59187c478bd9Sstevel@tonic-gate 59197c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_COMMIT)) 59207c478bd9Sstevel@tonic-gate return; 59217c478bd9Sstevel@tonic-gate 59227c478bd9Sstevel@tonic-gate assert(cmd != NULL); 59237c478bd9Sstevel@tonic-gate 59247c478bd9Sstevel@tonic-gate cmd->cmd_argc = 1; 59257c478bd9Sstevel@tonic-gate /* 59267c478bd9Sstevel@tonic-gate * cmd_arg normally comes from a strdup() in the lexer, and the 59277c478bd9Sstevel@tonic-gate * whole cmd structure and its (char *) attributes are freed at 59287c478bd9Sstevel@tonic-gate * the completion of each command, so the strdup() below is needed 59297c478bd9Sstevel@tonic-gate * to match this and prevent a core dump from trying to free() 59307c478bd9Sstevel@tonic-gate * something that can't be. 59317c478bd9Sstevel@tonic-gate */ 59327c478bd9Sstevel@tonic-gate if ((cmd->cmd_argv[0] = strdup("save")) == NULL) { 59337c478bd9Sstevel@tonic-gate zone_perror(zone, Z_NOMEM, TRUE); 59347c478bd9Sstevel@tonic-gate exit(Z_ERR); 59357c478bd9Sstevel@tonic-gate } 59367c478bd9Sstevel@tonic-gate cmd->cmd_argv[1] = NULL; 59377c478bd9Sstevel@tonic-gate verify_func(cmd); 59387c478bd9Sstevel@tonic-gate } 59397c478bd9Sstevel@tonic-gate 59407c478bd9Sstevel@tonic-gate void 59417c478bd9Sstevel@tonic-gate revert_func(cmd_t *cmd) 59427c478bd9Sstevel@tonic-gate { 59437c478bd9Sstevel@tonic-gate char line[128]; /* enough to ask a question */ 59447c478bd9Sstevel@tonic-gate bool force = FALSE; 59457c478bd9Sstevel@tonic-gate int err, arg, answer; 59467c478bd9Sstevel@tonic-gate 59477c478bd9Sstevel@tonic-gate optind = 0; 59487c478bd9Sstevel@tonic-gate while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?F")) != EOF) { 59497c478bd9Sstevel@tonic-gate switch (arg) { 59507c478bd9Sstevel@tonic-gate case '?': 59517c478bd9Sstevel@tonic-gate longer_usage(CMD_REVERT); 59527c478bd9Sstevel@tonic-gate return; 59537c478bd9Sstevel@tonic-gate case 'F': 59547c478bd9Sstevel@tonic-gate force = TRUE; 59557c478bd9Sstevel@tonic-gate break; 59567c478bd9Sstevel@tonic-gate default: 59577c478bd9Sstevel@tonic-gate short_usage(CMD_REVERT); 59587c478bd9Sstevel@tonic-gate return; 59597c478bd9Sstevel@tonic-gate } 59607c478bd9Sstevel@tonic-gate } 59617c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 59627c478bd9Sstevel@tonic-gate short_usage(CMD_REVERT); 59637c478bd9Sstevel@tonic-gate return; 59647c478bd9Sstevel@tonic-gate } 59657c478bd9Sstevel@tonic-gate 59667c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_REVERT)) 59677c478bd9Sstevel@tonic-gate return; 59687c478bd9Sstevel@tonic-gate 59697c478bd9Sstevel@tonic-gate if (zonecfg_check_handle(handle) != Z_OK) { 59707c478bd9Sstevel@tonic-gate zerr(gettext("No changes to revert.")); 59717c478bd9Sstevel@tonic-gate saw_error = TRUE; 59727c478bd9Sstevel@tonic-gate return; 59737c478bd9Sstevel@tonic-gate } 59747c478bd9Sstevel@tonic-gate 59757c478bd9Sstevel@tonic-gate if (!force) { 59767c478bd9Sstevel@tonic-gate (void) snprintf(line, sizeof (line), 59777c478bd9Sstevel@tonic-gate gettext("Are you sure you want to revert")); 59787c478bd9Sstevel@tonic-gate if ((answer = ask_yesno(FALSE, line)) == -1) { 59797c478bd9Sstevel@tonic-gate zerr(gettext("Input not from terminal and -F not " 59807c478bd9Sstevel@tonic-gate "specified:\n%s command ignored, exiting."), 59817c478bd9Sstevel@tonic-gate cmd_to_str(CMD_REVERT)); 59827c478bd9Sstevel@tonic-gate exit(Z_ERR); 59837c478bd9Sstevel@tonic-gate } 59847c478bd9Sstevel@tonic-gate if (answer != 1) 59857c478bd9Sstevel@tonic-gate return; 59867c478bd9Sstevel@tonic-gate } 59877c478bd9Sstevel@tonic-gate 59887c478bd9Sstevel@tonic-gate /* 59897c478bd9Sstevel@tonic-gate * Time for a new handle: finish the old one off first 59907c478bd9Sstevel@tonic-gate * then get a new one properly to avoid leaks. 59917c478bd9Sstevel@tonic-gate */ 59927c478bd9Sstevel@tonic-gate zonecfg_fini_handle(handle); 59937c478bd9Sstevel@tonic-gate if ((handle = zonecfg_init_handle()) == NULL) { 59947c478bd9Sstevel@tonic-gate zone_perror(execname, Z_NOMEM, TRUE); 59957c478bd9Sstevel@tonic-gate exit(Z_ERR); 59967c478bd9Sstevel@tonic-gate } 5997087719fdSdp if ((err = zonecfg_get_handle(revert_zone, handle)) != Z_OK) { 59987c478bd9Sstevel@tonic-gate saw_error = TRUE; 59997c478bd9Sstevel@tonic-gate got_handle = FALSE; 60007c478bd9Sstevel@tonic-gate if (err == Z_NO_ZONE) 60017c478bd9Sstevel@tonic-gate zerr(gettext("%s: no such saved zone to revert to."), 6002087719fdSdp revert_zone); 60037c478bd9Sstevel@tonic-gate else 60047c478bd9Sstevel@tonic-gate zone_perror(zone, err, TRUE); 60057c478bd9Sstevel@tonic-gate } 6006087719fdSdp (void) strlcpy(zone, revert_zone, sizeof (zone)); 60077c478bd9Sstevel@tonic-gate } 60087c478bd9Sstevel@tonic-gate 60097c478bd9Sstevel@tonic-gate void 60107c478bd9Sstevel@tonic-gate help_func(cmd_t *cmd) 60117c478bd9Sstevel@tonic-gate { 60127c478bd9Sstevel@tonic-gate int i; 60137c478bd9Sstevel@tonic-gate 60147c478bd9Sstevel@tonic-gate assert(cmd != NULL); 60157c478bd9Sstevel@tonic-gate 60167c478bd9Sstevel@tonic-gate if (cmd->cmd_argc == 0) { 60177c478bd9Sstevel@tonic-gate usage(TRUE, global_scope ? HELP_SUBCMDS : HELP_RES_SCOPE); 60187c478bd9Sstevel@tonic-gate return; 60197c478bd9Sstevel@tonic-gate } 60207c478bd9Sstevel@tonic-gate if (strcmp(cmd->cmd_argv[0], "usage") == 0) { 60217c478bd9Sstevel@tonic-gate usage(TRUE, HELP_USAGE); 60227c478bd9Sstevel@tonic-gate return; 60237c478bd9Sstevel@tonic-gate } 60247c478bd9Sstevel@tonic-gate if (strcmp(cmd->cmd_argv[0], "commands") == 0) { 60257c478bd9Sstevel@tonic-gate usage(TRUE, HELP_SUBCMDS); 60267c478bd9Sstevel@tonic-gate return; 60277c478bd9Sstevel@tonic-gate } 60287c478bd9Sstevel@tonic-gate if (strcmp(cmd->cmd_argv[0], "syntax") == 0) { 60297c478bd9Sstevel@tonic-gate usage(TRUE, HELP_SYNTAX | HELP_RES_PROPS); 60307c478bd9Sstevel@tonic-gate return; 60317c478bd9Sstevel@tonic-gate } 60327c478bd9Sstevel@tonic-gate if (strcmp(cmd->cmd_argv[0], "-?") == 0) { 60337c478bd9Sstevel@tonic-gate longer_usage(CMD_HELP); 60347c478bd9Sstevel@tonic-gate return; 60357c478bd9Sstevel@tonic-gate } 60367c478bd9Sstevel@tonic-gate 60377c478bd9Sstevel@tonic-gate for (i = 0; i <= CMD_MAX; i++) { 60387c478bd9Sstevel@tonic-gate if (strcmp(cmd->cmd_argv[0], cmd_to_str(i)) == 0) { 60397c478bd9Sstevel@tonic-gate longer_usage(i); 60407c478bd9Sstevel@tonic-gate return; 60417c478bd9Sstevel@tonic-gate } 60427c478bd9Sstevel@tonic-gate } 60437c478bd9Sstevel@tonic-gate /* We do not use zerr() here because we do not want its extra \n. */ 60447c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("Unknown help subject %s. "), 60457c478bd9Sstevel@tonic-gate cmd->cmd_argv[0]); 60467c478bd9Sstevel@tonic-gate usage(FALSE, HELP_META); 60477c478bd9Sstevel@tonic-gate } 60487c478bd9Sstevel@tonic-gate 60497c478bd9Sstevel@tonic-gate static int 60507c478bd9Sstevel@tonic-gate string_to_yyin(char *string) 60517c478bd9Sstevel@tonic-gate { 60527c478bd9Sstevel@tonic-gate if ((yyin = tmpfile()) == NULL) { 60537c478bd9Sstevel@tonic-gate zone_perror(execname, Z_TEMP_FILE, TRUE); 60547c478bd9Sstevel@tonic-gate return (Z_ERR); 60557c478bd9Sstevel@tonic-gate } 60567c478bd9Sstevel@tonic-gate if (fwrite(string, strlen(string), 1, yyin) != 1) { 60577c478bd9Sstevel@tonic-gate zone_perror(execname, Z_TEMP_FILE, TRUE); 60587c478bd9Sstevel@tonic-gate return (Z_ERR); 60597c478bd9Sstevel@tonic-gate } 60607c478bd9Sstevel@tonic-gate if (fseek(yyin, 0, SEEK_SET) != 0) { 60617c478bd9Sstevel@tonic-gate zone_perror(execname, Z_TEMP_FILE, TRUE); 60627c478bd9Sstevel@tonic-gate return (Z_ERR); 60637c478bd9Sstevel@tonic-gate } 60647c478bd9Sstevel@tonic-gate return (Z_OK); 60657c478bd9Sstevel@tonic-gate } 60667c478bd9Sstevel@tonic-gate 60677c478bd9Sstevel@tonic-gate /* This is the back-end helper function for read_input() below. */ 60687c478bd9Sstevel@tonic-gate 60697c478bd9Sstevel@tonic-gate static int 60707c478bd9Sstevel@tonic-gate cleanup() 60717c478bd9Sstevel@tonic-gate { 60727c478bd9Sstevel@tonic-gate int answer; 60737c478bd9Sstevel@tonic-gate cmd_t *cmd; 60747c478bd9Sstevel@tonic-gate 60757c478bd9Sstevel@tonic-gate if (!interactive_mode && !cmd_file_mode) { 60767c478bd9Sstevel@tonic-gate /* 60777c478bd9Sstevel@tonic-gate * If we're not in interactive mode, and we're not in command 60787c478bd9Sstevel@tonic-gate * file mode, then we must be in commands-from-the-command-line 60797c478bd9Sstevel@tonic-gate * mode. As such, we can't loop back and ask for more input. 60807c478bd9Sstevel@tonic-gate * It was OK to prompt for such things as whether or not to 60817c478bd9Sstevel@tonic-gate * really delete a zone in the command handler called from 60827c478bd9Sstevel@tonic-gate * yyparse() above, but "really quit?" makes no sense in this 60837c478bd9Sstevel@tonic-gate * context. So disable prompting. 60847c478bd9Sstevel@tonic-gate */ 60857c478bd9Sstevel@tonic-gate ok_to_prompt = FALSE; 60867c478bd9Sstevel@tonic-gate } 60877c478bd9Sstevel@tonic-gate if (!global_scope) { 60887c478bd9Sstevel@tonic-gate if (!time_to_exit) { 60897c478bd9Sstevel@tonic-gate /* 60907c478bd9Sstevel@tonic-gate * Just print a simple error message in the -1 case, 60917c478bd9Sstevel@tonic-gate * since exit_func() already handles that case, and 60927c478bd9Sstevel@tonic-gate * EOF means we are finished anyway. 60937c478bd9Sstevel@tonic-gate */ 60947c478bd9Sstevel@tonic-gate answer = ask_yesno(FALSE, 60957c478bd9Sstevel@tonic-gate gettext("Resource incomplete; really quit")); 60967c478bd9Sstevel@tonic-gate if (answer == -1) { 60977c478bd9Sstevel@tonic-gate zerr(gettext("Resource incomplete.")); 60987c478bd9Sstevel@tonic-gate return (Z_ERR); 60997c478bd9Sstevel@tonic-gate } 61007c478bd9Sstevel@tonic-gate if (answer != 1) { 61017c478bd9Sstevel@tonic-gate yyin = stdin; 61027c478bd9Sstevel@tonic-gate return (Z_REPEAT); 61037c478bd9Sstevel@tonic-gate } 61047c478bd9Sstevel@tonic-gate } else { 61057c478bd9Sstevel@tonic-gate saw_error = TRUE; 61067c478bd9Sstevel@tonic-gate } 61077c478bd9Sstevel@tonic-gate } 61087c478bd9Sstevel@tonic-gate /* 61097c478bd9Sstevel@tonic-gate * Make sure we tried something and that the handle checks 61107c478bd9Sstevel@tonic-gate * out, or we would get a false error trying to commit. 61117c478bd9Sstevel@tonic-gate */ 61127c478bd9Sstevel@tonic-gate if (need_to_commit && zonecfg_check_handle(handle) == Z_OK) { 61137c478bd9Sstevel@tonic-gate if ((cmd = alloc_cmd()) == NULL) { 61147c478bd9Sstevel@tonic-gate zone_perror(zone, Z_NOMEM, TRUE); 61157c478bd9Sstevel@tonic-gate return (Z_ERR); 61167c478bd9Sstevel@tonic-gate } 61177c478bd9Sstevel@tonic-gate cmd->cmd_argc = 0; 61187c478bd9Sstevel@tonic-gate cmd->cmd_argv[0] = NULL; 61197c478bd9Sstevel@tonic-gate commit_func(cmd); 61207c478bd9Sstevel@tonic-gate free_cmd(cmd); 61217c478bd9Sstevel@tonic-gate /* 61227c478bd9Sstevel@tonic-gate * need_to_commit will get set back to FALSE if the 61237c478bd9Sstevel@tonic-gate * configuration is saved successfully. 61247c478bd9Sstevel@tonic-gate */ 61257c478bd9Sstevel@tonic-gate if (need_to_commit) { 61267c478bd9Sstevel@tonic-gate if (force_exit) { 61277c478bd9Sstevel@tonic-gate zerr(gettext("Configuration not saved.")); 61287c478bd9Sstevel@tonic-gate return (Z_ERR); 61297c478bd9Sstevel@tonic-gate } 61307c478bd9Sstevel@tonic-gate answer = ask_yesno(FALSE, 61317c478bd9Sstevel@tonic-gate gettext("Configuration not saved; really quit")); 61327c478bd9Sstevel@tonic-gate if (answer == -1) { 61337c478bd9Sstevel@tonic-gate zerr(gettext("Configuration not saved.")); 61347c478bd9Sstevel@tonic-gate return (Z_ERR); 61357c478bd9Sstevel@tonic-gate } 61367c478bd9Sstevel@tonic-gate if (answer != 1) { 61377c478bd9Sstevel@tonic-gate time_to_exit = FALSE; 61387c478bd9Sstevel@tonic-gate yyin = stdin; 61397c478bd9Sstevel@tonic-gate return (Z_REPEAT); 61407c478bd9Sstevel@tonic-gate } 61417c478bd9Sstevel@tonic-gate } 61427c478bd9Sstevel@tonic-gate } 61437c478bd9Sstevel@tonic-gate return ((need_to_commit || saw_error) ? Z_ERR : Z_OK); 61447c478bd9Sstevel@tonic-gate } 61457c478bd9Sstevel@tonic-gate 61467c478bd9Sstevel@tonic-gate /* 61477c478bd9Sstevel@tonic-gate * read_input() is the driver of this program. It is a wrapper around 61487c478bd9Sstevel@tonic-gate * yyparse(), printing appropriate prompts when needed, checking for 61497c478bd9Sstevel@tonic-gate * exit conditions and reacting appropriately [the latter in its cleanup() 61507c478bd9Sstevel@tonic-gate * helper function]. 61517c478bd9Sstevel@tonic-gate * 61527c478bd9Sstevel@tonic-gate * Like most zonecfg functions, it returns Z_OK or Z_ERR, *or* Z_REPEAT 61537c478bd9Sstevel@tonic-gate * so do_interactive() knows that we are not really done (i.e, we asked 61547c478bd9Sstevel@tonic-gate * the user if we should really quit and the user said no). 61557c478bd9Sstevel@tonic-gate */ 61567c478bd9Sstevel@tonic-gate static int 61577c478bd9Sstevel@tonic-gate read_input() 61587c478bd9Sstevel@tonic-gate { 61597c478bd9Sstevel@tonic-gate bool yyin_is_a_tty = isatty(fileno(yyin)); 61607c478bd9Sstevel@tonic-gate /* 61617c478bd9Sstevel@tonic-gate * The prompt is "e:z> " or "e:z:r> " where e is execname, z is zone 61627c478bd9Sstevel@tonic-gate * and r is resource_scope: 5 is for the two ":"s + "> " + terminator. 61637c478bd9Sstevel@tonic-gate */ 61647c478bd9Sstevel@tonic-gate char prompt[MAXPATHLEN + ZONENAME_MAX + MAX_RT_STRLEN + 5], *line; 61657c478bd9Sstevel@tonic-gate 61667c478bd9Sstevel@tonic-gate /* yyin should have been set to the appropriate (FILE *) if not stdin */ 61677c478bd9Sstevel@tonic-gate newline_terminated = TRUE; 61687c478bd9Sstevel@tonic-gate for (;;) { 61697c478bd9Sstevel@tonic-gate if (yyin_is_a_tty) { 61707c478bd9Sstevel@tonic-gate if (newline_terminated) { 61717c478bd9Sstevel@tonic-gate if (global_scope) 61727c478bd9Sstevel@tonic-gate (void) snprintf(prompt, sizeof (prompt), 61737c478bd9Sstevel@tonic-gate "%s:%s> ", execname, zone); 61747c478bd9Sstevel@tonic-gate else 61757c478bd9Sstevel@tonic-gate (void) snprintf(prompt, sizeof (prompt), 61767c478bd9Sstevel@tonic-gate "%s:%s:%s> ", execname, zone, 61777c478bd9Sstevel@tonic-gate rt_to_str(resource_scope)); 61787c478bd9Sstevel@tonic-gate } 61797c478bd9Sstevel@tonic-gate /* 61807c478bd9Sstevel@tonic-gate * If the user hits ^C then we want to catch it and 61817c478bd9Sstevel@tonic-gate * start over. If the user hits EOF then we want to 61827c478bd9Sstevel@tonic-gate * bail out. 61837c478bd9Sstevel@tonic-gate */ 61847c478bd9Sstevel@tonic-gate line = gl_get_line(gl, prompt, NULL, -1); 61857c478bd9Sstevel@tonic-gate if (gl_return_status(gl) == GLR_SIGNAL) { 61867c478bd9Sstevel@tonic-gate gl_abandon_line(gl); 61877c478bd9Sstevel@tonic-gate continue; 61887c478bd9Sstevel@tonic-gate } 61897c478bd9Sstevel@tonic-gate if (line == NULL) 61907c478bd9Sstevel@tonic-gate break; 61917c478bd9Sstevel@tonic-gate (void) string_to_yyin(line); 61927c478bd9Sstevel@tonic-gate while (!feof(yyin)) 61937c478bd9Sstevel@tonic-gate yyparse(); 61947c478bd9Sstevel@tonic-gate } else { 61957c478bd9Sstevel@tonic-gate yyparse(); 61967c478bd9Sstevel@tonic-gate } 61977c478bd9Sstevel@tonic-gate /* Bail out on an error in command file mode. */ 61987c478bd9Sstevel@tonic-gate if (saw_error && cmd_file_mode && !interactive_mode) 61997c478bd9Sstevel@tonic-gate time_to_exit = TRUE; 62007c478bd9Sstevel@tonic-gate if (time_to_exit || (!yyin_is_a_tty && feof(yyin))) 62017c478bd9Sstevel@tonic-gate break; 62027c478bd9Sstevel@tonic-gate } 62037c478bd9Sstevel@tonic-gate return (cleanup()); 62047c478bd9Sstevel@tonic-gate } 62057c478bd9Sstevel@tonic-gate 62067c478bd9Sstevel@tonic-gate /* 62077c478bd9Sstevel@tonic-gate * This function is used in the zonecfg-interactive-mode scenario: it just 62087c478bd9Sstevel@tonic-gate * calls read_input() until we are done. 62097c478bd9Sstevel@tonic-gate */ 62107c478bd9Sstevel@tonic-gate 62117c478bd9Sstevel@tonic-gate static int 62127c478bd9Sstevel@tonic-gate do_interactive(void) 62137c478bd9Sstevel@tonic-gate { 62147c478bd9Sstevel@tonic-gate int err; 62157c478bd9Sstevel@tonic-gate 62167c478bd9Sstevel@tonic-gate interactive_mode = TRUE; 62177c478bd9Sstevel@tonic-gate if (!read_only_mode) { 62187c478bd9Sstevel@tonic-gate /* 62197c478bd9Sstevel@tonic-gate * Try to set things up proactively in interactive mode, so 62207c478bd9Sstevel@tonic-gate * that if the zone in question does not exist yet, we can 62217c478bd9Sstevel@tonic-gate * provide the user with a clue. 62227c478bd9Sstevel@tonic-gate */ 62237c478bd9Sstevel@tonic-gate (void) initialize(FALSE); 62247c478bd9Sstevel@tonic-gate } 6225087719fdSdp do { 62267c478bd9Sstevel@tonic-gate err = read_input(); 6227087719fdSdp } while (err == Z_REPEAT); 62287c478bd9Sstevel@tonic-gate return (err); 62297c478bd9Sstevel@tonic-gate } 62307c478bd9Sstevel@tonic-gate 62317c478bd9Sstevel@tonic-gate /* 62327c478bd9Sstevel@tonic-gate * cmd_file is slightly more complicated, as it has to open the command file 62337c478bd9Sstevel@tonic-gate * and set yyin appropriately. Once that is done, though, it just calls 62347c478bd9Sstevel@tonic-gate * read_input(), and only once, since prompting is not possible. 62357c478bd9Sstevel@tonic-gate */ 62367c478bd9Sstevel@tonic-gate 62377c478bd9Sstevel@tonic-gate static int 62387c478bd9Sstevel@tonic-gate cmd_file(char *file) 62397c478bd9Sstevel@tonic-gate { 62407c478bd9Sstevel@tonic-gate FILE *infile; 62417c478bd9Sstevel@tonic-gate int err; 62427c478bd9Sstevel@tonic-gate struct stat statbuf; 62437c478bd9Sstevel@tonic-gate bool using_real_file = (strcmp(file, "-") != 0); 62447c478bd9Sstevel@tonic-gate 62457c478bd9Sstevel@tonic-gate if (using_real_file) { 62467c478bd9Sstevel@tonic-gate /* 62477c478bd9Sstevel@tonic-gate * zerr() prints a line number in cmd_file_mode, which we do 62487c478bd9Sstevel@tonic-gate * not want here, so temporarily unset it. 62497c478bd9Sstevel@tonic-gate */ 62507c478bd9Sstevel@tonic-gate cmd_file_mode = FALSE; 62517c478bd9Sstevel@tonic-gate if ((infile = fopen(file, "r")) == NULL) { 62527c478bd9Sstevel@tonic-gate zerr(gettext("could not open file %s: %s"), 62537c478bd9Sstevel@tonic-gate file, strerror(errno)); 62547c478bd9Sstevel@tonic-gate return (Z_ERR); 62557c478bd9Sstevel@tonic-gate } 62567c478bd9Sstevel@tonic-gate if ((err = fstat(fileno(infile), &statbuf)) != 0) { 62577c478bd9Sstevel@tonic-gate zerr(gettext("could not stat file %s: %s"), 62587c478bd9Sstevel@tonic-gate file, strerror(errno)); 62597c478bd9Sstevel@tonic-gate err = Z_ERR; 62607c478bd9Sstevel@tonic-gate goto done; 62617c478bd9Sstevel@tonic-gate } 62627c478bd9Sstevel@tonic-gate if (!S_ISREG(statbuf.st_mode)) { 62637c478bd9Sstevel@tonic-gate zerr(gettext("%s is not a regular file."), file); 62647c478bd9Sstevel@tonic-gate err = Z_ERR; 62657c478bd9Sstevel@tonic-gate goto done; 62667c478bd9Sstevel@tonic-gate } 62677c478bd9Sstevel@tonic-gate yyin = infile; 62687c478bd9Sstevel@tonic-gate cmd_file_mode = TRUE; 62697c478bd9Sstevel@tonic-gate ok_to_prompt = FALSE; 62707c478bd9Sstevel@tonic-gate } else { 62717c478bd9Sstevel@tonic-gate /* 62727c478bd9Sstevel@tonic-gate * "-f -" is essentially the same as interactive mode, 62737c478bd9Sstevel@tonic-gate * so treat it that way. 62747c478bd9Sstevel@tonic-gate */ 62757c478bd9Sstevel@tonic-gate interactive_mode = TRUE; 62767c478bd9Sstevel@tonic-gate } 62777c478bd9Sstevel@tonic-gate /* Z_REPEAT is for interactive mode; treat it like Z_ERR here. */ 62787c478bd9Sstevel@tonic-gate if ((err = read_input()) == Z_REPEAT) 62797c478bd9Sstevel@tonic-gate err = Z_ERR; 62807c478bd9Sstevel@tonic-gate done: 62817c478bd9Sstevel@tonic-gate if (using_real_file) 62827c478bd9Sstevel@tonic-gate (void) fclose(infile); 62837c478bd9Sstevel@tonic-gate return (err); 62847c478bd9Sstevel@tonic-gate } 62857c478bd9Sstevel@tonic-gate 62867c478bd9Sstevel@tonic-gate /* 62877c478bd9Sstevel@tonic-gate * Since yacc is based on reading from a (FILE *) whereas what we get from 62887c478bd9Sstevel@tonic-gate * the command line is in argv format, we need to convert when the user 62897c478bd9Sstevel@tonic-gate * gives us commands directly from the command line. That is done here by 62907c478bd9Sstevel@tonic-gate * concatenating the argv list into a space-separated string, writing it 62917c478bd9Sstevel@tonic-gate * to a temp file, and rewinding the file so yyin can be set to it. Then 62927c478bd9Sstevel@tonic-gate * we call read_input(), and only once, since prompting about whether to 62937c478bd9Sstevel@tonic-gate * continue or quit would make no sense in this context. 62947c478bd9Sstevel@tonic-gate */ 62957c478bd9Sstevel@tonic-gate 62967c478bd9Sstevel@tonic-gate static int 62977c478bd9Sstevel@tonic-gate one_command_at_a_time(int argc, char *argv[]) 62987c478bd9Sstevel@tonic-gate { 62997c478bd9Sstevel@tonic-gate char *command; 63007c478bd9Sstevel@tonic-gate size_t len = 2; /* terminal \n\0 */ 63017c478bd9Sstevel@tonic-gate int i, err; 63027c478bd9Sstevel@tonic-gate 63037c478bd9Sstevel@tonic-gate for (i = 0; i < argc; i++) 63047c478bd9Sstevel@tonic-gate len += strlen(argv[i]) + 1; 63057c478bd9Sstevel@tonic-gate if ((command = malloc(len)) == NULL) { 63067c478bd9Sstevel@tonic-gate zone_perror(execname, Z_NOMEM, TRUE); 63077c478bd9Sstevel@tonic-gate return (Z_ERR); 63087c478bd9Sstevel@tonic-gate } 63097c478bd9Sstevel@tonic-gate (void) strlcpy(command, argv[0], len); 63107c478bd9Sstevel@tonic-gate for (i = 1; i < argc; i++) { 63117c478bd9Sstevel@tonic-gate (void) strlcat(command, " ", len); 63127c478bd9Sstevel@tonic-gate (void) strlcat(command, argv[i], len); 63137c478bd9Sstevel@tonic-gate } 63147c478bd9Sstevel@tonic-gate (void) strlcat(command, "\n", len); 63157c478bd9Sstevel@tonic-gate err = string_to_yyin(command); 63167c478bd9Sstevel@tonic-gate free(command); 63177c478bd9Sstevel@tonic-gate if (err != Z_OK) 63187c478bd9Sstevel@tonic-gate return (err); 63197c478bd9Sstevel@tonic-gate while (!feof(yyin)) 63207c478bd9Sstevel@tonic-gate yyparse(); 63217c478bd9Sstevel@tonic-gate return (cleanup()); 63227c478bd9Sstevel@tonic-gate } 63237c478bd9Sstevel@tonic-gate 63247c478bd9Sstevel@tonic-gate static char * 63257c478bd9Sstevel@tonic-gate get_execbasename(char *execfullname) 63267c478bd9Sstevel@tonic-gate { 63277c478bd9Sstevel@tonic-gate char *last_slash, *execbasename; 63287c478bd9Sstevel@tonic-gate 63297c478bd9Sstevel@tonic-gate /* guard against '/' at end of command invocation */ 63307c478bd9Sstevel@tonic-gate for (;;) { 63317c478bd9Sstevel@tonic-gate last_slash = strrchr(execfullname, '/'); 63327c478bd9Sstevel@tonic-gate if (last_slash == NULL) { 63337c478bd9Sstevel@tonic-gate execbasename = execfullname; 63347c478bd9Sstevel@tonic-gate break; 63357c478bd9Sstevel@tonic-gate } else { 63367c478bd9Sstevel@tonic-gate execbasename = last_slash + 1; 63377c478bd9Sstevel@tonic-gate if (*execbasename == '\0') { 63387c478bd9Sstevel@tonic-gate *last_slash = '\0'; 63397c478bd9Sstevel@tonic-gate continue; 63407c478bd9Sstevel@tonic-gate } 63417c478bd9Sstevel@tonic-gate break; 63427c478bd9Sstevel@tonic-gate } 63437c478bd9Sstevel@tonic-gate } 63447c478bd9Sstevel@tonic-gate return (execbasename); 63457c478bd9Sstevel@tonic-gate } 63467c478bd9Sstevel@tonic-gate 63477c478bd9Sstevel@tonic-gate int 63487c478bd9Sstevel@tonic-gate main(int argc, char *argv[]) 63497c478bd9Sstevel@tonic-gate { 63507c478bd9Sstevel@tonic-gate int err, arg; 6351555afedfScarlsonj struct stat st; 63527c478bd9Sstevel@tonic-gate 63537c478bd9Sstevel@tonic-gate /* This must be before anything goes to stdout. */ 63547c478bd9Sstevel@tonic-gate setbuf(stdout, NULL); 63557c478bd9Sstevel@tonic-gate 63567c478bd9Sstevel@tonic-gate saw_error = FALSE; 63577c478bd9Sstevel@tonic-gate cmd_file_mode = FALSE; 63587c478bd9Sstevel@tonic-gate execname = get_execbasename(argv[0]); 63597c478bd9Sstevel@tonic-gate 63607c478bd9Sstevel@tonic-gate (void) setlocale(LC_ALL, ""); 63617c478bd9Sstevel@tonic-gate (void) textdomain(TEXT_DOMAIN); 63627c478bd9Sstevel@tonic-gate 63637c478bd9Sstevel@tonic-gate if (getzoneid() != GLOBAL_ZONEID) { 63647c478bd9Sstevel@tonic-gate zerr(gettext("%s can only be run from the global zone."), 63657c478bd9Sstevel@tonic-gate execname); 63667c478bd9Sstevel@tonic-gate exit(Z_ERR); 63677c478bd9Sstevel@tonic-gate } 63687c478bd9Sstevel@tonic-gate 63697c478bd9Sstevel@tonic-gate if (argc < 2) { 63707c478bd9Sstevel@tonic-gate usage(FALSE, HELP_USAGE | HELP_SUBCMDS); 63717c478bd9Sstevel@tonic-gate exit(Z_USAGE); 63727c478bd9Sstevel@tonic-gate } 63737c478bd9Sstevel@tonic-gate if (strcmp(argv[1], cmd_to_str(CMD_HELP)) == 0) { 63747c478bd9Sstevel@tonic-gate (void) one_command_at_a_time(argc - 1, &(argv[1])); 63757c478bd9Sstevel@tonic-gate exit(Z_OK); 63767c478bd9Sstevel@tonic-gate } 63777c478bd9Sstevel@tonic-gate 6378555afedfScarlsonj while ((arg = getopt(argc, argv, "?f:R:z:")) != EOF) { 63797c478bd9Sstevel@tonic-gate switch (arg) { 63807c478bd9Sstevel@tonic-gate case '?': 63817c478bd9Sstevel@tonic-gate if (optopt == '?') 63827c478bd9Sstevel@tonic-gate usage(TRUE, HELP_USAGE | HELP_SUBCMDS); 63837c478bd9Sstevel@tonic-gate else 63847c478bd9Sstevel@tonic-gate usage(FALSE, HELP_USAGE); 63857c478bd9Sstevel@tonic-gate exit(Z_USAGE); 63867c478bd9Sstevel@tonic-gate /* NOTREACHED */ 63877c478bd9Sstevel@tonic-gate case 'f': 63887c478bd9Sstevel@tonic-gate cmd_file_name = optarg; 63897c478bd9Sstevel@tonic-gate cmd_file_mode = TRUE; 63907c478bd9Sstevel@tonic-gate break; 6391555afedfScarlsonj case 'R': 6392555afedfScarlsonj if (*optarg != '/') { 6393555afedfScarlsonj zerr(gettext("root path must be absolute: %s"), 6394555afedfScarlsonj optarg); 6395555afedfScarlsonj exit(Z_USAGE); 6396555afedfScarlsonj } 6397555afedfScarlsonj if (stat(optarg, &st) == -1 || !S_ISDIR(st.st_mode)) { 6398555afedfScarlsonj zerr(gettext( 6399555afedfScarlsonj "root path must be a directory: %s"), 6400555afedfScarlsonj optarg); 6401555afedfScarlsonj exit(Z_USAGE); 6402555afedfScarlsonj } 6403555afedfScarlsonj zonecfg_set_root(optarg); 6404555afedfScarlsonj break; 64057c478bd9Sstevel@tonic-gate case 'z': 64060209230bSgjelinek if (strcmp(optarg, GLOBAL_ZONENAME) == 0) { 64070209230bSgjelinek global_zone = TRUE; 64080209230bSgjelinek } else if (zonecfg_validate_zonename(optarg) != Z_OK) { 6409087719fdSdp zone_perror(optarg, Z_BOGUS_ZONE_NAME, TRUE); 6410087719fdSdp usage(FALSE, HELP_SYNTAX); 6411087719fdSdp exit(Z_USAGE); 6412087719fdSdp } 6413087719fdSdp (void) strlcpy(zone, optarg, sizeof (zone)); 6414087719fdSdp (void) strlcpy(revert_zone, optarg, sizeof (zone)); 64157c478bd9Sstevel@tonic-gate break; 64167c478bd9Sstevel@tonic-gate default: 64177c478bd9Sstevel@tonic-gate usage(FALSE, HELP_USAGE); 64187c478bd9Sstevel@tonic-gate exit(Z_USAGE); 64197c478bd9Sstevel@tonic-gate } 64207c478bd9Sstevel@tonic-gate } 64217c478bd9Sstevel@tonic-gate 6422087719fdSdp if (optind > argc || strcmp(zone, "") == 0) { 64237c478bd9Sstevel@tonic-gate usage(FALSE, HELP_USAGE); 64247c478bd9Sstevel@tonic-gate exit(Z_USAGE); 64257c478bd9Sstevel@tonic-gate } 64267c478bd9Sstevel@tonic-gate 6427087719fdSdp if ((err = zonecfg_access(zone, W_OK)) == Z_OK) { 64287c478bd9Sstevel@tonic-gate read_only_mode = FALSE; 6429087719fdSdp } else if (err == Z_ACCES) { 64307c478bd9Sstevel@tonic-gate read_only_mode = TRUE; 64317c478bd9Sstevel@tonic-gate /* skip this message in one-off from command line mode */ 64327c478bd9Sstevel@tonic-gate if (optind == argc) 64337c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("WARNING: you do not " 64347c478bd9Sstevel@tonic-gate "have write access to this zone's configuration " 64357c478bd9Sstevel@tonic-gate "file;\ngoing into read-only mode.\n")); 6436087719fdSdp } else { 6437087719fdSdp fprintf(stderr, "%s: Could not access zone configuration " 6438087719fdSdp "store: %s\n", execname, zonecfg_strerror(err)); 6439087719fdSdp exit(Z_ERR); 64407c478bd9Sstevel@tonic-gate } 64417c478bd9Sstevel@tonic-gate 64427c478bd9Sstevel@tonic-gate if ((handle = zonecfg_init_handle()) == NULL) { 64437c478bd9Sstevel@tonic-gate zone_perror(execname, Z_NOMEM, TRUE); 64447c478bd9Sstevel@tonic-gate exit(Z_ERR); 64457c478bd9Sstevel@tonic-gate } 64467c478bd9Sstevel@tonic-gate 64477c478bd9Sstevel@tonic-gate /* 64487c478bd9Sstevel@tonic-gate * This may get set back to FALSE again in cmd_file() if cmd_file_name 64497c478bd9Sstevel@tonic-gate * is a "real" file as opposed to "-" (i.e. meaning use stdin). 64507c478bd9Sstevel@tonic-gate */ 64517c478bd9Sstevel@tonic-gate if (isatty(STDIN_FILENO)) 64527c478bd9Sstevel@tonic-gate ok_to_prompt = TRUE; 64537c478bd9Sstevel@tonic-gate if ((gl = new_GetLine(MAX_LINE_LEN, MAX_CMD_HIST)) == NULL) 64547c478bd9Sstevel@tonic-gate exit(Z_ERR); 64557c478bd9Sstevel@tonic-gate if (gl_customize_completion(gl, NULL, cmd_cpl_fn) != 0) 64567c478bd9Sstevel@tonic-gate exit(Z_ERR); 64577c478bd9Sstevel@tonic-gate (void) sigset(SIGINT, SIG_IGN); 64587c478bd9Sstevel@tonic-gate if (optind == argc) { 64597c478bd9Sstevel@tonic-gate if (!cmd_file_mode) 64607c478bd9Sstevel@tonic-gate err = do_interactive(); 64617c478bd9Sstevel@tonic-gate else 64627c478bd9Sstevel@tonic-gate err = cmd_file(cmd_file_name); 64637c478bd9Sstevel@tonic-gate } else { 64647c478bd9Sstevel@tonic-gate err = one_command_at_a_time(argc - optind, &(argv[optind])); 64657c478bd9Sstevel@tonic-gate } 64667c478bd9Sstevel@tonic-gate zonecfg_fini_handle(handle); 64679acbbeafSnn if (brand != NULL) 64689acbbeafSnn brand_close(brand); 64697c478bd9Sstevel@tonic-gate (void) del_GetLine(gl); 64707c478bd9Sstevel@tonic-gate return (err); 64717c478bd9Sstevel@tonic-gate } 6472