rev 58428 : [mq]: XXXXXXX-typos

   1 /*
   2  * Copyright (c) 2014, 2019, 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 package java.lang;
  26 
  27 import java.lang.annotation.Native;
  28 import java.security.PrivilegedAction;
  29 import java.time.Duration;
  30 import java.time.Instant;
  31 import java.util.Arrays;
  32 import java.util.Optional;
  33 import java.util.concurrent.CompletableFuture;
  34 import java.util.concurrent.ConcurrentHashMap;
  35 import java.util.concurrent.ConcurrentMap;
  36 import java.util.concurrent.Executor;
  37 import java.util.concurrent.Executors;
  38 import java.util.concurrent.ThreadFactory;
  39 import java.util.stream.IntStream;
  40 import java.util.stream.Stream;
  41 
  42 import static java.security.AccessController.doPrivileged;
  43 
  44 /**
  45  * ProcessHandleImpl is the implementation of ProcessHandle.
  46  *
  47  * @see Process
  48  * @since 9
  49  */
  50 final class ProcessHandleImpl implements ProcessHandle {
  51     /**
  52      * Default size of stack for reaper processes.
  53      */
  54     private static long REAPER_DEFAULT_STACKSIZE = 128 * 1024;
  55 
  56     /**
  57      * Return value from waitForProcessExit0 indicating the process is not a child.
  58      */
  59     @Native
  60     private static final int NOT_A_CHILD = -2;
  61 
  62     /**
  63      * Cache the ProcessHandle of this process.
  64      */
  65     private static final ProcessHandleImpl current;
  66 
  67     /**
  68      * Map of pids to ExitCompletions.
  69      */
  70     private static final ConcurrentMap<Long, ExitCompletion>
  71             completions = new ConcurrentHashMap<>();
  72 
  73     static {
  74         initNative();
  75         long pid = getCurrentPid0();
  76         current = new ProcessHandleImpl(pid, isAlive0(pid));
  77     }
  78 
  79     private static native void initNative();
  80 
  81     /**
  82      * The thread pool of "process reaper" daemon threads.
  83      */
  84     private static final Executor processReaperExecutor =
  85             doPrivileged((PrivilegedAction<Executor>) () -> {
  86 
  87                 ThreadGroup tg = Thread.currentThread().getThreadGroup();
  88                 while (tg.getParent() != null) tg = tg.getParent();
  89                 ThreadGroup systemThreadGroup = tg;
  90                 final long stackSize = Boolean.getBoolean("jdk.lang.processReaperUseDefaultStackSize")
  91                         ? 0 : REAPER_DEFAULT_STACKSIZE;
  92 
  93                 ThreadFactory threadFactory = grimReaper -> {
  94                     Thread t = new Thread(systemThreadGroup, grimReaper,
  95                             "process reaper", stackSize, false);
  96                     t.setDaemon(true);
  97                     // A small attempt (probably futile) to avoid priority inversion
  98                     t.setPriority(Thread.MAX_PRIORITY);
  99                     return t;
 100                 };
 101 
 102                 return Executors.newCachedThreadPool(threadFactory);
 103             });
 104 
 105     private static class ExitCompletion extends CompletableFuture<Integer> {
 106         final boolean isReaping;
 107 
 108         ExitCompletion(boolean isReaping) {
 109             this.isReaping = isReaping;
 110         }
 111     }
 112 
 113     /**
 114      * Returns a CompletableFuture that completes with process exit status when
 115      * the process completes.
 116      *
 117      * @param shouldReap true if the exit value should be reaped
 118      */
 119     static CompletableFuture<Integer> completion(long pid, boolean shouldReap) {
 120         // check canonicalizing cache 1st
 121         ExitCompletion completion = completions.get(pid);
 122         // re-try until we get a completion that shouldReap => isReaping
 123         while (completion == null || (shouldReap && !completion.isReaping)) {
 124             ExitCompletion newCompletion = new ExitCompletion(shouldReap);
 125             if (completion == null) {
 126                 completion = completions.putIfAbsent(pid, newCompletion);
 127             } else {
 128                 completion = completions.replace(pid, completion, newCompletion)
 129                     ? null : completions.get(pid);
 130             }
 131             if (completion == null) {
 132                 // newCompletion has just been installed successfully
 133                 completion = newCompletion;
 134                 // spawn a thread to wait for and deliver the exit value
 135                 processReaperExecutor.execute(new Runnable() {
 136                     // Use inner class to avoid lambda stack overhead
 137                     public void run() {
 138                         int exitValue = waitForProcessExit0(pid, shouldReap);
 139                         if (exitValue == NOT_A_CHILD) {
 140                             // pid not alive or not a child of this process
 141                             // If it is alive wait for it to terminate
 142                             long sleep = 300;     // initial milliseconds to sleep
 143                             int incr = 30;        // increment to the sleep time
 144 
 145                             long startTime = isAlive0(pid);
 146                             long origStart = startTime;
 147                             while (startTime >= 0) {
 148                                 try {
 149                                     Thread.sleep(Math.min(sleep, 5000L)); // no more than 5 sec
 150                                     sleep += incr;
 151                                 } catch (InterruptedException ie) {
 152                                     // ignore and retry
 153                                 }
 154                                 startTime = isAlive0(pid);  // recheck if it is alive
 155                                 if (startTime > 0 && origStart > 0 && startTime != origStart) {
 156                                     // start time changed (and is not zero), pid is not the same process
 157                                     break;
 158                                 }
 159                             }
 160                             exitValue = 0;
 161                         }
 162                         newCompletion.complete(exitValue);
 163                         // remove from cache afterwards
 164                         completions.remove(pid, newCompletion);
 165                     }
 166                 });
 167             }
 168         }
 169         return completion;
 170     }
 171 
 172     @Override
 173     public CompletableFuture<ProcessHandle> onExit() {
 174         if (this.equals(current)) {
 175             throw new IllegalStateException("onExit for current process not allowed");
 176         }
 177 
 178         return ProcessHandleImpl.completion(pid(), false)
 179                 .handleAsync((exitStatus, unusedThrowable) -> this);
 180     }
 181 
 182     /**
 183      * Wait for the process to exit, return the value.
 184      * Conditionally reap the value if requested
 185      * @param pid the processId
 186      * @param reapvalue if true, the value is retrieved,
 187      *                   else return the value and leave the process waitable
 188      *
 189      * @return the value or -1 if an error occurs
 190      */
 191     private static native int waitForProcessExit0(long pid, boolean reapvalue);
 192 
 193     /**
 194      * The pid of this ProcessHandle.
 195      */
 196     private final long pid;
 197 
 198     /**
 199      * The start time of this process.
 200      * If STARTTIME_ANY, the start time of the process is not available from the os.
 201      * If greater than zero, the start time of the process.
 202      */
 203     private final long startTime;
 204 
 205     /* The start time should match any value.
 206      * Typically, this is because the OS can not supply it.
 207      * The process is known to exist but not the exact start time.
 208      */
 209     private final long STARTTIME_ANY = 0L;
 210 
 211     /* The start time of a Process that does not exist. */
 212     private final long STARTTIME_PROCESS_UNKNOWN = -1;
 213 
 214     /**
 215      * Private constructor.  Instances are created by the {@code get(long)} factory.
 216      * @param pid the pid for this instance
 217      */
 218     private ProcessHandleImpl(long pid, long startTime) {
 219         this.pid = pid;
 220         this.startTime = startTime;
 221     }
 222 
 223     /**
 224      * Returns a ProcessHandle for an existing native process.
 225      *
 226      * @param  pid the native process identifier
 227      * @return The ProcessHandle for the pid if the process is alive;
 228      *         or {@code null} if the process ID does not exist in the native system.
 229      * @throws SecurityException if RuntimePermission("manageProcess") is not granted
 230      */
 231     static Optional<ProcessHandle> get(long pid) {
 232         SecurityManager sm = System.getSecurityManager();
 233         if (sm != null) {
 234             sm.checkPermission(new RuntimePermission("manageProcess"));
 235         }
 236         long start = isAlive0(pid);
 237         return (start >= 0)
 238                 ? Optional.of(new ProcessHandleImpl(pid, start))
 239                 : Optional.empty();
 240     }
 241 
 242     /**
 243      * Returns a ProcessHandle for an existing native process known to be alive.
 244      * The startTime of the process is retrieved and stored in the ProcessHandle.
 245      * It does not perform a security check since it is called from ProcessImpl.
 246      * @param pid of the known to exist process
 247      * @return a ProcessHandle corresponding to an existing Process instance
 248      */
 249     static ProcessHandleImpl getInternal(long pid) {
 250         return new ProcessHandleImpl(pid, isAlive0(pid));
 251     }
 252 
 253     /**
 254      * Returns the native process ID.
 255      * A {@code long} is used to be able to fit the system specific binary values
 256      * for the process.
 257      *
 258      * @return the native process ID
 259      */
 260     @Override
 261     public long pid() {
 262         return pid;
 263     }
 264 
 265     /**
 266      * Returns the ProcessHandle for the current native process.
 267      *
 268      * @return The ProcessHandle for the OS process.
 269      * @throws SecurityException if RuntimePermission("manageProcess") is not granted
 270      */
 271     public static ProcessHandleImpl current() {
 272         SecurityManager sm = System.getSecurityManager();
 273         if (sm != null) {
 274             sm.checkPermission(new RuntimePermission("manageProcess"));
 275         }
 276         return current;
 277     }
 278 
 279     /**
 280      * Return the pid of the current process.
 281      *
 282      * @return the pid of the  current process
 283      */
 284     private static native long getCurrentPid0();
 285 
 286     /**
 287      * Returns a ProcessHandle for the parent process.
 288      *
 289      * @return a ProcessHandle of the parent process; {@code null} is returned
 290      *         if the child process does not have a parent
 291      * @throws SecurityException           if permission is not granted by the
 292      *                                     security policy
 293      */
 294     public Optional<ProcessHandle> parent() {
 295         SecurityManager sm = System.getSecurityManager();
 296         if (sm != null) {
 297             sm.checkPermission(new RuntimePermission("manageProcess"));
 298         }
 299         long ppid = parent0(pid, startTime);
 300         if (ppid <= 0) {
 301             return Optional.empty();
 302         }
 303         return get(ppid);
 304     }
 305 
 306     /**
 307      * Returns the parent of the native pid argument.
 308      *
 309      * @param pid the process id
 310      * @param startTime the startTime of the process
 311      * @return the parent of the native pid; if any, otherwise -1
 312      */
 313     private static native long parent0(long pid, long startTime);
 314 
 315     /**
 316      * Returns the number of pids filled in to the array.
 317      * @param pid if {@code pid} equals zero, then all known processes are returned;
 318      *      otherwise only direct child process pids are returned
 319      * @param pids an allocated long array to receive the pids
 320      * @param ppids an allocated long array to receive the parent pids; may be null
 321      * @param starttimes an allocated long array to receive the child start times; may be null
 322      * @return if greater than or equal to zero is the number of pids in the array;
 323      *      if greater than the length of the arrays, the arrays are too small
 324      */
 325     private static native int getProcessPids0(long pid, long[] pids,
 326                                               long[] ppids, long[] starttimes);
 327 
 328     /**
 329      * Destroy the process for this ProcessHandle.
 330      * The native code checks the start time before sending the termination request.
 331      *
 332      * @param force {@code true} if the process should be terminated forcibly;
 333      *     else {@code false} for a normal termination
 334      */
 335     boolean destroyProcess(boolean force) {
 336         if (this.equals(current)) {
 337             throw new IllegalStateException("destroy of current process not allowed");
 338         }
 339         return destroy0(pid, startTime, force);
 340     }
 341 
 342     /**
 343       * Signal the process to terminate.
 344       * The process is signaled only if its start time matches the known start time.
 345       *
 346       * @param pid  process id to kill
 347       * @param startTime the start time of the process
 348       * @param forcibly true to forcibly terminate (SIGKILL vs SIGTERM)
 349       * @return true if the process was signaled without error; false otherwise
 350       */
 351     private static native boolean destroy0(long pid, long startTime, boolean forcibly);
 352 
 353     @Override
 354     public boolean destroy() {
 355         return destroyProcess(false);
 356     }
 357 
 358     @Override
 359     public boolean destroyForcibly() {
 360         return destroyProcess(true);
 361     }
 362 
 363 
 364     @Override
 365     public boolean supportsNormalTermination() {
 366         return ProcessImpl.SUPPORTS_NORMAL_TERMINATION;
 367     }
 368 
 369     /**
 370      * Tests whether the process represented by this {@code ProcessHandle} is alive.
 371      *
 372      * @return {@code true} if the process represented by this
 373      * {@code ProcessHandle} object has not yet terminated.
 374      * @since 9
 375      */
 376     @Override
 377     public boolean isAlive() {
 378         long start = isAlive0(pid);
 379         return (start >= 0 && (start == startTime || start == 0 || startTime == 0));
 380     }
 381 
 382     /**
 383      * Returns the process start time depending on whether the pid is alive.
 384      * This must not reap the exitValue.
 385      *
 386      * @param pid the pid to check
 387      * @return the start time in milliseconds since 1970,
 388      *         0 if the start time cannot be determined,
 389      *         -1 if the pid does not exist.
 390      */
 391     private static native long isAlive0(long pid);
 392 
 393     @Override
 394     public Stream<ProcessHandle> children() {
 395         // The native OS code selects based on matching the requested parent pid.
 396         // If the original parent exits, the pid may have been re-used for
 397         // this newer process.
 398         // Processes started by the original parent (now dead) will all have
 399         // start times less than the start of this newer parent.
 400         // Processes started by this newer parent will have start times equal
 401         // or after this parent.
 402         return children(pid).filter(ph -> startTime <= ((ProcessHandleImpl)ph).startTime);
 403     }
 404 
 405     /**
 406      * Returns a Stream of the children of a process or all processes.
 407      *
 408      * @param pid the pid of the process for which to find the children;
 409      *            0 for all processes
 410      * @return a stream of ProcessHandles
 411      */
 412     static Stream<ProcessHandle> children(long pid) {
 413         SecurityManager sm = System.getSecurityManager();
 414         if (sm != null) {
 415             sm.checkPermission(new RuntimePermission("manageProcess"));
 416         }
 417         int size = 100;
 418         long[] childpids = null;
 419         long[] starttimes = null;
 420         while (childpids == null || size > childpids.length) {
 421             childpids = new long[size];
 422             starttimes = new long[size];
 423             size = getProcessPids0(pid, childpids, null, starttimes);
 424         }
 425 
 426         final long[] cpids = childpids;
 427         final long[] stimes = starttimes;
 428         return IntStream.range(0, size).mapToObj(i -> new ProcessHandleImpl(cpids[i], stimes[i]));
 429     }
 430 
 431     @Override
 432     public Stream<ProcessHandle> descendants() {
 433         SecurityManager sm = System.getSecurityManager();
 434         if (sm != null) {
 435             sm.checkPermission(new RuntimePermission("manageProcess"));
 436         }
 437         int size = 100;
 438         long[] pids = null;
 439         long[] ppids = null;
 440         long[] starttimes = null;
 441         while (pids == null || size > pids.length) {
 442             pids = new long[size];
 443             ppids = new long[size];
 444             starttimes = new long[size];
 445             size = getProcessPids0(0, pids, ppids, starttimes);
 446         }
 447 
 448         int next = 0;       // index of next process to check
 449         int count = -1;     // count of subprocesses scanned
 450         long ppid = pid;    // start looking for this parent
 451         long ppStart = 0;
 452         // Find the start time of the parent
 453         for (int i = 0; i < size; i++) {
 454             if (pids[i] == ppid) {
 455                 ppStart = starttimes[i];
 456                 break;
 457             }
 458         }
 459         do {
 460             // Scan from next to size looking for ppid with child start time
 461             // the same or later than the parent.
 462             // If found, exchange it with index next
 463             for (int i = next; i < size; i++) {
 464                 if (ppids[i] == ppid &&
 465                         ppStart <= starttimes[i]) {
 466                     swap(pids, i, next);
 467                     swap(ppids, i, next);
 468                     swap(starttimes, i, next);
 469                     next++;
 470                 }
 471             }
 472             ppid = pids[++count];   // pick up the next pid to scan for
 473             ppStart = starttimes[count];    // and its start time
 474         } while (count < next);
 475 
 476         final long[] cpids = pids;
 477         final long[] stimes = starttimes;
 478         return IntStream.range(0, count).mapToObj(i -> new ProcessHandleImpl(cpids[i], stimes[i]));
 479     }
 480 
 481     // Swap two elements in an array
 482     private static void swap(long[] array, int x, int y) {
 483         long v = array[x];
 484         array[x] = array[y];
 485         array[y] = v;
 486     }
 487 
 488     @Override
 489     public ProcessHandle.Info info() {
 490         return ProcessHandleImpl.Info.info(pid, startTime);
 491     }
 492 
 493     @Override
 494     public int compareTo(ProcessHandle other) {
 495         return Long.compare(pid, ((ProcessHandleImpl) other).pid);
 496     }
 497 
 498     @Override
 499     public String toString() {
 500         return Long.toString(pid);
 501     }
 502 
 503     @Override
 504     public int hashCode() {
 505         return Long.hashCode(pid);
 506     }
 507 
 508     @Override
 509     public boolean equals(Object obj) {
 510         if (this == obj) {
 511             return true;
 512         }
 513         if (obj instanceof ProcessHandleImpl) {
 514             ProcessHandleImpl other = (ProcessHandleImpl) obj;
 515             return (pid == other.pid) &&
 516                     (startTime == other.startTime
 517                         || startTime == 0
 518                         || other.startTime == 0);
 519         }
 520         return false;
 521     }
 522 
 523     /**
 524      * Implementation of ProcessHandle.Info.
 525      * Information snapshot about a process.
 526      * The attributes of a process vary by operating system and are not available
 527      * in all implementations.  Additionally, information about other processes
 528      * is limited by the operating system privileges of the process making the request.
 529      * If a value is not available, either a {@code null} or {@code -1} is stored.
 530      * The accessor methods return {@code null} if the value is not available.
 531      */
 532     static class Info implements ProcessHandle.Info {
 533         static {
 534             initIDs();
 535         }
 536 
 537         /**
 538          * Initialization of JNI fieldIDs.
 539          */
 540         private static native void initIDs();
 541 
 542         /**
 543          * Fill in this Info instance with information about the native process.
 544          * If values are not available the native code does not modify the field.
 545          * @param pid  of the native process
 546          */
 547         private native void info0(long pid);
 548 
 549         String command;
 550         String commandLine;
 551         String[] arguments;
 552         long startTime;
 553         long totalTime;
 554         String user;
 555 
 556         Info() {
 557             command = null;
 558             commandLine = null;
 559             arguments = null;
 560             startTime = -1L;
 561             totalTime = -1L;
 562             user = null;
 563         }
 564 
 565         /**
 566          * Returns the Info object with the fields from the process.
 567          * Whatever fields are provided by native are returned.
 568          * If the startTime of the process does not match the provided
 569          * startTime then an empty Info is returned.
 570          *
 571          * @param pid the native process identifier
 572          * @param startTime the startTime of the process being queried
 573          * @return ProcessHandle.Info non-null; individual fields may be null
 574          *          or -1 if not available.
 575          */
 576         public static ProcessHandle.Info info(long pid, long startTime) {
 577             Info info = new Info();
 578             info.info0(pid);
 579             if (startTime != info.startTime) {
 580                 info.command = null;
 581                 info.arguments = null;
 582                 info.startTime = -1L;
 583                 info.totalTime = -1L;
 584                 info.user = null;
 585             }
 586             return info;
 587         }
 588 
 589         @Override
 590         public Optional<String> command() {
 591             return Optional.ofNullable(command);
 592         }
 593 
 594         @Override
 595         public Optional<String> commandLine() {
 596             if (command != null && arguments != null) {
 597                 return Optional.of(command + " " + String.join(" ", arguments));
 598             } else {
 599                 return Optional.ofNullable(commandLine);
 600             }
 601         }
 602 
 603         @Override
 604         public Optional<String[]> arguments() {
 605             return Optional.ofNullable(arguments);
 606         }
 607 
 608         @Override
 609         public Optional<Instant> startInstant() {
 610             return (startTime > 0)
 611                     ? Optional.of(Instant.ofEpochMilli(startTime))
 612                     : Optional.empty();
 613         }
 614 
 615         @Override
 616         public Optional<Duration> totalCpuDuration() {
 617             return (totalTime != -1)
 618                     ? Optional.of(Duration.ofNanos(totalTime))
 619                     : Optional.empty();
 620         }
 621 
 622         @Override
 623         public Optional<String> user() {
 624             return Optional.ofNullable(user);
 625         }
 626 
 627         @Override
 628         public String toString() {
 629             StringBuilder sb = new StringBuilder(60);
 630             sb.append('[');
 631             if (user != null) {
 632                 sb.append("user: ");
 633                 sb.append(user());
 634             }
 635             if (command != null) {
 636                 if (sb.length() != 0) sb.append(", ");
 637                 sb.append("cmd: ");
 638                 sb.append(command);
 639             }
 640             if (arguments != null && arguments.length > 0) {
 641                 if (sb.length() != 0) sb.append(", ");
 642                 sb.append("args: ");
 643                 sb.append(Arrays.toString(arguments));
 644             }
 645             if (commandLine != null) {
 646                 if (sb.length() != 0) sb.append(", ");
 647                 sb.append("cmdLine: ");
 648                 sb.append(commandLine);
 649             }
 650             if (startTime > 0) {
 651                 if (sb.length() != 0) sb.append(", ");
 652                 sb.append("startTime: ");
 653                 sb.append(startInstant());
 654             }
 655             if (totalTime != -1) {
 656                 if (sb.length() != 0) sb.append(", ");
 657                 sb.append("totalTime: ");
 658                 sb.append(totalCpuDuration().toString());
 659             }
 660             sb.append(']');
 661             return sb.toString();
 662         }
 663     }
 664 }
--- EOF ---