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 545916cd2Sjpk * Common Development and Distribution License (the "License"). 645916cd2Sjpk * 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 */ 2197eda132Sraf 227c478bd9Sstevel@tonic-gate /* 23134a1f4eSCasper H.S. Dik * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved. 24a48d8120SJerry Jelinek * Copyright 2015, Joyent Inc. All rights reserved. 2548bbca81SDaniel Hoffman * Copyright (c) 2016 by Delphix. All rights reserved. 26*66d7818bSAndy Fiddaman * Copyright 2018 OmniOS Community Edition (OmniOSce) Association. 277c478bd9Sstevel@tonic-gate */ 287c478bd9Sstevel@tonic-gate 297c478bd9Sstevel@tonic-gate /* 307c478bd9Sstevel@tonic-gate * Zones 317c478bd9Sstevel@tonic-gate * 327c478bd9Sstevel@tonic-gate * A zone is a named collection of processes, namespace constraints, 337c478bd9Sstevel@tonic-gate * and other system resources which comprise a secure and manageable 347c478bd9Sstevel@tonic-gate * application containment facility. 357c478bd9Sstevel@tonic-gate * 367c478bd9Sstevel@tonic-gate * Zones (represented by the reference counted zone_t) are tracked in 377c478bd9Sstevel@tonic-gate * the kernel in the zonehash. Elsewhere in the kernel, Zone IDs 387c478bd9Sstevel@tonic-gate * (zoneid_t) are used to track zone association. Zone IDs are 397c478bd9Sstevel@tonic-gate * dynamically generated when the zone is created; if a persistent 407c478bd9Sstevel@tonic-gate * identifier is needed (core files, accounting logs, audit trail, 417c478bd9Sstevel@tonic-gate * etc.), the zone name should be used. 427c478bd9Sstevel@tonic-gate * 437c478bd9Sstevel@tonic-gate * 447c478bd9Sstevel@tonic-gate * Global Zone: 457c478bd9Sstevel@tonic-gate * 467c478bd9Sstevel@tonic-gate * The global zone (zoneid 0) is automatically associated with all 477c478bd9Sstevel@tonic-gate * system resources that have not been bound to a user-created zone. 487c478bd9Sstevel@tonic-gate * This means that even systems where zones are not in active use 497c478bd9Sstevel@tonic-gate * have a global zone, and all processes, mounts, etc. are 507c478bd9Sstevel@tonic-gate * associated with that zone. The global zone is generally 517c478bd9Sstevel@tonic-gate * unconstrained in terms of privileges and access, though the usual 527c478bd9Sstevel@tonic-gate * credential and privilege based restrictions apply. 537c478bd9Sstevel@tonic-gate * 547c478bd9Sstevel@tonic-gate * 557c478bd9Sstevel@tonic-gate * Zone States: 567c478bd9Sstevel@tonic-gate * 577c478bd9Sstevel@tonic-gate * The states in which a zone may be in and the transitions are as 587c478bd9Sstevel@tonic-gate * follows: 597c478bd9Sstevel@tonic-gate * 607c478bd9Sstevel@tonic-gate * ZONE_IS_UNINITIALIZED: primordial state for a zone. The partially 617c478bd9Sstevel@tonic-gate * initialized zone is added to the list of active zones on the system but 627c478bd9Sstevel@tonic-gate * isn't accessible. 637c478bd9Sstevel@tonic-gate * 64bd41d0a8Snordmark * ZONE_IS_INITIALIZED: Initialization complete except the ZSD callbacks are 65bd41d0a8Snordmark * not yet completed. Not possible to enter the zone, but attributes can 66bd41d0a8Snordmark * be retrieved. 67bd41d0a8Snordmark * 687c478bd9Sstevel@tonic-gate * ZONE_IS_READY: zsched (the kernel dummy process for a zone) is 697c478bd9Sstevel@tonic-gate * ready. The zone is made visible after the ZSD constructor callbacks are 707c478bd9Sstevel@tonic-gate * executed. A zone remains in this state until it transitions into 717c478bd9Sstevel@tonic-gate * the ZONE_IS_BOOTING state as a result of a call to zone_boot(). 727c478bd9Sstevel@tonic-gate * 737c478bd9Sstevel@tonic-gate * ZONE_IS_BOOTING: in this shortlived-state, zsched attempts to start 747c478bd9Sstevel@tonic-gate * init. Should that fail, the zone proceeds to the ZONE_IS_SHUTTING_DOWN 757c478bd9Sstevel@tonic-gate * state. 767c478bd9Sstevel@tonic-gate * 777c478bd9Sstevel@tonic-gate * ZONE_IS_RUNNING: The zone is open for business: zsched has 787c478bd9Sstevel@tonic-gate * successfully started init. A zone remains in this state until 797c478bd9Sstevel@tonic-gate * zone_shutdown() is called. 807c478bd9Sstevel@tonic-gate * 817c478bd9Sstevel@tonic-gate * ZONE_IS_SHUTTING_DOWN: zone_shutdown() has been called, the system is 827c478bd9Sstevel@tonic-gate * killing all processes running in the zone. The zone remains 837c478bd9Sstevel@tonic-gate * in this state until there are no more user processes running in the zone. 847c478bd9Sstevel@tonic-gate * zone_create(), zone_enter(), and zone_destroy() on this zone will fail. 857c478bd9Sstevel@tonic-gate * Since zone_shutdown() is restartable, it may be called successfully 867c478bd9Sstevel@tonic-gate * multiple times for the same zone_t. Setting of the zone's state to 877c478bd9Sstevel@tonic-gate * ZONE_IS_SHUTTING_DOWN is synchronized with mounts, so VOP_MOUNT() may check 887c478bd9Sstevel@tonic-gate * the zone's status without worrying about it being a moving target. 897c478bd9Sstevel@tonic-gate * 907c478bd9Sstevel@tonic-gate * ZONE_IS_EMPTY: zone_shutdown() has been called, and there 917c478bd9Sstevel@tonic-gate * are no more user processes in the zone. The zone remains in this 927c478bd9Sstevel@tonic-gate * state until there are no more kernel threads associated with the 937c478bd9Sstevel@tonic-gate * zone. zone_create(), zone_enter(), and zone_destroy() on this zone will 947c478bd9Sstevel@tonic-gate * fail. 957c478bd9Sstevel@tonic-gate * 967c478bd9Sstevel@tonic-gate * ZONE_IS_DOWN: All kernel threads doing work on behalf of the zone 977c478bd9Sstevel@tonic-gate * have exited. zone_shutdown() returns. Henceforth it is not possible to 987c478bd9Sstevel@tonic-gate * join the zone or create kernel threads therein. 997c478bd9Sstevel@tonic-gate * 1007c478bd9Sstevel@tonic-gate * ZONE_IS_DYING: zone_destroy() has been called on the zone; zone 1017c478bd9Sstevel@tonic-gate * remains in this state until zsched exits. Calls to zone_find_by_*() 1027c478bd9Sstevel@tonic-gate * return NULL from now on. 1037c478bd9Sstevel@tonic-gate * 1047c478bd9Sstevel@tonic-gate * ZONE_IS_DEAD: zsched has exited (zone_ntasks == 0). There are no 1057c478bd9Sstevel@tonic-gate * processes or threads doing work on behalf of the zone. The zone is 1067c478bd9Sstevel@tonic-gate * removed from the list of active zones. zone_destroy() returns, and 1077c478bd9Sstevel@tonic-gate * the zone can be recreated. 1087c478bd9Sstevel@tonic-gate * 1097c478bd9Sstevel@tonic-gate * ZONE_IS_FREE (internal state): zone_ref goes to 0, ZSD destructor 1107c478bd9Sstevel@tonic-gate * callbacks are executed, and all memory associated with the zone is 1117c478bd9Sstevel@tonic-gate * freed. 1127c478bd9Sstevel@tonic-gate * 1137c478bd9Sstevel@tonic-gate * Threads can wait for the zone to enter a requested state by using 1147c478bd9Sstevel@tonic-gate * zone_status_wait() or zone_status_timedwait() with the desired 1157c478bd9Sstevel@tonic-gate * state passed in as an argument. Zone state transitions are 1167c478bd9Sstevel@tonic-gate * uni-directional; it is not possible to move back to an earlier state. 1177c478bd9Sstevel@tonic-gate * 1187c478bd9Sstevel@tonic-gate * 1197c478bd9Sstevel@tonic-gate * Zone-Specific Data: 1207c478bd9Sstevel@tonic-gate * 1217c478bd9Sstevel@tonic-gate * Subsystems needing to maintain zone-specific data can store that 1227c478bd9Sstevel@tonic-gate * data using the ZSD mechanism. This provides a zone-specific data 1237c478bd9Sstevel@tonic-gate * store, similar to thread-specific data (see pthread_getspecific(3C) 1247c478bd9Sstevel@tonic-gate * or the TSD code in uts/common/disp/thread.c. Also, ZSD can be used 1257c478bd9Sstevel@tonic-gate * to register callbacks to be invoked when a zone is created, shut 1267c478bd9Sstevel@tonic-gate * down, or destroyed. This can be used to initialize zone-specific 1277c478bd9Sstevel@tonic-gate * data for new zones and to clean up when zones go away. 1287c478bd9Sstevel@tonic-gate * 1297c478bd9Sstevel@tonic-gate * 1307c478bd9Sstevel@tonic-gate * Data Structures: 1317c478bd9Sstevel@tonic-gate * 1327c478bd9Sstevel@tonic-gate * The per-zone structure (zone_t) is reference counted, and freed 1337c478bd9Sstevel@tonic-gate * when all references are released. zone_hold and zone_rele can be 1347c478bd9Sstevel@tonic-gate * used to adjust the reference count. In addition, reference counts 1357c478bd9Sstevel@tonic-gate * associated with the cred_t structure are tracked separately using 1367c478bd9Sstevel@tonic-gate * zone_cred_hold and zone_cred_rele. 1377c478bd9Sstevel@tonic-gate * 1387c478bd9Sstevel@tonic-gate * Pointers to active zone_t's are stored in two hash tables; one 1397c478bd9Sstevel@tonic-gate * for searching by id, the other for searching by name. Lookups 1407c478bd9Sstevel@tonic-gate * can be performed on either basis, using zone_find_by_id and 1417c478bd9Sstevel@tonic-gate * zone_find_by_name. Both return zone_t pointers with the zone 1427c478bd9Sstevel@tonic-gate * held, so zone_rele should be called when the pointer is no longer 1437c478bd9Sstevel@tonic-gate * needed. Zones can also be searched by path; zone_find_by_path 1447c478bd9Sstevel@tonic-gate * returns the zone with which a path name is associated (global 1457c478bd9Sstevel@tonic-gate * zone if the path is not within some other zone's file system 1467c478bd9Sstevel@tonic-gate * hierarchy). This currently requires iterating through each zone, 1477c478bd9Sstevel@tonic-gate * so it is slower than an id or name search via a hash table. 1487c478bd9Sstevel@tonic-gate * 1497c478bd9Sstevel@tonic-gate * 1507c478bd9Sstevel@tonic-gate * Locking: 1517c478bd9Sstevel@tonic-gate * 1527c478bd9Sstevel@tonic-gate * zonehash_lock: This is a top-level global lock used to protect the 1537c478bd9Sstevel@tonic-gate * zone hash tables and lists. Zones cannot be created or destroyed 1547c478bd9Sstevel@tonic-gate * while this lock is held. 1557c478bd9Sstevel@tonic-gate * zone_status_lock: This is a global lock protecting zone state. 1567c478bd9Sstevel@tonic-gate * Zones cannot change state while this lock is held. It also 1577c478bd9Sstevel@tonic-gate * protects the list of kernel threads associated with a zone. 1587c478bd9Sstevel@tonic-gate * zone_lock: This is a per-zone lock used to protect several fields of 1597c478bd9Sstevel@tonic-gate * the zone_t (see <sys/zone.h> for details). In addition, holding 1607c478bd9Sstevel@tonic-gate * this lock means that the zone cannot go away. 1610209230bSgjelinek * zone_nlwps_lock: This is a per-zone lock used to protect the fields 1620209230bSgjelinek * related to the zone.max-lwps rctl. 1630209230bSgjelinek * zone_mem_lock: This is a per-zone lock used to protect the fields 1640209230bSgjelinek * related to the zone.max-locked-memory and zone.max-swap rctls. 1650fbb751dSJohn Levon * zone_rctl_lock: This is a per-zone lock used to protect other rctls, 1660fbb751dSJohn Levon * currently just max_lofi 1677c478bd9Sstevel@tonic-gate * zsd_key_lock: This is a global lock protecting the key state for ZSD. 1687c478bd9Sstevel@tonic-gate * zone_deathrow_lock: This is a global lock protecting the "deathrow" 1697c478bd9Sstevel@tonic-gate * list (a list of zones in the ZONE_IS_DEAD state). 1707c478bd9Sstevel@tonic-gate * 1717c478bd9Sstevel@tonic-gate * Ordering requirements: 1727c478bd9Sstevel@tonic-gate * pool_lock --> cpu_lock --> zonehash_lock --> zone_status_lock --> 1737c478bd9Sstevel@tonic-gate * zone_lock --> zsd_key_lock --> pidlock --> p_lock 1747c478bd9Sstevel@tonic-gate * 1750209230bSgjelinek * When taking zone_mem_lock or zone_nlwps_lock, the lock ordering is: 1760209230bSgjelinek * zonehash_lock --> a_lock --> pidlock --> p_lock --> zone_mem_lock 177ff19e029SMenno Lageman * zonehash_lock --> a_lock --> pidlock --> p_lock --> zone_nlwps_lock 1780209230bSgjelinek * 1797c478bd9Sstevel@tonic-gate * Blocking memory allocations are permitted while holding any of the 1807c478bd9Sstevel@tonic-gate * zone locks. 1817c478bd9Sstevel@tonic-gate * 1827c478bd9Sstevel@tonic-gate * 1837c478bd9Sstevel@tonic-gate * System Call Interface: 1847c478bd9Sstevel@tonic-gate * 1857c478bd9Sstevel@tonic-gate * The zone subsystem can be managed and queried from user level with 1867c478bd9Sstevel@tonic-gate * the following system calls (all subcodes of the primary "zone" 1877c478bd9Sstevel@tonic-gate * system call): 1887c478bd9Sstevel@tonic-gate * - zone_create: creates a zone with selected attributes (name, 189fa9e4066Sahrens * root path, privileges, resource controls, ZFS datasets) 1907c478bd9Sstevel@tonic-gate * - zone_enter: allows the current process to enter a zone 1917c478bd9Sstevel@tonic-gate * - zone_getattr: reports attributes of a zone 1923f2f09c1Sdp * - zone_setattr: set attributes of a zone 1933f2f09c1Sdp * - zone_boot: set 'init' running for the zone 1947c478bd9Sstevel@tonic-gate * - zone_list: lists all zones active in the system 1957c478bd9Sstevel@tonic-gate * - zone_lookup: looks up zone id based on name 1967c478bd9Sstevel@tonic-gate * - zone_shutdown: initiates shutdown process (see states above) 1977c478bd9Sstevel@tonic-gate * - zone_destroy: completes shutdown process (see states above) 1987c478bd9Sstevel@tonic-gate * 1997c478bd9Sstevel@tonic-gate */ 2007c478bd9Sstevel@tonic-gate 2017c478bd9Sstevel@tonic-gate #include <sys/priv_impl.h> 2027c478bd9Sstevel@tonic-gate #include <sys/cred.h> 2037c478bd9Sstevel@tonic-gate #include <c2/audit.h> 2047c478bd9Sstevel@tonic-gate #include <sys/debug.h> 2057c478bd9Sstevel@tonic-gate #include <sys/file.h> 2067c478bd9Sstevel@tonic-gate #include <sys/kmem.h> 2070209230bSgjelinek #include <sys/kstat.h> 2087c478bd9Sstevel@tonic-gate #include <sys/mutex.h> 20945916cd2Sjpk #include <sys/note.h> 2107c478bd9Sstevel@tonic-gate #include <sys/pathname.h> 2117c478bd9Sstevel@tonic-gate #include <sys/proc.h> 2127c478bd9Sstevel@tonic-gate #include <sys/project.h> 213cf8f45c7Sdstaff #include <sys/sysevent.h> 2147c478bd9Sstevel@tonic-gate #include <sys/task.h> 2157c478bd9Sstevel@tonic-gate #include <sys/systm.h> 2167c478bd9Sstevel@tonic-gate #include <sys/types.h> 2177c478bd9Sstevel@tonic-gate #include <sys/utsname.h> 2187c478bd9Sstevel@tonic-gate #include <sys/vnode.h> 2197c478bd9Sstevel@tonic-gate #include <sys/vfs.h> 2207c478bd9Sstevel@tonic-gate #include <sys/systeminfo.h> 2217c478bd9Sstevel@tonic-gate #include <sys/policy.h> 2227c478bd9Sstevel@tonic-gate #include <sys/cred_impl.h> 2237c478bd9Sstevel@tonic-gate #include <sys/contract_impl.h> 2247c478bd9Sstevel@tonic-gate #include <sys/contract/process_impl.h> 2257c478bd9Sstevel@tonic-gate #include <sys/class.h> 2267c478bd9Sstevel@tonic-gate #include <sys/pool.h> 2277c478bd9Sstevel@tonic-gate #include <sys/pool_pset.h> 2287c478bd9Sstevel@tonic-gate #include <sys/pset.h> 229a19609f8Sjv #include <sys/strlog.h> 2307c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h> 2317c478bd9Sstevel@tonic-gate #include <sys/callb.h> 2327c478bd9Sstevel@tonic-gate #include <sys/vmparam.h> 2337c478bd9Sstevel@tonic-gate #include <sys/corectl.h> 234824c205fSml #include <sys/ipc_impl.h> 235134a1f4eSCasper H.S. Dik #include <sys/klpd.h> 2367c478bd9Sstevel@tonic-gate 2377c478bd9Sstevel@tonic-gate #include <sys/door.h> 2387c478bd9Sstevel@tonic-gate #include <sys/cpuvar.h> 239bd41d0a8Snordmark #include <sys/sdt.h> 2407c478bd9Sstevel@tonic-gate 2417c478bd9Sstevel@tonic-gate #include <sys/uadmin.h> 2427c478bd9Sstevel@tonic-gate #include <sys/session.h> 2437c478bd9Sstevel@tonic-gate #include <sys/cmn_err.h> 2447c478bd9Sstevel@tonic-gate #include <sys/modhash.h> 2453f2f09c1Sdp #include <sys/sunddi.h> 2467c478bd9Sstevel@tonic-gate #include <sys/nvpair.h> 2477c478bd9Sstevel@tonic-gate #include <sys/rctl.h> 2487c478bd9Sstevel@tonic-gate #include <sys/fss.h> 2499acbbeafSnn #include <sys/brand.h> 2507c478bd9Sstevel@tonic-gate #include <sys/zone.h> 251f4b3ec61Sdh #include <net/if.h> 252c97ad5cdSakolb #include <sys/cpucaps.h> 2530209230bSgjelinek #include <vm/seg.h> 2542b24ab6bSSebastien Roy #include <sys/mac.h> 2552b24ab6bSSebastien Roy 256a19609f8Sjv /* 257a19609f8Sjv * This constant specifies the number of seconds that threads waiting for 258a19609f8Sjv * subsystems to release a zone's general-purpose references will wait before 259a19609f8Sjv * they log the zone's reference counts. The constant's value shouldn't 260a19609f8Sjv * be so small that reference counts are unnecessarily reported for zones 261a19609f8Sjv * whose references are slowly released. On the other hand, it shouldn't be so 262a19609f8Sjv * large that users reboot their systems out of frustration over hung zones 263a19609f8Sjv * before the system logs the zones' reference counts. 264a19609f8Sjv */ 265a19609f8Sjv #define ZONE_DESTROY_TIMEOUT_SECS 60 266a19609f8Sjv 2672b24ab6bSSebastien Roy /* List of data link IDs which are accessible from the zone */ 2682b24ab6bSSebastien Roy typedef struct zone_dl { 2692b24ab6bSSebastien Roy datalink_id_t zdl_id; 270550b6e40SSowmini Varadhan nvlist_t *zdl_net; 2712b24ab6bSSebastien Roy list_node_t zdl_linkage; 2722b24ab6bSSebastien Roy } zone_dl_t; 2730209230bSgjelinek 2747c478bd9Sstevel@tonic-gate /* 2757c478bd9Sstevel@tonic-gate * cv used to signal that all references to the zone have been released. This 2767c478bd9Sstevel@tonic-gate * needs to be global since there may be multiple waiters, and the first to 2777c478bd9Sstevel@tonic-gate * wake up will free the zone_t, hence we cannot use zone->zone_cv. 2787c478bd9Sstevel@tonic-gate */ 2797c478bd9Sstevel@tonic-gate static kcondvar_t zone_destroy_cv; 2807c478bd9Sstevel@tonic-gate /* 2817c478bd9Sstevel@tonic-gate * Lock used to serialize access to zone_cv. This could have been per-zone, 2827c478bd9Sstevel@tonic-gate * but then we'd need another lock for zone_destroy_cv, and why bother? 2837c478bd9Sstevel@tonic-gate */ 2847c478bd9Sstevel@tonic-gate static kmutex_t zone_status_lock; 2857c478bd9Sstevel@tonic-gate 2867c478bd9Sstevel@tonic-gate /* 2877c478bd9Sstevel@tonic-gate * ZSD-related global variables. 2887c478bd9Sstevel@tonic-gate */ 2897c478bd9Sstevel@tonic-gate static kmutex_t zsd_key_lock; /* protects the following two */ 2907c478bd9Sstevel@tonic-gate /* 2917c478bd9Sstevel@tonic-gate * The next caller of zone_key_create() will be assigned a key of ++zsd_keyval. 2927c478bd9Sstevel@tonic-gate */ 2937c478bd9Sstevel@tonic-gate static zone_key_t zsd_keyval = 0; 2947c478bd9Sstevel@tonic-gate /* 2957c478bd9Sstevel@tonic-gate * Global list of registered keys. We use this when a new zone is created. 2967c478bd9Sstevel@tonic-gate */ 2977c478bd9Sstevel@tonic-gate static list_t zsd_registered_keys; 2987c478bd9Sstevel@tonic-gate 2997c478bd9Sstevel@tonic-gate int zone_hash_size = 256; 30045916cd2Sjpk static mod_hash_t *zonehashbyname, *zonehashbyid, *zonehashbylabel; 3017c478bd9Sstevel@tonic-gate static kmutex_t zonehash_lock; 3027c478bd9Sstevel@tonic-gate static uint_t zonecount; 3037c478bd9Sstevel@tonic-gate static id_space_t *zoneid_space; 3047c478bd9Sstevel@tonic-gate 3057c478bd9Sstevel@tonic-gate /* 3067c478bd9Sstevel@tonic-gate * The global zone (aka zone0) is the all-seeing, all-knowing zone in which the 3077c478bd9Sstevel@tonic-gate * kernel proper runs, and which manages all other zones. 3087c478bd9Sstevel@tonic-gate * 3097c478bd9Sstevel@tonic-gate * Although not declared as static, the variable "zone0" should not be used 3107c478bd9Sstevel@tonic-gate * except for by code that needs to reference the global zone early on in boot, 3117c478bd9Sstevel@tonic-gate * before it is fully initialized. All other consumers should use 3127c478bd9Sstevel@tonic-gate * 'global_zone'. 3137c478bd9Sstevel@tonic-gate */ 3147c478bd9Sstevel@tonic-gate zone_t zone0; 3157c478bd9Sstevel@tonic-gate zone_t *global_zone = NULL; /* Set when the global zone is initialized */ 3167c478bd9Sstevel@tonic-gate 3177c478bd9Sstevel@tonic-gate /* 3187c478bd9Sstevel@tonic-gate * List of active zones, protected by zonehash_lock. 3197c478bd9Sstevel@tonic-gate */ 3207c478bd9Sstevel@tonic-gate static list_t zone_active; 3217c478bd9Sstevel@tonic-gate 3227c478bd9Sstevel@tonic-gate /* 3237c478bd9Sstevel@tonic-gate * List of destroyed zones that still have outstanding cred references. 3247c478bd9Sstevel@tonic-gate * Used for debugging. Uses a separate lock to avoid lock ordering 3257c478bd9Sstevel@tonic-gate * problems in zone_free. 3267c478bd9Sstevel@tonic-gate */ 3277c478bd9Sstevel@tonic-gate static list_t zone_deathrow; 3287c478bd9Sstevel@tonic-gate static kmutex_t zone_deathrow_lock; 3297c478bd9Sstevel@tonic-gate 3307c478bd9Sstevel@tonic-gate /* number of zones is limited by virtual interface limit in IP */ 3317c478bd9Sstevel@tonic-gate uint_t maxzones = 8192; 3327c478bd9Sstevel@tonic-gate 333cf8f45c7Sdstaff /* Event channel to sent zone state change notifications */ 334cf8f45c7Sdstaff evchan_t *zone_event_chan; 335cf8f45c7Sdstaff 336cf8f45c7Sdstaff /* 337cf8f45c7Sdstaff * This table holds the mapping from kernel zone states to 338cf8f45c7Sdstaff * states visible in the state notification API. 339cf8f45c7Sdstaff * The idea is that we only expose "obvious" states and 340cf8f45c7Sdstaff * do not expose states which are just implementation details. 341cf8f45c7Sdstaff */ 342cf8f45c7Sdstaff const char *zone_status_table[] = { 343cf8f45c7Sdstaff ZONE_EVENT_UNINITIALIZED, /* uninitialized */ 344bd41d0a8Snordmark ZONE_EVENT_INITIALIZED, /* initialized */ 345cf8f45c7Sdstaff ZONE_EVENT_READY, /* ready */ 346cf8f45c7Sdstaff ZONE_EVENT_READY, /* booting */ 347cf8f45c7Sdstaff ZONE_EVENT_RUNNING, /* running */ 348cf8f45c7Sdstaff ZONE_EVENT_SHUTTING_DOWN, /* shutting_down */ 349cf8f45c7Sdstaff ZONE_EVENT_SHUTTING_DOWN, /* empty */ 350cf8f45c7Sdstaff ZONE_EVENT_SHUTTING_DOWN, /* down */ 351cf8f45c7Sdstaff ZONE_EVENT_SHUTTING_DOWN, /* dying */ 352cf8f45c7Sdstaff ZONE_EVENT_UNINITIALIZED, /* dead */ 353cf8f45c7Sdstaff }; 354cf8f45c7Sdstaff 355a19609f8Sjv /* 356a19609f8Sjv * This array contains the names of the subsystems listed in zone_ref_subsys_t 357a19609f8Sjv * (see sys/zone.h). 358a19609f8Sjv */ 359a19609f8Sjv static char *zone_ref_subsys_names[] = { 360a19609f8Sjv "NFS", /* ZONE_REF_NFS */ 361a19609f8Sjv "NFSv4", /* ZONE_REF_NFSV4 */ 362a19609f8Sjv "SMBFS", /* ZONE_REF_SMBFS */ 363a19609f8Sjv "MNTFS", /* ZONE_REF_MNTFS */ 364a19609f8Sjv "LOFI", /* ZONE_REF_LOFI */ 365a19609f8Sjv "VFS", /* ZONE_REF_VFS */ 366a19609f8Sjv "IPC" /* ZONE_REF_IPC */ 367a19609f8Sjv }; 368a19609f8Sjv 3697c478bd9Sstevel@tonic-gate /* 3707c478bd9Sstevel@tonic-gate * This isn't static so lint doesn't complain. 3717c478bd9Sstevel@tonic-gate */ 3727c478bd9Sstevel@tonic-gate rctl_hndl_t rc_zone_cpu_shares; 373c6939658Ssl rctl_hndl_t rc_zone_locked_mem; 3740209230bSgjelinek rctl_hndl_t rc_zone_max_swap; 3750fbb751dSJohn Levon rctl_hndl_t rc_zone_max_lofi; 376c97ad5cdSakolb rctl_hndl_t rc_zone_cpu_cap; 3777c478bd9Sstevel@tonic-gate rctl_hndl_t rc_zone_nlwps; 378ff19e029SMenno Lageman rctl_hndl_t rc_zone_nprocs; 379824c205fSml rctl_hndl_t rc_zone_shmmax; 380824c205fSml rctl_hndl_t rc_zone_shmmni; 381824c205fSml rctl_hndl_t rc_zone_semmni; 382824c205fSml rctl_hndl_t rc_zone_msgmni; 3837c478bd9Sstevel@tonic-gate 3843f2f09c1Sdp const char * const zone_default_initname = "/sbin/init"; 38545916cd2Sjpk static char * const zone_prefix = "/zone/"; 3867c478bd9Sstevel@tonic-gate static int zone_shutdown(zoneid_t zoneid); 3872b24ab6bSSebastien Roy static int zone_add_datalink(zoneid_t, datalink_id_t); 3882b24ab6bSSebastien Roy static int zone_remove_datalink(zoneid_t, datalink_id_t); 3892b24ab6bSSebastien Roy static int zone_list_datalink(zoneid_t, int *, datalink_id_t *); 390550b6e40SSowmini Varadhan static int zone_set_network(zoneid_t, zone_net_data_t *); 391550b6e40SSowmini Varadhan static int zone_get_network(zoneid_t, zone_net_data_t *); 3927c478bd9Sstevel@tonic-gate 393bd41d0a8Snordmark typedef boolean_t zsd_applyfn_t(kmutex_t *, boolean_t, zone_t *, zone_key_t); 394bd41d0a8Snordmark 395bd41d0a8Snordmark static void zsd_apply_all_zones(zsd_applyfn_t *, zone_key_t); 396bd41d0a8Snordmark static void zsd_apply_all_keys(zsd_applyfn_t *, zone_t *); 397bd41d0a8Snordmark static boolean_t zsd_apply_create(kmutex_t *, boolean_t, zone_t *, zone_key_t); 398bd41d0a8Snordmark static boolean_t zsd_apply_shutdown(kmutex_t *, boolean_t, zone_t *, 399bd41d0a8Snordmark zone_key_t); 400bd41d0a8Snordmark static boolean_t zsd_apply_destroy(kmutex_t *, boolean_t, zone_t *, zone_key_t); 401bd41d0a8Snordmark static boolean_t zsd_wait_for_creator(zone_t *, struct zsd_entry *, 402bd41d0a8Snordmark kmutex_t *); 403bd41d0a8Snordmark static boolean_t zsd_wait_for_inprogress(zone_t *, struct zsd_entry *, 404bd41d0a8Snordmark kmutex_t *); 405bd41d0a8Snordmark 406821c4a97Sdp /* 407821c4a97Sdp * Bump this number when you alter the zone syscall interfaces; this is 408821c4a97Sdp * because we need to have support for previous API versions in libc 409821c4a97Sdp * to support patching; libc calls into the kernel to determine this number. 410821c4a97Sdp * 411821c4a97Sdp * Version 1 of the API is the version originally shipped with Solaris 10 412821c4a97Sdp * Version 2 alters the zone_create system call in order to support more 413821c4a97Sdp * arguments by moving the args into a structure; and to do better 414821c4a97Sdp * error reporting when zone_create() fails. 415821c4a97Sdp * Version 3 alters the zone_create system call in order to support the 416821c4a97Sdp * import of ZFS datasets to zones. 41745916cd2Sjpk * Version 4 alters the zone_create system call in order to support 41845916cd2Sjpk * Trusted Extensions. 4193f2f09c1Sdp * Version 5 alters the zone_boot system call, and converts its old 4203f2f09c1Sdp * bootargs parameter to be set by the zone_setattr API instead. 421f4b3ec61Sdh * Version 6 adds the flag argument to zone_create. 422821c4a97Sdp */ 423f4b3ec61Sdh static const int ZONE_SYSCALL_API_VERSION = 6; 424821c4a97Sdp 4257c478bd9Sstevel@tonic-gate /* 4267c478bd9Sstevel@tonic-gate * Certain filesystems (such as NFS and autofs) need to know which zone 4277c478bd9Sstevel@tonic-gate * the mount is being placed in. Because of this, we need to be able to 4285fd5c689SJerry Jelinek * ensure that a zone isn't in the process of being created/destroyed such 4295fd5c689SJerry Jelinek * that nfs_mount() thinks it is in the global/NGZ zone, while by the time 4305fd5c689SJerry Jelinek * it gets added the list of mounted zones, it ends up on the wrong zone's 4315fd5c689SJerry Jelinek * mount list. Since a zone can't reside on an NFS file system, we don't 4325fd5c689SJerry Jelinek * have to worry about the zonepath itself. 4337c478bd9Sstevel@tonic-gate * 4347c478bd9Sstevel@tonic-gate * The following functions: block_mounts()/resume_mounts() and 4357c478bd9Sstevel@tonic-gate * mount_in_progress()/mount_completed() are used by zones and the VFS 4365fd5c689SJerry Jelinek * layer (respectively) to synchronize zone state transitions and new 4375fd5c689SJerry Jelinek * mounts within a zone. This syncronization is on a per-zone basis, so 4385fd5c689SJerry Jelinek * activity for one zone will not interfere with activity for another zone. 4397c478bd9Sstevel@tonic-gate * 4407c478bd9Sstevel@tonic-gate * The semantics are like a reader-reader lock such that there may 4415fd5c689SJerry Jelinek * either be multiple mounts (or zone state transitions, if that weren't 4427c478bd9Sstevel@tonic-gate * serialized by zonehash_lock) in progress at the same time, but not 4437c478bd9Sstevel@tonic-gate * both. 4447c478bd9Sstevel@tonic-gate * 4457c478bd9Sstevel@tonic-gate * We use cv's so the user can ctrl-C out of the operation if it's 4467c478bd9Sstevel@tonic-gate * taking too long. 4477c478bd9Sstevel@tonic-gate * 4487c478bd9Sstevel@tonic-gate * The semantics are such that there is unfair bias towards the 4495fd5c689SJerry Jelinek * "current" operation. This means that zone halt may starve if 4505fd5c689SJerry Jelinek * there is a rapid succession of new mounts coming in to the zone. 4517c478bd9Sstevel@tonic-gate */ 4527c478bd9Sstevel@tonic-gate /* 4537c478bd9Sstevel@tonic-gate * Prevent new mounts from progressing to the point of calling 4547c478bd9Sstevel@tonic-gate * VFS_MOUNT(). If there are already mounts in this "region", wait for 4557c478bd9Sstevel@tonic-gate * them to complete. 4567c478bd9Sstevel@tonic-gate */ 4577c478bd9Sstevel@tonic-gate static int 4585fd5c689SJerry Jelinek block_mounts(zone_t *zp) 4597c478bd9Sstevel@tonic-gate { 4607c478bd9Sstevel@tonic-gate int retval = 0; 4617c478bd9Sstevel@tonic-gate 4627c478bd9Sstevel@tonic-gate /* 4637c478bd9Sstevel@tonic-gate * Since it may block for a long time, block_mounts() shouldn't be 4647c478bd9Sstevel@tonic-gate * called with zonehash_lock held. 4657c478bd9Sstevel@tonic-gate */ 4667c478bd9Sstevel@tonic-gate ASSERT(MUTEX_NOT_HELD(&zonehash_lock)); 4675fd5c689SJerry Jelinek mutex_enter(&zp->zone_mount_lock); 4685fd5c689SJerry Jelinek while (zp->zone_mounts_in_progress > 0) { 4695fd5c689SJerry Jelinek if (cv_wait_sig(&zp->zone_mount_cv, &zp->zone_mount_lock) == 0) 4707c478bd9Sstevel@tonic-gate goto signaled; 4717c478bd9Sstevel@tonic-gate } 4727c478bd9Sstevel@tonic-gate /* 4737c478bd9Sstevel@tonic-gate * A negative value of mounts_in_progress indicates that mounts 4745fd5c689SJerry Jelinek * have been blocked by (-mounts_in_progress) different callers 4755fd5c689SJerry Jelinek * (remotely possible if two threads enter zone_shutdown at the same 4765fd5c689SJerry Jelinek * time). 4777c478bd9Sstevel@tonic-gate */ 4785fd5c689SJerry Jelinek zp->zone_mounts_in_progress--; 4797c478bd9Sstevel@tonic-gate retval = 1; 4807c478bd9Sstevel@tonic-gate signaled: 4815fd5c689SJerry Jelinek mutex_exit(&zp->zone_mount_lock); 4827c478bd9Sstevel@tonic-gate return (retval); 4837c478bd9Sstevel@tonic-gate } 4847c478bd9Sstevel@tonic-gate 4857c478bd9Sstevel@tonic-gate /* 4867c478bd9Sstevel@tonic-gate * The VFS layer may progress with new mounts as far as we're concerned. 4877c478bd9Sstevel@tonic-gate * Allow them to progress if we were the last obstacle. 4887c478bd9Sstevel@tonic-gate */ 4897c478bd9Sstevel@tonic-gate static void 4905fd5c689SJerry Jelinek resume_mounts(zone_t *zp) 4917c478bd9Sstevel@tonic-gate { 4925fd5c689SJerry Jelinek mutex_enter(&zp->zone_mount_lock); 4935fd5c689SJerry Jelinek if (++zp->zone_mounts_in_progress == 0) 4945fd5c689SJerry Jelinek cv_broadcast(&zp->zone_mount_cv); 4955fd5c689SJerry Jelinek mutex_exit(&zp->zone_mount_lock); 4967c478bd9Sstevel@tonic-gate } 4977c478bd9Sstevel@tonic-gate 4987c478bd9Sstevel@tonic-gate /* 4995fd5c689SJerry Jelinek * The VFS layer is busy with a mount; this zone should wait until all 5005fd5c689SJerry Jelinek * of its mounts are completed to progress. 5017c478bd9Sstevel@tonic-gate */ 5027c478bd9Sstevel@tonic-gate void 5035fd5c689SJerry Jelinek mount_in_progress(zone_t *zp) 5047c478bd9Sstevel@tonic-gate { 5055fd5c689SJerry Jelinek mutex_enter(&zp->zone_mount_lock); 5065fd5c689SJerry Jelinek while (zp->zone_mounts_in_progress < 0) 5075fd5c689SJerry Jelinek cv_wait(&zp->zone_mount_cv, &zp->zone_mount_lock); 5085fd5c689SJerry Jelinek zp->zone_mounts_in_progress++; 5095fd5c689SJerry Jelinek mutex_exit(&zp->zone_mount_lock); 5107c478bd9Sstevel@tonic-gate } 5117c478bd9Sstevel@tonic-gate 5127c478bd9Sstevel@tonic-gate /* 5137c478bd9Sstevel@tonic-gate * VFS is done with one mount; wake up any waiting block_mounts() 5147c478bd9Sstevel@tonic-gate * callers if this is the last mount. 5157c478bd9Sstevel@tonic-gate */ 5167c478bd9Sstevel@tonic-gate void 5175fd5c689SJerry Jelinek mount_completed(zone_t *zp) 5187c478bd9Sstevel@tonic-gate { 5195fd5c689SJerry Jelinek mutex_enter(&zp->zone_mount_lock); 5205fd5c689SJerry Jelinek if (--zp->zone_mounts_in_progress == 0) 5215fd5c689SJerry Jelinek cv_broadcast(&zp->zone_mount_cv); 5225fd5c689SJerry Jelinek mutex_exit(&zp->zone_mount_lock); 5237c478bd9Sstevel@tonic-gate } 5247c478bd9Sstevel@tonic-gate 5257c478bd9Sstevel@tonic-gate /* 5267c478bd9Sstevel@tonic-gate * ZSD routines. 5277c478bd9Sstevel@tonic-gate * 5287c478bd9Sstevel@tonic-gate * Zone Specific Data (ZSD) is modeled after Thread Specific Data as 5297c478bd9Sstevel@tonic-gate * defined by the pthread_key_create() and related interfaces. 5307c478bd9Sstevel@tonic-gate * 5317c478bd9Sstevel@tonic-gate * Kernel subsystems may register one or more data items and/or 5327c478bd9Sstevel@tonic-gate * callbacks to be executed when a zone is created, shutdown, or 5337c478bd9Sstevel@tonic-gate * destroyed. 5347c478bd9Sstevel@tonic-gate * 5357c478bd9Sstevel@tonic-gate * Unlike the thread counterpart, destructor callbacks will be executed 5367c478bd9Sstevel@tonic-gate * even if the data pointer is NULL and/or there are no constructor 5377c478bd9Sstevel@tonic-gate * callbacks, so it is the responsibility of such callbacks to check for 5387c478bd9Sstevel@tonic-gate * NULL data values if necessary. 5397c478bd9Sstevel@tonic-gate * 5407c478bd9Sstevel@tonic-gate * The locking strategy and overall picture is as follows: 5417c478bd9Sstevel@tonic-gate * 5427c478bd9Sstevel@tonic-gate * When someone calls zone_key_create(), a template ZSD entry is added to the 543bd41d0a8Snordmark * global list "zsd_registered_keys", protected by zsd_key_lock. While 544bd41d0a8Snordmark * holding that lock all the existing zones are marked as 545bd41d0a8Snordmark * ZSD_CREATE_NEEDED and a copy of the ZSD entry added to the per-zone 546bd41d0a8Snordmark * zone_zsd list (protected by zone_lock). The global list is updated first 547bd41d0a8Snordmark * (under zone_key_lock) to make sure that newly created zones use the 548bd41d0a8Snordmark * most recent list of keys. Then under zonehash_lock we walk the zones 549bd41d0a8Snordmark * and mark them. Similar locking is used in zone_key_delete(). 5507c478bd9Sstevel@tonic-gate * 551bd41d0a8Snordmark * The actual create, shutdown, and destroy callbacks are done without 552bd41d0a8Snordmark * holding any lock. And zsd_flags are used to ensure that the operations 553bd41d0a8Snordmark * completed so that when zone_key_create (and zone_create) is done, as well as 554bd41d0a8Snordmark * zone_key_delete (and zone_destroy) is done, all the necessary callbacks 555bd41d0a8Snordmark * are completed. 5567c478bd9Sstevel@tonic-gate * 5577c478bd9Sstevel@tonic-gate * When new zones are created constructor callbacks for all registered ZSD 558bd41d0a8Snordmark * entries will be called. That also uses the above two phases of marking 559bd41d0a8Snordmark * what needs to be done, and then running the callbacks without holding 560bd41d0a8Snordmark * any locks. 5617c478bd9Sstevel@tonic-gate * 5627c478bd9Sstevel@tonic-gate * The framework does not provide any locking around zone_getspecific() and 5637c478bd9Sstevel@tonic-gate * zone_setspecific() apart from that needed for internal consistency, so 5647c478bd9Sstevel@tonic-gate * callers interested in atomic "test-and-set" semantics will need to provide 5657c478bd9Sstevel@tonic-gate * their own locking. 5667c478bd9Sstevel@tonic-gate */ 5677c478bd9Sstevel@tonic-gate 568bd41d0a8Snordmark /* 569bd41d0a8Snordmark * Helper function to find the zsd_entry associated with the key in the 570bd41d0a8Snordmark * given list. 571bd41d0a8Snordmark */ 572bd41d0a8Snordmark static struct zsd_entry * 573bd41d0a8Snordmark zsd_find(list_t *l, zone_key_t key) 574bd41d0a8Snordmark { 575bd41d0a8Snordmark struct zsd_entry *zsd; 5767c478bd9Sstevel@tonic-gate 577bd41d0a8Snordmark for (zsd = list_head(l); zsd != NULL; zsd = list_next(l, zsd)) { 578bd41d0a8Snordmark if (zsd->zsd_key == key) { 579bd41d0a8Snordmark return (zsd); 5807c478bd9Sstevel@tonic-gate } 5817c478bd9Sstevel@tonic-gate } 582bd41d0a8Snordmark return (NULL); 5837c478bd9Sstevel@tonic-gate } 5847c478bd9Sstevel@tonic-gate 5857c478bd9Sstevel@tonic-gate /* 5867c478bd9Sstevel@tonic-gate * Helper function to find the zsd_entry associated with the key in the 587bd41d0a8Snordmark * given list. Move it to the front of the list. 5887c478bd9Sstevel@tonic-gate */ 5897c478bd9Sstevel@tonic-gate static struct zsd_entry * 590bd41d0a8Snordmark zsd_find_mru(list_t *l, zone_key_t key) 5917c478bd9Sstevel@tonic-gate { 5927c478bd9Sstevel@tonic-gate struct zsd_entry *zsd; 5937c478bd9Sstevel@tonic-gate 5947c478bd9Sstevel@tonic-gate for (zsd = list_head(l); zsd != NULL; zsd = list_next(l, zsd)) { 5957c478bd9Sstevel@tonic-gate if (zsd->zsd_key == key) { 5967c478bd9Sstevel@tonic-gate /* 5977c478bd9Sstevel@tonic-gate * Move to head of list to keep list in MRU order. 5987c478bd9Sstevel@tonic-gate */ 5997c478bd9Sstevel@tonic-gate if (zsd != list_head(l)) { 6007c478bd9Sstevel@tonic-gate list_remove(l, zsd); 6017c478bd9Sstevel@tonic-gate list_insert_head(l, zsd); 6027c478bd9Sstevel@tonic-gate } 6037c478bd9Sstevel@tonic-gate return (zsd); 6047c478bd9Sstevel@tonic-gate } 6057c478bd9Sstevel@tonic-gate } 6067c478bd9Sstevel@tonic-gate return (NULL); 6077c478bd9Sstevel@tonic-gate } 6087c478bd9Sstevel@tonic-gate 609bd41d0a8Snordmark void 610bd41d0a8Snordmark zone_key_create(zone_key_t *keyp, void *(*create)(zoneid_t), 611bd41d0a8Snordmark void (*shutdown)(zoneid_t, void *), void (*destroy)(zoneid_t, void *)) 612bd41d0a8Snordmark { 613bd41d0a8Snordmark struct zsd_entry *zsdp; 614bd41d0a8Snordmark struct zsd_entry *t; 615bd41d0a8Snordmark struct zone *zone; 616bd41d0a8Snordmark zone_key_t key; 617bd41d0a8Snordmark 618bd41d0a8Snordmark zsdp = kmem_zalloc(sizeof (*zsdp), KM_SLEEP); 619bd41d0a8Snordmark zsdp->zsd_data = NULL; 620bd41d0a8Snordmark zsdp->zsd_create = create; 621bd41d0a8Snordmark zsdp->zsd_shutdown = shutdown; 622bd41d0a8Snordmark zsdp->zsd_destroy = destroy; 623bd41d0a8Snordmark 624bd41d0a8Snordmark /* 625bd41d0a8Snordmark * Insert in global list of callbacks. Makes future zone creations 626bd41d0a8Snordmark * see it. 627bd41d0a8Snordmark */ 628bd41d0a8Snordmark mutex_enter(&zsd_key_lock); 629fe16170aSPramod Batni key = zsdp->zsd_key = ++zsd_keyval; 630bd41d0a8Snordmark ASSERT(zsd_keyval != 0); 631bd41d0a8Snordmark list_insert_tail(&zsd_registered_keys, zsdp); 632bd41d0a8Snordmark mutex_exit(&zsd_key_lock); 633bd41d0a8Snordmark 634bd41d0a8Snordmark /* 635bd41d0a8Snordmark * Insert for all existing zones and mark them as needing 636bd41d0a8Snordmark * a create callback. 637bd41d0a8Snordmark */ 638bd41d0a8Snordmark mutex_enter(&zonehash_lock); /* stop the world */ 639bd41d0a8Snordmark for (zone = list_head(&zone_active); zone != NULL; 640bd41d0a8Snordmark zone = list_next(&zone_active, zone)) { 641bd41d0a8Snordmark zone_status_t status; 642bd41d0a8Snordmark 643bd41d0a8Snordmark mutex_enter(&zone->zone_lock); 644bd41d0a8Snordmark 645bd41d0a8Snordmark /* Skip zones that are on the way down or not yet up */ 646bd41d0a8Snordmark status = zone_status_get(zone); 647bd41d0a8Snordmark if (status >= ZONE_IS_DOWN || 648bd41d0a8Snordmark status == ZONE_IS_UNINITIALIZED) { 649bd41d0a8Snordmark mutex_exit(&zone->zone_lock); 650bd41d0a8Snordmark continue; 651bd41d0a8Snordmark } 652bd41d0a8Snordmark 653bd41d0a8Snordmark t = zsd_find_mru(&zone->zone_zsd, key); 654bd41d0a8Snordmark if (t != NULL) { 655bd41d0a8Snordmark /* 656bd41d0a8Snordmark * A zsd_configure already inserted it after 657bd41d0a8Snordmark * we dropped zsd_key_lock above. 658bd41d0a8Snordmark */ 659bd41d0a8Snordmark mutex_exit(&zone->zone_lock); 660bd41d0a8Snordmark continue; 661bd41d0a8Snordmark } 662bd41d0a8Snordmark t = kmem_zalloc(sizeof (*t), KM_SLEEP); 663bd41d0a8Snordmark t->zsd_key = key; 664bd41d0a8Snordmark t->zsd_create = create; 665bd41d0a8Snordmark t->zsd_shutdown = shutdown; 666bd41d0a8Snordmark t->zsd_destroy = destroy; 667bd41d0a8Snordmark if (create != NULL) { 668bd41d0a8Snordmark t->zsd_flags = ZSD_CREATE_NEEDED; 669bd41d0a8Snordmark DTRACE_PROBE2(zsd__create__needed, 670bd41d0a8Snordmark zone_t *, zone, zone_key_t, key); 671bd41d0a8Snordmark } 672bd41d0a8Snordmark list_insert_tail(&zone->zone_zsd, t); 673bd41d0a8Snordmark mutex_exit(&zone->zone_lock); 674bd41d0a8Snordmark } 675bd41d0a8Snordmark mutex_exit(&zonehash_lock); 676bd41d0a8Snordmark 677bd41d0a8Snordmark if (create != NULL) { 678bd41d0a8Snordmark /* Now call the create callback for this key */ 679bd41d0a8Snordmark zsd_apply_all_zones(zsd_apply_create, key); 680bd41d0a8Snordmark } 681fe16170aSPramod Batni /* 682835ee219SRobert Harris * It is safe for consumers to use the key now, make it 683835ee219SRobert Harris * globally visible. Specifically zone_getspecific() will 684835ee219SRobert Harris * always successfully return the zone specific data associated 685835ee219SRobert Harris * with the key. 686835ee219SRobert Harris */ 687fe16170aSPramod Batni *keyp = key; 688fe16170aSPramod Batni 689bd41d0a8Snordmark } 690bd41d0a8Snordmark 6917c478bd9Sstevel@tonic-gate /* 6927c478bd9Sstevel@tonic-gate * Function called when a module is being unloaded, or otherwise wishes 6937c478bd9Sstevel@tonic-gate * to unregister its ZSD key and callbacks. 694bd41d0a8Snordmark * 695bd41d0a8Snordmark * Remove from the global list and determine the functions that need to 696bd41d0a8Snordmark * be called under a global lock. Then call the functions without 697bd41d0a8Snordmark * holding any locks. Finally free up the zone_zsd entries. (The apply 698bd41d0a8Snordmark * functions need to access the zone_zsd entries to find zsd_data etc.) 6997c478bd9Sstevel@tonic-gate */ 7007c478bd9Sstevel@tonic-gate int 7017c478bd9Sstevel@tonic-gate zone_key_delete(zone_key_t key) 7027c478bd9Sstevel@tonic-gate { 7037c478bd9Sstevel@tonic-gate struct zsd_entry *zsdp = NULL; 7047c478bd9Sstevel@tonic-gate zone_t *zone; 7057c478bd9Sstevel@tonic-gate 7067c478bd9Sstevel@tonic-gate mutex_enter(&zsd_key_lock); 707bd41d0a8Snordmark zsdp = zsd_find_mru(&zsd_registered_keys, key); 708bd41d0a8Snordmark if (zsdp == NULL) { 709bd41d0a8Snordmark mutex_exit(&zsd_key_lock); 710bd41d0a8Snordmark return (-1); 711bd41d0a8Snordmark } 7127c478bd9Sstevel@tonic-gate list_remove(&zsd_registered_keys, zsdp); 7137c478bd9Sstevel@tonic-gate mutex_exit(&zsd_key_lock); 7147c478bd9Sstevel@tonic-gate 715bd41d0a8Snordmark mutex_enter(&zonehash_lock); 7167c478bd9Sstevel@tonic-gate for (zone = list_head(&zone_active); zone != NULL; 7177c478bd9Sstevel@tonic-gate zone = list_next(&zone_active, zone)) { 7187c478bd9Sstevel@tonic-gate struct zsd_entry *del; 719bd41d0a8Snordmark 720bd41d0a8Snordmark mutex_enter(&zone->zone_lock); 721bd41d0a8Snordmark del = zsd_find_mru(&zone->zone_zsd, key); 722bd41d0a8Snordmark if (del == NULL) { 723bd41d0a8Snordmark /* 724bd41d0a8Snordmark * Somebody else got here first e.g the zone going 725bd41d0a8Snordmark * away. 726bd41d0a8Snordmark */ 727bd41d0a8Snordmark mutex_exit(&zone->zone_lock); 728bd41d0a8Snordmark continue; 729bd41d0a8Snordmark } 730bd41d0a8Snordmark ASSERT(del->zsd_shutdown == zsdp->zsd_shutdown); 731bd41d0a8Snordmark ASSERT(del->zsd_destroy == zsdp->zsd_destroy); 732bd41d0a8Snordmark if (del->zsd_shutdown != NULL && 733bd41d0a8Snordmark (del->zsd_flags & ZSD_SHUTDOWN_ALL) == 0) { 734bd41d0a8Snordmark del->zsd_flags |= ZSD_SHUTDOWN_NEEDED; 735bd41d0a8Snordmark DTRACE_PROBE2(zsd__shutdown__needed, 736bd41d0a8Snordmark zone_t *, zone, zone_key_t, key); 737bd41d0a8Snordmark } 738bd41d0a8Snordmark if (del->zsd_destroy != NULL && 739bd41d0a8Snordmark (del->zsd_flags & ZSD_DESTROY_ALL) == 0) { 740bd41d0a8Snordmark del->zsd_flags |= ZSD_DESTROY_NEEDED; 741bd41d0a8Snordmark DTRACE_PROBE2(zsd__destroy__needed, 742bd41d0a8Snordmark zone_t *, zone, zone_key_t, key); 7437c478bd9Sstevel@tonic-gate } 7447c478bd9Sstevel@tonic-gate mutex_exit(&zone->zone_lock); 7457c478bd9Sstevel@tonic-gate } 7467c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 7477c478bd9Sstevel@tonic-gate kmem_free(zsdp, sizeof (*zsdp)); 7487c478bd9Sstevel@tonic-gate 749bd41d0a8Snordmark /* Now call the shutdown and destroy callback for this key */ 750bd41d0a8Snordmark zsd_apply_all_zones(zsd_apply_shutdown, key); 751bd41d0a8Snordmark zsd_apply_all_zones(zsd_apply_destroy, key); 752bd41d0a8Snordmark 753bd41d0a8Snordmark /* Now we can free up the zsdp structures in each zone */ 754bd41d0a8Snordmark mutex_enter(&zonehash_lock); 7557c478bd9Sstevel@tonic-gate for (zone = list_head(&zone_active); zone != NULL; 756bd41d0a8Snordmark zone = list_next(&zone_active, zone)) { 757bd41d0a8Snordmark struct zsd_entry *del; 758bd41d0a8Snordmark 759bd41d0a8Snordmark mutex_enter(&zone->zone_lock); 760bd41d0a8Snordmark del = zsd_find(&zone->zone_zsd, key); 761bd41d0a8Snordmark if (del != NULL) { 762bd41d0a8Snordmark list_remove(&zone->zone_zsd, del); 763bd41d0a8Snordmark ASSERT(!(del->zsd_flags & ZSD_ALL_INPROGRESS)); 764bd41d0a8Snordmark kmem_free(del, sizeof (*del)); 765bd41d0a8Snordmark } 7667c478bd9Sstevel@tonic-gate mutex_exit(&zone->zone_lock); 767bd41d0a8Snordmark } 7687c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 769bd41d0a8Snordmark 770bd41d0a8Snordmark return (0); 7717c478bd9Sstevel@tonic-gate } 7727c478bd9Sstevel@tonic-gate 7737c478bd9Sstevel@tonic-gate /* 7747c478bd9Sstevel@tonic-gate * ZSD counterpart of pthread_setspecific(). 775bd41d0a8Snordmark * 776bd41d0a8Snordmark * Since all zsd callbacks, including those with no create function, 777bd41d0a8Snordmark * have an entry in zone_zsd, if the key is registered it is part of 778bd41d0a8Snordmark * the zone_zsd list. 779bd41d0a8Snordmark * Return an error if the key wasn't registerd. 7807c478bd9Sstevel@tonic-gate */ 7817c478bd9Sstevel@tonic-gate int 7827c478bd9Sstevel@tonic-gate zone_setspecific(zone_key_t key, zone_t *zone, const void *data) 7837c478bd9Sstevel@tonic-gate { 7847c478bd9Sstevel@tonic-gate struct zsd_entry *t; 7857c478bd9Sstevel@tonic-gate 7867c478bd9Sstevel@tonic-gate mutex_enter(&zone->zone_lock); 787bd41d0a8Snordmark t = zsd_find_mru(&zone->zone_zsd, key); 7887c478bd9Sstevel@tonic-gate if (t != NULL) { 7897c478bd9Sstevel@tonic-gate /* 7907c478bd9Sstevel@tonic-gate * Replace old value with new 7917c478bd9Sstevel@tonic-gate */ 7927c478bd9Sstevel@tonic-gate t->zsd_data = (void *)data; 7937c478bd9Sstevel@tonic-gate mutex_exit(&zone->zone_lock); 7947c478bd9Sstevel@tonic-gate return (0); 7957c478bd9Sstevel@tonic-gate } 7967c478bd9Sstevel@tonic-gate mutex_exit(&zone->zone_lock); 797bd41d0a8Snordmark return (-1); 7987c478bd9Sstevel@tonic-gate } 7997c478bd9Sstevel@tonic-gate 8007c478bd9Sstevel@tonic-gate /* 8017c478bd9Sstevel@tonic-gate * ZSD counterpart of pthread_getspecific(). 8027c478bd9Sstevel@tonic-gate */ 8037c478bd9Sstevel@tonic-gate void * 8047c478bd9Sstevel@tonic-gate zone_getspecific(zone_key_t key, zone_t *zone) 8057c478bd9Sstevel@tonic-gate { 8067c478bd9Sstevel@tonic-gate struct zsd_entry *t; 8077c478bd9Sstevel@tonic-gate void *data; 8087c478bd9Sstevel@tonic-gate 8097c478bd9Sstevel@tonic-gate mutex_enter(&zone->zone_lock); 810bd41d0a8Snordmark t = zsd_find_mru(&zone->zone_zsd, key); 8117c478bd9Sstevel@tonic-gate data = (t == NULL ? NULL : t->zsd_data); 8127c478bd9Sstevel@tonic-gate mutex_exit(&zone->zone_lock); 8137c478bd9Sstevel@tonic-gate return (data); 8147c478bd9Sstevel@tonic-gate } 8157c478bd9Sstevel@tonic-gate 8167c478bd9Sstevel@tonic-gate /* 8177c478bd9Sstevel@tonic-gate * Function used to initialize a zone's list of ZSD callbacks and data 8187c478bd9Sstevel@tonic-gate * when the zone is being created. The callbacks are initialized from 819bd41d0a8Snordmark * the template list (zsd_registered_keys). The constructor callback is 820bd41d0a8Snordmark * executed later (once the zone exists and with locks dropped). 8217c478bd9Sstevel@tonic-gate */ 8227c478bd9Sstevel@tonic-gate static void 8237c478bd9Sstevel@tonic-gate zone_zsd_configure(zone_t *zone) 8247c478bd9Sstevel@tonic-gate { 8257c478bd9Sstevel@tonic-gate struct zsd_entry *zsdp; 8267c478bd9Sstevel@tonic-gate struct zsd_entry *t; 8277c478bd9Sstevel@tonic-gate 8287c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&zonehash_lock)); 8297c478bd9Sstevel@tonic-gate ASSERT(list_head(&zone->zone_zsd) == NULL); 830bd41d0a8Snordmark mutex_enter(&zone->zone_lock); 8317c478bd9Sstevel@tonic-gate mutex_enter(&zsd_key_lock); 8327c478bd9Sstevel@tonic-gate for (zsdp = list_head(&zsd_registered_keys); zsdp != NULL; 8337c478bd9Sstevel@tonic-gate zsdp = list_next(&zsd_registered_keys, zsdp)) { 834bd41d0a8Snordmark /* 835bd41d0a8Snordmark * Since this zone is ZONE_IS_UNCONFIGURED, zone_key_create 836bd41d0a8Snordmark * should not have added anything to it. 837bd41d0a8Snordmark */ 838bd41d0a8Snordmark ASSERT(zsd_find(&zone->zone_zsd, zsdp->zsd_key) == NULL); 839bd41d0a8Snordmark 840bd41d0a8Snordmark t = kmem_zalloc(sizeof (*t), KM_SLEEP); 841bd41d0a8Snordmark t->zsd_key = zsdp->zsd_key; 842bd41d0a8Snordmark t->zsd_create = zsdp->zsd_create; 843bd41d0a8Snordmark t->zsd_shutdown = zsdp->zsd_shutdown; 844bd41d0a8Snordmark t->zsd_destroy = zsdp->zsd_destroy; 8457c478bd9Sstevel@tonic-gate if (zsdp->zsd_create != NULL) { 846bd41d0a8Snordmark t->zsd_flags = ZSD_CREATE_NEEDED; 847bd41d0a8Snordmark DTRACE_PROBE2(zsd__create__needed, 848bd41d0a8Snordmark zone_t *, zone, zone_key_t, zsdp->zsd_key); 8497c478bd9Sstevel@tonic-gate } 850bd41d0a8Snordmark list_insert_tail(&zone->zone_zsd, t); 8517c478bd9Sstevel@tonic-gate } 8527c478bd9Sstevel@tonic-gate mutex_exit(&zsd_key_lock); 853bd41d0a8Snordmark mutex_exit(&zone->zone_lock); 8547c478bd9Sstevel@tonic-gate } 8557c478bd9Sstevel@tonic-gate 8567c478bd9Sstevel@tonic-gate enum zsd_callback_type { ZSD_CREATE, ZSD_SHUTDOWN, ZSD_DESTROY }; 8577c478bd9Sstevel@tonic-gate 8587c478bd9Sstevel@tonic-gate /* 8597c478bd9Sstevel@tonic-gate * Helper function to execute shutdown or destructor callbacks. 8607c478bd9Sstevel@tonic-gate */ 8617c478bd9Sstevel@tonic-gate static void 8627c478bd9Sstevel@tonic-gate zone_zsd_callbacks(zone_t *zone, enum zsd_callback_type ct) 8637c478bd9Sstevel@tonic-gate { 8647c478bd9Sstevel@tonic-gate struct zsd_entry *t; 8657c478bd9Sstevel@tonic-gate 8667c478bd9Sstevel@tonic-gate ASSERT(ct == ZSD_SHUTDOWN || ct == ZSD_DESTROY); 8677c478bd9Sstevel@tonic-gate ASSERT(ct != ZSD_SHUTDOWN || zone_status_get(zone) >= ZONE_IS_EMPTY); 8687c478bd9Sstevel@tonic-gate ASSERT(ct != ZSD_DESTROY || zone_status_get(zone) >= ZONE_IS_DOWN); 8697c478bd9Sstevel@tonic-gate 8707c478bd9Sstevel@tonic-gate /* 871bd41d0a8Snordmark * Run the callback solely based on what is registered for the zone 872bd41d0a8Snordmark * in zone_zsd. The global list can change independently of this 873bd41d0a8Snordmark * as keys are registered and unregistered and we don't register new 874bd41d0a8Snordmark * callbacks for a zone that is in the process of going away. 8757c478bd9Sstevel@tonic-gate */ 876bd41d0a8Snordmark mutex_enter(&zone->zone_lock); 877bd41d0a8Snordmark for (t = list_head(&zone->zone_zsd); t != NULL; 878bd41d0a8Snordmark t = list_next(&zone->zone_zsd, t)) { 879bd41d0a8Snordmark zone_key_t key = t->zsd_key; 8807c478bd9Sstevel@tonic-gate 8817c478bd9Sstevel@tonic-gate /* Skip if no callbacks registered */ 882bd41d0a8Snordmark 883bd41d0a8Snordmark if (ct == ZSD_SHUTDOWN) { 884bd41d0a8Snordmark if (t->zsd_shutdown != NULL && 885bd41d0a8Snordmark (t->zsd_flags & ZSD_SHUTDOWN_ALL) == 0) { 886bd41d0a8Snordmark t->zsd_flags |= ZSD_SHUTDOWN_NEEDED; 887bd41d0a8Snordmark DTRACE_PROBE2(zsd__shutdown__needed, 888bd41d0a8Snordmark zone_t *, zone, zone_key_t, key); 8897c478bd9Sstevel@tonic-gate } 8907c478bd9Sstevel@tonic-gate } else { 891bd41d0a8Snordmark if (t->zsd_destroy != NULL && 892bd41d0a8Snordmark (t->zsd_flags & ZSD_DESTROY_ALL) == 0) { 893bd41d0a8Snordmark t->zsd_flags |= ZSD_DESTROY_NEEDED; 894bd41d0a8Snordmark DTRACE_PROBE2(zsd__destroy__needed, 895bd41d0a8Snordmark zone_t *, zone, zone_key_t, key); 8967c478bd9Sstevel@tonic-gate } 8977c478bd9Sstevel@tonic-gate } 8987c478bd9Sstevel@tonic-gate } 899bd41d0a8Snordmark mutex_exit(&zone->zone_lock); 900bd41d0a8Snordmark 901bd41d0a8Snordmark /* Now call the shutdown and destroy callback for this key */ 902bd41d0a8Snordmark zsd_apply_all_keys(zsd_apply_shutdown, zone); 903bd41d0a8Snordmark zsd_apply_all_keys(zsd_apply_destroy, zone); 904bd41d0a8Snordmark 9057c478bd9Sstevel@tonic-gate } 9067c478bd9Sstevel@tonic-gate 9077c478bd9Sstevel@tonic-gate /* 9087c478bd9Sstevel@tonic-gate * Called when the zone is going away; free ZSD-related memory, and 9097c478bd9Sstevel@tonic-gate * destroy the zone_zsd list. 9107c478bd9Sstevel@tonic-gate */ 9117c478bd9Sstevel@tonic-gate static void 9127c478bd9Sstevel@tonic-gate zone_free_zsd(zone_t *zone) 9137c478bd9Sstevel@tonic-gate { 9147c478bd9Sstevel@tonic-gate struct zsd_entry *t, *next; 9157c478bd9Sstevel@tonic-gate 9167c478bd9Sstevel@tonic-gate /* 9177c478bd9Sstevel@tonic-gate * Free all the zsd_entry's we had on this zone. 9187c478bd9Sstevel@tonic-gate */ 919bd41d0a8Snordmark mutex_enter(&zone->zone_lock); 9207c478bd9Sstevel@tonic-gate for (t = list_head(&zone->zone_zsd); t != NULL; t = next) { 9217c478bd9Sstevel@tonic-gate next = list_next(&zone->zone_zsd, t); 9227c478bd9Sstevel@tonic-gate list_remove(&zone->zone_zsd, t); 923bd41d0a8Snordmark ASSERT(!(t->zsd_flags & ZSD_ALL_INPROGRESS)); 9247c478bd9Sstevel@tonic-gate kmem_free(t, sizeof (*t)); 9257c478bd9Sstevel@tonic-gate } 9267c478bd9Sstevel@tonic-gate list_destroy(&zone->zone_zsd); 927bd41d0a8Snordmark mutex_exit(&zone->zone_lock); 928bd41d0a8Snordmark 929bd41d0a8Snordmark } 930bd41d0a8Snordmark 931bd41d0a8Snordmark /* 932bd41d0a8Snordmark * Apply a function to all zones for particular key value. 933bd41d0a8Snordmark * 934bd41d0a8Snordmark * The applyfn has to drop zonehash_lock if it does some work, and 935bd41d0a8Snordmark * then reacquire it before it returns. 936bd41d0a8Snordmark * When the lock is dropped we don't follow list_next even 937bd41d0a8Snordmark * if it is possible to do so without any hazards. This is 938bd41d0a8Snordmark * because we want the design to allow for the list of zones 939bd41d0a8Snordmark * to change in any arbitrary way during the time the 940bd41d0a8Snordmark * lock was dropped. 941bd41d0a8Snordmark * 942bd41d0a8Snordmark * It is safe to restart the loop at list_head since the applyfn 943bd41d0a8Snordmark * changes the zsd_flags as it does work, so a subsequent 944bd41d0a8Snordmark * pass through will have no effect in applyfn, hence the loop will terminate 945bd41d0a8Snordmark * in at worst O(N^2). 946bd41d0a8Snordmark */ 947bd41d0a8Snordmark static void 948bd41d0a8Snordmark zsd_apply_all_zones(zsd_applyfn_t *applyfn, zone_key_t key) 949bd41d0a8Snordmark { 950bd41d0a8Snordmark zone_t *zone; 951bd41d0a8Snordmark 952bd41d0a8Snordmark mutex_enter(&zonehash_lock); 953bd41d0a8Snordmark zone = list_head(&zone_active); 954bd41d0a8Snordmark while (zone != NULL) { 955bd41d0a8Snordmark if ((applyfn)(&zonehash_lock, B_FALSE, zone, key)) { 956bd41d0a8Snordmark /* Lock dropped - restart at head */ 957bd41d0a8Snordmark zone = list_head(&zone_active); 958bd41d0a8Snordmark } else { 959bd41d0a8Snordmark zone = list_next(&zone_active, zone); 960bd41d0a8Snordmark } 961bd41d0a8Snordmark } 962bd41d0a8Snordmark mutex_exit(&zonehash_lock); 963bd41d0a8Snordmark } 964bd41d0a8Snordmark 965bd41d0a8Snordmark /* 966bd41d0a8Snordmark * Apply a function to all keys for a particular zone. 967bd41d0a8Snordmark * 968bd41d0a8Snordmark * The applyfn has to drop zonehash_lock if it does some work, and 969bd41d0a8Snordmark * then reacquire it before it returns. 970bd41d0a8Snordmark * When the lock is dropped we don't follow list_next even 971bd41d0a8Snordmark * if it is possible to do so without any hazards. This is 972bd41d0a8Snordmark * because we want the design to allow for the list of zsd callbacks 973bd41d0a8Snordmark * to change in any arbitrary way during the time the 974bd41d0a8Snordmark * lock was dropped. 975bd41d0a8Snordmark * 976bd41d0a8Snordmark * It is safe to restart the loop at list_head since the applyfn 977bd41d0a8Snordmark * changes the zsd_flags as it does work, so a subsequent 978bd41d0a8Snordmark * pass through will have no effect in applyfn, hence the loop will terminate 979bd41d0a8Snordmark * in at worst O(N^2). 980bd41d0a8Snordmark */ 981bd41d0a8Snordmark static void 982bd41d0a8Snordmark zsd_apply_all_keys(zsd_applyfn_t *applyfn, zone_t *zone) 983bd41d0a8Snordmark { 984bd41d0a8Snordmark struct zsd_entry *t; 985bd41d0a8Snordmark 986bd41d0a8Snordmark mutex_enter(&zone->zone_lock); 987bd41d0a8Snordmark t = list_head(&zone->zone_zsd); 988bd41d0a8Snordmark while (t != NULL) { 989bd41d0a8Snordmark if ((applyfn)(NULL, B_TRUE, zone, t->zsd_key)) { 990bd41d0a8Snordmark /* Lock dropped - restart at head */ 991bd41d0a8Snordmark t = list_head(&zone->zone_zsd); 992bd41d0a8Snordmark } else { 993bd41d0a8Snordmark t = list_next(&zone->zone_zsd, t); 994bd41d0a8Snordmark } 995bd41d0a8Snordmark } 996bd41d0a8Snordmark mutex_exit(&zone->zone_lock); 997bd41d0a8Snordmark } 998bd41d0a8Snordmark 999bd41d0a8Snordmark /* 1000bd41d0a8Snordmark * Call the create function for the zone and key if CREATE_NEEDED 1001bd41d0a8Snordmark * is set. 1002bd41d0a8Snordmark * If some other thread gets here first and sets CREATE_INPROGRESS, then 1003bd41d0a8Snordmark * we wait for that thread to complete so that we can ensure that 1004bd41d0a8Snordmark * all the callbacks are done when we've looped over all zones/keys. 1005bd41d0a8Snordmark * 1006bd41d0a8Snordmark * When we call the create function, we drop the global held by the 1007bd41d0a8Snordmark * caller, and return true to tell the caller it needs to re-evalute the 1008bd41d0a8Snordmark * state. 1009bd41d0a8Snordmark * If the caller holds zone_lock then zone_lock_held is set, and zone_lock 1010bd41d0a8Snordmark * remains held on exit. 1011bd41d0a8Snordmark */ 1012bd41d0a8Snordmark static boolean_t 1013bd41d0a8Snordmark zsd_apply_create(kmutex_t *lockp, boolean_t zone_lock_held, 1014bd41d0a8Snordmark zone_t *zone, zone_key_t key) 1015bd41d0a8Snordmark { 1016bd41d0a8Snordmark void *result; 1017bd41d0a8Snordmark struct zsd_entry *t; 1018bd41d0a8Snordmark boolean_t dropped; 1019bd41d0a8Snordmark 1020bd41d0a8Snordmark if (lockp != NULL) { 1021bd41d0a8Snordmark ASSERT(MUTEX_HELD(lockp)); 1022bd41d0a8Snordmark } 1023bd41d0a8Snordmark if (zone_lock_held) { 1024bd41d0a8Snordmark ASSERT(MUTEX_HELD(&zone->zone_lock)); 1025bd41d0a8Snordmark } else { 1026bd41d0a8Snordmark mutex_enter(&zone->zone_lock); 1027bd41d0a8Snordmark } 1028bd41d0a8Snordmark 1029bd41d0a8Snordmark t = zsd_find(&zone->zone_zsd, key); 1030bd41d0a8Snordmark if (t == NULL) { 1031bd41d0a8Snordmark /* 1032bd41d0a8Snordmark * Somebody else got here first e.g the zone going 1033bd41d0a8Snordmark * away. 1034bd41d0a8Snordmark */ 1035bd41d0a8Snordmark if (!zone_lock_held) 1036bd41d0a8Snordmark mutex_exit(&zone->zone_lock); 1037bd41d0a8Snordmark return (B_FALSE); 1038bd41d0a8Snordmark } 1039bd41d0a8Snordmark dropped = B_FALSE; 1040bd41d0a8Snordmark if (zsd_wait_for_inprogress(zone, t, lockp)) 1041bd41d0a8Snordmark dropped = B_TRUE; 1042bd41d0a8Snordmark 1043bd41d0a8Snordmark if (t->zsd_flags & ZSD_CREATE_NEEDED) { 1044bd41d0a8Snordmark t->zsd_flags &= ~ZSD_CREATE_NEEDED; 1045bd41d0a8Snordmark t->zsd_flags |= ZSD_CREATE_INPROGRESS; 1046bd41d0a8Snordmark DTRACE_PROBE2(zsd__create__inprogress, 1047bd41d0a8Snordmark zone_t *, zone, zone_key_t, key); 1048bd41d0a8Snordmark mutex_exit(&zone->zone_lock); 1049bd41d0a8Snordmark if (lockp != NULL) 1050bd41d0a8Snordmark mutex_exit(lockp); 1051bd41d0a8Snordmark 1052bd41d0a8Snordmark dropped = B_TRUE; 1053bd41d0a8Snordmark ASSERT(t->zsd_create != NULL); 1054bd41d0a8Snordmark DTRACE_PROBE2(zsd__create__start, 1055bd41d0a8Snordmark zone_t *, zone, zone_key_t, key); 1056bd41d0a8Snordmark 1057bd41d0a8Snordmark result = (*t->zsd_create)(zone->zone_id); 1058bd41d0a8Snordmark 1059bd41d0a8Snordmark DTRACE_PROBE2(zsd__create__end, 1060bd41d0a8Snordmark zone_t *, zone, voidn *, result); 1061bd41d0a8Snordmark 1062bd41d0a8Snordmark ASSERT(result != NULL); 1063bd41d0a8Snordmark if (lockp != NULL) 1064bd41d0a8Snordmark mutex_enter(lockp); 1065bd41d0a8Snordmark mutex_enter(&zone->zone_lock); 1066bd41d0a8Snordmark t->zsd_data = result; 1067bd41d0a8Snordmark t->zsd_flags &= ~ZSD_CREATE_INPROGRESS; 1068bd41d0a8Snordmark t->zsd_flags |= ZSD_CREATE_COMPLETED; 1069bd41d0a8Snordmark cv_broadcast(&t->zsd_cv); 1070bd41d0a8Snordmark DTRACE_PROBE2(zsd__create__completed, 1071bd41d0a8Snordmark zone_t *, zone, zone_key_t, key); 1072bd41d0a8Snordmark } 1073bd41d0a8Snordmark if (!zone_lock_held) 1074bd41d0a8Snordmark mutex_exit(&zone->zone_lock); 1075bd41d0a8Snordmark return (dropped); 1076bd41d0a8Snordmark } 1077bd41d0a8Snordmark 1078bd41d0a8Snordmark /* 1079bd41d0a8Snordmark * Call the shutdown function for the zone and key if SHUTDOWN_NEEDED 1080bd41d0a8Snordmark * is set. 1081bd41d0a8Snordmark * If some other thread gets here first and sets *_INPROGRESS, then 1082bd41d0a8Snordmark * we wait for that thread to complete so that we can ensure that 1083bd41d0a8Snordmark * all the callbacks are done when we've looped over all zones/keys. 1084bd41d0a8Snordmark * 1085bd41d0a8Snordmark * When we call the shutdown function, we drop the global held by the 1086bd41d0a8Snordmark * caller, and return true to tell the caller it needs to re-evalute the 1087bd41d0a8Snordmark * state. 1088bd41d0a8Snordmark * If the caller holds zone_lock then zone_lock_held is set, and zone_lock 1089bd41d0a8Snordmark * remains held on exit. 1090bd41d0a8Snordmark */ 1091bd41d0a8Snordmark static boolean_t 1092bd41d0a8Snordmark zsd_apply_shutdown(kmutex_t *lockp, boolean_t zone_lock_held, 1093bd41d0a8Snordmark zone_t *zone, zone_key_t key) 1094bd41d0a8Snordmark { 1095bd41d0a8Snordmark struct zsd_entry *t; 1096bd41d0a8Snordmark void *data; 1097bd41d0a8Snordmark boolean_t dropped; 1098bd41d0a8Snordmark 1099bd41d0a8Snordmark if (lockp != NULL) { 1100bd41d0a8Snordmark ASSERT(MUTEX_HELD(lockp)); 1101bd41d0a8Snordmark } 1102bd41d0a8Snordmark if (zone_lock_held) { 1103bd41d0a8Snordmark ASSERT(MUTEX_HELD(&zone->zone_lock)); 1104bd41d0a8Snordmark } else { 1105bd41d0a8Snordmark mutex_enter(&zone->zone_lock); 1106bd41d0a8Snordmark } 1107bd41d0a8Snordmark 1108bd41d0a8Snordmark t = zsd_find(&zone->zone_zsd, key); 1109bd41d0a8Snordmark if (t == NULL) { 1110bd41d0a8Snordmark /* 1111bd41d0a8Snordmark * Somebody else got here first e.g the zone going 1112bd41d0a8Snordmark * away. 1113bd41d0a8Snordmark */ 1114bd41d0a8Snordmark if (!zone_lock_held) 1115bd41d0a8Snordmark mutex_exit(&zone->zone_lock); 1116bd41d0a8Snordmark return (B_FALSE); 1117bd41d0a8Snordmark } 1118bd41d0a8Snordmark dropped = B_FALSE; 1119bd41d0a8Snordmark if (zsd_wait_for_creator(zone, t, lockp)) 1120bd41d0a8Snordmark dropped = B_TRUE; 1121bd41d0a8Snordmark 1122bd41d0a8Snordmark if (zsd_wait_for_inprogress(zone, t, lockp)) 1123bd41d0a8Snordmark dropped = B_TRUE; 1124bd41d0a8Snordmark 1125bd41d0a8Snordmark if (t->zsd_flags & ZSD_SHUTDOWN_NEEDED) { 1126bd41d0a8Snordmark t->zsd_flags &= ~ZSD_SHUTDOWN_NEEDED; 1127bd41d0a8Snordmark t->zsd_flags |= ZSD_SHUTDOWN_INPROGRESS; 1128bd41d0a8Snordmark DTRACE_PROBE2(zsd__shutdown__inprogress, 1129bd41d0a8Snordmark zone_t *, zone, zone_key_t, key); 1130bd41d0a8Snordmark mutex_exit(&zone->zone_lock); 1131bd41d0a8Snordmark if (lockp != NULL) 1132bd41d0a8Snordmark mutex_exit(lockp); 1133bd41d0a8Snordmark dropped = B_TRUE; 1134bd41d0a8Snordmark 1135bd41d0a8Snordmark ASSERT(t->zsd_shutdown != NULL); 1136bd41d0a8Snordmark data = t->zsd_data; 1137bd41d0a8Snordmark 1138bd41d0a8Snordmark DTRACE_PROBE2(zsd__shutdown__start, 1139bd41d0a8Snordmark zone_t *, zone, zone_key_t, key); 1140bd41d0a8Snordmark 1141bd41d0a8Snordmark (t->zsd_shutdown)(zone->zone_id, data); 1142bd41d0a8Snordmark DTRACE_PROBE2(zsd__shutdown__end, 1143bd41d0a8Snordmark zone_t *, zone, zone_key_t, key); 1144bd41d0a8Snordmark 1145bd41d0a8Snordmark if (lockp != NULL) 1146bd41d0a8Snordmark mutex_enter(lockp); 1147bd41d0a8Snordmark mutex_enter(&zone->zone_lock); 1148bd41d0a8Snordmark t->zsd_flags &= ~ZSD_SHUTDOWN_INPROGRESS; 1149bd41d0a8Snordmark t->zsd_flags |= ZSD_SHUTDOWN_COMPLETED; 1150bd41d0a8Snordmark cv_broadcast(&t->zsd_cv); 1151bd41d0a8Snordmark DTRACE_PROBE2(zsd__shutdown__completed, 1152bd41d0a8Snordmark zone_t *, zone, zone_key_t, key); 1153bd41d0a8Snordmark } 1154bd41d0a8Snordmark if (!zone_lock_held) 1155bd41d0a8Snordmark mutex_exit(&zone->zone_lock); 1156bd41d0a8Snordmark return (dropped); 1157bd41d0a8Snordmark } 1158bd41d0a8Snordmark 1159bd41d0a8Snordmark /* 1160bd41d0a8Snordmark * Call the destroy function for the zone and key if DESTROY_NEEDED 1161bd41d0a8Snordmark * is set. 1162bd41d0a8Snordmark * If some other thread gets here first and sets *_INPROGRESS, then 1163bd41d0a8Snordmark * we wait for that thread to complete so that we can ensure that 1164bd41d0a8Snordmark * all the callbacks are done when we've looped over all zones/keys. 1165bd41d0a8Snordmark * 1166bd41d0a8Snordmark * When we call the destroy function, we drop the global held by the 1167bd41d0a8Snordmark * caller, and return true to tell the caller it needs to re-evalute the 1168bd41d0a8Snordmark * state. 1169bd41d0a8Snordmark * If the caller holds zone_lock then zone_lock_held is set, and zone_lock 1170bd41d0a8Snordmark * remains held on exit. 1171bd41d0a8Snordmark */ 1172bd41d0a8Snordmark static boolean_t 1173bd41d0a8Snordmark zsd_apply_destroy(kmutex_t *lockp, boolean_t zone_lock_held, 1174bd41d0a8Snordmark zone_t *zone, zone_key_t key) 1175bd41d0a8Snordmark { 1176bd41d0a8Snordmark struct zsd_entry *t; 1177bd41d0a8Snordmark void *data; 1178bd41d0a8Snordmark boolean_t dropped; 1179bd41d0a8Snordmark 1180bd41d0a8Snordmark if (lockp != NULL) { 1181bd41d0a8Snordmark ASSERT(MUTEX_HELD(lockp)); 1182bd41d0a8Snordmark } 1183bd41d0a8Snordmark if (zone_lock_held) { 1184bd41d0a8Snordmark ASSERT(MUTEX_HELD(&zone->zone_lock)); 1185bd41d0a8Snordmark } else { 1186bd41d0a8Snordmark mutex_enter(&zone->zone_lock); 1187bd41d0a8Snordmark } 1188bd41d0a8Snordmark 1189bd41d0a8Snordmark t = zsd_find(&zone->zone_zsd, key); 1190bd41d0a8Snordmark if (t == NULL) { 1191bd41d0a8Snordmark /* 1192bd41d0a8Snordmark * Somebody else got here first e.g the zone going 1193bd41d0a8Snordmark * away. 1194bd41d0a8Snordmark */ 1195bd41d0a8Snordmark if (!zone_lock_held) 1196bd41d0a8Snordmark mutex_exit(&zone->zone_lock); 1197bd41d0a8Snordmark return (B_FALSE); 1198bd41d0a8Snordmark } 1199bd41d0a8Snordmark dropped = B_FALSE; 1200bd41d0a8Snordmark if (zsd_wait_for_creator(zone, t, lockp)) 1201bd41d0a8Snordmark dropped = B_TRUE; 1202bd41d0a8Snordmark 1203bd41d0a8Snordmark if (zsd_wait_for_inprogress(zone, t, lockp)) 1204bd41d0a8Snordmark dropped = B_TRUE; 1205bd41d0a8Snordmark 1206bd41d0a8Snordmark if (t->zsd_flags & ZSD_DESTROY_NEEDED) { 1207bd41d0a8Snordmark t->zsd_flags &= ~ZSD_DESTROY_NEEDED; 1208bd41d0a8Snordmark t->zsd_flags |= ZSD_DESTROY_INPROGRESS; 1209bd41d0a8Snordmark DTRACE_PROBE2(zsd__destroy__inprogress, 1210bd41d0a8Snordmark zone_t *, zone, zone_key_t, key); 1211bd41d0a8Snordmark mutex_exit(&zone->zone_lock); 1212bd41d0a8Snordmark if (lockp != NULL) 1213bd41d0a8Snordmark mutex_exit(lockp); 1214bd41d0a8Snordmark dropped = B_TRUE; 1215bd41d0a8Snordmark 1216bd41d0a8Snordmark ASSERT(t->zsd_destroy != NULL); 1217bd41d0a8Snordmark data = t->zsd_data; 1218bd41d0a8Snordmark DTRACE_PROBE2(zsd__destroy__start, 1219bd41d0a8Snordmark zone_t *, zone, zone_key_t, key); 1220bd41d0a8Snordmark 1221bd41d0a8Snordmark (t->zsd_destroy)(zone->zone_id, data); 1222bd41d0a8Snordmark DTRACE_PROBE2(zsd__destroy__end, 1223bd41d0a8Snordmark zone_t *, zone, zone_key_t, key); 1224bd41d0a8Snordmark 1225bd41d0a8Snordmark if (lockp != NULL) 1226bd41d0a8Snordmark mutex_enter(lockp); 1227bd41d0a8Snordmark mutex_enter(&zone->zone_lock); 1228bd41d0a8Snordmark t->zsd_data = NULL; 1229bd41d0a8Snordmark t->zsd_flags &= ~ZSD_DESTROY_INPROGRESS; 1230bd41d0a8Snordmark t->zsd_flags |= ZSD_DESTROY_COMPLETED; 1231bd41d0a8Snordmark cv_broadcast(&t->zsd_cv); 1232bd41d0a8Snordmark DTRACE_PROBE2(zsd__destroy__completed, 1233bd41d0a8Snordmark zone_t *, zone, zone_key_t, key); 1234bd41d0a8Snordmark } 1235bd41d0a8Snordmark if (!zone_lock_held) 1236bd41d0a8Snordmark mutex_exit(&zone->zone_lock); 1237bd41d0a8Snordmark return (dropped); 1238bd41d0a8Snordmark } 1239bd41d0a8Snordmark 1240bd41d0a8Snordmark /* 1241bd41d0a8Snordmark * Wait for any CREATE_NEEDED flag to be cleared. 1242bd41d0a8Snordmark * Returns true if lockp was temporarily dropped while waiting. 1243bd41d0a8Snordmark */ 1244bd41d0a8Snordmark static boolean_t 1245bd41d0a8Snordmark zsd_wait_for_creator(zone_t *zone, struct zsd_entry *t, kmutex_t *lockp) 1246bd41d0a8Snordmark { 1247bd41d0a8Snordmark boolean_t dropped = B_FALSE; 1248bd41d0a8Snordmark 1249bd41d0a8Snordmark while (t->zsd_flags & ZSD_CREATE_NEEDED) { 1250bd41d0a8Snordmark DTRACE_PROBE2(zsd__wait__for__creator, 1251bd41d0a8Snordmark zone_t *, zone, struct zsd_entry *, t); 1252bd41d0a8Snordmark if (lockp != NULL) { 1253bd41d0a8Snordmark dropped = B_TRUE; 1254bd41d0a8Snordmark mutex_exit(lockp); 1255bd41d0a8Snordmark } 1256bd41d0a8Snordmark cv_wait(&t->zsd_cv, &zone->zone_lock); 1257bd41d0a8Snordmark if (lockp != NULL) { 1258bd41d0a8Snordmark /* First drop zone_lock to preserve order */ 1259bd41d0a8Snordmark mutex_exit(&zone->zone_lock); 1260bd41d0a8Snordmark mutex_enter(lockp); 1261bd41d0a8Snordmark mutex_enter(&zone->zone_lock); 1262bd41d0a8Snordmark } 1263bd41d0a8Snordmark } 1264bd41d0a8Snordmark return (dropped); 1265bd41d0a8Snordmark } 1266bd41d0a8Snordmark 1267bd41d0a8Snordmark /* 1268bd41d0a8Snordmark * Wait for any INPROGRESS flag to be cleared. 1269bd41d0a8Snordmark * Returns true if lockp was temporarily dropped while waiting. 1270bd41d0a8Snordmark */ 1271bd41d0a8Snordmark static boolean_t 1272bd41d0a8Snordmark zsd_wait_for_inprogress(zone_t *zone, struct zsd_entry *t, kmutex_t *lockp) 1273bd41d0a8Snordmark { 1274bd41d0a8Snordmark boolean_t dropped = B_FALSE; 1275bd41d0a8Snordmark 1276bd41d0a8Snordmark while (t->zsd_flags & ZSD_ALL_INPROGRESS) { 1277bd41d0a8Snordmark DTRACE_PROBE2(zsd__wait__for__inprogress, 1278bd41d0a8Snordmark zone_t *, zone, struct zsd_entry *, t); 1279bd41d0a8Snordmark if (lockp != NULL) { 1280bd41d0a8Snordmark dropped = B_TRUE; 1281bd41d0a8Snordmark mutex_exit(lockp); 1282bd41d0a8Snordmark } 1283bd41d0a8Snordmark cv_wait(&t->zsd_cv, &zone->zone_lock); 1284bd41d0a8Snordmark if (lockp != NULL) { 1285bd41d0a8Snordmark /* First drop zone_lock to preserve order */ 1286bd41d0a8Snordmark mutex_exit(&zone->zone_lock); 1287bd41d0a8Snordmark mutex_enter(lockp); 1288bd41d0a8Snordmark mutex_enter(&zone->zone_lock); 1289bd41d0a8Snordmark } 1290bd41d0a8Snordmark } 1291bd41d0a8Snordmark return (dropped); 12927c478bd9Sstevel@tonic-gate } 12937c478bd9Sstevel@tonic-gate 1294fa9e4066Sahrens /* 1295fa9e4066Sahrens * Frees memory associated with the zone dataset list. 1296fa9e4066Sahrens */ 1297fa9e4066Sahrens static void 1298fa9e4066Sahrens zone_free_datasets(zone_t *zone) 1299fa9e4066Sahrens { 1300fa9e4066Sahrens zone_dataset_t *t, *next; 1301fa9e4066Sahrens 1302fa9e4066Sahrens for (t = list_head(&zone->zone_datasets); t != NULL; t = next) { 1303fa9e4066Sahrens next = list_next(&zone->zone_datasets, t); 1304fa9e4066Sahrens list_remove(&zone->zone_datasets, t); 1305fa9e4066Sahrens kmem_free(t->zd_dataset, strlen(t->zd_dataset) + 1); 1306fa9e4066Sahrens kmem_free(t, sizeof (*t)); 1307fa9e4066Sahrens } 1308fa9e4066Sahrens list_destroy(&zone->zone_datasets); 1309fa9e4066Sahrens } 1310fa9e4066Sahrens 13117c478bd9Sstevel@tonic-gate /* 13127c478bd9Sstevel@tonic-gate * zone.cpu-shares resource control support. 13137c478bd9Sstevel@tonic-gate */ 13147c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 13157c478bd9Sstevel@tonic-gate static rctl_qty_t 13167c478bd9Sstevel@tonic-gate zone_cpu_shares_usage(rctl_t *rctl, struct proc *p) 13177c478bd9Sstevel@tonic-gate { 13187c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&p->p_lock)); 13197c478bd9Sstevel@tonic-gate return (p->p_zone->zone_shares); 13207c478bd9Sstevel@tonic-gate } 13217c478bd9Sstevel@tonic-gate 13227c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 13237c478bd9Sstevel@tonic-gate static int 13247c478bd9Sstevel@tonic-gate zone_cpu_shares_set(rctl_t *rctl, struct proc *p, rctl_entity_p_t *e, 13257c478bd9Sstevel@tonic-gate rctl_qty_t nv) 13267c478bd9Sstevel@tonic-gate { 13277c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&p->p_lock)); 13287c478bd9Sstevel@tonic-gate ASSERT(e->rcep_t == RCENTITY_ZONE); 13297c478bd9Sstevel@tonic-gate if (e->rcep_p.zone == NULL) 13307c478bd9Sstevel@tonic-gate return (0); 13317c478bd9Sstevel@tonic-gate 13327c478bd9Sstevel@tonic-gate e->rcep_p.zone->zone_shares = nv; 13337c478bd9Sstevel@tonic-gate return (0); 13347c478bd9Sstevel@tonic-gate } 13357c478bd9Sstevel@tonic-gate 13367c478bd9Sstevel@tonic-gate static rctl_ops_t zone_cpu_shares_ops = { 13377c478bd9Sstevel@tonic-gate rcop_no_action, 13387c478bd9Sstevel@tonic-gate zone_cpu_shares_usage, 13397c478bd9Sstevel@tonic-gate zone_cpu_shares_set, 13407c478bd9Sstevel@tonic-gate rcop_no_test 13417c478bd9Sstevel@tonic-gate }; 13427c478bd9Sstevel@tonic-gate 1343c97ad5cdSakolb /* 1344c97ad5cdSakolb * zone.cpu-cap resource control support. 1345c97ad5cdSakolb */ 1346c97ad5cdSakolb /*ARGSUSED*/ 1347c97ad5cdSakolb static rctl_qty_t 1348c97ad5cdSakolb zone_cpu_cap_get(rctl_t *rctl, struct proc *p) 1349c97ad5cdSakolb { 1350c97ad5cdSakolb ASSERT(MUTEX_HELD(&p->p_lock)); 1351c97ad5cdSakolb return (cpucaps_zone_get(p->p_zone)); 1352c97ad5cdSakolb } 1353c97ad5cdSakolb 1354c97ad5cdSakolb /*ARGSUSED*/ 1355c97ad5cdSakolb static int 1356c97ad5cdSakolb zone_cpu_cap_set(rctl_t *rctl, struct proc *p, rctl_entity_p_t *e, 1357c97ad5cdSakolb rctl_qty_t nv) 1358c97ad5cdSakolb { 1359c97ad5cdSakolb zone_t *zone = e->rcep_p.zone; 1360c97ad5cdSakolb 1361c97ad5cdSakolb ASSERT(MUTEX_HELD(&p->p_lock)); 1362c97ad5cdSakolb ASSERT(e->rcep_t == RCENTITY_ZONE); 1363c97ad5cdSakolb 1364c97ad5cdSakolb if (zone == NULL) 1365c97ad5cdSakolb return (0); 1366c97ad5cdSakolb 1367c97ad5cdSakolb /* 1368c97ad5cdSakolb * set cap to the new value. 1369c97ad5cdSakolb */ 1370c97ad5cdSakolb return (cpucaps_zone_set(zone, nv)); 1371c97ad5cdSakolb } 1372c97ad5cdSakolb 1373c97ad5cdSakolb static rctl_ops_t zone_cpu_cap_ops = { 1374c97ad5cdSakolb rcop_no_action, 1375c97ad5cdSakolb zone_cpu_cap_get, 1376c97ad5cdSakolb zone_cpu_cap_set, 1377c97ad5cdSakolb rcop_no_test 1378c97ad5cdSakolb }; 1379c97ad5cdSakolb 13807c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 13817c478bd9Sstevel@tonic-gate static rctl_qty_t 13827c478bd9Sstevel@tonic-gate zone_lwps_usage(rctl_t *r, proc_t *p) 13837c478bd9Sstevel@tonic-gate { 13847c478bd9Sstevel@tonic-gate rctl_qty_t nlwps; 13857c478bd9Sstevel@tonic-gate zone_t *zone = p->p_zone; 13867c478bd9Sstevel@tonic-gate 13877c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&p->p_lock)); 13887c478bd9Sstevel@tonic-gate 13897c478bd9Sstevel@tonic-gate mutex_enter(&zone->zone_nlwps_lock); 13907c478bd9Sstevel@tonic-gate nlwps = zone->zone_nlwps; 13917c478bd9Sstevel@tonic-gate mutex_exit(&zone->zone_nlwps_lock); 13927c478bd9Sstevel@tonic-gate 13937c478bd9Sstevel@tonic-gate return (nlwps); 13947c478bd9Sstevel@tonic-gate } 13957c478bd9Sstevel@tonic-gate 13967c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 13977c478bd9Sstevel@tonic-gate static int 13987c478bd9Sstevel@tonic-gate zone_lwps_test(rctl_t *r, proc_t *p, rctl_entity_p_t *e, rctl_val_t *rcntl, 13997c478bd9Sstevel@tonic-gate rctl_qty_t incr, uint_t flags) 14007c478bd9Sstevel@tonic-gate { 14017c478bd9Sstevel@tonic-gate rctl_qty_t nlwps; 14027c478bd9Sstevel@tonic-gate 14037c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&p->p_lock)); 14047c478bd9Sstevel@tonic-gate ASSERT(e->rcep_t == RCENTITY_ZONE); 14057c478bd9Sstevel@tonic-gate if (e->rcep_p.zone == NULL) 14067c478bd9Sstevel@tonic-gate return (0); 14077c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&(e->rcep_p.zone->zone_nlwps_lock))); 14087c478bd9Sstevel@tonic-gate nlwps = e->rcep_p.zone->zone_nlwps; 14097c478bd9Sstevel@tonic-gate 14107c478bd9Sstevel@tonic-gate if (nlwps + incr > rcntl->rcv_value) 14117c478bd9Sstevel@tonic-gate return (1); 14127c478bd9Sstevel@tonic-gate 14137c478bd9Sstevel@tonic-gate return (0); 14147c478bd9Sstevel@tonic-gate } 14157c478bd9Sstevel@tonic-gate 14167c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 14177c478bd9Sstevel@tonic-gate static int 1418c6939658Ssl zone_lwps_set(rctl_t *rctl, struct proc *p, rctl_entity_p_t *e, rctl_qty_t nv) 1419c6939658Ssl { 14207c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&p->p_lock)); 14217c478bd9Sstevel@tonic-gate ASSERT(e->rcep_t == RCENTITY_ZONE); 14227c478bd9Sstevel@tonic-gate if (e->rcep_p.zone == NULL) 14237c478bd9Sstevel@tonic-gate return (0); 14247c478bd9Sstevel@tonic-gate e->rcep_p.zone->zone_nlwps_ctl = nv; 14257c478bd9Sstevel@tonic-gate return (0); 14267c478bd9Sstevel@tonic-gate } 14277c478bd9Sstevel@tonic-gate 14287c478bd9Sstevel@tonic-gate static rctl_ops_t zone_lwps_ops = { 14297c478bd9Sstevel@tonic-gate rcop_no_action, 14307c478bd9Sstevel@tonic-gate zone_lwps_usage, 14317c478bd9Sstevel@tonic-gate zone_lwps_set, 14327c478bd9Sstevel@tonic-gate zone_lwps_test, 14337c478bd9Sstevel@tonic-gate }; 14347c478bd9Sstevel@tonic-gate 1435ff19e029SMenno Lageman /*ARGSUSED*/ 1436ff19e029SMenno Lageman static rctl_qty_t 1437ff19e029SMenno Lageman zone_procs_usage(rctl_t *r, proc_t *p) 1438ff19e029SMenno Lageman { 1439ff19e029SMenno Lageman rctl_qty_t nprocs; 1440ff19e029SMenno Lageman zone_t *zone = p->p_zone; 1441ff19e029SMenno Lageman 1442ff19e029SMenno Lageman ASSERT(MUTEX_HELD(&p->p_lock)); 1443ff19e029SMenno Lageman 1444ff19e029SMenno Lageman mutex_enter(&zone->zone_nlwps_lock); 1445ff19e029SMenno Lageman nprocs = zone->zone_nprocs; 1446ff19e029SMenno Lageman mutex_exit(&zone->zone_nlwps_lock); 1447ff19e029SMenno Lageman 1448ff19e029SMenno Lageman return (nprocs); 1449ff19e029SMenno Lageman } 1450ff19e029SMenno Lageman 1451ff19e029SMenno Lageman /*ARGSUSED*/ 1452ff19e029SMenno Lageman static int 1453ff19e029SMenno Lageman zone_procs_test(rctl_t *r, proc_t *p, rctl_entity_p_t *e, rctl_val_t *rcntl, 1454ff19e029SMenno Lageman rctl_qty_t incr, uint_t flags) 1455ff19e029SMenno Lageman { 1456ff19e029SMenno Lageman rctl_qty_t nprocs; 1457ff19e029SMenno Lageman 1458ff19e029SMenno Lageman ASSERT(MUTEX_HELD(&p->p_lock)); 1459ff19e029SMenno Lageman ASSERT(e->rcep_t == RCENTITY_ZONE); 1460ff19e029SMenno Lageman if (e->rcep_p.zone == NULL) 1461ff19e029SMenno Lageman return (0); 1462ff19e029SMenno Lageman ASSERT(MUTEX_HELD(&(e->rcep_p.zone->zone_nlwps_lock))); 1463ff19e029SMenno Lageman nprocs = e->rcep_p.zone->zone_nprocs; 1464ff19e029SMenno Lageman 1465ff19e029SMenno Lageman if (nprocs + incr > rcntl->rcv_value) 1466ff19e029SMenno Lageman return (1); 1467ff19e029SMenno Lageman 1468ff19e029SMenno Lageman return (0); 1469ff19e029SMenno Lageman } 1470ff19e029SMenno Lageman 1471ff19e029SMenno Lageman /*ARGSUSED*/ 1472ff19e029SMenno Lageman static int 1473ff19e029SMenno Lageman zone_procs_set(rctl_t *rctl, struct proc *p, rctl_entity_p_t *e, rctl_qty_t nv) 1474ff19e029SMenno Lageman { 1475ff19e029SMenno Lageman ASSERT(MUTEX_HELD(&p->p_lock)); 1476ff19e029SMenno Lageman ASSERT(e->rcep_t == RCENTITY_ZONE); 1477ff19e029SMenno Lageman if (e->rcep_p.zone == NULL) 1478ff19e029SMenno Lageman return (0); 1479ff19e029SMenno Lageman e->rcep_p.zone->zone_nprocs_ctl = nv; 1480ff19e029SMenno Lageman return (0); 1481ff19e029SMenno Lageman } 1482ff19e029SMenno Lageman 1483ff19e029SMenno Lageman static rctl_ops_t zone_procs_ops = { 1484ff19e029SMenno Lageman rcop_no_action, 1485ff19e029SMenno Lageman zone_procs_usage, 1486ff19e029SMenno Lageman zone_procs_set, 1487ff19e029SMenno Lageman zone_procs_test, 1488ff19e029SMenno Lageman }; 1489ff19e029SMenno Lageman 149008c359e5SJerry Jelinek /*ARGSUSED*/ 149108c359e5SJerry Jelinek static rctl_qty_t 149208c359e5SJerry Jelinek zone_shmmax_usage(rctl_t *rctl, struct proc *p) 149308c359e5SJerry Jelinek { 149408c359e5SJerry Jelinek ASSERT(MUTEX_HELD(&p->p_lock)); 149508c359e5SJerry Jelinek return (p->p_zone->zone_shmmax); 149608c359e5SJerry Jelinek } 149708c359e5SJerry Jelinek 1498824c205fSml /*ARGSUSED*/ 1499824c205fSml static int 1500824c205fSml zone_shmmax_test(rctl_t *r, proc_t *p, rctl_entity_p_t *e, rctl_val_t *rval, 1501824c205fSml rctl_qty_t incr, uint_t flags) 1502824c205fSml { 1503824c205fSml rctl_qty_t v; 1504824c205fSml ASSERT(MUTEX_HELD(&p->p_lock)); 1505824c205fSml ASSERT(e->rcep_t == RCENTITY_ZONE); 1506824c205fSml v = e->rcep_p.zone->zone_shmmax + incr; 1507824c205fSml if (v > rval->rcv_value) 1508824c205fSml return (1); 1509824c205fSml return (0); 1510824c205fSml } 1511824c205fSml 1512824c205fSml static rctl_ops_t zone_shmmax_ops = { 1513824c205fSml rcop_no_action, 151408c359e5SJerry Jelinek zone_shmmax_usage, 1515824c205fSml rcop_no_set, 1516824c205fSml zone_shmmax_test 1517824c205fSml }; 1518824c205fSml 151908c359e5SJerry Jelinek /*ARGSUSED*/ 152008c359e5SJerry Jelinek static rctl_qty_t 152108c359e5SJerry Jelinek zone_shmmni_usage(rctl_t *rctl, struct proc *p) 152208c359e5SJerry Jelinek { 152308c359e5SJerry Jelinek ASSERT(MUTEX_HELD(&p->p_lock)); 152408c359e5SJerry Jelinek return (p->p_zone->zone_ipc.ipcq_shmmni); 152508c359e5SJerry Jelinek } 152608c359e5SJerry Jelinek 1527824c205fSml /*ARGSUSED*/ 1528824c205fSml static int 1529824c205fSml zone_shmmni_test(rctl_t *r, proc_t *p, rctl_entity_p_t *e, rctl_val_t *rval, 1530824c205fSml rctl_qty_t incr, uint_t flags) 1531824c205fSml { 1532824c205fSml rctl_qty_t v; 1533824c205fSml ASSERT(MUTEX_HELD(&p->p_lock)); 1534824c205fSml ASSERT(e->rcep_t == RCENTITY_ZONE); 1535824c205fSml v = e->rcep_p.zone->zone_ipc.ipcq_shmmni + incr; 1536824c205fSml if (v > rval->rcv_value) 1537824c205fSml return (1); 1538824c205fSml return (0); 1539824c205fSml } 1540824c205fSml 1541824c205fSml static rctl_ops_t zone_shmmni_ops = { 1542824c205fSml rcop_no_action, 154308c359e5SJerry Jelinek zone_shmmni_usage, 1544824c205fSml rcop_no_set, 1545824c205fSml zone_shmmni_test 1546824c205fSml }; 1547824c205fSml 154808c359e5SJerry Jelinek /*ARGSUSED*/ 154908c359e5SJerry Jelinek static rctl_qty_t 155008c359e5SJerry Jelinek zone_semmni_usage(rctl_t *rctl, struct proc *p) 155108c359e5SJerry Jelinek { 155208c359e5SJerry Jelinek ASSERT(MUTEX_HELD(&p->p_lock)); 155308c359e5SJerry Jelinek return (p->p_zone->zone_ipc.ipcq_semmni); 155408c359e5SJerry Jelinek } 155508c359e5SJerry Jelinek 1556824c205fSml /*ARGSUSED*/ 1557824c205fSml static int 1558824c205fSml zone_semmni_test(rctl_t *r, proc_t *p, rctl_entity_p_t *e, rctl_val_t *rval, 1559824c205fSml rctl_qty_t incr, uint_t flags) 1560824c205fSml { 1561824c205fSml rctl_qty_t v; 1562824c205fSml ASSERT(MUTEX_HELD(&p->p_lock)); 1563824c205fSml ASSERT(e->rcep_t == RCENTITY_ZONE); 1564824c205fSml v = e->rcep_p.zone->zone_ipc.ipcq_semmni + incr; 1565824c205fSml if (v > rval->rcv_value) 1566824c205fSml return (1); 1567824c205fSml return (0); 1568824c205fSml } 1569824c205fSml 1570824c205fSml static rctl_ops_t zone_semmni_ops = { 1571824c205fSml rcop_no_action, 157208c359e5SJerry Jelinek zone_semmni_usage, 1573824c205fSml rcop_no_set, 1574824c205fSml zone_semmni_test 1575824c205fSml }; 1576824c205fSml 157708c359e5SJerry Jelinek /*ARGSUSED*/ 157808c359e5SJerry Jelinek static rctl_qty_t 157908c359e5SJerry Jelinek zone_msgmni_usage(rctl_t *rctl, struct proc *p) 158008c359e5SJerry Jelinek { 158108c359e5SJerry Jelinek ASSERT(MUTEX_HELD(&p->p_lock)); 158208c359e5SJerry Jelinek return (p->p_zone->zone_ipc.ipcq_msgmni); 158308c359e5SJerry Jelinek } 158408c359e5SJerry Jelinek 1585824c205fSml /*ARGSUSED*/ 1586824c205fSml static int 1587824c205fSml zone_msgmni_test(rctl_t *r, proc_t *p, rctl_entity_p_t *e, rctl_val_t *rval, 1588824c205fSml rctl_qty_t incr, uint_t flags) 1589824c205fSml { 1590824c205fSml rctl_qty_t v; 1591824c205fSml ASSERT(MUTEX_HELD(&p->p_lock)); 1592824c205fSml ASSERT(e->rcep_t == RCENTITY_ZONE); 1593824c205fSml v = e->rcep_p.zone->zone_ipc.ipcq_msgmni + incr; 1594824c205fSml if (v > rval->rcv_value) 1595824c205fSml return (1); 1596824c205fSml return (0); 1597824c205fSml } 1598824c205fSml 1599824c205fSml static rctl_ops_t zone_msgmni_ops = { 1600824c205fSml rcop_no_action, 160108c359e5SJerry Jelinek zone_msgmni_usage, 1602824c205fSml rcop_no_set, 1603824c205fSml zone_msgmni_test 1604824c205fSml }; 1605824c205fSml 1606c6939658Ssl /*ARGSUSED*/ 1607c6939658Ssl static rctl_qty_t 1608c6939658Ssl zone_locked_mem_usage(rctl_t *rctl, struct proc *p) 1609c6939658Ssl { 1610c6939658Ssl rctl_qty_t q; 1611c6939658Ssl ASSERT(MUTEX_HELD(&p->p_lock)); 16120209230bSgjelinek mutex_enter(&p->p_zone->zone_mem_lock); 1613c6939658Ssl q = p->p_zone->zone_locked_mem; 16140209230bSgjelinek mutex_exit(&p->p_zone->zone_mem_lock); 1615c6939658Ssl return (q); 1616c6939658Ssl } 1617c6939658Ssl 1618c6939658Ssl /*ARGSUSED*/ 1619c6939658Ssl static int 1620c6939658Ssl zone_locked_mem_test(rctl_t *r, proc_t *p, rctl_entity_p_t *e, 1621c6939658Ssl rctl_val_t *rcntl, rctl_qty_t incr, uint_t flags) 1622c6939658Ssl { 1623c6939658Ssl rctl_qty_t q; 16240209230bSgjelinek zone_t *z; 16250209230bSgjelinek 16260209230bSgjelinek z = e->rcep_p.zone; 1627c6939658Ssl ASSERT(MUTEX_HELD(&p->p_lock)); 16280209230bSgjelinek ASSERT(MUTEX_HELD(&z->zone_mem_lock)); 16290209230bSgjelinek q = z->zone_locked_mem; 1630c6939658Ssl if (q + incr > rcntl->rcv_value) 1631c6939658Ssl return (1); 1632c6939658Ssl return (0); 1633c6939658Ssl } 1634c6939658Ssl 1635c6939658Ssl /*ARGSUSED*/ 1636c6939658Ssl static int 1637c6939658Ssl zone_locked_mem_set(rctl_t *rctl, struct proc *p, rctl_entity_p_t *e, 1638c6939658Ssl rctl_qty_t nv) 1639c6939658Ssl { 1640c6939658Ssl ASSERT(MUTEX_HELD(&p->p_lock)); 1641c6939658Ssl ASSERT(e->rcep_t == RCENTITY_ZONE); 1642c6939658Ssl if (e->rcep_p.zone == NULL) 1643c6939658Ssl return (0); 1644c6939658Ssl e->rcep_p.zone->zone_locked_mem_ctl = nv; 1645c6939658Ssl return (0); 1646c6939658Ssl } 1647c6939658Ssl 1648c6939658Ssl static rctl_ops_t zone_locked_mem_ops = { 1649c6939658Ssl rcop_no_action, 1650c6939658Ssl zone_locked_mem_usage, 1651c6939658Ssl zone_locked_mem_set, 1652c6939658Ssl zone_locked_mem_test 1653c6939658Ssl }; 1654824c205fSml 16550209230bSgjelinek /*ARGSUSED*/ 16560209230bSgjelinek static rctl_qty_t 16570209230bSgjelinek zone_max_swap_usage(rctl_t *rctl, struct proc *p) 16580209230bSgjelinek { 16590209230bSgjelinek rctl_qty_t q; 16600209230bSgjelinek zone_t *z = p->p_zone; 16610209230bSgjelinek 16620209230bSgjelinek ASSERT(MUTEX_HELD(&p->p_lock)); 16630209230bSgjelinek mutex_enter(&z->zone_mem_lock); 16640209230bSgjelinek q = z->zone_max_swap; 16650209230bSgjelinek mutex_exit(&z->zone_mem_lock); 16660209230bSgjelinek return (q); 16670209230bSgjelinek } 16680209230bSgjelinek 16690209230bSgjelinek /*ARGSUSED*/ 16700209230bSgjelinek static int 16710209230bSgjelinek zone_max_swap_test(rctl_t *r, proc_t *p, rctl_entity_p_t *e, 16720209230bSgjelinek rctl_val_t *rcntl, rctl_qty_t incr, uint_t flags) 16730209230bSgjelinek { 16740209230bSgjelinek rctl_qty_t q; 16750209230bSgjelinek zone_t *z; 16760209230bSgjelinek 16770209230bSgjelinek z = e->rcep_p.zone; 16780209230bSgjelinek ASSERT(MUTEX_HELD(&p->p_lock)); 16790209230bSgjelinek ASSERT(MUTEX_HELD(&z->zone_mem_lock)); 16800209230bSgjelinek q = z->zone_max_swap; 16810209230bSgjelinek if (q + incr > rcntl->rcv_value) 16820209230bSgjelinek return (1); 16830209230bSgjelinek return (0); 16840209230bSgjelinek } 16850209230bSgjelinek 16860209230bSgjelinek /*ARGSUSED*/ 16870209230bSgjelinek static int 16880209230bSgjelinek zone_max_swap_set(rctl_t *rctl, struct proc *p, rctl_entity_p_t *e, 16890209230bSgjelinek rctl_qty_t nv) 16900209230bSgjelinek { 16910209230bSgjelinek ASSERT(MUTEX_HELD(&p->p_lock)); 16920209230bSgjelinek ASSERT(e->rcep_t == RCENTITY_ZONE); 16930209230bSgjelinek if (e->rcep_p.zone == NULL) 16940209230bSgjelinek return (0); 16950209230bSgjelinek e->rcep_p.zone->zone_max_swap_ctl = nv; 16960209230bSgjelinek return (0); 16970209230bSgjelinek } 16980209230bSgjelinek 16990209230bSgjelinek static rctl_ops_t zone_max_swap_ops = { 17000209230bSgjelinek rcop_no_action, 17010209230bSgjelinek zone_max_swap_usage, 17020209230bSgjelinek zone_max_swap_set, 17030209230bSgjelinek zone_max_swap_test 17040209230bSgjelinek }; 17050209230bSgjelinek 17060fbb751dSJohn Levon /*ARGSUSED*/ 17070fbb751dSJohn Levon static rctl_qty_t 17080fbb751dSJohn Levon zone_max_lofi_usage(rctl_t *rctl, struct proc *p) 17090fbb751dSJohn Levon { 17100fbb751dSJohn Levon rctl_qty_t q; 17110fbb751dSJohn Levon zone_t *z = p->p_zone; 17120fbb751dSJohn Levon 17130fbb751dSJohn Levon ASSERT(MUTEX_HELD(&p->p_lock)); 17140fbb751dSJohn Levon mutex_enter(&z->zone_rctl_lock); 17150fbb751dSJohn Levon q = z->zone_max_lofi; 17160fbb751dSJohn Levon mutex_exit(&z->zone_rctl_lock); 17170fbb751dSJohn Levon return (q); 17180fbb751dSJohn Levon } 17190fbb751dSJohn Levon 17200fbb751dSJohn Levon /*ARGSUSED*/ 17210fbb751dSJohn Levon static int 17220fbb751dSJohn Levon zone_max_lofi_test(rctl_t *r, proc_t *p, rctl_entity_p_t *e, 17230fbb751dSJohn Levon rctl_val_t *rcntl, rctl_qty_t incr, uint_t flags) 17240fbb751dSJohn Levon { 17250fbb751dSJohn Levon rctl_qty_t q; 17260fbb751dSJohn Levon zone_t *z; 17270fbb751dSJohn Levon 17280fbb751dSJohn Levon z = e->rcep_p.zone; 17290fbb751dSJohn Levon ASSERT(MUTEX_HELD(&p->p_lock)); 17300fbb751dSJohn Levon ASSERT(MUTEX_HELD(&z->zone_rctl_lock)); 17310fbb751dSJohn Levon q = z->zone_max_lofi; 17320fbb751dSJohn Levon if (q + incr > rcntl->rcv_value) 17330fbb751dSJohn Levon return (1); 17340fbb751dSJohn Levon return (0); 17350fbb751dSJohn Levon } 17360fbb751dSJohn Levon 17370fbb751dSJohn Levon /*ARGSUSED*/ 17380fbb751dSJohn Levon static int 17390fbb751dSJohn Levon zone_max_lofi_set(rctl_t *rctl, struct proc *p, rctl_entity_p_t *e, 17400fbb751dSJohn Levon rctl_qty_t nv) 17410fbb751dSJohn Levon { 17420fbb751dSJohn Levon ASSERT(MUTEX_HELD(&p->p_lock)); 17430fbb751dSJohn Levon ASSERT(e->rcep_t == RCENTITY_ZONE); 17440fbb751dSJohn Levon if (e->rcep_p.zone == NULL) 17450fbb751dSJohn Levon return (0); 17460fbb751dSJohn Levon e->rcep_p.zone->zone_max_lofi_ctl = nv; 17470fbb751dSJohn Levon return (0); 17480fbb751dSJohn Levon } 17490fbb751dSJohn Levon 17500fbb751dSJohn Levon static rctl_ops_t zone_max_lofi_ops = { 17510fbb751dSJohn Levon rcop_no_action, 17520fbb751dSJohn Levon zone_max_lofi_usage, 17530fbb751dSJohn Levon zone_max_lofi_set, 17540fbb751dSJohn Levon zone_max_lofi_test 17550fbb751dSJohn Levon }; 17560fbb751dSJohn Levon 17577c478bd9Sstevel@tonic-gate /* 17587c478bd9Sstevel@tonic-gate * Helper function to brand the zone with a unique ID. 17597c478bd9Sstevel@tonic-gate */ 17607c478bd9Sstevel@tonic-gate static void 17617c478bd9Sstevel@tonic-gate zone_uniqid(zone_t *zone) 17627c478bd9Sstevel@tonic-gate { 17637c478bd9Sstevel@tonic-gate static uint64_t uniqid = 0; 17647c478bd9Sstevel@tonic-gate 17657c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&zonehash_lock)); 17667c478bd9Sstevel@tonic-gate zone->zone_uniqid = uniqid++; 17677c478bd9Sstevel@tonic-gate } 17687c478bd9Sstevel@tonic-gate 17697c478bd9Sstevel@tonic-gate /* 17707c478bd9Sstevel@tonic-gate * Returns a held pointer to the "kcred" for the specified zone. 17717c478bd9Sstevel@tonic-gate */ 17727c478bd9Sstevel@tonic-gate struct cred * 17737c478bd9Sstevel@tonic-gate zone_get_kcred(zoneid_t zoneid) 17747c478bd9Sstevel@tonic-gate { 17757c478bd9Sstevel@tonic-gate zone_t *zone; 17767c478bd9Sstevel@tonic-gate cred_t *cr; 17777c478bd9Sstevel@tonic-gate 17787c478bd9Sstevel@tonic-gate if ((zone = zone_find_by_id(zoneid)) == NULL) 17797c478bd9Sstevel@tonic-gate return (NULL); 17807c478bd9Sstevel@tonic-gate cr = zone->zone_kcred; 17817c478bd9Sstevel@tonic-gate crhold(cr); 17827c478bd9Sstevel@tonic-gate zone_rele(zone); 17837c478bd9Sstevel@tonic-gate return (cr); 17847c478bd9Sstevel@tonic-gate } 17857c478bd9Sstevel@tonic-gate 17860209230bSgjelinek static int 17870209230bSgjelinek zone_lockedmem_kstat_update(kstat_t *ksp, int rw) 17880209230bSgjelinek { 17890209230bSgjelinek zone_t *zone = ksp->ks_private; 17900209230bSgjelinek zone_kstat_t *zk = ksp->ks_data; 17910209230bSgjelinek 17920209230bSgjelinek if (rw == KSTAT_WRITE) 17930209230bSgjelinek return (EACCES); 17940209230bSgjelinek 17950209230bSgjelinek zk->zk_usage.value.ui64 = zone->zone_locked_mem; 17960209230bSgjelinek zk->zk_value.value.ui64 = zone->zone_locked_mem_ctl; 17970209230bSgjelinek return (0); 17980209230bSgjelinek } 17990209230bSgjelinek 1800ff19e029SMenno Lageman static int 1801ff19e029SMenno Lageman zone_nprocs_kstat_update(kstat_t *ksp, int rw) 1802ff19e029SMenno Lageman { 1803ff19e029SMenno Lageman zone_t *zone = ksp->ks_private; 1804ff19e029SMenno Lageman zone_kstat_t *zk = ksp->ks_data; 1805ff19e029SMenno Lageman 1806ff19e029SMenno Lageman if (rw == KSTAT_WRITE) 1807ff19e029SMenno Lageman return (EACCES); 1808ff19e029SMenno Lageman 1809ff19e029SMenno Lageman zk->zk_usage.value.ui64 = zone->zone_nprocs; 1810ff19e029SMenno Lageman zk->zk_value.value.ui64 = zone->zone_nprocs_ctl; 1811ff19e029SMenno Lageman return (0); 1812ff19e029SMenno Lageman } 1813ff19e029SMenno Lageman 18140209230bSgjelinek static int 18150209230bSgjelinek zone_swapresv_kstat_update(kstat_t *ksp, int rw) 18160209230bSgjelinek { 18170209230bSgjelinek zone_t *zone = ksp->ks_private; 18180209230bSgjelinek zone_kstat_t *zk = ksp->ks_data; 18190209230bSgjelinek 18200209230bSgjelinek if (rw == KSTAT_WRITE) 18210209230bSgjelinek return (EACCES); 18220209230bSgjelinek 18230209230bSgjelinek zk->zk_usage.value.ui64 = zone->zone_max_swap; 18240209230bSgjelinek zk->zk_value.value.ui64 = zone->zone_max_swap_ctl; 18250209230bSgjelinek return (0); 18260209230bSgjelinek } 18270209230bSgjelinek 1828ff19e029SMenno Lageman static kstat_t * 1829ff19e029SMenno Lageman zone_kstat_create_common(zone_t *zone, char *name, 1830ff19e029SMenno Lageman int (*updatefunc) (kstat_t *, int)) 18310209230bSgjelinek { 18320209230bSgjelinek kstat_t *ksp; 18330209230bSgjelinek zone_kstat_t *zk; 18340209230bSgjelinek 1835ff19e029SMenno Lageman ksp = rctl_kstat_create_zone(zone, name, KSTAT_TYPE_NAMED, 18360209230bSgjelinek sizeof (zone_kstat_t) / sizeof (kstat_named_t), 18370209230bSgjelinek KSTAT_FLAG_VIRTUAL); 18380209230bSgjelinek 18390209230bSgjelinek if (ksp == NULL) 1840ff19e029SMenno Lageman return (NULL); 18410209230bSgjelinek 18420209230bSgjelinek zk = ksp->ks_data = kmem_alloc(sizeof (zone_kstat_t), KM_SLEEP); 18430209230bSgjelinek ksp->ks_data_size += strlen(zone->zone_name) + 1; 18440209230bSgjelinek kstat_named_init(&zk->zk_zonename, "zonename", KSTAT_DATA_STRING); 18450209230bSgjelinek kstat_named_setstr(&zk->zk_zonename, zone->zone_name); 18460209230bSgjelinek kstat_named_init(&zk->zk_usage, "usage", KSTAT_DATA_UINT64); 18470209230bSgjelinek kstat_named_init(&zk->zk_value, "value", KSTAT_DATA_UINT64); 1848ff19e029SMenno Lageman ksp->ks_update = updatefunc; 18490209230bSgjelinek ksp->ks_private = zone; 18500209230bSgjelinek kstat_install(ksp); 1851ff19e029SMenno Lageman return (ksp); 1852ff19e029SMenno Lageman } 18530209230bSgjelinek 18549468939eSJerry Jelinek 18559468939eSJerry Jelinek static int 18569468939eSJerry Jelinek zone_mcap_kstat_update(kstat_t *ksp, int rw) 18579468939eSJerry Jelinek { 18589468939eSJerry Jelinek zone_t *zone = ksp->ks_private; 18599468939eSJerry Jelinek zone_mcap_kstat_t *zmp = ksp->ks_data; 18609468939eSJerry Jelinek 18619468939eSJerry Jelinek if (rw == KSTAT_WRITE) 18629468939eSJerry Jelinek return (EACCES); 18639468939eSJerry Jelinek 18649468939eSJerry Jelinek zmp->zm_pgpgin.value.ui64 = zone->zone_pgpgin; 18659468939eSJerry Jelinek zmp->zm_anonpgin.value.ui64 = zone->zone_anonpgin; 18669468939eSJerry Jelinek zmp->zm_execpgin.value.ui64 = zone->zone_execpgin; 18679468939eSJerry Jelinek zmp->zm_fspgin.value.ui64 = zone->zone_fspgin; 1868d14b1d19SJerry Jelinek zmp->zm_anon_alloc_fail.value.ui64 = zone->zone_anon_alloc_fail; 18699468939eSJerry Jelinek 18709468939eSJerry Jelinek return (0); 18719468939eSJerry Jelinek } 18729468939eSJerry Jelinek 18739468939eSJerry Jelinek static kstat_t * 18749468939eSJerry Jelinek zone_mcap_kstat_create(zone_t *zone) 18759468939eSJerry Jelinek { 18769468939eSJerry Jelinek kstat_t *ksp; 18779468939eSJerry Jelinek zone_mcap_kstat_t *zmp; 18789468939eSJerry Jelinek 18799468939eSJerry Jelinek if ((ksp = kstat_create_zone("memory_cap", zone->zone_id, 18809468939eSJerry Jelinek zone->zone_name, "zone_memory_cap", KSTAT_TYPE_NAMED, 18819468939eSJerry Jelinek sizeof (zone_mcap_kstat_t) / sizeof (kstat_named_t), 18829468939eSJerry Jelinek KSTAT_FLAG_VIRTUAL, zone->zone_id)) == NULL) 18839468939eSJerry Jelinek return (NULL); 18849468939eSJerry Jelinek 18859468939eSJerry Jelinek if (zone->zone_id != GLOBAL_ZONEID) 18869468939eSJerry Jelinek kstat_zone_add(ksp, GLOBAL_ZONEID); 18879468939eSJerry Jelinek 18889468939eSJerry Jelinek zmp = ksp->ks_data = kmem_zalloc(sizeof (zone_mcap_kstat_t), KM_SLEEP); 18899468939eSJerry Jelinek ksp->ks_data_size += strlen(zone->zone_name) + 1; 18909468939eSJerry Jelinek ksp->ks_lock = &zone->zone_mcap_lock; 18919468939eSJerry Jelinek zone->zone_mcap_stats = zmp; 18929468939eSJerry Jelinek 18939468939eSJerry Jelinek /* The kstat "name" field is not large enough for a full zonename */ 18949468939eSJerry Jelinek kstat_named_init(&zmp->zm_zonename, "zonename", KSTAT_DATA_STRING); 18959468939eSJerry Jelinek kstat_named_setstr(&zmp->zm_zonename, zone->zone_name); 18969468939eSJerry Jelinek kstat_named_init(&zmp->zm_pgpgin, "pgpgin", KSTAT_DATA_UINT64); 18979468939eSJerry Jelinek kstat_named_init(&zmp->zm_anonpgin, "anonpgin", KSTAT_DATA_UINT64); 18989468939eSJerry Jelinek kstat_named_init(&zmp->zm_execpgin, "execpgin", KSTAT_DATA_UINT64); 18999468939eSJerry Jelinek kstat_named_init(&zmp->zm_fspgin, "fspgin", KSTAT_DATA_UINT64); 1900d14b1d19SJerry Jelinek kstat_named_init(&zmp->zm_anon_alloc_fail, "anon_alloc_fail", 1901d14b1d19SJerry Jelinek KSTAT_DATA_UINT64); 19029468939eSJerry Jelinek 19039468939eSJerry Jelinek ksp->ks_update = zone_mcap_kstat_update; 19049468939eSJerry Jelinek ksp->ks_private = zone; 19059468939eSJerry Jelinek 19069468939eSJerry Jelinek kstat_install(ksp); 19079468939eSJerry Jelinek return (ksp); 19089468939eSJerry Jelinek } 19099468939eSJerry Jelinek 1910542a813cSJerry Jelinek static int 1911542a813cSJerry Jelinek zone_misc_kstat_update(kstat_t *ksp, int rw) 1912542a813cSJerry Jelinek { 1913542a813cSJerry Jelinek zone_t *zone = ksp->ks_private; 1914542a813cSJerry Jelinek zone_misc_kstat_t *zmp = ksp->ks_data; 1915542a813cSJerry Jelinek hrtime_t tmp; 1916542a813cSJerry Jelinek 1917542a813cSJerry Jelinek if (rw == KSTAT_WRITE) 1918542a813cSJerry Jelinek return (EACCES); 1919542a813cSJerry Jelinek 1920542a813cSJerry Jelinek tmp = zone->zone_utime; 1921542a813cSJerry Jelinek scalehrtime(&tmp); 1922542a813cSJerry Jelinek zmp->zm_utime.value.ui64 = tmp; 1923542a813cSJerry Jelinek tmp = zone->zone_stime; 1924542a813cSJerry Jelinek scalehrtime(&tmp); 1925542a813cSJerry Jelinek zmp->zm_stime.value.ui64 = tmp; 1926542a813cSJerry Jelinek tmp = zone->zone_wtime; 1927542a813cSJerry Jelinek scalehrtime(&tmp); 1928542a813cSJerry Jelinek zmp->zm_wtime.value.ui64 = tmp; 1929542a813cSJerry Jelinek 193081d43577SJerry Jelinek zmp->zm_avenrun1.value.ui32 = zone->zone_avenrun[0]; 193181d43577SJerry Jelinek zmp->zm_avenrun5.value.ui32 = zone->zone_avenrun[1]; 193281d43577SJerry Jelinek zmp->zm_avenrun15.value.ui32 = zone->zone_avenrun[2]; 193381d43577SJerry Jelinek 19342dc692e0SJerry Jelinek zmp->zm_ffcap.value.ui32 = zone->zone_ffcap; 19352dc692e0SJerry Jelinek zmp->zm_ffnoproc.value.ui32 = zone->zone_ffnoproc; 19362dc692e0SJerry Jelinek zmp->zm_ffnomem.value.ui32 = zone->zone_ffnomem; 19372dc692e0SJerry Jelinek zmp->zm_ffmisc.value.ui32 = zone->zone_ffmisc; 19382dc692e0SJerry Jelinek 193993cf283aSJerry Jelinek zmp->zm_nested_intp.value.ui32 = zone->zone_nested_intp; 194093cf283aSJerry Jelinek 1941a48d8120SJerry Jelinek zmp->zm_init_pid.value.ui32 = zone->zone_proc_initpid; 1942a48d8120SJerry Jelinek zmp->zm_boot_time.value.ui64 = (uint64_t)zone->zone_boot_time; 1943a48d8120SJerry Jelinek 1944542a813cSJerry Jelinek return (0); 1945542a813cSJerry Jelinek } 1946542a813cSJerry Jelinek 1947542a813cSJerry Jelinek static kstat_t * 1948542a813cSJerry Jelinek zone_misc_kstat_create(zone_t *zone) 1949542a813cSJerry Jelinek { 1950542a813cSJerry Jelinek kstat_t *ksp; 1951542a813cSJerry Jelinek zone_misc_kstat_t *zmp; 1952542a813cSJerry Jelinek 1953542a813cSJerry Jelinek if ((ksp = kstat_create_zone("zones", zone->zone_id, 1954542a813cSJerry Jelinek zone->zone_name, "zone_misc", KSTAT_TYPE_NAMED, 1955542a813cSJerry Jelinek sizeof (zone_misc_kstat_t) / sizeof (kstat_named_t), 1956542a813cSJerry Jelinek KSTAT_FLAG_VIRTUAL, zone->zone_id)) == NULL) 1957542a813cSJerry Jelinek return (NULL); 1958542a813cSJerry Jelinek 1959542a813cSJerry Jelinek if (zone->zone_id != GLOBAL_ZONEID) 1960542a813cSJerry Jelinek kstat_zone_add(ksp, GLOBAL_ZONEID); 1961542a813cSJerry Jelinek 1962542a813cSJerry Jelinek zmp = ksp->ks_data = kmem_zalloc(sizeof (zone_misc_kstat_t), KM_SLEEP); 1963542a813cSJerry Jelinek ksp->ks_data_size += strlen(zone->zone_name) + 1; 1964542a813cSJerry Jelinek ksp->ks_lock = &zone->zone_misc_lock; 1965542a813cSJerry Jelinek zone->zone_misc_stats = zmp; 1966542a813cSJerry Jelinek 1967542a813cSJerry Jelinek /* The kstat "name" field is not large enough for a full zonename */ 1968542a813cSJerry Jelinek kstat_named_init(&zmp->zm_zonename, "zonename", KSTAT_DATA_STRING); 1969542a813cSJerry Jelinek kstat_named_setstr(&zmp->zm_zonename, zone->zone_name); 1970542a813cSJerry Jelinek kstat_named_init(&zmp->zm_utime, "nsec_user", KSTAT_DATA_UINT64); 1971542a813cSJerry Jelinek kstat_named_init(&zmp->zm_stime, "nsec_sys", KSTAT_DATA_UINT64); 1972542a813cSJerry Jelinek kstat_named_init(&zmp->zm_wtime, "nsec_waitrq", KSTAT_DATA_UINT64); 197381d43577SJerry Jelinek kstat_named_init(&zmp->zm_avenrun1, "avenrun_1min", KSTAT_DATA_UINT32); 197481d43577SJerry Jelinek kstat_named_init(&zmp->zm_avenrun5, "avenrun_5min", KSTAT_DATA_UINT32); 197581d43577SJerry Jelinek kstat_named_init(&zmp->zm_avenrun15, "avenrun_15min", 197681d43577SJerry Jelinek KSTAT_DATA_UINT32); 19772dc692e0SJerry Jelinek kstat_named_init(&zmp->zm_ffcap, "forkfail_cap", KSTAT_DATA_UINT32); 19782dc692e0SJerry Jelinek kstat_named_init(&zmp->zm_ffnoproc, "forkfail_noproc", 19792dc692e0SJerry Jelinek KSTAT_DATA_UINT32); 19802dc692e0SJerry Jelinek kstat_named_init(&zmp->zm_ffnomem, "forkfail_nomem", KSTAT_DATA_UINT32); 19812dc692e0SJerry Jelinek kstat_named_init(&zmp->zm_ffmisc, "forkfail_misc", KSTAT_DATA_UINT32); 198293cf283aSJerry Jelinek kstat_named_init(&zmp->zm_nested_intp, "nested_interp", 198393cf283aSJerry Jelinek KSTAT_DATA_UINT32); 1984a48d8120SJerry Jelinek kstat_named_init(&zmp->zm_init_pid, "init_pid", KSTAT_DATA_UINT32); 1985a48d8120SJerry Jelinek kstat_named_init(&zmp->zm_boot_time, "boot_time", KSTAT_DATA_UINT64); 1986542a813cSJerry Jelinek 1987542a813cSJerry Jelinek ksp->ks_update = zone_misc_kstat_update; 1988542a813cSJerry Jelinek ksp->ks_private = zone; 1989542a813cSJerry Jelinek 1990542a813cSJerry Jelinek kstat_install(ksp); 1991542a813cSJerry Jelinek return (ksp); 1992542a813cSJerry Jelinek } 1993542a813cSJerry Jelinek 1994ff19e029SMenno Lageman static void 1995ff19e029SMenno Lageman zone_kstat_create(zone_t *zone) 1996ff19e029SMenno Lageman { 1997ff19e029SMenno Lageman zone->zone_lockedmem_kstat = zone_kstat_create_common(zone, 1998ff19e029SMenno Lageman "lockedmem", zone_lockedmem_kstat_update); 1999ff19e029SMenno Lageman zone->zone_swapresv_kstat = zone_kstat_create_common(zone, 2000ff19e029SMenno Lageman "swapresv", zone_swapresv_kstat_update); 2001ff19e029SMenno Lageman zone->zone_nprocs_kstat = zone_kstat_create_common(zone, 2002ff19e029SMenno Lageman "nprocs", zone_nprocs_kstat_update); 2003542a813cSJerry Jelinek 20049468939eSJerry Jelinek if ((zone->zone_mcap_ksp = zone_mcap_kstat_create(zone)) == NULL) { 20059468939eSJerry Jelinek zone->zone_mcap_stats = kmem_zalloc( 20069468939eSJerry Jelinek sizeof (zone_mcap_kstat_t), KM_SLEEP); 20079468939eSJerry Jelinek } 20089468939eSJerry Jelinek 2009542a813cSJerry Jelinek if ((zone->zone_misc_ksp = zone_misc_kstat_create(zone)) == NULL) { 2010542a813cSJerry Jelinek zone->zone_misc_stats = kmem_zalloc( 2011542a813cSJerry Jelinek sizeof (zone_misc_kstat_t), KM_SLEEP); 2012542a813cSJerry Jelinek } 20130209230bSgjelinek } 20140209230bSgjelinek 20150209230bSgjelinek static void 2016542a813cSJerry Jelinek zone_kstat_delete_common(kstat_t **pkstat, size_t datasz) 20170209230bSgjelinek { 20180209230bSgjelinek void *data; 20190209230bSgjelinek 2020ff19e029SMenno Lageman if (*pkstat != NULL) { 2021ff19e029SMenno Lageman data = (*pkstat)->ks_data; 2022ff19e029SMenno Lageman kstat_delete(*pkstat); 2023542a813cSJerry Jelinek kmem_free(data, datasz); 2024ff19e029SMenno Lageman *pkstat = NULL; 20250209230bSgjelinek } 20260209230bSgjelinek } 20270209230bSgjelinek 2028ff19e029SMenno Lageman static void 2029ff19e029SMenno Lageman zone_kstat_delete(zone_t *zone) 2030ff19e029SMenno Lageman { 2031542a813cSJerry Jelinek zone_kstat_delete_common(&zone->zone_lockedmem_kstat, 2032542a813cSJerry Jelinek sizeof (zone_kstat_t)); 2033542a813cSJerry Jelinek zone_kstat_delete_common(&zone->zone_swapresv_kstat, 2034542a813cSJerry Jelinek sizeof (zone_kstat_t)); 2035542a813cSJerry Jelinek zone_kstat_delete_common(&zone->zone_nprocs_kstat, 2036542a813cSJerry Jelinek sizeof (zone_kstat_t)); 20379468939eSJerry Jelinek zone_kstat_delete_common(&zone->zone_mcap_ksp, 20389468939eSJerry Jelinek sizeof (zone_mcap_kstat_t)); 2039542a813cSJerry Jelinek zone_kstat_delete_common(&zone->zone_misc_ksp, 2040542a813cSJerry Jelinek sizeof (zone_misc_kstat_t)); 2041ff19e029SMenno Lageman } 2042ff19e029SMenno Lageman 20437c478bd9Sstevel@tonic-gate /* 20447c478bd9Sstevel@tonic-gate * Called very early on in boot to initialize the ZSD list so that 20457c478bd9Sstevel@tonic-gate * zone_key_create() can be called before zone_init(). It also initializes 20467c478bd9Sstevel@tonic-gate * portions of zone0 which may be used before zone_init() is called. The 20477c478bd9Sstevel@tonic-gate * variable "global_zone" will be set when zone0 is fully initialized by 20487c478bd9Sstevel@tonic-gate * zone_init(). 20497c478bd9Sstevel@tonic-gate */ 20507c478bd9Sstevel@tonic-gate void 20517c478bd9Sstevel@tonic-gate zone_zsd_init(void) 20527c478bd9Sstevel@tonic-gate { 20537c478bd9Sstevel@tonic-gate mutex_init(&zonehash_lock, NULL, MUTEX_DEFAULT, NULL); 20547c478bd9Sstevel@tonic-gate mutex_init(&zsd_key_lock, NULL, MUTEX_DEFAULT, NULL); 20557c478bd9Sstevel@tonic-gate list_create(&zsd_registered_keys, sizeof (struct zsd_entry), 20567c478bd9Sstevel@tonic-gate offsetof(struct zsd_entry, zsd_linkage)); 20577c478bd9Sstevel@tonic-gate list_create(&zone_active, sizeof (zone_t), 20587c478bd9Sstevel@tonic-gate offsetof(zone_t, zone_linkage)); 20597c478bd9Sstevel@tonic-gate list_create(&zone_deathrow, sizeof (zone_t), 20607c478bd9Sstevel@tonic-gate offsetof(zone_t, zone_linkage)); 20617c478bd9Sstevel@tonic-gate 20627c478bd9Sstevel@tonic-gate mutex_init(&zone0.zone_lock, NULL, MUTEX_DEFAULT, NULL); 20637c478bd9Sstevel@tonic-gate mutex_init(&zone0.zone_nlwps_lock, NULL, MUTEX_DEFAULT, NULL); 20640209230bSgjelinek mutex_init(&zone0.zone_mem_lock, NULL, MUTEX_DEFAULT, NULL); 20657c478bd9Sstevel@tonic-gate zone0.zone_shares = 1; 20660209230bSgjelinek zone0.zone_nlwps = 0; 20677c478bd9Sstevel@tonic-gate zone0.zone_nlwps_ctl = INT_MAX; 2068ff19e029SMenno Lageman zone0.zone_nprocs = 0; 2069ff19e029SMenno Lageman zone0.zone_nprocs_ctl = INT_MAX; 20700209230bSgjelinek zone0.zone_locked_mem = 0; 20710209230bSgjelinek zone0.zone_locked_mem_ctl = UINT64_MAX; 20720209230bSgjelinek ASSERT(zone0.zone_max_swap == 0); 20730209230bSgjelinek zone0.zone_max_swap_ctl = UINT64_MAX; 20740fbb751dSJohn Levon zone0.zone_max_lofi = 0; 20750fbb751dSJohn Levon zone0.zone_max_lofi_ctl = UINT64_MAX; 2076824c205fSml zone0.zone_shmmax = 0; 2077824c205fSml zone0.zone_ipc.ipcq_shmmni = 0; 2078824c205fSml zone0.zone_ipc.ipcq_semmni = 0; 2079824c205fSml zone0.zone_ipc.ipcq_msgmni = 0; 20807c478bd9Sstevel@tonic-gate zone0.zone_name = GLOBAL_ZONENAME; 20817c478bd9Sstevel@tonic-gate zone0.zone_nodename = utsname.nodename; 20827c478bd9Sstevel@tonic-gate zone0.zone_domain = srpc_domain; 20835679c89fSjv zone0.zone_hostid = HW_INVALID_HOSTID; 20840fbb751dSJohn Levon zone0.zone_fs_allowed = NULL; 2085d2a70789SRichard Lowe psecflags_default(&zone0.zone_secflags); 20867c478bd9Sstevel@tonic-gate zone0.zone_ref = 1; 20877c478bd9Sstevel@tonic-gate zone0.zone_id = GLOBAL_ZONEID; 20887c478bd9Sstevel@tonic-gate zone0.zone_status = ZONE_IS_RUNNING; 20897c478bd9Sstevel@tonic-gate zone0.zone_rootpath = "/"; 20907c478bd9Sstevel@tonic-gate zone0.zone_rootpathlen = 2; 20917c478bd9Sstevel@tonic-gate zone0.zone_psetid = ZONE_PS_INVAL; 20927c478bd9Sstevel@tonic-gate zone0.zone_ncpus = 0; 20937c478bd9Sstevel@tonic-gate zone0.zone_ncpus_online = 0; 20947c478bd9Sstevel@tonic-gate zone0.zone_proc_initpid = 1; 20953f2f09c1Sdp zone0.zone_initname = initname; 20960209230bSgjelinek zone0.zone_lockedmem_kstat = NULL; 20970209230bSgjelinek zone0.zone_swapresv_kstat = NULL; 2098ff19e029SMenno Lageman zone0.zone_nprocs_kstat = NULL; 2099542a813cSJerry Jelinek 2100542a813cSJerry Jelinek zone0.zone_stime = 0; 2101542a813cSJerry Jelinek zone0.zone_utime = 0; 2102542a813cSJerry Jelinek zone0.zone_wtime = 0; 2103542a813cSJerry Jelinek 2104a19609f8Sjv list_create(&zone0.zone_ref_list, sizeof (zone_ref_t), 2105a19609f8Sjv offsetof(zone_ref_t, zref_linkage)); 21067c478bd9Sstevel@tonic-gate list_create(&zone0.zone_zsd, sizeof (struct zsd_entry), 21077c478bd9Sstevel@tonic-gate offsetof(struct zsd_entry, zsd_linkage)); 21087c478bd9Sstevel@tonic-gate list_insert_head(&zone_active, &zone0); 21097c478bd9Sstevel@tonic-gate 21107c478bd9Sstevel@tonic-gate /* 21117c478bd9Sstevel@tonic-gate * The root filesystem is not mounted yet, so zone_rootvp cannot be set 21127c478bd9Sstevel@tonic-gate * to anything meaningful. It is assigned to be 'rootdir' in 21137c478bd9Sstevel@tonic-gate * vfs_mountroot(). 21147c478bd9Sstevel@tonic-gate */ 21157c478bd9Sstevel@tonic-gate zone0.zone_rootvp = NULL; 21167c478bd9Sstevel@tonic-gate zone0.zone_vfslist = NULL; 21173f2f09c1Sdp zone0.zone_bootargs = initargs; 21187c478bd9Sstevel@tonic-gate zone0.zone_privset = kmem_alloc(sizeof (priv_set_t), KM_SLEEP); 21197c478bd9Sstevel@tonic-gate /* 21207c478bd9Sstevel@tonic-gate * The global zone has all privileges 21217c478bd9Sstevel@tonic-gate */ 21227c478bd9Sstevel@tonic-gate priv_fillset(zone0.zone_privset); 21237c478bd9Sstevel@tonic-gate /* 21247c478bd9Sstevel@tonic-gate * Add p0 to the global zone 21257c478bd9Sstevel@tonic-gate */ 21267c478bd9Sstevel@tonic-gate zone0.zone_zsched = &p0; 21277c478bd9Sstevel@tonic-gate p0.p_zone = &zone0; 21287c478bd9Sstevel@tonic-gate } 21297c478bd9Sstevel@tonic-gate 213045916cd2Sjpk /* 213145916cd2Sjpk * Compute a hash value based on the contents of the label and the DOI. The 213245916cd2Sjpk * hash algorithm is somewhat arbitrary, but is based on the observation that 213345916cd2Sjpk * humans will likely pick labels that differ by amounts that work out to be 213445916cd2Sjpk * multiples of the number of hash chains, and thus stirring in some primes 213545916cd2Sjpk * should help. 213645916cd2Sjpk */ 213745916cd2Sjpk static uint_t 213845916cd2Sjpk hash_bylabel(void *hdata, mod_hash_key_t key) 213945916cd2Sjpk { 214045916cd2Sjpk const ts_label_t *lab = (ts_label_t *)key; 214145916cd2Sjpk const uint32_t *up, *ue; 214245916cd2Sjpk uint_t hash; 214345916cd2Sjpk int i; 214445916cd2Sjpk 214545916cd2Sjpk _NOTE(ARGUNUSED(hdata)); 214645916cd2Sjpk 214745916cd2Sjpk hash = lab->tsl_doi + (lab->tsl_doi << 1); 214845916cd2Sjpk /* we depend on alignment of label, but not representation */ 214945916cd2Sjpk up = (const uint32_t *)&lab->tsl_label; 215045916cd2Sjpk ue = up + sizeof (lab->tsl_label) / sizeof (*up); 215145916cd2Sjpk i = 1; 215245916cd2Sjpk while (up < ue) { 215345916cd2Sjpk /* using 2^n + 1, 1 <= n <= 16 as source of many primes */ 215445916cd2Sjpk hash += *up + (*up << ((i % 16) + 1)); 215545916cd2Sjpk up++; 215645916cd2Sjpk i++; 215745916cd2Sjpk } 215845916cd2Sjpk return (hash); 215945916cd2Sjpk } 216045916cd2Sjpk 216145916cd2Sjpk /* 216245916cd2Sjpk * All that mod_hash cares about here is zero (equal) versus non-zero (not 216345916cd2Sjpk * equal). This may need to be changed if less than / greater than is ever 216445916cd2Sjpk * needed. 216545916cd2Sjpk */ 216645916cd2Sjpk static int 216745916cd2Sjpk hash_labelkey_cmp(mod_hash_key_t key1, mod_hash_key_t key2) 216845916cd2Sjpk { 216945916cd2Sjpk ts_label_t *lab1 = (ts_label_t *)key1; 217045916cd2Sjpk ts_label_t *lab2 = (ts_label_t *)key2; 217145916cd2Sjpk 217245916cd2Sjpk return (label_equal(lab1, lab2) ? 0 : 1); 217345916cd2Sjpk } 217445916cd2Sjpk 21757c478bd9Sstevel@tonic-gate /* 21767c478bd9Sstevel@tonic-gate * Called by main() to initialize the zones framework. 21777c478bd9Sstevel@tonic-gate */ 21787c478bd9Sstevel@tonic-gate void 21797c478bd9Sstevel@tonic-gate zone_init(void) 21807c478bd9Sstevel@tonic-gate { 21817c478bd9Sstevel@tonic-gate rctl_dict_entry_t *rde; 21827c478bd9Sstevel@tonic-gate rctl_val_t *dval; 21837c478bd9Sstevel@tonic-gate rctl_set_t *set; 21847c478bd9Sstevel@tonic-gate rctl_alloc_gp_t *gp; 21857c478bd9Sstevel@tonic-gate rctl_entity_p_t e; 2186cf8f45c7Sdstaff int res; 21877c478bd9Sstevel@tonic-gate 21887c478bd9Sstevel@tonic-gate ASSERT(curproc == &p0); 21897c478bd9Sstevel@tonic-gate 21907c478bd9Sstevel@tonic-gate /* 21917c478bd9Sstevel@tonic-gate * Create ID space for zone IDs. ID 0 is reserved for the 21927c478bd9Sstevel@tonic-gate * global zone. 21937c478bd9Sstevel@tonic-gate */ 21947c478bd9Sstevel@tonic-gate zoneid_space = id_space_create("zoneid_space", 1, MAX_ZONEID); 21957c478bd9Sstevel@tonic-gate 21967c478bd9Sstevel@tonic-gate /* 21977c478bd9Sstevel@tonic-gate * Initialize generic zone resource controls, if any. 21987c478bd9Sstevel@tonic-gate */ 21997c478bd9Sstevel@tonic-gate rc_zone_cpu_shares = rctl_register("zone.cpu-shares", 22007c478bd9Sstevel@tonic-gate RCENTITY_ZONE, RCTL_GLOBAL_SIGNAL_NEVER | RCTL_GLOBAL_DENY_NEVER | 220119f92332Sml RCTL_GLOBAL_NOBASIC | RCTL_GLOBAL_COUNT | RCTL_GLOBAL_SYSLOG_NEVER, 2202c97ad5cdSakolb FSS_MAXSHARES, FSS_MAXSHARES, &zone_cpu_shares_ops); 2203c97ad5cdSakolb 2204c97ad5cdSakolb rc_zone_cpu_cap = rctl_register("zone.cpu-cap", 2205c97ad5cdSakolb RCENTITY_ZONE, RCTL_GLOBAL_SIGNAL_NEVER | RCTL_GLOBAL_DENY_ALWAYS | 2206c97ad5cdSakolb RCTL_GLOBAL_NOBASIC | RCTL_GLOBAL_COUNT |RCTL_GLOBAL_SYSLOG_NEVER | 2207c97ad5cdSakolb RCTL_GLOBAL_INFINITE, 2208c97ad5cdSakolb MAXCAP, MAXCAP, &zone_cpu_cap_ops); 22097c478bd9Sstevel@tonic-gate 22107c478bd9Sstevel@tonic-gate rc_zone_nlwps = rctl_register("zone.max-lwps", RCENTITY_ZONE, 22117c478bd9Sstevel@tonic-gate RCTL_GLOBAL_NOACTION | RCTL_GLOBAL_NOBASIC | RCTL_GLOBAL_COUNT, 22127c478bd9Sstevel@tonic-gate INT_MAX, INT_MAX, &zone_lwps_ops); 2213ff19e029SMenno Lageman 2214ff19e029SMenno Lageman rc_zone_nprocs = rctl_register("zone.max-processes", RCENTITY_ZONE, 2215ff19e029SMenno Lageman RCTL_GLOBAL_NOACTION | RCTL_GLOBAL_NOBASIC | RCTL_GLOBAL_COUNT, 2216ff19e029SMenno Lageman INT_MAX, INT_MAX, &zone_procs_ops); 2217ff19e029SMenno Lageman 2218824c205fSml /* 2219824c205fSml * System V IPC resource controls 2220824c205fSml */ 2221824c205fSml rc_zone_msgmni = rctl_register("zone.max-msg-ids", 2222824c205fSml RCENTITY_ZONE, RCTL_GLOBAL_DENY_ALWAYS | RCTL_GLOBAL_NOBASIC | 2223824c205fSml RCTL_GLOBAL_COUNT, IPC_IDS_MAX, IPC_IDS_MAX, &zone_msgmni_ops); 2224824c205fSml 2225824c205fSml rc_zone_semmni = rctl_register("zone.max-sem-ids", 2226824c205fSml RCENTITY_ZONE, RCTL_GLOBAL_DENY_ALWAYS | RCTL_GLOBAL_NOBASIC | 2227824c205fSml RCTL_GLOBAL_COUNT, IPC_IDS_MAX, IPC_IDS_MAX, &zone_semmni_ops); 2228824c205fSml 2229824c205fSml rc_zone_shmmni = rctl_register("zone.max-shm-ids", 2230824c205fSml RCENTITY_ZONE, RCTL_GLOBAL_DENY_ALWAYS | RCTL_GLOBAL_NOBASIC | 2231824c205fSml RCTL_GLOBAL_COUNT, IPC_IDS_MAX, IPC_IDS_MAX, &zone_shmmni_ops); 2232824c205fSml 2233824c205fSml rc_zone_shmmax = rctl_register("zone.max-shm-memory", 2234824c205fSml RCENTITY_ZONE, RCTL_GLOBAL_DENY_ALWAYS | RCTL_GLOBAL_NOBASIC | 2235824c205fSml RCTL_GLOBAL_BYTES, UINT64_MAX, UINT64_MAX, &zone_shmmax_ops); 2236824c205fSml 22377c478bd9Sstevel@tonic-gate /* 22387c478bd9Sstevel@tonic-gate * Create a rctl_val with PRIVILEGED, NOACTION, value = 1. Then attach 22397c478bd9Sstevel@tonic-gate * this at the head of the rctl_dict_entry for ``zone.cpu-shares''. 22407c478bd9Sstevel@tonic-gate */ 22417c478bd9Sstevel@tonic-gate dval = kmem_cache_alloc(rctl_val_cache, KM_SLEEP); 22427c478bd9Sstevel@tonic-gate bzero(dval, sizeof (rctl_val_t)); 22437c478bd9Sstevel@tonic-gate dval->rcv_value = 1; 22447c478bd9Sstevel@tonic-gate dval->rcv_privilege = RCPRIV_PRIVILEGED; 22457c478bd9Sstevel@tonic-gate dval->rcv_flagaction = RCTL_LOCAL_NOACTION; 22467c478bd9Sstevel@tonic-gate dval->rcv_action_recip_pid = -1; 22477c478bd9Sstevel@tonic-gate 22487c478bd9Sstevel@tonic-gate rde = rctl_dict_lookup("zone.cpu-shares"); 22497c478bd9Sstevel@tonic-gate (void) rctl_val_list_insert(&rde->rcd_default_value, dval); 22507c478bd9Sstevel@tonic-gate 2251c6939658Ssl rc_zone_locked_mem = rctl_register("zone.max-locked-memory", 2252c6939658Ssl RCENTITY_ZONE, RCTL_GLOBAL_NOBASIC | RCTL_GLOBAL_BYTES | 2253c6939658Ssl RCTL_GLOBAL_DENY_ALWAYS, UINT64_MAX, UINT64_MAX, 2254c6939658Ssl &zone_locked_mem_ops); 22550209230bSgjelinek 22560209230bSgjelinek rc_zone_max_swap = rctl_register("zone.max-swap", 22570209230bSgjelinek RCENTITY_ZONE, RCTL_GLOBAL_NOBASIC | RCTL_GLOBAL_BYTES | 22580209230bSgjelinek RCTL_GLOBAL_DENY_ALWAYS, UINT64_MAX, UINT64_MAX, 22590209230bSgjelinek &zone_max_swap_ops); 22600209230bSgjelinek 22610fbb751dSJohn Levon rc_zone_max_lofi = rctl_register("zone.max-lofi", 22620fbb751dSJohn Levon RCENTITY_ZONE, RCTL_GLOBAL_NOBASIC | RCTL_GLOBAL_COUNT | 22630fbb751dSJohn Levon RCTL_GLOBAL_DENY_ALWAYS, UINT64_MAX, UINT64_MAX, 22640fbb751dSJohn Levon &zone_max_lofi_ops); 22650fbb751dSJohn Levon 22667c478bd9Sstevel@tonic-gate /* 22677c478bd9Sstevel@tonic-gate * Initialize the ``global zone''. 22687c478bd9Sstevel@tonic-gate */ 22697c478bd9Sstevel@tonic-gate set = rctl_set_create(); 22707c478bd9Sstevel@tonic-gate gp = rctl_set_init_prealloc(RCENTITY_ZONE); 22717c478bd9Sstevel@tonic-gate mutex_enter(&p0.p_lock); 22727c478bd9Sstevel@tonic-gate e.rcep_p.zone = &zone0; 22737c478bd9Sstevel@tonic-gate e.rcep_t = RCENTITY_ZONE; 22747c478bd9Sstevel@tonic-gate zone0.zone_rctls = rctl_set_init(RCENTITY_ZONE, &p0, &e, set, 22757c478bd9Sstevel@tonic-gate gp); 22767c478bd9Sstevel@tonic-gate 22777c478bd9Sstevel@tonic-gate zone0.zone_nlwps = p0.p_lwpcnt; 2278ff19e029SMenno Lageman zone0.zone_nprocs = 1; 22797c478bd9Sstevel@tonic-gate zone0.zone_ntasks = 1; 22807c478bd9Sstevel@tonic-gate mutex_exit(&p0.p_lock); 22819acbbeafSnn zone0.zone_restart_init = B_TRUE; 22829acbbeafSnn zone0.zone_brand = &native_brand; 22837c478bd9Sstevel@tonic-gate rctl_prealloc_destroy(gp); 22847c478bd9Sstevel@tonic-gate /* 22850209230bSgjelinek * pool_default hasn't been initialized yet, so we let pool_init() 22860209230bSgjelinek * take care of making sure the global zone is in the default pool. 22870209230bSgjelinek */ 22880209230bSgjelinek 22890209230bSgjelinek /* 22900209230bSgjelinek * Initialize global zone kstats 22917c478bd9Sstevel@tonic-gate */ 22920209230bSgjelinek zone_kstat_create(&zone0); 229345916cd2Sjpk 229445916cd2Sjpk /* 229545916cd2Sjpk * Initialize zone label. 229645916cd2Sjpk * mlp are initialized when tnzonecfg is loaded. 229745916cd2Sjpk */ 229845916cd2Sjpk zone0.zone_slabel = l_admin_low; 229945916cd2Sjpk rw_init(&zone0.zone_mlps.mlpl_rwlock, NULL, RW_DEFAULT, NULL); 230045916cd2Sjpk label_hold(l_admin_low); 230145916cd2Sjpk 2302835ee219SRobert Harris /* 2303835ee219SRobert Harris * Initialise the lock for the database structure used by mntfs. 2304835ee219SRobert Harris */ 2305835ee219SRobert Harris rw_init(&zone0.zone_mntfs_db_lock, NULL, RW_DEFAULT, NULL); 2306835ee219SRobert Harris 23077c478bd9Sstevel@tonic-gate mutex_enter(&zonehash_lock); 23087c478bd9Sstevel@tonic-gate zone_uniqid(&zone0); 23097c478bd9Sstevel@tonic-gate ASSERT(zone0.zone_uniqid == GLOBAL_ZONEUNIQID); 231045916cd2Sjpk 23117c478bd9Sstevel@tonic-gate zonehashbyid = mod_hash_create_idhash("zone_by_id", zone_hash_size, 23127c478bd9Sstevel@tonic-gate mod_hash_null_valdtor); 23137c478bd9Sstevel@tonic-gate zonehashbyname = mod_hash_create_strhash("zone_by_name", 23147c478bd9Sstevel@tonic-gate zone_hash_size, mod_hash_null_valdtor); 231545916cd2Sjpk /* 231645916cd2Sjpk * maintain zonehashbylabel only for labeled systems 231745916cd2Sjpk */ 231845916cd2Sjpk if (is_system_labeled()) 231945916cd2Sjpk zonehashbylabel = mod_hash_create_extended("zone_by_label", 232045916cd2Sjpk zone_hash_size, mod_hash_null_keydtor, 232145916cd2Sjpk mod_hash_null_valdtor, hash_bylabel, NULL, 232245916cd2Sjpk hash_labelkey_cmp, KM_SLEEP); 23237c478bd9Sstevel@tonic-gate zonecount = 1; 23247c478bd9Sstevel@tonic-gate 23257c478bd9Sstevel@tonic-gate (void) mod_hash_insert(zonehashbyid, (mod_hash_key_t)GLOBAL_ZONEID, 23267c478bd9Sstevel@tonic-gate (mod_hash_val_t)&zone0); 23277c478bd9Sstevel@tonic-gate (void) mod_hash_insert(zonehashbyname, (mod_hash_key_t)zone0.zone_name, 23287c478bd9Sstevel@tonic-gate (mod_hash_val_t)&zone0); 232948451833Scarlsonj if (is_system_labeled()) { 233048451833Scarlsonj zone0.zone_flags |= ZF_HASHED_LABEL; 233145916cd2Sjpk (void) mod_hash_insert(zonehashbylabel, 233245916cd2Sjpk (mod_hash_key_t)zone0.zone_slabel, (mod_hash_val_t)&zone0); 233348451833Scarlsonj } 233445916cd2Sjpk mutex_exit(&zonehash_lock); 233545916cd2Sjpk 23367c478bd9Sstevel@tonic-gate /* 23377c478bd9Sstevel@tonic-gate * We avoid setting zone_kcred until now, since kcred is initialized 23387c478bd9Sstevel@tonic-gate * sometime after zone_zsd_init() and before zone_init(). 23397c478bd9Sstevel@tonic-gate */ 23407c478bd9Sstevel@tonic-gate zone0.zone_kcred = kcred; 23417c478bd9Sstevel@tonic-gate /* 23427c478bd9Sstevel@tonic-gate * The global zone is fully initialized (except for zone_rootvp which 23437c478bd9Sstevel@tonic-gate * will be set when the root filesystem is mounted). 23447c478bd9Sstevel@tonic-gate */ 23457c478bd9Sstevel@tonic-gate global_zone = &zone0; 2346cf8f45c7Sdstaff 2347cf8f45c7Sdstaff /* 2348cf8f45c7Sdstaff * Setup an event channel to send zone status change notifications on 2349cf8f45c7Sdstaff */ 2350cf8f45c7Sdstaff res = sysevent_evc_bind(ZONE_EVENT_CHANNEL, &zone_event_chan, 2351cf8f45c7Sdstaff EVCH_CREAT); 2352cf8f45c7Sdstaff 2353cf8f45c7Sdstaff if (res) 2354cf8f45c7Sdstaff panic("Sysevent_evc_bind failed during zone setup.\n"); 23550209230bSgjelinek 23567c478bd9Sstevel@tonic-gate } 23577c478bd9Sstevel@tonic-gate 23587c478bd9Sstevel@tonic-gate static void 23597c478bd9Sstevel@tonic-gate zone_free(zone_t *zone) 23607c478bd9Sstevel@tonic-gate { 23617c478bd9Sstevel@tonic-gate ASSERT(zone != global_zone); 23627c478bd9Sstevel@tonic-gate ASSERT(zone->zone_ntasks == 0); 23637c478bd9Sstevel@tonic-gate ASSERT(zone->zone_nlwps == 0); 2364ff19e029SMenno Lageman ASSERT(zone->zone_nprocs == 0); 23657c478bd9Sstevel@tonic-gate ASSERT(zone->zone_cred_ref == 0); 23667c478bd9Sstevel@tonic-gate ASSERT(zone->zone_kcred == NULL); 23677c478bd9Sstevel@tonic-gate ASSERT(zone_status_get(zone) == ZONE_IS_DEAD || 23687c478bd9Sstevel@tonic-gate zone_status_get(zone) == ZONE_IS_UNINITIALIZED); 2369a19609f8Sjv ASSERT(list_is_empty(&zone->zone_ref_list)); 23707c478bd9Sstevel@tonic-gate 2371c97ad5cdSakolb /* 2372c97ad5cdSakolb * Remove any zone caps. 2373c97ad5cdSakolb */ 2374c97ad5cdSakolb cpucaps_zone_remove(zone); 2375c97ad5cdSakolb 2376c97ad5cdSakolb ASSERT(zone->zone_cpucap == NULL); 2377c97ad5cdSakolb 23787c478bd9Sstevel@tonic-gate /* remove from deathrow list */ 23797c478bd9Sstevel@tonic-gate if (zone_status_get(zone) == ZONE_IS_DEAD) { 23807c478bd9Sstevel@tonic-gate ASSERT(zone->zone_ref == 0); 23817c478bd9Sstevel@tonic-gate mutex_enter(&zone_deathrow_lock); 23827c478bd9Sstevel@tonic-gate list_remove(&zone_deathrow, zone); 23837c478bd9Sstevel@tonic-gate mutex_exit(&zone_deathrow_lock); 23847c478bd9Sstevel@tonic-gate } 23857c478bd9Sstevel@tonic-gate 2386a19609f8Sjv list_destroy(&zone->zone_ref_list); 23877c478bd9Sstevel@tonic-gate zone_free_zsd(zone); 2388fa9e4066Sahrens zone_free_datasets(zone); 23892b24ab6bSSebastien Roy list_destroy(&zone->zone_dl_list); 23907c478bd9Sstevel@tonic-gate 23917c478bd9Sstevel@tonic-gate if (zone->zone_rootvp != NULL) 23927c478bd9Sstevel@tonic-gate VN_RELE(zone->zone_rootvp); 23937c478bd9Sstevel@tonic-gate if (zone->zone_rootpath) 23947c478bd9Sstevel@tonic-gate kmem_free(zone->zone_rootpath, zone->zone_rootpathlen); 23957c478bd9Sstevel@tonic-gate if (zone->zone_name != NULL) 23967c478bd9Sstevel@tonic-gate kmem_free(zone->zone_name, ZONENAME_MAX); 239745916cd2Sjpk if (zone->zone_slabel != NULL) 239845916cd2Sjpk label_rele(zone->zone_slabel); 23997c478bd9Sstevel@tonic-gate if (zone->zone_nodename != NULL) 24007c478bd9Sstevel@tonic-gate kmem_free(zone->zone_nodename, _SYS_NMLN); 24017c478bd9Sstevel@tonic-gate if (zone->zone_domain != NULL) 24027c478bd9Sstevel@tonic-gate kmem_free(zone->zone_domain, _SYS_NMLN); 24037c478bd9Sstevel@tonic-gate if (zone->zone_privset != NULL) 24047c478bd9Sstevel@tonic-gate kmem_free(zone->zone_privset, sizeof (priv_set_t)); 24057c478bd9Sstevel@tonic-gate if (zone->zone_rctls != NULL) 24067c478bd9Sstevel@tonic-gate rctl_set_free(zone->zone_rctls); 24077c478bd9Sstevel@tonic-gate if (zone->zone_bootargs != NULL) 24080fbb751dSJohn Levon strfree(zone->zone_bootargs); 24093f2f09c1Sdp if (zone->zone_initname != NULL) 24100fbb751dSJohn Levon strfree(zone->zone_initname); 24110fbb751dSJohn Levon if (zone->zone_fs_allowed != NULL) 24120fbb751dSJohn Levon strfree(zone->zone_fs_allowed); 2413134a1f4eSCasper H.S. Dik if (zone->zone_pfexecd != NULL) 2414134a1f4eSCasper H.S. Dik klpd_freelist(&zone->zone_pfexecd); 24157c478bd9Sstevel@tonic-gate id_free(zoneid_space, zone->zone_id); 24167c478bd9Sstevel@tonic-gate mutex_destroy(&zone->zone_lock); 24177c478bd9Sstevel@tonic-gate cv_destroy(&zone->zone_cv); 241845916cd2Sjpk rw_destroy(&zone->zone_mlps.mlpl_rwlock); 2419835ee219SRobert Harris rw_destroy(&zone->zone_mntfs_db_lock); 24207c478bd9Sstevel@tonic-gate kmem_free(zone, sizeof (zone_t)); 24217c478bd9Sstevel@tonic-gate } 24227c478bd9Sstevel@tonic-gate 24237c478bd9Sstevel@tonic-gate /* 24247c478bd9Sstevel@tonic-gate * See block comment at the top of this file for information about zone 24257c478bd9Sstevel@tonic-gate * status values. 24267c478bd9Sstevel@tonic-gate */ 24277c478bd9Sstevel@tonic-gate /* 24287c478bd9Sstevel@tonic-gate * Convenience function for setting zone status. 24297c478bd9Sstevel@tonic-gate */ 24307c478bd9Sstevel@tonic-gate static void 24317c478bd9Sstevel@tonic-gate zone_status_set(zone_t *zone, zone_status_t status) 24327c478bd9Sstevel@tonic-gate { 2433cf8f45c7Sdstaff 2434cf8f45c7Sdstaff nvlist_t *nvl = NULL; 24357c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&zone_status_lock)); 24367c478bd9Sstevel@tonic-gate ASSERT(status > ZONE_MIN_STATE && status <= ZONE_MAX_STATE && 24377c478bd9Sstevel@tonic-gate status >= zone_status_get(zone)); 2438cf8f45c7Sdstaff 2439cf8f45c7Sdstaff if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, KM_SLEEP) || 2440cf8f45c7Sdstaff nvlist_add_string(nvl, ZONE_CB_NAME, zone->zone_name) || 2441cf8f45c7Sdstaff nvlist_add_string(nvl, ZONE_CB_NEWSTATE, 24423f2f09c1Sdp zone_status_table[status]) || 2443cf8f45c7Sdstaff nvlist_add_string(nvl, ZONE_CB_OLDSTATE, 24443f2f09c1Sdp zone_status_table[zone->zone_status]) || 2445cf8f45c7Sdstaff nvlist_add_int32(nvl, ZONE_CB_ZONEID, zone->zone_id) || 2446cf8f45c7Sdstaff nvlist_add_uint64(nvl, ZONE_CB_TIMESTAMP, (uint64_t)gethrtime()) || 2447cf8f45c7Sdstaff sysevent_evc_publish(zone_event_chan, ZONE_EVENT_STATUS_CLASS, 24483f2f09c1Sdp ZONE_EVENT_STATUS_SUBCLASS, "sun.com", "kernel", nvl, EVCH_SLEEP)) { 2449cf8f45c7Sdstaff #ifdef DEBUG 2450cf8f45c7Sdstaff (void) printf( 2451cf8f45c7Sdstaff "Failed to allocate and send zone state change event.\n"); 2452cf8f45c7Sdstaff #endif 2453cf8f45c7Sdstaff } 2454cf8f45c7Sdstaff nvlist_free(nvl); 2455cf8f45c7Sdstaff 24567c478bd9Sstevel@tonic-gate zone->zone_status = status; 2457cf8f45c7Sdstaff 24587c478bd9Sstevel@tonic-gate cv_broadcast(&zone->zone_cv); 24597c478bd9Sstevel@tonic-gate } 24607c478bd9Sstevel@tonic-gate 24617c478bd9Sstevel@tonic-gate /* 24627c478bd9Sstevel@tonic-gate * Public function to retrieve the zone status. The zone status may 24637c478bd9Sstevel@tonic-gate * change after it is retrieved. 24647c478bd9Sstevel@tonic-gate */ 24657c478bd9Sstevel@tonic-gate zone_status_t 24667c478bd9Sstevel@tonic-gate zone_status_get(zone_t *zone) 24677c478bd9Sstevel@tonic-gate { 24687c478bd9Sstevel@tonic-gate return (zone->zone_status); 24697c478bd9Sstevel@tonic-gate } 24707c478bd9Sstevel@tonic-gate 24717c478bd9Sstevel@tonic-gate static int 24727c478bd9Sstevel@tonic-gate zone_set_bootargs(zone_t *zone, const char *zone_bootargs) 24737c478bd9Sstevel@tonic-gate { 24740fbb751dSJohn Levon char *buf = kmem_zalloc(BOOTARGS_MAX, KM_SLEEP); 24753f2f09c1Sdp int err = 0; 24763f2f09c1Sdp 24773f2f09c1Sdp ASSERT(zone != global_zone); 24780fbb751dSJohn Levon if ((err = copyinstr(zone_bootargs, buf, BOOTARGS_MAX, NULL)) != 0) 24793f2f09c1Sdp goto done; /* EFAULT or ENAMETOOLONG */ 24803f2f09c1Sdp 24813f2f09c1Sdp if (zone->zone_bootargs != NULL) 24820fbb751dSJohn Levon strfree(zone->zone_bootargs); 24833f2f09c1Sdp 24840fbb751dSJohn Levon zone->zone_bootargs = strdup(buf); 24853f2f09c1Sdp 24863f2f09c1Sdp done: 24870fbb751dSJohn Levon kmem_free(buf, BOOTARGS_MAX); 24883f2f09c1Sdp return (err); 24893f2f09c1Sdp } 24903f2f09c1Sdp 249159f2ff5cSedp static int 249259f2ff5cSedp zone_set_brand(zone_t *zone, const char *brand) 249359f2ff5cSedp { 249459f2ff5cSedp struct brand_attr *attrp; 249559f2ff5cSedp brand_t *bp; 249659f2ff5cSedp 249759f2ff5cSedp attrp = kmem_alloc(sizeof (struct brand_attr), KM_SLEEP); 249859f2ff5cSedp if (copyin(brand, attrp, sizeof (struct brand_attr)) != 0) { 249959f2ff5cSedp kmem_free(attrp, sizeof (struct brand_attr)); 250059f2ff5cSedp return (EFAULT); 250159f2ff5cSedp } 250259f2ff5cSedp 250359f2ff5cSedp bp = brand_register_zone(attrp); 250459f2ff5cSedp kmem_free(attrp, sizeof (struct brand_attr)); 250559f2ff5cSedp if (bp == NULL) 250659f2ff5cSedp return (EINVAL); 250759f2ff5cSedp 250859f2ff5cSedp /* 250959f2ff5cSedp * This is the only place where a zone can change it's brand. 251059f2ff5cSedp * We already need to hold zone_status_lock to check the zone 251159f2ff5cSedp * status, so we'll just use that lock to serialize zone 251259f2ff5cSedp * branding requests as well. 251359f2ff5cSedp */ 251459f2ff5cSedp mutex_enter(&zone_status_lock); 251559f2ff5cSedp 251659f2ff5cSedp /* Re-Branding is not allowed and the zone can't be booted yet */ 251759f2ff5cSedp if ((ZONE_IS_BRANDED(zone)) || 251859f2ff5cSedp (zone_status_get(zone) >= ZONE_IS_BOOTING)) { 251959f2ff5cSedp mutex_exit(&zone_status_lock); 252059f2ff5cSedp brand_unregister_zone(bp); 252159f2ff5cSedp return (EINVAL); 252259f2ff5cSedp } 252359f2ff5cSedp 2524319378d9Seh /* set up the brand specific data */ 252559f2ff5cSedp zone->zone_brand = bp; 2526319378d9Seh ZBROP(zone)->b_init_brand_data(zone); 2527319378d9Seh 252859f2ff5cSedp mutex_exit(&zone_status_lock); 252959f2ff5cSedp return (0); 253059f2ff5cSedp } 253159f2ff5cSedp 2532d2a70789SRichard Lowe static int 2533d2a70789SRichard Lowe zone_set_secflags(zone_t *zone, const psecflags_t *zone_secflags) 2534d2a70789SRichard Lowe { 2535d2a70789SRichard Lowe int err = 0; 2536d2a70789SRichard Lowe psecflags_t psf; 2537d2a70789SRichard Lowe 2538d2a70789SRichard Lowe ASSERT(zone != global_zone); 2539d2a70789SRichard Lowe 2540d2a70789SRichard Lowe if ((err = copyin(zone_secflags, &psf, sizeof (psf))) != 0) 2541d2a70789SRichard Lowe return (err); 2542d2a70789SRichard Lowe 2543d2a70789SRichard Lowe if (zone_status_get(zone) > ZONE_IS_READY) 2544d2a70789SRichard Lowe return (EINVAL); 2545d2a70789SRichard Lowe 2546d2a70789SRichard Lowe if (!psecflags_validate(&psf)) 2547d2a70789SRichard Lowe return (EINVAL); 2548d2a70789SRichard Lowe 2549d2a70789SRichard Lowe (void) memcpy(&zone->zone_secflags, &psf, sizeof (psf)); 2550d2a70789SRichard Lowe 2551d2a70789SRichard Lowe /* Set security flags on the zone's zsched */ 2552d2a70789SRichard Lowe (void) memcpy(&zone->zone_zsched->p_secflags, &zone->zone_secflags, 2553d2a70789SRichard Lowe sizeof (zone->zone_zsched->p_secflags)); 2554d2a70789SRichard Lowe 2555d2a70789SRichard Lowe return (0); 2556d2a70789SRichard Lowe } 2557d2a70789SRichard Lowe 25580fbb751dSJohn Levon static int 25590fbb751dSJohn Levon zone_set_fs_allowed(zone_t *zone, const char *zone_fs_allowed) 25600fbb751dSJohn Levon { 25610fbb751dSJohn Levon char *buf = kmem_zalloc(ZONE_FS_ALLOWED_MAX, KM_SLEEP); 25620fbb751dSJohn Levon int err = 0; 25630fbb751dSJohn Levon 25640fbb751dSJohn Levon ASSERT(zone != global_zone); 25650fbb751dSJohn Levon if ((err = copyinstr(zone_fs_allowed, buf, 25660fbb751dSJohn Levon ZONE_FS_ALLOWED_MAX, NULL)) != 0) 25670fbb751dSJohn Levon goto done; 25680fbb751dSJohn Levon 25690fbb751dSJohn Levon if (zone->zone_fs_allowed != NULL) 25700fbb751dSJohn Levon strfree(zone->zone_fs_allowed); 25710fbb751dSJohn Levon 25720fbb751dSJohn Levon zone->zone_fs_allowed = strdup(buf); 25730fbb751dSJohn Levon 25740fbb751dSJohn Levon done: 25750fbb751dSJohn Levon kmem_free(buf, ZONE_FS_ALLOWED_MAX); 25760fbb751dSJohn Levon return (err); 25770fbb751dSJohn Levon } 25780fbb751dSJohn Levon 25793f2f09c1Sdp static int 25803f2f09c1Sdp zone_set_initname(zone_t *zone, const char *zone_initname) 25813f2f09c1Sdp { 25823f2f09c1Sdp char initname[INITNAME_SZ]; 25837c478bd9Sstevel@tonic-gate size_t len; 25843f2f09c1Sdp int err = 0; 25857c478bd9Sstevel@tonic-gate 25863f2f09c1Sdp ASSERT(zone != global_zone); 25873f2f09c1Sdp if ((err = copyinstr(zone_initname, initname, INITNAME_SZ, &len)) != 0) 25887c478bd9Sstevel@tonic-gate return (err); /* EFAULT or ENAMETOOLONG */ 25897c478bd9Sstevel@tonic-gate 25903f2f09c1Sdp if (zone->zone_initname != NULL) 25910fbb751dSJohn Levon strfree(zone->zone_initname); 25923f2f09c1Sdp 25933f2f09c1Sdp zone->zone_initname = kmem_alloc(strlen(initname) + 1, KM_SLEEP); 25943f2f09c1Sdp (void) strcpy(zone->zone_initname, initname); 25957c478bd9Sstevel@tonic-gate return (0); 25967c478bd9Sstevel@tonic-gate } 25977c478bd9Sstevel@tonic-gate 25980209230bSgjelinek static int 25990209230bSgjelinek zone_set_phys_mcap(zone_t *zone, const uint64_t *zone_mcap) 26000209230bSgjelinek { 26010209230bSgjelinek uint64_t mcap; 26020209230bSgjelinek int err = 0; 26030209230bSgjelinek 26040209230bSgjelinek if ((err = copyin(zone_mcap, &mcap, sizeof (uint64_t))) == 0) 26050209230bSgjelinek zone->zone_phys_mcap = mcap; 26060209230bSgjelinek 26070209230bSgjelinek return (err); 26080209230bSgjelinek } 26090209230bSgjelinek 26100209230bSgjelinek static int 26110209230bSgjelinek zone_set_sched_class(zone_t *zone, const char *new_class) 26120209230bSgjelinek { 26130209230bSgjelinek char sched_class[PC_CLNMSZ]; 26140209230bSgjelinek id_t classid; 26150209230bSgjelinek int err; 26160209230bSgjelinek 26170209230bSgjelinek ASSERT(zone != global_zone); 26180209230bSgjelinek if ((err = copyinstr(new_class, sched_class, PC_CLNMSZ, NULL)) != 0) 26190209230bSgjelinek return (err); /* EFAULT or ENAMETOOLONG */ 26200209230bSgjelinek 262135a5a358SJonathan Adams if (getcid(sched_class, &classid) != 0 || CLASS_KERNEL(classid)) 26220209230bSgjelinek return (set_errno(EINVAL)); 26230209230bSgjelinek zone->zone_defaultcid = classid; 26240209230bSgjelinek ASSERT(zone->zone_defaultcid > 0 && 26250209230bSgjelinek zone->zone_defaultcid < loaded_classes); 26260209230bSgjelinek 26270209230bSgjelinek return (0); 26280209230bSgjelinek } 26290209230bSgjelinek 26307c478bd9Sstevel@tonic-gate /* 26317c478bd9Sstevel@tonic-gate * Block indefinitely waiting for (zone_status >= status) 26327c478bd9Sstevel@tonic-gate */ 26337c478bd9Sstevel@tonic-gate void 26347c478bd9Sstevel@tonic-gate zone_status_wait(zone_t *zone, zone_status_t status) 26357c478bd9Sstevel@tonic-gate { 26367c478bd9Sstevel@tonic-gate ASSERT(status > ZONE_MIN_STATE && status <= ZONE_MAX_STATE); 26377c478bd9Sstevel@tonic-gate 26387c478bd9Sstevel@tonic-gate mutex_enter(&zone_status_lock); 26397c478bd9Sstevel@tonic-gate while (zone->zone_status < status) { 26407c478bd9Sstevel@tonic-gate cv_wait(&zone->zone_cv, &zone_status_lock); 26417c478bd9Sstevel@tonic-gate } 26427c478bd9Sstevel@tonic-gate mutex_exit(&zone_status_lock); 26437c478bd9Sstevel@tonic-gate } 26447c478bd9Sstevel@tonic-gate 26457c478bd9Sstevel@tonic-gate /* 26467c478bd9Sstevel@tonic-gate * Private CPR-safe version of zone_status_wait(). 26477c478bd9Sstevel@tonic-gate */ 26487c478bd9Sstevel@tonic-gate static void 26497c478bd9Sstevel@tonic-gate zone_status_wait_cpr(zone_t *zone, zone_status_t status, char *str) 26507c478bd9Sstevel@tonic-gate { 26517c478bd9Sstevel@tonic-gate callb_cpr_t cprinfo; 26527c478bd9Sstevel@tonic-gate 26537c478bd9Sstevel@tonic-gate ASSERT(status > ZONE_MIN_STATE && status <= ZONE_MAX_STATE); 26547c478bd9Sstevel@tonic-gate 26557c478bd9Sstevel@tonic-gate CALLB_CPR_INIT(&cprinfo, &zone_status_lock, callb_generic_cpr, 26567c478bd9Sstevel@tonic-gate str); 26577c478bd9Sstevel@tonic-gate mutex_enter(&zone_status_lock); 26587c478bd9Sstevel@tonic-gate while (zone->zone_status < status) { 26597c478bd9Sstevel@tonic-gate CALLB_CPR_SAFE_BEGIN(&cprinfo); 26607c478bd9Sstevel@tonic-gate cv_wait(&zone->zone_cv, &zone_status_lock); 26617c478bd9Sstevel@tonic-gate CALLB_CPR_SAFE_END(&cprinfo, &zone_status_lock); 26627c478bd9Sstevel@tonic-gate } 26637c478bd9Sstevel@tonic-gate /* 26647c478bd9Sstevel@tonic-gate * zone_status_lock is implicitly released by the following. 26657c478bd9Sstevel@tonic-gate */ 26667c478bd9Sstevel@tonic-gate CALLB_CPR_EXIT(&cprinfo); 26677c478bd9Sstevel@tonic-gate } 26687c478bd9Sstevel@tonic-gate 26697c478bd9Sstevel@tonic-gate /* 26707c478bd9Sstevel@tonic-gate * Block until zone enters requested state or signal is received. Return (0) 26717c478bd9Sstevel@tonic-gate * if signaled, non-zero otherwise. 26727c478bd9Sstevel@tonic-gate */ 26737c478bd9Sstevel@tonic-gate int 26747c478bd9Sstevel@tonic-gate zone_status_wait_sig(zone_t *zone, zone_status_t status) 26757c478bd9Sstevel@tonic-gate { 26767c478bd9Sstevel@tonic-gate ASSERT(status > ZONE_MIN_STATE && status <= ZONE_MAX_STATE); 26777c478bd9Sstevel@tonic-gate 26787c478bd9Sstevel@tonic-gate mutex_enter(&zone_status_lock); 26797c478bd9Sstevel@tonic-gate while (zone->zone_status < status) { 26807c478bd9Sstevel@tonic-gate if (!cv_wait_sig(&zone->zone_cv, &zone_status_lock)) { 26817c478bd9Sstevel@tonic-gate mutex_exit(&zone_status_lock); 26827c478bd9Sstevel@tonic-gate return (0); 26837c478bd9Sstevel@tonic-gate } 26847c478bd9Sstevel@tonic-gate } 26857c478bd9Sstevel@tonic-gate mutex_exit(&zone_status_lock); 26867c478bd9Sstevel@tonic-gate return (1); 26877c478bd9Sstevel@tonic-gate } 26887c478bd9Sstevel@tonic-gate 26897c478bd9Sstevel@tonic-gate /* 26907c478bd9Sstevel@tonic-gate * Block until the zone enters the requested state or the timeout expires, 26917c478bd9Sstevel@tonic-gate * whichever happens first. Return (-1) if operation timed out, time remaining 26927c478bd9Sstevel@tonic-gate * otherwise. 26937c478bd9Sstevel@tonic-gate */ 26947c478bd9Sstevel@tonic-gate clock_t 26957c478bd9Sstevel@tonic-gate zone_status_timedwait(zone_t *zone, clock_t tim, zone_status_t status) 26967c478bd9Sstevel@tonic-gate { 26977c478bd9Sstevel@tonic-gate clock_t timeleft = 0; 26987c478bd9Sstevel@tonic-gate 26997c478bd9Sstevel@tonic-gate ASSERT(status > ZONE_MIN_STATE && status <= ZONE_MAX_STATE); 27007c478bd9Sstevel@tonic-gate 27017c478bd9Sstevel@tonic-gate mutex_enter(&zone_status_lock); 27027c478bd9Sstevel@tonic-gate while (zone->zone_status < status && timeleft != -1) { 27037c478bd9Sstevel@tonic-gate timeleft = cv_timedwait(&zone->zone_cv, &zone_status_lock, tim); 27047c478bd9Sstevel@tonic-gate } 27057c478bd9Sstevel@tonic-gate mutex_exit(&zone_status_lock); 27067c478bd9Sstevel@tonic-gate return (timeleft); 27077c478bd9Sstevel@tonic-gate } 27087c478bd9Sstevel@tonic-gate 27097c478bd9Sstevel@tonic-gate /* 27107c478bd9Sstevel@tonic-gate * Block until the zone enters the requested state, the current process is 27117c478bd9Sstevel@tonic-gate * signaled, or the timeout expires, whichever happens first. Return (-1) if 27127c478bd9Sstevel@tonic-gate * operation timed out, 0 if signaled, time remaining otherwise. 27137c478bd9Sstevel@tonic-gate */ 27147c478bd9Sstevel@tonic-gate clock_t 27157c478bd9Sstevel@tonic-gate zone_status_timedwait_sig(zone_t *zone, clock_t tim, zone_status_t status) 27167c478bd9Sstevel@tonic-gate { 2717d3d50737SRafael Vanoni clock_t timeleft = tim - ddi_get_lbolt(); 27187c478bd9Sstevel@tonic-gate 27197c478bd9Sstevel@tonic-gate ASSERT(status > ZONE_MIN_STATE && status <= ZONE_MAX_STATE); 27207c478bd9Sstevel@tonic-gate 27217c478bd9Sstevel@tonic-gate mutex_enter(&zone_status_lock); 27227c478bd9Sstevel@tonic-gate while (zone->zone_status < status) { 27237c478bd9Sstevel@tonic-gate timeleft = cv_timedwait_sig(&zone->zone_cv, &zone_status_lock, 27247c478bd9Sstevel@tonic-gate tim); 27257c478bd9Sstevel@tonic-gate if (timeleft <= 0) 27267c478bd9Sstevel@tonic-gate break; 27277c478bd9Sstevel@tonic-gate } 27287c478bd9Sstevel@tonic-gate mutex_exit(&zone_status_lock); 27297c478bd9Sstevel@tonic-gate return (timeleft); 27307c478bd9Sstevel@tonic-gate } 27317c478bd9Sstevel@tonic-gate 27327c478bd9Sstevel@tonic-gate /* 27337c478bd9Sstevel@tonic-gate * Zones have two reference counts: one for references from credential 27347c478bd9Sstevel@tonic-gate * structures (zone_cred_ref), and one (zone_ref) for everything else. 27357c478bd9Sstevel@tonic-gate * This is so we can allow a zone to be rebooted while there are still 27367c478bd9Sstevel@tonic-gate * outstanding cred references, since certain drivers cache dblks (which 27377c478bd9Sstevel@tonic-gate * implicitly results in cached creds). We wait for zone_ref to drop to 27387c478bd9Sstevel@tonic-gate * 0 (actually 1), but not zone_cred_ref. The zone structure itself is 27397c478bd9Sstevel@tonic-gate * later freed when the zone_cred_ref drops to 0, though nothing other 27407c478bd9Sstevel@tonic-gate * than the zone id and privilege set should be accessed once the zone 27417c478bd9Sstevel@tonic-gate * is "dead". 27427c478bd9Sstevel@tonic-gate * 27437c478bd9Sstevel@tonic-gate * A debugging flag, zone_wait_for_cred, can be set to a non-zero value 27447c478bd9Sstevel@tonic-gate * to force halt/reboot to block waiting for the zone_cred_ref to drop 27457c478bd9Sstevel@tonic-gate * to 0. This can be useful to flush out other sources of cached creds 27467c478bd9Sstevel@tonic-gate * that may be less innocuous than the driver case. 2747a19609f8Sjv * 2748a19609f8Sjv * Zones also provide a tracked reference counting mechanism in which zone 2749a19609f8Sjv * references are represented by "crumbs" (zone_ref structures). Crumbs help 2750a19609f8Sjv * debuggers determine the sources of leaked zone references. See 2751a19609f8Sjv * zone_hold_ref() and zone_rele_ref() below for more information. 27527c478bd9Sstevel@tonic-gate */ 27537c478bd9Sstevel@tonic-gate 27547c478bd9Sstevel@tonic-gate int zone_wait_for_cred = 0; 27557c478bd9Sstevel@tonic-gate 27567c478bd9Sstevel@tonic-gate static void 27577c478bd9Sstevel@tonic-gate zone_hold_locked(zone_t *z) 27587c478bd9Sstevel@tonic-gate { 27597c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&z->zone_lock)); 27607c478bd9Sstevel@tonic-gate z->zone_ref++; 27617c478bd9Sstevel@tonic-gate ASSERT(z->zone_ref != 0); 27627c478bd9Sstevel@tonic-gate } 27637c478bd9Sstevel@tonic-gate 2764a19609f8Sjv /* 2765a19609f8Sjv * Increment the specified zone's reference count. The zone's zone_t structure 2766a19609f8Sjv * will not be freed as long as the zone's reference count is nonzero. 2767a19609f8Sjv * Decrement the zone's reference count via zone_rele(). 2768a19609f8Sjv * 2769a19609f8Sjv * NOTE: This function should only be used to hold zones for short periods of 2770a19609f8Sjv * time. Use zone_hold_ref() if the zone must be held for a long time. 2771a19609f8Sjv */ 27727c478bd9Sstevel@tonic-gate void 27737c478bd9Sstevel@tonic-gate zone_hold(zone_t *z) 27747c478bd9Sstevel@tonic-gate { 27757c478bd9Sstevel@tonic-gate mutex_enter(&z->zone_lock); 27767c478bd9Sstevel@tonic-gate zone_hold_locked(z); 27777c478bd9Sstevel@tonic-gate mutex_exit(&z->zone_lock); 27787c478bd9Sstevel@tonic-gate } 27797c478bd9Sstevel@tonic-gate 27807c478bd9Sstevel@tonic-gate /* 27817c478bd9Sstevel@tonic-gate * If the non-cred ref count drops to 1 and either the cred ref count 27827c478bd9Sstevel@tonic-gate * is 0 or we aren't waiting for cred references, the zone is ready to 27837c478bd9Sstevel@tonic-gate * be destroyed. 27847c478bd9Sstevel@tonic-gate */ 27857c478bd9Sstevel@tonic-gate #define ZONE_IS_UNREF(zone) ((zone)->zone_ref == 1 && \ 27867c478bd9Sstevel@tonic-gate (!zone_wait_for_cred || (zone)->zone_cred_ref == 0)) 27877c478bd9Sstevel@tonic-gate 2788a19609f8Sjv /* 2789a19609f8Sjv * Common zone reference release function invoked by zone_rele() and 2790a19609f8Sjv * zone_rele_ref(). If subsys is ZONE_REF_NUM_SUBSYS, then the specified 2791a19609f8Sjv * zone's subsystem-specific reference counters are not affected by the 2792a19609f8Sjv * release. If ref is not NULL, then the zone_ref_t to which it refers is 2793a19609f8Sjv * removed from the specified zone's reference list. ref must be non-NULL iff 2794a19609f8Sjv * subsys is not ZONE_REF_NUM_SUBSYS. 2795a19609f8Sjv */ 2796a19609f8Sjv static void 2797a19609f8Sjv zone_rele_common(zone_t *z, zone_ref_t *ref, zone_ref_subsys_t subsys) 27987c478bd9Sstevel@tonic-gate { 27997c478bd9Sstevel@tonic-gate boolean_t wakeup; 28007c478bd9Sstevel@tonic-gate 28017c478bd9Sstevel@tonic-gate mutex_enter(&z->zone_lock); 28027c478bd9Sstevel@tonic-gate ASSERT(z->zone_ref != 0); 28037c478bd9Sstevel@tonic-gate z->zone_ref--; 2804a19609f8Sjv if (subsys != ZONE_REF_NUM_SUBSYS) { 2805a19609f8Sjv ASSERT(z->zone_subsys_ref[subsys] != 0); 2806a19609f8Sjv z->zone_subsys_ref[subsys]--; 2807a19609f8Sjv list_remove(&z->zone_ref_list, ref); 2808a19609f8Sjv } 28097c478bd9Sstevel@tonic-gate if (z->zone_ref == 0 && z->zone_cred_ref == 0) { 28107c478bd9Sstevel@tonic-gate /* no more refs, free the structure */ 28117c478bd9Sstevel@tonic-gate mutex_exit(&z->zone_lock); 28127c478bd9Sstevel@tonic-gate zone_free(z); 28137c478bd9Sstevel@tonic-gate return; 28147c478bd9Sstevel@tonic-gate } 28157c478bd9Sstevel@tonic-gate /* signal zone_destroy so the zone can finish halting */ 28167c478bd9Sstevel@tonic-gate wakeup = (ZONE_IS_UNREF(z) && zone_status_get(z) >= ZONE_IS_DEAD); 28177c478bd9Sstevel@tonic-gate mutex_exit(&z->zone_lock); 28187c478bd9Sstevel@tonic-gate 28197c478bd9Sstevel@tonic-gate if (wakeup) { 28207c478bd9Sstevel@tonic-gate /* 28217c478bd9Sstevel@tonic-gate * Grabbing zonehash_lock here effectively synchronizes with 28227c478bd9Sstevel@tonic-gate * zone_destroy() to avoid missed signals. 28237c478bd9Sstevel@tonic-gate */ 28247c478bd9Sstevel@tonic-gate mutex_enter(&zonehash_lock); 28257c478bd9Sstevel@tonic-gate cv_broadcast(&zone_destroy_cv); 28267c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 28277c478bd9Sstevel@tonic-gate } 28287c478bd9Sstevel@tonic-gate } 28297c478bd9Sstevel@tonic-gate 2830a19609f8Sjv /* 2831a19609f8Sjv * Decrement the specified zone's reference count. The specified zone will 2832a19609f8Sjv * cease to exist after this function returns if the reference count drops to 2833a19609f8Sjv * zero. This function should be paired with zone_hold(). 2834a19609f8Sjv */ 2835a19609f8Sjv void 2836a19609f8Sjv zone_rele(zone_t *z) 2837a19609f8Sjv { 2838a19609f8Sjv zone_rele_common(z, NULL, ZONE_REF_NUM_SUBSYS); 2839a19609f8Sjv } 2840a19609f8Sjv 2841a19609f8Sjv /* 2842a19609f8Sjv * Initialize a zone reference structure. This function must be invoked for 2843a19609f8Sjv * a reference structure before the structure is passed to zone_hold_ref(). 2844a19609f8Sjv */ 2845a19609f8Sjv void 2846a19609f8Sjv zone_init_ref(zone_ref_t *ref) 2847a19609f8Sjv { 2848a19609f8Sjv ref->zref_zone = NULL; 2849a19609f8Sjv list_link_init(&ref->zref_linkage); 2850a19609f8Sjv } 2851a19609f8Sjv 2852a19609f8Sjv /* 2853a19609f8Sjv * Acquire a reference to zone z. The caller must specify the 2854a19609f8Sjv * zone_ref_subsys_t constant associated with its subsystem. The specified 2855a19609f8Sjv * zone_ref_t structure will represent a reference to the specified zone. Use 2856a19609f8Sjv * zone_rele_ref() to release the reference. 2857a19609f8Sjv * 2858a19609f8Sjv * The referenced zone_t structure will not be freed as long as the zone_t's 2859a19609f8Sjv * zone_status field is not ZONE_IS_DEAD and the zone has outstanding 2860a19609f8Sjv * references. 2861a19609f8Sjv * 2862a19609f8Sjv * NOTE: The zone_ref_t structure must be initialized before it is used. 2863a19609f8Sjv * See zone_init_ref() above. 2864a19609f8Sjv */ 2865a19609f8Sjv void 2866a19609f8Sjv zone_hold_ref(zone_t *z, zone_ref_t *ref, zone_ref_subsys_t subsys) 2867a19609f8Sjv { 2868a19609f8Sjv ASSERT(subsys >= 0 && subsys < ZONE_REF_NUM_SUBSYS); 2869a19609f8Sjv 2870a19609f8Sjv /* 2871a19609f8Sjv * Prevent consumers from reusing a reference structure before 2872a19609f8Sjv * releasing it. 2873a19609f8Sjv */ 2874a19609f8Sjv VERIFY(ref->zref_zone == NULL); 2875a19609f8Sjv 2876a19609f8Sjv ref->zref_zone = z; 2877a19609f8Sjv mutex_enter(&z->zone_lock); 2878a19609f8Sjv zone_hold_locked(z); 2879a19609f8Sjv z->zone_subsys_ref[subsys]++; 2880a19609f8Sjv ASSERT(z->zone_subsys_ref[subsys] != 0); 2881a19609f8Sjv list_insert_head(&z->zone_ref_list, ref); 2882a19609f8Sjv mutex_exit(&z->zone_lock); 2883a19609f8Sjv } 2884a19609f8Sjv 2885a19609f8Sjv /* 2886a19609f8Sjv * Release the zone reference represented by the specified zone_ref_t. 2887a19609f8Sjv * The reference is invalid after it's released; however, the zone_ref_t 2888a19609f8Sjv * structure can be reused without having to invoke zone_init_ref(). 2889a19609f8Sjv * subsys should be the same value that was passed to zone_hold_ref() 2890a19609f8Sjv * when the reference was acquired. 2891a19609f8Sjv */ 2892a19609f8Sjv void 2893a19609f8Sjv zone_rele_ref(zone_ref_t *ref, zone_ref_subsys_t subsys) 2894a19609f8Sjv { 2895a19609f8Sjv zone_rele_common(ref->zref_zone, ref, subsys); 2896a19609f8Sjv 2897a19609f8Sjv /* 2898a19609f8Sjv * Set the zone_ref_t's zref_zone field to NULL to generate panics 2899a19609f8Sjv * when consumers dereference the reference. This helps us catch 2900a19609f8Sjv * consumers who use released references. Furthermore, this lets 2901a19609f8Sjv * consumers reuse the zone_ref_t structure without having to 2902a19609f8Sjv * invoke zone_init_ref(). 2903a19609f8Sjv */ 2904a19609f8Sjv ref->zref_zone = NULL; 2905a19609f8Sjv } 2906a19609f8Sjv 29077c478bd9Sstevel@tonic-gate void 29087c478bd9Sstevel@tonic-gate zone_cred_hold(zone_t *z) 29097c478bd9Sstevel@tonic-gate { 29107c478bd9Sstevel@tonic-gate mutex_enter(&z->zone_lock); 29117c478bd9Sstevel@tonic-gate z->zone_cred_ref++; 29127c478bd9Sstevel@tonic-gate ASSERT(z->zone_cred_ref != 0); 29137c478bd9Sstevel@tonic-gate mutex_exit(&z->zone_lock); 29147c478bd9Sstevel@tonic-gate } 29157c478bd9Sstevel@tonic-gate 29167c478bd9Sstevel@tonic-gate void 29177c478bd9Sstevel@tonic-gate zone_cred_rele(zone_t *z) 29187c478bd9Sstevel@tonic-gate { 29197c478bd9Sstevel@tonic-gate boolean_t wakeup; 29207c478bd9Sstevel@tonic-gate 29217c478bd9Sstevel@tonic-gate mutex_enter(&z->zone_lock); 29227c478bd9Sstevel@tonic-gate ASSERT(z->zone_cred_ref != 0); 29237c478bd9Sstevel@tonic-gate z->zone_cred_ref--; 29247c478bd9Sstevel@tonic-gate if (z->zone_ref == 0 && z->zone_cred_ref == 0) { 29257c478bd9Sstevel@tonic-gate /* no more refs, free the structure */ 29267c478bd9Sstevel@tonic-gate mutex_exit(&z->zone_lock); 29277c478bd9Sstevel@tonic-gate zone_free(z); 29287c478bd9Sstevel@tonic-gate return; 29297c478bd9Sstevel@tonic-gate } 29307c478bd9Sstevel@tonic-gate /* 29317c478bd9Sstevel@tonic-gate * If zone_destroy is waiting for the cred references to drain 29327c478bd9Sstevel@tonic-gate * out, and they have, signal it. 29337c478bd9Sstevel@tonic-gate */ 29347c478bd9Sstevel@tonic-gate wakeup = (zone_wait_for_cred && ZONE_IS_UNREF(z) && 29357c478bd9Sstevel@tonic-gate zone_status_get(z) >= ZONE_IS_DEAD); 29367c478bd9Sstevel@tonic-gate mutex_exit(&z->zone_lock); 29377c478bd9Sstevel@tonic-gate 29387c478bd9Sstevel@tonic-gate if (wakeup) { 29397c478bd9Sstevel@tonic-gate /* 29407c478bd9Sstevel@tonic-gate * Grabbing zonehash_lock here effectively synchronizes with 29417c478bd9Sstevel@tonic-gate * zone_destroy() to avoid missed signals. 29427c478bd9Sstevel@tonic-gate */ 29437c478bd9Sstevel@tonic-gate mutex_enter(&zonehash_lock); 29447c478bd9Sstevel@tonic-gate cv_broadcast(&zone_destroy_cv); 29457c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 29467c478bd9Sstevel@tonic-gate } 29477c478bd9Sstevel@tonic-gate } 29487c478bd9Sstevel@tonic-gate 29497c478bd9Sstevel@tonic-gate void 29507c478bd9Sstevel@tonic-gate zone_task_hold(zone_t *z) 29517c478bd9Sstevel@tonic-gate { 29527c478bd9Sstevel@tonic-gate mutex_enter(&z->zone_lock); 29537c478bd9Sstevel@tonic-gate z->zone_ntasks++; 29547c478bd9Sstevel@tonic-gate ASSERT(z->zone_ntasks != 0); 29557c478bd9Sstevel@tonic-gate mutex_exit(&z->zone_lock); 29567c478bd9Sstevel@tonic-gate } 29577c478bd9Sstevel@tonic-gate 29587c478bd9Sstevel@tonic-gate void 29597c478bd9Sstevel@tonic-gate zone_task_rele(zone_t *zone) 29607c478bd9Sstevel@tonic-gate { 29617c478bd9Sstevel@tonic-gate uint_t refcnt; 29627c478bd9Sstevel@tonic-gate 29637c478bd9Sstevel@tonic-gate mutex_enter(&zone->zone_lock); 29647c478bd9Sstevel@tonic-gate ASSERT(zone->zone_ntasks != 0); 29657c478bd9Sstevel@tonic-gate refcnt = --zone->zone_ntasks; 29667c478bd9Sstevel@tonic-gate if (refcnt > 1) { /* Common case */ 29677c478bd9Sstevel@tonic-gate mutex_exit(&zone->zone_lock); 29687c478bd9Sstevel@tonic-gate return; 29697c478bd9Sstevel@tonic-gate } 29707c478bd9Sstevel@tonic-gate zone_hold_locked(zone); /* so we can use the zone_t later */ 29717c478bd9Sstevel@tonic-gate mutex_exit(&zone->zone_lock); 29727c478bd9Sstevel@tonic-gate if (refcnt == 1) { 29737c478bd9Sstevel@tonic-gate /* 29747c478bd9Sstevel@tonic-gate * See if the zone is shutting down. 29757c478bd9Sstevel@tonic-gate */ 29767c478bd9Sstevel@tonic-gate mutex_enter(&zone_status_lock); 29777c478bd9Sstevel@tonic-gate if (zone_status_get(zone) != ZONE_IS_SHUTTING_DOWN) { 29787c478bd9Sstevel@tonic-gate goto out; 29797c478bd9Sstevel@tonic-gate } 29807c478bd9Sstevel@tonic-gate 29817c478bd9Sstevel@tonic-gate /* 29827c478bd9Sstevel@tonic-gate * Make sure the ntasks didn't change since we 29837c478bd9Sstevel@tonic-gate * dropped zone_lock. 29847c478bd9Sstevel@tonic-gate */ 29857c478bd9Sstevel@tonic-gate mutex_enter(&zone->zone_lock); 29867c478bd9Sstevel@tonic-gate if (refcnt != zone->zone_ntasks) { 29877c478bd9Sstevel@tonic-gate mutex_exit(&zone->zone_lock); 29887c478bd9Sstevel@tonic-gate goto out; 29897c478bd9Sstevel@tonic-gate } 29907c478bd9Sstevel@tonic-gate mutex_exit(&zone->zone_lock); 29917c478bd9Sstevel@tonic-gate 29927c478bd9Sstevel@tonic-gate /* 29937c478bd9Sstevel@tonic-gate * No more user processes in the zone. The zone is empty. 29947c478bd9Sstevel@tonic-gate */ 29957c478bd9Sstevel@tonic-gate zone_status_set(zone, ZONE_IS_EMPTY); 29967c478bd9Sstevel@tonic-gate goto out; 29977c478bd9Sstevel@tonic-gate } 29987c478bd9Sstevel@tonic-gate 29997c478bd9Sstevel@tonic-gate ASSERT(refcnt == 0); 30007c478bd9Sstevel@tonic-gate /* 30017c478bd9Sstevel@tonic-gate * zsched has exited; the zone is dead. 30027c478bd9Sstevel@tonic-gate */ 30037c478bd9Sstevel@tonic-gate zone->zone_zsched = NULL; /* paranoia */ 30047c478bd9Sstevel@tonic-gate mutex_enter(&zone_status_lock); 30057c478bd9Sstevel@tonic-gate zone_status_set(zone, ZONE_IS_DEAD); 30067c478bd9Sstevel@tonic-gate out: 30077c478bd9Sstevel@tonic-gate mutex_exit(&zone_status_lock); 30087c478bd9Sstevel@tonic-gate zone_rele(zone); 30097c478bd9Sstevel@tonic-gate } 30107c478bd9Sstevel@tonic-gate 30117c478bd9Sstevel@tonic-gate zoneid_t 30127c478bd9Sstevel@tonic-gate getzoneid(void) 30137c478bd9Sstevel@tonic-gate { 30147c478bd9Sstevel@tonic-gate return (curproc->p_zone->zone_id); 30157c478bd9Sstevel@tonic-gate } 30167c478bd9Sstevel@tonic-gate 30177c478bd9Sstevel@tonic-gate /* 30187c478bd9Sstevel@tonic-gate * Internal versions of zone_find_by_*(). These don't zone_hold() or 30197c478bd9Sstevel@tonic-gate * check the validity of a zone's state. 30207c478bd9Sstevel@tonic-gate */ 30217c478bd9Sstevel@tonic-gate static zone_t * 30227c478bd9Sstevel@tonic-gate zone_find_all_by_id(zoneid_t zoneid) 30237c478bd9Sstevel@tonic-gate { 30247c478bd9Sstevel@tonic-gate mod_hash_val_t hv; 30257c478bd9Sstevel@tonic-gate zone_t *zone = NULL; 30267c478bd9Sstevel@tonic-gate 30277c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&zonehash_lock)); 30287c478bd9Sstevel@tonic-gate 30297c478bd9Sstevel@tonic-gate if (mod_hash_find(zonehashbyid, 30307c478bd9Sstevel@tonic-gate (mod_hash_key_t)(uintptr_t)zoneid, &hv) == 0) 30317c478bd9Sstevel@tonic-gate zone = (zone_t *)hv; 30327c478bd9Sstevel@tonic-gate return (zone); 30337c478bd9Sstevel@tonic-gate } 30347c478bd9Sstevel@tonic-gate 303545916cd2Sjpk static zone_t * 303645916cd2Sjpk zone_find_all_by_label(const ts_label_t *label) 303745916cd2Sjpk { 303845916cd2Sjpk mod_hash_val_t hv; 303945916cd2Sjpk zone_t *zone = NULL; 304045916cd2Sjpk 304145916cd2Sjpk ASSERT(MUTEX_HELD(&zonehash_lock)); 304245916cd2Sjpk 304345916cd2Sjpk /* 304445916cd2Sjpk * zonehashbylabel is not maintained for unlabeled systems 304545916cd2Sjpk */ 304645916cd2Sjpk if (!is_system_labeled()) 304745916cd2Sjpk return (NULL); 304845916cd2Sjpk if (mod_hash_find(zonehashbylabel, (mod_hash_key_t)label, &hv) == 0) 304945916cd2Sjpk zone = (zone_t *)hv; 305045916cd2Sjpk return (zone); 305145916cd2Sjpk } 305245916cd2Sjpk 30537c478bd9Sstevel@tonic-gate static zone_t * 30547c478bd9Sstevel@tonic-gate zone_find_all_by_name(char *name) 30557c478bd9Sstevel@tonic-gate { 30567c478bd9Sstevel@tonic-gate mod_hash_val_t hv; 30577c478bd9Sstevel@tonic-gate zone_t *zone = NULL; 30587c478bd9Sstevel@tonic-gate 30597c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&zonehash_lock)); 30607c478bd9Sstevel@tonic-gate 30617c478bd9Sstevel@tonic-gate if (mod_hash_find(zonehashbyname, (mod_hash_key_t)name, &hv) == 0) 30627c478bd9Sstevel@tonic-gate zone = (zone_t *)hv; 30637c478bd9Sstevel@tonic-gate return (zone); 30647c478bd9Sstevel@tonic-gate } 30657c478bd9Sstevel@tonic-gate 30667c478bd9Sstevel@tonic-gate /* 30677c478bd9Sstevel@tonic-gate * Public interface for looking up a zone by zoneid. Only returns the zone if 30687c478bd9Sstevel@tonic-gate * it is fully initialized, and has not yet begun the zone_destroy() sequence. 30697c478bd9Sstevel@tonic-gate * Caller must call zone_rele() once it is done with the zone. 30707c478bd9Sstevel@tonic-gate * 30717c478bd9Sstevel@tonic-gate * The zone may begin the zone_destroy() sequence immediately after this 30727c478bd9Sstevel@tonic-gate * function returns, but may be safely used until zone_rele() is called. 30737c478bd9Sstevel@tonic-gate */ 30747c478bd9Sstevel@tonic-gate zone_t * 30757c478bd9Sstevel@tonic-gate zone_find_by_id(zoneid_t zoneid) 30767c478bd9Sstevel@tonic-gate { 30777c478bd9Sstevel@tonic-gate zone_t *zone; 30787c478bd9Sstevel@tonic-gate zone_status_t status; 30797c478bd9Sstevel@tonic-gate 30807c478bd9Sstevel@tonic-gate mutex_enter(&zonehash_lock); 30817c478bd9Sstevel@tonic-gate if ((zone = zone_find_all_by_id(zoneid)) == NULL) { 30827c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 30837c478bd9Sstevel@tonic-gate return (NULL); 30847c478bd9Sstevel@tonic-gate } 30857c478bd9Sstevel@tonic-gate status = zone_status_get(zone); 30867c478bd9Sstevel@tonic-gate if (status < ZONE_IS_READY || status > ZONE_IS_DOWN) { 30877c478bd9Sstevel@tonic-gate /* 30887c478bd9Sstevel@tonic-gate * For all practical purposes the zone doesn't exist. 30897c478bd9Sstevel@tonic-gate */ 30907c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 30917c478bd9Sstevel@tonic-gate return (NULL); 30927c478bd9Sstevel@tonic-gate } 30937c478bd9Sstevel@tonic-gate zone_hold(zone); 30947c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 30957c478bd9Sstevel@tonic-gate return (zone); 30967c478bd9Sstevel@tonic-gate } 30977c478bd9Sstevel@tonic-gate 309845916cd2Sjpk /* 309945916cd2Sjpk * Similar to zone_find_by_id, but using zone label as the key. 310045916cd2Sjpk */ 310145916cd2Sjpk zone_t * 310245916cd2Sjpk zone_find_by_label(const ts_label_t *label) 310345916cd2Sjpk { 310445916cd2Sjpk zone_t *zone; 310542bc57c4Srica zone_status_t status; 310645916cd2Sjpk 310745916cd2Sjpk mutex_enter(&zonehash_lock); 310845916cd2Sjpk if ((zone = zone_find_all_by_label(label)) == NULL) { 310945916cd2Sjpk mutex_exit(&zonehash_lock); 311045916cd2Sjpk return (NULL); 311145916cd2Sjpk } 311242bc57c4Srica 311342bc57c4Srica status = zone_status_get(zone); 311442bc57c4Srica if (status > ZONE_IS_DOWN) { 311545916cd2Sjpk /* 311645916cd2Sjpk * For all practical purposes the zone doesn't exist. 311745916cd2Sjpk */ 311842bc57c4Srica mutex_exit(&zonehash_lock); 311942bc57c4Srica return (NULL); 312045916cd2Sjpk } 312142bc57c4Srica zone_hold(zone); 312245916cd2Sjpk mutex_exit(&zonehash_lock); 312345916cd2Sjpk return (zone); 312445916cd2Sjpk } 312545916cd2Sjpk 31267c478bd9Sstevel@tonic-gate /* 31277c478bd9Sstevel@tonic-gate * Similar to zone_find_by_id, but using zone name as the key. 31287c478bd9Sstevel@tonic-gate */ 31297c478bd9Sstevel@tonic-gate zone_t * 31307c478bd9Sstevel@tonic-gate zone_find_by_name(char *name) 31317c478bd9Sstevel@tonic-gate { 31327c478bd9Sstevel@tonic-gate zone_t *zone; 31337c478bd9Sstevel@tonic-gate zone_status_t status; 31347c478bd9Sstevel@tonic-gate 31357c478bd9Sstevel@tonic-gate mutex_enter(&zonehash_lock); 31367c478bd9Sstevel@tonic-gate if ((zone = zone_find_all_by_name(name)) == NULL) { 31377c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 31387c478bd9Sstevel@tonic-gate return (NULL); 31397c478bd9Sstevel@tonic-gate } 31407c478bd9Sstevel@tonic-gate status = zone_status_get(zone); 31417c478bd9Sstevel@tonic-gate if (status < ZONE_IS_READY || status > ZONE_IS_DOWN) { 31427c478bd9Sstevel@tonic-gate /* 31437c478bd9Sstevel@tonic-gate * For all practical purposes the zone doesn't exist. 31447c478bd9Sstevel@tonic-gate */ 31457c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 31467c478bd9Sstevel@tonic-gate return (NULL); 31477c478bd9Sstevel@tonic-gate } 31487c478bd9Sstevel@tonic-gate zone_hold(zone); 31497c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 31507c478bd9Sstevel@tonic-gate return (zone); 31517c478bd9Sstevel@tonic-gate } 31527c478bd9Sstevel@tonic-gate 31537c478bd9Sstevel@tonic-gate /* 31547c478bd9Sstevel@tonic-gate * Similar to zone_find_by_id(), using the path as a key. For instance, 31557c478bd9Sstevel@tonic-gate * if there is a zone "foo" rooted at /foo/root, and the path argument 31567c478bd9Sstevel@tonic-gate * is "/foo/root/proc", it will return the held zone_t corresponding to 31577c478bd9Sstevel@tonic-gate * zone "foo". 31587c478bd9Sstevel@tonic-gate * 31597c478bd9Sstevel@tonic-gate * zone_find_by_path() always returns a non-NULL value, since at the 31607c478bd9Sstevel@tonic-gate * very least every path will be contained in the global zone. 31617c478bd9Sstevel@tonic-gate * 31627c478bd9Sstevel@tonic-gate * As with the other zone_find_by_*() functions, the caller is 31637c478bd9Sstevel@tonic-gate * responsible for zone_rele()ing the return value of this function. 31647c478bd9Sstevel@tonic-gate */ 31657c478bd9Sstevel@tonic-gate zone_t * 31667c478bd9Sstevel@tonic-gate zone_find_by_path(const char *path) 31677c478bd9Sstevel@tonic-gate { 31687c478bd9Sstevel@tonic-gate zone_t *zone; 31697c478bd9Sstevel@tonic-gate zone_t *zret = NULL; 31707c478bd9Sstevel@tonic-gate zone_status_t status; 31717c478bd9Sstevel@tonic-gate 31727c478bd9Sstevel@tonic-gate if (path == NULL) { 31737c478bd9Sstevel@tonic-gate /* 31747c478bd9Sstevel@tonic-gate * Call from rootconf(). 31757c478bd9Sstevel@tonic-gate */ 31767c478bd9Sstevel@tonic-gate zone_hold(global_zone); 31777c478bd9Sstevel@tonic-gate return (global_zone); 31787c478bd9Sstevel@tonic-gate } 31797c478bd9Sstevel@tonic-gate ASSERT(*path == '/'); 31807c478bd9Sstevel@tonic-gate mutex_enter(&zonehash_lock); 31817c478bd9Sstevel@tonic-gate for (zone = list_head(&zone_active); zone != NULL; 31827c478bd9Sstevel@tonic-gate zone = list_next(&zone_active, zone)) { 31837c478bd9Sstevel@tonic-gate if (ZONE_PATH_VISIBLE(path, zone)) 31847c478bd9Sstevel@tonic-gate zret = zone; 31857c478bd9Sstevel@tonic-gate } 31867c478bd9Sstevel@tonic-gate ASSERT(zret != NULL); 31877c478bd9Sstevel@tonic-gate status = zone_status_get(zret); 31887c478bd9Sstevel@tonic-gate if (status < ZONE_IS_READY || status > ZONE_IS_DOWN) { 31897c478bd9Sstevel@tonic-gate /* 31907c478bd9Sstevel@tonic-gate * Zone practically doesn't exist. 31917c478bd9Sstevel@tonic-gate */ 31927c478bd9Sstevel@tonic-gate zret = global_zone; 31937c478bd9Sstevel@tonic-gate } 31947c478bd9Sstevel@tonic-gate zone_hold(zret); 31957c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 31967c478bd9Sstevel@tonic-gate return (zret); 31977c478bd9Sstevel@tonic-gate } 31987c478bd9Sstevel@tonic-gate 319981d43577SJerry Jelinek /* 320081d43577SJerry Jelinek * Public interface for updating per-zone load averages. Called once per 320181d43577SJerry Jelinek * second. 320281d43577SJerry Jelinek * 320381d43577SJerry Jelinek * Based on loadavg_update(), genloadavg() and calcloadavg() from clock.c. 320481d43577SJerry Jelinek */ 320581d43577SJerry Jelinek void 320681d43577SJerry Jelinek zone_loadavg_update() 320781d43577SJerry Jelinek { 320881d43577SJerry Jelinek zone_t *zp; 320981d43577SJerry Jelinek zone_status_t status; 321081d43577SJerry Jelinek struct loadavg_s *lavg; 321181d43577SJerry Jelinek hrtime_t zone_total; 321281d43577SJerry Jelinek int i; 321381d43577SJerry Jelinek hrtime_t hr_avg; 321481d43577SJerry Jelinek int nrun; 321581d43577SJerry Jelinek static int64_t f[3] = { 135, 27, 9 }; 321681d43577SJerry Jelinek int64_t q, r; 321781d43577SJerry Jelinek 321881d43577SJerry Jelinek mutex_enter(&zonehash_lock); 321981d43577SJerry Jelinek for (zp = list_head(&zone_active); zp != NULL; 322081d43577SJerry Jelinek zp = list_next(&zone_active, zp)) { 322181d43577SJerry Jelinek mutex_enter(&zp->zone_lock); 322281d43577SJerry Jelinek 322381d43577SJerry Jelinek /* Skip zones that are on the way down or not yet up */ 322481d43577SJerry Jelinek status = zone_status_get(zp); 322581d43577SJerry Jelinek if (status < ZONE_IS_READY || status >= ZONE_IS_DOWN) { 322681d43577SJerry Jelinek /* For all practical purposes the zone doesn't exist. */ 322781d43577SJerry Jelinek mutex_exit(&zp->zone_lock); 322881d43577SJerry Jelinek continue; 322981d43577SJerry Jelinek } 323081d43577SJerry Jelinek 323181d43577SJerry Jelinek /* 323281d43577SJerry Jelinek * Update the 10 second moving average data in zone_loadavg. 323381d43577SJerry Jelinek */ 323481d43577SJerry Jelinek lavg = &zp->zone_loadavg; 323581d43577SJerry Jelinek 323681d43577SJerry Jelinek zone_total = zp->zone_utime + zp->zone_stime + zp->zone_wtime; 323781d43577SJerry Jelinek scalehrtime(&zone_total); 323881d43577SJerry Jelinek 323981d43577SJerry Jelinek /* The zone_total should always be increasing. */ 324081d43577SJerry Jelinek lavg->lg_loads[lavg->lg_cur] = (zone_total > lavg->lg_total) ? 324181d43577SJerry Jelinek zone_total - lavg->lg_total : 0; 324281d43577SJerry Jelinek lavg->lg_cur = (lavg->lg_cur + 1) % S_LOADAVG_SZ; 324381d43577SJerry Jelinek /* lg_total holds the prev. 1 sec. total */ 324481d43577SJerry Jelinek lavg->lg_total = zone_total; 324581d43577SJerry Jelinek 324681d43577SJerry Jelinek /* 324781d43577SJerry Jelinek * To simplify the calculation, we don't calculate the load avg. 324881d43577SJerry Jelinek * until the zone has been up for at least 10 seconds and our 324981d43577SJerry Jelinek * moving average is thus full. 325081d43577SJerry Jelinek */ 325181d43577SJerry Jelinek if ((lavg->lg_len + 1) < S_LOADAVG_SZ) { 325281d43577SJerry Jelinek lavg->lg_len++; 325381d43577SJerry Jelinek mutex_exit(&zp->zone_lock); 325481d43577SJerry Jelinek continue; 325581d43577SJerry Jelinek } 325681d43577SJerry Jelinek 325781d43577SJerry Jelinek /* Now calculate the 1min, 5min, 15 min load avg. */ 325881d43577SJerry Jelinek hr_avg = 0; 325981d43577SJerry Jelinek for (i = 0; i < S_LOADAVG_SZ; i++) 326081d43577SJerry Jelinek hr_avg += lavg->lg_loads[i]; 326181d43577SJerry Jelinek hr_avg = hr_avg / S_LOADAVG_SZ; 326281d43577SJerry Jelinek nrun = hr_avg / (NANOSEC / LGRP_LOADAVG_IN_THREAD_MAX); 326381d43577SJerry Jelinek 326481d43577SJerry Jelinek /* Compute load avg. See comment in calcloadavg() */ 326581d43577SJerry Jelinek for (i = 0; i < 3; i++) { 326681d43577SJerry Jelinek q = (zp->zone_hp_avenrun[i] >> 16) << 7; 326781d43577SJerry Jelinek r = (zp->zone_hp_avenrun[i] & 0xffff) << 7; 326881d43577SJerry Jelinek zp->zone_hp_avenrun[i] += 326981d43577SJerry Jelinek ((nrun - q) * f[i] - ((r * f[i]) >> 16)) >> 4; 327081d43577SJerry Jelinek 327181d43577SJerry Jelinek /* avenrun[] can only hold 31 bits of load avg. */ 327281d43577SJerry Jelinek if (zp->zone_hp_avenrun[i] < 327381d43577SJerry Jelinek ((uint64_t)1<<(31+16-FSHIFT))) 327481d43577SJerry Jelinek zp->zone_avenrun[i] = (int32_t) 327581d43577SJerry Jelinek (zp->zone_hp_avenrun[i] >> (16 - FSHIFT)); 327681d43577SJerry Jelinek else 327781d43577SJerry Jelinek zp->zone_avenrun[i] = 0x7fffffff; 327881d43577SJerry Jelinek } 327981d43577SJerry Jelinek 328081d43577SJerry Jelinek mutex_exit(&zp->zone_lock); 328181d43577SJerry Jelinek } 328281d43577SJerry Jelinek mutex_exit(&zonehash_lock); 328381d43577SJerry Jelinek } 328481d43577SJerry Jelinek 32857c478bd9Sstevel@tonic-gate /* 32867c478bd9Sstevel@tonic-gate * Get the number of cpus visible to this zone. The system-wide global 32877c478bd9Sstevel@tonic-gate * 'ncpus' is returned if pools are disabled, the caller is in the 32887c478bd9Sstevel@tonic-gate * global zone, or a NULL zone argument is passed in. 32897c478bd9Sstevel@tonic-gate */ 32907c478bd9Sstevel@tonic-gate int 32917c478bd9Sstevel@tonic-gate zone_ncpus_get(zone_t *zone) 32927c478bd9Sstevel@tonic-gate { 32937c478bd9Sstevel@tonic-gate int myncpus = zone == NULL ? 0 : zone->zone_ncpus; 32947c478bd9Sstevel@tonic-gate 32957c478bd9Sstevel@tonic-gate return (myncpus != 0 ? myncpus : ncpus); 32967c478bd9Sstevel@tonic-gate } 32977c478bd9Sstevel@tonic-gate 32987c478bd9Sstevel@tonic-gate /* 32997c478bd9Sstevel@tonic-gate * Get the number of online cpus visible to this zone. The system-wide 33007c478bd9Sstevel@tonic-gate * global 'ncpus_online' is returned if pools are disabled, the caller 33017c478bd9Sstevel@tonic-gate * is in the global zone, or a NULL zone argument is passed in. 33027c478bd9Sstevel@tonic-gate */ 33037c478bd9Sstevel@tonic-gate int 33047c478bd9Sstevel@tonic-gate zone_ncpus_online_get(zone_t *zone) 33057c478bd9Sstevel@tonic-gate { 33067c478bd9Sstevel@tonic-gate int myncpus_online = zone == NULL ? 0 : zone->zone_ncpus_online; 33077c478bd9Sstevel@tonic-gate 33087c478bd9Sstevel@tonic-gate return (myncpus_online != 0 ? myncpus_online : ncpus_online); 33097c478bd9Sstevel@tonic-gate } 33107c478bd9Sstevel@tonic-gate 33117c478bd9Sstevel@tonic-gate /* 33127c478bd9Sstevel@tonic-gate * Return the pool to which the zone is currently bound. 33137c478bd9Sstevel@tonic-gate */ 33147c478bd9Sstevel@tonic-gate pool_t * 33157c478bd9Sstevel@tonic-gate zone_pool_get(zone_t *zone) 33167c478bd9Sstevel@tonic-gate { 33177c478bd9Sstevel@tonic-gate ASSERT(pool_lock_held()); 33187c478bd9Sstevel@tonic-gate 33197c478bd9Sstevel@tonic-gate return (zone->zone_pool); 33207c478bd9Sstevel@tonic-gate } 33217c478bd9Sstevel@tonic-gate 33227c478bd9Sstevel@tonic-gate /* 33237c478bd9Sstevel@tonic-gate * Set the zone's pool pointer and update the zone's visibility to match 33247c478bd9Sstevel@tonic-gate * the resources in the new pool. 33257c478bd9Sstevel@tonic-gate */ 33267c478bd9Sstevel@tonic-gate void 33277c478bd9Sstevel@tonic-gate zone_pool_set(zone_t *zone, pool_t *pool) 33287c478bd9Sstevel@tonic-gate { 33297c478bd9Sstevel@tonic-gate ASSERT(pool_lock_held()); 33307c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&cpu_lock)); 33317c478bd9Sstevel@tonic-gate 33327c478bd9Sstevel@tonic-gate zone->zone_pool = pool; 33337c478bd9Sstevel@tonic-gate zone_pset_set(zone, pool->pool_pset->pset_id); 33347c478bd9Sstevel@tonic-gate } 33357c478bd9Sstevel@tonic-gate 33367c478bd9Sstevel@tonic-gate /* 33377c478bd9Sstevel@tonic-gate * Return the cached value of the id of the processor set to which the 33387c478bd9Sstevel@tonic-gate * zone is currently bound. The value will be ZONE_PS_INVAL if the pools 33397c478bd9Sstevel@tonic-gate * facility is disabled. 33407c478bd9Sstevel@tonic-gate */ 33417c478bd9Sstevel@tonic-gate psetid_t 33427c478bd9Sstevel@tonic-gate zone_pset_get(zone_t *zone) 33437c478bd9Sstevel@tonic-gate { 33447c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&cpu_lock)); 33457c478bd9Sstevel@tonic-gate 33467c478bd9Sstevel@tonic-gate return (zone->zone_psetid); 33477c478bd9Sstevel@tonic-gate } 33487c478bd9Sstevel@tonic-gate 33497c478bd9Sstevel@tonic-gate /* 33507c478bd9Sstevel@tonic-gate * Set the cached value of the id of the processor set to which the zone 33517c478bd9Sstevel@tonic-gate * is currently bound. Also update the zone's visibility to match the 33527c478bd9Sstevel@tonic-gate * resources in the new processor set. 33537c478bd9Sstevel@tonic-gate */ 33547c478bd9Sstevel@tonic-gate void 33557c478bd9Sstevel@tonic-gate zone_pset_set(zone_t *zone, psetid_t newpsetid) 33567c478bd9Sstevel@tonic-gate { 33577c478bd9Sstevel@tonic-gate psetid_t oldpsetid; 33587c478bd9Sstevel@tonic-gate 33597c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&cpu_lock)); 33607c478bd9Sstevel@tonic-gate oldpsetid = zone_pset_get(zone); 33617c478bd9Sstevel@tonic-gate 33627c478bd9Sstevel@tonic-gate if (oldpsetid == newpsetid) 33637c478bd9Sstevel@tonic-gate return; 33647c478bd9Sstevel@tonic-gate /* 33657c478bd9Sstevel@tonic-gate * Global zone sees all. 33667c478bd9Sstevel@tonic-gate */ 33677c478bd9Sstevel@tonic-gate if (zone != global_zone) { 33687c478bd9Sstevel@tonic-gate zone->zone_psetid = newpsetid; 33697c478bd9Sstevel@tonic-gate if (newpsetid != ZONE_PS_INVAL) 33707c478bd9Sstevel@tonic-gate pool_pset_visibility_add(newpsetid, zone); 33717c478bd9Sstevel@tonic-gate if (oldpsetid != ZONE_PS_INVAL) 33727c478bd9Sstevel@tonic-gate pool_pset_visibility_remove(oldpsetid, zone); 33737c478bd9Sstevel@tonic-gate } 33747c478bd9Sstevel@tonic-gate /* 33757c478bd9Sstevel@tonic-gate * Disabling pools, so we should start using the global values 33767c478bd9Sstevel@tonic-gate * for ncpus and ncpus_online. 33777c478bd9Sstevel@tonic-gate */ 33787c478bd9Sstevel@tonic-gate if (newpsetid == ZONE_PS_INVAL) { 33797c478bd9Sstevel@tonic-gate zone->zone_ncpus = 0; 33807c478bd9Sstevel@tonic-gate zone->zone_ncpus_online = 0; 33817c478bd9Sstevel@tonic-gate } 33827c478bd9Sstevel@tonic-gate } 33837c478bd9Sstevel@tonic-gate 33847c478bd9Sstevel@tonic-gate /* 33857c478bd9Sstevel@tonic-gate * Walk the list of active zones and issue the provided callback for 33867c478bd9Sstevel@tonic-gate * each of them. 33877c478bd9Sstevel@tonic-gate * 33887c478bd9Sstevel@tonic-gate * Caller must not be holding any locks that may be acquired under 33897c478bd9Sstevel@tonic-gate * zonehash_lock. See comment at the beginning of the file for a list of 33907c478bd9Sstevel@tonic-gate * common locks and their interactions with zones. 33917c478bd9Sstevel@tonic-gate */ 33927c478bd9Sstevel@tonic-gate int 33937c478bd9Sstevel@tonic-gate zone_walk(int (*cb)(zone_t *, void *), void *data) 33947c478bd9Sstevel@tonic-gate { 33957c478bd9Sstevel@tonic-gate zone_t *zone; 33967c478bd9Sstevel@tonic-gate int ret = 0; 33977c478bd9Sstevel@tonic-gate zone_status_t status; 33987c478bd9Sstevel@tonic-gate 33997c478bd9Sstevel@tonic-gate mutex_enter(&zonehash_lock); 34007c478bd9Sstevel@tonic-gate for (zone = list_head(&zone_active); zone != NULL; 34017c478bd9Sstevel@tonic-gate zone = list_next(&zone_active, zone)) { 34027c478bd9Sstevel@tonic-gate /* 34037c478bd9Sstevel@tonic-gate * Skip zones that shouldn't be externally visible. 34047c478bd9Sstevel@tonic-gate */ 34057c478bd9Sstevel@tonic-gate status = zone_status_get(zone); 34067c478bd9Sstevel@tonic-gate if (status < ZONE_IS_READY || status > ZONE_IS_DOWN) 34077c478bd9Sstevel@tonic-gate continue; 34087c478bd9Sstevel@tonic-gate /* 34097c478bd9Sstevel@tonic-gate * Bail immediately if any callback invocation returns a 34107c478bd9Sstevel@tonic-gate * non-zero value. 34117c478bd9Sstevel@tonic-gate */ 34127c478bd9Sstevel@tonic-gate ret = (*cb)(zone, data); 34137c478bd9Sstevel@tonic-gate if (ret != 0) 34147c478bd9Sstevel@tonic-gate break; 34157c478bd9Sstevel@tonic-gate } 34167c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 34177c478bd9Sstevel@tonic-gate return (ret); 34187c478bd9Sstevel@tonic-gate } 34197c478bd9Sstevel@tonic-gate 34207c478bd9Sstevel@tonic-gate static int 34217c478bd9Sstevel@tonic-gate zone_set_root(zone_t *zone, const char *upath) 34227c478bd9Sstevel@tonic-gate { 34237c478bd9Sstevel@tonic-gate vnode_t *vp; 34247c478bd9Sstevel@tonic-gate int trycount; 34257c478bd9Sstevel@tonic-gate int error = 0; 34267c478bd9Sstevel@tonic-gate char *path; 34277c478bd9Sstevel@tonic-gate struct pathname upn, pn; 34287c478bd9Sstevel@tonic-gate size_t pathlen; 34297c478bd9Sstevel@tonic-gate 34307c478bd9Sstevel@tonic-gate if ((error = pn_get((char *)upath, UIO_USERSPACE, &upn)) != 0) 34317c478bd9Sstevel@tonic-gate return (error); 34327c478bd9Sstevel@tonic-gate 34337c478bd9Sstevel@tonic-gate pn_alloc(&pn); 34347c478bd9Sstevel@tonic-gate 34357c478bd9Sstevel@tonic-gate /* prevent infinite loop */ 34367c478bd9Sstevel@tonic-gate trycount = 10; 34377c478bd9Sstevel@tonic-gate for (;;) { 34387c478bd9Sstevel@tonic-gate if (--trycount <= 0) { 34397c478bd9Sstevel@tonic-gate error = ESTALE; 34407c478bd9Sstevel@tonic-gate goto out; 34417c478bd9Sstevel@tonic-gate } 34427c478bd9Sstevel@tonic-gate 34437c478bd9Sstevel@tonic-gate if ((error = lookuppn(&upn, &pn, FOLLOW, NULLVPP, &vp)) == 0) { 34447c478bd9Sstevel@tonic-gate /* 34457c478bd9Sstevel@tonic-gate * VOP_ACCESS() may cover 'vp' with a new 34467c478bd9Sstevel@tonic-gate * filesystem, if 'vp' is an autoFS vnode. 34477c478bd9Sstevel@tonic-gate * Get the new 'vp' if so. 34487c478bd9Sstevel@tonic-gate */ 3449da6c28aaSamw if ((error = 3450da6c28aaSamw VOP_ACCESS(vp, VEXEC, 0, CRED(), NULL)) == 0 && 345125d2dc23Seh (!vn_ismntpt(vp) || 34527c478bd9Sstevel@tonic-gate (error = traverse(&vp)) == 0)) { 34537c478bd9Sstevel@tonic-gate pathlen = pn.pn_pathlen + 2; 34547c478bd9Sstevel@tonic-gate path = kmem_alloc(pathlen, KM_SLEEP); 34557c478bd9Sstevel@tonic-gate (void) strncpy(path, pn.pn_path, 34567c478bd9Sstevel@tonic-gate pn.pn_pathlen + 1); 34577c478bd9Sstevel@tonic-gate path[pathlen - 2] = '/'; 34587c478bd9Sstevel@tonic-gate path[pathlen - 1] = '\0'; 34597c478bd9Sstevel@tonic-gate pn_free(&pn); 34607c478bd9Sstevel@tonic-gate pn_free(&upn); 34617c478bd9Sstevel@tonic-gate 34627c478bd9Sstevel@tonic-gate /* Success! */ 34637c478bd9Sstevel@tonic-gate break; 34647c478bd9Sstevel@tonic-gate } 34657c478bd9Sstevel@tonic-gate VN_RELE(vp); 34667c478bd9Sstevel@tonic-gate } 34677c478bd9Sstevel@tonic-gate if (error != ESTALE) 34687c478bd9Sstevel@tonic-gate goto out; 34697c478bd9Sstevel@tonic-gate } 34707c478bd9Sstevel@tonic-gate 34717c478bd9Sstevel@tonic-gate ASSERT(error == 0); 34727c478bd9Sstevel@tonic-gate zone->zone_rootvp = vp; /* we hold a reference to vp */ 34737c478bd9Sstevel@tonic-gate zone->zone_rootpath = path; 34747c478bd9Sstevel@tonic-gate zone->zone_rootpathlen = pathlen; 347548451833Scarlsonj if (pathlen > 5 && strcmp(path + pathlen - 5, "/lu/") == 0) 347648451833Scarlsonj zone->zone_flags |= ZF_IS_SCRATCH; 34777c478bd9Sstevel@tonic-gate return (0); 34787c478bd9Sstevel@tonic-gate 34797c478bd9Sstevel@tonic-gate out: 34807c478bd9Sstevel@tonic-gate pn_free(&pn); 34817c478bd9Sstevel@tonic-gate pn_free(&upn); 34827c478bd9Sstevel@tonic-gate return (error); 34837c478bd9Sstevel@tonic-gate } 34847c478bd9Sstevel@tonic-gate 34857c478bd9Sstevel@tonic-gate #define isalnum(c) (((c) >= '0' && (c) <= '9') || \ 34867c478bd9Sstevel@tonic-gate ((c) >= 'a' && (c) <= 'z') || \ 34877c478bd9Sstevel@tonic-gate ((c) >= 'A' && (c) <= 'Z')) 34887c478bd9Sstevel@tonic-gate 34897c478bd9Sstevel@tonic-gate static int 34907c478bd9Sstevel@tonic-gate zone_set_name(zone_t *zone, const char *uname) 34917c478bd9Sstevel@tonic-gate { 34927c478bd9Sstevel@tonic-gate char *kname = kmem_zalloc(ZONENAME_MAX, KM_SLEEP); 34937c478bd9Sstevel@tonic-gate size_t len; 34947c478bd9Sstevel@tonic-gate int i, err; 34957c478bd9Sstevel@tonic-gate 34967c478bd9Sstevel@tonic-gate if ((err = copyinstr(uname, kname, ZONENAME_MAX, &len)) != 0) { 34977c478bd9Sstevel@tonic-gate kmem_free(kname, ZONENAME_MAX); 34987c478bd9Sstevel@tonic-gate return (err); /* EFAULT or ENAMETOOLONG */ 34997c478bd9Sstevel@tonic-gate } 35007c478bd9Sstevel@tonic-gate 35017c478bd9Sstevel@tonic-gate /* must be less than ZONENAME_MAX */ 35027c478bd9Sstevel@tonic-gate if (len == ZONENAME_MAX && kname[ZONENAME_MAX - 1] != '\0') { 35037c478bd9Sstevel@tonic-gate kmem_free(kname, ZONENAME_MAX); 35047c478bd9Sstevel@tonic-gate return (EINVAL); 35057c478bd9Sstevel@tonic-gate } 35067c478bd9Sstevel@tonic-gate 35077c478bd9Sstevel@tonic-gate /* 35087c478bd9Sstevel@tonic-gate * Name must start with an alphanumeric and must contain only 35097c478bd9Sstevel@tonic-gate * alphanumerics, '-', '_' and '.'. 35107c478bd9Sstevel@tonic-gate */ 35117c478bd9Sstevel@tonic-gate if (!isalnum(kname[0])) { 35127c478bd9Sstevel@tonic-gate kmem_free(kname, ZONENAME_MAX); 35137c478bd9Sstevel@tonic-gate return (EINVAL); 35147c478bd9Sstevel@tonic-gate } 35157c478bd9Sstevel@tonic-gate for (i = 1; i < len - 1; i++) { 35167c478bd9Sstevel@tonic-gate if (!isalnum(kname[i]) && kname[i] != '-' && kname[i] != '_' && 35177c478bd9Sstevel@tonic-gate kname[i] != '.') { 35187c478bd9Sstevel@tonic-gate kmem_free(kname, ZONENAME_MAX); 35197c478bd9Sstevel@tonic-gate return (EINVAL); 35207c478bd9Sstevel@tonic-gate } 35217c478bd9Sstevel@tonic-gate } 35227c478bd9Sstevel@tonic-gate 35237c478bd9Sstevel@tonic-gate zone->zone_name = kname; 35247c478bd9Sstevel@tonic-gate return (0); 35257c478bd9Sstevel@tonic-gate } 35267c478bd9Sstevel@tonic-gate 35275679c89fSjv /* 35285679c89fSjv * Gets the 32-bit hostid of the specified zone as an unsigned int. If 'zonep' 35295679c89fSjv * is NULL or it points to a zone with no hostid emulation, then the machine's 35305679c89fSjv * hostid (i.e., the global zone's hostid) is returned. This function returns 35315679c89fSjv * zero if neither the zone nor the host machine (global zone) have hostids. It 35325679c89fSjv * returns HW_INVALID_HOSTID if the function attempts to return the machine's 35335679c89fSjv * hostid and the machine's hostid is invalid. 35345679c89fSjv */ 35355679c89fSjv uint32_t 35365679c89fSjv zone_get_hostid(zone_t *zonep) 35375679c89fSjv { 35385679c89fSjv unsigned long machine_hostid; 35395679c89fSjv 35405679c89fSjv if (zonep == NULL || zonep->zone_hostid == HW_INVALID_HOSTID) { 35415679c89fSjv if (ddi_strtoul(hw_serial, NULL, 10, &machine_hostid) != 0) 35425679c89fSjv return (HW_INVALID_HOSTID); 35435679c89fSjv return ((uint32_t)machine_hostid); 35445679c89fSjv } 35455679c89fSjv return (zonep->zone_hostid); 35465679c89fSjv } 35475679c89fSjv 35487c478bd9Sstevel@tonic-gate /* 35497c478bd9Sstevel@tonic-gate * Similar to thread_create(), but makes sure the thread is in the appropriate 35507c478bd9Sstevel@tonic-gate * zone's zsched process (curproc->p_zone->zone_zsched) before returning. 35517c478bd9Sstevel@tonic-gate */ 35527c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 35537c478bd9Sstevel@tonic-gate kthread_t * 35547c478bd9Sstevel@tonic-gate zthread_create( 35557c478bd9Sstevel@tonic-gate caddr_t stk, 35567c478bd9Sstevel@tonic-gate size_t stksize, 35577c478bd9Sstevel@tonic-gate void (*proc)(), 35587c478bd9Sstevel@tonic-gate void *arg, 35597c478bd9Sstevel@tonic-gate size_t len, 35607c478bd9Sstevel@tonic-gate pri_t pri) 35617c478bd9Sstevel@tonic-gate { 35627c478bd9Sstevel@tonic-gate kthread_t *t; 35637c478bd9Sstevel@tonic-gate zone_t *zone = curproc->p_zone; 35647c478bd9Sstevel@tonic-gate proc_t *pp = zone->zone_zsched; 35657c478bd9Sstevel@tonic-gate 35667c478bd9Sstevel@tonic-gate zone_hold(zone); /* Reference to be dropped when thread exits */ 35677c478bd9Sstevel@tonic-gate 35687c478bd9Sstevel@tonic-gate /* 35697c478bd9Sstevel@tonic-gate * No-one should be trying to create threads if the zone is shutting 35707c478bd9Sstevel@tonic-gate * down and there aren't any kernel threads around. See comment 35717c478bd9Sstevel@tonic-gate * in zthread_exit(). 35727c478bd9Sstevel@tonic-gate */ 35737c478bd9Sstevel@tonic-gate ASSERT(!(zone->zone_kthreads == NULL && 35747c478bd9Sstevel@tonic-gate zone_status_get(zone) >= ZONE_IS_EMPTY)); 35757c478bd9Sstevel@tonic-gate /* 35767c478bd9Sstevel@tonic-gate * Create a thread, but don't let it run until we've finished setting 35777c478bd9Sstevel@tonic-gate * things up. 35787c478bd9Sstevel@tonic-gate */ 35797c478bd9Sstevel@tonic-gate t = thread_create(stk, stksize, proc, arg, len, pp, TS_STOPPED, pri); 35807c478bd9Sstevel@tonic-gate ASSERT(t->t_forw == NULL); 35817c478bd9Sstevel@tonic-gate mutex_enter(&zone_status_lock); 35827c478bd9Sstevel@tonic-gate if (zone->zone_kthreads == NULL) { 35837c478bd9Sstevel@tonic-gate t->t_forw = t->t_back = t; 35847c478bd9Sstevel@tonic-gate } else { 35857c478bd9Sstevel@tonic-gate kthread_t *tx = zone->zone_kthreads; 35867c478bd9Sstevel@tonic-gate 35877c478bd9Sstevel@tonic-gate t->t_forw = tx; 35887c478bd9Sstevel@tonic-gate t->t_back = tx->t_back; 35897c478bd9Sstevel@tonic-gate tx->t_back->t_forw = t; 35907c478bd9Sstevel@tonic-gate tx->t_back = t; 35917c478bd9Sstevel@tonic-gate } 35927c478bd9Sstevel@tonic-gate zone->zone_kthreads = t; 35937c478bd9Sstevel@tonic-gate mutex_exit(&zone_status_lock); 35947c478bd9Sstevel@tonic-gate 35957c478bd9Sstevel@tonic-gate mutex_enter(&pp->p_lock); 35967c478bd9Sstevel@tonic-gate t->t_proc_flag |= TP_ZTHREAD; 35977c478bd9Sstevel@tonic-gate project_rele(t->t_proj); 35987c478bd9Sstevel@tonic-gate t->t_proj = project_hold(pp->p_task->tk_proj); 35997c478bd9Sstevel@tonic-gate 36007c478bd9Sstevel@tonic-gate /* 36017c478bd9Sstevel@tonic-gate * Setup complete, let it run. 36027c478bd9Sstevel@tonic-gate */ 36037c478bd9Sstevel@tonic-gate thread_lock(t); 36047c478bd9Sstevel@tonic-gate t->t_schedflag |= TS_ALLSTART; 36057c478bd9Sstevel@tonic-gate setrun_locked(t); 36067c478bd9Sstevel@tonic-gate thread_unlock(t); 36077c478bd9Sstevel@tonic-gate 36087c478bd9Sstevel@tonic-gate mutex_exit(&pp->p_lock); 36097c478bd9Sstevel@tonic-gate 36107c478bd9Sstevel@tonic-gate return (t); 36117c478bd9Sstevel@tonic-gate } 36127c478bd9Sstevel@tonic-gate 36137c478bd9Sstevel@tonic-gate /* 36147c478bd9Sstevel@tonic-gate * Similar to thread_exit(). Must be called by threads created via 36157c478bd9Sstevel@tonic-gate * zthread_exit(). 36167c478bd9Sstevel@tonic-gate */ 36177c478bd9Sstevel@tonic-gate void 36187c478bd9Sstevel@tonic-gate zthread_exit(void) 36197c478bd9Sstevel@tonic-gate { 36207c478bd9Sstevel@tonic-gate kthread_t *t = curthread; 36217c478bd9Sstevel@tonic-gate proc_t *pp = curproc; 36227c478bd9Sstevel@tonic-gate zone_t *zone = pp->p_zone; 36237c478bd9Sstevel@tonic-gate 36247c478bd9Sstevel@tonic-gate mutex_enter(&zone_status_lock); 36257c478bd9Sstevel@tonic-gate 36267c478bd9Sstevel@tonic-gate /* 36277c478bd9Sstevel@tonic-gate * Reparent to p0 36287c478bd9Sstevel@tonic-gate */ 3629b4b07f87Sjosephb kpreempt_disable(); 36307c478bd9Sstevel@tonic-gate mutex_enter(&pp->p_lock); 36317c478bd9Sstevel@tonic-gate t->t_proc_flag &= ~TP_ZTHREAD; 36327c478bd9Sstevel@tonic-gate t->t_procp = &p0; 36337c478bd9Sstevel@tonic-gate hat_thread_exit(t); 36347c478bd9Sstevel@tonic-gate mutex_exit(&pp->p_lock); 3635b4b07f87Sjosephb kpreempt_enable(); 36367c478bd9Sstevel@tonic-gate 36377c478bd9Sstevel@tonic-gate if (t->t_back == t) { 36387c478bd9Sstevel@tonic-gate ASSERT(t->t_forw == t); 36397c478bd9Sstevel@tonic-gate /* 36407c478bd9Sstevel@tonic-gate * If the zone is empty, once the thread count 36417c478bd9Sstevel@tonic-gate * goes to zero no further kernel threads can be 36427c478bd9Sstevel@tonic-gate * created. This is because if the creator is a process 36437c478bd9Sstevel@tonic-gate * in the zone, then it must have exited before the zone 36447c478bd9Sstevel@tonic-gate * state could be set to ZONE_IS_EMPTY. 36457c478bd9Sstevel@tonic-gate * Otherwise, if the creator is a kernel thread in the 36467c478bd9Sstevel@tonic-gate * zone, the thread count is non-zero. 36477c478bd9Sstevel@tonic-gate * 36487c478bd9Sstevel@tonic-gate * This really means that non-zone kernel threads should 36497c478bd9Sstevel@tonic-gate * not create zone kernel threads. 36507c478bd9Sstevel@tonic-gate */ 36517c478bd9Sstevel@tonic-gate zone->zone_kthreads = NULL; 36527c478bd9Sstevel@tonic-gate if (zone_status_get(zone) == ZONE_IS_EMPTY) { 36537c478bd9Sstevel@tonic-gate zone_status_set(zone, ZONE_IS_DOWN); 3654c97ad5cdSakolb /* 3655c97ad5cdSakolb * Remove any CPU caps on this zone. 3656c97ad5cdSakolb */ 3657c97ad5cdSakolb cpucaps_zone_remove(zone); 36587c478bd9Sstevel@tonic-gate } 36597c478bd9Sstevel@tonic-gate } else { 36607c478bd9Sstevel@tonic-gate t->t_forw->t_back = t->t_back; 36617c478bd9Sstevel@tonic-gate t->t_back->t_forw = t->t_forw; 36627c478bd9Sstevel@tonic-gate if (zone->zone_kthreads == t) 36637c478bd9Sstevel@tonic-gate zone->zone_kthreads = t->t_forw; 36647c478bd9Sstevel@tonic-gate } 36657c478bd9Sstevel@tonic-gate mutex_exit(&zone_status_lock); 36667c478bd9Sstevel@tonic-gate zone_rele(zone); 36677c478bd9Sstevel@tonic-gate thread_exit(); 36687c478bd9Sstevel@tonic-gate /* NOTREACHED */ 36697c478bd9Sstevel@tonic-gate } 36707c478bd9Sstevel@tonic-gate 36717c478bd9Sstevel@tonic-gate static void 36727c478bd9Sstevel@tonic-gate zone_chdir(vnode_t *vp, vnode_t **vpp, proc_t *pp) 36737c478bd9Sstevel@tonic-gate { 36747c478bd9Sstevel@tonic-gate vnode_t *oldvp; 36757c478bd9Sstevel@tonic-gate 36767c478bd9Sstevel@tonic-gate /* we're going to hold a reference here to the directory */ 36777c478bd9Sstevel@tonic-gate VN_HOLD(vp); 36787c478bd9Sstevel@tonic-gate 3679005d3febSMarek Pospisil /* update abs cwd/root path see c2/audit.c */ 3680005d3febSMarek Pospisil if (AU_AUDITING()) 36817c478bd9Sstevel@tonic-gate audit_chdirec(vp, vpp); 36827c478bd9Sstevel@tonic-gate 36837c478bd9Sstevel@tonic-gate mutex_enter(&pp->p_lock); 36847c478bd9Sstevel@tonic-gate oldvp = *vpp; 36857c478bd9Sstevel@tonic-gate *vpp = vp; 36867c478bd9Sstevel@tonic-gate mutex_exit(&pp->p_lock); 36877c478bd9Sstevel@tonic-gate if (oldvp != NULL) 36887c478bd9Sstevel@tonic-gate VN_RELE(oldvp); 36897c478bd9Sstevel@tonic-gate } 36907c478bd9Sstevel@tonic-gate 36917c478bd9Sstevel@tonic-gate /* 36927c478bd9Sstevel@tonic-gate * Convert an rctl value represented by an nvlist_t into an rctl_val_t. 36937c478bd9Sstevel@tonic-gate */ 36947c478bd9Sstevel@tonic-gate static int 36957c478bd9Sstevel@tonic-gate nvlist2rctlval(nvlist_t *nvl, rctl_val_t *rv) 36967c478bd9Sstevel@tonic-gate { 36977c478bd9Sstevel@tonic-gate nvpair_t *nvp = NULL; 36987c478bd9Sstevel@tonic-gate boolean_t priv_set = B_FALSE; 36997c478bd9Sstevel@tonic-gate boolean_t limit_set = B_FALSE; 37007c478bd9Sstevel@tonic-gate boolean_t action_set = B_FALSE; 37017c478bd9Sstevel@tonic-gate 37027c478bd9Sstevel@tonic-gate while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) { 37037c478bd9Sstevel@tonic-gate const char *name; 37047c478bd9Sstevel@tonic-gate uint64_t ui64; 37057c478bd9Sstevel@tonic-gate 37067c478bd9Sstevel@tonic-gate name = nvpair_name(nvp); 37077c478bd9Sstevel@tonic-gate if (nvpair_type(nvp) != DATA_TYPE_UINT64) 37087c478bd9Sstevel@tonic-gate return (EINVAL); 37097c478bd9Sstevel@tonic-gate (void) nvpair_value_uint64(nvp, &ui64); 37107c478bd9Sstevel@tonic-gate if (strcmp(name, "privilege") == 0) { 37117c478bd9Sstevel@tonic-gate /* 37127c478bd9Sstevel@tonic-gate * Currently only privileged values are allowed, but 37137c478bd9Sstevel@tonic-gate * this may change in the future. 37147c478bd9Sstevel@tonic-gate */ 37157c478bd9Sstevel@tonic-gate if (ui64 != RCPRIV_PRIVILEGED) 37167c478bd9Sstevel@tonic-gate return (EINVAL); 37177c478bd9Sstevel@tonic-gate rv->rcv_privilege = ui64; 37187c478bd9Sstevel@tonic-gate priv_set = B_TRUE; 37197c478bd9Sstevel@tonic-gate } else if (strcmp(name, "limit") == 0) { 37207c478bd9Sstevel@tonic-gate rv->rcv_value = ui64; 37217c478bd9Sstevel@tonic-gate limit_set = B_TRUE; 37227c478bd9Sstevel@tonic-gate } else if (strcmp(name, "action") == 0) { 37237c478bd9Sstevel@tonic-gate if (ui64 != RCTL_LOCAL_NOACTION && 37247c478bd9Sstevel@tonic-gate ui64 != RCTL_LOCAL_DENY) 37257c478bd9Sstevel@tonic-gate return (EINVAL); 37267c478bd9Sstevel@tonic-gate rv->rcv_flagaction = ui64; 37277c478bd9Sstevel@tonic-gate action_set = B_TRUE; 37287c478bd9Sstevel@tonic-gate } else { 37297c478bd9Sstevel@tonic-gate return (EINVAL); 37307c478bd9Sstevel@tonic-gate } 37317c478bd9Sstevel@tonic-gate } 37327c478bd9Sstevel@tonic-gate 37337c478bd9Sstevel@tonic-gate if (!(priv_set && limit_set && action_set)) 37347c478bd9Sstevel@tonic-gate return (EINVAL); 37357c478bd9Sstevel@tonic-gate rv->rcv_action_signal = 0; 37367c478bd9Sstevel@tonic-gate rv->rcv_action_recipient = NULL; 37377c478bd9Sstevel@tonic-gate rv->rcv_action_recip_pid = -1; 37387c478bd9Sstevel@tonic-gate rv->rcv_firing_time = 0; 37397c478bd9Sstevel@tonic-gate 37407c478bd9Sstevel@tonic-gate return (0); 37417c478bd9Sstevel@tonic-gate } 37427c478bd9Sstevel@tonic-gate 37433f2f09c1Sdp /* 37443f2f09c1Sdp * Non-global zone version of start_init. 37453f2f09c1Sdp */ 37467c478bd9Sstevel@tonic-gate void 37473f2f09c1Sdp zone_start_init(void) 37487c478bd9Sstevel@tonic-gate { 37497c478bd9Sstevel@tonic-gate proc_t *p = ttoproc(curthread); 37509acbbeafSnn zone_t *z = p->p_zone; 37517c478bd9Sstevel@tonic-gate 37523f2f09c1Sdp ASSERT(!INGLOBALZONE(curproc)); 37537c478bd9Sstevel@tonic-gate 37549acbbeafSnn /* 37559acbbeafSnn * For all purposes (ZONE_ATTR_INITPID and restart_init), 37569acbbeafSnn * storing just the pid of init is sufficient. 37579acbbeafSnn */ 37589acbbeafSnn z->zone_proc_initpid = p->p_pid; 37599acbbeafSnn 37607c478bd9Sstevel@tonic-gate /* 37613f2f09c1Sdp * We maintain zone_boot_err so that we can return the cause of the 37623f2f09c1Sdp * failure back to the caller of the zone_boot syscall. 37637c478bd9Sstevel@tonic-gate */ 37643f2f09c1Sdp p->p_zone->zone_boot_err = start_init_common(); 37657c478bd9Sstevel@tonic-gate 37668f983ab3Sjv /* 37678f983ab3Sjv * We will prevent booting zones from becoming running zones if the 37688f983ab3Sjv * global zone is shutting down. 37698f983ab3Sjv */ 37707c478bd9Sstevel@tonic-gate mutex_enter(&zone_status_lock); 37718f983ab3Sjv if (z->zone_boot_err != 0 || zone_status_get(global_zone) >= 37728f983ab3Sjv ZONE_IS_SHUTTING_DOWN) { 37737c478bd9Sstevel@tonic-gate /* 37747c478bd9Sstevel@tonic-gate * Make sure we are still in the booting state-- we could have 37757c478bd9Sstevel@tonic-gate * raced and already be shutting down, or even further along. 37767c478bd9Sstevel@tonic-gate */ 3777c97ad5cdSakolb if (zone_status_get(z) == ZONE_IS_BOOTING) { 37789acbbeafSnn zone_status_set(z, ZONE_IS_SHUTTING_DOWN); 3779c97ad5cdSakolb } 37807c478bd9Sstevel@tonic-gate mutex_exit(&zone_status_lock); 37817c478bd9Sstevel@tonic-gate /* It's gone bad, dispose of the process */ 37829acbbeafSnn if (proc_exit(CLD_EXITED, z->zone_boot_err) != 0) { 378397eda132Sraf mutex_enter(&p->p_lock); 378497eda132Sraf ASSERT(p->p_flag & SEXITLWPS); 37857c478bd9Sstevel@tonic-gate lwp_exit(); 37867c478bd9Sstevel@tonic-gate } 37877c478bd9Sstevel@tonic-gate } else { 37889acbbeafSnn if (zone_status_get(z) == ZONE_IS_BOOTING) 37899acbbeafSnn zone_status_set(z, ZONE_IS_RUNNING); 37907c478bd9Sstevel@tonic-gate mutex_exit(&zone_status_lock); 37917c478bd9Sstevel@tonic-gate /* cause the process to return to userland. */ 37927c478bd9Sstevel@tonic-gate lwp_rtt(); 37937c478bd9Sstevel@tonic-gate } 37947c478bd9Sstevel@tonic-gate } 37957c478bd9Sstevel@tonic-gate 37967c478bd9Sstevel@tonic-gate struct zsched_arg { 37977c478bd9Sstevel@tonic-gate zone_t *zone; 37987c478bd9Sstevel@tonic-gate nvlist_t *nvlist; 37997c478bd9Sstevel@tonic-gate }; 38007c478bd9Sstevel@tonic-gate 38017c478bd9Sstevel@tonic-gate /* 38027c478bd9Sstevel@tonic-gate * Per-zone "sched" workalike. The similarity to "sched" doesn't have 38037c478bd9Sstevel@tonic-gate * anything to do with scheduling, but rather with the fact that 38047c478bd9Sstevel@tonic-gate * per-zone kernel threads are parented to zsched, just like regular 38057c478bd9Sstevel@tonic-gate * kernel threads are parented to sched (p0). 38067c478bd9Sstevel@tonic-gate * 38077c478bd9Sstevel@tonic-gate * zsched is also responsible for launching init for the zone. 38087c478bd9Sstevel@tonic-gate */ 38097c478bd9Sstevel@tonic-gate static void 38107c478bd9Sstevel@tonic-gate zsched(void *arg) 38117c478bd9Sstevel@tonic-gate { 38127c478bd9Sstevel@tonic-gate struct zsched_arg *za = arg; 38137c478bd9Sstevel@tonic-gate proc_t *pp = curproc; 38147c478bd9Sstevel@tonic-gate proc_t *initp = proc_init; 38157c478bd9Sstevel@tonic-gate zone_t *zone = za->zone; 38167c478bd9Sstevel@tonic-gate cred_t *cr, *oldcred; 38177c478bd9Sstevel@tonic-gate rctl_set_t *set; 38187c478bd9Sstevel@tonic-gate rctl_alloc_gp_t *gp; 38197c478bd9Sstevel@tonic-gate contract_t *ct = NULL; 38207c478bd9Sstevel@tonic-gate task_t *tk, *oldtk; 38217c478bd9Sstevel@tonic-gate rctl_entity_p_t e; 38227c478bd9Sstevel@tonic-gate kproject_t *pj; 38237c478bd9Sstevel@tonic-gate 38247c478bd9Sstevel@tonic-gate nvlist_t *nvl = za->nvlist; 38257c478bd9Sstevel@tonic-gate nvpair_t *nvp = NULL; 38267c478bd9Sstevel@tonic-gate 3827ae115bc7Smrj bcopy("zsched", PTOU(pp)->u_psargs, sizeof ("zsched")); 3828ae115bc7Smrj bcopy("zsched", PTOU(pp)->u_comm, sizeof ("zsched")); 3829ae115bc7Smrj PTOU(pp)->u_argc = 0; 3830ae115bc7Smrj PTOU(pp)->u_argv = NULL; 3831ae115bc7Smrj PTOU(pp)->u_envp = NULL; 38322428aad8SPatrick Mooney PTOU(pp)->u_commpagep = NULL; 38337c478bd9Sstevel@tonic-gate closeall(P_FINFO(pp)); 38347c478bd9Sstevel@tonic-gate 38357c478bd9Sstevel@tonic-gate /* 38367c478bd9Sstevel@tonic-gate * We are this zone's "zsched" process. As the zone isn't generally 38377c478bd9Sstevel@tonic-gate * visible yet we don't need to grab any locks before initializing its 38387c478bd9Sstevel@tonic-gate * zone_proc pointer. 38397c478bd9Sstevel@tonic-gate */ 38407c478bd9Sstevel@tonic-gate zone_hold(zone); /* this hold is released by zone_destroy() */ 38417c478bd9Sstevel@tonic-gate zone->zone_zsched = pp; 38427c478bd9Sstevel@tonic-gate mutex_enter(&pp->p_lock); 38437c478bd9Sstevel@tonic-gate pp->p_zone = zone; 38447c478bd9Sstevel@tonic-gate mutex_exit(&pp->p_lock); 38457c478bd9Sstevel@tonic-gate 38467c478bd9Sstevel@tonic-gate /* 38477c478bd9Sstevel@tonic-gate * Disassociate process from its 'parent'; parent ourselves to init 38487c478bd9Sstevel@tonic-gate * (pid 1) and change other values as needed. 38497c478bd9Sstevel@tonic-gate */ 38507c478bd9Sstevel@tonic-gate sess_create(); 38517c478bd9Sstevel@tonic-gate 38527c478bd9Sstevel@tonic-gate mutex_enter(&pidlock); 38537c478bd9Sstevel@tonic-gate proc_detach(pp); 38547c478bd9Sstevel@tonic-gate pp->p_ppid = 1; 38557c478bd9Sstevel@tonic-gate pp->p_flag |= SZONETOP; 38567c478bd9Sstevel@tonic-gate pp->p_ancpid = 1; 38577c478bd9Sstevel@tonic-gate pp->p_parent = initp; 38587c478bd9Sstevel@tonic-gate pp->p_psibling = NULL; 38597c478bd9Sstevel@tonic-gate if (initp->p_child) 38607c478bd9Sstevel@tonic-gate initp->p_child->p_psibling = pp; 38617c478bd9Sstevel@tonic-gate pp->p_sibling = initp->p_child; 38627c478bd9Sstevel@tonic-gate initp->p_child = pp; 38637c478bd9Sstevel@tonic-gate 38647c478bd9Sstevel@tonic-gate /* Decrement what newproc() incremented. */ 38657c478bd9Sstevel@tonic-gate upcount_dec(crgetruid(CRED()), GLOBAL_ZONEID); 38667c478bd9Sstevel@tonic-gate /* 38677c478bd9Sstevel@tonic-gate * Our credentials are about to become kcred-like, so we don't care 38687c478bd9Sstevel@tonic-gate * about the caller's ruid. 38697c478bd9Sstevel@tonic-gate */ 38707c478bd9Sstevel@tonic-gate upcount_inc(crgetruid(kcred), zone->zone_id); 38717c478bd9Sstevel@tonic-gate mutex_exit(&pidlock); 38727c478bd9Sstevel@tonic-gate 38737c478bd9Sstevel@tonic-gate /* 3874ff19e029SMenno Lageman * getting out of global zone, so decrement lwp and process counts 38757c478bd9Sstevel@tonic-gate */ 38767c478bd9Sstevel@tonic-gate pj = pp->p_task->tk_proj; 38777c478bd9Sstevel@tonic-gate mutex_enter(&global_zone->zone_nlwps_lock); 38787c478bd9Sstevel@tonic-gate pj->kpj_nlwps -= pp->p_lwpcnt; 38797c478bd9Sstevel@tonic-gate global_zone->zone_nlwps -= pp->p_lwpcnt; 3880ff19e029SMenno Lageman pj->kpj_nprocs--; 3881ff19e029SMenno Lageman global_zone->zone_nprocs--; 38827c478bd9Sstevel@tonic-gate mutex_exit(&global_zone->zone_nlwps_lock); 38837c478bd9Sstevel@tonic-gate 3884c6939658Ssl /* 3885c6939658Ssl * Decrement locked memory counts on old zone and project. 3886c6939658Ssl */ 38870209230bSgjelinek mutex_enter(&global_zone->zone_mem_lock); 3888c6939658Ssl global_zone->zone_locked_mem -= pp->p_locked_mem; 3889c6939658Ssl pj->kpj_data.kpd_locked_mem -= pp->p_locked_mem; 38900209230bSgjelinek mutex_exit(&global_zone->zone_mem_lock); 3891c6939658Ssl 38927c478bd9Sstevel@tonic-gate /* 38937c478bd9Sstevel@tonic-gate * Create and join a new task in project '0' of this zone. 38947c478bd9Sstevel@tonic-gate * 38957c478bd9Sstevel@tonic-gate * We don't need to call holdlwps() since we know we're the only lwp in 38967c478bd9Sstevel@tonic-gate * this process. 38977c478bd9Sstevel@tonic-gate * 38987c478bd9Sstevel@tonic-gate * task_join() returns with p_lock held. 38997c478bd9Sstevel@tonic-gate */ 39007c478bd9Sstevel@tonic-gate tk = task_create(0, zone); 39017c478bd9Sstevel@tonic-gate mutex_enter(&cpu_lock); 39027c478bd9Sstevel@tonic-gate oldtk = task_join(tk, 0); 3903c6939658Ssl 3904c6939658Ssl pj = pp->p_task->tk_proj; 3905c6939658Ssl 39060209230bSgjelinek mutex_enter(&zone->zone_mem_lock); 3907c6939658Ssl zone->zone_locked_mem += pp->p_locked_mem; 3908c6939658Ssl pj->kpj_data.kpd_locked_mem += pp->p_locked_mem; 39090209230bSgjelinek mutex_exit(&zone->zone_mem_lock); 39107c478bd9Sstevel@tonic-gate 39117c478bd9Sstevel@tonic-gate /* 3912ff19e029SMenno Lageman * add lwp and process counts to zsched's zone, and increment 3913ff19e029SMenno Lageman * project's task and process count due to the task created in 3914ff19e029SMenno Lageman * the above task_create. 39157c478bd9Sstevel@tonic-gate */ 39167c478bd9Sstevel@tonic-gate mutex_enter(&zone->zone_nlwps_lock); 39177c478bd9Sstevel@tonic-gate pj->kpj_nlwps += pp->p_lwpcnt; 39187c478bd9Sstevel@tonic-gate pj->kpj_ntasks += 1; 39197c478bd9Sstevel@tonic-gate zone->zone_nlwps += pp->p_lwpcnt; 3920ff19e029SMenno Lageman pj->kpj_nprocs++; 3921ff19e029SMenno Lageman zone->zone_nprocs++; 39227c478bd9Sstevel@tonic-gate mutex_exit(&zone->zone_nlwps_lock); 39237c478bd9Sstevel@tonic-gate 3924c6939658Ssl mutex_exit(&curproc->p_lock); 3925c6939658Ssl mutex_exit(&cpu_lock); 3926c6939658Ssl task_rele(oldtk); 3927c6939658Ssl 39287c478bd9Sstevel@tonic-gate /* 39297c478bd9Sstevel@tonic-gate * The process was created by a process in the global zone, hence the 39307c478bd9Sstevel@tonic-gate * credentials are wrong. We might as well have kcred-ish credentials. 39317c478bd9Sstevel@tonic-gate */ 39327c478bd9Sstevel@tonic-gate cr = zone->zone_kcred; 39337c478bd9Sstevel@tonic-gate crhold(cr); 39347c478bd9Sstevel@tonic-gate mutex_enter(&pp->p_crlock); 39357c478bd9Sstevel@tonic-gate oldcred = pp->p_cred; 39367c478bd9Sstevel@tonic-gate pp->p_cred = cr; 39377c478bd9Sstevel@tonic-gate mutex_exit(&pp->p_crlock); 39387c478bd9Sstevel@tonic-gate crfree(oldcred); 39397c478bd9Sstevel@tonic-gate 39407c478bd9Sstevel@tonic-gate /* 39417c478bd9Sstevel@tonic-gate * Hold credentials again (for thread) 39427c478bd9Sstevel@tonic-gate */ 39437c478bd9Sstevel@tonic-gate crhold(cr); 39447c478bd9Sstevel@tonic-gate 39457c478bd9Sstevel@tonic-gate /* 39467c478bd9Sstevel@tonic-gate * p_lwpcnt can't change since this is a kernel process. 39477c478bd9Sstevel@tonic-gate */ 39487c478bd9Sstevel@tonic-gate crset(pp, cr); 39497c478bd9Sstevel@tonic-gate 39507c478bd9Sstevel@tonic-gate /* 39517c478bd9Sstevel@tonic-gate * Chroot 39527c478bd9Sstevel@tonic-gate */ 39537c478bd9Sstevel@tonic-gate zone_chdir(zone->zone_rootvp, &PTOU(pp)->u_cdir, pp); 39547c478bd9Sstevel@tonic-gate zone_chdir(zone->zone_rootvp, &PTOU(pp)->u_rdir, pp); 39557c478bd9Sstevel@tonic-gate 39567c478bd9Sstevel@tonic-gate /* 39577c478bd9Sstevel@tonic-gate * Initialize zone's rctl set. 39587c478bd9Sstevel@tonic-gate */ 39597c478bd9Sstevel@tonic-gate set = rctl_set_create(); 39607c478bd9Sstevel@tonic-gate gp = rctl_set_init_prealloc(RCENTITY_ZONE); 39617c478bd9Sstevel@tonic-gate mutex_enter(&pp->p_lock); 39627c478bd9Sstevel@tonic-gate e.rcep_p.zone = zone; 39637c478bd9Sstevel@tonic-gate e.rcep_t = RCENTITY_ZONE; 39647c478bd9Sstevel@tonic-gate zone->zone_rctls = rctl_set_init(RCENTITY_ZONE, pp, &e, set, gp); 39657c478bd9Sstevel@tonic-gate mutex_exit(&pp->p_lock); 39667c478bd9Sstevel@tonic-gate rctl_prealloc_destroy(gp); 39677c478bd9Sstevel@tonic-gate 39687c478bd9Sstevel@tonic-gate /* 39697c478bd9Sstevel@tonic-gate * Apply the rctls passed in to zone_create(). This is basically a list 39707c478bd9Sstevel@tonic-gate * assignment: all of the old values are removed and the new ones 39717c478bd9Sstevel@tonic-gate * inserted. That is, if an empty list is passed in, all values are 39727c478bd9Sstevel@tonic-gate * removed. 39737c478bd9Sstevel@tonic-gate */ 39747c478bd9Sstevel@tonic-gate while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) { 39757c478bd9Sstevel@tonic-gate rctl_dict_entry_t *rde; 39767c478bd9Sstevel@tonic-gate rctl_hndl_t hndl; 39777c478bd9Sstevel@tonic-gate char *name; 39787c478bd9Sstevel@tonic-gate nvlist_t **nvlarray; 39797c478bd9Sstevel@tonic-gate uint_t i, nelem; 39807c478bd9Sstevel@tonic-gate int error; /* For ASSERT()s */ 39817c478bd9Sstevel@tonic-gate 39827c478bd9Sstevel@tonic-gate name = nvpair_name(nvp); 39837c478bd9Sstevel@tonic-gate hndl = rctl_hndl_lookup(name); 39847c478bd9Sstevel@tonic-gate ASSERT(hndl != -1); 39857c478bd9Sstevel@tonic-gate rde = rctl_dict_lookup_hndl(hndl); 39867c478bd9Sstevel@tonic-gate ASSERT(rde != NULL); 39877c478bd9Sstevel@tonic-gate 39887c478bd9Sstevel@tonic-gate for (; /* ever */; ) { 39897c478bd9Sstevel@tonic-gate rctl_val_t oval; 39907c478bd9Sstevel@tonic-gate 39917c478bd9Sstevel@tonic-gate mutex_enter(&pp->p_lock); 39927c478bd9Sstevel@tonic-gate error = rctl_local_get(hndl, NULL, &oval, pp); 39937c478bd9Sstevel@tonic-gate mutex_exit(&pp->p_lock); 39947c478bd9Sstevel@tonic-gate ASSERT(error == 0); /* Can't fail for RCTL_FIRST */ 39957c478bd9Sstevel@tonic-gate ASSERT(oval.rcv_privilege != RCPRIV_BASIC); 39967c478bd9Sstevel@tonic-gate if (oval.rcv_privilege == RCPRIV_SYSTEM) 39977c478bd9Sstevel@tonic-gate break; 39987c478bd9Sstevel@tonic-gate mutex_enter(&pp->p_lock); 39997c478bd9Sstevel@tonic-gate error = rctl_local_delete(hndl, &oval, pp); 40007c478bd9Sstevel@tonic-gate mutex_exit(&pp->p_lock); 40017c478bd9Sstevel@tonic-gate ASSERT(error == 0); 40027c478bd9Sstevel@tonic-gate } 40037c478bd9Sstevel@tonic-gate error = nvpair_value_nvlist_array(nvp, &nvlarray, &nelem); 40047c478bd9Sstevel@tonic-gate ASSERT(error == 0); 40057c478bd9Sstevel@tonic-gate for (i = 0; i < nelem; i++) { 40067c478bd9Sstevel@tonic-gate rctl_val_t *nvalp; 40077c478bd9Sstevel@tonic-gate 40087c478bd9Sstevel@tonic-gate nvalp = kmem_cache_alloc(rctl_val_cache, KM_SLEEP); 40097c478bd9Sstevel@tonic-gate error = nvlist2rctlval(nvlarray[i], nvalp); 40107c478bd9Sstevel@tonic-gate ASSERT(error == 0); 40117c478bd9Sstevel@tonic-gate /* 40127c478bd9Sstevel@tonic-gate * rctl_local_insert can fail if the value being 40137c478bd9Sstevel@tonic-gate * inserted is a duplicate; this is OK. 40147c478bd9Sstevel@tonic-gate */ 40157c478bd9Sstevel@tonic-gate mutex_enter(&pp->p_lock); 40167c478bd9Sstevel@tonic-gate if (rctl_local_insert(hndl, nvalp, pp) != 0) 40177c478bd9Sstevel@tonic-gate kmem_cache_free(rctl_val_cache, nvalp); 40187c478bd9Sstevel@tonic-gate mutex_exit(&pp->p_lock); 40197c478bd9Sstevel@tonic-gate } 40207c478bd9Sstevel@tonic-gate } 4021d2a70789SRichard Lowe 40227c478bd9Sstevel@tonic-gate /* 40237c478bd9Sstevel@tonic-gate * Tell the world that we're done setting up. 40247c478bd9Sstevel@tonic-gate * 4025bd41d0a8Snordmark * At this point we want to set the zone status to ZONE_IS_INITIALIZED 40267c478bd9Sstevel@tonic-gate * and atomically set the zone's processor set visibility. Once 40277c478bd9Sstevel@tonic-gate * we drop pool_lock() this zone will automatically get updated 40287c478bd9Sstevel@tonic-gate * to reflect any future changes to the pools configuration. 4029bd41d0a8Snordmark * 4030bd41d0a8Snordmark * Note that after we drop the locks below (zonehash_lock in 4031bd41d0a8Snordmark * particular) other operations such as a zone_getattr call can 4032bd41d0a8Snordmark * now proceed and observe the zone. That is the reason for doing a 4033bd41d0a8Snordmark * state transition to the INITIALIZED state. 40347c478bd9Sstevel@tonic-gate */ 40357c478bd9Sstevel@tonic-gate pool_lock(); 40367c478bd9Sstevel@tonic-gate mutex_enter(&cpu_lock); 40377c478bd9Sstevel@tonic-gate mutex_enter(&zonehash_lock); 40387c478bd9Sstevel@tonic-gate zone_uniqid(zone); 40397c478bd9Sstevel@tonic-gate zone_zsd_configure(zone); 40407c478bd9Sstevel@tonic-gate if (pool_state == POOL_ENABLED) 40417c478bd9Sstevel@tonic-gate zone_pset_set(zone, pool_default->pool_pset->pset_id); 40427c478bd9Sstevel@tonic-gate mutex_enter(&zone_status_lock); 40437c478bd9Sstevel@tonic-gate ASSERT(zone_status_get(zone) == ZONE_IS_UNINITIALIZED); 4044bd41d0a8Snordmark zone_status_set(zone, ZONE_IS_INITIALIZED); 40457c478bd9Sstevel@tonic-gate mutex_exit(&zone_status_lock); 40467c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 40477c478bd9Sstevel@tonic-gate mutex_exit(&cpu_lock); 40487c478bd9Sstevel@tonic-gate pool_unlock(); 40497c478bd9Sstevel@tonic-gate 4050bd41d0a8Snordmark /* Now call the create callback for this key */ 4051bd41d0a8Snordmark zsd_apply_all_keys(zsd_apply_create, zone); 4052bd41d0a8Snordmark 4053bd41d0a8Snordmark /* The callbacks are complete. Mark ZONE_IS_READY */ 4054bd41d0a8Snordmark mutex_enter(&zone_status_lock); 4055bd41d0a8Snordmark ASSERT(zone_status_get(zone) == ZONE_IS_INITIALIZED); 4056bd41d0a8Snordmark zone_status_set(zone, ZONE_IS_READY); 4057bd41d0a8Snordmark mutex_exit(&zone_status_lock); 4058bd41d0a8Snordmark 40597c478bd9Sstevel@tonic-gate /* 40607c478bd9Sstevel@tonic-gate * Once we see the zone transition to the ZONE_IS_BOOTING state, 40617c478bd9Sstevel@tonic-gate * we launch init, and set the state to running. 40627c478bd9Sstevel@tonic-gate */ 40637c478bd9Sstevel@tonic-gate zone_status_wait_cpr(zone, ZONE_IS_BOOTING, "zsched"); 40647c478bd9Sstevel@tonic-gate 40657c478bd9Sstevel@tonic-gate if (zone_status_get(zone) == ZONE_IS_BOOTING) { 40667c478bd9Sstevel@tonic-gate id_t cid; 40677c478bd9Sstevel@tonic-gate 40687c478bd9Sstevel@tonic-gate /* 40697c478bd9Sstevel@tonic-gate * Ok, this is a little complicated. We need to grab the 40707c478bd9Sstevel@tonic-gate * zone's pool's scheduling class ID; note that by now, we 40717c478bd9Sstevel@tonic-gate * are already bound to a pool if we need to be (zoneadmd 40727c478bd9Sstevel@tonic-gate * will have done that to us while we're in the READY 40737c478bd9Sstevel@tonic-gate * state). *But* the scheduling class for the zone's 'init' 40747c478bd9Sstevel@tonic-gate * must be explicitly passed to newproc, which doesn't 40757c478bd9Sstevel@tonic-gate * respect pool bindings. 40767c478bd9Sstevel@tonic-gate * 40777c478bd9Sstevel@tonic-gate * We hold the pool_lock across the call to newproc() to 40787c478bd9Sstevel@tonic-gate * close the obvious race: the pool's scheduling class 40797c478bd9Sstevel@tonic-gate * could change before we manage to create the LWP with 40807c478bd9Sstevel@tonic-gate * classid 'cid'. 40817c478bd9Sstevel@tonic-gate */ 40827c478bd9Sstevel@tonic-gate pool_lock(); 40830209230bSgjelinek if (zone->zone_defaultcid > 0) 40840209230bSgjelinek cid = zone->zone_defaultcid; 40850209230bSgjelinek else 40860209230bSgjelinek cid = pool_get_class(zone->zone_pool); 40877c478bd9Sstevel@tonic-gate if (cid == -1) 40887c478bd9Sstevel@tonic-gate cid = defaultcid; 40897c478bd9Sstevel@tonic-gate 40907c478bd9Sstevel@tonic-gate /* 40917c478bd9Sstevel@tonic-gate * If this fails, zone_boot will ultimately fail. The 40927c478bd9Sstevel@tonic-gate * state of the zone will be set to SHUTTING_DOWN-- userland 40937c478bd9Sstevel@tonic-gate * will have to tear down the zone, and fail, or try again. 40947c478bd9Sstevel@tonic-gate */ 40953f2f09c1Sdp if ((zone->zone_boot_err = newproc(zone_start_init, NULL, cid, 409635a5a358SJonathan Adams minclsyspri - 1, &ct, 0)) != 0) { 40977c478bd9Sstevel@tonic-gate mutex_enter(&zone_status_lock); 40987c478bd9Sstevel@tonic-gate zone_status_set(zone, ZONE_IS_SHUTTING_DOWN); 40997c478bd9Sstevel@tonic-gate mutex_exit(&zone_status_lock); 410086ad481cSJerry Jelinek } else { 410186ad481cSJerry Jelinek zone->zone_boot_time = gethrestime_sec(); 41027c478bd9Sstevel@tonic-gate } 410386ad481cSJerry Jelinek 41047c478bd9Sstevel@tonic-gate pool_unlock(); 41057c478bd9Sstevel@tonic-gate } 41067c478bd9Sstevel@tonic-gate 41077c478bd9Sstevel@tonic-gate /* 41087c478bd9Sstevel@tonic-gate * Wait for zone_destroy() to be called. This is what we spend 41097c478bd9Sstevel@tonic-gate * most of our life doing. 41107c478bd9Sstevel@tonic-gate */ 41117c478bd9Sstevel@tonic-gate zone_status_wait_cpr(zone, ZONE_IS_DYING, "zsched"); 41127c478bd9Sstevel@tonic-gate 41137c478bd9Sstevel@tonic-gate if (ct) 41147c478bd9Sstevel@tonic-gate /* 41157c478bd9Sstevel@tonic-gate * At this point the process contract should be empty. 41167c478bd9Sstevel@tonic-gate * (Though if it isn't, it's not the end of the world.) 41177c478bd9Sstevel@tonic-gate */ 41187c478bd9Sstevel@tonic-gate VERIFY(contract_abandon(ct, curproc, B_TRUE) == 0); 41197c478bd9Sstevel@tonic-gate 41207c478bd9Sstevel@tonic-gate /* 41217c478bd9Sstevel@tonic-gate * Allow kcred to be freed when all referring processes 41227c478bd9Sstevel@tonic-gate * (including this one) go away. We can't just do this in 41237c478bd9Sstevel@tonic-gate * zone_free because we need to wait for the zone_cred_ref to 41247c478bd9Sstevel@tonic-gate * drop to 0 before calling zone_free, and the existence of 41257c478bd9Sstevel@tonic-gate * zone_kcred will prevent that. Thus, we call crfree here to 41267c478bd9Sstevel@tonic-gate * balance the crdup in zone_create. The crhold calls earlier 41277c478bd9Sstevel@tonic-gate * in zsched will be dropped when the thread and process exit. 41287c478bd9Sstevel@tonic-gate */ 41297c478bd9Sstevel@tonic-gate crfree(zone->zone_kcred); 41307c478bd9Sstevel@tonic-gate zone->zone_kcred = NULL; 41317c478bd9Sstevel@tonic-gate 41327c478bd9Sstevel@tonic-gate exit(CLD_EXITED, 0); 41337c478bd9Sstevel@tonic-gate } 41347c478bd9Sstevel@tonic-gate 41357c478bd9Sstevel@tonic-gate /* 41367c478bd9Sstevel@tonic-gate * Helper function to determine if there are any submounts of the 41377c478bd9Sstevel@tonic-gate * provided path. Used to make sure the zone doesn't "inherit" any 41387c478bd9Sstevel@tonic-gate * mounts from before it is created. 41397c478bd9Sstevel@tonic-gate */ 41407c478bd9Sstevel@tonic-gate static uint_t 41417c478bd9Sstevel@tonic-gate zone_mount_count(const char *rootpath) 41427c478bd9Sstevel@tonic-gate { 41437c478bd9Sstevel@tonic-gate vfs_t *vfsp; 41447c478bd9Sstevel@tonic-gate uint_t count = 0; 41457c478bd9Sstevel@tonic-gate size_t rootpathlen = strlen(rootpath); 41467c478bd9Sstevel@tonic-gate 41477c478bd9Sstevel@tonic-gate /* 41487c478bd9Sstevel@tonic-gate * Holding zonehash_lock prevents race conditions with 41497c478bd9Sstevel@tonic-gate * vfs_list_add()/vfs_list_remove() since we serialize with 41507c478bd9Sstevel@tonic-gate * zone_find_by_path(). 41517c478bd9Sstevel@tonic-gate */ 41527c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&zonehash_lock)); 41537c478bd9Sstevel@tonic-gate /* 41547c478bd9Sstevel@tonic-gate * The rootpath must end with a '/' 41557c478bd9Sstevel@tonic-gate */ 41567c478bd9Sstevel@tonic-gate ASSERT(rootpath[rootpathlen - 1] == '/'); 41577c478bd9Sstevel@tonic-gate 41587c478bd9Sstevel@tonic-gate /* 41597c478bd9Sstevel@tonic-gate * This intentionally does not count the rootpath itself if that 41607c478bd9Sstevel@tonic-gate * happens to be a mount point. 41617c478bd9Sstevel@tonic-gate */ 41627c478bd9Sstevel@tonic-gate vfs_list_read_lock(); 41637c478bd9Sstevel@tonic-gate vfsp = rootvfs; 41647c478bd9Sstevel@tonic-gate do { 41657c478bd9Sstevel@tonic-gate if (strncmp(rootpath, refstr_value(vfsp->vfs_mntpt), 41667c478bd9Sstevel@tonic-gate rootpathlen) == 0) 41677c478bd9Sstevel@tonic-gate count++; 41687c478bd9Sstevel@tonic-gate vfsp = vfsp->vfs_next; 41697c478bd9Sstevel@tonic-gate } while (vfsp != rootvfs); 41707c478bd9Sstevel@tonic-gate vfs_list_unlock(); 41717c478bd9Sstevel@tonic-gate return (count); 41727c478bd9Sstevel@tonic-gate } 41737c478bd9Sstevel@tonic-gate 41747c478bd9Sstevel@tonic-gate /* 41757c478bd9Sstevel@tonic-gate * Helper function to make sure that a zone created on 'rootpath' 41767c478bd9Sstevel@tonic-gate * wouldn't end up containing other zones' rootpaths. 41777c478bd9Sstevel@tonic-gate */ 41787c478bd9Sstevel@tonic-gate static boolean_t 41797c478bd9Sstevel@tonic-gate zone_is_nested(const char *rootpath) 41807c478bd9Sstevel@tonic-gate { 41817c478bd9Sstevel@tonic-gate zone_t *zone; 41827c478bd9Sstevel@tonic-gate size_t rootpathlen = strlen(rootpath); 41837c478bd9Sstevel@tonic-gate size_t len; 41847c478bd9Sstevel@tonic-gate 41857c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&zonehash_lock)); 41867c478bd9Sstevel@tonic-gate 41872bb88978SDhanaraj M /* 41882bb88978SDhanaraj M * zone_set_root() appended '/' and '\0' at the end of rootpath 41892bb88978SDhanaraj M */ 41902bb88978SDhanaraj M if ((rootpathlen <= 3) && (rootpath[0] == '/') && 41912bb88978SDhanaraj M (rootpath[1] == '/') && (rootpath[2] == '\0')) 41922bb88978SDhanaraj M return (B_TRUE); 41932bb88978SDhanaraj M 41947c478bd9Sstevel@tonic-gate for (zone = list_head(&zone_active); zone != NULL; 41957c478bd9Sstevel@tonic-gate zone = list_next(&zone_active, zone)) { 41967c478bd9Sstevel@tonic-gate if (zone == global_zone) 41977c478bd9Sstevel@tonic-gate continue; 41987c478bd9Sstevel@tonic-gate len = strlen(zone->zone_rootpath); 41997c478bd9Sstevel@tonic-gate if (strncmp(rootpath, zone->zone_rootpath, 42007c478bd9Sstevel@tonic-gate MIN(rootpathlen, len)) == 0) 42017c478bd9Sstevel@tonic-gate return (B_TRUE); 42027c478bd9Sstevel@tonic-gate } 42037c478bd9Sstevel@tonic-gate return (B_FALSE); 42047c478bd9Sstevel@tonic-gate } 42057c478bd9Sstevel@tonic-gate 42067c478bd9Sstevel@tonic-gate static int 4207821c4a97Sdp zone_set_privset(zone_t *zone, const priv_set_t *zone_privs, 4208821c4a97Sdp size_t zone_privssz) 42097c478bd9Sstevel@tonic-gate { 42101a88ce5cSDan Price priv_set_t *privs; 42117c478bd9Sstevel@tonic-gate 4212821c4a97Sdp if (zone_privssz < sizeof (priv_set_t)) 42131a88ce5cSDan Price return (ENOMEM); 42141a88ce5cSDan Price 42151a88ce5cSDan Price privs = kmem_alloc(sizeof (priv_set_t), KM_SLEEP); 4216821c4a97Sdp 42177c478bd9Sstevel@tonic-gate if (copyin(zone_privs, privs, sizeof (priv_set_t))) { 42187c478bd9Sstevel@tonic-gate kmem_free(privs, sizeof (priv_set_t)); 42197c478bd9Sstevel@tonic-gate return (EFAULT); 42207c478bd9Sstevel@tonic-gate } 42217c478bd9Sstevel@tonic-gate 42227c478bd9Sstevel@tonic-gate zone->zone_privset = privs; 42237c478bd9Sstevel@tonic-gate return (0); 42247c478bd9Sstevel@tonic-gate } 42257c478bd9Sstevel@tonic-gate 42267c478bd9Sstevel@tonic-gate /* 42277c478bd9Sstevel@tonic-gate * We make creative use of nvlists to pass in rctls from userland. The list is 42287c478bd9Sstevel@tonic-gate * a list of the following structures: 42297c478bd9Sstevel@tonic-gate * 42307c478bd9Sstevel@tonic-gate * (name = rctl_name, value = nvpair_list_array) 42317c478bd9Sstevel@tonic-gate * 42327c478bd9Sstevel@tonic-gate * Where each element of the nvpair_list_array is of the form: 42337c478bd9Sstevel@tonic-gate * 42347c478bd9Sstevel@tonic-gate * [(name = "privilege", value = RCPRIV_PRIVILEGED), 42357c478bd9Sstevel@tonic-gate * (name = "limit", value = uint64_t), 42367c478bd9Sstevel@tonic-gate * (name = "action", value = (RCTL_LOCAL_NOACTION || RCTL_LOCAL_DENY))] 42377c478bd9Sstevel@tonic-gate */ 42387c478bd9Sstevel@tonic-gate static int 42397c478bd9Sstevel@tonic-gate parse_rctls(caddr_t ubuf, size_t buflen, nvlist_t **nvlp) 42407c478bd9Sstevel@tonic-gate { 42417c478bd9Sstevel@tonic-gate nvpair_t *nvp = NULL; 42427c478bd9Sstevel@tonic-gate nvlist_t *nvl = NULL; 42437c478bd9Sstevel@tonic-gate char *kbuf; 42447c478bd9Sstevel@tonic-gate int error; 42457c478bd9Sstevel@tonic-gate rctl_val_t rv; 42467c478bd9Sstevel@tonic-gate 42477c478bd9Sstevel@tonic-gate *nvlp = NULL; 42487c478bd9Sstevel@tonic-gate 42497c478bd9Sstevel@tonic-gate if (buflen == 0) 42507c478bd9Sstevel@tonic-gate return (0); 42517c478bd9Sstevel@tonic-gate 42527c478bd9Sstevel@tonic-gate if ((kbuf = kmem_alloc(buflen, KM_NOSLEEP)) == NULL) 42537c478bd9Sstevel@tonic-gate return (ENOMEM); 42547c478bd9Sstevel@tonic-gate if (copyin(ubuf, kbuf, buflen)) { 42557c478bd9Sstevel@tonic-gate error = EFAULT; 42567c478bd9Sstevel@tonic-gate goto out; 42577c478bd9Sstevel@tonic-gate } 42587c478bd9Sstevel@tonic-gate if (nvlist_unpack(kbuf, buflen, &nvl, KM_SLEEP) != 0) { 42597c478bd9Sstevel@tonic-gate /* 42607c478bd9Sstevel@tonic-gate * nvl may have been allocated/free'd, but the value set to 42617c478bd9Sstevel@tonic-gate * non-NULL, so we reset it here. 42627c478bd9Sstevel@tonic-gate */ 42637c478bd9Sstevel@tonic-gate nvl = NULL; 42647c478bd9Sstevel@tonic-gate error = EINVAL; 42657c478bd9Sstevel@tonic-gate goto out; 42667c478bd9Sstevel@tonic-gate } 42677c478bd9Sstevel@tonic-gate while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) { 42687c478bd9Sstevel@tonic-gate rctl_dict_entry_t *rde; 42697c478bd9Sstevel@tonic-gate rctl_hndl_t hndl; 42707c478bd9Sstevel@tonic-gate nvlist_t **nvlarray; 42717c478bd9Sstevel@tonic-gate uint_t i, nelem; 42727c478bd9Sstevel@tonic-gate char *name; 42737c478bd9Sstevel@tonic-gate 42747c478bd9Sstevel@tonic-gate error = EINVAL; 42757c478bd9Sstevel@tonic-gate name = nvpair_name(nvp); 42767c478bd9Sstevel@tonic-gate if (strncmp(nvpair_name(nvp), "zone.", sizeof ("zone.") - 1) 42777c478bd9Sstevel@tonic-gate != 0 || nvpair_type(nvp) != DATA_TYPE_NVLIST_ARRAY) { 42787c478bd9Sstevel@tonic-gate goto out; 42797c478bd9Sstevel@tonic-gate } 42807c478bd9Sstevel@tonic-gate if ((hndl = rctl_hndl_lookup(name)) == -1) { 42817c478bd9Sstevel@tonic-gate goto out; 42827c478bd9Sstevel@tonic-gate } 42837c478bd9Sstevel@tonic-gate rde = rctl_dict_lookup_hndl(hndl); 42847c478bd9Sstevel@tonic-gate error = nvpair_value_nvlist_array(nvp, &nvlarray, &nelem); 42857c478bd9Sstevel@tonic-gate ASSERT(error == 0); 42867c478bd9Sstevel@tonic-gate for (i = 0; i < nelem; i++) { 42877c478bd9Sstevel@tonic-gate if (error = nvlist2rctlval(nvlarray[i], &rv)) 42887c478bd9Sstevel@tonic-gate goto out; 42897c478bd9Sstevel@tonic-gate } 42907c478bd9Sstevel@tonic-gate if (rctl_invalid_value(rde, &rv)) { 42917c478bd9Sstevel@tonic-gate error = EINVAL; 42927c478bd9Sstevel@tonic-gate goto out; 42937c478bd9Sstevel@tonic-gate } 42947c478bd9Sstevel@tonic-gate } 42957c478bd9Sstevel@tonic-gate error = 0; 42967c478bd9Sstevel@tonic-gate *nvlp = nvl; 42977c478bd9Sstevel@tonic-gate out: 42987c478bd9Sstevel@tonic-gate kmem_free(kbuf, buflen); 42997c478bd9Sstevel@tonic-gate if (error && nvl != NULL) 43007c478bd9Sstevel@tonic-gate nvlist_free(nvl); 43017c478bd9Sstevel@tonic-gate return (error); 43027c478bd9Sstevel@tonic-gate } 43037c478bd9Sstevel@tonic-gate 43047c478bd9Sstevel@tonic-gate int 4305854956ceSBryan Cantrill zone_create_error(int er_error, int er_ext, int *er_out) 4306854956ceSBryan Cantrill { 43077c478bd9Sstevel@tonic-gate if (er_out != NULL) { 43087c478bd9Sstevel@tonic-gate if (copyout(&er_ext, er_out, sizeof (int))) { 43097c478bd9Sstevel@tonic-gate return (set_errno(EFAULT)); 43107c478bd9Sstevel@tonic-gate } 43117c478bd9Sstevel@tonic-gate } 43127c478bd9Sstevel@tonic-gate return (set_errno(er_error)); 43137c478bd9Sstevel@tonic-gate } 43147c478bd9Sstevel@tonic-gate 431545916cd2Sjpk static int 431645916cd2Sjpk zone_set_label(zone_t *zone, const bslabel_t *lab, uint32_t doi) 431745916cd2Sjpk { 431845916cd2Sjpk ts_label_t *tsl; 431945916cd2Sjpk bslabel_t blab; 432045916cd2Sjpk 432145916cd2Sjpk /* Get label from user */ 432245916cd2Sjpk if (copyin(lab, &blab, sizeof (blab)) != 0) 432345916cd2Sjpk return (EFAULT); 432445916cd2Sjpk tsl = labelalloc(&blab, doi, KM_NOSLEEP); 432545916cd2Sjpk if (tsl == NULL) 432645916cd2Sjpk return (ENOMEM); 432745916cd2Sjpk 432845916cd2Sjpk zone->zone_slabel = tsl; 432945916cd2Sjpk return (0); 433045916cd2Sjpk } 433145916cd2Sjpk 4332fa9e4066Sahrens /* 4333fa9e4066Sahrens * Parses a comma-separated list of ZFS datasets into a per-zone dictionary. 4334fa9e4066Sahrens */ 4335fa9e4066Sahrens static int 4336fa9e4066Sahrens parse_zfs(zone_t *zone, caddr_t ubuf, size_t buflen) 4337fa9e4066Sahrens { 4338fa9e4066Sahrens char *kbuf; 4339fa9e4066Sahrens char *dataset, *next; 4340fa9e4066Sahrens zone_dataset_t *zd; 4341fa9e4066Sahrens size_t len; 4342fa9e4066Sahrens 4343fa9e4066Sahrens if (ubuf == NULL || buflen == 0) 4344fa9e4066Sahrens return (0); 4345fa9e4066Sahrens 4346fa9e4066Sahrens if ((kbuf = kmem_alloc(buflen, KM_NOSLEEP)) == NULL) 4347fa9e4066Sahrens return (ENOMEM); 4348fa9e4066Sahrens 4349fa9e4066Sahrens if (copyin(ubuf, kbuf, buflen) != 0) { 4350fa9e4066Sahrens kmem_free(kbuf, buflen); 4351fa9e4066Sahrens return (EFAULT); 4352fa9e4066Sahrens } 4353fa9e4066Sahrens 4354fa9e4066Sahrens dataset = next = kbuf; 4355fa9e4066Sahrens for (;;) { 4356fa9e4066Sahrens zd = kmem_alloc(sizeof (zone_dataset_t), KM_SLEEP); 4357fa9e4066Sahrens 4358fa9e4066Sahrens next = strchr(dataset, ','); 4359fa9e4066Sahrens 4360fa9e4066Sahrens if (next == NULL) 4361fa9e4066Sahrens len = strlen(dataset); 4362fa9e4066Sahrens else 4363fa9e4066Sahrens len = next - dataset; 4364fa9e4066Sahrens 4365fa9e4066Sahrens zd->zd_dataset = kmem_alloc(len + 1, KM_SLEEP); 4366fa9e4066Sahrens bcopy(dataset, zd->zd_dataset, len); 4367fa9e4066Sahrens zd->zd_dataset[len] = '\0'; 4368fa9e4066Sahrens 4369fa9e4066Sahrens list_insert_head(&zone->zone_datasets, zd); 4370fa9e4066Sahrens 4371fa9e4066Sahrens if (next == NULL) 4372fa9e4066Sahrens break; 4373fa9e4066Sahrens 4374fa9e4066Sahrens dataset = next + 1; 4375fa9e4066Sahrens } 4376fa9e4066Sahrens 4377fa9e4066Sahrens kmem_free(kbuf, buflen); 4378fa9e4066Sahrens return (0); 4379fa9e4066Sahrens } 4380fa9e4066Sahrens 43817c478bd9Sstevel@tonic-gate /* 43827c478bd9Sstevel@tonic-gate * System call to create/initialize a new zone named 'zone_name', rooted 43837c478bd9Sstevel@tonic-gate * at 'zone_root', with a zone-wide privilege limit set of 'zone_privs', 438445916cd2Sjpk * and initialized with the zone-wide rctls described in 'rctlbuf', and 438545916cd2Sjpk * with labeling set by 'match', 'doi', and 'label'. 43867c478bd9Sstevel@tonic-gate * 43877c478bd9Sstevel@tonic-gate * If extended error is non-null, we may use it to return more detailed 43887c478bd9Sstevel@tonic-gate * error information. 43897c478bd9Sstevel@tonic-gate */ 43907c478bd9Sstevel@tonic-gate static zoneid_t 43917c478bd9Sstevel@tonic-gate zone_create(const char *zone_name, const char *zone_root, 4392821c4a97Sdp const priv_set_t *zone_privs, size_t zone_privssz, 4393821c4a97Sdp caddr_t rctlbuf, size_t rctlbufsz, 439445916cd2Sjpk caddr_t zfsbuf, size_t zfsbufsz, int *extended_error, 4395f4b3ec61Sdh int match, uint32_t doi, const bslabel_t *label, 4396f4b3ec61Sdh int flags) 43977c478bd9Sstevel@tonic-gate { 43987c478bd9Sstevel@tonic-gate struct zsched_arg zarg; 43997c478bd9Sstevel@tonic-gate nvlist_t *rctls = NULL; 44007c478bd9Sstevel@tonic-gate proc_t *pp = curproc; 44017c478bd9Sstevel@tonic-gate zone_t *zone, *ztmp; 4402854956ceSBryan Cantrill zoneid_t zoneid, start = GLOBAL_ZONEID; 44037c478bd9Sstevel@tonic-gate int error; 44047c478bd9Sstevel@tonic-gate int error2 = 0; 44057c478bd9Sstevel@tonic-gate char *str; 44067c478bd9Sstevel@tonic-gate cred_t *zkcr; 440748451833Scarlsonj boolean_t insert_label_hash; 44087c478bd9Sstevel@tonic-gate 44097c478bd9Sstevel@tonic-gate if (secpolicy_zone_config(CRED()) != 0) 44107c478bd9Sstevel@tonic-gate return (set_errno(EPERM)); 44117c478bd9Sstevel@tonic-gate 44127c478bd9Sstevel@tonic-gate /* can't boot zone from within chroot environment */ 44137c478bd9Sstevel@tonic-gate if (PTOU(pp)->u_rdir != NULL && PTOU(pp)->u_rdir != rootdir) 44147c478bd9Sstevel@tonic-gate return (zone_create_error(ENOTSUP, ZE_CHROOTED, 4415821c4a97Sdp extended_error)); 4416854956ceSBryan Cantrill /* 4417854956ceSBryan Cantrill * As the first step of zone creation, we want to allocate a zoneid. 4418854956ceSBryan Cantrill * This allocation is complicated by the fact that netstacks use the 4419854956ceSBryan Cantrill * zoneid to determine their stackid, but netstacks themselves are 4420854956ceSBryan Cantrill * freed asynchronously with respect to zone destruction. This means 4421854956ceSBryan Cantrill * that a netstack reference leak (or in principle, an extraordinarily 4422854956ceSBryan Cantrill * long netstack reference hold) could result in a zoneid being 4423854956ceSBryan Cantrill * allocated that in fact corresponds to a stackid from an active 4424854956ceSBryan Cantrill * (referenced) netstack -- unleashing all sorts of havoc when that 4425854956ceSBryan Cantrill * netstack is actually (re)used. (In the abstract, we might wish a 4426854956ceSBryan Cantrill * zoneid to not be deallocated until its last referencing netstack 4427854956ceSBryan Cantrill * has been released, but netstacks lack a backpointer into their 4428854956ceSBryan Cantrill * referencing zone -- and changing them to have such a pointer would 4429854956ceSBryan Cantrill * be substantial, to put it euphemistically.) To avoid this, we 4430854956ceSBryan Cantrill * detect this condition on allocation: if we have allocated a zoneid 4431854956ceSBryan Cantrill * that corresponds to a netstack that's still in use, we warn about 4432854956ceSBryan Cantrill * it (as it is much more likely to be a reference leak than an actual 4433854956ceSBryan Cantrill * netstack reference), free it, and allocate another. That these 4434854956ceSBryan Cantrill * identifers are allocated out of an ID space assures that we won't 4435854956ceSBryan Cantrill * see the identifier we just allocated. 4436854956ceSBryan Cantrill */ 4437854956ceSBryan Cantrill for (;;) { 4438854956ceSBryan Cantrill zoneid = id_alloc(zoneid_space); 4439854956ceSBryan Cantrill 4440854956ceSBryan Cantrill if (!netstack_inuse_by_stackid(zoneid_to_netstackid(zoneid))) 4441854956ceSBryan Cantrill break; 4442854956ceSBryan Cantrill 4443854956ceSBryan Cantrill id_free(zoneid_space, zoneid); 4444854956ceSBryan Cantrill 4445854956ceSBryan Cantrill if (start == GLOBAL_ZONEID) { 4446854956ceSBryan Cantrill start = zoneid; 4447854956ceSBryan Cantrill } else if (zoneid == start) { 4448854956ceSBryan Cantrill /* 4449854956ceSBryan Cantrill * We have managed to iterate over the entire available 4450854956ceSBryan Cantrill * zoneid space -- there are no identifiers available, 4451854956ceSBryan Cantrill * presumably due to some number of leaked netstack 4452854956ceSBryan Cantrill * references. While it's in principle possible for us 4453854956ceSBryan Cantrill * to continue to try, it seems wiser to give up at 4454854956ceSBryan Cantrill * this point to warn and fail explicitly with a 4455854956ceSBryan Cantrill * distinctive error. 4456854956ceSBryan Cantrill */ 4457854956ceSBryan Cantrill cmn_err(CE_WARN, "zone_create() failed: all available " 4458854956ceSBryan Cantrill "zone IDs have netstacks still in use"); 4459854956ceSBryan Cantrill return (set_errno(ENFILE)); 4460854956ceSBryan Cantrill } 4461854956ceSBryan Cantrill 4462854956ceSBryan Cantrill cmn_err(CE_WARN, "unable to reuse zone ID %d; " 4463854956ceSBryan Cantrill "netstack still in use", zoneid); 4464854956ceSBryan Cantrill } 44657c478bd9Sstevel@tonic-gate 44667c478bd9Sstevel@tonic-gate zone = kmem_zalloc(sizeof (zone_t), KM_SLEEP); 4467854956ceSBryan Cantrill zone->zone_id = zoneid; 44687c478bd9Sstevel@tonic-gate zone->zone_status = ZONE_IS_UNINITIALIZED; 44697c478bd9Sstevel@tonic-gate zone->zone_pool = pool_default; 44707c478bd9Sstevel@tonic-gate zone->zone_pool_mod = gethrtime(); 44717c478bd9Sstevel@tonic-gate zone->zone_psetid = ZONE_PS_INVAL; 44727c478bd9Sstevel@tonic-gate zone->zone_ncpus = 0; 44737c478bd9Sstevel@tonic-gate zone->zone_ncpus_online = 0; 44749acbbeafSnn zone->zone_restart_init = B_TRUE; 44759acbbeafSnn zone->zone_brand = &native_brand; 44769acbbeafSnn zone->zone_initname = NULL; 44777c478bd9Sstevel@tonic-gate mutex_init(&zone->zone_lock, NULL, MUTEX_DEFAULT, NULL); 44787c478bd9Sstevel@tonic-gate mutex_init(&zone->zone_nlwps_lock, NULL, MUTEX_DEFAULT, NULL); 44790209230bSgjelinek mutex_init(&zone->zone_mem_lock, NULL, MUTEX_DEFAULT, NULL); 44807c478bd9Sstevel@tonic-gate cv_init(&zone->zone_cv, NULL, CV_DEFAULT, NULL); 4481a19609f8Sjv list_create(&zone->zone_ref_list, sizeof (zone_ref_t), 4482a19609f8Sjv offsetof(zone_ref_t, zref_linkage)); 44837c478bd9Sstevel@tonic-gate list_create(&zone->zone_zsd, sizeof (struct zsd_entry), 44847c478bd9Sstevel@tonic-gate offsetof(struct zsd_entry, zsd_linkage)); 4485fa9e4066Sahrens list_create(&zone->zone_datasets, sizeof (zone_dataset_t), 4486fa9e4066Sahrens offsetof(zone_dataset_t, zd_linkage)); 44872b24ab6bSSebastien Roy list_create(&zone->zone_dl_list, sizeof (zone_dl_t), 44882b24ab6bSSebastien Roy offsetof(zone_dl_t, zdl_linkage)); 448945916cd2Sjpk rw_init(&zone->zone_mlps.mlpl_rwlock, NULL, RW_DEFAULT, NULL); 4490835ee219SRobert Harris rw_init(&zone->zone_mntfs_db_lock, NULL, RW_DEFAULT, NULL); 44917c478bd9Sstevel@tonic-gate 4492f4b3ec61Sdh if (flags & ZCF_NET_EXCL) { 4493f4b3ec61Sdh zone->zone_flags |= ZF_NET_EXCL; 4494f4b3ec61Sdh } 4495f4b3ec61Sdh 44967c478bd9Sstevel@tonic-gate if ((error = zone_set_name(zone, zone_name)) != 0) { 44977c478bd9Sstevel@tonic-gate zone_free(zone); 44987c478bd9Sstevel@tonic-gate return (zone_create_error(error, 0, extended_error)); 44997c478bd9Sstevel@tonic-gate } 45007c478bd9Sstevel@tonic-gate 45017c478bd9Sstevel@tonic-gate if ((error = zone_set_root(zone, zone_root)) != 0) { 45027c478bd9Sstevel@tonic-gate zone_free(zone); 45037c478bd9Sstevel@tonic-gate return (zone_create_error(error, 0, extended_error)); 45047c478bd9Sstevel@tonic-gate } 4505821c4a97Sdp if ((error = zone_set_privset(zone, zone_privs, zone_privssz)) != 0) { 45067c478bd9Sstevel@tonic-gate zone_free(zone); 45077c478bd9Sstevel@tonic-gate return (zone_create_error(error, 0, extended_error)); 45087c478bd9Sstevel@tonic-gate } 45097c478bd9Sstevel@tonic-gate 45107c478bd9Sstevel@tonic-gate /* initialize node name to be the same as zone name */ 45117c478bd9Sstevel@tonic-gate zone->zone_nodename = kmem_alloc(_SYS_NMLN, KM_SLEEP); 45127c478bd9Sstevel@tonic-gate (void) strncpy(zone->zone_nodename, zone->zone_name, _SYS_NMLN); 45137c478bd9Sstevel@tonic-gate zone->zone_nodename[_SYS_NMLN - 1] = '\0'; 45147c478bd9Sstevel@tonic-gate 45157c478bd9Sstevel@tonic-gate zone->zone_domain = kmem_alloc(_SYS_NMLN, KM_SLEEP); 45167c478bd9Sstevel@tonic-gate zone->zone_domain[0] = '\0'; 45175679c89fSjv zone->zone_hostid = HW_INVALID_HOSTID; 45187c478bd9Sstevel@tonic-gate zone->zone_shares = 1; 4519824c205fSml zone->zone_shmmax = 0; 4520824c205fSml zone->zone_ipc.ipcq_shmmni = 0; 4521824c205fSml zone->zone_ipc.ipcq_semmni = 0; 4522824c205fSml zone->zone_ipc.ipcq_msgmni = 0; 45237c478bd9Sstevel@tonic-gate zone->zone_bootargs = NULL; 45240fbb751dSJohn Levon zone->zone_fs_allowed = NULL; 4525d2a70789SRichard Lowe 4526d2a70789SRichard Lowe secflags_zero(&zone0.zone_secflags.psf_lower); 4527d2a70789SRichard Lowe secflags_zero(&zone0.zone_secflags.psf_effective); 4528d2a70789SRichard Lowe secflags_zero(&zone0.zone_secflags.psf_inherit); 4529d2a70789SRichard Lowe secflags_fullset(&zone0.zone_secflags.psf_upper); 4530d2a70789SRichard Lowe 45313f2f09c1Sdp zone->zone_initname = 45323f2f09c1Sdp kmem_alloc(strlen(zone_default_initname) + 1, KM_SLEEP); 45333f2f09c1Sdp (void) strcpy(zone->zone_initname, zone_default_initname); 45340209230bSgjelinek zone->zone_nlwps = 0; 45350209230bSgjelinek zone->zone_nlwps_ctl = INT_MAX; 4536ff19e029SMenno Lageman zone->zone_nprocs = 0; 4537ff19e029SMenno Lageman zone->zone_nprocs_ctl = INT_MAX; 4538c6939658Ssl zone->zone_locked_mem = 0; 4539c6939658Ssl zone->zone_locked_mem_ctl = UINT64_MAX; 45400209230bSgjelinek zone->zone_max_swap = 0; 45410209230bSgjelinek zone->zone_max_swap_ctl = UINT64_MAX; 45420fbb751dSJohn Levon zone->zone_max_lofi = 0; 45430fbb751dSJohn Levon zone->zone_max_lofi_ctl = UINT64_MAX; 45440209230bSgjelinek zone0.zone_lockedmem_kstat = NULL; 45450209230bSgjelinek zone0.zone_swapresv_kstat = NULL; 45467c478bd9Sstevel@tonic-gate 45477c478bd9Sstevel@tonic-gate /* 45487c478bd9Sstevel@tonic-gate * Zsched initializes the rctls. 45497c478bd9Sstevel@tonic-gate */ 45507c478bd9Sstevel@tonic-gate zone->zone_rctls = NULL; 45517c478bd9Sstevel@tonic-gate 45527c478bd9Sstevel@tonic-gate if ((error = parse_rctls(rctlbuf, rctlbufsz, &rctls)) != 0) { 45537c478bd9Sstevel@tonic-gate zone_free(zone); 45547c478bd9Sstevel@tonic-gate return (zone_create_error(error, 0, extended_error)); 45557c478bd9Sstevel@tonic-gate } 45567c478bd9Sstevel@tonic-gate 4557fa9e4066Sahrens if ((error = parse_zfs(zone, zfsbuf, zfsbufsz)) != 0) { 4558fa9e4066Sahrens zone_free(zone); 4559fa9e4066Sahrens return (set_errno(error)); 4560fa9e4066Sahrens } 4561fa9e4066Sahrens 456245916cd2Sjpk /* 456345916cd2Sjpk * Read in the trusted system parameters: 456445916cd2Sjpk * match flag and sensitivity label. 456545916cd2Sjpk */ 456645916cd2Sjpk zone->zone_match = match; 456748451833Scarlsonj if (is_system_labeled() && !(zone->zone_flags & ZF_IS_SCRATCH)) { 45687e6639c2Skp /* Fail if requested to set doi to anything but system's doi */ 45697e6639c2Skp if (doi != 0 && doi != default_doi) { 45707e6639c2Skp zone_free(zone); 45717e6639c2Skp return (set_errno(EINVAL)); 45727e6639c2Skp } 45737e6639c2Skp /* Always apply system's doi to the zone */ 45747e6639c2Skp error = zone_set_label(zone, label, default_doi); 457545916cd2Sjpk if (error != 0) { 457645916cd2Sjpk zone_free(zone); 457745916cd2Sjpk return (set_errno(error)); 457845916cd2Sjpk } 457948451833Scarlsonj insert_label_hash = B_TRUE; 458045916cd2Sjpk } else { 458145916cd2Sjpk /* all zones get an admin_low label if system is not labeled */ 458245916cd2Sjpk zone->zone_slabel = l_admin_low; 458345916cd2Sjpk label_hold(l_admin_low); 458448451833Scarlsonj insert_label_hash = B_FALSE; 458545916cd2Sjpk } 458645916cd2Sjpk 45877c478bd9Sstevel@tonic-gate /* 45887c478bd9Sstevel@tonic-gate * Stop all lwps since that's what normally happens as part of fork(). 45897c478bd9Sstevel@tonic-gate * This needs to happen before we grab any locks to avoid deadlock 45907c478bd9Sstevel@tonic-gate * (another lwp in the process could be waiting for the held lock). 45917c478bd9Sstevel@tonic-gate */ 45927c478bd9Sstevel@tonic-gate if (curthread != pp->p_agenttp && !holdlwps(SHOLDFORK)) { 45937c478bd9Sstevel@tonic-gate zone_free(zone); 4594aab83bb8SJosef 'Jeff' Sipek nvlist_free(rctls); 45957c478bd9Sstevel@tonic-gate return (zone_create_error(error, 0, extended_error)); 45967c478bd9Sstevel@tonic-gate } 45977c478bd9Sstevel@tonic-gate 45985fd5c689SJerry Jelinek if (block_mounts(zone) == 0) { 45997c478bd9Sstevel@tonic-gate mutex_enter(&pp->p_lock); 46007c478bd9Sstevel@tonic-gate if (curthread != pp->p_agenttp) 46017c478bd9Sstevel@tonic-gate continuelwps(pp); 46027c478bd9Sstevel@tonic-gate mutex_exit(&pp->p_lock); 46037c478bd9Sstevel@tonic-gate zone_free(zone); 4604aab83bb8SJosef 'Jeff' Sipek nvlist_free(rctls); 46057c478bd9Sstevel@tonic-gate return (zone_create_error(error, 0, extended_error)); 46067c478bd9Sstevel@tonic-gate } 46077c478bd9Sstevel@tonic-gate 46087c478bd9Sstevel@tonic-gate /* 46097c478bd9Sstevel@tonic-gate * Set up credential for kernel access. After this, any errors 46107c478bd9Sstevel@tonic-gate * should go through the dance in errout rather than calling 46117c478bd9Sstevel@tonic-gate * zone_free directly. 46127c478bd9Sstevel@tonic-gate */ 46137c478bd9Sstevel@tonic-gate zone->zone_kcred = crdup(kcred); 46147c478bd9Sstevel@tonic-gate crsetzone(zone->zone_kcred, zone); 46157c478bd9Sstevel@tonic-gate priv_intersect(zone->zone_privset, &CR_PPRIV(zone->zone_kcred)); 46167c478bd9Sstevel@tonic-gate priv_intersect(zone->zone_privset, &CR_EPRIV(zone->zone_kcred)); 46177c478bd9Sstevel@tonic-gate priv_intersect(zone->zone_privset, &CR_IPRIV(zone->zone_kcred)); 46187c478bd9Sstevel@tonic-gate priv_intersect(zone->zone_privset, &CR_LPRIV(zone->zone_kcred)); 46197c478bd9Sstevel@tonic-gate 46207c478bd9Sstevel@tonic-gate mutex_enter(&zonehash_lock); 46217c478bd9Sstevel@tonic-gate /* 46227c478bd9Sstevel@tonic-gate * Make sure zone doesn't already exist. 462345916cd2Sjpk * 462445916cd2Sjpk * If the system and zone are labeled, 462545916cd2Sjpk * make sure no other zone exists that has the same label. 46267c478bd9Sstevel@tonic-gate */ 462745916cd2Sjpk if ((ztmp = zone_find_all_by_name(zone->zone_name)) != NULL || 462848451833Scarlsonj (insert_label_hash && 462945916cd2Sjpk (ztmp = zone_find_all_by_label(zone->zone_slabel)) != NULL)) { 46307c478bd9Sstevel@tonic-gate zone_status_t status; 46317c478bd9Sstevel@tonic-gate 46327c478bd9Sstevel@tonic-gate status = zone_status_get(ztmp); 46337c478bd9Sstevel@tonic-gate if (status == ZONE_IS_READY || status == ZONE_IS_RUNNING) 46347c478bd9Sstevel@tonic-gate error = EEXIST; 46357c478bd9Sstevel@tonic-gate else 46367c478bd9Sstevel@tonic-gate error = EBUSY; 46378c55461bSton 46388c55461bSton if (insert_label_hash) 46398c55461bSton error2 = ZE_LABELINUSE; 46408c55461bSton 46417c478bd9Sstevel@tonic-gate goto errout; 46427c478bd9Sstevel@tonic-gate } 46437c478bd9Sstevel@tonic-gate 46447c478bd9Sstevel@tonic-gate /* 46457c478bd9Sstevel@tonic-gate * Don't allow zone creations which would cause one zone's rootpath to 46467c478bd9Sstevel@tonic-gate * be accessible from that of another (non-global) zone. 46477c478bd9Sstevel@tonic-gate */ 46487c478bd9Sstevel@tonic-gate if (zone_is_nested(zone->zone_rootpath)) { 46497c478bd9Sstevel@tonic-gate error = EBUSY; 46507c478bd9Sstevel@tonic-gate goto errout; 46517c478bd9Sstevel@tonic-gate } 46527c478bd9Sstevel@tonic-gate 46537c478bd9Sstevel@tonic-gate ASSERT(zonecount != 0); /* check for leaks */ 46547c478bd9Sstevel@tonic-gate if (zonecount + 1 > maxzones) { 46557c478bd9Sstevel@tonic-gate error = ENOMEM; 46567c478bd9Sstevel@tonic-gate goto errout; 46577c478bd9Sstevel@tonic-gate } 46587c478bd9Sstevel@tonic-gate 46597c478bd9Sstevel@tonic-gate if (zone_mount_count(zone->zone_rootpath) != 0) { 46607c478bd9Sstevel@tonic-gate error = EBUSY; 46617c478bd9Sstevel@tonic-gate error2 = ZE_AREMOUNTS; 46627c478bd9Sstevel@tonic-gate goto errout; 46637c478bd9Sstevel@tonic-gate } 46647c478bd9Sstevel@tonic-gate 46657c478bd9Sstevel@tonic-gate /* 46667c478bd9Sstevel@tonic-gate * Zone is still incomplete, but we need to drop all locks while 46677c478bd9Sstevel@tonic-gate * zsched() initializes this zone's kernel process. We 46687c478bd9Sstevel@tonic-gate * optimistically add the zone to the hashtable and associated 46697c478bd9Sstevel@tonic-gate * lists so a parallel zone_create() doesn't try to create the 46707c478bd9Sstevel@tonic-gate * same zone. 46717c478bd9Sstevel@tonic-gate */ 46727c478bd9Sstevel@tonic-gate zonecount++; 46737c478bd9Sstevel@tonic-gate (void) mod_hash_insert(zonehashbyid, 46747c478bd9Sstevel@tonic-gate (mod_hash_key_t)(uintptr_t)zone->zone_id, 46757c478bd9Sstevel@tonic-gate (mod_hash_val_t)(uintptr_t)zone); 46767c478bd9Sstevel@tonic-gate str = kmem_alloc(strlen(zone->zone_name) + 1, KM_SLEEP); 46777c478bd9Sstevel@tonic-gate (void) strcpy(str, zone->zone_name); 46787c478bd9Sstevel@tonic-gate (void) mod_hash_insert(zonehashbyname, (mod_hash_key_t)str, 46797c478bd9Sstevel@tonic-gate (mod_hash_val_t)(uintptr_t)zone); 468048451833Scarlsonj if (insert_label_hash) { 468145916cd2Sjpk (void) mod_hash_insert(zonehashbylabel, 468245916cd2Sjpk (mod_hash_key_t)zone->zone_slabel, (mod_hash_val_t)zone); 468348451833Scarlsonj zone->zone_flags |= ZF_HASHED_LABEL; 468445916cd2Sjpk } 468545916cd2Sjpk 46867c478bd9Sstevel@tonic-gate /* 46877c478bd9Sstevel@tonic-gate * Insert into active list. At this point there are no 'hold's 46887c478bd9Sstevel@tonic-gate * on the zone, but everyone else knows not to use it, so we can 46897c478bd9Sstevel@tonic-gate * continue to use it. zsched() will do a zone_hold() if the 46907c478bd9Sstevel@tonic-gate * newproc() is successful. 46917c478bd9Sstevel@tonic-gate */ 46927c478bd9Sstevel@tonic-gate list_insert_tail(&zone_active, zone); 46937c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 46947c478bd9Sstevel@tonic-gate 46957c478bd9Sstevel@tonic-gate zarg.zone = zone; 46967c478bd9Sstevel@tonic-gate zarg.nvlist = rctls; 46977c478bd9Sstevel@tonic-gate /* 46987c478bd9Sstevel@tonic-gate * The process, task, and project rctls are probably wrong; 46997c478bd9Sstevel@tonic-gate * we need an interface to get the default values of all rctls, 47007c478bd9Sstevel@tonic-gate * and initialize zsched appropriately. I'm not sure that that 47017c478bd9Sstevel@tonic-gate * makes much of a difference, though. 47027c478bd9Sstevel@tonic-gate */ 470335a5a358SJonathan Adams error = newproc(zsched, (void *)&zarg, syscid, minclsyspri, NULL, 0); 470435a5a358SJonathan Adams if (error != 0) { 47057c478bd9Sstevel@tonic-gate /* 47067c478bd9Sstevel@tonic-gate * We need to undo all globally visible state. 47077c478bd9Sstevel@tonic-gate */ 47087c478bd9Sstevel@tonic-gate mutex_enter(&zonehash_lock); 47097c478bd9Sstevel@tonic-gate list_remove(&zone_active, zone); 471048451833Scarlsonj if (zone->zone_flags & ZF_HASHED_LABEL) { 471145916cd2Sjpk ASSERT(zone->zone_slabel != NULL); 471245916cd2Sjpk (void) mod_hash_destroy(zonehashbylabel, 471345916cd2Sjpk (mod_hash_key_t)zone->zone_slabel); 471445916cd2Sjpk } 47157c478bd9Sstevel@tonic-gate (void) mod_hash_destroy(zonehashbyname, 47167c478bd9Sstevel@tonic-gate (mod_hash_key_t)(uintptr_t)zone->zone_name); 47177c478bd9Sstevel@tonic-gate (void) mod_hash_destroy(zonehashbyid, 47187c478bd9Sstevel@tonic-gate (mod_hash_key_t)(uintptr_t)zone->zone_id); 47197c478bd9Sstevel@tonic-gate ASSERT(zonecount > 1); 47207c478bd9Sstevel@tonic-gate zonecount--; 47217c478bd9Sstevel@tonic-gate goto errout; 47227c478bd9Sstevel@tonic-gate } 47237c478bd9Sstevel@tonic-gate 47247c478bd9Sstevel@tonic-gate /* 47257c478bd9Sstevel@tonic-gate * Zone creation can't fail from now on. 47267c478bd9Sstevel@tonic-gate */ 47277c478bd9Sstevel@tonic-gate 47280209230bSgjelinek /* 47290209230bSgjelinek * Create zone kstats 47300209230bSgjelinek */ 47310209230bSgjelinek zone_kstat_create(zone); 47320209230bSgjelinek 47337c478bd9Sstevel@tonic-gate /* 47347c478bd9Sstevel@tonic-gate * Let the other lwps continue. 47357c478bd9Sstevel@tonic-gate */ 47367c478bd9Sstevel@tonic-gate mutex_enter(&pp->p_lock); 47377c478bd9Sstevel@tonic-gate if (curthread != pp->p_agenttp) 47387c478bd9Sstevel@tonic-gate continuelwps(pp); 47397c478bd9Sstevel@tonic-gate mutex_exit(&pp->p_lock); 47407c478bd9Sstevel@tonic-gate 47417c478bd9Sstevel@tonic-gate /* 47427c478bd9Sstevel@tonic-gate * Wait for zsched to finish initializing the zone. 47437c478bd9Sstevel@tonic-gate */ 47447c478bd9Sstevel@tonic-gate zone_status_wait(zone, ZONE_IS_READY); 47457c478bd9Sstevel@tonic-gate /* 47467c478bd9Sstevel@tonic-gate * The zone is fully visible, so we can let mounts progress. 47477c478bd9Sstevel@tonic-gate */ 47485fd5c689SJerry Jelinek resume_mounts(zone); 4749aab83bb8SJosef 'Jeff' Sipek nvlist_free(rctls); 47507c478bd9Sstevel@tonic-gate 47517c478bd9Sstevel@tonic-gate return (zoneid); 47527c478bd9Sstevel@tonic-gate 47537c478bd9Sstevel@tonic-gate errout: 47547c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 47557c478bd9Sstevel@tonic-gate /* 47567c478bd9Sstevel@tonic-gate * Let the other lwps continue. 47577c478bd9Sstevel@tonic-gate */ 47587c478bd9Sstevel@tonic-gate mutex_enter(&pp->p_lock); 47597c478bd9Sstevel@tonic-gate if (curthread != pp->p_agenttp) 47607c478bd9Sstevel@tonic-gate continuelwps(pp); 47617c478bd9Sstevel@tonic-gate mutex_exit(&pp->p_lock); 47627c478bd9Sstevel@tonic-gate 47635fd5c689SJerry Jelinek resume_mounts(zone); 4764aab83bb8SJosef 'Jeff' Sipek nvlist_free(rctls); 47657c478bd9Sstevel@tonic-gate /* 47667c478bd9Sstevel@tonic-gate * There is currently one reference to the zone, a cred_ref from 47677c478bd9Sstevel@tonic-gate * zone_kcred. To free the zone, we call crfree, which will call 47687c478bd9Sstevel@tonic-gate * zone_cred_rele, which will call zone_free. 47697c478bd9Sstevel@tonic-gate */ 4770a19609f8Sjv ASSERT(zone->zone_cred_ref == 1); 47717c478bd9Sstevel@tonic-gate ASSERT(zone->zone_kcred->cr_ref == 1); 47727c478bd9Sstevel@tonic-gate ASSERT(zone->zone_ref == 0); 47737c478bd9Sstevel@tonic-gate zkcr = zone->zone_kcred; 47747c478bd9Sstevel@tonic-gate zone->zone_kcred = NULL; 47757c478bd9Sstevel@tonic-gate crfree(zkcr); /* triggers call to zone_free */ 47767c478bd9Sstevel@tonic-gate return (zone_create_error(error, error2, extended_error)); 47777c478bd9Sstevel@tonic-gate } 47787c478bd9Sstevel@tonic-gate 47797c478bd9Sstevel@tonic-gate /* 47807c478bd9Sstevel@tonic-gate * Cause the zone to boot. This is pretty simple, since we let zoneadmd do 47813f2f09c1Sdp * the heavy lifting. initname is the path to the program to launch 47823f2f09c1Sdp * at the "top" of the zone; if this is NULL, we use the system default, 47833f2f09c1Sdp * which is stored at zone_default_initname. 47847c478bd9Sstevel@tonic-gate */ 47857c478bd9Sstevel@tonic-gate static int 47863f2f09c1Sdp zone_boot(zoneid_t zoneid) 47877c478bd9Sstevel@tonic-gate { 47887c478bd9Sstevel@tonic-gate int err; 47897c478bd9Sstevel@tonic-gate zone_t *zone; 47907c478bd9Sstevel@tonic-gate 47917c478bd9Sstevel@tonic-gate if (secpolicy_zone_config(CRED()) != 0) 47927c478bd9Sstevel@tonic-gate return (set_errno(EPERM)); 47937c478bd9Sstevel@tonic-gate if (zoneid < MIN_USERZONEID || zoneid > MAX_ZONEID) 47947c478bd9Sstevel@tonic-gate return (set_errno(EINVAL)); 47957c478bd9Sstevel@tonic-gate 47967c478bd9Sstevel@tonic-gate mutex_enter(&zonehash_lock); 47977c478bd9Sstevel@tonic-gate /* 47987c478bd9Sstevel@tonic-gate * Look for zone under hash lock to prevent races with calls to 47997c478bd9Sstevel@tonic-gate * zone_shutdown, zone_destroy, etc. 48007c478bd9Sstevel@tonic-gate */ 48017c478bd9Sstevel@tonic-gate if ((zone = zone_find_all_by_id(zoneid)) == NULL) { 48027c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 48037c478bd9Sstevel@tonic-gate return (set_errno(EINVAL)); 48047c478bd9Sstevel@tonic-gate } 48057c478bd9Sstevel@tonic-gate 48067c478bd9Sstevel@tonic-gate mutex_enter(&zone_status_lock); 48077c478bd9Sstevel@tonic-gate if (zone_status_get(zone) != ZONE_IS_READY) { 48087c478bd9Sstevel@tonic-gate mutex_exit(&zone_status_lock); 48097c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 48107c478bd9Sstevel@tonic-gate return (set_errno(EINVAL)); 48117c478bd9Sstevel@tonic-gate } 48127c478bd9Sstevel@tonic-gate zone_status_set(zone, ZONE_IS_BOOTING); 48137c478bd9Sstevel@tonic-gate mutex_exit(&zone_status_lock); 48147c478bd9Sstevel@tonic-gate 48157c478bd9Sstevel@tonic-gate zone_hold(zone); /* so we can use the zone_t later */ 48167c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 48177c478bd9Sstevel@tonic-gate 48187c478bd9Sstevel@tonic-gate if (zone_status_wait_sig(zone, ZONE_IS_RUNNING) == 0) { 48197c478bd9Sstevel@tonic-gate zone_rele(zone); 48207c478bd9Sstevel@tonic-gate return (set_errno(EINTR)); 48217c478bd9Sstevel@tonic-gate } 48227c478bd9Sstevel@tonic-gate 48237c478bd9Sstevel@tonic-gate /* 48247c478bd9Sstevel@tonic-gate * Boot (starting init) might have failed, in which case the zone 48257c478bd9Sstevel@tonic-gate * will go to the SHUTTING_DOWN state; an appropriate errno will 48267c478bd9Sstevel@tonic-gate * be placed in zone->zone_boot_err, and so we return that. 48277c478bd9Sstevel@tonic-gate */ 48287c478bd9Sstevel@tonic-gate err = zone->zone_boot_err; 48297c478bd9Sstevel@tonic-gate zone_rele(zone); 48307c478bd9Sstevel@tonic-gate return (err ? set_errno(err) : 0); 48317c478bd9Sstevel@tonic-gate } 48327c478bd9Sstevel@tonic-gate 48337c478bd9Sstevel@tonic-gate /* 48347c478bd9Sstevel@tonic-gate * Kills all user processes in the zone, waiting for them all to exit 48357c478bd9Sstevel@tonic-gate * before returning. 48367c478bd9Sstevel@tonic-gate */ 48377c478bd9Sstevel@tonic-gate static int 48387c478bd9Sstevel@tonic-gate zone_empty(zone_t *zone) 48397c478bd9Sstevel@tonic-gate { 48407c478bd9Sstevel@tonic-gate int waitstatus; 48417c478bd9Sstevel@tonic-gate 48427c478bd9Sstevel@tonic-gate /* 48437c478bd9Sstevel@tonic-gate * We need to drop zonehash_lock before killing all 48447c478bd9Sstevel@tonic-gate * processes, otherwise we'll deadlock with zone_find_* 48457c478bd9Sstevel@tonic-gate * which can be called from the exit path. 48467c478bd9Sstevel@tonic-gate */ 48477c478bd9Sstevel@tonic-gate ASSERT(MUTEX_NOT_HELD(&zonehash_lock)); 4848d3d50737SRafael Vanoni while ((waitstatus = zone_status_timedwait_sig(zone, 4849d3d50737SRafael Vanoni ddi_get_lbolt() + hz, ZONE_IS_EMPTY)) == -1) { 48507c478bd9Sstevel@tonic-gate killall(zone->zone_id); 48517c478bd9Sstevel@tonic-gate } 48527c478bd9Sstevel@tonic-gate /* 48537c478bd9Sstevel@tonic-gate * return EINTR if we were signaled 48547c478bd9Sstevel@tonic-gate */ 48557c478bd9Sstevel@tonic-gate if (waitstatus == 0) 48567c478bd9Sstevel@tonic-gate return (EINTR); 48577c478bd9Sstevel@tonic-gate return (0); 48587c478bd9Sstevel@tonic-gate } 48597c478bd9Sstevel@tonic-gate 486045916cd2Sjpk /* 486145916cd2Sjpk * This function implements the policy for zone visibility. 486245916cd2Sjpk * 486345916cd2Sjpk * In standard Solaris, a non-global zone can only see itself. 486445916cd2Sjpk * 486545916cd2Sjpk * In Trusted Extensions, a labeled zone can lookup any zone whose label 486645916cd2Sjpk * it dominates. For this test, the label of the global zone is treated as 486745916cd2Sjpk * admin_high so it is special-cased instead of being checked for dominance. 486845916cd2Sjpk * 486945916cd2Sjpk * Returns true if zone attributes are viewable, false otherwise. 487045916cd2Sjpk */ 487145916cd2Sjpk static boolean_t 487245916cd2Sjpk zone_list_access(zone_t *zone) 487345916cd2Sjpk { 487445916cd2Sjpk 487545916cd2Sjpk if (curproc->p_zone == global_zone || 487645916cd2Sjpk curproc->p_zone == zone) { 487745916cd2Sjpk return (B_TRUE); 487848451833Scarlsonj } else if (is_system_labeled() && !(zone->zone_flags & ZF_IS_SCRATCH)) { 487945916cd2Sjpk bslabel_t *curproc_label; 488045916cd2Sjpk bslabel_t *zone_label; 488145916cd2Sjpk 488245916cd2Sjpk curproc_label = label2bslabel(curproc->p_zone->zone_slabel); 488345916cd2Sjpk zone_label = label2bslabel(zone->zone_slabel); 488445916cd2Sjpk 488545916cd2Sjpk if (zone->zone_id != GLOBAL_ZONEID && 488645916cd2Sjpk bldominates(curproc_label, zone_label)) { 488745916cd2Sjpk return (B_TRUE); 488845916cd2Sjpk } else { 488945916cd2Sjpk return (B_FALSE); 489045916cd2Sjpk } 489145916cd2Sjpk } else { 489245916cd2Sjpk return (B_FALSE); 489345916cd2Sjpk } 489445916cd2Sjpk } 489545916cd2Sjpk 48967c478bd9Sstevel@tonic-gate /* 48977c478bd9Sstevel@tonic-gate * Systemcall to start the zone's halt sequence. By the time this 48987c478bd9Sstevel@tonic-gate * function successfully returns, all user processes and kernel threads 48997c478bd9Sstevel@tonic-gate * executing in it will have exited, ZSD shutdown callbacks executed, 49007c478bd9Sstevel@tonic-gate * and the zone status set to ZONE_IS_DOWN. 49017c478bd9Sstevel@tonic-gate * 49027c478bd9Sstevel@tonic-gate * It is possible that the call will interrupt itself if the caller is the 49037c478bd9Sstevel@tonic-gate * parent of any process running in the zone, and doesn't have SIGCHLD blocked. 49047c478bd9Sstevel@tonic-gate */ 49057c478bd9Sstevel@tonic-gate static int 49067c478bd9Sstevel@tonic-gate zone_shutdown(zoneid_t zoneid) 49077c478bd9Sstevel@tonic-gate { 49087c478bd9Sstevel@tonic-gate int error; 49097c478bd9Sstevel@tonic-gate zone_t *zone; 49107c478bd9Sstevel@tonic-gate zone_status_t status; 49117c478bd9Sstevel@tonic-gate 49127c478bd9Sstevel@tonic-gate if (secpolicy_zone_config(CRED()) != 0) 49137c478bd9Sstevel@tonic-gate return (set_errno(EPERM)); 49147c478bd9Sstevel@tonic-gate if (zoneid < MIN_USERZONEID || zoneid > MAX_ZONEID) 49157c478bd9Sstevel@tonic-gate return (set_errno(EINVAL)); 49167c478bd9Sstevel@tonic-gate 49177c478bd9Sstevel@tonic-gate mutex_enter(&zonehash_lock); 49187c478bd9Sstevel@tonic-gate /* 49197c478bd9Sstevel@tonic-gate * Look for zone under hash lock to prevent races with other 49207c478bd9Sstevel@tonic-gate * calls to zone_shutdown and zone_destroy. 49217c478bd9Sstevel@tonic-gate */ 49227c478bd9Sstevel@tonic-gate if ((zone = zone_find_all_by_id(zoneid)) == NULL) { 49237c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 49247c478bd9Sstevel@tonic-gate return (set_errno(EINVAL)); 49257c478bd9Sstevel@tonic-gate } 49265fd5c689SJerry Jelinek 49275fd5c689SJerry Jelinek /* 49285fd5c689SJerry Jelinek * We have to drop zonehash_lock before calling block_mounts. 49295fd5c689SJerry Jelinek * Hold the zone so we can continue to use the zone_t. 49305fd5c689SJerry Jelinek */ 49315fd5c689SJerry Jelinek zone_hold(zone); 49325fd5c689SJerry Jelinek mutex_exit(&zonehash_lock); 49335fd5c689SJerry Jelinek 49345fd5c689SJerry Jelinek /* 49355fd5c689SJerry Jelinek * Block mounts so that VFS_MOUNT() can get an accurate view of 49365fd5c689SJerry Jelinek * the zone's status with regards to ZONE_IS_SHUTTING down. 49375fd5c689SJerry Jelinek * 49385fd5c689SJerry Jelinek * e.g. NFS can fail the mount if it determines that the zone 49395fd5c689SJerry Jelinek * has already begun the shutdown sequence. 49405fd5c689SJerry Jelinek * 49415fd5c689SJerry Jelinek */ 49425fd5c689SJerry Jelinek if (block_mounts(zone) == 0) { 49435fd5c689SJerry Jelinek zone_rele(zone); 49445fd5c689SJerry Jelinek return (set_errno(EINTR)); 49455fd5c689SJerry Jelinek } 49465fd5c689SJerry Jelinek 49475fd5c689SJerry Jelinek mutex_enter(&zonehash_lock); 49487c478bd9Sstevel@tonic-gate mutex_enter(&zone_status_lock); 49497c478bd9Sstevel@tonic-gate status = zone_status_get(zone); 49507c478bd9Sstevel@tonic-gate /* 49517c478bd9Sstevel@tonic-gate * Fail if the zone isn't fully initialized yet. 49527c478bd9Sstevel@tonic-gate */ 49537c478bd9Sstevel@tonic-gate if (status < ZONE_IS_READY) { 49547c478bd9Sstevel@tonic-gate mutex_exit(&zone_status_lock); 49557c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 49565fd5c689SJerry Jelinek resume_mounts(zone); 49575fd5c689SJerry Jelinek zone_rele(zone); 49587c478bd9Sstevel@tonic-gate return (set_errno(EINVAL)); 49597c478bd9Sstevel@tonic-gate } 49607c478bd9Sstevel@tonic-gate /* 49617c478bd9Sstevel@tonic-gate * If conditions required for zone_shutdown() to return have been met, 49627c478bd9Sstevel@tonic-gate * return success. 49637c478bd9Sstevel@tonic-gate */ 49647c478bd9Sstevel@tonic-gate if (status >= ZONE_IS_DOWN) { 49657c478bd9Sstevel@tonic-gate mutex_exit(&zone_status_lock); 49667c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 49675fd5c689SJerry Jelinek resume_mounts(zone); 49685fd5c689SJerry Jelinek zone_rele(zone); 49697c478bd9Sstevel@tonic-gate return (0); 49707c478bd9Sstevel@tonic-gate } 49717c478bd9Sstevel@tonic-gate /* 49727c478bd9Sstevel@tonic-gate * If zone_shutdown() hasn't been called before, go through the motions. 49737c478bd9Sstevel@tonic-gate * If it has, there's nothing to do but wait for the kernel threads to 49747c478bd9Sstevel@tonic-gate * drain. 49757c478bd9Sstevel@tonic-gate */ 49767c478bd9Sstevel@tonic-gate if (status < ZONE_IS_EMPTY) { 49777c478bd9Sstevel@tonic-gate uint_t ntasks; 49787c478bd9Sstevel@tonic-gate 49797c478bd9Sstevel@tonic-gate mutex_enter(&zone->zone_lock); 49807c478bd9Sstevel@tonic-gate if ((ntasks = zone->zone_ntasks) != 1) { 49817c478bd9Sstevel@tonic-gate /* 49827c478bd9Sstevel@tonic-gate * There's still stuff running. 49837c478bd9Sstevel@tonic-gate */ 49847c478bd9Sstevel@tonic-gate zone_status_set(zone, ZONE_IS_SHUTTING_DOWN); 49857c478bd9Sstevel@tonic-gate } 49867c478bd9Sstevel@tonic-gate mutex_exit(&zone->zone_lock); 49877c478bd9Sstevel@tonic-gate if (ntasks == 1) { 49887c478bd9Sstevel@tonic-gate /* 49897c478bd9Sstevel@tonic-gate * The only way to create another task is through 49907c478bd9Sstevel@tonic-gate * zone_enter(), which will block until we drop 49917c478bd9Sstevel@tonic-gate * zonehash_lock. The zone is empty. 49927c478bd9Sstevel@tonic-gate */ 49937c478bd9Sstevel@tonic-gate if (zone->zone_kthreads == NULL) { 49947c478bd9Sstevel@tonic-gate /* 49957c478bd9Sstevel@tonic-gate * Skip ahead to ZONE_IS_DOWN 49967c478bd9Sstevel@tonic-gate */ 49977c478bd9Sstevel@tonic-gate zone_status_set(zone, ZONE_IS_DOWN); 49987c478bd9Sstevel@tonic-gate } else { 49997c478bd9Sstevel@tonic-gate zone_status_set(zone, ZONE_IS_EMPTY); 50007c478bd9Sstevel@tonic-gate } 50017c478bd9Sstevel@tonic-gate } 50027c478bd9Sstevel@tonic-gate } 50037c478bd9Sstevel@tonic-gate mutex_exit(&zone_status_lock); 50047c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 50055fd5c689SJerry Jelinek resume_mounts(zone); 50067c478bd9Sstevel@tonic-gate 50077c478bd9Sstevel@tonic-gate if (error = zone_empty(zone)) { 50087c478bd9Sstevel@tonic-gate zone_rele(zone); 50097c478bd9Sstevel@tonic-gate return (set_errno(error)); 50107c478bd9Sstevel@tonic-gate } 50117c478bd9Sstevel@tonic-gate /* 50127c478bd9Sstevel@tonic-gate * After the zone status goes to ZONE_IS_DOWN this zone will no 50137c478bd9Sstevel@tonic-gate * longer be notified of changes to the pools configuration, so 50147c478bd9Sstevel@tonic-gate * in order to not end up with a stale pool pointer, we point 50157c478bd9Sstevel@tonic-gate * ourselves at the default pool and remove all resource 50167c478bd9Sstevel@tonic-gate * visibility. This is especially important as the zone_t may 50177c478bd9Sstevel@tonic-gate * languish on the deathrow for a very long time waiting for 50187c478bd9Sstevel@tonic-gate * cred's to drain out. 50197c478bd9Sstevel@tonic-gate * 50207c478bd9Sstevel@tonic-gate * This rebinding of the zone can happen multiple times 50217c478bd9Sstevel@tonic-gate * (presumably due to interrupted or parallel systemcalls) 50227c478bd9Sstevel@tonic-gate * without any adverse effects. 50237c478bd9Sstevel@tonic-gate */ 50247c478bd9Sstevel@tonic-gate if (pool_lock_intr() != 0) { 50257c478bd9Sstevel@tonic-gate zone_rele(zone); 50267c478bd9Sstevel@tonic-gate return (set_errno(EINTR)); 50277c478bd9Sstevel@tonic-gate } 50287c478bd9Sstevel@tonic-gate if (pool_state == POOL_ENABLED) { 50297c478bd9Sstevel@tonic-gate mutex_enter(&cpu_lock); 50307c478bd9Sstevel@tonic-gate zone_pool_set(zone, pool_default); 50317c478bd9Sstevel@tonic-gate /* 50327c478bd9Sstevel@tonic-gate * The zone no longer needs to be able to see any cpus. 50337c478bd9Sstevel@tonic-gate */ 50347c478bd9Sstevel@tonic-gate zone_pset_set(zone, ZONE_PS_INVAL); 50357c478bd9Sstevel@tonic-gate mutex_exit(&cpu_lock); 50367c478bd9Sstevel@tonic-gate } 50377c478bd9Sstevel@tonic-gate pool_unlock(); 50387c478bd9Sstevel@tonic-gate 50397c478bd9Sstevel@tonic-gate /* 50407c478bd9Sstevel@tonic-gate * ZSD shutdown callbacks can be executed multiple times, hence 50417c478bd9Sstevel@tonic-gate * it is safe to not be holding any locks across this call. 50427c478bd9Sstevel@tonic-gate */ 50437c478bd9Sstevel@tonic-gate zone_zsd_callbacks(zone, ZSD_SHUTDOWN); 50447c478bd9Sstevel@tonic-gate 50457c478bd9Sstevel@tonic-gate mutex_enter(&zone_status_lock); 50467c478bd9Sstevel@tonic-gate if (zone->zone_kthreads == NULL && zone_status_get(zone) < ZONE_IS_DOWN) 50477c478bd9Sstevel@tonic-gate zone_status_set(zone, ZONE_IS_DOWN); 50487c478bd9Sstevel@tonic-gate mutex_exit(&zone_status_lock); 50497c478bd9Sstevel@tonic-gate 50507c478bd9Sstevel@tonic-gate /* 50517c478bd9Sstevel@tonic-gate * Wait for kernel threads to drain. 50527c478bd9Sstevel@tonic-gate */ 50537c478bd9Sstevel@tonic-gate if (!zone_status_wait_sig(zone, ZONE_IS_DOWN)) { 50547c478bd9Sstevel@tonic-gate zone_rele(zone); 50557c478bd9Sstevel@tonic-gate return (set_errno(EINTR)); 50567c478bd9Sstevel@tonic-gate } 50579acbbeafSnn 505852978630Ssl /* 505952978630Ssl * Zone can be become down/destroyable even if the above wait 506052978630Ssl * returns EINTR, so any code added here may never execute. 506152978630Ssl * (i.e. don't add code here) 506252978630Ssl */ 50639acbbeafSnn 50647c478bd9Sstevel@tonic-gate zone_rele(zone); 50657c478bd9Sstevel@tonic-gate return (0); 50667c478bd9Sstevel@tonic-gate } 50677c478bd9Sstevel@tonic-gate 5068a19609f8Sjv /* 5069a19609f8Sjv * Log the specified zone's reference counts. The caller should not be 5070a19609f8Sjv * holding the zone's zone_lock. 5071a19609f8Sjv */ 5072a19609f8Sjv static void 5073a19609f8Sjv zone_log_refcounts(zone_t *zone) 5074a19609f8Sjv { 5075a19609f8Sjv char *buffer; 5076a19609f8Sjv char *buffer_position; 5077a19609f8Sjv uint32_t buffer_size; 5078a19609f8Sjv uint32_t index; 5079a19609f8Sjv uint_t ref; 5080a19609f8Sjv uint_t cred_ref; 5081a19609f8Sjv 5082a19609f8Sjv /* 5083a19609f8Sjv * Construct a string representing the subsystem-specific reference 5084a19609f8Sjv * counts. The counts are printed in ascending order by index into the 5085a19609f8Sjv * zone_t::zone_subsys_ref array. The list will be surrounded by 5086a19609f8Sjv * square brackets [] and will only contain nonzero reference counts. 5087a19609f8Sjv * 5088a19609f8Sjv * The buffer will hold two square bracket characters plus ten digits, 5089a19609f8Sjv * one colon, one space, one comma, and some characters for a 5090a19609f8Sjv * subsystem name per subsystem-specific reference count. (Unsigned 32- 5091a19609f8Sjv * bit integers have at most ten decimal digits.) The last 5092a19609f8Sjv * reference count's comma is replaced by the closing square 5093a19609f8Sjv * bracket and a NULL character to terminate the string. 5094a19609f8Sjv * 5095a19609f8Sjv * NOTE: We have to grab the zone's zone_lock to create a consistent 5096a19609f8Sjv * snapshot of the zone's reference counters. 5097a19609f8Sjv * 5098a19609f8Sjv * First, figure out how much space the string buffer will need. 5099a19609f8Sjv * The buffer's size is stored in buffer_size. 5100a19609f8Sjv */ 5101a19609f8Sjv buffer_size = 2; /* for the square brackets */ 5102a19609f8Sjv mutex_enter(&zone->zone_lock); 5103a19609f8Sjv zone->zone_flags |= ZF_REFCOUNTS_LOGGED; 5104a19609f8Sjv ref = zone->zone_ref; 5105a19609f8Sjv cred_ref = zone->zone_cred_ref; 5106a19609f8Sjv for (index = 0; index < ZONE_REF_NUM_SUBSYS; ++index) 5107a19609f8Sjv if (zone->zone_subsys_ref[index] != 0) 5108a19609f8Sjv buffer_size += strlen(zone_ref_subsys_names[index]) + 5109a19609f8Sjv 13; 5110a19609f8Sjv if (buffer_size == 2) { 5111a19609f8Sjv /* 5112a19609f8Sjv * No subsystems had nonzero reference counts. Don't bother 5113a19609f8Sjv * with allocating a buffer; just log the general-purpose and 5114a19609f8Sjv * credential reference counts. 5115a19609f8Sjv */ 5116a19609f8Sjv mutex_exit(&zone->zone_lock); 5117a19609f8Sjv (void) strlog(0, 0, 1, SL_CONSOLE | SL_NOTE, 5118a19609f8Sjv "Zone '%s' (ID: %d) is shutting down, but %u zone " 5119a19609f8Sjv "references and %u credential references are still extant", 5120a19609f8Sjv zone->zone_name, zone->zone_id, ref, cred_ref); 5121a19609f8Sjv return; 5122a19609f8Sjv } 5123a19609f8Sjv 5124a19609f8Sjv /* 5125a19609f8Sjv * buffer_size contains the exact number of characters that the 5126a19609f8Sjv * buffer will need. Allocate the buffer and fill it with nonzero 5127a19609f8Sjv * subsystem-specific reference counts. Surround the results with 5128a19609f8Sjv * square brackets afterwards. 5129a19609f8Sjv */ 5130a19609f8Sjv buffer = kmem_alloc(buffer_size, KM_SLEEP); 5131a19609f8Sjv buffer_position = &buffer[1]; 5132a19609f8Sjv for (index = 0; index < ZONE_REF_NUM_SUBSYS; ++index) { 5133a19609f8Sjv /* 5134a19609f8Sjv * NOTE: The DDI's version of sprintf() returns a pointer to 5135a19609f8Sjv * the modified buffer rather than the number of bytes written 5136a19609f8Sjv * (as in snprintf(3C)). This is unfortunate and annoying. 5137a19609f8Sjv * Therefore, we'll use snprintf() with INT_MAX to get the 5138a19609f8Sjv * number of bytes written. Using INT_MAX is safe because 5139a19609f8Sjv * the buffer is perfectly sized for the data: we'll never 5140a19609f8Sjv * overrun the buffer. 5141a19609f8Sjv */ 5142a19609f8Sjv if (zone->zone_subsys_ref[index] != 0) 5143a19609f8Sjv buffer_position += snprintf(buffer_position, INT_MAX, 5144a19609f8Sjv "%s: %u,", zone_ref_subsys_names[index], 5145a19609f8Sjv zone->zone_subsys_ref[index]); 5146a19609f8Sjv } 5147a19609f8Sjv mutex_exit(&zone->zone_lock); 5148a19609f8Sjv buffer[0] = '['; 5149a19609f8Sjv ASSERT((uintptr_t)(buffer_position - buffer) < buffer_size); 5150a19609f8Sjv ASSERT(buffer_position[0] == '\0' && buffer_position[-1] == ','); 5151a19609f8Sjv buffer_position[-1] = ']'; 5152a19609f8Sjv 5153a19609f8Sjv /* 5154a19609f8Sjv * Log the reference counts and free the message buffer. 5155a19609f8Sjv */ 5156a19609f8Sjv (void) strlog(0, 0, 1, SL_CONSOLE | SL_NOTE, 5157a19609f8Sjv "Zone '%s' (ID: %d) is shutting down, but %u zone references and " 5158a19609f8Sjv "%u credential references are still extant %s", zone->zone_name, 5159a19609f8Sjv zone->zone_id, ref, cred_ref, buffer); 5160a19609f8Sjv kmem_free(buffer, buffer_size); 5161a19609f8Sjv } 5162a19609f8Sjv 51637c478bd9Sstevel@tonic-gate /* 51647c478bd9Sstevel@tonic-gate * Systemcall entry point to finalize the zone halt process. The caller 5165824c205fSml * must have already successfully called zone_shutdown(). 51667c478bd9Sstevel@tonic-gate * 51677c478bd9Sstevel@tonic-gate * Upon successful completion, the zone will have been fully destroyed: 51687c478bd9Sstevel@tonic-gate * zsched will have exited, destructor callbacks executed, and the zone 51697c478bd9Sstevel@tonic-gate * removed from the list of active zones. 51707c478bd9Sstevel@tonic-gate */ 51717c478bd9Sstevel@tonic-gate static int 51727c478bd9Sstevel@tonic-gate zone_destroy(zoneid_t zoneid) 51737c478bd9Sstevel@tonic-gate { 51747c478bd9Sstevel@tonic-gate uint64_t uniqid; 51757c478bd9Sstevel@tonic-gate zone_t *zone; 51767c478bd9Sstevel@tonic-gate zone_status_t status; 5177a19609f8Sjv clock_t wait_time; 5178a19609f8Sjv boolean_t log_refcounts; 51797c478bd9Sstevel@tonic-gate 51807c478bd9Sstevel@tonic-gate if (secpolicy_zone_config(CRED()) != 0) 51817c478bd9Sstevel@tonic-gate return (set_errno(EPERM)); 51827c478bd9Sstevel@tonic-gate if (zoneid < MIN_USERZONEID || zoneid > MAX_ZONEID) 51837c478bd9Sstevel@tonic-gate return (set_errno(EINVAL)); 51847c478bd9Sstevel@tonic-gate 51857c478bd9Sstevel@tonic-gate mutex_enter(&zonehash_lock); 51867c478bd9Sstevel@tonic-gate /* 51877c478bd9Sstevel@tonic-gate * Look for zone under hash lock to prevent races with other 51887c478bd9Sstevel@tonic-gate * calls to zone_destroy. 51897c478bd9Sstevel@tonic-gate */ 51907c478bd9Sstevel@tonic-gate if ((zone = zone_find_all_by_id(zoneid)) == NULL) { 51917c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 51927c478bd9Sstevel@tonic-gate return (set_errno(EINVAL)); 51937c478bd9Sstevel@tonic-gate } 51947c478bd9Sstevel@tonic-gate 51957c478bd9Sstevel@tonic-gate if (zone_mount_count(zone->zone_rootpath) != 0) { 51967c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 51977c478bd9Sstevel@tonic-gate return (set_errno(EBUSY)); 51987c478bd9Sstevel@tonic-gate } 51997c478bd9Sstevel@tonic-gate mutex_enter(&zone_status_lock); 52007c478bd9Sstevel@tonic-gate status = zone_status_get(zone); 52017c478bd9Sstevel@tonic-gate if (status < ZONE_IS_DOWN) { 52027c478bd9Sstevel@tonic-gate mutex_exit(&zone_status_lock); 52037c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 52047c478bd9Sstevel@tonic-gate return (set_errno(EBUSY)); 52057c478bd9Sstevel@tonic-gate } else if (status == ZONE_IS_DOWN) { 52067c478bd9Sstevel@tonic-gate zone_status_set(zone, ZONE_IS_DYING); /* Tell zsched to exit */ 52077c478bd9Sstevel@tonic-gate } 52087c478bd9Sstevel@tonic-gate mutex_exit(&zone_status_lock); 52097c478bd9Sstevel@tonic-gate zone_hold(zone); 52107c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 52117c478bd9Sstevel@tonic-gate 52127c478bd9Sstevel@tonic-gate /* 52137c478bd9Sstevel@tonic-gate * wait for zsched to exit 52147c478bd9Sstevel@tonic-gate */ 52157c478bd9Sstevel@tonic-gate zone_status_wait(zone, ZONE_IS_DEAD); 52167c478bd9Sstevel@tonic-gate zone_zsd_callbacks(zone, ZSD_DESTROY); 5217f4b3ec61Sdh zone->zone_netstack = NULL; 52187c478bd9Sstevel@tonic-gate uniqid = zone->zone_uniqid; 52197c478bd9Sstevel@tonic-gate zone_rele(zone); 52207c478bd9Sstevel@tonic-gate zone = NULL; /* potentially free'd */ 52217c478bd9Sstevel@tonic-gate 5222a19609f8Sjv log_refcounts = B_FALSE; 5223a19609f8Sjv wait_time = SEC_TO_TICK(ZONE_DESTROY_TIMEOUT_SECS); 52247c478bd9Sstevel@tonic-gate mutex_enter(&zonehash_lock); 52257c478bd9Sstevel@tonic-gate for (; /* ever */; ) { 52267c478bd9Sstevel@tonic-gate boolean_t unref; 5227a19609f8Sjv boolean_t refs_have_been_logged; 52287c478bd9Sstevel@tonic-gate 52297c478bd9Sstevel@tonic-gate if ((zone = zone_find_all_by_id(zoneid)) == NULL || 52307c478bd9Sstevel@tonic-gate zone->zone_uniqid != uniqid) { 52317c478bd9Sstevel@tonic-gate /* 52327c478bd9Sstevel@tonic-gate * The zone has gone away. Necessary conditions 52337c478bd9Sstevel@tonic-gate * are met, so we return success. 52347c478bd9Sstevel@tonic-gate */ 52357c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 52367c478bd9Sstevel@tonic-gate return (0); 52377c478bd9Sstevel@tonic-gate } 52387c478bd9Sstevel@tonic-gate mutex_enter(&zone->zone_lock); 52397c478bd9Sstevel@tonic-gate unref = ZONE_IS_UNREF(zone); 5240a19609f8Sjv refs_have_been_logged = (zone->zone_flags & 5241a19609f8Sjv ZF_REFCOUNTS_LOGGED); 52427c478bd9Sstevel@tonic-gate mutex_exit(&zone->zone_lock); 52437c478bd9Sstevel@tonic-gate if (unref) { 52447c478bd9Sstevel@tonic-gate /* 52457c478bd9Sstevel@tonic-gate * There is only one reference to the zone -- that 52467c478bd9Sstevel@tonic-gate * added when the zone was added to the hashtables -- 52477c478bd9Sstevel@tonic-gate * and things will remain this way until we drop 52487c478bd9Sstevel@tonic-gate * zonehash_lock... we can go ahead and cleanup the 52497c478bd9Sstevel@tonic-gate * zone. 52507c478bd9Sstevel@tonic-gate */ 52517c478bd9Sstevel@tonic-gate break; 52527c478bd9Sstevel@tonic-gate } 52537c478bd9Sstevel@tonic-gate 5254a19609f8Sjv /* 5255a19609f8Sjv * Wait for zone_rele_common() or zone_cred_rele() to signal 5256a19609f8Sjv * zone_destroy_cv. zone_destroy_cv is signaled only when 5257a19609f8Sjv * some zone's general-purpose reference count reaches one. 5258a19609f8Sjv * If ZONE_DESTROY_TIMEOUT_SECS seconds elapse while waiting 5259a19609f8Sjv * on zone_destroy_cv, then log the zone's reference counts and 5260a19609f8Sjv * continue to wait for zone_rele() and zone_cred_rele(). 5261a19609f8Sjv */ 5262a19609f8Sjv if (!refs_have_been_logged) { 5263a19609f8Sjv if (!log_refcounts) { 5264a19609f8Sjv /* 5265a19609f8Sjv * This thread hasn't timed out waiting on 5266a19609f8Sjv * zone_destroy_cv yet. Wait wait_time clock 5267a19609f8Sjv * ticks (initially ZONE_DESTROY_TIMEOUT_SECS 5268a19609f8Sjv * seconds) for the zone's references to clear. 5269a19609f8Sjv */ 5270a19609f8Sjv ASSERT(wait_time > 0); 5271a19609f8Sjv wait_time = cv_reltimedwait_sig( 5272a19609f8Sjv &zone_destroy_cv, &zonehash_lock, wait_time, 5273a19609f8Sjv TR_SEC); 5274a19609f8Sjv if (wait_time > 0) { 5275a19609f8Sjv /* 5276a19609f8Sjv * A thread in zone_rele() or 5277a19609f8Sjv * zone_cred_rele() signaled 5278a19609f8Sjv * zone_destroy_cv before this thread's 5279a19609f8Sjv * wait timed out. The zone might have 5280a19609f8Sjv * only one reference left; find out! 5281a19609f8Sjv */ 5282a19609f8Sjv continue; 5283a19609f8Sjv } else if (wait_time == 0) { 5284a19609f8Sjv /* The thread's process was signaled. */ 5285a19609f8Sjv mutex_exit(&zonehash_lock); 5286a19609f8Sjv return (set_errno(EINTR)); 5287a19609f8Sjv } 5288a19609f8Sjv 5289a19609f8Sjv /* 5290a19609f8Sjv * The thread timed out while waiting on 5291a19609f8Sjv * zone_destroy_cv. Even though the thread 5292a19609f8Sjv * timed out, it has to check whether another 5293a19609f8Sjv * thread woke up from zone_destroy_cv and 5294a19609f8Sjv * destroyed the zone. 5295a19609f8Sjv * 5296a19609f8Sjv * If the zone still exists and has more than 5297a19609f8Sjv * one unreleased general-purpose reference, 5298a19609f8Sjv * then log the zone's reference counts. 5299a19609f8Sjv */ 5300a19609f8Sjv log_refcounts = B_TRUE; 5301a19609f8Sjv continue; 5302a19609f8Sjv } 5303a19609f8Sjv 5304a19609f8Sjv /* 5305a19609f8Sjv * The thread already timed out on zone_destroy_cv while 5306a19609f8Sjv * waiting for subsystems to release the zone's last 5307a19609f8Sjv * general-purpose references. Log the zone's reference 5308a19609f8Sjv * counts and wait indefinitely on zone_destroy_cv. 5309a19609f8Sjv */ 5310a19609f8Sjv zone_log_refcounts(zone); 5311a19609f8Sjv } 53127c478bd9Sstevel@tonic-gate if (cv_wait_sig(&zone_destroy_cv, &zonehash_lock) == 0) { 5313a19609f8Sjv /* The thread's process was signaled. */ 53147c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 53157c478bd9Sstevel@tonic-gate return (set_errno(EINTR)); 53167c478bd9Sstevel@tonic-gate } 53177c478bd9Sstevel@tonic-gate } 53187c478bd9Sstevel@tonic-gate 5319c97ad5cdSakolb /* 5320c97ad5cdSakolb * Remove CPU cap for this zone now since we're not going to 5321c97ad5cdSakolb * fail below this point. 5322c97ad5cdSakolb */ 5323c97ad5cdSakolb cpucaps_zone_remove(zone); 5324c97ad5cdSakolb 5325c97ad5cdSakolb /* Get rid of the zone's kstats */ 53260209230bSgjelinek zone_kstat_delete(zone); 53270209230bSgjelinek 5328134a1f4eSCasper H.S. Dik /* remove the pfexecd doors */ 5329134a1f4eSCasper H.S. Dik if (zone->zone_pfexecd != NULL) { 5330134a1f4eSCasper H.S. Dik klpd_freelist(&zone->zone_pfexecd); 5331134a1f4eSCasper H.S. Dik zone->zone_pfexecd = NULL; 5332134a1f4eSCasper H.S. Dik } 5333134a1f4eSCasper H.S. Dik 5334319378d9Seh /* free brand specific data */ 5335319378d9Seh if (ZONE_IS_BRANDED(zone)) 5336319378d9Seh ZBROP(zone)->b_free_brand_data(zone); 5337319378d9Seh 533852978630Ssl /* Say goodbye to brand framework. */ 533952978630Ssl brand_unregister_zone(zone->zone_brand); 534052978630Ssl 53417c478bd9Sstevel@tonic-gate /* 53427c478bd9Sstevel@tonic-gate * It is now safe to let the zone be recreated; remove it from the 53437c478bd9Sstevel@tonic-gate * lists. The memory will not be freed until the last cred 53447c478bd9Sstevel@tonic-gate * reference goes away. 53457c478bd9Sstevel@tonic-gate */ 53467c478bd9Sstevel@tonic-gate ASSERT(zonecount > 1); /* must be > 1; can't destroy global zone */ 53477c478bd9Sstevel@tonic-gate zonecount--; 53487c478bd9Sstevel@tonic-gate /* remove from active list and hash tables */ 53497c478bd9Sstevel@tonic-gate list_remove(&zone_active, zone); 53507c478bd9Sstevel@tonic-gate (void) mod_hash_destroy(zonehashbyname, 53517c478bd9Sstevel@tonic-gate (mod_hash_key_t)zone->zone_name); 53527c478bd9Sstevel@tonic-gate (void) mod_hash_destroy(zonehashbyid, 53537c478bd9Sstevel@tonic-gate (mod_hash_key_t)(uintptr_t)zone->zone_id); 535448451833Scarlsonj if (zone->zone_flags & ZF_HASHED_LABEL) 535545916cd2Sjpk (void) mod_hash_destroy(zonehashbylabel, 535645916cd2Sjpk (mod_hash_key_t)zone->zone_slabel); 53577c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 53587c478bd9Sstevel@tonic-gate 5359108322fbScarlsonj /* 5360108322fbScarlsonj * Release the root vnode; we're not using it anymore. Nor should any 5361108322fbScarlsonj * other thread that might access it exist. 5362108322fbScarlsonj */ 5363108322fbScarlsonj if (zone->zone_rootvp != NULL) { 5364108322fbScarlsonj VN_RELE(zone->zone_rootvp); 5365108322fbScarlsonj zone->zone_rootvp = NULL; 5366108322fbScarlsonj } 5367108322fbScarlsonj 53687c478bd9Sstevel@tonic-gate /* add to deathrow list */ 53697c478bd9Sstevel@tonic-gate mutex_enter(&zone_deathrow_lock); 53707c478bd9Sstevel@tonic-gate list_insert_tail(&zone_deathrow, zone); 53717c478bd9Sstevel@tonic-gate mutex_exit(&zone_deathrow_lock); 53727c478bd9Sstevel@tonic-gate 53737c478bd9Sstevel@tonic-gate /* 53747c478bd9Sstevel@tonic-gate * Drop last reference (which was added by zsched()), this will 53757c478bd9Sstevel@tonic-gate * free the zone unless there are outstanding cred references. 53767c478bd9Sstevel@tonic-gate */ 53777c478bd9Sstevel@tonic-gate zone_rele(zone); 53787c478bd9Sstevel@tonic-gate return (0); 53797c478bd9Sstevel@tonic-gate } 53807c478bd9Sstevel@tonic-gate 53817c478bd9Sstevel@tonic-gate /* 53827c478bd9Sstevel@tonic-gate * Systemcall entry point for zone_getattr(2). 53837c478bd9Sstevel@tonic-gate */ 53847c478bd9Sstevel@tonic-gate static ssize_t 53857c478bd9Sstevel@tonic-gate zone_getattr(zoneid_t zoneid, int attr, void *buf, size_t bufsize) 53867c478bd9Sstevel@tonic-gate { 53877c478bd9Sstevel@tonic-gate size_t size; 53887c478bd9Sstevel@tonic-gate int error = 0, err; 53897c478bd9Sstevel@tonic-gate zone_t *zone; 53907c478bd9Sstevel@tonic-gate char *zonepath; 53913f2f09c1Sdp char *outstr; 53927c478bd9Sstevel@tonic-gate zone_status_t zone_status; 53937c478bd9Sstevel@tonic-gate pid_t initpid; 5394c97ad5cdSakolb boolean_t global = (curzone == global_zone); 5395c97ad5cdSakolb boolean_t inzone = (curzone->zone_id == zoneid); 5396f4b3ec61Sdh ushort_t flags; 5397550b6e40SSowmini Varadhan zone_net_data_t *zbuf; 53987c478bd9Sstevel@tonic-gate 53997c478bd9Sstevel@tonic-gate mutex_enter(&zonehash_lock); 54007c478bd9Sstevel@tonic-gate if ((zone = zone_find_all_by_id(zoneid)) == NULL) { 54017c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 54027c478bd9Sstevel@tonic-gate return (set_errno(EINVAL)); 54037c478bd9Sstevel@tonic-gate } 54047c478bd9Sstevel@tonic-gate zone_status = zone_status_get(zone); 5405bd41d0a8Snordmark if (zone_status < ZONE_IS_INITIALIZED) { 54067c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 54077c478bd9Sstevel@tonic-gate return (set_errno(EINVAL)); 54087c478bd9Sstevel@tonic-gate } 54097c478bd9Sstevel@tonic-gate zone_hold(zone); 54107c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 54117c478bd9Sstevel@tonic-gate 54127c478bd9Sstevel@tonic-gate /* 541345916cd2Sjpk * If not in the global zone, don't show information about other zones, 541445916cd2Sjpk * unless the system is labeled and the local zone's label dominates 541545916cd2Sjpk * the other zone. 54167c478bd9Sstevel@tonic-gate */ 541745916cd2Sjpk if (!zone_list_access(zone)) { 54187c478bd9Sstevel@tonic-gate zone_rele(zone); 54197c478bd9Sstevel@tonic-gate return (set_errno(EINVAL)); 54207c478bd9Sstevel@tonic-gate } 54217c478bd9Sstevel@tonic-gate 54227c478bd9Sstevel@tonic-gate switch (attr) { 54237c478bd9Sstevel@tonic-gate case ZONE_ATTR_ROOT: 54247c478bd9Sstevel@tonic-gate if (global) { 54257c478bd9Sstevel@tonic-gate /* 54267c478bd9Sstevel@tonic-gate * Copy the path to trim the trailing "/" (except for 54277c478bd9Sstevel@tonic-gate * the global zone). 54287c478bd9Sstevel@tonic-gate */ 54297c478bd9Sstevel@tonic-gate if (zone != global_zone) 54307c478bd9Sstevel@tonic-gate size = zone->zone_rootpathlen - 1; 54317c478bd9Sstevel@tonic-gate else 54327c478bd9Sstevel@tonic-gate size = zone->zone_rootpathlen; 54337c478bd9Sstevel@tonic-gate zonepath = kmem_alloc(size, KM_SLEEP); 54347c478bd9Sstevel@tonic-gate bcopy(zone->zone_rootpath, zonepath, size); 54357c478bd9Sstevel@tonic-gate zonepath[size - 1] = '\0'; 54367c478bd9Sstevel@tonic-gate } else { 5437c97ad5cdSakolb if (inzone || !is_system_labeled()) { 543845916cd2Sjpk /* 543945916cd2Sjpk * Caller is not in the global zone. 544045916cd2Sjpk * if the query is on the current zone 544145916cd2Sjpk * or the system is not labeled, 544245916cd2Sjpk * just return faked-up path for current zone. 544345916cd2Sjpk */ 544445916cd2Sjpk zonepath = "/"; 544545916cd2Sjpk size = 2; 544645916cd2Sjpk } else { 544745916cd2Sjpk /* 544845916cd2Sjpk * Return related path for current zone. 544945916cd2Sjpk */ 545045916cd2Sjpk int prefix_len = strlen(zone_prefix); 545145916cd2Sjpk int zname_len = strlen(zone->zone_name); 545245916cd2Sjpk 545345916cd2Sjpk size = prefix_len + zname_len + 1; 545445916cd2Sjpk zonepath = kmem_alloc(size, KM_SLEEP); 545545916cd2Sjpk bcopy(zone_prefix, zonepath, prefix_len); 545645916cd2Sjpk bcopy(zone->zone_name, zonepath + 54573f2f09c1Sdp prefix_len, zname_len); 545845916cd2Sjpk zonepath[size - 1] = '\0'; 545945916cd2Sjpk } 54607c478bd9Sstevel@tonic-gate } 54617c478bd9Sstevel@tonic-gate if (bufsize > size) 54627c478bd9Sstevel@tonic-gate bufsize = size; 54637c478bd9Sstevel@tonic-gate if (buf != NULL) { 54647c478bd9Sstevel@tonic-gate err = copyoutstr(zonepath, buf, bufsize, NULL); 54657c478bd9Sstevel@tonic-gate if (err != 0 && err != ENAMETOOLONG) 54667c478bd9Sstevel@tonic-gate error = EFAULT; 54677c478bd9Sstevel@tonic-gate } 5468c97ad5cdSakolb if (global || (is_system_labeled() && !inzone)) 54697c478bd9Sstevel@tonic-gate kmem_free(zonepath, size); 54707c478bd9Sstevel@tonic-gate break; 54717c478bd9Sstevel@tonic-gate 54727c478bd9Sstevel@tonic-gate case ZONE_ATTR_NAME: 54737c478bd9Sstevel@tonic-gate size = strlen(zone->zone_name) + 1; 54747c478bd9Sstevel@tonic-gate if (bufsize > size) 54757c478bd9Sstevel@tonic-gate bufsize = size; 54767c478bd9Sstevel@tonic-gate if (buf != NULL) { 54777c478bd9Sstevel@tonic-gate err = copyoutstr(zone->zone_name, buf, bufsize, NULL); 54787c478bd9Sstevel@tonic-gate if (err != 0 && err != ENAMETOOLONG) 54797c478bd9Sstevel@tonic-gate error = EFAULT; 54807c478bd9Sstevel@tonic-gate } 54817c478bd9Sstevel@tonic-gate break; 54827c478bd9Sstevel@tonic-gate 54837c478bd9Sstevel@tonic-gate case ZONE_ATTR_STATUS: 54847c478bd9Sstevel@tonic-gate /* 54857c478bd9Sstevel@tonic-gate * Since we're not holding zonehash_lock, the zone status 54867c478bd9Sstevel@tonic-gate * may be anything; leave it up to userland to sort it out. 54877c478bd9Sstevel@tonic-gate */ 54887c478bd9Sstevel@tonic-gate size = sizeof (zone_status); 54897c478bd9Sstevel@tonic-gate if (bufsize > size) 54907c478bd9Sstevel@tonic-gate bufsize = size; 54917c478bd9Sstevel@tonic-gate zone_status = zone_status_get(zone); 54927c478bd9Sstevel@tonic-gate if (buf != NULL && 54937c478bd9Sstevel@tonic-gate copyout(&zone_status, buf, bufsize) != 0) 54947c478bd9Sstevel@tonic-gate error = EFAULT; 54957c478bd9Sstevel@tonic-gate break; 5496f4b3ec61Sdh case ZONE_ATTR_FLAGS: 5497f4b3ec61Sdh size = sizeof (zone->zone_flags); 5498f4b3ec61Sdh if (bufsize > size) 5499f4b3ec61Sdh bufsize = size; 5500f4b3ec61Sdh flags = zone->zone_flags; 5501f4b3ec61Sdh if (buf != NULL && 5502f4b3ec61Sdh copyout(&flags, buf, bufsize) != 0) 5503f4b3ec61Sdh error = EFAULT; 5504f4b3ec61Sdh break; 55057c478bd9Sstevel@tonic-gate case ZONE_ATTR_PRIVSET: 55067c478bd9Sstevel@tonic-gate size = sizeof (priv_set_t); 55077c478bd9Sstevel@tonic-gate if (bufsize > size) 55087c478bd9Sstevel@tonic-gate bufsize = size; 55097c478bd9Sstevel@tonic-gate if (buf != NULL && 55107c478bd9Sstevel@tonic-gate copyout(zone->zone_privset, buf, bufsize) != 0) 55117c478bd9Sstevel@tonic-gate error = EFAULT; 55127c478bd9Sstevel@tonic-gate break; 55137c478bd9Sstevel@tonic-gate case ZONE_ATTR_UNIQID: 55147c478bd9Sstevel@tonic-gate size = sizeof (zone->zone_uniqid); 55157c478bd9Sstevel@tonic-gate if (bufsize > size) 55167c478bd9Sstevel@tonic-gate bufsize = size; 55177c478bd9Sstevel@tonic-gate if (buf != NULL && 55187c478bd9Sstevel@tonic-gate copyout(&zone->zone_uniqid, buf, bufsize) != 0) 55197c478bd9Sstevel@tonic-gate error = EFAULT; 55207c478bd9Sstevel@tonic-gate break; 55217c478bd9Sstevel@tonic-gate case ZONE_ATTR_POOLID: 55227c478bd9Sstevel@tonic-gate { 55237c478bd9Sstevel@tonic-gate pool_t *pool; 55247c478bd9Sstevel@tonic-gate poolid_t poolid; 55257c478bd9Sstevel@tonic-gate 55267c478bd9Sstevel@tonic-gate if (pool_lock_intr() != 0) { 55277c478bd9Sstevel@tonic-gate error = EINTR; 55287c478bd9Sstevel@tonic-gate break; 55297c478bd9Sstevel@tonic-gate } 55307c478bd9Sstevel@tonic-gate pool = zone_pool_get(zone); 55317c478bd9Sstevel@tonic-gate poolid = pool->pool_id; 55327c478bd9Sstevel@tonic-gate pool_unlock(); 55337c478bd9Sstevel@tonic-gate size = sizeof (poolid); 55347c478bd9Sstevel@tonic-gate if (bufsize > size) 55357c478bd9Sstevel@tonic-gate bufsize = size; 55367c478bd9Sstevel@tonic-gate if (buf != NULL && copyout(&poolid, buf, size) != 0) 55377c478bd9Sstevel@tonic-gate error = EFAULT; 55387c478bd9Sstevel@tonic-gate } 55397c478bd9Sstevel@tonic-gate break; 554045916cd2Sjpk case ZONE_ATTR_SLBL: 554145916cd2Sjpk size = sizeof (bslabel_t); 554245916cd2Sjpk if (bufsize > size) 554345916cd2Sjpk bufsize = size; 554445916cd2Sjpk if (zone->zone_slabel == NULL) 554545916cd2Sjpk error = EINVAL; 554645916cd2Sjpk else if (buf != NULL && 554745916cd2Sjpk copyout(label2bslabel(zone->zone_slabel), buf, 554845916cd2Sjpk bufsize) != 0) 554945916cd2Sjpk error = EFAULT; 555045916cd2Sjpk break; 55517c478bd9Sstevel@tonic-gate case ZONE_ATTR_INITPID: 55527c478bd9Sstevel@tonic-gate size = sizeof (initpid); 55537c478bd9Sstevel@tonic-gate if (bufsize > size) 55547c478bd9Sstevel@tonic-gate bufsize = size; 55557c478bd9Sstevel@tonic-gate initpid = zone->zone_proc_initpid; 55567c478bd9Sstevel@tonic-gate if (initpid == -1) { 55577c478bd9Sstevel@tonic-gate error = ESRCH; 55587c478bd9Sstevel@tonic-gate break; 55597c478bd9Sstevel@tonic-gate } 55607c478bd9Sstevel@tonic-gate if (buf != NULL && 55617c478bd9Sstevel@tonic-gate copyout(&initpid, buf, bufsize) != 0) 55627c478bd9Sstevel@tonic-gate error = EFAULT; 55637c478bd9Sstevel@tonic-gate break; 55649acbbeafSnn case ZONE_ATTR_BRAND: 55659acbbeafSnn size = strlen(zone->zone_brand->b_name) + 1; 55669acbbeafSnn 55679acbbeafSnn if (bufsize > size) 55689acbbeafSnn bufsize = size; 55699acbbeafSnn if (buf != NULL) { 55709acbbeafSnn err = copyoutstr(zone->zone_brand->b_name, buf, 55719acbbeafSnn bufsize, NULL); 55729acbbeafSnn if (err != 0 && err != ENAMETOOLONG) 55739acbbeafSnn error = EFAULT; 55749acbbeafSnn } 55759acbbeafSnn break; 55763f2f09c1Sdp case ZONE_ATTR_INITNAME: 55773f2f09c1Sdp size = strlen(zone->zone_initname) + 1; 55783f2f09c1Sdp if (bufsize > size) 55793f2f09c1Sdp bufsize = size; 55803f2f09c1Sdp if (buf != NULL) { 55813f2f09c1Sdp err = copyoutstr(zone->zone_initname, buf, bufsize, 55823f2f09c1Sdp NULL); 55833f2f09c1Sdp if (err != 0 && err != ENAMETOOLONG) 55843f2f09c1Sdp error = EFAULT; 55853f2f09c1Sdp } 55863f2f09c1Sdp break; 55873f2f09c1Sdp case ZONE_ATTR_BOOTARGS: 55883f2f09c1Sdp if (zone->zone_bootargs == NULL) 55893f2f09c1Sdp outstr = ""; 55903f2f09c1Sdp else 55913f2f09c1Sdp outstr = zone->zone_bootargs; 55923f2f09c1Sdp size = strlen(outstr) + 1; 55933f2f09c1Sdp if (bufsize > size) 55943f2f09c1Sdp bufsize = size; 55953f2f09c1Sdp if (buf != NULL) { 55963f2f09c1Sdp err = copyoutstr(outstr, buf, bufsize, NULL); 55973f2f09c1Sdp if (err != 0 && err != ENAMETOOLONG) 55983f2f09c1Sdp error = EFAULT; 55993f2f09c1Sdp } 56003f2f09c1Sdp break; 56010209230bSgjelinek case ZONE_ATTR_PHYS_MCAP: 56020209230bSgjelinek size = sizeof (zone->zone_phys_mcap); 56030209230bSgjelinek if (bufsize > size) 56040209230bSgjelinek bufsize = size; 56050209230bSgjelinek if (buf != NULL && 56060209230bSgjelinek copyout(&zone->zone_phys_mcap, buf, bufsize) != 0) 56070209230bSgjelinek error = EFAULT; 56080209230bSgjelinek break; 56090209230bSgjelinek case ZONE_ATTR_SCHED_CLASS: 56100209230bSgjelinek mutex_enter(&class_lock); 56110209230bSgjelinek 56120209230bSgjelinek if (zone->zone_defaultcid >= loaded_classes) 56130209230bSgjelinek outstr = ""; 56140209230bSgjelinek else 56150209230bSgjelinek outstr = sclass[zone->zone_defaultcid].cl_name; 56160209230bSgjelinek size = strlen(outstr) + 1; 56170209230bSgjelinek if (bufsize > size) 56180209230bSgjelinek bufsize = size; 56190209230bSgjelinek if (buf != NULL) { 56200209230bSgjelinek err = copyoutstr(outstr, buf, bufsize, NULL); 56210209230bSgjelinek if (err != 0 && err != ENAMETOOLONG) 56220209230bSgjelinek error = EFAULT; 56230209230bSgjelinek } 56240209230bSgjelinek 56250209230bSgjelinek mutex_exit(&class_lock); 56260209230bSgjelinek break; 56275679c89fSjv case ZONE_ATTR_HOSTID: 56285679c89fSjv if (zone->zone_hostid != HW_INVALID_HOSTID && 56295679c89fSjv bufsize == sizeof (zone->zone_hostid)) { 56305679c89fSjv size = sizeof (zone->zone_hostid); 56315679c89fSjv if (buf != NULL && copyout(&zone->zone_hostid, buf, 56325679c89fSjv bufsize) != 0) 56335679c89fSjv error = EFAULT; 56345679c89fSjv } else { 56355679c89fSjv error = EINVAL; 56365679c89fSjv } 56375679c89fSjv break; 56380fbb751dSJohn Levon case ZONE_ATTR_FS_ALLOWED: 56390fbb751dSJohn Levon if (zone->zone_fs_allowed == NULL) 56400fbb751dSJohn Levon outstr = ""; 56410fbb751dSJohn Levon else 56420fbb751dSJohn Levon outstr = zone->zone_fs_allowed; 56430fbb751dSJohn Levon size = strlen(outstr) + 1; 56440fbb751dSJohn Levon if (bufsize > size) 56450fbb751dSJohn Levon bufsize = size; 56460fbb751dSJohn Levon if (buf != NULL) { 56470fbb751dSJohn Levon err = copyoutstr(outstr, buf, bufsize, NULL); 56480fbb751dSJohn Levon if (err != 0 && err != ENAMETOOLONG) 56490fbb751dSJohn Levon error = EFAULT; 56500fbb751dSJohn Levon } 56510fbb751dSJohn Levon break; 5652d2a70789SRichard Lowe case ZONE_ATTR_SECFLAGS: 5653d2a70789SRichard Lowe size = sizeof (zone->zone_secflags); 5654d2a70789SRichard Lowe if (bufsize > size) 5655d2a70789SRichard Lowe bufsize = size; 5656d2a70789SRichard Lowe if ((err = copyout(&zone->zone_secflags, buf, bufsize)) != 0) 5657d2a70789SRichard Lowe error = EFAULT; 5658d2a70789SRichard Lowe break; 5659550b6e40SSowmini Varadhan case ZONE_ATTR_NETWORK: 5660*66d7818bSAndy Fiddaman bufsize = MIN(bufsize, PIPE_BUF + sizeof (zone_net_data_t)); 5661*66d7818bSAndy Fiddaman size = bufsize; 5662550b6e40SSowmini Varadhan zbuf = kmem_alloc(bufsize, KM_SLEEP); 5663550b6e40SSowmini Varadhan if (copyin(buf, zbuf, bufsize) != 0) { 5664550b6e40SSowmini Varadhan error = EFAULT; 5665550b6e40SSowmini Varadhan } else { 5666550b6e40SSowmini Varadhan error = zone_get_network(zoneid, zbuf); 5667550b6e40SSowmini Varadhan if (error == 0 && copyout(zbuf, buf, bufsize) != 0) 5668550b6e40SSowmini Varadhan error = EFAULT; 5669550b6e40SSowmini Varadhan } 5670550b6e40SSowmini Varadhan kmem_free(zbuf, bufsize); 5671550b6e40SSowmini Varadhan break; 56727c478bd9Sstevel@tonic-gate default: 56739acbbeafSnn if ((attr >= ZONE_ATTR_BRAND_ATTRS) && ZONE_IS_BRANDED(zone)) { 56749acbbeafSnn size = bufsize; 56759acbbeafSnn error = ZBROP(zone)->b_getattr(zone, attr, buf, &size); 56769acbbeafSnn } else { 56779acbbeafSnn error = EINVAL; 56789acbbeafSnn } 56797c478bd9Sstevel@tonic-gate } 56807c478bd9Sstevel@tonic-gate zone_rele(zone); 56817c478bd9Sstevel@tonic-gate 56827c478bd9Sstevel@tonic-gate if (error) 56837c478bd9Sstevel@tonic-gate return (set_errno(error)); 56847c478bd9Sstevel@tonic-gate return ((ssize_t)size); 56857c478bd9Sstevel@tonic-gate } 56867c478bd9Sstevel@tonic-gate 56873f2f09c1Sdp /* 56883f2f09c1Sdp * Systemcall entry point for zone_setattr(2). 56893f2f09c1Sdp */ 56903f2f09c1Sdp /*ARGSUSED*/ 56913f2f09c1Sdp static int 56923f2f09c1Sdp zone_setattr(zoneid_t zoneid, int attr, void *buf, size_t bufsize) 56933f2f09c1Sdp { 56943f2f09c1Sdp zone_t *zone; 56953f2f09c1Sdp zone_status_t zone_status; 56961a88ce5cSDan Price int err = -1; 5697550b6e40SSowmini Varadhan zone_net_data_t *zbuf; 56983f2f09c1Sdp 56993f2f09c1Sdp if (secpolicy_zone_config(CRED()) != 0) 57003f2f09c1Sdp return (set_errno(EPERM)); 57013f2f09c1Sdp 57023f2f09c1Sdp /* 57030209230bSgjelinek * Only the ZONE_ATTR_PHYS_MCAP attribute can be set on the 57040209230bSgjelinek * global zone. 57053f2f09c1Sdp */ 57060209230bSgjelinek if (zoneid == GLOBAL_ZONEID && attr != ZONE_ATTR_PHYS_MCAP) { 57073f2f09c1Sdp return (set_errno(EINVAL)); 57083f2f09c1Sdp } 57093f2f09c1Sdp 57103f2f09c1Sdp mutex_enter(&zonehash_lock); 57113f2f09c1Sdp if ((zone = zone_find_all_by_id(zoneid)) == NULL) { 57123f2f09c1Sdp mutex_exit(&zonehash_lock); 57133f2f09c1Sdp return (set_errno(EINVAL)); 57143f2f09c1Sdp } 57153f2f09c1Sdp zone_hold(zone); 57163f2f09c1Sdp mutex_exit(&zonehash_lock); 57173f2f09c1Sdp 57180209230bSgjelinek /* 57190209230bSgjelinek * At present most attributes can only be set on non-running, 57200209230bSgjelinek * non-global zones. 57210209230bSgjelinek */ 57223f2f09c1Sdp zone_status = zone_status_get(zone); 57231a88ce5cSDan Price if (attr != ZONE_ATTR_PHYS_MCAP && zone_status > ZONE_IS_READY) { 57241a88ce5cSDan Price err = EINVAL; 57253f2f09c1Sdp goto done; 57261a88ce5cSDan Price } 57273f2f09c1Sdp 57283f2f09c1Sdp switch (attr) { 57293f2f09c1Sdp case ZONE_ATTR_INITNAME: 57303f2f09c1Sdp err = zone_set_initname(zone, (const char *)buf); 57313f2f09c1Sdp break; 5732bafd1f14SJerry Jelinek case ZONE_ATTR_INITNORESTART: 5733bafd1f14SJerry Jelinek zone->zone_restart_init = B_FALSE; 5734bafd1f14SJerry Jelinek err = 0; 5735bafd1f14SJerry Jelinek break; 57363f2f09c1Sdp case ZONE_ATTR_BOOTARGS: 57373f2f09c1Sdp err = zone_set_bootargs(zone, (const char *)buf); 57383f2f09c1Sdp break; 57399acbbeafSnn case ZONE_ATTR_BRAND: 574059f2ff5cSedp err = zone_set_brand(zone, (const char *)buf); 57419acbbeafSnn break; 57420fbb751dSJohn Levon case ZONE_ATTR_FS_ALLOWED: 57430fbb751dSJohn Levon err = zone_set_fs_allowed(zone, (const char *)buf); 57440fbb751dSJohn Levon break; 5745d2a70789SRichard Lowe case ZONE_ATTR_SECFLAGS: 5746d2a70789SRichard Lowe err = zone_set_secflags(zone, (psecflags_t *)buf); 5747d2a70789SRichard Lowe break; 57480209230bSgjelinek case ZONE_ATTR_PHYS_MCAP: 57490209230bSgjelinek err = zone_set_phys_mcap(zone, (const uint64_t *)buf); 57500209230bSgjelinek break; 57510209230bSgjelinek case ZONE_ATTR_SCHED_CLASS: 57520209230bSgjelinek err = zone_set_sched_class(zone, (const char *)buf); 57530209230bSgjelinek break; 57545679c89fSjv case ZONE_ATTR_HOSTID: 57555679c89fSjv if (bufsize == sizeof (zone->zone_hostid)) { 57565679c89fSjv if (copyin(buf, &zone->zone_hostid, bufsize) == 0) 57575679c89fSjv err = 0; 57585679c89fSjv else 57595679c89fSjv err = EFAULT; 57605679c89fSjv } else { 57615679c89fSjv err = EINVAL; 57625679c89fSjv } 57635679c89fSjv break; 5764550b6e40SSowmini Varadhan case ZONE_ATTR_NETWORK: 5765550b6e40SSowmini Varadhan if (bufsize > (PIPE_BUF + sizeof (zone_net_data_t))) { 5766550b6e40SSowmini Varadhan err = EINVAL; 57671a88ce5cSDan Price break; 5768550b6e40SSowmini Varadhan } 5769550b6e40SSowmini Varadhan zbuf = kmem_alloc(bufsize, KM_SLEEP); 5770550b6e40SSowmini Varadhan if (copyin(buf, zbuf, bufsize) != 0) { 57711a88ce5cSDan Price kmem_free(zbuf, bufsize); 5772550b6e40SSowmini Varadhan err = EFAULT; 57731a88ce5cSDan Price break; 5774550b6e40SSowmini Varadhan } 5775550b6e40SSowmini Varadhan err = zone_set_network(zoneid, zbuf); 5776550b6e40SSowmini Varadhan kmem_free(zbuf, bufsize); 5777550b6e40SSowmini Varadhan break; 57783f2f09c1Sdp default: 57799acbbeafSnn if ((attr >= ZONE_ATTR_BRAND_ATTRS) && ZONE_IS_BRANDED(zone)) 57809acbbeafSnn err = ZBROP(zone)->b_setattr(zone, attr, buf, bufsize); 57819acbbeafSnn else 57829acbbeafSnn err = EINVAL; 57833f2f09c1Sdp } 57843f2f09c1Sdp 57853f2f09c1Sdp done: 57863f2f09c1Sdp zone_rele(zone); 57871a88ce5cSDan Price ASSERT(err != -1); 57883f2f09c1Sdp return (err != 0 ? set_errno(err) : 0); 57893f2f09c1Sdp } 57903f2f09c1Sdp 57917c478bd9Sstevel@tonic-gate /* 57927c478bd9Sstevel@tonic-gate * Return zero if the process has at least one vnode mapped in to its 57937c478bd9Sstevel@tonic-gate * address space which shouldn't be allowed to change zones. 57940209230bSgjelinek * 57950209230bSgjelinek * Also return zero if the process has any shared mappings which reserve 57960209230bSgjelinek * swap. This is because the counting for zone.max-swap does not allow swap 5797da6c28aaSamw * reservation to be shared between zones. zone swap reservation is counted 57980209230bSgjelinek * on zone->zone_max_swap. 57997c478bd9Sstevel@tonic-gate */ 58007c478bd9Sstevel@tonic-gate static int 58017c478bd9Sstevel@tonic-gate as_can_change_zones(void) 58027c478bd9Sstevel@tonic-gate { 58037c478bd9Sstevel@tonic-gate proc_t *pp = curproc; 58047c478bd9Sstevel@tonic-gate struct seg *seg; 58057c478bd9Sstevel@tonic-gate struct as *as = pp->p_as; 58067c478bd9Sstevel@tonic-gate vnode_t *vp; 58077c478bd9Sstevel@tonic-gate int allow = 1; 58087c478bd9Sstevel@tonic-gate 58097c478bd9Sstevel@tonic-gate ASSERT(pp->p_as != &kas); 5810dc32d872SJosef 'Jeff' Sipek AS_LOCK_ENTER(as, RW_READER); 58117c478bd9Sstevel@tonic-gate for (seg = AS_SEGFIRST(as); seg != NULL; seg = AS_SEGNEXT(as, seg)) { 58120209230bSgjelinek 58130209230bSgjelinek /* 58140209230bSgjelinek * Cannot enter zone with shared anon memory which 58150209230bSgjelinek * reserves swap. See comment above. 58160209230bSgjelinek */ 58170209230bSgjelinek if (seg_can_change_zones(seg) == B_FALSE) { 58180209230bSgjelinek allow = 0; 58190209230bSgjelinek break; 58200209230bSgjelinek } 58217c478bd9Sstevel@tonic-gate /* 58227c478bd9Sstevel@tonic-gate * if we can't get a backing vnode for this segment then skip 58237c478bd9Sstevel@tonic-gate * it. 58247c478bd9Sstevel@tonic-gate */ 58257c478bd9Sstevel@tonic-gate vp = NULL; 58267c478bd9Sstevel@tonic-gate if (SEGOP_GETVP(seg, seg->s_base, &vp) != 0 || vp == NULL) 58277c478bd9Sstevel@tonic-gate continue; 58287c478bd9Sstevel@tonic-gate if (!vn_can_change_zones(vp)) { /* bail on first match */ 58297c478bd9Sstevel@tonic-gate allow = 0; 58307c478bd9Sstevel@tonic-gate break; 58317c478bd9Sstevel@tonic-gate } 58327c478bd9Sstevel@tonic-gate } 5833dc32d872SJosef 'Jeff' Sipek AS_LOCK_EXIT(as); 58347c478bd9Sstevel@tonic-gate return (allow); 58357c478bd9Sstevel@tonic-gate } 58367c478bd9Sstevel@tonic-gate 58370209230bSgjelinek /* 58380209230bSgjelinek * Count swap reserved by curproc's address space 58390209230bSgjelinek */ 58400209230bSgjelinek static size_t 58410209230bSgjelinek as_swresv(void) 58420209230bSgjelinek { 58430209230bSgjelinek proc_t *pp = curproc; 58440209230bSgjelinek struct seg *seg; 58450209230bSgjelinek struct as *as = pp->p_as; 58460209230bSgjelinek size_t swap = 0; 58470209230bSgjelinek 58480209230bSgjelinek ASSERT(pp->p_as != &kas); 5849dc32d872SJosef 'Jeff' Sipek ASSERT(AS_WRITE_HELD(as)); 58500209230bSgjelinek for (seg = AS_SEGFIRST(as); seg != NULL; seg = AS_SEGNEXT(as, seg)) 58510209230bSgjelinek swap += seg_swresv(seg); 58520209230bSgjelinek 58530209230bSgjelinek return (swap); 58540209230bSgjelinek } 58550209230bSgjelinek 58567c478bd9Sstevel@tonic-gate /* 58577c478bd9Sstevel@tonic-gate * Systemcall entry point for zone_enter(). 58587c478bd9Sstevel@tonic-gate * 58597c478bd9Sstevel@tonic-gate * The current process is injected into said zone. In the process 58607c478bd9Sstevel@tonic-gate * it will change its project membership, privileges, rootdir/cwd, 58617c478bd9Sstevel@tonic-gate * zone-wide rctls, and pool association to match those of the zone. 58627c478bd9Sstevel@tonic-gate * 58637c478bd9Sstevel@tonic-gate * The first zone_enter() called while the zone is in the ZONE_IS_READY 58647c478bd9Sstevel@tonic-gate * state will transition it to ZONE_IS_RUNNING. Processes may only 58657c478bd9Sstevel@tonic-gate * enter a zone that is "ready" or "running". 58667c478bd9Sstevel@tonic-gate */ 58677c478bd9Sstevel@tonic-gate static int 58687c478bd9Sstevel@tonic-gate zone_enter(zoneid_t zoneid) 58697c478bd9Sstevel@tonic-gate { 58707c478bd9Sstevel@tonic-gate zone_t *zone; 58717c478bd9Sstevel@tonic-gate vnode_t *vp; 58727c478bd9Sstevel@tonic-gate proc_t *pp = curproc; 58737c478bd9Sstevel@tonic-gate contract_t *ct; 58747c478bd9Sstevel@tonic-gate cont_process_t *ctp; 58757c478bd9Sstevel@tonic-gate task_t *tk, *oldtk; 58767c478bd9Sstevel@tonic-gate kproject_t *zone_proj0; 58777c478bd9Sstevel@tonic-gate cred_t *cr, *newcr; 58787c478bd9Sstevel@tonic-gate pool_t *oldpool, *newpool; 58797c478bd9Sstevel@tonic-gate sess_t *sp; 58807c478bd9Sstevel@tonic-gate uid_t uid; 58817c478bd9Sstevel@tonic-gate zone_status_t status; 58827c478bd9Sstevel@tonic-gate int err = 0; 58837c478bd9Sstevel@tonic-gate rctl_entity_p_t e; 58840209230bSgjelinek size_t swap; 5885c97ad5cdSakolb kthread_id_t t; 58867c478bd9Sstevel@tonic-gate 58877c478bd9Sstevel@tonic-gate if (secpolicy_zone_config(CRED()) != 0) 58887c478bd9Sstevel@tonic-gate return (set_errno(EPERM)); 58897c478bd9Sstevel@tonic-gate if (zoneid < MIN_USERZONEID || zoneid > MAX_ZONEID) 58907c478bd9Sstevel@tonic-gate return (set_errno(EINVAL)); 58917c478bd9Sstevel@tonic-gate 58927c478bd9Sstevel@tonic-gate /* 58937c478bd9Sstevel@tonic-gate * Stop all lwps so we don't need to hold a lock to look at 58947c478bd9Sstevel@tonic-gate * curproc->p_zone. This needs to happen before we grab any 58957c478bd9Sstevel@tonic-gate * locks to avoid deadlock (another lwp in the process could 58967c478bd9Sstevel@tonic-gate * be waiting for the held lock). 58977c478bd9Sstevel@tonic-gate */ 58987c478bd9Sstevel@tonic-gate if (curthread != pp->p_agenttp && !holdlwps(SHOLDFORK)) 58997c478bd9Sstevel@tonic-gate return (set_errno(EINTR)); 59007c478bd9Sstevel@tonic-gate 59017c478bd9Sstevel@tonic-gate /* 59027c478bd9Sstevel@tonic-gate * Make sure we're not changing zones with files open or mapped in 59037c478bd9Sstevel@tonic-gate * to our address space which shouldn't be changing zones. 59047c478bd9Sstevel@tonic-gate */ 59057c478bd9Sstevel@tonic-gate if (!files_can_change_zones()) { 59067c478bd9Sstevel@tonic-gate err = EBADF; 59077c478bd9Sstevel@tonic-gate goto out; 59087c478bd9Sstevel@tonic-gate } 59097c478bd9Sstevel@tonic-gate if (!as_can_change_zones()) { 59107c478bd9Sstevel@tonic-gate err = EFAULT; 59117c478bd9Sstevel@tonic-gate goto out; 59127c478bd9Sstevel@tonic-gate } 59137c478bd9Sstevel@tonic-gate 59147c478bd9Sstevel@tonic-gate mutex_enter(&zonehash_lock); 59157c478bd9Sstevel@tonic-gate if (pp->p_zone != global_zone) { 59167c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 59177c478bd9Sstevel@tonic-gate err = EINVAL; 59187c478bd9Sstevel@tonic-gate goto out; 59197c478bd9Sstevel@tonic-gate } 59207c478bd9Sstevel@tonic-gate 59217c478bd9Sstevel@tonic-gate zone = zone_find_all_by_id(zoneid); 59227c478bd9Sstevel@tonic-gate if (zone == NULL) { 59237c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 59247c478bd9Sstevel@tonic-gate err = EINVAL; 59257c478bd9Sstevel@tonic-gate goto out; 59267c478bd9Sstevel@tonic-gate } 59277c478bd9Sstevel@tonic-gate 59287c478bd9Sstevel@tonic-gate /* 59297c478bd9Sstevel@tonic-gate * To prevent processes in a zone from holding contracts on 59307c478bd9Sstevel@tonic-gate * extrazonal resources, and to avoid process contract 59317c478bd9Sstevel@tonic-gate * memberships which span zones, contract holders and processes 59327c478bd9Sstevel@tonic-gate * which aren't the sole members of their encapsulating process 59337c478bd9Sstevel@tonic-gate * contracts are not allowed to zone_enter. 59347c478bd9Sstevel@tonic-gate */ 59357c478bd9Sstevel@tonic-gate ctp = pp->p_ct_process; 59367c478bd9Sstevel@tonic-gate ct = &ctp->conp_contract; 59377c478bd9Sstevel@tonic-gate mutex_enter(&ct->ct_lock); 59387c478bd9Sstevel@tonic-gate mutex_enter(&pp->p_lock); 59397c478bd9Sstevel@tonic-gate if ((avl_numnodes(&pp->p_ct_held) != 0) || (ctp->conp_nmembers != 1)) { 59407c478bd9Sstevel@tonic-gate mutex_exit(&pp->p_lock); 59417c478bd9Sstevel@tonic-gate mutex_exit(&ct->ct_lock); 59427c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 59437c478bd9Sstevel@tonic-gate err = EINVAL; 59447c478bd9Sstevel@tonic-gate goto out; 59457c478bd9Sstevel@tonic-gate } 59467c478bd9Sstevel@tonic-gate 59477c478bd9Sstevel@tonic-gate /* 59487c478bd9Sstevel@tonic-gate * Moreover, we don't allow processes whose encapsulating 59497c478bd9Sstevel@tonic-gate * process contracts have inherited extrazonal contracts. 59507c478bd9Sstevel@tonic-gate * While it would be easier to eliminate all process contracts 59517c478bd9Sstevel@tonic-gate * with inherited contracts, we need to be able to give a 59527c478bd9Sstevel@tonic-gate * restarted init (or other zone-penetrating process) its 59537c478bd9Sstevel@tonic-gate * predecessor's contracts. 59547c478bd9Sstevel@tonic-gate */ 59557c478bd9Sstevel@tonic-gate if (ctp->conp_ninherited != 0) { 59567c478bd9Sstevel@tonic-gate contract_t *next; 59577c478bd9Sstevel@tonic-gate for (next = list_head(&ctp->conp_inherited); next; 59587c478bd9Sstevel@tonic-gate next = list_next(&ctp->conp_inherited, next)) { 59597c478bd9Sstevel@tonic-gate if (contract_getzuniqid(next) != zone->zone_uniqid) { 59607c478bd9Sstevel@tonic-gate mutex_exit(&pp->p_lock); 59617c478bd9Sstevel@tonic-gate mutex_exit(&ct->ct_lock); 59627c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 59637c478bd9Sstevel@tonic-gate err = EINVAL; 59647c478bd9Sstevel@tonic-gate goto out; 59657c478bd9Sstevel@tonic-gate } 59667c478bd9Sstevel@tonic-gate } 59677c478bd9Sstevel@tonic-gate } 59687b209c2cSacruz 59697c478bd9Sstevel@tonic-gate mutex_exit(&pp->p_lock); 59707c478bd9Sstevel@tonic-gate mutex_exit(&ct->ct_lock); 59717c478bd9Sstevel@tonic-gate 59727c478bd9Sstevel@tonic-gate status = zone_status_get(zone); 59737c478bd9Sstevel@tonic-gate if (status < ZONE_IS_READY || status >= ZONE_IS_SHUTTING_DOWN) { 59747c478bd9Sstevel@tonic-gate /* 59757c478bd9Sstevel@tonic-gate * Can't join 59767c478bd9Sstevel@tonic-gate */ 59777c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 59787c478bd9Sstevel@tonic-gate err = EINVAL; 59797c478bd9Sstevel@tonic-gate goto out; 59807c478bd9Sstevel@tonic-gate } 59817c478bd9Sstevel@tonic-gate 59827c478bd9Sstevel@tonic-gate /* 59837c478bd9Sstevel@tonic-gate * Make sure new priv set is within the permitted set for caller 59847c478bd9Sstevel@tonic-gate */ 59857c478bd9Sstevel@tonic-gate if (!priv_issubset(zone->zone_privset, &CR_OPPRIV(CRED()))) { 59867c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 59877c478bd9Sstevel@tonic-gate err = EPERM; 59887c478bd9Sstevel@tonic-gate goto out; 59897c478bd9Sstevel@tonic-gate } 59907c478bd9Sstevel@tonic-gate /* 59917c478bd9Sstevel@tonic-gate * We want to momentarily drop zonehash_lock while we optimistically 59927c478bd9Sstevel@tonic-gate * bind curproc to the pool it should be running in. This is safe 59937c478bd9Sstevel@tonic-gate * since the zone can't disappear (we have a hold on it). 59947c478bd9Sstevel@tonic-gate */ 59957c478bd9Sstevel@tonic-gate zone_hold(zone); 59967c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 59977c478bd9Sstevel@tonic-gate 59987c478bd9Sstevel@tonic-gate /* 59997c478bd9Sstevel@tonic-gate * Grab pool_lock to keep the pools configuration from changing 60007c478bd9Sstevel@tonic-gate * and to stop ourselves from getting rebound to another pool 60017c478bd9Sstevel@tonic-gate * until we join the zone. 60027c478bd9Sstevel@tonic-gate */ 60037c478bd9Sstevel@tonic-gate if (pool_lock_intr() != 0) { 60047c478bd9Sstevel@tonic-gate zone_rele(zone); 60057c478bd9Sstevel@tonic-gate err = EINTR; 60067c478bd9Sstevel@tonic-gate goto out; 60077c478bd9Sstevel@tonic-gate } 60087c478bd9Sstevel@tonic-gate ASSERT(secpolicy_pool(CRED()) == 0); 60097c478bd9Sstevel@tonic-gate /* 60107c478bd9Sstevel@tonic-gate * Bind ourselves to the pool currently associated with the zone. 60117c478bd9Sstevel@tonic-gate */ 60127c478bd9Sstevel@tonic-gate oldpool = curproc->p_pool; 60137c478bd9Sstevel@tonic-gate newpool = zone_pool_get(zone); 60147c478bd9Sstevel@tonic-gate if (pool_state == POOL_ENABLED && newpool != oldpool && 60157c478bd9Sstevel@tonic-gate (err = pool_do_bind(newpool, P_PID, P_MYID, 60167c478bd9Sstevel@tonic-gate POOL_BIND_ALL)) != 0) { 60177c478bd9Sstevel@tonic-gate pool_unlock(); 60187c478bd9Sstevel@tonic-gate zone_rele(zone); 60197c478bd9Sstevel@tonic-gate goto out; 60207c478bd9Sstevel@tonic-gate } 60217c478bd9Sstevel@tonic-gate 60227c478bd9Sstevel@tonic-gate /* 60237c478bd9Sstevel@tonic-gate * Grab cpu_lock now; we'll need it later when we call 60247c478bd9Sstevel@tonic-gate * task_join(). 60257c478bd9Sstevel@tonic-gate */ 60267c478bd9Sstevel@tonic-gate mutex_enter(&cpu_lock); 60277c478bd9Sstevel@tonic-gate mutex_enter(&zonehash_lock); 60287c478bd9Sstevel@tonic-gate /* 60297c478bd9Sstevel@tonic-gate * Make sure the zone hasn't moved on since we dropped zonehash_lock. 60307c478bd9Sstevel@tonic-gate */ 60317c478bd9Sstevel@tonic-gate if (zone_status_get(zone) >= ZONE_IS_SHUTTING_DOWN) { 60327c478bd9Sstevel@tonic-gate /* 60337c478bd9Sstevel@tonic-gate * Can't join anymore. 60347c478bd9Sstevel@tonic-gate */ 60357c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 60367c478bd9Sstevel@tonic-gate mutex_exit(&cpu_lock); 60377c478bd9Sstevel@tonic-gate if (pool_state == POOL_ENABLED && 60387c478bd9Sstevel@tonic-gate newpool != oldpool) 60397c478bd9Sstevel@tonic-gate (void) pool_do_bind(oldpool, P_PID, P_MYID, 60407c478bd9Sstevel@tonic-gate POOL_BIND_ALL); 60417c478bd9Sstevel@tonic-gate pool_unlock(); 60427c478bd9Sstevel@tonic-gate zone_rele(zone); 60437c478bd9Sstevel@tonic-gate err = EINVAL; 60447c478bd9Sstevel@tonic-gate goto out; 60457c478bd9Sstevel@tonic-gate } 60467c478bd9Sstevel@tonic-gate 60470209230bSgjelinek /* 60480209230bSgjelinek * a_lock must be held while transfering locked memory and swap 60490209230bSgjelinek * reservation from the global zone to the non global zone because 60500209230bSgjelinek * asynchronous faults on the processes' address space can lock 60510209230bSgjelinek * memory and reserve swap via MCL_FUTURE and MAP_NORESERVE 60520209230bSgjelinek * segments respectively. 60530209230bSgjelinek */ 6054dc32d872SJosef 'Jeff' Sipek AS_LOCK_ENTER(pp->p_as, RW_WRITER); 60550209230bSgjelinek swap = as_swresv(); 60567c478bd9Sstevel@tonic-gate mutex_enter(&pp->p_lock); 60577c478bd9Sstevel@tonic-gate zone_proj0 = zone->zone_zsched->p_task->tk_proj; 60587c478bd9Sstevel@tonic-gate /* verify that we do not exceed and task or lwp limits */ 60597c478bd9Sstevel@tonic-gate mutex_enter(&zone->zone_nlwps_lock); 60607c478bd9Sstevel@tonic-gate /* add new lwps to zone and zone's proj0 */ 60617c478bd9Sstevel@tonic-gate zone_proj0->kpj_nlwps += pp->p_lwpcnt; 60627c478bd9Sstevel@tonic-gate zone->zone_nlwps += pp->p_lwpcnt; 60637c478bd9Sstevel@tonic-gate /* add 1 task to zone's proj0 */ 60647c478bd9Sstevel@tonic-gate zone_proj0->kpj_ntasks += 1; 6065ff19e029SMenno Lageman 6066ff19e029SMenno Lageman zone_proj0->kpj_nprocs++; 6067ff19e029SMenno Lageman zone->zone_nprocs++; 60687c478bd9Sstevel@tonic-gate mutex_exit(&zone->zone_nlwps_lock); 60697c478bd9Sstevel@tonic-gate 60700209230bSgjelinek mutex_enter(&zone->zone_mem_lock); 6071c6939658Ssl zone->zone_locked_mem += pp->p_locked_mem; 6072c6939658Ssl zone_proj0->kpj_data.kpd_locked_mem += pp->p_locked_mem; 60730209230bSgjelinek zone->zone_max_swap += swap; 60740209230bSgjelinek mutex_exit(&zone->zone_mem_lock); 6075c6939658Ssl 6076c1a9a9c3Skrishna mutex_enter(&(zone_proj0->kpj_data.kpd_crypto_lock)); 6077c1a9a9c3Skrishna zone_proj0->kpj_data.kpd_crypto_mem += pp->p_crypto_mem; 6078c1a9a9c3Skrishna mutex_exit(&(zone_proj0->kpj_data.kpd_crypto_lock)); 6079c1a9a9c3Skrishna 6080ff19e029SMenno Lageman /* remove lwps and process from proc's old zone and old project */ 60817c478bd9Sstevel@tonic-gate mutex_enter(&pp->p_zone->zone_nlwps_lock); 60827c478bd9Sstevel@tonic-gate pp->p_zone->zone_nlwps -= pp->p_lwpcnt; 60837c478bd9Sstevel@tonic-gate pp->p_task->tk_proj->kpj_nlwps -= pp->p_lwpcnt; 6084ff19e029SMenno Lageman pp->p_task->tk_proj->kpj_nprocs--; 6085ff19e029SMenno Lageman pp->p_zone->zone_nprocs--; 60867c478bd9Sstevel@tonic-gate mutex_exit(&pp->p_zone->zone_nlwps_lock); 60877c478bd9Sstevel@tonic-gate 60880209230bSgjelinek mutex_enter(&pp->p_zone->zone_mem_lock); 6089c6939658Ssl pp->p_zone->zone_locked_mem -= pp->p_locked_mem; 6090c6939658Ssl pp->p_task->tk_proj->kpj_data.kpd_locked_mem -= pp->p_locked_mem; 60910209230bSgjelinek pp->p_zone->zone_max_swap -= swap; 60920209230bSgjelinek mutex_exit(&pp->p_zone->zone_mem_lock); 6093c6939658Ssl 6094c1a9a9c3Skrishna mutex_enter(&(pp->p_task->tk_proj->kpj_data.kpd_crypto_lock)); 6095c1a9a9c3Skrishna pp->p_task->tk_proj->kpj_data.kpd_crypto_mem -= pp->p_crypto_mem; 6096c1a9a9c3Skrishna mutex_exit(&(pp->p_task->tk_proj->kpj_data.kpd_crypto_lock)); 6097c1a9a9c3Skrishna 6098bb5ca623SVamsi Nagineni pp->p_flag |= SZONETOP; 6099bb5ca623SVamsi Nagineni pp->p_zone = zone; 6100c6939658Ssl mutex_exit(&pp->p_lock); 6101dc32d872SJosef 'Jeff' Sipek AS_LOCK_EXIT(pp->p_as); 6102c6939658Ssl 61037c478bd9Sstevel@tonic-gate /* 61047c478bd9Sstevel@tonic-gate * Joining the zone cannot fail from now on. 61057c478bd9Sstevel@tonic-gate * 61067c478bd9Sstevel@tonic-gate * This means that a lot of the following code can be commonized and 61077c478bd9Sstevel@tonic-gate * shared with zsched(). 61087c478bd9Sstevel@tonic-gate */ 61097c478bd9Sstevel@tonic-gate 61107b209c2cSacruz /* 61117b209c2cSacruz * If the process contract fmri was inherited, we need to 61127b209c2cSacruz * flag this so that any contract status will not leak 61137b209c2cSacruz * extra zone information, svc_fmri in this case 61147b209c2cSacruz */ 61157b209c2cSacruz if (ctp->conp_svc_ctid != ct->ct_id) { 61167b209c2cSacruz mutex_enter(&ct->ct_lock); 61177b209c2cSacruz ctp->conp_svc_zone_enter = ct->ct_id; 61187b209c2cSacruz mutex_exit(&ct->ct_lock); 61197b209c2cSacruz } 61207b209c2cSacruz 61217c478bd9Sstevel@tonic-gate /* 61227c478bd9Sstevel@tonic-gate * Reset the encapsulating process contract's zone. 61237c478bd9Sstevel@tonic-gate */ 61247c478bd9Sstevel@tonic-gate ASSERT(ct->ct_mzuniqid == GLOBAL_ZONEUNIQID); 61257c478bd9Sstevel@tonic-gate contract_setzuniqid(ct, zone->zone_uniqid); 61267c478bd9Sstevel@tonic-gate 61277c478bd9Sstevel@tonic-gate /* 61287c478bd9Sstevel@tonic-gate * Create a new task and associate the process with the project keyed 61297c478bd9Sstevel@tonic-gate * by (projid,zoneid). 61307c478bd9Sstevel@tonic-gate * 61317c478bd9Sstevel@tonic-gate * We might as well be in project 0; the global zone's projid doesn't 61327c478bd9Sstevel@tonic-gate * make much sense in a zone anyhow. 61337c478bd9Sstevel@tonic-gate * 61347c478bd9Sstevel@tonic-gate * This also increments zone_ntasks, and returns with p_lock held. 61357c478bd9Sstevel@tonic-gate */ 61367c478bd9Sstevel@tonic-gate tk = task_create(0, zone); 61377c478bd9Sstevel@tonic-gate oldtk = task_join(tk, 0); 61387c478bd9Sstevel@tonic-gate mutex_exit(&cpu_lock); 61397c478bd9Sstevel@tonic-gate 61407c478bd9Sstevel@tonic-gate /* 61417c478bd9Sstevel@tonic-gate * call RCTLOP_SET functions on this proc 61427c478bd9Sstevel@tonic-gate */ 61437c478bd9Sstevel@tonic-gate e.rcep_p.zone = zone; 61447c478bd9Sstevel@tonic-gate e.rcep_t = RCENTITY_ZONE; 61457c478bd9Sstevel@tonic-gate (void) rctl_set_dup(NULL, NULL, pp, &e, zone->zone_rctls, NULL, 61467c478bd9Sstevel@tonic-gate RCD_CALLBACK); 61477c478bd9Sstevel@tonic-gate mutex_exit(&pp->p_lock); 61487c478bd9Sstevel@tonic-gate 61497c478bd9Sstevel@tonic-gate /* 61507c478bd9Sstevel@tonic-gate * We don't need to hold any of zsched's locks here; not only do we know 61517c478bd9Sstevel@tonic-gate * the process and zone aren't going away, we know its session isn't 61527c478bd9Sstevel@tonic-gate * changing either. 61537c478bd9Sstevel@tonic-gate * 61547c478bd9Sstevel@tonic-gate * By joining zsched's session here, we mimic the behavior in the 61557c478bd9Sstevel@tonic-gate * global zone of init's sid being the pid of sched. We extend this 61567c478bd9Sstevel@tonic-gate * to all zlogin-like zone_enter()'ing processes as well. 61577c478bd9Sstevel@tonic-gate */ 61587c478bd9Sstevel@tonic-gate mutex_enter(&pidlock); 61597c478bd9Sstevel@tonic-gate sp = zone->zone_zsched->p_sessp; 61609acbbeafSnn sess_hold(zone->zone_zsched); 61617c478bd9Sstevel@tonic-gate mutex_enter(&pp->p_lock); 61627c478bd9Sstevel@tonic-gate pgexit(pp); 61639acbbeafSnn sess_rele(pp->p_sessp, B_TRUE); 61647c478bd9Sstevel@tonic-gate pp->p_sessp = sp; 61657c478bd9Sstevel@tonic-gate pgjoin(pp, zone->zone_zsched->p_pidp); 61660209230bSgjelinek 6167c97ad5cdSakolb /* 6168c97ad5cdSakolb * If any threads are scheduled to be placed on zone wait queue they 6169c97ad5cdSakolb * should abandon the idea since the wait queue is changing. 6170c97ad5cdSakolb * We need to be holding pidlock & p_lock to do this. 6171c97ad5cdSakolb */ 6172c97ad5cdSakolb if ((t = pp->p_tlist) != NULL) { 6173c97ad5cdSakolb do { 6174c97ad5cdSakolb thread_lock(t); 6175c97ad5cdSakolb /* 617648bbca81SDaniel Hoffman * Kick this thread so that it doesn't sit 6177c97ad5cdSakolb * on a wrong wait queue. 6178c97ad5cdSakolb */ 6179c97ad5cdSakolb if (ISWAITING(t)) 6180c97ad5cdSakolb setrun_locked(t); 6181c97ad5cdSakolb 6182c97ad5cdSakolb if (t->t_schedflag & TS_ANYWAITQ) 6183c97ad5cdSakolb t->t_schedflag &= ~ TS_ANYWAITQ; 6184c97ad5cdSakolb 6185c97ad5cdSakolb thread_unlock(t); 6186c97ad5cdSakolb } while ((t = t->t_forw) != pp->p_tlist); 6187c97ad5cdSakolb } 6188c97ad5cdSakolb 61890209230bSgjelinek /* 61900209230bSgjelinek * If there is a default scheduling class for the zone and it is not 61910209230bSgjelinek * the class we are currently in, change all of the threads in the 61920209230bSgjelinek * process to the new class. We need to be holding pidlock & p_lock 61930209230bSgjelinek * when we call parmsset so this is a good place to do it. 61940209230bSgjelinek */ 61950209230bSgjelinek if (zone->zone_defaultcid > 0 && 61960209230bSgjelinek zone->zone_defaultcid != curthread->t_cid) { 61970209230bSgjelinek pcparms_t pcparms; 61980209230bSgjelinek 61990209230bSgjelinek pcparms.pc_cid = zone->zone_defaultcid; 62000209230bSgjelinek pcparms.pc_clparms[0] = 0; 62010209230bSgjelinek 62020209230bSgjelinek /* 62030209230bSgjelinek * If setting the class fails, we still want to enter the zone. 62040209230bSgjelinek */ 62050209230bSgjelinek if ((t = pp->p_tlist) != NULL) { 62060209230bSgjelinek do { 62070209230bSgjelinek (void) parmsset(&pcparms, t); 62080209230bSgjelinek } while ((t = t->t_forw) != pp->p_tlist); 62090209230bSgjelinek } 62100209230bSgjelinek } 62110209230bSgjelinek 62127c478bd9Sstevel@tonic-gate mutex_exit(&pp->p_lock); 62137c478bd9Sstevel@tonic-gate mutex_exit(&pidlock); 62147c478bd9Sstevel@tonic-gate 62157c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 62167c478bd9Sstevel@tonic-gate /* 62177c478bd9Sstevel@tonic-gate * We're firmly in the zone; let pools progress. 62187c478bd9Sstevel@tonic-gate */ 62197c478bd9Sstevel@tonic-gate pool_unlock(); 62207c478bd9Sstevel@tonic-gate task_rele(oldtk); 62217c478bd9Sstevel@tonic-gate /* 62227c478bd9Sstevel@tonic-gate * We don't need to retain a hold on the zone since we already 62237c478bd9Sstevel@tonic-gate * incremented zone_ntasks, so the zone isn't going anywhere. 62247c478bd9Sstevel@tonic-gate */ 62257c478bd9Sstevel@tonic-gate zone_rele(zone); 62267c478bd9Sstevel@tonic-gate 62277c478bd9Sstevel@tonic-gate /* 62287c478bd9Sstevel@tonic-gate * Chroot 62297c478bd9Sstevel@tonic-gate */ 62307c478bd9Sstevel@tonic-gate vp = zone->zone_rootvp; 62317c478bd9Sstevel@tonic-gate zone_chdir(vp, &PTOU(pp)->u_cdir, pp); 62327c478bd9Sstevel@tonic-gate zone_chdir(vp, &PTOU(pp)->u_rdir, pp); 62337c478bd9Sstevel@tonic-gate 6234d2a70789SRichard Lowe /* 6235d2a70789SRichard Lowe * Change process security flags. Note that the _effective_ flags 6236d2a70789SRichard Lowe * cannot change 6237d2a70789SRichard Lowe */ 6238d2a70789SRichard Lowe secflags_copy(&pp->p_secflags.psf_lower, 6239d2a70789SRichard Lowe &zone->zone_secflags.psf_lower); 6240d2a70789SRichard Lowe secflags_copy(&pp->p_secflags.psf_upper, 6241d2a70789SRichard Lowe &zone->zone_secflags.psf_upper); 6242d2a70789SRichard Lowe secflags_copy(&pp->p_secflags.psf_inherit, 6243d2a70789SRichard Lowe &zone->zone_secflags.psf_inherit); 6244d2a70789SRichard Lowe 62457c478bd9Sstevel@tonic-gate /* 62467c478bd9Sstevel@tonic-gate * Change process credentials 62477c478bd9Sstevel@tonic-gate */ 62487c478bd9Sstevel@tonic-gate newcr = cralloc(); 62497c478bd9Sstevel@tonic-gate mutex_enter(&pp->p_crlock); 62507c478bd9Sstevel@tonic-gate cr = pp->p_cred; 62517c478bd9Sstevel@tonic-gate crcopy_to(cr, newcr); 62527c478bd9Sstevel@tonic-gate crsetzone(newcr, zone); 62537c478bd9Sstevel@tonic-gate pp->p_cred = newcr; 62547c478bd9Sstevel@tonic-gate 62557c478bd9Sstevel@tonic-gate /* 62567c478bd9Sstevel@tonic-gate * Restrict all process privilege sets to zone limit 62577c478bd9Sstevel@tonic-gate */ 62587c478bd9Sstevel@tonic-gate priv_intersect(zone->zone_privset, &CR_PPRIV(newcr)); 62597c478bd9Sstevel@tonic-gate priv_intersect(zone->zone_privset, &CR_EPRIV(newcr)); 62607c478bd9Sstevel@tonic-gate priv_intersect(zone->zone_privset, &CR_IPRIV(newcr)); 62617c478bd9Sstevel@tonic-gate priv_intersect(zone->zone_privset, &CR_LPRIV(newcr)); 62627c478bd9Sstevel@tonic-gate mutex_exit(&pp->p_crlock); 62637c478bd9Sstevel@tonic-gate crset(pp, newcr); 62647c478bd9Sstevel@tonic-gate 62657c478bd9Sstevel@tonic-gate /* 62667c478bd9Sstevel@tonic-gate * Adjust upcount to reflect zone entry. 62677c478bd9Sstevel@tonic-gate */ 62687c478bd9Sstevel@tonic-gate uid = crgetruid(newcr); 62697c478bd9Sstevel@tonic-gate mutex_enter(&pidlock); 62707c478bd9Sstevel@tonic-gate upcount_dec(uid, GLOBAL_ZONEID); 62717c478bd9Sstevel@tonic-gate upcount_inc(uid, zoneid); 62727c478bd9Sstevel@tonic-gate mutex_exit(&pidlock); 62737c478bd9Sstevel@tonic-gate 62747c478bd9Sstevel@tonic-gate /* 62757c478bd9Sstevel@tonic-gate * Set up core file path and content. 62767c478bd9Sstevel@tonic-gate */ 62777c478bd9Sstevel@tonic-gate set_core_defaults(); 62787c478bd9Sstevel@tonic-gate 62797c478bd9Sstevel@tonic-gate out: 62807c478bd9Sstevel@tonic-gate /* 62817c478bd9Sstevel@tonic-gate * Let the other lwps continue. 62827c478bd9Sstevel@tonic-gate */ 62837c478bd9Sstevel@tonic-gate mutex_enter(&pp->p_lock); 62847c478bd9Sstevel@tonic-gate if (curthread != pp->p_agenttp) 62857c478bd9Sstevel@tonic-gate continuelwps(pp); 62867c478bd9Sstevel@tonic-gate mutex_exit(&pp->p_lock); 62877c478bd9Sstevel@tonic-gate 62887c478bd9Sstevel@tonic-gate return (err != 0 ? set_errno(err) : 0); 62897c478bd9Sstevel@tonic-gate } 62907c478bd9Sstevel@tonic-gate 62917c478bd9Sstevel@tonic-gate /* 62927c478bd9Sstevel@tonic-gate * Systemcall entry point for zone_list(2). 62937c478bd9Sstevel@tonic-gate * 62947c478bd9Sstevel@tonic-gate * Processes running in a (non-global) zone only see themselves. 629545916cd2Sjpk * On labeled systems, they see all zones whose label they dominate. 62967c478bd9Sstevel@tonic-gate */ 62977c478bd9Sstevel@tonic-gate static int 62987c478bd9Sstevel@tonic-gate zone_list(zoneid_t *zoneidlist, uint_t *numzones) 62997c478bd9Sstevel@tonic-gate { 63007c478bd9Sstevel@tonic-gate zoneid_t *zoneids; 630148451833Scarlsonj zone_t *zone, *myzone; 63027c478bd9Sstevel@tonic-gate uint_t user_nzones, real_nzones; 630345916cd2Sjpk uint_t domi_nzones; 630445916cd2Sjpk int error; 63057c478bd9Sstevel@tonic-gate 63067c478bd9Sstevel@tonic-gate if (copyin(numzones, &user_nzones, sizeof (uint_t)) != 0) 63077c478bd9Sstevel@tonic-gate return (set_errno(EFAULT)); 63087c478bd9Sstevel@tonic-gate 630948451833Scarlsonj myzone = curproc->p_zone; 631048451833Scarlsonj if (myzone != global_zone) { 631145916cd2Sjpk bslabel_t *mybslab; 631245916cd2Sjpk 631345916cd2Sjpk if (!is_system_labeled()) { 631445916cd2Sjpk /* just return current zone */ 631545916cd2Sjpk real_nzones = domi_nzones = 1; 631645916cd2Sjpk zoneids = kmem_alloc(sizeof (zoneid_t), KM_SLEEP); 631748451833Scarlsonj zoneids[0] = myzone->zone_id; 631845916cd2Sjpk } else { 631945916cd2Sjpk /* return all zones that are dominated */ 632045916cd2Sjpk mutex_enter(&zonehash_lock); 632145916cd2Sjpk real_nzones = zonecount; 632245916cd2Sjpk domi_nzones = 0; 632345916cd2Sjpk if (real_nzones > 0) { 632445916cd2Sjpk zoneids = kmem_alloc(real_nzones * 632545916cd2Sjpk sizeof (zoneid_t), KM_SLEEP); 632648451833Scarlsonj mybslab = label2bslabel(myzone->zone_slabel); 632745916cd2Sjpk for (zone = list_head(&zone_active); 632845916cd2Sjpk zone != NULL; 632945916cd2Sjpk zone = list_next(&zone_active, zone)) { 633045916cd2Sjpk if (zone->zone_id == GLOBAL_ZONEID) 633145916cd2Sjpk continue; 633248451833Scarlsonj if (zone != myzone && 633348451833Scarlsonj (zone->zone_flags & ZF_IS_SCRATCH)) 633448451833Scarlsonj continue; 633548451833Scarlsonj /* 633648451833Scarlsonj * Note that a label always dominates 633748451833Scarlsonj * itself, so myzone is always included 633848451833Scarlsonj * in the list. 633948451833Scarlsonj */ 634045916cd2Sjpk if (bldominates(mybslab, 634145916cd2Sjpk label2bslabel(zone->zone_slabel))) { 634245916cd2Sjpk zoneids[domi_nzones++] = 634345916cd2Sjpk zone->zone_id; 634445916cd2Sjpk } 634545916cd2Sjpk } 634645916cd2Sjpk } 634745916cd2Sjpk mutex_exit(&zonehash_lock); 634845916cd2Sjpk } 63497c478bd9Sstevel@tonic-gate } else { 63507c478bd9Sstevel@tonic-gate mutex_enter(&zonehash_lock); 63517c478bd9Sstevel@tonic-gate real_nzones = zonecount; 635245916cd2Sjpk domi_nzones = 0; 635345916cd2Sjpk if (real_nzones > 0) { 63547c478bd9Sstevel@tonic-gate zoneids = kmem_alloc(real_nzones * sizeof (zoneid_t), 63557c478bd9Sstevel@tonic-gate KM_SLEEP); 63567c478bd9Sstevel@tonic-gate for (zone = list_head(&zone_active); zone != NULL; 63577c478bd9Sstevel@tonic-gate zone = list_next(&zone_active, zone)) 635845916cd2Sjpk zoneids[domi_nzones++] = zone->zone_id; 635945916cd2Sjpk ASSERT(domi_nzones == real_nzones); 63607c478bd9Sstevel@tonic-gate } 63617c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 63627c478bd9Sstevel@tonic-gate } 63637c478bd9Sstevel@tonic-gate 636445916cd2Sjpk /* 636545916cd2Sjpk * If user has allocated space for fewer entries than we found, then 636648bbca81SDaniel Hoffman * return only up to their limit. Either way, tell them exactly how 636748bbca81SDaniel Hoffman * many we found. 636845916cd2Sjpk */ 636945916cd2Sjpk if (domi_nzones < user_nzones) 637045916cd2Sjpk user_nzones = domi_nzones; 637145916cd2Sjpk error = 0; 637245916cd2Sjpk if (copyout(&domi_nzones, numzones, sizeof (uint_t)) != 0) { 63737c478bd9Sstevel@tonic-gate error = EFAULT; 637445916cd2Sjpk } else if (zoneidlist != NULL && user_nzones != 0) { 63757c478bd9Sstevel@tonic-gate if (copyout(zoneids, zoneidlist, 63767c478bd9Sstevel@tonic-gate user_nzones * sizeof (zoneid_t)) != 0) 63777c478bd9Sstevel@tonic-gate error = EFAULT; 63787c478bd9Sstevel@tonic-gate } 63797c478bd9Sstevel@tonic-gate 638045916cd2Sjpk if (real_nzones > 0) 63817c478bd9Sstevel@tonic-gate kmem_free(zoneids, real_nzones * sizeof (zoneid_t)); 63827c478bd9Sstevel@tonic-gate 638345916cd2Sjpk if (error != 0) 63847c478bd9Sstevel@tonic-gate return (set_errno(error)); 63857c478bd9Sstevel@tonic-gate else 63867c478bd9Sstevel@tonic-gate return (0); 63877c478bd9Sstevel@tonic-gate } 63887c478bd9Sstevel@tonic-gate 63897c478bd9Sstevel@tonic-gate /* 63907c478bd9Sstevel@tonic-gate * Systemcall entry point for zone_lookup(2). 63917c478bd9Sstevel@tonic-gate * 639245916cd2Sjpk * Non-global zones are only able to see themselves and (on labeled systems) 639345916cd2Sjpk * the zones they dominate. 63947c478bd9Sstevel@tonic-gate */ 63957c478bd9Sstevel@tonic-gate static zoneid_t 63967c478bd9Sstevel@tonic-gate zone_lookup(const char *zone_name) 63977c478bd9Sstevel@tonic-gate { 63987c478bd9Sstevel@tonic-gate char *kname; 63997c478bd9Sstevel@tonic-gate zone_t *zone; 64007c478bd9Sstevel@tonic-gate zoneid_t zoneid; 64017c478bd9Sstevel@tonic-gate int err; 64027c478bd9Sstevel@tonic-gate 64037c478bd9Sstevel@tonic-gate if (zone_name == NULL) { 64047c478bd9Sstevel@tonic-gate /* return caller's zone id */ 64057c478bd9Sstevel@tonic-gate return (getzoneid()); 64067c478bd9Sstevel@tonic-gate } 64077c478bd9Sstevel@tonic-gate 64087c478bd9Sstevel@tonic-gate kname = kmem_zalloc(ZONENAME_MAX, KM_SLEEP); 64097c478bd9Sstevel@tonic-gate if ((err = copyinstr(zone_name, kname, ZONENAME_MAX, NULL)) != 0) { 64107c478bd9Sstevel@tonic-gate kmem_free(kname, ZONENAME_MAX); 64117c478bd9Sstevel@tonic-gate return (set_errno(err)); 64127c478bd9Sstevel@tonic-gate } 64137c478bd9Sstevel@tonic-gate 64147c478bd9Sstevel@tonic-gate mutex_enter(&zonehash_lock); 64157c478bd9Sstevel@tonic-gate zone = zone_find_all_by_name(kname); 64167c478bd9Sstevel@tonic-gate kmem_free(kname, ZONENAME_MAX); 641745916cd2Sjpk /* 641845916cd2Sjpk * In a non-global zone, can only lookup global and own name. 641945916cd2Sjpk * In Trusted Extensions zone label dominance rules apply. 642045916cd2Sjpk */ 642145916cd2Sjpk if (zone == NULL || 642245916cd2Sjpk zone_status_get(zone) < ZONE_IS_READY || 642345916cd2Sjpk !zone_list_access(zone)) { 64247c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 64257c478bd9Sstevel@tonic-gate return (set_errno(EINVAL)); 642645916cd2Sjpk } else { 642745916cd2Sjpk zoneid = zone->zone_id; 642845916cd2Sjpk mutex_exit(&zonehash_lock); 642945916cd2Sjpk return (zoneid); 64307c478bd9Sstevel@tonic-gate } 64317c478bd9Sstevel@tonic-gate } 64327c478bd9Sstevel@tonic-gate 6433821c4a97Sdp static int 6434821c4a97Sdp zone_version(int *version_arg) 6435821c4a97Sdp { 6436821c4a97Sdp int version = ZONE_SYSCALL_API_VERSION; 6437821c4a97Sdp 6438821c4a97Sdp if (copyout(&version, version_arg, sizeof (int)) != 0) 6439821c4a97Sdp return (set_errno(EFAULT)); 6440821c4a97Sdp return (0); 6441821c4a97Sdp } 6442821c4a97Sdp 64437c478bd9Sstevel@tonic-gate /* ARGSUSED */ 64447c478bd9Sstevel@tonic-gate long 6445fa9e4066Sahrens zone(int cmd, void *arg1, void *arg2, void *arg3, void *arg4) 64467c478bd9Sstevel@tonic-gate { 64477c478bd9Sstevel@tonic-gate zone_def zs; 64482b24ab6bSSebastien Roy int err; 64497c478bd9Sstevel@tonic-gate 64507c478bd9Sstevel@tonic-gate switch (cmd) { 64517c478bd9Sstevel@tonic-gate case ZONE_CREATE: 64527c478bd9Sstevel@tonic-gate if (get_udatamodel() == DATAMODEL_NATIVE) { 64537c478bd9Sstevel@tonic-gate if (copyin(arg1, &zs, sizeof (zone_def))) { 64547c478bd9Sstevel@tonic-gate return (set_errno(EFAULT)); 64557c478bd9Sstevel@tonic-gate } 64567c478bd9Sstevel@tonic-gate } else { 64577c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 64587c478bd9Sstevel@tonic-gate zone_def32 zs32; 64597c478bd9Sstevel@tonic-gate 64607c478bd9Sstevel@tonic-gate if (copyin(arg1, &zs32, sizeof (zone_def32))) { 64617c478bd9Sstevel@tonic-gate return (set_errno(EFAULT)); 64627c478bd9Sstevel@tonic-gate } 64637c478bd9Sstevel@tonic-gate zs.zone_name = 64647c478bd9Sstevel@tonic-gate (const char *)(unsigned long)zs32.zone_name; 64657c478bd9Sstevel@tonic-gate zs.zone_root = 64667c478bd9Sstevel@tonic-gate (const char *)(unsigned long)zs32.zone_root; 64677c478bd9Sstevel@tonic-gate zs.zone_privs = 64687c478bd9Sstevel@tonic-gate (const struct priv_set *) 64697c478bd9Sstevel@tonic-gate (unsigned long)zs32.zone_privs; 64706f70df68Sdp zs.zone_privssz = zs32.zone_privssz; 64717c478bd9Sstevel@tonic-gate zs.rctlbuf = (caddr_t)(unsigned long)zs32.rctlbuf; 64727c478bd9Sstevel@tonic-gate zs.rctlbufsz = zs32.rctlbufsz; 6473fa9e4066Sahrens zs.zfsbuf = (caddr_t)(unsigned long)zs32.zfsbuf; 6474fa9e4066Sahrens zs.zfsbufsz = zs32.zfsbufsz; 64757c478bd9Sstevel@tonic-gate zs.extended_error = 64767c478bd9Sstevel@tonic-gate (int *)(unsigned long)zs32.extended_error; 647745916cd2Sjpk zs.match = zs32.match; 647845916cd2Sjpk zs.doi = zs32.doi; 647945916cd2Sjpk zs.label = (const bslabel_t *)(uintptr_t)zs32.label; 6480f4b3ec61Sdh zs.flags = zs32.flags; 64817c478bd9Sstevel@tonic-gate #else 64827c478bd9Sstevel@tonic-gate panic("get_udatamodel() returned bogus result\n"); 64837c478bd9Sstevel@tonic-gate #endif 64847c478bd9Sstevel@tonic-gate } 64857c478bd9Sstevel@tonic-gate 64867c478bd9Sstevel@tonic-gate return (zone_create(zs.zone_name, zs.zone_root, 6487821c4a97Sdp zs.zone_privs, zs.zone_privssz, 6488821c4a97Sdp (caddr_t)zs.rctlbuf, zs.rctlbufsz, 6489821c4a97Sdp (caddr_t)zs.zfsbuf, zs.zfsbufsz, 649045916cd2Sjpk zs.extended_error, zs.match, zs.doi, 6491f4b3ec61Sdh zs.label, zs.flags)); 64927c478bd9Sstevel@tonic-gate case ZONE_BOOT: 64933f2f09c1Sdp return (zone_boot((zoneid_t)(uintptr_t)arg1)); 64947c478bd9Sstevel@tonic-gate case ZONE_DESTROY: 64957c478bd9Sstevel@tonic-gate return (zone_destroy((zoneid_t)(uintptr_t)arg1)); 64967c478bd9Sstevel@tonic-gate case ZONE_GETATTR: 64977c478bd9Sstevel@tonic-gate return (zone_getattr((zoneid_t)(uintptr_t)arg1, 64987c478bd9Sstevel@tonic-gate (int)(uintptr_t)arg2, arg3, (size_t)arg4)); 64993f2f09c1Sdp case ZONE_SETATTR: 65003f2f09c1Sdp return (zone_setattr((zoneid_t)(uintptr_t)arg1, 65013f2f09c1Sdp (int)(uintptr_t)arg2, arg3, (size_t)arg4)); 65027c478bd9Sstevel@tonic-gate case ZONE_ENTER: 65037c478bd9Sstevel@tonic-gate return (zone_enter((zoneid_t)(uintptr_t)arg1)); 65047c478bd9Sstevel@tonic-gate case ZONE_LIST: 65057c478bd9Sstevel@tonic-gate return (zone_list((zoneid_t *)arg1, (uint_t *)arg2)); 65067c478bd9Sstevel@tonic-gate case ZONE_SHUTDOWN: 65077c478bd9Sstevel@tonic-gate return (zone_shutdown((zoneid_t)(uintptr_t)arg1)); 65087c478bd9Sstevel@tonic-gate case ZONE_LOOKUP: 65097c478bd9Sstevel@tonic-gate return (zone_lookup((const char *)arg1)); 6510821c4a97Sdp case ZONE_VERSION: 6511821c4a97Sdp return (zone_version((int *)arg1)); 6512f4b3ec61Sdh case ZONE_ADD_DATALINK: 6513f4b3ec61Sdh return (zone_add_datalink((zoneid_t)(uintptr_t)arg1, 65142b24ab6bSSebastien Roy (datalink_id_t)(uintptr_t)arg2)); 6515f4b3ec61Sdh case ZONE_DEL_DATALINK: 6516f4b3ec61Sdh return (zone_remove_datalink((zoneid_t)(uintptr_t)arg1, 65172b24ab6bSSebastien Roy (datalink_id_t)(uintptr_t)arg2)); 65182b24ab6bSSebastien Roy case ZONE_CHECK_DATALINK: { 65192b24ab6bSSebastien Roy zoneid_t zoneid; 65202b24ab6bSSebastien Roy boolean_t need_copyout; 65212b24ab6bSSebastien Roy 65222b24ab6bSSebastien Roy if (copyin(arg1, &zoneid, sizeof (zoneid)) != 0) 65232b24ab6bSSebastien Roy return (EFAULT); 65242b24ab6bSSebastien Roy need_copyout = (zoneid == ALL_ZONES); 65252b24ab6bSSebastien Roy err = zone_check_datalink(&zoneid, 65262b24ab6bSSebastien Roy (datalink_id_t)(uintptr_t)arg2); 65272b24ab6bSSebastien Roy if (err == 0 && need_copyout) { 65282b24ab6bSSebastien Roy if (copyout(&zoneid, arg1, sizeof (zoneid)) != 0) 65292b24ab6bSSebastien Roy err = EFAULT; 65302b24ab6bSSebastien Roy } 65312b24ab6bSSebastien Roy return (err == 0 ? 0 : set_errno(err)); 65322b24ab6bSSebastien Roy } 6533f4b3ec61Sdh case ZONE_LIST_DATALINK: 6534f4b3ec61Sdh return (zone_list_datalink((zoneid_t)(uintptr_t)arg1, 65352b24ab6bSSebastien Roy (int *)arg2, (datalink_id_t *)(uintptr_t)arg3)); 65367c478bd9Sstevel@tonic-gate default: 65377c478bd9Sstevel@tonic-gate return (set_errno(EINVAL)); 65387c478bd9Sstevel@tonic-gate } 65397c478bd9Sstevel@tonic-gate } 65407c478bd9Sstevel@tonic-gate 65417c478bd9Sstevel@tonic-gate struct zarg { 65427c478bd9Sstevel@tonic-gate zone_t *zone; 65437c478bd9Sstevel@tonic-gate zone_cmd_arg_t arg; 65447c478bd9Sstevel@tonic-gate }; 65457c478bd9Sstevel@tonic-gate 65467c478bd9Sstevel@tonic-gate static int 65477c478bd9Sstevel@tonic-gate zone_lookup_door(const char *zone_name, door_handle_t *doorp) 65487c478bd9Sstevel@tonic-gate { 65497c478bd9Sstevel@tonic-gate char *buf; 65507c478bd9Sstevel@tonic-gate size_t buflen; 65517c478bd9Sstevel@tonic-gate int error; 65527c478bd9Sstevel@tonic-gate 65537c478bd9Sstevel@tonic-gate buflen = sizeof (ZONE_DOOR_PATH) + strlen(zone_name); 65547c478bd9Sstevel@tonic-gate buf = kmem_alloc(buflen, KM_SLEEP); 65557c478bd9Sstevel@tonic-gate (void) snprintf(buf, buflen, ZONE_DOOR_PATH, zone_name); 65567c478bd9Sstevel@tonic-gate error = door_ki_open(buf, doorp); 65577c478bd9Sstevel@tonic-gate kmem_free(buf, buflen); 65587c478bd9Sstevel@tonic-gate return (error); 65597c478bd9Sstevel@tonic-gate } 65607c478bd9Sstevel@tonic-gate 65617c478bd9Sstevel@tonic-gate static void 65627c478bd9Sstevel@tonic-gate zone_release_door(door_handle_t *doorp) 65637c478bd9Sstevel@tonic-gate { 65647c478bd9Sstevel@tonic-gate door_ki_rele(*doorp); 65657c478bd9Sstevel@tonic-gate *doorp = NULL; 65667c478bd9Sstevel@tonic-gate } 65677c478bd9Sstevel@tonic-gate 65687c478bd9Sstevel@tonic-gate static void 65697c478bd9Sstevel@tonic-gate zone_ki_call_zoneadmd(struct zarg *zargp) 65707c478bd9Sstevel@tonic-gate { 65717c478bd9Sstevel@tonic-gate door_handle_t door = NULL; 65727c478bd9Sstevel@tonic-gate door_arg_t darg, save_arg; 65737c478bd9Sstevel@tonic-gate char *zone_name; 65747c478bd9Sstevel@tonic-gate size_t zone_namelen; 65757c478bd9Sstevel@tonic-gate zoneid_t zoneid; 65767c478bd9Sstevel@tonic-gate zone_t *zone; 65777c478bd9Sstevel@tonic-gate zone_cmd_arg_t arg; 65787c478bd9Sstevel@tonic-gate uint64_t uniqid; 65797c478bd9Sstevel@tonic-gate size_t size; 65807c478bd9Sstevel@tonic-gate int error; 65817c478bd9Sstevel@tonic-gate int retry; 65827c478bd9Sstevel@tonic-gate 65837c478bd9Sstevel@tonic-gate zone = zargp->zone; 65847c478bd9Sstevel@tonic-gate arg = zargp->arg; 65857c478bd9Sstevel@tonic-gate kmem_free(zargp, sizeof (*zargp)); 65867c478bd9Sstevel@tonic-gate 65877c478bd9Sstevel@tonic-gate zone_namelen = strlen(zone->zone_name) + 1; 65887c478bd9Sstevel@tonic-gate zone_name = kmem_alloc(zone_namelen, KM_SLEEP); 65897c478bd9Sstevel@tonic-gate bcopy(zone->zone_name, zone_name, zone_namelen); 65907c478bd9Sstevel@tonic-gate zoneid = zone->zone_id; 65917c478bd9Sstevel@tonic-gate uniqid = zone->zone_uniqid; 65927c478bd9Sstevel@tonic-gate /* 65937c478bd9Sstevel@tonic-gate * zoneadmd may be down, but at least we can empty out the zone. 65947c478bd9Sstevel@tonic-gate * We can ignore the return value of zone_empty() since we're called 65957c478bd9Sstevel@tonic-gate * from a kernel thread and know we won't be delivered any signals. 65967c478bd9Sstevel@tonic-gate */ 65977c478bd9Sstevel@tonic-gate ASSERT(curproc == &p0); 65987c478bd9Sstevel@tonic-gate (void) zone_empty(zone); 65997c478bd9Sstevel@tonic-gate ASSERT(zone_status_get(zone) >= ZONE_IS_EMPTY); 66007c478bd9Sstevel@tonic-gate zone_rele(zone); 66017c478bd9Sstevel@tonic-gate 66027c478bd9Sstevel@tonic-gate size = sizeof (arg); 66037c478bd9Sstevel@tonic-gate darg.rbuf = (char *)&arg; 66047c478bd9Sstevel@tonic-gate darg.data_ptr = (char *)&arg; 66057c478bd9Sstevel@tonic-gate darg.rsize = size; 66067c478bd9Sstevel@tonic-gate darg.data_size = size; 66077c478bd9Sstevel@tonic-gate darg.desc_ptr = NULL; 66087c478bd9Sstevel@tonic-gate darg.desc_num = 0; 66097c478bd9Sstevel@tonic-gate 66107c478bd9Sstevel@tonic-gate save_arg = darg; 66117c478bd9Sstevel@tonic-gate /* 66127c478bd9Sstevel@tonic-gate * Since we're not holding a reference to the zone, any number of 66137c478bd9Sstevel@tonic-gate * things can go wrong, including the zone disappearing before we get a 66147c478bd9Sstevel@tonic-gate * chance to talk to zoneadmd. 66157c478bd9Sstevel@tonic-gate */ 66167c478bd9Sstevel@tonic-gate for (retry = 0; /* forever */; retry++) { 66177c478bd9Sstevel@tonic-gate if (door == NULL && 66187c478bd9Sstevel@tonic-gate (error = zone_lookup_door(zone_name, &door)) != 0) { 66197c478bd9Sstevel@tonic-gate goto next; 66207c478bd9Sstevel@tonic-gate } 66217c478bd9Sstevel@tonic-gate ASSERT(door != NULL); 66227c478bd9Sstevel@tonic-gate 6623323a81d9Sjwadams if ((error = door_ki_upcall_limited(door, &darg, NULL, 6624323a81d9Sjwadams SIZE_MAX, 0)) == 0) { 66257c478bd9Sstevel@tonic-gate break; 66267c478bd9Sstevel@tonic-gate } 66277c478bd9Sstevel@tonic-gate switch (error) { 66287c478bd9Sstevel@tonic-gate case EINTR: 66297c478bd9Sstevel@tonic-gate /* FALLTHROUGH */ 66307c478bd9Sstevel@tonic-gate case EAGAIN: /* process may be forking */ 66317c478bd9Sstevel@tonic-gate /* 66327c478bd9Sstevel@tonic-gate * Back off for a bit 66337c478bd9Sstevel@tonic-gate */ 66347c478bd9Sstevel@tonic-gate break; 66357c478bd9Sstevel@tonic-gate case EBADF: 66367c478bd9Sstevel@tonic-gate zone_release_door(&door); 66377c478bd9Sstevel@tonic-gate if (zone_lookup_door(zone_name, &door) != 0) { 66387c478bd9Sstevel@tonic-gate /* 66397c478bd9Sstevel@tonic-gate * zoneadmd may be dead, but it may come back to 66407c478bd9Sstevel@tonic-gate * life later. 66417c478bd9Sstevel@tonic-gate */ 66427c478bd9Sstevel@tonic-gate break; 66437c478bd9Sstevel@tonic-gate } 66447c478bd9Sstevel@tonic-gate break; 66457c478bd9Sstevel@tonic-gate default: 66467c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, 66477c478bd9Sstevel@tonic-gate "zone_ki_call_zoneadmd: door_ki_upcall error %d\n", 66487c478bd9Sstevel@tonic-gate error); 66497c478bd9Sstevel@tonic-gate goto out; 66507c478bd9Sstevel@tonic-gate } 66517c478bd9Sstevel@tonic-gate next: 66527c478bd9Sstevel@tonic-gate /* 66537c478bd9Sstevel@tonic-gate * If this isn't the same zone_t that we originally had in mind, 66547c478bd9Sstevel@tonic-gate * then this is the same as if two kadmin requests come in at 66557c478bd9Sstevel@tonic-gate * the same time: the first one wins. This means we lose, so we 66567c478bd9Sstevel@tonic-gate * bail. 66577c478bd9Sstevel@tonic-gate */ 66587c478bd9Sstevel@tonic-gate if ((zone = zone_find_by_id(zoneid)) == NULL) { 66597c478bd9Sstevel@tonic-gate /* 66607c478bd9Sstevel@tonic-gate * Problem is solved. 66617c478bd9Sstevel@tonic-gate */ 66627c478bd9Sstevel@tonic-gate break; 66637c478bd9Sstevel@tonic-gate } 66647c478bd9Sstevel@tonic-gate if (zone->zone_uniqid != uniqid) { 66657c478bd9Sstevel@tonic-gate /* 66667c478bd9Sstevel@tonic-gate * zoneid recycled 66677c478bd9Sstevel@tonic-gate */ 66687c478bd9Sstevel@tonic-gate zone_rele(zone); 66697c478bd9Sstevel@tonic-gate break; 66707c478bd9Sstevel@tonic-gate } 66717c478bd9Sstevel@tonic-gate /* 66727c478bd9Sstevel@tonic-gate * We could zone_status_timedwait(), but there doesn't seem to 66737c478bd9Sstevel@tonic-gate * be much point in doing that (plus, it would mean that 66747c478bd9Sstevel@tonic-gate * zone_free() isn't called until this thread exits). 66757c478bd9Sstevel@tonic-gate */ 66767c478bd9Sstevel@tonic-gate zone_rele(zone); 66777c478bd9Sstevel@tonic-gate delay(hz); 66787c478bd9Sstevel@tonic-gate darg = save_arg; 66797c478bd9Sstevel@tonic-gate } 66807c478bd9Sstevel@tonic-gate out: 66817c478bd9Sstevel@tonic-gate if (door != NULL) { 66827c478bd9Sstevel@tonic-gate zone_release_door(&door); 66837c478bd9Sstevel@tonic-gate } 66847c478bd9Sstevel@tonic-gate kmem_free(zone_name, zone_namelen); 66857c478bd9Sstevel@tonic-gate thread_exit(); 66867c478bd9Sstevel@tonic-gate } 66877c478bd9Sstevel@tonic-gate 66887c478bd9Sstevel@tonic-gate /* 66893f2f09c1Sdp * Entry point for uadmin() to tell the zone to go away or reboot. Analog to 66903f2f09c1Sdp * kadmin(). The caller is a process in the zone. 66917c478bd9Sstevel@tonic-gate * 66927c478bd9Sstevel@tonic-gate * In order to shutdown the zone, we will hand off control to zoneadmd 66937c478bd9Sstevel@tonic-gate * (running in the global zone) via a door. We do a half-hearted job at 66947c478bd9Sstevel@tonic-gate * killing all processes in the zone, create a kernel thread to contact 66957c478bd9Sstevel@tonic-gate * zoneadmd, and make note of the "uniqid" of the zone. The uniqid is 66967c478bd9Sstevel@tonic-gate * a form of generation number used to let zoneadmd (as well as 66977c478bd9Sstevel@tonic-gate * zone_destroy()) know exactly which zone they're re talking about. 66987c478bd9Sstevel@tonic-gate */ 66997c478bd9Sstevel@tonic-gate int 67003f2f09c1Sdp zone_kadmin(int cmd, int fcn, const char *mdep, cred_t *credp) 67017c478bd9Sstevel@tonic-gate { 67027c478bd9Sstevel@tonic-gate struct zarg *zargp; 67037c478bd9Sstevel@tonic-gate zone_cmd_t zcmd; 67047c478bd9Sstevel@tonic-gate zone_t *zone; 67057c478bd9Sstevel@tonic-gate 67067c478bd9Sstevel@tonic-gate zone = curproc->p_zone; 67077c478bd9Sstevel@tonic-gate ASSERT(getzoneid() != GLOBAL_ZONEID); 67087c478bd9Sstevel@tonic-gate 67097c478bd9Sstevel@tonic-gate switch (cmd) { 67107c478bd9Sstevel@tonic-gate case A_SHUTDOWN: 67117c478bd9Sstevel@tonic-gate switch (fcn) { 67127c478bd9Sstevel@tonic-gate case AD_HALT: 67137c478bd9Sstevel@tonic-gate case AD_POWEROFF: 67147c478bd9Sstevel@tonic-gate zcmd = Z_HALT; 67157c478bd9Sstevel@tonic-gate break; 67167c478bd9Sstevel@tonic-gate case AD_BOOT: 67177c478bd9Sstevel@tonic-gate zcmd = Z_REBOOT; 67187c478bd9Sstevel@tonic-gate break; 67197c478bd9Sstevel@tonic-gate case AD_IBOOT: 67207c478bd9Sstevel@tonic-gate case AD_SBOOT: 67217c478bd9Sstevel@tonic-gate case AD_SIBOOT: 67227c478bd9Sstevel@tonic-gate case AD_NOSYNC: 67237c478bd9Sstevel@tonic-gate return (ENOTSUP); 67247c478bd9Sstevel@tonic-gate default: 67257c478bd9Sstevel@tonic-gate return (EINVAL); 67267c478bd9Sstevel@tonic-gate } 67277c478bd9Sstevel@tonic-gate break; 67287c478bd9Sstevel@tonic-gate case A_REBOOT: 67297c478bd9Sstevel@tonic-gate zcmd = Z_REBOOT; 67307c478bd9Sstevel@tonic-gate break; 67317c478bd9Sstevel@tonic-gate case A_FTRACE: 67327c478bd9Sstevel@tonic-gate case A_REMOUNT: 67337c478bd9Sstevel@tonic-gate case A_FREEZE: 67347c478bd9Sstevel@tonic-gate case A_DUMP: 6735753a6d45SSherry Moore case A_CONFIG: 67367c478bd9Sstevel@tonic-gate return (ENOTSUP); 67377c478bd9Sstevel@tonic-gate default: 67387c478bd9Sstevel@tonic-gate ASSERT(cmd != A_SWAPCTL); /* handled by uadmin() */ 67397c478bd9Sstevel@tonic-gate return (EINVAL); 67407c478bd9Sstevel@tonic-gate } 67417c478bd9Sstevel@tonic-gate 67427c478bd9Sstevel@tonic-gate if (secpolicy_zone_admin(credp, B_FALSE)) 67437c478bd9Sstevel@tonic-gate return (EPERM); 67447c478bd9Sstevel@tonic-gate mutex_enter(&zone_status_lock); 67453f2f09c1Sdp 67467c478bd9Sstevel@tonic-gate /* 67477c478bd9Sstevel@tonic-gate * zone_status can't be ZONE_IS_EMPTY or higher since curproc 67487c478bd9Sstevel@tonic-gate * is in the zone. 67497c478bd9Sstevel@tonic-gate */ 67507c478bd9Sstevel@tonic-gate ASSERT(zone_status_get(zone) < ZONE_IS_EMPTY); 67517c478bd9Sstevel@tonic-gate if (zone_status_get(zone) > ZONE_IS_RUNNING) { 67527c478bd9Sstevel@tonic-gate /* 67537c478bd9Sstevel@tonic-gate * This zone is already on its way down. 67547c478bd9Sstevel@tonic-gate */ 67557c478bd9Sstevel@tonic-gate mutex_exit(&zone_status_lock); 67567c478bd9Sstevel@tonic-gate return (0); 67577c478bd9Sstevel@tonic-gate } 67587c478bd9Sstevel@tonic-gate /* 67597c478bd9Sstevel@tonic-gate * Prevent future zone_enter()s 67607c478bd9Sstevel@tonic-gate */ 67617c478bd9Sstevel@tonic-gate zone_status_set(zone, ZONE_IS_SHUTTING_DOWN); 67627c478bd9Sstevel@tonic-gate mutex_exit(&zone_status_lock); 67637c478bd9Sstevel@tonic-gate 67647c478bd9Sstevel@tonic-gate /* 67657c478bd9Sstevel@tonic-gate * Kill everyone now and call zoneadmd later. 67667c478bd9Sstevel@tonic-gate * zone_ki_call_zoneadmd() will do a more thorough job of this 67677c478bd9Sstevel@tonic-gate * later. 67687c478bd9Sstevel@tonic-gate */ 67697c478bd9Sstevel@tonic-gate killall(zone->zone_id); 67707c478bd9Sstevel@tonic-gate /* 67717c478bd9Sstevel@tonic-gate * Now, create the thread to contact zoneadmd and do the rest of the 67727c478bd9Sstevel@tonic-gate * work. This thread can't be created in our zone otherwise 67737c478bd9Sstevel@tonic-gate * zone_destroy() would deadlock. 67747c478bd9Sstevel@tonic-gate */ 67753f2f09c1Sdp zargp = kmem_zalloc(sizeof (*zargp), KM_SLEEP); 67767c478bd9Sstevel@tonic-gate zargp->arg.cmd = zcmd; 67777c478bd9Sstevel@tonic-gate zargp->arg.uniqid = zone->zone_uniqid; 67783f2f09c1Sdp zargp->zone = zone; 67797c478bd9Sstevel@tonic-gate (void) strcpy(zargp->arg.locale, "C"); 67803f2f09c1Sdp /* mdep was already copied in for us by uadmin */ 67813f2f09c1Sdp if (mdep != NULL) 67823f2f09c1Sdp (void) strlcpy(zargp->arg.bootbuf, mdep, 67833f2f09c1Sdp sizeof (zargp->arg.bootbuf)); 67843f2f09c1Sdp zone_hold(zone); 67857c478bd9Sstevel@tonic-gate 67867c478bd9Sstevel@tonic-gate (void) thread_create(NULL, 0, zone_ki_call_zoneadmd, zargp, 0, &p0, 67877c478bd9Sstevel@tonic-gate TS_RUN, minclsyspri); 67887c478bd9Sstevel@tonic-gate exit(CLD_EXITED, 0); 67897c478bd9Sstevel@tonic-gate 67907c478bd9Sstevel@tonic-gate return (EINVAL); 67917c478bd9Sstevel@tonic-gate } 67927c478bd9Sstevel@tonic-gate 67937c478bd9Sstevel@tonic-gate /* 67947c478bd9Sstevel@tonic-gate * Entry point so kadmin(A_SHUTDOWN, ...) can set the global zone's 67957c478bd9Sstevel@tonic-gate * status to ZONE_IS_SHUTTING_DOWN. 67968f983ab3Sjv * 67978f983ab3Sjv * This function also shuts down all running zones to ensure that they won't 67988f983ab3Sjv * fork new processes. 67997c478bd9Sstevel@tonic-gate */ 68007c478bd9Sstevel@tonic-gate void 68017c478bd9Sstevel@tonic-gate zone_shutdown_global(void) 68027c478bd9Sstevel@tonic-gate { 68038f983ab3Sjv zone_t *current_zonep; 68047c478bd9Sstevel@tonic-gate 68058f983ab3Sjv ASSERT(INGLOBALZONE(curproc)); 68068f983ab3Sjv mutex_enter(&zonehash_lock); 68077c478bd9Sstevel@tonic-gate mutex_enter(&zone_status_lock); 68088f983ab3Sjv 68098f983ab3Sjv /* Modify the global zone's status first. */ 68107c478bd9Sstevel@tonic-gate ASSERT(zone_status_get(global_zone) == ZONE_IS_RUNNING); 68117c478bd9Sstevel@tonic-gate zone_status_set(global_zone, ZONE_IS_SHUTTING_DOWN); 68128f983ab3Sjv 68138f983ab3Sjv /* 68148f983ab3Sjv * Now change the states of all running zones to ZONE_IS_SHUTTING_DOWN. 68158f983ab3Sjv * We don't mark all zones with ZONE_IS_SHUTTING_DOWN because doing so 68168f983ab3Sjv * could cause assertions to fail (e.g., assertions about a zone's 68178f983ab3Sjv * state during initialization, readying, or booting) or produce races. 68188f983ab3Sjv * We'll let threads continue to initialize and ready new zones: they'll 68198f983ab3Sjv * fail to boot the new zones when they see that the global zone is 68208f983ab3Sjv * shutting down. 68218f983ab3Sjv */ 68228f983ab3Sjv for (current_zonep = list_head(&zone_active); current_zonep != NULL; 68238f983ab3Sjv current_zonep = list_next(&zone_active, current_zonep)) { 68248f983ab3Sjv if (zone_status_get(current_zonep) == ZONE_IS_RUNNING) 68258f983ab3Sjv zone_status_set(current_zonep, ZONE_IS_SHUTTING_DOWN); 68268f983ab3Sjv } 68277c478bd9Sstevel@tonic-gate mutex_exit(&zone_status_lock); 68288f983ab3Sjv mutex_exit(&zonehash_lock); 68297c478bd9Sstevel@tonic-gate } 6830fa9e4066Sahrens 6831fa9e4066Sahrens /* 6832fa9e4066Sahrens * Returns true if the named dataset is visible in the current zone. 6833fa9e4066Sahrens * The 'write' parameter is set to 1 if the dataset is also writable. 6834fa9e4066Sahrens */ 6835fa9e4066Sahrens int 6836fa9e4066Sahrens zone_dataset_visible(const char *dataset, int *write) 6837fa9e4066Sahrens { 6838658a1dc7SSanjeev Bagewadi static int zfstype = -1; 6839fa9e4066Sahrens zone_dataset_t *zd; 6840fa9e4066Sahrens size_t len; 6841fa9e4066Sahrens zone_t *zone = curproc->p_zone; 6842658a1dc7SSanjeev Bagewadi const char *name = NULL; 6843658a1dc7SSanjeev Bagewadi vfs_t *vfsp = NULL; 6844fa9e4066Sahrens 6845fa9e4066Sahrens if (dataset[0] == '\0') 6846fa9e4066Sahrens return (0); 6847fa9e4066Sahrens 6848fa9e4066Sahrens /* 6849fa9e4066Sahrens * Walk the list once, looking for datasets which match exactly, or 6850fa9e4066Sahrens * specify a dataset underneath an exported dataset. If found, return 6851fa9e4066Sahrens * true and note that it is writable. 6852fa9e4066Sahrens */ 6853fa9e4066Sahrens for (zd = list_head(&zone->zone_datasets); zd != NULL; 6854fa9e4066Sahrens zd = list_next(&zone->zone_datasets, zd)) { 6855fa9e4066Sahrens 6856fa9e4066Sahrens len = strlen(zd->zd_dataset); 6857fa9e4066Sahrens if (strlen(dataset) >= len && 6858fa9e4066Sahrens bcmp(dataset, zd->zd_dataset, len) == 0 && 685995c9592aSmaybee (dataset[len] == '\0' || dataset[len] == '/' || 686095c9592aSmaybee dataset[len] == '@')) { 6861fa9e4066Sahrens if (write) 6862fa9e4066Sahrens *write = 1; 6863fa9e4066Sahrens return (1); 6864fa9e4066Sahrens } 6865fa9e4066Sahrens } 6866fa9e4066Sahrens 6867fa9e4066Sahrens /* 6868fa9e4066Sahrens * Walk the list a second time, searching for datasets which are parents 6869fa9e4066Sahrens * of exported datasets. These should be visible, but read-only. 6870fa9e4066Sahrens * 6871fa9e4066Sahrens * Note that we also have to support forms such as 'pool/dataset/', with 6872fa9e4066Sahrens * a trailing slash. 6873fa9e4066Sahrens */ 6874fa9e4066Sahrens for (zd = list_head(&zone->zone_datasets); zd != NULL; 6875fa9e4066Sahrens zd = list_next(&zone->zone_datasets, zd)) { 6876fa9e4066Sahrens 6877fa9e4066Sahrens len = strlen(dataset); 6878fa9e4066Sahrens if (dataset[len - 1] == '/') 6879fa9e4066Sahrens len--; /* Ignore trailing slash */ 6880fa9e4066Sahrens if (len < strlen(zd->zd_dataset) && 6881fa9e4066Sahrens bcmp(dataset, zd->zd_dataset, len) == 0 && 6882fa9e4066Sahrens zd->zd_dataset[len] == '/') { 6883fa9e4066Sahrens if (write) 6884fa9e4066Sahrens *write = 0; 6885fa9e4066Sahrens return (1); 6886fa9e4066Sahrens } 6887fa9e4066Sahrens } 6888fa9e4066Sahrens 6889658a1dc7SSanjeev Bagewadi /* 6890658a1dc7SSanjeev Bagewadi * We reach here if the given dataset is not found in the zone_dataset 6891658a1dc7SSanjeev Bagewadi * list. Check if this dataset was added as a filesystem (ie. "add fs") 6892658a1dc7SSanjeev Bagewadi * instead of delegation. For this we search for the dataset in the 6893658a1dc7SSanjeev Bagewadi * zone_vfslist of this zone. If found, return true and note that it is 6894658a1dc7SSanjeev Bagewadi * not writable. 6895658a1dc7SSanjeev Bagewadi */ 6896658a1dc7SSanjeev Bagewadi 6897658a1dc7SSanjeev Bagewadi /* 6898658a1dc7SSanjeev Bagewadi * Initialize zfstype if it is not initialized yet. 6899658a1dc7SSanjeev Bagewadi */ 6900658a1dc7SSanjeev Bagewadi if (zfstype == -1) { 6901658a1dc7SSanjeev Bagewadi struct vfssw *vswp = vfs_getvfssw("zfs"); 6902658a1dc7SSanjeev Bagewadi zfstype = vswp - vfssw; 6903658a1dc7SSanjeev Bagewadi vfs_unrefvfssw(vswp); 6904658a1dc7SSanjeev Bagewadi } 6905658a1dc7SSanjeev Bagewadi 6906658a1dc7SSanjeev Bagewadi vfs_list_read_lock(); 6907658a1dc7SSanjeev Bagewadi vfsp = zone->zone_vfslist; 6908658a1dc7SSanjeev Bagewadi do { 6909658a1dc7SSanjeev Bagewadi ASSERT(vfsp); 6910658a1dc7SSanjeev Bagewadi if (vfsp->vfs_fstype == zfstype) { 6911658a1dc7SSanjeev Bagewadi name = refstr_value(vfsp->vfs_resource); 6912658a1dc7SSanjeev Bagewadi 6913658a1dc7SSanjeev Bagewadi /* 6914658a1dc7SSanjeev Bagewadi * Check if we have an exact match. 6915658a1dc7SSanjeev Bagewadi */ 6916658a1dc7SSanjeev Bagewadi if (strcmp(dataset, name) == 0) { 6917658a1dc7SSanjeev Bagewadi vfs_list_unlock(); 6918658a1dc7SSanjeev Bagewadi if (write) 6919658a1dc7SSanjeev Bagewadi *write = 0; 6920658a1dc7SSanjeev Bagewadi return (1); 6921658a1dc7SSanjeev Bagewadi } 6922658a1dc7SSanjeev Bagewadi /* 6923658a1dc7SSanjeev Bagewadi * We need to check if we are looking for parents of 6924658a1dc7SSanjeev Bagewadi * a dataset. These should be visible, but read-only. 6925658a1dc7SSanjeev Bagewadi */ 6926658a1dc7SSanjeev Bagewadi len = strlen(dataset); 6927658a1dc7SSanjeev Bagewadi if (dataset[len - 1] == '/') 6928658a1dc7SSanjeev Bagewadi len--; 6929658a1dc7SSanjeev Bagewadi 6930658a1dc7SSanjeev Bagewadi if (len < strlen(name) && 6931658a1dc7SSanjeev Bagewadi bcmp(dataset, name, len) == 0 && name[len] == '/') { 6932658a1dc7SSanjeev Bagewadi vfs_list_unlock(); 6933658a1dc7SSanjeev Bagewadi if (write) 6934658a1dc7SSanjeev Bagewadi *write = 0; 6935658a1dc7SSanjeev Bagewadi return (1); 6936658a1dc7SSanjeev Bagewadi } 6937658a1dc7SSanjeev Bagewadi } 6938658a1dc7SSanjeev Bagewadi vfsp = vfsp->vfs_zone_next; 6939658a1dc7SSanjeev Bagewadi } while (vfsp != zone->zone_vfslist); 6940658a1dc7SSanjeev Bagewadi 6941658a1dc7SSanjeev Bagewadi vfs_list_unlock(); 6942fa9e4066Sahrens return (0); 6943fa9e4066Sahrens } 694445916cd2Sjpk 694545916cd2Sjpk /* 694645916cd2Sjpk * zone_find_by_any_path() - 694745916cd2Sjpk * 694845916cd2Sjpk * kernel-private routine similar to zone_find_by_path(), but which 694945916cd2Sjpk * effectively compares against zone paths rather than zonerootpath 695045916cd2Sjpk * (i.e., the last component of zonerootpaths, which should be "root/", 695145916cd2Sjpk * are not compared.) This is done in order to accurately identify all 695245916cd2Sjpk * paths, whether zone-visible or not, including those which are parallel 695345916cd2Sjpk * to /root/, such as /dev/, /home/, etc... 695445916cd2Sjpk * 695545916cd2Sjpk * If the specified path does not fall under any zone path then global 695645916cd2Sjpk * zone is returned. 695745916cd2Sjpk * 695845916cd2Sjpk * The treat_abs parameter indicates whether the path should be treated as 695945916cd2Sjpk * an absolute path although it does not begin with "/". (This supports 696045916cd2Sjpk * nfs mount syntax such as host:any/path.) 696145916cd2Sjpk * 696245916cd2Sjpk * The caller is responsible for zone_rele of the returned zone. 696345916cd2Sjpk */ 696445916cd2Sjpk zone_t * 696545916cd2Sjpk zone_find_by_any_path(const char *path, boolean_t treat_abs) 696645916cd2Sjpk { 696745916cd2Sjpk zone_t *zone; 696845916cd2Sjpk int path_offset = 0; 696945916cd2Sjpk 697045916cd2Sjpk if (path == NULL) { 697145916cd2Sjpk zone_hold(global_zone); 697245916cd2Sjpk return (global_zone); 697345916cd2Sjpk } 697445916cd2Sjpk 697545916cd2Sjpk if (*path != '/') { 697645916cd2Sjpk ASSERT(treat_abs); 697745916cd2Sjpk path_offset = 1; 697845916cd2Sjpk } 697945916cd2Sjpk 698045916cd2Sjpk mutex_enter(&zonehash_lock); 698145916cd2Sjpk for (zone = list_head(&zone_active); zone != NULL; 698245916cd2Sjpk zone = list_next(&zone_active, zone)) { 698345916cd2Sjpk char *c; 698445916cd2Sjpk size_t pathlen; 69850f95d722Smp char *rootpath_start; 698645916cd2Sjpk 698745916cd2Sjpk if (zone == global_zone) /* skip global zone */ 698845916cd2Sjpk continue; 698945916cd2Sjpk 699045916cd2Sjpk /* scan backwards to find start of last component */ 699145916cd2Sjpk c = zone->zone_rootpath + zone->zone_rootpathlen - 2; 699245916cd2Sjpk do { 699345916cd2Sjpk c--; 699445916cd2Sjpk } while (*c != '/'); 699545916cd2Sjpk 69960f95d722Smp pathlen = c - zone->zone_rootpath + 1 - path_offset; 69970f95d722Smp rootpath_start = (zone->zone_rootpath + path_offset); 69980f95d722Smp if (strncmp(path, rootpath_start, pathlen) == 0) 699945916cd2Sjpk break; 700045916cd2Sjpk } 700145916cd2Sjpk if (zone == NULL) 700245916cd2Sjpk zone = global_zone; 700345916cd2Sjpk zone_hold(zone); 700445916cd2Sjpk mutex_exit(&zonehash_lock); 700545916cd2Sjpk return (zone); 700645916cd2Sjpk } 7007f4b3ec61Sdh 7008f4b3ec61Sdh /* 70092b24ab6bSSebastien Roy * Finds a zone_dl_t with the given linkid in the given zone. Returns the 70102b24ab6bSSebastien Roy * zone_dl_t pointer if found, and NULL otherwise. 7011f4b3ec61Sdh */ 70122b24ab6bSSebastien Roy static zone_dl_t * 70132b24ab6bSSebastien Roy zone_find_dl(zone_t *zone, datalink_id_t linkid) 7014f4b3ec61Sdh { 70152b24ab6bSSebastien Roy zone_dl_t *zdl; 7016f4b3ec61Sdh 70172b24ab6bSSebastien Roy ASSERT(mutex_owned(&zone->zone_lock)); 70182b24ab6bSSebastien Roy for (zdl = list_head(&zone->zone_dl_list); zdl != NULL; 70192b24ab6bSSebastien Roy zdl = list_next(&zone->zone_dl_list, zdl)) { 70202b24ab6bSSebastien Roy if (zdl->zdl_id == linkid) 7021f4b3ec61Sdh break; 7022f4b3ec61Sdh } 70232b24ab6bSSebastien Roy return (zdl); 70242b24ab6bSSebastien Roy } 70252b24ab6bSSebastien Roy 70262b24ab6bSSebastien Roy static boolean_t 70272b24ab6bSSebastien Roy zone_dl_exists(zone_t *zone, datalink_id_t linkid) 70282b24ab6bSSebastien Roy { 70292b24ab6bSSebastien Roy boolean_t exists; 70302b24ab6bSSebastien Roy 70312b24ab6bSSebastien Roy mutex_enter(&zone->zone_lock); 70322b24ab6bSSebastien Roy exists = (zone_find_dl(zone, linkid) != NULL); 7033f4b3ec61Sdh mutex_exit(&zone->zone_lock); 70342b24ab6bSSebastien Roy return (exists); 7035f4b3ec61Sdh } 7036f4b3ec61Sdh 7037f4b3ec61Sdh /* 70382b24ab6bSSebastien Roy * Add an data link name for the zone. 7039f4b3ec61Sdh */ 7040f4b3ec61Sdh static int 70412b24ab6bSSebastien Roy zone_add_datalink(zoneid_t zoneid, datalink_id_t linkid) 7042f4b3ec61Sdh { 70432b24ab6bSSebastien Roy zone_dl_t *zdl; 7044f4b3ec61Sdh zone_t *zone; 7045f4b3ec61Sdh zone_t *thiszone; 7046f4b3ec61Sdh 70472b24ab6bSSebastien Roy if ((thiszone = zone_find_by_id(zoneid)) == NULL) 7048f4b3ec61Sdh return (set_errno(ENXIO)); 7049f4b3ec61Sdh 70502b24ab6bSSebastien Roy /* Verify that the datalink ID doesn't already belong to a zone. */ 7051f4b3ec61Sdh mutex_enter(&zonehash_lock); 7052f4b3ec61Sdh for (zone = list_head(&zone_active); zone != NULL; 7053f4b3ec61Sdh zone = list_next(&zone_active, zone)) { 70542b24ab6bSSebastien Roy if (zone_dl_exists(zone, linkid)) { 7055f4b3ec61Sdh mutex_exit(&zonehash_lock); 7056f4b3ec61Sdh zone_rele(thiszone); 70572b24ab6bSSebastien Roy return (set_errno((zone == thiszone) ? EEXIST : EPERM)); 7058f4b3ec61Sdh } 7059f4b3ec61Sdh } 70602b24ab6bSSebastien Roy 70612b24ab6bSSebastien Roy zdl = kmem_zalloc(sizeof (*zdl), KM_SLEEP); 70622b24ab6bSSebastien Roy zdl->zdl_id = linkid; 7063550b6e40SSowmini Varadhan zdl->zdl_net = NULL; 7064f4b3ec61Sdh mutex_enter(&thiszone->zone_lock); 70652b24ab6bSSebastien Roy list_insert_head(&thiszone->zone_dl_list, zdl); 7066f4b3ec61Sdh mutex_exit(&thiszone->zone_lock); 7067f4b3ec61Sdh mutex_exit(&zonehash_lock); 7068f4b3ec61Sdh zone_rele(thiszone); 7069f4b3ec61Sdh return (0); 7070f4b3ec61Sdh } 7071f4b3ec61Sdh 7072f4b3ec61Sdh static int 70732b24ab6bSSebastien Roy zone_remove_datalink(zoneid_t zoneid, datalink_id_t linkid) 7074f4b3ec61Sdh { 70752b24ab6bSSebastien Roy zone_dl_t *zdl; 7076f4b3ec61Sdh zone_t *zone; 70772b24ab6bSSebastien Roy int err = 0; 7078f4b3ec61Sdh 70792b24ab6bSSebastien Roy if ((zone = zone_find_by_id(zoneid)) == NULL) 7080f4b3ec61Sdh return (set_errno(EINVAL)); 7081f4b3ec61Sdh 7082f4b3ec61Sdh mutex_enter(&zone->zone_lock); 70832b24ab6bSSebastien Roy if ((zdl = zone_find_dl(zone, linkid)) == NULL) { 70842b24ab6bSSebastien Roy err = ENXIO; 70852b24ab6bSSebastien Roy } else { 70862b24ab6bSSebastien Roy list_remove(&zone->zone_dl_list, zdl); 7087aab83bb8SJosef 'Jeff' Sipek nvlist_free(zdl->zdl_net); 70882b24ab6bSSebastien Roy kmem_free(zdl, sizeof (zone_dl_t)); 7089f4b3ec61Sdh } 7090f4b3ec61Sdh mutex_exit(&zone->zone_lock); 7091f4b3ec61Sdh zone_rele(zone); 70922b24ab6bSSebastien Roy return (err == 0 ? 0 : set_errno(err)); 7093f4b3ec61Sdh } 7094f4b3ec61Sdh 7095f4b3ec61Sdh /* 70962b24ab6bSSebastien Roy * Using the zoneidp as ALL_ZONES, we can lookup which zone has been assigned 70972b24ab6bSSebastien Roy * the linkid. Otherwise we just check if the specified zoneidp has been 70982b24ab6bSSebastien Roy * assigned the supplied linkid. 7099f4b3ec61Sdh */ 71002b24ab6bSSebastien Roy int 71012b24ab6bSSebastien Roy zone_check_datalink(zoneid_t *zoneidp, datalink_id_t linkid) 7102f4b3ec61Sdh { 7103f4b3ec61Sdh zone_t *zone; 71042b24ab6bSSebastien Roy int err = ENXIO; 7105f4b3ec61Sdh 71062b24ab6bSSebastien Roy if (*zoneidp != ALL_ZONES) { 71072b24ab6bSSebastien Roy if ((zone = zone_find_by_id(*zoneidp)) != NULL) { 71082b24ab6bSSebastien Roy if (zone_dl_exists(zone, linkid)) 71092b24ab6bSSebastien Roy err = 0; 71102b24ab6bSSebastien Roy zone_rele(zone); 71112b24ab6bSSebastien Roy } 71122b24ab6bSSebastien Roy return (err); 7113f4b3ec61Sdh } 7114f4b3ec61Sdh 7115f4b3ec61Sdh mutex_enter(&zonehash_lock); 7116f4b3ec61Sdh for (zone = list_head(&zone_active); zone != NULL; 7117f4b3ec61Sdh zone = list_next(&zone_active, zone)) { 71182b24ab6bSSebastien Roy if (zone_dl_exists(zone, linkid)) { 71192b24ab6bSSebastien Roy *zoneidp = zone->zone_id; 71202b24ab6bSSebastien Roy err = 0; 71212b24ab6bSSebastien Roy break; 7122f4b3ec61Sdh } 7123f4b3ec61Sdh } 7124f4b3ec61Sdh mutex_exit(&zonehash_lock); 71252b24ab6bSSebastien Roy return (err); 7126f4b3ec61Sdh } 7127f4b3ec61Sdh 7128f4b3ec61Sdh /* 71292b24ab6bSSebastien Roy * Get the list of datalink IDs assigned to a zone. 71302b24ab6bSSebastien Roy * 71312b24ab6bSSebastien Roy * On input, *nump is the number of datalink IDs that can fit in the supplied 71322b24ab6bSSebastien Roy * idarray. Upon return, *nump is either set to the number of datalink IDs 71332b24ab6bSSebastien Roy * that were placed in the array if the array was large enough, or to the 71342b24ab6bSSebastien Roy * number of datalink IDs that the function needs to place in the array if the 71352b24ab6bSSebastien Roy * array is too small. 7136f4b3ec61Sdh */ 7137f4b3ec61Sdh static int 71382b24ab6bSSebastien Roy zone_list_datalink(zoneid_t zoneid, int *nump, datalink_id_t *idarray) 7139f4b3ec61Sdh { 71402b24ab6bSSebastien Roy uint_t num, dlcount; 7141f4b3ec61Sdh zone_t *zone; 71422b24ab6bSSebastien Roy zone_dl_t *zdl; 71432b24ab6bSSebastien Roy datalink_id_t *idptr = idarray; 7144f4b3ec61Sdh 7145f4b3ec61Sdh if (copyin(nump, &dlcount, sizeof (dlcount)) != 0) 7146f4b3ec61Sdh return (set_errno(EFAULT)); 71472b24ab6bSSebastien Roy if ((zone = zone_find_by_id(zoneid)) == NULL) 7148f4b3ec61Sdh return (set_errno(ENXIO)); 7149f4b3ec61Sdh 7150f4b3ec61Sdh num = 0; 7151f4b3ec61Sdh mutex_enter(&zone->zone_lock); 71522b24ab6bSSebastien Roy for (zdl = list_head(&zone->zone_dl_list); zdl != NULL; 71532b24ab6bSSebastien Roy zdl = list_next(&zone->zone_dl_list, zdl)) { 7154f4b3ec61Sdh /* 71552b24ab6bSSebastien Roy * If the list is bigger than what the caller supplied, just 71562b24ab6bSSebastien Roy * count, don't do copyout. 7157f4b3ec61Sdh */ 7158f4b3ec61Sdh if (++num > dlcount) 7159f4b3ec61Sdh continue; 71602b24ab6bSSebastien Roy if (copyout(&zdl->zdl_id, idptr, sizeof (*idptr)) != 0) { 7161f4b3ec61Sdh mutex_exit(&zone->zone_lock); 7162f4b3ec61Sdh zone_rele(zone); 7163f4b3ec61Sdh return (set_errno(EFAULT)); 7164f4b3ec61Sdh } 71652b24ab6bSSebastien Roy idptr++; 7166f4b3ec61Sdh } 7167f4b3ec61Sdh mutex_exit(&zone->zone_lock); 7168f4b3ec61Sdh zone_rele(zone); 7169f4b3ec61Sdh 7170f4b3ec61Sdh /* Increased or decreased, caller should be notified. */ 7171f4b3ec61Sdh if (num != dlcount) { 71722b24ab6bSSebastien Roy if (copyout(&num, nump, sizeof (num)) != 0) 7173f4b3ec61Sdh return (set_errno(EFAULT)); 7174f4b3ec61Sdh } 7175f4b3ec61Sdh return (0); 7176f4b3ec61Sdh } 7177f4b3ec61Sdh 7178f4b3ec61Sdh /* 7179f4b3ec61Sdh * Public interface for looking up a zone by zoneid. It's a customized version 7180bd41d0a8Snordmark * for netstack_zone_create(). It can only be called from the zsd create 7181bd41d0a8Snordmark * callbacks, since it doesn't have reference on the zone structure hence if 7182bd41d0a8Snordmark * it is called elsewhere the zone could disappear after the zonehash_lock 7183bd41d0a8Snordmark * is dropped. 7184bd41d0a8Snordmark * 7185bd41d0a8Snordmark * Furthermore it 7186bd41d0a8Snordmark * 1. Doesn't check the status of the zone. 7187bd41d0a8Snordmark * 2. It will be called even before zone_init is called, in that case the 7188f4b3ec61Sdh * address of zone0 is returned directly, and netstack_zone_create() 7189f4b3ec61Sdh * will only assign a value to zone0.zone_netstack, won't break anything. 7190bd41d0a8Snordmark * 3. Returns without the zone being held. 7191f4b3ec61Sdh */ 7192f4b3ec61Sdh zone_t * 7193f4b3ec61Sdh zone_find_by_id_nolock(zoneid_t zoneid) 7194f4b3ec61Sdh { 7195bd41d0a8Snordmark zone_t *zone; 7196f4b3ec61Sdh 7197bd41d0a8Snordmark mutex_enter(&zonehash_lock); 7198f4b3ec61Sdh if (zonehashbyid == NULL) 7199bd41d0a8Snordmark zone = &zone0; 7200f4b3ec61Sdh else 7201bd41d0a8Snordmark zone = zone_find_all_by_id(zoneid); 7202bd41d0a8Snordmark mutex_exit(&zonehash_lock); 7203bd41d0a8Snordmark return (zone); 7204f4b3ec61Sdh } 7205d62bc4baSyz 7206d62bc4baSyz /* 7207d62bc4baSyz * Walk the datalinks for a given zone 7208d62bc4baSyz */ 7209d62bc4baSyz int 72102b24ab6bSSebastien Roy zone_datalink_walk(zoneid_t zoneid, int (*cb)(datalink_id_t, void *), 72112b24ab6bSSebastien Roy void *data) 7212d62bc4baSyz { 72132b24ab6bSSebastien Roy zone_t *zone; 72142b24ab6bSSebastien Roy zone_dl_t *zdl; 72152b24ab6bSSebastien Roy datalink_id_t *idarray; 72162b24ab6bSSebastien Roy uint_t idcount = 0; 72172b24ab6bSSebastien Roy int i, ret = 0; 7218d62bc4baSyz 7219d62bc4baSyz if ((zone = zone_find_by_id(zoneid)) == NULL) 7220d62bc4baSyz return (ENOENT); 7221d62bc4baSyz 72222b24ab6bSSebastien Roy /* 72232b24ab6bSSebastien Roy * We first build an array of linkid's so that we can walk these and 72242b24ab6bSSebastien Roy * execute the callback with the zone_lock dropped. 72252b24ab6bSSebastien Roy */ 7226d62bc4baSyz mutex_enter(&zone->zone_lock); 72272b24ab6bSSebastien Roy for (zdl = list_head(&zone->zone_dl_list); zdl != NULL; 72282b24ab6bSSebastien Roy zdl = list_next(&zone->zone_dl_list, zdl)) { 72292b24ab6bSSebastien Roy idcount++; 7230d62bc4baSyz } 72312b24ab6bSSebastien Roy 72322b24ab6bSSebastien Roy if (idcount == 0) { 72332b24ab6bSSebastien Roy mutex_exit(&zone->zone_lock); 72342b24ab6bSSebastien Roy zone_rele(zone); 72352b24ab6bSSebastien Roy return (0); 72362b24ab6bSSebastien Roy } 72372b24ab6bSSebastien Roy 72382b24ab6bSSebastien Roy idarray = kmem_alloc(sizeof (datalink_id_t) * idcount, KM_NOSLEEP); 72392b24ab6bSSebastien Roy if (idarray == NULL) { 72402b24ab6bSSebastien Roy mutex_exit(&zone->zone_lock); 72412b24ab6bSSebastien Roy zone_rele(zone); 72422b24ab6bSSebastien Roy return (ENOMEM); 72432b24ab6bSSebastien Roy } 72442b24ab6bSSebastien Roy 72452b24ab6bSSebastien Roy for (i = 0, zdl = list_head(&zone->zone_dl_list); zdl != NULL; 72462b24ab6bSSebastien Roy i++, zdl = list_next(&zone->zone_dl_list, zdl)) { 72472b24ab6bSSebastien Roy idarray[i] = zdl->zdl_id; 72482b24ab6bSSebastien Roy } 72492b24ab6bSSebastien Roy 7250d62bc4baSyz mutex_exit(&zone->zone_lock); 72512b24ab6bSSebastien Roy 72522b24ab6bSSebastien Roy for (i = 0; i < idcount && ret == 0; i++) { 72532b24ab6bSSebastien Roy if ((ret = (*cb)(idarray[i], data)) != 0) 72542b24ab6bSSebastien Roy break; 72552b24ab6bSSebastien Roy } 72562b24ab6bSSebastien Roy 7257d62bc4baSyz zone_rele(zone); 72582b24ab6bSSebastien Roy kmem_free(idarray, sizeof (datalink_id_t) * idcount); 7259d62bc4baSyz return (ret); 7260d62bc4baSyz } 7261550b6e40SSowmini Varadhan 7262550b6e40SSowmini Varadhan static char * 7263550b6e40SSowmini Varadhan zone_net_type2name(int type) 7264550b6e40SSowmini Varadhan { 7265550b6e40SSowmini Varadhan switch (type) { 7266550b6e40SSowmini Varadhan case ZONE_NETWORK_ADDRESS: 7267550b6e40SSowmini Varadhan return (ZONE_NET_ADDRNAME); 7268550b6e40SSowmini Varadhan case ZONE_NETWORK_DEFROUTER: 7269550b6e40SSowmini Varadhan return (ZONE_NET_RTRNAME); 7270550b6e40SSowmini Varadhan default: 7271550b6e40SSowmini Varadhan return (NULL); 7272550b6e40SSowmini Varadhan } 7273550b6e40SSowmini Varadhan } 7274550b6e40SSowmini Varadhan 7275550b6e40SSowmini Varadhan static int 7276550b6e40SSowmini Varadhan zone_set_network(zoneid_t zoneid, zone_net_data_t *znbuf) 7277550b6e40SSowmini Varadhan { 7278550b6e40SSowmini Varadhan zone_t *zone; 7279550b6e40SSowmini Varadhan zone_dl_t *zdl; 7280550b6e40SSowmini Varadhan nvlist_t *nvl; 7281550b6e40SSowmini Varadhan int err = 0; 7282550b6e40SSowmini Varadhan uint8_t *new = NULL; 7283550b6e40SSowmini Varadhan char *nvname; 7284550b6e40SSowmini Varadhan int bufsize; 7285550b6e40SSowmini Varadhan datalink_id_t linkid = znbuf->zn_linkid; 7286550b6e40SSowmini Varadhan 7287550b6e40SSowmini Varadhan if (secpolicy_zone_config(CRED()) != 0) 7288550b6e40SSowmini Varadhan return (set_errno(EPERM)); 7289550b6e40SSowmini Varadhan 7290550b6e40SSowmini Varadhan if (zoneid == GLOBAL_ZONEID) 7291550b6e40SSowmini Varadhan return (set_errno(EINVAL)); 7292550b6e40SSowmini Varadhan 7293550b6e40SSowmini Varadhan nvname = zone_net_type2name(znbuf->zn_type); 7294550b6e40SSowmini Varadhan bufsize = znbuf->zn_len; 7295550b6e40SSowmini Varadhan new = znbuf->zn_val; 7296550b6e40SSowmini Varadhan if (nvname == NULL) 7297550b6e40SSowmini Varadhan return (set_errno(EINVAL)); 7298550b6e40SSowmini Varadhan 7299550b6e40SSowmini Varadhan if ((zone = zone_find_by_id(zoneid)) == NULL) { 7300550b6e40SSowmini Varadhan return (set_errno(EINVAL)); 7301550b6e40SSowmini Varadhan } 7302550b6e40SSowmini Varadhan 7303550b6e40SSowmini Varadhan mutex_enter(&zone->zone_lock); 7304550b6e40SSowmini Varadhan if ((zdl = zone_find_dl(zone, linkid)) == NULL) { 7305550b6e40SSowmini Varadhan err = ENXIO; 7306550b6e40SSowmini Varadhan goto done; 7307550b6e40SSowmini Varadhan } 7308550b6e40SSowmini Varadhan if ((nvl = zdl->zdl_net) == NULL) { 7309550b6e40SSowmini Varadhan if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, KM_SLEEP)) { 7310550b6e40SSowmini Varadhan err = ENOMEM; 7311550b6e40SSowmini Varadhan goto done; 7312550b6e40SSowmini Varadhan } else { 7313550b6e40SSowmini Varadhan zdl->zdl_net = nvl; 7314550b6e40SSowmini Varadhan } 7315550b6e40SSowmini Varadhan } 7316550b6e40SSowmini Varadhan if (nvlist_exists(nvl, nvname)) { 7317550b6e40SSowmini Varadhan err = EINVAL; 7318550b6e40SSowmini Varadhan goto done; 7319550b6e40SSowmini Varadhan } 7320550b6e40SSowmini Varadhan err = nvlist_add_uint8_array(nvl, nvname, new, bufsize); 7321550b6e40SSowmini Varadhan ASSERT(err == 0); 7322550b6e40SSowmini Varadhan done: 7323550b6e40SSowmini Varadhan mutex_exit(&zone->zone_lock); 7324550b6e40SSowmini Varadhan zone_rele(zone); 7325550b6e40SSowmini Varadhan if (err != 0) 7326550b6e40SSowmini Varadhan return (set_errno(err)); 7327550b6e40SSowmini Varadhan else 7328550b6e40SSowmini Varadhan return (0); 7329550b6e40SSowmini Varadhan } 7330550b6e40SSowmini Varadhan 7331550b6e40SSowmini Varadhan static int 7332550b6e40SSowmini Varadhan zone_get_network(zoneid_t zoneid, zone_net_data_t *znbuf) 7333550b6e40SSowmini Varadhan { 7334550b6e40SSowmini Varadhan zone_t *zone; 7335550b6e40SSowmini Varadhan zone_dl_t *zdl; 7336550b6e40SSowmini Varadhan nvlist_t *nvl; 7337550b6e40SSowmini Varadhan uint8_t *ptr; 7338550b6e40SSowmini Varadhan uint_t psize; 7339550b6e40SSowmini Varadhan int err = 0; 7340550b6e40SSowmini Varadhan char *nvname; 7341550b6e40SSowmini Varadhan int bufsize; 7342550b6e40SSowmini Varadhan void *buf; 7343550b6e40SSowmini Varadhan datalink_id_t linkid = znbuf->zn_linkid; 7344550b6e40SSowmini Varadhan 7345550b6e40SSowmini Varadhan if (zoneid == GLOBAL_ZONEID) 7346550b6e40SSowmini Varadhan return (set_errno(EINVAL)); 7347550b6e40SSowmini Varadhan 7348550b6e40SSowmini Varadhan nvname = zone_net_type2name(znbuf->zn_type); 7349550b6e40SSowmini Varadhan bufsize = znbuf->zn_len; 7350550b6e40SSowmini Varadhan buf = znbuf->zn_val; 7351550b6e40SSowmini Varadhan 7352550b6e40SSowmini Varadhan if (nvname == NULL) 7353550b6e40SSowmini Varadhan return (set_errno(EINVAL)); 7354550b6e40SSowmini Varadhan if ((zone = zone_find_by_id(zoneid)) == NULL) 7355550b6e40SSowmini Varadhan return (set_errno(EINVAL)); 7356550b6e40SSowmini Varadhan 7357550b6e40SSowmini Varadhan mutex_enter(&zone->zone_lock); 7358550b6e40SSowmini Varadhan if ((zdl = zone_find_dl(zone, linkid)) == NULL) { 7359550b6e40SSowmini Varadhan err = ENXIO; 7360550b6e40SSowmini Varadhan goto done; 7361550b6e40SSowmini Varadhan } 7362550b6e40SSowmini Varadhan if ((nvl = zdl->zdl_net) == NULL || !nvlist_exists(nvl, nvname)) { 7363550b6e40SSowmini Varadhan err = ENOENT; 7364550b6e40SSowmini Varadhan goto done; 7365550b6e40SSowmini Varadhan } 7366550b6e40SSowmini Varadhan err = nvlist_lookup_uint8_array(nvl, nvname, &ptr, &psize); 7367550b6e40SSowmini Varadhan ASSERT(err == 0); 7368550b6e40SSowmini Varadhan 7369550b6e40SSowmini Varadhan if (psize > bufsize) { 7370550b6e40SSowmini Varadhan err = ENOBUFS; 7371550b6e40SSowmini Varadhan goto done; 7372550b6e40SSowmini Varadhan } 7373550b6e40SSowmini Varadhan znbuf->zn_len = psize; 7374550b6e40SSowmini Varadhan bcopy(ptr, buf, psize); 7375550b6e40SSowmini Varadhan done: 7376550b6e40SSowmini Varadhan mutex_exit(&zone->zone_lock); 7377550b6e40SSowmini Varadhan zone_rele(zone); 7378550b6e40SSowmini Varadhan if (err != 0) 7379550b6e40SSowmini Varadhan return (set_errno(err)); 7380550b6e40SSowmini Varadhan else 7381550b6e40SSowmini Varadhan return (0); 7382550b6e40SSowmini Varadhan } 7383