blob: 42ad8ae729a0b9d594a9c28afb2a22cb9c20197d [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/kernel/ptrace.c
3 *
4 * (C) Copyright 1999 Linus Torvalds
5 *
6 * Common interfaces for "ptrace()" which we do not want
7 * to continually duplicate across every architecture.
8 */
9
Randy.Dunlapc59ede72006-01-11 12:17:46 -080010#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070011#include <linux/module.h>
12#include <linux/sched.h>
13#include <linux/errno.h>
14#include <linux/mm.h>
15#include <linux/highmem.h>
16#include <linux/pagemap.h>
17#include <linux/smp_lock.h>
18#include <linux/ptrace.h>
19#include <linux/security.h>
Jesper Juhl7ed20e12005-05-01 08:59:14 -070020#include <linux/signal.h>
Al Viroa5cb0132007-03-20 13:58:35 -040021#include <linux/audit.h>
Pavel Emelyanovb4888932007-10-18 23:40:14 -070022#include <linux/pid_namespace.h>
Adrian Bunkf17d30a2008-02-06 01:36:44 -080023#include <linux/syscalls.h>
Roland McGrath3a709702009-04-07 23:21:06 -070024#include <linux/uaccess.h>
Suresh Siddha2225a122010-02-11 11:51:00 -080025#include <linux/regset.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070026
Markus Metzgerbf53de92008-12-19 15:10:24 +010027
28/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070029 * ptrace a task: make the debugger its new parent and
30 * move it to the ptrace list.
31 *
32 * Must be called with the tasklist lock write-held.
33 */
Ingo Molnar36c8b582006-07-03 00:25:41 -070034void __ptrace_link(struct task_struct *child, struct task_struct *new_parent)
Linus Torvalds1da177e2005-04-16 15:20:36 -070035{
Roland McGrathf4700212008-03-24 18:36:23 -070036 BUG_ON(!list_empty(&child->ptrace_entry));
37 list_add(&child->ptrace_entry, &new_parent->ptraced);
Linus Torvalds1da177e2005-04-16 15:20:36 -070038 child->parent = new_parent;
Linus Torvalds1da177e2005-04-16 15:20:36 -070039}
Roland McGrath3a709702009-04-07 23:21:06 -070040
Linus Torvalds1da177e2005-04-16 15:20:36 -070041/*
42 * Turn a tracing stop into a normal stop now, since with no tracer there
43 * would be no way to wake it up with SIGCONT or SIGKILL. If there was a
44 * signal sent that would resume the child, but didn't because it was in
45 * TASK_TRACED, resume it now.
46 * Requires that irqs be disabled.
47 */
Adrian Bunkb747c8c2008-10-18 20:28:21 -070048static void ptrace_untrace(struct task_struct *child)
Linus Torvalds1da177e2005-04-16 15:20:36 -070049{
50 spin_lock(&child->sighand->siglock);
Matthew Wilcox6618a3e2007-12-06 11:06:16 -050051 if (task_is_traced(child)) {
Oleg Nesterov1ee11842009-04-02 16:58:23 -070052 /*
53 * If the group stop is completed or in progress,
54 * this thread was already counted as stopped.
55 */
56 if (child->signal->flags & SIGNAL_STOP_STOPPED ||
57 child->signal->group_stop_count)
Oleg Nesterovd9ae90a2008-02-06 01:36:13 -080058 __set_task_state(child, TASK_STOPPED);
Oleg Nesterov1ee11842009-04-02 16:58:23 -070059 else
Linus Torvalds1da177e2005-04-16 15:20:36 -070060 signal_wake_up(child, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -070061 }
62 spin_unlock(&child->sighand->siglock);
63}
64
65/*
66 * unptrace a task: move it back to its original parent and
67 * remove it from the ptrace list.
68 *
69 * Must be called with the tasklist lock write-held.
70 */
Ingo Molnar36c8b582006-07-03 00:25:41 -070071void __ptrace_unlink(struct task_struct *child)
Linus Torvalds1da177e2005-04-16 15:20:36 -070072{
Oleg Nesterov5ecfbae2006-02-15 22:50:10 +030073 BUG_ON(!child->ptrace);
74
Linus Torvalds1da177e2005-04-16 15:20:36 -070075 child->ptrace = 0;
Roland McGrathf4700212008-03-24 18:36:23 -070076 child->parent = child->real_parent;
77 list_del_init(&child->ptrace_entry);
Linus Torvalds1da177e2005-04-16 15:20:36 -070078
Markus Metzgerbf53de92008-12-19 15:10:24 +010079 arch_ptrace_untrace(child);
Matthew Wilcox6618a3e2007-12-06 11:06:16 -050080 if (task_is_traced(child))
Roland McGrathe57a5052006-04-12 16:30:20 -070081 ptrace_untrace(child);
Linus Torvalds1da177e2005-04-16 15:20:36 -070082}
83
84/*
85 * Check that we have indeed attached to the thing..
86 */
87int ptrace_check_attach(struct task_struct *child, int kill)
88{
89 int ret = -ESRCH;
90
91 /*
92 * We take the read lock around doing both checks to close a
93 * possible race where someone else was tracing our child and
94 * detached between these two checks. After this locked check,
95 * we are sure that this is our traced child and that can only
96 * be changed by us so it's not changing right after this.
97 */
98 read_lock(&tasklist_lock);
Oleg Nesterovc0c0b642008-02-08 04:19:00 -080099 if ((child->ptrace & PT_PTRACED) && child->parent == current) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100 ret = 0;
Oleg Nesterovc0c0b642008-02-08 04:19:00 -0800101 /*
102 * child->sighand can't be NULL, release_task()
103 * does ptrace_unlink() before __exit_signal().
104 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105 spin_lock_irq(&child->sighand->siglock);
Oleg Nesterovd9ae90a2008-02-06 01:36:13 -0800106 if (task_is_stopped(child))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107 child->state = TASK_TRACED;
Oleg Nesterovd9ae90a2008-02-06 01:36:13 -0800108 else if (!task_is_traced(child) && !kill)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 ret = -ESRCH;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110 spin_unlock_irq(&child->sighand->siglock);
111 }
112 read_unlock(&tasklist_lock);
113
Oleg Nesterovd9ae90a2008-02-06 01:36:13 -0800114 if (!ret && !kill)
Roland McGrath85ba2d82008-07-25 19:45:58 -0700115 ret = wait_task_inactive(child, TASK_TRACED) ? 0 : -ESRCH;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116
117 /* All systems go.. */
118 return ret;
119}
120
Stephen Smalley006ebb42008-05-19 08:32:49 -0400121int __ptrace_may_access(struct task_struct *task, unsigned int mode)
Miklos Szerediab8d11b2005-09-06 15:18:24 -0700122{
David Howellsc69e8d92008-11-14 10:39:19 +1100123 const struct cred *cred = current_cred(), *tcred;
David Howellsb6dff3e2008-11-14 10:39:16 +1100124
Eric W. Biedermandf26c402006-06-26 00:25:59 -0700125 /* May we inspect the given task?
126 * This check is used both for attaching with ptrace
127 * and for allowing access to sensitive information in /proc.
128 *
129 * ptrace_attach denies several cases that /proc allows
130 * because setting up the necessary parent/child relationship
131 * or halting the specified task is impossible.
132 */
133 int dumpable = 0;
134 /* Don't let security modules deny introspection */
135 if (task == current)
136 return 0;
David Howellsc69e8d92008-11-14 10:39:19 +1100137 rcu_read_lock();
138 tcred = __task_cred(task);
139 if ((cred->uid != tcred->euid ||
140 cred->uid != tcred->suid ||
141 cred->uid != tcred->uid ||
142 cred->gid != tcred->egid ||
143 cred->gid != tcred->sgid ||
144 cred->gid != tcred->gid) &&
145 !capable(CAP_SYS_PTRACE)) {
146 rcu_read_unlock();
Miklos Szerediab8d11b2005-09-06 15:18:24 -0700147 return -EPERM;
David Howellsc69e8d92008-11-14 10:39:19 +1100148 }
149 rcu_read_unlock();
Miklos Szerediab8d11b2005-09-06 15:18:24 -0700150 smp_rmb();
Eric W. Biedermandf26c402006-06-26 00:25:59 -0700151 if (task->mm)
Kawai, Hidehiro6c5d5232007-07-19 01:48:27 -0700152 dumpable = get_dumpable(task->mm);
Eric W. Biedermandf26c402006-06-26 00:25:59 -0700153 if (!dumpable && !capable(CAP_SYS_PTRACE))
Miklos Szerediab8d11b2005-09-06 15:18:24 -0700154 return -EPERM;
155
Ingo Molnar9e488582009-05-07 19:26:19 +1000156 return security_ptrace_access_check(task, mode);
Miklos Szerediab8d11b2005-09-06 15:18:24 -0700157}
158
Stephen Smalley006ebb42008-05-19 08:32:49 -0400159bool ptrace_may_access(struct task_struct *task, unsigned int mode)
Miklos Szerediab8d11b2005-09-06 15:18:24 -0700160{
161 int err;
162 task_lock(task);
Stephen Smalley006ebb42008-05-19 08:32:49 -0400163 err = __ptrace_may_access(task, mode);
Miklos Szerediab8d11b2005-09-06 15:18:24 -0700164 task_unlock(task);
Roland McGrath3a709702009-04-07 23:21:06 -0700165 return !err;
Miklos Szerediab8d11b2005-09-06 15:18:24 -0700166}
167
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168int ptrace_attach(struct task_struct *task)
169{
170 int retval;
Linus Torvaldsf5b40e32006-05-07 10:49:33 -0700171
Al Viroa5cb0132007-03-20 13:58:35 -0400172 audit_ptrace(task);
173
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174 retval = -EPERM;
Oleg Nesterovb79b7ba2009-06-17 16:27:31 -0700175 if (unlikely(task->flags & PF_KTHREAD))
176 goto out;
Pavel Emelyanovbac0abd2007-10-18 23:40:18 -0700177 if (same_thread_group(task, current))
Linus Torvaldsf5b40e32006-05-07 10:49:33 -0700178 goto out;
179
Oleg Nesterovf2f0b002009-06-17 16:27:32 -0700180 /*
181 * Protect exec's credential calculations against our interference;
David Howells5e751e92009-05-08 13:55:22 +0100182 * interference; SUID, SGID and LSM creds get determined differently
183 * under ptrace.
David Howellsd84f4f92008-11-14 10:39:23 +1100184 */
Oleg Nesterov793285f2009-07-05 12:08:26 -0700185 retval = -ERESTARTNOINTR;
186 if (mutex_lock_interruptible(&task->cred_guard_mutex))
David Howellsd84f4f92008-11-14 10:39:23 +1100187 goto out;
Oleg Nesterov4b105cb2009-06-17 16:27:33 -0700188
Linus Torvaldsf5b40e32006-05-07 10:49:33 -0700189 task_lock(task);
Stephen Smalley006ebb42008-05-19 08:32:49 -0400190 retval = __ptrace_may_access(task, PTRACE_MODE_ATTACH);
Oleg Nesterov4b105cb2009-06-17 16:27:33 -0700191 task_unlock(task);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 if (retval)
Oleg Nesterov4b105cb2009-06-17 16:27:33 -0700193 goto unlock_creds;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194
Oleg Nesterov4b105cb2009-06-17 16:27:33 -0700195 write_lock_irq(&tasklist_lock);
Oleg Nesterovb79b7ba2009-06-17 16:27:31 -0700196 retval = -EPERM;
197 if (unlikely(task->exit_state))
Oleg Nesterov4b105cb2009-06-17 16:27:33 -0700198 goto unlock_tasklist;
Oleg Nesterovf2f0b002009-06-17 16:27:32 -0700199 if (task->ptrace)
Oleg Nesterov4b105cb2009-06-17 16:27:33 -0700200 goto unlock_tasklist;
Oleg Nesterovb79b7ba2009-06-17 16:27:31 -0700201
Oleg Nesterovf2f0b002009-06-17 16:27:32 -0700202 task->ptrace = PT_PTRACED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 if (capable(CAP_SYS_PTRACE))
204 task->ptrace |= PT_PTRACE_CAP;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206 __ptrace_link(task, current);
Oleg Nesterov33e9fc72008-04-30 00:53:14 -0700207 send_sig_info(SIGSTOP, SEND_SIG_FORCED, task);
Oleg Nesterovb79b7ba2009-06-17 16:27:31 -0700208
209 retval = 0;
Oleg Nesterov4b105cb2009-06-17 16:27:33 -0700210unlock_tasklist:
211 write_unlock_irq(&tasklist_lock);
212unlock_creds:
David Howells5e751e92009-05-08 13:55:22 +0100213 mutex_unlock(&task->cred_guard_mutex);
Linus Torvaldsf5b40e32006-05-07 10:49:33 -0700214out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215 return retval;
216}
217
Oleg Nesterovf2f0b002009-06-17 16:27:32 -0700218/**
219 * ptrace_traceme -- helper for PTRACE_TRACEME
220 *
221 * Performs checks and sets PT_PTRACED.
222 * Should be used by all ptrace implementations for PTRACE_TRACEME.
223 */
224int ptrace_traceme(void)
225{
226 int ret = -EPERM;
227
Oleg Nesterov4b105cb2009-06-17 16:27:33 -0700228 write_lock_irq(&tasklist_lock);
229 /* Are we already being traced? */
Oleg Nesterovf2f0b002009-06-17 16:27:32 -0700230 if (!current->ptrace) {
Oleg Nesterovf2f0b002009-06-17 16:27:32 -0700231 ret = security_ptrace_traceme(current->parent);
Oleg Nesterovf2f0b002009-06-17 16:27:32 -0700232 /*
233 * Check PF_EXITING to ensure ->real_parent has not passed
234 * exit_ptrace(). Otherwise we don't report the error but
235 * pretend ->real_parent untraces us right after return.
236 */
237 if (!ret && !(current->real_parent->flags & PF_EXITING)) {
238 current->ptrace = PT_PTRACED;
239 __ptrace_link(current, current->real_parent);
240 }
Oleg Nesterovf2f0b002009-06-17 16:27:32 -0700241 }
Oleg Nesterov4b105cb2009-06-17 16:27:33 -0700242 write_unlock_irq(&tasklist_lock);
243
Oleg Nesterovf2f0b002009-06-17 16:27:32 -0700244 return ret;
245}
246
Oleg Nesterov39c626a2009-04-02 16:58:18 -0700247/*
248 * Called with irqs disabled, returns true if childs should reap themselves.
249 */
250static int ignoring_children(struct sighand_struct *sigh)
251{
252 int ret;
253 spin_lock(&sigh->siglock);
254 ret = (sigh->action[SIGCHLD-1].sa.sa_handler == SIG_IGN) ||
255 (sigh->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT);
256 spin_unlock(&sigh->siglock);
257 return ret;
258}
259
260/*
261 * Called with tasklist_lock held for writing.
262 * Unlink a traced task, and clean it up if it was a traced zombie.
263 * Return true if it needs to be reaped with release_task().
264 * (We can't call release_task() here because we already hold tasklist_lock.)
265 *
266 * If it's a zombie, our attachedness prevented normal parent notification
267 * or self-reaping. Do notification now if it would have happened earlier.
268 * If it should reap itself, return true.
269 *
Oleg Nesterova7f07652009-09-23 15:56:44 -0700270 * If it's our own child, there is no notification to do. But if our normal
271 * children self-reap, then this child was prevented by ptrace and we must
272 * reap it now, in that case we must also wake up sub-threads sleeping in
273 * do_wait().
Oleg Nesterov39c626a2009-04-02 16:58:18 -0700274 */
275static bool __ptrace_detach(struct task_struct *tracer, struct task_struct *p)
276{
277 __ptrace_unlink(p);
278
279 if (p->exit_state == EXIT_ZOMBIE) {
280 if (!task_detached(p) && thread_group_empty(p)) {
281 if (!same_thread_group(p->real_parent, tracer))
282 do_notify_parent(p, p->exit_signal);
Oleg Nesterova7f07652009-09-23 15:56:44 -0700283 else if (ignoring_children(tracer->sighand)) {
284 __wake_up_parent(p, tracer);
Oleg Nesterov39c626a2009-04-02 16:58:18 -0700285 p->exit_signal = -1;
Oleg Nesterova7f07652009-09-23 15:56:44 -0700286 }
Oleg Nesterov39c626a2009-04-02 16:58:18 -0700287 }
288 if (task_detached(p)) {
289 /* Mark it as in the process of being reaped. */
290 p->exit_state = EXIT_DEAD;
291 return true;
292 }
293 }
294
295 return false;
296}
297
Oleg Nesterov5ecfbae2006-02-15 22:50:10 +0300298int ptrace_detach(struct task_struct *child, unsigned int data)
299{
Oleg Nesterov39c626a2009-04-02 16:58:18 -0700300 bool dead = false;
Oleg Nesterov45761452009-04-02 16:58:14 -0700301
Oleg Nesterov5ecfbae2006-02-15 22:50:10 +0300302 if (!valid_signal(data))
303 return -EIO;
304
305 /* Architecture-specific hardware disable .. */
306 ptrace_disable(child);
Roland McGrath7d941432007-09-05 03:05:56 -0700307 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
Oleg Nesterov5ecfbae2006-02-15 22:50:10 +0300308
Oleg Nesterov95c3eb72009-04-02 16:58:11 -0700309 write_lock_irq(&tasklist_lock);
Oleg Nesterov39c626a2009-04-02 16:58:18 -0700310 /*
311 * This child can be already killed. Make sure de_thread() or
312 * our sub-thread doing do_wait() didn't do release_task() yet.
313 */
Oleg Nesterov95c3eb72009-04-02 16:58:11 -0700314 if (child->ptrace) {
315 child->exit_code = data;
Oleg Nesterov45761452009-04-02 16:58:14 -0700316 dead = __ptrace_detach(current, child);
Oleg Nesterovedaba2c2009-06-04 16:29:09 -0700317 if (!child->exit_state)
318 wake_up_process(child);
Oleg Nesterov95c3eb72009-04-02 16:58:11 -0700319 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 write_unlock_irq(&tasklist_lock);
321
Oleg Nesterov45761452009-04-02 16:58:14 -0700322 if (unlikely(dead))
323 release_task(child);
324
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325 return 0;
326}
327
Oleg Nesterov39c626a2009-04-02 16:58:18 -0700328/*
329 * Detach all tasks we were using ptrace on.
330 */
331void exit_ptrace(struct task_struct *tracer)
332{
333 struct task_struct *p, *n;
334 LIST_HEAD(ptrace_dead);
335
336 write_lock_irq(&tasklist_lock);
337 list_for_each_entry_safe(p, n, &tracer->ptraced, ptrace_entry) {
338 if (__ptrace_detach(tracer, p))
339 list_add(&p->ptrace_entry, &ptrace_dead);
340 }
341 write_unlock_irq(&tasklist_lock);
342
343 BUG_ON(!list_empty(&tracer->ptraced));
344
345 list_for_each_entry_safe(p, n, &ptrace_dead, ptrace_entry) {
346 list_del_init(&p->ptrace_entry);
347 release_task(p);
348 }
349}
350
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351int ptrace_readdata(struct task_struct *tsk, unsigned long src, char __user *dst, int len)
352{
353 int copied = 0;
354
355 while (len > 0) {
356 char buf[128];
357 int this_len, retval;
358
359 this_len = (len > sizeof(buf)) ? sizeof(buf) : len;
360 retval = access_process_vm(tsk, src, buf, this_len, 0);
361 if (!retval) {
362 if (copied)
363 break;
364 return -EIO;
365 }
366 if (copy_to_user(dst, buf, retval))
367 return -EFAULT;
368 copied += retval;
369 src += retval;
370 dst += retval;
Roland McGrath3a709702009-04-07 23:21:06 -0700371 len -= retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 }
373 return copied;
374}
375
376int ptrace_writedata(struct task_struct *tsk, char __user *src, unsigned long dst, int len)
377{
378 int copied = 0;
379
380 while (len > 0) {
381 char buf[128];
382 int this_len, retval;
383
384 this_len = (len > sizeof(buf)) ? sizeof(buf) : len;
385 if (copy_from_user(buf, src, this_len))
386 return -EFAULT;
387 retval = access_process_vm(tsk, dst, buf, this_len, 1);
388 if (!retval) {
389 if (copied)
390 break;
391 return -EIO;
392 }
393 copied += retval;
394 src += retval;
395 dst += retval;
Roland McGrath3a709702009-04-07 23:21:06 -0700396 len -= retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 }
398 return copied;
399}
400
401static int ptrace_setoptions(struct task_struct *child, long data)
402{
403 child->ptrace &= ~PT_TRACE_MASK;
404
405 if (data & PTRACE_O_TRACESYSGOOD)
406 child->ptrace |= PT_TRACESYSGOOD;
407
408 if (data & PTRACE_O_TRACEFORK)
409 child->ptrace |= PT_TRACE_FORK;
410
411 if (data & PTRACE_O_TRACEVFORK)
412 child->ptrace |= PT_TRACE_VFORK;
413
414 if (data & PTRACE_O_TRACECLONE)
415 child->ptrace |= PT_TRACE_CLONE;
416
417 if (data & PTRACE_O_TRACEEXEC)
418 child->ptrace |= PT_TRACE_EXEC;
419
420 if (data & PTRACE_O_TRACEVFORKDONE)
421 child->ptrace |= PT_TRACE_VFORK_DONE;
422
423 if (data & PTRACE_O_TRACEEXIT)
424 child->ptrace |= PT_TRACE_EXIT;
425
426 return (data & ~PTRACE_O_MASK) ? -EINVAL : 0;
427}
428
Roland McGrathe16b2782008-04-20 13:10:12 -0700429static int ptrace_getsiginfo(struct task_struct *child, siginfo_t *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430{
Oleg Nesterove4961252009-06-17 16:27:36 -0700431 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 int error = -ESRCH;
433
Oleg Nesterove4961252009-06-17 16:27:36 -0700434 if (lock_task_sighand(child, &flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435 error = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436 if (likely(child->last_siginfo != NULL)) {
Roland McGrathe16b2782008-04-20 13:10:12 -0700437 *info = *child->last_siginfo;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 error = 0;
439 }
Oleg Nesterove4961252009-06-17 16:27:36 -0700440 unlock_task_sighand(child, &flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442 return error;
443}
444
Roland McGrathe16b2782008-04-20 13:10:12 -0700445static int ptrace_setsiginfo(struct task_struct *child, const siginfo_t *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446{
Oleg Nesterove4961252009-06-17 16:27:36 -0700447 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 int error = -ESRCH;
449
Oleg Nesterove4961252009-06-17 16:27:36 -0700450 if (lock_task_sighand(child, &flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 error = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 if (likely(child->last_siginfo != NULL)) {
Roland McGrathe16b2782008-04-20 13:10:12 -0700453 *child->last_siginfo = *info;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454 error = 0;
455 }
Oleg Nesterove4961252009-06-17 16:27:36 -0700456 unlock_task_sighand(child, &flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458 return error;
459}
460
Roland McGrath36df29d2008-01-30 13:30:51 +0100461
462#ifdef PTRACE_SINGLESTEP
463#define is_singlestep(request) ((request) == PTRACE_SINGLESTEP)
464#else
465#define is_singlestep(request) 0
466#endif
467
Roland McGrath5b88abb2008-01-30 13:30:53 +0100468#ifdef PTRACE_SINGLEBLOCK
469#define is_singleblock(request) ((request) == PTRACE_SINGLEBLOCK)
470#else
471#define is_singleblock(request) 0
472#endif
473
Roland McGrath36df29d2008-01-30 13:30:51 +0100474#ifdef PTRACE_SYSEMU
475#define is_sysemu_singlestep(request) ((request) == PTRACE_SYSEMU_SINGLESTEP)
476#else
477#define is_sysemu_singlestep(request) 0
478#endif
479
480static int ptrace_resume(struct task_struct *child, long request, long data)
481{
482 if (!valid_signal(data))
483 return -EIO;
484
485 if (request == PTRACE_SYSCALL)
486 set_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
487 else
488 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
489
490#ifdef TIF_SYSCALL_EMU
491 if (request == PTRACE_SYSEMU || request == PTRACE_SYSEMU_SINGLESTEP)
492 set_tsk_thread_flag(child, TIF_SYSCALL_EMU);
493 else
494 clear_tsk_thread_flag(child, TIF_SYSCALL_EMU);
495#endif
496
Roland McGrath5b88abb2008-01-30 13:30:53 +0100497 if (is_singleblock(request)) {
498 if (unlikely(!arch_has_block_step()))
499 return -EIO;
500 user_enable_block_step(child);
501 } else if (is_singlestep(request) || is_sysemu_singlestep(request)) {
Roland McGrath36df29d2008-01-30 13:30:51 +0100502 if (unlikely(!arch_has_single_step()))
503 return -EIO;
504 user_enable_single_step(child);
Roland McGrath3a709702009-04-07 23:21:06 -0700505 } else {
Roland McGrath36df29d2008-01-30 13:30:51 +0100506 user_disable_single_step(child);
Roland McGrath3a709702009-04-07 23:21:06 -0700507 }
Roland McGrath36df29d2008-01-30 13:30:51 +0100508
509 child->exit_code = data;
510 wake_up_process(child);
511
512 return 0;
513}
514
Suresh Siddha2225a122010-02-11 11:51:00 -0800515#ifdef CONFIG_HAVE_ARCH_TRACEHOOK
516
517static const struct user_regset *
518find_regset(const struct user_regset_view *view, unsigned int type)
519{
520 const struct user_regset *regset;
521 int n;
522
523 for (n = 0; n < view->n; ++n) {
524 regset = view->regsets + n;
525 if (regset->core_note_type == type)
526 return regset;
527 }
528
529 return NULL;
530}
531
532static int ptrace_regset(struct task_struct *task, int req, unsigned int type,
533 struct iovec *kiov)
534{
535 const struct user_regset_view *view = task_user_regset_view(task);
536 const struct user_regset *regset = find_regset(view, type);
537 int regset_no;
538
539 if (!regset || (kiov->iov_len % regset->size) != 0)
Suresh Siddhac6a0dd72010-02-22 14:51:32 -0800540 return -EINVAL;
Suresh Siddha2225a122010-02-11 11:51:00 -0800541
542 regset_no = regset - view->regsets;
543 kiov->iov_len = min(kiov->iov_len,
544 (__kernel_size_t) (regset->n * regset->size));
545
546 if (req == PTRACE_GETREGSET)
547 return copy_regset_to_user(task, view, regset_no, 0,
548 kiov->iov_len, kiov->iov_base);
549 else
550 return copy_regset_from_user(task, view, regset_no, 0,
551 kiov->iov_len, kiov->iov_base);
552}
553
554#endif
555
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556int ptrace_request(struct task_struct *child, long request,
557 long addr, long data)
558{
559 int ret = -EIO;
Roland McGrathe16b2782008-04-20 13:10:12 -0700560 siginfo_t siginfo;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561
562 switch (request) {
Roland McGrath16c3e382008-01-30 13:31:47 +0100563 case PTRACE_PEEKTEXT:
564 case PTRACE_PEEKDATA:
565 return generic_ptrace_peekdata(child, addr, data);
566 case PTRACE_POKETEXT:
567 case PTRACE_POKEDATA:
568 return generic_ptrace_pokedata(child, addr, data);
569
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570#ifdef PTRACE_OLDSETOPTIONS
571 case PTRACE_OLDSETOPTIONS:
572#endif
573 case PTRACE_SETOPTIONS:
574 ret = ptrace_setoptions(child, data);
575 break;
576 case PTRACE_GETEVENTMSG:
577 ret = put_user(child->ptrace_message, (unsigned long __user *) data);
578 break;
Roland McGrathe16b2782008-04-20 13:10:12 -0700579
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580 case PTRACE_GETSIGINFO:
Roland McGrathe16b2782008-04-20 13:10:12 -0700581 ret = ptrace_getsiginfo(child, &siginfo);
582 if (!ret)
583 ret = copy_siginfo_to_user((siginfo_t __user *) data,
584 &siginfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585 break;
Roland McGrathe16b2782008-04-20 13:10:12 -0700586
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587 case PTRACE_SETSIGINFO:
Roland McGrathe16b2782008-04-20 13:10:12 -0700588 if (copy_from_user(&siginfo, (siginfo_t __user *) data,
589 sizeof siginfo))
590 ret = -EFAULT;
591 else
592 ret = ptrace_setsiginfo(child, &siginfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 break;
Roland McGrathe16b2782008-04-20 13:10:12 -0700594
Alexey Dobriyan1bcf5482007-10-16 01:23:45 -0700595 case PTRACE_DETACH: /* detach a process that was attached. */
596 ret = ptrace_detach(child, data);
597 break;
Roland McGrath36df29d2008-01-30 13:30:51 +0100598
599#ifdef PTRACE_SINGLESTEP
600 case PTRACE_SINGLESTEP:
601#endif
Roland McGrath5b88abb2008-01-30 13:30:53 +0100602#ifdef PTRACE_SINGLEBLOCK
603 case PTRACE_SINGLEBLOCK:
604#endif
Roland McGrath36df29d2008-01-30 13:30:51 +0100605#ifdef PTRACE_SYSEMU
606 case PTRACE_SYSEMU:
607 case PTRACE_SYSEMU_SINGLESTEP:
608#endif
609 case PTRACE_SYSCALL:
610 case PTRACE_CONT:
611 return ptrace_resume(child, request, data);
612
613 case PTRACE_KILL:
614 if (child->exit_state) /* already dead */
615 return 0;
616 return ptrace_resume(child, request, SIGKILL);
617
Suresh Siddha2225a122010-02-11 11:51:00 -0800618#ifdef CONFIG_HAVE_ARCH_TRACEHOOK
619 case PTRACE_GETREGSET:
620 case PTRACE_SETREGSET:
621 {
622 struct iovec kiov;
623 struct iovec __user *uiov = (struct iovec __user *) data;
624
625 if (!access_ok(VERIFY_WRITE, uiov, sizeof(*uiov)))
626 return -EFAULT;
627
628 if (__get_user(kiov.iov_base, &uiov->iov_base) ||
629 __get_user(kiov.iov_len, &uiov->iov_len))
630 return -EFAULT;
631
632 ret = ptrace_regset(child, request, addr, &kiov);
633 if (!ret)
634 ret = __put_user(kiov.iov_len, &uiov->iov_len);
635 break;
636 }
637#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638 default:
639 break;
640 }
641
642 return ret;
643}
Christoph Hellwig481bed42005-11-07 00:59:47 -0800644
Oleg Nesterov8053bdd2009-06-17 16:27:34 -0700645static struct task_struct *ptrace_get_task_struct(pid_t pid)
Christoph Hellwig6b9c7ed2006-01-08 01:02:33 -0800646{
647 struct task_struct *child;
Christoph Hellwig481bed42005-11-07 00:59:47 -0800648
Oleg Nesterov8053bdd2009-06-17 16:27:34 -0700649 rcu_read_lock();
Pavel Emelyanov228ebcb2007-10-18 23:40:16 -0700650 child = find_task_by_vpid(pid);
Christoph Hellwig481bed42005-11-07 00:59:47 -0800651 if (child)
652 get_task_struct(child);
Oleg Nesterov8053bdd2009-06-17 16:27:34 -0700653 rcu_read_unlock();
Sukadev Bhattiproluf400e192006-09-29 02:00:07 -0700654
Christoph Hellwig481bed42005-11-07 00:59:47 -0800655 if (!child)
Christoph Hellwig6b9c7ed2006-01-08 01:02:33 -0800656 return ERR_PTR(-ESRCH);
657 return child;
Christoph Hellwig481bed42005-11-07 00:59:47 -0800658}
659
Christoph Hellwig0ac15552007-10-16 01:26:37 -0700660#ifndef arch_ptrace_attach
661#define arch_ptrace_attach(child) do { } while (0)
662#endif
663
Heiko Carstens1e7bfb22009-01-14 14:14:29 +0100664SYSCALL_DEFINE4(ptrace, long, request, long, pid, long, addr, long, data)
Christoph Hellwig481bed42005-11-07 00:59:47 -0800665{
666 struct task_struct *child;
667 long ret;
668
669 /*
670 * This lock_kernel fixes a subtle race with suid exec
671 */
672 lock_kernel();
Christoph Hellwig6b9c7ed2006-01-08 01:02:33 -0800673 if (request == PTRACE_TRACEME) {
674 ret = ptrace_traceme();
Haavard Skinnemoen6ea6dd92007-11-27 13:02:40 +0100675 if (!ret)
676 arch_ptrace_attach(current);
Christoph Hellwig481bed42005-11-07 00:59:47 -0800677 goto out;
Christoph Hellwig6b9c7ed2006-01-08 01:02:33 -0800678 }
679
680 child = ptrace_get_task_struct(pid);
681 if (IS_ERR(child)) {
682 ret = PTR_ERR(child);
683 goto out;
684 }
Christoph Hellwig481bed42005-11-07 00:59:47 -0800685
686 if (request == PTRACE_ATTACH) {
687 ret = ptrace_attach(child);
Christoph Hellwig0ac15552007-10-16 01:26:37 -0700688 /*
689 * Some architectures need to do book-keeping after
690 * a ptrace attach.
691 */
692 if (!ret)
693 arch_ptrace_attach(child);
Christoph Hellwig005f18d2005-11-13 16:06:33 -0800694 goto out_put_task_struct;
Christoph Hellwig481bed42005-11-07 00:59:47 -0800695 }
696
697 ret = ptrace_check_attach(child, request == PTRACE_KILL);
698 if (ret < 0)
699 goto out_put_task_struct;
700
701 ret = arch_ptrace(child, request, addr, data);
Christoph Hellwig481bed42005-11-07 00:59:47 -0800702
703 out_put_task_struct:
704 put_task_struct(child);
705 out:
706 unlock_kernel();
707 return ret;
708}
Alexey Dobriyan76647322007-07-17 04:03:43 -0700709
710int generic_ptrace_peekdata(struct task_struct *tsk, long addr, long data)
711{
712 unsigned long tmp;
713 int copied;
714
715 copied = access_process_vm(tsk, addr, &tmp, sizeof(tmp), 0);
716 if (copied != sizeof(tmp))
717 return -EIO;
718 return put_user(tmp, (unsigned long __user *)data);
719}
Alexey Dobriyanf284ce72007-07-17 04:03:44 -0700720
721int generic_ptrace_pokedata(struct task_struct *tsk, long addr, long data)
722{
723 int copied;
724
725 copied = access_process_vm(tsk, addr, &data, sizeof(data), 1);
726 return (copied == sizeof(data)) ? 0 : -EIO;
727}
Roland McGrath032d82d2008-01-30 13:31:47 +0100728
Christoph Hellwig96b89362008-11-25 08:10:03 +0100729#if defined CONFIG_COMPAT
Roland McGrath032d82d2008-01-30 13:31:47 +0100730#include <linux/compat.h>
731
732int compat_ptrace_request(struct task_struct *child, compat_long_t request,
733 compat_ulong_t addr, compat_ulong_t data)
734{
735 compat_ulong_t __user *datap = compat_ptr(data);
736 compat_ulong_t word;
Roland McGrathe16b2782008-04-20 13:10:12 -0700737 siginfo_t siginfo;
Roland McGrath032d82d2008-01-30 13:31:47 +0100738 int ret;
739
740 switch (request) {
741 case PTRACE_PEEKTEXT:
742 case PTRACE_PEEKDATA:
743 ret = access_process_vm(child, addr, &word, sizeof(word), 0);
744 if (ret != sizeof(word))
745 ret = -EIO;
746 else
747 ret = put_user(word, datap);
748 break;
749
750 case PTRACE_POKETEXT:
751 case PTRACE_POKEDATA:
752 ret = access_process_vm(child, addr, &data, sizeof(data), 1);
753 ret = (ret != sizeof(data) ? -EIO : 0);
754 break;
755
756 case PTRACE_GETEVENTMSG:
757 ret = put_user((compat_ulong_t) child->ptrace_message, datap);
758 break;
759
Roland McGrathe16b2782008-04-20 13:10:12 -0700760 case PTRACE_GETSIGINFO:
761 ret = ptrace_getsiginfo(child, &siginfo);
762 if (!ret)
763 ret = copy_siginfo_to_user32(
764 (struct compat_siginfo __user *) datap,
765 &siginfo);
766 break;
767
768 case PTRACE_SETSIGINFO:
769 memset(&siginfo, 0, sizeof siginfo);
770 if (copy_siginfo_from_user32(
771 &siginfo, (struct compat_siginfo __user *) datap))
772 ret = -EFAULT;
773 else
774 ret = ptrace_setsiginfo(child, &siginfo);
775 break;
Suresh Siddha2225a122010-02-11 11:51:00 -0800776#ifdef CONFIG_HAVE_ARCH_TRACEHOOK
777 case PTRACE_GETREGSET:
778 case PTRACE_SETREGSET:
779 {
780 struct iovec kiov;
781 struct compat_iovec __user *uiov =
782 (struct compat_iovec __user *) datap;
783 compat_uptr_t ptr;
784 compat_size_t len;
785
786 if (!access_ok(VERIFY_WRITE, uiov, sizeof(*uiov)))
787 return -EFAULT;
788
789 if (__get_user(ptr, &uiov->iov_base) ||
790 __get_user(len, &uiov->iov_len))
791 return -EFAULT;
792
793 kiov.iov_base = compat_ptr(ptr);
794 kiov.iov_len = len;
795
796 ret = ptrace_regset(child, request, addr, &kiov);
797 if (!ret)
798 ret = __put_user(kiov.iov_len, &uiov->iov_len);
799 break;
800 }
801#endif
Roland McGrathe16b2782008-04-20 13:10:12 -0700802
Roland McGrath032d82d2008-01-30 13:31:47 +0100803 default:
804 ret = ptrace_request(child, request, addr, data);
805 }
806
807 return ret;
808}
Roland McGrathc269f192008-01-30 13:31:48 +0100809
Roland McGrathc269f192008-01-30 13:31:48 +0100810asmlinkage long compat_sys_ptrace(compat_long_t request, compat_long_t pid,
811 compat_long_t addr, compat_long_t data)
812{
813 struct task_struct *child;
814 long ret;
815
816 /*
817 * This lock_kernel fixes a subtle race with suid exec
818 */
819 lock_kernel();
820 if (request == PTRACE_TRACEME) {
821 ret = ptrace_traceme();
822 goto out;
823 }
824
825 child = ptrace_get_task_struct(pid);
826 if (IS_ERR(child)) {
827 ret = PTR_ERR(child);
828 goto out;
829 }
830
831 if (request == PTRACE_ATTACH) {
832 ret = ptrace_attach(child);
833 /*
834 * Some architectures need to do book-keeping after
835 * a ptrace attach.
836 */
837 if (!ret)
838 arch_ptrace_attach(child);
839 goto out_put_task_struct;
840 }
841
842 ret = ptrace_check_attach(child, request == PTRACE_KILL);
843 if (!ret)
844 ret = compat_arch_ptrace(child, request, addr, data);
845
846 out_put_task_struct:
847 put_task_struct(child);
848 out:
849 unlock_kernel();
850 return ret;
851}
Christoph Hellwig96b89362008-11-25 08:10:03 +0100852#endif /* CONFIG_COMPAT */