Subversion Repositories openrisc

/* java.lang.VMProcess -- VM implementation of java.lang.Process

   Copyright (C) 2004, 2005 Free Software Foundation, Inc.

This file is part of GNU Classpath.

GNU Classpath 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 2, or (at your option)

any later version.

GNU Classpath 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 GNU Classpath; see the file COPYING.  If not, write to the

Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

02110-1301 USA.

Linking this library statically or dynamically with other modules is

making a combined work based on this library.  Thus, the terms and

conditions of the GNU General Public License cover the whole

combination.

As a special exception, the copyright holders of this library give you

permission to link this library with independent modules to produce an

executable, regardless of the license terms of these independent

modules, and to copy and distribute the resulting executable under

terms of your choice, provided that you also meet, for each linked

independent module, the terms and conditions of the license of that

module.  An independent module is a module which is not derived from

or based on this library.  If you modify this library, you may extend

this exception to your version of the library, but you are not

obligated to do so.  If you do not wish to do so, delete this

exception statement from your version. */

package java.lang;

import java.io.File;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.util.HashMap;

import java.util.Iterator;

import java.util.LinkedList;

import java.util.List;

import java.util.Map;

/**

 * Represents one external process. Each instance of this class is in

 * one of three states: INITIAL, RUNNING, or TERMINATED. The instance

 * is {@link Object#notifyAll notifyAll()}'d each time the state changes.

 * The state of all instances is managed by a single dedicated thread

 * which does the actual fork()/exec() and wait() system calls. User

 * threads {@link Object#wait()} on the instance when creating the

 * process or waiting for it to terminate.

 *

 * <p>

 * See

 * <a href="http://gcc.gnu.org/bugzilla/show_bug.cgi?id=11801">GCC bug

 * #11801</a> for the motivation behind the design of this class.

 *

 * @author Archie Cobbs

 * @see Process

 * @see Runtime#exec(String)

 */

final class VMProcess extends Process

{

  // Possible states for a VMProcess

  private static final int INITIAL = 0;

  private static final int RUNNING = 1;

  private static final int TERMINATED = 2;

  // Dedicated thread that does all the fork()'ing and wait()'ing.

  static Thread processThread;

  // New processes waiting to be spawned by processThread.

  static final LinkedList workList = new LinkedList();

  // Return values set by nativeReap() when a child is reaped.

  // These are only accessed by processThread so no locking required.

  static long reapedPid;

  static int reapedExitValue;

  // Information about this process

  int state;                                   // current state of process

  final String[] cmd;                          // copied from Runtime.exec()

  final String[] env;                          // copied from Runtime.exec()

  final File dir;                              // copied from Runtime.exec()

  Throwable exception;                         // if process failed to start

  long pid;                                    // process id

  OutputStream stdin;                          // process input stream

  InputStream stdout;                          // process output stream

  InputStream stderr;                          // process error stream

  int exitValue;                               // process exit value

  boolean redirect;                            // redirect stderr -> stdout

  //

  // Dedicated thread that does all the fork()'ing and wait()'ing

  // for external processes. This is needed because some systems like

  // Linux use a process-per-thread model, which means the same thread

  // that did the fork()/exec() must also do the wait().

  //

  private static class ProcessThread extends Thread

  {

    // Max time (in ms) we'll delay before trying to reap another child.

    private static final int MAX_REAP_DELAY = 1000;

    // Processes created but not yet terminated; maps Long(pid) -> VMProcess

    // Only used in run() and spawn() method from this Thread, so no locking.

    private final HashMap activeMap = new HashMap();

    // We have an explicit constructor, because the default

    // constructor will be private, which means the compiler will have

    // to generate a second package-private constructor, which is

    // bogus.

    ProcessThread ()

    {

    }

    public void run()

    {

      final LinkedList workList = VMProcess.workList;

      while (true)

        {

          // Get the next process to spawn (if any) and spawn it. Spawn

          // at most one at a time before checking for reapable children.

          VMProcess process = null;

          synchronized (workList)

            {

              if (!workList.isEmpty())

                process = (VMProcess)workList.removeFirst();

            }

          if (process != null)

            spawn(process);

          // Check for termination of active child processes

          while (!activeMap.isEmpty() && VMProcess.nativeReap())

            {

              long pid = VMProcess.reapedPid;

              int exitValue = VMProcess.reapedExitValue;

              process = (VMProcess)activeMap.remove(new Long(pid));

              if (process != null)

                {

                  synchronized (process)

                    {

                      process.exitValue = exitValue;

                      process.state = TERMINATED;

                      process.notify();

                    }

                }

              else

                System.err.println("VMProcess WARNING reaped unknown process: "

                                   + pid);

            }

          // If there are more new processes to create, go do that now.

          // If there is nothing left to do, exit this thread. Otherwise,

          // sleep a little while, and then check again for reapable children.

          // We will get woken up immediately if there are new processes to

          // spawn, but not if there are new children to reap. So we only

          // sleep a short time, in effect polling while processes are active.

          synchronized (workList)

            {

              if (!workList.isEmpty())

                continue;

              if (activeMap.isEmpty())

                {

                  processThread = null;

                  break;

                }

              try

                {

                  workList.wait(MAX_REAP_DELAY);

                }

              catch (InterruptedException e)

                {

                  /* ignore */

                }

            }

        }

    }

    // Spawn a process

    private void spawn(VMProcess process)

    {

      // Spawn the process and put it in our active map indexed by pid.

      // If the spawn operation fails, store the exception with the process.

      // In either case, wake up thread that created the process.

      synchronized (process)

        {

          try

            {

              process.nativeSpawn(process.cmd, process.env, process.dir,

                                  process.redirect);

              process.state = RUNNING;

              activeMap.put(new Long(process.pid), process);

            }

          catch (ThreadDeath death)

            {

              throw death;

            }

          catch (Throwable t)

            {

              process.state = TERMINATED;

              process.exception = t;

            }

          process.notify();

        }

    }

  }

  // Constructor

  private VMProcess(String[] cmd, String[] env, File dir, boolean redirect)

    throws IOException

  {

    // Initialize this process

    this.state = INITIAL;

    this.cmd = cmd;

    this.env = env;

    this.dir = dir;

    this.redirect = redirect;

    // Add process to the new process work list and wakeup processThread

    synchronized (workList)

      {

        workList.add(this);

        if (processThread == null)

          {

            processThread = new ProcessThread();

            processThread.setDaemon(true);

            processThread.start();

          }

        else

          {

            workList.notify();

          }

      }

    // Wait for processThread to spawn this process and update its state

    synchronized (this)

      {

        while (state == INITIAL)

          {

            try

              {

                wait();

              }

            catch (InterruptedException e)

              {

                /* ignore */

              }

          }

      }

    // If spawning failed, rethrow the exception in this thread

    if (exception != null)

      {

        exception.fillInStackTrace();

        if (exception instanceof IOException)

          throw (IOException)exception;

        if (exception instanceof Error)

          throw (Error)exception;

        if (exception instanceof RuntimeException)

          throw (RuntimeException)exception;

        throw new RuntimeException(exception);

      }

  }

  // Invoked by native code (from nativeSpawn()) to record process info.

  private void setProcessInfo(OutputStream stdin,

                              InputStream stdout, InputStream stderr, long pid)

  {

    this.stdin = stdin;

    this.stdout = stdout;

    if (stderr == null)

      this.stderr = new InputStream()

        {

          public int read() throws IOException

          {

            return -1;

          }

        };

    else

      this.stderr = stderr;

    this.pid = pid;

  }

  /**

   * Entry point from Runtime.exec().

   */

  static Process exec(String[] cmd, String[] env, File dir) throws IOException

  {

    return new VMProcess(cmd, env, dir, false);

  }

  static Process exec(List cmd, Map env,

                      File dir, boolean redirect) throws IOException

  {

    String[] acmd = (String[]) cmd.toArray(new String[cmd.size()]);

    String[] aenv = new String[env.size()];

    int i = 0;

    Iterator iter = env.entrySet().iterator();

    while (iter.hasNext())

      {

        Map.Entry entry = (Map.Entry) iter.next();

        aenv[i++] = entry.getKey() + "=" + entry.getValue();

      }

    return new VMProcess(acmd, aenv, dir, redirect);

  }

  public OutputStream getOutputStream()

  {

    return stdin;

  }

  public InputStream getInputStream()

  {

    return stdout;

  }

  public InputStream getErrorStream()

  {

    return stderr;

  }

  public synchronized int waitFor() throws InterruptedException

  {

    while (state != TERMINATED)

      wait();

    return exitValue;

  }

  public synchronized int exitValue()

  {

    if (state != TERMINATED)

      throw new IllegalThreadStateException();

    return exitValue;

  }

  public synchronized void destroy()

  {

    if (state == TERMINATED)

      return;

    nativeKill(pid);

    while (state != TERMINATED)

      {

        try

          {

            wait();

          }

        catch (InterruptedException e)

          {

            /* ignore */

          }

      }

  }

  /**

   * Does the fork()/exec() thing to create the O/S process.

   * Must invoke setProcessInfo() before returning successfully.

   * This method is only invoked by processThread.

   *

   * @throws IOException if the O/S process could not be created.

   */

  native void nativeSpawn(String[] cmd, String[] env, File dir,

                          boolean redirect)

    throws IOException;

  /**

   * Test for a reapable child process, and reap if so. Does not block.

   * If a child was reaped, this method must set reapedPid and

   * reapedExitValue appropriately before returning.

   * This method is only invoked by processThread.

   *

   * @return true if a child was reaped, otherwise false

   */

  // This is not private as it is called from an inner class.

  static native boolean nativeReap();

  /**

   * Kill a process. This sends it a fatal signal but does not reap it.

   */

  private static native void nativeKill(long pid);

}