1 /* 2 * fault.c: Page fault handlers for the Sparc. 3 * 4 * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu) 5 * Copyright (C) 1996 Eddie C. Dost (ecd@skynet.be) 6 * Copyright (C) 1997 Jakub Jelinek (jj@sunsite.mff.cuni.cz) 7 */ 8 9 #include <asm/head.h> 10 11 #include <linux/string.h> 12 #include <linux/types.h> 13 #include <linux/sched.h> 14 #include <linux/ptrace.h> 15 #include <linux/mman.h> 16 #include <linux/threads.h> 17 #include <linux/kernel.h> 18 #include <linux/signal.h> 19 #include <linux/mm.h> 20 #include <linux/smp.h> 21 #include <linux/interrupt.h> 22 #include <linux/module.h> 23 #include <linux/kdebug.h> 24 25 #include <asm/system.h> 26 #include <asm/page.h> 27 #include <asm/pgtable.h> 28 #include <asm/memreg.h> 29 #include <asm/openprom.h> 30 #include <asm/oplib.h> 31 #include <asm/smp.h> 32 #include <asm/traps.h> 33 #include <asm/uaccess.h> 34 35 extern int prom_node_root; 36 37 /* At boot time we determine these two values necessary for setting 38 * up the segment maps and page table entries (pte's). 39 */ 40 41 int num_segmaps, num_contexts; 42 int invalid_segment; 43 44 /* various Virtual Address Cache parameters we find at boot time... */ 45 46 int vac_size, vac_linesize, vac_do_hw_vac_flushes; 47 int vac_entries_per_context, vac_entries_per_segment; 48 int vac_entries_per_page; 49 50 /* Return how much physical memory we have. */ 51 unsigned long probe_memory(void) 52 { 53 unsigned long total = 0; 54 int i; 55 56 for (i = 0; sp_banks[i].num_bytes; i++) 57 total += sp_banks[i].num_bytes; 58 59 return total; 60 } 61 62 extern void sun4c_complete_all_stores(void); 63 64 /* Whee, a level 15 NMI interrupt memory error. Let's have fun... */ 65 asmlinkage void sparc_lvl15_nmi(struct pt_regs *regs, unsigned long serr, 66 unsigned long svaddr, unsigned long aerr, 67 unsigned long avaddr) 68 { 69 sun4c_complete_all_stores(); 70 printk("FAULT: NMI received\n"); 71 printk("SREGS: Synchronous Error %08lx\n", serr); 72 printk(" Synchronous Vaddr %08lx\n", svaddr); 73 printk(" Asynchronous Error %08lx\n", aerr); 74 printk(" Asynchronous Vaddr %08lx\n", avaddr); 75 if (sun4c_memerr_reg) 76 printk(" Memory Parity Error %08lx\n", *sun4c_memerr_reg); 77 printk("REGISTER DUMP:\n"); 78 show_regs(regs); 79 prom_halt(); 80 } 81 82 static void unhandled_fault(unsigned long, struct task_struct *, 83 struct pt_regs *) __attribute__ ((noreturn)); 84 85 static void unhandled_fault(unsigned long address, struct task_struct *tsk, 86 struct pt_regs *regs) 87 { 88 if((unsigned long) address < PAGE_SIZE) { 89 printk(KERN_ALERT 90 "Unable to handle kernel NULL pointer dereference\n"); 91 } else { 92 printk(KERN_ALERT "Unable to handle kernel paging request " 93 "at virtual address %08lx\n", address); 94 } 95 printk(KERN_ALERT "tsk->{mm,active_mm}->context = %08lx\n", 96 (tsk->mm ? tsk->mm->context : tsk->active_mm->context)); 97 printk(KERN_ALERT "tsk->{mm,active_mm}->pgd = %08lx\n", 98 (tsk->mm ? (unsigned long) tsk->mm->pgd : 99 (unsigned long) tsk->active_mm->pgd)); 100 die_if_kernel("Oops", regs); 101 } 102 103 asmlinkage int lookup_fault(unsigned long pc, unsigned long ret_pc, 104 unsigned long address) 105 { 106 struct pt_regs regs; 107 unsigned long g2; 108 unsigned int insn; 109 int i; 110 111 i = search_extables_range(ret_pc, &g2); 112 switch (i) { 113 case 3: 114 /* load & store will be handled by fixup */ 115 return 3; 116 117 case 1: 118 /* store will be handled by fixup, load will bump out */ 119 /* for _to_ macros */ 120 insn = *((unsigned int *) pc); 121 if ((insn >> 21) & 1) 122 return 1; 123 break; 124 125 case 2: 126 /* load will be handled by fixup, store will bump out */ 127 /* for _from_ macros */ 128 insn = *((unsigned int *) pc); 129 if (!((insn >> 21) & 1) || ((insn>>19)&0x3f) == 15) 130 return 2; 131 break; 132 133 default: 134 break; 135 }; 136 137 memset(®s, 0, sizeof (regs)); 138 regs.pc = pc; 139 regs.npc = pc + 4; 140 __asm__ __volatile__( 141 "rd %%psr, %0\n\t" 142 "nop\n\t" 143 "nop\n\t" 144 "nop\n" : "=r" (regs.psr)); 145 unhandled_fault(address, current, ®s); 146 147 /* Not reached */ 148 return 0; 149 } 150 151 extern unsigned long safe_compute_effective_address(struct pt_regs *, 152 unsigned int); 153 154 static unsigned long compute_si_addr(struct pt_regs *regs, int text_fault) 155 { 156 unsigned int insn; 157 158 if (text_fault) 159 return regs->pc; 160 161 if (regs->psr & PSR_PS) { 162 insn = *(unsigned int *) regs->pc; 163 } else { 164 __get_user(insn, (unsigned int *) regs->pc); 165 } 166 167 return safe_compute_effective_address(regs, insn); 168 } 169 170 asmlinkage void do_sparc_fault(struct pt_regs *regs, int text_fault, int write, 171 unsigned long address) 172 { 173 struct vm_area_struct *vma; 174 struct task_struct *tsk = current; 175 struct mm_struct *mm = tsk->mm; 176 unsigned int fixup; 177 unsigned long g2; 178 siginfo_t info; 179 int from_user = !(regs->psr & PSR_PS); 180 int fault; 181 182 if(text_fault) 183 address = regs->pc; 184 185 /* 186 * We fault-in kernel-space virtual memory on-demand. The 187 * 'reference' page table is init_mm.pgd. 188 * 189 * NOTE! We MUST NOT take any locks for this case. We may 190 * be in an interrupt or a critical region, and should 191 * only copy the information from the master page table, 192 * nothing more. 193 */ 194 if (!ARCH_SUN4C && address >= TASK_SIZE) 195 goto vmalloc_fault; 196 197 info.si_code = SEGV_MAPERR; 198 199 /* 200 * If we're in an interrupt or have no user 201 * context, we must not take the fault.. 202 */ 203 if (in_atomic() || !mm) 204 goto no_context; 205 206 down_read(&mm->mmap_sem); 207 208 /* 209 * The kernel referencing a bad kernel pointer can lock up 210 * a sun4c machine completely, so we must attempt recovery. 211 */ 212 if(!from_user && address >= PAGE_OFFSET) 213 goto bad_area; 214 215 vma = find_vma(mm, address); 216 if(!vma) 217 goto bad_area; 218 if(vma->vm_start <= address) 219 goto good_area; 220 if(!(vma->vm_flags & VM_GROWSDOWN)) 221 goto bad_area; 222 if(expand_stack(vma, address)) 223 goto bad_area; 224 /* 225 * Ok, we have a good vm_area for this memory access, so 226 * we can handle it.. 227 */ 228 good_area: 229 info.si_code = SEGV_ACCERR; 230 if(write) { 231 if(!(vma->vm_flags & VM_WRITE)) 232 goto bad_area; 233 } else { 234 /* Allow reads even for write-only mappings */ 235 if(!(vma->vm_flags & (VM_READ | VM_EXEC))) 236 goto bad_area; 237 } 238 239 /* 240 * If for any reason at all we couldn't handle the fault, 241 * make sure we exit gracefully rather than endlessly redo 242 * the fault. 243 */ 244 fault = handle_mm_fault(mm, vma, address, write); 245 if (unlikely(fault & VM_FAULT_ERROR)) { 246 if (fault & VM_FAULT_OOM) 247 goto out_of_memory; 248 else if (fault & VM_FAULT_SIGBUS) 249 goto do_sigbus; 250 BUG(); 251 } 252 if (fault & VM_FAULT_MAJOR) 253 current->maj_flt++; 254 else 255 current->min_flt++; 256 up_read(&mm->mmap_sem); 257 return; 258 259 /* 260 * Something tried to access memory that isn't in our memory map.. 261 * Fix it, but check if it's kernel or user first.. 262 */ 263 bad_area: 264 up_read(&mm->mmap_sem); 265 266 bad_area_nosemaphore: 267 /* User mode accesses just cause a SIGSEGV */ 268 if(from_user) { 269 #if 0 270 printk("Fault whee %s [%d]: segfaults at %08lx pc=%08lx\n", 271 tsk->comm, tsk->pid, address, regs->pc); 272 #endif 273 info.si_signo = SIGSEGV; 274 info.si_errno = 0; 275 /* info.si_code set above to make clear whether 276 this was a SEGV_MAPERR or SEGV_ACCERR fault. */ 277 info.si_addr = (void __user *)compute_si_addr(regs, text_fault); 278 info.si_trapno = 0; 279 force_sig_info (SIGSEGV, &info, tsk); 280 return; 281 } 282 283 /* Is this in ex_table? */ 284 no_context: 285 g2 = regs->u_regs[UREG_G2]; 286 if (!from_user) { 287 fixup = search_extables_range(regs->pc, &g2); 288 if (fixup > 10) { /* Values below are reserved for other things */ 289 extern const unsigned __memset_start[]; 290 extern const unsigned __memset_end[]; 291 extern const unsigned __csum_partial_copy_start[]; 292 extern const unsigned __csum_partial_copy_end[]; 293 294 #ifdef DEBUG_EXCEPTIONS 295 printk("Exception: PC<%08lx> faddr<%08lx>\n", regs->pc, address); 296 printk("EX_TABLE: insn<%08lx> fixup<%08x> g2<%08lx>\n", 297 regs->pc, fixup, g2); 298 #endif 299 if ((regs->pc >= (unsigned long)__memset_start && 300 regs->pc < (unsigned long)__memset_end) || 301 (regs->pc >= (unsigned long)__csum_partial_copy_start && 302 regs->pc < (unsigned long)__csum_partial_copy_end)) { 303 regs->u_regs[UREG_I4] = address; 304 regs->u_regs[UREG_I5] = regs->pc; 305 } 306 regs->u_regs[UREG_G2] = g2; 307 regs->pc = fixup; 308 regs->npc = regs->pc + 4; 309 return; 310 } 311 } 312 313 unhandled_fault (address, tsk, regs); 314 do_exit(SIGKILL); 315 316 /* 317 * We ran out of memory, or some other thing happened to us that made 318 * us unable to handle the page fault gracefully. 319 */ 320 out_of_memory: 321 up_read(&mm->mmap_sem); 322 printk("VM: killing process %s\n", tsk->comm); 323 if (from_user) 324 do_group_exit(SIGKILL); 325 goto no_context; 326 327 do_sigbus: 328 up_read(&mm->mmap_sem); 329 info.si_signo = SIGBUS; 330 info.si_errno = 0; 331 info.si_code = BUS_ADRERR; 332 info.si_addr = (void __user *) compute_si_addr(regs, text_fault); 333 info.si_trapno = 0; 334 force_sig_info (SIGBUS, &info, tsk); 335 if (!from_user) 336 goto no_context; 337 338 vmalloc_fault: 339 { 340 /* 341 * Synchronize this task's top level page-table 342 * with the 'reference' page table. 343 */ 344 int offset = pgd_index(address); 345 pgd_t *pgd, *pgd_k; 346 pmd_t *pmd, *pmd_k; 347 348 pgd = tsk->active_mm->pgd + offset; 349 pgd_k = init_mm.pgd + offset; 350 351 if (!pgd_present(*pgd)) { 352 if (!pgd_present(*pgd_k)) 353 goto bad_area_nosemaphore; 354 pgd_val(*pgd) = pgd_val(*pgd_k); 355 return; 356 } 357 358 pmd = pmd_offset(pgd, address); 359 pmd_k = pmd_offset(pgd_k, address); 360 361 if (pmd_present(*pmd) || !pmd_present(*pmd_k)) 362 goto bad_area_nosemaphore; 363 *pmd = *pmd_k; 364 return; 365 } 366 } 367 368 asmlinkage void do_sun4c_fault(struct pt_regs *regs, int text_fault, int write, 369 unsigned long address) 370 { 371 extern void sun4c_update_mmu_cache(struct vm_area_struct *, 372 unsigned long,pte_t); 373 extern pte_t *sun4c_pte_offset_kernel(pmd_t *,unsigned long); 374 struct task_struct *tsk = current; 375 struct mm_struct *mm = tsk->mm; 376 pgd_t *pgdp; 377 pte_t *ptep; 378 379 if (text_fault) { 380 address = regs->pc; 381 } else if (!write && 382 !(regs->psr & PSR_PS)) { 383 unsigned int insn, __user *ip; 384 385 ip = (unsigned int __user *)regs->pc; 386 if (!get_user(insn, ip)) { 387 if ((insn & 0xc1680000) == 0xc0680000) 388 write = 1; 389 } 390 } 391 392 if (!mm) { 393 /* We are oopsing. */ 394 do_sparc_fault(regs, text_fault, write, address); 395 BUG(); /* P3 Oops already, you bitch */ 396 } 397 398 pgdp = pgd_offset(mm, address); 399 ptep = sun4c_pte_offset_kernel((pmd_t *) pgdp, address); 400 401 if (pgd_val(*pgdp)) { 402 if (write) { 403 if ((pte_val(*ptep) & (_SUN4C_PAGE_WRITE|_SUN4C_PAGE_PRESENT)) 404 == (_SUN4C_PAGE_WRITE|_SUN4C_PAGE_PRESENT)) { 405 unsigned long flags; 406 407 *ptep = __pte(pte_val(*ptep) | _SUN4C_PAGE_ACCESSED | 408 _SUN4C_PAGE_MODIFIED | 409 _SUN4C_PAGE_VALID | 410 _SUN4C_PAGE_DIRTY); 411 412 local_irq_save(flags); 413 if (sun4c_get_segmap(address) != invalid_segment) { 414 sun4c_put_pte(address, pte_val(*ptep)); 415 local_irq_restore(flags); 416 return; 417 } 418 local_irq_restore(flags); 419 } 420 } else { 421 if ((pte_val(*ptep) & (_SUN4C_PAGE_READ|_SUN4C_PAGE_PRESENT)) 422 == (_SUN4C_PAGE_READ|_SUN4C_PAGE_PRESENT)) { 423 unsigned long flags; 424 425 *ptep = __pte(pte_val(*ptep) | _SUN4C_PAGE_ACCESSED | 426 _SUN4C_PAGE_VALID); 427 428 local_irq_save(flags); 429 if (sun4c_get_segmap(address) != invalid_segment) { 430 sun4c_put_pte(address, pte_val(*ptep)); 431 local_irq_restore(flags); 432 return; 433 } 434 local_irq_restore(flags); 435 } 436 } 437 } 438 439 /* This conditional is 'interesting'. */ 440 if (pgd_val(*pgdp) && !(write && !(pte_val(*ptep) & _SUN4C_PAGE_WRITE)) 441 && (pte_val(*ptep) & _SUN4C_PAGE_VALID)) 442 /* Note: It is safe to not grab the MMAP semaphore here because 443 * we know that update_mmu_cache() will not sleep for 444 * any reason (at least not in the current implementation) 445 * and therefore there is no danger of another thread getting 446 * on the CPU and doing a shrink_mmap() on this vma. 447 */ 448 sun4c_update_mmu_cache (find_vma(current->mm, address), address, 449 *ptep); 450 else 451 do_sparc_fault(regs, text_fault, write, address); 452 } 453 454 /* This always deals with user addresses. */ 455 static void force_user_fault(unsigned long address, int write) 456 { 457 struct vm_area_struct *vma; 458 struct task_struct *tsk = current; 459 struct mm_struct *mm = tsk->mm; 460 siginfo_t info; 461 462 info.si_code = SEGV_MAPERR; 463 464 #if 0 465 printk("wf<pid=%d,wr=%d,addr=%08lx>\n", 466 tsk->pid, write, address); 467 #endif 468 down_read(&mm->mmap_sem); 469 vma = find_vma(mm, address); 470 if(!vma) 471 goto bad_area; 472 if(vma->vm_start <= address) 473 goto good_area; 474 if(!(vma->vm_flags & VM_GROWSDOWN)) 475 goto bad_area; 476 if(expand_stack(vma, address)) 477 goto bad_area; 478 good_area: 479 info.si_code = SEGV_ACCERR; 480 if(write) { 481 if(!(vma->vm_flags & VM_WRITE)) 482 goto bad_area; 483 } else { 484 if(!(vma->vm_flags & (VM_READ | VM_EXEC))) 485 goto bad_area; 486 } 487 switch (handle_mm_fault(mm, vma, address, write)) { 488 case VM_FAULT_SIGBUS: 489 case VM_FAULT_OOM: 490 goto do_sigbus; 491 } 492 up_read(&mm->mmap_sem); 493 return; 494 bad_area: 495 up_read(&mm->mmap_sem); 496 #if 0 497 printk("Window whee %s [%d]: segfaults at %08lx\n", 498 tsk->comm, tsk->pid, address); 499 #endif 500 info.si_signo = SIGSEGV; 501 info.si_errno = 0; 502 /* info.si_code set above to make clear whether 503 this was a SEGV_MAPERR or SEGV_ACCERR fault. */ 504 info.si_addr = (void __user *) address; 505 info.si_trapno = 0; 506 force_sig_info (SIGSEGV, &info, tsk); 507 return; 508 509 do_sigbus: 510 up_read(&mm->mmap_sem); 511 info.si_signo = SIGBUS; 512 info.si_errno = 0; 513 info.si_code = BUS_ADRERR; 514 info.si_addr = (void __user *) address; 515 info.si_trapno = 0; 516 force_sig_info (SIGBUS, &info, tsk); 517 } 518 519 void window_overflow_fault(void) 520 { 521 unsigned long sp; 522 523 sp = current_thread_info()->rwbuf_stkptrs[0]; 524 if(((sp + 0x38) & PAGE_MASK) != (sp & PAGE_MASK)) 525 force_user_fault(sp + 0x38, 1); 526 force_user_fault(sp, 1); 527 } 528 529 void window_underflow_fault(unsigned long sp) 530 { 531 if(((sp + 0x38) & PAGE_MASK) != (sp & PAGE_MASK)) 532 force_user_fault(sp + 0x38, 0); 533 force_user_fault(sp, 0); 534 } 535 536 void window_ret_fault(struct pt_regs *regs) 537 { 538 unsigned long sp; 539 540 sp = regs->u_regs[UREG_FP]; 541 if(((sp + 0x38) & PAGE_MASK) != (sp & PAGE_MASK)) 542 force_user_fault(sp + 0x38, 0); 543 force_user_fault(sp, 0); 544 } 545