Home | History | Annotate | Line # | Download | only in arm32
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