17c478bd9Sstevel@tonic-gate /* 27c478bd9Sstevel@tonic-gate * CDDL HEADER START 37c478bd9Sstevel@tonic-gate * 47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the 519f92332Sml93401 * Common Development and Distribution License (the "License"). 619f92332Sml93401 * You may not use this file except in compliance with the License. 77c478bd9Sstevel@tonic-gate * 87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 117c478bd9Sstevel@tonic-gate * and limitations under the License. 127c478bd9Sstevel@tonic-gate * 137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 187c478bd9Sstevel@tonic-gate * 197c478bd9Sstevel@tonic-gate * CDDL HEADER END 207c478bd9Sstevel@tonic-gate */ 217c478bd9Sstevel@tonic-gate /* 22134a1f4eSCasper H.S. Dik * Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved. 237c478bd9Sstevel@tonic-gate */ 247c478bd9Sstevel@tonic-gate 257c478bd9Sstevel@tonic-gate #include <sys/project.h> 267c478bd9Sstevel@tonic-gate #include <sys/modhash.h> 277c478bd9Sstevel@tonic-gate #include <sys/modctl.h> 287c478bd9Sstevel@tonic-gate #include <sys/kmem.h> 290209230bSgjelinek #include <sys/kstat.h> 307c478bd9Sstevel@tonic-gate #include <sys/atomic.h> 317c478bd9Sstevel@tonic-gate #include <sys/cmn_err.h> 327c478bd9Sstevel@tonic-gate #include <sys/proc.h> 337c478bd9Sstevel@tonic-gate #include <sys/rctl.h> 347c478bd9Sstevel@tonic-gate #include <sys/sunddi.h> 357c478bd9Sstevel@tonic-gate #include <sys/fss.h> 367c478bd9Sstevel@tonic-gate #include <sys/systm.h> 377c478bd9Sstevel@tonic-gate #include <sys/ipc_impl.h> 387c478bd9Sstevel@tonic-gate #include <sys/port_kernel.h> 397c478bd9Sstevel@tonic-gate #include <sys/task.h> 407c478bd9Sstevel@tonic-gate #include <sys/zone.h> 41c97ad5cdSakolb #include <sys/cpucaps.h> 42ddf7fe95Scasper #include <sys/klpd.h> 437c478bd9Sstevel@tonic-gate 447c478bd9Sstevel@tonic-gate int project_hash_size = 64; 457c478bd9Sstevel@tonic-gate static kmutex_t project_hash_lock; 467c478bd9Sstevel@tonic-gate static kmutex_t projects_list_lock; 477c478bd9Sstevel@tonic-gate static mod_hash_t *projects_hash; 487c478bd9Sstevel@tonic-gate static kproject_t *projects_list; 497c478bd9Sstevel@tonic-gate 507c478bd9Sstevel@tonic-gate rctl_hndl_t rc_project_cpu_shares; 51c97ad5cdSakolb rctl_hndl_t rc_project_cpu_cap; 527c478bd9Sstevel@tonic-gate rctl_hndl_t rc_project_nlwps; 53*ff19e029SMenno Lageman rctl_hndl_t rc_project_nprocs; 547c478bd9Sstevel@tonic-gate rctl_hndl_t rc_project_ntasks; 557c478bd9Sstevel@tonic-gate rctl_hndl_t rc_project_msgmni; 567c478bd9Sstevel@tonic-gate rctl_hndl_t rc_project_semmni; 577c478bd9Sstevel@tonic-gate rctl_hndl_t rc_project_shmmax; 587c478bd9Sstevel@tonic-gate rctl_hndl_t rc_project_shmmni; 597c478bd9Sstevel@tonic-gate rctl_hndl_t rc_project_portids; 60c6939658Ssl108498 rctl_hndl_t rc_project_locked_mem; 617c478bd9Sstevel@tonic-gate rctl_hndl_t rc_project_contract; 627c478bd9Sstevel@tonic-gate rctl_hndl_t rc_project_crypto_mem; 637c478bd9Sstevel@tonic-gate 647c478bd9Sstevel@tonic-gate /* 657c478bd9Sstevel@tonic-gate * Dummy structure used when comparing projects. This structure must be kept 667c478bd9Sstevel@tonic-gate * identical to the first two fields of kproject_t. 677c478bd9Sstevel@tonic-gate */ 687c478bd9Sstevel@tonic-gate struct project_zone { 697c478bd9Sstevel@tonic-gate projid_t kpj_id; 707c478bd9Sstevel@tonic-gate zoneid_t kpj_zoneid; 717c478bd9Sstevel@tonic-gate }; 727c478bd9Sstevel@tonic-gate 737c478bd9Sstevel@tonic-gate /* 747c478bd9Sstevel@tonic-gate * Projects 757c478bd9Sstevel@tonic-gate * 767c478bd9Sstevel@tonic-gate * A dictionary of all active projects is maintained by the kernel so that we 777c478bd9Sstevel@tonic-gate * may track project usage and limits. (By an active project, we mean a 787c478bd9Sstevel@tonic-gate * project associated with one or more task, and therefore with one or more 797c478bd9Sstevel@tonic-gate * processes.) We build the dictionary on top of the mod_hash facility, since 807c478bd9Sstevel@tonic-gate * project additions and deletions are relatively rare events. An 817c478bd9Sstevel@tonic-gate * integer-to-pointer mapping is maintained within the hash, representing the 827c478bd9Sstevel@tonic-gate * map from project id to project structure. All projects, including the 837c478bd9Sstevel@tonic-gate * primordial "project 0", are allocated via the project_hold_by_id() 847c478bd9Sstevel@tonic-gate * interface. 857c478bd9Sstevel@tonic-gate * 867c478bd9Sstevel@tonic-gate * Currently, the project contains a reference count; the project ID, which is 877c478bd9Sstevel@tonic-gate * examined by the extended accounting subsystem as well as /proc; a resource 887c478bd9Sstevel@tonic-gate * control set, which contains the allowable values (and actions on exceeding 897c478bd9Sstevel@tonic-gate * those values) for controlled project-level resources on the system; and a 907c478bd9Sstevel@tonic-gate * number of CPU shares, which is used by the fair share scheduling class 917c478bd9Sstevel@tonic-gate * (FSS) to support its proportion-based scheduling algorithm. 927c478bd9Sstevel@tonic-gate * 937c478bd9Sstevel@tonic-gate * Reference counting convention 947c478bd9Sstevel@tonic-gate * The dictionary entry does not itself count as a reference--only references 957c478bd9Sstevel@tonic-gate * outside of the subsystem are tallied. At the drop of the final external 967c478bd9Sstevel@tonic-gate * reference, the project entry is removed. The reference counter keeps 977c478bd9Sstevel@tonic-gate * track of the number of threads *and* tasks within a project. 987c478bd9Sstevel@tonic-gate * 997c478bd9Sstevel@tonic-gate * Locking 1007c478bd9Sstevel@tonic-gate * Walking the doubly-linked project list must be done while holding 1017c478bd9Sstevel@tonic-gate * projects_list_lock. Thus, any dereference of kpj_next or kpj_prev must be 1027c478bd9Sstevel@tonic-gate * under projects_list_lock. 1037c478bd9Sstevel@tonic-gate * 1047c478bd9Sstevel@tonic-gate * If both the hash lock, project_hash_lock, and the list lock are to be 1057c478bd9Sstevel@tonic-gate * acquired, the hash lock is to be acquired first. 1067c478bd9Sstevel@tonic-gate */ 1077c478bd9Sstevel@tonic-gate 108*ff19e029SMenno Lageman static void project_kstat_create(kproject_t *pj, zone_t *zone); 1090209230bSgjelinek static void project_kstat_delete(kproject_t *pj); 1107c478bd9Sstevel@tonic-gate 1117c478bd9Sstevel@tonic-gate static void 1127c478bd9Sstevel@tonic-gate project_data_init(kproject_data_t *data) 1137c478bd9Sstevel@tonic-gate { 1147c478bd9Sstevel@tonic-gate /* 1157c478bd9Sstevel@tonic-gate * Initialize subsystem-specific data 1167c478bd9Sstevel@tonic-gate */ 1177c478bd9Sstevel@tonic-gate data->kpd_shmmax = 0; 118824c205fSml93401 data->kpd_ipc.ipcq_shmmni = 0; 119824c205fSml93401 data->kpd_ipc.ipcq_semmni = 0; 120824c205fSml93401 data->kpd_ipc.ipcq_msgmni = 0; 121c6939658Ssl108498 data->kpd_locked_mem = 0; 122c6939658Ssl108498 data->kpd_locked_mem_ctl = UINT64_MAX; 1237c478bd9Sstevel@tonic-gate data->kpd_contract = 0; 1247c478bd9Sstevel@tonic-gate data->kpd_crypto_mem = 0; 125db1cde31Skrishna data->kpd_crypto_mem_ctl = UINT64_MAX; 1260209230bSgjelinek data->kpd_lockedmem_kstat = NULL; 127*ff19e029SMenno Lageman data->kpd_nprocs_kstat = NULL; 1287c478bd9Sstevel@tonic-gate } 1297c478bd9Sstevel@tonic-gate 1307c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 1317c478bd9Sstevel@tonic-gate static uint_t 1327c478bd9Sstevel@tonic-gate project_hash_by_id(void *hash_data, mod_hash_key_t key) 1337c478bd9Sstevel@tonic-gate { 1347c478bd9Sstevel@tonic-gate struct project_zone *pz = key; 1357c478bd9Sstevel@tonic-gate uint_t mykey; 1367c478bd9Sstevel@tonic-gate 1377c478bd9Sstevel@tonic-gate /* 1387c478bd9Sstevel@tonic-gate * Merge the zoneid and projectid together to a 32-bit quantity, and 1397c478bd9Sstevel@tonic-gate * then pass that in to the existing idhash. 1407c478bd9Sstevel@tonic-gate */ 1417c478bd9Sstevel@tonic-gate mykey = (pz->kpj_zoneid << 16) | pz->kpj_id; 1427c478bd9Sstevel@tonic-gate return (mod_hash_byid(hash_data, (mod_hash_key_t)(uintptr_t)mykey)); 1437c478bd9Sstevel@tonic-gate } 1447c478bd9Sstevel@tonic-gate 1457c478bd9Sstevel@tonic-gate static int 1467c478bd9Sstevel@tonic-gate project_hash_key_cmp(mod_hash_key_t key1, mod_hash_key_t key2) 1477c478bd9Sstevel@tonic-gate { 1487c478bd9Sstevel@tonic-gate struct project_zone *pz1 = key1, *pz2 = key2; 1497c478bd9Sstevel@tonic-gate int retval; 1507c478bd9Sstevel@tonic-gate 1517c478bd9Sstevel@tonic-gate return ((int)((retval = pz1->kpj_id - pz2->kpj_id) != 0 ? retval : 1527c478bd9Sstevel@tonic-gate pz1->kpj_zoneid - pz2->kpj_zoneid)); 1537c478bd9Sstevel@tonic-gate } 1547c478bd9Sstevel@tonic-gate 1557c478bd9Sstevel@tonic-gate static void 1567c478bd9Sstevel@tonic-gate project_hash_val_dtor(mod_hash_val_t val) 1577c478bd9Sstevel@tonic-gate { 1587c478bd9Sstevel@tonic-gate kproject_t *kp = (kproject_t *)val; 1597c478bd9Sstevel@tonic-gate 1607c478bd9Sstevel@tonic-gate ASSERT(kp->kpj_count == 0); 161c97ad5cdSakolb ASSERT(kp->kpj_cpucap == NULL); 1627c478bd9Sstevel@tonic-gate kmem_free(kp, sizeof (kproject_t)); 1637c478bd9Sstevel@tonic-gate } 1647c478bd9Sstevel@tonic-gate 1657c478bd9Sstevel@tonic-gate /* 1667c478bd9Sstevel@tonic-gate * kproject_t *project_hold(kproject_t *) 1677c478bd9Sstevel@tonic-gate * 1687c478bd9Sstevel@tonic-gate * Overview 1697c478bd9Sstevel@tonic-gate * Record that an additional reference on the indicated project has been 1707c478bd9Sstevel@tonic-gate * taken. 1717c478bd9Sstevel@tonic-gate * 1727c478bd9Sstevel@tonic-gate * Return values 1737c478bd9Sstevel@tonic-gate * A pointer to the indicated project. 1747c478bd9Sstevel@tonic-gate * 1757c478bd9Sstevel@tonic-gate * Caller's context 1767c478bd9Sstevel@tonic-gate * project_hash_lock must not be held across the project_hold() call. 1777c478bd9Sstevel@tonic-gate */ 1787c478bd9Sstevel@tonic-gate kproject_t * 1797c478bd9Sstevel@tonic-gate project_hold(kproject_t *p) 1807c478bd9Sstevel@tonic-gate { 1817c478bd9Sstevel@tonic-gate mutex_enter(&project_hash_lock); 1827c478bd9Sstevel@tonic-gate ASSERT(p != NULL); 1837c478bd9Sstevel@tonic-gate p->kpj_count++; 1847c478bd9Sstevel@tonic-gate ASSERT(p->kpj_count != 0); 1857c478bd9Sstevel@tonic-gate mutex_exit(&project_hash_lock); 1867c478bd9Sstevel@tonic-gate return (p); 1877c478bd9Sstevel@tonic-gate } 1887c478bd9Sstevel@tonic-gate 1897c478bd9Sstevel@tonic-gate /* 1900209230bSgjelinek * kproject_t *project_hold_by_id(projid_t, zone_t *, int) 1917c478bd9Sstevel@tonic-gate * 1927c478bd9Sstevel@tonic-gate * Overview 1937c478bd9Sstevel@tonic-gate * project_hold_by_id() performs a look-up in the dictionary of projects 1940209230bSgjelinek * active on the system by specified project ID + zone and puts a hold on 1957c478bd9Sstevel@tonic-gate * it. The third argument defines the desired behavior in the case when 1967c478bd9Sstevel@tonic-gate * project with given project ID cannot be found: 1977c478bd9Sstevel@tonic-gate * 1987c478bd9Sstevel@tonic-gate * PROJECT_HOLD_INSERT New entry is made in dictionary and the project 1997c478bd9Sstevel@tonic-gate * is added to the global list. 2007c478bd9Sstevel@tonic-gate * 2017c478bd9Sstevel@tonic-gate * PROJECT_HOLD_FIND Return NULL. 2027c478bd9Sstevel@tonic-gate * 2037c478bd9Sstevel@tonic-gate * The project is returned with its reference count incremented by one. 2047c478bd9Sstevel@tonic-gate * A new project derives its resource controls from those of project 0. 2057c478bd9Sstevel@tonic-gate * 2067c478bd9Sstevel@tonic-gate * Return values 2077c478bd9Sstevel@tonic-gate * A pointer to the held project. 2087c478bd9Sstevel@tonic-gate * 2097c478bd9Sstevel@tonic-gate * Caller's context 2107c478bd9Sstevel@tonic-gate * Caller must be in a context suitable for KM_SLEEP allocations. 2117c478bd9Sstevel@tonic-gate */ 2127c478bd9Sstevel@tonic-gate kproject_t * 2130209230bSgjelinek project_hold_by_id(projid_t id, zone_t *zone, int flag) 2147c478bd9Sstevel@tonic-gate { 2157c478bd9Sstevel@tonic-gate kproject_t *spare_p; 2167c478bd9Sstevel@tonic-gate kproject_t *p; 2177c478bd9Sstevel@tonic-gate mod_hash_hndl_t hndl; 2187c478bd9Sstevel@tonic-gate rctl_set_t *set; 2197c478bd9Sstevel@tonic-gate rctl_alloc_gp_t *gp; 2207c478bd9Sstevel@tonic-gate rctl_entity_p_t e; 2217c478bd9Sstevel@tonic-gate struct project_zone pz; 2220209230bSgjelinek boolean_t create = B_FALSE; 2237c478bd9Sstevel@tonic-gate 2247c478bd9Sstevel@tonic-gate pz.kpj_id = id; 2250209230bSgjelinek pz.kpj_zoneid = zone->zone_id; 2267c478bd9Sstevel@tonic-gate 2277c478bd9Sstevel@tonic-gate if (flag == PROJECT_HOLD_FIND) { 2287c478bd9Sstevel@tonic-gate mutex_enter(&project_hash_lock); 2297c478bd9Sstevel@tonic-gate 2307c478bd9Sstevel@tonic-gate if (mod_hash_find(projects_hash, (mod_hash_key_t)&pz, 2317c478bd9Sstevel@tonic-gate (mod_hash_val_t)&p) == MH_ERR_NOTFOUND) 2327c478bd9Sstevel@tonic-gate p = NULL; 2337c478bd9Sstevel@tonic-gate else 2347c478bd9Sstevel@tonic-gate p->kpj_count++; 2357c478bd9Sstevel@tonic-gate 2367c478bd9Sstevel@tonic-gate mutex_exit(&project_hash_lock); 2377c478bd9Sstevel@tonic-gate return (p); 2387c478bd9Sstevel@tonic-gate } 2397c478bd9Sstevel@tonic-gate 2407c478bd9Sstevel@tonic-gate ASSERT(flag == PROJECT_HOLD_INSERT); 2417c478bd9Sstevel@tonic-gate 2427c478bd9Sstevel@tonic-gate spare_p = kmem_zalloc(sizeof (kproject_t), KM_SLEEP); 2437c478bd9Sstevel@tonic-gate set = rctl_set_create(); 2447c478bd9Sstevel@tonic-gate 2457c478bd9Sstevel@tonic-gate gp = rctl_set_init_prealloc(RCENTITY_PROJECT); 2467c478bd9Sstevel@tonic-gate 2477c478bd9Sstevel@tonic-gate (void) mod_hash_reserve(projects_hash, &hndl); 2487c478bd9Sstevel@tonic-gate 2497c478bd9Sstevel@tonic-gate mutex_enter(&curproc->p_lock); 2507c478bd9Sstevel@tonic-gate mutex_enter(&project_hash_lock); 2517c478bd9Sstevel@tonic-gate if (mod_hash_find(projects_hash, (mod_hash_key_t)&pz, 2527c478bd9Sstevel@tonic-gate (mod_hash_val_t *)&p) == MH_ERR_NOTFOUND) { 2530209230bSgjelinek 2547c478bd9Sstevel@tonic-gate p = spare_p; 2557c478bd9Sstevel@tonic-gate p->kpj_id = id; 256c97ad5cdSakolb p->kpj_zone = zone; 2570209230bSgjelinek p->kpj_zoneid = zone->zone_id; 2587c478bd9Sstevel@tonic-gate p->kpj_count = 0; 2597c478bd9Sstevel@tonic-gate p->kpj_shares = 1; 2607c478bd9Sstevel@tonic-gate p->kpj_nlwps = 0; 261*ff19e029SMenno Lageman p->kpj_nprocs = 0; 2627c478bd9Sstevel@tonic-gate p->kpj_ntasks = 0; 2637c478bd9Sstevel@tonic-gate p->kpj_nlwps_ctl = INT_MAX; 264*ff19e029SMenno Lageman p->kpj_nprocs_ctl = INT_MAX; 2657c478bd9Sstevel@tonic-gate p->kpj_ntasks_ctl = INT_MAX; 2667c478bd9Sstevel@tonic-gate project_data_init(&p->kpj_data); 2677c478bd9Sstevel@tonic-gate e.rcep_p.proj = p; 2687c478bd9Sstevel@tonic-gate e.rcep_t = RCENTITY_PROJECT; 2697c478bd9Sstevel@tonic-gate p->kpj_rctls = rctl_set_init(RCENTITY_PROJECT, curproc, &e, 2707c478bd9Sstevel@tonic-gate set, gp); 2717c478bd9Sstevel@tonic-gate mutex_exit(&curproc->p_lock); 2727c478bd9Sstevel@tonic-gate 2737c478bd9Sstevel@tonic-gate if (mod_hash_insert_reserve(projects_hash, (mod_hash_key_t)p, 2747c478bd9Sstevel@tonic-gate (mod_hash_val_t)p, hndl)) 2757c478bd9Sstevel@tonic-gate panic("unable to insert project %d(%p)", id, (void *)p); 2767c478bd9Sstevel@tonic-gate 2777c478bd9Sstevel@tonic-gate /* 2787c478bd9Sstevel@tonic-gate * Insert project into global project list. 2797c478bd9Sstevel@tonic-gate */ 2807c478bd9Sstevel@tonic-gate mutex_enter(&projects_list_lock); 2810209230bSgjelinek if (id != 0 || zone != &zone0) { 2827c478bd9Sstevel@tonic-gate p->kpj_next = projects_list; 2837c478bd9Sstevel@tonic-gate p->kpj_prev = projects_list->kpj_prev; 2847c478bd9Sstevel@tonic-gate p->kpj_prev->kpj_next = p; 2857c478bd9Sstevel@tonic-gate projects_list->kpj_prev = p; 2867c478bd9Sstevel@tonic-gate } else { 2877c478bd9Sstevel@tonic-gate /* 2887c478bd9Sstevel@tonic-gate * Special case: primordial hold on project 0. 2897c478bd9Sstevel@tonic-gate */ 2907c478bd9Sstevel@tonic-gate p->kpj_next = p; 2917c478bd9Sstevel@tonic-gate p->kpj_prev = p; 2927c478bd9Sstevel@tonic-gate projects_list = p; 2937c478bd9Sstevel@tonic-gate } 2947c478bd9Sstevel@tonic-gate mutex_exit(&projects_list_lock); 2950209230bSgjelinek create = B_TRUE; 2967c478bd9Sstevel@tonic-gate } else { 2977c478bd9Sstevel@tonic-gate mutex_exit(&curproc->p_lock); 2987c478bd9Sstevel@tonic-gate mod_hash_cancel(projects_hash, &hndl); 2997c478bd9Sstevel@tonic-gate kmem_free(spare_p, sizeof (kproject_t)); 3007c478bd9Sstevel@tonic-gate rctl_set_free(set); 3017c478bd9Sstevel@tonic-gate } 3027c478bd9Sstevel@tonic-gate 3037c478bd9Sstevel@tonic-gate rctl_prealloc_destroy(gp); 3047c478bd9Sstevel@tonic-gate p->kpj_count++; 3057c478bd9Sstevel@tonic-gate mutex_exit(&project_hash_lock); 3067c478bd9Sstevel@tonic-gate 3070209230bSgjelinek /* 3080209230bSgjelinek * The kstat stores the project's zone name, as zoneid's may change 3090209230bSgjelinek * across reboots. 3100209230bSgjelinek */ 3110209230bSgjelinek if (create == B_TRUE) { 312c97ad5cdSakolb /* 313c97ad5cdSakolb * Inform CPU caps framework of the new project 314c97ad5cdSakolb */ 315c97ad5cdSakolb cpucaps_project_add(p); 316c97ad5cdSakolb /* 317c97ad5cdSakolb * Set up project kstats 318c97ad5cdSakolb */ 319*ff19e029SMenno Lageman project_kstat_create(p, zone); 3200209230bSgjelinek } 3217c478bd9Sstevel@tonic-gate return (p); 3227c478bd9Sstevel@tonic-gate } 3237c478bd9Sstevel@tonic-gate 3247c478bd9Sstevel@tonic-gate /* 3257c478bd9Sstevel@tonic-gate * void project_rele(kproject_t *) 3267c478bd9Sstevel@tonic-gate * 3277c478bd9Sstevel@tonic-gate * Overview 3287c478bd9Sstevel@tonic-gate * Advertise that one external reference to this project is no longer needed. 3297c478bd9Sstevel@tonic-gate * 3307c478bd9Sstevel@tonic-gate * Return values 3317c478bd9Sstevel@tonic-gate * None. 3327c478bd9Sstevel@tonic-gate * 3337c478bd9Sstevel@tonic-gate * Caller's context 3347c478bd9Sstevel@tonic-gate * No restriction on context. 3357c478bd9Sstevel@tonic-gate */ 3367c478bd9Sstevel@tonic-gate void 3377c478bd9Sstevel@tonic-gate project_rele(kproject_t *p) 3387c478bd9Sstevel@tonic-gate { 3397c478bd9Sstevel@tonic-gate mutex_enter(&project_hash_lock); 3407c478bd9Sstevel@tonic-gate ASSERT(p->kpj_count != 0); 3417c478bd9Sstevel@tonic-gate p->kpj_count--; 3427c478bd9Sstevel@tonic-gate if (p->kpj_count == 0) { 3437c478bd9Sstevel@tonic-gate 3447c478bd9Sstevel@tonic-gate /* 3457c478bd9Sstevel@tonic-gate * Remove project from global list. 3467c478bd9Sstevel@tonic-gate */ 347*ff19e029SMenno Lageman ASSERT(p->kpj_nprocs == 0); 348*ff19e029SMenno Lageman 3497c478bd9Sstevel@tonic-gate mutex_enter(&projects_list_lock); 3507c478bd9Sstevel@tonic-gate p->kpj_next->kpj_prev = p->kpj_prev; 3517c478bd9Sstevel@tonic-gate p->kpj_prev->kpj_next = p->kpj_next; 3527c478bd9Sstevel@tonic-gate if (projects_list == p) 3537c478bd9Sstevel@tonic-gate projects_list = p->kpj_next; 3547c478bd9Sstevel@tonic-gate mutex_exit(&projects_list_lock); 3557c478bd9Sstevel@tonic-gate 356c97ad5cdSakolb cpucaps_project_remove(p); 357c97ad5cdSakolb 3587c478bd9Sstevel@tonic-gate rctl_set_free(p->kpj_rctls); 3590209230bSgjelinek project_kstat_delete(p); 3607c478bd9Sstevel@tonic-gate 361ddf7fe95Scasper if (p->kpj_klpd != NULL) 362134a1f4eSCasper H.S. Dik klpd_freelist(&p->kpj_klpd); 363ddf7fe95Scasper 3647c478bd9Sstevel@tonic-gate if (mod_hash_destroy(projects_hash, (mod_hash_key_t)p)) 3657c478bd9Sstevel@tonic-gate panic("unable to delete project %d zone %d", p->kpj_id, 3667c478bd9Sstevel@tonic-gate p->kpj_zoneid); 3677c478bd9Sstevel@tonic-gate 3687c478bd9Sstevel@tonic-gate } 3697c478bd9Sstevel@tonic-gate mutex_exit(&project_hash_lock); 3707c478bd9Sstevel@tonic-gate } 3717c478bd9Sstevel@tonic-gate 3727c478bd9Sstevel@tonic-gate /* 3737c478bd9Sstevel@tonic-gate * int project_walk_all(zoneid_t, int (*)(kproject_t *, void *), void *) 3747c478bd9Sstevel@tonic-gate * 3757c478bd9Sstevel@tonic-gate * Overview 3767c478bd9Sstevel@tonic-gate * Walk the project list for the given zoneid with a callback. 3777c478bd9Sstevel@tonic-gate * 3787c478bd9Sstevel@tonic-gate * Return values 3797c478bd9Sstevel@tonic-gate * -1 for an invalid walk, number of projects visited otherwise. 3807c478bd9Sstevel@tonic-gate * 3817c478bd9Sstevel@tonic-gate * Caller's context 3827c478bd9Sstevel@tonic-gate * projects_list_lock must not be held, as it is acquired by 3837c478bd9Sstevel@tonic-gate * project_walk_all(). Accordingly, callbacks may not perform KM_SLEEP 3847c478bd9Sstevel@tonic-gate * allocations. 3857c478bd9Sstevel@tonic-gate */ 3867c478bd9Sstevel@tonic-gate int 3877c478bd9Sstevel@tonic-gate project_walk_all(zoneid_t zoneid, int (*cb)(kproject_t *, void *), 3887c478bd9Sstevel@tonic-gate void *walk_data) 3897c478bd9Sstevel@tonic-gate { 3907c478bd9Sstevel@tonic-gate int cnt = 0; 3917c478bd9Sstevel@tonic-gate kproject_t *kp = proj0p; 3927c478bd9Sstevel@tonic-gate 3937c478bd9Sstevel@tonic-gate mutex_enter(&projects_list_lock); 3947c478bd9Sstevel@tonic-gate do { 3957c478bd9Sstevel@tonic-gate if (zoneid != ALL_ZONES && kp->kpj_zoneid != zoneid) 3967c478bd9Sstevel@tonic-gate continue; 3977c478bd9Sstevel@tonic-gate if (cb(kp, walk_data) == -1) { 3987c478bd9Sstevel@tonic-gate cnt = -1; 3997c478bd9Sstevel@tonic-gate break; 4007c478bd9Sstevel@tonic-gate } else { 4017c478bd9Sstevel@tonic-gate cnt++; 4027c478bd9Sstevel@tonic-gate } 4037c478bd9Sstevel@tonic-gate } while ((kp = kp->kpj_next) != proj0p); 4047c478bd9Sstevel@tonic-gate mutex_exit(&projects_list_lock); 4057c478bd9Sstevel@tonic-gate return (cnt); 4067c478bd9Sstevel@tonic-gate } 4077c478bd9Sstevel@tonic-gate 4087c478bd9Sstevel@tonic-gate /* 4097c478bd9Sstevel@tonic-gate * projid_t curprojid(void) 4107c478bd9Sstevel@tonic-gate * 4117c478bd9Sstevel@tonic-gate * Overview 4127c478bd9Sstevel@tonic-gate * Return project ID of the current thread 4137c478bd9Sstevel@tonic-gate * 4147c478bd9Sstevel@tonic-gate * Caller's context 4157c478bd9Sstevel@tonic-gate * No restrictions. 4167c478bd9Sstevel@tonic-gate */ 4177c478bd9Sstevel@tonic-gate projid_t 4187c478bd9Sstevel@tonic-gate curprojid() 4197c478bd9Sstevel@tonic-gate { 4207c478bd9Sstevel@tonic-gate return (ttoproj(curthread)->kpj_id); 4217c478bd9Sstevel@tonic-gate } 4227c478bd9Sstevel@tonic-gate 4237c478bd9Sstevel@tonic-gate /* 4247c478bd9Sstevel@tonic-gate * project.cpu-shares resource control support. 4257c478bd9Sstevel@tonic-gate */ 4267c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 4277c478bd9Sstevel@tonic-gate static rctl_qty_t 4287c478bd9Sstevel@tonic-gate project_cpu_shares_usage(rctl_t *rctl, struct proc *p) 4297c478bd9Sstevel@tonic-gate { 4307c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&p->p_lock)); 4317c478bd9Sstevel@tonic-gate return (p->p_task->tk_proj->kpj_shares); 4327c478bd9Sstevel@tonic-gate } 4337c478bd9Sstevel@tonic-gate 4347c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 4357c478bd9Sstevel@tonic-gate static int 4367c478bd9Sstevel@tonic-gate project_cpu_shares_set(rctl_t *rctl, struct proc *p, rctl_entity_p_t *e, 4377c478bd9Sstevel@tonic-gate rctl_qty_t nv) 4387c478bd9Sstevel@tonic-gate { 4397c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&p->p_lock)); 4407c478bd9Sstevel@tonic-gate ASSERT(e->rcep_t == RCENTITY_PROJECT); 4417c478bd9Sstevel@tonic-gate if (e->rcep_p.proj == NULL) 4427c478bd9Sstevel@tonic-gate return (0); 4437c478bd9Sstevel@tonic-gate 4447c478bd9Sstevel@tonic-gate e->rcep_p.proj->kpj_shares = nv; 4457c478bd9Sstevel@tonic-gate 4467c478bd9Sstevel@tonic-gate return (0); 4477c478bd9Sstevel@tonic-gate } 4487c478bd9Sstevel@tonic-gate 4497c478bd9Sstevel@tonic-gate static rctl_ops_t project_cpu_shares_ops = { 4507c478bd9Sstevel@tonic-gate rcop_no_action, 4517c478bd9Sstevel@tonic-gate project_cpu_shares_usage, 4527c478bd9Sstevel@tonic-gate project_cpu_shares_set, 4537c478bd9Sstevel@tonic-gate rcop_no_test 4547c478bd9Sstevel@tonic-gate }; 4557c478bd9Sstevel@tonic-gate 456c97ad5cdSakolb 457c97ad5cdSakolb /* 458c97ad5cdSakolb * project.cpu-cap resource control support. 459c97ad5cdSakolb */ 460c97ad5cdSakolb /*ARGSUSED*/ 461c97ad5cdSakolb static rctl_qty_t 462c97ad5cdSakolb project_cpu_cap_get(rctl_t *rctl, struct proc *p) 463c97ad5cdSakolb { 464c97ad5cdSakolb ASSERT(MUTEX_HELD(&p->p_lock)); 465c97ad5cdSakolb return (cpucaps_project_get(p->p_task->tk_proj)); 466c97ad5cdSakolb } 467c97ad5cdSakolb 468c97ad5cdSakolb /*ARGSUSED*/ 469c97ad5cdSakolb static int 470c97ad5cdSakolb project_cpu_cap_set(rctl_t *rctl, struct proc *p, rctl_entity_p_t *e, 471c97ad5cdSakolb rctl_qty_t nv) 472c97ad5cdSakolb { 473c97ad5cdSakolb kproject_t *kpj = e->rcep_p.proj; 474c97ad5cdSakolb 475c97ad5cdSakolb ASSERT(MUTEX_HELD(&p->p_lock)); 476c97ad5cdSakolb ASSERT(e->rcep_t == RCENTITY_PROJECT); 477c97ad5cdSakolb if (kpj == NULL) 478c97ad5cdSakolb return (0); 479c97ad5cdSakolb 480c97ad5cdSakolb /* 481c97ad5cdSakolb * set cap to the new value. 482c97ad5cdSakolb */ 483c97ad5cdSakolb return (cpucaps_project_set(kpj, nv)); 484c97ad5cdSakolb } 485c97ad5cdSakolb 486c97ad5cdSakolb static rctl_ops_t project_cpu_cap_ops = { 487c97ad5cdSakolb rcop_no_action, 488c97ad5cdSakolb project_cpu_cap_get, 489c97ad5cdSakolb project_cpu_cap_set, 490c97ad5cdSakolb rcop_no_test 491c97ad5cdSakolb }; 492c97ad5cdSakolb 4937c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 4947c478bd9Sstevel@tonic-gate static rctl_qty_t 4957c478bd9Sstevel@tonic-gate project_lwps_usage(rctl_t *r, proc_t *p) 4967c478bd9Sstevel@tonic-gate { 4977c478bd9Sstevel@tonic-gate kproject_t *pj; 4987c478bd9Sstevel@tonic-gate rctl_qty_t nlwps; 4997c478bd9Sstevel@tonic-gate 5007c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&p->p_lock)); 5017c478bd9Sstevel@tonic-gate pj = p->p_task->tk_proj; 5027c478bd9Sstevel@tonic-gate mutex_enter(&p->p_zone->zone_nlwps_lock); 5037c478bd9Sstevel@tonic-gate nlwps = pj->kpj_nlwps; 5047c478bd9Sstevel@tonic-gate mutex_exit(&p->p_zone->zone_nlwps_lock); 5057c478bd9Sstevel@tonic-gate 5067c478bd9Sstevel@tonic-gate return (nlwps); 5077c478bd9Sstevel@tonic-gate } 5087c478bd9Sstevel@tonic-gate 5097c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 5107c478bd9Sstevel@tonic-gate static int 5117c478bd9Sstevel@tonic-gate project_lwps_test(rctl_t *r, proc_t *p, rctl_entity_p_t *e, rctl_val_t *rcntl, 5127c478bd9Sstevel@tonic-gate rctl_qty_t incr, uint_t flags) 5137c478bd9Sstevel@tonic-gate { 5147c478bd9Sstevel@tonic-gate rctl_qty_t nlwps; 5157c478bd9Sstevel@tonic-gate 5167c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&p->p_lock)); 517c6939658Ssl108498 ASSERT(MUTEX_HELD(&p->p_zone->zone_nlwps_lock)); 5187c478bd9Sstevel@tonic-gate ASSERT(e->rcep_t == RCENTITY_PROJECT); 5197c478bd9Sstevel@tonic-gate if (e->rcep_p.proj == NULL) 5207c478bd9Sstevel@tonic-gate return (0); 5217c478bd9Sstevel@tonic-gate 5227c478bd9Sstevel@tonic-gate nlwps = e->rcep_p.proj->kpj_nlwps; 5237c478bd9Sstevel@tonic-gate if (nlwps + incr > rcntl->rcv_value) 5247c478bd9Sstevel@tonic-gate return (1); 5257c478bd9Sstevel@tonic-gate 5267c478bd9Sstevel@tonic-gate return (0); 5277c478bd9Sstevel@tonic-gate } 5287c478bd9Sstevel@tonic-gate 5297c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 5307c478bd9Sstevel@tonic-gate static int 5317c478bd9Sstevel@tonic-gate project_lwps_set(rctl_t *rctl, struct proc *p, rctl_entity_p_t *e, 5327c478bd9Sstevel@tonic-gate rctl_qty_t nv) { 5337c478bd9Sstevel@tonic-gate 5347c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&p->p_lock)); 5357c478bd9Sstevel@tonic-gate ASSERT(e->rcep_t == RCENTITY_PROJECT); 5367c478bd9Sstevel@tonic-gate if (e->rcep_p.proj == NULL) 5377c478bd9Sstevel@tonic-gate return (0); 5387c478bd9Sstevel@tonic-gate 5397c478bd9Sstevel@tonic-gate e->rcep_p.proj->kpj_nlwps_ctl = nv; 5407c478bd9Sstevel@tonic-gate return (0); 5417c478bd9Sstevel@tonic-gate } 5427c478bd9Sstevel@tonic-gate 5437c478bd9Sstevel@tonic-gate static rctl_ops_t project_lwps_ops = { 5447c478bd9Sstevel@tonic-gate rcop_no_action, 5457c478bd9Sstevel@tonic-gate project_lwps_usage, 5467c478bd9Sstevel@tonic-gate project_lwps_set, 5477c478bd9Sstevel@tonic-gate project_lwps_test, 5487c478bd9Sstevel@tonic-gate }; 5497c478bd9Sstevel@tonic-gate 5507c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 5517c478bd9Sstevel@tonic-gate static rctl_qty_t 552*ff19e029SMenno Lageman project_procs_usage(rctl_t *r, proc_t *p) 553*ff19e029SMenno Lageman { 554*ff19e029SMenno Lageman kproject_t *pj; 555*ff19e029SMenno Lageman rctl_qty_t nprocs; 556*ff19e029SMenno Lageman 557*ff19e029SMenno Lageman ASSERT(MUTEX_HELD(&p->p_lock)); 558*ff19e029SMenno Lageman pj = p->p_task->tk_proj; 559*ff19e029SMenno Lageman mutex_enter(&p->p_zone->zone_nlwps_lock); 560*ff19e029SMenno Lageman nprocs = pj->kpj_nprocs; 561*ff19e029SMenno Lageman mutex_exit(&p->p_zone->zone_nlwps_lock); 562*ff19e029SMenno Lageman 563*ff19e029SMenno Lageman return (nprocs); 564*ff19e029SMenno Lageman } 565*ff19e029SMenno Lageman 566*ff19e029SMenno Lageman /*ARGSUSED*/ 567*ff19e029SMenno Lageman static int 568*ff19e029SMenno Lageman project_procs_test(rctl_t *r, proc_t *p, rctl_entity_p_t *e, rctl_val_t *rcntl, 569*ff19e029SMenno Lageman rctl_qty_t incr, uint_t flags) 570*ff19e029SMenno Lageman { 571*ff19e029SMenno Lageman rctl_qty_t nprocs; 572*ff19e029SMenno Lageman 573*ff19e029SMenno Lageman ASSERT(MUTEX_HELD(&p->p_lock)); 574*ff19e029SMenno Lageman ASSERT(MUTEX_HELD(&p->p_zone->zone_nlwps_lock)); 575*ff19e029SMenno Lageman ASSERT(e->rcep_t == RCENTITY_PROJECT); 576*ff19e029SMenno Lageman if (e->rcep_p.proj == NULL) 577*ff19e029SMenno Lageman return (0); 578*ff19e029SMenno Lageman 579*ff19e029SMenno Lageman nprocs = e->rcep_p.proj->kpj_nprocs; 580*ff19e029SMenno Lageman if (nprocs + incr > rcntl->rcv_value) 581*ff19e029SMenno Lageman return (1); 582*ff19e029SMenno Lageman 583*ff19e029SMenno Lageman return (0); 584*ff19e029SMenno Lageman } 585*ff19e029SMenno Lageman 586*ff19e029SMenno Lageman /*ARGSUSED*/ 587*ff19e029SMenno Lageman static int 588*ff19e029SMenno Lageman project_procs_set(rctl_t *rctl, struct proc *p, rctl_entity_p_t *e, 589*ff19e029SMenno Lageman rctl_qty_t nv) { 590*ff19e029SMenno Lageman 591*ff19e029SMenno Lageman ASSERT(MUTEX_HELD(&p->p_lock)); 592*ff19e029SMenno Lageman ASSERT(e->rcep_t == RCENTITY_PROJECT); 593*ff19e029SMenno Lageman if (e->rcep_p.proj == NULL) 594*ff19e029SMenno Lageman return (0); 595*ff19e029SMenno Lageman 596*ff19e029SMenno Lageman e->rcep_p.proj->kpj_nprocs_ctl = nv; 597*ff19e029SMenno Lageman return (0); 598*ff19e029SMenno Lageman } 599*ff19e029SMenno Lageman 600*ff19e029SMenno Lageman static rctl_ops_t project_procs_ops = { 601*ff19e029SMenno Lageman rcop_no_action, 602*ff19e029SMenno Lageman project_procs_usage, 603*ff19e029SMenno Lageman project_procs_set, 604*ff19e029SMenno Lageman project_procs_test, 605*ff19e029SMenno Lageman }; 606*ff19e029SMenno Lageman 607*ff19e029SMenno Lageman /*ARGSUSED*/ 608*ff19e029SMenno Lageman static rctl_qty_t 6097c478bd9Sstevel@tonic-gate project_ntasks_usage(rctl_t *r, proc_t *p) 6107c478bd9Sstevel@tonic-gate { 6117c478bd9Sstevel@tonic-gate kproject_t *pj; 6127c478bd9Sstevel@tonic-gate rctl_qty_t ntasks; 6137c478bd9Sstevel@tonic-gate 6147c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&p->p_lock)); 6157c478bd9Sstevel@tonic-gate pj = p->p_task->tk_proj; 6167c478bd9Sstevel@tonic-gate mutex_enter(&p->p_zone->zone_nlwps_lock); 6177c478bd9Sstevel@tonic-gate ntasks = pj->kpj_ntasks; 6187c478bd9Sstevel@tonic-gate mutex_exit(&p->p_zone->zone_nlwps_lock); 6197c478bd9Sstevel@tonic-gate 6207c478bd9Sstevel@tonic-gate return (ntasks); 6217c478bd9Sstevel@tonic-gate } 6227c478bd9Sstevel@tonic-gate 6237c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 6247c478bd9Sstevel@tonic-gate static int 6257c478bd9Sstevel@tonic-gate project_ntasks_test(rctl_t *r, proc_t *p, rctl_entity_p_t *e, rctl_val_t *rcntl, 6267c478bd9Sstevel@tonic-gate rctl_qty_t incr, uint_t flags) 6277c478bd9Sstevel@tonic-gate { 6287c478bd9Sstevel@tonic-gate rctl_qty_t ntasks; 6297c478bd9Sstevel@tonic-gate 6307c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&p->p_lock)); 6317c478bd9Sstevel@tonic-gate ASSERT(e->rcep_t == RCENTITY_PROJECT); 6327c478bd9Sstevel@tonic-gate ntasks = e->rcep_p.proj->kpj_ntasks; 6337c478bd9Sstevel@tonic-gate if (ntasks + incr > rcntl->rcv_value) 6347c478bd9Sstevel@tonic-gate return (1); 6357c478bd9Sstevel@tonic-gate 6367c478bd9Sstevel@tonic-gate return (0); 6377c478bd9Sstevel@tonic-gate } 6387c478bd9Sstevel@tonic-gate 6397c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 6407c478bd9Sstevel@tonic-gate static int 6417c478bd9Sstevel@tonic-gate project_ntasks_set(rctl_t *rctl, struct proc *p, rctl_entity_p_t *e, 6427c478bd9Sstevel@tonic-gate rctl_qty_t nv) { 6437c478bd9Sstevel@tonic-gate 6447c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&p->p_lock)); 6457c478bd9Sstevel@tonic-gate ASSERT(e->rcep_t == RCENTITY_PROJECT); 6467c478bd9Sstevel@tonic-gate e->rcep_p.proj->kpj_ntasks_ctl = nv; 6477c478bd9Sstevel@tonic-gate return (0); 6487c478bd9Sstevel@tonic-gate } 6497c478bd9Sstevel@tonic-gate 6507c478bd9Sstevel@tonic-gate static rctl_ops_t project_tasks_ops = { 6517c478bd9Sstevel@tonic-gate rcop_no_action, 6527c478bd9Sstevel@tonic-gate project_ntasks_usage, 6537c478bd9Sstevel@tonic-gate project_ntasks_set, 6547c478bd9Sstevel@tonic-gate project_ntasks_test, 6557c478bd9Sstevel@tonic-gate }; 6567c478bd9Sstevel@tonic-gate 6577c478bd9Sstevel@tonic-gate /* 6587c478bd9Sstevel@tonic-gate * project.max-shm-memory resource control support. 6597c478bd9Sstevel@tonic-gate */ 6607c478bd9Sstevel@tonic-gate 6617c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 6627c478bd9Sstevel@tonic-gate static int 6637c478bd9Sstevel@tonic-gate project_shmmax_test(struct rctl *rctl, struct proc *p, rctl_entity_p_t *e, 6647c478bd9Sstevel@tonic-gate rctl_val_t *rval, rctl_qty_t inc, uint_t flags) 6657c478bd9Sstevel@tonic-gate { 6667c478bd9Sstevel@tonic-gate rctl_qty_t v; 6677c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&p->p_lock)); 6687c478bd9Sstevel@tonic-gate ASSERT(e->rcep_t == RCENTITY_PROJECT); 6697c478bd9Sstevel@tonic-gate v = e->rcep_p.proj->kpj_data.kpd_shmmax + inc; 6707c478bd9Sstevel@tonic-gate if (v > rval->rcv_value) 6717c478bd9Sstevel@tonic-gate return (1); 6727c478bd9Sstevel@tonic-gate 6737c478bd9Sstevel@tonic-gate return (0); 6747c478bd9Sstevel@tonic-gate } 6757c478bd9Sstevel@tonic-gate 6767c478bd9Sstevel@tonic-gate static rctl_ops_t project_shmmax_ops = { 6777c478bd9Sstevel@tonic-gate rcop_no_action, 6787c478bd9Sstevel@tonic-gate rcop_no_usage, 6797c478bd9Sstevel@tonic-gate rcop_no_set, 6807c478bd9Sstevel@tonic-gate project_shmmax_test 6817c478bd9Sstevel@tonic-gate }; 6827c478bd9Sstevel@tonic-gate 6837c478bd9Sstevel@tonic-gate /* 6847c478bd9Sstevel@tonic-gate * project.max-shm-ids resource control support. 6857c478bd9Sstevel@tonic-gate */ 6867c478bd9Sstevel@tonic-gate 6877c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 6887c478bd9Sstevel@tonic-gate static int 6897c478bd9Sstevel@tonic-gate project_shmmni_test(struct rctl *rctl, struct proc *p, rctl_entity_p_t *e, 6907c478bd9Sstevel@tonic-gate rctl_val_t *rval, rctl_qty_t inc, uint_t flags) 6917c478bd9Sstevel@tonic-gate { 6927c478bd9Sstevel@tonic-gate rctl_qty_t v; 6937c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&p->p_lock)); 6947c478bd9Sstevel@tonic-gate ASSERT(e->rcep_t == RCENTITY_PROJECT); 695824c205fSml93401 v = e->rcep_p.proj->kpj_data.kpd_ipc.ipcq_shmmni + inc; 6967c478bd9Sstevel@tonic-gate if (v > rval->rcv_value) 6977c478bd9Sstevel@tonic-gate return (1); 6987c478bd9Sstevel@tonic-gate 6997c478bd9Sstevel@tonic-gate return (0); 7007c478bd9Sstevel@tonic-gate } 7017c478bd9Sstevel@tonic-gate 7027c478bd9Sstevel@tonic-gate static rctl_ops_t project_shmmni_ops = { 7037c478bd9Sstevel@tonic-gate rcop_no_action, 7047c478bd9Sstevel@tonic-gate rcop_no_usage, 7057c478bd9Sstevel@tonic-gate rcop_no_set, 7067c478bd9Sstevel@tonic-gate project_shmmni_test 7077c478bd9Sstevel@tonic-gate }; 7087c478bd9Sstevel@tonic-gate 7097c478bd9Sstevel@tonic-gate /* 7107c478bd9Sstevel@tonic-gate * project.max-sem-ids resource control support. 7117c478bd9Sstevel@tonic-gate */ 7127c478bd9Sstevel@tonic-gate 7137c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 7147c478bd9Sstevel@tonic-gate static int 7157c478bd9Sstevel@tonic-gate project_semmni_test(struct rctl *rctl, struct proc *p, rctl_entity_p_t *e, 7167c478bd9Sstevel@tonic-gate rctl_val_t *rval, rctl_qty_t inc, uint_t flags) 7177c478bd9Sstevel@tonic-gate { 7187c478bd9Sstevel@tonic-gate rctl_qty_t v; 7197c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&p->p_lock)); 7207c478bd9Sstevel@tonic-gate ASSERT(e->rcep_t == RCENTITY_PROJECT); 721824c205fSml93401 v = e->rcep_p.proj->kpj_data.kpd_ipc.ipcq_semmni + inc; 7227c478bd9Sstevel@tonic-gate if (v > rval->rcv_value) 7237c478bd9Sstevel@tonic-gate return (1); 7247c478bd9Sstevel@tonic-gate 7257c478bd9Sstevel@tonic-gate return (0); 7267c478bd9Sstevel@tonic-gate } 7277c478bd9Sstevel@tonic-gate 7287c478bd9Sstevel@tonic-gate static rctl_ops_t project_semmni_ops = { 7297c478bd9Sstevel@tonic-gate rcop_no_action, 7307c478bd9Sstevel@tonic-gate rcop_no_usage, 7317c478bd9Sstevel@tonic-gate rcop_no_set, 7327c478bd9Sstevel@tonic-gate project_semmni_test 7337c478bd9Sstevel@tonic-gate }; 7347c478bd9Sstevel@tonic-gate 7357c478bd9Sstevel@tonic-gate /* 7367c478bd9Sstevel@tonic-gate * project.max-msg-ids resource control support. 7377c478bd9Sstevel@tonic-gate */ 7387c478bd9Sstevel@tonic-gate 7397c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 7407c478bd9Sstevel@tonic-gate static int 7417c478bd9Sstevel@tonic-gate project_msgmni_test(struct rctl *rctl, struct proc *p, rctl_entity_p_t *e, 7427c478bd9Sstevel@tonic-gate rctl_val_t *rval, rctl_qty_t inc, uint_t flags) 7437c478bd9Sstevel@tonic-gate { 7447c478bd9Sstevel@tonic-gate rctl_qty_t v; 7457c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&p->p_lock)); 7467c478bd9Sstevel@tonic-gate ASSERT(e->rcep_t == RCENTITY_PROJECT); 747824c205fSml93401 v = e->rcep_p.proj->kpj_data.kpd_ipc.ipcq_msgmni + inc; 7487c478bd9Sstevel@tonic-gate if (v > rval->rcv_value) 7497c478bd9Sstevel@tonic-gate return (1); 7507c478bd9Sstevel@tonic-gate 7517c478bd9Sstevel@tonic-gate return (0); 7527c478bd9Sstevel@tonic-gate } 7537c478bd9Sstevel@tonic-gate 7547c478bd9Sstevel@tonic-gate static rctl_ops_t project_msgmni_ops = { 7557c478bd9Sstevel@tonic-gate rcop_no_action, 7567c478bd9Sstevel@tonic-gate rcop_no_usage, 7577c478bd9Sstevel@tonic-gate rcop_no_set, 7587c478bd9Sstevel@tonic-gate project_msgmni_test 7597c478bd9Sstevel@tonic-gate }; 7607c478bd9Sstevel@tonic-gate 761c6939658Ssl108498 /*ARGSUSED*/ 762c6939658Ssl108498 static rctl_qty_t 763c6939658Ssl108498 project_locked_mem_usage(rctl_t *rctl, struct proc *p) 764c6939658Ssl108498 { 765c6939658Ssl108498 rctl_qty_t q; 766c6939658Ssl108498 ASSERT(MUTEX_HELD(&p->p_lock)); 7670209230bSgjelinek mutex_enter(&p->p_zone->zone_mem_lock); 768c6939658Ssl108498 q = p->p_task->tk_proj->kpj_data.kpd_locked_mem; 7690209230bSgjelinek mutex_exit(&p->p_zone->zone_mem_lock); 770c6939658Ssl108498 return (q); 771c6939658Ssl108498 } 7727c478bd9Sstevel@tonic-gate 7737c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 7747c478bd9Sstevel@tonic-gate static int 775c6939658Ssl108498 project_locked_mem_test(struct rctl *rctl, struct proc *p, rctl_entity_p_t *e, 7767c478bd9Sstevel@tonic-gate rctl_val_t *rval, rctl_qty_t inc, uint_t flags) 7777c478bd9Sstevel@tonic-gate { 778c6939658Ssl108498 rctl_qty_t q; 7797c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&p->p_lock)); 7800209230bSgjelinek ASSERT(MUTEX_HELD(&p->p_zone->zone_mem_lock)); 781c6939658Ssl108498 q = p->p_task->tk_proj->kpj_data.kpd_locked_mem; 782c6939658Ssl108498 if (q + inc > rval->rcv_value) 7837c478bd9Sstevel@tonic-gate return (1); 7847c478bd9Sstevel@tonic-gate return (0); 7857c478bd9Sstevel@tonic-gate } 7867c478bd9Sstevel@tonic-gate 787c6939658Ssl108498 /*ARGSUSED*/ 788c6939658Ssl108498 static int 789c6939658Ssl108498 project_locked_mem_set(rctl_t *rctl, struct proc *p, rctl_entity_p_t *e, 790c6939658Ssl108498 rctl_qty_t nv) { 791c6939658Ssl108498 792c6939658Ssl108498 ASSERT(MUTEX_HELD(&p->p_lock)); 793c6939658Ssl108498 ASSERT(e->rcep_t == RCENTITY_PROJECT); 794c6939658Ssl108498 if (e->rcep_p.proj == NULL) 795c6939658Ssl108498 return (0); 796c6939658Ssl108498 797c6939658Ssl108498 e->rcep_p.proj->kpj_data.kpd_locked_mem_ctl = nv; 798c6939658Ssl108498 return (0); 799c6939658Ssl108498 } 800c6939658Ssl108498 801c6939658Ssl108498 static rctl_ops_t project_locked_mem_ops = { 8027c478bd9Sstevel@tonic-gate rcop_no_action, 803c6939658Ssl108498 project_locked_mem_usage, 804c6939658Ssl108498 project_locked_mem_set, 805c6939658Ssl108498 project_locked_mem_test 8067c478bd9Sstevel@tonic-gate }; 8077c478bd9Sstevel@tonic-gate 8087c478bd9Sstevel@tonic-gate /* 8097c478bd9Sstevel@tonic-gate * project.max-contracts resource control support. 8107c478bd9Sstevel@tonic-gate */ 8117c478bd9Sstevel@tonic-gate 8127c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 8137c478bd9Sstevel@tonic-gate static int 8147c478bd9Sstevel@tonic-gate project_contract_test(struct rctl *rctl, struct proc *p, rctl_entity_p_t *e, 8157c478bd9Sstevel@tonic-gate rctl_val_t *rval, rctl_qty_t inc, uint_t flags) 8167c478bd9Sstevel@tonic-gate { 8177c478bd9Sstevel@tonic-gate rctl_qty_t v; 8187c478bd9Sstevel@tonic-gate 8197c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&p->p_lock)); 8207c478bd9Sstevel@tonic-gate ASSERT(e->rcep_t == RCENTITY_PROJECT); 8217c478bd9Sstevel@tonic-gate 8227c478bd9Sstevel@tonic-gate v = e->rcep_p.proj->kpj_data.kpd_contract + inc; 8237c478bd9Sstevel@tonic-gate 8247c478bd9Sstevel@tonic-gate if ((p->p_task != NULL) && (p->p_task->tk_proj) != NULL && 8257c478bd9Sstevel@tonic-gate (v > rval->rcv_value)) 8267c478bd9Sstevel@tonic-gate return (1); 8277c478bd9Sstevel@tonic-gate 8287c478bd9Sstevel@tonic-gate return (0); 8297c478bd9Sstevel@tonic-gate } 8307c478bd9Sstevel@tonic-gate 8317c478bd9Sstevel@tonic-gate static rctl_ops_t project_contract_ops = { 8327c478bd9Sstevel@tonic-gate rcop_no_action, 8337c478bd9Sstevel@tonic-gate rcop_no_usage, 8347c478bd9Sstevel@tonic-gate rcop_no_set, 8357c478bd9Sstevel@tonic-gate project_contract_test 8367c478bd9Sstevel@tonic-gate }; 8377c478bd9Sstevel@tonic-gate 8387c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 839db1cde31Skrishna static rctl_qty_t 840db1cde31Skrishna project_crypto_usage(rctl_t *r, proc_t *p) 841db1cde31Skrishna { 842db1cde31Skrishna ASSERT(MUTEX_HELD(&p->p_lock)); 843db1cde31Skrishna return (p->p_task->tk_proj->kpj_data.kpd_crypto_mem); 844db1cde31Skrishna } 845db1cde31Skrishna 846db1cde31Skrishna /*ARGSUSED*/ 847db1cde31Skrishna static int 848db1cde31Skrishna project_crypto_set(rctl_t *r, proc_t *p, rctl_entity_p_t *e, 849db1cde31Skrishna rctl_qty_t nv) 850db1cde31Skrishna { 851db1cde31Skrishna ASSERT(MUTEX_HELD(&p->p_lock)); 852db1cde31Skrishna ASSERT(e->rcep_t == RCENTITY_PROJECT); 853db1cde31Skrishna if (e->rcep_p.proj == NULL) 854db1cde31Skrishna return (0); 855db1cde31Skrishna 856db1cde31Skrishna e->rcep_p.proj->kpj_data.kpd_crypto_mem_ctl = nv; 857db1cde31Skrishna return (0); 858db1cde31Skrishna } 859db1cde31Skrishna 860db1cde31Skrishna /*ARGSUSED*/ 8617c478bd9Sstevel@tonic-gate static int 8627c478bd9Sstevel@tonic-gate project_crypto_test(rctl_t *r, proc_t *p, rctl_entity_p_t *e, 8637c478bd9Sstevel@tonic-gate rctl_val_t *rval, rctl_qty_t incr, uint_t flags) 8647c478bd9Sstevel@tonic-gate { 8657c478bd9Sstevel@tonic-gate rctl_qty_t v; 8667c478bd9Sstevel@tonic-gate ASSERT(MUTEX_HELD(&p->p_lock)); 8677c478bd9Sstevel@tonic-gate ASSERT(e->rcep_t == RCENTITY_PROJECT); 8687c478bd9Sstevel@tonic-gate v = e->rcep_p.proj->kpj_data.kpd_crypto_mem + incr; 8697c478bd9Sstevel@tonic-gate if (v > rval->rcv_value) 8707c478bd9Sstevel@tonic-gate return (1); 8717c478bd9Sstevel@tonic-gate return (0); 8727c478bd9Sstevel@tonic-gate } 8737c478bd9Sstevel@tonic-gate 8747c478bd9Sstevel@tonic-gate static rctl_ops_t project_crypto_mem_ops = { 8757c478bd9Sstevel@tonic-gate rcop_no_action, 876db1cde31Skrishna project_crypto_usage, 877db1cde31Skrishna project_crypto_set, 8787c478bd9Sstevel@tonic-gate project_crypto_test 8797c478bd9Sstevel@tonic-gate }; 8807c478bd9Sstevel@tonic-gate 8817c478bd9Sstevel@tonic-gate /* 8827c478bd9Sstevel@tonic-gate * void project_init(void) 8837c478bd9Sstevel@tonic-gate * 8847c478bd9Sstevel@tonic-gate * Overview 8857c478bd9Sstevel@tonic-gate * Initialize the project subsystem, including the primordial project 0 entry. 8867c478bd9Sstevel@tonic-gate * Register generic project resource controls, if any. 8877c478bd9Sstevel@tonic-gate * 8887c478bd9Sstevel@tonic-gate * Return values 8897c478bd9Sstevel@tonic-gate * None. 8907c478bd9Sstevel@tonic-gate * 8917c478bd9Sstevel@tonic-gate * Caller's context 8927c478bd9Sstevel@tonic-gate * Safe for KM_SLEEP allocations. 8937c478bd9Sstevel@tonic-gate */ 8947c478bd9Sstevel@tonic-gate void 8957c478bd9Sstevel@tonic-gate project_init(void) 8967c478bd9Sstevel@tonic-gate { 8977c478bd9Sstevel@tonic-gate rctl_qty_t shmmni, shmmax, qty; 8987c478bd9Sstevel@tonic-gate boolean_t check; 8997c478bd9Sstevel@tonic-gate 9007c478bd9Sstevel@tonic-gate projects_hash = mod_hash_create_extended("projects_hash", 9017c478bd9Sstevel@tonic-gate project_hash_size, mod_hash_null_keydtor, project_hash_val_dtor, 9027c478bd9Sstevel@tonic-gate project_hash_by_id, 9037c478bd9Sstevel@tonic-gate (void *)(uintptr_t)mod_hash_iddata_gen(project_hash_size), 9047c478bd9Sstevel@tonic-gate project_hash_key_cmp, KM_SLEEP); 9057c478bd9Sstevel@tonic-gate 9067c478bd9Sstevel@tonic-gate rc_project_cpu_shares = rctl_register("project.cpu-shares", 9077c478bd9Sstevel@tonic-gate RCENTITY_PROJECT, RCTL_GLOBAL_SIGNAL_NEVER | 9087c478bd9Sstevel@tonic-gate RCTL_GLOBAL_DENY_NEVER | RCTL_GLOBAL_NOBASIC | 90919f92332Sml93401 RCTL_GLOBAL_COUNT | RCTL_GLOBAL_SYSLOG_NEVER, 91019f92332Sml93401 FSS_MAXSHARES, FSS_MAXSHARES, 9117c478bd9Sstevel@tonic-gate &project_cpu_shares_ops); 9127c478bd9Sstevel@tonic-gate rctl_add_default_limit("project.cpu-shares", 1, RCPRIV_PRIVILEGED, 9137c478bd9Sstevel@tonic-gate RCTL_LOCAL_NOACTION); 9147c478bd9Sstevel@tonic-gate 915c97ad5cdSakolb rc_project_cpu_cap = rctl_register("project.cpu-cap", 916c97ad5cdSakolb RCENTITY_PROJECT, RCTL_GLOBAL_SIGNAL_NEVER | 917c97ad5cdSakolb RCTL_GLOBAL_DENY_ALWAYS | RCTL_GLOBAL_NOBASIC | 918c97ad5cdSakolb RCTL_GLOBAL_COUNT | RCTL_GLOBAL_SYSLOG_NEVER | 919c97ad5cdSakolb RCTL_GLOBAL_INFINITE, 920c97ad5cdSakolb MAXCAP, MAXCAP, &project_cpu_cap_ops); 921c97ad5cdSakolb 9227c478bd9Sstevel@tonic-gate rc_project_nlwps = rctl_register("project.max-lwps", RCENTITY_PROJECT, 9237c478bd9Sstevel@tonic-gate RCTL_GLOBAL_NOACTION | RCTL_GLOBAL_NOBASIC | RCTL_GLOBAL_COUNT, 9247c478bd9Sstevel@tonic-gate INT_MAX, INT_MAX, &project_lwps_ops); 9257c478bd9Sstevel@tonic-gate 926*ff19e029SMenno Lageman rc_project_nprocs = rctl_register("project.max-processes", 927*ff19e029SMenno Lageman RCENTITY_PROJECT, RCTL_GLOBAL_NOACTION | RCTL_GLOBAL_NOBASIC | 928*ff19e029SMenno Lageman RCTL_GLOBAL_COUNT, INT_MAX, INT_MAX, &project_procs_ops); 929*ff19e029SMenno Lageman 9307c478bd9Sstevel@tonic-gate rc_project_ntasks = rctl_register("project.max-tasks", RCENTITY_PROJECT, 9317c478bd9Sstevel@tonic-gate RCTL_GLOBAL_NOACTION | RCTL_GLOBAL_NOBASIC | RCTL_GLOBAL_COUNT, 9327c478bd9Sstevel@tonic-gate INT_MAX, INT_MAX, &project_tasks_ops); 9337c478bd9Sstevel@tonic-gate 9347c478bd9Sstevel@tonic-gate /* 9357c478bd9Sstevel@tonic-gate * This rctl handle is used by /dev/crypto. It is here rather than 9367c478bd9Sstevel@tonic-gate * in misc/kcf or the drv/crypto module because resource controls 9377c478bd9Sstevel@tonic-gate * currently don't allow modules to be unloaded, and the control 9387c478bd9Sstevel@tonic-gate * must be registered before init starts. 9397c478bd9Sstevel@tonic-gate */ 9407c478bd9Sstevel@tonic-gate rc_project_crypto_mem = rctl_register("project.max-crypto-memory", 9417c478bd9Sstevel@tonic-gate RCENTITY_PROJECT, RCTL_GLOBAL_DENY_ALWAYS | RCTL_GLOBAL_NOBASIC | 9427c478bd9Sstevel@tonic-gate RCTL_GLOBAL_BYTES, UINT64_MAX, UINT64_MAX, 9437c478bd9Sstevel@tonic-gate &project_crypto_mem_ops); 9447c478bd9Sstevel@tonic-gate 9457c478bd9Sstevel@tonic-gate /* 9467c478bd9Sstevel@tonic-gate * Default to a quarter of the machine's memory 9477c478bd9Sstevel@tonic-gate */ 9487c478bd9Sstevel@tonic-gate qty = availrmem_initial << (PAGESHIFT - 2); 9497c478bd9Sstevel@tonic-gate rctl_add_default_limit("project.max-crypto-memory", qty, 9507c478bd9Sstevel@tonic-gate RCPRIV_PRIVILEGED, RCTL_LOCAL_DENY); 9517c478bd9Sstevel@tonic-gate 9527c478bd9Sstevel@tonic-gate /* 9537c478bd9Sstevel@tonic-gate * System V IPC resource controls 9547c478bd9Sstevel@tonic-gate */ 9557c478bd9Sstevel@tonic-gate rc_project_semmni = rctl_register("project.max-sem-ids", 9567c478bd9Sstevel@tonic-gate RCENTITY_PROJECT, RCTL_GLOBAL_DENY_ALWAYS | RCTL_GLOBAL_NOBASIC | 9577c478bd9Sstevel@tonic-gate RCTL_GLOBAL_COUNT, IPC_IDS_MAX, IPC_IDS_MAX, &project_semmni_ops); 9587c478bd9Sstevel@tonic-gate rctl_add_legacy_limit("project.max-sem-ids", "semsys", 9597c478bd9Sstevel@tonic-gate "seminfo_semmni", 128, IPC_IDS_MAX); 9607c478bd9Sstevel@tonic-gate 9617c478bd9Sstevel@tonic-gate rc_project_msgmni = rctl_register("project.max-msg-ids", 9627c478bd9Sstevel@tonic-gate RCENTITY_PROJECT, RCTL_GLOBAL_DENY_ALWAYS | RCTL_GLOBAL_NOBASIC | 9637c478bd9Sstevel@tonic-gate RCTL_GLOBAL_COUNT, IPC_IDS_MAX, IPC_IDS_MAX, &project_msgmni_ops); 9647c478bd9Sstevel@tonic-gate rctl_add_legacy_limit("project.max-msg-ids", "msgsys", 9657c478bd9Sstevel@tonic-gate "msginfo_msgmni", 128, IPC_IDS_MAX); 9667c478bd9Sstevel@tonic-gate 9677c478bd9Sstevel@tonic-gate rc_project_shmmni = rctl_register("project.max-shm-ids", 9687c478bd9Sstevel@tonic-gate RCENTITY_PROJECT, RCTL_GLOBAL_DENY_ALWAYS | RCTL_GLOBAL_NOBASIC | 9697c478bd9Sstevel@tonic-gate RCTL_GLOBAL_COUNT, IPC_IDS_MAX, IPC_IDS_MAX, &project_shmmni_ops); 9707c478bd9Sstevel@tonic-gate rctl_add_legacy_limit("project.max-shm-ids", "shmsys", 9717c478bd9Sstevel@tonic-gate "shminfo_shmmni", 128, IPC_IDS_MAX); 9727c478bd9Sstevel@tonic-gate 9737c478bd9Sstevel@tonic-gate rc_project_shmmax = rctl_register("project.max-shm-memory", 9747c478bd9Sstevel@tonic-gate RCENTITY_PROJECT, RCTL_GLOBAL_DENY_ALWAYS | RCTL_GLOBAL_NOBASIC | 9757c478bd9Sstevel@tonic-gate RCTL_GLOBAL_BYTES, UINT64_MAX, UINT64_MAX, &project_shmmax_ops); 9767c478bd9Sstevel@tonic-gate 9777c478bd9Sstevel@tonic-gate check = B_FALSE; 9787c478bd9Sstevel@tonic-gate if (!mod_sysvar("shmsys", "shminfo_shmmni", &shmmni)) 9797c478bd9Sstevel@tonic-gate shmmni = 100; 9807c478bd9Sstevel@tonic-gate else 9817c478bd9Sstevel@tonic-gate check = B_TRUE; 9827c478bd9Sstevel@tonic-gate if (!mod_sysvar("shmsys", "shminfo_shmmax", &shmmax)) 9837c478bd9Sstevel@tonic-gate shmmax = 0x800000; 9847c478bd9Sstevel@tonic-gate else 9857c478bd9Sstevel@tonic-gate check = B_TRUE; 9867c478bd9Sstevel@tonic-gate 9877c478bd9Sstevel@tonic-gate /* 9887c478bd9Sstevel@tonic-gate * Default to a quarter of the machine's memory 9897c478bd9Sstevel@tonic-gate */ 9907c478bd9Sstevel@tonic-gate qty = availrmem_initial << (PAGESHIFT - 2); 9917c478bd9Sstevel@tonic-gate if (check) { 9927c478bd9Sstevel@tonic-gate if ((shmmax > 0) && (UINT64_MAX / shmmax <= shmmni)) 9937c478bd9Sstevel@tonic-gate qty = UINT64_MAX; 9947c478bd9Sstevel@tonic-gate else if (shmmni * shmmax > qty) 9957c478bd9Sstevel@tonic-gate qty = shmmni * shmmax; 9967c478bd9Sstevel@tonic-gate } 9977c478bd9Sstevel@tonic-gate rctl_add_default_limit("project.max-shm-memory", qty, 9987c478bd9Sstevel@tonic-gate RCPRIV_PRIVILEGED, RCTL_LOCAL_DENY); 9997c478bd9Sstevel@tonic-gate 10007c478bd9Sstevel@tonic-gate /* 10017c478bd9Sstevel@tonic-gate * Event Ports resource controls 10027c478bd9Sstevel@tonic-gate */ 10037c478bd9Sstevel@tonic-gate 10047c478bd9Sstevel@tonic-gate rc_project_portids = rctl_register("project.max-port-ids", 10057c478bd9Sstevel@tonic-gate RCENTITY_PROJECT, RCTL_GLOBAL_DENY_ALWAYS | RCTL_GLOBAL_NOBASIC | 10067c478bd9Sstevel@tonic-gate RCTL_GLOBAL_COUNT, PORT_MAX_PORTS, PORT_MAX_PORTS, 10077c478bd9Sstevel@tonic-gate &rctl_absolute_ops); 10087c478bd9Sstevel@tonic-gate rctl_add_default_limit("project.max-port-ids", PORT_DEFAULT_PORTS, 10097c478bd9Sstevel@tonic-gate RCPRIV_PRIVILEGED, RCTL_LOCAL_DENY); 10107c478bd9Sstevel@tonic-gate 10117c478bd9Sstevel@tonic-gate /* 10127c478bd9Sstevel@tonic-gate * Resource control for locked memory 10137c478bd9Sstevel@tonic-gate */ 1014c6939658Ssl108498 rc_project_locked_mem = rctl_register( 1015c6939658Ssl108498 "project.max-locked-memory", RCENTITY_PROJECT, 10167c478bd9Sstevel@tonic-gate RCTL_GLOBAL_DENY_ALWAYS | RCTL_GLOBAL_NOBASIC | RCTL_GLOBAL_BYTES, 1017c6939658Ssl108498 UINT64_MAX, UINT64_MAX, &project_locked_mem_ops); 10187c478bd9Sstevel@tonic-gate 10197c478bd9Sstevel@tonic-gate /* 10207c478bd9Sstevel@tonic-gate * Per project limit on contracts. 10217c478bd9Sstevel@tonic-gate */ 10227c478bd9Sstevel@tonic-gate rc_project_contract = rctl_register("project.max-contracts", 1023532877c4Srd117015 RCENTITY_PROJECT, RCTL_GLOBAL_DENY_ALWAYS | RCTL_GLOBAL_NOBASIC | 1024532877c4Srd117015 RCTL_GLOBAL_COUNT, INT_MAX, INT_MAX, &project_contract_ops); 10257c478bd9Sstevel@tonic-gate rctl_add_default_limit("project.max-contracts", 10000, 10267c478bd9Sstevel@tonic-gate RCPRIV_PRIVILEGED, RCTL_LOCAL_DENY); 10277c478bd9Sstevel@tonic-gate 10280209230bSgjelinek t0.t_proj = proj0p = project_hold_by_id(0, &zone0, 10297c478bd9Sstevel@tonic-gate PROJECT_HOLD_INSERT); 10307c478bd9Sstevel@tonic-gate 10317c478bd9Sstevel@tonic-gate mutex_enter(&p0.p_lock); 10327c478bd9Sstevel@tonic-gate proj0p->kpj_nlwps = p0.p_lwpcnt; 10337c478bd9Sstevel@tonic-gate mutex_exit(&p0.p_lock); 1034*ff19e029SMenno Lageman proj0p->kpj_nprocs = 1; 10357c478bd9Sstevel@tonic-gate proj0p->kpj_ntasks = 1; 10367c478bd9Sstevel@tonic-gate } 10370209230bSgjelinek 10380209230bSgjelinek static int 10390209230bSgjelinek project_lockedmem_kstat_update(kstat_t *ksp, int rw) 10400209230bSgjelinek { 10410209230bSgjelinek kproject_t *pj = ksp->ks_private; 10420209230bSgjelinek kproject_kstat_t *kpk = ksp->ks_data; 10430209230bSgjelinek 10440209230bSgjelinek if (rw == KSTAT_WRITE) 10450209230bSgjelinek return (EACCES); 10460209230bSgjelinek 10470209230bSgjelinek kpk->kpk_usage.value.ui64 = pj->kpj_data.kpd_locked_mem; 10480209230bSgjelinek kpk->kpk_value.value.ui64 = pj->kpj_data.kpd_locked_mem_ctl; 10490209230bSgjelinek return (0); 10500209230bSgjelinek } 10510209230bSgjelinek 1052*ff19e029SMenno Lageman static int 1053*ff19e029SMenno Lageman project_nprocs_kstat_update(kstat_t *ksp, int rw) 1054*ff19e029SMenno Lageman { 1055*ff19e029SMenno Lageman kproject_t *pj = ksp->ks_private; 1056*ff19e029SMenno Lageman kproject_kstat_t *kpk = ksp->ks_data; 1057*ff19e029SMenno Lageman 1058*ff19e029SMenno Lageman if (rw == KSTAT_WRITE) 1059*ff19e029SMenno Lageman return (EACCES); 1060*ff19e029SMenno Lageman 1061*ff19e029SMenno Lageman kpk->kpk_usage.value.ui64 = pj->kpj_nprocs; 1062*ff19e029SMenno Lageman kpk->kpk_value.value.ui64 = pj->kpj_nprocs_ctl; 1063*ff19e029SMenno Lageman return (0); 1064*ff19e029SMenno Lageman } 1065*ff19e029SMenno Lageman 10660209230bSgjelinek static kstat_t * 1067*ff19e029SMenno Lageman project_kstat_create_common(kproject_t *pj, char *name, char *zonename, 1068*ff19e029SMenno Lageman int (*updatefunc) (kstat_t *, int)) 10690209230bSgjelinek { 10700209230bSgjelinek kstat_t *ksp; 10710209230bSgjelinek kproject_kstat_t *kpk; 10720209230bSgjelinek 1073*ff19e029SMenno Lageman ksp = rctl_kstat_create_project(pj, name, KSTAT_TYPE_NAMED, 10740209230bSgjelinek sizeof (kproject_kstat_t) / sizeof (kstat_named_t), 10750209230bSgjelinek KSTAT_FLAG_VIRTUAL); 10760209230bSgjelinek 10770209230bSgjelinek if (ksp == NULL) 10780209230bSgjelinek return (NULL); 10790209230bSgjelinek 10800209230bSgjelinek kpk = ksp->ks_data = kmem_alloc(sizeof (kproject_kstat_t), KM_SLEEP); 10810209230bSgjelinek ksp->ks_data_size += strlen(zonename) + 1; 10820209230bSgjelinek kstat_named_init(&kpk->kpk_zonename, "zonename", KSTAT_DATA_STRING); 10830209230bSgjelinek kstat_named_setstr(&kpk->kpk_zonename, zonename); 10840209230bSgjelinek kstat_named_init(&kpk->kpk_usage, "usage", KSTAT_DATA_UINT64); 10850209230bSgjelinek kstat_named_init(&kpk->kpk_value, "value", KSTAT_DATA_UINT64); 1086*ff19e029SMenno Lageman ksp->ks_update = updatefunc; 10870209230bSgjelinek ksp->ks_private = pj; 10880209230bSgjelinek kstat_install(ksp); 10890209230bSgjelinek return (ksp); 10900209230bSgjelinek } 10910209230bSgjelinek 10920209230bSgjelinek static void 1093*ff19e029SMenno Lageman project_kstat_create(kproject_t *pj, zone_t *zone) 1094*ff19e029SMenno Lageman { 1095*ff19e029SMenno Lageman kstat_t *ksp_lockedmem; 1096*ff19e029SMenno Lageman kstat_t *ksp_nprocs; 1097*ff19e029SMenno Lageman 1098*ff19e029SMenno Lageman ksp_lockedmem = project_kstat_create_common(pj, "lockedmem", 1099*ff19e029SMenno Lageman zone->zone_name, project_lockedmem_kstat_update); 1100*ff19e029SMenno Lageman ksp_nprocs = project_kstat_create_common(pj, "nprocs", 1101*ff19e029SMenno Lageman zone->zone_name, project_nprocs_kstat_update); 1102*ff19e029SMenno Lageman 1103*ff19e029SMenno Lageman mutex_enter(&project_hash_lock); 1104*ff19e029SMenno Lageman ASSERT(pj->kpj_data.kpd_lockedmem_kstat == NULL); 1105*ff19e029SMenno Lageman pj->kpj_data.kpd_lockedmem_kstat = ksp_lockedmem; 1106*ff19e029SMenno Lageman ASSERT(pj->kpj_data.kpd_nprocs_kstat == NULL); 1107*ff19e029SMenno Lageman pj->kpj_data.kpd_nprocs_kstat = ksp_nprocs; 1108*ff19e029SMenno Lageman mutex_exit(&project_hash_lock); 1109*ff19e029SMenno Lageman } 1110*ff19e029SMenno Lageman 1111*ff19e029SMenno Lageman static void 1112*ff19e029SMenno Lageman project_kstat_delete_common(kstat_t **kstat) 1113*ff19e029SMenno Lageman { 1114*ff19e029SMenno Lageman void *data; 1115*ff19e029SMenno Lageman 1116*ff19e029SMenno Lageman if (*kstat != NULL) { 1117*ff19e029SMenno Lageman data = (*kstat)->ks_data; 1118*ff19e029SMenno Lageman kstat_delete(*kstat); 1119*ff19e029SMenno Lageman kmem_free(data, sizeof (kproject_kstat_t)); 1120*ff19e029SMenno Lageman *kstat = NULL; 1121*ff19e029SMenno Lageman } 1122*ff19e029SMenno Lageman } 1123*ff19e029SMenno Lageman 1124*ff19e029SMenno Lageman static void 11250209230bSgjelinek project_kstat_delete(kproject_t *pj) 11260209230bSgjelinek { 1127*ff19e029SMenno Lageman project_kstat_delete_common(&pj->kpj_data.kpd_lockedmem_kstat); 1128*ff19e029SMenno Lageman project_kstat_delete_common(&pj->kpj_data.kpd_nprocs_kstat); 11290209230bSgjelinek } 1130