--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/hotspot/share/prims/jvmtiTrace.cpp Tue Sep 12 19:03:39 2017 +0200
@@ -0,0 +1,312 @@
+/*
+ * Copyright (c) 2003, 2016, 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 "jvmtifiles/jvmtiEnv.hpp"
+#include "logging/log.hpp"
+#include "logging/logConfiguration.hpp"
+#include "memory/resourceArea.hpp"
+#include "prims/jvmtiTrace.hpp"
+
+//
+// class JvmtiTrace
+//
+// Support for JVMTI tracing code
+//
+// ------------
+// Usage:
+// -XX:TraceJVMTI=DESC,DESC,DESC
+//
+// DESC is DOMAIN ACTION KIND
+//
+// DOMAIN is function name
+// event name
+// "all" (all functions and events)
+// "func" (all functions except boring)
+// "allfunc" (all functions)
+// "event" (all events)
+// "ec" (event controller)
+//
+// ACTION is "+" (add)
+// "-" (remove)
+//
+// KIND is
+// for func
+// "i" (input params)
+// "e" (error returns)
+// "o" (output)
+// for event
+// "t" (event triggered aka posted)
+// "s" (event sent)
+//
+// Example:
+// -XX:TraceJVMTI=ec+,GetCallerFrame+ie,Breakpoint+s
+
+#ifdef JVMTI_TRACE
+
+bool JvmtiTrace::_initialized = false;
+bool JvmtiTrace::_on = false;
+bool JvmtiTrace::_trace_event_controller = false;
+
+void JvmtiTrace::initialize() {
+ if (_initialized) {
+ return;
+ }
+ SafeResourceMark rm;
+
+ const char *very_end;
+ const char *curr;
+ if (TraceJVMTI != NULL) {
+ curr = TraceJVMTI;
+ } else {
+ curr = ""; // hack in fixed tracing here
+ }
+
+ // Enable UL for JVMTI tracing
+ if (strlen(curr) > 0) {
+ if (!log_is_enabled(Trace, jvmti)) {
+ log_warning(arguments)("-XX:+TraceJVMTI specified, "
+ "but no log output configured for the 'jvmti' tag on Trace level. "
+ "Defaulting to -Xlog:jvmti=trace");
+ LogConfiguration::configure_stdout(LogLevel::Trace, true, LOG_TAGS(jvmti));
+ }
+ }
+
+ very_end = curr + strlen(curr);
+ while (curr < very_end) {
+ const char *curr_end = strchr(curr, ',');
+ if (curr_end == NULL) {
+ curr_end = very_end;
+ }
+ const char *op_pos = strchr(curr, '+');
+ const char *minus_pos = strchr(curr, '-');
+ if (minus_pos != NULL && (minus_pos < op_pos || op_pos == NULL)) {
+ op_pos = minus_pos;
+ }
+ char op;
+ const char *flags = op_pos + 1;
+ const char *flags_end = curr_end;
+ if (op_pos == NULL || op_pos > curr_end) {
+ flags = "ies";
+ flags_end = flags + strlen(flags);
+ op_pos = curr_end;
+ op = '+';
+ } else {
+ op = *op_pos;
+ }
+ jbyte bits = 0;
+ for (; flags < flags_end; ++flags) {
+ switch (*flags) {
+ case 'i':
+ bits |= SHOW_IN;
+ break;
+ case 'I':
+ bits |= SHOW_IN_DETAIL;
+ break;
+ case 'e':
+ bits |= SHOW_ERROR;
+ break;
+ case 'o':
+ bits |= SHOW_OUT;
+ break;
+ case 'O':
+ bits |= SHOW_OUT_DETAIL;
+ break;
+ case 't':
+ bits |= SHOW_EVENT_TRIGGER;
+ break;
+ case 's':
+ bits |= SHOW_EVENT_SENT;
+ break;
+ default:
+ log_warning(jvmti)("Invalid trace flag '%c'", *flags);
+ break;
+ }
+ }
+ const int FUNC = 1;
+ const int EXCLUDE = 2;
+ const int ALL_FUNC = 4;
+ const int EVENT = 8;
+ const int ALL_EVENT = 16;
+ int domain = 0;
+ size_t len = op_pos - curr;
+ if (op_pos == curr) {
+ domain = ALL_FUNC | FUNC | ALL_EVENT | EVENT | EXCLUDE;
+ } else if (len==3 && strncmp(curr, "all", 3)==0) {
+ domain = ALL_FUNC | FUNC | ALL_EVENT | EVENT;
+ } else if (len==7 && strncmp(curr, "allfunc", 7)==0) {
+ domain = ALL_FUNC | FUNC;
+ } else if (len==4 && strncmp(curr, "func", 4)==0) {
+ domain = ALL_FUNC | FUNC | EXCLUDE;
+ } else if (len==8 && strncmp(curr, "allevent", 8)==0) {
+ domain = ALL_EVENT | EVENT;
+ } else if (len==5 && strncmp(curr, "event", 5)==0) {
+ domain = ALL_EVENT | EVENT;
+ } else if (len==2 && strncmp(curr, "ec", 2)==0) {
+ _trace_event_controller = true;
+ log_trace(jvmti)("Tracing the event controller");
+ } else {
+ domain = FUNC | EVENT; // go searching
+ }
+
+ int exclude_index = 0;
+ if (domain & FUNC) {
+ if (domain & ALL_FUNC) {
+ if (domain & EXCLUDE) {
+ log_trace(jvmti)("Tracing all significant functions");
+ } else {
+ log_trace(jvmti)("Tracing all functions");
+ }
+ }
+ for (int i = 0; i <= _max_function_index; ++i) {
+ if (domain & EXCLUDE && i == _exclude_functions[exclude_index]) {
+ ++exclude_index;
+ } else {
+ bool do_op = false;
+ if (domain & ALL_FUNC) {
+ do_op = true;
+ } else {
+ const char *fname = function_name(i);
+ if (fname != NULL) {
+ size_t fnlen = strlen(fname);
+ if (len==fnlen && strncmp(curr, fname, fnlen)==0) {
+ log_trace(jvmti)("Tracing the function: %s", fname);
+ do_op = true;
+ }
+ }
+ }
+ if (do_op) {
+ if (op == '+') {
+ _trace_flags[i] |= bits;
+ } else {
+ _trace_flags[i] &= ~bits;
+ }
+ _on = true;
+ }
+ }
+ }
+ }
+ if (domain & EVENT) {
+ if (domain & ALL_EVENT) {
+ log_trace(jvmti)("Tracing all events");
+ }
+ for (int i = 0; i <= _max_event_index; ++i) {
+ bool do_op = false;
+ if (domain & ALL_EVENT) {
+ do_op = true;
+ } else {
+ const char *ename = event_name(i);
+ if (ename != NULL) {
+ size_t evtlen = strlen(ename);
+ if (len==evtlen && strncmp(curr, ename, evtlen)==0) {
+ log_trace(jvmti)("Tracing the event: %s", ename);
+ do_op = true;
+ }
+ }
+ }
+ if (do_op) {
+ if (op == '+') {
+ _event_trace_flags[i] |= bits;
+ } else {
+ _event_trace_flags[i] &= ~bits;
+ }
+ _on = true;
+ }
+ }
+ }
+ if (!_on && (domain & (FUNC|EVENT))) {
+ log_warning(jvmti)("Trace domain not found");
+ }
+ curr = curr_end + 1;
+ }
+ _initialized = true;
+}
+
+
+void JvmtiTrace::shutdown() {
+ int i;
+ _on = false;
+ _trace_event_controller = false;
+ for (i = 0; i <= _max_function_index; ++i) {
+ _trace_flags[i] = 0;
+ }
+ for (i = 0; i <= _max_event_index; ++i) {
+ _event_trace_flags[i] = 0;
+ }
+}
+
+
+const char* JvmtiTrace::enum_name(const char** names, const jint* values, jint value) {
+ for (int index = 0; names[index] != 0; ++index) {
+ if (values[index] == value) {
+ return names[index];
+ }
+ }
+ return "*INVALID-ENUM-VALUE*";
+}
+
+
+// return a valid string no matter what state the thread is in
+const char *JvmtiTrace::safe_get_thread_name(Thread *thread) {
+ if (thread == NULL) {
+ return "NULL";
+ }
+ if (!thread->is_Java_thread()) {
+ return thread->name();
+ }
+ JavaThread *java_thread = (JavaThread *)thread;
+ oop threadObj = java_thread->threadObj();
+ if (threadObj == NULL) {
+ return "NULL";
+ }
+ oop name = java_lang_Thread::name(threadObj);
+ if (name == NULL) {
+ return "<NOT FILLED IN>";
+ }
+ return java_lang_String::as_utf8_string(name);
+}
+
+
+// return the name of the current thread
+const char *JvmtiTrace::safe_get_current_thread_name() {
+ if (JvmtiEnv::is_vm_live()) {
+ return JvmtiTrace::safe_get_thread_name(Thread::current());
+ } else {
+ return "VM not live";
+ }
+}
+
+// return a valid string no matter what the state of k_mirror
+const char * JvmtiTrace::get_class_name(oop k_mirror) {
+ if (java_lang_Class::is_primitive(k_mirror)) {
+ return "primitive";
+ }
+ Klass* k_oop = java_lang_Class::as_Klass(k_mirror);
+ if (k_oop == NULL) {
+ return "INVALID";
+ }
+ return k_oop->external_name();
+}
+
+#endif /*JVMTI_TRACE */