![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ipc_object.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / ipc|
Return to ipc_object.c CVS log | Up to [GnuMach] / Gnu-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: * File: ipc/ipc_object.c
28: * Author: Rich Draves
29: * Date: 1989
30: *
31: * Functions to manipulate IPC objects.
32: */
33:
34: #include <mach_ipc_compat.h>
35:
36: #include <mach/boolean.h>
37: #include <mach/kern_return.h>
38: #include <mach/port.h>
39: #include <mach/message.h>
40: #include <ipc/port.h>
41: #include <ipc/ipc_space.h>
42: #include <ipc/ipc_entry.h>
43: #include <ipc/ipc_object.h>
44: #include <ipc/ipc_hash.h>
45: #include <ipc/ipc_right.h>
46: #include <ipc/ipc_notify.h>
47: #include <ipc/ipc_pset.h>
48:
49: zone_t ipc_object_zones[IOT_NUMBER];
50:
51:
52:
53: /*
54: * Routine: ipc_object_reference
55: * Purpose:
56: * Take a reference to an object.
57: */
58:
59: void
60: ipc_object_reference(
61: ipc_object_t object)
62: {
63: io_lock(object);
64: assert(object->io_references > 0);
65: io_reference(object);
66: io_unlock(object);
67: }
68:
69: /*
70: * Routine: ipc_object_release
71: * Purpose:
72: * Release a reference to an object.
73: */
74:
75: void
76: ipc_object_release(
77: ipc_object_t object)
78: {
79: io_lock(object);
80: assert(object->io_references > 0);
81: io_release(object);
82: io_check_unlock(object);
83: }
84:
85: /*
86: * Routine: ipc_object_translate
87: * Purpose:
88: * Look up an object in a space.
89: * Conditions:
90: * Nothing locked before. If successful, the object
91: * is returned locked. The caller doesn't get a ref.
92: * Returns:
93: * KERN_SUCCESS Objected returned locked.
94: * KERN_INVALID_TASK The space is dead.
95: * KERN_INVALID_NAME The name doesn't denote a right.
96: * KERN_INVALID_RIGHT Name doesn't denote the correct right.
97: */
98:
99: kern_return_t
100: ipc_object_translate(
101: ipc_space_t space,
102: mach_port_t name,
103: mach_port_right_t right,
104: ipc_object_t *objectp)
105: {
106: ipc_entry_t entry;
107: ipc_object_t object;
108: kern_return_t kr;
109:
110: kr = ipc_right_lookup_read(space, name, &entry);
111: if (kr != KERN_SUCCESS)
112: return kr;
113: /* space is read-locked and active */
114:
115: if ((entry->ie_bits & MACH_PORT_TYPE(right)) == (mach_port_right_t) 0) {
116: is_read_unlock(space);
117: return KERN_INVALID_RIGHT;
118: }
119:
120: object = entry->ie_object;
121: assert(object != IO_NULL);
122:
123: io_lock(object);
124: is_read_unlock(space);
125:
126: *objectp = object;
127: return KERN_SUCCESS;
128: }
129:
130: /*
131: * Routine: ipc_object_alloc_dead
132: * Purpose:
133: * Allocate a dead-name entry.
134: * Conditions:
135: * Nothing locked.
136: * Returns:
137: * KERN_SUCCESS The dead name is allocated.
138: * KERN_INVALID_TASK The space is dead.
139: * KERN_NO_SPACE No room for an entry in the space.
140: * KERN_RESOURCE_SHORTAGE Couldn't allocate memory.
141: */
142:
143: kern_return_t
144: ipc_object_alloc_dead(
145: ipc_space_t space,
146: mach_port_t *namep)
147: {
148: ipc_entry_t entry;
149: kern_return_t kr;
150:
151:
152: kr = ipc_entry_alloc(space, namep, &entry);
153: if (kr != KERN_SUCCESS)
154: return kr;
155: /* space is write-locked */
156:
157: /* null object, MACH_PORT_TYPE_DEAD_NAME, 1 uref */
158:
159: assert(entry->ie_object == IO_NULL);
160: entry->ie_bits |= MACH_PORT_TYPE_DEAD_NAME | 1;
161:
162: is_write_unlock(space);
163: return KERN_SUCCESS;
164: }
165:
166: /*
167: * Routine: ipc_object_alloc_dead_name
168: * Purpose:
169: * Allocate a dead-name entry, with a specific name.
170: * Conditions:
171: * Nothing locked.
172: * Returns:
173: * KERN_SUCCESS The dead name is allocated.
174: * KERN_INVALID_TASK The space is dead.
175: * KERN_NAME_EXISTS The name already denotes a right.
176: * KERN_RESOURCE_SHORTAGE Couldn't allocate memory.
177: */
178:
179: kern_return_t
180: ipc_object_alloc_dead_name(
181: ipc_space_t space,
182: mach_port_t name)
183: {
184: ipc_entry_t entry;
185: kern_return_t kr;
186:
187:
188: kr = ipc_entry_alloc_name(space, name, &entry);
189: if (kr != KERN_SUCCESS)
190: return kr;
191: /* space is write-locked */
192:
193: if (ipc_right_inuse(space, name, entry))
194: return KERN_NAME_EXISTS;
195:
196: /* null object, MACH_PORT_TYPE_DEAD_NAME, 1 uref */
197:
198: assert(entry->ie_object == IO_NULL);
199: entry->ie_bits |= MACH_PORT_TYPE_DEAD_NAME | 1;
200:
201: is_write_unlock(space);
202: return KERN_SUCCESS;
203: }
204:
205: /*
206: * Routine: ipc_object_alloc
207: * Purpose:
208: * Allocate an object.
209: * Conditions:
210: * Nothing locked. If successful, the object is returned locked.
211: * The caller doesn't get a reference for the object.
212: * Returns:
213: * KERN_SUCCESS The object is allocated.
214: * KERN_INVALID_TASK The space is dead.
215: * KERN_NO_SPACE No room for an entry in the space.
216: * KERN_RESOURCE_SHORTAGE Couldn't allocate memory.
217: */
218:
219: kern_return_t
220: ipc_object_alloc(
221: ipc_space_t space,
222: ipc_object_type_t otype,
223: mach_port_type_t type,
224: mach_port_urefs_t urefs,
225: mach_port_t *namep,
226: ipc_object_t *objectp)
227: {
228: ipc_object_t object;
229: ipc_entry_t entry;
230: kern_return_t kr;
231:
232: assert(otype < IOT_NUMBER);
233: assert((type & MACH_PORT_TYPE_ALL_RIGHTS) == type);
234: assert(type != MACH_PORT_TYPE_NONE);
235: assert(urefs <= MACH_PORT_UREFS_MAX);
236:
237: object = io_alloc(otype);
238: if (object == IO_NULL)
239: return KERN_RESOURCE_SHORTAGE;
240:
241: if (otype == IOT_PORT) {
242: ipc_port_t port = (ipc_port_t)object;
243:
244: bzero((char *)port, sizeof(*port));
245: } else if (otype == IOT_PORT_SET) {
246: ipc_pset_t pset = (ipc_pset_t)object;
247:
248: bzero((char *)pset, sizeof(*pset));
249: }
250: *namep = (mach_port_t)object;
251: kr = ipc_entry_alloc(space, namep, &entry);
252: if (kr != KERN_SUCCESS) {
253: io_free(otype, object);
254: return kr;
255: }
256: /* space is write-locked */
257:
258: entry->ie_bits |= type | urefs;
259: entry->ie_object = object;
260:
261: io_lock_init(object);
262: io_lock(object);
263: is_write_unlock(space);
264:
265: object->io_references = 1; /* for entry, not caller */
266: object->io_bits = io_makebits(TRUE, otype, 0);
267:
268: *objectp = object;
269: return KERN_SUCCESS;
270: }
271:
272: /*
273: * Routine: ipc_object_alloc_name
274: * Purpose:
275: * Allocate an object, with a specific name.
276: * Conditions:
277: * Nothing locked. If successful, the object is returned locked.
278: * The caller doesn't get a reference for the object.
279: * Returns:
280: * KERN_SUCCESS The object is allocated.
281: * KERN_INVALID_TASK The space is dead.
282: * KERN_NAME_EXISTS The name already denotes a right.
283: * KERN_RESOURCE_SHORTAGE Couldn't allocate memory.
284: */
285:
286: kern_return_t
287: ipc_object_alloc_name(
288: ipc_space_t space,
289: ipc_object_type_t otype,
290: mach_port_type_t type,
291: mach_port_urefs_t urefs,
292: mach_port_t name,
293: ipc_object_t *objectp)
294: {
295: ipc_object_t object;
296: ipc_entry_t entry;
297: kern_return_t kr;
298:
299: assert(otype < IOT_NUMBER);
300: assert((type & MACH_PORT_TYPE_ALL_RIGHTS) == type);
301: assert(type != MACH_PORT_TYPE_NONE);
302: assert(urefs <= MACH_PORT_UREFS_MAX);
303:
304: object = io_alloc(otype);
305: if (object == IO_NULL)
306: return KERN_RESOURCE_SHORTAGE;
307:
308: if (otype == IOT_PORT) {
309: ipc_port_t port = (ipc_port_t)object;
310:
311: bzero((char *)port, sizeof(*port));
312: } else if (otype == IOT_PORT_SET) {
313: ipc_pset_t pset = (ipc_pset_t)object;
314:
315: bzero((char *)pset, sizeof(*pset));
316: }
317:
318: kr = ipc_entry_alloc_name(space, name, &entry);
319: if (kr != KERN_SUCCESS) {
320: io_free(otype, object);
321: return kr;
322: }
323: /* space is write-locked */
324:
325: if (ipc_right_inuse(space, name, entry)) {
326: io_free(otype, object);
327: return KERN_NAME_EXISTS;
328: }
329:
330: entry->ie_bits |= type | urefs;
331: entry->ie_object = object;
332:
333: io_lock_init(object);
334: io_lock(object);
335: is_write_unlock(space);
336:
337: object->io_references = 1; /* for entry, not caller */
338: object->io_bits = io_makebits(TRUE, otype, 0);
339:
340: *objectp = object;
341: return KERN_SUCCESS;
342: }
343:
344: /*
345: * Routine: ipc_object_copyin_type
346: * Purpose:
347: * Convert a send type name to a received type name.
348: */
349:
350: mach_msg_type_name_t
351: ipc_object_copyin_type(
352: mach_msg_type_name_t msgt_name)
353: {
354: switch (msgt_name) {
355: case 0:
356: return 0;
357:
358: case MACH_MSG_TYPE_MOVE_RECEIVE:
359: return MACH_MSG_TYPE_PORT_RECEIVE;
360:
361: case MACH_MSG_TYPE_MOVE_SEND_ONCE:
362: case MACH_MSG_TYPE_MAKE_SEND_ONCE:
363: return MACH_MSG_TYPE_PORT_SEND_ONCE;
364:
365: case MACH_MSG_TYPE_MOVE_SEND:
366: case MACH_MSG_TYPE_MAKE_SEND:
367: case MACH_MSG_TYPE_COPY_SEND:
368: return MACH_MSG_TYPE_PORT_SEND;
369:
370: #if MACH_IPC_COMPAT
371: case MSG_TYPE_PORT:
372: return MACH_MSG_TYPE_PORT_SEND;
373:
374: case MSG_TYPE_PORT_ALL:
375: return MACH_MSG_TYPE_PORT_RECEIVE;
376: #endif MACH_IPC_COMPAT
377:
378: default:
379: #if MACH_ASSERT
380: assert(!"ipc_object_copyin_type: strange rights");
381: #else
382: panic("ipc_object_copyin_type: strange rights");
383: #endif
384: return 0; /* in case assert/panic returns */
385: }
386: }
387:
388: /*
389: * Routine: ipc_object_copyin
390: * Purpose:
391: * Copyin a capability from a space.
392: * If successful, the caller gets a ref
393: * for the resulting object, unless it is IO_DEAD.
394: * Conditions:
395: * Nothing locked.
396: * Returns:
397: * KERN_SUCCESS Acquired an object, possibly IO_DEAD.
398: * KERN_INVALID_TASK The space is dead.
399: * KERN_INVALID_NAME Name doesn't exist in space.
400: * KERN_INVALID_RIGHT Name doesn't denote correct right.
401: */
402:
403: kern_return_t
404: ipc_object_copyin(
405: ipc_space_t space,
406: mach_port_t name,
407: mach_msg_type_name_t msgt_name,
408: ipc_object_t *objectp)
409: {
410: ipc_entry_t entry;
411: ipc_port_t soright;
412: kern_return_t kr;
413:
414: /*
415: * Could first try a read lock when doing
416: * MACH_MSG_TYPE_COPY_SEND, MACH_MSG_TYPE_MAKE_SEND,
417: * and MACH_MSG_TYPE_MAKE_SEND_ONCE.
418: */
419:
420: kr = ipc_right_lookup_write(space, name, &entry);
421: if (kr != KERN_SUCCESS)
422: return kr;
423: /* space is write-locked and active */
424:
425: kr = ipc_right_copyin(space, name, entry,
426: msgt_name, TRUE,
427: objectp, &soright);
428: if (IE_BITS_TYPE(entry->ie_bits) == MACH_PORT_TYPE_NONE)
429: ipc_entry_dealloc(space, name, entry);
430: is_write_unlock(space);
431:
432: if ((kr == KERN_SUCCESS) && (soright != IP_NULL))
433: ipc_notify_port_deleted(soright, name);
434:
435: return kr;
436: }
437:
438: /*
439: * Routine: ipc_object_copyin_from_kernel
440: * Purpose:
441: * Copyin a naked capability from the kernel.
442: *
443: * MACH_MSG_TYPE_MOVE_RECEIVE
444: * The receiver must be ipc_space_kernel.
445: * Consumes the naked receive right.
446: * MACH_MSG_TYPE_COPY_SEND
447: * A naked send right must be supplied.
448: * The port gains a reference, and a send right
449: * if the port is still active.
450: * MACH_MSG_TYPE_MAKE_SEND
451: * The receiver must be ipc_space_kernel.
452: * The port gains a reference and a send right.
453: * MACH_MSG_TYPE_MOVE_SEND
454: * Consumes a naked send right.
455: * MACH_MSG_TYPE_MAKE_SEND_ONCE
456: * The receiver must be ipc_space_kernel.
457: * The port gains a reference and a send-once right.
458: * MACH_MSG_TYPE_MOVE_SEND_ONCE
459: * Consumes a naked send-once right.
460: * Conditions:
461: * Nothing locked.
462: */
463:
464: void
465: ipc_object_copyin_from_kernel(
466: ipc_object_t object,
467: mach_msg_type_name_t msgt_name)
468: {
469: assert(IO_VALID(object));
470:
471: switch (msgt_name) {
472: case MACH_MSG_TYPE_MOVE_RECEIVE: {
473: ipc_port_t port = (ipc_port_t) object;
474:
475: ip_lock(port);
476: assert(ip_active(port));
477: assert(port->ip_receiver_name != MACH_PORT_NULL);
478: assert(port->ip_receiver == ipc_space_kernel);
479:
480: /* relevant part of ipc_port_clear_receiver */
481: ipc_port_set_mscount(port, 0);
482:
483: port->ip_receiver_name = MACH_PORT_NULL;
484: port->ip_destination = IP_NULL;
485: ip_unlock(port);
486: break;
487: }
488:
489: case MACH_MSG_TYPE_COPY_SEND: {
490: ipc_port_t port = (ipc_port_t) object;
491:
492: ip_lock(port);
493: if (ip_active(port)) {
494: assert(port->ip_srights > 0);
495: port->ip_srights++;
496: }
497: ip_reference(port);
498: ip_unlock(port);
499: break;
500: }
501:
502: case MACH_MSG_TYPE_MAKE_SEND: {
503: ipc_port_t port = (ipc_port_t) object;
504:
505: ip_lock(port);
506: assert(ip_active(port));
507: assert(port->ip_receiver_name != MACH_PORT_NULL);
508: assert(port->ip_receiver == ipc_space_kernel);
509:
510: ip_reference(port);
511: port->ip_mscount++;
512: port->ip_srights++;
513: ip_unlock(port);
514: break;
515: }
516:
517: case MACH_MSG_TYPE_MOVE_SEND:
518: /* move naked send right into the message */
519: break;
520:
521: case MACH_MSG_TYPE_MAKE_SEND_ONCE: {
522: ipc_port_t port = (ipc_port_t) object;
523:
524: ip_lock(port);
525: assert(ip_active(port));
526: assert(port->ip_receiver_name != MACH_PORT_NULL);
527: assert(port->ip_receiver == ipc_space_kernel);
528:
529: ip_reference(port);
530: port->ip_sorights++;
531: ip_unlock(port);
532: break;
533: }
534:
535: case MACH_MSG_TYPE_MOVE_SEND_ONCE:
536: /* move naked send-once right into the message */
537: break;
538:
539: default:
540: #if MACH_ASSERT
541: assert(!"ipc_object_copyin_from_kernel: strange rights");
542: #else
543: panic("ipc_object_copyin_from_kernel: strange rights");
544: #endif
545: }
546: }
547:
548: /*
549: * Routine: ipc_object_destroy
550: * Purpose:
551: * Destroys a naked capability.
552: * Consumes a ref for the object.
553: *
554: * A receive right should be in limbo or in transit.
555: * Conditions:
556: * Nothing locked.
557: */
558:
559: void
560: ipc_object_destroy(
561: ipc_object_t object,
562: mach_msg_type_name_t msgt_name)
563: {
564: assert(IO_VALID(object));
565: assert(io_otype(object) == IOT_PORT);
566:
567: switch (msgt_name) {
568: case MACH_MSG_TYPE_PORT_SEND:
569: ipc_port_release_send((ipc_port_t) object);
570: break;
571:
572: case MACH_MSG_TYPE_PORT_SEND_ONCE:
573: ipc_notify_send_once((ipc_port_t) object);
574: break;
575:
576: case MACH_MSG_TYPE_PORT_RECEIVE:
577: ipc_port_release_receive((ipc_port_t) object);
578: break;
579:
580: default:
581: panic("ipc_object_destroy: strange rights");
582: }
583: }
584:
585: /*
586: * Routine: ipc_object_copyout
587: * Purpose:
588: * Copyout a capability, placing it into a space.
589: * If successful, consumes a ref for the object.
590: * Conditions:
591: * Nothing locked.
592: * Returns:
593: * KERN_SUCCESS Copied out object, consumed ref.
594: * KERN_INVALID_TASK The space is dead.
595: * KERN_INVALID_CAPABILITY The object is dead.
596: * KERN_NO_SPACE No room in space for another right.
597: * KERN_RESOURCE_SHORTAGE No memory available.
598: * KERN_UREFS_OVERFLOW Urefs limit exceeded
599: * and overflow wasn't specified.
600: */
601:
602: kern_return_t
603: ipc_object_copyout(
604: ipc_space_t space,
605: ipc_object_t object,
606: mach_msg_type_name_t msgt_name,
607: boolean_t overflow,
608: mach_port_t *namep)
609: {
610: mach_port_t name;
611: ipc_entry_t entry;
612: kern_return_t kr;
613:
614: assert(IO_VALID(object));
615: assert(io_otype(object) == IOT_PORT);
616:
617: is_write_lock(space);
618:
619: for (;;) {
620: if (!space->is_active) {
621: is_write_unlock(space);
622: return KERN_INVALID_TASK;
623: }
624:
625: if ((msgt_name != MACH_MSG_TYPE_PORT_SEND_ONCE) &&
626: ipc_right_reverse(space, object, &name, &entry)) {
627: /* object is locked and active */
628:
629: assert(entry->ie_bits & MACH_PORT_TYPE_SEND_RECEIVE);
630: break;
631: }
632:
633: kr = ipc_entry_get(space, &name, &entry);
634: if (kr != KERN_SUCCESS) {
635: /* unlocks/locks space, so must start again */
636:
637: kr = ipc_entry_grow_table(space);
638: if (kr != KERN_SUCCESS)
639: return kr; /* space is unlocked */
640:
641: continue;
642: }
643:
644: assert(IE_BITS_TYPE(entry->ie_bits) == MACH_PORT_TYPE_NONE);
645: assert(entry->ie_object == IO_NULL);
646:
647: io_lock(object);
648: if (!io_active(object)) {
649: io_unlock(object);
650: ipc_entry_dealloc(space, name, entry);
651: is_write_unlock(space);
652: return KERN_INVALID_CAPABILITY;
653: }
654:
655: entry->ie_object = object;
656: break;
657: }
658:
659: /* space is write-locked and active, object is locked and active */
660:
661: kr = ipc_right_copyout(space, name, entry,
662: msgt_name, overflow, object);
663: /* object is unlocked */
664: is_write_unlock(space);
665:
666: if (kr == KERN_SUCCESS)
667: *namep = name;
668: return kr;
669: }
670:
671: #if 0
672: /* XXX same, but don't check for already-existing send rights */
673: kern_return_t
674: ipc_object_copyout_multiname(space, object, namep)
675: ipc_space_t space;
676: ipc_object_t object;
677: mach_port_t *namep;
678: {
679: mach_port_t name;
680: ipc_entry_t entry;
681: kern_return_t kr;
682:
683: assert(IO_VALID(object));
684: assert(io_otype(object) == IOT_PORT);
685:
686: is_write_lock(space);
687:
688: for (;;) {
689: if (!space->is_active) {
690: is_write_unlock(space);
691: return KERN_INVALID_TASK;
692: }
693:
694: kr = ipc_entry_get(space, &name, &entry);
695: if (kr != KERN_SUCCESS) {
696: /* unlocks/locks space, so must start again */
697:
698: kr = ipc_entry_grow_table(space);
699: if (kr != KERN_SUCCESS)
700: return kr; /* space is unlocked */
701:
702: continue;
703: }
704:
705: assert(IE_BITS_TYPE(entry->ie_bits) == MACH_PORT_TYPE_NONE);
706: assert(entry->ie_object == IO_NULL);
707:
708: io_lock(object);
709: if (!io_active(object)) {
710: io_unlock(object);
711: ipc_entry_dealloc(space, name, entry);
712: is_write_unlock(space);
713: return KERN_INVALID_CAPABILITY;
714: }
715:
716: entry->ie_object = object;
717: break;
718: }
719:
720: /* space is write-locked and active, object is locked and active */
721:
722: kr = ipc_right_copyout_multiname(space, name, entry, object);
723: /* object is unlocked */
724: is_write_unlock(space);
725:
726: if (kr == KERN_SUCCESS)
727: *namep = name;
728: return kr;
729: }
730: #endif 0
731:
732: /*
733: * Routine: ipc_object_copyout_name
734: * Purpose:
735: * Copyout a capability, placing it into a space.
736: * The specified name is used for the capability.
737: * If successful, consumes a ref for the object.
738: * Conditions:
739: * Nothing locked.
740: * Returns:
741: * KERN_SUCCESS Copied out object, consumed ref.
742: * KERN_INVALID_TASK The space is dead.
743: * KERN_INVALID_CAPABILITY The object is dead.
744: * KERN_RESOURCE_SHORTAGE No memory available.
745: * KERN_UREFS_OVERFLOW Urefs limit exceeded
746: * and overflow wasn't specified.
747: * KERN_RIGHT_EXISTS Space has rights under another name.
748: * KERN_NAME_EXISTS Name is already used.
749: */
750:
751: kern_return_t
752: ipc_object_copyout_name(
753: ipc_space_t space,
754: ipc_object_t object,
755: mach_msg_type_name_t msgt_name,
756: boolean_t overflow,
757: mach_port_t name)
758: {
759: mach_port_t oname;
760: ipc_entry_t oentry;
761: ipc_entry_t entry;
762: kern_return_t kr;
763:
764: assert(IO_VALID(object));
765: assert(io_otype(object) == IOT_PORT);
766:
767: kr = ipc_entry_alloc_name(space, name, &entry);
768: if (kr != KERN_SUCCESS)
769: return kr;
770: /* space is write-locked and active */
771:
772: if ((msgt_name != MACH_MSG_TYPE_PORT_SEND_ONCE) &&
773: ipc_right_reverse(space, object, &oname, &oentry)) {
774: /* object is locked and active */
775:
776: if (name != oname) {
777: io_unlock(object);
778:
779: if (IE_BITS_TYPE(entry->ie_bits)
780: == MACH_PORT_TYPE_NONE)
781: ipc_entry_dealloc(space, name, entry);
782:
783: is_write_unlock(space);
784: return KERN_RIGHT_EXISTS;
785: }
786:
787: assert(entry == oentry);
788: assert(entry->ie_bits & MACH_PORT_TYPE_SEND_RECEIVE);
789: } else {
790: if (ipc_right_inuse(space, name, entry))
791: return KERN_NAME_EXISTS;
792:
793: assert(IE_BITS_TYPE(entry->ie_bits) == MACH_PORT_TYPE_NONE);
794: assert(entry->ie_object == IO_NULL);
795:
796: io_lock(object);
797: if (!io_active(object)) {
798: io_unlock(object);
799: ipc_entry_dealloc(space, name, entry);
800: is_write_unlock(space);
801: return KERN_INVALID_CAPABILITY;
802: }
803:
804: entry->ie_object = object;
805: }
806:
807: /* space is write-locked and active, object is locked and active */
808:
809: kr = ipc_right_copyout(space, name, entry,
810: msgt_name, overflow, object);
811: /* object is unlocked */
812: is_write_unlock(space);
813: return kr;
814: }
815:
816: /*
817: * Routine: ipc_object_copyout_dest
818: * Purpose:
819: * Translates/consumes the destination right of a message.
820: * This is unlike normal copyout because the right is consumed
821: * in a funny way instead of being given to the receiving space.
822: * The receiver gets his name for the port, if he has receive
823: * rights, otherwise MACH_PORT_NULL.
824: * Conditions:
825: * The object is locked and active. Nothing else locked.
826: * The object is unlocked and loses a reference.
827: */
828:
829: void
830: ipc_object_copyout_dest(
831: ipc_space_t space,
832: ipc_object_t object,
833: mach_msg_type_name_t msgt_name,
834: mach_port_t *namep)
835: {
836: mach_port_t name;
837:
838: assert(IO_VALID(object));
839: assert(io_active(object));
840:
841: io_release(object);
842:
843: /*
844: * If the space is the receiver/owner of the object,
845: * then we quietly consume the right and return
846: * the space's name for the object. Otherwise
847: * we destroy the right and return MACH_PORT_NULL.
848: */
849:
850: switch (msgt_name) {
851: case MACH_MSG_TYPE_PORT_SEND: {
852: ipc_port_t port = (ipc_port_t) object;
853: ipc_port_t nsrequest = IP_NULL;
854: mach_port_mscount_t mscount = 0; /* '=0' to shut up lint */
855:
856: assert(port->ip_srights > 0);
857: if (--port->ip_srights == 0) {
858: nsrequest = port->ip_nsrequest;
859: if (nsrequest != IP_NULL) {
860: port->ip_nsrequest = IP_NULL;
861: mscount = port->ip_mscount;
862: }
863: }
864:
865: if (port->ip_receiver == space)
866: name = port->ip_receiver_name;
867: else
868: name = MACH_PORT_NULL;
869:
870: ip_unlock(port);
871:
872: if (nsrequest != IP_NULL)
873: ipc_notify_no_senders(nsrequest, mscount);
874:
875: break;
876: }
877:
878: case MACH_MSG_TYPE_PORT_SEND_ONCE: {
879: ipc_port_t port = (ipc_port_t) object;
880:
881: assert(port->ip_sorights > 0);
882:
883: if (port->ip_receiver == space) {
884: /* quietly consume the send-once right */
885:
886: port->ip_sorights--;
887: name = port->ip_receiver_name;
888: ip_unlock(port);
889: } else {
890: /*
891: * A very bizarre case. The message
892: * was received, but before this copyout
893: * happened the space lost receive rights.
894: * We can't quietly consume the soright
895: * out from underneath some other task,
896: * so generate a send-once notification.
897: */
898:
899: ip_reference(port); /* restore ref */
900: ip_unlock(port);
901:
902: ipc_notify_send_once(port);
903: name = MACH_PORT_NULL;
904: }
905:
906: break;
907: }
908:
909: default:
910: #if MACH_ASSERT
911: assert(!"ipc_object_copyout_dest: strange rights");
912: #else
913: panic("ipc_object_copyout_dest: strange rights");
914: #endif
915:
916: }
917:
918: *namep = name;
919: }
920:
921: /*
922: * Routine: ipc_object_rename
923: * Purpose:
924: * Rename an entry in a space.
925: * Conditions:
926: * Nothing locked.
927: * Returns:
928: * KERN_SUCCESS Renamed the entry.
929: * KERN_INVALID_TASK The space was dead.
930: * KERN_INVALID_NAME oname didn't denote an entry.
931: * KERN_NAME_EXISTS nname already denoted an entry.
932: * KERN_RESOURCE_SHORTAGE Couldn't allocate new entry.
933: */
934:
935: kern_return_t
936: ipc_object_rename(
937: ipc_space_t space,
938: mach_port_t oname,
939: mach_port_t nname)
940: {
941: ipc_entry_t oentry, nentry;
942: kern_return_t kr;
943:
944: kr = ipc_entry_alloc_name(space, nname, &nentry);
945: if (kr != KERN_SUCCESS)
946: return kr;
947: /* space is write-locked and active */
948:
949: if (ipc_right_inuse(space, nname, nentry)) {
950: /* space is unlocked */
951: return KERN_NAME_EXISTS;
952: }
953:
954: /* don't let ipc_entry_lookup see the uninitialized new entry */
955:
956: if ((oname == nname) ||
957: ((oentry = ipc_entry_lookup(space, oname)) == IE_NULL)) {
958: ipc_entry_dealloc(space, nname, nentry);
959: is_write_unlock(space);
960: return KERN_INVALID_NAME;
961: }
962:
963: kr = ipc_right_rename(space, oname, oentry, nname, nentry);
964: /* space is unlocked */
965: return kr;
966: }
967:
968: #if MACH_IPC_COMPAT
969:
970: /*
971: * Routine: ipc_object_copyout_type_compat
972: * Purpose:
973: * Convert a carried type name to an old type name.
974: */
975:
976: mach_msg_type_name_t
977: ipc_object_copyout_type_compat(msgt_name)
978: mach_msg_type_name_t msgt_name;
979: {
980: switch (msgt_name) {
981: case MACH_MSG_TYPE_PORT_SEND:
982: case MACH_MSG_TYPE_PORT_SEND_ONCE:
983: return MSG_TYPE_PORT;
984:
985: case MACH_MSG_TYPE_PORT_RECEIVE:
986: return MSG_TYPE_PORT_ALL;
987:
988: default:
989: #if MACH_ASSERT
990: assert(!"ipc_object_copyout_type_compat: strange rights");
991: #else
992: panic("ipc_object_copyout_type_compat: strange rights");
993: #endif
994: }
995: }
996:
997: /*
998: * Routine: ipc_object_copyin_compat
999: * Purpose:
1000: * Copyin a capability from a space.
1001: * If successful, the caller gets a ref
1002: * for the resulting object, which is always valid.
1003: * Conditions:
1004: * Nothing locked.
1005: * Returns:
1006: * KERN_SUCCESS Acquired a valid object.
1007: * KERN_INVALID_TASK The space is dead.
1008: * KERN_INVALID_NAME Name doesn't exist in space.
1009: * KERN_INVALID_RIGHT Name doesn't denote correct right.
1010: */
1011:
1012: kern_return_t
1013: ipc_object_copyin_compat(space, name, msgt_name, dealloc, objectp)
1014: ipc_space_t space;
1015: mach_port_t name;
1016: mach_msg_type_name_t msgt_name;
1017: boolean_t dealloc;
1018: ipc_object_t *objectp;
1019: {
1020: ipc_entry_t entry;
1021: kern_return_t kr;
1022:
1023: kr = ipc_right_lookup_write(space, name, &entry);
1024: if (kr != KERN_SUCCESS)
1025: return kr;
1026: /* space is write-locked and active */
1027:
1028: kr = ipc_right_copyin_compat(space, name, entry,
1029: msgt_name, dealloc, objectp);
1030: /* space is unlocked */
1031: return kr;
1032: }
1033:
1034: /*
1035: * Routine: ipc_object_copyin_header
1036: * Purpose:
1037: * Copyin a capability from a space.
1038: * If successful, the caller gets a ref
1039: * for the resulting object, which is always valid.
1040: * The type of the acquired capability is returned.
1041: * Conditions:
1042: * Nothing locked.
1043: * Returns:
1044: * KERN_SUCCESS Acquired a valid object.
1045: * KERN_INVALID_TASK The space is dead.
1046: * KERN_INVALID_NAME Name doesn't exist in space.
1047: * KERN_INVALID_RIGHT Name doesn't denote correct right.
1048: */
1049:
1050: kern_return_t
1051: ipc_object_copyin_header(space, name, objectp, msgt_namep)
1052: ipc_space_t space;
1053: mach_port_t name;
1054: ipc_object_t *objectp;
1055: mach_msg_type_name_t *msgt_namep;
1056: {
1057: ipc_entry_t entry;
1058: kern_return_t kr;
1059:
1060: kr = ipc_right_lookup_write(space, name, &entry);
1061: if (kr != KERN_SUCCESS)
1062: return kr;
1063: /* space is write-locked and active */
1064:
1065: kr = ipc_right_copyin_header(space, name, entry,
1066: objectp, msgt_namep);
1067: /* space is unlocked */
1068: return kr;
1069: }
1070:
1071: /*
1072: * Routine: ipc_object_copyout_compat
1073: * Purpose:
1074: * Copyout a capability, placing it into a space.
1075: * If successful, consumes a ref for the object.
1076: *
1077: * Marks new entries with IE_BITS_COMPAT.
1078: * Conditions:
1079: * Nothing locked.
1080: * Returns:
1081: * KERN_SUCCESS Copied out object, consumed ref.
1082: * KERN_INVALID_TASK The space is dead.
1083: * KERN_INVALID_CAPABILITY The object is dead.
1084: * KERN_NO_SPACE No room in space for another right.
1085: * KERN_RESOURCE_SHORTAGE No memory available.
1086: */
1087:
1088: kern_return_t
1089: ipc_object_copyout_compat(space, object, msgt_name, namep)
1090: ipc_space_t space;
1091: ipc_object_t object;
1092: mach_msg_type_name_t msgt_name;
1093: mach_port_t *namep;
1094: {
1095: mach_port_t name;
1096: ipc_entry_t entry;
1097: ipc_port_t port;
1098: kern_return_t kr;
1099:
1100: assert(IO_VALID(object));
1101: assert(io_otype(object) == IOT_PORT);
1102: port = (ipc_port_t) object;
1103:
1104: is_write_lock(space);
1105:
1106: for (;;) {
1107: ipc_port_request_index_t request;
1108:
1109: if (!space->is_active) {
1110: is_write_unlock(space);
1111: return KERN_INVALID_TASK;
1112: }
1113:
1114: if ((msgt_name != MACH_MSG_TYPE_PORT_SEND_ONCE) &&
1115: ipc_right_reverse(space, (ipc_object_t) port,
1116: &name, &entry)) {
1117: /* port is locked and active */
1118:
1119: assert(entry->ie_bits & MACH_PORT_TYPE_SEND_RECEIVE);
1120: break;
1121: }
1122:
1123: kr = ipc_entry_get(space, &name, &entry);
1124: if (kr != KERN_SUCCESS) {
1125: /* unlocks/locks space, so must start again */
1126:
1127: kr = ipc_entry_grow_table(space);
1128: if (kr != KERN_SUCCESS)
1129: return kr; /* space is unlocked */
1130:
1131: continue;
1132: }
1133:
1134: assert(IE_BITS_TYPE(entry->ie_bits) == MACH_PORT_TYPE_NONE);
1135: assert(entry->ie_object == IO_NULL);
1136:
1137: ip_lock(port);
1138: if (!ip_active(port)) {
1139: ip_unlock(port);
1140: ipc_entry_dealloc(space, name, entry);
1141: is_write_unlock(space);
1142: return KERN_INVALID_CAPABILITY;
1143: }
1144:
1145: kr = ipc_port_dnrequest(port, name, ipr_spacem(space),
1146: &request);
1147: if (kr != KERN_SUCCESS) {
1148: ipc_entry_dealloc(space, name, entry);
1149: is_write_unlock(space);
1150:
1151: kr = ipc_port_dngrow(port);
1152: /* port is unlocked */
1153: if (kr != KERN_SUCCESS)
1154: return kr;
1155:
1156: is_write_lock(space);
1157: continue;
1158: }
1159:
1160: is_reference(space); /* for dnrequest */
1161: entry->ie_object = (ipc_object_t) port;
1162: entry->ie_request = request;
1163: entry->ie_bits |= IE_BITS_COMPAT;
1164: break;
1165: }
1166:
1167: /* space is write-locked and active, port is locked and active */
1168:
1169: kr = ipc_right_copyout(space, name, entry,
1170: msgt_name, TRUE, (ipc_object_t) port);
1171: /* object is unlocked */
1172: is_write_unlock(space);
1173:
1174: if (kr == KERN_SUCCESS)
1175: *namep = name;
1176: return kr;
1177: }
1178:
1179: /*
1180: * Routine: ipc_object_copyout_name_compat
1181: * Purpose:
1182: * Copyout a capability, placing it into a space.
1183: * The specified name is used for the capability.
1184: * If successful, consumes a ref for the object.
1185: *
1186: * Like ipc_object_copyout_name, except that
1187: * the name can't be in use at all, even for the same
1188: * port, and IE_BITS_COMPAT gets turned on.
1189: * Conditions:
1190: * Nothing locked.
1191: * Returns:
1192: * KERN_SUCCESS Copied out object, consumed ref.
1193: * KERN_INVALID_TASK The space is dead.
1194: * KERN_INVALID_CAPABILITY The object is dead.
1195: * KERN_RESOURCE_SHORTAGE No memory available.
1196: * KERN_RIGHT_EXISTS Space has rights under another name.
1197: * KERN_NAME_EXISTS Name is already used.
1198: */
1199:
1200: kern_return_t
1201: ipc_object_copyout_name_compat(space, object, msgt_name, name)
1202: ipc_space_t space;
1203: ipc_object_t object;
1204: mach_msg_type_name_t msgt_name;
1205: mach_port_t name;
1206: {
1207: ipc_entry_t entry;
1208: ipc_port_t port;
1209: kern_return_t kr;
1210:
1211: assert(IO_VALID(object));
1212: assert(io_otype(object) == IOT_PORT);
1213: port = (ipc_port_t) object;
1214:
1215: for (;;) {
1216: mach_port_t oname;
1217: ipc_entry_t oentry;
1218: ipc_port_request_index_t request;
1219:
1220: kr = ipc_entry_alloc_name(space, name, &entry);
1221: if (kr != KERN_SUCCESS)
1222: return kr;
1223: /* space is write-locked and active */
1224:
1225: if (ipc_right_inuse(space, name, entry))
1226: return KERN_NAME_EXISTS; /* space is unlocked */
1227:
1228: assert(IE_BITS_TYPE(entry->ie_bits) == MACH_PORT_TYPE_NONE);
1229: assert(entry->ie_object == IO_NULL);
1230:
1231: if ((msgt_name != MACH_MSG_TYPE_PORT_SEND_ONCE) &&
1232: ipc_right_reverse(space, (ipc_object_t) port,
1233: &oname, &oentry)) {
1234: /* port is locked and active */
1235:
1236: ip_unlock(port);
1237: ipc_entry_dealloc(space, name, entry);
1238: is_write_unlock(space);
1239: return KERN_RIGHT_EXISTS;
1240: }
1241:
1242: ip_lock(port);
1243: if (!ip_active(port)) {
1244: ip_unlock(port);
1245: ipc_entry_dealloc(space, name, entry);
1246: is_write_unlock(space);
1247: return KERN_INVALID_CAPABILITY;
1248: }
1249:
1250: kr = ipc_port_dnrequest(port, name, ipr_spacem(space),
1251: &request);
1252: if (kr != KERN_SUCCESS) {
1253: ipc_entry_dealloc(space, name, entry);
1254: is_write_unlock(space);
1255:
1256: kr = ipc_port_dngrow(port);
1257: /* port is unlocked */
1258: if (kr != KERN_SUCCESS)
1259: return kr;
1260:
1261: continue;
1262: }
1263:
1264: is_reference(space); /* for dnrequest */
1265: entry->ie_object = (ipc_object_t) port;
1266: entry->ie_request = request;
1267: entry->ie_bits |= IE_BITS_COMPAT;
1268: break;
1269: }
1270:
1271: /* space is write-locked and active, port is locked and active */
1272:
1273: kr = ipc_right_copyout(space, name, entry,
1274: msgt_name, TRUE, (ipc_object_t) port);
1275: /* object is unlocked */
1276: is_write_unlock(space);
1277:
1278: assert(kr == KERN_SUCCESS);
1279: return kr;
1280: }
1281:
1282: #endif MACH_IPC_COMPAT
1283:
1284: #include <mach_kdb.h>
1285:
1286:
1287: #if MACH_KDB
1288: #define printf kdbprintf
1289:
1290: /*
1291: * Routine: ipc_object_print
1292: * Purpose:
1293: * Pretty-print an object for kdb.
1294: */
1295:
1296: char *ikot_print_array[IKOT_MAX_TYPE] = {
1297: "(NONE) ",
1298: "(THREAD) ",
1299: "(TASK) ",
1300: "(HOST) ",
1301: "(HOST_PRIV) ",
1302: "(PROCESSOR) ",
1303: "(PSET) ",
1304: "(PSET_NAME) ",
1305: "(PAGER) ",
1306: "(PAGER_REQUEST) ",
1307: "(DEVICE) ", /* 10 */
1308: "(XMM_OBJECT) ",
1309: "(XMM_PAGER) ",
1310: "(XMM_KERNEL) ",
1311: "(XMM_REPLY) ",
1312: "(PAGER_TERMINATING)",
1313: "(PAGING_NAME) ",
1314: "(HOST_SECURITY) ",
1315: "(LEDGER) ",
1316: "(MASTER_DEVICE) ",
1317: "(ACTIVATION) ", /* 20 */
1318: "(SUBSYSTEM) ",
1319: "(IO_DONE_QUEUE) ",
1320: "(SEMAPHORE) ",
1321: "(LOCK_SET) ",
1322: "(CLOCK) ",
1323: "(CLOCK_CTRL) ", /* 26 */
1324: /* << new entries here */
1325: "(UNKNOWN) " /* magic catchall */
1326: }; /* Please keep in sync with kern/ipc_kobject.h */
1327:
1328: void
1329: ipc_object_print(
1330: ipc_object_t object)
1331: {
1332: int kotype;
1333:
1334: iprintf("%s", io_active(object) ? "active" : "dead");
1335: printf(", refs=%d", object->io_references);
1336: printf(", otype=%d", io_otype(object));
1337: kotype = io_kotype(object);
1338: if (kotype >= 0 && kotype < IKOT_MAX_TYPE)
1339: printf(", kotype=%d %s\n", io_kotype(object),
1340: ikot_print_array[kotype]);
1341: else
1342: printf(", kotype=0x%x %s\n", io_kotype(object),
1343: ikot_print_array[IKOT_UNKNOWN]);
1344: }
1345:
1346: #endif /* MACH_KDB */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.