arch/hexagon/mm/vm_fault.c

   1 /*
   2  * Memory fault handling for Hexagon
   3  *
   4  * Copyright (c) 2010-2011 Code Aurora Forum. All rights reserved.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 and
   8  * only version 2 as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  18  * 02110-1301, USA.
  19  */
  20
  21 /*
  22  * Page fault handling for the Hexagon Virtual Machine.
  23  * Can also be called by a native port emulating the HVM
  24  * execptions.
  25  */
  26
  27 #include <asm/pgtable.h>
  28 #include <asm/traps.h>
  29 #include <asm/uaccess.h>
  30 #include <linux/mm.h>
  31 #include <linux/signal.h>
  32 #include <linux/module.h>
  33 #include <linux/hardirq.h>
  34
  35 /*
  36  * Decode of hardware exception sends us to one of several
  37  * entry points.  At each, we generate canonical arguments
  38  * for handling by the abstract memory management code.
  39  */
  40 #define FLT_IFETCH     -1
  41 #define FLT_LOAD        0
  42 #define FLT_STORE       1
  43
  44
  45 /*
  46  * Canonical page fault handler
  47  */
  48 void do_page_fault(unsigned long address, long cause, struct pt_regs *regs)
  49 {
  50         struct vm_area_struct *vma;
  51         struct mm_struct *mm = current->mm;
  52         siginfo_t info;
  53         int si_code = SEGV_MAPERR;
  54         int fault;
  55         const struct exception_table_entry *fixup;
  56         unsigned int flags = FAULT_FLAG_ALLOW_RETRY | FAULT_FLAG_KILLABLE |
  57                                  (cause > 0 ? FAULT_FLAG_WRITE : 0);
  58
  59         /*
  60          * If we're in an interrupt or have no user context,
  61          * then must not take the fault.
  62          */
  63         if (unlikely(in_interrupt() || !mm))
  64                 goto no_context;
  65
  66         local_irq_enable();
  67
  68 retry:
  69         down_read(&mm->mmap_sem);
  70         vma = find_vma(mm, address);
  71         if (!vma)
  72                 goto bad_area;
  73
  74         if (vma->vm_start <= address)
  75                 goto good_area;
  76
  77         if (!(vma->vm_flags & VM_GROWSDOWN))
  78                 goto bad_area;
  79
  80         if (expand_stack(vma, address))
  81                 goto bad_area;
  82
  83 good_area:
  84         /* Address space is OK.  Now check access rights. */
  85         si_code = SEGV_ACCERR;
  86
  87         switch (cause) {
  88         case FLT_IFETCH:
  89                 if (!(vma->vm_flags & VM_EXEC))
  90                         goto bad_area;
  91                 break;
  92         case FLT_LOAD:
  93                 if (!(vma->vm_flags & VM_READ))
  94                         goto bad_area;
  95                 break;
  96         case FLT_STORE:
  97                 if (!(vma->vm_flags & VM_WRITE))
  98                         goto bad_area;
  99                 break;
 100         }
 101
 102         fault = handle_mm_fault(mm, vma, address, flags);
 103
 104         if ((fault & VM_FAULT_RETRY) && fatal_signal_pending(current))
 105                 return;
 106
 107         /* The most common case -- we are done. */
 108         if (likely(!(fault & VM_FAULT_ERROR))) {
 109                 if (flags & FAULT_FLAG_ALLOW_RETRY) {
 110                         if (fault & VM_FAULT_MAJOR)
 111                                 current->maj_flt++;
 112                         else
 113                                 current->min_flt++;
 114                         if (fault & VM_FAULT_RETRY) {
 115                                 flags &= ~FAULT_FLAG_ALLOW_RETRY;
 116                                 goto retry;
 117                         }
 118                 }
 119
 120                 up_read(&mm->mmap_sem);
 121                 return;
 122         }
 123
 124         up_read(&mm->mmap_sem);
 125
 126         /* Handle copyin/out exception cases */
 127         if (!user_mode(regs))
 128                 goto no_context;
 129
 130         if (fault & VM_FAULT_OOM) {
 131                 pagefault_out_of_memory();
 132                 return;
 133         }
 134
 135         /* User-mode address is in the memory map, but we are
 136          * unable to fix up the page fault.
 137          */
 138         if (fault & VM_FAULT_SIGBUS) {
 139                 info.si_signo = SIGBUS;
 140                 info.si_code = BUS_ADRERR;
 141         }
 142         /* Address is not in the memory map */
 143         else {
 144                 info.si_signo = SIGSEGV;
 145                 info.si_code = SEGV_ACCERR;
 146         }
 147         info.si_errno = 0;
 148         info.si_addr = (void __user *)address;
 149         force_sig_info(info.si_code, &info, current);
 150         return;
 151
 152 bad_area:
 153         up_read(&mm->mmap_sem);
 154
 155         if (user_mode(regs)) {
 156                 info.si_signo = SIGSEGV;
 157                 info.si_errno = 0;
 158                 info.si_code = si_code;
 159                 info.si_addr = (void *)address;
 160                 force_sig_info(SIGSEGV, &info, current);
 161                 return;
 162         }
 163         /* Kernel-mode fault falls through */
 164
 165 no_context:
 166         fixup = search_exception_tables(pt_elr(regs));
 167         if (fixup) {
 168                 pt_set_elr(regs, fixup->fixup);
 169                 return;
 170         }
 171
 172         /* Things are looking very, very bad now */
 173         bust_spinlocks(1);
 174         printk(KERN_EMERG "Unable to handle kernel paging request at "
 175                 "virtual address 0x%08lx, regs %p\n", address, regs);
 176         die("Bad Kernel VA", regs, SIGKILL);
 177 }
 178
 179
 180 void read_protection_fault(struct pt_regs *regs)
 181 {
 182         unsigned long badvadr = pt_badva(regs);
 183
 184         do_page_fault(badvadr, FLT_LOAD, regs);
 185 }
 186
 187 void write_protection_fault(struct pt_regs *regs)
 188 {
 189         unsigned long badvadr = pt_badva(regs);
 190
 191         do_page_fault(badvadr, FLT_STORE, regs);
 192 }
 193
 194 void execute_protection_fault(struct pt_regs *regs)
 195 {
 196         unsigned long badvadr = pt_badva(regs);
 197
 198         do_page_fault(badvadr, FLT_IFETCH, regs);
 199 }