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

/* Linux-specific ptrace manipulation routines.
   Copyright (C) 2012-2013 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/>.  */

#ifdef GDBSERVER
#include "server.h"
#else
#include "defs.h"
#include "gdb_string.h"
#endif

#include "linux-ptrace.h"
#include "linux-procfs.h"
#include "nat/linux-waitpid.h"
#include "buffer.h"
#include "gdb_assert.h"
#include "gdb_wait.h"

#include <stdint.h>

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

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

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

  tracerpid = linux_proc_get_tracerpid (pid);
  if (tracerpid > 0)
    buffer_xml_printf (buffer, _("warning: process %d is already traced "
				 "by process %d\n"),
		       (int) pid, (int) tracerpid);

  if (linux_proc_pid_is_zombie (pid))
    buffer_xml_printf (buffer, _("warning: process %d is a zombie "
				 "- the process has already terminated\n"),
		       (int) pid);
}

#if defined __i386__ || defined __x86_64__

/* Address of the 'ret' instruction in asm code block below.  */
extern 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"),
	       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"),
	       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"),
		 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, 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"),
	       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, 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);
}

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

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

  /* Initialize the options.  */
  current_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);

  /* 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)
    {
      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"));
	  return;
	}

      ret = my_waitpid (child_pid, &status, 0);
      if (ret != child_pid)
	warning (_("linux_check_ptrace_features: failed "
		   "to wait for killed child"));
      else if (!WIFSIGNALED (status))
	warning (_("linux_check_ptrace_features: unexpected "
		   "wait status 0x%x from killed child"), status);

      return;
    }

#ifdef GDBSERVER
  /* gdbserver does not support PTRACE_O_TRACESYSGOOD or
     PTRACE_O_TRACEVFORKDONE yet.  */
#else
  /* Check if the target supports PTRACE_O_TRACESYSGOOD.  */
  ret = ptrace (PTRACE_SETOPTIONS, child_pid, (PTRACE_TYPE_ARG3) 0,
		(PTRACE_TYPE_ARG4) PTRACE_O_TRACESYSGOOD);
  if (ret == 0)
    current_ptrace_options |= PTRACE_O_TRACESYSGOOD;

  /* 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)
    current_ptrace_options |= PTRACE_O_TRACEVFORKDONE;
#endif

  /* 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_check_ptrace_features: 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)
      && status >> 16 == 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.  */
#ifdef GDBSERVER
	  /* Do not enable all the options for now since gdbserver does not
	     properly support them.  This restriction will be lifted when
	     gdbserver is augmented to support them.  */
	  current_ptrace_options |= PTRACE_O_TRACECLONE;
#else
	  current_ptrace_options |= PTRACE_O_TRACEFORK | PTRACE_O_TRACEVFORK
	    | PTRACE_O_TRACECLONE | PTRACE_O_TRACEEXEC;

	  /* Do not enable PTRACE_O_TRACEEXIT until GDB is more prepared to
	     support read-only process state.  */
#endif

	  /* 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_check_ptrace_features: "
		       "failed to kill second child"));
	  my_waitpid (second_pid, &status, 0);
	}
    }
  else
    warning (_("linux_check_ptrace_features: unexpected result from waitpid "
	     "(%d, status 0x%x)"), ret, status);

  /* 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));
}

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

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

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

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

static int
ptrace_supports_feature (int ptrace_options)
{
  gdb_assert (current_ptrace_options >= 0);

  return ((current_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 ();
}
Commit	Line	Data
5f572dec	1	/* Linux-specific ptrace manipulation routines.
28e7fd62	2	Copyright (C) 2012-2013 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
	19	#ifdef GDBSERVER
	20	#include "server.h"
	21	#else
	22	#include "defs.h"
	23	#include "gdb_string.h"
	24	#endif
	25
	26	#include "linux-ptrace.h"
87b0bb13	27	#include "linux-procfs.h"
96d7229d	28	#include "nat/linux-waitpid.h"
87b0bb13	29	#include "buffer.h"
aa7c7447	30	#include "gdb_assert.h"
8bdce1ff	31	#include "gdb_wait.h"
87b0bb13	32
59ee9f94 WN	33	#include <stdint.h>
59ee9f94 WN	34
96d7229d LM	35	/* Stores the currently supported ptrace options. A value of
	36	-1 means we did not check for features yet. A value of 0 means
	37	there are no supported features. */
	38	static int current_ptrace_options = -1;
	39
87b0bb13 JK	40	/* Find all possible reasons we could fail to attach PID and append these
	41	newline terminated reason strings to initialized BUFFER. '\0' termination
	42	of BUFFER must be done by the caller. */
	43
	44	void
	45	linux_ptrace_attach_warnings (pid_t pid, struct buffer *buffer)
	46	{
	47	pid_t tracerpid;
	48
	49	tracerpid = linux_proc_get_tracerpid (pid);
	50	if (tracerpid > 0)
	51	buffer_xml_printf (buffer, _("warning: process %d is already traced "
	52	"by process %d\n"),
	53	(int) pid, (int) tracerpid);
	54
	55	if (linux_proc_pid_is_zombie (pid))
	56	buffer_xml_printf (buffer, _("warning: process %d is a zombie "
	57	"- the process has already terminated\n"),
	58	(int) pid);
	59	}
aa7c7447	60
6e3c039e	61	#if defined __i386__ \|\| defined __x86_64__
aa7c7447 JK	62
	63	/* Address of the 'ret' instruction in asm code block below. */
	64	extern void (linux_ptrace_test_ret_to_nx_instr) (void);
	65
	66	#include <sys/reg.h>
	67	#include <sys/mman.h>
	68	#include <signal.h>
aa7c7447	69
6e3c039e	70	#endif /* defined __i386__ \|\| defined __x86_64__ */
aa7c7447 JK	71
aa7c7447 JK	72	/* Test broken off-trunk Linux kernel patchset for NX support on i386. It was
6e3c039e JK	73	removed in Fedora kernel 88fa1f0332d188795ed73d7ac2b1564e11a0b4cd.
	74
	75	Test also x86_64 arch for PaX support. */
aa7c7447 JK	76
	77	static void
	78	linux_ptrace_test_ret_to_nx (void)
	79	{
6e3c039e	80	#if defined __i386__ \|\| defined __x86_64__
aa7c7447 JK	81	pid_t child, got_pid;
	82	gdb_byte return_address, pc;
	83	long l;
61a31a67	84	int status, kill_status;
aa7c7447 JK	85
	86	return_address = mmap (NULL, 2, PROT_READ \| PROT_WRITE,
	87	MAP_PRIVATE \| MAP_ANONYMOUS, -1, 0);
	88	if (return_address == MAP_FAILED)
	89	{
	90	warning (_("linux_ptrace_test_ret_to_nx: Cannot mmap: %s"),
	91	strerror (errno));
	92	return;
	93	}
	94
	95	/* Put there 'int3'. */
	96	*return_address = 0xcc;
	97
	98	child = fork ();
	99	switch (child)
	100	{
	101	case -1:
	102	warning (_("linux_ptrace_test_ret_to_nx: Cannot fork: %s"),
	103	strerror (errno));
	104	return;
	105
	106	case 0:
96d7229d LM	107	l = ptrace (PTRACE_TRACEME, 0, (PTRACE_TYPE_ARG3) NULL,
96d7229d LM	108	(PTRACE_TYPE_ARG4) NULL);
aa7c7447 JK	109	if (l != 0)
	110	warning (_("linux_ptrace_test_ret_to_nx: Cannot PTRACE_TRACEME: %s"),
	111	strerror (errno));
	112	else
	113	{
6e3c039e	114	#if defined __i386__
aa7c7447 JK	115	asm volatile ("pushl %0;"
	116	".globl linux_ptrace_test_ret_to_nx_instr;"
	117	"linux_ptrace_test_ret_to_nx_instr:"
	118	"ret"
	119	: : "r" (return_address) : "%esp", "memory");
6e3c039e JK	120	#elif defined __x86_64__
	121	asm volatile ("pushq %0;"
	122	".globl linux_ptrace_test_ret_to_nx_instr;"
	123	"linux_ptrace_test_ret_to_nx_instr:"
	124	"ret"
bdad4180 MF	125	: : "r" ((uint64_t) (uintptr_t) return_address)
bdad4180 MF	126	: "%rsp", "memory");
6e3c039e JK	127	#else
	128	# error "!__i386__ && !__x86_64__"
	129	#endif
aa7c7447 JK	130	gdb_assert_not_reached ("asm block did not terminate");
	131	}
	132
	133	_exit (1);
	134	}
	135
6e3c039e	136	errno = 0;
aa7c7447	137	got_pid = waitpid (child, &status, 0);
6e3c039e JK	138	if (got_pid != child)
	139	{
	140	warning (_("linux_ptrace_test_ret_to_nx: waitpid returned %ld: %s"),
	141	(long) got_pid, strerror (errno));
	142	return;
	143	}
	144
	145	if (WIFSIGNALED (status))
	146	{
	147	if (WTERMSIG (status) != SIGKILL)
	148	warning (_("linux_ptrace_test_ret_to_nx: WTERMSIG %d is not SIGKILL!"),
	149	(int) WTERMSIG (status));
	150	else
	151	warning (_("Cannot call inferior functions, Linux kernel PaX "
	152	"protection forbids return to non-executable pages!"));
	153	return;
	154	}
	155
	156	if (!WIFSTOPPED (status))
	157	{
	158	warning (_("linux_ptrace_test_ret_to_nx: status %d is not WIFSTOPPED!"),
	159	status);
	160	return;
	161	}
aa7c7447 JK	162
aa7c7447 JK	163	/* We may get SIGSEGV due to missing PROT_EXEC of the return_address. */
6e3c039e JK	164	if (WSTOPSIG (status) != SIGTRAP && WSTOPSIG (status) != SIGSEGV)
	165	{
	166	warning (_("linux_ptrace_test_ret_to_nx: "
	167	"WSTOPSIG %d is neither SIGTRAP nor SIGSEGV!"),
	168	(int) WSTOPSIG (status));
	169	return;
	170	}
aa7c7447 JK	171
aa7c7447 JK	172	errno = 0;
6e3c039e	173	#if defined __i386__
96d7229d LM	174	l = ptrace (PTRACE_PEEKUSER, child, (PTRACE_TYPE_ARG3) (uintptr_t) (EIP * 4),
96d7229d LM	175	(PTRACE_TYPE_ARG4) NULL);
6e3c039e	176	#elif defined __x86_64__
96d7229d LM	177	l = ptrace (PTRACE_PEEKUSER, child, (PTRACE_TYPE_ARG3) (uintptr_t) (RIP * 8),
96d7229d LM	178	(PTRACE_TYPE_ARG4) NULL);
6e3c039e JK	179	#else
	180	# error "!__i386__ && !__x86_64__"
	181	#endif
	182	if (errno != 0)
	183	{
	184	warning (_("linux_ptrace_test_ret_to_nx: Cannot PTRACE_PEEKUSER: %s"),
	185	strerror (errno));
	186	return;
	187	}
aa7c7447 JK	188	pc = (void *) (uintptr_t) l;
aa7c7447 JK	189
61a31a67	190	kill (child, SIGKILL);
96d7229d LM	191	ptrace (PTRACE_KILL, child, (PTRACE_TYPE_ARG3) NULL,
96d7229d LM	192	(PTRACE_TYPE_ARG4) NULL);
61a31a67 JK	193
	194	errno = 0;
	195	got_pid = waitpid (child, &kill_status, 0);
	196	if (got_pid != child)
6e3c039e	197	{
61a31a67 JK	198	warning (_("linux_ptrace_test_ret_to_nx: "
	199	"PTRACE_KILL waitpid returned %ld: %s"),
	200	(long) got_pid, strerror (errno));
6e3c039e JK	201	return;
6e3c039e JK	202	}
61a31a67	203	if (!WIFSIGNALED (kill_status))
aa7c7447	204	{
61a31a67 JK	205	warning (_("linux_ptrace_test_ret_to_nx: "
	206	"PTRACE_KILL status %d is not WIFSIGNALED!"),
	207	status);
	208	return;
aa7c7447 JK	209	}
	210
	211	/* + 1 is there as x86* stops after the 'int3' instruction. */
	212	if (WSTOPSIG (status) == SIGTRAP && pc == return_address + 1)
	213	{
	214	/* PASS */
	215	return;
	216	}
	217
	218	/* We may get SIGSEGV due to missing PROT_EXEC of the RETURN_ADDRESS page. */
	219	if (WSTOPSIG (status) == SIGSEGV && pc == return_address)
	220	{
	221	/* PASS */
	222	return;
	223	}
	224
6e3c039e JK	225	if ((void (*) (void)) pc != &linux_ptrace_test_ret_to_nx_instr)
	226	warning (_("linux_ptrace_test_ret_to_nx: PC %p is neither near return "
	227	"address %p nor is the return instruction %p!"),
	228	pc, return_address, &linux_ptrace_test_ret_to_nx_instr);
	229	else
025e6dce PA	230	warning (_("Cannot call inferior functions on this system - "
	231	"Linux kernel with broken i386 NX (non-executable pages) "
	232	"support detected!"));
6e3c039e	233	#endif /* defined __i386__ \|\| defined __x86_64__ */
aa7c7447 JK	234	}
aa7c7447 JK	235
96d7229d LM	236	/* Helper function to fork a process and make the child process call
	237	the function FUNCTION, passing CHILD_STACK as parameter.
	238
	239	For MMU-less targets, clone is used instead of fork, and
	240	CHILD_STACK is used as stack space for the cloned child. If NULL,
	241	stack space is allocated via malloc (and subsequently passed to
	242	FUNCTION). For MMU targets, CHILD_STACK is ignored. */
	243
	244	static int
	245	linux_fork_to_function (gdb_byte child_stack, void (function) (gdb_byte *))
	246	{
	247	int child_pid;
	248
	249	/* Sanity check the function pointer. */
	250	gdb_assert (function != NULL);
	251
	252	#if defined(__UCLIBC__) && defined(HAS_NOMMU)
	253	#define STACK_SIZE 4096
	254
	255	if (child_stack == NULL)
	256	child_stack = xmalloc (STACK_SIZE * 4);
	257
	258	/* Use CLONE_VM instead of fork, to support uClinux (no MMU). */
101158d9	259	#ifdef __ia64__
96d7229d LM	260	child_pid = __clone2 (function, child_stack, STACK_SIZE,
96d7229d LM	261	CLONE_VM \| SIGCHLD, child_stack + STACK_SIZE * 2);
101158d9	262	#else /* !__ia64__ */
96d7229d LM	263	child_pid = clone (function, child_stack + STACK_SIZE,
96d7229d LM	264	CLONE_VM \| SIGCHLD, child_stack + STACK_SIZE * 2);
101158d9	265	#endif /* !__ia64__ */
96d7229d LM	266	#else /* !defined(__UCLIBC) && defined(HAS_NOMMU) */
	267	child_pid = fork ();
	268
	269	if (child_pid == 0)
	270	function (NULL);
	271	#endif /* defined(__UCLIBC) && defined(HAS_NOMMU) */
	272
	273	if (child_pid == -1)
	274	perror_with_name (("fork"));
	275
	276	return child_pid;
	277	}
	278
	279	/* A helper function for linux_check_ptrace_features, called after
	280	the child forks a grandchild. */
	281
	282	static void
	283	linux_grandchild_function (gdb_byte *child_stack)
	284	{
	285	/* Free any allocated stack. */
	286	xfree (child_stack);
	287
	288	/* This code is only reacheable by the grandchild (child's child)
	289	process. */
	290	_exit (0);
	291	}
	292
	293	/* A helper function for linux_check_ptrace_features, called after
	294	the parent process forks a child. The child allows itself to
	295	be traced by its parent. */
	296
	297	static void
	298	linux_child_function (gdb_byte *child_stack)
	299	{
	300	ptrace (PTRACE_TRACEME, 0, (PTRACE_TYPE_ARG3) 0, (PTRACE_TYPE_ARG4) 0);
	301	kill (getpid (), SIGSTOP);
	302
	303	/* Fork a grandchild. */
	304	linux_fork_to_function (child_stack, linux_grandchild_function);
	305
	306	/* This code is only reacheable by the child (grandchild's parent)
	307	process. */
	308	_exit (0);
	309	}
	310
	311	/* Determine ptrace features available on this target. */
	312
	313	static void
	314	linux_check_ptrace_features (void)
	315	{
	316	int child_pid, ret, status;
	317	long second_pid;
	318
	319	/* Initialize the options. */
	320	current_ptrace_options = 0;
	321
	322	/* Fork a child so we can do some testing. The child will call
	323	linux_child_function and will get traced. The child will
	324	eventually fork a grandchild so we can test fork event
	325	reporting. */
	326	child_pid = linux_fork_to_function (NULL, linux_child_function);
	327
	328	ret = my_waitpid (child_pid, &status, 0);
	329	if (ret == -1)
330	perror_with_name (("waitpid"));
331	else if (ret != child_pid)
332	error (_("linux_check_ptrace_features: waitpid: unexpected result %d."),
333	ret);
334	if (! WIFSTOPPED (status))
335	error (_("linux_check_ptrace_features: waitpid: unexpected status %d."),
336	status);
337
338	/* First, set the PTRACE_O_TRACEFORK option. If this fails, we
339	know for sure that it is not supported. */
340	ret = ptrace (PTRACE_SETOPTIONS, child_pid, (PTRACE_TYPE_ARG3) 0,
341	(PTRACE_TYPE_ARG4) PTRACE_O_TRACEFORK);
342
343	if (ret != 0)
344	{
345	ret = ptrace (PTRACE_KILL, child_pid, (PTRACE_TYPE_ARG3) 0,
346	(PTRACE_TYPE_ARG4) 0);
347	if (ret != 0)
348	{
349	warning (_("linux_check_ptrace_features: failed to kill child"));
350	return;
351	}
352
353	ret = my_waitpid (child_pid, &status, 0);
354	if (ret != child_pid)
355	warning (_("linux_check_ptrace_features: failed "
356	"to wait for killed child"));
357	else if (!WIFSIGNALED (status))
358	warning (_("linux_check_ptrace_features: unexpected "
359	"wait status 0x%x from killed child"), status);
360
361	return;
362	}
363
364	#ifdef GDBSERVER
365	/* gdbserver does not support PTRACE_O_TRACESYSGOOD or
366	PTRACE_O_TRACEVFORKDONE yet. */
367	#else
368	/* Check if the target supports PTRACE_O_TRACESYSGOOD. */
369	ret = ptrace (PTRACE_SETOPTIONS, child_pid, (PTRACE_TYPE_ARG3) 0,
370	(PTRACE_TYPE_ARG4) PTRACE_O_TRACESYSGOOD);
371	if (ret == 0)
372	current_ptrace_options \|= PTRACE_O_TRACESYSGOOD;
373
374	/* Check if the target supports PTRACE_O_TRACEVFORKDONE. */
375	ret = ptrace (PTRACE_SETOPTIONS, child_pid, (PTRACE_TYPE_ARG3) 0,
376	(PTRACE_TYPE_ARG4) (PTRACE_O_TRACEFORK
377	\| PTRACE_O_TRACEVFORKDONE));
378	if (ret == 0)
379	current_ptrace_options \|= PTRACE_O_TRACEVFORKDONE;
380	#endif
381
382	/* Setting PTRACE_O_TRACEFORK did not cause an error, however we
383	don't know for sure that the feature is available; old
384	versions of PTRACE_SETOPTIONS ignored unknown options.
385	Therefore, we attach to the child process, use PTRACE_SETOPTIONS
386	to enable fork tracing, and let it fork. If the process exits,
387	we assume that we can't use PTRACE_O_TRACEFORK; if we get the
388	fork notification, and we can extract the new child's PID, then
389	we assume that we can.
390
391	We do not explicitly check for vfork tracing here. It is
392	assumed that vfork tracing is available whenever fork tracing
393	is available. */
394	ret = ptrace (PTRACE_CONT, child_pid, (PTRACE_TYPE_ARG3) 0,
395	(PTRACE_TYPE_ARG4) 0);
396	if (ret != 0)
397	warning (_("linux_check_ptrace_features: failed to resume child"));
398
399	ret = my_waitpid (child_pid, &status, 0);
400
401	/* Check if we received a fork event notification. */
402	if (ret == child_pid && WIFSTOPPED (status)
403	&& status >> 16 == PTRACE_EVENT_FORK)
404	{
405	/* We did receive a fork event notification. Make sure its PID
406	is reported. */
407	second_pid = 0;
408	ret = ptrace (PTRACE_GETEVENTMSG, child_pid, (PTRACE_TYPE_ARG3) 0,
409	(PTRACE_TYPE_ARG4) &second_pid);
410	if (ret == 0 && second_pid != 0)
411	{
412	int second_status;
413
414	/* We got the PID from the grandchild, which means fork
415	tracing is supported. */
416	#ifdef GDBSERVER
417	/* Do not enable all the options for now since gdbserver does not
418	properly support them. This restriction will be lifted when
419	gdbserver is augmented to support them. */
420	current_ptrace_options \|= PTRACE_O_TRACECLONE;
421	#else
422	current_ptrace_options \|= PTRACE_O_TRACEFORK \| PTRACE_O_TRACEVFORK
423	\| PTRACE_O_TRACECLONE \| PTRACE_O_TRACEEXEC;
424
425	/* Do not enable PTRACE_O_TRACEEXIT until GDB is more prepared to
426	support read-only process state. */
427	#endif
428
429	/* Do some cleanup and kill the grandchild. */
430	my_waitpid (second_pid, &second_status, 0);
431	ret = ptrace (PTRACE_KILL, second_pid, (PTRACE_TYPE_ARG3) 0,
432	(PTRACE_TYPE_ARG4) 0);
433	if (ret != 0)
434	warning (_("linux_check_ptrace_features: "
435	"failed to kill second child"));
436	my_waitpid (second_pid, &status, 0);
437	}
438	}
439	else
440	warning (_("linux_check_ptrace_features: unexpected result from waitpid "
441	"(%d, status 0x%x)"), ret, status);
442
443	/* Clean things up and kill any pending children. */
444	do
445	{
446	ret = ptrace (PTRACE_KILL, child_pid, (PTRACE_TYPE_ARG3) 0,
447	(PTRACE_TYPE_ARG4) 0);
448	if (ret != 0)
101158d9	449	warning (_("linux_check_ptrace_features: failed to kill child"));
96d7229d LM	450	my_waitpid (child_pid, &status, 0);
	451	}
	452	while (WIFSTOPPED (status));
	453	}
	454
	455	/* Enable reporting of all currently supported ptrace events. */
	456
	457	void
	458	linux_enable_event_reporting (pid_t pid)
	459	{
	460	/* Check if we have initialized the ptrace features for this
	461	target. If not, do it now. */
	462	if (current_ptrace_options == -1)
	463	linux_check_ptrace_features ();
	464
	465	/* Set the options. */
	466	ptrace (PTRACE_SETOPTIONS, pid, (PTRACE_TYPE_ARG3) 0,
	467	(PTRACE_TYPE_ARG4) (uintptr_t) current_ptrace_options);
	468	}
	469
	470	/* Returns non-zero if PTRACE_OPTIONS is contained within
	471	CURRENT_PTRACE_OPTIONS, therefore supported. Returns 0
	472	otherwise. */
	473
	474	static int
	475	ptrace_supports_feature (int ptrace_options)
	476	{
	477	gdb_assert (current_ptrace_options >= 0);
	478
	479	return ((current_ptrace_options & ptrace_options) == ptrace_options);
	480	}
	481
	482	/* Returns non-zero if PTRACE_EVENT_FORK is supported by ptrace,
	483	0 otherwise. Note that if PTRACE_EVENT_FORK is supported so is
	484	PTRACE_EVENT_CLONE, PTRACE_EVENT_EXEC and PTRACE_EVENT_VFORK,
	485	since they were all added to the kernel at the same time. */
	486
	487	int
	488	linux_supports_tracefork (void)
	489	{
	490	return ptrace_supports_feature (PTRACE_O_TRACEFORK);
	491	}
	492
	493	/* Returns non-zero if PTRACE_EVENT_CLONE is supported by ptrace,
	494	0 otherwise. Note that if PTRACE_EVENT_CLONE is supported so is
	495	PTRACE_EVENT_FORK, PTRACE_EVENT_EXEC and PTRACE_EVENT_VFORK,
	496	since they were all added to the kernel at the same time. */
	497
	498	int
	499	linux_supports_traceclone (void)
	500	{
	501	return ptrace_supports_feature (PTRACE_O_TRACECLONE);
	502	}
	503
	504	/* Returns non-zero if PTRACE_O_TRACEVFORKDONE is supported by
	505	ptrace, 0 otherwise. */
	506
	507	int
	508	linux_supports_tracevforkdone (void)
	509	{
	510	return ptrace_supports_feature (PTRACE_O_TRACEVFORKDONE);
	511	}
	512
	513	/* Returns non-zero if PTRACE_O_TRACESYSGOOD is supported by ptrace,
514	0 otherwise. */
515
516	int
517	linux_supports_tracesysgood (void)
518	{
519	return ptrace_supports_feature (PTRACE_O_TRACESYSGOOD);
520	}
521
aa7c7447 JK	522	/* Display possible problems on this system. Display them only once per GDB
	523	execution. */
	524
	525	void
	526	linux_ptrace_init_warnings (void)
	527	{
	528	static int warned = 0;
	529
	530	if (warned)
	531	return;
	532	warned = 1;
	533
	534	linux_ptrace_test_ret_to_nx ();
	535	}