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         fault = handle_mm_fault(mm, vma, ea, is_write);
  78         if (unlikely(fault & VM_FAULT_ERROR)) {
  79                 if (fault & VM_FAULT_OOM) {
  80                         ret = -ENOMEM;
  81                         goto bad_area;
  82                 } else if (fault & VM_FAULT_SIGBUS) {
  83                         ret = -EFAULT;
  84                         goto bad_area;
  85                 }
  86                 BUG();
  87         }
  88         if (fault & VM_FAULT_MAJOR)
  89                 current->maj_flt++;
  90         else
  91                 current->min_flt++;
  92         up_read(&mm->mmap_sem);
  93         return ret;
  94
  95 bad_area:
  96         up_read(&mm->mmap_sem);
  97         return -EFAULT;
  98 }
  99
 100 static void spufs_handle_dma_error(struct spu_context *ctx,
 101                                 unsigned long ea, int type)
 102 {
 103         if (ctx->flags & SPU_CREATE_EVENTS_ENABLED) {
 104                 ctx->event_return |= type;
 105                 wake_up_all(&ctx->stop_wq);
 106         } else {
 107                 siginfo_t info;
 108                 memset(&info, 0, sizeof(info));
 109
 110                 switch (type) {
 111                 case SPE_EVENT_INVALID_DMA:
 112                         info.si_signo = SIGBUS;
 113                         info.si_code = BUS_OBJERR;
 114                         break;
 115                 case SPE_EVENT_SPE_DATA_STORAGE:
 116                         info.si_signo = SIGBUS;
 117                         info.si_addr = (void __user *)ea;
 118                         info.si_code = BUS_ADRERR;
 119                         break;
 120                 case SPE_EVENT_DMA_ALIGNMENT:
 121                         info.si_signo = SIGBUS;
 122                         /* DAR isn't set for an alignment fault :( */
 123                         info.si_code = BUS_ADRALN;
 124                         break;
 125                 case SPE_EVENT_SPE_ERROR:
 126                         info.si_signo = SIGILL;
 127                         info.si_addr = (void __user *)(unsigned long)
 128                                 ctx->ops->npc_read(ctx) - 4;
 129                         info.si_code = ILL_ILLOPC;
 130                         break;
 131                 }
 132                 if (info.si_signo)
 133                         force_sig_info(info.si_signo, &info, current);
 134         }
 135 }
 136
 137 void spufs_dma_callback(struct spu *spu, int type)
 138 {
 139         spufs_handle_dma_error(spu->ctx, spu->dar, type);
 140 }
 141 EXPORT_SYMBOL_GPL(spufs_dma_callback);
 142
 143 /*
 144  * bottom half handler for page faults, we can't do this from
 145  * interrupt context, since we might need to sleep.
 146  * we also need to give up the mutex so we can get scheduled
 147  * out while waiting for the backing store.
 148  *
 149  * TODO: try calling hash_page from the interrupt handler first
 150  *       in order to speed up the easy case.
 151  */
 152 int spufs_handle_class1(struct spu_context *ctx)
 153 {
 154         u64 ea, dsisr, access;
 155         unsigned long flags;
 156         unsigned flt = 0;
 157         int ret;
 158
 159         /*
 160          * dar and dsisr get passed from the registers
 161          * to the spu_context, to this function, but not
 162          * back to the spu if it gets scheduled again.
 163          *
 164          * if we don't handle the fault for a saved context
 165          * in time, we can still expect to get the same fault
 166          * the immediately after the context restore.
 167          */
 168         if (ctx->state == SPU_STATE_RUNNABLE) {
 169                 ea = ctx->spu->dar;
 170                 dsisr = ctx->spu->dsisr;
 171                 ctx->spu->dar= ctx->spu->dsisr = 0;
 172         } else {
 173                 ea = ctx->csa.priv1.mfc_dar_RW;
 174                 dsisr = ctx->csa.priv1.mfc_dsisr_RW;
 175                 ctx->csa.priv1.mfc_dar_RW = 0;
 176                 ctx->csa.priv1.mfc_dsisr_RW = 0;
 177         }
 178
 179         if (!(dsisr & (MFC_DSISR_PTE_NOT_FOUND | MFC_DSISR_ACCESS_DENIED)))
 180                 return 0;
 181
 182         spuctx_switch_state(ctx, SPUCTX_UTIL_IOWAIT);
 183
 184         pr_debug("ctx %p: ea %016lx, dsisr %016lx state %d\n", ctx, ea,
 185                 dsisr, ctx->state);
 186
 187         ctx->stats.hash_flt++;
 188         if (ctx->state == SPU_STATE_RUNNABLE) {
 189                 ctx->spu->stats.hash_flt++;
 190                 spu_switch_state(ctx->spu, SPU_UTIL_IOWAIT);
 191         }
 192
 193         /* we must not hold the lock when entering spu_handle_mm_fault */
 194         spu_release(ctx);
 195
 196         access = (_PAGE_PRESENT | _PAGE_USER);
 197         access |= (dsisr & MFC_DSISR_ACCESS_PUT) ? _PAGE_RW : 0UL;
 198         local_irq_save(flags);
 199         ret = hash_page(ea, access, 0x300);
 200         local_irq_restore(flags);
 201
 202         /* hashing failed, so try the actual fault handler */
 203         if (ret)
 204                 ret = spu_handle_mm_fault(current->mm, ea, dsisr, &flt);
 205
 206         spu_acquire(ctx);
 207         /*
 208          * If we handled the fault successfully and are in runnable
 209          * state, restart the DMA.
 210          * In case of unhandled error report the problem to user space.
 211          */
 212         if (!ret) {
 213                 if (flt == VM_FAULT_MINOR)
 214                         ctx->stats.min_flt++;
 215                 else
 216                         ctx->stats.maj_flt++;
 217                 if (ctx->state == SPU_STATE_RUNNABLE) {
 218                         if (flt == VM_FAULT_MINOR)
 219                                 ctx->spu->stats.min_flt++;
 220                         else
 221                                 ctx->spu->stats.maj_flt++;
 222                 }
 223
 224                 if (ctx->spu)
 225                         ctx->ops->restart_dma(ctx);
 226         } else
 227                 spufs_handle_dma_error(ctx, ea, SPE_EVENT_SPE_DATA_STORAGE);
 228
 229         spuctx_switch_state(ctx, SPUCTX_UTIL_SYSTEM);
 230         return ret;
 231 }
 232 EXPORT_SYMBOL_GPL(spufs_handle_class1);