1 /*

     2  * Copyright (c) 2014, 2015, 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 

    26 #include "jni.h"

    27 #include "jni_util.h"

    28 #include "java_lang_ProcessHandleImpl.h"

    29 #include "java_lang_ProcessHandleImpl_Info.h"

    30 

    31 

    32 #include <stdio.h>

    33 

    34 #include <errno.h>

    35 #include <fcntl.h>

    36 #include <pwd.h>

    37 #include <signal.h>

    38 #include <stdlib.h>

    39 #include <unistd.h>

    40 #include <sys/types.h>

    41 #include <sys/stat.h>

    42 #include <sys/wait.h>

    43 

    44 #include <string.h>

    45 #include <dirent.h>

    46 #include <ctype.h>

    47 

    48 /**

    49  * Implementations of ProcessHandleImpl functions that are common to all

    50  * Unix variants:

    51  * - waitForProcessExit0(pid, reap)

    52  * - getCurrentPid0()

    53  * - destroy0(pid, force)

    54  */

    55 

    56 

    57 #ifndef WIFEXITED

    58 #define WIFEXITED(status) (((status)&0xFF) == 0)

    59 #endif

    60 

    61 #ifndef WEXITSTATUS

    62 #define WEXITSTATUS(status) (((status)>>8)&0xFF)

    63 #endif

    64 

    65 #ifndef WIFSIGNALED

    66 #define WIFSIGNALED(status) (((status)&0xFF) > 0 && ((status)&0xFF00) == 0)

    67 #endif

    68 

    69 #ifndef WTERMSIG

    70 #define WTERMSIG(status) ((status)&0x7F)

    71 #endif

    72 

    73 #define RESTARTABLE(_cmd, _result) do { \

    74   do { \

    75     _result = _cmd; \

    76   } while((_result == -1) && (errno == EINTR)); \

    77 } while(0)

    78 

    79 #define RESTARTABLE_RETURN_PTR(_cmd, _result) do { \

    80   do { \

    81     _result = _cmd; \

    82   } while((_result == NULL) && (errno == EINTR)); \

    83 } while(0)

    84 

    85 

    86 /* Block until a child process exits and return its exit code.

    87  * Note, can only be called once for any given pid if reapStatus = true.

    88  */

    89 JNIEXPORT jint JNICALL

    90 Java_java_lang_ProcessHandleImpl_waitForProcessExit0(JNIEnv* env,

    91                                               jclass junk,

    92                                               jlong jpid,

    93                                               jboolean reapStatus)

    94 {

    95     pid_t pid = (pid_t)jpid;

    96     errno = 0;

    97 

    98     if (reapStatus != JNI_FALSE) {

    99         /* Wait for the child process to exit.

   100          * waitpid() is standard, so use it on all POSIX platforms.

   101          * It is known to work when blocking to wait for the pid

   102          * This returns immediately if the child has already exited.

   103          */

   104         int status;

   105         while (waitpid(pid, &status, 0) < 0) {

   106             switch (errno) {

   107                 case ECHILD: return 0;

   108                 case EINTR: break;

   109                 default: return -1;

   110             }

   111         }

   112 

   113         if (WIFEXITED(status)) {

   114             return WEXITSTATUS(status);

   115         } else if (WIFSIGNALED(status)) {

   116             /* The child exited because of a signal.

   117              * The best value to return is 0x80 + signal number,

   118              * because that is what all Unix shells do, and because

   119              * it allows callers to distinguish between process exit and

   120              * process death by signal.

   121              * Unfortunately, the historical behavior on Solaris is to return

   122              * the signal number, and we preserve this for compatibility. */

   123 #ifdef __solaris__

   124             return WTERMSIG(status);

   125 #else

   126             return 0x80 + WTERMSIG(status);

   127 #endif

   128         } else {

   129             return status;

   130         }

   131      } else {

   132         /*

   133          * Wait for the child process to exit without reaping the exitValue.

   134          * waitid() is standard on all POSIX platforms.

   135          * Note: waitid on Mac OS X 10.7 seems to be broken;

   136          * it does not return the exit status consistently.

   137          */

   138         siginfo_t siginfo;

   139         int options = WEXITED |  WNOWAIT;

   140         memset(&siginfo, 0, sizeof siginfo);

   141         while (waitid(P_PID, pid, &siginfo, options) < 0) {

   142             switch (errno) {

   143             case ECHILD: return 0;

   144             case EINTR: break;

   145             default: return -1;

   146             }

   147         }

   148 

   149         if (siginfo.si_code == CLD_EXITED) {

   150              /*

   151               * The child exited normally; get its exit code.

   152               */

   153              return siginfo.si_status;

   154         } else if (siginfo.si_code == CLD_KILLED || siginfo.si_code == CLD_DUMPED) {

   155              /* The child exited because of a signal.

   156               * The best value to return is 0x80 + signal number,

   157               * because that is what all Unix shells do, and because

   158               * it allows callers to distinguish between process exit and

   159               * process death by signal.

   160               * Unfortunately, the historical behavior on Solaris is to return

   161               * the signal number, and we preserve this for compatibility. */

   162  #ifdef __solaris__

   163              return WTERMSIG(siginfo.si_status);

   164  #else

   165              return 0x80 + WTERMSIG(siginfo.si_status);

   166  #endif

   167         } else {

   168              /*

   169               * Unknown exit code; pass it through.

   170               */

   171              return siginfo.si_status;

   172         }

   173     }

   174 }

   175 

   176 /*

   177  * Class:     java_lang_ProcessHandleImpl

   178  * Method:    getCurrentPid0

   179  * Signature: ()J

   180  */

   181 JNIEXPORT jlong JNICALL Java_java_lang_ProcessHandleImpl_getCurrentPid0

   182 (JNIEnv *env, jclass clazz) {

   183     pid_t pid = getpid();

   184     return (jlong) pid;

   185 }

   186 

   187 /*

   188  * Class:     java_lang_ProcessHandleImpl

   189  * Method:    isAlive0

   190  * Signature: (J)Z

   191  */

   192 JNIEXPORT jboolean JNICALL Java_java_lang_ProcessHandleImpl_isAlive0

   193 (JNIEnv *env, jobject obj, jlong jpid) {

   194     pid_t pid = (pid_t) jpid;

   195     return (kill(pid, 0) < 0) ? JNI_FALSE : JNI_TRUE;

   196 }

   197 

   198 /*

   199  * Class:     java_lang_ProcessHandleImpl

   200  * Method:    destroy0

   201  * Signature: (Z)Z

   202  */

   203 JNIEXPORT jboolean JNICALL Java_java_lang_ProcessHandleImpl_destroy0

   204 (JNIEnv *env, jobject obj, jlong jpid, jboolean force) {

   205     pid_t pid = (pid_t) jpid;

   206     int sig = (force == JNI_TRUE) ? SIGKILL : SIGTERM;

   207     return (kill(pid, sig) >= 0);

   208 

   209 }

   210 

   211 /**

   212  * Size of password or group entry when not available via sysconf

   213  */

   214 #define ENT_BUF_SIZE   1024

   215 

   216 /**

   217  * Return a strong username for the uid_t or null.

   218  */

   219 jstring uidToUser(JNIEnv* env, uid_t uid) {

   220     int result = 0;

   221     int buflen;

   222     char* pwbuf;

   223     jstring name = NULL;

   224 

   225     /* allocate buffer for password record */

   226     buflen = (int)sysconf(_SC_GETPW_R_SIZE_MAX);

   227     if (buflen == -1)

   228         buflen = ENT_BUF_SIZE;

   229     pwbuf = (char*)malloc(buflen);

   230     if (pwbuf == NULL) {

   231         JNU_ThrowOutOfMemoryError(env, "Unable to open getpwent");

   232     } else {

   233         struct passwd pwent;

   234         struct passwd* p = NULL;

   235 

   236 #ifdef __solaris__

   237         RESTARTABLE_RETURN_PTR(getpwuid_r(uid, &pwent, pwbuf, (size_t)buflen), p);

   238 #else

   239         RESTARTABLE(getpwuid_r(uid, &pwent, pwbuf, (size_t)buflen, &p), result);

   240 #endif

   241 

   242         // Return the Java String if a name was found

   243         if (result == 0 && p != NULL &&

   244             p->pw_name != NULL && *(p->pw_name) != '\0') {

   245             name = JNU_NewStringPlatform(env, p->pw_name);

   246         }

   247         free(pwbuf);

   248     }

   249     return name;

   250 }

   251 

   252 /**

   253  * Implementations of ProcessHandleImpl functions that are common to

   254  * (some) Unix variants:

   255  * - getProcessPids0(pid, pidArray, parentArray)

   256  */

   257 

   258 #if defined(__linux__) || defined(__AIX__)

   259 

   260 /*

   261  * Signatures for internal OS specific functions.

   262  */

   263 static pid_t parentPid(JNIEnv *env, pid_t pid);

   264 static jint getChildren(JNIEnv *env, jlong jpid,

   265                         jlongArray array, jlongArray jparentArray);

   266 

   267 static void getStatInfo(JNIEnv *env, jobject jinfo, pid_t pid);

   268 static void getCmdlineInfo(JNIEnv *env, pid_t pid, jobject jinfo);

   269 static long long getBoottime(JNIEnv *env);

   270 

   271 jstring uidToUser(JNIEnv* env, uid_t uid);

   272 

   273 /* Field id for jString 'command' in java.lang.ProcessHandleImpl.Info */

   274 static jfieldID ProcessHandleImpl_Info_commandID;

   275 

   276 /* Field id for jString[] 'arguments' in java.lang.ProcessHandleImpl.Info */

   277 static jfieldID ProcessHandleImpl_Info_argumentsID;

   278 

   279 /* Field id for jlong 'totalTime' in java.lang.ProcessHandleImpl.Info */

   280 static jfieldID ProcessHandleImpl_Info_totalTimeID;

   281 

   282 /* Field id for jlong 'startTime' in java.lang.ProcessHandleImpl.Info */

   283 static jfieldID ProcessHandleImpl_Info_startTimeID;

   284 

   285 /* Field id for jString 'user' in java.lang.ProcessHandleImpl.Info */

   286 static jfieldID ProcessHandleImpl_Info_userID;

   287 

   288 /* static value for clock ticks per second. */

   289 static long clock_ticks_per_second;

   290 

   291 /* A static offset in milliseconds since boot. */

   292 static long long bootTime_ms;

   293 

   294 /**************************************************************

   295  * Static method to initialize field IDs and the ticks per second rate.

   296  *

   297  * Class:     java_lang_ProcessHandleImpl_Info

   298  * Method:    initIDs

   299  * Signature: ()V

   300  */

   301 JNIEXPORT void JNICALL Java_java_lang_ProcessHandleImpl_00024Info_initIDs

   302   (JNIEnv *env, jclass clazz) {

   303 

   304     CHECK_NULL(ProcessHandleImpl_Info_commandID = (*env)->GetFieldID(env,

   305         clazz, "command", "Ljava/lang/String;"));

   306     CHECK_NULL(ProcessHandleImpl_Info_argumentsID = (*env)->GetFieldID(env,

   307         clazz, "arguments", "[Ljava/lang/String;"));

   308     CHECK_NULL(ProcessHandleImpl_Info_totalTimeID = (*env)->GetFieldID(env,

   309         clazz, "totalTime", "J"));

   310     CHECK_NULL(ProcessHandleImpl_Info_startTimeID = (*env)->GetFieldID(env,

   311         clazz, "startTime", "J"));

   312     CHECK_NULL(ProcessHandleImpl_Info_userID = (*env)->GetFieldID(env,

   313         clazz, "user", "Ljava/lang/String;"));

   314     clock_ticks_per_second = sysconf(_SC_CLK_TCK);

   315     bootTime_ms = getBoottime(env);

   316 }

   317 

   318 /*

   319  * Returns the parent pid of the requested pid.

   320  *

   321  * Class:     java_lang_ProcessHandleImpl

   322  * Method:    parent0

   323  * Signature: (J)J

   324  */

   325 JNIEXPORT jlong JNICALL Java_java_lang_ProcessHandleImpl_parent0

   326 (JNIEnv *env, jobject obj, jlong jpid) {

   327     pid_t pid = (pid_t) jpid;

   328     pid_t ppid = -1;

   329 

   330     pid_t mypid = getpid();

   331     if (pid == mypid) {

   332         ppid = getppid();

   333     } else {

   334         ppid = parentPid(env, pid);

   335     }

   336     return (jlong) ppid;

   337 }

   338 

   339 /*

   340  * Returns the children of the requested pid and optionally each parent.

   341  *

   342  * Class:     java_lang_ProcessHandleImpl

   343  * Method:    getChildPids

   344  * Signature: (J[J[J)I

   345  */

   346 JNIEXPORT jint JNICALL Java_java_lang_ProcessHandleImpl_getProcessPids0

   347 (JNIEnv *env, jclass clazz, jlong jpid,

   348     jlongArray jarray, jlongArray jparentArray) {

   349     return getChildren(env, jpid, jarray, jparentArray);

   350 }

   351 

   352 /*

   353  * Reads /proc and accumulates any process who parent pid matches.

   354  * The resulting pids are stored into the array of longs.

   355  * The number of pids is returned if they all fit.

   356  * If the array is too short, the negative of the desired length is returned.

   357  */

   358 static jint getChildren(JNIEnv *env, jlong jpid,

   359     jlongArray jarray, jlongArray jparentArray) {

   360     DIR* dir;

   361     struct dirent* ptr;

   362     pid_t pid = (pid_t) jpid;

   363     pid_t ppid = 0;

   364     size_t count = 0;

   365     jlong* pids = NULL;

   366     jlong* ppids = NULL;

   367     size_t parentArraySize = 0;

   368     size_t arraySize = 0;

   369 

   370     arraySize = (*env)->GetArrayLength(env, jarray);

   371     JNU_CHECK_EXCEPTION_RETURN(env, -1);

   372     if (jparentArray != NULL) {

   373         parentArraySize = (*env)->GetArrayLength(env, jparentArray);

   374         JNU_CHECK_EXCEPTION_RETURN(env, -1);

   375 

   376         if (arraySize != parentArraySize) {

   377             JNU_ThrowIllegalArgumentException(env, "array sizes not equal");

   378             return 0;

   379         }

   380     }

   381 

   382     /*

   383      * To locate the children we scan /proc looking for files that have a

   384      * position integer as a filename.

   385      */

   386     if ((dir = opendir("/proc")) == NULL) {

   387         JNU_ThrowByNameWithLastError(env,

   388             "java/lang/Runtime", "Unable to open /proc");

   389         return -1;

   390     }

   391 

   392     do { // Block to break out of on Exception

   393         pids = (*env)->GetLongArrayElements(env, jarray, NULL);

   394         if (pids == NULL) {

   395             break;

   396         }

   397         if (jparentArray != NULL) {

   398             ppids  = (*env)->GetLongArrayElements(env, jparentArray, NULL);

   399             if (ppids == NULL) {

   400                 break;

   401             }

   402         }

   403 

   404         while ((ptr = readdir(dir)) != NULL) {

   405             /* skip files that aren't numbers */

   406             pid_t childpid = (pid_t) atoi(ptr->d_name);

   407             if ((int) childpid <= 0) {

   408                 continue;

   409             }

   410 

   411             ppid = 0;

   412             if (pid != 0 || jparentArray != NULL) {

   413                 // parentPid opens and reads /proc/pid/stat

   414                 ppid = parentPid(env, childpid);

   415             }

   416             if (pid == 0 || ppid == pid) {

   417                 if (count < arraySize) {

   418                     // Only store if it fits

   419                     pids[count] = (jlong) childpid;

   420 

   421                     if (ppids != NULL) {

   422                         // Store the parentPid

   423                         ppids[count] = (jlong) ppid;

   424                     }

   425                 }

   426                 count++; // Count to tabulate size needed

   427             }

   428         }

   429     } while (0);

   430 

   431     if (pids != NULL) {

   432         (*env)->ReleaseLongArrayElements(env, jarray, pids, 0);

   433     }

   434     if (ppids != NULL) {

   435         (*env)->ReleaseLongArrayElements(env, jparentArray, ppids, 0);

   436     }

   437 

   438     closedir(dir);

   439     // If more pids than array had size for; count will be greater than array size

   440     return count;

   441 }

   442 

   443 /*

   444  * Returns the parent pid of a given pid, or -1 if not found

   445  */

   446 static pid_t parentPid(JNIEnv *env, pid_t pid) {

   447     char state;

   448     FILE* fp;

   449     char stat[2048];

   450     int statlen;

   451     char fn[32];

   452     int i, p;

   453     char* s;

   454 

   455     /*

   456      * try to open /proc/%d/stat

   457      */

   458     snprintf(fn, sizeof fn, "/proc/%d/stat", pid);

   459     fp = fopen(fn, "r");

   460     if (fp == NULL) {

   461         return -1;

   462     }

   463 

   464     /*

   465      * The format is: pid (command) state ppid ...

   466      * As the command could be anything we must find the right most

   467      * ")" and then skip the white spaces that follow it.

   468      */

   469     statlen = fread(stat, 1, (sizeof stat - 1), fp);

   470     fclose(fp);

   471     if (statlen < 0) {

   472         return -1;

   473     }

   474 

   475     stat[statlen] = '\0';

   476     s = strrchr(stat, ')');

   477     if (s == NULL) {

   478         return -1;

   479     }

   480     do s++; while (isspace(*s));

   481     i = sscanf(s, "%c %d", &state, &p);

   482     if (i != 2) {

   483         return (pid_t)-1;

   484     }

   485     return (pid_t) p;

   486 }

   487 

   488 /**************************************************************

   489  * Implementation of ProcessHandleImpl_Info native methods.

   490  */

   491 

   492 /*

   493  * Fill in the Info object from the OS information about the process.

   494  *

   495  * Class:     java_lang_ProcessHandleImpl_Info

   496  * Method:    info0

   497  * Signature: (JLjava/lang/ProcessHandle/Info;)I

   498  */

   499 JNIEXPORT void JNICALL Java_java_lang_ProcessHandleImpl_00024Info_info0

   500   (JNIEnv *env, jobject jinfo, jlong jpid) {

   501     pid_t pid = (pid_t) jpid;

   502     getStatInfo(env, jinfo, (pid_t)pid);

   503     getCmdlineInfo(env, pid, jinfo);

   504 }

   505 

   506 /**

   507  * Read /proc/<pid>/stat and fill in the fields of the Info object.

   508  * The executable name, plus the user, system, and start times are gathered.

   509  */

   510 static void getStatInfo(JNIEnv *env, jobject jinfo, pid_t pid) {

   511     char state;

   512     FILE* fp;

   513     char buffer[2048];

   514     struct stat stat_buf;

   515     int statlen;

   516     char fn[32];

   517     int i, ppid = -2;

   518     char* s;

   519     char *cmd;

   520     jstring name = NULL;

   521     unsigned long userTime = 0;             // clock tics

   522     unsigned long totalTime = 0;            // clock tics

   523     jlong total = 0;                        // nano seconds

   524     unsigned long long startTime = 0;       // microseconds

   525 

   526     /*

   527      * Try to stat and then open /proc/%d/stat

   528      */

   529     snprintf(fn, sizeof fn, "/proc/%d/stat", pid);

   530 

   531     if (stat(fn, &stat_buf) < 0) {

   532         return;

   533     }

   534 

   535     CHECK_NULL((name = uidToUser(env, stat_buf.st_uid)));

   536     (*env)->SetObjectField(env, jinfo, ProcessHandleImpl_Info_userID, name);

   537     JNU_CHECK_EXCEPTION(env);

   538 

   539     fp = fopen(fn, "r");

   540     if (fp == NULL) {

   541         return;

   542     }

   543 

   544     /*

   545      * The format is: pid (command) state ppid ...

   546      * As the command could be anything we must find the right most

   547      * ")" and then skip the white spaces that follow it.

   548      */

   549     statlen = fread(buffer, 1, (sizeof buffer - 1), fp);

   550     fclose(fp);

   551     if (statlen < 0) {

   552         return;

   553     }

   554 

   555     buffer[statlen] = '\0';

   556     s = strchr(buffer, '(');

   557     if (s == NULL) {

   558         return;

   559     }

   560     // Found start of command, skip to end

   561     s++;

   562     s = strrchr(s, ')');

   563     if (s == NULL) {

   564         return;

   565     }

   566     s++;

   567 

   568     // Scan the needed fields from status, retaining only ppid(4),

   569     // utime (14), stime(15), starttime(22)

   570     i = sscanf(s, " %c %d %*d %*d %*d %*d %*d %*u %*u %*u %*u %lu %lu %*d %*d %*d %*d %*d %*d %llu",

   571             &state, &ppid, &userTime, &totalTime, &startTime);

   572     if (i != 5) {

   573         return;              // not all values parsed; return error

   574     }

   575 

   576     total = (userTime + totalTime) * (jlong)(1000000000 / clock_ticks_per_second);

   577 

   578     startTime = bootTime_ms + ((startTime * 1000) / clock_ticks_per_second);

   579 

   580     (*env)->SetLongField(env, jinfo, ProcessHandleImpl_Info_totalTimeID, total);

   581     JNU_CHECK_EXCEPTION(env);

   582     (*env)->SetLongField(env, jinfo, ProcessHandleImpl_Info_startTimeID, startTime);

   583     JNU_CHECK_EXCEPTION(env);

   584 }

   585 

   586 /**

   587  * Construct the argument array by parsing the arguments from the sequence

   588  * of arguments. The zero'th arg is the command executable

   589  */

   590 static int fillArgArray(JNIEnv *env, jobject jinfo,

   591                         int nargs, char *cp, char *argsEnd, jstring cmdexe) {

   592     jobject argsArray;

   593     int i;

   594 

   595     if (nargs < 1) {

   596         return 0;

   597     }

   598 

   599     if (cmdexe == NULL) {

   600         // Create a string from arg[0]

   601         CHECK_NULL_RETURN((cmdexe = JNU_NewStringPlatform(env, cp)), -1);

   602     }

   603     (*env)->SetObjectField(env, jinfo, ProcessHandleImpl_Info_commandID, cmdexe);

   604     JNU_CHECK_EXCEPTION_RETURN(env, -3);

   605 

   606     // Create a String array for nargs-1 elements

   607     argsArray = (*env)->NewObjectArray(env, nargs - 1, JNU_ClassString(env), NULL);

   608     CHECK_NULL_RETURN(argsArray, -1);

   609 

   610     for (i = 0; i < nargs - 1; i++) {

   611         jstring str = NULL;

   612 

   613         cp += strnlen(cp, (argsEnd - cp)) + 1;

   614         if (cp > argsEnd || *cp == '\0') {

   615             return -2;  // Off the end pointer or an empty argument is an error

   616         }

   617 

   618         CHECK_NULL_RETURN((str = JNU_NewStringPlatform(env, cp)), -1);

   619 

   620         (*env)->SetObjectArrayElement(env, argsArray, i, str);

   621         JNU_CHECK_EXCEPTION_RETURN(env, -3);

   622     }

   623     (*env)->SetObjectField(env, jinfo, ProcessHandleImpl_Info_argumentsID, argsArray);

   624     JNU_CHECK_EXCEPTION_RETURN(env, -4);

   625     return 0;

   626 }

   627 

   628 

   629 static void getCmdlineInfo(JNIEnv *env, pid_t pid, jobject jinfo) {

   630     int fd;

   631     int cmdlen = 0;

   632     char *cmdline = NULL, *cmdEnd;  // used for command line args and exe

   633     jstring cmdexe = NULL;

   634     char fn[32];

   635 

   636     /*

   637      * Try to open /proc/%d/cmdline

   638      */

   639     snprintf(fn, sizeof fn, "/proc/%d/cmdline", pid);

   640     if ((fd = open(fn, O_RDONLY)) < 0) {

   641         return;

   642     }

   643 

   644     do {                // Block to break out of on errors

   645         int i;

   646         char *s;

   647 

   648         cmdline = (char*)malloc(PATH_MAX);

   649         if (cmdline == NULL) {

   650             break;

   651         }

   652 

   653         /*

   654          * The path to the executable command is the link in /proc/<pid>/exe.

   655          */

   656         snprintf(fn, sizeof fn, "/proc/%d/exe", pid);

   657         if ((cmdlen = readlink(fn, cmdline, PATH_MAX - 1)) > 0) {

   658             // null terminate and create String to store for command

   659             cmdline[cmdlen] = '\0';

   660             cmdexe = JNU_NewStringPlatform(env, cmdline);

   661             (*env)->ExceptionClear(env);        // unconditionally clear any exception

   662         }

   663 

   664         /*

   665          * The buffer format is the arguments nul terminated with an extra nul.

   666          */

   667         cmdlen = read(fd, cmdline, PATH_MAX-1);

   668         if (cmdlen < 0) {

   669             break;

   670         }

   671 

   672         // Terminate the buffer and count the arguments

   673         cmdline[cmdlen] = '\0';

   674         cmdEnd = &cmdline[cmdlen + 1];

   675         for (s = cmdline,i = 0; *s != '\0' && (s < cmdEnd); i++) {

   676             s += strnlen(s, (cmdEnd - s)) + 1;

   677         }

   678 

   679         if (fillArgArray(env, jinfo, i, cmdline, cmdEnd, cmdexe) < 0) {

   680             break;

   681         }

   682     } while (0);

   683 

   684     if (cmdline != NULL) {

   685         free(cmdline);

   686     }

   687     if (fd >= 0) {

   688         close(fd);

   689     }

   690 }

   691 

   692 /**

   693  * Read the boottime from /proc/stat.

   694  */

   695 static long long getBoottime(JNIEnv *env) {

   696     FILE *fp;

   697     char *line = NULL;

   698     size_t len = 0;

   699     long long bootTime = 0;

   700 

   701     fp = fopen("/proc/stat", "r");

   702     if (fp == NULL) {

   703         return -1;

   704     }

   705 

   706     while (getline(&line, &len, fp) != -1) {

   707         if (sscanf(line, "btime %llu", &bootTime) == 1) {

   708             break;

   709         }

   710     }

   711     free(line);

   712 

   713     if (fp != 0) {

   714         fclose(fp);

   715     }

   716 

   717     return bootTime * 1000;

   718 }

   719 

   720 #endif  //  defined(__linux__) || defined(__AIX__)

   721 

   722 

   723 /* Block until a child process exits and return its exit code.

   724    Note, can only be called once for any given pid. */

   725 JNIEXPORT jint JNICALL

   726 Java_java_lang_ProcessImpl_waitForProcessExit(JNIEnv* env,

   727                                               jobject junk,

   728                                               jint pid)

   729 {

   730     /* We used to use waitid() on Solaris, waitpid() on Linux, but

   731      * waitpid() is more standard, so use it on all POSIX platforms. */

   732     int status;

   733     /* Wait for the child process to exit.  This returns immediately if

   734        the child has already exited. */

   735     while (waitpid(pid, &status, 0) < 0) {

   736         switch (errno) {

   737         case ECHILD: return 0;

   738         case EINTR: break;

   739         default: return -1;

   740         }

   741     }

   742 

   743     if (WIFEXITED(status)) {

   744         /*

   745          * The child exited normally; get its exit code.

   746          */

   747         return WEXITSTATUS(status);

   748     } else if (WIFSIGNALED(status)) {

   749         /* The child exited because of a signal.

   750          * The best value to return is 0x80 + signal number,

   751          * because that is what all Unix shells do, and because

   752          * it allows callers to distinguish between process exit and

   753          * process death by signal.

   754          * Unfortunately, the historical behavior on Solaris is to return

   755          * the signal number, and we preserve this for compatibility. */

   756 #ifdef __solaris__

   757         return WTERMSIG(status);

   758 #else

   759         return 0x80 + WTERMSIG(status);

   760 #endif

   761     } else {

   762         /*

   763          * Unknown exit code; pass it through.

   764          */

   765         return status;

   766     }

   767 }

   768 

   769