ptrace.c 15.5 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9
/*
 * linux/kernel/ptrace.c
 *
 * (C) Copyright 1999 Linus Torvalds
 *
 * Common interfaces for "ptrace()" which we do not want
 * to continually duplicate across every architecture.
 */

10
#include <linux/capability.h>
L
Linus Torvalds 已提交
11 12 13 14 15 16 17 18 19
#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>
20
#include <linux/signal.h>
A
Al Viro 已提交
21
#include <linux/audit.h>
22
#include <linux/pid_namespace.h>
23
#include <linux/syscalls.h>
L
Linus Torvalds 已提交
24 25 26 27 28 29 30 31 32 33

#include <asm/pgtable.h>
#include <asm/uaccess.h>

/*
 * 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.
 */
34
void __ptrace_link(struct task_struct *child, struct task_struct *new_parent)
L
Linus Torvalds 已提交
35
{
36
	BUG_ON(!list_empty(&child->ptrace_list));
L
Linus Torvalds 已提交
37 38 39
	if (child->parent == new_parent)
		return;
	list_add(&child->ptrace_list, &child->parent->ptrace_children);
40
	remove_parent(child);
L
Linus Torvalds 已提交
41
	child->parent = new_parent;
42
	add_parent(child);
L
Linus Torvalds 已提交
43 44 45 46 47 48 49 50 51
}
 
/*
 * 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.
 */
52
void ptrace_untrace(struct task_struct *child)
L
Linus Torvalds 已提交
53 54
{
	spin_lock(&child->sighand->siglock);
M
Matthew Wilcox 已提交
55
	if (task_is_traced(child)) {
L
Linus Torvalds 已提交
56
		if (child->signal->flags & SIGNAL_STOP_STOPPED) {
57
			__set_task_state(child, TASK_STOPPED);
L
Linus Torvalds 已提交
58 59 60 61 62 63 64 65 66 67 68 69 70
		} else {
			signal_wake_up(child, 1);
		}
	}
	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.
 */
71
void __ptrace_unlink(struct task_struct *child)
L
Linus Torvalds 已提交
72
{
73 74
	BUG_ON(!child->ptrace);

L
Linus Torvalds 已提交
75 76 77
	child->ptrace = 0;
	if (!list_empty(&child->ptrace_list)) {
		list_del_init(&child->ptrace_list);
78
		remove_parent(child);
L
Linus Torvalds 已提交
79
		child->parent = child->real_parent;
80
		add_parent(child);
L
Linus Torvalds 已提交
81 82
	}

M
Matthew Wilcox 已提交
83
	if (task_is_traced(child))
84
		ptrace_untrace(child);
L
Linus Torvalds 已提交
85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101
}

/*
 * 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);
102
	if ((child->ptrace & PT_PTRACED) && child->parent == current) {
L
Linus Torvalds 已提交
103
		ret = 0;
104 105 106 107
		/*
		 * child->sighand can't be NULL, release_task()
		 * does ptrace_unlink() before __exit_signal().
		 */
L
Linus Torvalds 已提交
108
		spin_lock_irq(&child->sighand->siglock);
109
		if (task_is_stopped(child))
L
Linus Torvalds 已提交
110
			child->state = TASK_TRACED;
111
		else if (!task_is_traced(child) && !kill)
L
Linus Torvalds 已提交
112 113 114 115 116
			ret = -ESRCH;
		spin_unlock_irq(&child->sighand->siglock);
	}
	read_unlock(&tasklist_lock);

117
	if (!ret && !kill)
L
Linus Torvalds 已提交
118 119 120 121 122 123
		wait_task_inactive(child);

	/* All systems go.. */
	return ret;
}

124
int __ptrace_may_attach(struct task_struct *task)
125
{
126 127 128 129 130 131 132 133 134 135 136 137
	/* 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;
138 139 140 141 142 143 144 145
	if (((current->uid != task->euid) ||
	     (current->uid != task->suid) ||
	     (current->uid != task->uid) ||
	     (current->gid != task->egid) ||
	     (current->gid != task->sgid) ||
	     (current->gid != task->gid)) && !capable(CAP_SYS_PTRACE))
		return -EPERM;
	smp_rmb();
146
	if (task->mm)
147
		dumpable = get_dumpable(task->mm);
148
	if (!dumpable && !capable(CAP_SYS_PTRACE))
149 150 151 152 153 154 155 156 157
		return -EPERM;

	return security_ptrace(current, task);
}

int ptrace_may_attach(struct task_struct *task)
{
	int err;
	task_lock(task);
158
	err = __ptrace_may_attach(task);
159 160 161 162
	task_unlock(task);
	return !err;
}

L
Linus Torvalds 已提交
163 164 165
int ptrace_attach(struct task_struct *task)
{
	int retval;
166
	unsigned long flags;
167

A
Al Viro 已提交
168 169
	audit_ptrace(task);

L
Linus Torvalds 已提交
170 171
	retval = -EPERM;
	if (task->pid <= 1)
172
		goto out;
173
	if (same_thread_group(task, current))
174 175
		goto out;

176 177 178 179 180 181 182 183 184 185
repeat:
	/*
	 * Nasty, nasty.
	 *
	 * We want to hold both the task-lock and the
	 * tasklist_lock for writing at the same time.
	 * But that's against the rules (tasklist_lock
	 * is taken for reading by interrupts on other
	 * cpu's that may have task_lock).
	 */
186
	task_lock(task);
187
	if (!write_trylock_irqsave(&tasklist_lock, flags)) {
188 189 190 191 192 193
		task_unlock(task);
		do {
			cpu_relax();
		} while (!write_can_lock(&tasklist_lock));
		goto repeat;
	}
194

195 196
	if (!task->mm)
		goto bad;
L
Linus Torvalds 已提交
197 198 199
	/* the same process cannot be attached many times */
	if (task->ptrace & PT_PTRACED)
		goto bad;
200
	retval = __ptrace_may_attach(task);
L
Linus Torvalds 已提交
201 202 203 204
	if (retval)
		goto bad;

	/* Go */
O
Oleg Nesterov 已提交
205
	task->ptrace |= PT_PTRACED;
L
Linus Torvalds 已提交
206 207 208 209 210 211 212 213
	if (capable(CAP_SYS_PTRACE))
		task->ptrace |= PT_PTRACE_CAP;

	__ptrace_link(task, current);

	force_sig_specific(SIGSTOP, task);

bad:
214
	write_unlock_irqrestore(&tasklist_lock, flags);
L
Linus Torvalds 已提交
215
	task_unlock(task);
216
out:
L
Linus Torvalds 已提交
217 218 219
	return retval;
}

220
static inline void __ptrace_detach(struct task_struct *child, unsigned int data)
221 222 223 224 225 226 227 228 229
{
	child->exit_code = data;
	/* .. re-parent .. */
	__ptrace_unlink(child);
	/* .. and wake it up. */
	if (child->exit_state != EXIT_ZOMBIE)
		wake_up_process(child);
}

L
Linus Torvalds 已提交
230 231
int ptrace_detach(struct task_struct *child, unsigned int data)
{
232
	if (!valid_signal(data))
233
		return -EIO;
L
Linus Torvalds 已提交
234 235 236

	/* Architecture-specific hardware disable .. */
	ptrace_disable(child);
237
	clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
L
Linus Torvalds 已提交
238 239

	write_lock_irq(&tasklist_lock);
240
	/* protect against de_thread()->release_task() */
241 242
	if (child->ptrace)
		__ptrace_detach(child, data);
L
Linus Torvalds 已提交
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 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368
	write_unlock_irq(&tasklist_lock);

	return 0;
}

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;
		len -= retval;			
	}
	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;
		len -= retval;			
	}
	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;
}

static int ptrace_getsiginfo(struct task_struct *child, siginfo_t __user * data)
{
	siginfo_t lastinfo;
	int error = -ESRCH;

	read_lock(&tasklist_lock);
	if (likely(child->sighand != NULL)) {
		error = -EINVAL;
		spin_lock_irq(&child->sighand->siglock);
		if (likely(child->last_siginfo != NULL)) {
			lastinfo = *child->last_siginfo;
			error = 0;
		}
		spin_unlock_irq(&child->sighand->siglock);
	}
	read_unlock(&tasklist_lock);
	if (!error)
		return copy_siginfo_to_user(data, &lastinfo);
	return error;
}

static int ptrace_setsiginfo(struct task_struct *child, siginfo_t __user * data)
{
	siginfo_t newinfo;
	int error = -ESRCH;

	if (copy_from_user(&newinfo, data, sizeof (siginfo_t)))
		return -EFAULT;

	read_lock(&tasklist_lock);
	if (likely(child->sighand != NULL)) {
		error = -EINVAL;
		spin_lock_irq(&child->sighand->siglock);
		if (likely(child->last_siginfo != NULL)) {
			*child->last_siginfo = newinfo;
			error = 0;
		}
		spin_unlock_irq(&child->sighand->siglock);
	}
	read_unlock(&tasklist_lock);
	return error;
}

R
Roland McGrath 已提交
369 370 371 372 373 374 375

#ifdef PTRACE_SINGLESTEP
#define is_singlestep(request)		((request) == PTRACE_SINGLESTEP)
#else
#define is_singlestep(request)		0
#endif

376 377 378 379 380 381
#ifdef PTRACE_SINGLEBLOCK
#define is_singleblock(request)		((request) == PTRACE_SINGLEBLOCK)
#else
#define is_singleblock(request)		0
#endif

R
Roland McGrath 已提交
382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404
#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

405 406 407 408 409
	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)) {
R
Roland McGrath 已提交
410 411 412 413 414 415 416 417 418 419 420 421 422
		if (unlikely(!arch_has_single_step()))
			return -EIO;
		user_enable_single_step(child);
	}
	else
		user_disable_single_step(child);

	child->exit_code = data;
	wake_up_process(child);

	return 0;
}

L
Linus Torvalds 已提交
423 424 425 426 427 428
int ptrace_request(struct task_struct *child, long request,
		   long addr, long data)
{
	int ret = -EIO;

	switch (request) {
429 430 431 432 433 434 435
	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);

L
Linus Torvalds 已提交
436 437 438 439 440 441 442 443 444 445 446 447 448 449 450
#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;
	case PTRACE_GETSIGINFO:
		ret = ptrace_getsiginfo(child, (siginfo_t __user *) data);
		break;
	case PTRACE_SETSIGINFO:
		ret = ptrace_setsiginfo(child, (siginfo_t __user *) data);
		break;
A
Alexey Dobriyan 已提交
451 452 453
	case PTRACE_DETACH:	 /* detach a process that was attached. */
		ret = ptrace_detach(child, data);
		break;
R
Roland McGrath 已提交
454 455 456 457

#ifdef PTRACE_SINGLESTEP
	case PTRACE_SINGLESTEP:
#endif
458 459 460
#ifdef PTRACE_SINGLEBLOCK
	case PTRACE_SINGLEBLOCK:
#endif
R
Roland McGrath 已提交
461 462 463 464 465 466 467 468 469 470 471 472 473
#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);

L
Linus Torvalds 已提交
474 475 476 477 478 479
	default:
		break;
	}

	return ret;
}
480

481 482 483 484 485 486 487
/**
 * 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)
488
{
489
	int ret = -EPERM;
490 491

	/*
492 493
	 * Are we already being traced?
	 */
494 495 496 497 498 499 500 501 502 503 504
	task_lock(current);
	if (!(current->ptrace & PT_PTRACED)) {
		ret = security_ptrace(current->parent, current);
		/*
		 * Set the ptrace bit in the process ptrace flags.
		 */
		if (!ret)
			current->ptrace |= PT_PTRACED;
	}
	task_unlock(current);
	return ret;
505
}
506

507 508 509 510 511 512 513 514 515 516 517 518 519
/**
 * ptrace_get_task_struct  --  grab a task struct reference for ptrace
 * @pid:       process id to grab a task_struct reference of
 *
 * This function is a helper for ptrace implementations.  It checks
 * permissions and then grabs a task struct for use of the actual
 * ptrace implementation.
 *
 * Returns the task_struct for @pid or an ERR_PTR() on failure.
 */
struct task_struct *ptrace_get_task_struct(pid_t pid)
{
	struct task_struct *child;
520 521

	/*
522
	 * Tracing init is not allowed.
523 524
	 */
	if (pid == 1)
525
		return ERR_PTR(-EPERM);
526 527

	read_lock(&tasklist_lock);
528
	child = find_task_by_vpid(pid);
529 530
	if (child)
		get_task_struct(child);
531

532 533
	read_unlock(&tasklist_lock);
	if (!child)
534 535
		return ERR_PTR(-ESRCH);
	return child;
536 537
}

538 539 540 541
#ifndef arch_ptrace_attach
#define arch_ptrace_attach(child)	do { } while (0)
#endif

542
#ifndef __ARCH_SYS_PTRACE
543 544 545 546 547 548 549 550 551
asmlinkage long sys_ptrace(long request, long pid, long addr, long data)
{
	struct task_struct *child;
	long ret;

	/*
	 * This lock_kernel fixes a subtle race with suid exec
	 */
	lock_kernel();
552 553
	if (request == PTRACE_TRACEME) {
		ret = ptrace_traceme();
554 555
		if (!ret)
			arch_ptrace_attach(current);
556
		goto out;
557 558 559 560 561 562 563
	}

	child = ptrace_get_task_struct(pid);
	if (IS_ERR(child)) {
		ret = PTR_ERR(child);
		goto out;
	}
564 565 566

	if (request == PTRACE_ATTACH) {
		ret = ptrace_attach(child);
567 568 569 570 571 572
		/*
		 * Some architectures need to do book-keeping after
		 * a ptrace attach.
		 */
		if (!ret)
			arch_ptrace_attach(child);
573
		goto out_put_task_struct;
574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590
	}

	ret = ptrace_check_attach(child, request == PTRACE_KILL);
	if (ret < 0)
		goto out_put_task_struct;

	ret = arch_ptrace(child, request, addr, data);
	if (ret < 0)
		goto out_put_task_struct;

 out_put_task_struct:
	put_task_struct(child);
 out:
	unlock_kernel();
	return ret;
}
#endif /* __ARCH_SYS_PTRACE */
A
Alexey Dobriyan 已提交
591 592 593 594 595 596 597 598 599 600 601

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);
}
A
Alexey Dobriyan 已提交
602 603 604 605 606 607 608 609

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;
}
R
Roland McGrath 已提交
610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646

#ifdef CONFIG_COMPAT
#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;
	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;

	default:
		ret = ptrace_request(child, request, addr, data);
	}

	return ret;
}
R
Roland McGrath 已提交
647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692

#ifdef __ARCH_WANT_COMPAT_SYS_PTRACE
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;
}
#endif /* __ARCH_WANT_COMPAT_SYS_PTRACE */

R
Roland McGrath 已提交
693
#endif	/* CONFIG_COMPAT */