static int __spu_trap_data_map(struct spu *spu, unsigned long ea, u64 dsisr) { pr_debug("%s, %lx, %lx\n", __FUNCTION__, dsisr, ea); /* Handle kernel space hash faults immediately. User hash faults need to be deferred to process context. */ if ((dsisr & MFC_DSISR_PTE_NOT_FOUND) && REGION_ID(ea) != USER_REGION_ID && hash_page(ea, _PAGE_PRESENT, 0x300) == 0) { spu_restart_dma(spu); return 0; } if (test_bit(SPU_CONTEXT_SWITCH_ACTIVE, &spu->flags)) { printk("%s: invalid access during switch!\n", __func__); return 1; } spu->dar = ea; spu->dsisr = dsisr; mb(); if (spu->stop_callback) spu->stop_callback(spu); return 0; }
int spufs_handle_class1(struct spu_context *ctx) { u64 ea, dsisr, access; unsigned long flags; unsigned flt = 0; int ret; ea = ctx->csa.class_1_dar; dsisr = ctx->csa.class_1_dsisr; if (!(dsisr & (MFC_DSISR_PTE_NOT_FOUND | MFC_DSISR_ACCESS_DENIED))) return 0; spuctx_switch_state(ctx, SPU_UTIL_IOWAIT); pr_debug("ctx %p: ea %016llx, dsisr %016llx state %d\n", ctx, ea, dsisr, ctx->state); ctx->stats.hash_flt++; if (ctx->state == SPU_STATE_RUNNABLE) ctx->spu->stats.hash_flt++; spu_release(ctx); access = (_PAGE_PRESENT | _PAGE_USER); access |= (dsisr & MFC_DSISR_ACCESS_PUT) ? _PAGE_RW : 0UL; local_irq_save(flags); ret = hash_page(ea, access, 0x300); local_irq_restore(flags); if (ret) ret = spu_handle_mm_fault(current->mm, ea, dsisr, &flt); mutex_lock(&ctx->state_mutex); ctx->csa.class_1_dar = ctx->csa.class_1_dsisr = 0; if (!ret) { if (flt & VM_FAULT_MAJOR) ctx->stats.maj_flt++; else ctx->stats.min_flt++; if (ctx->state == SPU_STATE_RUNNABLE) { if (flt & VM_FAULT_MAJOR) ctx->spu->stats.maj_flt++; else ctx->spu->stats.min_flt++; } if (ctx->spu) ctx->ops->restart_dma(ctx); } else spufs_handle_event(ctx, ea, SPE_EVENT_SPE_DATA_STORAGE); spuctx_switch_state(ctx, SPU_UTIL_SYSTEM); return ret; }
/* * bottom half handler for page faults, we can't do this from * interrupt context, since we might need to sleep. * we also need to give up the mutex so we can get scheduled * out while waiting for the backing store. * * TODO: try calling hash_page from the interrupt handler first * in order to speed up the easy case. */ int spufs_handle_class1(struct spu_context *ctx) { u64 ea, dsisr, access; unsigned long flags; unsigned flt = 0; int ret; /* * dar and dsisr get passed from the registers * to the spu_context, to this function, but not * back to the spu if it gets scheduled again. * * if we don't handle the fault for a saved context * in time, we can still expect to get the same fault * the immediately after the context restore. */ ea = ctx->csa.class_1_dar; dsisr = ctx->csa.class_1_dsisr; if (!(dsisr & (MFC_DSISR_PTE_NOT_FOUND | MFC_DSISR_ACCESS_DENIED))) return 0; spuctx_switch_state(ctx, SPU_UTIL_IOWAIT); pr_debug("ctx %p: ea %016llx, dsisr %016llx state %d\n", ctx, ea, dsisr, ctx->state); ctx->stats.hash_flt++; if (ctx->state == SPU_STATE_RUNNABLE) ctx->spu->stats.hash_flt++; /* we must not hold the lock when entering spu_handle_mm_fault */ spu_release(ctx); access = (_PAGE_PRESENT | _PAGE_USER); access |= (dsisr & MFC_DSISR_ACCESS_PUT) ? _PAGE_RW : 0UL; local_irq_save(flags); ret = hash_page(ea, access, 0x300); local_irq_restore(flags); /* hashing failed, so try the actual fault handler */ if (ret) ret = spu_handle_mm_fault(current->mm, ea, dsisr, &flt); /* * 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); /* * Clear dsisr under ctxt lock after handling the fault, so that * time slicing will not preempt the context while the page fault * handler is running. Context switch code removes mappings. */ ctx->csa.class_1_dar = ctx->csa.class_1_dsisr = 0; /* * If we handled the fault successfully and are in runnable * state, restart the DMA. * In case of unhandled error report the problem to user space. */ if (!ret) { if (flt & VM_FAULT_MAJOR) ctx->stats.maj_flt++; else ctx->stats.min_flt++; if (ctx->state == SPU_STATE_RUNNABLE) { if (flt & VM_FAULT_MAJOR) ctx->spu->stats.maj_flt++; else ctx->spu->stats.min_flt++; } if (ctx->spu) ctx->ops->restart_dma(ctx); } else spufs_handle_event(ctx, ea, SPE_EVENT_SPE_DATA_STORAGE); spuctx_switch_state(ctx, SPU_UTIL_SYSTEM); return ret; }