![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ipc_right.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / OSKit-Mach / ipc|
Return to ipc_right.c CVS log | Up to [GnuMach] / OSKit-Mach / ipc |
1.1 root 1: /*
2: * Mach Operating System
3: * Copyright (c) 1991,1990,1989 Carnegie Mellon University
4: * All Rights Reserved.
5: *
6: * Permission to use, copy, modify and distribute this software and its
7: * documentation is hereby granted, provided that both the copyright
8: * notice and this permission notice appear in all copies of the
9: * software, derivative works or modified versions, and any portions
10: * thereof, and that both notices appear in supporting documentation.
11: *
12: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
13: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
14: * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
15: *
16: * Carnegie Mellon requests users of this software to return to
17: *
18: * Software Distribution Coordinator or [email protected]
19: * School of Computer Science
20: * Carnegie Mellon University
21: * Pittsburgh PA 15213-3890
22: *
23: * any improvements or extensions that they make and grant Carnegie Mellon
24: * the rights to redistribute these changes.
25: */
26: /*
27: */
28: /*
29: * File: ipc/ipc_right.c
30: * Author: Rich Draves
31: * Date: 1989
32: *
33: * Functions to manipulate IPC capabilities.
34: */
35:
36: #include <mach_ipc_compat.h>
37:
38: #include <mach/boolean.h>
39: #include <mach/kern_return.h>
40: #include <mach/port.h>
41: #include <mach/message.h>
42: #include <kern/assert.h>
43: #include <ipc/port.h>
44: #include <ipc/ipc_entry.h>
45: #include <ipc/ipc_space.h>
46: #include <ipc/ipc_object.h>
47: #include <ipc/ipc_hash.h>
48: #include <ipc/ipc_port.h>
49: #include <ipc/ipc_pset.h>
50: #include <ipc/ipc_marequest.h>
51: #include <ipc/ipc_right.h>
52: #include <ipc/ipc_notify.h>
53:
54:
55:
56: /*
57: * Routine: ipc_right_lookup_write
58: * Purpose:
59: * Finds an entry in a space, given the name.
60: * Conditions:
61: * Nothing locked. If successful, the space is write-locked.
62: * Returns:
63: * KERN_SUCCESS Found an entry.
64: * KERN_INVALID_TASK The space is dead.
65: * KERN_INVALID_NAME Name doesn't exist in space.
66: */
67:
68: kern_return_t
69: ipc_right_lookup_write(
70: ipc_space_t space,
71: mach_port_t name,
72: ipc_entry_t *entryp)
73: {
74: ipc_entry_t entry;
75:
76: assert(space != IS_NULL);
77:
78: is_write_lock(space);
79:
80: if (!space->is_active) {
81: is_write_unlock(space);
82: return KERN_INVALID_TASK;
83: }
84:
85: if ((entry = ipc_entry_lookup(space, name)) == IE_NULL) {
86: is_write_unlock(space);
87: return KERN_INVALID_NAME;
88: }
89:
90: *entryp = entry;
91: return KERN_SUCCESS;
92: }
93:
94: /*
95: * Routine: ipc_right_reverse
96: * Purpose:
97: * Translate (space, object) -> (name, entry).
98: * Only finds send/receive rights.
99: * Returns TRUE if an entry is found; if so,
100: * the object is locked and active.
101: * Conditions:
102: * The space must be locked (read or write) and active.
103: * Nothing else locked.
104: */
105:
106: boolean_t
107: ipc_right_reverse(
108: ipc_space_t space,
109: ipc_object_t object,
110: mach_port_t *namep,
111: ipc_entry_t *entryp)
112: {
113: ipc_port_t port;
114: mach_port_t name;
115: ipc_entry_t entry;
116:
117: /* would switch on io_otype to handle multiple types of object */
118:
119: assert(space->is_active);
120: assert(io_otype(object) == IOT_PORT);
121:
122: port = (ipc_port_t) object;
123:
124: ip_lock(port);
125: if (!ip_active(port)) {
126: ip_unlock(port);
127:
128: return FALSE;
129: }
130:
131: if (port->ip_receiver == space) {
132: name = port->ip_receiver_name;
133: assert(name != MACH_PORT_NULL);
134:
135: entry = ipc_entry_lookup(space, name);
136:
137: assert(entry != IE_NULL);
138: assert(entry->ie_bits & MACH_PORT_TYPE_RECEIVE);
139: assert(port == (ipc_port_t) entry->ie_object);
140:
141: *namep = name;
142: *entryp = entry;
143: return TRUE;
144: }
145:
146: if (ipc_hash_lookup(space, (ipc_object_t) port, namep, entryp)) {
147: assert((entry = *entryp) != IE_NULL);
148: assert(IE_BITS_TYPE(entry->ie_bits) == MACH_PORT_TYPE_SEND);
149: assert(port == (ipc_port_t) entry->ie_object);
150:
151: return TRUE;
152: }
153:
154: ip_unlock(port);
155: return FALSE;
156: }
157:
158: /*
159: * Routine: ipc_right_dnrequest
160: * Purpose:
161: * Make a dead-name request, returning the previously
162: * registered send-once right. If notify is IP_NULL,
163: * just cancels the previously registered request.
164: *
165: * This interacts with the IE_BITS_COMPAT, because they
166: * both use ie_request. If this is a compat entry, then
167: * previous always gets IP_NULL. If notify is IP_NULL,
168: * then the entry remains a compat entry. Otherwise
169: * the real dead-name request is registered and the entry
170: * is no longer a compat entry.
171: * Conditions:
172: * Nothing locked. May allocate memory.
173: * Only consumes/returns refs if successful.
174: * Returns:
175: * KERN_SUCCESS Made/canceled dead-name request.
176: * KERN_INVALID_TASK The space is dead.
177: * KERN_INVALID_NAME Name doesn't exist in space.
178: * KERN_INVALID_RIGHT Name doesn't denote port/dead rights.
179: * KERN_INVALID_ARGUMENT Name denotes dead name, but
180: * immediate is FALSE or notify is IP_NULL.
181: * KERN_UREFS_OVERFLOW Name denotes dead name, but
182: * generating immediate notif. would overflow urefs.
183: * KERN_RESOURCE_SHORTAGE Couldn't allocate memory.
184: */
185:
186: kern_return_t
187: ipc_right_dnrequest(
188: ipc_space_t space,
189: mach_port_t name,
190: boolean_t immediate,
191: ipc_port_t notify,
192: ipc_port_t *previousp)
193: {
194: ipc_port_t previous;
195:
196: for (;;) {
197: ipc_entry_t entry;
198: ipc_entry_bits_t bits;
199: kern_return_t kr;
200:
201: kr = ipc_right_lookup_write(space, name, &entry);
202: if (kr != KERN_SUCCESS)
203: return kr;
204: /* space is write-locked and active */
205:
206: bits = entry->ie_bits;
207: if (bits & MACH_PORT_TYPE_PORT_RIGHTS) {
208: ipc_port_t port;
209: ipc_port_request_index_t request;
210:
211: port = (ipc_port_t) entry->ie_object;
212: assert(port != IP_NULL);
213:
214: if (!ipc_right_check(space, port, name, entry)) {
215: /* port is locked and active */
216:
217: if (notify == IP_NULL) {
218: #if MACH_IPC_COMPAT
219: if (bits & IE_BITS_COMPAT) {
220: assert(entry->ie_request != 0);
221:
222: previous = IP_NULL;
223: } else
224: #endif /* MACH_IPC_COMPAT */
225: previous = ipc_right_dncancel_macro(
226: space, port, name, entry);
227:
228: ip_unlock(port);
229: is_write_unlock(space);
230: break;
231: }
232:
233: /*
234: * If a registered soright exists,
235: * want to atomically switch with it.
236: * If ipc_port_dncancel finds us a
237: * soright, then the following
238: * ipc_port_dnrequest will reuse
239: * that slot, so we are guaranteed
240: * not to unlock and retry.
241: */
242:
243: previous = ipc_right_dncancel_macro(space,
244: port, name, entry);
245:
246: kr = ipc_port_dnrequest(port, name, notify,
247: &request);
248: if (kr != KERN_SUCCESS) {
249: assert(previous == IP_NULL);
250: is_write_unlock(space);
251:
252: kr = ipc_port_dngrow(port);
253: /* port is unlocked */
254: if (kr != KERN_SUCCESS)
255: return kr;
256:
257: continue;
258: }
259:
260: assert(request != 0);
261: ip_unlock(port);
262:
263: entry->ie_request = request;
264: #if MACH_IPC_COMPAT
265: entry->ie_bits = bits &~ IE_BITS_COMPAT;
266: #endif /* MACH_IPC_COMPAT */
267: is_write_unlock(space);
268: break;
269: }
270:
271: #if MACH_IPC_COMPAT
272: if (bits & IE_BITS_COMPAT) {
273: is_write_unlock(space);
274: return KERN_INVALID_NAME;
275: }
276: #endif /* MACH_IPC_COMPAT */
277:
278: bits = entry->ie_bits;
279: assert(bits & MACH_PORT_TYPE_DEAD_NAME);
280: }
281:
282: if ((bits & MACH_PORT_TYPE_DEAD_NAME) &&
283: immediate && (notify != IP_NULL)) {
284: mach_port_urefs_t urefs = IE_BITS_UREFS(bits);
285:
286: assert(IE_BITS_TYPE(bits) == MACH_PORT_TYPE_DEAD_NAME);
287: assert(urefs > 0);
288:
289: if (MACH_PORT_UREFS_OVERFLOW(urefs, 1)) {
290: is_write_unlock(space);
291: return KERN_UREFS_OVERFLOW;
292: }
293:
294: entry->ie_bits = bits + 1; /* increment urefs */
295: is_write_unlock(space);
296:
297: ipc_notify_dead_name(notify, name);
298: previous = IP_NULL;
299: break;
300: }
301:
302: is_write_unlock(space);
303: if (bits & MACH_PORT_TYPE_PORT_OR_DEAD)
304: return KERN_INVALID_ARGUMENT;
305: else
306: return KERN_INVALID_RIGHT;
307: }
308:
309: *previousp = previous;
310: return KERN_SUCCESS;
311: }
312:
313: /*
314: * Routine: ipc_right_dncancel
315: * Purpose:
316: * Cancel a dead-name request and return the send-once right.
317: * Afterwards, entry->ie_request == 0.
318: * Conditions:
319: * The space must be write-locked; the port must be locked.
320: * The port must be active; the space doesn't have to be.
321: */
322:
323: ipc_port_t
324: ipc_right_dncancel(
325: ipc_space_t space,
326: ipc_port_t port,
327: mach_port_t name,
328: ipc_entry_t entry)
329: {
330: ipc_port_t dnrequest;
331:
332: assert(ip_active(port));
333: assert(port == (ipc_port_t) entry->ie_object);
334:
335: dnrequest = ipc_port_dncancel(port, name, entry->ie_request);
336: entry->ie_request = 0;
337:
338: #if MACH_IPC_COMPAT
339: assert(!ipr_spacep(dnrequest) == !(entry->ie_bits & IE_BITS_COMPAT));
340:
341: /* if this is actually a space ptr, just release the ref */
342:
343: if (entry->ie_bits & IE_BITS_COMPAT) {
344: assert(space == ipr_space(dnrequest));
345:
346: is_release(space);
347: dnrequest = IP_NULL;
348: }
349: #endif /* MACH_IPC_COMPAT */
350:
351: return dnrequest;
352: }
353:
354: /*
355: * Routine: ipc_right_inuse
356: * Purpose:
357: * Check if an entry is being used.
358: * Returns TRUE if it is.
359: * Conditions:
360: * The space is write-locked and active.
361: * It is unlocked if the entry is inuse.
362: */
363:
364: boolean_t
365: ipc_right_inuse(space, name, entry)
366: ipc_space_t space;
367: mach_port_t name;
368: ipc_entry_t entry;
369: {
370: ipc_entry_bits_t bits = entry->ie_bits;
371:
372: if (IE_BITS_TYPE(bits) != MACH_PORT_TYPE_NONE) {
373: #if MACH_IPC_COMPAT
374: mach_port_type_t type = IE_BITS_TYPE(bits);
375:
376: /*
377: * There is yet hope. If the port has died, we
378: * must clean up the entry so it's as good as new.
379: */
380:
381: if ((bits & IE_BITS_COMPAT) &&
382: ((type == MACH_PORT_TYPE_SEND) ||
383: (type == MACH_PORT_TYPE_SEND_ONCE))) {
384: ipc_port_t port;
385: boolean_t active;
386:
387: assert(IE_BITS_UREFS(bits) > 0);
388: assert(entry->ie_request != 0);
389:
390: port = (ipc_port_t) entry->ie_object;
391: assert(port != IP_NULL);
392:
393: ip_lock(port);
394: active = ip_active(port);
395: ip_unlock(port);
396:
397: if (!active) {
398: if (type == MACH_PORT_TYPE_SEND) {
399: /* clean up msg-accepted request */
400:
401: if (bits & IE_BITS_MAREQUEST)
402: ipc_marequest_cancel(
403: space, name);
404:
405: ipc_hash_delete(
406: space, (ipc_object_t) port,
407: name, entry);
408: } else {
409: assert(IE_BITS_UREFS(bits) == 1);
410: assert(!(bits & IE_BITS_MAREQUEST));
411: }
412:
413: ipc_port_release(port);
414:
415: entry->ie_request = 0;
416: entry->ie_object = IO_NULL;
417: entry->ie_bits &= ~IE_BITS_RIGHT_MASK;
418:
419: return FALSE;
420: }
421: }
422: #endif /* MACH_IPC_COMPAT */
423:
424: is_write_unlock(space);
425: return TRUE;
426: }
427:
428: return FALSE;
429: }
430:
431: /*
432: * Routine: ipc_right_check
433: * Purpose:
434: * Check if the port has died. If it has,
435: * clean up the entry and return TRUE.
436: * Conditions:
437: * The space is write-locked; the port is not locked.
438: * If returns FALSE, the port is also locked and active.
439: * Otherwise, entry is converted to a dead name, freeing
440: * a reference to port.
441: *
442: * [MACH_IPC_COMPAT] If the port is dead, and this is a
443: * compat mode entry, then the port reference is released
444: * and the entry is destroyed. The call returns TRUE,
445: * and the space is left locked.
446: */
447:
448: boolean_t
449: ipc_right_check(space, port, name, entry)
450: ipc_space_t space;
451: ipc_port_t port;
452: mach_port_t name;
453: ipc_entry_t entry;
454: {
455: ipc_entry_bits_t bits;
456:
457: assert(space->is_active);
458: assert(port == (ipc_port_t) entry->ie_object);
459:
460: ip_lock(port);
461: if (ip_active(port))
462: return FALSE;
463: ip_unlock(port);
464:
465: /* this was either a pure send right or a send-once right */
466:
467: bits = entry->ie_bits;
468: assert((bits & MACH_PORT_TYPE_RECEIVE) == 0);
469: assert(IE_BITS_UREFS(bits) > 0);
470:
471: if (bits & MACH_PORT_TYPE_SEND) {
472: assert(IE_BITS_TYPE(bits) == MACH_PORT_TYPE_SEND);
473:
474: /* clean up msg-accepted request */
475:
476: if (bits & IE_BITS_MAREQUEST) {
477: bits &= ~IE_BITS_MAREQUEST;
478:
479: ipc_marequest_cancel(space, name);
480: }
481:
482: ipc_hash_delete(space, (ipc_object_t) port, name, entry);
483: } else {
484: assert(IE_BITS_TYPE(bits) == MACH_PORT_TYPE_SEND_ONCE);
485: assert(IE_BITS_UREFS(bits) == 1);
486: assert((bits & IE_BITS_MAREQUEST) == 0);
487: }
488:
489: ipc_port_release(port);
490:
491: #if MACH_IPC_COMPAT
492: if (bits & IE_BITS_COMPAT) {
493: assert(entry->ie_request != 0);
494: entry->ie_request = 0;
495:
496: entry->ie_object = IO_NULL;
497: ipc_entry_dealloc(space, name, entry);
498:
499: return TRUE;
500: }
501: #endif /* MACH_IPC_COMPAT */
502:
503: /* convert entry to dead name */
504:
505: bits = (bits &~ IE_BITS_TYPE_MASK) | MACH_PORT_TYPE_DEAD_NAME;
506:
507: if (entry->ie_request != 0) {
508: assert(IE_BITS_UREFS(bits) < MACH_PORT_UREFS_MAX);
509:
510: entry->ie_request = 0;
511: bits++; /* increment urefs */
512: }
513:
514: entry->ie_bits = bits;
515: entry->ie_object = IO_NULL;
516:
517: return TRUE;
518: }
519:
520: /*
521: * Routine: ipc_right_clean
522: * Purpose:
523: * Cleans up an entry in a dead space.
524: * The entry isn't deallocated or removed
525: * from reverse hash tables.
526: * Conditions:
527: * The space is dead and unlocked.
528: */
529:
530: void
531: ipc_right_clean(
532: ipc_space_t space,
533: mach_port_t name,
534: ipc_entry_t entry)
535: {
536: ipc_entry_bits_t bits = entry->ie_bits;
537: mach_port_type_t type = IE_BITS_TYPE(bits);
538:
539: assert(!space->is_active);
540:
541: /*
542: * We can't clean up IE_BITS_MAREQUEST when the space is dead.
543: * This is because ipc_marequest_destroy can't turn off
544: * the bit if the space is dead. Hence, it might be on
545: * even though the marequest has been destroyed. It's OK
546: * not to cancel the marequest, because ipc_marequest_destroy
547: * cancels for us if the space is dead.
548: *
549: * IE_BITS_COMPAT/ipc_right_dncancel doesn't have this
550: * problem, because we check that the port is active. If
551: * we didn't cancel IE_BITS_COMPAT, ipc_port_destroy
552: * would still work, but dead space refs would accumulate
553: * in ip_dnrequests. They would use up slots in
554: * ip_dnrequests and keep the spaces from being freed.
555: */
556:
557: switch (type) {
558: case MACH_PORT_TYPE_DEAD_NAME:
559: assert(entry->ie_request == 0);
560: assert(entry->ie_object == IO_NULL);
561: assert((bits & IE_BITS_MAREQUEST) == 0);
562: break;
563:
564: case MACH_PORT_TYPE_PORT_SET: {
565: ipc_pset_t pset = (ipc_pset_t) entry->ie_object;
566:
567: assert(entry->ie_request == 0);
568: assert((bits & IE_BITS_MAREQUEST) == 0);
569: assert(pset != IPS_NULL);
570:
571: ips_lock(pset);
572: assert(ips_active(pset));
573:
574: ipc_pset_destroy(pset); /* consumes ref, unlocks */
575: break;
576: }
577:
578: case MACH_PORT_TYPE_SEND:
579: case MACH_PORT_TYPE_RECEIVE:
580: case MACH_PORT_TYPE_SEND_RECEIVE:
581: case MACH_PORT_TYPE_SEND_ONCE: {
582: ipc_port_t port = (ipc_port_t) entry->ie_object;
583: ipc_port_t dnrequest;
584: ipc_port_t nsrequest = IP_NULL;
585: mach_port_mscount_t mscount = 0; /* '=0' to shut up lint */
586:
587: assert(port != IP_NULL);
588: ip_lock(port);
589:
590: if (!ip_active(port)) {
591: ip_release(port);
592: ip_check_unlock(port);
593: break;
594: }
595:
596: dnrequest = ipc_right_dncancel_macro(space, port, name, entry);
597:
598: if (type & MACH_PORT_TYPE_SEND) {
599: assert(port->ip_srights > 0);
600: if (--port->ip_srights == 0) {
601: nsrequest = port->ip_nsrequest;
602: if (nsrequest != IP_NULL) {
603: port->ip_nsrequest = IP_NULL;
604: mscount = port->ip_mscount;
605: }
606: }
607: }
608:
609: if (type & MACH_PORT_TYPE_RECEIVE) {
610: assert(port->ip_receiver_name == name);
611: assert(port->ip_receiver == space);
612:
613: ipc_port_clear_receiver(port);
614: ipc_port_destroy(port); /* consumes our ref, unlocks */
615: } else if (type & MACH_PORT_TYPE_SEND_ONCE) {
616: assert(port->ip_sorights > 0);
617: ip_unlock(port);
618:
619: ipc_notify_send_once(port); /* consumes our ref */
620: } else {
621: assert(port->ip_receiver != space);
622:
623: ip_release(port);
624: ip_unlock(port); /* port is active */
625: }
626:
627: if (nsrequest != IP_NULL)
628: ipc_notify_no_senders(nsrequest, mscount);
629:
630: if (dnrequest != IP_NULL)
631: ipc_notify_port_deleted(dnrequest, name);
632: break;
633: }
634:
635: default:
636: #if MACH_ASSERT
637: assert(!"ipc_right_clean: strange type");
638: #else
639: panic("ipc_right_clean: strange type");
640: #endif
641: }
642: }
643:
644: /*
645: * Routine: ipc_right_destroy
646: * Purpose:
647: * Destroys an entry in a space.
648: * Conditions:
649: * The space is write-locked, and is unlocked upon return.
650: * The space must be active.
651: * Returns:
652: * KERN_SUCCESS The entry was destroyed.
653: */
654:
655: kern_return_t
656: ipc_right_destroy(
657: ipc_space_t space,
658: mach_port_t name,
659: ipc_entry_t entry)
660: {
661: ipc_entry_bits_t bits = entry->ie_bits;
662: mach_port_type_t type = IE_BITS_TYPE(bits);
663:
664: assert(space->is_active);
665:
666: switch (type) {
667: case MACH_PORT_TYPE_DEAD_NAME:
668: assert(entry->ie_request == 0);
669: assert(entry->ie_object == IO_NULL);
670: assert((bits & IE_BITS_MAREQUEST) == 0);
671:
672: ipc_entry_dealloc(space, name, entry);
673: is_write_unlock(space);
674: break;
675:
676: case MACH_PORT_TYPE_PORT_SET: {
677: ipc_pset_t pset = (ipc_pset_t) entry->ie_object;
678:
679: assert(entry->ie_request == 0);
680: assert(pset != IPS_NULL);
681:
682: entry->ie_object = IO_NULL;
683: ipc_entry_dealloc(space, name, entry);
684:
685: ips_lock(pset);
686: assert(ips_active(pset));
687: is_write_unlock(space);
688:
689: ipc_pset_destroy(pset); /* consumes ref, unlocks */
690: break;
691: }
692:
693: case MACH_PORT_TYPE_SEND:
694: case MACH_PORT_TYPE_RECEIVE:
695: case MACH_PORT_TYPE_SEND_RECEIVE:
696: case MACH_PORT_TYPE_SEND_ONCE: {
697: ipc_port_t port = (ipc_port_t) entry->ie_object;
698: ipc_port_t nsrequest = IP_NULL;
699: mach_port_mscount_t mscount = 0; /* '=0' to shut up lint */
700: ipc_port_t dnrequest;
701:
702: assert(port != IP_NULL);
703:
704: if (bits & IE_BITS_MAREQUEST) {
705: assert(type & MACH_PORT_TYPE_SEND_RECEIVE);
706:
707: ipc_marequest_cancel(space, name);
708: }
709:
710: if (type == MACH_PORT_TYPE_SEND)
711: ipc_hash_delete(space, (ipc_object_t) port,
712: name, entry);
713:
714: ip_lock(port);
715:
716: if (!ip_active(port)) {
717: assert((type & MACH_PORT_TYPE_RECEIVE) == 0);
718:
719: ip_release(port);
720: ip_check_unlock(port);
721:
722: entry->ie_request = 0;
723: entry->ie_object = IO_NULL;
724: ipc_entry_dealloc(space, name, entry);
725: is_write_unlock(space);
726:
727: #if MACH_IPC_COMPAT
728: if (bits & IE_BITS_COMPAT)
729: return KERN_INVALID_NAME;
730: #endif /* MACH_IPC_COMPAT */
731: break;
732: }
733:
734: dnrequest = ipc_right_dncancel_macro(space, port, name, entry);
735:
736: entry->ie_object = IO_NULL;
737: ipc_entry_dealloc(space, name, entry);
738: is_write_unlock(space);
739:
740: if (type & MACH_PORT_TYPE_SEND) {
741: assert(port->ip_srights > 0);
742: if (--port->ip_srights == 0) {
743: nsrequest = port->ip_nsrequest;
744: if (nsrequest != IP_NULL) {
745: port->ip_nsrequest = IP_NULL;
746: mscount = port->ip_mscount;
747: }
748: }
749: }
750:
751: if (type & MACH_PORT_TYPE_RECEIVE) {
752: assert(ip_active(port));
753: assert(port->ip_receiver == space);
754:
755: ipc_port_clear_receiver(port);
756: ipc_port_destroy(port); /* consumes our ref, unlocks */
757: } else if (type & MACH_PORT_TYPE_SEND_ONCE) {
758: assert(port->ip_sorights > 0);
759: ip_unlock(port);
760:
761: ipc_notify_send_once(port); /* consumes our ref */
762: } else {
763: assert(port->ip_receiver != space);
764:
765: ip_release(port);
766: ip_unlock(port);
767: }
768:
769: if (nsrequest != IP_NULL)
770: ipc_notify_no_senders(nsrequest, mscount);
771:
772: if (dnrequest != IP_NULL)
773: ipc_notify_port_deleted(dnrequest, name);
774: break;
775: }
776:
777: default:
778: #if MACH_ASSERT
779: assert(!"ipc_right_destroy: strange type");
780: #else
781: panic("ipc_right_destroy: strange type");
782: #endif
783: }
784:
785: return KERN_SUCCESS;
786: }
787:
788: /*
789: * Routine: ipc_right_dealloc
790: * Purpose:
791: * Releases a send/send-once/dead-name user ref.
792: * Like ipc_right_delta with a delta of -1,
793: * but looks at the entry to determine the right.
794: * Conditions:
795: * The space is write-locked, and is unlocked upon return.
796: * The space must be active.
797: * Returns:
798: * KERN_SUCCESS A user ref was released.
799: * KERN_INVALID_RIGHT Entry has wrong type.
800: * KERN_INVALID_NAME [MACH_IPC_COMPAT]
801: * Caller should pretend lookup of entry failed.
802: */
803:
804: kern_return_t
805: ipc_right_dealloc(space, name, entry)
806: ipc_space_t space;
807: mach_port_t name;
808: ipc_entry_t entry;
809: {
810: ipc_entry_bits_t bits = entry->ie_bits;
811: mach_port_type_t type = IE_BITS_TYPE(bits);
812:
813: assert(space->is_active);
814:
815: switch (type) {
816: case MACH_PORT_TYPE_DEAD_NAME: {
817: dead_name:
818:
819: assert(IE_BITS_UREFS(bits) > 0);
820: assert(entry->ie_request == 0);
821: assert(entry->ie_object == IO_NULL);
822: assert((bits & IE_BITS_MAREQUEST) == 0);
823:
824: if (IE_BITS_UREFS(bits) == 1)
825: ipc_entry_dealloc(space, name, entry);
826: else
827: entry->ie_bits = bits-1; /* decrement urefs */
828:
829: is_write_unlock(space);
830: break;
831: }
832:
833: case MACH_PORT_TYPE_SEND_ONCE: {
834: ipc_port_t port, dnrequest;
835:
836: assert(IE_BITS_UREFS(bits) == 1);
837: assert((bits & IE_BITS_MAREQUEST) == 0);
838:
839: port = (ipc_port_t) entry->ie_object;
840: assert(port != IP_NULL);
841:
842: if (ipc_right_check(space, port, name, entry)) {
843: #if MACH_IPC_COMPAT
844: if (bits & IE_BITS_COMPAT)
845: goto invalid_name;
846: #endif /* MACH_IPC_COMPAT */
847:
848: bits = entry->ie_bits;
849: assert(IE_BITS_TYPE(bits) == MACH_PORT_TYPE_DEAD_NAME);
850: goto dead_name;
851: }
852: /* port is locked and active */
853:
854: assert(port->ip_sorights > 0);
855:
856: dnrequest = ipc_right_dncancel_macro(space, port, name, entry);
857: ip_unlock(port);
858:
859: entry->ie_object = IO_NULL;
860: ipc_entry_dealloc(space, name, entry);
861: is_write_unlock(space);
862:
863: ipc_notify_send_once(port);
864:
865: if (dnrequest != IP_NULL)
866: ipc_notify_port_deleted(dnrequest, name);
867: break;
868: }
869:
870: case MACH_PORT_TYPE_SEND: {
871: ipc_port_t port;
872: ipc_port_t dnrequest = IP_NULL;
873: ipc_port_t nsrequest = IP_NULL;
874: mach_port_mscount_t mscount = 0; /* '=0' to shut up lint */
875:
876: assert(IE_BITS_UREFS(bits) > 0);
877:
878: port = (ipc_port_t) entry->ie_object;
879: assert(port != IP_NULL);
880:
881: if (ipc_right_check(space, port, name, entry)) {
882: #if MACH_IPC_COMPAT
883: if (bits & IE_BITS_COMPAT)
884: goto invalid_name;
885: #endif /* MACH_IPC_COMPAT */
886:
887: bits = entry->ie_bits;
888: assert(IE_BITS_TYPE(bits) == MACH_PORT_TYPE_DEAD_NAME);
889: goto dead_name;
890: }
891: /* port is locked and active */
892:
893: assert(port->ip_srights > 0);
894:
895: if (IE_BITS_UREFS(bits) == 1) {
896: if (--port->ip_srights == 0) {
897: nsrequest = port->ip_nsrequest;
898: if (nsrequest != IP_NULL) {
899: port->ip_nsrequest = IP_NULL;
900: mscount = port->ip_mscount;
901: }
902: }
903:
904: dnrequest = ipc_right_dncancel_macro(space, port,
905: name, entry);
906:
907: ipc_hash_delete(space, (ipc_object_t) port,
908: name, entry);
909:
910: if (bits & IE_BITS_MAREQUEST)
911: ipc_marequest_cancel(space, name);
912:
913: ip_release(port);
914: entry->ie_object = IO_NULL;
915: ipc_entry_dealloc(space, name, entry);
916: } else
917: entry->ie_bits = bits-1; /* decrement urefs */
918:
919: ip_unlock(port); /* even if dropped a ref, port is active */
920: is_write_unlock(space);
921:
922: if (nsrequest != IP_NULL)
923: ipc_notify_no_senders(nsrequest, mscount);
924:
925: if (dnrequest != IP_NULL)
926: ipc_notify_port_deleted(dnrequest, name);
927: break;
928: }
929:
930: case MACH_PORT_TYPE_SEND_RECEIVE: {
931: ipc_port_t port;
932: ipc_port_t nsrequest = IP_NULL;
933: mach_port_mscount_t mscount = 0; /* '=0' to shut up lint */
934:
935: assert(IE_BITS_UREFS(bits) > 0);
936:
937: port = (ipc_port_t) entry->ie_object;
938: assert(port != IP_NULL);
939:
940: ip_lock(port);
941: assert(ip_active(port));
942: assert(port->ip_receiver_name == name);
943: assert(port->ip_receiver == space);
944: assert(port->ip_srights > 0);
945:
946: if (IE_BITS_UREFS(bits) == 1) {
947: if (--port->ip_srights == 0) {
948: nsrequest = port->ip_nsrequest;
949: if (nsrequest != IP_NULL) {
950: port->ip_nsrequest = IP_NULL;
951: mscount = port->ip_mscount;
952: }
953: }
954:
955: entry->ie_bits = bits &~ (IE_BITS_UREFS_MASK|
956: MACH_PORT_TYPE_SEND);
957: } else
958: entry->ie_bits = bits-1; /* decrement urefs */
959:
960: ip_unlock(port);
961: is_write_unlock(space);
962:
963: if (nsrequest != IP_NULL)
964: ipc_notify_no_senders(nsrequest, mscount);
965: break;
966: }
967:
968: default:
969: is_write_unlock(space);
970: return KERN_INVALID_RIGHT;
971: }
972:
973: return KERN_SUCCESS;
974:
975: #if MACH_IPC_COMPAT
976: invalid_name:
977: is_write_unlock(space);
978: return KERN_INVALID_NAME;
979: #endif /* MACH_IPC_COMPAT */
980: }
981:
982: /*
983: * Routine: ipc_right_delta
984: * Purpose:
985: * Modifies the user-reference count for a right.
986: * May deallocate the right, if the count goes to zero.
987: * Conditions:
988: * The space is write-locked, and is unlocked upon return.
989: * The space must be active.
990: * Returns:
991: * KERN_SUCCESS Count was modified.
992: * KERN_INVALID_RIGHT Entry has wrong type.
993: * KERN_INVALID_VALUE Bad delta for the right.
994: * KERN_UREFS_OVERFLOW OK delta, except would overflow.
995: * KERN_INVALID_NAME [MACH_IPC_COMPAT]
996: * Caller should pretend lookup of entry failed.
997: */
998:
999: kern_return_t
1000: ipc_right_delta(space, name, entry, right, delta)
1001: ipc_space_t space;
1002: mach_port_t name;
1003: ipc_entry_t entry;
1004: mach_port_right_t right;
1005: mach_port_delta_t delta;
1006: {
1007: ipc_entry_bits_t bits = entry->ie_bits;
1008:
1009: assert(space->is_active);
1010: assert(right < MACH_PORT_RIGHT_NUMBER);
1011:
1012: /* Rights-specific restrictions and operations. */
1013:
1014: switch (right) {
1015: case MACH_PORT_RIGHT_PORT_SET: {
1016: ipc_pset_t pset;
1017:
1018: if ((bits & MACH_PORT_TYPE_PORT_SET) == 0)
1019: goto invalid_right;
1020:
1021: assert(IE_BITS_TYPE(bits) == MACH_PORT_TYPE_PORT_SET);
1022: assert(IE_BITS_UREFS(bits) == 0);
1023: assert((bits & IE_BITS_MAREQUEST) == 0);
1024: assert(entry->ie_request == 0);
1025:
1026: if (delta == 0)
1027: goto success;
1028:
1029: if (delta != -1)
1030: goto invalid_value;
1031:
1032: pset = (ipc_pset_t) entry->ie_object;
1033: assert(pset != IPS_NULL);
1034:
1035: entry->ie_object = IO_NULL;
1036: ipc_entry_dealloc(space, name, entry);
1037:
1038: ips_lock(pset);
1039: assert(ips_active(pset));
1040: is_write_unlock(space);
1041:
1042: ipc_pset_destroy(pset); /* consumes ref, unlocks */
1043: break;
1044: }
1045:
1046: case MACH_PORT_RIGHT_RECEIVE: {
1047: ipc_port_t port;
1048: ipc_port_t dnrequest = IP_NULL;
1049:
1050: if ((bits & MACH_PORT_TYPE_RECEIVE) == 0)
1051: goto invalid_right;
1052:
1053: if (delta == 0)
1054: goto success;
1055:
1056: if (delta != -1)
1057: goto invalid_value;
1058:
1059: if (bits & IE_BITS_MAREQUEST) {
1060: bits &= ~IE_BITS_MAREQUEST;
1061:
1062: ipc_marequest_cancel(space, name);
1063: }
1064:
1065: port = (ipc_port_t) entry->ie_object;
1066: assert(port != IP_NULL);
1067:
1068: /*
1069: * The port lock is needed for ipc_right_dncancel;
1070: * otherwise, we wouldn't have to take the lock
1071: * until just before dropping the space lock.
1072: */
1073:
1074: ip_lock(port);
1075: assert(ip_active(port));
1076: assert(port->ip_receiver_name == name);
1077: assert(port->ip_receiver == space);
1078:
1079: #if MACH_IPC_COMPAT
1080: if (bits & IE_BITS_COMPAT) {
1081: assert(entry->ie_request != 0);
1082: dnrequest = ipc_right_dncancel(space, port,
1083: name, entry);
1084: assert(dnrequest == IP_NULL);
1085:
1086: entry->ie_object = IO_NULL;
1087: ipc_entry_dealloc(space, name, entry);
1088: } else
1089: #endif /* MACH_IPC_COMPAT */
1090: if (bits & MACH_PORT_TYPE_SEND) {
1091: assert(IE_BITS_TYPE(bits) ==
1092: MACH_PORT_TYPE_SEND_RECEIVE);
1093: assert(IE_BITS_UREFS(bits) > 0);
1094: assert(IE_BITS_UREFS(bits) < MACH_PORT_UREFS_MAX);
1095: assert(port->ip_srights > 0);
1096:
1097: /*
1098: * The remaining send right turns into a
1099: * dead name. Notice we don't decrement
1100: * ip_srights, generate a no-senders notif,
1101: * or use ipc_right_dncancel, because the
1102: * port is destroyed "first".
1103: */
1104:
1105: bits &= ~IE_BITS_TYPE_MASK;
1106: bits |= MACH_PORT_TYPE_DEAD_NAME;
1107:
1108: if (entry->ie_request != 0) {
1109: entry->ie_request = 0;
1110: bits++; /* increment urefs */
1111: }
1112:
1113: entry->ie_bits = bits;
1114: entry->ie_object = IO_NULL;
1115: } else {
1116: assert(IE_BITS_TYPE(bits) == MACH_PORT_TYPE_RECEIVE);
1117: assert(IE_BITS_UREFS(bits) == 0);
1118:
1119: dnrequest = ipc_right_dncancel_macro(space, port,
1120: name, entry);
1121:
1122: entry->ie_object = IO_NULL;
1123: ipc_entry_dealloc(space, name, entry);
1124: }
1125: is_write_unlock(space);
1126:
1127: ipc_port_clear_receiver(port);
1128: ipc_port_destroy(port); /* consumes ref, unlocks */
1129:
1130: if (dnrequest != IP_NULL)
1131: ipc_notify_port_deleted(dnrequest, name);
1132: break;
1133: }
1134:
1135: case MACH_PORT_RIGHT_SEND_ONCE: {
1136: ipc_port_t port, dnrequest;
1137:
1138: if ((bits & MACH_PORT_TYPE_SEND_ONCE) == 0)
1139: goto invalid_right;
1140:
1141: assert(IE_BITS_TYPE(bits) == MACH_PORT_TYPE_SEND_ONCE);
1142: assert(IE_BITS_UREFS(bits) == 1);
1143: assert((bits & IE_BITS_MAREQUEST) == 0);
1144:
1145: if ((delta > 0) || (delta < -1))
1146: goto invalid_value;
1147:
1148: port = (ipc_port_t) entry->ie_object;
1149: assert(port != IP_NULL);
1150:
1151: if (ipc_right_check(space, port, name, entry)) {
1152: #if MACH_IPC_COMPAT
1153: if (bits & IE_BITS_COMPAT)
1154: goto invalid_name;
1155: #endif /* MACH_IPC_COMPAT */
1156:
1157: assert(!(entry->ie_bits & MACH_PORT_TYPE_SEND_ONCE));
1158: goto invalid_right;
1159: }
1160: /* port is locked and active */
1161:
1162: assert(port->ip_sorights > 0);
1163:
1164: if (delta == 0) {
1165: ip_unlock(port);
1166: goto success;
1167: }
1168:
1169: dnrequest = ipc_right_dncancel_macro(space, port, name, entry);
1170: ip_unlock(port);
1171:
1172: entry->ie_object = IO_NULL;
1173: ipc_entry_dealloc(space, name, entry);
1174: is_write_unlock(space);
1175:
1176: ipc_notify_send_once(port);
1177:
1178: if (dnrequest != IP_NULL)
1179: ipc_notify_port_deleted(dnrequest, name);
1180: break;
1181: }
1182:
1183: case MACH_PORT_RIGHT_DEAD_NAME: {
1184: mach_port_urefs_t urefs;
1185:
1186: if (bits & MACH_PORT_TYPE_SEND_RIGHTS) {
1187: ipc_port_t port;
1188:
1189: port = (ipc_port_t) entry->ie_object;
1190: assert(port != IP_NULL);
1191:
1192: if (!ipc_right_check(space, port, name, entry)) {
1193: /* port is locked and active */
1194: ip_unlock(port);
1195: goto invalid_right;
1196: }
1197:
1198: #if MACH_IPC_COMPAT
1199: if (bits & IE_BITS_COMPAT)
1200: goto invalid_name;
1201: #endif /* MACH_IPC_COMPAT */
1202:
1203: bits = entry->ie_bits;
1204: } else if ((bits & MACH_PORT_TYPE_DEAD_NAME) == 0)
1205: goto invalid_right;
1206:
1207: assert(IE_BITS_TYPE(bits) == MACH_PORT_TYPE_DEAD_NAME);
1208: assert(IE_BITS_UREFS(bits) > 0);
1209: assert((bits & IE_BITS_MAREQUEST) == 0);
1210: assert(entry->ie_object == IO_NULL);
1211: assert(entry->ie_request == 0);
1212:
1213: urefs = IE_BITS_UREFS(bits);
1214: if (MACH_PORT_UREFS_UNDERFLOW(urefs, delta))
1215: goto invalid_value;
1216: if (MACH_PORT_UREFS_OVERFLOW(urefs, delta))
1217: goto urefs_overflow;
1218:
1219: if ((urefs + delta) == 0)
1220: ipc_entry_dealloc(space, name, entry);
1221: else
1222: entry->ie_bits = bits + delta;
1223:
1224: is_write_unlock(space);
1225: break;
1226: }
1227:
1228: case MACH_PORT_RIGHT_SEND: {
1229: mach_port_urefs_t urefs;
1230: ipc_port_t port;
1231: ipc_port_t dnrequest = IP_NULL;
1232: ipc_port_t nsrequest = IP_NULL;
1233: mach_port_mscount_t mscount = 0; /* '=0' to shut up lint */
1234:
1235: if ((bits & MACH_PORT_TYPE_SEND) == 0)
1236: goto invalid_right;
1237:
1238: /* maximum urefs for send is MACH_PORT_UREFS_MAX-1 */
1239:
1240: urefs = IE_BITS_UREFS(bits);
1241: if (MACH_PORT_UREFS_UNDERFLOW(urefs, delta))
1242: goto invalid_value;
1243: if (MACH_PORT_UREFS_OVERFLOW(urefs+1, delta))
1244: goto urefs_overflow;
1245:
1246: port = (ipc_port_t) entry->ie_object;
1247: assert(port != IP_NULL);
1248:
1249: if (ipc_right_check(space, port, name, entry)) {
1250: #if MACH_IPC_COMPAT
1251: if (bits & IE_BITS_COMPAT)
1252: goto invalid_name;
1253: #endif /* MACH_IPC_COMPAT */
1254:
1255: assert((entry->ie_bits & MACH_PORT_TYPE_SEND) == 0);
1256: goto invalid_right;
1257: }
1258: /* port is locked and active */
1259:
1260: assert(port->ip_srights > 0);
1261:
1262: if ((urefs + delta) == 0) {
1263: if (--port->ip_srights == 0) {
1264: nsrequest = port->ip_nsrequest;
1265: if (nsrequest != IP_NULL) {
1266: port->ip_nsrequest = IP_NULL;
1267: mscount = port->ip_mscount;
1268: }
1269: }
1270:
1271: if (bits & MACH_PORT_TYPE_RECEIVE) {
1272: assert(port->ip_receiver_name == name);
1273: assert(port->ip_receiver == space);
1274: assert(IE_BITS_TYPE(bits) ==
1275: MACH_PORT_TYPE_SEND_RECEIVE);
1276:
1277: entry->ie_bits = bits &~ (IE_BITS_UREFS_MASK|
1278: MACH_PORT_TYPE_SEND);
1279: } else {
1280: assert(IE_BITS_TYPE(bits) ==
1281: MACH_PORT_TYPE_SEND);
1282:
1283: dnrequest = ipc_right_dncancel_macro(
1284: space, port, name, entry);
1285:
1286: ipc_hash_delete(space, (ipc_object_t) port,
1287: name, entry);
1288:
1289: if (bits & IE_BITS_MAREQUEST)
1290: ipc_marequest_cancel(space, name);
1291:
1292: ip_release(port);
1293: entry->ie_object = IO_NULL;
1294: ipc_entry_dealloc(space, name, entry);
1295: }
1296: } else
1297: entry->ie_bits = bits + delta;
1298:
1299: ip_unlock(port); /* even if dropped a ref, port is active */
1300: is_write_unlock(space);
1301:
1302: if (nsrequest != IP_NULL)
1303: ipc_notify_no_senders(nsrequest, mscount);
1304:
1305: if (dnrequest != IP_NULL)
1306: ipc_notify_port_deleted(dnrequest, name);
1307: break;
1308: }
1309:
1310: default:
1311: #if MACH_ASSERT
1312: assert(!"ipc_right_delta: strange right");
1313: #else
1314: panic("ipc_right_delta: strange right");
1315: #endif
1316: }
1317:
1318: return KERN_SUCCESS;
1319:
1320: success:
1321: is_write_unlock(space);
1322: return KERN_SUCCESS;
1323:
1324: invalid_right:
1325: is_write_unlock(space);
1326: return KERN_INVALID_RIGHT;
1327:
1328: invalid_value:
1329: is_write_unlock(space);
1330: return KERN_INVALID_VALUE;
1331:
1332: urefs_overflow:
1333: is_write_unlock(space);
1334: return KERN_UREFS_OVERFLOW;
1335:
1336: #if MACH_IPC_COMPAT
1337: invalid_name:
1338: is_write_unlock(space);
1339: return KERN_INVALID_NAME;
1340: #endif /* MACH_IPC_COMPAT */
1341: }
1342:
1343: /*
1344: * Routine: ipc_right_info
1345: * Purpose:
1346: * Retrieves information about the right.
1347: * Conditions:
1348: * The space is write-locked, and is unlocked upon return
1349: * if the call is unsuccessful. The space must be active.
1350: * Returns:
1351: * KERN_SUCCESS Retrieved info; space still locked.
1352: */
1353:
1354: kern_return_t
1355: ipc_right_info(
1356: ipc_space_t space,
1357: mach_port_t name,
1358: ipc_entry_t entry,
1359: mach_port_type_t *typep,
1360: mach_port_urefs_t *urefsp)
1361: {
1362: ipc_entry_bits_t bits = entry->ie_bits;
1363: ipc_port_request_index_t request;
1364: mach_port_type_t type;
1365:
1366: if (bits & MACH_PORT_TYPE_SEND_RIGHTS) {
1367: ipc_port_t port = (ipc_port_t) entry->ie_object;
1368:
1369: if (ipc_right_check(space, port, name, entry)) {
1370: #if MACH_IPC_COMPAT
1371: if (bits & IE_BITS_COMPAT) {
1372: is_write_unlock(space);
1373: return KERN_INVALID_NAME;
1374: }
1375: #endif /* MACH_IPC_COMPAT */
1376:
1377: bits = entry->ie_bits;
1378: assert(IE_BITS_TYPE(bits) == MACH_PORT_TYPE_DEAD_NAME);
1379: } else
1380: ip_unlock(port);
1381: }
1382:
1383: type = IE_BITS_TYPE(bits);
1384: request = entry->ie_request;
1385:
1386: #if MACH_IPC_COMPAT
1387: if (bits & IE_BITS_COMPAT)
1388: type |= MACH_PORT_TYPE_COMPAT;
1389: else
1390: #endif /* MACH_IPC_COMPAT */
1391: if (request != 0)
1392: type |= MACH_PORT_TYPE_DNREQUEST;
1393: if (bits & IE_BITS_MAREQUEST)
1394: type |= MACH_PORT_TYPE_MAREQUEST;
1395:
1396: *typep = type;
1397: *urefsp = IE_BITS_UREFS(bits);
1398: return KERN_SUCCESS;
1399: }
1400:
1401: /*
1402: * Routine: ipc_right_copyin_check
1403: * Purpose:
1404: * Check if a subsequent ipc_right_copyin would succeed.
1405: * Conditions:
1406: * The space is locked (read or write) and active.
1407: */
1408:
1409: boolean_t
1410: ipc_right_copyin_check(
1411: ipc_space_t space,
1412: mach_port_t name,
1413: ipc_entry_t entry,
1414: mach_msg_type_name_t msgt_name)
1415: {
1416: ipc_entry_bits_t bits = entry->ie_bits;
1417:
1418: assert(space->is_active);
1419:
1420: switch (msgt_name) {
1421: case MACH_MSG_TYPE_MAKE_SEND:
1422: case MACH_MSG_TYPE_MAKE_SEND_ONCE:
1423: case MACH_MSG_TYPE_MOVE_RECEIVE:
1424: if ((bits & MACH_PORT_TYPE_RECEIVE) == 0)
1425: return FALSE;
1426:
1427: break;
1428:
1429: case MACH_MSG_TYPE_COPY_SEND:
1430: case MACH_MSG_TYPE_MOVE_SEND:
1431: case MACH_MSG_TYPE_MOVE_SEND_ONCE: {
1432: ipc_port_t port;
1433: boolean_t active;
1434:
1435: if (bits & MACH_PORT_TYPE_DEAD_NAME)
1436: break;
1437:
1438: if ((bits & MACH_PORT_TYPE_SEND_RIGHTS) == 0)
1439: return FALSE;
1440:
1441: port = (ipc_port_t) entry->ie_object;
1442: assert(port != IP_NULL);
1443:
1444: ip_lock(port);
1445: active = ip_active(port);
1446: ip_unlock(port);
1447:
1448: if (!active) {
1449: #if MACH_IPC_COMPAT
1450: if (bits & IE_BITS_COMPAT)
1451: return FALSE;
1452: #endif /* MACH_IPC_COMPAT */
1453:
1454: break;
1455: }
1456:
1457: if (msgt_name == MACH_MSG_TYPE_MOVE_SEND_ONCE) {
1458: if ((bits & MACH_PORT_TYPE_SEND_ONCE) == 0)
1459: return FALSE;
1460: } else {
1461: if ((bits & MACH_PORT_TYPE_SEND) == 0)
1462: return FALSE;
1463: }
1464:
1465: break;
1466: }
1467:
1468: default:
1469: #if MACH_ASSERT
1470: assert(!"ipc_right_copyin_check: strange rights");
1471: #else
1472: panic("ipc_right_copyin_check: strange rights");
1473: #endif
1474: }
1475:
1476: return TRUE;
1477: }
1478:
1479: /*
1480: * Routine: ipc_right_copyin
1481: * Purpose:
1482: * Copyin a capability from a space.
1483: * If successful, the caller gets a ref
1484: * for the resulting object, unless it is IO_DEAD,
1485: * and possibly a send-once right which should
1486: * be used in a port-deleted notification.
1487: *
1488: * If deadok is not TRUE, the copyin operation
1489: * will fail instead of producing IO_DEAD.
1490: *
1491: * The entry is never deallocated (except
1492: * when KERN_INVALID_NAME), so the caller
1493: * should deallocate the entry if its type
1494: * is MACH_PORT_TYPE_NONE.
1495: * Conditions:
1496: * The space is write-locked and active.
1497: * Returns:
1498: * KERN_SUCCESS Acquired an object, possibly IO_DEAD.
1499: * KERN_INVALID_RIGHT Name doesn't denote correct right.
1500: */
1501:
1502: kern_return_t
1503: ipc_right_copyin(
1504: ipc_space_t space,
1505: mach_port_t name,
1506: ipc_entry_t entry,
1507: mach_msg_type_name_t msgt_name,
1508: boolean_t deadok,
1509: ipc_object_t *objectp,
1510: ipc_port_t *sorightp)
1511: {
1512: ipc_entry_bits_t bits = entry->ie_bits;
1513:
1514: assert(space->is_active);
1515:
1516: switch (msgt_name) {
1517: case MACH_MSG_TYPE_MAKE_SEND: {
1518: ipc_port_t port;
1519:
1520: if ((bits & MACH_PORT_TYPE_RECEIVE) == 0)
1521: goto invalid_right;
1522:
1523: port = (ipc_port_t) entry->ie_object;
1524: assert(port != IP_NULL);
1525:
1526: ip_lock(port);
1527: assert(ip_active(port));
1528: assert(port->ip_receiver_name == name);
1529: assert(port->ip_receiver == space);
1530:
1531: port->ip_mscount++;
1532: port->ip_srights++;
1533: ip_reference(port);
1534: ip_unlock(port);
1535:
1536: *objectp = (ipc_object_t) port;
1537: *sorightp = IP_NULL;
1538: break;
1539: }
1540:
1541: case MACH_MSG_TYPE_MAKE_SEND_ONCE: {
1542: ipc_port_t port;
1543:
1544: if ((bits & MACH_PORT_TYPE_RECEIVE) == 0)
1545: goto invalid_right;
1546:
1547: port = (ipc_port_t) entry->ie_object;
1548: assert(port != IP_NULL);
1549:
1550: ip_lock(port);
1551: assert(ip_active(port));
1552: assert(port->ip_receiver_name == name);
1553: assert(port->ip_receiver == space);
1554:
1555: port->ip_sorights++;
1556: ip_reference(port);
1557: ip_unlock(port);
1558:
1559: *objectp = (ipc_object_t) port;
1560: *sorightp = IP_NULL;
1561: break;
1562: }
1563:
1564: case MACH_MSG_TYPE_MOVE_RECEIVE: {
1565: ipc_port_t port;
1566: ipc_port_t dnrequest = IP_NULL;
1567:
1568: if ((bits & MACH_PORT_TYPE_RECEIVE) == 0)
1569: goto invalid_right;
1570:
1571: port = (ipc_port_t) entry->ie_object;
1572: assert(port != IP_NULL);
1573:
1574: ip_lock(port);
1575: assert(ip_active(port));
1576: assert(port->ip_receiver_name == name);
1577: assert(port->ip_receiver == space);
1578:
1579: if (bits & MACH_PORT_TYPE_SEND) {
1580: assert(IE_BITS_TYPE(bits) ==
1581: MACH_PORT_TYPE_SEND_RECEIVE);
1582: assert(IE_BITS_UREFS(bits) > 0);
1583: assert(port->ip_srights > 0);
1584:
1585: ipc_hash_insert(space, (ipc_object_t) port,
1586: name, entry);
1587:
1588: ip_reference(port);
1589: } else {
1590: assert(IE_BITS_TYPE(bits) == MACH_PORT_TYPE_RECEIVE);
1591: assert(IE_BITS_UREFS(bits) == 0);
1592:
1593: dnrequest = ipc_right_dncancel_macro(space, port,
1594: name, entry);
1595:
1596: if (bits & IE_BITS_MAREQUEST)
1597: ipc_marequest_cancel(space, name);
1598:
1599: entry->ie_object = IO_NULL;
1600: }
1601: entry->ie_bits = bits &~ MACH_PORT_TYPE_RECEIVE;
1602:
1603: ipc_port_clear_receiver(port);
1604:
1605: port->ip_receiver_name = MACH_PORT_NULL;
1606: port->ip_destination = IP_NULL;
1607: ip_unlock(port);
1608:
1609: *objectp = (ipc_object_t) port;
1610: *sorightp = dnrequest;
1611: break;
1612: }
1613:
1614: case MACH_MSG_TYPE_COPY_SEND: {
1615: ipc_port_t port;
1616:
1617: if (bits & MACH_PORT_TYPE_DEAD_NAME)
1618: goto copy_dead;
1619:
1620: /* allow for dead send-once rights */
1621:
1622: if ((bits & MACH_PORT_TYPE_SEND_RIGHTS) == 0)
1623: goto invalid_right;
1624:
1625: assert(IE_BITS_UREFS(bits) > 0);
1626:
1627: port = (ipc_port_t) entry->ie_object;
1628: assert(port != IP_NULL);
1629:
1630: if (ipc_right_check(space, port, name, entry)) {
1631: #if MACH_IPC_COMPAT
1632: if (bits & IE_BITS_COMPAT)
1633: goto invalid_name;
1634: #endif /* MACH_IPC_COMPAT */
1635:
1636: bits = entry->ie_bits;
1637: goto copy_dead;
1638: }
1639: /* port is locked and active */
1640:
1641: if ((bits & MACH_PORT_TYPE_SEND) == 0) {
1642: assert(IE_BITS_TYPE(bits) == MACH_PORT_TYPE_SEND_ONCE);
1643: assert(port->ip_sorights > 0);
1644:
1645: ip_unlock(port);
1646: goto invalid_right;
1647: }
1648:
1649: assert(port->ip_srights > 0);
1650:
1651: port->ip_srights++;
1652: ip_reference(port);
1653: ip_unlock(port);
1654:
1655: *objectp = (ipc_object_t) port;
1656: *sorightp = IP_NULL;
1657: break;
1658: }
1659:
1660: case MACH_MSG_TYPE_MOVE_SEND: {
1661: ipc_port_t port;
1662: ipc_port_t dnrequest = IP_NULL;
1663:
1664: if (bits & MACH_PORT_TYPE_DEAD_NAME)
1665: goto move_dead;
1666:
1667: /* allow for dead send-once rights */
1668:
1669: if ((bits & MACH_PORT_TYPE_SEND_RIGHTS) == 0)
1670: goto invalid_right;
1671:
1672: assert(IE_BITS_UREFS(bits) > 0);
1673:
1674: port = (ipc_port_t) entry->ie_object;
1675: assert(port != IP_NULL);
1676:
1677: if (ipc_right_check(space, port, name, entry)) {
1678: #if MACH_IPC_COMPAT
1679: if (bits & IE_BITS_COMPAT)
1680: goto invalid_name;
1681: #endif /* MACH_IPC_COMPAT */
1682:
1683: bits = entry->ie_bits;
1684: goto move_dead;
1685: }
1686: /* port is locked and active */
1687:
1688: if ((bits & MACH_PORT_TYPE_SEND) == 0) {
1689: assert(IE_BITS_TYPE(bits) == MACH_PORT_TYPE_SEND_ONCE);
1690: assert(port->ip_sorights > 0);
1691:
1692: ip_unlock(port);
1693: goto invalid_right;
1694: }
1695:
1696: assert(port->ip_srights > 0);
1697:
1698: if (IE_BITS_UREFS(bits) == 1) {
1699: if (bits & MACH_PORT_TYPE_RECEIVE) {
1700: assert(port->ip_receiver_name == name);
1701: assert(port->ip_receiver == space);
1702: assert(IE_BITS_TYPE(bits) ==
1703: MACH_PORT_TYPE_SEND_RECEIVE);
1704:
1705: ip_reference(port);
1706: } else {
1707: assert(IE_BITS_TYPE(bits) ==
1708: MACH_PORT_TYPE_SEND);
1709:
1710: dnrequest = ipc_right_dncancel_macro(
1711: space, port, name, entry);
1712:
1713: ipc_hash_delete(space, (ipc_object_t) port,
1714: name, entry);
1715:
1716: if (bits & IE_BITS_MAREQUEST)
1717: ipc_marequest_cancel(space, name);
1718:
1719: entry->ie_object = IO_NULL;
1720: }
1721: entry->ie_bits = bits &~
1722: (IE_BITS_UREFS_MASK|MACH_PORT_TYPE_SEND);
1723: } else {
1724: port->ip_srights++;
1725: ip_reference(port);
1726: entry->ie_bits = bits-1; /* decrement urefs */
1727: }
1728:
1729: ip_unlock(port);
1730:
1731: *objectp = (ipc_object_t) port;
1732: *sorightp = dnrequest;
1733: break;
1734: }
1735:
1736: case MACH_MSG_TYPE_MOVE_SEND_ONCE: {
1737: ipc_port_t port;
1738: ipc_port_t dnrequest;
1739:
1740: if (bits & MACH_PORT_TYPE_DEAD_NAME)
1741: goto move_dead;
1742:
1743: /* allow for dead send rights */
1744:
1745: if ((bits & MACH_PORT_TYPE_SEND_RIGHTS) == 0)
1746: goto invalid_right;
1747:
1748: assert(IE_BITS_UREFS(bits) > 0);
1749:
1750: port = (ipc_port_t) entry->ie_object;
1751: assert(port != IP_NULL);
1752:
1753: if (ipc_right_check(space, port, name, entry)) {
1754: #if MACH_IPC_COMPAT
1755: if (bits & IE_BITS_COMPAT)
1756: goto invalid_name;
1757: #endif /* MACH_IPC_COMPAT */
1758:
1759: bits = entry->ie_bits;
1760: goto move_dead;
1761: }
1762: /* port is locked and active */
1763:
1764: if ((bits & MACH_PORT_TYPE_SEND_ONCE) == 0) {
1765: assert(bits & MACH_PORT_TYPE_SEND);
1766: assert(port->ip_srights > 0);
1767:
1768: ip_unlock(port);
1769: goto invalid_right;
1770: }
1771:
1772: assert(IE_BITS_TYPE(bits) == MACH_PORT_TYPE_SEND_ONCE);
1773: assert(IE_BITS_UREFS(bits) == 1);
1774: assert((bits & IE_BITS_MAREQUEST) == 0);
1775: assert(port->ip_sorights > 0);
1776:
1777: dnrequest = ipc_right_dncancel_macro(space, port, name, entry);
1778: ip_unlock(port);
1779:
1780: entry->ie_object = IO_NULL;
1781: entry->ie_bits = bits &~ MACH_PORT_TYPE_SEND_ONCE;
1782:
1783: *objectp = (ipc_object_t) port;
1784: *sorightp = dnrequest;
1785: break;
1786: }
1787:
1788: default:
1789: #if MACH_ASSERT
1790: assert(!"ipc_right_copyin: strange rights");
1791: #else
1792: panic("ipc_right_copyin: strange rights");
1793: #endif
1794: }
1795:
1796: return KERN_SUCCESS;
1797:
1798: copy_dead:
1799: assert(IE_BITS_TYPE(bits) == MACH_PORT_TYPE_DEAD_NAME);
1800: assert(IE_BITS_UREFS(bits) > 0);
1801: assert((bits & IE_BITS_MAREQUEST) == 0);
1802: assert(entry->ie_request == 0);
1803: assert(entry->ie_object == 0);
1804:
1805: if (!deadok)
1806: goto invalid_right;
1807:
1808: *objectp = IO_DEAD;
1809: *sorightp = IP_NULL;
1810: return KERN_SUCCESS;
1811:
1812: move_dead:
1813: assert(IE_BITS_TYPE(bits) == MACH_PORT_TYPE_DEAD_NAME);
1814: assert(IE_BITS_UREFS(bits) > 0);
1815: assert((bits & IE_BITS_MAREQUEST) == 0);
1816: assert(entry->ie_request == 0);
1817: assert(entry->ie_object == 0);
1818:
1819: if (!deadok)
1820: goto invalid_right;
1821:
1822: if (IE_BITS_UREFS(bits) == 1)
1823: entry->ie_bits = bits &~ MACH_PORT_TYPE_DEAD_NAME;
1824: else
1825: entry->ie_bits = bits-1; /* decrement urefs */
1826:
1827: *objectp = IO_DEAD;
1828: *sorightp = IP_NULL;
1829: return KERN_SUCCESS;
1830:
1831: invalid_right:
1832: return KERN_INVALID_RIGHT;
1833:
1834: #if MACH_IPC_COMPAT
1835: invalid_name:
1836: return KERN_INVALID_NAME;
1837: #endif /* MACH_IPC_COMPAT */
1838: }
1839:
1840: /*
1841: * Routine: ipc_right_copyin_undo
1842: * Purpose:
1843: * Undoes the effects of an ipc_right_copyin
1844: * of a send/send-once right that is dead.
1845: * (Object is either IO_DEAD or a dead port.)
1846: * Conditions:
1847: * The space is write-locked and active.
1848: */
1849:
1850: void
1851: ipc_right_copyin_undo(
1852: ipc_space_t space,
1853: mach_port_t name,
1854: ipc_entry_t entry,
1855: mach_msg_type_name_t msgt_name,
1856: ipc_object_t object,
1857: ipc_port_t soright)
1858: {
1859: ipc_entry_bits_t bits = entry->ie_bits;
1860:
1861: assert(space->is_active);
1862:
1863: assert((msgt_name == MACH_MSG_TYPE_MOVE_SEND) ||
1864: (msgt_name == MACH_MSG_TYPE_COPY_SEND) ||
1865: (msgt_name == MACH_MSG_TYPE_MOVE_SEND_ONCE));
1866:
1867: if (soright != IP_NULL) {
1868: assert((msgt_name == MACH_MSG_TYPE_MOVE_SEND) ||
1869: (msgt_name == MACH_MSG_TYPE_MOVE_SEND_ONCE));
1870: assert(IE_BITS_TYPE(bits) == MACH_PORT_TYPE_NONE);
1871: assert(entry->ie_object == IO_NULL);
1872: assert(object != IO_DEAD);
1873:
1874: entry->ie_bits = ((bits &~ IE_BITS_RIGHT_MASK) |
1875: MACH_PORT_TYPE_DEAD_NAME | 2);
1876: } else if (IE_BITS_TYPE(bits) == MACH_PORT_TYPE_NONE) {
1877: assert((msgt_name == MACH_MSG_TYPE_MOVE_SEND) ||
1878: (msgt_name == MACH_MSG_TYPE_MOVE_SEND_ONCE));
1879: assert(entry->ie_object == IO_NULL);
1880:
1881: entry->ie_bits = ((bits &~ IE_BITS_RIGHT_MASK) |
1882: MACH_PORT_TYPE_DEAD_NAME | 1);
1883: } else if (IE_BITS_TYPE(bits) == MACH_PORT_TYPE_DEAD_NAME) {
1884: assert(entry->ie_object == IO_NULL);
1885: assert(object == IO_DEAD);
1886: assert(IE_BITS_UREFS(bits) > 0);
1887:
1888: if (msgt_name != MACH_MSG_TYPE_COPY_SEND) {
1889: assert(IE_BITS_UREFS(bits) < MACH_PORT_UREFS_MAX);
1890:
1891: entry->ie_bits = bits+1; /* increment urefs */
1892: }
1893: } else {
1894: assert((msgt_name == MACH_MSG_TYPE_MOVE_SEND) ||
1895: (msgt_name == MACH_MSG_TYPE_COPY_SEND));
1896: assert(IE_BITS_TYPE(bits) == MACH_PORT_TYPE_SEND);
1897: assert(object != IO_DEAD);
1898: assert(entry->ie_object == object);
1899: assert(IE_BITS_UREFS(bits) > 0);
1900:
1901: if (msgt_name != MACH_MSG_TYPE_COPY_SEND) {
1902: assert(IE_BITS_UREFS(bits) < MACH_PORT_UREFS_MAX-1);
1903:
1904: entry->ie_bits = bits+1; /* increment urefs */
1905: }
1906:
1907: /*
1908: * May as well convert the entry to a dead name.
1909: * (Or if it is a compat entry, destroy it.)
1910: */
1911:
1912: (void) ipc_right_check(space, (ipc_port_t) object,
1913: name, entry);
1914: /* object is dead so it is not locked */
1915: }
1916:
1917: /* release the reference acquired by copyin */
1918:
1919: if (object != IO_DEAD)
1920: ipc_object_release(object);
1921: }
1922:
1923: /*
1924: * Routine: ipc_right_copyin_two
1925: * Purpose:
1926: * Like ipc_right_copyin with MACH_MSG_TYPE_MOVE_SEND
1927: * and deadok == FALSE, except that this moves two
1928: * send rights at once.
1929: * Conditions:
1930: * The space is write-locked and active.
1931: * The object is returned with two refs/send rights.
1932: * Returns:
1933: * KERN_SUCCESS Acquired an object.
1934: * KERN_INVALID_RIGHT Name doesn't denote correct right.
1935: */
1936:
1937: kern_return_t
1938: ipc_right_copyin_two(
1939: ipc_space_t space,
1940: mach_port_t name,
1941: ipc_entry_t entry,
1942: ipc_object_t *objectp,
1943: ipc_port_t *sorightp)
1944: {
1945: ipc_entry_bits_t bits = entry->ie_bits;
1946: mach_port_urefs_t urefs;
1947: ipc_port_t port;
1948: ipc_port_t dnrequest = IP_NULL;
1949:
1950: assert(space->is_active);
1951:
1952: if ((bits & MACH_PORT_TYPE_SEND) == 0)
1953: goto invalid_right;
1954:
1955: urefs = IE_BITS_UREFS(bits);
1956: if (urefs < 2)
1957: goto invalid_right;
1958:
1959: port = (ipc_port_t) entry->ie_object;
1960: assert(port != IP_NULL);
1961:
1962: if (ipc_right_check(space, port, name, entry)) {
1963: #if MACH_IPC_COMPAT
1964: if (bits & IE_BITS_COMPAT)
1965: goto invalid_name;
1966: #endif /* MACH_IPC_COMPAT */
1967:
1968: goto invalid_right;
1969: }
1970: /* port is locked and active */
1971:
1972: assert(port->ip_srights > 0);
1973:
1974: if (urefs == 2) {
1975: if (bits & MACH_PORT_TYPE_RECEIVE) {
1976: assert(port->ip_receiver_name == name);
1977: assert(port->ip_receiver == space);
1978: assert(IE_BITS_TYPE(bits) ==
1979: MACH_PORT_TYPE_SEND_RECEIVE);
1980:
1981: port->ip_srights++;
1982: ip_reference(port);
1983: ip_reference(port);
1984: } else {
1985: assert(IE_BITS_TYPE(bits) == MACH_PORT_TYPE_SEND);
1986:
1987: dnrequest = ipc_right_dncancel_macro(space, port,
1988: name, entry);
1989:
1990: ipc_hash_delete(space, (ipc_object_t) port,
1991: name, entry);
1992:
1993: if (bits & IE_BITS_MAREQUEST)
1994: ipc_marequest_cancel(space, name);
1995:
1996: port->ip_srights++;
1997: ip_reference(port);
1998: entry->ie_object = IO_NULL;
1999: }
2000: entry->ie_bits = bits &~
2001: (IE_BITS_UREFS_MASK|MACH_PORT_TYPE_SEND);
2002: } else {
2003: port->ip_srights += 2;
2004: ip_reference(port);
2005: ip_reference(port);
2006: entry->ie_bits = bits-2; /* decrement urefs */
2007: }
2008: ip_unlock(port);
2009:
2010: *objectp = (ipc_object_t) port;
2011: *sorightp = dnrequest;
2012: return KERN_SUCCESS;
2013:
2014: invalid_right:
2015: return KERN_INVALID_RIGHT;
2016:
2017: #if MACH_IPC_COMPAT
2018: invalid_name:
2019: return KERN_INVALID_NAME;
2020: #endif /* MACH_IPC_COMPAT */
2021: }
2022:
2023: /*
2024: * Routine: ipc_right_copyout
2025: * Purpose:
2026: * Copyout a capability to a space.
2027: * If successful, consumes a ref for the object.
2028: *
2029: * Always succeeds when given a newly-allocated entry,
2030: * because user-reference overflow isn't a possibility.
2031: *
2032: * If copying out the object would cause the user-reference
2033: * count in the entry to overflow, and overflow is TRUE,
2034: * then instead the user-reference count is left pegged
2035: * to its maximum value and the copyout succeeds anyway.
2036: * Conditions:
2037: * The space is write-locked and active.
2038: * The object is locked and active.
2039: * The object is unlocked; the space isn't.
2040: * Returns:
2041: * KERN_SUCCESS Copied out capability.
2042: * KERN_UREFS_OVERFLOW User-refs would overflow;
2043: * guaranteed not to happen with a fresh entry
2044: * or if overflow=TRUE was specified.
2045: */
2046:
2047: kern_return_t
2048: ipc_right_copyout(
2049: ipc_space_t space,
2050: mach_port_t name,
2051: ipc_entry_t entry,
2052: mach_msg_type_name_t msgt_name,
2053: boolean_t overflow,
2054: ipc_object_t object)
2055: {
2056: ipc_entry_bits_t bits = entry->ie_bits;
2057: ipc_port_t port;
2058:
2059: assert(IO_VALID(object));
2060: assert(io_otype(object) == IOT_PORT);
2061: assert(io_active(object));
2062: assert(entry->ie_object == object);
2063:
2064: port = (ipc_port_t) object;
2065:
2066: switch (msgt_name) {
2067: case MACH_MSG_TYPE_PORT_SEND_ONCE:
2068: assert(IE_BITS_TYPE(bits) == MACH_PORT_TYPE_NONE);
2069: assert(port->ip_sorights > 0);
2070:
2071: /* transfer send-once right and ref to entry */
2072: ip_unlock(port);
2073:
2074: entry->ie_bits = bits | (MACH_PORT_TYPE_SEND_ONCE | 1);
2075: break;
2076:
2077: case MACH_MSG_TYPE_PORT_SEND:
2078: assert(port->ip_srights > 0);
2079:
2080: if (bits & MACH_PORT_TYPE_SEND) {
2081: mach_port_urefs_t urefs = IE_BITS_UREFS(bits);
2082:
2083: assert(port->ip_srights > 1);
2084: assert(urefs > 0);
2085: assert(urefs < MACH_PORT_UREFS_MAX);
2086:
2087: if (urefs+1 == MACH_PORT_UREFS_MAX) {
2088: if (overflow) {
2089: /* leave urefs pegged to maximum */
2090:
2091: port->ip_srights--;
2092: ip_release(port);
2093: ip_unlock(port);
2094: return KERN_SUCCESS;
2095: }
2096:
2097: ip_unlock(port);
2098: return KERN_UREFS_OVERFLOW;
2099: }
2100:
2101: port->ip_srights--;
2102: ip_release(port);
2103: ip_unlock(port);
2104: } else if (bits & MACH_PORT_TYPE_RECEIVE) {
2105: assert(IE_BITS_TYPE(bits) == MACH_PORT_TYPE_RECEIVE);
2106: assert(IE_BITS_UREFS(bits) == 0);
2107:
2108: /* transfer send right to entry */
2109: ip_release(port);
2110: ip_unlock(port);
2111: } else {
2112: assert(IE_BITS_TYPE(bits) == MACH_PORT_TYPE_NONE);
2113: assert(IE_BITS_UREFS(bits) == 0);
2114:
2115: /* transfer send right and ref to entry */
2116: ip_unlock(port);
2117:
2118: /* entry is locked holding ref, so can use port */
2119:
2120: ipc_hash_insert(space, (ipc_object_t) port,
2121: name, entry);
2122: }
2123:
2124: entry->ie_bits = (bits | MACH_PORT_TYPE_SEND) + 1;
2125: break;
2126:
2127: case MACH_MSG_TYPE_PORT_RECEIVE: {
2128: ipc_port_t dest;
2129:
2130: assert(port->ip_mscount == 0);
2131: assert(port->ip_receiver_name == MACH_PORT_NULL);
2132: dest = port->ip_destination;
2133:
2134: port->ip_receiver_name = name;
2135: port->ip_receiver = space;
2136:
2137: assert((bits & MACH_PORT_TYPE_RECEIVE) == 0);
2138:
2139: if (bits & MACH_PORT_TYPE_SEND) {
2140: assert(IE_BITS_TYPE(bits) == MACH_PORT_TYPE_SEND);
2141: assert(IE_BITS_UREFS(bits) > 0);
2142: assert(port->ip_srights > 0);
2143:
2144: ip_release(port);
2145: ip_unlock(port);
2146:
2147: /* entry is locked holding ref, so can use port */
2148:
2149: ipc_hash_delete(space, (ipc_object_t) port,
2150: name, entry);
2151: } else {
2152: assert(IE_BITS_TYPE(bits) == MACH_PORT_TYPE_NONE);
2153: assert(IE_BITS_UREFS(bits) == 0);
2154:
2155: /* transfer ref to entry */
2156: ip_unlock(port);
2157: }
2158:
2159: entry->ie_bits = bits | MACH_PORT_TYPE_RECEIVE;
2160:
2161: if (dest != IP_NULL)
2162: ipc_port_release(dest);
2163: break;
2164: }
2165:
2166: default:
2167: #if MACH_ASSERT
2168: assert(!"ipc_right_copyout: strange rights");
2169: #else
2170: panic("ipc_right_copyout: strange rights");
2171: #endif
2172: }
2173:
2174: return KERN_SUCCESS;
2175: }
2176:
2177: #if 0
2178: /*XXX same, but allows multiple duplicate send rights */
2179: kern_return_t
2180: ipc_right_copyout_multiname(space, name, entry, object)
2181: ipc_space_t space;
2182: mach_port_t name;
2183: ipc_entry_t entry;
2184: ipc_object_t object;
2185: {
2186: ipc_entry_bits_t bits = entry->ie_bits;
2187: ipc_port_t port;
2188:
2189: assert(IO_VALID(object));
2190: assert(io_otype(object) == IOT_PORT);
2191: assert(io_active(object));
2192: assert(entry->ie_object == object);
2193:
2194: port = (ipc_port_t) object;
2195:
2196: assert(port->ip_srights > 0);
2197:
2198: assert(IE_BITS_TYPE(bits) == MACH_PORT_TYPE_NONE);
2199: assert(IE_BITS_UREFS(bits) == 0);
2200:
2201: /* transfer send right and ref to entry */
2202: ip_unlock(port);
2203:
2204: /* entry is locked holding ref, so can use port */
2205:
2206: entry->ie_bits = (bits | MACH_PORT_TYPE_SEND) + 1;
2207:
2208: return KERN_SUCCESS;
2209: }
2210: #endif
2211:
2212: /*
2213: * Routine: ipc_right_rename
2214: * Purpose:
2215: * Transfer an entry from one name to another.
2216: * The old entry is deallocated.
2217: * Conditions:
2218: * The space is write-locked and active.
2219: * The new entry is unused. Upon return,
2220: * the space is unlocked.
2221: * Returns:
2222: * KERN_SUCCESS Moved entry to new name.
2223: */
2224:
2225: kern_return_t
2226: ipc_right_rename(
2227: ipc_space_t space,
2228: mach_port_t oname,
2229: ipc_entry_t oentry,
2230: mach_port_t nname,
2231: ipc_entry_t nentry)
2232: {
2233: ipc_entry_bits_t bits = oentry->ie_bits;
2234: ipc_port_request_index_t request = oentry->ie_request;
2235: ipc_object_t object = oentry->ie_object;
2236:
2237: assert(space->is_active);
2238: assert(oname != nname);
2239:
2240: /*
2241: * If IE_BITS_COMPAT, we can't allow the entry to be renamed
2242: * if the port is dead. (This would foil ipc_port_destroy.)
2243: * Instead we should fail because oentry shouldn't exist.
2244: * Note IE_BITS_COMPAT implies ie_request != 0.
2245: */
2246:
2247: if (request != 0) {
2248: ipc_port_t port;
2249:
2250: assert(bits & MACH_PORT_TYPE_PORT_RIGHTS);
2251: port = (ipc_port_t) object;
2252: assert(port != IP_NULL);
2253:
2254: if (ipc_right_check(space, port, oname, oentry)) {
2255: #if MACH_IPC_COMPAT
2256: if (bits & IE_BITS_COMPAT) {
2257: ipc_entry_dealloc(space, nname, nentry);
2258: is_write_unlock(space);
2259: return KERN_INVALID_NAME;
2260: }
2261: #endif /* MACH_IPC_COMPAT */
2262:
2263: bits = oentry->ie_bits;
2264: assert(IE_BITS_TYPE(bits) == MACH_PORT_TYPE_DEAD_NAME);
2265: assert(oentry->ie_request == 0);
2266: request = 0;
2267: assert(oentry->ie_object == IO_NULL);
2268: object = IO_NULL;
2269: } else {
2270: /* port is locked and active */
2271:
2272: ipc_port_dnrename(port, request, oname, nname);
2273: ip_unlock(port);
2274: oentry->ie_request = 0;
2275: }
2276: }
2277:
2278: if (bits & IE_BITS_MAREQUEST) {
2279: assert(bits & MACH_PORT_TYPE_SEND_RECEIVE);
2280:
2281: ipc_marequest_rename(space, oname, nname);
2282: }
2283:
2284: /* initialize nentry before letting ipc_hash_insert see it */
2285:
2286: assert((nentry->ie_bits & IE_BITS_RIGHT_MASK) == 0);
2287: nentry->ie_bits |= bits & IE_BITS_RIGHT_MASK;
2288: nentry->ie_request = request;
2289: nentry->ie_object = object;
2290:
2291: switch (IE_BITS_TYPE(bits)) {
2292: case MACH_PORT_TYPE_SEND: {
2293: ipc_port_t port;
2294:
2295: port = (ipc_port_t) object;
2296: assert(port != IP_NULL);
2297:
2298: ipc_hash_delete(space, (ipc_object_t) port, oname, oentry);
2299: ipc_hash_insert(space, (ipc_object_t) port, nname, nentry);
2300: break;
2301: }
2302:
2303: case MACH_PORT_TYPE_RECEIVE:
2304: case MACH_PORT_TYPE_SEND_RECEIVE: {
2305: ipc_port_t port;
2306:
2307: port = (ipc_port_t) object;
2308: assert(port != IP_NULL);
2309:
2310: ip_lock(port);
2311: assert(ip_active(port));
2312: assert(port->ip_receiver_name == oname);
2313: assert(port->ip_receiver == space);
2314:
2315: port->ip_receiver_name = nname;
2316: ip_unlock(port);
2317: break;
2318: }
2319:
2320: case MACH_PORT_TYPE_PORT_SET: {
2321: ipc_pset_t pset;
2322:
2323: pset = (ipc_pset_t) object;
2324: assert(pset != IPS_NULL);
2325:
2326: ips_lock(pset);
2327: assert(ips_active(pset));
2328: assert(pset->ips_local_name == oname);
2329:
2330: pset->ips_local_name = nname;
2331: ips_unlock(pset);
2332: break;
2333: }
2334:
2335: case MACH_PORT_TYPE_SEND_ONCE:
2336: case MACH_PORT_TYPE_DEAD_NAME:
2337: break;
2338:
2339: default:
2340: #if MACH_ASSERT
2341: assert(!"ipc_right_rename: strange rights");
2342: #else
2343: panic("ipc_right_rename: strange rights");
2344: #endif
2345: }
2346:
2347: assert(oentry->ie_request == 0);
2348: oentry->ie_object = IO_NULL;
2349: ipc_entry_dealloc(space, oname, oentry);
2350: is_write_unlock(space);
2351:
2352: return KERN_SUCCESS;
2353: }
2354:
2355: #if MACH_IPC_COMPAT
2356:
2357: /*
2358: * Routine: ipc_right_copyin_compat
2359: * Purpose:
2360: * Copyin a capability from a space.
2361: * If successful, the caller gets a ref
2362: * for the resulting object, which is always valid.
2363: * Conditions:
2364: * The space is write-locked, and is unlocked upon return.
2365: * The space must be active.
2366: * Returns:
2367: * KERN_SUCCESS Acquired a valid object.
2368: * KERN_INVALID_RIGHT Name doesn't denote correct right.
2369: * KERN_INVALID_NAME [MACH_IPC_COMPAT]
2370: * Caller should pretend lookup of entry failed.
2371: */
2372:
2373: kern_return_t
2374: ipc_right_copyin_compat(space, name, entry, msgt_name, dealloc, objectp)
2375: ipc_space_t space;
2376: mach_port_t name;
2377: ipc_entry_t entry;
2378: mach_msg_type_name_t msgt_name;
2379: boolean_t dealloc;
2380: ipc_object_t *objectp;
2381: {
2382: ipc_entry_bits_t bits = entry->ie_bits;
2383:
2384: assert(space->is_active);
2385:
2386: switch (msgt_name) {
2387: case MSG_TYPE_PORT:
2388: if (dealloc) {
2389: ipc_port_t port;
2390: ipc_port_t dnrequest;
2391:
2392: /*
2393: * Pulls a send right out of the space,
2394: * leaving the space with no rights.
2395: * Not allowed to destroy the port,
2396: * so the space can't have receive rights.
2397: * Doesn't operate on dead names.
2398: */
2399:
2400: if (IE_BITS_TYPE(bits) != MACH_PORT_TYPE_SEND)
2401: goto invalid_right;
2402:
2403: port = (ipc_port_t) entry->ie_object;
2404: assert(port != IP_NULL);
2405:
2406: if (ipc_right_check(space, port, name, entry)) {
2407: if (bits & IE_BITS_COMPAT)
2408: goto invalid_name;
2409:
2410: goto invalid_right;
2411: }
2412: /* port is locked and active */
2413:
2414: dnrequest = ipc_right_dncancel_macro(space, port,
2415: name, entry);
2416:
2417: assert(port->ip_srights > 0);
2418: ip_unlock(port);
2419:
2420: if (bits & IE_BITS_MAREQUEST)
2421: ipc_marequest_cancel(space, name);
2422:
2423: entry->ie_object = IO_NULL;
2424: ipc_entry_dealloc(space, name, entry);
2425: is_write_unlock(space);
2426:
2427: if (dnrequest != IP_NULL)
2428: ipc_notify_port_deleted(dnrequest, name);
2429:
2430: *objectp = (ipc_object_t) port;
2431: break;
2432: } else {
2433: ipc_port_t port;
2434:
2435: /*
2436: * Pulls a send right out of the space,
2437: * making a send right if necessary.
2438: * Doesn't operate on dead names.
2439: */
2440:
2441: if ((bits & MACH_PORT_TYPE_SEND_RECEIVE) == 0)
2442: goto invalid_right;
2443:
2444: port = (ipc_port_t) entry->ie_object;
2445: assert(port != IP_NULL);
2446:
2447: if (ipc_right_check(space, port, name, entry)) {
2448: if (bits & IE_BITS_COMPAT)
2449: goto invalid_name;
2450:
2451: goto invalid_right;
2452: }
2453: /* port is locked and active */
2454:
2455: is_write_unlock(space);
2456:
2457: if ((bits & MACH_PORT_TYPE_SEND) == 0) {
2458: assert(IE_BITS_TYPE(bits) ==
2459: MACH_PORT_TYPE_RECEIVE);
2460: assert(IE_BITS_UREFS(bits) == 0);
2461:
2462: port->ip_mscount++;
2463: }
2464:
2465: port->ip_srights++;
2466: ip_reference(port);
2467: ip_unlock(port);
2468:
2469: *objectp = (ipc_object_t) port;
2470: break;
2471: }
2472:
2473: case MSG_TYPE_PORT_ALL:
2474: if (dealloc) {
2475: ipc_port_t port;
2476: ipc_port_t dnrequest = IP_NULL;
2477: ipc_port_t nsrequest = IP_NULL;
2478: mach_port_mscount_t mscount = 0; /* '=0' to shut up lint */
2479:
2480: /*
2481: * Like MACH_MSG_TYPE_MOVE_RECEIVE, except that
2482: * the space is always left without rights,
2483: * so we kill send rights if necessary.
2484: */
2485:
2486: if ((bits & MACH_PORT_TYPE_RECEIVE) == 0)
2487: goto invalid_right;
2488:
2489: port = (ipc_port_t) entry->ie_object;
2490: assert(port != IP_NULL);
2491:
2492: ip_lock(port);
2493: assert(ip_active(port));
2494: assert(port->ip_receiver_name == name);
2495: assert(port->ip_receiver == space);
2496:
2497: dnrequest = ipc_right_dncancel_macro(space, port,
2498: name, entry);
2499:
2500: if (bits & IE_BITS_MAREQUEST)
2501: ipc_marequest_cancel(space, name);
2502:
2503: entry->ie_object = IO_NULL;
2504: ipc_entry_dealloc(space, name, entry);
2505: is_write_unlock(space);
2506:
2507: if (bits & MACH_PORT_TYPE_SEND) {
2508: assert(IE_BITS_TYPE(bits) ==
2509: MACH_PORT_TYPE_SEND_RECEIVE);
2510: assert(IE_BITS_UREFS(bits) > 0);
2511: assert(port->ip_srights > 0);
2512:
2513: if (--port->ip_srights == 0) {
2514: nsrequest = port->ip_nsrequest;
2515: if (nsrequest != IP_NULL) {
2516: port->ip_nsrequest = IP_NULL;
2517: mscount = port->ip_mscount;
2518: }
2519: }
2520: }
2521:
2522: ipc_port_clear_receiver(port);
2523:
2524: port->ip_receiver_name = MACH_PORT_NULL;
2525: port->ip_destination = IP_NULL;
2526: ip_unlock(port);
2527:
2528: if (nsrequest != IP_NULL)
2529: ipc_notify_no_senders(nsrequest, mscount);
2530:
2531: if (dnrequest != IP_NULL)
2532: ipc_notify_port_deleted(dnrequest, name);
2533:
2534: *objectp = (ipc_object_t) port;
2535: break;
2536: } else {
2537: ipc_port_t port;
2538:
2539: /*
2540: * Like MACH_MSG_TYPE_MOVE_RECEIVE, except that
2541: * the space is always left with send rights,
2542: * so we make a send right if necessary.
2543: */
2544:
2545: if ((bits & MACH_PORT_TYPE_RECEIVE) == 0)
2546: goto invalid_right;
2547:
2548: port = (ipc_port_t) entry->ie_object;
2549: assert(port != IP_NULL);
2550:
2551: ip_lock(port);
2552: assert(ip_active(port));
2553: assert(port->ip_receiver_name == name);
2554: assert(port->ip_receiver == space);
2555:
2556: if ((bits & MACH_PORT_TYPE_SEND) == 0) {
2557: assert(IE_BITS_TYPE(bits) ==
2558: MACH_PORT_TYPE_RECEIVE);
2559: assert(IE_BITS_UREFS(bits) == 0);
2560:
2561: /* ip_mscount will be cleared below */
2562: port->ip_srights++;
2563: bits |= MACH_PORT_TYPE_SEND | 1;
2564: }
2565:
2566: ipc_hash_insert(space, (ipc_object_t) port,
2567: name, entry);
2568:
2569: entry->ie_bits = bits &~ MACH_PORT_TYPE_RECEIVE;
2570: is_write_unlock(space);
2571:
2572: ipc_port_clear_receiver(port); /* clears ip_mscount */
2573:
2574: port->ip_receiver_name = MACH_PORT_NULL;
2575: port->ip_destination = IP_NULL;
2576: ip_reference(port);
2577: ip_unlock(port);
2578:
2579: *objectp = (ipc_object_t) port;
2580: break;
2581: }
2582:
2583: default:
2584: #if MACH_ASSERT
2585: assert(!"ipc_right_copyin_compat: strange rights");
2586: #else
2587: panic("ipc_right_copyin_compat: strange rights");
2588: #endif
2589: }
2590:
2591: return KERN_SUCCESS;
2592:
2593: invalid_right:
2594: is_write_unlock(space);
2595: return KERN_INVALID_RIGHT;
2596:
2597: invalid_name:
2598: is_write_unlock(space);
2599: return KERN_INVALID_NAME;
2600: }
2601:
2602: /*
2603: * Routine: ipc_right_copyin_header
2604: * Purpose:
2605: * Copyin a capability from a space.
2606: * If successful, the caller gets a ref
2607: * for the resulting object, which is always valid.
2608: * The type of the acquired capability is returned.
2609: * Conditions:
2610: * The space is write-locked, and is unlocked upon return.
2611: * The space must be active.
2612: * Returns:
2613: * KERN_SUCCESS Acquired a valid object.
2614: * KERN_INVALID_RIGHT Name doesn't denote correct right.
2615: * KERN_INVALID_NAME [MACH_IPC_COMPAT]
2616: * Caller should pretend lookup of entry failed.
2617: */
2618:
2619: kern_return_t
2620: ipc_right_copyin_header(space, name, entry, objectp, msgt_namep)
2621: ipc_space_t space;
2622: mach_port_t name;
2623: ipc_entry_t entry;
2624: ipc_object_t *objectp;
2625: mach_msg_type_name_t *msgt_namep;
2626: {
2627: ipc_entry_bits_t bits = entry->ie_bits;
2628: mach_port_type_t type = IE_BITS_TYPE(bits);
2629:
2630: assert(space->is_active);
2631:
2632: switch (type) {
2633: case MACH_PORT_TYPE_PORT_SET:
2634: case MACH_PORT_TYPE_DEAD_NAME:
2635: goto invalid_right;
2636:
2637: case MACH_PORT_TYPE_RECEIVE: {
2638: ipc_port_t port;
2639:
2640: /*
2641: * Like MACH_MSG_TYPE_MAKE_SEND.
2642: */
2643:
2644: port = (ipc_port_t) entry->ie_object;
2645: assert(port != IP_NULL);
2646:
2647: ip_lock(port);
2648: assert(ip_active(port));
2649: assert(port->ip_receiver_name == name);
2650: assert(port->ip_receiver == space);
2651: is_write_unlock(space);
2652:
2653: port->ip_mscount++;
2654: port->ip_srights++;
2655: ip_reference(port);
2656: ip_unlock(port);
2657:
2658: *objectp = (ipc_object_t) port;
2659: *msgt_namep = MACH_MSG_TYPE_PORT_SEND;
2660: break;
2661: }
2662:
2663: case MACH_PORT_TYPE_SEND:
2664: case MACH_PORT_TYPE_SEND_RECEIVE: {
2665: ipc_port_t port;
2666:
2667: /*
2668: * Like MACH_MSG_TYPE_COPY_SEND,
2669: * except that the port must be alive.
2670: */
2671:
2672: assert(IE_BITS_UREFS(bits) > 0);
2673:
2674: port = (ipc_port_t) entry->ie_object;
2675: assert(port != IP_NULL);
2676:
2677: if (ipc_right_check(space, port, name, entry)) {
2678: if (bits & IE_BITS_COMPAT)
2679: goto invalid_name;
2680:
2681: goto invalid_right;
2682: }
2683: /* port is locked and active */
2684:
2685: assert(port->ip_srights > 0);
2686: is_write_unlock(space);
2687:
2688: port->ip_srights++;
2689: ip_reference(port);
2690: ip_unlock(port);
2691:
2692: *objectp = (ipc_object_t) port;
2693: *msgt_namep = MACH_MSG_TYPE_PORT_SEND;
2694: break;
2695: }
2696:
2697: case MACH_PORT_TYPE_SEND_ONCE: {
2698: ipc_port_t port;
2699: ipc_port_t dnrequest, notify;
2700:
2701: /*
2702: * Like MACH_MSG_TYPE_MOVE_SEND_ONCE,
2703: * except that the port must be alive
2704: * and a port-deleted notification is generated.
2705: */
2706:
2707: assert(IE_BITS_UREFS(bits) == 1);
2708: assert((bits & IE_BITS_MAREQUEST) == 0);
2709:
2710: port = (ipc_port_t) entry->ie_object;
2711: assert(port != IP_NULL);
2712:
2713: if (ipc_right_check(space, port, name, entry)) {
2714: if (bits & IE_BITS_COMPAT)
2715: goto invalid_name;
2716:
2717: goto invalid_right;
2718: }
2719: /* port is locked and active */
2720:
2721: assert(port->ip_sorights > 0);
2722:
2723: dnrequest = ipc_right_dncancel_macro(space, port, name, entry);
2724: ip_unlock(port);
2725:
2726: entry->ie_object = IO_NULL;
2727: ipc_entry_dealloc(space, name, entry);
2728:
2729: notify = ipc_space_make_notify(space);
2730: is_write_unlock(space);
2731:
2732: if (dnrequest != IP_NULL)
2733: ipc_notify_port_deleted(dnrequest, name);
2734:
2735: if (IP_VALID(notify))
2736: ipc_notify_port_deleted_compat(notify, name);
2737:
2738: *objectp = (ipc_object_t) port;
2739: *msgt_namep = MACH_MSG_TYPE_PORT_SEND_ONCE;
2740: break;
2741: }
2742:
2743: default:
2744: #if MACH_ASSERT
2745: assert(!"ipc_right_copyin_header: strange rights");
2746: #else
2747: panic("ipc_right_copyin_header: strange rights");
2748: #endif
2749: }
2750:
2751: return KERN_SUCCESS;
2752:
2753: invalid_right:
2754: is_write_unlock(space);
2755: return KERN_INVALID_RIGHT;
2756:
2757: invalid_name:
2758: is_write_unlock(space);
2759: return KERN_INVALID_NAME;
2760: }
2761:
2762: #endif /* MACH_IPC_COMPAT */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.