gdb/infptrace.c

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