path: root/gcc-4.4.3/libjava/java/lang/PosixProcess.java

// PosixProcess.java - Subclass of Process for POSIX systems.
/* Copyright (C) 1998, 1999, 2004, 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.  */

package java.lang;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Iterator;
import java.util.LinkedList;

import gnu.gcj.RawDataManaged;

/**
 * @author Tom Tromey <tromey@cygnus.com>
 * @date May 3, 1999
 * @author David Daney <ddaney@avtrex.com> Rewrote using
 * ProcessManager
 */
final class PosixProcess extends Process
{
  static final class ProcessManager extends Thread
  {
    /**
     * A list of {@link PosixProcess PosixProcesses} to be
     * started.  The queueLock object is used as the lock Object
     * for all process related operations. To avoid dead lock
     * ensure queueLock is obtained before PosixProcess.
     */
    private LinkedList<PosixProcess> queue = new LinkedList<PosixProcess>();
    private LinkedList<PosixProcess> liveProcesses =
      new LinkedList<PosixProcess>();
    private boolean ready = false;

    static RawDataManaged nativeData;

    ProcessManager()
    {
      // Use package private Thread constructor to place us in the
      // root ThreadGroup with no InheritableThreadLocal.  If the
      // InheritableThreadLocals were allowed to initialize, they could
      // cause a Runtime.exec() to be called causing infinite
      // recursion.
      super("ProcessManager", true);
      // Don't keep the (main) process from exiting on our account.
      this.setDaemon(true);
    }

    /**
     * Add a process to the list of running processes.  This must only
     * be called with the queueLock held.
     *
     * @param p The PosixProcess.
     */
    void addToLiveProcesses(PosixProcess p)
    {
      liveProcesses.add(p);
    }

    /**
     * Queue up the PosixProcess and awake the ProcessManager.
     * The ProcessManager will start the PosixProcess from its
     * thread so it can be reaped when it terminates.
     *
     * @param p The PosixProcess.
     */
    void startExecuting(PosixProcess p)
    {
      synchronized (queueLock)
        {
	  queue.add(p);
	  signalReaper(); // If blocked in waitForSignal().
	  queueLock.notifyAll(); // If blocked in wait();
        }
    }

    /**
     * Block until the ProcessManager thread is ready to accept
     * commands.
     */
    void waitUntilReady()
    {
      synchronized (this)
        {
	  try
	    {
	      while (! ready)
		wait();
	    }
	  catch (InterruptedException ie)
	    {
	      // Ignore.
	    }
        }
    }

    /**
     * Main Process starting/reaping loop.
     */
    public void run()
    {
      init();
      // Now ready to accept requests.
      synchronized (this)
        {
          ready = true;
          this.notifyAll();
        }

      for (;;)
        {
          try
            {
              synchronized (queueLock)
                {
                  Iterator<PosixProcess> processIterator =
                    liveProcesses.iterator();
                  while (processIterator.hasNext())
                    {
                      boolean reaped = reap(processIterator.next());
                      if (reaped)
                        processIterator.remove();
                    }
                  if (liveProcesses.size() == 0 && queue.size() == 0)
                    {
                      // This reaper thread could exit, but we keep it
                      // alive for a while in case someone wants to
                      // start more Processes.
                      try
                        {
                          queueLock.wait(1000L);
                          if (queue.size() == 0)
                            {
                              processManager = null;
                              return; // Timed out.
                            }
                        }
                      catch (InterruptedException ie)
                        {
                          // Ignore and exit the thread.
                          return;
                        }
                    }
                  while (queue.size() > 0)
                    {
                      PosixProcess p = queue.remove(0);
                      p.spawn(this);
                    }
                }

              // Wait for a SIGCHLD from either an exiting process or
              // the startExecuting() method.  This is done outside of
              // the synchronized block to allow other threads to
              // enter and submit more jobs.
              waitForSignal();
            }
          catch (Exception ex)
            {
              ex.printStackTrace(System.err);
            }
        }
    }

    /**
     * Setup native signal handlers and other housekeeping things.
     */
    private native void init();

    /**
     * Block waiting for SIGCHLD.
     *
     */
    private native void waitForSignal();

    /**
     * Try to reap the specified child without blocking.
     *
     * @param p the process to try to reap.
     *
     * @return true if the process terminated.
     *
     */
    private native boolean reap(PosixProcess p);

    /**
     * Send SIGCHLD to the reaper thread.
     */
    private native void signalReaper();
  }

  public void destroy()
  {
    // Synchronized on the queueLock.  This ensures that the reaper
    // thread cannot be doing a wait() on the child.
    // Otherwise there would be a race where the OS could
    // create a process with the same pid between the wait()
    // and the update of the state which would cause a kill to
    // the wrong process.
    synchronized (queueLock)
      {
	synchronized (this)
	  {
	    // If there is no ProcessManager we cannot kill.
	    if (state != STATE_TERMINATED)
	      {
		if (processManager == null)
		  throw new InternalError();
		nativeDestroy();
	      }
	  }
      }
  }

  private native void nativeDestroy();

  public int exitValue()
  {
    synchronized (this)
      {
	if (state != STATE_TERMINATED)
	  throw new IllegalThreadStateException("Process has not exited");
      }
    return status;
  }

  /**
   * Called by native code when process exits.
   *
   * Already synchronized (this).  Close any streams that we can to
   * conserve file descriptors.
   *
   * The outputStream can be closed as any future writes will
   * generate an IOException due to EPIPE.
   *
   * The inputStream and errorStream can only be closed if the user
   * has not obtained a reference to them AND they have no bytes
   * available.  Since the process has terminated they will never have
   * any more data available and can safely be replaced by
   * EOFInputStreams.
   */
  void processTerminationCleanup()
  {
    try
      {
        outputStream.close();
      }
    catch (IOException ioe)
      {
        // Ignore.
      }
    try
      {
        if (returnedErrorStream == null && errorStream.available() == 0)
          {
            errorStream.close();
            errorStream = null;
          }
      }
    catch (IOException ioe)
      {
        // Ignore.
      }
    try
      {
        if (returnedInputStream == null && inputStream.available() == 0)
          {
            inputStream.close();
            inputStream = null;
          }
      }
    catch (IOException ioe)
      {
        // Ignore.
      }
  }

  public synchronized InputStream getErrorStream()
  {
    if (returnedErrorStream != null)
      return returnedErrorStream;

    if (errorStream == null)
      returnedErrorStream = EOFInputStream.instance;
    else
      returnedErrorStream = errorStream;

    return returnedErrorStream;
  }

  public synchronized InputStream getInputStream()
  {
    if (returnedInputStream != null)
      return returnedInputStream;

    if (inputStream == null)
      returnedInputStream = EOFInputStream.instance;
    else
      returnedInputStream = inputStream;

    return returnedInputStream;
  }

  public OutputStream getOutputStream()
  {
    return outputStream;
  }

  public int waitFor() throws InterruptedException
  {
    synchronized (this)
      {
	while (state != STATE_TERMINATED)
	  wait();
      }
    return status;
  }

  /**
   * Start this process running.  This should only be called by the
   * ProcessManager with the queueLock held.
   *
   * @param pm The ProcessManager that made the call.
   */
  void spawn(ProcessManager pm)
  {
    synchronized (this)
      {
	// Do the fork/exec magic.
	nativeSpawn();
	// There is no race with reap() in the pidToProcess map
	// because this is always called from the same thread
	// doing the reaping.
	pm.addToLiveProcesses(this);
	state = STATE_RUNNING;
	// Notify anybody waiting on state change.
	this.notifyAll();
      }
  }

  /**
   * Do the fork and exec.
   */
  private native void nativeSpawn();

  PosixProcess(String[] progarray, String[] envp, File dir, boolean redirect)
    throws IOException
  {
    // Check to ensure there is something to run, and avoid
    // dereferencing null pointers in native code.
    if (progarray[0] == null)
      throw new NullPointerException();

    this.progarray = progarray;
    this.envp = envp;
    this.dir = dir;
    this.redirect = redirect;

    // Start a ProcessManager if there is not one already running.
    synchronized (queueLock)
      {
	if (processManager == null)
	  {
	    processManager = new ProcessManager();
	    processManager.start();
	    processManager.waitUntilReady();
	  }

	// Queue this PosixProcess for starting by the ProcessManager.
	processManager.startExecuting(this);
      }

    // Wait until ProcessManager has started us.
    synchronized (this)
      {
	while (state == STATE_WAITING_TO_START)
	  {
	    try
	      {
		wait();
	      }
	    catch (InterruptedException ie)
	      {
		// FIXME: What to do when interrupted while blocking in a constructor?
		// Ignore.
	      }
	  }
      }

    // If there was a problem, re-throw it.
    if (exception != null)
      {
	if (exception instanceof IOException)
	  {
	    IOException ioe = new IOException(exception.toString());
	    ioe.initCause(exception);
	    throw ioe;
	  }

	// Not an IOException.  Something bad happened.
	InternalError ie = new InternalError(exception.toString());
	ie.initCause(exception);
	throw ie;
      }

    // If we get here, all is well, the Process has started.
  }

  private String[] progarray;
  private String[] envp;
  private File dir;
  private boolean redirect;

  /** Set by the ProcessManager on problems starting. */
  private Throwable exception;

  /** The process id.  This is cast to a pid_t on the native side. */
  long pid;

  // FIXME: Why doesn't the friend declaration in PosixProcess.h
  // allow PosixProcess$ProcessManager native code access these
  // when they are private?

  /** Before the process is forked. */
  static final int STATE_WAITING_TO_START = 0;

  /** After the fork. */
  static final int STATE_RUNNING = 1;

  /** After exit code has been collected. */
  static final int STATE_TERMINATED = 2;

  /** One of STATE_WAITING_TO_START, STATE_RUNNING, STATE_TERMINATED. */
  int state;

  /** The exit status, if the child has exited. */
  int status;

  /** The streams. */
  private InputStream errorStream;
  private InputStream inputStream;
  private OutputStream outputStream;

  /** InputStreams obtained by the user.  Not null indicates that the
   *  user has obtained the stream.
   */
  private InputStream returnedErrorStream;
  private InputStream returnedInputStream;

  /**
   * Lock Object for all processManager related locking.
   */
  private static Object queueLock = new Object();
  private static ProcessManager processManager;

  static class EOFInputStream extends InputStream
  {
    static EOFInputStream instance = new EOFInputStream();
    public int read()
    {
      return -1;
    }
  }
}