1 /*
2 * Copyright (c) 2012, 2019, 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.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "iphlp_interface.hpp"
27 #include "logging/log.hpp"
28 #include "memory/allocation.inline.hpp"
29 #include "memory/resourceArea.hpp"
30 #include "pdh_interface.hpp"
31 #include "runtime/os_perf.hpp"
32 #include "runtime/os.hpp"
33 #include "utilities/macros.hpp"
34 #include "vm_version_ext_x86.hpp"
35 #include <math.h>
36 #include <psapi.h>
37 #include <TlHelp32.h>
38
39 /*
40 * Windows provides a vast plethora of performance objects and counters,
41 * consumption of which is assisted using the Performance Data Helper (PDH) interface.
42 * We import a selected few api entry points from PDH, see pdh_interface.hpp.
43 *
44 * The code located in this file is to a large extent an abstraction over much of the
45 * plumbing needed to start consuming an object and/or counter of choice.
46 *
47 */
48
49 /*
50 * How to use:
51 * 1. Create query
52 * 2. Add counters to the query
53 * 3. Collect the performance data using the query
54 * 4. Display the performance data using the counters associated with the query
55 * 5. Destroy query (counter destruction implied)
56 */
57
58 /*
59 * Every PDH artifact, like processor, process, thread, memory, and so forth are
60 * identified with an index that is always the same irrespective
61 * of the localized version of the operating system or service pack installed.
62 * INFO: Using PDH APIs Correctly in a Localized Language (Q287159)
63 * http://support.microsoft.com/default.aspx?scid=kb;EN-US;q287159
64 *
65 * To find the correct index for an object or counter, inspect the registry key / value:
66 * [HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Perflib\009\Counter]
67 *
68 * some common PDH indexes
69 */
70 static const DWORD PDH_PROCESSOR_IDX = 238;
71 static const DWORD PDH_PROCESSOR_TIME_IDX = 6;
72 static const DWORD PDH_PRIV_PROCESSOR_TIME_IDX = 144;
73 static const DWORD PDH_PROCESS_IDX = 230;
74 static const DWORD PDH_ID_PROCESS_IDX = 784;
75 static const DWORD PDH_CONTEXT_SWITCH_RATE_IDX = 146;
76 static const DWORD PDH_SYSTEM_IDX = 2;
77
78 /* useful pdh fmt's */
79 static const char* const OBJECT_COUNTER_FMT = "\\%s\\%s";
80 static const size_t OBJECT_COUNTER_FMT_LEN = 2;
81 static const char* const OBJECT_WITH_INSTANCES_COUNTER_FMT = "\\%s(%s)\\%s";
82 static const size_t OBJECT_WITH_INSTANCES_COUNTER_FMT_LEN = 4;
83 static const char* const PROCESS_OBJECT_INSTANCE_COUNTER_FMT = "\\%s(%s#%s)\\%s";
84 static const size_t PROCESS_OBJECT_INSTANCE_COUNTER_FMT_LEN = 5;
85
86 static const char* process_image_name = NULL; // for example, "java" but could have another image name
87 static char* pdh_IDProcess_counter_fmt = NULL; // "\Process(java#%d)\ID Process" */
88
89 // Need to limit how often we update a query to minimize the heisenberg effect.
90 // (PDH behaves erratically if the counters are queried too often, especially counters that
91 // store and use values from two consecutive updates, like cpu load.)
92 static const int min_update_interval_millis = 500;
93
94 /*
95 * Structs for PDH queries.
96 */
97 typedef struct {
98 HQUERY query;
99 s8 lastUpdate; // Last time query was updated (current millis).
100 } UpdateQueryS, *UpdateQueryP;
101
102
103 typedef struct {
104 UpdateQueryS query;
105 HCOUNTER counter;
106 bool initialized;
107 } CounterQueryS, *CounterQueryP;
108
109 typedef struct {
110 UpdateQueryS query;
111 HCOUNTER* counters;
112 int noOfCounters;
113 bool initialized;
114 } MultiCounterQueryS, *MultiCounterQueryP;
115
116 typedef struct {
117 MultiCounterQueryP queries;
118 int size;
119 bool initialized;
120 } MultiCounterQuerySetS, *MultiCounterQuerySetP;
121
122 typedef struct {
123 MultiCounterQuerySetS set;
124 int process_index;
125 } ProcessQueryS, *ProcessQueryP;
126
127 static void pdh_cleanup(HQUERY* const query, HCOUNTER* const counter) {
128 if (counter != NULL && *counter != NULL) {
129 PdhDll::PdhRemoveCounter(*counter);
130 *counter = NULL;
131 }
132 if (query != NULL && *query != NULL) {
133 PdhDll::PdhCloseQuery(*query);
134 *query = NULL;
135 }
136 }
137
138 static CounterQueryP create_counter_query() {
139 CounterQueryP const query = NEW_C_HEAP_OBJ(CounterQueryS, mtInternal);
140 memset(query, 0, sizeof(CounterQueryS));
141 return query;
142 }
143
144 static void destroy_counter_query(CounterQueryP query) {
145 assert(query != NULL, "invariant");
146 pdh_cleanup(&query->query.query, &query->counter);
147 FREE_C_HEAP_OBJ(query);
148 }
149
150 static MultiCounterQueryP create_multi_counter_query() {
151 MultiCounterQueryP const query = NEW_C_HEAP_ARRAY(MultiCounterQueryS, 1, mtInternal);
152 memset(query, 0, sizeof(MultiCounterQueryS));
153 return query;
154 }
155
156 static void destroy_counter_query(MultiCounterQueryP counter_query) {
157 if (counter_query != NULL) {
158 for (int i = 0; i < counter_query->noOfCounters; ++i) {
159 pdh_cleanup(NULL, &counter_query->counters[i]);
160 }
161 FREE_C_HEAP_ARRAY(char, counter_query->counters);
162 pdh_cleanup(&counter_query->query.query, NULL);
163 FREE_C_HEAP_ARRAY(MultiCounterQueryS, counter_query);
164 }
165 }
166
167 static void destroy_multi_counter_query(MultiCounterQuerySetP counter_query_set) {
168 for (int i = 0; i < counter_query_set->size; i++) {
169 for (int j = 0; j < counter_query_set->queries[i].noOfCounters; ++j) {
170 pdh_cleanup(NULL, &counter_query_set->queries[i].counters[j]);
171 }
172 FREE_C_HEAP_ARRAY(char, counter_query_set->queries[i].counters);
173 pdh_cleanup(&counter_query_set->queries[i].query.query, NULL);
174 }
175 FREE_C_HEAP_ARRAY(MultiCounterQueryS, counter_query_set->queries);
176 }
177
178 static void destroy_counter_query(MultiCounterQuerySetP counter_query_set) {
179 destroy_multi_counter_query(counter_query_set);
180 FREE_C_HEAP_ARRAY(MultiCounterQuerySetS, counter_query_set);
181 }
182
183 static void destroy_counter_query(ProcessQueryP process_query) {
184 destroy_multi_counter_query(&process_query->set);
185 FREE_C_HEAP_OBJ(process_query);
186 }
187
188 static int open_query(HQUERY* query) {
189 return PdhDll::PdhOpenQuery(NULL, 0, query);
190 }
191
192 template <typename QueryP>
193 static int open_query(QueryP query) {
194 return open_query(&query->query);
195 }
196
197 static void allocate_counters(MultiCounterQueryP query, size_t nofCounters) {
198 assert(query != NULL, "invariant");
199 assert(!query->initialized, "invariant");
200 assert(0 == query->noOfCounters, "invariant");
201 assert(query->counters == NULL, "invariant");
202 query->counters = NEW_C_HEAP_ARRAY(HCOUNTER, nofCounters, mtInternal);
203 memset(query->counters, 0, nofCounters * sizeof(HCOUNTER));
204 query->noOfCounters = (int)nofCounters;
205 }
206
207 static void allocate_counters(MultiCounterQuerySetP query_set, size_t nofCounters) {
208 assert(query_set != NULL, "invariant");
209 assert(!query_set->initialized, "invariant");
210 for (int i = 0; i < query_set->size; ++i) {
211 allocate_counters(&query_set->queries[i], nofCounters);
212 }
213 }
214
215 static void allocate_counters(ProcessQueryP process_query, size_t nofCounters) {
216 assert(process_query != NULL, "invariant");
217 allocate_counters(&process_query->set, nofCounters);
218 }
219
220 static void deallocate_counters(MultiCounterQueryP query) {
221 FREE_C_HEAP_ARRAY(char, query->counters);
222 query->counters = NULL;
223 query->noOfCounters = 0;
224 }
225
226 static OSReturn add_counter(UpdateQueryP query, HCOUNTER* counter, const char* path, bool first_sample_on_init) {
227 assert(query != NULL, "invariant");
228 assert(counter != NULL, "invariant");
229 assert(path != NULL, "invariant");
230 if (query->query == NULL) {
231 if (open_query(query) != ERROR_SUCCESS) {
232 return OS_ERR;
233 }
234 }
235 assert(query->query != NULL, "invariant");
236 PDH_STATUS status = PdhDll::PdhAddCounter(query->query, path, 0, counter);
237 if (PDH_CSTATUS_NO_OBJECT == status || PDH_CSTATUS_NO_COUNTER == status) {
238 return OS_ERR;
239 }
240 /*
241 * According to the MSDN documentation, rate counters must be read twice:
242 *
243 * "Obtaining the value of rate counters such as Page faults/sec requires that
244 * PdhCollectQueryData be called twice, with a specific time interval between
245 * the two calls, before calling PdhGetFormattedCounterValue. Call Sleep to
246 * implement the waiting period between the two calls to PdhCollectQueryData."
247 *
248 * Take the first sample here already to allow for the next "real" sample
249 * to succeed.
250 */
251 if (first_sample_on_init) {
252 PdhDll::PdhCollectQueryData(query->query);
253 }
254 return OS_OK;
255 }
256
257 template <typename QueryP>
258 static OSReturn add_counter(QueryP counter_query, HCOUNTER* counter, const char* path, bool first_sample_on_init) {
259 assert(counter_query != NULL, "invariant");
260 assert(counter != NULL, "invariant");
261 assert(path != NULL, "invariant");
262 return add_counter(&counter_query->query, counter, path, first_sample_on_init);
263 }
264
265 static OSReturn add_counter(CounterQueryP counter_query, const char* path, bool first_sample_on_init) {
266 if (add_counter(counter_query, &counter_query->counter, path, first_sample_on_init) != OS_OK) {
267 // performance counter might be disabled in the registry
268 return OS_ERR;
269 }
270 counter_query->initialized = true;
271 return OS_OK;
272 }
273
274 static OSReturn add_process_counter(MultiCounterQueryP query, int slot_index, const char* path, bool first_sample_on_init) {
275 assert(query != NULL, "invariant");
276 assert(slot_index < query->noOfCounters, "invariant");
277 assert(query->counters[slot_index] == NULL, "invariant");
278 const OSReturn ret = add_counter(query, &query->counters[slot_index], path, first_sample_on_init);
279 if (OS_OK == ret) {
280 if (slot_index + 1 == query->noOfCounters) {
281 query->initialized = true;
282 }
283 }
284 return ret;
285 }
286
287 static int collect_query_data(UpdateQueryP update_query) {
288 assert(update_query != NULL, "invariant");
289 const s8 now = os::javaTimeMillis();
290 if (now - update_query->lastUpdate > min_update_interval_millis) {
291 if (PdhDll::PdhCollectQueryData(update_query->query) != ERROR_SUCCESS) {
292 return OS_ERR;
293 }
294 update_query->lastUpdate = now;
295 }
296 return OS_OK;
297 }
298
299 template <typename Query>
300 static int collect_query_data(Query* counter_query) {
301 assert(counter_query != NULL, "invariant");
302 return collect_query_data(&counter_query->query);
303 }
304
305 static int formatted_counter_value(HCOUNTER counter, DWORD format, PDH_FMT_COUNTERVALUE* const value) {
306 assert(value != NULL, "invariant");
307 if (PdhDll::PdhGetFormattedCounterValue(counter, format, NULL, value) != ERROR_SUCCESS) {
308 return OS_ERR;
309 }
310 return OS_OK;
311 }
312
313 /*
314 * Working against the Process object and it's related counters is inherently problematic
315 * when using the PDH API:
316 *
317 * Using PDH, a process is not primarily identified by the process id,
318 * but with a sequential number, for example \Process(java#0), \Process(java#1), ...
319 * The really bad part is that this list is reset as soon as a process exits:
320 * If \Process(java#1) exits, \Process(java#3) now becomes \Process(java#2) etc.
321 *
322 * The PDH api requires a process identifier to be submitted when registering
323 * a query, but as soon as the list resets, the query is invalidated (since the name changed).
324 *
325 * Solution:
326 * The #number identifier for a Process query can only decrease after process creation.
327 *
328 * We therefore create an array of counter queries for all process object instances
329 * up to and including ourselves:
330 *
331 * Ex. we come in as third process instance (java#2), we then create and register
332 * queries for the following Process object instances:
333 * java#0, java#1, java#2
334 *
335 * current_query_index_for_process() keeps track of the current "correct" query
336 * (in order to keep this index valid when the list resets from underneath,
337 * ensure to call current_query_index_for_process() before every query involving
338 * Process object instance data).
339 *
340 * if unable to query, returns OS_ERR(-1)
341 */
342 static int current_query_index_for_process() {
343 assert(process_image_name != NULL, "invariant");
344 assert(pdh_IDProcess_counter_fmt != NULL, "invariant");
345 HQUERY tmpQuery = NULL;
346 if (open_query(&tmpQuery) != ERROR_SUCCESS) {
347 return OS_ERR;
348 }
349 char counter[512];
350 HCOUNTER handle_counter = NULL;
351 // iterate over all instance indexes and try to find our own pid
352 for (int index = 0; index < max_intx; index++) {
353 jio_snprintf(counter, sizeof(counter) - 1, pdh_IDProcess_counter_fmt, index);
354 assert(strlen(counter) < sizeof(counter), "invariant");
355 if (PdhDll::PdhAddCounter(tmpQuery, counter, 0, &handle_counter) != ERROR_SUCCESS) {
356 pdh_cleanup(&tmpQuery, &handle_counter);
357 return OS_ERR;
358 }
359 const PDH_STATUS res = PdhDll::PdhCollectQueryData(tmpQuery);
360 if (res == PDH_INVALID_HANDLE || res == PDH_NO_DATA) {
361 pdh_cleanup(&tmpQuery, &handle_counter);
362 return OS_ERR;
363 } else {
364 PDH_FMT_COUNTERVALUE counter_value;
365 formatted_counter_value(handle_counter, PDH_FMT_LONG, &counter_value);
366 pdh_cleanup(NULL, &handle_counter);
367 if ((LONG)os::current_process_id() == counter_value.longValue) {
368 pdh_cleanup(&tmpQuery, NULL);
369 return index;
370 }
371 }
372 }
373 pdh_cleanup(&tmpQuery, NULL);
374 return OS_ERR;
375 }
376
377 static ProcessQueryP create_process_query() {
378 const int current_process_idx = current_query_index_for_process();
379 if (OS_ERR == current_process_idx) {
380 return NULL;
381 }
382 ProcessQueryP const process_query = NEW_C_HEAP_OBJ(ProcessQueryS, mtInternal);
383 memset(process_query, 0, sizeof(ProcessQueryS));
384 process_query->set.queries = NEW_C_HEAP_ARRAY(MultiCounterQueryS, current_process_idx + 1, mtInternal);
385 memset(process_query->set.queries, 0, sizeof(MultiCounterQueryS) * (current_process_idx + 1));
386 process_query->process_index = current_process_idx;
387 process_query->set.size = current_process_idx + 1;
388 assert(process_query->set.size > process_query->process_index, "invariant");
389 return process_query;
390 }
391
392 static MultiCounterQueryP current_process_counter_query(ProcessQueryP process_query) {
393 assert(process_query != NULL, "invariant");
394 assert(process_query->process_index < process_query->set.size, "invariant");
395 return &process_query->set.queries[process_query->process_index];
396 }
397
398 static void clear_multi_counter(MultiCounterQueryP query) {
399 for (int i = 0; i < query->noOfCounters; ++i) {
400 pdh_cleanup(NULL, &query->counters[i]);
401 }
402 pdh_cleanup(&query->query.query, NULL);
403 query->initialized = false;
404 }
405
406 static int ensure_valid_process_query_index(ProcessQueryP process_query) {
407 assert(process_query != NULL, "invariant");
408 const int previous_process_idx = process_query->process_index;
409 if (previous_process_idx == 0) {
410 return previous_process_idx;
411 }
412 const int current_process_idx = current_query_index_for_process();
413 if (current_process_idx == previous_process_idx || OS_ERR == current_process_idx ||
414 current_process_idx >= process_query->set.size) {
415 return previous_process_idx;
416 }
417
418 assert(current_process_idx >= 0 && current_process_idx < process_query->set.size, "out of bounds!");
419 while (current_process_idx < process_query->set.size - 1) {
420 const int new_size = --process_query->set.size;
421 clear_multi_counter(&process_query->set.queries[new_size]);
422 }
423 assert(current_process_idx < process_query->set.size, "invariant");
424 process_query->process_index = current_process_idx;
425 return current_process_idx;
426 }
427
428 static MultiCounterQueryP current_process_query(ProcessQueryP process_query) {
429 assert(process_query != NULL, "invariant");
430 const int current_process_idx = ensure_valid_process_query_index(process_query);
431 assert(current_process_idx == process_query->process_index, "invariant");
432 assert(current_process_idx < process_query->set.size, "invariant");
433 return &process_query->set.queries[current_process_idx];
434 }
435
436 static int collect_process_query_data(ProcessQueryP process_query) {
437 assert(process_query != NULL, "invariant");
438 return collect_query_data(current_process_query(process_query));
439 }
440
441 static int query_process_counter(ProcessQueryP process_query, int slot_index, DWORD format, PDH_FMT_COUNTERVALUE* const value) {
442 MultiCounterQueryP const current_query = current_process_counter_query(process_query);
443 assert(current_query != NULL, "invariant");
444 assert(slot_index < current_query->noOfCounters, "invariant");
445 assert(current_query->counters[slot_index] != NULL, "invariant");
446 return formatted_counter_value(current_query->counters[slot_index], format, value);
447 }
448
449 /*
450 * Construct a fully qualified PDH path
451 *
452 * @param objectName a PDH Object string representation(required)
453 * @param counterName a PDH Counter string representation(required)
454 * @param imageName a process image name string, ex. "java" (opt)
455 * @param instance an instance string, ex. "0", "1", ... (opt)
456 * @return the fully qualified PDH path.
457 *
458 * Caller will need a ResourceMark.
459 *
460 * (PdhMakeCounterPath() seems buggy on concatenating instances, hence this function instead)
461 */
462 static const char* make_fully_qualified_counter_path(const char* object_name,
463 const char* counter_name,
464 const char* image_name = NULL,
465 const char* instance = NULL) {
466 assert(object_name != NULL, "invariant");
467 assert(counter_name != NULL, "invariant");
468 size_t full_counter_path_len = strlen(object_name) + strlen(counter_name);
469
470 char* full_counter_path;
471 size_t jio_snprintf_result = 0;
472 if (image_name) {
473 /*
474 * For paths using the "Process" Object.
475 *
476 * Examples:
477 * form: "\object_name(image_name#instance)\counter_name"
478 * actual: "\Process(java#2)\ID Process"
479 */
480 full_counter_path_len += PROCESS_OBJECT_INSTANCE_COUNTER_FMT_LEN;
481 full_counter_path_len += strlen(image_name);
482 /*
483 * image_name must be passed together with an associated
484 * instance "number" ("0", "1", "2", ...).
485 * This is required in order to create valid "Process" Object paths.
486 *
487 * Examples: "\Process(java#0)", \Process(java#1"), ...
488 */
489 assert(instance != NULL, "invariant");
490 full_counter_path_len += strlen(instance);
491 full_counter_path = NEW_RESOURCE_ARRAY_RETURN_NULL(char, full_counter_path_len + 1);
492 if (full_counter_path == NULL) {
493 return NULL;
494 }
495 jio_snprintf_result = jio_snprintf(full_counter_path,
496 full_counter_path_len + 1,
497 PROCESS_OBJECT_INSTANCE_COUNTER_FMT,
498 object_name,
499 image_name,
500 instance,
501 counter_name);
502 } else {
503 if (instance) {
504 /*
505 * For paths where the Object has multiple instances.
506 *
507 * Examples:
508 * form: "\object_name(instance)\counter_name"
509 * actual: "\Processor(0)\% Privileged Time"
510 */
511 full_counter_path_len += strlen(instance);
512 full_counter_path_len += OBJECT_WITH_INSTANCES_COUNTER_FMT_LEN;
513 } else {
514 /*
515 * For "normal" paths.
516 *
517 * Examples:
518 * form: "\object_name\counter_name"
519 * actual: "\Memory\Available Mbytes"
520 */
521 full_counter_path_len += OBJECT_COUNTER_FMT_LEN;
522 }
523 full_counter_path = NEW_RESOURCE_ARRAY_RETURN_NULL(char, full_counter_path_len + 1);
524 if (full_counter_path == NULL) {
525 return NULL;
526 }
527 if (instance) {
528 jio_snprintf_result = jio_snprintf(full_counter_path,
529 full_counter_path_len + 1,
530 OBJECT_WITH_INSTANCES_COUNTER_FMT,
531 object_name,
532 instance,
533 counter_name);
534 } else {
535 jio_snprintf_result = jio_snprintf(full_counter_path,
536 full_counter_path_len + 1,
537 OBJECT_COUNTER_FMT,
538 object_name,
539 counter_name);
540 }
541 }
542 assert(full_counter_path_len == jio_snprintf_result, "invariant");
543 return full_counter_path;
544 }
545
546 static void log_invalid_pdh_index(DWORD index) {
547 log_warning(os)("Unable to resolve PDH index: (%ld)", index);
548 log_warning(os)("Please check the registry if this performance object/counter is disabled");
549 }
550
551 static bool is_valid_pdh_index(DWORD index) {
552 DWORD dummy = 0;
553 if (PdhDll::PdhLookupPerfNameByIndex(NULL, index, NULL, &dummy) != PDH_MORE_DATA) {
554 log_invalid_pdh_index(index);
555 return false;
556 }
557 return true;
558 }
559
560 /*
561 * Maps an index to a resource area allocated string for the localized PDH artifact.
562 *
563 * Caller will need a ResourceMark.
564 *
565 * @param index the counter index as specified in the registry
566 * @param ppBuffer pointer to a char*
567 * @return OS_OK if successful, OS_ERR on failure.
568 */
569 static OSReturn lookup_name_by_index(DWORD index, char** p_string) {
570 assert(p_string != NULL, "invariant");
571 if (!is_valid_pdh_index(index)) {
572 return OS_ERR;
573 }
574 // determine size needed
575 DWORD size = 0;
576 PDH_STATUS status = PdhDll::PdhLookupPerfNameByIndex(NULL, index, NULL, &size);
577 assert(status == PDH_MORE_DATA, "invariant");
578 *p_string = NEW_RESOURCE_ARRAY_RETURN_NULL(char, size);
579 if (*p_string== NULL) {
580 return OS_ERR;
581 }
582 if (PdhDll::PdhLookupPerfNameByIndex(NULL, index, *p_string, &size) != ERROR_SUCCESS) {
583 return OS_ERR;
584 }
585 if (0 == size || *p_string == NULL) {
586 return OS_ERR;
587 }
588 // windows vista does not null-terminate the string (although the docs says it will)
589 (*p_string)[size - 1] = '\0';
590 return OS_OK;
591 }
592
593 static const char* copy_string_to_c_heap(const char* string) {
594 assert(string != NULL, "invariant");
595 const size_t len = strlen(string);
596 char* const cheap_allocated_string = NEW_C_HEAP_ARRAY_RETURN_NULL(char, len + 1, mtInternal);
597 if (NULL == cheap_allocated_string) {
598 return NULL;
599 }
600 strncpy(cheap_allocated_string, string, len + 1);
601 return cheap_allocated_string;
602 }
603
604 /*
605 * Maps an index to a resource area allocated string for the localized PDH artifact.
606 *
607 * Caller will need a ResourceMark.
608 *
609 * @param index the counter index as specified in the registry
610 * @return localized pdh artifact string if successful, NULL on failure.
611 */
612 static const char* pdh_localized_artifact(DWORD pdh_artifact_index) {
613 char* pdh_localized_artifact_string = NULL;
614 // get localized name from pdh artifact index
615 if (lookup_name_by_index(pdh_artifact_index, &pdh_localized_artifact_string) != OS_OK) {
616 return NULL;
617 }
618 return pdh_localized_artifact_string;
619 }
620
621 /*
622 * Returns the PDH string identifying the current process image name.
623 * Use this prefix when getting counters from the PDH process object
624 * representing your process.
625 * Ex. "Process(java#0)\Virtual Bytes" - where "java" is the PDH process
626 * image description.
627 *
628 * Caller needs ResourceMark.
629 *
630 * @return the process image description. NULL if the call failed.
631 */
632 static const char* pdh_process_image_name() {
633 char* module_name = NEW_RESOURCE_ARRAY_RETURN_NULL(char, MAX_PATH);
634 if (NULL == module_name) {
635 return NULL;
636 }
637 // Find our module name and use it to extract the image name used by PDH
638 DWORD getmfn_return = GetModuleFileName(NULL, module_name, MAX_PATH);
639 if (getmfn_return >= MAX_PATH || 0 == getmfn_return) {
640 return NULL;
641 }
642 if (os::get_last_error() == ERROR_INSUFFICIENT_BUFFER) {
643 return NULL;
644 }
645 char* process_image_name = strrchr(module_name, '\\'); //drop path
646 process_image_name++; //skip slash
647 char* dot_pos = strrchr(process_image_name, '.'); //drop .exe
648 dot_pos[0] = '\0';
649 return process_image_name;
650 }
651
652 static void deallocate_pdh_constants() {
653 FREE_C_HEAP_ARRAY(char, process_image_name);
654 process_image_name = NULL;
655 FREE_C_HEAP_ARRAY(char, pdh_IDProcess_counter_fmt);
656 pdh_IDProcess_counter_fmt = NULL;
657 }
658
659 static int allocate_pdh_constants() {
660 assert(process_image_name == NULL, "invariant");
661 const char* pdh_image_name = pdh_process_image_name();
662 if (pdh_image_name == NULL) {
663 return OS_ERR;
664 }
665 process_image_name = copy_string_to_c_heap(pdh_image_name);
666
667 const char* pdh_localized_process_object = pdh_localized_artifact(PDH_PROCESS_IDX);
668 if (pdh_localized_process_object == NULL) {
669 return OS_ERR;
670 }
671
672 const char* pdh_localized_IDProcess_counter = pdh_localized_artifact(PDH_ID_PROCESS_IDX);
673 if (pdh_localized_IDProcess_counter == NULL) {
674 return OS_ERR;
675 }
676
677 size_t pdh_IDProcess_counter_fmt_len = strlen(process_image_name);
678 pdh_IDProcess_counter_fmt_len += strlen(pdh_localized_process_object);
679 pdh_IDProcess_counter_fmt_len += strlen(pdh_localized_IDProcess_counter);
680 pdh_IDProcess_counter_fmt_len += PROCESS_OBJECT_INSTANCE_COUNTER_FMT_LEN;
681 pdh_IDProcess_counter_fmt_len += 2; // "%d"
682
683 assert(pdh_IDProcess_counter_fmt == NULL, "invariant");
684 pdh_IDProcess_counter_fmt = NEW_C_HEAP_ARRAY_RETURN_NULL(char, pdh_IDProcess_counter_fmt_len + 1, mtInternal);
685 if (pdh_IDProcess_counter_fmt == NULL) {
686 return OS_ERR;
687 }
688
689 /* "\Process(java#%d)\ID Process" */
690 const size_t len = jio_snprintf(pdh_IDProcess_counter_fmt,
691 pdh_IDProcess_counter_fmt_len + 1,
692 PROCESS_OBJECT_INSTANCE_COUNTER_FMT,
693 pdh_localized_process_object,
694 process_image_name,
695 "%d",
696 pdh_localized_IDProcess_counter);
697
698 assert(pdh_IDProcess_counter_fmt != NULL, "invariant");
699 assert(len == pdh_IDProcess_counter_fmt_len, "invariant");
700 return OS_OK;
701 }
702
703 /*
704 * Enuerate the Processor PDH object and returns a buffer containing the enumerated instances.
705 * Caller needs ResourceMark;
706 *
707 * @return buffer if successful, NULL on failure.
708 */
709 static const char* enumerate_cpu_instances() {
710 char* processor; //'Processor' == PDH_PROCESSOR_IDX
711 if (lookup_name_by_index(PDH_PROCESSOR_IDX, &processor) != OS_OK) {
712 return NULL;
713 }
714 DWORD c_size = 0;
715 DWORD i_size = 0;
716 // enumerate all processors.
717 PDH_STATUS pdhStat = PdhDll::PdhEnumObjectItems(NULL, // reserved
718 NULL, // local machine
719 processor, // object to enumerate
720 NULL,
721 &c_size,
722 NULL, // instance buffer is NULL and
723 &i_size, // pass 0 length in order to get the required size
724 PERF_DETAIL_WIZARD, // counter detail level
725 0);
726 if (PdhDll::PdhStatusFail((pdhStat))) {
727 return NULL;
728 }
729 char* const instances = NEW_RESOURCE_ARRAY_RETURN_NULL(char, i_size);
730 if (instances == NULL) {
731 return NULL;
732 }
733 c_size = 0;
734 pdhStat = PdhDll::PdhEnumObjectItems(NULL, // reserved
735 NULL, // local machine
736 processor, // object to enumerate
737 NULL,
738 &c_size,
739 instances, // now instance buffer is allocated to be filled in
740 &i_size, // and the required size is known
741 PERF_DETAIL_WIZARD, // counter detail level
742 0);
743 if (PdhDll::PdhStatusFail((pdhStat))) {
744 return NULL;
745 }
746 return instances;
747 }
748
749 static int count_logical_cpus(const char* instances) {
750 assert(instances != NULL, "invariant");
751 // count logical instances.
752 DWORD count;
753 char* tmp;
754 for (count = 0, tmp = const_cast<char*>(instances); *tmp != '\0'; tmp = &tmp[strlen(tmp) + 1], count++);
755 // PDH reports an instance for each logical processor plus an instance for the total (_Total)
756 assert(count == os::processor_count() + 1, "invalid enumeration!");
757 return count - 1;
758 }
759
760 static int number_of_logical_cpus() {
761 static int numberOfCPUS = 0;
762 if (numberOfCPUS == 0) {
763 const char* instances = enumerate_cpu_instances();
764 if (instances == NULL) {
765 return OS_ERR;
766 }
767 numberOfCPUS = count_logical_cpus(instances);
768 }
769 return numberOfCPUS;
770 }
771
772 static double cpu_factor() {
773 static DWORD numCpus = 0;
774 static double cpuFactor = .0;
775 if (numCpus == 0) {
776 numCpus = number_of_logical_cpus();
777 assert(os::processor_count() <= (int)numCpus, "invariant");
778 cpuFactor = numCpus * 100;
779 }
780 return cpuFactor;
781 }
782
783 static void log_error_message_on_no_PDH_artifact(const char* full_counter_name) {
784 log_warning(os)("Unable to register PDH query for \"%s\"", full_counter_name);
785 log_warning(os)("Please check the registry if this performance object/counter is disabled");
786 }
787
788 static int initialize_cpu_query_counters(MultiCounterQueryP cpu_query, DWORD pdh_counter_idx) {
789 assert(cpu_query != NULL, "invariant");
790 assert(cpu_query->counters != NULL, "invariant");
791 char* processor; //'Processor' == PDH_PROCESSOR_IDX
792 if (lookup_name_by_index(PDH_PROCESSOR_IDX, &processor) != OS_OK) {
793 return OS_ERR;
794 }
795 char* counter_name = NULL;
796 if (lookup_name_by_index(pdh_counter_idx, &counter_name) != OS_OK) {
797 return OS_ERR;
798 }
799 if (cpu_query->query.query == NULL) {
800 if (open_query(cpu_query)) {
801 return OS_ERR;
802 }
803 }
804 assert(cpu_query->query.query != NULL, "invariant");
805 size_t counter_len = strlen(processor);
806 counter_len += strlen(counter_name);
807 counter_len += OBJECT_WITH_INSTANCES_COUNTER_FMT_LEN; // "\\%s(%s)\\%s"
808
809 DWORD index;
810 char* tmp;
811 const char* instances = enumerate_cpu_instances();
812 for (index = 0, tmp = const_cast<char*>(instances); *tmp != '\0'; tmp = &tmp[strlen(tmp) + 1], index++) {
813 const size_t tmp_len = strlen(tmp);
814 char* counter_path = NEW_RESOURCE_ARRAY_RETURN_NULL(char, counter_len + tmp_len + 1);
815 if (counter_path == NULL) {
816 return OS_ERR;
817 }
818 const size_t jio_snprintf_result = jio_snprintf(counter_path,
819 counter_len + tmp_len + 1,
820 OBJECT_WITH_INSTANCES_COUNTER_FMT,
821 processor,
822 tmp, // instance "0", "1", .."_Total"
823 counter_name);
824 assert(counter_len + tmp_len == jio_snprintf_result, "invariant");
825 if (add_counter(cpu_query, &cpu_query->counters[index], counter_path, false) != OS_OK) {
826 // performance counter is disabled in registry and not accessible via PerfLib
827 log_error_message_on_no_PDH_artifact(counter_path);
828 // return OS_OK to have the system continue to run without the missing counter
829 return OS_OK;
830 }
831 }
832 cpu_query->initialized = true;
833 // Query once to initialize the counters which require at least two samples
834 // (like the % CPU usage) to calculate correctly.
835 collect_query_data(cpu_query);
836 return OS_OK;
837 }
838
839 static int initialize_cpu_query(MultiCounterQueryP cpu_query, DWORD pdh_counter_idx) {
840 assert(cpu_query != NULL, "invariant");
841 assert(!cpu_query->initialized, "invariant");
842 const int logical_cpu_count = number_of_logical_cpus();
843 assert(logical_cpu_count >= os::processor_count(), "invariant");
844 // we also add another counter for instance "_Total"
845 allocate_counters(cpu_query, logical_cpu_count + 1);
846 assert(cpu_query->noOfCounters == logical_cpu_count + 1, "invariant");
847 return initialize_cpu_query_counters(cpu_query, pdh_counter_idx);
848 }
849
850 static int initialize_process_counter(ProcessQueryP process_query, int slot_index, DWORD pdh_counter_index) {
851 char* localized_process_object;
852 if (lookup_name_by_index(PDH_PROCESS_IDX, &localized_process_object) != OS_OK) {
853 return OS_ERR;
854 }
855 assert(localized_process_object != NULL, "invariant");
856 char* localized_counter_name;
857 if (lookup_name_by_index(pdh_counter_index, &localized_counter_name) != OS_OK) {
858 return OS_ERR;
859 }
860 assert(localized_counter_name != NULL, "invariant");
861 for (int i = 0; i < process_query->set.size; ++i) {
862 char instanceIndexBuffer[32];
863 const char* counter_path = make_fully_qualified_counter_path(localized_process_object,
864 localized_counter_name,
865 process_image_name,
866 itoa(i, instanceIndexBuffer, 10));
867 if (counter_path == NULL) {
868 return OS_ERR;
869 }
870 MultiCounterQueryP const query = &process_query->set.queries[i];
871 if (add_process_counter(query, slot_index, counter_path, true)) {
872 return OS_ERR;
873 }
874 }
875 return OS_OK;
876 }
877
878 static CounterQueryP create_counter_query(DWORD pdh_object_idx, DWORD pdh_counter_idx) {
879 if (!((is_valid_pdh_index(pdh_object_idx) && is_valid_pdh_index(pdh_counter_idx)))) {
880 return NULL;
881 }
882 CounterQueryP const query = create_counter_query();
883 const char* object = pdh_localized_artifact(pdh_object_idx);
884 assert(object != NULL, "invariant");
885 const char* counter = pdh_localized_artifact(pdh_counter_idx);
886 assert(counter != NULL, "invariant");
887 const char* full_counter_path = make_fully_qualified_counter_path(object, counter);
888 assert(full_counter_path != NULL, "invariant");
889 add_counter(query, full_counter_path, true);
890 return query;
891 }
892
893 static void deallocate() {
894 deallocate_pdh_constants();
895 PdhDll::PdhDetach();
896 }
897
898 static LONG critical_section = 0;
899 static LONG reference_count = 0;
900 static bool pdh_initialized = false;
901
902 static void on_initialization_failure() {
903 // still holder of critical section
904 deallocate();
905 InterlockedExchangeAdd(&reference_count, -1);
906 }
907
908 static OSReturn initialize() {
909 ResourceMark rm;
910 if (!PdhDll::PdhAttach()) {
911 return OS_ERR;
912 }
913 if (allocate_pdh_constants() != OS_OK) {
914 on_initialization_failure();
915 return OS_ERR;
916 }
917 return OS_OK;
918 }
919
920 /*
921 * Helper to initialize the PDH library, function pointers, constants and counters.
922 *
923 * Reference counting allows for unloading of pdh.dll granted all sessions use the pair:
924 *
925 * pdh_acquire();
926 * pdh_release();
927 *
928 * @return OS_OK if successful, OS_ERR on failure.
929 */
930 static bool pdh_acquire() {
931 while (InterlockedCompareExchange(&critical_section, 1, 0) == 1);
932 InterlockedExchangeAdd(&reference_count, 1);
933 if (pdh_initialized) {
934 return true;
935 }
936 const OSReturn ret = initialize();
937 if (OS_OK == ret) {
938 pdh_initialized = true;
939 }
940 while (InterlockedCompareExchange(&critical_section, 0, 1) == 0);
941 return ret == OS_OK;
942 }
943
944 static void pdh_release() {
945 while (InterlockedCompareExchange(&critical_section, 1, 0) == 1);
946 const LONG prev_ref_count = InterlockedExchangeAdd(&reference_count, -1);
947 if (1 == prev_ref_count) {
948 deallocate();
949 pdh_initialized = false;
950 }
951 while (InterlockedCompareExchange(&critical_section, 0, 1) == 0);
952 }
953
954 class CPUPerformanceInterface::CPUPerformance : public CHeapObj<mtInternal> {
955 friend class CPUPerformanceInterface;
956 private:
957 CounterQueryP _context_switches;
958 ProcessQueryP _process_cpu_load;
959 MultiCounterQueryP _machine_cpu_load;
960
961 int cpu_load(int which_logical_cpu, double* cpu_load);
962 int context_switch_rate(double* rate);
963 int cpu_load_total_process(double* cpu_load);
964 int cpu_loads_process(double* jvm_user_load, double* jvm_kernel_load, double* psystemTotalLoad);
965 CPUPerformance();
966 ~CPUPerformance();
967 bool initialize();
968 };
969
970 class SystemProcessInterface::SystemProcesses : public CHeapObj<mtInternal> {
971 friend class SystemProcessInterface;
972 private:
973 class ProcessIterator : public CHeapObj<mtInternal> {
974 friend class SystemProcessInterface::SystemProcesses;
975 private:
976 HANDLE _hProcessSnap;
977 PROCESSENTRY32 _pe32;
978 BOOL _valid;
979 char _exePath[MAX_PATH];
980 ProcessIterator();
981 ~ProcessIterator();
982 bool initialize();
983
984 int current(SystemProcess* const process_info);
985 int next_process();
986 bool is_valid() const { return _valid != FALSE; }
987 char* allocate_string(const char* str) const;
988 int snapshot();
989 };
990
991 ProcessIterator* _iterator;
992 SystemProcesses();
993 ~SystemProcesses();
994 bool initialize();
995
996 // information about system processes
997 int system_processes(SystemProcess** system_processes, int* no_of_sys_processes) const;
998 };
999
1000 CPUPerformanceInterface::CPUPerformance::CPUPerformance() : _context_switches(NULL), _process_cpu_load(NULL), _machine_cpu_load(NULL) {}
1001
1002 bool CPUPerformanceInterface::CPUPerformance::initialize() {
1003 if (!pdh_acquire()) {
1004 return true;
1005 }
1006 _context_switches = create_counter_query(PDH_SYSTEM_IDX, PDH_CONTEXT_SWITCH_RATE_IDX);
1007 _process_cpu_load = create_process_query();
1008 if (_process_cpu_load == NULL) {
1009 return true;
1010 }
1011 allocate_counters(_process_cpu_load, 2);
1012 if (initialize_process_counter(_process_cpu_load, 0, PDH_PROCESSOR_TIME_IDX) != OS_OK) {
1013 return true;
1014 }
1015 if (initialize_process_counter(_process_cpu_load, 1, PDH_PRIV_PROCESSOR_TIME_IDX) != OS_OK) {
1016 return true;
1017 }
1018 _process_cpu_load->set.initialized = true;
1019 _machine_cpu_load = create_multi_counter_query();
1020 if (_machine_cpu_load == NULL) {
1021 return true;
1022 }
1023 initialize_cpu_query(_machine_cpu_load, PDH_PROCESSOR_TIME_IDX);
1024 return true;
1025 }
1026
1027 CPUPerformanceInterface::CPUPerformance::~CPUPerformance() {
1028 if (_context_switches != NULL) {
1029 destroy_counter_query(_context_switches);
1030 _context_switches = NULL;
1031 }
1032 if (_process_cpu_load != NULL) {
1033 destroy_counter_query(_process_cpu_load);
1034 _process_cpu_load = NULL;
1035 }
1036 if (_machine_cpu_load != NULL) {
1037 destroy_counter_query(_machine_cpu_load);
1038 _machine_cpu_load = NULL;
1039 }
1040 pdh_release();
1041 }
1042
1043 CPUPerformanceInterface::CPUPerformanceInterface() {
1044 _impl = NULL;
1045 }
1046
1047 bool CPUPerformanceInterface::initialize() {
1048 _impl = new CPUPerformanceInterface::CPUPerformance();
1049 return _impl->initialize();
1050 }
1051
1052 CPUPerformanceInterface::~CPUPerformanceInterface() {
1053 if (_impl != NULL) {
1054 delete _impl;
1055 }
1056 }
1057
1058 int CPUPerformanceInterface::cpu_load(int which_logical_cpu, double* cpu_load) const {
1059 return _impl->cpu_load(which_logical_cpu, cpu_load);
1060 }
1061
1062 int CPUPerformanceInterface::context_switch_rate(double* rate) const {
1063 return _impl->context_switch_rate(rate);
1064 }
1065
1066 int CPUPerformanceInterface::cpu_load_total_process(double* cpu_load) const {
1067 return _impl->cpu_load_total_process(cpu_load);
1068 }
1069
1070 int CPUPerformanceInterface::cpu_loads_process(double* pjvmUserLoad,
1071 double* pjvmKernelLoad,
1072 double* psystemTotalLoad) const {
1073 return _impl->cpu_loads_process(pjvmUserLoad, pjvmKernelLoad, psystemTotalLoad);
1074 }
1075
1076 int CPUPerformanceInterface::CPUPerformance::cpu_load(int which_logical_cpu, double* cpu_load) {
1077 *cpu_load = .0;
1078 if (_machine_cpu_load == NULL || !_machine_cpu_load->initialized) {
1079 return OS_ERR;
1080 }
1081 assert(_machine_cpu_load != NULL, "invariant");
1082 assert(which_logical_cpu < _machine_cpu_load->noOfCounters, "invariant");
1083
1084 if (collect_query_data(_machine_cpu_load)) {
1085 return OS_ERR;
1086 }
1087 // -1 is total (all cpus)
1088 const int counter_idx = -1 == which_logical_cpu ? _machine_cpu_load->noOfCounters - 1 : which_logical_cpu;
1089 PDH_FMT_COUNTERVALUE counter_value;
1090 formatted_counter_value(_machine_cpu_load->counters[counter_idx], PDH_FMT_DOUBLE, &counter_value);
1091 *cpu_load = counter_value.doubleValue / 100;
1092 return OS_OK;
1093 }
1094
1095 int CPUPerformanceInterface::CPUPerformance::cpu_load_total_process(double* cpu_load) {
1096 *cpu_load = .0;
1097 if (_process_cpu_load == NULL || !_process_cpu_load->set.initialized) {
1098 return OS_ERR;
1099 }
1100 assert(_process_cpu_load != NULL, "invariant");
1101 if (collect_process_query_data(_process_cpu_load)) {
1102 return OS_ERR;
1103 }
1104 PDH_FMT_COUNTERVALUE counter_value;
1105 if (query_process_counter(_process_cpu_load, 0, PDH_FMT_DOUBLE | PDH_FMT_NOCAP100, &counter_value) != OS_OK) {
1106 return OS_ERR;
1107 }
1108 double process_load = counter_value.doubleValue / cpu_factor();
1109 process_load = MIN2<double>(1, process_load);
1110 process_load = MAX2<double>(0, process_load);
1111 *cpu_load = process_load;
1112 return OS_OK;
1113 }
1114
1115 int CPUPerformanceInterface::CPUPerformance::cpu_loads_process(double* pjvmUserLoad,
1116 double* pjvmKernelLoad,
1117 double* psystemTotalLoad) {
1118 assert(pjvmUserLoad != NULL, "pjvmUserLoad is NULL!");
1119 assert(pjvmKernelLoad != NULL, "pjvmKernelLoad is NULL!");
1120 assert(psystemTotalLoad != NULL, "psystemTotalLoad is NULL!");
1121 *pjvmUserLoad = .0;
1122 *pjvmKernelLoad = .0;
1123 *psystemTotalLoad = .0;
1124
1125 if (_process_cpu_load == NULL || !_process_cpu_load->set.initialized) {
1126 return OS_ERR;
1127 }
1128 assert(_process_cpu_load != NULL, "invariant");
1129 if (collect_process_query_data(_process_cpu_load)) {
1130 return OS_ERR;
1131 }
1132 double process_load = .0;
1133 PDH_FMT_COUNTERVALUE counter_value;
1134 // Read PDH_PROCESSOR_TIME_IDX
1135 if (query_process_counter(_process_cpu_load, 0, PDH_FMT_DOUBLE | PDH_FMT_NOCAP100, &counter_value) != OS_OK) {
1136 return OS_ERR;
1137 }
1138 process_load = counter_value.doubleValue / cpu_factor();
1139 process_load = MIN2<double>(1, process_load);
1140 process_load = MAX2<double>(0, process_load);
1141 // Read PDH_PRIV_PROCESSOR_TIME_IDX
1142 if (query_process_counter(_process_cpu_load, 1, PDH_FMT_DOUBLE | PDH_FMT_NOCAP100, &counter_value) != OS_OK) {
1143 return OS_ERR;
1144 }
1145 double kernel_load = counter_value.doubleValue / cpu_factor();
1146 kernel_load = MIN2<double>(1, kernel_load);
1147 kernel_load = MAX2<double>(0, kernel_load);
1148 *pjvmKernelLoad = kernel_load;
1149
1150 double user_load = process_load - kernel_load;
1151 user_load = MIN2<double>(1, user_load);
1152 user_load = MAX2<double>(0, user_load);
1153 *pjvmUserLoad = user_load;
1154
1155 if (collect_query_data(_machine_cpu_load)) {
1156 return OS_ERR;
1157 }
1158 if (formatted_counter_value(_machine_cpu_load->counters[_machine_cpu_load->noOfCounters - 1], PDH_FMT_DOUBLE, &counter_value) != OS_OK) {
1159 return OS_ERR;
1160 }
1161 double machine_load = counter_value.doubleValue / 100;
1162 assert(machine_load >= 0, "machine_load is negative!");
1163 // clamp at user+system and 1.0
1164 if (*pjvmKernelLoad + *pjvmUserLoad > machine_load) {
1165 machine_load = MIN2(*pjvmKernelLoad + *pjvmUserLoad, 1.0);
1166 }
1167 *psystemTotalLoad = machine_load;
1168 return OS_OK;
1169 }
1170
1171 int CPUPerformanceInterface::CPUPerformance::context_switch_rate(double* rate) {
1172 assert(rate != NULL, "invariant");
1173 *rate = .0;
1174 if (_context_switches == NULL || !_context_switches->initialized) {
1175 return OS_ERR;
1176 }
1177 assert(_context_switches != NULL, "invariant");
1178 if (collect_query_data(_context_switches) != OS_OK) {
1179 return OS_ERR;
1180 }
1181 PDH_FMT_COUNTERVALUE counter_value;
1182 if (formatted_counter_value(_context_switches->counter, PDH_FMT_DOUBLE, &counter_value) != OS_OK) {
1183 return OS_ERR;
1184 }
1185 *rate = counter_value.doubleValue;
1186 return OS_OK;
1187 }
1188
1189 SystemProcessInterface::SystemProcesses::ProcessIterator::ProcessIterator() {
1190 _hProcessSnap = INVALID_HANDLE_VALUE;
1191 _valid = FALSE;
1192 _pe32.dwSize = sizeof(PROCESSENTRY32);
1193 }
1194
1195 bool SystemProcessInterface::SystemProcesses::ProcessIterator::initialize() {
1196 return true;
1197 }
1198
1199 int SystemProcessInterface::SystemProcesses::ProcessIterator::snapshot() {
1200 // take snapshot of all process in the system
1201 _hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
1202 if (_hProcessSnap == INVALID_HANDLE_VALUE) {
1203 return OS_ERR;
1204 }
1205 // step to first process
1206 _valid = Process32First(_hProcessSnap, &_pe32);
1207 return is_valid() ? OS_OK : OS_ERR;
1208 }
1209
1210 SystemProcessInterface::SystemProcesses::ProcessIterator::~ProcessIterator() {
1211 if (_hProcessSnap != INVALID_HANDLE_VALUE) {
1212 CloseHandle(_hProcessSnap);
1213 }
1214 }
1215
1216 int SystemProcessInterface::SystemProcesses::ProcessIterator::current(SystemProcess* process_info) {
1217 assert(is_valid(), "no current process to be fetched!");
1218 assert(process_info != NULL, "process_info is NULL!");
1219 char* exePath = NULL;
1220 HANDLE hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, false, _pe32.th32ProcessID);
1221 if (hProcess != NULL) {
1222 HMODULE hMod;
1223 DWORD cbNeeded;
1224 if (EnumProcessModules(hProcess, &hMod, sizeof(hMod), &cbNeeded) != 0) {
1225 if (GetModuleFileNameExA(hProcess, hMod, _exePath, sizeof(_exePath)) != 0) {
1226 exePath = _exePath;
1227 }
1228 }
1229 CloseHandle (hProcess);
1230 }
1231 process_info->set_pid((int)_pe32.th32ProcessID);
1232 process_info->set_name(allocate_string(_pe32.szExeFile));
1233 process_info->set_path(allocate_string(exePath));
1234 return OS_OK;
1235 }
1236
1237 char* SystemProcessInterface::SystemProcesses::ProcessIterator::allocate_string(const char* str) const {
1238 if (str != NULL) {
1239 return os::strdup_check_oom(str, mtInternal);
1240 }
1241 return NULL;
1242 }
1243
1244 int SystemProcessInterface::SystemProcesses::ProcessIterator::next_process() {
1245 _valid = Process32Next(_hProcessSnap, &_pe32);
1246 return OS_OK;
1247 }
1248
1249 SystemProcessInterface::SystemProcesses::SystemProcesses() {
1250 _iterator = NULL;
1251 }
1252
1253 bool SystemProcessInterface::SystemProcesses::initialize() {
1254 _iterator = new SystemProcessInterface::SystemProcesses::ProcessIterator();
1255 return _iterator->initialize();
1256 }
1257
1258 SystemProcessInterface::SystemProcesses::~SystemProcesses() {
1259 if (_iterator != NULL) {
1260 delete _iterator;
1261 _iterator = NULL;
1262 }
1263 }
1264
1265 int SystemProcessInterface::SystemProcesses::system_processes(SystemProcess** system_processes,
1266 int* no_of_sys_processes) const {
1267 assert(system_processes != NULL, "system_processes pointer is NULL!");
1268 assert(no_of_sys_processes != NULL, "system_processes counter pointers is NULL!");
1269 assert(_iterator != NULL, "iterator is NULL!");
1270
1271 // initialize pointers
1272 *no_of_sys_processes = 0;
1273 *system_processes = NULL;
1274
1275 // take process snapshot
1276 if (_iterator->snapshot() != OS_OK) {
1277 return OS_ERR;
1278 }
1279
1280 while (_iterator->is_valid()) {
1281 SystemProcess* tmp = new SystemProcess();
1282 _iterator->current(tmp);
1283
1284 //if already existing head
1285 if (*system_processes != NULL) {
1286 //move "first to second"
1287 tmp->set_next(*system_processes);
1288 }
1289 // new head
1290 *system_processes = tmp;
1291 // increment
1292 (*no_of_sys_processes)++;
1293 // step forward
1294 _iterator->next_process();
1295 }
1296 return OS_OK;
1297 }
1298
1299 int SystemProcessInterface::system_processes(SystemProcess** system_procs,
1300 int* no_of_sys_processes) const {
1301 return _impl->system_processes(system_procs, no_of_sys_processes);
1302 }
1303
1304 SystemProcessInterface::SystemProcessInterface() {
1305 _impl = NULL;
1306 }
1307
1308 bool SystemProcessInterface::initialize() {
1309 _impl = new SystemProcessInterface::SystemProcesses();
1310 return _impl->initialize();
1311 }
1312
1313 SystemProcessInterface::~SystemProcessInterface() {
1314 if (_impl != NULL) {
1315 delete _impl;
1316 }
1317 }
1318
1319 CPUInformationInterface::CPUInformationInterface() {
1320 _cpu_info = NULL;
1321 }
1322
1323 bool CPUInformationInterface::initialize() {
1324 _cpu_info = new CPUInformation();
1325 _cpu_info->set_number_of_hardware_threads(VM_Version_Ext::number_of_threads());
1326 _cpu_info->set_number_of_cores(VM_Version_Ext::number_of_cores());
1327 _cpu_info->set_number_of_sockets(VM_Version_Ext::number_of_sockets());
1328 _cpu_info->set_cpu_name(VM_Version_Ext::cpu_name());
1329 _cpu_info->set_cpu_description(VM_Version_Ext::cpu_description());
1330 return true;
1331 }
1332
1333 CPUInformationInterface::~CPUInformationInterface() {
1334 if (_cpu_info != NULL) {
1335 FREE_C_HEAP_ARRAY(char, _cpu_info->cpu_name());
1336 _cpu_info->set_cpu_name(NULL);
1337 FREE_C_HEAP_ARRAY(char, _cpu_info->cpu_description());
1338 _cpu_info->set_cpu_description(NULL);
1339 delete _cpu_info;
1340 _cpu_info = NULL;
1341 }
1342 }
1343
1344 int CPUInformationInterface::cpu_information(CPUInformation& cpu_info) {
1345 if (NULL == _cpu_info) {
1346 return OS_ERR;
1347 }
1348 cpu_info = *_cpu_info; // shallow copy assignment
1349 return OS_OK;
1350 }
1351
1352 class NetworkPerformanceInterface::NetworkPerformance : public CHeapObj<mtInternal> {
1353 friend class NetworkPerformanceInterface;
1354 private:
1355 bool _iphlp_attached;
1356
1357 NetworkPerformance();
1358 NetworkPerformance(const NetworkPerformance& rhs); // no impl
1359 NetworkPerformance& operator=(const NetworkPerformance& rhs); // no impl
1360 bool initialize();
1361 ~NetworkPerformance();
1362 int network_utilization(NetworkInterface** network_interfaces) const;
1363 };
1364
1365 NetworkPerformanceInterface::NetworkPerformance::NetworkPerformance()
1366 : _iphlp_attached(false) {
1367 }
1368
1369 bool NetworkPerformanceInterface::NetworkPerformance::initialize() {
1370 _iphlp_attached = IphlpDll::IphlpAttach();
1371 return _iphlp_attached;
1372 }
1373
1374 NetworkPerformanceInterface::NetworkPerformance::~NetworkPerformance() {
1375 if (_iphlp_attached) {
1376 IphlpDll::IphlpDetach();
1377 }
1378 }
1379
1380 int NetworkPerformanceInterface::NetworkPerformance::network_utilization(NetworkInterface** network_interfaces) const {
1381 MIB_IF_TABLE2* table;
1382
1383 if (IphlpDll::GetIfTable2(&table) != NO_ERROR) {
1384 return OS_ERR;
1385 }
1386
1387 NetworkInterface* ret = NULL;
1388 for (ULONG i = 0; i < table->NumEntries; ++i) {
1389 if (table->Table[i].InterfaceAndOperStatusFlags.FilterInterface) {
1390 continue;
1391 }
1392
1393 char buf[256];
1394 if (WideCharToMultiByte(CP_UTF8, 0, table->Table[i].Description, -1, buf, sizeof(buf), NULL, NULL) == 0) {
1395 continue;
1396 }
1397
1398 NetworkInterface* cur = new NetworkInterface(buf, table->Table[i].InOctets, table->Table[i].OutOctets, ret);
1399 ret = cur;
1400 }
1401
1402 IphlpDll::FreeMibTable(table);
1403 *network_interfaces = ret;
1404
1405 return OS_OK;
1406 }
1407
1408 NetworkPerformanceInterface::NetworkPerformanceInterface() {
1409 _impl = NULL;
1410 }
1411
1412 NetworkPerformanceInterface::~NetworkPerformanceInterface() {
1413 if (_impl != NULL) {
1414 delete _impl;
1415 }
1416 }
1417
1418 bool NetworkPerformanceInterface::initialize() {
1419 _impl = new NetworkPerformanceInterface::NetworkPerformance();
1420 return _impl->initialize();
1421 }
1422
1423 int NetworkPerformanceInterface::network_utilization(NetworkInterface** network_interfaces) const {
1424 return _impl->network_utilization(network_interfaces);
1425 }