![[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 XNU] / XNU / osfmk / kern|
Return to exception.c CVS log | Up to [Apple XNU] / XNU / osfmk / kern |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /*
23: * @OSF_COPYRIGHT@
24: */
25: /*
26: * Mach Operating System
27: * Copyright (c) 1991,1990,1989,1988,1987 Carnegie Mellon University
28: * All Rights Reserved.
29: *
30: * Permission to use, copy, modify and distribute this software and its
31: * documentation is hereby granted, provided that both the copyright
32: * notice and this permission notice appear in all copies of the
33: * software, derivative works or modified versions, and any portions
34: * thereof, and that both notices appear in supporting documentation.
35: *
36: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
37: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
38: * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
39: *
40: * Carnegie Mellon requests users of this software to return to
41: *
42: * Software Distribution Coordinator or [email protected]
43: * School of Computer Science
44: * Carnegie Mellon University
45: * Pittsburgh PA 15213-3890
46: *
47: * any improvements or extensions that they make and grant Carnegie Mellon
48: * the rights to redistribute these changes.
49: */
50: /*
51: */
52:
53: #include <mach_kdb.h>
54:
55: #include <mach/boolean.h>
56: #include <mach/kern_return.h>
57: #include <mach/message.h>
58: #include <mach/port.h>
59: #include <mach/mig_errors.h>
60: #include <mach/thread_status.h>
61: #include <mach/exception_types.h>
62: #include <ipc/port.h>
63: #include <ipc/ipc_entry.h>
64: #include <ipc/ipc_object.h>
65: #include <ipc/ipc_notify.h>
66: #include <ipc/ipc_space.h>
67: #include <ipc/ipc_pset.h>
68: #include <ipc/ipc_machdep.h>
69: #include <kern/etap_macros.h>
70: #include <kern/counters.h>
71: #include <kern/ipc_tt.h>
72: #include <kern/task.h>
73: #include <kern/thread.h>
74: #include <kern/thread_swap.h>
75: #include <kern/processor.h>
76: #include <kern/sched.h>
77: #include <kern/sched_prim.h>
78: #include <kern/host.h>
79: #include <kern/misc_protos.h>
80: #include <string.h>
81: #include <mach/exc.h> /* JMM - will become exception.h */
82: #include <machine/machine_rpc.h>
83:
84: #if MACH_KDB
85: #include <ddb/db_trap.h>
86: #endif /* MACH_KDB */
87:
88: /*
89: * Forward declarations
90: */
91: void exception_try_task(
92: exception_type_t exception,
93: exception_data_t code,
94: mach_msg_type_number_t codeCnt);
95:
96: void exception_no_server(void);
97:
98: kern_return_t alert_exception_try_task(
99: exception_type_t exception,
100: exception_data_t code,
101: int codeCnt);
102:
103: #if MACH_KDB
104:
105: #include <ddb/db_output.h>
106:
107: #if iPSC386 || iPSC860
108: boolean_t debug_user_with_kdb = TRUE;
109: #else
110: boolean_t debug_user_with_kdb = FALSE;
111: #endif
112:
113: #endif /* MACH_KDB */
114:
115: unsigned long c_thr_exc_raise = 0;
116: unsigned long c_thr_exc_raise_state = 0;
117: unsigned long c_thr_exc_raise_state_id = 0;
118: unsigned long c_tsk_exc_raise = 0;
119: unsigned long c_tsk_exc_raise_state = 0;
120: unsigned long c_tsk_exc_raise_state_id = 0;
121:
122:
123: #ifdef MACHINE_FAST_EXCEPTION /* from <machine/thread.h> if at all */
124: /*
125: * This is the fast, MD code, with lots of stuff in-lined.
126: */
127:
128: extern int switch_act_swapins;
129:
130: #ifdef i386
131: /*
132: * Temporary: controls the syscall copyin optimization.
133: * If TRUE, the exception function will copy in the first n
134: * words from the stack of the user thread and store it in
135: * the saved state, so that the server doesn't have to do
136: * this.
137: */
138: boolean_t syscall_exc_copyin = TRUE;
139: #endif
140:
141: /*
142: * Routine: exception
143: * Purpose:
144: * The current thread caught an exception.
145: * We make an up-call to the thread's exception server.
146: * Conditions:
147: * Nothing locked and no resources held.
148: * Called from an exception context, so
149: * thread_exception_return and thread_kdb_return
150: * are possible.
151: * Returns:
152: * Doesn't return.
153: */
154:
155: void
156: exception(
157: exception_type_t exception,
158: exception_data_t code,
159: mach_msg_type_number_t codeCnt )
160: {
161: thread_t self = current_thread();
162: thread_act_t a_self = self->top_act;
163: thread_act_t cln_act;
164: ipc_port_t exc_port;
165: int i;
166: struct exception_action *excp = &a_self->exc_actions[exception];
167: int flavor;
168: kern_return_t kr;
169:
170: assert(exception != EXC_RPC_ALERT);
171:
172: self->ith_scatter_list = MACH_MSG_BODY_NULL;
173:
174: /*
175: * Optimized version of retrieve_thread_exception.
176: */
177:
178: act_lock(a_self);
179: assert(a_self->ith_self != IP_NULL);
180: exc_port = excp->port;
181: if (!IP_VALID(exc_port)) {
182: act_unlock(a_self);
183: exception_try_task(exception, code, codeCnt);
184: /*NOTREACHED*/
185: return;
186: }
187: flavor = excp->flavor;
188:
189: #ifdef i386
190: /* For this flavor, we must copy in the first few procedure call
191: * args from the user's stack, since that is part of the important
192: * state in a syscall exception (this is for performance -- we
193: * can do the copyin much faster than the server, even if it is
194: * kernel-loaded):
195: */
196: if (flavor == i386_SAVED_STATE) {
197: struct i386_saved_state *statep = (struct i386_saved_state *)
198: act_machine_state_ptr(self->top_act);
199: statep->argv_status = FALSE;
200: if (syscall_exc_copyin && copyin((char *)statep->uesp,
201: (char *)statep->argv,
202: i386_SAVED_ARGV_COUNT * sizeof(int)) == 0) {
203: /* Indicate success for the server: */
204: statep->argv_status = TRUE;
205: }
206: }
207: #endif
208:
209: ETAP_EXCEPTION_PROBE(EVENT_BEGIN, self, exception, code);
210:
211: ip_lock(exc_port);
212: act_unlock(a_self);
213: if (!ip_active(exc_port)) {
214: ip_unlock(exc_port);
215: exception_try_task(exception, code, codeCnt);
216: /*NOTREACHED*/
217: return;
218: }
219:
220: /*
221: * Hold a reference to the port over the exception_raise_* calls
222: * so it can't be destroyed. This seems like overkill, but keeps
223: * the port from disappearing between now and when
224: * ipc_object_copyin_from_kernel is finally called.
225: */
226: ip_reference(exc_port);
227: exc_port->ip_srights++;
228: ip_unlock(exc_port);
229:
230: switch (excp->behavior) {
231: case EXCEPTION_STATE: {
232: mach_msg_type_number_t state_cnt;
233: {
234: natural_t state[ THREAD_MACHINE_STATE_MAX ];
235:
236: state_cnt = state_count[flavor];
237: kr = thread_getstatus(a_self, flavor, state, &state_cnt);
238: if (kr == KERN_SUCCESS) {
239: kr = exception_raise_state(exc_port, exception,
240: code, codeCnt,
241: &flavor,
242: state, state_cnt,
243: state, &state_cnt);
244: if (kr == MACH_MSG_SUCCESS)
245: kr = thread_setstatus(a_self, flavor, state, state_cnt);
246: }
247: }
248:
249: if (kr == KERN_SUCCESS ||
250: kr == MACH_RCV_PORT_DIED) {
251: ETAP_EXCEPTION_PROBE(EVENT_END, self, exception, code);
252: thread_exception_return();
253: /* NOTREACHED*/
254: return;
255: }
256: } break;
257:
258: case EXCEPTION_DEFAULT:
259: c_thr_exc_raise++;
260: kr = exception_raise(exc_port,
261: retrieve_act_self_fast(a_self),
262: retrieve_task_self_fast(a_self->task),
263: exception,
264: code, codeCnt);
265:
266: if (kr == KERN_SUCCESS ||
267: kr == MACH_RCV_PORT_DIED) {
268: ETAP_EXCEPTION_PROBE(EVENT_END, self, exception, code);
269: thread_exception_return();
270: /* NOTREACHED*/
271: return;
272: }
273: break;
274:
275: case EXCEPTION_STATE_IDENTITY: {
276: mach_msg_type_number_t state_cnt;
277: natural_t state[ THREAD_MACHINE_STATE_MAX ];
278:
279: c_thr_exc_raise_state_id++;
280: state_cnt = state_count[flavor];
281: kr = thread_getstatus(a_self, flavor, state, &state_cnt);
282: if (kr == KERN_SUCCESS) {
283: kr = exception_raise_state_identity(exc_port,
284: retrieve_act_self_fast(a_self),
285: retrieve_task_self_fast(a_self->task),
286: exception,
287: code, codeCnt,
288: &flavor,
289: state, state_cnt,
290: state, &state_cnt);
291: if (kr == MACH_MSG_SUCCESS)
292: kr = thread_setstatus(a_self, flavor, state, state_cnt);
293: }
294:
295: if (kr == KERN_SUCCESS ||
296: kr == MACH_RCV_PORT_DIED) {
297: ETAP_EXCEPTION_PROBE(EVENT_END, self, exception, code);
298: thread_exception_return();
299: /* NOTREACHED*/
300: return;
301: }
302: } break;
303: default:
304: panic ("bad behavior!");
305: }/* switch */
306:
307: /*
308: * When a task is being terminated, it's no longer ripped
309: * directly out of the rcv from its "kill me" message, and
310: * so returns here. The following causes it to return out
311: * to the glue code and clean itself up.
312: */
313: if ((self->top_act && !self->top_act->active) ||
314: (self->state & TH_ABORT)) {
315: ETAP_EXCEPTION_PROBE(EVENT_END, self, exception, code);
316: thread_exception_return();
317: }
318:
319: exception_try_task(exception, code, codeCnt);
320: /* NOTREACHED */
321: }
322:
323: /*
324: * We only use the machine-independent exception() routine
325: * if a faster MD version isn't available.
326: */
327: #else /* MACHINE_FAST_EXCEPTION */
328: /*
329: * If continuations are not used/supported, the NOTREACHED comments
330: * below are incorrect. The exception function is expected to return.
331: * So the return statements along the slow paths are important.
332: */
333:
334: /*
335: * Routine: exception
336: * Purpose:
337: * The current thread caught an exception.
338: * We make an up-call to the thread's exception server.
339: * Conditions:
340: * Nothing locked and no resources held.
341: * Called from an exception context, so
342: * thread_exception_return and thread_kdb_return
343: * are possible.
344: * Returns:
345: * Doesn't return.
346: */
347:
348: void
349: exception(
350: exception_type_t exception,
351: exception_data_t code,
352: mach_msg_type_number_t codeCnt)
353: {
354: thread_t self = current_thread();
355: thread_act_t a_self = self->top_act;
356: ipc_port_t exc_port;
357: int i;
358: struct exception_action *excp = &a_self->exc_actions[exception];
359: int flavor;
360: kern_return_t kr;
361:
362: assert(exception != EXC_RPC_ALERT);
363:
364: if (exception == KERN_SUCCESS)
365: panic("exception");
366:
367: self->ith_scatter_list = MACH_MSG_BODY_NULL;
368:
369: /*
370: * Optimized version of retrieve_thread_exception.
371: */
372:
373: act_lock(a_self);
374: assert(a_self->ith_self != IP_NULL);
375: exc_port = excp->port;
376: if (!IP_VALID(exc_port)) {
377: act_unlock(a_self);
378: exception_try_task(exception, code, codeCnt);
379: /*NOTREACHED*/
380: return;
381: }
382: flavor = excp->flavor;
383:
384: ip_lock(exc_port);
385: act_unlock(a_self);
386: if (!ip_active(exc_port)) {
387: ip_unlock(exc_port);
388: exception_try_task(exception, code, codeCnt);
389: /*NOTREACHED*/
390: return;
391: }
392:
393: /*
394: * Hold a reference to the port over the exception_raise_* calls
395: * so it can't be destroyed. This seems like overkill, but keeps
396: * the port from disappearing between now and when
397: * ipc_object_copyin_from_kernel is finally called.
398: */
399: ip_reference(exc_port);
400: exc_port->ip_srights++;
401: ip_unlock(exc_port);
402:
403: switch (excp->behavior) {
404: case EXCEPTION_STATE: {
405: mach_msg_type_number_t state_cnt;
406:
407: c_thr_exc_raise_state++;
408: {
409: natural_t state[ THREAD_MACHINE_STATE_MAX ];
410:
411: state_cnt = state_count[flavor];
412: kr = thread_getstatus(a_self, flavor,
413: (thread_state_t)state,
414: &state_cnt);
415: if (kr == KERN_SUCCESS) {
416: kr = exception_raise_state(exc_port, exception,
417: code, codeCnt,
418: &flavor,
419: state, state_cnt,
420: state, &state_cnt);
421: if (kr == MACH_MSG_SUCCESS)
422: kr = thread_setstatus(a_self, flavor,
423: (thread_state_t)state,
424: state_cnt);
425: }
426: }
427:
428: if (kr == KERN_SUCCESS ||
429: kr == MACH_RCV_PORT_DIED) {
430: thread_exception_return();
431: /*NOTREACHED*/
432: return;
433: }
434: } break;
435:
436: case EXCEPTION_DEFAULT:
437: c_thr_exc_raise++;
438: kr = exception_raise(exc_port,
439: retrieve_act_self_fast(a_self),
440: retrieve_task_self_fast(a_self->task),
441: exception,
442: code, codeCnt);
443:
444: if (kr == KERN_SUCCESS ||
445: kr == MACH_RCV_PORT_DIED) {
446: thread_exception_return();
447: /*NOTREACHED*/
448: return;
449: }
450: break;
451:
452: case EXCEPTION_STATE_IDENTITY: {
453: mach_msg_type_number_t state_cnt;
454: natural_t state[ THREAD_MACHINE_STATE_MAX ];
455:
456: c_thr_exc_raise_state_id++;
457: state_cnt = state_count[flavor];
458: kr = thread_getstatus(a_self, flavor,
459: (thread_state_t)state,
460: &state_cnt);
461: if (kr == KERN_SUCCESS) {
462: kr = exception_raise_state_identity(exc_port,
463: retrieve_act_self_fast(a_self),
464: retrieve_task_self_fast(a_self->task),
465: exception,
466: code, codeCnt,
467: &flavor,
468: state, state_cnt,
469: state, &state_cnt);
470: if (kr == MACH_MSG_SUCCESS)
471: kr = thread_setstatus(a_self, flavor,
472: (thread_state_t)state,
473: state_cnt);
474: }
475:
476: if (kr == KERN_SUCCESS ||
477: kr == MACH_RCV_PORT_DIED) {
478: thread_exception_return();
479: /*NOTREACHED*/
480: return;
481: }
482: } break;
483: default:
484: panic ("bad behavior!");
485: }/* switch */
486:
487: /*
488: * When a task is being terminated, it's no longer ripped
489: * directly out of the rcv from its "kill me" message, and
490: * so returns here. The following causes it to return out
491: * to the glue code and clean itself up.
492: */
493: if ((self->top_act && !self->top_act->active) ||
494: (self->state & TH_ABORT)) {
495: thread_exception_return();
496: /*NOTREACHED*/
497: }
498:
499: exception_try_task(exception, code, codeCnt);
500: /* NOTREACHED */
501: return;
502: }
503: #endif /* defined MACHINE_FAST_EXCEPTION */
504:
505: /*
506: * Routine: exception_try_task
507: * Purpose:
508: * The current thread caught an exception.
509: * We make an up-call to the task's exception server.
510: * Conditions:
511: * Nothing locked and no resources held.
512: * Called from an exception context, so
513: * thread_exception_return and thread_kdb_return
514: * are possible.
515: * Returns:
516: * Doesn't return.
517: */
518:
519: void
520: exception_try_task(
521: exception_type_t exception,
522: exception_data_t code,
523: mach_msg_type_number_t codeCnt)
524: {
525: thread_act_t a_self = current_act();
526: thread_t self = a_self->thread;
527: register task_t task = a_self->task;
528: register ipc_port_t exc_port;
529: int flavor, i;
530: kern_return_t kr;
531:
532: assert(exception != EXC_RPC_ALERT);
533:
534: self->ith_scatter_list = MACH_MSG_BODY_NULL;
535:
536: /*
537: * Optimized version of retrieve_task_exception.
538: */
539:
540: itk_lock(task);
541: assert(task->itk_self != IP_NULL);
542: exc_port = task->exc_actions[exception].port;
543: if (exception == EXC_MACH_SYSCALL && exc_port == realhost.host_self) {
544: itk_unlock(task);
545: restart_mach_syscall(); /* magic ! */
546: /* NOTREACHED */
547: }
548: if (!IP_VALID(exc_port)) {
549: itk_unlock(task);
550: exception_no_server();
551: /*NOTREACHED*/
552: return;
553: }
554: flavor = task->exc_actions[exception].flavor;
555:
556: ip_lock(exc_port);
557: itk_unlock(task);
558: if (!ip_active(exc_port)) {
559: ip_unlock(exc_port);
560: exception_no_server();
561: /*NOTREACHED*/
562: return;
563: }
564:
565: /*
566: * Hold a reference to the port over the exception_raise_* calls
567: * (see longer comment in exception())
568: */
569: ip_reference(exc_port);
570: exc_port->ip_srights++;
571: ip_unlock(exc_port);
572:
573: switch (task->exc_actions[exception].behavior) {
574: case EXCEPTION_STATE: {
575: mach_msg_type_number_t state_cnt;
576: {
577: natural_t state[ THREAD_MACHINE_STATE_MAX ];
578:
579: c_tsk_exc_raise_state++;
580: state_cnt = state_count[flavor];
581: kr = thread_getstatus(a_self, flavor, state, &state_cnt);
582: if (kr == KERN_SUCCESS) {
583: kr = exception_raise_state(exc_port, exception,
584: code, codeCnt,
585: &flavor,
586: state, state_cnt,
587: state, &state_cnt);
588: if (kr == MACH_MSG_SUCCESS)
589: kr = thread_setstatus(a_self, flavor, state, state_cnt);
590: }
591: }
592:
593: if (kr == KERN_SUCCESS ||
594: kr == MACH_RCV_PORT_DIED) {
595: ETAP_EXCEPTION_PROBE(EVENT_END, self, exception, code);
596: thread_exception_return();
597: /* NOTREACHED*/
598: return;
599: }
600: } break;
601:
602: case EXCEPTION_DEFAULT:
603: c_tsk_exc_raise++;
604: kr = exception_raise(exc_port,
605: retrieve_act_self_fast(a_self),
606: retrieve_task_self_fast(a_self->task),
607: exception, code, codeCnt);
608:
609: if (kr == KERN_SUCCESS ||
610: kr == MACH_RCV_PORT_DIED) {
611: thread_exception_return();
612: /*NOTREACHED*/
613: return;
614: }
615: break;
616:
617: case EXCEPTION_STATE_IDENTITY: {
618: mach_msg_type_number_t state_cnt;
619: natural_t state[ THREAD_MACHINE_STATE_MAX ];
620:
621: c_tsk_exc_raise_state_id++;
622: state_cnt = state_count[flavor];
623: kr = thread_getstatus(a_self, flavor, state, &state_cnt);
624: if (kr == KERN_SUCCESS) {
625: kr = exception_raise_state_identity(exc_port,
626: retrieve_act_self_fast(a_self),
627: retrieve_task_self_fast(a_self->task),
628: exception,
629: code, codeCnt,
630: &flavor,
631: state, state_cnt,
632: state, &state_cnt);
633: if (kr == KERN_SUCCESS)
634: kr = thread_setstatus(a_self, flavor, state, state_cnt);
635: }
636:
637: if (kr == MACH_MSG_SUCCESS || kr == MACH_RCV_PORT_DIED) {
638: thread_exception_return();
639: /*NOTREACHED*/
640: return;
641: }
642: } break;
643:
644: default:
645: panic ("bad behavior!");
646: }/* switch */
647:
648: exception_no_server();
649: /*NOTREACHED*/
650: }
651:
652: /*
653: * Routine: exception_no_server
654: * Purpose:
655: * The current thread took an exception,
656: * and no exception server took responsibility
657: * for the exception. So good bye, charlie.
658: * Conditions:
659: * Nothing locked and no resources held.
660: * Called from an exception context, so
661: * thread_kdb_return is possible.
662: * Returns:
663: * Doesn't return.
664: */
665:
666: void
667: exception_no_server(void)
668: {
669: register thread_t self = current_thread();
670:
671: /*
672: * If this thread is being terminated, cooperate.
673: *
674: * When a task is dying, it's no longer ripped
675: * directly out of the rcv from its "kill me" message, and
676: * so returns here. The following causes it to return out
677: * to the glue code and clean itself up.
678: */
679: if ((thread_should_halt(self)) || (self->state & TH_ABORT)) {
680: thread_exception_return();
681: panic("exception_no_server - 1");
682: }
683:
684:
685: if (self->top_act->task == kernel_task)
686: panic("kernel task terminating\n");
687:
688: #if MACH_KDB
689: if (debug_user_with_kdb) {
690: /*
691: * Debug the exception with kdb.
692: * If kdb handles the exception,
693: * then thread_kdb_return won't return.
694: */
695: db_printf("No exception server, calling kdb...\n");
696: #if iPSC860
697: db_printf("Dropping into ddb, avoiding thread_kdb_return\n");
698: gimmeabreak();
699: #endif
700: thread_kdb_return();
701: }
702: #endif /* MACH_KDB */
703:
704: /*
705: * All else failed; terminate task.
706: */
707:
708: (void) task_terminate(self->top_act->task);
709: thread_terminate_self();
710: /*NOTREACHED*/
711: panic("exception_no_server: returning!");
712: }
713:
714: #ifdef MACHINE_FAST_EXCEPTION /* from <machine/thread.h> if at all */
715: /*
716: * Routine: alert_exception
717: * Purpose:
718: * The current thread caught an exception.
719: * We make an up-call to the thread's exception server.
720: * Conditions:
721: * Nothing locked and no resources held.
722: * Returns:
723: * KERN_RPC_TERMINATE_ORPHAN - if orphan should be terminated
724: * KERN_RPC_CONTINUE_ORPHAN - if orphan should be allowed to
725: * continue execution
726: */
727:
728: kern_return_t
729: alert_exception(
730: exception_type_t exception,
731: exception_data_t code,
732: int codeCnt )
733: {
734: thread_t self = current_thread();
735: thread_act_t a_self = self->top_act;
736: thread_act_t cln_act;
737: ipc_port_t exc_port;
738: int i;
739: struct exception_action *excp = &a_self->exc_actions[exception];
740: int flavor;
741: kern_return_t kr;
742:
743: assert(exception == EXC_RPC_ALERT);
744:
745: self->ith_scatter_list = MACH_MSG_BODY_NULL;
746:
747: /*
748: * Optimized version of retrieve_thread_exception.
749: */
750:
751: act_lock(a_self);
752: assert(a_self->ith_self != IP_NULL);
753: exc_port = excp->port;
754: if (!IP_VALID(exc_port)) {
755: act_unlock(a_self);
756: return(alert_exception_try_task(exception, code, codeCnt));
757: }
758: flavor = excp->flavor;
759:
760: #ifdef i386
761: /* For this flavor, we must copy in the first few procedure call
762: * args from the user's stack, since that is part of the important
763: * state in a syscall exception (this is for performance -- we
764: * can do the copyin much faster than the server, even if it is
765: * kernel-loaded):
766: */
767: if (flavor == i386_SAVED_STATE) {
768: struct i386_saved_state *statep = (struct i386_saved_state *)
769: act_machine_state_ptr(self->top_act);
770: statep->argv_status = FALSE;
771: if (syscall_exc_copyin && copyin((char *)statep->uesp,
772: (char *)statep->argv,
773: i386_SAVED_ARGV_COUNT * sizeof(int)) == 0) {
774: /* Indicate success for the server: */
775: statep->argv_status = TRUE;
776: }
777: }
778: #endif
779:
780: ip_lock(exc_port);
781: act_unlock(a_self);
782: if (!ip_active(exc_port)) {
783: ip_unlock(exc_port);
784: return(alert_exception_try_task(exception, code, codeCnt));
785: }
786:
787: /*
788: * Hold a reference to the port over the exception_raise_* calls
789: * so it can't be destroyed. This seems like overkill, but keeps
790: * the port from disappearing between now and when
791: * ipc_object_copyin_from_kernel is finally called.
792: */
793: ip_reference(exc_port);
794: /* CHECKME! */
795: /* exc_port->ip_srights++; ipc_object_copy_from_kernel does this */
796: ip_unlock(exc_port);
797:
798: switch (excp->behavior) {
799: case EXCEPTION_STATE: {
800: mach_msg_type_number_t state_cnt;
801: {
802: natural_t state[ THREAD_MACHINE_STATE_MAX ];
803:
804: state_cnt = state_count[flavor];
805: kr = thread_getstatus(a_self, flavor, state, &state_cnt);
806: if (kr == KERN_SUCCESS) {
807: kr = exception_raise_state(exc_port, exception,
808: code, codeCnt,
809: &flavor,
810: state, state_cnt,
811: state, &state_cnt);
812: if (kr == MACH_MSG_SUCCESS)
813: kr = thread_setstatus(a_self, flavor, state, state_cnt);
814: }
815: }
816: ip_lock(exc_port);
817: ip_release(exc_port);
818: ip_unlock(exc_port);
819:
820: if (kr == KERN_SUCCESS ||
821: kr == MACH_RCV_PORT_DIED) {
822: return(KERN_RPC_TERMINATE_ORPHAN);
823: }
824: } break;
825:
826: case EXCEPTION_DEFAULT:
827: c_thr_exc_raise++;
828: kr = exception_raise(exc_port,
829: retrieve_act_self_fast(a_self),
830: retrieve_task_self_fast(a_self->task),
831: exception,
832: code, codeCnt);
833: ip_lock(exc_port);
834: ip_release(exc_port);
835: ip_unlock(exc_port);
836:
837: if (kr == KERN_SUCCESS ||
838: kr == MACH_RCV_PORT_DIED) {
839: return(KERN_RPC_TERMINATE_ORPHAN);
840: }
841: break;
842:
843: case EXCEPTION_STATE_IDENTITY: {
844: mach_msg_type_number_t state_cnt;
845: natural_t state[ THREAD_MACHINE_STATE_MAX ];
846:
847: c_thr_exc_raise_state_id++;
848: state_cnt = state_count[flavor];
849: kr = thread_getstatus(a_self, flavor, state, &state_cnt);
850: if (kr == KERN_SUCCESS) {
851: kr = exception_raise_state_identity(exc_port,
852: retrieve_act_self_fast(a_self),
853: retrieve_task_self_fast(a_self->task),
854: exception,
855: code, codeCnt,
856: &flavor,
857: state, state_cnt,
858: state, &state_cnt);
859: if (kr == MACH_MSG_SUCCESS)
860: kr = thread_setstatus(a_self, flavor, state, state_cnt);
861: }
862: ip_lock(exc_port);
863: ip_release(exc_port);
864: ip_unlock(exc_port);
865:
866: if (kr == KERN_SUCCESS ||
867: kr == MACH_RCV_PORT_DIED) {
868: return(KERN_RPC_TERMINATE_ORPHAN);
869: }
870: } break;
871: default:
872: panic ("bad behavior!");
873: }/* switch */
874:
875: /*
876: * When a task is being terminated, it's no longer ripped
877: * directly out of the rcv from its "kill me" message, and
878: * so returns here. The following causes it to return out
879: * to the glue code and clean itself up.
880: */
881: if (self->top_act && !self->top_act->active)
882: return(KERN_RPC_TERMINATE_ORPHAN);
883:
884: return(alert_exception_try_task(exception, code, codeCnt));
885: }
886: #else /* MACHINE_FAST_EXCEPTION */
887:
888: /*
889: * Routine: alert_exception
890: * Purpose:
891: * The current thread caught an exception.
892: * We make an up-call to the thread's exception server.
893: * Conditions:
894: * Nothing locked and no resources held.
895: * Returns:
896: * KERN_RPC_TERMINATE_ORPHAN - if orphan should be terminated
897: * KERN_RPC_CONTINUE_ORPHAN - if orphan should be allowed to
898: * continue execution
899: */
900:
901: kern_return_t
902: alert_exception(
903: exception_type_t exception,
904: exception_data_t code,
905: int codeCnt )
906: {
907: thread_t self = current_thread();
908: thread_act_t a_self = self->top_act;
909: ipc_port_t exc_port;
910: int i;
911: struct exception_action *excp = &a_self->exc_actions[exception];
912: int flavor;
913: kern_return_t kr;
914:
915: assert(exception == EXC_RPC_ALERT);
916:
917: self->ith_scatter_list = MACH_MSG_BODY_NULL;
918:
919: /*
920: * Optimized version of retrieve_thread_exception.
921: */
922:
923: act_lock(a_self);
924: assert(a_self->ith_self != IP_NULL);
925: exc_port = excp->port;
926: if (!IP_VALID(exc_port)) {
927: act_unlock(a_self);
928: return(alert_exception_try_task(exception, code, codeCnt));
929: }
930: flavor = excp->flavor;
931:
932: ip_lock(exc_port);
933: act_unlock(a_self);
934: if (!ip_active(exc_port)) {
935: ip_unlock(exc_port);
936: return(alert_exception_try_task(exception, code, codeCnt));
937: }
938:
939: /*
940: * Hold a reference to the port over the exception_raise_* calls
941: * so it can't be destroyed. This seems like overkill, but keeps
942: * the port from disappearing between now and when
943: * ipc_object_copyin_from_kernel is finally called.
944: */
945: ip_reference(exc_port);
946: /* CHECKME! */
947: /* exc_port->ip_srights++; ipc_object_copy_from_kernel does this */
948: ip_unlock(exc_port);
949:
950: switch (excp->behavior) {
951: case EXCEPTION_STATE: {
952: mach_msg_type_number_t state_cnt;
953: rpc_subsystem_t subsystem = ((ipc_port_t)exc_port)->ip_subsystem;
954:
955: c_thr_exc_raise_state++;
956: if (flavor == MACHINE_THREAD_STATE &&
957: subsystem &&
958: is_fast_space(exc_port->ip_receiver)) {
959: natural_t *statep;
960: /* Requested flavor is the same format in which
961: * we save state on this machine, so no copy is
962: * necessary. Obtain direct pointer to saved state:
963: */
964: statep = act_machine_state_ptr(self->top_act);
965: state_cnt = MACHINE_THREAD_STATE_COUNT;
966: kr = exception_raise_state(exc_port, exception,
967: code, codeCnt,
968: &flavor,
969: statep, state_cnt,
970: statep, &state_cnt);
971: /* Server is required to return same flavor: */
972: assert(flavor == MACHINE_THREAD_STATE);
973: } else {
974: natural_t state[ THREAD_MACHINE_STATE_MAX ];
975:
976: state_cnt = state_count[flavor];
977: kr = thread_getstatus(a_self, flavor,
978: (thread_state_t)state,
979: &state_cnt);
980: if (kr == KERN_SUCCESS) {
981: kr = exception_raise_state(exc_port, exception,
982: code, codeCnt,
983: &flavor,
984: state, state_cnt,
985: state, &state_cnt);
986: if (kr == MACH_MSG_SUCCESS)
987: kr = thread_setstatus(a_self, flavor,
988: (thread_state_t)state,
989: state_cnt);
990: }
991: }
992: ip_lock(exc_port);
993: ip_release(exc_port);
994: ip_unlock(exc_port);
995:
996: if (kr == KERN_SUCCESS ||
997: kr == MACH_RCV_PORT_DIED) {
998: return(KERN_RPC_TERMINATE_ORPHAN);
999: }
1000: } break;
1001:
1002: case EXCEPTION_DEFAULT:
1003: c_thr_exc_raise++;
1004: kr = exception_raise(exc_port,
1005: retrieve_act_self_fast(a_self),
1006: retrieve_task_self_fast(a_self->task),
1007: exception,
1008: code, codeCnt);
1009: ip_lock(exc_port);
1010: ip_release(exc_port);
1011: ip_unlock(exc_port);
1012:
1013: if (kr == KERN_SUCCESS ||
1014: kr == MACH_RCV_PORT_DIED) {
1015: return(KERN_RPC_TERMINATE_ORPHAN);
1016: }
1017: break;
1018:
1019: case EXCEPTION_STATE_IDENTITY: {
1020: mach_msg_type_number_t state_cnt;
1021: natural_t state[ THREAD_MACHINE_STATE_MAX ];
1022:
1023: c_thr_exc_raise_state_id++;
1024: state_cnt = state_count[flavor];
1025: kr = thread_getstatus(a_self, flavor,
1026: (thread_state_t)state,
1027: &state_cnt);
1028: if (kr == KERN_SUCCESS) {
1029: kr = exception_raise_state_identity(exc_port,
1030: retrieve_act_self_fast(a_self),
1031: retrieve_task_self_fast(a_self->task),
1032: exception,
1033: code, codeCnt,
1034: &flavor,
1035: state, state_cnt,
1036: state, &state_cnt);
1037: if (kr == MACH_MSG_SUCCESS)
1038: kr = thread_setstatus(a_self, flavor,
1039: (thread_state_t)state,
1040: state_cnt);
1041: }
1042: ip_lock(exc_port);
1043: ip_release(exc_port);
1044: ip_unlock(exc_port);
1045:
1046: if (kr == KERN_SUCCESS ||
1047: kr == MACH_RCV_PORT_DIED) {
1048: return(KERN_RPC_TERMINATE_ORPHAN);
1049: }
1050: } break;
1051: default:
1052: panic ("bad behavior!");
1053: }/* switch */
1054:
1055: /*
1056: * When a task is being terminated, it's no longer ripped
1057: * directly out of the rcv from its "kill me" message, and
1058: * so returns here. The following causes it to return out
1059: * to the glue code and clean itself up.
1060: */
1061: if (thread_should_halt(self)) {
1062: return(KERN_RPC_TERMINATE_ORPHAN);
1063: }
1064:
1065: return(alert_exception_try_task(exception, code, codeCnt));
1066: }
1067: #endif /* defined MACHINE_FAST_EXCEPTION */
1068:
1069: /*
1070: * Routine: alert_exception_try_task
1071: * Purpose:
1072: * The current thread caught an exception.
1073: * We make an up-call to the task's exception server.
1074: * Conditions:
1075: * Nothing locked and no resources held.
1076: * Returns:
1077: * KERN_RPC_TERMINATE_ORPHAN - if orphan should be terminated
1078: * KERN_RPC_CONTINUE_ORPHAN - if orphan should be allowed to
1079: * continue execution
1080: */
1081:
1082: kern_return_t
1083: alert_exception_try_task(
1084: exception_type_t exception,
1085: exception_data_t code,
1086: int codeCnt )
1087: {
1088: thread_act_t a_self = current_act();
1089: thread_t self = a_self->thread;
1090: register task_t task = a_self->task;
1091: register ipc_port_t exc_port;
1092: int flavor;
1093: kern_return_t kr;
1094:
1095: assert(exception == EXC_RPC_ALERT);
1096:
1097: self->ith_scatter_list = MACH_MSG_BODY_NULL;
1098:
1099: /*
1100: * Optimized version of retrieve_task_exception.
1101: */
1102:
1103: itk_lock(task);
1104: assert(task->itk_self != IP_NULL);
1105: exc_port = task->exc_actions[exception].port;
1106: if (!IP_VALID(exc_port)) {
1107: itk_unlock(task);
1108: return(KERN_RPC_CONTINUE_ORPHAN);
1109: }
1110: flavor = task->exc_actions[exception].flavor;
1111:
1112: ip_lock(exc_port);
1113: itk_unlock(task);
1114: if (!ip_active(exc_port)) {
1115: ip_unlock(exc_port);
1116: return(KERN_RPC_CONTINUE_ORPHAN);
1117: }
1118:
1119: /*
1120: * Hold a reference to the port over the exception_raise_* calls
1121: * (see longer comment in exception())
1122: */
1123: ip_reference(exc_port);
1124: /* CHECKME! */
1125: /* exc_port->ip_srights++; */
1126: ip_unlock(exc_port);
1127:
1128: switch (task->exc_actions[exception].behavior) {
1129: case EXCEPTION_STATE: {
1130: mach_msg_type_number_t state_cnt;
1131: natural_t state[ THREAD_MACHINE_STATE_MAX ];
1132:
1133: c_tsk_exc_raise_state++;
1134: state_cnt = state_count[flavor];
1135: kr = thread_getstatus(a_self, flavor, state, &state_cnt);
1136: if (kr == KERN_SUCCESS) {
1137: kr = exception_raise_state(exc_port, exception,
1138: code, codeCnt,
1139: &flavor,
1140: state, state_cnt,
1141: state, &state_cnt);
1142: if (kr == KERN_SUCCESS)
1143: kr = thread_setstatus(a_self, flavor, state, state_cnt);
1144: }
1145: ip_lock(exc_port);
1146: ip_release(exc_port);
1147: ip_unlock(exc_port);
1148:
1149: if (kr == MACH_MSG_SUCCESS || kr == MACH_RCV_PORT_DIED) {
1150: return(KERN_RPC_TERMINATE_ORPHAN);
1151: }
1152: } break;
1153:
1154: case EXCEPTION_DEFAULT:
1155: c_tsk_exc_raise++;
1156: kr = exception_raise(exc_port,
1157: retrieve_act_self_fast(a_self),
1158: retrieve_task_self_fast(a_self->task),
1159: exception, code, codeCnt);
1160: ip_lock(exc_port);
1161: ip_release(exc_port);
1162: ip_unlock(exc_port);
1163:
1164: if (kr == KERN_SUCCESS || kr == MACH_RCV_PORT_DIED) {
1165: return(KERN_RPC_TERMINATE_ORPHAN);
1166: }
1167: break;
1168:
1169: case EXCEPTION_STATE_IDENTITY: {
1170: mach_msg_type_number_t state_cnt;
1171: natural_t state[ THREAD_MACHINE_STATE_MAX ];
1172:
1173: c_tsk_exc_raise_state_id++;
1174: state_cnt = state_count[flavor];
1175: kr = thread_getstatus(a_self, flavor, state, &state_cnt);
1176: if (kr == KERN_SUCCESS) {
1177: kr = exception_raise_state_identity(exc_port,
1178: retrieve_act_self_fast(a_self),
1179: retrieve_task_self_fast(a_self->task),
1180: exception,
1181: code, codeCnt,
1182: &flavor,
1183: state, state_cnt,
1184: state, &state_cnt);
1185: if (kr == KERN_SUCCESS)
1186: kr = thread_setstatus(a_self, flavor, state, state_cnt);
1187: }
1188: ip_lock(exc_port);
1189: ip_release(exc_port);
1190: ip_unlock(exc_port);
1191:
1192: if (kr == MACH_MSG_SUCCESS || kr == MACH_RCV_PORT_DIED) {
1193: return(KERN_RPC_TERMINATE_ORPHAN);
1194: }
1195: } break;
1196:
1197: default:
1198: panic ("bad behavior!");
1199: }/* switch */
1200:
1201: return(KERN_RPC_CONTINUE_ORPHAN);
1202: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.