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