![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to exception.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 exception.c CVS log | Up to [GnuMach] / OSKit-Mach / kern |
1.1 ! root 1: /* ! 2: * Mach Operating System ! 3: * Copyright (c) 1993,1992,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: #include <norma_ipc.h> ! 28: #include <mach_kdb.h> ! 29: ! 30: #include <mach/boolean.h> ! 31: #include <mach/kern_return.h> ! 32: #include <mach/message.h> ! 33: #include <mach/port.h> ! 34: #include <mach/mig_errors.h> ! 35: #include <ipc/port.h> ! 36: #include <ipc/ipc_entry.h> ! 37: #include <ipc/ipc_object.h> ! 38: #include <ipc/ipc_space.h> ! 39: #include <ipc/ipc_port.h> ! 40: #include <ipc/ipc_pset.h> ! 41: #include <ipc/mach_msg.h> ! 42: #include <ipc/ipc_machdep.h> ! 43: #include <kern/counters.h> ! 44: #include <kern/ipc_tt.h> ! 45: #include <kern/task.h> ! 46: #include <kern/thread.h> ! 47: #include <kern/processor.h> ! 48: #include <kern/sched.h> ! 49: #include <kern/sched_prim.h> ! 50: #include <mach/machine/vm_types.h> ! 51: ! 52: ! 53: ! 54: extern void exception(); ! 55: extern void exception_try_task(); ! 56: extern void exception_no_server(); ! 57: ! 58: extern void exception_raise(); ! 59: extern kern_return_t exception_parse_reply(); ! 60: extern void exception_raise_continue(); ! 61: extern void exception_raise_continue_slow(); ! 62: extern void exception_raise_continue_fast(); ! 63: ! 64: #if MACH_KDB ! 65: extern void thread_kdb_return(); ! 66: extern void db_printf(); ! 67: ! 68: boolean_t debug_user_with_kdb = FALSE; ! 69: #endif /* MACH_KDB */ ! 70: ! 71: #ifdef KEEP_STACKS ! 72: /* ! 73: * Some obsolete architectures don't support kernel stack discarding ! 74: * or the thread_exception_return, thread_syscall_return continuations. ! 75: * For these architectures, the NOTREACHED comments below are incorrect. ! 76: * The exception function is expected to return. ! 77: * So the return statements along the slow paths are important. ! 78: */ ! 79: #endif /* KEEP_STACKS */ ! 80: ! 81: /* ! 82: * Routine: exception ! 83: * Purpose: ! 84: * The current thread caught an exception. ! 85: * We make an up-call to the thread's exception server. ! 86: * Conditions: ! 87: * Nothing locked and no resources held. ! 88: * Called from an exception context, so ! 89: * thread_exception_return and thread_kdb_return ! 90: * are possible. ! 91: * Returns: ! 92: * Doesn't return. ! 93: */ ! 94: ! 95: void ! 96: exception(_exception, code, subcode) ! 97: integer_t _exception, code, subcode; ! 98: { ! 99: register ipc_thread_t self = current_thread(); ! 100: register ipc_port_t exc_port; ! 101: ! 102: if (_exception == KERN_SUCCESS) ! 103: panic("exception"); ! 104: ! 105: /* ! 106: * Optimized version of retrieve_thread_exception. ! 107: */ ! 108: ! 109: ith_lock(self); ! 110: assert(self->ith_self != IP_NULL); ! 111: exc_port = self->ith_exception; ! 112: if (!IP_VALID(exc_port)) { ! 113: ith_unlock(self); ! 114: exception_try_task(_exception, code, subcode); ! 115: /*NOTREACHED*/ ! 116: return; ! 117: } ! 118: ! 119: ip_lock(exc_port); ! 120: ith_unlock(self); ! 121: if (!ip_active(exc_port)) { ! 122: ip_unlock(exc_port); ! 123: exception_try_task(_exception, code, subcode); ! 124: /*NOTREACHED*/ ! 125: return; ! 126: } ! 127: ! 128: /* ! 129: * Make a naked send right for the exception port. ! 130: */ ! 131: ! 132: ip_reference(exc_port); ! 133: exc_port->ip_srights++; ! 134: ip_unlock(exc_port); ! 135: ! 136: /* ! 137: * If this exception port doesn't work, ! 138: * we will want to try the task's exception port. ! 139: * Indicate this by saving the exception state. ! 140: */ ! 141: ! 142: self->ith_exc = _exception; ! 143: self->ith_exc_code = code; ! 144: self->ith_exc_subcode = subcode; ! 145: ! 146: exception_raise(exc_port, ! 147: retrieve_thread_self_fast(self), ! 148: retrieve_task_self_fast(self->task), ! 149: _exception, code, subcode); ! 150: /*NOTREACHED*/ ! 151: } ! 152: ! 153: /* ! 154: * Routine: exception_try_task ! 155: * Purpose: ! 156: * The current thread caught an exception. ! 157: * We make an up-call to the task's exception server. ! 158: * Conditions: ! 159: * Nothing locked and no resources held. ! 160: * Called from an exception context, so ! 161: * thread_exception_return and thread_kdb_return ! 162: * are possible. ! 163: * Returns: ! 164: * Doesn't return. ! 165: */ ! 166: ! 167: void ! 168: exception_try_task(_exception, code, subcode) ! 169: integer_t _exception, code, subcode; ! 170: { ! 171: ipc_thread_t self = current_thread(); ! 172: register task_t task = self->task; ! 173: register ipc_port_t exc_port; ! 174: ! 175: /* ! 176: * Optimized version of retrieve_task_exception. ! 177: */ ! 178: ! 179: itk_lock(task); ! 180: assert(task->itk_self != IP_NULL); ! 181: exc_port = task->itk_exception; ! 182: if (!IP_VALID(exc_port)) { ! 183: itk_unlock(task); ! 184: exception_no_server(); ! 185: /*NOTREACHED*/ ! 186: return; ! 187: } ! 188: ! 189: ip_lock(exc_port); ! 190: itk_unlock(task); ! 191: if (!ip_active(exc_port)) { ! 192: ip_unlock(exc_port); ! 193: exception_no_server(); ! 194: /*NOTREACHED*/ ! 195: return; ! 196: } ! 197: ! 198: /* ! 199: * Make a naked send right for the exception port. ! 200: */ ! 201: ! 202: ip_reference(exc_port); ! 203: exc_port->ip_srights++; ! 204: ip_unlock(exc_port); ! 205: ! 206: /* ! 207: * This is the thread's last chance. ! 208: * Clear the saved exception state. ! 209: */ ! 210: ! 211: self->ith_exc = KERN_SUCCESS; ! 212: ! 213: exception_raise(exc_port, ! 214: retrieve_thread_self_fast(self), ! 215: retrieve_task_self_fast(task), ! 216: _exception, code, subcode); ! 217: /*NOTREACHED*/ ! 218: } ! 219: ! 220: /* ! 221: * Routine: exception_no_server ! 222: * Purpose: ! 223: * The current thread took an exception, ! 224: * and no exception server took responsibility ! 225: * for the exception. So good bye, charlie. ! 226: * Conditions: ! 227: * Nothing locked and no resources held. ! 228: * Called from an exception context, so ! 229: * thread_kdb_return is possible. ! 230: * Returns: ! 231: * Doesn't return. ! 232: */ ! 233: ! 234: void ! 235: exception_no_server() ! 236: { ! 237: register ipc_thread_t self = current_thread(); ! 238: ! 239: /* ! 240: * If this thread is being terminated, cooperate. ! 241: */ ! 242: ! 243: while (thread_should_halt(self)) ! 244: thread_halt_self(); ! 245: ! 246: ! 247: #if 0 ! 248: if (thread_suspend (self) == KERN_SUCCESS) ! 249: thread_exception_return (); ! 250: #endif ! 251: ! 252: #if MACH_KDB ! 253: if (debug_user_with_kdb) { ! 254: /* ! 255: * Debug the exception with kdb. ! 256: * If kdb handles the exception, ! 257: * then thread_kdb_return won't return. ! 258: */ ! 259: ! 260: db_printf("No exception server, calling kdb...\n"); ! 261: thread_kdb_return(); ! 262: } ! 263: #endif /* MACH_KDB */ ! 264: ! 265: /* ! 266: * All else failed; terminate task. ! 267: */ ! 268: ! 269: (void) task_terminate(self->task); ! 270: thread_halt_self(); ! 271: /*NOTREACHED*/ ! 272: } ! 273: ! 274: #define MACH_EXCEPTION_ID 2400 /* from mach/exc.defs */ ! 275: #define MACH_EXCEPTION_REPLY_ID (MACH_EXCEPTION_ID + 100) ! 276: ! 277: struct mach_exception { ! 278: mach_msg_header_t Head; ! 279: mach_msg_type_t threadType; ! 280: mach_port_t thread; ! 281: mach_msg_type_t taskType; ! 282: mach_port_t task; ! 283: mach_msg_type_t exceptionType; ! 284: integer_t exception; ! 285: mach_msg_type_t codeType; ! 286: integer_t code; ! 287: mach_msg_type_t subcodeType; ! 288: integer_t subcode; ! 289: }; ! 290: ! 291: #define INTEGER_T_SIZE_IN_BITS (8 * sizeof(integer_t)) ! 292: #define INTEGER_T_TYPE MACH_MSG_TYPE_INTEGER_T ! 293: /* in mach/machine/vm_types.h */ ! 294: ! 295: mach_msg_type_t exc_port_proto = { ! 296: /* msgt_name = */ MACH_MSG_TYPE_PORT_SEND, ! 297: /* msgt_size = */ PORT_T_SIZE_IN_BITS, ! 298: /* msgt_number = */ 1, ! 299: /* msgt_inline = */ TRUE, ! 300: /* msgt_longform = */ FALSE, ! 301: /* msgt_deallocate = */ FALSE, ! 302: /* msgt_unused = */ 0 ! 303: }; ! 304: ! 305: mach_msg_type_t exc_code_proto = { ! 306: /* msgt_name = */ INTEGER_T_TYPE, ! 307: /* msgt_size = */ INTEGER_T_SIZE_IN_BITS, ! 308: /* msgt_number = */ 1, ! 309: /* msgt_inline = */ TRUE, ! 310: /* msgt_longform = */ FALSE, ! 311: /* msgt_deallocate = */ FALSE, ! 312: /* msgt_unused = */ 0 ! 313: }; ! 314: ! 315: /* ! 316: * Routine: exception_raise ! 317: * Purpose: ! 318: * Make an exception_raise up-call to an exception server. ! 319: * ! 320: * dest_port must be a valid naked send right. ! 321: * thread_port and task_port are naked send rights. ! 322: * All three are always consumed. ! 323: * ! 324: * self->ith_exc, self->ith_exc_code, self->ith_exc_subcode ! 325: * must be appropriately initialized. ! 326: * Conditions: ! 327: * Nothing locked. We are being called in an exception context, ! 328: * so thread_exception_return may be called. ! 329: * Returns: ! 330: * Doesn't return. ! 331: */ ! 332: ! 333: int exception_raise_misses = 0; ! 334: ! 335: void ! 336: exception_raise(dest_port, thread_port, task_port, ! 337: _exception, code, subcode) ! 338: ipc_port_t dest_port; ! 339: ipc_port_t thread_port; ! 340: ipc_port_t task_port; ! 341: integer_t _exception, code, subcode; ! 342: { ! 343: ipc_thread_t self = current_thread(); ! 344: ipc_thread_t receiver; ! 345: ipc_port_t reply_port; ! 346: ipc_mqueue_t dest_mqueue; ! 347: ipc_mqueue_t reply_mqueue; ! 348: ipc_kmsg_t kmsg; ! 349: mach_msg_return_t mr; ! 350: ! 351: assert(IP_VALID(dest_port)); ! 352: ! 353: /* ! 354: * We will eventually need a message buffer. ! 355: * Grab the buffer now, while nothing is locked. ! 356: * This buffer will get handed to the exception server, ! 357: * and it will give the buffer back with its reply. ! 358: */ ! 359: ! 360: kmsg = ikm_cache(); ! 361: if (kmsg != IKM_NULL) { ! 362: ikm_cache() = IKM_NULL; ! 363: ikm_check_initialized(kmsg, IKM_SAVED_KMSG_SIZE); ! 364: } else { ! 365: kmsg = ikm_alloc(IKM_SAVED_MSG_SIZE); ! 366: if (kmsg == IKM_NULL) ! 367: panic("exception_raise"); ! 368: ikm_init(kmsg, IKM_SAVED_MSG_SIZE); ! 369: } ! 370: ! 371: /* ! 372: * We need a reply port for the RPC. ! 373: * Check first for a cached port. ! 374: */ ! 375: ! 376: ith_lock(self); ! 377: assert(self->ith_self != IP_NULL); ! 378: ! 379: reply_port = self->ith_rpc_reply; ! 380: if (reply_port == IP_NULL) { ! 381: ith_unlock(self); ! 382: reply_port = ipc_port_alloc_reply(); ! 383: ith_lock(self); ! 384: if ((reply_port == IP_NULL) || ! 385: (self->ith_rpc_reply != IP_NULL)) ! 386: panic("exception_raise"); ! 387: self->ith_rpc_reply = reply_port; ! 388: } ! 389: ! 390: ip_lock(reply_port); ! 391: assert(ip_active(reply_port)); ! 392: ith_unlock(self); ! 393: ! 394: /* ! 395: * Make a naked send-once right for the reply port, ! 396: * to hand to the exception server. ! 397: * Make an extra reference for the reply port, ! 398: * to receive on. This protects us against ! 399: * mach_msg_abort_rpc. ! 400: */ ! 401: ! 402: reply_port->ip_sorights++; ! 403: ip_reference(reply_port); ! 404: ! 405: ip_reference(reply_port); ! 406: self->ith_port = reply_port; ! 407: ! 408: reply_mqueue = &reply_port->ip_messages; ! 409: imq_lock(reply_mqueue); ! 410: assert(ipc_kmsg_queue_empty(&reply_mqueue->imq_messages)); ! 411: ip_unlock(reply_port); ! 412: ! 413: /* ! 414: * Make sure we can queue to the destination port. ! 415: */ ! 416: ! 417: if (!ip_lock_try(dest_port)) { ! 418: imq_unlock(reply_mqueue); ! 419: goto slow_exception_raise; ! 420: } ! 421: ! 422: if (!ip_active(dest_port) || ! 423: #if NORMA_IPC ! 424: IP_NORMA_IS_PROXY(dest_port) || ! 425: #endif /* NORMA_IPC */ ! 426: (dest_port->ip_receiver == ipc_space_kernel)) { ! 427: imq_unlock(reply_mqueue); ! 428: ip_unlock(dest_port); ! 429: goto slow_exception_raise; ! 430: } ! 431: ! 432: /* ! 433: * Find the destination message queue. ! 434: */ ! 435: ! 436: { ! 437: register ipc_pset_t dest_pset; ! 438: ! 439: dest_pset = dest_port->ip_pset; ! 440: if (dest_pset == IPS_NULL) ! 441: dest_mqueue = &dest_port->ip_messages; ! 442: else ! 443: dest_mqueue = &dest_pset->ips_messages; ! 444: } ! 445: ! 446: if (!imq_lock_try(dest_mqueue)) { ! 447: imq_unlock(reply_mqueue); ! 448: ip_unlock(dest_port); ! 449: goto slow_exception_raise; ! 450: } ! 451: ! 452: /* ! 453: * Safe to unlock dest_port, because we hold ! 454: * dest_mqueue locked. We never bother changing ! 455: * dest_port->ip_msgcount. ! 456: */ ! 457: ! 458: ip_unlock(dest_port); ! 459: ! 460: receiver = ipc_thread_queue_first(&dest_mqueue->imq_threads); ! 461: if ((receiver == ITH_NULL) || ! 462: !((receiver->swap_func == (void (*)()) mach_msg_continue) || ! 463: ((receiver->swap_func == ! 464: (void (*)()) mach_msg_receive_continue) && ! 465: (sizeof(struct mach_exception) <= receiver->ith_msize) && ! 466: ((receiver->ith_option & MACH_RCV_NOTIFY) == 0))) || ! 467: !thread_handoff(self, exception_raise_continue, receiver)) { ! 468: imq_unlock(reply_mqueue); ! 469: imq_unlock(dest_mqueue); ! 470: goto slow_exception_raise; ! 471: } ! 472: counter(c_exception_raise_block++); ! 473: ! 474: assert(current_thread() == receiver); ! 475: ! 476: /* ! 477: * We need to finish preparing self for its ! 478: * time asleep in reply_mqueue. self is left ! 479: * holding the extra ref for reply_port. ! 480: */ ! 481: ! 482: ipc_thread_enqueue_macro(&reply_mqueue->imq_threads, self); ! 483: self->ith_state = MACH_RCV_IN_PROGRESS; ! 484: self->ith_msize = MACH_MSG_SIZE_MAX; ! 485: imq_unlock(reply_mqueue); ! 486: ! 487: /* ! 488: * Finish extracting receiver from dest_mqueue. ! 489: */ ! 490: ! 491: ipc_thread_rmqueue_first_macro( ! 492: &dest_mqueue->imq_threads, receiver); ! 493: imq_unlock(dest_mqueue); ! 494: ! 495: /* ! 496: * Release the receiver's reference for his object. ! 497: */ ! 498: { ! 499: register ipc_object_t object = receiver->ith_object; ! 500: ! 501: io_lock(object); ! 502: io_release(object); ! 503: io_check_unlock(object); ! 504: } ! 505: ! 506: { ! 507: register struct mach_exception *exc = ! 508: (struct mach_exception *) &kmsg->ikm_header; ! 509: ipc_space_t space = receiver->task->itk_space; ! 510: ! 511: /* ! 512: * We are running as the receiver now. We hold ! 513: * the following resources, which must be consumed: ! 514: * kmsg, send-once right for reply_port ! 515: * send rights for dest_port, thread_port, task_port ! 516: * Synthesize a kmsg for copyout to the receiver. ! 517: */ ! 518: ! 519: exc->Head.msgh_bits = (MACH_MSGH_BITS(MACH_MSG_TYPE_PORT_SEND_ONCE, ! 520: MACH_MSG_TYPE_PORT_SEND) | ! 521: MACH_MSGH_BITS_COMPLEX); ! 522: exc->Head.msgh_size = sizeof *exc; ! 523: /* exc->Head.msgh_remote_port later */ ! 524: /* exc->Head.msgh_local_port later */ ! 525: exc->Head.msgh_seqno = 0; ! 526: exc->Head.msgh_id = MACH_EXCEPTION_ID; ! 527: exc->threadType = exc_port_proto; ! 528: /* exc->thread later */ ! 529: exc->taskType = exc_port_proto; ! 530: /* exc->task later */ ! 531: exc->exceptionType = exc_code_proto; ! 532: exc->exception = _exception; ! 533: exc->codeType = exc_code_proto; ! 534: exc->code = code; ! 535: exc->subcodeType = exc_code_proto; ! 536: exc->subcode = subcode; ! 537: ! 538: /* ! 539: * Check that the receiver can handle the message. ! 540: */ ! 541: ! 542: if (receiver->ith_rcv_size < sizeof(struct mach_exception)) { ! 543: /* ! 544: * ipc_kmsg_destroy is a handy way to consume ! 545: * the resources we hold, but it requires setup. ! 546: */ ! 547: ! 548: exc->Head.msgh_bits = ! 549: (MACH_MSGH_BITS(MACH_MSG_TYPE_PORT_SEND, ! 550: MACH_MSG_TYPE_PORT_SEND_ONCE) | ! 551: MACH_MSGH_BITS_COMPLEX); ! 552: exc->Head.msgh_remote_port = (mach_port_t) dest_port; ! 553: exc->Head.msgh_local_port = (mach_port_t) reply_port; ! 554: exc->thread = (mach_port_t) thread_port; ! 555: exc->task = (mach_port_t) task_port; ! 556: ! 557: ipc_kmsg_destroy(kmsg); ! 558: thread_syscall_return(MACH_RCV_TOO_LARGE); ! 559: /*NOTREACHED*/ ! 560: } ! 561: ! 562: is_write_lock(space); ! 563: assert(space->is_active); ! 564: ! 565: /* ! 566: * To do an atomic copyout, need simultaneous ! 567: * locks on both ports and the space. ! 568: */ ! 569: ! 570: ip_lock(dest_port); ! 571: if (!ip_active(dest_port) || ! 572: !ip_lock_try(reply_port)) { ! 573: abort_copyout: ! 574: ip_unlock(dest_port); ! 575: is_write_unlock(space); ! 576: ! 577: /* ! 578: * Oh well, we have to do the header the slow way. ! 579: * First make it look like it's in-transit. ! 580: */ ! 581: ! 582: exc->Head.msgh_bits = ! 583: (MACH_MSGH_BITS(MACH_MSG_TYPE_PORT_SEND, ! 584: MACH_MSG_TYPE_PORT_SEND_ONCE) | ! 585: MACH_MSGH_BITS_COMPLEX); ! 586: exc->Head.msgh_remote_port = (mach_port_t) dest_port; ! 587: exc->Head.msgh_local_port = (mach_port_t) reply_port; ! 588: ! 589: mr = ipc_kmsg_copyout_header(&exc->Head, space, ! 590: MACH_PORT_NULL); ! 591: if (mr == MACH_MSG_SUCCESS) ! 592: goto copyout_body; ! 593: ! 594: /* ! 595: * Ack! Prepare for ipc_kmsg_copyout_dest. ! 596: * It will consume thread_port and task_port. ! 597: */ ! 598: ! 599: exc->thread = (mach_port_t) thread_port; ! 600: exc->task = (mach_port_t) task_port; ! 601: ! 602: ipc_kmsg_copyout_dest(kmsg, space); ! 603: (void) ipc_kmsg_put(receiver->ith_msg, kmsg, ! 604: sizeof(mach_msg_header_t)); ! 605: thread_syscall_return(mr); ! 606: /*NOTREACHED*/ ! 607: } ! 608: ! 609: if (!ip_active(reply_port)) { ! 610: ip_unlock(reply_port); ! 611: goto abort_copyout; ! 612: } ! 613: ! 614: assert(reply_port->ip_sorights > 0); ! 615: ip_unlock(reply_port); ! 616: ! 617: { ! 618: register ipc_entry_t table; ! 619: register ipc_entry_t entry; ! 620: register mach_port_index_t index; ! 621: ! 622: /* optimized ipc_entry_get */ ! 623: ! 624: table = space->is_table; ! 625: index = table->ie_next; ! 626: ! 627: if (index == 0) ! 628: goto abort_copyout; ! 629: ! 630: entry = &table[index]; ! 631: table->ie_next = entry->ie_next; ! 632: entry->ie_request = 0; ! 633: ! 634: { ! 635: register mach_port_gen_t gen; ! 636: ! 637: assert((entry->ie_bits &~ IE_BITS_GEN_MASK) == 0); ! 638: gen = entry->ie_bits + IE_BITS_GEN_ONE; ! 639: ! 640: exc->Head.msgh_remote_port = MACH_PORT_MAKE(index, gen); ! 641: ! 642: /* optimized ipc_right_copyout */ ! 643: ! 644: entry->ie_bits = gen | (MACH_PORT_TYPE_SEND_ONCE | 1); ! 645: } ! 646: ! 647: entry->ie_object = (ipc_object_t) reply_port; ! 648: is_write_unlock(space); ! 649: } ! 650: ! 651: /* optimized ipc_object_copyout_dest */ ! 652: ! 653: assert(dest_port->ip_srights > 0); ! 654: ip_release(dest_port); ! 655: ! 656: exc->Head.msgh_local_port = ! 657: ((dest_port->ip_receiver == space) ? ! 658: dest_port->ip_receiver_name : MACH_PORT_NULL); ! 659: ! 660: if ((--dest_port->ip_srights == 0) && ! 661: (dest_port->ip_nsrequest != IP_NULL)) { ! 662: ipc_port_t nsrequest; ! 663: mach_port_mscount_t mscount; ! 664: ! 665: /* a rather rare case */ ! 666: ! 667: nsrequest = dest_port->ip_nsrequest; ! 668: mscount = dest_port->ip_mscount; ! 669: dest_port->ip_nsrequest = IP_NULL; ! 670: ip_unlock(dest_port); ! 671: ! 672: ipc_notify_no_senders(nsrequest, mscount); ! 673: } else ! 674: ip_unlock(dest_port); ! 675: ! 676: copyout_body: ! 677: /* ! 678: * Optimized version of ipc_kmsg_copyout_body, ! 679: * to handle the two ports in the body. ! 680: */ ! 681: ! 682: mr = (ipc_kmsg_copyout_object(space, (ipc_object_t) thread_port, ! 683: MACH_MSG_TYPE_PORT_SEND, &exc->thread) | ! 684: ipc_kmsg_copyout_object(space, (ipc_object_t) task_port, ! 685: MACH_MSG_TYPE_PORT_SEND, &exc->task)); ! 686: if (mr != MACH_MSG_SUCCESS) { ! 687: (void) ipc_kmsg_put(receiver->ith_msg, kmsg, ! 688: kmsg->ikm_header.msgh_size); ! 689: thread_syscall_return(mr | MACH_RCV_BODY_ERROR); ! 690: /*NOTREACHED*/ ! 691: } ! 692: } ! 693: ! 694: /* ! 695: * Optimized version of ipc_kmsg_put. ! 696: * We must check ikm_cache after copyoutmsg. ! 697: */ ! 698: ! 699: ikm_check_initialized(kmsg, kmsg->ikm_size); ! 700: assert(kmsg->ikm_size == IKM_SAVED_KMSG_SIZE); ! 701: ! 702: if (copyoutmsg((vm_offset_t) &kmsg->ikm_header, (vm_offset_t)receiver->ith_msg, ! 703: sizeof(struct mach_exception)) || ! 704: (ikm_cache() != IKM_NULL)) { ! 705: mr = ipc_kmsg_put(receiver->ith_msg, kmsg, ! 706: kmsg->ikm_header.msgh_size); ! 707: thread_syscall_return(mr); ! 708: /*NOTREACHED*/ ! 709: } ! 710: ! 711: ikm_cache() = kmsg; ! 712: thread_syscall_return(MACH_MSG_SUCCESS); ! 713: /*NOTREACHED*/ ! 714: #ifndef __GNUC__ ! 715: return; /* help for the compiler */ ! 716: #endif ! 717: ! 718: slow_exception_raise: { ! 719: register struct mach_exception *exc = ! 720: (struct mach_exception *) &kmsg->ikm_header; ! 721: ipc_kmsg_t reply_kmsg; ! 722: mach_port_seqno_t reply_seqno; ! 723: ! 724: exception_raise_misses++; ! 725: ! 726: /* ! 727: * We hold the following resources, which must be consumed: ! 728: * kmsg, send-once right and ref for reply_port ! 729: * send rights for dest_port, thread_port, task_port ! 730: * Synthesize a kmsg to send. ! 731: */ ! 732: ! 733: exc->Head.msgh_bits = (MACH_MSGH_BITS(MACH_MSG_TYPE_PORT_SEND, ! 734: MACH_MSG_TYPE_PORT_SEND_ONCE) | ! 735: MACH_MSGH_BITS_COMPLEX); ! 736: exc->Head.msgh_size = sizeof *exc; ! 737: exc->Head.msgh_remote_port = (mach_port_t) dest_port; ! 738: exc->Head.msgh_local_port = (mach_port_t) reply_port; ! 739: exc->Head.msgh_seqno = 0; ! 740: exc->Head.msgh_id = MACH_EXCEPTION_ID; ! 741: exc->threadType = exc_port_proto; ! 742: exc->thread = (mach_port_t) thread_port; ! 743: exc->taskType = exc_port_proto; ! 744: exc->task = (mach_port_t) task_port; ! 745: exc->exceptionType = exc_code_proto; ! 746: exc->exception = _exception; ! 747: exc->codeType = exc_code_proto; ! 748: exc->code = code; ! 749: exc->subcodeType = exc_code_proto; ! 750: exc->subcode = subcode; ! 751: ! 752: ipc_mqueue_send_always(kmsg); ! 753: ! 754: /* ! 755: * We are left with a ref for reply_port, ! 756: * which we use to receive the reply message. ! 757: */ ! 758: ! 759: ip_lock(reply_port); ! 760: if (!ip_active(reply_port)) { ! 761: ip_unlock(reply_port); ! 762: exception_raise_continue_slow(MACH_RCV_PORT_DIED, IKM_NULL, /*dummy*/0); ! 763: /*NOTREACHED*/ ! 764: return; ! 765: } ! 766: ! 767: imq_lock(reply_mqueue); ! 768: ip_unlock(reply_port); ! 769: ! 770: mr = ipc_mqueue_receive(reply_mqueue, MACH_MSG_OPTION_NONE, ! 771: MACH_MSG_SIZE_MAX, ! 772: MACH_MSG_TIMEOUT_NONE, ! 773: FALSE, exception_raise_continue, ! 774: &reply_kmsg, &reply_seqno); ! 775: /* reply_mqueue is unlocked */ ! 776: ! 777: exception_raise_continue_slow(mr, reply_kmsg, reply_seqno); ! 778: /*NOTREACHED*/ ! 779: } ! 780: } ! 781: ! 782: mach_msg_type_t exc_RetCode_proto = { ! 783: /* msgt_name = */ MACH_MSG_TYPE_INTEGER_32, ! 784: /* msgt_size = */ 32, ! 785: /* msgt_number = */ 1, ! 786: /* msgt_inline = */ TRUE, ! 787: /* msgt_longform = */ FALSE, ! 788: /* msgt_deallocate = */ FALSE, ! 789: /* msgt_unused = */ 0 ! 790: }; ! 791: ! 792: /* ! 793: * Routine: exception_parse_reply ! 794: * Purpose: ! 795: * Parse and consume an exception reply message. ! 796: * Conditions: ! 797: * The destination port right has already been consumed. ! 798: * The message buffer and anything else in it is consumed. ! 799: * Returns: ! 800: * The reply return code. ! 801: */ ! 802: ! 803: kern_return_t ! 804: exception_parse_reply(kmsg) ! 805: ipc_kmsg_t kmsg; ! 806: { ! 807: register mig_reply_header_t *msg = ! 808: (mig_reply_header_t *) &kmsg->ikm_header; ! 809: kern_return_t kr; ! 810: ! 811: if ((msg->Head.msgh_bits != ! 812: MACH_MSGH_BITS(MACH_MSG_TYPE_PORT_SEND_ONCE, 0)) || ! 813: (msg->Head.msgh_size != sizeof *msg) || ! 814: (msg->Head.msgh_id != MACH_EXCEPTION_REPLY_ID) || ! 815: (* (int *) &msg->RetCodeType != * (int *) &exc_RetCode_proto)) { ! 816: /* ! 817: * Bozo user sent us a misformatted reply. ! 818: */ ! 819: ! 820: kmsg->ikm_header.msgh_remote_port = MACH_PORT_NULL; ! 821: ipc_kmsg_destroy(kmsg); ! 822: return MIG_REPLY_MISMATCH; ! 823: } ! 824: ! 825: kr = msg->RetCode; ! 826: ! 827: if ((kmsg->ikm_size == IKM_SAVED_KMSG_SIZE) && ! 828: (ikm_cache() == IKM_NULL)) ! 829: ikm_cache() = kmsg; ! 830: else ! 831: ikm_free(kmsg); ! 832: ! 833: return kr; ! 834: } ! 835: ! 836: /* ! 837: * Routine: exception_raise_continue ! 838: * Purpose: ! 839: * Continue after blocking for an exception. ! 840: * Conditions: ! 841: * Nothing locked. We are running on a new kernel stack, ! 842: * with the exception state saved in the thread. From here ! 843: * control goes back to user space. ! 844: * Returns: ! 845: * Doesn't return. ! 846: */ ! 847: ! 848: void ! 849: exception_raise_continue() ! 850: { ! 851: ipc_thread_t self = current_thread(); ! 852: ipc_port_t reply_port = self->ith_port; ! 853: ipc_mqueue_t reply_mqueue = &reply_port->ip_messages; ! 854: ipc_kmsg_t kmsg; ! 855: mach_port_seqno_t seqno; ! 856: mach_msg_return_t mr; ! 857: ! 858: mr = ipc_mqueue_receive(reply_mqueue, MACH_MSG_OPTION_NONE, ! 859: MACH_MSG_SIZE_MAX, ! 860: MACH_MSG_TIMEOUT_NONE, ! 861: TRUE, exception_raise_continue, ! 862: &kmsg, &seqno); ! 863: /* reply_mqueue is unlocked */ ! 864: ! 865: exception_raise_continue_slow(mr, kmsg, seqno); ! 866: /*NOTREACHED*/ ! 867: } ! 868: ! 869: /* ! 870: * Routine: exception_raise_continue_slow ! 871: * Purpose: ! 872: * Continue after finishing an ipc_mqueue_receive ! 873: * for an exception reply message. ! 874: * Conditions: ! 875: * Nothing locked. We hold a ref for reply_port. ! 876: * Returns: ! 877: * Doesn't return. ! 878: */ ! 879: ! 880: void ! 881: exception_raise_continue_slow(mr, kmsg, seqno) ! 882: mach_msg_return_t mr; ! 883: ipc_kmsg_t kmsg; ! 884: mach_port_seqno_t seqno; ! 885: { ! 886: ipc_thread_t self = current_thread(); ! 887: ipc_port_t reply_port = self->ith_port; ! 888: ipc_mqueue_t reply_mqueue = &reply_port->ip_messages; ! 889: ! 890: while (mr == MACH_RCV_INTERRUPTED) { ! 891: /* ! 892: * Somebody is trying to force this thread ! 893: * to a clean point. We must cooperate ! 894: * and then resume the receive. ! 895: */ ! 896: ! 897: while (thread_should_halt(self)) { ! 898: /* don't terminate while holding a reference */ ! 899: if (self->ast & AST_TERMINATE) ! 900: ipc_port_release(reply_port); ! 901: thread_halt_self(); ! 902: } ! 903: ! 904: ip_lock(reply_port); ! 905: if (!ip_active(reply_port)) { ! 906: ip_unlock(reply_port); ! 907: mr = MACH_RCV_PORT_DIED; ! 908: break; ! 909: } ! 910: ! 911: imq_lock(reply_mqueue); ! 912: ip_unlock(reply_port); ! 913: ! 914: mr = ipc_mqueue_receive(reply_mqueue, MACH_MSG_OPTION_NONE, ! 915: MACH_MSG_SIZE_MAX, ! 916: MACH_MSG_TIMEOUT_NONE, ! 917: FALSE, exception_raise_continue, ! 918: &kmsg, &seqno); ! 919: /* reply_mqueue is unlocked */ ! 920: } ! 921: ipc_port_release(reply_port); ! 922: ! 923: assert((mr == MACH_MSG_SUCCESS) || ! 924: (mr == MACH_RCV_PORT_DIED)); ! 925: ! 926: if (mr == MACH_MSG_SUCCESS) { ! 927: /* ! 928: * Consume the reply message. ! 929: */ ! 930: ! 931: ipc_port_release_sonce(reply_port); ! 932: mr = exception_parse_reply(kmsg); ! 933: } ! 934: ! 935: if ((mr == KERN_SUCCESS) || ! 936: (mr == MACH_RCV_PORT_DIED)) { ! 937: thread_exception_return(); ! 938: /*NOTREACHED*/ ! 939: return; ! 940: } ! 941: ! 942: if (self->ith_exc != KERN_SUCCESS) { ! 943: exception_try_task(self->ith_exc, ! 944: self->ith_exc_code, ! 945: self->ith_exc_subcode); ! 946: /*NOTREACHED*/ ! 947: return; ! 948: } ! 949: ! 950: exception_no_server(); ! 951: /*NOTREACHED*/ ! 952: } ! 953: ! 954: /* ! 955: * Routine: exception_raise_continue_fast ! 956: * Purpose: ! 957: * Special-purpose fast continuation for exceptions. ! 958: * Conditions: ! 959: * reply_port is locked and alive. ! 960: * kmsg is our reply message. ! 961: * Returns: ! 962: * Doesn't return. ! 963: */ ! 964: ! 965: void ! 966: exception_raise_continue_fast(reply_port, kmsg) ! 967: ipc_port_t reply_port; ! 968: ipc_kmsg_t kmsg; ! 969: { ! 970: ipc_thread_t self = current_thread(); ! 971: kern_return_t kr; ! 972: ! 973: assert(ip_active(reply_port)); ! 974: assert(reply_port == self->ith_port); ! 975: assert(reply_port == (ipc_port_t) kmsg->ikm_header.msgh_remote_port); ! 976: assert(MACH_MSGH_BITS_REMOTE(kmsg->ikm_header.msgh_bits) == ! 977: MACH_MSG_TYPE_PORT_SEND_ONCE); ! 978: ! 979: /* ! 980: * Release the send-once right (from the message header) ! 981: * and the saved reference (from self->ith_port). ! 982: */ ! 983: ! 984: reply_port->ip_sorights--; ! 985: ip_release(reply_port); ! 986: ip_release(reply_port); ! 987: ip_unlock(reply_port); ! 988: ! 989: /* ! 990: * Consume the reply message. ! 991: */ ! 992: ! 993: kr = exception_parse_reply(kmsg); ! 994: if (kr == KERN_SUCCESS) { ! 995: thread_exception_return(); ! 996: /*NOTREACHED*/ ! 997: return; /* help for the compiler */ ! 998: } ! 999: ! 1000: if (self->ith_exc != KERN_SUCCESS) { ! 1001: exception_try_task(self->ith_exc, ! 1002: self->ith_exc_code, ! 1003: self->ith_exc_subcode); ! 1004: /*NOTREACHED*/ ! 1005: } ! 1006: ! 1007: exception_no_server(); ! 1008: /*NOTREACHED*/ ! 1009: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.