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