Blame view
kernel/ptrace.c
17.5 KB
1da177e4c
|
1 2 3 4 5 6 7 8 |
/* * linux/kernel/ptrace.c * * (C) Copyright 1999 Linus Torvalds * * Common interfaces for "ptrace()" which we do not want * to continually duplicate across every architecture. */ |
c59ede7b7
|
9 |
#include <linux/capability.h> |
1da177e4c
|
10 11 12 13 14 15 16 17 18 |
#include <linux/module.h> #include <linux/sched.h> #include <linux/errno.h> #include <linux/mm.h> #include <linux/highmem.h> #include <linux/pagemap.h> #include <linux/smp_lock.h> #include <linux/ptrace.h> #include <linux/security.h> |
7ed20e1ad
|
19 |
#include <linux/signal.h> |
a5cb013da
|
20 |
#include <linux/audit.h> |
b488893a3
|
21 |
#include <linux/pid_namespace.h> |
f17d30a80
|
22 |
#include <linux/syscalls.h> |
3a7097035
|
23 |
#include <linux/uaccess.h> |
1da177e4c
|
24 |
|
bf53de907
|
25 26 |
/* |
1da177e4c
|
27 28 29 30 31 |
* ptrace a task: make the debugger its new parent and * move it to the ptrace list. * * Must be called with the tasklist lock write-held. */ |
36c8b5868
|
32 |
void __ptrace_link(struct task_struct *child, struct task_struct *new_parent) |
1da177e4c
|
33 |
{ |
f470021ad
|
34 35 |
BUG_ON(!list_empty(&child->ptrace_entry)); list_add(&child->ptrace_entry, &new_parent->ptraced); |
1da177e4c
|
36 |
child->parent = new_parent; |
1da177e4c
|
37 |
} |
3a7097035
|
38 |
|
1da177e4c
|
39 40 41 42 43 44 45 |
/* * Turn a tracing stop into a normal stop now, since with no tracer there * would be no way to wake it up with SIGCONT or SIGKILL. If there was a * signal sent that would resume the child, but didn't because it was in * TASK_TRACED, resume it now. * Requires that irqs be disabled. */ |
b747c8c10
|
46 |
static void ptrace_untrace(struct task_struct *child) |
1da177e4c
|
47 48 |
{ spin_lock(&child->sighand->siglock); |
6618a3e27
|
49 |
if (task_is_traced(child)) { |
1ee118448
|
50 51 52 53 54 55 |
/* * If the group stop is completed or in progress, * this thread was already counted as stopped. */ if (child->signal->flags & SIGNAL_STOP_STOPPED || child->signal->group_stop_count) |
d9ae90ac4
|
56 |
__set_task_state(child, TASK_STOPPED); |
1ee118448
|
57 |
else |
1da177e4c
|
58 |
signal_wake_up(child, 1); |
1da177e4c
|
59 60 61 62 63 64 65 66 67 68 |
} spin_unlock(&child->sighand->siglock); } /* * unptrace a task: move it back to its original parent and * remove it from the ptrace list. * * Must be called with the tasklist lock write-held. */ |
36c8b5868
|
69 |
void __ptrace_unlink(struct task_struct *child) |
1da177e4c
|
70 |
{ |
5ecfbae09
|
71 |
BUG_ON(!child->ptrace); |
1da177e4c
|
72 |
child->ptrace = 0; |
f470021ad
|
73 74 |
child->parent = child->real_parent; list_del_init(&child->ptrace_entry); |
1da177e4c
|
75 |
|
bf53de907
|
76 |
arch_ptrace_untrace(child); |
6618a3e27
|
77 |
if (task_is_traced(child)) |
e57a50598
|
78 |
ptrace_untrace(child); |
1da177e4c
|
79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 |
} /* * Check that we have indeed attached to the thing.. */ int ptrace_check_attach(struct task_struct *child, int kill) { int ret = -ESRCH; /* * We take the read lock around doing both checks to close a * possible race where someone else was tracing our child and * detached between these two checks. After this locked check, * we are sure that this is our traced child and that can only * be changed by us so it's not changing right after this. */ read_lock(&tasklist_lock); |
c0c0b649d
|
96 |
if ((child->ptrace & PT_PTRACED) && child->parent == current) { |
1da177e4c
|
97 |
ret = 0; |
c0c0b649d
|
98 99 100 101 |
/* * child->sighand can't be NULL, release_task() * does ptrace_unlink() before __exit_signal(). */ |
1da177e4c
|
102 |
spin_lock_irq(&child->sighand->siglock); |
d9ae90ac4
|
103 |
if (task_is_stopped(child)) |
1da177e4c
|
104 |
child->state = TASK_TRACED; |
d9ae90ac4
|
105 |
else if (!task_is_traced(child) && !kill) |
1da177e4c
|
106 |
ret = -ESRCH; |
1da177e4c
|
107 108 109 |
spin_unlock_irq(&child->sighand->siglock); } read_unlock(&tasklist_lock); |
d9ae90ac4
|
110 |
if (!ret && !kill) |
85ba2d862
|
111 |
ret = wait_task_inactive(child, TASK_TRACED) ? 0 : -ESRCH; |
1da177e4c
|
112 113 114 115 |
/* All systems go.. */ return ret; } |
006ebb40d
|
116 |
int __ptrace_may_access(struct task_struct *task, unsigned int mode) |
ab8d11beb
|
117 |
{ |
c69e8d9c0
|
118 |
const struct cred *cred = current_cred(), *tcred; |
b6dff3ec5
|
119 |
|
df26c40e5
|
120 121 122 123 124 125 126 127 128 129 130 131 |
/* May we inspect the given task? * This check is used both for attaching with ptrace * and for allowing access to sensitive information in /proc. * * ptrace_attach denies several cases that /proc allows * because setting up the necessary parent/child relationship * or halting the specified task is impossible. */ int dumpable = 0; /* Don't let security modules deny introspection */ if (task == current) return 0; |
c69e8d9c0
|
132 133 134 135 136 137 138 139 140 141 |
rcu_read_lock(); tcred = __task_cred(task); if ((cred->uid != tcred->euid || cred->uid != tcred->suid || cred->uid != tcred->uid || cred->gid != tcred->egid || cred->gid != tcred->sgid || cred->gid != tcred->gid) && !capable(CAP_SYS_PTRACE)) { rcu_read_unlock(); |
ab8d11beb
|
142 |
return -EPERM; |
c69e8d9c0
|
143 144 |
} rcu_read_unlock(); |
ab8d11beb
|
145 |
smp_rmb(); |
df26c40e5
|
146 |
if (task->mm) |
6c5d52382
|
147 |
dumpable = get_dumpable(task->mm); |
df26c40e5
|
148 |
if (!dumpable && !capable(CAP_SYS_PTRACE)) |
ab8d11beb
|
149 |
return -EPERM; |
5cd9c58fb
|
150 |
return security_ptrace_may_access(task, mode); |
ab8d11beb
|
151 |
} |
006ebb40d
|
152 |
bool ptrace_may_access(struct task_struct *task, unsigned int mode) |
ab8d11beb
|
153 154 155 |
{ int err; task_lock(task); |
006ebb40d
|
156 |
err = __ptrace_may_access(task, mode); |
ab8d11beb
|
157 |
task_unlock(task); |
3a7097035
|
158 |
return !err; |
ab8d11beb
|
159 |
} |
1da177e4c
|
160 161 162 |
int ptrace_attach(struct task_struct *task) { int retval; |
f5b40e363
|
163 |
|
a5cb013da
|
164 |
audit_ptrace(task); |
1da177e4c
|
165 |
retval = -EPERM; |
b79b7ba93
|
166 167 |
if (unlikely(task->flags & PF_KTHREAD)) goto out; |
bac0abd61
|
168 |
if (same_thread_group(task, current)) |
f5b40e363
|
169 |
goto out; |
f2f0b00ad
|
170 171 |
/* * Protect exec's credential calculations against our interference; |
5e751e992
|
172 173 |
* interference; SUID, SGID and LSM creds get determined differently * under ptrace. |
d84f4f992
|
174 |
*/ |
5e751e992
|
175 |
retval = mutex_lock_interruptible(&task->cred_guard_mutex); |
f2f0b00ad
|
176 |
if (retval < 0) |
d84f4f992
|
177 |
goto out; |
f5b40e363
|
178 |
|
4b105cbba
|
179 |
task_lock(task); |
006ebb40d
|
180 |
retval = __ptrace_may_access(task, PTRACE_MODE_ATTACH); |
4b105cbba
|
181 |
task_unlock(task); |
1da177e4c
|
182 |
if (retval) |
4b105cbba
|
183 |
goto unlock_creds; |
1da177e4c
|
184 |
|
4b105cbba
|
185 |
write_lock_irq(&tasklist_lock); |
b79b7ba93
|
186 187 |
retval = -EPERM; if (unlikely(task->exit_state)) |
4b105cbba
|
188 |
goto unlock_tasklist; |
f2f0b00ad
|
189 |
if (task->ptrace) |
4b105cbba
|
190 |
goto unlock_tasklist; |
b79b7ba93
|
191 |
|
f2f0b00ad
|
192 |
task->ptrace = PT_PTRACED; |
1da177e4c
|
193 194 |
if (capable(CAP_SYS_PTRACE)) task->ptrace |= PT_PTRACE_CAP; |
1da177e4c
|
195 |
|
1da177e4c
|
196 |
__ptrace_link(task, current); |
33e9fc7d0
|
197 |
send_sig_info(SIGSTOP, SEND_SIG_FORCED, task); |
b79b7ba93
|
198 199 |
retval = 0; |
4b105cbba
|
200 201 202 |
unlock_tasklist: write_unlock_irq(&tasklist_lock); unlock_creds: |
5e751e992
|
203 |
mutex_unlock(&task->cred_guard_mutex); |
f5b40e363
|
204 |
out: |
1da177e4c
|
205 206 |
return retval; } |
f2f0b00ad
|
207 208 209 210 211 212 213 214 215 |
/** * ptrace_traceme -- helper for PTRACE_TRACEME * * Performs checks and sets PT_PTRACED. * Should be used by all ptrace implementations for PTRACE_TRACEME. */ int ptrace_traceme(void) { int ret = -EPERM; |
4b105cbba
|
216 217 |
write_lock_irq(&tasklist_lock); /* Are we already being traced? */ |
f2f0b00ad
|
218 |
if (!current->ptrace) { |
f2f0b00ad
|
219 |
ret = security_ptrace_traceme(current->parent); |
f2f0b00ad
|
220 221 222 223 224 225 226 227 228 |
/* * Check PF_EXITING to ensure ->real_parent has not passed * exit_ptrace(). Otherwise we don't report the error but * pretend ->real_parent untraces us right after return. */ if (!ret && !(current->real_parent->flags & PF_EXITING)) { current->ptrace = PT_PTRACED; __ptrace_link(current, current->real_parent); } |
f2f0b00ad
|
229 |
} |
4b105cbba
|
230 |
write_unlock_irq(&tasklist_lock); |
f2f0b00ad
|
231 232 |
return ret; } |
39c626ae4
|
233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 |
/* * Called with irqs disabled, returns true if childs should reap themselves. */ static int ignoring_children(struct sighand_struct *sigh) { int ret; spin_lock(&sigh->siglock); ret = (sigh->action[SIGCHLD-1].sa.sa_handler == SIG_IGN) || (sigh->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT); spin_unlock(&sigh->siglock); return ret; } /* * Called with tasklist_lock held for writing. * Unlink a traced task, and clean it up if it was a traced zombie. * Return true if it needs to be reaped with release_task(). * (We can't call release_task() here because we already hold tasklist_lock.) * * If it's a zombie, our attachedness prevented normal parent notification * or self-reaping. Do notification now if it would have happened earlier. * If it should reap itself, return true. * * If it's our own child, there is no notification to do. * But if our normal children self-reap, then this child * was prevented by ptrace and we must reap it now. */ static bool __ptrace_detach(struct task_struct *tracer, struct task_struct *p) { __ptrace_unlink(p); if (p->exit_state == EXIT_ZOMBIE) { if (!task_detached(p) && thread_group_empty(p)) { if (!same_thread_group(p->real_parent, tracer)) do_notify_parent(p, p->exit_signal); else if (ignoring_children(tracer->sighand)) p->exit_signal = -1; } if (task_detached(p)) { /* Mark it as in the process of being reaped. */ p->exit_state = EXIT_DEAD; return true; } } return false; } |
1da177e4c
|
280 281 |
int ptrace_detach(struct task_struct *child, unsigned int data) { |
39c626ae4
|
282 |
bool dead = false; |
4576145c1
|
283 |
|
7ed20e1ad
|
284 |
if (!valid_signal(data)) |
5ecfbae09
|
285 |
return -EIO; |
1da177e4c
|
286 287 288 |
/* Architecture-specific hardware disable .. */ ptrace_disable(child); |
7d9414329
|
289 |
clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE); |
1da177e4c
|
290 |
|
95c3eb76d
|
291 |
write_lock_irq(&tasklist_lock); |
39c626ae4
|
292 293 294 295 |
/* * This child can be already killed. Make sure de_thread() or * our sub-thread doing do_wait() didn't do release_task() yet. */ |
95c3eb76d
|
296 297 |
if (child->ptrace) { child->exit_code = data; |
4576145c1
|
298 |
dead = __ptrace_detach(current, child); |
edaba2c53
|
299 300 |
if (!child->exit_state) wake_up_process(child); |
95c3eb76d
|
301 |
} |
1da177e4c
|
302 |
write_unlock_irq(&tasklist_lock); |
4576145c1
|
303 304 |
if (unlikely(dead)) release_task(child); |
1da177e4c
|
305 306 |
return 0; } |
39c626ae4
|
307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 |
/* * Detach all tasks we were using ptrace on. */ void exit_ptrace(struct task_struct *tracer) { struct task_struct *p, *n; LIST_HEAD(ptrace_dead); write_lock_irq(&tasklist_lock); list_for_each_entry_safe(p, n, &tracer->ptraced, ptrace_entry) { if (__ptrace_detach(tracer, p)) list_add(&p->ptrace_entry, &ptrace_dead); } write_unlock_irq(&tasklist_lock); BUG_ON(!list_empty(&tracer->ptraced)); list_for_each_entry_safe(p, n, &ptrace_dead, ptrace_entry) { list_del_init(&p->ptrace_entry); release_task(p); } } |
1da177e4c
|
329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 |
int ptrace_readdata(struct task_struct *tsk, unsigned long src, char __user *dst, int len) { int copied = 0; while (len > 0) { char buf[128]; int this_len, retval; this_len = (len > sizeof(buf)) ? sizeof(buf) : len; retval = access_process_vm(tsk, src, buf, this_len, 0); if (!retval) { if (copied) break; return -EIO; } if (copy_to_user(dst, buf, retval)) return -EFAULT; copied += retval; src += retval; dst += retval; |
3a7097035
|
349 |
len -= retval; |
1da177e4c
|
350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 |
} return copied; } int ptrace_writedata(struct task_struct *tsk, char __user *src, unsigned long dst, int len) { int copied = 0; while (len > 0) { char buf[128]; int this_len, retval; this_len = (len > sizeof(buf)) ? sizeof(buf) : len; if (copy_from_user(buf, src, this_len)) return -EFAULT; retval = access_process_vm(tsk, dst, buf, this_len, 1); if (!retval) { if (copied) break; return -EIO; } copied += retval; src += retval; dst += retval; |
3a7097035
|
374 |
len -= retval; |
1da177e4c
|
375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 |
} return copied; } static int ptrace_setoptions(struct task_struct *child, long data) { child->ptrace &= ~PT_TRACE_MASK; if (data & PTRACE_O_TRACESYSGOOD) child->ptrace |= PT_TRACESYSGOOD; if (data & PTRACE_O_TRACEFORK) child->ptrace |= PT_TRACE_FORK; if (data & PTRACE_O_TRACEVFORK) child->ptrace |= PT_TRACE_VFORK; if (data & PTRACE_O_TRACECLONE) child->ptrace |= PT_TRACE_CLONE; if (data & PTRACE_O_TRACEEXEC) child->ptrace |= PT_TRACE_EXEC; if (data & PTRACE_O_TRACEVFORKDONE) child->ptrace |= PT_TRACE_VFORK_DONE; if (data & PTRACE_O_TRACEEXIT) child->ptrace |= PT_TRACE_EXIT; return (data & ~PTRACE_O_MASK) ? -EINVAL : 0; } |
e16b27816
|
406 |
static int ptrace_getsiginfo(struct task_struct *child, siginfo_t *info) |
1da177e4c
|
407 |
{ |
e49612544
|
408 |
unsigned long flags; |
1da177e4c
|
409 |
int error = -ESRCH; |
e49612544
|
410 |
if (lock_task_sighand(child, &flags)) { |
1da177e4c
|
411 |
error = -EINVAL; |
1da177e4c
|
412 |
if (likely(child->last_siginfo != NULL)) { |
e16b27816
|
413 |
*info = *child->last_siginfo; |
1da177e4c
|
414 415 |
error = 0; } |
e49612544
|
416 |
unlock_task_sighand(child, &flags); |
1da177e4c
|
417 |
} |
1da177e4c
|
418 419 |
return error; } |
e16b27816
|
420 |
static int ptrace_setsiginfo(struct task_struct *child, const siginfo_t *info) |
1da177e4c
|
421 |
{ |
e49612544
|
422 |
unsigned long flags; |
1da177e4c
|
423 |
int error = -ESRCH; |
e49612544
|
424 |
if (lock_task_sighand(child, &flags)) { |
1da177e4c
|
425 |
error = -EINVAL; |
1da177e4c
|
426 |
if (likely(child->last_siginfo != NULL)) { |
e16b27816
|
427 |
*child->last_siginfo = *info; |
1da177e4c
|
428 429 |
error = 0; } |
e49612544
|
430 |
unlock_task_sighand(child, &flags); |
1da177e4c
|
431 |
} |
1da177e4c
|
432 433 |
return error; } |
36df29d79
|
434 435 436 437 438 439 |
#ifdef PTRACE_SINGLESTEP #define is_singlestep(request) ((request) == PTRACE_SINGLESTEP) #else #define is_singlestep(request) 0 #endif |
5b88abbf7
|
440 441 442 443 444 |
#ifdef PTRACE_SINGLEBLOCK #define is_singleblock(request) ((request) == PTRACE_SINGLEBLOCK) #else #define is_singleblock(request) 0 #endif |
36df29d79
|
445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 |
#ifdef PTRACE_SYSEMU #define is_sysemu_singlestep(request) ((request) == PTRACE_SYSEMU_SINGLESTEP) #else #define is_sysemu_singlestep(request) 0 #endif static int ptrace_resume(struct task_struct *child, long request, long data) { if (!valid_signal(data)) return -EIO; if (request == PTRACE_SYSCALL) set_tsk_thread_flag(child, TIF_SYSCALL_TRACE); else clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE); #ifdef TIF_SYSCALL_EMU if (request == PTRACE_SYSEMU || request == PTRACE_SYSEMU_SINGLESTEP) set_tsk_thread_flag(child, TIF_SYSCALL_EMU); else clear_tsk_thread_flag(child, TIF_SYSCALL_EMU); #endif |
5b88abbf7
|
467 468 469 470 471 |
if (is_singleblock(request)) { if (unlikely(!arch_has_block_step())) return -EIO; user_enable_block_step(child); } else if (is_singlestep(request) || is_sysemu_singlestep(request)) { |
36df29d79
|
472 473 474 |
if (unlikely(!arch_has_single_step())) return -EIO; user_enable_single_step(child); |
3a7097035
|
475 |
} else { |
36df29d79
|
476 |
user_disable_single_step(child); |
3a7097035
|
477 |
} |
36df29d79
|
478 479 480 481 482 483 |
child->exit_code = data; wake_up_process(child); return 0; } |
1da177e4c
|
484 485 486 487 |
int ptrace_request(struct task_struct *child, long request, long addr, long data) { int ret = -EIO; |
e16b27816
|
488 |
siginfo_t siginfo; |
1da177e4c
|
489 490 |
switch (request) { |
16c3e389e
|
491 492 493 494 495 496 |
case PTRACE_PEEKTEXT: case PTRACE_PEEKDATA: return generic_ptrace_peekdata(child, addr, data); case PTRACE_POKETEXT: case PTRACE_POKEDATA: return generic_ptrace_pokedata(child, addr, data); |
1da177e4c
|
497 498 499 500 501 502 503 504 505 |
#ifdef PTRACE_OLDSETOPTIONS case PTRACE_OLDSETOPTIONS: #endif case PTRACE_SETOPTIONS: ret = ptrace_setoptions(child, data); break; case PTRACE_GETEVENTMSG: ret = put_user(child->ptrace_message, (unsigned long __user *) data); break; |
e16b27816
|
506 |
|
1da177e4c
|
507 |
case PTRACE_GETSIGINFO: |
e16b27816
|
508 509 510 511 |
ret = ptrace_getsiginfo(child, &siginfo); if (!ret) ret = copy_siginfo_to_user((siginfo_t __user *) data, &siginfo); |
1da177e4c
|
512 |
break; |
e16b27816
|
513 |
|
1da177e4c
|
514 |
case PTRACE_SETSIGINFO: |
e16b27816
|
515 516 517 518 519 |
if (copy_from_user(&siginfo, (siginfo_t __user *) data, sizeof siginfo)) ret = -EFAULT; else ret = ptrace_setsiginfo(child, &siginfo); |
1da177e4c
|
520 |
break; |
e16b27816
|
521 |
|
1bcf54829
|
522 523 524 |
case PTRACE_DETACH: /* detach a process that was attached. */ ret = ptrace_detach(child, data); break; |
36df29d79
|
525 526 527 528 |
#ifdef PTRACE_SINGLESTEP case PTRACE_SINGLESTEP: #endif |
5b88abbf7
|
529 530 531 |
#ifdef PTRACE_SINGLEBLOCK case PTRACE_SINGLEBLOCK: #endif |
36df29d79
|
532 533 534 535 536 537 538 539 540 541 542 543 |
#ifdef PTRACE_SYSEMU case PTRACE_SYSEMU: case PTRACE_SYSEMU_SINGLESTEP: #endif case PTRACE_SYSCALL: case PTRACE_CONT: return ptrace_resume(child, request, data); case PTRACE_KILL: if (child->exit_state) /* already dead */ return 0; return ptrace_resume(child, request, SIGKILL); |
1da177e4c
|
544 545 546 547 548 549 |
default: break; } return ret; } |
481bed454
|
550 |
|
8053bdd5c
|
551 |
static struct task_struct *ptrace_get_task_struct(pid_t pid) |
6b9c7ed84
|
552 553 |
{ struct task_struct *child; |
481bed454
|
554 |
|
8053bdd5c
|
555 |
rcu_read_lock(); |
228ebcbe6
|
556 |
child = find_task_by_vpid(pid); |
481bed454
|
557 558 |
if (child) get_task_struct(child); |
8053bdd5c
|
559 |
rcu_read_unlock(); |
f400e198b
|
560 |
|
481bed454
|
561 |
if (!child) |
6b9c7ed84
|
562 563 |
return ERR_PTR(-ESRCH); return child; |
481bed454
|
564 |
} |
0ac155591
|
565 566 567 |
#ifndef arch_ptrace_attach #define arch_ptrace_attach(child) do { } while (0) #endif |
1e7bfb213
|
568 |
SYSCALL_DEFINE4(ptrace, long, request, long, pid, long, addr, long, data) |
481bed454
|
569 570 571 572 573 574 575 576 |
{ struct task_struct *child; long ret; /* * This lock_kernel fixes a subtle race with suid exec */ lock_kernel(); |
6b9c7ed84
|
577 578 |
if (request == PTRACE_TRACEME) { ret = ptrace_traceme(); |
6ea6dd93c
|
579 580 |
if (!ret) arch_ptrace_attach(current); |
481bed454
|
581 |
goto out; |
6b9c7ed84
|
582 583 584 585 586 587 588 |
} child = ptrace_get_task_struct(pid); if (IS_ERR(child)) { ret = PTR_ERR(child); goto out; } |
481bed454
|
589 590 591 |
if (request == PTRACE_ATTACH) { ret = ptrace_attach(child); |
0ac155591
|
592 593 594 595 596 597 |
/* * Some architectures need to do book-keeping after * a ptrace attach. */ if (!ret) arch_ptrace_attach(child); |
005f18dfd
|
598 |
goto out_put_task_struct; |
481bed454
|
599 600 601 602 603 604 605 |
} ret = ptrace_check_attach(child, request == PTRACE_KILL); if (ret < 0) goto out_put_task_struct; ret = arch_ptrace(child, request, addr, data); |
481bed454
|
606 607 608 609 610 611 612 |
out_put_task_struct: put_task_struct(child); out: unlock_kernel(); return ret; } |
766473231
|
613 614 615 616 617 618 619 620 621 622 623 |
int generic_ptrace_peekdata(struct task_struct *tsk, long addr, long data) { unsigned long tmp; int copied; copied = access_process_vm(tsk, addr, &tmp, sizeof(tmp), 0); if (copied != sizeof(tmp)) return -EIO; return put_user(tmp, (unsigned long __user *)data); } |
f284ce726
|
624 625 626 627 628 629 630 631 |
int generic_ptrace_pokedata(struct task_struct *tsk, long addr, long data) { int copied; copied = access_process_vm(tsk, addr, &data, sizeof(data), 1); return (copied == sizeof(data)) ? 0 : -EIO; } |
032d82d90
|
632 |
|
96b8936a9
|
633 |
#if defined CONFIG_COMPAT |
032d82d90
|
634 635 636 637 638 639 640 |
#include <linux/compat.h> int compat_ptrace_request(struct task_struct *child, compat_long_t request, compat_ulong_t addr, compat_ulong_t data) { compat_ulong_t __user *datap = compat_ptr(data); compat_ulong_t word; |
e16b27816
|
641 |
siginfo_t siginfo; |
032d82d90
|
642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 |
int ret; switch (request) { case PTRACE_PEEKTEXT: case PTRACE_PEEKDATA: ret = access_process_vm(child, addr, &word, sizeof(word), 0); if (ret != sizeof(word)) ret = -EIO; else ret = put_user(word, datap); break; case PTRACE_POKETEXT: case PTRACE_POKEDATA: ret = access_process_vm(child, addr, &data, sizeof(data), 1); ret = (ret != sizeof(data) ? -EIO : 0); break; case PTRACE_GETEVENTMSG: ret = put_user((compat_ulong_t) child->ptrace_message, datap); break; |
e16b27816
|
663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 |
case PTRACE_GETSIGINFO: ret = ptrace_getsiginfo(child, &siginfo); if (!ret) ret = copy_siginfo_to_user32( (struct compat_siginfo __user *) datap, &siginfo); break; case PTRACE_SETSIGINFO: memset(&siginfo, 0, sizeof siginfo); if (copy_siginfo_from_user32( &siginfo, (struct compat_siginfo __user *) datap)) ret = -EFAULT; else ret = ptrace_setsiginfo(child, &siginfo); break; |
032d82d90
|
679 680 681 682 683 684 |
default: ret = ptrace_request(child, request, addr, data); } return ret; } |
c269f1961
|
685 |
|
c269f1961
|
686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 |
asmlinkage long compat_sys_ptrace(compat_long_t request, compat_long_t pid, compat_long_t addr, compat_long_t data) { struct task_struct *child; long ret; /* * This lock_kernel fixes a subtle race with suid exec */ lock_kernel(); if (request == PTRACE_TRACEME) { ret = ptrace_traceme(); goto out; } child = ptrace_get_task_struct(pid); if (IS_ERR(child)) { ret = PTR_ERR(child); goto out; } if (request == PTRACE_ATTACH) { ret = ptrace_attach(child); /* * Some architectures need to do book-keeping after * a ptrace attach. */ if (!ret) arch_ptrace_attach(child); goto out_put_task_struct; } ret = ptrace_check_attach(child, request == PTRACE_KILL); if (!ret) ret = compat_arch_ptrace(child, request, addr, data); out_put_task_struct: put_task_struct(child); out: unlock_kernel(); return ret; } |
96b8936a9
|
728 |
#endif /* CONFIG_COMPAT */ |