xref: /illumos-gate/usr/src/uts/common/os/zone.c (revision 821c4a97)
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
57c478bd9Sstevel@tonic-gate  * Common Development and Distribution License, Version 1.0 only
67c478bd9Sstevel@tonic-gate  * (the "License").  You may not use this file except in compliance
77c478bd9Sstevel@tonic-gate  * with the License.
87c478bd9Sstevel@tonic-gate  *
97c478bd9Sstevel@tonic-gate  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
107c478bd9Sstevel@tonic-gate  * or http://www.opensolaris.org/os/licensing.
117c478bd9Sstevel@tonic-gate  * See the License for the specific language governing permissions
127c478bd9Sstevel@tonic-gate  * and limitations under the License.
137c478bd9Sstevel@tonic-gate  *
147c478bd9Sstevel@tonic-gate  * When distributing Covered Code, include this CDDL HEADER in each
157c478bd9Sstevel@tonic-gate  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
167c478bd9Sstevel@tonic-gate  * If applicable, add the following below this CDDL HEADER, with the
177c478bd9Sstevel@tonic-gate  * fields enclosed by brackets "[]" replaced with your own identifying
187c478bd9Sstevel@tonic-gate  * information: Portions Copyright [yyyy] [name of copyright owner]
197c478bd9Sstevel@tonic-gate  *
207c478bd9Sstevel@tonic-gate  * CDDL HEADER END
217c478bd9Sstevel@tonic-gate  */
2297eda132Sraf 
237c478bd9Sstevel@tonic-gate /*
247c478bd9Sstevel@tonic-gate  * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
257c478bd9Sstevel@tonic-gate  * Use is subject to license terms.
267c478bd9Sstevel@tonic-gate  */
277c478bd9Sstevel@tonic-gate 
287c478bd9Sstevel@tonic-gate #pragma ident	"%Z%%M%	%I%	%E% SMI"
297c478bd9Sstevel@tonic-gate 
307c478bd9Sstevel@tonic-gate /*
317c478bd9Sstevel@tonic-gate  * Zones
327c478bd9Sstevel@tonic-gate  *
337c478bd9Sstevel@tonic-gate  *   A zone is a named collection of processes, namespace constraints,
347c478bd9Sstevel@tonic-gate  *   and other system resources which comprise a secure and manageable
357c478bd9Sstevel@tonic-gate  *   application containment facility.
367c478bd9Sstevel@tonic-gate  *
377c478bd9Sstevel@tonic-gate  *   Zones (represented by the reference counted zone_t) are tracked in
387c478bd9Sstevel@tonic-gate  *   the kernel in the zonehash.  Elsewhere in the kernel, Zone IDs
397c478bd9Sstevel@tonic-gate  *   (zoneid_t) are used to track zone association.  Zone IDs are
407c478bd9Sstevel@tonic-gate  *   dynamically generated when the zone is created; if a persistent
417c478bd9Sstevel@tonic-gate  *   identifier is needed (core files, accounting logs, audit trail,
427c478bd9Sstevel@tonic-gate  *   etc.), the zone name should be used.
437c478bd9Sstevel@tonic-gate  *
447c478bd9Sstevel@tonic-gate  *
457c478bd9Sstevel@tonic-gate  *   Global Zone:
467c478bd9Sstevel@tonic-gate  *
477c478bd9Sstevel@tonic-gate  *   The global zone (zoneid 0) is automatically associated with all
487c478bd9Sstevel@tonic-gate  *   system resources that have not been bound to a user-created zone.
497c478bd9Sstevel@tonic-gate  *   This means that even systems where zones are not in active use
507c478bd9Sstevel@tonic-gate  *   have a global zone, and all processes, mounts, etc. are
517c478bd9Sstevel@tonic-gate  *   associated with that zone.  The global zone is generally
527c478bd9Sstevel@tonic-gate  *   unconstrained in terms of privileges and access, though the usual
537c478bd9Sstevel@tonic-gate  *   credential and privilege based restrictions apply.
547c478bd9Sstevel@tonic-gate  *
557c478bd9Sstevel@tonic-gate  *
567c478bd9Sstevel@tonic-gate  *   Zone States:
577c478bd9Sstevel@tonic-gate  *
587c478bd9Sstevel@tonic-gate  *   The states in which a zone may be in and the transitions are as
597c478bd9Sstevel@tonic-gate  *   follows:
607c478bd9Sstevel@tonic-gate  *
617c478bd9Sstevel@tonic-gate  *   ZONE_IS_UNINITIALIZED: primordial state for a zone. The partially
627c478bd9Sstevel@tonic-gate  *   initialized zone is added to the list of active zones on the system but
637c478bd9Sstevel@tonic-gate  *   isn't accessible.
647c478bd9Sstevel@tonic-gate  *
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.
1587c478bd9Sstevel@tonic-gate  *   zsd_key_lock: This is a global lock protecting the key state for ZSD.
1597c478bd9Sstevel@tonic-gate  *   zone_deathrow_lock: This is a global lock protecting the "deathrow"
1607c478bd9Sstevel@tonic-gate  *       list (a list of zones in the ZONE_IS_DEAD state).
1617c478bd9Sstevel@tonic-gate  *
1627c478bd9Sstevel@tonic-gate  *   Ordering requirements:
1637c478bd9Sstevel@tonic-gate  *       pool_lock --> cpu_lock --> zonehash_lock --> zone_status_lock -->
1647c478bd9Sstevel@tonic-gate  *       	zone_lock --> zsd_key_lock --> pidlock --> p_lock
1657c478bd9Sstevel@tonic-gate  *
1667c478bd9Sstevel@tonic-gate  *   Blocking memory allocations are permitted while holding any of the
1677c478bd9Sstevel@tonic-gate  *   zone locks.
1687c478bd9Sstevel@tonic-gate  *
1697c478bd9Sstevel@tonic-gate  *
1707c478bd9Sstevel@tonic-gate  *   System Call Interface:
1717c478bd9Sstevel@tonic-gate  *
1727c478bd9Sstevel@tonic-gate  *   The zone subsystem can be managed and queried from user level with
1737c478bd9Sstevel@tonic-gate  *   the following system calls (all subcodes of the primary "zone"
1747c478bd9Sstevel@tonic-gate  *   system call):
1757c478bd9Sstevel@tonic-gate  *   - zone_create: creates a zone with selected attributes (name,
176fa9e4066Sahrens  *     root path, privileges, resource controls, ZFS datasets)
1777c478bd9Sstevel@tonic-gate  *   - zone_enter: allows the current process to enter a zone
1787c478bd9Sstevel@tonic-gate  *   - zone_getattr: reports attributes of a zone
1797c478bd9Sstevel@tonic-gate  *   - zone_list: lists all zones active in the system
1807c478bd9Sstevel@tonic-gate  *   - zone_lookup: looks up zone id based on name
1817c478bd9Sstevel@tonic-gate  *   - zone_shutdown: initiates shutdown process (see states above)
1827c478bd9Sstevel@tonic-gate  *   - zone_destroy: completes shutdown process (see states above)
1837c478bd9Sstevel@tonic-gate  *
1847c478bd9Sstevel@tonic-gate  */
1857c478bd9Sstevel@tonic-gate 
1867c478bd9Sstevel@tonic-gate #include <sys/priv_impl.h>
1877c478bd9Sstevel@tonic-gate #include <sys/cred.h>
1887c478bd9Sstevel@tonic-gate #include <c2/audit.h>
1897c478bd9Sstevel@tonic-gate #include <sys/ddi.h>
1907c478bd9Sstevel@tonic-gate #include <sys/debug.h>
1917c478bd9Sstevel@tonic-gate #include <sys/file.h>
1927c478bd9Sstevel@tonic-gate #include <sys/kmem.h>
1937c478bd9Sstevel@tonic-gate #include <sys/mutex.h>
1947c478bd9Sstevel@tonic-gate #include <sys/pathname.h>
1957c478bd9Sstevel@tonic-gate #include <sys/proc.h>
1967c478bd9Sstevel@tonic-gate #include <sys/project.h>
1977c478bd9Sstevel@tonic-gate #include <sys/task.h>
1987c478bd9Sstevel@tonic-gate #include <sys/systm.h>
1997c478bd9Sstevel@tonic-gate #include <sys/types.h>
2007c478bd9Sstevel@tonic-gate #include <sys/utsname.h>
2017c478bd9Sstevel@tonic-gate #include <sys/vnode.h>
2027c478bd9Sstevel@tonic-gate #include <sys/vfs.h>
2037c478bd9Sstevel@tonic-gate #include <sys/systeminfo.h>
2047c478bd9Sstevel@tonic-gate #include <sys/policy.h>
2057c478bd9Sstevel@tonic-gate #include <sys/cred_impl.h>
2067c478bd9Sstevel@tonic-gate #include <sys/contract_impl.h>
2077c478bd9Sstevel@tonic-gate #include <sys/contract/process_impl.h>
2087c478bd9Sstevel@tonic-gate #include <sys/class.h>
2097c478bd9Sstevel@tonic-gate #include <sys/pool.h>
2107c478bd9Sstevel@tonic-gate #include <sys/pool_pset.h>
2117c478bd9Sstevel@tonic-gate #include <sys/pset.h>
2127c478bd9Sstevel@tonic-gate #include <sys/log.h>
2137c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h>
2147c478bd9Sstevel@tonic-gate #include <sys/callb.h>
2157c478bd9Sstevel@tonic-gate #include <sys/vmparam.h>
2167c478bd9Sstevel@tonic-gate #include <sys/corectl.h>
2177c478bd9Sstevel@tonic-gate 
2187c478bd9Sstevel@tonic-gate #include <sys/door.h>
2197c478bd9Sstevel@tonic-gate #include <sys/cpuvar.h>
2207c478bd9Sstevel@tonic-gate #include <sys/fs/snode.h>
2217c478bd9Sstevel@tonic-gate 
2227c478bd9Sstevel@tonic-gate #include <sys/uadmin.h>
2237c478bd9Sstevel@tonic-gate #include <sys/session.h>
2247c478bd9Sstevel@tonic-gate #include <sys/cmn_err.h>
2257c478bd9Sstevel@tonic-gate #include <sys/modhash.h>
2267c478bd9Sstevel@tonic-gate #include <sys/nvpair.h>
2277c478bd9Sstevel@tonic-gate #include <sys/rctl.h>
2287c478bd9Sstevel@tonic-gate #include <sys/fss.h>
2297c478bd9Sstevel@tonic-gate #include <sys/zone.h>
2307c478bd9Sstevel@tonic-gate 
2317c478bd9Sstevel@tonic-gate /*
2327c478bd9Sstevel@tonic-gate  * cv used to signal that all references to the zone have been released.  This
2337c478bd9Sstevel@tonic-gate  * needs to be global since there may be multiple waiters, and the first to
2347c478bd9Sstevel@tonic-gate  * wake up will free the zone_t, hence we cannot use zone->zone_cv.
2357c478bd9Sstevel@tonic-gate  */
2367c478bd9Sstevel@tonic-gate static kcondvar_t zone_destroy_cv;
2377c478bd9Sstevel@tonic-gate /*
2387c478bd9Sstevel@tonic-gate  * Lock used to serialize access to zone_cv.  This could have been per-zone,
2397c478bd9Sstevel@tonic-gate  * but then we'd need another lock for zone_destroy_cv, and why bother?
2407c478bd9Sstevel@tonic-gate  */
2417c478bd9Sstevel@tonic-gate static kmutex_t zone_status_lock;
2427c478bd9Sstevel@tonic-gate 
2437c478bd9Sstevel@tonic-gate /*
2447c478bd9Sstevel@tonic-gate  * ZSD-related global variables.
2457c478bd9Sstevel@tonic-gate  */
2467c478bd9Sstevel@tonic-gate static kmutex_t zsd_key_lock;	/* protects the following two */
2477c478bd9Sstevel@tonic-gate /*
2487c478bd9Sstevel@tonic-gate  * The next caller of zone_key_create() will be assigned a key of ++zsd_keyval.
2497c478bd9Sstevel@tonic-gate  */
2507c478bd9Sstevel@tonic-gate static zone_key_t zsd_keyval = 0;
2517c478bd9Sstevel@tonic-gate /*
2527c478bd9Sstevel@tonic-gate  * Global list of registered keys.  We use this when a new zone is created.
2537c478bd9Sstevel@tonic-gate  */
2547c478bd9Sstevel@tonic-gate static list_t zsd_registered_keys;
2557c478bd9Sstevel@tonic-gate 
2567c478bd9Sstevel@tonic-gate int zone_hash_size = 256;
2577c478bd9Sstevel@tonic-gate static mod_hash_t *zonehashbyname, *zonehashbyid;
2587c478bd9Sstevel@tonic-gate static kmutex_t zonehash_lock;
2597c478bd9Sstevel@tonic-gate static uint_t zonecount;
2607c478bd9Sstevel@tonic-gate static id_space_t *zoneid_space;
2617c478bd9Sstevel@tonic-gate 
2627c478bd9Sstevel@tonic-gate /*
2637c478bd9Sstevel@tonic-gate  * The global zone (aka zone0) is the all-seeing, all-knowing zone in which the
2647c478bd9Sstevel@tonic-gate  * kernel proper runs, and which manages all other zones.
2657c478bd9Sstevel@tonic-gate  *
2667c478bd9Sstevel@tonic-gate  * Although not declared as static, the variable "zone0" should not be used
2677c478bd9Sstevel@tonic-gate  * except for by code that needs to reference the global zone early on in boot,
2687c478bd9Sstevel@tonic-gate  * before it is fully initialized.  All other consumers should use
2697c478bd9Sstevel@tonic-gate  * 'global_zone'.
2707c478bd9Sstevel@tonic-gate  */
2717c478bd9Sstevel@tonic-gate zone_t zone0;
2727c478bd9Sstevel@tonic-gate zone_t *global_zone = NULL;	/* Set when the global zone is initialized */
2737c478bd9Sstevel@tonic-gate 
2747c478bd9Sstevel@tonic-gate /*
2757c478bd9Sstevel@tonic-gate  * List of active zones, protected by zonehash_lock.
2767c478bd9Sstevel@tonic-gate  */
2777c478bd9Sstevel@tonic-gate static list_t zone_active;
2787c478bd9Sstevel@tonic-gate 
2797c478bd9Sstevel@tonic-gate /*
2807c478bd9Sstevel@tonic-gate  * List of destroyed zones that still have outstanding cred references.
2817c478bd9Sstevel@tonic-gate  * Used for debugging.  Uses a separate lock to avoid lock ordering
2827c478bd9Sstevel@tonic-gate  * problems in zone_free.
2837c478bd9Sstevel@tonic-gate  */
2847c478bd9Sstevel@tonic-gate static list_t zone_deathrow;
2857c478bd9Sstevel@tonic-gate static kmutex_t zone_deathrow_lock;
2867c478bd9Sstevel@tonic-gate 
2877c478bd9Sstevel@tonic-gate /* number of zones is limited by virtual interface limit in IP */
2887c478bd9Sstevel@tonic-gate uint_t maxzones = 8192;
2897c478bd9Sstevel@tonic-gate 
2907c478bd9Sstevel@tonic-gate /*
2917c478bd9Sstevel@tonic-gate  * This isn't static so lint doesn't complain.
2927c478bd9Sstevel@tonic-gate  */
2937c478bd9Sstevel@tonic-gate rctl_hndl_t rc_zone_cpu_shares;
2947c478bd9Sstevel@tonic-gate rctl_hndl_t rc_zone_nlwps;
2957c478bd9Sstevel@tonic-gate /*
2967c478bd9Sstevel@tonic-gate  * Synchronization primitives used to synchronize between mounts and zone
2977c478bd9Sstevel@tonic-gate  * creation/destruction.
2987c478bd9Sstevel@tonic-gate  */
2997c478bd9Sstevel@tonic-gate static int mounts_in_progress;
3007c478bd9Sstevel@tonic-gate static kcondvar_t mount_cv;
3017c478bd9Sstevel@tonic-gate static kmutex_t mount_lock;
3027c478bd9Sstevel@tonic-gate 
3037c478bd9Sstevel@tonic-gate const char * const zone_initname = "/sbin/init";
3047c478bd9Sstevel@tonic-gate 
3057c478bd9Sstevel@tonic-gate static int zone_shutdown(zoneid_t zoneid);
3067c478bd9Sstevel@tonic-gate 
307*821c4a97Sdp /*
308*821c4a97Sdp  * Bump this number when you alter the zone syscall interfaces; this is
309*821c4a97Sdp  * because we need to have support for previous API versions in libc
310*821c4a97Sdp  * to support patching; libc calls into the kernel to determine this number.
311*821c4a97Sdp  *
312*821c4a97Sdp  * Version 1 of the API is the version originally shipped with Solaris 10
313*821c4a97Sdp  * Version 2 alters the zone_create system call in order to support more
314*821c4a97Sdp  *     arguments by moving the args into a structure; and to do better
315*821c4a97Sdp  *     error reporting when zone_create() fails.
316*821c4a97Sdp  * Version 3 alters the zone_create system call in order to support the
317*821c4a97Sdp  *     import of ZFS datasets to zones.
318*821c4a97Sdp  */
319*821c4a97Sdp static const int ZONE_SYSCALL_API_VERSION = 3;
320*821c4a97Sdp 
3217c478bd9Sstevel@tonic-gate /*
3227c478bd9Sstevel@tonic-gate  * Certain filesystems (such as NFS and autofs) need to know which zone
3237c478bd9Sstevel@tonic-gate  * the mount is being placed in.  Because of this, we need to be able to
3247c478bd9Sstevel@tonic-gate  * ensure that a zone isn't in the process of being created such that
3257c478bd9Sstevel@tonic-gate  * nfs_mount() thinks it is in the global zone, while by the time it
3267c478bd9Sstevel@tonic-gate  * gets added the list of mounted zones, it ends up on zoneA's mount
3277c478bd9Sstevel@tonic-gate  * list.
3287c478bd9Sstevel@tonic-gate  *
3297c478bd9Sstevel@tonic-gate  * The following functions: block_mounts()/resume_mounts() and
3307c478bd9Sstevel@tonic-gate  * mount_in_progress()/mount_completed() are used by zones and the VFS
3317c478bd9Sstevel@tonic-gate  * layer (respectively) to synchronize zone creation and new mounts.
3327c478bd9Sstevel@tonic-gate  *
3337c478bd9Sstevel@tonic-gate  * The semantics are like a reader-reader lock such that there may
3347c478bd9Sstevel@tonic-gate  * either be multiple mounts (or zone creations, if that weren't
3357c478bd9Sstevel@tonic-gate  * serialized by zonehash_lock) in progress at the same time, but not
3367c478bd9Sstevel@tonic-gate  * both.
3377c478bd9Sstevel@tonic-gate  *
3387c478bd9Sstevel@tonic-gate  * We use cv's so the user can ctrl-C out of the operation if it's
3397c478bd9Sstevel@tonic-gate  * taking too long.
3407c478bd9Sstevel@tonic-gate  *
3417c478bd9Sstevel@tonic-gate  * The semantics are such that there is unfair bias towards the
3427c478bd9Sstevel@tonic-gate  * "current" operation.  This means that zone creations may starve if
3437c478bd9Sstevel@tonic-gate  * there is a rapid succession of new mounts coming in to the system, or
3447c478bd9Sstevel@tonic-gate  * there is a remote possibility that zones will be created at such a
3457c478bd9Sstevel@tonic-gate  * rate that new mounts will not be able to proceed.
3467c478bd9Sstevel@tonic-gate  */
3477c478bd9Sstevel@tonic-gate /*
3487c478bd9Sstevel@tonic-gate  * Prevent new mounts from progressing to the point of calling
3497c478bd9Sstevel@tonic-gate  * VFS_MOUNT().  If there are already mounts in this "region", wait for
3507c478bd9Sstevel@tonic-gate  * them to complete.
3517c478bd9Sstevel@tonic-gate  */
3527c478bd9Sstevel@tonic-gate static int
3537c478bd9Sstevel@tonic-gate block_mounts(void)
3547c478bd9Sstevel@tonic-gate {
3557c478bd9Sstevel@tonic-gate 	int retval = 0;
3567c478bd9Sstevel@tonic-gate 
3577c478bd9Sstevel@tonic-gate 	/*
3587c478bd9Sstevel@tonic-gate 	 * Since it may block for a long time, block_mounts() shouldn't be
3597c478bd9Sstevel@tonic-gate 	 * called with zonehash_lock held.
3607c478bd9Sstevel@tonic-gate 	 */
3617c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_NOT_HELD(&zonehash_lock));
3627c478bd9Sstevel@tonic-gate 	mutex_enter(&mount_lock);
3637c478bd9Sstevel@tonic-gate 	while (mounts_in_progress > 0) {
3647c478bd9Sstevel@tonic-gate 		if (cv_wait_sig(&mount_cv, &mount_lock) == 0)
3657c478bd9Sstevel@tonic-gate 			goto signaled;
3667c478bd9Sstevel@tonic-gate 	}
3677c478bd9Sstevel@tonic-gate 	/*
3687c478bd9Sstevel@tonic-gate 	 * A negative value of mounts_in_progress indicates that mounts
3697c478bd9Sstevel@tonic-gate 	 * have been blocked by (-mounts_in_progress) different callers.
3707c478bd9Sstevel@tonic-gate 	 */
3717c478bd9Sstevel@tonic-gate 	mounts_in_progress--;
3727c478bd9Sstevel@tonic-gate 	retval = 1;
3737c478bd9Sstevel@tonic-gate signaled:
3747c478bd9Sstevel@tonic-gate 	mutex_exit(&mount_lock);
3757c478bd9Sstevel@tonic-gate 	return (retval);
3767c478bd9Sstevel@tonic-gate }
3777c478bd9Sstevel@tonic-gate 
3787c478bd9Sstevel@tonic-gate /*
3797c478bd9Sstevel@tonic-gate  * The VFS layer may progress with new mounts as far as we're concerned.
3807c478bd9Sstevel@tonic-gate  * Allow them to progress if we were the last obstacle.
3817c478bd9Sstevel@tonic-gate  */
3827c478bd9Sstevel@tonic-gate static void
3837c478bd9Sstevel@tonic-gate resume_mounts(void)
3847c478bd9Sstevel@tonic-gate {
3857c478bd9Sstevel@tonic-gate 	mutex_enter(&mount_lock);
3867c478bd9Sstevel@tonic-gate 	if (++mounts_in_progress == 0)
3877c478bd9Sstevel@tonic-gate 		cv_broadcast(&mount_cv);
3887c478bd9Sstevel@tonic-gate 	mutex_exit(&mount_lock);
3897c478bd9Sstevel@tonic-gate }
3907c478bd9Sstevel@tonic-gate 
3917c478bd9Sstevel@tonic-gate /*
3927c478bd9Sstevel@tonic-gate  * The VFS layer is busy with a mount; zones should wait until all
3937c478bd9Sstevel@tonic-gate  * mounts are completed to progress.
3947c478bd9Sstevel@tonic-gate  */
3957c478bd9Sstevel@tonic-gate void
3967c478bd9Sstevel@tonic-gate mount_in_progress(void)
3977c478bd9Sstevel@tonic-gate {
3987c478bd9Sstevel@tonic-gate 	mutex_enter(&mount_lock);
3997c478bd9Sstevel@tonic-gate 	while (mounts_in_progress < 0)
4007c478bd9Sstevel@tonic-gate 		cv_wait(&mount_cv, &mount_lock);
4017c478bd9Sstevel@tonic-gate 	mounts_in_progress++;
4027c478bd9Sstevel@tonic-gate 	mutex_exit(&mount_lock);
4037c478bd9Sstevel@tonic-gate }
4047c478bd9Sstevel@tonic-gate 
4057c478bd9Sstevel@tonic-gate /*
4067c478bd9Sstevel@tonic-gate  * VFS is done with one mount; wake up any waiting block_mounts()
4077c478bd9Sstevel@tonic-gate  * callers if this is the last mount.
4087c478bd9Sstevel@tonic-gate  */
4097c478bd9Sstevel@tonic-gate void
4107c478bd9Sstevel@tonic-gate mount_completed(void)
4117c478bd9Sstevel@tonic-gate {
4127c478bd9Sstevel@tonic-gate 	mutex_enter(&mount_lock);
4137c478bd9Sstevel@tonic-gate 	if (--mounts_in_progress == 0)
4147c478bd9Sstevel@tonic-gate 		cv_broadcast(&mount_cv);
4157c478bd9Sstevel@tonic-gate 	mutex_exit(&mount_lock);
4167c478bd9Sstevel@tonic-gate }
4177c478bd9Sstevel@tonic-gate 
4187c478bd9Sstevel@tonic-gate /*
4197c478bd9Sstevel@tonic-gate  * ZSD routines.
4207c478bd9Sstevel@tonic-gate  *
4217c478bd9Sstevel@tonic-gate  * Zone Specific Data (ZSD) is modeled after Thread Specific Data as
4227c478bd9Sstevel@tonic-gate  * defined by the pthread_key_create() and related interfaces.
4237c478bd9Sstevel@tonic-gate  *
4247c478bd9Sstevel@tonic-gate  * Kernel subsystems may register one or more data items and/or
4257c478bd9Sstevel@tonic-gate  * callbacks to be executed when a zone is created, shutdown, or
4267c478bd9Sstevel@tonic-gate  * destroyed.
4277c478bd9Sstevel@tonic-gate  *
4287c478bd9Sstevel@tonic-gate  * Unlike the thread counterpart, destructor callbacks will be executed
4297c478bd9Sstevel@tonic-gate  * even if the data pointer is NULL and/or there are no constructor
4307c478bd9Sstevel@tonic-gate  * callbacks, so it is the responsibility of such callbacks to check for
4317c478bd9Sstevel@tonic-gate  * NULL data values if necessary.
4327c478bd9Sstevel@tonic-gate  *
4337c478bd9Sstevel@tonic-gate  * The locking strategy and overall picture is as follows:
4347c478bd9Sstevel@tonic-gate  *
4357c478bd9Sstevel@tonic-gate  * When someone calls zone_key_create(), a template ZSD entry is added to the
4367c478bd9Sstevel@tonic-gate  * global list "zsd_registered_keys", protected by zsd_key_lock.  The
4377c478bd9Sstevel@tonic-gate  * constructor callback is called immediately on all existing zones, and a
4387c478bd9Sstevel@tonic-gate  * copy of the ZSD entry added to the per-zone zone_zsd list (protected by
4397c478bd9Sstevel@tonic-gate  * zone_lock).  As this operation requires the list of zones, the list of
4407c478bd9Sstevel@tonic-gate  * registered keys, and the per-zone list of ZSD entries to remain constant
4417c478bd9Sstevel@tonic-gate  * throughout the entire operation, it must grab zonehash_lock, zone_lock for
4427c478bd9Sstevel@tonic-gate  * all existing zones, and zsd_key_lock, in that order.  Similar locking is
4437c478bd9Sstevel@tonic-gate  * needed when zone_key_delete() is called.  It is thus sufficient to hold
4447c478bd9Sstevel@tonic-gate  * zsd_key_lock *or* zone_lock to prevent additions to or removals from the
4457c478bd9Sstevel@tonic-gate  * per-zone zone_zsd list.
4467c478bd9Sstevel@tonic-gate  *
4477c478bd9Sstevel@tonic-gate  * Note that this implementation does not make a copy of the ZSD entry if a
4487c478bd9Sstevel@tonic-gate  * constructor callback is not provided.  A zone_getspecific() on such an
4497c478bd9Sstevel@tonic-gate  * uninitialized ZSD entry will return NULL.
4507c478bd9Sstevel@tonic-gate  *
4517c478bd9Sstevel@tonic-gate  * When new zones are created constructor callbacks for all registered ZSD
4527c478bd9Sstevel@tonic-gate  * entries will be called.
4537c478bd9Sstevel@tonic-gate  *
4547c478bd9Sstevel@tonic-gate  * The framework does not provide any locking around zone_getspecific() and
4557c478bd9Sstevel@tonic-gate  * zone_setspecific() apart from that needed for internal consistency, so
4567c478bd9Sstevel@tonic-gate  * callers interested in atomic "test-and-set" semantics will need to provide
4577c478bd9Sstevel@tonic-gate  * their own locking.
4587c478bd9Sstevel@tonic-gate  */
4597c478bd9Sstevel@tonic-gate void
4607c478bd9Sstevel@tonic-gate zone_key_create(zone_key_t *keyp, void *(*create)(zoneid_t),
4617c478bd9Sstevel@tonic-gate     void (*shutdown)(zoneid_t, void *), void (*destroy)(zoneid_t, void *))
4627c478bd9Sstevel@tonic-gate {
4637c478bd9Sstevel@tonic-gate 	struct zsd_entry *zsdp;
4647c478bd9Sstevel@tonic-gate 	struct zsd_entry *t;
4657c478bd9Sstevel@tonic-gate 	struct zone *zone;
4667c478bd9Sstevel@tonic-gate 
4677c478bd9Sstevel@tonic-gate 	zsdp = kmem_alloc(sizeof (*zsdp), KM_SLEEP);
4687c478bd9Sstevel@tonic-gate 	zsdp->zsd_data = NULL;
4697c478bd9Sstevel@tonic-gate 	zsdp->zsd_create = create;
4707c478bd9Sstevel@tonic-gate 	zsdp->zsd_shutdown = shutdown;
4717c478bd9Sstevel@tonic-gate 	zsdp->zsd_destroy = destroy;
4727c478bd9Sstevel@tonic-gate 
4737c478bd9Sstevel@tonic-gate 	mutex_enter(&zonehash_lock);	/* stop the world */
4747c478bd9Sstevel@tonic-gate 	for (zone = list_head(&zone_active); zone != NULL;
4757c478bd9Sstevel@tonic-gate 	    zone = list_next(&zone_active, zone))
4767c478bd9Sstevel@tonic-gate 		mutex_enter(&zone->zone_lock);	/* lock all zones */
4777c478bd9Sstevel@tonic-gate 
4787c478bd9Sstevel@tonic-gate 	mutex_enter(&zsd_key_lock);
4797c478bd9Sstevel@tonic-gate 	*keyp = zsdp->zsd_key = ++zsd_keyval;
4807c478bd9Sstevel@tonic-gate 	ASSERT(zsd_keyval != 0);
4817c478bd9Sstevel@tonic-gate 	list_insert_tail(&zsd_registered_keys, zsdp);
4827c478bd9Sstevel@tonic-gate 	mutex_exit(&zsd_key_lock);
4837c478bd9Sstevel@tonic-gate 
4847c478bd9Sstevel@tonic-gate 	if (create != NULL) {
4857c478bd9Sstevel@tonic-gate 		for (zone = list_head(&zone_active); zone != NULL;
4867c478bd9Sstevel@tonic-gate 		    zone = list_next(&zone_active, zone)) {
4877c478bd9Sstevel@tonic-gate 			t = kmem_alloc(sizeof (*t), KM_SLEEP);
4887c478bd9Sstevel@tonic-gate 			t->zsd_key = *keyp;
4897c478bd9Sstevel@tonic-gate 			t->zsd_data = (*create)(zone->zone_id);
4907c478bd9Sstevel@tonic-gate 			t->zsd_create = create;
4917c478bd9Sstevel@tonic-gate 			t->zsd_shutdown = shutdown;
4927c478bd9Sstevel@tonic-gate 			t->zsd_destroy = destroy;
4937c478bd9Sstevel@tonic-gate 			list_insert_tail(&zone->zone_zsd, t);
4947c478bd9Sstevel@tonic-gate 		}
4957c478bd9Sstevel@tonic-gate 	}
4967c478bd9Sstevel@tonic-gate 	for (zone = list_head(&zone_active); zone != NULL;
4977c478bd9Sstevel@tonic-gate 	    zone = list_next(&zone_active, zone))
4987c478bd9Sstevel@tonic-gate 		mutex_exit(&zone->zone_lock);
4997c478bd9Sstevel@tonic-gate 	mutex_exit(&zonehash_lock);
5007c478bd9Sstevel@tonic-gate }
5017c478bd9Sstevel@tonic-gate 
5027c478bd9Sstevel@tonic-gate /*
5037c478bd9Sstevel@tonic-gate  * Helper function to find the zsd_entry associated with the key in the
5047c478bd9Sstevel@tonic-gate  * given list.
5057c478bd9Sstevel@tonic-gate  */
5067c478bd9Sstevel@tonic-gate static struct zsd_entry *
5077c478bd9Sstevel@tonic-gate zsd_find(list_t *l, zone_key_t key)
5087c478bd9Sstevel@tonic-gate {
5097c478bd9Sstevel@tonic-gate 	struct zsd_entry *zsd;
5107c478bd9Sstevel@tonic-gate 
5117c478bd9Sstevel@tonic-gate 	for (zsd = list_head(l); zsd != NULL; zsd = list_next(l, zsd)) {
5127c478bd9Sstevel@tonic-gate 		if (zsd->zsd_key == key) {
5137c478bd9Sstevel@tonic-gate 			/*
5147c478bd9Sstevel@tonic-gate 			 * Move to head of list to keep list in MRU order.
5157c478bd9Sstevel@tonic-gate 			 */
5167c478bd9Sstevel@tonic-gate 			if (zsd != list_head(l)) {
5177c478bd9Sstevel@tonic-gate 				list_remove(l, zsd);
5187c478bd9Sstevel@tonic-gate 				list_insert_head(l, zsd);
5197c478bd9Sstevel@tonic-gate 			}
5207c478bd9Sstevel@tonic-gate 			return (zsd);
5217c478bd9Sstevel@tonic-gate 		}
5227c478bd9Sstevel@tonic-gate 	}
5237c478bd9Sstevel@tonic-gate 	return (NULL);
5247c478bd9Sstevel@tonic-gate }
5257c478bd9Sstevel@tonic-gate 
5267c478bd9Sstevel@tonic-gate /*
5277c478bd9Sstevel@tonic-gate  * Function called when a module is being unloaded, or otherwise wishes
5287c478bd9Sstevel@tonic-gate  * to unregister its ZSD key and callbacks.
5297c478bd9Sstevel@tonic-gate  */
5307c478bd9Sstevel@tonic-gate int
5317c478bd9Sstevel@tonic-gate zone_key_delete(zone_key_t key)
5327c478bd9Sstevel@tonic-gate {
5337c478bd9Sstevel@tonic-gate 	struct zsd_entry *zsdp = NULL;
5347c478bd9Sstevel@tonic-gate 	zone_t *zone;
5357c478bd9Sstevel@tonic-gate 
5367c478bd9Sstevel@tonic-gate 	mutex_enter(&zonehash_lock);	/* Zone create/delete waits for us */
5377c478bd9Sstevel@tonic-gate 	for (zone = list_head(&zone_active); zone != NULL;
5387c478bd9Sstevel@tonic-gate 	    zone = list_next(&zone_active, zone))
5397c478bd9Sstevel@tonic-gate 		mutex_enter(&zone->zone_lock);	/* lock all zones */
5407c478bd9Sstevel@tonic-gate 
5417c478bd9Sstevel@tonic-gate 	mutex_enter(&zsd_key_lock);
5427c478bd9Sstevel@tonic-gate 	zsdp = zsd_find(&zsd_registered_keys, key);
5437c478bd9Sstevel@tonic-gate 	if (zsdp == NULL)
5447c478bd9Sstevel@tonic-gate 		goto notfound;
5457c478bd9Sstevel@tonic-gate 	list_remove(&zsd_registered_keys, zsdp);
5467c478bd9Sstevel@tonic-gate 	mutex_exit(&zsd_key_lock);
5477c478bd9Sstevel@tonic-gate 
5487c478bd9Sstevel@tonic-gate 	for (zone = list_head(&zone_active); zone != NULL;
5497c478bd9Sstevel@tonic-gate 	    zone = list_next(&zone_active, zone)) {
5507c478bd9Sstevel@tonic-gate 		struct zsd_entry *del;
5517c478bd9Sstevel@tonic-gate 		void *data;
5527c478bd9Sstevel@tonic-gate 
5537c478bd9Sstevel@tonic-gate 		if (!(zone->zone_flags & ZF_DESTROYED)) {
5547c478bd9Sstevel@tonic-gate 			del = zsd_find(&zone->zone_zsd, key);
5557c478bd9Sstevel@tonic-gate 			if (del != NULL) {
5567c478bd9Sstevel@tonic-gate 				data = del->zsd_data;
5577c478bd9Sstevel@tonic-gate 				ASSERT(del->zsd_shutdown == zsdp->zsd_shutdown);
5587c478bd9Sstevel@tonic-gate 				ASSERT(del->zsd_destroy == zsdp->zsd_destroy);
5597c478bd9Sstevel@tonic-gate 				list_remove(&zone->zone_zsd, del);
5607c478bd9Sstevel@tonic-gate 				kmem_free(del, sizeof (*del));
5617c478bd9Sstevel@tonic-gate 			} else {
5627c478bd9Sstevel@tonic-gate 				data = NULL;
5637c478bd9Sstevel@tonic-gate 			}
5647c478bd9Sstevel@tonic-gate 			if (zsdp->zsd_shutdown)
5657c478bd9Sstevel@tonic-gate 				zsdp->zsd_shutdown(zone->zone_id, data);
5667c478bd9Sstevel@tonic-gate 			if (zsdp->zsd_destroy)
5677c478bd9Sstevel@tonic-gate 				zsdp->zsd_destroy(zone->zone_id, data);
5687c478bd9Sstevel@tonic-gate 		}
5697c478bd9Sstevel@tonic-gate 		mutex_exit(&zone->zone_lock);
5707c478bd9Sstevel@tonic-gate 	}
5717c478bd9Sstevel@tonic-gate 	mutex_exit(&zonehash_lock);
5727c478bd9Sstevel@tonic-gate 	kmem_free(zsdp, sizeof (*zsdp));
5737c478bd9Sstevel@tonic-gate 	return (0);
5747c478bd9Sstevel@tonic-gate 
5757c478bd9Sstevel@tonic-gate notfound:
5767c478bd9Sstevel@tonic-gate 	mutex_exit(&zsd_key_lock);
5777c478bd9Sstevel@tonic-gate 	for (zone = list_head(&zone_active); zone != NULL;
5787c478bd9Sstevel@tonic-gate 	    zone = list_next(&zone_active, zone))
5797c478bd9Sstevel@tonic-gate 		mutex_exit(&zone->zone_lock);
5807c478bd9Sstevel@tonic-gate 	mutex_exit(&zonehash_lock);
5817c478bd9Sstevel@tonic-gate 	return (-1);
5827c478bd9Sstevel@tonic-gate }
5837c478bd9Sstevel@tonic-gate 
5847c478bd9Sstevel@tonic-gate /*
5857c478bd9Sstevel@tonic-gate  * ZSD counterpart of pthread_setspecific().
5867c478bd9Sstevel@tonic-gate  */
5877c478bd9Sstevel@tonic-gate int
5887c478bd9Sstevel@tonic-gate zone_setspecific(zone_key_t key, zone_t *zone, const void *data)
5897c478bd9Sstevel@tonic-gate {
5907c478bd9Sstevel@tonic-gate 	struct zsd_entry *t;
5917c478bd9Sstevel@tonic-gate 	struct zsd_entry *zsdp = NULL;
5927c478bd9Sstevel@tonic-gate 
5937c478bd9Sstevel@tonic-gate 	mutex_enter(&zone->zone_lock);
5947c478bd9Sstevel@tonic-gate 	t = zsd_find(&zone->zone_zsd, key);
5957c478bd9Sstevel@tonic-gate 	if (t != NULL) {
5967c478bd9Sstevel@tonic-gate 		/*
5977c478bd9Sstevel@tonic-gate 		 * Replace old value with new
5987c478bd9Sstevel@tonic-gate 		 */
5997c478bd9Sstevel@tonic-gate 		t->zsd_data = (void *)data;
6007c478bd9Sstevel@tonic-gate 		mutex_exit(&zone->zone_lock);
6017c478bd9Sstevel@tonic-gate 		return (0);
6027c478bd9Sstevel@tonic-gate 	}
6037c478bd9Sstevel@tonic-gate 	/*
6047c478bd9Sstevel@tonic-gate 	 * If there was no previous value, go through the list of registered
6057c478bd9Sstevel@tonic-gate 	 * keys.
6067c478bd9Sstevel@tonic-gate 	 *
6077c478bd9Sstevel@tonic-gate 	 * We avoid grabbing zsd_key_lock until we are sure we need it; this is
6087c478bd9Sstevel@tonic-gate 	 * necessary for shutdown callbacks to be able to execute without fear
6097c478bd9Sstevel@tonic-gate 	 * of deadlock.
6107c478bd9Sstevel@tonic-gate 	 */
6117c478bd9Sstevel@tonic-gate 	mutex_enter(&zsd_key_lock);
6127c478bd9Sstevel@tonic-gate 	zsdp = zsd_find(&zsd_registered_keys, key);
6137c478bd9Sstevel@tonic-gate 	if (zsdp == NULL) { 	/* Key was not registered */
6147c478bd9Sstevel@tonic-gate 		mutex_exit(&zsd_key_lock);
6157c478bd9Sstevel@tonic-gate 		mutex_exit(&zone->zone_lock);
6167c478bd9Sstevel@tonic-gate 		return (-1);
6177c478bd9Sstevel@tonic-gate 	}
6187c478bd9Sstevel@tonic-gate 
6197c478bd9Sstevel@tonic-gate 	/*
6207c478bd9Sstevel@tonic-gate 	 * Add a zsd_entry to this zone, using the template we just retrieved
6217c478bd9Sstevel@tonic-gate 	 * to initialize the constructor and destructor(s).
6227c478bd9Sstevel@tonic-gate 	 */
6237c478bd9Sstevel@tonic-gate 	t = kmem_alloc(sizeof (*t), KM_SLEEP);
6247c478bd9Sstevel@tonic-gate 	t->zsd_key = key;
6257c478bd9Sstevel@tonic-gate 	t->zsd_data = (void *)data;
6267c478bd9Sstevel@tonic-gate 	t->zsd_create = zsdp->zsd_create;
6277c478bd9Sstevel@tonic-gate 	t->zsd_shutdown = zsdp->zsd_shutdown;
6287c478bd9Sstevel@tonic-gate 	t->zsd_destroy = zsdp->zsd_destroy;
6297c478bd9Sstevel@tonic-gate 	list_insert_tail(&zone->zone_zsd, t);
6307c478bd9Sstevel@tonic-gate 	mutex_exit(&zsd_key_lock);
6317c478bd9Sstevel@tonic-gate 	mutex_exit(&zone->zone_lock);
6327c478bd9Sstevel@tonic-gate 	return (0);
6337c478bd9Sstevel@tonic-gate }
6347c478bd9Sstevel@tonic-gate 
6357c478bd9Sstevel@tonic-gate /*
6367c478bd9Sstevel@tonic-gate  * ZSD counterpart of pthread_getspecific().
6377c478bd9Sstevel@tonic-gate  */
6387c478bd9Sstevel@tonic-gate void *
6397c478bd9Sstevel@tonic-gate zone_getspecific(zone_key_t key, zone_t *zone)
6407c478bd9Sstevel@tonic-gate {
6417c478bd9Sstevel@tonic-gate 	struct zsd_entry *t;
6427c478bd9Sstevel@tonic-gate 	void *data;
6437c478bd9Sstevel@tonic-gate 
6447c478bd9Sstevel@tonic-gate 	mutex_enter(&zone->zone_lock);
6457c478bd9Sstevel@tonic-gate 	t = zsd_find(&zone->zone_zsd, key);
6467c478bd9Sstevel@tonic-gate 	data = (t == NULL ? NULL : t->zsd_data);
6477c478bd9Sstevel@tonic-gate 	mutex_exit(&zone->zone_lock);
6487c478bd9Sstevel@tonic-gate 	return (data);
6497c478bd9Sstevel@tonic-gate }
6507c478bd9Sstevel@tonic-gate 
6517c478bd9Sstevel@tonic-gate /*
6527c478bd9Sstevel@tonic-gate  * Function used to initialize a zone's list of ZSD callbacks and data
6537c478bd9Sstevel@tonic-gate  * when the zone is being created.  The callbacks are initialized from
6547c478bd9Sstevel@tonic-gate  * the template list (zsd_registered_keys), and the constructor
6557c478bd9Sstevel@tonic-gate  * callback executed (if one exists).
6567c478bd9Sstevel@tonic-gate  *
6577c478bd9Sstevel@tonic-gate  * This is called before the zone is made publicly available, hence no
6587c478bd9Sstevel@tonic-gate  * need to grab zone_lock.
6597c478bd9Sstevel@tonic-gate  *
6607c478bd9Sstevel@tonic-gate  * Although we grab and release zsd_key_lock, new entries cannot be
6617c478bd9Sstevel@tonic-gate  * added to or removed from the zsd_registered_keys list until we
6627c478bd9Sstevel@tonic-gate  * release zonehash_lock, so there isn't a window for a
6637c478bd9Sstevel@tonic-gate  * zone_key_create() to come in after we've dropped zsd_key_lock but
6647c478bd9Sstevel@tonic-gate  * before the zone is added to the zone list, such that the constructor
6657c478bd9Sstevel@tonic-gate  * callbacks aren't executed for the new zone.
6667c478bd9Sstevel@tonic-gate  */
6677c478bd9Sstevel@tonic-gate static void
6687c478bd9Sstevel@tonic-gate zone_zsd_configure(zone_t *zone)
6697c478bd9Sstevel@tonic-gate {
6707c478bd9Sstevel@tonic-gate 	struct zsd_entry *zsdp;
6717c478bd9Sstevel@tonic-gate 	struct zsd_entry *t;
6727c478bd9Sstevel@tonic-gate 	zoneid_t zoneid = zone->zone_id;
6737c478bd9Sstevel@tonic-gate 
6747c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&zonehash_lock));
6757c478bd9Sstevel@tonic-gate 	ASSERT(list_head(&zone->zone_zsd) == NULL);
6767c478bd9Sstevel@tonic-gate 	mutex_enter(&zsd_key_lock);
6777c478bd9Sstevel@tonic-gate 	for (zsdp = list_head(&zsd_registered_keys); zsdp != NULL;
6787c478bd9Sstevel@tonic-gate 	    zsdp = list_next(&zsd_registered_keys, zsdp)) {
6797c478bd9Sstevel@tonic-gate 		if (zsdp->zsd_create != NULL) {
6807c478bd9Sstevel@tonic-gate 			t = kmem_alloc(sizeof (*t), KM_SLEEP);
6817c478bd9Sstevel@tonic-gate 			t->zsd_key = zsdp->zsd_key;
6827c478bd9Sstevel@tonic-gate 			t->zsd_create = zsdp->zsd_create;
6837c478bd9Sstevel@tonic-gate 			t->zsd_data = (*t->zsd_create)(zoneid);
6847c478bd9Sstevel@tonic-gate 			t->zsd_shutdown = zsdp->zsd_shutdown;
6857c478bd9Sstevel@tonic-gate 			t->zsd_destroy = zsdp->zsd_destroy;
6867c478bd9Sstevel@tonic-gate 			list_insert_tail(&zone->zone_zsd, t);
6877c478bd9Sstevel@tonic-gate 		}
6887c478bd9Sstevel@tonic-gate 	}
6897c478bd9Sstevel@tonic-gate 	mutex_exit(&zsd_key_lock);
6907c478bd9Sstevel@tonic-gate }
6917c478bd9Sstevel@tonic-gate 
6927c478bd9Sstevel@tonic-gate enum zsd_callback_type { ZSD_CREATE, ZSD_SHUTDOWN, ZSD_DESTROY };
6937c478bd9Sstevel@tonic-gate 
6947c478bd9Sstevel@tonic-gate /*
6957c478bd9Sstevel@tonic-gate  * Helper function to execute shutdown or destructor callbacks.
6967c478bd9Sstevel@tonic-gate  */
6977c478bd9Sstevel@tonic-gate static void
6987c478bd9Sstevel@tonic-gate zone_zsd_callbacks(zone_t *zone, enum zsd_callback_type ct)
6997c478bd9Sstevel@tonic-gate {
7007c478bd9Sstevel@tonic-gate 	struct zsd_entry *zsdp;
7017c478bd9Sstevel@tonic-gate 	struct zsd_entry *t;
7027c478bd9Sstevel@tonic-gate 	zoneid_t zoneid = zone->zone_id;
7037c478bd9Sstevel@tonic-gate 
7047c478bd9Sstevel@tonic-gate 	ASSERT(ct == ZSD_SHUTDOWN || ct == ZSD_DESTROY);
7057c478bd9Sstevel@tonic-gate 	ASSERT(ct != ZSD_SHUTDOWN || zone_status_get(zone) >= ZONE_IS_EMPTY);
7067c478bd9Sstevel@tonic-gate 	ASSERT(ct != ZSD_DESTROY || zone_status_get(zone) >= ZONE_IS_DOWN);
7077c478bd9Sstevel@tonic-gate 
7087c478bd9Sstevel@tonic-gate 	mutex_enter(&zone->zone_lock);
7097c478bd9Sstevel@tonic-gate 	if (ct == ZSD_DESTROY) {
7107c478bd9Sstevel@tonic-gate 		if (zone->zone_flags & ZF_DESTROYED) {
7117c478bd9Sstevel@tonic-gate 			/*
7127c478bd9Sstevel@tonic-gate 			 * Make sure destructors are only called once.
7137c478bd9Sstevel@tonic-gate 			 */
7147c478bd9Sstevel@tonic-gate 			mutex_exit(&zone->zone_lock);
7157c478bd9Sstevel@tonic-gate 			return;
7167c478bd9Sstevel@tonic-gate 		}
7177c478bd9Sstevel@tonic-gate 		zone->zone_flags |= ZF_DESTROYED;
7187c478bd9Sstevel@tonic-gate 	}
7197c478bd9Sstevel@tonic-gate 	mutex_exit(&zone->zone_lock);
7207c478bd9Sstevel@tonic-gate 
7217c478bd9Sstevel@tonic-gate 	/*
7227c478bd9Sstevel@tonic-gate 	 * Both zsd_key_lock and zone_lock need to be held in order to add or
7237c478bd9Sstevel@tonic-gate 	 * remove a ZSD key, (either globally as part of
7247c478bd9Sstevel@tonic-gate 	 * zone_key_create()/zone_key_delete(), or on a per-zone basis, as is
7257c478bd9Sstevel@tonic-gate 	 * possible through zone_setspecific()), so it's sufficient to hold
7267c478bd9Sstevel@tonic-gate 	 * zsd_key_lock here.
7277c478bd9Sstevel@tonic-gate 	 *
7287c478bd9Sstevel@tonic-gate 	 * This is a good thing, since we don't want to recursively try to grab
7297c478bd9Sstevel@tonic-gate 	 * zone_lock if a callback attempts to do something like a crfree() or
7307c478bd9Sstevel@tonic-gate 	 * zone_rele().
7317c478bd9Sstevel@tonic-gate 	 */
7327c478bd9Sstevel@tonic-gate 	mutex_enter(&zsd_key_lock);
7337c478bd9Sstevel@tonic-gate 	for (zsdp = list_head(&zsd_registered_keys); zsdp != NULL;
7347c478bd9Sstevel@tonic-gate 	    zsdp = list_next(&zsd_registered_keys, zsdp)) {
7357c478bd9Sstevel@tonic-gate 		zone_key_t key = zsdp->zsd_key;
7367c478bd9Sstevel@tonic-gate 
7377c478bd9Sstevel@tonic-gate 		/* Skip if no callbacks registered */
7387c478bd9Sstevel@tonic-gate 		if (ct == ZSD_SHUTDOWN && zsdp->zsd_shutdown == NULL)
7397c478bd9Sstevel@tonic-gate 			continue;
7407c478bd9Sstevel@tonic-gate 		if (ct == ZSD_DESTROY && zsdp->zsd_destroy == NULL)
7417c478bd9Sstevel@tonic-gate 			continue;
7427c478bd9Sstevel@tonic-gate 		/*
7437c478bd9Sstevel@tonic-gate 		 * Call the callback with the zone-specific data if we can find
7447c478bd9Sstevel@tonic-gate 		 * any, otherwise with NULL.
7457c478bd9Sstevel@tonic-gate 		 */
7467c478bd9Sstevel@tonic-gate 		t = zsd_find(&zone->zone_zsd, key);
7477c478bd9Sstevel@tonic-gate 		if (t != NULL) {
7487c478bd9Sstevel@tonic-gate 			if (ct == ZSD_SHUTDOWN) {
7497c478bd9Sstevel@tonic-gate 				t->zsd_shutdown(zoneid, t->zsd_data);
7507c478bd9Sstevel@tonic-gate 			} else {
7517c478bd9Sstevel@tonic-gate 				ASSERT(ct == ZSD_DESTROY);
7527c478bd9Sstevel@tonic-gate 				t->zsd_destroy(zoneid, t->zsd_data);
7537c478bd9Sstevel@tonic-gate 			}
7547c478bd9Sstevel@tonic-gate 		} else {
7557c478bd9Sstevel@tonic-gate 			if (ct == ZSD_SHUTDOWN) {
7567c478bd9Sstevel@tonic-gate 				zsdp->zsd_shutdown(zoneid, NULL);
7577c478bd9Sstevel@tonic-gate 			} else {
7587c478bd9Sstevel@tonic-gate 				ASSERT(ct == ZSD_DESTROY);
7597c478bd9Sstevel@tonic-gate 				zsdp->zsd_destroy(zoneid, NULL);
7607c478bd9Sstevel@tonic-gate 			}
7617c478bd9Sstevel@tonic-gate 		}
7627c478bd9Sstevel@tonic-gate 	}
7637c478bd9Sstevel@tonic-gate 	mutex_exit(&zsd_key_lock);
7647c478bd9Sstevel@tonic-gate }
7657c478bd9Sstevel@tonic-gate 
7667c478bd9Sstevel@tonic-gate /*
7677c478bd9Sstevel@tonic-gate  * Called when the zone is going away; free ZSD-related memory, and
7687c478bd9Sstevel@tonic-gate  * destroy the zone_zsd list.
7697c478bd9Sstevel@tonic-gate  */
7707c478bd9Sstevel@tonic-gate static void
7717c478bd9Sstevel@tonic-gate zone_free_zsd(zone_t *zone)
7727c478bd9Sstevel@tonic-gate {
7737c478bd9Sstevel@tonic-gate 	struct zsd_entry *t, *next;
7747c478bd9Sstevel@tonic-gate 
7757c478bd9Sstevel@tonic-gate 	/*
7767c478bd9Sstevel@tonic-gate 	 * Free all the zsd_entry's we had on this zone.
7777c478bd9Sstevel@tonic-gate 	 */
7787c478bd9Sstevel@tonic-gate 	for (t = list_head(&zone->zone_zsd); t != NULL; t = next) {
7797c478bd9Sstevel@tonic-gate 		next = list_next(&zone->zone_zsd, t);
7807c478bd9Sstevel@tonic-gate 		list_remove(&zone->zone_zsd, t);
7817c478bd9Sstevel@tonic-gate 		kmem_free(t, sizeof (*t));
7827c478bd9Sstevel@tonic-gate 	}
7837c478bd9Sstevel@tonic-gate 	list_destroy(&zone->zone_zsd);
7847c478bd9Sstevel@tonic-gate }
7857c478bd9Sstevel@tonic-gate 
786fa9e4066Sahrens /*
787fa9e4066Sahrens  * Frees memory associated with the zone dataset list.
788fa9e4066Sahrens  */
789fa9e4066Sahrens static void
790fa9e4066Sahrens zone_free_datasets(zone_t *zone)
791fa9e4066Sahrens {
792fa9e4066Sahrens 	zone_dataset_t *t, *next;
793fa9e4066Sahrens 
794fa9e4066Sahrens 	for (t = list_head(&zone->zone_datasets); t != NULL; t = next) {
795fa9e4066Sahrens 		next = list_next(&zone->zone_datasets, t);
796fa9e4066Sahrens 		list_remove(&zone->zone_datasets, t);
797fa9e4066Sahrens 		kmem_free(t->zd_dataset, strlen(t->zd_dataset) + 1);
798fa9e4066Sahrens 		kmem_free(t, sizeof (*t));
799fa9e4066Sahrens 	}
800fa9e4066Sahrens 	list_destroy(&zone->zone_datasets);
801fa9e4066Sahrens }
802fa9e4066Sahrens 
8037c478bd9Sstevel@tonic-gate /*
8047c478bd9Sstevel@tonic-gate  * zone.cpu-shares resource control support.
8057c478bd9Sstevel@tonic-gate  */
8067c478bd9Sstevel@tonic-gate /*ARGSUSED*/
8077c478bd9Sstevel@tonic-gate static rctl_qty_t
8087c478bd9Sstevel@tonic-gate zone_cpu_shares_usage(rctl_t *rctl, struct proc *p)
8097c478bd9Sstevel@tonic-gate {
8107c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&p->p_lock));
8117c478bd9Sstevel@tonic-gate 	return (p->p_zone->zone_shares);
8127c478bd9Sstevel@tonic-gate }
8137c478bd9Sstevel@tonic-gate 
8147c478bd9Sstevel@tonic-gate /*ARGSUSED*/
8157c478bd9Sstevel@tonic-gate static int
8167c478bd9Sstevel@tonic-gate zone_cpu_shares_set(rctl_t *rctl, struct proc *p, rctl_entity_p_t *e,
8177c478bd9Sstevel@tonic-gate     rctl_qty_t nv)
8187c478bd9Sstevel@tonic-gate {
8197c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&p->p_lock));
8207c478bd9Sstevel@tonic-gate 	ASSERT(e->rcep_t == RCENTITY_ZONE);
8217c478bd9Sstevel@tonic-gate 	if (e->rcep_p.zone == NULL)
8227c478bd9Sstevel@tonic-gate 		return (0);
8237c478bd9Sstevel@tonic-gate 
8247c478bd9Sstevel@tonic-gate 	e->rcep_p.zone->zone_shares = nv;
8257c478bd9Sstevel@tonic-gate 	return (0);
8267c478bd9Sstevel@tonic-gate }
8277c478bd9Sstevel@tonic-gate 
8287c478bd9Sstevel@tonic-gate static rctl_ops_t zone_cpu_shares_ops = {
8297c478bd9Sstevel@tonic-gate 	rcop_no_action,
8307c478bd9Sstevel@tonic-gate 	zone_cpu_shares_usage,
8317c478bd9Sstevel@tonic-gate 	zone_cpu_shares_set,
8327c478bd9Sstevel@tonic-gate 	rcop_no_test
8337c478bd9Sstevel@tonic-gate };
8347c478bd9Sstevel@tonic-gate 
8357c478bd9Sstevel@tonic-gate /*ARGSUSED*/
8367c478bd9Sstevel@tonic-gate static rctl_qty_t
8377c478bd9Sstevel@tonic-gate zone_lwps_usage(rctl_t *r, proc_t *p)
8387c478bd9Sstevel@tonic-gate {
8397c478bd9Sstevel@tonic-gate 	rctl_qty_t nlwps;
8407c478bd9Sstevel@tonic-gate 	zone_t *zone = p->p_zone;
8417c478bd9Sstevel@tonic-gate 
8427c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&p->p_lock));
8437c478bd9Sstevel@tonic-gate 
8447c478bd9Sstevel@tonic-gate 	mutex_enter(&zone->zone_nlwps_lock);
8457c478bd9Sstevel@tonic-gate 	nlwps = zone->zone_nlwps;
8467c478bd9Sstevel@tonic-gate 	mutex_exit(&zone->zone_nlwps_lock);
8477c478bd9Sstevel@tonic-gate 
8487c478bd9Sstevel@tonic-gate 	return (nlwps);
8497c478bd9Sstevel@tonic-gate }
8507c478bd9Sstevel@tonic-gate 
8517c478bd9Sstevel@tonic-gate /*ARGSUSED*/
8527c478bd9Sstevel@tonic-gate static int
8537c478bd9Sstevel@tonic-gate zone_lwps_test(rctl_t *r, proc_t *p, rctl_entity_p_t *e, rctl_val_t *rcntl,
8547c478bd9Sstevel@tonic-gate     rctl_qty_t incr, uint_t flags)
8557c478bd9Sstevel@tonic-gate {
8567c478bd9Sstevel@tonic-gate 	rctl_qty_t nlwps;
8577c478bd9Sstevel@tonic-gate 
8587c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&p->p_lock));
8597c478bd9Sstevel@tonic-gate 	ASSERT(e->rcep_t == RCENTITY_ZONE);
8607c478bd9Sstevel@tonic-gate 	if (e->rcep_p.zone == NULL)
8617c478bd9Sstevel@tonic-gate 		return (0);
8627c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&(e->rcep_p.zone->zone_nlwps_lock)));
8637c478bd9Sstevel@tonic-gate 	nlwps = e->rcep_p.zone->zone_nlwps;
8647c478bd9Sstevel@tonic-gate 
8657c478bd9Sstevel@tonic-gate 	if (nlwps + incr > rcntl->rcv_value)
8667c478bd9Sstevel@tonic-gate 		return (1);
8677c478bd9Sstevel@tonic-gate 
8687c478bd9Sstevel@tonic-gate 	return (0);
8697c478bd9Sstevel@tonic-gate }
8707c478bd9Sstevel@tonic-gate 
8717c478bd9Sstevel@tonic-gate /*ARGSUSED*/
8727c478bd9Sstevel@tonic-gate static int
8737c478bd9Sstevel@tonic-gate zone_lwps_set(rctl_t *rctl, struct proc *p, rctl_entity_p_t *e, rctl_qty_t nv) {
8747c478bd9Sstevel@tonic-gate 
8757c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&p->p_lock));
8767c478bd9Sstevel@tonic-gate 	ASSERT(e->rcep_t == RCENTITY_ZONE);
8777c478bd9Sstevel@tonic-gate 	if (e->rcep_p.zone == NULL)
8787c478bd9Sstevel@tonic-gate 		return (0);
8797c478bd9Sstevel@tonic-gate 	e->rcep_p.zone->zone_nlwps_ctl = nv;
8807c478bd9Sstevel@tonic-gate 	return (0);
8817c478bd9Sstevel@tonic-gate }
8827c478bd9Sstevel@tonic-gate 
8837c478bd9Sstevel@tonic-gate static rctl_ops_t zone_lwps_ops = {
8847c478bd9Sstevel@tonic-gate 	rcop_no_action,
8857c478bd9Sstevel@tonic-gate 	zone_lwps_usage,
8867c478bd9Sstevel@tonic-gate 	zone_lwps_set,
8877c478bd9Sstevel@tonic-gate 	zone_lwps_test,
8887c478bd9Sstevel@tonic-gate };
8897c478bd9Sstevel@tonic-gate 
8907c478bd9Sstevel@tonic-gate /*
8917c478bd9Sstevel@tonic-gate  * Helper function to brand the zone with a unique ID.
8927c478bd9Sstevel@tonic-gate  */
8937c478bd9Sstevel@tonic-gate static void
8947c478bd9Sstevel@tonic-gate zone_uniqid(zone_t *zone)
8957c478bd9Sstevel@tonic-gate {
8967c478bd9Sstevel@tonic-gate 	static uint64_t uniqid = 0;
8977c478bd9Sstevel@tonic-gate 
8987c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&zonehash_lock));
8997c478bd9Sstevel@tonic-gate 	zone->zone_uniqid = uniqid++;
9007c478bd9Sstevel@tonic-gate }
9017c478bd9Sstevel@tonic-gate 
9027c478bd9Sstevel@tonic-gate /*
9037c478bd9Sstevel@tonic-gate  * Returns a held pointer to the "kcred" for the specified zone.
9047c478bd9Sstevel@tonic-gate  */
9057c478bd9Sstevel@tonic-gate struct cred *
9067c478bd9Sstevel@tonic-gate zone_get_kcred(zoneid_t zoneid)
9077c478bd9Sstevel@tonic-gate {
9087c478bd9Sstevel@tonic-gate 	zone_t *zone;
9097c478bd9Sstevel@tonic-gate 	cred_t *cr;
9107c478bd9Sstevel@tonic-gate 
9117c478bd9Sstevel@tonic-gate 	if ((zone = zone_find_by_id(zoneid)) == NULL)
9127c478bd9Sstevel@tonic-gate 		return (NULL);
9137c478bd9Sstevel@tonic-gate 	cr = zone->zone_kcred;
9147c478bd9Sstevel@tonic-gate 	crhold(cr);
9157c478bd9Sstevel@tonic-gate 	zone_rele(zone);
9167c478bd9Sstevel@tonic-gate 	return (cr);
9177c478bd9Sstevel@tonic-gate }
9187c478bd9Sstevel@tonic-gate 
9197c478bd9Sstevel@tonic-gate /*
9207c478bd9Sstevel@tonic-gate  * Called very early on in boot to initialize the ZSD list so that
9217c478bd9Sstevel@tonic-gate  * zone_key_create() can be called before zone_init().  It also initializes
9227c478bd9Sstevel@tonic-gate  * portions of zone0 which may be used before zone_init() is called.  The
9237c478bd9Sstevel@tonic-gate  * variable "global_zone" will be set when zone0 is fully initialized by
9247c478bd9Sstevel@tonic-gate  * zone_init().
9257c478bd9Sstevel@tonic-gate  */
9267c478bd9Sstevel@tonic-gate void
9277c478bd9Sstevel@tonic-gate zone_zsd_init(void)
9287c478bd9Sstevel@tonic-gate {
9297c478bd9Sstevel@tonic-gate 	mutex_init(&zonehash_lock, NULL, MUTEX_DEFAULT, NULL);
9307c478bd9Sstevel@tonic-gate 	mutex_init(&zsd_key_lock, NULL, MUTEX_DEFAULT, NULL);
9317c478bd9Sstevel@tonic-gate 	list_create(&zsd_registered_keys, sizeof (struct zsd_entry),
9327c478bd9Sstevel@tonic-gate 	    offsetof(struct zsd_entry, zsd_linkage));
9337c478bd9Sstevel@tonic-gate 	list_create(&zone_active, sizeof (zone_t),
9347c478bd9Sstevel@tonic-gate 	    offsetof(zone_t, zone_linkage));
9357c478bd9Sstevel@tonic-gate 	list_create(&zone_deathrow, sizeof (zone_t),
9367c478bd9Sstevel@tonic-gate 	    offsetof(zone_t, zone_linkage));
9377c478bd9Sstevel@tonic-gate 
9387c478bd9Sstevel@tonic-gate 	mutex_init(&zone0.zone_lock, NULL, MUTEX_DEFAULT, NULL);
9397c478bd9Sstevel@tonic-gate 	mutex_init(&zone0.zone_nlwps_lock, NULL, MUTEX_DEFAULT, NULL);
9407c478bd9Sstevel@tonic-gate 	zone0.zone_shares = 1;
9417c478bd9Sstevel@tonic-gate 	zone0.zone_nlwps_ctl = INT_MAX;
9427c478bd9Sstevel@tonic-gate 	zone0.zone_name = GLOBAL_ZONENAME;
9437c478bd9Sstevel@tonic-gate 	zone0.zone_nodename = utsname.nodename;
9447c478bd9Sstevel@tonic-gate 	zone0.zone_domain = srpc_domain;
9457c478bd9Sstevel@tonic-gate 	zone0.zone_ref = 1;
9467c478bd9Sstevel@tonic-gate 	zone0.zone_id = GLOBAL_ZONEID;
9477c478bd9Sstevel@tonic-gate 	zone0.zone_status = ZONE_IS_RUNNING;
9487c478bd9Sstevel@tonic-gate 	zone0.zone_rootpath = "/";
9497c478bd9Sstevel@tonic-gate 	zone0.zone_rootpathlen = 2;
9507c478bd9Sstevel@tonic-gate 	zone0.zone_psetid = ZONE_PS_INVAL;
9517c478bd9Sstevel@tonic-gate 	zone0.zone_ncpus = 0;
9527c478bd9Sstevel@tonic-gate 	zone0.zone_ncpus_online = 0;
9537c478bd9Sstevel@tonic-gate 	zone0.zone_proc_initpid = 1;
9547c478bd9Sstevel@tonic-gate 	list_create(&zone0.zone_zsd, sizeof (struct zsd_entry),
9557c478bd9Sstevel@tonic-gate 	    offsetof(struct zsd_entry, zsd_linkage));
9567c478bd9Sstevel@tonic-gate 	list_insert_head(&zone_active, &zone0);
9577c478bd9Sstevel@tonic-gate 
9587c478bd9Sstevel@tonic-gate 	/*
9597c478bd9Sstevel@tonic-gate 	 * The root filesystem is not mounted yet, so zone_rootvp cannot be set
9607c478bd9Sstevel@tonic-gate 	 * to anything meaningful.  It is assigned to be 'rootdir' in
9617c478bd9Sstevel@tonic-gate 	 * vfs_mountroot().
9627c478bd9Sstevel@tonic-gate 	 */
9637c478bd9Sstevel@tonic-gate 	zone0.zone_rootvp = NULL;
9647c478bd9Sstevel@tonic-gate 	zone0.zone_vfslist = NULL;
9657c478bd9Sstevel@tonic-gate 	zone0.zone_bootargs = NULL;
9667c478bd9Sstevel@tonic-gate 	zone0.zone_privset = kmem_alloc(sizeof (priv_set_t), KM_SLEEP);
9677c478bd9Sstevel@tonic-gate 	/*
9687c478bd9Sstevel@tonic-gate 	 * The global zone has all privileges
9697c478bd9Sstevel@tonic-gate 	 */
9707c478bd9Sstevel@tonic-gate 	priv_fillset(zone0.zone_privset);
9717c478bd9Sstevel@tonic-gate 	/*
9727c478bd9Sstevel@tonic-gate 	 * Add p0 to the global zone
9737c478bd9Sstevel@tonic-gate 	 */
9747c478bd9Sstevel@tonic-gate 	zone0.zone_zsched = &p0;
9757c478bd9Sstevel@tonic-gate 	p0.p_zone = &zone0;
9767c478bd9Sstevel@tonic-gate }
9777c478bd9Sstevel@tonic-gate 
9787c478bd9Sstevel@tonic-gate /*
9797c478bd9Sstevel@tonic-gate  * Called by main() to initialize the zones framework.
9807c478bd9Sstevel@tonic-gate  */
9817c478bd9Sstevel@tonic-gate void
9827c478bd9Sstevel@tonic-gate zone_init(void)
9837c478bd9Sstevel@tonic-gate {
9847c478bd9Sstevel@tonic-gate 	rctl_dict_entry_t *rde;
9857c478bd9Sstevel@tonic-gate 	rctl_val_t *dval;
9867c478bd9Sstevel@tonic-gate 	rctl_set_t *set;
9877c478bd9Sstevel@tonic-gate 	rctl_alloc_gp_t *gp;
9887c478bd9Sstevel@tonic-gate 	rctl_entity_p_t e;
9897c478bd9Sstevel@tonic-gate 
9907c478bd9Sstevel@tonic-gate 	ASSERT(curproc == &p0);
9917c478bd9Sstevel@tonic-gate 
9927c478bd9Sstevel@tonic-gate 	/*
9937c478bd9Sstevel@tonic-gate 	 * Create ID space for zone IDs.  ID 0 is reserved for the
9947c478bd9Sstevel@tonic-gate 	 * global zone.
9957c478bd9Sstevel@tonic-gate 	 */
9967c478bd9Sstevel@tonic-gate 	zoneid_space = id_space_create("zoneid_space", 1, MAX_ZONEID);
9977c478bd9Sstevel@tonic-gate 
9987c478bd9Sstevel@tonic-gate 	/*
9997c478bd9Sstevel@tonic-gate 	 * Initialize generic zone resource controls, if any.
10007c478bd9Sstevel@tonic-gate 	 */
10017c478bd9Sstevel@tonic-gate 	rc_zone_cpu_shares = rctl_register("zone.cpu-shares",
10027c478bd9Sstevel@tonic-gate 	    RCENTITY_ZONE, RCTL_GLOBAL_SIGNAL_NEVER | RCTL_GLOBAL_DENY_NEVER |
10037c478bd9Sstevel@tonic-gate 	    RCTL_GLOBAL_NOBASIC |
10047c478bd9Sstevel@tonic-gate 	    RCTL_GLOBAL_COUNT, FSS_MAXSHARES, FSS_MAXSHARES,
10057c478bd9Sstevel@tonic-gate 	    &zone_cpu_shares_ops);
10067c478bd9Sstevel@tonic-gate 
10077c478bd9Sstevel@tonic-gate 	rc_zone_nlwps = rctl_register("zone.max-lwps", RCENTITY_ZONE,
10087c478bd9Sstevel@tonic-gate 	    RCTL_GLOBAL_NOACTION | RCTL_GLOBAL_NOBASIC | RCTL_GLOBAL_COUNT,
10097c478bd9Sstevel@tonic-gate 	    INT_MAX, INT_MAX, &zone_lwps_ops);
10107c478bd9Sstevel@tonic-gate 	/*
10117c478bd9Sstevel@tonic-gate 	 * Create a rctl_val with PRIVILEGED, NOACTION, value = 1.  Then attach
10127c478bd9Sstevel@tonic-gate 	 * this at the head of the rctl_dict_entry for ``zone.cpu-shares''.
10137c478bd9Sstevel@tonic-gate 	 */
10147c478bd9Sstevel@tonic-gate 	dval = kmem_cache_alloc(rctl_val_cache, KM_SLEEP);
10157c478bd9Sstevel@tonic-gate 	bzero(dval, sizeof (rctl_val_t));
10167c478bd9Sstevel@tonic-gate 	dval->rcv_value = 1;
10177c478bd9Sstevel@tonic-gate 	dval->rcv_privilege = RCPRIV_PRIVILEGED;
10187c478bd9Sstevel@tonic-gate 	dval->rcv_flagaction = RCTL_LOCAL_NOACTION;
10197c478bd9Sstevel@tonic-gate 	dval->rcv_action_recip_pid = -1;
10207c478bd9Sstevel@tonic-gate 
10217c478bd9Sstevel@tonic-gate 	rde = rctl_dict_lookup("zone.cpu-shares");
10227c478bd9Sstevel@tonic-gate 	(void) rctl_val_list_insert(&rde->rcd_default_value, dval);
10237c478bd9Sstevel@tonic-gate 
10247c478bd9Sstevel@tonic-gate 	/*
10257c478bd9Sstevel@tonic-gate 	 * Initialize the ``global zone''.
10267c478bd9Sstevel@tonic-gate 	 */
10277c478bd9Sstevel@tonic-gate 	set = rctl_set_create();
10287c478bd9Sstevel@tonic-gate 	gp = rctl_set_init_prealloc(RCENTITY_ZONE);
10297c478bd9Sstevel@tonic-gate 	mutex_enter(&p0.p_lock);
10307c478bd9Sstevel@tonic-gate 	e.rcep_p.zone = &zone0;
10317c478bd9Sstevel@tonic-gate 	e.rcep_t = RCENTITY_ZONE;
10327c478bd9Sstevel@tonic-gate 	zone0.zone_rctls = rctl_set_init(RCENTITY_ZONE, &p0, &e, set,
10337c478bd9Sstevel@tonic-gate 	    gp);
10347c478bd9Sstevel@tonic-gate 
10357c478bd9Sstevel@tonic-gate 	zone0.zone_nlwps = p0.p_lwpcnt;
10367c478bd9Sstevel@tonic-gate 	zone0.zone_ntasks = 1;
10377c478bd9Sstevel@tonic-gate 	mutex_exit(&p0.p_lock);
10387c478bd9Sstevel@tonic-gate 	rctl_prealloc_destroy(gp);
10397c478bd9Sstevel@tonic-gate 	/*
10407c478bd9Sstevel@tonic-gate 	 * pool_default hasn't been initialized yet, so we let pool_init() take
10417c478bd9Sstevel@tonic-gate 	 * care of making the global zone is in the default pool.
10427c478bd9Sstevel@tonic-gate 	 */
10437c478bd9Sstevel@tonic-gate 	mutex_enter(&zonehash_lock);
10447c478bd9Sstevel@tonic-gate 	zone_uniqid(&zone0);
10457c478bd9Sstevel@tonic-gate 	ASSERT(zone0.zone_uniqid == GLOBAL_ZONEUNIQID);
10467c478bd9Sstevel@tonic-gate 	mutex_exit(&zonehash_lock);
10477c478bd9Sstevel@tonic-gate 	zonehashbyid = mod_hash_create_idhash("zone_by_id", zone_hash_size,
10487c478bd9Sstevel@tonic-gate 	    mod_hash_null_valdtor);
10497c478bd9Sstevel@tonic-gate 	zonehashbyname = mod_hash_create_strhash("zone_by_name",
10507c478bd9Sstevel@tonic-gate 	    zone_hash_size, mod_hash_null_valdtor);
10517c478bd9Sstevel@tonic-gate 	zonecount = 1;
10527c478bd9Sstevel@tonic-gate 
10537c478bd9Sstevel@tonic-gate 	(void) mod_hash_insert(zonehashbyid, (mod_hash_key_t)GLOBAL_ZONEID,
10547c478bd9Sstevel@tonic-gate 	    (mod_hash_val_t)&zone0);
10557c478bd9Sstevel@tonic-gate 	(void) mod_hash_insert(zonehashbyname, (mod_hash_key_t)zone0.zone_name,
10567c478bd9Sstevel@tonic-gate 	    (mod_hash_val_t)&zone0);
10577c478bd9Sstevel@tonic-gate 	/*
10587c478bd9Sstevel@tonic-gate 	 * We avoid setting zone_kcred until now, since kcred is initialized
10597c478bd9Sstevel@tonic-gate 	 * sometime after zone_zsd_init() and before zone_init().
10607c478bd9Sstevel@tonic-gate 	 */
10617c478bd9Sstevel@tonic-gate 	zone0.zone_kcred = kcred;
10627c478bd9Sstevel@tonic-gate 	/*
10637c478bd9Sstevel@tonic-gate 	 * The global zone is fully initialized (except for zone_rootvp which
10647c478bd9Sstevel@tonic-gate 	 * will be set when the root filesystem is mounted).
10657c478bd9Sstevel@tonic-gate 	 */
10667c478bd9Sstevel@tonic-gate 	global_zone = &zone0;
10677c478bd9Sstevel@tonic-gate }
10687c478bd9Sstevel@tonic-gate 
10697c478bd9Sstevel@tonic-gate static void
10707c478bd9Sstevel@tonic-gate zone_free(zone_t *zone)
10717c478bd9Sstevel@tonic-gate {
10727c478bd9Sstevel@tonic-gate 	ASSERT(zone != global_zone);
10737c478bd9Sstevel@tonic-gate 	ASSERT(zone->zone_ntasks == 0);
10747c478bd9Sstevel@tonic-gate 	ASSERT(zone->zone_nlwps == 0);
10757c478bd9Sstevel@tonic-gate 	ASSERT(zone->zone_cred_ref == 0);
10767c478bd9Sstevel@tonic-gate 	ASSERT(zone->zone_kcred == NULL);
10777c478bd9Sstevel@tonic-gate 	ASSERT(zone_status_get(zone) == ZONE_IS_DEAD ||
10787c478bd9Sstevel@tonic-gate 	    zone_status_get(zone) == ZONE_IS_UNINITIALIZED);
10797c478bd9Sstevel@tonic-gate 
10807c478bd9Sstevel@tonic-gate 	/* remove from deathrow list */
10817c478bd9Sstevel@tonic-gate 	if (zone_status_get(zone) == ZONE_IS_DEAD) {
10827c478bd9Sstevel@tonic-gate 		ASSERT(zone->zone_ref == 0);
10837c478bd9Sstevel@tonic-gate 		mutex_enter(&zone_deathrow_lock);
10847c478bd9Sstevel@tonic-gate 		list_remove(&zone_deathrow, zone);
10857c478bd9Sstevel@tonic-gate 		mutex_exit(&zone_deathrow_lock);
10867c478bd9Sstevel@tonic-gate 	}
10877c478bd9Sstevel@tonic-gate 
10887c478bd9Sstevel@tonic-gate 	zone_free_zsd(zone);
1089fa9e4066Sahrens 	zone_free_datasets(zone);
10907c478bd9Sstevel@tonic-gate 
10917c478bd9Sstevel@tonic-gate 	if (zone->zone_rootvp != NULL)
10927c478bd9Sstevel@tonic-gate 		VN_RELE(zone->zone_rootvp);
10937c478bd9Sstevel@tonic-gate 	if (zone->zone_rootpath)
10947c478bd9Sstevel@tonic-gate 		kmem_free(zone->zone_rootpath, zone->zone_rootpathlen);
10957c478bd9Sstevel@tonic-gate 	if (zone->zone_name != NULL)
10967c478bd9Sstevel@tonic-gate 		kmem_free(zone->zone_name, ZONENAME_MAX);
10977c478bd9Sstevel@tonic-gate 	if (zone->zone_nodename != NULL)
10987c478bd9Sstevel@tonic-gate 		kmem_free(zone->zone_nodename, _SYS_NMLN);
10997c478bd9Sstevel@tonic-gate 	if (zone->zone_domain != NULL)
11007c478bd9Sstevel@tonic-gate 		kmem_free(zone->zone_domain, _SYS_NMLN);
11017c478bd9Sstevel@tonic-gate 	if (zone->zone_privset != NULL)
11027c478bd9Sstevel@tonic-gate 		kmem_free(zone->zone_privset, sizeof (priv_set_t));
11037c478bd9Sstevel@tonic-gate 	if (zone->zone_rctls != NULL)
11047c478bd9Sstevel@tonic-gate 		rctl_set_free(zone->zone_rctls);
11057c478bd9Sstevel@tonic-gate 	if (zone->zone_bootargs != NULL)
11067c478bd9Sstevel@tonic-gate 		kmem_free(zone->zone_bootargs, ZONEBOOTARGS_MAX);
11077c478bd9Sstevel@tonic-gate 	id_free(zoneid_space, zone->zone_id);
11087c478bd9Sstevel@tonic-gate 	mutex_destroy(&zone->zone_lock);
11097c478bd9Sstevel@tonic-gate 	cv_destroy(&zone->zone_cv);
11107c478bd9Sstevel@tonic-gate 	kmem_free(zone, sizeof (zone_t));
11117c478bd9Sstevel@tonic-gate }
11127c478bd9Sstevel@tonic-gate 
11137c478bd9Sstevel@tonic-gate /*
11147c478bd9Sstevel@tonic-gate  * See block comment at the top of this file for information about zone
11157c478bd9Sstevel@tonic-gate  * status values.
11167c478bd9Sstevel@tonic-gate  */
11177c478bd9Sstevel@tonic-gate /*
11187c478bd9Sstevel@tonic-gate  * Convenience function for setting zone status.
11197c478bd9Sstevel@tonic-gate  */
11207c478bd9Sstevel@tonic-gate static void
11217c478bd9Sstevel@tonic-gate zone_status_set(zone_t *zone, zone_status_t status)
11227c478bd9Sstevel@tonic-gate {
11237c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&zone_status_lock));
11247c478bd9Sstevel@tonic-gate 	ASSERT(status > ZONE_MIN_STATE && status <= ZONE_MAX_STATE &&
11257c478bd9Sstevel@tonic-gate 	    status >= zone_status_get(zone));
11267c478bd9Sstevel@tonic-gate 	zone->zone_status = status;
11277c478bd9Sstevel@tonic-gate 	cv_broadcast(&zone->zone_cv);
11287c478bd9Sstevel@tonic-gate }
11297c478bd9Sstevel@tonic-gate 
11307c478bd9Sstevel@tonic-gate /*
11317c478bd9Sstevel@tonic-gate  * Public function to retrieve the zone status.  The zone status may
11327c478bd9Sstevel@tonic-gate  * change after it is retrieved.
11337c478bd9Sstevel@tonic-gate  */
11347c478bd9Sstevel@tonic-gate zone_status_t
11357c478bd9Sstevel@tonic-gate zone_status_get(zone_t *zone)
11367c478bd9Sstevel@tonic-gate {
11377c478bd9Sstevel@tonic-gate 	return (zone->zone_status);
11387c478bd9Sstevel@tonic-gate }
11397c478bd9Sstevel@tonic-gate 
11407c478bd9Sstevel@tonic-gate static int
11417c478bd9Sstevel@tonic-gate zone_set_bootargs(zone_t *zone, const char *zone_bootargs)
11427c478bd9Sstevel@tonic-gate {
11437c478bd9Sstevel@tonic-gate 	char *bootargs = kmem_zalloc(ZONEBOOTARGS_MAX, KM_SLEEP);
11447c478bd9Sstevel@tonic-gate 	size_t len;
11457c478bd9Sstevel@tonic-gate 	int err;
11467c478bd9Sstevel@tonic-gate 
11477c478bd9Sstevel@tonic-gate 	err = copyinstr(zone_bootargs, bootargs, ZONEBOOTARGS_MAX - 1, &len);
11487c478bd9Sstevel@tonic-gate 	if (err != 0) {
11497c478bd9Sstevel@tonic-gate 		kmem_free(bootargs, ZONEBOOTARGS_MAX);
11507c478bd9Sstevel@tonic-gate 		return (err);	/* EFAULT or ENAMETOOLONG */
11517c478bd9Sstevel@tonic-gate 	}
11527c478bd9Sstevel@tonic-gate 	bootargs[len] = '\0';
11537c478bd9Sstevel@tonic-gate 
11547c478bd9Sstevel@tonic-gate 	ASSERT(zone->zone_bootargs == NULL);
11557c478bd9Sstevel@tonic-gate 	zone->zone_bootargs = bootargs;
11567c478bd9Sstevel@tonic-gate 	return (0);
11577c478bd9Sstevel@tonic-gate }
11587c478bd9Sstevel@tonic-gate 
11597c478bd9Sstevel@tonic-gate /*
11607c478bd9Sstevel@tonic-gate  * Block indefinitely waiting for (zone_status >= status)
11617c478bd9Sstevel@tonic-gate  */
11627c478bd9Sstevel@tonic-gate void
11637c478bd9Sstevel@tonic-gate zone_status_wait(zone_t *zone, zone_status_t status)
11647c478bd9Sstevel@tonic-gate {
11657c478bd9Sstevel@tonic-gate 	ASSERT(status > ZONE_MIN_STATE && status <= ZONE_MAX_STATE);
11667c478bd9Sstevel@tonic-gate 
11677c478bd9Sstevel@tonic-gate 	mutex_enter(&zone_status_lock);
11687c478bd9Sstevel@tonic-gate 	while (zone->zone_status < status) {
11697c478bd9Sstevel@tonic-gate 		cv_wait(&zone->zone_cv, &zone_status_lock);
11707c478bd9Sstevel@tonic-gate 	}
11717c478bd9Sstevel@tonic-gate 	mutex_exit(&zone_status_lock);
11727c478bd9Sstevel@tonic-gate }
11737c478bd9Sstevel@tonic-gate 
11747c478bd9Sstevel@tonic-gate /*
11757c478bd9Sstevel@tonic-gate  * Private CPR-safe version of zone_status_wait().
11767c478bd9Sstevel@tonic-gate  */
11777c478bd9Sstevel@tonic-gate static void
11787c478bd9Sstevel@tonic-gate zone_status_wait_cpr(zone_t *zone, zone_status_t status, char *str)
11797c478bd9Sstevel@tonic-gate {
11807c478bd9Sstevel@tonic-gate 	callb_cpr_t cprinfo;
11817c478bd9Sstevel@tonic-gate 
11827c478bd9Sstevel@tonic-gate 	ASSERT(status > ZONE_MIN_STATE && status <= ZONE_MAX_STATE);
11837c478bd9Sstevel@tonic-gate 
11847c478bd9Sstevel@tonic-gate 	CALLB_CPR_INIT(&cprinfo, &zone_status_lock, callb_generic_cpr,
11857c478bd9Sstevel@tonic-gate 	    str);
11867c478bd9Sstevel@tonic-gate 	mutex_enter(&zone_status_lock);
11877c478bd9Sstevel@tonic-gate 	while (zone->zone_status < status) {
11887c478bd9Sstevel@tonic-gate 		CALLB_CPR_SAFE_BEGIN(&cprinfo);
11897c478bd9Sstevel@tonic-gate 		cv_wait(&zone->zone_cv, &zone_status_lock);
11907c478bd9Sstevel@tonic-gate 		CALLB_CPR_SAFE_END(&cprinfo, &zone_status_lock);
11917c478bd9Sstevel@tonic-gate 	}
11927c478bd9Sstevel@tonic-gate 	/*
11937c478bd9Sstevel@tonic-gate 	 * zone_status_lock is implicitly released by the following.
11947c478bd9Sstevel@tonic-gate 	 */
11957c478bd9Sstevel@tonic-gate 	CALLB_CPR_EXIT(&cprinfo);
11967c478bd9Sstevel@tonic-gate }
11977c478bd9Sstevel@tonic-gate 
11987c478bd9Sstevel@tonic-gate /*
11997c478bd9Sstevel@tonic-gate  * Block until zone enters requested state or signal is received.  Return (0)
12007c478bd9Sstevel@tonic-gate  * if signaled, non-zero otherwise.
12017c478bd9Sstevel@tonic-gate  */
12027c478bd9Sstevel@tonic-gate int
12037c478bd9Sstevel@tonic-gate zone_status_wait_sig(zone_t *zone, zone_status_t status)
12047c478bd9Sstevel@tonic-gate {
12057c478bd9Sstevel@tonic-gate 	ASSERT(status > ZONE_MIN_STATE && status <= ZONE_MAX_STATE);
12067c478bd9Sstevel@tonic-gate 
12077c478bd9Sstevel@tonic-gate 	mutex_enter(&zone_status_lock);
12087c478bd9Sstevel@tonic-gate 	while (zone->zone_status < status) {
12097c478bd9Sstevel@tonic-gate 		if (!cv_wait_sig(&zone->zone_cv, &zone_status_lock)) {
12107c478bd9Sstevel@tonic-gate 			mutex_exit(&zone_status_lock);
12117c478bd9Sstevel@tonic-gate 			return (0);
12127c478bd9Sstevel@tonic-gate 		}
12137c478bd9Sstevel@tonic-gate 	}
12147c478bd9Sstevel@tonic-gate 	mutex_exit(&zone_status_lock);
12157c478bd9Sstevel@tonic-gate 	return (1);
12167c478bd9Sstevel@tonic-gate }
12177c478bd9Sstevel@tonic-gate 
12187c478bd9Sstevel@tonic-gate /*
12197c478bd9Sstevel@tonic-gate  * Block until the zone enters the requested state or the timeout expires,
12207c478bd9Sstevel@tonic-gate  * whichever happens first.  Return (-1) if operation timed out, time remaining
12217c478bd9Sstevel@tonic-gate  * otherwise.
12227c478bd9Sstevel@tonic-gate  */
12237c478bd9Sstevel@tonic-gate clock_t
12247c478bd9Sstevel@tonic-gate zone_status_timedwait(zone_t *zone, clock_t tim, zone_status_t status)
12257c478bd9Sstevel@tonic-gate {
12267c478bd9Sstevel@tonic-gate 	clock_t timeleft = 0;
12277c478bd9Sstevel@tonic-gate 
12287c478bd9Sstevel@tonic-gate 	ASSERT(status > ZONE_MIN_STATE && status <= ZONE_MAX_STATE);
12297c478bd9Sstevel@tonic-gate 
12307c478bd9Sstevel@tonic-gate 	mutex_enter(&zone_status_lock);
12317c478bd9Sstevel@tonic-gate 	while (zone->zone_status < status && timeleft != -1) {
12327c478bd9Sstevel@tonic-gate 		timeleft = cv_timedwait(&zone->zone_cv, &zone_status_lock, tim);
12337c478bd9Sstevel@tonic-gate 	}
12347c478bd9Sstevel@tonic-gate 	mutex_exit(&zone_status_lock);
12357c478bd9Sstevel@tonic-gate 	return (timeleft);
12367c478bd9Sstevel@tonic-gate }
12377c478bd9Sstevel@tonic-gate 
12387c478bd9Sstevel@tonic-gate /*
12397c478bd9Sstevel@tonic-gate  * Block until the zone enters the requested state, the current process is
12407c478bd9Sstevel@tonic-gate  * signaled,  or the timeout expires, whichever happens first.  Return (-1) if
12417c478bd9Sstevel@tonic-gate  * operation timed out, 0 if signaled, time remaining otherwise.
12427c478bd9Sstevel@tonic-gate  */
12437c478bd9Sstevel@tonic-gate clock_t
12447c478bd9Sstevel@tonic-gate zone_status_timedwait_sig(zone_t *zone, clock_t tim, zone_status_t status)
12457c478bd9Sstevel@tonic-gate {
12467c478bd9Sstevel@tonic-gate 	clock_t timeleft = tim - lbolt;
12477c478bd9Sstevel@tonic-gate 
12487c478bd9Sstevel@tonic-gate 	ASSERT(status > ZONE_MIN_STATE && status <= ZONE_MAX_STATE);
12497c478bd9Sstevel@tonic-gate 
12507c478bd9Sstevel@tonic-gate 	mutex_enter(&zone_status_lock);
12517c478bd9Sstevel@tonic-gate 	while (zone->zone_status < status) {
12527c478bd9Sstevel@tonic-gate 		timeleft = cv_timedwait_sig(&zone->zone_cv, &zone_status_lock,
12537c478bd9Sstevel@tonic-gate 		    tim);
12547c478bd9Sstevel@tonic-gate 		if (timeleft <= 0)
12557c478bd9Sstevel@tonic-gate 			break;
12567c478bd9Sstevel@tonic-gate 	}
12577c478bd9Sstevel@tonic-gate 	mutex_exit(&zone_status_lock);
12587c478bd9Sstevel@tonic-gate 	return (timeleft);
12597c478bd9Sstevel@tonic-gate }
12607c478bd9Sstevel@tonic-gate 
12617c478bd9Sstevel@tonic-gate /*
12627c478bd9Sstevel@tonic-gate  * Zones have two reference counts: one for references from credential
12637c478bd9Sstevel@tonic-gate  * structures (zone_cred_ref), and one (zone_ref) for everything else.
12647c478bd9Sstevel@tonic-gate  * This is so we can allow a zone to be rebooted while there are still
12657c478bd9Sstevel@tonic-gate  * outstanding cred references, since certain drivers cache dblks (which
12667c478bd9Sstevel@tonic-gate  * implicitly results in cached creds).  We wait for zone_ref to drop to
12677c478bd9Sstevel@tonic-gate  * 0 (actually 1), but not zone_cred_ref.  The zone structure itself is
12687c478bd9Sstevel@tonic-gate  * later freed when the zone_cred_ref drops to 0, though nothing other
12697c478bd9Sstevel@tonic-gate  * than the zone id and privilege set should be accessed once the zone
12707c478bd9Sstevel@tonic-gate  * is "dead".
12717c478bd9Sstevel@tonic-gate  *
12727c478bd9Sstevel@tonic-gate  * A debugging flag, zone_wait_for_cred, can be set to a non-zero value
12737c478bd9Sstevel@tonic-gate  * to force halt/reboot to block waiting for the zone_cred_ref to drop
12747c478bd9Sstevel@tonic-gate  * to 0.  This can be useful to flush out other sources of cached creds
12757c478bd9Sstevel@tonic-gate  * that may be less innocuous than the driver case.
12767c478bd9Sstevel@tonic-gate  */
12777c478bd9Sstevel@tonic-gate 
12787c478bd9Sstevel@tonic-gate int zone_wait_for_cred = 0;
12797c478bd9Sstevel@tonic-gate 
12807c478bd9Sstevel@tonic-gate static void
12817c478bd9Sstevel@tonic-gate zone_hold_locked(zone_t *z)
12827c478bd9Sstevel@tonic-gate {
12837c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&z->zone_lock));
12847c478bd9Sstevel@tonic-gate 	z->zone_ref++;
12857c478bd9Sstevel@tonic-gate 	ASSERT(z->zone_ref != 0);
12867c478bd9Sstevel@tonic-gate }
12877c478bd9Sstevel@tonic-gate 
12887c478bd9Sstevel@tonic-gate void
12897c478bd9Sstevel@tonic-gate zone_hold(zone_t *z)
12907c478bd9Sstevel@tonic-gate {
12917c478bd9Sstevel@tonic-gate 	mutex_enter(&z->zone_lock);
12927c478bd9Sstevel@tonic-gate 	zone_hold_locked(z);
12937c478bd9Sstevel@tonic-gate 	mutex_exit(&z->zone_lock);
12947c478bd9Sstevel@tonic-gate }
12957c478bd9Sstevel@tonic-gate 
12967c478bd9Sstevel@tonic-gate /*
12977c478bd9Sstevel@tonic-gate  * If the non-cred ref count drops to 1 and either the cred ref count
12987c478bd9Sstevel@tonic-gate  * is 0 or we aren't waiting for cred references, the zone is ready to
12997c478bd9Sstevel@tonic-gate  * be destroyed.
13007c478bd9Sstevel@tonic-gate  */
13017c478bd9Sstevel@tonic-gate #define	ZONE_IS_UNREF(zone)	((zone)->zone_ref == 1 && \
13027c478bd9Sstevel@tonic-gate 	    (!zone_wait_for_cred || (zone)->zone_cred_ref == 0))
13037c478bd9Sstevel@tonic-gate 
13047c478bd9Sstevel@tonic-gate void
13057c478bd9Sstevel@tonic-gate zone_rele(zone_t *z)
13067c478bd9Sstevel@tonic-gate {
13077c478bd9Sstevel@tonic-gate 	boolean_t wakeup;
13087c478bd9Sstevel@tonic-gate 
13097c478bd9Sstevel@tonic-gate 	mutex_enter(&z->zone_lock);
13107c478bd9Sstevel@tonic-gate 	ASSERT(z->zone_ref != 0);
13117c478bd9Sstevel@tonic-gate 	z->zone_ref--;
13127c478bd9Sstevel@tonic-gate 	if (z->zone_ref == 0 && z->zone_cred_ref == 0) {
13137c478bd9Sstevel@tonic-gate 		/* no more refs, free the structure */
13147c478bd9Sstevel@tonic-gate 		mutex_exit(&z->zone_lock);
13157c478bd9Sstevel@tonic-gate 		zone_free(z);
13167c478bd9Sstevel@tonic-gate 		return;
13177c478bd9Sstevel@tonic-gate 	}
13187c478bd9Sstevel@tonic-gate 	/* signal zone_destroy so the zone can finish halting */
13197c478bd9Sstevel@tonic-gate 	wakeup = (ZONE_IS_UNREF(z) && zone_status_get(z) >= ZONE_IS_DEAD);
13207c478bd9Sstevel@tonic-gate 	mutex_exit(&z->zone_lock);
13217c478bd9Sstevel@tonic-gate 
13227c478bd9Sstevel@tonic-gate 	if (wakeup) {
13237c478bd9Sstevel@tonic-gate 		/*
13247c478bd9Sstevel@tonic-gate 		 * Grabbing zonehash_lock here effectively synchronizes with
13257c478bd9Sstevel@tonic-gate 		 * zone_destroy() to avoid missed signals.
13267c478bd9Sstevel@tonic-gate 		 */
13277c478bd9Sstevel@tonic-gate 		mutex_enter(&zonehash_lock);
13287c478bd9Sstevel@tonic-gate 		cv_broadcast(&zone_destroy_cv);
13297c478bd9Sstevel@tonic-gate 		mutex_exit(&zonehash_lock);
13307c478bd9Sstevel@tonic-gate 	}
13317c478bd9Sstevel@tonic-gate }
13327c478bd9Sstevel@tonic-gate 
13337c478bd9Sstevel@tonic-gate void
13347c478bd9Sstevel@tonic-gate zone_cred_hold(zone_t *z)
13357c478bd9Sstevel@tonic-gate {
13367c478bd9Sstevel@tonic-gate 	mutex_enter(&z->zone_lock);
13377c478bd9Sstevel@tonic-gate 	z->zone_cred_ref++;
13387c478bd9Sstevel@tonic-gate 	ASSERT(z->zone_cred_ref != 0);
13397c478bd9Sstevel@tonic-gate 	mutex_exit(&z->zone_lock);
13407c478bd9Sstevel@tonic-gate }
13417c478bd9Sstevel@tonic-gate 
13427c478bd9Sstevel@tonic-gate void
13437c478bd9Sstevel@tonic-gate zone_cred_rele(zone_t *z)
13447c478bd9Sstevel@tonic-gate {
13457c478bd9Sstevel@tonic-gate 	boolean_t wakeup;
13467c478bd9Sstevel@tonic-gate 
13477c478bd9Sstevel@tonic-gate 	mutex_enter(&z->zone_lock);
13487c478bd9Sstevel@tonic-gate 	ASSERT(z->zone_cred_ref != 0);
13497c478bd9Sstevel@tonic-gate 	z->zone_cred_ref--;
13507c478bd9Sstevel@tonic-gate 	if (z->zone_ref == 0 && z->zone_cred_ref == 0) {
13517c478bd9Sstevel@tonic-gate 		/* no more refs, free the structure */
13527c478bd9Sstevel@tonic-gate 		mutex_exit(&z->zone_lock);
13537c478bd9Sstevel@tonic-gate 		zone_free(z);
13547c478bd9Sstevel@tonic-gate 		return;
13557c478bd9Sstevel@tonic-gate 	}
13567c478bd9Sstevel@tonic-gate 	/*
13577c478bd9Sstevel@tonic-gate 	 * If zone_destroy is waiting for the cred references to drain
13587c478bd9Sstevel@tonic-gate 	 * out, and they have, signal it.
13597c478bd9Sstevel@tonic-gate 	 */
13607c478bd9Sstevel@tonic-gate 	wakeup = (zone_wait_for_cred && ZONE_IS_UNREF(z) &&
13617c478bd9Sstevel@tonic-gate 	    zone_status_get(z) >= ZONE_IS_DEAD);
13627c478bd9Sstevel@tonic-gate 	mutex_exit(&z->zone_lock);
13637c478bd9Sstevel@tonic-gate 
13647c478bd9Sstevel@tonic-gate 	if (wakeup) {
13657c478bd9Sstevel@tonic-gate 		/*
13667c478bd9Sstevel@tonic-gate 		 * Grabbing zonehash_lock here effectively synchronizes with
13677c478bd9Sstevel@tonic-gate 		 * zone_destroy() to avoid missed signals.
13687c478bd9Sstevel@tonic-gate 		 */
13697c478bd9Sstevel@tonic-gate 		mutex_enter(&zonehash_lock);
13707c478bd9Sstevel@tonic-gate 		cv_broadcast(&zone_destroy_cv);
13717c478bd9Sstevel@tonic-gate 		mutex_exit(&zonehash_lock);
13727c478bd9Sstevel@tonic-gate 	}
13737c478bd9Sstevel@tonic-gate }
13747c478bd9Sstevel@tonic-gate 
13757c478bd9Sstevel@tonic-gate void
13767c478bd9Sstevel@tonic-gate zone_task_hold(zone_t *z)
13777c478bd9Sstevel@tonic-gate {
13787c478bd9Sstevel@tonic-gate 	mutex_enter(&z->zone_lock);
13797c478bd9Sstevel@tonic-gate 	z->zone_ntasks++;
13807c478bd9Sstevel@tonic-gate 	ASSERT(z->zone_ntasks != 0);
13817c478bd9Sstevel@tonic-gate 	mutex_exit(&z->zone_lock);
13827c478bd9Sstevel@tonic-gate }
13837c478bd9Sstevel@tonic-gate 
13847c478bd9Sstevel@tonic-gate void
13857c478bd9Sstevel@tonic-gate zone_task_rele(zone_t *zone)
13867c478bd9Sstevel@tonic-gate {
13877c478bd9Sstevel@tonic-gate 	uint_t refcnt;
13887c478bd9Sstevel@tonic-gate 
13897c478bd9Sstevel@tonic-gate 	mutex_enter(&zone->zone_lock);
13907c478bd9Sstevel@tonic-gate 	ASSERT(zone->zone_ntasks != 0);
13917c478bd9Sstevel@tonic-gate 	refcnt = --zone->zone_ntasks;
13927c478bd9Sstevel@tonic-gate 	if (refcnt > 1)	{	/* Common case */
13937c478bd9Sstevel@tonic-gate 		mutex_exit(&zone->zone_lock);
13947c478bd9Sstevel@tonic-gate 		return;
13957c478bd9Sstevel@tonic-gate 	}
13967c478bd9Sstevel@tonic-gate 	zone_hold_locked(zone);	/* so we can use the zone_t later */
13977c478bd9Sstevel@tonic-gate 	mutex_exit(&zone->zone_lock);
13987c478bd9Sstevel@tonic-gate 	if (refcnt == 1) {
13997c478bd9Sstevel@tonic-gate 		/*
14007c478bd9Sstevel@tonic-gate 		 * See if the zone is shutting down.
14017c478bd9Sstevel@tonic-gate 		 */
14027c478bd9Sstevel@tonic-gate 		mutex_enter(&zone_status_lock);
14037c478bd9Sstevel@tonic-gate 		if (zone_status_get(zone) != ZONE_IS_SHUTTING_DOWN) {
14047c478bd9Sstevel@tonic-gate 			goto out;
14057c478bd9Sstevel@tonic-gate 		}
14067c478bd9Sstevel@tonic-gate 
14077c478bd9Sstevel@tonic-gate 		/*
14087c478bd9Sstevel@tonic-gate 		 * Make sure the ntasks didn't change since we
14097c478bd9Sstevel@tonic-gate 		 * dropped zone_lock.
14107c478bd9Sstevel@tonic-gate 		 */
14117c478bd9Sstevel@tonic-gate 		mutex_enter(&zone->zone_lock);
14127c478bd9Sstevel@tonic-gate 		if (refcnt != zone->zone_ntasks) {
14137c478bd9Sstevel@tonic-gate 			mutex_exit(&zone->zone_lock);
14147c478bd9Sstevel@tonic-gate 			goto out;
14157c478bd9Sstevel@tonic-gate 		}
14167c478bd9Sstevel@tonic-gate 		mutex_exit(&zone->zone_lock);
14177c478bd9Sstevel@tonic-gate 
14187c478bd9Sstevel@tonic-gate 		/*
14197c478bd9Sstevel@tonic-gate 		 * No more user processes in the zone.  The zone is empty.
14207c478bd9Sstevel@tonic-gate 		 */
14217c478bd9Sstevel@tonic-gate 		zone_status_set(zone, ZONE_IS_EMPTY);
14227c478bd9Sstevel@tonic-gate 		goto out;
14237c478bd9Sstevel@tonic-gate 	}
14247c478bd9Sstevel@tonic-gate 
14257c478bd9Sstevel@tonic-gate 	ASSERT(refcnt == 0);
14267c478bd9Sstevel@tonic-gate 	/*
14277c478bd9Sstevel@tonic-gate 	 * zsched has exited; the zone is dead.
14287c478bd9Sstevel@tonic-gate 	 */
14297c478bd9Sstevel@tonic-gate 	zone->zone_zsched = NULL;		/* paranoia */
14307c478bd9Sstevel@tonic-gate 	mutex_enter(&zone_status_lock);
14317c478bd9Sstevel@tonic-gate 	zone_status_set(zone, ZONE_IS_DEAD);
14327c478bd9Sstevel@tonic-gate out:
14337c478bd9Sstevel@tonic-gate 	mutex_exit(&zone_status_lock);
14347c478bd9Sstevel@tonic-gate 	zone_rele(zone);
14357c478bd9Sstevel@tonic-gate }
14367c478bd9Sstevel@tonic-gate 
14377c478bd9Sstevel@tonic-gate zoneid_t
14387c478bd9Sstevel@tonic-gate getzoneid(void)
14397c478bd9Sstevel@tonic-gate {
14407c478bd9Sstevel@tonic-gate 	return (curproc->p_zone->zone_id);
14417c478bd9Sstevel@tonic-gate }
14427c478bd9Sstevel@tonic-gate 
14437c478bd9Sstevel@tonic-gate /*
14447c478bd9Sstevel@tonic-gate  * Internal versions of zone_find_by_*().  These don't zone_hold() or
14457c478bd9Sstevel@tonic-gate  * check the validity of a zone's state.
14467c478bd9Sstevel@tonic-gate  */
14477c478bd9Sstevel@tonic-gate static zone_t *
14487c478bd9Sstevel@tonic-gate zone_find_all_by_id(zoneid_t zoneid)
14497c478bd9Sstevel@tonic-gate {
14507c478bd9Sstevel@tonic-gate 	mod_hash_val_t hv;
14517c478bd9Sstevel@tonic-gate 	zone_t *zone = NULL;
14527c478bd9Sstevel@tonic-gate 
14537c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&zonehash_lock));
14547c478bd9Sstevel@tonic-gate 
14557c478bd9Sstevel@tonic-gate 	if (mod_hash_find(zonehashbyid,
14567c478bd9Sstevel@tonic-gate 	    (mod_hash_key_t)(uintptr_t)zoneid, &hv) == 0)
14577c478bd9Sstevel@tonic-gate 		zone = (zone_t *)hv;
14587c478bd9Sstevel@tonic-gate 	return (zone);
14597c478bd9Sstevel@tonic-gate }
14607c478bd9Sstevel@tonic-gate 
14617c478bd9Sstevel@tonic-gate static zone_t *
14627c478bd9Sstevel@tonic-gate zone_find_all_by_name(char *name)
14637c478bd9Sstevel@tonic-gate {
14647c478bd9Sstevel@tonic-gate 	mod_hash_val_t hv;
14657c478bd9Sstevel@tonic-gate 	zone_t *zone = NULL;
14667c478bd9Sstevel@tonic-gate 
14677c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&zonehash_lock));
14687c478bd9Sstevel@tonic-gate 
14697c478bd9Sstevel@tonic-gate 	if (mod_hash_find(zonehashbyname, (mod_hash_key_t)name, &hv) == 0)
14707c478bd9Sstevel@tonic-gate 		zone = (zone_t *)hv;
14717c478bd9Sstevel@tonic-gate 	return (zone);
14727c478bd9Sstevel@tonic-gate }
14737c478bd9Sstevel@tonic-gate 
14747c478bd9Sstevel@tonic-gate /*
14757c478bd9Sstevel@tonic-gate  * Public interface for looking up a zone by zoneid.  Only returns the zone if
14767c478bd9Sstevel@tonic-gate  * it is fully initialized, and has not yet begun the zone_destroy() sequence.
14777c478bd9Sstevel@tonic-gate  * Caller must call zone_rele() once it is done with the zone.
14787c478bd9Sstevel@tonic-gate  *
14797c478bd9Sstevel@tonic-gate  * The zone may begin the zone_destroy() sequence immediately after this
14807c478bd9Sstevel@tonic-gate  * function returns, but may be safely used until zone_rele() is called.
14817c478bd9Sstevel@tonic-gate  */
14827c478bd9Sstevel@tonic-gate zone_t *
14837c478bd9Sstevel@tonic-gate zone_find_by_id(zoneid_t zoneid)
14847c478bd9Sstevel@tonic-gate {
14857c478bd9Sstevel@tonic-gate 	zone_t *zone;
14867c478bd9Sstevel@tonic-gate 	zone_status_t status;
14877c478bd9Sstevel@tonic-gate 
14887c478bd9Sstevel@tonic-gate 	mutex_enter(&zonehash_lock);
14897c478bd9Sstevel@tonic-gate 	if ((zone = zone_find_all_by_id(zoneid)) == NULL) {
14907c478bd9Sstevel@tonic-gate 		mutex_exit(&zonehash_lock);
14917c478bd9Sstevel@tonic-gate 		return (NULL);
14927c478bd9Sstevel@tonic-gate 	}
14937c478bd9Sstevel@tonic-gate 	status = zone_status_get(zone);
14947c478bd9Sstevel@tonic-gate 	if (status < ZONE_IS_READY || status > ZONE_IS_DOWN) {
14957c478bd9Sstevel@tonic-gate 		/*
14967c478bd9Sstevel@tonic-gate 		 * For all practical purposes the zone doesn't exist.
14977c478bd9Sstevel@tonic-gate 		 */
14987c478bd9Sstevel@tonic-gate 		mutex_exit(&zonehash_lock);
14997c478bd9Sstevel@tonic-gate 		return (NULL);
15007c478bd9Sstevel@tonic-gate 	}
15017c478bd9Sstevel@tonic-gate 	zone_hold(zone);
15027c478bd9Sstevel@tonic-gate 	mutex_exit(&zonehash_lock);
15037c478bd9Sstevel@tonic-gate 	return (zone);
15047c478bd9Sstevel@tonic-gate }
15057c478bd9Sstevel@tonic-gate 
15067c478bd9Sstevel@tonic-gate /*
15077c478bd9Sstevel@tonic-gate  * Similar to zone_find_by_id, but using zone name as the key.
15087c478bd9Sstevel@tonic-gate  */
15097c478bd9Sstevel@tonic-gate zone_t *
15107c478bd9Sstevel@tonic-gate zone_find_by_name(char *name)
15117c478bd9Sstevel@tonic-gate {
15127c478bd9Sstevel@tonic-gate 	zone_t *zone;
15137c478bd9Sstevel@tonic-gate 	zone_status_t status;
15147c478bd9Sstevel@tonic-gate 
15157c478bd9Sstevel@tonic-gate 	mutex_enter(&zonehash_lock);
15167c478bd9Sstevel@tonic-gate 	if ((zone = zone_find_all_by_name(name)) == NULL) {
15177c478bd9Sstevel@tonic-gate 		mutex_exit(&zonehash_lock);
15187c478bd9Sstevel@tonic-gate 		return (NULL);
15197c478bd9Sstevel@tonic-gate 	}
15207c478bd9Sstevel@tonic-gate 	status = zone_status_get(zone);
15217c478bd9Sstevel@tonic-gate 	if (status < ZONE_IS_READY || status > ZONE_IS_DOWN) {
15227c478bd9Sstevel@tonic-gate 		/*
15237c478bd9Sstevel@tonic-gate 		 * For all practical purposes the zone doesn't exist.
15247c478bd9Sstevel@tonic-gate 		 */
15257c478bd9Sstevel@tonic-gate 		mutex_exit(&zonehash_lock);
15267c478bd9Sstevel@tonic-gate 		return (NULL);
15277c478bd9Sstevel@tonic-gate 	}
15287c478bd9Sstevel@tonic-gate 	zone_hold(zone);
15297c478bd9Sstevel@tonic-gate 	mutex_exit(&zonehash_lock);
15307c478bd9Sstevel@tonic-gate 	return (zone);
15317c478bd9Sstevel@tonic-gate }
15327c478bd9Sstevel@tonic-gate 
15337c478bd9Sstevel@tonic-gate /*
15347c478bd9Sstevel@tonic-gate  * Similar to zone_find_by_id(), using the path as a key.  For instance,
15357c478bd9Sstevel@tonic-gate  * if there is a zone "foo" rooted at /foo/root, and the path argument
15367c478bd9Sstevel@tonic-gate  * is "/foo/root/proc", it will return the held zone_t corresponding to
15377c478bd9Sstevel@tonic-gate  * zone "foo".
15387c478bd9Sstevel@tonic-gate  *
15397c478bd9Sstevel@tonic-gate  * zone_find_by_path() always returns a non-NULL value, since at the
15407c478bd9Sstevel@tonic-gate  * very least every path will be contained in the global zone.
15417c478bd9Sstevel@tonic-gate  *
15427c478bd9Sstevel@tonic-gate  * As with the other zone_find_by_*() functions, the caller is
15437c478bd9Sstevel@tonic-gate  * responsible for zone_rele()ing the return value of this function.
15447c478bd9Sstevel@tonic-gate  */
15457c478bd9Sstevel@tonic-gate zone_t *
15467c478bd9Sstevel@tonic-gate zone_find_by_path(const char *path)
15477c478bd9Sstevel@tonic-gate {
15487c478bd9Sstevel@tonic-gate 	zone_t *zone;
15497c478bd9Sstevel@tonic-gate 	zone_t *zret = NULL;
15507c478bd9Sstevel@tonic-gate 	zone_status_t status;
15517c478bd9Sstevel@tonic-gate 
15527c478bd9Sstevel@tonic-gate 	if (path == NULL) {
15537c478bd9Sstevel@tonic-gate 		/*
15547c478bd9Sstevel@tonic-gate 		 * Call from rootconf().
15557c478bd9Sstevel@tonic-gate 		 */
15567c478bd9Sstevel@tonic-gate 		zone_hold(global_zone);
15577c478bd9Sstevel@tonic-gate 		return (global_zone);
15587c478bd9Sstevel@tonic-gate 	}
15597c478bd9Sstevel@tonic-gate 	ASSERT(*path == '/');
15607c478bd9Sstevel@tonic-gate 	mutex_enter(&zonehash_lock);
15617c478bd9Sstevel@tonic-gate 	for (zone = list_head(&zone_active); zone != NULL;
15627c478bd9Sstevel@tonic-gate 	    zone = list_next(&zone_active, zone)) {
15637c478bd9Sstevel@tonic-gate 		if (ZONE_PATH_VISIBLE(path, zone))
15647c478bd9Sstevel@tonic-gate 			zret = zone;
15657c478bd9Sstevel@tonic-gate 	}
15667c478bd9Sstevel@tonic-gate 	ASSERT(zret != NULL);
15677c478bd9Sstevel@tonic-gate 	status = zone_status_get(zret);
15687c478bd9Sstevel@tonic-gate 	if (status < ZONE_IS_READY || status > ZONE_IS_DOWN) {
15697c478bd9Sstevel@tonic-gate 		/*
15707c478bd9Sstevel@tonic-gate 		 * Zone practically doesn't exist.
15717c478bd9Sstevel@tonic-gate 		 */
15727c478bd9Sstevel@tonic-gate 		zret = global_zone;
15737c478bd9Sstevel@tonic-gate 	}
15747c478bd9Sstevel@tonic-gate 	zone_hold(zret);
15757c478bd9Sstevel@tonic-gate 	mutex_exit(&zonehash_lock);
15767c478bd9Sstevel@tonic-gate 	return (zret);
15777c478bd9Sstevel@tonic-gate }
15787c478bd9Sstevel@tonic-gate 
15797c478bd9Sstevel@tonic-gate /*
15807c478bd9Sstevel@tonic-gate  * Get the number of cpus visible to this zone.  The system-wide global
15817c478bd9Sstevel@tonic-gate  * 'ncpus' is returned if pools are disabled, the caller is in the
15827c478bd9Sstevel@tonic-gate  * global zone, or a NULL zone argument is passed in.
15837c478bd9Sstevel@tonic-gate  */
15847c478bd9Sstevel@tonic-gate int
15857c478bd9Sstevel@tonic-gate zone_ncpus_get(zone_t *zone)
15867c478bd9Sstevel@tonic-gate {
15877c478bd9Sstevel@tonic-gate 	int myncpus = zone == NULL ? 0 : zone->zone_ncpus;
15887c478bd9Sstevel@tonic-gate 
15897c478bd9Sstevel@tonic-gate 	return (myncpus != 0 ? myncpus : ncpus);
15907c478bd9Sstevel@tonic-gate }
15917c478bd9Sstevel@tonic-gate 
15927c478bd9Sstevel@tonic-gate /*
15937c478bd9Sstevel@tonic-gate  * Get the number of online cpus visible to this zone.  The system-wide
15947c478bd9Sstevel@tonic-gate  * global 'ncpus_online' is returned if pools are disabled, the caller
15957c478bd9Sstevel@tonic-gate  * is in the global zone, or a NULL zone argument is passed in.
15967c478bd9Sstevel@tonic-gate  */
15977c478bd9Sstevel@tonic-gate int
15987c478bd9Sstevel@tonic-gate zone_ncpus_online_get(zone_t *zone)
15997c478bd9Sstevel@tonic-gate {
16007c478bd9Sstevel@tonic-gate 	int myncpus_online = zone == NULL ? 0 : zone->zone_ncpus_online;
16017c478bd9Sstevel@tonic-gate 
16027c478bd9Sstevel@tonic-gate 	return (myncpus_online != 0 ? myncpus_online : ncpus_online);
16037c478bd9Sstevel@tonic-gate }
16047c478bd9Sstevel@tonic-gate 
16057c478bd9Sstevel@tonic-gate /*
16067c478bd9Sstevel@tonic-gate  * Return the pool to which the zone is currently bound.
16077c478bd9Sstevel@tonic-gate  */
16087c478bd9Sstevel@tonic-gate pool_t *
16097c478bd9Sstevel@tonic-gate zone_pool_get(zone_t *zone)
16107c478bd9Sstevel@tonic-gate {
16117c478bd9Sstevel@tonic-gate 	ASSERT(pool_lock_held());
16127c478bd9Sstevel@tonic-gate 
16137c478bd9Sstevel@tonic-gate 	return (zone->zone_pool);
16147c478bd9Sstevel@tonic-gate }
16157c478bd9Sstevel@tonic-gate 
16167c478bd9Sstevel@tonic-gate /*
16177c478bd9Sstevel@tonic-gate  * Set the zone's pool pointer and update the zone's visibility to match
16187c478bd9Sstevel@tonic-gate  * the resources in the new pool.
16197c478bd9Sstevel@tonic-gate  */
16207c478bd9Sstevel@tonic-gate void
16217c478bd9Sstevel@tonic-gate zone_pool_set(zone_t *zone, pool_t *pool)
16227c478bd9Sstevel@tonic-gate {
16237c478bd9Sstevel@tonic-gate 	ASSERT(pool_lock_held());
16247c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&cpu_lock));
16257c478bd9Sstevel@tonic-gate 
16267c478bd9Sstevel@tonic-gate 	zone->zone_pool = pool;
16277c478bd9Sstevel@tonic-gate 	zone_pset_set(zone, pool->pool_pset->pset_id);
16287c478bd9Sstevel@tonic-gate }
16297c478bd9Sstevel@tonic-gate 
16307c478bd9Sstevel@tonic-gate /*
16317c478bd9Sstevel@tonic-gate  * Return the cached value of the id of the processor set to which the
16327c478bd9Sstevel@tonic-gate  * zone is currently bound.  The value will be ZONE_PS_INVAL if the pools
16337c478bd9Sstevel@tonic-gate  * facility is disabled.
16347c478bd9Sstevel@tonic-gate  */
16357c478bd9Sstevel@tonic-gate psetid_t
16367c478bd9Sstevel@tonic-gate zone_pset_get(zone_t *zone)
16377c478bd9Sstevel@tonic-gate {
16387c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&cpu_lock));
16397c478bd9Sstevel@tonic-gate 
16407c478bd9Sstevel@tonic-gate 	return (zone->zone_psetid);
16417c478bd9Sstevel@tonic-gate }
16427c478bd9Sstevel@tonic-gate 
16437c478bd9Sstevel@tonic-gate /*
16447c478bd9Sstevel@tonic-gate  * Set the cached value of the id of the processor set to which the zone
16457c478bd9Sstevel@tonic-gate  * is currently bound.  Also update the zone's visibility to match the
16467c478bd9Sstevel@tonic-gate  * resources in the new processor set.
16477c478bd9Sstevel@tonic-gate  */
16487c478bd9Sstevel@tonic-gate void
16497c478bd9Sstevel@tonic-gate zone_pset_set(zone_t *zone, psetid_t newpsetid)
16507c478bd9Sstevel@tonic-gate {
16517c478bd9Sstevel@tonic-gate 	psetid_t oldpsetid;
16527c478bd9Sstevel@tonic-gate 
16537c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&cpu_lock));
16547c478bd9Sstevel@tonic-gate 	oldpsetid = zone_pset_get(zone);
16557c478bd9Sstevel@tonic-gate 
16567c478bd9Sstevel@tonic-gate 	if (oldpsetid == newpsetid)
16577c478bd9Sstevel@tonic-gate 		return;
16587c478bd9Sstevel@tonic-gate 	/*
16597c478bd9Sstevel@tonic-gate 	 * Global zone sees all.
16607c478bd9Sstevel@tonic-gate 	 */
16617c478bd9Sstevel@tonic-gate 	if (zone != global_zone) {
16627c478bd9Sstevel@tonic-gate 		zone->zone_psetid = newpsetid;
16637c478bd9Sstevel@tonic-gate 		if (newpsetid != ZONE_PS_INVAL)
16647c478bd9Sstevel@tonic-gate 			pool_pset_visibility_add(newpsetid, zone);
16657c478bd9Sstevel@tonic-gate 		if (oldpsetid != ZONE_PS_INVAL)
16667c478bd9Sstevel@tonic-gate 			pool_pset_visibility_remove(oldpsetid, zone);
16677c478bd9Sstevel@tonic-gate 	}
16687c478bd9Sstevel@tonic-gate 	/*
16697c478bd9Sstevel@tonic-gate 	 * Disabling pools, so we should start using the global values
16707c478bd9Sstevel@tonic-gate 	 * for ncpus and ncpus_online.
16717c478bd9Sstevel@tonic-gate 	 */
16727c478bd9Sstevel@tonic-gate 	if (newpsetid == ZONE_PS_INVAL) {
16737c478bd9Sstevel@tonic-gate 		zone->zone_ncpus = 0;
16747c478bd9Sstevel@tonic-gate 		zone->zone_ncpus_online = 0;
16757c478bd9Sstevel@tonic-gate 	}
16767c478bd9Sstevel@tonic-gate }
16777c478bd9Sstevel@tonic-gate 
16787c478bd9Sstevel@tonic-gate /*
16797c478bd9Sstevel@tonic-gate  * Walk the list of active zones and issue the provided callback for
16807c478bd9Sstevel@tonic-gate  * each of them.
16817c478bd9Sstevel@tonic-gate  *
16827c478bd9Sstevel@tonic-gate  * Caller must not be holding any locks that may be acquired under
16837c478bd9Sstevel@tonic-gate  * zonehash_lock.  See comment at the beginning of the file for a list of
16847c478bd9Sstevel@tonic-gate  * common locks and their interactions with zones.
16857c478bd9Sstevel@tonic-gate  */
16867c478bd9Sstevel@tonic-gate int
16877c478bd9Sstevel@tonic-gate zone_walk(int (*cb)(zone_t *, void *), void *data)
16887c478bd9Sstevel@tonic-gate {
16897c478bd9Sstevel@tonic-gate 	zone_t *zone;
16907c478bd9Sstevel@tonic-gate 	int ret = 0;
16917c478bd9Sstevel@tonic-gate 	zone_status_t status;
16927c478bd9Sstevel@tonic-gate 
16937c478bd9Sstevel@tonic-gate 	mutex_enter(&zonehash_lock);
16947c478bd9Sstevel@tonic-gate 	for (zone = list_head(&zone_active); zone != NULL;
16957c478bd9Sstevel@tonic-gate 	    zone = list_next(&zone_active, zone)) {
16967c478bd9Sstevel@tonic-gate 		/*
16977c478bd9Sstevel@tonic-gate 		 * Skip zones that shouldn't be externally visible.
16987c478bd9Sstevel@tonic-gate 		 */
16997c478bd9Sstevel@tonic-gate 		status = zone_status_get(zone);
17007c478bd9Sstevel@tonic-gate 		if (status < ZONE_IS_READY || status > ZONE_IS_DOWN)
17017c478bd9Sstevel@tonic-gate 			continue;
17027c478bd9Sstevel@tonic-gate 		/*
17037c478bd9Sstevel@tonic-gate 		 * Bail immediately if any callback invocation returns a
17047c478bd9Sstevel@tonic-gate 		 * non-zero value.
17057c478bd9Sstevel@tonic-gate 		 */
17067c478bd9Sstevel@tonic-gate 		ret = (*cb)(zone, data);
17077c478bd9Sstevel@tonic-gate 		if (ret != 0)
17087c478bd9Sstevel@tonic-gate 			break;
17097c478bd9Sstevel@tonic-gate 	}
17107c478bd9Sstevel@tonic-gate 	mutex_exit(&zonehash_lock);
17117c478bd9Sstevel@tonic-gate 	return (ret);
17127c478bd9Sstevel@tonic-gate }
17137c478bd9Sstevel@tonic-gate 
17147c478bd9Sstevel@tonic-gate static int
17157c478bd9Sstevel@tonic-gate zone_set_root(zone_t *zone, const char *upath)
17167c478bd9Sstevel@tonic-gate {
17177c478bd9Sstevel@tonic-gate 	vnode_t *vp;
17187c478bd9Sstevel@tonic-gate 	int trycount;
17197c478bd9Sstevel@tonic-gate 	int error = 0;
17207c478bd9Sstevel@tonic-gate 	char *path;
17217c478bd9Sstevel@tonic-gate 	struct pathname upn, pn;
17227c478bd9Sstevel@tonic-gate 	size_t pathlen;
17237c478bd9Sstevel@tonic-gate 
17247c478bd9Sstevel@tonic-gate 	if ((error = pn_get((char *)upath, UIO_USERSPACE, &upn)) != 0)
17257c478bd9Sstevel@tonic-gate 		return (error);
17267c478bd9Sstevel@tonic-gate 
17277c478bd9Sstevel@tonic-gate 	pn_alloc(&pn);
17287c478bd9Sstevel@tonic-gate 
17297c478bd9Sstevel@tonic-gate 	/* prevent infinite loop */
17307c478bd9Sstevel@tonic-gate 	trycount = 10;
17317c478bd9Sstevel@tonic-gate 	for (;;) {
17327c478bd9Sstevel@tonic-gate 		if (--trycount <= 0) {
17337c478bd9Sstevel@tonic-gate 			error = ESTALE;
17347c478bd9Sstevel@tonic-gate 			goto out;
17357c478bd9Sstevel@tonic-gate 		}
17367c478bd9Sstevel@tonic-gate 
17377c478bd9Sstevel@tonic-gate 		if ((error = lookuppn(&upn, &pn, FOLLOW, NULLVPP, &vp)) == 0) {
17387c478bd9Sstevel@tonic-gate 			/*
17397c478bd9Sstevel@tonic-gate 			 * VOP_ACCESS() may cover 'vp' with a new
17407c478bd9Sstevel@tonic-gate 			 * filesystem, if 'vp' is an autoFS vnode.
17417c478bd9Sstevel@tonic-gate 			 * Get the new 'vp' if so.
17427c478bd9Sstevel@tonic-gate 			 */
17437c478bd9Sstevel@tonic-gate 			if ((error = VOP_ACCESS(vp, VEXEC, 0, CRED())) == 0 &&
17447c478bd9Sstevel@tonic-gate 			    (vp->v_vfsmountedhere == NULL ||
17457c478bd9Sstevel@tonic-gate 			    (error = traverse(&vp)) == 0)) {
17467c478bd9Sstevel@tonic-gate 				pathlen = pn.pn_pathlen + 2;
17477c478bd9Sstevel@tonic-gate 				path = kmem_alloc(pathlen, KM_SLEEP);
17487c478bd9Sstevel@tonic-gate 				(void) strncpy(path, pn.pn_path,
17497c478bd9Sstevel@tonic-gate 				    pn.pn_pathlen + 1);
17507c478bd9Sstevel@tonic-gate 				path[pathlen - 2] = '/';
17517c478bd9Sstevel@tonic-gate 				path[pathlen - 1] = '\0';
17527c478bd9Sstevel@tonic-gate 				pn_free(&pn);
17537c478bd9Sstevel@tonic-gate 				pn_free(&upn);
17547c478bd9Sstevel@tonic-gate 
17557c478bd9Sstevel@tonic-gate 				/* Success! */
17567c478bd9Sstevel@tonic-gate 				break;
17577c478bd9Sstevel@tonic-gate 			}
17587c478bd9Sstevel@tonic-gate 			VN_RELE(vp);
17597c478bd9Sstevel@tonic-gate 		}
17607c478bd9Sstevel@tonic-gate 		if (error != ESTALE)
17617c478bd9Sstevel@tonic-gate 			goto out;
17627c478bd9Sstevel@tonic-gate 	}
17637c478bd9Sstevel@tonic-gate 
17647c478bd9Sstevel@tonic-gate 	ASSERT(error == 0);
17657c478bd9Sstevel@tonic-gate 	zone->zone_rootvp = vp;		/* we hold a reference to vp */
17667c478bd9Sstevel@tonic-gate 	zone->zone_rootpath = path;
17677c478bd9Sstevel@tonic-gate 	zone->zone_rootpathlen = pathlen;
17687c478bd9Sstevel@tonic-gate 	return (0);
17697c478bd9Sstevel@tonic-gate 
17707c478bd9Sstevel@tonic-gate out:
17717c478bd9Sstevel@tonic-gate 	pn_free(&pn);
17727c478bd9Sstevel@tonic-gate 	pn_free(&upn);
17737c478bd9Sstevel@tonic-gate 	return (error);
17747c478bd9Sstevel@tonic-gate }
17757c478bd9Sstevel@tonic-gate 
17767c478bd9Sstevel@tonic-gate #define	isalnum(c)	(((c) >= '0' && (c) <= '9') || \
17777c478bd9Sstevel@tonic-gate 			((c) >= 'a' && (c) <= 'z') || \
17787c478bd9Sstevel@tonic-gate 			((c) >= 'A' && (c) <= 'Z'))
17797c478bd9Sstevel@tonic-gate 
17807c478bd9Sstevel@tonic-gate static int
17817c478bd9Sstevel@tonic-gate zone_set_name(zone_t *zone, const char *uname)
17827c478bd9Sstevel@tonic-gate {
17837c478bd9Sstevel@tonic-gate 	char *kname = kmem_zalloc(ZONENAME_MAX, KM_SLEEP);
17847c478bd9Sstevel@tonic-gate 	size_t len;
17857c478bd9Sstevel@tonic-gate 	int i, err;
17867c478bd9Sstevel@tonic-gate 
17877c478bd9Sstevel@tonic-gate 	if ((err = copyinstr(uname, kname, ZONENAME_MAX, &len)) != 0) {
17887c478bd9Sstevel@tonic-gate 		kmem_free(kname, ZONENAME_MAX);
17897c478bd9Sstevel@tonic-gate 		return (err);	/* EFAULT or ENAMETOOLONG */
17907c478bd9Sstevel@tonic-gate 	}
17917c478bd9Sstevel@tonic-gate 
17927c478bd9Sstevel@tonic-gate 	/* must be less than ZONENAME_MAX */
17937c478bd9Sstevel@tonic-gate 	if (len == ZONENAME_MAX && kname[ZONENAME_MAX - 1] != '\0') {
17947c478bd9Sstevel@tonic-gate 		kmem_free(kname, ZONENAME_MAX);
17957c478bd9Sstevel@tonic-gate 		return (EINVAL);
17967c478bd9Sstevel@tonic-gate 	}
17977c478bd9Sstevel@tonic-gate 
17987c478bd9Sstevel@tonic-gate 	/*
17997c478bd9Sstevel@tonic-gate 	 * Name must start with an alphanumeric and must contain only
18007c478bd9Sstevel@tonic-gate 	 * alphanumerics, '-', '_' and '.'.
18017c478bd9Sstevel@tonic-gate 	 */
18027c478bd9Sstevel@tonic-gate 	if (!isalnum(kname[0])) {
18037c478bd9Sstevel@tonic-gate 		kmem_free(kname, ZONENAME_MAX);
18047c478bd9Sstevel@tonic-gate 		return (EINVAL);
18057c478bd9Sstevel@tonic-gate 	}
18067c478bd9Sstevel@tonic-gate 	for (i = 1; i < len - 1; i++) {
18077c478bd9Sstevel@tonic-gate 		if (!isalnum(kname[i]) && kname[i] != '-' && kname[i] != '_' &&
18087c478bd9Sstevel@tonic-gate 		    kname[i] != '.') {
18097c478bd9Sstevel@tonic-gate 			kmem_free(kname, ZONENAME_MAX);
18107c478bd9Sstevel@tonic-gate 			return (EINVAL);
18117c478bd9Sstevel@tonic-gate 		}
18127c478bd9Sstevel@tonic-gate 	}
18137c478bd9Sstevel@tonic-gate 
18147c478bd9Sstevel@tonic-gate 	zone->zone_name = kname;
18157c478bd9Sstevel@tonic-gate 	return (0);
18167c478bd9Sstevel@tonic-gate }
18177c478bd9Sstevel@tonic-gate 
18187c478bd9Sstevel@tonic-gate /*
18197c478bd9Sstevel@tonic-gate  * Similar to thread_create(), but makes sure the thread is in the appropriate
18207c478bd9Sstevel@tonic-gate  * zone's zsched process (curproc->p_zone->zone_zsched) before returning.
18217c478bd9Sstevel@tonic-gate  */
18227c478bd9Sstevel@tonic-gate /*ARGSUSED*/
18237c478bd9Sstevel@tonic-gate kthread_t *
18247c478bd9Sstevel@tonic-gate zthread_create(
18257c478bd9Sstevel@tonic-gate     caddr_t stk,
18267c478bd9Sstevel@tonic-gate     size_t stksize,
18277c478bd9Sstevel@tonic-gate     void (*proc)(),
18287c478bd9Sstevel@tonic-gate     void *arg,
18297c478bd9Sstevel@tonic-gate     size_t len,
18307c478bd9Sstevel@tonic-gate     pri_t pri)
18317c478bd9Sstevel@tonic-gate {
18327c478bd9Sstevel@tonic-gate 	kthread_t *t;
18337c478bd9Sstevel@tonic-gate 	zone_t *zone = curproc->p_zone;
18347c478bd9Sstevel@tonic-gate 	proc_t *pp = zone->zone_zsched;
18357c478bd9Sstevel@tonic-gate 
18367c478bd9Sstevel@tonic-gate 	zone_hold(zone);	/* Reference to be dropped when thread exits */
18377c478bd9Sstevel@tonic-gate 
18387c478bd9Sstevel@tonic-gate 	/*
18397c478bd9Sstevel@tonic-gate 	 * No-one should be trying to create threads if the zone is shutting
18407c478bd9Sstevel@tonic-gate 	 * down and there aren't any kernel threads around.  See comment
18417c478bd9Sstevel@tonic-gate 	 * in zthread_exit().
18427c478bd9Sstevel@tonic-gate 	 */
18437c478bd9Sstevel@tonic-gate 	ASSERT(!(zone->zone_kthreads == NULL &&
18447c478bd9Sstevel@tonic-gate 	    zone_status_get(zone) >= ZONE_IS_EMPTY));
18457c478bd9Sstevel@tonic-gate 	/*
18467c478bd9Sstevel@tonic-gate 	 * Create a thread, but don't let it run until we've finished setting
18477c478bd9Sstevel@tonic-gate 	 * things up.
18487c478bd9Sstevel@tonic-gate 	 */
18497c478bd9Sstevel@tonic-gate 	t = thread_create(stk, stksize, proc, arg, len, pp, TS_STOPPED, pri);
18507c478bd9Sstevel@tonic-gate 	ASSERT(t->t_forw == NULL);
18517c478bd9Sstevel@tonic-gate 	mutex_enter(&zone_status_lock);
18527c478bd9Sstevel@tonic-gate 	if (zone->zone_kthreads == NULL) {
18537c478bd9Sstevel@tonic-gate 		t->t_forw = t->t_back = t;
18547c478bd9Sstevel@tonic-gate 	} else {
18557c478bd9Sstevel@tonic-gate 		kthread_t *tx = zone->zone_kthreads;
18567c478bd9Sstevel@tonic-gate 
18577c478bd9Sstevel@tonic-gate 		t->t_forw = tx;
18587c478bd9Sstevel@tonic-gate 		t->t_back = tx->t_back;
18597c478bd9Sstevel@tonic-gate 		tx->t_back->t_forw = t;
18607c478bd9Sstevel@tonic-gate 		tx->t_back = t;
18617c478bd9Sstevel@tonic-gate 	}
18627c478bd9Sstevel@tonic-gate 	zone->zone_kthreads = t;
18637c478bd9Sstevel@tonic-gate 	mutex_exit(&zone_status_lock);
18647c478bd9Sstevel@tonic-gate 
18657c478bd9Sstevel@tonic-gate 	mutex_enter(&pp->p_lock);
18667c478bd9Sstevel@tonic-gate 	t->t_proc_flag |= TP_ZTHREAD;
18677c478bd9Sstevel@tonic-gate 	project_rele(t->t_proj);
18687c478bd9Sstevel@tonic-gate 	t->t_proj = project_hold(pp->p_task->tk_proj);
18697c478bd9Sstevel@tonic-gate 
18707c478bd9Sstevel@tonic-gate 	/*
18717c478bd9Sstevel@tonic-gate 	 * Setup complete, let it run.
18727c478bd9Sstevel@tonic-gate 	 */
18737c478bd9Sstevel@tonic-gate 	thread_lock(t);
18747c478bd9Sstevel@tonic-gate 	t->t_schedflag |= TS_ALLSTART;
18757c478bd9Sstevel@tonic-gate 	setrun_locked(t);
18767c478bd9Sstevel@tonic-gate 	thread_unlock(t);
18777c478bd9Sstevel@tonic-gate 
18787c478bd9Sstevel@tonic-gate 	mutex_exit(&pp->p_lock);
18797c478bd9Sstevel@tonic-gate 
18807c478bd9Sstevel@tonic-gate 	return (t);
18817c478bd9Sstevel@tonic-gate }
18827c478bd9Sstevel@tonic-gate 
18837c478bd9Sstevel@tonic-gate /*
18847c478bd9Sstevel@tonic-gate  * Similar to thread_exit().  Must be called by threads created via
18857c478bd9Sstevel@tonic-gate  * zthread_exit().
18867c478bd9Sstevel@tonic-gate  */
18877c478bd9Sstevel@tonic-gate void
18887c478bd9Sstevel@tonic-gate zthread_exit(void)
18897c478bd9Sstevel@tonic-gate {
18907c478bd9Sstevel@tonic-gate 	kthread_t *t = curthread;
18917c478bd9Sstevel@tonic-gate 	proc_t *pp = curproc;
18927c478bd9Sstevel@tonic-gate 	zone_t *zone = pp->p_zone;
18937c478bd9Sstevel@tonic-gate 
18947c478bd9Sstevel@tonic-gate 	mutex_enter(&zone_status_lock);
18957c478bd9Sstevel@tonic-gate 
18967c478bd9Sstevel@tonic-gate 	/*
18977c478bd9Sstevel@tonic-gate 	 * Reparent to p0
18987c478bd9Sstevel@tonic-gate 	 */
18997c478bd9Sstevel@tonic-gate 	mutex_enter(&pp->p_lock);
19007c478bd9Sstevel@tonic-gate 	t->t_proc_flag &= ~TP_ZTHREAD;
19017c478bd9Sstevel@tonic-gate 	t->t_procp = &p0;
19027c478bd9Sstevel@tonic-gate 	hat_thread_exit(t);
19037c478bd9Sstevel@tonic-gate 	mutex_exit(&pp->p_lock);
19047c478bd9Sstevel@tonic-gate 
19057c478bd9Sstevel@tonic-gate 	if (t->t_back == t) {
19067c478bd9Sstevel@tonic-gate 		ASSERT(t->t_forw == t);
19077c478bd9Sstevel@tonic-gate 		/*
19087c478bd9Sstevel@tonic-gate 		 * If the zone is empty, once the thread count
19097c478bd9Sstevel@tonic-gate 		 * goes to zero no further kernel threads can be
19107c478bd9Sstevel@tonic-gate 		 * created.  This is because if the creator is a process
19117c478bd9Sstevel@tonic-gate 		 * in the zone, then it must have exited before the zone
19127c478bd9Sstevel@tonic-gate 		 * state could be set to ZONE_IS_EMPTY.
19137c478bd9Sstevel@tonic-gate 		 * Otherwise, if the creator is a kernel thread in the
19147c478bd9Sstevel@tonic-gate 		 * zone, the thread count is non-zero.
19157c478bd9Sstevel@tonic-gate 		 *
19167c478bd9Sstevel@tonic-gate 		 * This really means that non-zone kernel threads should
19177c478bd9Sstevel@tonic-gate 		 * not create zone kernel threads.
19187c478bd9Sstevel@tonic-gate 		 */
19197c478bd9Sstevel@tonic-gate 		zone->zone_kthreads = NULL;
19207c478bd9Sstevel@tonic-gate 		if (zone_status_get(zone) == ZONE_IS_EMPTY) {
19217c478bd9Sstevel@tonic-gate 			zone_status_set(zone, ZONE_IS_DOWN);
19227c478bd9Sstevel@tonic-gate 		}
19237c478bd9Sstevel@tonic-gate 	} else {
19247c478bd9Sstevel@tonic-gate 		t->t_forw->t_back = t->t_back;
19257c478bd9Sstevel@tonic-gate 		t->t_back->t_forw = t->t_forw;
19267c478bd9Sstevel@tonic-gate 		if (zone->zone_kthreads == t)
19277c478bd9Sstevel@tonic-gate 			zone->zone_kthreads = t->t_forw;
19287c478bd9Sstevel@tonic-gate 	}
19297c478bd9Sstevel@tonic-gate 	mutex_exit(&zone_status_lock);
19307c478bd9Sstevel@tonic-gate 	zone_rele(zone);
19317c478bd9Sstevel@tonic-gate 	thread_exit();
19327c478bd9Sstevel@tonic-gate 	/* NOTREACHED */
19337c478bd9Sstevel@tonic-gate }
19347c478bd9Sstevel@tonic-gate 
19357c478bd9Sstevel@tonic-gate static void
19367c478bd9Sstevel@tonic-gate zone_chdir(vnode_t *vp, vnode_t **vpp, proc_t *pp)
19377c478bd9Sstevel@tonic-gate {
19387c478bd9Sstevel@tonic-gate 	vnode_t *oldvp;
19397c478bd9Sstevel@tonic-gate 
19407c478bd9Sstevel@tonic-gate 	/* we're going to hold a reference here to the directory */
19417c478bd9Sstevel@tonic-gate 	VN_HOLD(vp);
19427c478bd9Sstevel@tonic-gate 
19437c478bd9Sstevel@tonic-gate #ifdef C2_AUDIT
19447c478bd9Sstevel@tonic-gate 	if (audit_active)	/* update abs cwd/root path see c2audit.c */
19457c478bd9Sstevel@tonic-gate 		audit_chdirec(vp, vpp);
19467c478bd9Sstevel@tonic-gate #endif
19477c478bd9Sstevel@tonic-gate 
19487c478bd9Sstevel@tonic-gate 	mutex_enter(&pp->p_lock);
19497c478bd9Sstevel@tonic-gate 	oldvp = *vpp;
19507c478bd9Sstevel@tonic-gate 	*vpp = vp;
19517c478bd9Sstevel@tonic-gate 	mutex_exit(&pp->p_lock);
19527c478bd9Sstevel@tonic-gate 	if (oldvp != NULL)
19537c478bd9Sstevel@tonic-gate 		VN_RELE(oldvp);
19547c478bd9Sstevel@tonic-gate }
19557c478bd9Sstevel@tonic-gate 
19567c478bd9Sstevel@tonic-gate /*
19577c478bd9Sstevel@tonic-gate  * Convert an rctl value represented by an nvlist_t into an rctl_val_t.
19587c478bd9Sstevel@tonic-gate  */
19597c478bd9Sstevel@tonic-gate static int
19607c478bd9Sstevel@tonic-gate nvlist2rctlval(nvlist_t *nvl, rctl_val_t *rv)
19617c478bd9Sstevel@tonic-gate {
19627c478bd9Sstevel@tonic-gate 	nvpair_t *nvp = NULL;
19637c478bd9Sstevel@tonic-gate 	boolean_t priv_set = B_FALSE;
19647c478bd9Sstevel@tonic-gate 	boolean_t limit_set = B_FALSE;
19657c478bd9Sstevel@tonic-gate 	boolean_t action_set = B_FALSE;
19667c478bd9Sstevel@tonic-gate 
19677c478bd9Sstevel@tonic-gate 	while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
19687c478bd9Sstevel@tonic-gate 		const char *name;
19697c478bd9Sstevel@tonic-gate 		uint64_t ui64;
19707c478bd9Sstevel@tonic-gate 
19717c478bd9Sstevel@tonic-gate 		name = nvpair_name(nvp);
19727c478bd9Sstevel@tonic-gate 		if (nvpair_type(nvp) != DATA_TYPE_UINT64)
19737c478bd9Sstevel@tonic-gate 			return (EINVAL);
19747c478bd9Sstevel@tonic-gate 		(void) nvpair_value_uint64(nvp, &ui64);
19757c478bd9Sstevel@tonic-gate 		if (strcmp(name, "privilege") == 0) {
19767c478bd9Sstevel@tonic-gate 			/*
19777c478bd9Sstevel@tonic-gate 			 * Currently only privileged values are allowed, but
19787c478bd9Sstevel@tonic-gate 			 * this may change in the future.
19797c478bd9Sstevel@tonic-gate 			 */
19807c478bd9Sstevel@tonic-gate 			if (ui64 != RCPRIV_PRIVILEGED)
19817c478bd9Sstevel@tonic-gate 				return (EINVAL);
19827c478bd9Sstevel@tonic-gate 			rv->rcv_privilege = ui64;
19837c478bd9Sstevel@tonic-gate 			priv_set = B_TRUE;
19847c478bd9Sstevel@tonic-gate 		} else if (strcmp(name, "limit") == 0) {
19857c478bd9Sstevel@tonic-gate 			rv->rcv_value = ui64;
19867c478bd9Sstevel@tonic-gate 			limit_set = B_TRUE;
19877c478bd9Sstevel@tonic-gate 		} else if (strcmp(name, "action") == 0) {
19887c478bd9Sstevel@tonic-gate 			if (ui64 != RCTL_LOCAL_NOACTION &&
19897c478bd9Sstevel@tonic-gate 			    ui64 != RCTL_LOCAL_DENY)
19907c478bd9Sstevel@tonic-gate 				return (EINVAL);
19917c478bd9Sstevel@tonic-gate 			rv->rcv_flagaction = ui64;
19927c478bd9Sstevel@tonic-gate 			action_set = B_TRUE;
19937c478bd9Sstevel@tonic-gate 		} else {
19947c478bd9Sstevel@tonic-gate 			return (EINVAL);
19957c478bd9Sstevel@tonic-gate 		}
19967c478bd9Sstevel@tonic-gate 	}
19977c478bd9Sstevel@tonic-gate 
19987c478bd9Sstevel@tonic-gate 	if (!(priv_set && limit_set && action_set))
19997c478bd9Sstevel@tonic-gate 		return (EINVAL);
20007c478bd9Sstevel@tonic-gate 	rv->rcv_action_signal = 0;
20017c478bd9Sstevel@tonic-gate 	rv->rcv_action_recipient = NULL;
20027c478bd9Sstevel@tonic-gate 	rv->rcv_action_recip_pid = -1;
20037c478bd9Sstevel@tonic-gate 	rv->rcv_firing_time = 0;
20047c478bd9Sstevel@tonic-gate 
20057c478bd9Sstevel@tonic-gate 	return (0);
20067c478bd9Sstevel@tonic-gate }
20077c478bd9Sstevel@tonic-gate 
20087c478bd9Sstevel@tonic-gate void
20097c478bd9Sstevel@tonic-gate zone_icode(void)
20107c478bd9Sstevel@tonic-gate {
20117c478bd9Sstevel@tonic-gate 	proc_t *p = ttoproc(curthread);
20127c478bd9Sstevel@tonic-gate 	struct core_globals	*cg;
20137c478bd9Sstevel@tonic-gate 
20147c478bd9Sstevel@tonic-gate 	/*
20157c478bd9Sstevel@tonic-gate 	 * For all purposes (ZONE_ATTR_INITPID and restart_init),
20167c478bd9Sstevel@tonic-gate 	 * storing just the pid of init is sufficient.
20177c478bd9Sstevel@tonic-gate 	 */
20187c478bd9Sstevel@tonic-gate 	p->p_zone->zone_proc_initpid = p->p_pid;
20197c478bd9Sstevel@tonic-gate 
20207c478bd9Sstevel@tonic-gate 	/*
20217c478bd9Sstevel@tonic-gate 	 * Allocate user address space and stack segment
20227c478bd9Sstevel@tonic-gate 	 */
20237c478bd9Sstevel@tonic-gate 
20247c478bd9Sstevel@tonic-gate 	p->p_cstime = p->p_stime = p->p_cutime = p->p_utime = 0;
20257c478bd9Sstevel@tonic-gate 	p->p_usrstack = (caddr_t)USRSTACK32;
20267c478bd9Sstevel@tonic-gate 	p->p_model = DATAMODEL_ILP32;
20277c478bd9Sstevel@tonic-gate 	p->p_stkprot = PROT_ZFOD & ~PROT_EXEC;
20287c478bd9Sstevel@tonic-gate 	p->p_datprot = PROT_ZFOD & ~PROT_EXEC;
20297c478bd9Sstevel@tonic-gate 	p->p_stk_ctl = INT32_MAX;
20307c478bd9Sstevel@tonic-gate 
20317c478bd9Sstevel@tonic-gate 	p->p_as = as_alloc();
20327c478bd9Sstevel@tonic-gate 	p->p_as->a_userlimit = (caddr_t)USERLIMIT32;
20337c478bd9Sstevel@tonic-gate 	(void) hat_setup(p->p_as->a_hat, HAT_INIT);
20347c478bd9Sstevel@tonic-gate 
20357c478bd9Sstevel@tonic-gate 	cg = zone_getspecific(core_zone_key, p->p_zone);
20367c478bd9Sstevel@tonic-gate 	ASSERT(cg != NULL);
20377c478bd9Sstevel@tonic-gate 	corectl_path_hold(cg->core_default_path);
20387c478bd9Sstevel@tonic-gate 	corectl_content_hold(cg->core_default_content);
20397c478bd9Sstevel@tonic-gate 	p->p_corefile = cg->core_default_path;
20407c478bd9Sstevel@tonic-gate 	p->p_content = cg->core_default_content;
20417c478bd9Sstevel@tonic-gate 
20427c478bd9Sstevel@tonic-gate 	init_mstate(curthread, LMS_SYSTEM);
20437c478bd9Sstevel@tonic-gate 
20447c478bd9Sstevel@tonic-gate 	p->p_zone->zone_boot_err = exec_init(zone_initname, 0,
20457c478bd9Sstevel@tonic-gate 	    p->p_zone->zone_bootargs);
20467c478bd9Sstevel@tonic-gate 
20477c478bd9Sstevel@tonic-gate 	mutex_enter(&zone_status_lock);
20487c478bd9Sstevel@tonic-gate 	if (p->p_zone->zone_boot_err != 0) {
20497c478bd9Sstevel@tonic-gate 		/*
20507c478bd9Sstevel@tonic-gate 		 * Make sure we are still in the booting state-- we could have
20517c478bd9Sstevel@tonic-gate 		 * raced and already be shutting down, or even further along.
20527c478bd9Sstevel@tonic-gate 		 */
20537c478bd9Sstevel@tonic-gate 		if (zone_status_get(p->p_zone) == ZONE_IS_BOOTING)
20547c478bd9Sstevel@tonic-gate 			zone_status_set(p->p_zone, ZONE_IS_SHUTTING_DOWN);
20557c478bd9Sstevel@tonic-gate 		mutex_exit(&zone_status_lock);
20567c478bd9Sstevel@tonic-gate 		/* It's gone bad, dispose of the process */
20577c478bd9Sstevel@tonic-gate 		if (proc_exit(CLD_EXITED, p->p_zone->zone_boot_err) != 0) {
205897eda132Sraf 			mutex_enter(&p->p_lock);
205997eda132Sraf 			ASSERT(p->p_flag & SEXITLWPS);
20607c478bd9Sstevel@tonic-gate 			lwp_exit();
20617c478bd9Sstevel@tonic-gate 		}
20627c478bd9Sstevel@tonic-gate 	} else {
20637c478bd9Sstevel@tonic-gate 		if (zone_status_get(p->p_zone) == ZONE_IS_BOOTING)
20647c478bd9Sstevel@tonic-gate 			zone_status_set(p->p_zone, ZONE_IS_RUNNING);
20657c478bd9Sstevel@tonic-gate 		mutex_exit(&zone_status_lock);
20667c478bd9Sstevel@tonic-gate 		/* cause the process to return to userland. */
20677c478bd9Sstevel@tonic-gate 		lwp_rtt();
20687c478bd9Sstevel@tonic-gate 	}
20697c478bd9Sstevel@tonic-gate }
20707c478bd9Sstevel@tonic-gate 
20717c478bd9Sstevel@tonic-gate struct zsched_arg {
20727c478bd9Sstevel@tonic-gate 	zone_t *zone;
20737c478bd9Sstevel@tonic-gate 	nvlist_t *nvlist;
20747c478bd9Sstevel@tonic-gate };
20757c478bd9Sstevel@tonic-gate 
20767c478bd9Sstevel@tonic-gate /*
20777c478bd9Sstevel@tonic-gate  * Per-zone "sched" workalike.  The similarity to "sched" doesn't have
20787c478bd9Sstevel@tonic-gate  * anything to do with scheduling, but rather with the fact that
20797c478bd9Sstevel@tonic-gate  * per-zone kernel threads are parented to zsched, just like regular
20807c478bd9Sstevel@tonic-gate  * kernel threads are parented to sched (p0).
20817c478bd9Sstevel@tonic-gate  *
20827c478bd9Sstevel@tonic-gate  * zsched is also responsible for launching init for the zone.
20837c478bd9Sstevel@tonic-gate  */
20847c478bd9Sstevel@tonic-gate static void
20857c478bd9Sstevel@tonic-gate zsched(void *arg)
20867c478bd9Sstevel@tonic-gate {
20877c478bd9Sstevel@tonic-gate 	struct zsched_arg *za = arg;
20887c478bd9Sstevel@tonic-gate 	proc_t *pp = curproc;
20897c478bd9Sstevel@tonic-gate 	proc_t *initp = proc_init;
20907c478bd9Sstevel@tonic-gate 	zone_t *zone = za->zone;
20917c478bd9Sstevel@tonic-gate 	cred_t *cr, *oldcred;
20927c478bd9Sstevel@tonic-gate 	rctl_set_t *set;
20937c478bd9Sstevel@tonic-gate 	rctl_alloc_gp_t *gp;
20947c478bd9Sstevel@tonic-gate 	contract_t *ct = NULL;
20957c478bd9Sstevel@tonic-gate 	task_t *tk, *oldtk;
20967c478bd9Sstevel@tonic-gate 	rctl_entity_p_t e;
20977c478bd9Sstevel@tonic-gate 	kproject_t *pj;
20987c478bd9Sstevel@tonic-gate 
20997c478bd9Sstevel@tonic-gate 	nvlist_t *nvl = za->nvlist;
21007c478bd9Sstevel@tonic-gate 	nvpair_t *nvp = NULL;
21017c478bd9Sstevel@tonic-gate 
21027c478bd9Sstevel@tonic-gate 	bcopy("zsched", u.u_psargs, sizeof ("zsched"));
21037c478bd9Sstevel@tonic-gate 	bcopy("zsched", u.u_comm, sizeof ("zsched"));
21047c478bd9Sstevel@tonic-gate 	u.u_argc = 0;
21057c478bd9Sstevel@tonic-gate 	u.u_argv = NULL;
21067c478bd9Sstevel@tonic-gate 	u.u_envp = NULL;
21077c478bd9Sstevel@tonic-gate 	closeall(P_FINFO(pp));
21087c478bd9Sstevel@tonic-gate 
21097c478bd9Sstevel@tonic-gate 	/*
21107c478bd9Sstevel@tonic-gate 	 * We are this zone's "zsched" process.  As the zone isn't generally
21117c478bd9Sstevel@tonic-gate 	 * visible yet we don't need to grab any locks before initializing its
21127c478bd9Sstevel@tonic-gate 	 * zone_proc pointer.
21137c478bd9Sstevel@tonic-gate 	 */
21147c478bd9Sstevel@tonic-gate 	zone_hold(zone);  /* this hold is released by zone_destroy() */
21157c478bd9Sstevel@tonic-gate 	zone->zone_zsched = pp;
21167c478bd9Sstevel@tonic-gate 	mutex_enter(&pp->p_lock);
21177c478bd9Sstevel@tonic-gate 	pp->p_zone = zone;
21187c478bd9Sstevel@tonic-gate 	mutex_exit(&pp->p_lock);
21197c478bd9Sstevel@tonic-gate 
21207c478bd9Sstevel@tonic-gate 	/*
21217c478bd9Sstevel@tonic-gate 	 * Disassociate process from its 'parent'; parent ourselves to init
21227c478bd9Sstevel@tonic-gate 	 * (pid 1) and change other values as needed.
21237c478bd9Sstevel@tonic-gate 	 */
21247c478bd9Sstevel@tonic-gate 	sess_create();
21257c478bd9Sstevel@tonic-gate 
21267c478bd9Sstevel@tonic-gate 	mutex_enter(&pidlock);
21277c478bd9Sstevel@tonic-gate 	proc_detach(pp);
21287c478bd9Sstevel@tonic-gate 	pp->p_ppid = 1;
21297c478bd9Sstevel@tonic-gate 	pp->p_flag |= SZONETOP;
21307c478bd9Sstevel@tonic-gate 	pp->p_ancpid = 1;
21317c478bd9Sstevel@tonic-gate 	pp->p_parent = initp;
21327c478bd9Sstevel@tonic-gate 	pp->p_psibling = NULL;
21337c478bd9Sstevel@tonic-gate 	if (initp->p_child)
21347c478bd9Sstevel@tonic-gate 		initp->p_child->p_psibling = pp;
21357c478bd9Sstevel@tonic-gate 	pp->p_sibling = initp->p_child;
21367c478bd9Sstevel@tonic-gate 	initp->p_child = pp;
21377c478bd9Sstevel@tonic-gate 
21387c478bd9Sstevel@tonic-gate 	/* Decrement what newproc() incremented. */
21397c478bd9Sstevel@tonic-gate 	upcount_dec(crgetruid(CRED()), GLOBAL_ZONEID);
21407c478bd9Sstevel@tonic-gate 	/*
21417c478bd9Sstevel@tonic-gate 	 * Our credentials are about to become kcred-like, so we don't care
21427c478bd9Sstevel@tonic-gate 	 * about the caller's ruid.
21437c478bd9Sstevel@tonic-gate 	 */
21447c478bd9Sstevel@tonic-gate 	upcount_inc(crgetruid(kcred), zone->zone_id);
21457c478bd9Sstevel@tonic-gate 	mutex_exit(&pidlock);
21467c478bd9Sstevel@tonic-gate 
21477c478bd9Sstevel@tonic-gate 	/*
21487c478bd9Sstevel@tonic-gate 	 * getting out of global zone, so decrement lwp counts
21497c478bd9Sstevel@tonic-gate 	 */
21507c478bd9Sstevel@tonic-gate 	pj = pp->p_task->tk_proj;
21517c478bd9Sstevel@tonic-gate 	mutex_enter(&global_zone->zone_nlwps_lock);
21527c478bd9Sstevel@tonic-gate 	pj->kpj_nlwps -= pp->p_lwpcnt;
21537c478bd9Sstevel@tonic-gate 	global_zone->zone_nlwps -= pp->p_lwpcnt;
21547c478bd9Sstevel@tonic-gate 	mutex_exit(&global_zone->zone_nlwps_lock);
21557c478bd9Sstevel@tonic-gate 
21567c478bd9Sstevel@tonic-gate 	/*
21577c478bd9Sstevel@tonic-gate 	 * Create and join a new task in project '0' of this zone.
21587c478bd9Sstevel@tonic-gate 	 *
21597c478bd9Sstevel@tonic-gate 	 * We don't need to call holdlwps() since we know we're the only lwp in
21607c478bd9Sstevel@tonic-gate 	 * this process.
21617c478bd9Sstevel@tonic-gate 	 *
21627c478bd9Sstevel@tonic-gate 	 * task_join() returns with p_lock held.
21637c478bd9Sstevel@tonic-gate 	 */
21647c478bd9Sstevel@tonic-gate 	tk = task_create(0, zone);
21657c478bd9Sstevel@tonic-gate 	mutex_enter(&cpu_lock);
21667c478bd9Sstevel@tonic-gate 	oldtk = task_join(tk, 0);
21677c478bd9Sstevel@tonic-gate 	mutex_exit(&curproc->p_lock);
21687c478bd9Sstevel@tonic-gate 	mutex_exit(&cpu_lock);
21697c478bd9Sstevel@tonic-gate 	task_rele(oldtk);
21707c478bd9Sstevel@tonic-gate 
21717c478bd9Sstevel@tonic-gate 	/*
21727c478bd9Sstevel@tonic-gate 	 * add lwp counts to zsched's zone, and increment project's task count
21737c478bd9Sstevel@tonic-gate 	 * due to the task created in the above tasksys_settaskid
21747c478bd9Sstevel@tonic-gate 	 */
21757c478bd9Sstevel@tonic-gate 	pj = pp->p_task->tk_proj;
21767c478bd9Sstevel@tonic-gate 	mutex_enter(&zone->zone_nlwps_lock);
21777c478bd9Sstevel@tonic-gate 	pj->kpj_nlwps += pp->p_lwpcnt;
21787c478bd9Sstevel@tonic-gate 	pj->kpj_ntasks += 1;
21797c478bd9Sstevel@tonic-gate 	zone->zone_nlwps += pp->p_lwpcnt;
21807c478bd9Sstevel@tonic-gate 	mutex_exit(&zone->zone_nlwps_lock);
21817c478bd9Sstevel@tonic-gate 
21827c478bd9Sstevel@tonic-gate 	/*
21837c478bd9Sstevel@tonic-gate 	 * The process was created by a process in the global zone, hence the
21847c478bd9Sstevel@tonic-gate 	 * credentials are wrong.  We might as well have kcred-ish credentials.
21857c478bd9Sstevel@tonic-gate 	 */
21867c478bd9Sstevel@tonic-gate 	cr = zone->zone_kcred;
21877c478bd9Sstevel@tonic-gate 	crhold(cr);
21887c478bd9Sstevel@tonic-gate 	mutex_enter(&pp->p_crlock);
21897c478bd9Sstevel@tonic-gate 	oldcred = pp->p_cred;
21907c478bd9Sstevel@tonic-gate 	pp->p_cred = cr;
21917c478bd9Sstevel@tonic-gate 	mutex_exit(&pp->p_crlock);
21927c478bd9Sstevel@tonic-gate 	crfree(oldcred);
21937c478bd9Sstevel@tonic-gate 
21947c478bd9Sstevel@tonic-gate 	/*
21957c478bd9Sstevel@tonic-gate 	 * Hold credentials again (for thread)
21967c478bd9Sstevel@tonic-gate 	 */
21977c478bd9Sstevel@tonic-gate 	crhold(cr);
21987c478bd9Sstevel@tonic-gate 
21997c478bd9Sstevel@tonic-gate 	/*
22007c478bd9Sstevel@tonic-gate 	 * p_lwpcnt can't change since this is a kernel process.
22017c478bd9Sstevel@tonic-gate 	 */
22027c478bd9Sstevel@tonic-gate 	crset(pp, cr);
22037c478bd9Sstevel@tonic-gate 
22047c478bd9Sstevel@tonic-gate 	/*
22057c478bd9Sstevel@tonic-gate 	 * Chroot
22067c478bd9Sstevel@tonic-gate 	 */
22077c478bd9Sstevel@tonic-gate 	zone_chdir(zone->zone_rootvp, &PTOU(pp)->u_cdir, pp);
22087c478bd9Sstevel@tonic-gate 	zone_chdir(zone->zone_rootvp, &PTOU(pp)->u_rdir, pp);
22097c478bd9Sstevel@tonic-gate 
22107c478bd9Sstevel@tonic-gate 	/*
22117c478bd9Sstevel@tonic-gate 	 * Initialize zone's rctl set.
22127c478bd9Sstevel@tonic-gate 	 */
22137c478bd9Sstevel@tonic-gate 	set = rctl_set_create();
22147c478bd9Sstevel@tonic-gate 	gp = rctl_set_init_prealloc(RCENTITY_ZONE);
22157c478bd9Sstevel@tonic-gate 	mutex_enter(&pp->p_lock);
22167c478bd9Sstevel@tonic-gate 	e.rcep_p.zone = zone;
22177c478bd9Sstevel@tonic-gate 	e.rcep_t = RCENTITY_ZONE;
22187c478bd9Sstevel@tonic-gate 	zone->zone_rctls = rctl_set_init(RCENTITY_ZONE, pp, &e, set, gp);
22197c478bd9Sstevel@tonic-gate 	mutex_exit(&pp->p_lock);
22207c478bd9Sstevel@tonic-gate 	rctl_prealloc_destroy(gp);
22217c478bd9Sstevel@tonic-gate 
22227c478bd9Sstevel@tonic-gate 	/*
22237c478bd9Sstevel@tonic-gate 	 * Apply the rctls passed in to zone_create().  This is basically a list
22247c478bd9Sstevel@tonic-gate 	 * assignment: all of the old values are removed and the new ones
22257c478bd9Sstevel@tonic-gate 	 * inserted.  That is, if an empty list is passed in, all values are
22267c478bd9Sstevel@tonic-gate 	 * removed.
22277c478bd9Sstevel@tonic-gate 	 */
22287c478bd9Sstevel@tonic-gate 	while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
22297c478bd9Sstevel@tonic-gate 		rctl_dict_entry_t *rde;
22307c478bd9Sstevel@tonic-gate 		rctl_hndl_t hndl;
22317c478bd9Sstevel@tonic-gate 		char *name;
22327c478bd9Sstevel@tonic-gate 		nvlist_t **nvlarray;
22337c478bd9Sstevel@tonic-gate 		uint_t i, nelem;
22347c478bd9Sstevel@tonic-gate 		int error;	/* For ASSERT()s */
22357c478bd9Sstevel@tonic-gate 
22367c478bd9Sstevel@tonic-gate 		name = nvpair_name(nvp);
22377c478bd9Sstevel@tonic-gate 		hndl = rctl_hndl_lookup(name);
22387c478bd9Sstevel@tonic-gate 		ASSERT(hndl != -1);
22397c478bd9Sstevel@tonic-gate 		rde = rctl_dict_lookup_hndl(hndl);
22407c478bd9Sstevel@tonic-gate 		ASSERT(rde != NULL);
22417c478bd9Sstevel@tonic-gate 
22427c478bd9Sstevel@tonic-gate 		for (; /* ever */; ) {
22437c478bd9Sstevel@tonic-gate 			rctl_val_t oval;
22447c478bd9Sstevel@tonic-gate 
22457c478bd9Sstevel@tonic-gate 			mutex_enter(&pp->p_lock);
22467c478bd9Sstevel@tonic-gate 			error = rctl_local_get(hndl, NULL, &oval, pp);
22477c478bd9Sstevel@tonic-gate 			mutex_exit(&pp->p_lock);
22487c478bd9Sstevel@tonic-gate 			ASSERT(error == 0);	/* Can't fail for RCTL_FIRST */
22497c478bd9Sstevel@tonic-gate 			ASSERT(oval.rcv_privilege != RCPRIV_BASIC);
22507c478bd9Sstevel@tonic-gate 			if (oval.rcv_privilege == RCPRIV_SYSTEM)
22517c478bd9Sstevel@tonic-gate 				break;
22527c478bd9Sstevel@tonic-gate 			mutex_enter(&pp->p_lock);
22537c478bd9Sstevel@tonic-gate 			error = rctl_local_delete(hndl, &oval, pp);
22547c478bd9Sstevel@tonic-gate 			mutex_exit(&pp->p_lock);
22557c478bd9Sstevel@tonic-gate 			ASSERT(error == 0);
22567c478bd9Sstevel@tonic-gate 		}
22577c478bd9Sstevel@tonic-gate 		error = nvpair_value_nvlist_array(nvp, &nvlarray, &nelem);
22587c478bd9Sstevel@tonic-gate 		ASSERT(error == 0);
22597c478bd9Sstevel@tonic-gate 		for (i = 0; i < nelem; i++) {
22607c478bd9Sstevel@tonic-gate 			rctl_val_t *nvalp;
22617c478bd9Sstevel@tonic-gate 
22627c478bd9Sstevel@tonic-gate 			nvalp = kmem_cache_alloc(rctl_val_cache, KM_SLEEP);
22637c478bd9Sstevel@tonic-gate 			error = nvlist2rctlval(nvlarray[i], nvalp);
22647c478bd9Sstevel@tonic-gate 			ASSERT(error == 0);
22657c478bd9Sstevel@tonic-gate 			/*
22667c478bd9Sstevel@tonic-gate 			 * rctl_local_insert can fail if the value being
22677c478bd9Sstevel@tonic-gate 			 * inserted is a duplicate; this is OK.
22687c478bd9Sstevel@tonic-gate 			 */
22697c478bd9Sstevel@tonic-gate 			mutex_enter(&pp->p_lock);
22707c478bd9Sstevel@tonic-gate 			if (rctl_local_insert(hndl, nvalp, pp) != 0)
22717c478bd9Sstevel@tonic-gate 				kmem_cache_free(rctl_val_cache, nvalp);
22727c478bd9Sstevel@tonic-gate 			mutex_exit(&pp->p_lock);
22737c478bd9Sstevel@tonic-gate 		}
22747c478bd9Sstevel@tonic-gate 	}
22757c478bd9Sstevel@tonic-gate 	/*
22767c478bd9Sstevel@tonic-gate 	 * Tell the world that we're done setting up.
22777c478bd9Sstevel@tonic-gate 	 *
22787c478bd9Sstevel@tonic-gate 	 * At this point we want to set the zone status to ZONE_IS_READY
22797c478bd9Sstevel@tonic-gate 	 * and atomically set the zone's processor set visibility.  Once
22807c478bd9Sstevel@tonic-gate 	 * we drop pool_lock() this zone will automatically get updated
22817c478bd9Sstevel@tonic-gate 	 * to reflect any future changes to the pools configuration.
22827c478bd9Sstevel@tonic-gate 	 */
22837c478bd9Sstevel@tonic-gate 	pool_lock();
22847c478bd9Sstevel@tonic-gate 	mutex_enter(&cpu_lock);
22857c478bd9Sstevel@tonic-gate 	mutex_enter(&zonehash_lock);
22867c478bd9Sstevel@tonic-gate 	zone_uniqid(zone);
22877c478bd9Sstevel@tonic-gate 	zone_zsd_configure(zone);
22887c478bd9Sstevel@tonic-gate 	if (pool_state == POOL_ENABLED)
22897c478bd9Sstevel@tonic-gate 		zone_pset_set(zone, pool_default->pool_pset->pset_id);
22907c478bd9Sstevel@tonic-gate 	mutex_enter(&zone_status_lock);
22917c478bd9Sstevel@tonic-gate 	ASSERT(zone_status_get(zone) == ZONE_IS_UNINITIALIZED);
22927c478bd9Sstevel@tonic-gate 	zone_status_set(zone, ZONE_IS_READY);
22937c478bd9Sstevel@tonic-gate 	mutex_exit(&zone_status_lock);
22947c478bd9Sstevel@tonic-gate 	mutex_exit(&zonehash_lock);
22957c478bd9Sstevel@tonic-gate 	mutex_exit(&cpu_lock);
22967c478bd9Sstevel@tonic-gate 	pool_unlock();
22977c478bd9Sstevel@tonic-gate 
22987c478bd9Sstevel@tonic-gate 	/*
22997c478bd9Sstevel@tonic-gate 	 * Once we see the zone transition to the ZONE_IS_BOOTING state,
23007c478bd9Sstevel@tonic-gate 	 * we launch init, and set the state to running.
23017c478bd9Sstevel@tonic-gate 	 */
23027c478bd9Sstevel@tonic-gate 	zone_status_wait_cpr(zone, ZONE_IS_BOOTING, "zsched");
23037c478bd9Sstevel@tonic-gate 
23047c478bd9Sstevel@tonic-gate 	if (zone_status_get(zone) == ZONE_IS_BOOTING) {
23057c478bd9Sstevel@tonic-gate 		id_t cid;
23067c478bd9Sstevel@tonic-gate 
23077c478bd9Sstevel@tonic-gate 		/*
23087c478bd9Sstevel@tonic-gate 		 * Ok, this is a little complicated.  We need to grab the
23097c478bd9Sstevel@tonic-gate 		 * zone's pool's scheduling class ID; note that by now, we
23107c478bd9Sstevel@tonic-gate 		 * are already bound to a pool if we need to be (zoneadmd
23117c478bd9Sstevel@tonic-gate 		 * will have done that to us while we're in the READY
23127c478bd9Sstevel@tonic-gate 		 * state).  *But* the scheduling class for the zone's 'init'
23137c478bd9Sstevel@tonic-gate 		 * must be explicitly passed to newproc, which doesn't
23147c478bd9Sstevel@tonic-gate 		 * respect pool bindings.
23157c478bd9Sstevel@tonic-gate 		 *
23167c478bd9Sstevel@tonic-gate 		 * We hold the pool_lock across the call to newproc() to
23177c478bd9Sstevel@tonic-gate 		 * close the obvious race: the pool's scheduling class
23187c478bd9Sstevel@tonic-gate 		 * could change before we manage to create the LWP with
23197c478bd9Sstevel@tonic-gate 		 * classid 'cid'.
23207c478bd9Sstevel@tonic-gate 		 */
23217c478bd9Sstevel@tonic-gate 		pool_lock();
23227c478bd9Sstevel@tonic-gate 		cid = pool_get_class(zone->zone_pool);
23237c478bd9Sstevel@tonic-gate 		if (cid == -1)
23247c478bd9Sstevel@tonic-gate 			cid = defaultcid;
23257c478bd9Sstevel@tonic-gate 
23267c478bd9Sstevel@tonic-gate 		/*
23277c478bd9Sstevel@tonic-gate 		 * If this fails, zone_boot will ultimately fail.  The
23287c478bd9Sstevel@tonic-gate 		 * state of the zone will be set to SHUTTING_DOWN-- userland
23297c478bd9Sstevel@tonic-gate 		 * will have to tear down the zone, and fail, or try again.
23307c478bd9Sstevel@tonic-gate 		 */
23317c478bd9Sstevel@tonic-gate 		if ((zone->zone_boot_err = newproc(zone_icode, NULL, cid,
23327c478bd9Sstevel@tonic-gate 		    minclsyspri - 1, &ct)) != 0) {
23337c478bd9Sstevel@tonic-gate 			mutex_enter(&zone_status_lock);
23347c478bd9Sstevel@tonic-gate 			zone_status_set(zone, ZONE_IS_SHUTTING_DOWN);
23357c478bd9Sstevel@tonic-gate 			mutex_exit(&zone_status_lock);
23367c478bd9Sstevel@tonic-gate 		}
23377c478bd9Sstevel@tonic-gate 		pool_unlock();
23387c478bd9Sstevel@tonic-gate 	}
23397c478bd9Sstevel@tonic-gate 
23407c478bd9Sstevel@tonic-gate 	/*
23417c478bd9Sstevel@tonic-gate 	 * Wait for zone_destroy() to be called.  This is what we spend
23427c478bd9Sstevel@tonic-gate 	 * most of our life doing.
23437c478bd9Sstevel@tonic-gate 	 */
23447c478bd9Sstevel@tonic-gate 	zone_status_wait_cpr(zone, ZONE_IS_DYING, "zsched");
23457c478bd9Sstevel@tonic-gate 
23467c478bd9Sstevel@tonic-gate 	if (ct)
23477c478bd9Sstevel@tonic-gate 		/*
23487c478bd9Sstevel@tonic-gate 		 * At this point the process contract should be empty.
23497c478bd9Sstevel@tonic-gate 		 * (Though if it isn't, it's not the end of the world.)
23507c478bd9Sstevel@tonic-gate 		 */
23517c478bd9Sstevel@tonic-gate 		VERIFY(contract_abandon(ct, curproc, B_TRUE) == 0);
23527c478bd9Sstevel@tonic-gate 
23537c478bd9Sstevel@tonic-gate 	/*
23547c478bd9Sstevel@tonic-gate 	 * Allow kcred to be freed when all referring processes
23557c478bd9Sstevel@tonic-gate 	 * (including this one) go away.  We can't just do this in
23567c478bd9Sstevel@tonic-gate 	 * zone_free because we need to wait for the zone_cred_ref to
23577c478bd9Sstevel@tonic-gate 	 * drop to 0 before calling zone_free, and the existence of
23587c478bd9Sstevel@tonic-gate 	 * zone_kcred will prevent that.  Thus, we call crfree here to
23597c478bd9Sstevel@tonic-gate 	 * balance the crdup in zone_create.  The crhold calls earlier
23607c478bd9Sstevel@tonic-gate 	 * in zsched will be dropped when the thread and process exit.
23617c478bd9Sstevel@tonic-gate 	 */
23627c478bd9Sstevel@tonic-gate 	crfree(zone->zone_kcred);
23637c478bd9Sstevel@tonic-gate 	zone->zone_kcred = NULL;
23647c478bd9Sstevel@tonic-gate 
23657c478bd9Sstevel@tonic-gate 	exit(CLD_EXITED, 0);
23667c478bd9Sstevel@tonic-gate }
23677c478bd9Sstevel@tonic-gate 
23687c478bd9Sstevel@tonic-gate /*
23697c478bd9Sstevel@tonic-gate  * Helper function to determine if there are any submounts of the
23707c478bd9Sstevel@tonic-gate  * provided path.  Used to make sure the zone doesn't "inherit" any
23717c478bd9Sstevel@tonic-gate  * mounts from before it is created.
23727c478bd9Sstevel@tonic-gate  */
23737c478bd9Sstevel@tonic-gate static uint_t
23747c478bd9Sstevel@tonic-gate zone_mount_count(const char *rootpath)
23757c478bd9Sstevel@tonic-gate {
23767c478bd9Sstevel@tonic-gate 	vfs_t *vfsp;
23777c478bd9Sstevel@tonic-gate 	uint_t count = 0;
23787c478bd9Sstevel@tonic-gate 	size_t rootpathlen = strlen(rootpath);
23797c478bd9Sstevel@tonic-gate 
23807c478bd9Sstevel@tonic-gate 	/*
23817c478bd9Sstevel@tonic-gate 	 * Holding zonehash_lock prevents race conditions with
23827c478bd9Sstevel@tonic-gate 	 * vfs_list_add()/vfs_list_remove() since we serialize with
23837c478bd9Sstevel@tonic-gate 	 * zone_find_by_path().
23847c478bd9Sstevel@tonic-gate 	 */
23857c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&zonehash_lock));
23867c478bd9Sstevel@tonic-gate 	/*
23877c478bd9Sstevel@tonic-gate 	 * The rootpath must end with a '/'
23887c478bd9Sstevel@tonic-gate 	 */
23897c478bd9Sstevel@tonic-gate 	ASSERT(rootpath[rootpathlen - 1] == '/');
23907c478bd9Sstevel@tonic-gate 
23917c478bd9Sstevel@tonic-gate 	/*
23927c478bd9Sstevel@tonic-gate 	 * This intentionally does not count the rootpath itself if that
23937c478bd9Sstevel@tonic-gate 	 * happens to be a mount point.
23947c478bd9Sstevel@tonic-gate 	 */
23957c478bd9Sstevel@tonic-gate 	vfs_list_read_lock();
23967c478bd9Sstevel@tonic-gate 	vfsp = rootvfs;
23977c478bd9Sstevel@tonic-gate 	do {
23987c478bd9Sstevel@tonic-gate 		if (strncmp(rootpath, refstr_value(vfsp->vfs_mntpt),
23997c478bd9Sstevel@tonic-gate 		    rootpathlen) == 0)
24007c478bd9Sstevel@tonic-gate 			count++;
24017c478bd9Sstevel@tonic-gate 		vfsp = vfsp->vfs_next;
24027c478bd9Sstevel@tonic-gate 	} while (vfsp != rootvfs);
24037c478bd9Sstevel@tonic-gate 	vfs_list_unlock();
24047c478bd9Sstevel@tonic-gate 	return (count);
24057c478bd9Sstevel@tonic-gate }
24067c478bd9Sstevel@tonic-gate 
24077c478bd9Sstevel@tonic-gate /*
24087c478bd9Sstevel@tonic-gate  * Helper function to make sure that a zone created on 'rootpath'
24097c478bd9Sstevel@tonic-gate  * wouldn't end up containing other zones' rootpaths.
24107c478bd9Sstevel@tonic-gate  */
24117c478bd9Sstevel@tonic-gate static boolean_t
24127c478bd9Sstevel@tonic-gate zone_is_nested(const char *rootpath)
24137c478bd9Sstevel@tonic-gate {
24147c478bd9Sstevel@tonic-gate 	zone_t *zone;
24157c478bd9Sstevel@tonic-gate 	size_t rootpathlen = strlen(rootpath);
24167c478bd9Sstevel@tonic-gate 	size_t len;
24177c478bd9Sstevel@tonic-gate 
24187c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_HELD(&zonehash_lock));
24197c478bd9Sstevel@tonic-gate 
24207c478bd9Sstevel@tonic-gate 	for (zone = list_head(&zone_active); zone != NULL;
24217c478bd9Sstevel@tonic-gate 	    zone = list_next(&zone_active, zone)) {
24227c478bd9Sstevel@tonic-gate 		if (zone == global_zone)
24237c478bd9Sstevel@tonic-gate 			continue;
24247c478bd9Sstevel@tonic-gate 		len = strlen(zone->zone_rootpath);
24257c478bd9Sstevel@tonic-gate 		if (strncmp(rootpath, zone->zone_rootpath,
24267c478bd9Sstevel@tonic-gate 		    MIN(rootpathlen, len)) == 0)
24277c478bd9Sstevel@tonic-gate 			return (B_TRUE);
24287c478bd9Sstevel@tonic-gate 	}
24297c478bd9Sstevel@tonic-gate 	return (B_FALSE);
24307c478bd9Sstevel@tonic-gate }
24317c478bd9Sstevel@tonic-gate 
24327c478bd9Sstevel@tonic-gate static int
2433*821c4a97Sdp zone_set_privset(zone_t *zone, const priv_set_t *zone_privs,
2434*821c4a97Sdp     size_t zone_privssz)
24357c478bd9Sstevel@tonic-gate {
24367c478bd9Sstevel@tonic-gate 	priv_set_t *privs = kmem_alloc(sizeof (priv_set_t), KM_SLEEP);
24377c478bd9Sstevel@tonic-gate 
2438*821c4a97Sdp 	if (zone_privssz < sizeof (priv_set_t))
2439*821c4a97Sdp 		return (set_errno(ENOMEM));
2440*821c4a97Sdp 
24417c478bd9Sstevel@tonic-gate 	if (copyin(zone_privs, privs, sizeof (priv_set_t))) {
24427c478bd9Sstevel@tonic-gate 		kmem_free(privs, sizeof (priv_set_t));
24437c478bd9Sstevel@tonic-gate 		return (EFAULT);
24447c478bd9Sstevel@tonic-gate 	}
24457c478bd9Sstevel@tonic-gate 
24467c478bd9Sstevel@tonic-gate 	zone->zone_privset = privs;
24477c478bd9Sstevel@tonic-gate 	return (0);
24487c478bd9Sstevel@tonic-gate }
24497c478bd9Sstevel@tonic-gate 
24507c478bd9Sstevel@tonic-gate /*
24517c478bd9Sstevel@tonic-gate  * We make creative use of nvlists to pass in rctls from userland.  The list is
24527c478bd9Sstevel@tonic-gate  * a list of the following structures:
24537c478bd9Sstevel@tonic-gate  *
24547c478bd9Sstevel@tonic-gate  * (name = rctl_name, value = nvpair_list_array)
24557c478bd9Sstevel@tonic-gate  *
24567c478bd9Sstevel@tonic-gate  * Where each element of the nvpair_list_array is of the form:
24577c478bd9Sstevel@tonic-gate  *
24587c478bd9Sstevel@tonic-gate  * [(name = "privilege", value = RCPRIV_PRIVILEGED),
24597c478bd9Sstevel@tonic-gate  * 	(name = "limit", value = uint64_t),
24607c478bd9Sstevel@tonic-gate  * 	(name = "action", value = (RCTL_LOCAL_NOACTION || RCTL_LOCAL_DENY))]
24617c478bd9Sstevel@tonic-gate  */
24627c478bd9Sstevel@tonic-gate static int
24637c478bd9Sstevel@tonic-gate parse_rctls(caddr_t ubuf, size_t buflen, nvlist_t **nvlp)
24647c478bd9Sstevel@tonic-gate {
24657c478bd9Sstevel@tonic-gate 	nvpair_t *nvp = NULL;
24667c478bd9Sstevel@tonic-gate 	nvlist_t *nvl = NULL;
24677c478bd9Sstevel@tonic-gate 	char *kbuf;
24687c478bd9Sstevel@tonic-gate 	int error;
24697c478bd9Sstevel@tonic-gate 	rctl_val_t rv;
24707c478bd9Sstevel@tonic-gate 
24717c478bd9Sstevel@tonic-gate 	*nvlp = NULL;
24727c478bd9Sstevel@tonic-gate 
24737c478bd9Sstevel@tonic-gate 	if (buflen == 0)
24747c478bd9Sstevel@tonic-gate 		return (0);
24757c478bd9Sstevel@tonic-gate 
24767c478bd9Sstevel@tonic-gate 	if ((kbuf = kmem_alloc(buflen, KM_NOSLEEP)) == NULL)
24777c478bd9Sstevel@tonic-gate 		return (ENOMEM);
24787c478bd9Sstevel@tonic-gate 	if (copyin(ubuf, kbuf, buflen)) {
24797c478bd9Sstevel@tonic-gate 		error = EFAULT;
24807c478bd9Sstevel@tonic-gate 		goto out;
24817c478bd9Sstevel@tonic-gate 	}
24827c478bd9Sstevel@tonic-gate 	if (nvlist_unpack(kbuf, buflen, &nvl, KM_SLEEP) != 0) {
24837c478bd9Sstevel@tonic-gate 		/*
24847c478bd9Sstevel@tonic-gate 		 * nvl may have been allocated/free'd, but the value set to
24857c478bd9Sstevel@tonic-gate 		 * non-NULL, so we reset it here.
24867c478bd9Sstevel@tonic-gate 		 */
24877c478bd9Sstevel@tonic-gate 		nvl = NULL;
24887c478bd9Sstevel@tonic-gate 		error = EINVAL;
24897c478bd9Sstevel@tonic-gate 		goto out;
24907c478bd9Sstevel@tonic-gate 	}
24917c478bd9Sstevel@tonic-gate 	while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
24927c478bd9Sstevel@tonic-gate 		rctl_dict_entry_t *rde;
24937c478bd9Sstevel@tonic-gate 		rctl_hndl_t hndl;
24947c478bd9Sstevel@tonic-gate 		nvlist_t **nvlarray;
24957c478bd9Sstevel@tonic-gate 		uint_t i, nelem;
24967c478bd9Sstevel@tonic-gate 		char *name;
24977c478bd9Sstevel@tonic-gate 
24987c478bd9Sstevel@tonic-gate 		error = EINVAL;
24997c478bd9Sstevel@tonic-gate 		name = nvpair_name(nvp);
25007c478bd9Sstevel@tonic-gate 		if (strncmp(nvpair_name(nvp), "zone.", sizeof ("zone.") - 1)
25017c478bd9Sstevel@tonic-gate 		    != 0 || nvpair_type(nvp) != DATA_TYPE_NVLIST_ARRAY) {
25027c478bd9Sstevel@tonic-gate 			goto out;
25037c478bd9Sstevel@tonic-gate 		}
25047c478bd9Sstevel@tonic-gate 		if ((hndl = rctl_hndl_lookup(name)) == -1) {
25057c478bd9Sstevel@tonic-gate 			goto out;
25067c478bd9Sstevel@tonic-gate 		}
25077c478bd9Sstevel@tonic-gate 		rde = rctl_dict_lookup_hndl(hndl);
25087c478bd9Sstevel@tonic-gate 		error = nvpair_value_nvlist_array(nvp, &nvlarray, &nelem);
25097c478bd9Sstevel@tonic-gate 		ASSERT(error == 0);
25107c478bd9Sstevel@tonic-gate 		for (i = 0; i < nelem; i++) {
25117c478bd9Sstevel@tonic-gate 			if (error = nvlist2rctlval(nvlarray[i], &rv))
25127c478bd9Sstevel@tonic-gate 				goto out;
25137c478bd9Sstevel@tonic-gate 		}
25147c478bd9Sstevel@tonic-gate 		if (rctl_invalid_value(rde, &rv)) {
25157c478bd9Sstevel@tonic-gate 			error = EINVAL;
25167c478bd9Sstevel@tonic-gate 			goto out;
25177c478bd9Sstevel@tonic-gate 		}
25187c478bd9Sstevel@tonic-gate 	}
25197c478bd9Sstevel@tonic-gate 	error = 0;
25207c478bd9Sstevel@tonic-gate 	*nvlp = nvl;
25217c478bd9Sstevel@tonic-gate out:
25227c478bd9Sstevel@tonic-gate 	kmem_free(kbuf, buflen);
25237c478bd9Sstevel@tonic-gate 	if (error && nvl != NULL)
25247c478bd9Sstevel@tonic-gate 		nvlist_free(nvl);
25257c478bd9Sstevel@tonic-gate 	return (error);
25267c478bd9Sstevel@tonic-gate }
25277c478bd9Sstevel@tonic-gate 
25287c478bd9Sstevel@tonic-gate int
25297c478bd9Sstevel@tonic-gate zone_create_error(int er_error, int er_ext, int *er_out) {
25307c478bd9Sstevel@tonic-gate 	if (er_out != NULL) {
25317c478bd9Sstevel@tonic-gate 		if (copyout(&er_ext, er_out, sizeof (int))) {
25327c478bd9Sstevel@tonic-gate 			return (set_errno(EFAULT));
25337c478bd9Sstevel@tonic-gate 		}
25347c478bd9Sstevel@tonic-gate 	}
25357c478bd9Sstevel@tonic-gate 	return (set_errno(er_error));
25367c478bd9Sstevel@tonic-gate }
25377c478bd9Sstevel@tonic-gate 
2538fa9e4066Sahrens /*
2539fa9e4066Sahrens  * Parses a comma-separated list of ZFS datasets into a per-zone dictionary.
2540fa9e4066Sahrens  */
2541fa9e4066Sahrens static int
2542fa9e4066Sahrens parse_zfs(zone_t *zone, caddr_t ubuf, size_t buflen)
2543fa9e4066Sahrens {
2544fa9e4066Sahrens 	char *kbuf;
2545fa9e4066Sahrens 	char *dataset, *next;
2546fa9e4066Sahrens 	zone_dataset_t *zd;
2547fa9e4066Sahrens 	size_t len;
2548fa9e4066Sahrens 
2549fa9e4066Sahrens 	if (ubuf == NULL || buflen == 0)
2550fa9e4066Sahrens 		return (0);
2551fa9e4066Sahrens 
2552fa9e4066Sahrens 	if ((kbuf = kmem_alloc(buflen, KM_NOSLEEP)) == NULL)
2553fa9e4066Sahrens 		return (ENOMEM);
2554fa9e4066Sahrens 
2555fa9e4066Sahrens 	if (copyin(ubuf, kbuf, buflen) != 0) {
2556fa9e4066Sahrens 		kmem_free(kbuf, buflen);
2557fa9e4066Sahrens 		return (EFAULT);
2558fa9e4066Sahrens 	}
2559fa9e4066Sahrens 
2560fa9e4066Sahrens 	dataset = next = kbuf;
2561fa9e4066Sahrens 	for (;;) {
2562fa9e4066Sahrens 		zd = kmem_alloc(sizeof (zone_dataset_t), KM_SLEEP);
2563fa9e4066Sahrens 
2564fa9e4066Sahrens 		next = strchr(dataset, ',');
2565fa9e4066Sahrens 
2566fa9e4066Sahrens 		if (next == NULL)
2567fa9e4066Sahrens 			len = strlen(dataset);
2568fa9e4066Sahrens 		else
2569fa9e4066Sahrens 			len = next - dataset;
2570fa9e4066Sahrens 
2571fa9e4066Sahrens 		zd->zd_dataset = kmem_alloc(len + 1, KM_SLEEP);
2572fa9e4066Sahrens 		bcopy(dataset, zd->zd_dataset, len);
2573fa9e4066Sahrens 		zd->zd_dataset[len] = '\0';
2574fa9e4066Sahrens 
2575fa9e4066Sahrens 		list_insert_head(&zone->zone_datasets, zd);
2576fa9e4066Sahrens 
2577fa9e4066Sahrens 		if (next == NULL)
2578fa9e4066Sahrens 			break;
2579fa9e4066Sahrens 
2580fa9e4066Sahrens 		dataset = next + 1;
2581fa9e4066Sahrens 	}
2582fa9e4066Sahrens 
2583fa9e4066Sahrens 	kmem_free(kbuf, buflen);
2584fa9e4066Sahrens 	return (0);
2585fa9e4066Sahrens }
2586fa9e4066Sahrens 
25877c478bd9Sstevel@tonic-gate /*
25887c478bd9Sstevel@tonic-gate  * System call to create/initialize a new zone named 'zone_name', rooted
25897c478bd9Sstevel@tonic-gate  * at 'zone_root', with a zone-wide privilege limit set of 'zone_privs',
25907c478bd9Sstevel@tonic-gate  * and initialized with the zone-wide rctls described in 'rctlbuf'.
25917c478bd9Sstevel@tonic-gate  *
25927c478bd9Sstevel@tonic-gate  * If extended error is non-null, we may use it to return more detailed
25937c478bd9Sstevel@tonic-gate  * error information.
25947c478bd9Sstevel@tonic-gate  */
25957c478bd9Sstevel@tonic-gate static zoneid_t
25967c478bd9Sstevel@tonic-gate zone_create(const char *zone_name, const char *zone_root,
2597*821c4a97Sdp     const priv_set_t *zone_privs, size_t zone_privssz,
2598*821c4a97Sdp     caddr_t rctlbuf, size_t rctlbufsz,
2599fa9e4066Sahrens     caddr_t zfsbuf, size_t zfsbufsz, int *extended_error)
26007c478bd9Sstevel@tonic-gate {
26017c478bd9Sstevel@tonic-gate 	struct zsched_arg zarg;
26027c478bd9Sstevel@tonic-gate 	nvlist_t *rctls = NULL;
26037c478bd9Sstevel@tonic-gate 	proc_t *pp = curproc;
26047c478bd9Sstevel@tonic-gate 	zone_t *zone, *ztmp;
26057c478bd9Sstevel@tonic-gate 	zoneid_t zoneid;
26067c478bd9Sstevel@tonic-gate 	int error;
26077c478bd9Sstevel@tonic-gate 	int error2 = 0;
26087c478bd9Sstevel@tonic-gate 	char *str;
26097c478bd9Sstevel@tonic-gate 	cred_t *zkcr;
26107c478bd9Sstevel@tonic-gate 
26117c478bd9Sstevel@tonic-gate 	if (secpolicy_zone_config(CRED()) != 0)
26127c478bd9Sstevel@tonic-gate 		return (set_errno(EPERM));
26137c478bd9Sstevel@tonic-gate 
26147c478bd9Sstevel@tonic-gate 	/* can't boot zone from within chroot environment */
26157c478bd9Sstevel@tonic-gate 	if (PTOU(pp)->u_rdir != NULL && PTOU(pp)->u_rdir != rootdir)
26167c478bd9Sstevel@tonic-gate 		return (zone_create_error(ENOTSUP, ZE_CHROOTED,
2617*821c4a97Sdp 		    extended_error));
26187c478bd9Sstevel@tonic-gate 
26197c478bd9Sstevel@tonic-gate 	zone = kmem_zalloc(sizeof (zone_t), KM_SLEEP);
26207c478bd9Sstevel@tonic-gate 	zoneid = zone->zone_id = id_alloc(zoneid_space);
26217c478bd9Sstevel@tonic-gate 	zone->zone_status = ZONE_IS_UNINITIALIZED;
26227c478bd9Sstevel@tonic-gate 	zone->zone_pool = pool_default;
26237c478bd9Sstevel@tonic-gate 	zone->zone_pool_mod = gethrtime();
26247c478bd9Sstevel@tonic-gate 	zone->zone_psetid = ZONE_PS_INVAL;
26257c478bd9Sstevel@tonic-gate 	zone->zone_ncpus = 0;
26267c478bd9Sstevel@tonic-gate 	zone->zone_ncpus_online = 0;
26277c478bd9Sstevel@tonic-gate 	mutex_init(&zone->zone_lock, NULL, MUTEX_DEFAULT, NULL);
26287c478bd9Sstevel@tonic-gate 	mutex_init(&zone->zone_nlwps_lock, NULL, MUTEX_DEFAULT, NULL);
26297c478bd9Sstevel@tonic-gate 	cv_init(&zone->zone_cv, NULL, CV_DEFAULT, NULL);
26307c478bd9Sstevel@tonic-gate 	list_create(&zone->zone_zsd, sizeof (struct zsd_entry),
26317c478bd9Sstevel@tonic-gate 	    offsetof(struct zsd_entry, zsd_linkage));
2632fa9e4066Sahrens 	list_create(&zone->zone_datasets, sizeof (zone_dataset_t),
2633fa9e4066Sahrens 	    offsetof(zone_dataset_t, zd_linkage));
26347c478bd9Sstevel@tonic-gate 
26357c478bd9Sstevel@tonic-gate 	if ((error = zone_set_name(zone, zone_name)) != 0) {
26367c478bd9Sstevel@tonic-gate 		zone_free(zone);
26377c478bd9Sstevel@tonic-gate 		return (zone_create_error(error, 0, extended_error));
26387c478bd9Sstevel@tonic-gate 	}
26397c478bd9Sstevel@tonic-gate 
26407c478bd9Sstevel@tonic-gate 	if ((error = zone_set_root(zone, zone_root)) != 0) {
26417c478bd9Sstevel@tonic-gate 		zone_free(zone);
26427c478bd9Sstevel@tonic-gate 		return (zone_create_error(error, 0, extended_error));
26437c478bd9Sstevel@tonic-gate 	}
2644*821c4a97Sdp 	if ((error = zone_set_privset(zone, zone_privs, zone_privssz)) != 0) {
26457c478bd9Sstevel@tonic-gate 		zone_free(zone);
26467c478bd9Sstevel@tonic-gate 		return (zone_create_error(error, 0, extended_error));
26477c478bd9Sstevel@tonic-gate 	}
26487c478bd9Sstevel@tonic-gate 
26497c478bd9Sstevel@tonic-gate 	/* initialize node name to be the same as zone name */
26507c478bd9Sstevel@tonic-gate 	zone->zone_nodename = kmem_alloc(_SYS_NMLN, KM_SLEEP);
26517c478bd9Sstevel@tonic-gate 	(void) strncpy(zone->zone_nodename, zone->zone_name, _SYS_NMLN);
26527c478bd9Sstevel@tonic-gate 	zone->zone_nodename[_SYS_NMLN - 1] = '\0';
26537c478bd9Sstevel@tonic-gate 
26547c478bd9Sstevel@tonic-gate 	zone->zone_domain = kmem_alloc(_SYS_NMLN, KM_SLEEP);
26557c478bd9Sstevel@tonic-gate 	zone->zone_domain[0] = '\0';
26567c478bd9Sstevel@tonic-gate 	zone->zone_shares = 1;
26577c478bd9Sstevel@tonic-gate 	zone->zone_bootargs = NULL;
26587c478bd9Sstevel@tonic-gate 
26597c478bd9Sstevel@tonic-gate 	/*
26607c478bd9Sstevel@tonic-gate 	 * Zsched initializes the rctls.
26617c478bd9Sstevel@tonic-gate 	 */
26627c478bd9Sstevel@tonic-gate 	zone->zone_rctls = NULL;
26637c478bd9Sstevel@tonic-gate 
26647c478bd9Sstevel@tonic-gate 	if ((error = parse_rctls(rctlbuf, rctlbufsz, &rctls)) != 0) {
26657c478bd9Sstevel@tonic-gate 		zone_free(zone);
26667c478bd9Sstevel@tonic-gate 		return (zone_create_error(error, 0, extended_error));
26677c478bd9Sstevel@tonic-gate 	}
26687c478bd9Sstevel@tonic-gate 
2669fa9e4066Sahrens 	if ((error = parse_zfs(zone, zfsbuf, zfsbufsz)) != 0) {
2670fa9e4066Sahrens 		zone_free(zone);
2671fa9e4066Sahrens 		return (set_errno(error));
2672fa9e4066Sahrens 	}
2673fa9e4066Sahrens 
26747c478bd9Sstevel@tonic-gate 	/*
26757c478bd9Sstevel@tonic-gate 	 * Stop all lwps since that's what normally happens as part of fork().
26767c478bd9Sstevel@tonic-gate 	 * This needs to happen before we grab any locks to avoid deadlock
26777c478bd9Sstevel@tonic-gate 	 * (another lwp in the process could be waiting for the held lock).
26787c478bd9Sstevel@tonic-gate 	 */
26797c478bd9Sstevel@tonic-gate 	if (curthread != pp->p_agenttp && !holdlwps(SHOLDFORK)) {
26807c478bd9Sstevel@tonic-gate 		zone_free(zone);
26817c478bd9Sstevel@tonic-gate 		if (rctls)
26827c478bd9Sstevel@tonic-gate 			nvlist_free(rctls);
26837c478bd9Sstevel@tonic-gate 		return (zone_create_error(error, 0, extended_error));
26847c478bd9Sstevel@tonic-gate 	}
26857c478bd9Sstevel@tonic-gate 
26867c478bd9Sstevel@tonic-gate 	if (block_mounts() == 0) {
26877c478bd9Sstevel@tonic-gate 		mutex_enter(&pp->p_lock);
26887c478bd9Sstevel@tonic-gate 		if (curthread != pp->p_agenttp)
26897c478bd9Sstevel@tonic-gate 			continuelwps(pp);
26907c478bd9Sstevel@tonic-gate 		mutex_exit(&pp->p_lock);
26917c478bd9Sstevel@tonic-gate 		zone_free(zone);
26927c478bd9Sstevel@tonic-gate 		if (rctls)
26937c478bd9Sstevel@tonic-gate 			nvlist_free(rctls);
26947c478bd9Sstevel@tonic-gate 		return (zone_create_error(error, 0, extended_error));
26957c478bd9Sstevel@tonic-gate 	}
26967c478bd9Sstevel@tonic-gate 
26977c478bd9Sstevel@tonic-gate 	/*
26987c478bd9Sstevel@tonic-gate 	 * Set up credential for kernel access.  After this, any errors
26997c478bd9Sstevel@tonic-gate 	 * should go through the dance in errout rather than calling
27007c478bd9Sstevel@tonic-gate 	 * zone_free directly.
27017c478bd9Sstevel@tonic-gate 	 */
27027c478bd9Sstevel@tonic-gate 	zone->zone_kcred = crdup(kcred);
27037c478bd9Sstevel@tonic-gate 	crsetzone(zone->zone_kcred, zone);
27047c478bd9Sstevel@tonic-gate 	priv_intersect(zone->zone_privset, &CR_PPRIV(zone->zone_kcred));
27057c478bd9Sstevel@tonic-gate 	priv_intersect(zone->zone_privset, &CR_EPRIV(zone->zone_kcred));
27067c478bd9Sstevel@tonic-gate 	priv_intersect(zone->zone_privset, &CR_IPRIV(zone->zone_kcred));
27077c478bd9Sstevel@tonic-gate 	priv_intersect(zone->zone_privset, &CR_LPRIV(zone->zone_kcred));
27087c478bd9Sstevel@tonic-gate 
27097c478bd9Sstevel@tonic-gate 	mutex_enter(&zonehash_lock);
27107c478bd9Sstevel@tonic-gate 	/*
27117c478bd9Sstevel@tonic-gate 	 * Make sure zone doesn't already exist.
27127c478bd9Sstevel@tonic-gate 	 */
27137c478bd9Sstevel@tonic-gate 	if ((ztmp = zone_find_all_by_name(zone->zone_name)) != NULL) {
27147c478bd9Sstevel@tonic-gate 		zone_status_t status;
27157c478bd9Sstevel@tonic-gate 
27167c478bd9Sstevel@tonic-gate 		status = zone_status_get(ztmp);
27177c478bd9Sstevel@tonic-gate 		if (status == ZONE_IS_READY || status == ZONE_IS_RUNNING)
27187c478bd9Sstevel@tonic-gate 			error = EEXIST;
27197c478bd9Sstevel@tonic-gate 		else
27207c478bd9Sstevel@tonic-gate 			error = EBUSY;
27217c478bd9Sstevel@tonic-gate 		goto errout;
27227c478bd9Sstevel@tonic-gate 	}
27237c478bd9Sstevel@tonic-gate 
27247c478bd9Sstevel@tonic-gate 	/*
27257c478bd9Sstevel@tonic-gate 	 * Don't allow zone creations which would cause one zone's rootpath to
27267c478bd9Sstevel@tonic-gate 	 * be accessible from that of another (non-global) zone.
27277c478bd9Sstevel@tonic-gate 	 */
27287c478bd9Sstevel@tonic-gate 	if (zone_is_nested(zone->zone_rootpath)) {
27297c478bd9Sstevel@tonic-gate 		error = EBUSY;
27307c478bd9Sstevel@tonic-gate 		goto errout;
27317c478bd9Sstevel@tonic-gate 	}
27327c478bd9Sstevel@tonic-gate 
27337c478bd9Sstevel@tonic-gate 	ASSERT(zonecount != 0);		/* check for leaks */
27347c478bd9Sstevel@tonic-gate 	if (zonecount + 1 > maxzones) {
27357c478bd9Sstevel@tonic-gate 		error = ENOMEM;
27367c478bd9Sstevel@tonic-gate 		goto errout;
27377c478bd9Sstevel@tonic-gate 	}
27387c478bd9Sstevel@tonic-gate 
27397c478bd9Sstevel@tonic-gate 	if (zone_mount_count(zone->zone_rootpath) != 0) {
27407c478bd9Sstevel@tonic-gate 		error = EBUSY;
27417c478bd9Sstevel@tonic-gate 		error2 = ZE_AREMOUNTS;
27427c478bd9Sstevel@tonic-gate 		goto errout;
27437c478bd9Sstevel@tonic-gate 	}
27447c478bd9Sstevel@tonic-gate 
27457c478bd9Sstevel@tonic-gate 	/*
27467c478bd9Sstevel@tonic-gate 	 * Zone is still incomplete, but we need to drop all locks while
27477c478bd9Sstevel@tonic-gate 	 * zsched() initializes this zone's kernel process.  We
27487c478bd9Sstevel@tonic-gate 	 * optimistically add the zone to the hashtable and associated
27497c478bd9Sstevel@tonic-gate 	 * lists so a parallel zone_create() doesn't try to create the
27507c478bd9Sstevel@tonic-gate 	 * same zone.
27517c478bd9Sstevel@tonic-gate 	 */
27527c478bd9Sstevel@tonic-gate 	zonecount++;
27537c478bd9Sstevel@tonic-gate 	(void) mod_hash_insert(zonehashbyid,
27547c478bd9Sstevel@tonic-gate 	    (mod_hash_key_t)(uintptr_t)zone->zone_id,
27557c478bd9Sstevel@tonic-gate 	    (mod_hash_val_t)(uintptr_t)zone);
27567c478bd9Sstevel@tonic-gate 	str = kmem_alloc(strlen(zone->zone_name) + 1, KM_SLEEP);
27577c478bd9Sstevel@tonic-gate 	(void) strcpy(str, zone->zone_name);
27587c478bd9Sstevel@tonic-gate 	(void) mod_hash_insert(zonehashbyname, (mod_hash_key_t)str,
27597c478bd9Sstevel@tonic-gate 	    (mod_hash_val_t)(uintptr_t)zone);
27607c478bd9Sstevel@tonic-gate 	/*
27617c478bd9Sstevel@tonic-gate 	 * Insert into active list.  At this point there are no 'hold's
27627c478bd9Sstevel@tonic-gate 	 * on the zone, but everyone else knows not to use it, so we can
27637c478bd9Sstevel@tonic-gate 	 * continue to use it.  zsched() will do a zone_hold() if the
27647c478bd9Sstevel@tonic-gate 	 * newproc() is successful.
27657c478bd9Sstevel@tonic-gate 	 */
27667c478bd9Sstevel@tonic-gate 	list_insert_tail(&zone_active, zone);
27677c478bd9Sstevel@tonic-gate 	mutex_exit(&zonehash_lock);
27687c478bd9Sstevel@tonic-gate 
27697c478bd9Sstevel@tonic-gate 	zarg.zone = zone;
27707c478bd9Sstevel@tonic-gate 	zarg.nvlist = rctls;
27717c478bd9Sstevel@tonic-gate 	/*
27727c478bd9Sstevel@tonic-gate 	 * The process, task, and project rctls are probably wrong;
27737c478bd9Sstevel@tonic-gate 	 * we need an interface to get the default values of all rctls,
27747c478bd9Sstevel@tonic-gate 	 * and initialize zsched appropriately.  I'm not sure that that
27757c478bd9Sstevel@tonic-gate 	 * makes much of a difference, though.
27767c478bd9Sstevel@tonic-gate 	 */
27777c478bd9Sstevel@tonic-gate 	if (error = newproc(zsched, (void *)&zarg, syscid, minclsyspri, NULL)) {
27787c478bd9Sstevel@tonic-gate 		/*
27797c478bd9Sstevel@tonic-gate 		 * We need to undo all globally visible state.
27807c478bd9Sstevel@tonic-gate 		 */
27817c478bd9Sstevel@tonic-gate 		mutex_enter(&zonehash_lock);
27827c478bd9Sstevel@tonic-gate 		list_remove(&zone_active, zone);
27837c478bd9Sstevel@tonic-gate 		(void) mod_hash_destroy(zonehashbyname,
27847c478bd9Sstevel@tonic-gate 		    (mod_hash_key_t)(uintptr_t)zone->zone_name);
27857c478bd9Sstevel@tonic-gate 		(void) mod_hash_destroy(zonehashbyid,
27867c478bd9Sstevel@tonic-gate 		    (mod_hash_key_t)(uintptr_t)zone->zone_id);
27877c478bd9Sstevel@tonic-gate 		ASSERT(zonecount > 1);
27887c478bd9Sstevel@tonic-gate 		zonecount--;
27897c478bd9Sstevel@tonic-gate 		goto errout;
27907c478bd9Sstevel@tonic-gate 	}
27917c478bd9Sstevel@tonic-gate 
27927c478bd9Sstevel@tonic-gate 	/*
27937c478bd9Sstevel@tonic-gate 	 * Zone creation can't fail from now on.
27947c478bd9Sstevel@tonic-gate 	 */
27957c478bd9Sstevel@tonic-gate 
27967c478bd9Sstevel@tonic-gate 	/*
27977c478bd9Sstevel@tonic-gate 	 * Let the other lwps continue.
27987c478bd9Sstevel@tonic-gate 	 */
27997c478bd9Sstevel@tonic-gate 	mutex_enter(&pp->p_lock);
28007c478bd9Sstevel@tonic-gate 	if (curthread != pp->p_agenttp)
28017c478bd9Sstevel@tonic-gate 		continuelwps(pp);
28027c478bd9Sstevel@tonic-gate 	mutex_exit(&pp->p_lock);
28037c478bd9Sstevel@tonic-gate 
28047c478bd9Sstevel@tonic-gate 	/*
28057c478bd9Sstevel@tonic-gate 	 * Wait for zsched to finish initializing the zone.
28067c478bd9Sstevel@tonic-gate 	 */
28077c478bd9Sstevel@tonic-gate 	zone_status_wait(zone, ZONE_IS_READY);
28087c478bd9Sstevel@tonic-gate 	/*
28097c478bd9Sstevel@tonic-gate 	 * The zone is fully visible, so we can let mounts progress.
28107c478bd9Sstevel@tonic-gate 	 */
28117c478bd9Sstevel@tonic-gate 	resume_mounts();
28127c478bd9Sstevel@tonic-gate 	if (rctls)
28137c478bd9Sstevel@tonic-gate 		nvlist_free(rctls);
28147c478bd9Sstevel@tonic-gate 
28157c478bd9Sstevel@tonic-gate 	return (zoneid);
28167c478bd9Sstevel@tonic-gate 
28177c478bd9Sstevel@tonic-gate errout:
28187c478bd9Sstevel@tonic-gate 	mutex_exit(&zonehash_lock);
28197c478bd9Sstevel@tonic-gate 	/*
28207c478bd9Sstevel@tonic-gate 	 * Let the other lwps continue.
28217c478bd9Sstevel@tonic-gate 	 */
28227c478bd9Sstevel@tonic-gate 	mutex_enter(&pp->p_lock);
28237c478bd9Sstevel@tonic-gate 	if (curthread != pp->p_agenttp)
28247c478bd9Sstevel@tonic-gate 		continuelwps(pp);
28257c478bd9Sstevel@tonic-gate 	mutex_exit(&pp->p_lock);
28267c478bd9Sstevel@tonic-gate 
28277c478bd9Sstevel@tonic-gate 	resume_mounts();
28287c478bd9Sstevel@tonic-gate 	if (rctls)
28297c478bd9Sstevel@tonic-gate 		nvlist_free(rctls);
28307c478bd9Sstevel@tonic-gate 	/*
28317c478bd9Sstevel@tonic-gate 	 * There is currently one reference to the zone, a cred_ref from
28327c478bd9Sstevel@tonic-gate 	 * zone_kcred.  To free the zone, we call crfree, which will call
28337c478bd9Sstevel@tonic-gate 	 * zone_cred_rele, which will call zone_free.
28347c478bd9Sstevel@tonic-gate 	 */
28357c478bd9Sstevel@tonic-gate 	ASSERT(zone->zone_cred_ref == 1);	/* for zone_kcred */
28367c478bd9Sstevel@tonic-gate 	ASSERT(zone->zone_kcred->cr_ref == 1);
28377c478bd9Sstevel@tonic-gate 	ASSERT(zone->zone_ref == 0);
28387c478bd9Sstevel@tonic-gate 	zkcr = zone->zone_kcred;
28397c478bd9Sstevel@tonic-gate 	zone->zone_kcred = NULL;
28407c478bd9Sstevel@tonic-gate 	crfree(zkcr);				/* triggers call to zone_free */
28417c478bd9Sstevel@tonic-gate 	return (zone_create_error(error, error2, extended_error));
28427c478bd9Sstevel@tonic-gate }
28437c478bd9Sstevel@tonic-gate 
28447c478bd9Sstevel@tonic-gate /*
28457c478bd9Sstevel@tonic-gate  * Cause the zone to boot.  This is pretty simple, since we let zoneadmd do
28467c478bd9Sstevel@tonic-gate  * the heavy lifting.
28477c478bd9Sstevel@tonic-gate  */
28487c478bd9Sstevel@tonic-gate static int
28497c478bd9Sstevel@tonic-gate zone_boot(zoneid_t zoneid, const char *bootargs)
28507c478bd9Sstevel@tonic-gate {
28517c478bd9Sstevel@tonic-gate 	int err;
28527c478bd9Sstevel@tonic-gate 	zone_t *zone;
28537c478bd9Sstevel@tonic-gate 
28547c478bd9Sstevel@tonic-gate 	if (secpolicy_zone_config(CRED()) != 0)
28557c478bd9Sstevel@tonic-gate 		return (set_errno(EPERM));
28567c478bd9Sstevel@tonic-gate 	if (zoneid < MIN_USERZONEID || zoneid > MAX_ZONEID)
28577c478bd9Sstevel@tonic-gate 		return (set_errno(EINVAL));
28587c478bd9Sstevel@tonic-gate 
28597c478bd9Sstevel@tonic-gate 	mutex_enter(&zonehash_lock);
28607c478bd9Sstevel@tonic-gate 	/*
28617c478bd9Sstevel@tonic-gate 	 * Look for zone under hash lock to prevent races with calls to
28627c478bd9Sstevel@tonic-gate 	 * zone_shutdown, zone_destroy, etc.
28637c478bd9Sstevel@tonic-gate 	 */
28647c478bd9Sstevel@tonic-gate 	if ((zone = zone_find_all_by_id(zoneid)) == NULL) {
28657c478bd9Sstevel@tonic-gate 		mutex_exit(&zonehash_lock);
28667c478bd9Sstevel@tonic-gate 		return (set_errno(EINVAL));
28677c478bd9Sstevel@tonic-gate 	}
28687c478bd9Sstevel@tonic-gate 
28697c478bd9Sstevel@tonic-gate 	if ((err = zone_set_bootargs(zone, bootargs)) != 0) {
28707c478bd9Sstevel@tonic-gate 		mutex_exit(&zonehash_lock);
28717c478bd9Sstevel@tonic-gate 		return (set_errno(err));
28727c478bd9Sstevel@tonic-gate 	}
28737c478bd9Sstevel@tonic-gate 
28747c478bd9Sstevel@tonic-gate 	mutex_enter(&zone_status_lock);
28757c478bd9Sstevel@tonic-gate 	if (zone_status_get(zone) != ZONE_IS_READY) {
28767c478bd9Sstevel@tonic-gate 		mutex_exit(&zone_status_lock);
28777c478bd9Sstevel@tonic-gate 		mutex_exit(&zonehash_lock);
28787c478bd9Sstevel@tonic-gate 		return (set_errno(EINVAL));
28797c478bd9Sstevel@tonic-gate 	}
28807c478bd9Sstevel@tonic-gate 	zone_status_set(zone, ZONE_IS_BOOTING);
28817c478bd9Sstevel@tonic-gate 	mutex_exit(&zone_status_lock);
28827c478bd9Sstevel@tonic-gate 
28837c478bd9Sstevel@tonic-gate 	zone_hold(zone);	/* so we can use the zone_t later */
28847c478bd9Sstevel@tonic-gate 	mutex_exit(&zonehash_lock);
28857c478bd9Sstevel@tonic-gate 
28867c478bd9Sstevel@tonic-gate 	if (zone_status_wait_sig(zone, ZONE_IS_RUNNING) == 0) {
28877c478bd9Sstevel@tonic-gate 		zone_rele(zone);
28887c478bd9Sstevel@tonic-gate 		return (set_errno(EINTR));
28897c478bd9Sstevel@tonic-gate 	}
28907c478bd9Sstevel@tonic-gate 
28917c478bd9Sstevel@tonic-gate 	/*
28927c478bd9Sstevel@tonic-gate 	 * Boot (starting init) might have failed, in which case the zone
28937c478bd9Sstevel@tonic-gate 	 * will go to the SHUTTING_DOWN state; an appropriate errno will
28947c478bd9Sstevel@tonic-gate 	 * be placed in zone->zone_boot_err, and so we return that.
28957c478bd9Sstevel@tonic-gate 	 */
28967c478bd9Sstevel@tonic-gate 	err = zone->zone_boot_err;
28977c478bd9Sstevel@tonic-gate 	zone_rele(zone);
28987c478bd9Sstevel@tonic-gate 	return (err ? set_errno(err) : 0);
28997c478bd9Sstevel@tonic-gate }
29007c478bd9Sstevel@tonic-gate 
29017c478bd9Sstevel@tonic-gate /*
29027c478bd9Sstevel@tonic-gate  * Kills all user processes in the zone, waiting for them all to exit
29037c478bd9Sstevel@tonic-gate  * before returning.
29047c478bd9Sstevel@tonic-gate  */
29057c478bd9Sstevel@tonic-gate static int
29067c478bd9Sstevel@tonic-gate zone_empty(zone_t *zone)
29077c478bd9Sstevel@tonic-gate {
29087c478bd9Sstevel@tonic-gate 	int waitstatus;
29097c478bd9Sstevel@tonic-gate 
29107c478bd9Sstevel@tonic-gate 	/*
29117c478bd9Sstevel@tonic-gate 	 * We need to drop zonehash_lock before killing all
29127c478bd9Sstevel@tonic-gate 	 * processes, otherwise we'll deadlock with zone_find_*
29137c478bd9Sstevel@tonic-gate 	 * which can be called from the exit path.
29147c478bd9Sstevel@tonic-gate 	 */
29157c478bd9Sstevel@tonic-gate 	ASSERT(MUTEX_NOT_HELD(&zonehash_lock));
29167c478bd9Sstevel@tonic-gate 	while ((waitstatus = zone_status_timedwait_sig(zone, lbolt + hz,
29177c478bd9Sstevel@tonic-gate 	    ZONE_IS_EMPTY)) == -1) {
29187c478bd9Sstevel@tonic-gate 		killall(zone->zone_id);
29197c478bd9Sstevel@tonic-gate 	}
29207c478bd9Sstevel@tonic-gate 	/*
29217c478bd9Sstevel@tonic-gate 	 * return EINTR if we were signaled
29227c478bd9Sstevel@tonic-gate 	 */
29237c478bd9Sstevel@tonic-gate 	if (waitstatus == 0)
29247c478bd9Sstevel@tonic-gate 		return (EINTR);
29257c478bd9Sstevel@tonic-gate 	return (0);
29267c478bd9Sstevel@tonic-gate }
29277c478bd9Sstevel@tonic-gate 
29287c478bd9Sstevel@tonic-gate /*
29297c478bd9Sstevel@tonic-gate  * Systemcall to start the zone's halt sequence.  By the time this
29307c478bd9Sstevel@tonic-gate  * function successfully returns, all user processes and kernel threads
29317c478bd9Sstevel@tonic-gate  * executing in it will have exited, ZSD shutdown callbacks executed,
29327c478bd9Sstevel@tonic-gate  * and the zone status set to ZONE_IS_DOWN.
29337c478bd9Sstevel@tonic-gate  *
29347c478bd9Sstevel@tonic-gate  * It is possible that the call will interrupt itself if the caller is the
29357c478bd9Sstevel@tonic-gate  * parent of any process running in the zone, and doesn't have SIGCHLD blocked.
29367c478bd9Sstevel@tonic-gate  */
29377c478bd9Sstevel@tonic-gate static int
29387c478bd9Sstevel@tonic-gate zone_shutdown(zoneid_t zoneid)
29397c478bd9Sstevel@tonic-gate {
29407c478bd9Sstevel@tonic-gate 	int error;
29417c478bd9Sstevel@tonic-gate 	zone_t *zone;
29427c478bd9Sstevel@tonic-gate 	zone_status_t status;
29437c478bd9Sstevel@tonic-gate 
29447c478bd9Sstevel@tonic-gate 	if (secpolicy_zone_config(CRED()) != 0)
29457c478bd9Sstevel@tonic-gate 		return (set_errno(EPERM));
29467c478bd9Sstevel@tonic-gate 	if (zoneid < MIN_USERZONEID || zoneid > MAX_ZONEID)
29477c478bd9Sstevel@tonic-gate 		return (set_errno(EINVAL));
29487c478bd9Sstevel@tonic-gate 
29497c478bd9Sstevel@tonic-gate 	/*
29507c478bd9Sstevel@tonic-gate 	 * Block mounts so that VFS_MOUNT() can get an accurate view of
29517c478bd9Sstevel@tonic-gate 	 * the zone's status with regards to ZONE_IS_SHUTTING down.
29527c478bd9Sstevel@tonic-gate 	 *
29537c478bd9Sstevel@tonic-gate 	 * e.g. NFS can fail the mount if it determines that the zone
29547c478bd9Sstevel@tonic-gate 	 * has already begun the shutdown sequence.
29557c478bd9Sstevel@tonic-gate 	 */
29567c478bd9Sstevel@tonic-gate 	if (block_mounts() == 0)
29577c478bd9Sstevel@tonic-gate 		return (set_errno(EINTR));
29587c478bd9Sstevel@tonic-gate 	mutex_enter(&zonehash_lock);
29597c478bd9Sstevel@tonic-gate 	/*
29607c478bd9Sstevel@tonic-gate 	 * Look for zone under hash lock to prevent races with other
29617c478bd9Sstevel@tonic-gate 	 * calls to zone_shutdown and zone_destroy.
29627c478bd9Sstevel@tonic-gate 	 */
29637c478bd9Sstevel@tonic-gate 	if ((zone = zone_find_all_by_id(zoneid)) == NULL) {
29647c478bd9Sstevel@tonic-gate 		mutex_exit(&zonehash_lock);
29657c478bd9Sstevel@tonic-gate 		resume_mounts();
29667c478bd9Sstevel@tonic-gate 		return (set_errno(EINVAL));
29677c478bd9Sstevel@tonic-gate 	}
29687c478bd9Sstevel@tonic-gate 	mutex_enter(&zone_status_lock);
29697c478bd9Sstevel@tonic-gate 	status = zone_status_get(zone);
29707c478bd9Sstevel@tonic-gate 	/*
29717c478bd9Sstevel@tonic-gate 	 * Fail if the zone isn't fully initialized yet.
29727c478bd9Sstevel@tonic-gate 	 */
29737c478bd9Sstevel@tonic-gate 	if (status < ZONE_IS_READY) {
29747c478bd9Sstevel@tonic-gate 		mutex_exit(&zone_status_lock);
29757c478bd9Sstevel@tonic-gate 		mutex_exit(&zonehash_lock);
29767c478bd9Sstevel@tonic-gate 		resume_mounts();
29777c478bd9Sstevel@tonic-gate 		return (set_errno(EINVAL));
29787c478bd9Sstevel@tonic-gate 	}
29797c478bd9Sstevel@tonic-gate 	/*
29807c478bd9Sstevel@tonic-gate 	 * If conditions required for zone_shutdown() to return have been met,
29817c478bd9Sstevel@tonic-gate 	 * return success.
29827c478bd9Sstevel@tonic-gate 	 */
29837c478bd9Sstevel@tonic-gate 	if (status >= ZONE_IS_DOWN) {
29847c478bd9Sstevel@tonic-gate 		mutex_exit(&zone_status_lock);
29857c478bd9Sstevel@tonic-gate 		mutex_exit(&zonehash_lock);
29867c478bd9Sstevel@tonic-gate 		resume_mounts();
29877c478bd9Sstevel@tonic-gate 		return (0);
29887c478bd9Sstevel@tonic-gate 	}
29897c478bd9Sstevel@tonic-gate 	/*
29907c478bd9Sstevel@tonic-gate 	 * If zone_shutdown() hasn't been called before, go through the motions.
29917c478bd9Sstevel@tonic-gate 	 * If it has, there's nothing to do but wait for the kernel threads to
29927c478bd9Sstevel@tonic-gate 	 * drain.
29937c478bd9Sstevel@tonic-gate 	 */
29947c478bd9Sstevel@tonic-gate 	if (status < ZONE_IS_EMPTY) {
29957c478bd9Sstevel@tonic-gate 		uint_t ntasks;
29967c478bd9Sstevel@tonic-gate 
29977c478bd9Sstevel@tonic-gate 		mutex_enter(&zone->zone_lock);
29987c478bd9Sstevel@tonic-gate 		if ((ntasks = zone->zone_ntasks) != 1) {
29997c478bd9Sstevel@tonic-gate 			/*
30007c478bd9Sstevel@tonic-gate 			 * There's still stuff running.
30017c478bd9Sstevel@tonic-gate 			 */
30027c478bd9Sstevel@tonic-gate 			zone_status_set(zone, ZONE_IS_SHUTTING_DOWN);
30037c478bd9Sstevel@tonic-gate 		}
30047c478bd9Sstevel@tonic-gate 		mutex_exit(&zone->zone_lock);
30057c478bd9Sstevel@tonic-gate 		if (ntasks == 1) {
30067c478bd9Sstevel@tonic-gate 			/*
30077c478bd9Sstevel@tonic-gate 			 * The only way to create another task is through
30087c478bd9Sstevel@tonic-gate 			 * zone_enter(), which will block until we drop
30097c478bd9Sstevel@tonic-gate 			 * zonehash_lock.  The zone is empty.
30107c478bd9Sstevel@tonic-gate 			 */
30117c478bd9Sstevel@tonic-gate 			if (zone->zone_kthreads == NULL) {
30127c478bd9Sstevel@tonic-gate 				/*
30137c478bd9Sstevel@tonic-gate 				 * Skip ahead to ZONE_IS_DOWN
30147c478bd9Sstevel@tonic-gate 				 */
30157c478bd9Sstevel@tonic-gate 				zone_status_set(zone, ZONE_IS_DOWN);
30167c478bd9Sstevel@tonic-gate 			} else {
30177c478bd9Sstevel@tonic-gate 				zone_status_set(zone, ZONE_IS_EMPTY);
30187c478bd9Sstevel@tonic-gate 			}
30197c478bd9Sstevel@tonic-gate 		}
30207c478bd9Sstevel@tonic-gate 	}
30217c478bd9Sstevel@tonic-gate 	zone_hold(zone);	/* so we can use the zone_t later */
30227c478bd9Sstevel@tonic-gate 	mutex_exit(&zone_status_lock);
30237c478bd9Sstevel@tonic-gate 	mutex_exit(&zonehash_lock);
30247c478bd9Sstevel@tonic-gate 	resume_mounts();
30257c478bd9Sstevel@tonic-gate 
30267c478bd9Sstevel@tonic-gate 	if (error = zone_empty(zone)) {
30277c478bd9Sstevel@tonic-gate 		zone_rele(zone);
30287c478bd9Sstevel@tonic-gate 		return (set_errno(error));
30297c478bd9Sstevel@tonic-gate 	}
30307c478bd9Sstevel@tonic-gate 	/*
30317c478bd9Sstevel@tonic-gate 	 * After the zone status goes to ZONE_IS_DOWN this zone will no
30327c478bd9Sstevel@tonic-gate 	 * longer be notified of changes to the pools configuration, so
30337c478bd9Sstevel@tonic-gate 	 * in order to not end up with a stale pool pointer, we point
30347c478bd9Sstevel@tonic-gate 	 * ourselves at the default pool and remove all resource
30357c478bd9Sstevel@tonic-gate 	 * visibility.  This is especially important as the zone_t may
30367c478bd9Sstevel@tonic-gate 	 * languish on the deathrow for a very long time waiting for
30377c478bd9Sstevel@tonic-gate 	 * cred's to drain out.
30387c478bd9Sstevel@tonic-gate 	 *
30397c478bd9Sstevel@tonic-gate 	 * This rebinding of the zone can happen multiple times
30407c478bd9Sstevel@tonic-gate 	 * (presumably due to interrupted or parallel systemcalls)
30417c478bd9Sstevel@tonic-gate 	 * without any adverse effects.
30427c478bd9Sstevel@tonic-gate 	 */
30437c478bd9Sstevel@tonic-gate 	if (pool_lock_intr() != 0) {
30447c478bd9Sstevel@tonic-gate 		zone_rele(zone);
30457c478bd9Sstevel@tonic-gate 		return (set_errno(EINTR));
30467c478bd9Sstevel@tonic-gate 	}
30477c478bd9Sstevel@tonic-gate 	if (pool_state == POOL_ENABLED) {
30487c478bd9Sstevel@tonic-gate 		mutex_enter(&cpu_lock);
30497c478bd9Sstevel@tonic-gate 		zone_pool_set(zone, pool_default);
30507c478bd9Sstevel@tonic-gate 		/*
30517c478bd9Sstevel@tonic-gate 		 * The zone no longer needs to be able to see any cpus.
30527c478bd9Sstevel@tonic-gate 		 */
30537c478bd9Sstevel@tonic-gate 		zone_pset_set(zone, ZONE_PS_INVAL);
30547c478bd9Sstevel@tonic-gate 		mutex_exit(&cpu_lock);
30557c478bd9Sstevel@tonic-gate 	}
30567c478bd9Sstevel@tonic-gate 	pool_unlock();
30577c478bd9Sstevel@tonic-gate 
30587c478bd9Sstevel@tonic-gate 	/*
30597c478bd9Sstevel@tonic-gate 	 * ZSD shutdown callbacks can be executed multiple times, hence
30607c478bd9Sstevel@tonic-gate 	 * it is safe to not be holding any locks across this call.
30617c478bd9Sstevel@tonic-gate 	 */
30627c478bd9Sstevel@tonic-gate 	zone_zsd_callbacks(zone, ZSD_SHUTDOWN);
30637c478bd9Sstevel@tonic-gate 
30647c478bd9Sstevel@tonic-gate 	mutex_enter(&zone_status_lock);
30657c478bd9Sstevel@tonic-gate 	if (zone->zone_kthreads == NULL && zone_status_get(zone) < ZONE_IS_DOWN)
30667c478bd9Sstevel@tonic-gate 		zone_status_set(zone, ZONE_IS_DOWN);
30677c478bd9Sstevel@tonic-gate 	mutex_exit(&zone_status_lock);
30687c478bd9Sstevel@tonic-gate 
30697c478bd9Sstevel@tonic-gate 	/*
30707c478bd9Sstevel@tonic-gate 	 * Wait for kernel threads to drain.
30717c478bd9Sstevel@tonic-gate 	 */
30727c478bd9Sstevel@tonic-gate 	if (!zone_status_wait_sig(zone, ZONE_IS_DOWN)) {
30737c478bd9Sstevel@tonic-gate 		zone_rele(zone);
30747c478bd9Sstevel@tonic-gate 		return (set_errno(EINTR));
30757c478bd9Sstevel@tonic-gate 	}
30767c478bd9Sstevel@tonic-gate 	zone_rele(zone);
30777c478bd9Sstevel@tonic-gate 	return (0);
30787c478bd9Sstevel@tonic-gate }
30797c478bd9Sstevel@tonic-gate 
30807c478bd9Sstevel@tonic-gate /*
30817c478bd9Sstevel@tonic-gate  * Systemcall entry point to finalize the zone halt process.  The caller
30827c478bd9Sstevel@tonic-gate  * must have already successfully callefd zone_shutdown().
30837c478bd9Sstevel@tonic-gate  *
30847c478bd9Sstevel@tonic-gate  * Upon successful completion, the zone will have been fully destroyed:
30857c478bd9Sstevel@tonic-gate  * zsched will have exited, destructor callbacks executed, and the zone
30867c478bd9Sstevel@tonic-gate  * removed from the list of active zones.
30877c478bd9Sstevel@tonic-gate  */
30887c478bd9Sstevel@tonic-gate static int
30897c478bd9Sstevel@tonic-gate zone_destroy(zoneid_t zoneid)
30907c478bd9Sstevel@tonic-gate {
30917c478bd9Sstevel@tonic-gate 	uint64_t uniqid;
30927c478bd9Sstevel@tonic-gate 	zone_t *zone;
30937c478bd9Sstevel@tonic-gate 	zone_status_t status;
30947c478bd9Sstevel@tonic-gate 
30957c478bd9Sstevel@tonic-gate 	if (secpolicy_zone_config(CRED()) != 0)
30967c478bd9Sstevel@tonic-gate 		return (set_errno(EPERM));
30977c478bd9Sstevel@tonic-gate 	if (zoneid < MIN_USERZONEID || zoneid > MAX_ZONEID)
30987c478bd9Sstevel@tonic-gate 		return (set_errno(EINVAL));
30997c478bd9Sstevel@tonic-gate 
31007c478bd9Sstevel@tonic-gate 	mutex_enter(&zonehash_lock);
31017c478bd9Sstevel@tonic-gate 	/*
31027c478bd9Sstevel@tonic-gate 	 * Look for zone under hash lock to prevent races with other
31037c478bd9Sstevel@tonic-gate 	 * calls to zone_destroy.
31047c478bd9Sstevel@tonic-gate 	 */
31057c478bd9Sstevel@tonic-gate 	if ((zone = zone_find_all_by_id(zoneid)) == NULL) {
31067c478bd9Sstevel@tonic-gate 		mutex_exit(&zonehash_lock);
31077c478bd9Sstevel@tonic-gate 		return (set_errno(EINVAL));
31087c478bd9Sstevel@tonic-gate 	}
31097c478bd9Sstevel@tonic-gate 
31107c478bd9Sstevel@tonic-gate 	if (zone_mount_count(zone->zone_rootpath) != 0) {
31117c478bd9Sstevel@tonic-gate 		mutex_exit(&zonehash_lock);
31127c478bd9Sstevel@tonic-gate 		return (set_errno(EBUSY));
31137c478bd9Sstevel@tonic-gate 	}
31147c478bd9Sstevel@tonic-gate 	mutex_enter(&zone_status_lock);
31157c478bd9Sstevel@tonic-gate 	status = zone_status_get(zone);
31167c478bd9Sstevel@tonic-gate 	if (status < ZONE_IS_DOWN) {
31177c478bd9Sstevel@tonic-gate 		mutex_exit(&zone_status_lock);
31187c478bd9Sstevel@tonic-gate 		mutex_exit(&zonehash_lock);
31197c478bd9Sstevel@tonic-gate 		return (set_errno(EBUSY));
31207c478bd9Sstevel@tonic-gate 	} else if (status == ZONE_IS_DOWN) {
31217c478bd9Sstevel@tonic-gate 		zone_status_set(zone, ZONE_IS_DYING); /* Tell zsched to exit */
31227c478bd9Sstevel@tonic-gate 	}
31237c478bd9Sstevel@tonic-gate 	mutex_exit(&zone_status_lock);
31247c478bd9Sstevel@tonic-gate 	zone_hold(zone);
31257c478bd9Sstevel@tonic-gate 	mutex_exit(&zonehash_lock);
31267c478bd9Sstevel@tonic-gate 
31277c478bd9Sstevel@tonic-gate 	/*
31287c478bd9Sstevel@tonic-gate 	 * wait for zsched to exit
31297c478bd9Sstevel@tonic-gate 	 */
31307c478bd9Sstevel@tonic-gate 	zone_status_wait(zone, ZONE_IS_DEAD);
31317c478bd9Sstevel@tonic-gate 	zone_zsd_callbacks(zone, ZSD_DESTROY);
31327c478bd9Sstevel@tonic-gate 	uniqid = zone->zone_uniqid;
31337c478bd9Sstevel@tonic-gate 	zone_rele(zone);
31347c478bd9Sstevel@tonic-gate 	zone = NULL;	/* potentially free'd */
31357c478bd9Sstevel@tonic-gate 
31367c478bd9Sstevel@tonic-gate 	mutex_enter(&zonehash_lock);
31377c478bd9Sstevel@tonic-gate 	for (; /* ever */; ) {
31387c478bd9Sstevel@tonic-gate 		boolean_t unref;
31397c478bd9Sstevel@tonic-gate 
31407c478bd9Sstevel@tonic-gate 		if ((zone = zone_find_all_by_id(zoneid)) == NULL ||
31417c478bd9Sstevel@tonic-gate 		    zone->zone_uniqid != uniqid) {
31427c478bd9Sstevel@tonic-gate 			/*
31437c478bd9Sstevel@tonic-gate 			 * The zone has gone away.  Necessary conditions
31447c478bd9Sstevel@tonic-gate 			 * are met, so we return success.
31457c478bd9Sstevel@tonic-gate 			 */
31467c478bd9Sstevel@tonic-gate 			mutex_exit(&zonehash_lock);
31477c478bd9Sstevel@tonic-gate 			return (0);
31487c478bd9Sstevel@tonic-gate 		}
31497c478bd9Sstevel@tonic-gate 		mutex_enter(&zone->zone_lock);
31507c478bd9Sstevel@tonic-gate 		unref = ZONE_IS_UNREF(zone);
31517c478bd9Sstevel@tonic-gate 		mutex_exit(&zone->zone_lock);
31527c478bd9Sstevel@tonic-gate 		if (unref) {
31537c478bd9Sstevel@tonic-gate 			/*
31547c478bd9Sstevel@tonic-gate 			 * There is only one reference to the zone -- that
31557c478bd9Sstevel@tonic-gate 			 * added when the zone was added to the hashtables --
31567c478bd9Sstevel@tonic-gate 			 * and things will remain this way until we drop
31577c478bd9Sstevel@tonic-gate 			 * zonehash_lock... we can go ahead and cleanup the
31587c478bd9Sstevel@tonic-gate 			 * zone.
31597c478bd9Sstevel@tonic-gate 			 */
31607c478bd9Sstevel@tonic-gate 			break;
31617c478bd9Sstevel@tonic-gate 		}
31627c478bd9Sstevel@tonic-gate 
31637c478bd9Sstevel@tonic-gate 		if (cv_wait_sig(&zone_destroy_cv, &zonehash_lock) == 0) {
31647c478bd9Sstevel@tonic-gate 			/* Signaled */
31657c478bd9Sstevel@tonic-gate 			mutex_exit(&zonehash_lock);
31667c478bd9Sstevel@tonic-gate 			return (set_errno(EINTR));
31677c478bd9Sstevel@tonic-gate 		}
31687c478bd9Sstevel@tonic-gate 
31697c478bd9Sstevel@tonic-gate 	}
31707c478bd9Sstevel@tonic-gate 
31717c478bd9Sstevel@tonic-gate 	/*
31727c478bd9Sstevel@tonic-gate 	 * It is now safe to let the zone be recreated; remove it from the
31737c478bd9Sstevel@tonic-gate 	 * lists.  The memory will not be freed until the last cred
31747c478bd9Sstevel@tonic-gate 	 * reference goes away.
31757c478bd9Sstevel@tonic-gate 	 */
31767c478bd9Sstevel@tonic-gate 	ASSERT(zonecount > 1);	/* must be > 1; can't destroy global zone */
31777c478bd9Sstevel@tonic-gate 	zonecount--;
31787c478bd9Sstevel@tonic-gate 	/* remove from active list and hash tables */
31797c478bd9Sstevel@tonic-gate 	list_remove(&zone_active, zone);
31807c478bd9Sstevel@tonic-gate 	(void) mod_hash_destroy(zonehashbyname,
31817c478bd9Sstevel@tonic-gate 	    (mod_hash_key_t)zone->zone_name);
31827c478bd9Sstevel@tonic-gate 	(void) mod_hash_destroy(zonehashbyid,
31837c478bd9Sstevel@tonic-gate 	    (mod_hash_key_t)(uintptr_t)zone->zone_id);
31847c478bd9Sstevel@tonic-gate 	mutex_exit(&zonehash_lock);
31857c478bd9Sstevel@tonic-gate 
3186108322fbScarlsonj 	/*
3187108322fbScarlsonj 	 * Release the root vnode; we're not using it anymore.  Nor should any
3188108322fbScarlsonj 	 * other thread that might access it exist.
3189108322fbScarlsonj 	 */
3190108322fbScarlsonj 	if (zone->zone_rootvp != NULL) {
3191108322fbScarlsonj 		VN_RELE(zone->zone_rootvp);
3192108322fbScarlsonj 		zone->zone_rootvp = NULL;
3193108322fbScarlsonj 	}
3194108322fbScarlsonj 
31957c478bd9Sstevel@tonic-gate 	/* add to deathrow list */
31967c478bd9Sstevel@tonic-gate 	mutex_enter(&zone_deathrow_lock);
31977c478bd9Sstevel@tonic-gate 	list_insert_tail(&zone_deathrow, zone);
31987c478bd9Sstevel@tonic-gate 	mutex_exit(&zone_deathrow_lock);
31997c478bd9Sstevel@tonic-gate 
32007c478bd9Sstevel@tonic-gate 	/*
32017c478bd9Sstevel@tonic-gate 	 * Drop last reference (which was added by zsched()), this will
32027c478bd9Sstevel@tonic-gate 	 * free the zone unless there are outstanding cred references.
32037c478bd9Sstevel@tonic-gate 	 */
32047c478bd9Sstevel@tonic-gate 	zone_rele(zone);
32057c478bd9Sstevel@tonic-gate 	return (0);
32067c478bd9Sstevel@tonic-gate }
32077c478bd9Sstevel@tonic-gate 
32087c478bd9Sstevel@tonic-gate /*
32097c478bd9Sstevel@tonic-gate  * Systemcall entry point for zone_getattr(2).
32107c478bd9Sstevel@tonic-gate  */
32117c478bd9Sstevel@tonic-gate static ssize_t
32127c478bd9Sstevel@tonic-gate zone_getattr(zoneid_t zoneid, int attr, void *buf, size_t bufsize)
32137c478bd9Sstevel@tonic-gate {
32147c478bd9Sstevel@tonic-gate 	size_t size;
32157c478bd9Sstevel@tonic-gate 	int error = 0, err;
32167c478bd9Sstevel@tonic-gate 	zone_t *zone;
32177c478bd9Sstevel@tonic-gate 	char *zonepath;
32187c478bd9Sstevel@tonic-gate 	zone_status_t zone_status;
32197c478bd9Sstevel@tonic-gate 	pid_t initpid;
32207c478bd9Sstevel@tonic-gate 	boolean_t global = (curproc->p_zone == global_zone);
32217c478bd9Sstevel@tonic-gate 
32227c478bd9Sstevel@tonic-gate 	mutex_enter(&zonehash_lock);
32237c478bd9Sstevel@tonic-gate 	if ((zone = zone_find_all_by_id(zoneid)) == NULL) {
32247c478bd9Sstevel@tonic-gate 		mutex_exit(&zonehash_lock);
32257c478bd9Sstevel@tonic-gate 		return (set_errno(EINVAL));
32267c478bd9Sstevel@tonic-gate 	}
32277c478bd9Sstevel@tonic-gate 	zone_status = zone_status_get(zone);
32287c478bd9Sstevel@tonic-gate 	if (zone_status < ZONE_IS_READY) {
32297c478bd9Sstevel@tonic-gate 		mutex_exit(&zonehash_lock);
32307c478bd9Sstevel@tonic-gate 		return (set_errno(EINVAL));
32317c478bd9Sstevel@tonic-gate 	}
32327c478bd9Sstevel@tonic-gate 	zone_hold(zone);
32337c478bd9Sstevel@tonic-gate 	mutex_exit(&zonehash_lock);
32347c478bd9Sstevel@tonic-gate 
32357c478bd9Sstevel@tonic-gate 	/*
32367c478bd9Sstevel@tonic-gate 	 * If not in the global zone, don't show information about other zones.
32377c478bd9Sstevel@tonic-gate 	 */
32387c478bd9Sstevel@tonic-gate 	if (!global && curproc->p_zone != zone) {
32397c478bd9Sstevel@tonic-gate 		zone_rele(zone);
32407c478bd9Sstevel@tonic-gate 		return (set_errno(EINVAL));
32417c478bd9Sstevel@tonic-gate 	}
32427c478bd9Sstevel@tonic-gate 
32437c478bd9Sstevel@tonic-gate 	switch (attr) {
32447c478bd9Sstevel@tonic-gate 	case ZONE_ATTR_ROOT:
32457c478bd9Sstevel@tonic-gate 		if (global) {
32467c478bd9Sstevel@tonic-gate 			/*
32477c478bd9Sstevel@tonic-gate 			 * Copy the path to trim the trailing "/" (except for
32487c478bd9Sstevel@tonic-gate 			 * the global zone).
32497c478bd9Sstevel@tonic-gate 			 */
32507c478bd9Sstevel@tonic-gate 			if (zone != global_zone)
32517c478bd9Sstevel@tonic-gate 				size = zone->zone_rootpathlen - 1;
32527c478bd9Sstevel@tonic-gate 			else
32537c478bd9Sstevel@tonic-gate 				size = zone->zone_rootpathlen;
32547c478bd9Sstevel@tonic-gate 			zonepath = kmem_alloc(size, KM_SLEEP);
32557c478bd9Sstevel@tonic-gate 			bcopy(zone->zone_rootpath, zonepath, size);
32567c478bd9Sstevel@tonic-gate 			zonepath[size - 1] = '\0';
32577c478bd9Sstevel@tonic-gate 		} else {
32587c478bd9Sstevel@tonic-gate 			/*
32597c478bd9Sstevel@tonic-gate 			 * Caller is not in the global zone, just return
32607c478bd9Sstevel@tonic-gate 			 * faked-up path for current zone.
32617c478bd9Sstevel@tonic-gate 			 */
32627c478bd9Sstevel@tonic-gate 			zonepath = "/";
32637c478bd9Sstevel@tonic-gate 			size = 2;
32647c478bd9Sstevel@tonic-gate 		}
32657c478bd9Sstevel@tonic-gate 		if (bufsize > size)
32667c478bd9Sstevel@tonic-gate 			bufsize = size;
32677c478bd9Sstevel@tonic-gate 		if (buf != NULL) {
32687c478bd9Sstevel@tonic-gate 			err = copyoutstr(zonepath, buf, bufsize, NULL);
32697c478bd9Sstevel@tonic-gate 			if (err != 0 && err != ENAMETOOLONG)
32707c478bd9Sstevel@tonic-gate 				error = EFAULT;
32717c478bd9Sstevel@tonic-gate 		}
32727c478bd9Sstevel@tonic-gate 		if (global)
32737c478bd9Sstevel@tonic-gate 			kmem_free(zonepath, size);
32747c478bd9Sstevel@tonic-gate 		break;
32757c478bd9Sstevel@tonic-gate 
32767c478bd9Sstevel@tonic-gate 	case ZONE_ATTR_NAME:
32777c478bd9Sstevel@tonic-gate 		size = strlen(zone->zone_name) + 1;
32787c478bd9Sstevel@tonic-gate 		if (bufsize > size)
32797c478bd9Sstevel@tonic-gate 			bufsize = size;
32807c478bd9Sstevel@tonic-gate 		if (buf != NULL) {
32817c478bd9Sstevel@tonic-gate 			err = copyoutstr(zone->zone_name, buf, bufsize, NULL);
32827c478bd9Sstevel@tonic-gate 			if (err != 0 && err != ENAMETOOLONG)
32837c478bd9Sstevel@tonic-gate 				error = EFAULT;
32847c478bd9Sstevel@tonic-gate 		}
32857c478bd9Sstevel@tonic-gate 		break;
32867c478bd9Sstevel@tonic-gate 
32877c478bd9Sstevel@tonic-gate 	case ZONE_ATTR_STATUS:
32887c478bd9Sstevel@tonic-gate 		/*
32897c478bd9Sstevel@tonic-gate 		 * Since we're not holding zonehash_lock, the zone status
32907c478bd9Sstevel@tonic-gate 		 * may be anything; leave it up to userland to sort it out.
32917c478bd9Sstevel@tonic-gate 		 */
32927c478bd9Sstevel@tonic-gate 		size = sizeof (zone_status);
32937c478bd9Sstevel@tonic-gate 		if (bufsize > size)
32947c478bd9Sstevel@tonic-gate 			bufsize = size;
32957c478bd9Sstevel@tonic-gate 		zone_status = zone_status_get(zone);
32967c478bd9Sstevel@tonic-gate 		if (buf != NULL &&
32977c478bd9Sstevel@tonic-gate 		    copyout(&zone_status, buf, bufsize) != 0)
32987c478bd9Sstevel@tonic-gate 			error = EFAULT;
32997c478bd9Sstevel@tonic-gate 		break;
33007c478bd9Sstevel@tonic-gate 	case ZONE_ATTR_PRIVSET:
33017c478bd9Sstevel@tonic-gate 		size = sizeof (priv_set_t);
33027c478bd9Sstevel@tonic-gate 		if (bufsize > size)
33037c478bd9Sstevel@tonic-gate 			bufsize = size;
33047c478bd9Sstevel@tonic-gate 		if (buf != NULL &&
33057c478bd9Sstevel@tonic-gate 		    copyout(zone->zone_privset, buf, bufsize) != 0)
33067c478bd9Sstevel@tonic-gate 			error = EFAULT;
33077c478bd9Sstevel@tonic-gate 		break;
33087c478bd9Sstevel@tonic-gate 	case ZONE_ATTR_UNIQID:
33097c478bd9Sstevel@tonic-gate 		size = sizeof (zone->zone_uniqid);
33107c478bd9Sstevel@tonic-gate 		if (bufsize > size)
33117c478bd9Sstevel@tonic-gate 			bufsize = size;
33127c478bd9Sstevel@tonic-gate 		if (buf != NULL &&
33137c478bd9Sstevel@tonic-gate 		    copyout(&zone->zone_uniqid, buf, bufsize) != 0)
33147c478bd9Sstevel@tonic-gate 			error = EFAULT;
33157c478bd9Sstevel@tonic-gate 		break;
33167c478bd9Sstevel@tonic-gate 	case ZONE_ATTR_POOLID:
33177c478bd9Sstevel@tonic-gate 		{
33187c478bd9Sstevel@tonic-gate 			pool_t *pool;
33197c478bd9Sstevel@tonic-gate 			poolid_t poolid;
33207c478bd9Sstevel@tonic-gate 
33217c478bd9Sstevel@tonic-gate 			if (pool_lock_intr() != 0) {
33227c478bd9Sstevel@tonic-gate 				error = EINTR;
33237c478bd9Sstevel@tonic-gate 				break;
33247c478bd9Sstevel@tonic-gate 			}
33257c478bd9Sstevel@tonic-gate 			pool = zone_pool_get(zone);
33267c478bd9Sstevel@tonic-gate 			poolid = pool->pool_id;
33277c478bd9Sstevel@tonic-gate 			pool_unlock();
33287c478bd9Sstevel@tonic-gate 			size = sizeof (poolid);
33297c478bd9Sstevel@tonic-gate 			if (bufsize > size)
33307c478bd9Sstevel@tonic-gate 				bufsize = size;
33317c478bd9Sstevel@tonic-gate 			if (buf != NULL && copyout(&poolid, buf, size) != 0)
33327c478bd9Sstevel@tonic-gate 				error = EFAULT;
33337c478bd9Sstevel@tonic-gate 		}
33347c478bd9Sstevel@tonic-gate 		break;
33357c478bd9Sstevel@tonic-gate 	case ZONE_ATTR_INITPID:
33367c478bd9Sstevel@tonic-gate 		size = sizeof (initpid);
33377c478bd9Sstevel@tonic-gate 		if (bufsize > size)
33387c478bd9Sstevel@tonic-gate 			bufsize = size;
33397c478bd9Sstevel@tonic-gate 		initpid = zone->zone_proc_initpid;
33407c478bd9Sstevel@tonic-gate 		if (initpid == -1) {
33417c478bd9Sstevel@tonic-gate 			error = ESRCH;
33427c478bd9Sstevel@tonic-gate 			break;
33437c478bd9Sstevel@tonic-gate 		}
33447c478bd9Sstevel@tonic-gate 		if (buf != NULL &&
33457c478bd9Sstevel@tonic-gate 		    copyout(&initpid, buf, bufsize) != 0)
33467c478bd9Sstevel@tonic-gate 			error = EFAULT;
33477c478bd9Sstevel@tonic-gate 		break;
33487c478bd9Sstevel@tonic-gate 	default:
33497c478bd9Sstevel@tonic-gate 		error = EINVAL;
33507c478bd9Sstevel@tonic-gate 	}
33517c478bd9Sstevel@tonic-gate 	zone_rele(zone);
33527c478bd9Sstevel@tonic-gate 
33537c478bd9Sstevel@tonic-gate 	if (error)
33547c478bd9Sstevel@tonic-gate 		return (set_errno(error));
33557c478bd9Sstevel@tonic-gate 	return ((ssize_t)size);
33567c478bd9Sstevel@tonic-gate }
33577c478bd9Sstevel@tonic-gate 
33587c478bd9Sstevel@tonic-gate /*
33597c478bd9Sstevel@tonic-gate  * Return zero if the process has at least one vnode mapped in to its
33607c478bd9Sstevel@tonic-gate  * address space which shouldn't be allowed to change zones.
33617c478bd9Sstevel@tonic-gate  */
33627c478bd9Sstevel@tonic-gate static int
33637c478bd9Sstevel@tonic-gate as_can_change_zones(void)
33647c478bd9Sstevel@tonic-gate {
33657c478bd9Sstevel@tonic-gate 	proc_t *pp = curproc;
33667c478bd9Sstevel@tonic-gate 	struct seg *seg;
33677c478bd9Sstevel@tonic-gate 	struct as *as = pp->p_as;
33687c478bd9Sstevel@tonic-gate 	vnode_t *vp;
33697c478bd9Sstevel@tonic-gate 	int allow = 1;
33707c478bd9Sstevel@tonic-gate 
33717c478bd9Sstevel@tonic-gate 	ASSERT(pp->p_as != &kas);
33727c478bd9Sstevel@tonic-gate 	AS_LOCK_ENTER(&as, &as->a_lock, RW_READER);
33737c478bd9Sstevel@tonic-gate 	for (seg = AS_SEGFIRST(as); seg != NULL; seg = AS_SEGNEXT(as, seg)) {
33747c478bd9Sstevel@tonic-gate 		/*
33757c478bd9Sstevel@tonic-gate 		 * if we can't get a backing vnode for this segment then skip
33767c478bd9Sstevel@tonic-gate 		 * it.
33777c478bd9Sstevel@tonic-gate 		 */
33787c478bd9Sstevel@tonic-gate 		vp = NULL;
33797c478bd9Sstevel@tonic-gate 		if (SEGOP_GETVP(seg, seg->s_base, &vp) != 0 || vp == NULL)
33807c478bd9Sstevel@tonic-gate 			continue;
33817c478bd9Sstevel@tonic-gate 		if (!vn_can_change_zones(vp)) { /* bail on first match */
33827c478bd9Sstevel@tonic-gate 			allow = 0;
33837c478bd9Sstevel@tonic-gate 			break;
33847c478bd9Sstevel@tonic-gate 		}
33857c478bd9Sstevel@tonic-gate 	}
33867c478bd9Sstevel@tonic-gate 	AS_LOCK_EXIT(&as, &as->a_lock);
33877c478bd9Sstevel@tonic-gate 	return (allow);
33887c478bd9Sstevel@tonic-gate }
33897c478bd9Sstevel@tonic-gate 
33907c478bd9Sstevel@tonic-gate /*
33917c478bd9Sstevel@tonic-gate  * Systemcall entry point for zone_enter().
33927c478bd9Sstevel@tonic-gate  *
33937c478bd9Sstevel@tonic-gate  * The current process is injected into said zone.  In the process
33947c478bd9Sstevel@tonic-gate  * it will change its project membership, privileges, rootdir/cwd,
33957c478bd9Sstevel@tonic-gate  * zone-wide rctls, and pool association to match those of the zone.
33967c478bd9Sstevel@tonic-gate  *
33977c478bd9Sstevel@tonic-gate  * The first zone_enter() called while the zone is in the ZONE_IS_READY
33987c478bd9Sstevel@tonic-gate  * state will transition it to ZONE_IS_RUNNING.  Processes may only
33997c478bd9Sstevel@tonic-gate  * enter a zone that is "ready" or "running".
34007c478bd9Sstevel@tonic-gate  */
34017c478bd9Sstevel@tonic-gate static int
34027c478bd9Sstevel@tonic-gate zone_enter(zoneid_t zoneid)
34037c478bd9Sstevel@tonic-gate {
34047c478bd9Sstevel@tonic-gate 	zone_t *zone;
34057c478bd9Sstevel@tonic-gate 	vnode_t *vp;
34067c478bd9Sstevel@tonic-gate 	proc_t *pp = curproc;
34077c478bd9Sstevel@tonic-gate 	contract_t *ct;
34087c478bd9Sstevel@tonic-gate 	cont_process_t *ctp;
34097c478bd9Sstevel@tonic-gate 	task_t *tk, *oldtk;
34107c478bd9Sstevel@tonic-gate 	kproject_t *zone_proj0;
34117c478bd9Sstevel@tonic-gate 	cred_t *cr, *newcr;
34127c478bd9Sstevel@tonic-gate 	pool_t *oldpool, *newpool;
34137c478bd9Sstevel@tonic-gate 	sess_t *sp;
34147c478bd9Sstevel@tonic-gate 	uid_t uid;
34157c478bd9Sstevel@tonic-gate 	zone_status_t status;
34167c478bd9Sstevel@tonic-gate 	int err = 0;
34177c478bd9Sstevel@tonic-gate 	rctl_entity_p_t e;
34187c478bd9Sstevel@tonic-gate 
34197c478bd9Sstevel@tonic-gate 	if (secpolicy_zone_config(CRED()) != 0)
34207c478bd9Sstevel@tonic-gate 		return (set_errno(EPERM));
34217c478bd9Sstevel@tonic-gate 	if (zoneid < MIN_USERZONEID || zoneid > MAX_ZONEID)
34227c478bd9Sstevel@tonic-gate 		return (set_errno(EINVAL));
34237c478bd9Sstevel@tonic-gate 
34247c478bd9Sstevel@tonic-gate 	/*
34257c478bd9Sstevel@tonic-gate 	 * Stop all lwps so we don't need to hold a lock to look at
34267c478bd9Sstevel@tonic-gate 	 * curproc->p_zone.  This needs to happen before we grab any
34277c478bd9Sstevel@tonic-gate 	 * locks to avoid deadlock (another lwp in the process could
34287c478bd9Sstevel@tonic-gate 	 * be waiting for the held lock).
34297c478bd9Sstevel@tonic-gate 	 */
34307c478bd9Sstevel@tonic-gate 	if (curthread != pp->p_agenttp && !holdlwps(SHOLDFORK))
34317c478bd9Sstevel@tonic-gate 		return (set_errno(EINTR));
34327c478bd9Sstevel@tonic-gate 
34337c478bd9Sstevel@tonic-gate 	/*
34347c478bd9Sstevel@tonic-gate 	 * Make sure we're not changing zones with files open or mapped in
34357c478bd9Sstevel@tonic-gate 	 * to our address space which shouldn't be changing zones.
34367c478bd9Sstevel@tonic-gate 	 */
34377c478bd9Sstevel@tonic-gate 	if (!files_can_change_zones()) {
34387c478bd9Sstevel@tonic-gate 		err = EBADF;
34397c478bd9Sstevel@tonic-gate 		goto out;
34407c478bd9Sstevel@tonic-gate 	}
34417c478bd9Sstevel@tonic-gate 	if (!as_can_change_zones()) {
34427c478bd9Sstevel@tonic-gate 		err = EFAULT;
34437c478bd9Sstevel@tonic-gate 		goto out;
34447c478bd9Sstevel@tonic-gate 	}
34457c478bd9Sstevel@tonic-gate 
34467c478bd9Sstevel@tonic-gate 	mutex_enter(&zonehash_lock);
34477c478bd9Sstevel@tonic-gate 	if (pp->p_zone != global_zone) {
34487c478bd9Sstevel@tonic-gate 		mutex_exit(&zonehash_lock);
34497c478bd9Sstevel@tonic-gate 		err = EINVAL;
34507c478bd9Sstevel@tonic-gate 		goto out;
34517c478bd9Sstevel@tonic-gate 	}
34527c478bd9Sstevel@tonic-gate 
34537c478bd9Sstevel@tonic-gate 	zone = zone_find_all_by_id(zoneid);
34547c478bd9Sstevel@tonic-gate 	if (zone == NULL) {
34557c478bd9Sstevel@tonic-gate 		mutex_exit(&zonehash_lock);
34567c478bd9Sstevel@tonic-gate 		err = EINVAL;
34577c478bd9Sstevel@tonic-gate 		goto out;
34587c478bd9Sstevel@tonic-gate 	}
34597c478bd9Sstevel@tonic-gate 
34607c478bd9Sstevel@tonic-gate 	/*
34617c478bd9Sstevel@tonic-gate 	 * To prevent processes in a zone from holding contracts on
34627c478bd9Sstevel@tonic-gate 	 * extrazonal resources, and to avoid process contract
34637c478bd9Sstevel@tonic-gate 	 * memberships which span zones, contract holders and processes
34647c478bd9Sstevel@tonic-gate 	 * which aren't the sole members of their encapsulating process
34657c478bd9Sstevel@tonic-gate 	 * contracts are not allowed to zone_enter.
34667c478bd9Sstevel@tonic-gate 	 */
34677c478bd9Sstevel@tonic-gate 	ctp = pp->p_ct_process;
34687c478bd9Sstevel@tonic-gate 	ct = &ctp->conp_contract;
34697c478bd9Sstevel@tonic-gate 	mutex_enter(&ct->ct_lock);
34707c478bd9Sstevel@tonic-gate 	mutex_enter(&pp->p_lock);
34717c478bd9Sstevel@tonic-gate 	if ((avl_numnodes(&pp->p_ct_held) != 0) || (ctp->conp_nmembers != 1)) {
34727c478bd9Sstevel@tonic-gate 		mutex_exit(&pp->p_lock);
34737c478bd9Sstevel@tonic-gate 		mutex_exit(&ct->ct_lock);
34747c478bd9Sstevel@tonic-gate 		mutex_exit(&zonehash_lock);
34757c478bd9Sstevel@tonic-gate 		pool_unlock();
34767c478bd9Sstevel@tonic-gate 		err = EINVAL;
34777c478bd9Sstevel@tonic-gate 		goto out;
34787c478bd9Sstevel@tonic-gate 	}
34797c478bd9Sstevel@tonic-gate 
34807c478bd9Sstevel@tonic-gate 	/*
34817c478bd9Sstevel@tonic-gate 	 * Moreover, we don't allow processes whose encapsulating
34827c478bd9Sstevel@tonic-gate 	 * process contracts have inherited extrazonal contracts.
34837c478bd9Sstevel@tonic-gate 	 * While it would be easier to eliminate all process contracts
34847c478bd9Sstevel@tonic-gate 	 * with inherited contracts, we need to be able to give a
34857c478bd9Sstevel@tonic-gate 	 * restarted init (or other zone-penetrating process) its
34867c478bd9Sstevel@tonic-gate 	 * predecessor's contracts.
34877c478bd9Sstevel@tonic-gate 	 */
34887c478bd9Sstevel@tonic-gate 	if (ctp->conp_ninherited != 0) {
34897c478bd9Sstevel@tonic-gate 		contract_t *next;
34907c478bd9Sstevel@tonic-gate 		for (next = list_head(&ctp->conp_inherited); next;
34917c478bd9Sstevel@tonic-gate 		    next = list_next(&ctp->conp_inherited, next)) {
34927c478bd9Sstevel@tonic-gate 			if (contract_getzuniqid(next) != zone->zone_uniqid) {
34937c478bd9Sstevel@tonic-gate 				mutex_exit(&pp->p_lock);
34947c478bd9Sstevel@tonic-gate 				mutex_exit(&ct->ct_lock);
34957c478bd9Sstevel@tonic-gate 				mutex_exit(&zonehash_lock);
34967c478bd9Sstevel@tonic-gate 				pool_unlock();
34977c478bd9Sstevel@tonic-gate 				err = EINVAL;
34987c478bd9Sstevel@tonic-gate 				goto out;
34997c478bd9Sstevel@tonic-gate 			}
35007c478bd9Sstevel@tonic-gate 		}
35017c478bd9Sstevel@tonic-gate 	}
35027c478bd9Sstevel@tonic-gate 	mutex_exit(&pp->p_lock);
35037c478bd9Sstevel@tonic-gate 	mutex_exit(&ct->ct_lock);
35047c478bd9Sstevel@tonic-gate 
35057c478bd9Sstevel@tonic-gate 	status = zone_status_get(zone);
35067c478bd9Sstevel@tonic-gate 	if (status < ZONE_IS_READY || status >= ZONE_IS_SHUTTING_DOWN) {
35077c478bd9Sstevel@tonic-gate 		/*
35087c478bd9Sstevel@tonic-gate 		 * Can't join
35097c478bd9Sstevel@tonic-gate 		 */
35107c478bd9Sstevel@tonic-gate 		mutex_exit(&zonehash_lock);
35117c478bd9Sstevel@tonic-gate 		err = EINVAL;
35127c478bd9Sstevel@tonic-gate 		goto out;
35137c478bd9Sstevel@tonic-gate 	}
35147c478bd9Sstevel@tonic-gate 
35157c478bd9Sstevel@tonic-gate 	/*
35167c478bd9Sstevel@tonic-gate 	 * Make sure new priv set is within the permitted set for caller
35177c478bd9Sstevel@tonic-gate 	 */
35187c478bd9Sstevel@tonic-gate 	if (!priv_issubset(zone->zone_privset, &CR_OPPRIV(CRED()))) {
35197c478bd9Sstevel@tonic-gate 		mutex_exit(&zonehash_lock);
35207c478bd9Sstevel@tonic-gate 		err = EPERM;
35217c478bd9Sstevel@tonic-gate 		goto out;
35227c478bd9Sstevel@tonic-gate 	}
35237c478bd9Sstevel@tonic-gate 	/*
35247c478bd9Sstevel@tonic-gate 	 * We want to momentarily drop zonehash_lock while we optimistically
35257c478bd9Sstevel@tonic-gate 	 * bind curproc to the pool it should be running in.  This is safe
35267c478bd9Sstevel@tonic-gate 	 * since the zone can't disappear (we have a hold on it).
35277c478bd9Sstevel@tonic-gate 	 */
35287c478bd9Sstevel@tonic-gate 	zone_hold(zone);
35297c478bd9Sstevel@tonic-gate 	mutex_exit(&zonehash_lock);
35307c478bd9Sstevel@tonic-gate 
35317c478bd9Sstevel@tonic-gate 	/*
35327c478bd9Sstevel@tonic-gate 	 * Grab pool_lock to keep the pools configuration from changing
35337c478bd9Sstevel@tonic-gate 	 * and to stop ourselves from getting rebound to another pool
35347c478bd9Sstevel@tonic-gate 	 * until we join the zone.
35357c478bd9Sstevel@tonic-gate 	 */
35367c478bd9Sstevel@tonic-gate 	if (pool_lock_intr() != 0) {
35377c478bd9Sstevel@tonic-gate 		zone_rele(zone);
35387c478bd9Sstevel@tonic-gate 		err = EINTR;
35397c478bd9Sstevel@tonic-gate 		goto out;
35407c478bd9Sstevel@tonic-gate 	}
35417c478bd9Sstevel@tonic-gate 	ASSERT(secpolicy_pool(CRED()) == 0);
35427c478bd9Sstevel@tonic-gate 	/*
35437c478bd9Sstevel@tonic-gate 	 * Bind ourselves to the pool currently associated with the zone.
35447c478bd9Sstevel@tonic-gate 	 */
35457c478bd9Sstevel@tonic-gate 	oldpool = curproc->p_pool;
35467c478bd9Sstevel@tonic-gate 	newpool = zone_pool_get(zone);
35477c478bd9Sstevel@tonic-gate 	if (pool_state == POOL_ENABLED && newpool != oldpool &&
35487c478bd9Sstevel@tonic-gate 	    (err = pool_do_bind(newpool, P_PID, P_MYID,
35497c478bd9Sstevel@tonic-gate 	    POOL_BIND_ALL)) != 0) {
35507c478bd9Sstevel@tonic-gate 		pool_unlock();
35517c478bd9Sstevel@tonic-gate 		zone_rele(zone);
35527c478bd9Sstevel@tonic-gate 		goto out;
35537c478bd9Sstevel@tonic-gate 	}
35547c478bd9Sstevel@tonic-gate 
35557c478bd9Sstevel@tonic-gate 	/*
35567c478bd9Sstevel@tonic-gate 	 * Grab cpu_lock now; we'll need it later when we call
35577c478bd9Sstevel@tonic-gate 	 * task_join().
35587c478bd9Sstevel@tonic-gate 	 */
35597c478bd9Sstevel@tonic-gate 	mutex_enter(&cpu_lock);
35607c478bd9Sstevel@tonic-gate 	mutex_enter(&zonehash_lock);
35617c478bd9Sstevel@tonic-gate 	/*
35627c478bd9Sstevel@tonic-gate 	 * Make sure the zone hasn't moved on since we dropped zonehash_lock.
35637c478bd9Sstevel@tonic-gate 	 */
35647c478bd9Sstevel@tonic-gate 	if (zone_status_get(zone) >= ZONE_IS_SHUTTING_DOWN) {
35657c478bd9Sstevel@tonic-gate 		/*
35667c478bd9Sstevel@tonic-gate 		 * Can't join anymore.
35677c478bd9Sstevel@tonic-gate 		 */
35687c478bd9Sstevel@tonic-gate 		mutex_exit(&zonehash_lock);
35697c478bd9Sstevel@tonic-gate 		mutex_exit(&cpu_lock);
35707c478bd9Sstevel@tonic-gate 		if (pool_state == POOL_ENABLED &&
35717c478bd9Sstevel@tonic-gate 		    newpool != oldpool)
35727c478bd9Sstevel@tonic-gate 			(void) pool_do_bind(oldpool, P_PID, P_MYID,
35737c478bd9Sstevel@tonic-gate 			    POOL_BIND_ALL);
35747c478bd9Sstevel@tonic-gate 		pool_unlock();
35757c478bd9Sstevel@tonic-gate 		zone_rele(zone);
35767c478bd9Sstevel@tonic-gate 		err = EINVAL;
35777c478bd9Sstevel@tonic-gate 		goto out;
35787c478bd9Sstevel@tonic-gate 	}
35797c478bd9Sstevel@tonic-gate 
35807c478bd9Sstevel@tonic-gate 	mutex_enter(&pp->p_lock);
35817c478bd9Sstevel@tonic-gate 	zone_proj0 = zone->zone_zsched->p_task->tk_proj;
35827c478bd9Sstevel@tonic-gate 	/* verify that we do not exceed and task or lwp limits */
35837c478bd9Sstevel@tonic-gate 	mutex_enter(&zone->zone_nlwps_lock);
35847c478bd9Sstevel@tonic-gate 	/* add new lwps to zone and zone's proj0 */
35857c478bd9Sstevel@tonic-gate 	zone_proj0->kpj_nlwps += pp->p_lwpcnt;
35867c478bd9Sstevel@tonic-gate 	zone->zone_nlwps += pp->p_lwpcnt;
35877c478bd9Sstevel@tonic-gate 	/* add 1 task to zone's proj0 */
35887c478bd9Sstevel@tonic-gate 	zone_proj0->kpj_ntasks += 1;
35897c478bd9Sstevel@tonic-gate 	mutex_exit(&pp->p_lock);
35907c478bd9Sstevel@tonic-gate 	mutex_exit(&zone->zone_nlwps_lock);
35917c478bd9Sstevel@tonic-gate 
35927c478bd9Sstevel@tonic-gate 	/* remove lwps from proc's old zone and old project */
35937c478bd9Sstevel@tonic-gate 	mutex_enter(&pp->p_zone->zone_nlwps_lock);
35947c478bd9Sstevel@tonic-gate 	pp->p_zone->zone_nlwps -= pp->p_lwpcnt;
35957c478bd9Sstevel@tonic-gate 	pp->p_task->tk_proj->kpj_nlwps -= pp->p_lwpcnt;
35967c478bd9Sstevel@tonic-gate 	mutex_exit(&pp->p_zone->zone_nlwps_lock);
35977c478bd9Sstevel@tonic-gate 
35987c478bd9Sstevel@tonic-gate 	/*
35997c478bd9Sstevel@tonic-gate 	 * Joining the zone cannot fail from now on.
36007c478bd9Sstevel@tonic-gate 	 *
36017c478bd9Sstevel@tonic-gate 	 * This means that a lot of the following code can be commonized and
36027c478bd9Sstevel@tonic-gate 	 * shared with zsched().
36037c478bd9Sstevel@tonic-gate 	 */
36047c478bd9Sstevel@tonic-gate 
36057c478bd9Sstevel@tonic-gate 	/*
36067c478bd9Sstevel@tonic-gate 	 * Reset the encapsulating process contract's zone.
36077c478bd9Sstevel@tonic-gate 	 */
36087c478bd9Sstevel@tonic-gate 	ASSERT(ct->ct_mzuniqid == GLOBAL_ZONEUNIQID);
36097c478bd9Sstevel@tonic-gate 	contract_setzuniqid(ct, zone->zone_uniqid);
36107c478bd9Sstevel@tonic-gate 
36117c478bd9Sstevel@tonic-gate 	/*
36127c478bd9Sstevel@tonic-gate 	 * Create a new task and associate the process with the project keyed
36137c478bd9Sstevel@tonic-gate 	 * by (projid,zoneid).
36147c478bd9Sstevel@tonic-gate 	 *
36157c478bd9Sstevel@tonic-gate 	 * We might as well be in project 0; the global zone's projid doesn't
36167c478bd9Sstevel@tonic-gate 	 * make much sense in a zone anyhow.
36177c478bd9Sstevel@tonic-gate 	 *
36187c478bd9Sstevel@tonic-gate 	 * This also increments zone_ntasks, and returns with p_lock held.
36197c478bd9Sstevel@tonic-gate 	 */
36207c478bd9Sstevel@tonic-gate 	tk = task_create(0, zone);
36217c478bd9Sstevel@tonic-gate 	oldtk = task_join(tk, 0);
36227c478bd9Sstevel@tonic-gate 	mutex_exit(&cpu_lock);
36237c478bd9Sstevel@tonic-gate 
36247c478bd9Sstevel@tonic-gate 	pp->p_flag |= SZONETOP;
36257c478bd9Sstevel@tonic-gate 	pp->p_zone = zone;
36267c478bd9Sstevel@tonic-gate 
36277c478bd9Sstevel@tonic-gate 	/*
36287c478bd9Sstevel@tonic-gate 	 * call RCTLOP_SET functions on this proc
36297c478bd9Sstevel@tonic-gate 	 */
36307c478bd9Sstevel@tonic-gate 	e.rcep_p.zone = zone;
36317c478bd9Sstevel@tonic-gate 	e.rcep_t = RCENTITY_ZONE;
36327c478bd9Sstevel@tonic-gate 	(void) rctl_set_dup(NULL, NULL, pp, &e, zone->zone_rctls, NULL,
36337c478bd9Sstevel@tonic-gate 	    RCD_CALLBACK);
36347c478bd9Sstevel@tonic-gate 	mutex_exit(&pp->p_lock);
36357c478bd9Sstevel@tonic-gate 
36367c478bd9Sstevel@tonic-gate 	/*
36377c478bd9Sstevel@tonic-gate 	 * We don't need to hold any of zsched's locks here; not only do we know
36387c478bd9Sstevel@tonic-gate 	 * the process and zone aren't going away, we know its session isn't
36397c478bd9Sstevel@tonic-gate 	 * changing either.
36407c478bd9Sstevel@tonic-gate 	 *
36417c478bd9Sstevel@tonic-gate 	 * By joining zsched's session here, we mimic the behavior in the
36427c478bd9Sstevel@tonic-gate 	 * global zone of init's sid being the pid of sched.  We extend this
36437c478bd9Sstevel@tonic-gate 	 * to all zlogin-like zone_enter()'ing processes as well.
36447c478bd9Sstevel@tonic-gate 	 */
36457c478bd9Sstevel@tonic-gate 	mutex_enter(&pidlock);
36467c478bd9Sstevel@tonic-gate 	sp = zone->zone_zsched->p_sessp;
36477c478bd9Sstevel@tonic-gate 	SESS_HOLD(sp);
36487c478bd9Sstevel@tonic-gate 	mutex_enter(&pp->p_lock);
36497c478bd9Sstevel@tonic-gate 	pgexit(pp);
36507c478bd9Sstevel@tonic-gate 	SESS_RELE(pp->p_sessp);
36517c478bd9Sstevel@tonic-gate 	pp->p_sessp = sp;
36527c478bd9Sstevel@tonic-gate 	pgjoin(pp, zone->zone_zsched->p_pidp);
36537c478bd9Sstevel@tonic-gate 	mutex_exit(&pp->p_lock);
36547c478bd9Sstevel@tonic-gate 	mutex_exit(&pidlock);
36557c478bd9Sstevel@tonic-gate 
36567c478bd9Sstevel@tonic-gate 	mutex_exit(&zonehash_lock);
36577c478bd9Sstevel@tonic-gate 	/*
36587c478bd9Sstevel@tonic-gate 	 * We're firmly in the zone; let pools progress.
36597c478bd9Sstevel@tonic-gate 	 */
36607c478bd9Sstevel@tonic-gate 	pool_unlock();
36617c478bd9Sstevel@tonic-gate 	task_rele(oldtk);
36627c478bd9Sstevel@tonic-gate 	/*
36637c478bd9Sstevel@tonic-gate 	 * We don't need to retain a hold on the zone since we already
36647c478bd9Sstevel@tonic-gate 	 * incremented zone_ntasks, so the zone isn't going anywhere.
36657c478bd9Sstevel@tonic-gate 	 */
36667c478bd9Sstevel@tonic-gate 	zone_rele(zone);
36677c478bd9Sstevel@tonic-gate 
36687c478bd9Sstevel@tonic-gate 	/*
36697c478bd9Sstevel@tonic-gate 	 * Chroot
36707c478bd9Sstevel@tonic-gate 	 */
36717c478bd9Sstevel@tonic-gate 	vp = zone->zone_rootvp;
36727c478bd9Sstevel@tonic-gate 	zone_chdir(vp, &PTOU(pp)->u_cdir, pp);
36737c478bd9Sstevel@tonic-gate 	zone_chdir(vp, &PTOU(pp)->u_rdir, pp);
36747c478bd9Sstevel@tonic-gate 
36757c478bd9Sstevel@tonic-gate 	/*
36767c478bd9Sstevel@tonic-gate 	 * Change process credentials
36777c478bd9Sstevel@tonic-gate 	 */
36787c478bd9Sstevel@tonic-gate 	newcr = cralloc();
36797c478bd9Sstevel@tonic-gate 	mutex_enter(&pp->p_crlock);
36807c478bd9Sstevel@tonic-gate 	cr = pp->p_cred;
36817c478bd9Sstevel@tonic-gate 	crcopy_to(cr, newcr);
36827c478bd9Sstevel@tonic-gate 	crsetzone(newcr, zone);
36837c478bd9Sstevel@tonic-gate 	pp->p_cred = newcr;
36847c478bd9Sstevel@tonic-gate 
36857c478bd9Sstevel@tonic-gate 	/*
36867c478bd9Sstevel@tonic-gate 	 * Restrict all process privilege sets to zone limit
36877c478bd9Sstevel@tonic-gate 	 */
36887c478bd9Sstevel@tonic-gate 	priv_intersect(zone->zone_privset, &CR_PPRIV(newcr));
36897c478bd9Sstevel@tonic-gate 	priv_intersect(zone->zone_privset, &CR_EPRIV(newcr));
36907c478bd9Sstevel@tonic-gate 	priv_intersect(zone->zone_privset, &CR_IPRIV(newcr));
36917c478bd9Sstevel@tonic-gate 	priv_intersect(zone->zone_privset, &CR_LPRIV(newcr));
36927c478bd9Sstevel@tonic-gate 	mutex_exit(&pp->p_crlock);
36937c478bd9Sstevel@tonic-gate 	crset(pp, newcr);
36947c478bd9Sstevel@tonic-gate 
36957c478bd9Sstevel@tonic-gate 	/*
36967c478bd9Sstevel@tonic-gate 	 * Adjust upcount to reflect zone entry.
36977c478bd9Sstevel@tonic-gate 	 */
36987c478bd9Sstevel@tonic-gate 	uid = crgetruid(newcr);
36997c478bd9Sstevel@tonic-gate 	mutex_enter(&pidlock);
37007c478bd9Sstevel@tonic-gate 	upcount_dec(uid, GLOBAL_ZONEID);
37017c478bd9Sstevel@tonic-gate 	upcount_inc(uid, zoneid);
37027c478bd9Sstevel@tonic-gate 	mutex_exit(&pidlock);
37037c478bd9Sstevel@tonic-gate 
37047c478bd9Sstevel@tonic-gate 	/*
37057c478bd9Sstevel@tonic-gate 	 * Set up core file path and content.
37067c478bd9Sstevel@tonic-gate 	 */
37077c478bd9Sstevel@tonic-gate 	set_core_defaults();
37087c478bd9Sstevel@tonic-gate 
37097c478bd9Sstevel@tonic-gate out:
37107c478bd9Sstevel@tonic-gate 	/*
37117c478bd9Sstevel@tonic-gate 	 * Let the other lwps continue.
37127c478bd9Sstevel@tonic-gate 	 */
37137c478bd9Sstevel@tonic-gate 	mutex_enter(&pp->p_lock);
37147c478bd9Sstevel@tonic-gate 	if (curthread != pp->p_agenttp)
37157c478bd9Sstevel@tonic-gate 		continuelwps(pp);
37167c478bd9Sstevel@tonic-gate 	mutex_exit(&pp->p_lock);
37177c478bd9Sstevel@tonic-gate 
37187c478bd9Sstevel@tonic-gate 	return (err != 0 ? set_errno(err) : 0);
37197c478bd9Sstevel@tonic-gate }
37207c478bd9Sstevel@tonic-gate 
37217c478bd9Sstevel@tonic-gate /*
37227c478bd9Sstevel@tonic-gate  * Systemcall entry point for zone_list(2).
37237c478bd9Sstevel@tonic-gate  *
37247c478bd9Sstevel@tonic-gate  * Processes running in a (non-global) zone only see themselves.
37257c478bd9Sstevel@tonic-gate  */
37267c478bd9Sstevel@tonic-gate static int
37277c478bd9Sstevel@tonic-gate zone_list(zoneid_t *zoneidlist, uint_t *numzones)
37287c478bd9Sstevel@tonic-gate {
37297c478bd9Sstevel@tonic-gate 	zoneid_t *zoneids;
37307c478bd9Sstevel@tonic-gate 	zone_t *zone;
37317c478bd9Sstevel@tonic-gate 	uint_t user_nzones, real_nzones;
37327c478bd9Sstevel@tonic-gate 	int error = 0;
37337c478bd9Sstevel@tonic-gate 	uint_t i;
37347c478bd9Sstevel@tonic-gate 
37357c478bd9Sstevel@tonic-gate 	if (copyin(numzones, &user_nzones, sizeof (uint_t)) != 0)
37367c478bd9Sstevel@tonic-gate 		return (set_errno(EFAULT));
37377c478bd9Sstevel@tonic-gate 
37387c478bd9Sstevel@tonic-gate 	if (curproc->p_zone != global_zone) {
37397c478bd9Sstevel@tonic-gate 		/* just return current zone */
37407c478bd9Sstevel@tonic-gate 		real_nzones = 1;
37417c478bd9Sstevel@tonic-gate 		zoneids = kmem_alloc(sizeof (zoneid_t), KM_SLEEP);
37427c478bd9Sstevel@tonic-gate 		zoneids[0] = curproc->p_zone->zone_id;
37437c478bd9Sstevel@tonic-gate 	} else {
37447c478bd9Sstevel@tonic-gate 		mutex_enter(&zonehash_lock);
37457c478bd9Sstevel@tonic-gate 		real_nzones = zonecount;
37467c478bd9Sstevel@tonic-gate 		if (real_nzones) {
37477c478bd9Sstevel@tonic-gate 			zoneids = kmem_alloc(real_nzones * sizeof (zoneid_t),
37487c478bd9Sstevel@tonic-gate 			    KM_SLEEP);
37497c478bd9Sstevel@tonic-gate 			i = 0;
37507c478bd9Sstevel@tonic-gate 			for (zone = list_head(&zone_active); zone != NULL;
37517c478bd9Sstevel@tonic-gate 			    zone = list_next(&zone_active, zone))
37527c478bd9Sstevel@tonic-gate 				zoneids[i++] = zone->zone_id;
37537c478bd9Sstevel@tonic-gate 			ASSERT(i == real_nzones);
37547c478bd9Sstevel@tonic-gate 		}
37557c478bd9Sstevel@tonic-gate 		mutex_exit(&zonehash_lock);
37567c478bd9Sstevel@tonic-gate 	}
37577c478bd9Sstevel@tonic-gate 
37587c478bd9Sstevel@tonic-gate 	if (user_nzones > real_nzones)
37597c478bd9Sstevel@tonic-gate 		user_nzones = real_nzones;
37607c478bd9Sstevel@tonic-gate 
37617c478bd9Sstevel@tonic-gate 	if (copyout(&real_nzones, numzones, sizeof (uint_t)) != 0)
37627c478bd9Sstevel@tonic-gate 		error = EFAULT;
37637c478bd9Sstevel@tonic-gate 	else if (zoneidlist != NULL && user_nzones != 0) {
37647c478bd9Sstevel@tonic-gate 		if (copyout(zoneids, zoneidlist,
37657c478bd9Sstevel@tonic-gate 		    user_nzones * sizeof (zoneid_t)) != 0)
37667c478bd9Sstevel@tonic-gate 			error = EFAULT;
37677c478bd9Sstevel@tonic-gate 	}
37687c478bd9Sstevel@tonic-gate 
37697c478bd9Sstevel@tonic-gate 	if (real_nzones)
37707c478bd9Sstevel@tonic-gate 		kmem_free(zoneids, real_nzones * sizeof (zoneid_t));
37717c478bd9Sstevel@tonic-gate 
37727c478bd9Sstevel@tonic-gate 	if (error)
37737c478bd9Sstevel@tonic-gate 		return (set_errno(error));
37747c478bd9Sstevel@tonic-gate 	else
37757c478bd9Sstevel@tonic-gate 		return (0);
37767c478bd9Sstevel@tonic-gate }
37777c478bd9Sstevel@tonic-gate 
37787c478bd9Sstevel@tonic-gate /*
37797c478bd9Sstevel@tonic-gate  * Systemcall entry point for zone_lookup(2).
37807c478bd9Sstevel@tonic-gate  *
37817c478bd9Sstevel@tonic-gate  * Non-global zones are only able to see themselves.
37827c478bd9Sstevel@tonic-gate  */
37837c478bd9Sstevel@tonic-gate static zoneid_t
37847c478bd9Sstevel@tonic-gate zone_lookup(const char *zone_name)
37857c478bd9Sstevel@tonic-gate {
37867c478bd9Sstevel@tonic-gate 	char *kname;
37877c478bd9Sstevel@tonic-gate 	zone_t *zone;
37887c478bd9Sstevel@tonic-gate 	zoneid_t zoneid;
37897c478bd9Sstevel@tonic-gate 	int err;
37907c478bd9Sstevel@tonic-gate 
37917c478bd9Sstevel@tonic-gate 	if (zone_name == NULL) {
37927c478bd9Sstevel@tonic-gate 		/* return caller's zone id */
37937c478bd9Sstevel@tonic-gate 		return (getzoneid());
37947c478bd9Sstevel@tonic-gate 	}
37957c478bd9Sstevel@tonic-gate 
37967c478bd9Sstevel@tonic-gate 	kname = kmem_zalloc(ZONENAME_MAX, KM_SLEEP);
37977c478bd9Sstevel@tonic-gate 	if ((err = copyinstr(zone_name, kname, ZONENAME_MAX, NULL)) != 0) {
37987c478bd9Sstevel@tonic-gate 		kmem_free(kname, ZONENAME_MAX);
37997c478bd9Sstevel@tonic-gate 		return (set_errno(err));
38007c478bd9Sstevel@tonic-gate 	}
38017c478bd9Sstevel@tonic-gate 
38027c478bd9Sstevel@tonic-gate 	mutex_enter(&zonehash_lock);
38037c478bd9Sstevel@tonic-gate 	zone = zone_find_all_by_name(kname);
38047c478bd9Sstevel@tonic-gate 	kmem_free(kname, ZONENAME_MAX);
38057c478bd9Sstevel@tonic-gate 	if (zone == NULL || zone_status_get(zone) < ZONE_IS_READY ||
38067c478bd9Sstevel@tonic-gate 	    (curproc->p_zone != global_zone && curproc->p_zone != zone)) {
38077c478bd9Sstevel@tonic-gate 		/* in non-global zone, can only lookup own name */
38087c478bd9Sstevel@tonic-gate 		mutex_exit(&zonehash_lock);
38097c478bd9Sstevel@tonic-gate 		return (set_errno(EINVAL));
38107c478bd9Sstevel@tonic-gate 	}
38117c478bd9Sstevel@tonic-gate 	zoneid = zone->zone_id;
38127c478bd9Sstevel@tonic-gate 	mutex_exit(&zonehash_lock);
38137c478bd9Sstevel@tonic-gate 	return (zoneid);
38147c478bd9Sstevel@tonic-gate }
38157c478bd9Sstevel@tonic-gate 
3816*821c4a97Sdp static int
3817*821c4a97Sdp zone_version(int *version_arg)
3818*821c4a97Sdp {
3819*821c4a97Sdp 	int version = ZONE_SYSCALL_API_VERSION;
3820*821c4a97Sdp 
3821*821c4a97Sdp 	if (copyout(&version, version_arg, sizeof (int)) != 0)
3822*821c4a97Sdp 		return (set_errno(EFAULT));
3823*821c4a97Sdp 	return (0);
3824*821c4a97Sdp }
3825*821c4a97Sdp 
38267c478bd9Sstevel@tonic-gate /* ARGSUSED */
38277c478bd9Sstevel@tonic-gate long
3828fa9e4066Sahrens zone(int cmd, void *arg1, void *arg2, void *arg3, void *arg4)
38297c478bd9Sstevel@tonic-gate {
38307c478bd9Sstevel@tonic-gate 	zone_def zs;
38317c478bd9Sstevel@tonic-gate 
38327c478bd9Sstevel@tonic-gate 	switch (cmd) {
38337c478bd9Sstevel@tonic-gate 	case ZONE_CREATE:
38347c478bd9Sstevel@tonic-gate 		if (get_udatamodel() == DATAMODEL_NATIVE) {
38357c478bd9Sstevel@tonic-gate 			if (copyin(arg1, &zs, sizeof (zone_def))) {
38367c478bd9Sstevel@tonic-gate 				return (set_errno(EFAULT));
38377c478bd9Sstevel@tonic-gate 			}
38387c478bd9Sstevel@tonic-gate 		} else {
38397c478bd9Sstevel@tonic-gate #ifdef _SYSCALL32_IMPL
38407c478bd9Sstevel@tonic-gate 			zone_def32 zs32;
38417c478bd9Sstevel@tonic-gate 
38427c478bd9Sstevel@tonic-gate 			if (copyin(arg1, &zs32, sizeof (zone_def32))) {
38437c478bd9Sstevel@tonic-gate 				return (set_errno(EFAULT));
38447c478bd9Sstevel@tonic-gate 			}
38457c478bd9Sstevel@tonic-gate 			zs.zone_name =
38467c478bd9Sstevel@tonic-gate 			    (const char *)(unsigned long)zs32.zone_name;
38477c478bd9Sstevel@tonic-gate 			zs.zone_root =
38487c478bd9Sstevel@tonic-gate 			    (const char *)(unsigned long)zs32.zone_root;
38497c478bd9Sstevel@tonic-gate 			zs.zone_privs =
38507c478bd9Sstevel@tonic-gate 			    (const struct priv_set *)
38517c478bd9Sstevel@tonic-gate 			    (unsigned long)zs32.zone_privs;
38527c478bd9Sstevel@tonic-gate 			zs.rctlbuf = (caddr_t)(unsigned long)zs32.rctlbuf;
38537c478bd9Sstevel@tonic-gate 			zs.rctlbufsz = zs32.rctlbufsz;
3854fa9e4066Sahrens 			zs.zfsbuf = (caddr_t)(unsigned long)zs32.zfsbuf;
3855fa9e4066Sahrens 			zs.zfsbufsz = zs32.zfsbufsz;
38567c478bd9Sstevel@tonic-gate 			zs.extended_error =
38577c478bd9Sstevel@tonic-gate 			    (int *)(unsigned long)zs32.extended_error;
38587c478bd9Sstevel@tonic-gate #else
38597c478bd9Sstevel@tonic-gate 			panic("get_udatamodel() returned bogus result\n");
38607c478bd9Sstevel@tonic-gate #endif
38617c478bd9Sstevel@tonic-gate 		}
38627c478bd9Sstevel@tonic-gate 
38637c478bd9Sstevel@tonic-gate 		return (zone_create(zs.zone_name, zs.zone_root,
3864*821c4a97Sdp 		    zs.zone_privs, zs.zone_privssz,
3865*821c4a97Sdp 		    (caddr_t)zs.rctlbuf, zs.rctlbufsz,
3866*821c4a97Sdp 		    (caddr_t)zs.zfsbuf, zs.zfsbufsz,
3867*821c4a97Sdp 		    zs.extended_error));
38687c478bd9Sstevel@tonic-gate 	case ZONE_BOOT:
38697c478bd9Sstevel@tonic-gate 		return (zone_boot((zoneid_t)(uintptr_t)arg1,
38707c478bd9Sstevel@tonic-gate 		    (const char *)arg2));
38717c478bd9Sstevel@tonic-gate 	case ZONE_DESTROY:
38727c478bd9Sstevel@tonic-gate 		return (zone_destroy((zoneid_t)(uintptr_t)arg1));
38737c478bd9Sstevel@tonic-gate 	case ZONE_GETATTR:
38747c478bd9Sstevel@tonic-gate 		return (zone_getattr((zoneid_t)(uintptr_t)arg1,
38757c478bd9Sstevel@tonic-gate 		    (int)(uintptr_t)arg2, arg3, (size_t)arg4));
38767c478bd9Sstevel@tonic-gate 	case ZONE_ENTER:
38777c478bd9Sstevel@tonic-gate 		return (zone_enter((zoneid_t)(uintptr_t)arg1));
38787c478bd9Sstevel@tonic-gate 	case ZONE_LIST:
38797c478bd9Sstevel@tonic-gate 		return (zone_list((zoneid_t *)arg1, (uint_t *)arg2));
38807c478bd9Sstevel@tonic-gate 	case ZONE_SHUTDOWN:
38817c478bd9Sstevel@tonic-gate 		return (zone_shutdown((zoneid_t)(uintptr_t)arg1));
38827c478bd9Sstevel@tonic-gate 	case ZONE_LOOKUP:
38837c478bd9Sstevel@tonic-gate 		return (zone_lookup((const char *)arg1));
3884*821c4a97Sdp 	case ZONE_VERSION:
3885*821c4a97Sdp 		return (zone_version((int *)arg1));
38867c478bd9Sstevel@tonic-gate 	default:
38877c478bd9Sstevel@tonic-gate 		return (set_errno(EINVAL));
38887c478bd9Sstevel@tonic-gate 	}
38897c478bd9Sstevel@tonic-gate }
38907c478bd9Sstevel@tonic-gate 
38917c478bd9Sstevel@tonic-gate struct zarg {
38927c478bd9Sstevel@tonic-gate 	zone_t *zone;
38937c478bd9Sstevel@tonic-gate 	zone_cmd_arg_t arg;
38947c478bd9Sstevel@tonic-gate };
38957c478bd9Sstevel@tonic-gate 
38967c478bd9Sstevel@tonic-gate static int
38977c478bd9Sstevel@tonic-gate zone_lookup_door(const char *zone_name, door_handle_t *doorp)
38987c478bd9Sstevel@tonic-gate {
38997c478bd9Sstevel@tonic-gate 	char *buf;
39007c478bd9Sstevel@tonic-gate 	size_t buflen;
39017c478bd9Sstevel@tonic-gate 	int error;
39027c478bd9Sstevel@tonic-gate 
39037c478bd9Sstevel@tonic-gate 	buflen = sizeof (ZONE_DOOR_PATH) + strlen(zone_name);
39047c478bd9Sstevel@tonic-gate 	buf = kmem_alloc(buflen, KM_SLEEP);
39057c478bd9Sstevel@tonic-gate 	(void) snprintf(buf, buflen, ZONE_DOOR_PATH, zone_name);
39067c478bd9Sstevel@tonic-gate 	error = door_ki_open(buf, doorp);
39077c478bd9Sstevel@tonic-gate 	kmem_free(buf, buflen);
39087c478bd9Sstevel@tonic-gate 	return (error);
39097c478bd9Sstevel@tonic-gate }
39107c478bd9Sstevel@tonic-gate 
39117c478bd9Sstevel@tonic-gate static void
39127c478bd9Sstevel@tonic-gate zone_release_door(door_handle_t *doorp)
39137c478bd9Sstevel@tonic-gate {
39147c478bd9Sstevel@tonic-gate 	door_ki_rele(*doorp);
39157c478bd9Sstevel@tonic-gate 	*doorp = NULL;
39167c478bd9Sstevel@tonic-gate }
39177c478bd9Sstevel@tonic-gate 
39187c478bd9Sstevel@tonic-gate static void
39197c478bd9Sstevel@tonic-gate zone_ki_call_zoneadmd(struct zarg *zargp)
39207c478bd9Sstevel@tonic-gate {
39217c478bd9Sstevel@tonic-gate 	door_handle_t door = NULL;
39227c478bd9Sstevel@tonic-gate 	door_arg_t darg, save_arg;
39237c478bd9Sstevel@tonic-gate 	char *zone_name;
39247c478bd9Sstevel@tonic-gate 	size_t zone_namelen;
39257c478bd9Sstevel@tonic-gate 	zoneid_t zoneid;
39267c478bd9Sstevel@tonic-gate 	zone_t *zone;
39277c478bd9Sstevel@tonic-gate 	zone_cmd_arg_t arg;
39287c478bd9Sstevel@tonic-gate 	uint64_t uniqid;
39297c478bd9Sstevel@tonic-gate 	size_t size;
39307c478bd9Sstevel@tonic-gate 	int error;
39317c478bd9Sstevel@tonic-gate 	int retry;
39327c478bd9Sstevel@tonic-gate 
39337c478bd9Sstevel@tonic-gate 	zone = zargp->zone;
39347c478bd9Sstevel@tonic-gate 	arg = zargp->arg;
39357c478bd9Sstevel@tonic-gate 	kmem_free(zargp, sizeof (*zargp));
39367c478bd9Sstevel@tonic-gate 
39377c478bd9Sstevel@tonic-gate 	zone_namelen = strlen(zone->zone_name) + 1;
39387c478bd9Sstevel@tonic-gate 	zone_name = kmem_alloc(zone_namelen, KM_SLEEP);
39397c478bd9Sstevel@tonic-gate 	bcopy(zone->zone_name, zone_name, zone_namelen);
39407c478bd9Sstevel@tonic-gate 	zoneid = zone->zone_id;
39417c478bd9Sstevel@tonic-gate 	uniqid = zone->zone_uniqid;
39427c478bd9Sstevel@tonic-gate 	/*
39437c478bd9Sstevel@tonic-gate 	 * zoneadmd may be down, but at least we can empty out the zone.
39447c478bd9Sstevel@tonic-gate 	 * We can ignore the return value of zone_empty() since we're called
39457c478bd9Sstevel@tonic-gate 	 * from a kernel thread and know we won't be delivered any signals.
39467c478bd9Sstevel@tonic-gate 	 */
39477c478bd9Sstevel@tonic-gate 	ASSERT(curproc == &p0);
39487c478bd9Sstevel@tonic-gate 	(void) zone_empty(zone);
39497c478bd9Sstevel@tonic-gate 	ASSERT(zone_status_get(zone) >= ZONE_IS_EMPTY);
39507c478bd9Sstevel@tonic-gate 	zone_rele(zone);
39517c478bd9Sstevel@tonic-gate 
39527c478bd9Sstevel@tonic-gate 	size = sizeof (arg);
39537c478bd9Sstevel@tonic-gate 	darg.rbuf = (char *)&arg;
39547c478bd9Sstevel@tonic-gate 	darg.data_ptr = (char *)&arg;
39557c478bd9Sstevel@tonic-gate 	darg.rsize = size;
39567c478bd9Sstevel@tonic-gate 	darg.data_size = size;
39577c478bd9Sstevel@tonic-gate 	darg.desc_ptr = NULL;
39587c478bd9Sstevel@tonic-gate 	darg.desc_num = 0;
39597c478bd9Sstevel@tonic-gate 
39607c478bd9Sstevel@tonic-gate 	save_arg = darg;
39617c478bd9Sstevel@tonic-gate 	/*
39627c478bd9Sstevel@tonic-gate 	 * Since we're not holding a reference to the zone, any number of
39637c478bd9Sstevel@tonic-gate 	 * things can go wrong, including the zone disappearing before we get a
39647c478bd9Sstevel@tonic-gate 	 * chance to talk to zoneadmd.
39657c478bd9Sstevel@tonic-gate 	 */
39667c478bd9Sstevel@tonic-gate 	for (retry = 0; /* forever */; retry++) {
39677c478bd9Sstevel@tonic-gate 		if (door == NULL &&
39687c478bd9Sstevel@tonic-gate 		    (error = zone_lookup_door(zone_name, &door)) != 0) {
39697c478bd9Sstevel@tonic-gate 			goto next;
39707c478bd9Sstevel@tonic-gate 		}
39717c478bd9Sstevel@tonic-gate 		ASSERT(door != NULL);
39727c478bd9Sstevel@tonic-gate 
39737c478bd9Sstevel@tonic-gate 		if ((error = door_ki_upcall(door, &darg)) == 0) {
39747c478bd9Sstevel@tonic-gate 			break;
39757c478bd9Sstevel@tonic-gate 		}
39767c478bd9Sstevel@tonic-gate 		switch (error) {
39777c478bd9Sstevel@tonic-gate 		case EINTR:
39787c478bd9Sstevel@tonic-gate 			/* FALLTHROUGH */
39797c478bd9Sstevel@tonic-gate 		case EAGAIN:	/* process may be forking */
39807c478bd9Sstevel@tonic-gate 			/*
39817c478bd9Sstevel@tonic-gate 			 * Back off for a bit
39827c478bd9Sstevel@tonic-gate 			 */
39837c478bd9Sstevel@tonic-gate 			break;
39847c478bd9Sstevel@tonic-gate 		case EBADF:
39857c478bd9Sstevel@tonic-gate 			zone_release_door(&door);
39867c478bd9Sstevel@tonic-gate 			if (zone_lookup_door(zone_name, &door) != 0) {
39877c478bd9Sstevel@tonic-gate 				/*
39887c478bd9Sstevel@tonic-gate 				 * zoneadmd may be dead, but it may come back to
39897c478bd9Sstevel@tonic-gate 				 * life later.
39907c478bd9Sstevel@tonic-gate 				 */
39917c478bd9Sstevel@tonic-gate 				break;
39927c478bd9Sstevel@tonic-gate 			}
39937c478bd9Sstevel@tonic-gate 			break;
39947c478bd9Sstevel@tonic-gate 		default:
39957c478bd9Sstevel@tonic-gate 			cmn_err(CE_WARN,
39967c478bd9Sstevel@tonic-gate 			    "zone_ki_call_zoneadmd: door_ki_upcall error %d\n",
39977c478bd9Sstevel@tonic-gate 			    error);
39987c478bd9Sstevel@tonic-gate 			goto out;
39997c478bd9Sstevel@tonic-gate 		}
40007c478bd9Sstevel@tonic-gate next:
40017c478bd9Sstevel@tonic-gate 		/*
40027c478bd9Sstevel@tonic-gate 		 * If this isn't the same zone_t that we originally had in mind,
40037c478bd9Sstevel@tonic-gate 		 * then this is the same as if two kadmin requests come in at
40047c478bd9Sstevel@tonic-gate 		 * the same time: the first one wins.  This means we lose, so we
40057c478bd9Sstevel@tonic-gate 		 * bail.
40067c478bd9Sstevel@tonic-gate 		 */
40077c478bd9Sstevel@tonic-gate 		if ((zone = zone_find_by_id(zoneid)) == NULL) {
40087c478bd9Sstevel@tonic-gate 			/*
40097c478bd9Sstevel@tonic-gate 			 * Problem is solved.
40107c478bd9Sstevel@tonic-gate 			 */
40117c478bd9Sstevel@tonic-gate 			break;
40127c478bd9Sstevel@tonic-gate 		}
40137c478bd9Sstevel@tonic-gate 		if (zone->zone_uniqid != uniqid) {
40147c478bd9Sstevel@tonic-gate 			/*
40157c478bd9Sstevel@tonic-gate 			 * zoneid recycled
40167c478bd9Sstevel@tonic-gate 			 */
40177c478bd9Sstevel@tonic-gate 			zone_rele(zone);
40187c478bd9Sstevel@tonic-gate 			break;
40197c478bd9Sstevel@tonic-gate 		}
40207c478bd9Sstevel@tonic-gate 		/*
40217c478bd9Sstevel@tonic-gate 		 * We could zone_status_timedwait(), but there doesn't seem to
40227c478bd9Sstevel@tonic-gate 		 * be much point in doing that (plus, it would mean that
40237c478bd9Sstevel@tonic-gate 		 * zone_free() isn't called until this thread exits).
40247c478bd9Sstevel@tonic-gate 		 */
40257c478bd9Sstevel@tonic-gate 		zone_rele(zone);
40267c478bd9Sstevel@tonic-gate 		delay(hz);
40277c478bd9Sstevel@tonic-gate 		darg = save_arg;
40287c478bd9Sstevel@tonic-gate 	}
40297c478bd9Sstevel@tonic-gate out:
40307c478bd9Sstevel@tonic-gate 	if (door != NULL) {
40317c478bd9Sstevel@tonic-gate 		zone_release_door(&door);
40327c478bd9Sstevel@tonic-gate 	}
40337c478bd9Sstevel@tonic-gate 	kmem_free(zone_name, zone_namelen);
40347c478bd9Sstevel@tonic-gate 	thread_exit();
40357c478bd9Sstevel@tonic-gate }
40367c478bd9Sstevel@tonic-gate 
40377c478bd9Sstevel@tonic-gate /*
40387c478bd9Sstevel@tonic-gate  * Entry point for uadmin() to tell the zone to go away or reboot.  The caller
40397c478bd9Sstevel@tonic-gate  * is a process in the zone to be modified.
40407c478bd9Sstevel@tonic-gate  *
40417c478bd9Sstevel@tonic-gate  * In order to shutdown the zone, we will hand off control to zoneadmd
40427c478bd9Sstevel@tonic-gate  * (running in the global zone) via a door.  We do a half-hearted job at
40437c478bd9Sstevel@tonic-gate  * killing all processes in the zone, create a kernel thread to contact
40447c478bd9Sstevel@tonic-gate  * zoneadmd, and make note of the "uniqid" of the zone.  The uniqid is
40457c478bd9Sstevel@tonic-gate  * a form of generation number used to let zoneadmd (as well as
40467c478bd9Sstevel@tonic-gate  * zone_destroy()) know exactly which zone they're re talking about.
40477c478bd9Sstevel@tonic-gate  */
40487c478bd9Sstevel@tonic-gate int
40497c478bd9Sstevel@tonic-gate zone_uadmin(int cmd, int fcn, cred_t *credp)
40507c478bd9Sstevel@tonic-gate {
40517c478bd9Sstevel@tonic-gate 	struct zarg *zargp;
40527c478bd9Sstevel@tonic-gate 	zone_cmd_t zcmd;
40537c478bd9Sstevel@tonic-gate 	zone_t *zone;
40547c478bd9Sstevel@tonic-gate 
40557c478bd9Sstevel@tonic-gate 	zone = curproc->p_zone;
40567c478bd9Sstevel@tonic-gate 	ASSERT(getzoneid() != GLOBAL_ZONEID);
40577c478bd9Sstevel@tonic-gate 
40587c478bd9Sstevel@tonic-gate 	switch (cmd) {
40597c478bd9Sstevel@tonic-gate 	case A_SHUTDOWN:
40607c478bd9Sstevel@tonic-gate 		switch (fcn) {
40617c478bd9Sstevel@tonic-gate 		case AD_HALT:
40627c478bd9Sstevel@tonic-gate 		case AD_POWEROFF:
40637c478bd9Sstevel@tonic-gate 			zcmd = Z_HALT;
40647c478bd9Sstevel@tonic-gate 			break;
40657c478bd9Sstevel@tonic-gate 		case AD_BOOT:
40667c478bd9Sstevel@tonic-gate 			zcmd = Z_REBOOT;
40677c478bd9Sstevel@tonic-gate 			break;
40687c478bd9Sstevel@tonic-gate 		case AD_IBOOT:
40697c478bd9Sstevel@tonic-gate 		case AD_SBOOT:
40707c478bd9Sstevel@tonic-gate 		case AD_SIBOOT:
40717c478bd9Sstevel@tonic-gate 		case AD_NOSYNC:
40727c478bd9Sstevel@tonic-gate 			return (ENOTSUP);
40737c478bd9Sstevel@tonic-gate 		default:
40747c478bd9Sstevel@tonic-gate 			return (EINVAL);
40757c478bd9Sstevel@tonic-gate 		}
40767c478bd9Sstevel@tonic-gate 		break;
40777c478bd9Sstevel@tonic-gate 	case A_REBOOT:
40787c478bd9Sstevel@tonic-gate 		zcmd = Z_REBOOT;
40797c478bd9Sstevel@tonic-gate 		break;
40807c478bd9Sstevel@tonic-gate 	case A_FTRACE:
40817c478bd9Sstevel@tonic-gate 	case A_REMOUNT:
40827c478bd9Sstevel@tonic-gate 	case A_FREEZE:
40837c478bd9Sstevel@tonic-gate 	case A_DUMP:
40847c478bd9Sstevel@tonic-gate 		return (ENOTSUP);
40857c478bd9Sstevel@tonic-gate 	default:
40867c478bd9Sstevel@tonic-gate 		ASSERT(cmd != A_SWAPCTL);	/* handled by uadmin() */
40877c478bd9Sstevel@tonic-gate 		return (EINVAL);
40887c478bd9Sstevel@tonic-gate 	}
40897c478bd9Sstevel@tonic-gate 
40907c478bd9Sstevel@tonic-gate 	if (secpolicy_zone_admin(credp, B_FALSE))
40917c478bd9Sstevel@tonic-gate 		return (EPERM);
40927c478bd9Sstevel@tonic-gate 	mutex_enter(&zone_status_lock);
40937c478bd9Sstevel@tonic-gate 	/*
40947c478bd9Sstevel@tonic-gate 	 * zone_status can't be ZONE_IS_EMPTY or higher since curproc
40957c478bd9Sstevel@tonic-gate 	 * is in the zone.
40967c478bd9Sstevel@tonic-gate 	 */
40977c478bd9Sstevel@tonic-gate 	ASSERT(zone_status_get(zone) < ZONE_IS_EMPTY);
40987c478bd9Sstevel@tonic-gate 	if (zone_status_get(zone) > ZONE_IS_RUNNING) {
40997c478bd9Sstevel@tonic-gate 		/*
41007c478bd9Sstevel@tonic-gate 		 * This zone is already on its way down.
41017c478bd9Sstevel@tonic-gate 		 */
41027c478bd9Sstevel@tonic-gate 		mutex_exit(&zone_status_lock);
41037c478bd9Sstevel@tonic-gate 		return (0);
41047c478bd9Sstevel@tonic-gate 	}
41057c478bd9Sstevel@tonic-gate 	/*
41067c478bd9Sstevel@tonic-gate 	 * Prevent future zone_enter()s
41077c478bd9Sstevel@tonic-gate 	 */
41087c478bd9Sstevel@tonic-gate 	zone_status_set(zone, ZONE_IS_SHUTTING_DOWN);
41097c478bd9Sstevel@tonic-gate 	mutex_exit(&zone_status_lock);
41107c478bd9Sstevel@tonic-gate 
41117c478bd9Sstevel@tonic-gate 	/*
41127c478bd9Sstevel@tonic-gate 	 * Kill everyone now and call zoneadmd later.
41137c478bd9Sstevel@tonic-gate 	 * zone_ki_call_zoneadmd() will do a more thorough job of this
41147c478bd9Sstevel@tonic-gate 	 * later.
41157c478bd9Sstevel@tonic-gate 	 */
41167c478bd9Sstevel@tonic-gate 	killall(zone->zone_id);
41177c478bd9Sstevel@tonic-gate 	/*
41187c478bd9Sstevel@tonic-gate 	 * Now, create the thread to contact zoneadmd and do the rest of the
41197c478bd9Sstevel@tonic-gate 	 * work.  This thread can't be created in our zone otherwise
41207c478bd9Sstevel@tonic-gate 	 * zone_destroy() would deadlock.
41217c478bd9Sstevel@tonic-gate 	 */
41227c478bd9Sstevel@tonic-gate 	zargp = kmem_alloc(sizeof (*zargp), KM_SLEEP);
41237c478bd9Sstevel@tonic-gate 	zargp->arg.cmd = zcmd;
41247c478bd9Sstevel@tonic-gate 	zargp->arg.uniqid = zone->zone_uniqid;
41257c478bd9Sstevel@tonic-gate 	(void) strcpy(zargp->arg.locale, "C");
41267c478bd9Sstevel@tonic-gate 	zone_hold(zargp->zone = zone);
41277c478bd9Sstevel@tonic-gate 
41287c478bd9Sstevel@tonic-gate 	(void) thread_create(NULL, 0, zone_ki_call_zoneadmd, zargp, 0, &p0,
41297c478bd9Sstevel@tonic-gate 	    TS_RUN, minclsyspri);
41307c478bd9Sstevel@tonic-gate 	exit(CLD_EXITED, 0);
41317c478bd9Sstevel@tonic-gate 
41327c478bd9Sstevel@tonic-gate 	return (EINVAL);
41337c478bd9Sstevel@tonic-gate }
41347c478bd9Sstevel@tonic-gate 
41357c478bd9Sstevel@tonic-gate /*
41367c478bd9Sstevel@tonic-gate  * Entry point so kadmin(A_SHUTDOWN, ...) can set the global zone's
41377c478bd9Sstevel@tonic-gate  * status to ZONE_IS_SHUTTING_DOWN.
41387c478bd9Sstevel@tonic-gate  */
41397c478bd9Sstevel@tonic-gate void
41407c478bd9Sstevel@tonic-gate zone_shutdown_global(void)
41417c478bd9Sstevel@tonic-gate {
41427c478bd9Sstevel@tonic-gate 	ASSERT(curproc->p_zone == global_zone);
41437c478bd9Sstevel@tonic-gate 
41447c478bd9Sstevel@tonic-gate 	mutex_enter(&zone_status_lock);
41457c478bd9Sstevel@tonic-gate 	ASSERT(zone_status_get(global_zone) == ZONE_IS_RUNNING);
41467c478bd9Sstevel@tonic-gate 	zone_status_set(global_zone, ZONE_IS_SHUTTING_DOWN);
41477c478bd9Sstevel@tonic-gate 	mutex_exit(&zone_status_lock);
41487c478bd9Sstevel@tonic-gate }
4149fa9e4066Sahrens 
4150fa9e4066Sahrens /*
4151fa9e4066Sahrens  * Returns true if the named dataset is visible in the current zone.
4152fa9e4066Sahrens  * The 'write' parameter is set to 1 if the dataset is also writable.
4153fa9e4066Sahrens  */
4154fa9e4066Sahrens int
4155fa9e4066Sahrens zone_dataset_visible(const char *dataset, int *write)
4156fa9e4066Sahrens {
4157fa9e4066Sahrens 	zone_dataset_t *zd;
4158fa9e4066Sahrens 	size_t len;
4159fa9e4066Sahrens 	zone_t *zone = curproc->p_zone;
4160fa9e4066Sahrens 
4161fa9e4066Sahrens 	if (dataset[0] == '\0')
4162fa9e4066Sahrens 		return (0);
4163fa9e4066Sahrens 
4164fa9e4066Sahrens 	/*
4165fa9e4066Sahrens 	 * Walk the list once, looking for datasets which match exactly, or
4166fa9e4066Sahrens 	 * specify a dataset underneath an exported dataset.  If found, return
4167fa9e4066Sahrens 	 * true and note that it is writable.
4168fa9e4066Sahrens 	 */
4169fa9e4066Sahrens 	for (zd = list_head(&zone->zone_datasets); zd != NULL;
4170fa9e4066Sahrens 	    zd = list_next(&zone->zone_datasets, zd)) {
4171fa9e4066Sahrens 
4172fa9e4066Sahrens 		len = strlen(zd->zd_dataset);
4173fa9e4066Sahrens 		if (strlen(dataset) >= len &&
4174fa9e4066Sahrens 		    bcmp(dataset, zd->zd_dataset, len) == 0 &&
4175fa9e4066Sahrens 		    (zd->zd_dataset[len-1] == '/' ||
4176fa9e4066Sahrens 		    dataset[len] == '\0' || dataset[len] == '/')) {
4177fa9e4066Sahrens 			if (write)
4178fa9e4066Sahrens 				*write = 1;
4179fa9e4066Sahrens 			return (1);
4180fa9e4066Sahrens 		}
4181fa9e4066Sahrens 	}
4182fa9e4066Sahrens 
4183fa9e4066Sahrens 	/*
4184fa9e4066Sahrens 	 * Walk the list a second time, searching for datasets which are parents
4185fa9e4066Sahrens 	 * of exported datasets.  These should be visible, but read-only.
4186fa9e4066Sahrens 	 *
4187fa9e4066Sahrens 	 * Note that we also have to support forms such as 'pool/dataset/', with
4188fa9e4066Sahrens 	 * a trailing slash.
4189fa9e4066Sahrens 	 */
4190fa9e4066Sahrens 	for (zd = list_head(&zone->zone_datasets); zd != NULL;
4191fa9e4066Sahrens 	    zd = list_next(&zone->zone_datasets, zd)) {
4192fa9e4066Sahrens 
4193fa9e4066Sahrens 		len = strlen(dataset);
4194fa9e4066Sahrens 		if (dataset[len - 1] == '/')
4195fa9e4066Sahrens 			len--;	/* Ignore trailing slash */
4196fa9e4066Sahrens 		if (len < strlen(zd->zd_dataset) &&
4197fa9e4066Sahrens 		    bcmp(dataset, zd->zd_dataset, len) == 0 &&
4198fa9e4066Sahrens 		    zd->zd_dataset[len] == '/') {
4199fa9e4066Sahrens 			if (write)
4200fa9e4066Sahrens 				*write = 0;
4201fa9e4066Sahrens 			return (1);
4202fa9e4066Sahrens 		}
4203fa9e4066Sahrens 	}
4204fa9e4066Sahrens 
4205fa9e4066Sahrens 	return (0);
4206fa9e4066Sahrens }
4207