gdb/infptrace.c

   1 /* Low level Unix child interface to ptrace, for GDB when running under Unix.
   2    Copyright 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
   3    1998, 1999, 2000, 2001, 2002, 2004
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 59 Temple Place - Suite 330,
  21    Boston, MA 02111-1307, USA.  */
  22
  23 #include "defs.h"
  24 #include "command.h"
  25 #include "frame.h"
  26 #include "gdbcore.h"
  27 #include "inferior.h"
  28 #include "regcache.h"
  29 #include "target.h"
  30
  31 #include "gdb_assert.h"
  32 #include "gdb_wait.h"
  33 #include "gdb_string.h"
  34
  35 #include <sys/param.h>
  36 #include "gdb_dirent.h"
  37 #include <signal.h>
  38 #include <sys/ioctl.h>
  39
  40 #include "gdb_ptrace.h"
  41
  42 #ifdef HAVE_SYS_FILE_H
  43 #include <sys/file.h>
  44 #endif
  45
  46 #if !defined (FETCH_INFERIOR_REGISTERS)
  47 #include <sys/user.h>           /* Probably need to poke the user structure */
  48 #endif /* !FETCH_INFERIOR_REGISTERS */
  49
  50 #if !defined (CHILD_XFER_MEMORY)
  51 static void udot_info (char *, int);
  52 #endif
  53
  54 void _initialize_infptrace (void);
  55 \f
  56
  57 int
  58 call_ptrace (int request, int pid, PTRACE_ARG3_TYPE addr, int data)
  59 {
  60   return ptrace (request, pid, addr, data);
  61 }
  62
  63 /* Wait for a process to finish, possibly running a target-specific
  64    hook before returning.  */
  65
  66 /* NOTE: cagney: 2004-09-29: Dependant on the native configuration,
  67    "hppah-nat.c" may either call this or infttrace.c's implementation
  68    of ptrace_wait.  See "hppahpux.mh".  */
  69
  70 int
  71 ptrace_wait (ptid_t ptid, int *status)
  72 {
  73   int wstate;
  74
  75   wstate = wait (status);
  76   return wstate;
  77 }
  78
  79 #ifndef DEPRECATED_KILL_INFERIOR
  80 /* NOTE: cagney/2004-09-12: Instead of definining this macro, code
  81    should call inf_ptrace_target to get a basic ptrace target and then
  82    locally update any necessary methods.  See ppcnbsd-nat.c.  */
  83
  84 void
  85 kill_inferior (void)
  86 {
  87   int status;
  88   int pid =  PIDGET (inferior_ptid);
  89
  90   if (pid == 0)
  91     return;
  92
  93   /* This once used to call "kill" to kill the inferior just in case
  94      the inferior was still running.  As others have noted in the past
  95      (kingdon) there shouldn't be any way to get here if the inferior
  96      is still running -- else there's a major problem elsewere in gdb
  97      and it needs to be fixed.
  98
  99      The kill call causes problems under hpux10, so it's been removed;
 100      if this causes problems we'll deal with them as they arise.  */
 101   ptrace (PT_KILL, pid, (PTRACE_TYPE_ARG3) 0, 0);
 102   wait (&status);
 103   target_mourn_inferior ();
 104 }
 105 #endif /* DEPRECATED_KILL_INFERIOR */
 106
 107 #ifndef DEPRECATED_CHILD_RESUME
 108 /* NOTE: cagney/2004-09-12: Instead of definining this macro, code
 109    should call inf_ptrace_target to get a basic ptrace target and then
 110    locally update any necessary methods.  See ppcnbsd-nat.c.  */
 111
 112 /* Resume execution of the inferior process.
 113    If STEP is nonzero, single-step it.
 114    If SIGNAL is nonzero, give it that signal.  */
 115
 116 void
 117 child_resume (ptid_t ptid, int step, enum target_signal signal)
 118 {
 119   int request = PT_CONTINUE;
 120   int pid = PIDGET (ptid);
 121
 122   if (pid == -1)
 123     /* Resume all threads.  */
 124     /* I think this only gets used in the non-threaded case, where "resume
 125        all threads" and "resume inferior_ptid" are the same.  */
 126     pid = PIDGET (inferior_ptid);
 127
 128   if (step)
 129     {
 130       /* If this system does not support PT_STEP, a higher level
 131          function will have called single_step() to transmute the step
 132          request into a continue request (by setting breakpoints on
 133          all possible successor instructions), so we don't have to
 134          worry about that here.  */
 135
 136       gdb_assert (!SOFTWARE_SINGLE_STEP_P ());
 137       request = PT_STEP;
 138     }
 139
 140   /* An address of (PTRACE_TYPE_ARG3)1 tells ptrace to continue from
 141      where it was.  If GDB wanted it to start some other way, we have
 142      already written a new PC value to the child.  */
 143
 144   errno = 0;
 145   ptrace (request, pid, (PTRACE_TYPE_ARG3)1, target_signal_to_host (signal));
 146   if (errno != 0)
 147     perror_with_name (("ptrace"));
 148 }
 149 #endif /* DEPRECATED_CHILD_RESUME */
 150 \f
 151
 152 /* Start debugging the process whose number is PID.  */
 153
 154 int
 155 attach (int pid)
 156 {
 157 #ifdef PT_ATTACH
 158   errno = 0;
 159   ptrace (PT_ATTACH, pid, (PTRACE_TYPE_ARG3) 0, 0);
 160   if (errno != 0)
 161     perror_with_name (("ptrace"));
 162   attach_flag = 1;
 163   return pid;
 164 #else
 165   error (_("This system does not support attaching to a process"));
 166 #endif
 167 }
 168
 169 /* Stop debugging the process whose number is PID and continue it with
 170    signal number SIGNAL.  SIGNAL = 0 means just continue it.  */
 171
 172 void
 173 detach (int signal)
 174 {
 175 #ifdef PT_DETACH
 176   int pid = PIDGET (inferior_ptid);
 177
 178   errno = 0;
 179   ptrace (PT_DETACH, pid, (PTRACE_TYPE_ARG3) 1, signal);
 180   if (errno != 0)
 181     perror_with_name (("ptrace"));
 182   attach_flag = 0;
 183 #else
 184   error (_("This system does not support detaching from a process"));
 185 #endif
 186 }
 187 \f
 188
 189 #ifndef FETCH_INFERIOR_REGISTERS
 190
 191 /* U_REGS_OFFSET is the offset of the registers within the u area.  */
 192 #ifndef U_REGS_OFFSET
 193
 194 #ifndef offsetof
 195 #define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER)
 196 #endif
 197
 198 #define U_REGS_OFFSET \
 199   ptrace (PT_READ_U, PIDGET (inferior_ptid), \
 200           (PTRACE_TYPE_ARG3) (offsetof (struct user, u_ar0)), 0) \
 201     - KERNEL_U_ADDR
 202 #endif
 203
 204 /* Fetch register REGNUM from the inferior.  */
 205
 206 static void
 207 fetch_register (int regnum)
 208 {
 209   CORE_ADDR addr;
 210   size_t size;
 211   PTRACE_TYPE_RET *buf;
 212   int tid, i;
 213
 214   if (CANNOT_FETCH_REGISTER (regnum))
 215     {
 216       regcache_raw_supply (current_regcache, regnum, NULL);
 217       return;
 218     }
 219
 220   /* GNU/Linux LWP ID's are process ID's.  */
 221   tid = TIDGET (inferior_ptid);
 222   if (tid == 0)
 223     tid = PIDGET (inferior_ptid); /* Not a threaded program.  */
 224
 225   /* This isn't really an address.  But ptrace thinks of it as one.  */
 226   addr = register_addr (regnum, U_REGS_OFFSET);
 227   size = register_size (current_gdbarch, regnum);
 228
 229   gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0);
 230   buf = alloca (size);
 231
 232   /* Read the register contents from the inferior a chuck at the time.  */
 233   for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++)
 234     {
 235       errno = 0;
 236       buf[i] = ptrace (PT_READ_U, tid, (PTRACE_TYPE_ARG3) addr, 0);
 237       if (errno != 0)
 238         error (_("Couldn't read register %s (#%d): %s."), REGISTER_NAME (regnum),
 239                regnum, safe_strerror (errno));
 240
 241       addr += sizeof (PTRACE_TYPE_RET);
 242     }
 243   regcache_raw_supply (current_regcache, regnum, buf);
 244 }
 245
 246 /* Fetch register REGNUM from the inferior.  If REGNUM is -1, do this
 247    for all registers.  */
 248
 249 void
 250 fetch_inferior_registers (int regnum)
 251 {
 252   if (regnum == -1)
 253     for (regnum = 0; regnum < NUM_REGS; regnum++)
 254       fetch_register (regnum);
 255   else
 256     fetch_register (regnum);
 257 }
 258
 259 /* Store register REGNUM into the inferior.  */
 260
 261 static void
 262 store_register (int regnum)
 263 {
 264   CORE_ADDR addr;
 265   size_t size;
 266   PTRACE_TYPE_RET *buf;
 267   int tid, i;
 268
 269   if (CANNOT_STORE_REGISTER (regnum))
 270     return;
 271
 272   /* GNU/Linux LWP ID's are process ID's.  */
 273   tid = TIDGET (inferior_ptid);
 274   if (tid == 0)
 275     tid = PIDGET (inferior_ptid); /* Not a threaded program.  */
 276
 277   /* This isn't really an address.  But ptrace thinks of it as one.  */
 278   addr = register_addr (regnum, U_REGS_OFFSET);
 279   size = register_size (current_gdbarch, regnum);
 280
 281   gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0);
 282   buf = alloca (size);
 283
 284   /* Write the register contents into the inferior a chunk at the time.  */
 285   regcache_raw_collect (current_regcache, regnum, buf);
 286   for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++)
 287     {
 288       errno = 0;
 289       ptrace (PT_WRITE_U, tid, (PTRACE_TYPE_ARG3) addr, buf[i]);
 290       if (errno != 0)
 291         error (_("Couldn't write register %s (#%d): %s."),
 292                REGISTER_NAME (regnum), regnum, safe_strerror (errno));
 293
 294       addr += sizeof (PTRACE_TYPE_RET);
 295     }
 296 }
 297
 298 /* Store register REGNUM back into the inferior.  If REGNUM is -1, do
 299    this for all registers (including the floating point registers).  */
 300
 301 void
 302 store_inferior_registers (int regnum)
 303 {
 304   if (regnum == -1)
 305     for (regnum = 0; regnum < NUM_REGS; regnum++)
 306       store_register (regnum);
 307   else
 308     store_register (regnum);
 309 }
 310
 311 #endif /* not FETCH_INFERIOR_REGISTERS.  */
 312 \f
 313
 314 /* Set an upper limit on alloca.  */
 315 #ifndef GDB_MAX_ALLOCA
 316 #define GDB_MAX_ALLOCA 0x1000
 317 #endif
 318
 319 #if !defined (CHILD_XFER_MEMORY)
 320 /* NOTE! I tried using PTRACE_READDATA, etc., to read and write memory
 321    in the NEW_SUN_PTRACE case.  It ought to be straightforward.  But
 322    it appears that writing did not write the data that I specified.  I
 323    cannot understand where it got the data that it actually did write.  */
 324
 325 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR to
 326    debugger memory starting at MYADDR.  Copy to inferior if WRITE is
 327    nonzero.  TARGET is ignored.
 328
 329    Returns the length copied, which is either the LEN argument or
 330    zero.  This xfer function does not do partial moves, since
 331    deprecated_child_ops doesn't allow memory operations to cross below
 332    us in the target stack anyway.  */
 333
 334 int
 335 child_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
 336                    struct mem_attrib *attrib, struct target_ops *target)
 337 {
 338   int i;
 339   /* Round starting address down to longword boundary.  */
 340   CORE_ADDR addr = memaddr & -(CORE_ADDR) sizeof (PTRACE_TYPE_RET);
 341   /* Round ending address up; get number of longwords that makes.  */
 342   int count = ((((memaddr + len) - addr) + sizeof (PTRACE_TYPE_RET) - 1)
 343                / sizeof (PTRACE_TYPE_RET));
 344   int alloc = count * sizeof (PTRACE_TYPE_RET);
 345   PTRACE_TYPE_RET *buffer;
 346   struct cleanup *old_chain = NULL;
 347
 348 #ifdef PT_IO
 349   /* OpenBSD 3.1, NetBSD 1.6 and FreeBSD 5.0 have a new PT_IO request
 350      that promises to be much more efficient in reading and writing
 351      data in the traced process's address space.  */
 352
 353   {
 354     struct ptrace_io_desc piod;
 355
 356     /* NOTE: We assume that there are no distinct address spaces for
 357        instruction and data.  */
 358     piod.piod_op = write ? PIOD_WRITE_D : PIOD_READ_D;
 359     piod.piod_offs = (void *) memaddr;
 360     piod.piod_addr = myaddr;
 361     piod.piod_len = len;
 362
 363     if (ptrace (PT_IO, PIDGET (inferior_ptid), (caddr_t) &piod, 0) == -1)
 364       {
 365         /* If the PT_IO request is somehow not supported, fallback on
 366            using PT_WRITE_D/PT_READ_D.  Otherwise we will return zero
 367            to indicate failure.  */
 368         if (errno != EINVAL)
 369           return 0;
 370       }
 371     else
 372       {
 373         /* Return the actual number of bytes read or written.  */
 374         return piod.piod_len;
 375       }
 376   }
 377 #endif
 378
 379   /* Allocate buffer of that many longwords.  */
 380   if (len < GDB_MAX_ALLOCA)
 381     {
 382       buffer = (PTRACE_TYPE_RET *) alloca (alloc);
 383     }
 384   else
 385     {
 386       buffer = (PTRACE_TYPE_RET *) xmalloc (alloc);
 387       old_chain = make_cleanup (xfree, buffer);
 388     }
 389
 390   if (write)
 391     {
 392       /* Fill start and end extra bytes of buffer with existing memory
 393          data.  */
 394       if (addr != memaddr || len < (int) sizeof (PTRACE_TYPE_RET))
 395         {
 396           /* Need part of initial word -- fetch it.  */
 397           buffer[0] = ptrace (PT_READ_I, PIDGET (inferior_ptid),
 398                               (PTRACE_TYPE_ARG3) addr, 0);
 399         }
 400
 401       if (count > 1)            /* FIXME, avoid if even boundary.  */
 402         {
 403           buffer[count - 1] =
 404             ptrace (PT_READ_I, PIDGET (inferior_ptid),
 405                     ((PTRACE_TYPE_ARG3)
 406                      (addr + (count - 1) * sizeof (PTRACE_TYPE_RET))), 0);
 407         }
 408
 409       /* Copy data to be written over corresponding part of buffer.  */
 410       memcpy ((char *) buffer + (memaddr & (sizeof (PTRACE_TYPE_RET) - 1)),
 411               myaddr, len);
 412
 413       /* Write the entire buffer.  */
 414       for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET))
 415         {
 416           errno = 0;
 417           ptrace (PT_WRITE_D, PIDGET (inferior_ptid),
 418                   (PTRACE_TYPE_ARG3) addr, buffer[i]);
 419           if (errno)
 420             {
 421               /* Using the appropriate one (I or D) is necessary for
 422                  Gould NP1, at least.  */
 423               errno = 0;
 424               ptrace (PT_WRITE_I, PIDGET (inferior_ptid),
 425                       (PTRACE_TYPE_ARG3) addr, buffer[i]);
 426             }
 427           if (errno)
 428             return 0;
 429         }
 430     }
 431   else
 432     {
 433       /* Read all the longwords.  */
 434       for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET))
 435         {
 436           errno = 0;
 437           buffer[i] = ptrace (PT_READ_I, PIDGET (inferior_ptid),
 438                               (PTRACE_TYPE_ARG3) addr, 0);
 439           if (errno)
 440             return 0;
 441           QUIT;
 442         }
 443
 444       /* Copy appropriate bytes out of the buffer.  */
 445       memcpy (myaddr,
 446               (char *) buffer + (memaddr & (sizeof (PTRACE_TYPE_RET) - 1)),
 447               len);
 448     }
 449
 450   if (old_chain != NULL)
 451     do_cleanups (old_chain);
 452   return len;
 453 }
 454 \f
 455
 456 static void
 457 udot_info (char *dummy1, int dummy2)
 458 {
 459 #if defined (KERNEL_U_SIZE)
 460   long udot_off;                        /* Offset into user struct */
 461   int udot_val;                 /* Value from user struct at udot_off */
 462   char mess[128];               /* For messages */
 463 #endif
 464
 465   if (!target_has_execution)
 466     {
 467       error (_("The program is not being run."));
 468     }
 469
 470 #if !defined (KERNEL_U_SIZE)
 471
 472   /* Adding support for this command is easy.  Typically you just add a
 473      routine, called "kernel_u_size" that returns the size of the user
 474      struct, to the appropriate *-nat.c file and then add to the native
 475      config file "#define KERNEL_U_SIZE kernel_u_size()" */
 476   error (_("Don't know how large ``struct user'' is in this version of gdb."));
 477
 478 #else
 479
 480   for (udot_off = 0; udot_off < KERNEL_U_SIZE; udot_off += sizeof (udot_val))
 481     {
 482       if ((udot_off % 24) == 0)
 483         {
 484           if (udot_off > 0)
 485             {
 486               printf_filtered ("\n");
 487             }
 488           printf_filtered ("%s:", paddr (udot_off));
 489         }
 490       udot_val = ptrace (PT_READ_U, PIDGET (inferior_ptid), (PTRACE_TYPE_ARG3) udot_off, 0);
 491       if (errno != 0)
 492         {
 493           sprintf (mess, "\nreading user struct at offset 0x%s",
 494                    paddr_nz (udot_off));
 495           perror_with_name (mess);
 496         }
 497       /* Avoid using nonportable (?) "*" in print specs */
 498       printf_filtered (sizeof (int) == 4 ? " 0x%08x" : " 0x%16x", udot_val);
 499     }
 500   printf_filtered ("\n");
 501
 502 #endif
 503 }
 504 #endif /* !defined (CHILD_XFER_MEMORY).  */
 505 \f
 506
 507 void
 508 _initialize_infptrace (void)
 509 {
 510 #if !defined (CHILD_XFER_MEMORY)
 511   add_info ("udot", udot_info,
 512             _("Print contents of kernel ``struct user'' for current child."));
 513 #endif
 514 }