xref: /freebsd/sys/kern/subr_trap.c (revision 0c43d89a0d8e976ca494d4837f4c1f3734d2c300)
1 /*-
2  * Copyright (C) 1994, David Greenman
3  * Copyright (c) 1990, 1993
4  *	The Regents of the University of California.  All rights reserved.
5  *
6  * This code is derived from software contributed to Berkeley by
7  * the University of Utah, and William Jolitz.
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions
11  * are met:
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  * 2. Redistributions in binary form must reproduce the above copyright
15  *    notice, this list of conditions and the following disclaimer in the
16  *    documentation and/or other materials provided with the distribution.
17  * 3. All advertising materials mentioning features or use of this software
18  *    must display the following acknowledgement:
19  *	This product includes software developed by the University of
20  *	California, Berkeley and its contributors.
21  * 4. Neither the name of the University nor the names of its contributors
22  *    may be used to endorse or promote products derived from this software
23  *    without specific prior written permission.
24  *
25  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
26  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
28  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
29  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
30  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
31  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
32  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
33  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
34  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35  * SUCH DAMAGE.
36  *
37  *	from: @(#)trap.c	7.4 (Berkeley) 5/13/91
38  *	$Id: trap.c,v 1.29 1994/08/18 22:34:43 wollman Exp $
39  */
40 
41 /*
42  * 386 Trap and System call handling
43  */
44 
45 #include <sys/param.h>
46 #include <sys/systm.h>
47 #include <sys/proc.h>
48 #include <sys/user.h>
49 #include <sys/acct.h>
50 #include <sys/kernel.h>
51 #include <sys/syscall.h>
52 #include <sys/sysent.h>
53 #ifdef KTRACE
54 #include <sys/ktrace.h>
55 #endif
56 
57 #include <vm/vm_param.h>
58 #include <vm/pmap.h>
59 #include <vm/vm_map.h>
60 #include <vm/vm_page.h>
61 
62 #include <machine/cpu.h>
63 #include <machine/psl.h>
64 #include <machine/reg.h>
65 #include <machine/eflags.h>
66 #include <machine/trap.h>
67 
68 #include "isa.h"
69 #include "npx.h"
70 #include "ddb.h"
71 
72 int	trap_pfault	__P((struct trapframe *, int));
73 void	trap_fatal	__P((struct trapframe *));
74 
75 #define MAX_TRAP_MSG		27
76 char *trap_msg[] = {
77 	"reserved addressing fault",		/*  0 T_RESADFLT */
78 	"privileged instruction fault",		/*  1 T_PRIVINFLT */
79 	"reserved operand fault",		/*  2 T_RESOPFLT */
80 	"breakpoint instruction fault",		/*  3 T_BPTFLT */
81 	"",					/*  4 unused */
82 	"system call trap",			/*  5 T_SYSCALL */
83 	"arithmetic trap",			/*  6 T_ARITHTRAP */
84 	"system forced exception",		/*  7 T_ASTFLT */
85 	"segmentation (limit) fault",		/*  8 T_SEGFLT */
86 	"general protection fault",		/*  9 T_PROTFLT */
87 	"trace trap",				/* 10 T_TRCTRAP */
88 	"",					/* 11 unused */
89 	"page fault",				/* 12 T_PAGEFLT */
90 	"page table fault",			/* 13 T_TABLEFLT */
91 	"alignment fault",			/* 14 T_ALIGNFLT */
92 	"kernel stack pointer not valid",	/* 15 T_KSPNOTVAL */
93 	"bus error",				/* 16 T_BUSERR */
94 	"kernel debugger fault",		/* 17 T_KDBTRAP */
95 	"integer divide fault",			/* 18 T_DIVIDE */
96 	"non-maskable interrupt trap",		/* 19 T_NMI */
97 	"overflow trap",			/* 20 T_OFLOW */
98 	"FPU bounds check fault",		/* 21 T_BOUND */
99 	"FPU device not available",		/* 22 T_DNA */
100 	"double fault",				/* 23 T_DOUBLEFLT */
101 	"FPU operand fetch fault",		/* 24 T_FPOPFLT */
102 	"invalid TSS fault",			/* 25 T_TSSFLT */
103 	"segment not present fault",		/* 26 T_SEGNPFLT */
104 	"stack fault",				/* 27 T_STKFLT */
105 };
106 
107 static inline void
108 userret(p, frame, oticks)
109 	struct proc *p;
110 	struct trapframe *frame;
111 	u_quad_t oticks;
112 {
113 	int sig, s;
114 
115 	while (sig = CURSIG(p))
116 		postsig(sig);
117 	p->p_priority = p->p_usrpri;
118 	if (want_resched) {
119 		/*
120 		 * Since we are curproc, clock will normally just change
121 		 * our priority without moving us from one queue to another
122 		 * (since the running process is not on a queue.)
123 		 * If that happened after we setrunqueue ourselves but before we
124 		 * mi_switch()'ed, we might not be on the queue indicated by
125 		 * our priority.
126 		 */
127 		s = splclock();
128 		setrunqueue(p);
129 		p->p_stats->p_ru.ru_nivcsw++;
130 		mi_switch();
131 		splx(s);
132 		while (sig = CURSIG(p))
133 			postsig(sig);
134 	}
135 	if (p->p_stats->p_prof.pr_scale) {
136 		u_quad_t ticks = p->p_sticks - oticks;
137 
138 		if (ticks) {
139 #ifdef PROFTIMER
140 			extern int profscale;
141 			addupc(frame->tf_eip, &p->p_stats->p_prof,
142 			    ticks * profscale);
143 #else
144 			addupc(frame->tf_eip, &p->p_stats->p_prof, ticks);
145 #endif
146 		}
147 	}
148 	curpriority = p->p_priority;
149 }
150 
151 /*
152  * trap(frame):
153  *	Exception, fault, and trap interface to the FreeBSD kernel.
154  * This common code is called from assembly language IDT gate entry
155  * routines that prepare a suitable stack frame, and restore this
156  * frame after the exception has been processed.
157  */
158 
159 /*ARGSUSED*/
160 void
161 trap(frame)
162 	struct trapframe frame;
163 {
164 	struct proc *p = curproc;
165 	u_quad_t sticks = 0;
166 	int i = 0, ucode = 0, type, code, eva, fault_type;
167 
168 	frame.tf_eflags &= ~PSL_NT;	/* clear nested trap XXX */
169 	type = frame.tf_trapno;
170 	code = frame.tf_err;
171 
172 	if (ISPL(frame.tf_cs) == SEL_UPL) {
173 		/* user trap */
174 
175 		sticks = p->p_sticks;
176 		p->p_md.md_regs = (int *)&frame;
177 
178 		switch (type) {
179 		case T_RESADFLT:	/* reserved addressing fault */
180 		case T_PRIVINFLT:	/* privileged instruction fault */
181 		case T_RESOPFLT:	/* reserved operand fault */
182 			ucode = type;
183 			i = SIGILL;
184 			break;
185 
186 		case T_BPTFLT:		/* bpt instruction fault */
187 		case T_TRCTRAP:		/* trace trap */
188 			frame.tf_eflags &= ~PSL_T;
189 			i = SIGTRAP;
190 			break;
191 
192 		case T_ARITHTRAP:	/* arithmetic trap */
193 			ucode = code;
194 			i = SIGFPE;
195 			break;
196 
197 		case T_ASTFLT:		/* Allow process switch */
198 			astoff();
199 			cnt.v_soft++;
200 			if ((p->p_flag & P_OWEUPC) && p->p_stats->p_prof.pr_scale) {
201 				addupc(frame.tf_eip, &p->p_stats->p_prof, 1);
202 				p->p_flag &= ~P_OWEUPC;
203 			}
204 			goto out;
205 
206 		case T_PROTFLT:		/* general protection fault */
207 		case T_SEGNPFLT:	/* segment not present fault */
208 		case T_STKFLT:		/* stack fault */
209 			ucode = code + BUS_SEGM_FAULT ;
210 			i = SIGBUS;
211 			break;
212 
213 		case T_PAGEFLT:		/* page fault */
214 			i = trap_pfault(&frame, TRUE);
215 			if (i == 0)
216 				goto out;
217 
218 			ucode = T_PAGEFLT;
219 			break;
220 
221 		case T_DIVIDE:		/* integer divide fault */
222 			ucode = FPE_INTDIV_TRAP;
223 			i = SIGFPE;
224 			break;
225 
226 #if NISA > 0
227 		case T_NMI:
228 #if NDDB > 0
229 			/* NMI can be hooked up to a pushbutton for debugging */
230 			printf ("NMI ... going to debugger\n");
231 			if (kdb_trap (type, 0, &frame))
232 				return;
233 #endif
234 			/* machine/parity/power fail/"kitchen sink" faults */
235 			if (isa_nmi(code) == 0) return;
236 			panic("NMI indicates hardware failure");
237 #endif
238 
239 		case T_OFLOW:		/* integer overflow fault */
240 			ucode = FPE_INTOVF_TRAP;
241 			i = SIGFPE;
242 			break;
243 
244 		case T_BOUND:		/* bounds check fault */
245 			ucode = FPE_SUBRNG_TRAP;
246 			i = SIGFPE;
247 			break;
248 
249 		case T_DNA:
250 #if NNPX > 0
251 			/* if a transparent fault (due to context switch "late") */
252 			if (npxdna())
253 				return;
254 #endif	/* NNPX > 0 */
255 
256 #if defined(MATH_EMULATE) || defined(GPL_MATH_EMULATE)
257 			i = math_emulate(&frame);
258 			if (i == 0) return;
259 #else	/* MATH_EMULATE || GPL_MATH_EMULATE */
260 			panic("trap: math emulation necessary!");
261 #endif	/* MATH_EMULATE || GPL_MATH_EMULATE */
262 			ucode = FPE_FPU_NP_TRAP;
263 			break;
264 
265 		case T_FPOPFLT:		/* FPU operand fetch fault */
266 			ucode = T_FPOPFLT;
267 			i = SIGILL;
268 			break;
269 
270 		default:
271 			trap_fatal(&frame);
272 		}
273 	} else {
274 		/* kernel trap */
275 
276 		switch (type) {
277 		case T_PAGEFLT:			/* page fault */
278 			(void) trap_pfault(&frame, FALSE);
279 			return;
280 
281 		case T_PROTFLT:		/* general protection fault */
282 		case T_SEGNPFLT:	/* segment not present fault */
283 			if (curpcb && curpcb->pcb_onfault) {
284 				frame.tf_eip = (int)curpcb->pcb_onfault;
285 				return;
286 			}
287 			break;
288 
289 #if NDDB > 0
290 		case T_BPTFLT:
291 		case T_TRCTRAP:
292 			if (kdb_trap (type, 0, &frame))
293 				return;
294 			break;
295 #else
296 		case T_TRCTRAP:	 /* trace trap -- someone single stepping lcall's */
297 			/* Q: how do we turn it on again? */
298 			frame.tf_eflags &= ~PSL_T;
299 			return;
300 #endif
301 
302 #if NISA > 0
303 		case T_NMI:
304 #if NDDB > 0
305 			/* NMI can be hooked up to a pushbutton for debugging */
306 			printf ("NMI ... going to debugger\n");
307 			if (kdb_trap (type, 0, &frame))
308 				return;
309 #endif
310 			/* machine/parity/power fail/"kitchen sink" faults */
311 			if (isa_nmi(code) == 0) return;
312 			/* FALL THROUGH */
313 #endif
314 		}
315 
316 		trap_fatal(&frame);
317 	}
318 
319 	trapsignal(p, i, ucode);
320 
321 #ifdef DIAGNOSTIC
322 	eva = rcr2();
323 	if (type <= MAX_TRAP_MSG) {
324 		uprintf("fatal process exception: %s",
325 			trap_msg[type]);
326 		if ((type == T_PAGEFLT) || (type == T_PROTFLT))
327 			uprintf(", fault VA = 0x%x", eva);
328 		uprintf("\n");
329 	}
330 #endif
331 
332 out:
333 	userret(p, &frame, sticks);
334 }
335 
336 int
337 trap_pfault(frame, usermode)
338 	struct trapframe *frame;
339 	int usermode;
340 {
341 	vm_offset_t va;
342 	struct vmspace *vm;
343 	vm_map_t map = 0;
344 	int rv = 0, oldflags;
345 	vm_prot_t ftype;
346 	extern vm_map_t kernel_map;
347 	int eva;
348 	struct proc *p = curproc;
349 
350 	eva = rcr2();
351 	va = trunc_page((vm_offset_t)eva);
352 
353 	/*
354 	 * Don't allow user-mode faults in kernel address space
355 	 */
356 	if (usermode && (va >= KERNBASE)) {
357         	goto nogo;
358 	}
359 
360 	if ((p == 0) || (va >= KERNBASE)) {
361 		vm = 0;
362 		map = kernel_map;
363 	} else {
364 		vm = p->p_vmspace;
365 		map = &vm->vm_map;
366 	}
367 
368 	if (frame->tf_err & PGEX_W)
369 		ftype = VM_PROT_READ | VM_PROT_WRITE;
370 	else
371 		ftype = VM_PROT_READ;
372 
373 	if (map != kernel_map) {
374 		vm_offset_t pa;
375 		vm_offset_t v = (vm_offset_t) vtopte(va);
376 		vm_page_t ptepg;
377 
378 		/*
379 		 * Keep swapout from messing with us during this
380 		 *	critical time.
381 		 */
382 		++p->p_lock;
383 
384 		/*
385 		 * Grow the stack if necessary
386 		 */
387 		if ((caddr_t)va > vm->vm_maxsaddr
388 		    && (caddr_t)va < (caddr_t)USRSTACK) {
389 			if (!grow(p, va)) {
390 				rv = KERN_FAILURE;
391 				--p->p_lock;
392 				goto nogo;
393 			}
394 		}
395 
396 		/*
397 		 * Check if page table is mapped, if not,
398 		 *	fault it first
399 		 */
400 
401 		/* Fault the pte only if needed: */
402 		*(volatile char *)v += 0;
403 
404 		ptepg = (vm_page_t) pmap_pte_vm_page(vm_map_pmap(map), v);
405 		if( ptepg->hold_count == 0)
406 			ptepg->act_count += 3;
407 		vm_page_hold(ptepg);
408 
409 		/* Fault in the user page: */
410 		rv = vm_fault(map, va, ftype, FALSE);
411 
412 		vm_page_unhold(ptepg);
413 
414 		/*
415 		 * page table pages don't need to be kept if they
416 		 * are not held
417 		 */
418 		if( ptepg->hold_count == 0 && ptepg->wire_count == 0) {
419 			pmap_page_protect( VM_PAGE_TO_PHYS(ptepg),
420 				VM_PROT_NONE);
421 			vm_page_free(ptepg);
422 		}
423 
424 		--p->p_lock;
425 	} else {
426 		/*
427 		 * Since we know that kernel virtual address addresses
428 		 * always have pte pages mapped, we just have to fault
429 		 * the page.
430 		 */
431 		rv = vm_fault(map, va, ftype, FALSE);
432 	}
433 
434 	if (rv == KERN_SUCCESS)
435 		return (0);
436 nogo:
437 	if (!usermode) {
438 		if (curpcb->pcb_onfault) {
439 			frame->tf_eip = (int)curpcb->pcb_onfault;
440 			return (0);
441 		}
442 		trap_fatal(frame);
443 	}
444 
445 	/* kludge to pass faulting virtual address to sendsig */
446 	frame->tf_err = eva;
447 
448 	return((rv == KERN_PROTECTION_FAILURE) ? SIGBUS : SIGSEGV);
449 }
450 
451 void
452 trap_fatal(frame)
453 	struct trapframe *frame;
454 {
455 	int code, type, eva;
456 
457 	code = frame->tf_err;
458 	type = frame->tf_trapno;
459 	eva = rcr2();
460 
461 	if (type <= MAX_TRAP_MSG)
462 		printf("\n\nFatal trap %d: %s while in %s mode\n",
463 			type, trap_msg[type],
464 			ISPL(frame->tf_cs) == SEL_UPL ? "user" : "kernel");
465 	if (type == T_PAGEFLT) {
466 		printf("fault virtual address	= 0x%x\n", eva);
467 		printf("fault code		= %s %s, %s\n",
468 			code & PGEX_U ? "user" : "supervisor",
469 			code & PGEX_W ? "write" : "read",
470 			code & PGEX_P ? "protection violation" : "page not present");
471 	}
472 	printf("instruction pointer	= 0x%x\n", frame->tf_eip);
473 	printf("processor eflags	= ");
474 	if (frame->tf_eflags & EFL_TF)
475 		printf("trace/trap, ");
476 	if (frame->tf_eflags & EFL_IF)
477 		printf("interrupt enabled, ");
478 	if (frame->tf_eflags & EFL_NT)
479 		printf("nested task, ");
480 	if (frame->tf_eflags & EFL_RF)
481 		printf("resume, ");
482 	if (frame->tf_eflags & EFL_VM)
483 		printf("vm86, ");
484 	printf("IOPL = %d\n", (frame->tf_eflags & EFL_IOPL) >> 12);
485 	printf("current process		= ");
486 	if (curproc) {
487 		printf("%d (%s)\n",
488 		    curproc->p_pid, curproc->p_comm ?
489 		    curproc->p_comm : "");
490 	} else {
491 		printf("Idle\n");
492 	}
493 	printf("interrupt mask		= ");
494 	if ((cpl & net_imask) == net_imask)
495 		printf("net ");
496 	if ((cpl & tty_imask) == tty_imask)
497 		printf("tty ");
498 	if ((cpl & bio_imask) == bio_imask)
499 		printf("bio ");
500 	if (cpl == 0)
501 		printf("none");
502 	printf("\n");
503 
504 #ifdef KDB
505 	if (kdb_trap(&psl))
506 		return;
507 #endif
508 #if NDDB > 0
509 	if (kdb_trap (type, 0, frame))
510 		return;
511 #endif
512 	if (type <= MAX_TRAP_MSG)
513 		panic(trap_msg[type]);
514 	else
515 		panic("unknown/reserved trap");
516 }
517 
518 /*
519  * Compensate for 386 brain damage (missing URKR).
520  * This is a little simpler than the pagefault handler in trap() because
521  * it the page tables have already been faulted in and high addresses
522  * are thrown out early for other reasons.
523  */
524 int trapwrite(addr)
525 	unsigned addr;
526 {
527 	struct proc *p;
528 	vm_offset_t va, v;
529 	struct vmspace *vm;
530 	int oldflags;
531 	int rv;
532 
533 	va = trunc_page((vm_offset_t)addr);
534 	/*
535 	 * XXX - MAX is END.  Changed > to >= for temp. fix.
536 	 */
537 	if (va >= VM_MAXUSER_ADDRESS)
538 		return (1);
539 
540 	p = curproc;
541 	vm = p->p_vmspace;
542 
543 	++p->p_lock;
544 
545 	if ((caddr_t)va >= vm->vm_maxsaddr
546 	    && (caddr_t)va < (caddr_t)USRSTACK) {
547 		if (!grow(p, va)) {
548 			--p->p_lock;
549 			return (1);
550 		}
551 	}
552 
553 	v = trunc_page(vtopte(va));
554 
555 	/*
556 	 * wire the pte page
557 	 */
558 	if (va < USRSTACK) {
559 		vm_map_pageable(&vm->vm_map, v, round_page(v+1), FALSE);
560 	}
561 
562 	/*
563 	 * fault the data page
564 	 */
565 	rv = vm_fault(&vm->vm_map, va, VM_PROT_READ|VM_PROT_WRITE, FALSE);
566 
567 	/*
568 	 * unwire the pte page
569 	 */
570 	if (va < USRSTACK) {
571 		vm_map_pageable(&vm->vm_map, v, round_page(v+1), TRUE);
572 	}
573 
574 	--p->p_lock;
575 
576 	if (rv != KERN_SUCCESS)
577 		return 1;
578 
579 	return (0);
580 }
581 
582 /*
583  * syscall(frame):
584  *	System call request from POSIX system call gate interface to kernel.
585  * Like trap(), argument is call by reference.
586  */
587 /*ARGSUSED*/
588 void
589 syscall(frame)
590 	struct trapframe frame;
591 {
592 	caddr_t params;
593 	int i;
594 	struct sysent *callp;
595 	struct proc *p = curproc;
596 	u_quad_t sticks;
597 	int error, opc;
598 	int args[8], rval[2];
599 	u_int code;
600 
601 	sticks = p->p_sticks;
602 	if (ISPL(frame.tf_cs) != SEL_UPL)
603 		panic("syscall");
604 
605 	code = frame.tf_eax;
606 	p->p_md.md_regs = (int *)&frame;
607 	params = (caddr_t)frame.tf_esp + sizeof (int) ;
608 
609 	/*
610 	 * Reconstruct pc, assuming lcall $X,y is 7 bytes, as it is always.
611 	 */
612 	opc = frame.tf_eip - 7;
613 	/*
614 	 * Need to check if this is a 32 bit or 64 bit syscall.
615 	 */
616 	if (code == SYS_syscall) {
617 		/*
618 		 * Code is first argument, followed by actual args.
619 		 */
620 		code = fuword(params);
621 		params += sizeof (int);
622 	} else if (code == SYS___syscall) {
623 		/*
624 		 * Like syscall, but code is a quad, so as to maintain
625 		 * quad alignment for the rest of the arguments.
626 		 */
627 		code = fuword(params + _QUAD_LOWWORD * sizeof(int));
628 		params += sizeof(quad_t);
629 	}
630 
631  	if (p->p_sysent->sv_mask)
632  		code = code & p->p_sysent->sv_mask;
633 
634  	if (code < 0 || code >= p->p_sysent->sv_size)
635  		callp = &p->p_sysent->sv_table[0];
636   	else
637  		callp = &p->p_sysent->sv_table[code];
638 
639 	if ((i = callp->sy_narg * sizeof (int)) &&
640 	    (error = copyin(params, (caddr_t)args, (u_int)i))) {
641 #ifdef KTRACE
642 		if (KTRPOINT(p, KTR_SYSCALL))
643 			ktrsyscall(p->p_tracep, code, callp->sy_narg, args);
644 #endif
645 		goto bad;
646 	}
647 #ifdef KTRACE
648 	if (KTRPOINT(p, KTR_SYSCALL))
649 		ktrsyscall(p->p_tracep, code, callp->sy_narg, args);
650 #endif
651 	rval[0] = 0;
652 	rval[1] = frame.tf_edx;
653 
654 	error = (*callp->sy_call)(p, args, rval);
655 
656 	switch (error) {
657 
658 	case 0:
659 		/*
660 		 * Reinitialize proc pointer `p' as it may be different
661 		 * if this is a child returning from fork syscall.
662 		 */
663 		p = curproc;
664 		frame.tf_eax = rval[0];
665 		frame.tf_edx = rval[1];
666 		frame.tf_eflags &= ~PSL_C;	/* carry bit */
667 		break;
668 
669 	case ERESTART:
670 		frame.tf_eip = opc;
671 		break;
672 
673 	case EJUSTRETURN:
674 		break;
675 
676 	default:
677 	bad:
678 		frame.tf_eax = error;
679 		frame.tf_eflags |= PSL_C;	/* carry bit */
680 		break;
681 	}
682 
683 	userret(p, &frame, sticks);
684 
685 #ifdef KTRACE
686 	if (KTRPOINT(p, KTR_SYSRET))
687 		ktrsysret(p->p_tracep, code, error, rval[0]);
688 #endif
689 }
690