ptrace.c 6.56 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7 8 9 10 11 12 13
/*
 * linux/kernel/ptrace.c
 *
 * (C) Copyright 1999 Linus Torvalds
 *
 * Common interfaces for "ptrace()" which we do not want
 * to continually duplicate across every architecture.
 */

#include <linux/sched.h>
#include <linux/errno.h>
#include <linux/mm.h>
#include <linux/highmem.h>
14
#include <linux/pagemap.h>
Linus Torvalds's avatar
Linus Torvalds committed
15
#include <linux/smp_lock.h>
16
#include <linux/ptrace.h>
17
#include <linux/security.h>
Linus Torvalds's avatar
Linus Torvalds committed
18 19 20 21

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

22 23 24 25 26 27 28 29 30 31 32
/*
 * 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.
 */
void __ptrace_link(task_t *child, task_t *new_parent)
{
	if (!list_empty(&child->ptrace_list))
		BUG();
	if (child->parent == new_parent)
Ingo Molnar's avatar
Ingo Molnar committed
33
		return;
34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58
	list_add(&child->ptrace_list, &child->parent->ptrace_children);
	REMOVE_LINKS(child);
	child->parent = new_parent;
	SET_LINKS(child);
}
 
/*
 * 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.
 */
void __ptrace_unlink(task_t *child)
{
	if (!child->ptrace)
		BUG();
	child->ptrace = 0;
	if (list_empty(&child->ptrace_list))
		return;
	list_del_init(&child->ptrace_list);
	REMOVE_LINKS(child);
	child->parent = child->real_parent;
	SET_LINKS(child);
}

Linus Torvalds's avatar
Linus Torvalds committed
59 60 61 62 63 64 65 66
/*
 * Check that we have indeed attached to the thing..
 */
int ptrace_check_attach(struct task_struct *child, int kill)
{
	if (!(child->ptrace & PT_PTRACED))
		return -ESRCH;

67
	if (child->parent != current)
Linus Torvalds's avatar
Linus Torvalds committed
68 69 70 71 72
		return -ESRCH;

	if (!kill) {
		if (child->state != TASK_STOPPED)
			return -ESRCH;
Linus Torvalds's avatar
Linus Torvalds committed
73
		wait_task_inactive(child);
Linus Torvalds's avatar
Linus Torvalds committed
74 75 76 77 78 79
	}

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

Linus Torvalds's avatar
Linus Torvalds committed
80 81
int ptrace_attach(struct task_struct *task)
{
82
	int retval;
Linus Torvalds's avatar
Linus Torvalds committed
83
	task_lock(task);
84
	retval = -EPERM;
Linus Torvalds's avatar
Linus Torvalds committed
85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103
	if (task->pid <= 1)
		goto bad;
	if (task == current)
		goto bad;
	if (!task->mm)
		goto bad;
	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))
		goto bad;
	rmb();
	if (!task->mm->dumpable && !capable(CAP_SYS_PTRACE))
		goto bad;
	/* the same process cannot be attached many times */
	if (task->ptrace & PT_PTRACED)
		goto bad;
104 105
	retval = security_ptrace(current, task);
	if (retval)
106
		goto bad;
Linus Torvalds's avatar
Linus Torvalds committed
107 108 109

	/* Go */
	task->ptrace |= PT_PTRACED;
Linus Torvalds's avatar
Linus Torvalds committed
110 111
	if (capable(CAP_SYS_PTRACE))
		task->ptrace |= PT_PTRACE_CAP;
Linus Torvalds's avatar
Linus Torvalds committed
112 113 114
	task_unlock(task);

	write_lock_irq(&tasklist_lock);
115
	__ptrace_link(task, current);
Linus Torvalds's avatar
Linus Torvalds committed
116 117 118 119 120 121 122
	write_unlock_irq(&tasklist_lock);

	send_sig(SIGSTOP, task, 1);
	return 0;

bad:
	task_unlock(task);
123
	return retval;
Linus Torvalds's avatar
Linus Torvalds committed
124 125
}

Linus Torvalds's avatar
Linus Torvalds committed
126 127 128 129 130 131 132 133 134 135
int ptrace_detach(struct task_struct *child, unsigned int data)
{
	if ((unsigned long) data > _NSIG)
		return	-EIO;

	/* Architecture-specific hardware disable .. */
	ptrace_disable(child);

	/* .. re-parent .. */
	child->exit_code = data;
136

Linus Torvalds's avatar
Linus Torvalds committed
137
	write_lock_irq(&tasklist_lock);
138 139 140 141
	__ptrace_unlink(child);
	/* .. and wake it up. */
	if (child->state != TASK_ZOMBIE)
		wake_up_process(child);
Linus Torvalds's avatar
Linus Torvalds committed
142 143 144 145
	write_unlock_irq(&tasklist_lock);

	return 0;
}
Linus Torvalds's avatar
Linus Torvalds committed
146

Linus Torvalds's avatar
Linus Torvalds committed
147
/*
Linus Torvalds's avatar
Linus Torvalds committed
148 149 150
 * Access another process' address space.
 * Source/target buffer must be kernel space, 
 * Do not walk the page table directly, use get_user_pages
Linus Torvalds's avatar
Linus Torvalds committed
151 152 153 154 155
 */

int access_process_vm(struct task_struct *tsk, unsigned long addr, void *buf, int len, int write)
{
	struct mm_struct *mm;
Linus Torvalds's avatar
Linus Torvalds committed
156 157 158
	struct vm_area_struct *vma;
	struct page *page;
	void *old_buf = buf;
Linus Torvalds's avatar
Linus Torvalds committed
159

160
	mm = get_task_mm(tsk);
Linus Torvalds's avatar
Linus Torvalds committed
161 162 163
	if (!mm)
		return 0;

Linus Torvalds's avatar
Linus Torvalds committed
164
	down_read(&mm->mmap_sem);
Linus Torvalds's avatar
Linus Torvalds committed
165 166 167 168 169 170 171 172 173
	/* ignore errors, just check how much was sucessfully transfered */
	while (len) {
		int bytes, ret, offset;
		void *maddr;

		ret = get_user_pages(current, mm, addr, 1,
				write, 1, &page, &vma);
		if (ret <= 0)
			break;
Linus Torvalds's avatar
Linus Torvalds committed
174

Linus Torvalds's avatar
Linus Torvalds committed
175 176 177 178 179 180 181 182 183 184 185
		bytes = len;
		offset = addr & (PAGE_SIZE-1);
		if (bytes > PAGE_SIZE-offset)
			bytes = PAGE_SIZE-offset;

		flush_cache_page(vma, addr);

		maddr = kmap(page);
		if (write) {
			memcpy(maddr + offset, buf, bytes);
			flush_page_to_ram(page);
186
			flush_icache_user_range(vma, page, addr, bytes);
Linus Torvalds's avatar
Linus Torvalds committed
187 188 189 190 191
		} else {
			memcpy(buf, maddr + offset, bytes);
			flush_page_to_ram(page);
		}
		kunmap(page);
192
		page_cache_release(page);
Linus Torvalds's avatar
Linus Torvalds committed
193 194
		len -= bytes;
		buf += bytes;
Dave Jones's avatar
Dave Jones committed
195
		addr += bytes;
Linus Torvalds's avatar
Linus Torvalds committed
196
	}
Linus Torvalds's avatar
Linus Torvalds committed
197
	up_read(&mm->mmap_sem);
Linus Torvalds's avatar
Linus Torvalds committed
198
	mmput(mm);
Linus Torvalds's avatar
Linus Torvalds committed
199 200
	
	return buf - old_buf;
Linus Torvalds's avatar
Linus Torvalds committed
201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251
}

int ptrace_readdata(struct task_struct *tsk, unsigned long src, char *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 * 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;
}
252

253
static int ptrace_setoptions(struct task_struct *child, long data)
254 255 256 257 258 259
{
	if (data & PTRACE_O_TRACESYSGOOD)
		child->ptrace |= PT_TRACESYSGOOD;
	else
		child->ptrace &= ~PT_TRACESYSGOOD;

260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283
	if (data & PTRACE_O_TRACEFORK)
		child->ptrace |= PT_TRACE_FORK;
	else
		child->ptrace &= ~PT_TRACE_FORK;

	if (data & PTRACE_O_TRACEVFORK)
		child->ptrace |= PT_TRACE_VFORK;
	else
		child->ptrace &= ~PT_TRACE_VFORK;

	if (data & PTRACE_O_TRACECLONE)
		child->ptrace |= PT_TRACE_CLONE;
	else
		child->ptrace &= ~PT_TRACE_CLONE;

	if (data & PTRACE_O_TRACEEXEC)
		child->ptrace |= PT_TRACE_EXEC;
	else
		child->ptrace &= ~PT_TRACE_EXEC;

	if ((data & (PTRACE_O_TRACESYSGOOD | PTRACE_O_TRACEFORK
		    | PTRACE_O_TRACEVFORK | PTRACE_O_TRACECLONE
		    | PTRACE_O_TRACEEXEC))
	    != data)
284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300
		return -EINVAL;

	return 0;
}

int ptrace_request(struct task_struct *child, long request,
		   long addr, long data)
{
	int ret = -EIO;

	switch (request) {
#ifdef PTRACE_OLDSETOPTIONS
	case PTRACE_OLDSETOPTIONS:
#endif
	case PTRACE_SETOPTIONS:
		ret = ptrace_setoptions(child, data);
		break;
301 302 303
	case PTRACE_GETEVENTMSG:
		ret = put_user(child->ptrace_message, (unsigned long *) data);
		break;
304 305 306 307 308 309
	default:
		break;
	}

	return ret;
}
310 311 312 313 314 315 316 317 318 319 320

void ptrace_notify(int exit_code)
{
	BUG_ON (!(current->ptrace & PT_PTRACED));

	/* Let the debugger run.  */
	current->exit_code = exit_code;
	set_current_state(TASK_STOPPED);
	notify_parent(current, SIGCHLD);
	schedule();
}