1 /*

     2  * Copyright (c) 2003, 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 "jlong.h"

    29 #include "jvm.h"

    30 #include "management_ext.h"

    31 #include "com_sun_management_internal_OperatingSystemImpl.h"

    32 

    33 #include <psapi.h>

    34 #include <errno.h>

    35 #include <stdlib.h>

    36 

    37 #include <malloc.h>

    38 #pragma warning (push,0)

    39 #include <windows.h>

    40 #pragma warning (pop)

    41 #include <stdio.h>

    42 #include <time.h>

    43 #include <stdint.h>

    44 #include <assert.h>

    45 

    46 /* Disable warnings due to broken header files from Microsoft... */

    47 #pragma warning(push, 3)

    48 #include <pdh.h>

    49 #include <pdhmsg.h>

    50 #include <process.h>

    51 #pragma warning(pop)

    52 

    53 typedef unsigned __int32 juint;

    54 typedef unsigned __int64 julong;

    55 

    56 static void set_low(jlong* value, jint low) {

    57     *value &= (jlong)0xffffffff << 32;

    58     *value |= (jlong)(julong)(juint)low;

    59 }

    60 

    61 static void set_high(jlong* value, jint high) {

    62     *value &= (jlong)(julong)(juint)0xffffffff;

    63     *value |= (jlong)high       << 32;

    64 }

    65 

    66 static jlong jlong_from(jint h, jint l) {

    67     jlong result = 0; // initialization to avoid warning

    68     set_high(&result, h);

    69     set_low(&result,  l);

    70     return result;

    71 }

    72 

    73 static HANDLE main_process;

    74 

    75 static void perfInit(void);

    76 

    77 JNIEXPORT void JNICALL

    78 Java_com_sun_management_internal_OperatingSystemImpl_initialize0

    79   (JNIEnv *env, jclass cls)

    80 {

    81     main_process = GetCurrentProcess();

    82     perfInit();

    83 }

    84 

    85 JNIEXPORT jlong JNICALL

    86 Java_com_sun_management_internal_OperatingSystemImpl_getCommittedVirtualMemorySize0

    87   (JNIEnv *env, jobject mbean)

    88 {

    89     PROCESS_MEMORY_COUNTERS pmc;

    90     if (GetProcessMemoryInfo(main_process, &pmc, sizeof(PROCESS_MEMORY_COUNTERS)) == 0) {

    91         return (jlong)-1L;

    92     } else {

    93         return (jlong) pmc.PagefileUsage;

    94     }

    95 }

    96 

    97 JNIEXPORT jlong JNICALL

    98 Java_com_sun_management_internal_OperatingSystemImpl_getTotalSwapSpaceSize0

    99   (JNIEnv *env, jobject mbean)

   100 {

   101     MEMORYSTATUSEX ms;

   102     ms.dwLength = sizeof(ms);

   103     GlobalMemoryStatusEx(&ms);

   104     return (jlong) ms.ullTotalPageFile;

   105 }

   106 

   107 JNIEXPORT jlong JNICALL

   108 Java_com_sun_management_internal_OperatingSystemImpl_getFreeSwapSpaceSize0

   109   (JNIEnv *env, jobject mbean)

   110 {

   111     MEMORYSTATUSEX ms;

   112     ms.dwLength = sizeof(ms);

   113     GlobalMemoryStatusEx(&ms);

   114     return (jlong) ms.ullAvailPageFile;

   115 }

   116 

   117 JNIEXPORT jlong JNICALL

   118 Java_com_sun_management_internal_OperatingSystemImpl_getProcessCpuTime0

   119   (JNIEnv *env, jobject mbean)

   120 {

   121 

   122     FILETIME process_creation_time, process_exit_time,

   123              process_user_time, process_kernel_time;

   124 

   125     // Using static variables declared above

   126     // Units are 100-ns intervals.  Convert to ns.

   127     GetProcessTimes(main_process, &process_creation_time,

   128                     &process_exit_time,

   129                     &process_kernel_time, &process_user_time);

   130     return (jlong_from(process_user_time.dwHighDateTime,

   131                         process_user_time.dwLowDateTime) +

   132             jlong_from(process_kernel_time.dwHighDateTime,

   133                         process_kernel_time.dwLowDateTime)) * 100;

   134 }

   135 

   136 JNIEXPORT jlong JNICALL

   137 Java_com_sun_management_internal_OperatingSystemImpl_getFreePhysicalMemorySize0

   138   (JNIEnv *env, jobject mbean)

   139 {

   140     MEMORYSTATUSEX ms;

   141     ms.dwLength = sizeof(ms);

   142     GlobalMemoryStatusEx(&ms);

   143     return (jlong) ms.ullAvailPhys;

   144 }

   145 

   146 JNIEXPORT jlong JNICALL

   147 Java_com_sun_management_internal_OperatingSystemImpl_getTotalPhysicalMemorySize0

   148   (JNIEnv *env, jobject mbean)

   149 {

   150     MEMORYSTATUSEX ms;

   151     ms.dwLength = sizeof(ms);

   152     GlobalMemoryStatusEx(&ms);

   153     return (jlong) ms.ullTotalPhys;

   154 }

   155 

   156 /* Performance Data Helper API (PDH) support */

   157 

   158 typedef PDH_STATUS (WINAPI *PdhAddCounterFunc)(

   159                            HQUERY      hQuery,

   160                            LPCSTR      szFullCounterPath,

   161                            DWORD       dwUserData,

   162                            HCOUNTER    *phCounter

   163                            );

   164 typedef PDH_STATUS (WINAPI *PdhOpenQueryFunc)(

   165                            LPCWSTR     szDataSource,

   166                            DWORD       dwUserData,

   167                            HQUERY      *phQuery

   168                            );

   169 typedef PDH_STATUS (WINAPI *PdhCollectQueryDataFunc)(

   170                            HQUERY      hQuery

   171                            );

   172 

   173 typedef PDH_STATUS (WINAPI *PdhEnumObjectItemsFunc)(

   174                            LPCTSTR     szDataSource,

   175                            LPCTSTR     szMachineName,

   176                            LPCTSTR     szObjectName,

   177                            LPTSTR      mszCounterList,

   178                            LPDWORD     pcchCounterListLength,

   179                            LPTSTR      mszInstanceList,

   180                            LPDWORD     pcchInstanceListLength,

   181                            DWORD       dwDetailLevel,

   182                            DWORD       dwFlags

   183                            );

   184 typedef PDH_STATUS (WINAPI *PdhRemoveCounterFunc)(

   185                            HCOUNTER   hCounter

   186                            );

   187 typedef PDH_STATUS (WINAPI *PdhLookupPerfNameByIndexFunc)(

   188                            LPCSTR     szMachineName,

   189                            DWORD      dwNameIndex,

   190                            LPSTR      szNameBuffer,

   191                            LPDWORD    pcchNameBufferSize

   192                            );

   193 typedef DWORD (WINAPI *PdhCloseQueryFunc)(

   194                       HQUERY      hQuery

   195                       );

   196 

   197 typedef DWORD (WINAPI *PdhGetFormattedCounterValueFunc)(

   198                       HCOUNTER                hCounter,

   199                       DWORD                   dwFormat,

   200                       LPDWORD                 lpdwType,

   201                       PPDH_FMT_COUNTERVALUE   pValue

   202                       );

   203 

   204 static PdhAddCounterFunc PdhAddCounter_i;

   205 static PdhOpenQueryFunc PdhOpenQuery_i;

   206 static PdhCloseQueryFunc PdhCloseQuery_i;

   207 static PdhCollectQueryDataFunc PdhCollectQueryData_i;

   208 static PdhGetFormattedCounterValueFunc PdhGetFormattedCounterValue_i;

   209 static PdhEnumObjectItemsFunc PdhEnumObjectItems_i;

   210 static PdhRemoveCounterFunc PdhRemoveCounter_i;

   211 static PdhLookupPerfNameByIndexFunc PdhLookupPerfNameByIndex_i;

   212 

   213 /*

   214  * Struct for PDH queries.

   215  */

   216 typedef struct {

   217     HQUERY      query;

   218     uint64_t    lastUpdate; // Last time query was updated (ticks)

   219 } UpdateQueryS, *UpdateQueryP;

   220 

   221 // Min time between query updates (ticks)

   222 static const int MIN_UPDATE_INTERVAL = 500;

   223 

   224 /*

   225  * Struct for a PDH query with multiple counters.

   226  */

   227 typedef struct {

   228     UpdateQueryS  query;

   229     HCOUNTER*     counters;

   230     int           noOfCounters;

   231 } MultipleCounterQueryS, *MultipleCounterQueryP;

   232 

   233 /*

   234  * Struct for a PDH query with a single counter.

   235  */

   236 typedef struct {

   237     UpdateQueryS  query;

   238     HCOUNTER      counter;

   239 } SingleCounterQueryS, *SingleCounterQueryP;

   240 

   241 

   242 typedef struct {

   243     CRITICAL_SECTION cs;

   244     DWORD owningThread;

   245     DWORD recursionCount;

   246 } PdhCriticalSectionS, *PdhCriticalSectionP;

   247 

   248 static PdhCriticalSectionS initializationLock;

   249 

   250 static void InitializePdhCriticalSection(PdhCriticalSectionP criticalSection) {

   251     assert(criticalSection);

   252 

   253     InitializeCriticalSection(&criticalSection->cs);

   254     criticalSection->owningThread = 0;

   255     criticalSection->recursionCount = 0;

   256 }

   257 

   258 static void EnterPdhCriticalSection(PdhCriticalSectionP criticalSection) {

   259     assert(criticalSection);

   260 

   261     EnterCriticalSection(&criticalSection->cs);

   262     criticalSection->recursionCount++;

   263     if (!criticalSection->owningThread) {

   264         criticalSection->owningThread = GetCurrentThreadId();

   265     }

   266 }

   267 

   268 static void LeavePdhCriticalSection(PdhCriticalSectionP criticalSection) {

   269     assert(criticalSection);

   270     assert(GetCurrentThreadId() == criticalSection->owningThread);

   271     assert(criticalSection->recursionCount >= 1);

   272 

   273     criticalSection->recursionCount--;

   274     if (!criticalSection->recursionCount) {

   275         criticalSection->owningThread = 0;

   276     }

   277     LeaveCriticalSection(&criticalSection->cs);

   278 }

   279 

   280 /*

   281  * INFO: Using PDH APIs Correctly in a Localized Language (Q287159)

   282  *   http://support.microsoft.com/default.aspx?scid=kb;EN-US;q287159

   283  * The index value for the base system counters and objects like processor,

   284  * process, thread, memory, and so forth are always the same irrespective

   285  * of the localized version of the operating system or service pack installed.

   286  * To find the correct index for an object or counter, inspect the registry key/value:

   287  * [HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Perflib\009\Counter]

   288  */

   289 static const DWORD PDH_PROCESSOR_IDX = 238;

   290 static const DWORD PDH_PROCESSOR_TIME_IDX = 6;

   291 static const DWORD PDH_PROCESS_IDX = 230;

   292 static const DWORD PDH_ID_PROCESS_IDX = 784;

   293 

   294 /* useful pdh fmt's */

   295 static const char* const OBJECT_COUNTER_FMT = "\\%s\\%s";

   296 static const size_t OBJECT_COUNTER_FMT_LEN = 2;

   297 static const char* const OBJECT_WITH_INSTANCES_COUNTER_FMT = "\\%s(%s)\\%s";

   298 static const size_t OBJECT_WITH_INSTANCES_COUNTER_FMT_LEN = 4;

   299 static const char* const PROCESS_OBJECT_INSTANCE_COUNTER_FMT = "\\%s(%s#%s)\\%s";

   300 static const size_t PROCESS_OBJECT_INSTANCE_COUNTER_FMT_LEN = 5;

   301 

   302 static const char* pdhProcessImageName = NULL; /* "java" */

   303 static char* pdhIDProcessCounterFmt = NULL;    /* "\Process(java#%d)\ID Process" */

   304 

   305 static int numberOfJavaProcessesAtInitialization = 0;

   306 

   307 /*

   308  * Currently used CPU queries/counters and variables

   309  */

   310 static SingleCounterQueryP processTotalCPULoad = NULL;

   311 static MultipleCounterQueryP multiCounterCPULoad = NULL;

   312 static double cpuFactor = .0;

   313 static DWORD  numCpus = 0;

   314 

   315 /*

   316  * Seems WinXP PDH returns PDH_MORE_DATA whenever we send in a NULL buffer.

   317  * Let's just ignore it, since we make sure we have enough buffer anyway.

   318  */

   319 static int

   320 pdhFail(PDH_STATUS pdhStat) {

   321     return pdhStat != ERROR_SUCCESS && pdhStat != PDH_MORE_DATA;

   322 }

   323 

   324 static const char*

   325 allocateAndCopy(const char* const originalString) {

   326     size_t len;

   327     char* allocatedString;

   328 

   329     assert(originalString);

   330 

   331     len = strlen(originalString);

   332 

   333     allocatedString = malloc(len + 1);

   334 

   335     if (!allocatedString) {

   336         return NULL;

   337     }

   338 

   339     strncpy(allocatedString, originalString, len);

   340     allocatedString[len] = '\0';

   341 

   342     return allocatedString;

   343 }

   344 

   345 /*

   346  * Allocates memory into the supplied pointer and

   347  * fills it with the localized PDH artifact description, if indexed correctly.

   348  * Caller owns the memory from the point of returning from this function.

   349  *

   350  * @param index    the PDH counter index as specified in the registry

   351  * @param ppBuffer pointer to a char*.

   352  * @return         0 if successful, negative on failure.

   353  */

   354 static int

   355 lookupNameByIndex(DWORD index, char** ppBuffer) {

   356     DWORD size;

   357 

   358     assert(ppBuffer);

   359 

   360     /* determine size needed */

   361     if (PdhLookupPerfNameByIndex_i(NULL, index, NULL, &size) != PDH_MORE_DATA) {

   362       /* invalid index? */

   363       return -1;

   364     }

   365 

   366     *ppBuffer = malloc((size_t)size);

   367 

   368     if (!*ppBuffer) {

   369         return -1;

   370     }

   371 

   372     if (PdhLookupPerfNameByIndex_i(NULL, index, *ppBuffer, &size) != ERROR_SUCCESS) {

   373         free(*ppBuffer);

   374         *ppBuffer = NULL;

   375         return -1;

   376     }

   377 

   378     /* windows vista does not null-terminate the string

   379      * (although the docs says it will) */

   380     (*ppBuffer)[size - 1] = '\0';

   381 

   382     return 0;

   383 }

   384 

   385 /*

   386 * Construct a fully qualified PDH path

   387 *

   388 * @param objectName   a PDH Object string representation (required)

   389 * @param counterName  a PDH Counter string representation (required)

   390 * @param imageName    a process image name string, ex. "java" (opt)

   391 * @param instance     an instance string, ex. "0", "1", ... (opt)

   392 * @return             the fully qualified PDH path.

   393 *

   394 * Caller will own the returned malloc:ed string

   395 */

   396 static const char*

   397 makeFullCounterPath(const char* const objectName,

   398                     const char* const counterName,

   399                     const char* const imageName,

   400                     const char* const instance) {

   401 

   402     size_t fullCounterPathLen;

   403     char* fullCounterPath;

   404 

   405     assert(objectName);

   406     assert(counterName);

   407 

   408     fullCounterPathLen = strlen(objectName);

   409     fullCounterPathLen += strlen(counterName);

   410 

   411     if (imageName) {

   412         /*

   413          * For paths using the "Process" Object.

   414          *

   415          * Examples:

   416          * abstract: "\Process(imageName#instance)\Counter"

   417          * actual:   "\Process(java#2)\ID Process"

   418          */

   419         fullCounterPathLen += PROCESS_OBJECT_INSTANCE_COUNTER_FMT_LEN;

   420         fullCounterPathLen += strlen(imageName);

   421 

   422         /*

   423          * imageName must be passed together with an associated

   424          * instance "number" ("0", "1", "2", ...).

   425          * This is required in order to create valid "Process" Object paths.

   426          *

   427          * Examples: "\Process(java#0)", \Process(java#1"), ...

   428          */

   429         assert(instance);

   430 

   431         fullCounterPathLen += strlen(instance);

   432 

   433         fullCounterPath = malloc(fullCounterPathLen + 1);

   434 

   435         if (!fullCounterPath) {

   436             return NULL;

   437         }

   438 

   439         _snprintf(fullCounterPath,

   440                   fullCounterPathLen,

   441                   PROCESS_OBJECT_INSTANCE_COUNTER_FMT,

   442                   objectName,

   443                   imageName,

   444                   instance,

   445                   counterName);

   446     } else {

   447         if (instance) {

   448             /*

   449              * For paths where the Object has multiple instances.

   450              *

   451              * Examples:

   452              * abstract: "\Object(instance)\Counter"

   453              * actual:   "\Processor(0)\% Privileged Time"

   454              */

   455             fullCounterPathLen += strlen(instance);

   456             fullCounterPathLen += OBJECT_WITH_INSTANCES_COUNTER_FMT_LEN;

   457         } else {

   458             /*

   459              * For "normal" paths.

   460              *

   461              * Examples:

   462              * abstract: "\Object\Counter"

   463              * actual:   "\Memory\Available Mbytes"

   464              */

   465             fullCounterPathLen += OBJECT_COUNTER_FMT_LEN;

   466         }

   467 

   468         fullCounterPath = malloc(fullCounterPathLen + 1);

   469 

   470         if (!fullCounterPath) {

   471             return NULL;

   472         }

   473 

   474         if (instance) {

   475             _snprintf(fullCounterPath,

   476                       fullCounterPathLen,

   477                       OBJECT_WITH_INSTANCES_COUNTER_FMT,

   478                       objectName,

   479                       instance,

   480                       counterName);

   481         } else {

   482             _snprintf(fullCounterPath,

   483                       fullCounterPathLen,

   484                       OBJECT_COUNTER_FMT,

   485                       objectName,

   486                       counterName);

   487         }

   488     }

   489 

   490     fullCounterPath[fullCounterPathLen] = '\0';

   491 

   492     return fullCounterPath;

   493 }

   494 

   495 /*

   496  * Resolves an index for a PDH artifact to

   497  * a localized, malloc:ed string representation.

   498  * Caller will own the returned malloc:ed string.

   499  *

   500  * @param pdhArtifactIndex  PDH index

   501  * @return                  malloc:ed string representation

   502  *                          of the requested pdh artifact (localized).

   503  *                          NULL on failure.

   504  */

   505 static const char*

   506 getPdhLocalizedArtifact(DWORD pdhArtifactIndex) {

   507     char* pdhLocalizedArtifactString;

   508 

   509     if (lookupNameByIndex(pdhArtifactIndex,

   510                           &pdhLocalizedArtifactString) != 0) {

   511         return NULL;

   512     }

   513 

   514     return pdhLocalizedArtifactString;

   515 }

   516 

   517 static void

   518 pdhCleanup(HQUERY* const query, HCOUNTER* const counter) {

   519     if (counter && *counter) {

   520         PdhRemoveCounter_i(*counter);

   521         *counter = NULL;

   522     }

   523     if (query && *query) {

   524         PdhCloseQuery_i(*query);

   525         *query = NULL;

   526     }

   527 }

   528 

   529 static void

   530 destroySingleCounter(SingleCounterQueryP counterQuery) {

   531     if (counterQuery) {

   532         pdhCleanup(&counterQuery->query.query, &counterQuery->counter);

   533     }

   534 }

   535 

   536 static void

   537 destroyMultiCounter(MultipleCounterQueryP multiCounterQuery) {

   538     int i;

   539     if (multiCounterQuery) {

   540         if (multiCounterQuery->counters) {

   541             for (i = 0; i < multiCounterQuery->noOfCounters; i++) {

   542                 pdhCleanup(NULL, &multiCounterQuery->counters[i]);

   543             }

   544             free(multiCounterQuery->counters);

   545             multiCounterQuery->counters = NULL;

   546         }

   547         pdhCleanup(&multiCounterQuery->query.query, NULL);

   548     }

   549 }

   550 

   551 static int

   552 openQuery(HQUERY* const query) {

   553     assert(query);

   554 

   555     if (PdhOpenQuery_i(NULL, 0, query) != ERROR_SUCCESS) {

   556         return -1;

   557     }

   558 

   559     return 0;

   560 }

   561 

   562 static int

   563 addCounter(HQUERY query,

   564            const char* const fullCounterPath,

   565            HCOUNTER* const counter) {

   566 

   567     assert(fullCounterPath);

   568     assert(counter);

   569 

   570     if (PdhAddCounter_i(query,

   571                         fullCounterPath,

   572                         0,

   573                         counter) != ERROR_SUCCESS) {

   574         return -1;

   575     }

   576 

   577     return 0;

   578 }

   579 

   580 /*

   581  * Sets up the supplied SingleCounterQuery to listen for the specified counter.

   582  *

   583  * @param counterQuery       the counter query to set up.

   584  * @param fullCounterPath    the string specifying the full path to the counter.

   585  * @returns                  0 if successful, negative on failure.

   586  */

   587 static int

   588 initializeSingleCounterQuery(SingleCounterQueryP counterQuery,

   589                              const char* const fullCounterPath) {

   590     assert(counterQuery);

   591     assert(fullCounterPath);

   592 

   593     if (openQuery(&counterQuery->query.query) == 0) {

   594         if (addCounter(counterQuery->query.query,

   595                        fullCounterPath,

   596                        &counterQuery->counter) == 0) {

   597             return 0;

   598         }

   599     }

   600 

   601     return -1;

   602 }

   603 

   604 /*

   605  * Sets up a SingleCounterQuery

   606  *

   607  * param counter             the counter query to set up.

   608  * param localizedObject     string representing the PDH object to query

   609  * param localizedCounter    string representing the PDH counter to query

   610  * param processImageName    if the counter query needs the process image name ("java")

   611  * param instance            if the counter has instances, this is the instance ("\Processor(0)\")

   612                                  where 0 is the instance

   613  * param firstSampleOnInit   for counters that need two queries to yield their values,

   614                                  the first query can be issued just after initialization

   615  *

   616  * @returns                   0 if successful, negative on failure.

   617  */

   618 static int

   619 initializeSingleCounter(SingleCounterQueryP const counter,

   620                         const char* const localizedObject,

   621                         const char* const localizedCounter,

   622                         const char* const processImageName,

   623                         const char* const instance,

   624                         BOOL firstSampleOnInit) {

   625     int retValue = -1;

   626 

   627     const char* fullCounterPath = makeFullCounterPath(localizedObject,

   628                                                       localizedCounter,

   629                                                       processImageName,

   630                                                       instance);

   631 

   632     if (fullCounterPath) {

   633 

   634         assert(counter);

   635 

   636         if (initializeSingleCounterQuery(counter, fullCounterPath) == 0) {

   637             /*

   638              * According to the MSDN documentation, rate counters must be read twice:

   639              *

   640              * "Obtaining the value of rate counters such as Page faults/sec requires that

   641              *  PdhCollectQueryData be called twice, with a specific time interval between

   642              *  the two calls, before calling PdhGetFormattedCounterValue. Call Sleep to

   643              *  implement the waiting period between the two calls to PdhCollectQueryData."

   644              *

   645              *  Take the first sample here already to allow for the next (first) "real" sample

   646              *  to succeed.

   647              */

   648             if (firstSampleOnInit) {

   649                 PdhCollectQueryData_i(counter->query.query);

   650             }

   651 

   652             retValue = 0;

   653         }

   654         free((char*)fullCounterPath);

   655     }

   656 

   657     return retValue;

   658 }

   659 

   660 static void

   661 perfInit(void) {

   662     InitializePdhCriticalSection(&initializationLock);

   663 }

   664 

   665 static int

   666 getProcessID() {

   667     static int myPid = 0;

   668     if (0 == myPid) {

   669         myPid = _getpid();

   670     }

   671     return myPid;

   672 }

   673 

   674 /*

   675  * Working against the Process object and it's related counters is inherently problematic

   676  * when using the PDH API:

   677  *

   678  * For PDH, a process is not primarily identified by it's process id,

   679  * but with a sequential number, for example \Process(java#0), \Process(java#1), ....

   680  * The really bad part is that this list is reset as soon as one process exits:

   681  * If \Process(java#1) exits, \Process(java#3) now becomes \Process(java#2) etc.

   682  *

   683  * The PDH query api requires a process identifier to be submitted when registering

   684  * a query, but as soon as the list resets, the query is invalidated (since the name

   685  * changed).

   686  *

   687  * Solution:

   688  * The #number identifier for a Process query can only decrease after process creation.

   689  *

   690  * Therefore we create an array of counter queries for all process object instances

   691  * up to and including ourselves:

   692  *

   693  * Ex. we come in as third process instance (java#2), we then create and register

   694  * queries for the following Process object instances:

   695  * java#0, java#1, java#2

   696  *

   697  * currentQueryIndexForProcess() keeps track of the current "correct" query

   698  * (in order to keep this index valid when the list resets from underneath,

   699  * ensure to call getCurrentQueryIndexForProcess() before every query involving

   700  * Process object instance data).

   701  */

   702 static int

   703 currentQueryIndexForProcess(void) {

   704     HQUERY tmpQuery = NULL;

   705     HCOUNTER handleCounter = NULL;

   706     int retValue = -1;

   707 

   708     assert(pdhProcessImageName);

   709     assert(pdhIDProcessCounterFmt);

   710 

   711     if (openQuery(&tmpQuery) == 0) {

   712         int index;

   713 

   714         /* iterate over all instance indexes and try to find our own pid */

   715         for (index = 0; index < INT_MAX; ++index) {

   716             char fullIDProcessCounterPath[MAX_PATH];

   717             PDH_FMT_COUNTERVALUE counterValue;

   718             PDH_STATUS res;

   719 

   720             _snprintf(fullIDProcessCounterPath,

   721                       MAX_PATH,

   722                       pdhIDProcessCounterFmt,

   723                       index);

   724 

   725             if (addCounter(tmpQuery, fullIDProcessCounterPath, &handleCounter) != 0) {

   726                 break;

   727             }

   728 

   729             res = PdhCollectQueryData_i(tmpQuery);

   730 

   731             if (PDH_INVALID_HANDLE == res || PDH_NO_DATA == res) {

   732                 break;

   733             }

   734 

   735             PdhGetFormattedCounterValue_i(handleCounter,

   736                                           PDH_FMT_LONG,

   737                                           NULL,

   738                                           &counterValue);

   739             /*

   740              * This check seems to be needed for Win2k SMP boxes, since

   741              * they for some reason don't return PDH_NO_DATA for non existing

   742              * counters.

   743              */

   744             if (counterValue.CStatus != PDH_CSTATUS_VALID_DATA) {

   745                 break;

   746             }

   747 

   748             if ((LONG)getProcessID() == counterValue.longValue) {

   749                 retValue = index;

   750                 break;

   751             }

   752         }

   753     }

   754 

   755     pdhCleanup(&tmpQuery, &handleCounter);

   756 

   757     return retValue;

   758 }

   759 

   760 /*

   761  * If successful, returns the #index corresponding to our PID

   762  * as resolved by the pdh query:

   763  * "\Process(java#index)\ID Process" (or localized equivalent)

   764  *

   765  * This function should be called before attempting to read

   766  * from any Process related counter(s), and the return value

   767  * is the index to be used for indexing an array of Process object query's:

   768  *

   769  * Example:

   770  * processTotalCPULoad[currentQueryIndex].query

   771  *

   772  * Returns -1 on failure.

   773  */

   774 static int

   775 getCurrentQueryIndexForProcess() {

   776     int currentQueryIndex = currentQueryIndexForProcess();

   777 

   778     assert(currentQueryIndex >= 0 &&

   779            currentQueryIndex < numberOfJavaProcessesAtInitialization);

   780 

   781     return currentQueryIndex;

   782 }

   783 

   784 /*

   785  * Returns the PDH string identifying the current process image name.

   786  * Use this name as a qualifier when getting counters from the PDH Process Object

   787  * representing your process.

   788 

   789  * Example:

   790  * "\Process(java#0)\Virtual Bytes" - where "java" is the PDH process

   791  * image name.

   792  *

   793  * Please note that the process image name is not necessarily "java",

   794  * hence the use of GetModuleFileName() to detect the process image name.

   795  *

   796  * @return   the process image name to be used when retrieving

   797  *           PDH counters from the current process. The caller will

   798              own the returned malloc:ed string. NULL if failure.

   799  */

   800 static const char*

   801 getPdhProcessImageName() {

   802     char moduleName[MAX_PATH];

   803     char* processImageName;

   804     char* dotPos;

   805 

   806     // Find our module name and use it to extract the image name used by PDH

   807     DWORD getmfnReturn = GetModuleFileName(NULL, moduleName, sizeof(moduleName));

   808 

   809     if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) {

   810         return NULL;

   811     }

   812 

   813     if (getmfnReturn >= MAX_PATH || 0 == getmfnReturn) {

   814         return NULL;

   815     }

   816 

   817     processImageName = strrchr(moduleName, '\\'); //drop path

   818     processImageName++;                           //skip slash

   819     dotPos = strrchr(processImageName, '.');      //drop .exe

   820     dotPos[0] = '\0';

   821 

   822     return allocateAndCopy(processImageName);

   823 }

   824 

   825 /*

   826  * Sets up the supplied MultipleCounterQuery to check on the processors via PDH CPU counters.

   827  * TODO: Refactor and prettify as with the the SingleCounter queries

   828  * if more MultipleCounterQueries are discovered/needed.

   829  *

   830  * @param multiCounterCPULoad  a pointer to a MultipleCounterQueryS, will be filled in with

   831  *                             the necessary info to check the PDH processor counters.

   832  * @return                     0 if successful, negative on failure.

   833  */

   834 static int

   835 initializeMultipleCounterForCPUs(MultipleCounterQueryP multiCounterCPULoad) {

   836     DWORD cSize = 0;

   837     DWORD iSize = 0;

   838     DWORD pCount;

   839     DWORD index;

   840     char* processor = NULL; //'Processor' == PDH_PROCESSOR_IDX

   841     char* time = NULL;      //'Time' == PDH_PROCESSOR_TIME_IDX

   842     char* instances = NULL;

   843     char* tmp;

   844     int   retValue = -1;

   845     PDH_STATUS pdhStat;

   846 

   847     if (lookupNameByIndex(PDH_PROCESSOR_IDX, &processor) != 0) {

   848         goto end;

   849     }

   850 

   851     if (lookupNameByIndex(PDH_PROCESSOR_TIME_IDX, &time) != 0) {

   852         goto end;

   853     }

   854 

   855     //ok, now we have enough to enumerate all processors.

   856     pdhStat = PdhEnumObjectItems_i(

   857                                    NULL, // reserved

   858                                    NULL, // local machine

   859                                    processor, // object to enumerate

   860                                    NULL, // pass in NULL buffers

   861                                    &cSize, // and 0 length to get

   862                                    NULL, // required size

   863                                    &iSize, // of the buffers in chars

   864                                    PERF_DETAIL_WIZARD, // counter detail level

   865                                    0);

   866 

   867     if (pdhFail(pdhStat)) {

   868         goto end;

   869     }

   870 

   871     instances = calloc(iSize, 1);

   872 

   873     if (!instances) {

   874         goto end;

   875     }

   876 

   877     cSize = 0;

   878 

   879     pdhStat = PdhEnumObjectItems_i(

   880                                    NULL, // reserved

   881                                    NULL, // local machine

   882                                    processor, // object to enumerate

   883                                    NULL, // pass in NULL buffers

   884                                    &cSize,

   885                                    instances, // now allocated to be filled in

   886                                    &iSize, // and size is known

   887                                    PERF_DETAIL_WIZARD, // counter detail level

   888                                    0);

   889 

   890     if (pdhFail(pdhStat)) {

   891         goto end;

   892     }

   893 

   894     // enumerate the Processor instances ("\Processor(0)", "\Processor(1)", ..., "\Processor(_Total)")

   895     for (pCount = 0, tmp = instances; *tmp != '\0'; tmp = &tmp[strlen(tmp)+1], pCount++);

   896 

   897     assert(pCount == numCpus+1);

   898 

   899     //ok, we now have the number of Processor instances - allocate an HCOUNTER for each

   900     multiCounterCPULoad->counters = (HCOUNTER*)malloc(pCount * sizeof(HCOUNTER));

   901 

   902     if (!multiCounterCPULoad->counters) {

   903         goto end;

   904     }

   905 

   906     multiCounterCPULoad->noOfCounters = pCount;

   907 

   908     if (openQuery(&multiCounterCPULoad->query.query) != 0) {

   909         goto end;

   910     }

   911 

   912     // fetch instance and register its corresponding HCOUNTER with the query

   913     for (index = 0, tmp = instances; *tmp != '\0'; tmp = &tmp[strlen(tmp)+1], ++index) {

   914         const char* const fullCounterPath = makeFullCounterPath(processor, time, NULL, tmp);

   915 

   916         if (!fullCounterPath) {

   917             goto end;

   918         }

   919 

   920         retValue = addCounter(multiCounterCPULoad->query.query,

   921                               fullCounterPath,

   922                               &multiCounterCPULoad->counters[index]);

   923 

   924         free((char*)fullCounterPath);

   925 

   926         if (retValue != 0) {

   927             goto end;

   928         }

   929     }

   930 

   931     // Query once to initialize the counters which require at least two samples

   932     // (like the % CPU usage) to calculate correctly.

   933     PdhCollectQueryData_i(multiCounterCPULoad->query.query);

   934 

   935   end:

   936     if (processor) {

   937         free(processor);

   938     }

   939 

   940     if (time) {

   941         free(time);

   942     }

   943 

   944     if (instances) {

   945         free(instances);

   946     }

   947 

   948     return retValue;

   949 }

   950 

   951 /*

   952  * Dynamically sets up function pointers to the PDH library.

   953  *

   954  * @param h  HMODULE for the PDH library

   955  * @return   0 on success, negative on failure.

   956  */

   957 static int

   958 bindPdhFunctionPointers(HMODULE h) {

   959     assert(h);

   960     assert(GetCurrentThreadId() == initializationLock.owningThread);

   961 

   962     /* The 'A' at the end means the ANSI (not the UNICODE) vesions of the methods */

   963     PdhAddCounter_i         = (PdhAddCounterFunc)GetProcAddress(h, "PdhAddCounterA");

   964     PdhOpenQuery_i         = (PdhOpenQueryFunc)GetProcAddress(h, "PdhOpenQueryA");

   965     PdhCloseQuery_i         = (PdhCloseQueryFunc)GetProcAddress(h, "PdhCloseQuery");

   966     PdhCollectQueryData_i     = (PdhCollectQueryDataFunc)GetProcAddress(h, "PdhCollectQueryData");

   967     PdhGetFormattedCounterValue_i = (PdhGetFormattedCounterValueFunc)GetProcAddress(h, "PdhGetFormattedCounterValue");

   968     PdhEnumObjectItems_i         = (PdhEnumObjectItemsFunc)GetProcAddress(h, "PdhEnumObjectItemsA");

   969     PdhRemoveCounter_i         = (PdhRemoveCounterFunc)GetProcAddress(h, "PdhRemoveCounter");

   970     PdhLookupPerfNameByIndex_i     = (PdhLookupPerfNameByIndexFunc)GetProcAddress(h, "PdhLookupPerfNameByIndexA");

   971 

   972     if (!PdhAddCounter_i || !PdhOpenQuery_i ||

   973         !PdhCloseQuery_i || !PdhCollectQueryData_i ||

   974         !PdhGetFormattedCounterValue_i || !PdhEnumObjectItems_i ||

   975         !PdhRemoveCounter_i || !PdhLookupPerfNameByIndex_i)

   976     {

   977         return -1;

   978     }

   979     return 0;

   980 }

   981 

   982 /*

   983  * Returns the counter value as a double for the specified query.

   984  * Will collect the query data and update the counter values as necessary.

   985  *

   986  * @param query       the query to update (if needed).

   987  * @param c           the counter to read.

   988  * @param value       where to store the formatted value.

   989  * @param format      the format to use (i.e. PDH_FMT_DOUBLE, PDH_FMT_LONG etc)

   990  * @return            0 if no error

   991  *                    -1 if PdhCollectQueryData fails

   992  *                    -2 if PdhGetFormattedCounterValue fails

   993  */

   994 static int

   995 getPerformanceData(UpdateQueryP query, HCOUNTER c, PDH_FMT_COUNTERVALUE* value, DWORD format) {

   996     clock_t now = clock();

   997 

   998     /*

   999      * Need to limit how often we update the query

  1000      * to minimize the Heisenberg effect.

  1001      * (PDH behaves erratically if the counters are

  1002      * queried too often, especially counters that

  1003      * store and use values from two consecutive updates,

  1004      * like cpu load.)

  1005      */

  1006     if (now - query->lastUpdate > MIN_UPDATE_INTERVAL) {

  1007         if (PdhCollectQueryData_i(query->query) != ERROR_SUCCESS) {

  1008             return -1;

  1009         }

  1010         query->lastUpdate = now;

  1011     }

  1012 

  1013     if (PdhGetFormattedCounterValue_i(c, format, NULL, value) != ERROR_SUCCESS) {

  1014         return -2;

  1015     }

  1016 

  1017     return 0;

  1018 }

  1019 

  1020 static int

  1021 allocateAndInitializePdhConstants() {

  1022     const char* pdhLocalizedProcessObject = NULL;

  1023     const char* pdhLocalizedIDProcessCounter = NULL;

  1024     size_t pdhIDProcessCounterFmtLen;

  1025     int currentQueryIndex;

  1026     int retValue = -1;

  1027 

  1028     assert(GetCurrentThreadId() == initializationLock.owningThread);

  1029 

  1030     assert(!pdhProcessImageName);

  1031     pdhProcessImageName = getPdhProcessImageName();

  1032     if (!pdhProcessImageName) {

  1033         goto end;

  1034     }

  1035 

  1036     pdhLocalizedProcessObject = getPdhLocalizedArtifact(PDH_PROCESS_IDX);

  1037     if (!pdhLocalizedProcessObject) {

  1038         goto end;

  1039     }

  1040 

  1041     pdhLocalizedIDProcessCounter = getPdhLocalizedArtifact(PDH_ID_PROCESS_IDX);

  1042     if (!pdhLocalizedIDProcessCounter) {

  1043         goto end;

  1044     }

  1045 

  1046     assert(!pdhIDProcessCounterFmt);

  1047 

  1048     pdhIDProcessCounterFmtLen = strlen(pdhProcessImageName);

  1049     pdhIDProcessCounterFmtLen += strlen(pdhLocalizedProcessObject);

  1050     pdhIDProcessCounterFmtLen += strlen(pdhLocalizedIDProcessCounter);

  1051     pdhIDProcessCounterFmtLen += PROCESS_OBJECT_INSTANCE_COUNTER_FMT_LEN;

  1052     pdhIDProcessCounterFmtLen += 2; // "%d"

  1053 

  1054     assert(pdhIDProcessCounterFmtLen < MAX_PATH);

  1055     pdhIDProcessCounterFmt = malloc(pdhIDProcessCounterFmtLen + 1);

  1056     if (!pdhIDProcessCounterFmt) {

  1057         goto end;

  1058     }

  1059 

  1060     /* "\Process(java#%d)\ID Process" */

  1061     _snprintf(pdhIDProcessCounterFmt,

  1062               pdhIDProcessCounterFmtLen,

  1063               PROCESS_OBJECT_INSTANCE_COUNTER_FMT,

  1064               pdhLocalizedProcessObject,

  1065               pdhProcessImageName,

  1066               "%d",

  1067               pdhLocalizedIDProcessCounter);

  1068 

  1069     pdhIDProcessCounterFmt[pdhIDProcessCounterFmtLen] = '\0';

  1070 

  1071     assert(0 == numberOfJavaProcessesAtInitialization);

  1072     currentQueryIndex = currentQueryIndexForProcess();

  1073     if (-1 == currentQueryIndex) {

  1074         goto end;

  1075     }

  1076 

  1077     numberOfJavaProcessesAtInitialization = currentQueryIndex + 1;

  1078     assert(numberOfJavaProcessesAtInitialization >= 1);

  1079 

  1080     retValue = 0;

  1081 

  1082   end:

  1083 

  1084     if (pdhLocalizedProcessObject) {

  1085         free((char*)pdhLocalizedProcessObject);

  1086     }

  1087 

  1088     if (pdhLocalizedIDProcessCounter) {

  1089         free((char*)pdhLocalizedIDProcessCounter);

  1090     }

  1091 

  1092     return retValue;

  1093 }

  1094 

  1095 static void

  1096 deallocatePdhConstants() {

  1097     assert(GetCurrentThreadId() == initializationLock.owningThread);

  1098 

  1099     if (pdhProcessImageName) {

  1100         free((char*)pdhProcessImageName);

  1101         pdhProcessImageName = NULL;

  1102     }

  1103 

  1104     if (pdhIDProcessCounterFmt) {

  1105       free(pdhIDProcessCounterFmt);

  1106       pdhIDProcessCounterFmt = NULL;

  1107     }

  1108 

  1109     numberOfJavaProcessesAtInitialization = 0;

  1110 }

  1111 

  1112 static int

  1113 initializeCPUCounters() {

  1114     SYSTEM_INFO si;

  1115     char* localizedProcessObject;

  1116     char* localizedProcessorTimeCounter;

  1117     int i;

  1118     int retValue = -1;

  1119 

  1120     assert(GetCurrentThreadId() == initializationLock.owningThread);

  1121 

  1122     assert(0 == numCpus);

  1123     GetSystemInfo(&si);

  1124     numCpus = si.dwNumberOfProcessors;

  1125     assert(numCpus >= 1);

  1126 

  1127     /* Initialize the denominator for the jvm load calculations */

  1128     assert(.0 == cpuFactor);

  1129     cpuFactor = numCpus * 100;

  1130 

  1131     if (lookupNameByIndex(PDH_PROCESS_IDX,

  1132                           &localizedProcessObject) == 0) {

  1133 

  1134         if (lookupNameByIndex(PDH_PROCESSOR_TIME_IDX,

  1135                               &localizedProcessorTimeCounter) == 0) {