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