/*

 * Copyright (c) 2003, 2011, 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.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;

typedef enum boolean_values { false=0, true=1};

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;

int perfiInit(void);

JNIEXPORT void JNICALL

  (JNIEnv *env, jclass cls)

{

    main_process = GetCurrentProcess();

     perfiInit();

}

JNIEXPORT jlong JNICALL

  (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

  (JNIEnv *env, jobject mbean)

{

    MEMORYSTATUSEX ms;

    ms.dwLength = sizeof(ms);

    GlobalMemoryStatusEx(&ms);

    return (jlong) ms.ullTotalPageFile;

}

JNIEXPORT jlong JNICALL

  (JNIEnv *env, jobject mbean)

{

    MEMORYSTATUSEX ms;

    ms.dwLength = sizeof(ms);

    GlobalMemoryStatusEx(&ms);

    return (jlong) ms.ullAvailPageFile;

}

JNIEXPORT jlong JNICALL

  (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

  (JNIEnv *env, jobject mbean)

{

    MEMORYSTATUSEX ms;

    ms.dwLength = sizeof(ms);

    GlobalMemoryStatusEx(&ms);

    return (jlong) ms.ullAvailPhys;

}

JNIEXPORT jlong JNICALL

  (JNIEnv *env, jobject mbean)

{

    MEMORYSTATUSEX ms;

    ms.dwLength = sizeof(ms);

    GlobalMemoryStatusEx(&ms);

    return (jlong) ms.ullTotalPhys;

}

// 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

pdh_fail(PDH_STATUS pdhStat) {

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

}

// 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.

#define PDH_PROCESSOR_IDX        ((DWORD) 238)

#define PDH_PROCESSOR_TIME_IDX        ((DWORD)   6)

#define PDH_PRIV_PROCESSOR_TIME_IDX ((DWORD) 144)

#define PDH_PROCESS_IDX            ((DWORD) 230)

#define PDH_ID_PROCESS_IDX        ((DWORD) 784)

#define PDH_CONTEXT_SWITCH_RATE_IDX ((DWORD) 146)

#define PDH_SYSTEM_IDX            ((DWORD)   2)

#define PDH_VIRTUAL_BYTES_IDX        ((DWORD) 174)

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 DWORD (WINAPI *PdhCloseQueryFunc)(

                      HQUERY      hQuery

                      );

typedef PDH_STATUS (WINAPI *PdhCollectQueryDataFunc)(

                             HQUERY      hQuery

                             );

typedef DWORD (WINAPI *PdhGetFormattedCounterValueFunc)(

                            HCOUNTER                hCounter,

                            DWORD                   dwFormat,

                            LPDWORD                 lpdwType,

                            PPDH_FMT_COUNTERVALUE   pValue

                            );

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 PDH_STATUS (WINAPI *PdhMakeCounterPathFunc)(

                            PDH_COUNTER_PATH_ELEMENTS *pCounterPathElements,

                            LPTSTR szFullPathBuffer,

                            LPDWORD pcchBufferSize,

                            DWORD dwFlags

                            );

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;

static PdhMakeCounterPathFunc PdhMakeCounterPath_i;

static HANDLE thisProcess;

static double cpuFactor;

static DWORD  num_cpus;

#define FT2JLONG(X)  ((((jlong)X.dwHighDateTime) << 32) | ((jlong)X.dwLowDateTime))

#define COUNTER_BUF_SIZE 256

// Min time between query updates.

#define MIN_UPDATE_INTERVAL 500

#define CONFIG_SUCCESSFUL 0

/**

 * Struct for PDH queries.

 */

typedef struct {

    HQUERY      query;

    uint64_t      lastUpdate; // Last time query was updated (current millis).

} UpdateQueryS, *UpdateQueryP;

/**

 * Struct for the processor load counters.

 */

typedef struct {

    UpdateQueryS      query;

    HCOUNTER*      counters;

    int          noOfCounters;

} MultipleCounterQueryS, *MultipleCounterQueryP;

/**

 * Struct for the jvm process load counter.

 */

typedef struct {

    UpdateQueryS      query;

    HCOUNTER      counter;

} SingleCounterQueryS, *SingleCounterQueryP;

static char* getProcessPDHHeader(void);

/**

 * Currently available counters.

 */

static SingleCounterQueryS cntCtxtSwitchRate;

static SingleCounterQueryS cntVirtualSize;

static SingleCounterQueryS cntProcLoad;

static SingleCounterQueryS cntProcSystemLoad;

static MultipleCounterQueryS multiCounterCPULoad;

static CRITICAL_SECTION processHeaderLock;

static CRITICAL_SECTION initializationLock;

/**

 * Initialize the perf module at startup.

 */

int

perfiInit(void)

{

    InitializeCriticalSection(&processHeaderLock);

    InitializeCriticalSection(&initializationLock);

    return 0;

}

/**

 * Dynamically sets up function pointers to the PDH library.

 *

 * @return CONFIG_SUCCESSFUL on success, negative on failure.

 */

static int

get_functions(HMODULE h, char *ebuf, size_t elen) {

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

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

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

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

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

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

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

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

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

    PdhMakeCounterPath_i         = (PdhMakeCounterPathFunc)GetProcAddress(h, "PdhMakeCounterPathA");

    if (PdhAddCounter_i == NULL || PdhOpenQuery_i == NULL ||

    PdhCloseQuery_i == NULL || PdhCollectQueryData_i == NULL ||

    PdhGetFormattedCounterValue_i == NULL || PdhEnumObjectItems_i == NULL ||

    PdhRemoveCounter_i == NULL || PdhLookupPerfNameByIndex_i == NULL || PdhMakeCounterPath_i == NULL)

    {

        _snprintf(ebuf, elen, "Required method could not be found.");

        return -1;

    }

    return CONFIG_SUCCESSFUL;

}

/**

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

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

 *

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

 * @param c          the counter to read.

 * @param value       where to store the formatted value.

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

 * @return            CONFIG_SUCCESSFUL if no error

 *                    -1 if PdhCollectQueryData fails

 *                    -2 if PdhGetFormattedCounterValue fails

 */

static int

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

    clock_t now;

    now = clock();

    // Need to limit how often we update the query

    // to mimise the heisenberg effect.

    // (PDH behaves erratically if the counters are

    // queried too often, especially counters that

    // store and use values from two consecutive updates,

    // like cpu load.)

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

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

            return -1;

        }

        query->lastUpdate = now;

    }

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

        return -2;

    }

    return CONFIG_SUCCESSFUL;

}

/**

 * Places the resolved counter name of the counter at the specified index in the

 * supplied buffer. There must be enough space in the buffer to hold the counter name.

 *

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

 * @param buf     the buffer in which to place the counter name.

 * @param size      the size of the counter name buffer.

 * @param ebuf    the error message buffer.

 * @param elen    the length of the error buffer.

 * @return        CONFIG_SUCCESSFUL if successful, negative on failure.

 */

static int

find_name(DWORD index, char *buf, DWORD size) {

    PDH_STATUS res;

    if ((res = PdhLookupPerfNameByIndex_i(NULL, index, buf, &size)) != ERROR_SUCCESS) {

        /* printf("Could not open counter %d: error=0x%08x", index, res); */

        /* if (res == PDH_CSTATUS_NO_MACHINE) { */

        /*      printf("User probably does not have sufficient privileges to use"); */

        /*      printf("performance counters. If you are running on Windows 2003"); */

        /*      printf("or Windows Vista, make sure the user is in the"); */

        /*      printf("Performance Logs user group."); */

        /* } */

        return -1;

    }

    if (size == 0) {

        /* printf("Failed to get counter name for %d: empty string", index); */

        return -1;

    }

    // windows vista does not null-terminate the string (allthough the docs says it will)

    buf[size - 1] = '\0';

    return CONFIG_SUCCESSFUL;

}

/**

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

 * initPDH() must have been run prior to calling this function!

 *

 * @param counterQuery   the counter query to set up.

 * @param counterString  the string specifying the path to the counter.

 * @param ebuf           the error buffer.

 * @param elen           the length of the error buffer.

 * @returns              CONFIG_SUCCESSFUL if successful, negative on failure.

 */

static int

initSingleCounterQuery(SingleCounterQueryP counterQuery, char *counterString) {

    if (PdhOpenQuery_i(NULL, 0, &counterQuery->query.query) != ERROR_SUCCESS) {

        /* printf("Could not open query for %s", counterString); */

        return -1;

    }

    if (PdhAddCounter_i(counterQuery->query.query, counterString, 0, &counterQuery->counter) != ERROR_SUCCESS) {

        /* printf("Could not add counter %s for query", counterString); */

        if (counterQuery->counter != NULL) {

            PdhRemoveCounter_i(counterQuery->counter);

        }

        if (counterQuery->query.query != NULL) {

            PdhCloseQuery_i(counterQuery->query.query);

        }

        memset(counterQuery, 0, sizeof(SingleCounterQueryS));

        return -1;

    }

    return CONFIG_SUCCESSFUL;

}

/**

 * Sets up the supplied SingleCounterQuery to listen for the time spent

 * by the HotSpot process.

 *

 * @param counterQuery   the counter query to set up as a process counter.

 * @param ebuf           the error buffer.

 * @param elen           the length of the error buffer.

 * @returns              CONFIG_SUCCESSFUL if successful, negative on failure.

 */

static int

initProcLoadCounter(void) {

    char time[COUNTER_BUF_SIZE];

    char counter[COUNTER_BUF_SIZE*2];

    if (find_name(PDH_PROCESSOR_TIME_IDX, time, sizeof(time)-1) < 0) {

        return -1;

    }

    _snprintf(counter, sizeof(counter)-1, "%s\\%s", getProcessPDHHeader(), time);

    return initSingleCounterQuery(&cntProcLoad, counter);

}

static int

initProcSystemLoadCounter(void) {

    char time[COUNTER_BUF_SIZE];

    char counter[COUNTER_BUF_SIZE*2];

    if (find_name(PDH_PRIV_PROCESSOR_TIME_IDX, time, sizeof(time)-1) < 0) {

        return -1;

    }

    _snprintf(counter, sizeof(counter)-1, "%s\\%s", getProcessPDHHeader(), time);

    return initSingleCounterQuery(&cntProcSystemLoad, counter);

}

/**

 * Sets up the supplied MultipleCounterQuery to check on the processors.

 * (Comment: Refactor and prettify as with the the SingleCounter queries

 * if more MultipleCounterQueries are discovered.)

 *

 * initPDH() must have been run prior to calling this function.

 *

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

 *                    the necessary info to check the PDH processor counters.

 * @return            CONFIG_SUCCESSFUL if successful, negative on failure.

 */

static int

initProcessorCounters(void) {

    char          processor[COUNTER_BUF_SIZE]; //'Processor' == #238

    char          time[COUNTER_BUF_SIZE];      //'Time' == 6

    DWORD      c_size, i_size;

    HQUERY     tmpQuery;

    DWORD      i, p_count;

    BOOL          error;

    char         *instances, *tmp;

    PDH_STATUS pdhStat;

    c_size   = i_size = 0;

    tmpQuery = NULL;

    error    = false;

    // This __try / __except stuff is there since Windows 2000 beta (or so) sometimes triggered

    // an access violation when the user had insufficient privileges to use the performance

    // counters. This was previously guarded by a very ugly piece of code which disabled the

    // global trap handling in JRockit. Don't know if this really is needed anymore, but otoh,

    // if we keep it we don't crash on Win2k beta. /Ihse, 2005-05-30

    __try {

        if (find_name(PDH_PROCESSOR_IDX, processor, sizeof(processor)-1) < 0) {

            return -1;

        }