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
  57         /*
  58          * If we're in an interrupt or have no user context,
  59          * then must not take the fault.
  60          */
  61         if (unlikely(in_interrupt() || !mm))
  62                 goto no_context;
  63
  64         local_irq_enable();
  65
  66         down_read(&mm->mmap_sem);
  67         vma = find_vma(mm, address);
  68         if (!vma)
  69                 goto bad_area;
  70
  71         if (vma->vm_start <= address)
  72                 goto good_area;
  73
  74         if (!(vma->vm_flags & VM_GROWSDOWN))
  75                 goto bad_area;
  76
  77         if (expand_stack(vma, address))
  78                 goto bad_area;
  79
  80 good_area:
  81         /* Address space is OK.  Now check access rights. */
  82         si_code = SEGV_ACCERR;
  83
  84         switch (cause) {
  85         case FLT_IFETCH:
  86                 if (!(vma->vm_flags & VM_EXEC))
  87                         goto bad_area;
  88                 break;
  89         case FLT_LOAD:
  90                 if (!(vma->vm_flags & VM_READ))
  91                         goto bad_area;
  92                 break;
  93         case FLT_STORE:
  94                 if (!(vma->vm_flags & VM_WRITE))
  95                         goto bad_area;
  96                 break;
  97         }
  98
  99         fault = handle_mm_fault(mm, vma, address, (cause > 0));
 100
 101         /* The most common case -- we are done. */
 102         if (likely(!(fault & VM_FAULT_ERROR))) {
 103                 if (fault & VM_FAULT_MAJOR)
 104                         current->maj_flt++;
 105                 else
 106                         current->min_flt++;
 107
 108                 up_read(&mm->mmap_sem);
 109                 return;
 110         }
 111
 112         up_read(&mm->mmap_sem);
 113
 114         /* Handle copyin/out exception cases */
 115         if (!user_mode(regs))
 116                 goto no_context;
 117
 118         if (fault & VM_FAULT_OOM) {
 119                 pagefault_out_of_memory();
 120                 return;
 121         }
 122
 123         /* User-mode address is in the memory map, but we are
 124          * unable to fix up the page fault.
 125          */
 126         if (fault & VM_FAULT_SIGBUS) {
 127                 info.si_signo = SIGBUS;
 128                 info.si_code = BUS_ADRERR;
 129         }
 130         /* Address is not in the memory map */
 131         else {
 132                 info.si_signo = SIGSEGV;
 133                 info.si_code = SEGV_ACCERR;
 134         }
 135         info.si_errno = 0;
 136         info.si_addr = (void __user *)address;
 137         force_sig_info(info.si_code, &info, current);
 138         return;
 139
 140 bad_area:
 141         up_read(&mm->mmap_sem);
 142
 143         if (user_mode(regs)) {
 144                 info.si_signo = SIGSEGV;
 145                 info.si_errno = 0;
 146                 info.si_code = si_code;
 147                 info.si_addr = (void *)address;
 148                 force_sig_info(SIGSEGV, &info, current);
 149                 return;
 150         }
 151         /* Kernel-mode fault falls through */
 152
 153 no_context:
 154         fixup = search_exception_tables(pt_elr(regs));
 155         if (fixup) {
 156                 pt_set_elr(regs, fixup->fixup);
 157                 return;
 158         }
 159
 160         /* Things are looking very, very bad now */
 161         bust_spinlocks(1);
 162         printk(KERN_EMERG "Unable to handle kernel paging request at "
 163                 "virtual address 0x%08lx, regs %p\n", address, regs);
 164         die("Bad Kernel VA", regs, SIGKILL);
 165 }
 166
 167
 168 void read_protection_fault(struct pt_regs *regs)
 169 {
 170         unsigned long badvadr = pt_badva(regs);
 171
 172         do_page_fault(badvadr, FLT_LOAD, regs);
 173 }
 174
 175 void write_protection_fault(struct pt_regs *regs)
 176 {
 177         unsigned long badvadr = pt_badva(regs);
 178
 179         do_page_fault(badvadr, FLT_STORE, regs);
 180 }
 181
 182 void execute_protection_fault(struct pt_regs *regs)
 183 {
 184         unsigned long badvadr = pt_badva(regs);
 185
 186         do_page_fault(badvadr, FLT_IFETCH, regs);
 187 }