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 /* 23*134a1f4eSCasper H.S. Dik * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved. 247c478bd9Sstevel@tonic-gate */ 257c478bd9Sstevel@tonic-gate 267c478bd9Sstevel@tonic-gate /* 277c478bd9Sstevel@tonic-gate * Zones 287c478bd9Sstevel@tonic-gate * 297c478bd9Sstevel@tonic-gate * A zone is a named collection of processes, namespace constraints, 307c478bd9Sstevel@tonic-gate * and other system resources which comprise a secure and manageable 317c478bd9Sstevel@tonic-gate * application containment facility. 327c478bd9Sstevel@tonic-gate * 337c478bd9Sstevel@tonic-gate * Zones (represented by the reference counted zone_t) are tracked in 347c478bd9Sstevel@tonic-gate * the kernel in the zonehash. Elsewhere in the kernel, Zone IDs 357c478bd9Sstevel@tonic-gate * (zoneid_t) are used to track zone association. Zone IDs are 367c478bd9Sstevel@tonic-gate * dynamically generated when the zone is created; if a persistent 377c478bd9Sstevel@tonic-gate * identifier is needed (core files, accounting logs, audit trail, 387c478bd9Sstevel@tonic-gate * etc.), the zone name should be used. 397c478bd9Sstevel@tonic-gate * 407c478bd9Sstevel@tonic-gate * 417c478bd9Sstevel@tonic-gate * Global Zone: 427c478bd9Sstevel@tonic-gate * 437c478bd9Sstevel@tonic-gate * The global zone (zoneid 0) is automatically associated with all 447c478bd9Sstevel@tonic-gate * system resources that have not been bound to a user-created zone. 457c478bd9Sstevel@tonic-gate * This means that even systems where zones are not in active use 467c478bd9Sstevel@tonic-gate * have a global zone, and all processes, mounts, etc. are 477c478bd9Sstevel@tonic-gate * associated with that zone. The global zone is generally 487c478bd9Sstevel@tonic-gate * unconstrained in terms of privileges and access, though the usual 497c478bd9Sstevel@tonic-gate * credential and privilege based restrictions apply. 507c478bd9Sstevel@tonic-gate * 517c478bd9Sstevel@tonic-gate * 527c478bd9Sstevel@tonic-gate * Zone States: 537c478bd9Sstevel@tonic-gate * 547c478bd9Sstevel@tonic-gate * The states in which a zone may be in and the transitions are as 557c478bd9Sstevel@tonic-gate * follows: 567c478bd9Sstevel@tonic-gate * 577c478bd9Sstevel@tonic-gate * ZONE_IS_UNINITIALIZED: primordial state for a zone. The partially 587c478bd9Sstevel@tonic-gate * initialized zone is added to the list of active zones on the system but 597c478bd9Sstevel@tonic-gate * isn't accessible. 607c478bd9Sstevel@tonic-gate * 61bd41d0a8Snordmark * ZONE_IS_INITIALIZED: Initialization complete except the ZSD callbacks are 62bd41d0a8Snordmark * not yet completed. Not possible to enter the zone, but attributes can 63bd41d0a8Snordmark * be retrieved. 64bd41d0a8Snordmark * 657c478bd9Sstevel@tonic-gate * ZONE_IS_READY: zsched (the kernel dummy process for a zone) is 667c478bd9Sstevel@tonic-gate * ready. The zone is made visible after the ZSD constructor callbacks are 677c478bd9Sstevel@tonic-gate * executed. A zone remains in this state until it transitions into 687c478bd9Sstevel@tonic-gate * the ZONE_IS_BOOTING state as a result of a call to zone_boot(). 697c478bd9Sstevel@tonic-gate * 707c478bd9Sstevel@tonic-gate * ZONE_IS_BOOTING: in this shortlived-state, zsched attempts to start 717c478bd9Sstevel@tonic-gate * init. Should that fail, the zone proceeds to the ZONE_IS_SHUTTING_DOWN 727c478bd9Sstevel@tonic-gate * state. 737c478bd9Sstevel@tonic-gate * 747c478bd9Sstevel@tonic-gate * ZONE_IS_RUNNING: The zone is open for business: zsched has 757c478bd9Sstevel@tonic-gate * successfully started init. A zone remains in this state until 767c478bd9Sstevel@tonic-gate * zone_shutdown() is called. 777c478bd9Sstevel@tonic-gate * 787c478bd9Sstevel@tonic-gate * ZONE_IS_SHUTTING_DOWN: zone_shutdown() has been called, the system is 797c478bd9Sstevel@tonic-gate * killing all processes running in the zone. The zone remains 807c478bd9Sstevel@tonic-gate * in this state until there are no more user processes running in the zone. 817c478bd9Sstevel@tonic-gate * zone_create(), zone_enter(), and zone_destroy() on this zone will fail. 827c478bd9Sstevel@tonic-gate * Since zone_shutdown() is restartable, it may be called successfully 837c478bd9Sstevel@tonic-gate * multiple times for the same zone_t. Setting of the zone's state to 847c478bd9Sstevel@tonic-gate * ZONE_IS_SHUTTING_DOWN is synchronized with mounts, so VOP_MOUNT() may check 857c478bd9Sstevel@tonic-gate * the zone's status without worrying about it being a moving target. 867c478bd9Sstevel@tonic-gate * 877c478bd9Sstevel@tonic-gate * ZONE_IS_EMPTY: zone_shutdown() has been called, and there 887c478bd9Sstevel@tonic-gate * are no more user processes in the zone. The zone remains in this 897c478bd9Sstevel@tonic-gate * state until there are no more kernel threads associated with the 907c478bd9Sstevel@tonic-gate * zone. zone_create(), zone_enter(), and zone_destroy() on this zone will 917c478bd9Sstevel@tonic-gate * fail. 927c478bd9Sstevel@tonic-gate * 937c478bd9Sstevel@tonic-gate * ZONE_IS_DOWN: All kernel threads doing work on behalf of the zone 947c478bd9Sstevel@tonic-gate * have exited. zone_shutdown() returns. Henceforth it is not possible to 957c478bd9Sstevel@tonic-gate * join the zone or create kernel threads therein. 967c478bd9Sstevel@tonic-gate * 977c478bd9Sstevel@tonic-gate * ZONE_IS_DYING: zone_destroy() has been called on the zone; zone 987c478bd9Sstevel@tonic-gate * remains in this state until zsched exits. Calls to zone_find_by_*() 997c478bd9Sstevel@tonic-gate * return NULL from now on. 1007c478bd9Sstevel@tonic-gate * 1017c478bd9Sstevel@tonic-gate * ZONE_IS_DEAD: zsched has exited (zone_ntasks == 0). There are no 1027c478bd9Sstevel@tonic-gate * processes or threads doing work on behalf of the zone. The zone is 1037c478bd9Sstevel@tonic-gate * removed from the list of active zones. zone_destroy() returns, and 1047c478bd9Sstevel@tonic-gate * the zone can be recreated. 1057c478bd9Sstevel@tonic-gate * 1067c478bd9Sstevel@tonic-gate * ZONE_IS_FREE (internal state): zone_ref goes to 0, ZSD destructor 1077c478bd9Sstevel@tonic-gate * callbacks are executed, and all memory associated with the zone is 1087c478bd9Sstevel@tonic-gate * freed. 1097c478bd9Sstevel@tonic-gate * 1107c478bd9Sstevel@tonic-gate * Threads can wait for the zone to enter a requested state by using 1117c478bd9Sstevel@tonic-gate * zone_status_wait() or zone_status_timedwait() with the desired 1127c478bd9Sstevel@tonic-gate * state passed in as an argument. Zone state transitions are 1137c478bd9Sstevel@tonic-gate * uni-directional; it is not possible to move back to an earlier state. 1147c478bd9Sstevel@tonic-gate * 1157c478bd9Sstevel@tonic-gate * 1167c478bd9Sstevel@tonic-gate * Zone-Specific Data: 1177c478bd9Sstevel@tonic-gate * 1187c478bd9Sstevel@tonic-gate * Subsystems needing to maintain zone-specific data can store that 1197c478bd9Sstevel@tonic-gate * data using the ZSD mechanism. This provides a zone-specific data 1207c478bd9Sstevel@tonic-gate * store, similar to thread-specific data (see pthread_getspecific(3C) 1217c478bd9Sstevel@tonic-gate * or the TSD code in uts/common/disp/thread.c. Also, ZSD can be used 1227c478bd9Sstevel@tonic-gate * to register callbacks to be invoked when a zone is created, shut 1237c478bd9Sstevel@tonic-gate * down, or destroyed. This can be used to initialize zone-specific 1247c478bd9Sstevel@tonic-gate * data for new zones and to clean up when zones go away. 1257c478bd9Sstevel@tonic-gate * 1267c478bd9Sstevel@tonic-gate * 1277c478bd9Sstevel@tonic-gate * Data Structures: 1287c478bd9Sstevel@tonic-gate * 1297c478bd9Sstevel@tonic-gate * The per-zone structure (zone_t) is reference counted, and freed 1307c478bd9Sstevel@tonic-gate * when all references are released. zone_hold and zone_rele can be 1317c478bd9Sstevel@tonic-gate * used to adjust the reference count. In addition, reference counts 1327c478bd9Sstevel@tonic-gate * associated with the cred_t structure are tracked separately using 1337c478bd9Sstevel@tonic-gate * zone_cred_hold and zone_cred_rele. 1347c478bd9Sstevel@tonic-gate * 1357c478bd9Sstevel@tonic-gate * Pointers to active zone_t's are stored in two hash tables; one 1367c478bd9Sstevel@tonic-gate * for searching by id, the other for searching by name. Lookups 1377c478bd9Sstevel@tonic-gate * can be performed on either basis, using zone_find_by_id and 1387c478bd9Sstevel@tonic-gate * zone_find_by_name. Both return zone_t pointers with the zone 1397c478bd9Sstevel@tonic-gate * held, so zone_rele should be called when the pointer is no longer 1407c478bd9Sstevel@tonic-gate * needed. Zones can also be searched by path; zone_find_by_path 1417c478bd9Sstevel@tonic-gate * returns the zone with which a path name is associated (global 1427c478bd9Sstevel@tonic-gate * zone if the path is not within some other zone's file system 1437c478bd9Sstevel@tonic-gate * hierarchy). This currently requires iterating through each zone, 1447c478bd9Sstevel@tonic-gate * so it is slower than an id or name search via a hash table. 1457c478bd9Sstevel@tonic-gate * 1467c478bd9Sstevel@tonic-gate * 1477c478bd9Sstevel@tonic-gate * Locking: 1487c478bd9Sstevel@tonic-gate * 1497c478bd9Sstevel@tonic-gate * zonehash_lock: This is a top-level global lock used to protect the 1507c478bd9Sstevel@tonic-gate * zone hash tables and lists. Zones cannot be created or destroyed 1517c478bd9Sstevel@tonic-gate * while this lock is held. 1527c478bd9Sstevel@tonic-gate * zone_status_lock: This is a global lock protecting zone state. 1537c478bd9Sstevel@tonic-gate * Zones cannot change state while this lock is held. It also 1547c478bd9Sstevel@tonic-gate * protects the list of kernel threads associated with a zone. 1557c478bd9Sstevel@tonic-gate * zone_lock: This is a per-zone lock used to protect several fields of 1567c478bd9Sstevel@tonic-gate * the zone_t (see <sys/zone.h> for details). In addition, holding 1577c478bd9Sstevel@tonic-gate * this lock means that the zone cannot go away. 1580209230bSgjelinek * zone_nlwps_lock: This is a per-zone lock used to protect the fields 1590209230bSgjelinek * related to the zone.max-lwps rctl. 1600209230bSgjelinek * zone_mem_lock: This is a per-zone lock used to protect the fields 1610209230bSgjelinek * related to the zone.max-locked-memory and zone.max-swap rctls. 1627c478bd9Sstevel@tonic-gate * zsd_key_lock: This is a global lock protecting the key state for ZSD. 1637c478bd9Sstevel@tonic-gate * zone_deathrow_lock: This is a global lock protecting the "deathrow" 1647c478bd9Sstevel@tonic-gate * list (a list of zones in the ZONE_IS_DEAD state). 1657c478bd9Sstevel@tonic-gate * 1667c478bd9Sstevel@tonic-gate * Ordering requirements: 1677c478bd9Sstevel@tonic-gate * pool_lock --> cpu_lock --> zonehash_lock --> zone_status_lock --> 1687c478bd9Sstevel@tonic-gate * zone_lock --> zsd_key_lock --> pidlock --> p_lock 1697c478bd9Sstevel@tonic-gate * 1700209230bSgjelinek * When taking zone_mem_lock or zone_nlwps_lock, the lock ordering is: 1710209230bSgjelinek * zonehash_lock --> a_lock --> pidlock --> p_lock --> zone_mem_lock 1720209230bSgjelinek * zonehash_lock --> a_lock --> pidlock --> p_lock --> zone_mem_lock 1730209230bSgjelinek * 1747c478bd9Sstevel@tonic-gate * Blocking memory allocations are permitted while holding any of the 1757c478bd9Sstevel@tonic-gate * zone locks. 1767c478bd9Sstevel@tonic-gate * 1777c478bd9Sstevel@tonic-gate * 1787c478bd9Sstevel@tonic-gate * System Call Interface: 1797c478bd9Sstevel@tonic-gate * 1807c478bd9Sstevel@tonic-gate * The zone subsystem can be managed and queried from user level with 1817c478bd9Sstevel@tonic-gate * the following system calls (all subcodes of the primary "zone" 1827c478bd9Sstevel@tonic-gate * system call): 1837c478bd9Sstevel@tonic-gate * - zone_create: creates a zone with selected attributes (name, 184fa9e4066Sahrens * root path, privileges, resource controls, ZFS datasets) 1857c478bd9Sstevel@tonic-gate * - zone_enter: allows the current process to enter a zone 1867c478bd9Sstevel@tonic-gate * - zone_getattr: reports attributes of a zone 1873f2f09c1Sdp * - zone_setattr: set attributes of a zone 1883f2f09c1Sdp * - zone_boot: set 'init' running for the zone 1897c478bd9Sstevel@tonic-gate * - zone_list: lists all zones active in the system 1907c478bd9Sstevel@tonic-gate * - zone_lookup: looks up zone id based on name 1917c478bd9Sstevel@tonic-gate * - zone_shutdown: initiates shutdown process (see states above) 1927c478bd9Sstevel@tonic-gate * - zone_destroy: completes shutdown process (see states above) 1937c478bd9Sstevel@tonic-gate * 1947c478bd9Sstevel@tonic-gate */ 1957c478bd9Sstevel@tonic-gate 1967c478bd9Sstevel@tonic-gate #include <sys/priv_impl.h> 1977c478bd9Sstevel@tonic-gate #include <sys/cred.h> 1987c478bd9Sstevel@tonic-gate #include <c2/audit.h> 1997c478bd9Sstevel@tonic-gate #include <sys/debug.h> 2007c478bd9Sstevel@tonic-gate #include <sys/file.h> 2017c478bd9Sstevel@tonic-gate #include <sys/kmem.h> 2020209230bSgjelinek #include <sys/kstat.h> 2037c478bd9Sstevel@tonic-gate #include <sys/mutex.h> 20445916cd2Sjpk #include <sys/note.h> 2057c478bd9Sstevel@tonic-gate #include <sys/pathname.h> 2067c478bd9Sstevel@tonic-gate #include <sys/proc.h> 2077c478bd9Sstevel@tonic-gate #include <sys/project.h> 208cf8f45c7Sdstaff #include <sys/sysevent.h> 2097c478bd9Sstevel@tonic-gate #include <sys/task.h> 2107c478bd9Sstevel@tonic-gate #include <sys/systm.h> 2117c478bd9Sstevel@tonic-gate #include <sys/types.h> 2127c478bd9Sstevel@tonic-gate #include <sys/utsname.h> 2137c478bd9Sstevel@tonic-gate #include <sys/vnode.h> 2147c478bd9Sstevel@tonic-gate #include <sys/vfs.h> 2157c478bd9Sstevel@tonic-gate #include <sys/systeminfo.h> 2167c478bd9Sstevel@tonic-gate #include <sys/policy.h> 2177c478bd9Sstevel@tonic-gate #include <sys/cred_impl.h> 2187c478bd9Sstevel@tonic-gate #include <sys/contract_impl.h> 2197c478bd9Sstevel@tonic-gate #include <sys/contract/process_impl.h> 2207c478bd9Sstevel@tonic-gate #include <sys/class.h> 2217c478bd9Sstevel@tonic-gate #include <sys/pool.h> 2227c478bd9Sstevel@tonic-gate #include <sys/pool_pset.h> 2237c478bd9Sstevel@tonic-gate #include <sys/pset.h> 2247c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h> 2257c478bd9Sstevel@tonic-gate #include <sys/callb.h> 2267c478bd9Sstevel@tonic-gate #include <sys/vmparam.h> 2277c478bd9Sstevel@tonic-gate #include <sys/corectl.h> 228824c205fSml #include <sys/ipc_impl.h> 229*134a1f4eSCasper H.S. Dik #include <sys/klpd.h> 2307c478bd9Sstevel@tonic-gate 2317c478bd9Sstevel@tonic-gate #include <sys/door.h> 2327c478bd9Sstevel@tonic-gate #include <sys/cpuvar.h> 233bd41d0a8Snordmark #include <sys/sdt.h> 2347c478bd9Sstevel@tonic-gate 2357c478bd9Sstevel@tonic-gate #include <sys/uadmin.h> 2367c478bd9Sstevel@tonic-gate #include <sys/session.h> 2377c478bd9Sstevel@tonic-gate #include <sys/cmn_err.h> 2387c478bd9Sstevel@tonic-gate #include <sys/modhash.h> 2393f2f09c1Sdp #include <sys/sunddi.h> 2407c478bd9Sstevel@tonic-gate #include <sys/nvpair.h> 2417c478bd9Sstevel@tonic-gate #include <sys/rctl.h> 2427c478bd9Sstevel@tonic-gate #include <sys/fss.h> 2439acbbeafSnn #include <sys/brand.h> 2447c478bd9Sstevel@tonic-gate #include <sys/zone.h> 245f4b3ec61Sdh #include <net/if.h> 246c97ad5cdSakolb #include <sys/cpucaps.h> 2470209230bSgjelinek #include <vm/seg.h> 2482b24ab6bSSebastien Roy #include <sys/mac.h> 2492b24ab6bSSebastien Roy 2502b24ab6bSSebastien Roy /* List of data link IDs which are accessible from the zone */ 2512b24ab6bSSebastien Roy typedef struct zone_dl { 2522b24ab6bSSebastien Roy datalink_id_t zdl_id; 2532b24ab6bSSebastien Roy list_node_t zdl_linkage; 2542b24ab6bSSebastien Roy } zone_dl_t; 2550209230bSgjelinek 2567c478bd9Sstevel@tonic-gate /* 2577c478bd9Sstevel@tonic-gate * cv used to signal that all references to the zone have been released. This 2587c478bd9Sstevel@tonic-gate * needs to be global since there may be multiple waiters, and the first to 2597c478bd9Sstevel@tonic-gate * wake up will free the zone_t, hence we cannot use zone->zone_cv. 2607c478bd9Sstevel@tonic-gate */ 2617c478bd9Sstevel@tonic-gate static kcondvar_t zone_destroy_cv; 2627c478bd9Sstevel@tonic-gate /* 2637c478bd9Sstevel@tonic-gate * Lock used to serialize access to zone_cv. This could have been per-zone, 2647c478bd9Sstevel@tonic-gate * but then we'd need another lock for zone_destroy_cv, and why bother? 2657c478bd9Sstevel@tonic-gate */ 2667c478bd9Sstevel@tonic-gate static kmutex_t zone_status_lock; 2677c478bd9Sstevel@tonic-gate 2687c478bd9Sstevel@tonic-gate /* 2697c478bd9Sstevel@tonic-gate * ZSD-related global variables. 2707c478bd9Sstevel@tonic-gate */ 2717c478bd9Sstevel@tonic-gate static kmutex_t zsd_key_lock; /* protects the following two */ 2727c478bd9Sstevel@tonic-gate /* 2737c478bd9Sstevel@tonic-gate * The next caller of zone_key_create() will be assigned a key of ++zsd_keyval. 2747c478bd9Sstevel@tonic-gate */ 2757c478bd9Sstevel@tonic-gate static zone_key_t zsd_keyval = 0; 2767c478bd9Sstevel@tonic-gate /* 2777c478bd9Sstevel@tonic-gate * Global list of registered keys. We use this when a new zone is created. 2787c478bd9Sstevel@tonic-gate */ 2797c478bd9Sstevel@tonic-gate static list_t zsd_registered_keys; 2807c478bd9Sstevel@tonic-gate 2817c478bd9Sstevel@tonic-gate int zone_hash_size = 256; 28245916cd2Sjpk static mod_hash_t *zonehashbyname, *zonehashbyid, *zonehashbylabel; 2837c478bd9Sstevel@tonic-gate static kmutex_t zonehash_lock; 2847c478bd9Sstevel@tonic-gate static uint_t zonecount; 2857c478bd9Sstevel@tonic-gate static id_space_t *zoneid_space; 2867c478bd9Sstevel@tonic-gate 2877c478bd9Sstevel@tonic-gate /* 2887c478bd9Sstevel@tonic-gate * The global zone (aka zone0) is the all-seeing, all-knowing zone in which the 2897c478bd9Sstevel@tonic-gate * kernel proper runs, and which manages all other zones. 2907c478bd9Sstevel@tonic-gate * 2917c478bd9Sstevel@tonic-gate * Although not declared as static, the variable "zone0" should not be used 2927c478bd9Sstevel@tonic-gate * except for by code that needs to reference the global zone early on in boot, 2937c478bd9Sstevel@tonic-gate * before it is fully initialized. All other consumers should use 2947c478bd9Sstevel@tonic-gate * 'global_zone'. 2957c478bd9Sstevel@tonic-gate */ 2967c478bd9Sstevel@tonic-gate zone_t zone0; 2977c478bd9Sstevel@tonic-gate zone_t *global_zone = NULL; /* Set when the global zone is initialized */ 2987c478bd9Sstevel@tonic-gate 2997c478bd9Sstevel@tonic-gate /* 3007c478bd9Sstevel@tonic-gate * List of active zones, protected by zonehash_lock. 3017c478bd9Sstevel@tonic-gate */ 3027c478bd9Sstevel@tonic-gate static list_t zone_active; 3037c478bd9Sstevel@tonic-gate 3047c478bd9Sstevel@tonic-gate /* 3057c478bd9Sstevel@tonic-gate * List of destroyed zones that still have outstanding cred references. 3067c478bd9Sstevel@tonic-gate * Used for debugging. Uses a separate lock to avoid lock ordering 3077c478bd9Sstevel@tonic-gate * problems in zone_free. 3087c478bd9Sstevel@tonic-gate */ 3097c478bd9Sstevel@tonic-gate static list_t zone_deathrow; 3107c478bd9Sstevel@tonic-gate static kmutex_t zone_deathrow_lock; 3117c478bd9Sstevel@tonic-gate 3127c478bd9Sstevel@tonic-gate /* number of zones is limited by virtual interface limit in IP */ 3137c478bd9Sstevel@tonic-gate uint_t maxzones = 8192; 3147c478bd9Sstevel@tonic-gate 315cf8f45c7Sdstaff /* Event channel to sent zone state change notifications */ 316cf8f45c7Sdstaff evchan_t *zone_event_chan; 317cf8f45c7Sdstaff 318cf8f45c7Sdstaff /* 319cf8f45c7Sdstaff * This table holds the mapping from kernel zone states to 320cf8f45c7Sdstaff * states visible in the state notification API. 321cf8f45c7Sdstaff * The idea is that we only expose "obvious" states and 322cf8f45c7Sdstaff * do not expose states which are just implementation details. 323cf8f45c7Sdstaff */ 324cf8f45c7Sdstaff const char *zone_status_table[] = { 325cf8f45c7Sdstaff ZONE_EVENT_UNINITIALIZED, /* uninitialized */ 326bd41d0a8Snordmark ZONE_EVENT_INITIALIZED, /* initialized */ 327cf8f45c7Sdstaff ZONE_EVENT_READY, /* ready */ 328cf8f45c7Sdstaff ZONE_EVENT_READY, /* booting */ 329cf8f45c7Sdstaff ZONE_EVENT_RUNNING, /* running */ 330cf8f45c7Sdstaff ZONE_EVENT_SHUTTING_DOWN, /* shutting_down */ 331cf8f45c7Sdstaff ZONE_EVENT_SHUTTING_DOWN, /* empty */ 332cf8f45c7Sdstaff ZONE_EVENT_SHUTTING_DOWN, /* down */ 333cf8f45c7Sdstaff ZONE_EVENT_SHUTTING_DOWN, /* dying */ 334cf8f45c7Sdstaff ZONE_EVENT_UNINITIALIZED, /* dead */ 335cf8f45c7Sdstaff }; 336cf8f45c7Sdstaff 3377c478bd9Sstevel@tonic-gate /* 3387c478bd9Sstevel@tonic-gate * This isn't static so lint doesn't complain. 3397c478bd9Sstevel@tonic-gate */ 3407c478bd9Sstevel@tonic-gate rctl_hndl_t rc_zone_cpu_shares; 341c6939658Ssl rctl_hndl_t rc_zone_locked_mem; 3420209230bSgjelinek rctl_hndl_t rc_zone_max_swap; 343c97ad5cdSakolb rctl_hndl_t rc_zone_cpu_cap; 3447c478bd9Sstevel@tonic-gate rctl_hndl_t rc_zone_nlwps; 345824c205fSml rctl_hndl_t rc_zone_shmmax; 346824c205fSml rctl_hndl_t rc_zone_shmmni; 347824c205fSml rctl_hndl_t rc_zone_semmni; 348824c205fSml rctl_hndl_t rc_zone_msgmni; 3497c478bd9Sstevel@tonic-gate /* 3507c478bd9Sstevel@tonic-gate * Synchronization primitives used to synchronize between mounts and zone 3517c478bd9Sstevel@tonic-gate * creation/destruction. 3527c478bd9Sstevel@tonic-gate */ 3537c478bd9Sstevel@tonic-gate static int mounts_in_progress; 3547c478bd9Sstevel@tonic-gate static kcondvar_t mount_cv; 3557c478bd9Sstevel@tonic-gate static kmutex_t mount_lock; 3567c478bd9Sstevel@tonic-gate 3573f2f09c1Sdp const char * const zone_default_initname = "/sbin/init"; 35845916cd2Sjpk static char * const zone_prefix = "/zone/"; 3597c478bd9Sstevel@tonic-gate static int zone_shutdown(zoneid_t zoneid); 3602b24ab6bSSebastien Roy static int zone_add_datalink(zoneid_t, datalink_id_t); 3612b24ab6bSSebastien Roy static int zone_remove_datalink(zoneid_t, datalink_id_t); 3622b24ab6bSSebastien Roy static int zone_list_datalink(zoneid_t, int *, datalink_id_t *); 3637c478bd9Sstevel@tonic-gate 364bd41d0a8Snordmark typedef boolean_t zsd_applyfn_t(kmutex_t *, boolean_t, zone_t *, zone_key_t); 365bd41d0a8Snordmark 366bd41d0a8Snordmark static void zsd_apply_all_zones(zsd_applyfn_t *, zone_key_t); 367bd41d0a8Snordmark static void zsd_apply_all_keys(zsd_applyfn_t *, zone_t *); 368bd41d0a8Snordmark static boolean_t zsd_apply_create(kmutex_t *, boolean_t, zone_t *, zone_key_t); 369bd41d0a8Snordmark static boolean_t zsd_apply_shutdown(kmutex_t *, boolean_t, zone_t *, 370bd41d0a8Snordmark zone_key_t); 371bd41d0a8Snordmark static boolean_t zsd_apply_destroy(kmutex_t *, boolean_t, zone_t *, zone_key_t); 372bd41d0a8Snordmark static boolean_t zsd_wait_for_creator(zone_t *, struct zsd_entry *, 373bd41d0a8Snordmark kmutex_t *); 374bd41d0a8Snordmark static boolean_t zsd_wait_for_inprogress(zone_t *, struct zsd_entry *, 375bd41d0a8Snordmark kmutex_t *); 376bd41d0a8Snordmark 377821c4a97Sdp /* 378821c4a97Sdp * Bump this number when you alter the zone syscall interfaces; this is 379821c4a97Sdp * because we need to have support for previous API versions in libc 380821c4a97Sdp * to support patching; libc calls into the kernel to determine this number. 381821c4a97Sdp * 382821c4a97Sdp * Version 1 of the API is the version originally shipped with Solaris 10 383821c4a97Sdp * Version 2 alters the zone_create system call in order to support more 384821c4a97Sdp * arguments by moving the args into a structure; and to do better 385821c4a97Sdp * error reporting when zone_create() fails. 386821c4a97Sdp * Version 3 alters the zone_create system call in order to support the 387821c4a97Sdp * import of ZFS datasets to zones. 38845916cd2Sjpk * Version 4 alters the zone_create system call in order to support 38945916cd2Sjpk * Trusted Extensions. 3903f2f09c1Sdp * Version 5 alters the zone_boot system call, and converts its old 3913f2f09c1Sdp * bootargs parameter to be set by the zone_setattr API instead. 392f4b3ec61Sdh * Version 6 adds the flag argument to zone_create. 393821c4a97Sdp */ 394f4b3ec61Sdh static const int ZONE_SYSCALL_API_VERSION = 6; 395821c4a97Sdp 3967c478bd9Sstevel@tonic-gate /* 3977c478bd9Sstevel@tonic-gate * Certain filesystems (such as NFS and autofs) need to know which zone 3987c478bd9Sstevel@tonic-gate * the mount is being placed in. Because of this, we need to be able to 3997c478bd9Sstevel@tonic-gate * ensure that a zone isn't in the process of being created such that 4007c478bd9Sstevel@tonic-gate * nfs_mount() thinks it is in the global zone, while by the time it 4017c478bd9Sstevel@tonic-gate * gets added the list of mounted zones, it ends up on zoneA's mount 4027c478bd9Sstevel@tonic-gate * list. 4037c478bd9Sstevel@tonic-gate * 4047c478bd9Sstevel@tonic-gate * The following functions: block_mounts()/resume_mounts() and 4057c478bd9Sstevel@tonic-gate * mount_in_progress()/mount_completed() are used by zones and the VFS 4067c478bd9Sstevel@tonic-gate * layer (respectively) to synchronize zone creation and new mounts. 4077c478bd9Sstevel@tonic-gate * 4087c478bd9Sstevel@tonic-gate * The semantics are like a reader-reader lock such that there may 4097c478bd9Sstevel@tonic-gate * either be multiple mounts (or zone creations, if that weren't 4107c478bd9Sstevel@tonic-gate * serialized by zonehash_lock) in progress at the same time, but not 4117c478bd9Sstevel@tonic-gate * both. 4127c478bd9Sstevel@tonic-gate * 4137c478bd9Sstevel@tonic-gate * We use cv's so the user can ctrl-C out of the operation if it's 4147c478bd9Sstevel@tonic-gate * taking too long. 4157c478bd9Sstevel@tonic-gate * 4167c478bd9Sstevel@tonic-gate * The semantics are such that there is unfair bias towards the 4177c478bd9Sstevel@tonic-gate * "current" operation. This means that zone creations may starve if 4187c478bd9Sstevel@tonic-gate * there is a rapid succession of new mounts coming in to the system, or 4197c478bd9Sstevel@tonic-gate * there is a remote possibility that zones will be created at such a 4207c478bd9Sstevel@tonic-gate * rate that new mounts will not be able to proceed. 4217c478bd9Sstevel@tonic-gate */ 4227c478bd9Sstevel@tonic-gate /* 4237c478bd9Sstevel@tonic-gate * Prevent new mounts from progressing to the point of calling 4247c478bd9Sstevel@tonic-gate * VFS_MOUNT(). If there are already mounts in this "region", wait for 4257c478bd9Sstevel@tonic-gate * them to complete. 4267c478bd9Sstevel@tonic-gate */ 4277c478bd9Sstevel@tonic-gate static int 4287c478bd9Sstevel@tonic-gate block_mounts(void) 4297c478bd9Sstevel@tonic-gate { 4307c478bd9Sstevel@tonic-gate int retval = 0; 4317c478bd9Sstevel@tonic-gate 4327c478bd9Sstevel@tonic-gate /* 4337c478bd9Sstevel@tonic-gate * Since it may block for a long time, block_mounts() shouldn't be 4347c478bd9Sstevel@tonic-gate * called with zonehash_lock held. 4357c478bd9Sstevel@tonic-gate */ 4367c478bd9Sstevel@tonic-gate ASSERT(MUTEX_NOT_HELD(&zonehash_lock)); 4377c478bd9Sstevel@tonic-gate mutex_enter(&mount_lock); 4387c478bd9Sstevel@tonic-gate while (mounts_in_progress > 0) { 4397c478bd9Sstevel@tonic-gate if (cv_wait_sig(&mount_cv, &mount_lock) == 0) 4407c478bd9Sstevel@tonic-gate goto signaled; 4417c478bd9Sstevel@tonic-gate } 4427c478bd9Sstevel@tonic-gate /* 4437c478bd9Sstevel@tonic-gate * A negative value of mounts_in_progress indicates that mounts 4447c478bd9Sstevel@tonic-gate * have been blocked by (-mounts_in_progress) different callers. 4457c478bd9Sstevel@tonic-gate */ 4467c478bd9Sstevel@tonic-gate mounts_in_progress--; 4477c478bd9Sstevel@tonic-gate retval = 1; 4487c478bd9Sstevel@tonic-gate signaled: 4497c478bd9Sstevel@tonic-gate mutex_exit(&mount_lock); 4507c478bd9Sstevel@tonic-gate return (retval); 4517c478bd9Sstevel@tonic-gate } 4527c478bd9Sstevel@tonic-gate 4537c478bd9Sstevel@tonic-gate /* 4547c478bd9Sstevel@tonic-gate * The VFS layer may progress with new mounts as far as we're concerned. 4557c478bd9Sstevel@tonic-gate * Allow them to progress if we were the last obstacle. 4567c478bd9Sstevel@tonic-gate */ 4577c478bd9Sstevel@tonic-gate static void 4587c478bd9Sstevel@tonic-gate resume_mounts(void) 4597c478bd9Sstevel@tonic-gate { 4607c478bd9Sstevel@tonic-gate mutex_enter(&mount_lock); 4617c478bd9Sstevel@tonic-gate if (++mounts_in_progress == 0) 4627c478bd9Sstevel@tonic-gate cv_broadcast(&mount_cv); 4637c478bd9Sstevel@tonic-gate mutex_exit(&mount_lock); 4647c478bd9Sstevel@tonic-gate } 4657c478bd9Sstevel@tonic-gate 4667c478bd9Sstevel@tonic-gate /* 4677c478bd9Sstevel@tonic-gate * The VFS layer is busy with a mount; zones should wait until all 4687c478bd9Sstevel@tonic-gate * mounts are completed to progress. 4697c478bd9Sstevel@tonic-gate */ 4707c478bd9Sstevel@tonic-gate void 4717c478bd9Sstevel@tonic-gate mount_in_progress(void) 4727c478bd9Sstevel@tonic-gate { 4737c478bd9Sstevel@tonic-gate mutex_enter(&mount_lock); 4747c478bd9Sstevel@tonic-gate while (mounts_in_progress < 0) 4757c478bd9Sstevel@tonic-gate cv_wait(&mount_cv, &mount_lock); 4767c478bd9Sstevel@tonic-gate mounts_in_progress++; 4777c478bd9Sstevel@tonic-gate mutex_exit(&mount_lock); 4787c478bd9Sstevel@tonic-gate } 4797c478bd9Sstevel@tonic-gate 4807c478bd9Sstevel@tonic-gate /* 4817c478bd9Sstevel@tonic-gate * VFS is done with one mount; wake up any waiting block_mounts() 4827c478bd9Sstevel@tonic-gate * callers if this is the last mount. 4837c478bd9Sstevel@tonic-gate */ 4847c478bd9Sstevel@tonic-gate void 4857c478bd9Sstevel@tonic-gate mount_completed(void) 4867c478bd9Sstevel@tonic-gate { 4877c478bd9Sstevel@tonic-gate mutex_enter(&mount_lock); 4887c478bd9Sstevel@tonic-gate if (--mounts_in_progress == 0) 4897c478bd9Sstevel@tonic-gate cv_broadcast(&mount_cv); 4907c478bd9Sstevel@tonic-gate mutex_exit(&mount_lock); 4917c478bd9Sstevel@tonic-gate } 4927c478bd9Sstevel@tonic-gate 4937c478bd9Sstevel@tonic-gate /* 4947c478bd9Sstevel@tonic-gate * ZSD routines. 4957c478bd9Sstevel@tonic-gate * 4967c478bd9Sstevel@tonic-gate * Zone Specific Data (ZSD) is modeled after Thread Specific Data as 4977c478bd9Sstevel@tonic-gate * defined by the pthread_key_create() and related interfaces. 4987c478bd9Sstevel@tonic-gate * 4997c478bd9Sstevel@tonic-gate * Kernel subsystems may register one or more data items and/or 5007c478bd9Sstevel@tonic-gate * callbacks to be executed when a zone is created, shutdown, or 5017c478bd9Sstevel@tonic-gate * destroyed. 5027c478bd9Sstevel@tonic-gate * 5037c478bd9Sstevel@tonic-gate * Unlike the thread counterpart, destructor callbacks will be executed 5047c478bd9Sstevel@tonic-gate * even if the data pointer is NULL and/or there are no constructor 5057c478bd9Sstevel@tonic-gate * callbacks, so it is the responsibility of such callbacks to check for 5067c478bd9Sstevel@tonic-gate * NULL data values if necessary. 5077c478bd9Sstevel@tonic-gate * 5087c478bd9Sstevel@tonic-gate * The locking strategy and overall picture is as follows: 5097c478bd9Sstevel@tonic-gate * 5107c478bd9Sstevel@tonic-gate * When someone calls zone_key_create(), a template ZSD entry is added to the 511bd41d0a8Snordmark * global list "zsd_registered_keys", protected by zsd_key_lock. While 512bd41d0a8Snordmark * holding that lock all the existing zones are marked as 513bd41d0a8Snordmark * ZSD_CREATE_NEEDED and a copy of the ZSD entry added to the per-zone 514bd41d0a8Snordmark * zone_zsd list (protected by zone_lock). The global list is updated first 515bd41d0a8Snordmark * (under zone_key_lock) to make sure that newly created zones use the 516bd41d0a8Snordmark * most recent list of keys. Then under zonehash_lock we walk the zones 517bd41d0a8Snordmark * and mark them. Similar locking is used in zone_key_delete(). 5187c478bd9Sstevel@tonic-gate * 519bd41d0a8Snordmark * The actual create, shutdown, and destroy callbacks are done without 520bd41d0a8Snordmark * holding any lock. And zsd_flags are used to ensure that the operations 521bd41d0a8Snordmark * completed so that when zone_key_create (and zone_create) is done, as well as 522bd41d0a8Snordmark * zone_key_delete (and zone_destroy) is done, all the necessary callbacks 523bd41d0a8Snordmark * are completed. 5247c478bd9Sstevel@tonic-gate * 5257c478bd9Sstevel@tonic-gate * When new zones are created constructor callbacks for all registered ZSD 526bd41d0a8Snordmark * entries will be called. That also uses the above two phases of marking 527bd41d0a8Snordmark * what needs to be done, and then running the callbacks without holding 528bd41d0a8Snordmark * any locks. 5297c478bd9Sstevel@tonic-gate * 5307c478bd9Sstevel@tonic-gate * The framework does not provide any locking around zone_getspecific() and 5317c478bd9Sstevel@tonic-gate * zone_setspecific() apart from that needed for internal consistency, so 5327c478bd9Sstevel@tonic-gate * callers interested in atomic "test-and-set" semantics will need to provide 5337c478bd9Sstevel@tonic-gate * their own locking. 5347c478bd9Sstevel@tonic-gate */ 5357c478bd9Sstevel@tonic-gate 536bd41d0a8Snordmark /* 537bd41d0a8Snordmark * Helper function to find the zsd_entry associated with the key in the 538bd41d0a8Snordmark * given list. 539bd41d0a8Snordmark */ 540bd41d0a8Snordmark static struct zsd_entry * 541bd41d0a8Snordmark zsd_find(list_t *l, zone_key_t key) 542bd41d0a8Snordmark { 543bd41d0a8Snordmark struct zsd_entry *zsd; 5447c478bd9Sstevel@tonic-gate 545bd41d0a8Snordmark for (zsd = list_head(l); zsd != NULL; zsd = list_next(l, zsd)) { 546bd41d0a8Snordmark if (zsd->zsd_key == key) { 547bd41d0a8Snordmark return (zsd); 5487c478bd9Sstevel@tonic-gate } 5497c478bd9Sstevel@tonic-gate } 550bd41d0a8Snordmark return (NULL); 5517c478bd9Sstevel@tonic-gate } 5527c478bd9Sstevel@tonic-gate 5537c478bd9Sstevel@tonic-gate /* 5547c478bd9Sstevel@tonic-gate * Helper function to find the zsd_entry associated with the key in the 555bd41d0a8Snordmark * given list. Move it to the front of the list. 5567c478bd9Sstevel@tonic-gate */ 5577c478bd9Sstevel@tonic-gate static struct zsd_entry * 558bd41d0a8Snordmark zsd_find_mru(list_t *l, zone_key_t key) 5597c478bd9Sstevel@tonic-gate { 5607c478bd9Sstevel@tonic-gate struct zsd_entry *zsd; 5617c478bd9Sstevel@tonic-gate 5627c478bd9Sstevel@tonic-gate for (zsd = list_head(l); zsd != NULL; zsd = list_next(l, zsd)) { 5637c478bd9Sstevel@tonic-gate if (zsd->zsd_key == key) { 5647c478bd9Sstevel@tonic-gate /* 5657c478bd9Sstevel@tonic-gate * Move to head of list to keep list in MRU order. 5667c478bd9Sstevel@tonic-gate */ 5677c478bd9Sstevel@tonic-gate if (zsd != list_head(l)) { 5687c478bd9Sstevel@tonic-gate list_remove(l, zsd); 5697c478bd9Sstevel@tonic-gate list_insert_head(l, zsd); 5707c478bd9Sstevel@tonic-gate } 5717c478bd9Sstevel@tonic-gate return (zsd); 5727c478bd9Sstevel@tonic-gate } 5737c478bd9Sstevel@tonic-gate } 5747c478bd9Sstevel@tonic-gate return (NULL); 5757c478bd9Sstevel@tonic-gate } 5767c478bd9Sstevel@tonic-gate 577bd41d0a8Snordmark void 578bd41d0a8Snordmark zone_key_create(zone_key_t *keyp, void *(*create)(zoneid_t), 579bd41d0a8Snordmark void (*shutdown)(zoneid_t, void *), void (*destroy)(zoneid_t, void *)) 580bd41d0a8Snordmark { 581bd41d0a8Snordmark struct zsd_entry *zsdp; 582bd41d0a8Snordmark struct zsd_entry *t; 583bd41d0a8Snordmark struct zone *zone; 584bd41d0a8Snordmark zone_key_t key; 585bd41d0a8Snordmark 586bd41d0a8Snordmark zsdp = kmem_zalloc(sizeof (*zsdp), KM_SLEEP); 587bd41d0a8Snordmark zsdp->zsd_data = NULL; 588bd41d0a8Snordmark zsdp->zsd_create = create; 589bd41d0a8Snordmark zsdp->zsd_shutdown = shutdown; 590bd41d0a8Snordmark zsdp->zsd_destroy = destroy; 591bd41d0a8Snordmark 592bd41d0a8Snordmark /* 593bd41d0a8Snordmark * Insert in global list of callbacks. Makes future zone creations 594bd41d0a8Snordmark * see it. 595bd41d0a8Snordmark */ 596bd41d0a8Snordmark mutex_enter(&zsd_key_lock); 597fe16170aSPramod Batni key = zsdp->zsd_key = ++zsd_keyval; 598bd41d0a8Snordmark ASSERT(zsd_keyval != 0); 599bd41d0a8Snordmark list_insert_tail(&zsd_registered_keys, zsdp); 600bd41d0a8Snordmark mutex_exit(&zsd_key_lock); 601bd41d0a8Snordmark 602bd41d0a8Snordmark /* 603bd41d0a8Snordmark * Insert for all existing zones and mark them as needing 604bd41d0a8Snordmark * a create callback. 605bd41d0a8Snordmark */ 606bd41d0a8Snordmark mutex_enter(&zonehash_lock); /* stop the world */ 607bd41d0a8Snordmark for (zone = list_head(&zone_active); zone != NULL; 608bd41d0a8Snordmark zone = list_next(&zone_active, zone)) { 609bd41d0a8Snordmark zone_status_t status; 610bd41d0a8Snordmark 611bd41d0a8Snordmark mutex_enter(&zone->zone_lock); 612bd41d0a8Snordmark 613bd41d0a8Snordmark /* Skip zones that are on the way down or not yet up */ 614bd41d0a8Snordmark status = zone_status_get(zone); 615bd41d0a8Snordmark if (status >= ZONE_IS_DOWN || 616bd41d0a8Snordmark status == ZONE_IS_UNINITIALIZED) { 617bd41d0a8Snordmark mutex_exit(&zone->zone_lock); 618bd41d0a8Snordmark continue; 619bd41d0a8Snordmark } 620bd41d0a8Snordmark 621bd41d0a8Snordmark t = zsd_find_mru(&zone->zone_zsd, key); 622bd41d0a8Snordmark if (t != NULL) { 623bd41d0a8Snordmark /* 624bd41d0a8Snordmark * A zsd_configure already inserted it after 625bd41d0a8Snordmark * we dropped zsd_key_lock above. 626bd41d0a8Snordmark */ 627bd41d0a8Snordmark mutex_exit(&zone->zone_lock); 628bd41d0a8Snordmark continue; 629bd41d0a8Snordmark } 630bd41d0a8Snordmark t = kmem_zalloc(sizeof (*t), KM_SLEEP); 631bd41d0a8Snordmark t->zsd_key = key; 632bd41d0a8Snordmark t->zsd_create = create; 633bd41d0a8Snordmark t->zsd_shutdown = shutdown; 634bd41d0a8Snordmark t->zsd_destroy = destroy; 635bd41d0a8Snordmark if (create != NULL) { 636bd41d0a8Snordmark t->zsd_flags = ZSD_CREATE_NEEDED; 637bd41d0a8Snordmark DTRACE_PROBE2(zsd__create__needed, 638bd41d0a8Snordmark zone_t *, zone, zone_key_t, key); 639bd41d0a8Snordmark } 640bd41d0a8Snordmark list_insert_tail(&zone->zone_zsd, t); 641bd41d0a8Snordmark mutex_exit(&zone->zone_lock); 642bd41d0a8Snordmark } 643bd41d0a8Snordmark mutex_exit(&zonehash_lock); 644bd41d0a8Snordmark 645bd41d0a8Snordmark if (create != NULL) { 646bd41d0a8Snordmark /* Now call the create callback for this key */ 647bd41d0a8Snordmark zsd_apply_all_zones(zsd_apply_create, key); 648bd41d0a8Snordmark } 649fe16170aSPramod Batni /* 650835ee219SRobert Harris * It is safe for consumers to use the key now, make it 651835ee219SRobert Harris * globally visible. Specifically zone_getspecific() will 652835ee219SRobert Harris * always successfully return the zone specific data associated 653835ee219SRobert Harris * with the key. 654835ee219SRobert Harris */ 655fe16170aSPramod Batni *keyp = key; 656fe16170aSPramod Batni 657bd41d0a8Snordmark } 658bd41d0a8Snordmark 6597c478bd9Sstevel@tonic-gate /* 6607c478bd9Sstevel@tonic-gate * Function called when a module is being unloaded, or otherwise wishes 6617c478bd9Sstevel@tonic-gate * to unregister its ZSD key and callbacks. 662bd41d0a8Snordmark * 663bd41d0a8Snordmark * Remove from the global list and determine the functions that need to 664bd41d0a8Snordmark * be called under a global lock. Then call the functions without 665bd41d0a8Snordmark * holding any locks. Finally free up the zone_zsd entries. (The apply 666bd41d0a8Snordmark * functions need to access the zone_zsd entries to find zsd_data etc.) 6677c478bd9Sstevel@tonic-gate */ 6687c478bd9Sstevel@tonic-gate int 6697c478bd9Sstevel@tonic-gate zone_key_delete(zone_key_t key) 6707c478bd9Sstevel@tonic-gate { 6717c478bd9Sstevel@tonic-gate struct zsd_entry *zsdp = NULL; 6727c478bd9Sstevel@tonic-gate zone_t *zone; 6737c478bd9Sstevel@tonic-gate 6747c478bd9Sstevel@tonic-gate mutex_enter(&zsd_key_lock); 675bd41d0a8Snordmark zsdp = zsd_find_mru(&zsd_registered_keys, key); 676bd41d0a8Snordmark if (zsdp == NULL) { 677bd41d0a8Snordmark mutex_exit(&zsd_key_lock); 678bd41d0a8Snordmark return (-1); 679bd41d0a8Snordmark } 6807c478bd9Sstevel@tonic-gate list_remove(&zsd_registered_keys, zsdp); 6817c478bd9Sstevel@tonic-gate mutex_exit(&zsd_key_lock); 6827c478bd9Sstevel@tonic-gate 683bd41d0a8Snordmark mutex_enter(&zonehash_lock); 6847c478bd9Sstevel@tonic-gate for (zone = list_head(&zone_active); zone != NULL; 6857c478bd9Sstevel@tonic-gate zone = list_next(&zone_active, zone)) { 6867c478bd9Sstevel@tonic-gate struct zsd_entry *del; 687bd41d0a8Snordmark 688bd41d0a8Snordmark mutex_enter(&zone->zone_lock); 689bd41d0a8Snordmark del = zsd_find_mru(&zone->zone_zsd, key); 690bd41d0a8Snordmark if (del == NULL) { 691bd41d0a8Snordmark /* 692bd41d0a8Snordmark * Somebody else got here first e.g the zone going 693bd41d0a8Snordmark * away. 694bd41d0a8Snordmark */ 695bd41d0a8Snordmark mutex_exit(&zone->zone_lock); 696bd41d0a8Snordmark continue; 697bd41d0a8Snordmark } 698bd41d0a8Snordmark ASSERT(del->zsd_shutdown == zsdp->zsd_shutdown); 699bd41d0a8Snordmark ASSERT(del->zsd_destroy == zsdp->zsd_destroy); 700bd41d0a8Snordmark if (del->zsd_shutdown != NULL && 701bd41d0a8Snordmark (del->zsd_flags & ZSD_SHUTDOWN_ALL) == 0) { 702bd41d0a8Snordmark del->zsd_flags |= ZSD_SHUTDOWN_NEEDED; 703bd41d0a8Snordmark DTRACE_PROBE2(zsd__shutdown__needed, 704bd41d0a8Snordmark zone_t *, zone, zone_key_t, key); 705bd41d0a8Snordmark } 706bd41d0a8Snordmark if (del->zsd_destroy != NULL && 707bd41d0a8Snordmark (del->zsd_flags & ZSD_DESTROY_ALL) == 0) { 708bd41d0a8Snordmark del->zsd_flags |= ZSD_DESTROY_NEEDED; 709bd41d0a8Snordmark DTRACE_PROBE2(zsd__destroy__needed, 710bd41d0a8Snordmark zone_t *, zone, zone_key_t, key); 7117c478bd9Sstevel@tonic-gate } 7127c478bd9Sstevel@tonic-gate mutex_exit(&zone->zone_lock); 7137c478bd9Sstevel@tonic-gate } 7147c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 7157c478bd9Sstevel@tonic-gate kmem_free(zsdp, sizeof (*zsdp)); 7167c478bd9Sstevel@tonic-gate 717bd41d0a8Snordmark /* Now call the shutdown and destroy callback for this key */ 718bd41d0a8Snordmark zsd_apply_all_zones(zsd_apply_shutdown, key); 719bd41d0a8Snordmark zsd_apply_all_zones(zsd_apply_destroy, key); 720bd41d0a8Snordmark 721bd41d0a8Snordmark /* Now we can free up the zsdp structures in each zone */ 722bd41d0a8Snordmark mutex_enter(&zonehash_lock); 7237c478bd9Sstevel@tonic-gate for (zone = list_head(&zone_active); zone != NULL; 724bd41d0a8Snordmark zone = list_next(&zone_active, zone)) { 725bd41d0a8Snordmark struct zsd_entry *del; 726bd41d0a8Snordmark 727bd41d0a8Snordmark mutex_enter(&zone->zone_lock); 728bd41d0a8Snordmark del = zsd_find(&zone->zone_zsd, key); 729bd41d0a8Snordmark if (del != NULL) { 730bd41d0a8Snordmark list_remove(&zone->zone_zsd, del); 731bd41d0a8Snordmark ASSERT(!(del->zsd_flags & ZSD_ALL_INPROGRESS)); 732bd41d0a8Snordmark kmem_free(del, sizeof (*del)); 733bd41d0a8Snordmark } 7347c478bd9Sstevel@tonic-gate mutex_exit(&zone->zone_lock); 735bd41d0a8Snordmark } 7367c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 737bd41d0a8Snordmark 738bd41d0a8Snordmark return (0); 7397c478bd9Sstevel@tonic-gate } 7407c478bd9Sstevel@tonic-gate 7417c478bd9Sstevel@tonic-gate /* 7427c478bd9Sstevel@tonic-gate * ZSD counterpart of pthread_setspecific(). 743bd41d0a8Snordmark * 744bd41d0a8Snordmark * Since all zsd callbacks, including those with no create function, 745bd41d0a8Snordmark * have an entry in zone_zsd, if the key is registered it is part of 746bd41d0a8Snordmark * the zone_zsd list. 747bd41d0a8Snordmark * Return an error if the key wasn't registerd. 7487c478bd9Sstevel@tonic-gate */ 7497c478bd9Sstevel@tonic-gate int 7507c478bd9Sstevel@tonic-gate zone_setspecific(zone_key_t key, zone_t *zone, const void *data) 7517c478bd9Sstevel@tonic-gate { 7527c478bd9Sstevel@tonic-gate struct zsd_entry *t; 7537c478bd9Sstevel@tonic-gate 7547c478bd9Sstevel@tonic-gate mutex_enter(&zone->zone_lock); 755bd41d0a8Snordmark t = zsd_find_mru(&zone->zone_zsd, key); 7567c478bd9Sstevel@tonic-gate if (t != NULL) { 7577c478bd9Sstevel@tonic-gate /* 7587c478bd9Sstevel@tonic-gate * Replace old value with new 7597c478bd9Sstevel@tonic-gate */ 7607c478bd9Sstevel@tonic-gate t->zsd_data = (void *)data; 7617c478bd9Sstevel@tonic-gate mutex_exit(&zone->zone_lock); 7627c478bd9Sstevel@tonic-gate return (0); 7637c478bd9Sstevel@tonic-gate } 7647c478bd9Sstevel@tonic-gate mutex_exit(&zone->zone_lock); 765bd41d0a8Snordmark return (-1); 7667c478bd9Sstevel@tonic-gate } 7677c478bd9Sstevel@tonic-gate 7687c478bd9Sstevel@tonic-gate /* 7697c478bd9Sstevel@tonic-gate * ZSD counterpart of pthread_getspecific(). 7707c478bd9Sstevel@tonic-gate */ 7717c478bd9Sstevel@tonic-gate void * 7727c478bd9Sstevel@tonic-gate zone_getspecific(zone_key_t key, zone_t *zone) 7737c478bd9Sstevel@tonic-gate { 7747c478bd9Sstevel@tonic-gate struct zsd_entry *t; 7757c478bd9Sstevel@tonic-gate void *data; 7767c478bd9Sstevel@tonic-gate 7777c478bd9Sstevel@tonic-gate mutex_enter(&zone->zone_lock); 778bd41d0a8Snordmark t = zsd_find_mru(&zone->zone_zsd, key); 7797c478bd9Sstevel@tonic-gate data = (t == NULL ? NULL : t->zsd_data); 7807c478bd9Sstevel@tonic-gate mutex_exit(&zone->zone_lock); 7817c478bd9Sstevel@tonic-gate return (data); 7827c478bd9Sstevel@tonic-gate } 7837c478bd9Sstevel@tonic-gate 7847c478bd9Sstevel@tonic-gate /* 7857c478bd9Sstevel@tonic-gate * Function used to initialize a zone's list of ZSD callbacks and data 7867c478bd9Sstevel@tonic-gate * when the zone is being created. The callbacks are initialized from 787bd41d0a8Snordmark * the template list (zsd_registered_keys). The constructor callback is 788bd41d0a8Snordmark * executed later (once the zone exists and with locks dropped). 7897c478bd9Sstevel@tonic-gate */ 7907c478bd9Sstevel@tonic-gate static void 7917c478bd9Sstevel@tonic-gate zone_zsd_configure(zone_t *zone) 7927c478bd9Sstevel@tonic-gate { 7937c478bd9Sstevel@tonic-gate struct zsd_entry *zsdp; 7947c478bd9Sstevel@tonic-gate struct zsd_entry *t; 7957c478bd9Sstevel@tonic-gate 7967c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&zonehash_lock)); 7977c478bd9Sstevel@tonic-gate ASSERT(list_head(&zone->zone_zsd) == NULL); 798bd41d0a8Snordmark mutex_enter(&zone->zone_lock); 7997c478bd9Sstevel@tonic-gate mutex_enter(&zsd_key_lock); 8007c478bd9Sstevel@tonic-gate for (zsdp = list_head(&zsd_registered_keys); zsdp != NULL; 8017c478bd9Sstevel@tonic-gate zsdp = list_next(&zsd_registered_keys, zsdp)) { 802bd41d0a8Snordmark /* 803bd41d0a8Snordmark * Since this zone is ZONE_IS_UNCONFIGURED, zone_key_create 804bd41d0a8Snordmark * should not have added anything to it. 805bd41d0a8Snordmark */ 806bd41d0a8Snordmark ASSERT(zsd_find(&zone->zone_zsd, zsdp->zsd_key) == NULL); 807bd41d0a8Snordmark 808bd41d0a8Snordmark t = kmem_zalloc(sizeof (*t), KM_SLEEP); 809bd41d0a8Snordmark t->zsd_key = zsdp->zsd_key; 810bd41d0a8Snordmark t->zsd_create = zsdp->zsd_create; 811bd41d0a8Snordmark t->zsd_shutdown = zsdp->zsd_shutdown; 812bd41d0a8Snordmark t->zsd_destroy = zsdp->zsd_destroy; 8137c478bd9Sstevel@tonic-gate if (zsdp->zsd_create != NULL) { 814bd41d0a8Snordmark t->zsd_flags = ZSD_CREATE_NEEDED; 815bd41d0a8Snordmark DTRACE_PROBE2(zsd__create__needed, 816bd41d0a8Snordmark zone_t *, zone, zone_key_t, zsdp->zsd_key); 8177c478bd9Sstevel@tonic-gate } 818bd41d0a8Snordmark list_insert_tail(&zone->zone_zsd, t); 8197c478bd9Sstevel@tonic-gate } 8207c478bd9Sstevel@tonic-gate mutex_exit(&zsd_key_lock); 821bd41d0a8Snordmark mutex_exit(&zone->zone_lock); 8227c478bd9Sstevel@tonic-gate } 8237c478bd9Sstevel@tonic-gate 8247c478bd9Sstevel@tonic-gate enum zsd_callback_type { ZSD_CREATE, ZSD_SHUTDOWN, ZSD_DESTROY }; 8257c478bd9Sstevel@tonic-gate 8267c478bd9Sstevel@tonic-gate /* 8277c478bd9Sstevel@tonic-gate * Helper function to execute shutdown or destructor callbacks. 8287c478bd9Sstevel@tonic-gate */ 8297c478bd9Sstevel@tonic-gate static void 8307c478bd9Sstevel@tonic-gate zone_zsd_callbacks(zone_t *zone, enum zsd_callback_type ct) 8317c478bd9Sstevel@tonic-gate { 8327c478bd9Sstevel@tonic-gate struct zsd_entry *t; 8337c478bd9Sstevel@tonic-gate 8347c478bd9Sstevel@tonic-gate ASSERT(ct == ZSD_SHUTDOWN || ct == ZSD_DESTROY); 8357c478bd9Sstevel@tonic-gate ASSERT(ct != ZSD_SHUTDOWN || zone_status_get(zone) >= ZONE_IS_EMPTY); 8367c478bd9Sstevel@tonic-gate ASSERT(ct != ZSD_DESTROY || zone_status_get(zone) >= ZONE_IS_DOWN); 8377c478bd9Sstevel@tonic-gate 8387c478bd9Sstevel@tonic-gate /* 839bd41d0a8Snordmark * Run the callback solely based on what is registered for the zone 840bd41d0a8Snordmark * in zone_zsd. The global list can change independently of this 841bd41d0a8Snordmark * as keys are registered and unregistered and we don't register new 842bd41d0a8Snordmark * callbacks for a zone that is in the process of going away. 8437c478bd9Sstevel@tonic-gate */ 844bd41d0a8Snordmark mutex_enter(&zone->zone_lock); 845bd41d0a8Snordmark for (t = list_head(&zone->zone_zsd); t != NULL; 846bd41d0a8Snordmark t = list_next(&zone->zone_zsd, t)) { 847bd41d0a8Snordmark zone_key_t key = t->zsd_key; 8487c478bd9Sstevel@tonic-gate 8497c478bd9Sstevel@tonic-gate /* Skip if no callbacks registered */ 850bd41d0a8Snordmark 851bd41d0a8Snordmark if (ct == ZSD_SHUTDOWN) { 852bd41d0a8Snordmark if (t->zsd_shutdown != NULL && 853bd41d0a8Snordmark (t->zsd_flags & ZSD_SHUTDOWN_ALL) == 0) { 854bd41d0a8Snordmark t->zsd_flags |= ZSD_SHUTDOWN_NEEDED; 855bd41d0a8Snordmark DTRACE_PROBE2(zsd__shutdown__needed, 856bd41d0a8Snordmark zone_t *, zone, zone_key_t, key); 8577c478bd9Sstevel@tonic-gate } 8587c478bd9Sstevel@tonic-gate } else { 859bd41d0a8Snordmark if (t->zsd_destroy != NULL && 860bd41d0a8Snordmark (t->zsd_flags & ZSD_DESTROY_ALL) == 0) { 861bd41d0a8Snordmark t->zsd_flags |= ZSD_DESTROY_NEEDED; 862bd41d0a8Snordmark DTRACE_PROBE2(zsd__destroy__needed, 863bd41d0a8Snordmark zone_t *, zone, zone_key_t, key); 8647c478bd9Sstevel@tonic-gate } 8657c478bd9Sstevel@tonic-gate } 8667c478bd9Sstevel@tonic-gate } 867bd41d0a8Snordmark mutex_exit(&zone->zone_lock); 868bd41d0a8Snordmark 869bd41d0a8Snordmark /* Now call the shutdown and destroy callback for this key */ 870bd41d0a8Snordmark zsd_apply_all_keys(zsd_apply_shutdown, zone); 871bd41d0a8Snordmark zsd_apply_all_keys(zsd_apply_destroy, zone); 872bd41d0a8Snordmark 8737c478bd9Sstevel@tonic-gate } 8747c478bd9Sstevel@tonic-gate 8757c478bd9Sstevel@tonic-gate /* 8767c478bd9Sstevel@tonic-gate * Called when the zone is going away; free ZSD-related memory, and 8777c478bd9Sstevel@tonic-gate * destroy the zone_zsd list. 8787c478bd9Sstevel@tonic-gate */ 8797c478bd9Sstevel@tonic-gate static void 8807c478bd9Sstevel@tonic-gate zone_free_zsd(zone_t *zone) 8817c478bd9Sstevel@tonic-gate { 8827c478bd9Sstevel@tonic-gate struct zsd_entry *t, *next; 8837c478bd9Sstevel@tonic-gate 8847c478bd9Sstevel@tonic-gate /* 8857c478bd9Sstevel@tonic-gate * Free all the zsd_entry's we had on this zone. 8867c478bd9Sstevel@tonic-gate */ 887bd41d0a8Snordmark mutex_enter(&zone->zone_lock); 8887c478bd9Sstevel@tonic-gate for (t = list_head(&zone->zone_zsd); t != NULL; t = next) { 8897c478bd9Sstevel@tonic-gate next = list_next(&zone->zone_zsd, t); 8907c478bd9Sstevel@tonic-gate list_remove(&zone->zone_zsd, t); 891bd41d0a8Snordmark ASSERT(!(t->zsd_flags & ZSD_ALL_INPROGRESS)); 8927c478bd9Sstevel@tonic-gate kmem_free(t, sizeof (*t)); 8937c478bd9Sstevel@tonic-gate } 8947c478bd9Sstevel@tonic-gate list_destroy(&zone->zone_zsd); 895bd41d0a8Snordmark mutex_exit(&zone->zone_lock); 896bd41d0a8Snordmark 897bd41d0a8Snordmark } 898bd41d0a8Snordmark 899bd41d0a8Snordmark /* 900bd41d0a8Snordmark * Apply a function to all zones for particular key value. 901bd41d0a8Snordmark * 902bd41d0a8Snordmark * The applyfn has to drop zonehash_lock if it does some work, and 903bd41d0a8Snordmark * then reacquire it before it returns. 904bd41d0a8Snordmark * When the lock is dropped we don't follow list_next even 905bd41d0a8Snordmark * if it is possible to do so without any hazards. This is 906bd41d0a8Snordmark * because we want the design to allow for the list of zones 907bd41d0a8Snordmark * to change in any arbitrary way during the time the 908bd41d0a8Snordmark * lock was dropped. 909bd41d0a8Snordmark * 910bd41d0a8Snordmark * It is safe to restart the loop at list_head since the applyfn 911bd41d0a8Snordmark * changes the zsd_flags as it does work, so a subsequent 912bd41d0a8Snordmark * pass through will have no effect in applyfn, hence the loop will terminate 913bd41d0a8Snordmark * in at worst O(N^2). 914bd41d0a8Snordmark */ 915bd41d0a8Snordmark static void 916bd41d0a8Snordmark zsd_apply_all_zones(zsd_applyfn_t *applyfn, zone_key_t key) 917bd41d0a8Snordmark { 918bd41d0a8Snordmark zone_t *zone; 919bd41d0a8Snordmark 920bd41d0a8Snordmark mutex_enter(&zonehash_lock); 921bd41d0a8Snordmark zone = list_head(&zone_active); 922bd41d0a8Snordmark while (zone != NULL) { 923bd41d0a8Snordmark if ((applyfn)(&zonehash_lock, B_FALSE, zone, key)) { 924bd41d0a8Snordmark /* Lock dropped - restart at head */ 925bd41d0a8Snordmark zone = list_head(&zone_active); 926bd41d0a8Snordmark } else { 927bd41d0a8Snordmark zone = list_next(&zone_active, zone); 928bd41d0a8Snordmark } 929bd41d0a8Snordmark } 930bd41d0a8Snordmark mutex_exit(&zonehash_lock); 931bd41d0a8Snordmark } 932bd41d0a8Snordmark 933bd41d0a8Snordmark /* 934bd41d0a8Snordmark * Apply a function to all keys for a particular zone. 935bd41d0a8Snordmark * 936bd41d0a8Snordmark * The applyfn has to drop zonehash_lock if it does some work, and 937bd41d0a8Snordmark * then reacquire it before it returns. 938bd41d0a8Snordmark * When the lock is dropped we don't follow list_next even 939bd41d0a8Snordmark * if it is possible to do so without any hazards. This is 940bd41d0a8Snordmark * because we want the design to allow for the list of zsd callbacks 941bd41d0a8Snordmark * to change in any arbitrary way during the time the 942bd41d0a8Snordmark * lock was dropped. 943bd41d0a8Snordmark * 944bd41d0a8Snordmark * It is safe to restart the loop at list_head since the applyfn 945bd41d0a8Snordmark * changes the zsd_flags as it does work, so a subsequent 946bd41d0a8Snordmark * pass through will have no effect in applyfn, hence the loop will terminate 947bd41d0a8Snordmark * in at worst O(N^2). 948bd41d0a8Snordmark */ 949bd41d0a8Snordmark static void 950bd41d0a8Snordmark zsd_apply_all_keys(zsd_applyfn_t *applyfn, zone_t *zone) 951bd41d0a8Snordmark { 952bd41d0a8Snordmark struct zsd_entry *t; 953bd41d0a8Snordmark 954bd41d0a8Snordmark mutex_enter(&zone->zone_lock); 955bd41d0a8Snordmark t = list_head(&zone->zone_zsd); 956bd41d0a8Snordmark while (t != NULL) { 957bd41d0a8Snordmark if ((applyfn)(NULL, B_TRUE, zone, t->zsd_key)) { 958bd41d0a8Snordmark /* Lock dropped - restart at head */ 959bd41d0a8Snordmark t = list_head(&zone->zone_zsd); 960bd41d0a8Snordmark } else { 961bd41d0a8Snordmark t = list_next(&zone->zone_zsd, t); 962bd41d0a8Snordmark } 963bd41d0a8Snordmark } 964bd41d0a8Snordmark mutex_exit(&zone->zone_lock); 965bd41d0a8Snordmark } 966bd41d0a8Snordmark 967bd41d0a8Snordmark /* 968bd41d0a8Snordmark * Call the create function for the zone and key if CREATE_NEEDED 969bd41d0a8Snordmark * is set. 970bd41d0a8Snordmark * If some other thread gets here first and sets CREATE_INPROGRESS, then 971bd41d0a8Snordmark * we wait for that thread to complete so that we can ensure that 972bd41d0a8Snordmark * all the callbacks are done when we've looped over all zones/keys. 973bd41d0a8Snordmark * 974bd41d0a8Snordmark * When we call the create function, we drop the global held by the 975bd41d0a8Snordmark * caller, and return true to tell the caller it needs to re-evalute the 976bd41d0a8Snordmark * state. 977bd41d0a8Snordmark * If the caller holds zone_lock then zone_lock_held is set, and zone_lock 978bd41d0a8Snordmark * remains held on exit. 979bd41d0a8Snordmark */ 980bd41d0a8Snordmark static boolean_t 981bd41d0a8Snordmark zsd_apply_create(kmutex_t *lockp, boolean_t zone_lock_held, 982bd41d0a8Snordmark zone_t *zone, zone_key_t key) 983bd41d0a8Snordmark { 984bd41d0a8Snordmark void *result; 985bd41d0a8Snordmark struct zsd_entry *t; 986bd41d0a8Snordmark boolean_t dropped; 987bd41d0a8Snordmark 988bd41d0a8Snordmark if (lockp != NULL) { 989bd41d0a8Snordmark ASSERT(MUTEX_HELD(lockp)); 990bd41d0a8Snordmark } 991bd41d0a8Snordmark if (zone_lock_held) { 992bd41d0a8Snordmark ASSERT(MUTEX_HELD(&zone->zone_lock)); 993bd41d0a8Snordmark } else { 994bd41d0a8Snordmark mutex_enter(&zone->zone_lock); 995bd41d0a8Snordmark } 996bd41d0a8Snordmark 997bd41d0a8Snordmark t = zsd_find(&zone->zone_zsd, key); 998bd41d0a8Snordmark if (t == NULL) { 999bd41d0a8Snordmark /* 1000bd41d0a8Snordmark * Somebody else got here first e.g the zone going 1001bd41d0a8Snordmark * away. 1002bd41d0a8Snordmark */ 1003bd41d0a8Snordmark if (!zone_lock_held) 1004bd41d0a8Snordmark mutex_exit(&zone->zone_lock); 1005bd41d0a8Snordmark return (B_FALSE); 1006bd41d0a8Snordmark } 1007bd41d0a8Snordmark dropped = B_FALSE; 1008bd41d0a8Snordmark if (zsd_wait_for_inprogress(zone, t, lockp)) 1009bd41d0a8Snordmark dropped = B_TRUE; 1010bd41d0a8Snordmark 1011bd41d0a8Snordmark if (t->zsd_flags & ZSD_CREATE_NEEDED) { 1012bd41d0a8Snordmark t->zsd_flags &= ~ZSD_CREATE_NEEDED; 1013bd41d0a8Snordmark t->zsd_flags |= ZSD_CREATE_INPROGRESS; 1014bd41d0a8Snordmark DTRACE_PROBE2(zsd__create__inprogress, 1015bd41d0a8Snordmark zone_t *, zone, zone_key_t, key); 1016bd41d0a8Snordmark mutex_exit(&zone->zone_lock); 1017bd41d0a8Snordmark if (lockp != NULL) 1018bd41d0a8Snordmark mutex_exit(lockp); 1019bd41d0a8Snordmark 1020bd41d0a8Snordmark dropped = B_TRUE; 1021bd41d0a8Snordmark ASSERT(t->zsd_create != NULL); 1022bd41d0a8Snordmark DTRACE_PROBE2(zsd__create__start, 1023bd41d0a8Snordmark zone_t *, zone, zone_key_t, key); 1024bd41d0a8Snordmark 1025bd41d0a8Snordmark result = (*t->zsd_create)(zone->zone_id); 1026bd41d0a8Snordmark 1027bd41d0a8Snordmark DTRACE_PROBE2(zsd__create__end, 1028bd41d0a8Snordmark zone_t *, zone, voidn *, result); 1029bd41d0a8Snordmark 1030bd41d0a8Snordmark ASSERT(result != NULL); 1031bd41d0a8Snordmark if (lockp != NULL) 1032bd41d0a8Snordmark mutex_enter(lockp); 1033bd41d0a8Snordmark mutex_enter(&zone->zone_lock); 1034bd41d0a8Snordmark t->zsd_data = result; 1035bd41d0a8Snordmark t->zsd_flags &= ~ZSD_CREATE_INPROGRESS; 1036bd41d0a8Snordmark t->zsd_flags |= ZSD_CREATE_COMPLETED; 1037bd41d0a8Snordmark cv_broadcast(&t->zsd_cv); 1038bd41d0a8Snordmark DTRACE_PROBE2(zsd__create__completed, 1039bd41d0a8Snordmark zone_t *, zone, zone_key_t, key); 1040bd41d0a8Snordmark } 1041bd41d0a8Snordmark if (!zone_lock_held) 1042bd41d0a8Snordmark mutex_exit(&zone->zone_lock); 1043bd41d0a8Snordmark return (dropped); 1044bd41d0a8Snordmark } 1045bd41d0a8Snordmark 1046bd41d0a8Snordmark /* 1047bd41d0a8Snordmark * Call the shutdown function for the zone and key if SHUTDOWN_NEEDED 1048bd41d0a8Snordmark * is set. 1049bd41d0a8Snordmark * If some other thread gets here first and sets *_INPROGRESS, then 1050bd41d0a8Snordmark * we wait for that thread to complete so that we can ensure that 1051bd41d0a8Snordmark * all the callbacks are done when we've looped over all zones/keys. 1052bd41d0a8Snordmark * 1053bd41d0a8Snordmark * When we call the shutdown function, we drop the global held by the 1054bd41d0a8Snordmark * caller, and return true to tell the caller it needs to re-evalute the 1055bd41d0a8Snordmark * state. 1056bd41d0a8Snordmark * If the caller holds zone_lock then zone_lock_held is set, and zone_lock 1057bd41d0a8Snordmark * remains held on exit. 1058bd41d0a8Snordmark */ 1059bd41d0a8Snordmark static boolean_t 1060bd41d0a8Snordmark zsd_apply_shutdown(kmutex_t *lockp, boolean_t zone_lock_held, 1061bd41d0a8Snordmark zone_t *zone, zone_key_t key) 1062bd41d0a8Snordmark { 1063bd41d0a8Snordmark struct zsd_entry *t; 1064bd41d0a8Snordmark void *data; 1065bd41d0a8Snordmark boolean_t dropped; 1066bd41d0a8Snordmark 1067bd41d0a8Snordmark if (lockp != NULL) { 1068bd41d0a8Snordmark ASSERT(MUTEX_HELD(lockp)); 1069bd41d0a8Snordmark } 1070bd41d0a8Snordmark if (zone_lock_held) { 1071bd41d0a8Snordmark ASSERT(MUTEX_HELD(&zone->zone_lock)); 1072bd41d0a8Snordmark } else { 1073bd41d0a8Snordmark mutex_enter(&zone->zone_lock); 1074bd41d0a8Snordmark } 1075bd41d0a8Snordmark 1076bd41d0a8Snordmark t = zsd_find(&zone->zone_zsd, key); 1077bd41d0a8Snordmark if (t == NULL) { 1078bd41d0a8Snordmark /* 1079bd41d0a8Snordmark * Somebody else got here first e.g the zone going 1080bd41d0a8Snordmark * away. 1081bd41d0a8Snordmark */ 1082bd41d0a8Snordmark if (!zone_lock_held) 1083bd41d0a8Snordmark mutex_exit(&zone->zone_lock); 1084bd41d0a8Snordmark return (B_FALSE); 1085bd41d0a8Snordmark } 1086bd41d0a8Snordmark dropped = B_FALSE; 1087bd41d0a8Snordmark if (zsd_wait_for_creator(zone, t, lockp)) 1088bd41d0a8Snordmark dropped = B_TRUE; 1089bd41d0a8Snordmark 1090bd41d0a8Snordmark if (zsd_wait_for_inprogress(zone, t, lockp)) 1091bd41d0a8Snordmark dropped = B_TRUE; 1092bd41d0a8Snordmark 1093bd41d0a8Snordmark if (t->zsd_flags & ZSD_SHUTDOWN_NEEDED) { 1094bd41d0a8Snordmark t->zsd_flags &= ~ZSD_SHUTDOWN_NEEDED; 1095bd41d0a8Snordmark t->zsd_flags |= ZSD_SHUTDOWN_INPROGRESS; 1096bd41d0a8Snordmark DTRACE_PROBE2(zsd__shutdown__inprogress, 1097bd41d0a8Snordmark zone_t *, zone, zone_key_t, key); 1098bd41d0a8Snordmark mutex_exit(&zone->zone_lock); 1099bd41d0a8Snordmark if (lockp != NULL) 1100bd41d0a8Snordmark mutex_exit(lockp); 1101bd41d0a8Snordmark dropped = B_TRUE; 1102bd41d0a8Snordmark 1103bd41d0a8Snordmark ASSERT(t->zsd_shutdown != NULL); 1104bd41d0a8Snordmark data = t->zsd_data; 1105bd41d0a8Snordmark 1106bd41d0a8Snordmark DTRACE_PROBE2(zsd__shutdown__start, 1107bd41d0a8Snordmark zone_t *, zone, zone_key_t, key); 1108bd41d0a8Snordmark 1109bd41d0a8Snordmark (t->zsd_shutdown)(zone->zone_id, data); 1110bd41d0a8Snordmark DTRACE_PROBE2(zsd__shutdown__end, 1111bd41d0a8Snordmark zone_t *, zone, zone_key_t, key); 1112bd41d0a8Snordmark 1113bd41d0a8Snordmark if (lockp != NULL) 1114bd41d0a8Snordmark mutex_enter(lockp); 1115bd41d0a8Snordmark mutex_enter(&zone->zone_lock); 1116bd41d0a8Snordmark t->zsd_flags &= ~ZSD_SHUTDOWN_INPROGRESS; 1117bd41d0a8Snordmark t->zsd_flags |= ZSD_SHUTDOWN_COMPLETED; 1118bd41d0a8Snordmark cv_broadcast(&t->zsd_cv); 1119bd41d0a8Snordmark DTRACE_PROBE2(zsd__shutdown__completed, 1120bd41d0a8Snordmark zone_t *, zone, zone_key_t, key); 1121bd41d0a8Snordmark } 1122bd41d0a8Snordmark if (!zone_lock_held) 1123bd41d0a8Snordmark mutex_exit(&zone->zone_lock); 1124bd41d0a8Snordmark return (dropped); 1125bd41d0a8Snordmark } 1126bd41d0a8Snordmark 1127bd41d0a8Snordmark /* 1128bd41d0a8Snordmark * Call the destroy function for the zone and key if DESTROY_NEEDED 1129bd41d0a8Snordmark * is set. 1130bd41d0a8Snordmark * If some other thread gets here first and sets *_INPROGRESS, then 1131bd41d0a8Snordmark * we wait for that thread to complete so that we can ensure that 1132bd41d0a8Snordmark * all the callbacks are done when we've looped over all zones/keys. 1133bd41d0a8Snordmark * 1134bd41d0a8Snordmark * When we call the destroy function, we drop the global held by the 1135bd41d0a8Snordmark * caller, and return true to tell the caller it needs to re-evalute the 1136bd41d0a8Snordmark * state. 1137bd41d0a8Snordmark * If the caller holds zone_lock then zone_lock_held is set, and zone_lock 1138bd41d0a8Snordmark * remains held on exit. 1139bd41d0a8Snordmark */ 1140bd41d0a8Snordmark static boolean_t 1141bd41d0a8Snordmark zsd_apply_destroy(kmutex_t *lockp, boolean_t zone_lock_held, 1142bd41d0a8Snordmark zone_t *zone, zone_key_t key) 1143bd41d0a8Snordmark { 1144bd41d0a8Snordmark struct zsd_entry *t; 1145bd41d0a8Snordmark void *data; 1146bd41d0a8Snordmark boolean_t dropped; 1147bd41d0a8Snordmark 1148bd41d0a8Snordmark if (lockp != NULL) { 1149bd41d0a8Snordmark ASSERT(MUTEX_HELD(lockp)); 1150bd41d0a8Snordmark } 1151bd41d0a8Snordmark if (zone_lock_held) { 1152bd41d0a8Snordmark ASSERT(MUTEX_HELD(&zone->zone_lock)); 1153bd41d0a8Snordmark } else { 1154bd41d0a8Snordmark mutex_enter(&zone->zone_lock); 1155bd41d0a8Snordmark } 1156bd41d0a8Snordmark 1157bd41d0a8Snordmark t = zsd_find(&zone->zone_zsd, key); 1158bd41d0a8Snordmark if (t == NULL) { 1159bd41d0a8Snordmark /* 1160bd41d0a8Snordmark * Somebody else got here first e.g the zone going 1161bd41d0a8Snordmark * away. 1162bd41d0a8Snordmark */ 1163bd41d0a8Snordmark if (!zone_lock_held) 1164bd41d0a8Snordmark mutex_exit(&zone->zone_lock); 1165bd41d0a8Snordmark return (B_FALSE); 1166bd41d0a8Snordmark } 1167bd41d0a8Snordmark dropped = B_FALSE; 1168bd41d0a8Snordmark if (zsd_wait_for_creator(zone, t, lockp)) 1169bd41d0a8Snordmark dropped = B_TRUE; 1170bd41d0a8Snordmark 1171bd41d0a8Snordmark if (zsd_wait_for_inprogress(zone, t, lockp)) 1172bd41d0a8Snordmark dropped = B_TRUE; 1173bd41d0a8Snordmark 1174bd41d0a8Snordmark if (t->zsd_flags & ZSD_DESTROY_NEEDED) { 1175bd41d0a8Snordmark t->zsd_flags &= ~ZSD_DESTROY_NEEDED; 1176bd41d0a8Snordmark t->zsd_flags |= ZSD_DESTROY_INPROGRESS; 1177bd41d0a8Snordmark DTRACE_PROBE2(zsd__destroy__inprogress, 1178bd41d0a8Snordmark zone_t *, zone, zone_key_t, key); 1179bd41d0a8Snordmark mutex_exit(&zone->zone_lock); 1180bd41d0a8Snordmark if (lockp != NULL) 1181bd41d0a8Snordmark mutex_exit(lockp); 1182bd41d0a8Snordmark dropped = B_TRUE; 1183bd41d0a8Snordmark 1184bd41d0a8Snordmark ASSERT(t->zsd_destroy != NULL); 1185bd41d0a8Snordmark data = t->zsd_data; 1186bd41d0a8Snordmark DTRACE_PROBE2(zsd__destroy__start, 1187bd41d0a8Snordmark zone_t *, zone, zone_key_t, key); 1188bd41d0a8Snordmark 1189bd41d0a8Snordmark (t->zsd_destroy)(zone->zone_id, data); 1190bd41d0a8Snordmark DTRACE_PROBE2(zsd__destroy__end, 1191bd41d0a8Snordmark zone_t *, zone, zone_key_t, key); 1192bd41d0a8Snordmark 1193bd41d0a8Snordmark if (lockp != NULL) 1194bd41d0a8Snordmark mutex_enter(lockp); 1195bd41d0a8Snordmark mutex_enter(&zone->zone_lock); 1196bd41d0a8Snordmark t->zsd_data = NULL; 1197bd41d0a8Snordmark t->zsd_flags &= ~ZSD_DESTROY_INPROGRESS; 1198bd41d0a8Snordmark t->zsd_flags |= ZSD_DESTROY_COMPLETED; 1199bd41d0a8Snordmark cv_broadcast(&t->zsd_cv); 1200bd41d0a8Snordmark DTRACE_PROBE2(zsd__destroy__completed, 1201bd41d0a8Snordmark zone_t *, zone, zone_key_t, key); 1202bd41d0a8Snordmark } 1203bd41d0a8Snordmark if (!zone_lock_held) 1204bd41d0a8Snordmark mutex_exit(&zone->zone_lock); 1205bd41d0a8Snordmark return (dropped); 1206bd41d0a8Snordmark } 1207bd41d0a8Snordmark 1208bd41d0a8Snordmark /* 1209bd41d0a8Snordmark * Wait for any CREATE_NEEDED flag to be cleared. 1210bd41d0a8Snordmark * Returns true if lockp was temporarily dropped while waiting. 1211bd41d0a8Snordmark */ 1212bd41d0a8Snordmark static boolean_t 1213bd41d0a8Snordmark zsd_wait_for_creator(zone_t *zone, struct zsd_entry *t, kmutex_t *lockp) 1214bd41d0a8Snordmark { 1215bd41d0a8Snordmark boolean_t dropped = B_FALSE; 1216bd41d0a8Snordmark 1217bd41d0a8Snordmark while (t->zsd_flags & ZSD_CREATE_NEEDED) { 1218bd41d0a8Snordmark DTRACE_PROBE2(zsd__wait__for__creator, 1219bd41d0a8Snordmark zone_t *, zone, struct zsd_entry *, t); 1220bd41d0a8Snordmark if (lockp != NULL) { 1221bd41d0a8Snordmark dropped = B_TRUE; 1222bd41d0a8Snordmark mutex_exit(lockp); 1223bd41d0a8Snordmark } 1224bd41d0a8Snordmark cv_wait(&t->zsd_cv, &zone->zone_lock); 1225bd41d0a8Snordmark if (lockp != NULL) { 1226bd41d0a8Snordmark /* First drop zone_lock to preserve order */ 1227bd41d0a8Snordmark mutex_exit(&zone->zone_lock); 1228bd41d0a8Snordmark mutex_enter(lockp); 1229bd41d0a8Snordmark mutex_enter(&zone->zone_lock); 1230bd41d0a8Snordmark } 1231bd41d0a8Snordmark } 1232bd41d0a8Snordmark return (dropped); 1233bd41d0a8Snordmark } 1234bd41d0a8Snordmark 1235bd41d0a8Snordmark /* 1236bd41d0a8Snordmark * Wait for any INPROGRESS flag to be cleared. 1237bd41d0a8Snordmark * Returns true if lockp was temporarily dropped while waiting. 1238bd41d0a8Snordmark */ 1239bd41d0a8Snordmark static boolean_t 1240bd41d0a8Snordmark zsd_wait_for_inprogress(zone_t *zone, struct zsd_entry *t, kmutex_t *lockp) 1241bd41d0a8Snordmark { 1242bd41d0a8Snordmark boolean_t dropped = B_FALSE; 1243bd41d0a8Snordmark 1244bd41d0a8Snordmark while (t->zsd_flags & ZSD_ALL_INPROGRESS) { 1245bd41d0a8Snordmark DTRACE_PROBE2(zsd__wait__for__inprogress, 1246bd41d0a8Snordmark zone_t *, zone, struct zsd_entry *, t); 1247bd41d0a8Snordmark if (lockp != NULL) { 1248bd41d0a8Snordmark dropped = B_TRUE; 1249bd41d0a8Snordmark mutex_exit(lockp); 1250bd41d0a8Snordmark } 1251bd41d0a8Snordmark cv_wait(&t->zsd_cv, &zone->zone_lock); 1252bd41d0a8Snordmark if (lockp != NULL) { 1253bd41d0a8Snordmark /* First drop zone_lock to preserve order */ 1254bd41d0a8Snordmark mutex_exit(&zone->zone_lock); 1255bd41d0a8Snordmark mutex_enter(lockp); 1256bd41d0a8Snordmark mutex_enter(&zone->zone_lock); 1257bd41d0a8Snordmark } 1258bd41d0a8Snordmark } 1259bd41d0a8Snordmark return (dropped); 12607c478bd9Sstevel@tonic-gate } 12617c478bd9Sstevel@tonic-gate 1262fa9e4066Sahrens /* 1263fa9e4066Sahrens * Frees memory associated with the zone dataset list. 1264fa9e4066Sahrens */ 1265fa9e4066Sahrens static void 1266fa9e4066Sahrens zone_free_datasets(zone_t *zone) 1267fa9e4066Sahrens { 1268fa9e4066Sahrens zone_dataset_t *t, *next; 1269fa9e4066Sahrens 1270fa9e4066Sahrens for (t = list_head(&zone->zone_datasets); t != NULL; t = next) { 1271fa9e4066Sahrens next = list_next(&zone->zone_datasets, t); 1272fa9e4066Sahrens list_remove(&zone->zone_datasets, t); 1273fa9e4066Sahrens kmem_free(t->zd_dataset, strlen(t->zd_dataset) + 1); 1274fa9e4066Sahrens kmem_free(t, sizeof (*t)); 1275fa9e4066Sahrens } 1276fa9e4066Sahrens list_destroy(&zone->zone_datasets); 1277fa9e4066Sahrens } 1278fa9e4066Sahrens 12797c478bd9Sstevel@tonic-gate /* 12807c478bd9Sstevel@tonic-gate * zone.cpu-shares resource control support. 12817c478bd9Sstevel@tonic-gate */ 12827c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 12837c478bd9Sstevel@tonic-gate static rctl_qty_t 12847c478bd9Sstevel@tonic-gate zone_cpu_shares_usage(rctl_t *rctl, struct proc *p) 12857c478bd9Sstevel@tonic-gate { 12867c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&p->p_lock)); 12877c478bd9Sstevel@tonic-gate return (p->p_zone->zone_shares); 12887c478bd9Sstevel@tonic-gate } 12897c478bd9Sstevel@tonic-gate 12907c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 12917c478bd9Sstevel@tonic-gate static int 12927c478bd9Sstevel@tonic-gate zone_cpu_shares_set(rctl_t *rctl, struct proc *p, rctl_entity_p_t *e, 12937c478bd9Sstevel@tonic-gate rctl_qty_t nv) 12947c478bd9Sstevel@tonic-gate { 12957c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&p->p_lock)); 12967c478bd9Sstevel@tonic-gate ASSERT(e->rcep_t == RCENTITY_ZONE); 12977c478bd9Sstevel@tonic-gate if (e->rcep_p.zone == NULL) 12987c478bd9Sstevel@tonic-gate return (0); 12997c478bd9Sstevel@tonic-gate 13007c478bd9Sstevel@tonic-gate e->rcep_p.zone->zone_shares = nv; 13017c478bd9Sstevel@tonic-gate return (0); 13027c478bd9Sstevel@tonic-gate } 13037c478bd9Sstevel@tonic-gate 13047c478bd9Sstevel@tonic-gate static rctl_ops_t zone_cpu_shares_ops = { 13057c478bd9Sstevel@tonic-gate rcop_no_action, 13067c478bd9Sstevel@tonic-gate zone_cpu_shares_usage, 13077c478bd9Sstevel@tonic-gate zone_cpu_shares_set, 13087c478bd9Sstevel@tonic-gate rcop_no_test 13097c478bd9Sstevel@tonic-gate }; 13107c478bd9Sstevel@tonic-gate 1311c97ad5cdSakolb /* 1312c97ad5cdSakolb * zone.cpu-cap resource control support. 1313c97ad5cdSakolb */ 1314c97ad5cdSakolb /*ARGSUSED*/ 1315c97ad5cdSakolb static rctl_qty_t 1316c97ad5cdSakolb zone_cpu_cap_get(rctl_t *rctl, struct proc *p) 1317c97ad5cdSakolb { 1318c97ad5cdSakolb ASSERT(MUTEX_HELD(&p->p_lock)); 1319c97ad5cdSakolb return (cpucaps_zone_get(p->p_zone)); 1320c97ad5cdSakolb } 1321c97ad5cdSakolb 1322c97ad5cdSakolb /*ARGSUSED*/ 1323c97ad5cdSakolb static int 1324c97ad5cdSakolb zone_cpu_cap_set(rctl_t *rctl, struct proc *p, rctl_entity_p_t *e, 1325c97ad5cdSakolb rctl_qty_t nv) 1326c97ad5cdSakolb { 1327c97ad5cdSakolb zone_t *zone = e->rcep_p.zone; 1328c97ad5cdSakolb 1329c97ad5cdSakolb ASSERT(MUTEX_HELD(&p->p_lock)); 1330c97ad5cdSakolb ASSERT(e->rcep_t == RCENTITY_ZONE); 1331c97ad5cdSakolb 1332c97ad5cdSakolb if (zone == NULL) 1333c97ad5cdSakolb return (0); 1334c97ad5cdSakolb 1335c97ad5cdSakolb /* 1336c97ad5cdSakolb * set cap to the new value. 1337c97ad5cdSakolb */ 1338c97ad5cdSakolb return (cpucaps_zone_set(zone, nv)); 1339c97ad5cdSakolb } 1340c97ad5cdSakolb 1341c97ad5cdSakolb static rctl_ops_t zone_cpu_cap_ops = { 1342c97ad5cdSakolb rcop_no_action, 1343c97ad5cdSakolb zone_cpu_cap_get, 1344c97ad5cdSakolb zone_cpu_cap_set, 1345c97ad5cdSakolb rcop_no_test 1346c97ad5cdSakolb }; 1347c97ad5cdSakolb 13487c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 13497c478bd9Sstevel@tonic-gate static rctl_qty_t 13507c478bd9Sstevel@tonic-gate zone_lwps_usage(rctl_t *r, proc_t *p) 13517c478bd9Sstevel@tonic-gate { 13527c478bd9Sstevel@tonic-gate rctl_qty_t nlwps; 13537c478bd9Sstevel@tonic-gate zone_t *zone = p->p_zone; 13547c478bd9Sstevel@tonic-gate 13557c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&p->p_lock)); 13567c478bd9Sstevel@tonic-gate 13577c478bd9Sstevel@tonic-gate mutex_enter(&zone->zone_nlwps_lock); 13587c478bd9Sstevel@tonic-gate nlwps = zone->zone_nlwps; 13597c478bd9Sstevel@tonic-gate mutex_exit(&zone->zone_nlwps_lock); 13607c478bd9Sstevel@tonic-gate 13617c478bd9Sstevel@tonic-gate return (nlwps); 13627c478bd9Sstevel@tonic-gate } 13637c478bd9Sstevel@tonic-gate 13647c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 13657c478bd9Sstevel@tonic-gate static int 13667c478bd9Sstevel@tonic-gate zone_lwps_test(rctl_t *r, proc_t *p, rctl_entity_p_t *e, rctl_val_t *rcntl, 13677c478bd9Sstevel@tonic-gate rctl_qty_t incr, uint_t flags) 13687c478bd9Sstevel@tonic-gate { 13697c478bd9Sstevel@tonic-gate rctl_qty_t nlwps; 13707c478bd9Sstevel@tonic-gate 13717c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&p->p_lock)); 13727c478bd9Sstevel@tonic-gate ASSERT(e->rcep_t == RCENTITY_ZONE); 13737c478bd9Sstevel@tonic-gate if (e->rcep_p.zone == NULL) 13747c478bd9Sstevel@tonic-gate return (0); 13757c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&(e->rcep_p.zone->zone_nlwps_lock))); 13767c478bd9Sstevel@tonic-gate nlwps = e->rcep_p.zone->zone_nlwps; 13777c478bd9Sstevel@tonic-gate 13787c478bd9Sstevel@tonic-gate if (nlwps + incr > rcntl->rcv_value) 13797c478bd9Sstevel@tonic-gate return (1); 13807c478bd9Sstevel@tonic-gate 13817c478bd9Sstevel@tonic-gate return (0); 13827c478bd9Sstevel@tonic-gate } 13837c478bd9Sstevel@tonic-gate 13847c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 13857c478bd9Sstevel@tonic-gate static int 1386c6939658Ssl zone_lwps_set(rctl_t *rctl, struct proc *p, rctl_entity_p_t *e, rctl_qty_t nv) 1387c6939658Ssl { 13887c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&p->p_lock)); 13897c478bd9Sstevel@tonic-gate ASSERT(e->rcep_t == RCENTITY_ZONE); 13907c478bd9Sstevel@tonic-gate if (e->rcep_p.zone == NULL) 13917c478bd9Sstevel@tonic-gate return (0); 13927c478bd9Sstevel@tonic-gate e->rcep_p.zone->zone_nlwps_ctl = nv; 13937c478bd9Sstevel@tonic-gate return (0); 13947c478bd9Sstevel@tonic-gate } 13957c478bd9Sstevel@tonic-gate 13967c478bd9Sstevel@tonic-gate static rctl_ops_t zone_lwps_ops = { 13977c478bd9Sstevel@tonic-gate rcop_no_action, 13987c478bd9Sstevel@tonic-gate zone_lwps_usage, 13997c478bd9Sstevel@tonic-gate zone_lwps_set, 14007c478bd9Sstevel@tonic-gate zone_lwps_test, 14017c478bd9Sstevel@tonic-gate }; 14027c478bd9Sstevel@tonic-gate 1403824c205fSml /*ARGSUSED*/ 1404824c205fSml static int 1405824c205fSml zone_shmmax_test(rctl_t *r, proc_t *p, rctl_entity_p_t *e, rctl_val_t *rval, 1406824c205fSml rctl_qty_t incr, uint_t flags) 1407824c205fSml { 1408824c205fSml rctl_qty_t v; 1409824c205fSml ASSERT(MUTEX_HELD(&p->p_lock)); 1410824c205fSml ASSERT(e->rcep_t == RCENTITY_ZONE); 1411824c205fSml v = e->rcep_p.zone->zone_shmmax + incr; 1412824c205fSml if (v > rval->rcv_value) 1413824c205fSml return (1); 1414824c205fSml return (0); 1415824c205fSml } 1416824c205fSml 1417824c205fSml static rctl_ops_t zone_shmmax_ops = { 1418824c205fSml rcop_no_action, 1419824c205fSml rcop_no_usage, 1420824c205fSml rcop_no_set, 1421824c205fSml zone_shmmax_test 1422824c205fSml }; 1423824c205fSml 1424824c205fSml /*ARGSUSED*/ 1425824c205fSml static int 1426824c205fSml zone_shmmni_test(rctl_t *r, proc_t *p, rctl_entity_p_t *e, rctl_val_t *rval, 1427824c205fSml rctl_qty_t incr, uint_t flags) 1428824c205fSml { 1429824c205fSml rctl_qty_t v; 1430824c205fSml ASSERT(MUTEX_HELD(&p->p_lock)); 1431824c205fSml ASSERT(e->rcep_t == RCENTITY_ZONE); 1432824c205fSml v = e->rcep_p.zone->zone_ipc.ipcq_shmmni + incr; 1433824c205fSml if (v > rval->rcv_value) 1434824c205fSml return (1); 1435824c205fSml return (0); 1436824c205fSml } 1437824c205fSml 1438824c205fSml static rctl_ops_t zone_shmmni_ops = { 1439824c205fSml rcop_no_action, 1440824c205fSml rcop_no_usage, 1441824c205fSml rcop_no_set, 1442824c205fSml zone_shmmni_test 1443824c205fSml }; 1444824c205fSml 1445824c205fSml /*ARGSUSED*/ 1446824c205fSml static int 1447824c205fSml zone_semmni_test(rctl_t *r, proc_t *p, rctl_entity_p_t *e, rctl_val_t *rval, 1448824c205fSml rctl_qty_t incr, uint_t flags) 1449824c205fSml { 1450824c205fSml rctl_qty_t v; 1451824c205fSml ASSERT(MUTEX_HELD(&p->p_lock)); 1452824c205fSml ASSERT(e->rcep_t == RCENTITY_ZONE); 1453824c205fSml v = e->rcep_p.zone->zone_ipc.ipcq_semmni + incr; 1454824c205fSml if (v > rval->rcv_value) 1455824c205fSml return (1); 1456824c205fSml return (0); 1457824c205fSml } 1458824c205fSml 1459824c205fSml static rctl_ops_t zone_semmni_ops = { 1460824c205fSml rcop_no_action, 1461824c205fSml rcop_no_usage, 1462824c205fSml rcop_no_set, 1463824c205fSml zone_semmni_test 1464824c205fSml }; 1465824c205fSml 1466824c205fSml /*ARGSUSED*/ 1467824c205fSml static int 1468824c205fSml zone_msgmni_test(rctl_t *r, proc_t *p, rctl_entity_p_t *e, rctl_val_t *rval, 1469824c205fSml rctl_qty_t incr, uint_t flags) 1470824c205fSml { 1471824c205fSml rctl_qty_t v; 1472824c205fSml ASSERT(MUTEX_HELD(&p->p_lock)); 1473824c205fSml ASSERT(e->rcep_t == RCENTITY_ZONE); 1474824c205fSml v = e->rcep_p.zone->zone_ipc.ipcq_msgmni + incr; 1475824c205fSml if (v > rval->rcv_value) 1476824c205fSml return (1); 1477824c205fSml return (0); 1478824c205fSml } 1479824c205fSml 1480824c205fSml static rctl_ops_t zone_msgmni_ops = { 1481824c205fSml rcop_no_action, 1482824c205fSml rcop_no_usage, 1483824c205fSml rcop_no_set, 1484824c205fSml zone_msgmni_test 1485824c205fSml }; 1486824c205fSml 1487c6939658Ssl /*ARGSUSED*/ 1488c6939658Ssl static rctl_qty_t 1489c6939658Ssl zone_locked_mem_usage(rctl_t *rctl, struct proc *p) 1490c6939658Ssl { 1491c6939658Ssl rctl_qty_t q; 1492c6939658Ssl ASSERT(MUTEX_HELD(&p->p_lock)); 14930209230bSgjelinek mutex_enter(&p->p_zone->zone_mem_lock); 1494c6939658Ssl q = p->p_zone->zone_locked_mem; 14950209230bSgjelinek mutex_exit(&p->p_zone->zone_mem_lock); 1496c6939658Ssl return (q); 1497c6939658Ssl } 1498c6939658Ssl 1499c6939658Ssl /*ARGSUSED*/ 1500c6939658Ssl static int 1501c6939658Ssl zone_locked_mem_test(rctl_t *r, proc_t *p, rctl_entity_p_t *e, 1502c6939658Ssl rctl_val_t *rcntl, rctl_qty_t incr, uint_t flags) 1503c6939658Ssl { 1504c6939658Ssl rctl_qty_t q; 15050209230bSgjelinek zone_t *z; 15060209230bSgjelinek 15070209230bSgjelinek z = e->rcep_p.zone; 1508c6939658Ssl ASSERT(MUTEX_HELD(&p->p_lock)); 15090209230bSgjelinek ASSERT(MUTEX_HELD(&z->zone_mem_lock)); 15100209230bSgjelinek q = z->zone_locked_mem; 1511c6939658Ssl if (q + incr > rcntl->rcv_value) 1512c6939658Ssl return (1); 1513c6939658Ssl return (0); 1514c6939658Ssl } 1515c6939658Ssl 1516c6939658Ssl /*ARGSUSED*/ 1517c6939658Ssl static int 1518c6939658Ssl zone_locked_mem_set(rctl_t *rctl, struct proc *p, rctl_entity_p_t *e, 1519c6939658Ssl rctl_qty_t nv) 1520c6939658Ssl { 1521c6939658Ssl ASSERT(MUTEX_HELD(&p->p_lock)); 1522c6939658Ssl ASSERT(e->rcep_t == RCENTITY_ZONE); 1523c6939658Ssl if (e->rcep_p.zone == NULL) 1524c6939658Ssl return (0); 1525c6939658Ssl e->rcep_p.zone->zone_locked_mem_ctl = nv; 1526c6939658Ssl return (0); 1527c6939658Ssl } 1528c6939658Ssl 1529c6939658Ssl static rctl_ops_t zone_locked_mem_ops = { 1530c6939658Ssl rcop_no_action, 1531c6939658Ssl zone_locked_mem_usage, 1532c6939658Ssl zone_locked_mem_set, 1533c6939658Ssl zone_locked_mem_test 1534c6939658Ssl }; 1535824c205fSml 15360209230bSgjelinek /*ARGSUSED*/ 15370209230bSgjelinek static rctl_qty_t 15380209230bSgjelinek zone_max_swap_usage(rctl_t *rctl, struct proc *p) 15390209230bSgjelinek { 15400209230bSgjelinek rctl_qty_t q; 15410209230bSgjelinek zone_t *z = p->p_zone; 15420209230bSgjelinek 15430209230bSgjelinek ASSERT(MUTEX_HELD(&p->p_lock)); 15440209230bSgjelinek mutex_enter(&z->zone_mem_lock); 15450209230bSgjelinek q = z->zone_max_swap; 15460209230bSgjelinek mutex_exit(&z->zone_mem_lock); 15470209230bSgjelinek return (q); 15480209230bSgjelinek } 15490209230bSgjelinek 15500209230bSgjelinek /*ARGSUSED*/ 15510209230bSgjelinek static int 15520209230bSgjelinek zone_max_swap_test(rctl_t *r, proc_t *p, rctl_entity_p_t *e, 15530209230bSgjelinek rctl_val_t *rcntl, rctl_qty_t incr, uint_t flags) 15540209230bSgjelinek { 15550209230bSgjelinek rctl_qty_t q; 15560209230bSgjelinek zone_t *z; 15570209230bSgjelinek 15580209230bSgjelinek z = e->rcep_p.zone; 15590209230bSgjelinek ASSERT(MUTEX_HELD(&p->p_lock)); 15600209230bSgjelinek ASSERT(MUTEX_HELD(&z->zone_mem_lock)); 15610209230bSgjelinek q = z->zone_max_swap; 15620209230bSgjelinek if (q + incr > rcntl->rcv_value) 15630209230bSgjelinek return (1); 15640209230bSgjelinek return (0); 15650209230bSgjelinek } 15660209230bSgjelinek 15670209230bSgjelinek /*ARGSUSED*/ 15680209230bSgjelinek static int 15690209230bSgjelinek zone_max_swap_set(rctl_t *rctl, struct proc *p, rctl_entity_p_t *e, 15700209230bSgjelinek rctl_qty_t nv) 15710209230bSgjelinek { 15720209230bSgjelinek ASSERT(MUTEX_HELD(&p->p_lock)); 15730209230bSgjelinek ASSERT(e->rcep_t == RCENTITY_ZONE); 15740209230bSgjelinek if (e->rcep_p.zone == NULL) 15750209230bSgjelinek return (0); 15760209230bSgjelinek e->rcep_p.zone->zone_max_swap_ctl = nv; 15770209230bSgjelinek return (0); 15780209230bSgjelinek } 15790209230bSgjelinek 15800209230bSgjelinek static rctl_ops_t zone_max_swap_ops = { 15810209230bSgjelinek rcop_no_action, 15820209230bSgjelinek zone_max_swap_usage, 15830209230bSgjelinek zone_max_swap_set, 15840209230bSgjelinek zone_max_swap_test 15850209230bSgjelinek }; 15860209230bSgjelinek 15877c478bd9Sstevel@tonic-gate /* 15887c478bd9Sstevel@tonic-gate * Helper function to brand the zone with a unique ID. 15897c478bd9Sstevel@tonic-gate */ 15907c478bd9Sstevel@tonic-gate static void 15917c478bd9Sstevel@tonic-gate zone_uniqid(zone_t *zone) 15927c478bd9Sstevel@tonic-gate { 15937c478bd9Sstevel@tonic-gate static uint64_t uniqid = 0; 15947c478bd9Sstevel@tonic-gate 15957c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&zonehash_lock)); 15967c478bd9Sstevel@tonic-gate zone->zone_uniqid = uniqid++; 15977c478bd9Sstevel@tonic-gate } 15987c478bd9Sstevel@tonic-gate 15997c478bd9Sstevel@tonic-gate /* 16007c478bd9Sstevel@tonic-gate * Returns a held pointer to the "kcred" for the specified zone. 16017c478bd9Sstevel@tonic-gate */ 16027c478bd9Sstevel@tonic-gate struct cred * 16037c478bd9Sstevel@tonic-gate zone_get_kcred(zoneid_t zoneid) 16047c478bd9Sstevel@tonic-gate { 16057c478bd9Sstevel@tonic-gate zone_t *zone; 16067c478bd9Sstevel@tonic-gate cred_t *cr; 16077c478bd9Sstevel@tonic-gate 16087c478bd9Sstevel@tonic-gate if ((zone = zone_find_by_id(zoneid)) == NULL) 16097c478bd9Sstevel@tonic-gate return (NULL); 16107c478bd9Sstevel@tonic-gate cr = zone->zone_kcred; 16117c478bd9Sstevel@tonic-gate crhold(cr); 16127c478bd9Sstevel@tonic-gate zone_rele(zone); 16137c478bd9Sstevel@tonic-gate return (cr); 16147c478bd9Sstevel@tonic-gate } 16157c478bd9Sstevel@tonic-gate 16160209230bSgjelinek static int 16170209230bSgjelinek zone_lockedmem_kstat_update(kstat_t *ksp, int rw) 16180209230bSgjelinek { 16190209230bSgjelinek zone_t *zone = ksp->ks_private; 16200209230bSgjelinek zone_kstat_t *zk = ksp->ks_data; 16210209230bSgjelinek 16220209230bSgjelinek if (rw == KSTAT_WRITE) 16230209230bSgjelinek return (EACCES); 16240209230bSgjelinek 16250209230bSgjelinek zk->zk_usage.value.ui64 = zone->zone_locked_mem; 16260209230bSgjelinek zk->zk_value.value.ui64 = zone->zone_locked_mem_ctl; 16270209230bSgjelinek return (0); 16280209230bSgjelinek } 16290209230bSgjelinek 16300209230bSgjelinek static int 16310209230bSgjelinek zone_swapresv_kstat_update(kstat_t *ksp, int rw) 16320209230bSgjelinek { 16330209230bSgjelinek zone_t *zone = ksp->ks_private; 16340209230bSgjelinek zone_kstat_t *zk = ksp->ks_data; 16350209230bSgjelinek 16360209230bSgjelinek if (rw == KSTAT_WRITE) 16370209230bSgjelinek return (EACCES); 16380209230bSgjelinek 16390209230bSgjelinek zk->zk_usage.value.ui64 = zone->zone_max_swap; 16400209230bSgjelinek zk->zk_value.value.ui64 = zone->zone_max_swap_ctl; 16410209230bSgjelinek return (0); 16420209230bSgjelinek } 16430209230bSgjelinek 16440209230bSgjelinek static void 16450209230bSgjelinek zone_kstat_create(zone_t *zone) 16460209230bSgjelinek { 16470209230bSgjelinek kstat_t *ksp; 16480209230bSgjelinek zone_kstat_t *zk; 16490209230bSgjelinek 16500209230bSgjelinek ksp = rctl_kstat_create_zone(zone, "lockedmem", KSTAT_TYPE_NAMED, 16510209230bSgjelinek sizeof (zone_kstat_t) / sizeof (kstat_named_t), 16520209230bSgjelinek KSTAT_FLAG_VIRTUAL); 16530209230bSgjelinek 16540209230bSgjelinek if (ksp == NULL) 16550209230bSgjelinek return; 16560209230bSgjelinek 16570209230bSgjelinek zk = ksp->ks_data = kmem_alloc(sizeof (zone_kstat_t), KM_SLEEP); 16580209230bSgjelinek ksp->ks_data_size += strlen(zone->zone_name) + 1; 16590209230bSgjelinek kstat_named_init(&zk->zk_zonename, "zonename", KSTAT_DATA_STRING); 16600209230bSgjelinek kstat_named_setstr(&zk->zk_zonename, zone->zone_name); 16610209230bSgjelinek kstat_named_init(&zk->zk_usage, "usage", KSTAT_DATA_UINT64); 16620209230bSgjelinek kstat_named_init(&zk->zk_value, "value", KSTAT_DATA_UINT64); 16630209230bSgjelinek ksp->ks_update = zone_lockedmem_kstat_update; 16640209230bSgjelinek ksp->ks_private = zone; 16650209230bSgjelinek kstat_install(ksp); 16660209230bSgjelinek 16670209230bSgjelinek zone->zone_lockedmem_kstat = ksp; 16680209230bSgjelinek 16690209230bSgjelinek ksp = rctl_kstat_create_zone(zone, "swapresv", KSTAT_TYPE_NAMED, 16700209230bSgjelinek sizeof (zone_kstat_t) / sizeof (kstat_named_t), 16710209230bSgjelinek KSTAT_FLAG_VIRTUAL); 16720209230bSgjelinek 16730209230bSgjelinek if (ksp == NULL) 16740209230bSgjelinek return; 16750209230bSgjelinek 16760209230bSgjelinek zk = ksp->ks_data = kmem_alloc(sizeof (zone_kstat_t), KM_SLEEP); 16770209230bSgjelinek ksp->ks_data_size += strlen(zone->zone_name) + 1; 16780209230bSgjelinek kstat_named_init(&zk->zk_zonename, "zonename", KSTAT_DATA_STRING); 16790209230bSgjelinek kstat_named_setstr(&zk->zk_zonename, zone->zone_name); 16800209230bSgjelinek kstat_named_init(&zk->zk_usage, "usage", KSTAT_DATA_UINT64); 16810209230bSgjelinek kstat_named_init(&zk->zk_value, "value", KSTAT_DATA_UINT64); 16820209230bSgjelinek ksp->ks_update = zone_swapresv_kstat_update; 16830209230bSgjelinek ksp->ks_private = zone; 16840209230bSgjelinek kstat_install(ksp); 16850209230bSgjelinek 16860209230bSgjelinek zone->zone_swapresv_kstat = ksp; 16870209230bSgjelinek } 16880209230bSgjelinek 16890209230bSgjelinek static void 16900209230bSgjelinek zone_kstat_delete(zone_t *zone) 16910209230bSgjelinek { 16920209230bSgjelinek void *data; 16930209230bSgjelinek 16940209230bSgjelinek if (zone->zone_lockedmem_kstat != NULL) { 16950209230bSgjelinek data = zone->zone_lockedmem_kstat->ks_data; 16960209230bSgjelinek kstat_delete(zone->zone_lockedmem_kstat); 16970209230bSgjelinek kmem_free(data, sizeof (zone_kstat_t)); 16980209230bSgjelinek } 16990209230bSgjelinek if (zone->zone_swapresv_kstat != NULL) { 17000209230bSgjelinek data = zone->zone_swapresv_kstat->ks_data; 17010209230bSgjelinek kstat_delete(zone->zone_swapresv_kstat); 17020209230bSgjelinek kmem_free(data, sizeof (zone_kstat_t)); 17030209230bSgjelinek } 17040209230bSgjelinek } 17050209230bSgjelinek 17067c478bd9Sstevel@tonic-gate /* 17077c478bd9Sstevel@tonic-gate * Called very early on in boot to initialize the ZSD list so that 17087c478bd9Sstevel@tonic-gate * zone_key_create() can be called before zone_init(). It also initializes 17097c478bd9Sstevel@tonic-gate * portions of zone0 which may be used before zone_init() is called. The 17107c478bd9Sstevel@tonic-gate * variable "global_zone" will be set when zone0 is fully initialized by 17117c478bd9Sstevel@tonic-gate * zone_init(). 17127c478bd9Sstevel@tonic-gate */ 17137c478bd9Sstevel@tonic-gate void 17147c478bd9Sstevel@tonic-gate zone_zsd_init(void) 17157c478bd9Sstevel@tonic-gate { 17167c478bd9Sstevel@tonic-gate mutex_init(&zonehash_lock, NULL, MUTEX_DEFAULT, NULL); 17177c478bd9Sstevel@tonic-gate mutex_init(&zsd_key_lock, NULL, MUTEX_DEFAULT, NULL); 17187c478bd9Sstevel@tonic-gate list_create(&zsd_registered_keys, sizeof (struct zsd_entry), 17197c478bd9Sstevel@tonic-gate offsetof(struct zsd_entry, zsd_linkage)); 17207c478bd9Sstevel@tonic-gate list_create(&zone_active, sizeof (zone_t), 17217c478bd9Sstevel@tonic-gate offsetof(zone_t, zone_linkage)); 17227c478bd9Sstevel@tonic-gate list_create(&zone_deathrow, sizeof (zone_t), 17237c478bd9Sstevel@tonic-gate offsetof(zone_t, zone_linkage)); 17247c478bd9Sstevel@tonic-gate 17257c478bd9Sstevel@tonic-gate mutex_init(&zone0.zone_lock, NULL, MUTEX_DEFAULT, NULL); 17267c478bd9Sstevel@tonic-gate mutex_init(&zone0.zone_nlwps_lock, NULL, MUTEX_DEFAULT, NULL); 17270209230bSgjelinek mutex_init(&zone0.zone_mem_lock, NULL, MUTEX_DEFAULT, NULL); 17287c478bd9Sstevel@tonic-gate zone0.zone_shares = 1; 17290209230bSgjelinek zone0.zone_nlwps = 0; 17307c478bd9Sstevel@tonic-gate zone0.zone_nlwps_ctl = INT_MAX; 17310209230bSgjelinek zone0.zone_locked_mem = 0; 17320209230bSgjelinek zone0.zone_locked_mem_ctl = UINT64_MAX; 17330209230bSgjelinek ASSERT(zone0.zone_max_swap == 0); 17340209230bSgjelinek zone0.zone_max_swap_ctl = UINT64_MAX; 1735824c205fSml zone0.zone_shmmax = 0; 1736824c205fSml zone0.zone_ipc.ipcq_shmmni = 0; 1737824c205fSml zone0.zone_ipc.ipcq_semmni = 0; 1738824c205fSml zone0.zone_ipc.ipcq_msgmni = 0; 17397c478bd9Sstevel@tonic-gate zone0.zone_name = GLOBAL_ZONENAME; 17407c478bd9Sstevel@tonic-gate zone0.zone_nodename = utsname.nodename; 17417c478bd9Sstevel@tonic-gate zone0.zone_domain = srpc_domain; 17425679c89fSjv zone0.zone_hostid = HW_INVALID_HOSTID; 17437c478bd9Sstevel@tonic-gate zone0.zone_ref = 1; 17447c478bd9Sstevel@tonic-gate zone0.zone_id = GLOBAL_ZONEID; 17457c478bd9Sstevel@tonic-gate zone0.zone_status = ZONE_IS_RUNNING; 17467c478bd9Sstevel@tonic-gate zone0.zone_rootpath = "/"; 17477c478bd9Sstevel@tonic-gate zone0.zone_rootpathlen = 2; 17487c478bd9Sstevel@tonic-gate zone0.zone_psetid = ZONE_PS_INVAL; 17497c478bd9Sstevel@tonic-gate zone0.zone_ncpus = 0; 17507c478bd9Sstevel@tonic-gate zone0.zone_ncpus_online = 0; 17517c478bd9Sstevel@tonic-gate zone0.zone_proc_initpid = 1; 17523f2f09c1Sdp zone0.zone_initname = initname; 17530209230bSgjelinek zone0.zone_lockedmem_kstat = NULL; 17540209230bSgjelinek zone0.zone_swapresv_kstat = NULL; 17557c478bd9Sstevel@tonic-gate list_create(&zone0.zone_zsd, sizeof (struct zsd_entry), 17567c478bd9Sstevel@tonic-gate offsetof(struct zsd_entry, zsd_linkage)); 17577c478bd9Sstevel@tonic-gate list_insert_head(&zone_active, &zone0); 17587c478bd9Sstevel@tonic-gate 17597c478bd9Sstevel@tonic-gate /* 17607c478bd9Sstevel@tonic-gate * The root filesystem is not mounted yet, so zone_rootvp cannot be set 17617c478bd9Sstevel@tonic-gate * to anything meaningful. It is assigned to be 'rootdir' in 17627c478bd9Sstevel@tonic-gate * vfs_mountroot(). 17637c478bd9Sstevel@tonic-gate */ 17647c478bd9Sstevel@tonic-gate zone0.zone_rootvp = NULL; 17657c478bd9Sstevel@tonic-gate zone0.zone_vfslist = NULL; 17663f2f09c1Sdp zone0.zone_bootargs = initargs; 17677c478bd9Sstevel@tonic-gate zone0.zone_privset = kmem_alloc(sizeof (priv_set_t), KM_SLEEP); 17687c478bd9Sstevel@tonic-gate /* 17697c478bd9Sstevel@tonic-gate * The global zone has all privileges 17707c478bd9Sstevel@tonic-gate */ 17717c478bd9Sstevel@tonic-gate priv_fillset(zone0.zone_privset); 17727c478bd9Sstevel@tonic-gate /* 17737c478bd9Sstevel@tonic-gate * Add p0 to the global zone 17747c478bd9Sstevel@tonic-gate */ 17757c478bd9Sstevel@tonic-gate zone0.zone_zsched = &p0; 17767c478bd9Sstevel@tonic-gate p0.p_zone = &zone0; 17777c478bd9Sstevel@tonic-gate } 17787c478bd9Sstevel@tonic-gate 177945916cd2Sjpk /* 178045916cd2Sjpk * Compute a hash value based on the contents of the label and the DOI. The 178145916cd2Sjpk * hash algorithm is somewhat arbitrary, but is based on the observation that 178245916cd2Sjpk * humans will likely pick labels that differ by amounts that work out to be 178345916cd2Sjpk * multiples of the number of hash chains, and thus stirring in some primes 178445916cd2Sjpk * should help. 178545916cd2Sjpk */ 178645916cd2Sjpk static uint_t 178745916cd2Sjpk hash_bylabel(void *hdata, mod_hash_key_t key) 178845916cd2Sjpk { 178945916cd2Sjpk const ts_label_t *lab = (ts_label_t *)key; 179045916cd2Sjpk const uint32_t *up, *ue; 179145916cd2Sjpk uint_t hash; 179245916cd2Sjpk int i; 179345916cd2Sjpk 179445916cd2Sjpk _NOTE(ARGUNUSED(hdata)); 179545916cd2Sjpk 179645916cd2Sjpk hash = lab->tsl_doi + (lab->tsl_doi << 1); 179745916cd2Sjpk /* we depend on alignment of label, but not representation */ 179845916cd2Sjpk up = (const uint32_t *)&lab->tsl_label; 179945916cd2Sjpk ue = up + sizeof (lab->tsl_label) / sizeof (*up); 180045916cd2Sjpk i = 1; 180145916cd2Sjpk while (up < ue) { 180245916cd2Sjpk /* using 2^n + 1, 1 <= n <= 16 as source of many primes */ 180345916cd2Sjpk hash += *up + (*up << ((i % 16) + 1)); 180445916cd2Sjpk up++; 180545916cd2Sjpk i++; 180645916cd2Sjpk } 180745916cd2Sjpk return (hash); 180845916cd2Sjpk } 180945916cd2Sjpk 181045916cd2Sjpk /* 181145916cd2Sjpk * All that mod_hash cares about here is zero (equal) versus non-zero (not 181245916cd2Sjpk * equal). This may need to be changed if less than / greater than is ever 181345916cd2Sjpk * needed. 181445916cd2Sjpk */ 181545916cd2Sjpk static int 181645916cd2Sjpk hash_labelkey_cmp(mod_hash_key_t key1, mod_hash_key_t key2) 181745916cd2Sjpk { 181845916cd2Sjpk ts_label_t *lab1 = (ts_label_t *)key1; 181945916cd2Sjpk ts_label_t *lab2 = (ts_label_t *)key2; 182045916cd2Sjpk 182145916cd2Sjpk return (label_equal(lab1, lab2) ? 0 : 1); 182245916cd2Sjpk } 182345916cd2Sjpk 18247c478bd9Sstevel@tonic-gate /* 18257c478bd9Sstevel@tonic-gate * Called by main() to initialize the zones framework. 18267c478bd9Sstevel@tonic-gate */ 18277c478bd9Sstevel@tonic-gate void 18287c478bd9Sstevel@tonic-gate zone_init(void) 18297c478bd9Sstevel@tonic-gate { 18307c478bd9Sstevel@tonic-gate rctl_dict_entry_t *rde; 18317c478bd9Sstevel@tonic-gate rctl_val_t *dval; 18327c478bd9Sstevel@tonic-gate rctl_set_t *set; 18337c478bd9Sstevel@tonic-gate rctl_alloc_gp_t *gp; 18347c478bd9Sstevel@tonic-gate rctl_entity_p_t e; 1835cf8f45c7Sdstaff int res; 18367c478bd9Sstevel@tonic-gate 18377c478bd9Sstevel@tonic-gate ASSERT(curproc == &p0); 18387c478bd9Sstevel@tonic-gate 18397c478bd9Sstevel@tonic-gate /* 18407c478bd9Sstevel@tonic-gate * Create ID space for zone IDs. ID 0 is reserved for the 18417c478bd9Sstevel@tonic-gate * global zone. 18427c478bd9Sstevel@tonic-gate */ 18437c478bd9Sstevel@tonic-gate zoneid_space = id_space_create("zoneid_space", 1, MAX_ZONEID); 18447c478bd9Sstevel@tonic-gate 18457c478bd9Sstevel@tonic-gate /* 18467c478bd9Sstevel@tonic-gate * Initialize generic zone resource controls, if any. 18477c478bd9Sstevel@tonic-gate */ 18487c478bd9Sstevel@tonic-gate rc_zone_cpu_shares = rctl_register("zone.cpu-shares", 18497c478bd9Sstevel@tonic-gate RCENTITY_ZONE, RCTL_GLOBAL_SIGNAL_NEVER | RCTL_GLOBAL_DENY_NEVER | 185019f92332Sml RCTL_GLOBAL_NOBASIC | RCTL_GLOBAL_COUNT | RCTL_GLOBAL_SYSLOG_NEVER, 1851c97ad5cdSakolb FSS_MAXSHARES, FSS_MAXSHARES, &zone_cpu_shares_ops); 1852c97ad5cdSakolb 1853c97ad5cdSakolb rc_zone_cpu_cap = rctl_register("zone.cpu-cap", 1854c97ad5cdSakolb RCENTITY_ZONE, RCTL_GLOBAL_SIGNAL_NEVER | RCTL_GLOBAL_DENY_ALWAYS | 1855c97ad5cdSakolb RCTL_GLOBAL_NOBASIC | RCTL_GLOBAL_COUNT |RCTL_GLOBAL_SYSLOG_NEVER | 1856c97ad5cdSakolb RCTL_GLOBAL_INFINITE, 1857c97ad5cdSakolb MAXCAP, MAXCAP, &zone_cpu_cap_ops); 18587c478bd9Sstevel@tonic-gate 18597c478bd9Sstevel@tonic-gate rc_zone_nlwps = rctl_register("zone.max-lwps", RCENTITY_ZONE, 18607c478bd9Sstevel@tonic-gate RCTL_GLOBAL_NOACTION | RCTL_GLOBAL_NOBASIC | RCTL_GLOBAL_COUNT, 18617c478bd9Sstevel@tonic-gate INT_MAX, INT_MAX, &zone_lwps_ops); 1862824c205fSml /* 1863824c205fSml * System V IPC resource controls 1864824c205fSml */ 1865824c205fSml rc_zone_msgmni = rctl_register("zone.max-msg-ids", 1866824c205fSml RCENTITY_ZONE, RCTL_GLOBAL_DENY_ALWAYS | RCTL_GLOBAL_NOBASIC | 1867824c205fSml RCTL_GLOBAL_COUNT, IPC_IDS_MAX, IPC_IDS_MAX, &zone_msgmni_ops); 1868824c205fSml 1869824c205fSml rc_zone_semmni = rctl_register("zone.max-sem-ids", 1870824c205fSml RCENTITY_ZONE, RCTL_GLOBAL_DENY_ALWAYS | RCTL_GLOBAL_NOBASIC | 1871824c205fSml RCTL_GLOBAL_COUNT, IPC_IDS_MAX, IPC_IDS_MAX, &zone_semmni_ops); 1872824c205fSml 1873824c205fSml rc_zone_shmmni = rctl_register("zone.max-shm-ids", 1874824c205fSml RCENTITY_ZONE, RCTL_GLOBAL_DENY_ALWAYS | RCTL_GLOBAL_NOBASIC | 1875824c205fSml RCTL_GLOBAL_COUNT, IPC_IDS_MAX, IPC_IDS_MAX, &zone_shmmni_ops); 1876824c205fSml 1877824c205fSml rc_zone_shmmax = rctl_register("zone.max-shm-memory", 1878824c205fSml RCENTITY_ZONE, RCTL_GLOBAL_DENY_ALWAYS | RCTL_GLOBAL_NOBASIC | 1879824c205fSml RCTL_GLOBAL_BYTES, UINT64_MAX, UINT64_MAX, &zone_shmmax_ops); 1880824c205fSml 18817c478bd9Sstevel@tonic-gate /* 18827c478bd9Sstevel@tonic-gate * Create a rctl_val with PRIVILEGED, NOACTION, value = 1. Then attach 18837c478bd9Sstevel@tonic-gate * this at the head of the rctl_dict_entry for ``zone.cpu-shares''. 18847c478bd9Sstevel@tonic-gate */ 18857c478bd9Sstevel@tonic-gate dval = kmem_cache_alloc(rctl_val_cache, KM_SLEEP); 18867c478bd9Sstevel@tonic-gate bzero(dval, sizeof (rctl_val_t)); 18877c478bd9Sstevel@tonic-gate dval->rcv_value = 1; 18887c478bd9Sstevel@tonic-gate dval->rcv_privilege = RCPRIV_PRIVILEGED; 18897c478bd9Sstevel@tonic-gate dval->rcv_flagaction = RCTL_LOCAL_NOACTION; 18907c478bd9Sstevel@tonic-gate dval->rcv_action_recip_pid = -1; 18917c478bd9Sstevel@tonic-gate 18927c478bd9Sstevel@tonic-gate rde = rctl_dict_lookup("zone.cpu-shares"); 18937c478bd9Sstevel@tonic-gate (void) rctl_val_list_insert(&rde->rcd_default_value, dval); 18947c478bd9Sstevel@tonic-gate 1895c6939658Ssl rc_zone_locked_mem = rctl_register("zone.max-locked-memory", 1896c6939658Ssl RCENTITY_ZONE, RCTL_GLOBAL_NOBASIC | RCTL_GLOBAL_BYTES | 1897c6939658Ssl RCTL_GLOBAL_DENY_ALWAYS, UINT64_MAX, UINT64_MAX, 1898c6939658Ssl &zone_locked_mem_ops); 18990209230bSgjelinek 19000209230bSgjelinek rc_zone_max_swap = rctl_register("zone.max-swap", 19010209230bSgjelinek RCENTITY_ZONE, RCTL_GLOBAL_NOBASIC | RCTL_GLOBAL_BYTES | 19020209230bSgjelinek RCTL_GLOBAL_DENY_ALWAYS, UINT64_MAX, UINT64_MAX, 19030209230bSgjelinek &zone_max_swap_ops); 19040209230bSgjelinek 19057c478bd9Sstevel@tonic-gate /* 19067c478bd9Sstevel@tonic-gate * Initialize the ``global zone''. 19077c478bd9Sstevel@tonic-gate */ 19087c478bd9Sstevel@tonic-gate set = rctl_set_create(); 19097c478bd9Sstevel@tonic-gate gp = rctl_set_init_prealloc(RCENTITY_ZONE); 19107c478bd9Sstevel@tonic-gate mutex_enter(&p0.p_lock); 19117c478bd9Sstevel@tonic-gate e.rcep_p.zone = &zone0; 19127c478bd9Sstevel@tonic-gate e.rcep_t = RCENTITY_ZONE; 19137c478bd9Sstevel@tonic-gate zone0.zone_rctls = rctl_set_init(RCENTITY_ZONE, &p0, &e, set, 19147c478bd9Sstevel@tonic-gate gp); 19157c478bd9Sstevel@tonic-gate 19167c478bd9Sstevel@tonic-gate zone0.zone_nlwps = p0.p_lwpcnt; 19177c478bd9Sstevel@tonic-gate zone0.zone_ntasks = 1; 19187c478bd9Sstevel@tonic-gate mutex_exit(&p0.p_lock); 19199acbbeafSnn zone0.zone_restart_init = B_TRUE; 19209acbbeafSnn zone0.zone_brand = &native_brand; 19217c478bd9Sstevel@tonic-gate rctl_prealloc_destroy(gp); 19227c478bd9Sstevel@tonic-gate /* 19230209230bSgjelinek * pool_default hasn't been initialized yet, so we let pool_init() 19240209230bSgjelinek * take care of making sure the global zone is in the default pool. 19250209230bSgjelinek */ 19260209230bSgjelinek 19270209230bSgjelinek /* 19280209230bSgjelinek * Initialize global zone kstats 19297c478bd9Sstevel@tonic-gate */ 19300209230bSgjelinek zone_kstat_create(&zone0); 193145916cd2Sjpk 193245916cd2Sjpk /* 193345916cd2Sjpk * Initialize zone label. 193445916cd2Sjpk * mlp are initialized when tnzonecfg is loaded. 193545916cd2Sjpk */ 193645916cd2Sjpk zone0.zone_slabel = l_admin_low; 193745916cd2Sjpk rw_init(&zone0.zone_mlps.mlpl_rwlock, NULL, RW_DEFAULT, NULL); 193845916cd2Sjpk label_hold(l_admin_low); 193945916cd2Sjpk 1940835ee219SRobert Harris /* 1941835ee219SRobert Harris * Initialise the lock for the database structure used by mntfs. 1942835ee219SRobert Harris */ 1943835ee219SRobert Harris rw_init(&zone0.zone_mntfs_db_lock, NULL, RW_DEFAULT, NULL); 1944835ee219SRobert Harris 19457c478bd9Sstevel@tonic-gate mutex_enter(&zonehash_lock); 19467c478bd9Sstevel@tonic-gate zone_uniqid(&zone0); 19477c478bd9Sstevel@tonic-gate ASSERT(zone0.zone_uniqid == GLOBAL_ZONEUNIQID); 194845916cd2Sjpk 19497c478bd9Sstevel@tonic-gate zonehashbyid = mod_hash_create_idhash("zone_by_id", zone_hash_size, 19507c478bd9Sstevel@tonic-gate mod_hash_null_valdtor); 19517c478bd9Sstevel@tonic-gate zonehashbyname = mod_hash_create_strhash("zone_by_name", 19527c478bd9Sstevel@tonic-gate zone_hash_size, mod_hash_null_valdtor); 195345916cd2Sjpk /* 195445916cd2Sjpk * maintain zonehashbylabel only for labeled systems 195545916cd2Sjpk */ 195645916cd2Sjpk if (is_system_labeled()) 195745916cd2Sjpk zonehashbylabel = mod_hash_create_extended("zone_by_label", 195845916cd2Sjpk zone_hash_size, mod_hash_null_keydtor, 195945916cd2Sjpk mod_hash_null_valdtor, hash_bylabel, NULL, 196045916cd2Sjpk hash_labelkey_cmp, KM_SLEEP); 19617c478bd9Sstevel@tonic-gate zonecount = 1; 19627c478bd9Sstevel@tonic-gate 19637c478bd9Sstevel@tonic-gate (void) mod_hash_insert(zonehashbyid, (mod_hash_key_t)GLOBAL_ZONEID, 19647c478bd9Sstevel@tonic-gate (mod_hash_val_t)&zone0); 19657c478bd9Sstevel@tonic-gate (void) mod_hash_insert(zonehashbyname, (mod_hash_key_t)zone0.zone_name, 19667c478bd9Sstevel@tonic-gate (mod_hash_val_t)&zone0); 196748451833Scarlsonj if (is_system_labeled()) { 196848451833Scarlsonj zone0.zone_flags |= ZF_HASHED_LABEL; 196945916cd2Sjpk (void) mod_hash_insert(zonehashbylabel, 197045916cd2Sjpk (mod_hash_key_t)zone0.zone_slabel, (mod_hash_val_t)&zone0); 197148451833Scarlsonj } 197245916cd2Sjpk mutex_exit(&zonehash_lock); 197345916cd2Sjpk 19747c478bd9Sstevel@tonic-gate /* 19757c478bd9Sstevel@tonic-gate * We avoid setting zone_kcred until now, since kcred is initialized 19767c478bd9Sstevel@tonic-gate * sometime after zone_zsd_init() and before zone_init(). 19777c478bd9Sstevel@tonic-gate */ 19787c478bd9Sstevel@tonic-gate zone0.zone_kcred = kcred; 19797c478bd9Sstevel@tonic-gate /* 19807c478bd9Sstevel@tonic-gate * The global zone is fully initialized (except for zone_rootvp which 19817c478bd9Sstevel@tonic-gate * will be set when the root filesystem is mounted). 19827c478bd9Sstevel@tonic-gate */ 19837c478bd9Sstevel@tonic-gate global_zone = &zone0; 1984cf8f45c7Sdstaff 1985cf8f45c7Sdstaff /* 1986cf8f45c7Sdstaff * Setup an event channel to send zone status change notifications on 1987cf8f45c7Sdstaff */ 1988cf8f45c7Sdstaff res = sysevent_evc_bind(ZONE_EVENT_CHANNEL, &zone_event_chan, 1989cf8f45c7Sdstaff EVCH_CREAT); 1990cf8f45c7Sdstaff 1991cf8f45c7Sdstaff if (res) 1992cf8f45c7Sdstaff panic("Sysevent_evc_bind failed during zone setup.\n"); 19930209230bSgjelinek 19947c478bd9Sstevel@tonic-gate } 19957c478bd9Sstevel@tonic-gate 19967c478bd9Sstevel@tonic-gate static void 19977c478bd9Sstevel@tonic-gate zone_free(zone_t *zone) 19987c478bd9Sstevel@tonic-gate { 19997c478bd9Sstevel@tonic-gate ASSERT(zone != global_zone); 20007c478bd9Sstevel@tonic-gate ASSERT(zone->zone_ntasks == 0); 20017c478bd9Sstevel@tonic-gate ASSERT(zone->zone_nlwps == 0); 20027c478bd9Sstevel@tonic-gate ASSERT(zone->zone_cred_ref == 0); 20037c478bd9Sstevel@tonic-gate ASSERT(zone->zone_kcred == NULL); 20047c478bd9Sstevel@tonic-gate ASSERT(zone_status_get(zone) == ZONE_IS_DEAD || 20057c478bd9Sstevel@tonic-gate zone_status_get(zone) == ZONE_IS_UNINITIALIZED); 20067c478bd9Sstevel@tonic-gate 2007c97ad5cdSakolb /* 2008c97ad5cdSakolb * Remove any zone caps. 2009c97ad5cdSakolb */ 2010c97ad5cdSakolb cpucaps_zone_remove(zone); 2011c97ad5cdSakolb 2012c97ad5cdSakolb ASSERT(zone->zone_cpucap == NULL); 2013c97ad5cdSakolb 20147c478bd9Sstevel@tonic-gate /* remove from deathrow list */ 20157c478bd9Sstevel@tonic-gate if (zone_status_get(zone) == ZONE_IS_DEAD) { 20167c478bd9Sstevel@tonic-gate ASSERT(zone->zone_ref == 0); 20177c478bd9Sstevel@tonic-gate mutex_enter(&zone_deathrow_lock); 20187c478bd9Sstevel@tonic-gate list_remove(&zone_deathrow, zone); 20197c478bd9Sstevel@tonic-gate mutex_exit(&zone_deathrow_lock); 20207c478bd9Sstevel@tonic-gate } 20217c478bd9Sstevel@tonic-gate 20227c478bd9Sstevel@tonic-gate zone_free_zsd(zone); 2023fa9e4066Sahrens zone_free_datasets(zone); 20242b24ab6bSSebastien Roy list_destroy(&zone->zone_dl_list); 20257c478bd9Sstevel@tonic-gate 20267c478bd9Sstevel@tonic-gate if (zone->zone_rootvp != NULL) 20277c478bd9Sstevel@tonic-gate VN_RELE(zone->zone_rootvp); 20287c478bd9Sstevel@tonic-gate if (zone->zone_rootpath) 20297c478bd9Sstevel@tonic-gate kmem_free(zone->zone_rootpath, zone->zone_rootpathlen); 20307c478bd9Sstevel@tonic-gate if (zone->zone_name != NULL) 20317c478bd9Sstevel@tonic-gate kmem_free(zone->zone_name, ZONENAME_MAX); 203245916cd2Sjpk if (zone->zone_slabel != NULL) 203345916cd2Sjpk label_rele(zone->zone_slabel); 20347c478bd9Sstevel@tonic-gate if (zone->zone_nodename != NULL) 20357c478bd9Sstevel@tonic-gate kmem_free(zone->zone_nodename, _SYS_NMLN); 20367c478bd9Sstevel@tonic-gate if (zone->zone_domain != NULL) 20377c478bd9Sstevel@tonic-gate kmem_free(zone->zone_domain, _SYS_NMLN); 20387c478bd9Sstevel@tonic-gate if (zone->zone_privset != NULL) 20397c478bd9Sstevel@tonic-gate kmem_free(zone->zone_privset, sizeof (priv_set_t)); 20407c478bd9Sstevel@tonic-gate if (zone->zone_rctls != NULL) 20417c478bd9Sstevel@tonic-gate rctl_set_free(zone->zone_rctls); 20427c478bd9Sstevel@tonic-gate if (zone->zone_bootargs != NULL) 20433f2f09c1Sdp kmem_free(zone->zone_bootargs, strlen(zone->zone_bootargs) + 1); 20443f2f09c1Sdp if (zone->zone_initname != NULL) 20453f2f09c1Sdp kmem_free(zone->zone_initname, strlen(zone->zone_initname) + 1); 2046*134a1f4eSCasper H.S. Dik if (zone->zone_pfexecd != NULL) 2047*134a1f4eSCasper H.S. Dik klpd_freelist(&zone->zone_pfexecd); 20487c478bd9Sstevel@tonic-gate id_free(zoneid_space, zone->zone_id); 20497c478bd9Sstevel@tonic-gate mutex_destroy(&zone->zone_lock); 20507c478bd9Sstevel@tonic-gate cv_destroy(&zone->zone_cv); 205145916cd2Sjpk rw_destroy(&zone->zone_mlps.mlpl_rwlock); 2052835ee219SRobert Harris rw_destroy(&zone->zone_mntfs_db_lock); 20537c478bd9Sstevel@tonic-gate kmem_free(zone, sizeof (zone_t)); 20547c478bd9Sstevel@tonic-gate } 20557c478bd9Sstevel@tonic-gate 20567c478bd9Sstevel@tonic-gate /* 20577c478bd9Sstevel@tonic-gate * See block comment at the top of this file for information about zone 20587c478bd9Sstevel@tonic-gate * status values. 20597c478bd9Sstevel@tonic-gate */ 20607c478bd9Sstevel@tonic-gate /* 20617c478bd9Sstevel@tonic-gate * Convenience function for setting zone status. 20627c478bd9Sstevel@tonic-gate */ 20637c478bd9Sstevel@tonic-gate static void 20647c478bd9Sstevel@tonic-gate zone_status_set(zone_t *zone, zone_status_t status) 20657c478bd9Sstevel@tonic-gate { 2066cf8f45c7Sdstaff 2067cf8f45c7Sdstaff nvlist_t *nvl = NULL; 20687c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&zone_status_lock)); 20697c478bd9Sstevel@tonic-gate ASSERT(status > ZONE_MIN_STATE && status <= ZONE_MAX_STATE && 20707c478bd9Sstevel@tonic-gate status >= zone_status_get(zone)); 2071cf8f45c7Sdstaff 2072cf8f45c7Sdstaff if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, KM_SLEEP) || 2073cf8f45c7Sdstaff nvlist_add_string(nvl, ZONE_CB_NAME, zone->zone_name) || 2074cf8f45c7Sdstaff nvlist_add_string(nvl, ZONE_CB_NEWSTATE, 20753f2f09c1Sdp zone_status_table[status]) || 2076cf8f45c7Sdstaff nvlist_add_string(nvl, ZONE_CB_OLDSTATE, 20773f2f09c1Sdp zone_status_table[zone->zone_status]) || 2078cf8f45c7Sdstaff nvlist_add_int32(nvl, ZONE_CB_ZONEID, zone->zone_id) || 2079cf8f45c7Sdstaff nvlist_add_uint64(nvl, ZONE_CB_TIMESTAMP, (uint64_t)gethrtime()) || 2080cf8f45c7Sdstaff sysevent_evc_publish(zone_event_chan, ZONE_EVENT_STATUS_CLASS, 20813f2f09c1Sdp ZONE_EVENT_STATUS_SUBCLASS, "sun.com", "kernel", nvl, EVCH_SLEEP)) { 2082cf8f45c7Sdstaff #ifdef DEBUG 2083cf8f45c7Sdstaff (void) printf( 2084cf8f45c7Sdstaff "Failed to allocate and send zone state change event.\n"); 2085cf8f45c7Sdstaff #endif 2086cf8f45c7Sdstaff } 2087cf8f45c7Sdstaff nvlist_free(nvl); 2088cf8f45c7Sdstaff 20897c478bd9Sstevel@tonic-gate zone->zone_status = status; 2090cf8f45c7Sdstaff 20917c478bd9Sstevel@tonic-gate cv_broadcast(&zone->zone_cv); 20927c478bd9Sstevel@tonic-gate } 20937c478bd9Sstevel@tonic-gate 20947c478bd9Sstevel@tonic-gate /* 20957c478bd9Sstevel@tonic-gate * Public function to retrieve the zone status. The zone status may 20967c478bd9Sstevel@tonic-gate * change after it is retrieved. 20977c478bd9Sstevel@tonic-gate */ 20987c478bd9Sstevel@tonic-gate zone_status_t 20997c478bd9Sstevel@tonic-gate zone_status_get(zone_t *zone) 21007c478bd9Sstevel@tonic-gate { 21017c478bd9Sstevel@tonic-gate return (zone->zone_status); 21027c478bd9Sstevel@tonic-gate } 21037c478bd9Sstevel@tonic-gate 21047c478bd9Sstevel@tonic-gate static int 21057c478bd9Sstevel@tonic-gate zone_set_bootargs(zone_t *zone, const char *zone_bootargs) 21067c478bd9Sstevel@tonic-gate { 21073f2f09c1Sdp char *bootargs = kmem_zalloc(BOOTARGS_MAX, KM_SLEEP); 21083f2f09c1Sdp int err = 0; 21093f2f09c1Sdp 21103f2f09c1Sdp ASSERT(zone != global_zone); 21113f2f09c1Sdp if ((err = copyinstr(zone_bootargs, bootargs, BOOTARGS_MAX, NULL)) != 0) 21123f2f09c1Sdp goto done; /* EFAULT or ENAMETOOLONG */ 21133f2f09c1Sdp 21143f2f09c1Sdp if (zone->zone_bootargs != NULL) 21153f2f09c1Sdp kmem_free(zone->zone_bootargs, strlen(zone->zone_bootargs) + 1); 21163f2f09c1Sdp 21173f2f09c1Sdp zone->zone_bootargs = kmem_alloc(strlen(bootargs) + 1, KM_SLEEP); 21183f2f09c1Sdp (void) strcpy(zone->zone_bootargs, bootargs); 21193f2f09c1Sdp 21203f2f09c1Sdp done: 21213f2f09c1Sdp kmem_free(bootargs, BOOTARGS_MAX); 21223f2f09c1Sdp return (err); 21233f2f09c1Sdp } 21243f2f09c1Sdp 212559f2ff5cSedp static int 212659f2ff5cSedp zone_set_brand(zone_t *zone, const char *brand) 212759f2ff5cSedp { 212859f2ff5cSedp struct brand_attr *attrp; 212959f2ff5cSedp brand_t *bp; 213059f2ff5cSedp 213159f2ff5cSedp attrp = kmem_alloc(sizeof (struct brand_attr), KM_SLEEP); 213259f2ff5cSedp if (copyin(brand, attrp, sizeof (struct brand_attr)) != 0) { 213359f2ff5cSedp kmem_free(attrp, sizeof (struct brand_attr)); 213459f2ff5cSedp return (EFAULT); 213559f2ff5cSedp } 213659f2ff5cSedp 213759f2ff5cSedp bp = brand_register_zone(attrp); 213859f2ff5cSedp kmem_free(attrp, sizeof (struct brand_attr)); 213959f2ff5cSedp if (bp == NULL) 214059f2ff5cSedp return (EINVAL); 214159f2ff5cSedp 214259f2ff5cSedp /* 214359f2ff5cSedp * This is the only place where a zone can change it's brand. 214459f2ff5cSedp * We already need to hold zone_status_lock to check the zone 214559f2ff5cSedp * status, so we'll just use that lock to serialize zone 214659f2ff5cSedp * branding requests as well. 214759f2ff5cSedp */ 214859f2ff5cSedp mutex_enter(&zone_status_lock); 214959f2ff5cSedp 215059f2ff5cSedp /* Re-Branding is not allowed and the zone can't be booted yet */ 215159f2ff5cSedp if ((ZONE_IS_BRANDED(zone)) || 215259f2ff5cSedp (zone_status_get(zone) >= ZONE_IS_BOOTING)) { 215359f2ff5cSedp mutex_exit(&zone_status_lock); 215459f2ff5cSedp brand_unregister_zone(bp); 215559f2ff5cSedp return (EINVAL); 215659f2ff5cSedp } 215759f2ff5cSedp 2158319378d9Seh /* set up the brand specific data */ 215959f2ff5cSedp zone->zone_brand = bp; 2160319378d9Seh ZBROP(zone)->b_init_brand_data(zone); 2161319378d9Seh 216259f2ff5cSedp mutex_exit(&zone_status_lock); 216359f2ff5cSedp return (0); 216459f2ff5cSedp } 216559f2ff5cSedp 21663f2f09c1Sdp static int 21673f2f09c1Sdp zone_set_initname(zone_t *zone, const char *zone_initname) 21683f2f09c1Sdp { 21693f2f09c1Sdp char initname[INITNAME_SZ]; 21707c478bd9Sstevel@tonic-gate size_t len; 21713f2f09c1Sdp int err = 0; 21727c478bd9Sstevel@tonic-gate 21733f2f09c1Sdp ASSERT(zone != global_zone); 21743f2f09c1Sdp if ((err = copyinstr(zone_initname, initname, INITNAME_SZ, &len)) != 0) 21757c478bd9Sstevel@tonic-gate return (err); /* EFAULT or ENAMETOOLONG */ 21767c478bd9Sstevel@tonic-gate 21773f2f09c1Sdp if (zone->zone_initname != NULL) 21783f2f09c1Sdp kmem_free(zone->zone_initname, strlen(zone->zone_initname) + 1); 21793f2f09c1Sdp 21803f2f09c1Sdp zone->zone_initname = kmem_alloc(strlen(initname) + 1, KM_SLEEP); 21813f2f09c1Sdp (void) strcpy(zone->zone_initname, initname); 21827c478bd9Sstevel@tonic-gate return (0); 21837c478bd9Sstevel@tonic-gate } 21847c478bd9Sstevel@tonic-gate 21850209230bSgjelinek static int 21860209230bSgjelinek zone_set_phys_mcap(zone_t *zone, const uint64_t *zone_mcap) 21870209230bSgjelinek { 21880209230bSgjelinek uint64_t mcap; 21890209230bSgjelinek int err = 0; 21900209230bSgjelinek 21910209230bSgjelinek if ((err = copyin(zone_mcap, &mcap, sizeof (uint64_t))) == 0) 21920209230bSgjelinek zone->zone_phys_mcap = mcap; 21930209230bSgjelinek 21940209230bSgjelinek return (err); 21950209230bSgjelinek } 21960209230bSgjelinek 21970209230bSgjelinek static int 21980209230bSgjelinek zone_set_sched_class(zone_t *zone, const char *new_class) 21990209230bSgjelinek { 22000209230bSgjelinek char sched_class[PC_CLNMSZ]; 22010209230bSgjelinek id_t classid; 22020209230bSgjelinek int err; 22030209230bSgjelinek 22040209230bSgjelinek ASSERT(zone != global_zone); 22050209230bSgjelinek if ((err = copyinstr(new_class, sched_class, PC_CLNMSZ, NULL)) != 0) 22060209230bSgjelinek return (err); /* EFAULT or ENAMETOOLONG */ 22070209230bSgjelinek 220835a5a358SJonathan Adams if (getcid(sched_class, &classid) != 0 || CLASS_KERNEL(classid)) 22090209230bSgjelinek return (set_errno(EINVAL)); 22100209230bSgjelinek zone->zone_defaultcid = classid; 22110209230bSgjelinek ASSERT(zone->zone_defaultcid > 0 && 22120209230bSgjelinek zone->zone_defaultcid < loaded_classes); 22130209230bSgjelinek 22140209230bSgjelinek return (0); 22150209230bSgjelinek } 22160209230bSgjelinek 22177c478bd9Sstevel@tonic-gate /* 22187c478bd9Sstevel@tonic-gate * Block indefinitely waiting for (zone_status >= status) 22197c478bd9Sstevel@tonic-gate */ 22207c478bd9Sstevel@tonic-gate void 22217c478bd9Sstevel@tonic-gate zone_status_wait(zone_t *zone, zone_status_t status) 22227c478bd9Sstevel@tonic-gate { 22237c478bd9Sstevel@tonic-gate ASSERT(status > ZONE_MIN_STATE && status <= ZONE_MAX_STATE); 22247c478bd9Sstevel@tonic-gate 22257c478bd9Sstevel@tonic-gate mutex_enter(&zone_status_lock); 22267c478bd9Sstevel@tonic-gate while (zone->zone_status < status) { 22277c478bd9Sstevel@tonic-gate cv_wait(&zone->zone_cv, &zone_status_lock); 22287c478bd9Sstevel@tonic-gate } 22297c478bd9Sstevel@tonic-gate mutex_exit(&zone_status_lock); 22307c478bd9Sstevel@tonic-gate } 22317c478bd9Sstevel@tonic-gate 22327c478bd9Sstevel@tonic-gate /* 22337c478bd9Sstevel@tonic-gate * Private CPR-safe version of zone_status_wait(). 22347c478bd9Sstevel@tonic-gate */ 22357c478bd9Sstevel@tonic-gate static void 22367c478bd9Sstevel@tonic-gate zone_status_wait_cpr(zone_t *zone, zone_status_t status, char *str) 22377c478bd9Sstevel@tonic-gate { 22387c478bd9Sstevel@tonic-gate callb_cpr_t cprinfo; 22397c478bd9Sstevel@tonic-gate 22407c478bd9Sstevel@tonic-gate ASSERT(status > ZONE_MIN_STATE && status <= ZONE_MAX_STATE); 22417c478bd9Sstevel@tonic-gate 22427c478bd9Sstevel@tonic-gate CALLB_CPR_INIT(&cprinfo, &zone_status_lock, callb_generic_cpr, 22437c478bd9Sstevel@tonic-gate str); 22447c478bd9Sstevel@tonic-gate mutex_enter(&zone_status_lock); 22457c478bd9Sstevel@tonic-gate while (zone->zone_status < status) { 22467c478bd9Sstevel@tonic-gate CALLB_CPR_SAFE_BEGIN(&cprinfo); 22477c478bd9Sstevel@tonic-gate cv_wait(&zone->zone_cv, &zone_status_lock); 22487c478bd9Sstevel@tonic-gate CALLB_CPR_SAFE_END(&cprinfo, &zone_status_lock); 22497c478bd9Sstevel@tonic-gate } 22507c478bd9Sstevel@tonic-gate /* 22517c478bd9Sstevel@tonic-gate * zone_status_lock is implicitly released by the following. 22527c478bd9Sstevel@tonic-gate */ 22537c478bd9Sstevel@tonic-gate CALLB_CPR_EXIT(&cprinfo); 22547c478bd9Sstevel@tonic-gate } 22557c478bd9Sstevel@tonic-gate 22567c478bd9Sstevel@tonic-gate /* 22577c478bd9Sstevel@tonic-gate * Block until zone enters requested state or signal is received. Return (0) 22587c478bd9Sstevel@tonic-gate * if signaled, non-zero otherwise. 22597c478bd9Sstevel@tonic-gate */ 22607c478bd9Sstevel@tonic-gate int 22617c478bd9Sstevel@tonic-gate zone_status_wait_sig(zone_t *zone, zone_status_t status) 22627c478bd9Sstevel@tonic-gate { 22637c478bd9Sstevel@tonic-gate ASSERT(status > ZONE_MIN_STATE && status <= ZONE_MAX_STATE); 22647c478bd9Sstevel@tonic-gate 22657c478bd9Sstevel@tonic-gate mutex_enter(&zone_status_lock); 22667c478bd9Sstevel@tonic-gate while (zone->zone_status < status) { 22677c478bd9Sstevel@tonic-gate if (!cv_wait_sig(&zone->zone_cv, &zone_status_lock)) { 22687c478bd9Sstevel@tonic-gate mutex_exit(&zone_status_lock); 22697c478bd9Sstevel@tonic-gate return (0); 22707c478bd9Sstevel@tonic-gate } 22717c478bd9Sstevel@tonic-gate } 22727c478bd9Sstevel@tonic-gate mutex_exit(&zone_status_lock); 22737c478bd9Sstevel@tonic-gate return (1); 22747c478bd9Sstevel@tonic-gate } 22757c478bd9Sstevel@tonic-gate 22767c478bd9Sstevel@tonic-gate /* 22777c478bd9Sstevel@tonic-gate * Block until the zone enters the requested state or the timeout expires, 22787c478bd9Sstevel@tonic-gate * whichever happens first. Return (-1) if operation timed out, time remaining 22797c478bd9Sstevel@tonic-gate * otherwise. 22807c478bd9Sstevel@tonic-gate */ 22817c478bd9Sstevel@tonic-gate clock_t 22827c478bd9Sstevel@tonic-gate zone_status_timedwait(zone_t *zone, clock_t tim, zone_status_t status) 22837c478bd9Sstevel@tonic-gate { 22847c478bd9Sstevel@tonic-gate clock_t timeleft = 0; 22857c478bd9Sstevel@tonic-gate 22867c478bd9Sstevel@tonic-gate ASSERT(status > ZONE_MIN_STATE && status <= ZONE_MAX_STATE); 22877c478bd9Sstevel@tonic-gate 22887c478bd9Sstevel@tonic-gate mutex_enter(&zone_status_lock); 22897c478bd9Sstevel@tonic-gate while (zone->zone_status < status && timeleft != -1) { 22907c478bd9Sstevel@tonic-gate timeleft = cv_timedwait(&zone->zone_cv, &zone_status_lock, tim); 22917c478bd9Sstevel@tonic-gate } 22927c478bd9Sstevel@tonic-gate mutex_exit(&zone_status_lock); 22937c478bd9Sstevel@tonic-gate return (timeleft); 22947c478bd9Sstevel@tonic-gate } 22957c478bd9Sstevel@tonic-gate 22967c478bd9Sstevel@tonic-gate /* 22977c478bd9Sstevel@tonic-gate * Block until the zone enters the requested state, the current process is 22987c478bd9Sstevel@tonic-gate * signaled, or the timeout expires, whichever happens first. Return (-1) if 22997c478bd9Sstevel@tonic-gate * operation timed out, 0 if signaled, time remaining otherwise. 23007c478bd9Sstevel@tonic-gate */ 23017c478bd9Sstevel@tonic-gate clock_t 23027c478bd9Sstevel@tonic-gate zone_status_timedwait_sig(zone_t *zone, clock_t tim, zone_status_t status) 23037c478bd9Sstevel@tonic-gate { 2304d3d50737SRafael Vanoni clock_t timeleft = tim - ddi_get_lbolt(); 23057c478bd9Sstevel@tonic-gate 23067c478bd9Sstevel@tonic-gate ASSERT(status > ZONE_MIN_STATE && status <= ZONE_MAX_STATE); 23077c478bd9Sstevel@tonic-gate 23087c478bd9Sstevel@tonic-gate mutex_enter(&zone_status_lock); 23097c478bd9Sstevel@tonic-gate while (zone->zone_status < status) { 23107c478bd9Sstevel@tonic-gate timeleft = cv_timedwait_sig(&zone->zone_cv, &zone_status_lock, 23117c478bd9Sstevel@tonic-gate tim); 23127c478bd9Sstevel@tonic-gate if (timeleft <= 0) 23137c478bd9Sstevel@tonic-gate break; 23147c478bd9Sstevel@tonic-gate } 23157c478bd9Sstevel@tonic-gate mutex_exit(&zone_status_lock); 23167c478bd9Sstevel@tonic-gate return (timeleft); 23177c478bd9Sstevel@tonic-gate } 23187c478bd9Sstevel@tonic-gate 23197c478bd9Sstevel@tonic-gate /* 23207c478bd9Sstevel@tonic-gate * Zones have two reference counts: one for references from credential 23217c478bd9Sstevel@tonic-gate * structures (zone_cred_ref), and one (zone_ref) for everything else. 23227c478bd9Sstevel@tonic-gate * This is so we can allow a zone to be rebooted while there are still 23237c478bd9Sstevel@tonic-gate * outstanding cred references, since certain drivers cache dblks (which 23247c478bd9Sstevel@tonic-gate * implicitly results in cached creds). We wait for zone_ref to drop to 23257c478bd9Sstevel@tonic-gate * 0 (actually 1), but not zone_cred_ref. The zone structure itself is 23267c478bd9Sstevel@tonic-gate * later freed when the zone_cred_ref drops to 0, though nothing other 23277c478bd9Sstevel@tonic-gate * than the zone id and privilege set should be accessed once the zone 23287c478bd9Sstevel@tonic-gate * is "dead". 23297c478bd9Sstevel@tonic-gate * 23307c478bd9Sstevel@tonic-gate * A debugging flag, zone_wait_for_cred, can be set to a non-zero value 23317c478bd9Sstevel@tonic-gate * to force halt/reboot to block waiting for the zone_cred_ref to drop 23327c478bd9Sstevel@tonic-gate * to 0. This can be useful to flush out other sources of cached creds 23337c478bd9Sstevel@tonic-gate * that may be less innocuous than the driver case. 23347c478bd9Sstevel@tonic-gate */ 23357c478bd9Sstevel@tonic-gate 23367c478bd9Sstevel@tonic-gate int zone_wait_for_cred = 0; 23377c478bd9Sstevel@tonic-gate 23387c478bd9Sstevel@tonic-gate static void 23397c478bd9Sstevel@tonic-gate zone_hold_locked(zone_t *z) 23407c478bd9Sstevel@tonic-gate { 23417c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&z->zone_lock)); 23427c478bd9Sstevel@tonic-gate z->zone_ref++; 23437c478bd9Sstevel@tonic-gate ASSERT(z->zone_ref != 0); 23447c478bd9Sstevel@tonic-gate } 23457c478bd9Sstevel@tonic-gate 23467c478bd9Sstevel@tonic-gate void 23477c478bd9Sstevel@tonic-gate zone_hold(zone_t *z) 23487c478bd9Sstevel@tonic-gate { 23497c478bd9Sstevel@tonic-gate mutex_enter(&z->zone_lock); 23507c478bd9Sstevel@tonic-gate zone_hold_locked(z); 23517c478bd9Sstevel@tonic-gate mutex_exit(&z->zone_lock); 23527c478bd9Sstevel@tonic-gate } 23537c478bd9Sstevel@tonic-gate 23547c478bd9Sstevel@tonic-gate /* 23557c478bd9Sstevel@tonic-gate * If the non-cred ref count drops to 1 and either the cred ref count 23567c478bd9Sstevel@tonic-gate * is 0 or we aren't waiting for cred references, the zone is ready to 23577c478bd9Sstevel@tonic-gate * be destroyed. 23587c478bd9Sstevel@tonic-gate */ 23597c478bd9Sstevel@tonic-gate #define ZONE_IS_UNREF(zone) ((zone)->zone_ref == 1 && \ 23607c478bd9Sstevel@tonic-gate (!zone_wait_for_cred || (zone)->zone_cred_ref == 0)) 23617c478bd9Sstevel@tonic-gate 23627c478bd9Sstevel@tonic-gate void 23637c478bd9Sstevel@tonic-gate zone_rele(zone_t *z) 23647c478bd9Sstevel@tonic-gate { 23657c478bd9Sstevel@tonic-gate boolean_t wakeup; 23667c478bd9Sstevel@tonic-gate 23677c478bd9Sstevel@tonic-gate mutex_enter(&z->zone_lock); 23687c478bd9Sstevel@tonic-gate ASSERT(z->zone_ref != 0); 23697c478bd9Sstevel@tonic-gate z->zone_ref--; 23707c478bd9Sstevel@tonic-gate if (z->zone_ref == 0 && z->zone_cred_ref == 0) { 23717c478bd9Sstevel@tonic-gate /* no more refs, free the structure */ 23727c478bd9Sstevel@tonic-gate mutex_exit(&z->zone_lock); 23737c478bd9Sstevel@tonic-gate zone_free(z); 23747c478bd9Sstevel@tonic-gate return; 23757c478bd9Sstevel@tonic-gate } 23767c478bd9Sstevel@tonic-gate /* signal zone_destroy so the zone can finish halting */ 23777c478bd9Sstevel@tonic-gate wakeup = (ZONE_IS_UNREF(z) && zone_status_get(z) >= ZONE_IS_DEAD); 23787c478bd9Sstevel@tonic-gate mutex_exit(&z->zone_lock); 23797c478bd9Sstevel@tonic-gate 23807c478bd9Sstevel@tonic-gate if (wakeup) { 23817c478bd9Sstevel@tonic-gate /* 23827c478bd9Sstevel@tonic-gate * Grabbing zonehash_lock here effectively synchronizes with 23837c478bd9Sstevel@tonic-gate * zone_destroy() to avoid missed signals. 23847c478bd9Sstevel@tonic-gate */ 23857c478bd9Sstevel@tonic-gate mutex_enter(&zonehash_lock); 23867c478bd9Sstevel@tonic-gate cv_broadcast(&zone_destroy_cv); 23877c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 23887c478bd9Sstevel@tonic-gate } 23897c478bd9Sstevel@tonic-gate } 23907c478bd9Sstevel@tonic-gate 23917c478bd9Sstevel@tonic-gate void 23927c478bd9Sstevel@tonic-gate zone_cred_hold(zone_t *z) 23937c478bd9Sstevel@tonic-gate { 23947c478bd9Sstevel@tonic-gate mutex_enter(&z->zone_lock); 23957c478bd9Sstevel@tonic-gate z->zone_cred_ref++; 23967c478bd9Sstevel@tonic-gate ASSERT(z->zone_cred_ref != 0); 23977c478bd9Sstevel@tonic-gate mutex_exit(&z->zone_lock); 23987c478bd9Sstevel@tonic-gate } 23997c478bd9Sstevel@tonic-gate 24007c478bd9Sstevel@tonic-gate void 24017c478bd9Sstevel@tonic-gate zone_cred_rele(zone_t *z) 24027c478bd9Sstevel@tonic-gate { 24037c478bd9Sstevel@tonic-gate boolean_t wakeup; 24047c478bd9Sstevel@tonic-gate 24057c478bd9Sstevel@tonic-gate mutex_enter(&z->zone_lock); 24067c478bd9Sstevel@tonic-gate ASSERT(z->zone_cred_ref != 0); 24077c478bd9Sstevel@tonic-gate z->zone_cred_ref--; 24087c478bd9Sstevel@tonic-gate if (z->zone_ref == 0 && z->zone_cred_ref == 0) { 24097c478bd9Sstevel@tonic-gate /* no more refs, free the structure */ 24107c478bd9Sstevel@tonic-gate mutex_exit(&z->zone_lock); 24117c478bd9Sstevel@tonic-gate zone_free(z); 24127c478bd9Sstevel@tonic-gate return; 24137c478bd9Sstevel@tonic-gate } 24147c478bd9Sstevel@tonic-gate /* 24157c478bd9Sstevel@tonic-gate * If zone_destroy is waiting for the cred references to drain 24167c478bd9Sstevel@tonic-gate * out, and they have, signal it. 24177c478bd9Sstevel@tonic-gate */ 24187c478bd9Sstevel@tonic-gate wakeup = (zone_wait_for_cred && ZONE_IS_UNREF(z) && 24197c478bd9Sstevel@tonic-gate zone_status_get(z) >= ZONE_IS_DEAD); 24207c478bd9Sstevel@tonic-gate mutex_exit(&z->zone_lock); 24217c478bd9Sstevel@tonic-gate 24227c478bd9Sstevel@tonic-gate if (wakeup) { 24237c478bd9Sstevel@tonic-gate /* 24247c478bd9Sstevel@tonic-gate * Grabbing zonehash_lock here effectively synchronizes with 24257c478bd9Sstevel@tonic-gate * zone_destroy() to avoid missed signals. 24267c478bd9Sstevel@tonic-gate */ 24277c478bd9Sstevel@tonic-gate mutex_enter(&zonehash_lock); 24287c478bd9Sstevel@tonic-gate cv_broadcast(&zone_destroy_cv); 24297c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 24307c478bd9Sstevel@tonic-gate } 24317c478bd9Sstevel@tonic-gate } 24327c478bd9Sstevel@tonic-gate 24337c478bd9Sstevel@tonic-gate void 24347c478bd9Sstevel@tonic-gate zone_task_hold(zone_t *z) 24357c478bd9Sstevel@tonic-gate { 24367c478bd9Sstevel@tonic-gate mutex_enter(&z->zone_lock); 24377c478bd9Sstevel@tonic-gate z->zone_ntasks++; 24387c478bd9Sstevel@tonic-gate ASSERT(z->zone_ntasks != 0); 24397c478bd9Sstevel@tonic-gate mutex_exit(&z->zone_lock); 24407c478bd9Sstevel@tonic-gate } 24417c478bd9Sstevel@tonic-gate 24427c478bd9Sstevel@tonic-gate void 24437c478bd9Sstevel@tonic-gate zone_task_rele(zone_t *zone) 24447c478bd9Sstevel@tonic-gate { 24457c478bd9Sstevel@tonic-gate uint_t refcnt; 24467c478bd9Sstevel@tonic-gate 24477c478bd9Sstevel@tonic-gate mutex_enter(&zone->zone_lock); 24487c478bd9Sstevel@tonic-gate ASSERT(zone->zone_ntasks != 0); 24497c478bd9Sstevel@tonic-gate refcnt = --zone->zone_ntasks; 24507c478bd9Sstevel@tonic-gate if (refcnt > 1) { /* Common case */ 24517c478bd9Sstevel@tonic-gate mutex_exit(&zone->zone_lock); 24527c478bd9Sstevel@tonic-gate return; 24537c478bd9Sstevel@tonic-gate } 24547c478bd9Sstevel@tonic-gate zone_hold_locked(zone); /* so we can use the zone_t later */ 24557c478bd9Sstevel@tonic-gate mutex_exit(&zone->zone_lock); 24567c478bd9Sstevel@tonic-gate if (refcnt == 1) { 24577c478bd9Sstevel@tonic-gate /* 24587c478bd9Sstevel@tonic-gate * See if the zone is shutting down. 24597c478bd9Sstevel@tonic-gate */ 24607c478bd9Sstevel@tonic-gate mutex_enter(&zone_status_lock); 24617c478bd9Sstevel@tonic-gate if (zone_status_get(zone) != ZONE_IS_SHUTTING_DOWN) { 24627c478bd9Sstevel@tonic-gate goto out; 24637c478bd9Sstevel@tonic-gate } 24647c478bd9Sstevel@tonic-gate 24657c478bd9Sstevel@tonic-gate /* 24667c478bd9Sstevel@tonic-gate * Make sure the ntasks didn't change since we 24677c478bd9Sstevel@tonic-gate * dropped zone_lock. 24687c478bd9Sstevel@tonic-gate */ 24697c478bd9Sstevel@tonic-gate mutex_enter(&zone->zone_lock); 24707c478bd9Sstevel@tonic-gate if (refcnt != zone->zone_ntasks) { 24717c478bd9Sstevel@tonic-gate mutex_exit(&zone->zone_lock); 24727c478bd9Sstevel@tonic-gate goto out; 24737c478bd9Sstevel@tonic-gate } 24747c478bd9Sstevel@tonic-gate mutex_exit(&zone->zone_lock); 24757c478bd9Sstevel@tonic-gate 24767c478bd9Sstevel@tonic-gate /* 24777c478bd9Sstevel@tonic-gate * No more user processes in the zone. The zone is empty. 24787c478bd9Sstevel@tonic-gate */ 24797c478bd9Sstevel@tonic-gate zone_status_set(zone, ZONE_IS_EMPTY); 24807c478bd9Sstevel@tonic-gate goto out; 24817c478bd9Sstevel@tonic-gate } 24827c478bd9Sstevel@tonic-gate 24837c478bd9Sstevel@tonic-gate ASSERT(refcnt == 0); 24847c478bd9Sstevel@tonic-gate /* 24857c478bd9Sstevel@tonic-gate * zsched has exited; the zone is dead. 24867c478bd9Sstevel@tonic-gate */ 24877c478bd9Sstevel@tonic-gate zone->zone_zsched = NULL; /* paranoia */ 24887c478bd9Sstevel@tonic-gate mutex_enter(&zone_status_lock); 24897c478bd9Sstevel@tonic-gate zone_status_set(zone, ZONE_IS_DEAD); 24907c478bd9Sstevel@tonic-gate out: 24917c478bd9Sstevel@tonic-gate mutex_exit(&zone_status_lock); 24927c478bd9Sstevel@tonic-gate zone_rele(zone); 24937c478bd9Sstevel@tonic-gate } 24947c478bd9Sstevel@tonic-gate 24957c478bd9Sstevel@tonic-gate zoneid_t 24967c478bd9Sstevel@tonic-gate getzoneid(void) 24977c478bd9Sstevel@tonic-gate { 24987c478bd9Sstevel@tonic-gate return (curproc->p_zone->zone_id); 24997c478bd9Sstevel@tonic-gate } 25007c478bd9Sstevel@tonic-gate 25017c478bd9Sstevel@tonic-gate /* 25027c478bd9Sstevel@tonic-gate * Internal versions of zone_find_by_*(). These don't zone_hold() or 25037c478bd9Sstevel@tonic-gate * check the validity of a zone's state. 25047c478bd9Sstevel@tonic-gate */ 25057c478bd9Sstevel@tonic-gate static zone_t * 25067c478bd9Sstevel@tonic-gate zone_find_all_by_id(zoneid_t zoneid) 25077c478bd9Sstevel@tonic-gate { 25087c478bd9Sstevel@tonic-gate mod_hash_val_t hv; 25097c478bd9Sstevel@tonic-gate zone_t *zone = NULL; 25107c478bd9Sstevel@tonic-gate 25117c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&zonehash_lock)); 25127c478bd9Sstevel@tonic-gate 25137c478bd9Sstevel@tonic-gate if (mod_hash_find(zonehashbyid, 25147c478bd9Sstevel@tonic-gate (mod_hash_key_t)(uintptr_t)zoneid, &hv) == 0) 25157c478bd9Sstevel@tonic-gate zone = (zone_t *)hv; 25167c478bd9Sstevel@tonic-gate return (zone); 25177c478bd9Sstevel@tonic-gate } 25187c478bd9Sstevel@tonic-gate 251945916cd2Sjpk static zone_t * 252045916cd2Sjpk zone_find_all_by_label(const ts_label_t *label) 252145916cd2Sjpk { 252245916cd2Sjpk mod_hash_val_t hv; 252345916cd2Sjpk zone_t *zone = NULL; 252445916cd2Sjpk 252545916cd2Sjpk ASSERT(MUTEX_HELD(&zonehash_lock)); 252645916cd2Sjpk 252745916cd2Sjpk /* 252845916cd2Sjpk * zonehashbylabel is not maintained for unlabeled systems 252945916cd2Sjpk */ 253045916cd2Sjpk if (!is_system_labeled()) 253145916cd2Sjpk return (NULL); 253245916cd2Sjpk if (mod_hash_find(zonehashbylabel, (mod_hash_key_t)label, &hv) == 0) 253345916cd2Sjpk zone = (zone_t *)hv; 253445916cd2Sjpk return (zone); 253545916cd2Sjpk } 253645916cd2Sjpk 25377c478bd9Sstevel@tonic-gate static zone_t * 25387c478bd9Sstevel@tonic-gate zone_find_all_by_name(char *name) 25397c478bd9Sstevel@tonic-gate { 25407c478bd9Sstevel@tonic-gate mod_hash_val_t hv; 25417c478bd9Sstevel@tonic-gate zone_t *zone = NULL; 25427c478bd9Sstevel@tonic-gate 25437c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&zonehash_lock)); 25447c478bd9Sstevel@tonic-gate 25457c478bd9Sstevel@tonic-gate if (mod_hash_find(zonehashbyname, (mod_hash_key_t)name, &hv) == 0) 25467c478bd9Sstevel@tonic-gate zone = (zone_t *)hv; 25477c478bd9Sstevel@tonic-gate return (zone); 25487c478bd9Sstevel@tonic-gate } 25497c478bd9Sstevel@tonic-gate 25507c478bd9Sstevel@tonic-gate /* 25517c478bd9Sstevel@tonic-gate * Public interface for looking up a zone by zoneid. Only returns the zone if 25527c478bd9Sstevel@tonic-gate * it is fully initialized, and has not yet begun the zone_destroy() sequence. 25537c478bd9Sstevel@tonic-gate * Caller must call zone_rele() once it is done with the zone. 25547c478bd9Sstevel@tonic-gate * 25557c478bd9Sstevel@tonic-gate * The zone may begin the zone_destroy() sequence immediately after this 25567c478bd9Sstevel@tonic-gate * function returns, but may be safely used until zone_rele() is called. 25577c478bd9Sstevel@tonic-gate */ 25587c478bd9Sstevel@tonic-gate zone_t * 25597c478bd9Sstevel@tonic-gate zone_find_by_id(zoneid_t zoneid) 25607c478bd9Sstevel@tonic-gate { 25617c478bd9Sstevel@tonic-gate zone_t *zone; 25627c478bd9Sstevel@tonic-gate zone_status_t status; 25637c478bd9Sstevel@tonic-gate 25647c478bd9Sstevel@tonic-gate mutex_enter(&zonehash_lock); 25657c478bd9Sstevel@tonic-gate if ((zone = zone_find_all_by_id(zoneid)) == NULL) { 25667c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 25677c478bd9Sstevel@tonic-gate return (NULL); 25687c478bd9Sstevel@tonic-gate } 25697c478bd9Sstevel@tonic-gate status = zone_status_get(zone); 25707c478bd9Sstevel@tonic-gate if (status < ZONE_IS_READY || status > ZONE_IS_DOWN) { 25717c478bd9Sstevel@tonic-gate /* 25727c478bd9Sstevel@tonic-gate * For all practical purposes the zone doesn't exist. 25737c478bd9Sstevel@tonic-gate */ 25747c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 25757c478bd9Sstevel@tonic-gate return (NULL); 25767c478bd9Sstevel@tonic-gate } 25777c478bd9Sstevel@tonic-gate zone_hold(zone); 25787c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 25797c478bd9Sstevel@tonic-gate return (zone); 25807c478bd9Sstevel@tonic-gate } 25817c478bd9Sstevel@tonic-gate 258245916cd2Sjpk /* 258345916cd2Sjpk * Similar to zone_find_by_id, but using zone label as the key. 258445916cd2Sjpk */ 258545916cd2Sjpk zone_t * 258645916cd2Sjpk zone_find_by_label(const ts_label_t *label) 258745916cd2Sjpk { 258845916cd2Sjpk zone_t *zone; 258942bc57c4Srica zone_status_t status; 259045916cd2Sjpk 259145916cd2Sjpk mutex_enter(&zonehash_lock); 259245916cd2Sjpk if ((zone = zone_find_all_by_label(label)) == NULL) { 259345916cd2Sjpk mutex_exit(&zonehash_lock); 259445916cd2Sjpk return (NULL); 259545916cd2Sjpk } 259642bc57c4Srica 259742bc57c4Srica status = zone_status_get(zone); 259842bc57c4Srica if (status > ZONE_IS_DOWN) { 259945916cd2Sjpk /* 260045916cd2Sjpk * For all practical purposes the zone doesn't exist. 260145916cd2Sjpk */ 260242bc57c4Srica mutex_exit(&zonehash_lock); 260342bc57c4Srica return (NULL); 260445916cd2Sjpk } 260542bc57c4Srica zone_hold(zone); 260645916cd2Sjpk mutex_exit(&zonehash_lock); 260745916cd2Sjpk return (zone); 260845916cd2Sjpk } 260945916cd2Sjpk 26107c478bd9Sstevel@tonic-gate /* 26117c478bd9Sstevel@tonic-gate * Similar to zone_find_by_id, but using zone name as the key. 26127c478bd9Sstevel@tonic-gate */ 26137c478bd9Sstevel@tonic-gate zone_t * 26147c478bd9Sstevel@tonic-gate zone_find_by_name(char *name) 26157c478bd9Sstevel@tonic-gate { 26167c478bd9Sstevel@tonic-gate zone_t *zone; 26177c478bd9Sstevel@tonic-gate zone_status_t status; 26187c478bd9Sstevel@tonic-gate 26197c478bd9Sstevel@tonic-gate mutex_enter(&zonehash_lock); 26207c478bd9Sstevel@tonic-gate if ((zone = zone_find_all_by_name(name)) == NULL) { 26217c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 26227c478bd9Sstevel@tonic-gate return (NULL); 26237c478bd9Sstevel@tonic-gate } 26247c478bd9Sstevel@tonic-gate status = zone_status_get(zone); 26257c478bd9Sstevel@tonic-gate if (status < ZONE_IS_READY || status > ZONE_IS_DOWN) { 26267c478bd9Sstevel@tonic-gate /* 26277c478bd9Sstevel@tonic-gate * For all practical purposes the zone doesn't exist. 26287c478bd9Sstevel@tonic-gate */ 26297c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 26307c478bd9Sstevel@tonic-gate return (NULL); 26317c478bd9Sstevel@tonic-gate } 26327c478bd9Sstevel@tonic-gate zone_hold(zone); 26337c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 26347c478bd9Sstevel@tonic-gate return (zone); 26357c478bd9Sstevel@tonic-gate } 26367c478bd9Sstevel@tonic-gate 26377c478bd9Sstevel@tonic-gate /* 26387c478bd9Sstevel@tonic-gate * Similar to zone_find_by_id(), using the path as a key. For instance, 26397c478bd9Sstevel@tonic-gate * if there is a zone "foo" rooted at /foo/root, and the path argument 26407c478bd9Sstevel@tonic-gate * is "/foo/root/proc", it will return the held zone_t corresponding to 26417c478bd9Sstevel@tonic-gate * zone "foo". 26427c478bd9Sstevel@tonic-gate * 26437c478bd9Sstevel@tonic-gate * zone_find_by_path() always returns a non-NULL value, since at the 26447c478bd9Sstevel@tonic-gate * very least every path will be contained in the global zone. 26457c478bd9Sstevel@tonic-gate * 26467c478bd9Sstevel@tonic-gate * As with the other zone_find_by_*() functions, the caller is 26477c478bd9Sstevel@tonic-gate * responsible for zone_rele()ing the return value of this function. 26487c478bd9Sstevel@tonic-gate */ 26497c478bd9Sstevel@tonic-gate zone_t * 26507c478bd9Sstevel@tonic-gate zone_find_by_path(const char *path) 26517c478bd9Sstevel@tonic-gate { 26527c478bd9Sstevel@tonic-gate zone_t *zone; 26537c478bd9Sstevel@tonic-gate zone_t *zret = NULL; 26547c478bd9Sstevel@tonic-gate zone_status_t status; 26557c478bd9Sstevel@tonic-gate 26567c478bd9Sstevel@tonic-gate if (path == NULL) { 26577c478bd9Sstevel@tonic-gate /* 26587c478bd9Sstevel@tonic-gate * Call from rootconf(). 26597c478bd9Sstevel@tonic-gate */ 26607c478bd9Sstevel@tonic-gate zone_hold(global_zone); 26617c478bd9Sstevel@tonic-gate return (global_zone); 26627c478bd9Sstevel@tonic-gate } 26637c478bd9Sstevel@tonic-gate ASSERT(*path == '/'); 26647c478bd9Sstevel@tonic-gate mutex_enter(&zonehash_lock); 26657c478bd9Sstevel@tonic-gate for (zone = list_head(&zone_active); zone != NULL; 26667c478bd9Sstevel@tonic-gate zone = list_next(&zone_active, zone)) { 26677c478bd9Sstevel@tonic-gate if (ZONE_PATH_VISIBLE(path, zone)) 26687c478bd9Sstevel@tonic-gate zret = zone; 26697c478bd9Sstevel@tonic-gate } 26707c478bd9Sstevel@tonic-gate ASSERT(zret != NULL); 26717c478bd9Sstevel@tonic-gate status = zone_status_get(zret); 26727c478bd9Sstevel@tonic-gate if (status < ZONE_IS_READY || status > ZONE_IS_DOWN) { 26737c478bd9Sstevel@tonic-gate /* 26747c478bd9Sstevel@tonic-gate * Zone practically doesn't exist. 26757c478bd9Sstevel@tonic-gate */ 26767c478bd9Sstevel@tonic-gate zret = global_zone; 26777c478bd9Sstevel@tonic-gate } 26787c478bd9Sstevel@tonic-gate zone_hold(zret); 26797c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 26807c478bd9Sstevel@tonic-gate return (zret); 26817c478bd9Sstevel@tonic-gate } 26827c478bd9Sstevel@tonic-gate 26837c478bd9Sstevel@tonic-gate /* 26847c478bd9Sstevel@tonic-gate * Get the number of cpus visible to this zone. The system-wide global 26857c478bd9Sstevel@tonic-gate * 'ncpus' is returned if pools are disabled, the caller is in the 26867c478bd9Sstevel@tonic-gate * global zone, or a NULL zone argument is passed in. 26877c478bd9Sstevel@tonic-gate */ 26887c478bd9Sstevel@tonic-gate int 26897c478bd9Sstevel@tonic-gate zone_ncpus_get(zone_t *zone) 26907c478bd9Sstevel@tonic-gate { 26917c478bd9Sstevel@tonic-gate int myncpus = zone == NULL ? 0 : zone->zone_ncpus; 26927c478bd9Sstevel@tonic-gate 26937c478bd9Sstevel@tonic-gate return (myncpus != 0 ? myncpus : ncpus); 26947c478bd9Sstevel@tonic-gate } 26957c478bd9Sstevel@tonic-gate 26967c478bd9Sstevel@tonic-gate /* 26977c478bd9Sstevel@tonic-gate * Get the number of online cpus visible to this zone. The system-wide 26987c478bd9Sstevel@tonic-gate * global 'ncpus_online' is returned if pools are disabled, the caller 26997c478bd9Sstevel@tonic-gate * is in the global zone, or a NULL zone argument is passed in. 27007c478bd9Sstevel@tonic-gate */ 27017c478bd9Sstevel@tonic-gate int 27027c478bd9Sstevel@tonic-gate zone_ncpus_online_get(zone_t *zone) 27037c478bd9Sstevel@tonic-gate { 27047c478bd9Sstevel@tonic-gate int myncpus_online = zone == NULL ? 0 : zone->zone_ncpus_online; 27057c478bd9Sstevel@tonic-gate 27067c478bd9Sstevel@tonic-gate return (myncpus_online != 0 ? myncpus_online : ncpus_online); 27077c478bd9Sstevel@tonic-gate } 27087c478bd9Sstevel@tonic-gate 27097c478bd9Sstevel@tonic-gate /* 27107c478bd9Sstevel@tonic-gate * Return the pool to which the zone is currently bound. 27117c478bd9Sstevel@tonic-gate */ 27127c478bd9Sstevel@tonic-gate pool_t * 27137c478bd9Sstevel@tonic-gate zone_pool_get(zone_t *zone) 27147c478bd9Sstevel@tonic-gate { 27157c478bd9Sstevel@tonic-gate ASSERT(pool_lock_held()); 27167c478bd9Sstevel@tonic-gate 27177c478bd9Sstevel@tonic-gate return (zone->zone_pool); 27187c478bd9Sstevel@tonic-gate } 27197c478bd9Sstevel@tonic-gate 27207c478bd9Sstevel@tonic-gate /* 27217c478bd9Sstevel@tonic-gate * Set the zone's pool pointer and update the zone's visibility to match 27227c478bd9Sstevel@tonic-gate * the resources in the new pool. 27237c478bd9Sstevel@tonic-gate */ 27247c478bd9Sstevel@tonic-gate void 27257c478bd9Sstevel@tonic-gate zone_pool_set(zone_t *zone, pool_t *pool) 27267c478bd9Sstevel@tonic-gate { 27277c478bd9Sstevel@tonic-gate ASSERT(pool_lock_held()); 27287c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&cpu_lock)); 27297c478bd9Sstevel@tonic-gate 27307c478bd9Sstevel@tonic-gate zone->zone_pool = pool; 27317c478bd9Sstevel@tonic-gate zone_pset_set(zone, pool->pool_pset->pset_id); 27327c478bd9Sstevel@tonic-gate } 27337c478bd9Sstevel@tonic-gate 27347c478bd9Sstevel@tonic-gate /* 27357c478bd9Sstevel@tonic-gate * Return the cached value of the id of the processor set to which the 27367c478bd9Sstevel@tonic-gate * zone is currently bound. The value will be ZONE_PS_INVAL if the pools 27377c478bd9Sstevel@tonic-gate * facility is disabled. 27387c478bd9Sstevel@tonic-gate */ 27397c478bd9Sstevel@tonic-gate psetid_t 27407c478bd9Sstevel@tonic-gate zone_pset_get(zone_t *zone) 27417c478bd9Sstevel@tonic-gate { 27427c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&cpu_lock)); 27437c478bd9Sstevel@tonic-gate 27447c478bd9Sstevel@tonic-gate return (zone->zone_psetid); 27457c478bd9Sstevel@tonic-gate } 27467c478bd9Sstevel@tonic-gate 27477c478bd9Sstevel@tonic-gate /* 27487c478bd9Sstevel@tonic-gate * Set the cached value of the id of the processor set to which the zone 27497c478bd9Sstevel@tonic-gate * is currently bound. Also update the zone's visibility to match the 27507c478bd9Sstevel@tonic-gate * resources in the new processor set. 27517c478bd9Sstevel@tonic-gate */ 27527c478bd9Sstevel@tonic-gate void 27537c478bd9Sstevel@tonic-gate zone_pset_set(zone_t *zone, psetid_t newpsetid) 27547c478bd9Sstevel@tonic-gate { 27557c478bd9Sstevel@tonic-gate psetid_t oldpsetid; 27567c478bd9Sstevel@tonic-gate 27577c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&cpu_lock)); 27587c478bd9Sstevel@tonic-gate oldpsetid = zone_pset_get(zone); 27597c478bd9Sstevel@tonic-gate 27607c478bd9Sstevel@tonic-gate if (oldpsetid == newpsetid) 27617c478bd9Sstevel@tonic-gate return; 27627c478bd9Sstevel@tonic-gate /* 27637c478bd9Sstevel@tonic-gate * Global zone sees all. 27647c478bd9Sstevel@tonic-gate */ 27657c478bd9Sstevel@tonic-gate if (zone != global_zone) { 27667c478bd9Sstevel@tonic-gate zone->zone_psetid = newpsetid; 27677c478bd9Sstevel@tonic-gate if (newpsetid != ZONE_PS_INVAL) 27687c478bd9Sstevel@tonic-gate pool_pset_visibility_add(newpsetid, zone); 27697c478bd9Sstevel@tonic-gate if (oldpsetid != ZONE_PS_INVAL) 27707c478bd9Sstevel@tonic-gate pool_pset_visibility_remove(oldpsetid, zone); 27717c478bd9Sstevel@tonic-gate } 27727c478bd9Sstevel@tonic-gate /* 27737c478bd9Sstevel@tonic-gate * Disabling pools, so we should start using the global values 27747c478bd9Sstevel@tonic-gate * for ncpus and ncpus_online. 27757c478bd9Sstevel@tonic-gate */ 27767c478bd9Sstevel@tonic-gate if (newpsetid == ZONE_PS_INVAL) { 27777c478bd9Sstevel@tonic-gate zone->zone_ncpus = 0; 27787c478bd9Sstevel@tonic-gate zone->zone_ncpus_online = 0; 27797c478bd9Sstevel@tonic-gate } 27807c478bd9Sstevel@tonic-gate } 27817c478bd9Sstevel@tonic-gate 27827c478bd9Sstevel@tonic-gate /* 27837c478bd9Sstevel@tonic-gate * Walk the list of active zones and issue the provided callback for 27847c478bd9Sstevel@tonic-gate * each of them. 27857c478bd9Sstevel@tonic-gate * 27867c478bd9Sstevel@tonic-gate * Caller must not be holding any locks that may be acquired under 27877c478bd9Sstevel@tonic-gate * zonehash_lock. See comment at the beginning of the file for a list of 27887c478bd9Sstevel@tonic-gate * common locks and their interactions with zones. 27897c478bd9Sstevel@tonic-gate */ 27907c478bd9Sstevel@tonic-gate int 27917c478bd9Sstevel@tonic-gate zone_walk(int (*cb)(zone_t *, void *), void *data) 27927c478bd9Sstevel@tonic-gate { 27937c478bd9Sstevel@tonic-gate zone_t *zone; 27947c478bd9Sstevel@tonic-gate int ret = 0; 27957c478bd9Sstevel@tonic-gate zone_status_t status; 27967c478bd9Sstevel@tonic-gate 27977c478bd9Sstevel@tonic-gate mutex_enter(&zonehash_lock); 27987c478bd9Sstevel@tonic-gate for (zone = list_head(&zone_active); zone != NULL; 27997c478bd9Sstevel@tonic-gate zone = list_next(&zone_active, zone)) { 28007c478bd9Sstevel@tonic-gate /* 28017c478bd9Sstevel@tonic-gate * Skip zones that shouldn't be externally visible. 28027c478bd9Sstevel@tonic-gate */ 28037c478bd9Sstevel@tonic-gate status = zone_status_get(zone); 28047c478bd9Sstevel@tonic-gate if (status < ZONE_IS_READY || status > ZONE_IS_DOWN) 28057c478bd9Sstevel@tonic-gate continue; 28067c478bd9Sstevel@tonic-gate /* 28077c478bd9Sstevel@tonic-gate * Bail immediately if any callback invocation returns a 28087c478bd9Sstevel@tonic-gate * non-zero value. 28097c478bd9Sstevel@tonic-gate */ 28107c478bd9Sstevel@tonic-gate ret = (*cb)(zone, data); 28117c478bd9Sstevel@tonic-gate if (ret != 0) 28127c478bd9Sstevel@tonic-gate break; 28137c478bd9Sstevel@tonic-gate } 28147c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 28157c478bd9Sstevel@tonic-gate return (ret); 28167c478bd9Sstevel@tonic-gate } 28177c478bd9Sstevel@tonic-gate 28187c478bd9Sstevel@tonic-gate static int 28197c478bd9Sstevel@tonic-gate zone_set_root(zone_t *zone, const char *upath) 28207c478bd9Sstevel@tonic-gate { 28217c478bd9Sstevel@tonic-gate vnode_t *vp; 28227c478bd9Sstevel@tonic-gate int trycount; 28237c478bd9Sstevel@tonic-gate int error = 0; 28247c478bd9Sstevel@tonic-gate char *path; 28257c478bd9Sstevel@tonic-gate struct pathname upn, pn; 28267c478bd9Sstevel@tonic-gate size_t pathlen; 28277c478bd9Sstevel@tonic-gate 28287c478bd9Sstevel@tonic-gate if ((error = pn_get((char *)upath, UIO_USERSPACE, &upn)) != 0) 28297c478bd9Sstevel@tonic-gate return (error); 28307c478bd9Sstevel@tonic-gate 28317c478bd9Sstevel@tonic-gate pn_alloc(&pn); 28327c478bd9Sstevel@tonic-gate 28337c478bd9Sstevel@tonic-gate /* prevent infinite loop */ 28347c478bd9Sstevel@tonic-gate trycount = 10; 28357c478bd9Sstevel@tonic-gate for (;;) { 28367c478bd9Sstevel@tonic-gate if (--trycount <= 0) { 28377c478bd9Sstevel@tonic-gate error = ESTALE; 28387c478bd9Sstevel@tonic-gate goto out; 28397c478bd9Sstevel@tonic-gate } 28407c478bd9Sstevel@tonic-gate 28417c478bd9Sstevel@tonic-gate if ((error = lookuppn(&upn, &pn, FOLLOW, NULLVPP, &vp)) == 0) { 28427c478bd9Sstevel@tonic-gate /* 28437c478bd9Sstevel@tonic-gate * VOP_ACCESS() may cover 'vp' with a new 28447c478bd9Sstevel@tonic-gate * filesystem, if 'vp' is an autoFS vnode. 28457c478bd9Sstevel@tonic-gate * Get the new 'vp' if so. 28467c478bd9Sstevel@tonic-gate */ 2847da6c28aaSamw if ((error = 2848da6c28aaSamw VOP_ACCESS(vp, VEXEC, 0, CRED(), NULL)) == 0 && 284925d2dc23Seh (!vn_ismntpt(vp) || 28507c478bd9Sstevel@tonic-gate (error = traverse(&vp)) == 0)) { 28517c478bd9Sstevel@tonic-gate pathlen = pn.pn_pathlen + 2; 28527c478bd9Sstevel@tonic-gate path = kmem_alloc(pathlen, KM_SLEEP); 28537c478bd9Sstevel@tonic-gate (void) strncpy(path, pn.pn_path, 28547c478bd9Sstevel@tonic-gate pn.pn_pathlen + 1); 28557c478bd9Sstevel@tonic-gate path[pathlen - 2] = '/'; 28567c478bd9Sstevel@tonic-gate path[pathlen - 1] = '\0'; 28577c478bd9Sstevel@tonic-gate pn_free(&pn); 28587c478bd9Sstevel@tonic-gate pn_free(&upn); 28597c478bd9Sstevel@tonic-gate 28607c478bd9Sstevel@tonic-gate /* Success! */ 28617c478bd9Sstevel@tonic-gate break; 28627c478bd9Sstevel@tonic-gate } 28637c478bd9Sstevel@tonic-gate VN_RELE(vp); 28647c478bd9Sstevel@tonic-gate } 28657c478bd9Sstevel@tonic-gate if (error != ESTALE) 28667c478bd9Sstevel@tonic-gate goto out; 28677c478bd9Sstevel@tonic-gate } 28687c478bd9Sstevel@tonic-gate 28697c478bd9Sstevel@tonic-gate ASSERT(error == 0); 28707c478bd9Sstevel@tonic-gate zone->zone_rootvp = vp; /* we hold a reference to vp */ 28717c478bd9Sstevel@tonic-gate zone->zone_rootpath = path; 28727c478bd9Sstevel@tonic-gate zone->zone_rootpathlen = pathlen; 287348451833Scarlsonj if (pathlen > 5 && strcmp(path + pathlen - 5, "/lu/") == 0) 287448451833Scarlsonj zone->zone_flags |= ZF_IS_SCRATCH; 28757c478bd9Sstevel@tonic-gate return (0); 28767c478bd9Sstevel@tonic-gate 28777c478bd9Sstevel@tonic-gate out: 28787c478bd9Sstevel@tonic-gate pn_free(&pn); 28797c478bd9Sstevel@tonic-gate pn_free(&upn); 28807c478bd9Sstevel@tonic-gate return (error); 28817c478bd9Sstevel@tonic-gate } 28827c478bd9Sstevel@tonic-gate 28837c478bd9Sstevel@tonic-gate #define isalnum(c) (((c) >= '0' && (c) <= '9') || \ 28847c478bd9Sstevel@tonic-gate ((c) >= 'a' && (c) <= 'z') || \ 28857c478bd9Sstevel@tonic-gate ((c) >= 'A' && (c) <= 'Z')) 28867c478bd9Sstevel@tonic-gate 28877c478bd9Sstevel@tonic-gate static int 28887c478bd9Sstevel@tonic-gate zone_set_name(zone_t *zone, const char *uname) 28897c478bd9Sstevel@tonic-gate { 28907c478bd9Sstevel@tonic-gate char *kname = kmem_zalloc(ZONENAME_MAX, KM_SLEEP); 28917c478bd9Sstevel@tonic-gate size_t len; 28927c478bd9Sstevel@tonic-gate int i, err; 28937c478bd9Sstevel@tonic-gate 28947c478bd9Sstevel@tonic-gate if ((err = copyinstr(uname, kname, ZONENAME_MAX, &len)) != 0) { 28957c478bd9Sstevel@tonic-gate kmem_free(kname, ZONENAME_MAX); 28967c478bd9Sstevel@tonic-gate return (err); /* EFAULT or ENAMETOOLONG */ 28977c478bd9Sstevel@tonic-gate } 28987c478bd9Sstevel@tonic-gate 28997c478bd9Sstevel@tonic-gate /* must be less than ZONENAME_MAX */ 29007c478bd9Sstevel@tonic-gate if (len == ZONENAME_MAX && kname[ZONENAME_MAX - 1] != '\0') { 29017c478bd9Sstevel@tonic-gate kmem_free(kname, ZONENAME_MAX); 29027c478bd9Sstevel@tonic-gate return (EINVAL); 29037c478bd9Sstevel@tonic-gate } 29047c478bd9Sstevel@tonic-gate 29057c478bd9Sstevel@tonic-gate /* 29067c478bd9Sstevel@tonic-gate * Name must start with an alphanumeric and must contain only 29077c478bd9Sstevel@tonic-gate * alphanumerics, '-', '_' and '.'. 29087c478bd9Sstevel@tonic-gate */ 29097c478bd9Sstevel@tonic-gate if (!isalnum(kname[0])) { 29107c478bd9Sstevel@tonic-gate kmem_free(kname, ZONENAME_MAX); 29117c478bd9Sstevel@tonic-gate return (EINVAL); 29127c478bd9Sstevel@tonic-gate } 29137c478bd9Sstevel@tonic-gate for (i = 1; i < len - 1; i++) { 29147c478bd9Sstevel@tonic-gate if (!isalnum(kname[i]) && kname[i] != '-' && kname[i] != '_' && 29157c478bd9Sstevel@tonic-gate kname[i] != '.') { 29167c478bd9Sstevel@tonic-gate kmem_free(kname, ZONENAME_MAX); 29177c478bd9Sstevel@tonic-gate return (EINVAL); 29187c478bd9Sstevel@tonic-gate } 29197c478bd9Sstevel@tonic-gate } 29207c478bd9Sstevel@tonic-gate 29217c478bd9Sstevel@tonic-gate zone->zone_name = kname; 29227c478bd9Sstevel@tonic-gate return (0); 29237c478bd9Sstevel@tonic-gate } 29247c478bd9Sstevel@tonic-gate 29255679c89fSjv /* 29265679c89fSjv * Gets the 32-bit hostid of the specified zone as an unsigned int. If 'zonep' 29275679c89fSjv * is NULL or it points to a zone with no hostid emulation, then the machine's 29285679c89fSjv * hostid (i.e., the global zone's hostid) is returned. This function returns 29295679c89fSjv * zero if neither the zone nor the host machine (global zone) have hostids. It 29305679c89fSjv * returns HW_INVALID_HOSTID if the function attempts to return the machine's 29315679c89fSjv * hostid and the machine's hostid is invalid. 29325679c89fSjv */ 29335679c89fSjv uint32_t 29345679c89fSjv zone_get_hostid(zone_t *zonep) 29355679c89fSjv { 29365679c89fSjv unsigned long machine_hostid; 29375679c89fSjv 29385679c89fSjv if (zonep == NULL || zonep->zone_hostid == HW_INVALID_HOSTID) { 29395679c89fSjv if (ddi_strtoul(hw_serial, NULL, 10, &machine_hostid) != 0) 29405679c89fSjv return (HW_INVALID_HOSTID); 29415679c89fSjv return ((uint32_t)machine_hostid); 29425679c89fSjv } 29435679c89fSjv return (zonep->zone_hostid); 29445679c89fSjv } 29455679c89fSjv 29467c478bd9Sstevel@tonic-gate /* 29477c478bd9Sstevel@tonic-gate * Similar to thread_create(), but makes sure the thread is in the appropriate 29487c478bd9Sstevel@tonic-gate * zone's zsched process (curproc->p_zone->zone_zsched) before returning. 29497c478bd9Sstevel@tonic-gate */ 29507c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 29517c478bd9Sstevel@tonic-gate kthread_t * 29527c478bd9Sstevel@tonic-gate zthread_create( 29537c478bd9Sstevel@tonic-gate caddr_t stk, 29547c478bd9Sstevel@tonic-gate size_t stksize, 29557c478bd9Sstevel@tonic-gate void (*proc)(), 29567c478bd9Sstevel@tonic-gate void *arg, 29577c478bd9Sstevel@tonic-gate size_t len, 29587c478bd9Sstevel@tonic-gate pri_t pri) 29597c478bd9Sstevel@tonic-gate { 29607c478bd9Sstevel@tonic-gate kthread_t *t; 29617c478bd9Sstevel@tonic-gate zone_t *zone = curproc->p_zone; 29627c478bd9Sstevel@tonic-gate proc_t *pp = zone->zone_zsched; 29637c478bd9Sstevel@tonic-gate 29647c478bd9Sstevel@tonic-gate zone_hold(zone); /* Reference to be dropped when thread exits */ 29657c478bd9Sstevel@tonic-gate 29667c478bd9Sstevel@tonic-gate /* 29677c478bd9Sstevel@tonic-gate * No-one should be trying to create threads if the zone is shutting 29687c478bd9Sstevel@tonic-gate * down and there aren't any kernel threads around. See comment 29697c478bd9Sstevel@tonic-gate * in zthread_exit(). 29707c478bd9Sstevel@tonic-gate */ 29717c478bd9Sstevel@tonic-gate ASSERT(!(zone->zone_kthreads == NULL && 29727c478bd9Sstevel@tonic-gate zone_status_get(zone) >= ZONE_IS_EMPTY)); 29737c478bd9Sstevel@tonic-gate /* 29747c478bd9Sstevel@tonic-gate * Create a thread, but don't let it run until we've finished setting 29757c478bd9Sstevel@tonic-gate * things up. 29767c478bd9Sstevel@tonic-gate */ 29777c478bd9Sstevel@tonic-gate t = thread_create(stk, stksize, proc, arg, len, pp, TS_STOPPED, pri); 29787c478bd9Sstevel@tonic-gate ASSERT(t->t_forw == NULL); 29797c478bd9Sstevel@tonic-gate mutex_enter(&zone_status_lock); 29807c478bd9Sstevel@tonic-gate if (zone->zone_kthreads == NULL) { 29817c478bd9Sstevel@tonic-gate t->t_forw = t->t_back = t; 29827c478bd9Sstevel@tonic-gate } else { 29837c478bd9Sstevel@tonic-gate kthread_t *tx = zone->zone_kthreads; 29847c478bd9Sstevel@tonic-gate 29857c478bd9Sstevel@tonic-gate t->t_forw = tx; 29867c478bd9Sstevel@tonic-gate t->t_back = tx->t_back; 29877c478bd9Sstevel@tonic-gate tx->t_back->t_forw = t; 29887c478bd9Sstevel@tonic-gate tx->t_back = t; 29897c478bd9Sstevel@tonic-gate } 29907c478bd9Sstevel@tonic-gate zone->zone_kthreads = t; 29917c478bd9Sstevel@tonic-gate mutex_exit(&zone_status_lock); 29927c478bd9Sstevel@tonic-gate 29937c478bd9Sstevel@tonic-gate mutex_enter(&pp->p_lock); 29947c478bd9Sstevel@tonic-gate t->t_proc_flag |= TP_ZTHREAD; 29957c478bd9Sstevel@tonic-gate project_rele(t->t_proj); 29967c478bd9Sstevel@tonic-gate t->t_proj = project_hold(pp->p_task->tk_proj); 29977c478bd9Sstevel@tonic-gate 29987c478bd9Sstevel@tonic-gate /* 29997c478bd9Sstevel@tonic-gate * Setup complete, let it run. 30007c478bd9Sstevel@tonic-gate */ 30017c478bd9Sstevel@tonic-gate thread_lock(t); 30027c478bd9Sstevel@tonic-gate t->t_schedflag |= TS_ALLSTART; 30037c478bd9Sstevel@tonic-gate setrun_locked(t); 30047c478bd9Sstevel@tonic-gate thread_unlock(t); 30057c478bd9Sstevel@tonic-gate 30067c478bd9Sstevel@tonic-gate mutex_exit(&pp->p_lock); 30077c478bd9Sstevel@tonic-gate 30087c478bd9Sstevel@tonic-gate return (t); 30097c478bd9Sstevel@tonic-gate } 30107c478bd9Sstevel@tonic-gate 30117c478bd9Sstevel@tonic-gate /* 30127c478bd9Sstevel@tonic-gate * Similar to thread_exit(). Must be called by threads created via 30137c478bd9Sstevel@tonic-gate * zthread_exit(). 30147c478bd9Sstevel@tonic-gate */ 30157c478bd9Sstevel@tonic-gate void 30167c478bd9Sstevel@tonic-gate zthread_exit(void) 30177c478bd9Sstevel@tonic-gate { 30187c478bd9Sstevel@tonic-gate kthread_t *t = curthread; 30197c478bd9Sstevel@tonic-gate proc_t *pp = curproc; 30207c478bd9Sstevel@tonic-gate zone_t *zone = pp->p_zone; 30217c478bd9Sstevel@tonic-gate 30227c478bd9Sstevel@tonic-gate mutex_enter(&zone_status_lock); 30237c478bd9Sstevel@tonic-gate 30247c478bd9Sstevel@tonic-gate /* 30257c478bd9Sstevel@tonic-gate * Reparent to p0 30267c478bd9Sstevel@tonic-gate */ 3027b4b07f87Sjosephb kpreempt_disable(); 30287c478bd9Sstevel@tonic-gate mutex_enter(&pp->p_lock); 30297c478bd9Sstevel@tonic-gate t->t_proc_flag &= ~TP_ZTHREAD; 30307c478bd9Sstevel@tonic-gate t->t_procp = &p0; 30317c478bd9Sstevel@tonic-gate hat_thread_exit(t); 30327c478bd9Sstevel@tonic-gate mutex_exit(&pp->p_lock); 3033b4b07f87Sjosephb kpreempt_enable(); 30347c478bd9Sstevel@tonic-gate 30357c478bd9Sstevel@tonic-gate if (t->t_back == t) { 30367c478bd9Sstevel@tonic-gate ASSERT(t->t_forw == t); 30377c478bd9Sstevel@tonic-gate /* 30387c478bd9Sstevel@tonic-gate * If the zone is empty, once the thread count 30397c478bd9Sstevel@tonic-gate * goes to zero no further kernel threads can be 30407c478bd9Sstevel@tonic-gate * created. This is because if the creator is a process 30417c478bd9Sstevel@tonic-gate * in the zone, then it must have exited before the zone 30427c478bd9Sstevel@tonic-gate * state could be set to ZONE_IS_EMPTY. 30437c478bd9Sstevel@tonic-gate * Otherwise, if the creator is a kernel thread in the 30447c478bd9Sstevel@tonic-gate * zone, the thread count is non-zero. 30457c478bd9Sstevel@tonic-gate * 30467c478bd9Sstevel@tonic-gate * This really means that non-zone kernel threads should 30477c478bd9Sstevel@tonic-gate * not create zone kernel threads. 30487c478bd9Sstevel@tonic-gate */ 30497c478bd9Sstevel@tonic-gate zone->zone_kthreads = NULL; 30507c478bd9Sstevel@tonic-gate if (zone_status_get(zone) == ZONE_IS_EMPTY) { 30517c478bd9Sstevel@tonic-gate zone_status_set(zone, ZONE_IS_DOWN); 3052c97ad5cdSakolb /* 3053c97ad5cdSakolb * Remove any CPU caps on this zone. 3054c97ad5cdSakolb */ 3055c97ad5cdSakolb cpucaps_zone_remove(zone); 30567c478bd9Sstevel@tonic-gate } 30577c478bd9Sstevel@tonic-gate } else { 30587c478bd9Sstevel@tonic-gate t->t_forw->t_back = t->t_back; 30597c478bd9Sstevel@tonic-gate t->t_back->t_forw = t->t_forw; 30607c478bd9Sstevel@tonic-gate if (zone->zone_kthreads == t) 30617c478bd9Sstevel@tonic-gate zone->zone_kthreads = t->t_forw; 30627c478bd9Sstevel@tonic-gate } 30637c478bd9Sstevel@tonic-gate mutex_exit(&zone_status_lock); 30647c478bd9Sstevel@tonic-gate zone_rele(zone); 30657c478bd9Sstevel@tonic-gate thread_exit(); 30667c478bd9Sstevel@tonic-gate /* NOTREACHED */ 30677c478bd9Sstevel@tonic-gate } 30687c478bd9Sstevel@tonic-gate 30697c478bd9Sstevel@tonic-gate static void 30707c478bd9Sstevel@tonic-gate zone_chdir(vnode_t *vp, vnode_t **vpp, proc_t *pp) 30717c478bd9Sstevel@tonic-gate { 30727c478bd9Sstevel@tonic-gate vnode_t *oldvp; 30737c478bd9Sstevel@tonic-gate 30747c478bd9Sstevel@tonic-gate /* we're going to hold a reference here to the directory */ 30757c478bd9Sstevel@tonic-gate VN_HOLD(vp); 30767c478bd9Sstevel@tonic-gate 3077005d3febSMarek Pospisil /* update abs cwd/root path see c2/audit.c */ 3078005d3febSMarek Pospisil if (AU_AUDITING()) 30797c478bd9Sstevel@tonic-gate audit_chdirec(vp, vpp); 30807c478bd9Sstevel@tonic-gate 30817c478bd9Sstevel@tonic-gate mutex_enter(&pp->p_lock); 30827c478bd9Sstevel@tonic-gate oldvp = *vpp; 30837c478bd9Sstevel@tonic-gate *vpp = vp; 30847c478bd9Sstevel@tonic-gate mutex_exit(&pp->p_lock); 30857c478bd9Sstevel@tonic-gate if (oldvp != NULL) 30867c478bd9Sstevel@tonic-gate VN_RELE(oldvp); 30877c478bd9Sstevel@tonic-gate } 30887c478bd9Sstevel@tonic-gate 30897c478bd9Sstevel@tonic-gate /* 30907c478bd9Sstevel@tonic-gate * Convert an rctl value represented by an nvlist_t into an rctl_val_t. 30917c478bd9Sstevel@tonic-gate */ 30927c478bd9Sstevel@tonic-gate static int 30937c478bd9Sstevel@tonic-gate nvlist2rctlval(nvlist_t *nvl, rctl_val_t *rv) 30947c478bd9Sstevel@tonic-gate { 30957c478bd9Sstevel@tonic-gate nvpair_t *nvp = NULL; 30967c478bd9Sstevel@tonic-gate boolean_t priv_set = B_FALSE; 30977c478bd9Sstevel@tonic-gate boolean_t limit_set = B_FALSE; 30987c478bd9Sstevel@tonic-gate boolean_t action_set = B_FALSE; 30997c478bd9Sstevel@tonic-gate 31007c478bd9Sstevel@tonic-gate while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) { 31017c478bd9Sstevel@tonic-gate const char *name; 31027c478bd9Sstevel@tonic-gate uint64_t ui64; 31037c478bd9Sstevel@tonic-gate 31047c478bd9Sstevel@tonic-gate name = nvpair_name(nvp); 31057c478bd9Sstevel@tonic-gate if (nvpair_type(nvp) != DATA_TYPE_UINT64) 31067c478bd9Sstevel@tonic-gate return (EINVAL); 31077c478bd9Sstevel@tonic-gate (void) nvpair_value_uint64(nvp, &ui64); 31087c478bd9Sstevel@tonic-gate if (strcmp(name, "privilege") == 0) { 31097c478bd9Sstevel@tonic-gate /* 31107c478bd9Sstevel@tonic-gate * Currently only privileged values are allowed, but 31117c478bd9Sstevel@tonic-gate * this may change in the future. 31127c478bd9Sstevel@tonic-gate */ 31137c478bd9Sstevel@tonic-gate if (ui64 != RCPRIV_PRIVILEGED) 31147c478bd9Sstevel@tonic-gate return (EINVAL); 31157c478bd9Sstevel@tonic-gate rv->rcv_privilege = ui64; 31167c478bd9Sstevel@tonic-gate priv_set = B_TRUE; 31177c478bd9Sstevel@tonic-gate } else if (strcmp(name, "limit") == 0) { 31187c478bd9Sstevel@tonic-gate rv->rcv_value = ui64; 31197c478bd9Sstevel@tonic-gate limit_set = B_TRUE; 31207c478bd9Sstevel@tonic-gate } else if (strcmp(name, "action") == 0) { 31217c478bd9Sstevel@tonic-gate if (ui64 != RCTL_LOCAL_NOACTION && 31227c478bd9Sstevel@tonic-gate ui64 != RCTL_LOCAL_DENY) 31237c478bd9Sstevel@tonic-gate return (EINVAL); 31247c478bd9Sstevel@tonic-gate rv->rcv_flagaction = ui64; 31257c478bd9Sstevel@tonic-gate action_set = B_TRUE; 31267c478bd9Sstevel@tonic-gate } else { 31277c478bd9Sstevel@tonic-gate return (EINVAL); 31287c478bd9Sstevel@tonic-gate } 31297c478bd9Sstevel@tonic-gate } 31307c478bd9Sstevel@tonic-gate 31317c478bd9Sstevel@tonic-gate if (!(priv_set && limit_set && action_set)) 31327c478bd9Sstevel@tonic-gate return (EINVAL); 31337c478bd9Sstevel@tonic-gate rv->rcv_action_signal = 0; 31347c478bd9Sstevel@tonic-gate rv->rcv_action_recipient = NULL; 31357c478bd9Sstevel@tonic-gate rv->rcv_action_recip_pid = -1; 31367c478bd9Sstevel@tonic-gate rv->rcv_firing_time = 0; 31377c478bd9Sstevel@tonic-gate 31387c478bd9Sstevel@tonic-gate return (0); 31397c478bd9Sstevel@tonic-gate } 31407c478bd9Sstevel@tonic-gate 31413f2f09c1Sdp /* 31423f2f09c1Sdp * Non-global zone version of start_init. 31433f2f09c1Sdp */ 31447c478bd9Sstevel@tonic-gate void 31453f2f09c1Sdp zone_start_init(void) 31467c478bd9Sstevel@tonic-gate { 31477c478bd9Sstevel@tonic-gate proc_t *p = ttoproc(curthread); 31489acbbeafSnn zone_t *z = p->p_zone; 31497c478bd9Sstevel@tonic-gate 31503f2f09c1Sdp ASSERT(!INGLOBALZONE(curproc)); 31517c478bd9Sstevel@tonic-gate 31529acbbeafSnn /* 31539acbbeafSnn * For all purposes (ZONE_ATTR_INITPID and restart_init), 31549acbbeafSnn * storing just the pid of init is sufficient. 31559acbbeafSnn */ 31569acbbeafSnn z->zone_proc_initpid = p->p_pid; 31579acbbeafSnn 31587c478bd9Sstevel@tonic-gate /* 31593f2f09c1Sdp * We maintain zone_boot_err so that we can return the cause of the 31603f2f09c1Sdp * failure back to the caller of the zone_boot syscall. 31617c478bd9Sstevel@tonic-gate */ 31623f2f09c1Sdp p->p_zone->zone_boot_err = start_init_common(); 31637c478bd9Sstevel@tonic-gate 31648f983ab3Sjv /* 31658f983ab3Sjv * We will prevent booting zones from becoming running zones if the 31668f983ab3Sjv * global zone is shutting down. 31678f983ab3Sjv */ 31687c478bd9Sstevel@tonic-gate mutex_enter(&zone_status_lock); 31698f983ab3Sjv if (z->zone_boot_err != 0 || zone_status_get(global_zone) >= 31708f983ab3Sjv ZONE_IS_SHUTTING_DOWN) { 31717c478bd9Sstevel@tonic-gate /* 31727c478bd9Sstevel@tonic-gate * Make sure we are still in the booting state-- we could have 31737c478bd9Sstevel@tonic-gate * raced and already be shutting down, or even further along. 31747c478bd9Sstevel@tonic-gate */ 3175c97ad5cdSakolb if (zone_status_get(z) == ZONE_IS_BOOTING) { 31769acbbeafSnn zone_status_set(z, ZONE_IS_SHUTTING_DOWN); 3177c97ad5cdSakolb } 31787c478bd9Sstevel@tonic-gate mutex_exit(&zone_status_lock); 31797c478bd9Sstevel@tonic-gate /* It's gone bad, dispose of the process */ 31809acbbeafSnn if (proc_exit(CLD_EXITED, z->zone_boot_err) != 0) { 318197eda132Sraf mutex_enter(&p->p_lock); 318297eda132Sraf ASSERT(p->p_flag & SEXITLWPS); 31837c478bd9Sstevel@tonic-gate lwp_exit(); 31847c478bd9Sstevel@tonic-gate } 31857c478bd9Sstevel@tonic-gate } else { 31869acbbeafSnn if (zone_status_get(z) == ZONE_IS_BOOTING) 31879acbbeafSnn zone_status_set(z, ZONE_IS_RUNNING); 31887c478bd9Sstevel@tonic-gate mutex_exit(&zone_status_lock); 31897c478bd9Sstevel@tonic-gate /* cause the process to return to userland. */ 31907c478bd9Sstevel@tonic-gate lwp_rtt(); 31917c478bd9Sstevel@tonic-gate } 31927c478bd9Sstevel@tonic-gate } 31937c478bd9Sstevel@tonic-gate 31947c478bd9Sstevel@tonic-gate struct zsched_arg { 31957c478bd9Sstevel@tonic-gate zone_t *zone; 31967c478bd9Sstevel@tonic-gate nvlist_t *nvlist; 31977c478bd9Sstevel@tonic-gate }; 31987c478bd9Sstevel@tonic-gate 31997c478bd9Sstevel@tonic-gate /* 32007c478bd9Sstevel@tonic-gate * Per-zone "sched" workalike. The similarity to "sched" doesn't have 32017c478bd9Sstevel@tonic-gate * anything to do with scheduling, but rather with the fact that 32027c478bd9Sstevel@tonic-gate * per-zone kernel threads are parented to zsched, just like regular 32037c478bd9Sstevel@tonic-gate * kernel threads are parented to sched (p0). 32047c478bd9Sstevel@tonic-gate * 32057c478bd9Sstevel@tonic-gate * zsched is also responsible for launching init for the zone. 32067c478bd9Sstevel@tonic-gate */ 32077c478bd9Sstevel@tonic-gate static void 32087c478bd9Sstevel@tonic-gate zsched(void *arg) 32097c478bd9Sstevel@tonic-gate { 32107c478bd9Sstevel@tonic-gate struct zsched_arg *za = arg; 32117c478bd9Sstevel@tonic-gate proc_t *pp = curproc; 32127c478bd9Sstevel@tonic-gate proc_t *initp = proc_init; 32137c478bd9Sstevel@tonic-gate zone_t *zone = za->zone; 32147c478bd9Sstevel@tonic-gate cred_t *cr, *oldcred; 32157c478bd9Sstevel@tonic-gate rctl_set_t *set; 32167c478bd9Sstevel@tonic-gate rctl_alloc_gp_t *gp; 32177c478bd9Sstevel@tonic-gate contract_t *ct = NULL; 32187c478bd9Sstevel@tonic-gate task_t *tk, *oldtk; 32197c478bd9Sstevel@tonic-gate rctl_entity_p_t e; 32207c478bd9Sstevel@tonic-gate kproject_t *pj; 32217c478bd9Sstevel@tonic-gate 32227c478bd9Sstevel@tonic-gate nvlist_t *nvl = za->nvlist; 32237c478bd9Sstevel@tonic-gate nvpair_t *nvp = NULL; 32247c478bd9Sstevel@tonic-gate 3225ae115bc7Smrj bcopy("zsched", PTOU(pp)->u_psargs, sizeof ("zsched")); 3226ae115bc7Smrj bcopy("zsched", PTOU(pp)->u_comm, sizeof ("zsched")); 3227ae115bc7Smrj PTOU(pp)->u_argc = 0; 3228ae115bc7Smrj PTOU(pp)->u_argv = NULL; 3229ae115bc7Smrj PTOU(pp)->u_envp = NULL; 32307c478bd9Sstevel@tonic-gate closeall(P_FINFO(pp)); 32317c478bd9Sstevel@tonic-gate 32327c478bd9Sstevel@tonic-gate /* 32337c478bd9Sstevel@tonic-gate * We are this zone's "zsched" process. As the zone isn't generally 32347c478bd9Sstevel@tonic-gate * visible yet we don't need to grab any locks before initializing its 32357c478bd9Sstevel@tonic-gate * zone_proc pointer. 32367c478bd9Sstevel@tonic-gate */ 32377c478bd9Sstevel@tonic-gate zone_hold(zone); /* this hold is released by zone_destroy() */ 32387c478bd9Sstevel@tonic-gate zone->zone_zsched = pp; 32397c478bd9Sstevel@tonic-gate mutex_enter(&pp->p_lock); 32407c478bd9Sstevel@tonic-gate pp->p_zone = zone; 32417c478bd9Sstevel@tonic-gate mutex_exit(&pp->p_lock); 32427c478bd9Sstevel@tonic-gate 32437c478bd9Sstevel@tonic-gate /* 32447c478bd9Sstevel@tonic-gate * Disassociate process from its 'parent'; parent ourselves to init 32457c478bd9Sstevel@tonic-gate * (pid 1) and change other values as needed. 32467c478bd9Sstevel@tonic-gate */ 32477c478bd9Sstevel@tonic-gate sess_create(); 32487c478bd9Sstevel@tonic-gate 32497c478bd9Sstevel@tonic-gate mutex_enter(&pidlock); 32507c478bd9Sstevel@tonic-gate proc_detach(pp); 32517c478bd9Sstevel@tonic-gate pp->p_ppid = 1; 32527c478bd9Sstevel@tonic-gate pp->p_flag |= SZONETOP; 32537c478bd9Sstevel@tonic-gate pp->p_ancpid = 1; 32547c478bd9Sstevel@tonic-gate pp->p_parent = initp; 32557c478bd9Sstevel@tonic-gate pp->p_psibling = NULL; 32567c478bd9Sstevel@tonic-gate if (initp->p_child) 32577c478bd9Sstevel@tonic-gate initp->p_child->p_psibling = pp; 32587c478bd9Sstevel@tonic-gate pp->p_sibling = initp->p_child; 32597c478bd9Sstevel@tonic-gate initp->p_child = pp; 32607c478bd9Sstevel@tonic-gate 32617c478bd9Sstevel@tonic-gate /* Decrement what newproc() incremented. */ 32627c478bd9Sstevel@tonic-gate upcount_dec(crgetruid(CRED()), GLOBAL_ZONEID); 32637c478bd9Sstevel@tonic-gate /* 32647c478bd9Sstevel@tonic-gate * Our credentials are about to become kcred-like, so we don't care 32657c478bd9Sstevel@tonic-gate * about the caller's ruid. 32667c478bd9Sstevel@tonic-gate */ 32677c478bd9Sstevel@tonic-gate upcount_inc(crgetruid(kcred), zone->zone_id); 32687c478bd9Sstevel@tonic-gate mutex_exit(&pidlock); 32697c478bd9Sstevel@tonic-gate 32707c478bd9Sstevel@tonic-gate /* 32717c478bd9Sstevel@tonic-gate * getting out of global zone, so decrement lwp counts 32727c478bd9Sstevel@tonic-gate */ 32737c478bd9Sstevel@tonic-gate pj = pp->p_task->tk_proj; 32747c478bd9Sstevel@tonic-gate mutex_enter(&global_zone->zone_nlwps_lock); 32757c478bd9Sstevel@tonic-gate pj->kpj_nlwps -= pp->p_lwpcnt; 32767c478bd9Sstevel@tonic-gate global_zone->zone_nlwps -= pp->p_lwpcnt; 32777c478bd9Sstevel@tonic-gate mutex_exit(&global_zone->zone_nlwps_lock); 32787c478bd9Sstevel@tonic-gate 3279c6939658Ssl /* 3280c6939658Ssl * Decrement locked memory counts on old zone and project. 3281c6939658Ssl */ 32820209230bSgjelinek mutex_enter(&global_zone->zone_mem_lock); 3283c6939658Ssl global_zone->zone_locked_mem -= pp->p_locked_mem; 3284c6939658Ssl pj->kpj_data.kpd_locked_mem -= pp->p_locked_mem; 32850209230bSgjelinek mutex_exit(&global_zone->zone_mem_lock); 3286c6939658Ssl 32877c478bd9Sstevel@tonic-gate /* 32887c478bd9Sstevel@tonic-gate * Create and join a new task in project '0' of this zone. 32897c478bd9Sstevel@tonic-gate * 32907c478bd9Sstevel@tonic-gate * We don't need to call holdlwps() since we know we're the only lwp in 32917c478bd9Sstevel@tonic-gate * this process. 32927c478bd9Sstevel@tonic-gate * 32937c478bd9Sstevel@tonic-gate * task_join() returns with p_lock held. 32947c478bd9Sstevel@tonic-gate */ 32957c478bd9Sstevel@tonic-gate tk = task_create(0, zone); 32967c478bd9Sstevel@tonic-gate mutex_enter(&cpu_lock); 32977c478bd9Sstevel@tonic-gate oldtk = task_join(tk, 0); 3298c6939658Ssl 3299c6939658Ssl pj = pp->p_task->tk_proj; 3300c6939658Ssl 33010209230bSgjelinek mutex_enter(&zone->zone_mem_lock); 3302c6939658Ssl zone->zone_locked_mem += pp->p_locked_mem; 3303c6939658Ssl pj->kpj_data.kpd_locked_mem += pp->p_locked_mem; 33040209230bSgjelinek mutex_exit(&zone->zone_mem_lock); 33057c478bd9Sstevel@tonic-gate 33067c478bd9Sstevel@tonic-gate /* 33077c478bd9Sstevel@tonic-gate * add lwp counts to zsched's zone, and increment project's task count 33087c478bd9Sstevel@tonic-gate * due to the task created in the above tasksys_settaskid 33097c478bd9Sstevel@tonic-gate */ 3310c6939658Ssl 33117c478bd9Sstevel@tonic-gate mutex_enter(&zone->zone_nlwps_lock); 33127c478bd9Sstevel@tonic-gate pj->kpj_nlwps += pp->p_lwpcnt; 33137c478bd9Sstevel@tonic-gate pj->kpj_ntasks += 1; 33147c478bd9Sstevel@tonic-gate zone->zone_nlwps += pp->p_lwpcnt; 33157c478bd9Sstevel@tonic-gate mutex_exit(&zone->zone_nlwps_lock); 33167c478bd9Sstevel@tonic-gate 3317c6939658Ssl mutex_exit(&curproc->p_lock); 3318c6939658Ssl mutex_exit(&cpu_lock); 3319c6939658Ssl task_rele(oldtk); 3320c6939658Ssl 33217c478bd9Sstevel@tonic-gate /* 33227c478bd9Sstevel@tonic-gate * The process was created by a process in the global zone, hence the 33237c478bd9Sstevel@tonic-gate * credentials are wrong. We might as well have kcred-ish credentials. 33247c478bd9Sstevel@tonic-gate */ 33257c478bd9Sstevel@tonic-gate cr = zone->zone_kcred; 33267c478bd9Sstevel@tonic-gate crhold(cr); 33277c478bd9Sstevel@tonic-gate mutex_enter(&pp->p_crlock); 33287c478bd9Sstevel@tonic-gate oldcred = pp->p_cred; 33297c478bd9Sstevel@tonic-gate pp->p_cred = cr; 33307c478bd9Sstevel@tonic-gate mutex_exit(&pp->p_crlock); 33317c478bd9Sstevel@tonic-gate crfree(oldcred); 33327c478bd9Sstevel@tonic-gate 33337c478bd9Sstevel@tonic-gate /* 33347c478bd9Sstevel@tonic-gate * Hold credentials again (for thread) 33357c478bd9Sstevel@tonic-gate */ 33367c478bd9Sstevel@tonic-gate crhold(cr); 33377c478bd9Sstevel@tonic-gate 33387c478bd9Sstevel@tonic-gate /* 33397c478bd9Sstevel@tonic-gate * p_lwpcnt can't change since this is a kernel process. 33407c478bd9Sstevel@tonic-gate */ 33417c478bd9Sstevel@tonic-gate crset(pp, cr); 33427c478bd9Sstevel@tonic-gate 33437c478bd9Sstevel@tonic-gate /* 33447c478bd9Sstevel@tonic-gate * Chroot 33457c478bd9Sstevel@tonic-gate */ 33467c478bd9Sstevel@tonic-gate zone_chdir(zone->zone_rootvp, &PTOU(pp)->u_cdir, pp); 33477c478bd9Sstevel@tonic-gate zone_chdir(zone->zone_rootvp, &PTOU(pp)->u_rdir, pp); 33487c478bd9Sstevel@tonic-gate 33497c478bd9Sstevel@tonic-gate /* 33507c478bd9Sstevel@tonic-gate * Initialize zone's rctl set. 33517c478bd9Sstevel@tonic-gate */ 33527c478bd9Sstevel@tonic-gate set = rctl_set_create(); 33537c478bd9Sstevel@tonic-gate gp = rctl_set_init_prealloc(RCENTITY_ZONE); 33547c478bd9Sstevel@tonic-gate mutex_enter(&pp->p_lock); 33557c478bd9Sstevel@tonic-gate e.rcep_p.zone = zone; 33567c478bd9Sstevel@tonic-gate e.rcep_t = RCENTITY_ZONE; 33577c478bd9Sstevel@tonic-gate zone->zone_rctls = rctl_set_init(RCENTITY_ZONE, pp, &e, set, gp); 33587c478bd9Sstevel@tonic-gate mutex_exit(&pp->p_lock); 33597c478bd9Sstevel@tonic-gate rctl_prealloc_destroy(gp); 33607c478bd9Sstevel@tonic-gate 33617c478bd9Sstevel@tonic-gate /* 33627c478bd9Sstevel@tonic-gate * Apply the rctls passed in to zone_create(). This is basically a list 33637c478bd9Sstevel@tonic-gate * assignment: all of the old values are removed and the new ones 33647c478bd9Sstevel@tonic-gate * inserted. That is, if an empty list is passed in, all values are 33657c478bd9Sstevel@tonic-gate * removed. 33667c478bd9Sstevel@tonic-gate */ 33677c478bd9Sstevel@tonic-gate while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) { 33687c478bd9Sstevel@tonic-gate rctl_dict_entry_t *rde; 33697c478bd9Sstevel@tonic-gate rctl_hndl_t hndl; 33707c478bd9Sstevel@tonic-gate char *name; 33717c478bd9Sstevel@tonic-gate nvlist_t **nvlarray; 33727c478bd9Sstevel@tonic-gate uint_t i, nelem; 33737c478bd9Sstevel@tonic-gate int error; /* For ASSERT()s */ 33747c478bd9Sstevel@tonic-gate 33757c478bd9Sstevel@tonic-gate name = nvpair_name(nvp); 33767c478bd9Sstevel@tonic-gate hndl = rctl_hndl_lookup(name); 33777c478bd9Sstevel@tonic-gate ASSERT(hndl != -1); 33787c478bd9Sstevel@tonic-gate rde = rctl_dict_lookup_hndl(hndl); 33797c478bd9Sstevel@tonic-gate ASSERT(rde != NULL); 33807c478bd9Sstevel@tonic-gate 33817c478bd9Sstevel@tonic-gate for (; /* ever */; ) { 33827c478bd9Sstevel@tonic-gate rctl_val_t oval; 33837c478bd9Sstevel@tonic-gate 33847c478bd9Sstevel@tonic-gate mutex_enter(&pp->p_lock); 33857c478bd9Sstevel@tonic-gate error = rctl_local_get(hndl, NULL, &oval, pp); 33867c478bd9Sstevel@tonic-gate mutex_exit(&pp->p_lock); 33877c478bd9Sstevel@tonic-gate ASSERT(error == 0); /* Can't fail for RCTL_FIRST */ 33887c478bd9Sstevel@tonic-gate ASSERT(oval.rcv_privilege != RCPRIV_BASIC); 33897c478bd9Sstevel@tonic-gate if (oval.rcv_privilege == RCPRIV_SYSTEM) 33907c478bd9Sstevel@tonic-gate break; 33917c478bd9Sstevel@tonic-gate mutex_enter(&pp->p_lock); 33927c478bd9Sstevel@tonic-gate error = rctl_local_delete(hndl, &oval, pp); 33937c478bd9Sstevel@tonic-gate mutex_exit(&pp->p_lock); 33947c478bd9Sstevel@tonic-gate ASSERT(error == 0); 33957c478bd9Sstevel@tonic-gate } 33967c478bd9Sstevel@tonic-gate error = nvpair_value_nvlist_array(nvp, &nvlarray, &nelem); 33977c478bd9Sstevel@tonic-gate ASSERT(error == 0); 33987c478bd9Sstevel@tonic-gate for (i = 0; i < nelem; i++) { 33997c478bd9Sstevel@tonic-gate rctl_val_t *nvalp; 34007c478bd9Sstevel@tonic-gate 34017c478bd9Sstevel@tonic-gate nvalp = kmem_cache_alloc(rctl_val_cache, KM_SLEEP); 34027c478bd9Sstevel@tonic-gate error = nvlist2rctlval(nvlarray[i], nvalp); 34037c478bd9Sstevel@tonic-gate ASSERT(error == 0); 34047c478bd9Sstevel@tonic-gate /* 34057c478bd9Sstevel@tonic-gate * rctl_local_insert can fail if the value being 34067c478bd9Sstevel@tonic-gate * inserted is a duplicate; this is OK. 34077c478bd9Sstevel@tonic-gate */ 34087c478bd9Sstevel@tonic-gate mutex_enter(&pp->p_lock); 34097c478bd9Sstevel@tonic-gate if (rctl_local_insert(hndl, nvalp, pp) != 0) 34107c478bd9Sstevel@tonic-gate kmem_cache_free(rctl_val_cache, nvalp); 34117c478bd9Sstevel@tonic-gate mutex_exit(&pp->p_lock); 34127c478bd9Sstevel@tonic-gate } 34137c478bd9Sstevel@tonic-gate } 34147c478bd9Sstevel@tonic-gate /* 34157c478bd9Sstevel@tonic-gate * Tell the world that we're done setting up. 34167c478bd9Sstevel@tonic-gate * 3417bd41d0a8Snordmark * At this point we want to set the zone status to ZONE_IS_INITIALIZED 34187c478bd9Sstevel@tonic-gate * and atomically set the zone's processor set visibility. Once 34197c478bd9Sstevel@tonic-gate * we drop pool_lock() this zone will automatically get updated 34207c478bd9Sstevel@tonic-gate * to reflect any future changes to the pools configuration. 3421bd41d0a8Snordmark * 3422bd41d0a8Snordmark * Note that after we drop the locks below (zonehash_lock in 3423bd41d0a8Snordmark * particular) other operations such as a zone_getattr call can 3424bd41d0a8Snordmark * now proceed and observe the zone. That is the reason for doing a 3425bd41d0a8Snordmark * state transition to the INITIALIZED state. 34267c478bd9Sstevel@tonic-gate */ 34277c478bd9Sstevel@tonic-gate pool_lock(); 34287c478bd9Sstevel@tonic-gate mutex_enter(&cpu_lock); 34297c478bd9Sstevel@tonic-gate mutex_enter(&zonehash_lock); 34307c478bd9Sstevel@tonic-gate zone_uniqid(zone); 34317c478bd9Sstevel@tonic-gate zone_zsd_configure(zone); 34327c478bd9Sstevel@tonic-gate if (pool_state == POOL_ENABLED) 34337c478bd9Sstevel@tonic-gate zone_pset_set(zone, pool_default->pool_pset->pset_id); 34347c478bd9Sstevel@tonic-gate mutex_enter(&zone_status_lock); 34357c478bd9Sstevel@tonic-gate ASSERT(zone_status_get(zone) == ZONE_IS_UNINITIALIZED); 3436bd41d0a8Snordmark zone_status_set(zone, ZONE_IS_INITIALIZED); 34377c478bd9Sstevel@tonic-gate mutex_exit(&zone_status_lock); 34387c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 34397c478bd9Sstevel@tonic-gate mutex_exit(&cpu_lock); 34407c478bd9Sstevel@tonic-gate pool_unlock(); 34417c478bd9Sstevel@tonic-gate 3442bd41d0a8Snordmark /* Now call the create callback for this key */ 3443bd41d0a8Snordmark zsd_apply_all_keys(zsd_apply_create, zone); 3444bd41d0a8Snordmark 3445bd41d0a8Snordmark /* The callbacks are complete. Mark ZONE_IS_READY */ 3446bd41d0a8Snordmark mutex_enter(&zone_status_lock); 3447bd41d0a8Snordmark ASSERT(zone_status_get(zone) == ZONE_IS_INITIALIZED); 3448bd41d0a8Snordmark zone_status_set(zone, ZONE_IS_READY); 3449bd41d0a8Snordmark mutex_exit(&zone_status_lock); 3450bd41d0a8Snordmark 34517c478bd9Sstevel@tonic-gate /* 34527c478bd9Sstevel@tonic-gate * Once we see the zone transition to the ZONE_IS_BOOTING state, 34537c478bd9Sstevel@tonic-gate * we launch init, and set the state to running. 34547c478bd9Sstevel@tonic-gate */ 34557c478bd9Sstevel@tonic-gate zone_status_wait_cpr(zone, ZONE_IS_BOOTING, "zsched"); 34567c478bd9Sstevel@tonic-gate 34577c478bd9Sstevel@tonic-gate if (zone_status_get(zone) == ZONE_IS_BOOTING) { 34587c478bd9Sstevel@tonic-gate id_t cid; 34597c478bd9Sstevel@tonic-gate 34607c478bd9Sstevel@tonic-gate /* 34617c478bd9Sstevel@tonic-gate * Ok, this is a little complicated. We need to grab the 34627c478bd9Sstevel@tonic-gate * zone's pool's scheduling class ID; note that by now, we 34637c478bd9Sstevel@tonic-gate * are already bound to a pool if we need to be (zoneadmd 34647c478bd9Sstevel@tonic-gate * will have done that to us while we're in the READY 34657c478bd9Sstevel@tonic-gate * state). *But* the scheduling class for the zone's 'init' 34667c478bd9Sstevel@tonic-gate * must be explicitly passed to newproc, which doesn't 34677c478bd9Sstevel@tonic-gate * respect pool bindings. 34687c478bd9Sstevel@tonic-gate * 34697c478bd9Sstevel@tonic-gate * We hold the pool_lock across the call to newproc() to 34707c478bd9Sstevel@tonic-gate * close the obvious race: the pool's scheduling class 34717c478bd9Sstevel@tonic-gate * could change before we manage to create the LWP with 34727c478bd9Sstevel@tonic-gate * classid 'cid'. 34737c478bd9Sstevel@tonic-gate */ 34747c478bd9Sstevel@tonic-gate pool_lock(); 34750209230bSgjelinek if (zone->zone_defaultcid > 0) 34760209230bSgjelinek cid = zone->zone_defaultcid; 34770209230bSgjelinek else 34780209230bSgjelinek cid = pool_get_class(zone->zone_pool); 34797c478bd9Sstevel@tonic-gate if (cid == -1) 34807c478bd9Sstevel@tonic-gate cid = defaultcid; 34817c478bd9Sstevel@tonic-gate 34827c478bd9Sstevel@tonic-gate /* 34837c478bd9Sstevel@tonic-gate * If this fails, zone_boot will ultimately fail. The 34847c478bd9Sstevel@tonic-gate * state of the zone will be set to SHUTTING_DOWN-- userland 34857c478bd9Sstevel@tonic-gate * will have to tear down the zone, and fail, or try again. 34867c478bd9Sstevel@tonic-gate */ 34873f2f09c1Sdp if ((zone->zone_boot_err = newproc(zone_start_init, NULL, cid, 348835a5a358SJonathan Adams minclsyspri - 1, &ct, 0)) != 0) { 34897c478bd9Sstevel@tonic-gate mutex_enter(&zone_status_lock); 34907c478bd9Sstevel@tonic-gate zone_status_set(zone, ZONE_IS_SHUTTING_DOWN); 34917c478bd9Sstevel@tonic-gate mutex_exit(&zone_status_lock); 34927c478bd9Sstevel@tonic-gate } 34937c478bd9Sstevel@tonic-gate pool_unlock(); 34947c478bd9Sstevel@tonic-gate } 34957c478bd9Sstevel@tonic-gate 34967c478bd9Sstevel@tonic-gate /* 34977c478bd9Sstevel@tonic-gate * Wait for zone_destroy() to be called. This is what we spend 34987c478bd9Sstevel@tonic-gate * most of our life doing. 34997c478bd9Sstevel@tonic-gate */ 35007c478bd9Sstevel@tonic-gate zone_status_wait_cpr(zone, ZONE_IS_DYING, "zsched"); 35017c478bd9Sstevel@tonic-gate 35027c478bd9Sstevel@tonic-gate if (ct) 35037c478bd9Sstevel@tonic-gate /* 35047c478bd9Sstevel@tonic-gate * At this point the process contract should be empty. 35057c478bd9Sstevel@tonic-gate * (Though if it isn't, it's not the end of the world.) 35067c478bd9Sstevel@tonic-gate */ 35077c478bd9Sstevel@tonic-gate VERIFY(contract_abandon(ct, curproc, B_TRUE) == 0); 35087c478bd9Sstevel@tonic-gate 35097c478bd9Sstevel@tonic-gate /* 35107c478bd9Sstevel@tonic-gate * Allow kcred to be freed when all referring processes 35117c478bd9Sstevel@tonic-gate * (including this one) go away. We can't just do this in 35127c478bd9Sstevel@tonic-gate * zone_free because we need to wait for the zone_cred_ref to 35137c478bd9Sstevel@tonic-gate * drop to 0 before calling zone_free, and the existence of 35147c478bd9Sstevel@tonic-gate * zone_kcred will prevent that. Thus, we call crfree here to 35157c478bd9Sstevel@tonic-gate * balance the crdup in zone_create. The crhold calls earlier 35167c478bd9Sstevel@tonic-gate * in zsched will be dropped when the thread and process exit. 35177c478bd9Sstevel@tonic-gate */ 35187c478bd9Sstevel@tonic-gate crfree(zone->zone_kcred); 35197c478bd9Sstevel@tonic-gate zone->zone_kcred = NULL; 35207c478bd9Sstevel@tonic-gate 35217c478bd9Sstevel@tonic-gate exit(CLD_EXITED, 0); 35227c478bd9Sstevel@tonic-gate } 35237c478bd9Sstevel@tonic-gate 35247c478bd9Sstevel@tonic-gate /* 35257c478bd9Sstevel@tonic-gate * Helper function to determine if there are any submounts of the 35267c478bd9Sstevel@tonic-gate * provided path. Used to make sure the zone doesn't "inherit" any 35277c478bd9Sstevel@tonic-gate * mounts from before it is created. 35287c478bd9Sstevel@tonic-gate */ 35297c478bd9Sstevel@tonic-gate static uint_t 35307c478bd9Sstevel@tonic-gate zone_mount_count(const char *rootpath) 35317c478bd9Sstevel@tonic-gate { 35327c478bd9Sstevel@tonic-gate vfs_t *vfsp; 35337c478bd9Sstevel@tonic-gate uint_t count = 0; 35347c478bd9Sstevel@tonic-gate size_t rootpathlen = strlen(rootpath); 35357c478bd9Sstevel@tonic-gate 35367c478bd9Sstevel@tonic-gate /* 35377c478bd9Sstevel@tonic-gate * Holding zonehash_lock prevents race conditions with 35387c478bd9Sstevel@tonic-gate * vfs_list_add()/vfs_list_remove() since we serialize with 35397c478bd9Sstevel@tonic-gate * zone_find_by_path(). 35407c478bd9Sstevel@tonic-gate */ 35417c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&zonehash_lock)); 35427c478bd9Sstevel@tonic-gate /* 35437c478bd9Sstevel@tonic-gate * The rootpath must end with a '/' 35447c478bd9Sstevel@tonic-gate */ 35457c478bd9Sstevel@tonic-gate ASSERT(rootpath[rootpathlen - 1] == '/'); 35467c478bd9Sstevel@tonic-gate 35477c478bd9Sstevel@tonic-gate /* 35487c478bd9Sstevel@tonic-gate * This intentionally does not count the rootpath itself if that 35497c478bd9Sstevel@tonic-gate * happens to be a mount point. 35507c478bd9Sstevel@tonic-gate */ 35517c478bd9Sstevel@tonic-gate vfs_list_read_lock(); 35527c478bd9Sstevel@tonic-gate vfsp = rootvfs; 35537c478bd9Sstevel@tonic-gate do { 35547c478bd9Sstevel@tonic-gate if (strncmp(rootpath, refstr_value(vfsp->vfs_mntpt), 35557c478bd9Sstevel@tonic-gate rootpathlen) == 0) 35567c478bd9Sstevel@tonic-gate count++; 35577c478bd9Sstevel@tonic-gate vfsp = vfsp->vfs_next; 35587c478bd9Sstevel@tonic-gate } while (vfsp != rootvfs); 35597c478bd9Sstevel@tonic-gate vfs_list_unlock(); 35607c478bd9Sstevel@tonic-gate return (count); 35617c478bd9Sstevel@tonic-gate } 35627c478bd9Sstevel@tonic-gate 35637c478bd9Sstevel@tonic-gate /* 35647c478bd9Sstevel@tonic-gate * Helper function to make sure that a zone created on 'rootpath' 35657c478bd9Sstevel@tonic-gate * wouldn't end up containing other zones' rootpaths. 35667c478bd9Sstevel@tonic-gate */ 35677c478bd9Sstevel@tonic-gate static boolean_t 35687c478bd9Sstevel@tonic-gate zone_is_nested(const char *rootpath) 35697c478bd9Sstevel@tonic-gate { 35707c478bd9Sstevel@tonic-gate zone_t *zone; 35717c478bd9Sstevel@tonic-gate size_t rootpathlen = strlen(rootpath); 35727c478bd9Sstevel@tonic-gate size_t len; 35737c478bd9Sstevel@tonic-gate 35747c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&zonehash_lock)); 35757c478bd9Sstevel@tonic-gate 35762bb88978SDhanaraj M /* 35772bb88978SDhanaraj M * zone_set_root() appended '/' and '\0' at the end of rootpath 35782bb88978SDhanaraj M */ 35792bb88978SDhanaraj M if ((rootpathlen <= 3) && (rootpath[0] == '/') && 35802bb88978SDhanaraj M (rootpath[1] == '/') && (rootpath[2] == '\0')) 35812bb88978SDhanaraj M return (B_TRUE); 35822bb88978SDhanaraj M 35837c478bd9Sstevel@tonic-gate for (zone = list_head(&zone_active); zone != NULL; 35847c478bd9Sstevel@tonic-gate zone = list_next(&zone_active, zone)) { 35857c478bd9Sstevel@tonic-gate if (zone == global_zone) 35867c478bd9Sstevel@tonic-gate continue; 35877c478bd9Sstevel@tonic-gate len = strlen(zone->zone_rootpath); 35887c478bd9Sstevel@tonic-gate if (strncmp(rootpath, zone->zone_rootpath, 35897c478bd9Sstevel@tonic-gate MIN(rootpathlen, len)) == 0) 35907c478bd9Sstevel@tonic-gate return (B_TRUE); 35917c478bd9Sstevel@tonic-gate } 35927c478bd9Sstevel@tonic-gate return (B_FALSE); 35937c478bd9Sstevel@tonic-gate } 35947c478bd9Sstevel@tonic-gate 35957c478bd9Sstevel@tonic-gate static int 3596821c4a97Sdp zone_set_privset(zone_t *zone, const priv_set_t *zone_privs, 3597821c4a97Sdp size_t zone_privssz) 35987c478bd9Sstevel@tonic-gate { 35997c478bd9Sstevel@tonic-gate priv_set_t *privs = kmem_alloc(sizeof (priv_set_t), KM_SLEEP); 36007c478bd9Sstevel@tonic-gate 3601821c4a97Sdp if (zone_privssz < sizeof (priv_set_t)) 3602821c4a97Sdp return (set_errno(ENOMEM)); 3603821c4a97Sdp 36047c478bd9Sstevel@tonic-gate if (copyin(zone_privs, privs, sizeof (priv_set_t))) { 36057c478bd9Sstevel@tonic-gate kmem_free(privs, sizeof (priv_set_t)); 36067c478bd9Sstevel@tonic-gate return (EFAULT); 36077c478bd9Sstevel@tonic-gate } 36087c478bd9Sstevel@tonic-gate 36097c478bd9Sstevel@tonic-gate zone->zone_privset = privs; 36107c478bd9Sstevel@tonic-gate return (0); 36117c478bd9Sstevel@tonic-gate } 36127c478bd9Sstevel@tonic-gate 36137c478bd9Sstevel@tonic-gate /* 36147c478bd9Sstevel@tonic-gate * We make creative use of nvlists to pass in rctls from userland. The list is 36157c478bd9Sstevel@tonic-gate * a list of the following structures: 36167c478bd9Sstevel@tonic-gate * 36177c478bd9Sstevel@tonic-gate * (name = rctl_name, value = nvpair_list_array) 36187c478bd9Sstevel@tonic-gate * 36197c478bd9Sstevel@tonic-gate * Where each element of the nvpair_list_array is of the form: 36207c478bd9Sstevel@tonic-gate * 36217c478bd9Sstevel@tonic-gate * [(name = "privilege", value = RCPRIV_PRIVILEGED), 36227c478bd9Sstevel@tonic-gate * (name = "limit", value = uint64_t), 36237c478bd9Sstevel@tonic-gate * (name = "action", value = (RCTL_LOCAL_NOACTION || RCTL_LOCAL_DENY))] 36247c478bd9Sstevel@tonic-gate */ 36257c478bd9Sstevel@tonic-gate static int 36267c478bd9Sstevel@tonic-gate parse_rctls(caddr_t ubuf, size_t buflen, nvlist_t **nvlp) 36277c478bd9Sstevel@tonic-gate { 36287c478bd9Sstevel@tonic-gate nvpair_t *nvp = NULL; 36297c478bd9Sstevel@tonic-gate nvlist_t *nvl = NULL; 36307c478bd9Sstevel@tonic-gate char *kbuf; 36317c478bd9Sstevel@tonic-gate int error; 36327c478bd9Sstevel@tonic-gate rctl_val_t rv; 36337c478bd9Sstevel@tonic-gate 36347c478bd9Sstevel@tonic-gate *nvlp = NULL; 36357c478bd9Sstevel@tonic-gate 36367c478bd9Sstevel@tonic-gate if (buflen == 0) 36377c478bd9Sstevel@tonic-gate return (0); 36387c478bd9Sstevel@tonic-gate 36397c478bd9Sstevel@tonic-gate if ((kbuf = kmem_alloc(buflen, KM_NOSLEEP)) == NULL) 36407c478bd9Sstevel@tonic-gate return (ENOMEM); 36417c478bd9Sstevel@tonic-gate if (copyin(ubuf, kbuf, buflen)) { 36427c478bd9Sstevel@tonic-gate error = EFAULT; 36437c478bd9Sstevel@tonic-gate goto out; 36447c478bd9Sstevel@tonic-gate } 36457c478bd9Sstevel@tonic-gate if (nvlist_unpack(kbuf, buflen, &nvl, KM_SLEEP) != 0) { 36467c478bd9Sstevel@tonic-gate /* 36477c478bd9Sstevel@tonic-gate * nvl may have been allocated/free'd, but the value set to 36487c478bd9Sstevel@tonic-gate * non-NULL, so we reset it here. 36497c478bd9Sstevel@tonic-gate */ 36507c478bd9Sstevel@tonic-gate nvl = NULL; 36517c478bd9Sstevel@tonic-gate error = EINVAL; 36527c478bd9Sstevel@tonic-gate goto out; 36537c478bd9Sstevel@tonic-gate } 36547c478bd9Sstevel@tonic-gate while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) { 36557c478bd9Sstevel@tonic-gate rctl_dict_entry_t *rde; 36567c478bd9Sstevel@tonic-gate rctl_hndl_t hndl; 36577c478bd9Sstevel@tonic-gate nvlist_t **nvlarray; 36587c478bd9Sstevel@tonic-gate uint_t i, nelem; 36597c478bd9Sstevel@tonic-gate char *name; 36607c478bd9Sstevel@tonic-gate 36617c478bd9Sstevel@tonic-gate error = EINVAL; 36627c478bd9Sstevel@tonic-gate name = nvpair_name(nvp); 36637c478bd9Sstevel@tonic-gate if (strncmp(nvpair_name(nvp), "zone.", sizeof ("zone.") - 1) 36647c478bd9Sstevel@tonic-gate != 0 || nvpair_type(nvp) != DATA_TYPE_NVLIST_ARRAY) { 36657c478bd9Sstevel@tonic-gate goto out; 36667c478bd9Sstevel@tonic-gate } 36677c478bd9Sstevel@tonic-gate if ((hndl = rctl_hndl_lookup(name)) == -1) { 36687c478bd9Sstevel@tonic-gate goto out; 36697c478bd9Sstevel@tonic-gate } 36707c478bd9Sstevel@tonic-gate rde = rctl_dict_lookup_hndl(hndl); 36717c478bd9Sstevel@tonic-gate error = nvpair_value_nvlist_array(nvp, &nvlarray, &nelem); 36727c478bd9Sstevel@tonic-gate ASSERT(error == 0); 36737c478bd9Sstevel@tonic-gate for (i = 0; i < nelem; i++) { 36747c478bd9Sstevel@tonic-gate if (error = nvlist2rctlval(nvlarray[i], &rv)) 36757c478bd9Sstevel@tonic-gate goto out; 36767c478bd9Sstevel@tonic-gate } 36777c478bd9Sstevel@tonic-gate if (rctl_invalid_value(rde, &rv)) { 36787c478bd9Sstevel@tonic-gate error = EINVAL; 36797c478bd9Sstevel@tonic-gate goto out; 36807c478bd9Sstevel@tonic-gate } 36817c478bd9Sstevel@tonic-gate } 36827c478bd9Sstevel@tonic-gate error = 0; 36837c478bd9Sstevel@tonic-gate *nvlp = nvl; 36847c478bd9Sstevel@tonic-gate out: 36857c478bd9Sstevel@tonic-gate kmem_free(kbuf, buflen); 36867c478bd9Sstevel@tonic-gate if (error && nvl != NULL) 36877c478bd9Sstevel@tonic-gate nvlist_free(nvl); 36887c478bd9Sstevel@tonic-gate return (error); 36897c478bd9Sstevel@tonic-gate } 36907c478bd9Sstevel@tonic-gate 36917c478bd9Sstevel@tonic-gate int 36927c478bd9Sstevel@tonic-gate zone_create_error(int er_error, int er_ext, int *er_out) { 36937c478bd9Sstevel@tonic-gate if (er_out != NULL) { 36947c478bd9Sstevel@tonic-gate if (copyout(&er_ext, er_out, sizeof (int))) { 36957c478bd9Sstevel@tonic-gate return (set_errno(EFAULT)); 36967c478bd9Sstevel@tonic-gate } 36977c478bd9Sstevel@tonic-gate } 36987c478bd9Sstevel@tonic-gate return (set_errno(er_error)); 36997c478bd9Sstevel@tonic-gate } 37007c478bd9Sstevel@tonic-gate 370145916cd2Sjpk static int 370245916cd2Sjpk zone_set_label(zone_t *zone, const bslabel_t *lab, uint32_t doi) 370345916cd2Sjpk { 370445916cd2Sjpk ts_label_t *tsl; 370545916cd2Sjpk bslabel_t blab; 370645916cd2Sjpk 370745916cd2Sjpk /* Get label from user */ 370845916cd2Sjpk if (copyin(lab, &blab, sizeof (blab)) != 0) 370945916cd2Sjpk return (EFAULT); 371045916cd2Sjpk tsl = labelalloc(&blab, doi, KM_NOSLEEP); 371145916cd2Sjpk if (tsl == NULL) 371245916cd2Sjpk return (ENOMEM); 371345916cd2Sjpk 371445916cd2Sjpk zone->zone_slabel = tsl; 371545916cd2Sjpk return (0); 371645916cd2Sjpk } 371745916cd2Sjpk 3718fa9e4066Sahrens /* 3719fa9e4066Sahrens * Parses a comma-separated list of ZFS datasets into a per-zone dictionary. 3720fa9e4066Sahrens */ 3721fa9e4066Sahrens static int 3722fa9e4066Sahrens parse_zfs(zone_t *zone, caddr_t ubuf, size_t buflen) 3723fa9e4066Sahrens { 3724fa9e4066Sahrens char *kbuf; 3725fa9e4066Sahrens char *dataset, *next; 3726fa9e4066Sahrens zone_dataset_t *zd; 3727fa9e4066Sahrens size_t len; 3728fa9e4066Sahrens 3729fa9e4066Sahrens if (ubuf == NULL || buflen == 0) 3730fa9e4066Sahrens return (0); 3731fa9e4066Sahrens 3732fa9e4066Sahrens if ((kbuf = kmem_alloc(buflen, KM_NOSLEEP)) == NULL) 3733fa9e4066Sahrens return (ENOMEM); 3734fa9e4066Sahrens 3735fa9e4066Sahrens if (copyin(ubuf, kbuf, buflen) != 0) { 3736fa9e4066Sahrens kmem_free(kbuf, buflen); 3737fa9e4066Sahrens return (EFAULT); 3738fa9e4066Sahrens } 3739fa9e4066Sahrens 3740fa9e4066Sahrens dataset = next = kbuf; 3741fa9e4066Sahrens for (;;) { 3742fa9e4066Sahrens zd = kmem_alloc(sizeof (zone_dataset_t), KM_SLEEP); 3743fa9e4066Sahrens 3744fa9e4066Sahrens next = strchr(dataset, ','); 3745fa9e4066Sahrens 3746fa9e4066Sahrens if (next == NULL) 3747fa9e4066Sahrens len = strlen(dataset); 3748fa9e4066Sahrens else 3749fa9e4066Sahrens len = next - dataset; 3750fa9e4066Sahrens 3751fa9e4066Sahrens zd->zd_dataset = kmem_alloc(len + 1, KM_SLEEP); 3752fa9e4066Sahrens bcopy(dataset, zd->zd_dataset, len); 3753fa9e4066Sahrens zd->zd_dataset[len] = '\0'; 3754fa9e4066Sahrens 3755fa9e4066Sahrens list_insert_head(&zone->zone_datasets, zd); 3756fa9e4066Sahrens 3757fa9e4066Sahrens if (next == NULL) 3758fa9e4066Sahrens break; 3759fa9e4066Sahrens 3760fa9e4066Sahrens dataset = next + 1; 3761fa9e4066Sahrens } 3762fa9e4066Sahrens 3763fa9e4066Sahrens kmem_free(kbuf, buflen); 3764fa9e4066Sahrens return (0); 3765fa9e4066Sahrens } 3766fa9e4066Sahrens 37677c478bd9Sstevel@tonic-gate /* 37687c478bd9Sstevel@tonic-gate * System call to create/initialize a new zone named 'zone_name', rooted 37697c478bd9Sstevel@tonic-gate * at 'zone_root', with a zone-wide privilege limit set of 'zone_privs', 377045916cd2Sjpk * and initialized with the zone-wide rctls described in 'rctlbuf', and 377145916cd2Sjpk * with labeling set by 'match', 'doi', and 'label'. 37727c478bd9Sstevel@tonic-gate * 37737c478bd9Sstevel@tonic-gate * If extended error is non-null, we may use it to return more detailed 37747c478bd9Sstevel@tonic-gate * error information. 37757c478bd9Sstevel@tonic-gate */ 37767c478bd9Sstevel@tonic-gate static zoneid_t 37777c478bd9Sstevel@tonic-gate zone_create(const char *zone_name, const char *zone_root, 3778821c4a97Sdp const priv_set_t *zone_privs, size_t zone_privssz, 3779821c4a97Sdp caddr_t rctlbuf, size_t rctlbufsz, 378045916cd2Sjpk caddr_t zfsbuf, size_t zfsbufsz, int *extended_error, 3781f4b3ec61Sdh int match, uint32_t doi, const bslabel_t *label, 3782f4b3ec61Sdh int flags) 37837c478bd9Sstevel@tonic-gate { 37847c478bd9Sstevel@tonic-gate struct zsched_arg zarg; 37857c478bd9Sstevel@tonic-gate nvlist_t *rctls = NULL; 37867c478bd9Sstevel@tonic-gate proc_t *pp = curproc; 37877c478bd9Sstevel@tonic-gate zone_t *zone, *ztmp; 37887c478bd9Sstevel@tonic-gate zoneid_t zoneid; 37897c478bd9Sstevel@tonic-gate int error; 37907c478bd9Sstevel@tonic-gate int error2 = 0; 37917c478bd9Sstevel@tonic-gate char *str; 37927c478bd9Sstevel@tonic-gate cred_t *zkcr; 379348451833Scarlsonj boolean_t insert_label_hash; 37947c478bd9Sstevel@tonic-gate 37957c478bd9Sstevel@tonic-gate if (secpolicy_zone_config(CRED()) != 0) 37967c478bd9Sstevel@tonic-gate return (set_errno(EPERM)); 37977c478bd9Sstevel@tonic-gate 37987c478bd9Sstevel@tonic-gate /* can't boot zone from within chroot environment */ 37997c478bd9Sstevel@tonic-gate if (PTOU(pp)->u_rdir != NULL && PTOU(pp)->u_rdir != rootdir) 38007c478bd9Sstevel@tonic-gate return (zone_create_error(ENOTSUP, ZE_CHROOTED, 3801821c4a97Sdp extended_error)); 38027c478bd9Sstevel@tonic-gate 38037c478bd9Sstevel@tonic-gate zone = kmem_zalloc(sizeof (zone_t), KM_SLEEP); 38047c478bd9Sstevel@tonic-gate zoneid = zone->zone_id = id_alloc(zoneid_space); 38057c478bd9Sstevel@tonic-gate zone->zone_status = ZONE_IS_UNINITIALIZED; 38067c478bd9Sstevel@tonic-gate zone->zone_pool = pool_default; 38077c478bd9Sstevel@tonic-gate zone->zone_pool_mod = gethrtime(); 38087c478bd9Sstevel@tonic-gate zone->zone_psetid = ZONE_PS_INVAL; 38097c478bd9Sstevel@tonic-gate zone->zone_ncpus = 0; 38107c478bd9Sstevel@tonic-gate zone->zone_ncpus_online = 0; 38119acbbeafSnn zone->zone_restart_init = B_TRUE; 38129acbbeafSnn zone->zone_brand = &native_brand; 38139acbbeafSnn zone->zone_initname = NULL; 38147c478bd9Sstevel@tonic-gate mutex_init(&zone->zone_lock, NULL, MUTEX_DEFAULT, NULL); 38157c478bd9Sstevel@tonic-gate mutex_init(&zone->zone_nlwps_lock, NULL, MUTEX_DEFAULT, NULL); 38160209230bSgjelinek mutex_init(&zone->zone_mem_lock, NULL, MUTEX_DEFAULT, NULL); 38177c478bd9Sstevel@tonic-gate cv_init(&zone->zone_cv, NULL, CV_DEFAULT, NULL); 38187c478bd9Sstevel@tonic-gate list_create(&zone->zone_zsd, sizeof (struct zsd_entry), 38197c478bd9Sstevel@tonic-gate offsetof(struct zsd_entry, zsd_linkage)); 3820fa9e4066Sahrens list_create(&zone->zone_datasets, sizeof (zone_dataset_t), 3821fa9e4066Sahrens offsetof(zone_dataset_t, zd_linkage)); 38222b24ab6bSSebastien Roy list_create(&zone->zone_dl_list, sizeof (zone_dl_t), 38232b24ab6bSSebastien Roy offsetof(zone_dl_t, zdl_linkage)); 382445916cd2Sjpk rw_init(&zone->zone_mlps.mlpl_rwlock, NULL, RW_DEFAULT, NULL); 3825835ee219SRobert Harris rw_init(&zone->zone_mntfs_db_lock, NULL, RW_DEFAULT, NULL); 38267c478bd9Sstevel@tonic-gate 3827f4b3ec61Sdh if (flags & ZCF_NET_EXCL) { 3828f4b3ec61Sdh zone->zone_flags |= ZF_NET_EXCL; 3829f4b3ec61Sdh } 3830f4b3ec61Sdh 38317c478bd9Sstevel@tonic-gate if ((error = zone_set_name(zone, zone_name)) != 0) { 38327c478bd9Sstevel@tonic-gate zone_free(zone); 38337c478bd9Sstevel@tonic-gate return (zone_create_error(error, 0, extended_error)); 38347c478bd9Sstevel@tonic-gate } 38357c478bd9Sstevel@tonic-gate 38367c478bd9Sstevel@tonic-gate if ((error = zone_set_root(zone, zone_root)) != 0) { 38377c478bd9Sstevel@tonic-gate zone_free(zone); 38387c478bd9Sstevel@tonic-gate return (zone_create_error(error, 0, extended_error)); 38397c478bd9Sstevel@tonic-gate } 3840821c4a97Sdp if ((error = zone_set_privset(zone, zone_privs, zone_privssz)) != 0) { 38417c478bd9Sstevel@tonic-gate zone_free(zone); 38427c478bd9Sstevel@tonic-gate return (zone_create_error(error, 0, extended_error)); 38437c478bd9Sstevel@tonic-gate } 38447c478bd9Sstevel@tonic-gate 38457c478bd9Sstevel@tonic-gate /* initialize node name to be the same as zone name */ 38467c478bd9Sstevel@tonic-gate zone->zone_nodename = kmem_alloc(_SYS_NMLN, KM_SLEEP); 38477c478bd9Sstevel@tonic-gate (void) strncpy(zone->zone_nodename, zone->zone_name, _SYS_NMLN); 38487c478bd9Sstevel@tonic-gate zone->zone_nodename[_SYS_NMLN - 1] = '\0'; 38497c478bd9Sstevel@tonic-gate 38507c478bd9Sstevel@tonic-gate zone->zone_domain = kmem_alloc(_SYS_NMLN, KM_SLEEP); 38517c478bd9Sstevel@tonic-gate zone->zone_domain[0] = '\0'; 38525679c89fSjv zone->zone_hostid = HW_INVALID_HOSTID; 38537c478bd9Sstevel@tonic-gate zone->zone_shares = 1; 3854824c205fSml zone->zone_shmmax = 0; 3855824c205fSml zone->zone_ipc.ipcq_shmmni = 0; 3856824c205fSml zone->zone_ipc.ipcq_semmni = 0; 3857824c205fSml zone->zone_ipc.ipcq_msgmni = 0; 38587c478bd9Sstevel@tonic-gate zone->zone_bootargs = NULL; 38593f2f09c1Sdp zone->zone_initname = 38603f2f09c1Sdp kmem_alloc(strlen(zone_default_initname) + 1, KM_SLEEP); 38613f2f09c1Sdp (void) strcpy(zone->zone_initname, zone_default_initname); 38620209230bSgjelinek zone->zone_nlwps = 0; 38630209230bSgjelinek zone->zone_nlwps_ctl = INT_MAX; 3864c6939658Ssl zone->zone_locked_mem = 0; 3865c6939658Ssl zone->zone_locked_mem_ctl = UINT64_MAX; 38660209230bSgjelinek zone->zone_max_swap = 0; 38670209230bSgjelinek zone->zone_max_swap_ctl = UINT64_MAX; 38680209230bSgjelinek zone0.zone_lockedmem_kstat = NULL; 38690209230bSgjelinek zone0.zone_swapresv_kstat = NULL; 38707c478bd9Sstevel@tonic-gate 38717c478bd9Sstevel@tonic-gate /* 38727c478bd9Sstevel@tonic-gate * Zsched initializes the rctls. 38737c478bd9Sstevel@tonic-gate */ 38747c478bd9Sstevel@tonic-gate zone->zone_rctls = NULL; 38757c478bd9Sstevel@tonic-gate 38767c478bd9Sstevel@tonic-gate if ((error = parse_rctls(rctlbuf, rctlbufsz, &rctls)) != 0) { 38777c478bd9Sstevel@tonic-gate zone_free(zone); 38787c478bd9Sstevel@tonic-gate return (zone_create_error(error, 0, extended_error)); 38797c478bd9Sstevel@tonic-gate } 38807c478bd9Sstevel@tonic-gate 3881fa9e4066Sahrens if ((error = parse_zfs(zone, zfsbuf, zfsbufsz)) != 0) { 3882fa9e4066Sahrens zone_free(zone); 3883fa9e4066Sahrens return (set_errno(error)); 3884fa9e4066Sahrens } 3885fa9e4066Sahrens 388645916cd2Sjpk /* 388745916cd2Sjpk * Read in the trusted system parameters: 388845916cd2Sjpk * match flag and sensitivity label. 388945916cd2Sjpk */ 389045916cd2Sjpk zone->zone_match = match; 389148451833Scarlsonj if (is_system_labeled() && !(zone->zone_flags & ZF_IS_SCRATCH)) { 38927e6639c2Skp /* Fail if requested to set doi to anything but system's doi */ 38937e6639c2Skp if (doi != 0 && doi != default_doi) { 38947e6639c2Skp zone_free(zone); 38957e6639c2Skp return (set_errno(EINVAL)); 38967e6639c2Skp } 38977e6639c2Skp /* Always apply system's doi to the zone */ 38987e6639c2Skp error = zone_set_label(zone, label, default_doi); 389945916cd2Sjpk if (error != 0) { 390045916cd2Sjpk zone_free(zone); 390145916cd2Sjpk return (set_errno(error)); 390245916cd2Sjpk } 390348451833Scarlsonj insert_label_hash = B_TRUE; 390445916cd2Sjpk } else { 390545916cd2Sjpk /* all zones get an admin_low label if system is not labeled */ 390645916cd2Sjpk zone->zone_slabel = l_admin_low; 390745916cd2Sjpk label_hold(l_admin_low); 390848451833Scarlsonj insert_label_hash = B_FALSE; 390945916cd2Sjpk } 391045916cd2Sjpk 39117c478bd9Sstevel@tonic-gate /* 39127c478bd9Sstevel@tonic-gate * Stop all lwps since that's what normally happens as part of fork(). 39137c478bd9Sstevel@tonic-gate * This needs to happen before we grab any locks to avoid deadlock 39147c478bd9Sstevel@tonic-gate * (another lwp in the process could be waiting for the held lock). 39157c478bd9Sstevel@tonic-gate */ 39167c478bd9Sstevel@tonic-gate if (curthread != pp->p_agenttp && !holdlwps(SHOLDFORK)) { 39177c478bd9Sstevel@tonic-gate zone_free(zone); 39187c478bd9Sstevel@tonic-gate if (rctls) 39197c478bd9Sstevel@tonic-gate nvlist_free(rctls); 39207c478bd9Sstevel@tonic-gate return (zone_create_error(error, 0, extended_error)); 39217c478bd9Sstevel@tonic-gate } 39227c478bd9Sstevel@tonic-gate 39237c478bd9Sstevel@tonic-gate if (block_mounts() == 0) { 39247c478bd9Sstevel@tonic-gate mutex_enter(&pp->p_lock); 39257c478bd9Sstevel@tonic-gate if (curthread != pp->p_agenttp) 39267c478bd9Sstevel@tonic-gate continuelwps(pp); 39277c478bd9Sstevel@tonic-gate mutex_exit(&pp->p_lock); 39287c478bd9Sstevel@tonic-gate zone_free(zone); 39297c478bd9Sstevel@tonic-gate if (rctls) 39307c478bd9Sstevel@tonic-gate nvlist_free(rctls); 39317c478bd9Sstevel@tonic-gate return (zone_create_error(error, 0, extended_error)); 39327c478bd9Sstevel@tonic-gate } 39337c478bd9Sstevel@tonic-gate 39347c478bd9Sstevel@tonic-gate /* 39357c478bd9Sstevel@tonic-gate * Set up credential for kernel access. After this, any errors 39367c478bd9Sstevel@tonic-gate * should go through the dance in errout rather than calling 39377c478bd9Sstevel@tonic-gate * zone_free directly. 39387c478bd9Sstevel@tonic-gate */ 39397c478bd9Sstevel@tonic-gate zone->zone_kcred = crdup(kcred); 39407c478bd9Sstevel@tonic-gate crsetzone(zone->zone_kcred, zone); 39417c478bd9Sstevel@tonic-gate priv_intersect(zone->zone_privset, &CR_PPRIV(zone->zone_kcred)); 39427c478bd9Sstevel@tonic-gate priv_intersect(zone->zone_privset, &CR_EPRIV(zone->zone_kcred)); 39437c478bd9Sstevel@tonic-gate priv_intersect(zone->zone_privset, &CR_IPRIV(zone->zone_kcred)); 39447c478bd9Sstevel@tonic-gate priv_intersect(zone->zone_privset, &CR_LPRIV(zone->zone_kcred)); 39457c478bd9Sstevel@tonic-gate 39467c478bd9Sstevel@tonic-gate mutex_enter(&zonehash_lock); 39477c478bd9Sstevel@tonic-gate /* 39487c478bd9Sstevel@tonic-gate * Make sure zone doesn't already exist. 394945916cd2Sjpk * 395045916cd2Sjpk * If the system and zone are labeled, 395145916cd2Sjpk * make sure no other zone exists that has the same label. 39527c478bd9Sstevel@tonic-gate */ 395345916cd2Sjpk if ((ztmp = zone_find_all_by_name(zone->zone_name)) != NULL || 395448451833Scarlsonj (insert_label_hash && 395545916cd2Sjpk (ztmp = zone_find_all_by_label(zone->zone_slabel)) != NULL)) { 39567c478bd9Sstevel@tonic-gate zone_status_t status; 39577c478bd9Sstevel@tonic-gate 39587c478bd9Sstevel@tonic-gate status = zone_status_get(ztmp); 39597c478bd9Sstevel@tonic-gate if (status == ZONE_IS_READY || status == ZONE_IS_RUNNING) 39607c478bd9Sstevel@tonic-gate error = EEXIST; 39617c478bd9Sstevel@tonic-gate else 39627c478bd9Sstevel@tonic-gate error = EBUSY; 39638c55461bSton 39648c55461bSton if (insert_label_hash) 39658c55461bSton error2 = ZE_LABELINUSE; 39668c55461bSton 39677c478bd9Sstevel@tonic-gate goto errout; 39687c478bd9Sstevel@tonic-gate } 39697c478bd9Sstevel@tonic-gate 39707c478bd9Sstevel@tonic-gate /* 39717c478bd9Sstevel@tonic-gate * Don't allow zone creations which would cause one zone's rootpath to 39727c478bd9Sstevel@tonic-gate * be accessible from that of another (non-global) zone. 39737c478bd9Sstevel@tonic-gate */ 39747c478bd9Sstevel@tonic-gate if (zone_is_nested(zone->zone_rootpath)) { 39757c478bd9Sstevel@tonic-gate error = EBUSY; 39767c478bd9Sstevel@tonic-gate goto errout; 39777c478bd9Sstevel@tonic-gate } 39787c478bd9Sstevel@tonic-gate 39797c478bd9Sstevel@tonic-gate ASSERT(zonecount != 0); /* check for leaks */ 39807c478bd9Sstevel@tonic-gate if (zonecount + 1 > maxzones) { 39817c478bd9Sstevel@tonic-gate error = ENOMEM; 39827c478bd9Sstevel@tonic-gate goto errout; 39837c478bd9Sstevel@tonic-gate } 39847c478bd9Sstevel@tonic-gate 39857c478bd9Sstevel@tonic-gate if (zone_mount_count(zone->zone_rootpath) != 0) { 39867c478bd9Sstevel@tonic-gate error = EBUSY; 39877c478bd9Sstevel@tonic-gate error2 = ZE_AREMOUNTS; 39887c478bd9Sstevel@tonic-gate goto errout; 39897c478bd9Sstevel@tonic-gate } 39907c478bd9Sstevel@tonic-gate 39917c478bd9Sstevel@tonic-gate /* 39927c478bd9Sstevel@tonic-gate * Zone is still incomplete, but we need to drop all locks while 39937c478bd9Sstevel@tonic-gate * zsched() initializes this zone's kernel process. We 39947c478bd9Sstevel@tonic-gate * optimistically add the zone to the hashtable and associated 39957c478bd9Sstevel@tonic-gate * lists so a parallel zone_create() doesn't try to create the 39967c478bd9Sstevel@tonic-gate * same zone. 39977c478bd9Sstevel@tonic-gate */ 39987c478bd9Sstevel@tonic-gate zonecount++; 39997c478bd9Sstevel@tonic-gate (void) mod_hash_insert(zonehashbyid, 40007c478bd9Sstevel@tonic-gate (mod_hash_key_t)(uintptr_t)zone->zone_id, 40017c478bd9Sstevel@tonic-gate (mod_hash_val_t)(uintptr_t)zone); 40027c478bd9Sstevel@tonic-gate str = kmem_alloc(strlen(zone->zone_name) + 1, KM_SLEEP); 40037c478bd9Sstevel@tonic-gate (void) strcpy(str, zone->zone_name); 40047c478bd9Sstevel@tonic-gate (void) mod_hash_insert(zonehashbyname, (mod_hash_key_t)str, 40057c478bd9Sstevel@tonic-gate (mod_hash_val_t)(uintptr_t)zone); 400648451833Scarlsonj if (insert_label_hash) { 400745916cd2Sjpk (void) mod_hash_insert(zonehashbylabel, 400845916cd2Sjpk (mod_hash_key_t)zone->zone_slabel, (mod_hash_val_t)zone); 400948451833Scarlsonj zone->zone_flags |= ZF_HASHED_LABEL; 401045916cd2Sjpk } 401145916cd2Sjpk 40127c478bd9Sstevel@tonic-gate /* 40137c478bd9Sstevel@tonic-gate * Insert into active list. At this point there are no 'hold's 40147c478bd9Sstevel@tonic-gate * on the zone, but everyone else knows not to use it, so we can 40157c478bd9Sstevel@tonic-gate * continue to use it. zsched() will do a zone_hold() if the 40167c478bd9Sstevel@tonic-gate * newproc() is successful. 40177c478bd9Sstevel@tonic-gate */ 40187c478bd9Sstevel@tonic-gate list_insert_tail(&zone_active, zone); 40197c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 40207c478bd9Sstevel@tonic-gate 40217c478bd9Sstevel@tonic-gate zarg.zone = zone; 40227c478bd9Sstevel@tonic-gate zarg.nvlist = rctls; 40237c478bd9Sstevel@tonic-gate /* 40247c478bd9Sstevel@tonic-gate * The process, task, and project rctls are probably wrong; 40257c478bd9Sstevel@tonic-gate * we need an interface to get the default values of all rctls, 40267c478bd9Sstevel@tonic-gate * and initialize zsched appropriately. I'm not sure that that 40277c478bd9Sstevel@tonic-gate * makes much of a difference, though. 40287c478bd9Sstevel@tonic-gate */ 402935a5a358SJonathan Adams error = newproc(zsched, (void *)&zarg, syscid, minclsyspri, NULL, 0); 403035a5a358SJonathan Adams if (error != 0) { 40317c478bd9Sstevel@tonic-gate /* 40327c478bd9Sstevel@tonic-gate * We need to undo all globally visible state. 40337c478bd9Sstevel@tonic-gate */ 40347c478bd9Sstevel@tonic-gate mutex_enter(&zonehash_lock); 40357c478bd9Sstevel@tonic-gate list_remove(&zone_active, zone); 403648451833Scarlsonj if (zone->zone_flags & ZF_HASHED_LABEL) { 403745916cd2Sjpk ASSERT(zone->zone_slabel != NULL); 403845916cd2Sjpk (void) mod_hash_destroy(zonehashbylabel, 403945916cd2Sjpk (mod_hash_key_t)zone->zone_slabel); 404045916cd2Sjpk } 40417c478bd9Sstevel@tonic-gate (void) mod_hash_destroy(zonehashbyname, 40427c478bd9Sstevel@tonic-gate (mod_hash_key_t)(uintptr_t)zone->zone_name); 40437c478bd9Sstevel@tonic-gate (void) mod_hash_destroy(zonehashbyid, 40447c478bd9Sstevel@tonic-gate (mod_hash_key_t)(uintptr_t)zone->zone_id); 40457c478bd9Sstevel@tonic-gate ASSERT(zonecount > 1); 40467c478bd9Sstevel@tonic-gate zonecount--; 40477c478bd9Sstevel@tonic-gate goto errout; 40487c478bd9Sstevel@tonic-gate } 40497c478bd9Sstevel@tonic-gate 40507c478bd9Sstevel@tonic-gate /* 40517c478bd9Sstevel@tonic-gate * Zone creation can't fail from now on. 40527c478bd9Sstevel@tonic-gate */ 40537c478bd9Sstevel@tonic-gate 40540209230bSgjelinek /* 40550209230bSgjelinek * Create zone kstats 40560209230bSgjelinek */ 40570209230bSgjelinek zone_kstat_create(zone); 40580209230bSgjelinek 40597c478bd9Sstevel@tonic-gate /* 40607c478bd9Sstevel@tonic-gate * Let the other lwps continue. 40617c478bd9Sstevel@tonic-gate */ 40627c478bd9Sstevel@tonic-gate mutex_enter(&pp->p_lock); 40637c478bd9Sstevel@tonic-gate if (curthread != pp->p_agenttp) 40647c478bd9Sstevel@tonic-gate continuelwps(pp); 40657c478bd9Sstevel@tonic-gate mutex_exit(&pp->p_lock); 40667c478bd9Sstevel@tonic-gate 40677c478bd9Sstevel@tonic-gate /* 40687c478bd9Sstevel@tonic-gate * Wait for zsched to finish initializing the zone. 40697c478bd9Sstevel@tonic-gate */ 40707c478bd9Sstevel@tonic-gate zone_status_wait(zone, ZONE_IS_READY); 40717c478bd9Sstevel@tonic-gate /* 40727c478bd9Sstevel@tonic-gate * The zone is fully visible, so we can let mounts progress. 40737c478bd9Sstevel@tonic-gate */ 40747c478bd9Sstevel@tonic-gate resume_mounts(); 40757c478bd9Sstevel@tonic-gate if (rctls) 40767c478bd9Sstevel@tonic-gate nvlist_free(rctls); 40777c478bd9Sstevel@tonic-gate 40787c478bd9Sstevel@tonic-gate return (zoneid); 40797c478bd9Sstevel@tonic-gate 40807c478bd9Sstevel@tonic-gate errout: 40817c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 40827c478bd9Sstevel@tonic-gate /* 40837c478bd9Sstevel@tonic-gate * Let the other lwps continue. 40847c478bd9Sstevel@tonic-gate */ 40857c478bd9Sstevel@tonic-gate mutex_enter(&pp->p_lock); 40867c478bd9Sstevel@tonic-gate if (curthread != pp->p_agenttp) 40877c478bd9Sstevel@tonic-gate continuelwps(pp); 40887c478bd9Sstevel@tonic-gate mutex_exit(&pp->p_lock); 40897c478bd9Sstevel@tonic-gate 40907c478bd9Sstevel@tonic-gate resume_mounts(); 40917c478bd9Sstevel@tonic-gate if (rctls) 40927c478bd9Sstevel@tonic-gate nvlist_free(rctls); 40937c478bd9Sstevel@tonic-gate /* 40947c478bd9Sstevel@tonic-gate * There is currently one reference to the zone, a cred_ref from 40957c478bd9Sstevel@tonic-gate * zone_kcred. To free the zone, we call crfree, which will call 40967c478bd9Sstevel@tonic-gate * zone_cred_rele, which will call zone_free. 40977c478bd9Sstevel@tonic-gate */ 40987c478bd9Sstevel@tonic-gate ASSERT(zone->zone_cred_ref == 1); /* for zone_kcred */ 40997c478bd9Sstevel@tonic-gate ASSERT(zone->zone_kcred->cr_ref == 1); 41007c478bd9Sstevel@tonic-gate ASSERT(zone->zone_ref == 0); 41017c478bd9Sstevel@tonic-gate zkcr = zone->zone_kcred; 41027c478bd9Sstevel@tonic-gate zone->zone_kcred = NULL; 41037c478bd9Sstevel@tonic-gate crfree(zkcr); /* triggers call to zone_free */ 41047c478bd9Sstevel@tonic-gate return (zone_create_error(error, error2, extended_error)); 41057c478bd9Sstevel@tonic-gate } 41067c478bd9Sstevel@tonic-gate 41077c478bd9Sstevel@tonic-gate /* 41087c478bd9Sstevel@tonic-gate * Cause the zone to boot. This is pretty simple, since we let zoneadmd do 41093f2f09c1Sdp * the heavy lifting. initname is the path to the program to launch 41103f2f09c1Sdp * at the "top" of the zone; if this is NULL, we use the system default, 41113f2f09c1Sdp * which is stored at zone_default_initname. 41127c478bd9Sstevel@tonic-gate */ 41137c478bd9Sstevel@tonic-gate static int 41143f2f09c1Sdp zone_boot(zoneid_t zoneid) 41157c478bd9Sstevel@tonic-gate { 41167c478bd9Sstevel@tonic-gate int err; 41177c478bd9Sstevel@tonic-gate zone_t *zone; 41187c478bd9Sstevel@tonic-gate 41197c478bd9Sstevel@tonic-gate if (secpolicy_zone_config(CRED()) != 0) 41207c478bd9Sstevel@tonic-gate return (set_errno(EPERM)); 41217c478bd9Sstevel@tonic-gate if (zoneid < MIN_USERZONEID || zoneid > MAX_ZONEID) 41227c478bd9Sstevel@tonic-gate return (set_errno(EINVAL)); 41237c478bd9Sstevel@tonic-gate 41247c478bd9Sstevel@tonic-gate mutex_enter(&zonehash_lock); 41257c478bd9Sstevel@tonic-gate /* 41267c478bd9Sstevel@tonic-gate * Look for zone under hash lock to prevent races with calls to 41277c478bd9Sstevel@tonic-gate * zone_shutdown, zone_destroy, etc. 41287c478bd9Sstevel@tonic-gate */ 41297c478bd9Sstevel@tonic-gate if ((zone = zone_find_all_by_id(zoneid)) == NULL) { 41307c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 41317c478bd9Sstevel@tonic-gate return (set_errno(EINVAL)); 41327c478bd9Sstevel@tonic-gate } 41337c478bd9Sstevel@tonic-gate 41347c478bd9Sstevel@tonic-gate mutex_enter(&zone_status_lock); 41357c478bd9Sstevel@tonic-gate if (zone_status_get(zone) != ZONE_IS_READY) { 41367c478bd9Sstevel@tonic-gate mutex_exit(&zone_status_lock); 41377c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 41387c478bd9Sstevel@tonic-gate return (set_errno(EINVAL)); 41397c478bd9Sstevel@tonic-gate } 41407c478bd9Sstevel@tonic-gate zone_status_set(zone, ZONE_IS_BOOTING); 41417c478bd9Sstevel@tonic-gate mutex_exit(&zone_status_lock); 41427c478bd9Sstevel@tonic-gate 41437c478bd9Sstevel@tonic-gate zone_hold(zone); /* so we can use the zone_t later */ 41447c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 41457c478bd9Sstevel@tonic-gate 41467c478bd9Sstevel@tonic-gate if (zone_status_wait_sig(zone, ZONE_IS_RUNNING) == 0) { 41477c478bd9Sstevel@tonic-gate zone_rele(zone); 41487c478bd9Sstevel@tonic-gate return (set_errno(EINTR)); 41497c478bd9Sstevel@tonic-gate } 41507c478bd9Sstevel@tonic-gate 41517c478bd9Sstevel@tonic-gate /* 41527c478bd9Sstevel@tonic-gate * Boot (starting init) might have failed, in which case the zone 41537c478bd9Sstevel@tonic-gate * will go to the SHUTTING_DOWN state; an appropriate errno will 41547c478bd9Sstevel@tonic-gate * be placed in zone->zone_boot_err, and so we return that. 41557c478bd9Sstevel@tonic-gate */ 41567c478bd9Sstevel@tonic-gate err = zone->zone_boot_err; 41577c478bd9Sstevel@tonic-gate zone_rele(zone); 41587c478bd9Sstevel@tonic-gate return (err ? set_errno(err) : 0); 41597c478bd9Sstevel@tonic-gate } 41607c478bd9Sstevel@tonic-gate 41617c478bd9Sstevel@tonic-gate /* 41627c478bd9Sstevel@tonic-gate * Kills all user processes in the zone, waiting for them all to exit 41637c478bd9Sstevel@tonic-gate * before returning. 41647c478bd9Sstevel@tonic-gate */ 41657c478bd9Sstevel@tonic-gate static int 41667c478bd9Sstevel@tonic-gate zone_empty(zone_t *zone) 41677c478bd9Sstevel@tonic-gate { 41687c478bd9Sstevel@tonic-gate int waitstatus; 41697c478bd9Sstevel@tonic-gate 41707c478bd9Sstevel@tonic-gate /* 41717c478bd9Sstevel@tonic-gate * We need to drop zonehash_lock before killing all 41727c478bd9Sstevel@tonic-gate * processes, otherwise we'll deadlock with zone_find_* 41737c478bd9Sstevel@tonic-gate * which can be called from the exit path. 41747c478bd9Sstevel@tonic-gate */ 41757c478bd9Sstevel@tonic-gate ASSERT(MUTEX_NOT_HELD(&zonehash_lock)); 4176d3d50737SRafael Vanoni while ((waitstatus = zone_status_timedwait_sig(zone, 4177d3d50737SRafael Vanoni ddi_get_lbolt() + hz, ZONE_IS_EMPTY)) == -1) { 41787c478bd9Sstevel@tonic-gate killall(zone->zone_id); 41797c478bd9Sstevel@tonic-gate } 41807c478bd9Sstevel@tonic-gate /* 41817c478bd9Sstevel@tonic-gate * return EINTR if we were signaled 41827c478bd9Sstevel@tonic-gate */ 41837c478bd9Sstevel@tonic-gate if (waitstatus == 0) 41847c478bd9Sstevel@tonic-gate return (EINTR); 41857c478bd9Sstevel@tonic-gate return (0); 41867c478bd9Sstevel@tonic-gate } 41877c478bd9Sstevel@tonic-gate 418845916cd2Sjpk /* 418945916cd2Sjpk * This function implements the policy for zone visibility. 419045916cd2Sjpk * 419145916cd2Sjpk * In standard Solaris, a non-global zone can only see itself. 419245916cd2Sjpk * 419345916cd2Sjpk * In Trusted Extensions, a labeled zone can lookup any zone whose label 419445916cd2Sjpk * it dominates. For this test, the label of the global zone is treated as 419545916cd2Sjpk * admin_high so it is special-cased instead of being checked for dominance. 419645916cd2Sjpk * 419745916cd2Sjpk * Returns true if zone attributes are viewable, false otherwise. 419845916cd2Sjpk */ 419945916cd2Sjpk static boolean_t 420045916cd2Sjpk zone_list_access(zone_t *zone) 420145916cd2Sjpk { 420245916cd2Sjpk 420345916cd2Sjpk if (curproc->p_zone == global_zone || 420445916cd2Sjpk curproc->p_zone == zone) { 420545916cd2Sjpk return (B_TRUE); 420648451833Scarlsonj } else if (is_system_labeled() && !(zone->zone_flags & ZF_IS_SCRATCH)) { 420745916cd2Sjpk bslabel_t *curproc_label; 420845916cd2Sjpk bslabel_t *zone_label; 420945916cd2Sjpk 421045916cd2Sjpk curproc_label = label2bslabel(curproc->p_zone->zone_slabel); 421145916cd2Sjpk zone_label = label2bslabel(zone->zone_slabel); 421245916cd2Sjpk 421345916cd2Sjpk if (zone->zone_id != GLOBAL_ZONEID && 421445916cd2Sjpk bldominates(curproc_label, zone_label)) { 421545916cd2Sjpk return (B_TRUE); 421645916cd2Sjpk } else { 421745916cd2Sjpk return (B_FALSE); 421845916cd2Sjpk } 421945916cd2Sjpk } else { 422045916cd2Sjpk return (B_FALSE); 422145916cd2Sjpk } 422245916cd2Sjpk } 422345916cd2Sjpk 42247c478bd9Sstevel@tonic-gate /* 42257c478bd9Sstevel@tonic-gate * Systemcall to start the zone's halt sequence. By the time this 42267c478bd9Sstevel@tonic-gate * function successfully returns, all user processes and kernel threads 42277c478bd9Sstevel@tonic-gate * executing in it will have exited, ZSD shutdown callbacks executed, 42287c478bd9Sstevel@tonic-gate * and the zone status set to ZONE_IS_DOWN. 42297c478bd9Sstevel@tonic-gate * 42307c478bd9Sstevel@tonic-gate * It is possible that the call will interrupt itself if the caller is the 42317c478bd9Sstevel@tonic-gate * parent of any process running in the zone, and doesn't have SIGCHLD blocked. 42327c478bd9Sstevel@tonic-gate */ 42337c478bd9Sstevel@tonic-gate static int 42347c478bd9Sstevel@tonic-gate zone_shutdown(zoneid_t zoneid) 42357c478bd9Sstevel@tonic-gate { 42367c478bd9Sstevel@tonic-gate int error; 42377c478bd9Sstevel@tonic-gate zone_t *zone; 42387c478bd9Sstevel@tonic-gate zone_status_t status; 42397c478bd9Sstevel@tonic-gate 42407c478bd9Sstevel@tonic-gate if (secpolicy_zone_config(CRED()) != 0) 42417c478bd9Sstevel@tonic-gate return (set_errno(EPERM)); 42427c478bd9Sstevel@tonic-gate if (zoneid < MIN_USERZONEID || zoneid > MAX_ZONEID) 42437c478bd9Sstevel@tonic-gate return (set_errno(EINVAL)); 42447c478bd9Sstevel@tonic-gate 42457c478bd9Sstevel@tonic-gate /* 42467c478bd9Sstevel@tonic-gate * Block mounts so that VFS_MOUNT() can get an accurate view of 42477c478bd9Sstevel@tonic-gate * the zone's status with regards to ZONE_IS_SHUTTING down. 42487c478bd9Sstevel@tonic-gate * 42497c478bd9Sstevel@tonic-gate * e.g. NFS can fail the mount if it determines that the zone 42507c478bd9Sstevel@tonic-gate * has already begun the shutdown sequence. 42517c478bd9Sstevel@tonic-gate */ 42527c478bd9Sstevel@tonic-gate if (block_mounts() == 0) 42537c478bd9Sstevel@tonic-gate return (set_errno(EINTR)); 42547c478bd9Sstevel@tonic-gate mutex_enter(&zonehash_lock); 42557c478bd9Sstevel@tonic-gate /* 42567c478bd9Sstevel@tonic-gate * Look for zone under hash lock to prevent races with other 42577c478bd9Sstevel@tonic-gate * calls to zone_shutdown and zone_destroy. 42587c478bd9Sstevel@tonic-gate */ 42597c478bd9Sstevel@tonic-gate if ((zone = zone_find_all_by_id(zoneid)) == NULL) { 42607c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 42617c478bd9Sstevel@tonic-gate resume_mounts(); 42627c478bd9Sstevel@tonic-gate return (set_errno(EINVAL)); 42637c478bd9Sstevel@tonic-gate } 42647c478bd9Sstevel@tonic-gate mutex_enter(&zone_status_lock); 42657c478bd9Sstevel@tonic-gate status = zone_status_get(zone); 42667c478bd9Sstevel@tonic-gate /* 42677c478bd9Sstevel@tonic-gate * Fail if the zone isn't fully initialized yet. 42687c478bd9Sstevel@tonic-gate */ 42697c478bd9Sstevel@tonic-gate if (status < ZONE_IS_READY) { 42707c478bd9Sstevel@tonic-gate mutex_exit(&zone_status_lock); 42717c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 42727c478bd9Sstevel@tonic-gate resume_mounts(); 42737c478bd9Sstevel@tonic-gate return (set_errno(EINVAL)); 42747c478bd9Sstevel@tonic-gate } 42757c478bd9Sstevel@tonic-gate /* 42767c478bd9Sstevel@tonic-gate * If conditions required for zone_shutdown() to return have been met, 42777c478bd9Sstevel@tonic-gate * return success. 42787c478bd9Sstevel@tonic-gate */ 42797c478bd9Sstevel@tonic-gate if (status >= ZONE_IS_DOWN) { 42807c478bd9Sstevel@tonic-gate mutex_exit(&zone_status_lock); 42817c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 42827c478bd9Sstevel@tonic-gate resume_mounts(); 42837c478bd9Sstevel@tonic-gate return (0); 42847c478bd9Sstevel@tonic-gate } 42857c478bd9Sstevel@tonic-gate /* 42867c478bd9Sstevel@tonic-gate * If zone_shutdown() hasn't been called before, go through the motions. 42877c478bd9Sstevel@tonic-gate * If it has, there's nothing to do but wait for the kernel threads to 42887c478bd9Sstevel@tonic-gate * drain. 42897c478bd9Sstevel@tonic-gate */ 42907c478bd9Sstevel@tonic-gate if (status < ZONE_IS_EMPTY) { 42917c478bd9Sstevel@tonic-gate uint_t ntasks; 42927c478bd9Sstevel@tonic-gate 42937c478bd9Sstevel@tonic-gate mutex_enter(&zone->zone_lock); 42947c478bd9Sstevel@tonic-gate if ((ntasks = zone->zone_ntasks) != 1) { 42957c478bd9Sstevel@tonic-gate /* 42967c478bd9Sstevel@tonic-gate * There's still stuff running. 42977c478bd9Sstevel@tonic-gate */ 42987c478bd9Sstevel@tonic-gate zone_status_set(zone, ZONE_IS_SHUTTING_DOWN); 42997c478bd9Sstevel@tonic-gate } 43007c478bd9Sstevel@tonic-gate mutex_exit(&zone->zone_lock); 43017c478bd9Sstevel@tonic-gate if (ntasks == 1) { 43027c478bd9Sstevel@tonic-gate /* 43037c478bd9Sstevel@tonic-gate * The only way to create another task is through 43047c478bd9Sstevel@tonic-gate * zone_enter(), which will block until we drop 43057c478bd9Sstevel@tonic-gate * zonehash_lock. The zone is empty. 43067c478bd9Sstevel@tonic-gate */ 43077c478bd9Sstevel@tonic-gate if (zone->zone_kthreads == NULL) { 43087c478bd9Sstevel@tonic-gate /* 43097c478bd9Sstevel@tonic-gate * Skip ahead to ZONE_IS_DOWN 43107c478bd9Sstevel@tonic-gate */ 43117c478bd9Sstevel@tonic-gate zone_status_set(zone, ZONE_IS_DOWN); 43127c478bd9Sstevel@tonic-gate } else { 43137c478bd9Sstevel@tonic-gate zone_status_set(zone, ZONE_IS_EMPTY); 43147c478bd9Sstevel@tonic-gate } 43157c478bd9Sstevel@tonic-gate } 43167c478bd9Sstevel@tonic-gate } 43177c478bd9Sstevel@tonic-gate zone_hold(zone); /* so we can use the zone_t later */ 43187c478bd9Sstevel@tonic-gate mutex_exit(&zone_status_lock); 43197c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 43207c478bd9Sstevel@tonic-gate resume_mounts(); 43217c478bd9Sstevel@tonic-gate 43227c478bd9Sstevel@tonic-gate if (error = zone_empty(zone)) { 43237c478bd9Sstevel@tonic-gate zone_rele(zone); 43247c478bd9Sstevel@tonic-gate return (set_errno(error)); 43257c478bd9Sstevel@tonic-gate } 43267c478bd9Sstevel@tonic-gate /* 43277c478bd9Sstevel@tonic-gate * After the zone status goes to ZONE_IS_DOWN this zone will no 43287c478bd9Sstevel@tonic-gate * longer be notified of changes to the pools configuration, so 43297c478bd9Sstevel@tonic-gate * in order to not end up with a stale pool pointer, we point 43307c478bd9Sstevel@tonic-gate * ourselves at the default pool and remove all resource 43317c478bd9Sstevel@tonic-gate * visibility. This is especially important as the zone_t may 43327c478bd9Sstevel@tonic-gate * languish on the deathrow for a very long time waiting for 43337c478bd9Sstevel@tonic-gate * cred's to drain out. 43347c478bd9Sstevel@tonic-gate * 43357c478bd9Sstevel@tonic-gate * This rebinding of the zone can happen multiple times 43367c478bd9Sstevel@tonic-gate * (presumably due to interrupted or parallel systemcalls) 43377c478bd9Sstevel@tonic-gate * without any adverse effects. 43387c478bd9Sstevel@tonic-gate */ 43397c478bd9Sstevel@tonic-gate if (pool_lock_intr() != 0) { 43407c478bd9Sstevel@tonic-gate zone_rele(zone); 43417c478bd9Sstevel@tonic-gate return (set_errno(EINTR)); 43427c478bd9Sstevel@tonic-gate } 43437c478bd9Sstevel@tonic-gate if (pool_state == POOL_ENABLED) { 43447c478bd9Sstevel@tonic-gate mutex_enter(&cpu_lock); 43457c478bd9Sstevel@tonic-gate zone_pool_set(zone, pool_default); 43467c478bd9Sstevel@tonic-gate /* 43477c478bd9Sstevel@tonic-gate * The zone no longer needs to be able to see any cpus. 43487c478bd9Sstevel@tonic-gate */ 43497c478bd9Sstevel@tonic-gate zone_pset_set(zone, ZONE_PS_INVAL); 43507c478bd9Sstevel@tonic-gate mutex_exit(&cpu_lock); 43517c478bd9Sstevel@tonic-gate } 43527c478bd9Sstevel@tonic-gate pool_unlock(); 43537c478bd9Sstevel@tonic-gate 43547c478bd9Sstevel@tonic-gate /* 43557c478bd9Sstevel@tonic-gate * ZSD shutdown callbacks can be executed multiple times, hence 43567c478bd9Sstevel@tonic-gate * it is safe to not be holding any locks across this call. 43577c478bd9Sstevel@tonic-gate */ 43587c478bd9Sstevel@tonic-gate zone_zsd_callbacks(zone, ZSD_SHUTDOWN); 43597c478bd9Sstevel@tonic-gate 43607c478bd9Sstevel@tonic-gate mutex_enter(&zone_status_lock); 43617c478bd9Sstevel@tonic-gate if (zone->zone_kthreads == NULL && zone_status_get(zone) < ZONE_IS_DOWN) 43627c478bd9Sstevel@tonic-gate zone_status_set(zone, ZONE_IS_DOWN); 43637c478bd9Sstevel@tonic-gate mutex_exit(&zone_status_lock); 43647c478bd9Sstevel@tonic-gate 43657c478bd9Sstevel@tonic-gate /* 43667c478bd9Sstevel@tonic-gate * Wait for kernel threads to drain. 43677c478bd9Sstevel@tonic-gate */ 43687c478bd9Sstevel@tonic-gate if (!zone_status_wait_sig(zone, ZONE_IS_DOWN)) { 43697c478bd9Sstevel@tonic-gate zone_rele(zone); 43707c478bd9Sstevel@tonic-gate return (set_errno(EINTR)); 43717c478bd9Sstevel@tonic-gate } 43729acbbeafSnn 437352978630Ssl /* 437452978630Ssl * Zone can be become down/destroyable even if the above wait 437552978630Ssl * returns EINTR, so any code added here may never execute. 437652978630Ssl * (i.e. don't add code here) 437752978630Ssl */ 43789acbbeafSnn 43797c478bd9Sstevel@tonic-gate zone_rele(zone); 43807c478bd9Sstevel@tonic-gate return (0); 43817c478bd9Sstevel@tonic-gate } 43827c478bd9Sstevel@tonic-gate 43837c478bd9Sstevel@tonic-gate /* 43847c478bd9Sstevel@tonic-gate * Systemcall entry point to finalize the zone halt process. The caller 4385824c205fSml * must have already successfully called zone_shutdown(). 43867c478bd9Sstevel@tonic-gate * 43877c478bd9Sstevel@tonic-gate * Upon successful completion, the zone will have been fully destroyed: 43887c478bd9Sstevel@tonic-gate * zsched will have exited, destructor callbacks executed, and the zone 43897c478bd9Sstevel@tonic-gate * removed from the list of active zones. 43907c478bd9Sstevel@tonic-gate */ 43917c478bd9Sstevel@tonic-gate static int 43927c478bd9Sstevel@tonic-gate zone_destroy(zoneid_t zoneid) 43937c478bd9Sstevel@tonic-gate { 43947c478bd9Sstevel@tonic-gate uint64_t uniqid; 43957c478bd9Sstevel@tonic-gate zone_t *zone; 43967c478bd9Sstevel@tonic-gate zone_status_t status; 43977c478bd9Sstevel@tonic-gate 43987c478bd9Sstevel@tonic-gate if (secpolicy_zone_config(CRED()) != 0) 43997c478bd9Sstevel@tonic-gate return (set_errno(EPERM)); 44007c478bd9Sstevel@tonic-gate if (zoneid < MIN_USERZONEID || zoneid > MAX_ZONEID) 44017c478bd9Sstevel@tonic-gate return (set_errno(EINVAL)); 44027c478bd9Sstevel@tonic-gate 44037c478bd9Sstevel@tonic-gate mutex_enter(&zonehash_lock); 44047c478bd9Sstevel@tonic-gate /* 44057c478bd9Sstevel@tonic-gate * Look for zone under hash lock to prevent races with other 44067c478bd9Sstevel@tonic-gate * calls to zone_destroy. 44077c478bd9Sstevel@tonic-gate */ 44087c478bd9Sstevel@tonic-gate if ((zone = zone_find_all_by_id(zoneid)) == NULL) { 44097c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 44107c478bd9Sstevel@tonic-gate return (set_errno(EINVAL)); 44117c478bd9Sstevel@tonic-gate } 44127c478bd9Sstevel@tonic-gate 44137c478bd9Sstevel@tonic-gate if (zone_mount_count(zone->zone_rootpath) != 0) { 44147c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 44157c478bd9Sstevel@tonic-gate return (set_errno(EBUSY)); 44167c478bd9Sstevel@tonic-gate } 44177c478bd9Sstevel@tonic-gate mutex_enter(&zone_status_lock); 44187c478bd9Sstevel@tonic-gate status = zone_status_get(zone); 44197c478bd9Sstevel@tonic-gate if (status < ZONE_IS_DOWN) { 44207c478bd9Sstevel@tonic-gate mutex_exit(&zone_status_lock); 44217c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 44227c478bd9Sstevel@tonic-gate return (set_errno(EBUSY)); 44237c478bd9Sstevel@tonic-gate } else if (status == ZONE_IS_DOWN) { 44247c478bd9Sstevel@tonic-gate zone_status_set(zone, ZONE_IS_DYING); /* Tell zsched to exit */ 44257c478bd9Sstevel@tonic-gate } 44267c478bd9Sstevel@tonic-gate mutex_exit(&zone_status_lock); 44277c478bd9Sstevel@tonic-gate zone_hold(zone); 44287c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 44297c478bd9Sstevel@tonic-gate 44307c478bd9Sstevel@tonic-gate /* 44317c478bd9Sstevel@tonic-gate * wait for zsched to exit 44327c478bd9Sstevel@tonic-gate */ 44337c478bd9Sstevel@tonic-gate zone_status_wait(zone, ZONE_IS_DEAD); 44347c478bd9Sstevel@tonic-gate zone_zsd_callbacks(zone, ZSD_DESTROY); 4435f4b3ec61Sdh zone->zone_netstack = NULL; 44367c478bd9Sstevel@tonic-gate uniqid = zone->zone_uniqid; 44377c478bd9Sstevel@tonic-gate zone_rele(zone); 44387c478bd9Sstevel@tonic-gate zone = NULL; /* potentially free'd */ 44397c478bd9Sstevel@tonic-gate 44407c478bd9Sstevel@tonic-gate mutex_enter(&zonehash_lock); 44417c478bd9Sstevel@tonic-gate for (; /* ever */; ) { 44427c478bd9Sstevel@tonic-gate boolean_t unref; 44437c478bd9Sstevel@tonic-gate 44447c478bd9Sstevel@tonic-gate if ((zone = zone_find_all_by_id(zoneid)) == NULL || 44457c478bd9Sstevel@tonic-gate zone->zone_uniqid != uniqid) { 44467c478bd9Sstevel@tonic-gate /* 44477c478bd9Sstevel@tonic-gate * The zone has gone away. Necessary conditions 44487c478bd9Sstevel@tonic-gate * are met, so we return success. 44497c478bd9Sstevel@tonic-gate */ 44507c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 44517c478bd9Sstevel@tonic-gate return (0); 44527c478bd9Sstevel@tonic-gate } 44537c478bd9Sstevel@tonic-gate mutex_enter(&zone->zone_lock); 44547c478bd9Sstevel@tonic-gate unref = ZONE_IS_UNREF(zone); 44557c478bd9Sstevel@tonic-gate mutex_exit(&zone->zone_lock); 44567c478bd9Sstevel@tonic-gate if (unref) { 44577c478bd9Sstevel@tonic-gate /* 44587c478bd9Sstevel@tonic-gate * There is only one reference to the zone -- that 44597c478bd9Sstevel@tonic-gate * added when the zone was added to the hashtables -- 44607c478bd9Sstevel@tonic-gate * and things will remain this way until we drop 44617c478bd9Sstevel@tonic-gate * zonehash_lock... we can go ahead and cleanup the 44627c478bd9Sstevel@tonic-gate * zone. 44637c478bd9Sstevel@tonic-gate */ 44647c478bd9Sstevel@tonic-gate break; 44657c478bd9Sstevel@tonic-gate } 44667c478bd9Sstevel@tonic-gate 44677c478bd9Sstevel@tonic-gate if (cv_wait_sig(&zone_destroy_cv, &zonehash_lock) == 0) { 44687c478bd9Sstevel@tonic-gate /* Signaled */ 44697c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 44707c478bd9Sstevel@tonic-gate return (set_errno(EINTR)); 44717c478bd9Sstevel@tonic-gate } 44727c478bd9Sstevel@tonic-gate 44737c478bd9Sstevel@tonic-gate } 44747c478bd9Sstevel@tonic-gate 4475c97ad5cdSakolb /* 4476c97ad5cdSakolb * Remove CPU cap for this zone now since we're not going to 4477c97ad5cdSakolb * fail below this point. 4478c97ad5cdSakolb */ 4479c97ad5cdSakolb cpucaps_zone_remove(zone); 4480c97ad5cdSakolb 4481c97ad5cdSakolb /* Get rid of the zone's kstats */ 44820209230bSgjelinek zone_kstat_delete(zone); 44830209230bSgjelinek 4484*134a1f4eSCasper H.S. Dik /* remove the pfexecd doors */ 4485*134a1f4eSCasper H.S. Dik if (zone->zone_pfexecd != NULL) { 4486*134a1f4eSCasper H.S. Dik klpd_freelist(&zone->zone_pfexecd); 4487*134a1f4eSCasper H.S. Dik zone->zone_pfexecd = NULL; 4488*134a1f4eSCasper H.S. Dik } 4489*134a1f4eSCasper H.S. Dik 4490319378d9Seh /* free brand specific data */ 4491319378d9Seh if (ZONE_IS_BRANDED(zone)) 4492319378d9Seh ZBROP(zone)->b_free_brand_data(zone); 4493319378d9Seh 449452978630Ssl /* Say goodbye to brand framework. */ 449552978630Ssl brand_unregister_zone(zone->zone_brand); 449652978630Ssl 44977c478bd9Sstevel@tonic-gate /* 44987c478bd9Sstevel@tonic-gate * It is now safe to let the zone be recreated; remove it from the 44997c478bd9Sstevel@tonic-gate * lists. The memory will not be freed until the last cred 45007c478bd9Sstevel@tonic-gate * reference goes away. 45017c478bd9Sstevel@tonic-gate */ 45027c478bd9Sstevel@tonic-gate ASSERT(zonecount > 1); /* must be > 1; can't destroy global zone */ 45037c478bd9Sstevel@tonic-gate zonecount--; 45047c478bd9Sstevel@tonic-gate /* remove from active list and hash tables */ 45057c478bd9Sstevel@tonic-gate list_remove(&zone_active, zone); 45067c478bd9Sstevel@tonic-gate (void) mod_hash_destroy(zonehashbyname, 45077c478bd9Sstevel@tonic-gate (mod_hash_key_t)zone->zone_name); 45087c478bd9Sstevel@tonic-gate (void) mod_hash_destroy(zonehashbyid, 45097c478bd9Sstevel@tonic-gate (mod_hash_key_t)(uintptr_t)zone->zone_id); 451048451833Scarlsonj if (zone->zone_flags & ZF_HASHED_LABEL) 451145916cd2Sjpk (void) mod_hash_destroy(zonehashbylabel, 451245916cd2Sjpk (mod_hash_key_t)zone->zone_slabel); 45137c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 45147c478bd9Sstevel@tonic-gate 4515108322fbScarlsonj /* 4516108322fbScarlsonj * Release the root vnode; we're not using it anymore. Nor should any 4517108322fbScarlsonj * other thread that might access it exist. 4518108322fbScarlsonj */ 4519108322fbScarlsonj if (zone->zone_rootvp != NULL) { 4520108322fbScarlsonj VN_RELE(zone->zone_rootvp); 4521108322fbScarlsonj zone->zone_rootvp = NULL; 4522108322fbScarlsonj } 4523108322fbScarlsonj 45247c478bd9Sstevel@tonic-gate /* add to deathrow list */ 45257c478bd9Sstevel@tonic-gate mutex_enter(&zone_deathrow_lock); 45267c478bd9Sstevel@tonic-gate list_insert_tail(&zone_deathrow, zone); 45277c478bd9Sstevel@tonic-gate mutex_exit(&zone_deathrow_lock); 45287c478bd9Sstevel@tonic-gate 45297c478bd9Sstevel@tonic-gate /* 45307c478bd9Sstevel@tonic-gate * Drop last reference (which was added by zsched()), this will 45317c478bd9Sstevel@tonic-gate * free the zone unless there are outstanding cred references. 45327c478bd9Sstevel@tonic-gate */ 45337c478bd9Sstevel@tonic-gate zone_rele(zone); 45347c478bd9Sstevel@tonic-gate return (0); 45357c478bd9Sstevel@tonic-gate } 45367c478bd9Sstevel@tonic-gate 45377c478bd9Sstevel@tonic-gate /* 45387c478bd9Sstevel@tonic-gate * Systemcall entry point for zone_getattr(2). 45397c478bd9Sstevel@tonic-gate */ 45407c478bd9Sstevel@tonic-gate static ssize_t 45417c478bd9Sstevel@tonic-gate zone_getattr(zoneid_t zoneid, int attr, void *buf, size_t bufsize) 45427c478bd9Sstevel@tonic-gate { 45437c478bd9Sstevel@tonic-gate size_t size; 45447c478bd9Sstevel@tonic-gate int error = 0, err; 45457c478bd9Sstevel@tonic-gate zone_t *zone; 45467c478bd9Sstevel@tonic-gate char *zonepath; 45473f2f09c1Sdp char *outstr; 45487c478bd9Sstevel@tonic-gate zone_status_t zone_status; 45497c478bd9Sstevel@tonic-gate pid_t initpid; 4550c97ad5cdSakolb boolean_t global = (curzone == global_zone); 4551c97ad5cdSakolb boolean_t inzone = (curzone->zone_id == zoneid); 4552f4b3ec61Sdh ushort_t flags; 45537c478bd9Sstevel@tonic-gate 45547c478bd9Sstevel@tonic-gate mutex_enter(&zonehash_lock); 45557c478bd9Sstevel@tonic-gate if ((zone = zone_find_all_by_id(zoneid)) == NULL) { 45567c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 45577c478bd9Sstevel@tonic-gate return (set_errno(EINVAL)); 45587c478bd9Sstevel@tonic-gate } 45597c478bd9Sstevel@tonic-gate zone_status = zone_status_get(zone); 4560bd41d0a8Snordmark if (zone_status < ZONE_IS_INITIALIZED) { 45617c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 45627c478bd9Sstevel@tonic-gate return (set_errno(EINVAL)); 45637c478bd9Sstevel@tonic-gate } 45647c478bd9Sstevel@tonic-gate zone_hold(zone); 45657c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 45667c478bd9Sstevel@tonic-gate 45677c478bd9Sstevel@tonic-gate /* 456845916cd2Sjpk * If not in the global zone, don't show information about other zones, 456945916cd2Sjpk * unless the system is labeled and the local zone's label dominates 457045916cd2Sjpk * the other zone. 45717c478bd9Sstevel@tonic-gate */ 457245916cd2Sjpk if (!zone_list_access(zone)) { 45737c478bd9Sstevel@tonic-gate zone_rele(zone); 45747c478bd9Sstevel@tonic-gate return (set_errno(EINVAL)); 45757c478bd9Sstevel@tonic-gate } 45767c478bd9Sstevel@tonic-gate 45777c478bd9Sstevel@tonic-gate switch (attr) { 45787c478bd9Sstevel@tonic-gate case ZONE_ATTR_ROOT: 45797c478bd9Sstevel@tonic-gate if (global) { 45807c478bd9Sstevel@tonic-gate /* 45817c478bd9Sstevel@tonic-gate * Copy the path to trim the trailing "/" (except for 45827c478bd9Sstevel@tonic-gate * the global zone). 45837c478bd9Sstevel@tonic-gate */ 45847c478bd9Sstevel@tonic-gate if (zone != global_zone) 45857c478bd9Sstevel@tonic-gate size = zone->zone_rootpathlen - 1; 45867c478bd9Sstevel@tonic-gate else 45877c478bd9Sstevel@tonic-gate size = zone->zone_rootpathlen; 45887c478bd9Sstevel@tonic-gate zonepath = kmem_alloc(size, KM_SLEEP); 45897c478bd9Sstevel@tonic-gate bcopy(zone->zone_rootpath, zonepath, size); 45907c478bd9Sstevel@tonic-gate zonepath[size - 1] = '\0'; 45917c478bd9Sstevel@tonic-gate } else { 4592c97ad5cdSakolb if (inzone || !is_system_labeled()) { 459345916cd2Sjpk /* 459445916cd2Sjpk * Caller is not in the global zone. 459545916cd2Sjpk * if the query is on the current zone 459645916cd2Sjpk * or the system is not labeled, 459745916cd2Sjpk * just return faked-up path for current zone. 459845916cd2Sjpk */ 459945916cd2Sjpk zonepath = "/"; 460045916cd2Sjpk size = 2; 460145916cd2Sjpk } else { 460245916cd2Sjpk /* 460345916cd2Sjpk * Return related path for current zone. 460445916cd2Sjpk */ 460545916cd2Sjpk int prefix_len = strlen(zone_prefix); 460645916cd2Sjpk int zname_len = strlen(zone->zone_name); 460745916cd2Sjpk 460845916cd2Sjpk size = prefix_len + zname_len + 1; 460945916cd2Sjpk zonepath = kmem_alloc(size, KM_SLEEP); 461045916cd2Sjpk bcopy(zone_prefix, zonepath, prefix_len); 461145916cd2Sjpk bcopy(zone->zone_name, zonepath + 46123f2f09c1Sdp prefix_len, zname_len); 461345916cd2Sjpk zonepath[size - 1] = '\0'; 461445916cd2Sjpk } 46157c478bd9Sstevel@tonic-gate } 46167c478bd9Sstevel@tonic-gate if (bufsize > size) 46177c478bd9Sstevel@tonic-gate bufsize = size; 46187c478bd9Sstevel@tonic-gate if (buf != NULL) { 46197c478bd9Sstevel@tonic-gate err = copyoutstr(zonepath, buf, bufsize, NULL); 46207c478bd9Sstevel@tonic-gate if (err != 0 && err != ENAMETOOLONG) 46217c478bd9Sstevel@tonic-gate error = EFAULT; 46227c478bd9Sstevel@tonic-gate } 4623c97ad5cdSakolb if (global || (is_system_labeled() && !inzone)) 46247c478bd9Sstevel@tonic-gate kmem_free(zonepath, size); 46257c478bd9Sstevel@tonic-gate break; 46267c478bd9Sstevel@tonic-gate 46277c478bd9Sstevel@tonic-gate case ZONE_ATTR_NAME: 46287c478bd9Sstevel@tonic-gate size = strlen(zone->zone_name) + 1; 46297c478bd9Sstevel@tonic-gate if (bufsize > size) 46307c478bd9Sstevel@tonic-gate bufsize = size; 46317c478bd9Sstevel@tonic-gate if (buf != NULL) { 46327c478bd9Sstevel@tonic-gate err = copyoutstr(zone->zone_name, buf, bufsize, NULL); 46337c478bd9Sstevel@tonic-gate if (err != 0 && err != ENAMETOOLONG) 46347c478bd9Sstevel@tonic-gate error = EFAULT; 46357c478bd9Sstevel@tonic-gate } 46367c478bd9Sstevel@tonic-gate break; 46377c478bd9Sstevel@tonic-gate 46387c478bd9Sstevel@tonic-gate case ZONE_ATTR_STATUS: 46397c478bd9Sstevel@tonic-gate /* 46407c478bd9Sstevel@tonic-gate * Since we're not holding zonehash_lock, the zone status 46417c478bd9Sstevel@tonic-gate * may be anything; leave it up to userland to sort it out. 46427c478bd9Sstevel@tonic-gate */ 46437c478bd9Sstevel@tonic-gate size = sizeof (zone_status); 46447c478bd9Sstevel@tonic-gate if (bufsize > size) 46457c478bd9Sstevel@tonic-gate bufsize = size; 46467c478bd9Sstevel@tonic-gate zone_status = zone_status_get(zone); 46477c478bd9Sstevel@tonic-gate if (buf != NULL && 46487c478bd9Sstevel@tonic-gate copyout(&zone_status, buf, bufsize) != 0) 46497c478bd9Sstevel@tonic-gate error = EFAULT; 46507c478bd9Sstevel@tonic-gate break; 4651f4b3ec61Sdh case ZONE_ATTR_FLAGS: 4652f4b3ec61Sdh size = sizeof (zone->zone_flags); 4653f4b3ec61Sdh if (bufsize > size) 4654f4b3ec61Sdh bufsize = size; 4655f4b3ec61Sdh flags = zone->zone_flags; 4656f4b3ec61Sdh if (buf != NULL && 4657f4b3ec61Sdh copyout(&flags, buf, bufsize) != 0) 4658f4b3ec61Sdh error = EFAULT; 4659f4b3ec61Sdh break; 46607c478bd9Sstevel@tonic-gate case ZONE_ATTR_PRIVSET: 46617c478bd9Sstevel@tonic-gate size = sizeof (priv_set_t); 46627c478bd9Sstevel@tonic-gate if (bufsize > size) 46637c478bd9Sstevel@tonic-gate bufsize = size; 46647c478bd9Sstevel@tonic-gate if (buf != NULL && 46657c478bd9Sstevel@tonic-gate copyout(zone->zone_privset, buf, bufsize) != 0) 46667c478bd9Sstevel@tonic-gate error = EFAULT; 46677c478bd9Sstevel@tonic-gate break; 46687c478bd9Sstevel@tonic-gate case ZONE_ATTR_UNIQID: 46697c478bd9Sstevel@tonic-gate size = sizeof (zone->zone_uniqid); 46707c478bd9Sstevel@tonic-gate if (bufsize > size) 46717c478bd9Sstevel@tonic-gate bufsize = size; 46727c478bd9Sstevel@tonic-gate if (buf != NULL && 46737c478bd9Sstevel@tonic-gate copyout(&zone->zone_uniqid, buf, bufsize) != 0) 46747c478bd9Sstevel@tonic-gate error = EFAULT; 46757c478bd9Sstevel@tonic-gate break; 46767c478bd9Sstevel@tonic-gate case ZONE_ATTR_POOLID: 46777c478bd9Sstevel@tonic-gate { 46787c478bd9Sstevel@tonic-gate pool_t *pool; 46797c478bd9Sstevel@tonic-gate poolid_t poolid; 46807c478bd9Sstevel@tonic-gate 46817c478bd9Sstevel@tonic-gate if (pool_lock_intr() != 0) { 46827c478bd9Sstevel@tonic-gate error = EINTR; 46837c478bd9Sstevel@tonic-gate break; 46847c478bd9Sstevel@tonic-gate } 46857c478bd9Sstevel@tonic-gate pool = zone_pool_get(zone); 46867c478bd9Sstevel@tonic-gate poolid = pool->pool_id; 46877c478bd9Sstevel@tonic-gate pool_unlock(); 46887c478bd9Sstevel@tonic-gate size = sizeof (poolid); 46897c478bd9Sstevel@tonic-gate if (bufsize > size) 46907c478bd9Sstevel@tonic-gate bufsize = size; 46917c478bd9Sstevel@tonic-gate if (buf != NULL && copyout(&poolid, buf, size) != 0) 46927c478bd9Sstevel@tonic-gate error = EFAULT; 46937c478bd9Sstevel@tonic-gate } 46947c478bd9Sstevel@tonic-gate break; 469545916cd2Sjpk case ZONE_ATTR_SLBL: 469645916cd2Sjpk size = sizeof (bslabel_t); 469745916cd2Sjpk if (bufsize > size) 469845916cd2Sjpk bufsize = size; 469945916cd2Sjpk if (zone->zone_slabel == NULL) 470045916cd2Sjpk error = EINVAL; 470145916cd2Sjpk else if (buf != NULL && 470245916cd2Sjpk copyout(label2bslabel(zone->zone_slabel), buf, 470345916cd2Sjpk bufsize) != 0) 470445916cd2Sjpk error = EFAULT; 470545916cd2Sjpk break; 47067c478bd9Sstevel@tonic-gate case ZONE_ATTR_INITPID: 47077c478bd9Sstevel@tonic-gate size = sizeof (initpid); 47087c478bd9Sstevel@tonic-gate if (bufsize > size) 47097c478bd9Sstevel@tonic-gate bufsize = size; 47107c478bd9Sstevel@tonic-gate initpid = zone->zone_proc_initpid; 47117c478bd9Sstevel@tonic-gate if (initpid == -1) { 47127c478bd9Sstevel@tonic-gate error = ESRCH; 47137c478bd9Sstevel@tonic-gate break; 47147c478bd9Sstevel@tonic-gate } 47157c478bd9Sstevel@tonic-gate if (buf != NULL && 47167c478bd9Sstevel@tonic-gate copyout(&initpid, buf, bufsize) != 0) 47177c478bd9Sstevel@tonic-gate error = EFAULT; 47187c478bd9Sstevel@tonic-gate break; 47199acbbeafSnn case ZONE_ATTR_BRAND: 47209acbbeafSnn size = strlen(zone->zone_brand->b_name) + 1; 47219acbbeafSnn 47229acbbeafSnn if (bufsize > size) 47239acbbeafSnn bufsize = size; 47249acbbeafSnn if (buf != NULL) { 47259acbbeafSnn err = copyoutstr(zone->zone_brand->b_name, buf, 47269acbbeafSnn bufsize, NULL); 47279acbbeafSnn if (err != 0 && err != ENAMETOOLONG) 47289acbbeafSnn error = EFAULT; 47299acbbeafSnn } 47309acbbeafSnn break; 47313f2f09c1Sdp case ZONE_ATTR_INITNAME: 47323f2f09c1Sdp size = strlen(zone->zone_initname) + 1; 47333f2f09c1Sdp if (bufsize > size) 47343f2f09c1Sdp bufsize = size; 47353f2f09c1Sdp if (buf != NULL) { 47363f2f09c1Sdp err = copyoutstr(zone->zone_initname, buf, bufsize, 47373f2f09c1Sdp NULL); 47383f2f09c1Sdp if (err != 0 && err != ENAMETOOLONG) 47393f2f09c1Sdp error = EFAULT; 47403f2f09c1Sdp } 47413f2f09c1Sdp break; 47423f2f09c1Sdp case ZONE_ATTR_BOOTARGS: 47433f2f09c1Sdp if (zone->zone_bootargs == NULL) 47443f2f09c1Sdp outstr = ""; 47453f2f09c1Sdp else 47463f2f09c1Sdp outstr = zone->zone_bootargs; 47473f2f09c1Sdp size = strlen(outstr) + 1; 47483f2f09c1Sdp if (bufsize > size) 47493f2f09c1Sdp bufsize = size; 47503f2f09c1Sdp if (buf != NULL) { 47513f2f09c1Sdp err = copyoutstr(outstr, buf, bufsize, NULL); 47523f2f09c1Sdp if (err != 0 && err != ENAMETOOLONG) 47533f2f09c1Sdp error = EFAULT; 47543f2f09c1Sdp } 47553f2f09c1Sdp break; 47560209230bSgjelinek case ZONE_ATTR_PHYS_MCAP: 47570209230bSgjelinek size = sizeof (zone->zone_phys_mcap); 47580209230bSgjelinek if (bufsize > size) 47590209230bSgjelinek bufsize = size; 47600209230bSgjelinek if (buf != NULL && 47610209230bSgjelinek copyout(&zone->zone_phys_mcap, buf, bufsize) != 0) 47620209230bSgjelinek error = EFAULT; 47630209230bSgjelinek break; 47640209230bSgjelinek case ZONE_ATTR_SCHED_CLASS: 47650209230bSgjelinek mutex_enter(&class_lock); 47660209230bSgjelinek 47670209230bSgjelinek if (zone->zone_defaultcid >= loaded_classes) 47680209230bSgjelinek outstr = ""; 47690209230bSgjelinek else 47700209230bSgjelinek outstr = sclass[zone->zone_defaultcid].cl_name; 47710209230bSgjelinek size = strlen(outstr) + 1; 47720209230bSgjelinek if (bufsize > size) 47730209230bSgjelinek bufsize = size; 47740209230bSgjelinek if (buf != NULL) { 47750209230bSgjelinek err = copyoutstr(outstr, buf, bufsize, NULL); 47760209230bSgjelinek if (err != 0 && err != ENAMETOOLONG) 47770209230bSgjelinek error = EFAULT; 47780209230bSgjelinek } 47790209230bSgjelinek 47800209230bSgjelinek mutex_exit(&class_lock); 47810209230bSgjelinek break; 47825679c89fSjv case ZONE_ATTR_HOSTID: 47835679c89fSjv if (zone->zone_hostid != HW_INVALID_HOSTID && 47845679c89fSjv bufsize == sizeof (zone->zone_hostid)) { 47855679c89fSjv size = sizeof (zone->zone_hostid); 47865679c89fSjv if (buf != NULL && copyout(&zone->zone_hostid, buf, 47875679c89fSjv bufsize) != 0) 47885679c89fSjv error = EFAULT; 47895679c89fSjv } else { 47905679c89fSjv error = EINVAL; 47915679c89fSjv } 47925679c89fSjv break; 47937c478bd9Sstevel@tonic-gate default: 47949acbbeafSnn if ((attr >= ZONE_ATTR_BRAND_ATTRS) && ZONE_IS_BRANDED(zone)) { 47959acbbeafSnn size = bufsize; 47969acbbeafSnn error = ZBROP(zone)->b_getattr(zone, attr, buf, &size); 47979acbbeafSnn } else { 47989acbbeafSnn error = EINVAL; 47999acbbeafSnn } 48007c478bd9Sstevel@tonic-gate } 48017c478bd9Sstevel@tonic-gate zone_rele(zone); 48027c478bd9Sstevel@tonic-gate 48037c478bd9Sstevel@tonic-gate if (error) 48047c478bd9Sstevel@tonic-gate return (set_errno(error)); 48057c478bd9Sstevel@tonic-gate return ((ssize_t)size); 48067c478bd9Sstevel@tonic-gate } 48077c478bd9Sstevel@tonic-gate 48083f2f09c1Sdp /* 48093f2f09c1Sdp * Systemcall entry point for zone_setattr(2). 48103f2f09c1Sdp */ 48113f2f09c1Sdp /*ARGSUSED*/ 48123f2f09c1Sdp static int 48133f2f09c1Sdp zone_setattr(zoneid_t zoneid, int attr, void *buf, size_t bufsize) 48143f2f09c1Sdp { 48153f2f09c1Sdp zone_t *zone; 48163f2f09c1Sdp zone_status_t zone_status; 48173f2f09c1Sdp int err; 48183f2f09c1Sdp 48193f2f09c1Sdp if (secpolicy_zone_config(CRED()) != 0) 48203f2f09c1Sdp return (set_errno(EPERM)); 48213f2f09c1Sdp 48223f2f09c1Sdp /* 48230209230bSgjelinek * Only the ZONE_ATTR_PHYS_MCAP attribute can be set on the 48240209230bSgjelinek * global zone. 48253f2f09c1Sdp */ 48260209230bSgjelinek if (zoneid == GLOBAL_ZONEID && attr != ZONE_ATTR_PHYS_MCAP) { 48273f2f09c1Sdp return (set_errno(EINVAL)); 48283f2f09c1Sdp } 48293f2f09c1Sdp 48303f2f09c1Sdp mutex_enter(&zonehash_lock); 48313f2f09c1Sdp if ((zone = zone_find_all_by_id(zoneid)) == NULL) { 48323f2f09c1Sdp mutex_exit(&zonehash_lock); 48333f2f09c1Sdp return (set_errno(EINVAL)); 48343f2f09c1Sdp } 48353f2f09c1Sdp zone_hold(zone); 48363f2f09c1Sdp mutex_exit(&zonehash_lock); 48373f2f09c1Sdp 48380209230bSgjelinek /* 48390209230bSgjelinek * At present most attributes can only be set on non-running, 48400209230bSgjelinek * non-global zones. 48410209230bSgjelinek */ 48423f2f09c1Sdp zone_status = zone_status_get(zone); 48430209230bSgjelinek if (attr != ZONE_ATTR_PHYS_MCAP && zone_status > ZONE_IS_READY) 48443f2f09c1Sdp goto done; 48453f2f09c1Sdp 48463f2f09c1Sdp switch (attr) { 48473f2f09c1Sdp case ZONE_ATTR_INITNAME: 48483f2f09c1Sdp err = zone_set_initname(zone, (const char *)buf); 48493f2f09c1Sdp break; 48503f2f09c1Sdp case ZONE_ATTR_BOOTARGS: 48513f2f09c1Sdp err = zone_set_bootargs(zone, (const char *)buf); 48523f2f09c1Sdp break; 48539acbbeafSnn case ZONE_ATTR_BRAND: 485459f2ff5cSedp err = zone_set_brand(zone, (const char *)buf); 48559acbbeafSnn break; 48560209230bSgjelinek case ZONE_ATTR_PHYS_MCAP: 48570209230bSgjelinek err = zone_set_phys_mcap(zone, (const uint64_t *)buf); 48580209230bSgjelinek break; 48590209230bSgjelinek case ZONE_ATTR_SCHED_CLASS: 48600209230bSgjelinek err = zone_set_sched_class(zone, (const char *)buf); 48610209230bSgjelinek break; 48625679c89fSjv case ZONE_ATTR_HOSTID: 48635679c89fSjv if (bufsize == sizeof (zone->zone_hostid)) { 48645679c89fSjv if (copyin(buf, &zone->zone_hostid, bufsize) == 0) 48655679c89fSjv err = 0; 48665679c89fSjv else 48675679c89fSjv err = EFAULT; 48685679c89fSjv } else { 48695679c89fSjv err = EINVAL; 48705679c89fSjv } 48715679c89fSjv break; 48723f2f09c1Sdp default: 48739acbbeafSnn if ((attr >= ZONE_ATTR_BRAND_ATTRS) && ZONE_IS_BRANDED(zone)) 48749acbbeafSnn err = ZBROP(zone)->b_setattr(zone, attr, buf, bufsize); 48759acbbeafSnn else 48769acbbeafSnn err = EINVAL; 48773f2f09c1Sdp } 48783f2f09c1Sdp 48793f2f09c1Sdp done: 48803f2f09c1Sdp zone_rele(zone); 48813f2f09c1Sdp return (err != 0 ? set_errno(err) : 0); 48823f2f09c1Sdp } 48833f2f09c1Sdp 48847c478bd9Sstevel@tonic-gate /* 48857c478bd9Sstevel@tonic-gate * Return zero if the process has at least one vnode mapped in to its 48867c478bd9Sstevel@tonic-gate * address space which shouldn't be allowed to change zones. 48870209230bSgjelinek * 48880209230bSgjelinek * Also return zero if the process has any shared mappings which reserve 48890209230bSgjelinek * swap. This is because the counting for zone.max-swap does not allow swap 4890da6c28aaSamw * reservation to be shared between zones. zone swap reservation is counted 48910209230bSgjelinek * on zone->zone_max_swap. 48927c478bd9Sstevel@tonic-gate */ 48937c478bd9Sstevel@tonic-gate static int 48947c478bd9Sstevel@tonic-gate as_can_change_zones(void) 48957c478bd9Sstevel@tonic-gate { 48967c478bd9Sstevel@tonic-gate proc_t *pp = curproc; 48977c478bd9Sstevel@tonic-gate struct seg *seg; 48987c478bd9Sstevel@tonic-gate struct as *as = pp->p_as; 48997c478bd9Sstevel@tonic-gate vnode_t *vp; 49007c478bd9Sstevel@tonic-gate int allow = 1; 49017c478bd9Sstevel@tonic-gate 49027c478bd9Sstevel@tonic-gate ASSERT(pp->p_as != &kas); 49030209230bSgjelinek AS_LOCK_ENTER(as, &as->a_lock, RW_READER); 49047c478bd9Sstevel@tonic-gate for (seg = AS_SEGFIRST(as); seg != NULL; seg = AS_SEGNEXT(as, seg)) { 49050209230bSgjelinek 49060209230bSgjelinek /* 49070209230bSgjelinek * Cannot enter zone with shared anon memory which 49080209230bSgjelinek * reserves swap. See comment above. 49090209230bSgjelinek */ 49100209230bSgjelinek if (seg_can_change_zones(seg) == B_FALSE) { 49110209230bSgjelinek allow = 0; 49120209230bSgjelinek break; 49130209230bSgjelinek } 49147c478bd9Sstevel@tonic-gate /* 49157c478bd9Sstevel@tonic-gate * if we can't get a backing vnode for this segment then skip 49167c478bd9Sstevel@tonic-gate * it. 49177c478bd9Sstevel@tonic-gate */ 49187c478bd9Sstevel@tonic-gate vp = NULL; 49197c478bd9Sstevel@tonic-gate if (SEGOP_GETVP(seg, seg->s_base, &vp) != 0 || vp == NULL) 49207c478bd9Sstevel@tonic-gate continue; 49217c478bd9Sstevel@tonic-gate if (!vn_can_change_zones(vp)) { /* bail on first match */ 49227c478bd9Sstevel@tonic-gate allow = 0; 49237c478bd9Sstevel@tonic-gate break; 49247c478bd9Sstevel@tonic-gate } 49257c478bd9Sstevel@tonic-gate } 49260209230bSgjelinek AS_LOCK_EXIT(as, &as->a_lock); 49277c478bd9Sstevel@tonic-gate return (allow); 49287c478bd9Sstevel@tonic-gate } 49297c478bd9Sstevel@tonic-gate 49300209230bSgjelinek /* 49310209230bSgjelinek * Count swap reserved by curproc's address space 49320209230bSgjelinek */ 49330209230bSgjelinek static size_t 49340209230bSgjelinek as_swresv(void) 49350209230bSgjelinek { 49360209230bSgjelinek proc_t *pp = curproc; 49370209230bSgjelinek struct seg *seg; 49380209230bSgjelinek struct as *as = pp->p_as; 49390209230bSgjelinek size_t swap = 0; 49400209230bSgjelinek 49410209230bSgjelinek ASSERT(pp->p_as != &kas); 49420209230bSgjelinek ASSERT(AS_WRITE_HELD(as, &as->a_lock)); 49430209230bSgjelinek for (seg = AS_SEGFIRST(as); seg != NULL; seg = AS_SEGNEXT(as, seg)) 49440209230bSgjelinek swap += seg_swresv(seg); 49450209230bSgjelinek 49460209230bSgjelinek return (swap); 49470209230bSgjelinek } 49480209230bSgjelinek 49497c478bd9Sstevel@tonic-gate /* 49507c478bd9Sstevel@tonic-gate * Systemcall entry point for zone_enter(). 49517c478bd9Sstevel@tonic-gate * 49527c478bd9Sstevel@tonic-gate * The current process is injected into said zone. In the process 49537c478bd9Sstevel@tonic-gate * it will change its project membership, privileges, rootdir/cwd, 49547c478bd9Sstevel@tonic-gate * zone-wide rctls, and pool association to match those of the zone. 49557c478bd9Sstevel@tonic-gate * 49567c478bd9Sstevel@tonic-gate * The first zone_enter() called while the zone is in the ZONE_IS_READY 49577c478bd9Sstevel@tonic-gate * state will transition it to ZONE_IS_RUNNING. Processes may only 49587c478bd9Sstevel@tonic-gate * enter a zone that is "ready" or "running". 49597c478bd9Sstevel@tonic-gate */ 49607c478bd9Sstevel@tonic-gate static int 49617c478bd9Sstevel@tonic-gate zone_enter(zoneid_t zoneid) 49627c478bd9Sstevel@tonic-gate { 49637c478bd9Sstevel@tonic-gate zone_t *zone; 49647c478bd9Sstevel@tonic-gate vnode_t *vp; 49657c478bd9Sstevel@tonic-gate proc_t *pp = curproc; 49667c478bd9Sstevel@tonic-gate contract_t *ct; 49677c478bd9Sstevel@tonic-gate cont_process_t *ctp; 49687c478bd9Sstevel@tonic-gate task_t *tk, *oldtk; 49697c478bd9Sstevel@tonic-gate kproject_t *zone_proj0; 49707c478bd9Sstevel@tonic-gate cred_t *cr, *newcr; 49717c478bd9Sstevel@tonic-gate pool_t *oldpool, *newpool; 49727c478bd9Sstevel@tonic-gate sess_t *sp; 49737c478bd9Sstevel@tonic-gate uid_t uid; 49747c478bd9Sstevel@tonic-gate zone_status_t status; 49757c478bd9Sstevel@tonic-gate int err = 0; 49767c478bd9Sstevel@tonic-gate rctl_entity_p_t e; 49770209230bSgjelinek size_t swap; 4978c97ad5cdSakolb kthread_id_t t; 49797c478bd9Sstevel@tonic-gate 49807c478bd9Sstevel@tonic-gate if (secpolicy_zone_config(CRED()) != 0) 49817c478bd9Sstevel@tonic-gate return (set_errno(EPERM)); 49827c478bd9Sstevel@tonic-gate if (zoneid < MIN_USERZONEID || zoneid > MAX_ZONEID) 49837c478bd9Sstevel@tonic-gate return (set_errno(EINVAL)); 49847c478bd9Sstevel@tonic-gate 49857c478bd9Sstevel@tonic-gate /* 49867c478bd9Sstevel@tonic-gate * Stop all lwps so we don't need to hold a lock to look at 49877c478bd9Sstevel@tonic-gate * curproc->p_zone. This needs to happen before we grab any 49887c478bd9Sstevel@tonic-gate * locks to avoid deadlock (another lwp in the process could 49897c478bd9Sstevel@tonic-gate * be waiting for the held lock). 49907c478bd9Sstevel@tonic-gate */ 49917c478bd9Sstevel@tonic-gate if (curthread != pp->p_agenttp && !holdlwps(SHOLDFORK)) 49927c478bd9Sstevel@tonic-gate return (set_errno(EINTR)); 49937c478bd9Sstevel@tonic-gate 49947c478bd9Sstevel@tonic-gate /* 49957c478bd9Sstevel@tonic-gate * Make sure we're not changing zones with files open or mapped in 49967c478bd9Sstevel@tonic-gate * to our address space which shouldn't be changing zones. 49977c478bd9Sstevel@tonic-gate */ 49987c478bd9Sstevel@tonic-gate if (!files_can_change_zones()) { 49997c478bd9Sstevel@tonic-gate err = EBADF; 50007c478bd9Sstevel@tonic-gate goto out; 50017c478bd9Sstevel@tonic-gate } 50027c478bd9Sstevel@tonic-gate if (!as_can_change_zones()) { 50037c478bd9Sstevel@tonic-gate err = EFAULT; 50047c478bd9Sstevel@tonic-gate goto out; 50057c478bd9Sstevel@tonic-gate } 50067c478bd9Sstevel@tonic-gate 50077c478bd9Sstevel@tonic-gate mutex_enter(&zonehash_lock); 50087c478bd9Sstevel@tonic-gate if (pp->p_zone != global_zone) { 50097c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 50107c478bd9Sstevel@tonic-gate err = EINVAL; 50117c478bd9Sstevel@tonic-gate goto out; 50127c478bd9Sstevel@tonic-gate } 50137c478bd9Sstevel@tonic-gate 50147c478bd9Sstevel@tonic-gate zone = zone_find_all_by_id(zoneid); 50157c478bd9Sstevel@tonic-gate if (zone == NULL) { 50167c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 50177c478bd9Sstevel@tonic-gate err = EINVAL; 50187c478bd9Sstevel@tonic-gate goto out; 50197c478bd9Sstevel@tonic-gate } 50207c478bd9Sstevel@tonic-gate 50217c478bd9Sstevel@tonic-gate /* 50227c478bd9Sstevel@tonic-gate * To prevent processes in a zone from holding contracts on 50237c478bd9Sstevel@tonic-gate * extrazonal resources, and to avoid process contract 50247c478bd9Sstevel@tonic-gate * memberships which span zones, contract holders and processes 50257c478bd9Sstevel@tonic-gate * which aren't the sole members of their encapsulating process 50267c478bd9Sstevel@tonic-gate * contracts are not allowed to zone_enter. 50277c478bd9Sstevel@tonic-gate */ 50287c478bd9Sstevel@tonic-gate ctp = pp->p_ct_process; 50297c478bd9Sstevel@tonic-gate ct = &ctp->conp_contract; 50307c478bd9Sstevel@tonic-gate mutex_enter(&ct->ct_lock); 50317c478bd9Sstevel@tonic-gate mutex_enter(&pp->p_lock); 50327c478bd9Sstevel@tonic-gate if ((avl_numnodes(&pp->p_ct_held) != 0) || (ctp->conp_nmembers != 1)) { 50337c478bd9Sstevel@tonic-gate mutex_exit(&pp->p_lock); 50347c478bd9Sstevel@tonic-gate mutex_exit(&ct->ct_lock); 50357c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 50367c478bd9Sstevel@tonic-gate err = EINVAL; 50377c478bd9Sstevel@tonic-gate goto out; 50387c478bd9Sstevel@tonic-gate } 50397c478bd9Sstevel@tonic-gate 50407c478bd9Sstevel@tonic-gate /* 50417c478bd9Sstevel@tonic-gate * Moreover, we don't allow processes whose encapsulating 50427c478bd9Sstevel@tonic-gate * process contracts have inherited extrazonal contracts. 50437c478bd9Sstevel@tonic-gate * While it would be easier to eliminate all process contracts 50447c478bd9Sstevel@tonic-gate * with inherited contracts, we need to be able to give a 50457c478bd9Sstevel@tonic-gate * restarted init (or other zone-penetrating process) its 50467c478bd9Sstevel@tonic-gate * predecessor's contracts. 50477c478bd9Sstevel@tonic-gate */ 50487c478bd9Sstevel@tonic-gate if (ctp->conp_ninherited != 0) { 50497c478bd9Sstevel@tonic-gate contract_t *next; 50507c478bd9Sstevel@tonic-gate for (next = list_head(&ctp->conp_inherited); next; 50517c478bd9Sstevel@tonic-gate next = list_next(&ctp->conp_inherited, next)) { 50527c478bd9Sstevel@tonic-gate if (contract_getzuniqid(next) != zone->zone_uniqid) { 50537c478bd9Sstevel@tonic-gate mutex_exit(&pp->p_lock); 50547c478bd9Sstevel@tonic-gate mutex_exit(&ct->ct_lock); 50557c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 50567c478bd9Sstevel@tonic-gate err = EINVAL; 50577c478bd9Sstevel@tonic-gate goto out; 50587c478bd9Sstevel@tonic-gate } 50597c478bd9Sstevel@tonic-gate } 50607c478bd9Sstevel@tonic-gate } 50617b209c2cSacruz 50627c478bd9Sstevel@tonic-gate mutex_exit(&pp->p_lock); 50637c478bd9Sstevel@tonic-gate mutex_exit(&ct->ct_lock); 50647c478bd9Sstevel@tonic-gate 50657c478bd9Sstevel@tonic-gate status = zone_status_get(zone); 50667c478bd9Sstevel@tonic-gate if (status < ZONE_IS_READY || status >= ZONE_IS_SHUTTING_DOWN) { 50677c478bd9Sstevel@tonic-gate /* 50687c478bd9Sstevel@tonic-gate * Can't join 50697c478bd9Sstevel@tonic-gate */ 50707c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 50717c478bd9Sstevel@tonic-gate err = EINVAL; 50727c478bd9Sstevel@tonic-gate goto out; 50737c478bd9Sstevel@tonic-gate } 50747c478bd9Sstevel@tonic-gate 50757c478bd9Sstevel@tonic-gate /* 50767c478bd9Sstevel@tonic-gate * Make sure new priv set is within the permitted set for caller 50777c478bd9Sstevel@tonic-gate */ 50787c478bd9Sstevel@tonic-gate if (!priv_issubset(zone->zone_privset, &CR_OPPRIV(CRED()))) { 50797c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 50807c478bd9Sstevel@tonic-gate err = EPERM; 50817c478bd9Sstevel@tonic-gate goto out; 50827c478bd9Sstevel@tonic-gate } 50837c478bd9Sstevel@tonic-gate /* 50847c478bd9Sstevel@tonic-gate * We want to momentarily drop zonehash_lock while we optimistically 50857c478bd9Sstevel@tonic-gate * bind curproc to the pool it should be running in. This is safe 50867c478bd9Sstevel@tonic-gate * since the zone can't disappear (we have a hold on it). 50877c478bd9Sstevel@tonic-gate */ 50887c478bd9Sstevel@tonic-gate zone_hold(zone); 50897c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 50907c478bd9Sstevel@tonic-gate 50917c478bd9Sstevel@tonic-gate /* 50927c478bd9Sstevel@tonic-gate * Grab pool_lock to keep the pools configuration from changing 50937c478bd9Sstevel@tonic-gate * and to stop ourselves from getting rebound to another pool 50947c478bd9Sstevel@tonic-gate * until we join the zone. 50957c478bd9Sstevel@tonic-gate */ 50967c478bd9Sstevel@tonic-gate if (pool_lock_intr() != 0) { 50977c478bd9Sstevel@tonic-gate zone_rele(zone); 50987c478bd9Sstevel@tonic-gate err = EINTR; 50997c478bd9Sstevel@tonic-gate goto out; 51007c478bd9Sstevel@tonic-gate } 51017c478bd9Sstevel@tonic-gate ASSERT(secpolicy_pool(CRED()) == 0); 51027c478bd9Sstevel@tonic-gate /* 51037c478bd9Sstevel@tonic-gate * Bind ourselves to the pool currently associated with the zone. 51047c478bd9Sstevel@tonic-gate */ 51057c478bd9Sstevel@tonic-gate oldpool = curproc->p_pool; 51067c478bd9Sstevel@tonic-gate newpool = zone_pool_get(zone); 51077c478bd9Sstevel@tonic-gate if (pool_state == POOL_ENABLED && newpool != oldpool && 51087c478bd9Sstevel@tonic-gate (err = pool_do_bind(newpool, P_PID, P_MYID, 51097c478bd9Sstevel@tonic-gate POOL_BIND_ALL)) != 0) { 51107c478bd9Sstevel@tonic-gate pool_unlock(); 51117c478bd9Sstevel@tonic-gate zone_rele(zone); 51127c478bd9Sstevel@tonic-gate goto out; 51137c478bd9Sstevel@tonic-gate } 51147c478bd9Sstevel@tonic-gate 51157c478bd9Sstevel@tonic-gate /* 51167c478bd9Sstevel@tonic-gate * Grab cpu_lock now; we'll need it later when we call 51177c478bd9Sstevel@tonic-gate * task_join(). 51187c478bd9Sstevel@tonic-gate */ 51197c478bd9Sstevel@tonic-gate mutex_enter(&cpu_lock); 51207c478bd9Sstevel@tonic-gate mutex_enter(&zonehash_lock); 51217c478bd9Sstevel@tonic-gate /* 51227c478bd9Sstevel@tonic-gate * Make sure the zone hasn't moved on since we dropped zonehash_lock. 51237c478bd9Sstevel@tonic-gate */ 51247c478bd9Sstevel@tonic-gate if (zone_status_get(zone) >= ZONE_IS_SHUTTING_DOWN) { 51257c478bd9Sstevel@tonic-gate /* 51267c478bd9Sstevel@tonic-gate * Can't join anymore. 51277c478bd9Sstevel@tonic-gate */ 51287c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 51297c478bd9Sstevel@tonic-gate mutex_exit(&cpu_lock); 51307c478bd9Sstevel@tonic-gate if (pool_state == POOL_ENABLED && 51317c478bd9Sstevel@tonic-gate newpool != oldpool) 51327c478bd9Sstevel@tonic-gate (void) pool_do_bind(oldpool, P_PID, P_MYID, 51337c478bd9Sstevel@tonic-gate POOL_BIND_ALL); 51347c478bd9Sstevel@tonic-gate pool_unlock(); 51357c478bd9Sstevel@tonic-gate zone_rele(zone); 51367c478bd9Sstevel@tonic-gate err = EINVAL; 51377c478bd9Sstevel@tonic-gate goto out; 51387c478bd9Sstevel@tonic-gate } 51397c478bd9Sstevel@tonic-gate 51400209230bSgjelinek /* 51410209230bSgjelinek * a_lock must be held while transfering locked memory and swap 51420209230bSgjelinek * reservation from the global zone to the non global zone because 51430209230bSgjelinek * asynchronous faults on the processes' address space can lock 51440209230bSgjelinek * memory and reserve swap via MCL_FUTURE and MAP_NORESERVE 51450209230bSgjelinek * segments respectively. 51460209230bSgjelinek */ 51470209230bSgjelinek AS_LOCK_ENTER(pp->as, &pp->p_as->a_lock, RW_WRITER); 51480209230bSgjelinek swap = as_swresv(); 51497c478bd9Sstevel@tonic-gate mutex_enter(&pp->p_lock); 51507c478bd9Sstevel@tonic-gate zone_proj0 = zone->zone_zsched->p_task->tk_proj; 51517c478bd9Sstevel@tonic-gate /* verify that we do not exceed and task or lwp limits */ 51527c478bd9Sstevel@tonic-gate mutex_enter(&zone->zone_nlwps_lock); 51537c478bd9Sstevel@tonic-gate /* add new lwps to zone and zone's proj0 */ 51547c478bd9Sstevel@tonic-gate zone_proj0->kpj_nlwps += pp->p_lwpcnt; 51557c478bd9Sstevel@tonic-gate zone->zone_nlwps += pp->p_lwpcnt; 51567c478bd9Sstevel@tonic-gate /* add 1 task to zone's proj0 */ 51577c478bd9Sstevel@tonic-gate zone_proj0->kpj_ntasks += 1; 51587c478bd9Sstevel@tonic-gate mutex_exit(&zone->zone_nlwps_lock); 51597c478bd9Sstevel@tonic-gate 51600209230bSgjelinek mutex_enter(&zone->zone_mem_lock); 5161c6939658Ssl zone->zone_locked_mem += pp->p_locked_mem; 5162c6939658Ssl zone_proj0->kpj_data.kpd_locked_mem += pp->p_locked_mem; 51630209230bSgjelinek zone->zone_max_swap += swap; 51640209230bSgjelinek mutex_exit(&zone->zone_mem_lock); 5165c6939658Ssl 5166c1a9a9c3Skrishna mutex_enter(&(zone_proj0->kpj_data.kpd_crypto_lock)); 5167c1a9a9c3Skrishna zone_proj0->kpj_data.kpd_crypto_mem += pp->p_crypto_mem; 5168c1a9a9c3Skrishna mutex_exit(&(zone_proj0->kpj_data.kpd_crypto_lock)); 5169c1a9a9c3Skrishna 51707c478bd9Sstevel@tonic-gate /* remove lwps from proc's old zone and old project */ 51717c478bd9Sstevel@tonic-gate mutex_enter(&pp->p_zone->zone_nlwps_lock); 51727c478bd9Sstevel@tonic-gate pp->p_zone->zone_nlwps -= pp->p_lwpcnt; 51737c478bd9Sstevel@tonic-gate pp->p_task->tk_proj->kpj_nlwps -= pp->p_lwpcnt; 51747c478bd9Sstevel@tonic-gate mutex_exit(&pp->p_zone->zone_nlwps_lock); 51757c478bd9Sstevel@tonic-gate 51760209230bSgjelinek mutex_enter(&pp->p_zone->zone_mem_lock); 5177c6939658Ssl pp->p_zone->zone_locked_mem -= pp->p_locked_mem; 5178c6939658Ssl pp->p_task->tk_proj->kpj_data.kpd_locked_mem -= pp->p_locked_mem; 51790209230bSgjelinek pp->p_zone->zone_max_swap -= swap; 51800209230bSgjelinek mutex_exit(&pp->p_zone->zone_mem_lock); 5181c6939658Ssl 5182c1a9a9c3Skrishna mutex_enter(&(pp->p_task->tk_proj->kpj_data.kpd_crypto_lock)); 5183c1a9a9c3Skrishna pp->p_task->tk_proj->kpj_data.kpd_crypto_mem -= pp->p_crypto_mem; 5184c1a9a9c3Skrishna mutex_exit(&(pp->p_task->tk_proj->kpj_data.kpd_crypto_lock)); 5185c1a9a9c3Skrishna 5186bb5ca623SVamsi Nagineni pp->p_flag |= SZONETOP; 5187bb5ca623SVamsi Nagineni pp->p_zone = zone; 5188c6939658Ssl mutex_exit(&pp->p_lock); 51890209230bSgjelinek AS_LOCK_EXIT(pp->p_as, &pp->p_as->a_lock); 5190c6939658Ssl 51917c478bd9Sstevel@tonic-gate /* 51927c478bd9Sstevel@tonic-gate * Joining the zone cannot fail from now on. 51937c478bd9Sstevel@tonic-gate * 51947c478bd9Sstevel@tonic-gate * This means that a lot of the following code can be commonized and 51957c478bd9Sstevel@tonic-gate * shared with zsched(). 51967c478bd9Sstevel@tonic-gate */ 51977c478bd9Sstevel@tonic-gate 51987b209c2cSacruz /* 51997b209c2cSacruz * If the process contract fmri was inherited, we need to 52007b209c2cSacruz * flag this so that any contract status will not leak 52017b209c2cSacruz * extra zone information, svc_fmri in this case 52027b209c2cSacruz */ 52037b209c2cSacruz if (ctp->conp_svc_ctid != ct->ct_id) { 52047b209c2cSacruz mutex_enter(&ct->ct_lock); 52057b209c2cSacruz ctp->conp_svc_zone_enter = ct->ct_id; 52067b209c2cSacruz mutex_exit(&ct->ct_lock); 52077b209c2cSacruz } 52087b209c2cSacruz 52097c478bd9Sstevel@tonic-gate /* 52107c478bd9Sstevel@tonic-gate * Reset the encapsulating process contract's zone. 52117c478bd9Sstevel@tonic-gate */ 52127c478bd9Sstevel@tonic-gate ASSERT(ct->ct_mzuniqid == GLOBAL_ZONEUNIQID); 52137c478bd9Sstevel@tonic-gate contract_setzuniqid(ct, zone->zone_uniqid); 52147c478bd9Sstevel@tonic-gate 52157c478bd9Sstevel@tonic-gate /* 52167c478bd9Sstevel@tonic-gate * Create a new task and associate the process with the project keyed 52177c478bd9Sstevel@tonic-gate * by (projid,zoneid). 52187c478bd9Sstevel@tonic-gate * 52197c478bd9Sstevel@tonic-gate * We might as well be in project 0; the global zone's projid doesn't 52207c478bd9Sstevel@tonic-gate * make much sense in a zone anyhow. 52217c478bd9Sstevel@tonic-gate * 52227c478bd9Sstevel@tonic-gate * This also increments zone_ntasks, and returns with p_lock held. 52237c478bd9Sstevel@tonic-gate */ 52247c478bd9Sstevel@tonic-gate tk = task_create(0, zone); 52257c478bd9Sstevel@tonic-gate oldtk = task_join(tk, 0); 52267c478bd9Sstevel@tonic-gate mutex_exit(&cpu_lock); 52277c478bd9Sstevel@tonic-gate 52287c478bd9Sstevel@tonic-gate /* 52297c478bd9Sstevel@tonic-gate * call RCTLOP_SET functions on this proc 52307c478bd9Sstevel@tonic-gate */ 52317c478bd9Sstevel@tonic-gate e.rcep_p.zone = zone; 52327c478bd9Sstevel@tonic-gate e.rcep_t = RCENTITY_ZONE; 52337c478bd9Sstevel@tonic-gate (void) rctl_set_dup(NULL, NULL, pp, &e, zone->zone_rctls, NULL, 52347c478bd9Sstevel@tonic-gate RCD_CALLBACK); 52357c478bd9Sstevel@tonic-gate mutex_exit(&pp->p_lock); 52367c478bd9Sstevel@tonic-gate 52377c478bd9Sstevel@tonic-gate /* 52387c478bd9Sstevel@tonic-gate * We don't need to hold any of zsched's locks here; not only do we know 52397c478bd9Sstevel@tonic-gate * the process and zone aren't going away, we know its session isn't 52407c478bd9Sstevel@tonic-gate * changing either. 52417c478bd9Sstevel@tonic-gate * 52427c478bd9Sstevel@tonic-gate * By joining zsched's session here, we mimic the behavior in the 52437c478bd9Sstevel@tonic-gate * global zone of init's sid being the pid of sched. We extend this 52447c478bd9Sstevel@tonic-gate * to all zlogin-like zone_enter()'ing processes as well. 52457c478bd9Sstevel@tonic-gate */ 52467c478bd9Sstevel@tonic-gate mutex_enter(&pidlock); 52477c478bd9Sstevel@tonic-gate sp = zone->zone_zsched->p_sessp; 52489acbbeafSnn sess_hold(zone->zone_zsched); 52497c478bd9Sstevel@tonic-gate mutex_enter(&pp->p_lock); 52507c478bd9Sstevel@tonic-gate pgexit(pp); 52519acbbeafSnn sess_rele(pp->p_sessp, B_TRUE); 52527c478bd9Sstevel@tonic-gate pp->p_sessp = sp; 52537c478bd9Sstevel@tonic-gate pgjoin(pp, zone->zone_zsched->p_pidp); 52540209230bSgjelinek 5255c97ad5cdSakolb /* 5256c97ad5cdSakolb * If any threads are scheduled to be placed on zone wait queue they 5257c97ad5cdSakolb * should abandon the idea since the wait queue is changing. 5258c97ad5cdSakolb * We need to be holding pidlock & p_lock to do this. 5259c97ad5cdSakolb */ 5260c97ad5cdSakolb if ((t = pp->p_tlist) != NULL) { 5261c97ad5cdSakolb do { 5262c97ad5cdSakolb thread_lock(t); 5263c97ad5cdSakolb /* 5264c97ad5cdSakolb * Kick this thread so that he doesn't sit 5265c97ad5cdSakolb * on a wrong wait queue. 5266c97ad5cdSakolb */ 5267c97ad5cdSakolb if (ISWAITING(t)) 5268c97ad5cdSakolb setrun_locked(t); 5269c97ad5cdSakolb 5270c97ad5cdSakolb if (t->t_schedflag & TS_ANYWAITQ) 5271c97ad5cdSakolb t->t_schedflag &= ~ TS_ANYWAITQ; 5272c97ad5cdSakolb 5273c97ad5cdSakolb thread_unlock(t); 5274c97ad5cdSakolb } while ((t = t->t_forw) != pp->p_tlist); 5275c97ad5cdSakolb } 5276c97ad5cdSakolb 52770209230bSgjelinek /* 52780209230bSgjelinek * If there is a default scheduling class for the zone and it is not 52790209230bSgjelinek * the class we are currently in, change all of the threads in the 52800209230bSgjelinek * process to the new class. We need to be holding pidlock & p_lock 52810209230bSgjelinek * when we call parmsset so this is a good place to do it. 52820209230bSgjelinek */ 52830209230bSgjelinek if (zone->zone_defaultcid > 0 && 52840209230bSgjelinek zone->zone_defaultcid != curthread->t_cid) { 52850209230bSgjelinek pcparms_t pcparms; 52860209230bSgjelinek 52870209230bSgjelinek pcparms.pc_cid = zone->zone_defaultcid; 52880209230bSgjelinek pcparms.pc_clparms[0] = 0; 52890209230bSgjelinek 52900209230bSgjelinek /* 52910209230bSgjelinek * If setting the class fails, we still want to enter the zone. 52920209230bSgjelinek */ 52930209230bSgjelinek if ((t = pp->p_tlist) != NULL) { 52940209230bSgjelinek do { 52950209230bSgjelinek (void) parmsset(&pcparms, t); 52960209230bSgjelinek } while ((t = t->t_forw) != pp->p_tlist); 52970209230bSgjelinek } 52980209230bSgjelinek } 52990209230bSgjelinek 53007c478bd9Sstevel@tonic-gate mutex_exit(&pp->p_lock); 53017c478bd9Sstevel@tonic-gate mutex_exit(&pidlock); 53027c478bd9Sstevel@tonic-gate 53037c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 53047c478bd9Sstevel@tonic-gate /* 53057c478bd9Sstevel@tonic-gate * We're firmly in the zone; let pools progress. 53067c478bd9Sstevel@tonic-gate */ 53077c478bd9Sstevel@tonic-gate pool_unlock(); 53087c478bd9Sstevel@tonic-gate task_rele(oldtk); 53097c478bd9Sstevel@tonic-gate /* 53107c478bd9Sstevel@tonic-gate * We don't need to retain a hold on the zone since we already 53117c478bd9Sstevel@tonic-gate * incremented zone_ntasks, so the zone isn't going anywhere. 53127c478bd9Sstevel@tonic-gate */ 53137c478bd9Sstevel@tonic-gate zone_rele(zone); 53147c478bd9Sstevel@tonic-gate 53157c478bd9Sstevel@tonic-gate /* 53167c478bd9Sstevel@tonic-gate * Chroot 53177c478bd9Sstevel@tonic-gate */ 53187c478bd9Sstevel@tonic-gate vp = zone->zone_rootvp; 53197c478bd9Sstevel@tonic-gate zone_chdir(vp, &PTOU(pp)->u_cdir, pp); 53207c478bd9Sstevel@tonic-gate zone_chdir(vp, &PTOU(pp)->u_rdir, pp); 53217c478bd9Sstevel@tonic-gate 53227c478bd9Sstevel@tonic-gate /* 53237c478bd9Sstevel@tonic-gate * Change process credentials 53247c478bd9Sstevel@tonic-gate */ 53257c478bd9Sstevel@tonic-gate newcr = cralloc(); 53267c478bd9Sstevel@tonic-gate mutex_enter(&pp->p_crlock); 53277c478bd9Sstevel@tonic-gate cr = pp->p_cred; 53287c478bd9Sstevel@tonic-gate crcopy_to(cr, newcr); 53297c478bd9Sstevel@tonic-gate crsetzone(newcr, zone); 53307c478bd9Sstevel@tonic-gate pp->p_cred = newcr; 53317c478bd9Sstevel@tonic-gate 53327c478bd9Sstevel@tonic-gate /* 53337c478bd9Sstevel@tonic-gate * Restrict all process privilege sets to zone limit 53347c478bd9Sstevel@tonic-gate */ 53357c478bd9Sstevel@tonic-gate priv_intersect(zone->zone_privset, &CR_PPRIV(newcr)); 53367c478bd9Sstevel@tonic-gate priv_intersect(zone->zone_privset, &CR_EPRIV(newcr)); 53377c478bd9Sstevel@tonic-gate priv_intersect(zone->zone_privset, &CR_IPRIV(newcr)); 53387c478bd9Sstevel@tonic-gate priv_intersect(zone->zone_privset, &CR_LPRIV(newcr)); 53397c478bd9Sstevel@tonic-gate mutex_exit(&pp->p_crlock); 53407c478bd9Sstevel@tonic-gate crset(pp, newcr); 53417c478bd9Sstevel@tonic-gate 53427c478bd9Sstevel@tonic-gate /* 53437c478bd9Sstevel@tonic-gate * Adjust upcount to reflect zone entry. 53447c478bd9Sstevel@tonic-gate */ 53457c478bd9Sstevel@tonic-gate uid = crgetruid(newcr); 53467c478bd9Sstevel@tonic-gate mutex_enter(&pidlock); 53477c478bd9Sstevel@tonic-gate upcount_dec(uid, GLOBAL_ZONEID); 53487c478bd9Sstevel@tonic-gate upcount_inc(uid, zoneid); 53497c478bd9Sstevel@tonic-gate mutex_exit(&pidlock); 53507c478bd9Sstevel@tonic-gate 53517c478bd9Sstevel@tonic-gate /* 53527c478bd9Sstevel@tonic-gate * Set up core file path and content. 53537c478bd9Sstevel@tonic-gate */ 53547c478bd9Sstevel@tonic-gate set_core_defaults(); 53557c478bd9Sstevel@tonic-gate 53567c478bd9Sstevel@tonic-gate out: 53577c478bd9Sstevel@tonic-gate /* 53587c478bd9Sstevel@tonic-gate * Let the other lwps continue. 53597c478bd9Sstevel@tonic-gate */ 53607c478bd9Sstevel@tonic-gate mutex_enter(&pp->p_lock); 53617c478bd9Sstevel@tonic-gate if (curthread != pp->p_agenttp) 53627c478bd9Sstevel@tonic-gate continuelwps(pp); 53637c478bd9Sstevel@tonic-gate mutex_exit(&pp->p_lock); 53647c478bd9Sstevel@tonic-gate 53657c478bd9Sstevel@tonic-gate return (err != 0 ? set_errno(err) : 0); 53667c478bd9Sstevel@tonic-gate } 53677c478bd9Sstevel@tonic-gate 53687c478bd9Sstevel@tonic-gate /* 53697c478bd9Sstevel@tonic-gate * Systemcall entry point for zone_list(2). 53707c478bd9Sstevel@tonic-gate * 53717c478bd9Sstevel@tonic-gate * Processes running in a (non-global) zone only see themselves. 537245916cd2Sjpk * On labeled systems, they see all zones whose label they dominate. 53737c478bd9Sstevel@tonic-gate */ 53747c478bd9Sstevel@tonic-gate static int 53757c478bd9Sstevel@tonic-gate zone_list(zoneid_t *zoneidlist, uint_t *numzones) 53767c478bd9Sstevel@tonic-gate { 53777c478bd9Sstevel@tonic-gate zoneid_t *zoneids; 537848451833Scarlsonj zone_t *zone, *myzone; 53797c478bd9Sstevel@tonic-gate uint_t user_nzones, real_nzones; 538045916cd2Sjpk uint_t domi_nzones; 538145916cd2Sjpk int error; 53827c478bd9Sstevel@tonic-gate 53837c478bd9Sstevel@tonic-gate if (copyin(numzones, &user_nzones, sizeof (uint_t)) != 0) 53847c478bd9Sstevel@tonic-gate return (set_errno(EFAULT)); 53857c478bd9Sstevel@tonic-gate 538648451833Scarlsonj myzone = curproc->p_zone; 538748451833Scarlsonj if (myzone != global_zone) { 538845916cd2Sjpk bslabel_t *mybslab; 538945916cd2Sjpk 539045916cd2Sjpk if (!is_system_labeled()) { 539145916cd2Sjpk /* just return current zone */ 539245916cd2Sjpk real_nzones = domi_nzones = 1; 539345916cd2Sjpk zoneids = kmem_alloc(sizeof (zoneid_t), KM_SLEEP); 539448451833Scarlsonj zoneids[0] = myzone->zone_id; 539545916cd2Sjpk } else { 539645916cd2Sjpk /* return all zones that are dominated */ 539745916cd2Sjpk mutex_enter(&zonehash_lock); 539845916cd2Sjpk real_nzones = zonecount; 539945916cd2Sjpk domi_nzones = 0; 540045916cd2Sjpk if (real_nzones > 0) { 540145916cd2Sjpk zoneids = kmem_alloc(real_nzones * 540245916cd2Sjpk sizeof (zoneid_t), KM_SLEEP); 540348451833Scarlsonj mybslab = label2bslabel(myzone->zone_slabel); 540445916cd2Sjpk for (zone = list_head(&zone_active); 540545916cd2Sjpk zone != NULL; 540645916cd2Sjpk zone = list_next(&zone_active, zone)) { 540745916cd2Sjpk if (zone->zone_id == GLOBAL_ZONEID) 540845916cd2Sjpk continue; 540948451833Scarlsonj if (zone != myzone && 541048451833Scarlsonj (zone->zone_flags & ZF_IS_SCRATCH)) 541148451833Scarlsonj continue; 541248451833Scarlsonj /* 541348451833Scarlsonj * Note that a label always dominates 541448451833Scarlsonj * itself, so myzone is always included 541548451833Scarlsonj * in the list. 541648451833Scarlsonj */ 541745916cd2Sjpk if (bldominates(mybslab, 541845916cd2Sjpk label2bslabel(zone->zone_slabel))) { 541945916cd2Sjpk zoneids[domi_nzones++] = 542045916cd2Sjpk zone->zone_id; 542145916cd2Sjpk } 542245916cd2Sjpk } 542345916cd2Sjpk } 542445916cd2Sjpk mutex_exit(&zonehash_lock); 542545916cd2Sjpk } 54267c478bd9Sstevel@tonic-gate } else { 54277c478bd9Sstevel@tonic-gate mutex_enter(&zonehash_lock); 54287c478bd9Sstevel@tonic-gate real_nzones = zonecount; 542945916cd2Sjpk domi_nzones = 0; 543045916cd2Sjpk if (real_nzones > 0) { 54317c478bd9Sstevel@tonic-gate zoneids = kmem_alloc(real_nzones * sizeof (zoneid_t), 54327c478bd9Sstevel@tonic-gate KM_SLEEP); 54337c478bd9Sstevel@tonic-gate for (zone = list_head(&zone_active); zone != NULL; 54347c478bd9Sstevel@tonic-gate zone = list_next(&zone_active, zone)) 543545916cd2Sjpk zoneids[domi_nzones++] = zone->zone_id; 543645916cd2Sjpk ASSERT(domi_nzones == real_nzones); 54377c478bd9Sstevel@tonic-gate } 54387c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 54397c478bd9Sstevel@tonic-gate } 54407c478bd9Sstevel@tonic-gate 544145916cd2Sjpk /* 544245916cd2Sjpk * If user has allocated space for fewer entries than we found, then 544345916cd2Sjpk * return only up to his limit. Either way, tell him exactly how many 544445916cd2Sjpk * we found. 544545916cd2Sjpk */ 544645916cd2Sjpk if (domi_nzones < user_nzones) 544745916cd2Sjpk user_nzones = domi_nzones; 544845916cd2Sjpk error = 0; 544945916cd2Sjpk if (copyout(&domi_nzones, numzones, sizeof (uint_t)) != 0) { 54507c478bd9Sstevel@tonic-gate error = EFAULT; 545145916cd2Sjpk } else if (zoneidlist != NULL && user_nzones != 0) { 54527c478bd9Sstevel@tonic-gate if (copyout(zoneids, zoneidlist, 54537c478bd9Sstevel@tonic-gate user_nzones * sizeof (zoneid_t)) != 0) 54547c478bd9Sstevel@tonic-gate error = EFAULT; 54557c478bd9Sstevel@tonic-gate } 54567c478bd9Sstevel@tonic-gate 545745916cd2Sjpk if (real_nzones > 0) 54587c478bd9Sstevel@tonic-gate kmem_free(zoneids, real_nzones * sizeof (zoneid_t)); 54597c478bd9Sstevel@tonic-gate 546045916cd2Sjpk if (error != 0) 54617c478bd9Sstevel@tonic-gate return (set_errno(error)); 54627c478bd9Sstevel@tonic-gate else 54637c478bd9Sstevel@tonic-gate return (0); 54647c478bd9Sstevel@tonic-gate } 54657c478bd9Sstevel@tonic-gate 54667c478bd9Sstevel@tonic-gate /* 54677c478bd9Sstevel@tonic-gate * Systemcall entry point for zone_lookup(2). 54687c478bd9Sstevel@tonic-gate * 546945916cd2Sjpk * Non-global zones are only able to see themselves and (on labeled systems) 547045916cd2Sjpk * the zones they dominate. 54717c478bd9Sstevel@tonic-gate */ 54727c478bd9Sstevel@tonic-gate static zoneid_t 54737c478bd9Sstevel@tonic-gate zone_lookup(const char *zone_name) 54747c478bd9Sstevel@tonic-gate { 54757c478bd9Sstevel@tonic-gate char *kname; 54767c478bd9Sstevel@tonic-gate zone_t *zone; 54777c478bd9Sstevel@tonic-gate zoneid_t zoneid; 54787c478bd9Sstevel@tonic-gate int err; 54797c478bd9Sstevel@tonic-gate 54807c478bd9Sstevel@tonic-gate if (zone_name == NULL) { 54817c478bd9Sstevel@tonic-gate /* return caller's zone id */ 54827c478bd9Sstevel@tonic-gate return (getzoneid()); 54837c478bd9Sstevel@tonic-gate } 54847c478bd9Sstevel@tonic-gate 54857c478bd9Sstevel@tonic-gate kname = kmem_zalloc(ZONENAME_MAX, KM_SLEEP); 54867c478bd9Sstevel@tonic-gate if ((err = copyinstr(zone_name, kname, ZONENAME_MAX, NULL)) != 0) { 54877c478bd9Sstevel@tonic-gate kmem_free(kname, ZONENAME_MAX); 54887c478bd9Sstevel@tonic-gate return (set_errno(err)); 54897c478bd9Sstevel@tonic-gate } 54907c478bd9Sstevel@tonic-gate 54917c478bd9Sstevel@tonic-gate mutex_enter(&zonehash_lock); 54927c478bd9Sstevel@tonic-gate zone = zone_find_all_by_name(kname); 54937c478bd9Sstevel@tonic-gate kmem_free(kname, ZONENAME_MAX); 549445916cd2Sjpk /* 549545916cd2Sjpk * In a non-global zone, can only lookup global and own name. 549645916cd2Sjpk * In Trusted Extensions zone label dominance rules apply. 549745916cd2Sjpk */ 549845916cd2Sjpk if (zone == NULL || 549945916cd2Sjpk zone_status_get(zone) < ZONE_IS_READY || 550045916cd2Sjpk !zone_list_access(zone)) { 55017c478bd9Sstevel@tonic-gate mutex_exit(&zonehash_lock); 55027c478bd9Sstevel@tonic-gate return (set_errno(EINVAL)); 550345916cd2Sjpk } else { 550445916cd2Sjpk zoneid = zone->zone_id; 550545916cd2Sjpk mutex_exit(&zonehash_lock); 550645916cd2Sjpk return (zoneid); 55077c478bd9Sstevel@tonic-gate } 55087c478bd9Sstevel@tonic-gate } 55097c478bd9Sstevel@tonic-gate 5510821c4a97Sdp static int 5511821c4a97Sdp zone_version(int *version_arg) 5512821c4a97Sdp { 5513821c4a97Sdp int version = ZONE_SYSCALL_API_VERSION; 5514821c4a97Sdp 5515821c4a97Sdp if (copyout(&version, version_arg, sizeof (int)) != 0) 5516821c4a97Sdp return (set_errno(EFAULT)); 5517821c4a97Sdp return (0); 5518821c4a97Sdp } 5519821c4a97Sdp 55207c478bd9Sstevel@tonic-gate /* ARGSUSED */ 55217c478bd9Sstevel@tonic-gate long 5522fa9e4066Sahrens zone(int cmd, void *arg1, void *arg2, void *arg3, void *arg4) 55237c478bd9Sstevel@tonic-gate { 55247c478bd9Sstevel@tonic-gate zone_def zs; 55252b24ab6bSSebastien Roy int err; 55267c478bd9Sstevel@tonic-gate 55277c478bd9Sstevel@tonic-gate switch (cmd) { 55287c478bd9Sstevel@tonic-gate case ZONE_CREATE: 55297c478bd9Sstevel@tonic-gate if (get_udatamodel() == DATAMODEL_NATIVE) { 55307c478bd9Sstevel@tonic-gate if (copyin(arg1, &zs, sizeof (zone_def))) { 55317c478bd9Sstevel@tonic-gate return (set_errno(EFAULT)); 55327c478bd9Sstevel@tonic-gate } 55337c478bd9Sstevel@tonic-gate } else { 55347c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL 55357c478bd9Sstevel@tonic-gate zone_def32 zs32; 55367c478bd9Sstevel@tonic-gate 55377c478bd9Sstevel@tonic-gate if (copyin(arg1, &zs32, sizeof (zone_def32))) { 55387c478bd9Sstevel@tonic-gate return (set_errno(EFAULT)); 55397c478bd9Sstevel@tonic-gate } 55407c478bd9Sstevel@tonic-gate zs.zone_name = 55417c478bd9Sstevel@tonic-gate (const char *)(unsigned long)zs32.zone_name; 55427c478bd9Sstevel@tonic-gate zs.zone_root = 55437c478bd9Sstevel@tonic-gate (const char *)(unsigned long)zs32.zone_root; 55447c478bd9Sstevel@tonic-gate zs.zone_privs = 55457c478bd9Sstevel@tonic-gate (const struct priv_set *) 55467c478bd9Sstevel@tonic-gate (unsigned long)zs32.zone_privs; 55476f70df68Sdp zs.zone_privssz = zs32.zone_privssz; 55487c478bd9Sstevel@tonic-gate zs.rctlbuf = (caddr_t)(unsigned long)zs32.rctlbuf; 55497c478bd9Sstevel@tonic-gate zs.rctlbufsz = zs32.rctlbufsz; 5550fa9e4066Sahrens zs.zfsbuf = (caddr_t)(unsigned long)zs32.zfsbuf; 5551fa9e4066Sahrens zs.zfsbufsz = zs32.zfsbufsz; 55527c478bd9Sstevel@tonic-gate zs.extended_error = 55537c478bd9Sstevel@tonic-gate (int *)(unsigned long)zs32.extended_error; 555445916cd2Sjpk zs.match = zs32.match; 555545916cd2Sjpk zs.doi = zs32.doi; 555645916cd2Sjpk zs.label = (const bslabel_t *)(uintptr_t)zs32.label; 5557f4b3ec61Sdh zs.flags = zs32.flags; 55587c478bd9Sstevel@tonic-gate #else 55597c478bd9Sstevel@tonic-gate panic("get_udatamodel() returned bogus result\n"); 55607c478bd9Sstevel@tonic-gate #endif 55617c478bd9Sstevel@tonic-gate } 55627c478bd9Sstevel@tonic-gate 55637c478bd9Sstevel@tonic-gate return (zone_create(zs.zone_name, zs.zone_root, 5564821c4a97Sdp zs.zone_privs, zs.zone_privssz, 5565821c4a97Sdp (caddr_t)zs.rctlbuf, zs.rctlbufsz, 5566821c4a97Sdp (caddr_t)zs.zfsbuf, zs.zfsbufsz, 556745916cd2Sjpk zs.extended_error, zs.match, zs.doi, 5568f4b3ec61Sdh zs.label, zs.flags)); 55697c478bd9Sstevel@tonic-gate case ZONE_BOOT: 55703f2f09c1Sdp return (zone_boot((zoneid_t)(uintptr_t)arg1)); 55717c478bd9Sstevel@tonic-gate case ZONE_DESTROY: 55727c478bd9Sstevel@tonic-gate return (zone_destroy((zoneid_t)(uintptr_t)arg1)); 55737c478bd9Sstevel@tonic-gate case ZONE_GETATTR: 55747c478bd9Sstevel@tonic-gate return (zone_getattr((zoneid_t)(uintptr_t)arg1, 55757c478bd9Sstevel@tonic-gate (int)(uintptr_t)arg2, arg3, (size_t)arg4)); 55763f2f09c1Sdp case ZONE_SETATTR: 55773f2f09c1Sdp return (zone_setattr((zoneid_t)(uintptr_t)arg1, 55783f2f09c1Sdp (int)(uintptr_t)arg2, arg3, (size_t)arg4)); 55797c478bd9Sstevel@tonic-gate case ZONE_ENTER: 55807c478bd9Sstevel@tonic-gate return (zone_enter((zoneid_t)(uintptr_t)arg1)); 55817c478bd9Sstevel@tonic-gate case ZONE_LIST: 55827c478bd9Sstevel@tonic-gate return (zone_list((zoneid_t *)arg1, (uint_t *)arg2)); 55837c478bd9Sstevel@tonic-gate case ZONE_SHUTDOWN: 55847c478bd9Sstevel@tonic-gate return (zone_shutdown((zoneid_t)(uintptr_t)arg1)); 55857c478bd9Sstevel@tonic-gate case ZONE_LOOKUP: 55867c478bd9Sstevel@tonic-gate return (zone_lookup((const char *)arg1)); 5587821c4a97Sdp case ZONE_VERSION: 5588821c4a97Sdp return (zone_version((int *)arg1)); 5589f4b3ec61Sdh case ZONE_ADD_DATALINK: 5590f4b3ec61Sdh return (zone_add_datalink((zoneid_t)(uintptr_t)arg1, 55912b24ab6bSSebastien Roy (datalink_id_t)(uintptr_t)arg2)); 5592f4b3ec61Sdh case ZONE_DEL_DATALINK: 5593f4b3ec61Sdh return (zone_remove_datalink((zoneid_t)(uintptr_t)arg1, 55942b24ab6bSSebastien Roy (datalink_id_t)(uintptr_t)arg2)); 55952b24ab6bSSebastien Roy case ZONE_CHECK_DATALINK: { 55962b24ab6bSSebastien Roy zoneid_t zoneid; 55972b24ab6bSSebastien Roy boolean_t need_copyout; 55982b24ab6bSSebastien Roy 55992b24ab6bSSebastien Roy if (copyin(arg1, &zoneid, sizeof (zoneid)) != 0) 56002b24ab6bSSebastien Roy return (EFAULT); 56012b24ab6bSSebastien Roy need_copyout = (zoneid == ALL_ZONES); 56022b24ab6bSSebastien Roy err = zone_check_datalink(&zoneid, 56032b24ab6bSSebastien Roy (datalink_id_t)(uintptr_t)arg2); 56042b24ab6bSSebastien Roy if (err == 0 && need_copyout) { 56052b24ab6bSSebastien Roy if (copyout(&zoneid, arg1, sizeof (zoneid)) != 0) 56062b24ab6bSSebastien Roy err = EFAULT; 56072b24ab6bSSebastien Roy } 56082b24ab6bSSebastien Roy return (err == 0 ? 0 : set_errno(err)); 56092b24ab6bSSebastien Roy } 5610f4b3ec61Sdh case ZONE_LIST_DATALINK: 5611f4b3ec61Sdh return (zone_list_datalink((zoneid_t)(uintptr_t)arg1, 56122b24ab6bSSebastien Roy (int *)arg2, (datalink_id_t *)(uintptr_t)arg3)); 56137c478bd9Sstevel@tonic-gate default: 56147c478bd9Sstevel@tonic-gate return (set_errno(EINVAL)); 56157c478bd9Sstevel@tonic-gate } 56167c478bd9Sstevel@tonic-gate } 56177c478bd9Sstevel@tonic-gate 56187c478bd9Sstevel@tonic-gate struct zarg { 56197c478bd9Sstevel@tonic-gate zone_t *zone; 56207c478bd9Sstevel@tonic-gate zone_cmd_arg_t arg; 56217c478bd9Sstevel@tonic-gate }; 56227c478bd9Sstevel@tonic-gate 56237c478bd9Sstevel@tonic-gate static int 56247c478bd9Sstevel@tonic-gate zone_lookup_door(const char *zone_name, door_handle_t *doorp) 56257c478bd9Sstevel@tonic-gate { 56267c478bd9Sstevel@tonic-gate char *buf; 56277c478bd9Sstevel@tonic-gate size_t buflen; 56287c478bd9Sstevel@tonic-gate int error; 56297c478bd9Sstevel@tonic-gate 56307c478bd9Sstevel@tonic-gate buflen = sizeof (ZONE_DOOR_PATH) + strlen(zone_name); 56317c478bd9Sstevel@tonic-gate buf = kmem_alloc(buflen, KM_SLEEP); 56327c478bd9Sstevel@tonic-gate (void) snprintf(buf, buflen, ZONE_DOOR_PATH, zone_name); 56337c478bd9Sstevel@tonic-gate error = door_ki_open(buf, doorp); 56347c478bd9Sstevel@tonic-gate kmem_free(buf, buflen); 56357c478bd9Sstevel@tonic-gate return (error); 56367c478bd9Sstevel@tonic-gate } 56377c478bd9Sstevel@tonic-gate 56387c478bd9Sstevel@tonic-gate static void 56397c478bd9Sstevel@tonic-gate zone_release_door(door_handle_t *doorp) 56407c478bd9Sstevel@tonic-gate { 56417c478bd9Sstevel@tonic-gate door_ki_rele(*doorp); 56427c478bd9Sstevel@tonic-gate *doorp = NULL; 56437c478bd9Sstevel@tonic-gate } 56447c478bd9Sstevel@tonic-gate 56457c478bd9Sstevel@tonic-gate static void 56467c478bd9Sstevel@tonic-gate zone_ki_call_zoneadmd(struct zarg *zargp) 56477c478bd9Sstevel@tonic-gate { 56487c478bd9Sstevel@tonic-gate door_handle_t door = NULL; 56497c478bd9Sstevel@tonic-gate door_arg_t darg, save_arg; 56507c478bd9Sstevel@tonic-gate char *zone_name; 56517c478bd9Sstevel@tonic-gate size_t zone_namelen; 56527c478bd9Sstevel@tonic-gate zoneid_t zoneid; 56537c478bd9Sstevel@tonic-gate zone_t *zone; 56547c478bd9Sstevel@tonic-gate zone_cmd_arg_t arg; 56557c478bd9Sstevel@tonic-gate uint64_t uniqid; 56567c478bd9Sstevel@tonic-gate size_t size; 56577c478bd9Sstevel@tonic-gate int error; 56587c478bd9Sstevel@tonic-gate int retry; 56597c478bd9Sstevel@tonic-gate 56607c478bd9Sstevel@tonic-gate zone = zargp->zone; 56617c478bd9Sstevel@tonic-gate arg = zargp->arg; 56627c478bd9Sstevel@tonic-gate kmem_free(zargp, sizeof (*zargp)); 56637c478bd9Sstevel@tonic-gate 56647c478bd9Sstevel@tonic-gate zone_namelen = strlen(zone->zone_name) + 1; 56657c478bd9Sstevel@tonic-gate zone_name = kmem_alloc(zone_namelen, KM_SLEEP); 56667c478bd9Sstevel@tonic-gate bcopy(zone->zone_name, zone_name, zone_namelen); 56677c478bd9Sstevel@tonic-gate zoneid = zone->zone_id; 56687c478bd9Sstevel@tonic-gate uniqid = zone->zone_uniqid; 56697c478bd9Sstevel@tonic-gate /* 56707c478bd9Sstevel@tonic-gate * zoneadmd may be down, but at least we can empty out the zone. 56717c478bd9Sstevel@tonic-gate * We can ignore the return value of zone_empty() since we're called 56727c478bd9Sstevel@tonic-gate * from a kernel thread and know we won't be delivered any signals. 56737c478bd9Sstevel@tonic-gate */ 56747c478bd9Sstevel@tonic-gate ASSERT(curproc == &p0); 56757c478bd9Sstevel@tonic-gate (void) zone_empty(zone); 56767c478bd9Sstevel@tonic-gate ASSERT(zone_status_get(zone) >= ZONE_IS_EMPTY); 56777c478bd9Sstevel@tonic-gate zone_rele(zone); 56787c478bd9Sstevel@tonic-gate 56797c478bd9Sstevel@tonic-gate size = sizeof (arg); 56807c478bd9Sstevel@tonic-gate darg.rbuf = (char *)&arg; 56817c478bd9Sstevel@tonic-gate darg.data_ptr = (char *)&arg; 56827c478bd9Sstevel@tonic-gate darg.rsize = size; 56837c478bd9Sstevel@tonic-gate darg.data_size = size; 56847c478bd9Sstevel@tonic-gate darg.desc_ptr = NULL; 56857c478bd9Sstevel@tonic-gate darg.desc_num = 0; 56867c478bd9Sstevel@tonic-gate 56877c478bd9Sstevel@tonic-gate save_arg = darg; 56887c478bd9Sstevel@tonic-gate /* 56897c478bd9Sstevel@tonic-gate * Since we're not holding a reference to the zone, any number of 56907c478bd9Sstevel@tonic-gate * things can go wrong, including the zone disappearing before we get a 56917c478bd9Sstevel@tonic-gate * chance to talk to zoneadmd. 56927c478bd9Sstevel@tonic-gate */ 56937c478bd9Sstevel@tonic-gate for (retry = 0; /* forever */; retry++) { 56947c478bd9Sstevel@tonic-gate if (door == NULL && 56957c478bd9Sstevel@tonic-gate (error = zone_lookup_door(zone_name, &door)) != 0) { 56967c478bd9Sstevel@tonic-gate goto next; 56977c478bd9Sstevel@tonic-gate } 56987c478bd9Sstevel@tonic-gate ASSERT(door != NULL); 56997c478bd9Sstevel@tonic-gate 5700323a81d9Sjwadams if ((error = door_ki_upcall_limited(door, &darg, NULL, 5701323a81d9Sjwadams SIZE_MAX, 0)) == 0) { 57027c478bd9Sstevel@tonic-gate break; 57037c478bd9Sstevel@tonic-gate } 57047c478bd9Sstevel@tonic-gate switch (error) { 57057c478bd9Sstevel@tonic-gate case EINTR: 57067c478bd9Sstevel@tonic-gate /* FALLTHROUGH */ 57077c478bd9Sstevel@tonic-gate case EAGAIN: /* process may be forking */ 57087c478bd9Sstevel@tonic-gate /* 57097c478bd9Sstevel@tonic-gate * Back off for a bit 57107c478bd9Sstevel@tonic-gate */ 57117c478bd9Sstevel@tonic-gate break; 57127c478bd9Sstevel@tonic-gate case EBADF: 57137c478bd9Sstevel@tonic-gate zone_release_door(&door); 57147c478bd9Sstevel@tonic-gate if (zone_lookup_door(zone_name, &door) != 0) { 57157c478bd9Sstevel@tonic-gate /* 57167c478bd9Sstevel@tonic-gate * zoneadmd may be dead, but it may come back to 57177c478bd9Sstevel@tonic-gate * life later. 57187c478bd9Sstevel@tonic-gate */ 57197c478bd9Sstevel@tonic-gate break; 57207c478bd9Sstevel@tonic-gate } 57217c478bd9Sstevel@tonic-gate break; 57227c478bd9Sstevel@tonic-gate default: 57237c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, 57247c478bd9Sstevel@tonic-gate "zone_ki_call_zoneadmd: door_ki_upcall error %d\n", 57257c478bd9Sstevel@tonic-gate error); 57267c478bd9Sstevel@tonic-gate goto out; 57277c478bd9Sstevel@tonic-gate } 57287c478bd9Sstevel@tonic-gate next: 57297c478bd9Sstevel@tonic-gate /* 57307c478bd9Sstevel@tonic-gate * If this isn't the same zone_t that we originally had in mind, 57317c478bd9Sstevel@tonic-gate * then this is the same as if two kadmin requests come in at 57327c478bd9Sstevel@tonic-gate * the same time: the first one wins. This means we lose, so we 57337c478bd9Sstevel@tonic-gate * bail. 57347c478bd9Sstevel@tonic-gate */ 57357c478bd9Sstevel@tonic-gate if ((zone = zone_find_by_id(zoneid)) == NULL) { 57367c478bd9Sstevel@tonic-gate /* 57377c478bd9Sstevel@tonic-gate * Problem is solved. 57387c478bd9Sstevel@tonic-gate */ 57397c478bd9Sstevel@tonic-gate break; 57407c478bd9Sstevel@tonic-gate } 57417c478bd9Sstevel@tonic-gate if (zone->zone_uniqid != uniqid) { 57427c478bd9Sstevel@tonic-gate /* 57437c478bd9Sstevel@tonic-gate * zoneid recycled 57447c478bd9Sstevel@tonic-gate */ 57457c478bd9Sstevel@tonic-gate zone_rele(zone); 57467c478bd9Sstevel@tonic-gate break; 57477c478bd9Sstevel@tonic-gate } 57487c478bd9Sstevel@tonic-gate /* 57497c478bd9Sstevel@tonic-gate * We could zone_status_timedwait(), but there doesn't seem to 57507c478bd9Sstevel@tonic-gate * be much point in doing that (plus, it would mean that 57517c478bd9Sstevel@tonic-gate * zone_free() isn't called until this thread exits). 57527c478bd9Sstevel@tonic-gate */ 57537c478bd9Sstevel@tonic-gate zone_rele(zone); 57547c478bd9Sstevel@tonic-gate delay(hz); 57557c478bd9Sstevel@tonic-gate darg = save_arg; 57567c478bd9Sstevel@tonic-gate } 57577c478bd9Sstevel@tonic-gate out: 57587c478bd9Sstevel@tonic-gate if (door != NULL) { 57597c478bd9Sstevel@tonic-gate zone_release_door(&door); 57607c478bd9Sstevel@tonic-gate } 57617c478bd9Sstevel@tonic-gate kmem_free(zone_name, zone_namelen); 57627c478bd9Sstevel@tonic-gate thread_exit(); 57637c478bd9Sstevel@tonic-gate } 57647c478bd9Sstevel@tonic-gate 57657c478bd9Sstevel@tonic-gate /* 57663f2f09c1Sdp * Entry point for uadmin() to tell the zone to go away or reboot. Analog to 57673f2f09c1Sdp * kadmin(). The caller is a process in the zone. 57687c478bd9Sstevel@tonic-gate * 57697c478bd9Sstevel@tonic-gate * In order to shutdown the zone, we will hand off control to zoneadmd 57707c478bd9Sstevel@tonic-gate * (running in the global zone) via a door. We do a half-hearted job at 57717c478bd9Sstevel@tonic-gate * killing all processes in the zone, create a kernel thread to contact 57727c478bd9Sstevel@tonic-gate * zoneadmd, and make note of the "uniqid" of the zone. The uniqid is 57737c478bd9Sstevel@tonic-gate * a form of generation number used to let zoneadmd (as well as 57747c478bd9Sstevel@tonic-gate * zone_destroy()) know exactly which zone they're re talking about. 57757c478bd9Sstevel@tonic-gate */ 57767c478bd9Sstevel@tonic-gate int 57773f2f09c1Sdp zone_kadmin(int cmd, int fcn, const char *mdep, cred_t *credp) 57787c478bd9Sstevel@tonic-gate { 57797c478bd9Sstevel@tonic-gate struct zarg *zargp; 57807c478bd9Sstevel@tonic-gate zone_cmd_t zcmd; 57817c478bd9Sstevel@tonic-gate zone_t *zone; 57827c478bd9Sstevel@tonic-gate 57837c478bd9Sstevel@tonic-gate zone = curproc->p_zone; 57847c478bd9Sstevel@tonic-gate ASSERT(getzoneid() != GLOBAL_ZONEID); 57857c478bd9Sstevel@tonic-gate 57867c478bd9Sstevel@tonic-gate switch (cmd) { 57877c478bd9Sstevel@tonic-gate case A_SHUTDOWN: 57887c478bd9Sstevel@tonic-gate switch (fcn) { 57897c478bd9Sstevel@tonic-gate case AD_HALT: 57907c478bd9Sstevel@tonic-gate case AD_POWEROFF: 57917c478bd9Sstevel@tonic-gate zcmd = Z_HALT; 57927c478bd9Sstevel@tonic-gate break; 57937c478bd9Sstevel@tonic-gate case AD_BOOT: 57947c478bd9Sstevel@tonic-gate zcmd = Z_REBOOT; 57957c478bd9Sstevel@tonic-gate break; 57967c478bd9Sstevel@tonic-gate case AD_IBOOT: 57977c478bd9Sstevel@tonic-gate case AD_SBOOT: 57987c478bd9Sstevel@tonic-gate case AD_SIBOOT: 57997c478bd9Sstevel@tonic-gate case AD_NOSYNC: 58007c478bd9Sstevel@tonic-gate return (ENOTSUP); 58017c478bd9Sstevel@tonic-gate default: 58027c478bd9Sstevel@tonic-gate return (EINVAL); 58037c478bd9Sstevel@tonic-gate } 58047c478bd9Sstevel@tonic-gate break; 58057c478bd9Sstevel@tonic-gate case A_REBOOT: 58067c478bd9Sstevel@tonic-gate zcmd = Z_REBOOT; 58077c478bd9Sstevel@tonic-gate break; 58087c478bd9Sstevel@tonic-gate case A_FTRACE: 58097c478bd9Sstevel@tonic-gate case A_REMOUNT: 58107c478bd9Sstevel@tonic-gate case A_FREEZE: 58117c478bd9Sstevel@tonic-gate case A_DUMP: 5812753a6d45SSherry Moore case A_CONFIG: 58137c478bd9Sstevel@tonic-gate return (ENOTSUP); 58147c478bd9Sstevel@tonic-gate default: 58157c478bd9Sstevel@tonic-gate ASSERT(cmd != A_SWAPCTL); /* handled by uadmin() */ 58167c478bd9Sstevel@tonic-gate return (EINVAL); 58177c478bd9Sstevel@tonic-gate } 58187c478bd9Sstevel@tonic-gate 58197c478bd9Sstevel@tonic-gate if (secpolicy_zone_admin(credp, B_FALSE)) 58207c478bd9Sstevel@tonic-gate return (EPERM); 58217c478bd9Sstevel@tonic-gate mutex_enter(&zone_status_lock); 58223f2f09c1Sdp 58237c478bd9Sstevel@tonic-gate /* 58247c478bd9Sstevel@tonic-gate * zone_status can't be ZONE_IS_EMPTY or higher since curproc 58257c478bd9Sstevel@tonic-gate * is in the zone. 58267c478bd9Sstevel@tonic-gate */ 58277c478bd9Sstevel@tonic-gate ASSERT(zone_status_get(zone) < ZONE_IS_EMPTY); 58287c478bd9Sstevel@tonic-gate if (zone_status_get(zone) > ZONE_IS_RUNNING) { 58297c478bd9Sstevel@tonic-gate /* 58307c478bd9Sstevel@tonic-gate * This zone is already on its way down. 58317c478bd9Sstevel@tonic-gate */ 58327c478bd9Sstevel@tonic-gate mutex_exit(&zone_status_lock); 58337c478bd9Sstevel@tonic-gate return (0); 58347c478bd9Sstevel@tonic-gate } 58357c478bd9Sstevel@tonic-gate /* 58367c478bd9Sstevel@tonic-gate * Prevent future zone_enter()s 58377c478bd9Sstevel@tonic-gate */ 58387c478bd9Sstevel@tonic-gate zone_status_set(zone, ZONE_IS_SHUTTING_DOWN); 58397c478bd9Sstevel@tonic-gate mutex_exit(&zone_status_lock); 58407c478bd9Sstevel@tonic-gate 58417c478bd9Sstevel@tonic-gate /* 58427c478bd9Sstevel@tonic-gate * Kill everyone now and call zoneadmd later. 58437c478bd9Sstevel@tonic-gate * zone_ki_call_zoneadmd() will do a more thorough job of this 58447c478bd9Sstevel@tonic-gate * later. 58457c478bd9Sstevel@tonic-gate */ 58467c478bd9Sstevel@tonic-gate killall(zone->zone_id); 58477c478bd9Sstevel@tonic-gate /* 58487c478bd9Sstevel@tonic-gate * Now, create the thread to contact zoneadmd and do the rest of the 58497c478bd9Sstevel@tonic-gate * work. This thread can't be created in our zone otherwise 58507c478bd9Sstevel@tonic-gate * zone_destroy() would deadlock. 58517c478bd9Sstevel@tonic-gate */ 58523f2f09c1Sdp zargp = kmem_zalloc(sizeof (*zargp), KM_SLEEP); 58537c478bd9Sstevel@tonic-gate zargp->arg.cmd = zcmd; 58547c478bd9Sstevel@tonic-gate zargp->arg.uniqid = zone->zone_uniqid; 58553f2f09c1Sdp zargp->zone = zone; 58567c478bd9Sstevel@tonic-gate (void) strcpy(zargp->arg.locale, "C"); 58573f2f09c1Sdp /* mdep was already copied in for us by uadmin */ 58583f2f09c1Sdp if (mdep != NULL) 58593f2f09c1Sdp (void) strlcpy(zargp->arg.bootbuf, mdep, 58603f2f09c1Sdp sizeof (zargp->arg.bootbuf)); 58613f2f09c1Sdp zone_hold(zone); 58627c478bd9Sstevel@tonic-gate 58637c478bd9Sstevel@tonic-gate (void) thread_create(NULL, 0, zone_ki_call_zoneadmd, zargp, 0, &p0, 58647c478bd9Sstevel@tonic-gate TS_RUN, minclsyspri); 58657c478bd9Sstevel@tonic-gate exit(CLD_EXITED, 0); 58667c478bd9Sstevel@tonic-gate 58677c478bd9Sstevel@tonic-gate return (EINVAL); 58687c478bd9Sstevel@tonic-gate } 58697c478bd9Sstevel@tonic-gate 58707c478bd9Sstevel@tonic-gate /* 58717c478bd9Sstevel@tonic-gate * Entry point so kadmin(A_SHUTDOWN, ...) can set the global zone's 58727c478bd9Sstevel@tonic-gate * status to ZONE_IS_SHUTTING_DOWN. 58738f983ab3Sjv * 58748f983ab3Sjv * This function also shuts down all running zones to ensure that they won't 58758f983ab3Sjv * fork new processes. 58767c478bd9Sstevel@tonic-gate */ 58777c478bd9Sstevel@tonic-gate void 58787c478bd9Sstevel@tonic-gate zone_shutdown_global(void) 58797c478bd9Sstevel@tonic-gate { 58808f983ab3Sjv zone_t *current_zonep; 58817c478bd9Sstevel@tonic-gate 58828f983ab3Sjv ASSERT(INGLOBALZONE(curproc)); 58838f983ab3Sjv mutex_enter(&zonehash_lock); 58847c478bd9Sstevel@tonic-gate mutex_enter(&zone_status_lock); 58858f983ab3Sjv 58868f983ab3Sjv /* Modify the global zone's status first. */ 58877c478bd9Sstevel@tonic-gate ASSERT(zone_status_get(global_zone) == ZONE_IS_RUNNING); 58887c478bd9Sstevel@tonic-gate zone_status_set(global_zone, ZONE_IS_SHUTTING_DOWN); 58898f983ab3Sjv 58908f983ab3Sjv /* 58918f983ab3Sjv * Now change the states of all running zones to ZONE_IS_SHUTTING_DOWN. 58928f983ab3Sjv * We don't mark all zones with ZONE_IS_SHUTTING_DOWN because doing so 58938f983ab3Sjv * could cause assertions to fail (e.g., assertions about a zone's 58948f983ab3Sjv * state during initialization, readying, or booting) or produce races. 58958f983ab3Sjv * We'll let threads continue to initialize and ready new zones: they'll 58968f983ab3Sjv * fail to boot the new zones when they see that the global zone is 58978f983ab3Sjv * shutting down. 58988f983ab3Sjv */ 58998f983ab3Sjv for (current_zonep = list_head(&zone_active); current_zonep != NULL; 59008f983ab3Sjv current_zonep = list_next(&zone_active, current_zonep)) { 59018f983ab3Sjv if (zone_status_get(current_zonep) == ZONE_IS_RUNNING) 59028f983ab3Sjv zone_status_set(current_zonep, ZONE_IS_SHUTTING_DOWN); 59038f983ab3Sjv } 59047c478bd9Sstevel@tonic-gate mutex_exit(&zone_status_lock); 59058f983ab3Sjv mutex_exit(&zonehash_lock); 59067c478bd9Sstevel@tonic-gate } 5907fa9e4066Sahrens 5908fa9e4066Sahrens /* 5909fa9e4066Sahrens * Returns true if the named dataset is visible in the current zone. 5910fa9e4066Sahrens * The 'write' parameter is set to 1 if the dataset is also writable. 5911fa9e4066Sahrens */ 5912fa9e4066Sahrens int 5913fa9e4066Sahrens zone_dataset_visible(const char *dataset, int *write) 5914fa9e4066Sahrens { 5915658a1dc7SSanjeev Bagewadi static int zfstype = -1; 5916fa9e4066Sahrens zone_dataset_t *zd; 5917fa9e4066Sahrens size_t len; 5918fa9e4066Sahrens zone_t *zone = curproc->p_zone; 5919658a1dc7SSanjeev Bagewadi const char *name = NULL; 5920658a1dc7SSanjeev Bagewadi vfs_t *vfsp = NULL; 5921fa9e4066Sahrens 5922fa9e4066Sahrens if (dataset[0] == '\0') 5923fa9e4066Sahrens return (0); 5924fa9e4066Sahrens 5925fa9e4066Sahrens /* 5926fa9e4066Sahrens * Walk the list once, looking for datasets which match exactly, or 5927fa9e4066Sahrens * specify a dataset underneath an exported dataset. If found, return 5928fa9e4066Sahrens * true and note that it is writable. 5929fa9e4066Sahrens */ 5930fa9e4066Sahrens for (zd = list_head(&zone->zone_datasets); zd != NULL; 5931fa9e4066Sahrens zd = list_next(&zone->zone_datasets, zd)) { 5932fa9e4066Sahrens 5933fa9e4066Sahrens len = strlen(zd->zd_dataset); 5934fa9e4066Sahrens if (strlen(dataset) >= len && 5935fa9e4066Sahrens bcmp(dataset, zd->zd_dataset, len) == 0 && 593695c9592aSmaybee (dataset[len] == '\0' || dataset[len] == '/' || 593795c9592aSmaybee dataset[len] == '@')) { 5938fa9e4066Sahrens if (write) 5939fa9e4066Sahrens *write = 1; 5940fa9e4066Sahrens return (1); 5941fa9e4066Sahrens } 5942fa9e4066Sahrens } 5943fa9e4066Sahrens 5944fa9e4066Sahrens /* 5945fa9e4066Sahrens * Walk the list a second time, searching for datasets which are parents 5946fa9e4066Sahrens * of exported datasets. These should be visible, but read-only. 5947fa9e4066Sahrens * 5948fa9e4066Sahrens * Note that we also have to support forms such as 'pool/dataset/', with 5949fa9e4066Sahrens * a trailing slash. 5950fa9e4066Sahrens */ 5951fa9e4066Sahrens for (zd = list_head(&zone->zone_datasets); zd != NULL; 5952fa9e4066Sahrens zd = list_next(&zone->zone_datasets, zd)) { 5953fa9e4066Sahrens 5954fa9e4066Sahrens len = strlen(dataset); 5955fa9e4066Sahrens if (dataset[len - 1] == '/') 5956fa9e4066Sahrens len--; /* Ignore trailing slash */ 5957fa9e4066Sahrens if (len < strlen(zd->zd_dataset) && 5958fa9e4066Sahrens bcmp(dataset, zd->zd_dataset, len) == 0 && 5959fa9e4066Sahrens zd->zd_dataset[len] == '/') { 5960fa9e4066Sahrens if (write) 5961fa9e4066Sahrens *write = 0; 5962fa9e4066Sahrens return (1); 5963fa9e4066Sahrens } 5964fa9e4066Sahrens } 5965fa9e4066Sahrens 5966658a1dc7SSanjeev Bagewadi /* 5967658a1dc7SSanjeev Bagewadi * We reach here if the given dataset is not found in the zone_dataset 5968658a1dc7SSanjeev Bagewadi * list. Check if this dataset was added as a filesystem (ie. "add fs") 5969658a1dc7SSanjeev Bagewadi * instead of delegation. For this we search for the dataset in the 5970658a1dc7SSanjeev Bagewadi * zone_vfslist of this zone. If found, return true and note that it is 5971658a1dc7SSanjeev Bagewadi * not writable. 5972658a1dc7SSanjeev Bagewadi */ 5973658a1dc7SSanjeev Bagewadi 5974658a1dc7SSanjeev Bagewadi /* 5975658a1dc7SSanjeev Bagewadi * Initialize zfstype if it is not initialized yet. 5976658a1dc7SSanjeev Bagewadi */ 5977658a1dc7SSanjeev Bagewadi if (zfstype == -1) { 5978658a1dc7SSanjeev Bagewadi struct vfssw *vswp = vfs_getvfssw("zfs"); 5979658a1dc7SSanjeev Bagewadi zfstype = vswp - vfssw; 5980658a1dc7SSanjeev Bagewadi vfs_unrefvfssw(vswp); 5981658a1dc7SSanjeev Bagewadi } 5982658a1dc7SSanjeev Bagewadi 5983658a1dc7SSanjeev Bagewadi vfs_list_read_lock(); 5984658a1dc7SSanjeev Bagewadi vfsp = zone->zone_vfslist; 5985658a1dc7SSanjeev Bagewadi do { 5986658a1dc7SSanjeev Bagewadi ASSERT(vfsp); 5987658a1dc7SSanjeev Bagewadi if (vfsp->vfs_fstype == zfstype) { 5988658a1dc7SSanjeev Bagewadi name = refstr_value(vfsp->vfs_resource); 5989658a1dc7SSanjeev Bagewadi 5990658a1dc7SSanjeev Bagewadi /* 5991658a1dc7SSanjeev Bagewadi * Check if we have an exact match. 5992658a1dc7SSanjeev Bagewadi */ 5993658a1dc7SSanjeev Bagewadi if (strcmp(dataset, name) == 0) { 5994658a1dc7SSanjeev Bagewadi vfs_list_unlock(); 5995658a1dc7SSanjeev Bagewadi if (write) 5996658a1dc7SSanjeev Bagewadi *write = 0; 5997658a1dc7SSanjeev Bagewadi return (1); 5998658a1dc7SSanjeev Bagewadi } 5999658a1dc7SSanjeev Bagewadi /* 6000658a1dc7SSanjeev Bagewadi * We need to check if we are looking for parents of 6001658a1dc7SSanjeev Bagewadi * a dataset. These should be visible, but read-only. 6002658a1dc7SSanjeev Bagewadi */ 6003658a1dc7SSanjeev Bagewadi len = strlen(dataset); 6004658a1dc7SSanjeev Bagewadi if (dataset[len - 1] == '/') 6005658a1dc7SSanjeev Bagewadi len--; 6006658a1dc7SSanjeev Bagewadi 6007658a1dc7SSanjeev Bagewadi if (len < strlen(name) && 6008658a1dc7SSanjeev Bagewadi bcmp(dataset, name, len) == 0 && name[len] == '/') { 6009658a1dc7SSanjeev Bagewadi vfs_list_unlock(); 6010658a1dc7SSanjeev Bagewadi if (write) 6011658a1dc7SSanjeev Bagewadi *write = 0; 6012658a1dc7SSanjeev Bagewadi return (1); 6013658a1dc7SSanjeev Bagewadi } 6014658a1dc7SSanjeev Bagewadi } 6015658a1dc7SSanjeev Bagewadi vfsp = vfsp->vfs_zone_next; 6016658a1dc7SSanjeev Bagewadi } while (vfsp != zone->zone_vfslist); 6017658a1dc7SSanjeev Bagewadi 6018658a1dc7SSanjeev Bagewadi vfs_list_unlock(); 6019fa9e4066Sahrens return (0); 6020fa9e4066Sahrens } 602145916cd2Sjpk 602245916cd2Sjpk /* 602345916cd2Sjpk * zone_find_by_any_path() - 602445916cd2Sjpk * 602545916cd2Sjpk * kernel-private routine similar to zone_find_by_path(), but which 602645916cd2Sjpk * effectively compares against zone paths rather than zonerootpath 602745916cd2Sjpk * (i.e., the last component of zonerootpaths, which should be "root/", 602845916cd2Sjpk * are not compared.) This is done in order to accurately identify all 602945916cd2Sjpk * paths, whether zone-visible or not, including those which are parallel 603045916cd2Sjpk * to /root/, such as /dev/, /home/, etc... 603145916cd2Sjpk * 603245916cd2Sjpk * If the specified path does not fall under any zone path then global 603345916cd2Sjpk * zone is returned. 603445916cd2Sjpk * 603545916cd2Sjpk * The treat_abs parameter indicates whether the path should be treated as 603645916cd2Sjpk * an absolute path although it does not begin with "/". (This supports 603745916cd2Sjpk * nfs mount syntax such as host:any/path.) 603845916cd2Sjpk * 603945916cd2Sjpk * The caller is responsible for zone_rele of the returned zone. 604045916cd2Sjpk */ 604145916cd2Sjpk zone_t * 604245916cd2Sjpk zone_find_by_any_path(const char *path, boolean_t treat_abs) 604345916cd2Sjpk { 604445916cd2Sjpk zone_t *zone; 604545916cd2Sjpk int path_offset = 0; 604645916cd2Sjpk 604745916cd2Sjpk if (path == NULL) { 604845916cd2Sjpk zone_hold(global_zone); 604945916cd2Sjpk return (global_zone); 605045916cd2Sjpk } 605145916cd2Sjpk 605245916cd2Sjpk if (*path != '/') { 605345916cd2Sjpk ASSERT(treat_abs); 605445916cd2Sjpk path_offset = 1; 605545916cd2Sjpk } 605645916cd2Sjpk 605745916cd2Sjpk mutex_enter(&zonehash_lock); 605845916cd2Sjpk for (zone = list_head(&zone_active); zone != NULL; 605945916cd2Sjpk zone = list_next(&zone_active, zone)) { 606045916cd2Sjpk char *c; 606145916cd2Sjpk size_t pathlen; 60620f95d722Smp char *rootpath_start; 606345916cd2Sjpk 606445916cd2Sjpk if (zone == global_zone) /* skip global zone */ 606545916cd2Sjpk continue; 606645916cd2Sjpk 606745916cd2Sjpk /* scan backwards to find start of last component */ 606845916cd2Sjpk c = zone->zone_rootpath + zone->zone_rootpathlen - 2; 606945916cd2Sjpk do { 607045916cd2Sjpk c--; 607145916cd2Sjpk } while (*c != '/'); 607245916cd2Sjpk 60730f95d722Smp pathlen = c - zone->zone_rootpath + 1 - path_offset; 60740f95d722Smp rootpath_start = (zone->zone_rootpath + path_offset); 60750f95d722Smp if (strncmp(path, rootpath_start, pathlen) == 0) 607645916cd2Sjpk break; 607745916cd2Sjpk } 607845916cd2Sjpk if (zone == NULL) 607945916cd2Sjpk zone = global_zone; 608045916cd2Sjpk zone_hold(zone); 608145916cd2Sjpk mutex_exit(&zonehash_lock); 608245916cd2Sjpk return (zone); 608345916cd2Sjpk } 6084f4b3ec61Sdh 6085f4b3ec61Sdh /* 60862b24ab6bSSebastien Roy * Finds a zone_dl_t with the given linkid in the given zone. Returns the 60872b24ab6bSSebastien Roy * zone_dl_t pointer if found, and NULL otherwise. 6088f4b3ec61Sdh */ 60892b24ab6bSSebastien Roy static zone_dl_t * 60902b24ab6bSSebastien Roy zone_find_dl(zone_t *zone, datalink_id_t linkid) 6091f4b3ec61Sdh { 60922b24ab6bSSebastien Roy zone_dl_t *zdl; 6093f4b3ec61Sdh 60942b24ab6bSSebastien Roy ASSERT(mutex_owned(&zone->zone_lock)); 60952b24ab6bSSebastien Roy for (zdl = list_head(&zone->zone_dl_list); zdl != NULL; 60962b24ab6bSSebastien Roy zdl = list_next(&zone->zone_dl_list, zdl)) { 60972b24ab6bSSebastien Roy if (zdl->zdl_id == linkid) 6098f4b3ec61Sdh break; 6099f4b3ec61Sdh } 61002b24ab6bSSebastien Roy return (zdl); 61012b24ab6bSSebastien Roy } 61022b24ab6bSSebastien Roy 61032b24ab6bSSebastien Roy static boolean_t 61042b24ab6bSSebastien Roy zone_dl_exists(zone_t *zone, datalink_id_t linkid) 61052b24ab6bSSebastien Roy { 61062b24ab6bSSebastien Roy boolean_t exists; 61072b24ab6bSSebastien Roy 61082b24ab6bSSebastien Roy mutex_enter(&zone->zone_lock); 61092b24ab6bSSebastien Roy exists = (zone_find_dl(zone, linkid) != NULL); 6110f4b3ec61Sdh mutex_exit(&zone->zone_lock); 61112b24ab6bSSebastien Roy return (exists); 6112f4b3ec61Sdh } 6113f4b3ec61Sdh 6114f4b3ec61Sdh /* 61152b24ab6bSSebastien Roy * Add an data link name for the zone. 6116f4b3ec61Sdh */ 6117f4b3ec61Sdh static int 61182b24ab6bSSebastien Roy zone_add_datalink(zoneid_t zoneid, datalink_id_t linkid) 6119f4b3ec61Sdh { 61202b24ab6bSSebastien Roy zone_dl_t *zdl; 6121f4b3ec61Sdh zone_t *zone; 6122f4b3ec61Sdh zone_t *thiszone; 6123f4b3ec61Sdh 61242b24ab6bSSebastien Roy if ((thiszone = zone_find_by_id(zoneid)) == NULL) 6125f4b3ec61Sdh return (set_errno(ENXIO)); 6126f4b3ec61Sdh 61272b24ab6bSSebastien Roy /* Verify that the datalink ID doesn't already belong to a zone. */ 6128f4b3ec61Sdh mutex_enter(&zonehash_lock); 6129f4b3ec61Sdh for (zone = list_head(&zone_active); zone != NULL; 6130f4b3ec61Sdh zone = list_next(&zone_active, zone)) { 61312b24ab6bSSebastien Roy if (zone_dl_exists(zone, linkid)) { 6132f4b3ec61Sdh mutex_exit(&zonehash_lock); 6133f4b3ec61Sdh zone_rele(thiszone); 61342b24ab6bSSebastien Roy return (set_errno((zone == thiszone) ? EEXIST : EPERM)); 6135f4b3ec61Sdh } 6136f4b3ec61Sdh } 61372b24ab6bSSebastien Roy 61382b24ab6bSSebastien Roy zdl = kmem_zalloc(sizeof (*zdl), KM_SLEEP); 61392b24ab6bSSebastien Roy zdl->zdl_id = linkid; 6140f4b3ec61Sdh mutex_enter(&thiszone->zone_lock); 61412b24ab6bSSebastien Roy list_insert_head(&thiszone->zone_dl_list, zdl); 6142f4b3ec61Sdh mutex_exit(&thiszone->zone_lock); 6143f4b3ec61Sdh mutex_exit(&zonehash_lock); 6144f4b3ec61Sdh zone_rele(thiszone); 6145f4b3ec61Sdh return (0); 6146f4b3ec61Sdh } 6147f4b3ec61Sdh 6148f4b3ec61Sdh static int 61492b24ab6bSSebastien Roy zone_remove_datalink(zoneid_t zoneid, datalink_id_t linkid) 6150f4b3ec61Sdh { 61512b24ab6bSSebastien Roy zone_dl_t *zdl; 6152f4b3ec61Sdh zone_t *zone; 61532b24ab6bSSebastien Roy int err = 0; 6154f4b3ec61Sdh 61552b24ab6bSSebastien Roy if ((zone = zone_find_by_id(zoneid)) == NULL) 6156f4b3ec61Sdh return (set_errno(EINVAL)); 6157f4b3ec61Sdh 6158f4b3ec61Sdh mutex_enter(&zone->zone_lock); 61592b24ab6bSSebastien Roy if ((zdl = zone_find_dl(zone, linkid)) == NULL) { 61602b24ab6bSSebastien Roy err = ENXIO; 61612b24ab6bSSebastien Roy } else { 61622b24ab6bSSebastien Roy list_remove(&zone->zone_dl_list, zdl); 61632b24ab6bSSebastien Roy kmem_free(zdl, sizeof (zone_dl_t)); 6164f4b3ec61Sdh } 6165f4b3ec61Sdh mutex_exit(&zone->zone_lock); 6166f4b3ec61Sdh zone_rele(zone); 61672b24ab6bSSebastien Roy return (err == 0 ? 0 : set_errno(err)); 6168f4b3ec61Sdh } 6169f4b3ec61Sdh 6170f4b3ec61Sdh /* 61712b24ab6bSSebastien Roy * Using the zoneidp as ALL_ZONES, we can lookup which zone has been assigned 61722b24ab6bSSebastien Roy * the linkid. Otherwise we just check if the specified zoneidp has been 61732b24ab6bSSebastien Roy * assigned the supplied linkid. 6174f4b3ec61Sdh */ 61752b24ab6bSSebastien Roy int 61762b24ab6bSSebastien Roy zone_check_datalink(zoneid_t *zoneidp, datalink_id_t linkid) 6177f4b3ec61Sdh { 6178f4b3ec61Sdh zone_t *zone; 61792b24ab6bSSebastien Roy int err = ENXIO; 6180f4b3ec61Sdh 61812b24ab6bSSebastien Roy if (*zoneidp != ALL_ZONES) { 61822b24ab6bSSebastien Roy if ((zone = zone_find_by_id(*zoneidp)) != NULL) { 61832b24ab6bSSebastien Roy if (zone_dl_exists(zone, linkid)) 61842b24ab6bSSebastien Roy err = 0; 61852b24ab6bSSebastien Roy zone_rele(zone); 61862b24ab6bSSebastien Roy } 61872b24ab6bSSebastien Roy return (err); 6188f4b3ec61Sdh } 6189f4b3ec61Sdh 6190f4b3ec61Sdh mutex_enter(&zonehash_lock); 6191f4b3ec61Sdh for (zone = list_head(&zone_active); zone != NULL; 6192f4b3ec61Sdh zone = list_next(&zone_active, zone)) { 61932b24ab6bSSebastien Roy if (zone_dl_exists(zone, linkid)) { 61942b24ab6bSSebastien Roy *zoneidp = zone->zone_id; 61952b24ab6bSSebastien Roy err = 0; 61962b24ab6bSSebastien Roy break; 6197f4b3ec61Sdh } 6198f4b3ec61Sdh } 6199f4b3ec61Sdh mutex_exit(&zonehash_lock); 62002b24ab6bSSebastien Roy return (err); 6201f4b3ec61Sdh } 6202f4b3ec61Sdh 6203f4b3ec61Sdh /* 62042b24ab6bSSebastien Roy * Get the list of datalink IDs assigned to a zone. 62052b24ab6bSSebastien Roy * 62062b24ab6bSSebastien Roy * On input, *nump is the number of datalink IDs that can fit in the supplied 62072b24ab6bSSebastien Roy * idarray. Upon return, *nump is either set to the number of datalink IDs 62082b24ab6bSSebastien Roy * that were placed in the array if the array was large enough, or to the 62092b24ab6bSSebastien Roy * number of datalink IDs that the function needs to place in the array if the 62102b24ab6bSSebastien Roy * array is too small. 6211f4b3ec61Sdh */ 6212f4b3ec61Sdh static int 62132b24ab6bSSebastien Roy zone_list_datalink(zoneid_t zoneid, int *nump, datalink_id_t *idarray) 6214f4b3ec61Sdh { 62152b24ab6bSSebastien Roy uint_t num, dlcount; 6216f4b3ec61Sdh zone_t *zone; 62172b24ab6bSSebastien Roy zone_dl_t *zdl; 62182b24ab6bSSebastien Roy datalink_id_t *idptr = idarray; 6219f4b3ec61Sdh 6220f4b3ec61Sdh if (copyin(nump, &dlcount, sizeof (dlcount)) != 0) 6221f4b3ec61Sdh return (set_errno(EFAULT)); 62222b24ab6bSSebastien Roy if ((zone = zone_find_by_id(zoneid)) == NULL) 6223f4b3ec61Sdh return (set_errno(ENXIO)); 6224f4b3ec61Sdh 6225f4b3ec61Sdh num = 0; 6226f4b3ec61Sdh mutex_enter(&zone->zone_lock); 62272b24ab6bSSebastien Roy for (zdl = list_head(&zone->zone_dl_list); zdl != NULL; 62282b24ab6bSSebastien Roy zdl = list_next(&zone->zone_dl_list, zdl)) { 6229f4b3ec61Sdh /* 62302b24ab6bSSebastien Roy * If the list is bigger than what the caller supplied, just 62312b24ab6bSSebastien Roy * count, don't do copyout. 6232f4b3ec61Sdh */ 6233f4b3ec61Sdh if (++num > dlcount) 6234f4b3ec61Sdh continue; 62352b24ab6bSSebastien Roy if (copyout(&zdl->zdl_id, idptr, sizeof (*idptr)) != 0) { 6236f4b3ec61Sdh mutex_exit(&zone->zone_lock); 6237f4b3ec61Sdh zone_rele(zone); 6238f4b3ec61Sdh return (set_errno(EFAULT)); 6239f4b3ec61Sdh } 62402b24ab6bSSebastien Roy idptr++; 6241f4b3ec61Sdh } 6242f4b3ec61Sdh mutex_exit(&zone->zone_lock); 6243f4b3ec61Sdh zone_rele(zone); 6244f4b3ec61Sdh 6245f4b3ec61Sdh /* Increased or decreased, caller should be notified. */ 6246f4b3ec61Sdh if (num != dlcount) { 62472b24ab6bSSebastien Roy if (copyout(&num, nump, sizeof (num)) != 0) 6248f4b3ec61Sdh return (set_errno(EFAULT)); 6249f4b3ec61Sdh } 6250f4b3ec61Sdh return (0); 6251f4b3ec61Sdh } 6252f4b3ec61Sdh 6253f4b3ec61Sdh /* 6254f4b3ec61Sdh * Public interface for looking up a zone by zoneid. It's a customized version 6255bd41d0a8Snordmark * for netstack_zone_create(). It can only be called from the zsd create 6256bd41d0a8Snordmark * callbacks, since it doesn't have reference on the zone structure hence if 6257bd41d0a8Snordmark * it is called elsewhere the zone could disappear after the zonehash_lock 6258bd41d0a8Snordmark * is dropped. 6259bd41d0a8Snordmark * 6260bd41d0a8Snordmark * Furthermore it 6261bd41d0a8Snordmark * 1. Doesn't check the status of the zone. 6262bd41d0a8Snordmark * 2. It will be called even before zone_init is called, in that case the 6263f4b3ec61Sdh * address of zone0 is returned directly, and netstack_zone_create() 6264f4b3ec61Sdh * will only assign a value to zone0.zone_netstack, won't break anything. 6265bd41d0a8Snordmark * 3. Returns without the zone being held. 6266f4b3ec61Sdh */ 6267f4b3ec61Sdh zone_t * 6268f4b3ec61Sdh zone_find_by_id_nolock(zoneid_t zoneid) 6269f4b3ec61Sdh { 6270bd41d0a8Snordmark zone_t *zone; 6271f4b3ec61Sdh 6272bd41d0a8Snordmark mutex_enter(&zonehash_lock); 6273f4b3ec61Sdh if (zonehashbyid == NULL) 6274bd41d0a8Snordmark zone = &zone0; 6275f4b3ec61Sdh else 6276bd41d0a8Snordmark zone = zone_find_all_by_id(zoneid); 6277bd41d0a8Snordmark mutex_exit(&zonehash_lock); 6278bd41d0a8Snordmark return (zone); 6279f4b3ec61Sdh } 6280d62bc4baSyz 6281d62bc4baSyz /* 6282d62bc4baSyz * Walk the datalinks for a given zone 6283d62bc4baSyz */ 6284d62bc4baSyz int 62852b24ab6bSSebastien Roy zone_datalink_walk(zoneid_t zoneid, int (*cb)(datalink_id_t, void *), 62862b24ab6bSSebastien Roy void *data) 6287d62bc4baSyz { 62882b24ab6bSSebastien Roy zone_t *zone; 62892b24ab6bSSebastien Roy zone_dl_t *zdl; 62902b24ab6bSSebastien Roy datalink_id_t *idarray; 62912b24ab6bSSebastien Roy uint_t idcount = 0; 62922b24ab6bSSebastien Roy int i, ret = 0; 6293d62bc4baSyz 6294d62bc4baSyz if ((zone = zone_find_by_id(zoneid)) == NULL) 6295d62bc4baSyz return (ENOENT); 6296d62bc4baSyz 62972b24ab6bSSebastien Roy /* 62982b24ab6bSSebastien Roy * We first build an array of linkid's so that we can walk these and 62992b24ab6bSSebastien Roy * execute the callback with the zone_lock dropped. 63002b24ab6bSSebastien Roy */ 6301d62bc4baSyz mutex_enter(&zone->zone_lock); 63022b24ab6bSSebastien Roy for (zdl = list_head(&zone->zone_dl_list); zdl != NULL; 63032b24ab6bSSebastien Roy zdl = list_next(&zone->zone_dl_list, zdl)) { 63042b24ab6bSSebastien Roy idcount++; 6305d62bc4baSyz } 63062b24ab6bSSebastien Roy 63072b24ab6bSSebastien Roy if (idcount == 0) { 63082b24ab6bSSebastien Roy mutex_exit(&zone->zone_lock); 63092b24ab6bSSebastien Roy zone_rele(zone); 63102b24ab6bSSebastien Roy return (0); 63112b24ab6bSSebastien Roy } 63122b24ab6bSSebastien Roy 63132b24ab6bSSebastien Roy idarray = kmem_alloc(sizeof (datalink_id_t) * idcount, KM_NOSLEEP); 63142b24ab6bSSebastien Roy if (idarray == NULL) { 63152b24ab6bSSebastien Roy mutex_exit(&zone->zone_lock); 63162b24ab6bSSebastien Roy zone_rele(zone); 63172b24ab6bSSebastien Roy return (ENOMEM); 63182b24ab6bSSebastien Roy } 63192b24ab6bSSebastien Roy 63202b24ab6bSSebastien Roy for (i = 0, zdl = list_head(&zone->zone_dl_list); zdl != NULL; 63212b24ab6bSSebastien Roy i++, zdl = list_next(&zone->zone_dl_list, zdl)) { 63222b24ab6bSSebastien Roy idarray[i] = zdl->zdl_id; 63232b24ab6bSSebastien Roy } 63242b24ab6bSSebastien Roy 6325d62bc4baSyz mutex_exit(&zone->zone_lock); 63262b24ab6bSSebastien Roy 63272b24ab6bSSebastien Roy for (i = 0; i < idcount && ret == 0; i++) { 63282b24ab6bSSebastien Roy if ((ret = (*cb)(idarray[i], data)) != 0) 63292b24ab6bSSebastien Roy break; 63302b24ab6bSSebastien Roy } 63312b24ab6bSSebastien Roy 6332d62bc4baSyz zone_rele(zone); 63332b24ab6bSSebastien Roy kmem_free(idarray, sizeof (datalink_id_t) * idcount); 6334d62bc4baSyz return (ret); 6335d62bc4baSyz } 6336