jdk-sandbox: comparison jdk/src/java.base/unix/native/libjava/ProcessHandleImpl

equal deleted inserted replaced

-:e9a9d5b369bc
+:c19dcf5e0b6d
 * - waitForProcessExit0(pid, reap)
 * - getCurrentPid0()
 * - destroy0(pid, force)
 */
 #ifndef WIFEXITED
 #define WIFEXITED(status) (((status)&0xFF) == 0)
 #endif
 #ifndef WEXITSTATUS
 do { \
 _result = _cmd; \
 } while((_result == NULL) && (errno == EINTR)); \
 } while(0)
+#ifdef __solaris__
+#define STAT_FILE "/proc/%d/status"
+#else
+#define STAT_FILE "/proc/%d/stat"
+#endif
 /* Block until a child process exits and return its exit code.
 * Note, can only be called once for any given pid if reapStatus = true.
 */
 JNIEXPORT jint JNICALL
 Java_java_lang_ProcessHandleImpl_waitForProcessExit0(JNIEnv* env,
 jclass junk,
 jlong jpid,
 jboolean reapStatus)
 {
 pid_t pid = (pid_t)jpid;
 errno = 0;
 if (reapStatus != JNI_FALSE) {
 /*
 * Class:     java_lang_ProcessHandleImpl
 * Method:    getCurrentPid0
 * Signature: ()J
 */
-JNIEXPORT jlong JNICALL Java_java_lang_ProcessHandleImpl_getCurrentPid0
+JNIEXPORT jlong JNICALL
-(JNIEnv *env, jclass clazz) {
+Java_java_lang_ProcessHandleImpl_getCurrentPid0(JNIEnv *env, jclass clazz) {
 pid_t pid = getpid();
 return (jlong) pid;
-}
-/*
-* Class:     java_lang_ProcessHandleImpl
-* Method:    isAlive0
-* Signature: (J)Z
-*/
-JNIEXPORT jboolean JNICALL Java_java_lang_ProcessHandleImpl_isAlive0
-(JNIEnv *env, jobject obj, jlong jpid) {
-pid_t pid = (pid_t) jpid;
-return (kill(pid, 0) < 0) ? JNI_FALSE : JNI_TRUE;
 }
 /*
 * Class:     java_lang_ProcessHandleImpl
 * Method:    destroy0
 * Signature: (Z)Z
 */
-JNIEXPORT jboolean JNICALL Java_java_lang_ProcessHandleImpl_destroy0
+JNIEXPORT jboolean JNICALL
-(JNIEnv *env, jobject obj, jlong jpid, jboolean force) {
+Java_java_lang_ProcessHandleImpl_destroy0(JNIEnv *env,
+jobject obj,
+jlong jpid,
+jlong startTime,
+jboolean force) {
 pid_t pid = (pid_t) jpid;
 int sig = (force == JNI_TRUE) ? SIGKILL : SIGTERM;
-return (kill(pid, sig) >= 0);
+jlong start = Java_java_lang_ProcessHandleImpl_isAlive0(env, obj, jpid);
+if (start == startTime || start == 0 || startTime == 0) {
+return (kill(pid, sig) < 0) ? JNI_FALSE : JNI_TRUE;
+} else {
+return JNI_FALSE;
+}
 }
 /**
 * Size of password or group entry when not available via sysconf
 */
 #if defined(__linux__) || defined(__AIX__)
 /*
 * Signatures for internal OS specific functions.
 */
-static pid_t parentPid(JNIEnv *env, pid_t pid);
+static pid_t getStatInfo(JNIEnv *env, pid_t pid,
-static jint getChildren(JNIEnv *env, jlong jpid,
+jlong *totalTime, jlong* startTime);
-jlongArray array, jlongArray jparentArray);
-static void getStatInfo(JNIEnv *env, jobject jinfo, pid_t pid);
 static void getCmdlineInfo(JNIEnv *env, pid_t pid, jobject jinfo);
 static long long getBoottime(JNIEnv *env);
 jstring uidToUser(JNIEnv* env, uid_t uid);
 *
 * Class:     java_lang_ProcessHandleImpl_Info
 * Method:    initIDs
 * Signature: ()V
 */
-JNIEXPORT void JNICALL Java_java_lang_ProcessHandleImpl_00024Info_initIDs
+JNIEXPORT void JNICALL
-(JNIEnv *env, jclass clazz) {
+Java_java_lang_ProcessHandleImpl_00024Info_initIDs(JNIEnv *env, jclass clazz) {
 CHECK_NULL(ProcessHandleImpl_Info_commandID = (*env)->GetFieldID(env,
 clazz, "command", "Ljava/lang/String;"));
 CHECK_NULL(ProcessHandleImpl_Info_argumentsID = (*env)->GetFieldID(env,
 clazz, "arguments", "[Ljava/lang/String;"));
 clazz, "totalTime", "J"));
 CHECK_NULL(ProcessHandleImpl_Info_startTimeID = (*env)->GetFieldID(env,
 clazz, "startTime", "J"));
 CHECK_NULL(ProcessHandleImpl_Info_userID = (*env)->GetFieldID(env,
 clazz, "user", "Ljava/lang/String;"));
+}
+/**************************************************************
+* Static method to initialize the ticks per second rate.
+*
+* Class:     java_lang_ProcessHandleImpl
+* Method:    initNative
+* Signature: ()V
+*/
+JNIEXPORT void JNICALL
+Java_java_lang_ProcessHandleImpl_initNative(JNIEnv *env, jclass clazz) {
 clock_ticks_per_second = sysconf(_SC_CLK_TCK);
 bootTime_ms = getBoottime(env);
 }
 /*
+* Check if a process is alive.
+* Return the start time (ms since 1970) if it is available.
+* If the start time is not available return 0.
+* If the pid is invalid, return -1.
+*
+* Class:     java_lang_ProcessHandleImpl
+* Method:    isAlive0
+* Signature: (J)J
+*/
+JNIEXPORT jlong JNICALL
+Java_java_lang_ProcessHandleImpl_isAlive0(JNIEnv *env, jobject obj, jlong jpid) {
+pid_t pid = (pid_t) jpid;
+jlong startTime = 0L;
+jlong totalTime = 0L;
+pid_t ppid = getStatInfo(env, pid, &totalTime, &startTime);
+return (ppid <= 0) ? -1 : startTime;
+}
+/*
 * Returns the parent pid of the requested pid.
+* The start time of the process must match (or be ANY).
 *
 * Class:     java_lang_ProcessHandleImpl
 * Method:    parent0
 * Signature: (J)J
 */
-JNIEXPORT jlong JNICALL Java_java_lang_ProcessHandleImpl_parent0
+JNIEXPORT jlong JNICALL
-(JNIEnv *env, jobject obj, jlong jpid) {
+Java_java_lang_ProcessHandleImpl_parent0(JNIEnv *env,
+jobject obj,
+jlong jpid,
+jlong startTime) {
 pid_t pid = (pid_t) jpid;
-pid_t ppid = -1;
+pid_t ppid;
 pid_t mypid = getpid();
 if (pid == mypid) {
 ppid = getppid();
 } else {
-ppid = parentPid(env, pid);
+jlong start = 0L;;
+jlong total = 0L;        // unused
+ppid = getStatInfo(env, pid, &total, &start);
+if (start != startTime && start != 0 && startTime != 0) {
+ppid = -1;
+}
 }
 return (jlong) ppid;
 }
 /*
 * Returns the children of the requested pid and optionally each parent.
-*
+* Reads /proc and accumulates any process who parent pid matches.
+* The resulting pids are stored into the array of longs.
+* The number of pids is returned if they all fit.
+* If the array is too short, the negative of the desired length is returned. *
 * Class:     java_lang_ProcessHandleImpl
 * Method:    getChildPids
 * Signature: (J[J[J)I
 */
-JNIEXPORT jint JNICALL Java_java_lang_ProcessHandleImpl_getProcessPids0
+JNIEXPORT jint JNICALL
-(JNIEnv *env, jclass clazz, jlong jpid,
+Java_java_lang_ProcessHandleImpl_getProcessPids0(JNIEnv *env,
-jlongArray jarray, jlongArray jparentArray) {
+jclass clazz,
-return getChildren(env, jpid, jarray, jparentArray);
+jlong jpid,
-}
+jlongArray jarray,
+jlongArray jparentArray,
-/*
+jlongArray jstimesArray) {
-* Reads /proc and accumulates any process who parent pid matches.
-* The resulting pids are stored into the array of longs.
-* The number of pids is returned if they all fit.
-* If the array is too short, the negative of the desired length is returned.
-*/
-static jint getChildren(JNIEnv *env, jlong jpid,
-jlongArray jarray, jlongArray jparentArray) {
 DIR* dir;
 struct dirent* ptr;
 pid_t pid = (pid_t) jpid;
-pid_t ppid = 0;
-size_t count = 0;
 jlong* pids = NULL;
 jlong* ppids = NULL;
-size_t parentArraySize = 0;
+jlong* stimes = NULL;
-size_t arraySize = 0;
+jsize parentArraySize = 0;
+jsize arraySize = 0;
+jsize stimesSize = 0;
+jsize count = 0;
 arraySize = (*env)->GetArrayLength(env, jarray);
 JNU_CHECK_EXCEPTION_RETURN(env, -1);
 if (jparentArray != NULL) {
 parentArraySize = (*env)->GetArrayLength(env, jparentArray);
 JNU_CHECK_EXCEPTION_RETURN(env, -1);
 if (arraySize != parentArraySize) {
+JNU_ThrowIllegalArgumentException(env, "array sizes not equal");
+return 0;
+}
+}
+if (jstimesArray != NULL) {
+stimesSize = (*env)->GetArrayLength(env, jstimesArray);
+JNU_CHECK_EXCEPTION_RETURN(env, -1);
+if (arraySize != stimesSize) {
 JNU_ThrowIllegalArgumentException(env, "array sizes not equal");
 return 0;
 }
 }
 * To locate the children we scan /proc looking for files that have a
 * position integer as a filename.
 */
 if ((dir = opendir("/proc")) == NULL) {
 JNU_ThrowByNameWithLastError(env,
-"java/lang/Runtime", "Unable to open /proc");
+"java/lang/RuntimeException", "Unable to open /proc");
 return -1;
 }
 do { // Block to break out of on Exception
 pids = (*env)->GetLongArrayElements(env, jarray, NULL);
 ppids  = (*env)->GetLongArrayElements(env, jparentArray, NULL);
 if (ppids == NULL) {
 break;
 }
 }
+if (jstimesArray != NULL) {
+stimes  = (*env)->GetLongArrayElements(env, jstimesArray, NULL);
+if (stimes == NULL) {
+break;
+}
+}
 while ((ptr = readdir(dir)) != NULL) {
+pid_t ppid = 0;
+jlong totalTime = 0L;
+jlong startTime = 0L;
 /* skip files that aren't numbers */
 pid_t childpid = (pid_t) atoi(ptr->d_name);
 if ((int) childpid <= 0) {
 continue;
 }
+// Read /proc/pid/stat and get the parent pid, and start time
-ppid = 0;
+ppid = getStatInfo(env, childpid, &totalTime, &startTime);
-if (pid != 0 || jparentArray != NULL) {
+if (ppid > 0 && (pid == 0 || ppid == pid)) {
-// parentPid opens and reads /proc/pid/stat
-ppid = parentPid(env, childpid);
-}
-if (pid == 0 || ppid == pid) {
 if (count < arraySize) {
 // Only store if it fits
 pids[count] = (jlong) childpid;
 if (ppids != NULL) {
 // Store the parentPid
 ppids[count] = (jlong) ppid;
 }
+if (stimes != NULL) {
+// Store the process start time
+stimes[count] = startTime;
+}
 }
 count++; // Count to tabulate size needed
 }
 }
 } while (0);
 (*env)->ReleaseLongArrayElements(env, jarray, pids, 0);
 }
 if (ppids != NULL) {
 (*env)->ReleaseLongArrayElements(env, jparentArray, ppids, 0);
 }
+if (stimes != NULL) {
+(*env)->ReleaseLongArrayElements(env, jstimesArray, stimes, 0);
+}
 closedir(dir);
 // If more pids than array had size for; count will be greater than array size
 return count;
 }
-/*
-* Returns the parent pid of a given pid, or -1 if not found
-*/
-static pid_t parentPid(JNIEnv *env, pid_t pid) {
-char state;
-FILE* fp;
-char stat[2048];
-int statlen;
-char fn[32];
-int i, p;
-char* s;
-/*
-* try to open /proc/%d/stat
-*/
-snprintf(fn, sizeof fn, "/proc/%d/stat", pid);
-fp = fopen(fn, "r");
-if (fp == NULL) {
-return -1;
-}
-/*
-* The format is: pid (command) state ppid ...
-* As the command could be anything we must find the right most
-* ")" and then skip the white spaces that follow it.
-*/
-statlen = fread(stat, 1, (sizeof stat - 1), fp);
-fclose(fp);
-if (statlen < 0) {
-return -1;
-}
-stat[statlen] = '\0';
-s = strrchr(stat, ')');
-if (s == NULL) {
-return -1;
-}
-do s++; while (isspace(*s));
-i = sscanf(s, "%c %d", &state, &p);
-if (i != 2) {
-return (pid_t)-1;
-}
-return (pid_t) p;
-}
 /**************************************************************
 * Implementation of ProcessHandleImpl_Info native methods.
 */
 *
 * Class:     java_lang_ProcessHandleImpl_Info
 * Method:    info0
 * Signature: (JLjava/lang/ProcessHandle/Info;)I
 */
-JNIEXPORT void JNICALL Java_java_lang_ProcessHandleImpl_00024Info_info0
+JNIEXPORT void JNICALL
-(JNIEnv *env, jobject jinfo, jlong jpid) {
+Java_java_lang_ProcessHandleImpl_00024Info_info0(JNIEnv *env,
+jobject jinfo,
+jlong jpid) {
 pid_t pid = (pid_t) jpid;
-getStatInfo(env, jinfo, (pid_t)pid);
+pid_t ppid;
-getCmdlineInfo(env, pid, jinfo);
+jlong totalTime = 0L;
+jlong startTime = -1L;
+ppid = getStatInfo(env, pid,  &totalTime, &startTime);
+if (ppid > 0) {
+(*env)->SetLongField(env, jinfo, ProcessHandleImpl_Info_totalTimeID, totalTime);
+JNU_CHECK_EXCEPTION(env);
+(*env)->SetLongField(env, jinfo, ProcessHandleImpl_Info_startTimeID, startTime);
+JNU_CHECK_EXCEPTION(env);
+getCmdlineInfo(env, pid, jinfo);
+}
 }
 /**
-* Read /proc/<pid>/stat and fill in the fields of the Info object.
+* Read /proc/<pid>/stat and return the ppid, total cputime and start time.
-* The executable name, plus the user, system, and start times are gathered.
+* -1 is fail;  zero is unknown; >  0 is parent pid
 */
-static void getStatInfo(JNIEnv *env, jobject jinfo, pid_t pid) {
+static pid_t getStatInfo(JNIEnv *env, pid_t pid,
-char state;
+jlong *totalTime, jlong* startTime) {
 FILE* fp;
 char buffer[2048];
-struct stat stat_buf;
 int statlen;
 char fn[32];
-int i, ppid = -2;
 char* s;
-char *cmd;
+int parentPid;
-jstring name = NULL;
+long unsigned int utime = 0;      // clock tics
-unsigned long userTime = 0;             // clock tics
+long unsigned int stime = 0;      // clock tics
-unsigned long totalTime = 0;            // clock tics
+long long unsigned int start = 0; // microseconds
-jlong total = 0;                        // nano seconds
-unsigned long long startTime = 0;       // microseconds
 /*
 * Try to stat and then open /proc/%d/stat
 */
-snprintf(fn, sizeof fn, "/proc/%d/stat", pid);
+snprintf(fn, sizeof fn, STAT_FILE, pid);
-if (stat(fn, &stat_buf) < 0) {
-return;
-}
-CHECK_NULL((name = uidToUser(env, stat_buf.st_uid)));
-(*env)->SetObjectField(env, jinfo, ProcessHandleImpl_Info_userID, name);
-JNU_CHECK_EXCEPTION(env);
 fp = fopen(fn, "r");
 if (fp == NULL) {
-return;
+return -1;              // fail, no such /proc/pid/stat
 }
 /*
 * The format is: pid (command) state ppid ...
 * As the command could be anything we must find the right most
 * ")" and then skip the white spaces that follow it.
 */
 statlen = fread(buffer, 1, (sizeof buffer - 1), fp);
 fclose(fp);
 if (statlen < 0) {
-return;
+return 0;               // parent pid is not available
 }
 buffer[statlen] = '\0';
 s = strchr(buffer, '(');
 if (s == NULL) {
-return;
+return 0;               // parent pid is not available
 }
 // Found start of command, skip to end
 s++;
 s = strrchr(s, ')');
 if (s == NULL) {
-return;
+return 0;               // parent pid is not available
 }
 s++;
 // Scan the needed fields from status, retaining only ppid(4),
 // utime (14), stime(15), starttime(22)
-i = sscanf(s, " %c %d %*d %*d %*d %*d %*d %*u %*u %*u %*u %lu %lu %*d %*d %*d %*d %*d %*d %llu",
+if (4 != sscanf(s, " %*c %d %*d %*d %*d %*d %*d %*u %*u %*u %*u %lu %lu %*d %*d %*d %*d %*d %*d %llu",
-&state, &ppid, &userTime, &totalTime, &startTime);
+&parentPid, &utime, &stime, &start)) {
-if (i != 5) {
+return 0;              // not all values parsed; return error
-return;              // not all values parsed; return error
+}
-}
+*totalTime = (utime + stime) * (jlong)(1000000000 / clock_ticks_per_second);
-total = (userTime + totalTime) * (jlong)(1000000000 / clock_ticks_per_second);
+*startTime = bootTime_ms + ((start * 1000) / clock_ticks_per_second);
-startTime = bootTime_ms + ((startTime * 1000) / clock_ticks_per_second);
+return parentPid;
-(*env)->SetLongField(env, jinfo, ProcessHandleImpl_Info_totalTimeID, total);
-JNU_CHECK_EXCEPTION(env);
-(*env)->SetLongField(env, jinfo, ProcessHandleImpl_Info_startTimeID, startTime);
-JNU_CHECK_EXCEPTION(env);
 }
 /**
 * Construct the argument array by parsing the arguments from the sequence
 * of arguments. The zero'th arg is the command executable
 int fd;
 int cmdlen = 0;
 char *cmdline = NULL, *cmdEnd;  // used for command line args and exe
 jstring cmdexe = NULL;
 char fn[32];
+struct stat stat_buf;
 /*
 * Try to open /proc/%d/cmdline
 */
 snprintf(fn, sizeof fn, "/proc/%d/cmdline", pid);
 s += strnlen(s, (cmdEnd - s)) + 1;
 }
 if (fillArgArray(env, jinfo, i, cmdline, cmdEnd, cmdexe) < 0) {
 break;
+}
+// Get and store the user name
+if (fstat(fd, &stat_buf) == 0) {
+jstring name = uidToUser(env, stat_buf.st_uid);
+if (name != NULL) {
+(*env)->SetObjectField(env, jinfo, ProcessHandleImpl_Info_userID, name);
+}
 }
 } while (0);
 if (cmdline != NULL) {
 free(cmdline);

changeset 31682	c19dcf5e0b6d
parent 30899	d2408e757489
child 32209	24bb680a1609