1 /*

     2  * Copyright (c) 1995, 2010, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 package java.lang;

    27 

    28 import java.io.BufferedInputStream;

    29 import java.io.BufferedOutputStream;

    30 import java.io.ByteArrayInputStream;

    31 import java.io.FileDescriptor;

    32 import java.io.FileInputStream;

    33 import java.io.FileOutputStream;

    34 import java.io.IOException;

    35 import java.io.InputStream;

    36 import java.io.OutputStream;

    37 import java.util.Arrays;

    38 import java.util.concurrent.Executors;

    39 import java.util.concurrent.Executor;

    40 import java.util.concurrent.ThreadFactory;

    41 import java.security.AccessController;

    42 import static java.security.AccessController.doPrivileged;

    43 import java.security.PrivilegedAction;

    44 import java.security.PrivilegedActionException;

    45 import java.security.PrivilegedExceptionAction;

    46 

    47 /**

    48  * java.lang.Process subclass in the UNIX environment.

    49  *

    50  * @author Mario Wolczko and Ross Knippel.

    51  * @author Konstantin Kladko (ported to Bsd)

    52  * @author Martin Buchholz

    53  */

    54 final class UNIXProcess extends Process {

    55     private static final sun.misc.JavaIOFileDescriptorAccess fdAccess

    56         = sun.misc.SharedSecrets.getJavaIOFileDescriptorAccess();

    57 

    58     private final int pid;

    59     private int exitcode;

    60     private boolean hasExited;

    61 

    62     private /* final */ OutputStream stdin;

    63     private /* final */ InputStream  stdout;

    64     private /* final */ InputStream  stderr;

    65 

    66     /* this is for the reaping thread */

    67     private native int waitForProcessExit(int pid);

    68 

    69     /**

    70      * Create a process using fork(2) and exec(2).

    71      *

    72      * @param fds an array of three file descriptors.

    73      *        Indexes 0, 1, and 2 correspond to standard input,

    74      *        standard output and standard error, respectively.  On

    75      *        input, a value of -1 means to create a pipe to connect

    76      *        child and parent processes.  On output, a value which

    77      *        is not -1 is the parent pipe fd corresponding to the

    78      *        pipe which has been created.  An element of this array

    79      *        is -1 on input if and only if it is <em>not</em> -1 on

    80      *        output.

    81      * @return the pid of the subprocess

    82      */

    83     private native int forkAndExec(byte[] prog,

    84                                    byte[] argBlock, int argc,

    85                                    byte[] envBlock, int envc,

    86                                    byte[] dir,

    87                                    int[] fds,

    88                                    boolean redirectErrorStream)

    89         throws IOException;

    90 

    91     /**

    92      * The thread factory used to create "process reaper" daemon threads.

    93      */

    94     private static class ProcessReaperThreadFactory implements ThreadFactory {

    95         private final static ThreadGroup group = getRootThreadGroup();

    96 

    97         private static ThreadGroup getRootThreadGroup() {

    98             return doPrivileged(new PrivilegedAction<ThreadGroup> () {

    99                 public ThreadGroup run() {

   100                     ThreadGroup root = Thread.currentThread().getThreadGroup();

   101                     while (root.getParent() != null)

   102                         root = root.getParent();

   103                     return root;

   104                 }});

   105         }

   106 

   107         public Thread newThread(Runnable grimReaper) {

   108             // Our thread stack requirement is quite modest.

   109             Thread t = new Thread(group, grimReaper, "process reaper", 32768);

   110             t.setDaemon(true);

   111             // A small attempt (probably futile) to avoid priority inversion

   112             t.setPriority(Thread.MAX_PRIORITY);

   113             return t;

   114         }

   115     }

   116 

   117     /**

   118      * The thread pool of "process reaper" daemon threads.

   119      */

   120     private static final Executor processReaperExecutor =

   121         doPrivileged(new PrivilegedAction<Executor>() {

   122             public Executor run() {

   123                 return Executors.newCachedThreadPool

   124                     (new ProcessReaperThreadFactory());

   125             }});

   126 

   127     UNIXProcess(final byte[] prog,

   128                 final byte[] argBlock, final int argc,

   129                 final byte[] envBlock, final int envc,

   130                 final byte[] dir,

   131                 final int[] fds,

   132                 final boolean redirectErrorStream)

   133             throws IOException {

   134 

   135         pid = forkAndExec(prog,

   136                           argBlock, argc,

   137                           envBlock, envc,

   138                           dir,

   139                           fds,

   140                           redirectErrorStream);

   141 

   142         try {

   143             doPrivileged(new PrivilegedExceptionAction<Void>() {

   144                 public Void run() throws IOException {

   145                     initStreams(fds);

   146                     return null;

   147                 }});

   148         } catch (PrivilegedActionException ex) {

   149             throw (IOException) ex.getException();

   150         }

   151     }

   152 

   153     static FileDescriptor newFileDescriptor(int fd) {

   154         FileDescriptor fileDescriptor = new FileDescriptor();

   155         fdAccess.set(fileDescriptor, fd);

   156         return fileDescriptor;

   157     }

   158 

   159     void initStreams(int[] fds) throws IOException {

   160         stdin = (fds[0] == -1) ?

   161             ProcessBuilder.NullOutputStream.INSTANCE :

   162             new ProcessPipeOutputStream(fds[0]);

   163 

   164         stdout = (fds[1] == -1) ?

   165             ProcessBuilder.NullInputStream.INSTANCE :

   166             new ProcessPipeInputStream(fds[1]);

   167 

   168         stderr = (fds[2] == -1) ?

   169             ProcessBuilder.NullInputStream.INSTANCE :

   170             new ProcessPipeInputStream(fds[2]);

   171 

   172         processReaperExecutor.execute(new Runnable() {

   173             public void run() {

   174                 int exitcode = waitForProcessExit(pid);

   175                 UNIXProcess.this.processExited(exitcode);

   176             }});

   177     }

   178 

   179     void processExited(int exitcode) {

   180         synchronized (this) {

   181             this.exitcode = exitcode;

   182             hasExited = true;

   183             notifyAll();

   184         }

   185 

   186         if (stdout instanceof ProcessPipeInputStream)

   187             ((ProcessPipeInputStream) stdout).processExited();

   188 

   189         if (stderr instanceof ProcessPipeInputStream)

   190             ((ProcessPipeInputStream) stderr).processExited();

   191 

   192         if (stdin instanceof ProcessPipeOutputStream)

   193             ((ProcessPipeOutputStream) stdin).processExited();

   194     }

   195 

   196     public OutputStream getOutputStream() {

   197         return stdin;

   198     }

   199 

   200     public InputStream getInputStream() {

   201         return stdout;

   202     }

   203 

   204     public InputStream getErrorStream() {

   205         return stderr;

   206     }

   207 

   208     public synchronized int waitFor() throws InterruptedException {

   209         while (!hasExited) {

   210             wait();

   211         }

   212         return exitcode;

   213     }

   214 

   215     public synchronized int exitValue() {

   216         if (!hasExited) {

   217             throw new IllegalThreadStateException("process hasn't exited");

   218         }

   219         return exitcode;

   220     }

   221 

   222     private static native void destroyProcess(int pid);

   223     public void destroy() {

   224         // There is a risk that pid will be recycled, causing us to

   225         // kill the wrong process!  So we only terminate processes

   226         // that appear to still be running.  Even with this check,

   227         // there is an unavoidable race condition here, but the window

   228         // is very small, and OSes try hard to not recycle pids too

   229         // soon, so this is quite safe.

   230         synchronized (this) {

   231             if (!hasExited)

   232                 destroyProcess(pid);

   233         }

   234         try { stdin.close();  } catch (IOException ignored) {}

   235         try { stdout.close(); } catch (IOException ignored) {}

   236         try { stderr.close(); } catch (IOException ignored) {}

   237     }

   238 

   239     /* This routine initializes JNI field offsets for the class */

   240     private static native void initIDs();

   241 

   242     static {

   243         initIDs();

   244     }

   245 

   246     /**

   247      * A buffered input stream for a subprocess pipe file descriptor

   248      * that allows the underlying file descriptor to be reclaimed when

   249      * the process exits, via the processExited hook.

   250      *

   251      * This is tricky because we do not want the user-level InputStream to be

   252      * closed until the user invokes close(), and we need to continue to be

   253      * able to read any buffered data lingering in the OS pipe buffer.

   254      */

   255     static class ProcessPipeInputStream extends BufferedInputStream {

   256         ProcessPipeInputStream(int fd) {

   257             super(new FileInputStream(newFileDescriptor(fd)));

   258         }

   259 

   260         private static byte[] drainInputStream(InputStream in)

   261                 throws IOException {

   262             if (in == null) return null;

   263             int n = 0;

   264             int j;

   265             byte[] a = null;

   266             while ((j = in.available()) > 0) {

   267                 a = (a == null) ? new byte[j] : Arrays.copyOf(a, n + j);

   268                 n += in.read(a, n, j);

   269             }

   270             return (a == null || n == a.length) ? a : Arrays.copyOf(a, n);

   271         }

   272 

   273         /** Called by the process reaper thread when the process exits. */

   274         synchronized void processExited() {

   275             // Most BufferedInputStream methods are synchronized, but close()

   276             // is not, and so we have to handle concurrent racing close().

   277             try {

   278                 InputStream in = this.in;

   279                 if (in != null) {

   280                     byte[] stragglers = drainInputStream(in);

   281                     in.close();

   282                     this.in = (stragglers == null) ?

   283                         ProcessBuilder.NullInputStream.INSTANCE :

   284                         new ByteArrayInputStream(stragglers);

   285                     if (buf == null) // asynchronous close()?

   286                         this.in = null;

   287                 }

   288             } catch (IOException ignored) {

   289                 // probably an asynchronous close().

   290             }

   291         }

   292     }

   293 

   294     /**

   295      * A buffered output stream for a subprocess pipe file descriptor

   296      * that allows the underlying file descriptor to be reclaimed when

   297      * the process exits, via the processExited hook.

   298      */

   299     static class ProcessPipeOutputStream extends BufferedOutputStream {

   300         ProcessPipeOutputStream(int fd) {

   301             super(new FileOutputStream(newFileDescriptor(fd)));

   302         }

   303 

   304         /** Called by the process reaper thread when the process exits. */

   305         synchronized void processExited() {

   306             OutputStream out = this.out;

   307             if (out != null) {

   308                 try {

   309                     out.close();

   310                 } catch (IOException ignored) {

   311                     // We know of no reason to get an IOException, but if

   312                     // we do, there's nothing else to do but carry on.

   313                 }

   314                 this.out = ProcessBuilder.NullOutputStream.INSTANCE;

   315             }

   316         }

   317     }

   318 }