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