[thirdparty/binutils-gdb.git] / gdb / nat / linux-ptrace.c

/* Linux-specific ptrace manipulation routines.
   Copyright (C) 2012-2015 Free Software Foundation, Inc.

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

#include "common-defs.h"
#include "linux-ptrace.h"
#include "linux-procfs.h"
#include "linux-waitpid.h"
#include "buffer.h"
#include "gdb_wait.h"

/* Stores the ptrace options supported by the running kernel.
   A value of -1 means we did not check for features yet.  A value
   of 0 means there are no supported features.  */
static int supported_ptrace_options = -1;

/* Find all possible reasons we could fail to attach PID and append
   these as strings to the already initialized BUFFER.  '\0'
   termination of BUFFER must be done by the caller.  */

void
linux_ptrace_attach_fail_reason (pid_t pid, struct buffer *buffer)
{
  pid_t tracerpid;

  tracerpid = linux_proc_get_tracerpid_nowarn (pid);
  if (tracerpid > 0)
    buffer_xml_printf (buffer, _("process %d is already traced "
				 "by process %d"),
		       (int) pid, (int) tracerpid);

  if (linux_proc_pid_is_zombie_nowarn (pid))
    buffer_xml_printf (buffer, _("process %d is a zombie "
				 "- the process has already terminated"),
		       (int) pid);
}

/* See linux-ptrace.h.  */

char *
linux_ptrace_attach_fail_reason_string (ptid_t ptid, int err)
{
  static char *reason_string;
  struct buffer buffer;
  char *warnings;
  long lwpid = ptid_get_lwp (ptid);

  xfree (reason_string);

  buffer_init (&buffer);
  linux_ptrace_attach_fail_reason (lwpid, &buffer);
  buffer_grow_str0 (&buffer, "");
  warnings = buffer_finish (&buffer);
  if (warnings[0] != '\0')
    reason_string = xstrprintf ("%s (%d), %s",
				safe_strerror (err), err, warnings);
  else
    reason_string = xstrprintf ("%s (%d)",
				safe_strerror (err), err);
  xfree (warnings);
  return reason_string;
}

#if defined __i386__ || defined __x86_64__

/* Address of the 'ret' instruction in asm code block below.  */
EXTERN_C void linux_ptrace_test_ret_to_nx_instr (void);

#include <sys/reg.h>
#include <sys/mman.h>
#include <signal.h>

#endif /* defined __i386__ || defined __x86_64__ */

/* Test broken off-trunk Linux kernel patchset for NX support on i386.  It was
   removed in Fedora kernel 88fa1f0332d188795ed73d7ac2b1564e11a0b4cd.

   Test also x86_64 arch for PaX support.  */

static void
linux_ptrace_test_ret_to_nx (void)
{
#if defined __i386__ || defined __x86_64__
  pid_t child, got_pid;
  gdb_byte *return_address, *pc;
  long l;
  int status, kill_status;

  return_address = mmap (NULL, 2, PROT_READ | PROT_WRITE,
			 MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
  if (return_address == MAP_FAILED)
    {
      warning (_("linux_ptrace_test_ret_to_nx: Cannot mmap: %s"),
	       safe_strerror (errno));
      return;
    }

  /* Put there 'int3'.  */
  *return_address = 0xcc;

  child = fork ();
  switch (child)
    {
    case -1:
      warning (_("linux_ptrace_test_ret_to_nx: Cannot fork: %s"),
	       safe_strerror (errno));
      return;

    case 0:
      l = ptrace (PTRACE_TRACEME, 0, (PTRACE_TYPE_ARG3) NULL,
		  (PTRACE_TYPE_ARG4) NULL);
      if (l != 0)
	warning (_("linux_ptrace_test_ret_to_nx: Cannot PTRACE_TRACEME: %s"),
		 safe_strerror (errno));
      else
	{
#if defined __i386__
	  asm volatile ("pushl %0;"
			".globl linux_ptrace_test_ret_to_nx_instr;"
			"linux_ptrace_test_ret_to_nx_instr:"
			"ret"
			: : "r" (return_address) : "%esp", "memory");
#elif defined __x86_64__
	  asm volatile ("pushq %0;"
			".globl linux_ptrace_test_ret_to_nx_instr;"
			"linux_ptrace_test_ret_to_nx_instr:"
			"ret"
			: : "r" ((uint64_t) (uintptr_t) return_address)
			: "%rsp", "memory");
#else
# error "!__i386__ && !__x86_64__"
#endif
	  gdb_assert_not_reached ("asm block did not terminate");
	}

      _exit (1);
    }

  errno = 0;
  got_pid = waitpid (child, &status, 0);
  if (got_pid != child)
    {
      warning (_("linux_ptrace_test_ret_to_nx: waitpid returned %ld: %s"),
	       (long) got_pid, safe_strerror (errno));
      return;
    }

  if (WIFSIGNALED (status))
    {
      if (WTERMSIG (status) != SIGKILL)
	warning (_("linux_ptrace_test_ret_to_nx: WTERMSIG %d is not SIGKILL!"),
		 (int) WTERMSIG (status));
      else
	warning (_("Cannot call inferior functions, Linux kernel PaX "
		   "protection forbids return to non-executable pages!"));
      return;
    }

  if (!WIFSTOPPED (status))
    {
      warning (_("linux_ptrace_test_ret_to_nx: status %d is not WIFSTOPPED!"),
	       status);
      return;
    }

  /* We may get SIGSEGV due to missing PROT_EXEC of the return_address.  */
  if (WSTOPSIG (status) != SIGTRAP && WSTOPSIG (status) != SIGSEGV)
    {
      warning (_("linux_ptrace_test_ret_to_nx: "
		 "WSTOPSIG %d is neither SIGTRAP nor SIGSEGV!"),
	       (int) WSTOPSIG (status));
      return;
    }

  errno = 0;
#if defined __i386__
  l = ptrace (PTRACE_PEEKUSER, child, (PTRACE_TYPE_ARG3) (uintptr_t) (EIP * 4),
	      (PTRACE_TYPE_ARG4) NULL);
#elif defined __x86_64__
  l = ptrace (PTRACE_PEEKUSER, child, (PTRACE_TYPE_ARG3) (uintptr_t) (RIP * 8),
	      (PTRACE_TYPE_ARG4) NULL);
#else
# error "!__i386__ && !__x86_64__"
#endif
  if (errno != 0)
    {
      warning (_("linux_ptrace_test_ret_to_nx: Cannot PTRACE_PEEKUSER: %s"),
	       safe_strerror (errno));
      return;
    }
  pc = (void *) (uintptr_t) l;

  kill (child, SIGKILL);
  ptrace (PTRACE_KILL, child, (PTRACE_TYPE_ARG3) NULL,
	  (PTRACE_TYPE_ARG4) NULL);

  errno = 0;
  got_pid = waitpid (child, &kill_status, 0);
  if (got_pid != child)
    {
      warning (_("linux_ptrace_test_ret_to_nx: "
		 "PTRACE_KILL waitpid returned %ld: %s"),
	       (long) got_pid, safe_strerror (errno));
      return;
    }
  if (!WIFSIGNALED (kill_status))
    {
      warning (_("linux_ptrace_test_ret_to_nx: "
		 "PTRACE_KILL status %d is not WIFSIGNALED!"),
	       status);
      return;
    }

  /* + 1 is there as x86* stops after the 'int3' instruction.  */
  if (WSTOPSIG (status) == SIGTRAP && pc == return_address + 1)
    {
      /* PASS */
      return;
    }

  /* We may get SIGSEGV due to missing PROT_EXEC of the RETURN_ADDRESS page.  */
  if (WSTOPSIG (status) == SIGSEGV && pc == return_address)
    {
      /* PASS */
      return;
    }

  if ((void (*) (void)) pc != &linux_ptrace_test_ret_to_nx_instr)
    warning (_("linux_ptrace_test_ret_to_nx: PC %p is neither near return "
	       "address %p nor is the return instruction %p!"),
	     pc, return_address, &linux_ptrace_test_ret_to_nx_instr);
  else
    warning (_("Cannot call inferior functions on this system - "
	       "Linux kernel with broken i386 NX (non-executable pages) "
	       "support detected!"));
#endif /* defined __i386__ || defined __x86_64__ */
}

/* Helper function to fork a process and make the child process call
   the function FUNCTION, passing CHILD_STACK as parameter.

   For MMU-less targets, clone is used instead of fork, and
   CHILD_STACK is used as stack space for the cloned child.  If NULL,
   stack space is allocated via malloc (and subsequently passed to
   FUNCTION).  For MMU targets, CHILD_STACK is ignored.  */

static int
linux_fork_to_function (gdb_byte *child_stack, void (*function) (gdb_byte *))
{
  int child_pid;

  /* Sanity check the function pointer.  */
  gdb_assert (function != NULL);

#if defined(__UCLIBC__) && defined(HAS_NOMMU)
#define STACK_SIZE 4096

    if (child_stack == NULL)
      child_stack = xmalloc (STACK_SIZE * 4);

    /* Use CLONE_VM instead of fork, to support uClinux (no MMU).  */
#ifdef __ia64__
      child_pid = __clone2 (function, child_stack, STACK_SIZE,
			    CLONE_VM | SIGCHLD, child_stack + STACK_SIZE * 2);
#else /* !__ia64__ */
      child_pid = clone (function, child_stack + STACK_SIZE,
			 CLONE_VM | SIGCHLD, child_stack + STACK_SIZE * 2);
#endif /* !__ia64__ */
#else /* !defined(__UCLIBC) && defined(HAS_NOMMU) */
  child_pid = fork ();

  if (child_pid == 0)
    function (NULL);
#endif /* defined(__UCLIBC) && defined(HAS_NOMMU) */

  if (child_pid == -1)
    perror_with_name (("fork"));

  return child_pid;
}

/* A helper function for linux_check_ptrace_features, called after
   the child forks a grandchild.  */

static void
linux_grandchild_function (gdb_byte *child_stack)
{
  /* Free any allocated stack.  */
  xfree (child_stack);

  /* This code is only reacheable by the grandchild (child's child)
     process.  */
  _exit (0);
}

/* A helper function for linux_check_ptrace_features, called after
   the parent process forks a child.  The child allows itself to
   be traced by its parent.  */

static void
linux_child_function (gdb_byte *child_stack)
{
  ptrace (PTRACE_TRACEME, 0, (PTRACE_TYPE_ARG3) 0, (PTRACE_TYPE_ARG4) 0);
  kill (getpid (), SIGSTOP);

  /* Fork a grandchild.  */
  linux_fork_to_function (child_stack, linux_grandchild_function);

  /* This code is only reacheable by the child (grandchild's parent)
     process.  */
  _exit (0);
}

static void linux_test_for_tracesysgood (int child_pid);
static void linux_test_for_tracefork (int child_pid);
static void linux_test_for_exitkill (int child_pid);

/* Determine ptrace features available on this target.  */

void
linux_check_ptrace_features (void)
{
  int child_pid, ret, status;

  /* Initialize the options.  */
  supported_ptrace_options = 0;

  /* Fork a child so we can do some testing.  The child will call
     linux_child_function and will get traced.  The child will
     eventually fork a grandchild so we can test fork event
     reporting.  */
  child_pid = linux_fork_to_function (NULL, linux_child_function);

  ret = my_waitpid (child_pid, &status, 0);
  if (ret == -1)
    perror_with_name (("waitpid"));
  else if (ret != child_pid)
    error (_("linux_check_ptrace_features: waitpid: unexpected result %d."),
	   ret);
  if (! WIFSTOPPED (status))
    error (_("linux_check_ptrace_features: waitpid: unexpected status %d."),
	   status);

  linux_test_for_tracesysgood (child_pid);

  linux_test_for_tracefork (child_pid);

  linux_test_for_exitkill (child_pid);

  /* Clean things up and kill any pending children.  */
  do
    {
      ret = ptrace (PTRACE_KILL, child_pid, (PTRACE_TYPE_ARG3) 0,
		    (PTRACE_TYPE_ARG4) 0);
      if (ret != 0)
	warning (_("linux_check_ptrace_features: failed to kill child"));
      my_waitpid (child_pid, &status, 0);
    }
  while (WIFSTOPPED (status));
}

/* Determine if PTRACE_O_TRACESYSGOOD can be used to catch
   syscalls.  */

static void
linux_test_for_tracesysgood (int child_pid)
{
  int ret;

  ret = ptrace (PTRACE_SETOPTIONS, child_pid, (PTRACE_TYPE_ARG3) 0,
		(PTRACE_TYPE_ARG4) PTRACE_O_TRACESYSGOOD);

  if (ret == 0)
    supported_ptrace_options |= PTRACE_O_TRACESYSGOOD;
}

/* Determine if PTRACE_O_TRACEFORK can be used to follow fork
   events.  */

static void
linux_test_for_tracefork (int child_pid)
{
  int ret, status;
  long second_pid;

  /* First, set the PTRACE_O_TRACEFORK option.  If this fails, we
     know for sure that it is not supported.  */
  ret = ptrace (PTRACE_SETOPTIONS, child_pid, (PTRACE_TYPE_ARG3) 0,
		(PTRACE_TYPE_ARG4) PTRACE_O_TRACEFORK);

  if (ret != 0)
    return;

  /* Check if the target supports PTRACE_O_TRACEVFORKDONE.  */
  ret = ptrace (PTRACE_SETOPTIONS, child_pid, (PTRACE_TYPE_ARG3) 0,
		(PTRACE_TYPE_ARG4) (PTRACE_O_TRACEFORK
				    | PTRACE_O_TRACEVFORKDONE));
  if (ret == 0)
    supported_ptrace_options |= PTRACE_O_TRACEVFORKDONE;

  /* Setting PTRACE_O_TRACEFORK did not cause an error, however we
     don't know for sure that the feature is available; old
     versions of PTRACE_SETOPTIONS ignored unknown options.
     Therefore, we attach to the child process, use PTRACE_SETOPTIONS
     to enable fork tracing, and let it fork.  If the process exits,
     we assume that we can't use PTRACE_O_TRACEFORK; if we get the
     fork notification, and we can extract the new child's PID, then
     we assume that we can.

     We do not explicitly check for vfork tracing here.  It is
     assumed that vfork tracing is available whenever fork tracing
     is available.  */
  ret = ptrace (PTRACE_CONT, child_pid, (PTRACE_TYPE_ARG3) 0,
		(PTRACE_TYPE_ARG4) 0);
  if (ret != 0)
    warning (_("linux_test_for_tracefork: failed to resume child"));

  ret = my_waitpid (child_pid, &status, 0);

  /* Check if we received a fork event notification.  */
  if (ret == child_pid && WIFSTOPPED (status)
      && linux_ptrace_get_extended_event (status) == PTRACE_EVENT_FORK)
    {
      /* We did receive a fork event notification.  Make sure its PID
	 is reported.  */
      second_pid = 0;
      ret = ptrace (PTRACE_GETEVENTMSG, child_pid, (PTRACE_TYPE_ARG3) 0,
		    (PTRACE_TYPE_ARG4) &second_pid);
      if (ret == 0 && second_pid != 0)
	{
	  int second_status;

	  /* We got the PID from the grandchild, which means fork
	     tracing is supported.  */
	  supported_ptrace_options |= PTRACE_O_TRACECLONE;
	  supported_ptrace_options |= (PTRACE_O_TRACEFORK
				       | PTRACE_O_TRACEVFORK
				       | PTRACE_O_TRACEEXEC);

	  /* Do some cleanup and kill the grandchild.  */
	  my_waitpid (second_pid, &second_status, 0);
	  ret = ptrace (PTRACE_KILL, second_pid, (PTRACE_TYPE_ARG3) 0,
			(PTRACE_TYPE_ARG4) 0);
	  if (ret != 0)
	    warning (_("linux_test_for_tracefork: "
		       "failed to kill second child"));
	  my_waitpid (second_pid, &status, 0);
	}
    }
  else
    warning (_("linux_test_for_tracefork: unexpected result from waitpid "
	     "(%d, status 0x%x)"), ret, status);
}

/* Determine if PTRACE_O_EXITKILL can be used.  */

static void
linux_test_for_exitkill (int child_pid)
{
  int ret;

  ret = ptrace (PTRACE_SETOPTIONS, child_pid, (PTRACE_TYPE_ARG3) 0,
		(PTRACE_TYPE_ARG4) PTRACE_O_EXITKILL);

  if (ret == 0)
    supported_ptrace_options |= PTRACE_O_EXITKILL;
}

/* Enable reporting of all currently supported ptrace events.
   OPTIONS is a bit mask of extended features we want enabled,
   if supported by the kernel.  PTRACE_O_TRACECLONE is always
   enabled, if supported.  */

void
linux_enable_event_reporting (pid_t pid, int options)
{
  /* Check if we have initialized the ptrace features for this
     target.  If not, do it now.  */
  if (supported_ptrace_options == -1)
    linux_check_ptrace_features ();

  /* We always want clone events.  */
  options |= PTRACE_O_TRACECLONE;

  /* Filter out unsupported options.  */
  options &= supported_ptrace_options;

  /* Set the options.  */
  ptrace (PTRACE_SETOPTIONS, pid, (PTRACE_TYPE_ARG3) 0,
	  (PTRACE_TYPE_ARG4) (uintptr_t) options);
}

/* Disable reporting of all currently supported ptrace events.  */

void
linux_disable_event_reporting (pid_t pid)
{
  /* Set the options.  */
  ptrace (PTRACE_SETOPTIONS, pid, (PTRACE_TYPE_ARG3) 0, 0);
}

/* Returns non-zero if PTRACE_OPTIONS is contained within
   SUPPORTED_PTRACE_OPTIONS, therefore supported.  Returns 0
   otherwise.  */

static int
ptrace_supports_feature (int ptrace_options)
{
  if (supported_ptrace_options == -1)
    linux_check_ptrace_features ();

  return ((supported_ptrace_options & ptrace_options) == ptrace_options);
}

/* Returns non-zero if PTRACE_EVENT_FORK is supported by ptrace,
   0 otherwise.  Note that if PTRACE_EVENT_FORK is supported so is
   PTRACE_EVENT_CLONE, PTRACE_EVENT_EXEC and PTRACE_EVENT_VFORK,
   since they were all added to the kernel at the same time.  */

int
linux_supports_tracefork (void)
{
  return ptrace_supports_feature (PTRACE_O_TRACEFORK);
}

/* Returns non-zero if PTRACE_EVENT_CLONE is supported by ptrace,
   0 otherwise.  Note that if PTRACE_EVENT_CLONE is supported so is
   PTRACE_EVENT_FORK, PTRACE_EVENT_EXEC and PTRACE_EVENT_VFORK,
   since they were all added to the kernel at the same time.  */

int
linux_supports_traceclone (void)
{
  return ptrace_supports_feature (PTRACE_O_TRACECLONE);
}

/* Returns non-zero if PTRACE_O_TRACEVFORKDONE is supported by
   ptrace, 0 otherwise.  */

int
linux_supports_tracevforkdone (void)
{
  return ptrace_supports_feature (PTRACE_O_TRACEVFORKDONE);
}

/* Returns non-zero if PTRACE_O_TRACESYSGOOD is supported by ptrace,
   0 otherwise.  */

int
linux_supports_tracesysgood (void)
{
  return ptrace_supports_feature (PTRACE_O_TRACESYSGOOD);
}

/* Display possible problems on this system.  Display them only once per GDB
   execution.  */

void
linux_ptrace_init_warnings (void)
{
  static int warned = 0;

  if (warned)
    return;
  warned = 1;

  linux_ptrace_test_ret_to_nx ();
}

/* Extract extended ptrace event from wait status.  */

int
linux_ptrace_get_extended_event (int wstat)
{
  return (wstat >> 16);
}

/* Determine whether wait status denotes an extended event.  */

int
linux_is_extended_waitstatus (int wstat)
{
  return (linux_ptrace_get_extended_event (wstat) != 0);
}

/* Return true if the event in LP may be caused by breakpoint.  */

int
linux_wstatus_maybe_breakpoint (int wstat)
{
  return (WIFSTOPPED (wstat)
	  && (WSTOPSIG (wstat) == SIGTRAP
	      /* SIGILL and SIGSEGV are also treated as traps in case a
		 breakpoint is inserted at the current PC.  */
	      || WSTOPSIG (wstat) == SIGILL
	      || WSTOPSIG (wstat) == SIGSEGV));
}
Commit	Line	Data
5f572dec	1	/* Linux-specific ptrace manipulation routines.
32d0add0	2	Copyright (C) 2012-2015 Free Software Foundation, Inc.
5f572dec JK	3
	4	This file is part of GDB.
	5
	6	This program is free software; you can redistribute it and/or modify
	7	it under the terms of the GNU General Public License as published by
	8	the Free Software Foundation; either version 3 of the License, or
	9	(at your option) any later version.
	10
	11	This program is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	GNU General Public License for more details.
	15
	16	You should have received a copy of the GNU General Public License
	17	along with this program. If not, see <http://www.gnu.org/licenses/>. */
	18
727605ca	19	#include "common-defs.h"
5f572dec	20	#include "linux-ptrace.h"
87b0bb13	21	#include "linux-procfs.h"
125f8a3d	22	#include "linux-waitpid.h"
87b0bb13	23	#include "buffer.h"
8bdce1ff	24	#include "gdb_wait.h"
87b0bb13	25
de0d863e DB	26	/* Stores the ptrace options supported by the running kernel.
	27	A value of -1 means we did not check for features yet. A value
	28	of 0 means there are no supported features. */
	29	static int supported_ptrace_options = -1;
8009206a	30
7ae1a6a6 PA	31	/* Find all possible reasons we could fail to attach PID and append
	32	these as strings to the already initialized BUFFER. '\0'
	33	termination of BUFFER must be done by the caller. */
87b0bb13 JK	34
87b0bb13 JK	35	void
7ae1a6a6	36	linux_ptrace_attach_fail_reason (pid_t pid, struct buffer *buffer)
87b0bb13 JK	37	{
	38	pid_t tracerpid;
	39
8784d563	40	tracerpid = linux_proc_get_tracerpid_nowarn (pid);
87b0bb13	41	if (tracerpid > 0)
7ae1a6a6 PA	42	buffer_xml_printf (buffer, _("process %d is already traced "
7ae1a6a6 PA	43	"by process %d"),
87b0bb13 JK	44	(int) pid, (int) tracerpid);
87b0bb13 JK	45
8784d563	46	if (linux_proc_pid_is_zombie_nowarn (pid))
7ae1a6a6 PA	47	buffer_xml_printf (buffer, _("process %d is a zombie "
7ae1a6a6 PA	48	"- the process has already terminated"),
87b0bb13 JK	49	(int) pid);
87b0bb13 JK	50	}
aa7c7447	51
8784d563 PA	52	/* See linux-ptrace.h. */
	53
	54	char *
	55	linux_ptrace_attach_fail_reason_string (ptid_t ptid, int err)
	56	{
	57	static char *reason_string;
	58	struct buffer buffer;
	59	char *warnings;
	60	long lwpid = ptid_get_lwp (ptid);
	61
	62	xfree (reason_string);
	63
	64	buffer_init (&buffer);
	65	linux_ptrace_attach_fail_reason (lwpid, &buffer);
	66	buffer_grow_str0 (&buffer, "");
	67	warnings = buffer_finish (&buffer);
	68	if (warnings[0] != '\0')
	69	reason_string = xstrprintf ("%s (%d), %s",
049bb5de	70	safe_strerror (err), err, warnings);
8784d563 PA	71	else
8784d563 PA	72	reason_string = xstrprintf ("%s (%d)",
049bb5de	73	safe_strerror (err), err);
8784d563 PA	74	xfree (warnings);
	75	return reason_string;
	76	}
	77
6e3c039e	78	#if defined __i386__ \|\| defined __x86_64__
aa7c7447 JK	79
aa7c7447 JK	80	/* Address of the 'ret' instruction in asm code block below. */
56000a98	81	EXTERN_C void linux_ptrace_test_ret_to_nx_instr (void);
aa7c7447 JK	82
	83	#include <sys/reg.h>
	84	#include <sys/mman.h>
	85	#include <signal.h>
aa7c7447	86
6e3c039e	87	#endif /* defined __i386__ \|\| defined __x86_64__ */
aa7c7447 JK	88
aa7c7447 JK	89	/* Test broken off-trunk Linux kernel patchset for NX support on i386. It was
6e3c039e JK	90	removed in Fedora kernel 88fa1f0332d188795ed73d7ac2b1564e11a0b4cd.
	91
	92	Test also x86_64 arch for PaX support. */
aa7c7447 JK	93
	94	static void
	95	linux_ptrace_test_ret_to_nx (void)
	96	{
6e3c039e	97	#if defined __i386__ \|\| defined __x86_64__
aa7c7447 JK	98	pid_t child, got_pid;
	99	gdb_byte return_address, pc;
	100	long l;
61a31a67	101	int status, kill_status;
aa7c7447 JK	102
	103	return_address = mmap (NULL, 2, PROT_READ \| PROT_WRITE,
	104	MAP_PRIVATE \| MAP_ANONYMOUS, -1, 0);
	105	if (return_address == MAP_FAILED)
	106	{
	107	warning (_("linux_ptrace_test_ret_to_nx: Cannot mmap: %s"),
049bb5de	108	safe_strerror (errno));
aa7c7447 JK	109	return;
	110	}
	111
	112	/* Put there 'int3'. */
	113	*return_address = 0xcc;
	114
	115	child = fork ();
	116	switch (child)
	117	{
	118	case -1:
	119	warning (_("linux_ptrace_test_ret_to_nx: Cannot fork: %s"),
049bb5de	120	safe_strerror (errno));
aa7c7447 JK	121	return;
	122
	123	case 0:
96d7229d LM	124	l = ptrace (PTRACE_TRACEME, 0, (PTRACE_TYPE_ARG3) NULL,
96d7229d LM	125	(PTRACE_TYPE_ARG4) NULL);
aa7c7447 JK	126	if (l != 0)
aa7c7447 JK	127	warning (_("linux_ptrace_test_ret_to_nx: Cannot PTRACE_TRACEME: %s"),
049bb5de	128	safe_strerror (errno));
aa7c7447 JK	129	else
aa7c7447 JK	130	{
6e3c039e	131	#if defined __i386__
aa7c7447 JK	132	asm volatile ("pushl %0;"
	133	".globl linux_ptrace_test_ret_to_nx_instr;"
	134	"linux_ptrace_test_ret_to_nx_instr:"
	135	"ret"
	136	: : "r" (return_address) : "%esp", "memory");
6e3c039e JK	137	#elif defined __x86_64__
	138	asm volatile ("pushq %0;"
	139	".globl linux_ptrace_test_ret_to_nx_instr;"
	140	"linux_ptrace_test_ret_to_nx_instr:"
	141	"ret"
bdad4180 MF	142	: : "r" ((uint64_t) (uintptr_t) return_address)
bdad4180 MF	143	: "%rsp", "memory");
6e3c039e JK	144	#else
	145	# error "!__i386__ && !__x86_64__"
	146	#endif
aa7c7447 JK	147	gdb_assert_not_reached ("asm block did not terminate");
	148	}
	149
	150	_exit (1);
	151	}
	152
6e3c039e	153	errno = 0;
aa7c7447	154	got_pid = waitpid (child, &status, 0);
6e3c039e JK	155	if (got_pid != child)
	156	{
	157	warning (_("linux_ptrace_test_ret_to_nx: waitpid returned %ld: %s"),
049bb5de	158	(long) got_pid, safe_strerror (errno));
6e3c039e JK	159	return;
	160	}
	161
	162	if (WIFSIGNALED (status))
	163	{
	164	if (WTERMSIG (status) != SIGKILL)
	165	warning (_("linux_ptrace_test_ret_to_nx: WTERMSIG %d is not SIGKILL!"),
	166	(int) WTERMSIG (status));
	167	else
	168	warning (_("Cannot call inferior functions, Linux kernel PaX "
	169	"protection forbids return to non-executable pages!"));
	170	return;
	171	}
	172
	173	if (!WIFSTOPPED (status))
	174	{
	175	warning (_("linux_ptrace_test_ret_to_nx: status %d is not WIFSTOPPED!"),
	176	status);
	177	return;
	178	}
aa7c7447 JK	179
aa7c7447 JK	180	/* We may get SIGSEGV due to missing PROT_EXEC of the return_address. */
6e3c039e JK	181	if (WSTOPSIG (status) != SIGTRAP && WSTOPSIG (status) != SIGSEGV)
	182	{
	183	warning (_("linux_ptrace_test_ret_to_nx: "
	184	"WSTOPSIG %d is neither SIGTRAP nor SIGSEGV!"),
	185	(int) WSTOPSIG (status));
	186	return;
	187	}
aa7c7447 JK	188
aa7c7447 JK	189	errno = 0;
6e3c039e	190	#if defined __i386__
96d7229d LM	191	l = ptrace (PTRACE_PEEKUSER, child, (PTRACE_TYPE_ARG3) (uintptr_t) (EIP * 4),
96d7229d LM	192	(PTRACE_TYPE_ARG4) NULL);
6e3c039e	193	#elif defined __x86_64__
96d7229d LM	194	l = ptrace (PTRACE_PEEKUSER, child, (PTRACE_TYPE_ARG3) (uintptr_t) (RIP * 8),
96d7229d LM	195	(PTRACE_TYPE_ARG4) NULL);
6e3c039e JK	196	#else
	197	# error "!__i386__ && !__x86_64__"
	198	#endif
	199	if (errno != 0)
	200	{
	201	warning (_("linux_ptrace_test_ret_to_nx: Cannot PTRACE_PEEKUSER: %s"),
049bb5de	202	safe_strerror (errno));
6e3c039e JK	203	return;
6e3c039e JK	204	}
aa7c7447 JK	205	pc = (void *) (uintptr_t) l;
aa7c7447 JK	206
61a31a67	207	kill (child, SIGKILL);
96d7229d LM	208	ptrace (PTRACE_KILL, child, (PTRACE_TYPE_ARG3) NULL,
96d7229d LM	209	(PTRACE_TYPE_ARG4) NULL);
61a31a67 JK	210
	211	errno = 0;
	212	got_pid = waitpid (child, &kill_status, 0);
	213	if (got_pid != child)
6e3c039e	214	{
61a31a67 JK	215	warning (_("linux_ptrace_test_ret_to_nx: "
61a31a67 JK	216	"PTRACE_KILL waitpid returned %ld: %s"),
049bb5de	217	(long) got_pid, safe_strerror (errno));
6e3c039e JK	218	return;
6e3c039e JK	219	}
61a31a67	220	if (!WIFSIGNALED (kill_status))
aa7c7447	221	{
61a31a67 JK	222	warning (_("linux_ptrace_test_ret_to_nx: "
	223	"PTRACE_KILL status %d is not WIFSIGNALED!"),
	224	status);
	225	return;
aa7c7447 JK	226	}
	227
	228	/* + 1 is there as x86* stops after the 'int3' instruction. */
	229	if (WSTOPSIG (status) == SIGTRAP && pc == return_address + 1)
	230	{
	231	/* PASS */
	232	return;
	233	}
	234
	235	/* We may get SIGSEGV due to missing PROT_EXEC of the RETURN_ADDRESS page. */
	236	if (WSTOPSIG (status) == SIGSEGV && pc == return_address)
	237	{
	238	/* PASS */
	239	return;
	240	}
	241
6e3c039e JK	242	if ((void (*) (void)) pc != &linux_ptrace_test_ret_to_nx_instr)
	243	warning (_("linux_ptrace_test_ret_to_nx: PC %p is neither near return "
	244	"address %p nor is the return instruction %p!"),
	245	pc, return_address, &linux_ptrace_test_ret_to_nx_instr);
	246	else
025e6dce PA	247	warning (_("Cannot call inferior functions on this system - "
	248	"Linux kernel with broken i386 NX (non-executable pages) "
	249	"support detected!"));
6e3c039e	250	#endif /* defined __i386__ \|\| defined __x86_64__ */
aa7c7447 JK	251	}
aa7c7447 JK	252
96d7229d LM	253	/* Helper function to fork a process and make the child process call
	254	the function FUNCTION, passing CHILD_STACK as parameter.
	255
	256	For MMU-less targets, clone is used instead of fork, and
	257	CHILD_STACK is used as stack space for the cloned child. If NULL,
	258	stack space is allocated via malloc (and subsequently passed to
	259	FUNCTION). For MMU targets, CHILD_STACK is ignored. */
	260
	261	static int
	262	linux_fork_to_function (gdb_byte child_stack, void (function) (gdb_byte *))
	263	{
	264	int child_pid;
	265
	266	/* Sanity check the function pointer. */
	267	gdb_assert (function != NULL);
	268
	269	#if defined(__UCLIBC__) && defined(HAS_NOMMU)
	270	#define STACK_SIZE 4096
	271
	272	if (child_stack == NULL)
	273	child_stack = xmalloc (STACK_SIZE * 4);
	274
	275	/* Use CLONE_VM instead of fork, to support uClinux (no MMU). */
101158d9	276	#ifdef __ia64__
96d7229d LM	277	child_pid = __clone2 (function, child_stack, STACK_SIZE,
96d7229d LM	278	CLONE_VM \| SIGCHLD, child_stack + STACK_SIZE * 2);
101158d9	279	#else /* !__ia64__ */
96d7229d LM	280	child_pid = clone (function, child_stack + STACK_SIZE,
96d7229d LM	281	CLONE_VM \| SIGCHLD, child_stack + STACK_SIZE * 2);
101158d9	282	#endif /* !__ia64__ */
96d7229d LM	283	#else /* !defined(__UCLIBC) && defined(HAS_NOMMU) */
	284	child_pid = fork ();
	285
	286	if (child_pid == 0)
	287	function (NULL);
	288	#endif /* defined(__UCLIBC) && defined(HAS_NOMMU) */
	289
	290	if (child_pid == -1)
	291	perror_with_name (("fork"));
	292
	293	return child_pid;
	294	}
	295
	296	/* A helper function for linux_check_ptrace_features, called after
	297	the child forks a grandchild. */
	298
	299	static void
	300	linux_grandchild_function (gdb_byte *child_stack)
	301	{
	302	/* Free any allocated stack. */
	303	xfree (child_stack);
	304
	305	/* This code is only reacheable by the grandchild (child's child)
	306	process. */
	307	_exit (0);
	308	}
	309
	310	/* A helper function for linux_check_ptrace_features, called after
	311	the parent process forks a child. The child allows itself to
	312	be traced by its parent. */
	313
	314	static void
	315	linux_child_function (gdb_byte *child_stack)
	316	{
	317	ptrace (PTRACE_TRACEME, 0, (PTRACE_TYPE_ARG3) 0, (PTRACE_TYPE_ARG4) 0);
	318	kill (getpid (), SIGSTOP);
	319
	320	/* Fork a grandchild. */
	321	linux_fork_to_function (child_stack, linux_grandchild_function);
	322
	323	/* This code is only reacheable by the child (grandchild's parent)
	324	process. */
	325	_exit (0);
	326	}
	327
8ae377e8 PA	328	static void linux_test_for_tracesysgood (int child_pid);
8ae377e8 PA	329	static void linux_test_for_tracefork (int child_pid);
beed38b8	330	static void linux_test_for_exitkill (int child_pid);
8ae377e8	331
96d7229d LM	332	/* Determine ptrace features available on this target. */
96d7229d LM	333
89245bc0	334	void
96d7229d LM	335	linux_check_ptrace_features (void)
	336	{
	337	int child_pid, ret, status;
96d7229d LM	338
96d7229d LM	339	/* Initialize the options. */
de0d863e	340	supported_ptrace_options = 0;
96d7229d LM	341
	342	/* Fork a child so we can do some testing. The child will call
	343	linux_child_function and will get traced. The child will
	344	eventually fork a grandchild so we can test fork event
	345	reporting. */
	346	child_pid = linux_fork_to_function (NULL, linux_child_function);
	347
	348	ret = my_waitpid (child_pid, &status, 0);
	349	if (ret == -1)
	350	perror_with_name (("waitpid"));
	351	else if (ret != child_pid)
	352	error (_("linux_check_ptrace_features: waitpid: unexpected result %d."),
	353	ret);
	354	if (! WIFSTOPPED (status))
	355	error (_("linux_check_ptrace_features: waitpid: unexpected status %d."),
	356	status);
	357
8ae377e8	358	linux_test_for_tracesysgood (child_pid);
96d7229d	359
8ae377e8 PA	360	linux_test_for_tracefork (child_pid);
8ae377e8 PA	361
beed38b8 JB	362	linux_test_for_exitkill (child_pid);
beed38b8 JB	363
8ae377e8 PA	364	/* Clean things up and kill any pending children. */
8ae377e8 PA	365	do
96d7229d LM	366	{
	367	ret = ptrace (PTRACE_KILL, child_pid, (PTRACE_TYPE_ARG3) 0,
	368	(PTRACE_TYPE_ARG4) 0);
	369	if (ret != 0)
8ae377e8 PA	370	warning (_("linux_check_ptrace_features: failed to kill child"));
8ae377e8 PA	371	my_waitpid (child_pid, &status, 0);
96d7229d	372	}
8ae377e8 PA	373	while (WIFSTOPPED (status));
8ae377e8 PA	374	}
96d7229d	375
8ae377e8 PA	376	/* Determine if PTRACE_O_TRACESYSGOOD can be used to catch
	377	syscalls. */
	378
	379	static void
	380	linux_test_for_tracesysgood (int child_pid)
	381	{
8ae377e8 PA	382	int ret;
8ae377e8 PA	383
96d7229d LM	384	ret = ptrace (PTRACE_SETOPTIONS, child_pid, (PTRACE_TYPE_ARG3) 0,
96d7229d LM	385	(PTRACE_TYPE_ARG4) PTRACE_O_TRACESYSGOOD);
8009206a	386
96d7229d	387	if (ret == 0)
de0d863e	388	supported_ptrace_options \|= PTRACE_O_TRACESYSGOOD;
8ae377e8	389	}
96d7229d	390
8ae377e8 PA	391	/* Determine if PTRACE_O_TRACEFORK can be used to follow fork
	392	events. */
	393
	394	static void
	395	linux_test_for_tracefork (int child_pid)
	396	{
	397	int ret, status;
	398	long second_pid;
	399
	400	/* First, set the PTRACE_O_TRACEFORK option. If this fails, we
	401	know for sure that it is not supported. */
	402	ret = ptrace (PTRACE_SETOPTIONS, child_pid, (PTRACE_TYPE_ARG3) 0,
	403	(PTRACE_TYPE_ARG4) PTRACE_O_TRACEFORK);
	404
	405	if (ret != 0)
	406	return;
	407
de0d863e DB	408	/* Check if the target supports PTRACE_O_TRACEVFORKDONE. */
	409	ret = ptrace (PTRACE_SETOPTIONS, child_pid, (PTRACE_TYPE_ARG3) 0,
	410	(PTRACE_TYPE_ARG4) (PTRACE_O_TRACEFORK
	411	\| PTRACE_O_TRACEVFORKDONE));
	412	if (ret == 0)
	413	supported_ptrace_options \|= PTRACE_O_TRACEVFORKDONE;
96d7229d LM	414
	415	/* Setting PTRACE_O_TRACEFORK did not cause an error, however we
	416	don't know for sure that the feature is available; old
	417	versions of PTRACE_SETOPTIONS ignored unknown options.
	418	Therefore, we attach to the child process, use PTRACE_SETOPTIONS
	419	to enable fork tracing, and let it fork. If the process exits,
	420	we assume that we can't use PTRACE_O_TRACEFORK; if we get the
	421	fork notification, and we can extract the new child's PID, then
	422	we assume that we can.
	423
	424	We do not explicitly check for vfork tracing here. It is
	425	assumed that vfork tracing is available whenever fork tracing
	426	is available. */
	427	ret = ptrace (PTRACE_CONT, child_pid, (PTRACE_TYPE_ARG3) 0,
	428	(PTRACE_TYPE_ARG4) 0);
	429	if (ret != 0)
8ae377e8	430	warning (_("linux_test_for_tracefork: failed to resume child"));
96d7229d LM	431
	432	ret = my_waitpid (child_pid, &status, 0);
	433
	434	/* Check if we received a fork event notification. */
	435	if (ret == child_pid && WIFSTOPPED (status)
89a5711c	436	&& linux_ptrace_get_extended_event (status) == PTRACE_EVENT_FORK)
96d7229d LM	437	{
	438	/* We did receive a fork event notification. Make sure its PID
	439	is reported. */
	440	second_pid = 0;
	441	ret = ptrace (PTRACE_GETEVENTMSG, child_pid, (PTRACE_TYPE_ARG3) 0,
	442	(PTRACE_TYPE_ARG4) &second_pid);
	443	if (ret == 0 && second_pid != 0)
	444	{
	445	int second_status;
	446
	447	/* We got the PID from the grandchild, which means fork
	448	tracing is supported. */
de0d863e DB	449	supported_ptrace_options \|= PTRACE_O_TRACECLONE;
	450	supported_ptrace_options \|= (PTRACE_O_TRACEFORK
	451	\| PTRACE_O_TRACEVFORK
	452	\| PTRACE_O_TRACEEXEC);
96d7229d LM	453
	454	/* Do some cleanup and kill the grandchild. */
	455	my_waitpid (second_pid, &second_status, 0);
	456	ret = ptrace (PTRACE_KILL, second_pid, (PTRACE_TYPE_ARG3) 0,
	457	(PTRACE_TYPE_ARG4) 0);
	458	if (ret != 0)
8ae377e8	459	warning (_("linux_test_for_tracefork: "
96d7229d LM	460	"failed to kill second child"));
	461	my_waitpid (second_pid, &status, 0);
	462	}
	463	}
	464	else
8ae377e8	465	warning (_("linux_test_for_tracefork: unexpected result from waitpid "
96d7229d	466	"(%d, status 0x%x)"), ret, status);
96d7229d LM	467	}
96d7229d LM	468
beed38b8 JB	469	/* Determine if PTRACE_O_EXITKILL can be used. */
	470
	471	static void
	472	linux_test_for_exitkill (int child_pid)
	473	{
	474	int ret;
	475
	476	ret = ptrace (PTRACE_SETOPTIONS, child_pid, (PTRACE_TYPE_ARG3) 0,
	477	(PTRACE_TYPE_ARG4) PTRACE_O_EXITKILL);
	478
	479	if (ret == 0)
de0d863e	480	supported_ptrace_options \|= PTRACE_O_EXITKILL;
beed38b8 JB	481	}
	482
	483	/* Enable reporting of all currently supported ptrace events.
de0d863e DB	484	OPTIONS is a bit mask of extended features we want enabled,
	485	if supported by the kernel. PTRACE_O_TRACECLONE is always
	486	enabled, if supported. */
96d7229d LM	487
96d7229d LM	488	void
de0d863e	489	linux_enable_event_reporting (pid_t pid, int options)
96d7229d LM	490	{
	491	/* Check if we have initialized the ptrace features for this
	492	target. If not, do it now. */
de0d863e	493	if (supported_ptrace_options == -1)
96d7229d LM	494	linux_check_ptrace_features ();
96d7229d LM	495
de0d863e DB	496	/* We always want clone events. */
	497	options \|= PTRACE_O_TRACECLONE;
	498
	499	/* Filter out unsupported options. */
	500	options &= supported_ptrace_options;
beed38b8	501
96d7229d LM	502	/* Set the options. */
96d7229d LM	503	ptrace (PTRACE_SETOPTIONS, pid, (PTRACE_TYPE_ARG3) 0,
de0d863e	504	(PTRACE_TYPE_ARG4) (uintptr_t) options);
96d7229d LM	505	}
96d7229d LM	506
c077881a HZ	507	/* Disable reporting of all currently supported ptrace events. */
	508
	509	void
	510	linux_disable_event_reporting (pid_t pid)
	511	{
	512	/* Set the options. */
	513	ptrace (PTRACE_SETOPTIONS, pid, (PTRACE_TYPE_ARG3) 0, 0);
	514	}
	515
96d7229d	516	/* Returns non-zero if PTRACE_OPTIONS is contained within
de0d863e	517	SUPPORTED_PTRACE_OPTIONS, therefore supported. Returns 0
96d7229d LM	518	otherwise. */
	519
	520	static int
	521	ptrace_supports_feature (int ptrace_options)
	522	{
de0d863e	523	if (supported_ptrace_options == -1)
8784d563	524	linux_check_ptrace_features ();
96d7229d	525
de0d863e	526	return ((supported_ptrace_options & ptrace_options) == ptrace_options);
96d7229d LM	527	}
	528
	529	/* Returns non-zero if PTRACE_EVENT_FORK is supported by ptrace,
	530	0 otherwise. Note that if PTRACE_EVENT_FORK is supported so is
	531	PTRACE_EVENT_CLONE, PTRACE_EVENT_EXEC and PTRACE_EVENT_VFORK,
	532	since they were all added to the kernel at the same time. */
	533
	534	int
	535	linux_supports_tracefork (void)
	536	{
	537	return ptrace_supports_feature (PTRACE_O_TRACEFORK);
	538	}
	539
	540	/* Returns non-zero if PTRACE_EVENT_CLONE is supported by ptrace,
	541	0 otherwise. Note that if PTRACE_EVENT_CLONE is supported so is
	542	PTRACE_EVENT_FORK, PTRACE_EVENT_EXEC and PTRACE_EVENT_VFORK,
	543	since they were all added to the kernel at the same time. */
	544
	545	int
	546	linux_supports_traceclone (void)
	547	{
	548	return ptrace_supports_feature (PTRACE_O_TRACECLONE);
	549	}
	550
	551	/* Returns non-zero if PTRACE_O_TRACEVFORKDONE is supported by
	552	ptrace, 0 otherwise. */
	553
	554	int
	555	linux_supports_tracevforkdone (void)
	556	{
	557	return ptrace_supports_feature (PTRACE_O_TRACEVFORKDONE);
	558	}
	559
	560	/* Returns non-zero if PTRACE_O_TRACESYSGOOD is supported by ptrace,
	561	0 otherwise. */
	562
	563	int
	564	linux_supports_tracesysgood (void)
	565	{
	566	return ptrace_supports_feature (PTRACE_O_TRACESYSGOOD);
	567	}
	568
aa7c7447 JK	569	/* Display possible problems on this system. Display them only once per GDB
	570	execution. */
	571
	572	void
	573	linux_ptrace_init_warnings (void)
	574	{
	575	static int warned = 0;
	576
	577	if (warned)
	578	return;
	579	warned = 1;
	580
	581	linux_ptrace_test_ret_to_nx ();
	582	}
8009206a	583
89a5711c DB	584	/* Extract extended ptrace event from wait status. */
	585
	586	int
	587	linux_ptrace_get_extended_event (int wstat)
	588	{
	589	return (wstat >> 16);
	590	}
	591
	592	/* Determine whether wait status denotes an extended event. */
	593
	594	int
	595	linux_is_extended_waitstatus (int wstat)
	596	{
	597	return (linux_ptrace_get_extended_event (wstat) != 0);
	598	}
c9587f88 AT	599
	600	/* Return true if the event in LP may be caused by breakpoint. */
	601
	602	int
	603	linux_wstatus_maybe_breakpoint (int wstat)
	604	{
	605	return (WIFSTOPPED (wstat)
	606	&& (WSTOPSIG (wstat) == SIGTRAP
	607	/* SIGILL and SIGSEGV are also treated as traps in case a
	608	breakpoint is inserted at the current PC. */
	609	\|\| WSTOPSIG (wstat) == SIGILL
	610	\|\| WSTOPSIG (wstat) == SIGSEGV));
	611	}