![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ipc_tt.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / OSKit-Mach / kern|
Return to ipc_tt.c CVS log | Up to [GnuMach] / OSKit-Mach / kern |
1.1 ! root 1: /* ! 2: * Mach Operating System ! 3: * Copyright (c) 1991,1990,1989,1988,1987 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_tt.c ! 28: * Purpose: ! 29: * Task and thread related IPC functions. ! 30: */ ! 31: ! 32: #include <mach_ipc_compat.h> ! 33: ! 34: #include <mach/boolean.h> ! 35: #include <mach/kern_return.h> ! 36: #include <mach/mach_param.h> ! 37: #include <mach/task_special_ports.h> ! 38: #include <mach/thread_special_ports.h> ! 39: #include <vm/vm_kern.h> ! 40: #include <kern/task.h> ! 41: #include <kern/thread.h> ! 42: #include <kern/ipc_kobject.h> ! 43: #include <kern/ipc_tt.h> ! 44: #include <ipc/ipc_space.h> ! 45: #include <ipc/ipc_table.h> ! 46: #include <ipc/ipc_port.h> ! 47: #include <ipc/ipc_right.h> ! 48: #include <ipc/ipc_entry.h> ! 49: #include <ipc/ipc_object.h> ! 50: ! 51: ! 52: ! 53: /* ! 54: * Routine: ipc_task_init ! 55: * Purpose: ! 56: * Initialize a task's IPC state. ! 57: * ! 58: * If non-null, some state will be inherited from the parent. ! 59: * The parent must be appropriately initialized. ! 60: * Conditions: ! 61: * Nothing locked. ! 62: */ ! 63: ! 64: void ! 65: ipc_task_init( ! 66: task_t task, ! 67: task_t parent) ! 68: { ! 69: ipc_space_t space; ! 70: ipc_port_t kport; ! 71: kern_return_t kr; ! 72: int i; ! 73: ! 74: ! 75: kr = ipc_space_create(&ipc_table_entries[0], &space); ! 76: if (kr != KERN_SUCCESS) ! 77: panic("ipc_task_init"); ! 78: ! 79: ! 80: kport = ipc_port_alloc_kernel(); ! 81: if (kport == IP_NULL) ! 82: panic("ipc_task_init"); ! 83: ! 84: itk_lock_init(task); ! 85: task->itk_self = kport; ! 86: task->itk_sself = ipc_port_make_send(kport); ! 87: task->itk_space = space; ! 88: ! 89: if (parent == TASK_NULL) { ! 90: task->itk_exception = IP_NULL; ! 91: task->itk_bootstrap = IP_NULL; ! 92: for (i = 0; i < TASK_PORT_REGISTER_MAX; i++) ! 93: task->itk_registered[i] = IP_NULL; ! 94: } else { ! 95: itk_lock(parent); ! 96: assert(parent->itk_self != IP_NULL); ! 97: ! 98: /* inherit registered ports */ ! 99: ! 100: for (i = 0; i < TASK_PORT_REGISTER_MAX; i++) ! 101: task->itk_registered[i] = ! 102: ipc_port_copy_send(parent->itk_registered[i]); ! 103: ! 104: /* inherit exception and bootstrap ports */ ! 105: ! 106: task->itk_exception = ! 107: ipc_port_copy_send(parent->itk_exception); ! 108: task->itk_bootstrap = ! 109: ipc_port_copy_send(parent->itk_bootstrap); ! 110: ! 111: itk_unlock(parent); ! 112: } ! 113: } ! 114: ! 115: /* ! 116: * Routine: ipc_task_enable ! 117: * Purpose: ! 118: * Enable a task for IPC access. ! 119: * Conditions: ! 120: * Nothing locked. ! 121: */ ! 122: ! 123: void ! 124: ipc_task_enable( ! 125: task_t task) ! 126: { ! 127: ipc_port_t kport; ! 128: ! 129: itk_lock(task); ! 130: kport = task->itk_self; ! 131: if (kport != IP_NULL) ! 132: ipc_kobject_set(kport, (ipc_kobject_t) task, IKOT_TASK); ! 133: itk_unlock(task); ! 134: } ! 135: ! 136: /* ! 137: * Routine: ipc_task_disable ! 138: * Purpose: ! 139: * Disable IPC access to a task. ! 140: * Conditions: ! 141: * Nothing locked. ! 142: */ ! 143: ! 144: void ! 145: ipc_task_disable( ! 146: task_t task) ! 147: { ! 148: ipc_port_t kport; ! 149: ! 150: itk_lock(task); ! 151: kport = task->itk_self; ! 152: if (kport != IP_NULL) ! 153: ipc_kobject_set(kport, IKO_NULL, IKOT_NONE); ! 154: itk_unlock(task); ! 155: } ! 156: ! 157: /* ! 158: * Routine: ipc_task_terminate ! 159: * Purpose: ! 160: * Clean up and destroy a task's IPC state. ! 161: * Conditions: ! 162: * Nothing locked. The task must be suspended. ! 163: * (Or the current thread must be in the task.) ! 164: */ ! 165: ! 166: void ! 167: ipc_task_terminate( ! 168: task_t task) ! 169: { ! 170: ipc_port_t kport; ! 171: int i; ! 172: ! 173: itk_lock(task); ! 174: kport = task->itk_self; ! 175: ! 176: if (kport == IP_NULL) { ! 177: /* the task is already terminated (can this happen?) */ ! 178: itk_unlock(task); ! 179: return; ! 180: } ! 181: ! 182: task->itk_self = IP_NULL; ! 183: itk_unlock(task); ! 184: ! 185: /* release the naked send rights */ ! 186: ! 187: if (IP_VALID(task->itk_sself)) ! 188: ipc_port_release_send(task->itk_sself); ! 189: if (IP_VALID(task->itk_exception)) ! 190: ipc_port_release_send(task->itk_exception); ! 191: if (IP_VALID(task->itk_bootstrap)) ! 192: ipc_port_release_send(task->itk_bootstrap); ! 193: ! 194: for (i = 0; i < TASK_PORT_REGISTER_MAX; i++) ! 195: if (IP_VALID(task->itk_registered[i])) ! 196: ipc_port_release_send(task->itk_registered[i]); ! 197: ! 198: /* destroy the space, leaving just a reference for it */ ! 199: ! 200: ipc_space_destroy(task->itk_space); ! 201: ! 202: /* destroy the kernel port */ ! 203: ! 204: ipc_port_dealloc_kernel(kport); ! 205: } ! 206: ! 207: /* ! 208: * Routine: ipc_thread_init ! 209: * Purpose: ! 210: * Initialize a thread's IPC state. ! 211: * Conditions: ! 212: * Nothing locked. ! 213: */ ! 214: ! 215: void ! 216: ipc_thread_init(thread) ! 217: thread_t thread; ! 218: { ! 219: ipc_port_t kport; ! 220: ! 221: kport = ipc_port_alloc_kernel(); ! 222: if (kport == IP_NULL) ! 223: panic("ipc_thread_init"); ! 224: ! 225: ipc_thread_links_init(thread); ! 226: ipc_kmsg_queue_init(&thread->ith_messages); ! 227: ! 228: ith_lock_init(thread); ! 229: thread->ith_self = kport; ! 230: thread->ith_sself = ipc_port_make_send(kport); ! 231: thread->ith_exception = IP_NULL; ! 232: ! 233: thread->ith_mig_reply = MACH_PORT_NULL; ! 234: thread->ith_rpc_reply = IP_NULL; ! 235: ! 236: #if MACH_IPC_COMPAT ! 237: { ! 238: ipc_space_t space = thread->task->itk_space; ! 239: ipc_port_t port; ! 240: mach_port_t name; ! 241: kern_return_t kr; ! 242: ! 243: kr = ipc_port_alloc_compat(space, &name, &port); ! 244: if (kr != KERN_SUCCESS) ! 245: panic("ipc_thread_init"); ! 246: /* port is locked and active */ ! 247: ! 248: /* ! 249: * Now we have a reply port. We need to make a naked ! 250: * send right to stash in ith_reply. We can't use ! 251: * ipc_port_make_send, because we can't unlock the port ! 252: * before making the right. Also we don't want to ! 253: * increment ip_mscount. The net effect of all this ! 254: * is the same as doing ! 255: * ipc_port_alloc_kernel get the port ! 256: * ipc_port_make_send make the send right ! 257: * ipc_object_copyin_from_kernel grab receive right ! 258: * ipc_object_copyout_compat and give to user ! 259: */ ! 260: ! 261: port->ip_srights++; ! 262: ip_reference(port); ! 263: ip_unlock(port); ! 264: ! 265: thread->ith_reply = port; ! 266: } ! 267: #endif /* MACH_IPC_COMPAT */ ! 268: } ! 269: ! 270: /* ! 271: * Routine: ipc_thread_enable ! 272: * Purpose: ! 273: * Enable a thread for IPC access. ! 274: * Conditions: ! 275: * Nothing locked. ! 276: */ ! 277: ! 278: void ! 279: ipc_thread_enable(thread) ! 280: thread_t thread; ! 281: { ! 282: ipc_port_t kport; ! 283: ! 284: ith_lock(thread); ! 285: kport = thread->ith_self; ! 286: if (kport != IP_NULL) ! 287: ipc_kobject_set(kport, (ipc_kobject_t) thread, IKOT_THREAD); ! 288: ith_unlock(thread); ! 289: } ! 290: ! 291: /* ! 292: * Routine: ipc_thread_disable ! 293: * Purpose: ! 294: * Disable IPC access to a thread. ! 295: * Conditions: ! 296: * Nothing locked. ! 297: */ ! 298: ! 299: void ! 300: ipc_thread_disable(thread) ! 301: thread_t thread; ! 302: { ! 303: ipc_port_t kport; ! 304: ! 305: ith_lock(thread); ! 306: kport = thread->ith_self; ! 307: if (kport != IP_NULL) ! 308: ipc_kobject_set(kport, IKO_NULL, IKOT_NONE); ! 309: ith_unlock(thread); ! 310: } ! 311: ! 312: /* ! 313: * Routine: ipc_thread_terminate ! 314: * Purpose: ! 315: * Clean up and destroy a thread's IPC state. ! 316: * Conditions: ! 317: * Nothing locked. The thread must be suspended. ! 318: * (Or be the current thread.) ! 319: */ ! 320: ! 321: void ! 322: ipc_thread_terminate(thread) ! 323: thread_t thread; ! 324: { ! 325: ipc_port_t kport; ! 326: ! 327: ith_lock(thread); ! 328: kport = thread->ith_self; ! 329: ! 330: if (kport == IP_NULL) { ! 331: /* the thread is already terminated (can this happen?) */ ! 332: ith_unlock(thread); ! 333: return; ! 334: } ! 335: ! 336: thread->ith_self = IP_NULL; ! 337: ith_unlock(thread); ! 338: ! 339: assert(ipc_kmsg_queue_empty(&thread->ith_messages)); ! 340: ! 341: /* release the naked send rights */ ! 342: ! 343: if (IP_VALID(thread->ith_sself)) ! 344: ipc_port_release_send(thread->ith_sself); ! 345: if (IP_VALID(thread->ith_exception)) ! 346: ipc_port_release_send(thread->ith_exception); ! 347: ! 348: #if MACH_IPC_COMPAT ! 349: if (IP_VALID(thread->ith_reply)) { ! 350: ipc_space_t space = thread->task->itk_space; ! 351: ipc_port_t port = thread->ith_reply; ! 352: ipc_entry_t entry; ! 353: mach_port_t name; ! 354: ! 355: /* destroy any rights the task may have for the port */ ! 356: ! 357: is_write_lock(space); ! 358: if (space->is_active && ! 359: ipc_right_reverse(space, (ipc_object_t) port, ! 360: &name, &entry)) { ! 361: /* reply port is locked and active */ ! 362: ip_unlock(port); ! 363: ! 364: (void) ipc_right_destroy(space, name, entry); ! 365: /* space is unlocked */ ! 366: } else ! 367: is_write_unlock(space); ! 368: ! 369: ipc_port_release_send(port); ! 370: } ! 371: ! 372: /* ! 373: * Note we do *not* destroy any rights the space may have ! 374: * for the thread's kernel port. The old IPC code did this, ! 375: * to avoid generating a notification when the port is ! 376: * destroyed. However, this isn't a good idea when ! 377: * the kernel port is interposed, because then it doesn't ! 378: * happen, exposing the interposition to the task. ! 379: * Because we don't need the efficiency hack, I flushed ! 380: * this behaviour, introducing a small incompatibility ! 381: * with the old IPC code. ! 382: */ ! 383: #endif /* MACH_IPC_COMPAT */ ! 384: ! 385: /* destroy the kernel port */ ! 386: ! 387: ipc_port_dealloc_kernel(kport); ! 388: } ! 389: ! 390: #if 0 ! 391: /* ! 392: * Routine: retrieve_task_self ! 393: * Purpose: ! 394: * Return a send right (possibly null/dead) ! 395: * for the task's user-visible self port. ! 396: * Conditions: ! 397: * Nothing locked. ! 398: */ ! 399: ! 400: ipc_port_t ! 401: retrieve_task_self(task) ! 402: task_t task; ! 403: { ! 404: ipc_port_t port; ! 405: ! 406: assert(task != TASK_NULL); ! 407: ! 408: itk_lock(task); ! 409: if (task->itk_self != IP_NULL) ! 410: port = ipc_port_copy_send(task->itk_sself); ! 411: else ! 412: port = IP_NULL; ! 413: itk_unlock(task); ! 414: ! 415: return port; ! 416: } ! 417: ! 418: /* ! 419: * Routine: retrieve_thread_self ! 420: * Purpose: ! 421: * Return a send right (possibly null/dead) ! 422: * for the thread's user-visible self port. ! 423: * Conditions: ! 424: * Nothing locked. ! 425: */ ! 426: ! 427: ipc_port_t ! 428: retrieve_thread_self(thread) ! 429: thread_t thread; ! 430: { ! 431: ipc_port_t port; ! 432: ! 433: assert(thread != ITH_NULL); ! 434: ! 435: ith_lock(thread); ! 436: if (thread->ith_self != IP_NULL) ! 437: port = ipc_port_copy_send(thread->ith_sself); ! 438: else ! 439: port = IP_NULL; ! 440: ith_unlock(thread); ! 441: ! 442: return port; ! 443: } ! 444: #endif /* 0 */ ! 445: ! 446: /* ! 447: * Routine: retrieve_task_self_fast ! 448: * Purpose: ! 449: * Optimized version of retrieve_task_self, ! 450: * that only works for the current task. ! 451: * ! 452: * Return a send right (possibly null/dead) ! 453: * for the task's user-visible self port. ! 454: * Conditions: ! 455: * Nothing locked. ! 456: */ ! 457: ! 458: ipc_port_t ! 459: retrieve_task_self_fast( ! 460: register task_t task) ! 461: { ! 462: register ipc_port_t port; ! 463: ! 464: assert(task == current_task()); ! 465: ! 466: itk_lock(task); ! 467: assert(task->itk_self != IP_NULL); ! 468: ! 469: if ((port = task->itk_sself) == task->itk_self) { ! 470: /* no interposing */ ! 471: ! 472: ip_lock(port); ! 473: assert(ip_active(port)); ! 474: ip_reference(port); ! 475: port->ip_srights++; ! 476: ip_unlock(port); ! 477: } else ! 478: port = ipc_port_copy_send(port); ! 479: itk_unlock(task); ! 480: ! 481: return port; ! 482: } ! 483: ! 484: /* ! 485: * Routine: retrieve_thread_self_fast ! 486: * Purpose: ! 487: * Optimized version of retrieve_thread_self, ! 488: * that only works for the current thread. ! 489: * ! 490: * Return a send right (possibly null/dead) ! 491: * for the thread's user-visible self port. ! 492: * Conditions: ! 493: * Nothing locked. ! 494: */ ! 495: ! 496: ipc_port_t ! 497: retrieve_thread_self_fast(thread) ! 498: register thread_t thread; ! 499: { ! 500: register ipc_port_t port; ! 501: ! 502: assert(thread == current_thread()); ! 503: ! 504: ith_lock(thread); ! 505: assert(thread->ith_self != IP_NULL); ! 506: ! 507: if ((port = thread->ith_sself) == thread->ith_self) { ! 508: /* no interposing */ ! 509: ! 510: ip_lock(port); ! 511: assert(ip_active(port)); ! 512: ip_reference(port); ! 513: port->ip_srights++; ! 514: ip_unlock(port); ! 515: } else ! 516: port = ipc_port_copy_send(port); ! 517: ith_unlock(thread); ! 518: ! 519: return port; ! 520: } ! 521: ! 522: #if 0 ! 523: /* ! 524: * Routine: retrieve_task_exception ! 525: * Purpose: ! 526: * Return a send right (possibly null/dead) ! 527: * for the task's exception port. ! 528: * Conditions: ! 529: * Nothing locked. ! 530: */ ! 531: ! 532: ipc_port_t ! 533: retrieve_task_exception(task) ! 534: task_t task; ! 535: { ! 536: ipc_port_t port; ! 537: ! 538: assert(task != TASK_NULL); ! 539: ! 540: itk_lock(task); ! 541: if (task->itk_self != IP_NULL) ! 542: port = ipc_port_copy_send(task->itk_exception); ! 543: else ! 544: port = IP_NULL; ! 545: itk_unlock(task); ! 546: ! 547: return port; ! 548: } ! 549: ! 550: /* ! 551: * Routine: retrieve_thread_exception ! 552: * Purpose: ! 553: * Return a send right (possibly null/dead) ! 554: * for the thread's exception port. ! 555: * Conditions: ! 556: * Nothing locked. ! 557: */ ! 558: ! 559: ipc_port_t ! 560: retrieve_thread_exception(thread) ! 561: thread_t thread; ! 562: { ! 563: ipc_port_t port; ! 564: ! 565: assert(thread != ITH_NULL); ! 566: ! 567: ith_lock(thread); ! 568: if (thread->ith_self != IP_NULL) ! 569: port = ipc_port_copy_send(thread->ith_exception); ! 570: else ! 571: port = IP_NULL; ! 572: ith_unlock(thread); ! 573: ! 574: return port; ! 575: } ! 576: #endif /* 0 */ ! 577: ! 578: /* ! 579: * Routine: mach_task_self [mach trap] ! 580: * Purpose: ! 581: * Give the caller send rights for his own task port. ! 582: * Conditions: ! 583: * Nothing locked. ! 584: * Returns: ! 585: * MACH_PORT_NULL if there are any resource failures ! 586: * or other errors. ! 587: */ ! 588: ! 589: mach_port_t ! 590: mach_task_self(void) ! 591: { ! 592: task_t task = current_task(); ! 593: ipc_port_t sright; ! 594: ! 595: sright = retrieve_task_self_fast(task); ! 596: return ipc_port_copyout_send(sright, task->itk_space); ! 597: } ! 598: ! 599: /* ! 600: * Routine: mach_thread_self [mach trap] ! 601: * Purpose: ! 602: * Give the caller send rights for his own thread port. ! 603: * Conditions: ! 604: * Nothing locked. ! 605: * Returns: ! 606: * MACH_PORT_NULL if there are any resource failures ! 607: * or other errors. ! 608: */ ! 609: ! 610: mach_port_t ! 611: mach_thread_self() ! 612: { ! 613: thread_t thread = current_thread(); ! 614: task_t task = thread->task; ! 615: ipc_port_t sright; ! 616: ! 617: sright = retrieve_thread_self_fast(thread); ! 618: return ipc_port_copyout_send(sright, task->itk_space); ! 619: } ! 620: ! 621: /* ! 622: * Routine: mach_reply_port [mach trap] ! 623: * Purpose: ! 624: * Allocate a port for the caller. ! 625: * Conditions: ! 626: * Nothing locked. ! 627: * Returns: ! 628: * MACH_PORT_NULL if there are any resource failures ! 629: * or other errors. ! 630: */ ! 631: ! 632: mach_port_t ! 633: mach_reply_port(void) ! 634: { ! 635: ipc_port_t port; ! 636: mach_port_t name; ! 637: kern_return_t kr; ! 638: ! 639: kr = ipc_port_alloc(current_task()->itk_space, &name, &port); ! 640: if (kr == KERN_SUCCESS) ! 641: ip_unlock(port); ! 642: else ! 643: name = MACH_PORT_NULL; ! 644: ! 645: return name; ! 646: } ! 647: ! 648: #if MACH_IPC_COMPAT ! 649: ! 650: /* ! 651: * Routine: retrieve_task_notify ! 652: * Purpose: ! 653: * Return a reference (or null) for ! 654: * the task's notify port. ! 655: * Conditions: ! 656: * Nothing locked. ! 657: */ ! 658: ! 659: ipc_port_t ! 660: retrieve_task_notify(task) ! 661: task_t task; ! 662: { ! 663: ipc_space_t space = task->itk_space; ! 664: ipc_port_t port; ! 665: ! 666: is_read_lock(space); ! 667: if (space->is_active) { ! 668: port = space->is_notify; ! 669: if (IP_VALID(port)) ! 670: ipc_port_reference(port); ! 671: } else ! 672: port = IP_NULL; ! 673: is_read_unlock(space); ! 674: ! 675: return port; ! 676: } ! 677: ! 678: /* ! 679: * Routine: retrieve_thread_reply ! 680: * Purpose: ! 681: * Return a reference (or null) for ! 682: * the thread's reply port. ! 683: * Conditions: ! 684: * Nothing locked. ! 685: */ ! 686: ! 687: ipc_port_t ! 688: retrieve_thread_reply(thread) ! 689: thread_t thread; ! 690: { ! 691: ipc_port_t port; ! 692: ! 693: ith_lock(thread); ! 694: if (thread->ith_self != IP_NULL) { ! 695: port = thread->ith_reply; ! 696: if (IP_VALID(port)) ! 697: ipc_port_reference(port); ! 698: } else ! 699: port = IP_NULL; ! 700: ith_unlock(thread); ! 701: ! 702: return port; ! 703: } ! 704: ! 705: /* ! 706: * Routine: task_self [mach trap] ! 707: * Purpose: ! 708: * Give the caller send rights for his task port. ! 709: * If new, the send right is marked with IE_BITS_COMPAT. ! 710: * Conditions: ! 711: * Nothing locked. ! 712: * Returns: ! 713: * MACH_PORT_NULL if there are any resource failures ! 714: * or other errors. ! 715: */ ! 716: ! 717: port_name_t ! 718: task_self() ! 719: { ! 720: task_t task = current_task(); ! 721: ipc_port_t sright; ! 722: mach_port_t name; ! 723: ! 724: sright = retrieve_task_self_fast(task); ! 725: name = ipc_port_copyout_send_compat(sright, task->itk_space); ! 726: return (port_name_t) name; ! 727: } ! 728: ! 729: /* ! 730: * Routine: task_notify [mach trap] ! 731: * Purpose: ! 732: * Give the caller the name of his own notify port. ! 733: * Conditions: ! 734: * Nothing locked. ! 735: * Returns: ! 736: * MACH_PORT_NULL if there isn't a notify port, ! 737: * if it is dead, or if the caller doesn't hold ! 738: * receive rights for it. ! 739: */ ! 740: ! 741: port_name_t ! 742: task_notify() ! 743: { ! 744: task_t task = current_task(); ! 745: ipc_port_t notify; ! 746: mach_port_t name; ! 747: ! 748: notify = retrieve_task_notify(task); ! 749: name = ipc_port_copyout_receiver(notify, task->itk_space); ! 750: return (port_name_t) name; ! 751: } ! 752: ! 753: /* ! 754: * Routine: thread_self [mach trap] ! 755: * Purpose: ! 756: * Give the caller send rights for his own thread port. ! 757: * If new, the send right is marked with IE_BITS_COMPAT. ! 758: * Conditions: ! 759: * Nothing locked. ! 760: * Returns: ! 761: * MACH_PORT_NULL if there are any resource failures ! 762: * or other errors. ! 763: */ ! 764: ! 765: port_name_t ! 766: thread_self() ! 767: { ! 768: thread_t thread = current_thread(); ! 769: task_t task = thread->task; ! 770: ipc_port_t sright; ! 771: mach_port_t name; ! 772: ! 773: sright = retrieve_thread_self_fast(thread); ! 774: name = ipc_port_copyout_send_compat(sright, task->itk_space); ! 775: return (port_name_t) name; ! 776: } ! 777: ! 778: /* ! 779: * Routine: thread_reply [mach trap] ! 780: * Purpose: ! 781: * Give the caller the name of his own reply port. ! 782: * Conditions: ! 783: * Nothing locked. ! 784: * Returns: ! 785: * MACH_PORT_NULL if there isn't a reply port, ! 786: * if it is dead, or if the caller doesn't hold ! 787: * receive rights for it. ! 788: */ ! 789: ! 790: port_name_t ! 791: thread_reply() ! 792: { ! 793: task_t task = current_task(); ! 794: thread_t thread = current_thread(); ! 795: ipc_port_t reply; ! 796: mach_port_t name; ! 797: ! 798: reply = retrieve_thread_reply(thread); ! 799: name = ipc_port_copyout_receiver(reply, task->itk_space); ! 800: return (port_name_t) name; ! 801: } ! 802: ! 803: #endif /* MACH_IPC_COMPAT */ ! 804: ! 805: /* ! 806: * Routine: task_get_special_port [kernel call] ! 807: * Purpose: ! 808: * Clones a send right for one of the task's ! 809: * special ports. ! 810: * Conditions: ! 811: * Nothing locked. ! 812: * Returns: ! 813: * KERN_SUCCESS Extracted a send right. ! 814: * KERN_INVALID_ARGUMENT The task is null. ! 815: * KERN_FAILURE The task/space is dead. ! 816: * KERN_INVALID_ARGUMENT Invalid special port. ! 817: */ ! 818: ! 819: kern_return_t ! 820: task_get_special_port( ! 821: task_t task, ! 822: int which, ! 823: ipc_port_t *portp) ! 824: { ! 825: ipc_port_t *whichp; ! 826: ipc_port_t port; ! 827: ! 828: if (task == TASK_NULL) ! 829: return KERN_INVALID_ARGUMENT; ! 830: ! 831: switch (which) { ! 832: #if MACH_IPC_COMPAT ! 833: case TASK_NOTIFY_PORT: { ! 834: ipc_space_t space = task->itk_space; ! 835: ! 836: is_read_lock(space); ! 837: if (!space->is_active) { ! 838: is_read_unlock(space); ! 839: return KERN_FAILURE; ! 840: } ! 841: ! 842: port = ipc_port_copy_send(space->is_notify); ! 843: is_read_unlock(space); ! 844: ! 845: *portp = port; ! 846: return KERN_SUCCESS; ! 847: } ! 848: #endif /* MACH_IPC_COMPAT */ ! 849: ! 850: case TASK_KERNEL_PORT: ! 851: whichp = &task->itk_sself; ! 852: break; ! 853: ! 854: case TASK_EXCEPTION_PORT: ! 855: whichp = &task->itk_exception; ! 856: break; ! 857: ! 858: case TASK_BOOTSTRAP_PORT: ! 859: whichp = &task->itk_bootstrap; ! 860: break; ! 861: ! 862: default: ! 863: return KERN_INVALID_ARGUMENT; ! 864: } ! 865: ! 866: itk_lock(task); ! 867: if (task->itk_self == IP_NULL) { ! 868: itk_unlock(task); ! 869: return KERN_FAILURE; ! 870: } ! 871: ! 872: port = ipc_port_copy_send(*whichp); ! 873: itk_unlock(task); ! 874: ! 875: *portp = port; ! 876: return KERN_SUCCESS; ! 877: } ! 878: ! 879: /* ! 880: * Routine: task_set_special_port [kernel call] ! 881: * Purpose: ! 882: * Changes one of the task's special ports, ! 883: * setting it to the supplied send right. ! 884: * Conditions: ! 885: * Nothing locked. If successful, consumes ! 886: * the supplied send right. ! 887: * Returns: ! 888: * KERN_SUCCESS Changed the special port. ! 889: * KERN_INVALID_ARGUMENT The task is null. ! 890: * KERN_FAILURE The task/space is dead. ! 891: * KERN_INVALID_ARGUMENT Invalid special port. ! 892: */ ! 893: ! 894: kern_return_t ! 895: task_set_special_port( ! 896: task_t task, ! 897: int which, ! 898: ipc_port_t port) ! 899: { ! 900: ipc_port_t *whichp; ! 901: ipc_port_t old; ! 902: ! 903: if (task == TASK_NULL) ! 904: return KERN_INVALID_ARGUMENT; ! 905: ! 906: switch (which) { ! 907: #if MACH_IPC_COMPAT ! 908: case TASK_NOTIFY_PORT: { ! 909: ipc_space_t space = task->itk_space; ! 910: ! 911: is_write_lock(space); ! 912: if (!space->is_active) { ! 913: is_write_unlock(space); ! 914: return KERN_FAILURE; ! 915: } ! 916: ! 917: old = space->is_notify; ! 918: space->is_notify = port; ! 919: is_write_unlock(space); ! 920: ! 921: if (IP_VALID(old)) ! 922: ipc_port_release_send(old); ! 923: return KERN_SUCCESS; ! 924: } ! 925: #endif /* MACH_IPC_COMPAT */ ! 926: ! 927: case TASK_KERNEL_PORT: ! 928: whichp = &task->itk_sself; ! 929: break; ! 930: ! 931: case TASK_EXCEPTION_PORT: ! 932: whichp = &task->itk_exception; ! 933: break; ! 934: ! 935: case TASK_BOOTSTRAP_PORT: ! 936: whichp = &task->itk_bootstrap; ! 937: break; ! 938: ! 939: default: ! 940: return KERN_INVALID_ARGUMENT; ! 941: } ! 942: ! 943: itk_lock(task); ! 944: if (task->itk_self == IP_NULL) { ! 945: itk_unlock(task); ! 946: return KERN_FAILURE; ! 947: } ! 948: ! 949: old = *whichp; ! 950: *whichp = port; ! 951: itk_unlock(task); ! 952: ! 953: if (IP_VALID(old)) ! 954: ipc_port_release_send(old); ! 955: return KERN_SUCCESS; ! 956: } ! 957: ! 958: /* ! 959: * Routine: thread_get_special_port [kernel call] ! 960: * Purpose: ! 961: * Clones a send right for one of the thread's ! 962: * special ports. ! 963: * Conditions: ! 964: * Nothing locked. ! 965: * Returns: ! 966: * KERN_SUCCESS Extracted a send right. ! 967: * KERN_INVALID_ARGUMENT The thread is null. ! 968: * KERN_FAILURE The thread is dead. ! 969: * KERN_INVALID_ARGUMENT Invalid special port. ! 970: */ ! 971: ! 972: kern_return_t ! 973: thread_get_special_port(thread, which, portp) ! 974: thread_t thread; ! 975: int which; ! 976: ipc_port_t *portp; ! 977: { ! 978: ipc_port_t *whichp; ! 979: ipc_port_t port; ! 980: ! 981: if (thread == ITH_NULL) ! 982: return KERN_INVALID_ARGUMENT; ! 983: ! 984: switch (which) { ! 985: #if MACH_IPC_COMPAT ! 986: case THREAD_REPLY_PORT: ! 987: whichp = &thread->ith_reply; ! 988: break; ! 989: #endif /* MACH_IPC_COMPAT */ ! 990: ! 991: case THREAD_KERNEL_PORT: ! 992: whichp = &thread->ith_sself; ! 993: break; ! 994: ! 995: case THREAD_EXCEPTION_PORT: ! 996: whichp = &thread->ith_exception; ! 997: break; ! 998: ! 999: default: ! 1000: return KERN_INVALID_ARGUMENT; ! 1001: } ! 1002: ! 1003: ith_lock(thread); ! 1004: if (thread->ith_self == IP_NULL) { ! 1005: ith_unlock(thread); ! 1006: return KERN_FAILURE; ! 1007: } ! 1008: ! 1009: port = ipc_port_copy_send(*whichp); ! 1010: ith_unlock(thread); ! 1011: ! 1012: *portp = port; ! 1013: return KERN_SUCCESS; ! 1014: } ! 1015: ! 1016: /* ! 1017: * Routine: thread_set_special_port [kernel call] ! 1018: * Purpose: ! 1019: * Changes one of the thread's special ports, ! 1020: * setting it to the supplied send right. ! 1021: * Conditions: ! 1022: * Nothing locked. If successful, consumes ! 1023: * the supplied send right. ! 1024: * Returns: ! 1025: * KERN_SUCCESS Changed the special port. ! 1026: * KERN_INVALID_ARGUMENT The thread is null. ! 1027: * KERN_FAILURE The thread is dead. ! 1028: * KERN_INVALID_ARGUMENT Invalid special port. ! 1029: */ ! 1030: ! 1031: kern_return_t ! 1032: thread_set_special_port(thread, which, port) ! 1033: thread_t thread; ! 1034: int which; ! 1035: ipc_port_t port; ! 1036: { ! 1037: ipc_port_t *whichp; ! 1038: ipc_port_t old; ! 1039: ! 1040: if (thread == ITH_NULL) ! 1041: return KERN_INVALID_ARGUMENT; ! 1042: ! 1043: switch (which) { ! 1044: #if MACH_IPC_COMPAT ! 1045: case THREAD_REPLY_PORT: ! 1046: whichp = &thread->ith_reply; ! 1047: break; ! 1048: #endif /* MACH_IPC_COMPAT */ ! 1049: ! 1050: case THREAD_KERNEL_PORT: ! 1051: whichp = &thread->ith_sself; ! 1052: break; ! 1053: ! 1054: case THREAD_EXCEPTION_PORT: ! 1055: whichp = &thread->ith_exception; ! 1056: break; ! 1057: ! 1058: default: ! 1059: return KERN_INVALID_ARGUMENT; ! 1060: } ! 1061: ! 1062: ith_lock(thread); ! 1063: if (thread->ith_self == IP_NULL) { ! 1064: ith_unlock(thread); ! 1065: return KERN_FAILURE; ! 1066: } ! 1067: ! 1068: old = *whichp; ! 1069: *whichp = port; ! 1070: ith_unlock(thread); ! 1071: ! 1072: if (IP_VALID(old)) ! 1073: ipc_port_release_send(old); ! 1074: return KERN_SUCCESS; ! 1075: } ! 1076: ! 1077: /* ! 1078: * Routine: mach_ports_register [kernel call] ! 1079: * Purpose: ! 1080: * Stash a handful of port send rights in the task. ! 1081: * Child tasks will inherit these rights, but they ! 1082: * must use mach_ports_lookup to acquire them. ! 1083: * ! 1084: * The rights are supplied in a (wired) kalloc'd segment. ! 1085: * Rights which aren't supplied are assumed to be null. ! 1086: * Conditions: ! 1087: * Nothing locked. If successful, consumes ! 1088: * the supplied rights and memory. ! 1089: * Returns: ! 1090: * KERN_SUCCESS Stashed the port rights. ! 1091: * KERN_INVALID_ARGUMENT The task is null. ! 1092: * KERN_INVALID_ARGUMENT The task is dead. ! 1093: * KERN_INVALID_ARGUMENT Too many port rights supplied. ! 1094: */ ! 1095: ! 1096: kern_return_t ! 1097: mach_ports_register( ! 1098: task_t task, ! 1099: mach_port_array_t memory, ! 1100: mach_msg_type_number_t portsCnt) ! 1101: { ! 1102: ipc_port_t ports[TASK_PORT_REGISTER_MAX]; ! 1103: int i; ! 1104: ! 1105: if ((task == TASK_NULL) || ! 1106: (portsCnt > TASK_PORT_REGISTER_MAX)) ! 1107: return KERN_INVALID_ARGUMENT; ! 1108: ! 1109: /* ! 1110: * Pad the port rights with nulls. ! 1111: */ ! 1112: ! 1113: for (i = 0; i < portsCnt; i++) ! 1114: ports[i] = (ipc_port_t) memory[i]; ! 1115: for (; i < TASK_PORT_REGISTER_MAX; i++) ! 1116: ports[i] = IP_NULL; ! 1117: ! 1118: itk_lock(task); ! 1119: if (task->itk_self == IP_NULL) { ! 1120: itk_unlock(task); ! 1121: return KERN_INVALID_ARGUMENT; ! 1122: } ! 1123: ! 1124: /* ! 1125: * Replace the old send rights with the new. ! 1126: * Release the old rights after unlocking. ! 1127: */ ! 1128: ! 1129: for (i = 0; i < TASK_PORT_REGISTER_MAX; i++) { ! 1130: ipc_port_t old; ! 1131: ! 1132: old = task->itk_registered[i]; ! 1133: task->itk_registered[i] = ports[i]; ! 1134: ports[i] = old; ! 1135: } ! 1136: ! 1137: itk_unlock(task); ! 1138: ! 1139: for (i = 0; i < TASK_PORT_REGISTER_MAX; i++) ! 1140: if (IP_VALID(ports[i])) ! 1141: ipc_port_release_send(ports[i]); ! 1142: ! 1143: /* ! 1144: * Now that the operation is known to be successful, ! 1145: * we can free the memory. ! 1146: */ ! 1147: ! 1148: if (portsCnt != 0) ! 1149: kfree((vm_offset_t) memory, ! 1150: (vm_size_t) (portsCnt * sizeof(mach_port_t))); ! 1151: ! 1152: return KERN_SUCCESS; ! 1153: } ! 1154: ! 1155: /* ! 1156: * Routine: mach_ports_lookup [kernel call] ! 1157: * Purpose: ! 1158: * Retrieves (clones) the stashed port send rights. ! 1159: * Conditions: ! 1160: * Nothing locked. If successful, the caller gets ! 1161: * rights and memory. ! 1162: * Returns: ! 1163: * KERN_SUCCESS Retrieved the send rights. ! 1164: * KERN_INVALID_ARGUMENT The task is null. ! 1165: * KERN_INVALID_ARGUMENT The task is dead. ! 1166: * KERN_RESOURCE_SHORTAGE Couldn't allocate memory. ! 1167: */ ! 1168: ! 1169: kern_return_t ! 1170: mach_ports_lookup(task, portsp, portsCnt) ! 1171: task_t task; ! 1172: ipc_port_t **portsp; ! 1173: mach_msg_type_number_t *portsCnt; ! 1174: { ! 1175: vm_offset_t memory; ! 1176: vm_size_t size; ! 1177: ipc_port_t *ports; ! 1178: int i; ! 1179: ! 1180: if (task == TASK_NULL) ! 1181: return KERN_INVALID_ARGUMENT; ! 1182: ! 1183: size = (vm_size_t) (TASK_PORT_REGISTER_MAX * sizeof(ipc_port_t)); ! 1184: ! 1185: memory = kalloc(size); ! 1186: if (memory == 0) ! 1187: return KERN_RESOURCE_SHORTAGE; ! 1188: ! 1189: itk_lock(task); ! 1190: if (task->itk_self == IP_NULL) { ! 1191: itk_unlock(task); ! 1192: ! 1193: kfree(memory, size); ! 1194: return KERN_INVALID_ARGUMENT; ! 1195: } ! 1196: ! 1197: ports = (ipc_port_t *) memory; ! 1198: ! 1199: /* ! 1200: * Clone port rights. Because kalloc'd memory ! 1201: * is wired, we won't fault while holding the task lock. ! 1202: */ ! 1203: ! 1204: for (i = 0; i < TASK_PORT_REGISTER_MAX; i++) ! 1205: ports[i] = ipc_port_copy_send(task->itk_registered[i]); ! 1206: ! 1207: itk_unlock(task); ! 1208: ! 1209: *portsp = ports; ! 1210: *portsCnt = TASK_PORT_REGISTER_MAX; ! 1211: return KERN_SUCCESS; ! 1212: } ! 1213: ! 1214: /* ! 1215: * Routine: convert_port_to_task ! 1216: * Purpose: ! 1217: * Convert from a port to a task. ! 1218: * Doesn't consume the port ref; produces a task ref, ! 1219: * which may be null. ! 1220: * Conditions: ! 1221: * Nothing locked. ! 1222: */ ! 1223: ! 1224: task_t ! 1225: convert_port_to_task( ! 1226: ipc_port_t port) ! 1227: { ! 1228: task_t task = TASK_NULL; ! 1229: ! 1230: if (IP_VALID(port)) { ! 1231: ip_lock(port); ! 1232: if (ip_active(port) && ! 1233: (ip_kotype(port) == IKOT_TASK)) { ! 1234: task = (task_t) port->ip_kobject; ! 1235: task_reference(task); ! 1236: } ! 1237: ip_unlock(port); ! 1238: } ! 1239: ! 1240: return task; ! 1241: } ! 1242: ! 1243: /* ! 1244: * Routine: convert_port_to_space ! 1245: * Purpose: ! 1246: * Convert from a port to a space. ! 1247: * Doesn't consume the port ref; produces a space ref, ! 1248: * which may be null. ! 1249: * Conditions: ! 1250: * Nothing locked. ! 1251: */ ! 1252: ! 1253: ipc_space_t ! 1254: convert_port_to_space( ! 1255: ipc_port_t port) ! 1256: { ! 1257: ipc_space_t space = IS_NULL; ! 1258: ! 1259: if (IP_VALID(port)) { ! 1260: ip_lock(port); ! 1261: if (ip_active(port) && ! 1262: (ip_kotype(port) == IKOT_TASK)) { ! 1263: space = ((task_t) port->ip_kobject)->itk_space; ! 1264: is_reference(space); ! 1265: } ! 1266: ip_unlock(port); ! 1267: } ! 1268: ! 1269: return space; ! 1270: } ! 1271: ! 1272: /* ! 1273: * Routine: convert_port_to_map ! 1274: * Purpose: ! 1275: * Convert from a port to a map. ! 1276: * Doesn't consume the port ref; produces a map ref, ! 1277: * which may be null. ! 1278: * Conditions: ! 1279: * Nothing locked. ! 1280: */ ! 1281: ! 1282: vm_map_t ! 1283: convert_port_to_map(port) ! 1284: ipc_port_t port; ! 1285: { ! 1286: vm_map_t map = VM_MAP_NULL; ! 1287: ! 1288: if (IP_VALID(port)) { ! 1289: ip_lock(port); ! 1290: if (ip_active(port) && ! 1291: (ip_kotype(port) == IKOT_TASK)) { ! 1292: map = ((task_t) port->ip_kobject)->map; ! 1293: vm_map_reference(map); ! 1294: } ! 1295: ip_unlock(port); ! 1296: } ! 1297: ! 1298: return map; ! 1299: } ! 1300: ! 1301: /* ! 1302: * Routine: convert_port_to_thread ! 1303: * Purpose: ! 1304: * Convert from a port to a thread. ! 1305: * Doesn't consume the port ref; produces a thread ref, ! 1306: * which may be null. ! 1307: * Conditions: ! 1308: * Nothing locked. ! 1309: */ ! 1310: ! 1311: thread_t ! 1312: convert_port_to_thread(port) ! 1313: ipc_port_t port; ! 1314: { ! 1315: thread_t thread = THREAD_NULL; ! 1316: ! 1317: if (IP_VALID(port)) { ! 1318: ip_lock(port); ! 1319: if (ip_active(port) && ! 1320: (ip_kotype(port) == IKOT_THREAD)) { ! 1321: thread = (thread_t) port->ip_kobject; ! 1322: thread_reference(thread); ! 1323: } ! 1324: ip_unlock(port); ! 1325: } ! 1326: ! 1327: return thread; ! 1328: } ! 1329: ! 1330: /* ! 1331: * Routine: convert_task_to_port ! 1332: * Purpose: ! 1333: * Convert from a task to a port. ! 1334: * Consumes a task ref; produces a naked send right ! 1335: * which may be invalid. ! 1336: * Conditions: ! 1337: * Nothing locked. ! 1338: */ ! 1339: ! 1340: ipc_port_t ! 1341: convert_task_to_port(task) ! 1342: task_t task; ! 1343: { ! 1344: ipc_port_t port; ! 1345: ! 1346: itk_lock(task); ! 1347: if (task->itk_self != IP_NULL) ! 1348: port = ipc_port_make_send(task->itk_self); ! 1349: else ! 1350: port = IP_NULL; ! 1351: itk_unlock(task); ! 1352: ! 1353: task_deallocate(task); ! 1354: return port; ! 1355: } ! 1356: ! 1357: /* ! 1358: * Routine: convert_thread_to_port ! 1359: * Purpose: ! 1360: * Convert from a thread to a port. ! 1361: * Consumes a thread ref; produces a naked send right ! 1362: * which may be invalid. ! 1363: * Conditions: ! 1364: * Nothing locked. ! 1365: */ ! 1366: ! 1367: ipc_port_t ! 1368: convert_thread_to_port(thread) ! 1369: thread_t thread; ! 1370: { ! 1371: ipc_port_t port; ! 1372: ! 1373: ith_lock(thread); ! 1374: if (thread->ith_self != IP_NULL) ! 1375: port = ipc_port_make_send(thread->ith_self); ! 1376: else ! 1377: port = IP_NULL; ! 1378: ith_unlock(thread); ! 1379: ! 1380: thread_deallocate(thread); ! 1381: return port; ! 1382: } ! 1383: ! 1384: /* ! 1385: * Routine: space_deallocate ! 1386: * Purpose: ! 1387: * Deallocate a space ref produced by convert_port_to_space. ! 1388: * Conditions: ! 1389: * Nothing locked. ! 1390: */ ! 1391: ! 1392: void ! 1393: space_deallocate(space) ! 1394: ipc_space_t space; ! 1395: { ! 1396: if (space != IS_NULL) ! 1397: is_release(space); ! 1398: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.