/* This testcase is part of GDB, the GNU debugger.

   Copyright 2018-2020 Free Software Foundation, Inc.

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

/* This file contains a library that can be preloaded into GDB on Linux
   using the LD_PRELOAD technique.

   The library intercepts calls to WAITPID and SIGSUSPEND in order to
   simulate the behaviour of a heavily loaded kernel.

   When GDB wants to stop all threads in an inferior each thread is sent a
   SIGSTOP, GDB will then wait for the signal to be received by the thread
   with a waitpid call.

   If the kernel is slow in either delivering the signal, or making the
   result available to the waitpid call then GDB will enter a sigsuspend
   call in order to wait for the inferior threads to change state, this is
   signalled to GDB with a SIGCHLD.

   A bug in GDB meant that in some cases we would deadlock during this
   process.  This was rarely seen as the kernel is usually quick at
   delivering signals and making the results available to waitpid, so quick
   that GDB would gather the statuses from all inferior threads in the
   original pass.

   The idea in this library is to rate limit calls to waitpid (where pid is
   -1 and the WNOHANG option is set) so that only 1 per second can return
   an answer.  Any additional calls will report that no threads are
   currently ready.  This should match the behaviour we see on a slow
   kernel.

   However, given that usually when using this library, the kernel does
   have the waitpid result ready this means that the kernel will never send
   GDB a SIGCHLD.  This means that when GDB enters sigsuspend it will block
   forever.  Alternatively, if GDB enters its polling loop the lack of
   SIGCHLD means that we will never see an event on the child threads.  To
   resolve these problems the library intercepts calls to sigsuspend and
   forces the call to exit if there is a pending waitpid result.  Also,
   when we know that there's a waitpid result that we've ignored, we create
   a new thread which, after a short delay, will send GDB a SIGCHLD.  */

#define _GNU_SOURCE

#include <sys/types.h>
#include <sys/wait.h>
#include <sys/time.h>
#include <stdlib.h>
#include <stdio.h>
#include <dlfcn.h>
#include <string.h>
#include <stdarg.h>
#include <signal.h>
#include <errno.h>
#include <pthread.h>
#include <unistd.h>

/* Logging.  */

static void
log_msg (const char *fmt, ...)
{
#ifdef LOGGING
  va_list ap;

  va_start (ap, fmt);
  vfprintf (stderr, fmt, ap);
  va_end (ap);
#endif /* LOGGING */
}

/* Error handling, message and exit.  */

static void
error (const char *fmt, ...)
{
  va_list ap;

  va_start (ap, fmt);
  vfprintf (stderr, fmt, ap);
  va_end (ap);

  exit (EXIT_FAILURE);
}

/* Cache the result of a waitpid call that has not been reported back to
   GDB yet.  We only ever cache a single result.  Once we have a result
   cached then later calls to waitpid with the WNOHANG option will return a
   result of 0.  */

static struct
{
  /* Flag to indicate when we have a result cached.  */
  int cached_p;

  /* The cached result fields from a waitpid call.  */
  pid_t pid;
  int wstatus;
} cached_wait_status;

/* Lock to hold when modifying SIGNAL_THREAD_ACTIVE_P.  */

static pthread_mutex_t thread_creation_lock_obj = PTHREAD_MUTEX_INITIALIZER;
#define thread_creation_lock (&thread_creation_lock_obj)

/* This flag is only modified while holding the THREAD_CREATION_LOCK mutex.
   When this flag is true then there is a signal thread alive that will be
   sending a SIGCHLD at some point in the future.  */

static int signal_thread_active_p;

/* When we last allowed a waitpid to complete.  */

static struct timeval last_waitpid_time = { 0, 0 };

/* The number of seconds that must elapse between calls to waitpid where
   the pid is -1 and the WNOHANG option is set.  If calls occur faster than
   this then we force a result of 0 to be returned from waitpid.  */

#define WAITPID_MIN_TIME (1)

/* Return true (non-zero) if we should skip this call to waitpid, or false
   (zero) if this waitpid call should be handled with a call to the "real"
   waitpid function.  Allows 1 waitpid call per second.  */

static int
should_skip_waitpid (void)
{
  struct timeval *tv = &last_waitpid_time;
  if (tv->tv_sec == 0)
    {
      if (gettimeofday (tv, NULL) < 0)
	error ("error: gettimeofday failed\n");
      return 0; /* Don't skip.  */
    }
  else
    {
      struct timeval new_tv;

      if (gettimeofday (&new_tv, NULL) < 0)
	error ("error: gettimeofday failed\n");

      if ((new_tv.tv_sec - tv->tv_sec) < WAITPID_MIN_TIME)
	return 1; /* Skip.  */

      *tv = new_tv;
    }

  /* Don't skip.  */
  return 0;
}

/* Perform a real waitpid call.  */

static pid_t
real_waitpid (pid_t pid, int *wstatus, int options)
{
  typedef pid_t (*fptr_t) (pid_t, int *, int);
  static fptr_t real_func = NULL;

  if (real_func == NULL)
    {
      real_func = dlsym (RTLD_NEXT, "waitpid");
      if (real_func == NULL)
	error ("error: failed to find real waitpid\n");
    }

  return (*real_func) (pid, wstatus, options);
}

/* Thread worker created when we cache a waitpid result.  Delays for a
   short period of time and then sends SIGCHLD to the GDB process.  This
   should trigger GDB to call waitpid again, at which point we will make
   the cached waitpid result available.  */

static void*
send_sigchld_thread (void *arg)
{
  /* Delay one second longer than WAITPID_MIN_TIME so that there can be no
     chance that a call to SHOULD_SKIP_WAITPID will return true once the
     SIGCHLD is delivered and handled.  */
  sleep (WAITPID_MIN_TIME + 1);

  pthread_mutex_lock (thread_creation_lock);
  signal_thread_active_p = 0;

  if (cached_wait_status.cached_p)
    {
      log_msg ("signal-thread: sending SIGCHLD\n");
      kill (getpid (), SIGCHLD);
    }

  pthread_mutex_unlock (thread_creation_lock);
  return NULL;
}

/* The waitpid entry point function.  */

pid_t
waitpid (pid_t pid, int *wstatus, int options)
{
  log_msg ("waitpid: waitpid (%d, %p, 0x%x)\n", pid, wstatus, options);

  if ((options & WNOHANG) != 0
      && pid == -1
      && should_skip_waitpid ())
    {
      if (!cached_wait_status.cached_p)
	{
	  /* Do the waitpid call, but hold the result back.  */
	  pid_t tmp_pid;
	  int tmp_wstatus;

	  tmp_pid = real_waitpid (-1, &tmp_wstatus, options);
	  if (tmp_pid > 0)
	    {
	      log_msg ("waitpid: delaying waitpid result (pid = %d)\n",
		       tmp_pid);

	      /* Cache the result.  */
	      cached_wait_status.pid = tmp_pid;
	      cached_wait_status.wstatus = tmp_wstatus;
	      cached_wait_status.cached_p = 1;

	      /* Is there a thread around that will be sending a signal in
		 the near future?  The prevents us from creating one
		 thread per call to waitpid when the calls occur in a
		 sequence.  */
	      pthread_mutex_lock (thread_creation_lock);
	      if (!signal_thread_active_p)
		{
		  sigset_t old_ss, new_ss;
		  pthread_t thread_id;
		  pthread_attr_t attr;

		  /* Create the new signal sending thread in detached
		     state.  This means that the thread doesn't need to be
		     pthread_join'ed.  Which is fine as there's no result
		     we care about.  */
		  pthread_attr_init (&attr);
		  pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);

		  /* Ensure the signal sending thread has all signals
		     blocked.  We don't want any signals to GDB to be
		     handled in that thread.  */
		  sigfillset (&new_ss);
		  sigprocmask (SIG_BLOCK, &new_ss, &old_ss);

		  log_msg ("waitpid: spawn thread to signal us\n");
		  if (pthread_create (&thread_id, &attr,
				      send_sigchld_thread, NULL) != 0)
		    error ("error: pthread_create failed\n");

		  signal_thread_active_p = 1;
		  sigprocmask (SIG_SETMASK, &old_ss, NULL);
		  pthread_attr_destroy (&attr);
		}

	      pthread_mutex_unlock (thread_creation_lock);
	    }
	}

      log_msg ("waitpid: skipping\n");
      return 0;
    }

  /* If we have a cached result that is a suitable reply for this call to
     waitpid then send that cached result back now.  */
  if (cached_wait_status.cached_p
      && (pid == -1 || pid == cached_wait_status.pid))
    {
      pid_t pid;

      pid = cached_wait_status.pid;
      log_msg ("waitpid: return cached result (%d)\n", pid);
      *wstatus = cached_wait_status.wstatus;
      cached_wait_status.cached_p = 0;
      return pid;
    }

  log_msg ("waitpid: real waitpid call\n");
  return real_waitpid (pid, wstatus, options);
}

/* Perform a real sigsuspend call.  */

static int
real_sigsuspend (const sigset_t *mask)
{
  typedef int (*fptr_t) (const sigset_t *);
  static fptr_t real_func = NULL;

  if (real_func == NULL)
    {
      real_func = dlsym (RTLD_NEXT, "sigsuspend");
      if (real_func == NULL)
	error ("error: failed to find real sigsuspend\n");
    }

  return (*real_func) (mask);
}

/* The sigsuspend entry point function.  */

int
sigsuspend (const sigset_t *mask)
{
  log_msg ("sigsuspend: sigsuspend (0x%p)\n", ((void *) mask));

  /* If SIGCHLD is _not_ in MASK, and is therefore deliverable, then if we
     have a pending wait status pretend that a signal arrived.  We will
     have a thread alive that is going to deliver a signal but doing this
     will boost the speed as we don't have to wait for a signal.  If the
     signal ends up being delivered then it should be harmless, we'll just
     perform an additional waitpid call.   */
  if (!sigismember (mask, SIGCHLD))
    {
      if (cached_wait_status.cached_p)
	{
	  log_msg ("sigsuspend: interrupt for cached waitstatus\n");
	  last_waitpid_time.tv_sec = 0;
	  last_waitpid_time.tv_usec = 0;
	  errno = EINTR;
	  return -1;
	}
    }

  log_msg ("sigsuspend: real sigsuspend call\n");
  return real_sigsuspend (mask);
}