arch/sparc/mm/fault_32.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * fault.c:  Page fault handlers for the Sparc.
   4  *
   5  * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
   6  * Copyright (C) 1996 Eddie C. Dost (ecd@skynet.be)
   7  * Copyright (C) 1997 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
   8  */
   9
  10 #include <asm/head.h>
  11
  12 #include <linux/string.h>
  13 #include <linux/types.h>
  14 #include <linux/sched.h>
  15 #include <linux/ptrace.h>
  16 #include <linux/mman.h>
  17 #include <linux/threads.h>
  18 #include <linux/kernel.h>
  19 #include <linux/signal.h>
  20 #include <linux/mm.h>
  21 #include <linux/smp.h>
  22 #include <linux/perf_event.h>
  23 #include <linux/interrupt.h>
  24 #include <linux/kdebug.h>
  25 #include <linux/uaccess.h>
  26 #include <linux/extable.h>
  27
  28 #include <asm/page.h>
  29 #include <asm/openprom.h>
  30 #include <asm/oplib.h>
  31 #include <asm/setup.h>
  32 #include <asm/smp.h>
  33 #include <asm/traps.h>
  34
  35 #include "mm_32.h"
  36
  37 int show_unhandled_signals = 1;
  38
  39 static void __noreturn unhandled_fault(unsigned long address,
  40                                        struct task_struct *tsk,
  41                                        struct pt_regs *regs)
  42 {
  43         if ((unsigned long) address < PAGE_SIZE) {
  44                 printk(KERN_ALERT
  45                     "Unable to handle kernel NULL pointer dereference\n");
  46         } else {
  47                 printk(KERN_ALERT "Unable to handle kernel paging request at virtual address %08lx\n",
  48                        address);
  49         }
  50         printk(KERN_ALERT "tsk->{mm,active_mm}->context = %08lx\n",
  51                 (tsk->mm ? tsk->mm->context : tsk->active_mm->context));
  52         printk(KERN_ALERT "tsk->{mm,active_mm}->pgd = %08lx\n",
  53                 (tsk->mm ? (unsigned long) tsk->mm->pgd :
  54                         (unsigned long) tsk->active_mm->pgd));
  55         die_if_kernel("Oops", regs);
  56 }
  57
  58 static inline void
  59 show_signal_msg(struct pt_regs *regs, int sig, int code,
  60                 unsigned long address, struct task_struct *tsk)
  61 {
  62         if (!unhandled_signal(tsk, sig))
  63                 return;
  64
  65         if (!printk_ratelimit())
  66                 return;
  67
  68         printk("%s%s[%d]: segfault at %lx ip %px (rpc %px) sp %px error %x",
  69                task_pid_nr(tsk) > 1 ? KERN_INFO : KERN_EMERG,
  70                tsk->comm, task_pid_nr(tsk), address,
  71                (void *)regs->pc, (void *)regs->u_regs[UREG_I7],
  72                (void *)regs->u_regs[UREG_FP], code);
  73
  74         print_vma_addr(KERN_CONT " in ", regs->pc);
  75
  76         printk(KERN_CONT "\n");
  77 }
  78
  79 static void __do_fault_siginfo(int code, int sig, struct pt_regs *regs,
  80                                unsigned long addr)
  81 {
  82         if (unlikely(show_unhandled_signals))
  83                 show_signal_msg(regs, sig, code,
  84                                 addr, current);
  85
  86         force_sig_fault(sig, code, (void __user *) addr);
  87 }
  88
  89 static unsigned long compute_si_addr(struct pt_regs *regs, int text_fault)
  90 {
  91         unsigned int insn;
  92
  93         if (text_fault)
  94                 return regs->pc;
  95
  96         if (regs->psr & PSR_PS)
  97                 insn = *(unsigned int *) regs->pc;
  98         else
  99                 __get_user(insn, (unsigned int *) regs->pc);
 100
 101         return safe_compute_effective_address(regs, insn);
 102 }
 103
 104 static noinline void do_fault_siginfo(int code, int sig, struct pt_regs *regs,
 105                                       int text_fault)
 106 {
 107         unsigned long addr = compute_si_addr(regs, text_fault);
 108
 109         __do_fault_siginfo(code, sig, regs, addr);
 110 }
 111
 112 asmlinkage void do_sparc_fault(struct pt_regs *regs, int text_fault, int write,
 113                                unsigned long address)
 114 {
 115         struct vm_area_struct *vma;
 116         struct task_struct *tsk = current;
 117         struct mm_struct *mm = tsk->mm;
 118         int from_user = !(regs->psr & PSR_PS);
 119         int code;
 120         vm_fault_t fault;
 121         unsigned int flags = FAULT_FLAG_DEFAULT;
 122
 123         if (text_fault)
 124                 address = regs->pc;
 125
 126         /*
 127          * We fault-in kernel-space virtual memory on-demand. The
 128          * 'reference' page table is init_mm.pgd.
 129          *
 130          * NOTE! We MUST NOT take any locks for this case. We may
 131          * be in an interrupt or a critical region, and should
 132          * only copy the information from the master page table,
 133          * nothing more.
 134          */
 135         code = SEGV_MAPERR;
 136         if (address >= TASK_SIZE)
 137                 goto vmalloc_fault;
 138
 139         /*
 140          * If we're in an interrupt or have no user
 141          * context, we must not take the fault..
 142          */
 143         if (pagefault_disabled() || !mm)
 144                 goto no_context;
 145
 146         perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS, 1, regs, address);
 147
 148 retry:
 149         mmap_read_lock(mm);
 150
 151         if (!from_user && address >= PAGE_OFFSET)
 152                 goto bad_area;
 153
 154         vma = find_vma(mm, address);
 155         if (!vma)
 156                 goto bad_area;
 157         if (vma->vm_start <= address)
 158                 goto good_area;
 159         if (!(vma->vm_flags & VM_GROWSDOWN))
 160                 goto bad_area;
 161         if (expand_stack(vma, address))
 162                 goto bad_area;
 163         /*
 164          * Ok, we have a good vm_area for this memory access, so
 165          * we can handle it..
 166          */
 167 good_area:
 168         code = SEGV_ACCERR;
 169         if (write) {
 170                 if (!(vma->vm_flags & VM_WRITE))
 171                         goto bad_area;
 172         } else {
 173                 /* Allow reads even for write-only mappings */
 174                 if (!(vma->vm_flags & (VM_READ | VM_EXEC)))
 175                         goto bad_area;
 176         }
 177
 178         if (from_user)
 179                 flags |= FAULT_FLAG_USER;
 180         if (write)
 181                 flags |= FAULT_FLAG_WRITE;
 182
 183         /*
 184          * If for any reason at all we couldn't handle the fault,
 185          * make sure we exit gracefully rather than endlessly redo
 186          * the fault.
 187          */
 188         fault = handle_mm_fault(vma, address, flags, regs);
 189
 190         if (fault_signal_pending(fault, regs))
 191                 return;
 192
 193         /* The fault is fully completed (including releasing mmap lock) */
 194         if (fault & VM_FAULT_COMPLETED)
 195                 return;
 196
 197         if (unlikely(fault & VM_FAULT_ERROR)) {
 198                 if (fault & VM_FAULT_OOM)
 199                         goto out_of_memory;
 200                 else if (fault & VM_FAULT_SIGSEGV)
 201                         goto bad_area;
 202                 else if (fault & VM_FAULT_SIGBUS)
 203                         goto do_sigbus;
 204                 BUG();
 205         }
 206
 207         if (fault & VM_FAULT_RETRY) {
 208                 flags |= FAULT_FLAG_TRIED;
 209
 210                 /* No need to mmap_read_unlock(mm) as we would
 211                  * have already released it in __lock_page_or_retry
 212                  * in mm/filemap.c.
 213                  */
 214
 215                 goto retry;
 216         }
 217
 218         mmap_read_unlock(mm);
 219         return;
 220
 221         /*
 222          * Something tried to access memory that isn't in our memory map..
 223          * Fix it, but check if it's kernel or user first..
 224          */
 225 bad_area:
 226         mmap_read_unlock(mm);
 227
 228 bad_area_nosemaphore:
 229         /* User mode accesses just cause a SIGSEGV */
 230         if (from_user) {
 231                 do_fault_siginfo(code, SIGSEGV, regs, text_fault);
 232                 return;
 233         }
 234
 235         /* Is this in ex_table? */
 236 no_context:
 237         if (!from_user) {
 238                 const struct exception_table_entry *entry;
 239
 240                 entry = search_exception_tables(regs->pc);
 241 #ifdef DEBUG_EXCEPTIONS
 242                 printk("Exception: PC<%08lx> faddr<%08lx>\n",
 243                        regs->pc, address);
 244                 printk("EX_TABLE: insn<%08lx> fixup<%08x>\n",
 245                         regs->pc, entry->fixup);
 246 #endif
 247                 regs->pc = entry->fixup;
 248                 regs->npc = regs->pc + 4;
 249                 return;
 250         }
 251
 252         unhandled_fault(address, tsk, regs);
 253
 254 /*
 255  * We ran out of memory, or some other thing happened to us that made
 256  * us unable to handle the page fault gracefully.
 257  */
 258 out_of_memory:
 259         mmap_read_unlock(mm);
 260         if (from_user) {
 261                 pagefault_out_of_memory();
 262                 return;
 263         }
 264         goto no_context;
 265
 266 do_sigbus:
 267         mmap_read_unlock(mm);
 268         do_fault_siginfo(BUS_ADRERR, SIGBUS, regs, text_fault);
 269         if (!from_user)
 270                 goto no_context;
 271
 272 vmalloc_fault:
 273         {
 274                 /*
 275                  * Synchronize this task's top level page-table
 276                  * with the 'reference' page table.
 277                  */
 278                 int offset = pgd_index(address);
 279                 pgd_t *pgd, *pgd_k;
 280                 p4d_t *p4d, *p4d_k;
 281                 pud_t *pud, *pud_k;
 282                 pmd_t *pmd, *pmd_k;
 283
 284                 pgd = tsk->active_mm->pgd + offset;
 285                 pgd_k = init_mm.pgd + offset;
 286
 287                 if (!pgd_present(*pgd)) {
 288                         if (!pgd_present(*pgd_k))
 289                                 goto bad_area_nosemaphore;
 290                         pgd_val(*pgd) = pgd_val(*pgd_k);
 291                         return;
 292                 }
 293
 294                 p4d = p4d_offset(pgd, address);
 295                 pud = pud_offset(p4d, address);
 296                 pmd = pmd_offset(pud, address);
 297
 298                 p4d_k = p4d_offset(pgd_k, address);
 299                 pud_k = pud_offset(p4d_k, address);
 300                 pmd_k = pmd_offset(pud_k, address);
 301
 302                 if (pmd_present(*pmd) || !pmd_present(*pmd_k))
 303                         goto bad_area_nosemaphore;
 304
 305                 *pmd = *pmd_k;
 306                 return;
 307         }
 308 }
 309
 310 /* This always deals with user addresses. */
 311 static void force_user_fault(unsigned long address, int write)
 312 {
 313         struct vm_area_struct *vma;
 314         struct task_struct *tsk = current;
 315         struct mm_struct *mm = tsk->mm;
 316         unsigned int flags = FAULT_FLAG_USER;
 317         int code;
 318
 319         code = SEGV_MAPERR;
 320
 321         mmap_read_lock(mm);
 322         vma = find_vma(mm, address);
 323         if (!vma)
 324                 goto bad_area;
 325         if (vma->vm_start <= address)
 326                 goto good_area;
 327         if (!(vma->vm_flags & VM_GROWSDOWN))
 328                 goto bad_area;
 329         if (expand_stack(vma, address))
 330                 goto bad_area;
 331 good_area:
 332         code = SEGV_ACCERR;
 333         if (write) {
 334                 if (!(vma->vm_flags & VM_WRITE))
 335                         goto bad_area;
 336                 flags |= FAULT_FLAG_WRITE;
 337         } else {
 338                 if (!(vma->vm_flags & (VM_READ | VM_EXEC)))
 339                         goto bad_area;
 340         }
 341         switch (handle_mm_fault(vma, address, flags, NULL)) {
 342         case VM_FAULT_SIGBUS:
 343         case VM_FAULT_OOM:
 344                 goto do_sigbus;
 345         }
 346         mmap_read_unlock(mm);
 347         return;
 348 bad_area:
 349         mmap_read_unlock(mm);
 350         __do_fault_siginfo(code, SIGSEGV, tsk->thread.kregs, address);
 351         return;
 352
 353 do_sigbus:
 354         mmap_read_unlock(mm);
 355         __do_fault_siginfo(BUS_ADRERR, SIGBUS, tsk->thread.kregs, address);
 356 }
 357
 358 static void check_stack_aligned(unsigned long sp)
 359 {
 360         if (sp & 0x7UL)
 361                 force_sig(SIGILL);
 362 }
 363
 364 void window_overflow_fault(void)
 365 {
 366         unsigned long sp;
 367
 368         sp = current_thread_info()->rwbuf_stkptrs[0];
 369         if (((sp + 0x38) & PAGE_MASK) != (sp & PAGE_MASK))
 370                 force_user_fault(sp + 0x38, 1);
 371         force_user_fault(sp, 1);
 372
 373         check_stack_aligned(sp);
 374 }
 375
 376 void window_underflow_fault(unsigned long sp)
 377 {
 378         if (((sp + 0x38) & PAGE_MASK) != (sp & PAGE_MASK))
 379                 force_user_fault(sp + 0x38, 0);
 380         force_user_fault(sp, 0);
 381
 382         check_stack_aligned(sp);
 383 }
 384
 385 void window_ret_fault(struct pt_regs *regs)
 386 {
 387         unsigned long sp;
 388
 389         sp = regs->u_regs[UREG_FP];
 390         if (((sp + 0x38) & PAGE_MASK) != (sp & PAGE_MASK))
 391                 force_user_fault(sp + 0x38, 0);
 392         force_user_fault(sp, 0);
 393
 394         check_stack_aligned(sp);
 395 }