4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
23 * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
24 * Copyright 2013, Joyent Inc. All rights reserved.
30 * A zone is a named collection of processes, namespace constraints,
31 * and other system resources which comprise a secure and manageable
32 * application containment facility.
34 * Zones (represented by the reference counted zone_t) are tracked in
35 * the kernel in the zonehash. Elsewhere in the kernel, Zone IDs
36 * (zoneid_t) are used to track zone association. Zone IDs are
37 * dynamically generated when the zone is created; if a persistent
38 * identifier is needed (core files, accounting logs, audit trail,
39 * etc.), the zone name should be used.
44 * The global zone (zoneid 0) is automatically associated with all
45 * system resources that have not been bound to a user-created zone.
46 * This means that even systems where zones are not in active use
47 * have a global zone, and all processes, mounts, etc. are
48 * associated with that zone. The global zone is generally
49 * unconstrained in terms of privileges and access, though the usual
50 * credential and privilege based restrictions apply.
55 * The states in which a zone may be in and the transitions are as
58 * ZONE_IS_UNINITIALIZED: primordial state for a zone. The partially
59 * initialized zone is added to the list of active zones on the system but
62 * ZONE_IS_INITIALIZED: Initialization complete except the ZSD callbacks are
63 * not yet completed. Not possible to enter the zone, but attributes can
66 * ZONE_IS_READY: zsched (the kernel dummy process for a zone) is
67 * ready. The zone is made visible after the ZSD constructor callbacks are
68 * executed. A zone remains in this state until it transitions into
69 * the ZONE_IS_BOOTING state as a result of a call to zone_boot().
71 * ZONE_IS_BOOTING: in this shortlived-state, zsched attempts to start
72 * init. Should that fail, the zone proceeds to the ZONE_IS_SHUTTING_DOWN
75 * ZONE_IS_RUNNING: The zone is open for business: zsched has
76 * successfully started init. A zone remains in this state until
77 * zone_shutdown() is called.
79 * ZONE_IS_SHUTTING_DOWN: zone_shutdown() has been called, the system is
80 * killing all processes running in the zone. The zone remains
81 * in this state until there are no more user processes running in the zone.
82 * zone_create(), zone_enter(), and zone_destroy() on this zone will fail.
83 * Since zone_shutdown() is restartable, it may be called successfully
84 * multiple times for the same zone_t. Setting of the zone's state to
85 * ZONE_IS_SHUTTING_DOWN is synchronized with mounts, so VOP_MOUNT() may check
86 * the zone's status without worrying about it being a moving target.
88 * ZONE_IS_EMPTY: zone_shutdown() has been called, and there
89 * are no more user processes in the zone. The zone remains in this
90 * state until there are no more kernel threads associated with the
91 * zone. zone_create(), zone_enter(), and zone_destroy() on this zone will
94 * ZONE_IS_DOWN: All kernel threads doing work on behalf of the zone
95 * have exited. zone_shutdown() returns. Henceforth it is not possible to
96 * join the zone or create kernel threads therein.
98 * ZONE_IS_DYING: zone_destroy() has been called on the zone; zone
99 * remains in this state until zsched exits. Calls to zone_find_by_*()
100 * return NULL from now on.
102 * ZONE_IS_DEAD: zsched has exited (zone_ntasks == 0). There are no
103 * processes or threads doing work on behalf of the zone. The zone is
104 * removed from the list of active zones. zone_destroy() returns, and
105 * the zone can be recreated.
107 * ZONE_IS_FREE (internal state): zone_ref goes to 0, ZSD destructor
108 * callbacks are executed, and all memory associated with the zone is
111 * Threads can wait for the zone to enter a requested state by using
112 * zone_status_wait() or zone_status_timedwait() with the desired
113 * state passed in as an argument. Zone state transitions are
114 * uni-directional; it is not possible to move back to an earlier state.
117 * Zone-Specific Data:
119 * Subsystems needing to maintain zone-specific data can store that
120 * data using the ZSD mechanism. This provides a zone-specific data
121 * store, similar to thread-specific data (see pthread_getspecific(3C)
122 * or the TSD code in uts/common/disp/thread.c. Also, ZSD can be used
123 * to register callbacks to be invoked when a zone is created, shut
124 * down, or destroyed. This can be used to initialize zone-specific
125 * data for new zones and to clean up when zones go away.
130 * The per-zone structure (zone_t) is reference counted, and freed
131 * when all references are released. zone_hold and zone_rele can be
132 * used to adjust the reference count. In addition, reference counts
133 * associated with the cred_t structure are tracked separately using
134 * zone_cred_hold and zone_cred_rele.
136 * Pointers to active zone_t's are stored in two hash tables; one
137 * for searching by id, the other for searching by name. Lookups
138 * can be performed on either basis, using zone_find_by_id and
139 * zone_find_by_name. Both return zone_t pointers with the zone
140 * held, so zone_rele should be called when the pointer is no longer
141 * needed. Zones can also be searched by path; zone_find_by_path
142 * returns the zone with which a path name is associated (global
143 * zone if the path is not within some other zone's file system
144 * hierarchy). This currently requires iterating through each zone,
145 * so it is slower than an id or name search via a hash table.
150 * zonehash_lock: This is a top-level global lock used to protect the
151 * zone hash tables and lists. Zones cannot be created or destroyed
152 * while this lock is held.
153 * zone_status_lock: This is a global lock protecting zone state.
154 * Zones cannot change state while this lock is held. It also
155 * protects the list of kernel threads associated with a zone.
156 * zone_lock: This is a per-zone lock used to protect several fields of
157 * the zone_t (see <sys/zone.h> for details). In addition, holding
158 * this lock means that the zone cannot go away.
159 * zone_nlwps_lock: This is a per-zone lock used to protect the fields
160 * related to the zone.max-lwps rctl.
161 * zone_mem_lock: This is a per-zone lock used to protect the fields
162 * related to the zone.max-locked-memory and zone.max-swap rctls.
163 * zone_rctl_lock: This is a per-zone lock used to protect other rctls,
164 * currently just max_lofi
165 * zsd_key_lock: This is a global lock protecting the key state for ZSD.
166 * zone_deathrow_lock: This is a global lock protecting the "deathrow"
167 * list (a list of zones in the ZONE_IS_DEAD state).
169 * Ordering requirements:
170 * pool_lock --> cpu_lock --> zonehash_lock --> zone_status_lock -->
171 * zone_lock --> zsd_key_lock --> pidlock --> p_lock
173 * When taking zone_mem_lock or zone_nlwps_lock, the lock ordering is:
174 * zonehash_lock --> a_lock --> pidlock --> p_lock --> zone_mem_lock
175 * zonehash_lock --> a_lock --> pidlock --> p_lock --> zone_nlwps_lock
177 * Blocking memory allocations are permitted while holding any of the
181 * System Call Interface:
183 * The zone subsystem can be managed and queried from user level with
184 * the following system calls (all subcodes of the primary "zone"
186 * - zone_create: creates a zone with selected attributes (name,
187 * root path, privileges, resource controls, ZFS datasets)
188 * - zone_enter: allows the current process to enter a zone
189 * - zone_getattr: reports attributes of a zone
190 * - zone_setattr: set attributes of a zone
191 * - zone_boot: set 'init' running for the zone
192 * - zone_list: lists all zones active in the system
193 * - zone_lookup: looks up zone id based on name
194 * - zone_shutdown: initiates shutdown process (see states above)
195 * - zone_destroy: completes shutdown process (see states above)
199 #include <sys/priv_impl.h>
200 #include <sys/cred.h>
201 #include <c2/audit.h>
202 #include <sys/debug.h>
203 #include <sys/file.h>
204 #include <sys/kmem.h>
205 #include <sys/kstat.h>
206 #include <sys/mutex.h>
207 #include <sys/note.h>
208 #include <sys/pathname.h>
209 #include <sys/proc.h>
210 #include <sys/project.h>
211 #include <sys/sysevent.h>
212 #include <sys/task.h>
213 #include <sys/systm.h>
214 #include <sys/types.h>
215 #include <sys/utsname.h>
216 #include <sys/vnode.h>
218 #include <sys/systeminfo.h>
219 #include <sys/policy.h>
220 #include <sys/cred_impl.h>
221 #include <sys/contract_impl.h>
222 #include <sys/contract/process_impl.h>
223 #include <sys/class.h>
224 #include <sys/pool.h>
225 #include <sys/pool_pset.h>
226 #include <sys/pset.h>
227 #include <sys/strlog.h>
228 #include <sys/sysmacros.h>
229 #include <sys/callb.h>
230 #include <sys/vmparam.h>
231 #include <sys/corectl.h>
232 #include <sys/ipc_impl.h>
233 #include <sys/klpd.h>
235 #include <sys/door.h>
236 #include <sys/cpuvar.h>
239 #include <sys/uadmin.h>
240 #include <sys/session.h>
241 #include <sys/cmn_err.h>
242 #include <sys/modhash.h>
243 #include <sys/sunddi.h>
244 #include <sys/nvpair.h>
245 #include <sys/rctl.h>
247 #include <sys/brand.h>
248 #include <sys/zone.h>
250 #include <sys/cpucaps.h>
255 * This constant specifies the number of seconds that threads waiting for
256 * subsystems to release a zone's general-purpose references will wait before
257 * they log the zone's reference counts. The constant's value shouldn't
258 * be so small that reference counts are unnecessarily reported for zones
259 * whose references are slowly released. On the other hand, it shouldn't be so
260 * large that users reboot their systems out of frustration over hung zones
261 * before the system logs the zones' reference counts.
263 #define ZONE_DESTROY_TIMEOUT_SECS 60
265 /* List of data link IDs which are accessible from the zone */
266 typedef struct zone_dl
{
267 datalink_id_t zdl_id
;
269 list_node_t zdl_linkage
;
273 * cv used to signal that all references to the zone have been released. This
274 * needs to be global since there may be multiple waiters, and the first to
275 * wake up will free the zone_t, hence we cannot use zone->zone_cv.
277 static kcondvar_t zone_destroy_cv
;
279 * Lock used to serialize access to zone_cv. This could have been per-zone,
280 * but then we'd need another lock for zone_destroy_cv, and why bother?
282 static kmutex_t zone_status_lock
;
285 * ZSD-related global variables.
287 static kmutex_t zsd_key_lock
; /* protects the following two */
289 * The next caller of zone_key_create() will be assigned a key of ++zsd_keyval.
291 static zone_key_t zsd_keyval
= 0;
293 * Global list of registered keys. We use this when a new zone is created.
295 static list_t zsd_registered_keys
;
297 int zone_hash_size
= 256;
298 static mod_hash_t
*zonehashbyname
, *zonehashbyid
, *zonehashbylabel
;
299 static kmutex_t zonehash_lock
;
300 static uint_t zonecount
;
301 static id_space_t
*zoneid_space
;
304 * The global zone (aka zone0) is the all-seeing, all-knowing zone in which the
305 * kernel proper runs, and which manages all other zones.
307 * Although not declared as static, the variable "zone0" should not be used
308 * except for by code that needs to reference the global zone early on in boot,
309 * before it is fully initialized. All other consumers should use
313 zone_t
*global_zone
= NULL
; /* Set when the global zone is initialized */
316 * List of active zones, protected by zonehash_lock.
318 static list_t zone_active
;
321 * List of destroyed zones that still have outstanding cred references.
322 * Used for debugging. Uses a separate lock to avoid lock ordering
323 * problems in zone_free.
325 static list_t zone_deathrow
;
326 static kmutex_t zone_deathrow_lock
;
328 /* number of zones is limited by virtual interface limit in IP */
329 uint_t maxzones
= 8192;
331 /* Event channel to sent zone state change notifications */
332 evchan_t
*zone_event_chan
;
335 * This table holds the mapping from kernel zone states to
336 * states visible in the state notification API.
337 * The idea is that we only expose "obvious" states and
338 * do not expose states which are just implementation details.
340 const char *zone_status_table
[] = {
341 ZONE_EVENT_UNINITIALIZED
, /* uninitialized */
342 ZONE_EVENT_INITIALIZED
, /* initialized */
343 ZONE_EVENT_READY
, /* ready */
344 ZONE_EVENT_READY
, /* booting */
345 ZONE_EVENT_RUNNING
, /* running */
346 ZONE_EVENT_SHUTTING_DOWN
, /* shutting_down */
347 ZONE_EVENT_SHUTTING_DOWN
, /* empty */
348 ZONE_EVENT_SHUTTING_DOWN
, /* down */
349 ZONE_EVENT_SHUTTING_DOWN
, /* dying */
350 ZONE_EVENT_UNINITIALIZED
, /* dead */
354 * This array contains the names of the subsystems listed in zone_ref_subsys_t
357 static char *zone_ref_subsys_names
[] = {
358 "NFS", /* ZONE_REF_NFS */
359 "NFSv4", /* ZONE_REF_NFSV4 */
360 "SMBFS", /* ZONE_REF_SMBFS */
361 "MNTFS", /* ZONE_REF_MNTFS */
362 "LOFI", /* ZONE_REF_LOFI */
363 "VFS", /* ZONE_REF_VFS */
364 "IPC" /* ZONE_REF_IPC */
368 * This isn't static so lint doesn't complain.
370 rctl_hndl_t rc_zone_cpu_shares
;
371 rctl_hndl_t rc_zone_locked_mem
;
372 rctl_hndl_t rc_zone_max_swap
;
373 rctl_hndl_t rc_zone_max_lofi
;
374 rctl_hndl_t rc_zone_cpu_cap
;
375 rctl_hndl_t rc_zone_nlwps
;
376 rctl_hndl_t rc_zone_nprocs
;
377 rctl_hndl_t rc_zone_shmmax
;
378 rctl_hndl_t rc_zone_shmmni
;
379 rctl_hndl_t rc_zone_semmni
;
380 rctl_hndl_t rc_zone_msgmni
;
382 const char * const zone_default_initname
= "/sbin/init";
383 static char * const zone_prefix
= "/zone/";
384 static int zone_shutdown(zoneid_t zoneid
);
385 static int zone_add_datalink(zoneid_t
, datalink_id_t
);
386 static int zone_remove_datalink(zoneid_t
, datalink_id_t
);
387 static int zone_list_datalink(zoneid_t
, int *, datalink_id_t
*);
388 static int zone_set_network(zoneid_t
, zone_net_data_t
*);
389 static int zone_get_network(zoneid_t
, zone_net_data_t
*);
391 typedef boolean_t
zsd_applyfn_t(kmutex_t
*, boolean_t
, zone_t
*, zone_key_t
);
393 static void zsd_apply_all_zones(zsd_applyfn_t
*, zone_key_t
);
394 static void zsd_apply_all_keys(zsd_applyfn_t
*, zone_t
*);
395 static boolean_t
zsd_apply_create(kmutex_t
*, boolean_t
, zone_t
*, zone_key_t
);
396 static boolean_t
zsd_apply_shutdown(kmutex_t
*, boolean_t
, zone_t
*,
398 static boolean_t
zsd_apply_destroy(kmutex_t
*, boolean_t
, zone_t
*, zone_key_t
);
399 static boolean_t
zsd_wait_for_creator(zone_t
*, struct zsd_entry
*,
401 static boolean_t
zsd_wait_for_inprogress(zone_t
*, struct zsd_entry
*,
405 * Bump this number when you alter the zone syscall interfaces; this is
406 * because we need to have support for previous API versions in libc
407 * to support patching; libc calls into the kernel to determine this number.
409 * Version 1 of the API is the version originally shipped with Solaris 10
410 * Version 2 alters the zone_create system call in order to support more
411 * arguments by moving the args into a structure; and to do better
412 * error reporting when zone_create() fails.
413 * Version 3 alters the zone_create system call in order to support the
414 * import of ZFS datasets to zones.
415 * Version 4 alters the zone_create system call in order to support
416 * Trusted Extensions.
417 * Version 5 alters the zone_boot system call, and converts its old
418 * bootargs parameter to be set by the zone_setattr API instead.
419 * Version 6 adds the flag argument to zone_create.
421 static const int ZONE_SYSCALL_API_VERSION
= 6;
424 * Certain filesystems (such as NFS and autofs) need to know which zone
425 * the mount is being placed in. Because of this, we need to be able to
426 * ensure that a zone isn't in the process of being created/destroyed such
427 * that nfs_mount() thinks it is in the global/NGZ zone, while by the time
428 * it gets added the list of mounted zones, it ends up on the wrong zone's
429 * mount list. Since a zone can't reside on an NFS file system, we don't
430 * have to worry about the zonepath itself.
432 * The following functions: block_mounts()/resume_mounts() and
433 * mount_in_progress()/mount_completed() are used by zones and the VFS
434 * layer (respectively) to synchronize zone state transitions and new
435 * mounts within a zone. This syncronization is on a per-zone basis, so
436 * activity for one zone will not interfere with activity for another zone.
438 * The semantics are like a reader-reader lock such that there may
439 * either be multiple mounts (or zone state transitions, if that weren't
440 * serialized by zonehash_lock) in progress at the same time, but not
443 * We use cv's so the user can ctrl-C out of the operation if it's
446 * The semantics are such that there is unfair bias towards the
447 * "current" operation. This means that zone halt may starve if
448 * there is a rapid succession of new mounts coming in to the zone.
451 * Prevent new mounts from progressing to the point of calling
452 * VFS_MOUNT(). If there are already mounts in this "region", wait for
456 block_mounts(zone_t
*zp
)
461 * Since it may block for a long time, block_mounts() shouldn't be
462 * called with zonehash_lock held.
464 ASSERT(MUTEX_NOT_HELD(&zonehash_lock
));
465 mutex_enter(&zp
->zone_mount_lock
);
466 while (zp
->zone_mounts_in_progress
> 0) {
467 if (cv_wait_sig(&zp
->zone_mount_cv
, &zp
->zone_mount_lock
) == 0)
471 * A negative value of mounts_in_progress indicates that mounts
472 * have been blocked by (-mounts_in_progress) different callers
473 * (remotely possible if two threads enter zone_shutdown at the same
476 zp
->zone_mounts_in_progress
--;
479 mutex_exit(&zp
->zone_mount_lock
);
484 * The VFS layer may progress with new mounts as far as we're concerned.
485 * Allow them to progress if we were the last obstacle.
488 resume_mounts(zone_t
*zp
)
490 mutex_enter(&zp
->zone_mount_lock
);
491 if (++zp
->zone_mounts_in_progress
== 0)
492 cv_broadcast(&zp
->zone_mount_cv
);
493 mutex_exit(&zp
->zone_mount_lock
);
497 * The VFS layer is busy with a mount; this zone should wait until all
498 * of its mounts are completed to progress.
501 mount_in_progress(zone_t
*zp
)
503 mutex_enter(&zp
->zone_mount_lock
);
504 while (zp
->zone_mounts_in_progress
< 0)
505 cv_wait(&zp
->zone_mount_cv
, &zp
->zone_mount_lock
);
506 zp
->zone_mounts_in_progress
++;
507 mutex_exit(&zp
->zone_mount_lock
);
511 * VFS is done with one mount; wake up any waiting block_mounts()
512 * callers if this is the last mount.
515 mount_completed(zone_t
*zp
)
517 mutex_enter(&zp
->zone_mount_lock
);
518 if (--zp
->zone_mounts_in_progress
== 0)
519 cv_broadcast(&zp
->zone_mount_cv
);
520 mutex_exit(&zp
->zone_mount_lock
);
526 * Zone Specific Data (ZSD) is modeled after Thread Specific Data as
527 * defined by the pthread_key_create() and related interfaces.
529 * Kernel subsystems may register one or more data items and/or
530 * callbacks to be executed when a zone is created, shutdown, or
533 * Unlike the thread counterpart, destructor callbacks will be executed
534 * even if the data pointer is NULL and/or there are no constructor
535 * callbacks, so it is the responsibility of such callbacks to check for
536 * NULL data values if necessary.
538 * The locking strategy and overall picture is as follows:
540 * When someone calls zone_key_create(), a template ZSD entry is added to the
541 * global list "zsd_registered_keys", protected by zsd_key_lock. While
542 * holding that lock all the existing zones are marked as
543 * ZSD_CREATE_NEEDED and a copy of the ZSD entry added to the per-zone
544 * zone_zsd list (protected by zone_lock). The global list is updated first
545 * (under zone_key_lock) to make sure that newly created zones use the
546 * most recent list of keys. Then under zonehash_lock we walk the zones
547 * and mark them. Similar locking is used in zone_key_delete().
549 * The actual create, shutdown, and destroy callbacks are done without
550 * holding any lock. And zsd_flags are used to ensure that the operations
551 * completed so that when zone_key_create (and zone_create) is done, as well as
552 * zone_key_delete (and zone_destroy) is done, all the necessary callbacks
555 * When new zones are created constructor callbacks for all registered ZSD
556 * entries will be called. That also uses the above two phases of marking
557 * what needs to be done, and then running the callbacks without holding
560 * The framework does not provide any locking around zone_getspecific() and
561 * zone_setspecific() apart from that needed for internal consistency, so
562 * callers interested in atomic "test-and-set" semantics will need to provide
567 * Helper function to find the zsd_entry associated with the key in the
570 static struct zsd_entry
*
571 zsd_find(list_t
*l
, zone_key_t key
)
573 struct zsd_entry
*zsd
;
575 for (zsd
= list_head(l
); zsd
!= NULL
; zsd
= list_next(l
, zsd
)) {
576 if (zsd
->zsd_key
== key
) {
584 * Helper function to find the zsd_entry associated with the key in the
585 * given list. Move it to the front of the list.
587 static struct zsd_entry
*
588 zsd_find_mru(list_t
*l
, zone_key_t key
)
590 struct zsd_entry
*zsd
;
592 for (zsd
= list_head(l
); zsd
!= NULL
; zsd
= list_next(l
, zsd
)) {
593 if (zsd
->zsd_key
== key
) {
595 * Move to head of list to keep list in MRU order.
597 if (zsd
!= list_head(l
)) {
599 list_insert_head(l
, zsd
);
608 zone_key_create(zone_key_t
*keyp
, void *(*create
)(zoneid_t
),
609 void (*shutdown
)(zoneid_t
, void *), void (*destroy
)(zoneid_t
, void *))
611 struct zsd_entry
*zsdp
;
616 zsdp
= kmem_zalloc(sizeof (*zsdp
), KM_SLEEP
);
617 zsdp
->zsd_data
= NULL
;
618 zsdp
->zsd_create
= create
;
619 zsdp
->zsd_shutdown
= shutdown
;
620 zsdp
->zsd_destroy
= destroy
;
623 * Insert in global list of callbacks. Makes future zone creations
626 mutex_enter(&zsd_key_lock
);
627 key
= zsdp
->zsd_key
= ++zsd_keyval
;
628 ASSERT(zsd_keyval
!= 0);
629 list_insert_tail(&zsd_registered_keys
, zsdp
);
630 mutex_exit(&zsd_key_lock
);
633 * Insert for all existing zones and mark them as needing
636 mutex_enter(&zonehash_lock
); /* stop the world */
637 for (zone
= list_head(&zone_active
); zone
!= NULL
;
638 zone
= list_next(&zone_active
, zone
)) {
639 zone_status_t status
;
641 mutex_enter(&zone
->zone_lock
);
643 /* Skip zones that are on the way down or not yet up */
644 status
= zone_status_get(zone
);
645 if (status
>= ZONE_IS_DOWN
||
646 status
== ZONE_IS_UNINITIALIZED
) {
647 mutex_exit(&zone
->zone_lock
);
651 t
= zsd_find_mru(&zone
->zone_zsd
, key
);
654 * A zsd_configure already inserted it after
655 * we dropped zsd_key_lock above.
657 mutex_exit(&zone
->zone_lock
);
660 t
= kmem_zalloc(sizeof (*t
), KM_SLEEP
);
662 t
->zsd_create
= create
;
663 t
->zsd_shutdown
= shutdown
;
664 t
->zsd_destroy
= destroy
;
665 if (create
!= NULL
) {
666 t
->zsd_flags
= ZSD_CREATE_NEEDED
;
667 DTRACE_PROBE2(zsd__create__needed
,
668 zone_t
*, zone
, zone_key_t
, key
);
670 list_insert_tail(&zone
->zone_zsd
, t
);
671 mutex_exit(&zone
->zone_lock
);
673 mutex_exit(&zonehash_lock
);
675 if (create
!= NULL
) {
676 /* Now call the create callback for this key */
677 zsd_apply_all_zones(zsd_apply_create
, key
);
680 * It is safe for consumers to use the key now, make it
681 * globally visible. Specifically zone_getspecific() will
682 * always successfully return the zone specific data associated
690 * Function called when a module is being unloaded, or otherwise wishes
691 * to unregister its ZSD key and callbacks.
693 * Remove from the global list and determine the functions that need to
694 * be called under a global lock. Then call the functions without
695 * holding any locks. Finally free up the zone_zsd entries. (The apply
696 * functions need to access the zone_zsd entries to find zsd_data etc.)
699 zone_key_delete(zone_key_t key
)
701 struct zsd_entry
*zsdp
= NULL
;
704 mutex_enter(&zsd_key_lock
);
705 zsdp
= zsd_find_mru(&zsd_registered_keys
, key
);
707 mutex_exit(&zsd_key_lock
);
710 list_remove(&zsd_registered_keys
, zsdp
);
711 mutex_exit(&zsd_key_lock
);
713 mutex_enter(&zonehash_lock
);
714 for (zone
= list_head(&zone_active
); zone
!= NULL
;
715 zone
= list_next(&zone_active
, zone
)) {
716 struct zsd_entry
*del
;
718 mutex_enter(&zone
->zone_lock
);
719 del
= zsd_find_mru(&zone
->zone_zsd
, key
);
722 * Somebody else got here first e.g the zone going
725 mutex_exit(&zone
->zone_lock
);
728 ASSERT(del
->zsd_shutdown
== zsdp
->zsd_shutdown
);
729 ASSERT(del
->zsd_destroy
== zsdp
->zsd_destroy
);
730 if (del
->zsd_shutdown
!= NULL
&&
731 (del
->zsd_flags
& ZSD_SHUTDOWN_ALL
) == 0) {
732 del
->zsd_flags
|= ZSD_SHUTDOWN_NEEDED
;
733 DTRACE_PROBE2(zsd__shutdown__needed
,
734 zone_t
*, zone
, zone_key_t
, key
);
736 if (del
->zsd_destroy
!= NULL
&&
737 (del
->zsd_flags
& ZSD_DESTROY_ALL
) == 0) {
738 del
->zsd_flags
|= ZSD_DESTROY_NEEDED
;
739 DTRACE_PROBE2(zsd__destroy__needed
,
740 zone_t
*, zone
, zone_key_t
, key
);
742 mutex_exit(&zone
->zone_lock
);
744 mutex_exit(&zonehash_lock
);
745 kmem_free(zsdp
, sizeof (*zsdp
));
747 /* Now call the shutdown and destroy callback for this key */
748 zsd_apply_all_zones(zsd_apply_shutdown
, key
);
749 zsd_apply_all_zones(zsd_apply_destroy
, key
);
751 /* Now we can free up the zsdp structures in each zone */
752 mutex_enter(&zonehash_lock
);
753 for (zone
= list_head(&zone_active
); zone
!= NULL
;
754 zone
= list_next(&zone_active
, zone
)) {
755 struct zsd_entry
*del
;
757 mutex_enter(&zone
->zone_lock
);
758 del
= zsd_find(&zone
->zone_zsd
, key
);
760 list_remove(&zone
->zone_zsd
, del
);
761 ASSERT(!(del
->zsd_flags
& ZSD_ALL_INPROGRESS
));
762 kmem_free(del
, sizeof (*del
));
764 mutex_exit(&zone
->zone_lock
);
766 mutex_exit(&zonehash_lock
);
772 * ZSD counterpart of pthread_setspecific().
774 * Since all zsd callbacks, including those with no create function,
775 * have an entry in zone_zsd, if the key is registered it is part of
777 * Return an error if the key wasn't registerd.
780 zone_setspecific(zone_key_t key
, zone_t
*zone
, const void *data
)
784 mutex_enter(&zone
->zone_lock
);
785 t
= zsd_find_mru(&zone
->zone_zsd
, key
);
788 * Replace old value with new
790 t
->zsd_data
= (void *)data
;
791 mutex_exit(&zone
->zone_lock
);
794 mutex_exit(&zone
->zone_lock
);
799 * ZSD counterpart of pthread_getspecific().
802 zone_getspecific(zone_key_t key
, zone_t
*zone
)
807 mutex_enter(&zone
->zone_lock
);
808 t
= zsd_find_mru(&zone
->zone_zsd
, key
);
809 data
= (t
== NULL
? NULL
: t
->zsd_data
);
810 mutex_exit(&zone
->zone_lock
);
815 * Function used to initialize a zone's list of ZSD callbacks and data
816 * when the zone is being created. The callbacks are initialized from
817 * the template list (zsd_registered_keys). The constructor callback is
818 * executed later (once the zone exists and with locks dropped).
821 zone_zsd_configure(zone_t
*zone
)
823 struct zsd_entry
*zsdp
;
826 ASSERT(MUTEX_HELD(&zonehash_lock
));
827 ASSERT(list_head(&zone
->zone_zsd
) == NULL
);
828 mutex_enter(&zone
->zone_lock
);
829 mutex_enter(&zsd_key_lock
);
830 for (zsdp
= list_head(&zsd_registered_keys
); zsdp
!= NULL
;
831 zsdp
= list_next(&zsd_registered_keys
, zsdp
)) {
833 * Since this zone is ZONE_IS_UNCONFIGURED, zone_key_create
834 * should not have added anything to it.
836 ASSERT(zsd_find(&zone
->zone_zsd
, zsdp
->zsd_key
) == NULL
);
838 t
= kmem_zalloc(sizeof (*t
), KM_SLEEP
);
839 t
->zsd_key
= zsdp
->zsd_key
;
840 t
->zsd_create
= zsdp
->zsd_create
;
841 t
->zsd_shutdown
= zsdp
->zsd_shutdown
;
842 t
->zsd_destroy
= zsdp
->zsd_destroy
;
843 if (zsdp
->zsd_create
!= NULL
) {
844 t
->zsd_flags
= ZSD_CREATE_NEEDED
;
845 DTRACE_PROBE2(zsd__create__needed
,
846 zone_t
*, zone
, zone_key_t
, zsdp
->zsd_key
);
848 list_insert_tail(&zone
->zone_zsd
, t
);
850 mutex_exit(&zsd_key_lock
);
851 mutex_exit(&zone
->zone_lock
);
854 enum zsd_callback_type
{ ZSD_CREATE
, ZSD_SHUTDOWN
, ZSD_DESTROY
};
857 * Helper function to execute shutdown or destructor callbacks.
860 zone_zsd_callbacks(zone_t
*zone
, enum zsd_callback_type ct
)
864 ASSERT(ct
== ZSD_SHUTDOWN
|| ct
== ZSD_DESTROY
);
865 ASSERT(ct
!= ZSD_SHUTDOWN
|| zone_status_get(zone
) >= ZONE_IS_EMPTY
);
866 ASSERT(ct
!= ZSD_DESTROY
|| zone_status_get(zone
) >= ZONE_IS_DOWN
);
869 * Run the callback solely based on what is registered for the zone
870 * in zone_zsd. The global list can change independently of this
871 * as keys are registered and unregistered and we don't register new
872 * callbacks for a zone that is in the process of going away.
874 mutex_enter(&zone
->zone_lock
);
875 for (t
= list_head(&zone
->zone_zsd
); t
!= NULL
;
876 t
= list_next(&zone
->zone_zsd
, t
)) {
877 zone_key_t key
= t
->zsd_key
;
879 /* Skip if no callbacks registered */
881 if (ct
== ZSD_SHUTDOWN
) {
882 if (t
->zsd_shutdown
!= NULL
&&
883 (t
->zsd_flags
& ZSD_SHUTDOWN_ALL
) == 0) {
884 t
->zsd_flags
|= ZSD_SHUTDOWN_NEEDED
;
885 DTRACE_PROBE2(zsd__shutdown__needed
,
886 zone_t
*, zone
, zone_key_t
, key
);
889 if (t
->zsd_destroy
!= NULL
&&
890 (t
->zsd_flags
& ZSD_DESTROY_ALL
) == 0) {
891 t
->zsd_flags
|= ZSD_DESTROY_NEEDED
;
892 DTRACE_PROBE2(zsd__destroy__needed
,
893 zone_t
*, zone
, zone_key_t
, key
);
897 mutex_exit(&zone
->zone_lock
);
899 /* Now call the shutdown and destroy callback for this key */
900 zsd_apply_all_keys(zsd_apply_shutdown
, zone
);
901 zsd_apply_all_keys(zsd_apply_destroy
, zone
);
906 * Called when the zone is going away; free ZSD-related memory, and
907 * destroy the zone_zsd list.
910 zone_free_zsd(zone_t
*zone
)
912 struct zsd_entry
*t
, *next
;
915 * Free all the zsd_entry's we had on this zone.
917 mutex_enter(&zone
->zone_lock
);
918 for (t
= list_head(&zone
->zone_zsd
); t
!= NULL
; t
= next
) {
919 next
= list_next(&zone
->zone_zsd
, t
);
920 list_remove(&zone
->zone_zsd
, t
);
921 ASSERT(!(t
->zsd_flags
& ZSD_ALL_INPROGRESS
));
922 kmem_free(t
, sizeof (*t
));
924 list_destroy(&zone
->zone_zsd
);
925 mutex_exit(&zone
->zone_lock
);
930 * Apply a function to all zones for particular key value.
932 * The applyfn has to drop zonehash_lock if it does some work, and
933 * then reacquire it before it returns.
934 * When the lock is dropped we don't follow list_next even
935 * if it is possible to do so without any hazards. This is
936 * because we want the design to allow for the list of zones
937 * to change in any arbitrary way during the time the
940 * It is safe to restart the loop at list_head since the applyfn
941 * changes the zsd_flags as it does work, so a subsequent
942 * pass through will have no effect in applyfn, hence the loop will terminate
943 * in at worst O(N^2).
946 zsd_apply_all_zones(zsd_applyfn_t
*applyfn
, zone_key_t key
)
950 mutex_enter(&zonehash_lock
);
951 zone
= list_head(&zone_active
);
952 while (zone
!= NULL
) {
953 if ((applyfn
)(&zonehash_lock
, B_FALSE
, zone
, key
)) {
954 /* Lock dropped - restart at head */
955 zone
= list_head(&zone_active
);
957 zone
= list_next(&zone_active
, zone
);
960 mutex_exit(&zonehash_lock
);
964 * Apply a function to all keys for a particular zone.
966 * The applyfn has to drop zonehash_lock if it does some work, and
967 * then reacquire it before it returns.
968 * When the lock is dropped we don't follow list_next even
969 * if it is possible to do so without any hazards. This is
970 * because we want the design to allow for the list of zsd callbacks
971 * to change in any arbitrary way during the time the
974 * It is safe to restart the loop at list_head since the applyfn
975 * changes the zsd_flags as it does work, so a subsequent
976 * pass through will have no effect in applyfn, hence the loop will terminate
977 * in at worst O(N^2).
980 zsd_apply_all_keys(zsd_applyfn_t
*applyfn
, zone_t
*zone
)
984 mutex_enter(&zone
->zone_lock
);
985 t
= list_head(&zone
->zone_zsd
);
987 if ((applyfn
)(NULL
, B_TRUE
, zone
, t
->zsd_key
)) {
988 /* Lock dropped - restart at head */
989 t
= list_head(&zone
->zone_zsd
);
991 t
= list_next(&zone
->zone_zsd
, t
);
994 mutex_exit(&zone
->zone_lock
);
998 * Call the create function for the zone and key if CREATE_NEEDED
1000 * If some other thread gets here first and sets CREATE_INPROGRESS, then
1001 * we wait for that thread to complete so that we can ensure that
1002 * all the callbacks are done when we've looped over all zones/keys.
1004 * When we call the create function, we drop the global held by the
1005 * caller, and return true to tell the caller it needs to re-evalute the
1007 * If the caller holds zone_lock then zone_lock_held is set, and zone_lock
1008 * remains held on exit.
1011 zsd_apply_create(kmutex_t
*lockp
, boolean_t zone_lock_held
,
1012 zone_t
*zone
, zone_key_t key
)
1015 struct zsd_entry
*t
;
1018 if (lockp
!= NULL
) {
1019 ASSERT(MUTEX_HELD(lockp
));
1021 if (zone_lock_held
) {
1022 ASSERT(MUTEX_HELD(&zone
->zone_lock
));
1024 mutex_enter(&zone
->zone_lock
);
1027 t
= zsd_find(&zone
->zone_zsd
, key
);
1030 * Somebody else got here first e.g the zone going
1033 if (!zone_lock_held
)
1034 mutex_exit(&zone
->zone_lock
);
1038 if (zsd_wait_for_inprogress(zone
, t
, lockp
))
1041 if (t
->zsd_flags
& ZSD_CREATE_NEEDED
) {
1042 t
->zsd_flags
&= ~ZSD_CREATE_NEEDED
;
1043 t
->zsd_flags
|= ZSD_CREATE_INPROGRESS
;
1044 DTRACE_PROBE2(zsd__create__inprogress
,
1045 zone_t
*, zone
, zone_key_t
, key
);
1046 mutex_exit(&zone
->zone_lock
);
1051 ASSERT(t
->zsd_create
!= NULL
);
1052 DTRACE_PROBE2(zsd__create__start
,
1053 zone_t
*, zone
, zone_key_t
, key
);
1055 result
= (*t
->zsd_create
)(zone
->zone_id
);
1057 DTRACE_PROBE2(zsd__create__end
,
1058 zone_t
*, zone
, voidn
*, result
);
1060 ASSERT(result
!= NULL
);
1063 mutex_enter(&zone
->zone_lock
);
1064 t
->zsd_data
= result
;
1065 t
->zsd_flags
&= ~ZSD_CREATE_INPROGRESS
;
1066 t
->zsd_flags
|= ZSD_CREATE_COMPLETED
;
1067 cv_broadcast(&t
->zsd_cv
);
1068 DTRACE_PROBE2(zsd__create__completed
,
1069 zone_t
*, zone
, zone_key_t
, key
);
1071 if (!zone_lock_held
)
1072 mutex_exit(&zone
->zone_lock
);
1077 * Call the shutdown function for the zone and key if SHUTDOWN_NEEDED
1079 * If some other thread gets here first and sets *_INPROGRESS, then
1080 * we wait for that thread to complete so that we can ensure that
1081 * all the callbacks are done when we've looped over all zones/keys.
1083 * When we call the shutdown function, we drop the global held by the
1084 * caller, and return true to tell the caller it needs to re-evalute the
1086 * If the caller holds zone_lock then zone_lock_held is set, and zone_lock
1087 * remains held on exit.
1090 zsd_apply_shutdown(kmutex_t
*lockp
, boolean_t zone_lock_held
,
1091 zone_t
*zone
, zone_key_t key
)
1093 struct zsd_entry
*t
;
1097 if (lockp
!= NULL
) {
1098 ASSERT(MUTEX_HELD(lockp
));
1100 if (zone_lock_held
) {
1101 ASSERT(MUTEX_HELD(&zone
->zone_lock
));
1103 mutex_enter(&zone
->zone_lock
);
1106 t
= zsd_find(&zone
->zone_zsd
, key
);
1109 * Somebody else got here first e.g the zone going
1112 if (!zone_lock_held
)
1113 mutex_exit(&zone
->zone_lock
);
1117 if (zsd_wait_for_creator(zone
, t
, lockp
))
1120 if (zsd_wait_for_inprogress(zone
, t
, lockp
))
1123 if (t
->zsd_flags
& ZSD_SHUTDOWN_NEEDED
) {
1124 t
->zsd_flags
&= ~ZSD_SHUTDOWN_NEEDED
;
1125 t
->zsd_flags
|= ZSD_SHUTDOWN_INPROGRESS
;
1126 DTRACE_PROBE2(zsd__shutdown__inprogress
,
1127 zone_t
*, zone
, zone_key_t
, key
);
1128 mutex_exit(&zone
->zone_lock
);
1133 ASSERT(t
->zsd_shutdown
!= NULL
);
1136 DTRACE_PROBE2(zsd__shutdown__start
,
1137 zone_t
*, zone
, zone_key_t
, key
);
1139 (t
->zsd_shutdown
)(zone
->zone_id
, data
);
1140 DTRACE_PROBE2(zsd__shutdown__end
,
1141 zone_t
*, zone
, zone_key_t
, key
);
1145 mutex_enter(&zone
->zone_lock
);
1146 t
->zsd_flags
&= ~ZSD_SHUTDOWN_INPROGRESS
;
1147 t
->zsd_flags
|= ZSD_SHUTDOWN_COMPLETED
;
1148 cv_broadcast(&t
->zsd_cv
);
1149 DTRACE_PROBE2(zsd__shutdown__completed
,
1150 zone_t
*, zone
, zone_key_t
, key
);
1152 if (!zone_lock_held
)
1153 mutex_exit(&zone
->zone_lock
);
1158 * Call the destroy function for the zone and key if DESTROY_NEEDED
1160 * If some other thread gets here first and sets *_INPROGRESS, then
1161 * we wait for that thread to complete so that we can ensure that
1162 * all the callbacks are done when we've looped over all zones/keys.
1164 * When we call the destroy function, we drop the global held by the
1165 * caller, and return true to tell the caller it needs to re-evalute the
1167 * If the caller holds zone_lock then zone_lock_held is set, and zone_lock
1168 * remains held on exit.
1171 zsd_apply_destroy(kmutex_t
*lockp
, boolean_t zone_lock_held
,
1172 zone_t
*zone
, zone_key_t key
)
1174 struct zsd_entry
*t
;
1178 if (lockp
!= NULL
) {
1179 ASSERT(MUTEX_HELD(lockp
));
1181 if (zone_lock_held
) {
1182 ASSERT(MUTEX_HELD(&zone
->zone_lock
));
1184 mutex_enter(&zone
->zone_lock
);
1187 t
= zsd_find(&zone
->zone_zsd
, key
);
1190 * Somebody else got here first e.g the zone going
1193 if (!zone_lock_held
)
1194 mutex_exit(&zone
->zone_lock
);
1198 if (zsd_wait_for_creator(zone
, t
, lockp
))
1201 if (zsd_wait_for_inprogress(zone
, t
, lockp
))
1204 if (t
->zsd_flags
& ZSD_DESTROY_NEEDED
) {
1205 t
->zsd_flags
&= ~ZSD_DESTROY_NEEDED
;
1206 t
->zsd_flags
|= ZSD_DESTROY_INPROGRESS
;
1207 DTRACE_PROBE2(zsd__destroy__inprogress
,
1208 zone_t
*, zone
, zone_key_t
, key
);
1209 mutex_exit(&zone
->zone_lock
);
1214 ASSERT(t
->zsd_destroy
!= NULL
);
1216 DTRACE_PROBE2(zsd__destroy__start
,
1217 zone_t
*, zone
, zone_key_t
, key
);
1219 (t
->zsd_destroy
)(zone
->zone_id
, data
);
1220 DTRACE_PROBE2(zsd__destroy__end
,
1221 zone_t
*, zone
, zone_key_t
, key
);
1225 mutex_enter(&zone
->zone_lock
);
1227 t
->zsd_flags
&= ~ZSD_DESTROY_INPROGRESS
;
1228 t
->zsd_flags
|= ZSD_DESTROY_COMPLETED
;
1229 cv_broadcast(&t
->zsd_cv
);
1230 DTRACE_PROBE2(zsd__destroy__completed
,
1231 zone_t
*, zone
, zone_key_t
, key
);
1233 if (!zone_lock_held
)
1234 mutex_exit(&zone
->zone_lock
);
1239 * Wait for any CREATE_NEEDED flag to be cleared.
1240 * Returns true if lockp was temporarily dropped while waiting.
1243 zsd_wait_for_creator(zone_t
*zone
, struct zsd_entry
*t
, kmutex_t
*lockp
)
1245 boolean_t dropped
= B_FALSE
;
1247 while (t
->zsd_flags
& ZSD_CREATE_NEEDED
) {
1248 DTRACE_PROBE2(zsd__wait__for__creator
,
1249 zone_t
*, zone
, struct zsd_entry
*, t
);
1250 if (lockp
!= NULL
) {
1254 cv_wait(&t
->zsd_cv
, &zone
->zone_lock
);
1255 if (lockp
!= NULL
) {
1256 /* First drop zone_lock to preserve order */
1257 mutex_exit(&zone
->zone_lock
);
1259 mutex_enter(&zone
->zone_lock
);
1266 * Wait for any INPROGRESS flag to be cleared.
1267 * Returns true if lockp was temporarily dropped while waiting.
1270 zsd_wait_for_inprogress(zone_t
*zone
, struct zsd_entry
*t
, kmutex_t
*lockp
)
1272 boolean_t dropped
= B_FALSE
;
1274 while (t
->zsd_flags
& ZSD_ALL_INPROGRESS
) {
1275 DTRACE_PROBE2(zsd__wait__for__inprogress
,
1276 zone_t
*, zone
, struct zsd_entry
*, t
);
1277 if (lockp
!= NULL
) {
1281 cv_wait(&t
->zsd_cv
, &zone
->zone_lock
);
1282 if (lockp
!= NULL
) {
1283 /* First drop zone_lock to preserve order */
1284 mutex_exit(&zone
->zone_lock
);
1286 mutex_enter(&zone
->zone_lock
);
1293 * Frees memory associated with the zone dataset list.
1296 zone_free_datasets(zone_t
*zone
)
1298 zone_dataset_t
*t
, *next
;
1300 for (t
= list_head(&zone
->zone_datasets
); t
!= NULL
; t
= next
) {
1301 next
= list_next(&zone
->zone_datasets
, t
);
1302 list_remove(&zone
->zone_datasets
, t
);
1303 kmem_free(t
->zd_dataset
, strlen(t
->zd_dataset
) + 1);
1304 kmem_free(t
, sizeof (*t
));
1306 list_destroy(&zone
->zone_datasets
);
1310 * zone.cpu-shares resource control support.
1314 zone_cpu_shares_usage(rctl_t
*rctl
, struct proc
*p
)
1316 ASSERT(MUTEX_HELD(&p
->p_lock
));
1317 return (p
->p_zone
->zone_shares
);
1322 zone_cpu_shares_set(rctl_t
*rctl
, struct proc
*p
, rctl_entity_p_t
*e
,
1325 ASSERT(MUTEX_HELD(&p
->p_lock
));
1326 ASSERT(e
->rcep_t
== RCENTITY_ZONE
);
1327 if (e
->rcep_p
.zone
== NULL
)
1330 e
->rcep_p
.zone
->zone_shares
= nv
;
1334 static rctl_ops_t zone_cpu_shares_ops
= {
1336 zone_cpu_shares_usage
,
1337 zone_cpu_shares_set
,
1342 * zone.cpu-cap resource control support.
1346 zone_cpu_cap_get(rctl_t
*rctl
, struct proc
*p
)
1348 ASSERT(MUTEX_HELD(&p
->p_lock
));
1349 return (cpucaps_zone_get(p
->p_zone
));
1354 zone_cpu_cap_set(rctl_t
*rctl
, struct proc
*p
, rctl_entity_p_t
*e
,
1357 zone_t
*zone
= e
->rcep_p
.zone
;
1359 ASSERT(MUTEX_HELD(&p
->p_lock
));
1360 ASSERT(e
->rcep_t
== RCENTITY_ZONE
);
1366 * set cap to the new value.
1368 return (cpucaps_zone_set(zone
, nv
));
1371 static rctl_ops_t zone_cpu_cap_ops
= {
1380 zone_lwps_usage(rctl_t
*r
, proc_t
*p
)
1383 zone_t
*zone
= p
->p_zone
;
1385 ASSERT(MUTEX_HELD(&p
->p_lock
));
1387 mutex_enter(&zone
->zone_nlwps_lock
);
1388 nlwps
= zone
->zone_nlwps
;
1389 mutex_exit(&zone
->zone_nlwps_lock
);
1396 zone_lwps_test(rctl_t
*r
, proc_t
*p
, rctl_entity_p_t
*e
, rctl_val_t
*rcntl
,
1397 rctl_qty_t incr
, uint_t flags
)
1401 ASSERT(MUTEX_HELD(&p
->p_lock
));
1402 ASSERT(e
->rcep_t
== RCENTITY_ZONE
);
1403 if (e
->rcep_p
.zone
== NULL
)
1405 ASSERT(MUTEX_HELD(&(e
->rcep_p
.zone
->zone_nlwps_lock
)));
1406 nlwps
= e
->rcep_p
.zone
->zone_nlwps
;
1408 if (nlwps
+ incr
> rcntl
->rcv_value
)
1416 zone_lwps_set(rctl_t
*rctl
, struct proc
*p
, rctl_entity_p_t
*e
, rctl_qty_t nv
)
1418 ASSERT(MUTEX_HELD(&p
->p_lock
));
1419 ASSERT(e
->rcep_t
== RCENTITY_ZONE
);
1420 if (e
->rcep_p
.zone
== NULL
)
1422 e
->rcep_p
.zone
->zone_nlwps_ctl
= nv
;
1426 static rctl_ops_t zone_lwps_ops
= {
1435 zone_procs_usage(rctl_t
*r
, proc_t
*p
)
1438 zone_t
*zone
= p
->p_zone
;
1440 ASSERT(MUTEX_HELD(&p
->p_lock
));
1442 mutex_enter(&zone
->zone_nlwps_lock
);
1443 nprocs
= zone
->zone_nprocs
;
1444 mutex_exit(&zone
->zone_nlwps_lock
);
1451 zone_procs_test(rctl_t
*r
, proc_t
*p
, rctl_entity_p_t
*e
, rctl_val_t
*rcntl
,
1452 rctl_qty_t incr
, uint_t flags
)
1456 ASSERT(MUTEX_HELD(&p
->p_lock
));
1457 ASSERT(e
->rcep_t
== RCENTITY_ZONE
);
1458 if (e
->rcep_p
.zone
== NULL
)
1460 ASSERT(MUTEX_HELD(&(e
->rcep_p
.zone
->zone_nlwps_lock
)));
1461 nprocs
= e
->rcep_p
.zone
->zone_nprocs
;
1463 if (nprocs
+ incr
> rcntl
->rcv_value
)
1471 zone_procs_set(rctl_t
*rctl
, struct proc
*p
, rctl_entity_p_t
*e
, rctl_qty_t nv
)
1473 ASSERT(MUTEX_HELD(&p
->p_lock
));
1474 ASSERT(e
->rcep_t
== RCENTITY_ZONE
);
1475 if (e
->rcep_p
.zone
== NULL
)
1477 e
->rcep_p
.zone
->zone_nprocs_ctl
= nv
;
1481 static rctl_ops_t zone_procs_ops
= {
1490 zone_shmmax_test(rctl_t
*r
, proc_t
*p
, rctl_entity_p_t
*e
, rctl_val_t
*rval
,
1491 rctl_qty_t incr
, uint_t flags
)
1494 ASSERT(MUTEX_HELD(&p
->p_lock
));
1495 ASSERT(e
->rcep_t
== RCENTITY_ZONE
);
1496 v
= e
->rcep_p
.zone
->zone_shmmax
+ incr
;
1497 if (v
> rval
->rcv_value
)
1502 static rctl_ops_t zone_shmmax_ops
= {
1511 zone_shmmni_test(rctl_t
*r
, proc_t
*p
, rctl_entity_p_t
*e
, rctl_val_t
*rval
,
1512 rctl_qty_t incr
, uint_t flags
)
1515 ASSERT(MUTEX_HELD(&p
->p_lock
));
1516 ASSERT(e
->rcep_t
== RCENTITY_ZONE
);
1517 v
= e
->rcep_p
.zone
->zone_ipc
.ipcq_shmmni
+ incr
;
1518 if (v
> rval
->rcv_value
)
1523 static rctl_ops_t zone_shmmni_ops
= {
1532 zone_semmni_test(rctl_t
*r
, proc_t
*p
, rctl_entity_p_t
*e
, rctl_val_t
*rval
,
1533 rctl_qty_t incr
, uint_t flags
)
1536 ASSERT(MUTEX_HELD(&p
->p_lock
));
1537 ASSERT(e
->rcep_t
== RCENTITY_ZONE
);
1538 v
= e
->rcep_p
.zone
->zone_ipc
.ipcq_semmni
+ incr
;
1539 if (v
> rval
->rcv_value
)
1544 static rctl_ops_t zone_semmni_ops
= {
1553 zone_msgmni_test(rctl_t
*r
, proc_t
*p
, rctl_entity_p_t
*e
, rctl_val_t
*rval
,
1554 rctl_qty_t incr
, uint_t flags
)
1557 ASSERT(MUTEX_HELD(&p
->p_lock
));
1558 ASSERT(e
->rcep_t
== RCENTITY_ZONE
);
1559 v
= e
->rcep_p
.zone
->zone_ipc
.ipcq_msgmni
+ incr
;
1560 if (v
> rval
->rcv_value
)
1565 static rctl_ops_t zone_msgmni_ops
= {
1574 zone_locked_mem_usage(rctl_t
*rctl
, struct proc
*p
)
1577 ASSERT(MUTEX_HELD(&p
->p_lock
));
1578 mutex_enter(&p
->p_zone
->zone_mem_lock
);
1579 q
= p
->p_zone
->zone_locked_mem
;
1580 mutex_exit(&p
->p_zone
->zone_mem_lock
);
1586 zone_locked_mem_test(rctl_t
*r
, proc_t
*p
, rctl_entity_p_t
*e
,
1587 rctl_val_t
*rcntl
, rctl_qty_t incr
, uint_t flags
)
1593 ASSERT(MUTEX_HELD(&p
->p_lock
));
1594 ASSERT(MUTEX_HELD(&z
->zone_mem_lock
));
1595 q
= z
->zone_locked_mem
;
1596 if (q
+ incr
> rcntl
->rcv_value
)
1603 zone_locked_mem_set(rctl_t
*rctl
, struct proc
*p
, rctl_entity_p_t
*e
,
1606 ASSERT(MUTEX_HELD(&p
->p_lock
));
1607 ASSERT(e
->rcep_t
== RCENTITY_ZONE
);
1608 if (e
->rcep_p
.zone
== NULL
)
1610 e
->rcep_p
.zone
->zone_locked_mem_ctl
= nv
;
1614 static rctl_ops_t zone_locked_mem_ops
= {
1616 zone_locked_mem_usage
,
1617 zone_locked_mem_set
,
1618 zone_locked_mem_test
1623 zone_max_swap_usage(rctl_t
*rctl
, struct proc
*p
)
1626 zone_t
*z
= p
->p_zone
;
1628 ASSERT(MUTEX_HELD(&p
->p_lock
));
1629 mutex_enter(&z
->zone_mem_lock
);
1630 q
= z
->zone_max_swap
;
1631 mutex_exit(&z
->zone_mem_lock
);
1637 zone_max_swap_test(rctl_t
*r
, proc_t
*p
, rctl_entity_p_t
*e
,
1638 rctl_val_t
*rcntl
, rctl_qty_t incr
, uint_t flags
)
1644 ASSERT(MUTEX_HELD(&p
->p_lock
));
1645 ASSERT(MUTEX_HELD(&z
->zone_mem_lock
));
1646 q
= z
->zone_max_swap
;
1647 if (q
+ incr
> rcntl
->rcv_value
)
1654 zone_max_swap_set(rctl_t
*rctl
, struct proc
*p
, rctl_entity_p_t
*e
,
1657 ASSERT(MUTEX_HELD(&p
->p_lock
));
1658 ASSERT(e
->rcep_t
== RCENTITY_ZONE
);
1659 if (e
->rcep_p
.zone
== NULL
)
1661 e
->rcep_p
.zone
->zone_max_swap_ctl
= nv
;
1665 static rctl_ops_t zone_max_swap_ops
= {
1667 zone_max_swap_usage
,
1674 zone_max_lofi_usage(rctl_t
*rctl
, struct proc
*p
)
1677 zone_t
*z
= p
->p_zone
;
1679 ASSERT(MUTEX_HELD(&p
->p_lock
));
1680 mutex_enter(&z
->zone_rctl_lock
);
1681 q
= z
->zone_max_lofi
;
1682 mutex_exit(&z
->zone_rctl_lock
);
1688 zone_max_lofi_test(rctl_t
*r
, proc_t
*p
, rctl_entity_p_t
*e
,
1689 rctl_val_t
*rcntl
, rctl_qty_t incr
, uint_t flags
)
1695 ASSERT(MUTEX_HELD(&p
->p_lock
));
1696 ASSERT(MUTEX_HELD(&z
->zone_rctl_lock
));
1697 q
= z
->zone_max_lofi
;
1698 if (q
+ incr
> rcntl
->rcv_value
)
1705 zone_max_lofi_set(rctl_t
*rctl
, struct proc
*p
, rctl_entity_p_t
*e
,
1708 ASSERT(MUTEX_HELD(&p
->p_lock
));
1709 ASSERT(e
->rcep_t
== RCENTITY_ZONE
);
1710 if (e
->rcep_p
.zone
== NULL
)
1712 e
->rcep_p
.zone
->zone_max_lofi_ctl
= nv
;
1716 static rctl_ops_t zone_max_lofi_ops
= {
1718 zone_max_lofi_usage
,
1724 * Helper function to brand the zone with a unique ID.
1727 zone_uniqid(zone_t
*zone
)
1729 static uint64_t uniqid
= 0;
1731 ASSERT(MUTEX_HELD(&zonehash_lock
));
1732 zone
->zone_uniqid
= uniqid
++;
1736 * Returns a held pointer to the "kcred" for the specified zone.
1739 zone_get_kcred(zoneid_t zoneid
)
1744 if ((zone
= zone_find_by_id(zoneid
)) == NULL
)
1746 cr
= zone
->zone_kcred
;
1753 zone_lockedmem_kstat_update(kstat_t
*ksp
, int rw
)
1755 zone_t
*zone
= ksp
->ks_private
;
1756 zone_kstat_t
*zk
= ksp
->ks_data
;
1758 if (rw
== KSTAT_WRITE
)
1761 zk
->zk_usage
.value
.ui64
= zone
->zone_locked_mem
;
1762 zk
->zk_value
.value
.ui64
= zone
->zone_locked_mem_ctl
;
1767 zone_nprocs_kstat_update(kstat_t
*ksp
, int rw
)
1769 zone_t
*zone
= ksp
->ks_private
;
1770 zone_kstat_t
*zk
= ksp
->ks_data
;
1772 if (rw
== KSTAT_WRITE
)
1775 zk
->zk_usage
.value
.ui64
= zone
->zone_nprocs
;
1776 zk
->zk_value
.value
.ui64
= zone
->zone_nprocs_ctl
;
1781 zone_swapresv_kstat_update(kstat_t
*ksp
, int rw
)
1783 zone_t
*zone
= ksp
->ks_private
;
1784 zone_kstat_t
*zk
= ksp
->ks_data
;
1786 if (rw
== KSTAT_WRITE
)
1789 zk
->zk_usage
.value
.ui64
= zone
->zone_max_swap
;
1790 zk
->zk_value
.value
.ui64
= zone
->zone_max_swap_ctl
;
1795 zone_kstat_create_common(zone_t
*zone
, char *name
,
1796 int (*updatefunc
) (kstat_t
*, int))
1801 ksp
= rctl_kstat_create_zone(zone
, name
, KSTAT_TYPE_NAMED
,
1802 sizeof (zone_kstat_t
) / sizeof (kstat_named_t
),
1803 KSTAT_FLAG_VIRTUAL
);
1808 zk
= ksp
->ks_data
= kmem_alloc(sizeof (zone_kstat_t
), KM_SLEEP
);
1809 ksp
->ks_data_size
+= strlen(zone
->zone_name
) + 1;
1810 kstat_named_init(&zk
->zk_zonename
, "zonename", KSTAT_DATA_STRING
);
1811 kstat_named_setstr(&zk
->zk_zonename
, zone
->zone_name
);
1812 kstat_named_init(&zk
->zk_usage
, "usage", KSTAT_DATA_UINT64
);
1813 kstat_named_init(&zk
->zk_value
, "value", KSTAT_DATA_UINT64
);
1814 ksp
->ks_update
= updatefunc
;
1815 ksp
->ks_private
= zone
;
1821 zone_misc_kstat_update(kstat_t
*ksp
, int rw
)
1823 zone_t
*zone
= ksp
->ks_private
;
1824 zone_misc_kstat_t
*zmp
= ksp
->ks_data
;
1827 if (rw
== KSTAT_WRITE
)
1830 tmp
= zone
->zone_utime
;
1832 zmp
->zm_utime
.value
.ui64
= tmp
;
1833 tmp
= zone
->zone_stime
;
1835 zmp
->zm_stime
.value
.ui64
= tmp
;
1836 tmp
= zone
->zone_wtime
;
1838 zmp
->zm_wtime
.value
.ui64
= tmp
;
1840 zmp
->zm_avenrun1
.value
.ui32
= zone
->zone_avenrun
[0];
1841 zmp
->zm_avenrun5
.value
.ui32
= zone
->zone_avenrun
[1];
1842 zmp
->zm_avenrun15
.value
.ui32
= zone
->zone_avenrun
[2];
1844 zmp
->zm_ffcap
.value
.ui32
= zone
->zone_ffcap
;
1845 zmp
->zm_ffnoproc
.value
.ui32
= zone
->zone_ffnoproc
;
1846 zmp
->zm_ffnomem
.value
.ui32
= zone
->zone_ffnomem
;
1847 zmp
->zm_ffmisc
.value
.ui32
= zone
->zone_ffmisc
;
1853 zone_misc_kstat_create(zone_t
*zone
)
1856 zone_misc_kstat_t
*zmp
;
1858 if ((ksp
= kstat_create_zone("zones", zone
->zone_id
,
1859 zone
->zone_name
, "zone_misc", KSTAT_TYPE_NAMED
,
1860 sizeof (zone_misc_kstat_t
) / sizeof (kstat_named_t
),
1861 KSTAT_FLAG_VIRTUAL
, zone
->zone_id
)) == NULL
)
1864 if (zone
->zone_id
!= GLOBAL_ZONEID
)
1865 kstat_zone_add(ksp
, GLOBAL_ZONEID
);
1867 zmp
= ksp
->ks_data
= kmem_zalloc(sizeof (zone_misc_kstat_t
), KM_SLEEP
);
1868 ksp
->ks_data_size
+= strlen(zone
->zone_name
) + 1;
1869 ksp
->ks_lock
= &zone
->zone_misc_lock
;
1870 zone
->zone_misc_stats
= zmp
;
1872 /* The kstat "name" field is not large enough for a full zonename */
1873 kstat_named_init(&zmp
->zm_zonename
, "zonename", KSTAT_DATA_STRING
);
1874 kstat_named_setstr(&zmp
->zm_zonename
, zone
->zone_name
);
1875 kstat_named_init(&zmp
->zm_utime
, "nsec_user", KSTAT_DATA_UINT64
);
1876 kstat_named_init(&zmp
->zm_stime
, "nsec_sys", KSTAT_DATA_UINT64
);
1877 kstat_named_init(&zmp
->zm_wtime
, "nsec_waitrq", KSTAT_DATA_UINT64
);
1878 kstat_named_init(&zmp
->zm_avenrun1
, "avenrun_1min", KSTAT_DATA_UINT32
);
1879 kstat_named_init(&zmp
->zm_avenrun5
, "avenrun_5min", KSTAT_DATA_UINT32
);
1880 kstat_named_init(&zmp
->zm_avenrun15
, "avenrun_15min",
1882 kstat_named_init(&zmp
->zm_ffcap
, "forkfail_cap", KSTAT_DATA_UINT32
);
1883 kstat_named_init(&zmp
->zm_ffnoproc
, "forkfail_noproc",
1885 kstat_named_init(&zmp
->zm_ffnomem
, "forkfail_nomem", KSTAT_DATA_UINT32
);
1886 kstat_named_init(&zmp
->zm_ffmisc
, "forkfail_misc", KSTAT_DATA_UINT32
);
1889 ksp
->ks_update
= zone_misc_kstat_update
;
1890 ksp
->ks_private
= zone
;
1897 zone_kstat_create(zone_t
*zone
)
1899 zone
->zone_lockedmem_kstat
= zone_kstat_create_common(zone
,
1900 "lockedmem", zone_lockedmem_kstat_update
);
1901 zone
->zone_swapresv_kstat
= zone_kstat_create_common(zone
,
1902 "swapresv", zone_swapresv_kstat_update
);
1903 zone
->zone_nprocs_kstat
= zone_kstat_create_common(zone
,
1904 "nprocs", zone_nprocs_kstat_update
);
1906 if ((zone
->zone_misc_ksp
= zone_misc_kstat_create(zone
)) == NULL
) {
1907 zone
->zone_misc_stats
= kmem_zalloc(
1908 sizeof (zone_misc_kstat_t
), KM_SLEEP
);
1913 zone_kstat_delete_common(kstat_t
**pkstat
, size_t datasz
)
1917 if (*pkstat
!= NULL
) {
1918 data
= (*pkstat
)->ks_data
;
1919 kstat_delete(*pkstat
);
1920 kmem_free(data
, datasz
);
1926 zone_kstat_delete(zone_t
*zone
)
1928 zone_kstat_delete_common(&zone
->zone_lockedmem_kstat
,
1929 sizeof (zone_kstat_t
));
1930 zone_kstat_delete_common(&zone
->zone_swapresv_kstat
,
1931 sizeof (zone_kstat_t
));
1932 zone_kstat_delete_common(&zone
->zone_nprocs_kstat
,
1933 sizeof (zone_kstat_t
));
1934 zone_kstat_delete_common(&zone
->zone_misc_ksp
,
1935 sizeof (zone_misc_kstat_t
));
1939 * Called very early on in boot to initialize the ZSD list so that
1940 * zone_key_create() can be called before zone_init(). It also initializes
1941 * portions of zone0 which may be used before zone_init() is called. The
1942 * variable "global_zone" will be set when zone0 is fully initialized by
1948 mutex_init(&zonehash_lock
, NULL
, MUTEX_DEFAULT
, NULL
);
1949 mutex_init(&zsd_key_lock
, NULL
, MUTEX_DEFAULT
, NULL
);
1950 list_create(&zsd_registered_keys
, sizeof (struct zsd_entry
),
1951 offsetof(struct zsd_entry
, zsd_linkage
));
1952 list_create(&zone_active
, sizeof (zone_t
),
1953 offsetof(zone_t
, zone_linkage
));
1954 list_create(&zone_deathrow
, sizeof (zone_t
),
1955 offsetof(zone_t
, zone_linkage
));
1957 mutex_init(&zone0
.zone_lock
, NULL
, MUTEX_DEFAULT
, NULL
);
1958 mutex_init(&zone0
.zone_nlwps_lock
, NULL
, MUTEX_DEFAULT
, NULL
);
1959 mutex_init(&zone0
.zone_mem_lock
, NULL
, MUTEX_DEFAULT
, NULL
);
1960 zone0
.zone_shares
= 1;
1961 zone0
.zone_nlwps
= 0;
1962 zone0
.zone_nlwps_ctl
= INT_MAX
;
1963 zone0
.zone_nprocs
= 0;
1964 zone0
.zone_nprocs_ctl
= INT_MAX
;
1965 zone0
.zone_locked_mem
= 0;
1966 zone0
.zone_locked_mem_ctl
= UINT64_MAX
;
1967 ASSERT(zone0
.zone_max_swap
== 0);
1968 zone0
.zone_max_swap_ctl
= UINT64_MAX
;
1969 zone0
.zone_max_lofi
= 0;
1970 zone0
.zone_max_lofi_ctl
= UINT64_MAX
;
1971 zone0
.zone_shmmax
= 0;
1972 zone0
.zone_ipc
.ipcq_shmmni
= 0;
1973 zone0
.zone_ipc
.ipcq_semmni
= 0;
1974 zone0
.zone_ipc
.ipcq_msgmni
= 0;
1975 zone0
.zone_name
= GLOBAL_ZONENAME
;
1976 zone0
.zone_nodename
= utsname
.nodename
;
1977 zone0
.zone_domain
= srpc_domain
;
1978 zone0
.zone_hostid
= HW_INVALID_HOSTID
;
1979 zone0
.zone_fs_allowed
= NULL
;
1981 zone0
.zone_id
= GLOBAL_ZONEID
;
1982 zone0
.zone_status
= ZONE_IS_RUNNING
;
1983 zone0
.zone_rootpath
= "/";
1984 zone0
.zone_rootpathlen
= 2;
1985 zone0
.zone_psetid
= ZONE_PS_INVAL
;
1986 zone0
.zone_ncpus
= 0;
1987 zone0
.zone_ncpus_online
= 0;
1988 zone0
.zone_proc_initpid
= 1;
1989 zone0
.zone_initname
= initname
;
1990 zone0
.zone_lockedmem_kstat
= NULL
;
1991 zone0
.zone_swapresv_kstat
= NULL
;
1992 zone0
.zone_nprocs_kstat
= NULL
;
1994 zone0
.zone_stime
= 0;
1995 zone0
.zone_utime
= 0;
1996 zone0
.zone_wtime
= 0;
1998 list_create(&zone0
.zone_ref_list
, sizeof (zone_ref_t
),
1999 offsetof(zone_ref_t
, zref_linkage
));
2000 list_create(&zone0
.zone_zsd
, sizeof (struct zsd_entry
),
2001 offsetof(struct zsd_entry
, zsd_linkage
));
2002 list_insert_head(&zone_active
, &zone0
);
2005 * The root filesystem is not mounted yet, so zone_rootvp cannot be set
2006 * to anything meaningful. It is assigned to be 'rootdir' in
2009 zone0
.zone_rootvp
= NULL
;
2010 zone0
.zone_vfslist
= NULL
;
2011 zone0
.zone_bootargs
= initargs
;
2012 zone0
.zone_privset
= kmem_alloc(sizeof (priv_set_t
), KM_SLEEP
);
2014 * The global zone has all privileges
2016 priv_fillset(zone0
.zone_privset
);
2018 * Add p0 to the global zone
2020 zone0
.zone_zsched
= &p0
;
2025 * Compute a hash value based on the contents of the label and the DOI. The
2026 * hash algorithm is somewhat arbitrary, but is based on the observation that
2027 * humans will likely pick labels that differ by amounts that work out to be
2028 * multiples of the number of hash chains, and thus stirring in some primes
2032 hash_bylabel(void *hdata
, mod_hash_key_t key
)
2034 const ts_label_t
*lab
= (ts_label_t
*)key
;
2035 const uint32_t *up
, *ue
;
2039 _NOTE(ARGUNUSED(hdata
));
2041 hash
= lab
->tsl_doi
+ (lab
->tsl_doi
<< 1);
2042 /* we depend on alignment of label, but not representation */
2043 up
= (const uint32_t *)&lab
->tsl_label
;
2044 ue
= up
+ sizeof (lab
->tsl_label
) / sizeof (*up
);
2047 /* using 2^n + 1, 1 <= n <= 16 as source of many primes */
2048 hash
+= *up
+ (*up
<< ((i
% 16) + 1));
2056 * All that mod_hash cares about here is zero (equal) versus non-zero (not
2057 * equal). This may need to be changed if less than / greater than is ever
2061 hash_labelkey_cmp(mod_hash_key_t key1
, mod_hash_key_t key2
)
2063 ts_label_t
*lab1
= (ts_label_t
*)key1
;
2064 ts_label_t
*lab2
= (ts_label_t
*)key2
;
2066 return (label_equal(lab1
, lab2
) ? 0 : 1);
2070 * Called by main() to initialize the zones framework.
2075 rctl_dict_entry_t
*rde
;
2078 rctl_alloc_gp_t
*gp
;
2082 ASSERT(curproc
== &p0
);
2085 * Create ID space for zone IDs. ID 0 is reserved for the
2088 zoneid_space
= id_space_create("zoneid_space", 1, MAX_ZONEID
);
2091 * Initialize generic zone resource controls, if any.
2093 rc_zone_cpu_shares
= rctl_register("zone.cpu-shares",
2094 RCENTITY_ZONE
, RCTL_GLOBAL_SIGNAL_NEVER
| RCTL_GLOBAL_DENY_NEVER
|
2095 RCTL_GLOBAL_NOBASIC
| RCTL_GLOBAL_COUNT
| RCTL_GLOBAL_SYSLOG_NEVER
,
2096 FSS_MAXSHARES
, FSS_MAXSHARES
, &zone_cpu_shares_ops
);
2098 rc_zone_cpu_cap
= rctl_register("zone.cpu-cap",
2099 RCENTITY_ZONE
, RCTL_GLOBAL_SIGNAL_NEVER
| RCTL_GLOBAL_DENY_ALWAYS
|
2100 RCTL_GLOBAL_NOBASIC
| RCTL_GLOBAL_COUNT
|RCTL_GLOBAL_SYSLOG_NEVER
|
2101 RCTL_GLOBAL_INFINITE
,
2102 MAXCAP
, MAXCAP
, &zone_cpu_cap_ops
);
2104 rc_zone_nlwps
= rctl_register("zone.max-lwps", RCENTITY_ZONE
,
2105 RCTL_GLOBAL_NOACTION
| RCTL_GLOBAL_NOBASIC
| RCTL_GLOBAL_COUNT
,
2106 INT_MAX
, INT_MAX
, &zone_lwps_ops
);
2108 rc_zone_nprocs
= rctl_register("zone.max-processes", RCENTITY_ZONE
,
2109 RCTL_GLOBAL_NOACTION
| RCTL_GLOBAL_NOBASIC
| RCTL_GLOBAL_COUNT
,
2110 INT_MAX
, INT_MAX
, &zone_procs_ops
);
2113 * System V IPC resource controls
2115 rc_zone_msgmni
= rctl_register("zone.max-msg-ids",
2116 RCENTITY_ZONE
, RCTL_GLOBAL_DENY_ALWAYS
| RCTL_GLOBAL_NOBASIC
|
2117 RCTL_GLOBAL_COUNT
, IPC_IDS_MAX
, IPC_IDS_MAX
, &zone_msgmni_ops
);
2119 rc_zone_semmni
= rctl_register("zone.max-sem-ids",
2120 RCENTITY_ZONE
, RCTL_GLOBAL_DENY_ALWAYS
| RCTL_GLOBAL_NOBASIC
|
2121 RCTL_GLOBAL_COUNT
, IPC_IDS_MAX
, IPC_IDS_MAX
, &zone_semmni_ops
);
2123 rc_zone_shmmni
= rctl_register("zone.max-shm-ids",
2124 RCENTITY_ZONE
, RCTL_GLOBAL_DENY_ALWAYS
| RCTL_GLOBAL_NOBASIC
|
2125 RCTL_GLOBAL_COUNT
, IPC_IDS_MAX
, IPC_IDS_MAX
, &zone_shmmni_ops
);
2127 rc_zone_shmmax
= rctl_register("zone.max-shm-memory",
2128 RCENTITY_ZONE
, RCTL_GLOBAL_DENY_ALWAYS
| RCTL_GLOBAL_NOBASIC
|
2129 RCTL_GLOBAL_BYTES
, UINT64_MAX
, UINT64_MAX
, &zone_shmmax_ops
);
2132 * Create a rctl_val with PRIVILEGED, NOACTION, value = 1. Then attach
2133 * this at the head of the rctl_dict_entry for ``zone.cpu-shares''.
2135 dval
= kmem_cache_alloc(rctl_val_cache
, KM_SLEEP
);
2136 bzero(dval
, sizeof (rctl_val_t
));
2137 dval
->rcv_value
= 1;
2138 dval
->rcv_privilege
= RCPRIV_PRIVILEGED
;
2139 dval
->rcv_flagaction
= RCTL_LOCAL_NOACTION
;
2140 dval
->rcv_action_recip_pid
= -1;
2142 rde
= rctl_dict_lookup("zone.cpu-shares");
2143 (void) rctl_val_list_insert(&rde
->rcd_default_value
, dval
);
2145 rc_zone_locked_mem
= rctl_register("zone.max-locked-memory",
2146 RCENTITY_ZONE
, RCTL_GLOBAL_NOBASIC
| RCTL_GLOBAL_BYTES
|
2147 RCTL_GLOBAL_DENY_ALWAYS
, UINT64_MAX
, UINT64_MAX
,
2148 &zone_locked_mem_ops
);
2150 rc_zone_max_swap
= rctl_register("zone.max-swap",
2151 RCENTITY_ZONE
, RCTL_GLOBAL_NOBASIC
| RCTL_GLOBAL_BYTES
|
2152 RCTL_GLOBAL_DENY_ALWAYS
, UINT64_MAX
, UINT64_MAX
,
2153 &zone_max_swap_ops
);
2155 rc_zone_max_lofi
= rctl_register("zone.max-lofi",
2156 RCENTITY_ZONE
, RCTL_GLOBAL_NOBASIC
| RCTL_GLOBAL_COUNT
|
2157 RCTL_GLOBAL_DENY_ALWAYS
, UINT64_MAX
, UINT64_MAX
,
2158 &zone_max_lofi_ops
);
2161 * Initialize the ``global zone''.
2163 set
= rctl_set_create();
2164 gp
= rctl_set_init_prealloc(RCENTITY_ZONE
);
2165 mutex_enter(&p0
.p_lock
);
2166 e
.rcep_p
.zone
= &zone0
;
2167 e
.rcep_t
= RCENTITY_ZONE
;
2168 zone0
.zone_rctls
= rctl_set_init(RCENTITY_ZONE
, &p0
, &e
, set
,
2171 zone0
.zone_nlwps
= p0
.p_lwpcnt
;
2172 zone0
.zone_nprocs
= 1;
2173 zone0
.zone_ntasks
= 1;
2174 mutex_exit(&p0
.p_lock
);
2175 zone0
.zone_restart_init
= B_TRUE
;
2176 zone0
.zone_brand
= &native_brand
;
2177 rctl_prealloc_destroy(gp
);
2179 * pool_default hasn't been initialized yet, so we let pool_init()
2180 * take care of making sure the global zone is in the default pool.
2184 * Initialize global zone kstats
2186 zone_kstat_create(&zone0
);
2189 * Initialize zone label.
2190 * mlp are initialized when tnzonecfg is loaded.
2192 zone0
.zone_slabel
= l_admin_low
;
2193 rw_init(&zone0
.zone_mlps
.mlpl_rwlock
, NULL
, RW_DEFAULT
, NULL
);
2194 label_hold(l_admin_low
);
2197 * Initialise the lock for the database structure used by mntfs.
2199 rw_init(&zone0
.zone_mntfs_db_lock
, NULL
, RW_DEFAULT
, NULL
);
2201 mutex_enter(&zonehash_lock
);
2202 zone_uniqid(&zone0
);
2203 ASSERT(zone0
.zone_uniqid
== GLOBAL_ZONEUNIQID
);
2205 zonehashbyid
= mod_hash_create_idhash("zone_by_id", zone_hash_size
,
2206 mod_hash_null_valdtor
);
2207 zonehashbyname
= mod_hash_create_strhash("zone_by_name",
2208 zone_hash_size
, mod_hash_null_valdtor
);
2210 * maintain zonehashbylabel only for labeled systems
2212 if (is_system_labeled())
2213 zonehashbylabel
= mod_hash_create_extended("zone_by_label",
2214 zone_hash_size
, mod_hash_null_keydtor
,
2215 mod_hash_null_valdtor
, hash_bylabel
, NULL
,
2216 hash_labelkey_cmp
, KM_SLEEP
);
2219 (void) mod_hash_insert(zonehashbyid
, (mod_hash_key_t
)GLOBAL_ZONEID
,
2220 (mod_hash_val_t
)&zone0
);
2221 (void) mod_hash_insert(zonehashbyname
, (mod_hash_key_t
)zone0
.zone_name
,
2222 (mod_hash_val_t
)&zone0
);
2223 if (is_system_labeled()) {
2224 zone0
.zone_flags
|= ZF_HASHED_LABEL
;
2225 (void) mod_hash_insert(zonehashbylabel
,
2226 (mod_hash_key_t
)zone0
.zone_slabel
, (mod_hash_val_t
)&zone0
);
2228 mutex_exit(&zonehash_lock
);
2231 * We avoid setting zone_kcred until now, since kcred is initialized
2232 * sometime after zone_zsd_init() and before zone_init().
2234 zone0
.zone_kcred
= kcred
;
2236 * The global zone is fully initialized (except for zone_rootvp which
2237 * will be set when the root filesystem is mounted).
2239 global_zone
= &zone0
;
2242 * Setup an event channel to send zone status change notifications on
2244 res
= sysevent_evc_bind(ZONE_EVENT_CHANNEL
, &zone_event_chan
,
2248 panic("Sysevent_evc_bind failed during zone setup.\n");
2253 zone_free(zone_t
*zone
)
2255 ASSERT(zone
!= global_zone
);
2256 ASSERT(zone
->zone_ntasks
== 0);
2257 ASSERT(zone
->zone_nlwps
== 0);
2258 ASSERT(zone
->zone_nprocs
== 0);
2259 ASSERT(zone
->zone_cred_ref
== 0);
2260 ASSERT(zone
->zone_kcred
== NULL
);
2261 ASSERT(zone_status_get(zone
) == ZONE_IS_DEAD
||
2262 zone_status_get(zone
) == ZONE_IS_UNINITIALIZED
);
2263 ASSERT(list_is_empty(&zone
->zone_ref_list
));
2266 * Remove any zone caps.
2268 cpucaps_zone_remove(zone
);
2270 ASSERT(zone
->zone_cpucap
== NULL
);
2272 /* remove from deathrow list */
2273 if (zone_status_get(zone
) == ZONE_IS_DEAD
) {
2274 ASSERT(zone
->zone_ref
== 0);
2275 mutex_enter(&zone_deathrow_lock
);
2276 list_remove(&zone_deathrow
, zone
);
2277 mutex_exit(&zone_deathrow_lock
);
2280 list_destroy(&zone
->zone_ref_list
);
2281 zone_free_zsd(zone
);
2282 zone_free_datasets(zone
);
2283 list_destroy(&zone
->zone_dl_list
);
2285 if (zone
->zone_rootvp
!= NULL
)
2286 VN_RELE(zone
->zone_rootvp
);
2287 if (zone
->zone_rootpath
)
2288 kmem_free(zone
->zone_rootpath
, zone
->zone_rootpathlen
);
2289 if (zone
->zone_name
!= NULL
)
2290 kmem_free(zone
->zone_name
, ZONENAME_MAX
);
2291 if (zone
->zone_slabel
!= NULL
)
2292 label_rele(zone
->zone_slabel
);
2293 if (zone
->zone_nodename
!= NULL
)
2294 kmem_free(zone
->zone_nodename
, _SYS_NMLN
);
2295 if (zone
->zone_domain
!= NULL
)
2296 kmem_free(zone
->zone_domain
, _SYS_NMLN
);
2297 if (zone
->zone_privset
!= NULL
)
2298 kmem_free(zone
->zone_privset
, sizeof (priv_set_t
));
2299 if (zone
->zone_rctls
!= NULL
)
2300 rctl_set_free(zone
->zone_rctls
);
2301 if (zone
->zone_bootargs
!= NULL
)
2302 strfree(zone
->zone_bootargs
);
2303 if (zone
->zone_initname
!= NULL
)
2304 strfree(zone
->zone_initname
);
2305 if (zone
->zone_fs_allowed
!= NULL
)
2306 strfree(zone
->zone_fs_allowed
);
2307 if (zone
->zone_pfexecd
!= NULL
)
2308 klpd_freelist(&zone
->zone_pfexecd
);
2309 id_free(zoneid_space
, zone
->zone_id
);
2310 mutex_destroy(&zone
->zone_lock
);
2311 cv_destroy(&zone
->zone_cv
);
2312 rw_destroy(&zone
->zone_mlps
.mlpl_rwlock
);
2313 rw_destroy(&zone
->zone_mntfs_db_lock
);
2314 kmem_free(zone
, sizeof (zone_t
));
2318 * See block comment at the top of this file for information about zone
2322 * Convenience function for setting zone status.
2325 zone_status_set(zone_t
*zone
, zone_status_t status
)
2328 nvlist_t
*nvl
= NULL
;
2329 ASSERT(MUTEX_HELD(&zone_status_lock
));
2330 ASSERT(status
> ZONE_MIN_STATE
&& status
<= ZONE_MAX_STATE
&&
2331 status
>= zone_status_get(zone
));
2333 if (nvlist_alloc(&nvl
, NV_UNIQUE_NAME
, KM_SLEEP
) ||
2334 nvlist_add_string(nvl
, ZONE_CB_NAME
, zone
->zone_name
) ||
2335 nvlist_add_string(nvl
, ZONE_CB_NEWSTATE
,
2336 zone_status_table
[status
]) ||
2337 nvlist_add_string(nvl
, ZONE_CB_OLDSTATE
,
2338 zone_status_table
[zone
->zone_status
]) ||
2339 nvlist_add_int32(nvl
, ZONE_CB_ZONEID
, zone
->zone_id
) ||
2340 nvlist_add_uint64(nvl
, ZONE_CB_TIMESTAMP
, (uint64_t)gethrtime()) ||
2341 sysevent_evc_publish(zone_event_chan
, ZONE_EVENT_STATUS_CLASS
,
2342 ZONE_EVENT_STATUS_SUBCLASS
, "sun.com", "kernel", nvl
, EVCH_SLEEP
)) {
2345 "Failed to allocate and send zone state change event.\n");
2350 zone
->zone_status
= status
;
2352 cv_broadcast(&zone
->zone_cv
);
2356 * Public function to retrieve the zone status. The zone status may
2357 * change after it is retrieved.
2360 zone_status_get(zone_t
*zone
)
2362 return (zone
->zone_status
);
2366 zone_set_bootargs(zone_t
*zone
, const char *zone_bootargs
)
2368 char *buf
= kmem_zalloc(BOOTARGS_MAX
, KM_SLEEP
);
2371 ASSERT(zone
!= global_zone
);
2372 if ((err
= copyinstr(zone_bootargs
, buf
, BOOTARGS_MAX
, NULL
)) != 0)
2373 goto done
; /* EFAULT or ENAMETOOLONG */
2375 if (zone
->zone_bootargs
!= NULL
)
2376 strfree(zone
->zone_bootargs
);
2378 zone
->zone_bootargs
= strdup(buf
);
2381 kmem_free(buf
, BOOTARGS_MAX
);
2386 zone_set_brand(zone_t
*zone
, const char *brand
)
2388 struct brand_attr
*attrp
;
2391 attrp
= kmem_alloc(sizeof (struct brand_attr
), KM_SLEEP
);
2392 if (copyin(brand
, attrp
, sizeof (struct brand_attr
)) != 0) {
2393 kmem_free(attrp
, sizeof (struct brand_attr
));
2397 bp
= brand_register_zone(attrp
);
2398 kmem_free(attrp
, sizeof (struct brand_attr
));
2403 * This is the only place where a zone can change it's brand.
2404 * We already need to hold zone_status_lock to check the zone
2405 * status, so we'll just use that lock to serialize zone
2406 * branding requests as well.
2408 mutex_enter(&zone_status_lock
);
2410 /* Re-Branding is not allowed and the zone can't be booted yet */
2411 if ((ZONE_IS_BRANDED(zone
)) ||
2412 (zone_status_get(zone
) >= ZONE_IS_BOOTING
)) {
2413 mutex_exit(&zone_status_lock
);
2414 brand_unregister_zone(bp
);
2418 /* set up the brand specific data */
2419 zone
->zone_brand
= bp
;
2420 ZBROP(zone
)->b_init_brand_data(zone
);
2422 mutex_exit(&zone_status_lock
);
2427 zone_set_fs_allowed(zone_t
*zone
, const char *zone_fs_allowed
)
2429 char *buf
= kmem_zalloc(ZONE_FS_ALLOWED_MAX
, KM_SLEEP
);
2432 ASSERT(zone
!= global_zone
);
2433 if ((err
= copyinstr(zone_fs_allowed
, buf
,
2434 ZONE_FS_ALLOWED_MAX
, NULL
)) != 0)
2437 if (zone
->zone_fs_allowed
!= NULL
)
2438 strfree(zone
->zone_fs_allowed
);
2440 zone
->zone_fs_allowed
= strdup(buf
);
2443 kmem_free(buf
, ZONE_FS_ALLOWED_MAX
);
2448 zone_set_initname(zone_t
*zone
, const char *zone_initname
)
2450 char initname
[INITNAME_SZ
];
2454 ASSERT(zone
!= global_zone
);
2455 if ((err
= copyinstr(zone_initname
, initname
, INITNAME_SZ
, &len
)) != 0)
2456 return (err
); /* EFAULT or ENAMETOOLONG */
2458 if (zone
->zone_initname
!= NULL
)
2459 strfree(zone
->zone_initname
);
2461 zone
->zone_initname
= kmem_alloc(strlen(initname
) + 1, KM_SLEEP
);
2462 (void) strcpy(zone
->zone_initname
, initname
);
2467 zone_set_phys_mcap(zone_t
*zone
, const uint64_t *zone_mcap
)
2472 if ((err
= copyin(zone_mcap
, &mcap
, sizeof (uint64_t))) == 0)
2473 zone
->zone_phys_mcap
= mcap
;
2479 zone_set_sched_class(zone_t
*zone
, const char *new_class
)
2481 char sched_class
[PC_CLNMSZ
];
2485 ASSERT(zone
!= global_zone
);
2486 if ((err
= copyinstr(new_class
, sched_class
, PC_CLNMSZ
, NULL
)) != 0)
2487 return (err
); /* EFAULT or ENAMETOOLONG */
2489 if (getcid(sched_class
, &classid
) != 0 || CLASS_KERNEL(classid
))
2490 return (set_errno(EINVAL
));
2491 zone
->zone_defaultcid
= classid
;
2492 ASSERT(zone
->zone_defaultcid
> 0 &&
2493 zone
->zone_defaultcid
< loaded_classes
);
2499 * Block indefinitely waiting for (zone_status >= status)
2502 zone_status_wait(zone_t
*zone
, zone_status_t status
)
2504 ASSERT(status
> ZONE_MIN_STATE
&& status
<= ZONE_MAX_STATE
);
2506 mutex_enter(&zone_status_lock
);
2507 while (zone
->zone_status
< status
) {
2508 cv_wait(&zone
->zone_cv
, &zone_status_lock
);
2510 mutex_exit(&zone_status_lock
);
2514 * Private CPR-safe version of zone_status_wait().
2517 zone_status_wait_cpr(zone_t
*zone
, zone_status_t status
, char *str
)
2519 callb_cpr_t cprinfo
;
2521 ASSERT(status
> ZONE_MIN_STATE
&& status
<= ZONE_MAX_STATE
);
2523 CALLB_CPR_INIT(&cprinfo
, &zone_status_lock
, callb_generic_cpr
,
2525 mutex_enter(&zone_status_lock
);
2526 while (zone
->zone_status
< status
) {
2527 CALLB_CPR_SAFE_BEGIN(&cprinfo
);
2528 cv_wait(&zone
->zone_cv
, &zone_status_lock
);
2529 CALLB_CPR_SAFE_END(&cprinfo
, &zone_status_lock
);
2532 * zone_status_lock is implicitly released by the following.
2534 CALLB_CPR_EXIT(&cprinfo
);
2538 * Block until zone enters requested state or signal is received. Return (0)
2539 * if signaled, non-zero otherwise.
2542 zone_status_wait_sig(zone_t
*zone
, zone_status_t status
)
2544 ASSERT(status
> ZONE_MIN_STATE
&& status
<= ZONE_MAX_STATE
);
2546 mutex_enter(&zone_status_lock
);
2547 while (zone
->zone_status
< status
) {
2548 if (!cv_wait_sig(&zone
->zone_cv
, &zone_status_lock
)) {
2549 mutex_exit(&zone_status_lock
);
2553 mutex_exit(&zone_status_lock
);
2558 * Block until the zone enters the requested state or the timeout expires,
2559 * whichever happens first. Return (-1) if operation timed out, time remaining
2563 zone_status_timedwait(zone_t
*zone
, clock_t tim
, zone_status_t status
)
2565 clock_t timeleft
= 0;
2567 ASSERT(status
> ZONE_MIN_STATE
&& status
<= ZONE_MAX_STATE
);
2569 mutex_enter(&zone_status_lock
);
2570 while (zone
->zone_status
< status
&& timeleft
!= -1) {
2571 timeleft
= cv_timedwait(&zone
->zone_cv
, &zone_status_lock
, tim
);
2573 mutex_exit(&zone_status_lock
);
2578 * Block until the zone enters the requested state, the current process is
2579 * signaled, or the timeout expires, whichever happens first. Return (-1) if
2580 * operation timed out, 0 if signaled, time remaining otherwise.
2583 zone_status_timedwait_sig(zone_t
*zone
, clock_t tim
, zone_status_t status
)
2585 clock_t timeleft
= tim
- ddi_get_lbolt();
2587 ASSERT(status
> ZONE_MIN_STATE
&& status
<= ZONE_MAX_STATE
);
2589 mutex_enter(&zone_status_lock
);
2590 while (zone
->zone_status
< status
) {
2591 timeleft
= cv_timedwait_sig(&zone
->zone_cv
, &zone_status_lock
,
2596 mutex_exit(&zone_status_lock
);
2601 * Zones have two reference counts: one for references from credential
2602 * structures (zone_cred_ref), and one (zone_ref) for everything else.
2603 * This is so we can allow a zone to be rebooted while there are still
2604 * outstanding cred references, since certain drivers cache dblks (which
2605 * implicitly results in cached creds). We wait for zone_ref to drop to
2606 * 0 (actually 1), but not zone_cred_ref. The zone structure itself is
2607 * later freed when the zone_cred_ref drops to 0, though nothing other
2608 * than the zone id and privilege set should be accessed once the zone
2611 * A debugging flag, zone_wait_for_cred, can be set to a non-zero value
2612 * to force halt/reboot to block waiting for the zone_cred_ref to drop
2613 * to 0. This can be useful to flush out other sources of cached creds
2614 * that may be less innocuous than the driver case.
2616 * Zones also provide a tracked reference counting mechanism in which zone
2617 * references are represented by "crumbs" (zone_ref structures). Crumbs help
2618 * debuggers determine the sources of leaked zone references. See
2619 * zone_hold_ref() and zone_rele_ref() below for more information.
2622 int zone_wait_for_cred
= 0;
2625 zone_hold_locked(zone_t
*z
)
2627 ASSERT(MUTEX_HELD(&z
->zone_lock
));
2629 ASSERT(z
->zone_ref
!= 0);
2633 * Increment the specified zone's reference count. The zone's zone_t structure
2634 * will not be freed as long as the zone's reference count is nonzero.
2635 * Decrement the zone's reference count via zone_rele().
2637 * NOTE: This function should only be used to hold zones for short periods of
2638 * time. Use zone_hold_ref() if the zone must be held for a long time.
2641 zone_hold(zone_t
*z
)
2643 mutex_enter(&z
->zone_lock
);
2644 zone_hold_locked(z
);
2645 mutex_exit(&z
->zone_lock
);
2649 * If the non-cred ref count drops to 1 and either the cred ref count
2650 * is 0 or we aren't waiting for cred references, the zone is ready to
2653 #define ZONE_IS_UNREF(zone) ((zone)->zone_ref == 1 && \
2654 (!zone_wait_for_cred || (zone)->zone_cred_ref == 0))
2657 * Common zone reference release function invoked by zone_rele() and
2658 * zone_rele_ref(). If subsys is ZONE_REF_NUM_SUBSYS, then the specified
2659 * zone's subsystem-specific reference counters are not affected by the
2660 * release. If ref is not NULL, then the zone_ref_t to which it refers is
2661 * removed from the specified zone's reference list. ref must be non-NULL iff
2662 * subsys is not ZONE_REF_NUM_SUBSYS.
2665 zone_rele_common(zone_t
*z
, zone_ref_t
*ref
, zone_ref_subsys_t subsys
)
2669 mutex_enter(&z
->zone_lock
);
2670 ASSERT(z
->zone_ref
!= 0);
2672 if (subsys
!= ZONE_REF_NUM_SUBSYS
) {
2673 ASSERT(z
->zone_subsys_ref
[subsys
] != 0);
2674 z
->zone_subsys_ref
[subsys
]--;
2675 list_remove(&z
->zone_ref_list
, ref
);
2677 if (z
->zone_ref
== 0 && z
->zone_cred_ref
== 0) {
2678 /* no more refs, free the structure */
2679 mutex_exit(&z
->zone_lock
);
2683 /* signal zone_destroy so the zone can finish halting */
2684 wakeup
= (ZONE_IS_UNREF(z
) && zone_status_get(z
) >= ZONE_IS_DEAD
);
2685 mutex_exit(&z
->zone_lock
);
2689 * Grabbing zonehash_lock here effectively synchronizes with
2690 * zone_destroy() to avoid missed signals.
2692 mutex_enter(&zonehash_lock
);
2693 cv_broadcast(&zone_destroy_cv
);
2694 mutex_exit(&zonehash_lock
);
2699 * Decrement the specified zone's reference count. The specified zone will
2700 * cease to exist after this function returns if the reference count drops to
2701 * zero. This function should be paired with zone_hold().
2704 zone_rele(zone_t
*z
)
2706 zone_rele_common(z
, NULL
, ZONE_REF_NUM_SUBSYS
);
2710 * Initialize a zone reference structure. This function must be invoked for
2711 * a reference structure before the structure is passed to zone_hold_ref().
2714 zone_init_ref(zone_ref_t
*ref
)
2716 ref
->zref_zone
= NULL
;
2717 list_link_init(&ref
->zref_linkage
);
2721 * Acquire a reference to zone z. The caller must specify the
2722 * zone_ref_subsys_t constant associated with its subsystem. The specified
2723 * zone_ref_t structure will represent a reference to the specified zone. Use
2724 * zone_rele_ref() to release the reference.
2726 * The referenced zone_t structure will not be freed as long as the zone_t's
2727 * zone_status field is not ZONE_IS_DEAD and the zone has outstanding
2730 * NOTE: The zone_ref_t structure must be initialized before it is used.
2731 * See zone_init_ref() above.
2734 zone_hold_ref(zone_t
*z
, zone_ref_t
*ref
, zone_ref_subsys_t subsys
)
2736 ASSERT(subsys
>= 0 && subsys
< ZONE_REF_NUM_SUBSYS
);
2739 * Prevent consumers from reusing a reference structure before
2742 VERIFY(ref
->zref_zone
== NULL
);
2745 mutex_enter(&z
->zone_lock
);
2746 zone_hold_locked(z
);
2747 z
->zone_subsys_ref
[subsys
]++;
2748 ASSERT(z
->zone_subsys_ref
[subsys
] != 0);
2749 list_insert_head(&z
->zone_ref_list
, ref
);
2750 mutex_exit(&z
->zone_lock
);
2754 * Release the zone reference represented by the specified zone_ref_t.
2755 * The reference is invalid after it's released; however, the zone_ref_t
2756 * structure can be reused without having to invoke zone_init_ref().
2757 * subsys should be the same value that was passed to zone_hold_ref()
2758 * when the reference was acquired.
2761 zone_rele_ref(zone_ref_t
*ref
, zone_ref_subsys_t subsys
)
2763 zone_rele_common(ref
->zref_zone
, ref
, subsys
);
2766 * Set the zone_ref_t's zref_zone field to NULL to generate panics
2767 * when consumers dereference the reference. This helps us catch
2768 * consumers who use released references. Furthermore, this lets
2769 * consumers reuse the zone_ref_t structure without having to
2770 * invoke zone_init_ref().
2772 ref
->zref_zone
= NULL
;
2776 zone_cred_hold(zone_t
*z
)
2778 mutex_enter(&z
->zone_lock
);
2780 ASSERT(z
->zone_cred_ref
!= 0);
2781 mutex_exit(&z
->zone_lock
);
2785 zone_cred_rele(zone_t
*z
)
2789 mutex_enter(&z
->zone_lock
);
2790 ASSERT(z
->zone_cred_ref
!= 0);
2792 if (z
->zone_ref
== 0 && z
->zone_cred_ref
== 0) {
2793 /* no more refs, free the structure */
2794 mutex_exit(&z
->zone_lock
);
2799 * If zone_destroy is waiting for the cred references to drain
2800 * out, and they have, signal it.
2802 wakeup
= (zone_wait_for_cred
&& ZONE_IS_UNREF(z
) &&
2803 zone_status_get(z
) >= ZONE_IS_DEAD
);
2804 mutex_exit(&z
->zone_lock
);
2808 * Grabbing zonehash_lock here effectively synchronizes with
2809 * zone_destroy() to avoid missed signals.
2811 mutex_enter(&zonehash_lock
);
2812 cv_broadcast(&zone_destroy_cv
);
2813 mutex_exit(&zonehash_lock
);
2818 zone_task_hold(zone_t
*z
)
2820 mutex_enter(&z
->zone_lock
);
2822 ASSERT(z
->zone_ntasks
!= 0);
2823 mutex_exit(&z
->zone_lock
);
2827 zone_task_rele(zone_t
*zone
)
2831 mutex_enter(&zone
->zone_lock
);
2832 ASSERT(zone
->zone_ntasks
!= 0);
2833 refcnt
= --zone
->zone_ntasks
;
2834 if (refcnt
> 1) { /* Common case */
2835 mutex_exit(&zone
->zone_lock
);
2838 zone_hold_locked(zone
); /* so we can use the zone_t later */
2839 mutex_exit(&zone
->zone_lock
);
2842 * See if the zone is shutting down.
2844 mutex_enter(&zone_status_lock
);
2845 if (zone_status_get(zone
) != ZONE_IS_SHUTTING_DOWN
) {
2850 * Make sure the ntasks didn't change since we
2851 * dropped zone_lock.
2853 mutex_enter(&zone
->zone_lock
);
2854 if (refcnt
!= zone
->zone_ntasks
) {
2855 mutex_exit(&zone
->zone_lock
);
2858 mutex_exit(&zone
->zone_lock
);
2861 * No more user processes in the zone. The zone is empty.
2863 zone_status_set(zone
, ZONE_IS_EMPTY
);
2867 ASSERT(refcnt
== 0);
2869 * zsched has exited; the zone is dead.
2871 zone
->zone_zsched
= NULL
; /* paranoia */
2872 mutex_enter(&zone_status_lock
);
2873 zone_status_set(zone
, ZONE_IS_DEAD
);
2875 mutex_exit(&zone_status_lock
);
2882 return (curproc
->p_zone
->zone_id
);
2886 * Internal versions of zone_find_by_*(). These don't zone_hold() or
2887 * check the validity of a zone's state.
2890 zone_find_all_by_id(zoneid_t zoneid
)
2893 zone_t
*zone
= NULL
;
2895 ASSERT(MUTEX_HELD(&zonehash_lock
));
2897 if (mod_hash_find(zonehashbyid
,
2898 (mod_hash_key_t
)(uintptr_t)zoneid
, &hv
) == 0)
2899 zone
= (zone_t
*)hv
;
2904 zone_find_all_by_label(const ts_label_t
*label
)
2907 zone_t
*zone
= NULL
;
2909 ASSERT(MUTEX_HELD(&zonehash_lock
));
2912 * zonehashbylabel is not maintained for unlabeled systems
2914 if (!is_system_labeled())
2916 if (mod_hash_find(zonehashbylabel
, (mod_hash_key_t
)label
, &hv
) == 0)
2917 zone
= (zone_t
*)hv
;
2922 zone_find_all_by_name(char *name
)
2925 zone_t
*zone
= NULL
;
2927 ASSERT(MUTEX_HELD(&zonehash_lock
));
2929 if (mod_hash_find(zonehashbyname
, (mod_hash_key_t
)name
, &hv
) == 0)
2930 zone
= (zone_t
*)hv
;
2935 * Public interface for looking up a zone by zoneid. Only returns the zone if
2936 * it is fully initialized, and has not yet begun the zone_destroy() sequence.
2937 * Caller must call zone_rele() once it is done with the zone.
2939 * The zone may begin the zone_destroy() sequence immediately after this
2940 * function returns, but may be safely used until zone_rele() is called.
2943 zone_find_by_id(zoneid_t zoneid
)
2946 zone_status_t status
;
2948 mutex_enter(&zonehash_lock
);
2949 if ((zone
= zone_find_all_by_id(zoneid
)) == NULL
) {
2950 mutex_exit(&zonehash_lock
);
2953 status
= zone_status_get(zone
);
2954 if (status
< ZONE_IS_READY
|| status
> ZONE_IS_DOWN
) {
2956 * For all practical purposes the zone doesn't exist.
2958 mutex_exit(&zonehash_lock
);
2962 mutex_exit(&zonehash_lock
);
2967 * Similar to zone_find_by_id, but using zone label as the key.
2970 zone_find_by_label(const ts_label_t
*label
)
2973 zone_status_t status
;
2975 mutex_enter(&zonehash_lock
);
2976 if ((zone
= zone_find_all_by_label(label
)) == NULL
) {
2977 mutex_exit(&zonehash_lock
);
2981 status
= zone_status_get(zone
);
2982 if (status
> ZONE_IS_DOWN
) {
2984 * For all practical purposes the zone doesn't exist.
2986 mutex_exit(&zonehash_lock
);
2990 mutex_exit(&zonehash_lock
);
2995 * Similar to zone_find_by_id, but using zone name as the key.
2998 zone_find_by_name(char *name
)
3001 zone_status_t status
;
3003 mutex_enter(&zonehash_lock
);
3004 if ((zone
= zone_find_all_by_name(name
)) == NULL
) {
3005 mutex_exit(&zonehash_lock
);
3008 status
= zone_status_get(zone
);
3009 if (status
< ZONE_IS_READY
|| status
> ZONE_IS_DOWN
) {
3011 * For all practical purposes the zone doesn't exist.
3013 mutex_exit(&zonehash_lock
);
3017 mutex_exit(&zonehash_lock
);
3022 * Similar to zone_find_by_id(), using the path as a key. For instance,
3023 * if there is a zone "foo" rooted at /foo/root, and the path argument
3024 * is "/foo/root/proc", it will return the held zone_t corresponding to
3027 * zone_find_by_path() always returns a non-NULL value, since at the
3028 * very least every path will be contained in the global zone.
3030 * As with the other zone_find_by_*() functions, the caller is
3031 * responsible for zone_rele()ing the return value of this function.
3034 zone_find_by_path(const char *path
)
3037 zone_t
*zret
= NULL
;
3038 zone_status_t status
;
3042 * Call from rootconf().
3044 zone_hold(global_zone
);
3045 return (global_zone
);
3047 ASSERT(*path
== '/');
3048 mutex_enter(&zonehash_lock
);
3049 for (zone
= list_head(&zone_active
); zone
!= NULL
;
3050 zone
= list_next(&zone_active
, zone
)) {
3051 if (ZONE_PATH_VISIBLE(path
, zone
))
3054 ASSERT(zret
!= NULL
);
3055 status
= zone_status_get(zret
);
3056 if (status
< ZONE_IS_READY
|| status
> ZONE_IS_DOWN
) {
3058 * Zone practically doesn't exist.
3063 mutex_exit(&zonehash_lock
);
3068 * Public interface for updating per-zone load averages. Called once per
3071 * Based on loadavg_update(), genloadavg() and calcloadavg() from clock.c.
3074 zone_loadavg_update()
3077 zone_status_t status
;
3078 struct loadavg_s
*lavg
;
3079 hrtime_t zone_total
;
3083 static int64_t f
[3] = { 135, 27, 9 };
3086 mutex_enter(&zonehash_lock
);
3087 for (zp
= list_head(&zone_active
); zp
!= NULL
;
3088 zp
= list_next(&zone_active
, zp
)) {
3089 mutex_enter(&zp
->zone_lock
);
3091 /* Skip zones that are on the way down or not yet up */
3092 status
= zone_status_get(zp
);
3093 if (status
< ZONE_IS_READY
|| status
>= ZONE_IS_DOWN
) {
3094 /* For all practical purposes the zone doesn't exist. */
3095 mutex_exit(&zp
->zone_lock
);
3100 * Update the 10 second moving average data in zone_loadavg.
3102 lavg
= &zp
->zone_loadavg
;
3104 zone_total
= zp
->zone_utime
+ zp
->zone_stime
+ zp
->zone_wtime
;
3105 scalehrtime(&zone_total
);
3107 /* The zone_total should always be increasing. */
3108 lavg
->lg_loads
[lavg
->lg_cur
] = (zone_total
> lavg
->lg_total
) ?
3109 zone_total
- lavg
->lg_total
: 0;
3110 lavg
->lg_cur
= (lavg
->lg_cur
+ 1) % S_LOADAVG_SZ
;
3111 /* lg_total holds the prev. 1 sec. total */
3112 lavg
->lg_total
= zone_total
;
3115 * To simplify the calculation, we don't calculate the load avg.
3116 * until the zone has been up for at least 10 seconds and our
3117 * moving average is thus full.
3119 if ((lavg
->lg_len
+ 1) < S_LOADAVG_SZ
) {
3121 mutex_exit(&zp
->zone_lock
);
3125 /* Now calculate the 1min, 5min, 15 min load avg. */
3127 for (i
= 0; i
< S_LOADAVG_SZ
; i
++)
3128 hr_avg
+= lavg
->lg_loads
[i
];
3129 hr_avg
= hr_avg
/ S_LOADAVG_SZ
;
3130 nrun
= hr_avg
/ (NANOSEC
/ LGRP_LOADAVG_IN_THREAD_MAX
);
3132 /* Compute load avg. See comment in calcloadavg() */
3133 for (i
= 0; i
< 3; i
++) {
3134 q
= (zp
->zone_hp_avenrun
[i
] >> 16) << 7;
3135 r
= (zp
->zone_hp_avenrun
[i
] & 0xffff) << 7;
3136 zp
->zone_hp_avenrun
[i
] +=
3137 ((nrun
- q
) * f
[i
] - ((r
* f
[i
]) >> 16)) >> 4;
3139 /* avenrun[] can only hold 31 bits of load avg. */
3140 if (zp
->zone_hp_avenrun
[i
] <
3141 ((uint64_t)1<<(31+16-FSHIFT
)))
3142 zp
->zone_avenrun
[i
] = (int32_t)
3143 (zp
->zone_hp_avenrun
[i
] >> (16 - FSHIFT
));
3145 zp
->zone_avenrun
[i
] = 0x7fffffff;
3148 mutex_exit(&zp
->zone_lock
);
3150 mutex_exit(&zonehash_lock
);
3154 * Get the number of cpus visible to this zone. The system-wide global
3155 * 'ncpus' is returned if pools are disabled, the caller is in the
3156 * global zone, or a NULL zone argument is passed in.
3159 zone_ncpus_get(zone_t
*zone
)
3161 int myncpus
= zone
== NULL
? 0 : zone
->zone_ncpus
;
3163 return (myncpus
!= 0 ? myncpus
: ncpus
);
3167 * Get the number of online cpus visible to this zone. The system-wide
3168 * global 'ncpus_online' is returned if pools are disabled, the caller
3169 * is in the global zone, or a NULL zone argument is passed in.
3172 zone_ncpus_online_get(zone_t
*zone
)
3174 int myncpus_online
= zone
== NULL
? 0 : zone
->zone_ncpus_online
;
3176 return (myncpus_online
!= 0 ? myncpus_online
: ncpus_online
);
3180 * Return the pool to which the zone is currently bound.
3183 zone_pool_get(zone_t
*zone
)
3185 ASSERT(pool_lock_held());
3187 return (zone
->zone_pool
);
3191 * Set the zone's pool pointer and update the zone's visibility to match
3192 * the resources in the new pool.
3195 zone_pool_set(zone_t
*zone
, pool_t
*pool
)
3197 ASSERT(pool_lock_held());
3198 ASSERT(MUTEX_HELD(&cpu_lock
));
3200 zone
->zone_pool
= pool
;
3201 zone_pset_set(zone
, pool
->pool_pset
->pset_id
);
3205 * Return the cached value of the id of the processor set to which the
3206 * zone is currently bound. The value will be ZONE_PS_INVAL if the pools
3207 * facility is disabled.
3210 zone_pset_get(zone_t
*zone
)
3212 ASSERT(MUTEX_HELD(&cpu_lock
));
3214 return (zone
->zone_psetid
);
3218 * Set the cached value of the id of the processor set to which the zone
3219 * is currently bound. Also update the zone's visibility to match the
3220 * resources in the new processor set.
3223 zone_pset_set(zone_t
*zone
, psetid_t newpsetid
)
3227 ASSERT(MUTEX_HELD(&cpu_lock
));
3228 oldpsetid
= zone_pset_get(zone
);
3230 if (oldpsetid
== newpsetid
)
3233 * Global zone sees all.
3235 if (zone
!= global_zone
) {
3236 zone
->zone_psetid
= newpsetid
;
3237 if (newpsetid
!= ZONE_PS_INVAL
)
3238 pool_pset_visibility_add(newpsetid
, zone
);
3239 if (oldpsetid
!= ZONE_PS_INVAL
)
3240 pool_pset_visibility_remove(oldpsetid
, zone
);
3243 * Disabling pools, so we should start using the global values
3244 * for ncpus and ncpus_online.
3246 if (newpsetid
== ZONE_PS_INVAL
) {
3247 zone
->zone_ncpus
= 0;
3248 zone
->zone_ncpus_online
= 0;
3253 * Walk the list of active zones and issue the provided callback for
3256 * Caller must not be holding any locks that may be acquired under
3257 * zonehash_lock. See comment at the beginning of the file for a list of
3258 * common locks and their interactions with zones.
3261 zone_walk(int (*cb
)(zone_t
*, void *), void *data
)
3265 zone_status_t status
;
3267 mutex_enter(&zonehash_lock
);
3268 for (zone
= list_head(&zone_active
); zone
!= NULL
;
3269 zone
= list_next(&zone_active
, zone
)) {
3271 * Skip zones that shouldn't be externally visible.
3273 status
= zone_status_get(zone
);
3274 if (status
< ZONE_IS_READY
|| status
> ZONE_IS_DOWN
)
3277 * Bail immediately if any callback invocation returns a
3280 ret
= (*cb
)(zone
, data
);
3284 mutex_exit(&zonehash_lock
);
3289 zone_set_root(zone_t
*zone
, const char *upath
)
3295 struct pathname upn
, pn
;
3298 if ((error
= pn_get((char *)upath
, UIO_USERSPACE
, &upn
)) != 0)
3303 /* prevent infinite loop */
3306 if (--trycount
<= 0) {
3311 if ((error
= lookuppn(&upn
, &pn
, FOLLOW
, NULLVPP
, &vp
)) == 0) {
3313 * VOP_ACCESS() may cover 'vp' with a new
3314 * filesystem, if 'vp' is an autoFS vnode.
3315 * Get the new 'vp' if so.
3318 VOP_ACCESS(vp
, VEXEC
, 0, CRED(), NULL
)) == 0 &&
3320 (error
= traverse(&vp
)) == 0)) {
3321 pathlen
= pn
.pn_pathlen
+ 2;
3322 path
= kmem_alloc(pathlen
, KM_SLEEP
);
3323 (void) strncpy(path
, pn
.pn_path
,
3325 path
[pathlen
- 2] = '/';
3326 path
[pathlen
- 1] = '\0';
3335 if (error
!= ESTALE
)
3340 zone
->zone_rootvp
= vp
; /* we hold a reference to vp */
3341 zone
->zone_rootpath
= path
;
3342 zone
->zone_rootpathlen
= pathlen
;
3343 if (pathlen
> 5 && strcmp(path
+ pathlen
- 5, "/lu/") == 0)
3344 zone
->zone_flags
|= ZF_IS_SCRATCH
;
3353 #define isalnum(c) (((c) >= '0' && (c) <= '9') || \
3354 ((c) >= 'a' && (c) <= 'z') || \
3355 ((c) >= 'A' && (c) <= 'Z'))
3358 zone_set_name(zone_t
*zone
, const char *uname
)
3360 char *kname
= kmem_zalloc(ZONENAME_MAX
, KM_SLEEP
);
3364 if ((err
= copyinstr(uname
, kname
, ZONENAME_MAX
, &len
)) != 0) {
3365 kmem_free(kname
, ZONENAME_MAX
);
3366 return (err
); /* EFAULT or ENAMETOOLONG */
3369 /* must be less than ZONENAME_MAX */
3370 if (len
== ZONENAME_MAX
&& kname
[ZONENAME_MAX
- 1] != '\0') {
3371 kmem_free(kname
, ZONENAME_MAX
);
3376 * Name must start with an alphanumeric and must contain only
3377 * alphanumerics, '-', '_' and '.'.
3379 if (!isalnum(kname
[0])) {
3380 kmem_free(kname
, ZONENAME_MAX
);
3383 for (i
= 1; i
< len
- 1; i
++) {
3384 if (!isalnum(kname
[i
]) && kname
[i
] != '-' && kname
[i
] != '_' &&
3386 kmem_free(kname
, ZONENAME_MAX
);
3391 zone
->zone_name
= kname
;
3396 * Gets the 32-bit hostid of the specified zone as an unsigned int. If 'zonep'
3397 * is NULL or it points to a zone with no hostid emulation, then the machine's
3398 * hostid (i.e., the global zone's hostid) is returned. This function returns
3399 * zero if neither the zone nor the host machine (global zone) have hostids. It
3400 * returns HW_INVALID_HOSTID if the function attempts to return the machine's
3401 * hostid and the machine's hostid is invalid.
3404 zone_get_hostid(zone_t
*zonep
)
3406 unsigned long machine_hostid
;
3408 if (zonep
== NULL
|| zonep
->zone_hostid
== HW_INVALID_HOSTID
) {
3409 if (ddi_strtoul(hw_serial
, NULL
, 10, &machine_hostid
) != 0)
3410 return (HW_INVALID_HOSTID
);
3411 return ((uint32_t)machine_hostid
);
3413 return (zonep
->zone_hostid
);
3417 * Similar to thread_create(), but makes sure the thread is in the appropriate
3418 * zone's zsched process (curproc->p_zone->zone_zsched) before returning.
3431 zone_t
*zone
= curproc
->p_zone
;
3432 proc_t
*pp
= zone
->zone_zsched
;
3434 zone_hold(zone
); /* Reference to be dropped when thread exits */
3437 * No-one should be trying to create threads if the zone is shutting
3438 * down and there aren't any kernel threads around. See comment
3439 * in zthread_exit().
3441 ASSERT(!(zone
->zone_kthreads
== NULL
&&
3442 zone_status_get(zone
) >= ZONE_IS_EMPTY
));
3444 * Create a thread, but don't let it run until we've finished setting
3447 t
= thread_create(stk
, stksize
, proc
, arg
, len
, pp
, TS_STOPPED
, pri
);
3448 ASSERT(t
->t_forw
== NULL
);
3449 mutex_enter(&zone_status_lock
);
3450 if (zone
->zone_kthreads
== NULL
) {
3451 t
->t_forw
= t
->t_back
= t
;
3453 kthread_t
*tx
= zone
->zone_kthreads
;
3456 t
->t_back
= tx
->t_back
;
3457 tx
->t_back
->t_forw
= t
;
3460 zone
->zone_kthreads
= t
;
3461 mutex_exit(&zone_status_lock
);
3463 mutex_enter(&pp
->p_lock
);
3464 t
->t_proc_flag
|= TP_ZTHREAD
;
3465 project_rele(t
->t_proj
);
3466 t
->t_proj
= project_hold(pp
->p_task
->tk_proj
);
3469 * Setup complete, let it run.
3472 t
->t_schedflag
|= TS_ALLSTART
;
3476 mutex_exit(&pp
->p_lock
);
3482 * Similar to thread_exit(). Must be called by threads created via
3488 kthread_t
*t
= curthread
;
3489 proc_t
*pp
= curproc
;
3490 zone_t
*zone
= pp
->p_zone
;
3492 mutex_enter(&zone_status_lock
);
3498 mutex_enter(&pp
->p_lock
);
3499 t
->t_proc_flag
&= ~TP_ZTHREAD
;
3502 mutex_exit(&pp
->p_lock
);
3505 if (t
->t_back
== t
) {
3506 ASSERT(t
->t_forw
== t
);
3508 * If the zone is empty, once the thread count
3509 * goes to zero no further kernel threads can be
3510 * created. This is because if the creator is a process
3511 * in the zone, then it must have exited before the zone
3512 * state could be set to ZONE_IS_EMPTY.
3513 * Otherwise, if the creator is a kernel thread in the
3514 * zone, the thread count is non-zero.
3516 * This really means that non-zone kernel threads should
3517 * not create zone kernel threads.
3519 zone
->zone_kthreads
= NULL
;
3520 if (zone_status_get(zone
) == ZONE_IS_EMPTY
) {
3521 zone_status_set(zone
, ZONE_IS_DOWN
);
3523 * Remove any CPU caps on this zone.
3525 cpucaps_zone_remove(zone
);
3528 t
->t_forw
->t_back
= t
->t_back
;
3529 t
->t_back
->t_forw
= t
->t_forw
;
3530 if (zone
->zone_kthreads
== t
)
3531 zone
->zone_kthreads
= t
->t_forw
;
3533 mutex_exit(&zone_status_lock
);
3540 zone_chdir(vnode_t
*vp
, vnode_t
**vpp
, proc_t
*pp
)
3544 /* we're going to hold a reference here to the directory */
3547 /* update abs cwd/root path see c2/audit.c */
3549 audit_chdirec(vp
, vpp
);
3551 mutex_enter(&pp
->p_lock
);
3554 mutex_exit(&pp
->p_lock
);
3560 * Convert an rctl value represented by an nvlist_t into an rctl_val_t.
3563 nvlist2rctlval(nvlist_t
*nvl
, rctl_val_t
*rv
)
3565 nvpair_t
*nvp
= NULL
;
3566 boolean_t priv_set
= B_FALSE
;
3567 boolean_t limit_set
= B_FALSE
;
3568 boolean_t action_set
= B_FALSE
;
3570 while ((nvp
= nvlist_next_nvpair(nvl
, nvp
)) != NULL
) {
3574 name
= nvpair_name(nvp
);
3575 if (nvpair_type(nvp
) != DATA_TYPE_UINT64
)
3577 (void) nvpair_value_uint64(nvp
, &ui64
);
3578 if (strcmp(name
, "privilege") == 0) {
3580 * Currently only privileged values are allowed, but
3581 * this may change in the future.
3583 if (ui64
!= RCPRIV_PRIVILEGED
)
3585 rv
->rcv_privilege
= ui64
;
3587 } else if (strcmp(name
, "limit") == 0) {
3588 rv
->rcv_value
= ui64
;
3590 } else if (strcmp(name
, "action") == 0) {
3591 if (ui64
!= RCTL_LOCAL_NOACTION
&&
3592 ui64
!= RCTL_LOCAL_DENY
)
3594 rv
->rcv_flagaction
= ui64
;
3595 action_set
= B_TRUE
;
3601 if (!(priv_set
&& limit_set
&& action_set
))
3603 rv
->rcv_action_signal
= 0;
3604 rv
->rcv_action_recipient
= NULL
;
3605 rv
->rcv_action_recip_pid
= -1;
3606 rv
->rcv_firing_time
= 0;
3612 * Non-global zone version of start_init.
3615 zone_start_init(void)
3617 proc_t
*p
= ttoproc(curthread
);
3618 zone_t
*z
= p
->p_zone
;
3620 ASSERT(!INGLOBALZONE(curproc
));
3623 * For all purposes (ZONE_ATTR_INITPID and restart_init),
3624 * storing just the pid of init is sufficient.
3626 z
->zone_proc_initpid
= p
->p_pid
;
3629 * We maintain zone_boot_err so that we can return the cause of the
3630 * failure back to the caller of the zone_boot syscall.
3632 p
->p_zone
->zone_boot_err
= start_init_common();
3635 * We will prevent booting zones from becoming running zones if the
3636 * global zone is shutting down.
3638 mutex_enter(&zone_status_lock
);
3639 if (z
->zone_boot_err
!= 0 || zone_status_get(global_zone
) >=
3640 ZONE_IS_SHUTTING_DOWN
) {
3642 * Make sure we are still in the booting state-- we could have
3643 * raced and already be shutting down, or even further along.
3645 if (zone_status_get(z
) == ZONE_IS_BOOTING
) {
3646 zone_status_set(z
, ZONE_IS_SHUTTING_DOWN
);
3648 mutex_exit(&zone_status_lock
);
3649 /* It's gone bad, dispose of the process */
3650 if (proc_exit(CLD_EXITED
, z
->zone_boot_err
) != 0) {
3651 mutex_enter(&p
->p_lock
);
3652 ASSERT(p
->p_flag
& SEXITLWPS
);
3656 if (zone_status_get(z
) == ZONE_IS_BOOTING
)
3657 zone_status_set(z
, ZONE_IS_RUNNING
);
3658 mutex_exit(&zone_status_lock
);
3659 /* cause the process to return to userland. */
3670 * Per-zone "sched" workalike. The similarity to "sched" doesn't have
3671 * anything to do with scheduling, but rather with the fact that
3672 * per-zone kernel threads are parented to zsched, just like regular
3673 * kernel threads are parented to sched (p0).
3675 * zsched is also responsible for launching init for the zone.
3680 struct zsched_arg
*za
= arg
;
3681 proc_t
*pp
= curproc
;
3682 proc_t
*initp
= proc_init
;
3683 zone_t
*zone
= za
->zone
;
3684 cred_t
*cr
, *oldcred
;
3686 rctl_alloc_gp_t
*gp
;
3687 contract_t
*ct
= NULL
;
3692 nvlist_t
*nvl
= za
->nvlist
;
3693 nvpair_t
*nvp
= NULL
;
3695 bcopy("zsched", PTOU(pp
)->u_psargs
, sizeof ("zsched"));
3696 bcopy("zsched", PTOU(pp
)->u_comm
, sizeof ("zsched"));
3697 PTOU(pp
)->u_argc
= 0;
3698 PTOU(pp
)->u_argv
= NULL
;
3699 PTOU(pp
)->u_envp
= NULL
;
3700 closeall(P_FINFO(pp
));
3703 * We are this zone's "zsched" process. As the zone isn't generally
3704 * visible yet we don't need to grab any locks before initializing its
3705 * zone_proc pointer.
3707 zone_hold(zone
); /* this hold is released by zone_destroy() */
3708 zone
->zone_zsched
= pp
;
3709 mutex_enter(&pp
->p_lock
);
3711 mutex_exit(&pp
->p_lock
);
3714 * Disassociate process from its 'parent'; parent ourselves to init
3715 * (pid 1) and change other values as needed.
3719 mutex_enter(&pidlock
);
3722 pp
->p_flag
|= SZONETOP
;
3724 pp
->p_parent
= initp
;
3725 pp
->p_psibling
= NULL
;
3727 initp
->p_child
->p_psibling
= pp
;
3728 pp
->p_sibling
= initp
->p_child
;
3729 initp
->p_child
= pp
;
3731 /* Decrement what newproc() incremented. */
3732 upcount_dec(crgetruid(CRED()), GLOBAL_ZONEID
);
3734 * Our credentials are about to become kcred-like, so we don't care
3735 * about the caller's ruid.
3737 upcount_inc(crgetruid(kcred
), zone
->zone_id
);
3738 mutex_exit(&pidlock
);
3741 * getting out of global zone, so decrement lwp and process counts
3743 pj
= pp
->p_task
->tk_proj
;
3744 mutex_enter(&global_zone
->zone_nlwps_lock
);
3745 pj
->kpj_nlwps
-= pp
->p_lwpcnt
;
3746 global_zone
->zone_nlwps
-= pp
->p_lwpcnt
;
3748 global_zone
->zone_nprocs
--;
3749 mutex_exit(&global_zone
->zone_nlwps_lock
);
3752 * Decrement locked memory counts on old zone and project.
3754 mutex_enter(&global_zone
->zone_mem_lock
);
3755 global_zone
->zone_locked_mem
-= pp
->p_locked_mem
;
3756 pj
->kpj_data
.kpd_locked_mem
-= pp
->p_locked_mem
;
3757 mutex_exit(&global_zone
->zone_mem_lock
);
3760 * Create and join a new task in project '0' of this zone.
3762 * We don't need to call holdlwps() since we know we're the only lwp in
3765 * task_join() returns with p_lock held.
3767 tk
= task_create(0, zone
);
3768 mutex_enter(&cpu_lock
);
3769 oldtk
= task_join(tk
, 0);
3771 pj
= pp
->p_task
->tk_proj
;
3773 mutex_enter(&zone
->zone_mem_lock
);
3774 zone
->zone_locked_mem
+= pp
->p_locked_mem
;
3775 pj
->kpj_data
.kpd_locked_mem
+= pp
->p_locked_mem
;
3776 mutex_exit(&zone
->zone_mem_lock
);
3779 * add lwp and process counts to zsched's zone, and increment
3780 * project's task and process count due to the task created in
3781 * the above task_create.
3783 mutex_enter(&zone
->zone_nlwps_lock
);
3784 pj
->kpj_nlwps
+= pp
->p_lwpcnt
;
3785 pj
->kpj_ntasks
+= 1;
3786 zone
->zone_nlwps
+= pp
->p_lwpcnt
;
3788 zone
->zone_nprocs
++;
3789 mutex_exit(&zone
->zone_nlwps_lock
);
3791 mutex_exit(&curproc
->p_lock
);
3792 mutex_exit(&cpu_lock
);
3796 * The process was created by a process in the global zone, hence the
3797 * credentials are wrong. We might as well have kcred-ish credentials.
3799 cr
= zone
->zone_kcred
;
3801 mutex_enter(&pp
->p_crlock
);
3802 oldcred
= pp
->p_cred
;
3804 mutex_exit(&pp
->p_crlock
);
3808 * Hold credentials again (for thread)
3813 * p_lwpcnt can't change since this is a kernel process.
3820 zone_chdir(zone
->zone_rootvp
, &PTOU(pp
)->u_cdir
, pp
);
3821 zone_chdir(zone
->zone_rootvp
, &PTOU(pp
)->u_rdir
, pp
);
3824 * Initialize zone's rctl set.
3826 set
= rctl_set_create();
3827 gp
= rctl_set_init_prealloc(RCENTITY_ZONE
);
3828 mutex_enter(&pp
->p_lock
);
3829 e
.rcep_p
.zone
= zone
;
3830 e
.rcep_t
= RCENTITY_ZONE
;
3831 zone
->zone_rctls
= rctl_set_init(RCENTITY_ZONE
, pp
, &e
, set
, gp
);
3832 mutex_exit(&pp
->p_lock
);
3833 rctl_prealloc_destroy(gp
);
3836 * Apply the rctls passed in to zone_create(). This is basically a list
3837 * assignment: all of the old values are removed and the new ones
3838 * inserted. That is, if an empty list is passed in, all values are
3841 while ((nvp
= nvlist_next_nvpair(nvl
, nvp
)) != NULL
) {
3842 rctl_dict_entry_t
*rde
;
3845 nvlist_t
**nvlarray
;
3847 int error
; /* For ASSERT()s */
3849 name
= nvpair_name(nvp
);
3850 hndl
= rctl_hndl_lookup(name
);
3852 rde
= rctl_dict_lookup_hndl(hndl
);
3853 ASSERT(rde
!= NULL
);
3855 for (; /* ever */; ) {
3858 mutex_enter(&pp
->p_lock
);
3859 error
= rctl_local_get(hndl
, NULL
, &oval
, pp
);
3860 mutex_exit(&pp
->p_lock
);
3861 ASSERT(error
== 0); /* Can't fail for RCTL_FIRST */
3862 ASSERT(oval
.rcv_privilege
!= RCPRIV_BASIC
);
3863 if (oval
.rcv_privilege
== RCPRIV_SYSTEM
)
3865 mutex_enter(&pp
->p_lock
);
3866 error
= rctl_local_delete(hndl
, &oval
, pp
);
3867 mutex_exit(&pp
->p_lock
);
3870 error
= nvpair_value_nvlist_array(nvp
, &nvlarray
, &nelem
);
3872 for (i
= 0; i
< nelem
; i
++) {
3875 nvalp
= kmem_cache_alloc(rctl_val_cache
, KM_SLEEP
);
3876 error
= nvlist2rctlval(nvlarray
[i
], nvalp
);
3879 * rctl_local_insert can fail if the value being
3880 * inserted is a duplicate; this is OK.
3882 mutex_enter(&pp
->p_lock
);
3883 if (rctl_local_insert(hndl
, nvalp
, pp
) != 0)
3884 kmem_cache_free(rctl_val_cache
, nvalp
);
3885 mutex_exit(&pp
->p_lock
);
3889 * Tell the world that we're done setting up.
3891 * At this point we want to set the zone status to ZONE_IS_INITIALIZED
3892 * and atomically set the zone's processor set visibility. Once
3893 * we drop pool_lock() this zone will automatically get updated
3894 * to reflect any future changes to the pools configuration.
3896 * Note that after we drop the locks below (zonehash_lock in
3897 * particular) other operations such as a zone_getattr call can
3898 * now proceed and observe the zone. That is the reason for doing a
3899 * state transition to the INITIALIZED state.
3902 mutex_enter(&cpu_lock
);
3903 mutex_enter(&zonehash_lock
);
3905 zone_zsd_configure(zone
);
3906 if (pool_state
== POOL_ENABLED
)
3907 zone_pset_set(zone
, pool_default
->pool_pset
->pset_id
);
3908 mutex_enter(&zone_status_lock
);
3909 ASSERT(zone_status_get(zone
) == ZONE_IS_UNINITIALIZED
);
3910 zone_status_set(zone
, ZONE_IS_INITIALIZED
);
3911 mutex_exit(&zone_status_lock
);
3912 mutex_exit(&zonehash_lock
);
3913 mutex_exit(&cpu_lock
);
3916 /* Now call the create callback for this key */
3917 zsd_apply_all_keys(zsd_apply_create
, zone
);
3919 /* The callbacks are complete. Mark ZONE_IS_READY */
3920 mutex_enter(&zone_status_lock
);
3921 ASSERT(zone_status_get(zone
) == ZONE_IS_INITIALIZED
);
3922 zone_status_set(zone
, ZONE_IS_READY
);
3923 mutex_exit(&zone_status_lock
);
3926 * Once we see the zone transition to the ZONE_IS_BOOTING state,
3927 * we launch init, and set the state to running.
3929 zone_status_wait_cpr(zone
, ZONE_IS_BOOTING
, "zsched");
3931 if (zone_status_get(zone
) == ZONE_IS_BOOTING
) {
3935 * Ok, this is a little complicated. We need to grab the
3936 * zone's pool's scheduling class ID; note that by now, we
3937 * are already bound to a pool if we need to be (zoneadmd
3938 * will have done that to us while we're in the READY
3939 * state). *But* the scheduling class for the zone's 'init'
3940 * must be explicitly passed to newproc, which doesn't
3941 * respect pool bindings.
3943 * We hold the pool_lock across the call to newproc() to
3944 * close the obvious race: the pool's scheduling class
3945 * could change before we manage to create the LWP with
3949 if (zone
->zone_defaultcid
> 0)
3950 cid
= zone
->zone_defaultcid
;
3952 cid
= pool_get_class(zone
->zone_pool
);
3957 * If this fails, zone_boot will ultimately fail. The
3958 * state of the zone will be set to SHUTTING_DOWN-- userland
3959 * will have to tear down the zone, and fail, or try again.
3961 if ((zone
->zone_boot_err
= newproc(zone_start_init
, NULL
, cid
,
3962 minclsyspri
- 1, &ct
, 0)) != 0) {
3963 mutex_enter(&zone_status_lock
);
3964 zone_status_set(zone
, ZONE_IS_SHUTTING_DOWN
);
3965 mutex_exit(&zone_status_lock
);
3967 zone
->zone_boot_time
= gethrestime_sec();
3974 * Wait for zone_destroy() to be called. This is what we spend
3975 * most of our life doing.
3977 zone_status_wait_cpr(zone
, ZONE_IS_DYING
, "zsched");
3981 * At this point the process contract should be empty.
3982 * (Though if it isn't, it's not the end of the world.)
3984 VERIFY(contract_abandon(ct
, curproc
, B_TRUE
) == 0);
3987 * Allow kcred to be freed when all referring processes
3988 * (including this one) go away. We can't just do this in
3989 * zone_free because we need to wait for the zone_cred_ref to
3990 * drop to 0 before calling zone_free, and the existence of
3991 * zone_kcred will prevent that. Thus, we call crfree here to
3992 * balance the crdup in zone_create. The crhold calls earlier
3993 * in zsched will be dropped when the thread and process exit.
3995 crfree(zone
->zone_kcred
);
3996 zone
->zone_kcred
= NULL
;
3998 exit(CLD_EXITED
, 0);
4002 * Helper function to determine if there are any submounts of the
4003 * provided path. Used to make sure the zone doesn't "inherit" any
4004 * mounts from before it is created.
4007 zone_mount_count(const char *rootpath
)
4011 size_t rootpathlen
= strlen(rootpath
);
4014 * Holding zonehash_lock prevents race conditions with
4015 * vfs_list_add()/vfs_list_remove() since we serialize with
4016 * zone_find_by_path().
4018 ASSERT(MUTEX_HELD(&zonehash_lock
));
4020 * The rootpath must end with a '/'
4022 ASSERT(rootpath
[rootpathlen
- 1] == '/');
4025 * This intentionally does not count the rootpath itself if that
4026 * happens to be a mount point.
4028 vfs_list_read_lock();
4031 if (strncmp(rootpath
, refstr_value(vfsp
->vfs_mntpt
),
4034 vfsp
= vfsp
->vfs_next
;
4035 } while (vfsp
!= rootvfs
);
4041 * Helper function to make sure that a zone created on 'rootpath'
4042 * wouldn't end up containing other zones' rootpaths.
4045 zone_is_nested(const char *rootpath
)
4048 size_t rootpathlen
= strlen(rootpath
);
4051 ASSERT(MUTEX_HELD(&zonehash_lock
));
4054 * zone_set_root() appended '/' and '\0' at the end of rootpath
4056 if ((rootpathlen
<= 3) && (rootpath
[0] == '/') &&
4057 (rootpath
[1] == '/') && (rootpath
[2] == '\0'))
4060 for (zone
= list_head(&zone_active
); zone
!= NULL
;
4061 zone
= list_next(&zone_active
, zone
)) {
4062 if (zone
== global_zone
)
4064 len
= strlen(zone
->zone_rootpath
);
4065 if (strncmp(rootpath
, zone
->zone_rootpath
,
4066 MIN(rootpathlen
, len
)) == 0)
4073 zone_set_privset(zone_t
*zone
, const priv_set_t
*zone_privs
,
4074 size_t zone_privssz
)
4078 if (zone_privssz
< sizeof (priv_set_t
))
4081 privs
= kmem_alloc(sizeof (priv_set_t
), KM_SLEEP
);
4083 if (copyin(zone_privs
, privs
, sizeof (priv_set_t
))) {
4084 kmem_free(privs
, sizeof (priv_set_t
));
4088 zone
->zone_privset
= privs
;
4093 * We make creative use of nvlists to pass in rctls from userland. The list is
4094 * a list of the following structures:
4096 * (name = rctl_name, value = nvpair_list_array)
4098 * Where each element of the nvpair_list_array is of the form:
4100 * [(name = "privilege", value = RCPRIV_PRIVILEGED),
4101 * (name = "limit", value = uint64_t),
4102 * (name = "action", value = (RCTL_LOCAL_NOACTION || RCTL_LOCAL_DENY))]
4105 parse_rctls(caddr_t ubuf
, size_t buflen
, nvlist_t
**nvlp
)
4107 nvpair_t
*nvp
= NULL
;
4108 nvlist_t
*nvl
= NULL
;
4118 if ((kbuf
= kmem_alloc(buflen
, KM_NOSLEEP
)) == NULL
)
4120 if (copyin(ubuf
, kbuf
, buflen
)) {
4124 if (nvlist_unpack(kbuf
, buflen
, &nvl
, KM_SLEEP
) != 0) {
4126 * nvl may have been allocated/free'd, but the value set to
4127 * non-NULL, so we reset it here.
4133 while ((nvp
= nvlist_next_nvpair(nvl
, nvp
)) != NULL
) {
4134 rctl_dict_entry_t
*rde
;
4136 nvlist_t
**nvlarray
;
4141 name
= nvpair_name(nvp
);
4142 if (strncmp(nvpair_name(nvp
), "zone.", sizeof ("zone.") - 1)
4143 != 0 || nvpair_type(nvp
) != DATA_TYPE_NVLIST_ARRAY
) {
4146 if ((hndl
= rctl_hndl_lookup(name
)) == -1) {
4149 rde
= rctl_dict_lookup_hndl(hndl
);
4150 error
= nvpair_value_nvlist_array(nvp
, &nvlarray
, &nelem
);
4152 for (i
= 0; i
< nelem
; i
++) {
4153 if (error
= nvlist2rctlval(nvlarray
[i
], &rv
))
4156 if (rctl_invalid_value(rde
, &rv
)) {
4164 kmem_free(kbuf
, buflen
);
4165 if (error
&& nvl
!= NULL
)
4171 zone_create_error(int er_error
, int er_ext
, int *er_out
) {
4172 if (er_out
!= NULL
) {
4173 if (copyout(&er_ext
, er_out
, sizeof (int))) {
4174 return (set_errno(EFAULT
));
4177 return (set_errno(er_error
));
4181 zone_set_label(zone_t
*zone
, const bslabel_t
*lab
, uint32_t doi
)
4186 /* Get label from user */
4187 if (copyin(lab
, &blab
, sizeof (blab
)) != 0)
4189 tsl
= labelalloc(&blab
, doi
, KM_NOSLEEP
);
4193 zone
->zone_slabel
= tsl
;
4198 * Parses a comma-separated list of ZFS datasets into a per-zone dictionary.
4201 parse_zfs(zone_t
*zone
, caddr_t ubuf
, size_t buflen
)
4204 char *dataset
, *next
;
4208 if (ubuf
== NULL
|| buflen
== 0)
4211 if ((kbuf
= kmem_alloc(buflen
, KM_NOSLEEP
)) == NULL
)
4214 if (copyin(ubuf
, kbuf
, buflen
) != 0) {
4215 kmem_free(kbuf
, buflen
);
4219 dataset
= next
= kbuf
;
4221 zd
= kmem_alloc(sizeof (zone_dataset_t
), KM_SLEEP
);
4223 next
= strchr(dataset
, ',');
4226 len
= strlen(dataset
);
4228 len
= next
- dataset
;
4230 zd
->zd_dataset
= kmem_alloc(len
+ 1, KM_SLEEP
);
4231 bcopy(dataset
, zd
->zd_dataset
, len
);
4232 zd
->zd_dataset
[len
] = '\0';
4234 list_insert_head(&zone
->zone_datasets
, zd
);
4242 kmem_free(kbuf
, buflen
);
4247 * System call to create/initialize a new zone named 'zone_name', rooted
4248 * at 'zone_root', with a zone-wide privilege limit set of 'zone_privs',
4249 * and initialized with the zone-wide rctls described in 'rctlbuf', and
4250 * with labeling set by 'match', 'doi', and 'label'.
4252 * If extended error is non-null, we may use it to return more detailed
4253 * error information.
4256 zone_create(const char *zone_name
, const char *zone_root
,
4257 const priv_set_t
*zone_privs
, size_t zone_privssz
,
4258 caddr_t rctlbuf
, size_t rctlbufsz
,
4259 caddr_t zfsbuf
, size_t zfsbufsz
, int *extended_error
,
4260 int match
, uint32_t doi
, const bslabel_t
*label
,
4263 struct zsched_arg zarg
;
4264 nvlist_t
*rctls
= NULL
;
4265 proc_t
*pp
= curproc
;
4266 zone_t
*zone
, *ztmp
;
4272 boolean_t insert_label_hash
;
4274 if (secpolicy_zone_config(CRED()) != 0)
4275 return (set_errno(EPERM
));
4277 /* can't boot zone from within chroot environment */
4278 if (PTOU(pp
)->u_rdir
!= NULL
&& PTOU(pp
)->u_rdir
!= rootdir
)
4279 return (zone_create_error(ENOTSUP
, ZE_CHROOTED
,
4282 zone
= kmem_zalloc(sizeof (zone_t
), KM_SLEEP
);
4283 zoneid
= zone
->zone_id
= id_alloc(zoneid_space
);
4284 zone
->zone_status
= ZONE_IS_UNINITIALIZED
;
4285 zone
->zone_pool
= pool_default
;
4286 zone
->zone_pool_mod
= gethrtime();
4287 zone
->zone_psetid
= ZONE_PS_INVAL
;
4288 zone
->zone_ncpus
= 0;
4289 zone
->zone_ncpus_online
= 0;
4290 zone
->zone_restart_init
= B_TRUE
;
4291 zone
->zone_brand
= &native_brand
;
4292 zone
->zone_initname
= NULL
;
4293 mutex_init(&zone
->zone_lock
, NULL
, MUTEX_DEFAULT
, NULL
);
4294 mutex_init(&zone
->zone_nlwps_lock
, NULL
, MUTEX_DEFAULT
, NULL
);
4295 mutex_init(&zone
->zone_mem_lock
, NULL
, MUTEX_DEFAULT
, NULL
);
4296 cv_init(&zone
->zone_cv
, NULL
, CV_DEFAULT
, NULL
);
4297 list_create(&zone
->zone_ref_list
, sizeof (zone_ref_t
),
4298 offsetof(zone_ref_t
, zref_linkage
));
4299 list_create(&zone
->zone_zsd
, sizeof (struct zsd_entry
),
4300 offsetof(struct zsd_entry
, zsd_linkage
));
4301 list_create(&zone
->zone_datasets
, sizeof (zone_dataset_t
),
4302 offsetof(zone_dataset_t
, zd_linkage
));
4303 list_create(&zone
->zone_dl_list
, sizeof (zone_dl_t
),
4304 offsetof(zone_dl_t
, zdl_linkage
));
4305 rw_init(&zone
->zone_mlps
.mlpl_rwlock
, NULL
, RW_DEFAULT
, NULL
);
4306 rw_init(&zone
->zone_mntfs_db_lock
, NULL
, RW_DEFAULT
, NULL
);
4308 if (flags
& ZCF_NET_EXCL
) {
4309 zone
->zone_flags
|= ZF_NET_EXCL
;
4312 if ((error
= zone_set_name(zone
, zone_name
)) != 0) {
4314 return (zone_create_error(error
, 0, extended_error
));
4317 if ((error
= zone_set_root(zone
, zone_root
)) != 0) {
4319 return (zone_create_error(error
, 0, extended_error
));
4321 if ((error
= zone_set_privset(zone
, zone_privs
, zone_privssz
)) != 0) {
4323 return (zone_create_error(error
, 0, extended_error
));
4326 /* initialize node name to be the same as zone name */
4327 zone
->zone_nodename
= kmem_alloc(_SYS_NMLN
, KM_SLEEP
);
4328 (void) strncpy(zone
->zone_nodename
, zone
->zone_name
, _SYS_NMLN
);
4329 zone
->zone_nodename
[_SYS_NMLN
- 1] = '\0';
4331 zone
->zone_domain
= kmem_alloc(_SYS_NMLN
, KM_SLEEP
);
4332 zone
->zone_domain
[0] = '\0';
4333 zone
->zone_hostid
= HW_INVALID_HOSTID
;
4334 zone
->zone_shares
= 1;
4335 zone
->zone_shmmax
= 0;
4336 zone
->zone_ipc
.ipcq_shmmni
= 0;
4337 zone
->zone_ipc
.ipcq_semmni
= 0;
4338 zone
->zone_ipc
.ipcq_msgmni
= 0;
4339 zone
->zone_bootargs
= NULL
;
4340 zone
->zone_fs_allowed
= NULL
;
4341 zone
->zone_initname
=
4342 kmem_alloc(strlen(zone_default_initname
) + 1, KM_SLEEP
);
4343 (void) strcpy(zone
->zone_initname
, zone_default_initname
);
4344 zone
->zone_nlwps
= 0;
4345 zone
->zone_nlwps_ctl
= INT_MAX
;
4346 zone
->zone_nprocs
= 0;
4347 zone
->zone_nprocs_ctl
= INT_MAX
;
4348 zone
->zone_locked_mem
= 0;
4349 zone
->zone_locked_mem_ctl
= UINT64_MAX
;
4350 zone
->zone_max_swap
= 0;
4351 zone
->zone_max_swap_ctl
= UINT64_MAX
;
4352 zone
->zone_max_lofi
= 0;
4353 zone
->zone_max_lofi_ctl
= UINT64_MAX
;
4354 zone0
.zone_lockedmem_kstat
= NULL
;
4355 zone0
.zone_swapresv_kstat
= NULL
;
4358 * Zsched initializes the rctls.
4360 zone
->zone_rctls
= NULL
;
4362 if ((error
= parse_rctls(rctlbuf
, rctlbufsz
, &rctls
)) != 0) {
4364 return (zone_create_error(error
, 0, extended_error
));
4367 if ((error
= parse_zfs(zone
, zfsbuf
, zfsbufsz
)) != 0) {
4369 return (set_errno(error
));
4373 * Read in the trusted system parameters:
4374 * match flag and sensitivity label.
4376 zone
->zone_match
= match
;
4377 if (is_system_labeled() && !(zone
->zone_flags
& ZF_IS_SCRATCH
)) {
4378 /* Fail if requested to set doi to anything but system's doi */
4379 if (doi
!= 0 && doi
!= default_doi
) {
4381 return (set_errno(EINVAL
));
4383 /* Always apply system's doi to the zone */
4384 error
= zone_set_label(zone
, label
, default_doi
);
4387 return (set_errno(error
));
4389 insert_label_hash
= B_TRUE
;
4391 /* all zones get an admin_low label if system is not labeled */
4392 zone
->zone_slabel
= l_admin_low
;
4393 label_hold(l_admin_low
);
4394 insert_label_hash
= B_FALSE
;
4398 * Stop all lwps since that's what normally happens as part of fork().
4399 * This needs to happen before we grab any locks to avoid deadlock
4400 * (another lwp in the process could be waiting for the held lock).
4402 if (curthread
!= pp
->p_agenttp
&& !holdlwps(SHOLDFORK
)) {
4405 return (zone_create_error(error
, 0, extended_error
));
4408 if (block_mounts(zone
) == 0) {
4409 mutex_enter(&pp
->p_lock
);
4410 if (curthread
!= pp
->p_agenttp
)
4412 mutex_exit(&pp
->p_lock
);
4415 return (zone_create_error(error
, 0, extended_error
));
4419 * Set up credential for kernel access. After this, any errors
4420 * should go through the dance in errout rather than calling
4421 * zone_free directly.
4423 zone
->zone_kcred
= crdup(kcred
);
4424 crsetzone(zone
->zone_kcred
, zone
);
4425 priv_intersect(zone
->zone_privset
, &CR_PPRIV(zone
->zone_kcred
));
4426 priv_intersect(zone
->zone_privset
, &CR_EPRIV(zone
->zone_kcred
));
4427 priv_intersect(zone
->zone_privset
, &CR_IPRIV(zone
->zone_kcred
));
4428 priv_intersect(zone
->zone_privset
, &CR_LPRIV(zone
->zone_kcred
));
4430 mutex_enter(&zonehash_lock
);
4432 * Make sure zone doesn't already exist.
4434 * If the system and zone are labeled,
4435 * make sure no other zone exists that has the same label.
4437 if ((ztmp
= zone_find_all_by_name(zone
->zone_name
)) != NULL
||
4438 (insert_label_hash
&&
4439 (ztmp
= zone_find_all_by_label(zone
->zone_slabel
)) != NULL
)) {
4440 zone_status_t status
;
4442 status
= zone_status_get(ztmp
);
4443 if (status
== ZONE_IS_READY
|| status
== ZONE_IS_RUNNING
)
4448 if (insert_label_hash
)
4449 error2
= ZE_LABELINUSE
;
4455 * Don't allow zone creations which would cause one zone's rootpath to
4456 * be accessible from that of another (non-global) zone.
4458 if (zone_is_nested(zone
->zone_rootpath
)) {
4463 ASSERT(zonecount
!= 0); /* check for leaks */
4464 if (zonecount
+ 1 > maxzones
) {
4469 if (zone_mount_count(zone
->zone_rootpath
) != 0) {
4471 error2
= ZE_AREMOUNTS
;
4476 * Zone is still incomplete, but we need to drop all locks while
4477 * zsched() initializes this zone's kernel process. We
4478 * optimistically add the zone to the hashtable and associated
4479 * lists so a parallel zone_create() doesn't try to create the
4483 (void) mod_hash_insert(zonehashbyid
,
4484 (mod_hash_key_t
)(uintptr_t)zone
->zone_id
,
4485 (mod_hash_val_t
)(uintptr_t)zone
);
4486 str
= kmem_alloc(strlen(zone
->zone_name
) + 1, KM_SLEEP
);
4487 (void) strcpy(str
, zone
->zone_name
);
4488 (void) mod_hash_insert(zonehashbyname
, (mod_hash_key_t
)str
,
4489 (mod_hash_val_t
)(uintptr_t)zone
);
4490 if (insert_label_hash
) {
4491 (void) mod_hash_insert(zonehashbylabel
,
4492 (mod_hash_key_t
)zone
->zone_slabel
, (mod_hash_val_t
)zone
);
4493 zone
->zone_flags
|= ZF_HASHED_LABEL
;
4497 * Insert into active list. At this point there are no 'hold's
4498 * on the zone, but everyone else knows not to use it, so we can
4499 * continue to use it. zsched() will do a zone_hold() if the
4500 * newproc() is successful.
4502 list_insert_tail(&zone_active
, zone
);
4503 mutex_exit(&zonehash_lock
);
4506 zarg
.nvlist
= rctls
;
4508 * The process, task, and project rctls are probably wrong;
4509 * we need an interface to get the default values of all rctls,
4510 * and initialize zsched appropriately. I'm not sure that that
4511 * makes much of a difference, though.
4513 error
= newproc(zsched
, (void *)&zarg
, syscid
, minclsyspri
, NULL
, 0);
4516 * We need to undo all globally visible state.
4518 mutex_enter(&zonehash_lock
);
4519 list_remove(&zone_active
, zone
);
4520 if (zone
->zone_flags
& ZF_HASHED_LABEL
) {
4521 ASSERT(zone
->zone_slabel
!= NULL
);
4522 (void) mod_hash_destroy(zonehashbylabel
,
4523 (mod_hash_key_t
)zone
->zone_slabel
);
4525 (void) mod_hash_destroy(zonehashbyname
,
4526 (mod_hash_key_t
)(uintptr_t)zone
->zone_name
);
4527 (void) mod_hash_destroy(zonehashbyid
,
4528 (mod_hash_key_t
)(uintptr_t)zone
->zone_id
);
4529 ASSERT(zonecount
> 1);
4535 * Zone creation can't fail from now on.
4539 * Create zone kstats
4541 zone_kstat_create(zone
);
4544 * Let the other lwps continue.
4546 mutex_enter(&pp
->p_lock
);
4547 if (curthread
!= pp
->p_agenttp
)
4549 mutex_exit(&pp
->p_lock
);
4552 * Wait for zsched to finish initializing the zone.
4554 zone_status_wait(zone
, ZONE_IS_READY
);
4556 * The zone is fully visible, so we can let mounts progress.
4558 resume_mounts(zone
);
4564 mutex_exit(&zonehash_lock
);
4566 * Let the other lwps continue.
4568 mutex_enter(&pp
->p_lock
);
4569 if (curthread
!= pp
->p_agenttp
)
4571 mutex_exit(&pp
->p_lock
);
4573 resume_mounts(zone
);
4576 * There is currently one reference to the zone, a cred_ref from
4577 * zone_kcred. To free the zone, we call crfree, which will call
4578 * zone_cred_rele, which will call zone_free.
4580 ASSERT(zone
->zone_cred_ref
== 1);
4581 ASSERT(zone
->zone_kcred
->cr_ref
== 1);
4582 ASSERT(zone
->zone_ref
== 0);
4583 zkcr
= zone
->zone_kcred
;
4584 zone
->zone_kcred
= NULL
;
4585 crfree(zkcr
); /* triggers call to zone_free */
4586 return (zone_create_error(error
, error2
, extended_error
));
4590 * Cause the zone to boot. This is pretty simple, since we let zoneadmd do
4591 * the heavy lifting. initname is the path to the program to launch
4592 * at the "top" of the zone; if this is NULL, we use the system default,
4593 * which is stored at zone_default_initname.
4596 zone_boot(zoneid_t zoneid
)
4601 if (secpolicy_zone_config(CRED()) != 0)
4602 return (set_errno(EPERM
));
4603 if (zoneid
< MIN_USERZONEID
|| zoneid
> MAX_ZONEID
)
4604 return (set_errno(EINVAL
));
4606 mutex_enter(&zonehash_lock
);
4608 * Look for zone under hash lock to prevent races with calls to
4609 * zone_shutdown, zone_destroy, etc.
4611 if ((zone
= zone_find_all_by_id(zoneid
)) == NULL
) {
4612 mutex_exit(&zonehash_lock
);
4613 return (set_errno(EINVAL
));
4616 mutex_enter(&zone_status_lock
);
4617 if (zone_status_get(zone
) != ZONE_IS_READY
) {
4618 mutex_exit(&zone_status_lock
);
4619 mutex_exit(&zonehash_lock
);
4620 return (set_errno(EINVAL
));
4622 zone_status_set(zone
, ZONE_IS_BOOTING
);
4623 mutex_exit(&zone_status_lock
);
4625 zone_hold(zone
); /* so we can use the zone_t later */
4626 mutex_exit(&zonehash_lock
);
4628 if (zone_status_wait_sig(zone
, ZONE_IS_RUNNING
) == 0) {
4630 return (set_errno(EINTR
));
4634 * Boot (starting init) might have failed, in which case the zone
4635 * will go to the SHUTTING_DOWN state; an appropriate errno will
4636 * be placed in zone->zone_boot_err, and so we return that.
4638 err
= zone
->zone_boot_err
;
4640 return (err
? set_errno(err
) : 0);
4644 * Kills all user processes in the zone, waiting for them all to exit
4648 zone_empty(zone_t
*zone
)
4653 * We need to drop zonehash_lock before killing all
4654 * processes, otherwise we'll deadlock with zone_find_*
4655 * which can be called from the exit path.
4657 ASSERT(MUTEX_NOT_HELD(&zonehash_lock
));
4658 while ((waitstatus
= zone_status_timedwait_sig(zone
,
4659 ddi_get_lbolt() + hz
, ZONE_IS_EMPTY
)) == -1) {
4660 killall(zone
->zone_id
);
4663 * return EINTR if we were signaled
4665 if (waitstatus
== 0)
4671 * This function implements the policy for zone visibility.
4673 * In standard Solaris, a non-global zone can only see itself.
4675 * In Trusted Extensions, a labeled zone can lookup any zone whose label
4676 * it dominates. For this test, the label of the global zone is treated as
4677 * admin_high so it is special-cased instead of being checked for dominance.
4679 * Returns true if zone attributes are viewable, false otherwise.
4682 zone_list_access(zone_t
*zone
)
4685 if (curproc
->p_zone
== global_zone
||
4686 curproc
->p_zone
== zone
) {
4688 } else if (is_system_labeled() && !(zone
->zone_flags
& ZF_IS_SCRATCH
)) {
4689 bslabel_t
*curproc_label
;
4690 bslabel_t
*zone_label
;
4692 curproc_label
= label2bslabel(curproc
->p_zone
->zone_slabel
);
4693 zone_label
= label2bslabel(zone
->zone_slabel
);
4695 if (zone
->zone_id
!= GLOBAL_ZONEID
&&
4696 bldominates(curproc_label
, zone_label
)) {
4707 * Systemcall to start the zone's halt sequence. By the time this
4708 * function successfully returns, all user processes and kernel threads
4709 * executing in it will have exited, ZSD shutdown callbacks executed,
4710 * and the zone status set to ZONE_IS_DOWN.
4712 * It is possible that the call will interrupt itself if the caller is the
4713 * parent of any process running in the zone, and doesn't have SIGCHLD blocked.
4716 zone_shutdown(zoneid_t zoneid
)
4720 zone_status_t status
;
4722 if (secpolicy_zone_config(CRED()) != 0)
4723 return (set_errno(EPERM
));
4724 if (zoneid
< MIN_USERZONEID
|| zoneid
> MAX_ZONEID
)
4725 return (set_errno(EINVAL
));
4727 mutex_enter(&zonehash_lock
);
4729 * Look for zone under hash lock to prevent races with other
4730 * calls to zone_shutdown and zone_destroy.
4732 if ((zone
= zone_find_all_by_id(zoneid
)) == NULL
) {
4733 mutex_exit(&zonehash_lock
);
4734 return (set_errno(EINVAL
));
4738 * We have to drop zonehash_lock before calling block_mounts.
4739 * Hold the zone so we can continue to use the zone_t.
4742 mutex_exit(&zonehash_lock
);
4745 * Block mounts so that VFS_MOUNT() can get an accurate view of
4746 * the zone's status with regards to ZONE_IS_SHUTTING down.
4748 * e.g. NFS can fail the mount if it determines that the zone
4749 * has already begun the shutdown sequence.
4752 if (block_mounts(zone
) == 0) {
4754 return (set_errno(EINTR
));
4757 mutex_enter(&zonehash_lock
);
4758 mutex_enter(&zone_status_lock
);
4759 status
= zone_status_get(zone
);
4761 * Fail if the zone isn't fully initialized yet.
4763 if (status
< ZONE_IS_READY
) {
4764 mutex_exit(&zone_status_lock
);
4765 mutex_exit(&zonehash_lock
);
4766 resume_mounts(zone
);
4768 return (set_errno(EINVAL
));
4771 * If conditions required for zone_shutdown() to return have been met,
4774 if (status
>= ZONE_IS_DOWN
) {
4775 mutex_exit(&zone_status_lock
);
4776 mutex_exit(&zonehash_lock
);
4777 resume_mounts(zone
);
4782 * If zone_shutdown() hasn't been called before, go through the motions.
4783 * If it has, there's nothing to do but wait for the kernel threads to
4786 if (status
< ZONE_IS_EMPTY
) {
4789 mutex_enter(&zone
->zone_lock
);
4790 if ((ntasks
= zone
->zone_ntasks
) != 1) {
4792 * There's still stuff running.
4794 zone_status_set(zone
, ZONE_IS_SHUTTING_DOWN
);
4796 mutex_exit(&zone
->zone_lock
);
4799 * The only way to create another task is through
4800 * zone_enter(), which will block until we drop
4801 * zonehash_lock. The zone is empty.
4803 if (zone
->zone_kthreads
== NULL
) {
4805 * Skip ahead to ZONE_IS_DOWN
4807 zone_status_set(zone
, ZONE_IS_DOWN
);
4809 zone_status_set(zone
, ZONE_IS_EMPTY
);
4813 mutex_exit(&zone_status_lock
);
4814 mutex_exit(&zonehash_lock
);
4815 resume_mounts(zone
);
4817 if (error
= zone_empty(zone
)) {
4819 return (set_errno(error
));
4822 * After the zone status goes to ZONE_IS_DOWN this zone will no
4823 * longer be notified of changes to the pools configuration, so
4824 * in order to not end up with a stale pool pointer, we point
4825 * ourselves at the default pool and remove all resource
4826 * visibility. This is especially important as the zone_t may
4827 * languish on the deathrow for a very long time waiting for
4828 * cred's to drain out.
4830 * This rebinding of the zone can happen multiple times
4831 * (presumably due to interrupted or parallel systemcalls)
4832 * without any adverse effects.
4834 if (pool_lock_intr() != 0) {
4836 return (set_errno(EINTR
));
4838 if (pool_state
== POOL_ENABLED
) {
4839 mutex_enter(&cpu_lock
);
4840 zone_pool_set(zone
, pool_default
);
4842 * The zone no longer needs to be able to see any cpus.
4844 zone_pset_set(zone
, ZONE_PS_INVAL
);
4845 mutex_exit(&cpu_lock
);
4850 * ZSD shutdown callbacks can be executed multiple times, hence
4851 * it is safe to not be holding any locks across this call.
4853 zone_zsd_callbacks(zone
, ZSD_SHUTDOWN
);
4855 mutex_enter(&zone_status_lock
);
4856 if (zone
->zone_kthreads
== NULL
&& zone_status_get(zone
) < ZONE_IS_DOWN
)
4857 zone_status_set(zone
, ZONE_IS_DOWN
);
4858 mutex_exit(&zone_status_lock
);
4861 * Wait for kernel threads to drain.
4863 if (!zone_status_wait_sig(zone
, ZONE_IS_DOWN
)) {
4865 return (set_errno(EINTR
));
4869 * Zone can be become down/destroyable even if the above wait
4870 * returns EINTR, so any code added here may never execute.
4871 * (i.e. don't add code here)
4879 * Log the specified zone's reference counts. The caller should not be
4880 * holding the zone's zone_lock.
4883 zone_log_refcounts(zone_t
*zone
)
4886 char *buffer_position
;
4887 uint32_t buffer_size
;
4893 * Construct a string representing the subsystem-specific reference
4894 * counts. The counts are printed in ascending order by index into the
4895 * zone_t::zone_subsys_ref array. The list will be surrounded by
4896 * square brackets [] and will only contain nonzero reference counts.
4898 * The buffer will hold two square bracket characters plus ten digits,
4899 * one colon, one space, one comma, and some characters for a
4900 * subsystem name per subsystem-specific reference count. (Unsigned 32-
4901 * bit integers have at most ten decimal digits.) The last
4902 * reference count's comma is replaced by the closing square
4903 * bracket and a NULL character to terminate the string.
4905 * NOTE: We have to grab the zone's zone_lock to create a consistent
4906 * snapshot of the zone's reference counters.
4908 * First, figure out how much space the string buffer will need.
4909 * The buffer's size is stored in buffer_size.
4911 buffer_size
= 2; /* for the square brackets */
4912 mutex_enter(&zone
->zone_lock
);
4913 zone
->zone_flags
|= ZF_REFCOUNTS_LOGGED
;
4914 ref
= zone
->zone_ref
;
4915 cred_ref
= zone
->zone_cred_ref
;
4916 for (index
= 0; index
< ZONE_REF_NUM_SUBSYS
; ++index
)
4917 if (zone
->zone_subsys_ref
[index
] != 0)
4918 buffer_size
+= strlen(zone_ref_subsys_names
[index
]) +
4920 if (buffer_size
== 2) {
4922 * No subsystems had nonzero reference counts. Don't bother
4923 * with allocating a buffer; just log the general-purpose and
4924 * credential reference counts.
4926 mutex_exit(&zone
->zone_lock
);
4927 (void) strlog(0, 0, 1, SL_CONSOLE
| SL_NOTE
,
4928 "Zone '%s' (ID: %d) is shutting down, but %u zone "
4929 "references and %u credential references are still extant",
4930 zone
->zone_name
, zone
->zone_id
, ref
, cred_ref
);
4935 * buffer_size contains the exact number of characters that the
4936 * buffer will need. Allocate the buffer and fill it with nonzero
4937 * subsystem-specific reference counts. Surround the results with
4938 * square brackets afterwards.
4940 buffer
= kmem_alloc(buffer_size
, KM_SLEEP
);
4941 buffer_position
= &buffer
[1];
4942 for (index
= 0; index
< ZONE_REF_NUM_SUBSYS
; ++index
) {
4944 * NOTE: The DDI's version of sprintf() returns a pointer to
4945 * the modified buffer rather than the number of bytes written
4946 * (as in snprintf(3C)). This is unfortunate and annoying.
4947 * Therefore, we'll use snprintf() with INT_MAX to get the
4948 * number of bytes written. Using INT_MAX is safe because
4949 * the buffer is perfectly sized for the data: we'll never
4950 * overrun the buffer.
4952 if (zone
->zone_subsys_ref
[index
] != 0)
4953 buffer_position
+= snprintf(buffer_position
, INT_MAX
,
4954 "%s: %u,", zone_ref_subsys_names
[index
],
4955 zone
->zone_subsys_ref
[index
]);
4957 mutex_exit(&zone
->zone_lock
);
4959 ASSERT((uintptr_t)(buffer_position
- buffer
) < buffer_size
);
4960 ASSERT(buffer_position
[0] == '\0' && buffer_position
[-1] == ',');
4961 buffer_position
[-1] = ']';
4964 * Log the reference counts and free the message buffer.
4966 (void) strlog(0, 0, 1, SL_CONSOLE
| SL_NOTE
,
4967 "Zone '%s' (ID: %d) is shutting down, but %u zone references and "
4968 "%u credential references are still extant %s", zone
->zone_name
,
4969 zone
->zone_id
, ref
, cred_ref
, buffer
);
4970 kmem_free(buffer
, buffer_size
);
4974 * Systemcall entry point to finalize the zone halt process. The caller
4975 * must have already successfully called zone_shutdown().
4977 * Upon successful completion, the zone will have been fully destroyed:
4978 * zsched will have exited, destructor callbacks executed, and the zone
4979 * removed from the list of active zones.
4982 zone_destroy(zoneid_t zoneid
)
4986 zone_status_t status
;
4988 boolean_t log_refcounts
;
4990 if (secpolicy_zone_config(CRED()) != 0)
4991 return (set_errno(EPERM
));
4992 if (zoneid
< MIN_USERZONEID
|| zoneid
> MAX_ZONEID
)
4993 return (set_errno(EINVAL
));
4995 mutex_enter(&zonehash_lock
);
4997 * Look for zone under hash lock to prevent races with other
4998 * calls to zone_destroy.
5000 if ((zone
= zone_find_all_by_id(zoneid
)) == NULL
) {
5001 mutex_exit(&zonehash_lock
);
5002 return (set_errno(EINVAL
));
5005 if (zone_mount_count(zone
->zone_rootpath
) != 0) {
5006 mutex_exit(&zonehash_lock
);
5007 return (set_errno(EBUSY
));
5009 mutex_enter(&zone_status_lock
);
5010 status
= zone_status_get(zone
);
5011 if (status
< ZONE_IS_DOWN
) {
5012 mutex_exit(&zone_status_lock
);
5013 mutex_exit(&zonehash_lock
);
5014 return (set_errno(EBUSY
));
5015 } else if (status
== ZONE_IS_DOWN
) {
5016 zone_status_set(zone
, ZONE_IS_DYING
); /* Tell zsched to exit */
5018 mutex_exit(&zone_status_lock
);
5020 mutex_exit(&zonehash_lock
);
5023 * wait for zsched to exit
5025 zone_status_wait(zone
, ZONE_IS_DEAD
);
5026 zone_zsd_callbacks(zone
, ZSD_DESTROY
);
5027 zone
->zone_netstack
= NULL
;
5028 uniqid
= zone
->zone_uniqid
;
5030 zone
= NULL
; /* potentially free'd */
5032 log_refcounts
= B_FALSE
;
5033 wait_time
= SEC_TO_TICK(ZONE_DESTROY_TIMEOUT_SECS
);
5034 mutex_enter(&zonehash_lock
);
5035 for (; /* ever */; ) {
5037 boolean_t refs_have_been_logged
;
5039 if ((zone
= zone_find_all_by_id(zoneid
)) == NULL
||
5040 zone
->zone_uniqid
!= uniqid
) {
5042 * The zone has gone away. Necessary conditions
5043 * are met, so we return success.
5045 mutex_exit(&zonehash_lock
);
5048 mutex_enter(&zone
->zone_lock
);
5049 unref
= ZONE_IS_UNREF(zone
);
5050 refs_have_been_logged
= (zone
->zone_flags
&
5051 ZF_REFCOUNTS_LOGGED
);
5052 mutex_exit(&zone
->zone_lock
);
5055 * There is only one reference to the zone -- that
5056 * added when the zone was added to the hashtables --
5057 * and things will remain this way until we drop
5058 * zonehash_lock... we can go ahead and cleanup the
5065 * Wait for zone_rele_common() or zone_cred_rele() to signal
5066 * zone_destroy_cv. zone_destroy_cv is signaled only when
5067 * some zone's general-purpose reference count reaches one.
5068 * If ZONE_DESTROY_TIMEOUT_SECS seconds elapse while waiting
5069 * on zone_destroy_cv, then log the zone's reference counts and
5070 * continue to wait for zone_rele() and zone_cred_rele().
5072 if (!refs_have_been_logged
) {
5073 if (!log_refcounts
) {
5075 * This thread hasn't timed out waiting on
5076 * zone_destroy_cv yet. Wait wait_time clock
5077 * ticks (initially ZONE_DESTROY_TIMEOUT_SECS
5078 * seconds) for the zone's references to clear.
5080 ASSERT(wait_time
> 0);
5081 wait_time
= cv_reltimedwait_sig(
5082 &zone_destroy_cv
, &zonehash_lock
, wait_time
,
5084 if (wait_time
> 0) {
5086 * A thread in zone_rele() or
5087 * zone_cred_rele() signaled
5088 * zone_destroy_cv before this thread's
5089 * wait timed out. The zone might have
5090 * only one reference left; find out!
5093 } else if (wait_time
== 0) {
5094 /* The thread's process was signaled. */
5095 mutex_exit(&zonehash_lock
);
5096 return (set_errno(EINTR
));
5100 * The thread timed out while waiting on
5101 * zone_destroy_cv. Even though the thread
5102 * timed out, it has to check whether another
5103 * thread woke up from zone_destroy_cv and
5104 * destroyed the zone.
5106 * If the zone still exists and has more than
5107 * one unreleased general-purpose reference,
5108 * then log the zone's reference counts.
5110 log_refcounts
= B_TRUE
;
5115 * The thread already timed out on zone_destroy_cv while
5116 * waiting for subsystems to release the zone's last
5117 * general-purpose references. Log the zone's reference
5118 * counts and wait indefinitely on zone_destroy_cv.
5120 zone_log_refcounts(zone
);
5122 if (cv_wait_sig(&zone_destroy_cv
, &zonehash_lock
) == 0) {
5123 /* The thread's process was signaled. */
5124 mutex_exit(&zonehash_lock
);
5125 return (set_errno(EINTR
));
5130 * Remove CPU cap for this zone now since we're not going to
5131 * fail below this point.
5133 cpucaps_zone_remove(zone
);
5135 /* Get rid of the zone's kstats */
5136 zone_kstat_delete(zone
);
5138 /* remove the pfexecd doors */
5139 if (zone
->zone_pfexecd
!= NULL
) {
5140 klpd_freelist(&zone
->zone_pfexecd
);
5141 zone
->zone_pfexecd
= NULL
;
5144 /* free brand specific data */
5145 if (ZONE_IS_BRANDED(zone
))
5146 ZBROP(zone
)->b_free_brand_data(zone
);
5148 /* Say goodbye to brand framework. */
5149 brand_unregister_zone(zone
->zone_brand
);
5152 * It is now safe to let the zone be recreated; remove it from the
5153 * lists. The memory will not be freed until the last cred
5154 * reference goes away.
5156 ASSERT(zonecount
> 1); /* must be > 1; can't destroy global zone */
5158 /* remove from active list and hash tables */
5159 list_remove(&zone_active
, zone
);
5160 (void) mod_hash_destroy(zonehashbyname
,
5161 (mod_hash_key_t
)zone
->zone_name
);
5162 (void) mod_hash_destroy(zonehashbyid
,
5163 (mod_hash_key_t
)(uintptr_t)zone
->zone_id
);
5164 if (zone
->zone_flags
& ZF_HASHED_LABEL
)
5165 (void) mod_hash_destroy(zonehashbylabel
,
5166 (mod_hash_key_t
)zone
->zone_slabel
);
5167 mutex_exit(&zonehash_lock
);
5170 * Release the root vnode; we're not using it anymore. Nor should any
5171 * other thread that might access it exist.
5173 if (zone
->zone_rootvp
!= NULL
) {
5174 VN_RELE(zone
->zone_rootvp
);
5175 zone
->zone_rootvp
= NULL
;
5178 /* add to deathrow list */
5179 mutex_enter(&zone_deathrow_lock
);
5180 list_insert_tail(&zone_deathrow
, zone
);
5181 mutex_exit(&zone_deathrow_lock
);
5184 * Drop last reference (which was added by zsched()), this will
5185 * free the zone unless there are outstanding cred references.
5192 * Systemcall entry point for zone_getattr(2).
5195 zone_getattr(zoneid_t zoneid
, int attr
, void *buf
, size_t bufsize
)
5202 zone_status_t zone_status
;
5204 boolean_t global
= (curzone
== global_zone
);
5205 boolean_t inzone
= (curzone
->zone_id
== zoneid
);
5207 zone_net_data_t
*zbuf
;
5209 mutex_enter(&zonehash_lock
);
5210 if ((zone
= zone_find_all_by_id(zoneid
)) == NULL
) {
5211 mutex_exit(&zonehash_lock
);
5212 return (set_errno(EINVAL
));
5214 zone_status
= zone_status_get(zone
);
5215 if (zone_status
< ZONE_IS_INITIALIZED
) {
5216 mutex_exit(&zonehash_lock
);
5217 return (set_errno(EINVAL
));
5220 mutex_exit(&zonehash_lock
);
5223 * If not in the global zone, don't show information about other zones,
5224 * unless the system is labeled and the local zone's label dominates
5227 if (!zone_list_access(zone
)) {
5229 return (set_errno(EINVAL
));
5233 case ZONE_ATTR_ROOT
:
5236 * Copy the path to trim the trailing "/" (except for
5239 if (zone
!= global_zone
)
5240 size
= zone
->zone_rootpathlen
- 1;
5242 size
= zone
->zone_rootpathlen
;
5243 zonepath
= kmem_alloc(size
, KM_SLEEP
);
5244 bcopy(zone
->zone_rootpath
, zonepath
, size
);
5245 zonepath
[size
- 1] = '\0';
5247 if (inzone
|| !is_system_labeled()) {
5249 * Caller is not in the global zone.
5250 * if the query is on the current zone
5251 * or the system is not labeled,
5252 * just return faked-up path for current zone.
5258 * Return related path for current zone.
5260 int prefix_len
= strlen(zone_prefix
);
5261 int zname_len
= strlen(zone
->zone_name
);
5263 size
= prefix_len
+ zname_len
+ 1;
5264 zonepath
= kmem_alloc(size
, KM_SLEEP
);
5265 bcopy(zone_prefix
, zonepath
, prefix_len
);
5266 bcopy(zone
->zone_name
, zonepath
+
5267 prefix_len
, zname_len
);
5268 zonepath
[size
- 1] = '\0';
5274 err
= copyoutstr(zonepath
, buf
, bufsize
, NULL
);
5275 if (err
!= 0 && err
!= ENAMETOOLONG
)
5278 if (global
|| (is_system_labeled() && !inzone
))
5279 kmem_free(zonepath
, size
);
5282 case ZONE_ATTR_NAME
:
5283 size
= strlen(zone
->zone_name
) + 1;
5287 err
= copyoutstr(zone
->zone_name
, buf
, bufsize
, NULL
);
5288 if (err
!= 0 && err
!= ENAMETOOLONG
)
5293 case ZONE_ATTR_STATUS
:
5295 * Since we're not holding zonehash_lock, the zone status
5296 * may be anything; leave it up to userland to sort it out.
5298 size
= sizeof (zone_status
);
5301 zone_status
= zone_status_get(zone
);
5303 copyout(&zone_status
, buf
, bufsize
) != 0)
5306 case ZONE_ATTR_FLAGS
:
5307 size
= sizeof (zone
->zone_flags
);
5310 flags
= zone
->zone_flags
;
5312 copyout(&flags
, buf
, bufsize
) != 0)
5315 case ZONE_ATTR_PRIVSET
:
5316 size
= sizeof (priv_set_t
);
5320 copyout(zone
->zone_privset
, buf
, bufsize
) != 0)
5323 case ZONE_ATTR_UNIQID
:
5324 size
= sizeof (zone
->zone_uniqid
);
5328 copyout(&zone
->zone_uniqid
, buf
, bufsize
) != 0)
5331 case ZONE_ATTR_POOLID
:
5336 if (pool_lock_intr() != 0) {
5340 pool
= zone_pool_get(zone
);
5341 poolid
= pool
->pool_id
;
5343 size
= sizeof (poolid
);
5346 if (buf
!= NULL
&& copyout(&poolid
, buf
, size
) != 0)
5350 case ZONE_ATTR_SLBL
:
5351 size
= sizeof (bslabel_t
);
5354 if (zone
->zone_slabel
== NULL
)
5356 else if (buf
!= NULL
&&
5357 copyout(label2bslabel(zone
->zone_slabel
), buf
,
5361 case ZONE_ATTR_INITPID
:
5362 size
= sizeof (initpid
);
5365 initpid
= zone
->zone_proc_initpid
;
5366 if (initpid
== -1) {
5371 copyout(&initpid
, buf
, bufsize
) != 0)
5374 case ZONE_ATTR_BRAND
:
5375 size
= strlen(zone
->zone_brand
->b_name
) + 1;
5380 err
= copyoutstr(zone
->zone_brand
->b_name
, buf
,
5382 if (err
!= 0 && err
!= ENAMETOOLONG
)
5386 case ZONE_ATTR_INITNAME
:
5387 size
= strlen(zone
->zone_initname
) + 1;
5391 err
= copyoutstr(zone
->zone_initname
, buf
, bufsize
,
5393 if (err
!= 0 && err
!= ENAMETOOLONG
)
5397 case ZONE_ATTR_BOOTARGS
:
5398 if (zone
->zone_bootargs
== NULL
)
5401 outstr
= zone
->zone_bootargs
;
5402 size
= strlen(outstr
) + 1;
5406 err
= copyoutstr(outstr
, buf
, bufsize
, NULL
);
5407 if (err
!= 0 && err
!= ENAMETOOLONG
)
5411 case ZONE_ATTR_PHYS_MCAP
:
5412 size
= sizeof (zone
->zone_phys_mcap
);
5416 copyout(&zone
->zone_phys_mcap
, buf
, bufsize
) != 0)
5419 case ZONE_ATTR_SCHED_CLASS
:
5420 mutex_enter(&class_lock
);
5422 if (zone
->zone_defaultcid
>= loaded_classes
)
5425 outstr
= sclass
[zone
->zone_defaultcid
].cl_name
;
5426 size
= strlen(outstr
) + 1;
5430 err
= copyoutstr(outstr
, buf
, bufsize
, NULL
);
5431 if (err
!= 0 && err
!= ENAMETOOLONG
)
5435 mutex_exit(&class_lock
);
5437 case ZONE_ATTR_HOSTID
:
5438 if (zone
->zone_hostid
!= HW_INVALID_HOSTID
&&
5439 bufsize
== sizeof (zone
->zone_hostid
)) {
5440 size
= sizeof (zone
->zone_hostid
);
5441 if (buf
!= NULL
&& copyout(&zone
->zone_hostid
, buf
,
5448 case ZONE_ATTR_FS_ALLOWED
:
5449 if (zone
->zone_fs_allowed
== NULL
)
5452 outstr
= zone
->zone_fs_allowed
;
5453 size
= strlen(outstr
) + 1;
5457 err
= copyoutstr(outstr
, buf
, bufsize
, NULL
);
5458 if (err
!= 0 && err
!= ENAMETOOLONG
)
5462 case ZONE_ATTR_NETWORK
:
5463 zbuf
= kmem_alloc(bufsize
, KM_SLEEP
);
5464 if (copyin(buf
, zbuf
, bufsize
) != 0) {
5467 error
= zone_get_network(zoneid
, zbuf
);
5468 if (error
== 0 && copyout(zbuf
, buf
, bufsize
) != 0)
5471 kmem_free(zbuf
, bufsize
);
5474 if ((attr
>= ZONE_ATTR_BRAND_ATTRS
) && ZONE_IS_BRANDED(zone
)) {
5476 error
= ZBROP(zone
)->b_getattr(zone
, attr
, buf
, &size
);
5484 return (set_errno(error
));
5485 return ((ssize_t
)size
);
5489 * Systemcall entry point for zone_setattr(2).
5493 zone_setattr(zoneid_t zoneid
, int attr
, void *buf
, size_t bufsize
)
5496 zone_status_t zone_status
;
5498 zone_net_data_t
*zbuf
;
5500 if (secpolicy_zone_config(CRED()) != 0)
5501 return (set_errno(EPERM
));
5504 * Only the ZONE_ATTR_PHYS_MCAP attribute can be set on the
5507 if (zoneid
== GLOBAL_ZONEID
&& attr
!= ZONE_ATTR_PHYS_MCAP
) {
5508 return (set_errno(EINVAL
));
5511 mutex_enter(&zonehash_lock
);
5512 if ((zone
= zone_find_all_by_id(zoneid
)) == NULL
) {
5513 mutex_exit(&zonehash_lock
);
5514 return (set_errno(EINVAL
));
5517 mutex_exit(&zonehash_lock
);
5520 * At present most attributes can only be set on non-running,
5523 zone_status
= zone_status_get(zone
);
5524 if (attr
!= ZONE_ATTR_PHYS_MCAP
&& zone_status
> ZONE_IS_READY
) {
5530 case ZONE_ATTR_INITNAME
:
5531 err
= zone_set_initname(zone
, (const char *)buf
);
5533 case ZONE_ATTR_INITNORESTART
:
5534 zone
->zone_restart_init
= B_FALSE
;
5537 case ZONE_ATTR_BOOTARGS
:
5538 err
= zone_set_bootargs(zone
, (const char *)buf
);
5540 case ZONE_ATTR_BRAND
:
5541 err
= zone_set_brand(zone
, (const char *)buf
);
5543 case ZONE_ATTR_FS_ALLOWED
:
5544 err
= zone_set_fs_allowed(zone
, (const char *)buf
);
5546 case ZONE_ATTR_PHYS_MCAP
:
5547 err
= zone_set_phys_mcap(zone
, (const uint64_t *)buf
);
5549 case ZONE_ATTR_SCHED_CLASS
:
5550 err
= zone_set_sched_class(zone
, (const char *)buf
);
5552 case ZONE_ATTR_HOSTID
:
5553 if (bufsize
== sizeof (zone
->zone_hostid
)) {
5554 if (copyin(buf
, &zone
->zone_hostid
, bufsize
) == 0)
5562 case ZONE_ATTR_NETWORK
:
5563 if (bufsize
> (PIPE_BUF
+ sizeof (zone_net_data_t
))) {
5567 zbuf
= kmem_alloc(bufsize
, KM_SLEEP
);
5568 if (copyin(buf
, zbuf
, bufsize
) != 0) {
5569 kmem_free(zbuf
, bufsize
);
5573 err
= zone_set_network(zoneid
, zbuf
);
5574 kmem_free(zbuf
, bufsize
);
5577 if ((attr
>= ZONE_ATTR_BRAND_ATTRS
) && ZONE_IS_BRANDED(zone
))
5578 err
= ZBROP(zone
)->b_setattr(zone
, attr
, buf
, bufsize
);
5586 return (err
!= 0 ? set_errno(err
) : 0);
5590 * Return zero if the process has at least one vnode mapped in to its
5591 * address space which shouldn't be allowed to change zones.
5593 * Also return zero if the process has any shared mappings which reserve
5594 * swap. This is because the counting for zone.max-swap does not allow swap
5595 * reservation to be shared between zones. zone swap reservation is counted
5596 * on zone->zone_max_swap.
5599 as_can_change_zones(void)
5601 proc_t
*pp
= curproc
;
5603 struct as
*as
= pp
->p_as
;
5607 ASSERT(pp
->p_as
!= &kas
);
5608 AS_LOCK_ENTER(as
, RW_READER
);
5609 for (seg
= AS_SEGFIRST(as
); seg
!= NULL
; seg
= AS_SEGNEXT(as
, seg
)) {
5612 * Cannot enter zone with shared anon memory which
5613 * reserves swap. See comment above.
5615 if (seg_can_change_zones(seg
) == B_FALSE
) {
5620 * if we can't get a backing vnode for this segment then skip
5624 if (SEGOP_GETVP(seg
, seg
->s_base
, &vp
) != 0 || vp
== NULL
)
5626 if (!vn_can_change_zones(vp
)) { /* bail on first match */
5636 * Count swap reserved by curproc's address space
5641 proc_t
*pp
= curproc
;
5643 struct as
*as
= pp
->p_as
;
5646 ASSERT(pp
->p_as
!= &kas
);
5647 ASSERT(AS_WRITE_HELD(as
));
5648 for (seg
= AS_SEGFIRST(as
); seg
!= NULL
; seg
= AS_SEGNEXT(as
, seg
))
5649 swap
+= seg_swresv(seg
);
5655 * Systemcall entry point for zone_enter().
5657 * The current process is injected into said zone. In the process
5658 * it will change its project membership, privileges, rootdir/cwd,
5659 * zone-wide rctls, and pool association to match those of the zone.
5661 * The first zone_enter() called while the zone is in the ZONE_IS_READY
5662 * state will transition it to ZONE_IS_RUNNING. Processes may only
5663 * enter a zone that is "ready" or "running".
5666 zone_enter(zoneid_t zoneid
)
5670 proc_t
*pp
= curproc
;
5672 cont_process_t
*ctp
;
5674 kproject_t
*zone_proj0
;
5676 pool_t
*oldpool
, *newpool
;
5679 zone_status_t status
;
5685 if (secpolicy_zone_config(CRED()) != 0)
5686 return (set_errno(EPERM
));
5687 if (zoneid
< MIN_USERZONEID
|| zoneid
> MAX_ZONEID
)
5688 return (set_errno(EINVAL
));
5691 * Stop all lwps so we don't need to hold a lock to look at
5692 * curproc->p_zone. This needs to happen before we grab any
5693 * locks to avoid deadlock (another lwp in the process could
5694 * be waiting for the held lock).
5696 if (curthread
!= pp
->p_agenttp
&& !holdlwps(SHOLDFORK
))
5697 return (set_errno(EINTR
));
5700 * Make sure we're not changing zones with files open or mapped in
5701 * to our address space which shouldn't be changing zones.
5703 if (!files_can_change_zones()) {
5707 if (!as_can_change_zones()) {
5712 mutex_enter(&zonehash_lock
);
5713 if (pp
->p_zone
!= global_zone
) {
5714 mutex_exit(&zonehash_lock
);
5719 zone
= zone_find_all_by_id(zoneid
);
5721 mutex_exit(&zonehash_lock
);
5727 * To prevent processes in a zone from holding contracts on
5728 * extrazonal resources, and to avoid process contract
5729 * memberships which span zones, contract holders and processes
5730 * which aren't the sole members of their encapsulating process
5731 * contracts are not allowed to zone_enter.
5733 ctp
= pp
->p_ct_process
;
5734 ct
= &ctp
->conp_contract
;
5735 mutex_enter(&ct
->ct_lock
);
5736 mutex_enter(&pp
->p_lock
);
5737 if ((avl_numnodes(&pp
->p_ct_held
) != 0) || (ctp
->conp_nmembers
!= 1)) {
5738 mutex_exit(&pp
->p_lock
);
5739 mutex_exit(&ct
->ct_lock
);
5740 mutex_exit(&zonehash_lock
);
5746 * Moreover, we don't allow processes whose encapsulating
5747 * process contracts have inherited extrazonal contracts.
5748 * While it would be easier to eliminate all process contracts
5749 * with inherited contracts, we need to be able to give a
5750 * restarted init (or other zone-penetrating process) its
5751 * predecessor's contracts.
5753 if (ctp
->conp_ninherited
!= 0) {
5755 for (next
= list_head(&ctp
->conp_inherited
); next
;
5756 next
= list_next(&ctp
->conp_inherited
, next
)) {
5757 if (contract_getzuniqid(next
) != zone
->zone_uniqid
) {
5758 mutex_exit(&pp
->p_lock
);
5759 mutex_exit(&ct
->ct_lock
);
5760 mutex_exit(&zonehash_lock
);
5767 mutex_exit(&pp
->p_lock
);
5768 mutex_exit(&ct
->ct_lock
);
5770 status
= zone_status_get(zone
);
5771 if (status
< ZONE_IS_READY
|| status
>= ZONE_IS_SHUTTING_DOWN
) {
5775 mutex_exit(&zonehash_lock
);
5781 * Make sure new priv set is within the permitted set for caller
5783 if (!priv_issubset(zone
->zone_privset
, &CR_OPPRIV(CRED()))) {
5784 mutex_exit(&zonehash_lock
);
5789 * We want to momentarily drop zonehash_lock while we optimistically
5790 * bind curproc to the pool it should be running in. This is safe
5791 * since the zone can't disappear (we have a hold on it).
5794 mutex_exit(&zonehash_lock
);
5797 * Grab pool_lock to keep the pools configuration from changing
5798 * and to stop ourselves from getting rebound to another pool
5799 * until we join the zone.
5801 if (pool_lock_intr() != 0) {
5806 ASSERT(secpolicy_pool(CRED()) == 0);
5808 * Bind ourselves to the pool currently associated with the zone.
5810 oldpool
= curproc
->p_pool
;
5811 newpool
= zone_pool_get(zone
);
5812 if (pool_state
== POOL_ENABLED
&& newpool
!= oldpool
&&
5813 (err
= pool_do_bind(newpool
, P_PID
, P_MYID
,
5814 POOL_BIND_ALL
)) != 0) {
5821 * Grab cpu_lock now; we'll need it later when we call
5824 mutex_enter(&cpu_lock
);
5825 mutex_enter(&zonehash_lock
);
5827 * Make sure the zone hasn't moved on since we dropped zonehash_lock.
5829 if (zone_status_get(zone
) >= ZONE_IS_SHUTTING_DOWN
) {
5831 * Can't join anymore.
5833 mutex_exit(&zonehash_lock
);
5834 mutex_exit(&cpu_lock
);
5835 if (pool_state
== POOL_ENABLED
&&
5837 (void) pool_do_bind(oldpool
, P_PID
, P_MYID
,
5846 * a_lock must be held while transfering locked memory and swap
5847 * reservation from the global zone to the non global zone because
5848 * asynchronous faults on the processes' address space can lock
5849 * memory and reserve swap via MCL_FUTURE and MAP_NORESERVE
5850 * segments respectively.
5852 AS_LOCK_ENTER(pp
->p_as
, RW_WRITER
);
5854 mutex_enter(&pp
->p_lock
);
5855 zone_proj0
= zone
->zone_zsched
->p_task
->tk_proj
;
5856 /* verify that we do not exceed and task or lwp limits */
5857 mutex_enter(&zone
->zone_nlwps_lock
);
5858 /* add new lwps to zone and zone's proj0 */
5859 zone_proj0
->kpj_nlwps
+= pp
->p_lwpcnt
;
5860 zone
->zone_nlwps
+= pp
->p_lwpcnt
;
5861 /* add 1 task to zone's proj0 */
5862 zone_proj0
->kpj_ntasks
+= 1;
5864 zone_proj0
->kpj_nprocs
++;
5865 zone
->zone_nprocs
++;
5866 mutex_exit(&zone
->zone_nlwps_lock
);
5868 mutex_enter(&zone
->zone_mem_lock
);
5869 zone
->zone_locked_mem
+= pp
->p_locked_mem
;
5870 zone_proj0
->kpj_data
.kpd_locked_mem
+= pp
->p_locked_mem
;
5871 zone
->zone_max_swap
+= swap
;
5872 mutex_exit(&zone
->zone_mem_lock
);
5874 mutex_enter(&(zone_proj0
->kpj_data
.kpd_crypto_lock
));
5875 zone_proj0
->kpj_data
.kpd_crypto_mem
+= pp
->p_crypto_mem
;
5876 mutex_exit(&(zone_proj0
->kpj_data
.kpd_crypto_lock
));
5878 /* remove lwps and process from proc's old zone and old project */
5879 mutex_enter(&pp
->p_zone
->zone_nlwps_lock
);
5880 pp
->p_zone
->zone_nlwps
-= pp
->p_lwpcnt
;
5881 pp
->p_task
->tk_proj
->kpj_nlwps
-= pp
->p_lwpcnt
;
5882 pp
->p_task
->tk_proj
->kpj_nprocs
--;
5883 pp
->p_zone
->zone_nprocs
--;
5884 mutex_exit(&pp
->p_zone
->zone_nlwps_lock
);
5886 mutex_enter(&pp
->p_zone
->zone_mem_lock
);
5887 pp
->p_zone
->zone_locked_mem
-= pp
->p_locked_mem
;
5888 pp
->p_task
->tk_proj
->kpj_data
.kpd_locked_mem
-= pp
->p_locked_mem
;
5889 pp
->p_zone
->zone_max_swap
-= swap
;
5890 mutex_exit(&pp
->p_zone
->zone_mem_lock
);
5892 mutex_enter(&(pp
->p_task
->tk_proj
->kpj_data
.kpd_crypto_lock
));
5893 pp
->p_task
->tk_proj
->kpj_data
.kpd_crypto_mem
-= pp
->p_crypto_mem
;
5894 mutex_exit(&(pp
->p_task
->tk_proj
->kpj_data
.kpd_crypto_lock
));
5896 pp
->p_flag
|= SZONETOP
;
5898 mutex_exit(&pp
->p_lock
);
5899 AS_LOCK_EXIT(pp
->p_as
);
5902 * Joining the zone cannot fail from now on.
5904 * This means that a lot of the following code can be commonized and
5905 * shared with zsched().
5909 * If the process contract fmri was inherited, we need to
5910 * flag this so that any contract status will not leak
5911 * extra zone information, svc_fmri in this case
5913 if (ctp
->conp_svc_ctid
!= ct
->ct_id
) {
5914 mutex_enter(&ct
->ct_lock
);
5915 ctp
->conp_svc_zone_enter
= ct
->ct_id
;
5916 mutex_exit(&ct
->ct_lock
);
5920 * Reset the encapsulating process contract's zone.
5922 ASSERT(ct
->ct_mzuniqid
== GLOBAL_ZONEUNIQID
);
5923 contract_setzuniqid(ct
, zone
->zone_uniqid
);
5926 * Create a new task and associate the process with the project keyed
5927 * by (projid,zoneid).
5929 * We might as well be in project 0; the global zone's projid doesn't
5930 * make much sense in a zone anyhow.
5932 * This also increments zone_ntasks, and returns with p_lock held.
5934 tk
= task_create(0, zone
);
5935 oldtk
= task_join(tk
, 0);
5936 mutex_exit(&cpu_lock
);
5939 * call RCTLOP_SET functions on this proc
5941 e
.rcep_p
.zone
= zone
;
5942 e
.rcep_t
= RCENTITY_ZONE
;
5943 (void) rctl_set_dup(NULL
, NULL
, pp
, &e
, zone
->zone_rctls
, NULL
,
5945 mutex_exit(&pp
->p_lock
);
5948 * We don't need to hold any of zsched's locks here; not only do we know
5949 * the process and zone aren't going away, we know its session isn't
5952 * By joining zsched's session here, we mimic the behavior in the
5953 * global zone of init's sid being the pid of sched. We extend this
5954 * to all zlogin-like zone_enter()'ing processes as well.
5956 mutex_enter(&pidlock
);
5957 sp
= zone
->zone_zsched
->p_sessp
;
5958 sess_hold(zone
->zone_zsched
);
5959 mutex_enter(&pp
->p_lock
);
5961 sess_rele(pp
->p_sessp
, B_TRUE
);
5963 pgjoin(pp
, zone
->zone_zsched
->p_pidp
);
5966 * If any threads are scheduled to be placed on zone wait queue they
5967 * should abandon the idea since the wait queue is changing.
5968 * We need to be holding pidlock & p_lock to do this.
5970 if ((t
= pp
->p_tlist
) != NULL
) {
5974 * Kick this thread so that he doesn't sit
5975 * on a wrong wait queue.
5980 if (t
->t_schedflag
& TS_ANYWAITQ
)
5981 t
->t_schedflag
&= ~ TS_ANYWAITQ
;
5984 } while ((t
= t
->t_forw
) != pp
->p_tlist
);
5988 * If there is a default scheduling class for the zone and it is not
5989 * the class we are currently in, change all of the threads in the
5990 * process to the new class. We need to be holding pidlock & p_lock
5991 * when we call parmsset so this is a good place to do it.
5993 if (zone
->zone_defaultcid
> 0 &&
5994 zone
->zone_defaultcid
!= curthread
->t_cid
) {
5997 pcparms
.pc_cid
= zone
->zone_defaultcid
;
5998 pcparms
.pc_clparms
[0] = 0;
6001 * If setting the class fails, we still want to enter the zone.
6003 if ((t
= pp
->p_tlist
) != NULL
) {
6005 (void) parmsset(&pcparms
, t
);
6006 } while ((t
= t
->t_forw
) != pp
->p_tlist
);
6010 mutex_exit(&pp
->p_lock
);
6011 mutex_exit(&pidlock
);
6013 mutex_exit(&zonehash_lock
);
6015 * We're firmly in the zone; let pools progress.
6020 * We don't need to retain a hold on the zone since we already
6021 * incremented zone_ntasks, so the zone isn't going anywhere.
6028 vp
= zone
->zone_rootvp
;
6029 zone_chdir(vp
, &PTOU(pp
)->u_cdir
, pp
);
6030 zone_chdir(vp
, &PTOU(pp
)->u_rdir
, pp
);
6033 * Change process credentials
6036 mutex_enter(&pp
->p_crlock
);
6038 crcopy_to(cr
, newcr
);
6039 crsetzone(newcr
, zone
);
6043 * Restrict all process privilege sets to zone limit
6045 priv_intersect(zone
->zone_privset
, &CR_PPRIV(newcr
));
6046 priv_intersect(zone
->zone_privset
, &CR_EPRIV(newcr
));
6047 priv_intersect(zone
->zone_privset
, &CR_IPRIV(newcr
));
6048 priv_intersect(zone
->zone_privset
, &CR_LPRIV(newcr
));
6049 mutex_exit(&pp
->p_crlock
);
6053 * Adjust upcount to reflect zone entry.
6055 uid
= crgetruid(newcr
);
6056 mutex_enter(&pidlock
);
6057 upcount_dec(uid
, GLOBAL_ZONEID
);
6058 upcount_inc(uid
, zoneid
);
6059 mutex_exit(&pidlock
);
6062 * Set up core file path and content.
6064 set_core_defaults();
6068 * Let the other lwps continue.
6070 mutex_enter(&pp
->p_lock
);
6071 if (curthread
!= pp
->p_agenttp
)
6073 mutex_exit(&pp
->p_lock
);
6075 return (err
!= 0 ? set_errno(err
) : 0);
6079 * Systemcall entry point for zone_list(2).
6081 * Processes running in a (non-global) zone only see themselves.
6082 * On labeled systems, they see all zones whose label they dominate.
6085 zone_list(zoneid_t
*zoneidlist
, uint_t
*numzones
)
6088 zone_t
*zone
, *myzone
;
6089 uint_t user_nzones
, real_nzones
;
6093 if (copyin(numzones
, &user_nzones
, sizeof (uint_t
)) != 0)
6094 return (set_errno(EFAULT
));
6096 myzone
= curproc
->p_zone
;
6097 if (myzone
!= global_zone
) {
6100 if (!is_system_labeled()) {
6101 /* just return current zone */
6102 real_nzones
= domi_nzones
= 1;
6103 zoneids
= kmem_alloc(sizeof (zoneid_t
), KM_SLEEP
);
6104 zoneids
[0] = myzone
->zone_id
;
6106 /* return all zones that are dominated */
6107 mutex_enter(&zonehash_lock
);
6108 real_nzones
= zonecount
;
6110 if (real_nzones
> 0) {
6111 zoneids
= kmem_alloc(real_nzones
*
6112 sizeof (zoneid_t
), KM_SLEEP
);
6113 mybslab
= label2bslabel(myzone
->zone_slabel
);
6114 for (zone
= list_head(&zone_active
);
6116 zone
= list_next(&zone_active
, zone
)) {
6117 if (zone
->zone_id
== GLOBAL_ZONEID
)
6119 if (zone
!= myzone
&&
6120 (zone
->zone_flags
& ZF_IS_SCRATCH
))
6123 * Note that a label always dominates
6124 * itself, so myzone is always included
6127 if (bldominates(mybslab
,
6128 label2bslabel(zone
->zone_slabel
))) {
6129 zoneids
[domi_nzones
++] =
6134 mutex_exit(&zonehash_lock
);
6137 mutex_enter(&zonehash_lock
);
6138 real_nzones
= zonecount
;
6140 if (real_nzones
> 0) {
6141 zoneids
= kmem_alloc(real_nzones
* sizeof (zoneid_t
),
6143 for (zone
= list_head(&zone_active
); zone
!= NULL
;
6144 zone
= list_next(&zone_active
, zone
))
6145 zoneids
[domi_nzones
++] = zone
->zone_id
;
6146 ASSERT(domi_nzones
== real_nzones
);
6148 mutex_exit(&zonehash_lock
);
6152 * If user has allocated space for fewer entries than we found, then
6153 * return only up to his limit. Either way, tell him exactly how many
6156 if (domi_nzones
< user_nzones
)
6157 user_nzones
= domi_nzones
;
6159 if (copyout(&domi_nzones
, numzones
, sizeof (uint_t
)) != 0) {
6161 } else if (zoneidlist
!= NULL
&& user_nzones
!= 0) {
6162 if (copyout(zoneids
, zoneidlist
,
6163 user_nzones
* sizeof (zoneid_t
)) != 0)
6167 if (real_nzones
> 0)
6168 kmem_free(zoneids
, real_nzones
* sizeof (zoneid_t
));
6171 return (set_errno(error
));
6177 * Systemcall entry point for zone_lookup(2).
6179 * Non-global zones are only able to see themselves and (on labeled systems)
6180 * the zones they dominate.
6183 zone_lookup(const char *zone_name
)
6190 if (zone_name
== NULL
) {
6191 /* return caller's zone id */
6192 return (getzoneid());
6195 kname
= kmem_zalloc(ZONENAME_MAX
, KM_SLEEP
);
6196 if ((err
= copyinstr(zone_name
, kname
, ZONENAME_MAX
, NULL
)) != 0) {
6197 kmem_free(kname
, ZONENAME_MAX
);
6198 return (set_errno(err
));
6201 mutex_enter(&zonehash_lock
);
6202 zone
= zone_find_all_by_name(kname
);
6203 kmem_free(kname
, ZONENAME_MAX
);
6205 * In a non-global zone, can only lookup global and own name.
6206 * In Trusted Extensions zone label dominance rules apply.
6209 zone_status_get(zone
) < ZONE_IS_READY
||
6210 !zone_list_access(zone
)) {
6211 mutex_exit(&zonehash_lock
);
6212 return (set_errno(EINVAL
));
6214 zoneid
= zone
->zone_id
;
6215 mutex_exit(&zonehash_lock
);
6221 zone_version(int *version_arg
)
6223 int version
= ZONE_SYSCALL_API_VERSION
;
6225 if (copyout(&version
, version_arg
, sizeof (int)) != 0)
6226 return (set_errno(EFAULT
));
6232 zone(int cmd
, void *arg1
, void *arg2
, void *arg3
, void *arg4
)
6239 if (get_udatamodel() == DATAMODEL_NATIVE
) {
6240 if (copyin(arg1
, &zs
, sizeof (zone_def
))) {
6241 return (set_errno(EFAULT
));
6244 #ifdef _SYSCALL32_IMPL
6247 if (copyin(arg1
, &zs32
, sizeof (zone_def32
))) {
6248 return (set_errno(EFAULT
));
6251 (const char *)(unsigned long)zs32
.zone_name
;
6253 (const char *)(unsigned long)zs32
.zone_root
;
6255 (const struct priv_set
*)
6256 (unsigned long)zs32
.zone_privs
;
6257 zs
.zone_privssz
= zs32
.zone_privssz
;
6258 zs
.rctlbuf
= (caddr_t
)(unsigned long)zs32
.rctlbuf
;
6259 zs
.rctlbufsz
= zs32
.rctlbufsz
;
6260 zs
.zfsbuf
= (caddr_t
)(unsigned long)zs32
.zfsbuf
;
6261 zs
.zfsbufsz
= zs32
.zfsbufsz
;
6263 (int *)(unsigned long)zs32
.extended_error
;
6264 zs
.match
= zs32
.match
;
6266 zs
.label
= (const bslabel_t
*)(uintptr_t)zs32
.label
;
6267 zs
.flags
= zs32
.flags
;
6269 panic("get_udatamodel() returned bogus result\n");
6273 return (zone_create(zs
.zone_name
, zs
.zone_root
,
6274 zs
.zone_privs
, zs
.zone_privssz
,
6275 (caddr_t
)zs
.rctlbuf
, zs
.rctlbufsz
,
6276 (caddr_t
)zs
.zfsbuf
, zs
.zfsbufsz
,
6277 zs
.extended_error
, zs
.match
, zs
.doi
,
6278 zs
.label
, zs
.flags
));
6280 return (zone_boot((zoneid_t
)(uintptr_t)arg1
));
6282 return (zone_destroy((zoneid_t
)(uintptr_t)arg1
));
6284 return (zone_getattr((zoneid_t
)(uintptr_t)arg1
,
6285 (int)(uintptr_t)arg2
, arg3
, (size_t)arg4
));
6287 return (zone_setattr((zoneid_t
)(uintptr_t)arg1
,
6288 (int)(uintptr_t)arg2
, arg3
, (size_t)arg4
));
6290 return (zone_enter((zoneid_t
)(uintptr_t)arg1
));
6292 return (zone_list((zoneid_t
*)arg1
, (uint_t
*)arg2
));
6294 return (zone_shutdown((zoneid_t
)(uintptr_t)arg1
));
6296 return (zone_lookup((const char *)arg1
));
6298 return (zone_version((int *)arg1
));
6299 case ZONE_ADD_DATALINK
:
6300 return (zone_add_datalink((zoneid_t
)(uintptr_t)arg1
,
6301 (datalink_id_t
)(uintptr_t)arg2
));
6302 case ZONE_DEL_DATALINK
:
6303 return (zone_remove_datalink((zoneid_t
)(uintptr_t)arg1
,
6304 (datalink_id_t
)(uintptr_t)arg2
));
6305 case ZONE_CHECK_DATALINK
: {
6307 boolean_t need_copyout
;
6309 if (copyin(arg1
, &zoneid
, sizeof (zoneid
)) != 0)
6311 need_copyout
= (zoneid
== ALL_ZONES
);
6312 err
= zone_check_datalink(&zoneid
,
6313 (datalink_id_t
)(uintptr_t)arg2
);
6314 if (err
== 0 && need_copyout
) {
6315 if (copyout(&zoneid
, arg1
, sizeof (zoneid
)) != 0)
6318 return (err
== 0 ? 0 : set_errno(err
));
6320 case ZONE_LIST_DATALINK
:
6321 return (zone_list_datalink((zoneid_t
)(uintptr_t)arg1
,
6322 (int *)arg2
, (datalink_id_t
*)(uintptr_t)arg3
));
6324 return (set_errno(EINVAL
));
6334 zone_lookup_door(const char *zone_name
, door_handle_t
*doorp
)
6340 buflen
= sizeof (ZONE_DOOR_PATH
) + strlen(zone_name
);
6341 buf
= kmem_alloc(buflen
, KM_SLEEP
);
6342 (void) snprintf(buf
, buflen
, ZONE_DOOR_PATH
, zone_name
);
6343 error
= door_ki_open(buf
, doorp
);
6344 kmem_free(buf
, buflen
);
6349 zone_release_door(door_handle_t
*doorp
)
6351 door_ki_rele(*doorp
);
6356 zone_ki_call_zoneadmd(struct zarg
*zargp
)
6358 door_handle_t door
= NULL
;
6359 door_arg_t darg
, save_arg
;
6361 size_t zone_namelen
;
6372 kmem_free(zargp
, sizeof (*zargp
));
6374 zone_namelen
= strlen(zone
->zone_name
) + 1;
6375 zone_name
= kmem_alloc(zone_namelen
, KM_SLEEP
);
6376 bcopy(zone
->zone_name
, zone_name
, zone_namelen
);
6377 zoneid
= zone
->zone_id
;
6378 uniqid
= zone
->zone_uniqid
;
6380 * zoneadmd may be down, but at least we can empty out the zone.
6381 * We can ignore the return value of zone_empty() since we're called
6382 * from a kernel thread and know we won't be delivered any signals.
6384 ASSERT(curproc
== &p0
);
6385 (void) zone_empty(zone
);
6386 ASSERT(zone_status_get(zone
) >= ZONE_IS_EMPTY
);
6389 size
= sizeof (arg
);
6390 darg
.rbuf
= (char *)&arg
;
6391 darg
.data_ptr
= (char *)&arg
;
6393 darg
.data_size
= size
;
6394 darg
.desc_ptr
= NULL
;
6399 * Since we're not holding a reference to the zone, any number of
6400 * things can go wrong, including the zone disappearing before we get a
6401 * chance to talk to zoneadmd.
6403 for (retry
= 0; /* forever */; retry
++) {
6405 (error
= zone_lookup_door(zone_name
, &door
)) != 0) {
6408 ASSERT(door
!= NULL
);
6410 if ((error
= door_ki_upcall_limited(door
, &darg
, NULL
,
6411 SIZE_MAX
, 0)) == 0) {
6417 case EAGAIN
: /* process may be forking */
6419 * Back off for a bit
6423 zone_release_door(&door
);
6424 if (zone_lookup_door(zone_name
, &door
) != 0) {
6426 * zoneadmd may be dead, but it may come back to
6434 "zone_ki_call_zoneadmd: door_ki_upcall error %d\n",
6440 * If this isn't the same zone_t that we originally had in mind,
6441 * then this is the same as if two kadmin requests come in at
6442 * the same time: the first one wins. This means we lose, so we
6445 if ((zone
= zone_find_by_id(zoneid
)) == NULL
) {
6447 * Problem is solved.
6451 if (zone
->zone_uniqid
!= uniqid
) {
6459 * We could zone_status_timedwait(), but there doesn't seem to
6460 * be much point in doing that (plus, it would mean that
6461 * zone_free() isn't called until this thread exits).
6469 zone_release_door(&door
);
6471 kmem_free(zone_name
, zone_namelen
);
6476 * Entry point for uadmin() to tell the zone to go away or reboot. Analog to
6477 * kadmin(). The caller is a process in the zone.
6479 * In order to shutdown the zone, we will hand off control to zoneadmd
6480 * (running in the global zone) via a door. We do a half-hearted job at
6481 * killing all processes in the zone, create a kernel thread to contact
6482 * zoneadmd, and make note of the "uniqid" of the zone. The uniqid is
6483 * a form of generation number used to let zoneadmd (as well as
6484 * zone_destroy()) know exactly which zone they're re talking about.
6487 zone_kadmin(int cmd
, int fcn
, const char *mdep
, cred_t
*credp
)
6493 zone
= curproc
->p_zone
;
6494 ASSERT(getzoneid() != GLOBAL_ZONEID
);
6525 ASSERT(cmd
!= A_SWAPCTL
); /* handled by uadmin() */
6529 if (secpolicy_zone_admin(credp
, B_FALSE
))
6531 mutex_enter(&zone_status_lock
);
6534 * zone_status can't be ZONE_IS_EMPTY or higher since curproc
6537 ASSERT(zone_status_get(zone
) < ZONE_IS_EMPTY
);
6538 if (zone_status_get(zone
) > ZONE_IS_RUNNING
) {
6540 * This zone is already on its way down.
6542 mutex_exit(&zone_status_lock
);
6546 * Prevent future zone_enter()s
6548 zone_status_set(zone
, ZONE_IS_SHUTTING_DOWN
);
6549 mutex_exit(&zone_status_lock
);
6552 * Kill everyone now and call zoneadmd later.
6553 * zone_ki_call_zoneadmd() will do a more thorough job of this
6556 killall(zone
->zone_id
);
6558 * Now, create the thread to contact zoneadmd and do the rest of the
6559 * work. This thread can't be created in our zone otherwise
6560 * zone_destroy() would deadlock.
6562 zargp
= kmem_zalloc(sizeof (*zargp
), KM_SLEEP
);
6563 zargp
->arg
.cmd
= zcmd
;
6564 zargp
->arg
.uniqid
= zone
->zone_uniqid
;
6566 (void) strcpy(zargp
->arg
.locale
, "C");
6567 /* mdep was already copied in for us by uadmin */
6569 (void) strlcpy(zargp
->arg
.bootbuf
, mdep
,
6570 sizeof (zargp
->arg
.bootbuf
));
6573 (void) thread_create(NULL
, 0, zone_ki_call_zoneadmd
, zargp
, 0, &p0
,
6574 TS_RUN
, minclsyspri
);
6575 exit(CLD_EXITED
, 0);
6581 * Entry point so kadmin(A_SHUTDOWN, ...) can set the global zone's
6582 * status to ZONE_IS_SHUTTING_DOWN.
6584 * This function also shuts down all running zones to ensure that they won't
6585 * fork new processes.
6588 zone_shutdown_global(void)
6590 zone_t
*current_zonep
;
6592 ASSERT(INGLOBALZONE(curproc
));
6593 mutex_enter(&zonehash_lock
);
6594 mutex_enter(&zone_status_lock
);
6596 /* Modify the global zone's status first. */
6597 ASSERT(zone_status_get(global_zone
) == ZONE_IS_RUNNING
);
6598 zone_status_set(global_zone
, ZONE_IS_SHUTTING_DOWN
);
6601 * Now change the states of all running zones to ZONE_IS_SHUTTING_DOWN.
6602 * We don't mark all zones with ZONE_IS_SHUTTING_DOWN because doing so
6603 * could cause assertions to fail (e.g., assertions about a zone's
6604 * state during initialization, readying, or booting) or produce races.
6605 * We'll let threads continue to initialize and ready new zones: they'll
6606 * fail to boot the new zones when they see that the global zone is
6609 for (current_zonep
= list_head(&zone_active
); current_zonep
!= NULL
;
6610 current_zonep
= list_next(&zone_active
, current_zonep
)) {
6611 if (zone_status_get(current_zonep
) == ZONE_IS_RUNNING
)
6612 zone_status_set(current_zonep
, ZONE_IS_SHUTTING_DOWN
);
6614 mutex_exit(&zone_status_lock
);
6615 mutex_exit(&zonehash_lock
);
6619 * Returns true if the named dataset is visible in the current zone.
6620 * The 'write' parameter is set to 1 if the dataset is also writable.
6623 zone_dataset_visible(const char *dataset
, int *write
)
6625 static int zfstype
= -1;
6628 zone_t
*zone
= curproc
->p_zone
;
6629 const char *name
= NULL
;
6632 if (dataset
[0] == '\0')
6636 * Walk the list once, looking for datasets which match exactly, or
6637 * specify a dataset underneath an exported dataset. If found, return
6638 * true and note that it is writable.
6640 for (zd
= list_head(&zone
->zone_datasets
); zd
!= NULL
;
6641 zd
= list_next(&zone
->zone_datasets
, zd
)) {
6643 len
= strlen(zd
->zd_dataset
);
6644 if (strlen(dataset
) >= len
&&
6645 bcmp(dataset
, zd
->zd_dataset
, len
) == 0 &&
6646 (dataset
[len
] == '\0' || dataset
[len
] == '/' ||
6647 dataset
[len
] == '@')) {
6655 * Walk the list a second time, searching for datasets which are parents
6656 * of exported datasets. These should be visible, but read-only.
6658 * Note that we also have to support forms such as 'pool/dataset/', with
6661 for (zd
= list_head(&zone
->zone_datasets
); zd
!= NULL
;
6662 zd
= list_next(&zone
->zone_datasets
, zd
)) {
6664 len
= strlen(dataset
);
6665 if (dataset
[len
- 1] == '/')
6666 len
--; /* Ignore trailing slash */
6667 if (len
< strlen(zd
->zd_dataset
) &&
6668 bcmp(dataset
, zd
->zd_dataset
, len
) == 0 &&
6669 zd
->zd_dataset
[len
] == '/') {
6677 * We reach here if the given dataset is not found in the zone_dataset
6678 * list. Check if this dataset was added as a filesystem (ie. "add fs")
6679 * instead of delegation. For this we search for the dataset in the
6680 * zone_vfslist of this zone. If found, return true and note that it is
6685 * Initialize zfstype if it is not initialized yet.
6687 if (zfstype
== -1) {
6688 struct vfssw
*vswp
= vfs_getvfssw("zfs");
6689 zfstype
= vswp
- vfssw
;
6690 vfs_unrefvfssw(vswp
);
6693 vfs_list_read_lock();
6694 vfsp
= zone
->zone_vfslist
;
6697 if (vfsp
->vfs_fstype
== zfstype
) {
6698 name
= refstr_value(vfsp
->vfs_resource
);
6701 * Check if we have an exact match.
6703 if (strcmp(dataset
, name
) == 0) {
6710 * We need to check if we are looking for parents of
6711 * a dataset. These should be visible, but read-only.
6713 len
= strlen(dataset
);
6714 if (dataset
[len
- 1] == '/')
6717 if (len
< strlen(name
) &&
6718 bcmp(dataset
, name
, len
) == 0 && name
[len
] == '/') {
6725 vfsp
= vfsp
->vfs_zone_next
;
6726 } while (vfsp
!= zone
->zone_vfslist
);
6733 * zone_find_by_any_path() -
6735 * kernel-private routine similar to zone_find_by_path(), but which
6736 * effectively compares against zone paths rather than zonerootpath
6737 * (i.e., the last component of zonerootpaths, which should be "root/",
6738 * are not compared.) This is done in order to accurately identify all
6739 * paths, whether zone-visible or not, including those which are parallel
6740 * to /root/, such as /dev/, /home/, etc...
6742 * If the specified path does not fall under any zone path then global
6745 * The treat_abs parameter indicates whether the path should be treated as
6746 * an absolute path although it does not begin with "/". (This supports
6747 * nfs mount syntax such as host:any/path.)
6749 * The caller is responsible for zone_rele of the returned zone.
6752 zone_find_by_any_path(const char *path
, boolean_t treat_abs
)
6755 int path_offset
= 0;
6758 zone_hold(global_zone
);
6759 return (global_zone
);
6767 mutex_enter(&zonehash_lock
);
6768 for (zone
= list_head(&zone_active
); zone
!= NULL
;
6769 zone
= list_next(&zone_active
, zone
)) {
6772 char *rootpath_start
;
6774 if (zone
== global_zone
) /* skip global zone */
6777 /* scan backwards to find start of last component */
6778 c
= zone
->zone_rootpath
+ zone
->zone_rootpathlen
- 2;
6781 } while (*c
!= '/');
6783 pathlen
= c
- zone
->zone_rootpath
+ 1 - path_offset
;
6784 rootpath_start
= (zone
->zone_rootpath
+ path_offset
);
6785 if (strncmp(path
, rootpath_start
, pathlen
) == 0)
6791 mutex_exit(&zonehash_lock
);
6796 * Finds a zone_dl_t with the given linkid in the given zone. Returns the
6797 * zone_dl_t pointer if found, and NULL otherwise.
6800 zone_find_dl(zone_t
*zone
, datalink_id_t linkid
)
6804 ASSERT(mutex_owned(&zone
->zone_lock
));
6805 for (zdl
= list_head(&zone
->zone_dl_list
); zdl
!= NULL
;
6806 zdl
= list_next(&zone
->zone_dl_list
, zdl
)) {
6807 if (zdl
->zdl_id
== linkid
)
6814 zone_dl_exists(zone_t
*zone
, datalink_id_t linkid
)
6818 mutex_enter(&zone
->zone_lock
);
6819 exists
= (zone_find_dl(zone
, linkid
) != NULL
);
6820 mutex_exit(&zone
->zone_lock
);
6825 * Add an data link name for the zone.
6828 zone_add_datalink(zoneid_t zoneid
, datalink_id_t linkid
)
6834 if ((thiszone
= zone_find_by_id(zoneid
)) == NULL
)
6835 return (set_errno(ENXIO
));
6837 /* Verify that the datalink ID doesn't already belong to a zone. */
6838 mutex_enter(&zonehash_lock
);
6839 for (zone
= list_head(&zone_active
); zone
!= NULL
;
6840 zone
= list_next(&zone_active
, zone
)) {
6841 if (zone_dl_exists(zone
, linkid
)) {
6842 mutex_exit(&zonehash_lock
);
6843 zone_rele(thiszone
);
6844 return (set_errno((zone
== thiszone
) ? EEXIST
: EPERM
));
6848 zdl
= kmem_zalloc(sizeof (*zdl
), KM_SLEEP
);
6849 zdl
->zdl_id
= linkid
;
6850 zdl
->zdl_net
= NULL
;
6851 mutex_enter(&thiszone
->zone_lock
);
6852 list_insert_head(&thiszone
->zone_dl_list
, zdl
);
6853 mutex_exit(&thiszone
->zone_lock
);
6854 mutex_exit(&zonehash_lock
);
6855 zone_rele(thiszone
);
6860 zone_remove_datalink(zoneid_t zoneid
, datalink_id_t linkid
)
6866 if ((zone
= zone_find_by_id(zoneid
)) == NULL
)
6867 return (set_errno(EINVAL
));
6869 mutex_enter(&zone
->zone_lock
);
6870 if ((zdl
= zone_find_dl(zone
, linkid
)) == NULL
) {
6873 list_remove(&zone
->zone_dl_list
, zdl
);
6874 nvlist_free(zdl
->zdl_net
);
6875 kmem_free(zdl
, sizeof (zone_dl_t
));
6877 mutex_exit(&zone
->zone_lock
);
6879 return (err
== 0 ? 0 : set_errno(err
));
6883 * Using the zoneidp as ALL_ZONES, we can lookup which zone has been assigned
6884 * the linkid. Otherwise we just check if the specified zoneidp has been
6885 * assigned the supplied linkid.
6888 zone_check_datalink(zoneid_t
*zoneidp
, datalink_id_t linkid
)
6893 if (*zoneidp
!= ALL_ZONES
) {
6894 if ((zone
= zone_find_by_id(*zoneidp
)) != NULL
) {
6895 if (zone_dl_exists(zone
, linkid
))
6902 mutex_enter(&zonehash_lock
);
6903 for (zone
= list_head(&zone_active
); zone
!= NULL
;
6904 zone
= list_next(&zone_active
, zone
)) {
6905 if (zone_dl_exists(zone
, linkid
)) {
6906 *zoneidp
= zone
->zone_id
;
6911 mutex_exit(&zonehash_lock
);
6916 * Get the list of datalink IDs assigned to a zone.
6918 * On input, *nump is the number of datalink IDs that can fit in the supplied
6919 * idarray. Upon return, *nump is either set to the number of datalink IDs
6920 * that were placed in the array if the array was large enough, or to the
6921 * number of datalink IDs that the function needs to place in the array if the
6922 * array is too small.
6925 zone_list_datalink(zoneid_t zoneid
, int *nump
, datalink_id_t
*idarray
)
6927 uint_t num
, dlcount
;
6930 datalink_id_t
*idptr
= idarray
;
6932 if (copyin(nump
, &dlcount
, sizeof (dlcount
)) != 0)
6933 return (set_errno(EFAULT
));
6934 if ((zone
= zone_find_by_id(zoneid
)) == NULL
)
6935 return (set_errno(ENXIO
));
6938 mutex_enter(&zone
->zone_lock
);
6939 for (zdl
= list_head(&zone
->zone_dl_list
); zdl
!= NULL
;
6940 zdl
= list_next(&zone
->zone_dl_list
, zdl
)) {
6942 * If the list is bigger than what the caller supplied, just
6943 * count, don't do copyout.
6945 if (++num
> dlcount
)
6947 if (copyout(&zdl
->zdl_id
, idptr
, sizeof (*idptr
)) != 0) {
6948 mutex_exit(&zone
->zone_lock
);
6950 return (set_errno(EFAULT
));
6954 mutex_exit(&zone
->zone_lock
);
6957 /* Increased or decreased, caller should be notified. */
6958 if (num
!= dlcount
) {
6959 if (copyout(&num
, nump
, sizeof (num
)) != 0)
6960 return (set_errno(EFAULT
));
6966 * Public interface for looking up a zone by zoneid. It's a customized version
6967 * for netstack_zone_create(). It can only be called from the zsd create
6968 * callbacks, since it doesn't have reference on the zone structure hence if
6969 * it is called elsewhere the zone could disappear after the zonehash_lock
6973 * 1. Doesn't check the status of the zone.
6974 * 2. It will be called even before zone_init is called, in that case the
6975 * address of zone0 is returned directly, and netstack_zone_create()
6976 * will only assign a value to zone0.zone_netstack, won't break anything.
6977 * 3. Returns without the zone being held.
6980 zone_find_by_id_nolock(zoneid_t zoneid
)
6984 mutex_enter(&zonehash_lock
);
6985 if (zonehashbyid
== NULL
)
6988 zone
= zone_find_all_by_id(zoneid
);
6989 mutex_exit(&zonehash_lock
);
6994 * Walk the datalinks for a given zone
6997 zone_datalink_walk(zoneid_t zoneid
, int (*cb
)(datalink_id_t
, void *),
7002 datalink_id_t
*idarray
;
7006 if ((zone
= zone_find_by_id(zoneid
)) == NULL
)
7010 * We first build an array of linkid's so that we can walk these and
7011 * execute the callback with the zone_lock dropped.
7013 mutex_enter(&zone
->zone_lock
);
7014 for (zdl
= list_head(&zone
->zone_dl_list
); zdl
!= NULL
;
7015 zdl
= list_next(&zone
->zone_dl_list
, zdl
)) {
7020 mutex_exit(&zone
->zone_lock
);
7025 idarray
= kmem_alloc(sizeof (datalink_id_t
) * idcount
, KM_NOSLEEP
);
7026 if (idarray
== NULL
) {
7027 mutex_exit(&zone
->zone_lock
);
7032 for (i
= 0, zdl
= list_head(&zone
->zone_dl_list
); zdl
!= NULL
;
7033 i
++, zdl
= list_next(&zone
->zone_dl_list
, zdl
)) {
7034 idarray
[i
] = zdl
->zdl_id
;
7037 mutex_exit(&zone
->zone_lock
);
7039 for (i
= 0; i
< idcount
&& ret
== 0; i
++) {
7040 if ((ret
= (*cb
)(idarray
[i
], data
)) != 0)
7045 kmem_free(idarray
, sizeof (datalink_id_t
) * idcount
);
7050 zone_net_type2name(int type
)
7053 case ZONE_NETWORK_ADDRESS
:
7054 return (ZONE_NET_ADDRNAME
);
7055 case ZONE_NETWORK_DEFROUTER
:
7056 return (ZONE_NET_RTRNAME
);
7063 zone_set_network(zoneid_t zoneid
, zone_net_data_t
*znbuf
)
7069 uint8_t *new = NULL
;
7072 datalink_id_t linkid
= znbuf
->zn_linkid
;
7074 if (secpolicy_zone_config(CRED()) != 0)
7075 return (set_errno(EPERM
));
7077 if (zoneid
== GLOBAL_ZONEID
)
7078 return (set_errno(EINVAL
));
7080 nvname
= zone_net_type2name(znbuf
->zn_type
);
7081 bufsize
= znbuf
->zn_len
;
7082 new = znbuf
->zn_val
;
7084 return (set_errno(EINVAL
));
7086 if ((zone
= zone_find_by_id(zoneid
)) == NULL
) {
7087 return (set_errno(EINVAL
));
7090 mutex_enter(&zone
->zone_lock
);
7091 if ((zdl
= zone_find_dl(zone
, linkid
)) == NULL
) {
7095 if ((nvl
= zdl
->zdl_net
) == NULL
) {
7096 if (nvlist_alloc(&nvl
, NV_UNIQUE_NAME
, KM_SLEEP
)) {
7103 if (nvlist_exists(nvl
, nvname
)) {
7107 err
= nvlist_add_uint8_array(nvl
, nvname
, new, bufsize
);
7110 mutex_exit(&zone
->zone_lock
);
7113 return (set_errno(err
));
7119 zone_get_network(zoneid_t zoneid
, zone_net_data_t
*znbuf
)
7130 datalink_id_t linkid
= znbuf
->zn_linkid
;
7132 if (zoneid
== GLOBAL_ZONEID
)
7133 return (set_errno(EINVAL
));
7135 nvname
= zone_net_type2name(znbuf
->zn_type
);
7136 bufsize
= znbuf
->zn_len
;
7137 buf
= znbuf
->zn_val
;
7140 return (set_errno(EINVAL
));
7141 if ((zone
= zone_find_by_id(zoneid
)) == NULL
)
7142 return (set_errno(EINVAL
));
7144 mutex_enter(&zone
->zone_lock
);
7145 if ((zdl
= zone_find_dl(zone
, linkid
)) == NULL
) {
7149 if ((nvl
= zdl
->zdl_net
) == NULL
|| !nvlist_exists(nvl
, nvname
)) {
7153 err
= nvlist_lookup_uint8_array(nvl
, nvname
, &ptr
, &psize
);
7156 if (psize
> bufsize
) {
7160 znbuf
->zn_len
= psize
;
7161 bcopy(ptr
, buf
, psize
);
7163 mutex_exit(&zone
->zone_lock
);
7166 return (set_errno(err
));