Retro68/gcc/libjava/java/lang/natPosixProcess.cc

// natPosixProcess.cc - Native side of POSIX process code.

/* Copyright (C) 1998, 1999, 2000, 2002, 2003, 2004, 2005, 2006, 2007
  Free Software Foundation

   This file is part of libgcj.

This software is copyrighted work licensed under the terms of the
Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
details.  */

#include <config.h>

#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#include <errno.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/wait.h>
#ifdef HAVE_SYS_TIME_H
#include <sys/time.h>
#endif
#ifdef HAVE_SYS_RESOURCE_H
#include <sys/resource.h>
#endif
#include <signal.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>

#include <posix.h>
#include <posix-threads.h>
#include <jvm.h>

#include <java/lang/PosixProcess$ProcessManager.h>
#include <java/lang/PosixProcess.h>
#include <java/lang/IllegalThreadStateException.h>
#include <java/lang/InternalError.h>
#include <java/lang/InterruptedException.h>
#include <java/lang/NullPointerException.h>
#include <java/lang/Thread.h>
#include <java/io/File.h>
#include <java/io/FileDescriptor.h>
#include <gnu/java/nio/channels/FileChannelImpl.h>
#include <java/io/FileInputStream.h>
#include <java/io/FileOutputStream.h>
#include <java/io/IOException.h>
#include <java/lang/OutOfMemoryError.h>
#include <java/lang/PosixProcess$EOFInputStream.h>

using gnu::java::nio::channels::FileChannelImpl;
using namespace java::lang;

extern char **environ;

static char *
new_string (jstring string)
{
  jsize s = _Jv_GetStringUTFLength (string);
  char *buf = (char *) _Jv_Malloc (s + 1);
  _Jv_GetStringUTFRegion (string, 0, string->length(), buf);
  buf[s] = '\0';
  return buf;
}

static void
cleanup (char **args, char **env, char *path)
{
  if (args != NULL)
    {
      for (int i = 0; args[i] != NULL; ++i)
	_Jv_Free (args[i]);
      _Jv_Free (args);
    }
  if (env != NULL)
    {
      for (int i = 0; env[i] != NULL; ++i)
	_Jv_Free (env[i]);
      _Jv_Free (env);
    }
  if (path != NULL)
    _Jv_Free (path);
}

// This makes our error handling a bit simpler and it lets us avoid
// thread bugs where we close a possibly-reopened file descriptor for
// a second time.
static void
myclose (int &fd)
{
  if (fd != -1)
    close (fd);
  fd = -1;
}

namespace
{
  struct ProcessManagerInternal
  {
    int pipe_ends[2];
    struct sigaction old_sigaction;
  };
}


// There has to be a signal handler in order to be able to
// sigwait() on SIGCHLD.  The information passed is ignored as it
// will be recovered by the waitpid() call.
static void
#ifdef SA_SIGINFO
sigchld_handler (int sig, siginfo_t *si, void *third)
#else
sigchld_handler (int sig)
#endif
{
  if (PosixProcess$ProcessManager::nativeData != NULL)
    {
      ProcessManagerInternal *pmi =
        (ProcessManagerInternal *)PosixProcess$ProcessManager::nativeData;
      char c = 0;
      ::write(pmi->pipe_ends[1], &c, 1);
      if (pmi->old_sigaction.sa_handler != SIG_DFL
          && pmi->old_sigaction.sa_handler != SIG_IGN)
        {
#ifdef SA_SIGINFO
          if ((pmi->old_sigaction.sa_flags & SA_SIGINFO) != 0)
            pmi->old_sigaction.sa_sigaction(sig, si, third);
          else
#endif
            (*pmi->old_sigaction.sa_handler)(sig);
        }
    }
}


// Get ready to enter the main reaper thread loop.
void
java::lang::PosixProcess$ProcessManager::init ()
{
  // The nativeData is static to avoid races installing the signal
  // handler in the case that it is chained.
  if (nativeData == NULL )
    {
      ProcessManagerInternal *pmi =
        (ProcessManagerInternal *)JvAllocBytes(sizeof(ProcessManagerInternal));

      if (0 != ::pipe(pmi->pipe_ends))
        goto error;

      // Make writing non-blocking so that the signal handler will
      // never block.
      int fl = ::fcntl(pmi->pipe_ends[1], F_GETFL);
      ::fcntl(pmi->pipe_ends[1], F_SETFL, fl | O_NONBLOCK);

      nativeData = (::gnu::gcj::RawDataManaged *)pmi;

      // SIGCHLD is blocked in all threads in posix-threads.cc.
      // Setup the SIGCHLD handler.
      struct sigaction sa;
      memset (&sa, 0, sizeof (sa));

#ifdef SA_SIGINFO
      sa.sa_sigaction = sigchld_handler;
      // We only want signals when the things exit.
      sa.sa_flags = SA_NOCLDSTOP | SA_SIGINFO;
#else
      sa.sa_handler = sigchld_handler;
      // We only want signals when the things exit.
      sa.sa_flags = SA_NOCLDSTOP;
#endif

      if (-1 == sigaction (SIGCHLD, &sa, &pmi->old_sigaction))
        goto error;
    }
  // All OK.
  return;

error:
  throw new InternalError (JvNewStringUTF (strerror (errno)));
}

void
java::lang::PosixProcess$ProcessManager::waitForSignal ()
{
  // Wait for SIGCHLD
  _Jv_UnBlockSigchld();
  ProcessManagerInternal *pmi = (ProcessManagerInternal *)nativeData;

  // Try to read multiple (64) notifications in one go.
  char c[64];
 ::read(pmi->pipe_ends[0], c, sizeof (c));

  _Jv_BlockSigchld();

  return;
}

jboolean java::lang::PosixProcess$ProcessManager::reap (PosixProcess *p)
{
  pid_t rv;

  // Try to get the return code from the child process.
  int status;
  rv = ::waitpid ((pid_t)p->pid, &status, WNOHANG);
  if (rv == -1)
    throw new InternalError (JvNewStringUTF (strerror (errno)));

  if (rv == 0)
    return false;   // No children to wait for.

  JvSynchronize sync (p);
  p->status = WIFEXITED (status) ? WEXITSTATUS (status) : -1;
  p->state = PosixProcess::STATE_TERMINATED;
  p->processTerminationCleanup();
  p->notifyAll ();
  return true;
}

void
java::lang::PosixProcess$ProcessManager::signalReaper ()
{
  ProcessManagerInternal *pmi = (ProcessManagerInternal *)nativeData;
  char c = 0;
  ::write(pmi->pipe_ends[1], &c, 1);
  // Ignore errors.  If EPIPE the reaper has already exited.
}

void
java::lang::PosixProcess::nativeDestroy ()
{
  int c = ::kill ((pid_t) pid, SIGKILL);
  if (c == 0)
    return;
  // kill() failed.
  throw new InternalError (JvNewStringUTF (strerror (errno)));
}

void
java::lang::PosixProcess::nativeSpawn ()
{
  using namespace java::io;

  // Initialize all locals here to make cleanup simpler.
  char **args = NULL;
  char **env = NULL;
  char *path = NULL;
  int inp[2], outp[2], errp[2], msgp[2];
  inp[0] = -1;
  inp[1] = -1;
  outp[0] = -1;
  outp[1] = -1;
  errp[0] = -1;
  errp[1] = -1;
  msgp[0] = -1;
  msgp[1] = -1;
  errorStream = NULL;
  inputStream = NULL;
  outputStream = NULL;

  try
    {
      // Transform arrays to native form.
      args = (char **) _Jv_Malloc ((progarray->length + 1) * sizeof (char *));

      // Initialize so we can gracefully recover.
      jstring *elts = elements (progarray);
      for (int i = 0; i <= progarray->length; ++i)
	args[i] = NULL;

      for (int i = 0; i < progarray->length; ++i)
	args[i] = new_string (elts[i]);
      args[progarray->length] = NULL;

      if (envp)
	{
          bool need_path = true;
          bool need_ld_library_path = true;
          int i;

          // Preserve PATH and LD_LIBRARY_PATH unless specified
          // explicitly.  We need three extra slots.  Potentially PATH
          // and LD_LIBRARY_PATH will be added plus the NULL
          // termination.
	  env = (char **) _Jv_Malloc ((envp->length + 3) * sizeof (char *));
	  elts = elements (envp);

	  // Initialize so we can gracefully recover.
	  for (i = 0; i < envp->length + 3; ++i)
	    env[i] = NULL;

	  for (i = 0; i < envp->length; ++i)
            {
              env[i] = new_string (elts[i]);
              if (!strncmp (env[i], "PATH=", sizeof("PATH=")))
                need_path = false;
              if (!strncmp (env[i], "LD_LIBRARY_PATH=",
                            sizeof("LD_LIBRARY_PATH=")))
                need_ld_library_path = false;
            }

          if (need_path)
            {
	      char *path_val = getenv ("PATH");
              if (path_val)
                {
                  env[i] = (char *) _Jv_Malloc (strlen (path_val) +
                                                sizeof("PATH=") + 1);
                  strcpy (env[i], "PATH=");
                  strcat (env[i], path_val);
                  i++;
                }
            }
          if (need_ld_library_path)
            {
	      char *path_val = getenv ("LD_LIBRARY_PATH");
              if (path_val)
                {
                  env[i] =
                    (char *) _Jv_Malloc (strlen (path_val) +
                                         sizeof("LD_LIBRARY_PATH=") + 1);
                  strcpy (env[i], "LD_LIBRARY_PATH=");
                  strcat (env[i], path_val);
                  i++;
                }
            }
	  env[i] = NULL;
	}

      // We allocate this here because we can't call malloc() after
      // the fork.
      if (dir != NULL)
	path = new_string (dir->getPath ());

      // Create pipes for I/O.  MSGP is for communicating exec()
      // status.  If redirecting stderr to stdout, we don't need to
      // create the ERRP pipe.
      if (pipe (inp) || pipe (outp) || pipe (msgp)
	  || fcntl (msgp[1], F_SETFD, FD_CLOEXEC))
	throw new IOException (JvNewStringUTF (strerror (errno)));
      if (! redirect && pipe (errp))
	throw new IOException (JvNewStringUTF (strerror (errno)));

      // We create the streams before forking.  Otherwise if we had an
      // error while creating the streams we would have run the child
      // with no way to communicate with it.
      if (redirect)
	errorStream = PosixProcess$EOFInputStream::instance;
      else
	errorStream =
	  new FileInputStream (new
			       FileChannelImpl (errp[0],
						FileChannelImpl::READ));
      inputStream =
	new FileInputStream (new
			     FileChannelImpl (inp[0], FileChannelImpl::READ));
      outputStream =
	new FileOutputStream (new FileChannelImpl (outp[1],
						   FileChannelImpl::WRITE));

      // We don't use vfork() because that would cause the local
      // environment to be set by the child.

    // Use temporary for fork result to avoid dirtying an extra page.
    pid_t pid_tmp;
    if ((pid_tmp = fork ()) == -1)
      throw new IOException (JvNewStringUTF (strerror (errno)));

    if (pid_tmp == 0)
	{
	  // Child process, so remap descriptors, chdir and exec.
	  if (envp)
            environ = env;

	  // We ignore errors from dup2 because they should never occur.
	  dup2 (outp[0], 0);
	  dup2 (inp[1], 1);
	  dup2 (redirect ? inp[1] : errp[1], 2);

	  // Use close and not myclose -- we're in the child, and we
	  // aren't worried about the possible race condition.
	  close (inp[0]);
	  close (inp[1]);
	  if (! redirect)
	    {
	      close (errp[0]);
	      close (errp[1]);
	    }
	  close (outp[0]);
	  close (outp[1]);
	  close (msgp[0]);

	  // Change directory.
	  if (path != NULL)
	    {
	      if (chdir (path) != 0)
		{
		  char c = errno;
		  write (msgp[1], &c, 1);
		  _exit (127);
		}
	    }
          // Make sure all file descriptors are closed.  In
          // multi-threaded programs, there is a race between when a
          // descriptor is obtained, when we can set FD_CLOEXEC, and
          // fork().  If the fork occurs before FD_CLOEXEC is set, the
          // descriptor would leak to the execed process if we did not
          // manually close it.  So that is what we do.  Since we
          // close all the descriptors, it is redundant to set
          // FD_CLOEXEC on them elsewhere.
          int max_fd;
#ifdef HAVE_GETRLIMIT
          rlimit rl;
          int rv = getrlimit(RLIMIT_NOFILE, &rl);
          if (rv == 0)
            max_fd = rl.rlim_max - 1;
          else
            max_fd = 1024 - 1;
#else
          max_fd = 1024 - 1;
#endif
          while(max_fd > 2)
            {
              if (max_fd != msgp[1])
                close (max_fd);
              max_fd--;
            }
	  // Make sure that SIGCHLD is unblocked for the new process.
	  sigset_t mask;
	  sigemptyset (&mask);
	  sigaddset (&mask, SIGCHLD);
	  sigprocmask (SIG_UNBLOCK, &mask, NULL);

	  execvp (args[0], args);

	  // Send the parent notification that the exec failed.
	  char c = errno;
	  write (msgp[1], &c, 1);
	  _exit (127);
	}

      // Parent.  Close extra file descriptors and mark ours as
      // close-on-exec.
      pid = (jlong) pid_tmp;

      myclose (outp[0]);
      myclose (inp[1]);
      if (! redirect)
	myclose (errp[1]);
      myclose (msgp[1]);

      char c;
      int r = read (msgp[0], &c, 1);
      if (r == -1)
        throw new IOException (JvNewStringUTF (strerror (errno)));
      else if (r != 0)
        throw new IOException (JvNewStringUTF (strerror (c)));
    }
  catch (java::lang::Throwable *thrown)
    {
      // Do some cleanup we only do on failure.  If a stream object
      // has been created, we must close the stream itself (to avoid
      // duplicate closes when the stream object is collected).
      // Otherwise we simply close the underlying file descriptor.
      // We ignore errors here as they are uninteresting.

      try
	{
	  if (inputStream != NULL)
	    inputStream->close ();
	  else
	    myclose (inp[0]);
	}
      catch (java::lang::Throwable *ignore)
	{
	}

      try
	{
	  if (outputStream != NULL)
	    outputStream->close ();
	  else
	    myclose (outp[1]);
	}
      catch (java::lang::Throwable *ignore)
	{
	}

      try
	{
	  if (errorStream != NULL)
	    errorStream->close ();
	  else if (! redirect)
	    myclose (errp[0]);
	}
      catch (java::lang::Throwable *ignore)
	{
	}

      // These are potentially duplicate, but it doesn't matter due to
      // the use of myclose.
      myclose (outp[0]);
      myclose (inp[1]);
      if (! redirect)
	myclose (errp[1]);
      myclose (msgp[1]);

      exception = thrown;
    }

  myclose (msgp[0]);
  cleanup (args, env, path);
}