thinkpad-acpi: avoid keymap pitfall
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / kernel / ptrace.c
blob0279819f0c2839a5b6483cc66248c70540abfff8
1 /*
2 * linux/kernel/ptrace.c
4 * (C) Copyright 1999 Linus Torvalds
6 * Common interfaces for "ptrace()" which we do not want
7 * to continually duplicate across every architecture.
8 */
10 #include <linux/capability.h>
11 #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>
20 #include <linux/signal.h>
21 #include <linux/audit.h>
22 #include <linux/pid_namespace.h>
23 #include <linux/syscalls.h>
24 #include <linux/uaccess.h>
25 #include <linux/hw_breakpoint.h>
29 * ptrace a task: make the debugger its new parent and
30 * move it to the ptrace list.
32 * Must be called with the tasklist lock write-held.
34 void __ptrace_link(struct task_struct *child, struct task_struct *new_parent)
36 BUG_ON(!list_empty(&child->ptrace_entry));
37 list_add(&child->ptrace_entry, &new_parent->ptraced);
38 child->parent = new_parent;
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.
48 static void ptrace_untrace(struct task_struct *child)
50 spin_lock(&child->sighand->siglock);
51 if (task_is_traced(child)) {
53 * If the group stop is completed or in progress,
54 * this thread was already counted as stopped.
56 if (child->signal->flags & SIGNAL_STOP_STOPPED ||
57 child->signal->group_stop_count)
58 __set_task_state(child, TASK_STOPPED);
59 else
60 signal_wake_up(child, 1);
62 spin_unlock(&child->sighand->siglock);
66 * unptrace a task: move it back to its original parent and
67 * remove it from the ptrace list.
69 * Must be called with the tasklist lock write-held.
71 void __ptrace_unlink(struct task_struct *child)
73 BUG_ON(!child->ptrace);
75 child->ptrace = 0;
76 child->parent = child->real_parent;
77 list_del_init(&child->ptrace_entry);
79 arch_ptrace_untrace(child);
80 if (task_is_traced(child))
81 ptrace_untrace(child);
85 * Check that we have indeed attached to the thing..
87 int ptrace_check_attach(struct task_struct *child, int kill)
89 int ret = -ESRCH;
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.
98 read_lock(&tasklist_lock);
99 if ((child->ptrace & PT_PTRACED) && child->parent == current) {
100 ret = 0;
102 * child->sighand can't be NULL, release_task()
103 * does ptrace_unlink() before __exit_signal().
105 spin_lock_irq(&child->sighand->siglock);
106 if (task_is_stopped(child))
107 child->state = TASK_TRACED;
108 else if (!task_is_traced(child) && !kill)
109 ret = -ESRCH;
110 spin_unlock_irq(&child->sighand->siglock);
112 read_unlock(&tasklist_lock);
114 if (!ret && !kill)
115 ret = wait_task_inactive(child, TASK_TRACED) ? 0 : -ESRCH;
117 /* All systems go.. */
118 return ret;
121 int __ptrace_may_access(struct task_struct *task, unsigned int mode)
123 const struct cred *cred = current_cred(), *tcred;
125 /* 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.
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.
133 int dumpable = 0;
134 /* Don't let security modules deny introspection */
135 if (task == current)
136 return 0;
137 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();
147 return -EPERM;
149 rcu_read_unlock();
150 smp_rmb();
151 if (task->mm)
152 dumpable = get_dumpable(task->mm);
153 if (!dumpable && !capable(CAP_SYS_PTRACE))
154 return -EPERM;
156 return security_ptrace_access_check(task, mode);
159 bool ptrace_may_access(struct task_struct *task, unsigned int mode)
161 int err;
162 task_lock(task);
163 err = __ptrace_may_access(task, mode);
164 task_unlock(task);
165 return !err;
168 int ptrace_attach(struct task_struct *task)
170 int retval;
172 audit_ptrace(task);
174 retval = -EPERM;
175 if (unlikely(task->flags & PF_KTHREAD))
176 goto out;
177 if (same_thread_group(task, current))
178 goto out;
181 * Protect exec's credential calculations against our interference;
182 * interference; SUID, SGID and LSM creds get determined differently
183 * under ptrace.
185 retval = -ERESTARTNOINTR;
186 if (mutex_lock_interruptible(&task->cred_guard_mutex))
187 goto out;
189 task_lock(task);
190 retval = __ptrace_may_access(task, PTRACE_MODE_ATTACH);
191 task_unlock(task);
192 if (retval)
193 goto unlock_creds;
195 write_lock_irq(&tasklist_lock);
196 retval = -EPERM;
197 if (unlikely(task->exit_state))
198 goto unlock_tasklist;
199 if (task->ptrace)
200 goto unlock_tasklist;
202 task->ptrace = PT_PTRACED;
203 if (capable(CAP_SYS_PTRACE))
204 task->ptrace |= PT_PTRACE_CAP;
206 __ptrace_link(task, current);
207 send_sig_info(SIGSTOP, SEND_SIG_FORCED, task);
209 retval = 0;
210 unlock_tasklist:
211 write_unlock_irq(&tasklist_lock);
212 unlock_creds:
213 mutex_unlock(&task->cred_guard_mutex);
214 out:
215 return retval;
219 * ptrace_traceme -- helper for PTRACE_TRACEME
221 * Performs checks and sets PT_PTRACED.
222 * Should be used by all ptrace implementations for PTRACE_TRACEME.
224 int ptrace_traceme(void)
226 int ret = -EPERM;
228 write_lock_irq(&tasklist_lock);
229 /* Are we already being traced? */
230 if (!current->ptrace) {
231 ret = security_ptrace_traceme(current->parent);
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.
237 if (!ret && !(current->real_parent->flags & PF_EXITING)) {
238 current->ptrace = PT_PTRACED;
239 __ptrace_link(current, current->real_parent);
242 write_unlock_irq(&tasklist_lock);
244 return ret;
248 * Called with irqs disabled, returns true if childs should reap themselves.
250 static int ignoring_children(struct sighand_struct *sigh)
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;
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.)
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.
270 * 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().
275 static bool __ptrace_detach(struct task_struct *tracer, struct task_struct *p)
277 __ptrace_unlink(p);
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);
283 else if (ignoring_children(tracer->sighand)) {
284 __wake_up_parent(p, tracer);
285 p->exit_signal = -1;
288 if (task_detached(p)) {
289 /* Mark it as in the process of being reaped. */
290 p->exit_state = EXIT_DEAD;
291 return true;
295 return false;
298 int ptrace_detach(struct task_struct *child, unsigned int data)
300 bool dead = false;
302 if (!valid_signal(data))
303 return -EIO;
305 /* Architecture-specific hardware disable .. */
306 ptrace_disable(child);
307 clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
309 write_lock_irq(&tasklist_lock);
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.
314 if (child->ptrace) {
315 child->exit_code = data;
316 dead = __ptrace_detach(current, child);
317 if (!child->exit_state)
318 wake_up_state(child, TASK_TRACED | TASK_STOPPED);
320 write_unlock_irq(&tasklist_lock);
322 if (unlikely(dead))
323 release_task(child);
325 return 0;
329 * Detach all tasks we were using ptrace on.
331 void exit_ptrace(struct task_struct *tracer)
333 struct task_struct *p, *n;
334 LIST_HEAD(ptrace_dead);
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);
341 write_unlock_irq(&tasklist_lock);
343 BUG_ON(!list_empty(&tracer->ptraced));
345 list_for_each_entry_safe(p, n, &ptrace_dead, ptrace_entry) {
346 list_del_init(&p->ptrace_entry);
347 release_task(p);
351 int ptrace_readdata(struct task_struct *tsk, unsigned long src, char __user *dst, int len)
353 int copied = 0;
355 while (len > 0) {
356 char buf[128];
357 int this_len, retval;
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;
366 if (copy_to_user(dst, buf, retval))
367 return -EFAULT;
368 copied += retval;
369 src += retval;
370 dst += retval;
371 len -= retval;
373 return copied;
376 int ptrace_writedata(struct task_struct *tsk, char __user *src, unsigned long dst, int len)
378 int copied = 0;
380 while (len > 0) {
381 char buf[128];
382 int this_len, retval;
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;
393 copied += retval;
394 src += retval;
395 dst += retval;
396 len -= retval;
398 return copied;
401 static int ptrace_setoptions(struct task_struct *child, long data)
403 child->ptrace &= ~PT_TRACE_MASK;
405 if (data & PTRACE_O_TRACESYSGOOD)
406 child->ptrace |= PT_TRACESYSGOOD;
408 if (data & PTRACE_O_TRACEFORK)
409 child->ptrace |= PT_TRACE_FORK;
411 if (data & PTRACE_O_TRACEVFORK)
412 child->ptrace |= PT_TRACE_VFORK;
414 if (data & PTRACE_O_TRACECLONE)
415 child->ptrace |= PT_TRACE_CLONE;
417 if (data & PTRACE_O_TRACEEXEC)
418 child->ptrace |= PT_TRACE_EXEC;
420 if (data & PTRACE_O_TRACEVFORKDONE)
421 child->ptrace |= PT_TRACE_VFORK_DONE;
423 if (data & PTRACE_O_TRACEEXIT)
424 child->ptrace |= PT_TRACE_EXIT;
426 return (data & ~PTRACE_O_MASK) ? -EINVAL : 0;
429 static int ptrace_getsiginfo(struct task_struct *child, siginfo_t *info)
431 unsigned long flags;
432 int error = -ESRCH;
434 if (lock_task_sighand(child, &flags)) {
435 error = -EINVAL;
436 if (likely(child->last_siginfo != NULL)) {
437 *info = *child->last_siginfo;
438 error = 0;
440 unlock_task_sighand(child, &flags);
442 return error;
445 static int ptrace_setsiginfo(struct task_struct *child, const siginfo_t *info)
447 unsigned long flags;
448 int error = -ESRCH;
450 if (lock_task_sighand(child, &flags)) {
451 error = -EINVAL;
452 if (likely(child->last_siginfo != NULL)) {
453 *child->last_siginfo = *info;
454 error = 0;
456 unlock_task_sighand(child, &flags);
458 return error;
462 #ifdef PTRACE_SINGLESTEP
463 #define is_singlestep(request) ((request) == PTRACE_SINGLESTEP)
464 #else
465 #define is_singlestep(request) 0
466 #endif
468 #ifdef PTRACE_SINGLEBLOCK
469 #define is_singleblock(request) ((request) == PTRACE_SINGLEBLOCK)
470 #else
471 #define is_singleblock(request) 0
472 #endif
474 #ifdef PTRACE_SYSEMU
475 #define is_sysemu_singlestep(request) ((request) == PTRACE_SYSEMU_SINGLESTEP)
476 #else
477 #define is_sysemu_singlestep(request) 0
478 #endif
480 static int ptrace_resume(struct task_struct *child, long request, long data)
482 if (!valid_signal(data))
483 return -EIO;
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);
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
497 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)) {
502 if (unlikely(!arch_has_single_step()))
503 return -EIO;
504 user_enable_single_step(child);
505 } else {
506 user_disable_single_step(child);
509 child->exit_code = data;
510 wake_up_process(child);
512 return 0;
515 int ptrace_request(struct task_struct *child, long request,
516 long addr, long data)
518 int ret = -EIO;
519 siginfo_t siginfo;
521 switch (request) {
522 case PTRACE_PEEKTEXT:
523 case PTRACE_PEEKDATA:
524 return generic_ptrace_peekdata(child, addr, data);
525 case PTRACE_POKETEXT:
526 case PTRACE_POKEDATA:
527 return generic_ptrace_pokedata(child, addr, data);
529 #ifdef PTRACE_OLDSETOPTIONS
530 case PTRACE_OLDSETOPTIONS:
531 #endif
532 case PTRACE_SETOPTIONS:
533 ret = ptrace_setoptions(child, data);
534 break;
535 case PTRACE_GETEVENTMSG:
536 ret = put_user(child->ptrace_message, (unsigned long __user *) data);
537 break;
539 case PTRACE_GETSIGINFO:
540 ret = ptrace_getsiginfo(child, &siginfo);
541 if (!ret)
542 ret = copy_siginfo_to_user((siginfo_t __user *) data,
543 &siginfo);
544 break;
546 case PTRACE_SETSIGINFO:
547 if (copy_from_user(&siginfo, (siginfo_t __user *) data,
548 sizeof siginfo))
549 ret = -EFAULT;
550 else
551 ret = ptrace_setsiginfo(child, &siginfo);
552 break;
554 case PTRACE_DETACH: /* detach a process that was attached. */
555 ret = ptrace_detach(child, data);
556 break;
558 #ifdef PTRACE_SINGLESTEP
559 case PTRACE_SINGLESTEP:
560 #endif
561 #ifdef PTRACE_SINGLEBLOCK
562 case PTRACE_SINGLEBLOCK:
563 #endif
564 #ifdef PTRACE_SYSEMU
565 case PTRACE_SYSEMU:
566 case PTRACE_SYSEMU_SINGLESTEP:
567 #endif
568 case PTRACE_SYSCALL:
569 case PTRACE_CONT:
570 return ptrace_resume(child, request, data);
572 case PTRACE_KILL:
573 if (child->exit_state) /* already dead */
574 return 0;
575 return ptrace_resume(child, request, SIGKILL);
577 default:
578 break;
581 return ret;
584 static struct task_struct *ptrace_get_task_struct(pid_t pid)
586 struct task_struct *child;
588 rcu_read_lock();
589 child = find_task_by_vpid(pid);
590 if (child)
591 get_task_struct(child);
592 rcu_read_unlock();
594 if (!child)
595 return ERR_PTR(-ESRCH);
596 return child;
599 #ifndef arch_ptrace_attach
600 #define arch_ptrace_attach(child) do { } while (0)
601 #endif
603 SYSCALL_DEFINE4(ptrace, long, request, long, pid, long, addr, long, data)
605 struct task_struct *child;
606 long ret;
609 * This lock_kernel fixes a subtle race with suid exec
611 lock_kernel();
612 if (request == PTRACE_TRACEME) {
613 ret = ptrace_traceme();
614 if (!ret)
615 arch_ptrace_attach(current);
616 goto out;
619 child = ptrace_get_task_struct(pid);
620 if (IS_ERR(child)) {
621 ret = PTR_ERR(child);
622 goto out;
625 if (request == PTRACE_ATTACH) {
626 ret = ptrace_attach(child);
628 * Some architectures need to do book-keeping after
629 * a ptrace attach.
631 if (!ret)
632 arch_ptrace_attach(child);
633 goto out_put_task_struct;
636 ret = ptrace_check_attach(child, request == PTRACE_KILL);
637 if (ret < 0)
638 goto out_put_task_struct;
640 ret = arch_ptrace(child, request, addr, data);
642 out_put_task_struct:
643 put_task_struct(child);
644 out:
645 unlock_kernel();
646 return ret;
649 int generic_ptrace_peekdata(struct task_struct *tsk, long addr, long data)
651 unsigned long tmp;
652 int copied;
654 copied = access_process_vm(tsk, addr, &tmp, sizeof(tmp), 0);
655 if (copied != sizeof(tmp))
656 return -EIO;
657 return put_user(tmp, (unsigned long __user *)data);
660 int generic_ptrace_pokedata(struct task_struct *tsk, long addr, long data)
662 int copied;
664 copied = access_process_vm(tsk, addr, &data, sizeof(data), 1);
665 return (copied == sizeof(data)) ? 0 : -EIO;
668 #if defined CONFIG_COMPAT
669 #include <linux/compat.h>
671 int compat_ptrace_request(struct task_struct *child, compat_long_t request,
672 compat_ulong_t addr, compat_ulong_t data)
674 compat_ulong_t __user *datap = compat_ptr(data);
675 compat_ulong_t word;
676 siginfo_t siginfo;
677 int ret;
679 switch (request) {
680 case PTRACE_PEEKTEXT:
681 case PTRACE_PEEKDATA:
682 ret = access_process_vm(child, addr, &word, sizeof(word), 0);
683 if (ret != sizeof(word))
684 ret = -EIO;
685 else
686 ret = put_user(word, datap);
687 break;
689 case PTRACE_POKETEXT:
690 case PTRACE_POKEDATA:
691 ret = access_process_vm(child, addr, &data, sizeof(data), 1);
692 ret = (ret != sizeof(data) ? -EIO : 0);
693 break;
695 case PTRACE_GETEVENTMSG:
696 ret = put_user((compat_ulong_t) child->ptrace_message, datap);
697 break;
699 case PTRACE_GETSIGINFO:
700 ret = ptrace_getsiginfo(child, &siginfo);
701 if (!ret)
702 ret = copy_siginfo_to_user32(
703 (struct compat_siginfo __user *) datap,
704 &siginfo);
705 break;
707 case PTRACE_SETSIGINFO:
708 memset(&siginfo, 0, sizeof siginfo);
709 if (copy_siginfo_from_user32(
710 &siginfo, (struct compat_siginfo __user *) datap))
711 ret = -EFAULT;
712 else
713 ret = ptrace_setsiginfo(child, &siginfo);
714 break;
716 default:
717 ret = ptrace_request(child, request, addr, data);
720 return ret;
723 asmlinkage long compat_sys_ptrace(compat_long_t request, compat_long_t pid,
724 compat_long_t addr, compat_long_t data)
726 struct task_struct *child;
727 long ret;
730 * This lock_kernel fixes a subtle race with suid exec
732 lock_kernel();
733 if (request == PTRACE_TRACEME) {
734 ret = ptrace_traceme();
735 goto out;
738 child = ptrace_get_task_struct(pid);
739 if (IS_ERR(child)) {
740 ret = PTR_ERR(child);
741 goto out;
744 if (request == PTRACE_ATTACH) {
745 ret = ptrace_attach(child);
747 * Some architectures need to do book-keeping after
748 * a ptrace attach.
750 if (!ret)
751 arch_ptrace_attach(child);
752 goto out_put_task_struct;
755 ret = ptrace_check_attach(child, request == PTRACE_KILL);
756 if (!ret)
757 ret = compat_arch_ptrace(child, request, addr, data);
759 out_put_task_struct:
760 put_task_struct(child);
761 out:
762 unlock_kernel();
763 return ret;
765 #endif /* CONFIG_COMPAT */
767 #ifdef CONFIG_HAVE_HW_BREAKPOINT
768 int ptrace_get_breakpoints(struct task_struct *tsk)
770 if (atomic_inc_not_zero(&tsk->ptrace_bp_refcnt))
771 return 0;
773 return -1;
776 void ptrace_put_breakpoints(struct task_struct *tsk)
778 if (atomic_dec_and_test(&tsk->ptrace_bp_refcnt))
779 flush_ptrace_hw_breakpoint(tsk);
781 #endif /* CONFIG_HAVE_HW_BREAKPOINT */