/*

 * Copyright (c) 2003, 2015, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

#include "jni.h"

#include "jni_util.h"

#include "jlong.h"

#include "jvm.h"

#include "management_ext.h"

#include "com_sun_management_internal_OperatingSystemImpl.h"

#include <psapi.h>

#include <errno.h>

#include <stdlib.h>

#include <malloc.h>

#pragma warning (push,0)

#include <windows.h>

#pragma warning (pop)

#include <stdio.h>

#include <time.h>

#include <stdint.h>

#include <assert.h>

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

#pragma warning(push, 3)

#include <pdh.h>

#include <pdhmsg.h>

#include <process.h>

#pragma warning(pop)

typedef unsigned __int32 juint;

typedef unsigned __int64 julong;

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

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

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

}

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

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

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

}

static jlong jlong_from(jint h, jint l) {

    jlong result = 0; // initialization to avoid warning

    set_high(&result, h);

    set_low(&result,  l);

    return result;

}

static HANDLE main_process;

static void perfInit(void);

JNIEXPORT void JNICALL

Java_com_sun_management_internal_OperatingSystemImpl_initialize0

  (JNIEnv *env, jclass cls)

{

    main_process = GetCurrentProcess();

    perfInit();

}

JNIEXPORT jlong JNICALL

Java_com_sun_management_internal_OperatingSystemImpl_getCommittedVirtualMemorySize0

  (JNIEnv *env, jobject mbean)

{

    PROCESS_MEMORY_COUNTERS pmc;

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

        return (jlong)-1L;

    } else {

        return (jlong) pmc.PagefileUsage;

    }

}

JNIEXPORT jlong JNICALL

Java_com_sun_management_internal_OperatingSystemImpl_getTotalSwapSpaceSize0

  (JNIEnv *env, jobject mbean)

{

    MEMORYSTATUSEX ms;

    ms.dwLength = sizeof(ms);

    GlobalMemoryStatusEx(&ms);

    return (jlong) ms.ullTotalPageFile;

}

JNIEXPORT jlong JNICALL

Java_com_sun_management_internal_OperatingSystemImpl_getFreeSwapSpaceSize0

  (JNIEnv *env, jobject mbean)

{

    MEMORYSTATUSEX ms;

    ms.dwLength = sizeof(ms);

    GlobalMemoryStatusEx(&ms);

    return (jlong) ms.ullAvailPageFile;

}

JNIEXPORT jlong JNICALL

Java_com_sun_management_internal_OperatingSystemImpl_getProcessCpuTime0

  (JNIEnv *env, jobject mbean)

{

    FILETIME process_creation_time, process_exit_time,

             process_user_time, process_kernel_time;

    // Using static variables declared above

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

    GetProcessTimes(main_process, &process_creation_time,

                    &process_exit_time,

                    &process_kernel_time, &process_user_time);

    return (jlong_from(process_user_time.dwHighDateTime,

                        process_user_time.dwLowDateTime) +

            jlong_from(process_kernel_time.dwHighDateTime,

                        process_kernel_time.dwLowDateTime)) * 100;

}

JNIEXPORT jlong JNICALL

Java_com_sun_management_internal_OperatingSystemImpl_getFreePhysicalMemorySize0

  (JNIEnv *env, jobject mbean)

{

    MEMORYSTATUSEX ms;

    ms.dwLength = sizeof(ms);

    GlobalMemoryStatusEx(&ms);

    return (jlong) ms.ullAvailPhys;

}

JNIEXPORT jlong JNICALL

Java_com_sun_management_internal_OperatingSystemImpl_getTotalPhysicalMemorySize0

  (JNIEnv *env, jobject mbean)

{

    MEMORYSTATUSEX ms;

    ms.dwLength = sizeof(ms);

    GlobalMemoryStatusEx(&ms);

    return (jlong) ms.ullTotalPhys;

}

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

typedef PDH_STATUS (WINAPI *PdhAddCounterFunc)(

                           HQUERY      hQuery,

                           LPCSTR      szFullCounterPath,

                           DWORD       dwUserData,

                           HCOUNTER    *phCounter

                           );

typedef PDH_STATUS (WINAPI *PdhOpenQueryFunc)(

                           LPCWSTR     szDataSource,

                           DWORD       dwUserData,

                           HQUERY      *phQuery

                           );

typedef PDH_STATUS (WINAPI *PdhCollectQueryDataFunc)(

                           HQUERY      hQuery

                           );

typedef PDH_STATUS (WINAPI *PdhEnumObjectItemsFunc)(

                           LPCTSTR     szDataSource,

                           LPCTSTR     szMachineName,

                           LPCTSTR     szObjectName,

                           LPTSTR      mszCounterList,

                           LPDWORD     pcchCounterListLength,

                           LPTSTR      mszInstanceList,

                           LPDWORD     pcchInstanceListLength,

                           DWORD       dwDetailLevel,

                           DWORD       dwFlags

                           );

typedef PDH_STATUS (WINAPI *PdhRemoveCounterFunc)(

                           HCOUNTER   hCounter

                           );

typedef PDH_STATUS (WINAPI *PdhLookupPerfNameByIndexFunc)(

                           LPCSTR     szMachineName,

                           DWORD      dwNameIndex,

                           LPSTR      szNameBuffer,

                           LPDWORD    pcchNameBufferSize

                           );

typedef DWORD (WINAPI *PdhCloseQueryFunc)(

                      HQUERY      hQuery

                      );

typedef DWORD (WINAPI *PdhGetFormattedCounterValueFunc)(

                      HCOUNTER                hCounter,

                      DWORD                   dwFormat,

                      LPDWORD                 lpdwType,

                      PPDH_FMT_COUNTERVALUE   pValue

                      );

static PdhAddCounterFunc PdhAddCounter_i;

static PdhOpenQueryFunc PdhOpenQuery_i;

static PdhCloseQueryFunc PdhCloseQuery_i;

static PdhCollectQueryDataFunc PdhCollectQueryData_i;

static PdhGetFormattedCounterValueFunc PdhGetFormattedCounterValue_i;

static PdhEnumObjectItemsFunc PdhEnumObjectItems_i;

static PdhRemoveCounterFunc PdhRemoveCounter_i;

static PdhLookupPerfNameByIndexFunc PdhLookupPerfNameByIndex_i;

/*

 * Struct for PDH queries.

 */

typedef struct {

    HQUERY      query;

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

} UpdateQueryS, *UpdateQueryP;

// Min time between query updates (ticks)

static const int MIN_UPDATE_INTERVAL = 500;

/*

 * Struct for a PDH query with multiple counters.

 */

typedef struct {

    UpdateQueryS  query;

    HCOUNTER*     counters;

    int           noOfCounters;

} MultipleCounterQueryS, *MultipleCounterQueryP;

/*

 * Struct for a PDH query with a single counter.

 */

typedef struct {

    UpdateQueryS  query;

    HCOUNTER      counter;

} SingleCounterQueryS, *SingleCounterQueryP;

typedef struct {

    CRITICAL_SECTION cs;

    DWORD owningThread;

    DWORD recursionCount;

} PdhCriticalSectionS, *PdhCriticalSectionP;

static PdhCriticalSectionS initializationLock;

static void InitializePdhCriticalSection(PdhCriticalSectionP criticalSection) {

    assert(criticalSection);

    InitializeCriticalSection(&criticalSection->cs);

    criticalSection->owningThread = 0;

    criticalSection->recursionCount = 0;

}

static void EnterPdhCriticalSection(PdhCriticalSectionP criticalSection) {

    assert(criticalSection);

    EnterCriticalSection(&criticalSection->cs);

    criticalSection->recursionCount++;

    if (!criticalSection->owningThread) {

        criticalSection->owningThread = GetCurrentThreadId();

    }

}

static void LeavePdhCriticalSection(PdhCriticalSectionP criticalSection) {

    assert(criticalSection);

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

    assert(criticalSection->recursionCount >= 1);

    criticalSection->recursionCount--;

    if (!criticalSection->recursionCount) {

        criticalSection->owningThread = 0;

    }

    LeaveCriticalSection(&criticalSection->cs);

}

/*

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

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

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

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

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

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

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

 */

static const DWORD PDH_PROCESSOR_IDX = 238;

static const DWORD PDH_PROCESSOR_TIME_IDX = 6;

static const DWORD PDH_PROCESS_IDX = 230;

static const DWORD PDH_ID_PROCESS_IDX = 784;

/* useful pdh fmt's */

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

static const size_t OBJECT_COUNTER_FMT_LEN = 2;

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

static const size_t OBJECT_WITH_INSTANCES_COUNTER_FMT_LEN = 4;

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

static const size_t PROCESS_OBJECT_INSTANCE_COUNTER_FMT_LEN = 5;

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

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

static int numberOfJavaProcessesAtInitialization = 0;

/*

 * Currently used CPU queries/counters and variables

 */

static SingleCounterQueryP processTotalCPULoad = NULL;

static MultipleCounterQueryP multiCounterCPULoad = NULL;

static double cpuFactor = .0;

static DWORD  numCpus = 0;

/*

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

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

 */

static int

pdhFail(PDH_STATUS pdhStat) {

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

}

static const char*

allocateAndCopy(const char* const originalString) {

    size_t len;

    char* allocatedString;

    assert(originalString);

    len = strlen(originalString);

    allocatedString = malloc(len + 1);

    if (!allocatedString) {

        return NULL;

    }

    strncpy(allocatedString, originalString, len);

    allocatedString[len] = '\0';

    return allocatedString;

}

/*

 * Allocates memory into the supplied pointer and

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

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

 *

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

 * @param ppBuffer pointer to a char*.

 * @return         0 if successful, negative on failure.

 */

static int

lookupNameByIndex(DWORD index, char** ppBuffer) {

    DWORD size;

    assert(ppBuffer);

    /* determine size needed */

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

      /* invalid index? */

      return -1;

    }

    *ppBuffer = malloc((size_t)size);

    if (!*ppBuffer) {

        return -1;

    }

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

        free(*ppBuffer);

        *ppBuffer = NULL;

        return -1;

    }

    /* windows vista does not null-terminate the string

     * (although the docs says it will) */

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

    return 0;

}

/*

* Construct a fully qualified PDH path

*

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

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

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

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

* @return             the fully qualified PDH path.

*

* Caller will own the returned malloc:ed string

*/

static const char*

makeFullCounterPath(const char* const objectName,

                    const char* const counterName,

                    const char* const imageName,

                    const char* const instance) {

    size_t fullCounterPathLen;

    char* fullCounterPath;

    assert(objectName);

    assert(counterName);

    fullCounterPathLen = strlen(objectName);

    fullCounterPathLen += strlen(counterName);

    if (imageName) {

        /*

         * For paths using the "Process" Object.

         *

         * Examples:

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

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

         */

        fullCounterPathLen += PROCESS_OBJECT_INSTANCE_COUNTER_FMT_LEN;

        fullCounterPathLen += strlen(imageName);

        /*

         * imageName must be passed together with an associated

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

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

         *

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

         */

        assert(instance);

        fullCounterPathLen += strlen(instance);

        fullCounterPath = malloc(fullCounterPathLen + 1);

        if (!fullCounterPath) {

            return NULL;

        }

        _snprintf(fullCounterPath,

                  fullCounterPathLen,

                  PROCESS_OBJECT_INSTANCE_COUNTER_FMT,

                  objectName,

                  imageName,

                  instance,

                  counterName);

    } else {

        if (instance) {

            /*

             * For paths where the Object has multiple instances.

             *

             * Examples:

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

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

             */

            fullCounterPathLen += strlen(instance);

            fullCounterPathLen += OBJECT_WITH_INSTANCES_COUNTER_FMT_LEN;

        } else {

            /*

             * For "normal" paths.

             *

             * Examples:

             * abstract: "\Object\Counter"

             * actual:   "\Memory\Available Mbytes"

             */

            fullCounterPathLen += OBJECT_COUNTER_FMT_LEN;

        }

        fullCounterPath = malloc(fullCounterPathLen + 1);

        if (!fullCounterPath) {

            return NULL;

        }

        if (instance) {

            _snprintf(fullCounterPath,

                      fullCounterPathLen,

                      OBJECT_WITH_INSTANCES_COUNTER_FMT,

                      objectName,

                      instance,

                      counterName);

        } else {

            _snprintf(fullCounterPath,

                      fullCounterPathLen,

                      OBJECT_COUNTER_FMT,

                      objectName,

                      counterName);

        }

    }

    fullCounterPath[fullCounterPathLen] = '\0';

    return fullCounterPath;

}

/*

 * Resolves an index for a PDH artifact to