/hg/icedtea6: Add systemtap jstack support.
mjw at icedtea.classpath.org
mjw at icedtea.classpath.org
Sun Dec 13 13:27:49 PST 2009
changeset 6eb1a59f370f in /hg/icedtea6
details: http://icedtea.classpath.org/hg/icedtea6?cmd=changeset;node=6eb1a59f370f
author: Mark Wielaard <mark at klomp.org>
date: Sun Dec 13 22:32:25 2009 +0100
Add systemtap jstack support.
* Makefile.am (stamps/icedtea.stamp): Install jstack.stp. (stamps
/icedtea-debug.stamp): Likewise.
* configure.ac (AC_CONFIG_FILES): Add tapset/jstack.stp.
* tapset/jstack.stp.in: New tapset.
diffstat:
4 files changed, 517 insertions(+), 2 deletions(-)
ChangeLog | 7
Makefile.am | 8
configure.ac | 1
tapset/jstack.stp.in | 503 ++++++++++++++++++++++++++++++++++++++++++++++++++
diffs (truncated from 557 to 500 lines):
diff -r 638dec038e6f -r 6eb1a59f370f ChangeLog
--- a/ChangeLog Fri Dec 11 16:55:40 2009 +0000
+++ b/ChangeLog Sun Dec 13 22:32:25 2009 +0100
@@ -1,3 +1,10 @@ 2009-12-11 Andrew Haley <aph at redhat.co
+2009-12-13 Mark Wielaard <mjw at redhat.com>
+
+ * Makefile.am (stamps/icedtea.stamp): Install jstack.stp.
+ (stamps/icedtea-debug.stamp): Likewise.
+ * configure.ac (AC_CONFIG_FILES): Add tapset/jstack.stp.
+ * tapset/jstack.stp.in: New tapset.
+
2009-12-11 Andrew Haley <aph at redhat.com>
* patches/icedtea-linux-separate-debuginfo.patch: Add #ifdef
diff -r 638dec038e6f -r 6eb1a59f370f Makefile.am
--- a/Makefile.am Fri Dec 11 16:55:40 2009 +0000
+++ b/Makefile.am Sun Dec 13 22:32:25 2009 +0100
@@ -1255,7 +1255,9 @@ if ENABLE_SYSTEMTAP
$(BUILD_OUTPUT_DIR)/j2sdk-image/tapset/hotspot.stp; \
cp $(abs_top_builddir)/tapset/hotspot_jni.stp \
$(BUILD_OUTPUT_DIR)/j2sdk-image/tapset/hotspot_jni.stp; \
- fi
+ fi; \
+ cp $(abs_top_builddir)/tapset/jstack.stp \
+ $(BUILD_OUTPUT_DIR)/j2sdk-image/tapset/jstack.stp
endif
if ENABLE_NSS
cp $(abs_top_builddir)/nss.cfg \
@@ -1352,7 +1354,9 @@ if ENABLE_SYSTEMTAP
$(BUILD_OUTPUT_DIR)/j2sdk-image/tapset/hotspot.stp; \
cp $(abs_top_builddir)/tapset/hotspot_jni.stp \
$(BUILD_OUTPUT_DIR)/j2sdk-image/tapset/hotspot_jni.stp; \
- fi
+ fi; \
+ cp $(abs_top_builddir)/tapset/jstack.stp \
+ $(BUILD_OUTPUT_DIR)/j2sdk-image/tapset/jstack.stp
endif
if ENABLE_NSS
cp $(abs_top_builddir)/nss.cfg \
diff -r 638dec038e6f -r 6eb1a59f370f configure.ac
--- a/configure.ac Fri Dec 11 16:55:40 2009 +0000
+++ b/configure.ac Sun Dec 13 22:32:25 2009 +0100
@@ -389,6 +389,7 @@ public:
AC_SUBST(ABS_SERVER_LIBJVM_SO)
AC_CONFIG_FILES([tapset/hotspot.stp])
AC_CONFIG_FILES([tapset/hotspot_jni.stp])
+ AC_CONFIG_FILES([tapset/jstack.stp])
fi
dnl Check for libpng headers and libraries.
diff -r 638dec038e6f -r 6eb1a59f370f tapset/jstack.stp.in
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/tapset/jstack.stp.in Sun Dec 13 22:32:25 2009 +0100
@@ -0,0 +1,503 @@
+/* jstack systemtap tapset, for extracting hotspot java backtraces.
+ Copyright (C) 2009, Red Hat Inc.
+
+This file is part of IcedTea.
+
+IcedTea is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+IcedTea 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 for more details.
+
+You should have received a copy of the GNU General Public License
+along with IcedTea; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+*/
+
+/*
+ Provides helper functions to log and print hotspot java based backtraces.
+ jstack() provides up to 32 pure java frames from the current probe point
+ (space separated). jstack_print() does the same, but logs each frame
+ immediately. jstack_full() provides up to 32 "mixed" frames, including
+ full method signatures plus native code frames. print_jstack_full() does
+ the same, but prints eachs frame to the log immediately. To request
+ more or less frames use the jstack_n(), jstack_full_n(), print_jstack_n()
+ and print_jstack_full_n() variants. And to have full controll over the
+ amount of information included in each frame use the jstack_call()
+ function.
+
+ Currently only works with full path in process probes below.
+ When things don't seem to work look if the correct
+ jre/lib/[arch]/[client|server]/libjvm.so is used
+ and exists under @ABS_JAVA_HOME_DIR@/.
+ This version of jstack.stp has been configured to instrument the
+ libjvm.so for arch @INSTALL_ARCH_DIR@ installed at:
+ @ABS_CLIENT_LIBJVM_SO@
+ @ABS_SERVER_LIBJVM_SO@
+
+ Note that you need a systemtap version > 1.0.
+ Otherwise you will not be able to fetch global vars, which would show as:
+ semantic error: failed to retrieve location attribute for local
+*/
+
+global Universe_methodKlassObj;
+global Universe_collectedHeap;
+global HeapWordSize;
+global CodeCache_heap;
+
+global sp_register;
+global fp_register;
+global pc_register;
+global ptr_size;
+global ptr_mask;
+
+global constantPoolOopDesc_size;
+global HeapBlock_Header_size;
+global oopDesc_size;
+
+global vm_inited;
+
+/* We need to collect some global symbol addresses that cannot be resolved
+ in a bare function and vm_init_end seems a good place to use. */
+probe hotspot.vm_init_end
+{
+ // The parent/type oop for a methodOop.
+ Universe_methodKlassObj = $_methodKlassObj;
+
+ // For compressed oops.
+ // Universe_heap_base = $_heap_base;
+
+ /**
+ * The Universe class holds some of the interesting statics for
+ * introspection into HotSpot. The CollectedHeap
+ * (Universe::_collectedHeap) is an abstraction of a java heap for Hotspot
+ * it contains a _reserved MemRegion which represents a contigous
+ * region of the address space consisting of HeapWords (which just
+ * have one field member char *i).
+ *
+ * Note that we access it through its "short name" _collectedHeap.
+ */
+ Universe_collectedHeap = $_collectedHeap;
+ HeapWordSize = $HeapWordSize;
+
+ /**
+ * The CodeCache class contains the static CodeHeap _heap that
+ * is malloced at the start of the vm run and holds all generated
+ * code. If the program counter is between the low and high memory
+ * marks of the CodeHeap then it is generated code. Note that the
+ * interpreter CodeBlob itself is also generated at runtime.
+ *
+ * The code heap is made up of segments which are described in the
+ * CodeHeap _segmap. Each segment is of size _segment_size, which
+ * must be an exact power of 2 (_log2_segment_size). For each segment
+ * the _segmap has an unsigned char which is 0xFF if the segment
+ * isn't used, 0 if the segment is the start of a block and N
+ * (Where in is 1 till 0xFE) to indicate the segment belongs to
+ * the segment at index - N (which can be recursive if a block
+ * contains more than 0xFE segments).
+ */
+ CodeCache_heap = $_heap;
+
+ // Should really check arch of user space (for 32bit jvm on 64bit kernel).
+ %( arch == "i386" %?
+ sp_register = "esp";
+ fp_register = "ebp";
+ pc_register = "eip";
+ ptr_size = 4;
+ ptr_mask = 0xFFFFFFFF;
+ constantPoolOopDesc_size = 32; // Should use dwarf @size
+ %: %(arch == "x86_64" %?
+ sp_register = "rsp";
+ fp_register = "rbp";
+ pc_register = "rip";
+ ptr_size = 8; // XXX - might be probing 32-on-64 jvm.
+ ptr_mask = 0xFFFFFFFFFFFFFFFF;
+ constantPoolOopDesc_size = 56; // Should use dwarf @size
+ %: **ERROR** unknown architecture
+ %) %)
+
+ // Really should get from dwarf: @size("HeapBlock::Header"), @size("oopDesc")
+ HeapBlock_Header_size = 2 * ptr_size;
+ oopDesc_size = 2 * ptr_size;
+
+ vm_inited = 1;
+}
+
+function jstack:string()
+{
+ // java backtraces can be a lot bigger, but we risk going over MAXACTION.
+ // 32 frames only gives us ~32 actions per frame (with MAXACTION == 1024).
+ max_depth = 32;
+
+ return jstack_n(max_depth);
+}
+
+function jstack_n:string(max_depth:long)
+{
+ // Whether to log the method signatures.
+ log_sig = 0;
+
+ // Set to zero to only print pure java frames
+ log_native = 0;
+
+ // whether to print or just return the frames as space separated string
+ print_frames = 0;
+
+ return jstack_call(max_depth, log_sig, log_native, print_frames);
+}
+
+function print_jstack()
+{
+ // java backtraces can be a lot bigger, but we risk going over MAXACTION.
+ // 32 frames only gives us ~32 actions per frame (with MAXACTION == 1024).
+ max_depth = 32;
+
+ return print_jstack_n(max_depth);
+}
+
+function print_jstack_n:string(max_depth:long)
+{
+ // Whether to log the method signatures.
+ log_sig = 0;
+
+ // Set to zero to only print pure java frames
+ log_native = 0;
+
+ // whether to print or just return the frames as space separated string
+ print_frames = 1;
+
+ jstack_call(max_depth, log_sig, log_native, print_frames);
+}
+
+function jstack_full:string()
+{
+ // java backtraces can be a lot bigger, but we risk going over MAXACTION.
+ // 32 frames only gives us ~32 actions per frame (with MAXACTION == 1024).
+ max_depth = 32;
+
+ return jstack_full_n(max_depth);
+}
+
+function jstack_full_n:string(max_depth:long)
+{
+ // Whether to log the method signatures.
+ log_sig = 1;
+
+ // Set to zero to only print pure java frames
+ log_native = 1;
+
+ // whether to print or just return the frames as space separated string
+ print_frames = 0;
+
+ return jstack_call(max_depth, log_sig, log_native, print_frames);
+}
+
+function print_jstack_full()
+{
+ // java backtraces can be a lot bigger, but we risk going over MAXACTION.
+ // 32 frames only gives us ~32 actions per frame (with MAXACTION == 1024).
+ max_depth = 32;
+
+ return print_jstack_full_n(max_depth);
+}
+
+function print_jstack_full_n:string(max_depth:long)
+{
+ // Whether to log the method signatures.
+ log_sig = 1;
+
+ // Set to zero to only print pure java frames
+ log_native = 1;
+
+ // whether to print or just return the frames as space separated string
+ print_frames = 1;
+
+ jstack_call(max_depth, log_sig, log_native, print_frames);
+}
+
+function jstack_call:string(max_depth:long, log_sig:long, log_native:long,
+ print_frames:long)
+{
+ if (! vm_inited)
+ {
+ frame = "<vm-not-inited>";
+ if (print_frames)
+ {
+ log(frame);
+ return "";
+ }
+ else
+ return frame;
+ }
+
+ // Extract heap and code bounds.
+ heap_start = @cast(Universe_collectedHeap,
+ "CollectedHeap",
+ "@ABS_SERVER_LIBJVM_SO@")->_reserved->_start;
+ heap_size = HeapWordSize * @cast(Universe_collectedHeap,
+ "CollectedHeap",
+ "@ABS_SERVER_LIBJVM_SO@")->_reserved->_word_size;
+ heap_end = heap_start + heap_size;
+
+ CodeCache_low = @cast(CodeCache_heap, "CodeHeap",
+ "@ABS_SERVER_LIBJVM_SO@")->_memory->_low;
+ CodeCache_high = @cast(CodeCache_heap, "CodeHeap",
+ "@ABS_SERVER_LIBJVM_SO@")->_memory->_high;
+
+ CodeHeap_log2_segment_size = @cast(CodeCache_heap,
+ "CodeHeap",
+ "@ABS_SERVER_LIBJVM_SO@")->_log2_segment_size;
+ CodeCache_segmap_low = @cast(CodeCache_heap,
+ "CodeHeap",
+ "@ABS_SERVER_LIBJVM_SO@")->_segmap->_low;
+
+ // Might want to sanity check above values.
+
+ // Loop through all the frames. The program counter is the starting
+ // point to find the CodeBlob corresponding to the current frame. In
+ // most cases the frame pointer will help us detect the class/method
+ // and next pc value. But we need the stack pointer to help us out
+ // to "recover" the previous fp in case we hit a code blob that didn't
+ // preserve it.
+ frames = "";
+ sp = register(sp_register);
+ fp = register(fp_register);
+ pc = register(pc_register);
+ depth = 0;
+ while (pc != 0 && depth < max_depth)
+ {
+ frame = "";
+
+ // Assume things are fine unless indicated otherwise.
+ trust_fp = 1;
+
+ // Generated code? (Interpreter and stub methods are also generated)
+ if (CodeCache_low <= pc && pc < CodeCache_high)
+ {
+ // Find the start of the code segment and code block that
+ // this pc is in.
+ segments = 0;
+ segment = (pc - CodeCache_low) >> CodeHeap_log2_segment_size;
+ tag = user_char(CodeCache_segmap_low + segment) & 0xFF;
+ while (tag > 0 && segments < 16)
+ {
+ segment = segment - tag;
+ tag = user_char(CodeCache_segmap_low + segment) & 0xFF;
+ segments++;
+ }
+ block = CodeCache_low + (segment << CodeHeap_log2_segment_size);
+
+ // Do some sanity checking.
+ used = @cast(block, "HeapBlock",
+ "@ABS_SERVER_LIBJVM_SO@")->_header->_used;
+ if (used != 1)
+ {
+ // Something very odd has happened.
+ frame = sprintf("0x%x <?unused-code-block?>", pc);
+ blob_name = "unused";
+ trust_fp = 0;
+ frame_size = 0;
+ }
+ else
+ {
+ // We don't like spaces in frames (makes it hard to return
+ // a space separated frame list). So make sure they are
+ // replaced by underscores when used in frames.
+ blob = block + HeapBlock_Header_size;
+ blob_name_ptr = @cast(blob, "CodeBlob",
+ "@ABS_SERVER_LIBJVM_SO@")->_name;
+ blob_name = ((blob_name_ptr == 0) ? "<unknown-code-blob>"
+ : user_string(blob_name_ptr));
+ }
+
+ // For compiled code the methodOop is part of the code blob.
+ // For the interpreter (and other code blobs) it is on the
+ // stack relative to the frame pointer.
+ if (blob_name == "nmethod")
+ methodOopPtr = @cast(blob, "nmethod",
+ "@ABS_SERVER_LIBJVM_SO@")->_method
+ else
+ methodOopPtr = user_long(fp + (-3 * ptr_size)) & ptr_mask
+
+ // Start optimistic. A methodOop is only valid if it was
+ // heap allocated. And if the "type class" oop equals the
+ // Universe::methodKlassObj.
+ if (heap_start > methodOopPtr || methodOopPtr >= heap_end)
+ isMethodOop = 0
+ else
+ {
+ methodOopKlass = @cast(methodOopPtr, "methodOopDesc",
+ "@ABS_SERVER_LIBJVM_SO@")->_metadata->_klass;
+ isMethodOop = (methodOopKlass == Universe_methodKlassObj);
+ }
+
+ if (isMethodOop)
+ {
+ // The java class is the holder of the constants (strings)
+ // that describe the method and signature. This constant pool
+ // contains symbolic information that describe the properties
+ // of the class. The indexes for methods and signaturates in
+ // the constant pool are symbolOopDescs that contain utf8
+ // strings (plus lenghts). (We could also sanity check that
+ // the tag value is correct [CONSTANT_String = 8]).
+ // Note that the class name uses '/' instead of '.' as
+ // package name separator and that the method signature is
+ // encoded as a method descriptor string. Both of which we
+ // don't demangle here.
+ constantPoolOopDesc = @cast(methodOopPtr, "methodOopDesc",
+ "@ABS_SERVER_LIBJVM_SO@")->_constants;
+ constantPoolOop_base = constantPoolOopDesc + constantPoolOopDesc_size;
+
+ klassPtr = @cast(constantPoolOopDesc, "constantPoolOopDesc",
+ "@ABS_SERVER_LIBJVM_SO@")->_pool_holder;
+ klassSymbol = @cast(klassPtr + oopDesc_size, "Klass",
+ "@ABS_SERVER_LIBJVM_SO@")->_name;
+ klassName = &@cast(klassSymbol, "symbolOopDesc",
+ "@ABS_SERVER_LIBJVM_SO@")->_body[0];
+ klassLength = @cast(klassSymbol, "symbolOopDesc",
+ "@ABS_SERVER_LIBJVM_SO@")->_length;
+
+ methodIndex = @cast(methodOopPtr, "methodOopDesc",
+ "@ABS_SERVER_LIBJVM_SO@")->_constMethod->_name_index;
+ methodOopDesc = user_long(constantPoolOop_base + (methodIndex * ptr_size));
+ methodName = &@cast(methodOopDesc, "symbolOopDesc",
+ "@ABS_SERVER_LIBJVM_SO@")->_body[0];
+ methodLength = @cast(methodOopDesc, "symbolOopDesc",
+ "@ABS_SERVER_LIBJVM_SO@")->_length;
+
+ if (log_sig)
+ {
+ sigIndex = @cast(methodOopPtr, "methodOopDesc",
+ "@ABS_SERVER_LIBJVM_SO@")->_constMethod->_signature_index;
+ sigOopDesc = user_long(constantPoolOop_base
+ + (sigIndex * ptr_size));
+ sigName = &@cast(sigOopDesc, "symbolOopDesc",
+ "@ABS_SERVER_LIBJVM_SO@")->_body[0];
+ sigLength = @cast(sigOopDesc, "symbolOopDesc",
+ "@ABS_SERVER_LIBJVM_SO@")->_length;
+ sig = user_string_n(sigName, sigLength);
+ }
+ else
+ sig = "";
+
+ code_name = (log_native
+ ? sprintf("<%s at 0x%x>",
+ str_replace(blob_name, " ", "_"), pc)
+ : "");
+
+ frame = sprintf("%s.%s%s%s",
+ user_string_n(klassName, klassLength),
+ user_string_n(methodName, methodLength),
+ sig, code_name);
+ }
+ else
+ {
+ // This is probably just an internal function, not a java
+ // method, just print the blob_name and continue.
+ // fp is probably still trusted.
+ if (log_native)
+ frame = sprintf("<%s at 0x%x>",
+ str_replace(blob_name, " ", "_"), pc);
+ }
+
+ // We cannot trust the frame pointer of compiled methods.
+ // The server (c2) jit compiler uses the fp register.
+ // We do know the method frame size on the stack. But
+ // this seems to be useful only as a hint of the minimum
+ // stack being used.
+ if (blob_name == "nmethod")
+ {
+ trust_fp = 0;
+ frame_size = @cast(blob, "CodeBlob",
+ "@ABS_SERVER_LIBJVM_SO@")->_frame_size;
+ }
+ }
+ else
+ {
+ // "Normal" hotspot code. Just print what usymname() gets us.
+ // All such code is compiled with -fno-omit-frame-pointer so
+ // we can use that to get at the next frame.
+ // Theoretically there could be libraries or jni code not
+ // compiled with -fno-omit-frame-pointer, then we should really
+ // use the dwarf unwinder or some stack crawling heuristics.
+ if (log_native)
+ frame = usymname(pc);
+ }
+
+ // Get next frame by assuming frame pointers are being used.
+ // (which is not always true for c2 (server) compiled nmethods).
+ old_fp = fp;
+ old_sp = sp
+
+ sp = fp;
+ fp = user_long(sp);
+ pc = user_long(fp + ptr_size);
+
+ // Do we need to double check? We do not want to do this
+ // unless necessary. We have to assume most code is "sane"
+ // and has fp setup correctly because we do not have good
+ // heuristics that cover all cases (native code, interpreted
+ // code, client code, codeblob stubs). So we only check and try
+ // to adapt for nmethods. Scanning the stack for plausible
More information about the distro-pkg-dev
mailing list