sys/sparc64/sparc64/trap.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-3-Clause
   3  *
   4  * Copyright (c) 2001, Jake Burkholder
   5  * Copyright (C) 1994, David Greenman
   6  * Copyright (c) 1990, 1993
   7  *      The Regents of the University of California.  All rights reserved.
   8  *
   9  * This code is derived from software contributed to Berkeley by
  10  * the University of Utah, and William Jolitz.
  11  *
  12  * Redistribution and use in source and binary forms, with or without
  13  * modification, are permitted provided that the following conditions
  14  * are met:
  15  * 1. Redistributions of source code must retain the above copyright
  16  *    notice, this list of conditions and the following disclaimer.
  17  * 2. Redistributions in binary form must reproduce the above copyright
  18  *    notice, this list of conditions and the following disclaimer in the
  19  *    documentation and/or other materials provided with the distribution.
  20  * 3. Neither the name of the University nor the names of its contributors
  21  *    may be used to endorse or promote products derived from this software
  22  *    without specific prior written permission.
  23  *
  24  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  34  * SUCH DAMAGE.
  35  *
  36  *      from: @(#)trap.c        7.4 (Berkeley) 5/13/91
  37  *      from: FreeBSD: src/sys/i386/i386/trap.c,v 1.197 2001/07/19
  38  */
  39
  40 #include <sys/cdefs.h>
  41 __FBSDID("$FreeBSD$");
  42
  43 #include "opt_ddb.h"
  44 #include "opt_ktr.h"
  45
  46 #include <sys/param.h>
  47 #include <sys/kdb.h>
  48 #include <sys/kernel.h>
  49 #include <sys/bus.h>
  50 #include <sys/interrupt.h>
  51 #include <sys/ktr.h>
  52 #include <sys/lock.h>
  53 #include <sys/mutex.h>
  54 #include <sys/systm.h>
  55 #include <sys/pcpu.h>
  56 #include <sys/pioctl.h>
  57 #include <sys/ptrace.h>
  58 #include <sys/proc.h>
  59 #include <sys/smp.h>
  60 #include <sys/signalvar.h>
  61 #include <sys/syscall.h>
  62 #include <sys/sysctl.h>
  63 #include <sys/sysent.h>
  64 #include <sys/vmmeter.h>
  65 #include <security/audit/audit.h>
  66
  67 #include <dev/ofw/openfirm.h>
  68
  69 #include <vm/vm.h>
  70 #include <vm/pmap.h>
  71 #include <vm/vm_extern.h>
  72 #include <vm/vm_param.h>
  73 #include <vm/vm_kern.h>
  74 #include <vm/vm_map.h>
  75 #include <vm/vm_page.h>
  76
  77 #include <machine/cpu.h>
  78 #include <machine/frame.h>
  79 #include <machine/intr_machdep.h>
  80 #include <machine/ofw_machdep.h>
  81 #include <machine/pcb.h>
  82 #include <machine/smp.h>
  83 #include <machine/trap.h>
  84 #include <machine/tstate.h>
  85 #include <machine/tte.h>
  86 #include <machine/tlb.h>
  87 #include <machine/tsb.h>
  88 #include <machine/watch.h>
  89
  90 void trap(struct trapframe *tf);
  91 void syscall(struct trapframe *tf);
  92
  93 static int trap_cecc(void);
  94 static int trap_pfault(struct thread *td, struct trapframe *tf);
  95
  96 extern char copy_fault[];
  97 extern char copy_nofault_begin[];
  98 extern char copy_nofault_end[];
  99
 100 extern char fs_fault[];
 101 extern char fs_nofault_begin[];
 102 extern char fs_nofault_end[];
 103
 104 extern char fas_fault[];
 105 extern char fas_nofault_begin[];
 106 extern char fas_nofault_end[];
 107
 108 const char *const trap_msg[] = {
 109         "reserved",
 110         "instruction access exception",
 111         "instruction access error",
 112         "instruction access protection",
 113         "illtrap instruction",
 114         "illegal instruction",
 115         "privileged opcode",
 116         "floating point disabled",
 117         "floating point exception ieee 754",
 118         "floating point exception other",
 119         "tag overflow",
 120         "division by zero",
 121         "data access exception",
 122         "data access error",
 123         "data access protection",
 124         "memory address not aligned",
 125         "privileged action",
 126         "async data error",
 127         "trap instruction 16",
 128         "trap instruction 17",
 129         "trap instruction 18",
 130         "trap instruction 19",
 131         "trap instruction 20",
 132         "trap instruction 21",
 133         "trap instruction 22",
 134         "trap instruction 23",
 135         "trap instruction 24",
 136         "trap instruction 25",
 137         "trap instruction 26",
 138         "trap instruction 27",
 139         "trap instruction 28",
 140         "trap instruction 29",
 141         "trap instruction 30",
 142         "trap instruction 31",
 143         "fast instruction access mmu miss",
 144         "fast data access mmu miss",
 145         "interrupt",
 146         "physical address watchpoint",
 147         "virtual address watchpoint",
 148         "corrected ecc error",
 149         "spill",
 150         "fill",
 151         "fill",
 152         "breakpoint",
 153         "clean window",
 154         "range check",
 155         "fix alignment",
 156         "integer overflow",
 157         "syscall",
 158         "restore physical watchpoint",
 159         "restore virtual watchpoint",
 160         "kernel stack fault",
 161 };
 162
 163 static const int trap_sig[] = {
 164         SIGILL,                 /* reserved */
 165         SIGILL,                 /* instruction access exception */
 166         SIGILL,                 /* instruction access error */
 167         SIGILL,                 /* instruction access protection */
 168         SIGILL,                 /* illtrap instruction */
 169         SIGILL,                 /* illegal instruction */
 170         SIGBUS,                 /* privileged opcode */
 171         SIGFPE,                 /* floating point disabled */
 172         SIGFPE,                 /* floating point exception ieee 754 */
 173         SIGFPE,                 /* floating point exception other */
 174         SIGEMT,                 /* tag overflow */
 175         SIGFPE,                 /* division by zero */
 176         SIGILL,                 /* data access exception */
 177         SIGILL,                 /* data access error */
 178         SIGBUS,                 /* data access protection */
 179         SIGBUS,                 /* memory address not aligned */
 180         SIGBUS,                 /* privileged action */
 181         SIGBUS,                 /* async data error */
 182         SIGILL,                 /* trap instruction 16 */
 183         SIGILL,                 /* trap instruction 17 */
 184         SIGILL,                 /* trap instruction 18 */
 185         SIGILL,                 /* trap instruction 19 */
 186         SIGILL,                 /* trap instruction 20 */
 187         SIGILL,                 /* trap instruction 21 */
 188         SIGILL,                 /* trap instruction 22 */
 189         SIGILL,                 /* trap instruction 23 */
 190         SIGILL,                 /* trap instruction 24 */
 191         SIGILL,                 /* trap instruction 25 */
 192         SIGILL,                 /* trap instruction 26 */
 193         SIGILL,                 /* trap instruction 27 */
 194         SIGILL,                 /* trap instruction 28 */
 195         SIGILL,                 /* trap instruction 29 */
 196         SIGILL,                 /* trap instruction 30 */
 197         SIGILL,                 /* trap instruction 31 */
 198         SIGSEGV,                /* fast instruction access mmu miss */
 199         SIGSEGV,                /* fast data access mmu miss */
 200         -1,                     /* interrupt */
 201         -1,                     /* physical address watchpoint */
 202         -1,                     /* virtual address watchpoint */
 203         -1,                     /* corrected ecc error */
 204         SIGILL,                 /* spill */
 205         SIGILL,                 /* fill */
 206         SIGILL,                 /* fill */
 207         SIGTRAP,                /* breakpoint */
 208         SIGILL,                 /* clean window */
 209         SIGILL,                 /* range check */
 210         SIGILL,                 /* fix alignment */
 211         SIGILL,                 /* integer overflow */
 212         SIGSYS,                 /* syscall */
 213         -1,                     /* restore physical watchpoint */
 214         -1,                     /* restore virtual watchpoint */
 215         -1,                     /* kernel stack fault */
 216 };
 217
 218 CTASSERT(nitems(trap_msg) == T_MAX);
 219 CTASSERT(nitems(trap_sig) == T_MAX);
 220
 221 CTASSERT(sizeof(struct trapframe) == 256);
 222
 223 int debugger_on_signal = 0;
 224 SYSCTL_INT(_debug, OID_AUTO, debugger_on_signal, CTLFLAG_RW,
 225     &debugger_on_signal, 0, "");
 226
 227 u_int corrected_ecc = 0;
 228 SYSCTL_UINT(_machdep, OID_AUTO, corrected_ecc, CTLFLAG_RD, &corrected_ecc, 0,
 229     "corrected ECC errors");
 230
 231 /*
 232  * SUNW,set-trap-table allows to take over %tba from the PROM, which
 233  * will turn off interrupts and handle outstanding ones while doing so,
 234  * in a safe way.
 235  */
 236 void
 237 sun4u_set_traptable(void *tba_addr)
 238 {
 239         static struct {
 240                 cell_t name;
 241                 cell_t nargs;
 242                 cell_t nreturns;
 243                 cell_t tba_addr;
 244         } args = {
 245                 (cell_t)"SUNW,set-trap-table",
 246                 1,
 247                 0,
 248         };
 249
 250         args.tba_addr = (cell_t)tba_addr;
 251         ofw_entry(&args);
 252 }
 253
 254 void
 255 trap(struct trapframe *tf)
 256 {
 257         struct thread *td;
 258         struct proc *p;
 259         int error;
 260         int sig;
 261         register_t addr;
 262         ksiginfo_t ksi;
 263
 264         td = curthread;
 265
 266         CTR4(KTR_TRAP, "trap: %p type=%s (%s) pil=%#lx", td,
 267             trap_msg[tf->tf_type & ~T_KERNEL],
 268             (TRAPF_USERMODE(tf) ? "user" : "kernel"), rdpr(pil));
 269
 270         VM_CNT_INC(v_trap);
 271
 272         if ((tf->tf_tstate & TSTATE_PRIV) == 0) {
 273                 KASSERT(td != NULL, ("trap: curthread NULL"));
 274                 KASSERT(td->td_proc != NULL, ("trap: curproc NULL"));
 275
 276                 p = td->td_proc;
 277                 td->td_pticks = 0;
 278                 td->td_frame = tf;
 279                 addr = tf->tf_tpc;
 280                 if (td->td_cowgen != p->p_cowgen)
 281                         thread_cow_update(td);
 282
 283                 switch (tf->tf_type) {
 284                 case T_DATA_MISS:
 285                 case T_DATA_PROTECTION:
 286                         addr = tf->tf_sfar;
 287                         /* FALLTHROUGH */
 288                 case T_INSTRUCTION_MISS:
 289                         sig = trap_pfault(td, tf);
 290                         break;
 291                 case T_FILL:
 292                         sig = rwindow_load(td, tf, 2);
 293                         break;
 294                 case T_FILL_RET:
 295                         sig = rwindow_load(td, tf, 1);
 296                         break;
 297                 case T_SPILL:
 298                         sig = rwindow_save(td);
 299                         break;
 300                 case T_CORRECTED_ECC_ERROR:
 301                         sig = trap_cecc();
 302                         break;
 303                 default:
 304                         if (tf->tf_type > T_MAX)
 305                                 panic("trap: bad trap type %#lx (user)",
 306                                     tf->tf_type);
 307                         else if (trap_sig[tf->tf_type] == -1)
 308                                 panic("trap: %s (user)",
 309                                     trap_msg[tf->tf_type]);
 310                         sig = trap_sig[tf->tf_type];
 311                         break;
 312                 }
 313
 314                 if (sig != 0) {
 315                         /* Translate fault for emulators. */
 316                         if (p->p_sysent->sv_transtrap != NULL) {
 317                                 sig = p->p_sysent->sv_transtrap(sig,
 318                                     tf->tf_type);
 319                         }
 320                         if (debugger_on_signal &&
 321                             (sig == 4 || sig == 10 || sig == 11))
 322                                 kdb_enter(KDB_WHY_TRAPSIG, "trapsig");
 323                         ksiginfo_init_trap(&ksi);
 324                         ksi.ksi_signo = sig;
 325                         ksi.ksi_code = (int)tf->tf_type; /* XXX not POSIX */
 326                         ksi.ksi_addr = (void *)addr;
 327                         ksi.ksi_trapno = (int)tf->tf_type;
 328                         trapsignal(td, &ksi);
 329                 }
 330
 331                 userret(td, tf);
 332         } else {
 333                 KASSERT((tf->tf_type & T_KERNEL) != 0,
 334                     ("trap: kernel trap isn't"));
 335
 336                 if (kdb_active) {
 337                         kdb_reenter();
 338                         return;
 339                 }
 340
 341                 switch (tf->tf_type & ~T_KERNEL) {
 342                 case T_BREAKPOINT:
 343                 case T_KSTACK_FAULT:
 344                         error = (kdb_trap(tf->tf_type, 0, tf) == 0);
 345                         TF_DONE(tf);
 346                         break;
 347 #ifdef notyet
 348                 case T_PA_WATCHPOINT:
 349                 case T_VA_WATCHPOINT:
 350                         error = db_watch_trap(tf);
 351                         break;
 352 #endif
 353                 case T_DATA_MISS:
 354                 case T_DATA_PROTECTION:
 355                 case T_INSTRUCTION_MISS:
 356                         error = trap_pfault(td, tf);
 357                         break;
 358                 case T_DATA_EXCEPTION:
 359                 case T_MEM_ADDRESS_NOT_ALIGNED:
 360                         if ((tf->tf_sfsr & MMU_SFSR_FV) != 0 &&
 361                             MMU_SFSR_GET_ASI(tf->tf_sfsr) == ASI_AIUP) {
 362                                 if (tf->tf_tpc >= (u_long)copy_nofault_begin &&
 363                                     tf->tf_tpc <= (u_long)copy_nofault_end) {
 364                                         tf->tf_tpc = (u_long)copy_fault;
 365                                         tf->tf_tnpc = tf->tf_tpc + 4;
 366                                         error = 0;
 367                                         break;
 368                                 }
 369                                 if (tf->tf_tpc >= (u_long)fs_nofault_begin &&
 370                                     tf->tf_tpc <= (u_long)fs_nofault_end) {
 371                                         tf->tf_tpc = (u_long)fs_fault;
 372                                         tf->tf_tnpc = tf->tf_tpc + 4;
 373                                         error = 0;
 374                                         break;
 375                                 }
 376                         }
 377                         error = 1;
 378                         break;
 379                 case T_DATA_ERROR:
 380                         /*
 381                          * Handle PCI poke/peek as per UltraSPARC IIi
 382                          * User's Manual 16.2.1, modulo checking the
 383                          * TPC as USIII CPUs generate a precise trap
 384                          * instead of a special deferred one.
 385                          */
 386                         if (tf->tf_tpc > (u_long)fas_nofault_begin &&
 387                             tf->tf_tpc < (u_long)fas_nofault_end) {
 388                                 cache_flush();
 389                                 cache_enable(PCPU_GET(impl));
 390                                 tf->tf_tpc = (u_long)fas_fault;
 391                                 tf->tf_tnpc = tf->tf_tpc + 4;
 392                                 error = 0;
 393                                 break;
 394                         }
 395                         error = 1;
 396                         break;
 397                 case T_CORRECTED_ECC_ERROR:
 398                         error = trap_cecc();
 399                         break;
 400                 default:
 401                         error = 1;
 402                         break;
 403                 }
 404
 405                 if (error != 0) {
 406                         tf->tf_type &= ~T_KERNEL;
 407                         if (tf->tf_type > T_MAX)
 408                                 panic("trap: bad trap type %#lx (kernel)",
 409                                     tf->tf_type);
 410                         panic("trap: %s (kernel)", trap_msg[tf->tf_type]);
 411                 }
 412         }
 413         CTR1(KTR_TRAP, "trap: td=%p return", td);
 414 }
 415
 416 static int
 417 trap_cecc(void)
 418 {
 419         u_long eee;
 420
 421         /*
 422          * Turn off (non-)correctable error reporting while we're dealing
 423          * with the error.
 424          */
 425         eee = ldxa(0, ASI_ESTATE_ERROR_EN_REG);
 426         stxa_sync(0, ASI_ESTATE_ERROR_EN_REG, eee & ~(AA_ESTATE_NCEEN |
 427             AA_ESTATE_CEEN));
 428         /* Flush the caches in order ensure no corrupt data got installed. */
 429         cache_flush();
 430         /* Ensure the caches are still turned on (should be). */
 431         cache_enable(PCPU_GET(impl));
 432         /* Clear the error from the AFSR. */
 433         stxa_sync(0, ASI_AFSR, ldxa(0, ASI_AFSR));
 434         corrected_ecc++;
 435         printf("corrected ECC error\n");
 436         /* Turn (non-)correctable error reporting back on. */
 437         stxa_sync(0, ASI_ESTATE_ERROR_EN_REG, eee);
 438         return (0);
 439 }
 440
 441 static int
 442 trap_pfault(struct thread *td, struct trapframe *tf)
 443 {
 444         vm_map_t map;
 445         struct proc *p;
 446         vm_offset_t va;
 447         vm_prot_t prot;
 448         vm_map_entry_t entry;
 449         u_long ctx;
 450         int type;
 451         int rv;
 452
 453         if (td == NULL)
 454                 return (-1);
 455         KASSERT(td->td_pcb != NULL, ("trap_pfault: pcb NULL"));
 456         KASSERT(td->td_proc != NULL, ("trap_pfault: curproc NULL"));
 457         KASSERT(td->td_proc->p_vmspace != NULL, ("trap_pfault: vmspace NULL"));
 458
 459         p = td->td_proc;
 460
 461         rv = KERN_SUCCESS;
 462         ctx = TLB_TAR_CTX(tf->tf_tar);
 463         type = tf->tf_type & ~T_KERNEL;
 464         va = TLB_TAR_VA(tf->tf_tar);
 465
 466         CTR4(KTR_TRAP, "trap_pfault: td=%p pm_ctx=%#lx va=%#lx ctx=%#lx",
 467             td, p->p_vmspace->vm_pmap.pm_context[curcpu], va, ctx);
 468
 469         if (type == T_DATA_PROTECTION)
 470                 prot = VM_PROT_WRITE;
 471         else {
 472                 if (type == T_DATA_MISS)
 473                         prot = VM_PROT_READ;
 474                 else
 475                         prot = VM_PROT_READ | VM_PROT_EXECUTE;
 476         }
 477
 478         if (ctx != TLB_CTX_KERNEL) {
 479                 /* This is a fault on non-kernel virtual memory. */
 480                 map = &p->p_vmspace->vm_map;
 481         } else {
 482                 /*
 483                  * This is a fault on kernel virtual memory.  Attempts to
 484                  * access kernel memory from user mode cause privileged
 485                  * action traps, not page fault.
 486                  */
 487                 KASSERT(tf->tf_tstate & TSTATE_PRIV,
 488                     ("trap_pfault: fault on nucleus context from user mode"));
 489
 490                 if (tf->tf_tpc >= (u_long)copy_nofault_begin &&
 491                     tf->tf_tpc <= (u_long)copy_nofault_end) {
 492                         vm_map_lock_read(kernel_map);
 493                         if (vm_map_lookup_entry(kernel_map, va, &entry) &&
 494                             (entry->eflags & MAP_ENTRY_NOFAULT) != 0) {
 495                                 tf->tf_tpc = (u_long)copy_fault;
 496                                 tf->tf_tnpc = tf->tf_tpc + 4;
 497                                 vm_map_unlock_read(kernel_map);
 498                                 return (0);
 499                         }
 500                         vm_map_unlock_read(kernel_map);
 501                 }
 502                 map = kernel_map;
 503         }
 504
 505         /* Fault in the page. */
 506         rv = vm_fault(map, va, prot, VM_FAULT_NORMAL);
 507
 508         CTR3(KTR_TRAP, "trap_pfault: return td=%p va=%#lx rv=%d",
 509             td, va, rv);
 510         if (rv == KERN_SUCCESS)
 511                 return (0);
 512         if (ctx != TLB_CTX_KERNEL && (tf->tf_tstate & TSTATE_PRIV) != 0) {
 513                 if (tf->tf_tpc >= (u_long)fs_nofault_begin &&
 514                     tf->tf_tpc <= (u_long)fs_nofault_end) {
 515                         tf->tf_tpc = (u_long)fs_fault;
 516                         tf->tf_tnpc = tf->tf_tpc + 4;
 517                         return (0);
 518                 }
 519                 if (tf->tf_tpc >= (u_long)copy_nofault_begin &&
 520                     tf->tf_tpc <= (u_long)copy_nofault_end) {
 521                         tf->tf_tpc = (u_long)copy_fault;
 522                         tf->tf_tnpc = tf->tf_tpc + 4;
 523                         return (0);
 524                 }
 525         }
 526         return ((rv == KERN_PROTECTION_FAILURE) ? SIGBUS : SIGSEGV);
 527 }
 528
 529 /* Maximum number of arguments that can be passed via the out registers. */
 530 #define REG_MAXARGS     6
 531
 532 int
 533 cpu_fetch_syscall_args(struct thread *td)
 534 {
 535         struct trapframe *tf;
 536         struct proc *p;
 537         register_t *argp;
 538         struct syscall_args *sa;
 539         int reg;
 540         int regcnt;
 541         int error;
 542
 543         p = td->td_proc;
 544         tf = td->td_frame;
 545         sa = &td->td_sa;
 546         reg = 0;
 547         regcnt = REG_MAXARGS;
 548
 549         sa->code = tf->tf_global[1];
 550
 551         if (sa->code == SYS_syscall || sa->code == SYS___syscall) {
 552                 sa->code = tf->tf_out[reg++];
 553                 regcnt--;
 554         }
 555
 556         if (p->p_sysent->sv_mask)
 557                 sa->code &= p->p_sysent->sv_mask;
 558         if (sa->code >= p->p_sysent->sv_size)
 559                 sa->callp = &p->p_sysent->sv_table[0];
 560         else
 561                 sa->callp = &p->p_sysent->sv_table[sa->code];
 562
 563         sa->narg = sa->callp->sy_narg;
 564         KASSERT(sa->narg <= sizeof(sa->args) / sizeof(sa->args[0]),
 565             ("Too many syscall arguments!"));
 566         error = 0;
 567         argp = sa->args;
 568         bcopy(&tf->tf_out[reg], sa->args, sizeof(sa->args[0]) * regcnt);
 569         if (sa->narg > regcnt)
 570                 error = copyin((void *)(tf->tf_out[6] + SPOFF +
 571                     offsetof(struct frame, fr_pad[6])), &sa->args[regcnt],
 572                     (sa->narg - regcnt) * sizeof(sa->args[0]));
 573         if (error == 0) {
 574                 td->td_retval[0] = 0;
 575                 td->td_retval[1] = 0;
 576         }
 577
 578         return (error);
 579 }
 580
 581 #include "../../kern/subr_syscall.c"
 582
 583 /*
 584  * Syscall handler
 585  * The arguments to the syscall are passed in the out registers by the caller,
 586  * and are saved in the trap frame.  The syscall number is passed in %g1 (and
 587  * also saved in the trap frame).
 588  */
 589 void
 590 syscall(struct trapframe *tf)
 591 {
 592         struct thread *td;
 593         int error;
 594
 595         td = curthread;
 596         td->td_frame = tf;
 597
 598         KASSERT(td != NULL, ("trap: curthread NULL"));
 599         KASSERT(td->td_proc != NULL, ("trap: curproc NULL"));
 600
 601         /*
 602          * For syscalls, we don't want to retry the faulting instruction
 603          * (usually), instead we need to advance one instruction.
 604          */
 605         td->td_pcb->pcb_tpc = tf->tf_tpc;
 606         TF_DONE(tf);
 607
 608         error = syscallenter(td);
 609         syscallret(td, error);
 610 }