URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [arch/] [s390x/] [kernel/] [ptrace.c] - Blame information for rev 1765

Details | Compare with Previous | View Log


/*
 *  arch/s390/kernel/ptrace.c
 *
 *  S390 version
 *    Copyright (C) 1999,2000 IBM Deutschland Entwicklung GmbH, IBM Corporation
 *    Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com),
 *
 *  Based on PowerPC version
 *    Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
 *
 *  Derived from "arch/m68k/kernel/ptrace.c"
 *  Copyright (C) 1994 by Hamish Macdonald
 *  Taken from linux/kernel/ptrace.c and modified for M680x0.
 *  linux/kernel/ptrace.c is by Ross Biro 1/23/92, edited by Linus Torvalds
 *
 * Modified by Cort Dougan (cort@cs.nmt.edu)
 *
 *
 * This file is subject to the terms and conditions of the GNU General
 * Public License.  See the file README.legal in the main directory of
 * this archive for more details.
 */
 
#include <stddef.h>
#include <linux/config.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/mm.h>
#include <linux/smp.h>
#include <linux/smp_lock.h>
#include <linux/errno.h>
#include <linux/ptrace.h>
#include <linux/user.h>
 
#include <asm/segment.h>
#include <asm/page.h>
#include <asm/pgtable.h>
#include <asm/pgalloc.h>
#include <asm/system.h>
#include <asm/uaccess.h>
#ifdef CONFIG_S390_SUPPORT
#include "linux32.h"
#else
#define parent_31bit 0
#endif
 
 
void FixPerRegisters(struct task_struct *task)
{
        struct pt_regs *regs = __KSTK_PTREGS(task);
        per_struct *per_info=
                        (per_struct *)&task->thread.per_info;
 
        per_info->control_regs.bits.em_instruction_fetch =
                per_info->single_step | per_info->instruction_fetch;
 
        if (per_info->single_step) {
                per_info->control_regs.bits.starting_addr=0;
#ifdef CONFIG_S390_SUPPORT
                if (current->thread.flags & S390_FLAG_31BIT) {
                        per_info->control_regs.bits.ending_addr=0x7fffffffUL;
                }
                else
#endif      
                {
                per_info->control_regs.bits.ending_addr=-1L;
                }
        } else {
                per_info->control_regs.bits.starting_addr=
                        per_info->starting_addr;
                per_info->control_regs.bits.ending_addr=
                        per_info->ending_addr;
        }
        /* if any of the control reg tracing bits are on
           we switch on per in the psw */
        if (per_info->control_regs.words.cr[0] & PER_EM_MASK)
                regs->psw.mask |= PSW_PER_MASK;
        else
                regs->psw.mask &= ~PSW_PER_MASK;
        if (per_info->control_regs.bits.storage_alt_space_ctl)
                task->thread.user_seg |= USER_STD_MASK;
        else
                task->thread.user_seg &= ~USER_STD_MASK;
}
 
void set_single_step(struct task_struct *task)
{
        per_struct *per_info= (per_struct *) &task->thread.per_info;
 
        per_info->single_step = 1;  /* Single step */
        FixPerRegisters (task);
}
 
void clear_single_step(struct task_struct *task)
{
        per_struct *per_info= (per_struct *) &task->thread.per_info;
 
        per_info->single_step = 0;
        FixPerRegisters (task);
}
 
int ptrace_usercopy(addr_t realuseraddr, addr_t copyaddr, int len,
                    int tofromuser, int writeuser, unsigned long mask)
{
        unsigned long *realuserptr, *copyptr;
        unsigned long tempuser;
        int retval;
 
        retval = 0;
        realuserptr = (unsigned long *) realuseraddr;
        copyptr = (unsigned long *) copyaddr;
 
        if (writeuser && realuserptr == NULL)
                return 0;
 
        if (mask != -1L) {
                tempuser = *realuserptr;
                if (!writeuser) {
                        tempuser &= mask;
                        realuserptr = &tempuser;
                }
        }
        if (tofromuser) {
                if (writeuser) {
                        retval = copy_from_user(realuserptr, copyptr, len);
                } else {
                        if (realuserptr == NULL)
                                retval = clear_user(copyptr, len);
                        else
                                retval = copy_to_user(copyptr,realuserptr,len);
                }
                retval = retval ? -EFAULT : 0;
        } else {
                if (writeuser)
                        memcpy(realuserptr, copyptr, len);
                else
                        memcpy(copyptr, realuserptr, len);
        }
        if (mask != -1L && writeuser)
                *realuserptr = (*realuserptr & mask) | (tempuser & ~mask);
        return retval;
}
 
#ifdef CONFIG_S390_SUPPORT
 
typedef struct
{
        __u32 cr[3];
} per_cr_words32  __attribute__((packed));
 
typedef struct
{
        __u16          perc_atmid;          /* 0x096 */
        __u32          address;             /* 0x098 */
        __u8           access_id;           /* 0x0a1 */
} per_lowcore_words32  __attribute__((packed));
 
typedef struct
{
        union {
                per_cr_words32   words;
        } control_regs  __attribute__((packed));
        /*
         * Use these flags instead of setting em_instruction_fetch
         * directly they are used so that single stepping can be
         * switched on & off while not affecting other tracing
         */
        unsigned  single_step       : 1;
        unsigned  instruction_fetch : 1;
        unsigned                    : 30;
        /*
         * These addresses are copied into cr10 & cr11 if single
         * stepping is switched off
         */
        __u32     starting_addr;
        __u32     ending_addr;
        union {
                per_lowcore_words32 words;
        } lowcore;
} per_struct32 __attribute__((packed));
 
struct user_regs_struct32
{
        _psw_t32 psw;
        u32 gprs[NUM_GPRS];
        u32 acrs[NUM_ACRS];
        u32 orig_gpr2;
        s390_fp_regs fp_regs;
        /*
         * These per registers are in here so that gdb can modify them
         * itself as there is no "official" ptrace interface for hardware
         * watchpoints. This is the way intel does it.
         */
        per_struct32 per_info;
        u32  ieee_instruction_pointer;
        /* Used to give failing instruction back to user for ieee exceptions */
};
 
struct user32 {
                                  /* We start with the registers, to mimic the way that "memory" is returned
                                   from the ptrace(3,...) function.  */
  struct user_regs_struct32 regs; /* Where the registers are actually stored */
                                  /* The rest of this junk is to help gdb figure out what goes where */
  u32 u_tsize;                    /* Text segment size (pages). */
  u32 u_dsize;                    /* Data segment size (pages). */
  u32 u_ssize;                    /* Stack segment size (pages). */
  u32 start_code;                 /* Starting virtual address of text. */
  u32 start_stack;                /* Starting virtual address of stack area.
                                   This is actually the bottom of the stack,
                                   the top of the stack is always found in the
                                   esp register.  */
  s32 signal;                     /* Signal that caused the core dump. */
  u32 u_ar0;                      /* Used by gdb to help find the values for */
                                  /* the registers. */
  u32 magic;                      /* To uniquely identify a core file */
  char u_comm[32];                /* User command that was responsible */
};
 
 
#define PT32_PSWMASK  0x0
#define PT32_PSWADDR  0x04
#define PT32_GPR0     0x08
#define PT32_GPR15    0x44
#define PT32_ACR0     0x48
#define PT32_ACR15    0x84
#define PT32_ORIGGPR2 0x88
#define PT32_FPC      0x90
#define PT32_FPR0_HI  0x98
#define PT32_FPR15_LO 0x114
#define PT32_CR_9     0x118
#define PT32_CR_11    0x120
#define PT32_IEEE_IP  0x13C
#define PT32_LASTOFF  PT32_IEEE_IP
#define PT32_ENDREGS  0x140-1
#define U32OFFSETOF(member) offsetof(struct user32,regs.member)
#define U64OFFSETOF(member) offsetof(struct user,regs.member)
#define U6432DIFF(member) (U64OFFSETOF(member) - U32OFFSETOF(member))
#define PT_SINGLE_STEP   (PT_CR_11+8)
#define PT32_SINGLE_STEP (PT32_CR_11+4)
 
#endif /* CONFIG_S390_SUPPORT */
 
int copy_user(struct task_struct *task,saddr_t useraddr, addr_t copyaddr,
              int len, int tofromuser, int writingtouser)
{
        int copylen=0,copymax;
        addr_t  realuseraddr;
        saddr_t enduseraddr;
        unsigned long mask;
#ifdef CONFIG_S390_SUPPORT
        int     parent_31bit=current->thread.flags & S390_FLAG_31BIT;
        int     skip;
#endif
        enduseraddr=useraddr+len;
        if ((useraddr<0||useraddr&3||enduseraddr&3)||
#ifdef CONFIG_S390_SUPPORT
            (parent_31bit && enduseraddr > sizeof(struct user32)) ||
#endif
            enduseraddr > sizeof(struct user))
                return (-EIO);
 
#ifdef CONFIG_S390_SUPPORT
        if(parent_31bit)
        {
                if(useraddr != PT32_PSWMASK)
                {
                        if (useraddr == PT32_PSWADDR)
                                useraddr = PT_PSWADDR+4;
                        else if(useraddr <= PT32_GPR15)
                                useraddr = ((useraddr-PT32_GPR0)*2) + PT_GPR0+4;
                        else if(useraddr <= PT32_ACR15)
                                useraddr += PT_ACR0-PT32_ACR0;
                        else if(useraddr == PT32_ORIGGPR2)
                                useraddr = PT_ORIGGPR2+4;
                        else if(useraddr <= PT32_FPR15_LO)
                                useraddr += PT_FPR0-PT32_FPR0_HI;
                        else if(useraddr <= PT32_CR_11)
                                useraddr = ((useraddr-PT32_CR_9)*2) + PT_CR_9+4;
                        else if(useraddr ==  PT32_SINGLE_STEP)
                                useraddr = PT_SINGLE_STEP;
                        else if(useraddr <= U32OFFSETOF(per_info.ending_addr))
                                useraddr = (((useraddr-U32OFFSETOF(per_info.starting_addr)))*2) +
                                        U64OFFSETOF(per_info.starting_addr)+4;
                        else if( useraddr == U32OFFSETOF(per_info.lowcore.words.perc_atmid))
                                useraddr = U64OFFSETOF(per_info.lowcore.words.perc_atmid);
                        else if( useraddr == U32OFFSETOF(per_info.lowcore.words.address))
                                useraddr = U64OFFSETOF(per_info.lowcore.words.address)+4;
                        else if(useraddr == U32OFFSETOF(per_info.lowcore.words.access_id))
                                useraddr = U64OFFSETOF(per_info.lowcore.words.access_id);
                        else if(useraddr == PT32_IEEE_IP)
                                useraddr = PT_IEEE_IP+4;
                }
        }
#endif /* CONFIG_S390_SUPPORT */
 
        while(len>0)
        {
#ifdef CONFIG_S390_SUPPORT
                skip=0;
#endif
                mask=PSW_ADDR_MASK;
                if(useraddr<PT_FPC)
                {
                        realuseraddr=((addr_t) __KSTK_PTREGS(task)) + useraddr;
                        if(useraddr<(PT_PSWMASK+8))
                        {
                                if(parent_31bit)
                                {
                                        copymax=PT_PSWMASK+4;
#ifdef CONFIG_S390_SUPPORT
                                        skip=8;
#endif
                                }
                                else
                                {
                                        copymax=PT_PSWMASK+8;
                                }
                                if(writingtouser)
                                        mask=PSW_MASK_DEBUGCHANGE;
                        }
                        else if(useraddr<(PT_PSWADDR+8))
                        {
                                copymax=PT_PSWADDR+8;
                                mask=PSW_ADDR_DEBUGCHANGE;
#ifdef CONFIG_S390_SUPPORT
                                if(parent_31bit)
                                        skip=4;
#endif
 
                        }
                        else
                        {
#ifdef CONFIG_S390_SUPPORT
                                if(parent_31bit && useraddr <= PT_GPR15+4)
                                {
                                        copymax=useraddr+4;
                                        if(useraddr<PT_GPR15+4)
                                                skip=4;
                                }
                                else
#endif
                                        copymax=PT_FPC;
                        }
                }
                else if(useraddr<(PT_FPR15+sizeof(freg_t)))
                {
                        copymax=(PT_FPR15+sizeof(freg_t));
                        realuseraddr=(addr_t)&(((u8 *)&task->thread.fp_regs)[useraddr-PT_FPC]);
                }
                else if(useraddr<sizeof(struct user_regs_struct))
                {
#ifdef CONFIG_S390_SUPPORT
                        if( parent_31bit && useraddr <= PT_IEEE_IP+4)
                        {
                                switch(useraddr)
                                {
                                case PT_CR_11+4:
                                case U64OFFSETOF(per_info.ending_addr)+4:
                                case U64OFFSETOF(per_info.lowcore.words.address)+4:
                                        copymax=useraddr+4;
                                        break;
                                case  PT_SINGLE_STEP:
                                case  U64OFFSETOF(per_info.lowcore.words.perc_atmid):
                                        /* We copy 2 bytes in excess for the atmid member this also gets around */
                                        /* alignment for this member in 32 bit */
                                        skip=8;
                                        copymax=useraddr+4;
                                        break;
                                default:
                                        copymax=useraddr+4;
                                        skip=4;
                                }
                        }
                        else
#endif
                        {
                                copymax=sizeof(struct user_regs_struct);
                        }
                        realuseraddr=(addr_t)&(((u8 *)&task->thread.per_info)[useraddr-PT_CR_9]);
                }
                else
                {
                        copymax=sizeof(struct user);
                        realuseraddr=(addr_t)NULL;
                }
                copylen=copymax-useraddr;
                copylen=(copylen>len ? len:copylen);
                if(ptrace_usercopy(realuseraddr,copyaddr,copylen,tofromuser,writingtouser,mask))
                        return (-EIO);
                copyaddr+=copylen;
                len-=copylen;
                useraddr+=copylen
#if CONFIG_S390_SUPPORT
                        +skip
#endif
                        ;
        }
        FixPerRegisters(task);
        return(0);
}
 
/*
 * Called by kernel/ptrace.c when detaching..
 *
 * Make sure single step bits etc are not set.
 */
void ptrace_disable(struct task_struct *child)
{
        /* make sure the single step bit is not set. */
        clear_single_step(child);
}
 
typedef struct
{
__u32   len;
__u32   kernel_addr;
__u32   process_addr;
} ptrace_area_emu31;
 
 
asmlinkage int sys_ptrace(long request, long pid, long addr, long data)
{
        struct task_struct *child;
        int ret = -EPERM;
        int copied;
#ifdef CONFIG_S390_SUPPORT
        int           parent_31bit;
        int           sizeof_parent_long;
        u8            *dataptr;
#else
#define sizeof_parent_long 8
#define dataptr (u8 *)&data
#endif
        lock_kernel();
        if (request == PTRACE_TRACEME)
        {
                /* are we already being traced? */
                if (current->ptrace & PT_PTRACED)
                        goto out;
                /* set the ptrace bit in the process flags. */
                current->ptrace |= PT_PTRACED;
                ret = 0;
                goto out;
        }
        ret = -ESRCH;
        read_lock(&tasklist_lock);
        child = find_task_by_pid(pid);
        if (child)
                get_task_struct(child);
        read_unlock(&tasklist_lock);
        if (!child)
                goto out;
        ret = -EPERM;
        if (pid == 1)           /* you may not mess with init */
                goto out_tsk;
        if (request == PTRACE_ATTACH)
        {
                ret = ptrace_attach(child);
                goto out_tsk;
        }
        ret = -ESRCH;
        // printk("child=%lX child->flags=%lX",child,child->flags);
        /* I added child!=current line so we can get the */
        /* ieee_instruction_pointer from the user structure DJB */
        if(child!=current)
        {
                if (!(child->ptrace & PT_PTRACED))
                        goto out_tsk;
                if (child->state != TASK_STOPPED)
                {
                        if (request != PTRACE_KILL)
                                goto out_tsk;
                }
                if (child->p_pptr != current)
                        goto out_tsk;
        }
#ifdef CONFIG_S390_SUPPORT
        parent_31bit=(current->thread.flags & S390_FLAG_31BIT);
        sizeof_parent_long=(parent_31bit ? 4:8);
        dataptr=&(((u8 *)&data)[parent_31bit ? 4:0]);
#endif
        switch (request)
        {
                /* If I and D space are separate, these will need to be fixed. */
        case PTRACE_PEEKTEXT: /* read word at location addr. */
        case PTRACE_PEEKDATA:
        {
                u8 tmp[8];
                copied = access_process_vm(child, addr, tmp, sizeof_parent_long, 0);
                ret = -EIO;
                if (copied != sizeof_parent_long)
                        break;
                ret = copy_to_user((void *)data,tmp,sizeof_parent_long);
                ret = ret ? -EFAULT : 0;
                break;
 
        }
                /* read the word at location addr in the USER area. */
        case PTRACE_PEEKUSR:
                ret=copy_user(child,addr,data,sizeof_parent_long,1,0);
                break;
 
                /* If I and D space are separate, this will have to be fixed. */
        case PTRACE_POKETEXT: /* write the word at location addr. */
        case PTRACE_POKEDATA:
                ret = 0;
                if (access_process_vm(child, addr,dataptr, sizeof_parent_long, 1) == sizeof_parent_long)
                        break;
                ret = -EIO;
                break;
 
        case PTRACE_POKEUSR: /* write the word at location addr in the USER area */
                ret=copy_user(child,addr,(addr_t)dataptr,sizeof_parent_long,0,1);
                break;
 
        case PTRACE_SYSCALL:    /* continue and stop at next (return from) syscall */
        case PTRACE_CONT:        /* restart after signal. */
                ret = -EIO;
                if ((unsigned long) data >= _NSIG)
                        break;
                if (request == PTRACE_SYSCALL)
                        child->ptrace |= PT_TRACESYS;
                else
                        child->ptrace &= ~PT_TRACESYS;
                child->exit_code = data;
                /* make sure the single step bit is not set. */
                clear_single_step(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->state == TASK_ZOMBIE) /* already dead */
                        break;
                child->exit_code = SIGKILL;
                clear_single_step(child);
                wake_up_process(child);
                /* make sure the single step bit is not set. */
                break;
 
        case PTRACE_SINGLESTEP:  /* set the trap flag. */
                ret = -EIO;
                if ((unsigned long) data >= _NSIG)
                        break;
                child->ptrace &= ~PT_TRACESYS;
                child->exit_code = data;
                set_single_step(child);
                /* 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_PEEKUSR_AREA:
        case PTRACE_POKEUSR_AREA:
                if(parent_31bit)
                {
                        ptrace_area_emu31   parea;
                        if(copy_from_user(&parea,(void *)addr,sizeof(parea))==0)
                                ret=copy_user(child,parea.kernel_addr,parea.process_addr,
                                              parea.len,1,(request==PTRACE_POKEUSR_AREA));
                        else ret = -EFAULT;
                }
                else
                {
                        ptrace_area   parea;
                        if(copy_from_user(&parea,(void *)addr,sizeof(parea))==0)
                                ret=copy_user(child,parea.kernel_addr,parea.process_addr,
                                              parea.len,1,(request==PTRACE_POKEUSR_AREA));
                        else ret = -EFAULT;
                }
                break;
        default:
                ret = -EIO;
                break;
        }
 out_tsk:
        free_task_struct(child);
 out:
        unlock_kernel();
        return ret;
}
 
 
 
asmlinkage void syscall_trace(void)
{
        lock_kernel();
        if ((current->ptrace & (PT_PTRACED|PT_TRACESYS))
            != (PT_PTRACED|PT_TRACESYS))
                goto out;
        current->exit_code = SIGTRAP;
        set_current_state(TASK_STOPPED);
        notify_parent(current, SIGCHLD);
        schedule();
        /*
         * 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;
        }
 out:
        unlock_kernel();
}

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [arch/] [s390x/] [kernel/] [ptrace.c] - Blame information for rev 1765

Line No.	Rev	Author	Line
1	1275	phoenix	`/*`
2			`* arch/s390/kernel/ptrace.c`
3			`*`
4			`* S390 version`
5			`* Copyright (C) 1999,2000 IBM Deutschland Entwicklung GmbH, IBM Corporation`
6			`* Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com),`
7			`*`
8			`* Based on PowerPC version`
9			`* Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)`
10			`*`
11			`* Derived from "arch/m68k/kernel/ptrace.c"`
12			`* Copyright (C) 1994 by Hamish Macdonald`
13			`* Taken from linux/kernel/ptrace.c and modified for M680x0.`
14			`* linux/kernel/ptrace.c is by Ross Biro 1/23/92, edited by Linus Torvalds`
15			`*`
16			`* Modified by Cort Dougan (cort@cs.nmt.edu)`
17			`*`
18			`*`
19			`* This file is subject to the terms and conditions of the GNU General`
20			`* Public License. See the file README.legal in the main directory of`
21			`* this archive for more details.`
22			`*/`
23
24			`#include <stddef.h>`
25			`#include <linux/config.h>`
26			`#include <linux/kernel.h>`
27			`#include <linux/sched.h>`
28			`#include <linux/mm.h>`
29			`#include <linux/smp.h>`
30			`#include <linux/smp_lock.h>`
31			`#include <linux/errno.h>`
32			`#include <linux/ptrace.h>`
33			`#include <linux/user.h>`
34
35			`#include <asm/segment.h>`
36			`#include <asm/page.h>`
37			`#include <asm/pgtable.h>`
38			`#include <asm/pgalloc.h>`
39			`#include <asm/system.h>`
40			`#include <asm/uaccess.h>`
41			`#ifdef CONFIG_S390_SUPPORT`
42			`#include "linux32.h"`
43			`#else`
44			`#define parent_31bit 0`
45			`#endif`
46
47
48			`void FixPerRegisters(struct task_struct *task)`
49			`{`
50			`struct pt_regs *regs = __KSTK_PTREGS(task);`
51			`per_struct *per_info=`
52			`(per_struct *)&task->thread.per_info;`
53
54			`per_info->control_regs.bits.em_instruction_fetch =`
55			`per_info->single_step \| per_info->instruction_fetch;`
56
57			`if (per_info->single_step) {`
58			`per_info->control_regs.bits.starting_addr=0;`
59			`#ifdef CONFIG_S390_SUPPORT`
60			`if (current->thread.flags & S390_FLAG_31BIT) {`
61			`per_info->control_regs.bits.ending_addr=0x7fffffffUL;`
62			`}`
63			`else`
64			`#endif`
65			`{`
66			`per_info->control_regs.bits.ending_addr=-1L;`
67			`}`
68			`} else {`
69			`per_info->control_regs.bits.starting_addr=`
70			`per_info->starting_addr;`
71			`per_info->control_regs.bits.ending_addr=`
72			`per_info->ending_addr;`
73			`}`
74			`/* if any of the control reg tracing bits are on`
75			`we switch on per in the psw */`
76			`if (per_info->control_regs.words.cr[0] & PER_EM_MASK)`
77			`regs->psw.mask \|= PSW_PER_MASK;`
78			`else`
79			`regs->psw.mask &= ~PSW_PER_MASK;`
80			`if (per_info->control_regs.bits.storage_alt_space_ctl)`
81			`task->thread.user_seg \|= USER_STD_MASK;`
82			`else`
83			`task->thread.user_seg &= ~USER_STD_MASK;`
84			`}`
85
86			`void set_single_step(struct task_struct *task)`
87			`{`
88			`per_struct per_info= (per_struct ) &task->thread.per_info;`
89
90			`per_info->single_step = 1; /* Single step */`
91			`FixPerRegisters (task);`
92			`}`
93
94			`void clear_single_step(struct task_struct *task)`
95			`{`
96			`per_struct per_info= (per_struct ) &task->thread.per_info;`
97
98			`per_info->single_step = 0;`
99			`FixPerRegisters (task);`
100			`}`
101
102			`int ptrace_usercopy(addr_t realuseraddr, addr_t copyaddr, int len,`
103			`int tofromuser, int writeuser, unsigned long mask)`
104			`{`
105			`unsigned long realuserptr, copyptr;`
106			`unsigned long tempuser;`
107			`int retval;`
108
109			`retval = 0;`
110			`realuserptr = (unsigned long *) realuseraddr;`
111			`copyptr = (unsigned long *) copyaddr;`
112
113			`if (writeuser && realuserptr == NULL)`
114			`return 0;`
115
116			`if (mask != -1L) {`
117			`tempuser = *realuserptr;`
118			`if (!writeuser) {`
119			`tempuser &= mask;`
120			`realuserptr = &tempuser;`
121			`}`
122			`}`
123			`if (tofromuser) {`
124			`if (writeuser) {`
125			`retval = copy_from_user(realuserptr, copyptr, len);`
126			`} else {`
127			`if (realuserptr == NULL)`
128			`retval = clear_user(copyptr, len);`
129			`else`
130			`retval = copy_to_user(copyptr,realuserptr,len);`
131			`}`
132			`retval = retval ? -EFAULT : 0;`
133			`} else {`
134			`if (writeuser)`
135			`memcpy(realuserptr, copyptr, len);`
136			`else`
137			`memcpy(copyptr, realuserptr, len);`
138			`}`
139			`if (mask != -1L && writeuser)`
140			`realuserptr = (realuserptr & mask) \| (tempuser & ~mask);`
141			`return retval;`
142			`}`
143
144			`#ifdef CONFIG_S390_SUPPORT`
145
146			`typedef struct`
147			`{`
148			`__u32 cr[3];`
149			`} per_cr_words32 __attribute__((packed));`
150
151			`typedef struct`
152			`{`
153			`__u16 perc_atmid; /* 0x096 */`
154			`__u32 address; /* 0x098 */`
155			`__u8 access_id; /* 0x0a1 */`
156			`} per_lowcore_words32 __attribute__((packed));`
157
158			`typedef struct`
159			`{`
160			`union {`
161			`per_cr_words32 words;`
162			`} control_regs __attribute__((packed));`
163			`/*`
164			`* Use these flags instead of setting em_instruction_fetch`
165			`* directly they are used so that single stepping can be`
166			`* switched on & off while not affecting other tracing`
167			`*/`
168			`unsigned single_step : 1;`
169			`unsigned instruction_fetch : 1;`
170			`unsigned : 30;`
171			`/*`
172			`* These addresses are copied into cr10 & cr11 if single`
173			`* stepping is switched off`
174			`*/`
175			`__u32 starting_addr;`
176			`__u32 ending_addr;`
177			`union {`
178			`per_lowcore_words32 words;`
179			`} lowcore;`
180			`} per_struct32 __attribute__((packed));`
181
182			`struct user_regs_struct32`
183			`{`
184			`_psw_t32 psw;`
185			`u32 gprs[NUM_GPRS];`
186			`u32 acrs[NUM_ACRS];`
187			`u32 orig_gpr2;`
188			`s390_fp_regs fp_regs;`
189			`/*`
190			`* These per registers are in here so that gdb can modify them`
191			`* itself as there is no "official" ptrace interface for hardware`
192			`* watchpoints. This is the way intel does it.`
193			`*/`
194			`per_struct32 per_info;`
195			`u32 ieee_instruction_pointer;`
196			`/* Used to give failing instruction back to user for ieee exceptions */`
197			`};`
198
199			`struct user32 {`
200			`/* We start with the registers, to mimic the way that "memory" is returned`
201			`from the ptrace(3,...) function. */`
202			`struct user_regs_struct32 regs; /* Where the registers are actually stored */`
203			`/* The rest of this junk is to help gdb figure out what goes where */`
204			`u32 u_tsize; /* Text segment size (pages). */`
205			`u32 u_dsize; /* Data segment size (pages). */`
206			`u32 u_ssize; /* Stack segment size (pages). */`
207			`u32 start_code; /* Starting virtual address of text. */`
208			`u32 start_stack; /* Starting virtual address of stack area.`
209			`This is actually the bottom of the stack,`
210			`the top of the stack is always found in the`
211			`esp register. */`
212			`s32 signal; /* Signal that caused the core dump. */`
213			`u32 u_ar0; /* Used by gdb to help find the values for */`
214			`/* the registers. */`
215			`u32 magic; /* To uniquely identify a core file */`
216			`char u_comm[32]; /* User command that was responsible */`
217			`};`
218
219
220			`#define PT32_PSWMASK 0x0`
221			`#define PT32_PSWADDR 0x04`
222			`#define PT32_GPR0 0x08`
223			`#define PT32_GPR15 0x44`
224			`#define PT32_ACR0 0x48`
225			`#define PT32_ACR15 0x84`
226			`#define PT32_ORIGGPR2 0x88`
227			`#define PT32_FPC 0x90`
228			`#define PT32_FPR0_HI 0x98`
229			`#define PT32_FPR15_LO 0x114`
230			`#define PT32_CR_9 0x118`
231			`#define PT32_CR_11 0x120`
232			`#define PT32_IEEE_IP 0x13C`
233			`#define PT32_LASTOFF PT32_IEEE_IP`
234			`#define PT32_ENDREGS 0x140-1`
235			`#define U32OFFSETOF(member) offsetof(struct user32,regs.member)`
236			`#define U64OFFSETOF(member) offsetof(struct user,regs.member)`
237			`#define U6432DIFF(member) (U64OFFSETOF(member) - U32OFFSETOF(member))`
238			`#define PT_SINGLE_STEP (PT_CR_11+8)`
239			`#define PT32_SINGLE_STEP (PT32_CR_11+4)`
240
241			`#endif /* CONFIG_S390_SUPPORT */`
242
243			`int copy_user(struct task_struct *task,saddr_t useraddr, addr_t copyaddr,`
244			`int len, int tofromuser, int writingtouser)`
245			`{`
246			`int copylen=0,copymax;`
247			`addr_t realuseraddr;`
248			`saddr_t enduseraddr;`
249			`unsigned long mask;`
250			`#ifdef CONFIG_S390_SUPPORT`
251			`int parent_31bit=current->thread.flags & S390_FLAG_31BIT;`
252			`int skip;`
253			`#endif`
254			`enduseraddr=useraddr+len;`
255			`if ((useraddr<0\|\|useraddr&3\|\|enduseraddr&3)\|\|`
256			`#ifdef CONFIG_S390_SUPPORT`
257			`(parent_31bit && enduseraddr > sizeof(struct user32)) \|\|`
258			`#endif`
259			`enduseraddr > sizeof(struct user))`
260			`return (-EIO);`
261
262			`#ifdef CONFIG_S390_SUPPORT`
263			`if(parent_31bit)`
264			`{`
265			`if(useraddr != PT32_PSWMASK)`
266			`{`
267			`if (useraddr == PT32_PSWADDR)`
268			`useraddr = PT_PSWADDR+4;`
269			`else if(useraddr <= PT32_GPR15)`
270			`useraddr = ((useraddr-PT32_GPR0)*2) + PT_GPR0+4;`
271			`else if(useraddr <= PT32_ACR15)`
272			`useraddr += PT_ACR0-PT32_ACR0;`
273			`else if(useraddr == PT32_ORIGGPR2)`
274			`useraddr = PT_ORIGGPR2+4;`
275			`else if(useraddr <= PT32_FPR15_LO)`
276			`useraddr += PT_FPR0-PT32_FPR0_HI;`
277			`else if(useraddr <= PT32_CR_11)`
278			`useraddr = ((useraddr-PT32_CR_9)*2) + PT_CR_9+4;`
279			`else if(useraddr == PT32_SINGLE_STEP)`
280			`useraddr = PT_SINGLE_STEP;`
281			`else if(useraddr <= U32OFFSETOF(per_info.ending_addr))`
282			`useraddr = (((useraddr-U32OFFSETOF(per_info.starting_addr)))*2) +`
283			`U64OFFSETOF(per_info.starting_addr)+4;`
284			`else if( useraddr == U32OFFSETOF(per_info.lowcore.words.perc_atmid))`
285			`useraddr = U64OFFSETOF(per_info.lowcore.words.perc_atmid);`
286			`else if( useraddr == U32OFFSETOF(per_info.lowcore.words.address))`
287			`useraddr = U64OFFSETOF(per_info.lowcore.words.address)+4;`
288			`else if(useraddr == U32OFFSETOF(per_info.lowcore.words.access_id))`
289			`useraddr = U64OFFSETOF(per_info.lowcore.words.access_id);`
290			`else if(useraddr == PT32_IEEE_IP)`
291			`useraddr = PT_IEEE_IP+4;`
292			`}`
293			`}`
294			`#endif /* CONFIG_S390_SUPPORT */`
295
296			`while(len>0)`
297			`{`
298			`#ifdef CONFIG_S390_SUPPORT`
299			`skip=0;`
300			`#endif`
301			`mask=PSW_ADDR_MASK;`
302			`if(useraddr<PT_FPC)`
303			`{`
304			`realuseraddr=((addr_t) __KSTK_PTREGS(task)) + useraddr;`
305			`if(useraddr<(PT_PSWMASK+8))`
306			`{`
307			`if(parent_31bit)`
308			`{`
309			`copymax=PT_PSWMASK+4;`
310			`#ifdef CONFIG_S390_SUPPORT`
311			`skip=8;`
312			`#endif`
313			`}`
314			`else`
315			`{`
316			`copymax=PT_PSWMASK+8;`
317			`}`
318			`if(writingtouser)`
319			`mask=PSW_MASK_DEBUGCHANGE;`
320			`}`
321			`else if(useraddr<(PT_PSWADDR+8))`
322			`{`
323			`copymax=PT_PSWADDR+8;`
324			`mask=PSW_ADDR_DEBUGCHANGE;`
325			`#ifdef CONFIG_S390_SUPPORT`
326			`if(parent_31bit)`
327			`skip=4;`
328			`#endif`
329
330			`}`
331			`else`
332			`{`
333			`#ifdef CONFIG_S390_SUPPORT`
334			`if(parent_31bit && useraddr <= PT_GPR15+4)`
335			`{`
336			`copymax=useraddr+4;`
337			`if(useraddr<PT_GPR15+4)`
338			`skip=4;`
339			`}`
340			`else`
341			`#endif`
342			`copymax=PT_FPC;`
343			`}`
344			`}`
345			`else if(useraddr<(PT_FPR15+sizeof(freg_t)))`
346			`{`
347			`copymax=(PT_FPR15+sizeof(freg_t));`
348			`realuseraddr=(addr_t)&(((u8 *)&task->thread.fp_regs)[useraddr-PT_FPC]);`
349			`}`
350			`else if(useraddr<sizeof(struct user_regs_struct))`
351			`{`
352			`#ifdef CONFIG_S390_SUPPORT`
353			`if( parent_31bit && useraddr <= PT_IEEE_IP+4)`
354			`{`
355			`switch(useraddr)`
356			`{`
357			`case PT_CR_11+4:`
358			`case U64OFFSETOF(per_info.ending_addr)+4:`
359			`case U64OFFSETOF(per_info.lowcore.words.address)+4:`
360			`copymax=useraddr+4;`
361			`break;`
362			`case PT_SINGLE_STEP:`
363			`case U64OFFSETOF(per_info.lowcore.words.perc_atmid):`
364			`/* We copy 2 bytes in excess for the atmid member this also gets around */`
365			`/* alignment for this member in 32 bit */`
366			`skip=8;`
367			`copymax=useraddr+4;`
368			`break;`
369			`default:`
370			`copymax=useraddr+4;`
371			`skip=4;`
372			`}`
373			`}`
374			`else`
375			`#endif`
376			`{`
377			`copymax=sizeof(struct user_regs_struct);`
378			`}`
379			`realuseraddr=(addr_t)&(((u8 *)&task->thread.per_info)[useraddr-PT_CR_9]);`
380			`}`
381			`else`
382			`{`
383			`copymax=sizeof(struct user);`
384			`realuseraddr=(addr_t)NULL;`
385			`}`
386			`copylen=copymax-useraddr;`
387			`copylen=(copylen>len ? len:copylen);`
388			`if(ptrace_usercopy(realuseraddr,copyaddr,copylen,tofromuser,writingtouser,mask))`
389			`return (-EIO);`
390			`copyaddr+=copylen;`
391			`len-=copylen;`
392			`useraddr+=copylen`
393			`#if CONFIG_S390_SUPPORT`
394			`+skip`
395			`#endif`
396			`;`
397			`}`
398			`FixPerRegisters(task);`
399			`return(0);`
400			`}`
401
402			`/*`
403			`* Called by kernel/ptrace.c when detaching..`
404			`*`
405			`* Make sure single step bits etc are not set.`
406			`*/`
407			`void ptrace_disable(struct task_struct *child)`
408			`{`
409			`/* make sure the single step bit is not set. */`
410			`clear_single_step(child);`
411			`}`
412
413			`typedef struct`
414			`{`
415			`__u32 len;`
416			`__u32 kernel_addr;`
417			`__u32 process_addr;`
418			`} ptrace_area_emu31;`
419
420
421			`asmlinkage int sys_ptrace(long request, long pid, long addr, long data)`
422			`{`
423			`struct task_struct *child;`
424			`int ret = -EPERM;`
425			`int copied;`
426			`#ifdef CONFIG_S390_SUPPORT`
427			`int parent_31bit;`
428			`int sizeof_parent_long;`
429			`u8 *dataptr;`
430			`#else`
431			`#define sizeof_parent_long 8`
432			`#define dataptr (u8 *)&data`
433			`#endif`
434			`lock_kernel();`
435			`if (request == PTRACE_TRACEME)`
436			`{`
437			`/* are we already being traced? */`
438			`if (current->ptrace & PT_PTRACED)`
439			`goto out;`
440			`/* set the ptrace bit in the process flags. */`
441			`current->ptrace \|= PT_PTRACED;`
442			`ret = 0;`
443			`goto out;`
444			`}`
445			`ret = -ESRCH;`
446			`read_lock(&tasklist_lock);`
447			`child = find_task_by_pid(pid);`
448			`if (child)`
449			`get_task_struct(child);`
450			`read_unlock(&tasklist_lock);`
451			`if (!child)`
452			`goto out;`
453			`ret = -EPERM;`
454			`if (pid == 1) /* you may not mess with init */`
455			`goto out_tsk;`
456			`if (request == PTRACE_ATTACH)`
457			`{`
458			`ret = ptrace_attach(child);`
459			`goto out_tsk;`
460			`}`
461			`ret = -ESRCH;`
462			`// printk("child=%lX child->flags=%lX",child,child->flags);`
463			`/* I added child!=current line so we can get the */`
464			`/* ieee_instruction_pointer from the user structure DJB */`
465			`if(child!=current)`
466			`{`
467			`if (!(child->ptrace & PT_PTRACED))`
468			`goto out_tsk;`
469			`if (child->state != TASK_STOPPED)`
470			`{`
471			`if (request != PTRACE_KILL)`
472			`goto out_tsk;`
473			`}`
474			`if (child->p_pptr != current)`
475			`goto out_tsk;`
476			`}`
477			`#ifdef CONFIG_S390_SUPPORT`
478			`parent_31bit=(current->thread.flags & S390_FLAG_31BIT);`
479			`sizeof_parent_long=(parent_31bit ? 4:8);`
480			`dataptr=&(((u8 *)&data)[parent_31bit ? 4:0]);`
481			`#endif`
482			`switch (request)`
483			`{`
484			`/* If I and D space are separate, these will need to be fixed. */`
485			`case PTRACE_PEEKTEXT: /* read word at location addr. */`
486			`case PTRACE_PEEKDATA:`
487			`{`
488			`u8 tmp[8];`
489			`copied = access_process_vm(child, addr, tmp, sizeof_parent_long, 0);`
490			`ret = -EIO;`
491			`if (copied != sizeof_parent_long)`
492			`break;`
493			`ret = copy_to_user((void *)data,tmp,sizeof_parent_long);`
494			`ret = ret ? -EFAULT : 0;`
495			`break;`
496
497			`}`
498			`/* read the word at location addr in the USER area. */`
499			`case PTRACE_PEEKUSR:`
500			`ret=copy_user(child,addr,data,sizeof_parent_long,1,0);`
501			`break;`
502
503			`/* If I and D space are separate, this will have to be fixed. */`
504			`case PTRACE_POKETEXT: /* write the word at location addr. */`
505			`case PTRACE_POKEDATA:`
506			`ret = 0;`
507			`if (access_process_vm(child, addr,dataptr, sizeof_parent_long, 1) == sizeof_parent_long)`
508			`break;`
509			`ret = -EIO;`
510			`break;`
511
512			`case PTRACE_POKEUSR: /* write the word at location addr in the USER area */`
513			`ret=copy_user(child,addr,(addr_t)dataptr,sizeof_parent_long,0,1);`
514			`break;`
515
516			`case PTRACE_SYSCALL: /* continue and stop at next (return from) syscall */`
517			`case PTRACE_CONT: /* restart after signal. */`
518			`ret = -EIO;`
519			`if ((unsigned long) data >= _NSIG)`
520			`break;`
521			`if (request == PTRACE_SYSCALL)`
522			`child->ptrace \|= PT_TRACESYS;`
523			`else`
524			`child->ptrace &= ~PT_TRACESYS;`
525			`child->exit_code = data;`
526			`/* make sure the single step bit is not set. */`
527			`clear_single_step(child);`
528			`wake_up_process(child);`
529			`ret = 0;`
530			`break;`
531
532			`/*`
533			`* make the child exit. Best I can do is send it a sigkill.`
534			`* perhaps it should be put in the status that it wants to`
535			`* exit.`
536			`*/`
537			`case PTRACE_KILL:`
538			`ret = 0;`
539			`if (child->state == TASK_ZOMBIE) /* already dead */`
540			`break;`
541			`child->exit_code = SIGKILL;`
542			`clear_single_step(child);`
543			`wake_up_process(child);`
544			`/* make sure the single step bit is not set. */`
545			`break;`
546
547			`case PTRACE_SINGLESTEP: /* set the trap flag. */`
548			`ret = -EIO;`
549			`if ((unsigned long) data >= _NSIG)`
550			`break;`
551			`child->ptrace &= ~PT_TRACESYS;`
552			`child->exit_code = data;`
553			`set_single_step(child);`
554			`/* give it a chance to run. */`
555			`wake_up_process(child);`
556			`ret = 0;`
557			`break;`
558
559			`case PTRACE_DETACH: /* detach a process that was attached. */`
560			`ret = ptrace_detach(child, data);`
561			`break;`
562
563			`case PTRACE_PEEKUSR_AREA:`
564			`case PTRACE_POKEUSR_AREA:`
565			`if(parent_31bit)`
566			`{`
567			`ptrace_area_emu31 parea;`
568			`if(copy_from_user(&parea,(void *)addr,sizeof(parea))==0)`
569			`ret=copy_user(child,parea.kernel_addr,parea.process_addr,`
570			`parea.len,1,(request==PTRACE_POKEUSR_AREA));`
571			`else ret = -EFAULT;`
572			`}`
573			`else`
574			`{`
575			`ptrace_area parea;`
576			`if(copy_from_user(&parea,(void *)addr,sizeof(parea))==0)`
577			`ret=copy_user(child,parea.kernel_addr,parea.process_addr,`
578			`parea.len,1,(request==PTRACE_POKEUSR_AREA));`
579			`else ret = -EFAULT;`
580			`}`
581			`break;`
582			`default:`
583			`ret = -EIO;`
584			`break;`
585			`}`
586			`out_tsk:`
587			`free_task_struct(child);`
588			`out:`
589			`unlock_kernel();`
590			`return ret;`
591			`}`
592
593
594
595			`asmlinkage void syscall_trace(void)`
596			`{`
597			`lock_kernel();`
598			`if ((current->ptrace & (PT_PTRACED\|PT_TRACESYS))`
599			`!= (PT_PTRACED\|PT_TRACESYS))`
600			`goto out;`
601			`current->exit_code = SIGTRAP;`
602			`set_current_state(TASK_STOPPED);`
603			`notify_parent(current, SIGCHLD);`
604			`schedule();`
605			`/*`
606			`* this isn't the same as continuing with a signal, but it will do`
607			`* for normal use. strace only continues with a signal if the`
608			`* stopping signal is not SIGTRAP. -brl`
609			`*/`
610			`if (current->exit_code) {`
611			`send_sig(current->exit_code, current, 1);`
612			`current->exit_code = 0;`
613			`}`
614			`out:`
615			`unlock_kernel();`
616			`}`