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

TOMOYO Linux Cross Reference
Linux/arch/sparc/kernel/ptrace_32.c

Version: ~ [ linux-5.4-rc3 ] ~ [ linux-5.3.6 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.79 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.149 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.196 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.196 ] ~ [ 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.75 ] ~ [ 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 /* ptrace.c: Sparc process tracing support.
  2  *
  3  * Copyright (C) 1996, 2008 David S. Miller (davem@davemloft.net)
  4  *
  5  * Based upon code written by Ross Biro, Linus Torvalds, Bob Manson,
  6  * and David Mosberger.
  7  *
  8  * Added Linux support -miguel (weird, eh?, the original code was meant
  9  * to emulate SunOS).
 10  */
 11 
 12 #include <linux/kernel.h>
 13 #include <linux/sched.h>
 14 #include <linux/mm.h>
 15 #include <linux/errno.h>
 16 #include <linux/ptrace.h>
 17 #include <linux/user.h>
 18 #include <linux/smp.h>
 19 #include <linux/security.h>
 20 #include <linux/signal.h>
 21 #include <linux/regset.h>
 22 #include <linux/elf.h>
 23 #include <linux/tracehook.h>
 24 
 25 #include <asm/pgtable.h>
 26 #include <asm/uaccess.h>
 27 #include <asm/cacheflush.h>
 28 
 29 #include "kernel.h"
 30 
 31 /* #define ALLOW_INIT_TRACING */
 32 
 33 /*
 34  * Called by kernel/ptrace.c when detaching..
 35  *
 36  * Make sure single step bits etc are not set.
 37  */
 38 void ptrace_disable(struct task_struct *child)
 39 {
 40         /* nothing to do */
 41 }
 42 
 43 enum sparc_regset {
 44         REGSET_GENERAL,
 45         REGSET_FP,
 46 };
 47 
 48 static int genregs32_get(struct task_struct *target,
 49                          const struct user_regset *regset,
 50                          unsigned int pos, unsigned int count,
 51                          void *kbuf, void __user *ubuf)
 52 {
 53         const struct pt_regs *regs = target->thread.kregs;
 54         unsigned long __user *reg_window;
 55         unsigned long *k = kbuf;
 56         unsigned long __user *u = ubuf;
 57         unsigned long reg;
 58 
 59         if (target == current)
 60                 flush_user_windows();
 61 
 62         pos /= sizeof(reg);
 63         count /= sizeof(reg);
 64 
 65         if (kbuf) {
 66                 for (; count > 0 && pos < 16; count--)
 67                         *k++ = regs->u_regs[pos++];
 68 
 69                 reg_window = (unsigned long __user *) regs->u_regs[UREG_I6];
 70                 reg_window -= 16;
 71                 for (; count > 0 && pos < 32; count--) {
 72                         if (get_user(*k++, &reg_window[pos++]))
 73                                 return -EFAULT;
 74                 }
 75         } else {
 76                 for (; count > 0 && pos < 16; count--) {
 77                         if (put_user(regs->u_regs[pos++], u++))
 78                                 return -EFAULT;
 79                 }
 80 
 81                 reg_window = (unsigned long __user *) regs->u_regs[UREG_I6];
 82                 reg_window -= 16;
 83                 for (; count > 0 && pos < 32; count--) {
 84                         if (get_user(reg, &reg_window[pos++]) ||
 85                             put_user(reg, u++))
 86                                 return -EFAULT;
 87                 }
 88         }
 89         while (count > 0) {
 90                 switch (pos) {
 91                 case 32: /* PSR */
 92                         reg = regs->psr;
 93                         break;
 94                 case 33: /* PC */
 95                         reg = regs->pc;
 96                         break;
 97                 case 34: /* NPC */
 98                         reg = regs->npc;
 99                         break;
100                 case 35: /* Y */
101                         reg = regs->y;
102                         break;
103                 case 36: /* WIM */
104                 case 37: /* TBR */
105                         reg = 0;
106                         break;
107                 default:
108                         goto finish;
109                 }
110 
111                 if (kbuf)
112                         *k++ = reg;
113                 else if (put_user(reg, u++))
114                         return -EFAULT;
115                 pos++;
116                 count--;
117         }
118 finish:
119         pos *= sizeof(reg);
120         count *= sizeof(reg);
121 
122         return user_regset_copyout_zero(&pos, &count, &kbuf, &ubuf,
123                                         38 * sizeof(reg), -1);
124 }
125 
126 static int genregs32_set(struct task_struct *target,
127                          const struct user_regset *regset,
128                          unsigned int pos, unsigned int count,
129                          const void *kbuf, const void __user *ubuf)
130 {
131         struct pt_regs *regs = target->thread.kregs;
132         unsigned long __user *reg_window;
133         const unsigned long *k = kbuf;
134         const unsigned long __user *u = ubuf;
135         unsigned long reg;
136 
137         if (target == current)
138                 flush_user_windows();
139 
140         pos /= sizeof(reg);
141         count /= sizeof(reg);
142 
143         if (kbuf) {
144                 for (; count > 0 && pos < 16; count--)
145                         regs->u_regs[pos++] = *k++;
146 
147                 reg_window = (unsigned long __user *) regs->u_regs[UREG_I6];
148                 reg_window -= 16;
149                 for (; count > 0 && pos < 32; count--) {
150                         if (put_user(*k++, &reg_window[pos++]))
151                                 return -EFAULT;
152                 }
153         } else {
154                 for (; count > 0 && pos < 16; count--) {
155                         if (get_user(reg, u++))
156                                 return -EFAULT;
157                         regs->u_regs[pos++] = reg;
158                 }
159 
160                 reg_window = (unsigned long __user *) regs->u_regs[UREG_I6];
161                 reg_window -= 16;
162                 for (; count > 0 && pos < 32; count--) {
163                         if (get_user(reg, u++) ||
164                             put_user(reg, &reg_window[pos++]))
165                                 return -EFAULT;
166                 }
167         }
168         while (count > 0) {
169                 unsigned long psr;
170 
171                 if (kbuf)
172                         reg = *k++;
173                 else if (get_user(reg, u++))
174                         return -EFAULT;
175 
176                 switch (pos) {
177                 case 32: /* PSR */
178                         psr = regs->psr;
179                         psr &= ~(PSR_ICC | PSR_SYSCALL);
180                         psr |= (reg & (PSR_ICC | PSR_SYSCALL));
181                         regs->psr = psr;
182                         break;
183                 case 33: /* PC */
184                         regs->pc = reg;
185                         break;
186                 case 34: /* NPC */
187                         regs->npc = reg;
188                         break;
189                 case 35: /* Y */
190                         regs->y = reg;
191                         break;
192                 case 36: /* WIM */
193                 case 37: /* TBR */
194                         break;
195                 default:
196                         goto finish;
197                 }
198 
199                 pos++;
200                 count--;
201         }
202 finish:
203         pos *= sizeof(reg);
204         count *= sizeof(reg);
205 
206         return user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf,
207                                          38 * sizeof(reg), -1);
208 }
209 
210 static int fpregs32_get(struct task_struct *target,
211                         const struct user_regset *regset,
212                         unsigned int pos, unsigned int count,
213                         void *kbuf, void __user *ubuf)
214 {
215         const unsigned long *fpregs = target->thread.float_regs;
216         int ret = 0;
217 
218 #if 0
219         if (target == current)
220                 save_and_clear_fpu();
221 #endif
222 
223         ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
224                                   fpregs,
225                                   0, 32 * sizeof(u32));
226 
227         if (!ret)
228                 ret = user_regset_copyout_zero(&pos, &count, &kbuf, &ubuf,
229                                                32 * sizeof(u32),
230                                                33 * sizeof(u32));
231         if (!ret)
232                 ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
233                                           &target->thread.fsr,
234                                           33 * sizeof(u32),
235                                           34 * sizeof(u32));
236 
237         if (!ret) {
238                 unsigned long val;
239 
240                 val = (1 << 8) | (8 << 16);
241                 ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
242                                           &val,
243                                           34 * sizeof(u32),
244                                           35 * sizeof(u32));
245         }
246 
247         if (!ret)
248                 ret = user_regset_copyout_zero(&pos, &count, &kbuf, &ubuf,
249                                                35 * sizeof(u32), -1);
250 
251         return ret;
252 }
253 
254 static int fpregs32_set(struct task_struct *target,
255                         const struct user_regset *regset,
256                         unsigned int pos, unsigned int count,
257                         const void *kbuf, const void __user *ubuf)
258 {
259         unsigned long *fpregs = target->thread.float_regs;
260         int ret;
261 
262 #if 0
263         if (target == current)
264                 save_and_clear_fpu();
265 #endif
266         ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
267                                  fpregs,
268                                  0, 32 * sizeof(u32));
269         if (!ret)
270                 user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf,
271                                           32 * sizeof(u32),
272                                           33 * sizeof(u32));
273         if (!ret && count > 0) {
274                 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
275                                          &target->thread.fsr,
276                                          33 * sizeof(u32),
277                                          34 * sizeof(u32));
278         }
279 
280         if (!ret)
281                 ret = user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf,
282                                                 34 * sizeof(u32), -1);
283         return ret;
284 }
285 
286 static const struct user_regset sparc32_regsets[] = {
287         /* Format is:
288          *      G0 --> G7
289          *      O0 --> O7
290          *      L0 --> L7
291          *      I0 --> I7
292          *      PSR, PC, nPC, Y, WIM, TBR
293          */
294         [REGSET_GENERAL] = {
295                 .core_note_type = NT_PRSTATUS,
296                 .n = 38,
297                 .size = sizeof(u32), .align = sizeof(u32),
298                 .get = genregs32_get, .set = genregs32_set
299         },
300         /* Format is:
301          *      F0 --> F31
302          *      empty 32-bit word
303          *      FSR (32--bit word)
304          *      FPU QUEUE COUNT (8-bit char)
305          *      FPU QUEUE ENTRYSIZE (8-bit char)
306          *      FPU ENABLED (8-bit char)
307          *      empty 8-bit char
308          *      FPU QUEUE (64 32-bit ints)
309          */
310         [REGSET_FP] = {
311                 .core_note_type = NT_PRFPREG,
312                 .n = 99,
313                 .size = sizeof(u32), .align = sizeof(u32),
314                 .get = fpregs32_get, .set = fpregs32_set
315         },
316 };
317 
318 static const struct user_regset_view user_sparc32_view = {
319         .name = "sparc", .e_machine = EM_SPARC,
320         .regsets = sparc32_regsets, .n = ARRAY_SIZE(sparc32_regsets)
321 };
322 
323 const struct user_regset_view *task_user_regset_view(struct task_struct *task)
324 {
325         return &user_sparc32_view;
326 }
327 
328 struct fps {
329         unsigned long regs[32];
330         unsigned long fsr;
331         unsigned long flags;
332         unsigned long extra;
333         unsigned long fpqd;
334         struct fq {
335                 unsigned long *insnaddr;
336                 unsigned long insn;
337         } fpq[16];
338 };
339 
340 long arch_ptrace(struct task_struct *child, long request,
341                  unsigned long addr, unsigned long data)
342 {
343         unsigned long addr2 = current->thread.kregs->u_regs[UREG_I4];
344         void __user *addr2p;
345         const struct user_regset_view *view;
346         struct pt_regs __user *pregs;
347         struct fps __user *fps;
348         int ret;
349 
350         view = task_user_regset_view(current);
351         addr2p = (void __user *) addr2;
352         pregs = (struct pt_regs __user *) addr;
353         fps = (struct fps __user *) addr;
354 
355         switch(request) {
356         case PTRACE_GETREGS: {
357                 ret = copy_regset_to_user(child, view, REGSET_GENERAL,
358                                           32 * sizeof(u32),
359                                           4 * sizeof(u32),
360                                           &pregs->psr);
361                 if (!ret)
362                         copy_regset_to_user(child, view, REGSET_GENERAL,
363                                             1 * sizeof(u32),
364                                             15 * sizeof(u32),
365                                             &pregs->u_regs[0]);
366                 break;
367         }
368 
369         case PTRACE_SETREGS: {
370                 ret = copy_regset_from_user(child, view, REGSET_GENERAL,
371                                             32 * sizeof(u32),
372                                             4 * sizeof(u32),
373                                             &pregs->psr);
374                 if (!ret)
375                         copy_regset_from_user(child, view, REGSET_GENERAL,
376                                               1 * sizeof(u32),
377                                               15 * sizeof(u32),
378                                               &pregs->u_regs[0]);
379                 break;
380         }
381 
382         case PTRACE_GETFPREGS: {
383                 ret = copy_regset_to_user(child, view, REGSET_FP,
384                                           0 * sizeof(u32),
385                                           32 * sizeof(u32),
386                                           &fps->regs[0]);
387                 if (!ret)
388                         ret = copy_regset_to_user(child, view, REGSET_FP,
389                                                   33 * sizeof(u32),
390                                                   1 * sizeof(u32),
391                                                   &fps->fsr);
392 
393                 if (!ret) {
394                         if (__put_user(0, &fps->fpqd) ||
395                             __put_user(0, &fps->flags) ||
396                             __put_user(0, &fps->extra) ||
397                             clear_user(fps->fpq, sizeof(fps->fpq)))
398                                 ret = -EFAULT;
399                 }
400                 break;
401         }
402 
403         case PTRACE_SETFPREGS: {
404                 ret = copy_regset_from_user(child, view, REGSET_FP,
405                                             0 * sizeof(u32),
406                                             32 * sizeof(u32),
407                                             &fps->regs[0]);
408                 if (!ret)
409                         ret = copy_regset_from_user(child, view, REGSET_FP,
410                                                     33 * sizeof(u32),
411                                                     1 * sizeof(u32),
412                                                     &fps->fsr);
413                 break;
414         }
415 
416         case PTRACE_READTEXT:
417         case PTRACE_READDATA:
418                 ret = ptrace_readdata(child, addr, addr2p, data);
419 
420                 if (ret == data)
421                         ret = 0;
422                 else if (ret >= 0)
423                         ret = -EIO;
424                 break;
425 
426         case PTRACE_WRITETEXT:
427         case PTRACE_WRITEDATA:
428                 ret = ptrace_writedata(child, addr2p, addr, data);
429 
430                 if (ret == data)
431                         ret = 0;
432                 else if (ret >= 0)
433                         ret = -EIO;
434                 break;
435 
436         default:
437                 if (request == PTRACE_SPARC_DETACH)
438                         request = PTRACE_DETACH;
439                 ret = ptrace_request(child, request, addr, data);
440                 break;
441         }
442 
443         return ret;
444 }
445 
446 asmlinkage int syscall_trace(struct pt_regs *regs, int syscall_exit_p)
447 {
448         int ret = 0;
449 
450         if (test_thread_flag(TIF_SYSCALL_TRACE)) {
451                 if (syscall_exit_p)
452                         tracehook_report_syscall_exit(regs, 0);
453                 else
454                         ret = tracehook_report_syscall_entry(regs);
455         }
456 
457         return ret;
458 }
459 

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