Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/ericvh...
[linux-2.6] / arch / powerpc / platforms / cell / spufs / fault.c
1 /*
2  * Low-level SPU handling
3  *
4  * (C) Copyright IBM Deutschland Entwicklung GmbH 2005
5  *
6  * Author: Arnd Bergmann <arndb@de.ibm.com>
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2, or (at your option)
11  * any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21  */
22 #include <linux/sched.h>
23 #include <linux/mm.h>
24 #include <linux/module.h>
25
26 #include <asm/spu.h>
27 #include <asm/spu_csa.h>
28
29 #include "spufs.h"
30
31 /*
32  * This ought to be kept in sync with the powerpc specific do_page_fault
33  * function. Currently, there are a few corner cases that we haven't had
34  * to handle fortunately.
35  */
36 static int spu_handle_mm_fault(struct mm_struct *mm, unsigned long ea,
37                 unsigned long dsisr, unsigned *flt)
38 {
39         struct vm_area_struct *vma;
40         unsigned long is_write;
41         int ret;
42
43 #if 0
44         if (!IS_VALID_EA(ea)) {
45                 return -EFAULT;
46         }
47 #endif /* XXX */
48         if (mm == NULL) {
49                 return -EFAULT;
50         }
51         if (mm->pgd == NULL) {
52                 return -EFAULT;
53         }
54
55         down_read(&mm->mmap_sem);
56         vma = find_vma(mm, ea);
57         if (!vma)
58                 goto bad_area;
59         if (vma->vm_start <= ea)
60                 goto good_area;
61         if (!(vma->vm_flags & VM_GROWSDOWN))
62                 goto bad_area;
63         if (expand_stack(vma, ea))
64                 goto bad_area;
65 good_area:
66         is_write = dsisr & MFC_DSISR_ACCESS_PUT;
67         if (is_write) {
68                 if (!(vma->vm_flags & VM_WRITE))
69                         goto bad_area;
70         } else {
71                 if (dsisr & MFC_DSISR_ACCESS_DENIED)
72                         goto bad_area;
73                 if (!(vma->vm_flags & (VM_READ | VM_EXEC)))
74                         goto bad_area;
75         }
76         ret = 0;
77         *flt = handle_mm_fault(mm, vma, ea, is_write);
78         switch (*flt) {
79         case VM_FAULT_MINOR:
80                 current->min_flt++;
81                 break;
82         case VM_FAULT_MAJOR:
83                 current->maj_flt++;
84                 break;
85         case VM_FAULT_SIGBUS:
86                 ret = -EFAULT;
87                 goto bad_area;
88         case VM_FAULT_OOM:
89                 ret = -ENOMEM;
90                 goto bad_area;
91         default:
92                 BUG();
93         }
94         up_read(&mm->mmap_sem);
95         return ret;
96
97 bad_area:
98         up_read(&mm->mmap_sem);
99         return -EFAULT;
100 }
101
102 static void spufs_handle_dma_error(struct spu_context *ctx,
103                                 unsigned long ea, int type)
104 {
105         if (ctx->flags & SPU_CREATE_EVENTS_ENABLED) {
106                 ctx->event_return |= type;
107                 wake_up_all(&ctx->stop_wq);
108         } else {
109                 siginfo_t info;
110                 memset(&info, 0, sizeof(info));
111
112                 switch (type) {
113                 case SPE_EVENT_INVALID_DMA:
114                         info.si_signo = SIGBUS;
115                         info.si_code = BUS_OBJERR;
116                         break;
117                 case SPE_EVENT_SPE_DATA_STORAGE:
118                         info.si_signo = SIGBUS;
119                         info.si_addr = (void __user *)ea;
120                         info.si_code = BUS_ADRERR;
121                         break;
122                 case SPE_EVENT_DMA_ALIGNMENT:
123                         info.si_signo = SIGBUS;
124                         /* DAR isn't set for an alignment fault :( */
125                         info.si_code = BUS_ADRALN;
126                         break;
127                 case SPE_EVENT_SPE_ERROR:
128                         info.si_signo = SIGILL;
129                         info.si_addr = (void __user *)(unsigned long)
130                                 ctx->ops->npc_read(ctx) - 4;
131                         info.si_code = ILL_ILLOPC;
132                         break;
133                 }
134                 if (info.si_signo)
135                         force_sig_info(info.si_signo, &info, current);
136         }
137 }
138
139 void spufs_dma_callback(struct spu *spu, int type)
140 {
141         spufs_handle_dma_error(spu->ctx, spu->dar, type);
142 }
143 EXPORT_SYMBOL_GPL(spufs_dma_callback);
144
145 /*
146  * bottom half handler for page faults, we can't do this from
147  * interrupt context, since we might need to sleep.
148  * we also need to give up the mutex so we can get scheduled
149  * out while waiting for the backing store.
150  *
151  * TODO: try calling hash_page from the interrupt handler first
152  *       in order to speed up the easy case.
153  */
154 int spufs_handle_class1(struct spu_context *ctx)
155 {
156         u64 ea, dsisr, access;
157         unsigned long flags;
158         unsigned flt = 0;
159         int ret;
160
161         /*
162          * dar and dsisr get passed from the registers
163          * to the spu_context, to this function, but not
164          * back to the spu if it gets scheduled again.
165          *
166          * if we don't handle the fault for a saved context
167          * in time, we can still expect to get the same fault
168          * the immediately after the context restore.
169          */
170         if (ctx->state == SPU_STATE_RUNNABLE) {
171                 ea = ctx->spu->dar;
172                 dsisr = ctx->spu->dsisr;
173                 ctx->spu->dar= ctx->spu->dsisr = 0;
174         } else {
175                 ea = ctx->csa.priv1.mfc_dar_RW;
176                 dsisr = ctx->csa.priv1.mfc_dsisr_RW;
177                 ctx->csa.priv1.mfc_dar_RW = 0;
178                 ctx->csa.priv1.mfc_dsisr_RW = 0;
179         }
180
181         if (!(dsisr & (MFC_DSISR_PTE_NOT_FOUND | MFC_DSISR_ACCESS_DENIED)))
182                 return 0;
183
184         spuctx_switch_state(ctx, SPUCTX_UTIL_IOWAIT);
185
186         pr_debug("ctx %p: ea %016lx, dsisr %016lx state %d\n", ctx, ea,
187                 dsisr, ctx->state);
188
189         ctx->stats.hash_flt++;
190         if (ctx->state == SPU_STATE_RUNNABLE) {
191                 ctx->spu->stats.hash_flt++;
192                 spu_switch_state(ctx->spu, SPU_UTIL_IOWAIT);
193         }
194
195         /* we must not hold the lock when entering spu_handle_mm_fault */
196         spu_release(ctx);
197
198         access = (_PAGE_PRESENT | _PAGE_USER);
199         access |= (dsisr & MFC_DSISR_ACCESS_PUT) ? _PAGE_RW : 0UL;
200         local_irq_save(flags);
201         ret = hash_page(ea, access, 0x300);
202         local_irq_restore(flags);
203
204         /* hashing failed, so try the actual fault handler */
205         if (ret)
206                 ret = spu_handle_mm_fault(current->mm, ea, dsisr, &flt);
207
208         spu_acquire(ctx);
209         /*
210          * If we handled the fault successfully and are in runnable
211          * state, restart the DMA.
212          * In case of unhandled error report the problem to user space.
213          */
214         if (!ret) {
215                 if (flt == VM_FAULT_MINOR)
216                         ctx->stats.min_flt++;
217                 else
218                         ctx->stats.maj_flt++;
219                 if (ctx->state == SPU_STATE_RUNNABLE) {
220                         if (flt == VM_FAULT_MINOR)
221                                 ctx->spu->stats.min_flt++;
222                         else
223                                 ctx->spu->stats.maj_flt++;
224                 }
225
226                 if (ctx->spu)
227                         ctx->ops->restart_dma(ctx);
228         } else
229                 spufs_handle_dma_error(ctx, ea, SPE_EVENT_SPE_DATA_STORAGE);
230
231         spuctx_switch_state(ctx, SPUCTX_UTIL_SYSTEM);
232         return ret;
233 }
234 EXPORT_SYMBOL_GPL(spufs_handle_class1);