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  */
spufs_handle_event(struct spu_context * ctx,unsigned long ea,int type)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 
spufs_handle_class0(struct spu_context * ctx)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  */
spufs_handle_class1(struct spu_context * ctx)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