gdb/inf-ptrace.c

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