forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
451 lines
11 KiB
451 lines
11 KiB
// SPDX-License-Identifier: GPL-2.0 |
|
#define DEBUG |
|
|
|
#include <linux/wait.h> |
|
#include <linux/ptrace.h> |
|
|
|
#include <asm/spu.h> |
|
#include <asm/spu_priv1.h> |
|
#include <asm/io.h> |
|
#include <asm/unistd.h> |
|
|
|
#include "spufs.h" |
|
|
|
/* interrupt-level stop callback function. */ |
|
void spufs_stop_callback(struct spu *spu, int irq) |
|
{ |
|
struct spu_context *ctx = spu->ctx; |
|
|
|
/* |
|
* It should be impossible to preempt a context while an exception |
|
* is being processed, since the context switch code is specially |
|
* coded to deal with interrupts ... But, just in case, sanity check |
|
* the context pointer. It is OK to return doing nothing since |
|
* the exception will be regenerated when the context is resumed. |
|
*/ |
|
if (ctx) { |
|
/* Copy exception arguments into module specific structure */ |
|
switch(irq) { |
|
case 0 : |
|
ctx->csa.class_0_pending = spu->class_0_pending; |
|
ctx->csa.class_0_dar = spu->class_0_dar; |
|
break; |
|
case 1 : |
|
ctx->csa.class_1_dsisr = spu->class_1_dsisr; |
|
ctx->csa.class_1_dar = spu->class_1_dar; |
|
break; |
|
case 2 : |
|
break; |
|
} |
|
|
|
/* ensure that the exception status has hit memory before a |
|
* thread waiting on the context's stop queue is woken */ |
|
smp_wmb(); |
|
|
|
wake_up_all(&ctx->stop_wq); |
|
} |
|
} |
|
|
|
int spu_stopped(struct spu_context *ctx, u32 *stat) |
|
{ |
|
u64 dsisr; |
|
u32 stopped; |
|
|
|
stopped = SPU_STATUS_INVALID_INSTR | SPU_STATUS_SINGLE_STEP | |
|
SPU_STATUS_STOPPED_BY_HALT | SPU_STATUS_STOPPED_BY_STOP; |
|
|
|
top: |
|
*stat = ctx->ops->status_read(ctx); |
|
if (*stat & stopped) { |
|
/* |
|
* If the spu hasn't finished stopping, we need to |
|
* re-read the register to get the stopped value. |
|
*/ |
|
if (*stat & SPU_STATUS_RUNNING) |
|
goto top; |
|
return 1; |
|
} |
|
|
|
if (test_bit(SPU_SCHED_NOTIFY_ACTIVE, &ctx->sched_flags)) |
|
return 1; |
|
|
|
dsisr = ctx->csa.class_1_dsisr; |
|
if (dsisr & (MFC_DSISR_PTE_NOT_FOUND | MFC_DSISR_ACCESS_DENIED)) |
|
return 1; |
|
|
|
if (ctx->csa.class_0_pending) |
|
return 1; |
|
|
|
return 0; |
|
} |
|
|
|
static int spu_setup_isolated(struct spu_context *ctx) |
|
{ |
|
int ret; |
|
u64 __iomem *mfc_cntl; |
|
u64 sr1; |
|
u32 status; |
|
unsigned long timeout; |
|
const u32 status_loading = SPU_STATUS_RUNNING |
|
| SPU_STATUS_ISOLATED_STATE | SPU_STATUS_ISOLATED_LOAD_STATUS; |
|
|
|
ret = -ENODEV; |
|
if (!isolated_loader) |
|
goto out; |
|
|
|
/* |
|
* We need to exclude userspace access to the context. |
|
* |
|
* To protect against memory access we invalidate all ptes |
|
* and make sure the pagefault handlers block on the mutex. |
|
*/ |
|
spu_unmap_mappings(ctx); |
|
|
|
mfc_cntl = &ctx->spu->priv2->mfc_control_RW; |
|
|
|
/* purge the MFC DMA queue to ensure no spurious accesses before we |
|
* enter kernel mode */ |
|
timeout = jiffies + HZ; |
|
out_be64(mfc_cntl, MFC_CNTL_PURGE_DMA_REQUEST); |
|
while ((in_be64(mfc_cntl) & MFC_CNTL_PURGE_DMA_STATUS_MASK) |
|
!= MFC_CNTL_PURGE_DMA_COMPLETE) { |
|
if (time_after(jiffies, timeout)) { |
|
printk(KERN_ERR "%s: timeout flushing MFC DMA queue\n", |
|
__func__); |
|
ret = -EIO; |
|
goto out; |
|
} |
|
cond_resched(); |
|
} |
|
|
|
/* clear purge status */ |
|
out_be64(mfc_cntl, 0); |
|
|
|
/* put the SPE in kernel mode to allow access to the loader */ |
|
sr1 = spu_mfc_sr1_get(ctx->spu); |
|
sr1 &= ~MFC_STATE1_PROBLEM_STATE_MASK; |
|
spu_mfc_sr1_set(ctx->spu, sr1); |
|
|
|
/* start the loader */ |
|
ctx->ops->signal1_write(ctx, (unsigned long)isolated_loader >> 32); |
|
ctx->ops->signal2_write(ctx, |
|
(unsigned long)isolated_loader & 0xffffffff); |
|
|
|
ctx->ops->runcntl_write(ctx, |
|
SPU_RUNCNTL_RUNNABLE | SPU_RUNCNTL_ISOLATE); |
|
|
|
ret = 0; |
|
timeout = jiffies + HZ; |
|
while (((status = ctx->ops->status_read(ctx)) & status_loading) == |
|
status_loading) { |
|
if (time_after(jiffies, timeout)) { |
|
printk(KERN_ERR "%s: timeout waiting for loader\n", |
|
__func__); |
|
ret = -EIO; |
|
goto out_drop_priv; |
|
} |
|
cond_resched(); |
|
} |
|
|
|
if (!(status & SPU_STATUS_RUNNING)) { |
|
/* If isolated LOAD has failed: run SPU, we will get a stop-and |
|
* signal later. */ |
|
pr_debug("%s: isolated LOAD failed\n", __func__); |
|
ctx->ops->runcntl_write(ctx, SPU_RUNCNTL_RUNNABLE); |
|
ret = -EACCES; |
|
goto out_drop_priv; |
|
} |
|
|
|
if (!(status & SPU_STATUS_ISOLATED_STATE)) { |
|
/* This isn't allowed by the CBEA, but check anyway */ |
|
pr_debug("%s: SPU fell out of isolated mode?\n", __func__); |
|
ctx->ops->runcntl_write(ctx, SPU_RUNCNTL_STOP); |
|
ret = -EINVAL; |
|
goto out_drop_priv; |
|
} |
|
|
|
out_drop_priv: |
|
/* Finished accessing the loader. Drop kernel mode */ |
|
sr1 |= MFC_STATE1_PROBLEM_STATE_MASK; |
|
spu_mfc_sr1_set(ctx->spu, sr1); |
|
|
|
out: |
|
return ret; |
|
} |
|
|
|
static int spu_run_init(struct spu_context *ctx, u32 *npc) |
|
{ |
|
unsigned long runcntl = SPU_RUNCNTL_RUNNABLE; |
|
int ret; |
|
|
|
spuctx_switch_state(ctx, SPU_UTIL_SYSTEM); |
|
|
|
/* |
|
* NOSCHED is synchronous scheduling with respect to the caller. |
|
* The caller waits for the context to be loaded. |
|
*/ |
|
if (ctx->flags & SPU_CREATE_NOSCHED) { |
|
if (ctx->state == SPU_STATE_SAVED) { |
|
ret = spu_activate(ctx, 0); |
|
if (ret) |
|
return ret; |
|
} |
|
} |
|
|
|
/* |
|
* Apply special setup as required. |
|
*/ |
|
if (ctx->flags & SPU_CREATE_ISOLATE) { |
|
if (!(ctx->ops->status_read(ctx) & SPU_STATUS_ISOLATED_STATE)) { |
|
ret = spu_setup_isolated(ctx); |
|
if (ret) |
|
return ret; |
|
} |
|
|
|
/* |
|
* If userspace has set the runcntrl register (eg, to |
|
* issue an isolated exit), we need to re-set it here |
|
*/ |
|
runcntl = ctx->ops->runcntl_read(ctx) & |
|
(SPU_RUNCNTL_RUNNABLE | SPU_RUNCNTL_ISOLATE); |
|
if (runcntl == 0) |
|
runcntl = SPU_RUNCNTL_RUNNABLE; |
|
} else { |
|
unsigned long privcntl; |
|
|
|
if (test_thread_flag(TIF_SINGLESTEP)) |
|
privcntl = SPU_PRIVCNTL_MODE_SINGLE_STEP; |
|
else |
|
privcntl = SPU_PRIVCNTL_MODE_NORMAL; |
|
|
|
ctx->ops->privcntl_write(ctx, privcntl); |
|
ctx->ops->npc_write(ctx, *npc); |
|
} |
|
|
|
ctx->ops->runcntl_write(ctx, runcntl); |
|
|
|
if (ctx->flags & SPU_CREATE_NOSCHED) { |
|
spuctx_switch_state(ctx, SPU_UTIL_USER); |
|
} else { |
|
|
|
if (ctx->state == SPU_STATE_SAVED) { |
|
ret = spu_activate(ctx, 0); |
|
if (ret) |
|
return ret; |
|
} else { |
|
spuctx_switch_state(ctx, SPU_UTIL_USER); |
|
} |
|
} |
|
|
|
set_bit(SPU_SCHED_SPU_RUN, &ctx->sched_flags); |
|
return 0; |
|
} |
|
|
|
static int spu_run_fini(struct spu_context *ctx, u32 *npc, |
|
u32 *status) |
|
{ |
|
int ret = 0; |
|
|
|
spu_del_from_rq(ctx); |
|
|
|
*status = ctx->ops->status_read(ctx); |
|
*npc = ctx->ops->npc_read(ctx); |
|
|
|
spuctx_switch_state(ctx, SPU_UTIL_IDLE_LOADED); |
|
clear_bit(SPU_SCHED_SPU_RUN, &ctx->sched_flags); |
|
spu_switch_log_notify(NULL, ctx, SWITCH_LOG_EXIT, *status); |
|
spu_release(ctx); |
|
|
|
if (signal_pending(current)) |
|
ret = -ERESTARTSYS; |
|
|
|
return ret; |
|
} |
|
|
|
/* |
|
* SPU syscall restarting is tricky because we violate the basic |
|
* assumption that the signal handler is running on the interrupted |
|
* thread. Here instead, the handler runs on PowerPC user space code, |
|
* while the syscall was called from the SPU. |
|
* This means we can only do a very rough approximation of POSIX |
|
* signal semantics. |
|
*/ |
|
static int spu_handle_restartsys(struct spu_context *ctx, long *spu_ret, |
|
unsigned int *npc) |
|
{ |
|
int ret; |
|
|
|
switch (*spu_ret) { |
|
case -ERESTARTSYS: |
|
case -ERESTARTNOINTR: |
|
/* |
|
* Enter the regular syscall restarting for |
|
* sys_spu_run, then restart the SPU syscall |
|
* callback. |
|
*/ |
|
*npc -= 8; |
|
ret = -ERESTARTSYS; |
|
break; |
|
case -ERESTARTNOHAND: |
|
case -ERESTART_RESTARTBLOCK: |
|
/* |
|
* Restart block is too hard for now, just return -EINTR |
|
* to the SPU. |
|
* ERESTARTNOHAND comes from sys_pause, we also return |
|
* -EINTR from there. |
|
* Assume that we need to be restarted ourselves though. |
|
*/ |
|
*spu_ret = -EINTR; |
|
ret = -ERESTARTSYS; |
|
break; |
|
default: |
|
printk(KERN_WARNING "%s: unexpected return code %ld\n", |
|
__func__, *spu_ret); |
|
ret = 0; |
|
} |
|
return ret; |
|
} |
|
|
|
static int spu_process_callback(struct spu_context *ctx) |
|
{ |
|
struct spu_syscall_block s; |
|
u32 ls_pointer, npc; |
|
void __iomem *ls; |
|
long spu_ret; |
|
int ret; |
|
|
|
/* get syscall block from local store */ |
|
npc = ctx->ops->npc_read(ctx) & ~3; |
|
ls = (void __iomem *)ctx->ops->get_ls(ctx); |
|
ls_pointer = in_be32(ls + npc); |
|
if (ls_pointer > (LS_SIZE - sizeof(s))) |
|
return -EFAULT; |
|
memcpy_fromio(&s, ls + ls_pointer, sizeof(s)); |
|
|
|
/* do actual syscall without pinning the spu */ |
|
ret = 0; |
|
spu_ret = -ENOSYS; |
|
npc += 4; |
|
|
|
if (s.nr_ret < NR_syscalls) { |
|
spu_release(ctx); |
|
/* do actual system call from here */ |
|
spu_ret = spu_sys_callback(&s); |
|
if (spu_ret <= -ERESTARTSYS) { |
|
ret = spu_handle_restartsys(ctx, &spu_ret, &npc); |
|
} |
|
mutex_lock(&ctx->state_mutex); |
|
if (ret == -ERESTARTSYS) |
|
return ret; |
|
} |
|
|
|
/* need to re-get the ls, as it may have changed when we released the |
|
* spu */ |
|
ls = (void __iomem *)ctx->ops->get_ls(ctx); |
|
|
|
/* write result, jump over indirect pointer */ |
|
memcpy_toio(ls + ls_pointer, &spu_ret, sizeof(spu_ret)); |
|
ctx->ops->npc_write(ctx, npc); |
|
ctx->ops->runcntl_write(ctx, SPU_RUNCNTL_RUNNABLE); |
|
return ret; |
|
} |
|
|
|
long spufs_run_spu(struct spu_context *ctx, u32 *npc, u32 *event) |
|
{ |
|
int ret; |
|
u32 status; |
|
|
|
if (mutex_lock_interruptible(&ctx->run_mutex)) |
|
return -ERESTARTSYS; |
|
|
|
ctx->event_return = 0; |
|
|
|
ret = spu_acquire(ctx); |
|
if (ret) |
|
goto out_unlock; |
|
|
|
spu_enable_spu(ctx); |
|
|
|
spu_update_sched_info(ctx); |
|
|
|
ret = spu_run_init(ctx, npc); |
|
if (ret) { |
|
spu_release(ctx); |
|
goto out; |
|
} |
|
|
|
do { |
|
ret = spufs_wait(ctx->stop_wq, spu_stopped(ctx, &status)); |
|
if (unlikely(ret)) { |
|
/* |
|
* This is nasty: we need the state_mutex for all the |
|
* bookkeeping even if the syscall was interrupted by |
|
* a signal. ewww. |
|
*/ |
|
mutex_lock(&ctx->state_mutex); |
|
break; |
|
} |
|
if (unlikely(test_and_clear_bit(SPU_SCHED_NOTIFY_ACTIVE, |
|
&ctx->sched_flags))) { |
|
if (!(status & SPU_STATUS_STOPPED_BY_STOP)) |
|
continue; |
|
} |
|
|
|
spuctx_switch_state(ctx, SPU_UTIL_SYSTEM); |
|
|
|
if ((status & SPU_STATUS_STOPPED_BY_STOP) && |
|
(status >> SPU_STOP_STATUS_SHIFT == 0x2104)) { |
|
ret = spu_process_callback(ctx); |
|
if (ret) |
|
break; |
|
status &= ~SPU_STATUS_STOPPED_BY_STOP; |
|
} |
|
ret = spufs_handle_class1(ctx); |
|
if (ret) |
|
break; |
|
|
|
ret = spufs_handle_class0(ctx); |
|
if (ret) |
|
break; |
|
|
|
if (signal_pending(current)) |
|
ret = -ERESTARTSYS; |
|
} while (!ret && !(status & (SPU_STATUS_STOPPED_BY_STOP | |
|
SPU_STATUS_STOPPED_BY_HALT | |
|
SPU_STATUS_SINGLE_STEP))); |
|
|
|
spu_disable_spu(ctx); |
|
ret = spu_run_fini(ctx, npc, &status); |
|
spu_yield(ctx); |
|
|
|
if ((status & SPU_STATUS_STOPPED_BY_STOP) && |
|
(((status >> SPU_STOP_STATUS_SHIFT) & 0x3f00) == 0x2100)) |
|
ctx->stats.libassist++; |
|
|
|
if ((ret == 0) || |
|
((ret == -ERESTARTSYS) && |
|
((status & SPU_STATUS_STOPPED_BY_HALT) || |
|
(status & SPU_STATUS_SINGLE_STEP) || |
|
((status & SPU_STATUS_STOPPED_BY_STOP) && |
|
(status >> SPU_STOP_STATUS_SHIFT != 0x2104))))) |
|
ret = status; |
|
|
|
/* Note: we don't need to force_sig SIGTRAP on single-step |
|
* since we have TIF_SINGLESTEP set, thus the kernel will do |
|
* it upon return from the syscall anyway. |
|
*/ |
|
if (unlikely(status & SPU_STATUS_SINGLE_STEP)) |
|
ret = -ERESTARTSYS; |
|
|
|
else if (unlikely((status & SPU_STATUS_STOPPED_BY_STOP) |
|
&& (status >> SPU_STOP_STATUS_SHIFT) == 0x3fff)) { |
|
force_sig(SIGTRAP); |
|
ret = -ERESTARTSYS; |
|
} |
|
|
|
out: |
|
*event = ctx->event_return; |
|
out_unlock: |
|
mutex_unlock(&ctx->run_mutex); |
|
return ret; |
|
}
|
|
|