arch/arm26/mm/fault.c

   1 /*
   2  *  linux/arch/arm26/mm/fault.c
   3  *
   4  *  Copyright (C) 1995  Linus Torvalds
   5  *  Modifications for ARM processor (c) 1995-2001 Russell King
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 as
   9  * published by the Free Software Foundation.
  10  */
  11 #include <linux/signal.h>
  12 #include <linux/sched.h>
  13 #include <linux/kernel.h>
  14 #include <linux/errno.h>
  15 #include <linux/string.h>
  16 #include <linux/types.h>
  17 #include <linux/ptrace.h>
  18 #include <linux/mman.h>
  19 #include <linux/mm.h>
  20 #include <linux/interrupt.h>
  21 #include <linux/proc_fs.h>
  22 #include <linux/init.h>
  23
  24 #include <asm/system.h>
  25 #include <asm/pgtable.h>
  26 #include <asm/uaccess.h> //FIXME this header may be bogusly included
  27
  28 #include "fault.h"
  29
  30 #define FAULT_CODE_LDRSTRPOST   0x80
  31 #define FAULT_CODE_LDRSTRPRE    0x40
  32 #define FAULT_CODE_LDRSTRREG    0x20
  33 #define FAULT_CODE_LDMSTM       0x10
  34 #define FAULT_CODE_LDCSTC       0x08
  35 #define FAULT_CODE_PREFETCH     0x04
  36 #define FAULT_CODE_WRITE        0x02
  37 #define FAULT_CODE_FORCECOW     0x01
  38
  39 #define DO_COW(m)               ((m) & (FAULT_CODE_WRITE|FAULT_CODE_FORCECOW))
  40 #define READ_FAULT(m)           (!((m) & FAULT_CODE_WRITE))
  41 #define DEBUG
  42 /*
  43  * This is useful to dump out the page tables associated with
  44  * 'addr' in mm 'mm'.
  45  */
  46 void show_pte(struct mm_struct *mm, unsigned long addr)
  47 {
  48         pgd_t *pgd;
  49
  50         if (!mm)
  51                 mm = &init_mm;
  52
  53         printk(KERN_ALERT "pgd = %p\n", mm->pgd);
  54         pgd = pgd_offset(mm, addr);
  55         printk(KERN_ALERT "[%08lx] *pgd=%08lx", addr, pgd_val(*pgd));
  56
  57         do {
  58                 pmd_t *pmd;
  59                 pte_t *pte;
  60
  61                 pmd = pmd_offset(pgd, addr);
  62
  63                 if (pmd_none(*pmd))
  64                         break;
  65
  66                 if (pmd_bad(*pmd)) {
  67                         printk("(bad)");
  68                         break;
  69                 }
  70
  71                 /* We must not map this if we have highmem enabled */
  72                 /* FIXME */
  73                 pte = pte_offset_map(pmd, addr);
  74                 printk(", *pte=%08lx", pte_val(*pte));
  75                 pte_unmap(pte);
  76         } while(0);
  77
  78         printk("\n");
  79 }
  80
  81 /*
  82  * Oops.  The kernel tried to access some page that wasn't present.
  83  */
  84 static void
  85 __do_kernel_fault(struct mm_struct *mm, unsigned long addr, unsigned int fsr,
  86                   struct pt_regs *regs)
  87 {
  88         /*
  89          * Are we prepared to handle this kernel fault?
  90          */
  91         if (fixup_exception(regs))
  92                 return;
  93
  94         /*
  95          * No handler, we'll have to terminate things with extreme prejudice.
  96          */
  97         bust_spinlocks(1);
  98         printk(KERN_ALERT
  99                 "Unable to handle kernel %s at virtual address %08lx\n",
 100                 (addr < PAGE_SIZE) ? "NULL pointer dereference" :
 101                 "paging request", addr);
 102
 103         show_pte(mm, addr);
 104         die("Oops", regs, fsr);
 105         bust_spinlocks(0);
 106         do_exit(SIGKILL);
 107 }
 108
 109 /*
 110  * Something tried to access memory that isn't in our memory map..
 111  * User mode accesses just cause a SIGSEGV
 112  */
 113 static void
 114 __do_user_fault(struct task_struct *tsk, unsigned long addr,
 115                 unsigned int fsr, int code, struct pt_regs *regs)
 116 {
 117         struct siginfo si;
 118
 119 #ifdef CONFIG_DEBUG_USER
 120         printk("%s: unhandled page fault at 0x%08lx, code 0x%03x\n",
 121                tsk->comm, addr, fsr);
 122         show_pte(tsk->mm, addr);
 123         show_regs(regs);
 124         //dump_backtrace(regs, tsk); // FIXME ARM32 dropped this - why?
 125         while(1); //FIXME - hack to stop debug going nutso
 126 #endif
 127
 128         tsk->thread.address = addr;
 129         tsk->thread.error_code = fsr;
 130         tsk->thread.trap_no = 14;
 131         si.si_signo = SIGSEGV;
 132         si.si_errno = 0;
 133         si.si_code = code;
 134         si.si_addr = (void *)addr;
 135         force_sig_info(SIGSEGV, &si, tsk);
 136 }
 137
 138 static int
 139 __do_page_fault(struct mm_struct *mm, unsigned long addr, unsigned int fsr,
 140                 struct task_struct *tsk)
 141 {
 142         struct vm_area_struct *vma;
 143         int fault, mask;
 144
 145         vma = find_vma(mm, addr);
 146         fault = -2; /* bad map area */
 147         if (!vma)
 148                 goto out;
 149         if (vma->vm_start > addr)
 150                 goto check_stack;
 151
 152         /*
 153          * Ok, we have a good vm_area for this
 154          * memory access, so we can handle it.
 155          */
 156 good_area:
 157         if (READ_FAULT(fsr)) /* read? */
 158                 mask = VM_READ|VM_EXEC|VM_WRITE;
 159         else
 160                 mask = VM_WRITE;
 161
 162         fault = -1; /* bad access type */
 163         if (!(vma->vm_flags & mask))
 164                 goto out;
 165
 166         /*
 167          * If for any reason at all we couldn't handle
 168          * the fault, make sure we exit gracefully rather
 169          * than endlessly redo the fault.
 170          */
 171 survive:
 172         fault = handle_mm_fault(mm, vma, addr & PAGE_MASK, DO_COW(fsr));
 173         if (unlikely(fault & VM_FAULT_ERROR)) {
 174                 if (fault & VM_FAULT_OOM)
 175                         goto out_of_memory;
 176                 else if (fault & VM_FAULT_SIGBUS)
 177                         return fault;
 178                 BUG();
 179         }
 180         if (fault & VM_FAULT_MAJOR)
 181                 tsk->maj_flt++;
 182         else
 183                 tsk->min_flt++;
 184         return fault;
 185
 186 out_of_memory:
 187         fault = -3; /* out of memory */
 188         if (!is_init(tsk))
 189                 goto out;
 190
 191         /*
 192          * If we are out of memory for pid1,
 193          * sleep for a while and retry
 194          */
 195         yield();
 196         goto survive;
 197
 198 check_stack:
 199         if (vma->vm_flags & VM_GROWSDOWN && !expand_stack(vma, addr))
 200                 goto good_area;
 201 out:
 202         return fault;
 203 }
 204
 205 int do_page_fault(unsigned long addr, unsigned int fsr, struct pt_regs *regs)
 206 {
 207         struct task_struct *tsk;
 208         struct mm_struct *mm;
 209         int fault;
 210
 211         tsk = current;
 212         mm  = tsk->mm;
 213
 214         /*
 215          * If we're in an interrupt or have no user
 216          * context, we must not take the fault..
 217          */
 218         if (in_atomic() || !mm)
 219                 goto no_context;
 220
 221         down_read(&mm->mmap_sem);
 222         fault = __do_page_fault(mm, addr, fsr, tsk);
 223         up_read(&mm->mmap_sem);
 224
 225         /*
 226          * Handle the "normal" case first
 227          */
 228         if (likely(!(fault & VM_FAULT_ERROR)))
 229                 return 0;
 230         if (fault & VM_FAULT_SIGBUS)
 231                 goto do_sigbus;
 232         /* else VM_FAULT_OOM */
 233
 234         /*
 235          * If we are in kernel mode at this point, we
 236          * have no context to handle this fault with.
 237          * FIXME - is this test right?
 238          */
 239         if (!user_mode(regs)){
 240                 goto no_context;
 241         }
 242
 243         if (fault == -3) {
 244                 /*
 245                  * We ran out of memory, or some other thing happened to
 246                  * us that made us unable to handle the page fault gracefully.
 247                  */
 248                 printk("VM: killing process %s\n", tsk->comm);
 249                 do_exit(SIGKILL);
 250         }
 251         else{
 252                 __do_user_fault(tsk, addr, fsr, fault == -1 ? SEGV_ACCERR : SEGV_MAPERR, regs);
 253         }
 254
 255         return 0;
 256
 257
 258 /*
 259  * We ran out of memory, or some other thing happened to us that made
 260  * us unable to handle the page fault gracefully.
 261  */
 262 do_sigbus:
 263         /*
 264          * Send a sigbus, regardless of whether we were in kernel
 265          * or user mode.
 266          */
 267         tsk->thread.address = addr;  //FIXME - need other bits setting?
 268         tsk->thread.error_code = fsr;
 269         tsk->thread.trap_no = 14;
 270         force_sig(SIGBUS, tsk);
 271 #ifdef CONFIG_DEBUG_USER
 272         printk(KERN_DEBUG "%s: sigbus at 0x%08lx, pc=0x%08lx\n",
 273                 current->comm, addr, instruction_pointer(regs));
 274 #endif
 275
 276         /* Kernel mode? Handle exceptions or die */
 277         if (user_mode(regs))
 278                 return 0;
 279
 280 no_context:
 281         __do_kernel_fault(mm, addr, fsr, regs);
 282         return 0;
 283 }
 284
 285 /*
 286  * Handle a data abort.  Note that we have to handle a range of addresses
 287  * on ARM2/3 for ldm.  If both pages are zero-mapped, then we have to force
 288  * a copy-on-write.  However, on the second page, we always force COW.
 289  */
 290 asmlinkage void
 291 do_DataAbort(unsigned long min_addr, unsigned long max_addr, int mode, struct pt_regs *regs)
 292 {
 293         do_page_fault(min_addr, mode, regs);
 294
 295         if ((min_addr ^ max_addr) >> PAGE_SHIFT){
 296                do_page_fault(max_addr, mode | FAULT_CODE_FORCECOW, regs);
 297         }
 298 }
 299
 300 asmlinkage int
 301 do_PrefetchAbort(unsigned long addr, struct pt_regs *regs)
 302 {
 303 #if 0
 304         if (the memc mapping for this page exists) {
 305                 printk ("Page in, but got abort (undefined instruction?)\n");
 306                 return 0;
 307         }
 308 #endif
 309         do_page_fault(addr, FAULT_CODE_PREFETCH, regs);
 310         return 1;
 311 }
 312