/* ptrace.c */
|
/* ptrace.c */
|
/* By Ross Biro 1/23/92 */
|
/* By Ross Biro 1/23/92 */
|
/* edited by Linus Torvalds */
|
/* edited by Linus Torvalds */
|
|
|
#include <linux/config.h> /* CONFIG_MATH_EMULATION */
|
#include <linux/config.h> /* CONFIG_MATH_EMULATION */
|
#include <linux/head.h>
|
#include <linux/head.h>
|
#include <linux/kernel.h>
|
#include <linux/kernel.h>
|
#include <linux/sched.h>
|
#include <linux/sched.h>
|
#include <linux/mm.h>
|
#include <linux/mm.h>
|
#include <linux/errno.h>
|
#include <linux/errno.h>
|
#include <linux/ptrace.h>
|
#include <linux/ptrace.h>
|
#include <linux/user.h>
|
#include <linux/user.h>
|
#include <linux/debugreg.h>
|
#include <linux/debugreg.h>
|
|
|
#include <asm/segment.h>
|
#include <asm/segment.h>
|
#include <asm/pgtable.h>
|
#include <asm/pgtable.h>
|
#include <asm/system.h>
|
#include <asm/system.h>
|
|
|
/*
|
/*
|
* does not yet catch signals sent when the child dies.
|
* does not yet catch signals sent when the child dies.
|
* in exit.c or in signal.c.
|
* in exit.c or in signal.c.
|
*/
|
*/
|
|
|
/* determines which flags the user has access to. */
|
/* determines which flags the user has access to. */
|
/* 1 = access 0 = no access */
|
/* 1 = access 0 = no access */
|
#define FLAG_MASK 0x00044dd5
|
#define FLAG_MASK 0x00044dd5
|
|
|
/* set's the trap flag. */
|
/* set's the trap flag. */
|
#define TRAP_FLAG 0x100
|
#define TRAP_FLAG 0x100
|
|
|
/*
|
/*
|
* this is the number to subtract from the top of the stack. To find
|
* this is the number to subtract from the top of the stack. To find
|
* the local frame.
|
* the local frame.
|
*/
|
*/
|
#define MAGICNUMBER 68
|
#define MAGICNUMBER 68
|
|
|
/* change a pid into a task struct. */
|
/* change a pid into a task struct. */
|
static inline struct task_struct * get_task(int pid)
|
static inline struct task_struct * get_task(int pid)
|
{
|
{
|
int i;
|
int i;
|
|
|
for (i = 1; i < NR_TASKS; i++) {
|
for (i = 1; i < NR_TASKS; i++) {
|
if (task[i] != NULL && (task[i]->pid == pid))
|
if (task[i] != NULL && (task[i]->pid == pid))
|
return task[i];
|
return task[i];
|
}
|
}
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
/*
|
/*
|
* this routine will get a word off of the processes privileged stack.
|
* this routine will get a word off of the processes privileged stack.
|
* the offset is how far from the base addr as stored in the TSS.
|
* the offset is how far from the base addr as stored in the TSS.
|
* this routine assumes that all the privileged stacks are in our
|
* this routine assumes that all the privileged stacks are in our
|
* data space.
|
* data space.
|
*/
|
*/
|
static inline int get_stack_long(struct task_struct *task, int offset)
|
static inline int get_stack_long(struct task_struct *task, int offset)
|
{
|
{
|
unsigned char *stack;
|
unsigned char *stack;
|
|
|
stack = (unsigned char *)task->tss.esp0;
|
stack = (unsigned char *)task->tss.esp0;
|
stack += offset;
|
stack += offset;
|
return (*((int *)stack));
|
return (*((int *)stack));
|
}
|
}
|
|
|
/*
|
/*
|
* this routine will put a word on the processes privileged stack.
|
* this routine will put a word on the processes privileged stack.
|
* the offset is how far from the base addr as stored in the TSS.
|
* the offset is how far from the base addr as stored in the TSS.
|
* this routine assumes that all the privileged stacks are in our
|
* this routine assumes that all the privileged stacks are in our
|
* data space.
|
* data space.
|
*/
|
*/
|
static inline int put_stack_long(struct task_struct *task, int offset,
|
static inline int put_stack_long(struct task_struct *task, int offset,
|
unsigned long data)
|
unsigned long data)
|
{
|
{
|
unsigned char * stack;
|
unsigned char * stack;
|
|
|
stack = (unsigned char *) task->tss.esp0;
|
stack = (unsigned char *) task->tss.esp0;
|
stack += offset;
|
stack += offset;
|
*(unsigned long *) stack = data;
|
*(unsigned long *) stack = data;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/*
|
/*
|
* This routine gets a long from any process space by following the page
|
* This routine gets a long from any process space by following the page
|
* tables. NOTE! You should check that the long isn't on a page boundary,
|
* tables. NOTE! You should check that the long isn't on a page boundary,
|
* and that it is in the task area before calling this: this routine does
|
* and that it is in the task area before calling this: this routine does
|
* no checking.
|
* no checking.
|
*/
|
*/
|
static unsigned long get_long(struct task_struct * tsk,
|
static unsigned long get_long(struct task_struct * tsk,
|
struct vm_area_struct * vma, unsigned long addr)
|
struct vm_area_struct * vma, unsigned long addr)
|
{
|
{
|
pgd_t * pgdir;
|
pgd_t * pgdir;
|
pmd_t * pgmiddle;
|
pmd_t * pgmiddle;
|
pte_t * pgtable;
|
pte_t * pgtable;
|
unsigned long page;
|
unsigned long page;
|
|
|
repeat:
|
repeat:
|
pgdir = pgd_offset(vma->vm_mm, addr);
|
pgdir = pgd_offset(vma->vm_mm, addr);
|
if (pgd_none(*pgdir)) {
|
if (pgd_none(*pgdir)) {
|
do_no_page(tsk, vma, addr, 0);
|
do_no_page(tsk, vma, addr, 0);
|
goto repeat;
|
goto repeat;
|
}
|
}
|
if (pgd_bad(*pgdir)) {
|
if (pgd_bad(*pgdir)) {
|
printk("ptrace: bad page directory %08lx\n", pgd_val(*pgdir));
|
printk("ptrace: bad page directory %08lx\n", pgd_val(*pgdir));
|
pgd_clear(pgdir);
|
pgd_clear(pgdir);
|
return 0;
|
return 0;
|
}
|
}
|
pgmiddle = pmd_offset(pgdir, addr);
|
pgmiddle = pmd_offset(pgdir, addr);
|
if (pmd_none(*pgmiddle)) {
|
if (pmd_none(*pgmiddle)) {
|
do_no_page(tsk, vma, addr, 0);
|
do_no_page(tsk, vma, addr, 0);
|
goto repeat;
|
goto repeat;
|
}
|
}
|
if (pmd_bad(*pgmiddle)) {
|
if (pmd_bad(*pgmiddle)) {
|
printk("ptrace: bad page middle %08lx\n", pmd_val(*pgmiddle));
|
printk("ptrace: bad page middle %08lx\n", pmd_val(*pgmiddle));
|
pmd_clear(pgmiddle);
|
pmd_clear(pgmiddle);
|
return 0;
|
return 0;
|
}
|
}
|
pgtable = pte_offset(pgmiddle, addr);
|
pgtable = pte_offset(pgmiddle, addr);
|
if (!pte_present(*pgtable)) {
|
if (!pte_present(*pgtable)) {
|
do_no_page(tsk, vma, addr, 0);
|
do_no_page(tsk, vma, addr, 0);
|
goto repeat;
|
goto repeat;
|
}
|
}
|
page = pte_page(*pgtable);
|
page = pte_page(*pgtable);
|
/* this is a hack for non-kernel-mapped video buffers and similar */
|
/* this is a hack for non-kernel-mapped video buffers and similar */
|
if (page >= high_memory)
|
if (page >= high_memory)
|
return 0;
|
return 0;
|
page += addr & ~PAGE_MASK;
|
page += addr & ~PAGE_MASK;
|
return *(unsigned long *) page;
|
return *(unsigned long *) page;
|
}
|
}
|
|
|
/*
|
/*
|
* This routine puts a long into any process space by following the page
|
* This routine puts a long into any process space by following the page
|
* tables. NOTE! You should check that the long isn't on a page boundary,
|
* tables. NOTE! You should check that the long isn't on a page boundary,
|
* and that it is in the task area before calling this: this routine does
|
* and that it is in the task area before calling this: this routine does
|
* no checking.
|
* no checking.
|
*
|
*
|
* Now keeps R/W state of page so that a text page stays readonly
|
* Now keeps R/W state of page so that a text page stays readonly
|
* even if a debugger scribbles breakpoints into it. -M.U-
|
* even if a debugger scribbles breakpoints into it. -M.U-
|
*/
|
*/
|
static void put_long(struct task_struct * tsk, struct vm_area_struct * vma, unsigned long addr,
|
static void put_long(struct task_struct * tsk, struct vm_area_struct * vma, unsigned long addr,
|
unsigned long data)
|
unsigned long data)
|
{
|
{
|
pgd_t *pgdir;
|
pgd_t *pgdir;
|
pmd_t *pgmiddle;
|
pmd_t *pgmiddle;
|
pte_t *pgtable;
|
pte_t *pgtable;
|
unsigned long page;
|
unsigned long page;
|
|
|
repeat:
|
repeat:
|
pgdir = pgd_offset(vma->vm_mm, addr);
|
pgdir = pgd_offset(vma->vm_mm, addr);
|
if (!pgd_present(*pgdir)) {
|
if (!pgd_present(*pgdir)) {
|
do_no_page(tsk, vma, addr, 1);
|
do_no_page(tsk, vma, addr, 1);
|
goto repeat;
|
goto repeat;
|
}
|
}
|
if (pgd_bad(*pgdir)) {
|
if (pgd_bad(*pgdir)) {
|
printk("ptrace: bad page directory %08lx\n", pgd_val(*pgdir));
|
printk("ptrace: bad page directory %08lx\n", pgd_val(*pgdir));
|
pgd_clear(pgdir);
|
pgd_clear(pgdir);
|
return;
|
return;
|
}
|
}
|
pgmiddle = pmd_offset(pgdir, addr);
|
pgmiddle = pmd_offset(pgdir, addr);
|
if (pmd_none(*pgmiddle)) {
|
if (pmd_none(*pgmiddle)) {
|
do_no_page(tsk, vma, addr, 1);
|
do_no_page(tsk, vma, addr, 1);
|
goto repeat;
|
goto repeat;
|
}
|
}
|
if (pmd_bad(*pgmiddle)) {
|
if (pmd_bad(*pgmiddle)) {
|
printk("ptrace: bad page middle %08lx\n", pmd_val(*pgmiddle));
|
printk("ptrace: bad page middle %08lx\n", pmd_val(*pgmiddle));
|
pmd_clear(pgmiddle);
|
pmd_clear(pgmiddle);
|
return;
|
return;
|
}
|
}
|
pgtable = pte_offset(pgmiddle, addr);
|
pgtable = pte_offset(pgmiddle, addr);
|
if (!pte_present(*pgtable)) {
|
if (!pte_present(*pgtable)) {
|
do_no_page(tsk, vma, addr, 1);
|
do_no_page(tsk, vma, addr, 1);
|
goto repeat;
|
goto repeat;
|
}
|
}
|
page = pte_page(*pgtable);
|
page = pte_page(*pgtable);
|
if (!pte_write(*pgtable)) {
|
if (!pte_write(*pgtable)) {
|
do_wp_page(tsk, vma, addr, 1);
|
do_wp_page(tsk, vma, addr, 1);
|
goto repeat;
|
goto repeat;
|
}
|
}
|
/* this is a hack for non-kernel-mapped video buffers and similar */
|
/* this is a hack for non-kernel-mapped video buffers and similar */
|
if (page < high_memory)
|
if (page < high_memory)
|
*(unsigned long *) (page + (addr & ~PAGE_MASK)) = data;
|
*(unsigned long *) (page + (addr & ~PAGE_MASK)) = data;
|
/* we're bypassing pagetables, so we have to set the dirty bit ourselves */
|
/* we're bypassing pagetables, so we have to set the dirty bit ourselves */
|
/* this should also re-instate whatever read-only mode there was before */
|
/* this should also re-instate whatever read-only mode there was before */
|
set_pte(pgtable, pte_mkdirty(mk_pte(page, vma->vm_page_prot)));
|
set_pte(pgtable, pte_mkdirty(mk_pte(page, vma->vm_page_prot)));
|
flush_tlb();
|
flush_tlb();
|
}
|
}
|
|
|
static struct vm_area_struct * find_extend_vma(struct task_struct * tsk, unsigned long addr)
|
static struct vm_area_struct * find_extend_vma(struct task_struct * tsk, unsigned long addr)
|
{
|
{
|
struct vm_area_struct * vma;
|
struct vm_area_struct * vma;
|
|
|
addr &= PAGE_MASK;
|
addr &= PAGE_MASK;
|
vma = find_vma(tsk->mm,addr);
|
vma = find_vma(tsk->mm,addr);
|
if (!vma)
|
if (!vma)
|
return NULL;
|
return NULL;
|
if (vma->vm_start <= addr)
|
if (vma->vm_start <= addr)
|
return vma;
|
return vma;
|
if (!(vma->vm_flags & VM_GROWSDOWN))
|
if (!(vma->vm_flags & VM_GROWSDOWN))
|
return NULL;
|
return NULL;
|
if (vma->vm_end - addr > tsk->rlim[RLIMIT_STACK].rlim_cur)
|
if (vma->vm_end - addr > tsk->rlim[RLIMIT_STACK].rlim_cur)
|
return NULL;
|
return NULL;
|
vma->vm_offset -= vma->vm_start - addr;
|
vma->vm_offset -= vma->vm_start - addr;
|
vma->vm_start = addr;
|
vma->vm_start = addr;
|
return vma;
|
return vma;
|
}
|
}
|
|
|
/*
|
/*
|
* This routine checks the page boundaries, and that the offset is
|
* This routine checks the page boundaries, and that the offset is
|
* within the task area. It then calls get_long() to read a long.
|
* within the task area. It then calls get_long() to read a long.
|
*/
|
*/
|
static int read_long(struct task_struct * tsk, unsigned long addr,
|
static int read_long(struct task_struct * tsk, unsigned long addr,
|
unsigned long * result)
|
unsigned long * result)
|
{
|
{
|
struct vm_area_struct * vma = find_extend_vma(tsk, addr);
|
struct vm_area_struct * vma = find_extend_vma(tsk, addr);
|
|
|
if (!vma)
|
if (!vma)
|
return -EIO;
|
return -EIO;
|
if ((addr & ~PAGE_MASK) > PAGE_SIZE-sizeof(long)) {
|
if ((addr & ~PAGE_MASK) > PAGE_SIZE-sizeof(long)) {
|
unsigned long low,high;
|
unsigned long low,high;
|
struct vm_area_struct * vma_high = vma;
|
struct vm_area_struct * vma_high = vma;
|
|
|
if (addr + sizeof(long) >= vma->vm_end) {
|
if (addr + sizeof(long) >= vma->vm_end) {
|
vma_high = vma->vm_next;
|
vma_high = vma->vm_next;
|
if (!vma_high || vma_high->vm_start != vma->vm_end)
|
if (!vma_high || vma_high->vm_start != vma->vm_end)
|
return -EIO;
|
return -EIO;
|
}
|
}
|
low = get_long(tsk, vma, addr & ~(sizeof(long)-1));
|
low = get_long(tsk, vma, addr & ~(sizeof(long)-1));
|
high = get_long(tsk, vma_high, (addr+sizeof(long)) & ~(sizeof(long)-1));
|
high = get_long(tsk, vma_high, (addr+sizeof(long)) & ~(sizeof(long)-1));
|
switch (addr & (sizeof(long)-1)) {
|
switch (addr & (sizeof(long)-1)) {
|
case 1:
|
case 1:
|
low >>= 8;
|
low >>= 8;
|
low |= high << 24;
|
low |= high << 24;
|
break;
|
break;
|
case 2:
|
case 2:
|
low >>= 16;
|
low >>= 16;
|
low |= high << 16;
|
low |= high << 16;
|
break;
|
break;
|
case 3:
|
case 3:
|
low >>= 24;
|
low >>= 24;
|
low |= high << 8;
|
low |= high << 8;
|
break;
|
break;
|
}
|
}
|
*result = low;
|
*result = low;
|
} else
|
} else
|
*result = get_long(tsk, vma, addr);
|
*result = get_long(tsk, vma, addr);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/*
|
/*
|
* This routine checks the page boundaries, and that the offset is
|
* This routine checks the page boundaries, and that the offset is
|
* within the task area. It then calls put_long() to write a long.
|
* within the task area. It then calls put_long() to write a long.
|
*/
|
*/
|
static int write_long(struct task_struct * tsk, unsigned long addr,
|
static int write_long(struct task_struct * tsk, unsigned long addr,
|
unsigned long data)
|
unsigned long data)
|
{
|
{
|
struct vm_area_struct * vma = find_extend_vma(tsk, addr);
|
struct vm_area_struct * vma = find_extend_vma(tsk, addr);
|
|
|
if (!vma)
|
if (!vma)
|
return -EIO;
|
return -EIO;
|
if ((addr & ~PAGE_MASK) > PAGE_SIZE-sizeof(long)) {
|
if ((addr & ~PAGE_MASK) > PAGE_SIZE-sizeof(long)) {
|
unsigned long low,high;
|
unsigned long low,high;
|
struct vm_area_struct * vma_high = vma;
|
struct vm_area_struct * vma_high = vma;
|
|
|
if (addr + sizeof(long) >= vma->vm_end) {
|
if (addr + sizeof(long) >= vma->vm_end) {
|
vma_high = vma->vm_next;
|
vma_high = vma->vm_next;
|
if (!vma_high || vma_high->vm_start != vma->vm_end)
|
if (!vma_high || vma_high->vm_start != vma->vm_end)
|
return -EIO;
|
return -EIO;
|
}
|
}
|
low = get_long(tsk, vma, addr & ~(sizeof(long)-1));
|
low = get_long(tsk, vma, addr & ~(sizeof(long)-1));
|
high = get_long(tsk, vma_high, (addr+sizeof(long)) & ~(sizeof(long)-1));
|
high = get_long(tsk, vma_high, (addr+sizeof(long)) & ~(sizeof(long)-1));
|
switch (addr & (sizeof(long)-1)) {
|
switch (addr & (sizeof(long)-1)) {
|
case 0: /* shouldn't happen, but safety first */
|
case 0: /* shouldn't happen, but safety first */
|
low = data;
|
low = data;
|
break;
|
break;
|
case 1:
|
case 1:
|
low &= 0x000000ff;
|
low &= 0x000000ff;
|
low |= data << 8;
|
low |= data << 8;
|
high &= ~0xff;
|
high &= ~0xff;
|
high |= data >> 24;
|
high |= data >> 24;
|
break;
|
break;
|
case 2:
|
case 2:
|
low &= 0x0000ffff;
|
low &= 0x0000ffff;
|
low |= data << 16;
|
low |= data << 16;
|
high &= ~0xffff;
|
high &= ~0xffff;
|
high |= data >> 16;
|
high |= data >> 16;
|
break;
|
break;
|
case 3:
|
case 3:
|
low &= 0x00ffffff;
|
low &= 0x00ffffff;
|
low |= data << 24;
|
low |= data << 24;
|
high &= ~0xffffff;
|
high &= ~0xffffff;
|
high |= data >> 8;
|
high |= data >> 8;
|
break;
|
break;
|
}
|
}
|
put_long(tsk, vma, addr & ~(sizeof(long)-1),low);
|
put_long(tsk, vma, addr & ~(sizeof(long)-1),low);
|
put_long(tsk, vma_high, (addr+sizeof(long)) & ~(sizeof(long)-1),high);
|
put_long(tsk, vma_high, (addr+sizeof(long)) & ~(sizeof(long)-1),high);
|
} else
|
} else
|
put_long(tsk, vma, addr, data);
|
put_long(tsk, vma, addr, data);
|
return 0;
|
return 0;
|
}
|
}
|
#ifdef CONFIG_MATH_EMULATION
|
#ifdef CONFIG_MATH_EMULATION
|
static void write_emulator_word(struct task_struct *child,
|
static void write_emulator_word(struct task_struct *child,
|
unsigned long register_offset,
|
unsigned long register_offset,
|
long data)
|
long data)
|
{
|
{
|
int i, j;
|
int i, j;
|
struct i387_soft_struct *soft_fpu;
|
struct i387_soft_struct *soft_fpu;
|
struct fpu_reg *this_fpreg, *next_fpreg;
|
struct fpu_reg *this_fpreg, *next_fpreg;
|
char hard_reg[2][10];
|
char hard_reg[2][10];
|
int control_word;
|
int control_word;
|
unsigned long top;
|
unsigned long top;
|
i = register_offset / 10;
|
i = register_offset / 10;
|
j = register_offset % 10;
|
j = register_offset % 10;
|
soft_fpu = &child->tss.i387.soft;
|
soft_fpu = &child->tss.i387.soft;
|
top = i + (unsigned long) soft_fpu->top;
|
top = i + (unsigned long) soft_fpu->top;
|
control_word = soft_fpu->cwd;
|
control_word = soft_fpu->cwd;
|
this_fpreg = &soft_fpu->regs[(top + i) % 8];
|
this_fpreg = &soft_fpu->regs[(top + i) % 8];
|
next_fpreg = &soft_fpu->regs[(top + i + 1) % 8];
|
next_fpreg = &soft_fpu->regs[(top + i + 1) % 8];
|
softreg_to_hardreg(this_fpreg, hard_reg[0], control_word);
|
softreg_to_hardreg(this_fpreg, hard_reg[0], control_word);
|
if (j > 6)
|
if (j > 6)
|
softreg_to_hardreg(next_fpreg, hard_reg[1], control_word);
|
softreg_to_hardreg(next_fpreg, hard_reg[1], control_word);
|
*(long *) &hard_reg[0][j] = data;
|
*(long *) &hard_reg[0][j] = data;
|
hardreg_to_softreg(hard_reg[0], this_fpreg);
|
hardreg_to_softreg(hard_reg[0], this_fpreg);
|
if (j > 6)
|
if (j > 6)
|
hardreg_to_softreg(hard_reg[1], next_fpreg);
|
hardreg_to_softreg(hard_reg[1], next_fpreg);
|
}
|
}
|
#endif /* defined(CONFIG_MATH_EMULATION) */
|
#endif /* defined(CONFIG_MATH_EMULATION) */
|
|
|
/*
|
/*
|
* Floating point support added to ptrace by Ramon Garcia,
|
* Floating point support added to ptrace by Ramon Garcia,
|
* ramon@juguete.quim.ucm.es
|
* ramon@juguete.quim.ucm.es
|
*/
|
*/
|
|
|
#ifdef CONFIG_MATH_EMULATION
|
#ifdef CONFIG_MATH_EMULATION
|
|
|
static unsigned long get_emulator_word(struct task_struct *child,
|
static unsigned long get_emulator_word(struct task_struct *child,
|
unsigned long register_offset)
|
unsigned long register_offset)
|
{
|
{
|
char hard_reg[2][10];
|
char hard_reg[2][10];
|
int i, j;
|
int i, j;
|
struct fpu_reg *this_fpreg, *next_fpreg;
|
struct fpu_reg *this_fpreg, *next_fpreg;
|
struct i387_soft_struct *soft_fpu;
|
struct i387_soft_struct *soft_fpu;
|
long int control_word;
|
long int control_word;
|
unsigned long top;
|
unsigned long top;
|
unsigned long tmp;
|
unsigned long tmp;
|
i = register_offset / 10;
|
i = register_offset / 10;
|
j = register_offset % 10;
|
j = register_offset % 10;
|
soft_fpu = &child->tss.i387.soft;
|
soft_fpu = &child->tss.i387.soft;
|
top = (unsigned long) soft_fpu->top;
|
top = (unsigned long) soft_fpu->top;
|
this_fpreg = &soft_fpu->regs[(top + i) % 8];
|
this_fpreg = &soft_fpu->regs[(top + i) % 8];
|
next_fpreg = &soft_fpu->regs[(top + i + 1) % 8];
|
next_fpreg = &soft_fpu->regs[(top + i + 1) % 8];
|
control_word = soft_fpu->cwd;
|
control_word = soft_fpu->cwd;
|
softreg_to_hardreg(this_fpreg, hard_reg[0], control_word);
|
softreg_to_hardreg(this_fpreg, hard_reg[0], control_word);
|
if (j > 6)
|
if (j > 6)
|
softreg_to_hardreg(next_fpreg, hard_reg[1], control_word);
|
softreg_to_hardreg(next_fpreg, hard_reg[1], control_word);
|
tmp = *(long *)
|
tmp = *(long *)
|
&hard_reg[0][j];
|
&hard_reg[0][j];
|
return tmp;
|
return tmp;
|
}
|
}
|
|
|
#endif /* defined(CONFIG_MATH_EMULATION) */
|
#endif /* defined(CONFIG_MATH_EMULATION) */
|
|
|
static int putreg(struct task_struct *child,
|
static int putreg(struct task_struct *child,
|
unsigned long regno, unsigned long value)
|
unsigned long regno, unsigned long value)
|
{
|
{
|
switch (regno >> 2) {
|
switch (regno >> 2) {
|
case ORIG_EAX:
|
case ORIG_EAX:
|
return -EIO;
|
return -EIO;
|
case FS:
|
case FS:
|
case GS:
|
case GS:
|
case DS:
|
case DS:
|
case ES:
|
case ES:
|
if (value && (value & 3) != 3)
|
if (value && (value & 3) != 3)
|
return -EIO;
|
return -EIO;
|
value &= 0xffff;
|
value &= 0xffff;
|
break;
|
break;
|
case SS:
|
case SS:
|
case CS:
|
case CS:
|
if ((value & 3) != 3)
|
if ((value & 3) != 3)
|
return -EIO;
|
return -EIO;
|
value &= 0xffff;
|
value &= 0xffff;
|
break;
|
break;
|
case EFL:
|
case EFL:
|
value &= FLAG_MASK;
|
value &= FLAG_MASK;
|
value |= get_stack_long(child, sizeof(long)*EFL-MAGICNUMBER) & ~FLAG_MASK;
|
value |= get_stack_long(child, sizeof(long)*EFL-MAGICNUMBER) & ~FLAG_MASK;
|
}
|
}
|
put_stack_long(child, regno - sizeof(struct pt_regs), value);
|
put_stack_long(child, regno - sizeof(struct pt_regs), value);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
static unsigned long getreg(struct task_struct *child,
|
static unsigned long getreg(struct task_struct *child,
|
unsigned long regno)
|
unsigned long regno)
|
{
|
{
|
unsigned long retval = ~0UL;
|
unsigned long retval = ~0UL;
|
|
|
switch (regno >> 2) {
|
switch (regno >> 2) {
|
case FS:
|
case FS:
|
case GS:
|
case GS:
|
case DS:
|
case DS:
|
case ES:
|
case ES:
|
case SS:
|
case SS:
|
case CS:
|
case CS:
|
retval = 0xffff;
|
retval = 0xffff;
|
/* fall through */
|
/* fall through */
|
default:
|
default:
|
regno = regno - sizeof(struct pt_regs);
|
regno = regno - sizeof(struct pt_regs);
|
retval &= get_stack_long(child, regno);
|
retval &= get_stack_long(child, regno);
|
}
|
}
|
return retval;
|
return retval;
|
}
|
}
|
|
|
asmlinkage int sys_ptrace(long request, long pid, long addr, long data)
|
asmlinkage int sys_ptrace(long request, long pid, long addr, long data)
|
{
|
{
|
struct task_struct *child;
|
struct task_struct *child;
|
struct user * dummy;
|
struct user * dummy;
|
int i;
|
int i;
|
|
|
dummy = NULL;
|
dummy = NULL;
|
|
|
if (request == PTRACE_TRACEME) {
|
if (request == PTRACE_TRACEME) {
|
/* are we already being traced? */
|
/* are we already being traced? */
|
if (current->flags & PF_PTRACED)
|
if (current->flags & PF_PTRACED)
|
return -EPERM;
|
return -EPERM;
|
/* set the ptrace bit in the process flags. */
|
/* set the ptrace bit in the process flags. */
|
current->flags |= PF_PTRACED;
|
current->flags |= PF_PTRACED;
|
return 0;
|
return 0;
|
}
|
}
|
if (pid == 1) /* you may not mess with init */
|
if (pid == 1) /* you may not mess with init */
|
return -EPERM;
|
return -EPERM;
|
if (!(child = get_task(pid)))
|
if (!(child = get_task(pid)))
|
return -ESRCH;
|
return -ESRCH;
|
if (request == PTRACE_ATTACH) {
|
if (request == PTRACE_ATTACH) {
|
if (child == current)
|
if (child == current)
|
return -EPERM;
|
return -EPERM;
|
if ((!child->dumpable ||
|
if ((!child->dumpable ||
|
(current->uid != child->euid) ||
|
(current->uid != child->euid) ||
|
(current->uid != child->suid) ||
|
(current->uid != child->suid) ||
|
(current->uid != child->uid) ||
|
(current->uid != child->uid) ||
|
(current->gid != child->egid) ||
|
(current->gid != child->egid) ||
|
(current->gid != child->sgid) ||
|
(current->gid != child->sgid) ||
|
(current->gid != child->gid)) && !suser())
|
(current->gid != child->gid)) && !suser())
|
return -EPERM;
|
return -EPERM;
|
/* the same process cannot be attached many times */
|
/* the same process cannot be attached many times */
|
if (child->flags & PF_PTRACED)
|
if (child->flags & PF_PTRACED)
|
return -EPERM;
|
return -EPERM;
|
child->flags |= PF_PTRACED;
|
child->flags |= PF_PTRACED;
|
if (child->p_pptr != current) {
|
if (child->p_pptr != current) {
|
REMOVE_LINKS(child);
|
REMOVE_LINKS(child);
|
child->p_pptr = current;
|
child->p_pptr = current;
|
SET_LINKS(child);
|
SET_LINKS(child);
|
}
|
}
|
send_sig(SIGSTOP, child, 1);
|
send_sig(SIGSTOP, child, 1);
|
return 0;
|
return 0;
|
}
|
}
|
if (!(child->flags & PF_PTRACED))
|
if (!(child->flags & PF_PTRACED))
|
return -ESRCH;
|
return -ESRCH;
|
if (child->state != TASK_STOPPED) {
|
if (child->state != TASK_STOPPED) {
|
if (request != PTRACE_KILL)
|
if (request != PTRACE_KILL)
|
return -ESRCH;
|
return -ESRCH;
|
}
|
}
|
if (child->p_pptr != current)
|
if (child->p_pptr != current)
|
return -ESRCH;
|
return -ESRCH;
|
|
|
switch (request) {
|
switch (request) {
|
/* when I and D space are separate, these will need to be fixed. */
|
/* when I and D space are separate, these will need to be fixed. */
|
case PTRACE_PEEKTEXT: /* read word at location addr. */
|
case PTRACE_PEEKTEXT: /* read word at location addr. */
|
case PTRACE_PEEKDATA: {
|
case PTRACE_PEEKDATA: {
|
unsigned long tmp;
|
unsigned long tmp;
|
int res;
|
int res;
|
|
|
res = read_long(child, addr, &tmp);
|
res = read_long(child, addr, &tmp);
|
if (res < 0)
|
if (res < 0)
|
return res;
|
return res;
|
res = verify_area(VERIFY_WRITE, (void *) data, sizeof(long));
|
res = verify_area(VERIFY_WRITE, (void *) data, sizeof(long));
|
if (!res)
|
if (!res)
|
put_fs_long(tmp,(unsigned long *) data);
|
put_fs_long(tmp,(unsigned long *) data);
|
return res;
|
return res;
|
}
|
}
|
|
|
/* read the word at location addr in the USER area. */
|
/* read the word at location addr in the USER area. */
|
case PTRACE_PEEKUSR: {
|
case PTRACE_PEEKUSR: {
|
unsigned long tmp;
|
unsigned long tmp;
|
int res;
|
int res;
|
|
|
if ((addr & 3) || addr < 0
|
if ((addr & 3) || addr < 0
|
|| addr > sizeof(struct user) - 3)
|
|| addr > sizeof(struct user) - 3)
|
return -EIO;
|
return -EIO;
|
|
|
res = verify_area(VERIFY_WRITE, (void *) data, sizeof(long));
|
res = verify_area(VERIFY_WRITE, (void *) data, sizeof(long));
|
if (res)
|
if (res)
|
return res;
|
return res;
|
tmp = 0; /* Default return condition */
|
tmp = 0; /* Default return condition */
|
if(addr < 17*sizeof(long))
|
if(addr < 17*sizeof(long))
|
tmp = getreg(child, addr);
|
tmp = getreg(child, addr);
|
else if(addr >= (long) &dummy->u_debugreg[0]
|
else if(addr >= (long) &dummy->u_debugreg[0]
|
&& addr <= (long) &dummy->u_debugreg[7])
|
&& addr <= (long) &dummy->u_debugreg[7])
|
{
|
{
|
addr -= (long) &dummy->u_debugreg[0];
|
addr -= (long) &dummy->u_debugreg[0];
|
addr = addr >> 2;
|
addr = addr >> 2;
|
tmp = child->debugreg[addr];
|
tmp = child->debugreg[addr];
|
}
|
}
|
put_fs_long(tmp,(unsigned long *) data);
|
put_fs_long(tmp,(unsigned long *) data);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* when I and D space are separate, this will have to be fixed. */
|
/* when I and D space are separate, this will have to be fixed. */
|
case PTRACE_POKETEXT: /* write the word at location addr. */
|
case PTRACE_POKETEXT: /* write the word at location addr. */
|
case PTRACE_POKEDATA:
|
case PTRACE_POKEDATA:
|
return write_long(child,addr,data);
|
return write_long(child,addr,data);
|
|
|
case PTRACE_POKEUSR: /* write the word at location addr in the USER area */
|
case PTRACE_POKEUSR: /* write the word at location addr in the USER area */
|
if ((addr & 3) || addr < 0
|
if ((addr & 3) || addr < 0
|
|| addr > sizeof(struct user) - 3)
|
|| addr > sizeof(struct user) - 3)
|
return -EIO;
|
return -EIO;
|
|
|
if(addr < 17*sizeof(long))
|
if(addr < 17*sizeof(long))
|
return putreg(child, addr, data);
|
return putreg(child, addr, data);
|
|
|
/* We need to be very careful here. We implicitly
|
/* We need to be very careful here. We implicitly
|
want to modify a portion of the task_struct, and we
|
want to modify a portion of the task_struct, and we
|
have to be selective about what portions we allow someone
|
have to be selective about what portions we allow someone
|
to modify. */
|
to modify. */
|
|
|
if(addr >= (long) &dummy->u_debugreg[0] &&
|
if(addr >= (long) &dummy->u_debugreg[0] &&
|
addr <= (long) &dummy->u_debugreg[7]){
|
addr <= (long) &dummy->u_debugreg[7]){
|
|
|
if(addr == (long) &dummy->u_debugreg[4]) return -EIO;
|
if(addr == (long) &dummy->u_debugreg[4]) return -EIO;
|
if(addr == (long) &dummy->u_debugreg[5]) return -EIO;
|
if(addr == (long) &dummy->u_debugreg[5]) return -EIO;
|
if(addr < (long) &dummy->u_debugreg[4] &&
|
if(addr < (long) &dummy->u_debugreg[4] &&
|
((unsigned long) data) >= 0xbffffffd) return -EIO;
|
((unsigned long) data) >= 0xbffffffd) return -EIO;
|
|
|
if(addr == (long) &dummy->u_debugreg[7]) {
|
if(addr == (long) &dummy->u_debugreg[7]) {
|
data &= ~DR_CONTROL_RESERVED;
|
data &= ~DR_CONTROL_RESERVED;
|
for(i=0; i<4; i++)
|
for(i=0; i<4; i++)
|
if ((0x5f54 >> ((data >> (16 + 4*i)) & 0xf)) & 1)
|
if ((0x5f54 >> ((data >> (16 + 4*i)) & 0xf)) & 1)
|
return -EIO;
|
return -EIO;
|
};
|
};
|
|
|
addr -= (long) &dummy->u_debugreg;
|
addr -= (long) &dummy->u_debugreg;
|
addr = addr >> 2;
|
addr = addr >> 2;
|
child->debugreg[addr] = data;
|
child->debugreg[addr] = data;
|
return 0;
|
return 0;
|
};
|
};
|
return -EIO;
|
return -EIO;
|
|
|
case PTRACE_SYSCALL: /* continue and stop at next (return from) syscall */
|
case PTRACE_SYSCALL: /* continue and stop at next (return from) syscall */
|
case PTRACE_CONT: { /* restart after signal. */
|
case PTRACE_CONT: { /* restart after signal. */
|
long tmp;
|
long tmp;
|
|
|
if ((unsigned long) data > NSIG)
|
if ((unsigned long) data > NSIG)
|
return -EIO;
|
return -EIO;
|
if (request == PTRACE_SYSCALL)
|
if (request == PTRACE_SYSCALL)
|
child->flags |= PF_TRACESYS;
|
child->flags |= PF_TRACESYS;
|
else
|
else
|
child->flags &= ~PF_TRACESYS;
|
child->flags &= ~PF_TRACESYS;
|
child->exit_code = data;
|
child->exit_code = data;
|
wake_up_process(child);
|
wake_up_process(child);
|
/* make sure the single step bit is not set. */
|
/* make sure the single step bit is not set. */
|
tmp = get_stack_long(child, sizeof(long)*EFL-MAGICNUMBER) & ~TRAP_FLAG;
|
tmp = get_stack_long(child, sizeof(long)*EFL-MAGICNUMBER) & ~TRAP_FLAG;
|
put_stack_long(child, sizeof(long)*EFL-MAGICNUMBER,tmp);
|
put_stack_long(child, sizeof(long)*EFL-MAGICNUMBER,tmp);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/*
|
/*
|
* make the child exit. Best I can do is send it a sigkill.
|
* 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
|
* perhaps it should be put in the status that it wants to
|
* exit.
|
* exit.
|
*/
|
*/
|
case PTRACE_KILL: {
|
case PTRACE_KILL: {
|
long tmp;
|
long tmp;
|
|
|
if (child->state == TASK_ZOMBIE) /* already dead */
|
if (child->state == TASK_ZOMBIE) /* already dead */
|
return 0;
|
return 0;
|
wake_up_process(child);
|
wake_up_process(child);
|
child->exit_code = SIGKILL;
|
child->exit_code = SIGKILL;
|
/* make sure the single step bit is not set. */
|
/* make sure the single step bit is not set. */
|
tmp = get_stack_long(child, sizeof(long)*EFL-MAGICNUMBER) & ~TRAP_FLAG;
|
tmp = get_stack_long(child, sizeof(long)*EFL-MAGICNUMBER) & ~TRAP_FLAG;
|
put_stack_long(child, sizeof(long)*EFL-MAGICNUMBER,tmp);
|
put_stack_long(child, sizeof(long)*EFL-MAGICNUMBER,tmp);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
case PTRACE_SINGLESTEP: { /* set the trap flag. */
|
case PTRACE_SINGLESTEP: { /* set the trap flag. */
|
long tmp;
|
long tmp;
|
|
|
if ((unsigned long) data > NSIG)
|
if ((unsigned long) data > NSIG)
|
return -EIO;
|
return -EIO;
|
child->flags &= ~PF_TRACESYS;
|
child->flags &= ~PF_TRACESYS;
|
tmp = get_stack_long(child, sizeof(long)*EFL-MAGICNUMBER) | TRAP_FLAG;
|
tmp = get_stack_long(child, sizeof(long)*EFL-MAGICNUMBER) | TRAP_FLAG;
|
put_stack_long(child, sizeof(long)*EFL-MAGICNUMBER,tmp);
|
put_stack_long(child, sizeof(long)*EFL-MAGICNUMBER,tmp);
|
wake_up_process(child);
|
wake_up_process(child);
|
child->exit_code = data;
|
child->exit_code = data;
|
/* give it a chance to run. */
|
/* give it a chance to run. */
|
return 0;
|
return 0;
|
}
|
}
|
|
|
case PTRACE_DETACH: { /* detach a process that was attached. */
|
case PTRACE_DETACH: { /* detach a process that was attached. */
|
long tmp;
|
long tmp;
|
|
|
if ((unsigned long) data > NSIG)
|
if ((unsigned long) data > NSIG)
|
return -EIO;
|
return -EIO;
|
child->flags &= ~(PF_PTRACED|PF_TRACESYS);
|
child->flags &= ~(PF_PTRACED|PF_TRACESYS);
|
wake_up_process(child);
|
wake_up_process(child);
|
child->exit_code = data;
|
child->exit_code = data;
|
REMOVE_LINKS(child);
|
REMOVE_LINKS(child);
|
child->p_pptr = child->p_opptr;
|
child->p_pptr = child->p_opptr;
|
SET_LINKS(child);
|
SET_LINKS(child);
|
/* make sure the single step bit is not set. */
|
/* make sure the single step bit is not set. */
|
tmp = get_stack_long(child, sizeof(long)*EFL-MAGICNUMBER) & ~TRAP_FLAG;
|
tmp = get_stack_long(child, sizeof(long)*EFL-MAGICNUMBER) & ~TRAP_FLAG;
|
put_stack_long(child, sizeof(long)*EFL-MAGICNUMBER,tmp);
|
put_stack_long(child, sizeof(long)*EFL-MAGICNUMBER,tmp);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
case PTRACE_GETREGS: { /* Get all gp regs from the child. */
|
case PTRACE_GETREGS: { /* Get all gp regs from the child. */
|
#ifdef CONFIG_MATH_EMULATION
|
#ifdef CONFIG_MATH_EMULATION
|
if (!hard_math)
|
if (!hard_math)
|
/* Not supported. */
|
/* Not supported. */
|
return -EIO;
|
return -EIO;
|
#endif
|
#endif
|
|
|
if (verify_area(VERIFY_WRITE, (void *) data,
|
if (verify_area(VERIFY_WRITE, (void *) data,
|
17*sizeof(long)))
|
17*sizeof(long)))
|
return -EIO;
|
return -EIO;
|
for (i = 0; i < 17*sizeof(long);
|
for (i = 0; i < 17*sizeof(long);
|
i += sizeof(long), data += sizeof(long))
|
i += sizeof(long), data += sizeof(long))
|
put_fs_long (getreg(child, i), (unsigned long *) data);
|
put_fs_long (getreg(child, i), (unsigned long *) data);
|
return 0;
|
return 0;
|
};
|
};
|
|
|
case PTRACE_SETREGS: { /* Set all gp regs in the child. */
|
case PTRACE_SETREGS: { /* Set all gp regs in the child. */
|
unsigned long tmp;
|
unsigned long tmp;
|
|
|
#ifdef CONFIG_MATH_EMULATION
|
#ifdef CONFIG_MATH_EMULATION
|
if (!hard_math)
|
if (!hard_math)
|
/* Not supported. */
|
/* Not supported. */
|
return -EIO;
|
return -EIO;
|
#endif
|
#endif
|
|
|
if (verify_area(VERIFY_READ, (void *) data,
|
if (verify_area(VERIFY_READ, (void *) data,
|
17*sizeof(long)))
|
17*sizeof(long)))
|
return -EIO;
|
return -EIO;
|
for (i = 0; i < 17*sizeof(long);
|
for (i = 0; i < 17*sizeof(long);
|
i += sizeof(long), data += sizeof(long))
|
i += sizeof(long), data += sizeof(long))
|
{
|
{
|
tmp = get_fs_long ((unsigned long *) data);
|
tmp = get_fs_long ((unsigned long *) data);
|
putreg(child, i, tmp);
|
putreg(child, i, tmp);
|
}
|
}
|
return 0;
|
return 0;
|
};
|
};
|
|
|
case PTRACE_GETFPREGS: { /* Get the child FPU state. */
|
case PTRACE_GETFPREGS: { /* Get the child FPU state. */
|
unsigned long *tmp;
|
unsigned long *tmp;
|
|
|
#ifdef CONFIG_MATH_EMULATION
|
#ifdef CONFIG_MATH_EMULATION
|
if (!hard_math)
|
if (!hard_math)
|
/* Not supported. */
|
/* Not supported. */
|
return -EIO;
|
return -EIO;
|
#endif
|
#endif
|
|
|
if (verify_area(VERIFY_WRITE, (void *) data,
|
if (verify_area(VERIFY_WRITE, (void *) data,
|
sizeof(struct user_i387_struct)))
|
sizeof(struct user_i387_struct)))
|
return -EIO;
|
return -EIO;
|
if ( !child->used_math ) {
|
if ( !child->used_math ) {
|
/* Simulate an empty FPU. */
|
/* Simulate an empty FPU. */
|
child->tss.i387.hard.cwd = 0xffff037f;
|
child->tss.i387.hard.cwd = 0xffff037f;
|
child->tss.i387.hard.swd = 0xffff0000;
|
child->tss.i387.hard.swd = 0xffff0000;
|
child->tss.i387.hard.twd = 0xffffffff;
|
child->tss.i387.hard.twd = 0xffffffff;
|
}
|
}
|
if (last_task_used_math == child)
|
if (last_task_used_math == child)
|
{
|
{
|
clts();
|
clts();
|
__asm__("fnsave %0; fwait":"=m" (child->tss.i387.hard));
|
__asm__("fnsave %0; fwait":"=m" (child->tss.i387.hard));
|
last_task_used_math = NULL;
|
last_task_used_math = NULL;
|
stts();
|
stts();
|
}
|
}
|
tmp = (unsigned long *) &child->tss.i387.hard;
|
tmp = (unsigned long *) &child->tss.i387.hard;
|
for ( i = 0; i < sizeof(struct user_i387_struct); i += sizeof(long) )
|
for ( i = 0; i < sizeof(struct user_i387_struct); i += sizeof(long) )
|
{
|
{
|
put_fs_long (*tmp, (unsigned long *) data);
|
put_fs_long (*tmp, (unsigned long *) data);
|
data += sizeof(long);
|
data += sizeof(long);
|
tmp++;
|
tmp++;
|
}
|
}
|
|
|
return 0;
|
return 0;
|
};
|
};
|
|
|
case PTRACE_SETFPREGS: { /* Set the child FPU state. */
|
case PTRACE_SETFPREGS: { /* Set the child FPU state. */
|
unsigned long *tmp;
|
unsigned long *tmp;
|
|
|
#ifdef CONFIG_MATH_EMULATION
|
#ifdef CONFIG_MATH_EMULATION
|
if (!hard_math)
|
if (!hard_math)
|
/* Not supported. */
|
/* Not supported. */
|
return -EIO;
|
return -EIO;
|
#endif
|
#endif
|
|
|
if (verify_area(VERIFY_READ, (void *) data,
|
if (verify_area(VERIFY_READ, (void *) data,
|
sizeof(struct user_i387_struct)))
|
sizeof(struct user_i387_struct)))
|
return -EIO;
|
return -EIO;
|
child->used_math = 1;
|
child->used_math = 1;
|
if (last_task_used_math == child)
|
if (last_task_used_math == child)
|
{
|
{
|
/* Discard the state of the FPU */
|
/* Discard the state of the FPU */
|
last_task_used_math = NULL;
|
last_task_used_math = NULL;
|
}
|
}
|
tmp = (unsigned long *) &child->tss.i387.hard;
|
tmp = (unsigned long *) &child->tss.i387.hard;
|
for ( i = 0; i < sizeof(struct user_i387_struct); i += sizeof(long) )
|
for ( i = 0; i < sizeof(struct user_i387_struct); i += sizeof(long) )
|
{
|
{
|
*tmp = get_fs_long ((unsigned long *) data);
|
*tmp = get_fs_long ((unsigned long *) data);
|
data += sizeof(long);
|
data += sizeof(long);
|
tmp++;
|
tmp++;
|
}
|
}
|
child->flags &= ~PF_USEDFPU;
|
child->flags &= ~PF_USEDFPU;
|
return 0;
|
return 0;
|
};
|
};
|
|
|
default:
|
default:
|
return -EIO;
|
return -EIO;
|
}
|
}
|
}
|
}
|
|
|
asmlinkage void syscall_trace(void)
|
asmlinkage void syscall_trace(void)
|
{
|
{
|
if ((current->flags & (PF_PTRACED|PF_TRACESYS))
|
if ((current->flags & (PF_PTRACED|PF_TRACESYS))
|
!= (PF_PTRACED|PF_TRACESYS))
|
!= (PF_PTRACED|PF_TRACESYS))
|
return;
|
return;
|
current->exit_code = SIGTRAP;
|
current->exit_code = SIGTRAP;
|
current->state = TASK_STOPPED;
|
current->state = TASK_STOPPED;
|
notify_parent(current, SIGCHLD);
|
notify_parent(current, SIGCHLD);
|
schedule();
|
schedule();
|
/*
|
/*
|
* this isn't the same as continuing with a signal, but it will do
|
* 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
|
* for normal use. strace only continues with a signal if the
|
* stopping signal is not SIGTRAP. -brl
|
* stopping signal is not SIGTRAP. -brl
|
*/
|
*/
|
if (current->exit_code)
|
if (current->exit_code)
|
current->signal |= (1 << (current->exit_code - 1));
|
current->signal |= (1 << (current->exit_code - 1));
|
current->exit_code = 0;
|
current->exit_code = 0;
|
}
|
}
|
|
|
void get_pt_regs_for_task(struct pt_regs *regs, struct task_struct *task)
|
void get_pt_regs_for_task(struct pt_regs *regs, struct task_struct *task)
|
{
|
{
|
*regs = *(struct pt_regs *) (((unsigned char *) task->tss.esp0) - MAGICNUMBER);
|
*regs = *(struct pt_regs *) (((unsigned char *) task->tss.esp0) - MAGICNUMBER);
|
}
|
}
|
|
|
|
|
