gdb/inf-ptrace.c

   1 /* Low-level child interface to ptrace.
   2
   3    Copyright (C) 1988-2018 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 3 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, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "command.h"
  22 #include "inferior.h"
  23 #include "inflow.h"
  24 #include "terminal.h"
  25 #include "gdbcore.h"
  26 #include "regcache.h"
  27 #include "nat/gdb_ptrace.h"
  28 #include "gdb_wait.h"
  29 #include <signal.h>
  30
  31 #include "inf-ptrace.h"
  32 #include "inf-child.h"
  33 #include "gdbthread.h"
  34 #include "nat/fork-inferior.h"
  35 #include "utils.h"
  36
  37 \f
  38
  39 /* A unique_ptr helper to unpush a target.  */
  40
  41 struct target_unpusher
  42 {
  43   void operator() (struct target_ops *ops) const
  44   {
  45     unpush_target (ops);
  46   }
  47 };
  48
  49 /* A unique_ptr that unpushes a target on destruction.  */
  50
  51 typedef std::unique_ptr<struct target_ops, target_unpusher> target_unpush_up;
  52
  53 \f
  54
  55 inf_ptrace_target::~inf_ptrace_target ()
  56 {}
  57
  58 #ifdef PT_GET_PROCESS_STATE
  59
  60 /* Target hook for follow_fork.  On entry and at return inferior_ptid is
  61    the ptid of the followed inferior.  */
  62
  63 int
  64 inf_ptrace_target::follow_fork (int follow_child, int detach_fork)
  65 {
  66   if (!follow_child)
  67     {
  68       struct thread_info *tp = inferior_thread ();
  69       pid_t child_pid = tp->pending_follow.value.related_pid.pid ();
  70
  71       /* Breakpoints have already been detached from the child by
  72          infrun.c.  */
  73
  74       if (ptrace (PT_DETACH, child_pid, (PTRACE_TYPE_ARG3)1, 0) == -1)
  75         perror_with_name (("ptrace"));
  76     }
  77
  78   return 0;
  79 }
  80
  81 int
  82 inf_ptrace_target::insert_fork_catchpoint (int pid)
  83 {
  84   return 0;
  85 }
  86
  87 int
  88 inf_ptrace_target::remove_fork_catchpoint (int pid)
  89 {
  90   return 0;
  91 }
  92
  93 #endif /* PT_GET_PROCESS_STATE */
  94 \f
  95
  96 /* Prepare to be traced.  */
  97
  98 static void
  99 inf_ptrace_me (void)
 100 {
 101   /* "Trace me, Dr. Memory!"  */
 102   if (ptrace (PT_TRACE_ME, 0, (PTRACE_TYPE_ARG3) 0, 0) < 0)
 103     trace_start_error_with_name ("ptrace");
 104 }
 105
 106 /* Start a new inferior Unix child process.  EXEC_FILE is the file to
 107    run, ALLARGS is a string containing the arguments to the program.
 108    ENV is the environment vector to pass.  If FROM_TTY is non-zero, be
 109    chatty about it.  */
 110
 111 void
 112 inf_ptrace_target::create_inferior (const char *exec_file,
 113                                     const std::string &allargs,
 114                                     char **env, int from_tty)
 115 {
 116   pid_t pid;
 117   ptid_t ptid;
 118
 119   /* Do not change either targets above or the same target if already present.
 120      The reason is the target stack is shared across multiple inferiors.  */
 121   int ops_already_pushed = target_is_pushed (this);
 122
 123   target_unpush_up unpusher;
 124   if (! ops_already_pushed)
 125     {
 126       /* Clear possible core file with its process_stratum.  */
 127       push_target (this);
 128       unpusher.reset (this);
 129     }
 130
 131   pid = fork_inferior (exec_file, allargs, env, inf_ptrace_me, NULL,
 132                        NULL, NULL, NULL);
 133
 134   ptid = ptid_t (pid);
 135   /* We have something that executes now.  We'll be running through
 136      the shell at this point (if startup-with-shell is true), but the
 137      pid shouldn't change.  */
 138   add_thread_silent (ptid);
 139
 140   unpusher.release ();
 141
 142   gdb_startup_inferior (pid, START_INFERIOR_TRAPS_EXPECTED);
 143
 144   /* On some targets, there must be some explicit actions taken after
 145      the inferior has been started up.  */
 146   target_post_startup_inferior (ptid);
 147 }
 148
 149 #ifdef PT_GET_PROCESS_STATE
 150
 151 void
 152 inf_ptrace_target::post_startup_inferior (ptid_t pid)
 153 {
 154   ptrace_event_t pe;
 155
 156   /* Set the initial event mask.  */
 157   memset (&pe, 0, sizeof pe);
 158   pe.pe_set_event |= PTRACE_FORK;
 159   if (ptrace (PT_SET_EVENT_MASK, pid.pid (),
 160               (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
 161     perror_with_name (("ptrace"));
 162 }
 163
 164 #endif
 165
 166 /* Clean up a rotting corpse of an inferior after it died.  */
 167
 168 void
 169 inf_ptrace_target::mourn_inferior ()
 170 {
 171   int status;
 172
 173   /* Wait just one more time to collect the inferior's exit status.
 174      Do not check whether this succeeds though, since we may be
 175      dealing with a process that we attached to.  Such a process will
 176      only report its exit status to its original parent.  */
 177   waitpid (inferior_ptid.pid (), &status, 0);
 178
 179   inf_child_target::mourn_inferior ();
 180 }
 181
 182 /* Attach to the process specified by ARGS.  If FROM_TTY is non-zero,
 183    be chatty about it.  */
 184
 185 void
 186 inf_ptrace_target::attach (const char *args, int from_tty)
 187 {
 188   char *exec_file;
 189   pid_t pid;
 190   struct inferior *inf;
 191
 192   /* Do not change either targets above or the same target if already present.
 193      The reason is the target stack is shared across multiple inferiors.  */
 194   int ops_already_pushed = target_is_pushed (this);
 195
 196   pid = parse_pid_to_attach (args);
 197
 198   if (pid == getpid ())         /* Trying to masturbate?  */
 199     error (_("I refuse to debug myself!"));
 200
 201   target_unpush_up unpusher;
 202   if (! ops_already_pushed)
 203     {
 204       /* target_pid_to_str already uses the target.  Also clear possible core
 205          file with its process_stratum.  */
 206       push_target (this);
 207       unpusher.reset (this);
 208     }
 209
 210   if (from_tty)
 211     {
 212       exec_file = get_exec_file (0);
 213
 214       if (exec_file)
 215         printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file,
 216                            target_pid_to_str (ptid_t (pid)));
 217       else
 218         printf_unfiltered (_("Attaching to %s\n"),
 219                            target_pid_to_str (ptid_t (pid)));
 220
 221       gdb_flush (gdb_stdout);
 222     }
 223
 224 #ifdef PT_ATTACH
 225   errno = 0;
 226   ptrace (PT_ATTACH, pid, (PTRACE_TYPE_ARG3)0, 0);
 227   if (errno != 0)
 228     perror_with_name (("ptrace"));
 229 #else
 230   error (_("This system does not support attaching to a process"));
 231 #endif
 232
 233   inf = current_inferior ();
 234   inferior_appeared (inf, pid);
 235   inf->attach_flag = 1;
 236   inferior_ptid = ptid_t (pid);
 237
 238   /* Always add a main thread.  If some target extends the ptrace
 239      target, it should decorate the ptid later with more info.  */
 240   thread_info *thr = add_thread_silent (inferior_ptid);
 241   /* Don't consider the thread stopped until we've processed its
 242      initial SIGSTOP stop.  */
 243   set_executing (thr->ptid, true);
 244
 245   unpusher.release ();
 246 }
 247
 248 #ifdef PT_GET_PROCESS_STATE
 249
 250 void
 251 inf_ptrace_target::post_attach (int pid)
 252 {
 253   ptrace_event_t pe;
 254
 255   /* Set the initial event mask.  */
 256   memset (&pe, 0, sizeof pe);
 257   pe.pe_set_event |= PTRACE_FORK;
 258   if (ptrace (PT_SET_EVENT_MASK, pid,
 259               (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
 260     perror_with_name (("ptrace"));
 261 }
 262
 263 #endif
 264
 265 /* Detach from the inferior.  If FROM_TTY is non-zero, be chatty about it.  */
 266
 267 void
 268 inf_ptrace_target::detach (inferior *inf, int from_tty)
 269 {
 270   pid_t pid = inferior_ptid.pid ();
 271
 272   target_announce_detach (from_tty);
 273
 274 #ifdef PT_DETACH
 275   /* We'd better not have left any breakpoints in the program or it'll
 276      die when it hits one.  Also note that this may only work if we
 277      previously attached to the inferior.  It *might* work if we
 278      started the process ourselves.  */
 279   errno = 0;
 280   ptrace (PT_DETACH, pid, (PTRACE_TYPE_ARG3)1, 0);
 281   if (errno != 0)
 282     perror_with_name (("ptrace"));
 283 #else
 284   error (_("This system does not support detaching from a process"));
 285 #endif
 286
 287   detach_success (inf);
 288 }
 289
 290 /* See inf-ptrace.h.  */
 291
 292 void
 293 inf_ptrace_target::detach_success (inferior *inf)
 294 {
 295   inferior_ptid = null_ptid;
 296   detach_inferior (inf);
 297
 298   maybe_unpush_target ();
 299 }
 300
 301 /* Kill the inferior.  */
 302
 303 void
 304 inf_ptrace_target::kill ()
 305 {
 306   pid_t pid = inferior_ptid.pid ();
 307   int status;
 308
 309   if (pid == 0)
 310     return;
 311
 312   ptrace (PT_KILL, pid, (PTRACE_TYPE_ARG3)0, 0);
 313   waitpid (pid, &status, 0);
 314
 315   target_mourn_inferior (inferior_ptid);
 316 }
 317
 318 /* Return which PID to pass to ptrace in order to observe/control the
 319    tracee identified by PTID.  */
 320
 321 pid_t
 322 get_ptrace_pid (ptid_t ptid)
 323 {
 324   pid_t pid;
 325
 326   /* If we have an LWPID to work with, use it.  Otherwise, we're
 327      dealing with a non-threaded program/target.  */
 328   pid = ptid.lwp ();
 329   if (pid == 0)
 330     pid = ptid.pid ();
 331   return pid;
 332 }
 333
 334 /* Resume execution of thread PTID, or all threads if PTID is -1.  If
 335    STEP is nonzero, single-step it.  If SIGNAL is nonzero, give it
 336    that signal.  */
 337
 338 void
 339 inf_ptrace_target::resume (ptid_t ptid, int step, enum gdb_signal signal)
 340 {
 341   pid_t pid;
 342   int request;
 343
 344   if (minus_one_ptid == ptid)
 345     /* Resume all threads.  Traditionally ptrace() only supports
 346        single-threaded processes, so simply resume the inferior.  */
 347     pid = inferior_ptid.pid ();
 348   else
 349     pid = get_ptrace_pid (ptid);
 350
 351   if (catch_syscall_enabled () > 0)
 352     request = PT_SYSCALL;
 353   else
 354     request = PT_CONTINUE;
 355
 356   if (step)
 357     {
 358       /* If this system does not support PT_STEP, a higher level
 359          function will have called single_step() to transmute the step
 360          request into a continue request (by setting breakpoints on
 361          all possible successor instructions), so we don't have to
 362          worry about that here.  */
 363       request = PT_STEP;
 364     }
 365
 366   /* An address of (PTRACE_TYPE_ARG3)1 tells ptrace to continue from
 367      where it was.  If GDB wanted it to start some other way, we have
 368      already written a new program counter value to the child.  */
 369   errno = 0;
 370   ptrace (request, pid, (PTRACE_TYPE_ARG3)1, gdb_signal_to_host (signal));
 371   if (errno != 0)
 372     perror_with_name (("ptrace"));
 373 }
 374
 375 /* Wait for the child specified by PTID to do something.  Return the
 376    process ID of the child, or MINUS_ONE_PTID in case of error; store
 377    the status in *OURSTATUS.  */
 378
 379 ptid_t
 380 inf_ptrace_target::wait (ptid_t ptid, struct target_waitstatus *ourstatus,
 381                          int options)
 382 {
 383   pid_t pid;
 384   int status, save_errno;
 385
 386   do
 387     {
 388       set_sigint_trap ();
 389
 390       do
 391         {
 392           pid = waitpid (ptid.pid (), &status, 0);
 393           save_errno = errno;
 394         }
 395       while (pid == -1 && errno == EINTR);
 396
 397       clear_sigint_trap ();
 398
 399       if (pid == -1)
 400         {
 401           fprintf_unfiltered (gdb_stderr,
 402                               _("Child process unexpectedly missing: %s.\n"),
 403                               safe_strerror (save_errno));
 404
 405           /* Claim it exited with unknown signal.  */
 406           ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
 407           ourstatus->value.sig = GDB_SIGNAL_UNKNOWN;
 408           return inferior_ptid;
 409         }
 410
 411       /* Ignore terminated detached child processes.  */
 412       if (!WIFSTOPPED (status) && pid != inferior_ptid.pid ())
 413         pid = -1;
 414     }
 415   while (pid == -1);
 416
 417 #ifdef PT_GET_PROCESS_STATE
 418   if (WIFSTOPPED (status))
 419     {
 420       ptrace_state_t pe;
 421       pid_t fpid;
 422
 423       if (ptrace (PT_GET_PROCESS_STATE, pid,
 424                   (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
 425         perror_with_name (("ptrace"));
 426
 427       switch (pe.pe_report_event)
 428         {
 429         case PTRACE_FORK:
 430           ourstatus->kind = TARGET_WAITKIND_FORKED;
 431           ourstatus->value.related_pid = ptid_t (pe.pe_other_pid);
 432
 433           /* Make sure the other end of the fork is stopped too.  */
 434           fpid = waitpid (pe.pe_other_pid, &status, 0);
 435           if (fpid == -1)
 436             perror_with_name (("waitpid"));
 437
 438           if (ptrace (PT_GET_PROCESS_STATE, fpid,
 439                       (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1)
 440             perror_with_name (("ptrace"));
 441
 442           gdb_assert (pe.pe_report_event == PTRACE_FORK);
 443           gdb_assert (pe.pe_other_pid == pid);
 444           if (fpid == inferior_ptid.pid ())
 445             {
 446               ourstatus->value.related_pid = ptid_t (pe.pe_other_pid);
 447               return ptid_t (fpid);
 448             }
 449
 450           return ptid_t (pid);
 451         }
 452     }
 453 #endif
 454
 455   store_waitstatus (ourstatus, status);
 456   return ptid_t (pid);
 457 }
 458
 459 /* Transfer data via ptrace into process PID's memory from WRITEBUF, or
 460    from process PID's memory into READBUF.  Start at target address ADDR
 461    and transfer up to LEN bytes.  Exactly one of READBUF and WRITEBUF must
 462    be non-null.  Return the number of transferred bytes.  */
 463
 464 static ULONGEST
 465 inf_ptrace_peek_poke (pid_t pid, gdb_byte *readbuf,
 466                       const gdb_byte *writebuf,
 467                       ULONGEST addr, ULONGEST len)
 468 {
 469   ULONGEST n;
 470   unsigned int chunk;
 471
 472   /* We transfer aligned words.  Thus align ADDR down to a word
 473      boundary and determine how many bytes to skip at the
 474      beginning.  */
 475   ULONGEST skip = addr & (sizeof (PTRACE_TYPE_RET) - 1);
 476   addr -= skip;
 477
 478   for (n = 0;
 479        n < len;
 480        n += chunk, addr += sizeof (PTRACE_TYPE_RET), skip = 0)
 481     {
 482       /* Restrict to a chunk that fits in the current word.  */
 483       chunk = std::min (sizeof (PTRACE_TYPE_RET) - skip, len - n);
 484
 485       /* Use a union for type punning.  */
 486       union
 487       {
 488         PTRACE_TYPE_RET word;
 489         gdb_byte byte[sizeof (PTRACE_TYPE_RET)];
 490       } buf;
 491
 492       /* Read the word, also when doing a partial word write.  */
 493       if (readbuf != NULL || chunk < sizeof (PTRACE_TYPE_RET))
 494         {
 495           errno = 0;
 496           buf.word = ptrace (PT_READ_I, pid,
 497                              (PTRACE_TYPE_ARG3)(uintptr_t) addr, 0);
 498           if (errno != 0)
 499             break;
 500           if (readbuf != NULL)
 501             memcpy (readbuf + n, buf.byte + skip, chunk);
 502         }
 503       if (writebuf != NULL)
 504         {
 505           memcpy (buf.byte + skip, writebuf + n, chunk);
 506           errno = 0;
 507           ptrace (PT_WRITE_D, pid, (PTRACE_TYPE_ARG3)(uintptr_t) addr,
 508                   buf.word);
 509           if (errno != 0)
 510             {
 511               /* Using the appropriate one (I or D) is necessary for
 512                  Gould NP1, at least.  */
 513               errno = 0;
 514               ptrace (PT_WRITE_I, pid, (PTRACE_TYPE_ARG3)(uintptr_t) addr,
 515                       buf.word);
 516               if (errno != 0)
 517                 break;
 518             }
 519         }
 520     }
 521
 522   return n;
 523 }
 524
 525 /* Implement the to_xfer_partial target_ops method.  */
 526
 527 enum target_xfer_status
 528 inf_ptrace_target::xfer_partial (enum target_object object,
 529                                  const char *annex, gdb_byte *readbuf,
 530                                  const gdb_byte *writebuf,
 531                                  ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
 532 {
 533   pid_t pid = get_ptrace_pid (inferior_ptid);
 534
 535   switch (object)
 536     {
 537     case TARGET_OBJECT_MEMORY:
 538 #ifdef PT_IO
 539       /* OpenBSD 3.1, NetBSD 1.6 and FreeBSD 5.0 have a new PT_IO
 540          request that promises to be much more efficient in reading
 541          and writing data in the traced process's address space.  */
 542       {
 543         struct ptrace_io_desc piod;
 544
 545         /* NOTE: We assume that there are no distinct address spaces
 546            for instruction and data.  However, on OpenBSD 3.9 and
 547            later, PIOD_WRITE_D doesn't allow changing memory that's
 548            mapped read-only.  Since most code segments will be
 549            read-only, using PIOD_WRITE_D will prevent us from
 550            inserting breakpoints, so we use PIOD_WRITE_I instead.  */
 551         piod.piod_op = writebuf ? PIOD_WRITE_I : PIOD_READ_D;
 552         piod.piod_addr = writebuf ? (void *) writebuf : readbuf;
 553         piod.piod_offs = (void *) (long) offset;
 554         piod.piod_len = len;
 555
 556         errno = 0;
 557         if (ptrace (PT_IO, pid, (caddr_t)&piod, 0) == 0)
 558           {
 559             /* Return the actual number of bytes read or written.  */
 560             *xfered_len = piod.piod_len;
 561             return (piod.piod_len == 0) ? TARGET_XFER_EOF : TARGET_XFER_OK;
 562           }
 563         /* If the PT_IO request is somehow not supported, fallback on
 564            using PT_WRITE_D/PT_READ_D.  Otherwise we will return zero
 565            to indicate failure.  */
 566         if (errno != EINVAL)
 567           return TARGET_XFER_EOF;
 568       }
 569 #endif
 570       *xfered_len = inf_ptrace_peek_poke (pid, readbuf, writebuf,
 571                                           offset, len);
 572       return *xfered_len != 0 ? TARGET_XFER_OK : TARGET_XFER_EOF;
 573
 574     case TARGET_OBJECT_UNWIND_TABLE:
 575       return TARGET_XFER_E_IO;
 576
 577     case TARGET_OBJECT_AUXV:
 578 #if defined (PT_IO) && defined (PIOD_READ_AUXV)
 579       /* OpenBSD 4.5 has a new PIOD_READ_AUXV operation for the PT_IO
 580          request that allows us to read the auxilliary vector.  Other
 581          BSD's may follow if they feel the need to support PIE.  */
 582       {
 583         struct ptrace_io_desc piod;
 584
 585         if (writebuf)
 586           return TARGET_XFER_E_IO;
 587         piod.piod_op = PIOD_READ_AUXV;
 588         piod.piod_addr = readbuf;
 589         piod.piod_offs = (void *) (long) offset;
 590         piod.piod_len = len;
 591
 592         errno = 0;
 593         if (ptrace (PT_IO, pid, (caddr_t)&piod, 0) == 0)
 594           {
 595             /* Return the actual number of bytes read or written.  */
 596             *xfered_len = piod.piod_len;
 597             return (piod.piod_len == 0) ? TARGET_XFER_EOF : TARGET_XFER_OK;
 598           }
 599       }
 600 #endif
 601       return TARGET_XFER_E_IO;
 602
 603     case TARGET_OBJECT_WCOOKIE:
 604       return TARGET_XFER_E_IO;
 605
 606     default:
 607       return TARGET_XFER_E_IO;
 608     }
 609 }
 610
 611 /* Return non-zero if the thread specified by PTID is alive.  */
 612
 613 bool
 614 inf_ptrace_target::thread_alive (ptid_t ptid)
 615 {
 616   /* ??? Is kill the right way to do this?  */
 617   return (::kill (ptid.pid (), 0) != -1);
 618 }
 619
 620 /* Print status information about what we're accessing.  */
 621
 622 void
 623 inf_ptrace_target::files_info ()
 624 {
 625   struct inferior *inf = current_inferior ();
 626
 627   printf_filtered (_("\tUsing the running image of %s %s.\n"),
 628                    inf->attach_flag ? "attached" : "child",
 629                    target_pid_to_str (inferior_ptid));
 630 }
 631
 632 const char *
 633 inf_ptrace_target::pid_to_str (ptid_t ptid)
 634 {
 635   return normal_pid_to_str (ptid);
 636 }
 637
 638 #if defined (PT_IO) && defined (PIOD_READ_AUXV)
 639
 640 /* Read one auxv entry from *READPTR, not reading locations >= ENDPTR.
 641    Return 0 if *READPTR is already at the end of the buffer.
 642    Return -1 if there is insufficient buffer for a whole entry.
 643    Return 1 if an entry was read into *TYPEP and *VALP.  */
 644
 645 int
 646 inf_ptrace_target::auxv_parse (gdb_byte **readptr, gdb_byte *endptr,
 647                                CORE_ADDR *typep, CORE_ADDR *valp)
 648 {
 649   struct type *int_type = builtin_type (target_gdbarch ())->builtin_int;
 650   struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
 651   const int sizeof_auxv_type = TYPE_LENGTH (int_type);
 652   const int sizeof_auxv_val = TYPE_LENGTH (ptr_type);
 653   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
 654   gdb_byte *ptr = *readptr;
 655
 656   if (endptr == ptr)
 657     return 0;
 658
 659   if (endptr - ptr < 2 * sizeof_auxv_val)
 660     return -1;
 661
 662   *typep = extract_unsigned_integer (ptr, sizeof_auxv_type, byte_order);
 663   ptr += sizeof_auxv_val;       /* Alignment.  */
 664   *valp = extract_unsigned_integer (ptr, sizeof_auxv_val, byte_order);
 665   ptr += sizeof_auxv_val;
 666
 667   *readptr = ptr;
 668   return 1;
 669 }
 670
 671 #endif
 672 \f