![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to trap.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / machdep / i386|
Return to trap.c CVS log | Up to [Apple Darwin 0.x] / kernel / machdep / i386 |
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: * Copyright (c) 1992 NeXT Computer, Inc.
27: *
28: * Intel386 Family: Trap handlers.
29: *
30: * HISTORY
31: *
32: * 13 April 1992 ? at NeXT
33: * Created.
34: */
35:
36: #import <gdb.h>
37:
38: #import <mach/mach_types.h>
39: #import <mach/exception.h>
40:
41: #import <kern/syscall_sw.h>
42: #import <kern/kdp.h>
43:
44: #import <vm/vm_kern.h>
45:
46: #import <machdep/i386/trap.h>
47: #import <machdep/i386/machdep_call.h>
48: #import <machdep/i386/cpu_inline.h>
49: #import <machdep/i386/fp_exported.h>
50: #import <machdep/i386/sel_inline.h>
51: #import <machdep/i386/err_inline.h>
52:
53: #import <sys/kernel.h>
54: #import <sys/systm.h>
55: #import <sys/proc.h>
56: #import <sys/user.h>
57: #import <sys/syslog.h>
58:
59: #define N_BACKTRACE 4 // number of backtrace frames to print
60:
61: static
62: void
63: kernel_debug_trap(
64: thread_saved_state_t *saved_state
65: );
66: static
67: kern_return_t
68: kernel_pagefault(
69: vm_offset_t address,
70: except_frame_t *frame
71: );
72: static
73: boolean_t
74: kernel_try_recover(
75: except_frame_t *frame
76: );
77: static
78: void
79: kernel_recover_thread(
80: thread_saved_state_t *saved_state
81: );
82:
83: void
84: _i386_backtrace(
85: void *frame,
86: int nframes
87: );
88:
89: void
90: user_trap(
91: thread_saved_state_t *state
92: )
93: {
94: except_frame_t *frame = &state->frame;
95: int trapno;
96: thread_t thread;
97: int _exception, code = 0, subcode = 0;
98: vm_offset_t va;
99: kern_return_t result;
100: int uerror;
101: struct proc *p;
102: struct timeval syst;
103:
104: thread = current_thread();
105: trapno = state->trapno;
106:
107: if (p = current_proc())
108: syst = p->p_stats->p_ru.ru_stime;
109:
110: switch (trapno) {
111:
112: case T_ZERO_DIVIDE:
113: _exception = EXC_ARITHMETIC;
114: code = EXC_I386_ZERO_DIVIDE;
115: break;
116:
117: case T_DEBUG:
118: _exception = EXC_BREAKPOINT;
119: code = EXC_I386_DEBUG;
120: break;
121:
122: case T_BREAKPOINT:
123: _exception = EXC_BREAKPOINT;
124: code = EXC_I386_BREAKPOINT;
125: break;
126:
127: case T_OVERFLOW:
128: _exception = EXC_SOFTWARE;
129: code = EXC_I386_OVERFLOW;
130: break;
131:
132: case T_BOUNDS_CHECK:
133: _exception = EXC_SOFTWARE;
134: code = EXC_I386_BOUNDS_CHECK;
135: break;
136:
137: case T_INVALID_OPCODE:
138: _exception = EXC_BAD_INSTRUCTION;
139: code = EXC_I386_INVALID_OPCODE;
140: break;
141:
142: case T_NOEXTENSION:
143: fp_noextension(state);
144: goto out;
145:
146: case T_SEGMENT_NOTPRESENT:
147: _exception = EXC_BAD_INSTRUCTION;
148: code = EXC_I386_SEGMENT_NOTPRESENT;
149: subcode = err_to_error_code(frame->err);
150: break;
151:
152: case T_STACK_EXCEPTION:
153: _exception = EXC_BAD_INSTRUCTION;
154: code = EXC_I386_STACK_EXCEPTION;
155: subcode = err_to_error_code(frame->err);
156: break;
157:
158: case T_GENERAL_PROTECTION:
159: _exception = EXC_BAD_INSTRUCTION;
160: code = EXC_I386_GENERAL_PROTECTION;
161: subcode = err_to_error_code(frame->err);
162: break;
163:
164: case T_PAGE_FAULT:
165: va = cr2();
166: result = vm_fault(thread->task->map, trunc_page(va),
167: frame->err.pgfault.wrtflt?
168: VM_PROT_READ | VM_PROT_WRITE:
169: VM_PROT_READ,
170: FALSE, 0);
171: if (result == KERN_SUCCESS)
172: goto out;
173:
174: _exception = EXC_BAD_ACCESS;
175: code = result;
176: subcode = va;
177: break;
178:
179: case T_EXTENSION_FAULT:
180: fp_extension_fault(state);
181: goto out;
182:
183: case T_ALIGNMENT_CHECK:
184: _exception = EXC_SOFTWARE;
185: code = EXC_I386_ALIGNMENT_CHECK;
186: break;
187:
188: default:
189: _exception = EXC_BAD_INSTRUCTION;
190: code = trapno;
191: break;
192: }
193:
194: exception(_exception, code, subcode);
195: /* NOTREACHED */
196:
197: out:
198: if (p && (p->p_flag & P_PROFIL)) {
199: int ticks;
200: struct timeval *tv = &p->p_stats->p_ru.ru_stime;
201:
202: ticks = ((tv->tv_sec - syst.tv_sec) * 1000 +
203: (tv->tv_usec - syst.tv_usec) / 1000) / (tick / 1000);
204: if (ticks)
205: addupc_task(p, frame->eip, ticks);
206: }
207:
208: thread_exception_return();
209: /* NOTREACHED */
210: }
211:
212: void
213: kernel_trap(
214: thread_saved_state_t *state
215: )
216: {
217: except_frame_t *frame = &state->frame;
218: int trapno;
219: vm_offset_t va;
220: int _exception, code = 0, subcode = 0;
221: kern_return_t result;
222: int uerror;
223:
224: trapno = state->trapno;
225:
226: switch (trapno) {
227:
228: case T_NOEXTENSION:
229: /* ignore exception */;
230: return;
231:
232: case T_EXTENSION_FAULT:
233: fp_kernel_extension_fault(state);
234: return;
235:
236: case T_DEBUG:
237: case T_BREAKPOINT:
238: kernel_debug_trap(state);
239: return;
240:
241: case T_PAGE_FAULT:
242: va = cr2();
243:
244: if (va >= KERNEL_LINEAR_BASE)
245: result = kernel_pagefault(va, frame);
246: else
247: result = vm_fault(current_task()->map, trunc_page(va),
248: frame->err.pgfault.wrtflt?
249: VM_PROT_READ | VM_PROT_WRITE:
250: VM_PROT_READ,
251: FALSE, 0);
252:
253: if (result == KERN_SUCCESS)
254: return;
255:
256: if (kernel_try_recover(frame))
257: return;
258:
259: if (va < KERNEL_LINEAR_BASE) {
260: /*
261: * This can happen on return to user mode
262: * when a private thread LDT contains
263: * unallocated virtual memory. Send an
264: * exception RPC, after carefully piecing
265: * the thread state back together.
266: */
267: kernel_recover_thread(state);
268:
269: _exception = EXC_BAD_ACCESS;
270: code = result;
271: subcode = va;
272: exception_from_kernel(_exception, code, subcode);
273: thread_exception_return();
274: /* NOTREACHED */
275: }
276: break;
277:
278: case T_GENERAL_PROTECTION:
279: case T_SEGMENT_NOTPRESENT:
280: case T_STACK_EXCEPTION:
281: if (frame->err.normal.tbl == ERR_LDT) {
282: /*
283: * This can happen on return to user mode
284: * when one of the segment registers refers
285: * to a descriptor that is invalid for some
286: * reason or another. Send an exception RPC,
287: * after carefully piecing the thread state
288: * back together.
289: */
290: kernel_recover_thread(state);
291:
292: _exception = EXC_BAD_INSTRUCTION;
293: code = trapno;
294: subcode = err_to_error_code(frame->err);
295: exception_from_kernel(_exception, code, subcode);
296: thread_exception_return();
297: /* NOTREACHED */
298: }
299: break;
300:
301: case T_INVALID_TSS:
302: if ((frame->eflags & EFL_NT) != 0) {
303: /*
304: * This can happen on return to user mode
305: * when a thread managed to set the NT flag
306: * and then entered the kernel through a call
307: * gate. The fix is to redo the IRET, since
308: * the NT flag cannot be set at this point (we
309: * just came through a trap gate to get here).
310: */
311: kernel_recover_thread(state);
312: thread_exception_return();
313: /* NOTREACHED */
314: }
315: break;
316: }
317:
318: if (kernel_try_recover(frame))
319: return;
320:
321: #if GDB
322: DoSafeAlert("Kernel Trap", "", FALSE);
323: printf("unexpected kernel trap %x eip %x\n", trapno, frame->eip);
324: switch (trapno) {
325:
326: case T_ZERO_DIVIDE:
327: _exception = EXC_ARITHMETIC;
328: code = EXC_I386_ZERO_DIVIDE;
329: break;
330:
331: case T_OVERFLOW:
332: _exception = EXC_SOFTWARE;
333: code = EXC_I386_OVERFLOW;
334: break;
335:
336: case T_BOUNDS_CHECK:
337: _exception = EXC_ARITHMETIC;
338: code = EXC_I386_BOUNDS_CHECK;
339: break;
340:
341: case T_INVALID_OPCODE:
342: _exception = EXC_BAD_INSTRUCTION;
343: code = EXC_I386_INVALID_OPCODE;
344: break;
345:
346: case T_SEGMENT_NOTPRESENT:
347: _exception = EXC_BAD_INSTRUCTION;
348: code = EXC_I386_SEGMENT_NOTPRESENT;
349: subcode = err_to_error_code(frame->err);
350: break;
351:
352: case T_STACK_EXCEPTION:
353: _exception = EXC_BAD_INSTRUCTION;
354: code = EXC_I386_STACK_EXCEPTION;
355: subcode = err_to_error_code(frame->err);
356: break;
357:
358: case T_GENERAL_PROTECTION:
359: _exception = EXC_BAD_INSTRUCTION;
360: code = EXC_I386_GENERAL_PROTECTION;
361: subcode = err_to_error_code(frame->err);
362: break;
363:
364: case T_PAGE_FAULT:
365: _exception = EXC_BAD_ACCESS;
366: code = result;
367: subcode = va;
368: break;
369:
370: case T_ALIGNMENT_CHECK:
371: _exception = EXC_SOFTWARE;
372: code = EXC_I386_ALIGNMENT_CHECK;
373: break;
374:
375: default:
376: _exception = EXC_BAD_INSTRUCTION;
377: code = trapno;
378: break;
379: }
380:
381: _i386_backtrace(state->regs.ebp, N_BACKTRACE);
382:
383: kdp_raise_exception(_exception, code, subcode, state);
384: DoRestore();
385: panic("continued after kernel trap");
386: #else
387: printf("unexpected kernel trap %x eip %x\n", trapno, frame->eip);
388: panic("kernel trap");
389: #endif
390: }
391:
392: static
393: kern_return_t
394: kernel_pagefault(
395: vm_offset_t va,
396: except_frame_t *frame
397: )
398: {
399: thread_t thread = current_thread();
400: vm_map_t map;
401: kern_return_t result;
402:
403: if (thread == THREAD_NULL)
404: map = kernel_map;
405: else {
406: map = thread->task->map;
407: if (vm_map_pmap(map) != kernel_pmap)
408: map = kernel_map;
409: }
410:
411: result = vm_fault(map, trunc_page(va - KERNEL_LINEAR_BASE),
412: frame->err.pgfault.wrtflt?
413: VM_PROT_READ | VM_PROT_WRITE:
414: VM_PROT_READ,
415: FALSE, 0);
416:
417: return (result);
418: }
419:
420: static
421: void
422: kernel_debug_trap(
423: thread_saved_state_t *state
424: )
425: {
426: except_frame_t *frame = &state->frame;
427: int code;
428: dr6_t debug = (dr6_t) { 0 };
429: extern void unix_syscall_(void),
430: mach_kernel_trap_(void),
431: machdep_call_(void);
432:
433: // Clear debug status
434: set_dr6(debug);
435:
436: if (state->trapno == T_DEBUG) {
437: if ( frame->eip == (unsigned int)unix_syscall_ ||
438: frame->eip == (unsigned int)mach_kernel_trap_ ||
439: frame->eip == (unsigned int)machdep_call_ ) {
440: current_thread()->pcb->trace = TRUE;
441: frame->eflags &= ~EFL_TF;
442: return;
443: }
444: code = EXC_I386_DEBUG;
445: }
446: else
447: code = EXC_I386_BREAKPOINT;
448:
449: #if GDB
450: kdp_raise_exception(EXC_BREAKPOINT, code, 0, state);
451: #else
452: panic("kernel debug trap");
453: #endif
454: }
455:
456: static
457: boolean_t
458: kernel_try_recover(
459: except_frame_t *frame
460: )
461: {
462: vm_offset_t recover = current_thread()->recover;
463:
464: if (recover != 0) {
465: frame->eip = recover;
466: frame->cs = KCS_SEL;
467: frame->eflags &= ~EFL_DF;
468: }
469: else
470: return (FALSE);
471:
472: current_thread()->recover = 0;
473:
474: return (TRUE);
475: }
476:
477: static
478: void
479: kernel_recover_thread(
480: thread_saved_state_t *state
481: )
482: {
483: thread_saved_state_t *user_regs = USER_REGS(current_thread());
484: vm_offset_t stack_ptr = (vm_offset_t)&state->frame.esp;
485:
486: user_regs->frame.err = state->frame.err;
487:
488: if (stack_ptr > (vm_offset_t)&user_regs->regs.ds) {
489:
490: user_regs->regs.eax = state->regs.eax;
491: user_regs->regs.ecx = state->regs.ecx;
492: user_regs->regs.edx = state->regs.edx;
493: user_regs->regs.ebx = state->regs.ebx;
494: user_regs->regs.ebp = state->regs.ebp;
495: user_regs->regs.esi = state->regs.esi;
496: user_regs->regs.edi = state->regs.edi;
497:
498: user_regs->regs.ds = state->regs.ds;
499: user_regs->regs.es = state->regs.es;
500: user_regs->regs.fs = state->regs.fs;
501: user_regs->regs.gs = state->regs.gs;
502: }
503: else if (stack_ptr > (vm_offset_t)&user_regs->regs.es) {
504: user_regs->regs.es = state->regs.es;
505: user_regs->regs.fs = state->regs.fs;
506: user_regs->regs.gs = state->regs.gs;
507: }
508: else if (stack_ptr > (vm_offset_t)&user_regs->regs.fs) {
509: user_regs->regs.fs = state->regs.fs;
510: user_regs->regs.gs = state->regs.gs;
511: }
512: else if (stack_ptr > (vm_offset_t)&user_regs->regs.gs)
513: user_regs->regs.gs = state->regs.gs;
514: }
515:
516: static inline
517: void
518: check_for_trace(
519: thread_saved_state_t *state
520: )
521: {
522: thread_t thread = current_thread();
523:
524: if (thread->pcb->trace) {
525: thread->pcb->trace = FALSE;
526: state->frame.eflags |= EFL_TF;
527: }
528: }
529:
530: void
531: machdep_call(
532: thread_saved_state_t *state
533: )
534: {
535: except_frame_t *frame = &state->frame;
536: regs_t *regs = &state->regs;
537: int trapno, nargs;
538: machdep_call_t *entry;
539:
540: check_for_trace(state);
541:
542: trapno = regs->eax;
543: if (trapno < 0 || trapno >= machdep_call_count) {
544: regs->eax = (unsigned int)kern_invalid();
545:
546: thread_exception_return();
547: /* NOTREACHED */
548: }
549:
550: entry = &machdep_call_table[trapno];
551: nargs = entry->nargs;
552:
553: if (nargs > 0) {
554: int args[nargs];
555:
556: if (copyin(frame->esp + sizeof (int),
557: args,
558: nargs * sizeof (int))) {
559:
560: regs->eax = KERN_INVALID_ADDRESS;
561:
562: thread_exception_return();
563: /* NOTREACHED */
564: }
565:
566: asm volatile("
567: 1:
568: mov (%2),%%eax;
569: pushl %%eax;
570: sub $4,%2;
571: dec %1;
572: jne 1b;
573: mov %3,%%eax;
574: call *%%eax;
575: mov %%eax,%0"
576:
577: : "=r" (regs->eax)
578: : "r" (nargs),
579: "r" (&args[nargs - 1]),
580: "g" (entry->routine)
581: : "ax", "cx", "dx", "sp");
582: }
583: else
584: regs->eax = (unsigned int)(*entry->routine)();
585:
586: thread_exception_return();
587: /* NOTREACHED */
588: }
589:
590: void
591: mach_kernel_trap(
592: thread_saved_state_t *state
593: )
594: {
595: except_frame_t *frame = &state->frame;
596: regs_t *regs = &state->regs;
597: int trapno, nargs;
598: mach_trap_t *entry;
599:
600: check_for_trace(state);
601:
602: trapno = -(int)regs->eax;
603: if (trapno < 0 || trapno >= mach_trap_count) {
604: regs->eax = (unsigned int)kern_invalid();
605:
606: thread_exception_return();
607: /* NOTREACHED */
608: }
609:
610: entry = &mach_trap_table[trapno];
611: nargs = entry->mach_trap_arg_count;
612:
613: if (nargs > 0) {
614: int args[nargs];
615:
616: if (copyin(frame->esp + sizeof (int),
617: args,
618: nargs * sizeof (int))) {
619:
620: exception(EXC_BAD_ACCESS,
621: KERN_INVALID_ADDRESS,
622: frame->esp + sizeof (int));
623: /* NOTREACHED */
624: }
625:
626: asm volatile("
627: 1:
628: mov (%2),%%eax;
629: pushl %%eax;
630: sub $4,%2;
631: dec %1;
632: jne 1b;
633: mov %3,%%eax;
634: call *%%eax;
635: mov %%eax,%0"
636:
637: : "=r" (regs->eax)
638: : "r" (nargs),
639: "r" (&args[nargs - 1]),
640: "g" (entry->mach_trap_function)
641: : "ax", "cx", "dx", "sp");
642: }
643: else
644: regs->eax = (unsigned int)(*entry->mach_trap_function)();
645:
646: thread_exception_return();
647: /* NOTREACHED */
648: }
649:
650: void
651: unix_syscall(
652: thread_saved_state_t *state
653: )
654: {
655: except_frame_t *frame = &state->frame;
656: regs_t *regs = &state->regs;
657: thread_t thread = current_thread();
658: struct uthread *uthread;
659: struct sysent *callp;
660: struct proc *p;
661: struct timeval syst;
662: int nargs, error = 0;
663: unsigned short code;
664: caddr_t params;
665: int rval[2];
666:
667: check_for_trace(state);
668:
669: uthread = thread->_uthread;
670: uthread->uu_ar0 = (int *)state;
671: if (p = current_proc())
672: syst = p->p_stats->p_ru.ru_stime;
673:
674: code = regs->eax;
675: params = (caddr_t)frame->esp + sizeof (int);
676: callp = (code >= nsysent) ? &sysent[63] : &sysent[code];
677: if (callp == sysent) {
678: code = fuword(params);
679: params += sizeof (int);
680: callp = (code >= nsysent) ? &sysent[63] : &sysent[code];
681: }
682:
683: if ((nargs = (callp->sy_narg * sizeof (int))) &&
684: (error = copyin(params, (caddr_t)uthread->uu_arg, nargs)) != 0) {
685: regs->eax = error;
686: frame->eflags |= EFL_CF;
687: thread_exception_return();
688: /* NOTREACHED */
689: }
690:
691: rval[0] = 0;
692: rval[1] = regs->edx;
693:
694: error = (*(callp->sy_call))(p, (caddr_t)uthread->uu_arg, rval);
695:
696: if (error == ERESTART) {
697: state->frame.eip -= 7;
698: }
699: else if (error != EJUSTRETURN) {
700: if (error) {
701: state->regs.eax = error;
702: state->frame.eflags |= EFL_CF; /* carry bit */
703: } else { /* (not error) */
704: state->regs.eax = rval[0];
705: state->regs.edx = rval[1];
706: state->frame.eflags &= ~EFL_CF;
707: }
708: }
709: /* else (error == EJUSTRETURN) { nothing } */
710:
711: thread_exception_return();
712: /* NOTREACHED */
713:
714: }
715:
716:
717: void
718: check_for_ast(
719: thread_saved_state_t *state
720: )
721: {
722: thread_t thread = current_thread();
723: struct proc *p = current_proc();
724:
725: while (TRUE) {
726: ast_t reasons;
727: int mycpu = cpu_number();
728: int signum;
729:
730: cli(); // disable interrupts
731:
732: reasons = ast_needed(mycpu);
733:
734: if (p) {
735: if ((p->p_flag & P_OWEUPC) && (p->p_flag & P_PROFIL)) {
736: addupc_task(p, state->frame.eip, 1);
737: p->p_flag &= ~P_OWEUPC;
738: }
739:
740: ast_off(mycpu, AST_UNIX);
741:
742: if (CHECK_SIGNALS(p, thread, thread->_uthread)) {
743: signum = issignal(p);
744: if (signum)
745: postsig(signum);
746: cli();
747: }
748: }
749:
750: ast_off(mycpu, reasons);
751:
752: if (thread_should_halt(thread))
753: thread_halt_self();
754: else
755: if ((reasons & AST_BLOCK) ||
756: csw_needed(thread, current_processor())) {
757: p->p_stats->p_ru.ru_nivcsw++;
758: thread_block_with_continuation(thread_exception_return);
759: }
760: else
761: if (reasons & AST_FP_EXTEN)
762: fp_ast(thread);
763: else
764: break;
765: }
766: }
767:
768: typedef struct _cframe_t {
769: struct _cframe_t *prev;
770: unsigned caller;
771: unsigned args[0];
772: } cframe_t;
773:
774:
775: #define MAX_FRAME_DELTA 65536
776:
777: void
778: _i386_backtrace(
779: void *_frame,
780: int nframes
781: )
782: {
783: cframe_t *frame = (cframe_t *)_frame;
784: int i;
785:
786: for (i=0; i<nframes; i++) {
787: if ((vm_offset_t)frame < VM_MIN_KERNEL_ADDRESS ||
788: (vm_offset_t)frame > VM_MAX_KERNEL_ADDRESS) {
789: goto invalid;
790: }
791: safe_prf("frame %x called by %x ",
792: frame, frame->caller);
793: safe_prf("args %x %x %x %x\n",
794: frame->args[0], frame->args[1],
795: frame->args[2], frame->args[3]);
796: if ((frame->prev < frame) || /* wrong direction */
797: ((frame->prev - frame) > MAX_FRAME_DELTA)) {
798: goto invalid;
799: }
800: frame = frame->prev;
801: }
802: return;
803: invalid:
804: safe_prf("invalid frame pointer %x\n",frame->prev);
805: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.