blob: e950805f86300eebefcf88de6c0602209370ba4e [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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070025
Markus Metzgerbf53de92008-12-19 15:10:24 +010026
27/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070028 * ptrace a task: make the debugger its new parent and
29 * move it to the ptrace list.
30 *
31 * Must be called with the tasklist lock write-held.
32 */
Ingo Molnar36c8b582006-07-03 00:25:41 -070033void __ptrace_link(struct task_struct *child, struct task_struct *new_parent)
Linus Torvalds1da177e2005-04-16 15:20:36 -070034{
Roland McGrathf4700212008-03-24 18:36:23 -070035 BUG_ON(!list_empty(&child->ptrace_entry));
36 list_add(&child->ptrace_entry, &new_parent->ptraced);
Linus Torvalds1da177e2005-04-16 15:20:36 -070037 child->parent = new_parent;
Linus Torvalds1da177e2005-04-16 15:20:36 -070038}
Roland McGrath3a709702009-04-07 23:21:06 -070039
Linus Torvalds1da177e2005-04-16 15:20:36 -070040/*
41 * Turn a tracing stop into a normal stop now, since with no tracer there
42 * would be no way to wake it up with SIGCONT or SIGKILL. If there was a
43 * signal sent that would resume the child, but didn't because it was in
44 * TASK_TRACED, resume it now.
45 * Requires that irqs be disabled.
46 */
Adrian Bunkb747c8c2008-10-18 20:28:21 -070047static void ptrace_untrace(struct task_struct *child)
Linus Torvalds1da177e2005-04-16 15:20:36 -070048{
49 spin_lock(&child->sighand->siglock);
Matthew Wilcox6618a3e2007-12-06 11:06:16 -050050 if (task_is_traced(child)) {
Oleg Nesterov1ee11842009-04-02 16:58:23 -070051 /*
52 * If the group stop is completed or in progress,
53 * this thread was already counted as stopped.
54 */
55 if (child->signal->flags & SIGNAL_STOP_STOPPED ||
56 child->signal->group_stop_count)
Oleg Nesterovd9ae90a2008-02-06 01:36:13 -080057 __set_task_state(child, TASK_STOPPED);
Oleg Nesterov1ee11842009-04-02 16:58:23 -070058 else
Linus Torvalds1da177e2005-04-16 15:20:36 -070059 signal_wake_up(child, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -070060 }
61 spin_unlock(&child->sighand->siglock);
62}
63
64/*
65 * unptrace a task: move it back to its original parent and
66 * remove it from the ptrace list.
67 *
68 * Must be called with the tasklist lock write-held.
69 */
Ingo Molnar36c8b582006-07-03 00:25:41 -070070void __ptrace_unlink(struct task_struct *child)
Linus Torvalds1da177e2005-04-16 15:20:36 -070071{
Oleg Nesterov5ecfbae2006-02-15 22:50:10 +030072 BUG_ON(!child->ptrace);
73
Linus Torvalds1da177e2005-04-16 15:20:36 -070074 child->ptrace = 0;
Roland McGrathf4700212008-03-24 18:36:23 -070075 child->parent = child->real_parent;
76 list_del_init(&child->ptrace_entry);
Linus Torvalds1da177e2005-04-16 15:20:36 -070077
Markus Metzgerbf53de92008-12-19 15:10:24 +010078 arch_ptrace_untrace(child);
Matthew Wilcox6618a3e2007-12-06 11:06:16 -050079 if (task_is_traced(child))
Roland McGrathe57a5052006-04-12 16:30:20 -070080 ptrace_untrace(child);
Linus Torvalds1da177e2005-04-16 15:20:36 -070081}
82
83/*
84 * Check that we have indeed attached to the thing..
85 */
86int ptrace_check_attach(struct task_struct *child, int kill)
87{
88 int ret = -ESRCH;
89
90 /*
91 * We take the read lock around doing both checks to close a
92 * possible race where someone else was tracing our child and
93 * detached between these two checks. After this locked check,
94 * we are sure that this is our traced child and that can only
95 * be changed by us so it's not changing right after this.
96 */
97 read_lock(&tasklist_lock);
Oleg Nesterovc0c0b642008-02-08 04:19:00 -080098 if ((child->ptrace & PT_PTRACED) && child->parent == current) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070099 ret = 0;
Oleg Nesterovc0c0b642008-02-08 04:19:00 -0800100 /*
101 * child->sighand can't be NULL, release_task()
102 * does ptrace_unlink() before __exit_signal().
103 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104 spin_lock_irq(&child->sighand->siglock);
Oleg Nesterovd9ae90a2008-02-06 01:36:13 -0800105 if (task_is_stopped(child))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106 child->state = TASK_TRACED;
Oleg Nesterovd9ae90a2008-02-06 01:36:13 -0800107 else if (!task_is_traced(child) && !kill)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108 ret = -ESRCH;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 spin_unlock_irq(&child->sighand->siglock);
110 }
111 read_unlock(&tasklist_lock);
112
Oleg Nesterovd9ae90a2008-02-06 01:36:13 -0800113 if (!ret && !kill)
Roland McGrath85ba2d82008-07-25 19:45:58 -0700114 ret = wait_task_inactive(child, TASK_TRACED) ? 0 : -ESRCH;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115
116 /* All systems go.. */
117 return ret;
118}
119
Stephen Smalley006ebb42008-05-19 08:32:49 -0400120int __ptrace_may_access(struct task_struct *task, unsigned int mode)
Miklos Szerediab8d11b2005-09-06 15:18:24 -0700121{
David Howellsc69e8d92008-11-14 10:39:19 +1100122 const struct cred *cred = current_cred(), *tcred;
David Howellsb6dff3e2008-11-14 10:39:16 +1100123
Eric W. Biedermandf26c402006-06-26 00:25:59 -0700124 /* May we inspect the given task?
125 * This check is used both for attaching with ptrace
126 * and for allowing access to sensitive information in /proc.
127 *
128 * ptrace_attach denies several cases that /proc allows
129 * because setting up the necessary parent/child relationship
130 * or halting the specified task is impossible.
131 */
132 int dumpable = 0;
133 /* Don't let security modules deny introspection */
134 if (task == current)
135 return 0;
David Howellsc69e8d92008-11-14 10:39:19 +1100136 rcu_read_lock();
137 tcred = __task_cred(task);
138 if ((cred->uid != tcred->euid ||
139 cred->uid != tcred->suid ||
140 cred->uid != tcred->uid ||
141 cred->gid != tcred->egid ||
142 cred->gid != tcred->sgid ||
143 cred->gid != tcred->gid) &&
144 !capable(CAP_SYS_PTRACE)) {
145 rcu_read_unlock();
Miklos Szerediab8d11b2005-09-06 15:18:24 -0700146 return -EPERM;
David Howellsc69e8d92008-11-14 10:39:19 +1100147 }
148 rcu_read_unlock();
Miklos Szerediab8d11b2005-09-06 15:18:24 -0700149 smp_rmb();
Eric W. Biedermandf26c402006-06-26 00:25:59 -0700150 if (task->mm)
Kawai, Hidehiro6c5d5232007-07-19 01:48:27 -0700151 dumpable = get_dumpable(task->mm);
Eric W. Biedermandf26c402006-06-26 00:25:59 -0700152 if (!dumpable && !capable(CAP_SYS_PTRACE))
Miklos Szerediab8d11b2005-09-06 15:18:24 -0700153 return -EPERM;
154
David Howells5cd9c582008-08-14 11:37:28 +0100155 return security_ptrace_may_access(task, mode);
Miklos Szerediab8d11b2005-09-06 15:18:24 -0700156}
157
Stephen Smalley006ebb42008-05-19 08:32:49 -0400158bool ptrace_may_access(struct task_struct *task, unsigned int mode)
Miklos Szerediab8d11b2005-09-06 15:18:24 -0700159{
160 int err;
161 task_lock(task);
Stephen Smalley006ebb42008-05-19 08:32:49 -0400162 err = __ptrace_may_access(task, mode);
Miklos Szerediab8d11b2005-09-06 15:18:24 -0700163 task_unlock(task);
Roland McGrath3a709702009-04-07 23:21:06 -0700164 return !err;
Miklos Szerediab8d11b2005-09-06 15:18:24 -0700165}
166
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167int ptrace_attach(struct task_struct *task)
168{
169 int retval;
Sripathi Kodi6175ecf2007-07-15 23:39:26 -0700170 unsigned long flags;
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;
Pavel Emelyanovbac0abd2007-10-18 23:40:18 -0700175 if (same_thread_group(task, current))
Linus Torvaldsf5b40e32006-05-07 10:49:33 -0700176 goto out;
177
David Howellsd84f4f92008-11-14 10:39:23 +1100178 /* Protect exec's credential calculations against our interference;
179 * SUID, SGID and LSM creds get determined differently under ptrace.
180 */
Oleg Nesterovcad81bc2009-04-27 01:41:34 +0200181 retval = mutex_lock_interruptible(&task->cred_exec_mutex);
David Howellsd84f4f92008-11-14 10:39:23 +1100182 if (retval < 0)
183 goto out;
184
185 retval = -EPERM;
Linus Torvaldsf3581662006-05-11 11:08:49 -0700186repeat:
187 /*
188 * Nasty, nasty.
189 *
190 * We want to hold both the task-lock and the
191 * tasklist_lock for writing at the same time.
192 * But that's against the rules (tasklist_lock
193 * is taken for reading by interrupts on other
194 * cpu's that may have task_lock).
195 */
Linus Torvaldsf5b40e32006-05-07 10:49:33 -0700196 task_lock(task);
Sripathi Kodi6175ecf2007-07-15 23:39:26 -0700197 if (!write_trylock_irqsave(&tasklist_lock, flags)) {
Linus Torvaldsf3581662006-05-11 11:08:49 -0700198 task_unlock(task);
199 do {
200 cpu_relax();
201 } while (!write_can_lock(&tasklist_lock));
202 goto repeat;
203 }
Linus Torvaldsf5b40e32006-05-07 10:49:33 -0700204
Eric W. Biedermandf26c402006-06-26 00:25:59 -0700205 if (!task->mm)
206 goto bad;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 /* the same process cannot be attached many times */
208 if (task->ptrace & PT_PTRACED)
209 goto bad;
Stephen Smalley006ebb42008-05-19 08:32:49 -0400210 retval = __ptrace_may_access(task, PTRACE_MODE_ATTACH);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 if (retval)
212 goto bad;
213
214 /* Go */
Oleg Nesterov6b39c7b2008-02-08 04:18:58 -0800215 task->ptrace |= PT_PTRACED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216 if (capable(CAP_SYS_PTRACE))
217 task->ptrace |= PT_PTRACE_CAP;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219 __ptrace_link(task, current);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220
Oleg Nesterov33e9fc72008-04-30 00:53:14 -0700221 send_sig_info(SIGSTOP, SEND_SIG_FORCED, task);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222bad:
Sripathi Kodi6175ecf2007-07-15 23:39:26 -0700223 write_unlock_irqrestore(&tasklist_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224 task_unlock(task);
Oleg Nesterovcad81bc2009-04-27 01:41:34 +0200225 mutex_unlock(&task->cred_exec_mutex);
Linus Torvaldsf5b40e32006-05-07 10:49:33 -0700226out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227 return retval;
228}
229
Oleg Nesterov39c626a2009-04-02 16:58:18 -0700230/*
231 * Called with irqs disabled, returns true if childs should reap themselves.
232 */
233static int ignoring_children(struct sighand_struct *sigh)
234{
235 int ret;
236 spin_lock(&sigh->siglock);
237 ret = (sigh->action[SIGCHLD-1].sa.sa_handler == SIG_IGN) ||
238 (sigh->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT);
239 spin_unlock(&sigh->siglock);
240 return ret;
241}
242
243/*
244 * Called with tasklist_lock held for writing.
245 * Unlink a traced task, and clean it up if it was a traced zombie.
246 * Return true if it needs to be reaped with release_task().
247 * (We can't call release_task() here because we already hold tasklist_lock.)
248 *
249 * If it's a zombie, our attachedness prevented normal parent notification
250 * or self-reaping. Do notification now if it would have happened earlier.
251 * If it should reap itself, return true.
252 *
253 * If it's our own child, there is no notification to do.
254 * But if our normal children self-reap, then this child
255 * was prevented by ptrace and we must reap it now.
256 */
257static bool __ptrace_detach(struct task_struct *tracer, struct task_struct *p)
258{
259 __ptrace_unlink(p);
260
261 if (p->exit_state == EXIT_ZOMBIE) {
262 if (!task_detached(p) && thread_group_empty(p)) {
263 if (!same_thread_group(p->real_parent, tracer))
264 do_notify_parent(p, p->exit_signal);
265 else if (ignoring_children(tracer->sighand))
266 p->exit_signal = -1;
267 }
268 if (task_detached(p)) {
269 /* Mark it as in the process of being reaped. */
270 p->exit_state = EXIT_DEAD;
271 return true;
272 }
273 }
274
275 return false;
276}
277
Oleg Nesterov5ecfbae2006-02-15 22:50:10 +0300278int ptrace_detach(struct task_struct *child, unsigned int data)
279{
Oleg Nesterov39c626a2009-04-02 16:58:18 -0700280 bool dead = false;
Oleg Nesterov45761452009-04-02 16:58:14 -0700281
Oleg Nesterov5ecfbae2006-02-15 22:50:10 +0300282 if (!valid_signal(data))
283 return -EIO;
284
285 /* Architecture-specific hardware disable .. */
286 ptrace_disable(child);
Roland McGrath7d941432007-09-05 03:05:56 -0700287 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
Oleg Nesterov5ecfbae2006-02-15 22:50:10 +0300288
Oleg Nesterov95c3eb72009-04-02 16:58:11 -0700289 write_lock_irq(&tasklist_lock);
Oleg Nesterov39c626a2009-04-02 16:58:18 -0700290 /*
291 * This child can be already killed. Make sure de_thread() or
292 * our sub-thread doing do_wait() didn't do release_task() yet.
293 */
Oleg Nesterov95c3eb72009-04-02 16:58:11 -0700294 if (child->ptrace) {
295 child->exit_code = data;
Oleg Nesterov45761452009-04-02 16:58:14 -0700296 dead = __ptrace_detach(current, child);
Oleg Nesterov95c3eb72009-04-02 16:58:11 -0700297 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298 write_unlock_irq(&tasklist_lock);
299
Oleg Nesterov45761452009-04-02 16:58:14 -0700300 if (unlikely(dead))
301 release_task(child);
302
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303 return 0;
304}
305
Oleg Nesterov39c626a2009-04-02 16:58:18 -0700306/*
307 * Detach all tasks we were using ptrace on.
308 */
309void exit_ptrace(struct task_struct *tracer)
310{
311 struct task_struct *p, *n;
312 LIST_HEAD(ptrace_dead);
313
314 write_lock_irq(&tasklist_lock);
315 list_for_each_entry_safe(p, n, &tracer->ptraced, ptrace_entry) {
316 if (__ptrace_detach(tracer, p))
317 list_add(&p->ptrace_entry, &ptrace_dead);
318 }
319 write_unlock_irq(&tasklist_lock);
320
321 BUG_ON(!list_empty(&tracer->ptraced));
322
323 list_for_each_entry_safe(p, n, &ptrace_dead, ptrace_entry) {
324 list_del_init(&p->ptrace_entry);
325 release_task(p);
326 }
327}
328
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329int ptrace_readdata(struct task_struct *tsk, unsigned long src, char __user *dst, int len)
330{
331 int copied = 0;
332
333 while (len > 0) {
334 char buf[128];
335 int this_len, retval;
336
337 this_len = (len > sizeof(buf)) ? sizeof(buf) : len;
338 retval = access_process_vm(tsk, src, buf, this_len, 0);
339 if (!retval) {
340 if (copied)
341 break;
342 return -EIO;
343 }
344 if (copy_to_user(dst, buf, retval))
345 return -EFAULT;
346 copied += retval;
347 src += retval;
348 dst += retval;
Roland McGrath3a709702009-04-07 23:21:06 -0700349 len -= retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350 }
351 return copied;
352}
353
354int ptrace_writedata(struct task_struct *tsk, char __user *src, unsigned long dst, int len)
355{
356 int copied = 0;
357
358 while (len > 0) {
359 char buf[128];
360 int this_len, retval;
361
362 this_len = (len > sizeof(buf)) ? sizeof(buf) : len;
363 if (copy_from_user(buf, src, this_len))
364 return -EFAULT;
365 retval = access_process_vm(tsk, dst, buf, this_len, 1);
366 if (!retval) {
367 if (copied)
368 break;
369 return -EIO;
370 }
371 copied += retval;
372 src += retval;
373 dst += retval;
Roland McGrath3a709702009-04-07 23:21:06 -0700374 len -= retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 }
376 return copied;
377}
378
379static int ptrace_setoptions(struct task_struct *child, long data)
380{
381 child->ptrace &= ~PT_TRACE_MASK;
382
383 if (data & PTRACE_O_TRACESYSGOOD)
384 child->ptrace |= PT_TRACESYSGOOD;
385
386 if (data & PTRACE_O_TRACEFORK)
387 child->ptrace |= PT_TRACE_FORK;
388
389 if (data & PTRACE_O_TRACEVFORK)
390 child->ptrace |= PT_TRACE_VFORK;
391
392 if (data & PTRACE_O_TRACECLONE)
393 child->ptrace |= PT_TRACE_CLONE;
394
395 if (data & PTRACE_O_TRACEEXEC)
396 child->ptrace |= PT_TRACE_EXEC;
397
398 if (data & PTRACE_O_TRACEVFORKDONE)
399 child->ptrace |= PT_TRACE_VFORK_DONE;
400
401 if (data & PTRACE_O_TRACEEXIT)
402 child->ptrace |= PT_TRACE_EXIT;
403
404 return (data & ~PTRACE_O_MASK) ? -EINVAL : 0;
405}
406
Roland McGrathe16b2782008-04-20 13:10:12 -0700407static int ptrace_getsiginfo(struct task_struct *child, siginfo_t *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 int error = -ESRCH;
410
411 read_lock(&tasklist_lock);
412 if (likely(child->sighand != NULL)) {
413 error = -EINVAL;
414 spin_lock_irq(&child->sighand->siglock);
415 if (likely(child->last_siginfo != NULL)) {
Roland McGrathe16b2782008-04-20 13:10:12 -0700416 *info = *child->last_siginfo;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 error = 0;
418 }
419 spin_unlock_irq(&child->sighand->siglock);
420 }
421 read_unlock(&tasklist_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 return error;
423}
424
Roland McGrathe16b2782008-04-20 13:10:12 -0700425static int ptrace_setsiginfo(struct task_struct *child, const siginfo_t *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 int error = -ESRCH;
428
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429 read_lock(&tasklist_lock);
430 if (likely(child->sighand != NULL)) {
431 error = -EINVAL;
432 spin_lock_irq(&child->sighand->siglock);
433 if (likely(child->last_siginfo != NULL)) {
Roland McGrathe16b2782008-04-20 13:10:12 -0700434 *child->last_siginfo = *info;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435 error = 0;
436 }
437 spin_unlock_irq(&child->sighand->siglock);
438 }
439 read_unlock(&tasklist_lock);
440 return error;
441}
442
Roland McGrath36df29d2008-01-30 13:30:51 +0100443
444#ifdef PTRACE_SINGLESTEP
445#define is_singlestep(request) ((request) == PTRACE_SINGLESTEP)
446#else
447#define is_singlestep(request) 0
448#endif
449
Roland McGrath5b88abb2008-01-30 13:30:53 +0100450#ifdef PTRACE_SINGLEBLOCK
451#define is_singleblock(request) ((request) == PTRACE_SINGLEBLOCK)
452#else
453#define is_singleblock(request) 0
454#endif
455
Roland McGrath36df29d2008-01-30 13:30:51 +0100456#ifdef PTRACE_SYSEMU
457#define is_sysemu_singlestep(request) ((request) == PTRACE_SYSEMU_SINGLESTEP)
458#else
459#define is_sysemu_singlestep(request) 0
460#endif
461
462static int ptrace_resume(struct task_struct *child, long request, long data)
463{
464 if (!valid_signal(data))
465 return -EIO;
466
467 if (request == PTRACE_SYSCALL)
468 set_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
469 else
470 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
471
472#ifdef TIF_SYSCALL_EMU
473 if (request == PTRACE_SYSEMU || request == PTRACE_SYSEMU_SINGLESTEP)
474 set_tsk_thread_flag(child, TIF_SYSCALL_EMU);
475 else
476 clear_tsk_thread_flag(child, TIF_SYSCALL_EMU);
477#endif
478
Roland McGrath5b88abb2008-01-30 13:30:53 +0100479 if (is_singleblock(request)) {
480 if (unlikely(!arch_has_block_step()))
481 return -EIO;
482 user_enable_block_step(child);
483 } else if (is_singlestep(request) || is_sysemu_singlestep(request)) {
Roland McGrath36df29d2008-01-30 13:30:51 +0100484 if (unlikely(!arch_has_single_step()))
485 return -EIO;
486 user_enable_single_step(child);
Roland McGrath3a709702009-04-07 23:21:06 -0700487 } else {
Roland McGrath36df29d2008-01-30 13:30:51 +0100488 user_disable_single_step(child);
Roland McGrath3a709702009-04-07 23:21:06 -0700489 }
Roland McGrath36df29d2008-01-30 13:30:51 +0100490
491 child->exit_code = data;
492 wake_up_process(child);
493
494 return 0;
495}
496
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497int ptrace_request(struct task_struct *child, long request,
498 long addr, long data)
499{
500 int ret = -EIO;
Roland McGrathe16b2782008-04-20 13:10:12 -0700501 siginfo_t siginfo;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502
503 switch (request) {
Roland McGrath16c3e382008-01-30 13:31:47 +0100504 case PTRACE_PEEKTEXT:
505 case PTRACE_PEEKDATA:
506 return generic_ptrace_peekdata(child, addr, data);
507 case PTRACE_POKETEXT:
508 case PTRACE_POKEDATA:
509 return generic_ptrace_pokedata(child, addr, data);
510
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511#ifdef PTRACE_OLDSETOPTIONS
512 case PTRACE_OLDSETOPTIONS:
513#endif
514 case PTRACE_SETOPTIONS:
515 ret = ptrace_setoptions(child, data);
516 break;
517 case PTRACE_GETEVENTMSG:
518 ret = put_user(child->ptrace_message, (unsigned long __user *) data);
519 break;
Roland McGrathe16b2782008-04-20 13:10:12 -0700520
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 case PTRACE_GETSIGINFO:
Roland McGrathe16b2782008-04-20 13:10:12 -0700522 ret = ptrace_getsiginfo(child, &siginfo);
523 if (!ret)
524 ret = copy_siginfo_to_user((siginfo_t __user *) data,
525 &siginfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 break;
Roland McGrathe16b2782008-04-20 13:10:12 -0700527
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528 case PTRACE_SETSIGINFO:
Roland McGrathe16b2782008-04-20 13:10:12 -0700529 if (copy_from_user(&siginfo, (siginfo_t __user *) data,
530 sizeof siginfo))
531 ret = -EFAULT;
532 else
533 ret = ptrace_setsiginfo(child, &siginfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534 break;
Roland McGrathe16b2782008-04-20 13:10:12 -0700535
Alexey Dobriyan1bcf5482007-10-16 01:23:45 -0700536 case PTRACE_DETACH: /* detach a process that was attached. */
537 ret = ptrace_detach(child, data);
538 break;
Roland McGrath36df29d2008-01-30 13:30:51 +0100539
540#ifdef PTRACE_SINGLESTEP
541 case PTRACE_SINGLESTEP:
542#endif
Roland McGrath5b88abb2008-01-30 13:30:53 +0100543#ifdef PTRACE_SINGLEBLOCK
544 case PTRACE_SINGLEBLOCK:
545#endif
Roland McGrath36df29d2008-01-30 13:30:51 +0100546#ifdef PTRACE_SYSEMU
547 case PTRACE_SYSEMU:
548 case PTRACE_SYSEMU_SINGLESTEP:
549#endif
550 case PTRACE_SYSCALL:
551 case PTRACE_CONT:
552 return ptrace_resume(child, request, data);
553
554 case PTRACE_KILL:
555 if (child->exit_state) /* already dead */
556 return 0;
557 return ptrace_resume(child, request, SIGKILL);
558
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559 default:
560 break;
561 }
562
563 return ret;
564}
Christoph Hellwig481bed42005-11-07 00:59:47 -0800565
Christoph Hellwig6b9c7ed2006-01-08 01:02:33 -0800566/**
567 * ptrace_traceme -- helper for PTRACE_TRACEME
568 *
569 * Performs checks and sets PT_PTRACED.
570 * Should be used by all ptrace implementations for PTRACE_TRACEME.
571 */
572int ptrace_traceme(void)
Christoph Hellwig481bed42005-11-07 00:59:47 -0800573{
Linus Torvaldsf5b40e32006-05-07 10:49:33 -0700574 int ret = -EPERM;
Christoph Hellwig481bed42005-11-07 00:59:47 -0800575
576 /*
Christoph Hellwig6b9c7ed2006-01-08 01:02:33 -0800577 * Are we already being traced?
Christoph Hellwig481bed42005-11-07 00:59:47 -0800578 */
Roland McGrathf4700212008-03-24 18:36:23 -0700579repeat:
Linus Torvaldsf5b40e32006-05-07 10:49:33 -0700580 task_lock(current);
581 if (!(current->ptrace & PT_PTRACED)) {
Roland McGrathf4700212008-03-24 18:36:23 -0700582 /*
583 * See ptrace_attach() comments about the locking here.
584 */
585 unsigned long flags;
586 if (!write_trylock_irqsave(&tasklist_lock, flags)) {
587 task_unlock(current);
588 do {
589 cpu_relax();
590 } while (!write_can_lock(&tasklist_lock));
591 goto repeat;
592 }
593
David Howells5cd9c582008-08-14 11:37:28 +0100594 ret = security_ptrace_traceme(current->parent);
Roland McGrathf4700212008-03-24 18:36:23 -0700595
Linus Torvaldsf5b40e32006-05-07 10:49:33 -0700596 /*
Oleg Nesterovf1671f62009-04-13 14:40:03 -0700597 * Check PF_EXITING to ensure ->real_parent has not passed
598 * exit_ptrace(). Otherwise we don't report the error but
599 * pretend ->real_parent untraces us right after return.
Linus Torvaldsf5b40e32006-05-07 10:49:33 -0700600 */
Oleg Nesterovf1671f62009-04-13 14:40:03 -0700601 if (!ret && !(current->real_parent->flags & PF_EXITING)) {
Linus Torvaldsf5b40e32006-05-07 10:49:33 -0700602 current->ptrace |= PT_PTRACED;
Roland McGrathf4700212008-03-24 18:36:23 -0700603 __ptrace_link(current, current->real_parent);
604 }
605
606 write_unlock_irqrestore(&tasklist_lock, flags);
Linus Torvaldsf5b40e32006-05-07 10:49:33 -0700607 }
608 task_unlock(current);
609 return ret;
Christoph Hellwig6b9c7ed2006-01-08 01:02:33 -0800610}
Christoph Hellwig481bed42005-11-07 00:59:47 -0800611
Christoph Hellwig6b9c7ed2006-01-08 01:02:33 -0800612/**
613 * ptrace_get_task_struct -- grab a task struct reference for ptrace
614 * @pid: process id to grab a task_struct reference of
615 *
616 * This function is a helper for ptrace implementations. It checks
617 * permissions and then grabs a task struct for use of the actual
618 * ptrace implementation.
619 *
620 * Returns the task_struct for @pid or an ERR_PTR() on failure.
621 */
622struct task_struct *ptrace_get_task_struct(pid_t pid)
623{
624 struct task_struct *child;
Christoph Hellwig481bed42005-11-07 00:59:47 -0800625
Christoph Hellwig481bed42005-11-07 00:59:47 -0800626 read_lock(&tasklist_lock);
Pavel Emelyanov228ebcb2007-10-18 23:40:16 -0700627 child = find_task_by_vpid(pid);
Christoph Hellwig481bed42005-11-07 00:59:47 -0800628 if (child)
629 get_task_struct(child);
Sukadev Bhattiproluf400e192006-09-29 02:00:07 -0700630
Christoph Hellwig481bed42005-11-07 00:59:47 -0800631 read_unlock(&tasklist_lock);
632 if (!child)
Christoph Hellwig6b9c7ed2006-01-08 01:02:33 -0800633 return ERR_PTR(-ESRCH);
634 return child;
Christoph Hellwig481bed42005-11-07 00:59:47 -0800635}
636
Christoph Hellwig0ac15552007-10-16 01:26:37 -0700637#ifndef arch_ptrace_attach
638#define arch_ptrace_attach(child) do { } while (0)
639#endif
640
Heiko Carstens1e7bfb22009-01-14 14:14:29 +0100641SYSCALL_DEFINE4(ptrace, long, request, long, pid, long, addr, long, data)
Christoph Hellwig481bed42005-11-07 00:59:47 -0800642{
643 struct task_struct *child;
644 long ret;
645
646 /*
647 * This lock_kernel fixes a subtle race with suid exec
648 */
649 lock_kernel();
Christoph Hellwig6b9c7ed2006-01-08 01:02:33 -0800650 if (request == PTRACE_TRACEME) {
651 ret = ptrace_traceme();
Haavard Skinnemoen6ea6dd92007-11-27 13:02:40 +0100652 if (!ret)
653 arch_ptrace_attach(current);
Christoph Hellwig481bed42005-11-07 00:59:47 -0800654 goto out;
Christoph Hellwig6b9c7ed2006-01-08 01:02:33 -0800655 }
656
657 child = ptrace_get_task_struct(pid);
658 if (IS_ERR(child)) {
659 ret = PTR_ERR(child);
660 goto out;
661 }
Christoph Hellwig481bed42005-11-07 00:59:47 -0800662
663 if (request == PTRACE_ATTACH) {
664 ret = ptrace_attach(child);
Christoph Hellwig0ac15552007-10-16 01:26:37 -0700665 /*
666 * Some architectures need to do book-keeping after
667 * a ptrace attach.
668 */
669 if (!ret)
670 arch_ptrace_attach(child);
Christoph Hellwig005f18d2005-11-13 16:06:33 -0800671 goto out_put_task_struct;
Christoph Hellwig481bed42005-11-07 00:59:47 -0800672 }
673
674 ret = ptrace_check_attach(child, request == PTRACE_KILL);
675 if (ret < 0)
676 goto out_put_task_struct;
677
678 ret = arch_ptrace(child, request, addr, data);
Christoph Hellwig481bed42005-11-07 00:59:47 -0800679
680 out_put_task_struct:
681 put_task_struct(child);
682 out:
683 unlock_kernel();
684 return ret;
685}
Alexey Dobriyan76647322007-07-17 04:03:43 -0700686
687int generic_ptrace_peekdata(struct task_struct *tsk, long addr, long data)
688{
689 unsigned long tmp;
690 int copied;
691
692 copied = access_process_vm(tsk, addr, &tmp, sizeof(tmp), 0);
693 if (copied != sizeof(tmp))
694 return -EIO;
695 return put_user(tmp, (unsigned long __user *)data);
696}
Alexey Dobriyanf284ce72007-07-17 04:03:44 -0700697
698int generic_ptrace_pokedata(struct task_struct *tsk, long addr, long data)
699{
700 int copied;
701
702 copied = access_process_vm(tsk, addr, &data, sizeof(data), 1);
703 return (copied == sizeof(data)) ? 0 : -EIO;
704}
Roland McGrath032d82d2008-01-30 13:31:47 +0100705
Christoph Hellwig96b89362008-11-25 08:10:03 +0100706#if defined CONFIG_COMPAT
Roland McGrath032d82d2008-01-30 13:31:47 +0100707#include <linux/compat.h>
708
709int compat_ptrace_request(struct task_struct *child, compat_long_t request,
710 compat_ulong_t addr, compat_ulong_t data)
711{
712 compat_ulong_t __user *datap = compat_ptr(data);
713 compat_ulong_t word;
Roland McGrathe16b2782008-04-20 13:10:12 -0700714 siginfo_t siginfo;
Roland McGrath032d82d2008-01-30 13:31:47 +0100715 int ret;
716
717 switch (request) {
718 case PTRACE_PEEKTEXT:
719 case PTRACE_PEEKDATA:
720 ret = access_process_vm(child, addr, &word, sizeof(word), 0);
721 if (ret != sizeof(word))
722 ret = -EIO;
723 else
724 ret = put_user(word, datap);
725 break;
726
727 case PTRACE_POKETEXT:
728 case PTRACE_POKEDATA:
729 ret = access_process_vm(child, addr, &data, sizeof(data), 1);
730 ret = (ret != sizeof(data) ? -EIO : 0);
731 break;
732
733 case PTRACE_GETEVENTMSG:
734 ret = put_user((compat_ulong_t) child->ptrace_message, datap);
735 break;
736
Roland McGrathe16b2782008-04-20 13:10:12 -0700737 case PTRACE_GETSIGINFO:
738 ret = ptrace_getsiginfo(child, &siginfo);
739 if (!ret)
740 ret = copy_siginfo_to_user32(
741 (struct compat_siginfo __user *) datap,
742 &siginfo);
743 break;
744
745 case PTRACE_SETSIGINFO:
746 memset(&siginfo, 0, sizeof siginfo);
747 if (copy_siginfo_from_user32(
748 &siginfo, (struct compat_siginfo __user *) datap))
749 ret = -EFAULT;
750 else
751 ret = ptrace_setsiginfo(child, &siginfo);
752 break;
753
Roland McGrath032d82d2008-01-30 13:31:47 +0100754 default:
755 ret = ptrace_request(child, request, addr, data);
756 }
757
758 return ret;
759}
Roland McGrathc269f192008-01-30 13:31:48 +0100760
Roland McGrathc269f192008-01-30 13:31:48 +0100761asmlinkage long compat_sys_ptrace(compat_long_t request, compat_long_t pid,
762 compat_long_t addr, compat_long_t data)
763{
764 struct task_struct *child;
765 long ret;
766
767 /*
768 * This lock_kernel fixes a subtle race with suid exec
769 */
770 lock_kernel();
771 if (request == PTRACE_TRACEME) {
772 ret = ptrace_traceme();
773 goto out;
774 }
775
776 child = ptrace_get_task_struct(pid);
777 if (IS_ERR(child)) {
778 ret = PTR_ERR(child);
779 goto out;
780 }
781
782 if (request == PTRACE_ATTACH) {
783 ret = ptrace_attach(child);
784 /*
785 * Some architectures need to do book-keeping after
786 * a ptrace attach.
787 */
788 if (!ret)
789 arch_ptrace_attach(child);
790 goto out_put_task_struct;
791 }
792
793 ret = ptrace_check_attach(child, request == PTRACE_KILL);
794 if (!ret)
795 ret = compat_arch_ptrace(child, request, addr, data);
796
797 out_put_task_struct:
798 put_task_struct(child);
799 out:
800 unlock_kernel();
801 return ret;
802}
Christoph Hellwig96b89362008-11-25 08:10:03 +0100803#endif /* CONFIG_COMPAT */