| /* |
| * Copyright (c) 2014, 2017, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code 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 |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| package java.lang; |
| |
| import java.lang.annotation.Native; |
| import java.security.PrivilegedAction; |
| import java.time.Duration; |
| import java.time.Instant; |
| import java.util.Arrays; |
| import java.util.Optional; |
| import java.util.concurrent.CompletableFuture; |
| import java.util.concurrent.ConcurrentHashMap; |
| import java.util.concurrent.ConcurrentMap; |
| import java.util.concurrent.Executor; |
| import java.util.concurrent.Executors; |
| import java.util.concurrent.ThreadFactory; |
| import java.util.stream.IntStream; |
| import java.util.stream.Stream; |
| |
| import static java.security.AccessController.doPrivileged; |
| |
| /** |
| * ProcessHandleImpl is the implementation of ProcessHandle. |
| * |
| * @see Process |
| * @since 9 |
| */ |
| final class ProcessHandleImpl implements ProcessHandle { |
| /** |
| * Default size of stack for reaper processes. |
| */ |
| private static long REAPER_DEFAULT_STACKSIZE = 128 * 1024; |
| |
| /** |
| * Return value from waitForProcessExit0 indicating the process is not a child. |
| */ |
| @Native |
| private static final int NOT_A_CHILD = -2; |
| |
| /** |
| * Cache the ProcessHandle of this process. |
| */ |
| private static final ProcessHandleImpl current; |
| |
| /** |
| * Map of pids to ExitCompletions. |
| */ |
| private static final ConcurrentMap<Long, ExitCompletion> |
| completions = new ConcurrentHashMap<>(); |
| |
| static { |
| initNative(); |
| long pid = getCurrentPid0(); |
| current = new ProcessHandleImpl(pid, isAlive0(pid)); |
| } |
| |
| private static native void initNative(); |
| |
| /** |
| * The thread pool of "process reaper" daemon threads. |
| */ |
| private static final Executor processReaperExecutor = |
| doPrivileged((PrivilegedAction<Executor>) () -> { |
| |
| ThreadGroup tg = Thread.currentThread().getThreadGroup(); |
| while (tg.getParent() != null) tg = tg.getParent(); |
| ThreadGroup systemThreadGroup = tg; |
| final long stackSize = Boolean.getBoolean("jdk.lang.processReaperUseDefaultStackSize") |
| ? 0 : REAPER_DEFAULT_STACKSIZE; |
| |
| ThreadFactory threadFactory = grimReaper -> { |
| Thread t = new Thread(systemThreadGroup, grimReaper, |
| "process reaper", stackSize, false); |
| t.setDaemon(true); |
| // A small attempt (probably futile) to avoid priority inversion |
| t.setPriority(Thread.MAX_PRIORITY); |
| return t; |
| }; |
| |
| return Executors.newCachedThreadPool(threadFactory); |
| }); |
| |
| private static class ExitCompletion extends CompletableFuture<Integer> { |
| final boolean isReaping; |
| |
| ExitCompletion(boolean isReaping) { |
| this.isReaping = isReaping; |
| } |
| } |
| |
| /** |
| * Returns a CompletableFuture that completes with process exit status when |
| * the process completes. |
| * |
| * @param shouldReap true if the exit value should be reaped |
| */ |
| static CompletableFuture<Integer> completion(long pid, boolean shouldReap) { |
| // check canonicalizing cache 1st |
| ExitCompletion completion = completions.get(pid); |
| // re-try until we get a completion that shouldReap => isReaping |
| while (completion == null || (shouldReap && !completion.isReaping)) { |
| ExitCompletion newCompletion = new ExitCompletion(shouldReap); |
| if (completion == null) { |
| completion = completions.putIfAbsent(pid, newCompletion); |
| } else { |
| completion = completions.replace(pid, completion, newCompletion) |
| ? null : completions.get(pid); |
| } |
| if (completion == null) { |
| // newCompletion has just been installed successfully |
| completion = newCompletion; |
| // spawn a thread to wait for and deliver the exit value |
| processReaperExecutor.execute(new Runnable() { |
| // Use inner class to avoid lambda stack overhead |
| public void run() { |
| int exitValue = waitForProcessExit0(pid, shouldReap); |
| if (exitValue == NOT_A_CHILD) { |
| // pid not alive or not a child of this process |
| // If it is alive wait for it to terminate |
| long sleep = 300; // initial milliseconds to sleep |
| int incr = 30; // increment to the sleep time |
| |
| long startTime = isAlive0(pid); |
| long origStart = startTime; |
| while (startTime >= 0) { |
| try { |
| Thread.sleep(Math.min(sleep, 5000L)); // no more than 5 sec |
| sleep += incr; |
| } catch (InterruptedException ie) { |
| // ignore and retry |
| } |
| startTime = isAlive0(pid); // recheck if is alive |
| if (origStart > 0 && startTime != origStart) { |
| // start time changed, pid is not the same process |
| break; |
| } |
| } |
| exitValue = 0; |
| } |
| newCompletion.complete(exitValue); |
| // remove from cache afterwards |
| completions.remove(pid, newCompletion); |
| } |
| }); |
| } |
| } |
| return completion; |
| } |
| |
| @Override |
| public CompletableFuture<ProcessHandle> onExit() { |
| if (this.equals(current)) { |
| throw new IllegalStateException("onExit for current process not allowed"); |
| } |
| |
| return ProcessHandleImpl.completion(pid(), false) |
| .handleAsync((exitStatus, unusedThrowable) -> this); |
| } |
| |
| /** |
| * Wait for the process to exit, return the value. |
| * Conditionally reap the value if requested |
| * @param pid the processId |
| * @param reapvalue if true, the value is retrieved, |
| * else return the value and leave the process waitable |
| * |
| * @return the value or -1 if an error occurs |
| */ |
| private static native int waitForProcessExit0(long pid, boolean reapvalue); |
| |
| /** |
| * The pid of this ProcessHandle. |
| */ |
| private final long pid; |
| |
| /** |
| * The start time of this process. |
| * If STARTTIME_ANY, the start time of the process is not available from the os. |
| * If greater than zero, the start time of the process. |
| */ |
| private final long startTime; |
| |
| /* The start time should match any value. |
| * Typically, this is because the OS can not supply it. |
| * The process is known to exist but not the exact start time. |
| */ |
| private final long STARTTIME_ANY = 0L; |
| |
| /* The start time of a Process that does not exist. */ |
| private final long STARTTIME_PROCESS_UNKNOWN = -1; |
| |
| /** |
| * Private constructor. Instances are created by the {@code get(long)} factory. |
| * @param pid the pid for this instance |
| */ |
| private ProcessHandleImpl(long pid, long startTime) { |
| this.pid = pid; |
| this.startTime = startTime; |
| } |
| |
| /** |
| * Returns a ProcessHandle for an existing native process. |
| * |
| * @param pid the native process identifier |
| * @return The ProcessHandle for the pid if the process is alive; |
| * or {@code null} if the process ID does not exist in the native system. |
| * @throws SecurityException if RuntimePermission("manageProcess") is not granted |
| */ |
| static Optional<ProcessHandle> get(long pid) { |
| SecurityManager sm = System.getSecurityManager(); |
| if (sm != null) { |
| sm.checkPermission(new RuntimePermission("manageProcess")); |
| } |
| long start = isAlive0(pid); |
| return (start >= 0) |
| ? Optional.of(new ProcessHandleImpl(pid, start)) |
| : Optional.empty(); |
| } |
| |
| /** |
| * Returns a ProcessHandle for an existing native process known to be alive. |
| * The startTime of the process is retrieved and stored in the ProcessHandle. |
| * It does not perform a security check since it is called from ProcessImpl. |
| * @param pid of the known to exist process |
| * @return a ProcessHandle corresponding to an existing Process instance |
| */ |
| static ProcessHandleImpl getInternal(long pid) { |
| return new ProcessHandleImpl(pid, isAlive0(pid)); |
| } |
| |
| /** |
| * Returns the native process ID. |
| * A {@code long} is used to be able to fit the system specific binary values |
| * for the process. |
| * |
| * @return the native process ID |
| */ |
| @Override |
| public long pid() { |
| return pid; |
| } |
| |
| /** |
| * Returns the ProcessHandle for the current native process. |
| * |
| * @return The ProcessHandle for the OS process. |
| * @throws SecurityException if RuntimePermission("manageProcess") is not granted |
| */ |
| public static ProcessHandleImpl current() { |
| SecurityManager sm = System.getSecurityManager(); |
| if (sm != null) { |
| sm.checkPermission(new RuntimePermission("manageProcess")); |
| } |
| return current; |
| } |
| |
| /** |
| * Return the pid of the current process. |
| * |
| * @return the pid of the current process |
| */ |
| private static native long getCurrentPid0(); |
| |
| /** |
| * Returns a ProcessHandle for the parent process. |
| * |
| * @return a ProcessHandle of the parent process; {@code null} is returned |
| * if the child process does not have a parent |
| * @throws SecurityException if permission is not granted by the |
| * security policy |
| */ |
| public Optional<ProcessHandle> parent() { |
| SecurityManager sm = System.getSecurityManager(); |
| if (sm != null) { |
| sm.checkPermission(new RuntimePermission("manageProcess")); |
| } |
| long ppid = parent0(pid, startTime); |
| if (ppid <= 0) { |
| return Optional.empty(); |
| } |
| return get(ppid); |
| } |
| |
| /** |
| * Returns the parent of the native pid argument. |
| * |
| * @param pid the process id |
| * @param startTime the startTime of the process |
| * @return the parent of the native pid; if any, otherwise -1 |
| */ |
| private static native long parent0(long pid, long startTime); |
| |
| /** |
| * Returns the number of pids filled in to the array. |
| * @param pid if {@code pid} equals zero, then all known processes are returned; |
| * otherwise only direct child process pids are returned |
| * @param pids an allocated long array to receive the pids |
| * @param ppids an allocated long array to receive the parent pids; may be null |
| * @param starttimes an allocated long array to receive the child start times; may be null |
| * @return if greater than or equals to zero is the number of pids in the array; |
| * if greater than the length of the arrays, the arrays are too small |
| */ |
| private static native int getProcessPids0(long pid, long[] pids, |
| long[] ppids, long[] starttimes); |
| |
| /** |
| * Destroy the process for this ProcessHandle. |
| * The native code checks the start time before sending the termination request. |
| * |
| * @param force {@code true} if the process should be terminated forcibly; |
| * else {@code false} for a normal termination |
| */ |
| boolean destroyProcess(boolean force) { |
| if (this.equals(current)) { |
| throw new IllegalStateException("destroy of current process not allowed"); |
| } |
| return destroy0(pid, startTime, force); |
| } |
| |
| /** |
| * Signal the process to terminate. |
| * The process is signaled only if its start time matches the known start time. |
| * |
| * @param pid process id to kill |
| * @param startTime the start time of the process |
| * @param forcibly true to forcibly terminate (SIGKILL vs SIGTERM) |
| * @return true if the process was signaled without error; false otherwise |
| */ |
| private static native boolean destroy0(long pid, long startTime, boolean forcibly); |
| |
| @Override |
| public boolean destroy() { |
| return destroyProcess(false); |
| } |
| |
| @Override |
| public boolean destroyForcibly() { |
| return destroyProcess(true); |
| } |
| |
| |
| @Override |
| public boolean supportsNormalTermination() { |
| return ProcessImpl.SUPPORTS_NORMAL_TERMINATION; |
| } |
| |
| /** |
| * Tests whether the process represented by this {@code ProcessHandle} is alive. |
| * |
| * @return {@code true} if the process represented by this |
| * {@code ProcessHandle} object has not yet terminated. |
| * @since 9 |
| */ |
| @Override |
| public boolean isAlive() { |
| long start = isAlive0(pid); |
| return (start >= 0 && (start == startTime || start == 0 || startTime == 0)); |
| } |
| |
| /** |
| * Returns the process start time depending on whether the pid is alive. |
| * This must not reap the exitValue. |
| * |
| * @param pid the pid to check |
| * @return the start time in milliseconds since 1970, |
| * 0 if the start time cannot be determined, |
| * -1 if the pid does not exist. |
| */ |
| private static native long isAlive0(long pid); |
| |
| @Override |
| public Stream<ProcessHandle> children() { |
| // The native OS code selects based on matching the requested parent pid. |
| // If the original parent exits, the pid may have been re-used for |
| // this newer process. |
| // Processes started by the original parent (now dead) will all have |
| // start times less than the start of this newer parent. |
| // Processes started by this newer parent will have start times equal |
| // or after this parent. |
| return children(pid).filter(ph -> startTime <= ((ProcessHandleImpl)ph).startTime); |
| } |
| |
| /** |
| * Returns a Stream of the children of a process or all processes. |
| * |
| * @param pid the pid of the process for which to find the children; |
| * 0 for all processes |
| * @return a stream of ProcessHandles |
| */ |
| static Stream<ProcessHandle> children(long pid) { |
| SecurityManager sm = System.getSecurityManager(); |
| if (sm != null) { |
| sm.checkPermission(new RuntimePermission("manageProcess")); |
| } |
| int size = 100; |
| long[] childpids = null; |
| long[] starttimes = null; |
| while (childpids == null || size > childpids.length) { |
| childpids = new long[size]; |
| starttimes = new long[size]; |
| size = getProcessPids0(pid, childpids, null, starttimes); |
| } |
| |
| final long[] cpids = childpids; |
| final long[] stimes = starttimes; |
| return IntStream.range(0, size).mapToObj(i -> new ProcessHandleImpl(cpids[i], stimes[i])); |
| } |
| |
| @Override |
| public Stream<ProcessHandle> descendants() { |
| SecurityManager sm = System.getSecurityManager(); |
| if (sm != null) { |
| sm.checkPermission(new RuntimePermission("manageProcess")); |
| } |
| int size = 100; |
| long[] pids = null; |
| long[] ppids = null; |
| long[] starttimes = null; |
| while (pids == null || size > pids.length) { |
| pids = new long[size]; |
| ppids = new long[size]; |
| starttimes = new long[size]; |
| size = getProcessPids0(0, pids, ppids, starttimes); |
| } |
| |
| int next = 0; // index of next process to check |
| int count = -1; // count of subprocesses scanned |
| long ppid = pid; // start looking for this parent |
| long ppStart = 0; |
| // Find the start time of the parent |
| for (int i = 0; i < size; i++) { |
| if (pids[i] == ppid) { |
| ppStart = starttimes[i]; |
| break; |
| } |
| } |
| do { |
| // Scan from next to size looking for ppid with child start time |
| // the same or later than the parent. |
| // If found, exchange it with index next |
| for (int i = next; i < size; i++) { |
| if (ppids[i] == ppid && |
| ppStart <= starttimes[i]) { |
| swap(pids, i, next); |
| swap(ppids, i, next); |
| swap(starttimes, i, next); |
| next++; |
| } |
| } |
| ppid = pids[++count]; // pick up the next pid to scan for |
| ppStart = starttimes[count]; // and its start time |
| } while (count < next); |
| |
| final long[] cpids = pids; |
| final long[] stimes = starttimes; |
| return IntStream.range(0, count).mapToObj(i -> new ProcessHandleImpl(cpids[i], stimes[i])); |
| } |
| |
| // Swap two elements in an array |
| private static void swap(long[] array, int x, int y) { |
| long v = array[x]; |
| array[x] = array[y]; |
| array[y] = v; |
| } |
| |
| @Override |
| public ProcessHandle.Info info() { |
| return ProcessHandleImpl.Info.info(pid, startTime); |
| } |
| |
| @Override |
| public int compareTo(ProcessHandle other) { |
| return Long.compare(pid, ((ProcessHandleImpl) other).pid); |
| } |
| |
| @Override |
| public String toString() { |
| return Long.toString(pid); |
| } |
| |
| @Override |
| public int hashCode() { |
| return Long.hashCode(pid); |
| } |
| |
| @Override |
| public boolean equals(Object obj) { |
| if (this == obj) { |
| return true; |
| } |
| if (obj instanceof ProcessHandleImpl) { |
| ProcessHandleImpl other = (ProcessHandleImpl) obj; |
| return (pid == other.pid) && |
| (startTime == other.startTime |
| || startTime == 0 |
| || other.startTime == 0); |
| } |
| return false; |
| } |
| |
| /** |
| * Implementation of ProcessHandle.Info. |
| * Information snapshot about a process. |
| * The attributes of a process vary by operating system and are not available |
| * in all implementations. Additionally, information about other processes |
| * is limited by the operating system privileges of the process making the request. |
| * If a value is not available, either a {@code null} or {@code -1} is stored. |
| * The accessor methods return {@code null} if the value is not available. |
| */ |
| static class Info implements ProcessHandle.Info { |
| static { |
| initIDs(); |
| } |
| |
| /** |
| * Initialization of JNI fieldIDs. |
| */ |
| private static native void initIDs(); |
| |
| /** |
| * Fill in this Info instance with information about the native process. |
| * If values are not available the native code does not modify the field. |
| * @param pid of the native process |
| */ |
| private native void info0(long pid); |
| |
| String command; |
| String commandLine; |
| String[] arguments; |
| long startTime; |
| long totalTime; |
| String user; |
| |
| Info() { |
| command = null; |
| commandLine = null; |
| arguments = null; |
| startTime = -1L; |
| totalTime = -1L; |
| user = null; |
| } |
| |
| /** |
| * Returns the Info object with the fields from the process. |
| * Whatever fields are provided by native are returned. |
| * If the startTime of the process does not match the provided |
| * startTime then an empty Info is returned. |
| * |
| * @param pid the native process identifier |
| * @param startTime the startTime of the process being queried |
| * @return ProcessHandle.Info non-null; individual fields may be null |
| * or -1 if not available. |
| */ |
| public static ProcessHandle.Info info(long pid, long startTime) { |
| Info info = new Info(); |
| info.info0(pid); |
| if (startTime != info.startTime) { |
| info.command = null; |
| info.arguments = null; |
| info.startTime = -1L; |
| info.totalTime = -1L; |
| info.user = null; |
| } |
| return info; |
| } |
| |
| @Override |
| public Optional<String> command() { |
| return Optional.ofNullable(command); |
| } |
| |
| @Override |
| public Optional<String> commandLine() { |
| if (command != null && arguments != null) { |
| return Optional.of(command + " " + String.join(" ", arguments)); |
| } else { |
| return Optional.ofNullable(commandLine); |
| } |
| } |
| |
| @Override |
| public Optional<String[]> arguments() { |
| return Optional.ofNullable(arguments); |
| } |
| |
| @Override |
| public Optional<Instant> startInstant() { |
| return (startTime > 0) |
| ? Optional.of(Instant.ofEpochMilli(startTime)) |
| : Optional.empty(); |
| } |
| |
| @Override |
| public Optional<Duration> totalCpuDuration() { |
| return (totalTime != -1) |
| ? Optional.of(Duration.ofNanos(totalTime)) |
| : Optional.empty(); |
| } |
| |
| @Override |
| public Optional<String> user() { |
| return Optional.ofNullable(user); |
| } |
| |
| @Override |
| public String toString() { |
| StringBuilder sb = new StringBuilder(60); |
| sb.append('['); |
| if (user != null) { |
| sb.append("user: "); |
| sb.append(user()); |
| } |
| if (command != null) { |
| if (sb.length() != 0) sb.append(", "); |
| sb.append("cmd: "); |
| sb.append(command); |
| } |
| if (arguments != null && arguments.length > 0) { |
| if (sb.length() != 0) sb.append(", "); |
| sb.append("args: "); |
| sb.append(Arrays.toString(arguments)); |
| } |
| if (commandLine != null) { |
| if (sb.length() != 0) sb.append(", "); |
| sb.append("cmdLine: "); |
| sb.append(commandLine); |
| } |
| if (startTime > 0) { |
| if (sb.length() != 0) sb.append(", "); |
| sb.append("startTime: "); |
| sb.append(startInstant()); |
| } |
| if (totalTime != -1) { |
| if (sb.length() != 0) sb.append(", "); |
| sb.append("totalTime: "); |
| sb.append(totalCpuDuration().toString()); |
| } |
| sb.append(']'); |
| return sb.toString(); |
| } |
| } |
| } |