1 /*
   2  * Copyright (c) 2014, 2017, 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 #include "ProcessHandleImpl_unix.h"
  32 
  33 
  34 #include <stdio.h>
  35 #include <errno.h>
  36 #include <fcntl.h>
  37 #include <signal.h>
  38 #include <stdlib.h>
  39 #include <unistd.h>
  40 #include <string.h>
  41 #include <dirent.h>
  42 #include <ctype.h>
  43 #include <limits.h>
  44 #include <sys/types.h>
  45 #include <sys/stat.h>
  46 #include <sys/wait.h>
  47 
  48 /* For POSIX-compliant getpwuid_r on Solaris */
  49 #if defined(__solaris__)
  50 #define _POSIX_PTHREAD_SEMANTICS
  51 #endif
  52 #include <pwd.h>
  53 
  54 #ifdef _AIX
  55 #include <sys/procfs.h>
  56 #endif
  57 #ifdef __solaris__
  58 #include <procfs.h>
  59 #endif
  60 
  61 /**
  62  * This file contains the implementation of the native ProcessHandleImpl
  63  * functions which are common to all Unix variants.
  64  *
  65  * The currently supported Unix variants are Solaris, Linux, MaxOS X and AIX.
  66  * The various similarities and differences between these systems make it hard
  67  * to find a clear boundary between platform specific and shared code.
  68  *
  69  * In order to ease code sharing between the platforms while still keeping the
  70  * code as clean as possible (i.e. free of preprocessor macros) we use the
  71  * following source code layout (remember that ProcessHandleImpl_unix.c will
  72  * be compiled on EVERY Unix platform while ProcessHandleImpl_<os>.c will be
  73  * only compiled on the specific OS):
  74  *
  75  * - all the JNI wrappers for the ProcessHandleImpl functions go into this file
  76  * - if their implementation is common on ALL the supported Unix platforms it
  77  *   goes right into the JNI wrappers
  78  * - if the whole function or substantial parts of it are platform dependent,
  79  *   the implementation goes into os_<function_name> functions in
  80  *   ProcessHandleImpl_<os>.c
  81  * - if at least two platforms implement an os_<function_name> function in the
  82  *   same way, this implementation is factored out into unix_<function_name>,
  83  *   placed into this file and called from the corresponding os_<function_name>
  84  *   function.
  85  * - For convenience, all the os_ and unix_ functions are declared in
  86  *   ProcessHandleImpl_unix.h which is included into every
  87  *   ProcessHandleImpl_<os>.c file.
  88  *
  89  * Example 1:
  90  * ----------
  91  * The implementation of Java_java_lang_ProcessHandleImpl_initNative()
  92  * is the same on all platforms except on Linux where it initilizes one
  93  * additional field. So we place the implementation right into
  94  * Java_java_lang_ProcessHandleImpl_initNative() but add call to
  95  * os_init() at the end of the function which is empty on all platforms
  96  * except Linux where it performs the additionally initializations.
  97  *
  98  * Example 2:
  99  * ----------
 100  * The implementation of Java_java_lang_ProcessHandleImpl_00024Info_info0 is the
 101  * same on Solaris and AIX but different on Linux and MacOSX. We therefore simply
 102  * call the helpers os_getParentPidAndTimings() and os_getCmdlineAndUserInfo().
 103  * The Linux and MaxOS X versions of these functions (in the corresponding files
 104  * ProcessHandleImpl_linux.c and ProcessHandleImpl_macosx.c) directly contain
 105  * the platform specific implementations while the Solaris and AIX
 106  * implementations simply call back to unix_getParentPidAndTimings() and
 107  * unix_getCmdlineAndUserInfo() which are implemented right in this file.
 108  *
 109  * The term "same implementation" is still a question of interpretation. It my
 110  * be acceptable to have a few ifdef'ed lines if that allows the sharing of a
 111  * huge function. On the other hand, if the platform specific code in a shared
 112  * function grows over a certain limit, it may be better to refactor that
 113  * functionality into corresponding, platform-specific os_ functions.
 114  */
 115 
 116 
 117 #ifndef WIFEXITED
 118 #define WIFEXITED(status) (((status)&0xFF) == 0)
 119 #endif
 120 
 121 #ifndef WEXITSTATUS
 122 #define WEXITSTATUS(status) (((status)>>8)&0xFF)
 123 #endif
 124 
 125 #ifndef WIFSIGNALED
 126 #define WIFSIGNALED(status) (((status)&0xFF) > 0 && ((status)&0xFF00) == 0)
 127 #endif
 128 
 129 #ifndef WTERMSIG
 130 #define WTERMSIG(status) ((status)&0x7F)
 131 #endif
 132 
 133 #ifdef __solaris__
 134 /* The child exited because of a signal.
 135  * The best value to return is 0x80 + signal number,
 136  * because that is what all Unix shells do, and because
 137  * it allows callers to distinguish between process exit and
 138  * process death by signal.
 139  * Unfortunately, the historical behavior on Solaris is to return
 140  * the signal number, and we preserve this for compatibility. */
 141 #define WTERMSIG_RETURN(status) WTERMSIG(status)
 142 #else
 143 #define WTERMSIG_RETURN(status) (WTERMSIG(status) + 0x80)
 144 #endif
 145 
 146 #define RESTARTABLE(_cmd, _result) do { \
 147   do { \
 148     _result = _cmd; \
 149   } while((_result == -1) && (errno == EINTR)); \
 150 } while(0)
 151 
 152 #define RESTARTABLE_RETURN_PTR(_cmd, _result) do { \
 153   do { \
 154     _result = _cmd; \
 155   } while((_result == NULL) && (errno == EINTR)); \
 156 } while(0)
 157 
 158 
 159 /* Field id for jString 'command' in java.lang.ProcessHandleImpl.Info */
 160 jfieldID ProcessHandleImpl_Info_commandID;
 161 
 162 /* Field id for jString 'commandLine' in java.lang.ProcessHandleImpl.Info */
 163 jfieldID ProcessHandleImpl_Info_commandLineID;
 164 
 165 /* Field id for jString[] 'arguments' in java.lang.ProcessHandleImpl.Info */
 166 jfieldID ProcessHandleImpl_Info_argumentsID;
 167 
 168 /* Field id for jlong 'totalTime' in java.lang.ProcessHandleImpl.Info */
 169 jfieldID ProcessHandleImpl_Info_totalTimeID;
 170 
 171 /* Field id for jlong 'startTime' in java.lang.ProcessHandleImpl.Info */
 172 jfieldID ProcessHandleImpl_Info_startTimeID;
 173 
 174 /* Field id for jString 'user' in java.lang.ProcessHandleImpl.Info */
 175 jfieldID ProcessHandleImpl_Info_userID;
 176 
 177 /* Size of password or group entry when not available via sysconf */
 178 #define ENT_BUF_SIZE   1024
 179 /* The value for the size of the buffer used by getpwuid_r(). The result of */
 180 /* sysconf(_SC_GETPW_R_SIZE_MAX) if available or ENT_BUF_SIZE otherwise. */
 181 static long getpw_buf_size;
 182 
 183 /**************************************************************
 184  * Static method to initialize field IDs and the ticks per second rate.
 185  *
 186  * Class:     java_lang_ProcessHandleImpl_Info
 187  * Method:    initIDs
 188  * Signature: ()V
 189  */
 190 JNIEXPORT void JNICALL
 191 Java_java_lang_ProcessHandleImpl_00024Info_initIDs(JNIEnv *env, jclass clazz) {
 192 
 193     CHECK_NULL(ProcessHandleImpl_Info_commandID =
 194             (*env)->GetFieldID(env, clazz, "command", "Ljava/lang/String;"));
 195     CHECK_NULL(ProcessHandleImpl_Info_commandLineID =
 196             (*env)->GetFieldID(env, clazz, "commandLine", "Ljava/lang/String;"));
 197     CHECK_NULL(ProcessHandleImpl_Info_argumentsID =
 198             (*env)->GetFieldID(env, clazz, "arguments", "[Ljava/lang/String;"));
 199     CHECK_NULL(ProcessHandleImpl_Info_totalTimeID =
 200             (*env)->GetFieldID(env, clazz, "totalTime", "J"));
 201     CHECK_NULL(ProcessHandleImpl_Info_startTimeID =
 202             (*env)->GetFieldID(env, clazz, "startTime", "J"));
 203     CHECK_NULL(ProcessHandleImpl_Info_userID =
 204             (*env)->GetFieldID(env, clazz, "user", "Ljava/lang/String;"));
 205 }
 206 
 207 /***********************************************************
 208  * Static method to initialize platform dependent constants.
 209  *
 210  * Class:     java_lang_ProcessHandleImpl
 211  * Method:    initNative
 212  * Signature: ()V
 213  */
 214 JNIEXPORT void JNICALL
 215 Java_java_lang_ProcessHandleImpl_initNative(JNIEnv *env, jclass clazz) {
 216     getpw_buf_size = sysconf(_SC_GETPW_R_SIZE_MAX);
 217     if (getpw_buf_size == -1) {
 218         getpw_buf_size = ENT_BUF_SIZE;
 219     }
 220     os_initNative(env, clazz);
 221 }
 222 
 223 /* Block until a child process exits and return its exit code.
 224  * Note, can only be called once for any given pid if reapStatus = true.
 225  *
 226  * Class:     java_lang_ProcessHandleImpl
 227  * Method:    waitForProcessExit0
 228  * Signature: (JZ)I
 229  */
 230 JNIEXPORT jint JNICALL
 231 Java_java_lang_ProcessHandleImpl_waitForProcessExit0(JNIEnv* env,
 232                                                      jclass junk,
 233                                                      jlong jpid,
 234                                                      jboolean reapStatus) {
 235     pid_t pid = (pid_t)jpid;
 236     errno = 0;
 237 
 238     if (reapStatus != JNI_FALSE) {
 239         /* Wait for the child process to exit.
 240          * waitpid() is standard, so use it on all POSIX platforms.
 241          * It is known to work when blocking to wait for the pid
 242          * This returns immediately if the child has already exited.
 243          */
 244         int status;
 245         while (waitpid(pid, &status, 0) < 0) {
 246             switch (errno) {
 247                 case ECHILD:
 248                     return java_lang_ProcessHandleImpl_NOT_A_CHILD; // No child
 249                 case EINTR: break;
 250                 default: return -1;
 251             }
 252         }
 253 
 254         if (WIFEXITED(status)) {
 255             return WEXITSTATUS(status);
 256         } else if (WIFSIGNALED(status)) {
 257             return WTERMSIG_RETURN(status);
 258         } else {
 259             return status;
 260         }
 261      } else {
 262         /*
 263          * Wait for the child process to exit without reaping the exitValue.
 264          * waitid() is standard on all POSIX platforms.
 265          * Note: waitid on Mac OS X 10.7 seems to be broken;
 266          * it does not return the exit status consistently.
 267          */
 268         siginfo_t siginfo;
 269         int options = WEXITED |  WNOWAIT;
 270         memset(&siginfo, 0, sizeof siginfo);
 271         while (waitid(P_PID, pid, &siginfo, options) < 0) {
 272             switch (errno) {
 273                 case ECHILD:
 274                     return java_lang_ProcessHandleImpl_NOT_A_CHILD; // No child
 275                 case EINTR: break;
 276                 default: return -1;
 277             }
 278         }
 279 
 280         if (siginfo.si_code == CLD_EXITED) {
 281              /*
 282               * The child exited normally; get its exit code.
 283               */
 284              return siginfo.si_status;
 285         } else if (siginfo.si_code == CLD_KILLED || siginfo.si_code == CLD_DUMPED) {
 286              return WTERMSIG_RETURN(siginfo.si_status);
 287         } else {
 288              /*
 289               * Unknown exit code; pass it through.
 290               */
 291              return siginfo.si_status;
 292         }
 293     }
 294 }
 295 
 296 /*
 297  * Class:     java_lang_ProcessHandleImpl
 298  * Method:    getCurrentPid0
 299  * Signature: ()J
 300  */
 301 JNIEXPORT jlong JNICALL
 302 Java_java_lang_ProcessHandleImpl_getCurrentPid0(JNIEnv *env, jclass clazz) {
 303     pid_t pid = getpid();
 304     return (jlong) pid;
 305 }
 306 
 307 /*
 308  * Class:     java_lang_ProcessHandleImpl
 309  * Method:    destroy0
 310  * Signature: (JJZ)Z
 311  */
 312 JNIEXPORT jboolean JNICALL
 313 Java_java_lang_ProcessHandleImpl_destroy0(JNIEnv *env,
 314                                           jobject obj,
 315                                           jlong jpid,
 316                                           jlong startTime,
 317                                           jboolean force) {
 318     pid_t pid = (pid_t) jpid;
 319     int sig = (force == JNI_TRUE) ? SIGKILL : SIGTERM;
 320     jlong start = Java_java_lang_ProcessHandleImpl_isAlive0(env, obj, jpid);
 321 
 322     if (start == startTime || start == 0 || startTime == 0) {
 323         return (kill(pid, sig) < 0) ? JNI_FALSE : JNI_TRUE;
 324     } else {
 325         return JNI_FALSE;
 326     }
 327 }
 328 
 329 /*
 330  * Returns the children of the requested pid and optionally each parent and
 331  * start time.
 332  * Accumulates any process who parent pid matches.
 333  * The resulting pids are stored into the array of longs.
 334  * The number of pids is returned if they all fit.
 335  * If the array is too short, the negative of the desired length is returned.
 336  * Class:     java_lang_ProcessHandleImpl
 337  * Method:    getProcessPids0
 338  * Signature: (J[J[J[J)I
 339  */
 340 JNIEXPORT jint JNICALL
 341 Java_java_lang_ProcessHandleImpl_getProcessPids0(JNIEnv *env,
 342                                                  jclass clazz,
 343                                                  jlong jpid,
 344                                                  jlongArray jarray,
 345                                                  jlongArray jparentArray,
 346                                                  jlongArray jstimesArray) {
 347     return os_getChildren(env, jpid, jarray, jparentArray, jstimesArray);
 348 }
 349 
 350 /*
 351  * Fill in the Info object from the OS information about the process.
 352  *
 353  * Class:     java_lang_ProcessHandleImpl_Info
 354  * Method:    info0
 355  * Signature: (Ljava/lang/ProcessHandle/Info;J)I
 356  */
 357 JNIEXPORT void JNICALL
 358 Java_java_lang_ProcessHandleImpl_00024Info_info0(JNIEnv *env,
 359                                                  jobject jinfo,
 360                                                  jlong jpid) {
 361     pid_t pid = (pid_t) jpid;
 362     pid_t ppid;
 363     jlong totalTime = -1L;
 364     jlong startTime = -1L;
 365 
 366     ppid = os_getParentPidAndTimings(env, pid,  &totalTime, &startTime);
 367     if (ppid >= 0) {
 368         (*env)->SetLongField(env, jinfo, ProcessHandleImpl_Info_totalTimeID, totalTime);
 369         JNU_CHECK_EXCEPTION(env);
 370 
 371         (*env)->SetLongField(env, jinfo, ProcessHandleImpl_Info_startTimeID, startTime);
 372         JNU_CHECK_EXCEPTION(env);
 373     }
 374     os_getCmdlineAndUserInfo(env, jinfo, pid);
 375 }
 376 
 377 /*
 378  * Check if a process is alive.
 379  * Return the start time (ms since 1970) if it is available.
 380  * If the start time is not available return 0.
 381  * If the pid is invalid, return -1.
 382  *
 383  * Class:     java_lang_ProcessHandleImpl
 384  * Method:    isAlive0
 385  * Signature: (J)J
 386  */
 387 JNIEXPORT jlong JNICALL
 388 Java_java_lang_ProcessHandleImpl_isAlive0(JNIEnv *env, jobject obj, jlong jpid) {
 389     pid_t pid = (pid_t) jpid;
 390     jlong startTime = 0L;
 391     jlong totalTime = 0L;
 392     pid_t ppid = os_getParentPidAndTimings(env, pid, &totalTime, &startTime);
 393     return (ppid < 0) ? -1 : startTime;
 394 }
 395 
 396 /*
 397  * Returns the parent pid of the requested pid.
 398  * The start time of the process must match (or be ANY).
 399  *
 400  * Class:     java_lang_ProcessHandleImpl
 401  * Method:    parent0
 402  * Signature: (JJ)J
 403  */
 404 JNIEXPORT jlong JNICALL
 405 Java_java_lang_ProcessHandleImpl_parent0(JNIEnv *env,
 406                                         jobject obj,
 407                                         jlong jpid,
 408                                         jlong startTime) {
 409     pid_t pid = (pid_t) jpid;
 410     pid_t ppid;
 411 
 412     if (pid == getpid()) {
 413         ppid = getppid();
 414     } else {
 415         jlong start = 0L;
 416         jlong total = 0L;        // unused
 417         ppid = os_getParentPidAndTimings(env, pid, &total, &start);
 418         if (start != startTime && start != 0 && startTime != 0) {
 419             ppid = -1;
 420         }
 421     }
 422     return (jlong) ppid;
 423 }
 424 
 425 /**
 426  * Construct the argument array by parsing the arguments from the sequence
 427  * of arguments.
 428  */
 429 void unix_fillArgArray(JNIEnv *env, jobject jinfo, int nargs, char *cp,
 430                        char *argsEnd, jstring cmdexe, char *cmdline) {
 431     jobject argsArray;
 432     int i;
 433 
 434     (*env)->SetObjectField(env, jinfo, ProcessHandleImpl_Info_commandID, cmdexe);
 435     JNU_CHECK_EXCEPTION(env);
 436 
 437     if (nargs >= 1) {
 438         // Create a String array for nargs-1 elements
 439         jclass clazzString = JNU_ClassString(env);
 440         CHECK_NULL(clazzString);
 441         argsArray = (*env)->NewObjectArray(env, nargs - 1, clazzString, NULL);
 442         CHECK_NULL(argsArray);
 443 
 444         for (i = 0; i < nargs - 1; i++) {
 445             jstring str = NULL;
 446 
 447             cp += strlen(cp) + 1;
 448             if (cp > argsEnd || *cp == '\0') {
 449                 return;  // Off the end pointer or an empty argument is an error
 450             }
 451 
 452             CHECK_NULL((str = JNU_NewStringPlatform(env, cp)));
 453 
 454             (*env)->SetObjectArrayElement(env, argsArray, i, str);
 455             JNU_CHECK_EXCEPTION(env);
 456         }
 457         (*env)->SetObjectField(env, jinfo, ProcessHandleImpl_Info_argumentsID, argsArray);
 458         JNU_CHECK_EXCEPTION(env);
 459     }
 460     if (cmdline != NULL) {
 461         jstring commandLine = NULL;
 462         CHECK_NULL((commandLine = JNU_NewStringPlatform(env, cmdline)));
 463         (*env)->SetObjectField(env, jinfo, ProcessHandleImpl_Info_commandLineID, commandLine);
 464         JNU_CHECK_EXCEPTION(env);
 465     }
 466 }
 467 
 468 void unix_getUserInfo(JNIEnv* env, jobject jinfo, uid_t uid) {
 469     int result = 0;
 470     char* pwbuf;
 471     jstring name = NULL;
 472 
 473     /* allocate buffer for password record */
 474     pwbuf = (char*)malloc(getpw_buf_size);
 475     if (pwbuf == NULL) {
 476         JNU_ThrowOutOfMemoryError(env, "Unable to open getpwent");
 477     } else {
 478         struct passwd pwent;
 479         struct passwd* p = NULL;
 480         RESTARTABLE(getpwuid_r(uid, &pwent, pwbuf, (size_t)getpw_buf_size, &p), result);
 481 
 482         // Create the Java String if a name was found
 483         if (result == 0 && p != NULL &&
 484             p->pw_name != NULL && *(p->pw_name) != '\0') {
 485             name = JNU_NewStringPlatform(env, p->pw_name);
 486         }
 487         free(pwbuf);
 488     }
 489     if (name != NULL) {
 490         (*env)->SetObjectField(env, jinfo, ProcessHandleImpl_Info_userID, name);
 491     }
 492 }
 493 
 494 /*
 495  * The following functions are common on Solaris, Linux and AIX.
 496  */
 497 
 498 #if defined(__solaris__) || defined (__linux__) || defined(_AIX)
 499 
 500 /*
 501  * Returns the children of the requested pid and optionally each parent and
 502  * start time.
 503  * Reads /proc and accumulates any process who parent pid matches.
 504  * The resulting pids are stored into the array of longs.
 505  * The number of pids is returned if they all fit.
 506  * If the array is too short, the negative of the desired length is returned.
 507  */
 508 jint unix_getChildren(JNIEnv *env, jlong jpid, jlongArray jarray,
 509                       jlongArray jparentArray, jlongArray jstimesArray) {
 510     DIR* dir;
 511     struct dirent* ptr;
 512     pid_t pid = (pid_t) jpid;
 513     jlong* pids = NULL;
 514     jlong* ppids = NULL;
 515     jlong* stimes = NULL;
 516     jsize parentArraySize = 0;
 517     jsize arraySize = 0;
 518     jsize stimesSize = 0;
 519     jsize count = 0;
 520 
 521     arraySize = (*env)->GetArrayLength(env, jarray);
 522     JNU_CHECK_EXCEPTION_RETURN(env, -1);
 523     if (jparentArray != NULL) {
 524         parentArraySize = (*env)->GetArrayLength(env, jparentArray);
 525         JNU_CHECK_EXCEPTION_RETURN(env, -1);
 526 
 527         if (arraySize != parentArraySize) {
 528             JNU_ThrowIllegalArgumentException(env, "array sizes not equal");
 529             return 0;
 530         }
 531     }
 532     if (jstimesArray != NULL) {
 533         stimesSize = (*env)->GetArrayLength(env, jstimesArray);
 534         JNU_CHECK_EXCEPTION_RETURN(env, -1);
 535 
 536         if (arraySize != stimesSize) {
 537             JNU_ThrowIllegalArgumentException(env, "array sizes not equal");
 538             return 0;
 539         }
 540     }
 541 
 542     /*
 543      * To locate the children we scan /proc looking for files that have a
 544      * position integer as a filename.
 545      */
 546     if ((dir = opendir("/proc")) == NULL) {
 547         JNU_ThrowByNameWithLastError(env,
 548             "java/lang/RuntimeException", "Unable to open /proc");
 549         return -1;
 550     }
 551 
 552     do { // Block to break out of on Exception
 553         pids = (*env)->GetLongArrayElements(env, jarray, NULL);
 554         if (pids == NULL) {
 555             break;
 556         }
 557         if (jparentArray != NULL) {
 558             ppids  = (*env)->GetLongArrayElements(env, jparentArray, NULL);
 559             if (ppids == NULL) {
 560                 break;
 561             }
 562         }
 563         if (jstimesArray != NULL) {
 564             stimes  = (*env)->GetLongArrayElements(env, jstimesArray, NULL);
 565             if (stimes == NULL) {
 566                 break;
 567             }
 568         }
 569 
 570         while ((ptr = readdir(dir)) != NULL) {
 571             pid_t ppid = 0;
 572             jlong totalTime = 0L;
 573             jlong startTime = 0L;
 574 
 575             /* skip files that aren't numbers */
 576             pid_t childpid = (pid_t) atoi(ptr->d_name);
 577             if ((int) childpid <= 0) {
 578                 continue;
 579             }
 580 
 581             // Get the parent pid, and start time
 582             ppid = os_getParentPidAndTimings(env, childpid, &totalTime, &startTime);
 583             if (ppid >= 0 && (pid == 0 || ppid == pid)) {
 584                 if (count < arraySize) {
 585                     // Only store if it fits
 586                     pids[count] = (jlong) childpid;
 587 
 588                     if (ppids != NULL) {
 589                         // Store the parentPid
 590                         ppids[count] = (jlong) ppid;
 591                     }
 592                     if (stimes != NULL) {
 593                         // Store the process start time
 594                         stimes[count] = startTime;
 595                     }
 596                 }
 597                 count++; // Count to tabulate size needed
 598             }
 599         }
 600     } while (0);
 601 
 602     if (pids != NULL) {
 603         (*env)->ReleaseLongArrayElements(env, jarray, pids, 0);
 604     }
 605     if (ppids != NULL) {
 606         (*env)->ReleaseLongArrayElements(env, jparentArray, ppids, 0);
 607     }
 608     if (stimes != NULL) {
 609         (*env)->ReleaseLongArrayElements(env, jstimesArray, stimes, 0);
 610     }
 611 
 612     closedir(dir);
 613     // If more pids than array had size for; count will be greater than array size
 614     return count;
 615 }
 616 
 617 #endif // defined(__solaris__) || defined (__linux__) || defined(_AIX)
 618 
 619 /*
 620  * The following functions are common on Solaris and AIX.
 621  */
 622 
 623 #if defined(__solaris__) || defined(_AIX)
 624 
 625 /**
 626  * Helper function to get the 'psinfo_t' data from "/proc/%d/psinfo".
 627  * Returns 0 on success and -1 on error.
 628  */
 629 static int getPsinfo(pid_t pid, psinfo_t *psinfo) {
 630     FILE* fp;
 631     char fn[32];
 632     int ret;
 633 
 634     /*
 635      * Try to open /proc/%d/psinfo
 636      */
 637     snprintf(fn, sizeof fn, "/proc/%d/psinfo", pid);
 638     fp = fopen(fn, "r");
 639     if (fp == NULL) {
 640         return -1;
 641     }
 642 
 643     ret = fread(psinfo, 1, sizeof(psinfo_t), fp);
 644     fclose(fp);
 645     if (ret < sizeof(psinfo_t)) {
 646         return -1;
 647     }
 648     return 0;
 649 }
 650 
 651 /**
 652  * Read /proc/<pid>/psinfo and return the ppid, total cputime and start time.
 653  * Return: -1 is fail;  >=  0 is parent pid
 654  * 'total' will contain the running time of 'pid' in nanoseconds.
 655  * 'start' will contain the start time of 'pid' in milliseconds since epoch.
 656  */
 657 pid_t unix_getParentPidAndTimings(JNIEnv *env, pid_t pid,
 658                                   jlong *totalTime, jlong* startTime) {
 659     psinfo_t psinfo;
 660 
 661     if (getPsinfo(pid, &psinfo) < 0) {
 662         return -1;
 663     }
 664 
 665     // Validate the pid before returning the info
 666     if (kill(pid, 0) < 0) {
 667         return -1;
 668     }
 669 
 670     *totalTime = psinfo.pr_time.tv_sec * 1000000000L + psinfo.pr_time.tv_nsec;
 671 
 672     *startTime = psinfo.pr_start.tv_sec * (jlong)1000 +
 673                  psinfo.pr_start.tv_nsec / 1000000;
 674 
 675     return (pid_t) psinfo.pr_ppid;
 676 }
 677 
 678 void unix_getCmdlineAndUserInfo(JNIEnv *env, jobject jinfo, pid_t pid) {
 679     psinfo_t psinfo;
 680     char fn[32];
 681     char exePath[PATH_MAX];
 682     char prargs[PRARGSZ + 1];
 683     jstring cmdexe = NULL;
 684     int ret;
 685 
 686     /*
 687      * On Solaris, the full path to the executable command is the link in
 688      * /proc/<pid>/paths/a.out. But it is only readable for processes we own.
 689      */
 690 #if defined(__solaris__)
 691     snprintf(fn, sizeof fn, "/proc/%d/path/a.out", pid);
 692     if ((ret = readlink(fn, exePath, PATH_MAX - 1)) > 0) {
 693         // null terminate and create String to store for command
 694         exePath[ret] = '\0';
 695         CHECK_NULL(cmdexe = JNU_NewStringPlatform(env, exePath));
 696     }
 697 #endif
 698 
 699     /*
 700      * Now try to open /proc/%d/psinfo
 701      */
 702     if (getPsinfo(pid, &psinfo) < 0) {
 703         unix_fillArgArray(env, jinfo, 0, NULL, NULL, cmdexe, NULL);
 704         return;
 705     }
 706 
 707     unix_getUserInfo(env, jinfo, psinfo.pr_uid);
 708 
 709     /*
 710      * Now read psinfo.pr_psargs which contains the first PRARGSZ characters of the
 711      * argument list (i.e. arg[0] arg[1] ...). Unfortunately, PRARGSZ is usually set
 712      * to 80 characters only. Nevertheless it's better than nothing :)
 713      */
 714     strncpy(prargs, psinfo.pr_psargs, PRARGSZ);
 715     prargs[PRARGSZ] = '\0';
 716     if (prargs[0] == '\0') {
 717         /* If psinfo.pr_psargs didn't contain any strings, use psinfo.pr_fname
 718          * (which only contains the last component of exec()ed pathname) as a
 719          * last resort. This is true for AIX kernel processes for example.
 720          */
 721         strncpy(prargs, psinfo.pr_fname, PRARGSZ);
 722         prargs[PRARGSZ] = '\0';
 723     }
 724     unix_fillArgArray(env, jinfo, 0, NULL, NULL, cmdexe,
 725                       prargs[0] == '\0' ? NULL : prargs);
 726 }
 727 
 728 #endif // defined(__solaris__) || defined(_AIX)