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 Free Software Foundation, Inc.
   3
   4 This file is part of GDB.
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  19
  20 #include "defs.h"
  21 #include "frame.h"
  22 #include "inferior.h"
  23 #include "target.h"
  24 #include "gdb_string.h"
  25 #include "wait.h"
  26 #include "command.h"
  27
  28 #ifdef USG
  29 #include <sys/types.h>
  30 #endif
  31
  32 #include <sys/param.h>
  33 #include <sys/dir.h>
  34 #include <signal.h>
  35 #include <sys/ioctl.h>
  36
  37 #ifndef NO_PTRACE_H
  38 #ifdef PTRACE_IN_WRONG_PLACE
  39 #include <ptrace.h>
  40 #else
  41 #include <sys/ptrace.h>
  42 #endif
  43 #endif /* NO_PTRACE_H */
  44
  45 #if !defined (PT_READ_I)
  46 #define PT_READ_I       1       /* Read word from text space */
  47 #endif
  48 #if !defined (PT_READ_D)
  49 #define PT_READ_D       2       /* Read word from data space */
  50 #endif
  51 #if !defined (PT_READ_U)
  52 #define PT_READ_U       3       /* Read word from kernel user struct */
  53 #endif
  54 #if !defined (PT_WRITE_I)
  55 #define PT_WRITE_I      4       /* Write word to text space */
  56 #endif
  57 #if !defined (PT_WRITE_D)
  58 #define PT_WRITE_D      5       /* Write word to data space */
  59 #endif
  60 #if !defined (PT_WRITE_U)
  61 #define PT_WRITE_U      6       /* Write word to kernel user struct */
  62 #endif
  63 #if !defined (PT_CONTINUE)
  64 #define PT_CONTINUE     7       /* Continue after signal */
  65 #endif
  66 #if !defined (PT_STEP)
  67 #define PT_STEP         9       /* Set flag for single stepping */
  68 #endif
  69 #if !defined (PT_KILL)
  70 #define PT_KILL         8       /* Send child a SIGKILL signal */
  71 #endif
  72
  73 #ifndef PT_ATTACH
  74 #define PT_ATTACH PTRACE_ATTACH
  75 #endif
  76 #ifndef PT_DETACH
  77 #define PT_DETACH PTRACE_DETACH
  78 #endif
  79
  80 #include "gdbcore.h"
  81 #ifndef NO_SYS_FILE
  82 #include <sys/file.h>
  83 #endif
  84 #if 0
  85 /* Don't think this is used anymore.  On the sequent (not sure whether it's
  86    dynix or ptx or both), it is included unconditionally by sys/user.h and
  87    not protected against multiple inclusion.  */
  88 #include "gdb_stat.h"
  89 #endif
  90
  91 #if !defined (FETCH_INFERIOR_REGISTERS)
  92 #include <sys/user.h>           /* Probably need to poke the user structure */
  93 #if defined (KERNEL_U_ADDR_BSD)
  94 #include <a.out.h>              /* For struct nlist */
  95 #endif /* KERNEL_U_ADDR_BSD.  */
  96 #endif /* !FETCH_INFERIOR_REGISTERS */
  97
  98 \f
  99 /* This function simply calls ptrace with the given arguments.
 100    It exists so that all calls to ptrace are isolated in this
 101    machine-dependent file. */
 102 int
 103 call_ptrace (request, pid, addr, data)
 104      int request, pid;
 105      PTRACE_ARG3_TYPE addr;
 106      int data;
 107 {
 108   return ptrace (request, pid, addr, data
 109 #if defined (FIVE_ARG_PTRACE)
 110                  /* Deal with HPUX 8.0 braindamage.  We never use the
 111                     calls which require the fifth argument.  */
 112                  , 0
 113 #endif
 114                  );
 115 }
 116
 117 #if defined (DEBUG_PTRACE) || defined (FIVE_ARG_PTRACE)
 118 /* For the rest of the file, use an extra level of indirection */
 119 /* This lets us breakpoint usefully on call_ptrace. */
 120 #define ptrace call_ptrace
 121 #endif
 122
 123 void
 124 kill_inferior ()
 125 {
 126   if (inferior_pid == 0)
 127     return;
 128   /* ptrace PT_KILL only works if process is stopped!!!  So stop it with
 129      a real signal first, if we can.  FIXME: This is bogus.  When the inferior
 130      is not stopped, GDB should just be waiting for it.  Either the following
 131      line is unecessary, or there is some problem elsewhere in GDB which
 132      causes us to get here when the inferior is not stopped.  */
 133   kill (inferior_pid, SIGKILL);
 134   ptrace (PT_KILL, inferior_pid, (PTRACE_ARG3_TYPE) 0, 0);
 135   wait ((int *)0);
 136   target_mourn_inferior ();
 137 }
 138
 139 #ifndef CHILD_RESUME
 140
 141 /* Resume execution of the inferior process.
 142    If STEP is nonzero, single-step it.
 143    If SIGNAL is nonzero, give it that signal.  */
 144
 145 void
 146 child_resume (pid, step, signal)
 147      int pid;
 148      int step;
 149      enum target_signal signal;
 150 {
 151   errno = 0;
 152
 153   if (pid == -1)
 154     /* Resume all threads.  */
 155     /* I think this only gets used in the non-threaded case, where "resume
 156        all threads" and "resume inferior_pid" are the same.  */
 157     pid = inferior_pid;
 158
 159   /* An address of (PTRACE_ARG3_TYPE)1 tells ptrace to continue from where
 160      it was.  (If GDB wanted it to start some other way, we have already
 161      written a new PC value to the child.)
 162
 163      If this system does not support PT_STEP, a higher level function will
 164      have called single_step() to transmute the step request into a
 165      continue request (by setting breakpoints on all possible successor
 166      instructions), so we don't have to worry about that here.  */
 167
 168   if (step)
 169     ptrace (PT_STEP,     pid, (PTRACE_ARG3_TYPE) 1,
 170             target_signal_to_host (signal));
 171   else
 172     ptrace (PT_CONTINUE, pid, (PTRACE_ARG3_TYPE) 1,
 173             target_signal_to_host (signal));
 174
 175   if (errno)
 176     perror_with_name ("ptrace");
 177 }
 178 #endif /* CHILD_RESUME */
 179
 180 \f
 181 #ifdef ATTACH_DETACH
 182 /* Start debugging the process whose number is PID.  */
 183 int
 184 attach (pid)
 185      int pid;
 186 {
 187   errno = 0;
 188   ptrace (PT_ATTACH, pid, (PTRACE_ARG3_TYPE) 0, 0);
 189   if (errno)
 190     perror_with_name ("ptrace");
 191   attach_flag = 1;
 192   return pid;
 193 }
 194
 195 /* Stop debugging the process whose number is PID
 196    and continue it with signal number SIGNAL.
 197    SIGNAL = 0 means just continue it.  */
 198
 199 void
 200 detach (signal)
 201      int signal;
 202 {
 203   errno = 0;
 204   ptrace (PT_DETACH, inferior_pid, (PTRACE_ARG3_TYPE) 1, signal);
 205   if (errno)
 206     perror_with_name ("ptrace");
 207   attach_flag = 0;
 208 }
 209 #endif /* ATTACH_DETACH */
 210 \f
 211 /* Default the type of the ptrace transfer to int.  */
 212 #ifndef PTRACE_XFER_TYPE
 213 #define PTRACE_XFER_TYPE int
 214 #endif
 215
 216 /* KERNEL_U_ADDR is the amount to subtract from u.u_ar0
 217    to get the offset in the core file of the register values.  */
 218 #if defined (KERNEL_U_ADDR_BSD) && !defined (FETCH_INFERIOR_REGISTERS)
 219 /* Get kernel_u_addr using BSD-style nlist().  */
 220 CORE_ADDR kernel_u_addr;
 221 #endif /* KERNEL_U_ADDR_BSD.  */
 222
 223 void
 224 _initialize_kernel_u_addr ()
 225 {
 226 #if defined (KERNEL_U_ADDR_BSD) && !defined (FETCH_INFERIOR_REGISTERS)
 227   struct nlist names[2];
 228
 229   names[0].n_un.n_name = "_u";
 230   names[1].n_un.n_name = NULL;
 231   if (nlist ("/vmunix", names) == 0)
 232     kernel_u_addr = names[0].n_value;
 233   else
 234     fatal ("Unable to get kernel u area address.");
 235 #endif /* KERNEL_U_ADDR_BSD.  */
 236 }
 237
 238 #if !defined (FETCH_INFERIOR_REGISTERS)
 239
 240 #if !defined (offsetof)
 241 #define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER)
 242 #endif
 243
 244 /* U_REGS_OFFSET is the offset of the registers within the u area.  */
 245 #if !defined (U_REGS_OFFSET)
 246 #define U_REGS_OFFSET \
 247   ptrace (PT_READ_U, inferior_pid, \
 248           (PTRACE_ARG3_TYPE) (offsetof (struct user, u_ar0)), 0) \
 249     - KERNEL_U_ADDR
 250 #endif
 251
 252 /* Registers we shouldn't try to fetch.  */
 253 #if !defined (CANNOT_FETCH_REGISTER)
 254 #define CANNOT_FETCH_REGISTER(regno) 0
 255 #endif
 256
 257 /* Fetch one register.  */
 258
 259 static void
 260 fetch_register (regno)
 261      int regno;
 262 {
 263   /* This isn't really an address.  But ptrace thinks of it as one.  */
 264   CORE_ADDR regaddr;
 265   char buf[MAX_REGISTER_RAW_SIZE];
 266   char mess[128];                               /* For messages */
 267   register int i;
 268
 269   /* Offset of registers within the u area.  */
 270   unsigned int offset;
 271
 272   if (CANNOT_FETCH_REGISTER (regno))
 273     {
 274       memset (buf, '\0', REGISTER_RAW_SIZE (regno));    /* Supply zeroes */
 275       supply_register (regno, buf);
 276       return;
 277     }
 278
 279   offset = U_REGS_OFFSET;
 280
 281   regaddr = register_addr (regno, offset);
 282   for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (PTRACE_XFER_TYPE))
 283     {
 284       errno = 0;
 285       *(PTRACE_XFER_TYPE *) &buf[i] = ptrace (PT_READ_U, inferior_pid,
 286                                               (PTRACE_ARG3_TYPE) regaddr, 0);
 287       regaddr += sizeof (PTRACE_XFER_TYPE);
 288       if (errno != 0)
 289         {
 290           sprintf (mess, "reading register %s (#%d)", reg_names[regno], regno);
 291           perror_with_name (mess);
 292         }
 293     }
 294   supply_register (regno, buf);
 295 }
 296
 297
 298 /* Fetch all registers, or just one, from the child process.  */
 299
 300 void
 301 fetch_inferior_registers (regno)
 302      int regno;
 303 {
 304   int numregs;
 305
 306   if (regno == -1)
 307     {
 308       numregs = ARCH_NUM_REGS;
 309       for (regno = 0; regno < numregs; regno++)
 310         fetch_register (regno);
 311     }
 312   else
 313     fetch_register (regno);
 314 }
 315
 316 /* Registers we shouldn't try to store.  */
 317 #if !defined (CANNOT_STORE_REGISTER)
 318 #define CANNOT_STORE_REGISTER(regno) 0
 319 #endif
 320
 321 /* Store our register values back into the inferior.
 322    If REGNO is -1, do this for all registers.
 323    Otherwise, REGNO specifies which register (so we can save time).  */
 324
 325 void
 326 store_inferior_registers (regno)
 327      int regno;
 328 {
 329   /* This isn't really an address.  But ptrace thinks of it as one.  */
 330   CORE_ADDR regaddr;
 331   char buf[80];
 332   register int i, numregs;
 333
 334   unsigned int offset = U_REGS_OFFSET;
 335
 336   if (regno >= 0)
 337     {
 338       regaddr = register_addr (regno, offset);
 339       for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof(PTRACE_XFER_TYPE))
 340         {
 341           errno = 0;
 342           ptrace (PT_WRITE_U, inferior_pid, (PTRACE_ARG3_TYPE) regaddr,
 343                   *(PTRACE_XFER_TYPE *) &registers[REGISTER_BYTE (regno) + i]);
 344           if (errno != 0)
 345             {
 346               sprintf (buf, "writing register number %d(%d)", regno, i);
 347               perror_with_name (buf);
 348             }
 349           regaddr += sizeof(PTRACE_XFER_TYPE);
 350         }
 351     }
 352   else
 353     {
 354       numregs = ARCH_NUM_REGS;
 355       for (regno = 0; regno < numregs; regno++)
 356         {
 357           if (CANNOT_STORE_REGISTER (regno))
 358             continue;
 359           regaddr = register_addr (regno, offset);
 360           for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof(PTRACE_XFER_TYPE))
 361             {
 362               errno = 0;
 363               ptrace (PT_WRITE_U, inferior_pid, (PTRACE_ARG3_TYPE) regaddr,
 364                       *(PTRACE_XFER_TYPE *) &registers[REGISTER_BYTE (regno) + i]);
 365               if (errno != 0)
 366                 {
 367                   sprintf (buf, "writing register number %d(%d)", regno, i);
 368                   perror_with_name (buf);
 369                 }
 370               regaddr += sizeof(PTRACE_XFER_TYPE);
 371             }
 372         }
 373     }
 374 }
 375 #endif /* !defined (FETCH_INFERIOR_REGISTERS).  */
 376 \f
 377
 378 #if !defined (CHILD_XFER_MEMORY)
 379 /* NOTE! I tried using PTRACE_READDATA, etc., to read and write memory
 380    in the NEW_SUN_PTRACE case.
 381    It ought to be straightforward.  But it appears that writing did
 382    not write the data that I specified.  I cannot understand where
 383    it got the data that it actually did write.  */
 384
 385 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
 386    to debugger memory starting at MYADDR.   Copy to inferior if
 387    WRITE is nonzero.
 388
 389    Returns the length copied, which is either the LEN argument or zero.
 390    This xfer function does not do partial moves, since child_ops
 391    doesn't allow memory operations to cross below us in the target stack
 392    anyway.  */
 393
 394 int
 395 child_xfer_memory (memaddr, myaddr, len, write, target)
 396      CORE_ADDR memaddr;
 397      char *myaddr;
 398      int len;
 399      int write;
 400      struct target_ops *target;         /* ignored */
 401 {
 402   register int i;
 403   /* Round starting address down to longword boundary.  */
 404   register CORE_ADDR addr = memaddr & - sizeof (PTRACE_XFER_TYPE);
 405   /* Round ending address up; get number of longwords that makes.  */
 406   register int count
 407     = (((memaddr + len) - addr) + sizeof (PTRACE_XFER_TYPE) - 1)
 408       / sizeof (PTRACE_XFER_TYPE);
 409   /* Allocate buffer of that many longwords.  */
 410   register PTRACE_XFER_TYPE *buffer
 411     = (PTRACE_XFER_TYPE *) alloca (count * sizeof (PTRACE_XFER_TYPE));
 412
 413   if (write)
 414     {
 415       /* Fill start and end extra bytes of buffer with existing memory data.  */
 416
 417       if (addr != memaddr || len < (int) sizeof (PTRACE_XFER_TYPE)) {
 418         /* Need part of initial word -- fetch it.  */
 419         buffer[0] = ptrace (PT_READ_I, inferior_pid, (PTRACE_ARG3_TYPE) addr,
 420                             0);
 421       }
 422
 423       if (count > 1)            /* FIXME, avoid if even boundary */
 424         {
 425           buffer[count - 1]
 426             = ptrace (PT_READ_I, inferior_pid,
 427                       ((PTRACE_ARG3_TYPE)
 428                        (addr + (count - 1) * sizeof (PTRACE_XFER_TYPE))),
 429                       0);
 430         }
 431
 432       /* Copy data to be written over corresponding part of buffer */
 433
 434       memcpy ((char *) buffer + (memaddr & (sizeof (PTRACE_XFER_TYPE) - 1)),
 435               myaddr,
 436               len);
 437
 438       /* Write the entire buffer.  */
 439
 440       for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE))
 441         {
 442           errno = 0;
 443           ptrace (PT_WRITE_D, inferior_pid, (PTRACE_ARG3_TYPE) addr,
 444                   buffer[i]);
 445           if (errno)
 446             {
 447               /* Using the appropriate one (I or D) is necessary for
 448                  Gould NP1, at least.  */
 449               errno = 0;
 450               ptrace (PT_WRITE_I, inferior_pid, (PTRACE_ARG3_TYPE) addr,
 451                       buffer[i]);
 452             }
 453           if (errno)
 454             return 0;
 455         }
 456     }
 457   else
 458     {
 459       /* Read all the longwords */
 460       for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE))
 461         {
 462           errno = 0;
 463           buffer[i] = ptrace (PT_READ_I, inferior_pid,
 464                               (PTRACE_ARG3_TYPE) addr, 0);
 465           if (errno)
 466             return 0;
 467           QUIT;
 468         }
 469
 470       /* Copy appropriate bytes out of the buffer.  */
 471       memcpy (myaddr,
 472               (char *) buffer + (memaddr & (sizeof (PTRACE_XFER_TYPE) - 1)),
 473               len);
 474     }
 475   return len;
 476 }
 477
 478 \f
 479 static void
 480 udot_info ()
 481 {
 482   int udot_off;         /* Offset into user struct */
 483   int udot_val;         /* Value from user struct at udot_off */
 484   char mess[128];       /* For messages */
 485
 486    if (!target_has_execution)
 487      {
 488        error ("The program is not being run.");
 489      }
 490
 491 #if !defined (KERNEL_U_SIZE)
 492
 493   /* Adding support for this command is easy.  Typically you just add a
 494      routine, called "kernel_u_size" that returns the size of the user
 495      struct, to the appropriate *-nat.c file and then add to the native
 496      config file "#define KERNEL_U_SIZE kernel_u_size()" */
 497   error ("Don't know how large ``struct user'' is in this version of gdb.");
 498
 499 #else
 500
 501   for (udot_off = 0; udot_off < KERNEL_U_SIZE; udot_off += sizeof (udot_val))
 502     {
 503       if ((udot_off % 24) == 0)
 504         {
 505           if (udot_off > 0)
 506             {
 507               printf_filtered ("\n");
 508             }
 509           printf_filtered ("%04x:", udot_off);
 510         }
 511       udot_val = ptrace (PT_READ_U, inferior_pid, (PTRACE_ARG3_TYPE) udot_off, 0);
 512       if (errno != 0)
 513         {
 514           sprintf (mess, "\nreading user struct at offset 0x%x", udot_off);
 515           perror_with_name (mess);
 516         }
 517       /* Avoid using nonportable (?) "*" in print specs */
 518       printf_filtered (sizeof (int) == 4 ? " 0x%08x" : " 0x%16x", udot_val);
 519     }
 520   printf_filtered ("\n");
 521
 522 #endif
 523 }
 524 #endif /* !defined (CHILD_XFER_MEMORY).  */
 525
 526 \f
 527 void
 528 _initialize_infptrace ()
 529 {
 530 #if !defined (CHILD_XFER_MEMORY)
 531   add_info ("udot", udot_info,
 532             "Print contents of kernel ``struct user'' for current child.");
 533 #endif
 534 }