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

TOMOYO Linux Cross Reference
Linux/arch/tile/kernel/ptrace.c

Version: ~ [ linux-6.2-rc3 ] ~ [ linux-6.1.5 ] ~ [ linux-6.0.19 ] ~ [ linux-5.19.17 ] ~ [ linux-5.18.19 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.87 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.162 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.228 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.269 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.302 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.337 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.302 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * Copyright 2010 Tilera Corporation. All Rights Reserved.
  3  *
  4  *   This program is free software; you can redistribute it and/or
  5  *   modify it under the terms of the GNU General Public License
  6  *   as published by the Free Software Foundation, version 2.
  7  *
  8  *   This program is distributed in the hope that it will be useful, but
  9  *   WITHOUT ANY WARRANTY; without even the implied warranty of
 10  *   MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
 11  *   NON INFRINGEMENT.  See the GNU General Public License for
 12  *   more details.
 13  *
 14  * Copied from i386: Ross Biro 1/23/92
 15  */
 16 
 17 #include <linux/kernel.h>
 18 #include <linux/ptrace.h>
 19 #include <linux/kprobes.h>
 20 #include <linux/compat.h>
 21 #include <linux/uaccess.h>
 22 #include <linux/regset.h>
 23 #include <linux/elf.h>
 24 #include <linux/tracehook.h>
 25 #include <linux/context_tracking.h>
 26 #include <asm/traps.h>
 27 #include <arch/chip.h>
 28 
 29 #define CREATE_TRACE_POINTS
 30 #include <trace/events/syscalls.h>
 31 
 32 void user_enable_single_step(struct task_struct *child)
 33 {
 34         set_tsk_thread_flag(child, TIF_SINGLESTEP);
 35 }
 36 
 37 void user_disable_single_step(struct task_struct *child)
 38 {
 39         clear_tsk_thread_flag(child, TIF_SINGLESTEP);
 40 }
 41 
 42 /*
 43  * Called by kernel/ptrace.c when detaching..
 44  */
 45 void ptrace_disable(struct task_struct *child)
 46 {
 47         clear_tsk_thread_flag(child, TIF_SINGLESTEP);
 48 
 49         /*
 50          * These two are currently unused, but will be set by arch_ptrace()
 51          * and used in the syscall assembly when we do support them.
 52          */
 53         clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
 54 }
 55 
 56 /*
 57  * Get registers from task and ready the result for userspace.
 58  * Note that we localize the API issues to getregs() and putregs() at
 59  * some cost in performance, e.g. we need a full pt_regs copy for
 60  * PEEKUSR, and two copies for POKEUSR.  But in general we expect
 61  * GETREGS/PUTREGS to be the API of choice anyway.
 62  */
 63 static char *getregs(struct task_struct *child, struct pt_regs *uregs)
 64 {
 65         *uregs = *task_pt_regs(child);
 66 
 67         /* Set up flags ABI bits. */
 68         uregs->flags = 0;
 69 #ifdef CONFIG_COMPAT
 70         if (task_thread_info(child)->status & TS_COMPAT)
 71                 uregs->flags |= PT_FLAGS_COMPAT;
 72 #endif
 73 
 74         return (char *)uregs;
 75 }
 76 
 77 /* Put registers back to task. */
 78 static void putregs(struct task_struct *child, struct pt_regs *uregs)
 79 {
 80         struct pt_regs *regs = task_pt_regs(child);
 81 
 82         /* Don't allow overwriting the kernel-internal flags word. */
 83         uregs->flags = regs->flags;
 84 
 85         /* Only allow setting the ICS bit in the ex1 word. */
 86         uregs->ex1 = PL_ICS_EX1(USER_PL, EX1_ICS(uregs->ex1));
 87 
 88         *regs = *uregs;
 89 }
 90 
 91 enum tile_regset {
 92         REGSET_GPR,
 93 };
 94 
 95 static int tile_gpr_get(struct task_struct *target,
 96                           const struct user_regset *regset,
 97                           unsigned int pos, unsigned int count,
 98                           void *kbuf, void __user *ubuf)
 99 {
100         struct pt_regs regs;
101 
102         getregs(target, &regs);
103 
104         return user_regset_copyout(&pos, &count, &kbuf, &ubuf, &regs, 0,
105                                    sizeof(regs));
106 }
107 
108 static int tile_gpr_set(struct task_struct *target,
109                           const struct user_regset *regset,
110                           unsigned int pos, unsigned int count,
111                           const void *kbuf, const void __user *ubuf)
112 {
113         int ret;
114         struct pt_regs regs = *task_pt_regs(target);
115 
116         ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, &regs, 0,
117                                  sizeof(regs));
118         if (ret)
119                 return ret;
120 
121         putregs(target, &regs);
122 
123         return 0;
124 }
125 
126 static const struct user_regset tile_user_regset[] = {
127         [REGSET_GPR] = {
128                 .core_note_type = NT_PRSTATUS,
129                 .n = ELF_NGREG,
130                 .size = sizeof(elf_greg_t),
131                 .align = sizeof(elf_greg_t),
132                 .get = tile_gpr_get,
133                 .set = tile_gpr_set,
134         },
135 };
136 
137 static const struct user_regset_view tile_user_regset_view = {
138         .name = CHIP_ARCH_NAME,
139         .e_machine = ELF_ARCH,
140         .ei_osabi = ELF_OSABI,
141         .regsets = tile_user_regset,
142         .n = ARRAY_SIZE(tile_user_regset),
143 };
144 
145 const struct user_regset_view *task_user_regset_view(struct task_struct *task)
146 {
147         return &tile_user_regset_view;
148 }
149 
150 long arch_ptrace(struct task_struct *child, long request,
151                  unsigned long addr, unsigned long data)
152 {
153         unsigned long __user *datap = (long __user __force *)data;
154         unsigned long tmp;
155         long ret = -EIO;
156         char *childreg;
157         struct pt_regs copyregs;
158 
159         switch (request) {
160 
161         case PTRACE_PEEKUSR:  /* Read register from pt_regs. */
162                 if (addr >= PTREGS_SIZE)
163                         break;
164                 childreg = getregs(child, &copyregs) + addr;
165 #ifdef CONFIG_COMPAT
166                 if (is_compat_task()) {
167                         if (addr & (sizeof(compat_long_t)-1))
168                                 break;
169                         ret = put_user(*(compat_long_t *)childreg,
170                                        (compat_long_t __user *)datap);
171                 } else
172 #endif
173                 {
174                         if (addr & (sizeof(long)-1))
175                                 break;
176                         ret = put_user(*(long *)childreg, datap);
177                 }
178                 break;
179 
180         case PTRACE_POKEUSR:  /* Write register in pt_regs. */
181                 if (addr >= PTREGS_SIZE)
182                         break;
183                 childreg = getregs(child, &copyregs) + addr;
184 #ifdef CONFIG_COMPAT
185                 if (is_compat_task()) {
186                         if (addr & (sizeof(compat_long_t)-1))
187                                 break;
188                         *(compat_long_t *)childreg = data;
189                 } else
190 #endif
191                 {
192                         if (addr & (sizeof(long)-1))
193                                 break;
194                         *(long *)childreg = data;
195                 }
196                 putregs(child, &copyregs);
197                 ret = 0;
198                 break;
199 
200         case PTRACE_GETREGS:  /* Get all registers from the child. */
201                 ret = copy_regset_to_user(child, &tile_user_regset_view,
202                                           REGSET_GPR, 0,
203                                           sizeof(struct pt_regs), datap);
204                 break;
205 
206         case PTRACE_SETREGS:  /* Set all registers in the child. */
207                 ret = copy_regset_from_user(child, &tile_user_regset_view,
208                                             REGSET_GPR, 0,
209                                             sizeof(struct pt_regs), datap);
210                 break;
211 
212         case PTRACE_GETFPREGS:  /* Get the child FPU state. */
213         case PTRACE_SETFPREGS:  /* Set the child FPU state. */
214                 break;
215 
216         case PTRACE_SETOPTIONS:
217                 /* Support TILE-specific ptrace options. */
218                 BUILD_BUG_ON(PTRACE_O_MASK_TILE & PTRACE_O_MASK);
219                 tmp = data & PTRACE_O_MASK_TILE;
220                 data &= ~PTRACE_O_MASK_TILE;
221                 ret = ptrace_request(child, request, addr, data);
222                 if (ret == 0) {
223                         unsigned int flags = child->ptrace;
224                         flags &= ~(PTRACE_O_MASK_TILE << PT_OPT_FLAG_SHIFT);
225                         flags |= (tmp << PT_OPT_FLAG_SHIFT);
226                         child->ptrace = flags;
227                 }
228                 break;
229 
230         default:
231 #ifdef CONFIG_COMPAT
232                 if (task_thread_info(current)->status & TS_COMPAT) {
233                         ret = compat_ptrace_request(child, request,
234                                                     addr, data);
235                         break;
236                 }
237 #endif
238                 ret = ptrace_request(child, request, addr, data);
239                 break;
240         }
241 
242         return ret;
243 }
244 
245 #ifdef CONFIG_COMPAT
246 /* Not used; we handle compat issues in arch_ptrace() directly. */
247 long compat_arch_ptrace(struct task_struct *child, compat_long_t request,
248                                compat_ulong_t addr, compat_ulong_t data)
249 {
250         BUG();
251 }
252 #endif
253 
254 int do_syscall_trace_enter(struct pt_regs *regs)
255 {
256         u32 work = ACCESS_ONCE(current_thread_info()->flags);
257 
258         if ((work & _TIF_SYSCALL_TRACE) &&
259             tracehook_report_syscall_entry(regs)) {
260                 regs->regs[TREG_SYSCALL_NR] = -1;
261                 return -1;
262         }
263 
264         if (secure_computing(NULL) == -1)
265                 return -1;
266 
267         if (work & _TIF_SYSCALL_TRACEPOINT)
268                 trace_sys_enter(regs, regs->regs[TREG_SYSCALL_NR]);
269 
270         return regs->regs[TREG_SYSCALL_NR];
271 }
272 
273 void do_syscall_trace_exit(struct pt_regs *regs)
274 {
275         long errno;
276 
277         /*
278          * The standard tile calling convention returns the value (or negative
279          * errno) in r0, and zero (or positive errno) in r1.
280          * It saves a couple of cycles on the hot path to do this work in
281          * registers only as we return, rather than updating the in-memory
282          * struct ptregs.
283          */
284         errno = (long) regs->regs[0];
285         if (errno < 0 && errno > -4096)
286                 regs->regs[1] = -errno;
287         else
288                 regs->regs[1] = 0;
289 
290         if (test_thread_flag(TIF_SYSCALL_TRACE))
291                 tracehook_report_syscall_exit(regs, 0);
292 
293         if (test_thread_flag(TIF_SYSCALL_TRACEPOINT))
294                 trace_sys_exit(regs, regs->regs[0]);
295 }
296 
297 void send_sigtrap(struct task_struct *tsk, struct pt_regs *regs)
298 {
299         struct siginfo info;
300 
301         memset(&info, 0, sizeof(info));
302         info.si_signo = SIGTRAP;
303         info.si_code  = TRAP_BRKPT;
304         info.si_addr  = (void __user *) regs->pc;
305 
306         /* Send us the fakey SIGTRAP */
307         force_sig_info(SIGTRAP, &info, tsk);
308 }
309 
310 /* Handle synthetic interrupt delivered only by the simulator. */
311 void __kprobes do_breakpoint(struct pt_regs* regs, int fault_num)
312 {
313         send_sigtrap(current, regs);
314 }
315 

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