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