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