osfmk/ipc/ipc_right.c

101  *		Finds an entry in a space, given the name.
103  *		Nothing locked.  If successful, the space is write-locked.
106  *		KERN_INVALID_TASK	The space is dead.
107  *		KERN_INVALID_NAME	Name doesn't exist in space.
112 	ipc_space_t		space,
118 	assert(space != IS_NULL);
120 	is_write_lock(space);
122 	if (!is_active(space)) {
123 		is_write_unlock(space);
127 	if ((entry = ipc_entry_lookup(space, name)) == IE_NULL) {
128 		is_write_unlock(space);
141  *		up under the same space lock.
143  *		Nothing locked.  If successful, the space is write-locked.
145  *		KERN_INVALID_TASK	The space is dead.
146  *		KERN_INVALID_NAME	Name doesn't exist in space.
151 	ipc_space_t		space,
160 	assert(space != IS_NULL);
162 	is_write_lock(space);
164 	if (!is_active(space)) {
165 		is_write_unlock(space);
169 	if ((entry1 = ipc_entry_lookup(space, name1)) == IE_NULL) {
170 		is_write_unlock(space);
173 	if ((entry2 = ipc_entry_lookup(space, name2)) == IE_NULL) {
174 		is_write_unlock(space);
185  *		Translate (space, object) -> (name, entry).
190  *		The space must be locked (read or write) and active.
196 	ipc_space_t		space,
207 	assert(is_active(space));
219 	if (port->ip_receiver == space) {
223 		entry = ipc_entry_lookup(space, name);
234 	if (ipc_hash_lookup(space, (ipc_object_t) port, namep, entryp)) {
258  *		KERN_INVALID_TASK	The space is dead.
259  *		KERN_INVALID_NAME	Name doesn't exist in space.
270 	ipc_space_t		space,
289 		kr = ipc_right_lookup_write(space, name, &entry);
293 		/* space is write-locked and active */
299 			is_write_unlock(space);
311 			if (!ipc_right_check(space, port, name, entry)) {
320 					ipc_entry_modified(space, name, entry);
321 					is_write_unlock(space);
336 					ipc_entry_modified(space, name, entry);
337 					is_write_unlock(space);
361 					is_write_unlock(space);
375 				ipc_entry_modified(space, name, entry);
376 				is_write_unlock(space);
400 				is_write_unlock(space);
407 			ipc_entry_modified(space, name, entry);
408 			is_write_unlock(space);
418 		is_write_unlock(space);
439  *		The space must be write-locked; the port must be locked.
440  *		The port must be active; the space doesn't have to be.
445 	__unused ipc_space_t		space,
460 	ipc_entry_modified(space, name, entry);
470  *		The space is write-locked and active.
476 	ipc_space_t			space,
481 		is_write_unlock(space);
493  *		The space is write-locked; the port is not locked.
503 	ipc_space_t		space,
510 	assert(is_active(space));
541 		ipc_hash_delete(space, (ipc_object_t)port, name, entry);
554 	 * because the latter doesn't have a space reference and
572 	ipc_entry_modified(space, name, entry);
579  *		Cleans up an entry in a terminated space.
583  *		The space is dead and unlocked.
588 	ipc_space_t		space,
598 	assert(!is_active(space));
604 	 *	would still work, but dead space refs would accumulate
645 		request = ipc_right_request_cancel_macro(space, port,
666 			assert(port->ip_receiver == space);
682 			assert(port->ip_receiver != space);
704  *		Destroys an entry in a space.
706  *		The space is write-locked (returns unlocked).
707  *		The space must be active.
714 	ipc_space_t		space,
727 	assert(is_active(space));
734 		ipc_entry_dealloc(space, name, entry);
735 		is_write_unlock(space);
745 		ipc_entry_dealloc(space, name, entry);
748 		is_write_unlock(space);
767 			ipc_hash_delete(space, (ipc_object_t) port,
777 			ipc_entry_dealloc(space, name, entry);
778 			is_write_unlock(space);
790 			is_write_unlock(space);
797 		request = ipc_right_request_cancel_macro(space, port, name, entry);
800 		ipc_entry_dealloc(space, name, entry);
801 		is_write_unlock(space);
820 			assert(port->ip_receiver == space);
838 			assert(port->ip_receiver != space);
868  *		The space is write-locked, and is unlocked upon return.
869  *		The space must be active.
877 	ipc_space_t		space,
889 	assert(is_active(space));
900 			ipc_entry_dealloc(space, name, entry);
903 			ipc_entry_modified(space, name, entry);
905 		is_write_unlock(space);
921 		if (ipc_right_check(space, port, name, entry)) {
931 		request = ipc_right_request_cancel_macro(space, port, name, entry);
935 		ipc_entry_dealloc(space, name, entry);
937 		is_write_unlock(space);
957 		if (ipc_right_check(space, port, name, entry)) {
975 			request = ipc_right_request_cancel_macro(space, port,
977 			ipc_hash_delete(space, (ipc_object_t) port,
982 			ipc_entry_dealloc(space, name, entry);
983 			is_write_unlock(space);
989 			ipc_entry_modified(space, name, entry);
990 			is_write_unlock(space);
1014 		assert(port->ip_receiver == space);
1033 		ipc_entry_modified(space, name, entry);
1034 		is_write_unlock(space);
1042 		is_write_unlock(space);
1055  *		The space is write-locked, and is unlocked upon return.
1056  *		The space must be active.
1066 	ipc_space_t		space,
1083  *	we postpone doing so when we are holding the space lock.
1086 	assert(is_active(space));
1112 		ipc_entry_dealloc(space, name, entry);
1116 		is_write_unlock(space);
1143 		 *	until just before dropping the space lock.
1149 		assert(port->ip_receiver == space);
1155 			is_write_unlock(space);
1179 				ipc_entry_modified(space, name, entry);
1181 				ipc_hash_insert(space, (ipc_object_t) port,
1200 				ipc_entry_modified(space, name, entry);
1206 			request = ipc_right_request_cancel_macro(space, port,
1209 			ipc_entry_dealloc(space, name, entry);
1211 		is_write_unlock(space);
1239 		if (ipc_right_check(space, port, name, entry)) {
1257 		request = ipc_right_request_cancel_macro(space, port, name, entry);
1261 		ipc_entry_dealloc(space, name, entry);
1263 		is_write_unlock(space);
1281 			if (!ipc_right_check(space, port, name, entry)) {
1305 			ipc_entry_dealloc(space, name, entry);
1308 			ipc_entry_modified(space, name, entry);
1310 		is_write_unlock(space);
1332 		if (ipc_right_check(space, port, name, entry)) {
1361 				assert(port->ip_receiver == space);
1368 				ipc_entry_modified(space, name, entry);
1373 				request = ipc_right_request_cancel_macro(space, port,
1375 				ipc_hash_delete(space, (ipc_object_t) port,
1382 				ipc_entry_dealloc(space, name, entry);
1387 			ipc_entry_modified(space, name, entry);
1390 		is_write_unlock(space);
1407 	is_write_unlock(space);
1411 	is_write_unlock(space);
1417 	is_write_unlock(space);
1421 	is_write_unlock(space);
1434  *		The space is write-locked, and is unlocked upon return.
1435  *		The space must be active.
1444 	ipc_space_t		space,
1464 	assert(is_active(space));
1468 		is_write_unlock(space);
1481 	assert(port->ip_receiver == space);
1487 		is_write_unlock(space);
1529 	 * Now destroy the receive right. Update space and
1549 			ipc_entry_modified(space, name, entry);
1551 			ipc_hash_insert(space, (ipc_object_t) port,
1570 			ipc_entry_modified(space, name, entry);
1575 		request = ipc_right_request_cancel_macro(space, port,
1578 		ipc_entry_dealloc(space, name, entry);
1581 	/* Unlock space */
1582 	is_write_unlock(space);
1602 	is_write_unlock(space);
1613  *		The space is active and write-locked.
1614  *	        The space is unlocked upon return.
1621 	ipc_space_t		space,
1645 		is_write_unlock(space);
1653 		if (!ipc_right_check(space, port, name, entry)) {
1657 			is_write_unlock(space);
1661 			is_write_unlock(space);
1665 		is_write_unlock(space);
1680  *		The space is locked (read or write) and active.
1685 	__assert_only ipc_space_t	space,
1698 	assert(is_active(space));
1815  *		Copyin a capability from a space.
1829  *		The space is write-locked and active.
1837 	ipc_space_t		space,
1865 	assert(is_active(space));
1879 		assert(port->ip_receiver == space);
1912 		assert(port->ip_receiver == space);
1945 		assert(port->ip_receiver == space);
1964 			ipc_hash_insert(space, (ipc_object_t) port,
1971 			request = ipc_right_request_cancel_macro(space, port,
1976 		ipc_entry_modified(space, name, entry);
2023 		if (ipc_right_check(space, port, name, entry)) {
2075 		if (ipc_right_check(space, port, name, entry)) {
2106 				assert(port->ip_receiver == space);
2115 				request = ipc_right_request_cancel_macro(space, port,
2117 				ipc_hash_delete(space, (ipc_object_t) port,
2128 		ipc_entry_modified(space, name, entry);
2152 		if (ipc_right_check(space, port, name, entry)) {
2181 		request = ipc_right_request_cancel_macro(space, port, name, entry);
2187 		ipc_entry_modified(space, name, entry);
2226 	ipc_entry_modified(space, name, entry);
2240  *		The space is write-locked and active.
2245 	ipc_space_t		space,
2256 	assert(is_active(space));
2303 		(void) ipc_right_check(space, (ipc_port_t) object,
2307 	ipc_entry_modified(space, name, entry);
2321  *		The space is write-locked and active.
2330 	ipc_space_t		space,
2348 	assert(is_active(space));
2362 	if (ipc_right_check(space, port, name, entry)) {
2383 			assert(port->ip_receiver == space);
2393 			request = ipc_right_request_cancel_macro(space, port,
2398 			ipc_hash_delete(space, (ipc_object_t) port,
2409 	ipc_entry_modified(space, name, entry);
2424  *		Copyout a capability to a space.
2435  *		The space is write-locked and active.
2437  *		The object is unlocked; the space isn't.
2447 	ipc_space_t		space,
2476 		if (space->is_task) {
2477 			tasklabel_lock(space->is_task);
2478 			rc = mac_port_check_hold_send_once(&space->is_task->maclabel,
2480 			tasklabel_unlock(space->is_task);
2492 		ipc_entry_modified(space, name, entry);
2499 		if (space->is_task) {
2500 			tasklabel_lock(space->is_task);
2501 			rc = mac_port_check_hold_send(&space->is_task->maclabel,
2503 			tasklabel_unlock(space->is_task);
2553 			ipc_hash_insert(space, (ipc_object_t) port,
2558 		ipc_entry_modified(space, name, entry);
2573 		if (space->is_task) {
2574 			tasklabel_lock(space->is_task);
2575 			rc = mac_port_check_hold_receive(&space->is_task->maclabel,
2577 			tasklabel_unlock(space->is_task);
2587 		port->ip_receiver = space;
2601 			ipc_hash_delete(space, (ipc_object_t) port,
2611 		ipc_entry_modified(space, name, entry);
2643  *		The space is write-locked and active.
2645  *		the space is unlocked.
2652 	ipc_space_t		space,
2663 	assert(is_active(space));
2680 		if (ipc_right_check(space, port, oname, oentry)) {
2713 	  	ipc_hash_delete(space, (ipc_object_t) port, oname, oentry);
2714 		ipc_hash_insert(space, (ipc_object_t) port, nname, nentry);
2728 		assert(port->ip_receiver == space);
2760 	ipc_entry_dealloc(space, oname, oentry);
2761 	ipc_entry_modified(space, nname, nentry);
2762 	is_write_unlock(space);