| // natPosixProcess.cc - Native side of POSIX process code. | |
| /* Copyright (C) 1998, 1999, 2000, 2002, 2003, 2004, 2005, 2006, 2007 | |
| Free Software Foundation | |
| This file is part of libgcj. | |
| This software is copyrighted work licensed under the terms of the | |
| Libgcj License. Please consult the file "LIBGCJ_LICENSE" for | |
| details. */ | |
| #include <config.h> | |
| #ifdef HAVE_UNISTD_H | |
| #include <unistd.h> | |
| #endif | |
| #include <errno.h> | |
| #include <fcntl.h> | |
| #include <sys/types.h> | |
| #include <sys/wait.h> | |
| #ifdef HAVE_SYS_TIME_H | |
| #include <sys/time.h> | |
| #endif | |
| #ifdef HAVE_SYS_RESOURCE_H | |
| #include <sys/resource.h> | |
| #endif | |
| #include <signal.h> | |
| #include <string.h> | |
| #include <stdlib.h> | |
| #include <stdio.h> | |
| #include <unistd.h> | |
| #include <pthread.h> | |
| #include <posix.h> | |
| #include <posix-threads.h> | |
| #include <jvm.h> | |
| #include <java/lang/PosixProcess$ProcessManager.h> | |
| #include <java/lang/PosixProcess.h> | |
| #include <java/lang/IllegalThreadStateException.h> | |
| #include <java/lang/InternalError.h> | |
| #include <java/lang/InterruptedException.h> | |
| #include <java/lang/NullPointerException.h> | |
| #include <java/lang/Thread.h> | |
| #include <java/io/File.h> | |
| #include <java/io/FileDescriptor.h> | |
| #include <gnu/java/nio/channels/FileChannelImpl.h> | |
| #include <java/io/FileInputStream.h> | |
| #include <java/io/FileOutputStream.h> | |
| #include <java/io/IOException.h> | |
| #include <java/lang/OutOfMemoryError.h> | |
| #include <java/lang/PosixProcess$EOFInputStream.h> | |
| using gnu::java::nio::channels::FileChannelImpl; | |
| using namespace java::lang; | |
| extern char **environ; | |
| static char * | |
| new_string (jstring string) | |
| { | |
| jsize s = _Jv_GetStringUTFLength (string); | |
| char *buf = (char *) _Jv_Malloc (s + 1); | |
| _Jv_GetStringUTFRegion (string, 0, string->length(), buf); | |
| buf[s] = '\0'; | |
| return buf; | |
| } | |
| static void | |
| cleanup (char **args, char **env, char *path) | |
| { | |
| if (args != NULL) | |
| { | |
| for (int i = 0; args[i] != NULL; ++i) | |
| _Jv_Free (args[i]); | |
| _Jv_Free (args); | |
| } | |
| if (env != NULL) | |
| { | |
| for (int i = 0; env[i] != NULL; ++i) | |
| _Jv_Free (env[i]); | |
| _Jv_Free (env); | |
| } | |
| if (path != NULL) | |
| _Jv_Free (path); | |
| } | |
| // This makes our error handling a bit simpler and it lets us avoid | |
| // thread bugs where we close a possibly-reopened file descriptor for | |
| // a second time. | |
| static void | |
| myclose (int &fd) | |
| { | |
| if (fd != -1) | |
| close (fd); | |
| fd = -1; | |
| } | |
| namespace | |
| { | |
| struct ProcessManagerInternal | |
| { | |
| int pipe_ends[2]; | |
| struct sigaction old_sigaction; | |
| }; | |
| } | |
| // There has to be a signal handler in order to be able to | |
| // sigwait() on SIGCHLD. The information passed is ignored as it | |
| // will be recovered by the waitpid() call. | |
| static void | |
| #ifdef SA_SIGINFO | |
| sigchld_handler (int sig, siginfo_t *si, void *third) | |
| #else | |
| sigchld_handler (int sig) | |
| #endif | |
| { | |
| if (PosixProcess$ProcessManager::nativeData != NULL) | |
| { | |
| ProcessManagerInternal *pmi = | |
| (ProcessManagerInternal *)PosixProcess$ProcessManager::nativeData; | |
| char c = 0; | |
| ::write(pmi->pipe_ends[1], &c, 1); | |
| if (pmi->old_sigaction.sa_handler != SIG_DFL | |
| && pmi->old_sigaction.sa_handler != SIG_IGN) | |
| { | |
| #ifdef SA_SIGINFO | |
| if ((pmi->old_sigaction.sa_flags & SA_SIGINFO) != 0) | |
| pmi->old_sigaction.sa_sigaction(sig, si, third); | |
| else | |
| #endif | |
| (*pmi->old_sigaction.sa_handler)(sig); | |
| } | |
| } | |
| } | |
| // Get ready to enter the main reaper thread loop. | |
| void | |
| java::lang::PosixProcess$ProcessManager::init () | |
| { | |
| // The nativeData is static to avoid races installing the signal | |
| // handler in the case that it is chained. | |
| if (nativeData == NULL ) | |
| { | |
| ProcessManagerInternal *pmi = | |
| (ProcessManagerInternal *)JvAllocBytes(sizeof(ProcessManagerInternal)); | |
| if (0 != ::pipe(pmi->pipe_ends)) | |
| goto error; | |
| // Make writing non-blocking so that the signal handler will | |
| // never block. | |
| int fl = ::fcntl(pmi->pipe_ends[1], F_GETFL); | |
| ::fcntl(pmi->pipe_ends[1], F_SETFL, fl | O_NONBLOCK); | |
| nativeData = (::gnu::gcj::RawDataManaged *)pmi; | |
| // SIGCHLD is blocked in all threads in posix-threads.cc. | |
| // Setup the SIGCHLD handler. | |
| struct sigaction sa; | |
| memset (&sa, 0, sizeof (sa)); | |
| #ifdef SA_SIGINFO | |
| sa.sa_sigaction = sigchld_handler; | |
| // We only want signals when the things exit. | |
| sa.sa_flags = SA_NOCLDSTOP | SA_SIGINFO; | |
| #else | |
| sa.sa_handler = sigchld_handler; | |
| // We only want signals when the things exit. | |
| sa.sa_flags = SA_NOCLDSTOP; | |
| #endif | |
| if (-1 == sigaction (SIGCHLD, &sa, &pmi->old_sigaction)) | |
| goto error; | |
| } | |
| // All OK. | |
| return; | |
| error: | |
| throw new InternalError (JvNewStringUTF (strerror (errno))); | |
| } | |
| void | |
| java::lang::PosixProcess$ProcessManager::waitForSignal () | |
| { | |
| // Wait for SIGCHLD | |
| _Jv_UnBlockSigchld(); | |
| ProcessManagerInternal *pmi = (ProcessManagerInternal *)nativeData; | |
| // Try to read multiple (64) notifications in one go. | |
| char c[64]; | |
| ::read(pmi->pipe_ends[0], c, sizeof (c)); | |
| _Jv_BlockSigchld(); | |
| return; | |
| } | |
| jboolean java::lang::PosixProcess$ProcessManager::reap (PosixProcess *p) | |
| { | |
| pid_t rv; | |
| // Try to get the return code from the child process. | |
| int status; | |
| rv = ::waitpid ((pid_t)p->pid, &status, WNOHANG); | |
| if (rv == -1) | |
| throw new InternalError (JvNewStringUTF (strerror (errno))); | |
| if (rv == 0) | |
| return false; // No children to wait for. | |
| JvSynchronize sync (p); | |
| p->status = WIFEXITED (status) ? WEXITSTATUS (status) : -1; | |
| p->state = PosixProcess::STATE_TERMINATED; | |
| p->processTerminationCleanup(); | |
| p->notifyAll (); | |
| return true; | |
| } | |
| void | |
| java::lang::PosixProcess$ProcessManager::signalReaper () | |
| { | |
| ProcessManagerInternal *pmi = (ProcessManagerInternal *)nativeData; | |
| char c = 0; | |
| ::write(pmi->pipe_ends[1], &c, 1); | |
| // Ignore errors. If EPIPE the reaper has already exited. | |
| } | |
| void | |
| java::lang::PosixProcess::nativeDestroy () | |
| { | |
| int c = ::kill ((pid_t) pid, SIGKILL); | |
| if (c == 0) | |
| return; | |
| // kill() failed. | |
| throw new InternalError (JvNewStringUTF (strerror (errno))); | |
| } | |
| void | |
| java::lang::PosixProcess::nativeSpawn () | |
| { | |
| using namespace java::io; | |
| // Initialize all locals here to make cleanup simpler. | |
| char **args = NULL; | |
| char **env = NULL; | |
| char *path = NULL; | |
| int inp[2], outp[2], errp[2], msgp[2]; | |
| inp[0] = -1; | |
| inp[1] = -1; | |
| outp[0] = -1; | |
| outp[1] = -1; | |
| errp[0] = -1; | |
| errp[1] = -1; | |
| msgp[0] = -1; | |
| msgp[1] = -1; | |
| errorStream = NULL; | |
| inputStream = NULL; | |
| outputStream = NULL; | |
| try | |
| { | |
| // Transform arrays to native form. | |
| args = (char **) _Jv_Malloc ((progarray->length + 1) * sizeof (char *)); | |
| // Initialize so we can gracefully recover. | |
| jstring *elts = elements (progarray); | |
| for (int i = 0; i <= progarray->length; ++i) | |
| args[i] = NULL; | |
| for (int i = 0; i < progarray->length; ++i) | |
| args[i] = new_string (elts[i]); | |
| args[progarray->length] = NULL; | |
| if (envp) | |
| { | |
| bool need_path = true; | |
| bool need_ld_library_path = true; | |
| int i; | |
| // Preserve PATH and LD_LIBRARY_PATH unless specified | |
| // explicitly. We need three extra slots. Potentially PATH | |
| // and LD_LIBRARY_PATH will be added plus the NULL | |
| // termination. | |
| env = (char **) _Jv_Malloc ((envp->length + 3) * sizeof (char *)); | |
| elts = elements (envp); | |
| // Initialize so we can gracefully recover. | |
| for (i = 0; i < envp->length + 3; ++i) | |
| env[i] = NULL; | |
| for (i = 0; i < envp->length; ++i) | |
| { | |
| env[i] = new_string (elts[i]); | |
| if (!strncmp (env[i], "PATH=", sizeof("PATH="))) | |
| need_path = false; | |
| if (!strncmp (env[i], "LD_LIBRARY_PATH=", | |
| sizeof("LD_LIBRARY_PATH="))) | |
| need_ld_library_path = false; | |
| } | |
| if (need_path) | |
| { | |
| char *path_val = getenv ("PATH"); | |
| if (path_val) | |
| { | |
| env[i] = (char *) _Jv_Malloc (strlen (path_val) + | |
| sizeof("PATH=") + 1); | |
| strcpy (env[i], "PATH="); | |
| strcat (env[i], path_val); | |
| i++; | |
| } | |
| } | |
| if (need_ld_library_path) | |
| { | |
| char *path_val = getenv ("LD_LIBRARY_PATH"); | |
| if (path_val) | |
| { | |
| env[i] = | |
| (char *) _Jv_Malloc (strlen (path_val) + | |
| sizeof("LD_LIBRARY_PATH=") + 1); | |
| strcpy (env[i], "LD_LIBRARY_PATH="); | |
| strcat (env[i], path_val); | |
| i++; | |
| } | |
| } | |
| env[i] = NULL; | |
| } | |
| // We allocate this here because we can't call malloc() after | |
| // the fork. | |
| if (dir != NULL) | |
| path = new_string (dir->getPath ()); | |
| // Create pipes for I/O. MSGP is for communicating exec() | |
| // status. If redirecting stderr to stdout, we don't need to | |
| // create the ERRP pipe. | |
| if (pipe (inp) || pipe (outp) || pipe (msgp) | |
| || fcntl (msgp[1], F_SETFD, FD_CLOEXEC)) | |
| throw new IOException (JvNewStringUTF (strerror (errno))); | |
| if (! redirect && pipe (errp)) | |
| throw new IOException (JvNewStringUTF (strerror (errno))); | |
| // We create the streams before forking. Otherwise if we had an | |
| // error while creating the streams we would have run the child | |
| // with no way to communicate with it. | |
| if (redirect) | |
| errorStream = PosixProcess$EOFInputStream::instance; | |
| else | |
| errorStream = | |
| new FileInputStream (new | |
| FileChannelImpl (errp[0], | |
| FileChannelImpl::READ)); | |
| inputStream = | |
| new FileInputStream (new | |
| FileChannelImpl (inp[0], FileChannelImpl::READ)); | |
| outputStream = | |
| new FileOutputStream (new FileChannelImpl (outp[1], | |
| FileChannelImpl::WRITE)); | |
| // We don't use vfork() because that would cause the local | |
| // environment to be set by the child. | |
| // Use temporary for fork result to avoid dirtying an extra page. | |
| pid_t pid_tmp; | |
| if ((pid_tmp = fork ()) == -1) | |
| throw new IOException (JvNewStringUTF (strerror (errno))); | |
| if (pid_tmp == 0) | |
| { | |
| // Child process, so remap descriptors, chdir and exec. | |
| if (envp) | |
| environ = env; | |
| // We ignore errors from dup2 because they should never occur. | |
| dup2 (outp[0], 0); | |
| dup2 (inp[1], 1); | |
| dup2 (redirect ? inp[1] : errp[1], 2); | |
| // Use close and not myclose -- we're in the child, and we | |
| // aren't worried about the possible race condition. | |
| close (inp[0]); | |
| close (inp[1]); | |
| if (! redirect) | |
| { | |
| close (errp[0]); | |
| close (errp[1]); | |
| } | |
| close (outp[0]); | |
| close (outp[1]); | |
| close (msgp[0]); | |
| // Change directory. | |
| if (path != NULL) | |
| { | |
| if (chdir (path) != 0) | |
| { | |
| char c = errno; | |
| write (msgp[1], &c, 1); | |
| _exit (127); | |
| } | |
| } | |
| // Make sure all file descriptors are closed. In | |
| // multi-threaded programs, there is a race between when a | |
| // descriptor is obtained, when we can set FD_CLOEXEC, and | |
| // fork(). If the fork occurs before FD_CLOEXEC is set, the | |
| // descriptor would leak to the execed process if we did not | |
| // manually close it. So that is what we do. Since we | |
| // close all the descriptors, it is redundant to set | |
| // FD_CLOEXEC on them elsewhere. | |
| int max_fd; | |
| #ifdef HAVE_GETRLIMIT | |
| rlimit rl; | |
| int rv = getrlimit(RLIMIT_NOFILE, &rl); | |
| if (rv == 0) | |
| max_fd = rl.rlim_max - 1; | |
| else | |
| max_fd = 1024 - 1; | |
| #else | |
| max_fd = 1024 - 1; | |
| #endif | |
| while(max_fd > 2) | |
| { | |
| if (max_fd != msgp[1]) | |
| close (max_fd); | |
| max_fd--; | |
| } | |
| // Make sure that SIGCHLD is unblocked for the new process. | |
| sigset_t mask; | |
| sigemptyset (&mask); | |
| sigaddset (&mask, SIGCHLD); | |
| sigprocmask (SIG_UNBLOCK, &mask, NULL); | |
| execvp (args[0], args); | |
| // Send the parent notification that the exec failed. | |
| char c = errno; | |
| write (msgp[1], &c, 1); | |
| _exit (127); | |
| } | |
| // Parent. Close extra file descriptors and mark ours as | |
| // close-on-exec. | |
| pid = (jlong) pid_tmp; | |
| myclose (outp[0]); | |
| myclose (inp[1]); | |
| if (! redirect) | |
| myclose (errp[1]); | |
| myclose (msgp[1]); | |
| char c; | |
| int r = read (msgp[0], &c, 1); | |
| if (r == -1) | |
| throw new IOException (JvNewStringUTF (strerror (errno))); | |
| else if (r != 0) | |
| throw new IOException (JvNewStringUTF (strerror (c))); | |
| } | |
| catch (java::lang::Throwable *thrown) | |
| { | |
| // Do some cleanup we only do on failure. If a stream object | |
| // has been created, we must close the stream itself (to avoid | |
| // duplicate closes when the stream object is collected). | |
| // Otherwise we simply close the underlying file descriptor. | |
| // We ignore errors here as they are uninteresting. | |
| try | |
| { | |
| if (inputStream != NULL) | |
| inputStream->close (); | |
| else | |
| myclose (inp[0]); | |
| } | |
| catch (java::lang::Throwable *ignore) | |
| { | |
| } | |
| try | |
| { | |
| if (outputStream != NULL) | |
| outputStream->close (); | |
| else | |
| myclose (outp[1]); | |
| } | |
| catch (java::lang::Throwable *ignore) | |
| { | |
| } | |
| try | |
| { | |
| if (errorStream != NULL) | |
| errorStream->close (); | |
| else if (! redirect) | |
| myclose (errp[0]); | |
| } | |
| catch (java::lang::Throwable *ignore) | |
| { | |
| } | |
| // These are potentially duplicate, but it doesn't matter due to | |
| // the use of myclose. | |
| myclose (outp[0]); | |
| myclose (inp[1]); | |
| if (! redirect) | |
| myclose (errp[1]); | |
| myclose (msgp[1]); | |
| exception = thrown; | |
| } | |
| myclose (msgp[0]); | |
| cleanup (args, env, path); | |
| } |