![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ipc_mig.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_mig.c CVS log | Up to [GnuMach] / OSKit-Mach / kern |
1.1 ! root 1: /* ! 2: * Mach Operating System ! 3: * Copyright (c) 1991,1990 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: #include <norma_vm.h> ! 28: ! 29: #include <mach/boolean.h> ! 30: #include <mach/port.h> ! 31: #include <mach/message.h> ! 32: #include <mach/thread_status.h> ! 33: #include <kern/ast.h> ! 34: #include <kern/ipc_tt.h> ! 35: #include <kern/thread.h> ! 36: #include <kern/task.h> ! 37: #include <kern/ipc_kobject.h> ! 38: #include <vm/vm_map.h> ! 39: #include <vm/vm_user.h> ! 40: #include <ipc/port.h> ! 41: #include <ipc/ipc_kmsg.h> ! 42: #include <ipc/ipc_entry.h> ! 43: #include <ipc/ipc_object.h> ! 44: #include <ipc/ipc_mqueue.h> ! 45: #include <ipc/ipc_space.h> ! 46: #include <ipc/ipc_port.h> ! 47: #include <ipc/ipc_pset.h> ! 48: #include <ipc/ipc_thread.h> ! 49: #include <device/device_types.h> ! 50: ! 51: ! 52: /* ! 53: * Routine: mach_msg_send_from_kernel ! 54: * Purpose: ! 55: * Send a message from the kernel. ! 56: * ! 57: * This is used by the client side of KernelUser interfaces ! 58: * to implement SimpleRoutines. Currently, this includes ! 59: * device_reply and memory_object messages. ! 60: * Conditions: ! 61: * Nothing locked. ! 62: * Returns: ! 63: * MACH_MSG_SUCCESS Sent the message. ! 64: * MACH_SEND_INVALID_DATA Bad destination port. ! 65: */ ! 66: ! 67: mach_msg_return_t ! 68: mach_msg_send_from_kernel( ! 69: mach_msg_header_t *msg, ! 70: mach_msg_size_t send_size) ! 71: { ! 72: ipc_kmsg_t kmsg; ! 73: mach_msg_return_t mr; ! 74: ! 75: if (!MACH_PORT_VALID(msg->msgh_remote_port)) ! 76: return MACH_SEND_INVALID_DEST; ! 77: ! 78: mr = ipc_kmsg_get_from_kernel(msg, send_size, &kmsg); ! 79: if (mr != MACH_MSG_SUCCESS) ! 80: panic("mach_msg_send_from_kernel"); ! 81: ! 82: ipc_kmsg_copyin_from_kernel(kmsg); ! 83: ipc_mqueue_send_always(kmsg); ! 84: ! 85: return MACH_MSG_SUCCESS; ! 86: } ! 87: ! 88: mach_msg_return_t ! 89: mach_msg_rpc_from_kernel(msg, send_size, reply_size) ! 90: mach_msg_header_t *msg; ! 91: mach_msg_size_t send_size; ! 92: mach_msg_size_t reply_size; ! 93: { ! 94: panic("mach_msg_rpc_from_kernel"); /*XXX*/ ! 95: } ! 96: ! 97: #if NORMA_VM ! 98: /* ! 99: * Routine: mach_msg_rpc_from_kernel ! 100: * Purpose: ! 101: * Send a message from the kernel and receive a reply. ! 102: * Uses ith_rpc_reply for the reply port. ! 103: * ! 104: * This is used by the client side of KernelUser interfaces ! 105: * to implement Routines. ! 106: * Conditions: ! 107: * Nothing locked. ! 108: * Returns: ! 109: * MACH_MSG_SUCCESS Sent the message. ! 110: * MACH_RCV_PORT_DIED The reply port was deallocated. ! 111: */ ! 112: ! 113: mach_msg_return_t ! 114: mach_msg_rpc_from_kernel( ! 115: mach_msg_header_t *msg, ! 116: mach_msg_size_t send_size, ! 117: mach_msg_size_t rcv_size) ! 118: { ! 119: ipc_thread_t self = current_thread(); ! 120: ipc_port_t reply; ! 121: ipc_kmsg_t kmsg; ! 122: mach_port_seqno_t seqno; ! 123: mach_msg_return_t mr; ! 124: ! 125: assert(MACH_PORT_VALID(msg->msgh_remote_port)); ! 126: assert(msg->msgh_local_port == MACH_PORT_NULL); ! 127: ! 128: mr = ipc_kmsg_get_from_kernel(msg, send_size, &kmsg); ! 129: if (mr != MACH_MSG_SUCCESS) ! 130: panic("mach_msg_rpc_from_kernel"); ! 131: ! 132: ipc_kmsg_copyin_from_kernel(kmsg); ! 133: ! 134: ith_lock(self); ! 135: assert(self->ith_self != IP_NULL); ! 136: ! 137: reply = self->ith_rpc_reply; ! 138: if (reply == IP_NULL) { ! 139: ith_unlock(self); ! 140: reply = ipc_port_alloc_reply(); ! 141: ith_lock(self); ! 142: if ((reply == IP_NULL) || ! 143: (self->ith_rpc_reply != IP_NULL)) ! 144: panic("mach_msg_rpc_from_kernel"); ! 145: self->ith_rpc_reply = reply; ! 146: } ! 147: ! 148: /* insert send-once right for the reply port */ ! 149: kmsg->ikm_header.msgh_local_port = ! 150: (mach_port_t) ipc_port_make_sonce(reply); ! 151: ! 152: ipc_port_reference(reply); ! 153: ith_unlock(self); ! 154: ! 155: ipc_mqueue_send_always(kmsg); ! 156: ! 157: for (;;) { ! 158: ipc_mqueue_t mqueue; ! 159: ! 160: ip_lock(reply); ! 161: if (!ip_active(reply)) { ! 162: ip_unlock(reply); ! 163: ipc_port_release(reply); ! 164: return MACH_RCV_PORT_DIED; ! 165: } ! 166: ! 167: assert(reply->ip_pset == IPS_NULL); ! 168: mqueue = &reply->ip_messages; ! 169: imq_lock(mqueue); ! 170: ip_unlock(reply); ! 171: ! 172: mr = ipc_mqueue_receive(mqueue, MACH_MSG_OPTION_NONE, ! 173: MACH_MSG_SIZE_MAX, ! 174: MACH_MSG_TIMEOUT_NONE, ! 175: FALSE, IMQ_NULL_CONTINUE, ! 176: &kmsg, &seqno); ! 177: /* mqueue is unlocked */ ! 178: if (mr == MACH_MSG_SUCCESS) ! 179: break; ! 180: ! 181: assert((mr == MACH_RCV_INTERRUPTED) || ! 182: (mr == MACH_RCV_PORT_DIED)); ! 183: ! 184: while (thread_should_halt(self)) { ! 185: /* don't terminate while holding a reference */ ! 186: if (self->ast & AST_TERMINATE) ! 187: ipc_port_release(reply); ! 188: thread_halt_self(); ! 189: } ! 190: } ! 191: ipc_port_release(reply); ! 192: ! 193: kmsg->ikm_header.msgh_seqno = seqno; ! 194: ! 195: if (rcv_size < kmsg->ikm_header.msgh_size) { ! 196: ipc_kmsg_copyout_dest(kmsg, ipc_space_reply); ! 197: ipc_kmsg_put_to_kernel(msg, kmsg, kmsg->ikm_header.msgh_size); ! 198: return MACH_RCV_TOO_LARGE; ! 199: } ! 200: ! 201: /* ! 202: * We want to preserve rights and memory in reply! ! 203: * We don't have to put them anywhere; just leave them ! 204: * as they are. ! 205: */ ! 206: ! 207: ipc_kmsg_copyout_to_kernel(kmsg, ipc_space_reply); ! 208: ipc_kmsg_put_to_kernel(msg, kmsg, kmsg->ikm_header.msgh_size); ! 209: return MACH_MSG_SUCCESS; ! 210: } ! 211: #endif /* NORMA_VM */ ! 212: ! 213: /* ! 214: * Routine: mach_msg_abort_rpc ! 215: * Purpose: ! 216: * Destroy the thread's ith_rpc_reply port. ! 217: * This will interrupt a mach_msg_rpc_from_kernel ! 218: * with a MACH_RCV_PORT_DIED return code. ! 219: * Conditions: ! 220: * Nothing locked. ! 221: */ ! 222: ! 223: void ! 224: mach_msg_abort_rpc(thread) ! 225: ipc_thread_t thread; ! 226: { ! 227: ipc_port_t reply = IP_NULL; ! 228: ! 229: ith_lock(thread); ! 230: if (thread->ith_self != IP_NULL) { ! 231: reply = thread->ith_rpc_reply; ! 232: thread->ith_rpc_reply = IP_NULL; ! 233: } ! 234: ith_unlock(thread); ! 235: ! 236: if (reply != IP_NULL) ! 237: ipc_port_dealloc_reply(reply); ! 238: } ! 239: ! 240: /* ! 241: * Routine: mach_msg ! 242: * Purpose: ! 243: * Like mach_msg_trap except that message buffers ! 244: * live in kernel space. Doesn't handle any options. ! 245: * ! 246: * This is used by in-kernel server threads to make ! 247: * kernel calls, to receive request messages, and ! 248: * to send reply messages. ! 249: * Conditions: ! 250: * Nothing locked. ! 251: * Returns: ! 252: */ ! 253: ! 254: mach_msg_return_t ! 255: mach_msg(msg, option, send_size, rcv_size, rcv_name, time_out, notify) ! 256: mach_msg_header_t *msg; ! 257: mach_msg_option_t option; ! 258: mach_msg_size_t send_size; ! 259: mach_msg_size_t rcv_size; ! 260: mach_port_t rcv_name; ! 261: mach_msg_timeout_t time_out; ! 262: mach_port_t notify; ! 263: { ! 264: ipc_space_t space = current_space(); ! 265: vm_map_t map = current_map(); ! 266: ipc_kmsg_t kmsg; ! 267: mach_port_seqno_t seqno; ! 268: mach_msg_return_t mr; ! 269: ! 270: if (option & MACH_SEND_MSG) { ! 271: mr = ipc_kmsg_get_from_kernel(msg, send_size, &kmsg); ! 272: if (mr != MACH_MSG_SUCCESS) ! 273: panic("mach_msg"); ! 274: ! 275: mr = ipc_kmsg_copyin(kmsg, space, map, MACH_PORT_NULL); ! 276: if (mr != MACH_MSG_SUCCESS) { ! 277: ikm_free(kmsg); ! 278: return mr; ! 279: } ! 280: ! 281: do ! 282: mr = ipc_mqueue_send(kmsg, MACH_MSG_OPTION_NONE, ! 283: MACH_MSG_TIMEOUT_NONE); ! 284: while (mr == MACH_SEND_INTERRUPTED); ! 285: assert(mr == MACH_MSG_SUCCESS); ! 286: } ! 287: ! 288: if (option & MACH_RCV_MSG) { ! 289: do { ! 290: ipc_object_t object; ! 291: ipc_mqueue_t mqueue; ! 292: ! 293: mr = ipc_mqueue_copyin(space, rcv_name, ! 294: &mqueue, &object); ! 295: if (mr != MACH_MSG_SUCCESS) ! 296: return mr; ! 297: /* hold ref for object; mqueue is locked */ ! 298: ! 299: mr = ipc_mqueue_receive(mqueue, MACH_MSG_OPTION_NONE, ! 300: MACH_MSG_SIZE_MAX, ! 301: MACH_MSG_TIMEOUT_NONE, ! 302: FALSE, IMQ_NULL_CONTINUE, ! 303: &kmsg, &seqno); ! 304: /* mqueue is unlocked */ ! 305: ipc_object_release(object); ! 306: } while (mr == MACH_RCV_INTERRUPTED); ! 307: if (mr != MACH_MSG_SUCCESS) ! 308: return mr; ! 309: ! 310: kmsg->ikm_header.msgh_seqno = seqno; ! 311: ! 312: if (rcv_size < kmsg->ikm_header.msgh_size) { ! 313: ipc_kmsg_copyout_dest(kmsg, space); ! 314: ipc_kmsg_put_to_kernel(msg, kmsg, sizeof *msg); ! 315: return MACH_RCV_TOO_LARGE; ! 316: } ! 317: ! 318: mr = ipc_kmsg_copyout(kmsg, space, map, MACH_PORT_NULL); ! 319: if (mr != MACH_MSG_SUCCESS) { ! 320: if ((mr &~ MACH_MSG_MASK) == MACH_RCV_BODY_ERROR) { ! 321: ipc_kmsg_put_to_kernel(msg, kmsg, ! 322: kmsg->ikm_header.msgh_size); ! 323: } else { ! 324: ipc_kmsg_copyout_dest(kmsg, space); ! 325: ipc_kmsg_put_to_kernel(msg, kmsg, sizeof *msg); ! 326: } ! 327: ! 328: return mr; ! 329: } ! 330: ! 331: ipc_kmsg_put_to_kernel(msg, kmsg, kmsg->ikm_header.msgh_size); ! 332: } ! 333: ! 334: return MACH_MSG_SUCCESS; ! 335: } ! 336: ! 337: /* ! 338: * Routine: mig_get_reply_port ! 339: * Purpose: ! 340: * Called by client side interfaces living in the kernel ! 341: * to get a reply port. This port is used for ! 342: * mach_msg() calls which are kernel calls. ! 343: */ ! 344: ! 345: mach_port_t ! 346: mig_get_reply_port(void) ! 347: { ! 348: ipc_thread_t self = current_thread(); ! 349: ! 350: if (self->ith_mig_reply == MACH_PORT_NULL) ! 351: self->ith_mig_reply = mach_reply_port(); ! 352: ! 353: return self->ith_mig_reply; ! 354: } ! 355: ! 356: /* ! 357: * Routine: mig_dealloc_reply_port ! 358: * Purpose: ! 359: * Called by client side interfaces to get rid of a reply port. ! 360: * Shouldn't ever be called inside the kernel, because ! 361: * kernel calls shouldn't prompt Mig to call it. ! 362: */ ! 363: ! 364: void ! 365: mig_dealloc_reply_port( ! 366: mach_port_t reply_port) ! 367: { ! 368: panic("mig_dealloc_reply_port"); ! 369: } ! 370: ! 371: /* ! 372: * Routine: mig_put_reply_port ! 373: * Purpose: ! 374: * Called by client side interfaces after each RPC to ! 375: * let the client recycle the reply port if it wishes. ! 376: */ ! 377: void ! 378: mig_put_reply_port( ! 379: mach_port_t reply_port) ! 380: { ! 381: } ! 382: ! 383: /* ! 384: * mig_strncpy.c - by Joshua Block ! 385: * ! 386: * mig_strncp -- Bounded string copy. Does what the library routine strncpy ! 387: * OUGHT to do: Copies the (null terminated) string in src into dest, a ! 388: * buffer of length len. Assures that the copy is still null terminated ! 389: * and doesn't overflow the buffer, truncating the copy if necessary. ! 390: * ! 391: * Parameters: ! 392: * ! 393: * dest - Pointer to destination buffer. ! 394: * ! 395: * src - Pointer to source string. ! 396: * ! 397: * len - Length of destination buffer. ! 398: */ ! 399: void mig_strncpy(dest, src, len) ! 400: char *dest, *src; ! 401: int len; ! 402: { ! 403: int i; ! 404: ! 405: if (len <= 0) ! 406: return; ! 407: ! 408: for (i=1; i<len; i++) ! 409: if (! (*dest++ = *src++)) ! 410: return; ! 411: ! 412: *dest = '\0'; ! 413: return; ! 414: } ! 415: ! 416: #define fast_send_right_lookup(name, port, abort) \ ! 417: MACRO_BEGIN \ ! 418: register ipc_space_t space = current_space(); \ ! 419: register ipc_entry_t entry; \ ! 420: register mach_port_index_t index = MACH_PORT_INDEX(name); \ ! 421: \ ! 422: is_read_lock(space); \ ! 423: assert(space->is_active); \ ! 424: \ ! 425: if ((index >= space->is_table_size) || \ ! 426: (((entry = &space->is_table[index])->ie_bits & \ ! 427: (IE_BITS_GEN_MASK|MACH_PORT_TYPE_SEND)) != \ ! 428: (MACH_PORT_GEN(name) | MACH_PORT_TYPE_SEND))) { \ ! 429: is_read_unlock(space); \ ! 430: abort; \ ! 431: } \ ! 432: \ ! 433: port = (ipc_port_t) entry->ie_object; \ ! 434: assert(port != IP_NULL); \ ! 435: \ ! 436: ip_lock(port); \ ! 437: /* can safely unlock space now that port is locked */ \ ! 438: is_read_unlock(space); \ ! 439: MACRO_END ! 440: ! 441: device_t ! 442: port_name_to_device(name) ! 443: mach_port_t name; ! 444: { ! 445: register ipc_port_t port; ! 446: register device_t device; ! 447: ! 448: fast_send_right_lookup(name, port, goto abort); ! 449: /* port is locked */ ! 450: ! 451: /* ! 452: * Now map the port object to a device object. ! 453: * This is an inline version of dev_port_lookup(). ! 454: */ ! 455: if (ip_active(port) && (ip_kotype(port) == IKOT_DEVICE)) { ! 456: device = (device_t) port->ip_kobject; ! 457: device_reference(device); ! 458: ip_unlock(port); ! 459: return device; ! 460: } ! 461: ! 462: ip_unlock(port); ! 463: return DEVICE_NULL; ! 464: ! 465: /* ! 466: * The slow case. The port wasn't easily accessible. ! 467: */ ! 468: abort: { ! 469: ipc_port_t kern_port; ! 470: kern_return_t kr; ! 471: ! 472: kr = ipc_object_copyin(current_space(), name, ! 473: MACH_MSG_TYPE_COPY_SEND, ! 474: (ipc_object_t *) &kern_port); ! 475: if (kr != KERN_SUCCESS) ! 476: return DEVICE_NULL; ! 477: ! 478: device = dev_port_lookup(kern_port); ! 479: if (IP_VALID(kern_port)) ! 480: ipc_port_release_send(kern_port); ! 481: return device; ! 482: } ! 483: } ! 484: ! 485: thread_t ! 486: port_name_to_thread(name) ! 487: mach_port_t name; ! 488: { ! 489: register ipc_port_t port; ! 490: ! 491: fast_send_right_lookup(name, port, goto abort); ! 492: /* port is locked */ ! 493: ! 494: if (ip_active(port) && ! 495: (ip_kotype(port) == IKOT_THREAD)) { ! 496: register thread_t thread; ! 497: ! 498: thread = (thread_t) port->ip_kobject; ! 499: assert(thread != THREAD_NULL); ! 500: ! 501: /* thread referencing is a bit complicated, ! 502: so don't bother to expand inline */ ! 503: thread_reference(thread); ! 504: ip_unlock(port); ! 505: ! 506: return thread; ! 507: } ! 508: ! 509: ip_unlock(port); ! 510: return THREAD_NULL; ! 511: ! 512: abort: { ! 513: thread_t thread; ! 514: ipc_port_t kern_port; ! 515: kern_return_t kr; ! 516: ! 517: kr = ipc_object_copyin(current_space(), name, ! 518: MACH_MSG_TYPE_COPY_SEND, ! 519: (ipc_object_t *) &kern_port); ! 520: if (kr != KERN_SUCCESS) ! 521: return THREAD_NULL; ! 522: ! 523: thread = convert_port_to_thread(kern_port); ! 524: if (IP_VALID(kern_port)) ! 525: ipc_port_release_send(kern_port); ! 526: ! 527: return thread; ! 528: } ! 529: } ! 530: ! 531: task_t ! 532: port_name_to_task(name) ! 533: mach_port_t name; ! 534: { ! 535: register ipc_port_t port; ! 536: ! 537: fast_send_right_lookup(name, port, goto abort); ! 538: /* port is locked */ ! 539: ! 540: if (ip_active(port) && ! 541: (ip_kotype(port) == IKOT_TASK)) { ! 542: register task_t task; ! 543: ! 544: task = (task_t) port->ip_kobject; ! 545: assert(task != TASK_NULL); ! 546: ! 547: task_lock(task); ! 548: /* can safely unlock port now that task is locked */ ! 549: ip_unlock(port); ! 550: ! 551: task->ref_count++; ! 552: task_unlock(task); ! 553: ! 554: return task; ! 555: } ! 556: ! 557: ip_unlock(port); ! 558: return TASK_NULL; ! 559: ! 560: abort: { ! 561: task_t task; ! 562: ipc_port_t kern_port; ! 563: kern_return_t kr; ! 564: ! 565: kr = ipc_object_copyin(current_space(), name, ! 566: MACH_MSG_TYPE_COPY_SEND, ! 567: (ipc_object_t *) &kern_port); ! 568: if (kr != KERN_SUCCESS) ! 569: return TASK_NULL; ! 570: ! 571: task = convert_port_to_task(kern_port); ! 572: if (IP_VALID(kern_port)) ! 573: ipc_port_release_send(kern_port); ! 574: ! 575: return task; ! 576: } ! 577: } ! 578: ! 579: vm_map_t ! 580: port_name_to_map( ! 581: mach_port_t name) ! 582: { ! 583: register ipc_port_t port; ! 584: ! 585: fast_send_right_lookup(name, port, goto abort); ! 586: /* port is locked */ ! 587: ! 588: if (ip_active(port) && ! 589: (ip_kotype(port) == IKOT_TASK)) { ! 590: register vm_map_t map; ! 591: ! 592: map = ((task_t) port->ip_kobject)->map; ! 593: assert(map != VM_MAP_NULL); ! 594: ! 595: simple_lock(&map->ref_lock); ! 596: /* can safely unlock port now that map is locked */ ! 597: ip_unlock(port); ! 598: ! 599: map->ref_count++; ! 600: simple_unlock(&map->ref_lock); ! 601: ! 602: return map; ! 603: } ! 604: ! 605: ip_unlock(port); ! 606: return VM_MAP_NULL; ! 607: ! 608: abort: { ! 609: vm_map_t map; ! 610: ipc_port_t kern_port; ! 611: kern_return_t kr; ! 612: ! 613: kr = ipc_object_copyin(current_space(), name, ! 614: MACH_MSG_TYPE_COPY_SEND, ! 615: (ipc_object_t *) &kern_port); ! 616: if (kr != KERN_SUCCESS) ! 617: return VM_MAP_NULL; ! 618: ! 619: map = convert_port_to_map(kern_port); ! 620: if (IP_VALID(kern_port)) ! 621: ipc_port_release_send(kern_port); ! 622: ! 623: return map; ! 624: } ! 625: } ! 626: ! 627: ipc_space_t ! 628: port_name_to_space(name) ! 629: mach_port_t name; ! 630: { ! 631: register ipc_port_t port; ! 632: ! 633: fast_send_right_lookup(name, port, goto abort); ! 634: /* port is locked */ ! 635: ! 636: if (ip_active(port) && ! 637: (ip_kotype(port) == IKOT_TASK)) { ! 638: register ipc_space_t space; ! 639: ! 640: space = ((task_t) port->ip_kobject)->itk_space; ! 641: assert(space != IS_NULL); ! 642: ! 643: simple_lock(&space->is_ref_lock_data); ! 644: /* can safely unlock port now that space is locked */ ! 645: ip_unlock(port); ! 646: ! 647: space->is_references++; ! 648: simple_unlock(&space->is_ref_lock_data); ! 649: ! 650: return space; ! 651: } ! 652: ! 653: ip_unlock(port); ! 654: return IS_NULL; ! 655: ! 656: abort: { ! 657: ipc_space_t space; ! 658: ipc_port_t kern_port; ! 659: kern_return_t kr; ! 660: ! 661: kr = ipc_object_copyin(current_space(), name, ! 662: MACH_MSG_TYPE_COPY_SEND, ! 663: (ipc_object_t *) &kern_port); ! 664: if (kr != KERN_SUCCESS) ! 665: return IS_NULL; ! 666: ! 667: space = convert_port_to_space(kern_port); ! 668: if (IP_VALID(kern_port)) ! 669: ipc_port_release_send(kern_port); ! 670: ! 671: return space; ! 672: } ! 673: } ! 674: ! 675: /* ! 676: * Hack to translate a thread port to a thread pointer for calling ! 677: * thread_get_state and thread_set_state. This is only necessary ! 678: * because the IPC message for these two operations overflows the ! 679: * kernel stack. ! 680: * ! 681: * AARGH! ! 682: */ ! 683: ! 684: kern_return_t thread_get_state_KERNEL(thread_port, flavor, ! 685: old_state, old_state_count) ! 686: mach_port_t thread_port; /* port right for thread */ ! 687: int flavor; ! 688: thread_state_t old_state; /* pointer to OUT array */ ! 689: natural_t *old_state_count; /* IN/OUT */ ! 690: { ! 691: thread_t thread; ! 692: kern_return_t result; ! 693: ! 694: thread = port_name_to_thread(thread_port); ! 695: result = thread_get_state(thread, flavor, old_state, old_state_count); ! 696: thread_deallocate(thread); ! 697: ! 698: return result; ! 699: } ! 700: ! 701: kern_return_t thread_set_state_KERNEL(thread_port, flavor, ! 702: new_state, new_state_count) ! 703: mach_port_t thread_port; /* port right for thread */ ! 704: int flavor; ! 705: thread_state_t new_state; ! 706: natural_t new_state_count; ! 707: { ! 708: thread_t thread; ! 709: kern_return_t result; ! 710: ! 711: thread = port_name_to_thread(thread_port); ! 712: result = thread_set_state(thread, flavor, new_state, new_state_count); ! 713: thread_deallocate(thread); ! 714: ! 715: return result; ! 716: } ! 717: ! 718: /* ! 719: * Things to keep in mind: ! 720: * ! 721: * The idea here is to duplicate the semantics of the true kernel RPC. ! 722: * The destination port/object should be checked first, before anything ! 723: * that the user might notice (like ipc_object_copyin). Return ! 724: * MACH_SEND_INTERRUPTED if it isn't correct, so that the user stub ! 725: * knows to fall back on an RPC. For other return values, it won't ! 726: * retry with an RPC. The retry might get a different (incorrect) rc. ! 727: * Return values are only set (and should only be set, with copyout) ! 728: * on successfull calls. ! 729: */ ! 730: ! 731: kern_return_t ! 732: syscall_vm_map( ! 733: mach_port_t target_map, ! 734: vm_offset_t *address, ! 735: vm_size_t size, ! 736: vm_offset_t mask, ! 737: boolean_t anywhere, ! 738: mach_port_t memory_object, ! 739: vm_offset_t offset, ! 740: boolean_t copy, ! 741: vm_prot_t cur_protection, ! 742: vm_prot_t max_protection, ! 743: vm_inherit_t inheritance) ! 744: { ! 745: vm_map_t map; ! 746: ipc_port_t port; ! 747: vm_offset_t addr; ! 748: kern_return_t result; ! 749: ! 750: map = port_name_to_map(target_map); ! 751: if (map == VM_MAP_NULL) ! 752: return MACH_SEND_INTERRUPTED; ! 753: ! 754: if (MACH_PORT_VALID(memory_object)) { ! 755: result = ipc_object_copyin(current_space(), memory_object, ! 756: MACH_MSG_TYPE_COPY_SEND, ! 757: (ipc_object_t *) &port); ! 758: if (result != KERN_SUCCESS) { ! 759: vm_map_deallocate(map); ! 760: return result; ! 761: } ! 762: } else ! 763: port = (ipc_port_t) memory_object; ! 764: ! 765: copyin((char *)address, (char *)&addr, sizeof(vm_offset_t)); ! 766: result = vm_map(map, &addr, size, mask, anywhere, ! 767: port, offset, copy, ! 768: cur_protection, max_protection, inheritance); ! 769: if (result == KERN_SUCCESS) ! 770: copyout((char *)&addr, (char *)address, sizeof(vm_offset_t)); ! 771: if (IP_VALID(port)) ! 772: ipc_port_release_send(port); ! 773: vm_map_deallocate(map); ! 774: ! 775: return result; ! 776: } ! 777: ! 778: kern_return_t syscall_vm_allocate(target_map, address, size, anywhere) ! 779: mach_port_t target_map; ! 780: vm_offset_t *address; ! 781: vm_size_t size; ! 782: boolean_t anywhere; ! 783: { ! 784: vm_map_t map; ! 785: vm_offset_t addr; ! 786: kern_return_t result; ! 787: ! 788: map = port_name_to_map(target_map); ! 789: if (map == VM_MAP_NULL) ! 790: return MACH_SEND_INTERRUPTED; ! 791: ! 792: copyin((char *)address, (char *)&addr, sizeof(vm_offset_t)); ! 793: result = vm_allocate(map, &addr, size, anywhere); ! 794: if (result == KERN_SUCCESS) ! 795: copyout((char *)&addr, (char *)address, sizeof(vm_offset_t)); ! 796: vm_map_deallocate(map); ! 797: ! 798: return result; ! 799: } ! 800: ! 801: kern_return_t syscall_vm_deallocate(target_map, start, size) ! 802: mach_port_t target_map; ! 803: vm_offset_t start; ! 804: vm_size_t size; ! 805: { ! 806: vm_map_t map; ! 807: kern_return_t result; ! 808: ! 809: map = port_name_to_map(target_map); ! 810: if (map == VM_MAP_NULL) ! 811: return MACH_SEND_INTERRUPTED; ! 812: ! 813: result = vm_deallocate(map, start, size); ! 814: vm_map_deallocate(map); ! 815: ! 816: return result; ! 817: } ! 818: ! 819: kern_return_t syscall_task_create(parent_task, inherit_memory, child_task) ! 820: mach_port_t parent_task; ! 821: boolean_t inherit_memory; ! 822: mach_port_t *child_task; /* OUT */ ! 823: { ! 824: task_t t, c; ! 825: ipc_port_t port; ! 826: mach_port_t name; ! 827: kern_return_t result; ! 828: ! 829: t = port_name_to_task(parent_task); ! 830: if (t == TASK_NULL) ! 831: return MACH_SEND_INTERRUPTED; ! 832: ! 833: result = task_create(t, inherit_memory, &c); ! 834: if (result == KERN_SUCCESS) { ! 835: port = (ipc_port_t) convert_task_to_port(c); ! 836: /* always returns a name, even for non-success return codes */ ! 837: (void) ipc_kmsg_copyout_object(current_space(), ! 838: (ipc_object_t) port, ! 839: MACH_MSG_TYPE_PORT_SEND, &name); ! 840: copyout((char *)&name, (char *)child_task, ! 841: sizeof(mach_port_t)); ! 842: } ! 843: task_deallocate(t); ! 844: ! 845: return result; ! 846: } ! 847: ! 848: kern_return_t syscall_task_terminate(task) ! 849: mach_port_t task; ! 850: { ! 851: task_t t; ! 852: kern_return_t result; ! 853: ! 854: t = port_name_to_task(task); ! 855: if (t == TASK_NULL) ! 856: return MACH_SEND_INTERRUPTED; ! 857: ! 858: result = task_terminate(t); ! 859: task_deallocate(t); ! 860: ! 861: return result; ! 862: } ! 863: ! 864: kern_return_t syscall_task_suspend(task) ! 865: mach_port_t task; ! 866: { ! 867: task_t t; ! 868: kern_return_t result; ! 869: ! 870: t = port_name_to_task(task); ! 871: if (t == TASK_NULL) ! 872: return MACH_SEND_INTERRUPTED; ! 873: ! 874: result = task_suspend(t); ! 875: task_deallocate(t); ! 876: ! 877: return result; ! 878: } ! 879: ! 880: kern_return_t syscall_task_set_special_port(task, which_port, port_name) ! 881: mach_port_t task; ! 882: int which_port; ! 883: mach_port_t port_name; ! 884: { ! 885: task_t t; ! 886: ipc_port_t port; ! 887: kern_return_t result; ! 888: ! 889: t = port_name_to_task(task); ! 890: if (t == TASK_NULL) ! 891: return MACH_SEND_INTERRUPTED; ! 892: ! 893: if (MACH_PORT_VALID(port_name)) { ! 894: result = ipc_object_copyin(current_space(), port_name, ! 895: MACH_MSG_TYPE_COPY_SEND, ! 896: (ipc_object_t *) &port); ! 897: if (result != KERN_SUCCESS) { ! 898: task_deallocate(t); ! 899: return result; ! 900: } ! 901: } else ! 902: port = (ipc_port_t) port_name; ! 903: ! 904: result = task_set_special_port(t, which_port, port); ! 905: if ((result != KERN_SUCCESS) && IP_VALID(port)) ! 906: ipc_port_release_send(port); ! 907: task_deallocate(t); ! 908: ! 909: return result; ! 910: } ! 911: ! 912: kern_return_t ! 913: syscall_mach_port_allocate(task, right, namep) ! 914: mach_port_t task; ! 915: mach_port_right_t right; ! 916: mach_port_t *namep; ! 917: { ! 918: ipc_space_t space; ! 919: mach_port_t name; ! 920: kern_return_t kr; ! 921: ! 922: space = port_name_to_space(task); ! 923: if (space == IS_NULL) ! 924: return MACH_SEND_INTERRUPTED; ! 925: ! 926: kr = mach_port_allocate(space, right, &name); ! 927: if (kr == KERN_SUCCESS) ! 928: copyout((char *)&name, (char *)namep, sizeof(mach_port_t)); ! 929: is_release(space); ! 930: ! 931: return kr; ! 932: } ! 933: ! 934: kern_return_t ! 935: syscall_mach_port_allocate_name(task, right, name) ! 936: mach_port_t task; ! 937: mach_port_right_t right; ! 938: mach_port_t name; ! 939: { ! 940: ipc_space_t space; ! 941: kern_return_t kr; ! 942: ! 943: space = port_name_to_space(task); ! 944: if (space == IS_NULL) ! 945: return MACH_SEND_INTERRUPTED; ! 946: ! 947: kr = mach_port_allocate_name(space, right, name); ! 948: is_release(space); ! 949: ! 950: return kr; ! 951: } ! 952: ! 953: kern_return_t ! 954: syscall_mach_port_deallocate(task, name) ! 955: mach_port_t task; ! 956: mach_port_t name; ! 957: { ! 958: ipc_space_t space; ! 959: kern_return_t kr; ! 960: ! 961: space = port_name_to_space(task); ! 962: if (space == IS_NULL) ! 963: return MACH_SEND_INTERRUPTED; ! 964: ! 965: kr = mach_port_deallocate(space, name); ! 966: is_release(space); ! 967: ! 968: return kr; ! 969: } ! 970: ! 971: kern_return_t ! 972: syscall_mach_port_insert_right(task, name, right, rightType) ! 973: mach_port_t task; ! 974: mach_port_t name; ! 975: mach_port_t right; ! 976: mach_msg_type_name_t rightType; ! 977: { ! 978: ipc_space_t space; ! 979: ipc_object_t object; ! 980: mach_msg_type_name_t newtype; ! 981: kern_return_t kr; ! 982: ! 983: space = port_name_to_space(task); ! 984: if (space == IS_NULL) ! 985: return MACH_SEND_INTERRUPTED; ! 986: ! 987: if (!MACH_MSG_TYPE_PORT_ANY(rightType)) { ! 988: is_release(space); ! 989: return KERN_INVALID_VALUE; ! 990: } ! 991: ! 992: if (MACH_PORT_VALID(right)) { ! 993: kr = ipc_object_copyin(current_space(), right, rightType, ! 994: &object); ! 995: if (kr != KERN_SUCCESS) { ! 996: is_release(space); ! 997: return kr; ! 998: } ! 999: } else ! 1000: object = (ipc_object_t) right; ! 1001: newtype = ipc_object_copyin_type(rightType); ! 1002: ! 1003: kr = mach_port_insert_right(space, name, (ipc_port_t) object, newtype); ! 1004: if ((kr != KERN_SUCCESS) && IO_VALID(object)) ! 1005: ipc_object_destroy(object, newtype); ! 1006: is_release(space); ! 1007: ! 1008: return kr; ! 1009: } ! 1010: ! 1011: kern_return_t syscall_thread_depress_abort(thread) ! 1012: mach_port_t thread; ! 1013: { ! 1014: thread_t t; ! 1015: kern_return_t result; ! 1016: ! 1017: t = port_name_to_thread(thread); ! 1018: if (t == THREAD_NULL) ! 1019: return MACH_SEND_INTERRUPTED; ! 1020: ! 1021: result = thread_depress_abort(t); ! 1022: thread_deallocate(t); ! 1023: ! 1024: return result; ! 1025: } ! 1026: ! 1027: /* ! 1028: * Device traps -- these are way experimental. ! 1029: */ ! 1030: ! 1031: extern io_return_t ds_device_write_trap(); ! 1032: extern io_return_t ds_device_writev_trap(); ! 1033: ! 1034: io_return_t ! 1035: syscall_device_write_request(mach_port_t device_name, ! 1036: mach_port_t reply_name, ! 1037: dev_mode_t mode, ! 1038: recnum_t recnum, ! 1039: vm_offset_t data, ! 1040: vm_size_t data_count) ! 1041: { ! 1042: device_t dev; ! 1043: ipc_port_t reply_port; ! 1044: io_return_t res; ! 1045: ! 1046: /* ! 1047: * First try to translate the device name. ! 1048: * ! 1049: * If this fails, return KERN_INVALID_CAPABILITY. ! 1050: * Caller knows that this most likely means that ! 1051: * device is not local to node and IPC should be used. ! 1052: * ! 1053: * If kernel doesn't do device traps, kern_invalid() ! 1054: * will be called instead of this function which will ! 1055: * return KERN_INVALID_ARGUMENT. ! 1056: */ ! 1057: dev = port_name_to_device(device_name); ! 1058: if (dev == DEVICE_NULL) ! 1059: return KERN_INVALID_CAPABILITY; ! 1060: ! 1061: /* ! 1062: * Translate reply port. ! 1063: */ ! 1064: if (reply_name == MACH_PORT_NULL) ! 1065: reply_port = IP_NULL; ! 1066: else { ! 1067: /* Homey don't play that. */ ! 1068: device_deallocate(dev); ! 1069: return KERN_INVALID_RIGHT; ! 1070: } ! 1071: ! 1072: /* note: doesn't take reply_port arg yet. */ ! 1073: res = ds_device_write_trap(dev, /*reply_port,*/ ! 1074: mode, recnum, ! 1075: data, data_count); ! 1076: ! 1077: /* ! 1078: * Give up reference from port_name_to_device. ! 1079: */ ! 1080: device_deallocate(dev); ! 1081: return res; ! 1082: } ! 1083: ! 1084: io_return_t ! 1085: syscall_device_writev_request(mach_port_t device_name, ! 1086: mach_port_t reply_name, ! 1087: dev_mode_t mode, ! 1088: recnum_t recnum, ! 1089: io_buf_vec_t *iovec, ! 1090: vm_size_t iocount) ! 1091: { ! 1092: device_t dev; ! 1093: ipc_port_t reply_port; ! 1094: io_return_t res; ! 1095: ! 1096: /* ! 1097: * First try to translate the device name. ! 1098: * ! 1099: * If this fails, return KERN_INVALID_CAPABILITY. ! 1100: * Caller knows that this most likely means that ! 1101: * device is not local to node and IPC should be used. ! 1102: * ! 1103: * If kernel doesn't do device traps, kern_invalid() ! 1104: * will be called instead of this function which will ! 1105: * return KERN_INVALID_ARGUMENT. ! 1106: */ ! 1107: dev = port_name_to_device(device_name); ! 1108: if (dev == DEVICE_NULL) ! 1109: return KERN_INVALID_CAPABILITY; ! 1110: ! 1111: /* ! 1112: * Translate reply port. ! 1113: */ ! 1114: if (reply_name == MACH_PORT_NULL) ! 1115: reply_port = IP_NULL; ! 1116: else { ! 1117: /* Homey don't play that. */ ! 1118: device_deallocate(dev); ! 1119: return KERN_INVALID_RIGHT; ! 1120: } ! 1121: ! 1122: /* note: doesn't take reply_port arg yet. */ ! 1123: res = ds_device_writev_trap(dev, /*reply_port,*/ ! 1124: mode, recnum, ! 1125: iovec, iocount); ! 1126: ! 1127: /* ! 1128: * Give up reference from port_name_to_device. ! 1129: */ ! 1130: device_deallocate(dev); ! 1131: return res; ! 1132: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.