/*

 * Copyright (c) 2012, 2019, 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.

 *

 * 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 "precompiled.hpp"

#include "iphlp_interface.hpp"

#include "logging/log.hpp"

#include "memory/allocation.inline.hpp"

#include "memory/resourceArea.hpp"

#include "pdh_interface.hpp"

#include "runtime/os_perf.hpp"

#include "runtime/os.hpp"

#include "utilities/macros.hpp"

#include "vm_version_ext_x86.hpp"

#include <math.h>

#include <psapi.h>

#include <TlHelp32.h>

/*

 * Windows provides a vast plethora of performance objects and counters,

 * consumption of which is assisted using the Performance Data Helper (PDH) interface.

 * We import a selected few api entry points from PDH, see pdh_interface.hpp.

 *

 * The code located in this file is to a large extent an abstraction over much of the

 * plumbing needed to start consuming an object and/or counter of choice.

 *

 */

 /*

 * How to use:

 * 1. Create query

 * 2. Add counters to the query

 * 3. Collect the performance data using the query

 * 4. Display the performance data using the counters associated with the query

 * 5. Destroy query (counter destruction implied)

 */

/*

 * Every PDH artifact, like processor, process, thread, memory, and so forth are

 * identified with an index that is always the same irrespective

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

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

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

 *

 * 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]

 *

 * some common PDH indexes

 */

static const DWORD PDH_PROCESSOR_IDX = 238;

static const DWORD PDH_PROCESSOR_TIME_IDX = 6;

static const DWORD PDH_PRIV_PROCESSOR_TIME_IDX = 144;

static const DWORD PDH_PROCESS_IDX = 230;

static const DWORD PDH_ID_PROCESS_IDX = 784;

static const DWORD PDH_CONTEXT_SWITCH_RATE_IDX = 146;

static const DWORD PDH_SYSTEM_IDX = 2;

/* 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* process_image_name = NULL; // for example, "java" but could have another image name

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

// Need to limit how often we update a query to minimize 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.)

static const int min_update_interval_millis = 500;

/*

* Structs for PDH queries.

*/

typedef struct {

  HQUERY query;

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

} UpdateQueryS, *UpdateQueryP;

typedef struct {

  UpdateQueryS query;

  HCOUNTER     counter;

  bool         initialized;

} CounterQueryS, *CounterQueryP;

typedef struct {

  UpdateQueryS query;

  HCOUNTER*    counters;

  int          noOfCounters;

  bool         initialized;

} MultiCounterQueryS, *MultiCounterQueryP;

typedef struct {

  MultiCounterQueryP queries;

  int                size;

  bool               initialized;

} MultiCounterQuerySetS, *MultiCounterQuerySetP;

typedef struct {

  MultiCounterQuerySetS set;

  int                   process_index;

} ProcessQueryS, *ProcessQueryP;

static void pdh_cleanup(HQUERY* const query, HCOUNTER* const counter) {

  if (counter != NULL && *counter != NULL) {

    PdhDll::PdhRemoveCounter(*counter);

    *counter = NULL;

  }

  if (query != NULL && *query != NULL) {

    PdhDll::PdhCloseQuery(*query);

    *query = NULL;

  }

}

static CounterQueryP create_counter_query() {

  CounterQueryP const query = NEW_C_HEAP_OBJ(CounterQueryS, mtInternal);

  memset(query, 0, sizeof(CounterQueryS));

  return query;

}

static void destroy_counter_query(CounterQueryP query) {

  assert(query != NULL, "invariant");

  pdh_cleanup(&query->query.query, &query->counter);

  FREE_C_HEAP_OBJ(query);

}

static MultiCounterQueryP create_multi_counter_query() {

  MultiCounterQueryP const query = NEW_C_HEAP_ARRAY(MultiCounterQueryS, 1, mtInternal);

  memset(query, 0, sizeof(MultiCounterQueryS));

  return query;

}

static void destroy_counter_query(MultiCounterQueryP counter_query) {

  if (counter_query != NULL) {

    for (int i = 0; i < counter_query->noOfCounters; ++i) {

      pdh_cleanup(NULL, &counter_query->counters[i]);

    }

    FREE_C_HEAP_ARRAY(char, counter_query->counters);

    pdh_cleanup(&counter_query->query.query, NULL);

    FREE_C_HEAP_ARRAY(MultiCounterQueryS, counter_query);

  }

}

static void destroy_multi_counter_query(MultiCounterQuerySetP counter_query_set) {

  for (int i = 0; i < counter_query_set->size; i++) {

    for (int j = 0; j < counter_query_set->queries[i].noOfCounters; ++j) {

      pdh_cleanup(NULL, &counter_query_set->queries[i].counters[j]);

    }

    FREE_C_HEAP_ARRAY(char, counter_query_set->queries[i].counters);

    pdh_cleanup(&counter_query_set->queries[i].query.query, NULL);

  }

  FREE_C_HEAP_ARRAY(MultiCounterQueryS, counter_query_set->queries);

}

static void destroy_counter_query(MultiCounterQuerySetP counter_query_set) {

  destroy_multi_counter_query(counter_query_set);

  FREE_C_HEAP_ARRAY(MultiCounterQuerySetS, counter_query_set);

}

static void destroy_counter_query(ProcessQueryP process_query) {

  destroy_multi_counter_query(&process_query->set);

  FREE_C_HEAP_OBJ(process_query);

}

static int open_query(HQUERY* query) {

  return PdhDll::PdhOpenQuery(NULL, 0, query);

}

template <typename QueryP>

static int open_query(QueryP query) {

  return open_query(&query->query);

}

static void allocate_counters(MultiCounterQueryP query, size_t nofCounters) {

  assert(query != NULL, "invariant");

  assert(!query->initialized, "invariant");

  assert(0 == query->noOfCounters, "invariant");

  assert(query->counters == NULL, "invariant");

  query->counters = NEW_C_HEAP_ARRAY(HCOUNTER, nofCounters, mtInternal);

  memset(query->counters, 0, nofCounters * sizeof(HCOUNTER));

  query->noOfCounters = (int)nofCounters;

}

static void allocate_counters(MultiCounterQuerySetP query_set, size_t nofCounters) {

  assert(query_set != NULL, "invariant");

  assert(!query_set->initialized, "invariant");

  for (int i = 0; i < query_set->size; ++i) {

    allocate_counters(&query_set->queries[i], nofCounters);

  }

}

static void allocate_counters(ProcessQueryP process_query, size_t nofCounters) {

  assert(process_query != NULL, "invariant");

  allocate_counters(&process_query->set, nofCounters);

}

static void deallocate_counters(MultiCounterQueryP query) {

  FREE_C_HEAP_ARRAY(char, query->counters);

  query->counters = NULL;

  query->noOfCounters = 0;

}

static OSReturn add_counter(UpdateQueryP query, HCOUNTER* counter, const char* path, bool first_sample_on_init) {

  assert(query != NULL, "invariant");

  assert(counter != NULL, "invariant");

  assert(path != NULL, "invariant");

  if (query->query == NULL) {

    if (open_query(query) != ERROR_SUCCESS) {

      return OS_ERR;

    }

  }

  assert(query->query != NULL, "invariant");

  PDH_STATUS status = PdhDll::PdhAddCounter(query->query, path, 0, counter);

  if (PDH_CSTATUS_NO_OBJECT == status || PDH_CSTATUS_NO_COUNTER == status) {

    return OS_ERR;

  }

  /*

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

  *

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

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

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

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

  *

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

  *  to succeed.

  */

  if (first_sample_on_init) {

    PdhDll::PdhCollectQueryData(query->query);

  }

  return OS_OK;

}

template <typename QueryP>

static OSReturn add_counter(QueryP counter_query, HCOUNTER* counter, const char* path, bool first_sample_on_init) {

  assert(counter_query != NULL, "invariant");

  assert(counter != NULL, "invariant");

  assert(path != NULL, "invariant");

  return add_counter(&counter_query->query, counter, path, first_sample_on_init);

}

static OSReturn add_counter(CounterQueryP counter_query, const char* path, bool first_sample_on_init) {

  if (add_counter(counter_query, &counter_query->counter, path, first_sample_on_init) != OS_OK) {

    // performance counter might be disabled in the registry

    return OS_ERR;

  }

  counter_query->initialized = true;

  return OS_OK;

}

static OSReturn add_process_counter(MultiCounterQueryP query, int slot_index, const char* path, bool first_sample_on_init) {

  assert(query != NULL, "invariant");

  assert(slot_index < query->noOfCounters, "invariant");

  assert(query->counters[slot_index] == NULL, "invariant");

  const OSReturn ret = add_counter(query, &query->counters[slot_index], path, first_sample_on_init);

  if (OS_OK == ret) {

    if (slot_index + 1 == query->noOfCounters) {

      query->initialized = true;

    }

  }

  return ret;

}

static int collect_query_data(UpdateQueryP update_query) {

  assert(update_query != NULL, "invariant");

  const s8 now = os::javaTimeMillis();

  if (now - update_query->lastUpdate > min_update_interval_millis) {

    if (PdhDll::PdhCollectQueryData(update_query->query) != ERROR_SUCCESS) {

      return OS_ERR;

    }

    update_query->lastUpdate = now;

  }

  return OS_OK;

}

template <typename Query>

static int collect_query_data(Query* counter_query) {

  assert(counter_query != NULL, "invariant");

  return collect_query_data(&counter_query->query);

}

static int formatted_counter_value(HCOUNTER counter, DWORD format, PDH_FMT_COUNTERVALUE* const value) {

  assert(value != NULL, "invariant");

  if (PdhDll::PdhGetFormattedCounterValue(counter, format, NULL, value) != ERROR_SUCCESS) {

    return OS_ERR;

  }

  return OS_OK;

}

/*

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

* when using the PDH API:

*

* Using PDH, a process is not primarily identified by the process id,

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

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

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

*

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

* a query, but as soon as the list resets, the query is invalidated (since the name changed).

*

* Solution:

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

*

* We therefore create an array of counter queries for all process object instances

* up to and including ourselves:

*

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

* queries for the following Process object instances:

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

*

* current_query_index_for_process() keeps track of the current "correct" query

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

* ensure to call current_query_index_for_process() before every query involving

* Process object instance data).

*

* if unable to query, returns OS_ERR(-1)

*/

static int current_query_index_for_process() {

  assert(process_image_name != NULL, "invariant");

  assert(pdh_IDProcess_counter_fmt != NULL, "invariant");

  HQUERY tmpQuery = NULL;

  if (open_query(&tmpQuery) != ERROR_SUCCESS) {

    return OS_ERR;

  }

  char counter[512];

  HCOUNTER handle_counter = NULL;

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

  for (int index = 0; index < max_intx; index++) {

    jio_snprintf(counter, sizeof(counter) - 1, pdh_IDProcess_counter_fmt, index);

    assert(strlen(counter) < sizeof(counter), "invariant");

    if (PdhDll::PdhAddCounter(tmpQuery, counter, 0, &handle_counter) != ERROR_SUCCESS) {

      pdh_cleanup(&tmpQuery, &handle_counter);

      return OS_ERR;

    }

    const PDH_STATUS res = PdhDll::PdhCollectQueryData(tmpQuery);

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

      pdh_cleanup(&tmpQuery, &handle_counter);

      return OS_ERR;

    } else {

      PDH_FMT_COUNTERVALUE counter_value;

      formatted_counter_value(handle_counter, PDH_FMT_LONG, &counter_value);

      pdh_cleanup(NULL, &handle_counter);

      if ((LONG)os::current_process_id() == counter_value.longValue) {

        pdh_cleanup(&tmpQuery, NULL);

        return index;

      }

    }

  }

  pdh_cleanup(&tmpQuery, NULL);

  return OS_ERR;

}

static ProcessQueryP create_process_query() {

  const int current_process_idx = current_query_index_for_process();

  if (OS_ERR == current_process_idx) {

    return NULL;

  }

  ProcessQueryP const process_query = NEW_C_HEAP_OBJ(ProcessQueryS, mtInternal);

  memset(process_query, 0, sizeof(ProcessQueryS));

  process_query->set.queries = NEW_C_HEAP_ARRAY(MultiCounterQueryS, current_process_idx + 1, mtInternal);

  memset(process_query->set.queries, 0, sizeof(MultiCounterQueryS) * (current_process_idx + 1));

  process_query->process_index = current_process_idx;

  process_query->set.size = current_process_idx + 1;

  assert(process_query->set.size > process_query->process_index, "invariant");

  return process_query;

}

static MultiCounterQueryP current_process_counter_query(ProcessQueryP process_query) {

  assert(process_query != NULL, "invariant");

  assert(process_query->process_index < process_query->set.size, "invariant");

  return &process_query->set.queries[process_query->process_index];

}

static void clear_multi_counter(MultiCounterQueryP query) {

  for (int i = 0; i < query->noOfCounters; ++i) {

    pdh_cleanup(NULL, &query->counters[i]);

  }

  pdh_cleanup(&query->query.query, NULL);

  query->initialized = false;

}

static int ensure_valid_process_query_index(ProcessQueryP process_query) {

  assert(process_query != NULL, "invariant");

  const int previous_process_idx = process_query->process_index;

  if (previous_process_idx == 0) {

    return previous_process_idx;

  }

  const int current_process_idx = current_query_index_for_process();

  if (current_process_idx == previous_process_idx || OS_ERR == current_process_idx ||

    current_process_idx >= process_query->set.size) {

    return previous_process_idx;

  }

  assert(current_process_idx >= 0 && current_process_idx < process_query->set.size, "out of bounds!");

  while (current_process_idx < process_query->set.size - 1) {

    const int new_size = --process_query->set.size;

    clear_multi_counter(&process_query->set.queries[new_size]);

  }

  assert(current_process_idx < process_query->set.size, "invariant");

  process_query->process_index = current_process_idx;

  return current_process_idx;

}

static MultiCounterQueryP current_process_query(ProcessQueryP process_query) {

  assert(process_query != NULL, "invariant");

  const int current_process_idx = ensure_valid_process_query_index(process_query);

  assert(current_process_idx == process_query->process_index, "invariant");

  assert(current_process_idx < process_query->set.size, "invariant");

  return &process_query->set.queries[current_process_idx];

}

static int collect_process_query_data(ProcessQueryP process_query) {

  assert(process_query != NULL, "invariant");

  return collect_query_data(current_process_query(process_query));

}

static int query_process_counter(ProcessQueryP process_query, int slot_index, DWORD format, PDH_FMT_COUNTERVALUE* const value) {

  MultiCounterQueryP const current_query = current_process_counter_query(process_query);

  assert(current_query != NULL, "invariant");

  assert(slot_index < current_query->noOfCounters, "invariant");

  assert(current_query->counters[slot_index] != NULL, "invariant");

  return formatted_counter_value(current_query->counters[slot_index], format, value);

}

/*

 * 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 need a ResourceMark.

 *

 * (PdhMakeCounterPath() seems buggy on concatenating instances, hence this function instead)

 */

static const char* make_fully_qualified_counter_path(const char* object_name,

                                                     const char* counter_name,

                                                     const char* image_name = NULL,

                                                     const char* instance = NULL) {

  assert(object_name != NULL, "invariant");

  assert(counter_name != NULL, "invariant");

  size_t full_counter_path_len = strlen(object_name) + strlen(counter_name);

  char* full_counter_path;

  size_t jio_snprintf_result = 0;

  if (image_name) {

    /*

    * For paths using the "Process" Object.

    *

    * Examples:

    * form:   "\object_name(image_name#instance)\counter_name"

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

    */

    full_counter_path_len += PROCESS_OBJECT_INSTANCE_COUNTER_FMT_LEN;

    full_counter_path_len += strlen(image_name);

    /*

    * image_name 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 != NULL, "invariant");

    full_counter_path_len += strlen(instance);

    full_counter_path = NEW_RESOURCE_ARRAY_RETURN_NULL(char, full_counter_path_len + 1);

    if (full_counter_path == NULL) {

      return NULL;

    }

    jio_snprintf_result = jio_snprintf(full_counter_path,

                                       full_counter_path_len + 1,

                                       PROCESS_OBJECT_INSTANCE_COUNTER_FMT,

                                       object_name,

                                       image_name,

                                       instance,

                                       counter_name);

  } else {

    if (instance) {

      /*

      * For paths where the Object has multiple instances.

      *

      * Examples:

      * form:   "\object_name(instance)\counter_name"

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

      */

      full_counter_path_len += strlen(instance);

      full_counter_path_len += OBJECT_WITH_INSTANCES_COUNTER_FMT_LEN;

    } else {

      /*

      * For "normal" paths.

      *

      * Examples:

      * form:   "\object_name\counter_name"