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 /* 23fb03efaaSdp * Copyright 2006 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 104*0209230bSgjelinek #define ONE_MB 1048576 105*0209230bSgjelinek 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" 113*0209230bSgjelinek #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]*]" 122*0209230bSgjelinek #define SHELP_REMOVE "remove [-F] <resource-type> " \ 123*0209230bSgjelinek "[ <property-name>=<property-value> ]*\n" \ 124*0209230bSgjelinek "\t(global scope)\n" \ 125*0209230bSgjelinek "remove <property-name> <property-value>\n" \ 126*0209230bSgjelinek "\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, }, 136*0209230bSgjelinek { 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", 172*0209230bSgjelinek "dedicated-cpu", 173*0209230bSgjelinek "capped-memory", 174*0209230bSgjelinek ALIAS_MAXLWPS, 175*0209230bSgjelinek ALIAS_MAXSHMMEM, 176*0209230bSgjelinek ALIAS_MAXSHMIDS, 177*0209230bSgjelinek ALIAS_MAXMSGIDS, 178*0209230bSgjelinek ALIAS_MAXSEMIDS, 179*0209230bSgjelinek ALIAS_SHARES, 180*0209230bSgjelinek "scheduling-class", 1817c478bd9Sstevel@tonic-gate NULL 1827c478bd9Sstevel@tonic-gate }; 1837c478bd9Sstevel@tonic-gate 1847c478bd9Sstevel@tonic-gate /* These *must* match the order of the PT_ define's from zonecfg.h */ 1857c478bd9Sstevel@tonic-gate static char *prop_types[] = { 1867c478bd9Sstevel@tonic-gate "unknown", 187087719fdSdp "zonename", 1887c478bd9Sstevel@tonic-gate "zonepath", 1897c478bd9Sstevel@tonic-gate "autoboot", 1907c478bd9Sstevel@tonic-gate "pool", 1917c478bd9Sstevel@tonic-gate "dir", 1927c478bd9Sstevel@tonic-gate "special", 1937c478bd9Sstevel@tonic-gate "type", 1947c478bd9Sstevel@tonic-gate "options", 1957c478bd9Sstevel@tonic-gate "address", 1967c478bd9Sstevel@tonic-gate "physical", 1977c478bd9Sstevel@tonic-gate "name", 1987c478bd9Sstevel@tonic-gate "value", 1997c478bd9Sstevel@tonic-gate "match", 2007c478bd9Sstevel@tonic-gate "priv", 2017c478bd9Sstevel@tonic-gate "limit", 2027c478bd9Sstevel@tonic-gate "action", 2037c478bd9Sstevel@tonic-gate "raw", 204ffbafc53Scomay "limitpriv", 2053f2f09c1Sdp "bootargs", 2069acbbeafSnn "brand", 207*0209230bSgjelinek "ncpus", 208*0209230bSgjelinek "importance", 209*0209230bSgjelinek "swap", 210*0209230bSgjelinek "locked", 211*0209230bSgjelinek ALIAS_SHARES, 212*0209230bSgjelinek ALIAS_MAXLWPS, 213*0209230bSgjelinek ALIAS_MAXSHMMEM, 214*0209230bSgjelinek ALIAS_MAXSHMIDS, 215*0209230bSgjelinek ALIAS_MAXMSGIDS, 216*0209230bSgjelinek ALIAS_MAXSEMIDS, 217*0209230bSgjelinek ALIAS_MAXLOCKEDMEM, 218*0209230bSgjelinek ALIAS_MAXSWAP, 219*0209230bSgjelinek "scheduling-class", 2207c478bd9Sstevel@tonic-gate NULL 2217c478bd9Sstevel@tonic-gate }; 2227c478bd9Sstevel@tonic-gate 223ffbafc53Scomay /* These *must* match the order of the PROP_VAL_ define's from zonecfg.h */ 2247c478bd9Sstevel@tonic-gate static char *prop_val_types[] = { 2257c478bd9Sstevel@tonic-gate "simple", 2267c478bd9Sstevel@tonic-gate "complex", 2277c478bd9Sstevel@tonic-gate "list", 2287c478bd9Sstevel@tonic-gate }; 2297c478bd9Sstevel@tonic-gate 2307c478bd9Sstevel@tonic-gate /* 2317c478bd9Sstevel@tonic-gate * The various _cmds[] lists below are for command tab-completion. 2327c478bd9Sstevel@tonic-gate */ 2337c478bd9Sstevel@tonic-gate 2347c478bd9Sstevel@tonic-gate /* 2357c478bd9Sstevel@tonic-gate * remove has a space afterwards because it has qualifiers; the other commands 236*0209230bSgjelinek * that have qualifiers (add, select, etc.) don't need a space here because 2377c478bd9Sstevel@tonic-gate * they have their own _cmds[] lists below. 2387c478bd9Sstevel@tonic-gate */ 2397c478bd9Sstevel@tonic-gate static const char *global_scope_cmds[] = { 2407c478bd9Sstevel@tonic-gate "add", 241*0209230bSgjelinek "clear", 2427c478bd9Sstevel@tonic-gate "commit", 2437c478bd9Sstevel@tonic-gate "create", 2447c478bd9Sstevel@tonic-gate "delete", 2457c478bd9Sstevel@tonic-gate "exit", 2467c478bd9Sstevel@tonic-gate "export", 2477c478bd9Sstevel@tonic-gate "help", 2487c478bd9Sstevel@tonic-gate "info", 2497c478bd9Sstevel@tonic-gate "remove ", 2507c478bd9Sstevel@tonic-gate "revert", 2517c478bd9Sstevel@tonic-gate "select", 2527c478bd9Sstevel@tonic-gate "set", 2537c478bd9Sstevel@tonic-gate "verify", 2547c478bd9Sstevel@tonic-gate NULL 2557c478bd9Sstevel@tonic-gate }; 2567c478bd9Sstevel@tonic-gate 2577c478bd9Sstevel@tonic-gate static const char *add_cmds[] = { 2587c478bd9Sstevel@tonic-gate "add fs", 2597c478bd9Sstevel@tonic-gate "add inherit-pkg-dir", 2607c478bd9Sstevel@tonic-gate "add net", 2617c478bd9Sstevel@tonic-gate "add device", 2627c478bd9Sstevel@tonic-gate "add rctl", 2637c478bd9Sstevel@tonic-gate "add attr", 264fa9e4066Sahrens "add dataset", 265*0209230bSgjelinek "add dedicated-cpu", 266*0209230bSgjelinek "add capped-memory", 267*0209230bSgjelinek NULL 268*0209230bSgjelinek }; 269*0209230bSgjelinek 270*0209230bSgjelinek static const char *clear_cmds[] = { 271*0209230bSgjelinek "clear autoboot", 272*0209230bSgjelinek "clear pool", 273*0209230bSgjelinek "clear limitpriv", 274*0209230bSgjelinek "clear bootargs", 275*0209230bSgjelinek "clear scheduling-class", 276*0209230bSgjelinek "clear " ALIAS_MAXLWPS, 277*0209230bSgjelinek "clear " ALIAS_MAXSHMMEM, 278*0209230bSgjelinek "clear " ALIAS_MAXSHMIDS, 279*0209230bSgjelinek "clear " ALIAS_MAXMSGIDS, 280*0209230bSgjelinek "clear " ALIAS_MAXSEMIDS, 281*0209230bSgjelinek "clear " ALIAS_SHARES, 2827c478bd9Sstevel@tonic-gate NULL 2837c478bd9Sstevel@tonic-gate }; 2847c478bd9Sstevel@tonic-gate 2859e7542f4Sdp static const char *remove_cmds[] = { 2869e7542f4Sdp "remove fs ", 2879e7542f4Sdp "remove inherit-pkg-dir ", 2889e7542f4Sdp "remove net ", 2899e7542f4Sdp "remove device ", 2909e7542f4Sdp "remove rctl ", 2919e7542f4Sdp "remove attr ", 2929e7542f4Sdp "remove dataset ", 293*0209230bSgjelinek "remove dedicated-cpu ", 294*0209230bSgjelinek "remove capped-memory ", 2959e7542f4Sdp NULL 2969e7542f4Sdp }; 2979e7542f4Sdp 2987c478bd9Sstevel@tonic-gate static const char *select_cmds[] = { 299087719fdSdp "select fs ", 300087719fdSdp "select inherit-pkg-dir ", 301087719fdSdp "select net ", 302087719fdSdp "select device ", 303087719fdSdp "select rctl ", 304087719fdSdp "select attr ", 305fa9e4066Sahrens "select dataset ", 306*0209230bSgjelinek "select dedicated-cpu", 307*0209230bSgjelinek "select capped-memory", 3087c478bd9Sstevel@tonic-gate NULL 3097c478bd9Sstevel@tonic-gate }; 3107c478bd9Sstevel@tonic-gate 3117c478bd9Sstevel@tonic-gate static const char *set_cmds[] = { 312087719fdSdp "set zonename=", 313087719fdSdp "set zonepath=", 3149acbbeafSnn "set brand=", 315087719fdSdp "set autoboot=", 316087719fdSdp "set pool=", 317ffbafc53Scomay "set limitpriv=", 3183f2f09c1Sdp "set bootargs=", 319*0209230bSgjelinek "set scheduling-class=", 320*0209230bSgjelinek "set " ALIAS_MAXLWPS "=", 321*0209230bSgjelinek "set " ALIAS_MAXSHMMEM "=", 322*0209230bSgjelinek "set " ALIAS_MAXSHMIDS "=", 323*0209230bSgjelinek "set " ALIAS_MAXMSGIDS "=", 324*0209230bSgjelinek "set " ALIAS_MAXSEMIDS "=", 325*0209230bSgjelinek "set " ALIAS_SHARES "=", 3267c478bd9Sstevel@tonic-gate NULL 3277c478bd9Sstevel@tonic-gate }; 3287c478bd9Sstevel@tonic-gate 3299e7542f4Sdp static const char *info_cmds[] = { 3309e7542f4Sdp "info fs ", 3319e7542f4Sdp "info inherit-pkg-dir ", 3329e7542f4Sdp "info net ", 3339e7542f4Sdp "info device ", 3349e7542f4Sdp "info rctl ", 3359e7542f4Sdp "info attr ", 3369e7542f4Sdp "info dataset ", 337*0209230bSgjelinek "info capped-memory", 338*0209230bSgjelinek "info dedicated-cpu", 3399e7542f4Sdp "info zonename", 3409e7542f4Sdp "info zonepath", 3419e7542f4Sdp "info autoboot", 3429e7542f4Sdp "info pool", 3439e7542f4Sdp "info limitpriv", 3449e7542f4Sdp "info bootargs", 345*0209230bSgjelinek "info brand", 346*0209230bSgjelinek "info scheduling-class", 347*0209230bSgjelinek "info max-lwps", 348*0209230bSgjelinek "info max-shm-memory", 349*0209230bSgjelinek "info max-shm-ids", 350*0209230bSgjelinek "info max-msg-ids", 351*0209230bSgjelinek "info max-sem-ids", 352*0209230bSgjelinek "info cpu-shares", 3539e7542f4Sdp NULL 3549e7542f4Sdp }; 3559e7542f4Sdp 3567c478bd9Sstevel@tonic-gate static const char *fs_res_scope_cmds[] = { 3577c478bd9Sstevel@tonic-gate "add options ", 3587c478bd9Sstevel@tonic-gate "cancel", 3597c478bd9Sstevel@tonic-gate "end", 3607c478bd9Sstevel@tonic-gate "exit", 3617c478bd9Sstevel@tonic-gate "help", 3627c478bd9Sstevel@tonic-gate "info", 363ffbafc53Scomay "remove options ", 3647c478bd9Sstevel@tonic-gate "set dir=", 3657c478bd9Sstevel@tonic-gate "set raw=", 3667c478bd9Sstevel@tonic-gate "set special=", 3677c478bd9Sstevel@tonic-gate "set type=", 368*0209230bSgjelinek "clear raw", 3697c478bd9Sstevel@tonic-gate NULL 3707c478bd9Sstevel@tonic-gate }; 3717c478bd9Sstevel@tonic-gate 3727c478bd9Sstevel@tonic-gate static const char *net_res_scope_cmds[] = { 3737c478bd9Sstevel@tonic-gate "cancel", 3747c478bd9Sstevel@tonic-gate "end", 3757c478bd9Sstevel@tonic-gate "exit", 3767c478bd9Sstevel@tonic-gate "help", 3777c478bd9Sstevel@tonic-gate "info", 3787c478bd9Sstevel@tonic-gate "set address=", 3797c478bd9Sstevel@tonic-gate "set physical=", 3807c478bd9Sstevel@tonic-gate NULL 3817c478bd9Sstevel@tonic-gate }; 3827c478bd9Sstevel@tonic-gate 3837c478bd9Sstevel@tonic-gate static const char *ipd_res_scope_cmds[] = { 3847c478bd9Sstevel@tonic-gate "cancel", 3857c478bd9Sstevel@tonic-gate "end", 3867c478bd9Sstevel@tonic-gate "exit", 3877c478bd9Sstevel@tonic-gate "help", 3887c478bd9Sstevel@tonic-gate "info", 3897c478bd9Sstevel@tonic-gate "set dir=", 3907c478bd9Sstevel@tonic-gate NULL 3917c478bd9Sstevel@tonic-gate }; 3927c478bd9Sstevel@tonic-gate 3937c478bd9Sstevel@tonic-gate static const char *device_res_scope_cmds[] = { 3947c478bd9Sstevel@tonic-gate "cancel", 3957c478bd9Sstevel@tonic-gate "end", 3967c478bd9Sstevel@tonic-gate "exit", 3977c478bd9Sstevel@tonic-gate "help", 3987c478bd9Sstevel@tonic-gate "info", 3997c478bd9Sstevel@tonic-gate "set match=", 4007c478bd9Sstevel@tonic-gate NULL 4017c478bd9Sstevel@tonic-gate }; 4027c478bd9Sstevel@tonic-gate 4037c478bd9Sstevel@tonic-gate static const char *attr_res_scope_cmds[] = { 4047c478bd9Sstevel@tonic-gate "cancel", 4057c478bd9Sstevel@tonic-gate "end", 4067c478bd9Sstevel@tonic-gate "exit", 4077c478bd9Sstevel@tonic-gate "help", 4087c478bd9Sstevel@tonic-gate "info", 4097c478bd9Sstevel@tonic-gate "set name=", 4107c478bd9Sstevel@tonic-gate "set type=", 4117c478bd9Sstevel@tonic-gate "set value=", 4127c478bd9Sstevel@tonic-gate NULL 4137c478bd9Sstevel@tonic-gate }; 4147c478bd9Sstevel@tonic-gate 4157c478bd9Sstevel@tonic-gate static const char *rctl_res_scope_cmds[] = { 4167c478bd9Sstevel@tonic-gate "add value ", 4177c478bd9Sstevel@tonic-gate "cancel", 4187c478bd9Sstevel@tonic-gate "end", 4197c478bd9Sstevel@tonic-gate "exit", 4207c478bd9Sstevel@tonic-gate "help", 4217c478bd9Sstevel@tonic-gate "info", 422ffbafc53Scomay "remove value ", 4237c478bd9Sstevel@tonic-gate "set name=", 4247c478bd9Sstevel@tonic-gate NULL 4257c478bd9Sstevel@tonic-gate }; 4267c478bd9Sstevel@tonic-gate 427fa9e4066Sahrens static const char *dataset_res_scope_cmds[] = { 428fa9e4066Sahrens "cancel", 429fa9e4066Sahrens "end", 430fa9e4066Sahrens "exit", 431fa9e4066Sahrens "help", 432fa9e4066Sahrens "info", 433fa9e4066Sahrens "set name=", 434fa9e4066Sahrens NULL 435fa9e4066Sahrens }; 436fa9e4066Sahrens 437*0209230bSgjelinek static const char *pset_res_scope_cmds[] = { 438*0209230bSgjelinek "cancel", 439*0209230bSgjelinek "end", 440*0209230bSgjelinek "exit", 441*0209230bSgjelinek "help", 442*0209230bSgjelinek "info", 443*0209230bSgjelinek "set ncpus=", 444*0209230bSgjelinek "set importance=", 445*0209230bSgjelinek "clear importance", 446*0209230bSgjelinek NULL 447*0209230bSgjelinek }; 448*0209230bSgjelinek 449*0209230bSgjelinek static const char *mcap_res_scope_cmds[] = { 450*0209230bSgjelinek "cancel", 451*0209230bSgjelinek "end", 452*0209230bSgjelinek "exit", 453*0209230bSgjelinek "help", 454*0209230bSgjelinek "info", 455*0209230bSgjelinek "set physical=", 456*0209230bSgjelinek "set swap=", 457*0209230bSgjelinek "set locked=", 458*0209230bSgjelinek "clear physical", 459*0209230bSgjelinek "clear swap", 460*0209230bSgjelinek "clear locked", 461*0209230bSgjelinek NULL 462*0209230bSgjelinek }; 463*0209230bSgjelinek 4647c478bd9Sstevel@tonic-gate /* Global variables */ 4657c478bd9Sstevel@tonic-gate 4667c478bd9Sstevel@tonic-gate /* set early in main(), never modified thereafter, used all over the place */ 4677c478bd9Sstevel@tonic-gate static char *execname; 4687c478bd9Sstevel@tonic-gate 4697c478bd9Sstevel@tonic-gate /* set in main(), used all over the place */ 4707c478bd9Sstevel@tonic-gate static zone_dochandle_t handle; 4717c478bd9Sstevel@tonic-gate 4727c478bd9Sstevel@tonic-gate /* used all over the place */ 473087719fdSdp static char zone[ZONENAME_MAX]; 474087719fdSdp static char revert_zone[ZONENAME_MAX]; 4757c478bd9Sstevel@tonic-gate 4769acbbeafSnn /* global brand operations */ 477123807fbSedp static brand_handle_t brand; 4789acbbeafSnn 4797c478bd9Sstevel@tonic-gate /* set in modifying functions, checked in read_input() */ 4807c478bd9Sstevel@tonic-gate static bool need_to_commit = FALSE; 4817c478bd9Sstevel@tonic-gate bool saw_error; 4827c478bd9Sstevel@tonic-gate 4837c478bd9Sstevel@tonic-gate /* set in yacc parser, checked in read_input() */ 4847c478bd9Sstevel@tonic-gate bool newline_terminated; 4857c478bd9Sstevel@tonic-gate 4867c478bd9Sstevel@tonic-gate /* set in main(), checked in lex error handler */ 4877c478bd9Sstevel@tonic-gate bool cmd_file_mode; 4887c478bd9Sstevel@tonic-gate 4897c478bd9Sstevel@tonic-gate /* set in exit_func(), checked in read_input() */ 4907c478bd9Sstevel@tonic-gate static bool time_to_exit = FALSE, force_exit = FALSE; 4917c478bd9Sstevel@tonic-gate 4927c478bd9Sstevel@tonic-gate /* used in short_usage() and zerr() */ 4937c478bd9Sstevel@tonic-gate static char *cmd_file_name = NULL; 4947c478bd9Sstevel@tonic-gate 4957c478bd9Sstevel@tonic-gate /* checked in read_input() and other places */ 4967c478bd9Sstevel@tonic-gate static bool ok_to_prompt = FALSE; 4977c478bd9Sstevel@tonic-gate 4987c478bd9Sstevel@tonic-gate /* set and checked in initialize() */ 4997c478bd9Sstevel@tonic-gate static bool got_handle = FALSE; 5007c478bd9Sstevel@tonic-gate 5017c478bd9Sstevel@tonic-gate /* initialized in do_interactive(), checked in initialize() */ 5027c478bd9Sstevel@tonic-gate static bool interactive_mode; 5037c478bd9Sstevel@tonic-gate 504*0209230bSgjelinek /* set if configuring the global zone */ 505*0209230bSgjelinek static bool global_zone = FALSE; 506*0209230bSgjelinek 5077c478bd9Sstevel@tonic-gate /* set in main(), checked in multiple places */ 5087c478bd9Sstevel@tonic-gate static bool read_only_mode; 5097c478bd9Sstevel@tonic-gate 5107c478bd9Sstevel@tonic-gate static bool global_scope = TRUE; /* scope is outer/global or inner/resource */ 5117c478bd9Sstevel@tonic-gate static int resource_scope; /* should be in the RT_ list from zonecfg.h */ 5127c478bd9Sstevel@tonic-gate static int end_op = -1; /* operation on end is either add or modify */ 5137c478bd9Sstevel@tonic-gate 5147c478bd9Sstevel@tonic-gate int num_prop_vals; /* for grammar */ 5157c478bd9Sstevel@tonic-gate 5167c478bd9Sstevel@tonic-gate /* 5177c478bd9Sstevel@tonic-gate * These are for keeping track of resources as they are specified as part of 5187c478bd9Sstevel@tonic-gate * the multi-step process. They should be initialized by add_resource() or 5197c478bd9Sstevel@tonic-gate * select_func() and filled in by add_property() or set_func(). 5207c478bd9Sstevel@tonic-gate */ 5217c478bd9Sstevel@tonic-gate static struct zone_fstab old_fstab, in_progress_fstab; 5227c478bd9Sstevel@tonic-gate static struct zone_fstab old_ipdtab, in_progress_ipdtab; 5237c478bd9Sstevel@tonic-gate static struct zone_nwiftab old_nwiftab, in_progress_nwiftab; 5247c478bd9Sstevel@tonic-gate static struct zone_devtab old_devtab, in_progress_devtab; 5257c478bd9Sstevel@tonic-gate static struct zone_rctltab old_rctltab, in_progress_rctltab; 5267c478bd9Sstevel@tonic-gate static struct zone_attrtab old_attrtab, in_progress_attrtab; 527fa9e4066Sahrens static struct zone_dstab old_dstab, in_progress_dstab; 528*0209230bSgjelinek static struct zone_psettab old_psettab, in_progress_psettab; 529*0209230bSgjelinek static struct zone_mcaptab old_mcaptab, in_progress_mcaptab; 5307c478bd9Sstevel@tonic-gate 5317c478bd9Sstevel@tonic-gate static GetLine *gl; /* The gl_get_line() resource object */ 5327c478bd9Sstevel@tonic-gate 533*0209230bSgjelinek static void bytes_to_units(char *str, char *buf, int bufsize); 534*0209230bSgjelinek 5357c478bd9Sstevel@tonic-gate /* Functions begin here */ 5367c478bd9Sstevel@tonic-gate 5377c478bd9Sstevel@tonic-gate static bool 5387c478bd9Sstevel@tonic-gate initial_match(const char *line1, const char *line2, int word_end) 5397c478bd9Sstevel@tonic-gate { 5407c478bd9Sstevel@tonic-gate if (word_end <= 0) 5417c478bd9Sstevel@tonic-gate return (TRUE); 5427c478bd9Sstevel@tonic-gate return (strncmp(line1, line2, word_end) == 0); 5437c478bd9Sstevel@tonic-gate } 5447c478bd9Sstevel@tonic-gate 5457c478bd9Sstevel@tonic-gate static int 5467c478bd9Sstevel@tonic-gate add_stuff(WordCompletion *cpl, const char *line1, const char **list, 5477c478bd9Sstevel@tonic-gate int word_end) 5487c478bd9Sstevel@tonic-gate { 5497c478bd9Sstevel@tonic-gate int i, err; 5507c478bd9Sstevel@tonic-gate 5517c478bd9Sstevel@tonic-gate for (i = 0; list[i] != NULL; i++) { 5527c478bd9Sstevel@tonic-gate if (initial_match(line1, list[i], word_end)) { 5537c478bd9Sstevel@tonic-gate err = cpl_add_completion(cpl, line1, 0, word_end, 5547c478bd9Sstevel@tonic-gate list[i] + word_end, "", ""); 5557c478bd9Sstevel@tonic-gate if (err != 0) 5567c478bd9Sstevel@tonic-gate return (err); 5577c478bd9Sstevel@tonic-gate } 5587c478bd9Sstevel@tonic-gate } 5597c478bd9Sstevel@tonic-gate return (0); 5607c478bd9Sstevel@tonic-gate } 5617c478bd9Sstevel@tonic-gate 5627c478bd9Sstevel@tonic-gate static 5637c478bd9Sstevel@tonic-gate /* ARGSUSED */ 5647c478bd9Sstevel@tonic-gate CPL_MATCH_FN(cmd_cpl_fn) 5657c478bd9Sstevel@tonic-gate { 5667c478bd9Sstevel@tonic-gate if (global_scope) { 5677c478bd9Sstevel@tonic-gate /* 5687c478bd9Sstevel@tonic-gate * The MAX/MIN tests below are to make sure we have at least 5697c478bd9Sstevel@tonic-gate * enough characters to distinguish from other prefixes (MAX) 5707c478bd9Sstevel@tonic-gate * but only check MIN(what we have, what we're checking). 5717c478bd9Sstevel@tonic-gate */ 5727c478bd9Sstevel@tonic-gate if (strncmp(line, "add ", MAX(MIN(word_end, 4), 1)) == 0) 5737c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, add_cmds, word_end)); 574*0209230bSgjelinek if (strncmp(line, "clear ", MAX(MIN(word_end, 6), 2)) == 0) 575*0209230bSgjelinek return (add_stuff(cpl, line, clear_cmds, word_end)); 5767c478bd9Sstevel@tonic-gate if (strncmp(line, "select ", MAX(MIN(word_end, 7), 3)) == 0) 5777c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, select_cmds, word_end)); 5787c478bd9Sstevel@tonic-gate if (strncmp(line, "set ", MAX(MIN(word_end, 4), 3)) == 0) 5797c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, set_cmds, word_end)); 5809e7542f4Sdp if (strncmp(line, "remove ", MAX(MIN(word_end, 7), 1)) == 0) 5819e7542f4Sdp return (add_stuff(cpl, line, remove_cmds, word_end)); 5829e7542f4Sdp if (strncmp(line, "info ", MAX(MIN(word_end, 5), 1)) == 0) 5839e7542f4Sdp return (add_stuff(cpl, line, info_cmds, word_end)); 5847c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, global_scope_cmds, word_end)); 5857c478bd9Sstevel@tonic-gate } 5867c478bd9Sstevel@tonic-gate switch (resource_scope) { 5877c478bd9Sstevel@tonic-gate case RT_FS: 5887c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, fs_res_scope_cmds, word_end)); 5897c478bd9Sstevel@tonic-gate case RT_IPD: 5907c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, ipd_res_scope_cmds, word_end)); 5917c478bd9Sstevel@tonic-gate case RT_NET: 5927c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, net_res_scope_cmds, word_end)); 5937c478bd9Sstevel@tonic-gate case RT_DEVICE: 5947c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, device_res_scope_cmds, word_end)); 5957c478bd9Sstevel@tonic-gate case RT_RCTL: 5967c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, rctl_res_scope_cmds, word_end)); 5977c478bd9Sstevel@tonic-gate case RT_ATTR: 5987c478bd9Sstevel@tonic-gate return (add_stuff(cpl, line, attr_res_scope_cmds, word_end)); 599fa9e4066Sahrens case RT_DATASET: 600fa9e4066Sahrens return (add_stuff(cpl, line, dataset_res_scope_cmds, word_end)); 601*0209230bSgjelinek case RT_DCPU: 602*0209230bSgjelinek return (add_stuff(cpl, line, pset_res_scope_cmds, word_end)); 603*0209230bSgjelinek case RT_MCAP: 604*0209230bSgjelinek return (add_stuff(cpl, line, mcap_res_scope_cmds, word_end)); 6057c478bd9Sstevel@tonic-gate } 6067c478bd9Sstevel@tonic-gate return (0); 6077c478bd9Sstevel@tonic-gate } 6087c478bd9Sstevel@tonic-gate 6097c478bd9Sstevel@tonic-gate /* 6107c478bd9Sstevel@tonic-gate * For the main CMD_func() functions below, several of them call getopt() 6117c478bd9Sstevel@tonic-gate * then check optind against argc to make sure an extra parameter was not 6127c478bd9Sstevel@tonic-gate * passed in. The reason this is not caught in the grammar is that the 6137c478bd9Sstevel@tonic-gate * grammar just checks for a miscellaneous TOKEN, which is *expected* to 6147c478bd9Sstevel@tonic-gate * be "-F" (for example), but could be anything. So (for example) this 6157c478bd9Sstevel@tonic-gate * check will prevent "create bogus". 6167c478bd9Sstevel@tonic-gate */ 6177c478bd9Sstevel@tonic-gate 6187c478bd9Sstevel@tonic-gate cmd_t * 6197c478bd9Sstevel@tonic-gate alloc_cmd(void) 6207c478bd9Sstevel@tonic-gate { 6217c478bd9Sstevel@tonic-gate return (calloc(1, sizeof (cmd_t))); 6227c478bd9Sstevel@tonic-gate } 6237c478bd9Sstevel@tonic-gate 6247c478bd9Sstevel@tonic-gate void 6257c478bd9Sstevel@tonic-gate free_cmd(cmd_t *cmd) 6267c478bd9Sstevel@tonic-gate { 6277c478bd9Sstevel@tonic-gate int i; 6287c478bd9Sstevel@tonic-gate 6297c478bd9Sstevel@tonic-gate for (i = 0; i < MAX_EQ_PROP_PAIRS; i++) 6307c478bd9Sstevel@tonic-gate if (cmd->cmd_property_ptr[i] != NULL) { 6317c478bd9Sstevel@tonic-gate property_value_ptr_t pp = cmd->cmd_property_ptr[i]; 6327c478bd9Sstevel@tonic-gate 6337c478bd9Sstevel@tonic-gate switch (pp->pv_type) { 6347c478bd9Sstevel@tonic-gate case PROP_VAL_SIMPLE: 6357c478bd9Sstevel@tonic-gate free(pp->pv_simple); 6367c478bd9Sstevel@tonic-gate break; 6377c478bd9Sstevel@tonic-gate case PROP_VAL_COMPLEX: 6387c478bd9Sstevel@tonic-gate free_complex(pp->pv_complex); 6397c478bd9Sstevel@tonic-gate break; 6407c478bd9Sstevel@tonic-gate case PROP_VAL_LIST: 6417c478bd9Sstevel@tonic-gate free_list(pp->pv_list); 6427c478bd9Sstevel@tonic-gate break; 6437c478bd9Sstevel@tonic-gate } 6447c478bd9Sstevel@tonic-gate } 6457c478bd9Sstevel@tonic-gate for (i = 0; i < cmd->cmd_argc; i++) 6467c478bd9Sstevel@tonic-gate free(cmd->cmd_argv[i]); 6477c478bd9Sstevel@tonic-gate free(cmd); 6487c478bd9Sstevel@tonic-gate } 6497c478bd9Sstevel@tonic-gate 6507c478bd9Sstevel@tonic-gate complex_property_ptr_t 6517c478bd9Sstevel@tonic-gate alloc_complex(void) 6527c478bd9Sstevel@tonic-gate { 6537c478bd9Sstevel@tonic-gate return (calloc(1, sizeof (complex_property_t))); 6547c478bd9Sstevel@tonic-gate } 6557c478bd9Sstevel@tonic-gate 6567c478bd9Sstevel@tonic-gate void 6577c478bd9Sstevel@tonic-gate free_complex(complex_property_ptr_t complex) 6587c478bd9Sstevel@tonic-gate { 6597c478bd9Sstevel@tonic-gate if (complex == NULL) 6607c478bd9Sstevel@tonic-gate return; 6617c478bd9Sstevel@tonic-gate free_complex(complex->cp_next); 6627c478bd9Sstevel@tonic-gate if (complex->cp_value != NULL) 6637c478bd9Sstevel@tonic-gate free(complex->cp_value); 6647c478bd9Sstevel@tonic-gate free(complex); 6657c478bd9Sstevel@tonic-gate } 6667c478bd9Sstevel@tonic-gate 6677c478bd9Sstevel@tonic-gate list_property_ptr_t 6687c478bd9Sstevel@tonic-gate alloc_list(void) 6697c478bd9Sstevel@tonic-gate { 6707c478bd9Sstevel@tonic-gate return (calloc(1, sizeof (list_property_t))); 6717c478bd9Sstevel@tonic-gate } 6727c478bd9Sstevel@tonic-gate 6737c478bd9Sstevel@tonic-gate void 6747c478bd9Sstevel@tonic-gate free_list(list_property_ptr_t list) 6757c478bd9Sstevel@tonic-gate { 6767c478bd9Sstevel@tonic-gate if (list == NULL) 6777c478bd9Sstevel@tonic-gate return; 6787c478bd9Sstevel@tonic-gate if (list->lp_simple != NULL) 6797c478bd9Sstevel@tonic-gate free(list->lp_simple); 6807c478bd9Sstevel@tonic-gate free_complex(list->lp_complex); 6817c478bd9Sstevel@tonic-gate free_list(list->lp_next); 6827c478bd9Sstevel@tonic-gate free(list); 6837c478bd9Sstevel@tonic-gate } 6847c478bd9Sstevel@tonic-gate 6857c478bd9Sstevel@tonic-gate void 6867c478bd9Sstevel@tonic-gate free_outer_list(list_property_ptr_t list) 6877c478bd9Sstevel@tonic-gate { 6887c478bd9Sstevel@tonic-gate if (list == NULL) 6897c478bd9Sstevel@tonic-gate return; 6907c478bd9Sstevel@tonic-gate free_outer_list(list->lp_next); 6917c478bd9Sstevel@tonic-gate free(list); 6927c478bd9Sstevel@tonic-gate } 6937c478bd9Sstevel@tonic-gate 6947c478bd9Sstevel@tonic-gate static struct zone_rctlvaltab * 6957c478bd9Sstevel@tonic-gate alloc_rctlvaltab(void) 6967c478bd9Sstevel@tonic-gate { 6977c478bd9Sstevel@tonic-gate return (calloc(1, sizeof (struct zone_rctlvaltab))); 6987c478bd9Sstevel@tonic-gate } 6997c478bd9Sstevel@tonic-gate 7007c478bd9Sstevel@tonic-gate static char * 7017c478bd9Sstevel@tonic-gate rt_to_str(int res_type) 7027c478bd9Sstevel@tonic-gate { 7037c478bd9Sstevel@tonic-gate assert(res_type >= RT_MIN && res_type <= RT_MAX); 7047c478bd9Sstevel@tonic-gate return (res_types[res_type]); 7057c478bd9Sstevel@tonic-gate } 7067c478bd9Sstevel@tonic-gate 7077c478bd9Sstevel@tonic-gate static char * 7087c478bd9Sstevel@tonic-gate pt_to_str(int prop_type) 7097c478bd9Sstevel@tonic-gate { 7107c478bd9Sstevel@tonic-gate assert(prop_type >= PT_MIN && prop_type <= PT_MAX); 7117c478bd9Sstevel@tonic-gate return (prop_types[prop_type]); 7127c478bd9Sstevel@tonic-gate } 7137c478bd9Sstevel@tonic-gate 7147c478bd9Sstevel@tonic-gate static char * 7157c478bd9Sstevel@tonic-gate pvt_to_str(int pv_type) 7167c478bd9Sstevel@tonic-gate { 7177c478bd9Sstevel@tonic-gate assert(pv_type >= PROP_VAL_MIN && pv_type <= PROP_VAL_MAX); 7187c478bd9Sstevel@tonic-gate return (prop_val_types[pv_type]); 7197c478bd9Sstevel@tonic-gate } 7207c478bd9Sstevel@tonic-gate 7217c478bd9Sstevel@tonic-gate static char * 7227c478bd9Sstevel@tonic-gate cmd_to_str(int cmd_num) 7237c478bd9Sstevel@tonic-gate { 7247c478bd9Sstevel@tonic-gate assert(cmd_num >= CMD_MIN && cmd_num <= CMD_MAX); 7257c478bd9Sstevel@tonic-gate return (helptab[cmd_num].cmd_name); 7267c478bd9Sstevel@tonic-gate } 7277c478bd9Sstevel@tonic-gate 7287c478bd9Sstevel@tonic-gate /* 7297c478bd9Sstevel@tonic-gate * This is a separate function rather than a set of define's because of the 7307c478bd9Sstevel@tonic-gate * gettext() wrapping. 7317c478bd9Sstevel@tonic-gate */ 7327c478bd9Sstevel@tonic-gate 7337c478bd9Sstevel@tonic-gate /* 7347c478bd9Sstevel@tonic-gate * TRANSLATION_NOTE 7357c478bd9Sstevel@tonic-gate * Each string below should have \t follow \n whenever needed; the 7367c478bd9Sstevel@tonic-gate * initial \t and the terminal \n will be provided by the calling function. 7377c478bd9Sstevel@tonic-gate */ 7387c478bd9Sstevel@tonic-gate 7397c478bd9Sstevel@tonic-gate static char * 7407c478bd9Sstevel@tonic-gate long_help(int cmd_num) 7417c478bd9Sstevel@tonic-gate { 7427c478bd9Sstevel@tonic-gate static char line[1024]; /* arbitrary large amount */ 7437c478bd9Sstevel@tonic-gate 7447c478bd9Sstevel@tonic-gate assert(cmd_num >= CMD_MIN && cmd_num <= CMD_MAX); 7457c478bd9Sstevel@tonic-gate switch (cmd_num) { 7467c478bd9Sstevel@tonic-gate case CMD_HELP: 7477c478bd9Sstevel@tonic-gate return (gettext("Prints help message.")); 7487c478bd9Sstevel@tonic-gate case CMD_CREATE: 7497c478bd9Sstevel@tonic-gate (void) snprintf(line, sizeof (line), 7507c478bd9Sstevel@tonic-gate gettext("Creates a configuration for the " 7517c478bd9Sstevel@tonic-gate "specified zone. %s should be\n\tused to " 7527c478bd9Sstevel@tonic-gate "begin configuring a new zone. If overwriting an " 7537c478bd9Sstevel@tonic-gate "existing\n\tconfiguration, the -F flag can be " 7547c478bd9Sstevel@tonic-gate "used to force the action. If\n\t-t template is " 7557c478bd9Sstevel@tonic-gate "given, creates a configuration identical to the\n" 7567c478bd9Sstevel@tonic-gate "\tspecified template, except that the zone name " 7579e518655Sgjelinek "is changed from\n\ttemplate to zonename. '%s -a' " 7589e518655Sgjelinek "creates a configuration from a\n\tdetached " 7599e518655Sgjelinek "zonepath. '%s -b' results in a blank " 7609e518655Sgjelinek "configuration.\n\t'%s' with no arguments applies " 7619e518655Sgjelinek "the Sun default settings."), 7627c478bd9Sstevel@tonic-gate cmd_to_str(CMD_CREATE), cmd_to_str(CMD_CREATE), 7639e518655Sgjelinek cmd_to_str(CMD_CREATE), cmd_to_str(CMD_CREATE)); 7647c478bd9Sstevel@tonic-gate return (line); 7657c478bd9Sstevel@tonic-gate case CMD_EXIT: 7667c478bd9Sstevel@tonic-gate return (gettext("Exits the program. The -F flag can " 7677c478bd9Sstevel@tonic-gate "be used to force the action.")); 7687c478bd9Sstevel@tonic-gate case CMD_EXPORT: 7697c478bd9Sstevel@tonic-gate return (gettext("Prints configuration to standard " 7707c478bd9Sstevel@tonic-gate "output, or to output-file if\n\tspecified, in " 7717c478bd9Sstevel@tonic-gate "a form suitable for use in a command-file.")); 7727c478bd9Sstevel@tonic-gate case CMD_ADD: 7737c478bd9Sstevel@tonic-gate return (gettext("Add specified resource to " 7747c478bd9Sstevel@tonic-gate "configuration.")); 7757c478bd9Sstevel@tonic-gate case CMD_DELETE: 7767c478bd9Sstevel@tonic-gate return (gettext("Deletes the specified zone. The -F " 7777c478bd9Sstevel@tonic-gate "flag can be used to force the\n\taction.")); 7787c478bd9Sstevel@tonic-gate case CMD_REMOVE: 7797c478bd9Sstevel@tonic-gate return (gettext("Remove specified resource from " 780*0209230bSgjelinek "configuration. The -F flag can be used\n\tto " 781*0209230bSgjelinek "force the action.")); 7827c478bd9Sstevel@tonic-gate case CMD_SELECT: 7837c478bd9Sstevel@tonic-gate (void) snprintf(line, sizeof (line), 7847c478bd9Sstevel@tonic-gate gettext("Selects a resource to modify. " 7857c478bd9Sstevel@tonic-gate "Resource modification is completed\n\twith the " 7867c478bd9Sstevel@tonic-gate "command \"%s\". The property name/value pairs " 7877c478bd9Sstevel@tonic-gate "must uniquely\n\tidentify a resource. Note that " 7887c478bd9Sstevel@tonic-gate "the curly braces ('{', '}') mean one\n\tor more " 7897c478bd9Sstevel@tonic-gate "of whatever is between them."), 7907c478bd9Sstevel@tonic-gate cmd_to_str(CMD_END)); 7917c478bd9Sstevel@tonic-gate return (line); 7927c478bd9Sstevel@tonic-gate case CMD_SET: 7937c478bd9Sstevel@tonic-gate return (gettext("Sets property values.")); 794*0209230bSgjelinek case CMD_CLEAR: 795*0209230bSgjelinek return (gettext("Clears property values.")); 7967c478bd9Sstevel@tonic-gate case CMD_INFO: 7977c478bd9Sstevel@tonic-gate return (gettext("Displays information about the " 7987c478bd9Sstevel@tonic-gate "current configuration. If resource\n\ttype is " 7997c478bd9Sstevel@tonic-gate "specified, displays only information about " 8007c478bd9Sstevel@tonic-gate "resources of\n\tthe relevant type. If resource " 8017c478bd9Sstevel@tonic-gate "id is specified, displays only\n\tinformation " 8027c478bd9Sstevel@tonic-gate "about that resource.")); 8037c478bd9Sstevel@tonic-gate case CMD_VERIFY: 8047c478bd9Sstevel@tonic-gate return (gettext("Verifies current configuration " 8057c478bd9Sstevel@tonic-gate "for correctness (some resource types\n\thave " 8067c478bd9Sstevel@tonic-gate "required properties).")); 8077c478bd9Sstevel@tonic-gate case CMD_COMMIT: 8087c478bd9Sstevel@tonic-gate (void) snprintf(line, sizeof (line), 8097c478bd9Sstevel@tonic-gate gettext("Commits current configuration. " 8107c478bd9Sstevel@tonic-gate "Configuration must be committed to\n\tbe used by " 8117c478bd9Sstevel@tonic-gate "%s. Until the configuration is committed, " 8127c478bd9Sstevel@tonic-gate "changes \n\tcan be removed with the %s " 8137c478bd9Sstevel@tonic-gate "command. This operation is\n\tattempted " 8147c478bd9Sstevel@tonic-gate "automatically upon completion of a %s " 8157c478bd9Sstevel@tonic-gate "session."), "zoneadm", cmd_to_str(CMD_REVERT), 8167c478bd9Sstevel@tonic-gate "zonecfg"); 8177c478bd9Sstevel@tonic-gate return (line); 8187c478bd9Sstevel@tonic-gate case CMD_REVERT: 8197c478bd9Sstevel@tonic-gate return (gettext("Reverts configuration back to the " 8207c478bd9Sstevel@tonic-gate "last committed state. The -F flag\n\tcan be " 8217c478bd9Sstevel@tonic-gate "used to force the action.")); 8227c478bd9Sstevel@tonic-gate case CMD_CANCEL: 8237c478bd9Sstevel@tonic-gate return (gettext("Cancels resource/property " 8247c478bd9Sstevel@tonic-gate "specification.")); 8257c478bd9Sstevel@tonic-gate case CMD_END: 8267c478bd9Sstevel@tonic-gate return (gettext("Ends resource/property " 8277c478bd9Sstevel@tonic-gate "specification.")); 8287c478bd9Sstevel@tonic-gate } 8297c478bd9Sstevel@tonic-gate /* NOTREACHED */ 8307e362f58Scomay return (NULL); 8317c478bd9Sstevel@tonic-gate } 8327c478bd9Sstevel@tonic-gate 8337c478bd9Sstevel@tonic-gate /* 8347c478bd9Sstevel@tonic-gate * Called with verbose TRUE when help is explicitly requested, FALSE for 8357c478bd9Sstevel@tonic-gate * unexpected errors. 8367c478bd9Sstevel@tonic-gate */ 8377c478bd9Sstevel@tonic-gate 8387c478bd9Sstevel@tonic-gate void 8397c478bd9Sstevel@tonic-gate usage(bool verbose, uint_t flags) 8407c478bd9Sstevel@tonic-gate { 8417c478bd9Sstevel@tonic-gate FILE *fp = verbose ? stdout : stderr, *newfp; 8427c478bd9Sstevel@tonic-gate bool need_to_close = FALSE; 8437c478bd9Sstevel@tonic-gate char *pager; 8447c478bd9Sstevel@tonic-gate int i; 8457c478bd9Sstevel@tonic-gate 8467c478bd9Sstevel@tonic-gate /* don't page error output */ 8477c478bd9Sstevel@tonic-gate if (verbose && interactive_mode) { 8487c478bd9Sstevel@tonic-gate if ((pager = getenv("PAGER")) == NULL) 8497c478bd9Sstevel@tonic-gate pager = PAGER; 8507c478bd9Sstevel@tonic-gate if ((newfp = popen(pager, "w")) != NULL) { 8517c478bd9Sstevel@tonic-gate need_to_close = TRUE; 8527c478bd9Sstevel@tonic-gate fp = newfp; 8537c478bd9Sstevel@tonic-gate } 8547c478bd9Sstevel@tonic-gate } 8557c478bd9Sstevel@tonic-gate if (flags & HELP_META) { 8567c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("More help is available for the " 8577c478bd9Sstevel@tonic-gate "following:\n")); 8587c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\n\tcommands ('%s commands')\n", 8597c478bd9Sstevel@tonic-gate cmd_to_str(CMD_HELP)); 8607c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\tsyntax ('%s syntax')\n", 8617c478bd9Sstevel@tonic-gate cmd_to_str(CMD_HELP)); 8627c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\tusage ('%s usage')\n\n", 8637c478bd9Sstevel@tonic-gate cmd_to_str(CMD_HELP)); 8647c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("You may also obtain help on any " 8657c478bd9Sstevel@tonic-gate "command by typing '%s <command-name>.'\n"), 8667c478bd9Sstevel@tonic-gate cmd_to_str(CMD_HELP)); 8677c478bd9Sstevel@tonic-gate } 8687c478bd9Sstevel@tonic-gate if (flags & HELP_RES_SCOPE) { 8697c478bd9Sstevel@tonic-gate switch (resource_scope) { 8707c478bd9Sstevel@tonic-gate case RT_FS: 8717c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("The '%s' resource scope is " 8727c478bd9Sstevel@tonic-gate "used to configure a file-system.\n"), 8737c478bd9Sstevel@tonic-gate rt_to_str(resource_scope)); 8747c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("Valid commands:\n")); 8757c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 8767c478bd9Sstevel@tonic-gate pt_to_str(PT_DIR), gettext("<path>")); 8777c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 8787c478bd9Sstevel@tonic-gate pt_to_str(PT_SPECIAL), gettext("<path>")); 8797c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 8807c478bd9Sstevel@tonic-gate pt_to_str(PT_RAW), gettext("<raw-device>")); 8817c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 8827c478bd9Sstevel@tonic-gate pt_to_str(PT_TYPE), gettext("<file-system type>")); 8837c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s %s\n", cmd_to_str(CMD_ADD), 8847c478bd9Sstevel@tonic-gate pt_to_str(PT_OPTIONS), 8857c478bd9Sstevel@tonic-gate gettext("<file-system options>")); 886ffbafc53Scomay (void) fprintf(fp, "\t%s %s %s\n", 887ffbafc53Scomay cmd_to_str(CMD_REMOVE), pt_to_str(PT_OPTIONS), 888ffbafc53Scomay gettext("<file-system options>")); 8897c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("Consult the file-system " 8907c478bd9Sstevel@tonic-gate "specific manual page, such as mount_ufs(1M), " 8917c478bd9Sstevel@tonic-gate "for\ndetails about file-system options. Note " 8927c478bd9Sstevel@tonic-gate "that any file-system options with an\nembedded " 8937c478bd9Sstevel@tonic-gate "'=' character must be enclosed in double quotes, " 8947c478bd9Sstevel@tonic-gate /*CSTYLED*/ 8957c478bd9Sstevel@tonic-gate "such as \"%s=5\".\n"), MNTOPT_RETRY); 8967c478bd9Sstevel@tonic-gate break; 8977c478bd9Sstevel@tonic-gate case RT_IPD: 8987c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("The '%s' resource scope is " 8997c478bd9Sstevel@tonic-gate "used to configure a directory\ninherited from the " 9007c478bd9Sstevel@tonic-gate "global zone into a non-global zone in read-only " 9017c478bd9Sstevel@tonic-gate "mode.\n"), rt_to_str(resource_scope)); 9027c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("Valid commands:\n")); 9037c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 9047c478bd9Sstevel@tonic-gate pt_to_str(PT_DIR), gettext("<path>")); 9057c478bd9Sstevel@tonic-gate break; 9067c478bd9Sstevel@tonic-gate case RT_NET: 9077c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("The '%s' resource scope is " 9087c478bd9Sstevel@tonic-gate "used to configure a network interface.\n"), 9097c478bd9Sstevel@tonic-gate rt_to_str(resource_scope)); 9107c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("Valid commands:\n")); 9117c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 9127c478bd9Sstevel@tonic-gate pt_to_str(PT_ADDRESS), gettext("<IP-address>")); 9137c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 9147c478bd9Sstevel@tonic-gate pt_to_str(PT_PHYSICAL), gettext("<interface>")); 9157c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("See ifconfig(1M) for " 9167c478bd9Sstevel@tonic-gate "details of the <interface> string.\n")); 9177c478bd9Sstevel@tonic-gate break; 9187c478bd9Sstevel@tonic-gate case RT_DEVICE: 9197c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("The '%s' resource scope is " 9207c478bd9Sstevel@tonic-gate "used to configure a device node.\n"), 9217c478bd9Sstevel@tonic-gate rt_to_str(resource_scope)); 9227c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("Valid commands:\n")); 9237c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 9247c478bd9Sstevel@tonic-gate pt_to_str(PT_MATCH), gettext("<device-path>")); 9257c478bd9Sstevel@tonic-gate break; 9267c478bd9Sstevel@tonic-gate case RT_RCTL: 9277c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("The '%s' resource scope is " 9287c478bd9Sstevel@tonic-gate "used to configure a resource control.\n"), 9297c478bd9Sstevel@tonic-gate rt_to_str(resource_scope)); 9307c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("Valid commands:\n")); 9317c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 9327c478bd9Sstevel@tonic-gate pt_to_str(PT_NAME), gettext("<string>")); 9337c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s (%s=%s,%s=%s,%s=%s)\n", 9347c478bd9Sstevel@tonic-gate cmd_to_str(CMD_ADD), pt_to_str(PT_VALUE), 9357c478bd9Sstevel@tonic-gate pt_to_str(PT_PRIV), gettext("<priv-value>"), 9367c478bd9Sstevel@tonic-gate pt_to_str(PT_LIMIT), gettext("<number>"), 9377c478bd9Sstevel@tonic-gate pt_to_str(PT_ACTION), gettext("<action-value>")); 938ffbafc53Scomay (void) fprintf(fp, "\t%s %s (%s=%s,%s=%s,%s=%s)\n", 939ffbafc53Scomay cmd_to_str(CMD_REMOVE), pt_to_str(PT_VALUE), 940ffbafc53Scomay pt_to_str(PT_PRIV), gettext("<priv-value>"), 941ffbafc53Scomay pt_to_str(PT_LIMIT), gettext("<number>"), 942ffbafc53Scomay pt_to_str(PT_ACTION), gettext("<action-value>")); 9437c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s\n\t%s := privileged\n" 9447c478bd9Sstevel@tonic-gate "\t%s := none | deny\n", gettext("Where"), 9457c478bd9Sstevel@tonic-gate gettext("<priv-value>"), gettext("<action-value>")); 9467c478bd9Sstevel@tonic-gate break; 9477c478bd9Sstevel@tonic-gate case RT_ATTR: 9487c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("The '%s' resource scope is " 9497c478bd9Sstevel@tonic-gate "used to configure a generic attribute.\n"), 9507c478bd9Sstevel@tonic-gate rt_to_str(resource_scope)); 9517c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("Valid commands:\n")); 9527c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 9537c478bd9Sstevel@tonic-gate pt_to_str(PT_NAME), gettext("<name>")); 9547c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=boolean\n", 9557c478bd9Sstevel@tonic-gate cmd_to_str(CMD_SET), pt_to_str(PT_TYPE)); 9567c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=true | false\n", 9577c478bd9Sstevel@tonic-gate cmd_to_str(CMD_SET), pt_to_str(PT_VALUE)); 9587c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("or\n")); 9597c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=int\n", cmd_to_str(CMD_SET), 9607c478bd9Sstevel@tonic-gate pt_to_str(PT_TYPE)); 9617c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 9627c478bd9Sstevel@tonic-gate pt_to_str(PT_VALUE), gettext("<integer>")); 9637c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("or\n")); 9647c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=string\n", 9657c478bd9Sstevel@tonic-gate cmd_to_str(CMD_SET), pt_to_str(PT_TYPE)); 9667c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 9677c478bd9Sstevel@tonic-gate pt_to_str(PT_VALUE), gettext("<string>")); 9687c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("or\n")); 9697c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s %s=uint\n", 9707c478bd9Sstevel@tonic-gate cmd_to_str(CMD_SET), 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("<unsigned integer>")); 9737c478bd9Sstevel@tonic-gate break; 974fa9e4066Sahrens case RT_DATASET: 975fa9e4066Sahrens (void) fprintf(fp, gettext("The '%s' resource scope is " 976fa9e4066Sahrens "used to export ZFS datasets.\n"), 977fa9e4066Sahrens rt_to_str(resource_scope)); 978fa9e4066Sahrens (void) fprintf(fp, gettext("Valid commands:\n")); 979fa9e4066Sahrens (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 980fa9e4066Sahrens pt_to_str(PT_NAME), gettext("<name>")); 981fa9e4066Sahrens break; 982*0209230bSgjelinek case RT_DCPU: 983*0209230bSgjelinek (void) fprintf(fp, gettext("The '%s' resource scope " 984*0209230bSgjelinek "configures the 'pools' facility to dedicate\na " 985*0209230bSgjelinek "subset of the system's processors to this zone " 986*0209230bSgjelinek "while it is running.\n"), 987*0209230bSgjelinek rt_to_str(resource_scope)); 988*0209230bSgjelinek (void) fprintf(fp, gettext("Valid commands:\n")); 989*0209230bSgjelinek (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 990*0209230bSgjelinek pt_to_str(PT_NCPUS), 991*0209230bSgjelinek gettext("<unsigned integer | range>")); 992*0209230bSgjelinek (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 993*0209230bSgjelinek pt_to_str(PT_IMPORTANCE), 994*0209230bSgjelinek gettext("<unsigned integer>")); 995*0209230bSgjelinek break; 996*0209230bSgjelinek case RT_MCAP: 997*0209230bSgjelinek (void) fprintf(fp, gettext("The '%s' resource scope is " 998*0209230bSgjelinek "used to set an upper limit (a cap) on the\n" 999*0209230bSgjelinek "amount of physical memory, swap space and locked " 1000*0209230bSgjelinek "memory that can be used by\nthis zone.\n"), 1001*0209230bSgjelinek rt_to_str(resource_scope)); 1002*0209230bSgjelinek (void) fprintf(fp, gettext("Valid commands:\n")); 1003*0209230bSgjelinek (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 1004*0209230bSgjelinek pt_to_str(PT_PHYSICAL), 1005*0209230bSgjelinek gettext("<qualified unsigned decimal>")); 1006*0209230bSgjelinek (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 1007*0209230bSgjelinek pt_to_str(PT_SWAP), 1008*0209230bSgjelinek gettext("<qualified unsigned decimal>")); 1009*0209230bSgjelinek (void) fprintf(fp, "\t%s %s=%s\n", cmd_to_str(CMD_SET), 1010*0209230bSgjelinek pt_to_str(PT_LOCKED), 1011*0209230bSgjelinek gettext("<qualified unsigned decimal>")); 1012*0209230bSgjelinek break; 10137c478bd9Sstevel@tonic-gate } 10147c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("And from any resource scope, you " 10157c478bd9Sstevel@tonic-gate "can:\n")); 10167c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t%s\n", cmd_to_str(CMD_END), 10177c478bd9Sstevel@tonic-gate gettext("(to conclude this operation)")); 10187c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t%s\n", cmd_to_str(CMD_CANCEL), 10197c478bd9Sstevel@tonic-gate gettext("(to cancel this operation)")); 10207c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t%s\n", cmd_to_str(CMD_EXIT), 10217c478bd9Sstevel@tonic-gate gettext("(to exit the zonecfg utility)")); 10227c478bd9Sstevel@tonic-gate } 10237c478bd9Sstevel@tonic-gate if (flags & HELP_USAGE) { 10247c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s:\t%s %s\n", gettext("usage"), 10257c478bd9Sstevel@tonic-gate execname, cmd_to_str(CMD_HELP)); 10267c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s -z <zone>\t\t\t(%s)\n", 10277c478bd9Sstevel@tonic-gate execname, gettext("interactive")); 10287c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s -z <zone> <command>\n", execname); 10297c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s -z <zone> -f <command-file>\n", 10307c478bd9Sstevel@tonic-gate execname); 10317c478bd9Sstevel@tonic-gate } 10327c478bd9Sstevel@tonic-gate if (flags & HELP_SUBCMDS) { 10337c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s:\n\n", gettext("Commands")); 10347c478bd9Sstevel@tonic-gate for (i = 0; i <= CMD_MAX; i++) { 10357c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s\n", helptab[i].short_usage); 10367c478bd9Sstevel@tonic-gate if (verbose) 10377c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\n\n", long_help(i)); 10387c478bd9Sstevel@tonic-gate } 10397c478bd9Sstevel@tonic-gate } 10407c478bd9Sstevel@tonic-gate if (flags & HELP_SYNTAX) { 10417c478bd9Sstevel@tonic-gate if (!verbose) 10427c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\n"); 10437c478bd9Sstevel@tonic-gate (void) fprintf(fp, "<zone> := [A-Za-z0-9][A-Za-z0-9_.-]*\n"); 10447c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("\t(except the reserved words " 10457c478bd9Sstevel@tonic-gate "'%s' and anything starting with '%s')\n"), "global", 10467c478bd9Sstevel@tonic-gate "SUNW"); 10477c478bd9Sstevel@tonic-gate (void) fprintf(fp, 10487c478bd9Sstevel@tonic-gate gettext("\tName must be less than %d characters.\n"), 10497c478bd9Sstevel@tonic-gate ZONENAME_MAX); 10507c478bd9Sstevel@tonic-gate if (verbose) 10517c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\n"); 10527c478bd9Sstevel@tonic-gate } 10537c478bd9Sstevel@tonic-gate if (flags & HELP_NETADDR) { 10547c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("\n<net-addr> :=")); 10557c478bd9Sstevel@tonic-gate (void) fprintf(fp, 10567c478bd9Sstevel@tonic-gate gettext("\t<IPv4-address>[/<IPv4-prefix-length>] |\n")); 10577c478bd9Sstevel@tonic-gate (void) fprintf(fp, 10587c478bd9Sstevel@tonic-gate gettext("\t\t<IPv6-address>/<IPv6-prefix-length> |\n")); 10597c478bd9Sstevel@tonic-gate (void) fprintf(fp, 10607c478bd9Sstevel@tonic-gate gettext("\t\t<hostname>[/<IPv4-prefix-length>]\n")); 10617c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("See inet(3SOCKET) for IPv4 and " 10627c478bd9Sstevel@tonic-gate "IPv6 address syntax.\n")); 10637c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("<IPv4-prefix-length> := [0-32]\n")); 10647c478bd9Sstevel@tonic-gate (void) fprintf(fp, 10657c478bd9Sstevel@tonic-gate gettext("<IPv6-prefix-length> := [0-128]\n")); 10667c478bd9Sstevel@tonic-gate (void) fprintf(fp, 10677c478bd9Sstevel@tonic-gate gettext("<hostname> := [A-Za-z0-9][A-Za-z0-9-.]*\n")); 10687c478bd9Sstevel@tonic-gate } 10697c478bd9Sstevel@tonic-gate if (flags & HELP_RESOURCES) { 10709e7542f4Sdp (void) fprintf(fp, "<%s> := %s | %s | %s | %s | %s | %s |\n\t" 1071*0209230bSgjelinek "%s | %s | %s\n\n", 10727c478bd9Sstevel@tonic-gate gettext("resource type"), rt_to_str(RT_FS), 10737c478bd9Sstevel@tonic-gate rt_to_str(RT_IPD), rt_to_str(RT_NET), rt_to_str(RT_DEVICE), 10749e7542f4Sdp rt_to_str(RT_RCTL), rt_to_str(RT_ATTR), 1075*0209230bSgjelinek rt_to_str(RT_DATASET), rt_to_str(RT_DCPU), 1076*0209230bSgjelinek rt_to_str(RT_MCAP)); 10777c478bd9Sstevel@tonic-gate } 10787c478bd9Sstevel@tonic-gate if (flags & HELP_PROPS) { 10797c478bd9Sstevel@tonic-gate (void) fprintf(fp, gettext("For resource type ... there are " 10807c478bd9Sstevel@tonic-gate "property types ...:\n")); 1081087719fdSdp (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 1082087719fdSdp pt_to_str(PT_ZONENAME)); 10837c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 10847c478bd9Sstevel@tonic-gate pt_to_str(PT_ZONEPATH)); 10859acbbeafSnn (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 10869acbbeafSnn pt_to_str(PT_BRAND)); 10877c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 10887c478bd9Sstevel@tonic-gate pt_to_str(PT_AUTOBOOT)); 10893f2f09c1Sdp (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 10903f2f09c1Sdp pt_to_str(PT_BOOTARGS)); 10917c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 10927c478bd9Sstevel@tonic-gate pt_to_str(PT_POOL)); 1093ffbafc53Scomay (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 1094ffbafc53Scomay pt_to_str(PT_LIMITPRIV)); 1095*0209230bSgjelinek (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 1096*0209230bSgjelinek pt_to_str(PT_SCHED)); 1097*0209230bSgjelinek (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 1098*0209230bSgjelinek pt_to_str(PT_MAXLWPS)); 1099*0209230bSgjelinek (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 1100*0209230bSgjelinek pt_to_str(PT_MAXSHMMEM)); 1101*0209230bSgjelinek (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 1102*0209230bSgjelinek pt_to_str(PT_MAXSHMIDS)); 1103*0209230bSgjelinek (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 1104*0209230bSgjelinek pt_to_str(PT_MAXMSGIDS)); 1105*0209230bSgjelinek (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 1106*0209230bSgjelinek pt_to_str(PT_MAXSEMIDS)); 1107*0209230bSgjelinek (void) fprintf(fp, "\t%s\t%s\n", gettext("(global)"), 1108*0209230bSgjelinek pt_to_str(PT_SHARES)); 11097c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t\t%s, %s, %s, %s\n", rt_to_str(RT_FS), 11107c478bd9Sstevel@tonic-gate pt_to_str(PT_DIR), pt_to_str(PT_SPECIAL), 11117c478bd9Sstevel@tonic-gate pt_to_str(PT_RAW), pt_to_str(PT_TYPE), 11127c478bd9Sstevel@tonic-gate pt_to_str(PT_OPTIONS)); 11137c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t%s\n", rt_to_str(RT_IPD), 11147c478bd9Sstevel@tonic-gate pt_to_str(PT_DIR)); 11157c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t\t%s, %s\n", rt_to_str(RT_NET), 11167c478bd9Sstevel@tonic-gate pt_to_str(PT_ADDRESS), pt_to_str(PT_PHYSICAL)); 11177c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t\t%s\n", rt_to_str(RT_DEVICE), 11187c478bd9Sstevel@tonic-gate pt_to_str(PT_MATCH)); 11197c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t\t%s, %s\n", rt_to_str(RT_RCTL), 11207c478bd9Sstevel@tonic-gate pt_to_str(PT_NAME), pt_to_str(PT_VALUE)); 11217c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s\t\t%s, %s, %s\n", rt_to_str(RT_ATTR), 11227c478bd9Sstevel@tonic-gate pt_to_str(PT_NAME), pt_to_str(PT_TYPE), 11237c478bd9Sstevel@tonic-gate pt_to_str(PT_VALUE)); 1124fa9e4066Sahrens (void) fprintf(fp, "\t%s\t\t%s\n", rt_to_str(RT_DATASET), 1125fa9e4066Sahrens pt_to_str(PT_NAME)); 1126*0209230bSgjelinek (void) fprintf(fp, "\t%s\t%s, %s\n", rt_to_str(RT_DCPU), 1127*0209230bSgjelinek pt_to_str(PT_NCPUS), pt_to_str(PT_IMPORTANCE)); 1128*0209230bSgjelinek (void) fprintf(fp, "\t%s\t%s, %s, %s\n", rt_to_str(RT_MCAP), 1129*0209230bSgjelinek pt_to_str(PT_PHYSICAL), pt_to_str(PT_SWAP), 1130*0209230bSgjelinek pt_to_str(PT_LOCKED)); 11317c478bd9Sstevel@tonic-gate } 11327c478bd9Sstevel@tonic-gate if (need_to_close) 11337c478bd9Sstevel@tonic-gate (void) pclose(fp); 11347c478bd9Sstevel@tonic-gate } 11357c478bd9Sstevel@tonic-gate 11367c478bd9Sstevel@tonic-gate /* PRINTFLIKE1 */ 11377c478bd9Sstevel@tonic-gate static void 11387c478bd9Sstevel@tonic-gate zerr(const char *fmt, ...) 11397c478bd9Sstevel@tonic-gate { 11407c478bd9Sstevel@tonic-gate va_list alist; 11417c478bd9Sstevel@tonic-gate static int last_lineno; 11427c478bd9Sstevel@tonic-gate 11437c478bd9Sstevel@tonic-gate /* lex_lineno has already been incremented in the lexer; compensate */ 11447c478bd9Sstevel@tonic-gate if (cmd_file_mode && lex_lineno > last_lineno) { 11457c478bd9Sstevel@tonic-gate if (strcmp(cmd_file_name, "-") == 0) 11467c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("On line %d:\n"), 11477c478bd9Sstevel@tonic-gate lex_lineno - 1); 11487c478bd9Sstevel@tonic-gate else 11497c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("On line %d of %s:\n"), 11507c478bd9Sstevel@tonic-gate lex_lineno - 1, cmd_file_name); 11517c478bd9Sstevel@tonic-gate last_lineno = lex_lineno; 11527c478bd9Sstevel@tonic-gate } 11537c478bd9Sstevel@tonic-gate va_start(alist, fmt); 11547c478bd9Sstevel@tonic-gate (void) vfprintf(stderr, fmt, alist); 11557c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "\n"); 11567c478bd9Sstevel@tonic-gate va_end(alist); 11577c478bd9Sstevel@tonic-gate } 11587c478bd9Sstevel@tonic-gate 11597c478bd9Sstevel@tonic-gate static void 11607c478bd9Sstevel@tonic-gate zone_perror(char *prefix, int err, bool set_saw) 11617c478bd9Sstevel@tonic-gate { 11627c478bd9Sstevel@tonic-gate zerr("%s: %s", prefix, zonecfg_strerror(err)); 11637c478bd9Sstevel@tonic-gate if (set_saw) 11647c478bd9Sstevel@tonic-gate saw_error = TRUE; 11657c478bd9Sstevel@tonic-gate } 11667c478bd9Sstevel@tonic-gate 11677c478bd9Sstevel@tonic-gate /* 11687c478bd9Sstevel@tonic-gate * zone_perror() expects a single string, but for remove and select 11697c478bd9Sstevel@tonic-gate * we have both the command and the resource type, so this wrapper 11707c478bd9Sstevel@tonic-gate * function serves the same purpose in a slightly different way. 11717c478bd9Sstevel@tonic-gate */ 11727c478bd9Sstevel@tonic-gate 11737c478bd9Sstevel@tonic-gate static void 11747c478bd9Sstevel@tonic-gate z_cmd_rt_perror(int cmd_num, int res_num, int err, bool set_saw) 11757c478bd9Sstevel@tonic-gate { 11767c478bd9Sstevel@tonic-gate zerr("%s %s: %s", cmd_to_str(cmd_num), rt_to_str(res_num), 11777c478bd9Sstevel@tonic-gate zonecfg_strerror(err)); 11787c478bd9Sstevel@tonic-gate if (set_saw) 11797c478bd9Sstevel@tonic-gate saw_error = TRUE; 11807c478bd9Sstevel@tonic-gate } 11817c478bd9Sstevel@tonic-gate 11827c478bd9Sstevel@tonic-gate /* returns Z_OK if successful, Z_foo from <libzonecfg.h> otherwise */ 11837c478bd9Sstevel@tonic-gate static int 11847c478bd9Sstevel@tonic-gate initialize(bool handle_expected) 11857c478bd9Sstevel@tonic-gate { 11867c478bd9Sstevel@tonic-gate int err; 11879acbbeafSnn char brandname[MAXNAMELEN]; 11887c478bd9Sstevel@tonic-gate 11897c478bd9Sstevel@tonic-gate if (zonecfg_check_handle(handle) != Z_OK) { 11907c478bd9Sstevel@tonic-gate if ((err = zonecfg_get_handle(zone, handle)) == Z_OK) { 11917c478bd9Sstevel@tonic-gate got_handle = TRUE; 11929acbbeafSnn if (zonecfg_get_brand(handle, brandname, 11939acbbeafSnn sizeof (brandname)) != Z_OK) { 11949acbbeafSnn zerr("Zone %s is inconsistent: missing " 11959acbbeafSnn "brand attribute", zone); 11969acbbeafSnn exit(Z_ERR); 11979acbbeafSnn } 11989acbbeafSnn if ((brand = brand_open(brandname)) == NULL) { 11999acbbeafSnn zerr("Zone %s uses non-existent brand \"%s\"." 12009acbbeafSnn " Unable to continue", zone, brandname); 12019acbbeafSnn exit(Z_ERR); 12029acbbeafSnn } 1203*0209230bSgjelinek } else if (global_zone && err == Z_NO_ZONE && !got_handle && 1204*0209230bSgjelinek !read_only_mode) { 1205*0209230bSgjelinek /* 1206*0209230bSgjelinek * We implicitly create the global zone config if it 1207*0209230bSgjelinek * doesn't exist. 1208*0209230bSgjelinek */ 1209*0209230bSgjelinek zone_dochandle_t tmphandle; 1210*0209230bSgjelinek 1211*0209230bSgjelinek if ((tmphandle = zonecfg_init_handle()) == NULL) { 1212*0209230bSgjelinek zone_perror(execname, Z_NOMEM, TRUE); 1213*0209230bSgjelinek exit(Z_ERR); 1214*0209230bSgjelinek } 1215*0209230bSgjelinek 1216*0209230bSgjelinek err = zonecfg_get_template_handle("SUNWblank", zone, 1217*0209230bSgjelinek tmphandle); 1218*0209230bSgjelinek 1219*0209230bSgjelinek if (err != Z_OK) { 1220*0209230bSgjelinek zonecfg_fini_handle(tmphandle); 1221*0209230bSgjelinek zone_perror("SUNWblank", err, TRUE); 1222*0209230bSgjelinek return (err); 1223*0209230bSgjelinek } 1224*0209230bSgjelinek 1225*0209230bSgjelinek need_to_commit = TRUE; 1226*0209230bSgjelinek zonecfg_fini_handle(handle); 1227*0209230bSgjelinek handle = tmphandle; 1228*0209230bSgjelinek got_handle = TRUE; 1229*0209230bSgjelinek 12307c478bd9Sstevel@tonic-gate } else { 12317c478bd9Sstevel@tonic-gate zone_perror(zone, err, handle_expected || got_handle); 12327c478bd9Sstevel@tonic-gate if (err == Z_NO_ZONE && !got_handle && 12337c478bd9Sstevel@tonic-gate interactive_mode && !read_only_mode) 12347c478bd9Sstevel@tonic-gate (void) printf(gettext("Use '%s' to begin " 12357c478bd9Sstevel@tonic-gate "configuring a new zone.\n"), 12367c478bd9Sstevel@tonic-gate cmd_to_str(CMD_CREATE)); 12377c478bd9Sstevel@tonic-gate return (err); 12387c478bd9Sstevel@tonic-gate } 12397c478bd9Sstevel@tonic-gate } 12407c478bd9Sstevel@tonic-gate return (Z_OK); 12417c478bd9Sstevel@tonic-gate } 12427c478bd9Sstevel@tonic-gate 1243087719fdSdp static bool 1244087719fdSdp state_atleast(zone_state_t state) 1245087719fdSdp { 1246087719fdSdp zone_state_t state_num; 1247087719fdSdp int err; 1248087719fdSdp 1249087719fdSdp if ((err = zone_get_state(zone, &state_num)) != Z_OK) { 1250087719fdSdp /* all states are greater than "non-existent" */ 1251087719fdSdp if (err == Z_NO_ZONE) 1252087719fdSdp return (B_FALSE); 1253087719fdSdp zerr(gettext("Unexpectedly failed to determine state " 1254087719fdSdp "of zone %s: %s"), zone, zonecfg_strerror(err)); 1255087719fdSdp exit(Z_ERR); 1256087719fdSdp } 1257087719fdSdp return (state_num >= state); 1258087719fdSdp } 1259087719fdSdp 12607c478bd9Sstevel@tonic-gate /* 12617c478bd9Sstevel@tonic-gate * short_usage() is for bad syntax: getopt() issues, too many arguments, etc. 12627c478bd9Sstevel@tonic-gate */ 12637c478bd9Sstevel@tonic-gate 12647c478bd9Sstevel@tonic-gate void 12657c478bd9Sstevel@tonic-gate short_usage(int command) 12667c478bd9Sstevel@tonic-gate { 12677c478bd9Sstevel@tonic-gate /* lex_lineno has already been incremented in the lexer; compensate */ 12687c478bd9Sstevel@tonic-gate if (cmd_file_mode) { 12697c478bd9Sstevel@tonic-gate if (strcmp(cmd_file_name, "-") == 0) 12707c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 12717c478bd9Sstevel@tonic-gate gettext("syntax error on line %d\n"), 12727c478bd9Sstevel@tonic-gate lex_lineno - 1); 12737c478bd9Sstevel@tonic-gate else 12747c478bd9Sstevel@tonic-gate (void) fprintf(stderr, 12757c478bd9Sstevel@tonic-gate gettext("syntax error on line %d of %s\n"), 12767c478bd9Sstevel@tonic-gate lex_lineno - 1, cmd_file_name); 12777c478bd9Sstevel@tonic-gate } 12787c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "%s:\n%s\n", gettext("usage"), 12797c478bd9Sstevel@tonic-gate helptab[command].short_usage); 12807c478bd9Sstevel@tonic-gate saw_error = TRUE; 12817c478bd9Sstevel@tonic-gate } 12827c478bd9Sstevel@tonic-gate 12837c478bd9Sstevel@tonic-gate /* 12847c478bd9Sstevel@tonic-gate * long_usage() is for bad semantics: e.g., wrong property type for a given 12857c478bd9Sstevel@tonic-gate * resource type. It is also used by longer_usage() below. 12867c478bd9Sstevel@tonic-gate */ 12877c478bd9Sstevel@tonic-gate 12887c478bd9Sstevel@tonic-gate void 12897c478bd9Sstevel@tonic-gate long_usage(uint_t cmd_num, bool set_saw) 12907c478bd9Sstevel@tonic-gate { 12917c478bd9Sstevel@tonic-gate (void) fprintf(set_saw ? stderr : stdout, "%s:\n%s\n", gettext("usage"), 12927c478bd9Sstevel@tonic-gate helptab[cmd_num].short_usage); 12937c478bd9Sstevel@tonic-gate (void) fprintf(set_saw ? stderr : stdout, "\t%s\n", long_help(cmd_num)); 12947c478bd9Sstevel@tonic-gate if (set_saw) 12957c478bd9Sstevel@tonic-gate saw_error = TRUE; 12967c478bd9Sstevel@tonic-gate } 12977c478bd9Sstevel@tonic-gate 12987c478bd9Sstevel@tonic-gate /* 12997c478bd9Sstevel@tonic-gate * longer_usage() is for 'help foo' and 'foo -?': call long_usage() and also 13007c478bd9Sstevel@tonic-gate * any extra usage() flags as appropriate for whatever command. 13017c478bd9Sstevel@tonic-gate */ 13027c478bd9Sstevel@tonic-gate 13037c478bd9Sstevel@tonic-gate void 13047c478bd9Sstevel@tonic-gate longer_usage(uint_t cmd_num) 13057c478bd9Sstevel@tonic-gate { 13067c478bd9Sstevel@tonic-gate long_usage(cmd_num, FALSE); 13077c478bd9Sstevel@tonic-gate if (helptab[cmd_num].flags != 0) { 13087c478bd9Sstevel@tonic-gate (void) printf("\n"); 13097c478bd9Sstevel@tonic-gate usage(TRUE, helptab[cmd_num].flags); 13107c478bd9Sstevel@tonic-gate } 13117c478bd9Sstevel@tonic-gate } 13127c478bd9Sstevel@tonic-gate 13137c478bd9Sstevel@tonic-gate /* 13147c478bd9Sstevel@tonic-gate * scope_usage() is simply used when a command is called from the wrong scope. 13157c478bd9Sstevel@tonic-gate */ 13167c478bd9Sstevel@tonic-gate 13177c478bd9Sstevel@tonic-gate static void 13187c478bd9Sstevel@tonic-gate scope_usage(uint_t cmd_num) 13197c478bd9Sstevel@tonic-gate { 13207c478bd9Sstevel@tonic-gate zerr(gettext("The %s command only makes sense in the %s scope."), 13217c478bd9Sstevel@tonic-gate cmd_to_str(cmd_num), 13227c478bd9Sstevel@tonic-gate global_scope ? gettext("resource") : gettext("global")); 13237c478bd9Sstevel@tonic-gate saw_error = TRUE; 13247c478bd9Sstevel@tonic-gate } 13257c478bd9Sstevel@tonic-gate 13267c478bd9Sstevel@tonic-gate /* 13277c478bd9Sstevel@tonic-gate * On input, TRUE => yes, FALSE => no. 13287c478bd9Sstevel@tonic-gate * On return, TRUE => 1, FALSE => no, could not ask => -1. 13297c478bd9Sstevel@tonic-gate */ 13307c478bd9Sstevel@tonic-gate 13317c478bd9Sstevel@tonic-gate static int 13327c478bd9Sstevel@tonic-gate ask_yesno(bool default_answer, const char *question) 13337c478bd9Sstevel@tonic-gate { 13347c478bd9Sstevel@tonic-gate char line[64]; /* should be enough to answer yes or no */ 13357c478bd9Sstevel@tonic-gate 13367c478bd9Sstevel@tonic-gate if (!ok_to_prompt) { 13377c478bd9Sstevel@tonic-gate saw_error = TRUE; 13387c478bd9Sstevel@tonic-gate return (-1); 13397c478bd9Sstevel@tonic-gate } 13407c478bd9Sstevel@tonic-gate for (;;) { 1341087719fdSdp if (printf("%s (%s)? ", question, 1342087719fdSdp default_answer ? "[y]/n" : "y/[n]") < 0) 1343087719fdSdp return (-1); 1344087719fdSdp if (fgets(line, sizeof (line), stdin) == NULL) 1345087719fdSdp return (-1); 1346087719fdSdp 1347087719fdSdp if (line[0] == '\n') 13487c478bd9Sstevel@tonic-gate return (default_answer ? 1 : 0); 13497c478bd9Sstevel@tonic-gate if (tolower(line[0]) == 'y') 13507c478bd9Sstevel@tonic-gate return (1); 13517c478bd9Sstevel@tonic-gate if (tolower(line[0]) == 'n') 13527c478bd9Sstevel@tonic-gate return (0); 13537c478bd9Sstevel@tonic-gate } 13547c478bd9Sstevel@tonic-gate } 13557c478bd9Sstevel@tonic-gate 13567c478bd9Sstevel@tonic-gate /* 13577c478bd9Sstevel@tonic-gate * Prints warning if zone already exists. 13587c478bd9Sstevel@tonic-gate * In interactive mode, prompts if we should continue anyway and returns Z_OK 13597c478bd9Sstevel@tonic-gate * if so, Z_ERR if not. In non-interactive mode, exits with Z_ERR. 13607c478bd9Sstevel@tonic-gate * 13617c478bd9Sstevel@tonic-gate * Note that if a zone exists and its state is >= INSTALLED, an error message 13627c478bd9Sstevel@tonic-gate * will be printed and this function will return Z_ERR regardless of mode. 13637c478bd9Sstevel@tonic-gate */ 13647c478bd9Sstevel@tonic-gate 13657c478bd9Sstevel@tonic-gate static int 13667c478bd9Sstevel@tonic-gate check_if_zone_already_exists(bool force) 13677c478bd9Sstevel@tonic-gate { 13687c478bd9Sstevel@tonic-gate char line[ZONENAME_MAX + 128]; /* enough to ask a question */ 13697c478bd9Sstevel@tonic-gate zone_dochandle_t tmphandle; 13707c478bd9Sstevel@tonic-gate int res, answer; 13717c478bd9Sstevel@tonic-gate 13727c478bd9Sstevel@tonic-gate if ((tmphandle = zonecfg_init_handle()) == NULL) { 13737c478bd9Sstevel@tonic-gate zone_perror(execname, Z_NOMEM, TRUE); 13747c478bd9Sstevel@tonic-gate exit(Z_ERR); 13757c478bd9Sstevel@tonic-gate } 13767c478bd9Sstevel@tonic-gate res = zonecfg_get_handle(zone, tmphandle); 13777c478bd9Sstevel@tonic-gate zonecfg_fini_handle(tmphandle); 1378087719fdSdp if (res != Z_OK) 13797c478bd9Sstevel@tonic-gate return (Z_OK); 1380087719fdSdp 1381087719fdSdp if (state_atleast(ZONE_STATE_INSTALLED)) { 13827c478bd9Sstevel@tonic-gate zerr(gettext("Zone %s already installed; %s not allowed."), 13837c478bd9Sstevel@tonic-gate zone, cmd_to_str(CMD_CREATE)); 13847c478bd9Sstevel@tonic-gate return (Z_ERR); 13857c478bd9Sstevel@tonic-gate } 13867c478bd9Sstevel@tonic-gate 13877c478bd9Sstevel@tonic-gate if (force) { 13887c478bd9Sstevel@tonic-gate (void) printf(gettext("Zone %s already exists; overwriting.\n"), 13897c478bd9Sstevel@tonic-gate zone); 13907c478bd9Sstevel@tonic-gate return (Z_OK); 13917c478bd9Sstevel@tonic-gate } 13927c478bd9Sstevel@tonic-gate (void) snprintf(line, sizeof (line), 13937c478bd9Sstevel@tonic-gate gettext("Zone %s already exists; %s anyway"), zone, 13947c478bd9Sstevel@tonic-gate cmd_to_str(CMD_CREATE)); 13957c478bd9Sstevel@tonic-gate if ((answer = ask_yesno(FALSE, line)) == -1) { 13967c478bd9Sstevel@tonic-gate zerr(gettext("Zone exists, input not from terminal and -F not " 13977c478bd9Sstevel@tonic-gate "specified:\n%s command ignored, exiting."), 13987c478bd9Sstevel@tonic-gate cmd_to_str(CMD_CREATE)); 13997c478bd9Sstevel@tonic-gate exit(Z_ERR); 14007c478bd9Sstevel@tonic-gate } 14017c478bd9Sstevel@tonic-gate return (answer == 1 ? Z_OK : Z_ERR); 14027c478bd9Sstevel@tonic-gate } 14037c478bd9Sstevel@tonic-gate 14047c478bd9Sstevel@tonic-gate static bool 14057c478bd9Sstevel@tonic-gate zone_is_read_only(int cmd_num) 14067c478bd9Sstevel@tonic-gate { 14077c478bd9Sstevel@tonic-gate if (strncmp(zone, "SUNW", 4) == 0) { 14087c478bd9Sstevel@tonic-gate zerr(gettext("%s: zones beginning with SUNW are read-only."), 14097c478bd9Sstevel@tonic-gate zone); 14107c478bd9Sstevel@tonic-gate saw_error = TRUE; 14117c478bd9Sstevel@tonic-gate return (TRUE); 14127c478bd9Sstevel@tonic-gate } 14137c478bd9Sstevel@tonic-gate if (read_only_mode) { 14147c478bd9Sstevel@tonic-gate zerr(gettext("%s: cannot %s in read-only mode."), zone, 14157c478bd9Sstevel@tonic-gate cmd_to_str(cmd_num)); 14167c478bd9Sstevel@tonic-gate saw_error = TRUE; 14177c478bd9Sstevel@tonic-gate return (TRUE); 14187c478bd9Sstevel@tonic-gate } 14197c478bd9Sstevel@tonic-gate return (FALSE); 14207c478bd9Sstevel@tonic-gate } 14217c478bd9Sstevel@tonic-gate 14227c478bd9Sstevel@tonic-gate /* 14237c478bd9Sstevel@tonic-gate * Create a new configuration. 14247c478bd9Sstevel@tonic-gate */ 14257c478bd9Sstevel@tonic-gate void 14267c478bd9Sstevel@tonic-gate create_func(cmd_t *cmd) 14277c478bd9Sstevel@tonic-gate { 14287c478bd9Sstevel@tonic-gate int err, arg; 14297c478bd9Sstevel@tonic-gate char zone_template[ZONENAME_MAX]; 1430ee519a1fSgjelinek char attach_path[MAXPATHLEN]; 14317c478bd9Sstevel@tonic-gate zone_dochandle_t tmphandle; 14327c478bd9Sstevel@tonic-gate bool force = FALSE; 1433ee519a1fSgjelinek bool attach = FALSE; 14347c478bd9Sstevel@tonic-gate 14357c478bd9Sstevel@tonic-gate assert(cmd != NULL); 14367c478bd9Sstevel@tonic-gate 14377c478bd9Sstevel@tonic-gate /* This is the default if no arguments are given. */ 14387c478bd9Sstevel@tonic-gate (void) strlcpy(zone_template, "SUNWdefault", sizeof (zone_template)); 14397c478bd9Sstevel@tonic-gate 14407c478bd9Sstevel@tonic-gate optind = 0; 14419acbbeafSnn while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?a:bFt:")) 14429acbbeafSnn != EOF) { 14437c478bd9Sstevel@tonic-gate switch (arg) { 14447c478bd9Sstevel@tonic-gate case '?': 14457c478bd9Sstevel@tonic-gate if (optopt == '?') 14467c478bd9Sstevel@tonic-gate longer_usage(CMD_CREATE); 14477c478bd9Sstevel@tonic-gate else 14487c478bd9Sstevel@tonic-gate short_usage(CMD_CREATE); 14497c478bd9Sstevel@tonic-gate return; 1450ee519a1fSgjelinek case 'a': 1451ee519a1fSgjelinek (void) strlcpy(attach_path, optarg, 1452ee519a1fSgjelinek sizeof (attach_path)); 1453ee519a1fSgjelinek attach = TRUE; 1454ee519a1fSgjelinek break; 14557c478bd9Sstevel@tonic-gate case 'b': 14567c478bd9Sstevel@tonic-gate (void) strlcpy(zone_template, "SUNWblank", 14577c478bd9Sstevel@tonic-gate sizeof (zone_template)); 14587c478bd9Sstevel@tonic-gate break; 14597c478bd9Sstevel@tonic-gate case 'F': 14607c478bd9Sstevel@tonic-gate force = TRUE; 14617c478bd9Sstevel@tonic-gate break; 14627c478bd9Sstevel@tonic-gate case 't': 14637c478bd9Sstevel@tonic-gate (void) strlcpy(zone_template, optarg, 14647c478bd9Sstevel@tonic-gate sizeof (zone_template)); 14657c478bd9Sstevel@tonic-gate break; 14667c478bd9Sstevel@tonic-gate default: 14677c478bd9Sstevel@tonic-gate short_usage(CMD_CREATE); 14687c478bd9Sstevel@tonic-gate return; 14697c478bd9Sstevel@tonic-gate } 14707c478bd9Sstevel@tonic-gate } 14717c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 14727c478bd9Sstevel@tonic-gate short_usage(CMD_CREATE); 14737c478bd9Sstevel@tonic-gate return; 14747c478bd9Sstevel@tonic-gate } 14757c478bd9Sstevel@tonic-gate 14767c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_CREATE)) 14777c478bd9Sstevel@tonic-gate return; 14787c478bd9Sstevel@tonic-gate 14797c478bd9Sstevel@tonic-gate if (check_if_zone_already_exists(force) != Z_OK) 14807c478bd9Sstevel@tonic-gate return; 14817c478bd9Sstevel@tonic-gate 14827c478bd9Sstevel@tonic-gate /* 14837c478bd9Sstevel@tonic-gate * Get a temporary handle first. If that fails, the old handle 14847c478bd9Sstevel@tonic-gate * will not be lost. Then finish whichever one we don't need, 14857c478bd9Sstevel@tonic-gate * to avoid leaks. Then get the handle for zone_template, and 14867c478bd9Sstevel@tonic-gate * set the name to zone: this "copy, rename" method is how 14877c478bd9Sstevel@tonic-gate * create -[b|t] works. 14887c478bd9Sstevel@tonic-gate */ 14897c478bd9Sstevel@tonic-gate if ((tmphandle = zonecfg_init_handle()) == NULL) { 14907c478bd9Sstevel@tonic-gate zone_perror(execname, Z_NOMEM, TRUE); 14917c478bd9Sstevel@tonic-gate exit(Z_ERR); 14927c478bd9Sstevel@tonic-gate } 1493ee519a1fSgjelinek 1494ee519a1fSgjelinek if (attach) 1495ee519a1fSgjelinek err = zonecfg_get_attach_handle(attach_path, zone, B_FALSE, 1496ee519a1fSgjelinek tmphandle); 1497ee519a1fSgjelinek else 1498ee519a1fSgjelinek err = zonecfg_get_template_handle(zone_template, zone, 1499ee519a1fSgjelinek tmphandle); 1500ee519a1fSgjelinek 1501ee519a1fSgjelinek if (err != Z_OK) { 15027c478bd9Sstevel@tonic-gate zonecfg_fini_handle(tmphandle); 1503ee519a1fSgjelinek if (attach && err == Z_NO_ZONE) 1504ee519a1fSgjelinek (void) fprintf(stderr, gettext("invalid path to " 1505ee519a1fSgjelinek "detached zone\n")); 1506ee519a1fSgjelinek else if (attach && err == Z_INVALID_DOCUMENT) 1507ee519a1fSgjelinek (void) fprintf(stderr, gettext("Cannot attach to an " 1508ee519a1fSgjelinek "earlier release of the operating system\n")); 1509ee519a1fSgjelinek else 1510ee519a1fSgjelinek zone_perror(zone_template, err, TRUE); 15117c478bd9Sstevel@tonic-gate return; 15127c478bd9Sstevel@tonic-gate } 1513087719fdSdp 1514087719fdSdp need_to_commit = TRUE; 15157c478bd9Sstevel@tonic-gate zonecfg_fini_handle(handle); 15167c478bd9Sstevel@tonic-gate handle = tmphandle; 1517087719fdSdp got_handle = TRUE; 15187c478bd9Sstevel@tonic-gate } 15197c478bd9Sstevel@tonic-gate 15207c478bd9Sstevel@tonic-gate /* 15217c478bd9Sstevel@tonic-gate * This malloc()'s memory, which must be freed by the caller. 15227c478bd9Sstevel@tonic-gate */ 15237c478bd9Sstevel@tonic-gate static char * 15247c478bd9Sstevel@tonic-gate quoteit(char *instr) 15257c478bd9Sstevel@tonic-gate { 15267c478bd9Sstevel@tonic-gate char *outstr; 15277c478bd9Sstevel@tonic-gate size_t outstrsize = strlen(instr) + 3; /* 2 quotes + '\0' */ 15287c478bd9Sstevel@tonic-gate 15297c478bd9Sstevel@tonic-gate if ((outstr = malloc(outstrsize)) == NULL) { 15307c478bd9Sstevel@tonic-gate zone_perror(zone, Z_NOMEM, FALSE); 15317c478bd9Sstevel@tonic-gate exit(Z_ERR); 15327c478bd9Sstevel@tonic-gate } 15337c478bd9Sstevel@tonic-gate if (strchr(instr, ' ') == NULL) { 15347c478bd9Sstevel@tonic-gate (void) strlcpy(outstr, instr, outstrsize); 15357c478bd9Sstevel@tonic-gate return (outstr); 15367c478bd9Sstevel@tonic-gate } 15377c478bd9Sstevel@tonic-gate (void) snprintf(outstr, outstrsize, "\"%s\"", instr); 15387c478bd9Sstevel@tonic-gate return (outstr); 15397c478bd9Sstevel@tonic-gate } 15407c478bd9Sstevel@tonic-gate 15417c478bd9Sstevel@tonic-gate static void 15427c478bd9Sstevel@tonic-gate export_prop(FILE *of, int prop_num, char *prop_id) 15437c478bd9Sstevel@tonic-gate { 15447c478bd9Sstevel@tonic-gate char *quote_str; 15457c478bd9Sstevel@tonic-gate 15467c478bd9Sstevel@tonic-gate if (strlen(prop_id) == 0) 15477c478bd9Sstevel@tonic-gate return; 15487c478bd9Sstevel@tonic-gate quote_str = quoteit(prop_id); 15497c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 15507c478bd9Sstevel@tonic-gate pt_to_str(prop_num), quote_str); 15517c478bd9Sstevel@tonic-gate free(quote_str); 15527c478bd9Sstevel@tonic-gate } 15537c478bd9Sstevel@tonic-gate 15547c478bd9Sstevel@tonic-gate void 15557c478bd9Sstevel@tonic-gate export_func(cmd_t *cmd) 15567c478bd9Sstevel@tonic-gate { 15577c478bd9Sstevel@tonic-gate struct zone_nwiftab nwiftab; 15587c478bd9Sstevel@tonic-gate struct zone_fstab fstab; 15597c478bd9Sstevel@tonic-gate struct zone_devtab devtab; 15607c478bd9Sstevel@tonic-gate struct zone_attrtab attrtab; 15617c478bd9Sstevel@tonic-gate struct zone_rctltab rctltab; 1562fa9e4066Sahrens struct zone_dstab dstab; 1563*0209230bSgjelinek struct zone_psettab psettab; 1564*0209230bSgjelinek struct zone_mcaptab mcaptab; 15657c478bd9Sstevel@tonic-gate struct zone_rctlvaltab *valptr; 15667c478bd9Sstevel@tonic-gate int err, arg; 15677c478bd9Sstevel@tonic-gate char zonepath[MAXPATHLEN], outfile[MAXPATHLEN], pool[MAXNAMELEN]; 15683f2f09c1Sdp char bootargs[BOOTARGS_MAX]; 1569*0209230bSgjelinek char sched[MAXNAMELEN]; 15709acbbeafSnn char brand[MAXNAMELEN]; 1571ffbafc53Scomay char *limitpriv; 15727c478bd9Sstevel@tonic-gate FILE *of; 15737c478bd9Sstevel@tonic-gate boolean_t autoboot; 15747c478bd9Sstevel@tonic-gate bool need_to_close = FALSE; 15757c478bd9Sstevel@tonic-gate 15767c478bd9Sstevel@tonic-gate assert(cmd != NULL); 15777c478bd9Sstevel@tonic-gate 15787c478bd9Sstevel@tonic-gate outfile[0] = '\0'; 15797c478bd9Sstevel@tonic-gate optind = 0; 15807c478bd9Sstevel@tonic-gate while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?f:")) != EOF) { 15817c478bd9Sstevel@tonic-gate switch (arg) { 15827c478bd9Sstevel@tonic-gate case '?': 15837c478bd9Sstevel@tonic-gate if (optopt == '?') 15847c478bd9Sstevel@tonic-gate longer_usage(CMD_EXPORT); 15857c478bd9Sstevel@tonic-gate else 15867c478bd9Sstevel@tonic-gate short_usage(CMD_EXPORT); 15877c478bd9Sstevel@tonic-gate return; 15887c478bd9Sstevel@tonic-gate case 'f': 15897c478bd9Sstevel@tonic-gate (void) strlcpy(outfile, optarg, sizeof (outfile)); 15907c478bd9Sstevel@tonic-gate break; 15917c478bd9Sstevel@tonic-gate default: 15927c478bd9Sstevel@tonic-gate short_usage(CMD_EXPORT); 15937c478bd9Sstevel@tonic-gate return; 15947c478bd9Sstevel@tonic-gate } 15957c478bd9Sstevel@tonic-gate } 15967c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 15977c478bd9Sstevel@tonic-gate short_usage(CMD_EXPORT); 15987c478bd9Sstevel@tonic-gate return; 15997c478bd9Sstevel@tonic-gate } 16007c478bd9Sstevel@tonic-gate if (strlen(outfile) == 0) { 16017c478bd9Sstevel@tonic-gate of = stdout; 16027c478bd9Sstevel@tonic-gate } else { 16037c478bd9Sstevel@tonic-gate if ((of = fopen(outfile, "w")) == NULL) { 16047c478bd9Sstevel@tonic-gate zerr(gettext("opening file %s: %s"), 16057c478bd9Sstevel@tonic-gate outfile, strerror(errno)); 16067c478bd9Sstevel@tonic-gate goto done; 16077c478bd9Sstevel@tonic-gate } 16087c478bd9Sstevel@tonic-gate setbuf(of, NULL); 16097c478bd9Sstevel@tonic-gate need_to_close = TRUE; 16107c478bd9Sstevel@tonic-gate } 16117c478bd9Sstevel@tonic-gate 16127c478bd9Sstevel@tonic-gate if ((err = initialize(TRUE)) != Z_OK) 16137c478bd9Sstevel@tonic-gate goto done; 16147c478bd9Sstevel@tonic-gate 16157c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s -b\n", cmd_to_str(CMD_CREATE)); 16167c478bd9Sstevel@tonic-gate 16177c478bd9Sstevel@tonic-gate if (zonecfg_get_zonepath(handle, zonepath, sizeof (zonepath)) == Z_OK && 16187c478bd9Sstevel@tonic-gate strlen(zonepath) > 0) 16197c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 16207c478bd9Sstevel@tonic-gate pt_to_str(PT_ZONEPATH), zonepath); 16217c478bd9Sstevel@tonic-gate 16229acbbeafSnn if ((zone_get_brand(zone, brand, sizeof (brand)) == Z_OK) && 16239acbbeafSnn (strcmp(brand, NATIVE_BRAND_NAME) != 0)) 16249acbbeafSnn (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 16259acbbeafSnn pt_to_str(PT_BRAND), brand); 16269acbbeafSnn 16277c478bd9Sstevel@tonic-gate if (zonecfg_get_autoboot(handle, &autoboot) == Z_OK) 16287c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 16297c478bd9Sstevel@tonic-gate pt_to_str(PT_AUTOBOOT), autoboot ? "true" : "false"); 16307c478bd9Sstevel@tonic-gate 16313f2f09c1Sdp if (zonecfg_get_bootargs(handle, bootargs, sizeof (bootargs)) == Z_OK && 16323f2f09c1Sdp strlen(bootargs) > 0) { 16333f2f09c1Sdp (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 16343f2f09c1Sdp pt_to_str(PT_BOOTARGS), bootargs); 16353f2f09c1Sdp } 16363f2f09c1Sdp 16377c478bd9Sstevel@tonic-gate if (zonecfg_get_pool(handle, pool, sizeof (pool)) == Z_OK && 16387c478bd9Sstevel@tonic-gate strlen(pool) > 0) 16397c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 16407c478bd9Sstevel@tonic-gate pt_to_str(PT_POOL), pool); 16417c478bd9Sstevel@tonic-gate 1642ffbafc53Scomay if (zonecfg_get_limitpriv(handle, &limitpriv) == Z_OK && 1643ffbafc53Scomay strlen(limitpriv) > 0) { 1644ffbafc53Scomay (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 1645ffbafc53Scomay pt_to_str(PT_LIMITPRIV), limitpriv); 1646ffbafc53Scomay free(limitpriv); 1647ffbafc53Scomay } 1648ffbafc53Scomay 1649*0209230bSgjelinek if (zonecfg_get_sched_class(handle, sched, sizeof (sched)) == Z_OK && 1650*0209230bSgjelinek strlen(sched) > 0) 1651*0209230bSgjelinek (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 1652*0209230bSgjelinek pt_to_str(PT_SCHED), sched); 16533f2f09c1Sdp 16547c478bd9Sstevel@tonic-gate if ((err = zonecfg_setipdent(handle)) != Z_OK) { 16557c478bd9Sstevel@tonic-gate zone_perror(zone, err, FALSE); 16567c478bd9Sstevel@tonic-gate goto done; 16577c478bd9Sstevel@tonic-gate } 16587c478bd9Sstevel@tonic-gate while (zonecfg_getipdent(handle, &fstab) == Z_OK) { 16597c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 16607c478bd9Sstevel@tonic-gate rt_to_str(RT_IPD)); 16617c478bd9Sstevel@tonic-gate export_prop(of, PT_DIR, fstab.zone_fs_dir); 16627c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 16637c478bd9Sstevel@tonic-gate } 16647c478bd9Sstevel@tonic-gate (void) zonecfg_endipdent(handle); 16657c478bd9Sstevel@tonic-gate 16667c478bd9Sstevel@tonic-gate if ((err = zonecfg_setfsent(handle)) != Z_OK) { 16677c478bd9Sstevel@tonic-gate zone_perror(zone, err, FALSE); 16687c478bd9Sstevel@tonic-gate goto done; 16697c478bd9Sstevel@tonic-gate } 16707c478bd9Sstevel@tonic-gate while (zonecfg_getfsent(handle, &fstab) == Z_OK) { 16717c478bd9Sstevel@tonic-gate zone_fsopt_t *optptr; 16727c478bd9Sstevel@tonic-gate 16737c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 16747c478bd9Sstevel@tonic-gate rt_to_str(RT_FS)); 16757c478bd9Sstevel@tonic-gate export_prop(of, PT_DIR, fstab.zone_fs_dir); 16767c478bd9Sstevel@tonic-gate export_prop(of, PT_SPECIAL, fstab.zone_fs_special); 16777c478bd9Sstevel@tonic-gate export_prop(of, PT_RAW, fstab.zone_fs_raw); 16787c478bd9Sstevel@tonic-gate export_prop(of, PT_TYPE, fstab.zone_fs_type); 16797c478bd9Sstevel@tonic-gate for (optptr = fstab.zone_fs_options; optptr != NULL; 16807c478bd9Sstevel@tonic-gate optptr = optptr->zone_fsopt_next) { 16817c478bd9Sstevel@tonic-gate /* 16827c478bd9Sstevel@tonic-gate * Simple property values with embedded equal signs 16837c478bd9Sstevel@tonic-gate * need to be quoted to prevent the lexer from 16847c478bd9Sstevel@tonic-gate * mis-parsing them as complex name=value pairs. 16857c478bd9Sstevel@tonic-gate */ 16867c478bd9Sstevel@tonic-gate if (strchr(optptr->zone_fsopt_opt, '=')) 16877c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s \"%s\"\n", 16887c478bd9Sstevel@tonic-gate cmd_to_str(CMD_ADD), 16897c478bd9Sstevel@tonic-gate pt_to_str(PT_OPTIONS), 16907c478bd9Sstevel@tonic-gate optptr->zone_fsopt_opt); 16917c478bd9Sstevel@tonic-gate else 16927c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s %s\n", 16937c478bd9Sstevel@tonic-gate cmd_to_str(CMD_ADD), 16947c478bd9Sstevel@tonic-gate pt_to_str(PT_OPTIONS), 16957c478bd9Sstevel@tonic-gate optptr->zone_fsopt_opt); 16967c478bd9Sstevel@tonic-gate } 16977c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 16987c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(fstab.zone_fs_options); 16997c478bd9Sstevel@tonic-gate } 17007c478bd9Sstevel@tonic-gate (void) zonecfg_endfsent(handle); 17017c478bd9Sstevel@tonic-gate 17027c478bd9Sstevel@tonic-gate if ((err = zonecfg_setnwifent(handle)) != Z_OK) { 17037c478bd9Sstevel@tonic-gate zone_perror(zone, err, FALSE); 17047c478bd9Sstevel@tonic-gate goto done; 17057c478bd9Sstevel@tonic-gate } 17067c478bd9Sstevel@tonic-gate while (zonecfg_getnwifent(handle, &nwiftab) == Z_OK) { 17077c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 17087c478bd9Sstevel@tonic-gate rt_to_str(RT_NET)); 17097c478bd9Sstevel@tonic-gate export_prop(of, PT_ADDRESS, nwiftab.zone_nwif_address); 17107c478bd9Sstevel@tonic-gate export_prop(of, PT_PHYSICAL, nwiftab.zone_nwif_physical); 17117c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 17127c478bd9Sstevel@tonic-gate } 17137c478bd9Sstevel@tonic-gate (void) zonecfg_endnwifent(handle); 17147c478bd9Sstevel@tonic-gate 17157c478bd9Sstevel@tonic-gate if ((err = zonecfg_setdevent(handle)) != Z_OK) { 17167c478bd9Sstevel@tonic-gate zone_perror(zone, err, FALSE); 17177c478bd9Sstevel@tonic-gate goto done; 17187c478bd9Sstevel@tonic-gate } 17197c478bd9Sstevel@tonic-gate while (zonecfg_getdevent(handle, &devtab) == Z_OK) { 17207c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 17217c478bd9Sstevel@tonic-gate rt_to_str(RT_DEVICE)); 17227c478bd9Sstevel@tonic-gate export_prop(of, PT_MATCH, devtab.zone_dev_match); 17237c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 17247c478bd9Sstevel@tonic-gate } 17257c478bd9Sstevel@tonic-gate (void) zonecfg_enddevent(handle); 17267c478bd9Sstevel@tonic-gate 17277c478bd9Sstevel@tonic-gate if ((err = zonecfg_setrctlent(handle)) != Z_OK) { 17287c478bd9Sstevel@tonic-gate zone_perror(zone, err, FALSE); 17297c478bd9Sstevel@tonic-gate goto done; 17307c478bd9Sstevel@tonic-gate } 17317c478bd9Sstevel@tonic-gate while (zonecfg_getrctlent(handle, &rctltab) == Z_OK) { 17327c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s rctl\n", cmd_to_str(CMD_ADD)); 17337c478bd9Sstevel@tonic-gate export_prop(of, PT_NAME, rctltab.zone_rctl_name); 17347c478bd9Sstevel@tonic-gate for (valptr = rctltab.zone_rctl_valptr; valptr != NULL; 17357c478bd9Sstevel@tonic-gate valptr = valptr->zone_rctlval_next) { 17367c478bd9Sstevel@tonic-gate fprintf(of, "%s %s (%s=%s,%s=%s,%s=%s)\n", 17377c478bd9Sstevel@tonic-gate cmd_to_str(CMD_ADD), pt_to_str(PT_VALUE), 17387c478bd9Sstevel@tonic-gate pt_to_str(PT_PRIV), valptr->zone_rctlval_priv, 17397c478bd9Sstevel@tonic-gate pt_to_str(PT_LIMIT), valptr->zone_rctlval_limit, 17407c478bd9Sstevel@tonic-gate pt_to_str(PT_ACTION), valptr->zone_rctlval_action); 17417c478bd9Sstevel@tonic-gate } 17427c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 17437c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctltab.zone_rctl_valptr); 17447c478bd9Sstevel@tonic-gate } 17457c478bd9Sstevel@tonic-gate (void) zonecfg_endrctlent(handle); 17467c478bd9Sstevel@tonic-gate 17477c478bd9Sstevel@tonic-gate if ((err = zonecfg_setattrent(handle)) != Z_OK) { 17487c478bd9Sstevel@tonic-gate zone_perror(zone, err, FALSE); 17497c478bd9Sstevel@tonic-gate goto done; 17507c478bd9Sstevel@tonic-gate } 17517c478bd9Sstevel@tonic-gate while (zonecfg_getattrent(handle, &attrtab) == Z_OK) { 17527c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 17537c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR)); 17547c478bd9Sstevel@tonic-gate export_prop(of, PT_NAME, attrtab.zone_attr_name); 17557c478bd9Sstevel@tonic-gate export_prop(of, PT_TYPE, attrtab.zone_attr_type); 17567c478bd9Sstevel@tonic-gate export_prop(of, PT_VALUE, attrtab.zone_attr_value); 17577c478bd9Sstevel@tonic-gate (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 17587c478bd9Sstevel@tonic-gate } 17597c478bd9Sstevel@tonic-gate (void) zonecfg_endattrent(handle); 17607c478bd9Sstevel@tonic-gate 1761fa9e4066Sahrens if ((err = zonecfg_setdsent(handle)) != Z_OK) { 1762fa9e4066Sahrens zone_perror(zone, err, FALSE); 1763fa9e4066Sahrens goto done; 1764fa9e4066Sahrens } 1765fa9e4066Sahrens while (zonecfg_getdsent(handle, &dstab) == Z_OK) { 1766fa9e4066Sahrens (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 1767fa9e4066Sahrens rt_to_str(RT_DATASET)); 1768fa9e4066Sahrens export_prop(of, PT_NAME, dstab.zone_dataset_name); 1769fa9e4066Sahrens (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 1770fa9e4066Sahrens } 1771fa9e4066Sahrens (void) zonecfg_enddsent(handle); 1772fa9e4066Sahrens 1773*0209230bSgjelinek if (zonecfg_getpsetent(handle, &psettab) == Z_OK) { 1774*0209230bSgjelinek (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 1775*0209230bSgjelinek rt_to_str(RT_DCPU)); 1776*0209230bSgjelinek if (strcmp(psettab.zone_ncpu_min, psettab.zone_ncpu_max) == 0) 1777*0209230bSgjelinek (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 1778*0209230bSgjelinek pt_to_str(PT_NCPUS), psettab.zone_ncpu_max); 1779*0209230bSgjelinek else 1780*0209230bSgjelinek (void) fprintf(of, "%s %s=%s-%s\n", cmd_to_str(CMD_SET), 1781*0209230bSgjelinek pt_to_str(PT_NCPUS), psettab.zone_ncpu_min, 1782*0209230bSgjelinek psettab.zone_ncpu_max); 1783*0209230bSgjelinek if (psettab.zone_importance[0] != '\0') 1784*0209230bSgjelinek (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 1785*0209230bSgjelinek pt_to_str(PT_IMPORTANCE), psettab.zone_importance); 1786*0209230bSgjelinek (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 1787*0209230bSgjelinek } 1788*0209230bSgjelinek 1789*0209230bSgjelinek if (zonecfg_getmcapent(handle, &mcaptab) == Z_OK) { 1790*0209230bSgjelinek char buf[128]; 1791*0209230bSgjelinek 1792*0209230bSgjelinek (void) fprintf(of, "%s %s\n", cmd_to_str(CMD_ADD), 1793*0209230bSgjelinek rt_to_str(RT_MCAP)); 1794*0209230bSgjelinek bytes_to_units(mcaptab.zone_physmem_cap, buf, sizeof (buf)); 1795*0209230bSgjelinek (void) fprintf(of, "%s %s=%s\n", cmd_to_str(CMD_SET), 1796*0209230bSgjelinek pt_to_str(PT_PHYSICAL), buf); 1797*0209230bSgjelinek (void) fprintf(of, "%s\n", cmd_to_str(CMD_END)); 1798*0209230bSgjelinek } 1799*0209230bSgjelinek 18007c478bd9Sstevel@tonic-gate done: 18017c478bd9Sstevel@tonic-gate if (need_to_close) 18027c478bd9Sstevel@tonic-gate (void) fclose(of); 18037c478bd9Sstevel@tonic-gate } 18047c478bd9Sstevel@tonic-gate 18057c478bd9Sstevel@tonic-gate void 18067c478bd9Sstevel@tonic-gate exit_func(cmd_t *cmd) 18077c478bd9Sstevel@tonic-gate { 18087c478bd9Sstevel@tonic-gate int arg, answer; 18097c478bd9Sstevel@tonic-gate 18107c478bd9Sstevel@tonic-gate optind = 0; 18117c478bd9Sstevel@tonic-gate while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?F")) != EOF) { 18127c478bd9Sstevel@tonic-gate switch (arg) { 18137c478bd9Sstevel@tonic-gate case '?': 18147c478bd9Sstevel@tonic-gate longer_usage(CMD_EXIT); 18157c478bd9Sstevel@tonic-gate return; 18167c478bd9Sstevel@tonic-gate case 'F': 18177c478bd9Sstevel@tonic-gate force_exit = TRUE; 18187c478bd9Sstevel@tonic-gate break; 18197c478bd9Sstevel@tonic-gate default: 18207c478bd9Sstevel@tonic-gate short_usage(CMD_EXIT); 18217c478bd9Sstevel@tonic-gate return; 18227c478bd9Sstevel@tonic-gate } 18237c478bd9Sstevel@tonic-gate } 18247c478bd9Sstevel@tonic-gate if (optind < cmd->cmd_argc) { 18257c478bd9Sstevel@tonic-gate short_usage(CMD_EXIT); 18267c478bd9Sstevel@tonic-gate return; 18277c478bd9Sstevel@tonic-gate } 18287c478bd9Sstevel@tonic-gate 18297c478bd9Sstevel@tonic-gate if (global_scope || force_exit) { 18307c478bd9Sstevel@tonic-gate time_to_exit = TRUE; 18317c478bd9Sstevel@tonic-gate return; 18327c478bd9Sstevel@tonic-gate } 18337c478bd9Sstevel@tonic-gate 18347c478bd9Sstevel@tonic-gate answer = ask_yesno(FALSE, "Resource incomplete; really quit"); 18357c478bd9Sstevel@tonic-gate if (answer == -1) { 18367c478bd9Sstevel@tonic-gate zerr(gettext("Resource incomplete, input " 18377c478bd9Sstevel@tonic-gate "not from terminal and -F not specified:\n%s command " 18387c478bd9Sstevel@tonic-gate "ignored, but exiting anyway."), cmd_to_str(CMD_EXIT)); 18397c478bd9Sstevel@tonic-gate exit(Z_ERR); 18407c478bd9Sstevel@tonic-gate } else if (answer == 1) { 18417c478bd9Sstevel@tonic-gate time_to_exit = TRUE; 18427c478bd9Sstevel@tonic-gate } 18437c478bd9Sstevel@tonic-gate /* (answer == 0) => just return */ 18447c478bd9Sstevel@tonic-gate } 18457c478bd9Sstevel@tonic-gate 18467c478bd9Sstevel@tonic-gate static int 18477c478bd9Sstevel@tonic-gate validate_zonepath_syntax(char *path) 18487c478bd9Sstevel@tonic-gate { 18497c478bd9Sstevel@tonic-gate if (path[0] != '/') { 18507c478bd9Sstevel@tonic-gate zerr(gettext("%s is not an absolute path."), path); 18517c478bd9Sstevel@tonic-gate return (Z_ERR); 18527c478bd9Sstevel@tonic-gate } 18537c478bd9Sstevel@tonic-gate if (strcmp(path, "/") == 0) { 18547c478bd9Sstevel@tonic-gate zerr(gettext("/ is not allowed as a %s."), 18557c478bd9Sstevel@tonic-gate pt_to_str(PT_ZONEPATH)); 18567c478bd9Sstevel@tonic-gate return (Z_ERR); 18577c478bd9Sstevel@tonic-gate } 18587c478bd9Sstevel@tonic-gate return (Z_OK); 18597c478bd9Sstevel@tonic-gate } 18607c478bd9Sstevel@tonic-gate 18617c478bd9Sstevel@tonic-gate static void 18627c478bd9Sstevel@tonic-gate add_resource(cmd_t *cmd) 18637c478bd9Sstevel@tonic-gate { 18647c478bd9Sstevel@tonic-gate int type; 1865*0209230bSgjelinek struct zone_psettab tmp_psettab; 1866*0209230bSgjelinek struct zone_mcaptab tmp_mcaptab; 1867*0209230bSgjelinek uint64_t tmp_mcap; 1868*0209230bSgjelinek char pool[MAXNAMELEN]; 18697c478bd9Sstevel@tonic-gate 18707c478bd9Sstevel@tonic-gate if ((type = cmd->cmd_res_type) == RT_UNKNOWN) { 18717c478bd9Sstevel@tonic-gate long_usage(CMD_ADD, TRUE); 18727c478bd9Sstevel@tonic-gate goto bad; 18737c478bd9Sstevel@tonic-gate } 18747c478bd9Sstevel@tonic-gate 18757c478bd9Sstevel@tonic-gate switch (type) { 18767c478bd9Sstevel@tonic-gate case RT_FS: 18777c478bd9Sstevel@tonic-gate bzero(&in_progress_fstab, sizeof (in_progress_fstab)); 18787c478bd9Sstevel@tonic-gate return; 18797c478bd9Sstevel@tonic-gate case RT_IPD: 1880087719fdSdp if (state_atleast(ZONE_STATE_INSTALLED)) { 18817c478bd9Sstevel@tonic-gate zerr(gettext("Zone %s already installed; %s %s not " 18827c478bd9Sstevel@tonic-gate "allowed."), zone, cmd_to_str(CMD_ADD), 18837c478bd9Sstevel@tonic-gate rt_to_str(RT_IPD)); 18847c478bd9Sstevel@tonic-gate goto bad; 18857c478bd9Sstevel@tonic-gate } 18867c478bd9Sstevel@tonic-gate bzero(&in_progress_ipdtab, sizeof (in_progress_ipdtab)); 18877c478bd9Sstevel@tonic-gate return; 18887c478bd9Sstevel@tonic-gate case RT_NET: 18897c478bd9Sstevel@tonic-gate bzero(&in_progress_nwiftab, sizeof (in_progress_nwiftab)); 18907c478bd9Sstevel@tonic-gate return; 18917c478bd9Sstevel@tonic-gate case RT_DEVICE: 18927c478bd9Sstevel@tonic-gate bzero(&in_progress_devtab, sizeof (in_progress_devtab)); 18937c478bd9Sstevel@tonic-gate return; 18947c478bd9Sstevel@tonic-gate case RT_RCTL: 1895*0209230bSgjelinek if (global_zone) 1896*0209230bSgjelinek zerr(gettext("WARNING: Setting a global zone resource " 1897*0209230bSgjelinek "control too low could deny\nservice " 1898*0209230bSgjelinek "to even the root user; " 1899*0209230bSgjelinek "this could render the system impossible\n" 1900*0209230bSgjelinek "to administer. Please use caution.")); 19017c478bd9Sstevel@tonic-gate bzero(&in_progress_rctltab, sizeof (in_progress_rctltab)); 19027c478bd9Sstevel@tonic-gate return; 19037c478bd9Sstevel@tonic-gate case RT_ATTR: 19047c478bd9Sstevel@tonic-gate bzero(&in_progress_attrtab, sizeof (in_progress_attrtab)); 19057c478bd9Sstevel@tonic-gate return; 1906fa9e4066Sahrens case RT_DATASET: 1907fa9e4066Sahrens bzero(&in_progress_dstab, sizeof (in_progress_dstab)); 1908fa9e4066Sahrens return; 1909*0209230bSgjelinek case RT_DCPU: 1910*0209230bSgjelinek /* Make sure there isn't already a cpu-set entry. */ 1911*0209230bSgjelinek if (zonecfg_lookup_pset(handle, &tmp_psettab) == Z_OK) { 1912*0209230bSgjelinek zerr(gettext("The %s resource already exists."), 1913*0209230bSgjelinek rt_to_str(RT_DCPU)); 1914*0209230bSgjelinek goto bad; 1915*0209230bSgjelinek } 1916*0209230bSgjelinek 1917*0209230bSgjelinek /* Make sure the pool property isn't set. */ 1918*0209230bSgjelinek if (zonecfg_get_pool(handle, pool, sizeof (pool)) == Z_OK && 1919*0209230bSgjelinek strlen(pool) > 0) { 1920*0209230bSgjelinek zerr(gettext("The %s property is already set. " 1921*0209230bSgjelinek "A persistent pool is incompatible with\nthe %s " 1922*0209230bSgjelinek "resource."), 1923*0209230bSgjelinek pt_to_str(PT_POOL), rt_to_str(RT_DCPU)); 1924*0209230bSgjelinek goto bad; 1925*0209230bSgjelinek } 1926*0209230bSgjelinek 1927*0209230bSgjelinek bzero(&in_progress_psettab, sizeof (in_progress_psettab)); 1928*0209230bSgjelinek return; 1929*0209230bSgjelinek case RT_MCAP: 1930*0209230bSgjelinek /* 1931*0209230bSgjelinek * Make sure there isn't already a mem-cap entry or max-swap 1932*0209230bSgjelinek * or max-locked rctl. 1933*0209230bSgjelinek */ 1934*0209230bSgjelinek if (zonecfg_lookup_mcap(handle, &tmp_mcaptab) == Z_OK || 1935*0209230bSgjelinek zonecfg_get_aliased_rctl(handle, ALIAS_MAXSWAP, &tmp_mcap) 1936*0209230bSgjelinek == Z_OK || 1937*0209230bSgjelinek zonecfg_get_aliased_rctl(handle, ALIAS_MAXLOCKEDMEM, 1938*0209230bSgjelinek &tmp_mcap) == Z_OK) { 1939*0209230bSgjelinek zerr(gettext("The %s resource or a related resource " 1940*0209230bSgjelinek "control already exists."), rt_to_str(RT_MCAP)); 1941*0209230bSgjelinek goto bad; 1942*0209230bSgjelinek } 1943*0209230bSgjelinek if (global_zone) 1944*0209230bSgjelinek zerr(gettext("WARNING: Setting a global zone memory " 1945*0209230bSgjelinek "cap too low could deny\nservice " 1946*0209230bSgjelinek "to even the root user; " 1947*0209230bSgjelinek "this could render the system impossible\n" 1948*0209230bSgjelinek "to administer. Please use caution.")); 1949*0209230bSgjelinek bzero(&in_progress_mcaptab, sizeof (in_progress_mcaptab)); 1950*0209230bSgjelinek return; 19517c478bd9Sstevel@tonic-gate default: 19527c478bd9Sstevel@tonic-gate zone_perror(rt_to_str(type), Z_NO_RESOURCE_TYPE, TRUE); 19537c478bd9Sstevel@tonic-gate long_usage(CMD_ADD, TRUE); 19547c478bd9Sstevel@tonic-gate usage(FALSE, HELP_RESOURCES); 19557c478bd9Sstevel@tonic-gate } 19567c478bd9Sstevel@tonic-gate bad: 19577c478bd9Sstevel@tonic-gate global_scope = TRUE; 19587c478bd9Sstevel@tonic-gate end_op = -1; 19597c478bd9Sstevel@tonic-gate } 19607c478bd9Sstevel@tonic-gate 19617c478bd9Sstevel@tonic-gate static void 19627c478bd9Sstevel@tonic-gate do_complex_rctl_val(complex_property_ptr_t cp) 19637c478bd9Sstevel@tonic-gate { 19647c478bd9Sstevel@tonic-gate struct zone_rctlvaltab *rctlvaltab; 19657c478bd9Sstevel@tonic-gate complex_property_ptr_t cx; 19667c478bd9Sstevel@tonic-gate bool seen_priv = FALSE, seen_limit = FALSE, seen_action = FALSE; 19677c478bd9Sstevel@tonic-gate rctlblk_t *rctlblk; 19687c478bd9Sstevel@tonic-gate int err; 19697c478bd9Sstevel@tonic-gate 19707c478bd9Sstevel@tonic-gate if ((rctlvaltab = alloc_rctlvaltab()) == NULL) { 19717c478bd9Sstevel@tonic-gate zone_perror(zone, Z_NOMEM, TRUE); 19727c478bd9Sstevel@tonic-gate exit(Z_ERR); 19737c478bd9Sstevel@tonic-gate } 19747c478bd9Sstevel@tonic-gate for (cx = cp; cx != NULL; cx = cx->cp_next) { 19757c478bd9Sstevel@tonic-gate switch (cx->cp_type) { 19767c478bd9Sstevel@tonic-gate case PT_PRIV: 19777c478bd9Sstevel@tonic-gate if (seen_priv) { 19787c478bd9Sstevel@tonic-gate zerr(gettext("%s already specified"), 19797c478bd9Sstevel@tonic-gate pt_to_str(PT_PRIV)); 19807c478bd9Sstevel@tonic-gate goto bad; 19817c478bd9Sstevel@tonic-gate } 19827c478bd9Sstevel@tonic-gate (void) strlcpy(rctlvaltab->zone_rctlval_priv, 19837c478bd9Sstevel@tonic-gate cx->cp_value, 19847c478bd9Sstevel@tonic-gate sizeof (rctlvaltab->zone_rctlval_priv)); 19857c478bd9Sstevel@tonic-gate seen_priv = TRUE; 19867c478bd9Sstevel@tonic-gate break; 19877c478bd9Sstevel@tonic-gate case PT_LIMIT: 19887c478bd9Sstevel@tonic-gate if (seen_limit) { 19897c478bd9Sstevel@tonic-gate zerr(gettext("%s already specified"), 19907c478bd9Sstevel@tonic-gate pt_to_str(PT_LIMIT)); 19917c478bd9Sstevel@tonic-gate goto bad; 19927c478bd9Sstevel@tonic-gate } 19937c478bd9Sstevel@tonic-gate (void) strlcpy(rctlvaltab->zone_rctlval_limit, 19947c478bd9Sstevel@tonic-gate cx->cp_value, 19957c478bd9Sstevel@tonic-gate sizeof (rctlvaltab->zone_rctlval_limit)); 19967c478bd9Sstevel@tonic-gate seen_limit = TRUE; 19977c478bd9Sstevel@tonic-gate break; 19987c478bd9Sstevel@tonic-gate case PT_ACTION: 19997c478bd9Sstevel@tonic-gate if (seen_action) { 20007c478bd9Sstevel@tonic-gate zerr(gettext("%s already specified"), 20017c478bd9Sstevel@tonic-gate pt_to_str(PT_ACTION)); 20027c478bd9Sstevel@tonic-gate goto bad; 20037c478bd9Sstevel@tonic-gate } 20047c478bd9Sstevel@tonic-gate (void) strlcpy(rctlvaltab->zone_rctlval_action, 20057c478bd9Sstevel@tonic-gate cx->cp_value, 20067c478bd9Sstevel@tonic-gate sizeof (rctlvaltab->zone_rctlval_action)); 20077c478bd9Sstevel@tonic-gate seen_action = TRUE; 20087c478bd9Sstevel@tonic-gate break; 20097c478bd9Sstevel@tonic-gate default: 20107c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(PT_VALUE), 20117c478bd9Sstevel@tonic-gate Z_NO_PROPERTY_TYPE, TRUE); 20127c478bd9Sstevel@tonic-gate long_usage(CMD_ADD, TRUE); 20137c478bd9Sstevel@tonic-gate usage(FALSE, HELP_PROPS); 20147c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctlvaltab); 20157c478bd9Sstevel@tonic-gate return; 20167c478bd9Sstevel@tonic-gate } 20177c478bd9Sstevel@tonic-gate } 20187c478bd9Sstevel@tonic-gate if (!seen_priv) 20197c478bd9Sstevel@tonic-gate zerr(gettext("%s not specified"), pt_to_str(PT_PRIV)); 20207c478bd9Sstevel@tonic-gate if (!seen_limit) 20217c478bd9Sstevel@tonic-gate zerr(gettext("%s not specified"), pt_to_str(PT_LIMIT)); 20227c478bd9Sstevel@tonic-gate if (!seen_action) 20237c478bd9Sstevel@tonic-gate zerr(gettext("%s not specified"), pt_to_str(PT_ACTION)); 20247c478bd9Sstevel@tonic-gate if (!seen_priv || !seen_limit || !seen_action) 20257c478bd9Sstevel@tonic-gate goto bad; 20267c478bd9Sstevel@tonic-gate rctlvaltab->zone_rctlval_next = NULL; 20277c478bd9Sstevel@tonic-gate rctlblk = alloca(rctlblk_size()); 20287c478bd9Sstevel@tonic-gate /* 20297c478bd9Sstevel@tonic-gate * Make sure the rctl value looks roughly correct; we won't know if 20307c478bd9Sstevel@tonic-gate * it's truly OK until we verify the configuration on the target 20317c478bd9Sstevel@tonic-gate * system. 20327c478bd9Sstevel@tonic-gate */ 20337c478bd9Sstevel@tonic-gate if (zonecfg_construct_rctlblk(rctlvaltab, rctlblk) != Z_OK || 20347c478bd9Sstevel@tonic-gate !zonecfg_valid_rctlblk(rctlblk)) { 20357c478bd9Sstevel@tonic-gate zerr(gettext("Invalid %s %s specification"), rt_to_str(RT_RCTL), 20367c478bd9Sstevel@tonic-gate pt_to_str(PT_VALUE)); 20377c478bd9Sstevel@tonic-gate goto bad; 20387c478bd9Sstevel@tonic-gate } 20397c478bd9Sstevel@tonic-gate err = zonecfg_add_rctl_value(&in_progress_rctltab, rctlvaltab); 20407c478bd9Sstevel@tonic-gate if (err != Z_OK) 20417c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(PT_VALUE), err, TRUE); 20427c478bd9Sstevel@tonic-gate return; 20437c478bd9Sstevel@tonic-gate 20447c478bd9Sstevel@tonic-gate bad: 20457c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctlvaltab); 20467c478bd9Sstevel@tonic-gate } 20477c478bd9Sstevel@tonic-gate 20487c478bd9Sstevel@tonic-gate static void 20497c478bd9Sstevel@tonic-gate add_property(cmd_t *cmd) 20507c478bd9Sstevel@tonic-gate { 20517c478bd9Sstevel@tonic-gate char *prop_id; 20527c478bd9Sstevel@tonic-gate int err, res_type, prop_type; 20537c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 20547c478bd9Sstevel@tonic-gate list_property_ptr_t l; 20557c478bd9Sstevel@tonic-gate 20567c478bd9Sstevel@tonic-gate res_type = resource_scope; 20577c478bd9Sstevel@tonic-gate prop_type = cmd->cmd_prop_name[0]; 20587c478bd9Sstevel@tonic-gate if (res_type == RT_UNKNOWN || prop_type == PT_UNKNOWN) { 20597c478bd9Sstevel@tonic-gate long_usage(CMD_ADD, TRUE); 20607c478bd9Sstevel@tonic-gate return; 20617c478bd9Sstevel@tonic-gate } 20627c478bd9Sstevel@tonic-gate 20637c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs != 1) { 20647c478bd9Sstevel@tonic-gate long_usage(CMD_ADD, TRUE); 20657c478bd9Sstevel@tonic-gate return; 20667c478bd9Sstevel@tonic-gate } 20677c478bd9Sstevel@tonic-gate 20687c478bd9Sstevel@tonic-gate if (initialize(TRUE) != Z_OK) 20697c478bd9Sstevel@tonic-gate return; 20707c478bd9Sstevel@tonic-gate 20717c478bd9Sstevel@tonic-gate switch (res_type) { 20727c478bd9Sstevel@tonic-gate case RT_FS: 20737c478bd9Sstevel@tonic-gate if (prop_type != PT_OPTIONS) { 20747c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 20757c478bd9Sstevel@tonic-gate TRUE); 20767c478bd9Sstevel@tonic-gate long_usage(CMD_ADD, TRUE); 20777c478bd9Sstevel@tonic-gate usage(FALSE, HELP_PROPS); 20787c478bd9Sstevel@tonic-gate return; 20797c478bd9Sstevel@tonic-gate } 20807c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[0]; 20817c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE && 20827c478bd9Sstevel@tonic-gate pp->pv_type != PROP_VAL_LIST) { 20837c478bd9Sstevel@tonic-gate zerr(gettext("A %s or %s value was expected here."), 20847c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_SIMPLE), 20857c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_LIST)); 20867c478bd9Sstevel@tonic-gate saw_error = TRUE; 20877c478bd9Sstevel@tonic-gate return; 20887c478bd9Sstevel@tonic-gate } 20897c478bd9Sstevel@tonic-gate if (pp->pv_type == PROP_VAL_SIMPLE) { 20907c478bd9Sstevel@tonic-gate if (pp->pv_simple == NULL) { 20917c478bd9Sstevel@tonic-gate long_usage(CMD_ADD, TRUE); 20927c478bd9Sstevel@tonic-gate return; 20937c478bd9Sstevel@tonic-gate } 20947c478bd9Sstevel@tonic-gate prop_id = pp->pv_simple; 20957c478bd9Sstevel@tonic-gate err = zonecfg_add_fs_option(&in_progress_fstab, 20967c478bd9Sstevel@tonic-gate prop_id); 20977c478bd9Sstevel@tonic-gate if (err != Z_OK) 20987c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), err, TRUE); 20997c478bd9Sstevel@tonic-gate } else { 21007c478bd9Sstevel@tonic-gate list_property_ptr_t list; 21017c478bd9Sstevel@tonic-gate 21027c478bd9Sstevel@tonic-gate for (list = pp->pv_list; list != NULL; 21037c478bd9Sstevel@tonic-gate list = list->lp_next) { 21047c478bd9Sstevel@tonic-gate prop_id = list->lp_simple; 21057c478bd9Sstevel@tonic-gate if (prop_id == NULL) 21067c478bd9Sstevel@tonic-gate break; 21077c478bd9Sstevel@tonic-gate err = zonecfg_add_fs_option( 21087c478bd9Sstevel@tonic-gate &in_progress_fstab, prop_id); 21097c478bd9Sstevel@tonic-gate if (err != Z_OK) 21107c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), err, 21117c478bd9Sstevel@tonic-gate TRUE); 21127c478bd9Sstevel@tonic-gate } 21137c478bd9Sstevel@tonic-gate } 21147c478bd9Sstevel@tonic-gate return; 21157c478bd9Sstevel@tonic-gate case RT_RCTL: 21167c478bd9Sstevel@tonic-gate if (prop_type != PT_VALUE) { 21177c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 21187c478bd9Sstevel@tonic-gate TRUE); 21197c478bd9Sstevel@tonic-gate long_usage(CMD_ADD, TRUE); 21207c478bd9Sstevel@tonic-gate usage(FALSE, HELP_PROPS); 21217c478bd9Sstevel@tonic-gate return; 21227c478bd9Sstevel@tonic-gate } 21237c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[0]; 21247c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_COMPLEX && 21257c478bd9Sstevel@tonic-gate pp->pv_type != PROP_VAL_LIST) { 21267c478bd9Sstevel@tonic-gate zerr(gettext("A %s or %s value was expected here."), 21277c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_COMPLEX), 21287c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_LIST)); 21297c478bd9Sstevel@tonic-gate saw_error = TRUE; 21307c478bd9Sstevel@tonic-gate return; 21317c478bd9Sstevel@tonic-gate } 21327c478bd9Sstevel@tonic-gate if (pp->pv_type == PROP_VAL_COMPLEX) { 21337c478bd9Sstevel@tonic-gate do_complex_rctl_val(pp->pv_complex); 21347c478bd9Sstevel@tonic-gate return; 21357c478bd9Sstevel@tonic-gate } 21367c478bd9Sstevel@tonic-gate for (l = pp->pv_list; l != NULL; l = l->lp_next) 21377c478bd9Sstevel@tonic-gate do_complex_rctl_val(l->lp_complex); 21387c478bd9Sstevel@tonic-gate return; 21397c478bd9Sstevel@tonic-gate default: 21407c478bd9Sstevel@tonic-gate zone_perror(rt_to_str(res_type), Z_NO_RESOURCE_TYPE, TRUE); 21417c478bd9Sstevel@tonic-gate long_usage(CMD_ADD, TRUE); 21427c478bd9Sstevel@tonic-gate usage(FALSE, HELP_RESOURCES); 21437c478bd9Sstevel@tonic-gate return; 21447c478bd9Sstevel@tonic-gate } 21457c478bd9Sstevel@tonic-gate } 21467c478bd9Sstevel@tonic-gate 2147*0209230bSgjelinek static boolean_t 2148*0209230bSgjelinek gz_invalid_resource(int type) 2149*0209230bSgjelinek { 2150*0209230bSgjelinek return (global_zone && (type == RT_FS || type == RT_IPD || 2151*0209230bSgjelinek type == RT_NET || type == RT_DEVICE || type == RT_ATTR || 2152*0209230bSgjelinek type == RT_DATASET)); 2153*0209230bSgjelinek } 2154*0209230bSgjelinek 2155*0209230bSgjelinek static boolean_t 2156*0209230bSgjelinek gz_invalid_rt_property(int type) 2157*0209230bSgjelinek { 2158*0209230bSgjelinek return (global_zone && (type == RT_ZONENAME || type == RT_ZONEPATH || 2159*0209230bSgjelinek type == RT_AUTOBOOT || type == RT_LIMITPRIV || 2160*0209230bSgjelinek type == RT_BOOTARGS || type == RT_BRAND || type == RT_SCHED)); 2161*0209230bSgjelinek } 2162*0209230bSgjelinek 2163*0209230bSgjelinek static boolean_t 2164*0209230bSgjelinek gz_invalid_property(int type) 2165*0209230bSgjelinek { 2166*0209230bSgjelinek return (global_zone && (type == PT_ZONENAME || type == PT_ZONEPATH || 2167*0209230bSgjelinek type == PT_AUTOBOOT || type == PT_LIMITPRIV || 2168*0209230bSgjelinek type == PT_BOOTARGS || type == PT_BRAND || type == PT_SCHED)); 2169*0209230bSgjelinek } 2170*0209230bSgjelinek 21717c478bd9Sstevel@tonic-gate void 21727c478bd9Sstevel@tonic-gate add_func(cmd_t *cmd) 21737c478bd9Sstevel@tonic-gate { 21747c478bd9Sstevel@tonic-gate int arg; 21757c478bd9Sstevel@tonic-gate 21767c478bd9Sstevel@tonic-gate assert(cmd != NULL); 21777c478bd9Sstevel@tonic-gate 21787c478bd9Sstevel@tonic-gate optind = 0; 21797c478bd9Sstevel@tonic-gate if ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?")) != EOF) { 21807c478bd9Sstevel@tonic-gate switch (arg) { 21817c478bd9Sstevel@tonic-gate case '?': 21827c478bd9Sstevel@tonic-gate longer_usage(CMD_ADD); 21837c478bd9Sstevel@tonic-gate return; 21847c478bd9Sstevel@tonic-gate default: 21857c478bd9Sstevel@tonic-gate short_usage(CMD_ADD); 21867c478bd9Sstevel@tonic-gate return; 21877c478bd9Sstevel@tonic-gate } 21887c478bd9Sstevel@tonic-gate } 21897c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 21907c478bd9Sstevel@tonic-gate short_usage(CMD_ADD); 21917c478bd9Sstevel@tonic-gate return; 21927c478bd9Sstevel@tonic-gate } 21937c478bd9Sstevel@tonic-gate 21947c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_ADD)) 21957c478bd9Sstevel@tonic-gate return; 21967c478bd9Sstevel@tonic-gate 21977c478bd9Sstevel@tonic-gate if (initialize(TRUE) != Z_OK) 21987c478bd9Sstevel@tonic-gate return; 21997c478bd9Sstevel@tonic-gate if (global_scope) { 2200*0209230bSgjelinek if (gz_invalid_resource(cmd->cmd_res_type)) { 2201*0209230bSgjelinek zerr(gettext("Cannot add a %s resource to the " 2202*0209230bSgjelinek "global zone."), rt_to_str(cmd->cmd_res_type)); 2203*0209230bSgjelinek saw_error = TRUE; 2204*0209230bSgjelinek return; 2205*0209230bSgjelinek } 2206*0209230bSgjelinek 22077c478bd9Sstevel@tonic-gate global_scope = FALSE; 22087c478bd9Sstevel@tonic-gate resource_scope = cmd->cmd_res_type; 22097c478bd9Sstevel@tonic-gate end_op = CMD_ADD; 22107c478bd9Sstevel@tonic-gate add_resource(cmd); 22117c478bd9Sstevel@tonic-gate } else 22127c478bd9Sstevel@tonic-gate add_property(cmd); 22137c478bd9Sstevel@tonic-gate } 22147c478bd9Sstevel@tonic-gate 2215087719fdSdp /* 2216087719fdSdp * This routine has an unusual implementation, because it tries very 2217087719fdSdp * hard to succeed in the face of a variety of failure modes. 2218087719fdSdp * The most common and most vexing occurs when the index file and 2219087719fdSdp * the /etc/zones/<zonename.xml> file are not both present. In 2220087719fdSdp * this case, delete must eradicate as much of the zone state as is left 2221087719fdSdp * so that the user can later create a new zone with the same name. 2222087719fdSdp */ 22237c478bd9Sstevel@tonic-gate void 22247c478bd9Sstevel@tonic-gate delete_func(cmd_t *cmd) 22257c478bd9Sstevel@tonic-gate { 22267c478bd9Sstevel@tonic-gate int err, arg, answer; 22277c478bd9Sstevel@tonic-gate char line[ZONENAME_MAX + 128]; /* enough to ask a question */ 22287c478bd9Sstevel@tonic-gate bool force = FALSE; 22297c478bd9Sstevel@tonic-gate 22307c478bd9Sstevel@tonic-gate optind = 0; 22317c478bd9Sstevel@tonic-gate while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?F")) != EOF) { 22327c478bd9Sstevel@tonic-gate switch (arg) { 22337c478bd9Sstevel@tonic-gate case '?': 22347c478bd9Sstevel@tonic-gate longer_usage(CMD_DELETE); 22357c478bd9Sstevel@tonic-gate return; 22367c478bd9Sstevel@tonic-gate case 'F': 22377c478bd9Sstevel@tonic-gate force = TRUE; 22387c478bd9Sstevel@tonic-gate break; 22397c478bd9Sstevel@tonic-gate default: 22407c478bd9Sstevel@tonic-gate short_usage(CMD_DELETE); 22417c478bd9Sstevel@tonic-gate return; 22427c478bd9Sstevel@tonic-gate } 22437c478bd9Sstevel@tonic-gate } 22447c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 22457c478bd9Sstevel@tonic-gate short_usage(CMD_DELETE); 22467c478bd9Sstevel@tonic-gate return; 22477c478bd9Sstevel@tonic-gate } 22487c478bd9Sstevel@tonic-gate 22497c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_DELETE)) 22507c478bd9Sstevel@tonic-gate return; 22517c478bd9Sstevel@tonic-gate 22527c478bd9Sstevel@tonic-gate if (!force) { 2253087719fdSdp /* 2254087719fdSdp * Initialize sets up the global called "handle" and warns the 2255087719fdSdp * user if the zone is not configured. In force mode, we don't 2256087719fdSdp * trust that evaluation, and hence skip it. (We don't need the 2257087719fdSdp * handle to be loaded anyway, since zonecfg_destroy is done by 2258087719fdSdp * zonename). However, we also have to take care to emulate the 2259087719fdSdp * messages spit out by initialize; see below. 2260087719fdSdp */ 2261087719fdSdp if (initialize(TRUE) != Z_OK) 2262087719fdSdp return; 2263087719fdSdp 22647c478bd9Sstevel@tonic-gate (void) snprintf(line, sizeof (line), 22657c478bd9Sstevel@tonic-gate gettext("Are you sure you want to delete zone %s"), zone); 22667c478bd9Sstevel@tonic-gate if ((answer = ask_yesno(FALSE, line)) == -1) { 2267087719fdSdp zerr(gettext("Input not from terminal and -F not " 2268087719fdSdp "specified:\n%s command ignored, exiting."), 2269087719fdSdp cmd_to_str(CMD_DELETE)); 22707c478bd9Sstevel@tonic-gate exit(Z_ERR); 22717c478bd9Sstevel@tonic-gate } 22727c478bd9Sstevel@tonic-gate if (answer != 1) 22737c478bd9Sstevel@tonic-gate return; 22747c478bd9Sstevel@tonic-gate } 22757c478bd9Sstevel@tonic-gate 2276087719fdSdp if ((err = zonecfg_destroy(zone, force)) != Z_OK) { 2277087719fdSdp if ((err == Z_BAD_ZONE_STATE) && !force) { 2278087719fdSdp zerr(gettext("Zone %s not in %s state; %s not " 2279087719fdSdp "allowed. Use -F to force %s."), 2280087719fdSdp zone, zone_state_str(ZONE_STATE_CONFIGURED), 2281087719fdSdp cmd_to_str(CMD_DELETE), cmd_to_str(CMD_DELETE)); 2282087719fdSdp } else { 2283087719fdSdp zone_perror(zone, err, TRUE); 2284087719fdSdp } 22857c478bd9Sstevel@tonic-gate } 22867c478bd9Sstevel@tonic-gate need_to_commit = FALSE; 2287087719fdSdp 2288087719fdSdp /* 2289087719fdSdp * Emulate initialize's messaging; if there wasn't a valid handle to 2290087719fdSdp * begin with, then user had typed delete (or delete -F) multiple 2291087719fdSdp * times. So we emit a message. 2292087719fdSdp * 2293087719fdSdp * We only do this in the 'force' case because normally, initialize() 2294087719fdSdp * takes care of this for us. 2295087719fdSdp */ 2296087719fdSdp if (force && zonecfg_check_handle(handle) != Z_OK && interactive_mode) 2297087719fdSdp (void) printf(gettext("Use '%s' to begin " 2298087719fdSdp "configuring a new zone.\n"), cmd_to_str(CMD_CREATE)); 22997c478bd9Sstevel@tonic-gate 23007c478bd9Sstevel@tonic-gate /* 23017c478bd9Sstevel@tonic-gate * Time for a new handle: finish the old one off first 23027c478bd9Sstevel@tonic-gate * then get a new one properly to avoid leaks. 23037c478bd9Sstevel@tonic-gate */ 2304087719fdSdp if (got_handle) { 2305087719fdSdp zonecfg_fini_handle(handle); 2306087719fdSdp if ((handle = zonecfg_init_handle()) == NULL) { 2307087719fdSdp zone_perror(execname, Z_NOMEM, TRUE); 2308087719fdSdp exit(Z_ERR); 2309087719fdSdp } 2310087719fdSdp if ((err = zonecfg_get_handle(zone, handle)) != Z_OK) { 2311087719fdSdp /* If there was no zone before, that's OK */ 2312087719fdSdp if (err != Z_NO_ZONE) 2313087719fdSdp zone_perror(zone, err, TRUE); 2314087719fdSdp got_handle = FALSE; 2315087719fdSdp } 23167c478bd9Sstevel@tonic-gate } 23177c478bd9Sstevel@tonic-gate } 23187c478bd9Sstevel@tonic-gate 23197c478bd9Sstevel@tonic-gate static int 23207c478bd9Sstevel@tonic-gate fill_in_fstab(cmd_t *cmd, struct zone_fstab *fstab, bool fill_in_only) 23217c478bd9Sstevel@tonic-gate { 23227c478bd9Sstevel@tonic-gate int err, i; 23237c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 23247c478bd9Sstevel@tonic-gate 23257c478bd9Sstevel@tonic-gate if ((err = initialize(TRUE)) != Z_OK) 23267c478bd9Sstevel@tonic-gate return (err); 23277c478bd9Sstevel@tonic-gate 2328e193d1e6Svp bzero(fstab, sizeof (*fstab)); 23297c478bd9Sstevel@tonic-gate for (i = 0; i < cmd->cmd_prop_nv_pairs; i++) { 23307c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[i]; 23317c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE || pp->pv_simple == NULL) { 23327c478bd9Sstevel@tonic-gate zerr(gettext("A simple value was expected here.")); 23337c478bd9Sstevel@tonic-gate saw_error = TRUE; 23347c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 23357c478bd9Sstevel@tonic-gate } 23367c478bd9Sstevel@tonic-gate switch (cmd->cmd_prop_name[i]) { 23377c478bd9Sstevel@tonic-gate case PT_DIR: 23387c478bd9Sstevel@tonic-gate (void) strlcpy(fstab->zone_fs_dir, pp->pv_simple, 23397c478bd9Sstevel@tonic-gate sizeof (fstab->zone_fs_dir)); 23407c478bd9Sstevel@tonic-gate break; 23417c478bd9Sstevel@tonic-gate case PT_SPECIAL: 23427c478bd9Sstevel@tonic-gate (void) strlcpy(fstab->zone_fs_special, pp->pv_simple, 23437c478bd9Sstevel@tonic-gate sizeof (fstab->zone_fs_special)); 23447c478bd9Sstevel@tonic-gate break; 23457c478bd9Sstevel@tonic-gate case PT_RAW: 23467c478bd9Sstevel@tonic-gate (void) strlcpy(fstab->zone_fs_raw, pp->pv_simple, 23477c478bd9Sstevel@tonic-gate sizeof (fstab->zone_fs_raw)); 23487c478bd9Sstevel@tonic-gate break; 23497c478bd9Sstevel@tonic-gate case PT_TYPE: 23507c478bd9Sstevel@tonic-gate (void) strlcpy(fstab->zone_fs_type, pp->pv_simple, 23517c478bd9Sstevel@tonic-gate sizeof (fstab->zone_fs_type)); 23527c478bd9Sstevel@tonic-gate break; 23537c478bd9Sstevel@tonic-gate default: 23547c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(cmd->cmd_prop_name[i]), 23557c478bd9Sstevel@tonic-gate Z_NO_PROPERTY_TYPE, TRUE); 23567c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 23577c478bd9Sstevel@tonic-gate } 23587c478bd9Sstevel@tonic-gate } 23597c478bd9Sstevel@tonic-gate if (fill_in_only) 23607c478bd9Sstevel@tonic-gate return (Z_OK); 23617c478bd9Sstevel@tonic-gate return (zonecfg_lookup_filesystem(handle, fstab)); 23627c478bd9Sstevel@tonic-gate } 23637c478bd9Sstevel@tonic-gate 23647c478bd9Sstevel@tonic-gate static int 23657c478bd9Sstevel@tonic-gate fill_in_ipdtab(cmd_t *cmd, struct zone_fstab *ipdtab, bool fill_in_only) 23667c478bd9Sstevel@tonic-gate { 23677c478bd9Sstevel@tonic-gate int err, i; 23687c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 23697c478bd9Sstevel@tonic-gate 23707c478bd9Sstevel@tonic-gate if ((err = initialize(TRUE)) != Z_OK) 23717c478bd9Sstevel@tonic-gate return (err); 23727c478bd9Sstevel@tonic-gate 2373e193d1e6Svp bzero(ipdtab, sizeof (*ipdtab)); 23747c478bd9Sstevel@tonic-gate for (i = 0; i < cmd->cmd_prop_nv_pairs; i++) { 23757c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[i]; 23767c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE || pp->pv_simple == NULL) { 23777c478bd9Sstevel@tonic-gate zerr(gettext("A simple value was expected here.")); 23787c478bd9Sstevel@tonic-gate saw_error = TRUE; 23797c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 23807c478bd9Sstevel@tonic-gate } 23817c478bd9Sstevel@tonic-gate switch (cmd->cmd_prop_name[i]) { 23827c478bd9Sstevel@tonic-gate case PT_DIR: 23837c478bd9Sstevel@tonic-gate (void) strlcpy(ipdtab->zone_fs_dir, pp->pv_simple, 23847c478bd9Sstevel@tonic-gate sizeof (ipdtab->zone_fs_dir)); 23857c478bd9Sstevel@tonic-gate break; 23867c478bd9Sstevel@tonic-gate default: 23877c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(cmd->cmd_prop_name[i]), 23887c478bd9Sstevel@tonic-gate Z_NO_PROPERTY_TYPE, TRUE); 23897c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 23907c478bd9Sstevel@tonic-gate } 23917c478bd9Sstevel@tonic-gate } 23927c478bd9Sstevel@tonic-gate if (fill_in_only) 23937c478bd9Sstevel@tonic-gate return (Z_OK); 23947c478bd9Sstevel@tonic-gate return (zonecfg_lookup_ipd(handle, ipdtab)); 23957c478bd9Sstevel@tonic-gate } 23967c478bd9Sstevel@tonic-gate 23977c478bd9Sstevel@tonic-gate static int 23987c478bd9Sstevel@tonic-gate fill_in_nwiftab(cmd_t *cmd, struct zone_nwiftab *nwiftab, bool fill_in_only) 23997c478bd9Sstevel@tonic-gate { 24007c478bd9Sstevel@tonic-gate int err, i; 24017c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 24027c478bd9Sstevel@tonic-gate 24037c478bd9Sstevel@tonic-gate if ((err = initialize(TRUE)) != Z_OK) 24047c478bd9Sstevel@tonic-gate return (err); 24057c478bd9Sstevel@tonic-gate 2406e193d1e6Svp bzero(nwiftab, sizeof (*nwiftab)); 24077c478bd9Sstevel@tonic-gate for (i = 0; i < cmd->cmd_prop_nv_pairs; i++) { 24087c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[i]; 24097c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE || pp->pv_simple == NULL) { 24107c478bd9Sstevel@tonic-gate zerr(gettext("A simple value was expected here.")); 24117c478bd9Sstevel@tonic-gate saw_error = TRUE; 24127c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 24137c478bd9Sstevel@tonic-gate } 24147c478bd9Sstevel@tonic-gate switch (cmd->cmd_prop_name[i]) { 24157c478bd9Sstevel@tonic-gate case PT_ADDRESS: 24167c478bd9Sstevel@tonic-gate (void) strlcpy(nwiftab->zone_nwif_address, 24177c478bd9Sstevel@tonic-gate pp->pv_simple, sizeof (nwiftab->zone_nwif_address)); 24187c478bd9Sstevel@tonic-gate break; 24197c478bd9Sstevel@tonic-gate case PT_PHYSICAL: 24207c478bd9Sstevel@tonic-gate (void) strlcpy(nwiftab->zone_nwif_physical, 24217c478bd9Sstevel@tonic-gate pp->pv_simple, 24227c478bd9Sstevel@tonic-gate sizeof (nwiftab->zone_nwif_physical)); 24237c478bd9Sstevel@tonic-gate break; 24247c478bd9Sstevel@tonic-gate default: 24257c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(cmd->cmd_prop_name[i]), 24267c478bd9Sstevel@tonic-gate Z_NO_PROPERTY_TYPE, TRUE); 24277c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 24287c478bd9Sstevel@tonic-gate } 24297c478bd9Sstevel@tonic-gate } 24307c478bd9Sstevel@tonic-gate if (fill_in_only) 24317c478bd9Sstevel@tonic-gate return (Z_OK); 24327c478bd9Sstevel@tonic-gate err = zonecfg_lookup_nwif(handle, nwiftab); 24337c478bd9Sstevel@tonic-gate return (err); 24347c478bd9Sstevel@tonic-gate } 24357c478bd9Sstevel@tonic-gate 24367c478bd9Sstevel@tonic-gate static int 24377c478bd9Sstevel@tonic-gate fill_in_devtab(cmd_t *cmd, struct zone_devtab *devtab, bool fill_in_only) 24387c478bd9Sstevel@tonic-gate { 24397c478bd9Sstevel@tonic-gate int err, i; 24407c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 24417c478bd9Sstevel@tonic-gate 24427c478bd9Sstevel@tonic-gate if ((err = initialize(TRUE)) != Z_OK) 24437c478bd9Sstevel@tonic-gate return (err); 24447c478bd9Sstevel@tonic-gate 2445e193d1e6Svp bzero(devtab, sizeof (*devtab)); 24467c478bd9Sstevel@tonic-gate for (i = 0; i < cmd->cmd_prop_nv_pairs; i++) { 24477c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[i]; 24487c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE || pp->pv_simple == NULL) { 24497c478bd9Sstevel@tonic-gate zerr(gettext("A simple value was expected here.")); 24507c478bd9Sstevel@tonic-gate saw_error = TRUE; 24517c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 24527c478bd9Sstevel@tonic-gate } 24537c478bd9Sstevel@tonic-gate switch (cmd->cmd_prop_name[i]) { 24547c478bd9Sstevel@tonic-gate case PT_MATCH: 24557c478bd9Sstevel@tonic-gate (void) strlcpy(devtab->zone_dev_match, pp->pv_simple, 24567c478bd9Sstevel@tonic-gate sizeof (devtab->zone_dev_match)); 24577c478bd9Sstevel@tonic-gate break; 24587c478bd9Sstevel@tonic-gate default: 24597c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(cmd->cmd_prop_name[i]), 24607c478bd9Sstevel@tonic-gate Z_NO_PROPERTY_TYPE, TRUE); 24617c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 24627c478bd9Sstevel@tonic-gate } 24637c478bd9Sstevel@tonic-gate } 24647c478bd9Sstevel@tonic-gate if (fill_in_only) 24657c478bd9Sstevel@tonic-gate return (Z_OK); 24667c478bd9Sstevel@tonic-gate err = zonecfg_lookup_dev(handle, devtab); 24677c478bd9Sstevel@tonic-gate return (err); 24687c478bd9Sstevel@tonic-gate } 24697c478bd9Sstevel@tonic-gate 24707c478bd9Sstevel@tonic-gate static int 24717c478bd9Sstevel@tonic-gate fill_in_rctltab(cmd_t *cmd, struct zone_rctltab *rctltab, bool fill_in_only) 24727c478bd9Sstevel@tonic-gate { 24737c478bd9Sstevel@tonic-gate int err, i; 24747c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 24757c478bd9Sstevel@tonic-gate 24767c478bd9Sstevel@tonic-gate if ((err = initialize(TRUE)) != Z_OK) 24777c478bd9Sstevel@tonic-gate return (err); 24787c478bd9Sstevel@tonic-gate 2479e193d1e6Svp bzero(rctltab, sizeof (*rctltab)); 24807c478bd9Sstevel@tonic-gate for (i = 0; i < cmd->cmd_prop_nv_pairs; i++) { 24817c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[i]; 24827c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE || pp->pv_simple == NULL) { 24837c478bd9Sstevel@tonic-gate zerr(gettext("A simple value was expected here.")); 24847c478bd9Sstevel@tonic-gate saw_error = TRUE; 24857c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 24867c478bd9Sstevel@tonic-gate } 24877c478bd9Sstevel@tonic-gate switch (cmd->cmd_prop_name[i]) { 24887c478bd9Sstevel@tonic-gate case PT_NAME: 24897c478bd9Sstevel@tonic-gate (void) strlcpy(rctltab->zone_rctl_name, pp->pv_simple, 24907c478bd9Sstevel@tonic-gate sizeof (rctltab->zone_rctl_name)); 24917c478bd9Sstevel@tonic-gate break; 24927c478bd9Sstevel@tonic-gate default: 24937c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(cmd->cmd_prop_name[i]), 24947c478bd9Sstevel@tonic-gate Z_NO_PROPERTY_TYPE, TRUE); 24957c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 24967c478bd9Sstevel@tonic-gate } 24977c478bd9Sstevel@tonic-gate } 24987c478bd9Sstevel@tonic-gate if (fill_in_only) 24997c478bd9Sstevel@tonic-gate return (Z_OK); 25007c478bd9Sstevel@tonic-gate err = zonecfg_lookup_rctl(handle, rctltab); 25017c478bd9Sstevel@tonic-gate return (err); 25027c478bd9Sstevel@tonic-gate } 25037c478bd9Sstevel@tonic-gate 25047c478bd9Sstevel@tonic-gate static int 25057c478bd9Sstevel@tonic-gate fill_in_attrtab(cmd_t *cmd, struct zone_attrtab *attrtab, bool fill_in_only) 25067c478bd9Sstevel@tonic-gate { 25077c478bd9Sstevel@tonic-gate int err, i; 25087c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 25097c478bd9Sstevel@tonic-gate 25107c478bd9Sstevel@tonic-gate if ((err = initialize(TRUE)) != Z_OK) 25117c478bd9Sstevel@tonic-gate return (err); 25127c478bd9Sstevel@tonic-gate 2513e193d1e6Svp bzero(attrtab, sizeof (*attrtab)); 25147c478bd9Sstevel@tonic-gate for (i = 0; i < cmd->cmd_prop_nv_pairs; i++) { 25157c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[i]; 25167c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE || pp->pv_simple == NULL) { 25177c478bd9Sstevel@tonic-gate zerr(gettext("A simple value was expected here.")); 25187c478bd9Sstevel@tonic-gate saw_error = TRUE; 25197c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 25207c478bd9Sstevel@tonic-gate } 25217c478bd9Sstevel@tonic-gate switch (cmd->cmd_prop_name[i]) { 25227c478bd9Sstevel@tonic-gate case PT_NAME: 25237c478bd9Sstevel@tonic-gate (void) strlcpy(attrtab->zone_attr_name, pp->pv_simple, 25247c478bd9Sstevel@tonic-gate sizeof (attrtab->zone_attr_name)); 25257c478bd9Sstevel@tonic-gate break; 25267c478bd9Sstevel@tonic-gate case PT_TYPE: 25277c478bd9Sstevel@tonic-gate (void) strlcpy(attrtab->zone_attr_type, pp->pv_simple, 25287c478bd9Sstevel@tonic-gate sizeof (attrtab->zone_attr_type)); 25297c478bd9Sstevel@tonic-gate break; 25307c478bd9Sstevel@tonic-gate case PT_VALUE: 25317c478bd9Sstevel@tonic-gate (void) strlcpy(attrtab->zone_attr_value, pp->pv_simple, 25327c478bd9Sstevel@tonic-gate sizeof (attrtab->zone_attr_value)); 25337c478bd9Sstevel@tonic-gate break; 25347c478bd9Sstevel@tonic-gate default: 25357c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(cmd->cmd_prop_name[i]), 25367c478bd9Sstevel@tonic-gate Z_NO_PROPERTY_TYPE, TRUE); 25377c478bd9Sstevel@tonic-gate return (Z_INSUFFICIENT_SPEC); 25387c478bd9Sstevel@tonic-gate } 25397c478bd9Sstevel@tonic-gate } 25407c478bd9Sstevel@tonic-gate if (fill_in_only) 25417c478bd9Sstevel@tonic-gate return (Z_OK); 25427c478bd9Sstevel@tonic-gate err = zonecfg_lookup_attr(handle, attrtab); 25437c478bd9Sstevel@tonic-gate return (err); 25447c478bd9Sstevel@tonic-gate } 25457c478bd9Sstevel@tonic-gate 2546fa9e4066Sahrens static int 2547fa9e4066Sahrens fill_in_dstab(cmd_t *cmd, struct zone_dstab *dstab, bool fill_in_only) 2548fa9e4066Sahrens { 2549fa9e4066Sahrens int err, i; 2550fa9e4066Sahrens property_value_ptr_t pp; 2551fa9e4066Sahrens 2552fa9e4066Sahrens if ((err = initialize(TRUE)) != Z_OK) 2553fa9e4066Sahrens return (err); 2554fa9e4066Sahrens 2555fa9e4066Sahrens dstab->zone_dataset_name[0] = '\0'; 2556fa9e4066Sahrens for (i = 0; i < cmd->cmd_prop_nv_pairs; i++) { 2557fa9e4066Sahrens pp = cmd->cmd_property_ptr[i]; 2558fa9e4066Sahrens if (pp->pv_type != PROP_VAL_SIMPLE || pp->pv_simple == NULL) { 2559fa9e4066Sahrens zerr(gettext("A simple value was expected here.")); 2560fa9e4066Sahrens saw_error = TRUE; 2561fa9e4066Sahrens return (Z_INSUFFICIENT_SPEC); 2562fa9e4066Sahrens } 2563fa9e4066Sahrens switch (cmd->cmd_prop_name[i]) { 2564fa9e4066Sahrens case PT_NAME: 2565fa9e4066Sahrens (void) strlcpy(dstab->zone_dataset_name, pp->pv_simple, 2566fa9e4066Sahrens sizeof (dstab->zone_dataset_name)); 2567fa9e4066Sahrens break; 2568fa9e4066Sahrens default: 2569fa9e4066Sahrens zone_perror(pt_to_str(cmd->cmd_prop_name[i]), 2570fa9e4066Sahrens Z_NO_PROPERTY_TYPE, TRUE); 2571fa9e4066Sahrens return (Z_INSUFFICIENT_SPEC); 2572fa9e4066Sahrens } 2573fa9e4066Sahrens } 2574fa9e4066Sahrens if (fill_in_only) 2575fa9e4066Sahrens return (Z_OK); 2576fa9e4066Sahrens return (zonecfg_lookup_ds(handle, dstab)); 2577fa9e4066Sahrens } 2578fa9e4066Sahrens 25797c478bd9Sstevel@tonic-gate static void 2580*0209230bSgjelinek remove_aliased_rctl(int type, char *name) 25817c478bd9Sstevel@tonic-gate { 2582*0209230bSgjelinek int err; 2583*0209230bSgjelinek uint64_t tmp; 25847c478bd9Sstevel@tonic-gate 2585*0209230bSgjelinek if ((err = zonecfg_get_aliased_rctl(handle, name, &tmp)) != Z_OK) { 2586*0209230bSgjelinek zerr("%s %s: %s", cmd_to_str(CMD_CLEAR), pt_to_str(type), 2587*0209230bSgjelinek zonecfg_strerror(err)); 2588*0209230bSgjelinek saw_error = TRUE; 25897c478bd9Sstevel@tonic-gate return; 25907c478bd9Sstevel@tonic-gate } 2591*0209230bSgjelinek if ((err = zonecfg_rm_aliased_rctl(handle, name)) != Z_OK) { 2592*0209230bSgjelinek zerr("%s %s: %s", cmd_to_str(CMD_CLEAR), pt_to_str(type), 2593*0209230bSgjelinek zonecfg_strerror(err)); 2594*0209230bSgjelinek saw_error = TRUE; 2595*0209230bSgjelinek } else { 2596*0209230bSgjelinek need_to_commit = TRUE; 2597*0209230bSgjelinek } 2598*0209230bSgjelinek } 25997c478bd9Sstevel@tonic-gate 2600*0209230bSgjelinek static boolean_t 2601*0209230bSgjelinek prompt_remove_resource(cmd_t *cmd, char *rsrc) 2602*0209230bSgjelinek { 2603*0209230bSgjelinek int num; 2604*0209230bSgjelinek int answer; 2605*0209230bSgjelinek int arg; 2606*0209230bSgjelinek boolean_t force = B_FALSE; 2607*0209230bSgjelinek char prompt[128]; 2608*0209230bSgjelinek 2609*0209230bSgjelinek optind = 0; 2610*0209230bSgjelinek while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "F")) != EOF) { 2611*0209230bSgjelinek switch (arg) { 2612*0209230bSgjelinek case 'F': 2613*0209230bSgjelinek force = B_TRUE; 2614*0209230bSgjelinek break; 2615*0209230bSgjelinek default: 2616*0209230bSgjelinek return (B_FALSE); 2617*0209230bSgjelinek } 2618*0209230bSgjelinek } 2619*0209230bSgjelinek 2620*0209230bSgjelinek num = zonecfg_num_resources(handle, rsrc); 2621*0209230bSgjelinek 2622*0209230bSgjelinek if (num == 0) { 2623*0209230bSgjelinek z_cmd_rt_perror(CMD_REMOVE, cmd->cmd_res_type, Z_NO_ENTRY, 2624*0209230bSgjelinek TRUE); 2625*0209230bSgjelinek return (B_FALSE); 2626*0209230bSgjelinek } 2627*0209230bSgjelinek if (num > 1 && !force) { 2628*0209230bSgjelinek if (!interactive_mode) { 2629*0209230bSgjelinek zerr(gettext("There are multiple instances of this " 2630*0209230bSgjelinek "resource. Either qualify the resource to\n" 2631*0209230bSgjelinek "remove a single instance or use the -F option to " 2632*0209230bSgjelinek "remove all instances.")); 2633*0209230bSgjelinek saw_error = TRUE; 2634*0209230bSgjelinek return (B_FALSE); 2635*0209230bSgjelinek } 2636*0209230bSgjelinek (void) snprintf(prompt, sizeof (prompt), gettext( 2637*0209230bSgjelinek "Are you sure you want to remove ALL '%s' resources"), 2638*0209230bSgjelinek rsrc); 2639*0209230bSgjelinek answer = ask_yesno(FALSE, prompt); 2640*0209230bSgjelinek if (answer == -1) { 2641*0209230bSgjelinek zerr(gettext("Resource incomplete.")); 2642*0209230bSgjelinek return (B_FALSE); 2643*0209230bSgjelinek } 2644*0209230bSgjelinek if (answer != 1) 2645*0209230bSgjelinek return (B_FALSE); 2646*0209230bSgjelinek } 2647*0209230bSgjelinek return (B_TRUE); 2648*0209230bSgjelinek } 2649*0209230bSgjelinek 2650*0209230bSgjelinek static void 2651*0209230bSgjelinek remove_fs(cmd_t *cmd) 2652*0209230bSgjelinek { 2653*0209230bSgjelinek int err; 2654*0209230bSgjelinek 2655*0209230bSgjelinek /* traditional, qualified fs removal */ 2656*0209230bSgjelinek if (cmd->cmd_prop_nv_pairs > 0) { 2657*0209230bSgjelinek struct zone_fstab fstab; 26587c478bd9Sstevel@tonic-gate 26597c478bd9Sstevel@tonic-gate if ((err = fill_in_fstab(cmd, &fstab, FALSE)) != Z_OK) { 26607c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_REMOVE, RT_FS, err, TRUE); 26617c478bd9Sstevel@tonic-gate return; 26627c478bd9Sstevel@tonic-gate } 26637c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_filesystem(handle, &fstab)) != Z_OK) 26647c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_REMOVE, RT_FS, err, TRUE); 26657c478bd9Sstevel@tonic-gate else 26667c478bd9Sstevel@tonic-gate need_to_commit = TRUE; 26677c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(fstab.zone_fs_options); 26687c478bd9Sstevel@tonic-gate return; 2669*0209230bSgjelinek } 2670*0209230bSgjelinek 2671*0209230bSgjelinek /* 2672*0209230bSgjelinek * unqualified fs removal. remove all fs's but prompt if more 2673*0209230bSgjelinek * than one. 2674*0209230bSgjelinek */ 2675*0209230bSgjelinek if (!prompt_remove_resource(cmd, "fs")) 2676*0209230bSgjelinek return; 2677*0209230bSgjelinek 2678*0209230bSgjelinek if ((err = zonecfg_del_all_resources(handle, "fs")) != Z_OK) 2679*0209230bSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_FS, err, TRUE); 2680*0209230bSgjelinek else 2681*0209230bSgjelinek need_to_commit = TRUE; 2682*0209230bSgjelinek } 2683*0209230bSgjelinek 2684*0209230bSgjelinek static void 2685*0209230bSgjelinek remove_ipd(cmd_t *cmd) 2686*0209230bSgjelinek { 2687*0209230bSgjelinek int err; 2688*0209230bSgjelinek 2689*0209230bSgjelinek if (state_atleast(ZONE_STATE_INSTALLED)) { 2690*0209230bSgjelinek zerr(gettext("Zone %s already installed; %s %s not allowed."), 2691*0209230bSgjelinek zone, cmd_to_str(CMD_REMOVE), rt_to_str(RT_IPD)); 2692*0209230bSgjelinek return; 2693*0209230bSgjelinek } 2694*0209230bSgjelinek 2695*0209230bSgjelinek /* traditional, qualified ipd removal */ 2696*0209230bSgjelinek if (cmd->cmd_prop_nv_pairs > 0) { 2697*0209230bSgjelinek struct zone_fstab fstab; 2698*0209230bSgjelinek 26997c478bd9Sstevel@tonic-gate if ((err = fill_in_ipdtab(cmd, &fstab, FALSE)) != Z_OK) { 27007c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_REMOVE, RT_IPD, err, TRUE); 27017c478bd9Sstevel@tonic-gate return; 27027c478bd9Sstevel@tonic-gate } 27037c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_ipd(handle, &fstab)) != Z_OK) 27047c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_REMOVE, RT_IPD, err, TRUE); 27057c478bd9Sstevel@tonic-gate else 27067c478bd9Sstevel@tonic-gate need_to_commit = TRUE; 27077c478bd9Sstevel@tonic-gate return; 2708*0209230bSgjelinek } 2709*0209230bSgjelinek 2710*0209230bSgjelinek /* 2711*0209230bSgjelinek * unqualified ipd removal. remove all ipds but prompt if more 2712*0209230bSgjelinek * than one. 2713*0209230bSgjelinek */ 2714*0209230bSgjelinek if (!prompt_remove_resource(cmd, "inherit-pkg-dir")) 2715*0209230bSgjelinek return; 2716*0209230bSgjelinek 2717*0209230bSgjelinek if ((err = zonecfg_del_all_resources(handle, "inherit-pkg-dir")) 2718*0209230bSgjelinek != Z_OK) 2719*0209230bSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_IPD, err, TRUE); 2720*0209230bSgjelinek else 2721*0209230bSgjelinek need_to_commit = TRUE; 2722*0209230bSgjelinek } 2723*0209230bSgjelinek 2724*0209230bSgjelinek static void 2725*0209230bSgjelinek remove_net(cmd_t *cmd) 2726*0209230bSgjelinek { 2727*0209230bSgjelinek int err; 2728*0209230bSgjelinek 2729*0209230bSgjelinek /* traditional, qualified net removal */ 2730*0209230bSgjelinek if (cmd->cmd_prop_nv_pairs > 0) { 2731*0209230bSgjelinek struct zone_nwiftab nwiftab; 2732*0209230bSgjelinek 27337c478bd9Sstevel@tonic-gate if ((err = fill_in_nwiftab(cmd, &nwiftab, FALSE)) != Z_OK) { 27347c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_REMOVE, RT_NET, err, TRUE); 27357c478bd9Sstevel@tonic-gate return; 27367c478bd9Sstevel@tonic-gate } 27377c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_nwif(handle, &nwiftab)) != Z_OK) 27387c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_REMOVE, RT_NET, err, TRUE); 27397c478bd9Sstevel@tonic-gate else 27407c478bd9Sstevel@tonic-gate need_to_commit = TRUE; 27417c478bd9Sstevel@tonic-gate return; 2742*0209230bSgjelinek } 2743*0209230bSgjelinek 2744*0209230bSgjelinek /* 2745*0209230bSgjelinek * unqualified net removal. remove all nets but prompt if more 2746*0209230bSgjelinek * than one. 2747*0209230bSgjelinek */ 2748*0209230bSgjelinek if (!prompt_remove_resource(cmd, "net")) 2749*0209230bSgjelinek return; 2750*0209230bSgjelinek 2751*0209230bSgjelinek if ((err = zonecfg_del_all_resources(handle, "net")) != Z_OK) 2752*0209230bSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_NET, err, TRUE); 2753*0209230bSgjelinek else 2754*0209230bSgjelinek need_to_commit = TRUE; 2755*0209230bSgjelinek } 2756*0209230bSgjelinek 2757*0209230bSgjelinek static void 2758*0209230bSgjelinek remove_device(cmd_t *cmd) 2759*0209230bSgjelinek { 2760*0209230bSgjelinek int err; 2761*0209230bSgjelinek 2762*0209230bSgjelinek /* traditional, qualified device removal */ 2763*0209230bSgjelinek if (cmd->cmd_prop_nv_pairs > 0) { 2764*0209230bSgjelinek struct zone_devtab devtab; 2765*0209230bSgjelinek 27667c478bd9Sstevel@tonic-gate if ((err = fill_in_devtab(cmd, &devtab, FALSE)) != Z_OK) { 27677c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_REMOVE, RT_DEVICE, err, TRUE); 27687c478bd9Sstevel@tonic-gate return; 27697c478bd9Sstevel@tonic-gate } 27707c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_dev(handle, &devtab)) != Z_OK) 27717c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_REMOVE, RT_DEVICE, err, TRUE); 27727c478bd9Sstevel@tonic-gate else 27737c478bd9Sstevel@tonic-gate need_to_commit = TRUE; 27747c478bd9Sstevel@tonic-gate return; 2775*0209230bSgjelinek } 2776*0209230bSgjelinek 2777*0209230bSgjelinek /* 2778*0209230bSgjelinek * unqualified device removal. remove all devices but prompt if more 2779*0209230bSgjelinek * than one. 2780*0209230bSgjelinek */ 2781*0209230bSgjelinek if (!prompt_remove_resource(cmd, "device")) 27827c478bd9Sstevel@tonic-gate return; 2783*0209230bSgjelinek 2784*0209230bSgjelinek if ((err = zonecfg_del_all_resources(handle, "device")) != Z_OK) 2785*0209230bSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_DEVICE, err, TRUE); 2786*0209230bSgjelinek else 2787*0209230bSgjelinek need_to_commit = TRUE; 2788*0209230bSgjelinek } 2789*0209230bSgjelinek 2790*0209230bSgjelinek static void 2791*0209230bSgjelinek remove_attr(cmd_t *cmd) 2792*0209230bSgjelinek { 2793*0209230bSgjelinek int err; 2794*0209230bSgjelinek 2795*0209230bSgjelinek /* traditional, qualified attr removal */ 2796*0209230bSgjelinek if (cmd->cmd_prop_nv_pairs > 0) { 2797*0209230bSgjelinek struct zone_attrtab attrtab; 2798*0209230bSgjelinek 27997c478bd9Sstevel@tonic-gate if ((err = fill_in_attrtab(cmd, &attrtab, FALSE)) != Z_OK) { 28007c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_REMOVE, RT_ATTR, err, TRUE); 28017c478bd9Sstevel@tonic-gate return; 28027c478bd9Sstevel@tonic-gate } 28037c478bd9Sstevel@tonic-gate if ((err = zonecfg_delete_attr(handle, &attrtab)) != Z_OK) 28047c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_REMOVE, RT_ATTR, err, TRUE); 28057c478bd9Sstevel@tonic-gate else 28067c478bd9Sstevel@tonic-gate need_to_commit = TRUE; 28077c478bd9Sstevel@tonic-gate return; 2808*0209230bSgjelinek } 2809*0209230bSgjelinek 2810*0209230bSgjelinek /* 2811*0209230bSgjelinek * unqualified attr removal. remove all attrs but prompt if more 2812*0209230bSgjelinek * than one. 2813*0209230bSgjelinek */ 2814*0209230bSgjelinek if (!prompt_remove_resource(cmd, "attr")) 2815*0209230bSgjelinek return; 2816*0209230bSgjelinek 2817*0209230bSgjelinek if ((err = zonecfg_del_all_resources(handle, "attr")) != Z_OK) 2818*0209230bSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_ATTR, err, TRUE); 2819*0209230bSgjelinek else 2820*0209230bSgjelinek need_to_commit = TRUE; 2821*0209230bSgjelinek } 2822*0209230bSgjelinek 2823*0209230bSgjelinek static void 2824*0209230bSgjelinek remove_dataset(cmd_t *cmd) 2825*0209230bSgjelinek { 2826*0209230bSgjelinek int err; 2827*0209230bSgjelinek 2828*0209230bSgjelinek /* traditional, qualified dataset removal */ 2829*0209230bSgjelinek if (cmd->cmd_prop_nv_pairs > 0) { 2830*0209230bSgjelinek struct zone_dstab dstab; 2831*0209230bSgjelinek 2832fa9e4066Sahrens if ((err = fill_in_dstab(cmd, &dstab, FALSE)) != Z_OK) { 2833fa9e4066Sahrens z_cmd_rt_perror(CMD_REMOVE, RT_DATASET, err, TRUE); 2834fa9e4066Sahrens return; 2835fa9e4066Sahrens } 2836fa9e4066Sahrens if ((err = zonecfg_delete_ds(handle, &dstab)) != Z_OK) 2837fa9e4066Sahrens z_cmd_rt_perror(CMD_REMOVE, RT_DATASET, err, TRUE); 2838fa9e4066Sahrens else 2839fa9e4066Sahrens need_to_commit = TRUE; 2840fa9e4066Sahrens return; 28417c478bd9Sstevel@tonic-gate } 2842*0209230bSgjelinek 2843*0209230bSgjelinek /* 2844*0209230bSgjelinek * unqualified dataset removal. remove all datasets but prompt if more 2845*0209230bSgjelinek * than one. 2846*0209230bSgjelinek */ 2847*0209230bSgjelinek if (!prompt_remove_resource(cmd, "dataset")) 2848*0209230bSgjelinek return; 2849*0209230bSgjelinek 2850*0209230bSgjelinek if ((err = zonecfg_del_all_resources(handle, "dataset")) != Z_OK) 2851*0209230bSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_DATASET, err, TRUE); 2852*0209230bSgjelinek else 2853*0209230bSgjelinek need_to_commit = TRUE; 2854*0209230bSgjelinek } 2855*0209230bSgjelinek 2856*0209230bSgjelinek static void 2857*0209230bSgjelinek remove_rctl(cmd_t *cmd) 2858*0209230bSgjelinek { 2859*0209230bSgjelinek int err; 2860*0209230bSgjelinek 2861*0209230bSgjelinek /* traditional, qualified rctl removal */ 2862*0209230bSgjelinek if (cmd->cmd_prop_nv_pairs > 0) { 2863*0209230bSgjelinek struct zone_rctltab rctltab; 2864*0209230bSgjelinek 2865*0209230bSgjelinek if ((err = fill_in_rctltab(cmd, &rctltab, FALSE)) != Z_OK) { 2866*0209230bSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_RCTL, err, TRUE); 2867*0209230bSgjelinek return; 2868*0209230bSgjelinek } 2869*0209230bSgjelinek if ((err = zonecfg_delete_rctl(handle, &rctltab)) != Z_OK) 2870*0209230bSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_RCTL, err, TRUE); 2871*0209230bSgjelinek else 2872*0209230bSgjelinek need_to_commit = TRUE; 2873*0209230bSgjelinek zonecfg_free_rctl_value_list(rctltab.zone_rctl_valptr); 2874*0209230bSgjelinek return; 2875*0209230bSgjelinek } 2876*0209230bSgjelinek 2877*0209230bSgjelinek /* 2878*0209230bSgjelinek * unqualified rctl removal. remove all rctls but prompt if more 2879*0209230bSgjelinek * than one. 2880*0209230bSgjelinek */ 2881*0209230bSgjelinek if (!prompt_remove_resource(cmd, "rctl")) 2882*0209230bSgjelinek return; 2883*0209230bSgjelinek 2884*0209230bSgjelinek if ((err = zonecfg_del_all_resources(handle, "rctl")) != Z_OK) 2885*0209230bSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_RCTL, err, TRUE); 2886*0209230bSgjelinek else 2887*0209230bSgjelinek need_to_commit = TRUE; 2888*0209230bSgjelinek } 2889*0209230bSgjelinek 2890*0209230bSgjelinek static void 2891*0209230bSgjelinek remove_pset() 2892*0209230bSgjelinek { 2893*0209230bSgjelinek int err; 2894*0209230bSgjelinek struct zone_psettab psettab; 2895*0209230bSgjelinek 2896*0209230bSgjelinek if ((err = zonecfg_lookup_pset(handle, &psettab)) != Z_OK) { 2897*0209230bSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_DCPU, err, TRUE); 2898*0209230bSgjelinek return; 2899*0209230bSgjelinek } 2900*0209230bSgjelinek if ((err = zonecfg_delete_pset(handle)) != Z_OK) 2901*0209230bSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_DCPU, err, TRUE); 2902*0209230bSgjelinek else 2903*0209230bSgjelinek need_to_commit = TRUE; 2904*0209230bSgjelinek } 2905*0209230bSgjelinek 2906*0209230bSgjelinek static void 2907*0209230bSgjelinek remove_mcap() 2908*0209230bSgjelinek { 2909*0209230bSgjelinek int err, res1, res2, res3; 2910*0209230bSgjelinek uint64_t tmp; 2911*0209230bSgjelinek struct zone_mcaptab mcaptab; 2912*0209230bSgjelinek boolean_t revert = B_FALSE; 2913*0209230bSgjelinek 2914*0209230bSgjelinek res1 = zonecfg_lookup_mcap(handle, &mcaptab); 2915*0209230bSgjelinek res2 = zonecfg_get_aliased_rctl(handle, ALIAS_MAXSWAP, &tmp); 2916*0209230bSgjelinek res3 = zonecfg_get_aliased_rctl(handle, ALIAS_MAXLOCKEDMEM, &tmp); 2917*0209230bSgjelinek 2918*0209230bSgjelinek /* if none of these exist, there is no resource to remove */ 2919*0209230bSgjelinek if (res1 != Z_OK && res2 != Z_OK && res3 != Z_OK) { 2920*0209230bSgjelinek zerr("%s %s: %s", cmd_to_str(CMD_REMOVE), rt_to_str(RT_MCAP), 2921*0209230bSgjelinek zonecfg_strerror(Z_NO_RESOURCE_TYPE)); 2922*0209230bSgjelinek saw_error = TRUE; 2923*0209230bSgjelinek return; 2924*0209230bSgjelinek } 2925*0209230bSgjelinek if (res1 == Z_OK) { 2926*0209230bSgjelinek if ((err = zonecfg_delete_mcap(handle)) != Z_OK) { 2927*0209230bSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_MCAP, err, TRUE); 2928*0209230bSgjelinek revert = B_TRUE; 2929*0209230bSgjelinek } else { 2930*0209230bSgjelinek need_to_commit = TRUE; 2931*0209230bSgjelinek } 2932*0209230bSgjelinek } 2933*0209230bSgjelinek if (res2 == Z_OK) { 2934*0209230bSgjelinek if ((err = zonecfg_rm_aliased_rctl(handle, ALIAS_MAXSWAP)) 2935*0209230bSgjelinek != Z_OK) { 2936*0209230bSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_MCAP, err, TRUE); 2937*0209230bSgjelinek revert = B_TRUE; 2938*0209230bSgjelinek } else { 2939*0209230bSgjelinek need_to_commit = TRUE; 2940*0209230bSgjelinek } 2941*0209230bSgjelinek } 2942*0209230bSgjelinek if (res3 == Z_OK) { 2943*0209230bSgjelinek if ((err = zonecfg_rm_aliased_rctl(handle, ALIAS_MAXLOCKEDMEM)) 2944*0209230bSgjelinek != Z_OK) { 2945*0209230bSgjelinek z_cmd_rt_perror(CMD_REMOVE, RT_MCAP, err, TRUE); 2946*0209230bSgjelinek revert = B_TRUE; 2947*0209230bSgjelinek } else { 2948*0209230bSgjelinek need_to_commit = TRUE; 2949*0209230bSgjelinek } 2950*0209230bSgjelinek } 2951*0209230bSgjelinek 2952*0209230bSgjelinek if (revert) 2953*0209230bSgjelinek need_to_commit = FALSE; 2954*0209230bSgjelinek } 2955*0209230bSgjelinek 2956*0209230bSgjelinek static void 2957*0209230bSgjelinek remove_resource(cmd_t *cmd) 2958*0209230bSgjelinek { 2959*0209230bSgjelinek int type; 2960*0209230bSgjelinek int arg; 2961*0209230bSgjelinek 2962*0209230bSgjelinek if ((type = cmd->cmd_res_type) == RT_UNKNOWN) { 2963*0209230bSgjelinek long_usage(CMD_REMOVE, TRUE); 2964*0209230bSgjelinek return; 2965*0209230bSgjelinek } 2966*0209230bSgjelinek 2967*0209230bSgjelinek optind = 0; 2968*0209230bSgjelinek while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?F")) != EOF) { 2969*0209230bSgjelinek switch (arg) { 2970*0209230bSgjelinek case '?': 2971*0209230bSgjelinek longer_usage(CMD_REMOVE); 2972*0209230bSgjelinek return; 2973*0209230bSgjelinek case 'F': 2974*0209230bSgjelinek break; 2975*0209230bSgjelinek default: 2976*0209230bSgjelinek short_usage(CMD_REMOVE); 2977*0209230bSgjelinek return; 2978*0209230bSgjelinek } 2979*0209230bSgjelinek } 2980*0209230bSgjelinek 2981*0209230bSgjelinek if (initialize(TRUE) != Z_OK) 2982*0209230bSgjelinek return; 2983*0209230bSgjelinek 2984*0209230bSgjelinek switch (type) { 2985*0209230bSgjelinek case RT_FS: 2986*0209230bSgjelinek remove_fs(cmd); 2987*0209230bSgjelinek return; 2988*0209230bSgjelinek case RT_IPD: 2989*0209230bSgjelinek remove_ipd(cmd); 2990*0209230bSgjelinek return; 2991*0209230bSgjelinek case RT_NET: 2992*0209230bSgjelinek remove_net(cmd); 2993*0209230bSgjelinek return; 2994*0209230bSgjelinek case RT_DEVICE: 2995*0209230bSgjelinek remove_device(cmd); 2996*0209230bSgjelinek return; 2997*0209230bSgjelinek case RT_RCTL: 2998*0209230bSgjelinek remove_rctl(cmd); 2999*0209230bSgjelinek return; 3000*0209230bSgjelinek case RT_ATTR: 3001*0209230bSgjelinek remove_attr(cmd); 3002*0209230bSgjelinek return; 3003*0209230bSgjelinek case RT_DATASET: 3004*0209230bSgjelinek remove_dataset(cmd); 3005*0209230bSgjelinek return; 3006*0209230bSgjelinek case RT_DCPU: 3007*0209230bSgjelinek remove_pset(); 3008*0209230bSgjelinek return; 3009*0209230bSgjelinek case RT_MCAP: 3010*0209230bSgjelinek remove_mcap(); 3011*0209230bSgjelinek return; 3012*0209230bSgjelinek default: 3013*0209230bSgjelinek zone_perror(rt_to_str(type), Z_NO_RESOURCE_TYPE, TRUE); 3014*0209230bSgjelinek long_usage(CMD_REMOVE, TRUE); 3015*0209230bSgjelinek usage(FALSE, HELP_RESOURCES); 3016*0209230bSgjelinek return; 3017*0209230bSgjelinek } 3018*0209230bSgjelinek } 30197c478bd9Sstevel@tonic-gate 30207c478bd9Sstevel@tonic-gate static void 30217c478bd9Sstevel@tonic-gate remove_property(cmd_t *cmd) 30227c478bd9Sstevel@tonic-gate { 30237c478bd9Sstevel@tonic-gate char *prop_id; 30247c478bd9Sstevel@tonic-gate int err, res_type, prop_type; 30257c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 30267c478bd9Sstevel@tonic-gate struct zone_rctlvaltab *rctlvaltab; 30277c478bd9Sstevel@tonic-gate complex_property_ptr_t cx; 30287c478bd9Sstevel@tonic-gate 30297c478bd9Sstevel@tonic-gate res_type = resource_scope; 30307c478bd9Sstevel@tonic-gate prop_type = cmd->cmd_prop_name[0]; 30317c478bd9Sstevel@tonic-gate if (res_type == RT_UNKNOWN || prop_type == PT_UNKNOWN) { 30327c478bd9Sstevel@tonic-gate long_usage(CMD_REMOVE, TRUE); 30337c478bd9Sstevel@tonic-gate return; 30347c478bd9Sstevel@tonic-gate } 30357c478bd9Sstevel@tonic-gate 30367c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs != 1) { 30377c478bd9Sstevel@tonic-gate long_usage(CMD_ADD, TRUE); 30387c478bd9Sstevel@tonic-gate return; 30397c478bd9Sstevel@tonic-gate } 30407c478bd9Sstevel@tonic-gate 30417c478bd9Sstevel@tonic-gate if (initialize(TRUE) != Z_OK) 30427c478bd9Sstevel@tonic-gate return; 30437c478bd9Sstevel@tonic-gate 30447c478bd9Sstevel@tonic-gate switch (res_type) { 30457c478bd9Sstevel@tonic-gate case RT_FS: 30467c478bd9Sstevel@tonic-gate if (prop_type != PT_OPTIONS) { 30477c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 30487c478bd9Sstevel@tonic-gate TRUE); 30497c478bd9Sstevel@tonic-gate long_usage(CMD_REMOVE, TRUE); 30507c478bd9Sstevel@tonic-gate usage(FALSE, HELP_PROPS); 30517c478bd9Sstevel@tonic-gate return; 30527c478bd9Sstevel@tonic-gate } 30537c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[0]; 30547c478bd9Sstevel@tonic-gate if (pp->pv_type == PROP_VAL_COMPLEX) { 30557c478bd9Sstevel@tonic-gate zerr(gettext("A %s or %s value was expected here."), 30567c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_SIMPLE), 30577c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_LIST)); 30587c478bd9Sstevel@tonic-gate saw_error = TRUE; 30597c478bd9Sstevel@tonic-gate return; 30607c478bd9Sstevel@tonic-gate } 30617c478bd9Sstevel@tonic-gate if (pp->pv_type == PROP_VAL_SIMPLE) { 30627c478bd9Sstevel@tonic-gate if (pp->pv_simple == NULL) { 30637c478bd9Sstevel@tonic-gate long_usage(CMD_ADD, TRUE); 30647c478bd9Sstevel@tonic-gate return; 30657c478bd9Sstevel@tonic-gate } 30667c478bd9Sstevel@tonic-gate prop_id = pp->pv_simple; 30677c478bd9Sstevel@tonic-gate err = zonecfg_remove_fs_option(&in_progress_fstab, 30687c478bd9Sstevel@tonic-gate prop_id); 30697c478bd9Sstevel@tonic-gate if (err != Z_OK) 30707c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), err, TRUE); 30717c478bd9Sstevel@tonic-gate } else { 30727c478bd9Sstevel@tonic-gate list_property_ptr_t list; 30737c478bd9Sstevel@tonic-gate 30747c478bd9Sstevel@tonic-gate for (list = pp->pv_list; list != NULL; 30757c478bd9Sstevel@tonic-gate list = list->lp_next) { 30767c478bd9Sstevel@tonic-gate prop_id = list->lp_simple; 30777c478bd9Sstevel@tonic-gate if (prop_id == NULL) 30787c478bd9Sstevel@tonic-gate break; 30797c478bd9Sstevel@tonic-gate err = zonecfg_remove_fs_option( 30807c478bd9Sstevel@tonic-gate &in_progress_fstab, prop_id); 30817c478bd9Sstevel@tonic-gate if (err != Z_OK) 30827c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), err, 30837c478bd9Sstevel@tonic-gate TRUE); 30847c478bd9Sstevel@tonic-gate } 30857c478bd9Sstevel@tonic-gate } 30867c478bd9Sstevel@tonic-gate return; 30877c478bd9Sstevel@tonic-gate case RT_RCTL: 30887c478bd9Sstevel@tonic-gate if (prop_type != PT_VALUE) { 30897c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 30907c478bd9Sstevel@tonic-gate TRUE); 30917c478bd9Sstevel@tonic-gate long_usage(CMD_REMOVE, TRUE); 30927c478bd9Sstevel@tonic-gate usage(FALSE, HELP_PROPS); 30937c478bd9Sstevel@tonic-gate return; 30947c478bd9Sstevel@tonic-gate } 30957c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[0]; 30967c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_COMPLEX) { 30977c478bd9Sstevel@tonic-gate zerr(gettext("A %s value was expected here."), 30987c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_COMPLEX)); 30997c478bd9Sstevel@tonic-gate saw_error = TRUE; 31007c478bd9Sstevel@tonic-gate return; 31017c478bd9Sstevel@tonic-gate } 31027c478bd9Sstevel@tonic-gate if ((rctlvaltab = alloc_rctlvaltab()) == NULL) { 31037c478bd9Sstevel@tonic-gate zone_perror(zone, Z_NOMEM, TRUE); 31047c478bd9Sstevel@tonic-gate exit(Z_ERR); 31057c478bd9Sstevel@tonic-gate } 31067c478bd9Sstevel@tonic-gate for (cx = pp->pv_complex; cx != NULL; cx = cx->cp_next) { 31077c478bd9Sstevel@tonic-gate switch (cx->cp_type) { 31087c478bd9Sstevel@tonic-gate case PT_PRIV: 31097c478bd9Sstevel@tonic-gate (void) strlcpy(rctlvaltab->zone_rctlval_priv, 31107c478bd9Sstevel@tonic-gate cx->cp_value, 31117c478bd9Sstevel@tonic-gate sizeof (rctlvaltab->zone_rctlval_priv)); 31127c478bd9Sstevel@tonic-gate break; 31137c478bd9Sstevel@tonic-gate case PT_LIMIT: 31147c478bd9Sstevel@tonic-gate (void) strlcpy(rctlvaltab->zone_rctlval_limit, 31157c478bd9Sstevel@tonic-gate cx->cp_value, 31167c478bd9Sstevel@tonic-gate sizeof (rctlvaltab->zone_rctlval_limit)); 31177c478bd9Sstevel@tonic-gate break; 31187c478bd9Sstevel@tonic-gate case PT_ACTION: 31197c478bd9Sstevel@tonic-gate (void) strlcpy(rctlvaltab->zone_rctlval_action, 31207c478bd9Sstevel@tonic-gate cx->cp_value, 31217c478bd9Sstevel@tonic-gate sizeof (rctlvaltab->zone_rctlval_action)); 31227c478bd9Sstevel@tonic-gate break; 31237c478bd9Sstevel@tonic-gate default: 31247c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), 31257c478bd9Sstevel@tonic-gate Z_NO_PROPERTY_TYPE, TRUE); 31267c478bd9Sstevel@tonic-gate long_usage(CMD_ADD, TRUE); 31277c478bd9Sstevel@tonic-gate usage(FALSE, HELP_PROPS); 31287c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctlvaltab); 31297c478bd9Sstevel@tonic-gate return; 31307c478bd9Sstevel@tonic-gate } 31317c478bd9Sstevel@tonic-gate } 31327c478bd9Sstevel@tonic-gate rctlvaltab->zone_rctlval_next = NULL; 31337c478bd9Sstevel@tonic-gate err = zonecfg_remove_rctl_value(&in_progress_rctltab, 31347c478bd9Sstevel@tonic-gate rctlvaltab); 31357c478bd9Sstevel@tonic-gate if (err != Z_OK) 31367c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), err, TRUE); 31377c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctlvaltab); 31387c478bd9Sstevel@tonic-gate return; 31397c478bd9Sstevel@tonic-gate default: 31407c478bd9Sstevel@tonic-gate zone_perror(rt_to_str(res_type), Z_NO_RESOURCE_TYPE, TRUE); 31417c478bd9Sstevel@tonic-gate long_usage(CMD_REMOVE, TRUE); 31427c478bd9Sstevel@tonic-gate usage(FALSE, HELP_RESOURCES); 31437c478bd9Sstevel@tonic-gate return; 31447c478bd9Sstevel@tonic-gate } 31457c478bd9Sstevel@tonic-gate } 31467c478bd9Sstevel@tonic-gate 31477c478bd9Sstevel@tonic-gate void 31487c478bd9Sstevel@tonic-gate remove_func(cmd_t *cmd) 31497c478bd9Sstevel@tonic-gate { 31507c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_REMOVE)) 31517c478bd9Sstevel@tonic-gate return; 31527c478bd9Sstevel@tonic-gate 31537c478bd9Sstevel@tonic-gate assert(cmd != NULL); 31547c478bd9Sstevel@tonic-gate 3155*0209230bSgjelinek if (global_scope) { 3156*0209230bSgjelinek if (gz_invalid_resource(cmd->cmd_res_type)) { 3157*0209230bSgjelinek zerr(gettext("%s is not a valid resource for the " 3158*0209230bSgjelinek "global zone."), rt_to_str(cmd->cmd_res_type)); 3159*0209230bSgjelinek saw_error = TRUE; 3160*0209230bSgjelinek return; 3161*0209230bSgjelinek } 31627c478bd9Sstevel@tonic-gate remove_resource(cmd); 3163*0209230bSgjelinek } else { 31647c478bd9Sstevel@tonic-gate remove_property(cmd); 3165*0209230bSgjelinek } 3166*0209230bSgjelinek } 3167*0209230bSgjelinek 3168*0209230bSgjelinek static void 3169*0209230bSgjelinek clear_property(cmd_t *cmd) 3170*0209230bSgjelinek { 3171*0209230bSgjelinek int res_type, prop_type; 3172*0209230bSgjelinek 3173*0209230bSgjelinek res_type = resource_scope; 3174*0209230bSgjelinek prop_type = cmd->cmd_res_type; 3175*0209230bSgjelinek if (res_type == RT_UNKNOWN || prop_type == PT_UNKNOWN) { 3176*0209230bSgjelinek long_usage(CMD_CLEAR, TRUE); 3177*0209230bSgjelinek return; 3178*0209230bSgjelinek } 3179*0209230bSgjelinek 3180*0209230bSgjelinek if (initialize(TRUE) != Z_OK) 3181*0209230bSgjelinek return; 3182*0209230bSgjelinek 3183*0209230bSgjelinek switch (res_type) { 3184*0209230bSgjelinek case RT_FS: 3185*0209230bSgjelinek if (prop_type == PT_RAW) { 3186*0209230bSgjelinek in_progress_fstab.zone_fs_raw[0] = '\0'; 3187*0209230bSgjelinek need_to_commit = TRUE; 3188*0209230bSgjelinek return; 3189*0209230bSgjelinek } 3190*0209230bSgjelinek break; 3191*0209230bSgjelinek case RT_DCPU: 3192*0209230bSgjelinek if (prop_type == PT_IMPORTANCE) { 3193*0209230bSgjelinek in_progress_psettab.zone_importance[0] = '\0'; 3194*0209230bSgjelinek need_to_commit = TRUE; 3195*0209230bSgjelinek return; 3196*0209230bSgjelinek } 3197*0209230bSgjelinek break; 3198*0209230bSgjelinek case RT_MCAP: 3199*0209230bSgjelinek switch (prop_type) { 3200*0209230bSgjelinek case PT_PHYSICAL: 3201*0209230bSgjelinek in_progress_mcaptab.zone_physmem_cap[0] = '\0'; 3202*0209230bSgjelinek need_to_commit = TRUE; 3203*0209230bSgjelinek return; 3204*0209230bSgjelinek case PT_SWAP: 3205*0209230bSgjelinek remove_aliased_rctl(PT_SWAP, ALIAS_MAXSWAP); 3206*0209230bSgjelinek return; 3207*0209230bSgjelinek case PT_LOCKED: 3208*0209230bSgjelinek remove_aliased_rctl(PT_LOCKED, ALIAS_MAXLOCKEDMEM); 3209*0209230bSgjelinek return; 3210*0209230bSgjelinek } 3211*0209230bSgjelinek break; 3212*0209230bSgjelinek default: 3213*0209230bSgjelinek break; 3214*0209230bSgjelinek } 3215*0209230bSgjelinek 3216*0209230bSgjelinek zone_perror(pt_to_str(prop_type), Z_CLEAR_DISALLOW, TRUE); 3217*0209230bSgjelinek } 3218*0209230bSgjelinek 3219*0209230bSgjelinek static void 3220*0209230bSgjelinek clear_global(cmd_t *cmd) 3221*0209230bSgjelinek { 3222*0209230bSgjelinek int err, type; 3223*0209230bSgjelinek 3224*0209230bSgjelinek if ((type = cmd->cmd_res_type) == RT_UNKNOWN) { 3225*0209230bSgjelinek long_usage(CMD_CLEAR, TRUE); 3226*0209230bSgjelinek return; 3227*0209230bSgjelinek } 3228*0209230bSgjelinek 3229*0209230bSgjelinek if (initialize(TRUE) != Z_OK) 3230*0209230bSgjelinek return; 3231*0209230bSgjelinek 3232*0209230bSgjelinek switch (type) { 3233*0209230bSgjelinek case PT_ZONENAME: 3234*0209230bSgjelinek /* FALLTHRU */ 3235*0209230bSgjelinek case PT_ZONEPATH: 3236*0209230bSgjelinek /* FALLTHRU */ 3237*0209230bSgjelinek case PT_BRAND: 3238*0209230bSgjelinek zone_perror(pt_to_str(type), Z_CLEAR_DISALLOW, TRUE); 3239*0209230bSgjelinek return; 3240*0209230bSgjelinek case PT_AUTOBOOT: 3241*0209230bSgjelinek /* false is default; we'll treat as equivalent to clearing */ 3242*0209230bSgjelinek if ((err = zonecfg_set_autoboot(handle, B_FALSE)) != Z_OK) 3243*0209230bSgjelinek z_cmd_rt_perror(CMD_CLEAR, RT_AUTOBOOT, err, TRUE); 3244*0209230bSgjelinek else 3245*0209230bSgjelinek need_to_commit = TRUE; 3246*0209230bSgjelinek return; 3247*0209230bSgjelinek case PT_POOL: 3248*0209230bSgjelinek if ((err = zonecfg_set_pool(handle, NULL)) != Z_OK) 3249*0209230bSgjelinek z_cmd_rt_perror(CMD_CLEAR, RT_POOL, err, TRUE); 3250*0209230bSgjelinek else 3251*0209230bSgjelinek need_to_commit = TRUE; 3252*0209230bSgjelinek return; 3253*0209230bSgjelinek case PT_LIMITPRIV: 3254*0209230bSgjelinek if ((err = zonecfg_set_limitpriv(handle, NULL)) != Z_OK) 3255*0209230bSgjelinek z_cmd_rt_perror(CMD_CLEAR, RT_LIMITPRIV, err, TRUE); 3256*0209230bSgjelinek else 3257*0209230bSgjelinek need_to_commit = TRUE; 3258*0209230bSgjelinek return; 3259*0209230bSgjelinek case PT_BOOTARGS: 3260*0209230bSgjelinek if ((err = zonecfg_set_bootargs(handle, NULL)) != Z_OK) 3261*0209230bSgjelinek z_cmd_rt_perror(CMD_CLEAR, RT_BOOTARGS, err, TRUE); 3262*0209230bSgjelinek else 3263*0209230bSgjelinek need_to_commit = TRUE; 3264*0209230bSgjelinek return; 3265*0209230bSgjelinek case PT_SCHED: 3266*0209230bSgjelinek if ((err = zonecfg_set_sched(handle, NULL)) != Z_OK) 3267*0209230bSgjelinek z_cmd_rt_perror(CMD_CLEAR, RT_SCHED, err, TRUE); 3268*0209230bSgjelinek else 3269*0209230bSgjelinek need_to_commit = TRUE; 3270*0209230bSgjelinek return; 3271*0209230bSgjelinek case PT_MAXLWPS: 3272*0209230bSgjelinek remove_aliased_rctl(PT_MAXLWPS, ALIAS_MAXLWPS); 3273*0209230bSgjelinek return; 3274*0209230bSgjelinek case PT_MAXSHMMEM: 3275*0209230bSgjelinek remove_aliased_rctl(PT_MAXSHMMEM, ALIAS_MAXSHMMEM); 3276*0209230bSgjelinek return; 3277*0209230bSgjelinek case PT_MAXSHMIDS: 3278*0209230bSgjelinek remove_aliased_rctl(PT_MAXSHMIDS, ALIAS_MAXSHMIDS); 3279*0209230bSgjelinek return; 3280*0209230bSgjelinek case PT_MAXMSGIDS: 3281*0209230bSgjelinek remove_aliased_rctl(PT_MAXMSGIDS, ALIAS_MAXMSGIDS); 3282*0209230bSgjelinek return; 3283*0209230bSgjelinek case PT_MAXSEMIDS: 3284*0209230bSgjelinek remove_aliased_rctl(PT_MAXSEMIDS, ALIAS_MAXSEMIDS); 3285*0209230bSgjelinek return; 3286*0209230bSgjelinek case PT_SHARES: 3287*0209230bSgjelinek remove_aliased_rctl(PT_SHARES, ALIAS_SHARES); 3288*0209230bSgjelinek return; 3289*0209230bSgjelinek default: 3290*0209230bSgjelinek zone_perror(pt_to_str(type), Z_NO_PROPERTY_TYPE, TRUE); 3291*0209230bSgjelinek long_usage(CMD_CLEAR, TRUE); 3292*0209230bSgjelinek usage(FALSE, HELP_PROPS); 3293*0209230bSgjelinek return; 3294*0209230bSgjelinek } 3295*0209230bSgjelinek } 3296*0209230bSgjelinek 3297*0209230bSgjelinek void 3298*0209230bSgjelinek clear_func(cmd_t *cmd) 3299*0209230bSgjelinek { 3300*0209230bSgjelinek if (zone_is_read_only(CMD_CLEAR)) 3301*0209230bSgjelinek return; 3302*0209230bSgjelinek 3303*0209230bSgjelinek assert(cmd != NULL); 3304*0209230bSgjelinek 3305*0209230bSgjelinek if (global_scope) { 3306*0209230bSgjelinek if (gz_invalid_property(cmd->cmd_res_type)) { 3307*0209230bSgjelinek zerr(gettext("%s is not a valid property for the " 3308*0209230bSgjelinek "global zone."), pt_to_str(cmd->cmd_res_type)); 3309*0209230bSgjelinek saw_error = TRUE; 3310*0209230bSgjelinek return; 3311*0209230bSgjelinek } 3312*0209230bSgjelinek 3313*0209230bSgjelinek clear_global(cmd); 3314*0209230bSgjelinek } else { 3315*0209230bSgjelinek clear_property(cmd); 3316*0209230bSgjelinek } 33177c478bd9Sstevel@tonic-gate } 33187c478bd9Sstevel@tonic-gate 33197c478bd9Sstevel@tonic-gate void 33207c478bd9Sstevel@tonic-gate select_func(cmd_t *cmd) 33217c478bd9Sstevel@tonic-gate { 3322*0209230bSgjelinek int type, err, res; 3323*0209230bSgjelinek uint64_t limit; 33247c478bd9Sstevel@tonic-gate 33257c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_SELECT)) 33267c478bd9Sstevel@tonic-gate return; 33277c478bd9Sstevel@tonic-gate 33287c478bd9Sstevel@tonic-gate assert(cmd != NULL); 33297c478bd9Sstevel@tonic-gate 33307c478bd9Sstevel@tonic-gate if (global_scope) { 33317c478bd9Sstevel@tonic-gate global_scope = FALSE; 33327c478bd9Sstevel@tonic-gate resource_scope = cmd->cmd_res_type; 33337c478bd9Sstevel@tonic-gate end_op = CMD_SELECT; 33347c478bd9Sstevel@tonic-gate } else { 33357c478bd9Sstevel@tonic-gate scope_usage(CMD_SELECT); 33367c478bd9Sstevel@tonic-gate return; 33377c478bd9Sstevel@tonic-gate } 33387c478bd9Sstevel@tonic-gate 33397c478bd9Sstevel@tonic-gate if ((type = cmd->cmd_res_type) == RT_UNKNOWN) { 33407c478bd9Sstevel@tonic-gate long_usage(CMD_SELECT, TRUE); 33417c478bd9Sstevel@tonic-gate return; 33427c478bd9Sstevel@tonic-gate } 33437c478bd9Sstevel@tonic-gate 33447c478bd9Sstevel@tonic-gate if (initialize(TRUE) != Z_OK) 33457c478bd9Sstevel@tonic-gate return; 33467c478bd9Sstevel@tonic-gate 33477c478bd9Sstevel@tonic-gate switch (type) { 33487c478bd9Sstevel@tonic-gate case RT_FS: 33497c478bd9Sstevel@tonic-gate if ((err = fill_in_fstab(cmd, &old_fstab, FALSE)) != Z_OK) { 33507c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_SELECT, RT_FS, err, TRUE); 33517c478bd9Sstevel@tonic-gate global_scope = TRUE; 33527c478bd9Sstevel@tonic-gate } 33537c478bd9Sstevel@tonic-gate bcopy(&old_fstab, &in_progress_fstab, 33547c478bd9Sstevel@tonic-gate sizeof (struct zone_fstab)); 33557c478bd9Sstevel@tonic-gate return; 33567c478bd9Sstevel@tonic-gate case RT_IPD: 3357087719fdSdp if (state_atleast(ZONE_STATE_INCOMPLETE)) { 33587c478bd9Sstevel@tonic-gate zerr(gettext("Zone %s not in %s state; %s %s not " 33597c478bd9Sstevel@tonic-gate "allowed."), zone, 33607c478bd9Sstevel@tonic-gate zone_state_str(ZONE_STATE_CONFIGURED), 33617c478bd9Sstevel@tonic-gate cmd_to_str(CMD_SELECT), rt_to_str(RT_IPD)); 33627c478bd9Sstevel@tonic-gate global_scope = TRUE; 33637c478bd9Sstevel@tonic-gate end_op = -1; 33647c478bd9Sstevel@tonic-gate return; 33657c478bd9Sstevel@tonic-gate } 33667c478bd9Sstevel@tonic-gate if ((err = fill_in_ipdtab(cmd, &old_ipdtab, FALSE)) != Z_OK) { 33677c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_SELECT, RT_IPD, err, TRUE); 33687c478bd9Sstevel@tonic-gate global_scope = TRUE; 33697c478bd9Sstevel@tonic-gate } 33707c478bd9Sstevel@tonic-gate bcopy(&old_ipdtab, &in_progress_ipdtab, 33717c478bd9Sstevel@tonic-gate sizeof (struct zone_fstab)); 33727c478bd9Sstevel@tonic-gate return; 33737c478bd9Sstevel@tonic-gate case RT_NET: 33747c478bd9Sstevel@tonic-gate if ((err = fill_in_nwiftab(cmd, &old_nwiftab, FALSE)) != Z_OK) { 33757c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_SELECT, RT_NET, err, TRUE); 33767c478bd9Sstevel@tonic-gate global_scope = TRUE; 33777c478bd9Sstevel@tonic-gate } 33787c478bd9Sstevel@tonic-gate bcopy(&old_nwiftab, &in_progress_nwiftab, 33797c478bd9Sstevel@tonic-gate sizeof (struct zone_nwiftab)); 33807c478bd9Sstevel@tonic-gate return; 33817c478bd9Sstevel@tonic-gate case RT_DEVICE: 33827c478bd9Sstevel@tonic-gate if ((err = fill_in_devtab(cmd, &old_devtab, FALSE)) != Z_OK) { 33837c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_SELECT, RT_DEVICE, err, TRUE); 33847c478bd9Sstevel@tonic-gate global_scope = TRUE; 33857c478bd9Sstevel@tonic-gate } 33867c478bd9Sstevel@tonic-gate bcopy(&old_devtab, &in_progress_devtab, 33877c478bd9Sstevel@tonic-gate sizeof (struct zone_devtab)); 33887c478bd9Sstevel@tonic-gate return; 33897c478bd9Sstevel@tonic-gate case RT_RCTL: 33907c478bd9Sstevel@tonic-gate if ((err = fill_in_rctltab(cmd, &old_rctltab, FALSE)) != Z_OK) { 33917c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_SELECT, RT_RCTL, err, TRUE); 33927c478bd9Sstevel@tonic-gate global_scope = TRUE; 33937c478bd9Sstevel@tonic-gate } 33947c478bd9Sstevel@tonic-gate bcopy(&old_rctltab, &in_progress_rctltab, 33957c478bd9Sstevel@tonic-gate sizeof (struct zone_rctltab)); 33967c478bd9Sstevel@tonic-gate return; 33977c478bd9Sstevel@tonic-gate case RT_ATTR: 33987c478bd9Sstevel@tonic-gate if ((err = fill_in_attrtab(cmd, &old_attrtab, FALSE)) != Z_OK) { 33997c478bd9Sstevel@tonic-gate z_cmd_rt_perror(CMD_SELECT, RT_ATTR, err, TRUE); 34007c478bd9Sstevel@tonic-gate global_scope = TRUE; 34017c478bd9Sstevel@tonic-gate } 34027c478bd9Sstevel@tonic-gate bcopy(&old_attrtab, &in_progress_attrtab, 34037c478bd9Sstevel@tonic-gate sizeof (struct zone_attrtab)); 34047c478bd9Sstevel@tonic-gate return; 3405fa9e4066Sahrens case RT_DATASET: 3406fa9e4066Sahrens if ((err = fill_in_dstab(cmd, &old_dstab, FALSE)) != Z_OK) { 3407fa9e4066Sahrens z_cmd_rt_perror(CMD_SELECT, RT_DATASET, err, TRUE); 3408fa9e4066Sahrens global_scope = TRUE; 3409fa9e4066Sahrens } 3410fa9e4066Sahrens bcopy(&old_dstab, &in_progress_dstab, 3411fa9e4066Sahrens sizeof (struct zone_dstab)); 3412fa9e4066Sahrens return; 3413*0209230bSgjelinek case RT_DCPU: 3414*0209230bSgjelinek if ((err = zonecfg_lookup_pset(handle, &old_psettab)) != Z_OK) { 3415*0209230bSgjelinek z_cmd_rt_perror(CMD_SELECT, RT_DCPU, err, TRUE); 3416*0209230bSgjelinek global_scope = TRUE; 3417*0209230bSgjelinek } 3418*0209230bSgjelinek bcopy(&old_psettab, &in_progress_psettab, 3419*0209230bSgjelinek sizeof (struct zone_psettab)); 3420*0209230bSgjelinek return; 3421*0209230bSgjelinek case RT_MCAP: 3422*0209230bSgjelinek /* if none of these exist, there is no resource to select */ 3423*0209230bSgjelinek if ((res = zonecfg_lookup_mcap(handle, &old_mcaptab)) != Z_OK && 3424*0209230bSgjelinek zonecfg_get_aliased_rctl(handle, ALIAS_MAXSWAP, &limit) 3425*0209230bSgjelinek != Z_OK && 3426*0209230bSgjelinek zonecfg_get_aliased_rctl(handle, ALIAS_MAXLOCKEDMEM, &limit) 3427*0209230bSgjelinek != Z_OK) { 3428*0209230bSgjelinek z_cmd_rt_perror(CMD_SELECT, RT_MCAP, Z_NO_RESOURCE_TYPE, 3429*0209230bSgjelinek TRUE); 3430*0209230bSgjelinek global_scope = TRUE; 3431*0209230bSgjelinek } 3432*0209230bSgjelinek if (res == Z_OK) 3433*0209230bSgjelinek bcopy(&old_mcaptab, &in_progress_mcaptab, 3434*0209230bSgjelinek sizeof (struct zone_mcaptab)); 3435*0209230bSgjelinek else 3436*0209230bSgjelinek bzero(&in_progress_mcaptab, 3437*0209230bSgjelinek sizeof (in_progress_mcaptab)); 3438*0209230bSgjelinek return; 34397c478bd9Sstevel@tonic-gate default: 34407c478bd9Sstevel@tonic-gate zone_perror(rt_to_str(type), Z_NO_RESOURCE_TYPE, TRUE); 34417c478bd9Sstevel@tonic-gate long_usage(CMD_SELECT, TRUE); 34427c478bd9Sstevel@tonic-gate usage(FALSE, HELP_RESOURCES); 34437c478bd9Sstevel@tonic-gate return; 34447c478bd9Sstevel@tonic-gate } 34457c478bd9Sstevel@tonic-gate } 34467c478bd9Sstevel@tonic-gate 34477c478bd9Sstevel@tonic-gate /* 34487c478bd9Sstevel@tonic-gate * Network "addresses" can be one of the following forms: 34497c478bd9Sstevel@tonic-gate * <IPv4 address> 34507c478bd9Sstevel@tonic-gate * <IPv4 address>/<prefix length> 34517c478bd9Sstevel@tonic-gate * <IPv6 address>/<prefix length> 34527c478bd9Sstevel@tonic-gate * <host name> 34537c478bd9Sstevel@tonic-gate * <host name>/<prefix length> 34547c478bd9Sstevel@tonic-gate * In other words, the "/" followed by a prefix length is allowed but not 34557c478bd9Sstevel@tonic-gate * required for IPv4 addresses and host names, and required for IPv6 addresses. 34567c478bd9Sstevel@tonic-gate * If a prefix length is given, it must be in the allowable range: 0 to 32 for 34577c478bd9Sstevel@tonic-gate * IPv4 addresses and host names, 0 to 128 for IPv6 addresses. 34587c478bd9Sstevel@tonic-gate * Host names must start with an alpha-numeric character, and all subsequent 34597c478bd9Sstevel@tonic-gate * characters must be either alpha-numeric or "-". 34607c478bd9Sstevel@tonic-gate */ 34617c478bd9Sstevel@tonic-gate 34627c478bd9Sstevel@tonic-gate static int 34637c478bd9Sstevel@tonic-gate validate_net_address_syntax(char *address) 34647c478bd9Sstevel@tonic-gate { 34657c478bd9Sstevel@tonic-gate char *slashp, part1[MAXHOSTNAMELEN]; 34667c478bd9Sstevel@tonic-gate struct in6_addr in6; 34677c478bd9Sstevel@tonic-gate struct in_addr in4; 34687c478bd9Sstevel@tonic-gate int prefixlen, i; 34697c478bd9Sstevel@tonic-gate 34707c478bd9Sstevel@tonic-gate /* 34717c478bd9Sstevel@tonic-gate * Copy the part before any '/' into part1 or copy the whole 34727c478bd9Sstevel@tonic-gate * thing if there is no '/'. 34737c478bd9Sstevel@tonic-gate */ 34747c478bd9Sstevel@tonic-gate if ((slashp = strchr(address, '/')) != NULL) { 34757c478bd9Sstevel@tonic-gate *slashp = '\0'; 34767c478bd9Sstevel@tonic-gate (void) strlcpy(part1, address, sizeof (part1)); 34777c478bd9Sstevel@tonic-gate *slashp = '/'; 34787c478bd9Sstevel@tonic-gate prefixlen = atoi(++slashp); 34797c478bd9Sstevel@tonic-gate } else { 34807c478bd9Sstevel@tonic-gate (void) strlcpy(part1, address, sizeof (part1)); 34817c478bd9Sstevel@tonic-gate } 34827c478bd9Sstevel@tonic-gate 34837c478bd9Sstevel@tonic-gate if (inet_pton(AF_INET6, part1, &in6) == 1) { 34847c478bd9Sstevel@tonic-gate if (slashp == NULL) { 34857c478bd9Sstevel@tonic-gate zerr(gettext("%s: IPv6 addresses " 34867c478bd9Sstevel@tonic-gate "require /prefix-length suffix."), address); 34877c478bd9Sstevel@tonic-gate return (Z_ERR); 34887c478bd9Sstevel@tonic-gate } 34897c478bd9Sstevel@tonic-gate if (prefixlen < 0 || prefixlen > 128) { 34907c478bd9Sstevel@tonic-gate zerr(gettext("%s: IPv6 address " 34917c478bd9Sstevel@tonic-gate "prefix lengths must be 0 - 128."), address); 34927c478bd9Sstevel@tonic-gate return (Z_ERR); 34937c478bd9Sstevel@tonic-gate } 34947c478bd9Sstevel@tonic-gate return (Z_OK); 34957c478bd9Sstevel@tonic-gate } 34967c478bd9Sstevel@tonic-gate 34977c478bd9Sstevel@tonic-gate /* At this point, any /prefix must be for IPv4. */ 34987c478bd9Sstevel@tonic-gate if (slashp != NULL) { 34997c478bd9Sstevel@tonic-gate if (prefixlen < 0 || prefixlen > 32) { 35007c478bd9Sstevel@tonic-gate zerr(gettext("%s: IPv4 address " 35017c478bd9Sstevel@tonic-gate "prefix lengths must be 0 - 32."), address); 35027c478bd9Sstevel@tonic-gate return (Z_ERR); 35037c478bd9Sstevel@tonic-gate } 35047c478bd9Sstevel@tonic-gate } 35057c478bd9Sstevel@tonic-gate if (inet_pton(AF_INET, part1, &in4) == 1) 35067c478bd9Sstevel@tonic-gate return (Z_OK); 35077c478bd9Sstevel@tonic-gate 35087c478bd9Sstevel@tonic-gate /* address may also be a host name */ 35097c478bd9Sstevel@tonic-gate if (!isalnum(part1[0])) { 35107c478bd9Sstevel@tonic-gate zerr(gettext("%s: bogus host name or network address syntax"), 35117c478bd9Sstevel@tonic-gate part1); 35127c478bd9Sstevel@tonic-gate saw_error = TRUE; 35137c478bd9Sstevel@tonic-gate usage(FALSE, HELP_NETADDR); 35147c478bd9Sstevel@tonic-gate return (Z_ERR); 35157c478bd9Sstevel@tonic-gate } 35167c478bd9Sstevel@tonic-gate for (i = 1; part1[i]; i++) 35177c478bd9Sstevel@tonic-gate if (!isalnum(part1[i]) && part1[i] != '-' && part1[i] != '.') { 35187c478bd9Sstevel@tonic-gate zerr(gettext("%s: bogus host name or " 35197c478bd9Sstevel@tonic-gate "network address syntax"), part1); 35207c478bd9Sstevel@tonic-gate saw_error = TRUE; 35217c478bd9Sstevel@tonic-gate usage(FALSE, HELP_NETADDR); 35227c478bd9Sstevel@tonic-gate return (Z_ERR); 35237c478bd9Sstevel@tonic-gate } 35247c478bd9Sstevel@tonic-gate return (Z_OK); 35257c478bd9Sstevel@tonic-gate } 35267c478bd9Sstevel@tonic-gate 35277c478bd9Sstevel@tonic-gate static int 35287c478bd9Sstevel@tonic-gate validate_net_physical_syntax(char *ifname) 35297c478bd9Sstevel@tonic-gate { 35307c478bd9Sstevel@tonic-gate if (strchr(ifname, ':') == NULL) 35317c478bd9Sstevel@tonic-gate return (Z_OK); 35327c478bd9Sstevel@tonic-gate zerr(gettext("%s: physical interface name required; " 35337c478bd9Sstevel@tonic-gate "logical interface name not allowed"), ifname); 35347c478bd9Sstevel@tonic-gate return (Z_ERR); 35357c478bd9Sstevel@tonic-gate } 35367c478bd9Sstevel@tonic-gate 35377c478bd9Sstevel@tonic-gate static boolean_t 35387c478bd9Sstevel@tonic-gate valid_fs_type(const char *type) 35397c478bd9Sstevel@tonic-gate { 35407c478bd9Sstevel@tonic-gate /* 35417c478bd9Sstevel@tonic-gate * Is this a valid path component? 35427c478bd9Sstevel@tonic-gate */ 35437c478bd9Sstevel@tonic-gate if (strlen(type) + 1 > MAXNAMELEN) 35447c478bd9Sstevel@tonic-gate return (B_FALSE); 35457c478bd9Sstevel@tonic-gate /* 35467c478bd9Sstevel@tonic-gate * Make sure a bad value for "type" doesn't make 35477c478bd9Sstevel@tonic-gate * /usr/lib/fs/<type>/mount turn into something else. 35487c478bd9Sstevel@tonic-gate */ 35497c478bd9Sstevel@tonic-gate if (strchr(type, '/') != NULL || type[0] == '\0' || 35507c478bd9Sstevel@tonic-gate strcmp(type, ".") == 0 || strcmp(type, "..") == 0) 3551087719fdSdp return (B_FALSE); 35527c478bd9Sstevel@tonic-gate /* 35537c478bd9Sstevel@tonic-gate * More detailed verification happens later by zoneadm(1m). 35547c478bd9Sstevel@tonic-gate */ 35557c478bd9Sstevel@tonic-gate return (B_TRUE); 35567c478bd9Sstevel@tonic-gate } 35577c478bd9Sstevel@tonic-gate 3558*0209230bSgjelinek static void 3559*0209230bSgjelinek set_aliased_rctl(char *alias, int prop_type, char *s) 3560*0209230bSgjelinek { 3561*0209230bSgjelinek uint64_t limit; 3562*0209230bSgjelinek int err; 3563*0209230bSgjelinek char tmp[128]; 3564*0209230bSgjelinek 3565*0209230bSgjelinek if (global_zone && strcmp(alias, ALIAS_SHARES) != 0) 3566*0209230bSgjelinek zerr(gettext("WARNING: Setting a global zone resource " 3567*0209230bSgjelinek "control too low could deny\nservice " 3568*0209230bSgjelinek "to even the root user; " 3569*0209230bSgjelinek "this could render the system impossible\n" 3570*0209230bSgjelinek "to administer. Please use caution.")); 3571*0209230bSgjelinek 3572*0209230bSgjelinek /* convert memory based properties */ 3573*0209230bSgjelinek if (prop_type == PT_MAXSHMMEM) { 3574*0209230bSgjelinek if (!zonecfg_valid_memlimit(s, &limit)) { 3575*0209230bSgjelinek zerr(gettext("A non-negative number with a required " 3576*0209230bSgjelinek "scale suffix (K, M, G or T) was expected\nhere.")); 3577*0209230bSgjelinek saw_error = TRUE; 3578*0209230bSgjelinek return; 3579*0209230bSgjelinek } 3580*0209230bSgjelinek 3581*0209230bSgjelinek (void) snprintf(tmp, sizeof (tmp), "%llu", limit); 3582*0209230bSgjelinek s = tmp; 3583*0209230bSgjelinek } 3584*0209230bSgjelinek 3585*0209230bSgjelinek if (!zonecfg_aliased_rctl_ok(handle, alias)) { 3586*0209230bSgjelinek zone_perror(pt_to_str(prop_type), Z_ALIAS_DISALLOW, FALSE); 3587*0209230bSgjelinek saw_error = TRUE; 3588*0209230bSgjelinek } else if (!zonecfg_valid_alias_limit(alias, s, &limit)) { 3589*0209230bSgjelinek zerr(gettext("%s property is out of range."), 3590*0209230bSgjelinek pt_to_str(prop_type)); 3591*0209230bSgjelinek saw_error = TRUE; 3592*0209230bSgjelinek } else if ((err = zonecfg_set_aliased_rctl(handle, alias, limit)) 3593*0209230bSgjelinek != Z_OK) { 3594*0209230bSgjelinek zone_perror(zone, err, TRUE); 3595*0209230bSgjelinek saw_error = TRUE; 3596*0209230bSgjelinek } else { 3597*0209230bSgjelinek need_to_commit = TRUE; 3598*0209230bSgjelinek } 3599*0209230bSgjelinek } 3600*0209230bSgjelinek 36017c478bd9Sstevel@tonic-gate void 36027c478bd9Sstevel@tonic-gate set_func(cmd_t *cmd) 36037c478bd9Sstevel@tonic-gate { 36047c478bd9Sstevel@tonic-gate char *prop_id; 3605555afedfScarlsonj int arg, err, res_type, prop_type; 36067c478bd9Sstevel@tonic-gate property_value_ptr_t pp; 36077c478bd9Sstevel@tonic-gate boolean_t autoboot; 3608555afedfScarlsonj boolean_t force_set = FALSE; 3609*0209230bSgjelinek size_t physmem_size = sizeof (in_progress_mcaptab.zone_physmem_cap); 3610*0209230bSgjelinek uint64_t mem_cap, mem_limit; 3611*0209230bSgjelinek struct zone_psettab tmp_psettab; 36127c478bd9Sstevel@tonic-gate 36137c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_SET)) 36147c478bd9Sstevel@tonic-gate return; 36157c478bd9Sstevel@tonic-gate 36167c478bd9Sstevel@tonic-gate assert(cmd != NULL); 36177c478bd9Sstevel@tonic-gate 3618555afedfScarlsonj optind = opterr = 0; 3619555afedfScarlsonj while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "F")) != EOF) { 3620555afedfScarlsonj switch (arg) { 3621555afedfScarlsonj case 'F': 3622555afedfScarlsonj force_set = TRUE; 3623555afedfScarlsonj break; 3624555afedfScarlsonj default: 3625555afedfScarlsonj if (optopt == '?') 3626555afedfScarlsonj longer_usage(CMD_SET); 3627555afedfScarlsonj else 3628555afedfScarlsonj short_usage(CMD_SET); 3629555afedfScarlsonj return; 3630555afedfScarlsonj } 3631555afedfScarlsonj } 3632555afedfScarlsonj 36337c478bd9Sstevel@tonic-gate prop_type = cmd->cmd_prop_name[0]; 36347c478bd9Sstevel@tonic-gate if (global_scope) { 3635*0209230bSgjelinek if (gz_invalid_property(prop_type)) { 3636*0209230bSgjelinek zerr(gettext("%s is not a valid property for the " 3637*0209230bSgjelinek "global zone."), pt_to_str(prop_type)); 3638*0209230bSgjelinek saw_error = TRUE; 3639*0209230bSgjelinek return; 3640*0209230bSgjelinek } 3641*0209230bSgjelinek 3642087719fdSdp if (prop_type == PT_ZONENAME) { 3643087719fdSdp res_type = RT_ZONENAME; 3644087719fdSdp } else if (prop_type == PT_ZONEPATH) { 36457c478bd9Sstevel@tonic-gate res_type = RT_ZONEPATH; 36467c478bd9Sstevel@tonic-gate } else if (prop_type == PT_AUTOBOOT) { 36477c478bd9Sstevel@tonic-gate res_type = RT_AUTOBOOT; 36489acbbeafSnn } else if (prop_type == PT_BRAND) { 36499acbbeafSnn res_type = RT_BRAND; 36507c478bd9Sstevel@tonic-gate } else if (prop_type == PT_POOL) { 36517c478bd9Sstevel@tonic-gate res_type = RT_POOL; 3652ffbafc53Scomay } else if (prop_type == PT_LIMITPRIV) { 3653ffbafc53Scomay res_type = RT_LIMITPRIV; 36543f2f09c1Sdp } else if (prop_type == PT_BOOTARGS) { 36553f2f09c1Sdp res_type = RT_BOOTARGS; 3656*0209230bSgjelinek } else if (prop_type == PT_SCHED) { 3657*0209230bSgjelinek res_type = RT_SCHED; 3658*0209230bSgjelinek } else if (prop_type == PT_MAXLWPS) { 3659*0209230bSgjelinek res_type = RT_MAXLWPS; 3660*0209230bSgjelinek } else if (prop_type == PT_MAXSHMMEM) { 3661*0209230bSgjelinek res_type = RT_MAXSHMMEM; 3662*0209230bSgjelinek } else if (prop_type == PT_MAXSHMIDS) { 3663*0209230bSgjelinek res_type = RT_MAXSHMIDS; 3664*0209230bSgjelinek } else if (prop_type == PT_MAXMSGIDS) { 3665*0209230bSgjelinek res_type = RT_MAXMSGIDS; 3666*0209230bSgjelinek } else if (prop_type == PT_MAXSEMIDS) { 3667*0209230bSgjelinek res_type = RT_MAXSEMIDS; 3668*0209230bSgjelinek } else if (prop_type == PT_SHARES) { 3669*0209230bSgjelinek res_type = RT_SHARES; 36707c478bd9Sstevel@tonic-gate } else { 36717c478bd9Sstevel@tonic-gate zerr(gettext("Cannot set a resource-specific property " 36727c478bd9Sstevel@tonic-gate "from the global scope.")); 36737c478bd9Sstevel@tonic-gate saw_error = TRUE; 36747c478bd9Sstevel@tonic-gate return; 36757c478bd9Sstevel@tonic-gate } 36767c478bd9Sstevel@tonic-gate } else { 36777c478bd9Sstevel@tonic-gate res_type = resource_scope; 36787c478bd9Sstevel@tonic-gate } 36797c478bd9Sstevel@tonic-gate 3680555afedfScarlsonj if (force_set) { 3681555afedfScarlsonj if (res_type != RT_ZONEPATH) { 3682555afedfScarlsonj zerr(gettext("Only zonepath setting can be forced.")); 3683555afedfScarlsonj saw_error = TRUE; 3684555afedfScarlsonj return; 3685555afedfScarlsonj } 3686555afedfScarlsonj if (!zonecfg_in_alt_root()) { 3687555afedfScarlsonj zerr(gettext("Zonepath is changeable only in an " 3688555afedfScarlsonj "alternate root.")); 3689555afedfScarlsonj saw_error = TRUE; 3690555afedfScarlsonj return; 3691555afedfScarlsonj } 3692555afedfScarlsonj } 3693555afedfScarlsonj 36947c478bd9Sstevel@tonic-gate pp = cmd->cmd_property_ptr[0]; 36957c478bd9Sstevel@tonic-gate /* 36967c478bd9Sstevel@tonic-gate * A nasty expression but not that complicated: 36977c478bd9Sstevel@tonic-gate * 1. fs options are simple or list (tested below) 36987c478bd9Sstevel@tonic-gate * 2. rctl value's are complex or list (tested below) 36997c478bd9Sstevel@tonic-gate * Anything else should be simple. 37007c478bd9Sstevel@tonic-gate */ 37017c478bd9Sstevel@tonic-gate if (!(res_type == RT_FS && prop_type == PT_OPTIONS) && 37027c478bd9Sstevel@tonic-gate !(res_type == RT_RCTL && prop_type == PT_VALUE) && 37037c478bd9Sstevel@tonic-gate (pp->pv_type != PROP_VAL_SIMPLE || 37047c478bd9Sstevel@tonic-gate (prop_id = pp->pv_simple) == NULL)) { 37057c478bd9Sstevel@tonic-gate zerr(gettext("A %s value was expected here."), 37067c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_SIMPLE)); 37077c478bd9Sstevel@tonic-gate saw_error = TRUE; 37087c478bd9Sstevel@tonic-gate return; 37097c478bd9Sstevel@tonic-gate } 37107c478bd9Sstevel@tonic-gate if (prop_type == PT_UNKNOWN) { 37117c478bd9Sstevel@tonic-gate long_usage(CMD_SET, TRUE); 37127c478bd9Sstevel@tonic-gate return; 37137c478bd9Sstevel@tonic-gate } 37147c478bd9Sstevel@tonic-gate 3715087719fdSdp /* 3716087719fdSdp * Special case: the user can change the zone name prior to 'create'; 3717087719fdSdp * if the zone already exists, we fall through letting initialize() 3718087719fdSdp * and the rest of the logic run. 3719087719fdSdp */ 3720087719fdSdp if (res_type == RT_ZONENAME && got_handle == FALSE && 3721087719fdSdp !state_atleast(ZONE_STATE_CONFIGURED)) { 3722fb03efaaSdp if ((err = zonecfg_validate_zonename(prop_id)) != Z_OK) { 3723fb03efaaSdp zone_perror(prop_id, err, TRUE); 3724fb03efaaSdp usage(FALSE, HELP_SYNTAX); 3725fb03efaaSdp return; 3726fb03efaaSdp } 3727087719fdSdp (void) strlcpy(zone, prop_id, sizeof (zone)); 3728087719fdSdp return; 3729087719fdSdp } 3730087719fdSdp 37317c478bd9Sstevel@tonic-gate if (initialize(TRUE) != Z_OK) 37327c478bd9Sstevel@tonic-gate return; 37337c478bd9Sstevel@tonic-gate 37347c478bd9Sstevel@tonic-gate switch (res_type) { 3735087719fdSdp case RT_ZONENAME: 3736087719fdSdp if ((err = zonecfg_set_name(handle, prop_id)) != Z_OK) { 3737087719fdSdp /* 3738087719fdSdp * Use prop_id instead of 'zone' here, since we're 3739087719fdSdp * reporting a problem about the *new* zonename. 3740087719fdSdp */ 3741087719fdSdp zone_perror(prop_id, err, TRUE); 3742fb03efaaSdp usage(FALSE, HELP_SYNTAX); 3743087719fdSdp } else { 3744087719fdSdp need_to_commit = TRUE; 3745087719fdSdp (void) strlcpy(zone, prop_id, sizeof (zone)); 3746087719fdSdp } 3747087719fdSdp return; 37487c478bd9Sstevel@tonic-gate case RT_ZONEPATH: 3749555afedfScarlsonj if (!force_set && state_atleast(ZONE_STATE_INSTALLED)) { 37507c478bd9Sstevel@tonic-gate zerr(gettext("Zone %s already installed; %s %s not " 37517c478bd9Sstevel@tonic-gate "allowed."), zone, cmd_to_str(CMD_SET), 37527c478bd9Sstevel@tonic-gate rt_to_str(RT_ZONEPATH)); 37537c478bd9Sstevel@tonic-gate return; 37547c478bd9Sstevel@tonic-gate } 37557c478bd9Sstevel@tonic-gate if (validate_zonepath_syntax(prop_id) != Z_OK) { 37567c478bd9Sstevel@tonic-gate saw_error = TRUE; 37577c478bd9Sstevel@tonic-gate return; 37587c478bd9Sstevel@tonic-gate } 37597c478bd9Sstevel@tonic-gate if ((err = zonecfg_set_zonepath(handle, prop_id)) != Z_OK) 37607c478bd9Sstevel@tonic-gate zone_perror(zone, err, TRUE); 37617c478bd9Sstevel@tonic-gate else 37627c478bd9Sstevel@tonic-gate need_to_commit = TRUE; 37637c478bd9Sstevel@tonic-gate return; 37649acbbeafSnn case RT_BRAND: 37659acbbeafSnn if (state_atleast(ZONE_STATE_INSTALLED)) { 37669acbbeafSnn zerr(gettext("Zone %s already installed; %s %s not " 37679acbbeafSnn "allowed."), zone, cmd_to_str(CMD_SET), 37689acbbeafSnn rt_to_str(RT_BRAND)); 37699acbbeafSnn return; 37709acbbeafSnn } 37719acbbeafSnn if ((err = zonecfg_set_brand(handle, prop_id)) != Z_OK) 37729acbbeafSnn zone_perror(zone, err, TRUE); 37739acbbeafSnn else 37749acbbeafSnn need_to_commit = TRUE; 37759acbbeafSnn return; 37767c478bd9Sstevel@tonic-gate case RT_AUTOBOOT: 37777c478bd9Sstevel@tonic-gate if (strcmp(prop_id, "true") == 0) { 37787c478bd9Sstevel@tonic-gate autoboot = B_TRUE; 37797c478bd9Sstevel@tonic-gate } else if (strcmp(prop_id, "false") == 0) { 37807c478bd9Sstevel@tonic-gate autoboot = B_FALSE; 37817c478bd9Sstevel@tonic-gate } else { 37827c478bd9Sstevel@tonic-gate zerr(gettext("%s value must be '%s' or '%s'."), 37837c478bd9Sstevel@tonic-gate pt_to_str(PT_AUTOBOOT), "true", "false"); 37847c478bd9Sstevel@tonic-gate saw_error = TRUE; 37857c478bd9Sstevel@tonic-gate return; 37867c478bd9Sstevel@tonic-gate } 37877c478bd9Sstevel@tonic-gate if ((err = zonecfg_set_autoboot(handle, autoboot)) != Z_OK) 37887c478bd9Sstevel@tonic-gate zone_perror(zone, err, TRUE); 37897c478bd9Sstevel@tonic-gate else 37907c478bd9Sstevel@tonic-gate need_to_commit = TRUE; 37917c478bd9Sstevel@tonic-gate return; 37927c478bd9Sstevel@tonic-gate case RT_POOL: 3793*0209230bSgjelinek /* don't allow use of the reserved temporary pool names */ 3794*0209230bSgjelinek if (strncmp("SUNW", prop_id, 4) == 0) { 3795*0209230bSgjelinek zerr(gettext("pool names starting with SUNW are " 3796*0209230bSgjelinek "reserved.")); 3797*0209230bSgjelinek saw_error = TRUE; 3798*0209230bSgjelinek return; 3799*0209230bSgjelinek } 3800*0209230bSgjelinek 3801*0209230bSgjelinek /* can't set pool if dedicated-cpu exists */ 3802*0209230bSgjelinek if (zonecfg_lookup_pset(handle, &tmp_psettab) == Z_OK) { 3803*0209230bSgjelinek zerr(gettext("The %s resource already exists. " 3804*0209230bSgjelinek "A persistent pool is incompatible\nwith the %s " 3805*0209230bSgjelinek "resource."), rt_to_str(RT_DCPU), 3806*0209230bSgjelinek rt_to_str(RT_DCPU)); 3807*0209230bSgjelinek saw_error = TRUE; 3808*0209230bSgjelinek return; 3809*0209230bSgjelinek } 3810*0209230bSgjelinek 38117c478bd9Sstevel@tonic-gate if ((err = zonecfg_set_pool(handle, prop_id)) != Z_OK) 38127c478bd9Sstevel@tonic-gate zone_perror(zone, err, TRUE); 38137c478bd9Sstevel@tonic-gate else 38147c478bd9Sstevel@tonic-gate need_to_commit = TRUE; 38157c478bd9Sstevel@tonic-gate return; 3816ffbafc53Scomay case RT_LIMITPRIV: 3817ffbafc53Scomay if ((err = zonecfg_set_limitpriv(handle, prop_id)) != Z_OK) 3818ffbafc53Scomay zone_perror(zone, err, TRUE); 3819ffbafc53Scomay else 3820ffbafc53Scomay need_to_commit = TRUE; 3821ffbafc53Scomay return; 38223f2f09c1Sdp case RT_BOOTARGS: 38233f2f09c1Sdp if ((err = zonecfg_set_bootargs(handle, prop_id)) != Z_OK) 38243f2f09c1Sdp zone_perror(zone, err, TRUE); 38253f2f09c1Sdp else 38263f2f09c1Sdp need_to_commit = TRUE; 38273f2f09c1Sdp return; 3828*0209230bSgjelinek case RT_SCHED: 3829*0209230bSgjelinek if ((err = zonecfg_set_sched(handle, prop_id)) != Z_OK) 3830*0209230bSgjelinek zone_perror(zone, err, TRUE); 3831*0209230bSgjelinek else 3832*0209230bSgjelinek need_to_commit = TRUE; 3833*0209230bSgjelinek return; 3834*0209230bSgjelinek case RT_MAXLWPS: 3835*0209230bSgjelinek set_aliased_rctl(ALIAS_MAXLWPS, prop_type, prop_id); 3836*0209230bSgjelinek return; 3837*0209230bSgjelinek case RT_MAXSHMMEM: 3838*0209230bSgjelinek set_aliased_rctl(ALIAS_MAXSHMMEM, prop_type, prop_id); 3839*0209230bSgjelinek return; 3840*0209230bSgjelinek case RT_MAXSHMIDS: 3841*0209230bSgjelinek set_aliased_rctl(ALIAS_MAXSHMIDS, prop_type, prop_id); 3842*0209230bSgjelinek return; 3843*0209230bSgjelinek case RT_MAXMSGIDS: 3844*0209230bSgjelinek set_aliased_rctl(ALIAS_MAXMSGIDS, prop_type, prop_id); 3845*0209230bSgjelinek return; 3846*0209230bSgjelinek case RT_MAXSEMIDS: 3847*0209230bSgjelinek set_aliased_rctl(ALIAS_MAXSEMIDS, prop_type, prop_id); 3848*0209230bSgjelinek return; 3849*0209230bSgjelinek case RT_SHARES: 3850*0209230bSgjelinek set_aliased_rctl(ALIAS_SHARES, prop_type, prop_id); 3851*0209230bSgjelinek return; 38527c478bd9Sstevel@tonic-gate case RT_FS: 38537c478bd9Sstevel@tonic-gate switch (prop_type) { 38547c478bd9Sstevel@tonic-gate case PT_DIR: 38557c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_fstab.zone_fs_dir, prop_id, 38567c478bd9Sstevel@tonic-gate sizeof (in_progress_fstab.zone_fs_dir)); 38577c478bd9Sstevel@tonic-gate return; 38587c478bd9Sstevel@tonic-gate case PT_SPECIAL: 38597c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_fstab.zone_fs_special, 38607c478bd9Sstevel@tonic-gate prop_id, 38617c478bd9Sstevel@tonic-gate sizeof (in_progress_fstab.zone_fs_special)); 38627c478bd9Sstevel@tonic-gate return; 38637c478bd9Sstevel@tonic-gate case PT_RAW: 38647c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_fstab.zone_fs_raw, 38657c478bd9Sstevel@tonic-gate prop_id, sizeof (in_progress_fstab.zone_fs_raw)); 38667c478bd9Sstevel@tonic-gate return; 38677c478bd9Sstevel@tonic-gate case PT_TYPE: 38687c478bd9Sstevel@tonic-gate if (!valid_fs_type(prop_id)) { 38697c478bd9Sstevel@tonic-gate zerr(gettext("\"%s\" is not a valid %s."), 38707c478bd9Sstevel@tonic-gate prop_id, pt_to_str(PT_TYPE)); 38717c478bd9Sstevel@tonic-gate saw_error = TRUE; 38727c478bd9Sstevel@tonic-gate return; 38737c478bd9Sstevel@tonic-gate } 38747c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_fstab.zone_fs_type, prop_id, 38757c478bd9Sstevel@tonic-gate sizeof (in_progress_fstab.zone_fs_type)); 38767c478bd9Sstevel@tonic-gate return; 38777c478bd9Sstevel@tonic-gate case PT_OPTIONS: 38787c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_SIMPLE && 38797c478bd9Sstevel@tonic-gate pp->pv_type != PROP_VAL_LIST) { 38807c478bd9Sstevel@tonic-gate zerr(gettext("A %s or %s value was expected " 38817c478bd9Sstevel@tonic-gate "here."), pvt_to_str(PROP_VAL_SIMPLE), 38827c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_LIST)); 38837c478bd9Sstevel@tonic-gate saw_error = TRUE; 38847c478bd9Sstevel@tonic-gate return; 38857c478bd9Sstevel@tonic-gate } 38867c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list( 38877c478bd9Sstevel@tonic-gate in_progress_fstab.zone_fs_options); 38887c478bd9Sstevel@tonic-gate in_progress_fstab.zone_fs_options = NULL; 38897c478bd9Sstevel@tonic-gate if (!(pp->pv_type == PROP_VAL_LIST && 38907c478bd9Sstevel@tonic-gate pp->pv_list == NULL)) 38917c478bd9Sstevel@tonic-gate add_property(cmd); 38927c478bd9Sstevel@tonic-gate return; 38937c478bd9Sstevel@tonic-gate default: 38947c478bd9Sstevel@tonic-gate break; 38957c478bd9Sstevel@tonic-gate } 38967c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, TRUE); 38977c478bd9Sstevel@tonic-gate long_usage(CMD_SET, TRUE); 38987c478bd9Sstevel@tonic-gate usage(FALSE, HELP_PROPS); 38997c478bd9Sstevel@tonic-gate return; 39007c478bd9Sstevel@tonic-gate case RT_IPD: 39017c478bd9Sstevel@tonic-gate switch (prop_type) { 39027c478bd9Sstevel@tonic-gate case PT_DIR: 39037c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_ipdtab.zone_fs_dir, prop_id, 39047c478bd9Sstevel@tonic-gate sizeof (in_progress_ipdtab.zone_fs_dir)); 39057c478bd9Sstevel@tonic-gate return; 39067c478bd9Sstevel@tonic-gate default: 39077c478bd9Sstevel@tonic-gate break; 39087c478bd9Sstevel@tonic-gate } 39097c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, TRUE); 39107c478bd9Sstevel@tonic-gate long_usage(CMD_SET, TRUE); 39117c478bd9Sstevel@tonic-gate usage(FALSE, HELP_PROPS); 39127c478bd9Sstevel@tonic-gate return; 39137c478bd9Sstevel@tonic-gate case RT_NET: 39147c478bd9Sstevel@tonic-gate switch (prop_type) { 39157c478bd9Sstevel@tonic-gate case PT_ADDRESS: 39167c478bd9Sstevel@tonic-gate if (validate_net_address_syntax(prop_id) != Z_OK) { 39177c478bd9Sstevel@tonic-gate saw_error = TRUE; 39187c478bd9Sstevel@tonic-gate return; 39197c478bd9Sstevel@tonic-gate } 39207c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_nwiftab.zone_nwif_address, 39217c478bd9Sstevel@tonic-gate prop_id, 39227c478bd9Sstevel@tonic-gate sizeof (in_progress_nwiftab.zone_nwif_address)); 39237c478bd9Sstevel@tonic-gate break; 39247c478bd9Sstevel@tonic-gate case PT_PHYSICAL: 39257c478bd9Sstevel@tonic-gate if (validate_net_physical_syntax(prop_id) != Z_OK) { 39267c478bd9Sstevel@tonic-gate saw_error = TRUE; 39277c478bd9Sstevel@tonic-gate return; 39287c478bd9Sstevel@tonic-gate } 39297c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_nwiftab.zone_nwif_physical, 39307c478bd9Sstevel@tonic-gate prop_id, 39317c478bd9Sstevel@tonic-gate sizeof (in_progress_nwiftab.zone_nwif_physical)); 39327c478bd9Sstevel@tonic-gate break; 39337c478bd9Sstevel@tonic-gate default: 39347c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 39357c478bd9Sstevel@tonic-gate TRUE); 39367c478bd9Sstevel@tonic-gate long_usage(CMD_SET, TRUE); 39377c478bd9Sstevel@tonic-gate usage(FALSE, HELP_PROPS); 39387c478bd9Sstevel@tonic-gate return; 39397c478bd9Sstevel@tonic-gate } 39407c478bd9Sstevel@tonic-gate return; 39417c478bd9Sstevel@tonic-gate case RT_DEVICE: 39427c478bd9Sstevel@tonic-gate switch (prop_type) { 39437c478bd9Sstevel@tonic-gate case PT_MATCH: 39447c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_devtab.zone_dev_match, 39457c478bd9Sstevel@tonic-gate prop_id, 39467c478bd9Sstevel@tonic-gate sizeof (in_progress_devtab.zone_dev_match)); 39477c478bd9Sstevel@tonic-gate break; 39487c478bd9Sstevel@tonic-gate default: 39497c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 39507c478bd9Sstevel@tonic-gate TRUE); 39517c478bd9Sstevel@tonic-gate long_usage(CMD_SET, TRUE); 39527c478bd9Sstevel@tonic-gate usage(FALSE, HELP_PROPS); 39537c478bd9Sstevel@tonic-gate return; 39547c478bd9Sstevel@tonic-gate } 39557c478bd9Sstevel@tonic-gate return; 39567c478bd9Sstevel@tonic-gate case RT_RCTL: 39577c478bd9Sstevel@tonic-gate switch (prop_type) { 39587c478bd9Sstevel@tonic-gate case PT_NAME: 39597c478bd9Sstevel@tonic-gate if (!zonecfg_valid_rctlname(prop_id)) { 39607c478bd9Sstevel@tonic-gate zerr(gettext("'%s' is not a valid zone %s " 39617c478bd9Sstevel@tonic-gate "name."), prop_id, rt_to_str(RT_RCTL)); 39627c478bd9Sstevel@tonic-gate return; 39637c478bd9Sstevel@tonic-gate } 39647c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_rctltab.zone_rctl_name, 39657c478bd9Sstevel@tonic-gate prop_id, 39667c478bd9Sstevel@tonic-gate sizeof (in_progress_rctltab.zone_rctl_name)); 39677c478bd9Sstevel@tonic-gate break; 39687c478bd9Sstevel@tonic-gate case PT_VALUE: 39697c478bd9Sstevel@tonic-gate if (pp->pv_type != PROP_VAL_COMPLEX && 39707c478bd9Sstevel@tonic-gate pp->pv_type != PROP_VAL_LIST) { 39717c478bd9Sstevel@tonic-gate zerr(gettext("A %s or %s value was expected " 39727c478bd9Sstevel@tonic-gate "here."), pvt_to_str(PROP_VAL_COMPLEX), 39737c478bd9Sstevel@tonic-gate pvt_to_str(PROP_VAL_LIST)); 39747c478bd9Sstevel@tonic-gate saw_error = TRUE; 39757c478bd9Sstevel@tonic-gate return; 39767c478bd9Sstevel@tonic-gate } 39777c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list( 39787c478bd9Sstevel@tonic-gate in_progress_rctltab.zone_rctl_valptr); 39797c478bd9Sstevel@tonic-gate in_progress_rctltab.zone_rctl_valptr = NULL; 39807c478bd9Sstevel@tonic-gate if (!(pp->pv_type == PROP_VAL_LIST && 39817c478bd9Sstevel@tonic-gate pp->pv_list == NULL)) 39827c478bd9Sstevel@tonic-gate add_property(cmd); 39837c478bd9Sstevel@tonic-gate break; 39847c478bd9Sstevel@tonic-gate default: 39857c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 39867c478bd9Sstevel@tonic-gate TRUE); 39877c478bd9Sstevel@tonic-gate long_usage(CMD_SET, TRUE); 39887c478bd9Sstevel@tonic-gate usage(FALSE, HELP_PROPS); 39897c478bd9Sstevel@tonic-gate return; 39907c478bd9Sstevel@tonic-gate } 39917c478bd9Sstevel@tonic-gate return; 39927c478bd9Sstevel@tonic-gate case RT_ATTR: 39937c478bd9Sstevel@tonic-gate switch (prop_type) { 39947c478bd9Sstevel@tonic-gate case PT_NAME: 39957c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_attrtab.zone_attr_name, 39967c478bd9Sstevel@tonic-gate prop_id, 39977c478bd9Sstevel@tonic-gate sizeof (in_progress_attrtab.zone_attr_name)); 39987c478bd9Sstevel@tonic-gate break; 39997c478bd9Sstevel@tonic-gate case PT_TYPE: 40007c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_attrtab.zone_attr_type, 40017c478bd9Sstevel@tonic-gate prop_id, 40027c478bd9Sstevel@tonic-gate sizeof (in_progress_attrtab.zone_attr_type)); 40037c478bd9Sstevel@tonic-gate break; 40047c478bd9Sstevel@tonic-gate case PT_VALUE: 40057c478bd9Sstevel@tonic-gate (void) strlcpy(in_progress_attrtab.zone_attr_value, 40067c478bd9Sstevel@tonic-gate prop_id, 40077c478bd9Sstevel@tonic-gate sizeof (in_progress_attrtab.zone_attr_value)); 40087c478bd9Sstevel@tonic-gate break; 40097c478bd9Sstevel@tonic-gate default: 40107c478bd9Sstevel@tonic-gate zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 40117c478bd9Sstevel@tonic-gate TRUE); 40127c478bd9Sstevel@tonic-gate long_usage(CMD_SET, TRUE); 40137c478bd9Sstevel@tonic-gate usage(FALSE, HELP_PROPS); 40147c478bd9Sstevel@tonic-gate return; 40157c478bd9Sstevel@tonic-gate } 40167c478bd9Sstevel@tonic-gate return; 4017fa9e4066Sahrens case RT_DATASET: 4018fa9e4066Sahrens switch (prop_type) { 4019fa9e4066Sahrens case PT_NAME: 4020fa9e4066Sahrens (void) strlcpy(in_progress_dstab.zone_dataset_name, 4021fa9e4066Sahrens prop_id, 4022fa9e4066Sahrens sizeof (in_progress_dstab.zone_dataset_name)); 4023fa9e4066Sahrens return; 4024fa9e4066Sahrens default: 4025fa9e4066Sahrens break; 4026fa9e4066Sahrens } 4027fa9e4066Sahrens zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, TRUE); 4028fa9e4066Sahrens long_usage(CMD_SET, TRUE); 4029fa9e4066Sahrens usage(FALSE, HELP_PROPS); 4030*0209230bSgjelinek return; 4031*0209230bSgjelinek case RT_DCPU: 4032*0209230bSgjelinek switch (prop_type) { 4033*0209230bSgjelinek char *lowp, *highp; 4034*0209230bSgjelinek 4035*0209230bSgjelinek case PT_NCPUS: 4036*0209230bSgjelinek lowp = prop_id; 4037*0209230bSgjelinek if ((highp = strchr(prop_id, '-')) != NULL) 4038*0209230bSgjelinek *highp++ = '\0'; 4039*0209230bSgjelinek else 4040*0209230bSgjelinek highp = lowp; 4041*0209230bSgjelinek 4042*0209230bSgjelinek /* Make sure the input makes sense. */ 4043*0209230bSgjelinek if (!zonecfg_valid_ncpus(lowp, highp)) { 4044*0209230bSgjelinek zerr(gettext("%s property is out of range."), 4045*0209230bSgjelinek pt_to_str(PT_NCPUS)); 4046*0209230bSgjelinek saw_error = TRUE; 4047*0209230bSgjelinek return; 4048*0209230bSgjelinek } 4049*0209230bSgjelinek 4050*0209230bSgjelinek (void) strlcpy( 4051*0209230bSgjelinek in_progress_psettab.zone_ncpu_min, lowp, 4052*0209230bSgjelinek sizeof (in_progress_psettab.zone_ncpu_min)); 4053*0209230bSgjelinek (void) strlcpy( 4054*0209230bSgjelinek in_progress_psettab.zone_ncpu_max, highp, 4055*0209230bSgjelinek sizeof (in_progress_psettab.zone_ncpu_max)); 4056*0209230bSgjelinek return; 4057*0209230bSgjelinek case PT_IMPORTANCE: 4058*0209230bSgjelinek /* Make sure the value makes sense. */ 4059*0209230bSgjelinek if (!zonecfg_valid_importance(prop_id)) { 4060*0209230bSgjelinek zerr(gettext("%s property is out of range."), 4061*0209230bSgjelinek pt_to_str(PT_IMPORTANCE)); 4062*0209230bSgjelinek saw_error = TRUE; 4063*0209230bSgjelinek return; 4064*0209230bSgjelinek } 4065*0209230bSgjelinek 4066*0209230bSgjelinek (void) strlcpy(in_progress_psettab.zone_importance, 4067*0209230bSgjelinek prop_id, 4068*0209230bSgjelinek sizeof (in_progress_psettab.zone_importance)); 4069*0209230bSgjelinek return; 4070*0209230bSgjelinek default: 4071*0209230bSgjelinek break; 4072*0209230bSgjelinek } 4073*0209230bSgjelinek zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, TRUE); 4074*0209230bSgjelinek long_usage(CMD_SET, TRUE); 4075*0209230bSgjelinek usage(FALSE, HELP_PROPS); 4076*0209230bSgjelinek return; 4077*0209230bSgjelinek case RT_MCAP: 4078*0209230bSgjelinek switch (prop_type) { 4079*0209230bSgjelinek case PT_PHYSICAL: 4080*0209230bSgjelinek if (!zonecfg_valid_memlimit(prop_id, &mem_cap)) { 4081*0209230bSgjelinek zerr(gettext("A positive number with a " 4082*0209230bSgjelinek "required scale suffix (K, M, G or T) was " 4083*0209230bSgjelinek "expected here.")); 4084*0209230bSgjelinek saw_error = TRUE; 4085*0209230bSgjelinek } else if (mem_cap < ONE_MB) { 4086*0209230bSgjelinek zerr(gettext("%s value is too small. It must " 4087*0209230bSgjelinek "be at least 1M."), pt_to_str(PT_PHYSICAL)); 4088*0209230bSgjelinek saw_error = TRUE; 4089*0209230bSgjelinek } else { 4090*0209230bSgjelinek snprintf(in_progress_mcaptab.zone_physmem_cap, 4091*0209230bSgjelinek physmem_size, "%llu", mem_cap); 4092*0209230bSgjelinek } 4093*0209230bSgjelinek break; 4094*0209230bSgjelinek case PT_SWAP: 4095*0209230bSgjelinek /* 4096*0209230bSgjelinek * We have to check if an rctl is allowed here since 4097*0209230bSgjelinek * there might already be a rctl defined that blocks 4098*0209230bSgjelinek * the alias. 4099*0209230bSgjelinek */ 4100*0209230bSgjelinek if (!zonecfg_aliased_rctl_ok(handle, ALIAS_MAXSWAP)) { 4101*0209230bSgjelinek zone_perror(pt_to_str(PT_MAXSWAP), 4102*0209230bSgjelinek Z_ALIAS_DISALLOW, FALSE); 4103*0209230bSgjelinek saw_error = TRUE; 4104*0209230bSgjelinek return; 4105*0209230bSgjelinek } 4106*0209230bSgjelinek 4107*0209230bSgjelinek if (global_zone) 4108*0209230bSgjelinek mem_limit = ONE_MB * 100; 4109*0209230bSgjelinek else 4110*0209230bSgjelinek mem_limit = ONE_MB * 50; 4111*0209230bSgjelinek 4112*0209230bSgjelinek if (!zonecfg_valid_memlimit(prop_id, &mem_cap)) { 4113*0209230bSgjelinek zerr(gettext("A positive number with a " 4114*0209230bSgjelinek "required scale suffix (K, M, G or T) was " 4115*0209230bSgjelinek "expected here.")); 4116*0209230bSgjelinek saw_error = TRUE; 4117*0209230bSgjelinek } else if (mem_cap < mem_limit) { 4118*0209230bSgjelinek char buf[128]; 4119*0209230bSgjelinek 4120*0209230bSgjelinek (void) snprintf(buf, sizeof (buf), "%llu", 4121*0209230bSgjelinek mem_limit); 4122*0209230bSgjelinek bytes_to_units(buf, buf, sizeof (buf)); 4123*0209230bSgjelinek zerr(gettext("%s value is too small. It must " 4124*0209230bSgjelinek "be at least %s."), pt_to_str(PT_SWAP), 4125*0209230bSgjelinek buf); 4126*0209230bSgjelinek saw_error = TRUE; 4127*0209230bSgjelinek } else { 4128*0209230bSgjelinek if ((err = zonecfg_set_aliased_rctl(handle, 4129*0209230bSgjelinek ALIAS_MAXSWAP, mem_cap)) != Z_OK) 4130*0209230bSgjelinek zone_perror(zone, err, TRUE); 4131*0209230bSgjelinek else 4132*0209230bSgjelinek need_to_commit = TRUE; 4133*0209230bSgjelinek } 4134*0209230bSgjelinek break; 4135*0209230bSgjelinek case PT_LOCKED: 4136*0209230bSgjelinek /* 4137*0209230bSgjelinek * We have to check if an rctl is allowed here since 4138*0209230bSgjelinek * there might already be a rctl defined that blocks 4139*0209230bSgjelinek * the alias. 4140*0209230bSgjelinek */ 4141*0209230bSgjelinek if (!zonecfg_aliased_rctl_ok(handle, 4142*0209230bSgjelinek ALIAS_MAXLOCKEDMEM)) { 4143*0209230bSgjelinek zone_perror(pt_to_str(PT_LOCKED), 4144*0209230bSgjelinek Z_ALIAS_DISALLOW, FALSE); 4145*0209230bSgjelinek saw_error = TRUE; 4146*0209230bSgjelinek return; 4147*0209230bSgjelinek } 4148*0209230bSgjelinek 4149*0209230bSgjelinek if (!zonecfg_valid_memlimit(prop_id, &mem_cap)) { 4150*0209230bSgjelinek zerr(gettext("A non-negative number with a " 4151*0209230bSgjelinek "required scale suffix (K, M, G or T) was " 4152*0209230bSgjelinek "expected\nhere.")); 4153*0209230bSgjelinek saw_error = TRUE; 4154*0209230bSgjelinek } else { 4155*0209230bSgjelinek if ((err = zonecfg_set_aliased_rctl(handle, 4156*0209230bSgjelinek ALIAS_MAXLOCKEDMEM, mem_cap)) != Z_OK) 4157*0209230bSgjelinek zone_perror(zone, err, TRUE); 4158*0209230bSgjelinek else 4159*0209230bSgjelinek need_to_commit = TRUE; 4160*0209230bSgjelinek } 4161*0209230bSgjelinek break; 4162*0209230bSgjelinek default: 4163*0209230bSgjelinek zone_perror(pt_to_str(prop_type), Z_NO_PROPERTY_TYPE, 4164*0209230bSgjelinek TRUE); 4165*0209230bSgjelinek long_usage(CMD_SET, TRUE); 4166*0209230bSgjelinek usage(FALSE, HELP_PROPS); 4167*0209230bSgjelinek return; 4168*0209230bSgjelinek } 4169*0209230bSgjelinek 4170fa9e4066Sahrens return; 41717c478bd9Sstevel@tonic-gate default: 41727c478bd9Sstevel@tonic-gate zone_perror(rt_to_str(res_type), Z_NO_RESOURCE_TYPE, TRUE); 41737c478bd9Sstevel@tonic-gate long_usage(CMD_SET, TRUE); 41747c478bd9Sstevel@tonic-gate usage(FALSE, HELP_RESOURCES); 41757c478bd9Sstevel@tonic-gate return; 41767c478bd9Sstevel@tonic-gate } 41777c478bd9Sstevel@tonic-gate } 41787c478bd9Sstevel@tonic-gate 41797c478bd9Sstevel@tonic-gate static void 41807c478bd9Sstevel@tonic-gate output_prop(FILE *fp, int pnum, char *pval, bool print_notspec) 41817c478bd9Sstevel@tonic-gate { 41827c478bd9Sstevel@tonic-gate char *qstr; 41837c478bd9Sstevel@tonic-gate 41847c478bd9Sstevel@tonic-gate if (*pval != '\0') { 41857c478bd9Sstevel@tonic-gate qstr = quoteit(pval); 4186*0209230bSgjelinek if (pnum == PT_SWAP || pnum == PT_LOCKED) 4187*0209230bSgjelinek (void) fprintf(fp, "\t[%s: %s]\n", pt_to_str(pnum), 4188*0209230bSgjelinek qstr); 4189*0209230bSgjelinek else 4190*0209230bSgjelinek (void) fprintf(fp, "\t%s: %s\n", pt_to_str(pnum), qstr); 41917c478bd9Sstevel@tonic-gate free(qstr); 41927c478bd9Sstevel@tonic-gate } else if (print_notspec) 4193087719fdSdp (void) fprintf(fp, gettext("\t%s not specified\n"), 4194087719fdSdp pt_to_str(pnum)); 4195087719fdSdp } 4196087719fdSdp 4197087719fdSdp static void 4198087719fdSdp info_zonename(zone_dochandle_t handle, FILE *fp) 4199087719fdSdp { 4200087719fdSdp char zonename[ZONENAME_MAX]; 4201087719fdSdp 4202087719fdSdp if (zonecfg_get_name(handle, zonename, sizeof (zonename)) == Z_OK) 4203087719fdSdp (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_ZONENAME), 4204087719fdSdp zonename); 4205087719fdSdp else 4206087719fdSdp (void) fprintf(fp, gettext("%s not specified\n"), 4207087719fdSdp pt_to_str(PT_ZONENAME)); 42087c478bd9Sstevel@tonic-gate } 42097c478bd9Sstevel@tonic-gate 42107c478bd9Sstevel@tonic-gate static void 42117c478bd9Sstevel@tonic-gate info_zonepath(zone_dochandle_t handle, FILE *fp) 42127c478bd9Sstevel@tonic-gate { 42137c478bd9Sstevel@tonic-gate char zonepath[MAXPATHLEN]; 42147c478bd9Sstevel@tonic-gate 42157c478bd9Sstevel@tonic-gate if (zonecfg_get_zonepath(handle, zonepath, sizeof (zonepath)) == Z_OK) 42167c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_ZONEPATH), 42177c478bd9Sstevel@tonic-gate zonepath); 4218087719fdSdp else { 4219087719fdSdp (void) fprintf(fp, gettext("%s not specified\n"), 4220087719fdSdp pt_to_str(PT_ZONEPATH)); 4221087719fdSdp } 42227c478bd9Sstevel@tonic-gate } 42237c478bd9Sstevel@tonic-gate 42249acbbeafSnn static void 42259acbbeafSnn info_brand(zone_dochandle_t handle, FILE *fp) 42269acbbeafSnn { 42279acbbeafSnn char brand[MAXNAMELEN]; 42289acbbeafSnn 42299acbbeafSnn if (zonecfg_get_brand(handle, brand, sizeof (brand)) == Z_OK) 42309acbbeafSnn (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_BRAND), 42319acbbeafSnn brand); 42329acbbeafSnn else 42339acbbeafSnn (void) fprintf(fp, "%s %s\n", pt_to_str(PT_BRAND), 42349acbbeafSnn gettext("not specified")); 42359acbbeafSnn } 42369acbbeafSnn 42377c478bd9Sstevel@tonic-gate static void 42387c478bd9Sstevel@tonic-gate info_autoboot(zone_dochandle_t handle, FILE *fp) 42397c478bd9Sstevel@tonic-gate { 42407c478bd9Sstevel@tonic-gate boolean_t autoboot; 42417c478bd9Sstevel@tonic-gate int err; 42427c478bd9Sstevel@tonic-gate 42437c478bd9Sstevel@tonic-gate if ((err = zonecfg_get_autoboot(handle, &autoboot)) == Z_OK) 42447c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_AUTOBOOT), 42457c478bd9Sstevel@tonic-gate autoboot ? "true" : "false"); 42467c478bd9Sstevel@tonic-gate else 42477c478bd9Sstevel@tonic-gate zone_perror(zone, err, TRUE); 42487c478bd9Sstevel@tonic-gate } 42497c478bd9Sstevel@tonic-gate 42507c478bd9Sstevel@tonic-gate static void 42517c478bd9Sstevel@tonic-gate info_pool(zone_dochandle_t handle, FILE *fp) 42527c478bd9Sstevel@tonic-gate { 42537c478bd9Sstevel@tonic-gate char pool[MAXNAMELEN]; 42547c478bd9Sstevel@tonic-gate int err; 42557c478bd9Sstevel@tonic-gate 42567c478bd9Sstevel@tonic-gate if ((err = zonecfg_get_pool(handle, pool, sizeof (pool))) == Z_OK) 42577c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_POOL), pool); 42587c478bd9Sstevel@tonic-gate else 42597c478bd9Sstevel@tonic-gate zone_perror(zone, err, TRUE); 42607c478bd9Sstevel@tonic-gate } 42617c478bd9Sstevel@tonic-gate 4262ffbafc53Scomay static void 4263ffbafc53Scomay info_limitpriv(zone_dochandle_t handle, FILE *fp) 4264ffbafc53Scomay { 4265ffbafc53Scomay char *limitpriv; 4266ffbafc53Scomay int err; 4267ffbafc53Scomay 4268ffbafc53Scomay if ((err = zonecfg_get_limitpriv(handle, &limitpriv)) == Z_OK) { 4269ffbafc53Scomay (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_LIMITPRIV), 4270ffbafc53Scomay limitpriv); 4271ffbafc53Scomay free(limitpriv); 4272ffbafc53Scomay } else { 4273ffbafc53Scomay zone_perror(zone, err, TRUE); 4274ffbafc53Scomay } 4275ffbafc53Scomay } 4276ffbafc53Scomay 42773f2f09c1Sdp static void 42783f2f09c1Sdp info_bootargs(zone_dochandle_t handle, FILE *fp) 42793f2f09c1Sdp { 42803f2f09c1Sdp char bootargs[BOOTARGS_MAX]; 42813f2f09c1Sdp int err; 42823f2f09c1Sdp 42833f2f09c1Sdp if ((err = zonecfg_get_bootargs(handle, bootargs, 42843f2f09c1Sdp sizeof (bootargs))) == Z_OK) { 42853f2f09c1Sdp (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_BOOTARGS), 42863f2f09c1Sdp bootargs); 42873f2f09c1Sdp } else { 42883f2f09c1Sdp zone_perror(zone, err, TRUE); 42893f2f09c1Sdp } 42903f2f09c1Sdp } 42913f2f09c1Sdp 4292*0209230bSgjelinek static void 4293*0209230bSgjelinek info_sched(zone_dochandle_t handle, FILE *fp) 4294*0209230bSgjelinek { 4295*0209230bSgjelinek char sched[MAXNAMELEN]; 4296*0209230bSgjelinek int err; 4297*0209230bSgjelinek 4298*0209230bSgjelinek if ((err = zonecfg_get_sched_class(handle, sched, sizeof (sched))) 4299*0209230bSgjelinek == Z_OK) { 4300*0209230bSgjelinek (void) fprintf(fp, "%s: %s\n", pt_to_str(PT_SCHED), sched); 4301*0209230bSgjelinek } else { 4302*0209230bSgjelinek zone_perror(zone, err, TRUE); 4303*0209230bSgjelinek } 4304*0209230bSgjelinek } 4305*0209230bSgjelinek 43067c478bd9Sstevel@tonic-gate static void 43077c478bd9Sstevel@tonic-gate output_fs(FILE *fp, struct zone_fstab *fstab) 43087c478bd9Sstevel@tonic-gate { 43097c478bd9Sstevel@tonic-gate zone_fsopt_t *this; 43107c478bd9Sstevel@tonic-gate 43117c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s:\n", rt_to_str(RT_FS)); 43127c478bd9Sstevel@tonic-gate output_prop(fp, PT_DIR, fstab->zone_fs_dir, B_TRUE); 43137c478bd9Sstevel@tonic-gate output_prop(fp, PT_SPECIAL, fstab->zone_fs_special, B_TRUE); 43147c478bd9Sstevel@tonic-gate output_prop(fp, PT_RAW, fstab->zone_fs_raw, B_TRUE); 43157c478bd9Sstevel@tonic-gate output_prop(fp, PT_TYPE, fstab->zone_fs_type, B_TRUE); 43167c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\t%s: [", pt_to_str(PT_OPTIONS)); 43177c478bd9Sstevel@tonic-gate for (this = fstab->zone_fs_options; this != NULL; 43187c478bd9Sstevel@tonic-gate this = this->zone_fsopt_next) { 43197c478bd9Sstevel@tonic-gate if (strchr(this->zone_fsopt_opt, '=')) 43207c478bd9Sstevel@tonic-gate (void) fprintf(fp, "\"%s\"", this->zone_fsopt_opt); 43217c478bd9Sstevel@tonic-gate else 43227c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s", this->zone_fsopt_opt); 43237c478bd9Sstevel@tonic-gate if (this->zone_fsopt_next != NULL) 43247c478bd9Sstevel@tonic-gate (void) fprintf(fp, ","); 43257c478bd9Sstevel@tonic-gate } 43267c478bd9Sstevel@tonic-gate (void) fprintf(fp, "]\n"); 43277c478bd9Sstevel@tonic-gate } 43287c478bd9Sstevel@tonic-gate 43297c478bd9Sstevel@tonic-gate static void 43307c478bd9Sstevel@tonic-gate output_ipd(FILE *fp, struct zone_fstab *ipdtab) 43317c478bd9Sstevel@tonic-gate { 43327c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s:\n", rt_to_str(RT_IPD)); 43337c478bd9Sstevel@tonic-gate output_prop(fp, PT_DIR, ipdtab->zone_fs_dir, B_TRUE); 43347c478bd9Sstevel@tonic-gate } 43357c478bd9Sstevel@tonic-gate 43367c478bd9Sstevel@tonic-gate static void 43377c478bd9Sstevel@tonic-gate info_fs(zone_dochandle_t handle, FILE *fp, cmd_t *cmd) 43387c478bd9Sstevel@tonic-gate { 43397c478bd9Sstevel@tonic-gate struct zone_fstab lookup, user; 43407c478bd9Sstevel@tonic-gate bool output = FALSE; 43417c478bd9Sstevel@tonic-gate 43427c478bd9Sstevel@tonic-gate if (zonecfg_setfsent(handle) != Z_OK) 43437c478bd9Sstevel@tonic-gate return; 43447c478bd9Sstevel@tonic-gate while (zonecfg_getfsent(handle, &lookup) == Z_OK) { 43457c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs == 0) { 43467c478bd9Sstevel@tonic-gate output_fs(fp, &lookup); 43477c478bd9Sstevel@tonic-gate goto loopend; 43487c478bd9Sstevel@tonic-gate } 43497c478bd9Sstevel@tonic-gate if (fill_in_fstab(cmd, &user, TRUE) != Z_OK) 43507c478bd9Sstevel@tonic-gate goto loopend; 43517c478bd9Sstevel@tonic-gate if (strlen(user.zone_fs_dir) > 0 && 43527c478bd9Sstevel@tonic-gate strcmp(user.zone_fs_dir, lookup.zone_fs_dir) != 0) 43537c478bd9Sstevel@tonic-gate goto loopend; /* no match */ 43547c478bd9Sstevel@tonic-gate if (strlen(user.zone_fs_special) > 0 && 43557c478bd9Sstevel@tonic-gate strcmp(user.zone_fs_special, lookup.zone_fs_special) != 0) 43567c478bd9Sstevel@tonic-gate goto loopend; /* no match */ 43577c478bd9Sstevel@tonic-gate if (strlen(user.zone_fs_type) > 0 && 43587c478bd9Sstevel@tonic-gate strcmp(user.zone_fs_type, lookup.zone_fs_type) != 0) 43597c478bd9Sstevel@tonic-gate goto loopend; /* no match */ 43607c478bd9Sstevel@tonic-gate output_fs(fp, &lookup); 43617c478bd9Sstevel@tonic-gate output = TRUE; 43627c478bd9Sstevel@tonic-gate loopend: 43637c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(lookup.zone_fs_options); 43647c478bd9Sstevel@tonic-gate } 43657c478bd9Sstevel@tonic-gate (void) zonecfg_endfsent(handle); 43667c478bd9Sstevel@tonic-gate /* 43677c478bd9Sstevel@tonic-gate * If a property n/v pair was specified, warn the user if there was 43687c478bd9Sstevel@tonic-gate * nothing to output. 43697c478bd9Sstevel@tonic-gate */ 43707c478bd9Sstevel@tonic-gate if (!output && cmd->cmd_prop_nv_pairs > 0) 43717c478bd9Sstevel@tonic-gate (void) printf(gettext("No such %s resource.\n"), 43727c478bd9Sstevel@tonic-gate rt_to_str(RT_FS)); 43737c478bd9Sstevel@tonic-gate } 43747c478bd9Sstevel@tonic-gate 43757c478bd9Sstevel@tonic-gate static void 43767c478bd9Sstevel@tonic-gate info_ipd(zone_dochandle_t handle, FILE *fp, cmd_t *cmd) 43777c478bd9Sstevel@tonic-gate { 43787c478bd9Sstevel@tonic-gate struct zone_fstab lookup, user; 43797c478bd9Sstevel@tonic-gate bool output = FALSE; 43807c478bd9Sstevel@tonic-gate 43817c478bd9Sstevel@tonic-gate if (zonecfg_setipdent(handle) != Z_OK) 43827c478bd9Sstevel@tonic-gate return; 43837c478bd9Sstevel@tonic-gate while (zonecfg_getipdent(handle, &lookup) == Z_OK) { 43847c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs == 0) { 43857c478bd9Sstevel@tonic-gate output_ipd(fp, &lookup); 43867c478bd9Sstevel@tonic-gate continue; 43877c478bd9Sstevel@tonic-gate } 43887c478bd9Sstevel@tonic-gate if (fill_in_ipdtab(cmd, &user, TRUE) != Z_OK) 43897c478bd9Sstevel@tonic-gate continue; 43907c478bd9Sstevel@tonic-gate if (strlen(user.zone_fs_dir) > 0 && 43917c478bd9Sstevel@tonic-gate strcmp(user.zone_fs_dir, lookup.zone_fs_dir) != 0) 43927c478bd9Sstevel@tonic-gate continue; /* no match */ 43937c478bd9Sstevel@tonic-gate output_ipd(fp, &lookup); 43947c478bd9Sstevel@tonic-gate output = TRUE; 43957c478bd9Sstevel@tonic-gate } 43967c478bd9Sstevel@tonic-gate (void) zonecfg_endipdent(handle); 43977c478bd9Sstevel@tonic-gate /* 43987c478bd9Sstevel@tonic-gate * If a property n/v pair was specified, warn the user if there was 43997c478bd9Sstevel@tonic-gate * nothing to output. 44007c478bd9Sstevel@tonic-gate */ 44017c478bd9Sstevel@tonic-gate if (!output && cmd->cmd_prop_nv_pairs > 0) 44027c478bd9Sstevel@tonic-gate (void) printf(gettext("No such %s resource.\n"), 44037c478bd9Sstevel@tonic-gate rt_to_str(RT_IPD)); 44047c478bd9Sstevel@tonic-gate } 44057c478bd9Sstevel@tonic-gate 44067c478bd9Sstevel@tonic-gate static void 44077c478bd9Sstevel@tonic-gate output_net(FILE *fp, struct zone_nwiftab *nwiftab) 44087c478bd9Sstevel@tonic-gate { 44097c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s:\n", rt_to_str(RT_NET)); 44107c478bd9Sstevel@tonic-gate output_prop(fp, PT_ADDRESS, nwiftab->zone_nwif_address, B_TRUE); 44117c478bd9Sstevel@tonic-gate output_prop(fp, PT_PHYSICAL, nwiftab->zone_nwif_physical, B_TRUE); 44127c478bd9Sstevel@tonic-gate } 44137c478bd9Sstevel@tonic-gate 44147c478bd9Sstevel@tonic-gate static void 44157c478bd9Sstevel@tonic-gate info_net(zone_dochandle_t handle, FILE *fp, cmd_t *cmd) 44167c478bd9Sstevel@tonic-gate { 44177c478bd9Sstevel@tonic-gate struct zone_nwiftab lookup, user; 44187c478bd9Sstevel@tonic-gate bool output = FALSE; 44197c478bd9Sstevel@tonic-gate 44207c478bd9Sstevel@tonic-gate if (zonecfg_setnwifent(handle) != Z_OK) 44217c478bd9Sstevel@tonic-gate return; 44227c478bd9Sstevel@tonic-gate while (zonecfg_getnwifent(handle, &lookup) == Z_OK) { 44237c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs == 0) { 44247c478bd9Sstevel@tonic-gate output_net(fp, &lookup); 44257c478bd9Sstevel@tonic-gate continue; 44267c478bd9Sstevel@tonic-gate } 44277c478bd9Sstevel@tonic-gate if (fill_in_nwiftab(cmd, &user, TRUE) != Z_OK) 44287c478bd9Sstevel@tonic-gate continue; 44297c478bd9Sstevel@tonic-gate if (strlen(user.zone_nwif_physical) > 0 && 44307c478bd9Sstevel@tonic-gate strcmp(user.zone_nwif_physical, 44317c478bd9Sstevel@tonic-gate lookup.zone_nwif_physical) != 0) 44327c478bd9Sstevel@tonic-gate continue; /* no match */ 44337c478bd9Sstevel@tonic-gate if (strlen(user.zone_nwif_address) > 0 && 44347c478bd9Sstevel@tonic-gate !zonecfg_same_net_address(user.zone_nwif_address, 44357c478bd9Sstevel@tonic-gate lookup.zone_nwif_address)) 44367c478bd9Sstevel@tonic-gate continue; /* no match */ 44377c478bd9Sstevel@tonic-gate output_net(fp, &lookup); 44387c478bd9Sstevel@tonic-gate output = TRUE; 44397c478bd9Sstevel@tonic-gate } 44407c478bd9Sstevel@tonic-gate (void) zonecfg_endnwifent(handle); 44417c478bd9Sstevel@tonic-gate /* 44427c478bd9Sstevel@tonic-gate * If a property n/v pair was specified, warn the user if there was 44437c478bd9Sstevel@tonic-gate * nothing to output. 44447c478bd9Sstevel@tonic-gate */ 44457c478bd9Sstevel@tonic-gate if (!output && cmd->cmd_prop_nv_pairs > 0) 44467c478bd9Sstevel@tonic-gate (void) printf(gettext("No such %s resource.\n"), 44477c478bd9Sstevel@tonic-gate rt_to_str(RT_NET)); 44487c478bd9Sstevel@tonic-gate } 44497c478bd9Sstevel@tonic-gate 44507c478bd9Sstevel@tonic-gate static void 44517c478bd9Sstevel@tonic-gate output_dev(FILE *fp, struct zone_devtab *devtab) 44527c478bd9Sstevel@tonic-gate { 44537c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s\n", rt_to_str(RT_DEVICE)); 44547c478bd9Sstevel@tonic-gate output_prop(fp, PT_MATCH, devtab->zone_dev_match, B_TRUE); 44557c478bd9Sstevel@tonic-gate } 44567c478bd9Sstevel@tonic-gate 44577c478bd9Sstevel@tonic-gate static void 44587c478bd9Sstevel@tonic-gate info_dev(zone_dochandle_t handle, FILE *fp, cmd_t *cmd) 44597c478bd9Sstevel@tonic-gate { 44607c478bd9Sstevel@tonic-gate struct zone_devtab lookup, user; 44617c478bd9Sstevel@tonic-gate bool output = FALSE; 44627c478bd9Sstevel@tonic-gate 44637c478bd9Sstevel@tonic-gate if (zonecfg_setdevent(handle) != Z_OK) 44647c478bd9Sstevel@tonic-gate return; 44657c478bd9Sstevel@tonic-gate while (zonecfg_getdevent(handle, &lookup) == Z_OK) { 44667c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs == 0) { 44677c478bd9Sstevel@tonic-gate output_dev(fp, &lookup); 44687c478bd9Sstevel@tonic-gate continue; 44697c478bd9Sstevel@tonic-gate } 44707c478bd9Sstevel@tonic-gate if (fill_in_devtab(cmd, &user, TRUE) != Z_OK) 44717c478bd9Sstevel@tonic-gate continue; 44727c478bd9Sstevel@tonic-gate if (strlen(user.zone_dev_match) > 0 && 44737c478bd9Sstevel@tonic-gate strcmp(user.zone_dev_match, lookup.zone_dev_match) != 0) 44747c478bd9Sstevel@tonic-gate continue; /* no match */ 44757c478bd9Sstevel@tonic-gate output_dev(fp, &lookup); 44767c478bd9Sstevel@tonic-gate output = TRUE; 44777c478bd9Sstevel@tonic-gate } 44787c478bd9Sstevel@tonic-gate (void) zonecfg_enddevent(handle); 44797c478bd9Sstevel@tonic-gate /* 44807c478bd9Sstevel@tonic-gate * If a property n/v pair was specified, warn the user if there was 44817c478bd9Sstevel@tonic-gate * nothing to output. 44827c478bd9Sstevel@tonic-gate */ 44837c478bd9Sstevel@tonic-gate if (!output && cmd->cmd_prop_nv_pairs > 0) 44847c478bd9Sstevel@tonic-gate (void) printf(gettext("No such %s resource.\n"), 44857c478bd9Sstevel@tonic-gate rt_to_str(RT_DEVICE)); 44867c478bd9Sstevel@tonic-gate } 44877c478bd9Sstevel@tonic-gate 44887c478bd9Sstevel@tonic-gate static void 44897c478bd9Sstevel@tonic-gate output_rctl(FILE *fp, struct zone_rctltab *rctltab) 44907c478bd9Sstevel@tonic-gate { 44917c478bd9Sstevel@tonic-gate struct zone_rctlvaltab *valptr; 44927c478bd9Sstevel@tonic-gate 44937c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s:\n", rt_to_str(RT_RCTL)); 44947c478bd9Sstevel@tonic-gate output_prop(fp, PT_NAME, rctltab->zone_rctl_name, B_TRUE); 44957c478bd9Sstevel@tonic-gate for (valptr = rctltab->zone_rctl_valptr; valptr != NULL; 44967c478bd9Sstevel@tonic-gate valptr = valptr->zone_rctlval_next) { 44977c478bd9Sstevel@tonic-gate fprintf(fp, "\t%s: (%s=%s,%s=%s,%s=%s)\n", 44987c478bd9Sstevel@tonic-gate pt_to_str(PT_VALUE), 44997c478bd9Sstevel@tonic-gate pt_to_str(PT_PRIV), valptr->zone_rctlval_priv, 45007c478bd9Sstevel@tonic-gate pt_to_str(PT_LIMIT), valptr->zone_rctlval_limit, 45017c478bd9Sstevel@tonic-gate pt_to_str(PT_ACTION), valptr->zone_rctlval_action); 45027c478bd9Sstevel@tonic-gate } 45037c478bd9Sstevel@tonic-gate } 45047c478bd9Sstevel@tonic-gate 45057c478bd9Sstevel@tonic-gate static void 45067c478bd9Sstevel@tonic-gate info_rctl(zone_dochandle_t handle, FILE *fp, cmd_t *cmd) 45077c478bd9Sstevel@tonic-gate { 45087c478bd9Sstevel@tonic-gate struct zone_rctltab lookup, user; 45097c478bd9Sstevel@tonic-gate bool output = FALSE; 45107c478bd9Sstevel@tonic-gate 45117c478bd9Sstevel@tonic-gate if (zonecfg_setrctlent(handle) != Z_OK) 45127c478bd9Sstevel@tonic-gate return; 45137c478bd9Sstevel@tonic-gate while (zonecfg_getrctlent(handle, &lookup) == Z_OK) { 45147c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs == 0) { 45157c478bd9Sstevel@tonic-gate output_rctl(fp, &lookup); 45167c478bd9Sstevel@tonic-gate } else if (fill_in_rctltab(cmd, &user, TRUE) == Z_OK && 45177c478bd9Sstevel@tonic-gate (strlen(user.zone_rctl_name) == 0 || 45187c478bd9Sstevel@tonic-gate strcmp(user.zone_rctl_name, lookup.zone_rctl_name) == 0)) { 45197c478bd9Sstevel@tonic-gate output_rctl(fp, &lookup); 45207c478bd9Sstevel@tonic-gate output = TRUE; 45217c478bd9Sstevel@tonic-gate } 45227c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(lookup.zone_rctl_valptr); 45237c478bd9Sstevel@tonic-gate } 45247c478bd9Sstevel@tonic-gate (void) zonecfg_endrctlent(handle); 45257c478bd9Sstevel@tonic-gate /* 45267c478bd9Sstevel@tonic-gate * If a property n/v pair was specified, warn the user if there was 45277c478bd9Sstevel@tonic-gate * nothing to output. 45287c478bd9Sstevel@tonic-gate */ 45297c478bd9Sstevel@tonic-gate if (!output && cmd->cmd_prop_nv_pairs > 0) 45307c478bd9Sstevel@tonic-gate (void) printf(gettext("No such %s resource.\n"), 45317c478bd9Sstevel@tonic-gate rt_to_str(RT_RCTL)); 45327c478bd9Sstevel@tonic-gate } 45337c478bd9Sstevel@tonic-gate 45347c478bd9Sstevel@tonic-gate static void 45357c478bd9Sstevel@tonic-gate output_attr(FILE *fp, struct zone_attrtab *attrtab) 45367c478bd9Sstevel@tonic-gate { 45377c478bd9Sstevel@tonic-gate (void) fprintf(fp, "%s:\n", rt_to_str(RT_ATTR)); 45387c478bd9Sstevel@tonic-gate output_prop(fp, PT_NAME, attrtab->zone_attr_name, B_TRUE); 45397c478bd9Sstevel@tonic-gate output_prop(fp, PT_TYPE, attrtab->zone_attr_type, B_TRUE); 45407c478bd9Sstevel@tonic-gate output_prop(fp, PT_VALUE, attrtab->zone_attr_value, B_TRUE); 45417c478bd9Sstevel@tonic-gate } 45427c478bd9Sstevel@tonic-gate 45437c478bd9Sstevel@tonic-gate static void 45447c478bd9Sstevel@tonic-gate info_attr(zone_dochandle_t handle, FILE *fp, cmd_t *cmd) 45457c478bd9Sstevel@tonic-gate { 45467c478bd9Sstevel@tonic-gate struct zone_attrtab lookup, user; 45477c478bd9Sstevel@tonic-gate bool output = FALSE; 45487c478bd9Sstevel@tonic-gate 45497c478bd9Sstevel@tonic-gate if (zonecfg_setattrent(handle) != Z_OK) 45507c478bd9Sstevel@tonic-gate return; 45517c478bd9Sstevel@tonic-gate while (zonecfg_getattrent(handle, &lookup) == Z_OK) { 45527c478bd9Sstevel@tonic-gate if (cmd->cmd_prop_nv_pairs == 0) { 45537c478bd9Sstevel@tonic-gate output_attr(fp, &lookup); 45547c478bd9Sstevel@tonic-gate continue; 45557c478bd9Sstevel@tonic-gate } 45567c478bd9Sstevel@tonic-gate if (fill_in_attrtab(cmd, &user, TRUE) != Z_OK) 45577c478bd9Sstevel@tonic-gate continue; 45587c478bd9Sstevel@tonic-gate if (strlen(user.zone_attr_name) > 0 && 45597c478bd9Sstevel@tonic-gate strcmp(user.zone_attr_name, lookup.zone_attr_name) != 0) 45607c478bd9Sstevel@tonic-gate continue; /* no match */ 45617c478bd9Sstevel@tonic-gate if (strlen(user.zone_attr_type) > 0 && 45627c478bd9Sstevel@tonic-gate strcmp(user.zone_attr_type, lookup.zone_attr_type) != 0) 45637c478bd9Sstevel@tonic-gate continue; /* no match */ 45647c478bd9Sstevel@tonic-gate if (strlen(user.zone_attr_value) > 0 && 45657c478bd9Sstevel@tonic-gate strcmp(user.zone_attr_value, lookup.zone_attr_value) != 0) 45667c478bd9Sstevel@tonic-gate continue; /* no match */ 45677c478bd9Sstevel@tonic-gate output_attr(fp, &lookup); 45687c478bd9Sstevel@tonic-gate output = TRUE; 45697c478bd9Sstevel@tonic-gate } 45707c478bd9Sstevel@tonic-gate (void) zonecfg_endattrent(handle); 45717c478bd9Sstevel@tonic-gate /* 45727c478bd9Sstevel@tonic-gate * If a property n/v pair was specified, warn the user if there was 45737c478bd9Sstevel@tonic-gate * nothing to output. 45747c478bd9Sstevel@tonic-gate */ 45757c478bd9Sstevel@tonic-gate if (!output && cmd->cmd_prop_nv_pairs > 0) 45767c478bd9Sstevel@tonic-gate (void) printf(gettext("No such %s resource.\n"), 45777c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR)); 45787c478bd9Sstevel@tonic-gate } 45797c478bd9Sstevel@tonic-gate 4580fa9e4066Sahrens static void 4581fa9e4066Sahrens output_ds(FILE *fp, struct zone_dstab *dstab) 4582fa9e4066Sahrens { 4583fa9e4066Sahrens (void) fprintf(fp, "%s:\n", rt_to_str(RT_DATASET)); 4584fa9e4066Sahrens output_prop(fp, PT_NAME, dstab->zone_dataset_name, B_TRUE); 4585fa9e4066Sahrens } 4586fa9e4066Sahrens 4587fa9e4066Sahrens static void 4588fa9e4066Sahrens info_ds(zone_dochandle_t handle, FILE *fp, cmd_t *cmd) 4589fa9e4066Sahrens { 4590fa9e4066Sahrens struct zone_dstab lookup, user; 4591fa9e4066Sahrens bool output = FALSE; 4592fa9e4066Sahrens 4593*0209230bSgjelinek if (zonecfg_setdsent(handle) != Z_OK) 4594fa9e4066Sahrens return; 4595fa9e4066Sahrens while (zonecfg_getdsent(handle, &lookup) == Z_OK) { 4596fa9e4066Sahrens if (cmd->cmd_prop_nv_pairs == 0) { 4597fa9e4066Sahrens output_ds(fp, &lookup); 4598fa9e4066Sahrens continue; 4599fa9e4066Sahrens } 4600fa9e4066Sahrens if (fill_in_dstab(cmd, &user, TRUE) != Z_OK) 4601fa9e4066Sahrens continue; 4602fa9e4066Sahrens if (strlen(user.zone_dataset_name) > 0 && 4603fa9e4066Sahrens strcmp(user.zone_dataset_name, 4604fa9e4066Sahrens lookup.zone_dataset_name) != 0) 4605fa9e4066Sahrens continue; /* no match */ 4606fa9e4066Sahrens output_ds(fp, &lookup); 4607fa9e4066Sahrens output = TRUE; 4608fa9e4066Sahrens } 4609fa9e4066Sahrens (void) zonecfg_enddsent(handle); 4610fa9e4066Sahrens /* 4611fa9e4066Sahrens * If a property n/v pair was specified, warn the user if there was 4612fa9e4066Sahrens * nothing to output. 4613fa9e4066Sahrens */ 4614fa9e4066Sahrens if (!output && cmd->cmd_prop_nv_pairs > 0) 4615fa9e4066Sahrens (void) printf(gettext("No such %s resource.\n"), 4616fa9e4066Sahrens rt_to_str(RT_DATASET)); 4617fa9e4066Sahrens } 4618fa9e4066Sahrens 4619*0209230bSgjelinek static void 4620*0209230bSgjelinek output_pset(FILE *fp, struct zone_psettab *psettab) 4621*0209230bSgjelinek { 4622*0209230bSgjelinek (void) fprintf(fp, "%s:\n", rt_to_str(RT_DCPU)); 4623*0209230bSgjelinek if (strcmp(psettab->zone_ncpu_min, psettab->zone_ncpu_max) == 0) 4624*0209230bSgjelinek (void) fprintf(fp, "\t%s: %s\n", pt_to_str(PT_NCPUS), 4625*0209230bSgjelinek psettab->zone_ncpu_max); 4626*0209230bSgjelinek else 4627*0209230bSgjelinek (void) fprintf(fp, "\t%s: %s-%s\n", pt_to_str(PT_NCPUS), 4628*0209230bSgjelinek psettab->zone_ncpu_min, psettab->zone_ncpu_max); 4629*0209230bSgjelinek if (psettab->zone_importance[0] != '\0') 4630*0209230bSgjelinek (void) fprintf(fp, "\t%s: %s\n", pt_to_str(PT_IMPORTANCE), 4631*0209230bSgjelinek psettab->zone_importance); 4632*0209230bSgjelinek } 4633*0209230bSgjelinek 4634*0209230bSgjelinek static void 4635*0209230bSgjelinek info_pset(zone_dochandle_t handle, FILE *fp) 4636*0209230bSgjelinek { 4637*0209230bSgjelinek struct zone_psettab lookup; 4638*0209230bSgjelinek 4639*0209230bSgjelinek if (zonecfg_getpsetent(handle, &lookup) == Z_OK) 4640*0209230bSgjelinek output_pset(fp, &lookup); 4641*0209230bSgjelinek } 4642*0209230bSgjelinek 4643*0209230bSgjelinek static void 4644*0209230bSgjelinek info_aliased_rctl(zone_dochandle_t handle, FILE *fp, char *alias) 4645*0209230bSgjelinek { 4646*0209230bSgjelinek uint64_t limit; 4647*0209230bSgjelinek 4648*0209230bSgjelinek if (zonecfg_get_aliased_rctl(handle, alias, &limit) == Z_OK) { 4649*0209230bSgjelinek /* convert memory based properties */ 4650*0209230bSgjelinek if (strcmp(alias, ALIAS_MAXSHMMEM) == 0) { 4651*0209230bSgjelinek char buf[128]; 4652*0209230bSgjelinek 4653*0209230bSgjelinek (void) snprintf(buf, sizeof (buf), "%llu", limit); 4654*0209230bSgjelinek bytes_to_units(buf, buf, sizeof (buf)); 4655*0209230bSgjelinek (void) fprintf(fp, "[%s: %s]\n", alias, buf); 4656*0209230bSgjelinek return; 4657*0209230bSgjelinek } 4658*0209230bSgjelinek 4659*0209230bSgjelinek (void) fprintf(fp, "[%s: %llu]\n", alias, limit); 4660*0209230bSgjelinek } 4661*0209230bSgjelinek } 4662*0209230bSgjelinek 4663*0209230bSgjelinek static void 4664*0209230bSgjelinek bytes_to_units(char *str, char *buf, int bufsize) 4665*0209230bSgjelinek { 4666*0209230bSgjelinek unsigned long long num; 4667*0209230bSgjelinek unsigned long long save = 0; 4668*0209230bSgjelinek char *units = "BKMGT"; 4669*0209230bSgjelinek char *up = units; 4670*0209230bSgjelinek 4671*0209230bSgjelinek num = strtoll(str, NULL, 10); 4672*0209230bSgjelinek 4673*0209230bSgjelinek if (num < 1024) { 4674*0209230bSgjelinek (void) snprintf(buf, bufsize, "%llu", num); 4675*0209230bSgjelinek return; 4676*0209230bSgjelinek } 4677*0209230bSgjelinek 4678*0209230bSgjelinek while ((num >= 1024) && (*up != 'T')) { 4679*0209230bSgjelinek up++; /* next unit of measurement */ 4680*0209230bSgjelinek save = num; 4681*0209230bSgjelinek num = (num + 512) >> 10; 4682*0209230bSgjelinek } 4683*0209230bSgjelinek 4684*0209230bSgjelinek /* check if we should output a fraction. snprintf will round for us */ 4685*0209230bSgjelinek if (save % 1024 != 0 && ((save >> 10) < 10)) 4686*0209230bSgjelinek (void) snprintf(buf, bufsize, "%2.1f%c", ((float)save / 1024), 4687*0209230bSgjelinek *up); 4688*0209230bSgjelinek else 4689*0209230bSgjelinek (void) snprintf(buf, bufsize, "%llu%c", num, *up); 4690*0209230bSgjelinek } 4691*0209230bSgjelinek 4692*0209230bSgjelinek static void 4693*0209230bSgjelinek output_mcap(FILE *fp, struct zone_mcaptab *mcaptab, int showswap, 4694*0209230bSgjelinek uint64_t maxswap, int showlocked, uint64_t maxlocked) 4695*0209230bSgjelinek { 4696*0209230bSgjelinek char buf[128]; 4697*0209230bSgjelinek 4698*0209230bSgjelinek (void) fprintf(fp, "%s:\n", rt_to_str(RT_MCAP)); 4699*0209230bSgjelinek if (mcaptab->zone_physmem_cap[0] != '\0') { 4700*0209230bSgjelinek bytes_to_units(mcaptab->zone_physmem_cap, buf, sizeof (buf)); 4701*0209230bSgjelinek output_prop(fp, PT_PHYSICAL, buf, B_TRUE); 4702*0209230bSgjelinek } 4703*0209230bSgjelinek 4704*0209230bSgjelinek if (showswap == Z_OK) { 4705*0209230bSgjelinek (void) snprintf(buf, sizeof (buf), "%llu", maxswap); 4706*0209230bSgjelinek bytes_to_units(buf, buf, sizeof (buf)); 4707*0209230bSgjelinek output_prop(fp, PT_SWAP, buf, B_TRUE); 4708*0209230bSgjelinek } 4709*0209230bSgjelinek 4710*0209230bSgjelinek if (showlocked == Z_OK) { 4711*0209230bSgjelinek (void) snprintf(buf, sizeof (buf), "%llu", maxlocked); 4712*0209230bSgjelinek bytes_to_units(buf, buf, sizeof (buf)); 4713*0209230bSgjelinek output_prop(fp, PT_LOCKED, buf, B_TRUE); 4714*0209230bSgjelinek } 4715*0209230bSgjelinek } 4716*0209230bSgjelinek 4717*0209230bSgjelinek static void 4718*0209230bSgjelinek info_mcap(zone_dochandle_t handle, FILE *fp) 4719*0209230bSgjelinek { 4720*0209230bSgjelinek int res1, res2, res3; 4721*0209230bSgjelinek uint64_t swap_limit; 4722*0209230bSgjelinek uint64_t locked_limit; 4723*0209230bSgjelinek struct zone_mcaptab lookup; 4724*0209230bSgjelinek 4725*0209230bSgjelinek bzero(&lookup, sizeof (lookup)); 4726*0209230bSgjelinek res1 = zonecfg_getmcapent(handle, &lookup); 4727*0209230bSgjelinek res2 = zonecfg_get_aliased_rctl(handle, ALIAS_MAXSWAP, &swap_limit); 4728*0209230bSgjelinek res3 = zonecfg_get_aliased_rctl(handle, ALIAS_MAXLOCKEDMEM, 4729*0209230bSgjelinek &locked_limit); 4730*0209230bSgjelinek 4731*0209230bSgjelinek if (res1 == Z_OK || res2 == Z_OK || res3 == Z_OK) 4732*0209230bSgjelinek output_mcap(fp, &lookup, res2, swap_limit, res3, locked_limit); 4733*0209230bSgjelinek } 4734*0209230bSgjelinek 47357c478bd9Sstevel@tonic-gate void 47367c478bd9Sstevel@tonic-gate info_func(cmd_t *cmd) 47377c478bd9Sstevel@tonic-gate { 47387c478bd9Sstevel@tonic-gate FILE *fp = stdout; 47397c478bd9Sstevel@tonic-gate bool need_to_close = FALSE; 47407c478bd9Sstevel@tonic-gate char *pager; 4741*0209230bSgjelinek int type; 4742*0209230bSgjelinek int res1, res2; 4743*0209230bSgjelinek uint64_t swap_limit; 4744*0209230bSgjelinek uint64_t locked_limit; 47457c478bd9Sstevel@tonic-gate 47467c478bd9Sstevel@tonic-gate assert(cmd != NULL); 47477c478bd9Sstevel@tonic-gate 47487c478bd9Sstevel@tonic-gate if (initialize(TRUE) != Z_OK) 47497c478bd9Sstevel@tonic-gate return; 47507c478bd9Sstevel@tonic-gate 47517c478bd9Sstevel@tonic-gate /* don't page error output */ 47527c478bd9Sstevel@tonic-gate if (interactive_mode) { 47537c478bd9Sstevel@tonic-gate if ((pager = getenv("PAGER")) == NULL) 47547c478bd9Sstevel@tonic-gate pager = PAGER; 47557c478bd9Sstevel@tonic-gate if ((fp = popen(pager, "w")) != NULL) 47567c478bd9Sstevel@tonic-gate need_to_close = TRUE; 47577c478bd9Sstevel@tonic-gate setbuf(fp, NULL); 47587c478bd9Sstevel@tonic-gate } 47597c478bd9Sstevel@tonic-gate 47607c478bd9Sstevel@tonic-gate if (!global_scope) { 47617c478bd9Sstevel@tonic-gate switch (resource_scope) { 47627c478bd9Sstevel@tonic-gate case RT_FS: 47637c478bd9Sstevel@tonic-gate output_fs(fp, &in_progress_fstab); 47647c478bd9Sstevel@tonic-gate break; 47657c478bd9Sstevel@tonic-gate case RT_IPD: 47667c478bd9Sstevel@tonic-gate output_ipd(fp, &in_progress_ipdtab); 47677c478bd9Sstevel@tonic-gate break; 47687c478bd9Sstevel@tonic-gate case RT_NET: 47697c478bd9Sstevel@tonic-gate output_net(fp, &in_progress_nwiftab); 47707c478bd9Sstevel@tonic-gate break; 47717c478bd9Sstevel@tonic-gate case RT_DEVICE: 47727c478bd9Sstevel@tonic-gate output_dev(fp, &in_progress_devtab); 47737c478bd9Sstevel@tonic-gate break; 47747c478bd9Sstevel@tonic-gate case RT_RCTL: 47757c478bd9Sstevel@tonic-gate output_rctl(fp, &in_progress_rctltab); 47767c478bd9Sstevel@tonic-gate break; 47777c478bd9Sstevel@tonic-gate case RT_ATTR: 47787c478bd9Sstevel@tonic-gate output_attr(fp, &in_progress_attrtab); 47797c478bd9Sstevel@tonic-gate break; 4780fa9e4066Sahrens case RT_DATASET: 4781fa9e4066Sahrens output_ds(fp, &in_progress_dstab); 4782fa9e4066Sahrens break; 4783*0209230bSgjelinek case RT_DCPU: 4784*0209230bSgjelinek output_pset(fp, &in_progress_psettab); 4785*0209230bSgjelinek break; 4786*0209230bSgjelinek case RT_MCAP: 4787*0209230bSgjelinek res1 = zonecfg_get_aliased_rctl(handle, ALIAS_MAXSWAP, 4788*0209230bSgjelinek &swap_limit); 4789*0209230bSgjelinek res2 = zonecfg_get_aliased_rctl(handle, 4790*0209230bSgjelinek ALIAS_MAXLOCKEDMEM, &locked_limit); 4791*0209230bSgjelinek output_mcap(fp, &in_progress_mcaptab, res1, swap_limit, 4792*0209230bSgjelinek res2, locked_limit); 4793*0209230bSgjelinek break; 47947c478bd9Sstevel@tonic-gate } 47957c478bd9Sstevel@tonic-gate goto cleanup; 47967c478bd9Sstevel@tonic-gate } 47977c478bd9Sstevel@tonic-gate 4798*0209230bSgjelinek type = cmd->cmd_res_type; 4799*0209230bSgjelinek 4800*0209230bSgjelinek if (gz_invalid_rt_property(type)) { 4801*0209230bSgjelinek zerr(gettext("%s is not a valid property for the global zone."), 4802*0209230bSgjelinek rt_to_str(type)); 4803*0209230bSgjelinek goto cleanup; 4804*0209230bSgjelinek } 4805*0209230bSgjelinek 4806*0209230bSgjelinek if (gz_invalid_resource(type)) { 4807*0209230bSgjelinek zerr(gettext("%s is not a valid resource for the global zone."), 4808*0209230bSgjelinek rt_to_str(type)); 4809*0209230bSgjelinek goto cleanup; 4810*0209230bSgjelinek } 4811*0209230bSgjelinek 48127c478bd9Sstevel@tonic-gate switch (cmd->cmd_res_type) { 48137c478bd9Sstevel@tonic-gate case RT_UNKNOWN: 4814087719fdSdp info_zonename(handle, fp); 4815*0209230bSgjelinek if (!global_zone) { 4816*0209230bSgjelinek info_zonepath(handle, fp); 4817*0209230bSgjelinek info_brand(handle, fp); 4818*0209230bSgjelinek info_autoboot(handle, fp); 4819*0209230bSgjelinek info_bootargs(handle, fp); 4820*0209230bSgjelinek } 48217c478bd9Sstevel@tonic-gate info_pool(handle, fp); 4822*0209230bSgjelinek if (!global_zone) { 4823*0209230bSgjelinek info_limitpriv(handle, fp); 4824*0209230bSgjelinek info_sched(handle, fp); 4825*0209230bSgjelinek } 4826*0209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXLWPS); 4827*0209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXSHMMEM); 4828*0209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXSHMIDS); 4829*0209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXMSGIDS); 4830*0209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXSEMIDS); 4831*0209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_SHARES); 4832*0209230bSgjelinek if (!global_zone) { 4833*0209230bSgjelinek info_ipd(handle, fp, cmd); 4834*0209230bSgjelinek info_fs(handle, fp, cmd); 4835*0209230bSgjelinek info_net(handle, fp, cmd); 4836*0209230bSgjelinek info_dev(handle, fp, cmd); 4837*0209230bSgjelinek } 4838*0209230bSgjelinek info_pset(handle, fp); 4839*0209230bSgjelinek info_mcap(handle, fp); 4840*0209230bSgjelinek if (!global_zone) { 4841*0209230bSgjelinek info_attr(handle, fp, cmd); 4842*0209230bSgjelinek info_ds(handle, fp, cmd); 4843*0209230bSgjelinek } 48447c478bd9Sstevel@tonic-gate info_rctl(handle, fp, cmd); 48457c478bd9Sstevel@tonic-gate break; 4846087719fdSdp case RT_ZONENAME: 4847087719fdSdp info_zonename(handle, fp); 4848087719fdSdp break; 48497c478bd9Sstevel@tonic-gate case RT_ZONEPATH: 48507c478bd9Sstevel@tonic-gate info_zonepath(handle, fp); 48517c478bd9Sstevel@tonic-gate break; 48529acbbeafSnn case RT_BRAND: 48539acbbeafSnn info_brand(handle, fp); 48549acbbeafSnn break; 48557c478bd9Sstevel@tonic-gate case RT_AUTOBOOT: 48567c478bd9Sstevel@tonic-gate info_autoboot(handle, fp); 48577c478bd9Sstevel@tonic-gate break; 48587c478bd9Sstevel@tonic-gate case RT_POOL: 48597c478bd9Sstevel@tonic-gate info_pool(handle, fp); 48607c478bd9Sstevel@tonic-gate break; 4861ffbafc53Scomay case RT_LIMITPRIV: 4862ffbafc53Scomay info_limitpriv(handle, fp); 4863ffbafc53Scomay break; 48643f2f09c1Sdp case RT_BOOTARGS: 48653f2f09c1Sdp info_bootargs(handle, fp); 48663f2f09c1Sdp break; 4867*0209230bSgjelinek case RT_SCHED: 4868*0209230bSgjelinek info_sched(handle, fp); 4869*0209230bSgjelinek break; 4870*0209230bSgjelinek case RT_MAXLWPS: 4871*0209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXLWPS); 4872*0209230bSgjelinek break; 4873*0209230bSgjelinek case RT_MAXSHMMEM: 4874*0209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXSHMMEM); 4875*0209230bSgjelinek break; 4876*0209230bSgjelinek case RT_MAXSHMIDS: 4877*0209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXSHMIDS); 4878*0209230bSgjelinek break; 4879*0209230bSgjelinek case RT_MAXMSGIDS: 4880*0209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXMSGIDS); 4881*0209230bSgjelinek break; 4882*0209230bSgjelinek case RT_MAXSEMIDS: 4883*0209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_MAXSEMIDS); 4884*0209230bSgjelinek break; 4885*0209230bSgjelinek case RT_SHARES: 4886*0209230bSgjelinek info_aliased_rctl(handle, fp, ALIAS_SHARES); 4887*0209230bSgjelinek break; 48887c478bd9Sstevel@tonic-gate case RT_FS: 48897c478bd9Sstevel@tonic-gate info_fs(handle, fp, cmd); 48907c478bd9Sstevel@tonic-gate break; 48917c478bd9Sstevel@tonic-gate case RT_IPD: 48927c478bd9Sstevel@tonic-gate info_ipd(handle, fp, cmd); 48937c478bd9Sstevel@tonic-gate break; 48947c478bd9Sstevel@tonic-gate case RT_NET: 48957c478bd9Sstevel@tonic-gate info_net(handle, fp, cmd); 48967c478bd9Sstevel@tonic-gate break; 48977c478bd9Sstevel@tonic-gate case RT_DEVICE: 48987c478bd9Sstevel@tonic-gate info_dev(handle, fp, cmd); 48997c478bd9Sstevel@tonic-gate break; 49007c478bd9Sstevel@tonic-gate case RT_RCTL: 49017c478bd9Sstevel@tonic-gate info_rctl(handle, fp, cmd); 49027c478bd9Sstevel@tonic-gate break; 49037c478bd9Sstevel@tonic-gate case RT_ATTR: 49047c478bd9Sstevel@tonic-gate info_attr(handle, fp, cmd); 49057c478bd9Sstevel@tonic-gate break; 4906fa9e4066Sahrens case RT_DATASET: 4907fa9e4066Sahrens info_ds(handle, fp, cmd); 4908fa9e4066Sahrens break; 4909*0209230bSgjelinek case RT_DCPU: 4910*0209230bSgjelinek info_pset(handle, fp); 4911*0209230bSgjelinek break; 4912*0209230bSgjelinek case RT_MCAP: 4913*0209230bSgjelinek info_mcap(handle, fp); 4914*0209230bSgjelinek break; 49157c478bd9Sstevel@tonic-gate default: 49167c478bd9Sstevel@tonic-gate zone_perror(rt_to_str(cmd->cmd_res_type), Z_NO_RESOURCE_TYPE, 49177c478bd9Sstevel@tonic-gate TRUE); 49187c478bd9Sstevel@tonic-gate } 49197c478bd9Sstevel@tonic-gate 49207c478bd9Sstevel@tonic-gate cleanup: 49217c478bd9Sstevel@tonic-gate if (need_to_close) 49227c478bd9Sstevel@tonic-gate (void) pclose(fp); 49237c478bd9Sstevel@tonic-gate } 49247c478bd9Sstevel@tonic-gate 4925087719fdSdp /* 4926087719fdSdp * Helper function for verify-- checks that a required string property 4927087719fdSdp * exists. 4928087719fdSdp */ 4929087719fdSdp static void 4930087719fdSdp check_reqd_prop(char *attr, int rt, int pt, int *ret_val) 49317c478bd9Sstevel@tonic-gate { 4932087719fdSdp if (strlen(attr) == 0) { 4933087719fdSdp zerr(gettext("%s: %s not specified"), rt_to_str(rt), 4934087719fdSdp pt_to_str(pt)); 4935087719fdSdp saw_error = TRUE; 4936087719fdSdp if (*ret_val == Z_OK) 4937087719fdSdp *ret_val = Z_REQD_PROPERTY_MISSING; 49387c478bd9Sstevel@tonic-gate } 49397c478bd9Sstevel@tonic-gate } 49407c478bd9Sstevel@tonic-gate 49419acbbeafSnn static int 49429acbbeafSnn do_subproc(char *cmdbuf) 49439acbbeafSnn { 49449acbbeafSnn char inbuf[MAX_CMD_LEN]; 49459acbbeafSnn FILE *file; 49469acbbeafSnn int status; 49479acbbeafSnn 49489acbbeafSnn file = popen(cmdbuf, "r"); 49499acbbeafSnn if (file == NULL) { 49509acbbeafSnn zerr(gettext("Could not launch: %s"), cmdbuf); 49519acbbeafSnn return (-1); 49529acbbeafSnn } 49539acbbeafSnn 49549acbbeafSnn while (fgets(inbuf, sizeof (inbuf), file) != NULL) 49559acbbeafSnn fprintf(stderr, "%s", inbuf); 49569acbbeafSnn status = pclose(file); 49579acbbeafSnn 49589acbbeafSnn if (WIFSIGNALED(status)) { 49599acbbeafSnn zerr(gettext("%s unexpectedly terminated due to signal %d"), 49609acbbeafSnn cmdbuf, WTERMSIG(status)); 49619acbbeafSnn return (-1); 49629acbbeafSnn } 49639acbbeafSnn assert(WIFEXITED(status)); 49649acbbeafSnn return (WEXITSTATUS(status)); 49659acbbeafSnn } 49669acbbeafSnn 49679acbbeafSnn static int 49689acbbeafSnn brand_verify(zone_dochandle_t handle) 49699acbbeafSnn { 49706e65f9afSnn char xml_file[32]; 49719acbbeafSnn char cmdbuf[MAX_CMD_LEN]; 4972123807fbSedp brand_handle_t bh; 49739acbbeafSnn char brand[MAXNAMELEN]; 49749acbbeafSnn int err; 49759acbbeafSnn 49769acbbeafSnn if (zonecfg_get_brand(handle, brand, sizeof (brand)) != Z_OK) { 49779acbbeafSnn zerr("%s: %s\n", zone, gettext("could not get zone brand")); 49789acbbeafSnn return (Z_INVALID_DOCUMENT); 49799acbbeafSnn } 4980123807fbSedp if ((bh = brand_open(brand)) == NULL) { 49819acbbeafSnn zerr("%s: %s\n", zone, gettext("unknown brand.")); 49829acbbeafSnn return (Z_INVALID_DOCUMENT); 49839acbbeafSnn } 49849acbbeafSnn 49859acbbeafSnn /* 49869acbbeafSnn * Fetch the verify command, if any, from the brand configuration 49879acbbeafSnn * and build the command line to execute it. 49889acbbeafSnn */ 49899acbbeafSnn strcpy(cmdbuf, EXEC_PREFIX); 4990123807fbSedp err = brand_get_verify_cfg(bh, cmdbuf + EXEC_LEN, 49919acbbeafSnn sizeof (cmdbuf) - (EXEC_LEN + (strlen(xml_file) + 1))); 4992123807fbSedp brand_close(bh); 49939acbbeafSnn if (err != Z_OK) { 49949acbbeafSnn zerr("%s: %s\n", zone, 49959acbbeafSnn gettext("could not get brand verification command")); 49969acbbeafSnn return (Z_INVALID_DOCUMENT); 49979acbbeafSnn } 49989acbbeafSnn 49999acbbeafSnn /* 50009acbbeafSnn * If the brand doesn't provide a verification routine, we just 50019acbbeafSnn * return success. 50029acbbeafSnn */ 50039acbbeafSnn if (strlen(cmdbuf) == EXEC_LEN) 50049acbbeafSnn return (Z_OK); 50059acbbeafSnn 50069acbbeafSnn /* 50079acbbeafSnn * Dump the current config information for this zone to a file. 50089acbbeafSnn */ 50096e65f9afSnn strcpy(xml_file, "/tmp/zonecfg_verify.XXXXXX"); 50109acbbeafSnn if (mkstemp(xml_file) == NULL) 50119acbbeafSnn return (Z_TEMP_FILE); 50129acbbeafSnn if ((err = zonecfg_verify_save(handle, xml_file)) != Z_OK) { 50139acbbeafSnn (void) unlink(xml_file); 50149acbbeafSnn return (err); 50159acbbeafSnn } 50169acbbeafSnn 50179acbbeafSnn /* 50189acbbeafSnn * Execute the verification command. 50199acbbeafSnn */ 50209acbbeafSnn if ((strlcat(cmdbuf, " ", MAX_CMD_LEN) >= MAX_CMD_LEN) || 50219acbbeafSnn (strlcat(cmdbuf, xml_file, MAX_CMD_LEN) >= MAX_CMD_LEN)) { 50229acbbeafSnn err = Z_BRAND_ERROR; 50239acbbeafSnn } else { 50249acbbeafSnn err = do_subproc(cmdbuf); 50259acbbeafSnn } 50269acbbeafSnn 50279acbbeafSnn (void) unlink(xml_file); 50289acbbeafSnn return ((err == Z_OK) ? Z_OK : Z_BRAND_ERROR); 50299acbbeafSnn } 50309acbbeafSnn 50317c478bd9Sstevel@tonic-gate /* 50327c478bd9Sstevel@tonic-gate * See the DTD for which attributes are required for which resources. 50337c478bd9Sstevel@tonic-gate * 50347c478bd9Sstevel@tonic-gate * This function can be called by commit_func(), which needs to save things, 50357c478bd9Sstevel@tonic-gate * in addition to the general call from parse_and_run(), which doesn't need 50367c478bd9Sstevel@tonic-gate * things saved. Since the parameters are standardized, we distinguish by 50377c478bd9Sstevel@tonic-gate * having commit_func() call here with cmd->cmd_arg set to "save" to indicate 50387c478bd9Sstevel@tonic-gate * that a save is needed. 50397c478bd9Sstevel@tonic-gate */ 50407c478bd9Sstevel@tonic-gate void 50417c478bd9Sstevel@tonic-gate verify_func(cmd_t *cmd) 50427c478bd9Sstevel@tonic-gate { 50437c478bd9Sstevel@tonic-gate struct zone_nwiftab nwiftab; 50447c478bd9Sstevel@tonic-gate struct zone_fstab fstab; 50457c478bd9Sstevel@tonic-gate struct zone_attrtab attrtab; 50467c478bd9Sstevel@tonic-gate struct zone_rctltab rctltab; 5047fa9e4066Sahrens struct zone_dstab dstab; 5048*0209230bSgjelinek struct zone_psettab psettab; 50497c478bd9Sstevel@tonic-gate char zonepath[MAXPATHLEN]; 5050*0209230bSgjelinek char sched[MAXNAMELEN]; 50519acbbeafSnn char brand[MAXNAMELEN]; 50527c478bd9Sstevel@tonic-gate int err, ret_val = Z_OK, arg; 50537c478bd9Sstevel@tonic-gate bool save = FALSE; 5054*0209230bSgjelinek boolean_t has_cpu_shares = B_FALSE; 50557c478bd9Sstevel@tonic-gate 50567c478bd9Sstevel@tonic-gate optind = 0; 50577c478bd9Sstevel@tonic-gate if ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?")) != EOF) { 50587c478bd9Sstevel@tonic-gate switch (arg) { 50597c478bd9Sstevel@tonic-gate case '?': 50607c478bd9Sstevel@tonic-gate longer_usage(CMD_VERIFY); 50617c478bd9Sstevel@tonic-gate return; 50627c478bd9Sstevel@tonic-gate default: 50637c478bd9Sstevel@tonic-gate short_usage(CMD_VERIFY); 50647c478bd9Sstevel@tonic-gate return; 50657c478bd9Sstevel@tonic-gate } 50667c478bd9Sstevel@tonic-gate } 50677c478bd9Sstevel@tonic-gate if (optind > cmd->cmd_argc) { 50687c478bd9Sstevel@tonic-gate short_usage(CMD_VERIFY); 50697c478bd9Sstevel@tonic-gate return; 50707c478bd9Sstevel@tonic-gate } 50717c478bd9Sstevel@tonic-gate 50727c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_VERIFY)) 50737c478bd9Sstevel@tonic-gate return; 50747c478bd9Sstevel@tonic-gate 50757c478bd9Sstevel@tonic-gate assert(cmd != NULL); 50767c478bd9Sstevel@tonic-gate 50777c478bd9Sstevel@tonic-gate if (cmd->cmd_argc > 0 && (strcmp(cmd->cmd_argv[0], "save") == 0)) 50787c478bd9Sstevel@tonic-gate save = TRUE; 50797c478bd9Sstevel@tonic-gate if (initialize(TRUE) != Z_OK) 50807c478bd9Sstevel@tonic-gate return; 50817c478bd9Sstevel@tonic-gate 5082*0209230bSgjelinek if (zonecfg_get_zonepath(handle, zonepath, sizeof (zonepath)) != Z_OK && 5083*0209230bSgjelinek !global_zone) { 5084087719fdSdp zerr(gettext("%s not specified"), pt_to_str(PT_ZONEPATH)); 50857c478bd9Sstevel@tonic-gate ret_val = Z_REQD_RESOURCE_MISSING; 50867c478bd9Sstevel@tonic-gate saw_error = TRUE; 50877c478bd9Sstevel@tonic-gate } 5088*0209230bSgjelinek if (strlen(zonepath) == 0 && !global_zone) { 5089087719fdSdp zerr(gettext("%s cannot be empty."), pt_to_str(PT_ZONEPATH)); 50907c478bd9Sstevel@tonic-gate ret_val = Z_REQD_RESOURCE_MISSING; 50917c478bd9Sstevel@tonic-gate saw_error = TRUE; 50927c478bd9Sstevel@tonic-gate } 50937c478bd9Sstevel@tonic-gate 50949acbbeafSnn if ((err = zonecfg_get_brand(handle, brand, sizeof (brand))) != Z_OK) { 50959acbbeafSnn zone_perror(zone, err, TRUE); 50969acbbeafSnn return; 50979acbbeafSnn } 50989acbbeafSnn if (strcmp(brand, NATIVE_BRAND_NAME) != 0) { 50999acbbeafSnn if ((err = brand_verify(handle)) != Z_OK) { 51009acbbeafSnn zone_perror(zone, err, TRUE); 51019acbbeafSnn return; 51029acbbeafSnn } 51039acbbeafSnn } 51049acbbeafSnn 51057c478bd9Sstevel@tonic-gate if ((err = zonecfg_setipdent(handle)) != Z_OK) { 51067c478bd9Sstevel@tonic-gate zone_perror(zone, err, TRUE); 51077c478bd9Sstevel@tonic-gate return; 51087c478bd9Sstevel@tonic-gate } 51097c478bd9Sstevel@tonic-gate while (zonecfg_getipdent(handle, &fstab) == Z_OK) { 5110087719fdSdp check_reqd_prop(fstab.zone_fs_dir, RT_IPD, PT_DIR, &ret_val); 51117c478bd9Sstevel@tonic-gate } 51127c478bd9Sstevel@tonic-gate (void) zonecfg_endipdent(handle); 51137c478bd9Sstevel@tonic-gate 51147c478bd9Sstevel@tonic-gate if ((err = zonecfg_setfsent(handle)) != Z_OK) { 51157c478bd9Sstevel@tonic-gate zone_perror(zone, err, TRUE); 51167c478bd9Sstevel@tonic-gate return; 51177c478bd9Sstevel@tonic-gate } 51187c478bd9Sstevel@tonic-gate while (zonecfg_getfsent(handle, &fstab) == Z_OK) { 5119087719fdSdp check_reqd_prop(fstab.zone_fs_dir, RT_FS, PT_DIR, &ret_val); 5120087719fdSdp check_reqd_prop(fstab.zone_fs_special, RT_FS, PT_SPECIAL, 5121087719fdSdp &ret_val); 5122087719fdSdp check_reqd_prop(fstab.zone_fs_type, RT_FS, PT_TYPE, &ret_val); 5123087719fdSdp 51247c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(fstab.zone_fs_options); 51257c478bd9Sstevel@tonic-gate } 51267c478bd9Sstevel@tonic-gate (void) zonecfg_endfsent(handle); 51277c478bd9Sstevel@tonic-gate 51287c478bd9Sstevel@tonic-gate if ((err = zonecfg_setnwifent(handle)) != Z_OK) { 51297c478bd9Sstevel@tonic-gate zone_perror(zone, err, TRUE); 51307c478bd9Sstevel@tonic-gate return; 51317c478bd9Sstevel@tonic-gate } 51327c478bd9Sstevel@tonic-gate while (zonecfg_getnwifent(handle, &nwiftab) == Z_OK) { 5133087719fdSdp check_reqd_prop(nwiftab.zone_nwif_address, RT_NET, 5134087719fdSdp PT_ADDRESS, &ret_val); 5135087719fdSdp check_reqd_prop(nwiftab.zone_nwif_physical, RT_NET, 5136087719fdSdp PT_PHYSICAL, &ret_val); 51377c478bd9Sstevel@tonic-gate } 51387c478bd9Sstevel@tonic-gate (void) zonecfg_endnwifent(handle); 51397c478bd9Sstevel@tonic-gate 51407c478bd9Sstevel@tonic-gate if ((err = zonecfg_setrctlent(handle)) != Z_OK) { 51417c478bd9Sstevel@tonic-gate zone_perror(zone, err, TRUE); 51427c478bd9Sstevel@tonic-gate return; 51437c478bd9Sstevel@tonic-gate } 51447c478bd9Sstevel@tonic-gate while (zonecfg_getrctlent(handle, &rctltab) == Z_OK) { 5145087719fdSdp check_reqd_prop(rctltab.zone_rctl_name, RT_RCTL, PT_NAME, 5146087719fdSdp &ret_val); 5147087719fdSdp 5148*0209230bSgjelinek if (strcmp(rctltab.zone_rctl_name, "zone.cpu-shares") == 0) 5149*0209230bSgjelinek has_cpu_shares = B_TRUE; 5150*0209230bSgjelinek 51517c478bd9Sstevel@tonic-gate if (rctltab.zone_rctl_valptr == NULL) { 51527c478bd9Sstevel@tonic-gate zerr(gettext("%s: no %s specified"), 51537c478bd9Sstevel@tonic-gate rt_to_str(RT_RCTL), pt_to_str(PT_VALUE)); 51547c478bd9Sstevel@tonic-gate saw_error = TRUE; 51557c478bd9Sstevel@tonic-gate if (ret_val == Z_OK) 51567c478bd9Sstevel@tonic-gate ret_val = Z_REQD_PROPERTY_MISSING; 51577c478bd9Sstevel@tonic-gate } else { 51587c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(rctltab.zone_rctl_valptr); 51597c478bd9Sstevel@tonic-gate } 51607c478bd9Sstevel@tonic-gate } 51617c478bd9Sstevel@tonic-gate (void) zonecfg_endrctlent(handle); 51627c478bd9Sstevel@tonic-gate 5163*0209230bSgjelinek if (zonecfg_lookup_pset(handle, &psettab) == Z_OK && has_cpu_shares) { 5164*0209230bSgjelinek zerr(gettext("%s zone.cpu-shares and %s are incompatible."), 5165*0209230bSgjelinek rt_to_str(RT_RCTL), rt_to_str(RT_DCPU)); 5166*0209230bSgjelinek saw_error = TRUE; 5167*0209230bSgjelinek if (ret_val == Z_OK) 5168*0209230bSgjelinek ret_val = Z_INCOMPATIBLE; 5169*0209230bSgjelinek } 5170*0209230bSgjelinek 5171*0209230bSgjelinek if (has_cpu_shares && zonecfg_get_sched_class(handle, sched, 5172*0209230bSgjelinek sizeof (sched)) == Z_OK && strlen(sched) > 0 && 5173*0209230bSgjelinek strcmp(sched, "FSS") != 0) { 5174*0209230bSgjelinek zerr(gettext("WARNING: %s zone.cpu-shares and %s=%s are " 5175*0209230bSgjelinek "incompatible"), 5176*0209230bSgjelinek rt_to_str(RT_RCTL), rt_to_str(RT_SCHED), sched); 5177*0209230bSgjelinek saw_error = TRUE; 5178*0209230bSgjelinek if (ret_val == Z_OK) 5179*0209230bSgjelinek ret_val = Z_INCOMPATIBLE; 5180*0209230bSgjelinek } 5181*0209230bSgjelinek 51827c478bd9Sstevel@tonic-gate if ((err = zonecfg_setattrent(handle)) != Z_OK) { 51837c478bd9Sstevel@tonic-gate zone_perror(zone, err, TRUE); 51847c478bd9Sstevel@tonic-gate return; 51857c478bd9Sstevel@tonic-gate } 51867c478bd9Sstevel@tonic-gate while (zonecfg_getattrent(handle, &attrtab) == Z_OK) { 5187087719fdSdp check_reqd_prop(attrtab.zone_attr_name, RT_ATTR, PT_NAME, 5188087719fdSdp &ret_val); 5189087719fdSdp check_reqd_prop(attrtab.zone_attr_type, RT_ATTR, PT_TYPE, 5190087719fdSdp &ret_val); 5191087719fdSdp check_reqd_prop(attrtab.zone_attr_value, RT_ATTR, PT_VALUE, 5192087719fdSdp &ret_val); 51937c478bd9Sstevel@tonic-gate } 51947c478bd9Sstevel@tonic-gate (void) zonecfg_endattrent(handle); 51957c478bd9Sstevel@tonic-gate 5196fa9e4066Sahrens if ((err = zonecfg_setdsent(handle)) != Z_OK) { 5197fa9e4066Sahrens zone_perror(zone, err, TRUE); 5198fa9e4066Sahrens return; 5199fa9e4066Sahrens } 5200fa9e4066Sahrens while (zonecfg_getdsent(handle, &dstab) == Z_OK) { 5201fa9e4066Sahrens if (strlen(dstab.zone_dataset_name) == 0) { 5202fa9e4066Sahrens zerr("%s: %s %s", rt_to_str(RT_DATASET), 5203fa9e4066Sahrens pt_to_str(PT_NAME), gettext("not specified")); 5204fa9e4066Sahrens saw_error = TRUE; 5205fa9e4066Sahrens if (ret_val == Z_OK) 5206fa9e4066Sahrens ret_val = Z_REQD_PROPERTY_MISSING; 5207fa9e4066Sahrens } else if (!zfs_name_valid(dstab.zone_dataset_name, 5208fa9e4066Sahrens ZFS_TYPE_FILESYSTEM)) { 5209fa9e4066Sahrens zerr("%s: %s %s", rt_to_str(RT_DATASET), 5210fa9e4066Sahrens pt_to_str(PT_NAME), gettext("invalid")); 5211fa9e4066Sahrens saw_error = TRUE; 5212fa9e4066Sahrens if (ret_val == Z_OK) 5213fa9e4066Sahrens ret_val = Z_BAD_PROPERTY; 5214fa9e4066Sahrens } 5215fa9e4066Sahrens 5216fa9e4066Sahrens } 5217fa9e4066Sahrens (void) zonecfg_enddsent(handle); 5218fa9e4066Sahrens 52197c478bd9Sstevel@tonic-gate if (!global_scope) { 52207c478bd9Sstevel@tonic-gate zerr(gettext("resource specification incomplete")); 52217c478bd9Sstevel@tonic-gate saw_error = TRUE; 52227c478bd9Sstevel@tonic-gate if (ret_val == Z_OK) 52237c478bd9Sstevel@tonic-gate ret_val = Z_INSUFFICIENT_SPEC; 52247c478bd9Sstevel@tonic-gate } 52257c478bd9Sstevel@tonic-gate 52267c478bd9Sstevel@tonic-gate if (save) { 5227087719fdSdp if (ret_val == Z_OK) { 5228087719fdSdp if ((ret_val = zonecfg_save(handle)) == Z_OK) { 5229087719fdSdp need_to_commit = FALSE; 5230087719fdSdp (void) strlcpy(revert_zone, zone, 5231087719fdSdp sizeof (revert_zone)); 5232087719fdSdp } 5233087719fdSdp } else { 5234087719fdSdp zerr(gettext("Zone %s failed to verify"), zone); 5235087719fdSdp } 52367c478bd9Sstevel@tonic-gate } 52377c478bd9Sstevel@tonic-gate if (ret_val != Z_OK) 52387c478bd9Sstevel@tonic-gate zone_perror(zone, ret_val, TRUE); 52397c478bd9Sstevel@tonic-gate } 52407c478bd9Sstevel@tonic-gate 52417c478bd9Sstevel@tonic-gate void 52427c478bd9Sstevel@tonic-gate cancel_func(cmd_t *cmd) 52437c478bd9Sstevel@tonic-gate { 52447c478bd9Sstevel@tonic-gate int arg; 52457c478bd9Sstevel@tonic-gate 52467c478bd9Sstevel@tonic-gate assert(cmd != NULL); 52477c478bd9Sstevel@tonic-gate 52487c478bd9Sstevel@tonic-gate optind = 0; 52497c478bd9Sstevel@tonic-gate if ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?")) != EOF) { 52507c478bd9Sstevel@tonic-gate switch (arg) { 52517c478bd9Sstevel@tonic-gate case '?': 52527c478bd9Sstevel@tonic-gate longer_usage(CMD_CANCEL); 52537c478bd9Sstevel@tonic-gate return; 52547c478bd9Sstevel@tonic-gate default: 52557c478bd9Sstevel@tonic-gate short_usage(CMD_CANCEL); 52567c478bd9Sstevel@tonic-gate return; 52577c478bd9Sstevel@tonic-gate } 52587c478bd9Sstevel@tonic-gate } 52597c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 52607c478bd9Sstevel@tonic-gate short_usage(CMD_CANCEL); 52617c478bd9Sstevel@tonic-gate return; 52627c478bd9Sstevel@tonic-gate } 52637c478bd9Sstevel@tonic-gate 52647c478bd9Sstevel@tonic-gate if (global_scope) 52657c478bd9Sstevel@tonic-gate scope_usage(CMD_CANCEL); 52667c478bd9Sstevel@tonic-gate global_scope = TRUE; 52677c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(in_progress_fstab.zone_fs_options); 52687c478bd9Sstevel@tonic-gate bzero(&in_progress_fstab, sizeof (in_progress_fstab)); 52697c478bd9Sstevel@tonic-gate bzero(&in_progress_nwiftab, sizeof (in_progress_nwiftab)); 5270fa9e4066Sahrens bzero(&in_progress_ipdtab, sizeof (in_progress_ipdtab)); 52717c478bd9Sstevel@tonic-gate bzero(&in_progress_devtab, sizeof (in_progress_devtab)); 52727c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list(in_progress_rctltab.zone_rctl_valptr); 52737c478bd9Sstevel@tonic-gate bzero(&in_progress_rctltab, sizeof (in_progress_rctltab)); 52747c478bd9Sstevel@tonic-gate bzero(&in_progress_attrtab, sizeof (in_progress_attrtab)); 5275fa9e4066Sahrens bzero(&in_progress_dstab, sizeof (in_progress_dstab)); 52767c478bd9Sstevel@tonic-gate } 52777c478bd9Sstevel@tonic-gate 52787c478bd9Sstevel@tonic-gate static int 52797c478bd9Sstevel@tonic-gate validate_attr_name(char *name) 52807c478bd9Sstevel@tonic-gate { 52817c478bd9Sstevel@tonic-gate int i; 52827c478bd9Sstevel@tonic-gate 52837c478bd9Sstevel@tonic-gate if (!isalnum(name[0])) { 52847c478bd9Sstevel@tonic-gate zerr(gettext("Invalid %s %s %s: must start with an alpha-" 52857c478bd9Sstevel@tonic-gate "numeric character."), rt_to_str(RT_ATTR), 52867c478bd9Sstevel@tonic-gate pt_to_str(PT_NAME), name); 52877c478bd9Sstevel@tonic-gate return (Z_INVAL); 52887c478bd9Sstevel@tonic-gate } 52897c478bd9Sstevel@tonic-gate for (i = 1; name[i]; i++) 52907c478bd9Sstevel@tonic-gate if (!isalnum(name[i]) && name[i] != '-' && name[i] != '.') { 52917c478bd9Sstevel@tonic-gate zerr(gettext("Invalid %s %s %s: can only contain " 52927c478bd9Sstevel@tonic-gate "alpha-numeric characters, plus '-' and '.'."), 52937c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR), pt_to_str(PT_NAME), name); 52947c478bd9Sstevel@tonic-gate return (Z_INVAL); 52957c478bd9Sstevel@tonic-gate } 52967c478bd9Sstevel@tonic-gate return (Z_OK); 52977c478bd9Sstevel@tonic-gate } 52987c478bd9Sstevel@tonic-gate 52997c478bd9Sstevel@tonic-gate static int 53007c478bd9Sstevel@tonic-gate validate_attr_type_val(struct zone_attrtab *attrtab) 53017c478bd9Sstevel@tonic-gate { 53027c478bd9Sstevel@tonic-gate boolean_t boolval; 53037c478bd9Sstevel@tonic-gate int64_t intval; 53047c478bd9Sstevel@tonic-gate char strval[MAXNAMELEN]; 53057c478bd9Sstevel@tonic-gate uint64_t uintval; 53067c478bd9Sstevel@tonic-gate 53077c478bd9Sstevel@tonic-gate if (strcmp(attrtab->zone_attr_type, "boolean") == 0) { 53087c478bd9Sstevel@tonic-gate if (zonecfg_get_attr_boolean(attrtab, &boolval) == Z_OK) 53097c478bd9Sstevel@tonic-gate return (Z_OK); 53107c478bd9Sstevel@tonic-gate zerr(gettext("invalid %s value for %s=%s"), 53117c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR), pt_to_str(PT_TYPE), "boolean"); 53127c478bd9Sstevel@tonic-gate return (Z_ERR); 53137c478bd9Sstevel@tonic-gate } 53147c478bd9Sstevel@tonic-gate 53157c478bd9Sstevel@tonic-gate if (strcmp(attrtab->zone_attr_type, "int") == 0) { 53167c478bd9Sstevel@tonic-gate if (zonecfg_get_attr_int(attrtab, &intval) == Z_OK) 53177c478bd9Sstevel@tonic-gate return (Z_OK); 53187c478bd9Sstevel@tonic-gate zerr(gettext("invalid %s value for %s=%s"), 53197c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR), pt_to_str(PT_TYPE), "int"); 53207c478bd9Sstevel@tonic-gate return (Z_ERR); 53217c478bd9Sstevel@tonic-gate } 53227c478bd9Sstevel@tonic-gate 53237c478bd9Sstevel@tonic-gate if (strcmp(attrtab->zone_attr_type, "string") == 0) { 53247c478bd9Sstevel@tonic-gate if (zonecfg_get_attr_string(attrtab, strval, 53257c478bd9Sstevel@tonic-gate sizeof (strval)) == Z_OK) 53267c478bd9Sstevel@tonic-gate return (Z_OK); 53277c478bd9Sstevel@tonic-gate zerr(gettext("invalid %s value for %s=%s"), 53287c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR), pt_to_str(PT_TYPE), "string"); 53297c478bd9Sstevel@tonic-gate return (Z_ERR); 53307c478bd9Sstevel@tonic-gate } 53317c478bd9Sstevel@tonic-gate 53327c478bd9Sstevel@tonic-gate if (strcmp(attrtab->zone_attr_type, "uint") == 0) { 53337c478bd9Sstevel@tonic-gate if (zonecfg_get_attr_uint(attrtab, &uintval) == Z_OK) 53347c478bd9Sstevel@tonic-gate return (Z_OK); 53357c478bd9Sstevel@tonic-gate zerr(gettext("invalid %s value for %s=%s"), 53367c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR), pt_to_str(PT_TYPE), "uint"); 53377c478bd9Sstevel@tonic-gate return (Z_ERR); 53387c478bd9Sstevel@tonic-gate } 53397c478bd9Sstevel@tonic-gate 53407c478bd9Sstevel@tonic-gate zerr(gettext("invalid %s %s '%s'"), rt_to_str(RT_ATTR), 53417c478bd9Sstevel@tonic-gate pt_to_str(PT_TYPE), attrtab->zone_attr_type); 53427c478bd9Sstevel@tonic-gate return (Z_ERR); 53437c478bd9Sstevel@tonic-gate } 53447c478bd9Sstevel@tonic-gate 5345087719fdSdp /* 5346087719fdSdp * Helper function for end_func-- checks the existence of a given property 5347087719fdSdp * and emits a message if not specified. 5348087719fdSdp */ 5349087719fdSdp static int 5350087719fdSdp end_check_reqd(char *attr, int pt, bool *validation_failed) 5351087719fdSdp { 5352087719fdSdp if (strlen(attr) == 0) { 5353087719fdSdp *validation_failed = TRUE; 5354087719fdSdp zerr(gettext("%s not specified"), pt_to_str(pt)); 5355087719fdSdp return (Z_ERR); 5356087719fdSdp } 5357087719fdSdp return (Z_OK); 5358087719fdSdp } 5359087719fdSdp 53607c478bd9Sstevel@tonic-gate void 53617c478bd9Sstevel@tonic-gate end_func(cmd_t *cmd) 53627c478bd9Sstevel@tonic-gate { 53637c478bd9Sstevel@tonic-gate bool validation_failed = FALSE; 53647c478bd9Sstevel@tonic-gate struct zone_fstab tmp_fstab; 53657c478bd9Sstevel@tonic-gate struct zone_nwiftab tmp_nwiftab; 53667c478bd9Sstevel@tonic-gate struct zone_devtab tmp_devtab; 53677c478bd9Sstevel@tonic-gate struct zone_rctltab tmp_rctltab; 53687c478bd9Sstevel@tonic-gate struct zone_attrtab tmp_attrtab; 5369fa9e4066Sahrens struct zone_dstab tmp_dstab; 5370*0209230bSgjelinek int err, arg, res1, res2, res3; 5371*0209230bSgjelinek uint64_t swap_limit; 5372*0209230bSgjelinek uint64_t locked_limit; 53737c478bd9Sstevel@tonic-gate 53747c478bd9Sstevel@tonic-gate assert(cmd != NULL); 53757c478bd9Sstevel@tonic-gate 53767c478bd9Sstevel@tonic-gate optind = 0; 53777c478bd9Sstevel@tonic-gate if ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?")) != EOF) { 53787c478bd9Sstevel@tonic-gate switch (arg) { 53797c478bd9Sstevel@tonic-gate case '?': 53807c478bd9Sstevel@tonic-gate longer_usage(CMD_END); 53817c478bd9Sstevel@tonic-gate return; 53827c478bd9Sstevel@tonic-gate default: 53837c478bd9Sstevel@tonic-gate short_usage(CMD_END); 53847c478bd9Sstevel@tonic-gate return; 53857c478bd9Sstevel@tonic-gate } 53867c478bd9Sstevel@tonic-gate } 53877c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 53887c478bd9Sstevel@tonic-gate short_usage(CMD_END); 53897c478bd9Sstevel@tonic-gate return; 53907c478bd9Sstevel@tonic-gate } 53917c478bd9Sstevel@tonic-gate 53927c478bd9Sstevel@tonic-gate if (global_scope) { 53937c478bd9Sstevel@tonic-gate scope_usage(CMD_END); 53947c478bd9Sstevel@tonic-gate return; 53957c478bd9Sstevel@tonic-gate } 53967c478bd9Sstevel@tonic-gate 53977c478bd9Sstevel@tonic-gate assert(end_op == CMD_ADD || end_op == CMD_SELECT); 53987c478bd9Sstevel@tonic-gate 53997c478bd9Sstevel@tonic-gate switch (resource_scope) { 54007c478bd9Sstevel@tonic-gate case RT_FS: 54017c478bd9Sstevel@tonic-gate /* First make sure everything was filled in. */ 5402087719fdSdp if (end_check_reqd(in_progress_fstab.zone_fs_dir, 5403087719fdSdp PT_DIR, &validation_failed) == Z_OK) { 5404087719fdSdp if (in_progress_fstab.zone_fs_dir[0] != '/') { 5405087719fdSdp zerr(gettext("%s %s is not an absolute path."), 5406087719fdSdp pt_to_str(PT_DIR), 5407087719fdSdp in_progress_fstab.zone_fs_dir); 5408087719fdSdp validation_failed = TRUE; 5409087719fdSdp } 54107c478bd9Sstevel@tonic-gate } 5411087719fdSdp 5412087719fdSdp (void) end_check_reqd(in_progress_fstab.zone_fs_special, 5413087719fdSdp PT_SPECIAL, &validation_failed); 5414087719fdSdp 54157c478bd9Sstevel@tonic-gate if (in_progress_fstab.zone_fs_raw[0] != '\0' && 54167c478bd9Sstevel@tonic-gate in_progress_fstab.zone_fs_raw[0] != '/') { 5417087719fdSdp zerr(gettext("%s %s is not an absolute path."), 5418087719fdSdp pt_to_str(PT_RAW), 5419087719fdSdp in_progress_fstab.zone_fs_raw); 54207c478bd9Sstevel@tonic-gate validation_failed = TRUE; 54217c478bd9Sstevel@tonic-gate } 5422087719fdSdp 5423087719fdSdp (void) end_check_reqd(in_progress_fstab.zone_fs_type, PT_TYPE, 5424087719fdSdp &validation_failed); 5425087719fdSdp 5426087719fdSdp if (validation_failed) { 54277c478bd9Sstevel@tonic-gate saw_error = TRUE; 54287c478bd9Sstevel@tonic-gate return; 5429087719fdSdp } 5430087719fdSdp 54317c478bd9Sstevel@tonic-gate if (end_op == CMD_ADD) { 54327c478bd9Sstevel@tonic-gate /* Make sure there isn't already one like this. */ 54337c478bd9Sstevel@tonic-gate bzero(&tmp_fstab, sizeof (tmp_fstab)); 54347c478bd9Sstevel@tonic-gate (void) strlcpy(tmp_fstab.zone_fs_dir, 54357c478bd9Sstevel@tonic-gate in_progress_fstab.zone_fs_dir, 54367c478bd9Sstevel@tonic-gate sizeof (tmp_fstab.zone_fs_dir)); 54377c478bd9Sstevel@tonic-gate err = zonecfg_lookup_filesystem(handle, &tmp_fstab); 54387c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(tmp_fstab.zone_fs_options); 54397c478bd9Sstevel@tonic-gate if (err == Z_OK) { 54407c478bd9Sstevel@tonic-gate zerr(gettext("A %s resource " 54417c478bd9Sstevel@tonic-gate "with the %s '%s' already exists."), 54427c478bd9Sstevel@tonic-gate rt_to_str(RT_FS), pt_to_str(PT_DIR), 54437c478bd9Sstevel@tonic-gate in_progress_fstab.zone_fs_dir); 54447c478bd9Sstevel@tonic-gate saw_error = TRUE; 54457c478bd9Sstevel@tonic-gate return; 54467c478bd9Sstevel@tonic-gate } 54477c478bd9Sstevel@tonic-gate err = zonecfg_add_filesystem(handle, 54487c478bd9Sstevel@tonic-gate &in_progress_fstab); 54497c478bd9Sstevel@tonic-gate } else { 54507c478bd9Sstevel@tonic-gate err = zonecfg_modify_filesystem(handle, &old_fstab, 54517c478bd9Sstevel@tonic-gate &in_progress_fstab); 54527c478bd9Sstevel@tonic-gate } 54537c478bd9Sstevel@tonic-gate zonecfg_free_fs_option_list(in_progress_fstab.zone_fs_options); 54547c478bd9Sstevel@tonic-gate in_progress_fstab.zone_fs_options = NULL; 54557c478bd9Sstevel@tonic-gate break; 5456087719fdSdp 54577c478bd9Sstevel@tonic-gate case RT_IPD: 54587c478bd9Sstevel@tonic-gate /* First make sure everything was filled in. */ 5459087719fdSdp if (end_check_reqd(in_progress_ipdtab.zone_fs_dir, PT_DIR, 5460087719fdSdp &validation_failed) == Z_OK) { 5461087719fdSdp if (in_progress_ipdtab.zone_fs_dir[0] != '/') { 5462087719fdSdp zerr(gettext("%s %s is not an absolute path."), 5463087719fdSdp pt_to_str(PT_DIR), 5464087719fdSdp in_progress_ipdtab.zone_fs_dir); 5465087719fdSdp validation_failed = TRUE; 5466087719fdSdp } 54677c478bd9Sstevel@tonic-gate } 5468087719fdSdp if (validation_failed) { 5469087719fdSdp saw_error = TRUE; 54707c478bd9Sstevel@tonic-gate return; 5471087719fdSdp } 5472087719fdSdp 54737c478bd9Sstevel@tonic-gate if (end_op == CMD_ADD) { 54747c478bd9Sstevel@tonic-gate /* Make sure there isn't already one like this. */ 54757c478bd9Sstevel@tonic-gate bzero(&tmp_fstab, sizeof (tmp_fstab)); 54767c478bd9Sstevel@tonic-gate (void) strlcpy(tmp_fstab.zone_fs_dir, 54777c478bd9Sstevel@tonic-gate in_progress_ipdtab.zone_fs_dir, 54787c478bd9Sstevel@tonic-gate sizeof (tmp_fstab.zone_fs_dir)); 54797c478bd9Sstevel@tonic-gate err = zonecfg_lookup_ipd(handle, &tmp_fstab); 54807c478bd9Sstevel@tonic-gate if (err == Z_OK) { 54817c478bd9Sstevel@tonic-gate zerr(gettext("An %s resource " 54827c478bd9Sstevel@tonic-gate "with the %s '%s' already exists."), 54837c478bd9Sstevel@tonic-gate rt_to_str(RT_IPD), pt_to_str(PT_DIR), 54847c478bd9Sstevel@tonic-gate in_progress_ipdtab.zone_fs_dir); 54857c478bd9Sstevel@tonic-gate saw_error = TRUE; 54867c478bd9Sstevel@tonic-gate return; 54877c478bd9Sstevel@tonic-gate } 54887c478bd9Sstevel@tonic-gate err = zonecfg_add_ipd(handle, &in_progress_ipdtab); 54897c478bd9Sstevel@tonic-gate } else { 54907c478bd9Sstevel@tonic-gate err = zonecfg_modify_ipd(handle, &old_ipdtab, 54917c478bd9Sstevel@tonic-gate &in_progress_ipdtab); 54927c478bd9Sstevel@tonic-gate } 54937c478bd9Sstevel@tonic-gate break; 54947c478bd9Sstevel@tonic-gate case RT_NET: 54957c478bd9Sstevel@tonic-gate /* First make sure everything was filled in. */ 5496087719fdSdp (void) end_check_reqd(in_progress_nwiftab.zone_nwif_physical, 5497087719fdSdp PT_PHYSICAL, &validation_failed); 5498087719fdSdp (void) end_check_reqd(in_progress_nwiftab.zone_nwif_address, 5499087719fdSdp PT_ADDRESS, &validation_failed); 5500087719fdSdp 5501087719fdSdp if (validation_failed) { 55027c478bd9Sstevel@tonic-gate saw_error = TRUE; 55037c478bd9Sstevel@tonic-gate return; 5504087719fdSdp } 5505087719fdSdp 55067c478bd9Sstevel@tonic-gate if (end_op == CMD_ADD) { 55077c478bd9Sstevel@tonic-gate /* Make sure there isn't already one like this. */ 55087c478bd9Sstevel@tonic-gate bzero(&tmp_nwiftab, sizeof (tmp_nwiftab)); 55097c478bd9Sstevel@tonic-gate (void) strlcpy(tmp_nwiftab.zone_nwif_address, 55107c478bd9Sstevel@tonic-gate in_progress_nwiftab.zone_nwif_address, 55117c478bd9Sstevel@tonic-gate sizeof (tmp_nwiftab.zone_nwif_address)); 55127c478bd9Sstevel@tonic-gate if (zonecfg_lookup_nwif(handle, &tmp_nwiftab) == Z_OK) { 55137c478bd9Sstevel@tonic-gate zerr(gettext("A %s resource " 55147c478bd9Sstevel@tonic-gate "with the %s '%s' already exists."), 55157c478bd9Sstevel@tonic-gate rt_to_str(RT_NET), pt_to_str(PT_ADDRESS), 55167c478bd9Sstevel@tonic-gate in_progress_nwiftab.zone_nwif_address); 55177c478bd9Sstevel@tonic-gate saw_error = TRUE; 55187c478bd9Sstevel@tonic-gate return; 55197c478bd9Sstevel@tonic-gate } 55207c478bd9Sstevel@tonic-gate err = zonecfg_add_nwif(handle, &in_progress_nwiftab); 55217c478bd9Sstevel@tonic-gate } else { 55227c478bd9Sstevel@tonic-gate err = zonecfg_modify_nwif(handle, &old_nwiftab, 55237c478bd9Sstevel@tonic-gate &in_progress_nwiftab); 55247c478bd9Sstevel@tonic-gate } 55257c478bd9Sstevel@tonic-gate break; 5526087719fdSdp 55277c478bd9Sstevel@tonic-gate case RT_DEVICE: 55287c478bd9Sstevel@tonic-gate /* First make sure everything was filled in. */ 5529087719fdSdp (void) end_check_reqd(in_progress_devtab.zone_dev_match, 5530087719fdSdp PT_MATCH, &validation_failed); 5531087719fdSdp 5532087719fdSdp if (validation_failed) { 55337c478bd9Sstevel@tonic-gate saw_error = TRUE; 55347c478bd9Sstevel@tonic-gate return; 5535087719fdSdp } 5536087719fdSdp 55377c478bd9Sstevel@tonic-gate if (end_op == CMD_ADD) { 55387c478bd9Sstevel@tonic-gate /* Make sure there isn't already one like this. */ 55397c478bd9Sstevel@tonic-gate (void) strlcpy(tmp_devtab.zone_dev_match, 55407c478bd9Sstevel@tonic-gate in_progress_devtab.zone_dev_match, 55417c478bd9Sstevel@tonic-gate sizeof (tmp_devtab.zone_dev_match)); 55427c478bd9Sstevel@tonic-gate if (zonecfg_lookup_dev(handle, &tmp_devtab) == Z_OK) { 55437c478bd9Sstevel@tonic-gate zerr(gettext("A %s resource with the %s '%s' " 55447c478bd9Sstevel@tonic-gate "already exists."), rt_to_str(RT_DEVICE), 55457c478bd9Sstevel@tonic-gate pt_to_str(PT_MATCH), 55467c478bd9Sstevel@tonic-gate in_progress_devtab.zone_dev_match); 55477c478bd9Sstevel@tonic-gate saw_error = TRUE; 55487c478bd9Sstevel@tonic-gate return; 55497c478bd9Sstevel@tonic-gate } 55507c478bd9Sstevel@tonic-gate err = zonecfg_add_dev(handle, &in_progress_devtab); 55517c478bd9Sstevel@tonic-gate } else { 55527c478bd9Sstevel@tonic-gate err = zonecfg_modify_dev(handle, &old_devtab, 55537c478bd9Sstevel@tonic-gate &in_progress_devtab); 55547c478bd9Sstevel@tonic-gate } 55557c478bd9Sstevel@tonic-gate break; 5556087719fdSdp 55577c478bd9Sstevel@tonic-gate case RT_RCTL: 55587c478bd9Sstevel@tonic-gate /* First make sure everything was filled in. */ 5559087719fdSdp (void) end_check_reqd(in_progress_rctltab.zone_rctl_name, 5560087719fdSdp PT_NAME, &validation_failed); 5561087719fdSdp 55627c478bd9Sstevel@tonic-gate if (in_progress_rctltab.zone_rctl_valptr == NULL) { 55637c478bd9Sstevel@tonic-gate zerr(gettext("no %s specified"), pt_to_str(PT_VALUE)); 55647c478bd9Sstevel@tonic-gate validation_failed = TRUE; 55657c478bd9Sstevel@tonic-gate } 5566087719fdSdp 5567087719fdSdp if (validation_failed) { 5568087719fdSdp saw_error = TRUE; 55697c478bd9Sstevel@tonic-gate return; 5570087719fdSdp } 5571087719fdSdp 55727c478bd9Sstevel@tonic-gate if (end_op == CMD_ADD) { 55737c478bd9Sstevel@tonic-gate /* Make sure there isn't already one like this. */ 55747c478bd9Sstevel@tonic-gate (void) strlcpy(tmp_rctltab.zone_rctl_name, 55757c478bd9Sstevel@tonic-gate in_progress_rctltab.zone_rctl_name, 55767c478bd9Sstevel@tonic-gate sizeof (tmp_rctltab.zone_rctl_name)); 55777c478bd9Sstevel@tonic-gate tmp_rctltab.zone_rctl_valptr = NULL; 55787c478bd9Sstevel@tonic-gate err = zonecfg_lookup_rctl(handle, &tmp_rctltab); 55797c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list( 55807c478bd9Sstevel@tonic-gate tmp_rctltab.zone_rctl_valptr); 55817c478bd9Sstevel@tonic-gate if (err == Z_OK) { 55827c478bd9Sstevel@tonic-gate zerr(gettext("A %s resource " 55837c478bd9Sstevel@tonic-gate "with the %s '%s' already exists."), 55847c478bd9Sstevel@tonic-gate rt_to_str(RT_RCTL), pt_to_str(PT_NAME), 55857c478bd9Sstevel@tonic-gate in_progress_rctltab.zone_rctl_name); 55867c478bd9Sstevel@tonic-gate saw_error = TRUE; 55877c478bd9Sstevel@tonic-gate return; 55887c478bd9Sstevel@tonic-gate } 55897c478bd9Sstevel@tonic-gate err = zonecfg_add_rctl(handle, &in_progress_rctltab); 55907c478bd9Sstevel@tonic-gate } else { 55917c478bd9Sstevel@tonic-gate err = zonecfg_modify_rctl(handle, &old_rctltab, 55927c478bd9Sstevel@tonic-gate &in_progress_rctltab); 55937c478bd9Sstevel@tonic-gate } 55947c478bd9Sstevel@tonic-gate if (err == Z_OK) { 55957c478bd9Sstevel@tonic-gate zonecfg_free_rctl_value_list( 55967c478bd9Sstevel@tonic-gate in_progress_rctltab.zone_rctl_valptr); 55977c478bd9Sstevel@tonic-gate in_progress_rctltab.zone_rctl_valptr = NULL; 55987c478bd9Sstevel@tonic-gate } 55997c478bd9Sstevel@tonic-gate break; 5600087719fdSdp 56017c478bd9Sstevel@tonic-gate case RT_ATTR: 56027c478bd9Sstevel@tonic-gate /* First make sure everything was filled in. */ 5603087719fdSdp (void) end_check_reqd(in_progress_attrtab.zone_attr_name, 5604087719fdSdp PT_NAME, &validation_failed); 5605087719fdSdp (void) end_check_reqd(in_progress_attrtab.zone_attr_type, 5606087719fdSdp PT_TYPE, &validation_failed); 5607087719fdSdp (void) end_check_reqd(in_progress_attrtab.zone_attr_value, 5608087719fdSdp PT_VALUE, &validation_failed); 5609087719fdSdp 56107c478bd9Sstevel@tonic-gate if (validate_attr_name(in_progress_attrtab.zone_attr_name) != 5611087719fdSdp Z_OK) 56127c478bd9Sstevel@tonic-gate validation_failed = TRUE; 5613087719fdSdp 5614087719fdSdp if (validate_attr_type_val(&in_progress_attrtab) != Z_OK) 56157c478bd9Sstevel@tonic-gate validation_failed = TRUE; 5616087719fdSdp 5617087719fdSdp if (validation_failed) { 5618087719fdSdp saw_error = TRUE; 56197c478bd9Sstevel@tonic-gate return; 5620087719fdSdp } 56217c478bd9Sstevel@tonic-gate if (end_op == CMD_ADD) { 56227c478bd9Sstevel@tonic-gate /* Make sure there isn't already one like this. */ 56237c478bd9Sstevel@tonic-gate bzero(&tmp_attrtab, sizeof (tmp_attrtab)); 56247c478bd9Sstevel@tonic-gate (void) strlcpy(tmp_attrtab.zone_attr_name, 56257c478bd9Sstevel@tonic-gate in_progress_attrtab.zone_attr_name, 56267c478bd9Sstevel@tonic-gate sizeof (tmp_attrtab.zone_attr_name)); 56277c478bd9Sstevel@tonic-gate if (zonecfg_lookup_attr(handle, &tmp_attrtab) == Z_OK) { 56287c478bd9Sstevel@tonic-gate zerr(gettext("An %s resource " 56297c478bd9Sstevel@tonic-gate "with the %s '%s' already exists."), 56307c478bd9Sstevel@tonic-gate rt_to_str(RT_ATTR), pt_to_str(PT_NAME), 56317c478bd9Sstevel@tonic-gate in_progress_attrtab.zone_attr_name); 56327c478bd9Sstevel@tonic-gate saw_error = TRUE; 56337c478bd9Sstevel@tonic-gate return; 56347c478bd9Sstevel@tonic-gate } 56357c478bd9Sstevel@tonic-gate err = zonecfg_add_attr(handle, &in_progress_attrtab); 56367c478bd9Sstevel@tonic-gate } else { 56377c478bd9Sstevel@tonic-gate err = zonecfg_modify_attr(handle, &old_attrtab, 56387c478bd9Sstevel@tonic-gate &in_progress_attrtab); 56397c478bd9Sstevel@tonic-gate } 56407c478bd9Sstevel@tonic-gate break; 5641fa9e4066Sahrens case RT_DATASET: 5642fa9e4066Sahrens /* First make sure everything was filled in. */ 5643fa9e4066Sahrens if (strlen(in_progress_dstab.zone_dataset_name) == 0) { 5644fa9e4066Sahrens zerr("%s %s", pt_to_str(PT_NAME), 5645fa9e4066Sahrens gettext("not specified")); 5646fa9e4066Sahrens saw_error = TRUE; 5647fa9e4066Sahrens validation_failed = TRUE; 5648fa9e4066Sahrens } 5649fa9e4066Sahrens if (validation_failed) 5650fa9e4066Sahrens return; 5651fa9e4066Sahrens if (end_op == CMD_ADD) { 5652fa9e4066Sahrens /* Make sure there isn't already one like this. */ 5653fa9e4066Sahrens bzero(&tmp_dstab, sizeof (tmp_dstab)); 5654fa9e4066Sahrens (void) strlcpy(tmp_dstab.zone_dataset_name, 5655fa9e4066Sahrens in_progress_dstab.zone_dataset_name, 5656fa9e4066Sahrens sizeof (tmp_dstab.zone_dataset_name)); 5657fa9e4066Sahrens err = zonecfg_lookup_ds(handle, &tmp_dstab); 5658fa9e4066Sahrens if (err == Z_OK) { 5659fa9e4066Sahrens zerr(gettext("A %s resource " 5660fa9e4066Sahrens "with the %s '%s' already exists."), 5661fa9e4066Sahrens rt_to_str(RT_DATASET), pt_to_str(PT_NAME), 5662fa9e4066Sahrens in_progress_dstab.zone_dataset_name); 5663fa9e4066Sahrens saw_error = TRUE; 5664fa9e4066Sahrens return; 5665fa9e4066Sahrens } 5666fa9e4066Sahrens err = zonecfg_add_ds(handle, &in_progress_dstab); 5667fa9e4066Sahrens } else { 5668fa9e4066Sahrens err = zonecfg_modify_ds(handle, &old_dstab, 5669fa9e4066Sahrens &in_progress_dstab); 5670fa9e4066Sahrens } 5671fa9e4066Sahrens break; 5672*0209230bSgjelinek case RT_DCPU: 5673*0209230bSgjelinek /* Make sure everything was filled in. */ 5674*0209230bSgjelinek if (end_check_reqd(in_progress_psettab.zone_ncpu_min, 5675*0209230bSgjelinek PT_NCPUS, &validation_failed) != Z_OK) { 5676*0209230bSgjelinek saw_error = TRUE; 5677*0209230bSgjelinek return; 5678*0209230bSgjelinek } 5679*0209230bSgjelinek 5680*0209230bSgjelinek if (end_op == CMD_ADD) { 5681*0209230bSgjelinek err = zonecfg_add_pset(handle, &in_progress_psettab); 5682*0209230bSgjelinek } else { 5683*0209230bSgjelinek err = zonecfg_modify_pset(handle, &in_progress_psettab); 5684*0209230bSgjelinek } 5685*0209230bSgjelinek break; 5686*0209230bSgjelinek case RT_MCAP: 5687*0209230bSgjelinek /* Make sure everything was filled in. */ 5688*0209230bSgjelinek res1 = strlen(in_progress_mcaptab.zone_physmem_cap) == 0 ? 5689*0209230bSgjelinek Z_ERR : Z_OK; 5690*0209230bSgjelinek res2 = zonecfg_get_aliased_rctl(handle, ALIAS_MAXSWAP, 5691*0209230bSgjelinek &swap_limit); 5692*0209230bSgjelinek res3 = zonecfg_get_aliased_rctl(handle, ALIAS_MAXLOCKEDMEM, 5693*0209230bSgjelinek &locked_limit); 5694*0209230bSgjelinek 5695*0209230bSgjelinek if (res1 != Z_OK && res2 != Z_OK && res3 != Z_OK) { 5696*0209230bSgjelinek zerr(gettext("No property was specified. One of %s, " 5697*0209230bSgjelinek "%s or %s is required."), pt_to_str(PT_PHYSICAL), 5698*0209230bSgjelinek pt_to_str(PT_SWAP), pt_to_str(PT_LOCKED)); 5699*0209230bSgjelinek saw_error = TRUE; 5700*0209230bSgjelinek return; 5701*0209230bSgjelinek } 5702*0209230bSgjelinek 5703*0209230bSgjelinek /* if phys & locked are both set, verify locked <= phys */ 5704*0209230bSgjelinek if (res1 == Z_OK && res3 == Z_OK) { 5705*0209230bSgjelinek uint64_t phys_limit; 5706*0209230bSgjelinek char *endp; 5707*0209230bSgjelinek 5708*0209230bSgjelinek phys_limit = strtoull( 5709*0209230bSgjelinek in_progress_mcaptab.zone_physmem_cap, &endp, 10); 5710*0209230bSgjelinek if (phys_limit < locked_limit) { 5711*0209230bSgjelinek zerr(gettext("The %s cap must be less than or " 5712*0209230bSgjelinek "equal to the %s cap."), 5713*0209230bSgjelinek pt_to_str(PT_LOCKED), 5714*0209230bSgjelinek pt_to_str(PT_PHYSICAL)); 5715*0209230bSgjelinek saw_error = TRUE; 5716*0209230bSgjelinek return; 5717*0209230bSgjelinek } 5718*0209230bSgjelinek } 5719*0209230bSgjelinek 5720*0209230bSgjelinek err = Z_OK; 5721*0209230bSgjelinek if (res1 == Z_OK) { 5722*0209230bSgjelinek /* 5723*0209230bSgjelinek * We could be ending from either an add operation 5724*0209230bSgjelinek * or a select operation. Since all of the properties 5725*0209230bSgjelinek * within this resource are optional, we always use 5726*0209230bSgjelinek * modify on the mcap entry. zonecfg_modify_mcap() 5727*0209230bSgjelinek * will handle both adding and modifying a memory cap. 5728*0209230bSgjelinek */ 5729*0209230bSgjelinek err = zonecfg_modify_mcap(handle, &in_progress_mcaptab); 5730*0209230bSgjelinek } else if (end_op == CMD_SELECT) { 5731*0209230bSgjelinek /* 5732*0209230bSgjelinek * If we're ending from a select and the physical 5733*0209230bSgjelinek * memory cap is empty then the user could have cleared 5734*0209230bSgjelinek * the physical cap value, so try to delete the entry. 5735*0209230bSgjelinek */ 5736*0209230bSgjelinek (void) zonecfg_delete_mcap(handle); 5737*0209230bSgjelinek } 5738*0209230bSgjelinek break; 57397c478bd9Sstevel@tonic-gate default: 57407c478bd9Sstevel@tonic-gate zone_perror(rt_to_str(resource_scope), Z_NO_RESOURCE_TYPE, 57417c478bd9Sstevel@tonic-gate TRUE); 57427c478bd9Sstevel@tonic-gate saw_error = TRUE; 57437c478bd9Sstevel@tonic-gate return; 57447c478bd9Sstevel@tonic-gate } 57457c478bd9Sstevel@tonic-gate 57467c478bd9Sstevel@tonic-gate if (err != Z_OK) { 57477c478bd9Sstevel@tonic-gate zone_perror(zone, err, TRUE); 57487c478bd9Sstevel@tonic-gate } else { 57497c478bd9Sstevel@tonic-gate need_to_commit = TRUE; 57507c478bd9Sstevel@tonic-gate global_scope = TRUE; 57517c478bd9Sstevel@tonic-gate end_op = -1; 57527c478bd9Sstevel@tonic-gate } 57537c478bd9Sstevel@tonic-gate } 57547c478bd9Sstevel@tonic-gate 57557c478bd9Sstevel@tonic-gate void 57567c478bd9Sstevel@tonic-gate commit_func(cmd_t *cmd) 57577c478bd9Sstevel@tonic-gate { 57587c478bd9Sstevel@tonic-gate int arg; 57597c478bd9Sstevel@tonic-gate 57607c478bd9Sstevel@tonic-gate optind = 0; 57617c478bd9Sstevel@tonic-gate if ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?")) != EOF) { 57627c478bd9Sstevel@tonic-gate switch (arg) { 57637c478bd9Sstevel@tonic-gate case '?': 57647c478bd9Sstevel@tonic-gate longer_usage(CMD_COMMIT); 57657c478bd9Sstevel@tonic-gate return; 57667c478bd9Sstevel@tonic-gate default: 57677c478bd9Sstevel@tonic-gate short_usage(CMD_COMMIT); 57687c478bd9Sstevel@tonic-gate return; 57697c478bd9Sstevel@tonic-gate } 57707c478bd9Sstevel@tonic-gate } 57717c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 57727c478bd9Sstevel@tonic-gate short_usage(CMD_COMMIT); 57737c478bd9Sstevel@tonic-gate return; 57747c478bd9Sstevel@tonic-gate } 57757c478bd9Sstevel@tonic-gate 57767c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_COMMIT)) 57777c478bd9Sstevel@tonic-gate return; 57787c478bd9Sstevel@tonic-gate 57797c478bd9Sstevel@tonic-gate assert(cmd != NULL); 57807c478bd9Sstevel@tonic-gate 57817c478bd9Sstevel@tonic-gate cmd->cmd_argc = 1; 57827c478bd9Sstevel@tonic-gate /* 57837c478bd9Sstevel@tonic-gate * cmd_arg normally comes from a strdup() in the lexer, and the 57847c478bd9Sstevel@tonic-gate * whole cmd structure and its (char *) attributes are freed at 57857c478bd9Sstevel@tonic-gate * the completion of each command, so the strdup() below is needed 57867c478bd9Sstevel@tonic-gate * to match this and prevent a core dump from trying to free() 57877c478bd9Sstevel@tonic-gate * something that can't be. 57887c478bd9Sstevel@tonic-gate */ 57897c478bd9Sstevel@tonic-gate if ((cmd->cmd_argv[0] = strdup("save")) == NULL) { 57907c478bd9Sstevel@tonic-gate zone_perror(zone, Z_NOMEM, TRUE); 57917c478bd9Sstevel@tonic-gate exit(Z_ERR); 57927c478bd9Sstevel@tonic-gate } 57937c478bd9Sstevel@tonic-gate cmd->cmd_argv[1] = NULL; 57947c478bd9Sstevel@tonic-gate verify_func(cmd); 57957c478bd9Sstevel@tonic-gate } 57967c478bd9Sstevel@tonic-gate 57977c478bd9Sstevel@tonic-gate void 57987c478bd9Sstevel@tonic-gate revert_func(cmd_t *cmd) 57997c478bd9Sstevel@tonic-gate { 58007c478bd9Sstevel@tonic-gate char line[128]; /* enough to ask a question */ 58017c478bd9Sstevel@tonic-gate bool force = FALSE; 58027c478bd9Sstevel@tonic-gate int err, arg, answer; 58037c478bd9Sstevel@tonic-gate 58047c478bd9Sstevel@tonic-gate optind = 0; 58057c478bd9Sstevel@tonic-gate while ((arg = getopt(cmd->cmd_argc, cmd->cmd_argv, "?F")) != EOF) { 58067c478bd9Sstevel@tonic-gate switch (arg) { 58077c478bd9Sstevel@tonic-gate case '?': 58087c478bd9Sstevel@tonic-gate longer_usage(CMD_REVERT); 58097c478bd9Sstevel@tonic-gate return; 58107c478bd9Sstevel@tonic-gate case 'F': 58117c478bd9Sstevel@tonic-gate force = TRUE; 58127c478bd9Sstevel@tonic-gate break; 58137c478bd9Sstevel@tonic-gate default: 58147c478bd9Sstevel@tonic-gate short_usage(CMD_REVERT); 58157c478bd9Sstevel@tonic-gate return; 58167c478bd9Sstevel@tonic-gate } 58177c478bd9Sstevel@tonic-gate } 58187c478bd9Sstevel@tonic-gate if (optind != cmd->cmd_argc) { 58197c478bd9Sstevel@tonic-gate short_usage(CMD_REVERT); 58207c478bd9Sstevel@tonic-gate return; 58217c478bd9Sstevel@tonic-gate } 58227c478bd9Sstevel@tonic-gate 58237c478bd9Sstevel@tonic-gate if (zone_is_read_only(CMD_REVERT)) 58247c478bd9Sstevel@tonic-gate return; 58257c478bd9Sstevel@tonic-gate 58267c478bd9Sstevel@tonic-gate if (zonecfg_check_handle(handle) != Z_OK) { 58277c478bd9Sstevel@tonic-gate zerr(gettext("No changes to revert.")); 58287c478bd9Sstevel@tonic-gate saw_error = TRUE; 58297c478bd9Sstevel@tonic-gate return; 58307c478bd9Sstevel@tonic-gate } 58317c478bd9Sstevel@tonic-gate 58327c478bd9Sstevel@tonic-gate if (!force) { 58337c478bd9Sstevel@tonic-gate (void) snprintf(line, sizeof (line), 58347c478bd9Sstevel@tonic-gate gettext("Are you sure you want to revert")); 58357c478bd9Sstevel@tonic-gate if ((answer = ask_yesno(FALSE, line)) == -1) { 58367c478bd9Sstevel@tonic-gate zerr(gettext("Input not from terminal and -F not " 58377c478bd9Sstevel@tonic-gate "specified:\n%s command ignored, exiting."), 58387c478bd9Sstevel@tonic-gate cmd_to_str(CMD_REVERT)); 58397c478bd9Sstevel@tonic-gate exit(Z_ERR); 58407c478bd9Sstevel@tonic-gate } 58417c478bd9Sstevel@tonic-gate if (answer != 1) 58427c478bd9Sstevel@tonic-gate return; 58437c478bd9Sstevel@tonic-gate } 58447c478bd9Sstevel@tonic-gate 58457c478bd9Sstevel@tonic-gate /* 58467c478bd9Sstevel@tonic-gate * Time for a new handle: finish the old one off first 58477c478bd9Sstevel@tonic-gate * then get a new one properly to avoid leaks. 58487c478bd9Sstevel@tonic-gate */ 58497c478bd9Sstevel@tonic-gate zonecfg_fini_handle(handle); 58507c478bd9Sstevel@tonic-gate if ((handle = zonecfg_init_handle()) == NULL) { 58517c478bd9Sstevel@tonic-gate zone_perror(execname, Z_NOMEM, TRUE); 58527c478bd9Sstevel@tonic-gate exit(Z_ERR); 58537c478bd9Sstevel@tonic-gate } 5854087719fdSdp if ((err = zonecfg_get_handle(revert_zone, handle)) != Z_OK) { 58557c478bd9Sstevel@tonic-gate saw_error = TRUE; 58567c478bd9Sstevel@tonic-gate got_handle = FALSE; 58577c478bd9Sstevel@tonic-gate if (err == Z_NO_ZONE) 58587c478bd9Sstevel@tonic-gate zerr(gettext("%s: no such saved zone to revert to."), 5859087719fdSdp revert_zone); 58607c478bd9Sstevel@tonic-gate else 58617c478bd9Sstevel@tonic-gate zone_perror(zone, err, TRUE); 58627c478bd9Sstevel@tonic-gate } 5863087719fdSdp (void) strlcpy(zone, revert_zone, sizeof (zone)); 58647c478bd9Sstevel@tonic-gate } 58657c478bd9Sstevel@tonic-gate 58667c478bd9Sstevel@tonic-gate void 58677c478bd9Sstevel@tonic-gate help_func(cmd_t *cmd) 58687c478bd9Sstevel@tonic-gate { 58697c478bd9Sstevel@tonic-gate int i; 58707c478bd9Sstevel@tonic-gate 58717c478bd9Sstevel@tonic-gate assert(cmd != NULL); 58727c478bd9Sstevel@tonic-gate 58737c478bd9Sstevel@tonic-gate if (cmd->cmd_argc == 0) { 58747c478bd9Sstevel@tonic-gate usage(TRUE, global_scope ? HELP_SUBCMDS : HELP_RES_SCOPE); 58757c478bd9Sstevel@tonic-gate return; 58767c478bd9Sstevel@tonic-gate } 58777c478bd9Sstevel@tonic-gate if (strcmp(cmd->cmd_argv[0], "usage") == 0) { 58787c478bd9Sstevel@tonic-gate usage(TRUE, HELP_USAGE); 58797c478bd9Sstevel@tonic-gate return; 58807c478bd9Sstevel@tonic-gate } 58817c478bd9Sstevel@tonic-gate if (strcmp(cmd->cmd_argv[0], "commands") == 0) { 58827c478bd9Sstevel@tonic-gate usage(TRUE, HELP_SUBCMDS); 58837c478bd9Sstevel@tonic-gate return; 58847c478bd9Sstevel@tonic-gate } 58857c478bd9Sstevel@tonic-gate if (strcmp(cmd->cmd_argv[0], "syntax") == 0) { 58867c478bd9Sstevel@tonic-gate usage(TRUE, HELP_SYNTAX | HELP_RES_PROPS); 58877c478bd9Sstevel@tonic-gate return; 58887c478bd9Sstevel@tonic-gate } 58897c478bd9Sstevel@tonic-gate if (strcmp(cmd->cmd_argv[0], "-?") == 0) { 58907c478bd9Sstevel@tonic-gate longer_usage(CMD_HELP); 58917c478bd9Sstevel@tonic-gate return; 58927c478bd9Sstevel@tonic-gate } 58937c478bd9Sstevel@tonic-gate 58947c478bd9Sstevel@tonic-gate for (i = 0; i <= CMD_MAX; i++) { 58957c478bd9Sstevel@tonic-gate if (strcmp(cmd->cmd_argv[0], cmd_to_str(i)) == 0) { 58967c478bd9Sstevel@tonic-gate longer_usage(i); 58977c478bd9Sstevel@tonic-gate return; 58987c478bd9Sstevel@tonic-gate } 58997c478bd9Sstevel@tonic-gate } 59007c478bd9Sstevel@tonic-gate /* We do not use zerr() here because we do not want its extra \n. */ 59017c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("Unknown help subject %s. "), 59027c478bd9Sstevel@tonic-gate cmd->cmd_argv[0]); 59037c478bd9Sstevel@tonic-gate usage(FALSE, HELP_META); 59047c478bd9Sstevel@tonic-gate } 59057c478bd9Sstevel@tonic-gate 59067c478bd9Sstevel@tonic-gate static int 59077c478bd9Sstevel@tonic-gate string_to_yyin(char *string) 59087c478bd9Sstevel@tonic-gate { 59097c478bd9Sstevel@tonic-gate if ((yyin = tmpfile()) == NULL) { 59107c478bd9Sstevel@tonic-gate zone_perror(execname, Z_TEMP_FILE, TRUE); 59117c478bd9Sstevel@tonic-gate return (Z_ERR); 59127c478bd9Sstevel@tonic-gate } 59137c478bd9Sstevel@tonic-gate if (fwrite(string, strlen(string), 1, yyin) != 1) { 59147c478bd9Sstevel@tonic-gate zone_perror(execname, Z_TEMP_FILE, TRUE); 59157c478bd9Sstevel@tonic-gate return (Z_ERR); 59167c478bd9Sstevel@tonic-gate } 59177c478bd9Sstevel@tonic-gate if (fseek(yyin, 0, SEEK_SET) != 0) { 59187c478bd9Sstevel@tonic-gate zone_perror(execname, Z_TEMP_FILE, TRUE); 59197c478bd9Sstevel@tonic-gate return (Z_ERR); 59207c478bd9Sstevel@tonic-gate } 59217c478bd9Sstevel@tonic-gate return (Z_OK); 59227c478bd9Sstevel@tonic-gate } 59237c478bd9Sstevel@tonic-gate 59247c478bd9Sstevel@tonic-gate /* This is the back-end helper function for read_input() below. */ 59257c478bd9Sstevel@tonic-gate 59267c478bd9Sstevel@tonic-gate static int 59277c478bd9Sstevel@tonic-gate cleanup() 59287c478bd9Sstevel@tonic-gate { 59297c478bd9Sstevel@tonic-gate int answer; 59307c478bd9Sstevel@tonic-gate cmd_t *cmd; 59317c478bd9Sstevel@tonic-gate 59327c478bd9Sstevel@tonic-gate if (!interactive_mode && !cmd_file_mode) { 59337c478bd9Sstevel@tonic-gate /* 59347c478bd9Sstevel@tonic-gate * If we're not in interactive mode, and we're not in command 59357c478bd9Sstevel@tonic-gate * file mode, then we must be in commands-from-the-command-line 59367c478bd9Sstevel@tonic-gate * mode. As such, we can't loop back and ask for more input. 59377c478bd9Sstevel@tonic-gate * It was OK to prompt for such things as whether or not to 59387c478bd9Sstevel@tonic-gate * really delete a zone in the command handler called from 59397c478bd9Sstevel@tonic-gate * yyparse() above, but "really quit?" makes no sense in this 59407c478bd9Sstevel@tonic-gate * context. So disable prompting. 59417c478bd9Sstevel@tonic-gate */ 59427c478bd9Sstevel@tonic-gate ok_to_prompt = FALSE; 59437c478bd9Sstevel@tonic-gate } 59447c478bd9Sstevel@tonic-gate if (!global_scope) { 59457c478bd9Sstevel@tonic-gate if (!time_to_exit) { 59467c478bd9Sstevel@tonic-gate /* 59477c478bd9Sstevel@tonic-gate * Just print a simple error message in the -1 case, 59487c478bd9Sstevel@tonic-gate * since exit_func() already handles that case, and 59497c478bd9Sstevel@tonic-gate * EOF means we are finished anyway. 59507c478bd9Sstevel@tonic-gate */ 59517c478bd9Sstevel@tonic-gate answer = ask_yesno(FALSE, 59527c478bd9Sstevel@tonic-gate gettext("Resource incomplete; really quit")); 59537c478bd9Sstevel@tonic-gate if (answer == -1) { 59547c478bd9Sstevel@tonic-gate zerr(gettext("Resource incomplete.")); 59557c478bd9Sstevel@tonic-gate return (Z_ERR); 59567c478bd9Sstevel@tonic-gate } 59577c478bd9Sstevel@tonic-gate if (answer != 1) { 59587c478bd9Sstevel@tonic-gate yyin = stdin; 59597c478bd9Sstevel@tonic-gate return (Z_REPEAT); 59607c478bd9Sstevel@tonic-gate } 59617c478bd9Sstevel@tonic-gate } else { 59627c478bd9Sstevel@tonic-gate saw_error = TRUE; 59637c478bd9Sstevel@tonic-gate } 59647c478bd9Sstevel@tonic-gate } 59657c478bd9Sstevel@tonic-gate /* 59667c478bd9Sstevel@tonic-gate * Make sure we tried something and that the handle checks 59677c478bd9Sstevel@tonic-gate * out, or we would get a false error trying to commit. 59687c478bd9Sstevel@tonic-gate */ 59697c478bd9Sstevel@tonic-gate if (need_to_commit && zonecfg_check_handle(handle) == Z_OK) { 59707c478bd9Sstevel@tonic-gate if ((cmd = alloc_cmd()) == NULL) { 59717c478bd9Sstevel@tonic-gate zone_perror(zone, Z_NOMEM, TRUE); 59727c478bd9Sstevel@tonic-gate return (Z_ERR); 59737c478bd9Sstevel@tonic-gate } 59747c478bd9Sstevel@tonic-gate cmd->cmd_argc = 0; 59757c478bd9Sstevel@tonic-gate cmd->cmd_argv[0] = NULL; 59767c478bd9Sstevel@tonic-gate commit_func(cmd); 59777c478bd9Sstevel@tonic-gate free_cmd(cmd); 59787c478bd9Sstevel@tonic-gate /* 59797c478bd9Sstevel@tonic-gate * need_to_commit will get set back to FALSE if the 59807c478bd9Sstevel@tonic-gate * configuration is saved successfully. 59817c478bd9Sstevel@tonic-gate */ 59827c478bd9Sstevel@tonic-gate if (need_to_commit) { 59837c478bd9Sstevel@tonic-gate if (force_exit) { 59847c478bd9Sstevel@tonic-gate zerr(gettext("Configuration not saved.")); 59857c478bd9Sstevel@tonic-gate return (Z_ERR); 59867c478bd9Sstevel@tonic-gate } 59877c478bd9Sstevel@tonic-gate answer = ask_yesno(FALSE, 59887c478bd9Sstevel@tonic-gate gettext("Configuration not saved; really quit")); 59897c478bd9Sstevel@tonic-gate if (answer == -1) { 59907c478bd9Sstevel@tonic-gate zerr(gettext("Configuration not saved.")); 59917c478bd9Sstevel@tonic-gate return (Z_ERR); 59927c478bd9Sstevel@tonic-gate } 59937c478bd9Sstevel@tonic-gate if (answer != 1) { 59947c478bd9Sstevel@tonic-gate time_to_exit = FALSE; 59957c478bd9Sstevel@tonic-gate yyin = stdin; 59967c478bd9Sstevel@tonic-gate return (Z_REPEAT); 59977c478bd9Sstevel@tonic-gate } 59987c478bd9Sstevel@tonic-gate } 59997c478bd9Sstevel@tonic-gate } 60007c478bd9Sstevel@tonic-gate return ((need_to_commit || saw_error) ? Z_ERR : Z_OK); 60017c478bd9Sstevel@tonic-gate } 60027c478bd9Sstevel@tonic-gate 60037c478bd9Sstevel@tonic-gate /* 60047c478bd9Sstevel@tonic-gate * read_input() is the driver of this program. It is a wrapper around 60057c478bd9Sstevel@tonic-gate * yyparse(), printing appropriate prompts when needed, checking for 60067c478bd9Sstevel@tonic-gate * exit conditions and reacting appropriately [the latter in its cleanup() 60077c478bd9Sstevel@tonic-gate * helper function]. 60087c478bd9Sstevel@tonic-gate * 60097c478bd9Sstevel@tonic-gate * Like most zonecfg functions, it returns Z_OK or Z_ERR, *or* Z_REPEAT 60107c478bd9Sstevel@tonic-gate * so do_interactive() knows that we are not really done (i.e, we asked 60117c478bd9Sstevel@tonic-gate * the user if we should really quit and the user said no). 60127c478bd9Sstevel@tonic-gate */ 60137c478bd9Sstevel@tonic-gate static int 60147c478bd9Sstevel@tonic-gate read_input() 60157c478bd9Sstevel@tonic-gate { 60167c478bd9Sstevel@tonic-gate bool yyin_is_a_tty = isatty(fileno(yyin)); 60177c478bd9Sstevel@tonic-gate /* 60187c478bd9Sstevel@tonic-gate * The prompt is "e:z> " or "e:z:r> " where e is execname, z is zone 60197c478bd9Sstevel@tonic-gate * and r is resource_scope: 5 is for the two ":"s + "> " + terminator. 60207c478bd9Sstevel@tonic-gate */ 60217c478bd9Sstevel@tonic-gate char prompt[MAXPATHLEN + ZONENAME_MAX + MAX_RT_STRLEN + 5], *line; 60227c478bd9Sstevel@tonic-gate 60237c478bd9Sstevel@tonic-gate /* yyin should have been set to the appropriate (FILE *) if not stdin */ 60247c478bd9Sstevel@tonic-gate newline_terminated = TRUE; 60257c478bd9Sstevel@tonic-gate for (;;) { 60267c478bd9Sstevel@tonic-gate if (yyin_is_a_tty) { 60277c478bd9Sstevel@tonic-gate if (newline_terminated) { 60287c478bd9Sstevel@tonic-gate if (global_scope) 60297c478bd9Sstevel@tonic-gate (void) snprintf(prompt, sizeof (prompt), 60307c478bd9Sstevel@tonic-gate "%s:%s> ", execname, zone); 60317c478bd9Sstevel@tonic-gate else 60327c478bd9Sstevel@tonic-gate (void) snprintf(prompt, sizeof (prompt), 60337c478bd9Sstevel@tonic-gate "%s:%s:%s> ", execname, zone, 60347c478bd9Sstevel@tonic-gate rt_to_str(resource_scope)); 60357c478bd9Sstevel@tonic-gate } 60367c478bd9Sstevel@tonic-gate /* 60377c478bd9Sstevel@tonic-gate * If the user hits ^C then we want to catch it and 60387c478bd9Sstevel@tonic-gate * start over. If the user hits EOF then we want to 60397c478bd9Sstevel@tonic-gate * bail out. 60407c478bd9Sstevel@tonic-gate */ 60417c478bd9Sstevel@tonic-gate line = gl_get_line(gl, prompt, NULL, -1); 60427c478bd9Sstevel@tonic-gate if (gl_return_status(gl) == GLR_SIGNAL) { 60437c478bd9Sstevel@tonic-gate gl_abandon_line(gl); 60447c478bd9Sstevel@tonic-gate continue; 60457c478bd9Sstevel@tonic-gate } 60467c478bd9Sstevel@tonic-gate if (line == NULL) 60477c478bd9Sstevel@tonic-gate break; 60487c478bd9Sstevel@tonic-gate (void) string_to_yyin(line); 60497c478bd9Sstevel@tonic-gate while (!feof(yyin)) 60507c478bd9Sstevel@tonic-gate yyparse(); 60517c478bd9Sstevel@tonic-gate } else { 60527c478bd9Sstevel@tonic-gate yyparse(); 60537c478bd9Sstevel@tonic-gate } 60547c478bd9Sstevel@tonic-gate /* Bail out on an error in command file mode. */ 60557c478bd9Sstevel@tonic-gate if (saw_error && cmd_file_mode && !interactive_mode) 60567c478bd9Sstevel@tonic-gate time_to_exit = TRUE; 60577c478bd9Sstevel@tonic-gate if (time_to_exit || (!yyin_is_a_tty && feof(yyin))) 60587c478bd9Sstevel@tonic-gate break; 60597c478bd9Sstevel@tonic-gate } 60607c478bd9Sstevel@tonic-gate return (cleanup()); 60617c478bd9Sstevel@tonic-gate } 60627c478bd9Sstevel@tonic-gate 60637c478bd9Sstevel@tonic-gate /* 60647c478bd9Sstevel@tonic-gate * This function is used in the zonecfg-interactive-mode scenario: it just 60657c478bd9Sstevel@tonic-gate * calls read_input() until we are done. 60667c478bd9Sstevel@tonic-gate */ 60677c478bd9Sstevel@tonic-gate 60687c478bd9Sstevel@tonic-gate static int 60697c478bd9Sstevel@tonic-gate do_interactive(void) 60707c478bd9Sstevel@tonic-gate { 60717c478bd9Sstevel@tonic-gate int err; 60727c478bd9Sstevel@tonic-gate 60737c478bd9Sstevel@tonic-gate interactive_mode = TRUE; 60747c478bd9Sstevel@tonic-gate if (!read_only_mode) { 60757c478bd9Sstevel@tonic-gate /* 60767c478bd9Sstevel@tonic-gate * Try to set things up proactively in interactive mode, so 60777c478bd9Sstevel@tonic-gate * that if the zone in question does not exist yet, we can 60787c478bd9Sstevel@tonic-gate * provide the user with a clue. 60797c478bd9Sstevel@tonic-gate */ 60807c478bd9Sstevel@tonic-gate (void) initialize(FALSE); 60817c478bd9Sstevel@tonic-gate } 6082087719fdSdp do { 60837c478bd9Sstevel@tonic-gate err = read_input(); 6084087719fdSdp } while (err == Z_REPEAT); 60857c478bd9Sstevel@tonic-gate return (err); 60867c478bd9Sstevel@tonic-gate } 60877c478bd9Sstevel@tonic-gate 60887c478bd9Sstevel@tonic-gate /* 60897c478bd9Sstevel@tonic-gate * cmd_file is slightly more complicated, as it has to open the command file 60907c478bd9Sstevel@tonic-gate * and set yyin appropriately. Once that is done, though, it just calls 60917c478bd9Sstevel@tonic-gate * read_input(), and only once, since prompting is not possible. 60927c478bd9Sstevel@tonic-gate */ 60937c478bd9Sstevel@tonic-gate 60947c478bd9Sstevel@tonic-gate static int 60957c478bd9Sstevel@tonic-gate cmd_file(char *file) 60967c478bd9Sstevel@tonic-gate { 60977c478bd9Sstevel@tonic-gate FILE *infile; 60987c478bd9Sstevel@tonic-gate int err; 60997c478bd9Sstevel@tonic-gate struct stat statbuf; 61007c478bd9Sstevel@tonic-gate bool using_real_file = (strcmp(file, "-") != 0); 61017c478bd9Sstevel@tonic-gate 61027c478bd9Sstevel@tonic-gate if (using_real_file) { 61037c478bd9Sstevel@tonic-gate /* 61047c478bd9Sstevel@tonic-gate * zerr() prints a line number in cmd_file_mode, which we do 61057c478bd9Sstevel@tonic-gate * not want here, so temporarily unset it. 61067c478bd9Sstevel@tonic-gate */ 61077c478bd9Sstevel@tonic-gate cmd_file_mode = FALSE; 61087c478bd9Sstevel@tonic-gate if ((infile = fopen(file, "r")) == NULL) { 61097c478bd9Sstevel@tonic-gate zerr(gettext("could not open file %s: %s"), 61107c478bd9Sstevel@tonic-gate file, strerror(errno)); 61117c478bd9Sstevel@tonic-gate return (Z_ERR); 61127c478bd9Sstevel@tonic-gate } 61137c478bd9Sstevel@tonic-gate if ((err = fstat(fileno(infile), &statbuf)) != 0) { 61147c478bd9Sstevel@tonic-gate zerr(gettext("could not stat file %s: %s"), 61157c478bd9Sstevel@tonic-gate file, strerror(errno)); 61167c478bd9Sstevel@tonic-gate err = Z_ERR; 61177c478bd9Sstevel@tonic-gate goto done; 61187c478bd9Sstevel@tonic-gate } 61197c478bd9Sstevel@tonic-gate if (!S_ISREG(statbuf.st_mode)) { 61207c478bd9Sstevel@tonic-gate zerr(gettext("%s is not a regular file."), file); 61217c478bd9Sstevel@tonic-gate err = Z_ERR; 61227c478bd9Sstevel@tonic-gate goto done; 61237c478bd9Sstevel@tonic-gate } 61247c478bd9Sstevel@tonic-gate yyin = infile; 61257c478bd9Sstevel@tonic-gate cmd_file_mode = TRUE; 61267c478bd9Sstevel@tonic-gate ok_to_prompt = FALSE; 61277c478bd9Sstevel@tonic-gate } else { 61287c478bd9Sstevel@tonic-gate /* 61297c478bd9Sstevel@tonic-gate * "-f -" is essentially the same as interactive mode, 61307c478bd9Sstevel@tonic-gate * so treat it that way. 61317c478bd9Sstevel@tonic-gate */ 61327c478bd9Sstevel@tonic-gate interactive_mode = TRUE; 61337c478bd9Sstevel@tonic-gate } 61347c478bd9Sstevel@tonic-gate /* Z_REPEAT is for interactive mode; treat it like Z_ERR here. */ 61357c478bd9Sstevel@tonic-gate if ((err = read_input()) == Z_REPEAT) 61367c478bd9Sstevel@tonic-gate err = Z_ERR; 61377c478bd9Sstevel@tonic-gate done: 61387c478bd9Sstevel@tonic-gate if (using_real_file) 61397c478bd9Sstevel@tonic-gate (void) fclose(infile); 61407c478bd9Sstevel@tonic-gate return (err); 61417c478bd9Sstevel@tonic-gate } 61427c478bd9Sstevel@tonic-gate 61437c478bd9Sstevel@tonic-gate /* 61447c478bd9Sstevel@tonic-gate * Since yacc is based on reading from a (FILE *) whereas what we get from 61457c478bd9Sstevel@tonic-gate * the command line is in argv format, we need to convert when the user 61467c478bd9Sstevel@tonic-gate * gives us commands directly from the command line. That is done here by 61477c478bd9Sstevel@tonic-gate * concatenating the argv list into a space-separated string, writing it 61487c478bd9Sstevel@tonic-gate * to a temp file, and rewinding the file so yyin can be set to it. Then 61497c478bd9Sstevel@tonic-gate * we call read_input(), and only once, since prompting about whether to 61507c478bd9Sstevel@tonic-gate * continue or quit would make no sense in this context. 61517c478bd9Sstevel@tonic-gate */ 61527c478bd9Sstevel@tonic-gate 61537c478bd9Sstevel@tonic-gate static int 61547c478bd9Sstevel@tonic-gate one_command_at_a_time(int argc, char *argv[]) 61557c478bd9Sstevel@tonic-gate { 61567c478bd9Sstevel@tonic-gate char *command; 61577c478bd9Sstevel@tonic-gate size_t len = 2; /* terminal \n\0 */ 61587c478bd9Sstevel@tonic-gate int i, err; 61597c478bd9Sstevel@tonic-gate 61607c478bd9Sstevel@tonic-gate for (i = 0; i < argc; i++) 61617c478bd9Sstevel@tonic-gate len += strlen(argv[i]) + 1; 61627c478bd9Sstevel@tonic-gate if ((command = malloc(len)) == NULL) { 61637c478bd9Sstevel@tonic-gate zone_perror(execname, Z_NOMEM, TRUE); 61647c478bd9Sstevel@tonic-gate return (Z_ERR); 61657c478bd9Sstevel@tonic-gate } 61667c478bd9Sstevel@tonic-gate (void) strlcpy(command, argv[0], len); 61677c478bd9Sstevel@tonic-gate for (i = 1; i < argc; i++) { 61687c478bd9Sstevel@tonic-gate (void) strlcat(command, " ", len); 61697c478bd9Sstevel@tonic-gate (void) strlcat(command, argv[i], len); 61707c478bd9Sstevel@tonic-gate } 61717c478bd9Sstevel@tonic-gate (void) strlcat(command, "\n", len); 61727c478bd9Sstevel@tonic-gate err = string_to_yyin(command); 61737c478bd9Sstevel@tonic-gate free(command); 61747c478bd9Sstevel@tonic-gate if (err != Z_OK) 61757c478bd9Sstevel@tonic-gate return (err); 61767c478bd9Sstevel@tonic-gate while (!feof(yyin)) 61777c478bd9Sstevel@tonic-gate yyparse(); 61787c478bd9Sstevel@tonic-gate return (cleanup()); 61797c478bd9Sstevel@tonic-gate } 61807c478bd9Sstevel@tonic-gate 61817c478bd9Sstevel@tonic-gate static char * 61827c478bd9Sstevel@tonic-gate get_execbasename(char *execfullname) 61837c478bd9Sstevel@tonic-gate { 61847c478bd9Sstevel@tonic-gate char *last_slash, *execbasename; 61857c478bd9Sstevel@tonic-gate 61867c478bd9Sstevel@tonic-gate /* guard against '/' at end of command invocation */ 61877c478bd9Sstevel@tonic-gate for (;;) { 61887c478bd9Sstevel@tonic-gate last_slash = strrchr(execfullname, '/'); 61897c478bd9Sstevel@tonic-gate if (last_slash == NULL) { 61907c478bd9Sstevel@tonic-gate execbasename = execfullname; 61917c478bd9Sstevel@tonic-gate break; 61927c478bd9Sstevel@tonic-gate } else { 61937c478bd9Sstevel@tonic-gate execbasename = last_slash + 1; 61947c478bd9Sstevel@tonic-gate if (*execbasename == '\0') { 61957c478bd9Sstevel@tonic-gate *last_slash = '\0'; 61967c478bd9Sstevel@tonic-gate continue; 61977c478bd9Sstevel@tonic-gate } 61987c478bd9Sstevel@tonic-gate break; 61997c478bd9Sstevel@tonic-gate } 62007c478bd9Sstevel@tonic-gate } 62017c478bd9Sstevel@tonic-gate return (execbasename); 62027c478bd9Sstevel@tonic-gate } 62037c478bd9Sstevel@tonic-gate 62047c478bd9Sstevel@tonic-gate int 62057c478bd9Sstevel@tonic-gate main(int argc, char *argv[]) 62067c478bd9Sstevel@tonic-gate { 62077c478bd9Sstevel@tonic-gate int err, arg; 6208555afedfScarlsonj struct stat st; 62097c478bd9Sstevel@tonic-gate 62107c478bd9Sstevel@tonic-gate /* This must be before anything goes to stdout. */ 62117c478bd9Sstevel@tonic-gate setbuf(stdout, NULL); 62127c478bd9Sstevel@tonic-gate 62137c478bd9Sstevel@tonic-gate saw_error = FALSE; 62147c478bd9Sstevel@tonic-gate cmd_file_mode = FALSE; 62157c478bd9Sstevel@tonic-gate execname = get_execbasename(argv[0]); 62167c478bd9Sstevel@tonic-gate 62177c478bd9Sstevel@tonic-gate (void) setlocale(LC_ALL, ""); 62187c478bd9Sstevel@tonic-gate (void) textdomain(TEXT_DOMAIN); 62197c478bd9Sstevel@tonic-gate 62207c478bd9Sstevel@tonic-gate if (getzoneid() != GLOBAL_ZONEID) { 62217c478bd9Sstevel@tonic-gate zerr(gettext("%s can only be run from the global zone."), 62227c478bd9Sstevel@tonic-gate execname); 62237c478bd9Sstevel@tonic-gate exit(Z_ERR); 62247c478bd9Sstevel@tonic-gate } 62257c478bd9Sstevel@tonic-gate 62267c478bd9Sstevel@tonic-gate if (argc < 2) { 62277c478bd9Sstevel@tonic-gate usage(FALSE, HELP_USAGE | HELP_SUBCMDS); 62287c478bd9Sstevel@tonic-gate exit(Z_USAGE); 62297c478bd9Sstevel@tonic-gate } 62307c478bd9Sstevel@tonic-gate if (strcmp(argv[1], cmd_to_str(CMD_HELP)) == 0) { 62317c478bd9Sstevel@tonic-gate (void) one_command_at_a_time(argc - 1, &(argv[1])); 62327c478bd9Sstevel@tonic-gate exit(Z_OK); 62337c478bd9Sstevel@tonic-gate } 62347c478bd9Sstevel@tonic-gate 6235555afedfScarlsonj while ((arg = getopt(argc, argv, "?f:R:z:")) != EOF) { 62367c478bd9Sstevel@tonic-gate switch (arg) { 62377c478bd9Sstevel@tonic-gate case '?': 62387c478bd9Sstevel@tonic-gate if (optopt == '?') 62397c478bd9Sstevel@tonic-gate usage(TRUE, HELP_USAGE | HELP_SUBCMDS); 62407c478bd9Sstevel@tonic-gate else 62417c478bd9Sstevel@tonic-gate usage(FALSE, HELP_USAGE); 62427c478bd9Sstevel@tonic-gate exit(Z_USAGE); 62437c478bd9Sstevel@tonic-gate /* NOTREACHED */ 62447c478bd9Sstevel@tonic-gate case 'f': 62457c478bd9Sstevel@tonic-gate cmd_file_name = optarg; 62467c478bd9Sstevel@tonic-gate cmd_file_mode = TRUE; 62477c478bd9Sstevel@tonic-gate break; 6248555afedfScarlsonj case 'R': 6249555afedfScarlsonj if (*optarg != '/') { 6250555afedfScarlsonj zerr(gettext("root path must be absolute: %s"), 6251555afedfScarlsonj optarg); 6252555afedfScarlsonj exit(Z_USAGE); 6253555afedfScarlsonj } 6254555afedfScarlsonj if (stat(optarg, &st) == -1 || !S_ISDIR(st.st_mode)) { 6255555afedfScarlsonj zerr(gettext( 6256555afedfScarlsonj "root path must be a directory: %s"), 6257555afedfScarlsonj optarg); 6258555afedfScarlsonj exit(Z_USAGE); 6259555afedfScarlsonj } 6260555afedfScarlsonj zonecfg_set_root(optarg); 6261555afedfScarlsonj break; 62627c478bd9Sstevel@tonic-gate case 'z': 6263*0209230bSgjelinek if (strcmp(optarg, GLOBAL_ZONENAME) == 0) { 6264*0209230bSgjelinek global_zone = TRUE; 6265*0209230bSgjelinek } else if (zonecfg_validate_zonename(optarg) != Z_OK) { 6266087719fdSdp zone_perror(optarg, Z_BOGUS_ZONE_NAME, TRUE); 6267087719fdSdp usage(FALSE, HELP_SYNTAX); 6268087719fdSdp exit(Z_USAGE); 6269087719fdSdp } 6270087719fdSdp (void) strlcpy(zone, optarg, sizeof (zone)); 6271087719fdSdp (void) strlcpy(revert_zone, optarg, sizeof (zone)); 62727c478bd9Sstevel@tonic-gate break; 62737c478bd9Sstevel@tonic-gate default: 62747c478bd9Sstevel@tonic-gate usage(FALSE, HELP_USAGE); 62757c478bd9Sstevel@tonic-gate exit(Z_USAGE); 62767c478bd9Sstevel@tonic-gate } 62777c478bd9Sstevel@tonic-gate } 62787c478bd9Sstevel@tonic-gate 6279087719fdSdp if (optind > argc || strcmp(zone, "") == 0) { 62807c478bd9Sstevel@tonic-gate usage(FALSE, HELP_USAGE); 62817c478bd9Sstevel@tonic-gate exit(Z_USAGE); 62827c478bd9Sstevel@tonic-gate } 62837c478bd9Sstevel@tonic-gate 6284087719fdSdp if ((err = zonecfg_access(zone, W_OK)) == Z_OK) { 62857c478bd9Sstevel@tonic-gate read_only_mode = FALSE; 6286087719fdSdp } else if (err == Z_ACCES) { 62877c478bd9Sstevel@tonic-gate read_only_mode = TRUE; 62887c478bd9Sstevel@tonic-gate /* skip this message in one-off from command line mode */ 62897c478bd9Sstevel@tonic-gate if (optind == argc) 62907c478bd9Sstevel@tonic-gate (void) fprintf(stderr, gettext("WARNING: you do not " 62917c478bd9Sstevel@tonic-gate "have write access to this zone's configuration " 62927c478bd9Sstevel@tonic-gate "file;\ngoing into read-only mode.\n")); 6293087719fdSdp } else { 6294087719fdSdp fprintf(stderr, "%s: Could not access zone configuration " 6295087719fdSdp "store: %s\n", execname, zonecfg_strerror(err)); 6296087719fdSdp exit(Z_ERR); 62977c478bd9Sstevel@tonic-gate } 62987c478bd9Sstevel@tonic-gate 62997c478bd9Sstevel@tonic-gate if ((handle = zonecfg_init_handle()) == NULL) { 63007c478bd9Sstevel@tonic-gate zone_perror(execname, Z_NOMEM, TRUE); 63017c478bd9Sstevel@tonic-gate exit(Z_ERR); 63027c478bd9Sstevel@tonic-gate } 63037c478bd9Sstevel@tonic-gate 63047c478bd9Sstevel@tonic-gate /* 63057c478bd9Sstevel@tonic-gate * This may get set back to FALSE again in cmd_file() if cmd_file_name 63067c478bd9Sstevel@tonic-gate * is a "real" file as opposed to "-" (i.e. meaning use stdin). 63077c478bd9Sstevel@tonic-gate */ 63087c478bd9Sstevel@tonic-gate if (isatty(STDIN_FILENO)) 63097c478bd9Sstevel@tonic-gate ok_to_prompt = TRUE; 63107c478bd9Sstevel@tonic-gate if ((gl = new_GetLine(MAX_LINE_LEN, MAX_CMD_HIST)) == NULL) 63117c478bd9Sstevel@tonic-gate exit(Z_ERR); 63127c478bd9Sstevel@tonic-gate if (gl_customize_completion(gl, NULL, cmd_cpl_fn) != 0) 63137c478bd9Sstevel@tonic-gate exit(Z_ERR); 63147c478bd9Sstevel@tonic-gate (void) sigset(SIGINT, SIG_IGN); 63157c478bd9Sstevel@tonic-gate if (optind == argc) { 63167c478bd9Sstevel@tonic-gate if (!cmd_file_mode) 63177c478bd9Sstevel@tonic-gate err = do_interactive(); 63187c478bd9Sstevel@tonic-gate else 63197c478bd9Sstevel@tonic-gate err = cmd_file(cmd_file_name); 63207c478bd9Sstevel@tonic-gate } else { 63217c478bd9Sstevel@tonic-gate err = one_command_at_a_time(argc - optind, &(argv[optind])); 63227c478bd9Sstevel@tonic-gate } 63237c478bd9Sstevel@tonic-gate zonecfg_fini_handle(handle); 63249acbbeafSnn if (brand != NULL) 63259acbbeafSnn brand_close(brand); 63267c478bd9Sstevel@tonic-gate (void) del_GetLine(gl); 63277c478bd9Sstevel@tonic-gate return (err); 63287c478bd9Sstevel@tonic-gate } 6329