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

TOMOYO Linux Cross Reference
Linux/arch/sparc/mm/fault_32.c

Version: ~ [ linux-5.13-rc1 ] ~ [ linux-5.12.2 ] ~ [ linux-5.11.19 ] ~ [ linux-5.10.35 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.117 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.190 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.232 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.268 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.268 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ 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 // SPDX-License-Identifier: GPL-2.0
  2 /*
  3  * fault.c:  Page fault handlers for the Sparc.
  4  *
  5  * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
  6  * Copyright (C) 1996 Eddie C. Dost (ecd@skynet.be)
  7  * Copyright (C) 1997 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
  8  */
  9 
 10 #include <asm/head.h>
 11 
 12 #include <linux/string.h>
 13 #include <linux/types.h>
 14 #include <linux/sched.h>
 15 #include <linux/ptrace.h>
 16 #include <linux/mman.h>
 17 #include <linux/threads.h>
 18 #include <linux/kernel.h>
 19 #include <linux/signal.h>
 20 #include <linux/mm.h>
 21 #include <linux/smp.h>
 22 #include <linux/perf_event.h>
 23 #include <linux/interrupt.h>
 24 #include <linux/kdebug.h>
 25 #include <linux/uaccess.h>
 26 
 27 #include <asm/page.h>
 28 #include <asm/openprom.h>
 29 #include <asm/oplib.h>
 30 #include <asm/setup.h>
 31 #include <asm/smp.h>
 32 #include <asm/traps.h>
 33 
 34 #include "mm_32.h"
 35 
 36 int show_unhandled_signals = 1;
 37 
 38 static void __noreturn unhandled_fault(unsigned long address,
 39                                        struct task_struct *tsk,
 40                                        struct pt_regs *regs)
 41 {
 42         if ((unsigned long) address < PAGE_SIZE) {
 43                 printk(KERN_ALERT
 44                     "Unable to handle kernel NULL pointer dereference\n");
 45         } else {
 46                 printk(KERN_ALERT "Unable to handle kernel paging request at virtual address %08lx\n",
 47                        address);
 48         }
 49         printk(KERN_ALERT "tsk->{mm,active_mm}->context = %08lx\n",
 50                 (tsk->mm ? tsk->mm->context : tsk->active_mm->context));
 51         printk(KERN_ALERT "tsk->{mm,active_mm}->pgd = %08lx\n",
 52                 (tsk->mm ? (unsigned long) tsk->mm->pgd :
 53                         (unsigned long) tsk->active_mm->pgd));
 54         die_if_kernel("Oops", regs);
 55 }
 56 
 57 asmlinkage int lookup_fault(unsigned long pc, unsigned long ret_pc,
 58                             unsigned long address)
 59 {
 60         struct pt_regs regs;
 61         unsigned long g2;
 62         unsigned int insn;
 63         int i;
 64 
 65         i = search_extables_range(ret_pc, &g2);
 66         switch (i) {
 67         case 3:
 68                 /* load & store will be handled by fixup */
 69                 return 3;
 70 
 71         case 1:
 72                 /* store will be handled by fixup, load will bump out */
 73                 /* for _to_ macros */
 74                 insn = *((unsigned int *) pc);
 75                 if ((insn >> 21) & 1)
 76                         return 1;
 77                 break;
 78 
 79         case 2:
 80                 /* load will be handled by fixup, store will bump out */
 81                 /* for _from_ macros */
 82                 insn = *((unsigned int *) pc);
 83                 if (!((insn >> 21) & 1) || ((insn>>19)&0x3f) == 15)
 84                         return 2;
 85                 break;
 86 
 87         default:
 88                 break;
 89         }
 90 
 91         memset(&regs, 0, sizeof(regs));
 92         regs.pc = pc;
 93         regs.npc = pc + 4;
 94         __asm__ __volatile__(
 95                 "rd %%psr, %0\n\t"
 96                 "nop\n\t"
 97                 "nop\n\t"
 98                 "nop\n" : "=r" (regs.psr));
 99         unhandled_fault(address, current, &regs);
100 
101         /* Not reached */
102         return 0;
103 }
104 
105 static inline void
106 show_signal_msg(struct pt_regs *regs, int sig, int code,
107                 unsigned long address, struct task_struct *tsk)
108 {
109         if (!unhandled_signal(tsk, sig))
110                 return;
111 
112         if (!printk_ratelimit())
113                 return;
114 
115         printk("%s%s[%d]: segfault at %lx ip %px (rpc %px) sp %px error %x",
116                task_pid_nr(tsk) > 1 ? KERN_INFO : KERN_EMERG,
117                tsk->comm, task_pid_nr(tsk), address,
118                (void *)regs->pc, (void *)regs->u_regs[UREG_I7],
119                (void *)regs->u_regs[UREG_FP], code);
120 
121         print_vma_addr(KERN_CONT " in ", regs->pc);
122 
123         printk(KERN_CONT "\n");
124 }
125 
126 static void __do_fault_siginfo(int code, int sig, struct pt_regs *regs,
127                                unsigned long addr)
128 {
129         if (unlikely(show_unhandled_signals))
130                 show_signal_msg(regs, sig, code,
131                                 addr, current);
132 
133         force_sig_fault(sig, code, (void __user *) addr, 0);
134 }
135 
136 static unsigned long compute_si_addr(struct pt_regs *regs, int text_fault)
137 {
138         unsigned int insn;
139 
140         if (text_fault)
141                 return regs->pc;
142 
143         if (regs->psr & PSR_PS)
144                 insn = *(unsigned int *) regs->pc;
145         else
146                 __get_user(insn, (unsigned int *) regs->pc);
147 
148         return safe_compute_effective_address(regs, insn);
149 }
150 
151 static noinline void do_fault_siginfo(int code, int sig, struct pt_regs *regs,
152                                       int text_fault)
153 {
154         unsigned long addr = compute_si_addr(regs, text_fault);
155 
156         __do_fault_siginfo(code, sig, regs, addr);
157 }
158 
159 asmlinkage void do_sparc_fault(struct pt_regs *regs, int text_fault, int write,
160                                unsigned long address)
161 {
162         struct vm_area_struct *vma;
163         struct task_struct *tsk = current;
164         struct mm_struct *mm = tsk->mm;
165         unsigned int fixup;
166         unsigned long g2;
167         int from_user = !(regs->psr & PSR_PS);
168         int code;
169         vm_fault_t fault;
170         unsigned int flags = FAULT_FLAG_DEFAULT;
171 
172         if (text_fault)
173                 address = regs->pc;
174 
175         /*
176          * We fault-in kernel-space virtual memory on-demand. The
177          * 'reference' page table is init_mm.pgd.
178          *
179          * NOTE! We MUST NOT take any locks for this case. We may
180          * be in an interrupt or a critical region, and should
181          * only copy the information from the master page table,
182          * nothing more.
183          */
184         code = SEGV_MAPERR;
185         if (address >= TASK_SIZE)
186                 goto vmalloc_fault;
187 
188         /*
189          * If we're in an interrupt or have no user
190          * context, we must not take the fault..
191          */
192         if (pagefault_disabled() || !mm)
193                 goto no_context;
194 
195         perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS, 1, regs, address);
196 
197 retry:
198         mmap_read_lock(mm);
199 
200         if (!from_user && address >= PAGE_OFFSET)
201                 goto bad_area;
202 
203         vma = find_vma(mm, address);
204         if (!vma)
205                 goto bad_area;
206         if (vma->vm_start <= address)
207                 goto good_area;
208         if (!(vma->vm_flags & VM_GROWSDOWN))
209                 goto bad_area;
210         if (expand_stack(vma, address))
211                 goto bad_area;
212         /*
213          * Ok, we have a good vm_area for this memory access, so
214          * we can handle it..
215          */
216 good_area:
217         code = SEGV_ACCERR;
218         if (write) {
219                 if (!(vma->vm_flags & VM_WRITE))
220                         goto bad_area;
221         } else {
222                 /* Allow reads even for write-only mappings */
223                 if (!(vma->vm_flags & (VM_READ | VM_EXEC)))
224                         goto bad_area;
225         }
226 
227         if (from_user)
228                 flags |= FAULT_FLAG_USER;
229         if (write)
230                 flags |= FAULT_FLAG_WRITE;
231 
232         /*
233          * If for any reason at all we couldn't handle the fault,
234          * make sure we exit gracefully rather than endlessly redo
235          * the fault.
236          */
237         fault = handle_mm_fault(vma, address, flags);
238 
239         if (fault_signal_pending(fault, regs))
240                 return;
241 
242         if (unlikely(fault & VM_FAULT_ERROR)) {
243                 if (fault & VM_FAULT_OOM)
244                         goto out_of_memory;
245                 else if (fault & VM_FAULT_SIGSEGV)
246                         goto bad_area;
247                 else if (fault & VM_FAULT_SIGBUS)
248                         goto do_sigbus;
249                 BUG();
250         }
251 
252         if (flags & FAULT_FLAG_ALLOW_RETRY) {
253                 if (fault & VM_FAULT_MAJOR) {
254                         current->maj_flt++;
255                         perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MAJ,
256                                       1, regs, address);
257                 } else {
258                         current->min_flt++;
259                         perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MIN,
260                                       1, regs, address);
261                 }
262                 if (fault & VM_FAULT_RETRY) {
263                         flags |= FAULT_FLAG_TRIED;
264 
265                         /* No need to mmap_read_unlock(mm) as we would
266                          * have already released it in __lock_page_or_retry
267                          * in mm/filemap.c.
268                          */
269 
270                         goto retry;
271                 }
272         }
273 
274         mmap_read_unlock(mm);
275         return;
276 
277         /*
278          * Something tried to access memory that isn't in our memory map..
279          * Fix it, but check if it's kernel or user first..
280          */
281 bad_area:
282         mmap_read_unlock(mm);
283 
284 bad_area_nosemaphore:
285         /* User mode accesses just cause a SIGSEGV */
286         if (from_user) {
287                 do_fault_siginfo(code, SIGSEGV, regs, text_fault);
288                 return;
289         }
290 
291         /* Is this in ex_table? */
292 no_context:
293         g2 = regs->u_regs[UREG_G2];
294         if (!from_user) {
295                 fixup = search_extables_range(regs->pc, &g2);
296                 /* Values below 10 are reserved for other things */
297                 if (fixup > 10) {
298                         extern const unsigned int __memset_start[];
299                         extern const unsigned int __memset_end[];
300                         extern const unsigned int __csum_partial_copy_start[];
301                         extern const unsigned int __csum_partial_copy_end[];
302 
303 #ifdef DEBUG_EXCEPTIONS
304                         printk("Exception: PC<%08lx> faddr<%08lx>\n",
305                                regs->pc, address);
306                         printk("EX_TABLE: insn<%08lx> fixup<%08x> g2<%08lx>\n",
307                                 regs->pc, fixup, g2);
308 #endif
309                         if ((regs->pc >= (unsigned long)__memset_start &&
310                              regs->pc < (unsigned long)__memset_end) ||
311                             (regs->pc >= (unsigned long)__csum_partial_copy_start &&
312                              regs->pc < (unsigned long)__csum_partial_copy_end)) {
313                                 regs->u_regs[UREG_I4] = address;
314                                 regs->u_regs[UREG_I5] = regs->pc;
315                         }
316                         regs->u_regs[UREG_G2] = g2;
317                         regs->pc = fixup;
318                         regs->npc = regs->pc + 4;
319                         return;
320                 }
321         }
322 
323         unhandled_fault(address, tsk, regs);
324         do_exit(SIGKILL);
325 
326 /*
327  * We ran out of memory, or some other thing happened to us that made
328  * us unable to handle the page fault gracefully.
329  */
330 out_of_memory:
331         mmap_read_unlock(mm);
332         if (from_user) {
333                 pagefault_out_of_memory();
334                 return;
335         }
336         goto no_context;
337 
338 do_sigbus:
339         mmap_read_unlock(mm);
340         do_fault_siginfo(BUS_ADRERR, SIGBUS, regs, text_fault);
341         if (!from_user)
342                 goto no_context;
343 
344 vmalloc_fault:
345         {
346                 /*
347                  * Synchronize this task's top level page-table
348                  * with the 'reference' page table.
349                  */
350                 int offset = pgd_index(address);
351                 pgd_t *pgd, *pgd_k;
352                 p4d_t *p4d, *p4d_k;
353                 pud_t *pud, *pud_k;
354                 pmd_t *pmd, *pmd_k;
355 
356                 pgd = tsk->active_mm->pgd + offset;
357                 pgd_k = init_mm.pgd + offset;
358 
359                 if (!pgd_present(*pgd)) {
360                         if (!pgd_present(*pgd_k))
361                                 goto bad_area_nosemaphore;
362                         pgd_val(*pgd) = pgd_val(*pgd_k);
363                         return;
364                 }
365 
366                 p4d = p4d_offset(pgd, address);
367                 pud = pud_offset(p4d, address);
368                 pmd = pmd_offset(pud, address);
369 
370                 p4d_k = p4d_offset(pgd_k, address);
371                 pud_k = pud_offset(p4d_k, address);
372                 pmd_k = pmd_offset(pud_k, address);
373 
374                 if (pmd_present(*pmd) || !pmd_present(*pmd_k))
375                         goto bad_area_nosemaphore;
376 
377                 *pmd = *pmd_k;
378                 return;
379         }
380 }
381 
382 /* This always deals with user addresses. */
383 static void force_user_fault(unsigned long address, int write)
384 {
385         struct vm_area_struct *vma;
386         struct task_struct *tsk = current;
387         struct mm_struct *mm = tsk->mm;
388         unsigned int flags = FAULT_FLAG_USER;
389         int code;
390 
391         code = SEGV_MAPERR;
392 
393         mmap_read_lock(mm);
394         vma = find_vma(mm, address);
395         if (!vma)
396                 goto bad_area;
397         if (vma->vm_start <= address)
398                 goto good_area;
399         if (!(vma->vm_flags & VM_GROWSDOWN))
400                 goto bad_area;
401         if (expand_stack(vma, address))
402                 goto bad_area;
403 good_area:
404         code = SEGV_ACCERR;
405         if (write) {
406                 if (!(vma->vm_flags & VM_WRITE))
407                         goto bad_area;
408                 flags |= FAULT_FLAG_WRITE;
409         } else {
410                 if (!(vma->vm_flags & (VM_READ | VM_EXEC)))
411                         goto bad_area;
412         }
413         switch (handle_mm_fault(vma, address, flags)) {
414         case VM_FAULT_SIGBUS:
415         case VM_FAULT_OOM:
416                 goto do_sigbus;
417         }
418         mmap_read_unlock(mm);
419         return;
420 bad_area:
421         mmap_read_unlock(mm);
422         __do_fault_siginfo(code, SIGSEGV, tsk->thread.kregs, address);
423         return;
424 
425 do_sigbus:
426         mmap_read_unlock(mm);
427         __do_fault_siginfo(BUS_ADRERR, SIGBUS, tsk->thread.kregs, address);
428 }
429 
430 static void check_stack_aligned(unsigned long sp)
431 {
432         if (sp & 0x7UL)
433                 force_sig(SIGILL);
434 }
435 
436 void window_overflow_fault(void)
437 {
438         unsigned long sp;
439 
440         sp = current_thread_info()->rwbuf_stkptrs[0];
441         if (((sp + 0x38) & PAGE_MASK) != (sp & PAGE_MASK))
442                 force_user_fault(sp + 0x38, 1);
443         force_user_fault(sp, 1);
444 
445         check_stack_aligned(sp);
446 }
447 
448 void window_underflow_fault(unsigned long sp)
449 {
450         if (((sp + 0x38) & PAGE_MASK) != (sp & PAGE_MASK))
451                 force_user_fault(sp + 0x38, 0);
452         force_user_fault(sp, 0);
453 
454         check_stack_aligned(sp);
455 }
456 
457 void window_ret_fault(struct pt_regs *regs)
458 {
459         unsigned long sp;
460 
461         sp = regs->u_regs[UREG_FP];
462         if (((sp + 0x38) & PAGE_MASK) != (sp & PAGE_MASK))
463                 force_user_fault(sp + 0x38, 0);
464         force_user_fault(sp, 0);
465 
466         check_stack_aligned(sp);
467 }
468 

~ [ 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