linux/arch/mips/mm/fault.c
<<
>>
Prefs
   1/*
   2 * This file is subject to the terms and conditions of the GNU General Public
   3 * License.  See the file "COPYING" in the main directory of this archive
   4 * for more details.
   5 *
   6 * Copyright (C) 1995 - 2000 by Ralf Baechle
   7 */
   8#include <linux/signal.h>
   9#include <linux/sched.h>
  10#include <linux/interrupt.h>
  11#include <linux/kernel.h>
  12#include <linux/errno.h>
  13#include <linux/string.h>
  14#include <linux/types.h>
  15#include <linux/ptrace.h>
  16#include <linux/mman.h>
  17#include <linux/mm.h>
  18#include <linux/smp.h>
  19#include <linux/module.h>
  20#include <linux/kprobes.h>
  21#include <linux/perf_event.h>
  22
  23#include <asm/branch.h>
  24#include <asm/mmu_context.h>
  25#include <asm/system.h>
  26#include <asm/uaccess.h>
  27#include <asm/ptrace.h>
  28#include <asm/highmem.h>                /* For VMALLOC_END */
  29#include <linux/kdebug.h>
  30
  31/*
  32 * This routine handles page faults.  It determines the address,
  33 * and the problem, and then passes it off to one of the appropriate
  34 * routines.
  35 */
  36asmlinkage void __kprobes do_page_fault(struct pt_regs *regs, unsigned long write,
  37                              unsigned long address)
  38{
  39        struct vm_area_struct * vma = NULL;
  40        struct task_struct *tsk = current;
  41        struct mm_struct *mm = tsk->mm;
  42        const int field = sizeof(unsigned long) * 2;
  43        siginfo_t info;
  44        int fault;
  45
  46#if 0
  47        printk("Cpu%d[%s:%d:%0*lx:%ld:%0*lx]\n", raw_smp_processor_id(),
  48               current->comm, current->pid, field, address, write,
  49               field, regs->cp0_epc);
  50#endif
  51
  52#ifdef CONFIG_KPROBES
  53        /*
  54         * This is to notify the fault handler of the kprobes.  The
  55         * exception code is redundant as it is also carried in REGS,
  56         * but we pass it anyhow.
  57         */
  58        if (notify_die(DIE_PAGE_FAULT, "page fault", regs, -1,
  59                       (regs->cp0_cause >> 2) & 0x1f, SIGSEGV) == NOTIFY_STOP)
  60                return;
  61#endif
  62
  63        info.si_code = SEGV_MAPERR;
  64
  65        /*
  66         * We fault-in kernel-space virtual memory on-demand. The
  67         * 'reference' page table is init_mm.pgd.
  68         *
  69         * NOTE! We MUST NOT take any locks for this case. We may
  70         * be in an interrupt or a critical region, and should
  71         * only copy the information from the master page table,
  72         * nothing more.
  73         */
  74#ifdef CONFIG_64BIT
  75# define VMALLOC_FAULT_TARGET no_context
  76#else
  77# define VMALLOC_FAULT_TARGET vmalloc_fault
  78#endif
  79
  80        if (unlikely(address >= VMALLOC_START && address <= VMALLOC_END))
  81                goto VMALLOC_FAULT_TARGET;
  82#ifdef MODULE_START
  83        if (unlikely(address >= MODULE_START && address < MODULE_END))
  84                goto VMALLOC_FAULT_TARGET;
  85#endif
  86
  87        /*
  88         * If we're in an interrupt or have no user
  89         * context, we must not take the fault..
  90         */
  91        if (in_atomic() || !mm)
  92                goto bad_area_nosemaphore;
  93
  94        down_read(&mm->mmap_sem);
  95        vma = find_vma(mm, address);
  96        if (!vma)
  97                goto bad_area;
  98        if (vma->vm_start <= address)
  99                goto good_area;
 100        if (!(vma->vm_flags & VM_GROWSDOWN))
 101                goto bad_area;
 102        if (expand_stack(vma, address))
 103                goto bad_area;
 104/*
 105 * Ok, we have a good vm_area for this memory access, so
 106 * we can handle it..
 107 */
 108good_area:
 109        info.si_code = SEGV_ACCERR;
 110
 111        if (write) {
 112                if (!(vma->vm_flags & VM_WRITE))
 113                        goto bad_area;
 114        } else {
 115                if (kernel_uses_smartmips_rixi) {
 116                        if (address == regs->cp0_epc && !(vma->vm_flags & VM_EXEC)) {
 117#if 0
 118                                pr_notice("Cpu%d[%s:%d:%0*lx:%ld:%0*lx] XI violation\n",
 119                                          raw_smp_processor_id(),
 120                                          current->comm, current->pid,
 121                                          field, address, write,
 122                                          field, regs->cp0_epc);
 123#endif
 124                                goto bad_area;
 125                        }
 126                        if (!(vma->vm_flags & VM_READ)) {
 127#if 0
 128                                pr_notice("Cpu%d[%s:%d:%0*lx:%ld:%0*lx] RI violation\n",
 129                                          raw_smp_processor_id(),
 130                                          current->comm, current->pid,
 131                                          field, address, write,
 132                                          field, regs->cp0_epc);
 133#endif
 134                                goto bad_area;
 135                        }
 136                } else {
 137                        if (!(vma->vm_flags & (VM_READ | VM_WRITE | VM_EXEC)))
 138                                goto bad_area;
 139                }
 140        }
 141
 142        /*
 143         * If for any reason at all we couldn't handle the fault,
 144         * make sure we exit gracefully rather than endlessly redo
 145         * the fault.
 146         */
 147        fault = handle_mm_fault(mm, vma, address, write ? FAULT_FLAG_WRITE : 0);
 148        perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS, 1, 0, regs, address);
 149        if (unlikely(fault & VM_FAULT_ERROR)) {
 150                if (fault & VM_FAULT_OOM)
 151                        goto out_of_memory;
 152                else if (fault & VM_FAULT_SIGBUS)
 153                        goto do_sigbus;
 154                BUG();
 155        }
 156        if (fault & VM_FAULT_MAJOR) {
 157                perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MAJ,
 158                                1, 0, regs, address);
 159                tsk->maj_flt++;
 160        } else {
 161                perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MIN,
 162                                1, 0, regs, address);
 163                tsk->min_flt++;
 164        }
 165
 166        up_read(&mm->mmap_sem);
 167        return;
 168
 169/*
 170 * Something tried to access memory that isn't in our memory map..
 171 * Fix it, but check if it's kernel or user first..
 172 */
 173bad_area:
 174        up_read(&mm->mmap_sem);
 175
 176bad_area_nosemaphore:
 177        /* User mode accesses just cause a SIGSEGV */
 178        if (user_mode(regs)) {
 179                tsk->thread.cp0_badvaddr = address;
 180                tsk->thread.error_code = write;
 181#if 0
 182                printk("do_page_fault() #2: sending SIGSEGV to %s for "
 183                       "invalid %s\n%0*lx (epc == %0*lx, ra == %0*lx)\n",
 184                       tsk->comm,
 185                       write ? "write access to" : "read access from",
 186                       field, address,
 187                       field, (unsigned long) regs->cp0_epc,
 188                       field, (unsigned long) regs->regs[31]);
 189#endif
 190                info.si_signo = SIGSEGV;
 191                info.si_errno = 0;
 192                /* info.si_code has been set above */
 193                info.si_addr = (void __user *) address;
 194                force_sig_info(SIGSEGV, &info, tsk);
 195                return;
 196        }
 197
 198no_context:
 199        /* Are we prepared to handle this kernel fault?  */
 200        if (fixup_exception(regs)) {
 201                current->thread.cp0_baduaddr = address;
 202                return;
 203        }
 204
 205        /*
 206         * Oops. The kernel tried to access some bad page. We'll have to
 207         * terminate things with extreme prejudice.
 208         */
 209        bust_spinlocks(1);
 210
 211        printk(KERN_ALERT "CPU %d Unable to handle kernel paging request at "
 212               "virtual address %0*lx, epc == %0*lx, ra == %0*lx\n",
 213               raw_smp_processor_id(), field, address, field, regs->cp0_epc,
 214               field,  regs->regs[31]);
 215        die("Oops", regs);
 216
 217out_of_memory:
 218        /*
 219         * We ran out of memory, call the OOM killer, and return the userspace
 220         * (which will retry the fault, or kill us if we got oom-killed).
 221         */
 222        up_read(&mm->mmap_sem);
 223        pagefault_out_of_memory();
 224        return;
 225
 226do_sigbus:
 227        up_read(&mm->mmap_sem);
 228
 229        /* Kernel mode? Handle exceptions or die */
 230        if (!user_mode(regs))
 231                goto no_context;
 232        else
 233        /*
 234         * Send a sigbus, regardless of whether we were in kernel
 235         * or user mode.
 236         */
 237#if 0
 238                printk("do_page_fault() #3: sending SIGBUS to %s for "
 239                       "invalid %s\n%0*lx (epc == %0*lx, ra == %0*lx)\n",
 240                       tsk->comm,
 241                       write ? "write access to" : "read access from",
 242                       field, address,
 243                       field, (unsigned long) regs->cp0_epc,
 244                       field, (unsigned long) regs->regs[31]);
 245#endif
 246        tsk->thread.cp0_badvaddr = address;
 247        info.si_signo = SIGBUS;
 248        info.si_errno = 0;
 249        info.si_code = BUS_ADRERR;
 250        info.si_addr = (void __user *) address;
 251        force_sig_info(SIGBUS, &info, tsk);
 252
 253        return;
 254#ifndef CONFIG_64BIT
 255vmalloc_fault:
 256        {
 257                /*
 258                 * Synchronize this task's top level page-table
 259                 * with the 'reference' page table.
 260                 *
 261                 * Do _not_ use "tsk" here. We might be inside
 262                 * an interrupt in the middle of a task switch..
 263                 */
 264                int offset = __pgd_offset(address);
 265                pgd_t *pgd, *pgd_k;
 266                pud_t *pud, *pud_k;
 267                pmd_t *pmd, *pmd_k;
 268                pte_t *pte_k;
 269
 270                pgd = (pgd_t *) pgd_current[raw_smp_processor_id()] + offset;
 271                pgd_k = init_mm.pgd + offset;
 272
 273                if (!pgd_present(*pgd_k))
 274                        goto no_context;
 275                set_pgd(pgd, *pgd_k);
 276
 277                pud = pud_offset(pgd, address);
 278                pud_k = pud_offset(pgd_k, address);
 279                if (!pud_present(*pud_k))
 280                        goto no_context;
 281
 282                pmd = pmd_offset(pud, address);
 283                pmd_k = pmd_offset(pud_k, address);
 284                if (!pmd_present(*pmd_k))
 285                        goto no_context;
 286                set_pmd(pmd, *pmd_k);
 287
 288                pte_k = pte_offset_kernel(pmd_k, address);
 289                if (!pte_present(*pte_k))
 290                        goto no_context;
 291                return;
 292        }
 293#endif
 294}
 295