2005-04-16 22:20:36 +00:00
|
|
|
/* By Ross Biro 1/23/92 */
|
|
|
|
/*
|
|
|
|
* Pentium III FXSR, SSE support
|
|
|
|
* Gareth Hughes <gareth@valinux.com>, May 2000
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/smp.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/ptrace.h>
|
|
|
|
#include <linux/user.h>
|
|
|
|
#include <linux/security.h>
|
|
|
|
#include <linux/audit.h>
|
|
|
|
#include <linux/seccomp.h>
|
2005-05-01 15:59:14 +00:00
|
|
|
#include <linux/signal.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#include <asm/uaccess.h>
|
|
|
|
#include <asm/pgtable.h>
|
|
|
|
#include <asm/system.h>
|
|
|
|
#include <asm/processor.h>
|
|
|
|
#include <asm/i387.h>
|
|
|
|
#include <asm/debugreg.h>
|
|
|
|
#include <asm/ldt.h>
|
|
|
|
#include <asm/desc.h>
|
|
|
|
|
|
|
|
/*
|
|
|
|
* does not yet catch signals sent when the child dies.
|
|
|
|
* in exit.c or in signal.c.
|
|
|
|
*/
|
|
|
|
|
2006-01-06 04:11:29 +00:00
|
|
|
/*
|
|
|
|
* Determines which flags the user has access to [1 = access, 0 = no access].
|
2006-03-23 10:59:39 +00:00
|
|
|
* Prohibits changing ID(21), VIP(20), VIF(19), VM(17), NT(14), IOPL(12-13), IF(9).
|
2006-01-06 04:11:29 +00:00
|
|
|
* Also masks reserved bits (31-22, 15, 5, 3, 1).
|
|
|
|
*/
|
2006-03-23 10:59:39 +00:00
|
|
|
#define FLAG_MASK 0x00050dd5
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* set's the trap flag. */
|
|
|
|
#define TRAP_FLAG 0x100
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Offset of eflags on child stack..
|
|
|
|
*/
|
2006-12-22 09:11:21 +00:00
|
|
|
#define EFL_OFFSET offsetof(struct pt_regs, eflags)
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
static inline struct pt_regs *get_child_regs(struct task_struct *task)
|
|
|
|
{
|
|
|
|
void *stack_top = (void *)task->thread.esp0;
|
|
|
|
return stack_top - sizeof(struct pt_regs);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2006-12-22 09:11:21 +00:00
|
|
|
* This routine will get a word off of the processes privileged stack.
|
|
|
|
* the offset is bytes into the pt_regs structure on the stack.
|
|
|
|
* This routine assumes that all the privileged stacks are in our
|
2005-04-16 22:20:36 +00:00
|
|
|
* data space.
|
|
|
|
*/
|
|
|
|
static inline int get_stack_long(struct task_struct *task, int offset)
|
|
|
|
{
|
|
|
|
unsigned char *stack;
|
|
|
|
|
2006-12-22 09:11:21 +00:00
|
|
|
stack = (unsigned char *)task->thread.esp0 - sizeof(struct pt_regs);
|
2005-04-16 22:20:36 +00:00
|
|
|
stack += offset;
|
|
|
|
return (*((int *)stack));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2006-12-22 09:11:21 +00:00
|
|
|
* This routine will put a word on the processes privileged stack.
|
|
|
|
* the offset is bytes into the pt_regs structure on the stack.
|
|
|
|
* This routine assumes that all the privileged stacks are in our
|
2005-04-16 22:20:36 +00:00
|
|
|
* data space.
|
|
|
|
*/
|
|
|
|
static inline int put_stack_long(struct task_struct *task, int offset,
|
|
|
|
unsigned long data)
|
|
|
|
{
|
|
|
|
unsigned char * stack;
|
|
|
|
|
2006-12-22 09:11:21 +00:00
|
|
|
stack = (unsigned char *)task->thread.esp0 - sizeof(struct pt_regs);
|
2005-04-16 22:20:36 +00:00
|
|
|
stack += offset;
|
|
|
|
*(unsigned long *) stack = data;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int putreg(struct task_struct *child,
|
|
|
|
unsigned long regno, unsigned long value)
|
|
|
|
{
|
|
|
|
switch (regno >> 2) {
|
2007-02-13 12:26:20 +00:00
|
|
|
case GS:
|
2005-04-16 22:20:36 +00:00
|
|
|
if (value && (value & 3) != 3)
|
|
|
|
return -EIO;
|
2007-02-13 12:26:20 +00:00
|
|
|
child->thread.gs = value;
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
case DS:
|
|
|
|
case ES:
|
2007-02-13 12:26:20 +00:00
|
|
|
case FS:
|
2005-04-16 22:20:36 +00:00
|
|
|
if (value && (value & 3) != 3)
|
|
|
|
return -EIO;
|
|
|
|
value &= 0xffff;
|
|
|
|
break;
|
|
|
|
case SS:
|
|
|
|
case CS:
|
|
|
|
if ((value & 3) != 3)
|
|
|
|
return -EIO;
|
|
|
|
value &= 0xffff;
|
|
|
|
break;
|
|
|
|
case EFL:
|
|
|
|
value &= FLAG_MASK;
|
|
|
|
value |= get_stack_long(child, EFL_OFFSET) & ~FLAG_MASK;
|
|
|
|
break;
|
|
|
|
}
|
2007-02-13 12:26:20 +00:00
|
|
|
if (regno > FS*4)
|
2006-12-07 01:14:02 +00:00
|
|
|
regno -= 1*4;
|
2006-12-22 09:11:21 +00:00
|
|
|
put_stack_long(child, regno, value);
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned long getreg(struct task_struct *child,
|
|
|
|
unsigned long regno)
|
|
|
|
{
|
|
|
|
unsigned long retval = ~0UL;
|
|
|
|
|
|
|
|
switch (regno >> 2) {
|
2007-02-13 12:26:20 +00:00
|
|
|
case GS:
|
|
|
|
retval = child->thread.gs;
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
case DS:
|
|
|
|
case ES:
|
2007-02-13 12:26:20 +00:00
|
|
|
case FS:
|
2005-04-16 22:20:36 +00:00
|
|
|
case SS:
|
|
|
|
case CS:
|
|
|
|
retval = 0xffff;
|
|
|
|
/* fall through */
|
|
|
|
default:
|
2007-02-13 12:26:20 +00:00
|
|
|
if (regno > FS*4)
|
2006-12-07 01:14:02 +00:00
|
|
|
regno -= 1*4;
|
2005-04-16 22:20:36 +00:00
|
|
|
retval &= get_stack_long(child, regno);
|
|
|
|
}
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define LDT_SEGMENT 4
|
|
|
|
|
|
|
|
static unsigned long convert_eip_to_linear(struct task_struct *child, struct pt_regs *regs)
|
|
|
|
{
|
|
|
|
unsigned long addr, seg;
|
|
|
|
|
|
|
|
addr = regs->eip;
|
|
|
|
seg = regs->xcs & 0xffff;
|
|
|
|
if (regs->eflags & VM_MASK) {
|
|
|
|
addr = (addr & 0xffff) + (seg << 4);
|
|
|
|
return addr;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We'll assume that the code segments in the GDT
|
|
|
|
* are all zero-based. That is largely true: the
|
|
|
|
* TLS segments are used for data, and the PNPBIOS
|
|
|
|
* and APM bios ones we just ignore here.
|
|
|
|
*/
|
|
|
|
if (seg & LDT_SEGMENT) {
|
|
|
|
u32 *desc;
|
|
|
|
unsigned long base;
|
|
|
|
|
2007-07-16 08:03:16 +00:00
|
|
|
seg &= ~7UL;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-07-16 08:03:16 +00:00
|
|
|
down(&child->mm->context.sem);
|
|
|
|
if (unlikely((seg >> 3) >= child->mm->context.size))
|
|
|
|
addr = -1L; /* bogus selector, access would fault */
|
|
|
|
else {
|
|
|
|
desc = child->mm->context.ldt + seg;
|
|
|
|
base = ((desc[0] >> 16) |
|
|
|
|
((desc[1] & 0xff) << 16) |
|
|
|
|
(desc[1] & 0xff000000));
|
|
|
|
|
|
|
|
/* 16-bit code segment? */
|
|
|
|
if (!((desc[1] >> 22) & 1))
|
|
|
|
addr &= 0xffff;
|
|
|
|
addr += base;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
up(&child->mm->context.sem);
|
|
|
|
}
|
|
|
|
return addr;
|
|
|
|
}
|
|
|
|
|
2006-09-26 08:52:33 +00:00
|
|
|
static inline int is_setting_trap_flag(struct task_struct *child, struct pt_regs *regs)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
int i, copied;
|
2006-09-26 08:52:33 +00:00
|
|
|
unsigned char opcode[15];
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned long addr = convert_eip_to_linear(child, regs);
|
|
|
|
|
|
|
|
copied = access_process_vm(child, addr, opcode, sizeof(opcode), 0);
|
|
|
|
for (i = 0; i < copied; i++) {
|
|
|
|
switch (opcode[i]) {
|
2006-09-26 08:52:33 +00:00
|
|
|
/* popf and iret */
|
|
|
|
case 0x9d: case 0xcf:
|
2005-04-16 22:20:36 +00:00
|
|
|
return 1;
|
|
|
|
/* opcode and address size prefixes */
|
|
|
|
case 0x66: case 0x67:
|
|
|
|
continue;
|
|
|
|
/* irrelevant prefixes (segment overrides and repeats) */
|
|
|
|
case 0x26: case 0x2e:
|
|
|
|
case 0x36: case 0x3e:
|
|
|
|
case 0x64: case 0x65:
|
|
|
|
case 0xf0: case 0xf2: case 0xf3:
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* pushf: NOTE! We should probably not let
|
|
|
|
* the user see the TF bit being set. But
|
|
|
|
* it's more pain than it's worth to avoid
|
|
|
|
* it, and a debugger could emulate this
|
|
|
|
* all in user space if it _really_ cares.
|
|
|
|
*/
|
|
|
|
case 0x9c:
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void set_singlestep(struct task_struct *child)
|
|
|
|
{
|
|
|
|
struct pt_regs *regs = get_child_regs(child);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Always set TIF_SINGLESTEP - this guarantees that
|
|
|
|
* we single-step system calls etc.. This will also
|
|
|
|
* cause us to set TF when returning to user mode.
|
|
|
|
*/
|
|
|
|
set_tsk_thread_flag(child, TIF_SINGLESTEP);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If TF was already set, don't do anything else
|
|
|
|
*/
|
|
|
|
if (regs->eflags & TRAP_FLAG)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* Set TF on the kernel stack.. */
|
|
|
|
regs->eflags |= TRAP_FLAG;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* ..but if TF is changed by the instruction we will trace,
|
|
|
|
* don't mark it as being "us" that set it, so that we
|
|
|
|
* won't clear it by hand later.
|
|
|
|
*/
|
2006-09-26 08:52:33 +00:00
|
|
|
if (is_setting_trap_flag(child, regs))
|
2005-04-16 22:20:36 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
child->ptrace |= PT_DTRACE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void clear_singlestep(struct task_struct *child)
|
|
|
|
{
|
|
|
|
/* Always clear TIF_SINGLESTEP... */
|
|
|
|
clear_tsk_thread_flag(child, TIF_SINGLESTEP);
|
|
|
|
|
|
|
|
/* But touch TF only if it was set by us.. */
|
|
|
|
if (child->ptrace & PT_DTRACE) {
|
|
|
|
struct pt_regs *regs = get_child_regs(child);
|
|
|
|
regs->eflags &= ~TRAP_FLAG;
|
|
|
|
child->ptrace &= ~PT_DTRACE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Called by kernel/ptrace.c when detaching..
|
|
|
|
*
|
|
|
|
* Make sure the single step bit is not set.
|
|
|
|
*/
|
|
|
|
void ptrace_disable(struct task_struct *child)
|
|
|
|
{
|
|
|
|
clear_singlestep(child);
|
2005-09-03 22:57:21 +00:00
|
|
|
clear_tsk_thread_flag(child, TIF_SYSCALL_EMU);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Perform get_thread_area on behalf of the traced child.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
ptrace_get_thread_area(struct task_struct *child,
|
|
|
|
int idx, struct user_desc __user *user_desc)
|
|
|
|
{
|
|
|
|
struct user_desc info;
|
|
|
|
struct desc_struct *desc;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Get the current Thread-Local Storage area:
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define GET_BASE(desc) ( \
|
|
|
|
(((desc)->a >> 16) & 0x0000ffff) | \
|
|
|
|
(((desc)->b << 16) & 0x00ff0000) | \
|
|
|
|
( (desc)->b & 0xff000000) )
|
|
|
|
|
|
|
|
#define GET_LIMIT(desc) ( \
|
|
|
|
((desc)->a & 0x0ffff) | \
|
|
|
|
((desc)->b & 0xf0000) )
|
|
|
|
|
|
|
|
#define GET_32BIT(desc) (((desc)->b >> 22) & 1)
|
|
|
|
#define GET_CONTENTS(desc) (((desc)->b >> 10) & 3)
|
|
|
|
#define GET_WRITABLE(desc) (((desc)->b >> 9) & 1)
|
|
|
|
#define GET_LIMIT_PAGES(desc) (((desc)->b >> 23) & 1)
|
|
|
|
#define GET_PRESENT(desc) (((desc)->b >> 15) & 1)
|
|
|
|
#define GET_USEABLE(desc) (((desc)->b >> 20) & 1)
|
|
|
|
|
|
|
|
if (idx < GDT_ENTRY_TLS_MIN || idx > GDT_ENTRY_TLS_MAX)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
desc = child->thread.tls_array + idx - GDT_ENTRY_TLS_MIN;
|
|
|
|
|
|
|
|
info.entry_number = idx;
|
|
|
|
info.base_addr = GET_BASE(desc);
|
|
|
|
info.limit = GET_LIMIT(desc);
|
|
|
|
info.seg_32bit = GET_32BIT(desc);
|
|
|
|
info.contents = GET_CONTENTS(desc);
|
|
|
|
info.read_exec_only = !GET_WRITABLE(desc);
|
|
|
|
info.limit_in_pages = GET_LIMIT_PAGES(desc);
|
|
|
|
info.seg_not_present = !GET_PRESENT(desc);
|
|
|
|
info.useable = GET_USEABLE(desc);
|
|
|
|
|
|
|
|
if (copy_to_user(user_desc, &info, sizeof(info)))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Perform set_thread_area on behalf of the traced child.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
ptrace_set_thread_area(struct task_struct *child,
|
|
|
|
int idx, struct user_desc __user *user_desc)
|
|
|
|
{
|
|
|
|
struct user_desc info;
|
|
|
|
struct desc_struct *desc;
|
|
|
|
|
|
|
|
if (copy_from_user(&info, user_desc, sizeof(info)))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
if (idx < GDT_ENTRY_TLS_MIN || idx > GDT_ENTRY_TLS_MAX)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
desc = child->thread.tls_array + idx - GDT_ENTRY_TLS_MIN;
|
|
|
|
if (LDT_empty(&info)) {
|
|
|
|
desc->a = 0;
|
|
|
|
desc->b = 0;
|
|
|
|
} else {
|
|
|
|
desc->a = LDT_entry_a(&info);
|
|
|
|
desc->b = LDT_entry_b(&info);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-11-07 08:59:47 +00:00
|
|
|
long arch_ptrace(struct task_struct *child, long request, long addr, long data)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct user * dummy = NULL;
|
|
|
|
int i, ret;
|
|
|
|
unsigned long __user *datap = (unsigned long __user *)data;
|
|
|
|
|
|
|
|
switch (request) {
|
|
|
|
/* when I and D space are separate, these will need to be fixed. */
|
|
|
|
case PTRACE_PEEKTEXT: /* read word at location addr. */
|
2007-07-17 11:03:43 +00:00
|
|
|
case PTRACE_PEEKDATA:
|
|
|
|
ret = generic_ptrace_peekdata(child, addr, data);
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
/* read the word at location addr in the USER area. */
|
|
|
|
case PTRACE_PEEKUSR: {
|
|
|
|
unsigned long tmp;
|
|
|
|
|
|
|
|
ret = -EIO;
|
|
|
|
if ((addr & 3) || addr < 0 ||
|
|
|
|
addr > sizeof(struct user) - 3)
|
|
|
|
break;
|
|
|
|
|
|
|
|
tmp = 0; /* Default return condition */
|
|
|
|
if(addr < FRAME_SIZE*sizeof(long))
|
|
|
|
tmp = getreg(child, addr);
|
|
|
|
if(addr >= (long) &dummy->u_debugreg[0] &&
|
|
|
|
addr <= (long) &dummy->u_debugreg[7]){
|
|
|
|
addr -= (long) &dummy->u_debugreg[0];
|
|
|
|
addr = addr >> 2;
|
|
|
|
tmp = child->thread.debugreg[addr];
|
|
|
|
}
|
|
|
|
ret = put_user(tmp, datap);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* when I and D space are separate, this will have to be fixed. */
|
|
|
|
case PTRACE_POKETEXT: /* write the word at location addr. */
|
|
|
|
case PTRACE_POKEDATA:
|
2007-07-17 11:03:44 +00:00
|
|
|
ret = generic_ptrace_pokedata(child, addr, data);
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case PTRACE_POKEUSR: /* write the word at location addr in the USER area */
|
|
|
|
ret = -EIO;
|
|
|
|
if ((addr & 3) || addr < 0 ||
|
|
|
|
addr > sizeof(struct user) - 3)
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (addr < FRAME_SIZE*sizeof(long)) {
|
|
|
|
ret = putreg(child, addr, data);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* We need to be very careful here. We implicitly
|
|
|
|
want to modify a portion of the task_struct, and we
|
|
|
|
have to be selective about what portions we allow someone
|
|
|
|
to modify. */
|
|
|
|
|
|
|
|
ret = -EIO;
|
|
|
|
if(addr >= (long) &dummy->u_debugreg[0] &&
|
|
|
|
addr <= (long) &dummy->u_debugreg[7]){
|
|
|
|
|
|
|
|
if(addr == (long) &dummy->u_debugreg[4]) break;
|
|
|
|
if(addr == (long) &dummy->u_debugreg[5]) break;
|
|
|
|
if(addr < (long) &dummy->u_debugreg[4] &&
|
|
|
|
((unsigned long) data) >= TASK_SIZE-3) break;
|
|
|
|
|
|
|
|
/* Sanity-check data. Take one half-byte at once with
|
|
|
|
* check = (val >> (16 + 4*i)) & 0xf. It contains the
|
|
|
|
* R/Wi and LENi bits; bits 0 and 1 are R/Wi, and bits
|
|
|
|
* 2 and 3 are LENi. Given a list of invalid values,
|
|
|
|
* we do mask |= 1 << invalid_value, so that
|
|
|
|
* (mask >> check) & 1 is a correct test for invalid
|
|
|
|
* values.
|
|
|
|
*
|
|
|
|
* R/Wi contains the type of the breakpoint /
|
|
|
|
* watchpoint, LENi contains the length of the watched
|
|
|
|
* data in the watchpoint case.
|
|
|
|
*
|
|
|
|
* The invalid values are:
|
|
|
|
* - LENi == 0x10 (undefined), so mask |= 0x0f00.
|
|
|
|
* - R/Wi == 0x10 (break on I/O reads or writes), so
|
|
|
|
* mask |= 0x4444.
|
|
|
|
* - R/Wi == 0x00 && LENi != 0x00, so we have mask |=
|
|
|
|
* 0x1110.
|
|
|
|
*
|
|
|
|
* Finally, mask = 0x0f00 | 0x4444 | 0x1110 == 0x5f54.
|
|
|
|
*
|
|
|
|
* See the Intel Manual "System Programming Guide",
|
|
|
|
* 15.2.4
|
|
|
|
*
|
|
|
|
* Note that LENi == 0x10 is defined on x86_64 in long
|
|
|
|
* mode (i.e. even for 32-bit userspace software, but
|
|
|
|
* 64-bit kernel), so the x86_64 mask value is 0x5454.
|
|
|
|
* See the AMD manual no. 24593 (AMD64 System
|
|
|
|
* Programming)*/
|
|
|
|
|
|
|
|
if(addr == (long) &dummy->u_debugreg[7]) {
|
|
|
|
data &= ~DR_CONTROL_RESERVED;
|
|
|
|
for(i=0; i<4; i++)
|
|
|
|
if ((0x5f54 >> ((data >> (16 + 4*i)) & 0xf)) & 1)
|
|
|
|
goto out_tsk;
|
2006-07-10 01:12:39 +00:00
|
|
|
if (data)
|
|
|
|
set_tsk_thread_flag(child, TIF_DEBUG);
|
|
|
|
else
|
|
|
|
clear_tsk_thread_flag(child, TIF_DEBUG);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
addr -= (long) &dummy->u_debugreg;
|
|
|
|
addr = addr >> 2;
|
|
|
|
child->thread.debugreg[addr] = data;
|
|
|
|
ret = 0;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
[PATCH] UML Support - Ptrace: adds the host SYSEMU support, for UML and general usage
Jeff Dike <jdike@addtoit.com>,
Paolo 'Blaisorblade' Giarrusso <blaisorblade_spam@yahoo.it>,
Bodo Stroesser <bstroesser@fujitsu-siemens.com>
Adds a new ptrace(2) mode, called PTRACE_SYSEMU, resembling PTRACE_SYSCALL
except that the kernel does not execute the requested syscall; this is useful
to improve performance for virtual environments, like UML, which want to run
the syscall on their own.
In fact, using PTRACE_SYSCALL means stopping child execution twice, on entry
and on exit, and each time you also have two context switches; with SYSEMU you
avoid the 2nd stop and so save two context switches per syscall.
Also, some architectures don't have support in the host for changing the
syscall number via ptrace(), which is currently needed to skip syscall
execution (UML turns any syscall into getpid() to avoid it being executed on
the host). Fixing that is hard, while SYSEMU is easier to implement.
* This version of the patch includes some suggestions of Jeff Dike to avoid
adding any instructions to the syscall fast path, plus some other little
changes, by myself, to make it work even when the syscall is executed with
SYSENTER (but I'm unsure about them). It has been widely tested for quite a
lot of time.
* Various fixed were included to handle the various switches between
various states, i.e. when for instance a syscall entry is traced with one of
PT_SYSCALL / _SYSEMU / _SINGLESTEP and another one is used on exit.
Basically, this is done by remembering which one of them was used even after
the call to ptrace_notify().
* We're combining TIF_SYSCALL_EMU with TIF_SYSCALL_TRACE or TIF_SINGLESTEP
to make do_syscall_trace() notice that the current syscall was started with
SYSEMU on entry, so that no notification ought to be done in the exit path;
this is a bit of a hack, so this problem is solved in another way in next
patches.
* Also, the effects of the patch:
"Ptrace - i386: fix Syscall Audit interaction with singlestep"
are cancelled; they are restored back in the last patch of this series.
Detailed descriptions of the patches doing this kind of processing follow (but
I've already summed everything up).
* Fix behaviour when changing interception kind #1.
In do_syscall_trace(), we check the status of the TIF_SYSCALL_EMU flag
only after doing the debugger notification; but the debugger might have
changed the status of this flag because he continued execution with
PTRACE_SYSCALL, so this is wrong. This patch fixes it by saving the flag
status before calling ptrace_notify().
* Fix behaviour when changing interception kind #2:
avoid intercepting syscall on return when using SYSCALL again.
A guest process switching from using PTRACE_SYSEMU to PTRACE_SYSCALL
crashes.
The problem is in arch/i386/kernel/entry.S. The current SYSEMU patch
inhibits the syscall-handler to be called, but does not prevent
do_syscall_trace() to be called after this for syscall completion
interception.
The appended patch fixes this. It reuses the flag TIF_SYSCALL_EMU to
remember "we come from PTRACE_SYSEMU and now are in PTRACE_SYSCALL", since
the flag is unused in the depicted situation.
* Fix behaviour when changing interception kind #3:
avoid intercepting syscall on return when using SINGLESTEP.
When testing 2.6.9 and the skas3.v6 patch, with my latest patch and had
problems with singlestepping on UML in SKAS with SYSEMU. It looped
receiving SIGTRAPs without moving forward. EIP of the traced process was
the same for all SIGTRAPs.
What's missing is to handle switching from PTRACE_SYSCALL_EMU to
PTRACE_SINGLESTEP in a way very similar to what is done for the change from
PTRACE_SYSCALL_EMU to PTRACE_SYSCALL_TRACE.
I.e., after calling ptrace(PTRACE_SYSEMU), on the return path, the debugger is
notified and then wake ups the process; the syscall is executed (or skipped,
when do_syscall_trace() returns 0, i.e. when using PTRACE_SYSEMU), and
do_syscall_trace() is called again. Since we are on the return path of a
SYSEMU'd syscall, if the wake up is performed through ptrace(PTRACE_SYSCALL),
we must still avoid notifying the parent of the syscall exit. Now, this
behaviour is extended even to resuming with PTRACE_SINGLESTEP.
Signed-off-by: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Cc: Jeff Dike <jdike@addtoit.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-09-03 22:57:18 +00:00
|
|
|
case PTRACE_SYSEMU: /* continue and stop at next syscall, which will not be executed */
|
2005-04-16 22:20:36 +00:00
|
|
|
case PTRACE_SYSCALL: /* continue and stop at next (return from) syscall */
|
|
|
|
case PTRACE_CONT: /* restart after signal. */
|
|
|
|
ret = -EIO;
|
2005-05-01 15:59:14 +00:00
|
|
|
if (!valid_signal(data))
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
[PATCH] UML Support - Ptrace: adds the host SYSEMU support, for UML and general usage
Jeff Dike <jdike@addtoit.com>,
Paolo 'Blaisorblade' Giarrusso <blaisorblade_spam@yahoo.it>,
Bodo Stroesser <bstroesser@fujitsu-siemens.com>
Adds a new ptrace(2) mode, called PTRACE_SYSEMU, resembling PTRACE_SYSCALL
except that the kernel does not execute the requested syscall; this is useful
to improve performance for virtual environments, like UML, which want to run
the syscall on their own.
In fact, using PTRACE_SYSCALL means stopping child execution twice, on entry
and on exit, and each time you also have two context switches; with SYSEMU you
avoid the 2nd stop and so save two context switches per syscall.
Also, some architectures don't have support in the host for changing the
syscall number via ptrace(), which is currently needed to skip syscall
execution (UML turns any syscall into getpid() to avoid it being executed on
the host). Fixing that is hard, while SYSEMU is easier to implement.
* This version of the patch includes some suggestions of Jeff Dike to avoid
adding any instructions to the syscall fast path, plus some other little
changes, by myself, to make it work even when the syscall is executed with
SYSENTER (but I'm unsure about them). It has been widely tested for quite a
lot of time.
* Various fixed were included to handle the various switches between
various states, i.e. when for instance a syscall entry is traced with one of
PT_SYSCALL / _SYSEMU / _SINGLESTEP and another one is used on exit.
Basically, this is done by remembering which one of them was used even after
the call to ptrace_notify().
* We're combining TIF_SYSCALL_EMU with TIF_SYSCALL_TRACE or TIF_SINGLESTEP
to make do_syscall_trace() notice that the current syscall was started with
SYSEMU on entry, so that no notification ought to be done in the exit path;
this is a bit of a hack, so this problem is solved in another way in next
patches.
* Also, the effects of the patch:
"Ptrace - i386: fix Syscall Audit interaction with singlestep"
are cancelled; they are restored back in the last patch of this series.
Detailed descriptions of the patches doing this kind of processing follow (but
I've already summed everything up).
* Fix behaviour when changing interception kind #1.
In do_syscall_trace(), we check the status of the TIF_SYSCALL_EMU flag
only after doing the debugger notification; but the debugger might have
changed the status of this flag because he continued execution with
PTRACE_SYSCALL, so this is wrong. This patch fixes it by saving the flag
status before calling ptrace_notify().
* Fix behaviour when changing interception kind #2:
avoid intercepting syscall on return when using SYSCALL again.
A guest process switching from using PTRACE_SYSEMU to PTRACE_SYSCALL
crashes.
The problem is in arch/i386/kernel/entry.S. The current SYSEMU patch
inhibits the syscall-handler to be called, but does not prevent
do_syscall_trace() to be called after this for syscall completion
interception.
The appended patch fixes this. It reuses the flag TIF_SYSCALL_EMU to
remember "we come from PTRACE_SYSEMU and now are in PTRACE_SYSCALL", since
the flag is unused in the depicted situation.
* Fix behaviour when changing interception kind #3:
avoid intercepting syscall on return when using SINGLESTEP.
When testing 2.6.9 and the skas3.v6 patch, with my latest patch and had
problems with singlestepping on UML in SKAS with SYSEMU. It looped
receiving SIGTRAPs without moving forward. EIP of the traced process was
the same for all SIGTRAPs.
What's missing is to handle switching from PTRACE_SYSCALL_EMU to
PTRACE_SINGLESTEP in a way very similar to what is done for the change from
PTRACE_SYSCALL_EMU to PTRACE_SYSCALL_TRACE.
I.e., after calling ptrace(PTRACE_SYSEMU), on the return path, the debugger is
notified and then wake ups the process; the syscall is executed (or skipped,
when do_syscall_trace() returns 0, i.e. when using PTRACE_SYSEMU), and
do_syscall_trace() is called again. Since we are on the return path of a
SYSEMU'd syscall, if the wake up is performed through ptrace(PTRACE_SYSCALL),
we must still avoid notifying the parent of the syscall exit. Now, this
behaviour is extended even to resuming with PTRACE_SINGLESTEP.
Signed-off-by: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Cc: Jeff Dike <jdike@addtoit.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-09-03 22:57:18 +00:00
|
|
|
if (request == PTRACE_SYSEMU) {
|
|
|
|
set_tsk_thread_flag(child, TIF_SYSCALL_EMU);
|
2005-09-03 22:57:19 +00:00
|
|
|
clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
|
|
|
|
} else if (request == PTRACE_SYSCALL) {
|
2005-04-16 22:20:36 +00:00
|
|
|
set_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
|
2005-09-03 22:57:19 +00:00
|
|
|
clear_tsk_thread_flag(child, TIF_SYSCALL_EMU);
|
[PATCH] UML Support - Ptrace: adds the host SYSEMU support, for UML and general usage
Jeff Dike <jdike@addtoit.com>,
Paolo 'Blaisorblade' Giarrusso <blaisorblade_spam@yahoo.it>,
Bodo Stroesser <bstroesser@fujitsu-siemens.com>
Adds a new ptrace(2) mode, called PTRACE_SYSEMU, resembling PTRACE_SYSCALL
except that the kernel does not execute the requested syscall; this is useful
to improve performance for virtual environments, like UML, which want to run
the syscall on their own.
In fact, using PTRACE_SYSCALL means stopping child execution twice, on entry
and on exit, and each time you also have two context switches; with SYSEMU you
avoid the 2nd stop and so save two context switches per syscall.
Also, some architectures don't have support in the host for changing the
syscall number via ptrace(), which is currently needed to skip syscall
execution (UML turns any syscall into getpid() to avoid it being executed on
the host). Fixing that is hard, while SYSEMU is easier to implement.
* This version of the patch includes some suggestions of Jeff Dike to avoid
adding any instructions to the syscall fast path, plus some other little
changes, by myself, to make it work even when the syscall is executed with
SYSENTER (but I'm unsure about them). It has been widely tested for quite a
lot of time.
* Various fixed were included to handle the various switches between
various states, i.e. when for instance a syscall entry is traced with one of
PT_SYSCALL / _SYSEMU / _SINGLESTEP and another one is used on exit.
Basically, this is done by remembering which one of them was used even after
the call to ptrace_notify().
* We're combining TIF_SYSCALL_EMU with TIF_SYSCALL_TRACE or TIF_SINGLESTEP
to make do_syscall_trace() notice that the current syscall was started with
SYSEMU on entry, so that no notification ought to be done in the exit path;
this is a bit of a hack, so this problem is solved in another way in next
patches.
* Also, the effects of the patch:
"Ptrace - i386: fix Syscall Audit interaction with singlestep"
are cancelled; they are restored back in the last patch of this series.
Detailed descriptions of the patches doing this kind of processing follow (but
I've already summed everything up).
* Fix behaviour when changing interception kind #1.
In do_syscall_trace(), we check the status of the TIF_SYSCALL_EMU flag
only after doing the debugger notification; but the debugger might have
changed the status of this flag because he continued execution with
PTRACE_SYSCALL, so this is wrong. This patch fixes it by saving the flag
status before calling ptrace_notify().
* Fix behaviour when changing interception kind #2:
avoid intercepting syscall on return when using SYSCALL again.
A guest process switching from using PTRACE_SYSEMU to PTRACE_SYSCALL
crashes.
The problem is in arch/i386/kernel/entry.S. The current SYSEMU patch
inhibits the syscall-handler to be called, but does not prevent
do_syscall_trace() to be called after this for syscall completion
interception.
The appended patch fixes this. It reuses the flag TIF_SYSCALL_EMU to
remember "we come from PTRACE_SYSEMU and now are in PTRACE_SYSCALL", since
the flag is unused in the depicted situation.
* Fix behaviour when changing interception kind #3:
avoid intercepting syscall on return when using SINGLESTEP.
When testing 2.6.9 and the skas3.v6 patch, with my latest patch and had
problems with singlestepping on UML in SKAS with SYSEMU. It looped
receiving SIGTRAPs without moving forward. EIP of the traced process was
the same for all SIGTRAPs.
What's missing is to handle switching from PTRACE_SYSCALL_EMU to
PTRACE_SINGLESTEP in a way very similar to what is done for the change from
PTRACE_SYSCALL_EMU to PTRACE_SYSCALL_TRACE.
I.e., after calling ptrace(PTRACE_SYSEMU), on the return path, the debugger is
notified and then wake ups the process; the syscall is executed (or skipped,
when do_syscall_trace() returns 0, i.e. when using PTRACE_SYSEMU), and
do_syscall_trace() is called again. Since we are on the return path of a
SYSEMU'd syscall, if the wake up is performed through ptrace(PTRACE_SYSCALL),
we must still avoid notifying the parent of the syscall exit. Now, this
behaviour is extended even to resuming with PTRACE_SINGLESTEP.
Signed-off-by: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Cc: Jeff Dike <jdike@addtoit.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-09-03 22:57:18 +00:00
|
|
|
} else {
|
2005-09-03 22:57:19 +00:00
|
|
|
clear_tsk_thread_flag(child, TIF_SYSCALL_EMU);
|
2005-04-16 22:20:36 +00:00
|
|
|
clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
|
|
|
|
}
|
|
|
|
child->exit_code = data;
|
|
|
|
/* make sure the single step bit is not set. */
|
|
|
|
clear_singlestep(child);
|
|
|
|
wake_up_process(child);
|
|
|
|
ret = 0;
|
|
|
|
break;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* make the child exit. Best I can do is send it a sigkill.
|
|
|
|
* perhaps it should be put in the status that it wants to
|
|
|
|
* exit.
|
|
|
|
*/
|
|
|
|
case PTRACE_KILL:
|
|
|
|
ret = 0;
|
|
|
|
if (child->exit_state == EXIT_ZOMBIE) /* already dead */
|
|
|
|
break;
|
|
|
|
child->exit_code = SIGKILL;
|
|
|
|
/* make sure the single step bit is not set. */
|
|
|
|
clear_singlestep(child);
|
|
|
|
wake_up_process(child);
|
|
|
|
break;
|
|
|
|
|
2005-09-03 22:57:20 +00:00
|
|
|
case PTRACE_SYSEMU_SINGLESTEP: /* Same as SYSEMU, but singlestep if not syscall */
|
2005-04-16 22:20:36 +00:00
|
|
|
case PTRACE_SINGLESTEP: /* set the trap flag. */
|
|
|
|
ret = -EIO;
|
2005-05-01 15:59:14 +00:00
|
|
|
if (!valid_signal(data))
|
2005-04-16 22:20:36 +00:00
|
|
|
break;
|
2005-09-03 22:57:20 +00:00
|
|
|
|
|
|
|
if (request == PTRACE_SYSEMU_SINGLESTEP)
|
|
|
|
set_tsk_thread_flag(child, TIF_SYSCALL_EMU);
|
|
|
|
else
|
|
|
|
clear_tsk_thread_flag(child, TIF_SYSCALL_EMU);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
|
|
|
|
set_singlestep(child);
|
|
|
|
child->exit_code = data;
|
|
|
|
/* give it a chance to run. */
|
|
|
|
wake_up_process(child);
|
|
|
|
ret = 0;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case PTRACE_DETACH:
|
|
|
|
/* detach a process that was attached. */
|
|
|
|
ret = ptrace_detach(child, data);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case PTRACE_GETREGS: { /* Get all gp regs from the child. */
|
|
|
|
if (!access_ok(VERIFY_WRITE, datap, FRAME_SIZE*sizeof(long))) {
|
|
|
|
ret = -EIO;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
for ( i = 0; i < FRAME_SIZE*sizeof(long); i += sizeof(long) ) {
|
|
|
|
__put_user(getreg(child, i), datap);
|
|
|
|
datap++;
|
|
|
|
}
|
|
|
|
ret = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case PTRACE_SETREGS: { /* Set all gp regs in the child. */
|
|
|
|
unsigned long tmp;
|
|
|
|
if (!access_ok(VERIFY_READ, datap, FRAME_SIZE*sizeof(long))) {
|
|
|
|
ret = -EIO;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
for ( i = 0; i < FRAME_SIZE*sizeof(long); i += sizeof(long) ) {
|
|
|
|
__get_user(tmp, datap);
|
|
|
|
putreg(child, i, tmp);
|
|
|
|
datap++;
|
|
|
|
}
|
|
|
|
ret = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case PTRACE_GETFPREGS: { /* Get the child FPU state. */
|
|
|
|
if (!access_ok(VERIFY_WRITE, datap,
|
|
|
|
sizeof(struct user_i387_struct))) {
|
|
|
|
ret = -EIO;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
ret = 0;
|
|
|
|
if (!tsk_used_math(child))
|
|
|
|
init_fpu(child);
|
|
|
|
get_fpregs((struct user_i387_struct __user *)data, child);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case PTRACE_SETFPREGS: { /* Set the child FPU state. */
|
|
|
|
if (!access_ok(VERIFY_READ, datap,
|
|
|
|
sizeof(struct user_i387_struct))) {
|
|
|
|
ret = -EIO;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
set_stopped_child_used_math(child);
|
|
|
|
set_fpregs(child, (struct user_i387_struct __user *)data);
|
|
|
|
ret = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case PTRACE_GETFPXREGS: { /* Get the child extended FPU state. */
|
|
|
|
if (!access_ok(VERIFY_WRITE, datap,
|
|
|
|
sizeof(struct user_fxsr_struct))) {
|
|
|
|
ret = -EIO;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (!tsk_used_math(child))
|
|
|
|
init_fpu(child);
|
|
|
|
ret = get_fpxregs((struct user_fxsr_struct __user *)data, child);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case PTRACE_SETFPXREGS: { /* Set the child extended FPU state. */
|
|
|
|
if (!access_ok(VERIFY_READ, datap,
|
|
|
|
sizeof(struct user_fxsr_struct))) {
|
|
|
|
ret = -EIO;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
set_stopped_child_used_math(child);
|
|
|
|
ret = set_fpxregs(child, (struct user_fxsr_struct __user *)data);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case PTRACE_GET_THREAD_AREA:
|
|
|
|
ret = ptrace_get_thread_area(child, addr,
|
|
|
|
(struct user_desc __user *) data);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case PTRACE_SET_THREAD_AREA:
|
|
|
|
ret = ptrace_set_thread_area(child, addr,
|
|
|
|
(struct user_desc __user *) data);
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
ret = ptrace_request(child, request, addr, data);
|
|
|
|
break;
|
|
|
|
}
|
2005-11-07 08:59:47 +00:00
|
|
|
out_tsk:
|
2005-04-16 22:20:36 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
void send_sigtrap(struct task_struct *tsk, struct pt_regs *regs, int error_code)
|
|
|
|
{
|
|
|
|
struct siginfo info;
|
|
|
|
|
|
|
|
tsk->thread.trap_no = 1;
|
|
|
|
tsk->thread.error_code = error_code;
|
|
|
|
|
|
|
|
memset(&info, 0, sizeof(info));
|
|
|
|
info.si_signo = SIGTRAP;
|
|
|
|
info.si_code = TRAP_BRKPT;
|
|
|
|
|
|
|
|
/* User-mode eip? */
|
2005-06-23 07:08:44 +00:00
|
|
|
info.si_addr = user_mode_vm(regs) ? (void __user *) regs->eip : NULL;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Send us the fakey SIGTRAP */
|
|
|
|
force_sig_info(SIGTRAP, &info, tsk);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* notification of system call entry/exit
|
|
|
|
* - triggered by current->work.syscall_trace
|
|
|
|
*/
|
|
|
|
__attribute__((regparm(3)))
|
[PATCH] UML Support - Ptrace: adds the host SYSEMU support, for UML and general usage
Jeff Dike <jdike@addtoit.com>,
Paolo 'Blaisorblade' Giarrusso <blaisorblade_spam@yahoo.it>,
Bodo Stroesser <bstroesser@fujitsu-siemens.com>
Adds a new ptrace(2) mode, called PTRACE_SYSEMU, resembling PTRACE_SYSCALL
except that the kernel does not execute the requested syscall; this is useful
to improve performance for virtual environments, like UML, which want to run
the syscall on their own.
In fact, using PTRACE_SYSCALL means stopping child execution twice, on entry
and on exit, and each time you also have two context switches; with SYSEMU you
avoid the 2nd stop and so save two context switches per syscall.
Also, some architectures don't have support in the host for changing the
syscall number via ptrace(), which is currently needed to skip syscall
execution (UML turns any syscall into getpid() to avoid it being executed on
the host). Fixing that is hard, while SYSEMU is easier to implement.
* This version of the patch includes some suggestions of Jeff Dike to avoid
adding any instructions to the syscall fast path, plus some other little
changes, by myself, to make it work even when the syscall is executed with
SYSENTER (but I'm unsure about them). It has been widely tested for quite a
lot of time.
* Various fixed were included to handle the various switches between
various states, i.e. when for instance a syscall entry is traced with one of
PT_SYSCALL / _SYSEMU / _SINGLESTEP and another one is used on exit.
Basically, this is done by remembering which one of them was used even after
the call to ptrace_notify().
* We're combining TIF_SYSCALL_EMU with TIF_SYSCALL_TRACE or TIF_SINGLESTEP
to make do_syscall_trace() notice that the current syscall was started with
SYSEMU on entry, so that no notification ought to be done in the exit path;
this is a bit of a hack, so this problem is solved in another way in next
patches.
* Also, the effects of the patch:
"Ptrace - i386: fix Syscall Audit interaction with singlestep"
are cancelled; they are restored back in the last patch of this series.
Detailed descriptions of the patches doing this kind of processing follow (but
I've already summed everything up).
* Fix behaviour when changing interception kind #1.
In do_syscall_trace(), we check the status of the TIF_SYSCALL_EMU flag
only after doing the debugger notification; but the debugger might have
changed the status of this flag because he continued execution with
PTRACE_SYSCALL, so this is wrong. This patch fixes it by saving the flag
status before calling ptrace_notify().
* Fix behaviour when changing interception kind #2:
avoid intercepting syscall on return when using SYSCALL again.
A guest process switching from using PTRACE_SYSEMU to PTRACE_SYSCALL
crashes.
The problem is in arch/i386/kernel/entry.S. The current SYSEMU patch
inhibits the syscall-handler to be called, but does not prevent
do_syscall_trace() to be called after this for syscall completion
interception.
The appended patch fixes this. It reuses the flag TIF_SYSCALL_EMU to
remember "we come from PTRACE_SYSEMU and now are in PTRACE_SYSCALL", since
the flag is unused in the depicted situation.
* Fix behaviour when changing interception kind #3:
avoid intercepting syscall on return when using SINGLESTEP.
When testing 2.6.9 and the skas3.v6 patch, with my latest patch and had
problems with singlestepping on UML in SKAS with SYSEMU. It looped
receiving SIGTRAPs without moving forward. EIP of the traced process was
the same for all SIGTRAPs.
What's missing is to handle switching from PTRACE_SYSCALL_EMU to
PTRACE_SINGLESTEP in a way very similar to what is done for the change from
PTRACE_SYSCALL_EMU to PTRACE_SYSCALL_TRACE.
I.e., after calling ptrace(PTRACE_SYSEMU), on the return path, the debugger is
notified and then wake ups the process; the syscall is executed (or skipped,
when do_syscall_trace() returns 0, i.e. when using PTRACE_SYSEMU), and
do_syscall_trace() is called again. Since we are on the return path of a
SYSEMU'd syscall, if the wake up is performed through ptrace(PTRACE_SYSCALL),
we must still avoid notifying the parent of the syscall exit. Now, this
behaviour is extended even to resuming with PTRACE_SINGLESTEP.
Signed-off-by: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Cc: Jeff Dike <jdike@addtoit.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-09-03 22:57:18 +00:00
|
|
|
int do_syscall_trace(struct pt_regs *regs, int entryexit)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2005-09-09 20:01:51 +00:00
|
|
|
int is_sysemu = test_thread_flag(TIF_SYSCALL_EMU);
|
|
|
|
/*
|
|
|
|
* With TIF_SYSCALL_EMU set we want to ignore TIF_SINGLESTEP for syscall
|
|
|
|
* interception
|
|
|
|
*/
|
2005-09-03 22:57:20 +00:00
|
|
|
int is_singlestep = !is_sysemu && test_thread_flag(TIF_SINGLESTEP);
|
2005-09-09 20:01:51 +00:00
|
|
|
int ret = 0;
|
2005-09-03 22:57:20 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* do the secure computing check first */
|
2005-09-09 20:01:51 +00:00
|
|
|
if (!entryexit)
|
|
|
|
secure_computing(regs->orig_eax);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-09-03 22:57:21 +00:00
|
|
|
if (unlikely(current->audit_context)) {
|
|
|
|
if (entryexit)
|
2006-03-30 01:23:36 +00:00
|
|
|
audit_syscall_exit(AUDITSC_RESULT(regs->eax),
|
2005-09-09 20:01:51 +00:00
|
|
|
regs->eax);
|
2005-09-03 22:57:21 +00:00
|
|
|
/* Debug traps, when using PTRACE_SINGLESTEP, must be sent only
|
|
|
|
* on the syscall exit path. Normally, when TIF_SYSCALL_AUDIT is
|
|
|
|
* not used, entry.S will call us only on syscall exit, not
|
|
|
|
* entry; so when TIF_SYSCALL_AUDIT is used we must avoid
|
|
|
|
* calling send_sigtrap() on syscall entry.
|
|
|
|
*
|
|
|
|
* Note that when PTRACE_SYSEMU_SINGLESTEP is used,
|
|
|
|
* is_singlestep is false, despite his name, so we will still do
|
|
|
|
* the correct thing.
|
|
|
|
*/
|
|
|
|
else if (is_singlestep)
|
|
|
|
goto out;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (!(current->ptrace & PT_PTRACED))
|
2005-04-29 15:08:28 +00:00
|
|
|
goto out;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-09-03 22:57:20 +00:00
|
|
|
/* If a process stops on the 1st tracepoint with SYSCALL_TRACE
|
|
|
|
* and then is resumed with SYSEMU_SINGLESTEP, it will come in
|
|
|
|
* here. We have to check this and return */
|
|
|
|
if (is_sysemu && entryexit)
|
|
|
|
return 0;
|
[PATCH] UML Support - Ptrace: adds the host SYSEMU support, for UML and general usage
Jeff Dike <jdike@addtoit.com>,
Paolo 'Blaisorblade' Giarrusso <blaisorblade_spam@yahoo.it>,
Bodo Stroesser <bstroesser@fujitsu-siemens.com>
Adds a new ptrace(2) mode, called PTRACE_SYSEMU, resembling PTRACE_SYSCALL
except that the kernel does not execute the requested syscall; this is useful
to improve performance for virtual environments, like UML, which want to run
the syscall on their own.
In fact, using PTRACE_SYSCALL means stopping child execution twice, on entry
and on exit, and each time you also have two context switches; with SYSEMU you
avoid the 2nd stop and so save two context switches per syscall.
Also, some architectures don't have support in the host for changing the
syscall number via ptrace(), which is currently needed to skip syscall
execution (UML turns any syscall into getpid() to avoid it being executed on
the host). Fixing that is hard, while SYSEMU is easier to implement.
* This version of the patch includes some suggestions of Jeff Dike to avoid
adding any instructions to the syscall fast path, plus some other little
changes, by myself, to make it work even when the syscall is executed with
SYSENTER (but I'm unsure about them). It has been widely tested for quite a
lot of time.
* Various fixed were included to handle the various switches between
various states, i.e. when for instance a syscall entry is traced with one of
PT_SYSCALL / _SYSEMU / _SINGLESTEP and another one is used on exit.
Basically, this is done by remembering which one of them was used even after
the call to ptrace_notify().
* We're combining TIF_SYSCALL_EMU with TIF_SYSCALL_TRACE or TIF_SINGLESTEP
to make do_syscall_trace() notice that the current syscall was started with
SYSEMU on entry, so that no notification ought to be done in the exit path;
this is a bit of a hack, so this problem is solved in another way in next
patches.
* Also, the effects of the patch:
"Ptrace - i386: fix Syscall Audit interaction with singlestep"
are cancelled; they are restored back in the last patch of this series.
Detailed descriptions of the patches doing this kind of processing follow (but
I've already summed everything up).
* Fix behaviour when changing interception kind #1.
In do_syscall_trace(), we check the status of the TIF_SYSCALL_EMU flag
only after doing the debugger notification; but the debugger might have
changed the status of this flag because he continued execution with
PTRACE_SYSCALL, so this is wrong. This patch fixes it by saving the flag
status before calling ptrace_notify().
* Fix behaviour when changing interception kind #2:
avoid intercepting syscall on return when using SYSCALL again.
A guest process switching from using PTRACE_SYSEMU to PTRACE_SYSCALL
crashes.
The problem is in arch/i386/kernel/entry.S. The current SYSEMU patch
inhibits the syscall-handler to be called, but does not prevent
do_syscall_trace() to be called after this for syscall completion
interception.
The appended patch fixes this. It reuses the flag TIF_SYSCALL_EMU to
remember "we come from PTRACE_SYSEMU and now are in PTRACE_SYSCALL", since
the flag is unused in the depicted situation.
* Fix behaviour when changing interception kind #3:
avoid intercepting syscall on return when using SINGLESTEP.
When testing 2.6.9 and the skas3.v6 patch, with my latest patch and had
problems with singlestepping on UML in SKAS with SYSEMU. It looped
receiving SIGTRAPs without moving forward. EIP of the traced process was
the same for all SIGTRAPs.
What's missing is to handle switching from PTRACE_SYSCALL_EMU to
PTRACE_SINGLESTEP in a way very similar to what is done for the change from
PTRACE_SYSCALL_EMU to PTRACE_SYSCALL_TRACE.
I.e., after calling ptrace(PTRACE_SYSEMU), on the return path, the debugger is
notified and then wake ups the process; the syscall is executed (or skipped,
when do_syscall_trace() returns 0, i.e. when using PTRACE_SYSEMU), and
do_syscall_trace() is called again. Since we are on the return path of a
SYSEMU'd syscall, if the wake up is performed through ptrace(PTRACE_SYSCALL),
we must still avoid notifying the parent of the syscall exit. Now, this
behaviour is extended even to resuming with PTRACE_SINGLESTEP.
Signed-off-by: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Cc: Jeff Dike <jdike@addtoit.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-09-03 22:57:18 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Fake a debug trap */
|
2005-09-03 22:57:19 +00:00
|
|
|
if (is_singlestep)
|
2005-04-16 22:20:36 +00:00
|
|
|
send_sigtrap(current, regs, 0);
|
|
|
|
|
2005-09-03 22:57:19 +00:00
|
|
|
if (!test_thread_flag(TIF_SYSCALL_TRACE) && !is_sysemu)
|
2005-04-29 15:08:28 +00:00
|
|
|
goto out;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* the 0x80 provides a way for the tracing parent to distinguish
|
|
|
|
between a syscall stop and SIGTRAP delivery */
|
[PATCH] UML Support - Ptrace: adds the host SYSEMU support, for UML and general usage
Jeff Dike <jdike@addtoit.com>,
Paolo 'Blaisorblade' Giarrusso <blaisorblade_spam@yahoo.it>,
Bodo Stroesser <bstroesser@fujitsu-siemens.com>
Adds a new ptrace(2) mode, called PTRACE_SYSEMU, resembling PTRACE_SYSCALL
except that the kernel does not execute the requested syscall; this is useful
to improve performance for virtual environments, like UML, which want to run
the syscall on their own.
In fact, using PTRACE_SYSCALL means stopping child execution twice, on entry
and on exit, and each time you also have two context switches; with SYSEMU you
avoid the 2nd stop and so save two context switches per syscall.
Also, some architectures don't have support in the host for changing the
syscall number via ptrace(), which is currently needed to skip syscall
execution (UML turns any syscall into getpid() to avoid it being executed on
the host). Fixing that is hard, while SYSEMU is easier to implement.
* This version of the patch includes some suggestions of Jeff Dike to avoid
adding any instructions to the syscall fast path, plus some other little
changes, by myself, to make it work even when the syscall is executed with
SYSENTER (but I'm unsure about them). It has been widely tested for quite a
lot of time.
* Various fixed were included to handle the various switches between
various states, i.e. when for instance a syscall entry is traced with one of
PT_SYSCALL / _SYSEMU / _SINGLESTEP and another one is used on exit.
Basically, this is done by remembering which one of them was used even after
the call to ptrace_notify().
* We're combining TIF_SYSCALL_EMU with TIF_SYSCALL_TRACE or TIF_SINGLESTEP
to make do_syscall_trace() notice that the current syscall was started with
SYSEMU on entry, so that no notification ought to be done in the exit path;
this is a bit of a hack, so this problem is solved in another way in next
patches.
* Also, the effects of the patch:
"Ptrace - i386: fix Syscall Audit interaction with singlestep"
are cancelled; they are restored back in the last patch of this series.
Detailed descriptions of the patches doing this kind of processing follow (but
I've already summed everything up).
* Fix behaviour when changing interception kind #1.
In do_syscall_trace(), we check the status of the TIF_SYSCALL_EMU flag
only after doing the debugger notification; but the debugger might have
changed the status of this flag because he continued execution with
PTRACE_SYSCALL, so this is wrong. This patch fixes it by saving the flag
status before calling ptrace_notify().
* Fix behaviour when changing interception kind #2:
avoid intercepting syscall on return when using SYSCALL again.
A guest process switching from using PTRACE_SYSEMU to PTRACE_SYSCALL
crashes.
The problem is in arch/i386/kernel/entry.S. The current SYSEMU patch
inhibits the syscall-handler to be called, but does not prevent
do_syscall_trace() to be called after this for syscall completion
interception.
The appended patch fixes this. It reuses the flag TIF_SYSCALL_EMU to
remember "we come from PTRACE_SYSEMU and now are in PTRACE_SYSCALL", since
the flag is unused in the depicted situation.
* Fix behaviour when changing interception kind #3:
avoid intercepting syscall on return when using SINGLESTEP.
When testing 2.6.9 and the skas3.v6 patch, with my latest patch and had
problems with singlestepping on UML in SKAS with SYSEMU. It looped
receiving SIGTRAPs without moving forward. EIP of the traced process was
the same for all SIGTRAPs.
What's missing is to handle switching from PTRACE_SYSCALL_EMU to
PTRACE_SINGLESTEP in a way very similar to what is done for the change from
PTRACE_SYSCALL_EMU to PTRACE_SYSCALL_TRACE.
I.e., after calling ptrace(PTRACE_SYSEMU), on the return path, the debugger is
notified and then wake ups the process; the syscall is executed (or skipped,
when do_syscall_trace() returns 0, i.e. when using PTRACE_SYSEMU), and
do_syscall_trace() is called again. Since we are on the return path of a
SYSEMU'd syscall, if the wake up is performed through ptrace(PTRACE_SYSCALL),
we must still avoid notifying the parent of the syscall exit. Now, this
behaviour is extended even to resuming with PTRACE_SINGLESTEP.
Signed-off-by: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Cc: Jeff Dike <jdike@addtoit.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-09-03 22:57:18 +00:00
|
|
|
/* Note that the debugger could change the result of test_thread_flag!*/
|
2005-09-09 20:01:51 +00:00
|
|
|
ptrace_notify(SIGTRAP | ((current->ptrace & PT_TRACESYSGOOD) ? 0x80:0));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* this isn't the same as continuing with a signal, but it will do
|
|
|
|
* for normal use. strace only continues with a signal if the
|
|
|
|
* stopping signal is not SIGTRAP. -brl
|
|
|
|
*/
|
|
|
|
if (current->exit_code) {
|
|
|
|
send_sig(current->exit_code, current, 1);
|
|
|
|
current->exit_code = 0;
|
|
|
|
}
|
[PATCH] UML Support - Ptrace: adds the host SYSEMU support, for UML and general usage
Jeff Dike <jdike@addtoit.com>,
Paolo 'Blaisorblade' Giarrusso <blaisorblade_spam@yahoo.it>,
Bodo Stroesser <bstroesser@fujitsu-siemens.com>
Adds a new ptrace(2) mode, called PTRACE_SYSEMU, resembling PTRACE_SYSCALL
except that the kernel does not execute the requested syscall; this is useful
to improve performance for virtual environments, like UML, which want to run
the syscall on their own.
In fact, using PTRACE_SYSCALL means stopping child execution twice, on entry
and on exit, and each time you also have two context switches; with SYSEMU you
avoid the 2nd stop and so save two context switches per syscall.
Also, some architectures don't have support in the host for changing the
syscall number via ptrace(), which is currently needed to skip syscall
execution (UML turns any syscall into getpid() to avoid it being executed on
the host). Fixing that is hard, while SYSEMU is easier to implement.
* This version of the patch includes some suggestions of Jeff Dike to avoid
adding any instructions to the syscall fast path, plus some other little
changes, by myself, to make it work even when the syscall is executed with
SYSENTER (but I'm unsure about them). It has been widely tested for quite a
lot of time.
* Various fixed were included to handle the various switches between
various states, i.e. when for instance a syscall entry is traced with one of
PT_SYSCALL / _SYSEMU / _SINGLESTEP and another one is used on exit.
Basically, this is done by remembering which one of them was used even after
the call to ptrace_notify().
* We're combining TIF_SYSCALL_EMU with TIF_SYSCALL_TRACE or TIF_SINGLESTEP
to make do_syscall_trace() notice that the current syscall was started with
SYSEMU on entry, so that no notification ought to be done in the exit path;
this is a bit of a hack, so this problem is solved in another way in next
patches.
* Also, the effects of the patch:
"Ptrace - i386: fix Syscall Audit interaction with singlestep"
are cancelled; they are restored back in the last patch of this series.
Detailed descriptions of the patches doing this kind of processing follow (but
I've already summed everything up).
* Fix behaviour when changing interception kind #1.
In do_syscall_trace(), we check the status of the TIF_SYSCALL_EMU flag
only after doing the debugger notification; but the debugger might have
changed the status of this flag because he continued execution with
PTRACE_SYSCALL, so this is wrong. This patch fixes it by saving the flag
status before calling ptrace_notify().
* Fix behaviour when changing interception kind #2:
avoid intercepting syscall on return when using SYSCALL again.
A guest process switching from using PTRACE_SYSEMU to PTRACE_SYSCALL
crashes.
The problem is in arch/i386/kernel/entry.S. The current SYSEMU patch
inhibits the syscall-handler to be called, but does not prevent
do_syscall_trace() to be called after this for syscall completion
interception.
The appended patch fixes this. It reuses the flag TIF_SYSCALL_EMU to
remember "we come from PTRACE_SYSEMU and now are in PTRACE_SYSCALL", since
the flag is unused in the depicted situation.
* Fix behaviour when changing interception kind #3:
avoid intercepting syscall on return when using SINGLESTEP.
When testing 2.6.9 and the skas3.v6 patch, with my latest patch and had
problems with singlestepping on UML in SKAS with SYSEMU. It looped
receiving SIGTRAPs without moving forward. EIP of the traced process was
the same for all SIGTRAPs.
What's missing is to handle switching from PTRACE_SYSCALL_EMU to
PTRACE_SINGLESTEP in a way very similar to what is done for the change from
PTRACE_SYSCALL_EMU to PTRACE_SYSCALL_TRACE.
I.e., after calling ptrace(PTRACE_SYSEMU), on the return path, the debugger is
notified and then wake ups the process; the syscall is executed (or skipped,
when do_syscall_trace() returns 0, i.e. when using PTRACE_SYSEMU), and
do_syscall_trace() is called again. Since we are on the return path of a
SYSEMU'd syscall, if the wake up is performed through ptrace(PTRACE_SYSCALL),
we must still avoid notifying the parent of the syscall exit. Now, this
behaviour is extended even to resuming with PTRACE_SINGLESTEP.
Signed-off-by: Paolo 'Blaisorblade' Giarrusso <blaisorblade@yahoo.it>
Cc: Jeff Dike <jdike@addtoit.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-09-03 22:57:18 +00:00
|
|
|
ret = is_sysemu;
|
2005-09-09 20:01:51 +00:00
|
|
|
out:
|
2005-04-29 15:08:28 +00:00
|
|
|
if (unlikely(current->audit_context) && !entryexit)
|
2006-03-30 01:23:36 +00:00
|
|
|
audit_syscall_entry(AUDIT_ARCH_I386, regs->orig_eax,
|
2005-04-29 15:08:28 +00:00
|
|
|
regs->ebx, regs->ecx, regs->edx, regs->esi);
|
2005-09-03 22:57:19 +00:00
|
|
|
if (ret == 0)
|
|
|
|
return 0;
|
|
|
|
|
2005-09-03 22:57:20 +00:00
|
|
|
regs->orig_eax = -1; /* force skip of syscall restarting */
|
2005-09-03 22:57:19 +00:00
|
|
|
if (unlikely(current->audit_context))
|
2006-03-30 01:23:36 +00:00
|
|
|
audit_syscall_exit(AUDITSC_RESULT(regs->eax), regs->eax);
|
2005-09-03 22:57:19 +00:00
|
|
|
return 1;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|