fix file specification in comments
[linux-2.6.git] / arch / xtensa / mm / fault.c
1 // TODO VM_EXEC flag work-around, cache aliasing
2 /*
3  * arch/xtensa/mm/fault.c
4  *
5  * This file is subject to the terms and conditions of the GNU General Public
6  * License.  See the file "COPYING" in the main directory of this archive
7  * for more details.
8  *
9  * Copyright (C) 2001 - 2005 Tensilica Inc.
10  *
11  * Chris Zankel <chris@zankel.net>
12  * Joe Taylor   <joe@tensilica.com, joetylr@yahoo.com>
13  */
14
15 #include <linux/mm.h>
16 #include <linux/module.h>
17 #include <asm/mmu_context.h>
18 #include <asm/cacheflush.h>
19 #include <asm/hardirq.h>
20 #include <asm/uaccess.h>
21 #include <asm/system.h>
22 #include <asm/pgalloc.h>
23
24 unsigned long asid_cache = ASID_FIRST_VERSION;
25 void bad_page_fault(struct pt_regs*, unsigned long, int);
26
27 /*
28  * This routine handles page faults.  It determines the address,
29  * and the problem, and then passes it off to one of the appropriate
30  * routines.
31  *
32  * Note: does not handle Miss and MultiHit.
33  */
34
35 void do_page_fault(struct pt_regs *regs)
36 {
37         struct vm_area_struct * vma;
38         struct mm_struct *mm = current->mm;
39         unsigned int exccause = regs->exccause;
40         unsigned int address = regs->excvaddr;
41         siginfo_t info;
42
43         int is_write, is_exec;
44
45         info.si_code = SEGV_MAPERR;
46
47         /* We fault-in kernel-space virtual memory on-demand. The
48          * 'reference' page table is init_mm.pgd.
49          */
50         if (address >= TASK_SIZE && !user_mode(regs))
51                 goto vmalloc_fault;
52
53         /* If we're in an interrupt or have no user
54          * context, we must not take the fault..
55          */
56         if (in_atomic() || !mm) {
57                 bad_page_fault(regs, address, SIGSEGV);
58                 return;
59         }
60
61         is_write = (exccause == XCHAL_EXCCAUSE_STORE_CACHE_ATTRIBUTE) ? 1 : 0;
62         is_exec =  (exccause == XCHAL_EXCCAUSE_ITLB_PRIVILEGE ||
63                     exccause == XCHAL_EXCCAUSE_ITLB_MISS ||
64                     exccause == XCHAL_EXCCAUSE_FETCH_CACHE_ATTRIBUTE) ? 1 : 0;
65
66 #if 0
67         printk("[%s:%d:%08x:%d:%08x:%s%s]\n", current->comm, current->pid,
68                address, exccause, regs->pc, is_write? "w":"", is_exec? "x":"");
69 #endif
70
71         down_read(&mm->mmap_sem);
72         vma = find_vma(mm, address);
73
74         if (!vma)
75                 goto bad_area;
76         if (vma->vm_start <= address)
77                 goto good_area;
78         if (!(vma->vm_flags & VM_GROWSDOWN))
79                 goto bad_area;
80         if (expand_stack(vma, address))
81                 goto bad_area;
82
83         /* Ok, we have a good vm_area for this memory access, so
84          * we can handle it..
85          */
86
87 good_area:
88         info.si_code = SEGV_ACCERR;
89
90         if (is_write) {
91                 if (!(vma->vm_flags & VM_WRITE))
92                         goto bad_area;
93         } else if (is_exec) {
94                 if (!(vma->vm_flags & VM_EXEC))
95                         goto bad_area;
96         } else  /* Allow read even from write-only pages. */
97                 if (!(vma->vm_flags & (VM_READ | VM_WRITE)))
98                         goto bad_area;
99
100         /* If for any reason at all we couldn't handle the fault,
101          * make sure we exit gracefully rather than endlessly redo
102          * the fault.
103          */
104 survive:
105         switch (handle_mm_fault(mm, vma, address, is_write)) {
106         case VM_FAULT_MINOR:
107                 current->min_flt++;
108                 break;
109         case VM_FAULT_MAJOR:
110                 current->maj_flt++;
111                 break;
112         case VM_FAULT_SIGBUS:
113                 goto do_sigbus;
114         case VM_FAULT_OOM:
115                 goto out_of_memory;
116         default:
117                 BUG();
118         }
119
120         up_read(&mm->mmap_sem);
121         return;
122
123         /* Something tried to access memory that isn't in our memory map..
124          * Fix it, but check if it's kernel or user first..
125          */
126 bad_area:
127         up_read(&mm->mmap_sem);
128         if (user_mode(regs)) {
129                 current->thread.bad_vaddr = address;
130                 current->thread.error_code = is_write;
131                 info.si_signo = SIGSEGV;
132                 info.si_errno = 0;
133                 /* info.si_code has been set above */
134                 info.si_addr = (void *) address;
135                 force_sig_info(SIGSEGV, &info, current);
136                 return;
137         }
138         bad_page_fault(regs, address, SIGSEGV);
139         return;
140
141
142         /* We ran out of memory, or some other thing happened to us that made
143          * us unable to handle the page fault gracefully.
144          */
145 out_of_memory:
146         up_read(&mm->mmap_sem);
147         if (is_init(current)) {
148                 yield();
149                 down_read(&mm->mmap_sem);
150                 goto survive;
151         }
152         printk("VM: killing process %s\n", current->comm);
153         if (user_mode(regs))
154                 do_exit(SIGKILL);
155         bad_page_fault(regs, address, SIGKILL);
156         return;
157
158 do_sigbus:
159         up_read(&mm->mmap_sem);
160
161         /* Send a sigbus, regardless of whether we were in kernel
162          * or user mode.
163          */
164         current->thread.bad_vaddr = address;
165         info.si_code = SIGBUS;
166         info.si_errno = 0;
167         info.si_code = BUS_ADRERR;
168         info.si_addr = (void *) address;
169         force_sig_info(SIGBUS, &info, current);
170
171         /* Kernel mode? Handle exceptions or die */
172         if (!user_mode(regs))
173                 bad_page_fault(regs, address, SIGBUS);
174
175 vmalloc_fault:
176         {
177                 /* Synchronize this task's top level page-table
178                  * with the 'reference' page table.
179                  */
180                 struct mm_struct *act_mm = current->active_mm;
181                 int index = pgd_index(address);
182                 pgd_t *pgd, *pgd_k;
183                 pmd_t *pmd, *pmd_k;
184                 pte_t *pte_k;
185
186                 if (act_mm == NULL)
187                         goto bad_page_fault;
188
189                 pgd = act_mm->pgd + index;
190                 pgd_k = init_mm.pgd + index;
191
192                 if (!pgd_present(*pgd_k))
193                         goto bad_page_fault;
194
195                 pgd_val(*pgd) = pgd_val(*pgd_k);
196
197                 pmd = pmd_offset(pgd, address);
198                 pmd_k = pmd_offset(pgd_k, address);
199                 if (!pmd_present(*pmd) || !pmd_present(*pmd_k))
200                         goto bad_page_fault;
201
202                 pmd_val(*pmd) = pmd_val(*pmd_k);
203                 pte_k = pte_offset_kernel(pmd_k, address);
204
205                 if (!pte_present(*pte_k))
206                         goto bad_page_fault;
207                 return;
208         }
209 bad_page_fault:
210         bad_page_fault(regs, address, SIGKILL);
211         return;
212 }
213
214
215 void
216 bad_page_fault(struct pt_regs *regs, unsigned long address, int sig)
217 {
218         extern void die(const char*, struct pt_regs*, long);
219         const struct exception_table_entry *entry;
220
221         /* Are we prepared to handle this kernel fault?  */
222         if ((entry = search_exception_tables(regs->pc)) != NULL) {
223 #if 1
224                 printk(KERN_DEBUG "%s: Exception at pc=%#010lx (%lx)\n",
225                                 current->comm, regs->pc, entry->fixup);
226 #endif
227                 current->thread.bad_uaddr = address;
228                 regs->pc = entry->fixup;
229                 return;
230         }
231
232         /* Oops. The kernel tried to access some bad page. We'll have to
233          * terminate things with extreme prejudice.
234          */
235         printk(KERN_ALERT "Unable to handle kernel paging request at virtual "
236                "address %08lx\n pc = %08lx, ra = %08lx\n",
237                address, regs->pc, regs->areg[0]);
238         die("Oops", regs, sig);
239         do_exit(sig);
240 }
241