arch/sparc/mm/fault_32.c

   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/perf_event.h>
  22 #include <linux/interrupt.h>
  23 #include <linux/kdebug.h>
  24
  25 #include <asm/page.h>
  26 #include <asm/pgtable.h>
  27 #include <asm/openprom.h>
  28 #include <asm/oplib.h>
  29 #include <asm/smp.h>
  30 #include <asm/traps.h>
  31 #include <asm/uaccess.h>
  32
  33 int show_unhandled_signals = 1;
  34
  35 static void unhandled_fault(unsigned long, struct task_struct *,
  36                 struct pt_regs *) __attribute__ ((noreturn));
  37
  38 static void __noreturn unhandled_fault(unsigned long address,
  39                                        struct task_struct *tsk,
  40                                        struct pt_regs *regs)
  41 {
  42         if ((unsigned long) address < PAGE_SIZE) {
  43                 printk(KERN_ALERT
  44                     "Unable to handle kernel NULL pointer dereference\n");
  45         } else {
  46                 printk(KERN_ALERT "Unable to handle kernel paging request at virtual address %08lx\n",
  47                        address);
  48         }
  49         printk(KERN_ALERT "tsk->{mm,active_mm}->context = %08lx\n",
  50                 (tsk->mm ? tsk->mm->context : tsk->active_mm->context));
  51         printk(KERN_ALERT "tsk->{mm,active_mm}->pgd = %08lx\n",
  52                 (tsk->mm ? (unsigned long) tsk->mm->pgd :
  53                         (unsigned long) tsk->active_mm->pgd));
  54         die_if_kernel("Oops", regs);
  55 }
  56
  57 asmlinkage int lookup_fault(unsigned long pc, unsigned long ret_pc,
  58                             unsigned long address)
  59 {
  60         struct pt_regs regs;
  61         unsigned long g2;
  62         unsigned int insn;
  63         int i;
  64
  65         i = search_extables_range(ret_pc, &g2);
  66         switch (i) {
  67         case 3:
  68                 /* load & store will be handled by fixup */
  69                 return 3;
  70
  71         case 1:
  72                 /* store will be handled by fixup, load will bump out */
  73                 /* for _to_ macros */
  74                 insn = *((unsigned int *) pc);
  75                 if ((insn >> 21) & 1)
  76                         return 1;
  77                 break;
  78
  79         case 2:
  80                 /* load will be handled by fixup, store will bump out */
  81                 /* for _from_ macros */
  82                 insn = *((unsigned int *) pc);
  83                 if (!((insn >> 21) & 1) || ((insn>>19)&0x3f) == 15)
  84                         return 2;
  85                 break;
  86
  87         default:
  88                 break;
  89         }
  90
  91         memset(&regs, 0, sizeof(regs));
  92         regs.pc = pc;
  93         regs.npc = pc + 4;
  94         __asm__ __volatile__(
  95                 "rd %%psr, %0\n\t"
  96                 "nop\n\t"
  97                 "nop\n\t"
  98                 "nop\n" : "=r" (regs.psr));
  99         unhandled_fault(address, current, &regs);
 100
 101         /* Not reached */
 102         return 0;
 103 }
 104
 105 static inline void
 106 show_signal_msg(struct pt_regs *regs, int sig, int code,
 107                 unsigned long address, struct task_struct *tsk)
 108 {
 109         if (!unhandled_signal(tsk, sig))
 110                 return;
 111
 112         if (!printk_ratelimit())
 113                 return;
 114
 115         printk("%s%s[%d]: segfault at %lx ip %p (rpc %p) sp %p error %x",
 116                task_pid_nr(tsk) > 1 ? KERN_INFO : KERN_EMERG,
 117                tsk->comm, task_pid_nr(tsk), address,
 118                (void *)regs->pc, (void *)regs->u_regs[UREG_I7],
 119                (void *)regs->u_regs[UREG_FP], code);
 120
 121         print_vma_addr(KERN_CONT " in ", regs->pc);
 122
 123         printk(KERN_CONT "\n");
 124 }
 125
 126 static void __do_fault_siginfo(int code, int sig, struct pt_regs *regs,
 127                                unsigned long addr)
 128 {
 129         siginfo_t info;
 130
 131         info.si_signo = sig;
 132         info.si_code = code;
 133         info.si_errno = 0;
 134         info.si_addr = (void __user *) addr;
 135         info.si_trapno = 0;
 136
 137         if (unlikely(show_unhandled_signals))
 138                 show_signal_msg(regs, sig, info.si_code,
 139                                 addr, current);
 140
 141         force_sig_info (sig, &info, current);
 142 }
 143
 144 extern unsigned long safe_compute_effective_address(struct pt_regs *,
 145                                                     unsigned int);
 146
 147 static unsigned long compute_si_addr(struct pt_regs *regs, int text_fault)
 148 {
 149         unsigned int insn;
 150
 151         if (text_fault)
 152                 return regs->pc;
 153
 154         if (regs->psr & PSR_PS)
 155                 insn = *(unsigned int *) regs->pc;
 156         else
 157                 __get_user(insn, (unsigned int *) regs->pc);
 158
 159         return safe_compute_effective_address(regs, insn);
 160 }
 161
 162 static noinline void do_fault_siginfo(int code, int sig, struct pt_regs *regs,
 163                                       int text_fault)
 164 {
 165         unsigned long addr = compute_si_addr(regs, text_fault);
 166
 167         __do_fault_siginfo(code, sig, regs, addr);
 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         int from_user = !(regs->psr & PSR_PS);
 179         int fault, code;
 180         unsigned int flags = FAULT_FLAG_ALLOW_RETRY | FAULT_FLAG_KILLABLE;
 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         code = SEGV_MAPERR;
 195         if (address >= TASK_SIZE)
 196                 goto vmalloc_fault;
 197
 198         /*
 199          * If we're in an interrupt or have no user
 200          * context, we must not take the fault..
 201          */
 202         if (in_atomic() || !mm)
 203                 goto no_context;
 204
 205         perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS, 1, regs, address);
 206
 207 retry:
 208         down_read(&mm->mmap_sem);
 209
 210         if (!from_user && address >= PAGE_OFFSET)
 211                 goto bad_area;
 212
 213         vma = find_vma(mm, address);
 214         if (!vma)
 215                 goto bad_area;
 216         if (vma->vm_start <= address)
 217                 goto good_area;
 218         if (!(vma->vm_flags & VM_GROWSDOWN))
 219                 goto bad_area;
 220         if (expand_stack(vma, address))
 221                 goto bad_area;
 222         /*
 223          * Ok, we have a good vm_area for this memory access, so
 224          * we can handle it..
 225          */
 226 good_area:
 227         code = SEGV_ACCERR;
 228         if (write) {
 229                 if (!(vma->vm_flags & VM_WRITE))
 230                         goto bad_area;
 231         } else {
 232                 /* Allow reads even for write-only mappings */
 233                 if (!(vma->vm_flags & (VM_READ | VM_EXEC)))
 234                         goto bad_area;
 235         }
 236
 237         if (from_user)
 238                 flags |= FAULT_FLAG_USER;
 239         if (write)
 240                 flags |= FAULT_FLAG_WRITE;
 241
 242         /*
 243          * If for any reason at all we couldn't handle the fault,
 244          * make sure we exit gracefully rather than endlessly redo
 245          * the fault.
 246          */
 247         fault = handle_mm_fault(mm, vma, address, flags);
 248
 249         if ((fault & VM_FAULT_RETRY) && fatal_signal_pending(current))
 250                 return;
 251
 252         if (unlikely(fault & VM_FAULT_ERROR)) {
 253                 if (fault & VM_FAULT_OOM)
 254                         goto out_of_memory;
 255                 else if (fault & VM_FAULT_SIGSEGV)
 256                         goto bad_area;
 257                 else if (fault & VM_FAULT_SIGBUS)
 258                         goto do_sigbus;
 259                 BUG();
 260         }
 261
 262         if (flags & FAULT_FLAG_ALLOW_RETRY) {
 263                 if (fault & VM_FAULT_MAJOR) {
 264                         current->maj_flt++;
 265                         perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MAJ,
 266                                       1, regs, address);
 267                 } else {
 268                         current->min_flt++;
 269                         perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MIN,
 270                                       1, regs, address);
 271                 }
 272                 if (fault & VM_FAULT_RETRY) {
 273                         flags &= ~FAULT_FLAG_ALLOW_RETRY;
 274                         flags |= FAULT_FLAG_TRIED;
 275
 276                         /* No need to up_read(&mm->mmap_sem) as we would
 277                          * have already released it in __lock_page_or_retry
 278                          * in mm/filemap.c.
 279                          */
 280
 281                         goto retry;
 282                 }
 283         }
 284
 285         up_read(&mm->mmap_sem);
 286         return;
 287
 288         /*
 289          * Something tried to access memory that isn't in our memory map..
 290          * Fix it, but check if it's kernel or user first..
 291          */
 292 bad_area:
 293         up_read(&mm->mmap_sem);
 294
 295 bad_area_nosemaphore:
 296         /* User mode accesses just cause a SIGSEGV */
 297         if (from_user) {
 298                 do_fault_siginfo(code, SIGSEGV, regs, text_fault);
 299                 return;
 300         }
 301
 302         /* Is this in ex_table? */
 303 no_context:
 304         g2 = regs->u_regs[UREG_G2];
 305         if (!from_user) {
 306                 fixup = search_extables_range(regs->pc, &g2);
 307                 /* Values below 10 are reserved for other things */
 308                 if (fixup > 10) {
 309                         extern const unsigned __memset_start[];
 310                         extern const unsigned __memset_end[];
 311                         extern const unsigned __csum_partial_copy_start[];
 312                         extern const unsigned __csum_partial_copy_end[];
 313
 314 #ifdef DEBUG_EXCEPTIONS
 315                         printk("Exception: PC<%08lx> faddr<%08lx>\n",
 316                                regs->pc, address);
 317                         printk("EX_TABLE: insn<%08lx> fixup<%08x> g2<%08lx>\n",
 318                                 regs->pc, fixup, g2);
 319 #endif
 320                         if ((regs->pc >= (unsigned long)__memset_start &&
 321                              regs->pc < (unsigned long)__memset_end) ||
 322                             (regs->pc >= (unsigned long)__csum_partial_copy_start &&
 323                              regs->pc < (unsigned long)__csum_partial_copy_end)) {
 324                                 regs->u_regs[UREG_I4] = address;
 325                                 regs->u_regs[UREG_I5] = regs->pc;
 326                         }
 327                         regs->u_regs[UREG_G2] = g2;
 328                         regs->pc = fixup;
 329                         regs->npc = regs->pc + 4;
 330                         return;
 331                 }
 332         }
 333
 334         unhandled_fault(address, tsk, regs);
 335         do_exit(SIGKILL);
 336
 337 /*
 338  * We ran out of memory, or some other thing happened to us that made
 339  * us unable to handle the page fault gracefully.
 340  */
 341 out_of_memory:
 342         up_read(&mm->mmap_sem);
 343         if (from_user) {
 344                 pagefault_out_of_memory();
 345                 return;
 346         }
 347         goto no_context;
 348
 349 do_sigbus:
 350         up_read(&mm->mmap_sem);
 351         do_fault_siginfo(BUS_ADRERR, SIGBUS, regs, text_fault);
 352         if (!from_user)
 353                 goto no_context;
 354
 355 vmalloc_fault:
 356         {
 357                 /*
 358                  * Synchronize this task's top level page-table
 359                  * with the 'reference' page table.
 360                  */
 361                 int offset = pgd_index(address);
 362                 pgd_t *pgd, *pgd_k;
 363                 pmd_t *pmd, *pmd_k;
 364
 365                 pgd = tsk->active_mm->pgd + offset;
 366                 pgd_k = init_mm.pgd + offset;
 367
 368                 if (!pgd_present(*pgd)) {
 369                         if (!pgd_present(*pgd_k))
 370                                 goto bad_area_nosemaphore;
 371                         pgd_val(*pgd) = pgd_val(*pgd_k);
 372                         return;
 373                 }
 374
 375                 pmd = pmd_offset(pgd, address);
 376                 pmd_k = pmd_offset(pgd_k, address);
 377
 378                 if (pmd_present(*pmd) || !pmd_present(*pmd_k))
 379                         goto bad_area_nosemaphore;
 380
 381                 *pmd = *pmd_k;
 382                 return;
 383         }
 384 }
 385
 386 /* This always deals with user addresses. */
 387 static void force_user_fault(unsigned long address, int write)
 388 {
 389         struct vm_area_struct *vma;
 390         struct task_struct *tsk = current;
 391         struct mm_struct *mm = tsk->mm;
 392         unsigned int flags = FAULT_FLAG_USER;
 393         int code;
 394
 395         code = SEGV_MAPERR;
 396
 397         down_read(&mm->mmap_sem);
 398         vma = find_vma(mm, address);
 399         if (!vma)
 400                 goto bad_area;
 401         if (vma->vm_start <= address)
 402                 goto good_area;
 403         if (!(vma->vm_flags & VM_GROWSDOWN))
 404                 goto bad_area;
 405         if (expand_stack(vma, address))
 406                 goto bad_area;
 407 good_area:
 408         code = SEGV_ACCERR;
 409         if (write) {
 410                 if (!(vma->vm_flags & VM_WRITE))
 411                         goto bad_area;
 412                 flags |= FAULT_FLAG_WRITE;
 413         } else {
 414                 if (!(vma->vm_flags & (VM_READ | VM_EXEC)))
 415                         goto bad_area;
 416         }
 417         switch (handle_mm_fault(mm, vma, address, flags)) {
 418         case VM_FAULT_SIGBUS:
 419         case VM_FAULT_OOM:
 420                 goto do_sigbus;
 421         }
 422         up_read(&mm->mmap_sem);
 423         return;
 424 bad_area:
 425         up_read(&mm->mmap_sem);
 426         __do_fault_siginfo(code, SIGSEGV, tsk->thread.kregs, address);
 427         return;
 428
 429 do_sigbus:
 430         up_read(&mm->mmap_sem);
 431         __do_fault_siginfo(BUS_ADRERR, SIGBUS, tsk->thread.kregs, address);
 432 }
 433
 434 static void check_stack_aligned(unsigned long sp)
 435 {
 436         if (sp & 0x7UL)
 437                 force_sig(SIGILL, current);
 438 }
 439
 440 void window_overflow_fault(void)
 441 {
 442         unsigned long sp;
 443
 444         sp = current_thread_info()->rwbuf_stkptrs[0];
 445         if (((sp + 0x38) & PAGE_MASK) != (sp & PAGE_MASK))
 446                 force_user_fault(sp + 0x38, 1);
 447         force_user_fault(sp, 1);
 448
 449         check_stack_aligned(sp);
 450 }
 451
 452 void window_underflow_fault(unsigned long sp)
 453 {
 454         if (((sp + 0x38) & PAGE_MASK) != (sp & PAGE_MASK))
 455                 force_user_fault(sp + 0x38, 0);
 456         force_user_fault(sp, 0);
 457
 458         check_stack_aligned(sp);
 459 }
 460
 461 void window_ret_fault(struct pt_regs *regs)
 462 {
 463         unsigned long sp;
 464
 465         sp = regs->u_regs[UREG_FP];
 466         if (((sp + 0x38) & PAGE_MASK) != (sp & PAGE_MASK))
 467                 force_user_fault(sp + 0x38, 0);
 468         force_user_fault(sp, 0);
 469
 470         check_stack_aligned(sp);
 471 }