8314745: JFR: @StackFilter

Reviewed-by: mgronlun

Author: egahlin

src/hotspot/share/jfr/jni/jfrJavaSupport.cpp

@@ -525,6 +525,33 @@ const char* JfrJavaSupport::c_str(jstring string, Thread* thread, bool c_heap /*
   return string != nullptr ? c_str(resolve_non_null(string), thread, c_heap) : nullptr;
 }
 
+static Symbol** allocate_symbol_array(bool c_heap, int length, Thread* thread) {
+  return c_heap ?
+           NEW_C_HEAP_ARRAY(Symbol*, length, mtTracing) :
+           NEW_RESOURCE_ARRAY_IN_THREAD(thread, Symbol*, length);
+}
+
+Symbol** JfrJavaSupport::symbol_array(jobjectArray string_array, JavaThread* thread, intptr_t* result_array_size, bool c_heap /* false */) {
+  DEBUG_ONLY(JfrJavaSupport::check_java_thread_in_vm(thread));
+  assert(string_array != nullptr, "invariant");
+  assert(result_array_size != nullptr, "invariant");
+  objArrayOop arrayOop = objArrayOop(resolve_non_null(string_array));
+  const int length = arrayOop->length();
+  *result_array_size = length;
+  Symbol** result_array = allocate_symbol_array(c_heap, length, thread);
+  assert(result_array != nullptr, "invariant");
+  for (int i = 0; i < length; i++) {
+    oop object = arrayOop->obj_at(i);
+    Symbol* symbol = nullptr;
+    if (object != nullptr) {
+      const char* text = c_str(arrayOop->obj_at(i), thread, c_heap);
+      symbol = SymbolTable::new_symbol(text);
+    }
+    result_array[i] = symbol;
+  }
+  return result_array;
+}
+
 /*
  *  Exceptions and errors
  */

src/hotspot/share/jfr/jni/jfrJavaSupport.hpp

@@ -86,6 +86,7 @@ class JfrJavaSupport : public AllStatic {
   static Klass* klass(const jobject handle);
   static const char* c_str(jstring string, Thread* thread, bool c_heap = false);
   static const char* c_str(oop string, Thread* thread, bool c_heap = false);
+  static Symbol** symbol_array(jobjectArray string_array, JavaThread* thread, intptr_t* result_size, bool c_heap = false);
 
   // exceptions
   static void throw_illegal_state_exception(const char* message, TRAPS);

src/hotspot/share/jfr/jni/jfrJniMethod.cpp

@@ -36,6 +36,8 @@
 #include "jfr/recorder/repository/jfrEmergencyDump.hpp"
 #include "jfr/recorder/service/jfrEventThrottler.hpp"
 #include "jfr/recorder/service/jfrOptionSet.hpp"
+#include "jfr/recorder/stacktrace/jfrStackFilter.hpp"
+#include "jfr/recorder/stacktrace/jfrStackFilterRegistry.hpp"
 #include "jfr/recorder/stacktrace/jfrStackTraceRepository.hpp"
 #include "jfr/recorder/stringpool/jfrStringPool.hpp"
 #include "jfr/jni/jfrJavaSupport.hpp"
@@ -239,8 +241,8 @@ JVM_ENTRY_NO_ENV(jlong, jfr_class_id(JNIEnv* env, jclass jvm, jclass jc))
   return JfrTraceId::load(jc);
 JVM_END
 
-JVM_ENTRY_NO_ENV(jlong, jfr_stacktrace_id(JNIEnv* env, jclass jvm, jint skip))
-  return JfrStackTraceRepository::record(thread, skip);
+JVM_ENTRY_NO_ENV(jlong, jfr_stacktrace_id(JNIEnv* env, jclass jvm, jint skip, jlong stack_filter_id))
+  return JfrStackTraceRepository::record(thread, skip, stack_filter_id);
 JVM_END
 
 JVM_ENTRY_NO_ENV(void, jfr_log(JNIEnv* env, jclass jvm, jint tag_set, jint level, jstring message))
@@ -397,3 +399,11 @@ JVM_END
 JVM_ENTRY_NO_ENV(void, jfr_emit_data_loss(JNIEnv* env, jclass jvm, jlong bytes))
   EventDataLoss::commit(bytes, min_jlong);
 JVM_END
+
+JVM_ENTRY_NO_ENV(jlong, jfr_register_stack_filter(JNIEnv* env,  jclass jvm, jobjectArray classes, jobjectArray methods))
+  return JfrStackFilterRegistry::add(classes, methods, thread);
+JVM_END
+
+JVM_ENTRY_NO_ENV(void, jfr_unregister_stack_filter(JNIEnv* env,  jclass jvm, jlong id))
+  JfrStackFilterRegistry::remove(id);
+JVM_END

src/hotspot/share/jfr/jni/jfrJniMethod.hpp

@@ -57,7 +57,7 @@ jlong JNICALL jfr_class_id(JNIEnv* env, jclass jvm, jclass jc);
 
 jstring JNICALL jfr_get_pid(JNIEnv* env, jclass jvm);
 
-jlong JNICALL jfr_stacktrace_id(JNIEnv* env, jclass jvm, jint skip);
+jlong JNICALL jfr_stacktrace_id(JNIEnv* env, jclass jvm, jint skip, jlong stack_filter_id);
 
 jlong JNICALL jfr_elapsed_frequency(JNIEnv* env, jclass jvm);
 
@@ -159,6 +159,10 @@ jlong JNICALL jfr_host_total_memory(JNIEnv* env, jclass jvm);
 
 void JNICALL jfr_emit_data_loss(JNIEnv* env, jclass jvm, jlong bytes);
 
+jlong JNICALL jfr_register_stack_filter(JNIEnv* env, jobject classes, jobject methods);
+
+jlong JNICALL jfr_unregister_stack_filter(JNIEnv* env, jlong start_filter_id);
+
 #ifdef __cplusplus
 }
 #endif

src/hotspot/share/jfr/jni/jfrJniMethodRegistration.cpp

@@ -46,7 +46,7 @@ JfrJniMethodRegistration::JfrJniMethodRegistration(JNIEnv* env) {
       (char*)"getAllEventClasses", (char*)"()Ljava/util/List;", (void*)jfr_get_all_event_classes,
       (char*)"getClassId", (char*)"(Ljava/lang/Class;)J", (void*)jfr_class_id,
       (char*)"getPid", (char*)"()Ljava/lang/String;", (void*)jfr_get_pid,
-      (char*)"getStackTraceId", (char*)"(I)J", (void*)jfr_stacktrace_id,
+      (char*)"getStackTraceId", (char*)"(IJ)J", (void*)jfr_stacktrace_id,
       (char*)"getThreadId", (char*)"(Ljava/lang/Thread;)J", (void*)jfr_id_for_thread,
       (char*)"getTicksFrequency", (char*)"()J", (void*)jfr_elapsed_frequency,
       (char*)"subscribeLogLevel", (char*)"(Ljdk/jfr/internal/LogTag;I)V", (void*)jfr_subscribe_log_level,
@@ -97,7 +97,9 @@ JfrJniMethodRegistration::JfrJniMethodRegistration(JNIEnv* env) {
       (char*)"isInstrumented", (char*)"(Ljava/lang/Class;)Z", (void*) jfr_is_class_instrumented,
       (char*)"isContainerized", (char*)"()Z", (void*) jfr_is_containerized,
       (char*)"hostTotalMemory", (char*)"()J", (void*) jfr_host_total_memory,
-      (char*)"emitDataLoss", (char*)"(J)V", (void*)jfr_emit_data_loss
+      (char*)"emitDataLoss", (char*)"(J)V", (void*)jfr_emit_data_loss,
+      (char*)"registerStackFilter", (char*)"([Ljava/lang/String;[Ljava/lang/String;)J", (void*)jfr_register_stack_filter,
+      (char*)"unregisterStackFilter", (char*)"(J)V", (void*)jfr_unregister_stack_filter
     };
 
     const size_t method_array_length = sizeof(method) / sizeof(JNINativeMethod);

src/hotspot/share/jfr/recorder/stacktrace/jfrStackFilter.cpp

@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2023, 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 "jfr/recorder/stacktrace/jfrStackFilter.hpp"
+#include "oops/method.hpp"
+#include "oops/symbol.hpp"
+
+JfrStackFilter::JfrStackFilter(Symbol** class_names, Symbol** method_names, size_t count)
+  : _count(count),
+    _class_names(class_names),
+    _method_names(method_names) {
+  assert(_class_names != nullptr, "invariant");
+  assert(_method_names != nullptr, "invariant");
+}
+
+bool JfrStackFilter::match(const Method* method) const {
+  assert(method != nullptr, "Invariant");
+  const Symbol* const method_name = method->name();
+  const Symbol* const klass_name = method->klass_name();
+  for (size_t i = 0; i < _count; i++) {
+    const Symbol* m = _method_names[i];
+    if (m == nullptr || m == method_name) {
+      const Symbol* c = _class_names[i];
+      if (c == nullptr || c == klass_name) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+JfrStackFilter::~JfrStackFilter() {
+  for (size_t i = 0; i < _count; i++) {
+    Symbol::maybe_decrement_refcount(_method_names[i]);
+    Symbol::maybe_decrement_refcount(_class_names[i]);
+  }
+  FREE_C_HEAP_ARRAY(Symbol*, _method_names);
+  FREE_C_HEAP_ARRAY(Symbol*, _class_names);
+}

src/hotspot/share/jfr/recorder/stacktrace/jfrStackFilter.hpp

@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2023, 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.
+ *
+ */
+
+#ifndef SHARE_JFR_RECORDER_STACKTRACE_JFRSTACKFILTER_HPP
+#define SHARE_JFR_RECORDER_STACKTRACE_JFRSTACKFILTER_HPP
+
+#include "jfr/utilities/jfrAllocation.hpp"
+
+class Mathod;
+class Symbol;
+
+class JfrStackFilter : public JfrCHeapObj {
+ private:
+  size_t _count;
+  Symbol** _class_names;
+  Symbol** _method_names;
+
+ public:
+  JfrStackFilter(Symbol** class_names, Symbol** method_names, size_t count);
+  ~JfrStackFilter();
+  bool match(const Method* method) const;
+};
+
+#endif // SHARE_JFR_RECORDER_STACKTRACE_JFRSTACKFILTER_HPP

src/hotspot/share/jfr/recorder/stacktrace/jfrStackFilterRegistry.cpp

@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2023, 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 "jfr/jni/jfrJavaSupport.hpp"
+#include "jfr/recorder/stacktrace/jfrStackFilter.hpp"
+#include "jfr/recorder/stacktrace/jfrStackFilterRegistry.hpp"
+#include "logging/log.hpp"
+
+static const intptr_t STACK_FILTER_ELEMENTS_SIZE = 4096;
+static const intptr_t STACK_FILTER_ERROR_CODE = -1;
+static const JfrStackFilter* _elements[STACK_FILTER_ELEMENTS_SIZE];
+static intptr_t _free_list[STACK_FILTER_ELEMENTS_SIZE];
+static intptr_t _index = 0;
+static intptr_t _free_list_index = 0;
+
+int64_t JfrStackFilterRegistry::add(jobjectArray classes, jobjectArray methods, JavaThread* jt) {
+  intptr_t c_size = 0;
+  Symbol** class_names = JfrJavaSupport::symbol_array(classes, jt, &c_size, true);
+  assert(class_names != nullptr, "invariant");
+  intptr_t m_size = 0;
+  Symbol** method_names = JfrJavaSupport::symbol_array(methods, jt, &m_size, true);
+  assert(method_names != nullptr, "invariant");
+  if (c_size != m_size) {
+    FREE_C_HEAP_ARRAY(Symbol*, class_names);
+    FREE_C_HEAP_ARRAY(Symbol*, method_names);
+    JfrJavaSupport::throw_internal_error("Method array size doesn't match class array size", jt);
+    return STACK_FILTER_ERROR_CODE;
+  }
+  assert(c_size >= 0, "invariant");
+  const JfrStackFilter* filter = new JfrStackFilter(class_names, method_names, static_cast<size_t>(c_size));
+  return JfrStackFilterRegistry::add(filter);
+}
+
+#ifdef ASSERT
+static bool range_check(int64_t idx) {
+  return idx < STACK_FILTER_ELEMENTS_SIZE && idx >= 0;
+}
+#endif
+
+int64_t JfrStackFilterRegistry::add(const JfrStackFilter* filter) {
+  if (_free_list_index > 0) {
+    assert(range_check(_free_list_index), "invariant");
+    const intptr_t free_index = _free_list[_free_list_index - 1];
+    _elements[free_index] = filter;
+    _free_list_index--;
+    return free_index;
+  }
+  if (_index >= STACK_FILTER_ELEMENTS_SIZE - 1) {
+    log_warning(jfr)("Maximum number of @StackFrame in use has been reached.");
+    return STACK_FILTER_ERROR_CODE;
+  }
+  assert(range_check(_index), "invariant");
+  _elements[_index] = filter;
+  return _index++;
+}
+
+const JfrStackFilter* JfrStackFilterRegistry::lookup(int64_t id) {
+  if (id < 0) {
+    return nullptr;
+  }
+  assert(range_check(id), "invariant");
+  return _elements[id];
+}
+
+void JfrStackFilterRegistry::remove(int64_t index) {
+  assert(range_check(index), "invariant");
+  delete _elements[index];
+  if (_free_list_index < STACK_FILTER_ELEMENTS_SIZE - 1) {
+    assert(range_check(_free_list_index), "invariant");
+    _free_list[_free_list_index++] = index;
+  }
+}

src/hotspot/share/jfr/recorder/stacktrace/jfrStackFilterRegistry.hpp

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2023, 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.
+ *
+ */
+
+#ifndef SHARE_JFR_RECORDER_STACKTRACE_JFRSTCKFILTERREGISTRY_HPP
+#define SHARE_JFR_RECORDER_STACKTRACE_JFRSTCKFILTERREGISTRY_HPP
+
+#include "jni.h"
+#include "jfr/utilities/jfrAllocation.hpp"
+
+class JavaThread;
+class JfrStackFilter;
+
+class JfrStackFilterRegistry : AllStatic {
+ private:
+  static int64_t add(const JfrStackFilter* frame);
+ public:
+  static int64_t add(jobjectArray classes, jobjectArray methods, JavaThread* jt);
+  static void remove(int64_t id);
+  static const JfrStackFilter* lookup(int64_t id);
+};
+
+#endif // SHARE_JFR_RECORDER_STACKTRACE_JFRSTCKFILTERREGISTRY_HPP