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 <linux/uaccess.h> 14 #include <registers.h> 15 #include <asm/ptrace-abi.h> 16 17 /* 18 * determines which flags the user has access to. 19 * 1 = access 0 = no access 20 */ 21 #define FLAG_MASK 0x44dd5UL 22 23 static const int reg_offsets[] = 24 { 25 [R8 >> 3] = HOST_R8, 26 [R9 >> 3] = HOST_R9, 27 [R10 >> 3] = HOST_R10, 28 [R11 >> 3] = HOST_R11, 29 [R12 >> 3] = HOST_R12, 30 [R13 >> 3] = HOST_R13, 31 [R14 >> 3] = HOST_R14, 32 [R15 >> 3] = HOST_R15, 33 [RIP >> 3] = HOST_IP, 34 [RSP >> 3] = HOST_SP, 35 [RAX >> 3] = HOST_AX, 36 [RBX >> 3] = HOST_BX, 37 [RCX >> 3] = HOST_CX, 38 [RDX >> 3] = HOST_DX, 39 [RSI >> 3] = HOST_SI, 40 [RDI >> 3] = HOST_DI, 41 [RBP >> 3] = HOST_BP, 42 [CS >> 3] = HOST_CS, 43 [SS >> 3] = HOST_SS, 44 [FS_BASE >> 3] = HOST_FS_BASE, 45 [GS_BASE >> 3] = HOST_GS_BASE, 46 [DS >> 3] = HOST_DS, 47 [ES >> 3] = HOST_ES, 48 [FS >> 3] = HOST_FS, 49 [GS >> 3] = HOST_GS, 50 [EFLAGS >> 3] = HOST_EFLAGS, 51 [ORIG_RAX >> 3] = HOST_ORIG_AX, 52 }; 53 54 int putreg(struct task_struct *child, int regno, unsigned long value) 55 { 56 switch (regno) { 57 case R8: 58 case R9: 59 case R10: 60 case R11: 61 case R12: 62 case R13: 63 case R14: 64 case R15: 65 case RIP: 66 case RSP: 67 case RAX: 68 case RBX: 69 case RCX: 70 case RDX: 71 case RSI: 72 case RDI: 73 case RBP: 74 break; 75 76 case ORIG_RAX: 77 /* Update the syscall number. */ 78 UPT_SYSCALL_NR(&child->thread.regs.regs) = value; 79 break; 80 81 case FS: 82 case GS: 83 case DS: 84 case ES: 85 case SS: 86 case CS: 87 if (value && (value & 3) != 3) 88 return -EIO; 89 value &= 0xffff; 90 break; 91 92 case FS_BASE: 93 case GS_BASE: 94 if (!((value >> 48) == 0 || (value >> 48) == 0xffff)) 95 return -EIO; 96 break; 97 98 case EFLAGS: 99 value &= FLAG_MASK; 100 child->thread.regs.regs.gp[HOST_EFLAGS] |= value; 101 return 0; 102 103 default: 104 panic("Bad register in putreg(): %d\n", regno); 105 } 106 107 child->thread.regs.regs.gp[reg_offsets[regno >> 3]] = value; 108 return 0; 109 } 110 111 int poke_user(struct task_struct *child, long addr, long data) 112 { 113 if ((addr & 3) || addr < 0) 114 return -EIO; 115 116 if (addr < MAX_REG_OFFSET) 117 return putreg(child, addr, data); 118 else if ((addr >= offsetof(struct user, u_debugreg[0])) && 119 (addr <= offsetof(struct user, u_debugreg[7]))) { 120 addr -= offsetof(struct user, u_debugreg[0]); 121 addr = addr >> 3; 122 if ((addr == 4) || (addr == 5)) 123 return -EIO; 124 child->thread.arch.debugregs[addr] = data; 125 return 0; 126 } 127 return -EIO; 128 } 129 130 unsigned long getreg(struct task_struct *child, int regno) 131 { 132 unsigned long mask = ~0UL; 133 134 switch (regno) { 135 case R8: 136 case R9: 137 case R10: 138 case R11: 139 case R12: 140 case R13: 141 case R14: 142 case R15: 143 case RIP: 144 case RSP: 145 case RAX: 146 case RBX: 147 case RCX: 148 case RDX: 149 case RSI: 150 case RDI: 151 case RBP: 152 case ORIG_RAX: 153 case EFLAGS: 154 case FS_BASE: 155 case GS_BASE: 156 break; 157 case FS: 158 case GS: 159 case DS: 160 case ES: 161 case SS: 162 case CS: 163 mask = 0xffff; 164 break; 165 default: 166 panic("Bad register in getreg: %d\n", regno); 167 } 168 return mask & child->thread.regs.regs.gp[reg_offsets[regno >> 3]]; 169 } 170 171 int peek_user(struct task_struct *child, long addr, long data) 172 { 173 /* read the word at location addr in the USER area. */ 174 unsigned long tmp; 175 176 if ((addr & 3) || addr < 0) 177 return -EIO; 178 179 tmp = 0; /* Default return condition */ 180 if (addr < MAX_REG_OFFSET) 181 tmp = getreg(child, addr); 182 else if ((addr >= offsetof(struct user, u_debugreg[0])) && 183 (addr <= offsetof(struct user, u_debugreg[7]))) { 184 addr -= offsetof(struct user, u_debugreg[0]); 185 addr = addr >> 2; 186 tmp = child->thread.arch.debugregs[addr]; 187 } 188 return put_user(tmp, (unsigned long *) data); 189 } 190 191 /* XXX Mostly copied from sys-i386 */ 192 int is_syscall(unsigned long addr) 193 { 194 unsigned short instr; 195 int n; 196 197 n = copy_from_user(&instr, (void __user *) addr, sizeof(instr)); 198 if (n) { 199 /* 200 * access_process_vm() grants access to vsyscall and stub, 201 * while copy_from_user doesn't. Maybe access_process_vm is 202 * slow, but that doesn't matter, since it will be called only 203 * in case of singlestepping, if copy_from_user failed. 204 */ 205 n = access_process_vm(current, addr, &instr, sizeof(instr), 206 FOLL_FORCE); 207 if (n != sizeof(instr)) { 208 printk("is_syscall : failed to read instruction from " 209 "0x%lx\n", addr); 210 return 1; 211 } 212 } 213 /* sysenter */ 214 return instr == 0x050f; 215 } 216 217 static int get_fpregs(struct user_i387_struct __user *buf, struct task_struct *child) 218 { 219 int err, n, cpu = ((struct thread_info *) child->stack)->cpu; 220 struct user_i387_struct fpregs; 221 222 err = save_i387_registers(userspace_pid[cpu], 223 (unsigned long *) &fpregs); 224 if (err) 225 return err; 226 227 n = copy_to_user(buf, &fpregs, sizeof(fpregs)); 228 if (n > 0) 229 return -EFAULT; 230 231 return n; 232 } 233 234 static int set_fpregs(struct user_i387_struct __user *buf, struct task_struct *child) 235 { 236 int n, cpu = ((struct thread_info *) child->stack)->cpu; 237 struct user_i387_struct fpregs; 238 239 n = copy_from_user(&fpregs, buf, sizeof(fpregs)); 240 if (n > 0) 241 return -EFAULT; 242 243 return restore_i387_registers(userspace_pid[cpu], 244 (unsigned long *) &fpregs); 245 } 246 247 long subarch_ptrace(struct task_struct *child, long request, 248 unsigned long addr, unsigned long data) 249 { 250 int ret = -EIO; 251 void __user *datap = (void __user *) data; 252 253 switch (request) { 254 case PTRACE_GETFPREGS: /* Get the child FPU state. */ 255 ret = get_fpregs(datap, child); 256 break; 257 case PTRACE_SETFPREGS: /* Set the child FPU state. */ 258 ret = set_fpregs(datap, child); 259 break; 260 case PTRACE_ARCH_PRCTL: 261 /* XXX Calls ptrace on the host - needs some SMP thinking */ 262 ret = arch_prctl(child, data, (void __user *) addr); 263 break; 264 } 265 266 return ret; 267 } 268