All Classes and Interfaces
Class
Description
Factories that build image level components like:
com.ibm.dtfj.image.Image
com.ibm.dtfj.image.ImageAddressSpace
com.ibm.dtfj.image.ImageProcess
share similar structure in the sense that each contains a collection of children factories.
com.ibm.dtfj.image.Image
com.ibm.dtfj.image.ImageAddressSpace
com.ibm.dtfj.image.ImageProcess
share similar structure in the sense that each contains a collection of children factories.
This is the superclass of a variety of subclasses which provide hash map functionality
using integer keys rather than objects.
This is the superclass of a variety of subclasses which provide hash map functionality
using integer keys rather than objects.
This class is the superclass of the LRU cache classes.
This class is the superclass of the LRU cache classes.
Abstract class containing the logic for mapping a memory space
onto a set of IMemorySource objects through a caching layer.
Active section of a file header.
Active section of a file header.
A CorruptDataException with an address.
Contains static helpers for working with addresses as long.
This class represents an address range.
This class represents an address range.
This class represents an address space in an svcdump.
This class represents an address space in an svcdump.
This class implements ImageInputStream for an AddressSpace.
This class implements ImageInputStream for an AddressSpace.
Class containing the boilerplate code for picking an appropriate algorithm.
The annotations that are found on a class.
Encapsulates the details of a DLPAR notification emitted by a
OperatingSystemMXBean when the number
of available processors changes.Support for the
AvailableProcessorsNotificationInfo class.AVL tree wrapper
Abstract IOSThread for AIX.
Contains logic for doing a simple one-version match for an algorithm
Base command which supplies basic support.
Default field formatter with empty implementations for preFormat, format and postFormat
This the base command for all jdmpview commands.
Enum for identifying the type of artifact that is currently being analyzed.
Abstract base class containing common logic for IMemoryRange
Base implementation of IStackWalkerCallbacks that does performs no-ops
for each callback.
Base class for structure formatting commands
Default IStructureFormatter implementation with safe default behaviour
Abstract class containing stack-walking logic for Windows OS threads.
Simple java.util.logging formatter than minimises the amount of java.util.logging meta-data
that is printed.
Bytecode name->value mappings from oti/bcnames.h
This class provides a compact representation of an array of sparse bit sets.
This class provides a mechanism for writing and reading numbers in a bit stream.
This class provides a mechanism for writing numbers in a bit stream.
This class provides a mechanism for writing and reading numbers in a bit stream.
This class will start cache lines once any match is found.
This class first caches all the lines.
Object representing a single live
process model where a section of
memory in a the process can be represented
in a byte buffer as its source
Serves as a ByteBuffer backed memory source.
Improved performance NumberStream for small number of references
Keeps the refs in a LongArray - only outputs to the compressed bitstream if it overflows
Contains a collection of factories.
Thrown when a factory object cannot be created.
Runs DDR extension !
Conversion routines to marshall Java binary types (short, int, long, float,
double) to byte arrays.
Conversion routines to unmarshall Java binary types (short, int, long, float,
double) from byte arrays.
Generates the class bytecodes needed by DDR to represent, as Java classes,
the structures and pointers described by the blob.
Constants from oti/bytecodewalk.h
This class represents the LE view of an MVS
Tcb.This class represents the LE view of an MVS
Tcb.This exception is thrown when an attempt is made to create a Caa for a Tcb that doesn't
have one.
Exception thrown if an attempt is made to modify confirmed elements of a
classpath in SharedClassURLClasspathHelper.
This class emulates the Ceexdsaf macro (Ph variant).
This class provides some handy character conversion methods
This class provides some handy character conversion methods
This class generates the same structure and pointer classes that
would be created at runtime from a DDR blob.
A formatter for classic heap dumps.
Information about the structural aspects of a class such as the annotations found and interfaces
supported.
A subset of the ASM ClassVisitor and AnnotationVisitor methods on a
single interface to allow specific visitor actions to be carried out.
Object representing a PHD ClassRecord
This class provides a low level interface to some of the z/OS C library.
A wrapper around the functionality that we require from RandomAccessFiles but with the added auto-closing
functionality that we require.
A wrapper around the functionality that we require from RandomAccessFiles but
with the added auto-closing functionality that we require.
Wrapper class that takes an existing DTFJ context and augments
it with a DDR interactive context if one exists.
Description for how a command should be executed
Base exception when running commands
This is the default exception used by the tools to indicate
unexpected situation.
Handles command line entries and does extra interpretation, such as handling quoted strings (whilst discarding
quotes themselves and handling escaped characters), recognising redirection to file etc.
Handles command line entries and does extra interpretation, such as handling quoted strings (whilst discarding
quotes themselves and handling escaped characters), recognising redirection to file etc.
Abstract class for handling compressed files
This class represents an array of records which are stored in a compressed format whilst
still allowing random access to them.
This class represents an array of records which are stored in a compressed format whilst
still allowing random access to them.
Handles converting !
A ConditionException is used to represent a z/OS Language Environment condition.
This exception is thrown when the dump configuration cannot be
updated through the methods in OpenJ9DiagnosticMXBean because it is
in use.
Represents a class file container in the file system, this
could be a directory or a jar file.
Represents a process and its VMData.
A context represents the environment within which a command is executing.
Factory for creating different types of contexts.
DDR command to walk the stack frames of a continuation.
Runs DDR extension !
Factory for ICoreReader implementations.
Used by the core readers when they recognize a core file as a certain type but know that it is damaged and unusable
Used by the core readers when they recognize a core file as a certain type
but know that it is damaged and unusable
This class is used to indicate that corruption has been detected in the image.
Used to indicate that corruption has been detected in the image.
Base type for all corrupt data exceptions
Class to represent a corrupt pointer and can be used to populate a corrupt data exception.
Exception to indicate that the DDR blob is corrupt and cannot be read.
Constants used by
OperatingSystemMXBean.getProcessCpuLoad() and
OperatingSystemMXBean.getSystemCpuLoad() methods.A management interface of the CRaC functionality in the Java virtual machine.
An implementation of the CRaCMXBean interface.
The permission class for operations on the org.eclipse.openj9.criu.CRIUSupport class.
CRIU Support API
A checkpoint is the act of halting the JVM, saving its state and writing it out to a file(s).
A hook can be one of the following states:
SINGLE_THREAD_MODE - a mode in which only the Java thread that requested a
checkpoint is permitted to run.
Field formatter that adds the value of any char * string fields.
Utility class - used for parsing C type declarations.
The
Cuda class provides general CUDA utilities.The
CudaBuffer class represents a region of memory on a specific
device.The
CudaDevice class represents a CUDA-capable device.Representation of a real, connected CUDA device.
CacheConfig identifies the cache configuration choices for
a device.Limit identifies device limits that may be queried or configured.The
CudaError interface defines the possible values of CudaException.code.The
CudaEvent class represents an event that can be queued in a
stream on a CUDA-capable device.The
CudaException class represents an unusual or unexpected response
from a CUDA-capable device.The
CudaFunction class represents a kernel entry point found in
a specific CudaModule loaded on a CUDA-capable device.The
CudaGlobal class represents a global variable found in
a specific CudaModule loaded on a CUDA-capable device.Provides CUDA-based GPU sort assist depending on the values
of the following system properties:
com.ibm.gpu.enforce
com.ibm.gpu.enable
com.ibm.gpu.disable
See CUDAManager for more details.
The
CudaGrid class represents a kernel launch configuration.CudaJitInputType identifies the type of input being provided to
CudaLinker#add(...).The
CudaJitOptions class represents a set of options that influence
the behavior of linking and loading modules.CacheMode identifies the cache management choices.Fallback identifies the available fall-back strategies
when an exactly matching object is not available.CudaJitTarget identifies the target compute device class
for linking and loading modules.The
Parameters class represents the actual parameters in
a kernel launch.The
CudaLinker class supports combining one or more code fragments
to form a module that can be then loaded on a CUDA-capable device.This class contains information important to IBM GPU enabled functions.
The
CudaModule class represents a module that has been loaded
on a CUDA-capable device.The
Cache class provides a simple mechanism to avoid reloading
modules repeatedly.This class defines CUDA permissions as described in the following table.
The
CudaStream class represents an independent queue of work for a
specific CudaDevice.The
CudaSurface class represents a surface object found in
a specific CudaModule loaded on a CUDA-capable device.The
CudaTexture class represents a texture object found in
a specific CudaModule loaded on a CUDA-capable device.This exception is used to indicate that data was requested which
is not available on this system, or in this image.
Exception thrown when data isn't available for some reason.
DDR Interactive classloader which is responsible for finding all classes specified by the plugins property.
The Debuggable annotation applies to either classes or methods and provides
a hint to the VM that decorated entities must remain debuggable.
LocalMap used for stacks generated in debug mode
Routines to convert between decimal data types stored in byte arrays and Java binary types.
The
Dim3 class represents the dimensions of a cube.This class represents a DLL (Dynamically Linked Library).
This class represents a DLL (Dynamically Linked Library).
This class represents a DLL exported function.
This class represents a DLL exported function.
This class represents a DLL exported variable.
This class represents a DLL exported variable.
This class represents a single LE stack frame (aka DSA).
This class represents a single LE stack frame (aka DSA).
Shim used to create the DTFJJavaRuntime in the J9DDR classloader
Simulates loading different components from an external file.
Represents the current context under which DTFJ is being used.
A DTFJ context within which a DTFJ command executes
J9DDR CorruptDataException that can take a cause for improved debugging.
This class is the superclass of all exceptions thrown by DTFJ classes
JavaRuntimeMemorySection used for everything but J9MemTag sections.
Simple Java bean which contains the data from the Image interface.
A helper class containing static methods that are used by implementations of DTFJJavaClass
A helper class containing static methods that are used by implementations of DTFJJavaFieldI
JavaReference is intended to represent either a standard reference within a java heap,
for example a reference from one object to another, or a root.
Combined JavaStackFrame invalid input: '&' JavaLocation
Adapter for J9VMThreadPointer
A JavaRuntimeMemorySection based on a J9MemTag malloced data chunk.
DTFJ specific version of the plugin config
Decorator class for the plugin manager which adds DTFJ specific capabilities.
This class represents an svcdump.
This class represents an svcdump.
This class is used to trigger and configure the options used to produce different
types of diagnostic dumps available from the OpenJ9 JVM.
DumpModuleExports command dumps all modules that the package is exported to
Example:
!
This exception is thrown when the dump configuration cannot be
updated through the methods on com.ibm.jvm.Dump because it is
in use.
This class is the superclass of all exceptions thrown by Dump classes
This class is the superclass of all exceptions thrown by Dump classes
Memory range backed by an AbstractCoreReader
DumpModuleDirectedExports command dumps all modules that the package is exported to
Example:
!
Dumpmoduleexports command displays all display all j9packages exported by the target module
Example:
!
DumpModuleReads command displays all modules that the target module reads
Example:
!
The permission class for operations on the com.ibm.jvm.Dump class.
This class represents an LE Enclave Data Block.
This class represents an LE Enclave Data Block.
ELFDumpReader for AArch64 dumps.
ELFDumpReader for ARM32 dumps.
ELFDumpReader for IA32 dumps.
Memory source that gets its data from an ELFFile.
It is possible that if a core file is sufficiently corrupt, or that an invalid type of
file is passed to jdmpview, then at least one context needs to be created so that the
user can exit the tool
This interface represents a zSeries emulator.
This class represents one of the branch relative family of instructions.
This interface is implemented by users who want to receive branch trace events.
Call back interface used by Emulator to call user registered function.
This interface represents a mutable address space.
The base class of all instructions.
This interface is implemented by users who want to receive trace events.
Describes an entry in a file system.
Provides parser for environment (CI) section in the javacore
Parser rules for lines in the environment (CI) section in the javacore
Class which attempts to handle exceptions thrown by the DTFJ API in a consistent manner.
Exit codes which can be returned by jdmpview.
Runtime type for
GarbageCollectorMXBean.Runtime type for
HotSpotDiagnosticMXBean.Runtime type for
MemoryMXBean.Runtime type for
OperatingSystemMXBean.Runtime type for
RuntimeMXBean.Class encapsulates a ThreadInfo instance along with the corresponding native thread identification
information as assigned by the operating system.
Implementation of the extended ThreadMXBean.
Class to hold a FDE (Frame Description Entry).
This class represents an exception thrown when opening a dump with an unrecognized format.
Class which manages the files on the local system.
Sniffs files attempting to determine the contents, typically from known
magic numbers/values.
FindAllModules command displays all the modules loaded by the runtime
Example:
!
FindAllReads command displays all modules that read the target module
Example:
!
searches memory for a given ASCII string, U8, U16, U64, UDATA or pointer occurrence.
FindModuleByName command find the modules corresponding to its module name
Example:
!
IBootstrapRunnable that copies the VM pointer into a long array
Encapsulates knowledge of which structures should be handled as flags.
FlatObjectCommand
Displays all the fields of a j9object.
Enumeration of results of structure formatting walks.
Java realisation of J9_STACKWALK_KEEP_ITERATING and
J9_STACKWALK_STOP_ITERATING
This class represents an LE managed function.
This class represents an LE managed function.
This class acts as a more convenient way of using the
Emulator class.This interface is similar to Emulator.CallbackFunction except that it adds the ability
to set the return value from the function (which is XPLINK specific).
This exception can be thrown by callback functions which want to call the overridden
function.
Information about a garbage collection.
Support for the
GarbageCollectionNotificationInfo class.The OpenJ9 extension interface for managing and monitoring the virtual machine's
garbage collection functionality.
Iterator over the classes in the class segments of a class loader,
Garbage collection information.
Support for the
GcInfo class.Utility functions for debugging generated classes
Annotation used to tag methods in generated pointer types
that access fields.
Annotation for generated pointer classes.
This class represents a single "generic" thread within the dump and is basically a
data holding class (together with a toString() that allows a nice view of the
class
Basic debug extension to print out gpInfo for dumps triggered by a gpf.
This exception is thrown when GPU operations fail due to configuration
or environment issues - for example, an invalid device has been specified
or we are running on an unsupported platform.
This class defines GPU permissions as described in the following table.
This exception is thrown when there is an attempt to perform a sort on GPU and the sort operation fails.
Runtime type for
GuestOSMXBean.This exception class is thrown when retrieving
Guest (Virtual Machine(VM)/Logical Partition(LPAR)) usage statistics fails.
This provides a snapshot of the Guest (Virtual Machine(VM)/Logical Partition(LPAR))
Memory usage statistics as seen by the Hypervisor Host.
Support for the
GuestOSMemoryUsage class.This interface provides Processor and Memory usage statistics of the
Guest (Virtual Machine(VM)/Logical Partition(LPAR)) as seen by the Hypervisor Host.
This provides a snapshot of the Guest (Virtual Machine(VM)/Logical Partition(LPAR))
Processor usage statistics as seen by the Hypervisor Host.
Support for the
GuestOSProcessorUsage class.File manger for gzip'd files.
Encapsulation of the equal function needed by the HashTable
Encapsulation of the hash function needed by the HashTable
Command for dumping heapdumps from DTFJ.
Abstract class to decouple the formatting of heapdumps from the walking of
the internal data structures that hold the source data.
This class parses a PHD format heapdump file.
Encapsulates the marshalling and unmarshalling of heapdump
settings through the properties map.
Prints out either a help summary for all commands in this context or forwards
the request onto a particular command for a detailed output.
Exception thrown if a factory is asked to get multiple helpers for a ClassLoader.
Utility class for converting a value to a human-readable form.
This exception class is thrown when retrieving Hypervisor information fails.
This interface provides information on whether the current Operating System is running directly on physical hardware
or running as a Guest (Virtual Machine (VM)/Logical Partition (LPAR)) on top of a Hypervisor.
Runtime type for
HypervisorMXBean.A region of addressable memory that has an ID and a list of processes.
Interface that can be used by versioned algorithms to make
matching algorithms to versions easier.
Contains a map of values parsed from a tag line.
For use with AVLTree
Factory which provides blobs
Common data values used throughout the javacore parsing and DTFJ javacore building process.
A combined context is an extended DTFJ context which also contains a DDR context.
Interface for DDR Interactive commands.
A context is the process and address space within which a plugin
is operating.
Interface representing core dump.
Interface for entities that can parse core dumps.
A memory range that can hold all the OS properties for a range of a process.
Return the Java signature for this DTFJJavaField.
Interface for objects that format fields in structures.
Factory for building an com.ibm.dtfj.image.ImageAddressSpace.
Image building factory for com.ibm.dtfj.image.Image
Support for multiple address spaces: If a javacore contains multiple address spaces, each with its own set of processes and runtimes, it is assumed that some sort of unique ID in the javacore (could be start address of address space) is used to distinguish each address space, and that the proper addressSpaceBuilder can be selected throughout the parsing process by parsing a tag in the javacore that contains this id.
Support for multiple address spaces: If a javacore contains multiple address spaces, each with its own set of processes and runtimes, it is assumed that some sort of unique ID in the javacore (could be start address of address space) is used to distinguish each address space, and that the proper addressSpaceBuilder can be selected throughout the parsing process by parsing a tag in the javacore that contains this id.
Generates a Image builder factory with a unique id.
Factory for building a com.ibm.dtfj.image.ImageProcess
Each Image Process factory must have at least one Java runtime factory that builds
Basic support for multiple java runtime factories is present.
Each Image Process factory must have at least one Java runtime factory that builds
JavaRuntime
Basic support for multiple java runtime factories is present.
Factory for building a com.ibm.dtfj.java.JavaRuntime object.
A core file that is dependent on shared libraries
to complete its address space.
Object for resolving libraries
Parses a string source pertaining to a tag line from a javacore, and returns
a map of tokens, where the token type (java.lang.String) is the key and token value (java.lang.String)is the value.
Prediction buffer that holds a certain number of tokens.
Represents an entire operating system image (for example, a core file).
Represents a single address space within the image.
This interface is used for classes which can produce instances of Image
implementers.
Represents a shared library loaded into the image, or the executable module itself.
Represents an address in memory.
Represents a native operating system process.
Represents the state of a CPU or FPU register
Represents a contiguous range of memory in an address space.
Enum which represents the type of source that an image has been derived from
i.e. core file, javacore or PHD.
Represents a native stack frame.
Represents a symbol defined in an ImageModule.
Represents a native operating system thread.
Common interface representing an area of addressable memory.
InputStream that takes its data from an IMemory instance.
An optionally named range of memory with permissions.
A memory range that holds its data.
A module (shared library or executable) loaded in an address space
A binary file (shared library / executable) on disk.
A named IMemoryRange
Useful utility class that just implements an array of integers that can be sorted.
This class provides an LRU (Least Recently Used) cache which maps integer keys to int values.
This is a simple class to map one integer to another but without the overhead of using
a Hashtable.
This is a simple class to map one integer to another but without the overhead of using
a Hashtable.
This is a lightweight class to hold a set of integer values.
This class implements a simple stack of integers.
This interface is just like that of java.util.Enumeration except that it adds the ability
to enumerate integer values rather than incur the overhead of allocating Integer objects.
This interface is just like that of java.util.Enumeration except that it adds the ability
to enumerate integer values rather than incur the overhead of allocating Integer objects.
Exception thrown by com.ibm.dtfj.j9ddr.structures.types classes when operation does not
make sense for the types value
This exception is thrown when an invalid option is passed
to methods on the com.ibm.jvm.Dump class.
This exception is thrown when an invalid option is passed
to methods on the openj9.lang.management.OpenJ9DiagnosticsMXBean class.
This exception is thrown when the beginning of a buffer (including spanned
record if any) is not the start of a record.
Frame on IOSThread native stack
An operating system (native) thread.
An output channel provides a mechanism by which text will be displayed
to the user.
The output manager is responsible for managing a collection of registered
output channels.
Atomic unit for the parsing procedure.
This to for a Tool to indicate it is to be used after a pipe line.
This is the interface to be used by post-match handlers.
This is an interface to be used by pre-match handlers.
Models an OS process.
CPU register
Lowest level of the javacore parser.
Parses a section of a javacore.
Represents a single jdmpview session which may contain multiple contexts.
Controls the creation and deletion of contexts within a session.
Interface for stack-walker callback routines.
Interface for objects that format entire structures
e.g. turning
!
Represents a native symbol.
This helper interface can be implemented to run a section of logic to parse or
process the attributes pertaining to a particular javacore tag.
Utility functions for working with iterators
Interface for filtering iterators
Field formatter that adds // to struct J9Class * fields
Structure Formatter that adds a suffix like this:
Class name: com/ibm/oti/vm/BootstrapClassLoader
To view static fields, use !
Formats fields which are J9ConstantPool pointers,
which require special handling of the low-order bits.
This ClassLoader serves two purposes.
1) Based on partitioning rules and package namespaces it ensures that
certain classes are loaded once per runtime invocation while others
are loaded once per CORE file being inspected.
2) Generate bytecode at runtime based on the data in the core file (or
structure metadata file) for the J9 structure constants and offsets;
as well as pointer classes.
CorruptData implementation that can bridge the gap between
DDR CorruptDataExceptions and DTFJ CorruptData interface
Image implementation that wraps a J9DDR ICore
Adapter for DDR IProcesses to make them implement the ImageProcess
API
Adapter for IRegister to make it implement ImageRegister
Adapter for IOSThread objects to make them implement ImageThread
ImageThread used for when we can't find a matching thread in the image.
Iterator encapsulating the knowledge of how to search for J9-malloc'd sections in
memory.
Adds // class.method (signature) to all !
Structure formatter that adds the signature and j9rommethod pointer as a suffix
after a !
Structure Formatter that adds a suffix to the command "!
Field formatter that appends the class of !
Representation of the offset for instance fields or address for static fields in a J9Object
Class that calculates offsets into an Object of fields.
A helper class for functionality related to J9ObjectMonitorPointers
NOTE: J9ObjectMonitorHelper is only relevant to inflated monitors, whereas ObjectMonitor handles both inflated and uninflated monitors
Custom structure formatter for J9Object and J9Indexable object
Structure Formatter that adds a suffix like this:
Package name: jdk/internal/perf
To dump all modules that a package is exported to, use !
Represents the basic J9RAS structure found in all Java versions
U_8 eyecatcher[8];
U_32 bitpattern1;
U_32 bitpattern2;
I_32 version;
I_32 length;
A J9RAS fragment contains the VM version specific offsets which are
required to successfully parse a J9RAS structure.
Represents the J9RAS structure prior to SR10.
Represents the J9RAS structure from Java 5 SR10 when TID and PID fields were added to the RAS structure
Java 5 32 bit : length = 0x120, version = 0x10000 TID + PID, No J9DDR
Java 5 64 bit : length = 0x158, version = 0x10000 TID + PID, No J9DDR
Represents the J9RAS structure starting from Java 5 SR12 which contains the DDR blob pointer
Java 5 32 bit : length = 0x128, version = 0x20000 TID+PID+DDR
Java 5 64 bit : length = 0x160, version = 0x20000 TID+PID+DDR
Represents the J9RAS structure prior to SR5.
Represents the J9RAS structure from Java 6 SR06 when TID and PID fields were added to the RAS structure
Java 6 32 bit : length = 0x240, version = 0x10000 PID+TID, No DDR
Java 6 64 bit : length = 0x278, version = 0x10000 PID+TID, No DDR
Represents the J9RAS structure starting from Java 6 SR09 which contains the DDR blob pointer
Java 6 32 bit : length = 0x248, version = 0x20000 TID+PID+DDR
Java 6 64 bit : length = 0x280, version = 0x20000 TID+PID+DDR
Represents the J9RAS structure starting from Java 7 GA and Java6 SR10, which contains the longer hostname string
Java 6 32 bit : length = 0x328, version = 0x30000 TID+PID+DDR + long hostname
Java 6 64 bit : length = 0x360, version = 0x30000 TID+PID+DDR + long hostname
Point of contact for Image code needing to extract
data from the J9RAS structure
Bootstrap shim for extracting information from the J9RAS structure.
Static helper for ROM methods
Represents a Java class.
Represents an internal ClassLoader structure within a Java VM instance.
Represents a Java field declaration.
Represents a heap of managed objects.
Represents a point of execution within a Java method.
Base interface inherited by JavaField and JavaMethod.
Represents a method or constructor in a class.
Represents a Java monitor (either an object monitor or a raw monitor).
Represents a Java Object.
Represents a Java reference.
Represents a Java runtime.
Represents a category of native memory allocated by the Java runtime.
Represents a native memory range allocated by the Java Runtime.
Represents a frame on a Java thread stack.
Represents a Java thread.
JavaVersionHelper helps check if the JVM version is new enough for the modularity DDR commands
Represents the JavaVMInitArgs C structure passed to JNI_CreateJavaVM
to create the Java runtime.
Represents the JavaVMOption C structures passed to JNI_CreateJavaVM
to create the VM.
A javacore-based implementation of
JavaRuntime.
A javacore-based implementation of DTFJ JavaVMInitArgs.
A javacore-based implementation of DTFJ JavaVMOption.
Class for managing jdmpview contexts as it is possible to add and remove contexts
without exiting the application.
Indicates that jdmpview failed to initialize
Jdmpview specific print stream which allows access to the underlying
Output class which controls an arbitrary number of write destinations
Mirror of util/jitlook.c
JIT register map.
Stack walker for processing JIT frames.
An exception representing a failure in the JVM before checkpoint.
Runtime type for
JvmCpuMonitorMXBean.JvmCpuMonitorInfo provides a snapshot of JVM CPU usage information
that is distributed across thread categories.Support for the
JvmCpuMonitorInfo class.
This interface provides APIs to obtain JVM CPU usage information in terms of thread categories.
Abstract CRIU exception superclass.
Exception to indicate that although the JVM was found, the RAS structure indicates that there is no
DDR field and the build could not be matched either through the blob archive or via the system property
Exception to indicate that the JVM was not found in a specified process.
An exception representing a JVM failure after restore.
Specifies the type of collection to use.
Used to indicated the overall outcome when invoking the library collection process
Static factory for ILibraryResolvers.
Private class used to store the regions.
Input buffer for javacore scanner.
This is the basic line parser for a javacore tag.
Provides subset of function in stackmap/localmap.c
Classloader to search for classes locally first before delegating to the parent classloader.
The
Log class contains methods for controlling system log options
This class cannot be instantiated.Command to display all the currently installed Java util loggers.
The permission class for operations on the com.ibm.jvm.Log class.
Similar to IntegerArray but for longs.
Similar to IntegerArray but for longs.
This interface provides an enumeration of long values.
Reference iterator based on a list of Longs.
Debug extension to resolve symbols from addresses.
This class represents Linkage Stack Entry (LSE).
This class represents Linkage Stack Entry (LSE).
This dump reader supports Mach-O core files generated on 64-bit macOS systems.
Wrapper class to allow management functionality to be added to DTFJ Images
returned to the client.
Represents a managed core file.
Represents a generic managed runtime instance.
This class checks if a line contains some strings.
This class is used to perform sorting operations of
primitive arrays of type int, long, float, double
on any connected CUDA GPU.
This class caches up to a specified number of lines before a matching is found.
This class first caches up to a specified number of lines before the matching is found.
Memory adapter which removes the need for a component to know the address space ID that it is working with.
Indicates that an attempt was made to access memory which is not included
within the image
Indicates that an attempt was made to access memory which is not included within the image.
Walker for J9MemCategories
Exception class representing a memory fault (GPF)
The OpenJ9 extension interface for monitoring the virtual machine's memory
management system.
The OpenJ9 interface for managing and monitoring the virtual machine's memory pools.
Implementation of the extended MemoryPoolMXBean.
Dumps contain lots of memory - segmented across a range of virtual
addresses.......
Simple memory range class.
Class encapsulating the logic for taking a list of memory
sources and efficiently finding ranges for addresses
This represents a snapshot of the Operating System level Memory usage statistics.
Exception class whose instance is thrown when Memory usage sampling fails.
Support for the
MemoryUsage class.Merges the trace entries
Acts as a template for mapping trace ids to messages.
Acts as a template for mapping trace ids to messages.
Java-equivalent of MethodMetaData.c.
Class used to pass maps by reference to jitGetMapsFromPC.
Exception to indicate that the RAS structure was found but the address of the DDR blob was 0
IModule placeholder for modules we don't have the file for
(and therefore can't get the symbols from).
ModuleHashTable is used for accessing hash tables in J9Modules (e.g. readAccessHashTable)
The monitor iterator walks over the monitor table to get the system and inflated object monitors.
Various monitor related commands
See
MonitorsCommand.helpCommand(String[], PrintStream) for command documentationRepresents the list of monitors anchored on J9JavaVM->monitorTableList
Iterates over all the J9ObjectMonitor entries in all of the monitor tables in the monitor table list
Thrown when there is more than one core file present in a zip
file and the calling application has not specified which entry
should be used.
Provides the ability to write as well as read to a copy of the address space.
Debug extension to extract native libraries appended to the end of
a core file by diagnostics collector.
Debug extension to print the native stacks for all or selected threads.
NativeThreadContext based on ThreadContext class from Sovereign
basically used to help try and generalize stack traversal
struct and constant reference: /usr/include/elf.h
Example:
<gpf failingThread="0x806a600" nativeFailingThread="0xb7e286c0">
J9Generic_Signal_Number=00000004 Signal_Number=0000000b Error_Value=00000000 Signal_Code=00000001
Handler1=B7DADB8F Handler2=B7D7B0C6 InaccessibleAddress=FFFFFFFB
EDI=083639B0 ESI=09010101 EAX=96C5879E EBX=082EACDC
ECX=00000000 EDX=00000000
EIP=96C587A1 ES=C010007B DS=C010007B ESP=BFAB3634
EFlags=00210246 CS=00000073 SS=0000007B EBP=BFAB3634
Module=/tmp/rtj_jextract/jre/bin/libgptest.so
Module_base_address=96C58000 Symbol=Java_VMBench_GPTests_GPTest_gpWrite
Symbol_address=96C5879E
</gpf>
Example:
<j9dump endian="little" size="32" version="2.3" stamp="20060714_07189_lHdSMR" uuid="16994021750723430015" format="1.1" arch="x86" cpus="2" memory="1593016320" osname="Linux" osversion="2.6.15-1-686-smp" environ="0x80569c0">
Example:
<javavm id="0x805fd90">
This class provides an empty iterator with no elements.
This class provides a stream of integers in a relatively compact format.
Record representing an object array.
This class provides an LRU (Least Recently Used) cache which maps integer keys to object values.
This class provides an LRU (Least Recently Used) cache which maps integer keys to object values.
This is a simple class to map an integer key to an object value.
This is a simple class to map an integer key to an object value.
Object record.
Input buffer that computes character offset from disk.
Helper routines for OMRMemCategoryPointer.
This interface provides APIs to dynamically trigger dump agents.
Runtime type for
OpenJ9DiagnosticsMXBean.OpenJ9 platform management extension interface for the Operating System on which the Java Virtual Machine is running.
Analogue to util/optinfo.c
Note, this class copied some logic from class com.ibm.java.diagnostics.utils.commands.CommandParser
This class works with the class OutputStream and class IStringModifier.
Classloader to deal with the fact that in order to be able to shim ASM
onto the extensions classpath, some DTFJ classes need to be resolved
by this loader rather than the parent loader (which will be the ext
loader).
PackageHashTable is used for accessing hash tables in J9Packages
Arithmetic, copying and shifting operations for Packed Decimal data.
Simple paging cache, to speedup getMemoryBytes
This class divides the command line into the command with arguments.
A string containing wildcards and other characters that enable it
to represent many strings at once.
A class to represent the PatternString in two separate patterns
Program-counter stack use information.
Java monitor information
The constructors for PHDJavaObject used to take up to 11 arguments, many of which were ints.
Enumeration for platform type
This class implements the service-provider interface to make OpenJ9-specific
MXBeans available.
Command which allows control of the loaded plugins
Simple java bean to hold plugin configuration information
Simple Java bean to represent a plugin
Shared constants between plugin classes
Interface for factories which produce plugin listeners to be notified
when the class scanning takes place.
Used so that the DTFJPluginClassloader will not be referenced directly in code,
but only loaded through reflection, using a dedicated classloader (in DTFJContext)
Used so that the DTFJPluginClassloader will not be referenced directly in code,
but only loaded through reflection, using a dedicated classloader (in DTFJContext)
Singleton manager for working with plugins.
Locator class to hide the ASM classloading shimming that occurs when using
the plugin manager, allowing this to be shared by different plugin architectures
rather than just the DTFJ based ones.
Utility to generate concrete implementation classes based on that
structure data found in a binary file of the same format as the new
core file offset data.
Retrieves the pointer size from a line containing OS and JVM information.
A formatter for Portable heap dumps (PHDs).
This interface is used to parse a heapdump in Phd format.
Base class for all PHD records.
Superclass of IntegerArray and LongArray
Superclass of IntegerArray and LongArray
This class simply prints the contents of the heap dump.
Helper class to print j9object fields.
Object representing the single address space / process model used by Linux,
AIX and Windows.
Encapsulates the details of a DLPAR notification emitted by a
OperatingSystemMXBean when the available
processing capacity changes.Support for the
ProcessingCapacityNotificationInfo class.Processor section of a file header
Processor section of a file header
This represents a snapshot of the Operating System level Processor usage statistics.
Exception class whose instance is thrown when Processor usage sampling fails.
Support for the
ProcessorUsage class.This class is used to provide feedback on progress for long running (eg greater than one
second) tasks.
Abstract memory range that adds the isReadable/Executable/Writable methods
Command to quit out of the interactive command parser
Walk every slot and sections of a RAMClass
The sections are:
-jit vTable
-ramHeader
-vTable
-Extended method block
-RAM methods
-Constant Pool
-Ram static
-Superclasses
-InstanceDescription
-iTable -StaticSplitTable
-SpecialSplitTable
-jit vTable
-ramHeader
-vTable
-Extended method block
-RAM methods
-Constant Pool
-Ram static
-Superclasses
-InstanceDescription
-iTable -StaticSplitTable
-SpecialSplitTable
Type-safe, resettable iterator for references.
This class handles the matching tasks when regular expressions are used.
Represents a register for a thread.
This class represents a set of registers for a failed thread.
This class represents a set of registers for a failed thread.
Walk every slot and sections of a ROMClass
Static helper functions.
The OpenJ9 extension interface for the runtime system of the virtual machine.
Defines the different states of
RuntimeMXBean.getVMIdleState().Runs DDR extension !
Formatter for all numeric scalar types (U* and I*)
Abstract IMemory encapsulating findPattern() logic.
This interface is used when searching a dump or an address space to report back when
a match is found.
This interface is used when searching a dump or an address space to report back when
a match is found.
Parent section parser that implements most of the grammar based functionality used
by the concrete section parsers.
Analogue of util/sendslot.c util/sendslot.asm
Service section of a file header.
Service section of a file header.
Interface which lists all of the property names which are part of the DTFJ context property bag.
Global class that provides SharedClassHelperFactory, SharedDataHelperFactory and sharing status.
SharedAbstractHelper provides common functions and data to helper subclasses.
SharedAbstractHelperFactory is an abstract superclass for helper factory subclasses.
SharedClassAbstractHelper provides common functions and data to class helper subclasses.
SharedClassCacheInfo stores information about a shared class cache and
provides methods to retrieve that information.
This class defines shared cache permissions as described in the following table.
SharedClassFilter allows users of a Helper API to filter which classes are found and stored in the cache.
The SharedClassHelper superinterface defines functions that are common
to all class helpers.
SharedClassHelperFactory provides an interface that is
used to create various types of SharedClassHelper for ClassLoaders.
SharedClassPermission provides security permission to govern ClassLoader access to the shared class cache.
SharedClassPermissionCollection provides permission collection to support SharedClassPermission.
Implementation of SharedClassProvider.
SharedClassStatistics provides static functions that report basic cache statistics.
SharedClassHelper API that stores and finds classes using String tokens.
SharedClassHelper API that stores and finds classes by using URL classpaths.
Interface that allows an index to be returned from findSharedClass calls.
SharedClassHelper API that stores and finds classes by using URL paths.
SharedClassUtilities provides APIs to get information about all shared class
caches in a directory and to destroy a particular shared class cache.
SharedDataHelper API that stores and finds byte data using String tokens.
SharedDataHelperFactory provides an interface used to create SharedDataHelpers.
The SharedHelper superinterface defines functions common to all helpers.
Methods for mapping OS-specific signal numbers to human-readable strings.
Simple file manager for dealing with files that are intended to be read directly.
There are a number of jdmpview commands which just act as routing
commands onto other more specific commands.
This class provides an iterator with a single element.
Debug extension superclass to extract trace buffers from a core dump
so they can be dumped or formatted.
Debug extension to extract trace buffers from a core dump
so they can be formatted.
Packs references more efficiently by sorting them in order, so allowing smaller
deltas to be encoded.
The StackMap determines the shape of the operand stack at a
particular point in the code.
This exception is thrown if a stack cannot be found for a thread.
Provides parser for environment (CI) section in the javacore
Parser rules for lines in the (native) stack section in the javacore
StackWalker
Utility methods shared between stack walkers.
Java realisation of the various J9_STACKWALK_RC_* values
Startup section of a file header.
Startup section of a file header.
This class is used provide the following java heap and system statistics:
committed heap memory
used heap memory
max heap memory
softmx heap memory
free physical memory
total physical memory
All this info is retrieved without any allocation of new objects.
This class is to be used together with pre-match handler, match handler
and post-match handler.
This is a kind of OutputStream which caches the incoming bytes (instead if printing them out)
and releases them as a string whenever it is asked to.
VM-specific half of the structure formatter.
Formatting inline structures - prints a pointer to it
Represents the header for the blob
Identifies the type of blob by its name
Root of the hierarchy for VM C structures.
Utility to generate concrete implementation classes based on the structure
data found in a binary file of the same format as the new core file offset
data.
Helper class for working with structure data
Class to maintain a list of addresses and coverage extents and a
symbolic name - then given an input address will convert this into
a string showing offset from the symbol.
Static utility functions for symbols
An exception representing a failed system operation before checkpoint.
Interface which lists all the system properties which are recognised by jdmpview.
An exception representing a system failure after restore.
This class represents the System Trace mechanism.
Utility class for printing text-based tables.
This class represents an MVS Task Control Block (TCB).
This class represents an MVS Task Control Block (TCB).
zOS dump reader implemented as a thin wrapper around Zebedee.
This class represents a single template as defined in a template xml file.
This class represents one field of a template.
The OpenJ9 extension interface to
ThreadMXBean.Parse the thread section.
Wrapper command to time the execution of another ddr command.
The permission class for allowing "tool" dump agents to be run or
configured via the com.ibm.jvm.Dump class.
This class contains some static methods to invoke registered commands.
Note, this class needs to be initialized first before it can be used.
Encapsulates the details of a DLPAR notification emitted by a
OperatingSystemMXBean when the total
physical memory changes.Support for the
TotalPhysicalMemoryNotificationInfo class.The
Trace class contains methods for controlling trace and using application trace.Parses the arguments and make available to rest of the formatter
A container for the information that is described by the <trace> data in the XML index.
Encapsulates a trace "file" - In this case it is a single file on the disk.
Encapsulates the header for a trace file.
Encapsulates the header for a trace file.
A class to format and report a binary TraceFileHeader produced by the IBM JVM's trace
engine.
Main routine for formatting the trace file.
Support for converting binary trace files to a human readable form.
The permission class for operations on the com.ibm.jvm.Trace class.
Class to represent a tracepoint produced by IBM JVM's trace engine.
Class to represent a tracepoint produced by IBM JVM's trace engine.
This is a Cursor that thinks it's an Iterator really.
The Trace Record corresponds to a runtime Trace Buffer, it is responsible for formatting
individual trace entries.
Extends Trace Record.
Extends Trace Record.
Extends Trace Record.
Trace section of a file header.
Trace section of a file header.
Vector containing all trace records for a specific thread.
Specific formatter to handle U64 which is not natively supported by the java long.
Memory source for storage range that is declared, but not backed.
Interface provides platform-specific management utilities on Unix and Unix-like
operating systems.
When trying to automatically determine support for in service JVMs the architecture needs to be determined from the
core file reader.
Class for parsing the unwind information from a .eh_frame header
It creates a list of FDE's (Frame Description Entry) objects and
the associated CIE's (Common Information Entry) for the process
when created.
Thrown when an error occurs while unzipping an archive
Provides various utility functions needed by the trace formatter
Value type helper class
areValueTypesSupported() must return true before using any other methods in this class
Acts as an accessor to the current build level of the ibmgpu library.
vthreads command lists all the virtual threads.
VMConstant pool value retrieval.
Create IVMData instances for each VM found in a Process
Contains tables from util/vrfytbl.c
Mutable java equivalent of J9StackWalkState
Map that weakly references values.
Implements !
XCOFF spec here: http://publib16.boulder.ibm.com/pseries/en_US/files/aixfiles/XCOFF.htm
Abstract superclass for all x/ commands
Utility class which reads in a configuration
properties file which defines a series of XPath
statements to execute against two source files.
CMVC 154851 : class created
This is a SAX 'lite' input stream whose primary purpose is to clean up
xml being allowing to be read by the SAX parser in DTFJ.
Resolves entries in a zip file without extracting the file
Sub-class of an image input stream that comes from a zip file entry
which allows it to provide more information than the standard
MemoryCacheImageInputStream such as the length of the stream.