LXR linux/arch/sparc/mm/fault

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