sys/compat/linux/arch/i386/linux_ptrace.c

   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                 error = 0;
 296                 if (addr < LUSR_OFF(lusr_startgdb)) {
 297                         /* XXX should provide appropriate register */
 298                         error = 1;
 299                 } else if (addr == LUSR_OFF(u_tsize))
 300                         *retval = p->p_vmspace->vm_tsize;
 301                 else if (addr == LUSR_OFF(u_dsize))
 302                         *retval = p->p_vmspace->vm_dsize;
 303                 else if (addr == LUSR_OFF(u_ssize))
 304                         *retval = p->p_vmspace->vm_ssize;
 305                 else if (addr == LUSR_OFF(start_code))
 306                         *retval = (register_t) p->p_vmspace->vm_taddr;
 307                 else if (addr == LUSR_OFF(start_stack))
 308                         *retval = (register_t) p->p_vmspace->vm_minsaddr;
 309                 else if (addr == LUSR_OFF(u_ar0))
 310                         *retval = LUSR_OFF(regs);
 311                 else if (addr >= LUSR_OFF(u_debugreg)
 312                            && addr <= LUSR_OFF(u_debugreg_end)) {
 313                         int off = (addr - LUSR_OFF(u_debugreg)) / sizeof(int);
 314
 315                         /* only do this for Linux processes */
 316                         if (t->p_emul != &emul_linux)
 317                                 error = EINVAL;
 318                         else {
 319                                 *retval = ((struct linux_emuldata *)
 320                                                 t->p_emuldata)->debugreg[off];
 321                         }
 322                 } else if (addr == LUSR_OFF(__signal)) {
 323                         error = 1;
 324                 } else if (addr == LUSR_OFF(__signal)) {
 325                         error = 1;
 326                 } else if (addr == LUSR_OFF(u_fpstate)) {
 327                         error = 1;
 328                 } else if (addr == LUSR_OFF(__magic)) {
 329                         error = 1;
 330                 } else if (addr == LUSR_OFF(u_comm)) {
 331                         error = 1;
 332                 } else {
 333 #ifdef DEBUG_LINUX
 334                         printf("linux_ptrace: unsupported address: %d\n", addr);
 335 #endif
 336                         error = 1;
 337                 }
 338                 if (!error)
 339                         return 0;
 340
 341         case  LINUX_PTRACE_POKEUSR:
 342                 /* we only support setting debugregs for now */
 343                 addr = SCARG(uap, addr);
 344                 if (addr >= LUSR_OFF(u_debugreg)
 345                            && addr <= LUSR_OFF(u_debugreg_end)) {
 346                         int off = (addr - LUSR_OFF(u_debugreg)) / sizeof(int);
 347                         int data = SCARG(uap, data);
 348
 349                         /* only do this for Linux processes */
 350                         if (t->p_emul != &emul_linux)
 351                                 return EINVAL;
 352
 353                         ((struct linux_emuldata *)t->p_emuldata)->debugreg[off] = data;
 354                         return (0);
 355                 }
 356
 357                 break;
 358         default:
 359                 /* never reached */
 360                 break;
 361         }
 362
 363         return EIO;
 364
 365     out:
 366         if (regs)
 367                 free(regs, M_TEMP);
 368         if (fpregs)
 369                 free(fpregs, M_TEMP);
 370         if (linux_regs)
 371                 free(linux_regs, M_TEMP);
 372         if (linux_fpregs)
 373                 free(linux_fpregs, M_TEMP);
 374         return (error);
 375 }