/* Copyright 2007, Red Hat Inc.  */

#include <unistd.h>
#include <stdlib.h>
#include <assert.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <linux/unistd.h>
#include <limits.h>
#include <string.h>
#include <pthread.h>

#include "debugger.h"

#define LIBRARY 1
#include "debugger.c"


_syscall2(int, tkill, int, tid, int, sig)
int tkill(int tid, int sig);


static int attach_checked (pid_t pid, int redelivered_expect)
{
  int stopped;

  STATE (pid, (1 << STATE_SLEEPING) | (1 << STATE_RUNNING) | (1 << STATE_STOPPED));
  stopped = attach (pid);
  if (attach_redelivered != redelivered_expect)
    {
      fprintf (stderr, "Expecting redelivery of %d but found %d\n",
	       redelivered_expect, attach_redelivered);
      abort ();
    }
  /* FIXME: Why also STATE_STOPPED?  */
  STATE (pid, (1 << STATE_PTRACED) | (1 << STATE_STOPPED));
  return stopped;
}

static void detach_checked (pid_t pid, int stopped)
{
  /* FIXME: Why STATE_STOPPED?  */
  STATE (pid, (stopped ? 1 << STATE_STOPPED : 1 << STATE_PTRACED));
  detach (pid, stopped);
  STATE (pid, (stopped ? 1 << STATE_STOPPED : (1 << STATE_SLEEPING) | (1 << STATE_RUNNING)));
}

struct registry
  {
    struct registry *next;
    pid_t pid;
  };
struct registry *registry_list;

static void registry_add (pid_t pid)
{
  struct registry *new;

  new = malloc (sizeof (*new));
  assert (new != NULL);
  new->pid = pid;
  new->next = registry_list;
  registry_list = new;
}

static void registry_remove (pid_t pid)
{
  struct registry **iter_pointer;

  for (iter_pointer = &registry_list; *iter_pointer != NULL;
       iter_pointer = &(*iter_pointer)->next)
    {
      struct registry *found = *iter_pointer;
      if (found->pid != pid)
        continue;

      *iter_pointer = found->next;
      free (found);
      return;
    }
  abort ();
}

static void registry_atexit (void)
{
  struct registry *iter;

  for (iter = registry_list; iter != NULL; iter = iter->next)
    kill (iter->pid, SIGKILL);
}

static void registry_cleanup (void)
{
  struct registry *iter;
  pid_t pid;

  registry_atexit ();
  while ((pid = wait (NULL)) != -1)
    {
      for (iter = registry_list; iter != NULL; iter = iter->next)
        if (iter->pid == pid)
	  break;
      assert (iter != NULL);
    }
  assert (errno == ECHILD);
  while (registry_list)
    {
      iter = registry_list;
      registry_list = iter->next;
      free (iter);
    }
}

static void registry_handler (int signo)
{
  signal (signo, SIG_DFL);
  registry_atexit ();
  raise (signo);
}

static void child_pause (void)
{
  for (;;)
    pause ();
  /* NOTREACHED */
  abort ();
}

static void child_alrm_handler (int signo)
{
  assert (signo == SIGALRM);
  raise (SIGALRM);
}

static void child_alrm (void)
{
  void (*handler_orig) (int signo);
#if 0
  int i;
  sigset_t oldset;
#endif

  handler_orig = signal (SIGALRM, child_alrm_handler);
  assert (handler_orig == SIG_DFL);

#if 0
  i = sigprocmask (SIG_BLOCK, NULL, &oldset);
  assert (i == 0);
  printf ("sigprocmask () -> sigismember (SIGALRM) == %d\n", sigismember (&oldset, SIGALRM));
#endif

  for (;;)
    pause ();
  /* NOTREACHED */
  abort ();
}

static pid_t spawn (void *(*child) (void *data, void *input), void *data,
		    void *input, int fd_close)
{
  pid_t pid;

  pid = fork();
  switch (pid)
    {
      case -1:
        perror ("fork()");
	exit (EXIT_FAILURE);
	/* NOTREACHED */
      case 0:
        if (fd_close != -1)
	  {
	    int i;

	    i = close (fd_close);
	    assert (i == 0);
	  }
	child (data, input);
	/* NOTREACHED */
	abort ();
      default:;
	/* PASSTHRU */
    }
  /* Parent.  */

  registry_add (pid);
  STATE (pid, (1 << STATE_SLEEPING) | (1 << STATE_RUNNING));
  return pid;
}

static void murder (pid_t pid)
{
  int i;
  pid_t pid_got;
  int status;

  if (pid == 0)
    return;

  i = kill (pid, SIGKILL);
  assert (i == 0);

  pid_got = waitpid (pid, &status, 0);
  if (!(pid_got == -1 && errno == ECHILD))
    {
      assert (pid_got == pid);
      assert ((WIFSIGNALED (status) && WTERMSIG (status) == SIGKILL)
	      || (WIFEXITED (status) && WEXITSTATUS (status) == 0));
      STATE (pid, 1 << STATE_ENOENT);
    }
  else
    STATE (pid, (1 << STATE_ENOENT) | (1 << STATE_ZOMBIE));

  registry_remove (pid);
}


struct child_spawner
  {
    void *(*child) (void *data, void *input);
    void *data;
    int fd;
  };

static void *child_spawner (void *param_voidpointer, void *input)
{
  struct child_spawner *param = param_voidpointer;
  pid_t inferior;
  ssize_t inferior_size;
  int i;

  inferior = spawn (param->child, param->data, input, param->fd);

  inferior_size = write (param->fd, &inferior, sizeof (inferior));
  assert (inferior_size == sizeof (inferior));
  i = close (param->fd);
  assert (i == 0);

  waitpid (inferior, NULL, 0);
  _exit (EXIT_SUCCESS);
  /* NOTREACHED */
  abort ();
}

struct spawner
  {
    void *(*func) (void *data, void *input);
    void *data;
  };

static void *spawn_with_waiter (void *data, void *input)
{
  pid_t waiter;
  struct child_spawner param_local;
  int pipefds[2];
  int i;
  pid_t inferior;
  ssize_t inferior_size;
  unsigned char buf;
  ssize_t buf_size;
  struct spawner *param = data;

  assert (data != NULL);

  i = pipe (pipefds);
  assert (i == 0);

  param_local.child = param->func;
  param_local.data = param->data;
  param_local.fd = pipefds[1];
  waiter = spawn (child_spawner, &param_local, input, pipefds[0]);

  i = close (pipefds[1]);
  assert (i == 0);
  inferior_size = read (pipefds[0], &inferior, sizeof (inferior));
  assert (inferior_size == sizeof (inferior));
  buf_size = read (pipefds[0], &buf, sizeof (buf));
  assert (buf_size == 0);
  i = close (pipefds[0]);
  assert (i == 0);

  registry_add (inferior);

  return (void *) (unsigned long) inferior;
}

static void *spawn_without_waiter (void *data, void *input)
{
  struct spawner *param = data;

  return (void *) (unsigned long) spawn (param->func, param->data, input, -1);
}

static void body_spawner (void *(*child) (void *data, void *input), void *data,
			  void *input)
{
  pid_t inferior;
  int stopped;
  int i;

  assert (input == NULL);

  /* Plain attach/detach.  */
  inferior = (unsigned long) (*child) (data, child_pause);
  stopped = attach_checked (inferior, 0);
  assert (stopped == 0);
  detach_checked (inferior, stopped);
  murder (inferior);

  /* Attach to a process stopped by standard kill(2).  */
  inferior = (unsigned long) (*child) (data, child_pause);
  delay ();
  i = kill (inferior, SIGSTOP);
  assert (i == 0);
  STATE (inferior, 1 << STATE_STOPPED);
  stopped = attach_checked (inferior, 0);
  assert (stopped == 1);
  detach_checked (inferior, stopped);
  murder (inferior);

  /* Attach to a process stopped by Linux specific tkill(2).  */
  inferior = (unsigned long) (*child) (data, child_pause);
  delay ();
  i = tkill (inferior, SIGSTOP);
  assert (i == 0);
  STATE (inferior, 1 << STATE_STOPPED);
  stopped = attach_checked (inferior, 0);
  assert (stopped == 1);
  detach_checked (inferior, stopped);
  murder (inferior);

  /* Attach to a stopped process with already pending SIGALRM.  */
  inferior = (unsigned long) (*child) (data, child_alrm);
  STATE (inferior, 1 << STATE_SLEEPING);
  delay ();
  i = tkill (inferior, SIGSTOP);
  assert (i == 0);
  delay ();
  i = tkill (inferior, SIGALRM);
  assert (i == 0);
  STATE (inferior, 1 << STATE_STOPPED);
  /* FIXME: SIGALRM did not get redelivered?  */
#if 0
  stopped = attach_checked (inferior, SIGALRM);
#else
  stopped = attach_checked (inferior, 0);
#endif
  assert (stopped == 1);
  detach_checked (inferior, stopped);
  STATE (inferior, 1 << STATE_STOPPED);
  delay ();
  i = tkill (inferior, SIGCONT);
  assert (i == 0);
  STATE (inferior, 1 << STATE_RUNNING);
  murder (inferior);
}

static void *pass (void *data, void *input)
{
  struct spawner *param = data;
  void (*input_func) (void) = input;

  if (param != NULL)
    return (*param->func) (param->data, input);

  assert (input_func != NULL);
  (*input_func) ();
  /* NOTREACHED */
  abort ();
}

static void *spawn_singlethreaded (void *data, void *input)
{
  return pass (data, input);
}

static void *spawn_threaded_parent_start (void *arg)
{
  for (;;)
    pause ();
  /* NOTREACHED */
  abort ();
}

static void *spawn_threaded_parent (void *data, void *input)
{
  pthread_t thread;
  int i;

  i = pthread_create (&thread, NULL, spawn_threaded_parent_start, NULL);
  assert (i == 0);
  return pass (data, input);
}

struct spawn_threaded_child_start
  {
    void *data;
    void *input;
  };

static void *spawn_threaded_child_start (void *arg_voidpointer)
{
  struct spawn_threaded_child_start *arg = arg_voidpointer;

  return pass (arg->data, arg->input);
  /* NOTREACHED */
}

static void *spawn_threaded_child (void *data, void *input)
{
  pthread_t thread;
  int i;
  struct spawn_threaded_child_start arg_local;

  arg_local.data = data;
  arg_local.input = input;
  i = pthread_create (&thread, NULL, spawn_threaded_child_start, &arg_local);
  assert (i == 0);
  i = pthread_join (thread, NULL);
  assert (i == 0);

  _exit (EXIT_SUCCESS);
}

static void body_maywaiter (void *(*child) (void *data, void *input),
			    void *data, void *input)
{
  struct spawner param_local;

  param_local.func = child;
  param_local.data = data;
  body_spawner (spawn_without_waiter, &param_local, NULL);
  body_spawner (spawn_with_waiter, &param_local, NULL);
}

static volatile unsigned long loops = 0;
static volatile int loops_print = 0;

static void handler_sigusr1 (int signo)
{
  assert (signo == SIGUSR1);

  loops_print++;
}

int main (int argc, char **argv)
{
  int loop = 0;
  int i;

  if (argc == 1)
    ;
  else if (argc == 2 && strcmp (argv[1], "-l") == 0)
    loop = 1;
  else
    abort ();

  i = nice (10);
  assert (i != -1);

  atexit (registry_atexit);
  signal (SIGINT, registry_handler);
  signal (SIGABRT, registry_handler);

  signal (SIGUSR1, handler_sigusr1);

  do
    {
      while (loops_print > 0)
        {
	  printf ("%lu\n", loops);
	  loops_print--;
	}
      body_maywaiter (spawn_singlethreaded, NULL, NULL);
      body_maywaiter (spawn_threaded_parent, NULL, NULL);
      body_maywaiter (spawn_threaded_child, NULL, NULL);

      registry_cleanup ();
      loops++;
    }
  while (loop != 0);

  return EXIT_SUCCESS;
}