src/java.base/unix/classes/java/lang/ProcessImpl.java

rev 59105 : imported patch corelibs

*** 75,87 ****
  
      private /* final */ OutputStream stdin;
      private /* final */ InputStream  stdout;
      private /* final */ InputStream  stderr;
  
-     // only used on Solaris
-     private /* final */ DeferredCloseInputStream stdout_inner_stream;
- 
      private static enum LaunchMechanism {
          // order IS important!
          FORK,
          POSIX_SPAWN,
          VFORK
--- 75,84 ----
*** 91,102 ****
  
          LINUX(LaunchMechanism.POSIX_SPAWN, LaunchMechanism.VFORK, LaunchMechanism.FORK),
  
          BSD(LaunchMechanism.POSIX_SPAWN, LaunchMechanism.FORK),
  
-         SOLARIS(LaunchMechanism.POSIX_SPAWN, LaunchMechanism.FORK),
- 
          AIX(LaunchMechanism.POSIX_SPAWN, LaunchMechanism.FORK);
  
          final LaunchMechanism defaultLaunchMechanism;
          final Set<LaunchMechanism> validLaunchMechanisms;
  
--- 88,97 ----
*** 137,147 ****
          static Platform get() {
              String osName = GetPropertyAction.privilegedGetProperty("os.name");
  
              if (osName.equals("Linux")) { return LINUX; }
              if (osName.contains("OS X")) { return BSD; }
-             if (osName.equals("SunOS")) { return SOLARIS; }
              if (osName.equals("AIX")) { return AIX; }
  
              throw new Error(osName + " is not a supported OS platform.");
          }
      }
--- 132,141 ----
*** 383,427 ****
  
                      return null;
                  });
                  break;
  
-             case SOLARIS:
-                 stdin = (fds[0] == -1) ?
-                         ProcessBuilder.NullOutputStream.INSTANCE :
-                         new BufferedOutputStream(
-                             new FileOutputStream(newFileDescriptor(fds[0])));
- 
-                 stdout = (fds[1] == -1 || forceNullOutputStream) ?
-                          ProcessBuilder.NullInputStream.INSTANCE :
-                          new BufferedInputStream(
-                              stdout_inner_stream =
-                                  new DeferredCloseInputStream(
-                                      newFileDescriptor(fds[1])));
- 
-                 stderr = (fds[2] == -1) ?
-                          ProcessBuilder.NullInputStream.INSTANCE :
-                          new DeferredCloseInputStream(newFileDescriptor(fds[2]));
- 
-                 /*
-                  * For each subprocess forked a corresponding reaper task
-                  * is submitted.  That task is the only thread which waits
-                  * for the subprocess to terminate and it doesn't hold any
-                  * locks while doing so.  This design allows waitFor() and
-                  * exitStatus() to be safely executed in parallel (and they
-                  * need no native code).
-                  */
-                 ProcessHandleImpl.completion(pid, true).handle((exitcode, throwable) -> {
-                     synchronized (this) {
-                         this.exitcode = (exitcode == null) ? -1 : exitcode.intValue();
-                         this.hasExited = true;
-                         this.notifyAll();
-                     }
-                     return null;
-                 });
-                 break;
- 
              case AIX:
                  stdin = (fds[0] == -1) ?
                          ProcessBuilder.NullOutputStream.INSTANCE :
                          new ProcessPipeOutputStream(fds[0]);
  
--- 377,386 ----
*** 520,552 ****
                  try { stdin.close();  } catch (IOException ignored) {}
                  try { stdout.close(); } catch (IOException ignored) {}
                  try { stderr.close(); } catch (IOException ignored) {}
                  break;
  
-             case SOLARIS:
-                 // There is a risk that pid will be recycled, causing us to
-                 // kill the wrong process!  So we only terminate processes
-                 // that appear to still be running.  Even with this check,
-                 // there is an unavoidable race condition here, but the window
-                 // is very small, and OSes try hard to not recycle pids too
-                 // soon, so this is quite safe.
-                 synchronized (this) {
-                     if (!hasExited)
-                         processHandle.destroyProcess(force);
-                     try {
-                         stdin.close();
-                         if (stdout_inner_stream != null)
-                             stdout_inner_stream.closeDeferred(stdout);
-                         if (stderr instanceof DeferredCloseInputStream)
-                             ((DeferredCloseInputStream) stderr)
-                                 .closeDeferred(stderr);
-                     } catch (IOException e) {
-                         // ignore
-                     }
-                 }
-                 break;
- 
              default: throw new AssertionError("Unsupported platform: " + platform);
          }
      }
  
      @Override
--- 479,488 ----