21 * questions.
22 *
23 */
24
25 #include "classfile/classLoader.hpp"
26 #include "classfile/systemDictionary.hpp"
27 #include "classfile/vmClasses.hpp"
28 #include "compiler/compileBroker.hpp"
29 #include "gc/shared/collectedHeap.hpp"
30 #include "jmm.h"
31 #include "memory/allocation.inline.hpp"
32 #include "memory/iterator.hpp"
33 #include "memory/oopFactory.hpp"
34 #include "memory/resourceArea.hpp"
35 #include "memory/universe.hpp"
36 #include "oops/klass.hpp"
37 #include "oops/klass.inline.hpp"
38 #include "oops/objArrayKlass.hpp"
39 #include "oops/objArrayOop.inline.hpp"
40 #include "oops/oop.inline.hpp"
41 #include "oops/oopHandle.inline.hpp"
42 #include "oops/typeArrayOop.inline.hpp"
43 #include "runtime/flags/jvmFlag.hpp"
44 #include "runtime/globals.hpp"
45 #include "runtime/handles.inline.hpp"
46 #include "runtime/interfaceSupport.inline.hpp"
47 #include "runtime/javaCalls.hpp"
48 #include "runtime/jniHandles.inline.hpp"
49 #include "runtime/mutexLocker.hpp"
50 #include "runtime/notificationThread.hpp"
51 #include "runtime/os.hpp"
52 #include "runtime/thread.inline.hpp"
53 #include "runtime/threads.hpp"
54 #include "runtime/threadSMR.hpp"
55 #include "runtime/vmOperations.hpp"
56 #include "services/classLoadingService.hpp"
57 #include "services/cpuTimeUsage.hpp"
58 #include "services/diagnosticCommand.hpp"
59 #include "services/diagnosticFramework.hpp"
60 #include "services/finalizerService.hpp"
61 #include "services/gcNotifier.hpp"
1427
1428 JavaThread* java_thread = nullptr;
1429 if (thread_id == 0) {
1430 // current thread
1431 return os::current_thread_cpu_time();
1432 } else {
1433 ThreadsListHandle tlh;
1434 java_thread = tlh.list()->find_JavaThread_from_java_tid(thread_id);
1435 if (is_platform_thread(java_thread)) {
1436 return os::thread_cpu_time((Thread*) java_thread);
1437 }
1438 }
1439 return -1;
1440 JVM_END
1441
1442 // Returns a String array of all VM global flag names
1443 JVM_ENTRY(jobjectArray, jmm_GetVMGlobalNames(JNIEnv *env))
1444 // last flag entry is always null, so subtract 1
1445 int nFlags = (int) JVMFlag::numFlags - 1;
1446 // allocate a temp array
1447 objArrayOop r = oopFactory::new_objArray(vmClasses::String_klass(),
1448 nFlags, CHECK_NULL);
1449 objArrayHandle flags_ah(THREAD, r);
1450 int num_entries = 0;
1451 for (int i = 0; i < nFlags; i++) {
1452 JVMFlag* flag = &JVMFlag::flags[i];
1453 // Exclude develop flags in product builds.
1454 if (flag->is_constant_in_binary()) {
1455 continue;
1456 }
1457 // Exclude the locked (experimental, diagnostic) flags
1458 if (flag->is_unlocked() || flag->is_unlocker()) {
1459 Handle s = java_lang_String::create_from_str(flag->name(), CHECK_NULL);
1460 flags_ah->obj_at_put(num_entries, s());
1461 num_entries++;
1462 }
1463 }
1464
1465 if (num_entries < nFlags) {
1466 // Return array of right length
1467 objArrayOop res = oopFactory::new_objArray(vmClasses::String_klass(), num_entries, CHECK_NULL);
1468 for(int i = 0; i < num_entries; i++) {
1469 res->obj_at_put(i, flags_ah->obj_at(i));
1470 }
1471 return (jobjectArray)JNIHandles::make_local(THREAD, res);
1472 }
1473
1474 return (jobjectArray)JNIHandles::make_local(THREAD, flags_ah());
1475 JVM_END
1476
1477 // Utility function used by jmm_GetVMGlobals. Returns false if flag type
1478 // can't be determined, true otherwise. If false is returned, then *global
1479 // will be incomplete and invalid.
1480 static bool add_global_entry(Handle name, jmmVMGlobal *global, JVMFlag *flag, TRAPS) {
1481 Handle flag_name;
1482 if (name() == nullptr) {
1483 flag_name = java_lang_String::create_from_str(flag->name(), CHECK_false);
1484 } else {
1485 flag_name = name;
1486 }
1487 global->name = (jstring)JNIHandles::make_local(THREAD, flag_name());
1553 // Fill globals array of count length with jmmVMGlobal entries
1554 // specified by names. If names == null, fill globals array
1555 // with all Flags. Return value is number of entries
1556 // created in globals.
1557 // If a JVMFlag with a given name in an array element does not
1558 // exist, globals[i].name will be set to null.
1559 JVM_ENTRY(jint, jmm_GetVMGlobals(JNIEnv *env,
1560 jobjectArray names,
1561 jmmVMGlobal *globals,
1562 jint count))
1563
1564
1565 if (globals == nullptr) {
1566 THROW_(vmSymbols::java_lang_NullPointerException(), 0);
1567 }
1568
1569 ResourceMark rm(THREAD);
1570
1571 if (names != nullptr) {
1572 // return the requested globals
1573 objArrayOop ta = objArrayOop(JNIHandles::resolve_non_null(names));
1574 objArrayHandle names_ah(THREAD, ta);
1575 // Make sure we have a String array
1576 Klass* element_klass = ObjArrayKlass::cast(names_ah->klass())->element_klass();
1577 if (element_klass != vmClasses::String_klass()) {
1578 THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(),
1579 "Array element type is not String class", 0);
1580 }
1581
1582 int names_length = names_ah->length();
1583 int num_entries = 0;
1584 for (int i = 0; i < names_length && i < count; i++) {
1585 oop s = names_ah->obj_at(i);
1586 if (s == nullptr) {
1587 THROW_(vmSymbols::java_lang_NullPointerException(), 0);
1588 }
1589
1590 Handle sh(THREAD, s);
1591 char* str = java_lang_String::as_utf8_string(s);
1592 JVMFlag* flag = JVMFlag::find_flag(str);
1593 if (flag != nullptr &&
1594 add_global_entry(sh, &globals[i], flag, THREAD)) {
1595 num_entries++;
1596 } else {
1980 ResourceMark rm(THREAD);
1981 GrowableArray<const char *>* dcmd_list = DCmdFactory::DCmd_list(DCmd_Source_MBean);
1982 objArrayOop cmd_array_oop = oopFactory::new_objArray(vmClasses::String_klass(),
1983 dcmd_list->length(), CHECK_NULL);
1984 objArrayHandle cmd_array(THREAD, cmd_array_oop);
1985 for (int i = 0; i < dcmd_list->length(); i++) {
1986 oop cmd_name = java_lang_String::create_oop_from_str(dcmd_list->at(i), CHECK_NULL);
1987 cmd_array->obj_at_put(i, cmd_name);
1988 }
1989 return (jobjectArray) JNIHandles::make_local(THREAD, cmd_array());
1990 JVM_END
1991
1992 JVM_ENTRY(void, jmm_GetDiagnosticCommandInfo(JNIEnv *env, jobjectArray cmds,
1993 dcmdInfo* infoArray))
1994 if (cmds == nullptr || infoArray == nullptr) {
1995 THROW(vmSymbols::java_lang_NullPointerException());
1996 }
1997
1998 ResourceMark rm(THREAD);
1999
2000 objArrayOop ca = objArrayOop(JNIHandles::resolve_non_null(cmds));
2001 objArrayHandle cmds_ah(THREAD, ca);
2002
2003 // Make sure we have a String array
2004 Klass* element_klass = ObjArrayKlass::cast(cmds_ah->klass())->element_klass();
2005 if (element_klass != vmClasses::String_klass()) {
2006 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
2007 "Array element type is not String class");
2008 }
2009
2010 GrowableArray<DCmdInfo *>* info_list = DCmdFactory::DCmdInfo_list(DCmd_Source_MBean);
2011
2012 int num_cmds = cmds_ah->length();
2013 for (int i = 0; i < num_cmds; i++) {
2014 oop cmd = cmds_ah->obj_at(i);
2015 if (cmd == nullptr) {
2016 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
2017 "Command name cannot be null.");
2018 }
2019 char* cmd_name = java_lang_String::as_utf8_string(cmd);
2020 if (cmd_name == nullptr) {
2021 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
2022 "Command name cannot be null.");
2023 }
2024 int pos = info_list->find_if([&](DCmdInfo* info) {
|
21 * questions.
22 *
23 */
24
25 #include "classfile/classLoader.hpp"
26 #include "classfile/systemDictionary.hpp"
27 #include "classfile/vmClasses.hpp"
28 #include "compiler/compileBroker.hpp"
29 #include "gc/shared/collectedHeap.hpp"
30 #include "jmm.h"
31 #include "memory/allocation.inline.hpp"
32 #include "memory/iterator.hpp"
33 #include "memory/oopFactory.hpp"
34 #include "memory/resourceArea.hpp"
35 #include "memory/universe.hpp"
36 #include "oops/klass.hpp"
37 #include "oops/klass.inline.hpp"
38 #include "oops/objArrayKlass.hpp"
39 #include "oops/objArrayOop.inline.hpp"
40 #include "oops/oop.inline.hpp"
41 #include "oops/oopCast.inline.hpp"
42 #include "oops/oopHandle.inline.hpp"
43 #include "oops/refArrayOop.inline.hpp"
44 #include "oops/typeArrayOop.inline.hpp"
45 #include "runtime/flags/jvmFlag.hpp"
46 #include "runtime/globals.hpp"
47 #include "runtime/handles.inline.hpp"
48 #include "runtime/interfaceSupport.inline.hpp"
49 #include "runtime/javaCalls.hpp"
50 #include "runtime/jniHandles.inline.hpp"
51 #include "runtime/mutexLocker.hpp"
52 #include "runtime/notificationThread.hpp"
53 #include "runtime/os.hpp"
54 #include "runtime/thread.inline.hpp"
55 #include "runtime/threads.hpp"
56 #include "runtime/threadSMR.hpp"
57 #include "runtime/vmOperations.hpp"
58 #include "services/classLoadingService.hpp"
59 #include "services/cpuTimeUsage.hpp"
60 #include "services/diagnosticCommand.hpp"
61 #include "services/diagnosticFramework.hpp"
62 #include "services/finalizerService.hpp"
63 #include "services/gcNotifier.hpp"
1429
1430 JavaThread* java_thread = nullptr;
1431 if (thread_id == 0) {
1432 // current thread
1433 return os::current_thread_cpu_time();
1434 } else {
1435 ThreadsListHandle tlh;
1436 java_thread = tlh.list()->find_JavaThread_from_java_tid(thread_id);
1437 if (is_platform_thread(java_thread)) {
1438 return os::thread_cpu_time((Thread*) java_thread);
1439 }
1440 }
1441 return -1;
1442 JVM_END
1443
1444 // Returns a String array of all VM global flag names
1445 JVM_ENTRY(jobjectArray, jmm_GetVMGlobalNames(JNIEnv *env))
1446 // last flag entry is always null, so subtract 1
1447 int nFlags = (int) JVMFlag::numFlags - 1;
1448 // allocate a temp array
1449 refArrayOop r = oopFactory::new_refArray(vmClasses::String_klass(),
1450 nFlags,
1451 CHECK_NULL);
1452 refArrayHandle flags_ah(THREAD, r);
1453 int num_entries = 0;
1454 for (int i = 0; i < nFlags; i++) {
1455 JVMFlag* flag = &JVMFlag::flags[i];
1456 // Exclude develop flags in product builds.
1457 if (flag->is_constant_in_binary()) {
1458 continue;
1459 }
1460 // Exclude the locked (experimental, diagnostic) flags
1461 if (flag->is_unlocked() || flag->is_unlocker()) {
1462 Handle s = java_lang_String::create_from_str(flag->name(), CHECK_NULL);
1463 flags_ah->obj_at_put(num_entries, s());
1464 num_entries++;
1465 }
1466 }
1467
1468 if (num_entries < nFlags) {
1469 // Return array of right length
1470 refArrayOop res = oopFactory::new_refArray(vmClasses::String_klass(), num_entries, CHECK_NULL);
1471 for(int i = 0; i < num_entries; i++) {
1472 res->obj_at_put(i, flags_ah->obj_at(i));
1473 }
1474 return (jobjectArray)JNIHandles::make_local(THREAD, res);
1475 }
1476
1477 return (jobjectArray)JNIHandles::make_local(THREAD, flags_ah());
1478 JVM_END
1479
1480 // Utility function used by jmm_GetVMGlobals. Returns false if flag type
1481 // can't be determined, true otherwise. If false is returned, then *global
1482 // will be incomplete and invalid.
1483 static bool add_global_entry(Handle name, jmmVMGlobal *global, JVMFlag *flag, TRAPS) {
1484 Handle flag_name;
1485 if (name() == nullptr) {
1486 flag_name = java_lang_String::create_from_str(flag->name(), CHECK_false);
1487 } else {
1488 flag_name = name;
1489 }
1490 global->name = (jstring)JNIHandles::make_local(THREAD, flag_name());
1556 // Fill globals array of count length with jmmVMGlobal entries
1557 // specified by names. If names == null, fill globals array
1558 // with all Flags. Return value is number of entries
1559 // created in globals.
1560 // If a JVMFlag with a given name in an array element does not
1561 // exist, globals[i].name will be set to null.
1562 JVM_ENTRY(jint, jmm_GetVMGlobals(JNIEnv *env,
1563 jobjectArray names,
1564 jmmVMGlobal *globals,
1565 jint count))
1566
1567
1568 if (globals == nullptr) {
1569 THROW_(vmSymbols::java_lang_NullPointerException(), 0);
1570 }
1571
1572 ResourceMark rm(THREAD);
1573
1574 if (names != nullptr) {
1575 // return the requested globals
1576 refArrayOop ta = oop_cast<refArrayOop>(JNIHandles::resolve_non_null(names));
1577 refArrayHandle names_ah(THREAD, ta);
1578 // Make sure we have a String array
1579 Klass* element_klass = names_ah->klass()->element_klass();
1580 if (element_klass != vmClasses::String_klass()) {
1581 THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(),
1582 "Array element type is not String class", 0);
1583 }
1584
1585 int names_length = names_ah->length();
1586 int num_entries = 0;
1587 for (int i = 0; i < names_length && i < count; i++) {
1588 oop s = names_ah->obj_at(i);
1589 if (s == nullptr) {
1590 THROW_(vmSymbols::java_lang_NullPointerException(), 0);
1591 }
1592
1593 Handle sh(THREAD, s);
1594 char* str = java_lang_String::as_utf8_string(s);
1595 JVMFlag* flag = JVMFlag::find_flag(str);
1596 if (flag != nullptr &&
1597 add_global_entry(sh, &globals[i], flag, THREAD)) {
1598 num_entries++;
1599 } else {
1983 ResourceMark rm(THREAD);
1984 GrowableArray<const char *>* dcmd_list = DCmdFactory::DCmd_list(DCmd_Source_MBean);
1985 objArrayOop cmd_array_oop = oopFactory::new_objArray(vmClasses::String_klass(),
1986 dcmd_list->length(), CHECK_NULL);
1987 objArrayHandle cmd_array(THREAD, cmd_array_oop);
1988 for (int i = 0; i < dcmd_list->length(); i++) {
1989 oop cmd_name = java_lang_String::create_oop_from_str(dcmd_list->at(i), CHECK_NULL);
1990 cmd_array->obj_at_put(i, cmd_name);
1991 }
1992 return (jobjectArray) JNIHandles::make_local(THREAD, cmd_array());
1993 JVM_END
1994
1995 JVM_ENTRY(void, jmm_GetDiagnosticCommandInfo(JNIEnv *env, jobjectArray cmds,
1996 dcmdInfo* infoArray))
1997 if (cmds == nullptr || infoArray == nullptr) {
1998 THROW(vmSymbols::java_lang_NullPointerException());
1999 }
2000
2001 ResourceMark rm(THREAD);
2002
2003 refArrayOop ca = oop_cast<refArrayOop>(JNIHandles::resolve_non_null(cmds));
2004 refArrayHandle cmds_ah(THREAD, ca);
2005
2006 // Make sure we have a String array
2007 Klass* element_klass = cmds_ah->klass()->element_klass();
2008 if (element_klass != vmClasses::String_klass()) {
2009 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
2010 "Array element type is not String class");
2011 }
2012
2013 GrowableArray<DCmdInfo *>* info_list = DCmdFactory::DCmdInfo_list(DCmd_Source_MBean);
2014
2015 int num_cmds = cmds_ah->length();
2016 for (int i = 0; i < num_cmds; i++) {
2017 oop cmd = cmds_ah->obj_at(i);
2018 if (cmd == nullptr) {
2019 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
2020 "Command name cannot be null.");
2021 }
2022 char* cmd_name = java_lang_String::as_utf8_string(cmd);
2023 if (cmd_name == nullptr) {
2024 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
2025 "Command name cannot be null.");
2026 }
2027 int pos = info_list->find_if([&](DCmdInfo* info) {
|