Root/
Source at commit cdde9cf73945d547acd3e96f9508c79e84ad0bf1 created 12 years 9 months ago. By Maarten ter Huurne, MMC: JZ4740: Added support for CPU frequency changing | |
---|---|
1 | /* |
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 | |
10 | #include <linux/capability.h> |
11 | #include <linux/export.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/ptrace.h> |
18 | #include <linux/security.h> |
19 | #include <linux/signal.h> |
20 | #include <linux/audit.h> |
21 | #include <linux/pid_namespace.h> |
22 | #include <linux/syscalls.h> |
23 | #include <linux/uaccess.h> |
24 | #include <linux/regset.h> |
25 | #include <linux/hw_breakpoint.h> |
26 | #include <linux/cn_proc.h> |
27 | |
28 | |
29 | static int ptrace_trapping_sleep_fn(void *flags) |
30 | { |
31 | schedule(); |
32 | return 0; |
33 | } |
34 | |
35 | /* |
36 | * ptrace a task: make the debugger its new parent and |
37 | * move it to the ptrace list. |
38 | * |
39 | * Must be called with the tasklist lock write-held. |
40 | */ |
41 | void __ptrace_link(struct task_struct *child, struct task_struct *new_parent) |
42 | { |
43 | BUG_ON(!list_empty(&child->ptrace_entry)); |
44 | list_add(&child->ptrace_entry, &new_parent->ptraced); |
45 | child->parent = new_parent; |
46 | } |
47 | |
48 | /** |
49 | * __ptrace_unlink - unlink ptracee and restore its execution state |
50 | * @child: ptracee to be unlinked |
51 | * |
52 | * Remove @child from the ptrace list, move it back to the original parent, |
53 | * and restore the execution state so that it conforms to the group stop |
54 | * state. |
55 | * |
56 | * Unlinking can happen via two paths - explicit PTRACE_DETACH or ptracer |
57 | * exiting. For PTRACE_DETACH, unless the ptracee has been killed between |
58 | * ptrace_check_attach() and here, it's guaranteed to be in TASK_TRACED. |
59 | * If the ptracer is exiting, the ptracee can be in any state. |
60 | * |
61 | * After detach, the ptracee should be in a state which conforms to the |
62 | * group stop. If the group is stopped or in the process of stopping, the |
63 | * ptracee should be put into TASK_STOPPED; otherwise, it should be woken |
64 | * up from TASK_TRACED. |
65 | * |
66 | * If the ptracee is in TASK_TRACED and needs to be moved to TASK_STOPPED, |
67 | * it goes through TRACED -> RUNNING -> STOPPED transition which is similar |
68 | * to but in the opposite direction of what happens while attaching to a |
69 | * stopped task. However, in this direction, the intermediate RUNNING |
70 | * state is not hidden even from the current ptracer and if it immediately |
71 | * re-attaches and performs a WNOHANG wait(2), it may fail. |
72 | * |
73 | * CONTEXT: |
74 | * write_lock_irq(tasklist_lock) |
75 | */ |
76 | void __ptrace_unlink(struct task_struct *child) |
77 | { |
78 | BUG_ON(!child->ptrace); |
79 | |
80 | child->ptrace = 0; |
81 | child->parent = child->real_parent; |
82 | list_del_init(&child->ptrace_entry); |
83 | |
84 | spin_lock(&child->sighand->siglock); |
85 | |
86 | /* |
87 | * Clear all pending traps and TRAPPING. TRAPPING should be |
88 | * cleared regardless of JOBCTL_STOP_PENDING. Do it explicitly. |
89 | */ |
90 | task_clear_jobctl_pending(child, JOBCTL_TRAP_MASK); |
91 | task_clear_jobctl_trapping(child); |
92 | |
93 | /* |
94 | * Reinstate JOBCTL_STOP_PENDING if group stop is in effect and |
95 | * @child isn't dead. |
96 | */ |
97 | if (!(child->flags & PF_EXITING) && |
98 | (child->signal->flags & SIGNAL_STOP_STOPPED || |
99 | child->signal->group_stop_count)) { |
100 | child->jobctl |= JOBCTL_STOP_PENDING; |
101 | |
102 | /* |
103 | * This is only possible if this thread was cloned by the |
104 | * traced task running in the stopped group, set the signal |
105 | * for the future reports. |
106 | * FIXME: we should change ptrace_init_task() to handle this |
107 | * case. |
108 | */ |
109 | if (!(child->jobctl & JOBCTL_STOP_SIGMASK)) |
110 | child->jobctl |= SIGSTOP; |
111 | } |
112 | |
113 | /* |
114 | * If transition to TASK_STOPPED is pending or in TASK_TRACED, kick |
115 | * @child in the butt. Note that @resume should be used iff @child |
116 | * is in TASK_TRACED; otherwise, we might unduly disrupt |
117 | * TASK_KILLABLE sleeps. |
118 | */ |
119 | if (child->jobctl & JOBCTL_STOP_PENDING || task_is_traced(child)) |
120 | signal_wake_up(child, task_is_traced(child)); |
121 | |
122 | spin_unlock(&child->sighand->siglock); |
123 | } |
124 | |
125 | /** |
126 | * ptrace_check_attach - check whether ptracee is ready for ptrace operation |
127 | * @child: ptracee to check for |
128 | * @ignore_state: don't check whether @child is currently %TASK_TRACED |
129 | * |
130 | * Check whether @child is being ptraced by %current and ready for further |
131 | * ptrace operations. If @ignore_state is %false, @child also should be in |
132 | * %TASK_TRACED state and on return the child is guaranteed to be traced |
133 | * and not executing. If @ignore_state is %true, @child can be in any |
134 | * state. |
135 | * |
136 | * CONTEXT: |
137 | * Grabs and releases tasklist_lock and @child->sighand->siglock. |
138 | * |
139 | * RETURNS: |
140 | * 0 on success, -ESRCH if %child is not ready. |
141 | */ |
142 | int ptrace_check_attach(struct task_struct *child, bool ignore_state) |
143 | { |
144 | int ret = -ESRCH; |
145 | |
146 | /* |
147 | * We take the read lock around doing both checks to close a |
148 | * possible race where someone else was tracing our child and |
149 | * detached between these two checks. After this locked check, |
150 | * we are sure that this is our traced child and that can only |
151 | * be changed by us so it's not changing right after this. |
152 | */ |
153 | read_lock(&tasklist_lock); |
154 | if ((child->ptrace & PT_PTRACED) && child->parent == current) { |
155 | /* |
156 | * child->sighand can't be NULL, release_task() |
157 | * does ptrace_unlink() before __exit_signal(). |
158 | */ |
159 | spin_lock_irq(&child->sighand->siglock); |
160 | WARN_ON_ONCE(task_is_stopped(child)); |
161 | if (ignore_state || (task_is_traced(child) && |
162 | !(child->jobctl & JOBCTL_LISTENING))) |
163 | ret = 0; |
164 | spin_unlock_irq(&child->sighand->siglock); |
165 | } |
166 | read_unlock(&tasklist_lock); |
167 | |
168 | if (!ret && !ignore_state) |
169 | ret = wait_task_inactive(child, TASK_TRACED) ? 0 : -ESRCH; |
170 | |
171 | /* All systems go.. */ |
172 | return ret; |
173 | } |
174 | |
175 | static int ptrace_has_cap(struct user_namespace *ns, unsigned int mode) |
176 | { |
177 | if (mode & PTRACE_MODE_NOAUDIT) |
178 | return has_ns_capability_noaudit(current, ns, CAP_SYS_PTRACE); |
179 | else |
180 | return has_ns_capability(current, ns, CAP_SYS_PTRACE); |
181 | } |
182 | |
183 | int __ptrace_may_access(struct task_struct *task, unsigned int mode) |
184 | { |
185 | const struct cred *cred = current_cred(), *tcred; |
186 | |
187 | /* May we inspect the given task? |
188 | * This check is used both for attaching with ptrace |
189 | * and for allowing access to sensitive information in /proc. |
190 | * |
191 | * ptrace_attach denies several cases that /proc allows |
192 | * because setting up the necessary parent/child relationship |
193 | * or halting the specified task is impossible. |
194 | */ |
195 | int dumpable = 0; |
196 | /* Don't let security modules deny introspection */ |
197 | if (task == current) |
198 | return 0; |
199 | rcu_read_lock(); |
200 | tcred = __task_cred(task); |
201 | if (uid_eq(cred->uid, tcred->euid) && |
202 | uid_eq(cred->uid, tcred->suid) && |
203 | uid_eq(cred->uid, tcred->uid) && |
204 | gid_eq(cred->gid, tcred->egid) && |
205 | gid_eq(cred->gid, tcred->sgid) && |
206 | gid_eq(cred->gid, tcred->gid)) |
207 | goto ok; |
208 | if (ptrace_has_cap(tcred->user_ns, mode)) |
209 | goto ok; |
210 | rcu_read_unlock(); |
211 | return -EPERM; |
212 | ok: |
213 | rcu_read_unlock(); |
214 | smp_rmb(); |
215 | if (task->mm) |
216 | dumpable = get_dumpable(task->mm); |
217 | if (!dumpable && !ptrace_has_cap(task_user_ns(task), mode)) |
218 | return -EPERM; |
219 | |
220 | return security_ptrace_access_check(task, mode); |
221 | } |
222 | |
223 | bool ptrace_may_access(struct task_struct *task, unsigned int mode) |
224 | { |
225 | int err; |
226 | task_lock(task); |
227 | err = __ptrace_may_access(task, mode); |
228 | task_unlock(task); |
229 | return !err; |
230 | } |
231 | |
232 | static int ptrace_attach(struct task_struct *task, long request, |
233 | unsigned long addr, |
234 | unsigned long flags) |
235 | { |
236 | bool seize = (request == PTRACE_SEIZE); |
237 | int retval; |
238 | |
239 | retval = -EIO; |
240 | if (seize) { |
241 | if (addr != 0) |
242 | goto out; |
243 | if (flags & ~(unsigned long)PTRACE_O_MASK) |
244 | goto out; |
245 | flags = PT_PTRACED | PT_SEIZED | (flags << PT_OPT_FLAG_SHIFT); |
246 | } else { |
247 | flags = PT_PTRACED; |
248 | } |
249 | |
250 | audit_ptrace(task); |
251 | |
252 | retval = -EPERM; |
253 | if (unlikely(task->flags & PF_KTHREAD)) |
254 | goto out; |
255 | if (same_thread_group(task, current)) |
256 | goto out; |
257 | |
258 | /* |
259 | * Protect exec's credential calculations against our interference; |
260 | * SUID, SGID and LSM creds get determined differently |
261 | * under ptrace. |
262 | */ |
263 | retval = -ERESTARTNOINTR; |
264 | if (mutex_lock_interruptible(&task->signal->cred_guard_mutex)) |
265 | goto out; |
266 | |
267 | task_lock(task); |
268 | retval = __ptrace_may_access(task, PTRACE_MODE_ATTACH); |
269 | task_unlock(task); |
270 | if (retval) |
271 | goto unlock_creds; |
272 | |
273 | write_lock_irq(&tasklist_lock); |
274 | retval = -EPERM; |
275 | if (unlikely(task->exit_state)) |
276 | goto unlock_tasklist; |
277 | if (task->ptrace) |
278 | goto unlock_tasklist; |
279 | |
280 | if (seize) |
281 | flags |= PT_SEIZED; |
282 | if (ns_capable(task_user_ns(task), CAP_SYS_PTRACE)) |
283 | flags |= PT_PTRACE_CAP; |
284 | task->ptrace = flags; |
285 | |
286 | __ptrace_link(task, current); |
287 | |
288 | /* SEIZE doesn't trap tracee on attach */ |
289 | if (!seize) |
290 | send_sig_info(SIGSTOP, SEND_SIG_FORCED, task); |
291 | |
292 | spin_lock(&task->sighand->siglock); |
293 | |
294 | /* |
295 | * If the task is already STOPPED, set JOBCTL_TRAP_STOP and |
296 | * TRAPPING, and kick it so that it transits to TRACED. TRAPPING |
297 | * will be cleared if the child completes the transition or any |
298 | * event which clears the group stop states happens. We'll wait |
299 | * for the transition to complete before returning from this |
300 | * function. |
301 | * |
302 | * This hides STOPPED -> RUNNING -> TRACED transition from the |
303 | * attaching thread but a different thread in the same group can |
304 | * still observe the transient RUNNING state. IOW, if another |
305 | * thread's WNOHANG wait(2) on the stopped tracee races against |
306 | * ATTACH, the wait(2) may fail due to the transient RUNNING. |
307 | * |
308 | * The following task_is_stopped() test is safe as both transitions |
309 | * in and out of STOPPED are protected by siglock. |
310 | */ |
311 | if (task_is_stopped(task) && |
312 | task_set_jobctl_pending(task, JOBCTL_TRAP_STOP | JOBCTL_TRAPPING)) |
313 | signal_wake_up(task, 1); |
314 | |
315 | spin_unlock(&task->sighand->siglock); |
316 | |
317 | retval = 0; |
318 | unlock_tasklist: |
319 | write_unlock_irq(&tasklist_lock); |
320 | unlock_creds: |
321 | mutex_unlock(&task->signal->cred_guard_mutex); |
322 | out: |
323 | if (!retval) { |
324 | wait_on_bit(&task->jobctl, JOBCTL_TRAPPING_BIT, |
325 | ptrace_trapping_sleep_fn, TASK_UNINTERRUPTIBLE); |
326 | proc_ptrace_connector(task, PTRACE_ATTACH); |
327 | } |
328 | |
329 | return retval; |
330 | } |
331 | |
332 | /** |
333 | * ptrace_traceme -- helper for PTRACE_TRACEME |
334 | * |
335 | * Performs checks and sets PT_PTRACED. |
336 | * Should be used by all ptrace implementations for PTRACE_TRACEME. |
337 | */ |
338 | static int ptrace_traceme(void) |
339 | { |
340 | int ret = -EPERM; |
341 | |
342 | write_lock_irq(&tasklist_lock); |
343 | /* Are we already being traced? */ |
344 | if (!current->ptrace) { |
345 | ret = security_ptrace_traceme(current->parent); |
346 | /* |
347 | * Check PF_EXITING to ensure ->real_parent has not passed |
348 | * exit_ptrace(). Otherwise we don't report the error but |
349 | * pretend ->real_parent untraces us right after return. |
350 | */ |
351 | if (!ret && !(current->real_parent->flags & PF_EXITING)) { |
352 | current->ptrace = PT_PTRACED; |
353 | __ptrace_link(current, current->real_parent); |
354 | } |
355 | } |
356 | write_unlock_irq(&tasklist_lock); |
357 | |
358 | return ret; |
359 | } |
360 | |
361 | /* |
362 | * Called with irqs disabled, returns true if childs should reap themselves. |
363 | */ |
364 | static int ignoring_children(struct sighand_struct *sigh) |
365 | { |
366 | int ret; |
367 | spin_lock(&sigh->siglock); |
368 | ret = (sigh->action[SIGCHLD-1].sa.sa_handler == SIG_IGN) || |
369 | (sigh->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT); |
370 | spin_unlock(&sigh->siglock); |
371 | return ret; |
372 | } |
373 | |
374 | /* |
375 | * Called with tasklist_lock held for writing. |
376 | * Unlink a traced task, and clean it up if it was a traced zombie. |
377 | * Return true if it needs to be reaped with release_task(). |
378 | * (We can't call release_task() here because we already hold tasklist_lock.) |
379 | * |
380 | * If it's a zombie, our attachedness prevented normal parent notification |
381 | * or self-reaping. Do notification now if it would have happened earlier. |
382 | * If it should reap itself, return true. |
383 | * |
384 | * If it's our own child, there is no notification to do. But if our normal |
385 | * children self-reap, then this child was prevented by ptrace and we must |
386 | * reap it now, in that case we must also wake up sub-threads sleeping in |
387 | * do_wait(). |
388 | */ |
389 | static bool __ptrace_detach(struct task_struct *tracer, struct task_struct *p) |
390 | { |
391 | bool dead; |
392 | |
393 | __ptrace_unlink(p); |
394 | |
395 | if (p->exit_state != EXIT_ZOMBIE) |
396 | return false; |
397 | |
398 | dead = !thread_group_leader(p); |
399 | |
400 | if (!dead && thread_group_empty(p)) { |
401 | if (!same_thread_group(p->real_parent, tracer)) |
402 | dead = do_notify_parent(p, p->exit_signal); |
403 | else if (ignoring_children(tracer->sighand)) { |
404 | __wake_up_parent(p, tracer); |
405 | dead = true; |
406 | } |
407 | } |
408 | /* Mark it as in the process of being reaped. */ |
409 | if (dead) |
410 | p->exit_state = EXIT_DEAD; |
411 | return dead; |
412 | } |
413 | |
414 | static int ptrace_detach(struct task_struct *child, unsigned int data) |
415 | { |
416 | bool dead = false; |
417 | |
418 | if (!valid_signal(data)) |
419 | return -EIO; |
420 | |
421 | /* Architecture-specific hardware disable .. */ |
422 | ptrace_disable(child); |
423 | clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE); |
424 | |
425 | write_lock_irq(&tasklist_lock); |
426 | /* |
427 | * This child can be already killed. Make sure de_thread() or |
428 | * our sub-thread doing do_wait() didn't do release_task() yet. |
429 | */ |
430 | if (child->ptrace) { |
431 | child->exit_code = data; |
432 | dead = __ptrace_detach(current, child); |
433 | } |
434 | write_unlock_irq(&tasklist_lock); |
435 | |
436 | proc_ptrace_connector(child, PTRACE_DETACH); |
437 | if (unlikely(dead)) |
438 | release_task(child); |
439 | |
440 | return 0; |
441 | } |
442 | |
443 | /* |
444 | * Detach all tasks we were using ptrace on. Called with tasklist held |
445 | * for writing, and returns with it held too. But note it can release |
446 | * and reacquire the lock. |
447 | */ |
448 | void exit_ptrace(struct task_struct *tracer) |
449 | __releases(&tasklist_lock) |
450 | __acquires(&tasklist_lock) |
451 | { |
452 | struct task_struct *p, *n; |
453 | LIST_HEAD(ptrace_dead); |
454 | |
455 | if (likely(list_empty(&tracer->ptraced))) |
456 | return; |
457 | |
458 | list_for_each_entry_safe(p, n, &tracer->ptraced, ptrace_entry) { |
459 | if (__ptrace_detach(tracer, p)) |
460 | list_add(&p->ptrace_entry, &ptrace_dead); |
461 | } |
462 | |
463 | write_unlock_irq(&tasklist_lock); |
464 | BUG_ON(!list_empty(&tracer->ptraced)); |
465 | |
466 | list_for_each_entry_safe(p, n, &ptrace_dead, ptrace_entry) { |
467 | list_del_init(&p->ptrace_entry); |
468 | release_task(p); |
469 | } |
470 | |
471 | write_lock_irq(&tasklist_lock); |
472 | } |
473 | |
474 | int ptrace_readdata(struct task_struct *tsk, unsigned long src, char __user *dst, int len) |
475 | { |
476 | int copied = 0; |
477 | |
478 | while (len > 0) { |
479 | char buf[128]; |
480 | int this_len, retval; |
481 | |
482 | this_len = (len > sizeof(buf)) ? sizeof(buf) : len; |
483 | retval = access_process_vm(tsk, src, buf, this_len, 0); |
484 | if (!retval) { |
485 | if (copied) |
486 | break; |
487 | return -EIO; |
488 | } |
489 | if (copy_to_user(dst, buf, retval)) |
490 | return -EFAULT; |
491 | copied += retval; |
492 | src += retval; |
493 | dst += retval; |
494 | len -= retval; |
495 | } |
496 | return copied; |
497 | } |
498 | |
499 | int ptrace_writedata(struct task_struct *tsk, char __user *src, unsigned long dst, int len) |
500 | { |
501 | int copied = 0; |
502 | |
503 | while (len > 0) { |
504 | char buf[128]; |
505 | int this_len, retval; |
506 | |
507 | this_len = (len > sizeof(buf)) ? sizeof(buf) : len; |
508 | if (copy_from_user(buf, src, this_len)) |
509 | return -EFAULT; |
510 | retval = access_process_vm(tsk, dst, buf, this_len, 1); |
511 | if (!retval) { |
512 | if (copied) |
513 | break; |
514 | return -EIO; |
515 | } |
516 | copied += retval; |
517 | src += retval; |
518 | dst += retval; |
519 | len -= retval; |
520 | } |
521 | return copied; |
522 | } |
523 | |
524 | static int ptrace_setoptions(struct task_struct *child, unsigned long data) |
525 | { |
526 | unsigned flags; |
527 | |
528 | if (data & ~(unsigned long)PTRACE_O_MASK) |
529 | return -EINVAL; |
530 | |
531 | /* Avoid intermediate state when all opts are cleared */ |
532 | flags = child->ptrace; |
533 | flags &= ~(PTRACE_O_MASK << PT_OPT_FLAG_SHIFT); |
534 | flags |= (data << PT_OPT_FLAG_SHIFT); |
535 | child->ptrace = flags; |
536 | |
537 | return 0; |
538 | } |
539 | |
540 | static int ptrace_getsiginfo(struct task_struct *child, siginfo_t *info) |
541 | { |
542 | unsigned long flags; |
543 | int error = -ESRCH; |
544 | |
545 | if (lock_task_sighand(child, &flags)) { |
546 | error = -EINVAL; |
547 | if (likely(child->last_siginfo != NULL)) { |
548 | *info = *child->last_siginfo; |
549 | error = 0; |
550 | } |
551 | unlock_task_sighand(child, &flags); |
552 | } |
553 | return error; |
554 | } |
555 | |
556 | static int ptrace_setsiginfo(struct task_struct *child, const siginfo_t *info) |
557 | { |
558 | unsigned long flags; |
559 | int error = -ESRCH; |
560 | |
561 | if (lock_task_sighand(child, &flags)) { |
562 | error = -EINVAL; |
563 | if (likely(child->last_siginfo != NULL)) { |
564 | *child->last_siginfo = *info; |
565 | error = 0; |
566 | } |
567 | unlock_task_sighand(child, &flags); |
568 | } |
569 | return error; |
570 | } |
571 | |
572 | |
573 | #ifdef PTRACE_SINGLESTEP |
574 | #define is_singlestep(request) ((request) == PTRACE_SINGLESTEP) |
575 | #else |
576 | #define is_singlestep(request) 0 |
577 | #endif |
578 | |
579 | #ifdef PTRACE_SINGLEBLOCK |
580 | #define is_singleblock(request) ((request) == PTRACE_SINGLEBLOCK) |
581 | #else |
582 | #define is_singleblock(request) 0 |
583 | #endif |
584 | |
585 | #ifdef PTRACE_SYSEMU |
586 | #define is_sysemu_singlestep(request) ((request) == PTRACE_SYSEMU_SINGLESTEP) |
587 | #else |
588 | #define is_sysemu_singlestep(request) 0 |
589 | #endif |
590 | |
591 | static int ptrace_resume(struct task_struct *child, long request, |
592 | unsigned long data) |
593 | { |
594 | if (!valid_signal(data)) |
595 | return -EIO; |
596 | |
597 | if (request == PTRACE_SYSCALL) |
598 | set_tsk_thread_flag(child, TIF_SYSCALL_TRACE); |
599 | else |
600 | clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE); |
601 | |
602 | #ifdef TIF_SYSCALL_EMU |
603 | if (request == PTRACE_SYSEMU || request == PTRACE_SYSEMU_SINGLESTEP) |
604 | set_tsk_thread_flag(child, TIF_SYSCALL_EMU); |
605 | else |
606 | clear_tsk_thread_flag(child, TIF_SYSCALL_EMU); |
607 | #endif |
608 | |
609 | if (is_singleblock(request)) { |
610 | if (unlikely(!arch_has_block_step())) |
611 | return -EIO; |
612 | user_enable_block_step(child); |
613 | } else if (is_singlestep(request) || is_sysemu_singlestep(request)) { |
614 | if (unlikely(!arch_has_single_step())) |
615 | return -EIO; |
616 | user_enable_single_step(child); |
617 | } else { |
618 | user_disable_single_step(child); |
619 | } |
620 | |
621 | child->exit_code = data; |
622 | wake_up_state(child, __TASK_TRACED); |
623 | |
624 | return 0; |
625 | } |
626 | |
627 | #ifdef CONFIG_HAVE_ARCH_TRACEHOOK |
628 | |
629 | static const struct user_regset * |
630 | find_regset(const struct user_regset_view *view, unsigned int type) |
631 | { |
632 | const struct user_regset *regset; |
633 | int n; |
634 | |
635 | for (n = 0; n < view->n; ++n) { |
636 | regset = view->regsets + n; |
637 | if (regset->core_note_type == type) |
638 | return regset; |
639 | } |
640 | |
641 | return NULL; |
642 | } |
643 | |
644 | static int ptrace_regset(struct task_struct *task, int req, unsigned int type, |
645 | struct iovec *kiov) |
646 | { |
647 | const struct user_regset_view *view = task_user_regset_view(task); |
648 | const struct user_regset *regset = find_regset(view, type); |
649 | int regset_no; |
650 | |
651 | if (!regset || (kiov->iov_len % regset->size) != 0) |
652 | return -EINVAL; |
653 | |
654 | regset_no = regset - view->regsets; |
655 | kiov->iov_len = min(kiov->iov_len, |
656 | (__kernel_size_t) (regset->n * regset->size)); |
657 | |
658 | if (req == PTRACE_GETREGSET) |
659 | return copy_regset_to_user(task, view, regset_no, 0, |
660 | kiov->iov_len, kiov->iov_base); |
661 | else |
662 | return copy_regset_from_user(task, view, regset_no, 0, |
663 | kiov->iov_len, kiov->iov_base); |
664 | } |
665 | |
666 | #endif |
667 | |
668 | int ptrace_request(struct task_struct *child, long request, |
669 | unsigned long addr, unsigned long data) |
670 | { |
671 | bool seized = child->ptrace & PT_SEIZED; |
672 | int ret = -EIO; |
673 | siginfo_t siginfo, *si; |
674 | void __user *datavp = (void __user *) data; |
675 | unsigned long __user *datalp = datavp; |
676 | unsigned long flags; |
677 | |
678 | switch (request) { |
679 | case PTRACE_PEEKTEXT: |
680 | case PTRACE_PEEKDATA: |
681 | return generic_ptrace_peekdata(child, addr, data); |
682 | case PTRACE_POKETEXT: |
683 | case PTRACE_POKEDATA: |
684 | return generic_ptrace_pokedata(child, addr, data); |
685 | |
686 | #ifdef PTRACE_OLDSETOPTIONS |
687 | case PTRACE_OLDSETOPTIONS: |
688 | #endif |
689 | case PTRACE_SETOPTIONS: |
690 | ret = ptrace_setoptions(child, data); |
691 | break; |
692 | case PTRACE_GETEVENTMSG: |
693 | ret = put_user(child->ptrace_message, datalp); |
694 | break; |
695 | |
696 | case PTRACE_GETSIGINFO: |
697 | ret = ptrace_getsiginfo(child, &siginfo); |
698 | if (!ret) |
699 | ret = copy_siginfo_to_user(datavp, &siginfo); |
700 | break; |
701 | |
702 | case PTRACE_SETSIGINFO: |
703 | if (copy_from_user(&siginfo, datavp, sizeof siginfo)) |
704 | ret = -EFAULT; |
705 | else |
706 | ret = ptrace_setsiginfo(child, &siginfo); |
707 | break; |
708 | |
709 | case PTRACE_INTERRUPT: |
710 | /* |
711 | * Stop tracee without any side-effect on signal or job |
712 | * control. At least one trap is guaranteed to happen |
713 | * after this request. If @child is already trapped, the |
714 | * current trap is not disturbed and another trap will |
715 | * happen after the current trap is ended with PTRACE_CONT. |
716 | * |
717 | * The actual trap might not be PTRACE_EVENT_STOP trap but |
718 | * the pending condition is cleared regardless. |
719 | */ |
720 | if (unlikely(!seized || !lock_task_sighand(child, &flags))) |
721 | break; |
722 | |
723 | /* |
724 | * INTERRUPT doesn't disturb existing trap sans one |
725 | * exception. If ptracer issued LISTEN for the current |
726 | * STOP, this INTERRUPT should clear LISTEN and re-trap |
727 | * tracee into STOP. |
728 | */ |
729 | if (likely(task_set_jobctl_pending(child, JOBCTL_TRAP_STOP))) |
730 | signal_wake_up(child, child->jobctl & JOBCTL_LISTENING); |
731 | |
732 | unlock_task_sighand(child, &flags); |
733 | ret = 0; |
734 | break; |
735 | |
736 | case PTRACE_LISTEN: |
737 | /* |
738 | * Listen for events. Tracee must be in STOP. It's not |
739 | * resumed per-se but is not considered to be in TRACED by |
740 | * wait(2) or ptrace(2). If an async event (e.g. group |
741 | * stop state change) happens, tracee will enter STOP trap |
742 | * again. Alternatively, ptracer can issue INTERRUPT to |
743 | * finish listening and re-trap tracee into STOP. |
744 | */ |
745 | if (unlikely(!seized || !lock_task_sighand(child, &flags))) |
746 | break; |
747 | |
748 | si = child->last_siginfo; |
749 | if (likely(si && (si->si_code >> 8) == PTRACE_EVENT_STOP)) { |
750 | child->jobctl |= JOBCTL_LISTENING; |
751 | /* |
752 | * If NOTIFY is set, it means event happened between |
753 | * start of this trap and now. Trigger re-trap. |
754 | */ |
755 | if (child->jobctl & JOBCTL_TRAP_NOTIFY) |
756 | signal_wake_up(child, true); |
757 | ret = 0; |
758 | } |
759 | unlock_task_sighand(child, &flags); |
760 | break; |
761 | |
762 | case PTRACE_DETACH: /* detach a process that was attached. */ |
763 | ret = ptrace_detach(child, data); |
764 | break; |
765 | |
766 | #ifdef CONFIG_BINFMT_ELF_FDPIC |
767 | case PTRACE_GETFDPIC: { |
768 | struct mm_struct *mm = get_task_mm(child); |
769 | unsigned long tmp = 0; |
770 | |
771 | ret = -ESRCH; |
772 | if (!mm) |
773 | break; |
774 | |
775 | switch (addr) { |
776 | case PTRACE_GETFDPIC_EXEC: |
777 | tmp = mm->context.exec_fdpic_loadmap; |
778 | break; |
779 | case PTRACE_GETFDPIC_INTERP: |
780 | tmp = mm->context.interp_fdpic_loadmap; |
781 | break; |
782 | default: |
783 | break; |
784 | } |
785 | mmput(mm); |
786 | |
787 | ret = put_user(tmp, datalp); |
788 | break; |
789 | } |
790 | #endif |
791 | |
792 | #ifdef PTRACE_SINGLESTEP |
793 | case PTRACE_SINGLESTEP: |
794 | #endif |
795 | #ifdef PTRACE_SINGLEBLOCK |
796 | case PTRACE_SINGLEBLOCK: |
797 | #endif |
798 | #ifdef PTRACE_SYSEMU |
799 | case PTRACE_SYSEMU: |
800 | case PTRACE_SYSEMU_SINGLESTEP: |
801 | #endif |
802 | case PTRACE_SYSCALL: |
803 | case PTRACE_CONT: |
804 | return ptrace_resume(child, request, data); |
805 | |
806 | case PTRACE_KILL: |
807 | if (child->exit_state) /* already dead */ |
808 | return 0; |
809 | return ptrace_resume(child, request, SIGKILL); |
810 | |
811 | #ifdef CONFIG_HAVE_ARCH_TRACEHOOK |
812 | case PTRACE_GETREGSET: |
813 | case PTRACE_SETREGSET: |
814 | { |
815 | struct iovec kiov; |
816 | struct iovec __user *uiov = datavp; |
817 | |
818 | if (!access_ok(VERIFY_WRITE, uiov, sizeof(*uiov))) |
819 | return -EFAULT; |
820 | |
821 | if (__get_user(kiov.iov_base, &uiov->iov_base) || |
822 | __get_user(kiov.iov_len, &uiov->iov_len)) |
823 | return -EFAULT; |
824 | |
825 | ret = ptrace_regset(child, request, addr, &kiov); |
826 | if (!ret) |
827 | ret = __put_user(kiov.iov_len, &uiov->iov_len); |
828 | break; |
829 | } |
830 | #endif |
831 | default: |
832 | break; |
833 | } |
834 | |
835 | return ret; |
836 | } |
837 | |
838 | static struct task_struct *ptrace_get_task_struct(pid_t pid) |
839 | { |
840 | struct task_struct *child; |
841 | |
842 | rcu_read_lock(); |
843 | child = find_task_by_vpid(pid); |
844 | if (child) |
845 | get_task_struct(child); |
846 | rcu_read_unlock(); |
847 | |
848 | if (!child) |
849 | return ERR_PTR(-ESRCH); |
850 | return child; |
851 | } |
852 | |
853 | #ifndef arch_ptrace_attach |
854 | #define arch_ptrace_attach(child) do { } while (0) |
855 | #endif |
856 | |
857 | SYSCALL_DEFINE4(ptrace, long, request, long, pid, unsigned long, addr, |
858 | unsigned long, data) |
859 | { |
860 | struct task_struct *child; |
861 | long ret; |
862 | |
863 | if (request == PTRACE_TRACEME) { |
864 | ret = ptrace_traceme(); |
865 | if (!ret) |
866 | arch_ptrace_attach(current); |
867 | goto out; |
868 | } |
869 | |
870 | child = ptrace_get_task_struct(pid); |
871 | if (IS_ERR(child)) { |
872 | ret = PTR_ERR(child); |
873 | goto out; |
874 | } |
875 | |
876 | if (request == PTRACE_ATTACH || request == PTRACE_SEIZE) { |
877 | ret = ptrace_attach(child, request, addr, data); |
878 | /* |
879 | * Some architectures need to do book-keeping after |
880 | * a ptrace attach. |
881 | */ |
882 | if (!ret) |
883 | arch_ptrace_attach(child); |
884 | goto out_put_task_struct; |
885 | } |
886 | |
887 | ret = ptrace_check_attach(child, request == PTRACE_KILL || |
888 | request == PTRACE_INTERRUPT); |
889 | if (ret < 0) |
890 | goto out_put_task_struct; |
891 | |
892 | ret = arch_ptrace(child, request, addr, data); |
893 | |
894 | out_put_task_struct: |
895 | put_task_struct(child); |
896 | out: |
897 | return ret; |
898 | } |
899 | |
900 | int generic_ptrace_peekdata(struct task_struct *tsk, unsigned long addr, |
901 | unsigned long data) |
902 | { |
903 | unsigned long tmp; |
904 | int copied; |
905 | |
906 | copied = access_process_vm(tsk, addr, &tmp, sizeof(tmp), 0); |
907 | if (copied != sizeof(tmp)) |
908 | return -EIO; |
909 | return put_user(tmp, (unsigned long __user *)data); |
910 | } |
911 | |
912 | int generic_ptrace_pokedata(struct task_struct *tsk, unsigned long addr, |
913 | unsigned long data) |
914 | { |
915 | int copied; |
916 | |
917 | copied = access_process_vm(tsk, addr, &data, sizeof(data), 1); |
918 | return (copied == sizeof(data)) ? 0 : -EIO; |
919 | } |
920 | |
921 | #if defined CONFIG_COMPAT |
922 | #include <linux/compat.h> |
923 | |
924 | int compat_ptrace_request(struct task_struct *child, compat_long_t request, |
925 | compat_ulong_t addr, compat_ulong_t data) |
926 | { |
927 | compat_ulong_t __user *datap = compat_ptr(data); |
928 | compat_ulong_t word; |
929 | siginfo_t siginfo; |
930 | int ret; |
931 | |
932 | switch (request) { |
933 | case PTRACE_PEEKTEXT: |
934 | case PTRACE_PEEKDATA: |
935 | ret = access_process_vm(child, addr, &word, sizeof(word), 0); |
936 | if (ret != sizeof(word)) |
937 | ret = -EIO; |
938 | else |
939 | ret = put_user(word, datap); |
940 | break; |
941 | |
942 | case PTRACE_POKETEXT: |
943 | case PTRACE_POKEDATA: |
944 | ret = access_process_vm(child, addr, &data, sizeof(data), 1); |
945 | ret = (ret != sizeof(data) ? -EIO : 0); |
946 | break; |
947 | |
948 | case PTRACE_GETEVENTMSG: |
949 | ret = put_user((compat_ulong_t) child->ptrace_message, datap); |
950 | break; |
951 | |
952 | case PTRACE_GETSIGINFO: |
953 | ret = ptrace_getsiginfo(child, &siginfo); |
954 | if (!ret) |
955 | ret = copy_siginfo_to_user32( |
956 | (struct compat_siginfo __user *) datap, |
957 | &siginfo); |
958 | break; |
959 | |
960 | case PTRACE_SETSIGINFO: |
961 | memset(&siginfo, 0, sizeof siginfo); |
962 | if (copy_siginfo_from_user32( |
963 | &siginfo, (struct compat_siginfo __user *) datap)) |
964 | ret = -EFAULT; |
965 | else |
966 | ret = ptrace_setsiginfo(child, &siginfo); |
967 | break; |
968 | #ifdef CONFIG_HAVE_ARCH_TRACEHOOK |
969 | case PTRACE_GETREGSET: |
970 | case PTRACE_SETREGSET: |
971 | { |
972 | struct iovec kiov; |
973 | struct compat_iovec __user *uiov = |
974 | (struct compat_iovec __user *) datap; |
975 | compat_uptr_t ptr; |
976 | compat_size_t len; |
977 | |
978 | if (!access_ok(VERIFY_WRITE, uiov, sizeof(*uiov))) |
979 | return -EFAULT; |
980 | |
981 | if (__get_user(ptr, &uiov->iov_base) || |
982 | __get_user(len, &uiov->iov_len)) |
983 | return -EFAULT; |
984 | |
985 | kiov.iov_base = compat_ptr(ptr); |
986 | kiov.iov_len = len; |
987 | |
988 | ret = ptrace_regset(child, request, addr, &kiov); |
989 | if (!ret) |
990 | ret = __put_user(kiov.iov_len, &uiov->iov_len); |
991 | break; |
992 | } |
993 | #endif |
994 | |
995 | default: |
996 | ret = ptrace_request(child, request, addr, data); |
997 | } |
998 | |
999 | return ret; |
1000 | } |
1001 | |
1002 | asmlinkage long compat_sys_ptrace(compat_long_t request, compat_long_t pid, |
1003 | compat_long_t addr, compat_long_t data) |
1004 | { |
1005 | struct task_struct *child; |
1006 | long ret; |
1007 | |
1008 | if (request == PTRACE_TRACEME) { |
1009 | ret = ptrace_traceme(); |
1010 | goto out; |
1011 | } |
1012 | |
1013 | child = ptrace_get_task_struct(pid); |
1014 | if (IS_ERR(child)) { |
1015 | ret = PTR_ERR(child); |
1016 | goto out; |
1017 | } |
1018 | |
1019 | if (request == PTRACE_ATTACH || request == PTRACE_SEIZE) { |
1020 | ret = ptrace_attach(child, request, addr, data); |
1021 | /* |
1022 | * Some architectures need to do book-keeping after |
1023 | * a ptrace attach. |
1024 | */ |
1025 | if (!ret) |
1026 | arch_ptrace_attach(child); |
1027 | goto out_put_task_struct; |
1028 | } |
1029 | |
1030 | ret = ptrace_check_attach(child, request == PTRACE_KILL || |
1031 | request == PTRACE_INTERRUPT); |
1032 | if (!ret) |
1033 | ret = compat_arch_ptrace(child, request, addr, data); |
1034 | |
1035 | out_put_task_struct: |
1036 | put_task_struct(child); |
1037 | out: |
1038 | return ret; |
1039 | } |
1040 | #endif /* CONFIG_COMPAT */ |
1041 | |
1042 | #ifdef CONFIG_HAVE_HW_BREAKPOINT |
1043 | int ptrace_get_breakpoints(struct task_struct *tsk) |
1044 | { |
1045 | if (atomic_inc_not_zero(&tsk->ptrace_bp_refcnt)) |
1046 | return 0; |
1047 | |
1048 | return -1; |
1049 | } |
1050 | |
1051 | void ptrace_put_breakpoints(struct task_struct *tsk) |
1052 | { |
1053 | if (atomic_dec_and_test(&tsk->ptrace_bp_refcnt)) |
1054 | flush_ptrace_hw_breakpoint(tsk); |
1055 | } |
1056 | #endif /* CONFIG_HAVE_HW_BREAKPOINT */ |
1057 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9