| /* 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); | |
| } |