git.oblomov.eu Git - linux-2.6/blob - arch/um/sys-x86_64/ptrace.c

   1 /*
   2  * Copyright 2003 PathScale, Inc.
   3  * Copyright (C) 2003 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
   4  *
   5  * Licensed under the GPL
   6  */
   7
   8 #define __FRAME_OFFSETS
   9 #include <asm/ptrace.h>
  10 #include <linux/sched.h>
  11 #include <linux/errno.h>
  12 #include <linux/mm.h>
  13 #include <asm/uaccess.h>
  14 #include <asm/elf.h>
  15
  16 /*
  17  * determines which flags the user has access to.
  18  * 1 = access 0 = no access
  19  */
  20 #define FLAG_MASK 0x44dd5UL
  21
  22 int putreg(struct task_struct *child, int regno, unsigned long value)
  23 {
  24         unsigned long tmp;
  25
  26 #ifdef TIF_IA32
  27         /* Some code in the 64bit emulation may not be 64bit clean.
  28            Don't take any chances. */
  29         if (test_tsk_thread_flag(child, TIF_IA32))
  30                 value &= 0xffffffff;
  31 #endif
  32         switch (regno){
  33         case FS:
  34         case GS:
  35         case DS:
  36         case ES:
  37         case SS:
  38         case CS:
  39                 if (value && (value & 3) != 3)
  40                         return -EIO;
  41                 value &= 0xffff;
  42                 break;
  43
  44         case FS_BASE:
  45         case GS_BASE:
  46                 if (!((value >> 48) == 0 || (value >> 48) == 0xffff))
  47                         return -EIO;
  48                 break;
  49
  50         case EFLAGS:
  51                 value &= FLAG_MASK;
  52                 tmp = PT_REGS_EFLAGS(&child->thread.regs) & ~FLAG_MASK;
  53                 value |= tmp;
  54                 break;
  55         }
  56
  57         PT_REGS_SET(&child->thread.regs, regno, value);
  58         return 0;
  59 }
  60
  61 int poke_user(struct task_struct *child, long addr, long data)
  62 {
  63         if ((addr & 3) || addr < 0)
  64                 return -EIO;
  65
  66         if (addr < MAX_REG_OFFSET)
  67                 return putreg(child, addr, data);
  68         else if ((addr >= offsetof(struct user, u_debugreg[0])) &&
  69                 (addr <= offsetof(struct user, u_debugreg[7]))){
  70                 addr -= offsetof(struct user, u_debugreg[0]);
  71                 addr = addr >> 2;
  72                 if ((addr == 4) || (addr == 5))
  73                         return -EIO;
  74                 child->thread.arch.debugregs[addr] = data;
  75                 return 0;
  76         }
  77         return -EIO;
  78 }
  79
  80 unsigned long getreg(struct task_struct *child, int regno)
  81 {
  82         unsigned long retval = ~0UL;
  83         switch (regno) {
  84         case FS:
  85         case GS:
  86         case DS:
  87         case ES:
  88         case SS:
  89         case CS:
  90                 retval = 0xffff;
  91                 /* fall through */
  92         default:
  93                 retval &= PT_REG(&child->thread.regs, regno);
  94 #ifdef TIF_IA32
  95                 if (test_tsk_thread_flag(child, TIF_IA32))
  96                         retval &= 0xffffffff;
  97 #endif
  98         }
  99         return retval;
 100 }
 101
 102 int peek_user(struct task_struct *child, long addr, long data)
 103 {
 104         /* read the word at location addr in the USER area. */
 105         unsigned long tmp;
 106
 107         if ((addr & 3) || addr < 0)
 108                 return -EIO;
 109
 110         tmp = 0;  /* Default return condition */
 111         if (addr < MAX_REG_OFFSET){
 112                 tmp = getreg(child, addr);
 113         }
 114         else if ((addr >= offsetof(struct user, u_debugreg[0])) &&
 115                 (addr <= offsetof(struct user, u_debugreg[7]))){
 116                 addr -= offsetof(struct user, u_debugreg[0]);
 117                 addr = addr >> 2;
 118                 tmp = child->thread.arch.debugregs[addr];
 119         }
 120         return put_user(tmp, (unsigned long *) data);
 121 }
 122
 123 /* XXX Mostly copied from sys-i386 */
 124 int is_syscall(unsigned long addr)
 125 {
 126         unsigned short instr;
 127         int n;
 128
 129         n = copy_from_user(&instr, (void __user *) addr, sizeof(instr));
 130         if (n){
 131                 /* access_process_vm() grants access to vsyscall and stub,
 132                  * while copy_from_user doesn't. Maybe access_process_vm is
 133                  * slow, but that doesn't matter, since it will be called only
 134                  * in case of singlestepping, if copy_from_user failed.
 135                  */
 136                 n = access_process_vm(current, addr, &instr, sizeof(instr), 0);
 137                 if (n != sizeof(instr)) {
 138                         printk("is_syscall : failed to read instruction from "
 139                                "0x%lx\n", addr);
 140                         return 1;
 141                 }
 142         }
 143         /* sysenter */
 144         return instr == 0x050f;
 145 }
 146
 147 int get_fpregs(struct user_i387_struct __user *buf, struct task_struct *child)
 148 {
 149         int err, n, cpu = ((struct thread_info *) child->stack)->cpu;
 150         long fpregs[HOST_FP_SIZE];
 151
 152         BUG_ON(sizeof(*buf) != sizeof(fpregs));
 153         err = save_fp_registers(userspace_pid[cpu], fpregs);
 154         if (err)
 155                 return err;
 156
 157         n = copy_to_user(buf, fpregs, sizeof(fpregs));
 158         if(n > 0)
 159                 return -EFAULT;
 160
 161         return n;
 162 }
 163
 164 int set_fpregs(struct user_i387_struct __user *buf, struct task_struct *child)
 165 {
 166         int n, cpu = ((struct thread_info *) child->stack)->cpu;
 167         long fpregs[HOST_FP_SIZE];
 168
 169         BUG_ON(sizeof(*buf) != sizeof(fpregs));
 170         n = copy_from_user(fpregs, buf, sizeof(fpregs));
 171         if (n > 0)
 172                 return -EFAULT;
 173
 174         return restore_fp_registers(userspace_pid[cpu], fpregs);
 175 }
 176
 177 long subarch_ptrace(struct task_struct *child, long request, long addr,
 178                     long data)
 179 {
 180         int ret = -EIO;
 181
 182         switch (request) {
 183         case PTRACE_GETFPXREGS: /* Get the child FPU state. */
 184                 ret = get_fpregs((struct user_i387_struct __user *) data,
 185                                  child);
 186                 break;
 187         case PTRACE_SETFPXREGS: /* Set the child FPU state. */
 188                 ret = set_fpregs((struct user_i387_struct __user *) data,
 189                                  child);
 190                 break;
 191         }
 192
 193         return ret;
 194 }