Remove upc_{control,register} syscalls and everything that has to do with it.
[dragonfly.git] / sys / platform / pc64 / x86_64 / trap.c
1 /*-
2  * Copyright (c) 1990, 1993
3  *      The Regents of the University of California.  All rights reserved.
4  * Copyright (C) 1994, David Greenman
5  * Copyright (c) 2008 The DragonFly Project.
6  * Copyright (c) 2008 Jordan Gordeev.
7  *
8  * This code is derived from software contributed to Berkeley by
9  * the University of Utah, and William Jolitz.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions and the following disclaimer.
16  * 2. Redistributions in binary form must reproduce the above copyright
17  *    notice, this list of conditions and the following disclaimer in the
18  *    documentation and/or other materials provided with the distribution.
19  * 3. All advertising materials mentioning features or use of this software
20  *    must display the following acknowledgement:
21  *      This product includes software developed by the University of
22  *      California, Berkeley and its contributors.
23  * 4. Neither the name of the University nor the names of its contributors
24  *    may be used to endorse or promote products derived from this software
25  *    without specific prior written permission.
26  *
27  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
28  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
29  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
30  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
31  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
32  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
33  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
34  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
35  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
36  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
37  * SUCH DAMAGE.
38  *
39  * from: @(#)trap.c     7.4 (Berkeley) 5/13/91
40  * $FreeBSD: src/sys/i386/i386/trap.c,v 1.147.2.11 2003/02/27 19:09:59 luoqi Exp $
41  */
42
43 /*
44  * x86_64 Trap and System call handling
45  */
46
47 #include "use_isa.h"
48
49 #include "opt_ddb.h"
50 #include "opt_ktrace.h"
51
52 #include <machine/frame.h>
53 #include <sys/param.h>
54 #include <sys/systm.h>
55 #include <sys/kernel.h>
56 #include <sys/kerneldump.h>
57 #include <sys/proc.h>
58 #include <sys/pioctl.h>
59 #include <sys/types.h>
60 #include <sys/signal2.h>
61 #include <sys/syscall.h>
62 #include <sys/sysctl.h>
63 #include <sys/sysent.h>
64 #include <sys/systm.h>
65 #ifdef KTRACE
66 #include <sys/ktrace.h>
67 #endif
68 #include <sys/ktr.h>
69 #include <sys/sysmsg.h>
70 #include <sys/sysproto.h>
71 #include <sys/sysunion.h>
72
73 #include <vm/pmap.h>
74 #include <vm/vm.h>
75 #include <vm/vm_extern.h>
76 #include <vm/vm_kern.h>
77 #include <vm/vm_param.h>
78 #include <machine/cpu.h>
79 #include <machine/pcb.h>
80 #include <machine/smp.h>
81 #include <machine/thread.h>
82 #include <machine/clock.h>
83 #include <machine/vmparam.h>
84 #include <machine/md_var.h>
85 #include <machine_base/isa/isa_intr.h>
86 #include <machine_base/apic/lapic.h>
87
88 #include <ddb/ddb.h>
89
90 #include <sys/thread2.h>
91 #include <sys/mplock2.h>
92
93 #define MAKEMPSAFE(have_mplock)                 \
94         if (have_mplock == 0) {                 \
95                 get_mplock();                   \
96                 have_mplock = 1;                \
97         }
98
99 extern void trap(struct trapframe *frame);
100
101 static int trap_pfault(struct trapframe *, int);
102 static void trap_fatal(struct trapframe *, vm_offset_t);
103 void dblfault_handler(struct trapframe *frame);
104
105 #define MAX_TRAP_MSG            30
106 static char *trap_msg[] = {
107         "",                                     /*  0 unused */
108         "privileged instruction fault",         /*  1 T_PRIVINFLT */
109         "",                                     /*  2 unused */
110         "breakpoint instruction fault",         /*  3 T_BPTFLT */
111         "",                                     /*  4 unused */
112         "",                                     /*  5 unused */
113         "arithmetic trap",                      /*  6 T_ARITHTRAP */
114         "system forced exception",              /*  7 T_ASTFLT */
115         "",                                     /*  8 unused */
116         "general protection fault",             /*  9 T_PROTFLT */
117         "trace trap",                           /* 10 T_TRCTRAP */
118         "",                                     /* 11 unused */
119         "page fault",                           /* 12 T_PAGEFLT */
120         "",                                     /* 13 unused */
121         "alignment fault",                      /* 14 T_ALIGNFLT */
122         "",                                     /* 15 unused */
123         "",                                     /* 16 unused */
124         "",                                     /* 17 unused */
125         "integer divide fault",                 /* 18 T_DIVIDE */
126         "non-maskable interrupt trap",          /* 19 T_NMI */
127         "overflow trap",                        /* 20 T_OFLOW */
128         "FPU bounds check fault",               /* 21 T_BOUND */
129         "FPU device not available",             /* 22 T_DNA */
130         "double fault",                         /* 23 T_DOUBLEFLT */
131         "FPU operand fetch fault",              /* 24 T_FPOPFLT */
132         "invalid TSS fault",                    /* 25 T_TSSFLT */
133         "segment not present fault",            /* 26 T_SEGNPFLT */
134         "stack fault",                          /* 27 T_STKFLT */
135         "machine check trap",                   /* 28 T_MCHK */
136         "SIMD floating-point exception",        /* 29 T_XMMFLT */
137         "reserved (unknown) fault",             /* 30 T_RESERVED */
138 };
139
140 #ifdef DDB
141 static int ddb_on_nmi = 1;
142 SYSCTL_INT(_machdep, OID_AUTO, ddb_on_nmi, CTLFLAG_RW,
143         &ddb_on_nmi, 0, "Go to DDB on NMI");
144 static int ddb_on_seg_fault = 0;
145 SYSCTL_INT(_machdep, OID_AUTO, ddb_on_seg_fault, CTLFLAG_RW,
146         &ddb_on_seg_fault, 0, "Go to DDB on user seg-fault");
147 static int freeze_on_seg_fault = 0;
148 SYSCTL_INT(_machdep, OID_AUTO, freeze_on_seg_fault, CTLFLAG_RW,
149         &freeze_on_seg_fault, 0, "Go to DDB on user seg-fault");
150 #endif
151 static int panic_on_nmi = 1;
152 SYSCTL_INT(_machdep, OID_AUTO, panic_on_nmi, CTLFLAG_RW,
153         &panic_on_nmi, 0, "Panic on NMI");
154 static int fast_release;
155 SYSCTL_INT(_machdep, OID_AUTO, fast_release, CTLFLAG_RW,
156         &fast_release, 0, "Passive Release was optimal");
157 static int slow_release;
158 SYSCTL_INT(_machdep, OID_AUTO, slow_release, CTLFLAG_RW,
159         &slow_release, 0, "Passive Release was nonoptimal");
160
161 /*
162  * System call debugging records the worst-case system call
163  * overhead (inclusive of blocking), but may be inaccurate.
164  */
165 /*#define SYSCALL_DEBUG*/
166 #ifdef SYSCALL_DEBUG
167 uint64_t SysCallsWorstCase[SYS_MAXSYSCALL];
168 #endif
169
170 /*
171  * Passively intercepts the thread switch function to increase
172  * the thread priority from a user priority to a kernel priority, reducing
173  * syscall and trap overhead for the case where no switch occurs.
174  *
175  * Synchronizes td_ucred with p_ucred.  This is used by system calls,
176  * signal handling, faults, AST traps, and anything else that enters the
177  * kernel from userland and provides the kernel with a stable read-only
178  * copy of the process ucred.
179  */
180 static __inline void
181 userenter(struct thread *curtd, struct proc *curp)
182 {
183         struct ucred *ocred;
184         struct ucred *ncred;
185
186         curtd->td_release = lwkt_passive_release;
187
188         if (curtd->td_ucred != curp->p_ucred) {
189                 ncred = crhold(curp->p_ucred);
190                 ocred = curtd->td_ucred;
191                 curtd->td_ucred = ncred;
192                 if (ocred)
193                         crfree(ocred);
194         }
195
196 #ifdef DDB
197         /*
198          * Debugging, remove top two user stack pages to catch kernel faults
199          */
200         if (freeze_on_seg_fault > 1 && curtd->td_lwp) {
201                 pmap_remove(vmspace_pmap(curtd->td_lwp->lwp_vmspace),
202                             0x00007FFFFFFFD000LU,
203                             0x0000800000000000LU);
204         }
205 #endif
206 }
207
208 /*
209  * Handle signals, upcalls, profiling, and other AST's and/or tasks that
210  * must be completed before we can return to or try to return to userland.
211  *
212  * Note that td_sticks is a 64 bit quantity, but there's no point doing 64
213  * arithmatic on the delta calculation so the absolute tick values are
214  * truncated to an integer.
215  */
216 static void
217 userret(struct lwp *lp, struct trapframe *frame, int sticks)
218 {
219         struct proc *p = lp->lwp_proc;
220         int sig;
221
222         /*
223          * Charge system time if profiling.  Note: times are in microseconds.
224          * This may do a copyout and block, so do it first even though it
225          * means some system time will be charged as user time.
226          */
227         if (p->p_flags & P_PROFIL) {
228                 addupc_task(p, frame->tf_rip,
229                         (u_int)((int)lp->lwp_thread->td_sticks - sticks));
230         }
231
232 recheck:
233         /*
234          * Specific on-return-to-usermode checks (LWP_MP_WEXIT,
235          * LWP_MP_VNLRU, etc).
236          */
237         if (lp->lwp_mpflags & LWP_MP_URETMASK)
238                 lwpuserret(lp);
239
240         /*
241          * Block here if we are in a stopped state.
242          */
243         if (p->p_stat == SSTOP || dump_stop_usertds) {
244                 lwkt_gettoken(&p->p_token);
245                 tstop();
246                 lwkt_reltoken(&p->p_token);
247                 goto recheck;
248         }
249
250         /*
251          * Post any pending upcalls.  If running a virtual kernel be sure
252          * to restore the virtual kernel's vmspace before posting the upcall.
253          */
254         if (p->p_flags & (P_SIGVTALRM | P_SIGPROF)) {
255                 lwkt_gettoken(&p->p_token);
256                 if (p->p_flags & P_SIGVTALRM) {
257                         p->p_flags &= ~P_SIGVTALRM;
258                         ksignal(p, SIGVTALRM);
259                 }
260                 if (p->p_flags & P_SIGPROF) {
261                         p->p_flags &= ~P_SIGPROF;
262                         ksignal(p, SIGPROF);
263                 }
264                 lwkt_reltoken(&p->p_token);
265                 goto recheck;
266         }
267
268         /*
269          * Post any pending signals.  If running a virtual kernel be sure
270          * to restore the virtual kernel's vmspace before posting the signal.
271          *
272          * WARNING!  postsig() can exit and not return.
273          */
274         if ((sig = CURSIG_TRACE(lp)) != 0) {
275                 lwkt_gettoken(&p->p_token);
276                 postsig(sig);
277                 lwkt_reltoken(&p->p_token);
278                 goto recheck;
279         }
280
281         /*
282          * block here if we are swapped out, but still process signals
283          * (such as SIGKILL).  proc0 (the swapin scheduler) is already
284          * aware of our situation, we do not have to wake it up.
285          */
286         if (p->p_flags & P_SWAPPEDOUT) {
287                 lwkt_gettoken(&p->p_token);
288                 get_mplock();
289                 p->p_flags |= P_SWAPWAIT;
290                 swapin_request();
291                 if (p->p_flags & P_SWAPWAIT)
292                         tsleep(p, PCATCH, "SWOUT", 0);
293                 p->p_flags &= ~P_SWAPWAIT;
294                 rel_mplock();
295                 lwkt_reltoken(&p->p_token);
296                 goto recheck;
297         }
298
299         /*
300          * In a multi-threaded program it is possible for a thread to change
301          * signal state during a system call which temporarily changes the
302          * signal mask.  In this case postsig() might not be run and we
303          * have to restore the mask ourselves.
304          */
305         if (lp->lwp_flags & LWP_OLDMASK) {
306                 lp->lwp_flags &= ~LWP_OLDMASK;
307                 lp->lwp_sigmask = lp->lwp_oldsigmask;
308                 goto recheck;
309         }
310 }
311
312 /*
313  * Cleanup from userenter and any passive release that might have occured.
314  * We must reclaim the current-process designation before we can return
315  * to usermode.  We also handle both LWKT and USER reschedule requests.
316  */
317 static __inline void
318 userexit(struct lwp *lp)
319 {
320         struct thread *td = lp->lwp_thread;
321         /* globaldata_t gd = td->td_gd; */
322
323         /*
324          * Handle stop requests at kernel priority.  Any requests queued
325          * after this loop will generate another AST.
326          */
327         while (lp->lwp_proc->p_stat == SSTOP) {
328                 lwkt_gettoken(&lp->lwp_proc->p_token);
329                 tstop();
330                 lwkt_reltoken(&lp->lwp_proc->p_token);
331         }
332
333         /*
334          * Reduce our priority in preparation for a return to userland.  If
335          * our passive release function was still in place, our priority was
336          * never raised and does not need to be reduced.
337          */
338         lwkt_passive_recover(td);
339
340         /* WARNING: we may have migrated cpu's */
341         /* gd = td->td_gd; */
342
343         /*
344          * Become the current user scheduled process if we aren't already,
345          * and deal with reschedule requests and other factors.
346          */
347         lp->lwp_proc->p_usched->acquire_curproc(lp);
348 }
349
350 #if !defined(KTR_KERNENTRY)
351 #define KTR_KERNENTRY   KTR_ALL
352 #endif
353 KTR_INFO_MASTER(kernentry);
354 KTR_INFO(KTR_KERNENTRY, kernentry, trap, 0,
355          "TRAP(pid %d, tid %d, trapno %ld, eva %lu)",
356          pid_t pid, lwpid_t tid,  register_t trapno, vm_offset_t eva);
357 KTR_INFO(KTR_KERNENTRY, kernentry, trap_ret, 0, "TRAP_RET(pid %d, tid %d)",
358          pid_t pid, lwpid_t tid);
359 KTR_INFO(KTR_KERNENTRY, kernentry, syscall, 0, "SYSC(pid %d, tid %d, nr %ld)",
360          pid_t pid, lwpid_t tid,  register_t trapno);
361 KTR_INFO(KTR_KERNENTRY, kernentry, syscall_ret, 0, "SYSRET(pid %d, tid %d, err %d)",
362          pid_t pid, lwpid_t tid,  int err);
363 KTR_INFO(KTR_KERNENTRY, kernentry, fork_ret, 0, "FORKRET(pid %d, tid %d)",
364          pid_t pid, lwpid_t tid);
365
366 /*
367  * Exception, fault, and trap interface to the kernel.
368  * This common code is called from assembly language IDT gate entry
369  * routines that prepare a suitable stack frame, and restore this
370  * frame after the exception has been processed.
371  *
372  * This function is also called from doreti in an interlock to handle ASTs.
373  * For example:  hardwareint->INTROUTINE->(set ast)->doreti->trap
374  *
375  * NOTE!  We have to retrieve the fault address prior to obtaining the
376  * MP lock because get_mplock() may switch out.  YYY cr2 really ought
377  * to be retrieved by the assembly code, not here.
378  *
379  * XXX gd_trap_nesting_level currently prevents lwkt_switch() from panicing
380  * if an attempt is made to switch from a fast interrupt or IPI.  This is
381  * necessary to properly take fatal kernel traps on SMP machines if
382  * get_mplock() has to block.
383  */
384
385 void
386 trap(struct trapframe *frame)
387 {
388         struct globaldata *gd = mycpu;
389         struct thread *td = gd->gd_curthread;
390         struct lwp *lp = td->td_lwp;
391         struct proc *p;
392         int sticks = 0;
393         int i = 0, ucode = 0, type, code;
394         int have_mplock = 0;
395 #ifdef INVARIANTS
396         int crit_count = td->td_critcount;
397         lwkt_tokref_t curstop = td->td_toks_stop;
398 #endif
399         vm_offset_t eva;
400
401         p = td->td_proc;
402         clear_quickret();
403
404 #ifdef DDB
405         /*
406          * We need to allow T_DNA faults when the debugger is active since
407          * some dumping paths do large bcopy() which use the floating
408          * point registers for faster copying.
409          */
410         if (db_active && frame->tf_trapno != T_DNA) {
411                 eva = (frame->tf_trapno == T_PAGEFLT ? frame->tf_addr : 0);
412                 ++gd->gd_trap_nesting_level;
413                 MAKEMPSAFE(have_mplock);
414                 trap_fatal(frame, eva);
415                 --gd->gd_trap_nesting_level;
416                 goto out2;
417         }
418 #endif
419
420         eva = 0;
421
422         if ((frame->tf_rflags & PSL_I) == 0) {
423                 /*
424                  * Buggy application or kernel code has disabled interrupts
425                  * and then trapped.  Enabling interrupts now is wrong, but
426                  * it is better than running with interrupts disabled until
427                  * they are accidentally enabled later.
428                  */
429                 type = frame->tf_trapno;
430                 if (ISPL(frame->tf_cs) == SEL_UPL) {
431                         MAKEMPSAFE(have_mplock);
432                         /* JG curproc can be NULL */
433                         kprintf(
434                             "pid %ld (%s): trap %d with interrupts disabled\n",
435                             (long)curproc->p_pid, curproc->p_comm, type);
436                 } else if (type != T_NMI && type != T_BPTFLT &&
437                     type != T_TRCTRAP) {
438                         /*
439                          * XXX not quite right, since this may be for a
440                          * multiple fault in user mode.
441                          */
442                         MAKEMPSAFE(have_mplock);
443                         kprintf("kernel trap %d with interrupts disabled\n",
444                             type);
445                 }
446                 cpu_enable_intr();
447         }
448
449         type = frame->tf_trapno;
450         code = frame->tf_err;
451
452         if (ISPL(frame->tf_cs) == SEL_UPL) {
453                 /* user trap */
454
455                 KTR_LOG(kernentry_trap, p->p_pid, lp->lwp_tid,
456                         frame->tf_trapno, eva);
457
458                 userenter(td, p);
459
460                 sticks = (int)td->td_sticks;
461                 KASSERT(lp->lwp_md.md_regs == frame,
462                         ("Frame mismatch %p %p", lp->lwp_md.md_regs, frame));
463
464                 switch (type) {
465                 case T_PRIVINFLT:       /* privileged instruction fault */
466                         i = SIGILL;
467                         ucode = ILL_PRVOPC;
468                         break;
469
470                 case T_BPTFLT:          /* bpt instruction fault */
471                 case T_TRCTRAP:         /* trace trap */
472                         frame->tf_rflags &= ~PSL_T;
473                         i = SIGTRAP;
474                         ucode = (type == T_TRCTRAP ? TRAP_TRACE : TRAP_BRKPT);
475                         break;
476
477                 case T_ARITHTRAP:       /* arithmetic trap */
478                         ucode = code;
479                         i = SIGFPE;
480                         break;
481
482                 case T_ASTFLT:          /* Allow process switch */
483                         mycpu->gd_cnt.v_soft++;
484                         if (mycpu->gd_reqflags & RQF_AST_OWEUPC) {
485                                 atomic_clear_int(&mycpu->gd_reqflags,
486                                                  RQF_AST_OWEUPC);
487                                 addupc_task(p, p->p_prof.pr_addr,
488                                             p->p_prof.pr_ticks);
489                         }
490                         goto out;
491
492                 case T_PROTFLT:         /* general protection fault */
493                         i = SIGBUS;
494                         ucode = BUS_OBJERR;
495                         break;
496                 case T_STKFLT:          /* stack fault */
497                 case T_SEGNPFLT:        /* segment not present fault */
498                         i = SIGBUS;
499                         ucode = BUS_ADRERR;
500                         break;
501                 case T_TSSFLT:          /* invalid TSS fault */
502                 case T_DOUBLEFLT:       /* double fault */
503                 default:
504                         i = SIGBUS;
505                         ucode = BUS_OBJERR;
506                         break;
507
508                 case T_PAGEFLT:         /* page fault */
509                         i = trap_pfault(frame, TRUE);
510                         if (frame->tf_rip == 0) {
511                                 kprintf("T_PAGEFLT: Warning %%rip == 0!\n");
512 #ifdef DDB
513                                 while (freeze_on_seg_fault)
514                                         tsleep(p, 0, "freeze", hz * 20);
515 #endif
516                         }
517                         if (i == -1 || i == 0)
518                                 goto out;
519
520
521                         if (i == SIGSEGV)
522                                 ucode = SEGV_MAPERR;
523                         else {
524                                 i = SIGSEGV;
525                                 ucode = SEGV_ACCERR;
526                         }
527                         break;
528
529                 case T_DIVIDE:          /* integer divide fault */
530                         ucode = FPE_INTDIV;
531                         i = SIGFPE;
532                         break;
533
534 #if NISA > 0
535                 case T_NMI:
536                         MAKEMPSAFE(have_mplock);
537                         /* machine/parity/power fail/"kitchen sink" faults */
538                         if (isa_nmi(code) == 0) {
539 #ifdef DDB
540                                 /*
541                                  * NMI can be hooked up to a pushbutton
542                                  * for debugging.
543                                  */
544                                 if (ddb_on_nmi) {
545                                         kprintf ("NMI ... going to debugger\n");
546                                         kdb_trap(type, 0, frame);
547                                 }
548 #endif /* DDB */
549                                 goto out2;
550                         } else if (panic_on_nmi)
551                                 panic("NMI indicates hardware failure");
552                         break;
553 #endif /* NISA > 0 */
554
555                 case T_OFLOW:           /* integer overflow fault */
556                         ucode = FPE_INTOVF;
557                         i = SIGFPE;
558                         break;
559
560                 case T_BOUND:           /* bounds check fault */
561                         ucode = FPE_FLTSUB;
562                         i = SIGFPE;
563                         break;
564
565                 case T_DNA:
566                         /*
567                          * Virtual kernel intercept - pass the DNA exception
568                          * to the virtual kernel if it asked to handle it.
569                          * This occurs when the virtual kernel is holding
570                          * onto the FP context for a different emulated
571                          * process then the one currently running.
572                          *
573                          * We must still call npxdna() since we may have
574                          * saved FP state that the virtual kernel needs
575                          * to hand over to a different emulated process.
576                          */
577                         if (lp->lwp_vkernel && lp->lwp_vkernel->ve &&
578                             (td->td_pcb->pcb_flags & FP_VIRTFP)
579                         ) {
580                                 npxdna();
581                                 break;
582                         }
583
584                         /*
585                          * The kernel may have switched out the FP unit's
586                          * state, causing the user process to take a fault
587                          * when it tries to use the FP unit.  Restore the
588                          * state here
589                          */
590                         if (npxdna())
591                                 goto out;
592                         i = SIGFPE;
593                         ucode = FPE_FPU_NP_TRAP;
594                         break;
595
596                 case T_FPOPFLT:         /* FPU operand fetch fault */
597                         ucode = ILL_COPROC;
598                         i = SIGILL;
599                         break;
600
601                 case T_XMMFLT:          /* SIMD floating-point exception */
602                         ucode = 0; /* XXX */
603                         i = SIGFPE;
604                         break;
605                 }
606         } else {
607                 /* kernel trap */
608
609                 switch (type) {
610                 case T_PAGEFLT:                 /* page fault */
611                         trap_pfault(frame, FALSE);
612                         goto out2;
613
614                 case T_DNA:
615                         /*
616                          * The kernel is apparently using fpu for copying.
617                          * XXX this should be fatal unless the kernel has
618                          * registered such use.
619                          */
620                         if (npxdna())
621                                 goto out2;
622                         break;
623
624                 case T_STKFLT:          /* stack fault */
625                         break;
626
627                 case T_PROTFLT:         /* general protection fault */
628                 case T_SEGNPFLT:        /* segment not present fault */
629                         /*
630                          * Invalid segment selectors and out of bounds
631                          * %rip's and %rsp's can be set up in user mode.
632                          * This causes a fault in kernel mode when the
633                          * kernel tries to return to user mode.  We want
634                          * to get this fault so that we can fix the
635                          * problem here and not have to check all the
636                          * selectors and pointers when the user changes
637                          * them.
638                          */
639                         if (mycpu->gd_intr_nesting_level == 0) {
640                                 /*
641                                  * NOTE: in 64-bit mode traps push rsp/ss
642                                  *       even if no ring change occurs.
643                                  */
644                                 if (td->td_pcb->pcb_onfault &&
645                                     td->td_pcb->pcb_onfault_sp ==
646                                     frame->tf_rsp) {
647                                         frame->tf_rip = (register_t)
648                                                 td->td_pcb->pcb_onfault;
649                                         goto out2;
650                                 }
651                                 if (frame->tf_rip == (long)doreti_iret) {
652                                         frame->tf_rip = (long)doreti_iret_fault;
653                                         goto out2;
654                                 }
655                         }
656                         break;
657
658                 case T_TSSFLT:
659                         /*
660                          * PSL_NT can be set in user mode and isn't cleared
661                          * automatically when the kernel is entered.  This
662                          * causes a TSS fault when the kernel attempts to
663                          * `iret' because the TSS link is uninitialized.  We
664                          * want to get this fault so that we can fix the
665                          * problem here and not every time the kernel is
666                          * entered.
667                          */
668                         if (frame->tf_rflags & PSL_NT) {
669                                 frame->tf_rflags &= ~PSL_NT;
670                                 goto out2;
671                         }
672                         break;
673
674                 case T_TRCTRAP:  /* trace trap */
675 #if 0
676                         if (frame->tf_rip == (int)IDTVEC(syscall)) {
677                                 /*
678                                  * We've just entered system mode via the
679                                  * syscall lcall.  Continue single stepping
680                                  * silently until the syscall handler has
681                                  * saved the flags.
682                                  */
683                                 goto out2;
684                         }
685                         if (frame->tf_rip == (int)IDTVEC(syscall) + 1) {
686                                 /*
687                                  * The syscall handler has now saved the
688                                  * flags.  Stop single stepping it.
689                                  */
690                                 frame->tf_rflags &= ~PSL_T;
691                                 goto out2;
692                         }
693 #endif
694
695                         /*
696                          * Ignore debug register trace traps due to
697                          * accesses in the user's address space, which
698                          * can happen under several conditions such as
699                          * if a user sets a watchpoint on a buffer and
700                          * then passes that buffer to a system call.
701                          * We still want to get TRCTRAPS for addresses
702                          * in kernel space because that is useful when
703                          * debugging the kernel.
704                          */
705 #if JG
706                         if (user_dbreg_trap()) {
707                                 /*
708                                  * Reset breakpoint bits because the
709                                  * processor doesn't
710                                  */
711                                 /* XXX check upper bits here */
712                                 load_dr6(rdr6() & 0xfffffff0);
713                                 goto out2;
714                         }
715 #endif
716                         /*
717                          * FALLTHROUGH (TRCTRAP kernel mode, kernel address)
718                          */
719                 case T_BPTFLT:
720                         /*
721                          * If DDB is enabled, let it handle the debugger trap.
722                          * Otherwise, debugger traps "can't happen".
723                          */
724                         ucode = TRAP_BRKPT;
725 #ifdef DDB
726                         MAKEMPSAFE(have_mplock);
727                         if (kdb_trap(type, 0, frame))
728                                 goto out2;
729 #endif
730                         break;
731
732 #if NISA > 0
733                 case T_NMI:
734                         MAKEMPSAFE(have_mplock);
735                         /* machine/parity/power fail/"kitchen sink" faults */
736                         if (isa_nmi(code) == 0) {
737 #ifdef DDB
738                                 /*
739                                  * NMI can be hooked up to a pushbutton
740                                  * for debugging.
741                                  */
742                                 if (ddb_on_nmi) {
743                                         kprintf ("NMI ... going to debugger\n");
744                                         kdb_trap(type, 0, frame);
745                                 }
746 #endif /* DDB */
747                                 goto out2;
748                         } else if (panic_on_nmi == 0)
749                                 goto out2;
750                         /* FALL THROUGH */
751 #endif /* NISA > 0 */
752                 }
753                 MAKEMPSAFE(have_mplock);
754                 trap_fatal(frame, 0);
755                 goto out2;
756         }
757
758         /*
759          * Virtual kernel intercept - if the fault is directly related to a
760          * VM context managed by a virtual kernel then let the virtual kernel
761          * handle it.
762          */
763         if (lp->lwp_vkernel && lp->lwp_vkernel->ve) {
764                 vkernel_trap(lp, frame);
765                 goto out;
766         }
767
768         /* Translate fault for emulators (e.g. Linux) */
769         if (*p->p_sysent->sv_transtrap)
770                 i = (*p->p_sysent->sv_transtrap)(i, type);
771
772         MAKEMPSAFE(have_mplock);
773         trapsignal(lp, i, ucode);
774
775 #ifdef DEBUG
776         if (type <= MAX_TRAP_MSG) {
777                 uprintf("fatal process exception: %s",
778                         trap_msg[type]);
779                 if ((type == T_PAGEFLT) || (type == T_PROTFLT))
780                         uprintf(", fault VA = 0x%lx", frame->tf_addr);
781                 uprintf("\n");
782         }
783 #endif
784
785 out:
786         userret(lp, frame, sticks);
787         userexit(lp);
788 out2:   ;
789         if (have_mplock)
790                 rel_mplock();
791         if (p != NULL && lp != NULL)
792                 KTR_LOG(kernentry_trap_ret, p->p_pid, lp->lwp_tid);
793 #ifdef INVARIANTS
794         KASSERT(crit_count == td->td_critcount,
795                 ("trap: critical section count mismatch! %d/%d",
796                 crit_count, td->td_pri));
797         KASSERT(curstop == td->td_toks_stop,
798                 ("trap: extra tokens held after trap! %ld/%ld",
799                 curstop - &td->td_toks_base,
800                 td->td_toks_stop - &td->td_toks_base));
801 #endif
802 }
803
804 static int
805 trap_pfault(struct trapframe *frame, int usermode)
806 {
807         vm_offset_t va;
808         struct vmspace *vm = NULL;
809         vm_map_t map;
810         int rv = 0;
811         int fault_flags;
812         vm_prot_t ftype;
813         thread_t td = curthread;
814         struct lwp *lp = td->td_lwp;
815         struct proc *p;
816
817         va = trunc_page(frame->tf_addr);
818         if (va >= VM_MIN_KERNEL_ADDRESS) {
819                 /*
820                  * Don't allow user-mode faults in kernel address space.
821                  */
822                 if (usermode) {
823                         fault_flags = -1;
824                         ftype = -1;
825                         goto nogo;
826                 }
827
828                 map = &kernel_map;
829         } else {
830                 /*
831                  * This is a fault on non-kernel virtual memory.
832                  * vm is initialized above to NULL. If curproc is NULL
833                  * or curproc->p_vmspace is NULL the fault is fatal.
834                  */
835                 if (lp != NULL)
836                         vm = lp->lwp_vmspace;
837
838                 if (vm == NULL) {
839                         fault_flags = -1;
840                         ftype = -1;
841                         goto nogo;
842                 }
843
844                 /*
845                  * Debugging, try to catch kernel faults on the user address space when not inside
846                  * on onfault (e.g. copyin/copyout) routine.
847                  */
848                 if (usermode == 0 && (td->td_pcb == NULL ||
849                     td->td_pcb->pcb_onfault == NULL)) {
850 #ifdef DDB
851                         if (freeze_on_seg_fault) {
852                                 kprintf("trap_pfault: user address fault from kernel mode "
853                                         "%016lx\n", (long)frame->tf_addr);
854                                 while (freeze_on_seg_fault)
855                                             tsleep(&freeze_on_seg_fault, 0, "frzseg", hz * 20);
856                         }
857 #endif
858                 }
859                 map = &vm->vm_map;
860         }
861
862         /*
863          * PGEX_I is defined only if the execute disable bit capability is
864          * supported and enabled.
865          */
866         if (frame->tf_err & PGEX_W)
867                 ftype = VM_PROT_WRITE;
868 #if JG
869         else if ((frame->tf_err & PGEX_I) && pg_nx != 0)
870                 ftype = VM_PROT_EXECUTE;
871 #endif
872         else
873                 ftype = VM_PROT_READ;
874
875         if (map != &kernel_map) {
876                 /*
877                  * Keep swapout from messing with us during this
878                  *      critical time.
879                  */
880                 PHOLD(lp->lwp_proc);
881
882                 /*
883                  * Issue fault
884                  */
885                 fault_flags = 0;
886                 if (usermode)
887                         fault_flags |= VM_FAULT_BURST;
888                 if (ftype & VM_PROT_WRITE)
889                         fault_flags |= VM_FAULT_DIRTY;
890                 else
891                         fault_flags |= VM_FAULT_NORMAL;
892                 rv = vm_fault(map, va, ftype, fault_flags);
893
894                 PRELE(lp->lwp_proc);
895         } else {
896                 /*
897                  * Don't have to worry about process locking or stacks in the
898                  * kernel.
899                  */
900                 fault_flags = VM_FAULT_NORMAL;
901                 rv = vm_fault(map, va, ftype, VM_FAULT_NORMAL);
902         }
903         if (rv == KERN_SUCCESS)
904                 return (0);
905 nogo:
906         if (!usermode) {
907                 /*
908                  * NOTE: in 64-bit mode traps push rsp/ss
909                  *       even if no ring change occurs.
910                  */
911                 if (td->td_pcb->pcb_onfault &&
912                     td->td_pcb->pcb_onfault_sp == frame->tf_rsp &&
913                     td->td_gd->gd_intr_nesting_level == 0) {
914                         frame->tf_rip = (register_t)td->td_pcb->pcb_onfault;
915                         return (0);
916                 }
917                 trap_fatal(frame, frame->tf_addr);
918                 return (-1);
919         }
920
921         /*
922          * NOTE: on x86_64 we have a tf_addr field in the trapframe, no
923          * kludge is needed to pass the fault address to signal handlers.
924          */
925         p = td->td_proc;
926         if (td->td_lwp->lwp_vkernel == NULL) {
927 #ifdef DDB
928                 if (bootverbose || freeze_on_seg_fault || ddb_on_seg_fault) {
929 #else
930                 if (bootverbose) {
931 #endif
932                         kprintf("seg-fault ft=%04x ff=%04x addr=%p rip=%p "
933                             "pid=%d cpu=%d p_comm=%s\n",
934                             ftype, fault_flags,
935                             (void *)frame->tf_addr,
936                             (void *)frame->tf_rip,
937                             p->p_pid, mycpu->gd_cpuid, p->p_comm);
938                 }
939 #ifdef DDB
940                 while (freeze_on_seg_fault) {
941                         tsleep(p, 0, "freeze", hz * 20);
942                 }
943                 if (ddb_on_seg_fault)
944                         Debugger("ddb_on_seg_fault");
945 #endif
946         }
947
948         return((rv == KERN_PROTECTION_FAILURE) ? SIGBUS : SIGSEGV);
949 }
950
951 static void
952 trap_fatal(struct trapframe *frame, vm_offset_t eva)
953 {
954         int code, ss;
955         u_int type;
956         long rsp;
957         struct soft_segment_descriptor softseg;
958         char *msg;
959
960         code = frame->tf_err;
961         type = frame->tf_trapno;
962         sdtossd(&gdt[IDXSEL(frame->tf_cs & 0xffff)], &softseg);
963
964         if (type <= MAX_TRAP_MSG)
965                 msg = trap_msg[type];
966         else
967                 msg = "UNKNOWN";
968         kprintf("\n\nFatal trap %d: %s while in %s mode\n", type, msg,
969             ISPL(frame->tf_cs) == SEL_UPL ? "user" : "kernel");
970         /* three separate prints in case of a trap on an unmapped page */
971         kprintf("cpuid = %d; ", mycpu->gd_cpuid);
972         kprintf("lapic->id = %08x\n", lapic->id);
973         if (type == T_PAGEFLT) {
974                 kprintf("fault virtual address  = 0x%lx\n", eva);
975                 kprintf("fault code             = %s %s %s, %s\n",
976                         code & PGEX_U ? "user" : "supervisor",
977                         code & PGEX_W ? "write" : "read",
978                         code & PGEX_I ? "instruction" : "data",
979                         code & PGEX_P ? "protection violation" : "page not present");
980         }
981         kprintf("instruction pointer    = 0x%lx:0x%lx\n",
982                frame->tf_cs & 0xffff, frame->tf_rip);
983         if (ISPL(frame->tf_cs) == SEL_UPL) {
984                 ss = frame->tf_ss & 0xffff;
985                 rsp = frame->tf_rsp;
986         } else {
987                 /*
988                  * NOTE: in 64-bit mode traps push rsp/ss even if no ring
989                  *       change occurs.
990                  */
991                 ss = GSEL(GDATA_SEL, SEL_KPL);
992                 rsp = frame->tf_rsp;
993         }
994         kprintf("stack pointer          = 0x%x:0x%lx\n", ss, rsp);
995         kprintf("frame pointer          = 0x%x:0x%lx\n", ss, frame->tf_rbp);
996         kprintf("code segment           = base 0x%lx, limit 0x%lx, type 0x%x\n",
997                softseg.ssd_base, softseg.ssd_limit, softseg.ssd_type);
998         kprintf("                       = DPL %d, pres %d, long %d, def32 %d, gran %d\n",
999                softseg.ssd_dpl, softseg.ssd_p, softseg.ssd_long, softseg.ssd_def32,
1000                softseg.ssd_gran);
1001         kprintf("processor eflags       = ");
1002         if (frame->tf_rflags & PSL_T)
1003                 kprintf("trace trap, ");
1004         if (frame->tf_rflags & PSL_I)
1005                 kprintf("interrupt enabled, ");
1006         if (frame->tf_rflags & PSL_NT)
1007                 kprintf("nested task, ");
1008         if (frame->tf_rflags & PSL_RF)
1009                 kprintf("resume, ");
1010         kprintf("IOPL = %ld\n", (frame->tf_rflags & PSL_IOPL) >> 12);
1011         kprintf("current process                = ");
1012         if (curproc) {
1013                 kprintf("%lu\n",
1014                     (u_long)curproc->p_pid);
1015         } else {
1016                 kprintf("Idle\n");
1017         }
1018         kprintf("current thread          = pri %d ", curthread->td_pri);
1019         if (curthread->td_critcount)
1020                 kprintf("(CRIT)");
1021         kprintf("\n");
1022
1023 #ifdef DDB
1024         if ((debugger_on_panic || db_active) && kdb_trap(type, code, frame))
1025                 return;
1026 #endif
1027         kprintf("trap number            = %d\n", type);
1028         if (type <= MAX_TRAP_MSG)
1029                 panic("%s", trap_msg[type]);
1030         else
1031                 panic("unknown/reserved trap");
1032 }
1033
1034 /*
1035  * Double fault handler. Called when a fault occurs while writing
1036  * a frame for a trap/exception onto the stack. This usually occurs
1037  * when the stack overflows (such is the case with infinite recursion,
1038  * for example).
1039  */
1040 static __inline
1041 int
1042 in_kstack_guard(register_t rptr)
1043 {
1044         thread_t td = curthread;
1045
1046         if ((char *)rptr >= td->td_kstack &&
1047             (char *)rptr < td->td_kstack + PAGE_SIZE) {
1048                 return 1;
1049         }
1050         return 0;
1051 }
1052
1053 void
1054 dblfault_handler(struct trapframe *frame)
1055 {
1056         thread_t td = curthread;
1057
1058         if (in_kstack_guard(frame->tf_rsp) || in_kstack_guard(frame->tf_rbp)) {
1059                 kprintf("DOUBLE FAULT - KERNEL STACK GUARD HIT!\n");
1060                 if (in_kstack_guard(frame->tf_rsp))
1061                         frame->tf_rsp = (register_t)(td->td_kstack + PAGE_SIZE);
1062                 if (in_kstack_guard(frame->tf_rbp))
1063                         frame->tf_rbp = (register_t)(td->td_kstack + PAGE_SIZE);
1064         } else {
1065                 kprintf("DOUBLE FAULT\n");
1066         }
1067         kprintf("\nFatal double fault\n");
1068         kprintf("rip = 0x%lx\n", frame->tf_rip);
1069         kprintf("rsp = 0x%lx\n", frame->tf_rsp);
1070         kprintf("rbp = 0x%lx\n", frame->tf_rbp);
1071         /* three separate prints in case of a trap on an unmapped page */
1072         kprintf("cpuid = %d; ", mycpu->gd_cpuid);
1073         kprintf("lapic->id = %08x\n", lapic->id);
1074         panic("double fault");
1075 }
1076
1077 /*
1078  * syscall2 -   MP aware system call request C handler
1079  *
1080  * A system call is essentially treated as a trap except that the
1081  * MP lock is not held on entry or return.  We are responsible for
1082  * obtaining the MP lock if necessary and for handling ASTs
1083  * (e.g. a task switch) prior to return.
1084  *
1085  * MPSAFE
1086  */
1087 void
1088 syscall2(struct trapframe *frame)
1089 {
1090         struct thread *td = curthread;
1091         struct proc *p = td->td_proc;
1092         struct lwp *lp = td->td_lwp;
1093         caddr_t params;
1094         struct sysent *callp;
1095         register_t orig_tf_rflags;
1096         int sticks;
1097         int error;
1098         int narg;
1099 #ifdef INVARIANTS
1100         int crit_count = td->td_critcount;
1101 #endif
1102         int have_mplock = 0;
1103         register_t *argp;
1104         u_int code;
1105         int reg, regcnt;
1106         union sysunion args;
1107         register_t *argsdst;
1108
1109         mycpu->gd_cnt.v_syscall++;
1110
1111 #ifdef DIAGNOSTIC
1112         if (ISPL(frame->tf_cs) != SEL_UPL) {
1113                 get_mplock();
1114                 panic("syscall");
1115                 /* NOT REACHED */
1116         }
1117 #endif
1118
1119         KTR_LOG(kernentry_syscall, p->p_pid, lp->lwp_tid,
1120                 frame->tf_rax);
1121
1122         userenter(td, p);       /* lazy raise our priority */
1123
1124         reg = 0;
1125         regcnt = 6;
1126         /*
1127          * Misc
1128          */
1129         sticks = (int)td->td_sticks;
1130         orig_tf_rflags = frame->tf_rflags;
1131
1132         /*
1133          * Virtual kernel intercept - if a VM context managed by a virtual
1134          * kernel issues a system call the virtual kernel handles it, not us.
1135          * Restore the virtual kernel context and return from its system
1136          * call.  The current frame is copied out to the virtual kernel.
1137          */
1138         if (lp->lwp_vkernel && lp->lwp_vkernel->ve) {
1139                 vkernel_trap(lp, frame);
1140                 error = EJUSTRETURN;
1141                 goto out;
1142         }
1143
1144         /*
1145          * Get the system call parameters and account for time
1146          */
1147         KASSERT(lp->lwp_md.md_regs == frame,
1148                 ("Frame mismatch %p %p", lp->lwp_md.md_regs, frame));
1149         params = (caddr_t)frame->tf_rsp + sizeof(register_t);
1150         code = frame->tf_rax;
1151
1152         if (p->p_sysent->sv_prepsyscall) {
1153                 (*p->p_sysent->sv_prepsyscall)(
1154                         frame, (int *)(&args.nosys.sysmsg + 1),
1155                         &code, &params);
1156         } else {
1157                 if (code == SYS_syscall || code == SYS___syscall) {
1158                         code = frame->tf_rdi;
1159                         reg++;
1160                         regcnt--;
1161                 }
1162         }
1163
1164         if (p->p_sysent->sv_mask)
1165                 code &= p->p_sysent->sv_mask;
1166
1167         if (code >= p->p_sysent->sv_size)
1168                 callp = &p->p_sysent->sv_table[0];
1169         else
1170                 callp = &p->p_sysent->sv_table[code];
1171
1172         narg = callp->sy_narg & SYF_ARGMASK;
1173
1174         /*
1175          * On x86_64 we get up to six arguments in registers. The rest are
1176          * on the stack. The first six members of 'struct trapframe' happen
1177          * to be the registers used to pass arguments, in exactly the right
1178          * order.
1179          */
1180         argp = &frame->tf_rdi;
1181         argp += reg;
1182         argsdst = (register_t *)(&args.nosys.sysmsg + 1);
1183         /*
1184          * JG can we overflow the space pointed to by 'argsdst'
1185          * either with 'bcopy' or with 'copyin'?
1186          */
1187         bcopy(argp, argsdst, sizeof(register_t) * regcnt);
1188         /*
1189          * copyin is MP aware, but the tracing code is not
1190          */
1191         if (narg > regcnt) {
1192                 KASSERT(params != NULL, ("copyin args with no params!"));
1193                 error = copyin(params, &argsdst[regcnt],
1194                         (narg - regcnt) * sizeof(register_t));
1195                 if (error) {
1196 #ifdef KTRACE
1197                         if (KTRPOINT(td, KTR_SYSCALL)) {
1198                                 MAKEMPSAFE(have_mplock);
1199
1200                                 ktrsyscall(lp, code, narg,
1201                                         (void *)(&args.nosys.sysmsg + 1));
1202                         }
1203 #endif
1204                         goto bad;
1205                 }
1206         }
1207
1208 #ifdef KTRACE
1209         if (KTRPOINT(td, KTR_SYSCALL)) {
1210                 MAKEMPSAFE(have_mplock);
1211                 ktrsyscall(lp, code, narg, (void *)(&args.nosys.sysmsg + 1));
1212         }
1213 #endif
1214
1215         /*
1216          * Default return value is 0 (will be copied to %rax).  Double-value
1217          * returns use %rax and %rdx.  %rdx is left unchanged for system
1218          * calls which return only one result.
1219          */
1220         args.sysmsg_fds[0] = 0;
1221         args.sysmsg_fds[1] = frame->tf_rdx;
1222
1223         /*
1224          * The syscall might manipulate the trap frame. If it does it
1225          * will probably return EJUSTRETURN.
1226          */
1227         args.sysmsg_frame = frame;
1228
1229         STOPEVENT(p, S_SCE, narg);      /* MP aware */
1230
1231         /*
1232          * NOTE: All system calls run MPSAFE now.  The system call itself
1233          *       is responsible for getting the MP lock.
1234          */
1235 #ifdef SYSCALL_DEBUG
1236         uint64_t tscval = rdtsc();
1237 #endif
1238         error = (*callp->sy_call)(&args);
1239 #ifdef SYSCALL_DEBUG
1240         tscval = rdtsc() - tscval;
1241         tscval = tscval * 1000000 / tsc_frequency;
1242         if (SysCallsWorstCase[code] < tscval)
1243                 SysCallsWorstCase[code] = tscval;
1244 #endif
1245
1246 out:
1247         /*
1248          * MP SAFE (we may or may not have the MP lock at this point)
1249          */
1250         //kprintf("SYSMSG %d ", error);
1251         switch (error) {
1252         case 0:
1253                 /*
1254                  * Reinitialize proc pointer `p' as it may be different
1255                  * if this is a child returning from fork syscall.
1256                  */
1257                 p = curproc;
1258                 lp = curthread->td_lwp;
1259                 frame->tf_rax = args.sysmsg_fds[0];
1260                 frame->tf_rdx = args.sysmsg_fds[1];
1261                 frame->tf_rflags &= ~PSL_C;
1262                 break;
1263         case ERESTART:
1264                 /*
1265                  * Reconstruct pc, we know that 'syscall' is 2 bytes.
1266                  * We have to do a full context restore so that %r10
1267                  * (which was holding the value of %rcx) is restored for
1268                  * the next iteration.
1269                  */
1270                 if (frame->tf_err != 0 && frame->tf_err != 2)
1271                         kprintf("lp %s:%d frame->tf_err is weird %ld\n",
1272                                 td->td_comm, lp->lwp_proc->p_pid, frame->tf_err);
1273                 frame->tf_rip -= frame->tf_err;
1274                 frame->tf_r10 = frame->tf_rcx;
1275                 break;
1276         case EJUSTRETURN:
1277                 break;
1278         case EASYNC:
1279                 panic("Unexpected EASYNC return value (for now)");
1280         default:
1281 bad:
1282                 if (p->p_sysent->sv_errsize) {
1283                         if (error >= p->p_sysent->sv_errsize)
1284                                 error = -1;     /* XXX */
1285                         else
1286                                 error = p->p_sysent->sv_errtbl[error];
1287                 }
1288                 frame->tf_rax = error;
1289                 frame->tf_rflags |= PSL_C;
1290                 break;
1291         }
1292
1293         /*
1294          * Traced syscall.  trapsignal() is not MP aware.
1295          */
1296         if (orig_tf_rflags & PSL_T) {
1297                 MAKEMPSAFE(have_mplock);
1298                 frame->tf_rflags &= ~PSL_T;
1299                 trapsignal(lp, SIGTRAP, TRAP_TRACE);
1300         }
1301
1302         /*
1303          * Handle reschedule and other end-of-syscall issues
1304          */
1305         userret(lp, frame, sticks);
1306
1307 #ifdef KTRACE
1308         if (KTRPOINT(td, KTR_SYSRET)) {
1309                 MAKEMPSAFE(have_mplock);
1310                 ktrsysret(lp, code, error, args.sysmsg_result);
1311         }
1312 #endif
1313
1314         /*
1315          * This works because errno is findable through the
1316          * register set.  If we ever support an emulation where this
1317          * is not the case, this code will need to be revisited.
1318          */
1319         STOPEVENT(p, S_SCX, code);
1320
1321         userexit(lp);
1322         /*
1323          * Release the MP lock if we had to get it
1324          */
1325         if (have_mplock)
1326                 rel_mplock();
1327         KTR_LOG(kernentry_syscall_ret, p->p_pid, lp->lwp_tid, error);
1328 #ifdef INVARIANTS
1329         KASSERT(crit_count == td->td_critcount,
1330                 ("syscall: critical section count mismatch! %d/%d",
1331                 crit_count, td->td_pri));
1332         KASSERT(&td->td_toks_base == td->td_toks_stop,
1333                 ("syscall: extra tokens held after trap! %ld",
1334                 td->td_toks_stop - &td->td_toks_base));
1335 #endif
1336 }
1337
1338 /*
1339  * NOTE: mplock not held at any point
1340  */
1341 void
1342 fork_return(struct lwp *lp, struct trapframe *frame)
1343 {
1344         frame->tf_rax = 0;              /* Child returns zero */
1345         frame->tf_rflags &= ~PSL_C;     /* success */
1346         frame->tf_rdx = 1;
1347
1348         generic_lwp_return(lp, frame);
1349         KTR_LOG(kernentry_fork_ret, lp->lwp_proc->p_pid, lp->lwp_tid);
1350 }
1351
1352 /*
1353  * Simplified back end of syscall(), used when returning from fork()
1354  * directly into user mode.
1355  *
1356  * This code will return back into the fork trampoline code which then
1357  * runs doreti.
1358  *
1359  * NOTE: The mplock is not held at any point.
1360  */
1361 void
1362 generic_lwp_return(struct lwp *lp, struct trapframe *frame)
1363 {
1364         struct proc *p = lp->lwp_proc;
1365
1366         /*
1367          * Newly forked processes are given a kernel priority.  We have to
1368          * adjust the priority to a normal user priority and fake entry
1369          * into the kernel (call userenter()) to install a passive release
1370          * function just in case userret() decides to stop the process.  This
1371          * can occur when ^Z races a fork.  If we do not install the passive
1372          * release function the current process designation will not be
1373          * released when the thread goes to sleep.
1374          */
1375         lwkt_setpri_self(TDPRI_USER_NORM);
1376         userenter(lp->lwp_thread, p);
1377         userret(lp, frame, 0);
1378 #ifdef KTRACE
1379         if (KTRPOINT(lp->lwp_thread, KTR_SYSRET))
1380                 ktrsysret(lp, SYS_fork, 0, 0);
1381 #endif
1382         lp->lwp_flags |= LWP_PASSIVE_ACQ;
1383         userexit(lp);
1384         lp->lwp_flags &= ~LWP_PASSIVE_ACQ;
1385 }
1386
1387 /*
1388  * If PGEX_FPFAULT is set then set FP_VIRTFP in the PCB to force a T_DNA
1389  * fault (which is then passed back to the virtual kernel) if an attempt is
1390  * made to use the FP unit.
1391  *
1392  * XXX this is a fairly big hack.
1393  */
1394 void
1395 set_vkernel_fp(struct trapframe *frame)
1396 {
1397         struct thread *td = curthread;
1398
1399         if (frame->tf_xflags & PGEX_FPFAULT) {
1400                 td->td_pcb->pcb_flags |= FP_VIRTFP;
1401                 if (mdcpu->gd_npxthread == td)
1402                         npxexit();
1403         } else {
1404                 td->td_pcb->pcb_flags &= ~FP_VIRTFP;
1405         }
1406 }
1407
1408 /*
1409  * Called from vkernel_trap() to fixup the vkernel's syscall
1410  * frame for vmspace_ctl() return.
1411  */
1412 void
1413 cpu_vkernel_trap(struct trapframe *frame, int error)
1414 {
1415         frame->tf_rax = error;
1416         if (error)
1417                 frame->tf_rflags |= PSL_C;
1418         else
1419                 frame->tf_rflags &= ~PSL_C;
1420 }