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