gdb/obsd-nat.c - gdb

Functions defined

Source code

  1. /* Native-dependent code for OpenBSD.

  3.    Copyright (C) 2012-2015 Free Software Foundation, Inc.

  5.    This file is part of GDB.

  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.

  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.

  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/>.  */

  20. #include "defs.h"
  21. #include "gdbthread.h"
  22. #include "inferior.h"
  23. #include "target.h"

  25. #include <sys/types.h>
  26. #include <sys/ptrace.h>
  27. #include "gdb_wait.h"

  29. #include "inf-child.h"
  30. #include "obsd-nat.h"

  32. /* OpenBSD 5.2 and later include rthreads which uses a thread model
  33.    that maps userland threads directly onto kernel threads in a 1:1
  34.    fashion.  */

  36. #ifdef PT_GET_THREAD_FIRST

  38. static char *
  39. ‌obsd_pid_to_str (struct target_ops *ops, ptid_t ptid)
  40. {
  41.   if (ptid_get_lwp (ptid) != 0)
  42.     {
  43.       static char buf[64];

  45.       xsnprintf (buf, sizeof buf, "thread %ld", ptid_get_lwp (ptid));
  46.       return buf;
  47.     }

  49.   return normal_pid_to_str (ptid);
  50. }

  52. static void
  53. ‌obsd_update_thread_list (struct target_ops *ops)
  54. {
  55.   pid_t pid = ptid_get_pid (inferior_ptid);
  56.   struct ptrace_thread_state pts;

  58.   prune_threads ();

  60.   if (ptrace (PT_GET_THREAD_FIRST, pid, (caddr_t)&pts, sizeof pts) == -1)
  61.     perror_with_name (("ptrace"));

  63.   while (pts.pts_tid != -1)
  64.     {
  65.       ptid_t ptid = ptid_build (pid, pts.pts_tid, 0);

  67.       if (!in_thread_list (ptid))
  68.         {
  69.           if (ptid_get_lwp (inferior_ptid) == 0)
  70.             thread_change_ptid (inferior_ptid, ptid);
  71.           else
  72.             add_thread (ptid);
  73.         }

  75.       if (ptrace (PT_GET_THREAD_NEXT, pid, (caddr_t)&pts, sizeof pts) == -1)
  76.         perror_with_name (("ptrace"));
  77.     }
  78. }

  80. static ptid_t
  81. ‌obsd_wait (struct target_ops *ops,
  82.            ptid_t ptid, struct target_waitstatus *ourstatus, int options)
  83. {
  84.   pid_t pid;
  85.   int status, save_errno;

  87.   do
  88.     {
  89.       set_sigint_trap ();

  91.       do
  92.         {
  93.           pid = waitpid (ptid_get_pid (ptid), &status, 0);
  94.           save_errno = errno;
  95.         }
  96.       while (pid == -1 && errno == EINTR);

  98.       clear_sigint_trap ();

  100.       if (pid == -1)
  101.         {
  102.           fprintf_unfiltered (gdb_stderr,
  103.                               _("Child process unexpectedly missing: %s.\n"),
  104.                               safe_strerror (save_errno));

  106.           /* Claim it exited with unknown signal.  */
  107.           ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
  108.           ourstatus->value.sig = GDB_SIGNAL_UNKNOWN;
  109.           return inferior_ptid;
  110.         }

  112.       /* Ignore terminated detached child processes.  */
  113.       if (!WIFSTOPPED (status) && pid != ptid_get_pid (inferior_ptid))
  114.         pid = -1;
  115.     }
  116.   while (pid == -1);

  118.   ptid = pid_to_ptid (pid);

  120.   if (WIFSTOPPED (status))
  121.     {
  122.       ptrace_state_t pe;
  123.       pid_t fpid;

  125.       if (ptrace (PT_GET_PROCESS_STATE, pid, (caddr_t)&pe, sizeof pe) == -1)
  126.         perror_with_name (("ptrace"));

  128.       switch (pe.pe_report_event)
  129.         {
  130.         case PTRACE_FORK:
  131.           ourstatus->kind = TARGET_WAITKIND_FORKED;
  132.           ourstatus->value.related_pid = pid_to_ptid (pe.pe_other_pid);

  134.           /* Make sure the other end of the fork is stopped too.  */
  135.           fpid = waitpid (pe.pe_other_pid, &status, 0);
  136.           if (fpid == -1)
  137.             perror_with_name (("waitpid"));

  139.           if (ptrace (PT_GET_PROCESS_STATE, fpid,
  140.                       (caddr_t)&pe, sizeof pe) == -1)
  141.             perror_with_name (("ptrace"));

  143.           gdb_assert (pe.pe_report_event == PTRACE_FORK);
  144.           gdb_assert (pe.pe_other_pid == pid);
  145.           if (fpid == ptid_get_pid (inferior_ptid))
  146.             {
  147.               ourstatus->value.related_pid = pid_to_ptid (pe.pe_other_pid);
  148.               return pid_to_ptid (fpid);
  149.             }

  151.           return pid_to_ptid (pid);
  152.         }

  154.       ptid = ptid_build (pid, pe.pe_tid, 0);
  155.       if (!in_thread_list (ptid))
  156.         {
  157.           if (ptid_get_lwp (inferior_ptid) == 0)
  158.             thread_change_ptid (inferior_ptid, ptid);
  159.           else
  160.             add_thread (ptid);
  161.         }
  162.     }

  164.   store_waitstatus (ourstatus, status);
  165.   return ptid;
  166. }

  168. void
  169. ‌obsd_add_target (struct target_ops *t)
  170. {
  171.   /* Override some methods to support threads.  */
  172.   t->to_pid_to_str = obsd_pid_to_str;
  173.   t->to_update_thread_list = obsd_update_thread_list;
  174.   t->to_wait = obsd_wait;
  175.   add_target (t);
  176. }

  178. #else

  180. void
  181. ‌obsd_add_target (struct target_ops *t)
  182. {
  183.   add_target (t);
  184. }

  186. #endif /* PT_GET_THREAD_FIRST */