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

TOMOYO Linux Cross Reference
Linux/arch/powerpc/mm/icswx.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  *  ICSWX and ACOP Management
  3  *
  4  *  Copyright (C) 2011 Anton Blanchard, IBM Corp. <anton@samba.org>
  5  *
  6  *  This program is free software; you can redistribute it and/or
  7  *  modify it under the terms of the GNU General Public License
  8  *  as published by the Free Software Foundation; either version
  9  *  2 of the License, or (at your option) any later version.
 10  *
 11  */
 12 
 13 #include <linux/sched.h>
 14 #include <linux/kernel.h>
 15 #include <linux/errno.h>
 16 #include <linux/types.h>
 17 #include <linux/mm.h>
 18 #include <linux/spinlock.h>
 19 #include <linux/module.h>
 20 #include <linux/uaccess.h>
 21 
 22 #include "icswx.h"
 23 
 24 /*
 25  * The processor and its L2 cache cause the icswx instruction to
 26  * generate a COP_REQ transaction on PowerBus. The transaction has no
 27  * address, and the processor does not perform an MMU access to
 28  * authenticate the transaction. The command portion of the PowerBus
 29  * COP_REQ transaction includes the LPAR_ID (LPID) and the coprocessor
 30  * Process ID (PID), which the coprocessor compares to the authorized
 31  * LPID and PID held in the coprocessor, to determine if the process
 32  * is authorized to generate the transaction.  The data of the COP_REQ
 33  * transaction is 128-byte or less in size and is placed in cacheable
 34  * memory on a 128-byte cache line boundary.
 35  *
 36  * The task to use a coprocessor should use use_cop() to mark the use
 37  * of the Coprocessor Type (CT) and context switching. On a server
 38  * class processor, the PID register is used only for coprocessor
 39  * management + * and so a coprocessor PID is allocated before
 40  * executing icswx + * instruction. Drop_cop() is used to free the
 41  * coprocessor PID.
 42  *
 43  * Example:
 44  * Host Fabric Interface (HFI) is a PowerPC network coprocessor.
 45  * Each HFI have multiple windows. Each HFI window serves as a
 46  * network device sending to and receiving from HFI network.
 47  * HFI immediate send function uses icswx instruction. The immediate
 48  * send function allows small (single cache-line) packets be sent
 49  * without using the regular HFI send FIFO and doorbell, which are
 50  * much slower than immediate send.
 51  *
 52  * For each task intending to use HFI immediate send, the HFI driver
 53  * calls use_cop() to obtain a coprocessor PID for the task.
 54  * The HFI driver then allocate a free HFI window and save the
 55  * coprocessor PID to the HFI window to allow the task to use the
 56  * HFI window.
 57  *
 58  * The HFI driver repeatedly creates immediate send packets and
 59  * issues icswx instruction to send data through the HFI window.
 60  * The HFI compares the coprocessor PID in the CPU PID register
 61  * to the PID held in the HFI window to determine if the transaction
 62  * is allowed.
 63  *
 64  * When the task to release the HFI window, the HFI driver calls
 65  * drop_cop() to release the coprocessor PID.
 66  */
 67 
 68 void switch_cop(struct mm_struct *next)
 69 {
 70 #ifdef CONFIG_PPC_ICSWX_PID
 71         mtspr(SPRN_PID, next->context.cop_pid);
 72 #endif
 73         mtspr(SPRN_ACOP, next->context.acop);
 74 }
 75 
 76 /**
 77  * Start using a coprocessor.
 78  * @acop: mask of coprocessor to be used.
 79  * @mm: The mm the coprocessor to associate with. Most likely current mm.
 80  *
 81  * Return a positive PID if successful. Negative errno otherwise.
 82  * The returned PID will be fed to the coprocessor to determine if an
 83  * icswx transaction is authenticated.
 84  */
 85 int use_cop(unsigned long acop, struct mm_struct *mm)
 86 {
 87         int ret;
 88 
 89         if (!cpu_has_feature(CPU_FTR_ICSWX))
 90                 return -ENODEV;
 91 
 92         if (!mm || !acop)
 93                 return -EINVAL;
 94 
 95         /* The page_table_lock ensures mm_users won't change under us */
 96         spin_lock(&mm->page_table_lock);
 97         spin_lock(mm->context.cop_lockp);
 98 
 99         ret = get_cop_pid(mm);
100         if (ret < 0)
101                 goto out;
102 
103         /* update acop */
104         mm->context.acop |= acop;
105 
106         sync_cop(mm);
107 
108         /*
109          * If this is a threaded process then there might be other threads
110          * running. We need to send an IPI to force them to pick up any
111          * change in PID and ACOP.
112          */
113         if (atomic_read(&mm->mm_users) > 1)
114                 smp_call_function(sync_cop, mm, 1);
115 
116 out:
117         spin_unlock(mm->context.cop_lockp);
118         spin_unlock(&mm->page_table_lock);
119 
120         return ret;
121 }
122 EXPORT_SYMBOL_GPL(use_cop);
123 
124 /**
125  * Stop using a coprocessor.
126  * @acop: mask of coprocessor to be stopped.
127  * @mm: The mm the coprocessor associated with.
128  */
129 void drop_cop(unsigned long acop, struct mm_struct *mm)
130 {
131         int free_pid;
132 
133         if (!cpu_has_feature(CPU_FTR_ICSWX))
134                 return;
135 
136         if (WARN_ON_ONCE(!mm))
137                 return;
138 
139         /* The page_table_lock ensures mm_users won't change under us */
140         spin_lock(&mm->page_table_lock);
141         spin_lock(mm->context.cop_lockp);
142 
143         mm->context.acop &= ~acop;
144 
145         free_pid = disable_cop_pid(mm);
146         sync_cop(mm);
147 
148         /*
149          * If this is a threaded process then there might be other threads
150          * running. We need to send an IPI to force them to pick up any
151          * change in PID and ACOP.
152          */
153         if (atomic_read(&mm->mm_users) > 1)
154                 smp_call_function(sync_cop, mm, 1);
155 
156         if (free_pid != COP_PID_NONE)
157                 free_cop_pid(free_pid);
158 
159         spin_unlock(mm->context.cop_lockp);
160         spin_unlock(&mm->page_table_lock);
161 }
162 EXPORT_SYMBOL_GPL(drop_cop);
163 
164 static int acop_use_cop(int ct)
165 {
166         /* There is no alternate policy, yet */
167         return -1;
168 }
169 
170 /*
171  * Get the instruction word at the NIP
172  */
173 static u32 acop_get_inst(struct pt_regs *regs)
174 {
175         u32 inst;
176         u32 __user *p;
177 
178         p = (u32 __user *)regs->nip;
179         if (!access_ok(VERIFY_READ, p, sizeof(*p)))
180                 return 0;
181 
182         if (__get_user(inst, p))
183                 return 0;
184 
185         return inst;
186 }
187 
188 /**
189  * @regs: regsiters at time of interrupt
190  * @address: storage address
191  * @error_code: Fault code, usually the DSISR or ESR depending on
192  *              processor type
193  *
194  * Return 0 if we are able to resolve the data storage fault that
195  * results from a CT miss in the ACOP register.
196  */
197 int acop_handle_fault(struct pt_regs *regs, unsigned long address,
198                       unsigned long error_code)
199 {
200         int ct;
201         u32 inst = 0;
202 
203         if (!cpu_has_feature(CPU_FTR_ICSWX)) {
204                 pr_info("No coprocessors available");
205                 _exception(SIGILL, regs, ILL_ILLOPN, address);
206         }
207 
208         if (!user_mode(regs)) {
209                 /* this could happen if the HV denies the
210                  * kernel access, for now we just die */
211                 die("ICSWX from kernel failed", regs, SIGSEGV);
212         }
213 
214         /* Some implementations leave us a hint for the CT */
215         ct = ICSWX_GET_CT_HINT(error_code);
216         if (ct < 0) {
217                 /* we have to peek at the instruction word to figure out CT */
218                 u32 ccw;
219                 u32 rs;
220 
221                 inst = acop_get_inst(regs);
222                 if (inst == 0)
223                         return -1;
224 
225                 rs = (inst >> (31 - 10)) & 0x1f;
226                 ccw = regs->gpr[rs];
227                 ct = (ccw >> 16) & 0x3f;
228         }
229 
230         /*
231          * We could be here because another thread has enabled acop
232          * but the ACOP register has yet to be updated.
233          *
234          * This should have been taken care of by the IPI to sync all
235          * the threads (see smp_call_function(sync_cop, mm, 1)), but
236          * that could take forever if there are a significant amount
237          * of threads.
238          *
239          * Given the number of threads on some of these systems,
240          * perhaps this is the best way to sync ACOP rather than whack
241          * every thread with an IPI.
242          */
243         if ((acop_copro_type_bit(ct) & current->active_mm->context.acop) != 0) {
244                 sync_cop(current->active_mm);
245                 return 0;
246         }
247 
248         /* check for alternate policy */
249         if (!acop_use_cop(ct))
250                 return 0;
251 
252         /* at this point the CT is unknown to the system */
253         pr_warn("%s[%d]: Coprocessor %d is unavailable\n",
254                 current->comm, current->pid, ct);
255 
256         /* get inst if we don't already have it */
257         if (inst == 0) {
258                 inst = acop_get_inst(regs);
259                 if (inst == 0)
260                         return -1;
261         }
262 
263         /* Check if the instruction is the "record form" */
264         if (inst & 1) {
265                 /*
266                  * the instruction is "record" form so we can reject
267                  * using CR0
268                  */
269                 regs->ccr &= ~(0xful << 28);
270                 regs->ccr |= ICSWX_RC_NOT_FOUND << 28;
271 
272                 /* Move on to the next instruction */
273                 regs->nip += 4;
274         } else {
275                 /*
276                  * There is no architected mechanism to report a bad
277                  * CT so we could either SIGILL or report nothing.
278                  * Since the non-record version should only bu used
279                  * for "hints" or "don't care" we should probably do
280                  * nothing.  However, I could see how some people
281                  * might want an SIGILL so it here if you want it.
282                  */
283 #ifdef CONFIG_PPC_ICSWX_USE_SIGILL
284                 _exception(SIGILL, regs, ILL_ILLOPN, address);
285 #else
286                 regs->nip += 4;
287 #endif
288         }
289 
290         return 0;
291 }
292 EXPORT_SYMBOL_GPL(acop_handle_fault);
293 

~ [ 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