511 ipcperm_set(ipc_service_t *service, struct cred *cr,
520 	ASSERT(IPC_LOCKED(service, kperm));
539 		audit_ipcget(service->ipcs_atype, kperm);
560 ipcperm_set64(ipc_service_t *service, struct cred *cr,
565 	ASSERT(IPC_LOCKED(service, kperm));
581 		audit_ipcget(service->ipcs_atype, kperm);
637  * Create an ipc service.
670  * Destroy an ipc service.
673 ipcs_destroy(ipc_service_t *service)
677 	mutex_enter(&service->ipcs_lock);
679 	ASSERT(service->ipcs_count == 0);
680 	avl_destroy(&service->ipcs_keys);
681 	list_destroy(&service->ipcs_usedids);
682 	id_space_destroy(service->ipcs_ids);
684 	for (slot = service->ipcs_table; slot; slot = next) {
686 		kmem_free(slot, service->ipcs_tabsz * sizeof (ipc_slot_t));
687 		service->ipcs_tabsz >>= 1;
690 	mutex_destroy(&service->ipcs_lock);
691 	kmem_free(service, sizeof (ipc_service_t));
695  * Takes the service lock.
698 ipcs_lock(ipc_service_t *service)
700 	mutex_enter(&service->ipcs_lock);
704  * Releases the service lock.
707 ipcs_unlock(ipc_service_t *service)
709 	mutex_exit(&service->ipcs_lock);
717 ipc_lock_internal(ipc_service_t *service, uint_t id)
724 		tabsz = service->ipcs_tabsz;
727 		mutex = &service->ipcs_table[index].ipct_lock;
729 		if (tabsz == service->ipcs_tabsz)
741 ipc_lock(ipc_service_t *service, int id)
750 	ASSERT(IPC_INDEX(id) < service->ipcs_tabsz);
751 	index = ipc_lock_internal(service, id);
753 	return (&service->ipcs_table[index].ipct_lock);
764 ipc_relock(ipc_service_t *service, int id, kmutex_t *lock)
767 	ASSERT(IPC_INDEX(id) < service->ipcs_tabsz);
770 	if (&service->ipcs_table[IPC_INDEX(id)].ipct_lock == lock)
774 	return (ipc_lock(service, id));
784 ipc_lookup(ipc_service_t *service, int id, kipc_perm_t **perm)
795 	index = ipc_lock_internal(service, id);
796 	result = service->ipcs_table[index].ipct_data;
799 		mutex_exit(&service->ipcs_table[index].ipct_lock);
803 	ASSERT(IPC_SEQ(id) == service->ipcs_table[index].ipct_seq);
807 		audit_ipc(service->ipcs_atype, id, result);
809 	return (&service->ipcs_table[index].ipct_lock);
866  * Internal function to grow the service ID table.
869 ipc_grow(ipc_service_t *service)
874 	ASSERT(MUTEX_HELD(&service->ipcs_lock));
877 	if (service->ipcs_tabsz == IPC_IDS_MAX)
880 	oldsize = service->ipcs_tabsz;
886 	old = service->ipcs_table;
897 	service->ipcs_table = new;
899 	service->ipcs_tabsz = newsize;
906 	id_space_extend(service->ipcs_ids, oldsize, service->ipcs_tabsz);
913 ipc_keylookup(ipc_service_t *service, key_t key, int flag, kipc_perm_t **permp)
919 	ASSERT(MUTEX_HELD(&service->ipcs_lock));
923 	if (perm = avl_find(&service->ipcs_keys, &template, &where)) {
942 ipc_alloc_test(ipc_service_t *service, proc_t *pp)
944 	ASSERT(MUTEX_HELD(&service->ipcs_lock));
954 	if ((rctl_test(service->ipcs_proj_rctl, pp->p_task->tk_proj->kpj_rctls,
956 	    (rctl_test(service->ipcs_zone_rctl, pp->p_zone->zone_rctls,
962 	if (service->ipcs_count == service->ipcs_tabsz) {
966 		if (error = ipc_grow(service))
979  * allocated object structure in permp.  A pointer to the held service
990 ipc_get(ipc_service_t *service, key_t key, int flag, kipc_perm_t **permp,
1000 		mutex_enter(&service->ipcs_lock);
1001 		error = ipc_keylookup(service, key, flag, &perm);
1003 			index = ipc_lock_internal(service, perm->ipc_id);
1004 		mutex_exit(&service->ipcs_lock);
1014 			*lockp = &service->ipcs_table[index].ipct_lock;
1021 	perm = kmem_zalloc(service->ipcs_ssize, KM_SLEEP);
1023 	mutex_enter(&service->ipcs_lock);
1024 	if (error = ipc_alloc_test(service, pp)) {
1025 		mutex_exit(&service->ipcs_lock);
1026 		kmem_free(perm, service->ipcs_ssize);
1038 	*lockp = &service->ipcs_lock;
1048  * and the service lock held.
1055 ipc_commit_begin(ipc_service_t *service, key_t key, int flag,
1074 	mutex_enter(&service->ipcs_lock);
1079 	    (((error = ipc_keylookup(service, key, flag, &perm)) != 0) ||
1090 	if (error = ipc_alloc_test(service, pp))
1093 	ASSERT(MUTEX_HELD(&service->ipcs_lock));
1098 	mutex_exit(&service->ipcs_lock);
1099 	service->ipcs_dtor(newperm);
1101 	kmem_free(newperm, service->ipcs_ssize);
1107  * service lock held, both of which are dropped.  Returns the held ID
1111 ipc_commit_end(ipc_service_t *service, kipc_perm_t *perm)
1118 	ASSERT(MUTEX_HELD(&service->ipcs_lock));
1127 	service->ipcs_count++;
1128 	index = id_alloc(service->ipcs_ids);
1129 	ASSERT(index < service->ipcs_tabsz);
1130 	slot = &service->ipcs_table[index];
1145 		loc = avl_find(&service->ipcs_keys, perm, &where);
1147 		avl_insert(&service->ipcs_keys, perm, where);
1149 	list_insert_head(&service->ipcs_usedids, perm);
1154 	IPC_PROJ_USAGE(perm, service) += 1;
1155 	IPC_ZONE_USAGE(perm, service) += 1;
1157 	mutex_exit(&service->ipcs_lock);
1168 ipc_cleanup(ipc_service_t *service, kipc_perm_t *perm)
1173 		mutex_exit(&service->ipcs_lock);
1174 		service->ipcs_dtor(perm);
1178 	kmem_free(perm, service->ipcs_ssize);
1184  * all permissions checks have been performed, and with the service
1187  * dropping the service lock).
1190 ipc_remove(ipc_service_t *service, kipc_perm_t *perm)
1195 	ASSERT(MUTEX_HELD(&service->ipcs_lock));
1196 	ASSERT(IPC_LOCKED(service, perm));
1200 	service->ipcs_table[index].ipct_data = NULL;
1203 		avl_remove(&service->ipcs_keys, perm);
1204 	list_remove(&service->ipcs_usedids, perm);
1207 	id_free(service->ipcs_ids, index);
1209 	if (service->ipcs_table[index].ipct_seq++ == IPC_SEQ_MASK)
1210 		service->ipcs_table[index].ipct_seq = 0;
1211 	service->ipcs_count--;
1212 	ASSERT(IPC_PROJ_USAGE(perm, service) > 0);
1213 	ASSERT(IPC_ZONE_USAGE(perm, service) > 0);
1214 	IPC_PROJ_USAGE(perm, service) -= 1;
1215 	IPC_ZONE_USAGE(perm, service) -= 1;
1216 	ASSERT(service->ipcs_count || ((IPC_PROJ_USAGE(perm, service) == 0) &&
1217 	    (IPC_ZONE_USAGE(perm, service) == 0)));
1226 ipc_rmid(ipc_service_t *service, int id, cred_t *cr)
1231 	mutex_enter(&service->ipcs_lock);
1233 	lock = ipc_lookup(service, id, &perm);
1235 		mutex_exit(&service->ipcs_lock);
1239 	ASSERT(service->ipcs_count > 0);
1243 		mutex_exit(&service->ipcs_lock);
1250 	ipc_remove(service, perm);
1251 	mutex_exit(&service->ipcs_lock);
1253 	/* perform any per-service removal actions */
1254 	service->ipcs_rmid(perm);
1256 	ipc_rele(service, perm);
1268 ipc_ids(ipc_service_t *service, int *buf, uint_t nids, uint_t *pnids)
1291 	idcount = service->ipcs_count;
1302 		mutex_enter(&service->ipcs_lock);
1303 		if (idcount >= service->ipcs_count)
1305 		idcount = service->ipcs_count;
1306 		mutex_exit(&service->ipcs_lock);
1314 	for (perm = list_head(&service->ipcs_usedids); perm != NULL;
1315 	    perm = list_next(&service->ipcs_usedids, perm)) {
1320 	mutex_exit(&service->ipcs_lock);
1339  * Destroy IPC objects from the given service that are associated with
1342  * We can't hold on to the service lock when freeing objects, so we
1343  * first search the service and move all the objects to a private
1347 ipc_remove_zone(ipc_service_t *service, zoneid_t zoneid)
1356 	mutex_enter(&service->ipcs_lock);
1357 	for (perm = list_head(&service->ipcs_usedids); perm != NULL;
1359 		next = list_next(&service->ipcs_usedids, perm);
1364 		 * Remove the object from the service, then put it on
1368 		 * the service lock.
1371 		lock = ipc_lock(service, perm->ipc_id);
1372 		ipc_remove(service, perm);
1376 	mutex_exit(&service->ipcs_lock);
1379 	 * Now that we've dropped the service lock, loop through the
1386 		(void) ipc_lock(service, perm->ipc_id);
1388 		/* perform any per-service removal actions */
1389 		service->ipcs_rmid(perm);
1392 		ipc_rele(service, perm);

Indexes created Tue Jul 24 14:28:13 CEST 2018