1 /* $NetBSD: linux_ptrace.c,v 1.23 2008/12/17 20:51:33 cegger Exp $ */ 2 3 /*- 4 * Copyright (c) 1999 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Matthias Scheler. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 #include <sys/cdefs.h> 33 __KERNEL_RCSID(0, "$NetBSD: linux_ptrace.c,v 1.23 2008/12/17 20:51:33 cegger Exp $"); 34 35 #include <sys/param.h> 36 #include <sys/malloc.h> 37 #include <sys/mount.h> 38 #include <sys/proc.h> 39 #include <sys/ptrace.h> 40 #include <sys/systm.h> 41 #include <sys/syscall.h> 42 #include <sys/syscallargs.h> 43 #include <uvm/uvm_extern.h> 44 45 #include <machine/reg.h> 46 47 #include <compat/linux/common/linux_types.h> 48 #include <compat/linux/common/linux_ptrace.h> 49 #include <compat/linux/common/linux_signal.h> 50 51 #include <compat/linux/common/linux_util.h> 52 #include <compat/linux/common/linux_machdep.h> 53 #include <compat/linux/common/linux_emuldata.h> 54 #include <compat/linux/common/linux_exec.h> /* for emul_linux */ 55 56 #include <compat/linux/linux_syscallargs.h> 57 58 #include <lib/libkern/libkern.h> /* for offsetof() */ 59 60 struct linux_reg { 61 long ebx; 62 long ecx; 63 long edx; 64 long esi; 65 long edi; 66 long ebp; 67 long eax; 68 long xds, xes; /* unsigned short ds, __ds, es, __es; */ 69 long __fs, __gs; /* unsigned short fs, __fs, gs, __gs; */ 70 long orig_eax; 71 long eip; 72 long xcs; /* unsigned short cs, __cs; */ 73 long eflags; 74 long esp; 75 long xss; /* unsigned short ss, __ss; */ 76 }; 77 78 /* structure used for storing floating point context */ 79 struct linux_fpctx { 80 long cwd; 81 long swd; 82 long twd; 83 long fip; 84 long fcs; 85 long foo; 86 long fos; 87 long st_space[20]; 88 }; 89 90 /* user struct for linux process - this is used for Linux ptrace emulation */ 91 /* most of it is junk only used by gdb */ 92 struct linux_user { 93 struct linux_reg regs; /* registers */ 94 int u_fpvalid; /* true if math co-processor being used. */ 95 struct linux_fpctx i387; /* Math Co-processor registers. */ 96 /* The rest of this junk is to help gdb figure out what goes where */ 97 #define lusr_startgdb u_tsize 98 unsigned long int u_tsize; /* Text segment size (pages). */ 99 unsigned long int u_dsize; /* Data segment size (pages). */ 100 unsigned long int u_ssize; /* Stack segment size (pages). */ 101 unsigned long start_code; /* Starting virtual address of text. */ 102 unsigned long start_stack; /* Starting virtual address of stack 103 area. This is actually the bottom of 104 the stack, the top of the stack is 105 always found in the esp register. */ 106 long int __signal; /* Signal that caused the core dump. */ 107 int __reserved; /* unused */ 108 void *u_ar0; /* Used by gdb to help find the values 109 for the registers. */ 110 struct linux_fpctx *u_fpstate; /* Math Co-processor pointer. */ 111 unsigned long __magic; /* To uniquely identify a core file */ 112 char u_comm[32]; /* User command that was responsible */ 113 int u_debugreg[8]; 114 #define u_debugreg_end u_debugreg[7] 115 }; 116 117 #define LUSR_OFF(member) offsetof(struct linux_user, member) 118 #define ISSET(t, f) ((t) & (f)) 119 120 int linux_ptrace_disabled = 1; /* bitrotted */ 121 122 int 123 linux_sys_ptrace_arch(struct lwp *l, const struct linux_sys_ptrace_args *uap, register_t *retval) 124 { 125 /* { 126 syscallarg(int) request; 127 syscallarg(int) pid; 128 syscallarg(int) addr; 129 syscallarg(int) data; 130 } */ 131 struct proc *p = l->l_proc; 132 int request, error; 133 struct proc *t; /* target process */ 134 struct lwp *lt; 135 struct reg *regs = NULL; 136 struct fpreg *fpregs = NULL; 137 struct linux_reg *linux_regs = NULL; 138 struct linux_fpctx *linux_fpregs = NULL; 139 int addr; 140 141 if (linux_ptrace_disabled) 142 return ENOSYS; 143 144 request = SCARG(uap, request); 145 146 if ((request != LINUX_PTRACE_PEEKUSR) && 147 (request != LINUX_PTRACE_POKEUSR) && 148 (request != LINUX_PTRACE_GETREGS) && 149 (request != LINUX_PTRACE_SETREGS) && 150 (request != LINUX_PTRACE_GETFPREGS) && 151 (request != LINUX_PTRACE_SETFPREGS)) 152 return EIO; 153 154 /* XXXAD locking */ 155 156 /* Find the process we're supposed to be operating on. */ 157 if ((t = pfind(SCARG(uap, pid))) == NULL) 158 return ESRCH; 159 160 /* 161 * You can't do what you want to the process if: 162 * (1) It's not being traced at all, 163 */ 164 if (!ISSET(t->p_slflag, PSL_TRACED)) 165 return EPERM; 166 167 /* 168 * (2) it's being traced by procfs (which has 169 * different signal delivery semantics), 170 */ 171 if (ISSET(t->p_slflag, PSL_FSTRACE)) 172 return EBUSY; 173 174 /* 175 * (3) it's not being traced by _you_, or 176 */ 177 if (t->p_pptr != p) 178 return EBUSY; 179 180 /* 181 * (4) it's not currently stopped. 182 */ 183 if (t->p_stat != SSTOP || !t->p_waited /* XXXSMP */) 184 return EBUSY; 185 186 /* XXX NJWLWP 187 * The entire ptrace interface needs work to be useful to 188 * a process with multiple LWPs. For the moment, we'll 189 * just kluge this and fail on others. 190 */ 191 192 if (p->p_nlwps > 1) 193 return (ENOSYS); 194 195 lt = LIST_FIRST(&t->p_lwps); 196 197 *retval = 0; 198 199 switch (request) { 200 case LINUX_PTRACE_GETREGS: 201 regs = malloc(sizeof(struct reg), M_TEMP, M_WAITOK); 202 linux_regs = malloc(sizeof(struct linux_reg), M_TEMP, M_WAITOK); 203 204 error = process_read_regs(lt, regs); 205 if (error != 0) 206 goto out; 207 208 linux_regs->ebx = regs->r_ebx; 209 linux_regs->ecx = regs->r_ecx; 210 linux_regs->edx = regs->r_edx; 211 linux_regs->esi = regs->r_esi; 212 linux_regs->edi = regs->r_edi; 213 linux_regs->ebp = regs->r_ebp; 214 linux_regs->eax = regs->r_eax; 215 linux_regs->xds = regs->r_ds; 216 linux_regs->xes = regs->r_es; 217 linux_regs->orig_eax = regs->r_eax; /* XXX is this correct? */ 218 linux_regs->eip = regs->r_cs + regs->r_eip; 219 linux_regs->xcs = regs->r_cs; 220 linux_regs->eflags = regs->r_eflags; 221 linux_regs->esp = regs->r_esp; 222 linux_regs->xss = regs->r_ss; 223 224 error = copyout(linux_regs, (void *)SCARG(uap, data), 225 sizeof(struct linux_reg)); 226 goto out; 227 228 case LINUX_PTRACE_SETREGS: 229 regs = malloc(sizeof(struct reg), M_TEMP, M_WAITOK); 230 linux_regs = malloc(sizeof(struct linux_reg), 231 M_TEMP, M_WAITOK); 232 233 error = copyin((void *)SCARG(uap, data), linux_regs, 234 sizeof(struct linux_reg)); 235 if (error != 0) 236 goto out; 237 238 regs->r_ebx = linux_regs->ebx; 239 regs->r_ecx = linux_regs->ecx; 240 regs->r_edx = linux_regs->edx; 241 regs->r_esi = linux_regs->esi; 242 regs->r_edi = linux_regs->edi; 243 regs->r_ebp = linux_regs->ebp; 244 regs->r_eax = linux_regs->eax; 245 regs->r_ds = linux_regs->xds; 246 regs->r_es = linux_regs->xes; 247 regs->r_eip = linux_regs->eip - linux_regs->xcs; 248 regs->r_cs = linux_regs->xcs; 249 regs->r_eflags = linux_regs->eflags; 250 regs->r_esp = linux_regs->esp; 251 regs->r_ss = linux_regs->xss; 252 253 error = process_write_regs(lt, regs); 254 goto out; 255 256 case LINUX_PTRACE_GETFPREGS: 257 fpregs = malloc(sizeof(struct fpreg), 258 M_TEMP, M_WAITOK); 259 linux_fpregs = malloc(sizeof(struct linux_fpctx), 260 M_TEMP, M_WAITOK); 261 262 error = process_read_fpregs(lt, fpregs); 263 if (error != 0) 264 goto out; 265 266 /* zero the contents if NetBSD fpreg structure is smaller */ 267 if (sizeof(struct fpreg) < sizeof(struct linux_fpctx)) 268 memset(linux_fpregs, '\0', sizeof(struct linux_fpctx)); 269 270 memcpy(linux_fpregs, fpregs, 271 min(sizeof(struct linux_fpctx), sizeof(struct fpreg))); 272 error = copyout(linux_fpregs, (void *)SCARG(uap, data), 273 sizeof(struct linux_fpctx)); 274 goto out; 275 276 case LINUX_PTRACE_SETFPREGS: 277 fpregs = malloc(sizeof(struct fpreg), M_TEMP, M_WAITOK); 278 linux_fpregs = malloc(sizeof(struct linux_fpctx), 279 M_TEMP, M_WAITOK); 280 error = copyin((void *)SCARG(uap, data), linux_fpregs, 281 sizeof(struct linux_fpctx)); 282 if (error != 0) 283 goto out; 284 285 memset(fpregs, '\0', sizeof(struct fpreg)); 286 memcpy(fpregs, linux_fpregs, 287 min(sizeof(struct linux_fpctx), sizeof(struct fpreg))); 288 289 error = process_write_regs(lt, regs); 290 goto out; 291 292 case LINUX_PTRACE_PEEKUSR: 293 addr = SCARG(uap, addr); 294 295 uvm_lwp_hold(lt); /* need full process info */ 296 error = 0; 297 if (addr < LUSR_OFF(lusr_startgdb)) { 298 /* XXX should provide appropriate register */ 299 error = 1; 300 } else if (addr == LUSR_OFF(u_tsize)) 301 *retval = p->p_vmspace->vm_tsize; 302 else if (addr == LUSR_OFF(u_dsize)) 303 *retval = p->p_vmspace->vm_dsize; 304 else if (addr == LUSR_OFF(u_ssize)) 305 *retval = p->p_vmspace->vm_ssize; 306 else if (addr == LUSR_OFF(start_code)) 307 *retval = (register_t) p->p_vmspace->vm_taddr; 308 else if (addr == LUSR_OFF(start_stack)) 309 *retval = (register_t) p->p_vmspace->vm_minsaddr; 310 else if (addr == LUSR_OFF(u_ar0)) 311 *retval = LUSR_OFF(regs); 312 else if (addr >= LUSR_OFF(u_debugreg) 313 && addr <= LUSR_OFF(u_debugreg_end)) { 314 int off = (addr - LUSR_OFF(u_debugreg)) / sizeof(int); 315 316 /* only do this for Linux processes */ 317 if (t->p_emul != &emul_linux) 318 error = EINVAL; 319 else { 320 *retval = ((struct linux_emuldata *) 321 t->p_emuldata)->debugreg[off]; 322 } 323 } else if (addr == LUSR_OFF(__signal)) { 324 error = 1; 325 } else if (addr == LUSR_OFF(__signal)) { 326 error = 1; 327 } else if (addr == LUSR_OFF(u_fpstate)) { 328 error = 1; 329 } else if (addr == LUSR_OFF(__magic)) { 330 error = 1; 331 } else if (addr == LUSR_OFF(u_comm)) { 332 error = 1; 333 } else { 334 #ifdef DEBUG_LINUX 335 printf("linux_ptrace: unsupported address: %d\n", addr); 336 #endif 337 error = 1; 338 } 339 340 uvm_lwp_rele(lt); 341 342 if (!error) 343 return 0; 344 345 case LINUX_PTRACE_POKEUSR: 346 /* we only support setting debugregs for now */ 347 addr = SCARG(uap, addr); 348 if (addr >= LUSR_OFF(u_debugreg) 349 && addr <= LUSR_OFF(u_debugreg_end)) { 350 int off = (addr - LUSR_OFF(u_debugreg)) / sizeof(int); 351 int data = SCARG(uap, data); 352 353 /* only do this for Linux processes */ 354 if (t->p_emul != &emul_linux) 355 return EINVAL; 356 357 uvm_lwp_hold(lt); 358 ((struct linux_emuldata *)t->p_emuldata)->debugreg[off] = data; 359 uvm_lwp_rele(lt); 360 return (0); 361 } 362 363 break; 364 default: 365 /* never reached */ 366 break; 367 } 368 369 return EIO; 370 371 out: 372 if (regs) 373 free(regs, M_TEMP); 374 if (fpregs) 375 free(fpregs, M_TEMP); 376 if (linux_regs) 377 free(linux_regs, M_TEMP); 378 if (linux_fpregs) 379 free(linux_fpregs, M_TEMP); 380 return (error); 381 } 382