LXR linux/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/signal.h>
  23#include <linux/mm.h>
  24
  25#include <asm/spu.h>
  26#include <asm/spu_csa.h>
  27
  28#include "spufs.h"
  29
  30/**
  31 * Handle an SPE event, depending on context SPU_CREATE_EVENTS_ENABLED flag.
  32 *
  33 * If the context was created with events, we just set the return event.
  34 * Otherwise, send an appropriate signal to the process.
  35 */
  36static void spufs_handle_event(struct spu_context *ctx,
  37                                unsigned long ea, int type)
  38{
  39        if (ctx->flags & SPU_CREATE_EVENTS_ENABLED) {
  40                ctx->event_return |= type;
  41                wake_up_all(&ctx->stop_wq);
  42                return;
  43        }
  44
  45        switch (type) {
  46        case SPE_EVENT_INVALID_DMA:
  47                force_sig_fault(SIGBUS, BUS_OBJERR, NULL, current);
  48                break;
  49        case SPE_EVENT_SPE_DATA_STORAGE:
  50                ctx->ops->restart_dma(ctx);
  51                force_sig_fault(SIGSEGV, SEGV_ACCERR, (void __user *)ea,
  52                                current);
  53                break;
  54        case SPE_EVENT_DMA_ALIGNMENT:
  55                /* DAR isn't set for an alignment fault :( */
  56                force_sig_fault(SIGBUS, BUS_ADRALN, NULL, current);
  57                break;
  58        case SPE_EVENT_SPE_ERROR:
  59                force_sig_fault(
  60                        SIGILL, ILL_ILLOPC,
  61                        (void __user *)(unsigned long)
  62                        ctx->ops->npc_read(ctx) - 4, current);
  63                break;
  64        }
  65}
  66
  67int spufs_handle_class0(struct spu_context *ctx)
  68{
  69        unsigned long stat = ctx->csa.class_0_pending & CLASS0_INTR_MASK;
  70
  71        if (likely(!stat))
  72                return 0;
  73
  74        if (stat & CLASS0_DMA_ALIGNMENT_INTR)
  75                spufs_handle_event(ctx, ctx->csa.class_0_dar,
  76                        SPE_EVENT_DMA_ALIGNMENT);
  77
  78        if (stat & CLASS0_INVALID_DMA_COMMAND_INTR)
  79                spufs_handle_event(ctx, ctx->csa.class_0_dar,
  80                        SPE_EVENT_INVALID_DMA);
  81
  82        if (stat & CLASS0_SPU_ERROR_INTR)
  83                spufs_handle_event(ctx, ctx->csa.class_0_dar,
  84                        SPE_EVENT_SPE_ERROR);
  85
  86        ctx->csa.class_0_pending = 0;
  87
  88        return -EIO;
  89}
  90
  91/*
  92 * bottom half handler for page faults, we can't do this from
  93 * interrupt context, since we might need to sleep.
  94 * we also need to give up the mutex so we can get scheduled
  95 * out while waiting for the backing store.
  96 *
  97 * TODO: try calling hash_page from the interrupt handler first
  98 *       in order to speed up the easy case.
  99 */
 100int spufs_handle_class1(struct spu_context *ctx)
 101{
 102        u64 ea, dsisr, access;
 103        unsigned long flags;
 104        vm_fault_t flt = 0;
 105        int ret;
 106
 107        /*
 108         * dar and dsisr get passed from the registers
 109         * to the spu_context, to this function, but not
 110         * back to the spu if it gets scheduled again.
 111         *
 112         * if we don't handle the fault for a saved context
 113         * in time, we can still expect to get the same fault
 114         * the immediately after the context restore.
 115         */
 116        ea = ctx->csa.class_1_dar;
 117        dsisr = ctx->csa.class_1_dsisr;
 118
 119        if (!(dsisr & (MFC_DSISR_PTE_NOT_FOUND | MFC_DSISR_ACCESS_DENIED)))
 120                return 0;
 121
 122        spuctx_switch_state(ctx, SPU_UTIL_IOWAIT);
 123
 124        pr_debug("ctx %p: ea %016llx, dsisr %016llx state %d\n", ctx, ea,
 125                dsisr, ctx->state);
 126
 127        ctx->stats.hash_flt++;
 128        if (ctx->state == SPU_STATE_RUNNABLE)
 129                ctx->spu->stats.hash_flt++;
 130
 131        /* we must not hold the lock when entering copro_handle_mm_fault */
 132        spu_release(ctx);
 133
 134        access = (_PAGE_PRESENT | _PAGE_READ);
 135        access |= (dsisr & MFC_DSISR_ACCESS_PUT) ? _PAGE_WRITE : 0UL;
 136        local_irq_save(flags);
 137        ret = hash_page(ea, access, 0x300, dsisr);
 138        local_irq_restore(flags);
 139
 140        /* hashing failed, so try the actual fault handler */
 141        if (ret)
 142                ret = copro_handle_mm_fault(current->mm, ea, dsisr, &flt);
 143
 144        /*
 145         * This is nasty: we need the state_mutex for all the bookkeeping even
 146         * if the syscall was interrupted by a signal. ewww.
 147         */
 148        mutex_lock(&ctx->state_mutex);
 149
 150        /*
 151         * Clear dsisr under ctxt lock after handling the fault, so that
 152         * time slicing will not preempt the context while the page fault
 153         * handler is running. Context switch code removes mappings.
 154         */
 155        ctx->csa.class_1_dar = ctx->csa.class_1_dsisr = 0;
 156
 157        /*
 158         * If we handled the fault successfully and are in runnable
 159         * state, restart the DMA.
 160         * In case of unhandled error report the problem to user space.
 161         */
 162        if (!ret) {
 163                if (flt & VM_FAULT_MAJOR)
 164                        ctx->stats.maj_flt++;
 165                else
 166                        ctx->stats.min_flt++;
 167                if (ctx->state == SPU_STATE_RUNNABLE) {
 168                        if (flt & VM_FAULT_MAJOR)
 169                                ctx->spu->stats.maj_flt++;
 170                        else
 171                                ctx->spu->stats.min_flt++;
 172                }
 173
 174                if (ctx->spu)
 175                        ctx->ops->restart_dma(ctx);
 176        } else
 177                spufs_handle_event(ctx, ea, SPE_EVENT_SPE_DATA_STORAGE);
 178
 179        spuctx_switch_state(ctx, SPU_UTIL_SYSTEM);
 180        return ret;
 181}
 182