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