![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ipc_port.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_port.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_port.c ! 75: * Author: Rich Draves ! 76: * Date: 1989 ! 77: * ! 78: * Functions to manipulate IPC ports. ! 79: */ ! 80: ! 81: #import <mach/features.h> ! 82: ! 83: #include <mach/port.h> ! 84: #include <mach/kern_return.h> ! 85: #include <kern/lock.h> ! 86: #include <kern/ipc_sched.h> ! 87: #include <kern/ipc_kobject.h> ! 88: #include <ipc/ipc_entry.h> ! 89: #include <ipc/ipc_space.h> ! 90: #include <ipc/ipc_object.h> ! 91: #include <ipc/ipc_port.h> ! 92: #include <ipc/ipc_pset.h> ! 93: #include <ipc/ipc_thread.h> ! 94: #include <ipc/ipc_mqueue.h> ! 95: #include <ipc/ipc_notify.h> ! 96: ! 97: decl_simple_lock_data(, ipc_port_multiple_lock_data) ! 98: ! 99: decl_simple_lock_data(, ipc_port_timestamp_lock_data) ! 100: ipc_port_timestamp_t ipc_port_timestamp_data; ! 101: ! 102: /* ! 103: * Routine: ipc_port_timestamp ! 104: * Purpose: ! 105: * Retrieve a timestamp value. ! 106: */ ! 107: ! 108: ipc_port_timestamp_t ! 109: ipc_port_timestamp(void) ! 110: { ! 111: ipc_port_timestamp_t timestamp; ! 112: ! 113: ipc_port_timestamp_lock(); ! 114: timestamp = ipc_port_timestamp_data++; ! 115: ipc_port_timestamp_unlock(); ! 116: ! 117: return timestamp; ! 118: } ! 119: ! 120: /* ! 121: * Routine: ipc_port_dnrequest ! 122: * Purpose: ! 123: * Try to allocate a dead-name request slot. ! 124: * If successful, returns the request index. ! 125: * Otherwise returns zero. ! 126: * Conditions: ! 127: * The port is locked and active. ! 128: * Returns: ! 129: * KERN_SUCCESS A request index was found. ! 130: * KERN_NO_SPACE No index allocated. ! 131: */ ! 132: ! 133: kern_return_t ! 134: ipc_port_dnrequest( ! 135: ipc_port_t port, ! 136: mach_port_t name, ! 137: ipc_port_t soright, ! 138: ipc_port_request_index_t *indexp) ! 139: { ! 140: ipc_port_request_t ipr, table; ! 141: ipc_port_request_index_t index; ! 142: ! 143: assert(ip_active(port)); ! 144: assert(name != MACH_PORT_NULL); ! 145: assert(soright != IP_NULL); ! 146: ! 147: table = port->ip_dnrequests; ! 148: if (table == IPR_NULL) ! 149: return KERN_NO_SPACE; ! 150: ! 151: index = table->ipr_next; ! 152: if (index == 0) ! 153: return KERN_NO_SPACE; ! 154: ! 155: ipr = &table[index]; ! 156: assert(ipr->ipr_name == MACH_PORT_NULL); ! 157: ! 158: table->ipr_next = ipr->ipr_next; ! 159: ipr->ipr_name = name; ! 160: ipr->ipr_soright = soright; ! 161: ! 162: *indexp = index; ! 163: return KERN_SUCCESS; ! 164: } ! 165: ! 166: /* ! 167: * Routine: ipc_port_dngrow ! 168: * Purpose: ! 169: * Grow a port's table of dead-name requests. ! 170: * Conditions: ! 171: * The port must be locked and active. ! 172: * Nothing else locked; will allocate memory. ! 173: * Upon return the port is unlocked. ! 174: * Returns: ! 175: * KERN_SUCCESS Grew the table. ! 176: * KERN_SUCCESS Somebody else grew the table. ! 177: * KERN_SUCCESS The port died. ! 178: * KERN_RESOURCE_SHORTAGE Couldn't allocate new table. ! 179: * KERN_NO_SPACE Couldn't grow to desired size ! 180: */ ! 181: ! 182: kern_return_t ! 183: ipc_port_dngrow( ! 184: ipc_port_t port, ! 185: int target_size) ! 186: { ! 187: ipc_table_size_t its; ! 188: ipc_port_request_t otable, ntable; ! 189: ! 190: assert(ip_active(port)); ! 191: ! 192: otable = port->ip_dnrequests; ! 193: if (otable == IPR_NULL) ! 194: its = &ipc_table_dnrequests[0]; ! 195: else ! 196: its = otable->ipr_size + 1; ! 197: ! 198: if (target_size != ITS_SIZE_NONE) { ! 199: if ((otable != IPR_NULL) && ! 200: (target_size <= otable->ipr_size->its_size)) { ! 201: ip_unlock(port); ! 202: return KERN_SUCCESS; ! 203: } ! 204: while ((its->its_size) && (its->its_size < target_size)) { ! 205: its++; ! 206: } ! 207: if (its->its_size == 0) { ! 208: ip_unlock(port); ! 209: return KERN_NO_SPACE; ! 210: } ! 211: } ! 212: ! 213: ip_reference(port); ! 214: ip_unlock(port); ! 215: ! 216: if ((its->its_size == 0) || ! 217: ((ntable = it_dnrequests_alloc(its)) == IPR_NULL)) { ! 218: ipc_port_release(port); ! 219: return KERN_RESOURCE_SHORTAGE; ! 220: } ! 221: ! 222: ip_lock(port); ! 223: ip_release(port); ! 224: ! 225: /* ! 226: * Check that port is still active and that nobody else ! 227: * has slipped in and grown the table on us. Note that ! 228: * just checking port->ip_dnrequests == otable isn't ! 229: * sufficient; must check ipr_size. ! 230: */ ! 231: ! 232: if (ip_active(port) && ! 233: (port->ip_dnrequests == otable) && ! 234: ((otable == IPR_NULL) || (otable->ipr_size+1 == its))) { ! 235: ipc_table_size_t oits; ! 236: ipc_table_elems_t osize, nsize; ! 237: ipc_port_request_index_t free, i; ! 238: ! 239: /* copy old table to new table */ ! 240: ! 241: if (otable != IPR_NULL) { ! 242: oits = otable->ipr_size; ! 243: osize = oits->its_size; ! 244: free = otable->ipr_next; ! 245: ! 246: bcopy((char *)(otable + 1), (char *)(ntable + 1), ! 247: (osize - 1) * sizeof(struct ipc_port_request)); ! 248: } else { ! 249: osize = 1; ! 250: free = 0; ! 251: } ! 252: ! 253: nsize = its->its_size; ! 254: assert(nsize > osize); ! 255: ! 256: /* add new elements to the new table's free list */ ! 257: ! 258: for (i = osize; i < nsize; i++) { ! 259: ipc_port_request_t ipr = &ntable[i]; ! 260: ! 261: ipr->ipr_name = MACH_PORT_NULL; ! 262: ipr->ipr_next = free; ! 263: free = i; ! 264: } ! 265: ! 266: ntable->ipr_next = free; ! 267: ntable->ipr_size = its; ! 268: port->ip_dnrequests = ntable; ! 269: ip_unlock(port); ! 270: ! 271: if (otable != IPR_NULL) ! 272: it_dnrequests_free(oits, otable); ! 273: } else { ! 274: ip_check_unlock(port); ! 275: it_dnrequests_free(its, ntable); ! 276: } ! 277: ! 278: return KERN_SUCCESS; ! 279: } ! 280: ! 281: /* ! 282: * Routine: ipc_port_dncancel ! 283: * Purpose: ! 284: * Cancel a dead-name request and return the send-once right. ! 285: * Conditions: ! 286: * The port must locked and active. ! 287: */ ! 288: ! 289: ipc_port_t ! 290: ipc_port_dncancel( ! 291: ipc_port_t port, ! 292: mach_port_t name, ! 293: ipc_port_request_index_t index) ! 294: { ! 295: ipc_port_request_t ipr, table; ! 296: ipc_port_t dnrequest; ! 297: ! 298: assert(ip_active(port)); ! 299: assert(name != MACH_PORT_NULL); ! 300: assert(index != 0); ! 301: ! 302: table = port->ip_dnrequests; ! 303: assert(table != IPR_NULL); ! 304: ! 305: ipr = &table[index]; ! 306: dnrequest = ipr->ipr_soright; ! 307: assert(ipr->ipr_name == name); ! 308: ! 309: /* return ipr to the free list inside the table */ ! 310: ! 311: ipr->ipr_name = MACH_PORT_NULL; ! 312: ipr->ipr_next = table->ipr_next; ! 313: table->ipr_next = index; ! 314: ! 315: return dnrequest; ! 316: } ! 317: ! 318: /* ! 319: * Routine: ipc_port_pdrequest ! 320: * Purpose: ! 321: * Make a port-deleted request, returning the ! 322: * previously registered send-once right. ! 323: * Just cancels the previous request if notify is IP_NULL. ! 324: * Conditions: ! 325: * The port is locked and active. It is unlocked. ! 326: * Consumes a ref for notify (if non-null), and ! 327: * returns previous with a ref (if non-null). ! 328: */ ! 329: ! 330: void ! 331: ipc_port_pdrequest( ! 332: ipc_port_t port, ! 333: ipc_port_t notify, ! 334: ipc_port_t *previousp) ! 335: { ! 336: ipc_port_t previous; ! 337: ! 338: assert(ip_active(port)); ! 339: ! 340: previous = port->ip_pdrequest; ! 341: port->ip_pdrequest = notify; ! 342: ip_unlock(port); ! 343: ! 344: *previousp = previous; ! 345: } ! 346: ! 347: /* ! 348: * Routine: ipc_port_nsrequest ! 349: * Purpose: ! 350: * Make a no-senders request, returning the ! 351: * previously registered send-once right. ! 352: * Just cancels the previous request if notify is IP_NULL. ! 353: * Conditions: ! 354: * The port is locked and active. It is unlocked. ! 355: * Consumes a ref for notify (if non-null), and ! 356: * returns previous with a ref (if non-null). ! 357: */ ! 358: ! 359: void ! 360: ipc_port_nsrequest( ! 361: ipc_port_t port, ! 362: mach_port_mscount_t sync, ! 363: ipc_port_t notify, ! 364: ipc_port_t *previousp) ! 365: { ! 366: ipc_port_t previous; ! 367: mach_port_mscount_t mscount; ! 368: ! 369: assert(ip_active(port)); ! 370: ! 371: previous = port->ip_nsrequest; ! 372: mscount = port->ip_mscount; ! 373: ! 374: if ((port->ip_srights == 0) && ! 375: (sync <= mscount) && ! 376: (notify != IP_NULL)) { ! 377: port->ip_nsrequest = IP_NULL; ! 378: ip_unlock(port); ! 379: ipc_notify_no_senders(notify, mscount); ! 380: } else { ! 381: port->ip_nsrequest = notify; ! 382: ip_unlock(port); ! 383: } ! 384: ! 385: *previousp = previous; ! 386: } ! 387: ! 388: /* ! 389: * Routine: ipc_port_set_qlimit ! 390: * Purpose: ! 391: * Changes a port's queue limit; the maximum number ! 392: * of messages which may be queued to the port. ! 393: * Conditions: ! 394: * The port is locked and active. ! 395: */ ! 396: ! 397: void ! 398: ipc_port_set_qlimit( ! 399: ipc_port_t port, ! 400: mach_port_msgcount_t qlimit) ! 401: { ! 402: assert(ip_active(port)); ! 403: assert(qlimit <= MACH_PORT_QLIMIT_MAX); ! 404: ! 405: /* wake up senders allowed by the new qlimit */ ! 406: ! 407: if (qlimit > port->ip_qlimit) { ! 408: mach_port_msgcount_t i, wakeup; ! 409: ! 410: /* caution: wakeup, qlimit are unsigned */ ! 411: ! 412: wakeup = qlimit - port->ip_qlimit; ! 413: ! 414: for (i = 0; i < wakeup; i++) { ! 415: ipc_thread_t th; ! 416: ! 417: th = ipc_thread_dequeue(&port->ip_blocked); ! 418: if (th == ITH_NULL) ! 419: break; ! 420: ! 421: th->ith_state = MACH_MSG_SUCCESS; ! 422: thread_go(th); ! 423: } ! 424: } ! 425: ! 426: port->ip_qlimit = qlimit; ! 427: } ! 428: ! 429: /* ! 430: * Routine: ipc_port_set_seqno ! 431: * Purpose: ! 432: * Changes a port's sequence number. ! 433: * Conditions: ! 434: * The port is locked and active. ! 435: */ ! 436: ! 437: void ! 438: ipc_port_set_seqno( ! 439: ipc_port_t port, ! 440: mach_port_seqno_t seqno) ! 441: { ! 442: if (port->ip_pset != IPS_NULL) { ! 443: ipc_pset_t pset = port->ip_pset; ! 444: ! 445: ips_lock(pset); ! 446: if (!ips_active(pset)) { ! 447: ipc_pset_remove(pset, port); ! 448: ips_check_unlock(pset); ! 449: goto no_port_set; ! 450: } else { ! 451: imq_lock(&pset->ips_messages); ! 452: port->ip_seqno = seqno; ! 453: imq_unlock(&pset->ips_messages); ! 454: } ! 455: } else { ! 456: no_port_set: ! 457: imq_lock(&port->ip_messages); ! 458: port->ip_seqno = seqno; ! 459: imq_unlock(&port->ip_messages); ! 460: } ! 461: } ! 462: ! 463: /* ! 464: * Routine: ipc_port_clear_receiver ! 465: * Purpose: ! 466: * Prepares a receive right for transmission/destruction. ! 467: * Conditions: ! 468: * The port is locked and active. ! 469: */ ! 470: ! 471: void ! 472: ipc_port_clear_receiver( ! 473: ipc_port_t port) ! 474: { ! 475: ipc_pset_t pset; ! 476: ! 477: assert(ip_active(port)); ! 478: ! 479: pset = port->ip_pset; ! 480: if (pset != IPS_NULL) { ! 481: /* No threads receiving from port, but must remove from set. */ ! 482: ! 483: ips_lock(pset); ! 484: ipc_pset_remove(pset, port); ! 485: ips_check_unlock(pset); ! 486: } else { ! 487: /* Else, wake up all receivers, indicating why. */ ! 488: ! 489: imq_lock(&port->ip_messages); ! 490: ipc_mqueue_changed(&port->ip_messages, MACH_RCV_PORT_DIED); ! 491: imq_unlock(&port->ip_messages); ! 492: } ! 493: ! 494: ipc_port_set_mscount(port, 0); ! 495: imq_lock(&port->ip_messages); ! 496: port->ip_seqno = 0; ! 497: imq_unlock(&port->ip_messages); ! 498: } ! 499: ! 500: /* ! 501: * Routine: ipc_port_init ! 502: * Purpose: ! 503: * Initializes a newly-allocated port. ! 504: * Doesn't touch the ip_object fields. ! 505: */ ! 506: ! 507: void ! 508: ipc_port_init( ! 509: ipc_port_t port, ! 510: ipc_space_t space, ! 511: mach_port_t name) ! 512: { ! 513: /* port->ip_kobject doesn't have to be initialized */ ! 514: ! 515: port->ip_receiver = space; ! 516: port->ip_receiver_name = name; ! 517: ! 518: port->ip_mscount = 0; ! 519: port->ip_srights = 0; ! 520: port->ip_sorights = 0; ! 521: ! 522: port->ip_nsrequest = IP_NULL; ! 523: port->ip_pdrequest = IP_NULL; ! 524: port->ip_dnrequests = IPR_NULL; ! 525: ! 526: port->ip_pset = IPS_NULL; ! 527: port->ip_seqno = 0; ! 528: port->ip_msgcount = 0; ! 529: port->ip_qlimit = MACH_PORT_QLIMIT_DEFAULT; ! 530: ! 531: ipc_mqueue_init(&port->ip_messages); ! 532: ipc_thread_queue_init(&port->ip_blocked); ! 533: } ! 534: ! 535: /* ! 536: * Routine: ipc_port_alloc ! 537: * Purpose: ! 538: * Allocate a port. ! 539: * Conditions: ! 540: * Nothing locked. If successful, the port is returned ! 541: * locked. (The caller doesn't have a reference.) ! 542: * Returns: ! 543: * KERN_SUCCESS The port is allocated. ! 544: * KERN_INVALID_TASK The space is dead. ! 545: * KERN_NO_SPACE No room for an entry in the space. ! 546: * KERN_RESOURCE_SHORTAGE Couldn't allocate memory. ! 547: */ ! 548: ! 549: kern_return_t ! 550: ipc_port_alloc( ! 551: ipc_space_t space, ! 552: mach_port_t *namep, ! 553: ipc_port_t *portp) ! 554: { ! 555: ipc_port_t port; ! 556: mach_port_t name; ! 557: kern_return_t kr; ! 558: ! 559: kr = ipc_object_alloc(space, IOT_PORT, ! 560: MACH_PORT_TYPE_RECEIVE, 0, ! 561: &name, (ipc_object_t *) &port); ! 562: if (kr != KERN_SUCCESS) ! 563: return kr; ! 564: /* port is locked */ ! 565: ! 566: ipc_port_init(port, space, name); ! 567: ! 568: *namep = name; ! 569: *portp = port; ! 570: return KERN_SUCCESS; ! 571: } ! 572: ! 573: /* ! 574: * Routine: ipc_port_alloc_name ! 575: * Purpose: ! 576: * Allocate a port, with a specific name. ! 577: * Conditions: ! 578: * Nothing locked. If successful, the port is returned ! 579: * locked. (The caller doesn't have a reference.) ! 580: * Returns: ! 581: * KERN_SUCCESS The port is allocated. ! 582: * KERN_INVALID_TASK The space is dead. ! 583: * KERN_NAME_EXISTS The name already denotes a right. ! 584: * KERN_RESOURCE_SHORTAGE Couldn't allocate memory. ! 585: */ ! 586: ! 587: kern_return_t ! 588: ipc_port_alloc_name( ! 589: ipc_space_t space, ! 590: mach_port_t name, ! 591: ipc_port_t *portp) ! 592: { ! 593: ipc_port_t port; ! 594: kern_return_t kr; ! 595: ! 596: kr = ipc_object_alloc_name(space, IOT_PORT, ! 597: MACH_PORT_TYPE_RECEIVE, 0, ! 598: name, (ipc_object_t *) &port); ! 599: if (kr != KERN_SUCCESS) ! 600: return kr; ! 601: /* port is locked */ ! 602: ! 603: ipc_port_init(port, space, name); ! 604: ! 605: *portp = port; ! 606: return KERN_SUCCESS; ! 607: } ! 608: ! 609: #if MACH_IPC_COMPAT ! 610: /* ! 611: * Routine: ipc_port_delete_compat ! 612: * Purpose: ! 613: * Find and destroy a compat entry for a dead port. ! 614: * If successful, generate a port-deleted notification. ! 615: * Conditions: ! 616: * Nothing locked; the port is dead. ! 617: * Frees a ref for the space. ! 618: */ ! 619: ! 620: void ! 621: ipc_port_delete_compat( ! 622: ipc_port_t port, ! 623: ipc_space_t space, ! 624: mach_port_t name) ! 625: { ! 626: ipc_entry_t entry; ! 627: kern_return_t kr; ! 628: ! 629: assert(!ip_active(port)); ! 630: ! 631: kr = ipc_right_lookup_write(space, name, &entry); ! 632: if (kr == KERN_SUCCESS) { ! 633: ipc_port_t sright; ! 634: ! 635: /* space is write-locked and active */ ! 636: ! 637: if ((ipc_port_t) entry->ie_object == port) { ! 638: assert(entry->ie_bits & IE_BITS_COMPAT); ! 639: ! 640: sright = ipc_space_make_notify(space); ! 641: ! 642: kr = ipc_right_destroy(space, name, entry); ! 643: /* space is unlocked */ ! 644: assert(kr == KERN_INVALID_NAME); ! 645: } else { ! 646: is_write_unlock(space); ! 647: sright = IP_NULL; ! 648: } ! 649: ! 650: if (IP_VALID(sright)) ! 651: ipc_notify_port_deleted_compat(sright, name); ! 652: } ! 653: ! 654: is_release(space); ! 655: } ! 656: #endif /* MACH_IPC_COMPAT */ ! 657: ! 658: /* ! 659: * Routine: ipc_port_destroy ! 660: * Purpose: ! 661: * Destroys a port. Cleans up queued messages. ! 662: * ! 663: * If the port has a backup, it doesn't get destroyed, ! 664: * but is sent in a port-destroyed notification to the backup. ! 665: * Conditions: ! 666: * The port is locked and alive; nothing else locked. ! 667: * The caller has a reference, which is consumed. ! 668: * Afterwards, the port is unlocked and dead. ! 669: */ ! 670: ! 671: void ! 672: ipc_port_destroy( ! 673: ipc_port_t port) ! 674: { ! 675: ipc_port_t pdrequest, nsrequest; ! 676: ipc_mqueue_t mqueue; ! 677: ipc_kmsg_queue_t kmqueue; ! 678: ipc_kmsg_t kmsg; ! 679: ipc_thread_t sender; ! 680: ipc_port_request_t dnrequests; ! 681: ! 682: assert(ip_active(port)); ! 683: /* port->ip_receiver_name is garbage */ ! 684: /* port->ip_receiver/port->ip_destination is garbage */ ! 685: assert(port->ip_pset == IPS_NULL); ! 686: assert(port->ip_mscount == 0); ! 687: assert(port->ip_seqno == 0); ! 688: ! 689: /* first check for a backup port */ ! 690: ! 691: pdrequest = port->ip_pdrequest; ! 692: if (pdrequest != IP_NULL) { ! 693: /* we assume the ref for pdrequest */ ! 694: port->ip_pdrequest = IP_NULL; ! 695: ! 696: /* make port be in limbo */ ! 697: port->ip_receiver_name = MACH_PORT_NULL; ! 698: port->ip_destination = IP_NULL; ! 699: ip_unlock(port); ! 700: ! 701: #if MACH_IPC_COMPAT ! 702: /* ! 703: * pdrequest might actually be a send right instead ! 704: * of a send-once right, indicated by the low bit ! 705: * of the pointer value. If this is the case, ! 706: * we must use ipc_notify_port_destroyed_compat. ! 707: */ ! 708: ! 709: if (ip_pdsendp(pdrequest)) { ! 710: ipc_port_t sright = ip_pdsend(pdrequest); ! 711: ! 712: if (!ipc_port_check_circularity(port, sright)) { ! 713: /* consumes our refs for port and sright */ ! 714: ipc_notify_port_destroyed_compat(sright, port); ! 715: return; ! 716: } else { ! 717: /* consume sright and destroy port */ ! 718: ipc_port_release_send(sright); ! 719: } ! 720: } else ! 721: #endif /* MACH_IPC_COMPAT */ ! 722: ! 723: if (!ipc_port_check_circularity(port, pdrequest)) { ! 724: /* consumes our refs for port and pdrequest */ ! 725: ipc_notify_port_destroyed(pdrequest, port); ! 726: return; ! 727: } else { ! 728: /* consume pdrequest and destroy port */ ! 729: ipc_port_release_sonce(pdrequest); ! 730: } ! 731: ! 732: ip_lock(port); ! 733: assert(ip_active(port)); ! 734: assert(port->ip_pset == IPS_NULL); ! 735: assert(port->ip_mscount == 0); ! 736: assert(port->ip_seqno == 0); ! 737: assert(port->ip_pdrequest == IP_NULL); ! 738: assert(port->ip_receiver_name == MACH_PORT_NULL); ! 739: assert(port->ip_destination == IP_NULL); ! 740: ! 741: /* fall through and destroy the port */ ! 742: } ! 743: ! 744: /* ! 745: * rouse all blocked senders ! 746: * ! 747: * This must be done with the port locked, because ! 748: * ipc_mqueue_send can play with the ip_blocked queue ! 749: * of a dead port. ! 750: */ ! 751: ! 752: while ((sender = ipc_thread_dequeue(&port->ip_blocked)) != ITH_NULL) { ! 753: sender->ith_state = MACH_MSG_SUCCESS; ! 754: thread_go(sender); ! 755: } ! 756: ! 757: /* once port is dead, we don't need to keep it locked */ ! 758: ! 759: port->ip_object.io_bits &= ~IO_BITS_ACTIVE; ! 760: port->ip_timestamp = ipc_port_timestamp(); ! 761: ip_unlock(port); ! 762: ! 763: /* throw away no-senders request */ ! 764: ! 765: nsrequest = port->ip_nsrequest; ! 766: if (nsrequest != IP_NULL) ! 767: ipc_notify_send_once(nsrequest); /* consumes ref */ ! 768: ! 769: /* destroy any queued messages */ ! 770: ! 771: mqueue = &port->ip_messages; ! 772: imq_lock(mqueue); ! 773: assert(ipc_thread_queue_empty(&mqueue->imq_threads)); ! 774: kmqueue = &mqueue->imq_messages; ! 775: ! 776: while ((kmsg = ipc_kmsg_dequeue(kmqueue)) != IKM_NULL) { ! 777: imq_unlock(mqueue); ! 778: ! 779: assert(kmsg->ikm_header.msgh_remote_port == ! 780: (mach_port_t) port); ! 781: ! 782: ipc_port_release(port); ! 783: kmsg->ikm_header.msgh_remote_port = MACH_PORT_NULL; ! 784: ipc_kmsg_destroy(kmsg); ! 785: ! 786: imq_lock(mqueue); ! 787: } ! 788: ! 789: imq_unlock(mqueue); ! 790: ! 791: /* generate dead-name notifications */ ! 792: ! 793: dnrequests = port->ip_dnrequests; ! 794: if (dnrequests != IPR_NULL) { ! 795: ipc_table_size_t its = dnrequests->ipr_size; ! 796: ipc_table_elems_t size = its->its_size; ! 797: ipc_port_request_index_t index; ! 798: ! 799: for (index = 1; index < size; index++) { ! 800: ipc_port_request_t ipr = &dnrequests[index]; ! 801: mach_port_t name = ipr->ipr_name; ! 802: ipc_port_t soright; ! 803: ! 804: if (name == MACH_PORT_NULL) ! 805: continue; ! 806: ! 807: soright = ipr->ipr_soright; ! 808: assert(soright != IP_NULL); ! 809: ! 810: #if MACH_IPC_COMPAT ! 811: if (ipr_spacep(soright)) { ! 812: ipc_port_delete_compat(port, ! 813: ipr_space(soright), name); ! 814: continue; ! 815: } ! 816: #endif /* MACH_IPC_COMPAT */ ! 817: ! 818: ipc_notify_dead_name(soright, name); ! 819: } ! 820: ! 821: it_dnrequests_free(its, dnrequests); ! 822: } ! 823: ! 824: if (ip_kotype(port) != IKOT_NONE) ! 825: ipc_kobject_destroy(port); ! 826: ! 827: ipc_port_release(port); /* consume caller's ref */ ! 828: } ! 829: ! 830: /* ! 831: * Routine: ipc_port_check_circularity ! 832: * Purpose: ! 833: * Check if queueing "port" in a message for "dest" ! 834: * would create a circular group of ports and messages. ! 835: * ! 836: * If no circularity (FALSE returned), then "port" ! 837: * is changed from "in limbo" to "in transit". ! 838: * ! 839: * That is, we want to set port->ip_destination == dest, ! 840: * but guaranteeing that this doesn't create a circle ! 841: * port->ip_destination->ip_destination->... == port ! 842: * Conditions: ! 843: * No ports locked. References held for "port" and "dest". ! 844: */ ! 845: ! 846: boolean_t ! 847: ipc_port_check_circularity( ! 848: ipc_port_t port, ! 849: ipc_port_t dest) ! 850: { ! 851: ipc_port_t base; ! 852: ! 853: assert(port != IP_NULL); ! 854: assert(dest != IP_NULL); ! 855: ! 856: if (port == dest) ! 857: return TRUE; ! 858: base = dest; ! 859: ! 860: /* ! 861: * First try a quick check that can run in parallel. ! 862: * No circularity if dest is not in transit. ! 863: */ ! 864: ! 865: ip_lock(port); ! 866: if (ip_lock_try(dest)) { ! 867: if (!ip_active(dest) || ! 868: (dest->ip_receiver_name != MACH_PORT_NULL) || ! 869: (dest->ip_destination == IP_NULL)) ! 870: goto not_circular; ! 871: ! 872: /* dest is in transit; further checking necessary */ ! 873: ! 874: ip_unlock(dest); ! 875: } ! 876: ip_unlock(port); ! 877: ! 878: ipc_port_multiple_lock(); /* massive serialization */ ! 879: ! 880: /* ! 881: * Search for the end of the chain (a port not in transit), ! 882: * acquiring locks along the way. ! 883: */ ! 884: ! 885: for (;;) { ! 886: ip_lock(base); ! 887: ! 888: if (!ip_active(base) || ! 889: (base->ip_receiver_name != MACH_PORT_NULL) || ! 890: (base->ip_destination == IP_NULL)) ! 891: break; ! 892: ! 893: base = base->ip_destination; ! 894: } ! 895: ! 896: /* all ports in chain from dest to base, inclusive, are locked */ ! 897: ! 898: if (port == base) { ! 899: /* circularity detected! */ ! 900: ! 901: ipc_port_multiple_unlock(); ! 902: ! 903: /* port (== base) is in limbo */ ! 904: ! 905: assert(ip_active(port)); ! 906: assert(port->ip_receiver_name == MACH_PORT_NULL); ! 907: assert(port->ip_destination == IP_NULL); ! 908: ! 909: while (dest != IP_NULL) { ! 910: ipc_port_t next; ! 911: ! 912: /* dest is in transit or in limbo */ ! 913: ! 914: assert(ip_active(dest)); ! 915: assert(dest->ip_receiver_name == MACH_PORT_NULL); ! 916: ! 917: next = dest->ip_destination; ! 918: ip_unlock(dest); ! 919: dest = next; ! 920: } ! 921: ! 922: return TRUE; ! 923: } ! 924: ! 925: /* ! 926: * The guarantee: lock port while the entire chain is locked. ! 927: * Once port is locked, we can take a reference to dest, ! 928: * add port to the chain, and unlock everything. ! 929: */ ! 930: ! 931: ip_lock(port); ! 932: ipc_port_multiple_unlock(); ! 933: ! 934: not_circular: ! 935: ! 936: /* port is in limbo */ ! 937: ! 938: assert(ip_active(port)); ! 939: assert(port->ip_receiver_name == MACH_PORT_NULL); ! 940: assert(port->ip_destination == IP_NULL); ! 941: ! 942: ip_reference(dest); ! 943: port->ip_destination = dest; ! 944: ! 945: /* now unlock chain */ ! 946: ! 947: while (port != base) { ! 948: ipc_port_t next; ! 949: ! 950: /* port is in transit */ ! 951: ! 952: assert(ip_active(port)); ! 953: assert(port->ip_receiver_name == MACH_PORT_NULL); ! 954: assert(port->ip_destination != IP_NULL); ! 955: ! 956: next = port->ip_destination; ! 957: ip_unlock(port); ! 958: port = next; ! 959: } ! 960: ! 961: /* base is not in transit */ ! 962: ! 963: assert(!ip_active(base) || ! 964: (base->ip_receiver_name != MACH_PORT_NULL) || ! 965: (base->ip_destination == IP_NULL)); ! 966: ip_unlock(base); ! 967: ! 968: return FALSE; ! 969: } ! 970: ! 971: /* ! 972: * Routine: ipc_port_lookup_notify ! 973: * Purpose: ! 974: * Make a send-once notify port from a receive right. ! 975: * Returns IP_NULL if name doesn't denote a receive right. ! 976: * Conditions: ! 977: * The space must be locked (read or write) and active. ! 978: */ ! 979: ! 980: ipc_port_t ! 981: ipc_port_lookup_notify( ! 982: ipc_space_t space, ! 983: mach_port_t name) ! 984: { ! 985: ipc_port_t port; ! 986: ipc_entry_t entry; ! 987: ! 988: assert(space->is_active); ! 989: ! 990: entry = ipc_entry_lookup(space, name); ! 991: if (entry == IE_NULL) ! 992: return IP_NULL; ! 993: ! 994: if ((entry->ie_bits & MACH_PORT_TYPE_RECEIVE) == 0) ! 995: return IP_NULL; ! 996: ! 997: port = (ipc_port_t) entry->ie_object; ! 998: assert(port != IP_NULL); ! 999: ! 1000: ip_lock(port); ! 1001: assert(ip_active(port)); ! 1002: assert(port->ip_receiver_name == name); ! 1003: assert(port->ip_receiver == space); ! 1004: ! 1005: ip_reference(port); ! 1006: port->ip_sorights++; ! 1007: ip_unlock(port); ! 1008: ! 1009: return port; ! 1010: } ! 1011: ! 1012: /* ! 1013: * Routine: ipc_port_make_send ! 1014: * Purpose: ! 1015: * Make a naked send right from a receive right. ! 1016: * Conditions: ! 1017: * The port is not locked but it is active. ! 1018: */ ! 1019: ! 1020: ipc_port_t ! 1021: ipc_port_make_send( ! 1022: ipc_port_t port) ! 1023: { ! 1024: assert(IP_VALID(port)); ! 1025: ! 1026: ip_lock(port); ! 1027: assert(ip_active(port)); ! 1028: port->ip_mscount++; ! 1029: port->ip_srights++; ! 1030: ip_reference(port); ! 1031: ip_unlock(port); ! 1032: ! 1033: return port; ! 1034: } ! 1035: ! 1036: /* ! 1037: * Routine: ipc_port_copy_send ! 1038: * Purpose: ! 1039: * Make a naked send right from another naked send right. ! 1040: * IP_NULL -> IP_NULL ! 1041: * IP_DEAD -> IP_DEAD ! 1042: * dead port -> IP_DEAD ! 1043: * live port -> port + ref ! 1044: * Conditions: ! 1045: * Nothing locked except possibly a space. ! 1046: */ ! 1047: ! 1048: ipc_port_t ! 1049: ipc_port_copy_send( ! 1050: ipc_port_t port) ! 1051: { ! 1052: ipc_port_t sright; ! 1053: ! 1054: if (!IP_VALID(port)) ! 1055: return port; ! 1056: ! 1057: ip_lock(port); ! 1058: if (ip_active(port)) { ! 1059: assert(port->ip_srights > 0); ! 1060: ! 1061: ip_reference(port); ! 1062: port->ip_srights++; ! 1063: sright = port; ! 1064: } else ! 1065: sright = IP_DEAD; ! 1066: ip_unlock(port); ! 1067: ! 1068: return sright; ! 1069: } ! 1070: ! 1071: /* ! 1072: * Routine: ipc_port_copyout_send ! 1073: * Purpose: ! 1074: * Copyout a naked send right (possibly null/dead), ! 1075: * or if that fails, destroy the right. ! 1076: * Conditions: ! 1077: * Nothing locked. ! 1078: */ ! 1079: ! 1080: mach_port_t ! 1081: ipc_port_copyout_send( ! 1082: ipc_port_t sright, ! 1083: ipc_space_t space) ! 1084: { ! 1085: mach_port_t name; ! 1086: ! 1087: if (IP_VALID(sright)) { ! 1088: kern_return_t kr; ! 1089: ! 1090: kr = ipc_object_copyout(space, (ipc_object_t) sright, ! 1091: MACH_MSG_TYPE_PORT_SEND, TRUE, &name); ! 1092: if (kr != KERN_SUCCESS) { ! 1093: ipc_port_release_send(sright); ! 1094: ! 1095: if (kr == KERN_INVALID_CAPABILITY) ! 1096: name = MACH_PORT_DEAD; ! 1097: else ! 1098: name = MACH_PORT_NULL; ! 1099: } ! 1100: } else ! 1101: name = (mach_port_t) sright; ! 1102: ! 1103: return name; ! 1104: } ! 1105: ! 1106: /* ! 1107: * Routine: ipc_port_release_send ! 1108: * Purpose: ! 1109: * Release a (valid) naked send right. ! 1110: * Consumes a ref for the port. ! 1111: * Conditions: ! 1112: * Nothing locked. ! 1113: */ ! 1114: ! 1115: void ! 1116: ipc_port_release_send( ! 1117: ipc_port_t port) ! 1118: { ! 1119: ipc_port_t nsrequest = IP_NULL; ! 1120: mach_port_mscount_t mscount; ! 1121: ! 1122: assert(IP_VALID(port)); ! 1123: ! 1124: ip_lock(port); ! 1125: ip_release(port); ! 1126: ! 1127: if (!ip_active(port)) { ! 1128: ip_check_unlock(port); ! 1129: return; ! 1130: } ! 1131: ! 1132: assert(port->ip_srights > 0); ! 1133: ! 1134: if (--port->ip_srights == 0) { ! 1135: nsrequest = port->ip_nsrequest; ! 1136: if (nsrequest != IP_NULL) { ! 1137: port->ip_nsrequest = IP_NULL; ! 1138: mscount = port->ip_mscount; ! 1139: } ! 1140: } ! 1141: ! 1142: ip_unlock(port); ! 1143: ! 1144: if (nsrequest != IP_NULL) ! 1145: ipc_notify_no_senders(nsrequest, mscount); ! 1146: } ! 1147: ! 1148: /* ! 1149: * Routine: ipc_port_make_sonce ! 1150: * Purpose: ! 1151: * Make a naked send-once right from a receive right. ! 1152: * Conditions: ! 1153: * The port is not locked but it is active. ! 1154: */ ! 1155: ! 1156: ipc_port_t ! 1157: ipc_port_make_sonce( ! 1158: ipc_port_t port) ! 1159: { ! 1160: assert(IP_VALID(port)); ! 1161: ! 1162: ip_lock(port); ! 1163: assert(ip_active(port)); ! 1164: port->ip_sorights++; ! 1165: ip_reference(port); ! 1166: ip_unlock(port); ! 1167: ! 1168: return port; ! 1169: } ! 1170: ! 1171: /* ! 1172: * Routine: ipc_port_release_sonce ! 1173: * Purpose: ! 1174: * Release a naked send-once right. ! 1175: * Consumes a ref for the port. ! 1176: * ! 1177: * In normal situations, this is never used. ! 1178: * Send-once rights are only consumed when ! 1179: * a message (possibly a send-once notification) ! 1180: * is sent to them. ! 1181: * Conditions: ! 1182: * Nothing locked except possibly a space. ! 1183: */ ! 1184: ! 1185: void ! 1186: ipc_port_release_sonce( ! 1187: ipc_port_t port) ! 1188: { ! 1189: assert(IP_VALID(port)); ! 1190: ! 1191: ip_lock(port); ! 1192: ip_release(port); ! 1193: ! 1194: if (!ip_active(port)) { ! 1195: ip_check_unlock(port); ! 1196: return; ! 1197: } ! 1198: ! 1199: assert(port->ip_sorights > 0); ! 1200: ! 1201: port->ip_sorights--; ! 1202: ip_unlock(port); ! 1203: } ! 1204: ! 1205: /* ! 1206: * Routine: ipc_port_release_receive ! 1207: * Purpose: ! 1208: * Release a naked (in limbo or in transit) receive right. ! 1209: * Consumes a ref for the port; destroys the port. ! 1210: * Conditions: ! 1211: * Nothing locked. ! 1212: */ ! 1213: ! 1214: void ! 1215: ipc_port_release_receive( ! 1216: ipc_port_t port) ! 1217: { ! 1218: ipc_port_t dest; ! 1219: ! 1220: assert(IP_VALID(port)); ! 1221: ! 1222: ip_lock(port); ! 1223: assert(ip_active(port)); ! 1224: assert(port->ip_receiver_name == MACH_PORT_NULL); ! 1225: dest = port->ip_destination; ! 1226: ! 1227: ipc_port_destroy(port); /* consumes ref, unlocks */ ! 1228: ! 1229: if (dest != IP_NULL) ! 1230: ipc_port_release(dest); ! 1231: } ! 1232: ! 1233: /* ! 1234: * Routine: ipc_port_alloc_special ! 1235: * Purpose: ! 1236: * Allocate a port in a special space. ! 1237: * The new port is returned with one ref. ! 1238: * If unsuccessful, IP_NULL is returned. ! 1239: * Conditions: ! 1240: * Nothing locked. ! 1241: */ ! 1242: ! 1243: ipc_port_t ! 1244: ipc_port_alloc_special( ! 1245: ipc_space_t space) ! 1246: { ! 1247: ipc_port_t port; ! 1248: ! 1249: port = (ipc_port_t) io_alloc(IOT_PORT); ! 1250: if (port == IP_NULL) ! 1251: return IP_NULL; ! 1252: ! 1253: io_lock_init(&port->ip_object); ! 1254: port->ip_references = 1; ! 1255: port->ip_object.io_bits = io_makebits(TRUE, IOT_PORT, 0); ! 1256: ! 1257: /* ! 1258: * The actual values of ip_receiver_name aren't important, ! 1259: * as long as they are valid (not null/dead). ! 1260: */ ! 1261: ! 1262: ipc_port_init(port, space, 1); ! 1263: ! 1264: return port; ! 1265: } ! 1266: ! 1267: /* ! 1268: * Routine: ipc_port_dealloc_special ! 1269: * Purpose: ! 1270: * Deallocate a port in a special space. ! 1271: * Consumes one ref for the port. ! 1272: * Conditions: ! 1273: * Nothing locked. ! 1274: */ ! 1275: ! 1276: void ! 1277: ipc_port_dealloc_special( ! 1278: ipc_port_t port, ! 1279: ipc_space_t space) ! 1280: { ! 1281: ip_lock(port); ! 1282: assert(ip_active(port)); ! 1283: assert(port->ip_receiver_name != MACH_PORT_NULL); ! 1284: assert(port->ip_receiver == space); ! 1285: ! 1286: /* ! 1287: * We clear ip_receiver_name and ip_receiver to simplify ! 1288: * the ipc_space_kernel check in ipc_mqueue_send. ! 1289: */ ! 1290: ! 1291: port->ip_receiver_name = MACH_PORT_NULL; ! 1292: port->ip_receiver = IS_NULL; ! 1293: ! 1294: /* ! 1295: * For ipc_space_kernel, all ipc_port_clear_receiver does ! 1296: * is clean things up for the assertions in ipc_port_destroy. ! 1297: * For ipc_space_reply, there might be a waiting receiver. ! 1298: */ ! 1299: ! 1300: ipc_port_clear_receiver(port); ! 1301: ipc_port_destroy(port); ! 1302: } ! 1303: ! 1304: #if MACH_IPC_COMPAT ! 1305: ! 1306: /* ! 1307: * Routine: ipc_port_alloc_compat ! 1308: * Purpose: ! 1309: * Allocate a port. ! 1310: * Conditions: ! 1311: * Nothing locked. If successful, the port is returned ! 1312: * locked. (The caller doesn't have a reference.) ! 1313: * ! 1314: * Like ipc_port_alloc, except that the new entry ! 1315: * is IE_BITS_COMPAT. ! 1316: * Returns: ! 1317: * KERN_SUCCESS The port is allocated. ! 1318: * KERN_INVALID_TASK The space is dead. ! 1319: * KERN_NO_SPACE No room for an entry in the space. ! 1320: * KERN_RESOURCE_SHORTAGE Couldn't allocate memory. ! 1321: */ ! 1322: ! 1323: kern_return_t ! 1324: ipc_port_alloc_compat( ! 1325: ipc_space_t space, ! 1326: mach_port_t *namep, ! 1327: ipc_port_t *portp) ! 1328: { ! 1329: ipc_port_t port; ! 1330: ipc_entry_t entry; ! 1331: mach_port_t name; ! 1332: ipc_table_size_t its; ! 1333: ipc_port_request_t table; ! 1334: ipc_table_elems_t size; ! 1335: ipc_port_request_index_t free, i; ! 1336: kern_return_t kr; ! 1337: ! 1338: port = ip_alloc(); ! 1339: if (port == IP_NULL) ! 1340: return KERN_RESOURCE_SHORTAGE; ! 1341: ! 1342: its = &ipc_table_dnrequests[0]; ! 1343: table = it_dnrequests_alloc(its); ! 1344: if (table == IPR_NULL) { ! 1345: ip_free(port); ! 1346: return KERN_RESOURCE_SHORTAGE; ! 1347: } ! 1348: ! 1349: kr = ipc_entry_alloc(space, &name, &entry); ! 1350: if (kr != KERN_SUCCESS) { ! 1351: ip_free(port); ! 1352: it_dnrequests_free(its, table); ! 1353: return kr; ! 1354: } ! 1355: /* space is write-locked */ ! 1356: ! 1357: entry->ie_object = (ipc_object_t) port; ! 1358: entry->ie_request = 1; ! 1359: entry->ie_bits |= IE_BITS_COMPAT|MACH_PORT_TYPE_RECEIVE; ! 1360: ! 1361: ip_lock_init(port); ! 1362: ip_lock(port); ! 1363: is_write_unlock(space); ! 1364: ! 1365: port->ip_references = 1; /* for entry, not caller */ ! 1366: port->ip_bits = io_makebits(TRUE, IOT_PORT, 0); ! 1367: ! 1368: ipc_port_init(port, space, name); ! 1369: ! 1370: size = its->its_size; ! 1371: assert(size > 1); ! 1372: free = 0; ! 1373: ! 1374: for (i = 2; i < size; i++) { ! 1375: ipc_port_request_t ipr = &table[i]; ! 1376: ! 1377: ipr->ipr_name = MACH_PORT_NULL; ! 1378: ipr->ipr_next = free; ! 1379: free = i; ! 1380: } ! 1381: ! 1382: table->ipr_next = free; ! 1383: table->ipr_size = its; ! 1384: port->ip_dnrequests = table; ! 1385: ! 1386: table[1].ipr_name = name; ! 1387: table[1].ipr_soright = ipr_spacem(space); ! 1388: is_reference(space); ! 1389: ! 1390: *namep = name; ! 1391: *portp = port; ! 1392: return KERN_SUCCESS; ! 1393: } ! 1394: ! 1395: /* ! 1396: * Routine: ipc_port_copyout_send_compat ! 1397: * Purpose: ! 1398: * Copyout a naked send right (possibly null/dead), ! 1399: * or if that fails, destroy the right. ! 1400: * Like ipc_port_copyout_send, except that if a ! 1401: * new translation is created it has the compat bit. ! 1402: * Conditions: ! 1403: * Nothing locked. ! 1404: */ ! 1405: ! 1406: mach_port_t ! 1407: ipc_port_copyout_send_compat( ! 1408: ipc_port_t sright, ! 1409: ipc_space_t space) ! 1410: { ! 1411: mach_port_t name; ! 1412: ! 1413: if (IP_VALID(sright)) { ! 1414: kern_return_t kr; ! 1415: ! 1416: kr = ipc_object_copyout_compat(space, (ipc_object_t) sright, ! 1417: MACH_MSG_TYPE_PORT_SEND, &name); ! 1418: if (kr != KERN_SUCCESS) { ! 1419: ipc_port_release_send(sright); ! 1420: name = MACH_PORT_NULL; ! 1421: } ! 1422: } else ! 1423: name = (mach_port_t) sright; ! 1424: ! 1425: return name; ! 1426: } ! 1427: ! 1428: /* ! 1429: * Routine: ipc_port_copyout_receiver ! 1430: * Purpose: ! 1431: * Copyout a port reference (possibly null) ! 1432: * by giving the caller his name for the port, ! 1433: * if he is the receiver. ! 1434: * Conditions: ! 1435: * Nothing locked. Consumes a ref for the port. ! 1436: */ ! 1437: ! 1438: mach_port_t ! 1439: ipc_port_copyout_receiver( ! 1440: ipc_port_t port, ! 1441: ipc_space_t space) ! 1442: { ! 1443: mach_port_t name; ! 1444: ! 1445: if (!IP_VALID(port)) ! 1446: return MACH_PORT_NULL; ! 1447: ! 1448: ip_lock(port); ! 1449: if (port->ip_receiver == space) { ! 1450: name = port->ip_receiver_name; ! 1451: assert(MACH_PORT_VALID(name)); ! 1452: } else ! 1453: name = MACH_PORT_NULL; ! 1454: ! 1455: ip_release(port); ! 1456: ip_check_unlock(port); ! 1457: ! 1458: return name; ! 1459: } ! 1460: ! 1461: #endif /* MACH_IPC_COMPAT */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.