![[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 [Apple Darwin 0.x] / kernel / ipc|
Return to ipc_object.c CVS log | Up to [Apple Darwin 0.x] / kernel / ipc |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: /*
26: * Copyright (c) 1995, 1994, 1993, 1992, 1991, 1990
27: * Open Software Foundation, Inc.
28: *
29: * Permission to use, copy, modify, and distribute this software and
30: * its documentation for any purpose and without fee is hereby granted,
31: * provided that the above copyright notice appears in all copies and
32: * that both the copyright notice and this permission notice appear in
33: * supporting documentation, and that the name of ("OSF") or Open Software
34: * Foundation not be used in advertising or publicity pertaining to
35: * distribution of the software without specific, written prior permission.
36: *
37: * OSF DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE
38: * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
39: * FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL OSF BE LIABLE FOR ANY
40: * SPECIAL, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
41: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
42: * ACTION OF CONTRACT, NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING
43: * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE
44: */
45: /*
46: * OSF Research Institute MK6.1 (unencumbered) 1/31/1995
47: */
48: /*
49: * Mach Operating System
50: * Copyright (c) 1991,1990,1989 Carnegie Mellon University
51: * All Rights Reserved.
52: *
53: * Permission to use, copy, modify and distribute this software and its
54: * documentation is hereby granted, provided that both the copyright
55: * notice and this permission notice appear in all copies of the
56: * software, derivative works or modified versions, and any portions
57: * thereof, and that both notices appear in supporting documentation.
58: *
59: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
60: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
61: * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
62: *
63: * Carnegie Mellon requests users of this software to return to
64: *
65: * Software Distribution Coordinator or [email protected]
66: * School of Computer Science
67: * Carnegie Mellon University
68: * Pittsburgh PA 15213-3890
69: *
70: * any improvements or extensions that they make and grant Carnegie Mellon
71: * the rights to redistribute these changes.
72: */
73: /*
74: * File: ipc/ipc_object.c
75: * Author: Rich Draves
76: * Date: 1989
77: *
78: * Functions to manipulate IPC objects.
79: */
80:
81: #import <mach/features.h>
82:
83: #include <mach/boolean.h>
84: #include <mach/kern_return.h>
85: #include <mach/port.h>
86: #include <mach/message.h>
87: #include <ipc/port.h>
88: #include <ipc/ipc_space.h>
89: #include <ipc/ipc_entry.h>
90: #include <ipc/ipc_object.h>
91: #include <ipc/ipc_hash.h>
92: #include <ipc/ipc_right.h>
93: #include <ipc/ipc_notify.h>
94:
95: zone_t ipc_object_zones[IOT_NUMBER];
96:
97: /*
98: * Routine: ipc_object_reference
99: * Purpose:
100: * Take a reference to an object.
101: */
102:
103: void
104: ipc_object_reference(
105: ipc_object_t object)
106: {
107: io_lock(object);
108: assert(object->io_references > 0);
109: io_reference(object);
110: io_unlock(object);
111: }
112:
113: /*
114: * Routine: ipc_object_release
115: * Purpose:
116: * Release a reference to an object.
117: */
118:
119: void
120: ipc_object_release(
121: ipc_object_t object)
122: {
123: io_lock(object);
124: assert(object->io_references > 0);
125: io_release(object);
126: io_check_unlock(object);
127: }
128:
129: /*
130: * Routine: ipc_object_translate
131: * Purpose:
132: * Look up an object in a space.
133: * Conditions:
134: * Nothing locked before. If successful, the object
135: * is returned locked. The caller doesn't get a ref.
136: * Returns:
137: * KERN_SUCCESS Objected returned locked.
138: * KERN_INVALID_TASK The space is dead.
139: * KERN_INVALID_NAME The name doesn't denote a right.
140: * KERN_INVALID_RIGHT Name doesn't denote the correct right.
141: */
142:
143: kern_return_t
144: ipc_object_translate(
145: ipc_space_t space,
146: mach_port_t name,
147: mach_port_right_t right,
148: ipc_object_t *objectp)
149: {
150: ipc_entry_t entry;
151: ipc_object_t object;
152: kern_return_t kr;
153:
154: kr = ipc_right_lookup_read(space, name, &entry);
155: if (kr != KERN_SUCCESS)
156: return kr;
157: /* space is read-locked and active */
158:
159: if ((entry->ie_bits & MACH_PORT_TYPE(right)) == 0) {
160: is_read_unlock(space);
161: return KERN_INVALID_RIGHT;
162: }
163:
164: object = entry->ie_object;
165: assert(object != IO_NULL);
166:
167: io_lock(object);
168: is_read_unlock(space);
169:
170: *objectp = object;
171: return KERN_SUCCESS;
172: }
173:
174: /*
175: * Routine: ipc_object_alloc_dead
176: * Purpose:
177: * Allocate a dead-name entry.
178: * Conditions:
179: * Nothing locked.
180: * Returns:
181: * KERN_SUCCESS The dead name is allocated.
182: * KERN_INVALID_TASK The space is dead.
183: * KERN_NO_SPACE No room for an entry in the space.
184: * KERN_RESOURCE_SHORTAGE Couldn't allocate memory.
185: */
186:
187: kern_return_t
188: ipc_object_alloc_dead(
189: ipc_space_t space,
190: mach_port_t *namep)
191: {
192: ipc_entry_t entry;
193: kern_return_t kr;
194:
195: kr = ipc_entry_alloc(space, namep, &entry);
196: if (kr != KERN_SUCCESS)
197: return kr;
198: /* space is write-locked */
199:
200: /* null object, MACH_PORT_TYPE_DEAD_NAME, 1 uref */
201:
202: assert(entry->ie_object == IO_NULL);
203: entry->ie_bits |= MACH_PORT_TYPE_DEAD_NAME | 1;
204:
205: is_write_unlock(space);
206: return KERN_SUCCESS;
207: }
208:
209: /*
210: * Routine: ipc_object_alloc_dead_name
211: * Purpose:
212: * Allocate a dead-name entry, with a specific name.
213: * Conditions:
214: * Nothing locked.
215: * Returns:
216: * KERN_SUCCESS The dead name is allocated.
217: * KERN_INVALID_TASK The space is dead.
218: * KERN_NAME_EXISTS The name already denotes a right.
219: * KERN_RESOURCE_SHORTAGE Couldn't allocate memory.
220: */
221:
222: kern_return_t
223: ipc_object_alloc_dead_name(
224: ipc_space_t space,
225: mach_port_t name)
226: {
227: ipc_entry_t entry;
228: kern_return_t kr;
229:
230: kr = ipc_entry_alloc_name(space, name, &entry);
231: if (kr != KERN_SUCCESS)
232: return kr;
233: /* space is write-locked */
234:
235: if (ipc_right_inuse(space, name, entry))
236: return KERN_NAME_EXISTS;
237:
238: /* null object, MACH_PORT_TYPE_DEAD_NAME, 1 uref */
239:
240: assert(entry->ie_object == IO_NULL);
241: entry->ie_bits |= MACH_PORT_TYPE_DEAD_NAME | 1;
242:
243: is_write_unlock(space);
244: return KERN_SUCCESS;
245: }
246:
247: /*
248: * Routine: ipc_object_alloc
249: * Purpose:
250: * Allocate an object.
251: * Conditions:
252: * Nothing locked. If successful, the object is returned locked.
253: * The caller doesn't get a reference for the object.
254: * Returns:
255: * KERN_SUCCESS The object is allocated.
256: * KERN_INVALID_TASK The space is dead.
257: * KERN_NO_SPACE No room for an entry in the space.
258: * KERN_RESOURCE_SHORTAGE Couldn't allocate memory.
259: */
260:
261: kern_return_t
262: ipc_object_alloc(
263: ipc_space_t space,
264: ipc_object_type_t otype,
265: mach_port_type_t type,
266: mach_port_urefs_t urefs,
267: mach_port_t *namep,
268: ipc_object_t *objectp)
269: {
270: ipc_object_t object;
271: ipc_entry_t entry;
272: kern_return_t kr;
273:
274: assert(otype < IOT_NUMBER);
275: assert((type & MACH_PORT_TYPE_ALL_RIGHTS) == type);
276: assert(type != MACH_PORT_TYPE_NONE);
277: assert(urefs <= MACH_PORT_UREFS_MAX);
278:
279: object = io_alloc(otype);
280: if (object == IO_NULL)
281: return KERN_RESOURCE_SHORTAGE;
282:
283: kr = ipc_entry_alloc(space, namep, &entry);
284: if (kr != KERN_SUCCESS) {
285: io_free(otype, object);
286: return kr;
287: }
288: /* space is write-locked */
289:
290: entry->ie_bits |= type | urefs;
291: entry->ie_object = object;
292:
293: io_lock_init(object);
294: io_lock(object);
295: is_write_unlock(space);
296:
297: object->io_references = 1; /* for entry, not caller */
298: object->io_bits = io_makebits(TRUE, otype, 0);
299:
300: *objectp = object;
301: return KERN_SUCCESS;
302: }
303:
304: /*
305: * Routine: ipc_object_alloc_name
306: * Purpose:
307: * Allocate an object, with a specific name.
308: * Conditions:
309: * Nothing locked. If successful, the object is returned locked.
310: * The caller doesn't get a reference for the object.
311: * Returns:
312: * KERN_SUCCESS The object is allocated.
313: * KERN_INVALID_TASK The space is dead.
314: * KERN_NAME_EXISTS The name already denotes a right.
315: * KERN_RESOURCE_SHORTAGE Couldn't allocate memory.
316: */
317:
318: kern_return_t
319: ipc_object_alloc_name(
320: ipc_space_t space,
321: ipc_object_type_t otype,
322: mach_port_type_t type,
323: mach_port_urefs_t urefs,
324: mach_port_t name,
325: ipc_object_t *objectp)
326: {
327: ipc_object_t object;
328: ipc_entry_t entry;
329: kern_return_t kr;
330:
331: assert(otype < IOT_NUMBER);
332: assert((type & MACH_PORT_TYPE_ALL_RIGHTS) == type);
333: assert(type != MACH_PORT_TYPE_NONE);
334: assert(urefs <= MACH_PORT_UREFS_MAX);
335:
336: object = io_alloc(otype);
337: if (object == IO_NULL)
338: return KERN_RESOURCE_SHORTAGE;
339:
340: kr = ipc_entry_alloc_name(space, name, &entry);
341: if (kr != KERN_SUCCESS) {
342: io_free(otype, object);
343: return kr;
344: }
345: /* space is write-locked */
346:
347: if (ipc_right_inuse(space, name, entry)) {
348: io_free(otype, object);
349: return KERN_NAME_EXISTS;
350: }
351:
352: entry->ie_bits |= type | urefs;
353: entry->ie_object = object;
354:
355: io_lock_init(object);
356: io_lock(object);
357: is_write_unlock(space);
358:
359: object->io_references = 1; /* for entry, not caller */
360: object->io_bits = io_makebits(TRUE, otype, 0);
361:
362: *objectp = object;
363: return KERN_SUCCESS;
364: }
365:
366: /*
367: * Routine: ipc_object_copyin_type
368: * Purpose:
369: * Convert a send type name to a received type name.
370: */
371: mach_msg_type_name_t
372: ipc_object_copyin_type(
373: mach_msg_type_name_t msgt_name)
374: {
375: switch (msgt_name) {
376: case 0:
377: return 0;
378:
379: case MACH_MSG_TYPE_MOVE_RECEIVE:
380: return MACH_MSG_TYPE_PORT_RECEIVE;
381:
382: case MACH_MSG_TYPE_MOVE_SEND_ONCE:
383: case MACH_MSG_TYPE_MAKE_SEND_ONCE:
384: return MACH_MSG_TYPE_PORT_SEND_ONCE;
385:
386: case MACH_MSG_TYPE_MOVE_SEND:
387: case MACH_MSG_TYPE_MAKE_SEND:
388: case MACH_MSG_TYPE_COPY_SEND:
389: return MACH_MSG_TYPE_PORT_SEND;
390:
391: #if MACH_IPC_COMPAT
392: case MSG_TYPE_PORT:
393: return MACH_MSG_TYPE_PORT_SEND;
394:
395: case MSG_TYPE_PORT_ALL:
396: return MACH_MSG_TYPE_PORT_RECEIVE;
397: #endif MACH_IPC_COMPAT
398:
399: default:
400: panic("ipc_object_copyin_type: strange rights");
401: }
402: }
403:
404: /*
405: * Routine: ipc_object_copyin
406: * Purpose:
407: * Copyin a capability from a space.
408: * If successful, the caller gets a ref
409: * for the resulting object, unless it is IO_DEAD.
410: * Conditions:
411: * Nothing locked.
412: * Returns:
413: * KERN_SUCCESS Acquired an object, possibly IO_DEAD.
414: * KERN_INVALID_TASK The space is dead.
415: * KERN_INVALID_NAME Name doesn't exist in space.
416: * KERN_INVALID_RIGHT Name doesn't denote correct right.
417: */
418:
419: kern_return_t
420: ipc_object_copyin(
421: ipc_space_t space,
422: mach_port_t name,
423: mach_msg_type_name_t msgt_name,
424: ipc_object_t *objectp)
425: {
426: ipc_entry_t entry;
427: ipc_port_t soright;
428: kern_return_t kr;
429:
430: /*
431: * Could first try a read lock when doing
432: * MACH_MSG_TYPE_COPY_SEND, MACH_MSG_TYPE_MAKE_SEND,
433: * and MACH_MSG_TYPE_MAKE_SEND_ONCE.
434: */
435:
436: kr = ipc_right_lookup_write(space, name, &entry);
437: if (kr != KERN_SUCCESS)
438: return kr;
439: /* space is write-locked and active */
440:
441: kr = ipc_right_copyin(space, name, entry,
442: msgt_name, TRUE,
443: objectp, &soright);
444: if (IE_BITS_TYPE(entry->ie_bits) == MACH_PORT_TYPE_NONE)
445: ipc_entry_dealloc(space, name, entry);
446: is_write_unlock(space);
447:
448: if ((kr == KERN_SUCCESS) && (soright != IP_NULL))
449: ipc_notify_port_deleted(soright, name);
450:
451: return kr;
452: }
453:
454: /*
455: * Routine: ipc_object_copyin_from_kernel
456: * Purpose:
457: * Copyin a naked capability from the kernel.
458: *
459: * MACH_MSG_TYPE_MOVE_RECEIVE
460: * The receiver must be ipc_space_kernel.
461: * Consumes the naked receive right.
462: * MACH_MSG_TYPE_COPY_SEND
463: * A naked send right must be supplied.
464: * The port gains a reference, and a send right
465: * if the port is still active.
466: * MACH_MSG_TYPE_MAKE_SEND
467: * The receiver must be ipc_space_kernel.
468: * The port gains a reference and a send right.
469: * MACH_MSG_TYPE_MOVE_SEND
470: * Consumes a naked send right.
471: * MACH_MSG_TYPE_MAKE_SEND_ONCE
472: * The receiver must be ipc_space_kernel.
473: * The port gains a reference and a send-once right.
474: * MACH_MSG_TYPE_MOVE_SEND_ONCE
475: * Consumes a naked send-once right.
476: * Conditions:
477: * Nothing locked.
478: */
479:
480: void
481: ipc_object_copyin_from_kernel(
482: ipc_object_t object,
483: mach_msg_type_name_t msgt_name)
484: {
485: assert(IO_VALID(object));
486:
487: switch (msgt_name) {
488: #if MACH_IPC_COMPAT
489: case MSG_TYPE_PORT_ALL:
490: #endif
491: case MACH_MSG_TYPE_MOVE_RECEIVE: {
492: ipc_port_t port = (ipc_port_t) object;
493:
494: ip_lock(port);
495: assert(ip_active(port));
496: assert(port->ip_receiver_name != MACH_PORT_NULL);
497: assert(port->ip_receiver == ipc_space_kernel);
498:
499: /* relevant part of ipc_port_clear_receiver */
500: ipc_port_set_mscount(port, 0);
501:
502: port->ip_receiver_name = MACH_PORT_NULL;
503: port->ip_destination = IP_NULL;
504: ip_unlock(port);
505: break;
506: }
507:
508: #if MACH_IPC_COMPAT
509: case MSG_TYPE_PORT:
510: #endif
511: case MACH_MSG_TYPE_COPY_SEND: {
512: ipc_port_t port = (ipc_port_t) object;
513:
514: ip_lock(port);
515: if (ip_active(port)) {
516: assert(port->ip_srights > 0);
517: port->ip_srights++;
518: }
519: ip_reference(port);
520: ip_unlock(port);
521: break;
522: }
523:
524: case MACH_MSG_TYPE_MAKE_SEND: {
525: ipc_port_t port = (ipc_port_t) object;
526:
527: ip_lock(port);
528: assert(ip_active(port));
529: assert(port->ip_receiver_name != MACH_PORT_NULL);
530: assert(port->ip_receiver == ipc_space_kernel);
531:
532: ip_reference(port);
533: port->ip_mscount++;
534: port->ip_srights++;
535: ip_unlock(port);
536: break;
537: }
538:
539: case MACH_MSG_TYPE_MOVE_SEND:
540: /* move naked send right into the message */
541: break;
542:
543: case MACH_MSG_TYPE_MAKE_SEND_ONCE: {
544: ipc_port_t port = (ipc_port_t) object;
545:
546: ip_lock(port);
547: assert(ip_active(port));
548: assert(port->ip_receiver_name != MACH_PORT_NULL);
549: assert(port->ip_receiver == ipc_space_kernel);
550:
551: ip_reference(port);
552: port->ip_sorights++;
553: ip_unlock(port);
554: break;
555: }
556:
557: case MACH_MSG_TYPE_MOVE_SEND_ONCE:
558: /* move naked send-once right into the message */
559: break;
560:
561: default:
562: panic("ipc_object_copyin_from_kernel: strange rights");
563: }
564: }
565:
566: /*
567: * Routine: ipc_object_destroy
568: * Purpose:
569: * Destroys a naked capability.
570: * Consumes a ref for the object.
571: *
572: * A receive right should be in limbo or in transit.
573: * Conditions:
574: * Nothing locked.
575: */
576:
577: void
578: ipc_object_destroy(
579: ipc_object_t object,
580: mach_msg_type_name_t msgt_name)
581: {
582: assert(IO_VALID(object));
583:
584: switch (msgt_name) {
585: case MACH_MSG_TYPE_PORT_SEND:
586: assert(io_otype(object) == IOT_PORT);
587: ipc_port_release_send((ipc_port_t) object);
588: break;
589:
590: case MACH_MSG_TYPE_PORT_SEND_ONCE:
591: assert(io_otype(object) == IOT_PORT);
592: ipc_notify_send_once((ipc_port_t) object);
593: break;
594:
595: case MACH_MSG_TYPE_PORT_RECEIVE:
596: assert(io_otype(object) == IOT_PORT);
597: ipc_port_release_receive((ipc_port_t) object);
598: break;
599:
600: default:
601: panic("ipc_object_copyout_dest: strange rights");
602: }
603: }
604:
605: /*
606: * Routine: ipc_object_copyout
607: * Purpose:
608: * Copyout a capability, placing it into a space.
609: * If successful, consumes a ref for the object.
610: * Conditions:
611: * Nothing locked.
612: * Returns:
613: * KERN_SUCCESS Copied out object, consumed ref.
614: * KERN_INVALID_TASK The space is dead.
615: * KERN_INVALID_CAPABILITY The object is dead.
616: * KERN_NO_SPACE No room in space for another right.
617: * KERN_RESOURCE_SHORTAGE No memory available.
618: * KERN_UREFS_OVERFLOW Urefs limit exceeded
619: * and overflow wasn't specified.
620: */
621:
622: kern_return_t
623: ipc_object_copyout(
624: ipc_space_t space,
625: ipc_object_t object,
626: mach_msg_type_name_t msgt_name,
627: boolean_t overflow,
628: mach_port_t *namep)
629: {
630: mach_port_t name;
631: ipc_entry_t entry;
632: kern_return_t kr;
633:
634: assert(IO_VALID(object));
635: assert(io_otype(object) == IOT_PORT);
636:
637: is_write_lock(space);
638:
639: for (;;) {
640: if (!space->is_active) {
641: is_write_unlock(space);
642: return KERN_INVALID_TASK;
643: }
644:
645: if ((msgt_name != MACH_MSG_TYPE_PORT_SEND_ONCE) &&
646: ipc_right_reverse(space, object, &name, &entry)) {
647: /* object is locked and active */
648:
649: assert(entry->ie_bits & MACH_PORT_TYPE_SEND_RECEIVE);
650: break;
651: }
652:
653: kr = ipc_entry_get(space, &name, &entry);
654: if (kr != KERN_SUCCESS) {
655: /* unlocks/locks space, so must start again */
656:
657: kr = ipc_entry_grow_table(space, ITS_SIZE_NONE);
658: if (kr != KERN_SUCCESS)
659: return kr; /* space is unlocked */
660:
661: continue;
662: }
663:
664: assert(IE_BITS_TYPE(entry->ie_bits) == MACH_PORT_TYPE_NONE);
665: assert(entry->ie_object == IO_NULL);
666:
667: io_lock(object);
668: if (!io_active(object)) {
669: io_unlock(object);
670: ipc_entry_dealloc(space, name, entry);
671: is_write_unlock(space);
672: return KERN_INVALID_CAPABILITY;
673: }
674:
675: entry->ie_object = object;
676: break;
677: }
678:
679: /* space is write-locked and active, object is locked and active */
680:
681: kr = ipc_right_copyout(space, name, entry,
682: msgt_name, overflow, object);
683: /* object is unlocked */
684: is_write_unlock(space);
685:
686: if (kr == KERN_SUCCESS)
687: *namep = name;
688: return kr;
689: }
690:
691: /*
692: * Routine: ipc_object_copyout_name
693: * Purpose:
694: * Copyout a capability, placing it into a space.
695: * The specified name is used for the capability.
696: * If successful, consumes a ref for the object.
697: * Conditions:
698: * Nothing locked.
699: * Returns:
700: * KERN_SUCCESS Copied out object, consumed ref.
701: * KERN_INVALID_TASK The space is dead.
702: * KERN_INVALID_CAPABILITY The object is dead.
703: * KERN_RESOURCE_SHORTAGE No memory available.
704: * KERN_UREFS_OVERFLOW Urefs limit exceeded
705: * and overflow wasn't specified.
706: * KERN_RIGHT_EXISTS Space has rights under another name.
707: * KERN_NAME_EXISTS Name is already used.
708: */
709:
710: kern_return_t
711: ipc_object_copyout_name(
712: ipc_space_t space,
713: ipc_object_t object,
714: mach_msg_type_name_t msgt_name,
715: boolean_t overflow,
716: mach_port_t name)
717: {
718: mach_port_t oname;
719: ipc_entry_t oentry;
720: ipc_entry_t entry;
721: kern_return_t kr;
722:
723: assert(IO_VALID(object));
724: assert(io_otype(object) == IOT_PORT);
725:
726: kr = ipc_entry_alloc_name(space, name, &entry);
727: if (kr != KERN_SUCCESS)
728: return kr;
729: /* space is write-locked and active */
730:
731: if ((msgt_name != MACH_MSG_TYPE_PORT_SEND_ONCE) &&
732: ipc_right_reverse(space, object, &oname, &oentry)) {
733: /* object is locked and active */
734:
735: if (name != oname) {
736: io_unlock(object);
737:
738: if (IE_BITS_TYPE(entry->ie_bits)
739: == MACH_PORT_TYPE_NONE)
740: ipc_entry_dealloc(space, name, entry);
741:
742: is_write_unlock(space);
743: return KERN_RIGHT_EXISTS;
744: }
745:
746: assert(entry == oentry);
747: assert(entry->ie_bits & MACH_PORT_TYPE_SEND_RECEIVE);
748: } else {
749: if (ipc_right_inuse(space, name, entry))
750: return KERN_NAME_EXISTS;
751:
752: assert(IE_BITS_TYPE(entry->ie_bits) == MACH_PORT_TYPE_NONE);
753: assert(entry->ie_object == IO_NULL);
754:
755: io_lock(object);
756: if (!io_active(object)) {
757: io_unlock(object);
758: ipc_entry_dealloc(space, name, entry);
759: is_write_unlock(space);
760: return KERN_INVALID_CAPABILITY;
761: }
762:
763: entry->ie_object = object;
764: }
765:
766: /* space is write-locked and active, object is locked and active */
767:
768: kr = ipc_right_copyout(space, name, entry,
769: msgt_name, overflow, object);
770: /* object is unlocked */
771: is_write_unlock(space);
772: return kr;
773: }
774:
775: /*
776: * Routine: ipc_object_copyout_dest
777: * Purpose:
778: * Translates/consumes the destination right of a message.
779: * This is unlike normal copyout because the right is consumed
780: * in a funny way instead of being given to the receiving space.
781: * The receiver gets his name for the port, if he has receive
782: * rights, otherwise MACH_PORT_NULL.
783: * Conditions:
784: * The object is locked and active. Nothing else locked.
785: * The object is unlocked and loses a reference.
786: */
787:
788: void
789: ipc_object_copyout_dest(
790: ipc_space_t space,
791: ipc_object_t object,
792: mach_msg_type_name_t msgt_name,
793: mach_port_t *namep)
794: {
795: mach_port_t name;
796:
797: assert(IO_VALID(object));
798: assert(io_active(object));
799:
800: io_release(object);
801:
802: /*
803: * If the space is the receiver/owner of the object,
804: * then we quietly consume the right and return
805: * the space's name for the object. Otherwise
806: * we destroy the right and return MACH_PORT_NULL.
807: */
808:
809: switch (msgt_name) {
810: case MACH_MSG_TYPE_PORT_SEND: {
811: ipc_port_t port = (ipc_port_t) object;
812: ipc_port_t nsrequest = IP_NULL;
813: mach_port_mscount_t mscount;
814:
815: assert(port->ip_srights > 0);
816: if (--port->ip_srights == 0) {
817: nsrequest = port->ip_nsrequest;
818: if (nsrequest != IP_NULL) {
819: port->ip_nsrequest = IP_NULL;
820: mscount = port->ip_mscount;
821: }
822: }
823:
824: if (port->ip_receiver == space)
825: name = port->ip_receiver_name;
826: else
827: name = MACH_PORT_NULL;
828:
829: ip_unlock(port);
830:
831: if (nsrequest != IP_NULL)
832: ipc_notify_no_senders(nsrequest, mscount);
833:
834: break;
835: }
836:
837: case MACH_MSG_TYPE_PORT_SEND_ONCE: {
838: ipc_port_t port = (ipc_port_t) object;
839:
840: assert(port->ip_sorights > 0);
841:
842: if (port->ip_receiver == space) {
843: /* quietly consume the send-once right */
844:
845: port->ip_sorights--;
846: name = port->ip_receiver_name;
847: ip_unlock(port);
848: } else {
849: /*
850: * A very bizarre case. The message
851: * was received, but before this copyout
852: * happened the space lost receive rights.
853: * We can't quietly consume the soright
854: * out from underneath some other task,
855: * so generate a send-once notification.
856: */
857:
858: ip_reference(port); /* restore ref */
859: ip_unlock(port);
860:
861: ipc_notify_send_once(port);
862: name = MACH_PORT_NULL;
863: }
864:
865: break;
866: }
867:
868: default:
869: panic("ipc_object_copyout_dest: strange rights");
870: }
871:
872: *namep = name;
873: }
874:
875: /*
876: * Routine: ipc_object_rename
877: * Purpose:
878: * Rename an entry in a space.
879: * Conditions:
880: * Nothing locked.
881: * Returns:
882: * KERN_SUCCESS Renamed the entry.
883: * KERN_INVALID_TASK The space was dead.
884: * KERN_INVALID_NAME oname didn't denote an entry.
885: * KERN_NAME_EXISTS nname already denoted an entry.
886: * KERN_RESOURCE_SHORTAGE Couldn't allocate new entry.
887: */
888:
889: kern_return_t
890: ipc_object_rename(
891: ipc_space_t space,
892: mach_port_t oname,
893: mach_port_t nname)
894: {
895: ipc_entry_t oentry, nentry;
896: kern_return_t kr;
897:
898: kr = ipc_entry_alloc_name(space, nname, &nentry);
899: if (kr != KERN_SUCCESS)
900: return kr;
901: /* space is write-locked and active */
902:
903: if (ipc_right_inuse(space, nname, nentry)) {
904: /* space is unlocked */
905: return KERN_NAME_EXISTS;
906: }
907:
908: /* don't let ipc_entry_lookup see the uninitialized new entry */
909:
910: if ((oname == nname) ||
911: ((oentry = ipc_entry_lookup(space, oname)) == IE_NULL)) {
912: ipc_entry_dealloc(space, nname, nentry);
913: is_write_unlock(space);
914: return KERN_INVALID_NAME;
915: }
916:
917: kr = ipc_right_rename(space, oname, oentry, nname, nentry);
918: /* space is unlocked */
919: return kr;
920: }
921:
922: #if MACH_IPC_COMPAT
923:
924: /*
925: * Routine: ipc_object_copyout_type_compat
926: * Purpose:
927: * Convert a carried type name to an old type name.
928: */
929:
930: mach_msg_type_name_t
931: ipc_object_copyout_type_compat(
932: mach_msg_type_name_t msgt_name)
933: {
934: switch (msgt_name) {
935: case MACH_MSG_TYPE_PORT_SEND:
936: case MACH_MSG_TYPE_PORT_SEND_ONCE:
937: return MSG_TYPE_PORT;
938:
939: case MACH_MSG_TYPE_PORT_RECEIVE:
940: return MSG_TYPE_PORT_ALL;
941:
942: default:
943: panic("ipc_object_copyout_type_compat: strange rights");
944: }
945: }
946:
947: /*
948: * Routine: ipc_object_copyin_compat
949: * Purpose:
950: * Copyin a capability from a space.
951: * If successful, the caller gets a ref
952: * for the resulting object, which is always valid.
953: * Conditions:
954: * Nothing locked.
955: * Returns:
956: * KERN_SUCCESS Acquired a valid object.
957: * KERN_INVALID_TASK The space is dead.
958: * KERN_INVALID_NAME Name doesn't exist in space.
959: * KERN_INVALID_RIGHT Name doesn't denote correct right.
960: */
961:
962: kern_return_t
963: ipc_object_copyin_compat(
964: ipc_space_t space,
965: mach_port_t name,
966: mach_msg_type_name_t msgt_name,
967: boolean_t dealloc,
968: ipc_object_t *objectp)
969: {
970: ipc_entry_t entry;
971: kern_return_t kr;
972:
973: kr = ipc_right_lookup_write(space, name, &entry);
974: if (kr != KERN_SUCCESS)
975: return kr;
976: /* space is write-locked and active */
977:
978: kr = ipc_right_copyin_compat(space, name, entry,
979: msgt_name, dealloc, objectp);
980: /* space is unlocked */
981: return kr;
982: }
983:
984: /*
985: * Routine: ipc_object_copyin_header
986: * Purpose:
987: * Copyin a capability from a space.
988: * If successful, the caller gets a ref
989: * for the resulting object, which is always valid.
990: * The type of the acquired capability is returned.
991: * Conditions:
992: * Nothing locked.
993: * Returns:
994: * KERN_SUCCESS Acquired a valid object.
995: * KERN_INVALID_TASK The space is dead.
996: * KERN_INVALID_NAME Name doesn't exist in space.
997: * KERN_INVALID_RIGHT Name doesn't denote correct right.
998: */
999:
1000: kern_return_t
1001: ipc_object_copyin_header(
1002: ipc_space_t space,
1003: mach_port_t name,
1004: ipc_object_t *objectp,
1005: mach_msg_type_name_t *msgt_namep)
1006: {
1007: ipc_entry_t entry;
1008: kern_return_t kr;
1009:
1010: kr = ipc_right_lookup_write(space, name, &entry);
1011: if (kr != KERN_SUCCESS)
1012: return kr;
1013: /* space is write-locked and active */
1014:
1015: kr = ipc_right_copyin_header(space, name, entry,
1016: objectp, msgt_namep);
1017: /* space is unlocked */
1018: return kr;
1019: }
1020:
1021: /*
1022: * Routine: ipc_object_copyout_compat
1023: * Purpose:
1024: * Copyout a capability, placing it into a space.
1025: * If successful, consumes a ref for the object.
1026: *
1027: * Marks new entries with IE_BITS_COMPAT.
1028: * Conditions:
1029: * Nothing locked.
1030: * Returns:
1031: * KERN_SUCCESS Copied out object, consumed ref.
1032: * KERN_INVALID_TASK The space is dead.
1033: * KERN_INVALID_CAPABILITY The object is dead.
1034: * KERN_NO_SPACE No room in space for another right.
1035: * KERN_RESOURCE_SHORTAGE No memory available.
1036: */
1037:
1038: kern_return_t
1039: ipc_object_copyout_compat(
1040: ipc_space_t space,
1041: ipc_object_t object,
1042: mach_msg_type_name_t msgt_name,
1043: mach_port_t *namep)
1044: {
1045: mach_port_t name;
1046: ipc_entry_t entry;
1047: ipc_port_t port;
1048: kern_return_t kr;
1049:
1050: assert(IO_VALID(object));
1051: assert(io_otype(object) == IOT_PORT);
1052: port = (ipc_port_t) object;
1053:
1054: is_write_lock(space);
1055:
1056: for (;;) {
1057: ipc_port_request_index_t request;
1058:
1059: if (!space->is_active) {
1060: is_write_unlock(space);
1061: return KERN_INVALID_TASK;
1062: }
1063:
1064: if ((msgt_name != MACH_MSG_TYPE_PORT_SEND_ONCE) &&
1065: ipc_right_reverse(space, (ipc_object_t) port,
1066: &name, &entry)) {
1067: /* port is locked and active */
1068:
1069: assert(entry->ie_bits & MACH_PORT_TYPE_SEND_RECEIVE);
1070: break;
1071: }
1072:
1073: kr = ipc_entry_get(space, &name, &entry);
1074: if (kr != KERN_SUCCESS) {
1075: /* unlocks/locks space, so must start again */
1076:
1077: kr = ipc_entry_grow_table(space, ITS_SIZE_NONE);
1078: if (kr != KERN_SUCCESS)
1079: return kr; /* space is unlocked */
1080:
1081: continue;
1082: }
1083:
1084: assert(IE_BITS_TYPE(entry->ie_bits) == MACH_PORT_TYPE_NONE);
1085: assert(entry->ie_object == IO_NULL);
1086:
1087: ip_lock(port);
1088: if (!ip_active(port)) {
1089: ip_unlock(port);
1090: ipc_entry_dealloc(space, name, entry);
1091: is_write_unlock(space);
1092: return KERN_INVALID_CAPABILITY;
1093: }
1094:
1095: kr = ipc_port_dnrequest(port, name, ipr_spacem(space),
1096: &request);
1097: if (kr != KERN_SUCCESS) {
1098: ipc_entry_dealloc(space, name, entry);
1099: is_write_unlock(space);
1100:
1101: kr = ipc_port_dngrow(port, ITS_SIZE_NONE);
1102: /* port is unlocked */
1103: if (kr != KERN_SUCCESS)
1104: return kr;
1105:
1106: is_write_lock(space);
1107: continue;
1108: }
1109:
1110: is_reference(space); /* for dnrequest */
1111: entry->ie_object = (ipc_object_t) port;
1112: entry->ie_request = request;
1113: entry->ie_bits |= IE_BITS_COMPAT;
1114: break;
1115: }
1116:
1117: /* space is write-locked and active, port is locked and active */
1118:
1119: kr = ipc_right_copyout(space, name, entry,
1120: msgt_name, TRUE, (ipc_object_t) port);
1121: /* object is unlocked */
1122: is_write_unlock(space);
1123:
1124: if (kr == KERN_SUCCESS)
1125: *namep = name;
1126: return kr;
1127: }
1128:
1129: /*
1130: * Routine: ipc_object_copyout_name_compat
1131: * Purpose:
1132: * Copyout a capability, placing it into a space.
1133: * The specified name is used for the capability.
1134: * If successful, consumes a ref for the object.
1135: *
1136: * Like ipc_object_copyout_name, except that
1137: * the name can't be in use at all, even for the same
1138: * port, and IE_BITS_COMPAT gets turned on.
1139: * Conditions:
1140: * Nothing locked.
1141: * Returns:
1142: * KERN_SUCCESS Copied out object, consumed ref.
1143: * KERN_INVALID_TASK The space is dead.
1144: * KERN_INVALID_CAPABILITY The object is dead.
1145: * KERN_RESOURCE_SHORTAGE No memory available.
1146: * KERN_RIGHT_EXISTS Space has rights under another name.
1147: * KERN_NAME_EXISTS Name is already used.
1148: */
1149:
1150: kern_return_t
1151: ipc_object_copyout_name_compat(
1152: ipc_space_t space,
1153: ipc_object_t object,
1154: mach_msg_type_name_t msgt_name,
1155: mach_port_t name)
1156: {
1157: ipc_entry_t entry;
1158: ipc_port_t port;
1159: kern_return_t kr;
1160:
1161: assert(IO_VALID(object));
1162: assert(io_otype(object) == IOT_PORT);
1163: port = (ipc_port_t) object;
1164:
1165: for (;;) {
1166: mach_port_t oname;
1167: ipc_entry_t oentry;
1168: ipc_port_request_index_t request;
1169:
1170: kr = ipc_entry_alloc_name(space, name, &entry);
1171: if (kr != KERN_SUCCESS)
1172: return kr;
1173: /* space is write-locked and active */
1174:
1175: if (ipc_right_inuse(space, name, entry))
1176: return KERN_NAME_EXISTS; /* space is unlocked */
1177:
1178: assert(IE_BITS_TYPE(entry->ie_bits) == MACH_PORT_TYPE_NONE);
1179: assert(entry->ie_object == IO_NULL);
1180:
1181: if ((msgt_name != MACH_MSG_TYPE_PORT_SEND_ONCE) &&
1182: ipc_right_reverse(space, (ipc_object_t) port,
1183: &oname, &oentry)) {
1184: /* port is locked and active */
1185:
1186: ip_unlock(port);
1187: ipc_entry_dealloc(space, name, entry);
1188: is_write_unlock(space);
1189: return KERN_RIGHT_EXISTS;
1190: }
1191:
1192: ip_lock(port);
1193: if (!ip_active(port)) {
1194: ip_unlock(port);
1195: ipc_entry_dealloc(space, name, entry);
1196: is_write_unlock(space);
1197: return KERN_INVALID_CAPABILITY;
1198: }
1199:
1200: kr = ipc_port_dnrequest(port, name, ipr_spacem(space),
1201: &request);
1202: if (kr != KERN_SUCCESS) {
1203: ipc_entry_dealloc(space, name, entry);
1204: is_write_unlock(space);
1205:
1206: kr = ipc_port_dngrow(port, ITS_SIZE_NONE);
1207: /* port is unlocked */
1208: if (kr != KERN_SUCCESS)
1209: return kr;
1210:
1211: continue;
1212: }
1213:
1214: is_reference(space); /* for dnrequest */
1215: entry->ie_object = (ipc_object_t) port;
1216: entry->ie_request = request;
1217: entry->ie_bits |= IE_BITS_COMPAT;
1218: break;
1219: }
1220:
1221: /* space is write-locked and active, port is locked and active */
1222:
1223: kr = ipc_right_copyout(space, name, entry,
1224: msgt_name, TRUE, (ipc_object_t) port);
1225: /* object is unlocked */
1226: is_write_unlock(space);
1227:
1228: assert(kr == KERN_SUCCESS);
1229: return kr;
1230: }
1231:
1232: #endif /* MACH_IPC_COMPAT */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.