sun.tools.attach.HotSpotVirtualMachine Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jmockit Show documentation
Show all versions of jmockit Show documentation
JMockit is a Java toolkit for developer (unit/integration) testing.
It contains mocking APIs and other tools, supporting both JUnit and TestNG.
The mocking APIs allow all kinds of Java code, without testability restrictions, to be tested
in isolation from selected dependencies.
/*
* Copyright 2005-2006 Sun Microsystems, Inc. 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. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*/
package sun.tools.attach;
import java.io.*;
import java.util.*;
import com.sun.tools.attach.*;
import com.sun.tools.attach.spi.*;
/**
* The HotSpot implementation of com.sun.tools.attach.VirtualMachine.
*/
public abstract class HotSpotVirtualMachine extends VirtualMachine
{
HotSpotVirtualMachine(AttachProvider provider, String id)
{
super(provider, id);
}
/**
* Load agent library.
* If isAbsolute is true then the agent library is the absolute path to the library and thus
* will not be expanded in the target VM.
* If isAbsolute is false then the agent library is just a library name and it will be expended
* in the target VM.
*/
private void loadAgentLibrary(String agentLibrary, boolean isAbsolute, String options)
throws AgentLoadException, AgentInitializationException, IOException
{
InputStream in = execute("load", agentLibrary, isAbsolute ? "true" : "false", options);
try {
int result = readInt(in);
if (result != 0) {
throw new AgentInitializationException("Agent_OnAttach failed", result);
}
}
finally {
in.close();
}
}
/**
* Load agent library - library name will be expanded in target VM.
*/
@Override
public void loadAgentLibrary(String agentLibrary, String options)
throws AgentLoadException, AgentInitializationException, IOException
{
loadAgentLibrary(agentLibrary, false, options);
}
/**
* Load agent - absolute path of library provided to target VM.
*/
@Override
public void loadAgentPath(String agentLibrary, String options)
throws AgentLoadException, AgentInitializationException, IOException
{
loadAgentLibrary(agentLibrary, true, options);
}
/**
* Load JPLIS agent which will load the agent JAR file and invoke the agentmain method.
*/
@Override
public void loadAgent(String agent, String options)
throws AgentLoadException, AgentInitializationException, IOException
{
String args = agent;
if (options != null) {
args = args + '=' + options;
}
try {
loadAgentLibrary("instrument", args);
}
catch (AgentLoadException ignore) {
throw new InternalError("instrument library is missing in target VM");
}
catch (AgentInitializationException x) {
/*
* Translate interesting errors into the right exception and message
* (FIXME: create a better interface to the instrument implementation so this isn't
* necessary).
*/
int rc = x.returnValue();
switch (rc) {
case JNI_ENOMEM:
throw new AgentLoadException("Insufficient memory");
case ATTACH_ERROR_BADJAR:
throw new AgentLoadException("Agent JAR not found or no Agent-Class attribute");
case ATTACH_ERROR_NOTONCP:
throw new AgentLoadException("Unable to add JAR file to system class path");
case ATTACH_ERROR_STARTFAIL:
throw new AgentInitializationException(
"Agent JAR loaded but agent failed to initialize");
default:
throw new AgentLoadException("Failed to load agent - unknown reason: " + rc);
}
}
}
/*
* The possible errors returned by JPLIS's agentmain.
*/
private static final int JNI_ENOMEM = -4;
private static final int ATTACH_ERROR_BADJAR = 100;
private static final int ATTACH_ERROR_NOTONCP = 101;
private static final int ATTACH_ERROR_STARTFAIL = 102;
/**
* Send "properties" command to target VM.
*/
@Override
public Properties getSystemProperties() throws IOException
{
InputStream in = null;
Properties props = new Properties();
try {
in = executeCommand("properties");
props.load(in);
}
finally {
if (in != null) {
in.close();
}
}
return props;
}
@Override
public Properties getAgentProperties() throws IOException
{
InputStream in = null;
Properties props = new Properties();
try {
in = executeCommand("agentProperties");
props.load(in);
}
finally {
if (in != null) {
in.close();
}
}
return props;
}
// --- HotSpot specific methods ---
// same as SIGQUIT
public void localDataDump() throws IOException
{
executeCommand("datadump").close();
}
// Remote ctrl-break. The output of the ctrl-break actions can be read from the input stream.
public InputStream remoteDataDump(Object... args) throws IOException
{
return executeCommand("threaddump", args);
}
// Remote heap dump. The output (error message) can be read from the returned input stream.
public InputStream dumpHeap(Object... args) throws IOException
{
return executeCommand("dumpheap", args);
}
// Heap histogram (heap inspection in HotSpot).
public InputStream heapHisto(Object... args) throws IOException
{
return executeCommand("inspectheap", args);
}
// Set JVM command line flag.
public InputStream setFlag(String name, String value) throws IOException
{
return executeCommand("setflag", name, value);
}
// Print command line flag.
public InputStream printFlag(String name) throws IOException
{
return executeCommand("printflag", name);
}
// -- Supporting methods
/**
* Execute the given command in the target VM - specific platform implementation must implement
* this.
*/
abstract InputStream execute(String cmd, Object... args) throws AgentLoadException, IOException;
/**
* Convenience method for simple commands.
*/
private InputStream executeCommand(String cmd, Object... args) throws IOException
{
try {
return execute(cmd, args);
}
catch (AgentLoadException ignore) {
throw new InternalError("Should not get here");
}
}
/**
* Utility method to read an 'int' from the input stream.
* Ideally we should be using java.util.Scanner here but this implementation guarantees not to
* read ahead.
*/
int readInt(InputStream in) throws IOException
{
StringBuilder sb = new StringBuilder();
// read to \n or EOF
int n;
byte[] buf = new byte[1];
do {
n = in.read(buf, 0, 1);
if (n > 0) {
char c = (char) buf[0];
if (c == '\n') {
break; // EOL found
}
else {
sb.append(c);
}
}
}
while (n > 0);
if (sb.length() == 0) {
throw new IOException("Premature EOF");
}
int value;
try {
value = Integer.parseInt(sb.toString());
}
catch (NumberFormatException ignore) {
throw new IOException("Non-numeric value found - int expected");
}
return value;
}
// -- attach timeout support
private static final long defaultAttachTimeout = 5000;
private volatile long attachTimeout;
/**
* Return attach timeout based on the value of the sun.tools.attach.attachTimeout
* property, or the default timeout if the property is not set to a positive value.
*/
long attachTimeout()
{
if (attachTimeout == 0) {
synchronized (this) {
if (attachTimeout == 0) {
try {
String s = System.getProperty("sun.tools.attach.attachTimeout");
attachTimeout = Long.parseLong(s);
}
catch (SecurityException ignore) {}
catch (NumberFormatException ignore) {}
if (attachTimeout <= 0) {
attachTimeout = defaultAttachTimeout;
}
}
}
}
return attachTimeout;
}
}