arch/m68k/mm/fault.c

   1 /*
   2  *  linux/arch/m68k/mm/fault.c
   3  *
   4  *  Copyright (C) 1995  Hamish Macdonald
   5  */
   6
   7 #include <linux/mman.h>
   8 #include <linux/mm.h>
   9 #include <linux/kernel.h>
  10 #include <linux/ptrace.h>
  11 #include <linux/interrupt.h>
  12
  13 #include <asm/setup.h>
  14 #include <asm/traps.h>
  15 #include <asm/system.h>
  16 #include <asm/uaccess.h>
  17 #include <asm/pgalloc.h>
  18
  19 extern void die_if_kernel(char *, struct pt_regs *, long);
  20 extern const int frame_extra_sizes[]; /* in m68k/kernel/signal.c */
  21
  22 /*
  23  * This routine handles page faults.  It determines the problem, and
  24  * then passes it off to one of the appropriate routines.
  25  *
  26  * error_code:
  27  *      bit 0 == 0 means no page found, 1 means protection fault
  28  *      bit 1 == 0 means read, 1 means write
  29  *
  30  * If this routine detects a bad access, it returns 1, otherwise it
  31  * returns 0.
  32  */
  33 asmlinkage int do_page_fault(struct pt_regs *regs, unsigned long address,
  34                               unsigned long error_code)
  35 {
  36         struct mm_struct *mm = current->mm;
  37         struct vm_area_struct * vma;
  38         unsigned long fixup;
  39         int write, fault;
  40
  41 #ifdef DEBUG
  42         printk ("regs->sr=%#x, regs->pc=%#lx, address=%#lx, %ld, %p\n",
  43                 regs->sr, regs->pc, address, error_code,
  44                 current->mm->pgd);
  45 #endif
  46
  47         /*
  48          * If we're in an interrupt or have no user
  49          * context, we must not take the fault..
  50          */
  51         if (in_interrupt() || !mm)
  52                 goto no_context;
  53
  54         down(&mm->mmap_sem);
  55
  56         vma = find_vma(mm, address);
  57         if (!vma)
  58                 goto bad_area;
  59         if (vma->vm_flags & VM_IO)
  60                 goto bad_area;
  61         if (vma->vm_start <= address)
  62                 goto good_area;
  63         if (!(vma->vm_flags & VM_GROWSDOWN))
  64                 goto bad_area;
  65         if (user_mode(regs)) {
  66                 /* Accessing the stack below usp is always a bug.  The
  67                    "+ 256" is there due to some instructions doing
  68                    pre-decrement on the stack and that doesn't show up
  69                    until later.  */
  70                 if (address + 256 < rdusp())
  71                         goto bad_area;
  72         }
  73         if (expand_stack(vma, address))
  74                 goto bad_area;
  75
  76 /*
  77  * Ok, we have a good vm_area for this memory access, so
  78  * we can handle it..
  79  */
  80 good_area:
  81         write = 0;
  82         switch (error_code & 3) {
  83                 default:        /* 3: write, present */
  84                         /* fall through */
  85                 case 2:         /* write, not present */
  86                         if (!(vma->vm_flags & VM_WRITE))
  87                                 goto bad_area;
  88                         write++;
  89                         break;
  90                 case 1:         /* read, present */
  91                         goto bad_area;
  92                 case 0:         /* read, not present */
  93                         if (!(vma->vm_flags & (VM_READ | VM_EXEC)))
  94                                 goto bad_area;
  95         }
  96
  97         /*
  98          * If for any reason at all we couldn't handle the fault,
  99          * make sure we exit gracefully rather than endlessly redo
 100          * the fault.
 101          */
 102         fault = handle_mm_fault(current, vma, address, write);
 103         if (fault < 0)
 104                 goto out_of_memory;
 105         if (!fault)
 106                 goto do_sigbus;
 107
 108         /* There seems to be a missing invalidate somewhere in do_no_page.
 109          * Until I found it, this one cures the problem and makes
 110          * 1.2 run on the 68040 (Martin Apel).
 111          */
 112         if (CPU_IS_040_OR_060)
 113                 flush_tlb_page(vma, address);
 114         up(&mm->mmap_sem);
 115         return 0;
 116
 117 /*
 118  * Something tried to access memory that isn't in our memory map..
 119  * Fix it, but check if it's kernel or user first..
 120  */
 121 bad_area:
 122         up(&mm->mmap_sem);
 123
 124         /* User mode accesses just cause a SIGSEGV */
 125         if (user_mode(regs)) {
 126                 siginfo_t info;
 127                 info.si_signo = SIGSEGV;
 128                 info.si_code = SEGV_MAPERR;
 129                 info.si_addr = (void *)address;
 130                 force_sig_info(SIGSEGV, &info, current);
 131                 return 1;
 132         }
 133
 134 no_context:
 135         /* Are we prepared to handle this kernel fault?  */
 136         if ((fixup = search_exception_table(regs->pc)) != 0) {
 137                 struct pt_regs *tregs;
 138                 /* Create a new four word stack frame, discarding the old
 139                    one.  */
 140                 regs->stkadj = frame_extra_sizes[regs->format];
 141                 tregs = (struct pt_regs *)((ulong)regs + regs->stkadj);
 142                 tregs->vector = regs->vector;
 143                 tregs->format = 0;
 144                 tregs->pc = fixup;
 145                 tregs->sr = regs->sr;
 146                 return -1;
 147         }
 148
 149 /*
 150  * Oops. The kernel tried to access some bad page. We'll have to
 151  * terminate things with extreme prejudice.
 152  */
 153         if ((unsigned long) address < PAGE_SIZE) {
 154                 printk(KERN_ALERT "Unable to handle kernel NULL pointer dereference");
 155         } else
 156                 printk(KERN_ALERT "Unable to handle kernel access");
 157         printk(" at virtual address %08lx\n",address);
 158         die_if_kernel("Oops", regs, error_code);
 159         do_exit(SIGKILL);
 160
 161 /*
 162  * We ran out of memory, or some other thing happened to us that made
 163  * us unable to handle the page fault gracefully.
 164  */
 165 out_of_memory:
 166         up(&mm->mmap_sem);
 167         printk("VM: killing process %s\n", current->comm);
 168         if (error_code & 4)
 169                 do_exit(SIGKILL);
 170         goto no_context;
 171
 172 do_sigbus:
 173         up(&mm->mmap_sem);
 174
 175         /*
 176          * Send a sigbus, regardless of whether we were in kernel
 177          * or user mode.
 178          */
 179         force_sig(SIGBUS, current);
 180
 181         /* Kernel mode? Handle exceptions or die */
 182         if (!user_mode(regs))
 183                 goto no_context;
 184
 185         return 1;
 186 }