Automatic date update in version.in
[external/binutils.git] / 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