~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/microblaze/mm/fault.c

Version: ~ [ linux-5.9-rc5 ] ~ [ linux-5.8.10 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.66 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.146 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.198 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.236 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.236 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  *  arch/microblaze/mm/fault.c
  3  *
  4  *    Copyright (C) 2007 Xilinx, Inc.  All rights reserved.
  5  *
  6  *  Derived from "arch/ppc/mm/fault.c"
  7  *    Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
  8  *
  9  *  Derived from "arch/i386/mm/fault.c"
 10  *    Copyright (C) 1991, 1992, 1993, 1994  Linus Torvalds
 11  *
 12  *  Modified by Cort Dougan and Paul Mackerras.
 13  *
 14  * This file is subject to the terms and conditions of the GNU General
 15  * Public License.  See the file COPYING in the main directory of this
 16  * archive for more details.
 17  *
 18  */
 19 
 20 #include <linux/module.h>
 21 #include <linux/signal.h>
 22 #include <linux/sched.h>
 23 #include <linux/kernel.h>
 24 #include <linux/errno.h>
 25 #include <linux/string.h>
 26 #include <linux/types.h>
 27 #include <linux/ptrace.h>
 28 #include <linux/mman.h>
 29 #include <linux/mm.h>
 30 #include <linux/interrupt.h>
 31 
 32 #include <asm/page.h>
 33 #include <asm/pgtable.h>
 34 #include <asm/mmu.h>
 35 #include <linux/mmu_context.h>
 36 #include <linux/uaccess.h>
 37 #include <asm/exceptions.h>
 38 
 39 static unsigned long pte_misses;        /* updated by do_page_fault() */
 40 static unsigned long pte_errors;        /* updated by do_page_fault() */
 41 
 42 /*
 43  * Check whether the instruction at regs->pc is a store using
 44  * an update addressing form which will update r1.
 45  */
 46 static int store_updates_sp(struct pt_regs *regs)
 47 {
 48         unsigned int inst;
 49 
 50         if (get_user(inst, (unsigned int __user *)regs->pc))
 51                 return 0;
 52         /* check for 1 in the rD field */
 53         if (((inst >> 21) & 0x1f) != 1)
 54                 return 0;
 55         /* check for store opcodes */
 56         if ((inst & 0xd0000000) == 0xd0000000)
 57                 return 1;
 58         return 0;
 59 }
 60 
 61 
 62 /*
 63  * bad_page_fault is called when we have a bad access from the kernel.
 64  * It is called from do_page_fault above and from some of the procedures
 65  * in traps.c.
 66  */
 67 void bad_page_fault(struct pt_regs *regs, unsigned long address, int sig)
 68 {
 69         const struct exception_table_entry *fixup;
 70 /* MS: no context */
 71         /* Are we prepared to handle this fault?  */
 72         fixup = search_exception_tables(regs->pc);
 73         if (fixup) {
 74                 regs->pc = fixup->fixup;
 75                 return;
 76         }
 77 
 78         /* kernel has accessed a bad area */
 79         die("kernel access of bad area", regs, sig);
 80 }
 81 
 82 /*
 83  * The error_code parameter is ESR for a data fault,
 84  * 0 for an instruction fault.
 85  */
 86 void do_page_fault(struct pt_regs *regs, unsigned long address,
 87                    unsigned long error_code)
 88 {
 89         struct vm_area_struct *vma;
 90         struct mm_struct *mm = current->mm;
 91         siginfo_t info;
 92         int code = SEGV_MAPERR;
 93         int is_write = error_code & ESR_S;
 94         int fault;
 95         unsigned int flags = FAULT_FLAG_ALLOW_RETRY | FAULT_FLAG_KILLABLE;
 96 
 97         regs->ear = address;
 98         regs->esr = error_code;
 99 
100         /* On a kernel SLB miss we can only check for a valid exception entry */
101         if (unlikely(kernel_mode(regs) && (address >= TASK_SIZE))) {
102                 pr_warn("kernel task_size exceed");
103                 _exception(SIGSEGV, regs, code, address);
104         }
105 
106         /* for instr TLB miss and instr storage exception ESR_S is undefined */
107         if ((error_code & 0x13) == 0x13 || (error_code & 0x11) == 0x11)
108                 is_write = 0;
109 
110         if (unlikely(faulthandler_disabled() || !mm)) {
111                 if (kernel_mode(regs))
112                         goto bad_area_nosemaphore;
113 
114                 /* faulthandler_disabled() in user mode is really bad,
115                    as is current->mm == NULL. */
116                 pr_emerg("Page fault in user mode with faulthandler_disabled(), mm = %p\n",
117                          mm);
118                 pr_emerg("r15 = %lx  MSR = %lx\n",
119                        regs->r15, regs->msr);
120                 die("Weird page fault", regs, SIGSEGV);
121         }
122 
123         if (user_mode(regs))
124                 flags |= FAULT_FLAG_USER;
125 
126         /* When running in the kernel we expect faults to occur only to
127          * addresses in user space.  All other faults represent errors in the
128          * kernel and should generate an OOPS.  Unfortunately, in the case of an
129          * erroneous fault occurring in a code path which already holds mmap_sem
130          * we will deadlock attempting to validate the fault against the
131          * address space.  Luckily the kernel only validly references user
132          * space from well defined areas of code, which are listed in the
133          * exceptions table.
134          *
135          * As the vast majority of faults will be valid we will only perform
136          * the source reference check when there is a possibility of a deadlock.
137          * Attempt to lock the address space, if we cannot we then validate the
138          * source.  If this is invalid we can skip the address space check,
139          * thus avoiding the deadlock.
140          */
141         if (unlikely(!down_read_trylock(&mm->mmap_sem))) {
142                 if (kernel_mode(regs) && !search_exception_tables(regs->pc))
143                         goto bad_area_nosemaphore;
144 
145 retry:
146                 down_read(&mm->mmap_sem);
147         }
148 
149         vma = find_vma(mm, address);
150         if (unlikely(!vma))
151                 goto bad_area;
152 
153         if (vma->vm_start <= address)
154                 goto good_area;
155 
156         if (unlikely(!(vma->vm_flags & VM_GROWSDOWN)))
157                 goto bad_area;
158 
159         if (unlikely(!is_write))
160                 goto bad_area;
161 
162         /*
163          * N.B. The ABI allows programs to access up to
164          * a few hundred bytes below the stack pointer (TBD).
165          * The kernel signal delivery code writes up to about 1.5kB
166          * below the stack pointer (r1) before decrementing it.
167          * The exec code can write slightly over 640kB to the stack
168          * before setting the user r1.  Thus we allow the stack to
169          * expand to 1MB without further checks.
170          */
171         if (unlikely(address + 0x100000 < vma->vm_end)) {
172 
173                 /* get user regs even if this fault is in kernel mode */
174                 struct pt_regs *uregs = current->thread.regs;
175                 if (uregs == NULL)
176                         goto bad_area;
177 
178                 /*
179                  * A user-mode access to an address a long way below
180                  * the stack pointer is only valid if the instruction
181                  * is one which would update the stack pointer to the
182                  * address accessed if the instruction completed,
183                  * i.e. either stwu rs,n(r1) or stwux rs,r1,rb
184                  * (or the byte, halfword, float or double forms).
185                  *
186                  * If we don't check this then any write to the area
187                  * between the last mapped region and the stack will
188                  * expand the stack rather than segfaulting.
189                  */
190                 if (address + 2048 < uregs->r1
191                         && (kernel_mode(regs) || !store_updates_sp(regs)))
192                                 goto bad_area;
193         }
194         if (expand_stack(vma, address))
195                 goto bad_area;
196 
197 good_area:
198         code = SEGV_ACCERR;
199 
200         /* a write */
201         if (unlikely(is_write)) {
202                 if (unlikely(!(vma->vm_flags & VM_WRITE)))
203                         goto bad_area;
204                 flags |= FAULT_FLAG_WRITE;
205         /* a read */
206         } else {
207                 /* protection fault */
208                 if (unlikely(error_code & 0x08000000))
209                         goto bad_area;
210                 if (unlikely(!(vma->vm_flags & (VM_READ | VM_EXEC))))
211                         goto bad_area;
212         }
213 
214         /*
215          * If for any reason at all we couldn't handle the fault,
216          * make sure we exit gracefully rather than endlessly redo
217          * the fault.
218          */
219         fault = handle_mm_fault(mm, vma, address, flags);
220 
221         if ((fault & VM_FAULT_RETRY) && fatal_signal_pending(current))
222                 return;
223 
224         if (unlikely(fault & VM_FAULT_ERROR)) {
225                 if (fault & VM_FAULT_OOM)
226                         goto out_of_memory;
227                 else if (fault & VM_FAULT_SIGSEGV)
228                         goto bad_area;
229                 else if (fault & VM_FAULT_SIGBUS)
230                         goto do_sigbus;
231                 BUG();
232         }
233 
234         if (flags & FAULT_FLAG_ALLOW_RETRY) {
235                 if (unlikely(fault & VM_FAULT_MAJOR))
236                         current->maj_flt++;
237                 else
238                         current->min_flt++;
239                 if (fault & VM_FAULT_RETRY) {
240                         flags &= ~FAULT_FLAG_ALLOW_RETRY;
241                         flags |= FAULT_FLAG_TRIED;
242 
243                         /*
244                          * No need to up_read(&mm->mmap_sem) as we would
245                          * have already released it in __lock_page_or_retry
246                          * in mm/filemap.c.
247                          */
248 
249                         goto retry;
250                 }
251         }
252 
253         up_read(&mm->mmap_sem);
254 
255         /*
256          * keep track of tlb+htab misses that are good addrs but
257          * just need pte's created via handle_mm_fault()
258          * -- Cort
259          */
260         pte_misses++;
261         return;
262 
263 bad_area:
264         up_read(&mm->mmap_sem);
265 
266 bad_area_nosemaphore:
267         pte_errors++;
268 
269         /* User mode accesses cause a SIGSEGV */
270         if (user_mode(regs)) {
271                 _exception(SIGSEGV, regs, code, address);
272 /*              info.si_signo = SIGSEGV;
273                 info.si_errno = 0;
274                 info.si_code = code;
275                 info.si_addr = (void *) address;
276                 force_sig_info(SIGSEGV, &info, current);*/
277                 return;
278         }
279 
280         bad_page_fault(regs, address, SIGSEGV);
281         return;
282 
283 /*
284  * We ran out of memory, or some other thing happened to us that made
285  * us unable to handle the page fault gracefully.
286  */
287 out_of_memory:
288         up_read(&mm->mmap_sem);
289         if (!user_mode(regs))
290                 bad_page_fault(regs, address, SIGKILL);
291         else
292                 pagefault_out_of_memory();
293         return;
294 
295 do_sigbus:
296         up_read(&mm->mmap_sem);
297         if (user_mode(regs)) {
298                 info.si_signo = SIGBUS;
299                 info.si_errno = 0;
300                 info.si_code = BUS_ADRERR;
301                 info.si_addr = (void __user *)address;
302                 force_sig_info(SIGBUS, &info, current);
303                 return;
304         }
305         bad_page_fault(regs, address, SIGBUS);
306 }
307 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp