Paul Mundt | 26ff6c1 | 2006-09-27 15:13:36 +0900 | [diff] [blame] | 1 | /* |
| 2 | * Page fault handler for SH with an MMU. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3 | * |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 4 | * Copyright (C) 1999 Niibe Yutaka |
Paul Mundt | 0f60bb2 | 2009-07-05 03:18:47 +0900 | [diff] [blame] | 5 | * Copyright (C) 2003 - 2009 Paul Mundt |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 6 | * |
| 7 | * Based on linux/arch/i386/mm/fault.c: |
| 8 | * Copyright (C) 1995 Linus Torvalds |
Paul Mundt | 26ff6c1 | 2006-09-27 15:13:36 +0900 | [diff] [blame] | 9 | * |
| 10 | * This file is subject to the terms and conditions of the GNU General Public |
| 11 | * License. See the file "COPYING" in the main directory of this archive |
| 12 | * for more details. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 13 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 14 | #include <linux/kernel.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 15 | #include <linux/mm.h> |
Paul Mundt | 0f08f33 | 2006-09-27 17:03:56 +0900 | [diff] [blame] | 16 | #include <linux/hardirq.h> |
| 17 | #include <linux/kprobes.h> |
Ingo Molnar | cdd6c48 | 2009-09-21 12:02:48 +0200 | [diff] [blame] | 18 | #include <linux/perf_event.h> |
Magnus Damm | e7cc9a7 | 2008-02-07 20:18:21 +0900 | [diff] [blame] | 19 | #include <asm/io_trapped.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 20 | #include <asm/mmu_context.h> |
Paul Mundt | db2e1fa | 2007-02-14 14:13:10 +0900 | [diff] [blame] | 21 | #include <asm/tlbflush.h> |
David Howells | e839ca5 | 2012-03-28 18:30:03 +0100 | [diff] [blame] | 22 | #include <asm/traps.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 23 | |
Paul Mundt | 7433ab770 | 2009-06-25 02:30:10 +0900 | [diff] [blame] | 24 | static inline int notify_page_fault(struct pt_regs *regs, int trap) |
| 25 | { |
| 26 | int ret = 0; |
| 27 | |
Paul Mundt | c63c310 | 2009-07-05 02:50:10 +0900 | [diff] [blame] | 28 | if (kprobes_built_in() && !user_mode(regs)) { |
Paul Mundt | 7433ab770 | 2009-06-25 02:30:10 +0900 | [diff] [blame] | 29 | preempt_disable(); |
| 30 | if (kprobe_running() && kprobe_fault_handler(regs, trap)) |
| 31 | ret = 1; |
| 32 | preempt_enable(); |
| 33 | } |
Paul Mundt | 7433ab770 | 2009-06-25 02:30:10 +0900 | [diff] [blame] | 34 | |
| 35 | return ret; |
| 36 | } |
| 37 | |
Paul Mundt | 0f60bb2 | 2009-07-05 03:18:47 +0900 | [diff] [blame] | 38 | static inline pmd_t *vmalloc_sync_one(pgd_t *pgd, unsigned long address) |
| 39 | { |
| 40 | unsigned index = pgd_index(address); |
| 41 | pgd_t *pgd_k; |
| 42 | pud_t *pud, *pud_k; |
| 43 | pmd_t *pmd, *pmd_k; |
| 44 | |
| 45 | pgd += index; |
| 46 | pgd_k = init_mm.pgd + index; |
| 47 | |
| 48 | if (!pgd_present(*pgd_k)) |
| 49 | return NULL; |
| 50 | |
| 51 | pud = pud_offset(pgd, address); |
| 52 | pud_k = pud_offset(pgd_k, address); |
| 53 | if (!pud_present(*pud_k)) |
| 54 | return NULL; |
| 55 | |
Matt Fleming | 5d9b4b1 | 2009-12-13 14:38:50 +0000 | [diff] [blame] | 56 | if (!pud_present(*pud)) |
| 57 | set_pud(pud, *pud_k); |
| 58 | |
Paul Mundt | 0f60bb2 | 2009-07-05 03:18:47 +0900 | [diff] [blame] | 59 | pmd = pmd_offset(pud, address); |
| 60 | pmd_k = pmd_offset(pud_k, address); |
| 61 | if (!pmd_present(*pmd_k)) |
| 62 | return NULL; |
| 63 | |
| 64 | if (!pmd_present(*pmd)) |
| 65 | set_pmd(pmd, *pmd_k); |
Matt Fleming | 05dd2cd | 2009-07-13 11:38:04 +0000 | [diff] [blame] | 66 | else { |
| 67 | /* |
| 68 | * The page tables are fully synchronised so there must |
| 69 | * be another reason for the fault. Return NULL here to |
| 70 | * signal that we have not taken care of the fault. |
| 71 | */ |
Paul Mundt | 0f60bb2 | 2009-07-05 03:18:47 +0900 | [diff] [blame] | 72 | BUG_ON(pmd_page(*pmd) != pmd_page(*pmd_k)); |
Matt Fleming | 05dd2cd | 2009-07-13 11:38:04 +0000 | [diff] [blame] | 73 | return NULL; |
| 74 | } |
Paul Mundt | 0f60bb2 | 2009-07-05 03:18:47 +0900 | [diff] [blame] | 75 | |
| 76 | return pmd_k; |
| 77 | } |
| 78 | |
| 79 | /* |
| 80 | * Handle a fault on the vmalloc or module mapping area |
| 81 | */ |
| 82 | static noinline int vmalloc_fault(unsigned long address) |
| 83 | { |
| 84 | pgd_t *pgd_k; |
| 85 | pmd_t *pmd_k; |
| 86 | pte_t *pte_k; |
| 87 | |
Paul Mundt | 0906a3a | 2009-09-03 17:21:10 +0900 | [diff] [blame] | 88 | /* Make sure we are in vmalloc/module/P3 area: */ |
Stuart Menefy | 8d9a784 | 2012-02-14 11:29:11 +0000 | [diff] [blame] | 89 | if (!(address >= P3SEG && address < P3_ADDR_MAX)) |
Paul Mundt | 0f60bb2 | 2009-07-05 03:18:47 +0900 | [diff] [blame] | 90 | return -1; |
| 91 | |
| 92 | /* |
| 93 | * Synchronize this task's top level page-table |
| 94 | * with the 'reference' page table. |
| 95 | * |
| 96 | * Do _not_ use "current" here. We might be inside |
| 97 | * an interrupt in the middle of a task switch.. |
| 98 | */ |
| 99 | pgd_k = get_TTB(); |
Matt Fleming | 05dd2cd | 2009-07-13 11:38:04 +0000 | [diff] [blame] | 100 | pmd_k = vmalloc_sync_one(pgd_k, address); |
Paul Mundt | 0f60bb2 | 2009-07-05 03:18:47 +0900 | [diff] [blame] | 101 | if (!pmd_k) |
| 102 | return -1; |
| 103 | |
| 104 | pte_k = pte_offset_kernel(pmd_k, address); |
| 105 | if (!pte_present(*pte_k)) |
| 106 | return -1; |
| 107 | |
| 108 | return 0; |
| 109 | } |
| 110 | |
| 111 | static int fault_in_kernel_space(unsigned long address) |
| 112 | { |
| 113 | return address >= TASK_SIZE; |
| 114 | } |
| 115 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 116 | /* |
| 117 | * This routine handles page faults. It determines the address, |
| 118 | * and the problem, and then passes it off to one of the appropriate |
| 119 | * routines. |
| 120 | */ |
Stuart Menefy | b5a1bcb | 2006-11-21 13:34:04 +0900 | [diff] [blame] | 121 | asmlinkage void __kprobes do_page_fault(struct pt_regs *regs, |
| 122 | unsigned long writeaccess, |
| 123 | unsigned long address) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 124 | { |
Paul Mundt | 0f60bb2 | 2009-07-05 03:18:47 +0900 | [diff] [blame] | 125 | unsigned long vec; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 126 | struct task_struct *tsk; |
| 127 | struct mm_struct *mm; |
| 128 | struct vm_area_struct * vma; |
Stuart Menefy | b5a1bcb | 2006-11-21 13:34:04 +0900 | [diff] [blame] | 129 | int si_code; |
Nick Piggin | 83c5407 | 2007-07-19 01:47:05 -0700 | [diff] [blame] | 130 | int fault; |
Stuart Menefy | b5a1bcb | 2006-11-21 13:34:04 +0900 | [diff] [blame] | 131 | siginfo_t info; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 132 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 133 | tsk = current; |
Paul Mundt | 0f60bb2 | 2009-07-05 03:18:47 +0900 | [diff] [blame] | 134 | mm = tsk->mm; |
Stuart Menefy | b5a1bcb | 2006-11-21 13:34:04 +0900 | [diff] [blame] | 135 | si_code = SEGV_MAPERR; |
Paul Mundt | 0f60bb2 | 2009-07-05 03:18:47 +0900 | [diff] [blame] | 136 | vec = lookup_exception_vector(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 137 | |
Paul Mundt | 0f60bb2 | 2009-07-05 03:18:47 +0900 | [diff] [blame] | 138 | /* |
| 139 | * We fault-in kernel-space virtual memory on-demand. The |
| 140 | * 'reference' page table is init_mm.pgd. |
| 141 | * |
| 142 | * NOTE! We MUST NOT take any locks for this case. We may |
| 143 | * be in an interrupt or a critical region, and should |
| 144 | * only copy the information from the master page table, |
| 145 | * nothing more. |
| 146 | */ |
| 147 | if (unlikely(fault_in_kernel_space(address))) { |
| 148 | if (vmalloc_fault(address) >= 0) |
Stuart Menefy | 99a596f | 2006-11-21 15:38:05 +0900 | [diff] [blame] | 149 | return; |
Paul Mundt | 0f60bb2 | 2009-07-05 03:18:47 +0900 | [diff] [blame] | 150 | if (notify_page_fault(regs, vec)) |
Stuart Menefy | 96e14e5 | 2008-09-05 16:17:15 +0900 | [diff] [blame] | 151 | return; |
Stuart Menefy | 99a596f | 2006-11-21 15:38:05 +0900 | [diff] [blame] | 152 | |
Paul Mundt | 0f60bb2 | 2009-07-05 03:18:47 +0900 | [diff] [blame] | 153 | goto bad_area_nosemaphore; |
Stuart Menefy | 99a596f | 2006-11-21 15:38:05 +0900 | [diff] [blame] | 154 | } |
| 155 | |
Paul Mundt | 0f60bb2 | 2009-07-05 03:18:47 +0900 | [diff] [blame] | 156 | if (unlikely(notify_page_fault(regs, vec))) |
Paul Mundt | 7433ab770 | 2009-06-25 02:30:10 +0900 | [diff] [blame] | 157 | return; |
| 158 | |
| 159 | /* Only enable interrupts if they were on before the fault */ |
| 160 | if ((regs->sr & SR_IMASK) != SR_IMASK) |
| 161 | local_irq_enable(); |
| 162 | |
Peter Zijlstra | a8b0ca1 | 2011-06-27 14:41:57 +0200 | [diff] [blame] | 163 | perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS, 1, regs, address); |
Paul Mundt | 7433ab770 | 2009-06-25 02:30:10 +0900 | [diff] [blame] | 164 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 165 | /* |
Paul Mundt | 0f60bb2 | 2009-07-05 03:18:47 +0900 | [diff] [blame] | 166 | * If we're in an interrupt, have no user context or are running |
| 167 | * in an atomic region then we must not take the fault: |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 168 | */ |
| 169 | if (in_atomic() || !mm) |
| 170 | goto no_context; |
| 171 | |
| 172 | down_read(&mm->mmap_sem); |
| 173 | |
| 174 | vma = find_vma(mm, address); |
| 175 | if (!vma) |
| 176 | goto bad_area; |
| 177 | if (vma->vm_start <= address) |
| 178 | goto good_area; |
| 179 | if (!(vma->vm_flags & VM_GROWSDOWN)) |
| 180 | goto bad_area; |
| 181 | if (expand_stack(vma, address)) |
| 182 | goto bad_area; |
Paul Mundt | 0f60bb2 | 2009-07-05 03:18:47 +0900 | [diff] [blame] | 183 | |
| 184 | /* |
| 185 | * Ok, we have a good vm_area for this memory access, so |
| 186 | * we can handle it.. |
| 187 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 188 | good_area: |
Stuart Menefy | b5a1bcb | 2006-11-21 13:34:04 +0900 | [diff] [blame] | 189 | si_code = SEGV_ACCERR; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 190 | if (writeaccess) { |
| 191 | if (!(vma->vm_flags & VM_WRITE)) |
| 192 | goto bad_area; |
| 193 | } else { |
Jason Baron | df67b3d | 2006-09-29 01:58:58 -0700 | [diff] [blame] | 194 | if (!(vma->vm_flags & (VM_READ | VM_EXEC | VM_WRITE))) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 195 | goto bad_area; |
| 196 | } |
| 197 | |
| 198 | /* |
| 199 | * If for any reason at all we couldn't handle the fault, |
| 200 | * make sure we exit gracefully rather than endlessly redo |
| 201 | * the fault. |
| 202 | */ |
Linus Torvalds | d06063c | 2009-04-10 09:01:23 -0700 | [diff] [blame] | 203 | fault = handle_mm_fault(mm, vma, address, writeaccess ? FAULT_FLAG_WRITE : 0); |
Nick Piggin | 83c5407 | 2007-07-19 01:47:05 -0700 | [diff] [blame] | 204 | if (unlikely(fault & VM_FAULT_ERROR)) { |
| 205 | if (fault & VM_FAULT_OOM) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 206 | goto out_of_memory; |
Nick Piggin | 83c5407 | 2007-07-19 01:47:05 -0700 | [diff] [blame] | 207 | else if (fault & VM_FAULT_SIGBUS) |
| 208 | goto do_sigbus; |
| 209 | BUG(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 210 | } |
Paul Mundt | 7433ab770 | 2009-06-25 02:30:10 +0900 | [diff] [blame] | 211 | if (fault & VM_FAULT_MAJOR) { |
Nick Piggin | 83c5407 | 2007-07-19 01:47:05 -0700 | [diff] [blame] | 212 | tsk->maj_flt++; |
Peter Zijlstra | a8b0ca1 | 2011-06-27 14:41:57 +0200 | [diff] [blame] | 213 | perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MAJ, 1, |
Paul Mundt | 7433ab770 | 2009-06-25 02:30:10 +0900 | [diff] [blame] | 214 | regs, address); |
| 215 | } else { |
Nick Piggin | 83c5407 | 2007-07-19 01:47:05 -0700 | [diff] [blame] | 216 | tsk->min_flt++; |
Peter Zijlstra | a8b0ca1 | 2011-06-27 14:41:57 +0200 | [diff] [blame] | 217 | perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MIN, 1, |
Paul Mundt | 7433ab770 | 2009-06-25 02:30:10 +0900 | [diff] [blame] | 218 | regs, address); |
| 219 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 220 | |
| 221 | up_read(&mm->mmap_sem); |
| 222 | return; |
| 223 | |
Paul Mundt | 0f60bb2 | 2009-07-05 03:18:47 +0900 | [diff] [blame] | 224 | /* |
| 225 | * Something tried to access memory that isn't in our memory map.. |
| 226 | * Fix it, but check if it's kernel or user first.. |
| 227 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 228 | bad_area: |
| 229 | up_read(&mm->mmap_sem); |
| 230 | |
Stuart Menefy | 99a596f | 2006-11-21 15:38:05 +0900 | [diff] [blame] | 231 | bad_area_nosemaphore: |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 232 | if (user_mode(regs)) { |
Stuart Menefy | b5a1bcb | 2006-11-21 13:34:04 +0900 | [diff] [blame] | 233 | info.si_signo = SIGSEGV; |
| 234 | info.si_errno = 0; |
| 235 | info.si_code = si_code; |
| 236 | info.si_addr = (void *) address; |
| 237 | force_sig_info(SIGSEGV, &info, tsk); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 238 | return; |
| 239 | } |
| 240 | |
| 241 | no_context: |
| 242 | /* Are we prepared to handle this kernel fault? */ |
| 243 | if (fixup_exception(regs)) |
| 244 | return; |
| 245 | |
Magnus Damm | e7cc9a7 | 2008-02-07 20:18:21 +0900 | [diff] [blame] | 246 | if (handle_trapped_io(regs, address)) |
| 247 | return; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 248 | /* |
| 249 | * Oops. The kernel tried to access some bad page. We'll have to |
| 250 | * terminate things with extreme prejudice. |
| 251 | * |
| 252 | */ |
Paul Mundt | 0630e45 | 2007-06-18 19:02:47 +0900 | [diff] [blame] | 253 | |
| 254 | bust_spinlocks(1); |
| 255 | |
| 256 | if (oops_may_print()) { |
Paul Mundt | b62ad83 | 2008-01-10 14:07:03 +0900 | [diff] [blame] | 257 | unsigned long page; |
Paul Mundt | 0630e45 | 2007-06-18 19:02:47 +0900 | [diff] [blame] | 258 | |
| 259 | if (address < PAGE_SIZE) |
| 260 | printk(KERN_ALERT "Unable to handle kernel NULL " |
| 261 | "pointer dereference"); |
| 262 | else |
| 263 | printk(KERN_ALERT "Unable to handle kernel paging " |
| 264 | "request"); |
| 265 | printk(" at virtual address %08lx\n", address); |
| 266 | printk(KERN_ALERT "pc = %08lx\n", regs->pc); |
| 267 | page = (unsigned long)get_TTB(); |
| 268 | if (page) { |
Paul Mundt | 06f862c | 2007-08-01 16:39:51 +0900 | [diff] [blame] | 269 | page = ((__typeof__(page) *)page)[address >> PGDIR_SHIFT]; |
Paul Mundt | 0630e45 | 2007-06-18 19:02:47 +0900 | [diff] [blame] | 270 | printk(KERN_ALERT "*pde = %08lx\n", page); |
| 271 | if (page & _PAGE_PRESENT) { |
| 272 | page &= PAGE_MASK; |
| 273 | address &= 0x003ff000; |
| 274 | page = ((__typeof__(page) *) |
| 275 | __va(page))[address >> |
| 276 | PAGE_SHIFT]; |
| 277 | printk(KERN_ALERT "*pte = %08lx\n", page); |
| 278 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 279 | } |
| 280 | } |
Paul Mundt | 0630e45 | 2007-06-18 19:02:47 +0900 | [diff] [blame] | 281 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 282 | die("Oops", regs, writeaccess); |
Paul Mundt | 0630e45 | 2007-06-18 19:02:47 +0900 | [diff] [blame] | 283 | bust_spinlocks(0); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 284 | do_exit(SIGKILL); |
| 285 | |
| 286 | /* |
| 287 | * We ran out of memory, or some other thing happened to us that made |
| 288 | * us unable to handle the page fault gracefully. |
| 289 | */ |
| 290 | out_of_memory: |
| 291 | up_read(&mm->mmap_sem); |
Nick Piggin | 6b6b18e | 2010-04-22 16:06:26 +0000 | [diff] [blame] | 292 | if (!user_mode(regs)) |
| 293 | goto no_context; |
| 294 | pagefault_out_of_memory(); |
| 295 | return; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 296 | |
| 297 | do_sigbus: |
| 298 | up_read(&mm->mmap_sem); |
| 299 | |
| 300 | /* |
| 301 | * Send a sigbus, regardless of whether we were in kernel |
| 302 | * or user mode. |
| 303 | */ |
Stuart Menefy | b5a1bcb | 2006-11-21 13:34:04 +0900 | [diff] [blame] | 304 | info.si_signo = SIGBUS; |
| 305 | info.si_errno = 0; |
| 306 | info.si_code = BUS_ADRERR; |
| 307 | info.si_addr = (void *)address; |
| 308 | force_sig_info(SIGBUS, &info, tsk); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 309 | |
| 310 | /* Kernel mode? Handle exceptions or die */ |
| 311 | if (!user_mode(regs)) |
| 312 | goto no_context; |
| 313 | } |
Paul Mundt | db2e1fa | 2007-02-14 14:13:10 +0900 | [diff] [blame] | 314 | |
Paul Mundt | db2e1fa | 2007-02-14 14:13:10 +0900 | [diff] [blame] | 315 | /* |
| 316 | * Called with interrupts disabled. |
| 317 | */ |
Paul Mundt | 112e584 | 2009-08-15 02:49:40 +0900 | [diff] [blame] | 318 | asmlinkage int __kprobes |
| 319 | handle_tlbmiss(struct pt_regs *regs, unsigned long writeaccess, |
| 320 | unsigned long address) |
Paul Mundt | db2e1fa | 2007-02-14 14:13:10 +0900 | [diff] [blame] | 321 | { |
| 322 | pgd_t *pgd; |
| 323 | pud_t *pud; |
| 324 | pmd_t *pmd; |
| 325 | pte_t *pte; |
| 326 | pte_t entry; |
Paul Mundt | 3d58695 | 2008-09-21 13:56:39 +0900 | [diff] [blame] | 327 | |
Paul Mundt | db2e1fa | 2007-02-14 14:13:10 +0900 | [diff] [blame] | 328 | /* |
| 329 | * We don't take page faults for P1, P2, and parts of P4, these |
| 330 | * are always mapped, whether it be due to legacy behaviour in |
| 331 | * 29-bit mode, or due to PMB configuration in 32-bit mode. |
| 332 | */ |
| 333 | if (address >= P3SEG && address < P3_ADDR_MAX) { |
| 334 | pgd = pgd_offset_k(address); |
Paul Mundt | db2e1fa | 2007-02-14 14:13:10 +0900 | [diff] [blame] | 335 | } else { |
Paul Mundt | 0f1a394 | 2007-11-19 13:05:18 +0900 | [diff] [blame] | 336 | if (unlikely(address >= TASK_SIZE || !current->mm)) |
Paul Mundt | 8010fbe | 2009-08-15 03:06:41 +0900 | [diff] [blame] | 337 | return 1; |
Paul Mundt | db2e1fa | 2007-02-14 14:13:10 +0900 | [diff] [blame] | 338 | |
Paul Mundt | 0f1a394 | 2007-11-19 13:05:18 +0900 | [diff] [blame] | 339 | pgd = pgd_offset(current->mm, address); |
Paul Mundt | db2e1fa | 2007-02-14 14:13:10 +0900 | [diff] [blame] | 340 | } |
| 341 | |
| 342 | pud = pud_offset(pgd, address); |
| 343 | if (pud_none_or_clear_bad(pud)) |
Paul Mundt | 8010fbe | 2009-08-15 03:06:41 +0900 | [diff] [blame] | 344 | return 1; |
Paul Mundt | db2e1fa | 2007-02-14 14:13:10 +0900 | [diff] [blame] | 345 | pmd = pmd_offset(pud, address); |
| 346 | if (pmd_none_or_clear_bad(pmd)) |
Paul Mundt | 8010fbe | 2009-08-15 03:06:41 +0900 | [diff] [blame] | 347 | return 1; |
Paul Mundt | 0f1a394 | 2007-11-19 13:05:18 +0900 | [diff] [blame] | 348 | pte = pte_offset_kernel(pmd, address); |
Paul Mundt | db2e1fa | 2007-02-14 14:13:10 +0900 | [diff] [blame] | 349 | entry = *pte; |
| 350 | if (unlikely(pte_none(entry) || pte_not_present(entry))) |
Paul Mundt | 8010fbe | 2009-08-15 03:06:41 +0900 | [diff] [blame] | 351 | return 1; |
Paul Mundt | db2e1fa | 2007-02-14 14:13:10 +0900 | [diff] [blame] | 352 | if (unlikely(writeaccess && !pte_write(entry))) |
Paul Mundt | 8010fbe | 2009-08-15 03:06:41 +0900 | [diff] [blame] | 353 | return 1; |
Paul Mundt | db2e1fa | 2007-02-14 14:13:10 +0900 | [diff] [blame] | 354 | |
| 355 | if (writeaccess) |
| 356 | entry = pte_mkdirty(entry); |
| 357 | entry = pte_mkyoung(entry); |
| 358 | |
Paul Mundt | 8010fbe | 2009-08-15 03:06:41 +0900 | [diff] [blame] | 359 | set_pte(pte, entry); |
| 360 | |
Hideo Saito | a602cc0 | 2008-02-14 14:45:08 +0900 | [diff] [blame] | 361 | #if defined(CONFIG_CPU_SH4) && !defined(CONFIG_SMP) |
| 362 | /* |
Paul Mundt | 8010fbe | 2009-08-15 03:06:41 +0900 | [diff] [blame] | 363 | * SH-4 does not set MMUCR.RC to the corresponding TLB entry in |
| 364 | * the case of an initial page write exception, so we need to |
| 365 | * flush it in order to avoid potential TLB entry duplication. |
Hideo Saito | a602cc0 | 2008-02-14 14:45:08 +0900 | [diff] [blame] | 366 | */ |
Paul Mundt | 8010fbe | 2009-08-15 03:06:41 +0900 | [diff] [blame] | 367 | if (writeaccess == 2) |
| 368 | local_flush_tlb_one(get_asid(), address & PAGE_MASK); |
Hideo Saito | a602cc0 | 2008-02-14 14:45:08 +0900 | [diff] [blame] | 369 | #endif |
| 370 | |
Russell King | 4b3073e | 2009-12-18 16:40:18 +0000 | [diff] [blame] | 371 | update_mmu_cache(NULL, address, pte); |
Paul Mundt | 0f1a394 | 2007-11-19 13:05:18 +0900 | [diff] [blame] | 372 | |
Paul Mundt | 8010fbe | 2009-08-15 03:06:41 +0900 | [diff] [blame] | 373 | return 0; |
Paul Mundt | db2e1fa | 2007-02-14 14:13:10 +0900 | [diff] [blame] | 374 | } |