~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/powerpc/platforms/cell/spufs/fault.c

Version: ~ [ linux-5.4-rc7 ] ~ [ linux-5.3.11 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.84 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.154 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.201 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.201 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.77 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp