fault.c revision 1.31 1 /* $NetBSD: fault.c,v 1.31 2003/07/09 20:14:15 thorpej Exp $ */
2
3 /*
4 * Copyright 2003 Wasabi Systems, Inc.
5 * All rights reserved.
6 *
7 * Written by Steve C. Woodford for Wasabi Systems, Inc.
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 for the NetBSD Project by
20 * Wasabi Systems, Inc.
21 * 4. The name of Wasabi Systems, Inc. may not be used to endorse
22 * or promote products derived from this software without specific prior
23 * written permission.
24 *
25 * THIS SOFTWARE IS PROVIDED BY WASABI SYSTEMS, INC. ``AS IS'' AND
26 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
27 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
28 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL WASABI SYSTEMS, INC
29 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
30 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
31 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
32 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
33 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
34 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
35 * POSSIBILITY OF SUCH DAMAGE.
36 */
37 /*
38 * Copyright (c) 1994-1997 Mark Brinicombe.
39 * Copyright (c) 1994 Brini.
40 * All rights reserved.
41 *
42 * This code is derived from software written for Brini by Mark Brinicombe
43 *
44 * Redistribution and use in source and binary forms, with or without
45 * modification, are permitted provided that the following conditions
46 * are met:
47 * 1. Redistributions of source code must retain the above copyright
48 * notice, this list of conditions and the following disclaimer.
49 * 2. Redistributions in binary form must reproduce the above copyright
50 * notice, this list of conditions and the following disclaimer in the
51 * documentation and/or other materials provided with the distribution.
52 * 3. All advertising materials mentioning features or use of this software
53 * must display the following acknowledgement:
54 * This product includes software developed by Brini.
55 * 4. The name of the company nor the name of the author may be used to
56 * endorse or promote products derived from this software without specific
57 * prior written permission.
58 *
59 * THIS SOFTWARE IS PROVIDED BY BRINI ``AS IS'' AND ANY EXPRESS OR IMPLIED
60 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
61 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
62 * IN NO EVENT SHALL BRINI OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
63 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
64 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
65 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
66 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
67 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
68 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
69 * SUCH DAMAGE.
70 *
71 * RiscBSD kernel project
72 *
73 * fault.c
74 *
75 * Fault handlers
76 *
77 * Created : 28/11/94
78 */
79
80 #include "opt_ddb.h"
81 #include "opt_kgdb.h"
82 #include "opt_pmap_debug.h"
83
84 #include <sys/types.h>
85 __KERNEL_RCSID(0, "$NetBSD: fault.c,v 1.31 2003/07/09 20:14:15 thorpej Exp $");
86
87 #include <sys/param.h>
88 #include <sys/systm.h>
89 #include <sys/proc.h>
90 #include <sys/user.h>
91 #include <sys/kernel.h>
92
93 #include <uvm/uvm_extern.h>
94
95 #include <arm/cpuconf.h>
96
97 #include <machine/frame.h>
98 #include <arm/arm32/katelib.h>
99 #include <machine/cpu.h>
100 #include <machine/intr.h>
101 #if defined(DDB) || defined(KGDB)
102 #include <machine/db_machdep.h>
103 #ifdef KGDB
104 #include <sys/kgdb.h>
105 #endif
106 #if !defined(DDB)
107 #define kdb_trap kgdb_trap
108 #endif
109 #endif
110
111 #include <arch/arm/arm/disassem.h>
112 #include <arm/arm32/machdep.h>
113
114 extern char fusubailout[];
115
116 #ifdef DEBUG
117 int last_fault_code; /* For the benefit of pmap_fault_fixup() */
118 #endif
119
120 static void report_abort __P((const char *, u_int, u_int, u_int));
121
122 /* Abort code */
123
124 /* Define text descriptions of the different aborts */
125
126 static const char *aborts[16] = {
127 "Write buffer fault",
128 "Alignment fault",
129 "Write buffer fault",
130 "Alignment fault",
131 "Bus error (LF section)",
132 "Translation fault (section)",
133 "Bus error (page)",
134 "Translation fault (page)",
135 "Bus error (section)",
136 "Domain error (section)",
137 "Bus error (page)",
138 "Domain error (page)",
139 "Bus error trans (L1)",
140 "Permission error (section)",
141 "Bus error trans (L2)",
142 "Permission error (page)"
143 };
144
145 static void
146 report_abort(prefix, fault_status, fault_address, fault_pc)
147 const char *prefix;
148 u_int fault_status;
149 u_int fault_address;
150 u_int fault_pc;
151 {
152 #ifndef DEBUG
153 if (prefix == NULL) {
154 #endif
155 if (prefix)
156 printf("%s ", prefix);
157 printf("Data abort: '%s' status=%03x address=%08x PC=%08x\n",
158 aborts[fault_status & FAULT_TYPE_MASK],
159 fault_status & 0xfff, fault_address, fault_pc);
160 #ifndef DEBUG
161 }
162 #endif
163 }
164
165 static __volatile int data_abort_expected;
166 static __volatile int data_abort_received;
167
168 int
169 badaddr_read(void *addr, size_t size, void *rptr)
170 {
171 u_long rcpt;
172 int rv;
173
174 /* Tell the Data Abort handler that we're expecting one. */
175 data_abort_received = 0;
176 data_abort_expected = 1;
177
178 cpu_drain_writebuf();
179
180 /* Read from the test address. */
181 switch (size) {
182 case sizeof(uint8_t):
183 __asm __volatile("ldrb %0, [%1]"
184 : "=r" (rcpt)
185 : "r" (addr));
186 break;
187
188 case sizeof(uint16_t):
189 __asm __volatile("ldrh %0, [%1]"
190 : "=r" (rcpt)
191 : "r" (addr));
192 break;
193
194 case sizeof(uint32_t):
195 __asm __volatile("ldr %0, [%1]"
196 : "=r" (rcpt)
197 : "r" (addr));
198 break;
199
200 default:
201 data_abort_expected = 0;
202 panic("badaddr: invalid size (%lu)", (u_long) size);
203 }
204
205 /* Disallow further Data Aborts. */
206 data_abort_expected = 0;
207
208 rv = data_abort_received;
209 data_abort_received = 0;
210
211 /* Copy the data back if no fault occurred. */
212 if (rptr != NULL && rv == 0) {
213 switch (size) {
214 case sizeof(uint8_t):
215 *(uint8_t *) rptr = rcpt;
216 break;
217
218 case sizeof(uint16_t):
219 *(uint16_t *) rptr = rcpt;
220 break;
221
222 case sizeof(uint32_t):
223 *(uint32_t *) rptr = rcpt;
224 break;
225 }
226 }
227
228 /* Return true if the address was invalid. */
229 return (rv);
230 }
231
232 /*
233 * void data_abort_handler(trapframe_t *frame)
234 *
235 * Abort handler called when read/write occurs at an address of
236 * a non existent or restricted (access permissions) memory page.
237 * We first need to identify the type of page fault.
238 */
239
240 #define TRAP_CODE ((fault_status & 0x0f) | (fault_address & 0xfffffff0))
241
242 /* Determine if we can recover from a fault */
243 #define IS_FATAL_FAULT(x) \
244 (((1 << (x)) & \
245 ((1 << FAULT_WRTBUF_0) | (1 << FAULT_WRTBUF_1) | \
246 (1 << FAULT_BUSERR_0) | (1 << FAULT_BUSERR_1) | \
247 (1 << FAULT_BUSERR_2) | (1 << FAULT_BUSERR_3) | \
248 (1 << FAULT_BUSTRNL1) | (1 << FAULT_BUSTRNL2) | \
249 (1 << FAULT_ALIGN_0) | (1 << FAULT_ALIGN_1))) != 0)
250
251 void
252 data_abort_handler(frame)
253 trapframe_t *frame;
254 {
255 struct lwp *l;
256 struct proc *p;
257 struct pcb *pcb;
258 u_int fault_address;
259 u_int fault_status;
260 u_int fault_pc;
261 u_int fault_instruction;
262 int fault_code, fatal_fault;
263 int user;
264 int error;
265 int rv;
266 void *onfault;
267 vaddr_t va;
268 struct vmspace *vm;
269 struct vm_map *map;
270 vm_prot_t ftype;
271 extern struct vm_map *kernel_map;
272
273 /*
274 * If we were expecting a Data Abort, signal that we got
275 * one, adjust the PC to skip the faulting insn, and
276 * return.
277 */
278 if (data_abort_expected) {
279 data_abort_received = 1;
280 frame->tf_pc += INSN_SIZE;
281 return;
282 }
283
284 /*
285 * Must get fault address and status from the CPU before
286 * re-enabling interrupts. (Interrupt handlers may take
287 * R/M emulation faults.)
288 */
289 fault_address = cpu_faultaddress();
290 fault_status = cpu_faultstatus();
291 fault_pc = frame->tf_pc;
292
293 /*
294 * Enable IRQ's (disabled by CPU on abort) if trapframe
295 * shows they were enabled.
296 */
297 if (!(frame->tf_spsr & I32_bit))
298 enable_interrupts(I32_bit);
299
300 #ifdef DEBUG
301 if ((GetCPSR() & PSR_MODE) != PSR_SVC32_MODE)
302 panic("data_abort_handler: not in SVC32 mode");
303 #endif
304
305 /* Update vmmeter statistics */
306 uvmexp.traps++;
307
308 /* Extract the fault code from the fault status */
309 fault_code = fault_status & FAULT_TYPE_MASK;
310 fatal_fault = IS_FATAL_FAULT(fault_code);
311
312 /* Get the current lwp structure or lwp0 if there is none */
313 l = curlwp == NULL ? &lwp0 : curlwp;
314 p = l->l_proc;
315
316 /*
317 * can't use curpcb, as it might be NULL; and we have p in
318 * a register anyway
319 */
320 pcb = &l->l_addr->u_pcb;
321
322 /* fusubailout is used by [fs]uswintr to avoid page faulting */
323 if (pcb->pcb_onfault &&
324 (fatal_fault || pcb->pcb_onfault == fusubailout)) {
325
326 frame->tf_r0 = EFAULT;
327 copyfault:
328 #ifdef DEBUG
329 printf("Using pcb_onfault=%p addr=%08x st=%08x l=%p\n",
330 pcb->pcb_onfault, fault_address, fault_status, l);
331 #endif
332 frame->tf_pc = (u_int)pcb->pcb_onfault;
333 if ((frame->tf_spsr & PSR_MODE) == PSR_USR32_MODE)
334 panic("Yikes pcb_onfault=%p during USR mode fault",
335 pcb->pcb_onfault);
336 return;
337 }
338
339 /* More debug stuff */
340
341 fault_instruction = ReadWord(fault_pc);
342
343 #ifdef PMAP_DEBUG
344 if (pmap_debug_level >= 0) {
345 report_abort(NULL, fault_status, fault_address, fault_pc);
346 printf("Instruction @V%08x = %08x\n",
347 fault_pc, fault_instruction);
348 }
349 #endif
350
351 /* Call the cpu specific abort fixup routine */
352 error = cpu_dataabt_fixup(frame);
353 if (error == ABORT_FIXUP_RETURN)
354 return;
355 if (error == ABORT_FIXUP_FAILED) {
356 printf("pc = 0x%08x, opcode 0x%08x, insn = ", fault_pc, *((u_int *)fault_pc));
357 disassemble(fault_pc);
358 printf("data abort handler: fixup failed for this instruction\n");
359 }
360
361 #ifdef PMAP_DEBUG
362 if (pmap_debug_level >= 0)
363 printf("fault in process %p\n", p);
364 #endif
365
366 #ifdef DEBUG
367 /* Is this needed ? (XXXSCW: yes. can happen during boot ...) */
368 if (!cold && pcb != curpcb) {
369 printf("data_abort: Alert ! pcb(%p) != curpcb(%p)\n",
370 pcb, curpcb);
371 printf("data_abort: Alert ! proc(%p), curlwp(%p)\n",
372 p, curlwp);
373 }
374 #endif /* DEBUG */
375
376 /* Were we in user mode when the abort occurred ? */
377 if ((frame->tf_spsr & PSR_MODE) == PSR_USR32_MODE) {
378 /*
379 * Note that the fault was from USR mode.
380 */
381 user = 1;
382 l->l_addr->u_pcb.pcb_tf = frame;
383 } else
384 user = 0;
385
386 /* check if this was a failed fixup */
387 if (error == ABORT_FIXUP_FAILED) {
388 if (user) {
389 trapsignal(l, SIGSEGV, TRAP_CODE);
390 userret(l);
391 return;
392 };
393 panic("Data abort fixup failed in kernel - we're dead");
394 };
395
396 /* Now act on the fault type */
397 if (fatal_fault) {
398 /*
399 * None of these faults should happen on a perfectly
400 * functioning system. They indicate either some gross
401 * problem with the kernel, or a hardware problem.
402 * In either case, stop.
403 */
404 report_abort(NULL, fault_status, fault_address, fault_pc);
405
406 we_re_toast:
407 /*
408 * Were are dead, try and provide some debug
409 * information before dying.
410 */
411 #if defined(DDB) || defined(KGDB)
412 printf("Unhandled trap (frame = %p)\n", frame);
413 report_abort(NULL, fault_status, fault_address, fault_pc);
414 kdb_trap(T_FAULT, frame);
415 return;
416 #else
417 panic("Unhandled trap (frame = %p)", frame);
418 #endif /* DDB || KGDB */
419 }
420
421 /*
422 * At this point, we're dealing with one of the following faults:
423 *
424 * FAULT_TRANS_P Page Translation Fault
425 * FAULT_PERM_P Page Permission Fault
426 * FAULT_TRANS_S Section Translation Fault
427 * FAULT_PERM_S Section Permission Fault
428 * FAULT_DOMAIN_P Page Domain Error Fault
429 * FAULT_DOMAIN_S Section Domain Error Fault
430 *
431 * Page/section translation/permission fault -- need to fault in
432 * the page.
433 *
434 * Page/section domain fault -- need to see if the L1 entry can
435 * be fixed up.
436 */
437 vm = p->p_vmspace;
438 va = trunc_page((vaddr_t)fault_address);
439
440 #ifdef PMAP_DEBUG
441 if (pmap_debug_level >= 0)
442 printf("page fault: addr=V%08lx ", va);
443 #endif
444
445 /*
446 * It is only a kernel address space fault iff:
447 * 1. user == 0 and
448 * 2. pcb_onfault not set or
449 * 3. pcb_onfault set but supervisor space fault
450 * The last can occur during an exec() copyin where the
451 * argument space is lazy-allocated.
452 */
453 if (!user &&
454 (va >= VM_MIN_KERNEL_ADDRESS || va < VM_MIN_ADDRESS)) {
455 /* Was the fault due to the FPE/IPKDB ? */
456 if ((frame->tf_spsr & PSR_MODE) == PSR_UND32_MODE) {
457 report_abort("UND32", fault_status,
458 fault_address, fault_pc);
459 trapsignal(l, SIGSEGV, TRAP_CODE);
460
461 /*
462 * Force exit via userret()
463 * This is necessary as the FPE is an extension
464 * to userland that actually runs in a
465 * priveledged mode but uses USR mode
466 * permissions for its accesses.
467 */
468 userret(l);
469 return;
470 }
471 map = kernel_map;
472 } else
473 map = &vm->vm_map;
474
475 #ifdef PMAP_DEBUG
476 if (pmap_debug_level >= 0)
477 printf("vmmap=%p ", map);
478 #endif
479
480 if (map == NULL)
481 printf("No map for fault address va = 0x%08lx", va);
482
483 /*
484 * We need to know whether the page should be mapped
485 * as R or R/W. The MMU does not give us the info as
486 * to whether the fault was caused by a read or a write.
487 * This means we need to disassemble the instruction
488 * responsible and determine if it was a read or write
489 * instruction.
490 */
491 /* STR instruction ? */
492 if ((fault_instruction & 0x0c100000) == 0x04000000)
493 ftype = VM_PROT_WRITE;
494 /* STM or CDT instruction ? */
495 else if ((fault_instruction & 0x0a100000) == 0x08000000)
496 ftype = VM_PROT_WRITE;
497 /* STRH, STRSH or STRSB instruction ? */
498 else if ((fault_instruction & 0x0e100090) == 0x00000090)
499 ftype = VM_PROT_WRITE;
500 /* SWP instruction ? */
501 else if ((fault_instruction & 0x0fb00ff0) == 0x01000090)
502 ftype = VM_PROT_READ | VM_PROT_WRITE;
503 else
504 ftype = VM_PROT_READ;
505
506 #ifdef PMAP_DEBUG
507 if (pmap_debug_level >= 0)
508 printf("fault protection = %d\n", ftype);
509 #endif
510
511 if (pmap_fault_fixup(map->pmap, va, ftype, user))
512 goto out;
513
514 if (current_intr_depth > 0) {
515 #if defined(DDB) || defined(KGDB)
516 printf("Non-emulated page fault with intr_depth > 0\n");
517 report_abort(NULL, fault_status, fault_address, fault_pc);
518 kdb_trap(T_FAULT, frame);
519 return;
520 #else
521 panic("Fault with intr_depth > 0");
522 #endif /* DDB */
523 }
524
525 onfault = pcb->pcb_onfault;
526 pcb->pcb_onfault = NULL;
527 rv = uvm_fault(map, va, 0, ftype);
528 pcb->pcb_onfault = onfault;
529 if (rv == 0) {
530 if (user != 0) /* Record any stack growth... */
531 uvm_grow(p, trunc_page(va));
532 goto out;
533 }
534 if (user == 0) {
535 if (pcb->pcb_onfault) {
536 frame->tf_r0 = rv;
537 goto copyfault;
538 }
539 printf("[u]vm_fault(%p, %lx, %x, 0) -> %x\n", map, va, ftype,
540 rv);
541 goto we_re_toast;
542 }
543
544 report_abort("", fault_status, fault_address, fault_pc);
545 if (rv == ENOMEM) {
546 printf("UVM: pid %d (%s), uid %d killed: "
547 "out of swap\n", p->p_pid, p->p_comm,
548 (p->p_cred && p->p_ucred) ? p->p_ucred->cr_uid : -1);
549 trapsignal(l, SIGKILL, TRAP_CODE);
550 } else
551 trapsignal(l, SIGSEGV, TRAP_CODE);
552
553 out:
554 /* Call userret() if it was a USR mode fault */
555 if (user)
556 userret(l);
557 }
558
559
560 /*
561 * void prefetch_abort_handler(trapframe_t *frame)
562 *
563 * Abort handler called when instruction execution occurs at
564 * a non existent or restricted (access permissions) memory page.
565 * If the address is invalid and we were in SVC mode then panic as
566 * the kernel should never prefetch abort.
567 * If the address is invalid and the page is mapped then the user process
568 * does no have read permission so send it a signal.
569 * Otherwise fault the page in and try again.
570 */
571
572 void
573 prefetch_abort_handler(frame)
574 trapframe_t *frame;
575 {
576 struct lwp *l;
577 struct proc *p;
578 struct vm_map *map;
579 vaddr_t fault_pc, va;
580 int error;
581
582 /*
583 * Enable IRQ's (disabled by the abort) This always comes
584 * from user mode so we know interrupts were not disabled.
585 * But we check anyway.
586 */
587 if (!(frame->tf_spsr & I32_bit))
588 enable_interrupts(I32_bit);
589
590 #ifdef DEBUG
591 if ((GetCPSR() & PSR_MODE) != PSR_SVC32_MODE)
592 panic("prefetch_abort_handler: not in SVC32 mode");
593 #endif
594
595 /* Update vmmeter statistics */
596 uvmexp.traps++;
597
598 /* Call the cpu specific abort fixup routine */
599 error = cpu_prefetchabt_fixup(frame);
600 if (error == ABORT_FIXUP_RETURN)
601 return;
602 if (error == ABORT_FIXUP_FAILED)
603 panic("prefetch abort fixup failed");
604
605 /* Get the current proc structure or proc0 if there is none */
606 if ((l = curlwp) == NULL) {
607 l = &lwp0;
608 #ifdef DEBUG
609 printf("Prefetch abort with curlwp == 0\n");
610 #endif
611 }
612 p = l->l_proc;
613
614 #ifdef PMAP_DEBUG
615 if (pmap_debug_level >= 0)
616 printf("prefetch fault in process %p %s\n", p, p->p_comm);
617 #endif
618
619 /* Get fault address */
620 fault_pc = frame->tf_pc;
621 va = trunc_page(fault_pc);
622
623 /* Was the prefectch abort from USR32 mode ? */
624 if ((frame->tf_spsr & PSR_MODE) == PSR_USR32_MODE) {
625 l->l_addr->u_pcb.pcb_tf = frame;
626 } else {
627 /*
628 * All the kernel code pages are loaded at boot time
629 * and do not get paged
630 */
631 panic("Prefetch abort in non-USR mode (frame=%p PC=0x%08lx)",
632 frame, fault_pc);
633 }
634
635 map = &p->p_vmspace->vm_map;
636
637 #ifdef PMAP_DEBUG
638 if (pmap_debug_level >= 0)
639 printf("prefetch_abort: PC = %08lx\n", fault_pc);
640 #endif
641 /* Ok validate the address, can only execute in USER space */
642 if (fault_pc < VM_MIN_ADDRESS || fault_pc >= VM_MAXUSER_ADDRESS) {
643 #ifdef DEBUG
644 printf("prefetch: pc (%08lx) not in user process space\n",
645 fault_pc);
646 #endif
647 trapsignal(l, SIGSEGV, fault_pc);
648 userret(l);
649 return;
650 }
651
652 /*
653 * See if the pmap can handle this fault on its own...
654 */
655 if (pmap_fault_fixup(map->pmap, va, VM_PROT_READ, 1))
656 goto out;
657
658 if (current_intr_depth > 0) {
659 #ifdef DDB
660 printf("Non-emulated prefetch abort with intr_depth > 0\n");
661 kdb_trap(T_FAULT, frame);
662 return;
663 #else
664 panic("Prefetch Abort with intr_depth > 0");
665 #endif
666 }
667
668 error = uvm_fault(map, va, 0, VM_PROT_READ);
669 if (error == 0)
670 goto out;
671
672 if (error == ENOMEM) {
673 printf("UVM: pid %d (%s), uid %d killed: "
674 "out of swap\n", p->p_pid, p->p_comm,
675 (p->p_cred && p->p_ucred) ? p->p_ucred->cr_uid : -1);
676 trapsignal(l, SIGKILL, fault_pc);
677 } else
678 trapsignal(l, SIGSEGV, fault_pc);
679 out:
680 userret(l);
681 }
682