public static JavaVM GetInstance(JvmVirtualMachineRemoteHandle virtualMachineHandle)
{
JavaVM vm = _instances[new JavaVMHandle((IntPtr)virtualMachineHandle.Handle)];
//JNIEnvHandle env;
//JavaVMAttachArgs args = new JavaVMAttachArgs(jniVersion.Version1_6, IntPtr.Zero, jthreadGroup.Null);
//int result = vm.GetRawInterface().AttachCurrentThread(vm, out env, ref args);
//JvmEnvironment environment = vm.GetEnvironment(jvmtiVersion.Version1_1);
//if (environment != null)
//{
// jvmtiPhase phase = environment.GetPhase();
// if (phase == jvmtiPhase.Live)
// {
// }
//}
//if (attachCurrentThread)
//{
// JNIEnvHandle env;
// JavaVMAttachArgs args = new JavaVMAttachArgs(jvmtiVersion.Version1_1, IntPtr.Zero, jthreadGroup.Null);
// vm.GetRawInterface().AttachCurrentThread(vm, out env, ref args);
//}
return(vm);
}
private static void GetEnvironmentVersion(JavaVM vm)
{
JvmtiEnvironment env;
int error = vm.GetEnvironment(out env);
int version;
jvmtiError error2 = env.GetVersionNumber(out version);
}
public static unsafe int OnAttach(IntPtr vmPtr, IntPtr optionsPtr, IntPtr reserved)
{
_loaded = true;
JavaVM vm = JavaVM.GetOrCreateInstance(new JavaVMHandle(vmPtr));
string options = null;
if (optionsPtr != IntPtr.Zero)
{
options = ModifiedUTF8Encoding.GetString((byte *)optionsPtr);
}
return(0);
}
private JvmtiEnvironment(JavaVM virtualMachine, jvmtiEnvHandle handle)
{
Contract.Requires <ArgumentNullException>(virtualMachine != null, "virtualMachine");
_virtualMachine = virtualMachine;
_handle = handle;
_rawInterface = (jvmtiInterface)Marshal.PtrToStructure(Marshal.ReadIntPtr(handle.Handle), typeof(jvmtiInterface));
jvmtiCapabilities previousCapabilities;
JvmtiErrorHandler.ThrowOnFailure(RawInterface.GetCapabilities(this, out previousCapabilities));
jvmtiCapabilities potentialCapabilities;
JvmtiErrorHandler.ThrowOnFailure(RawInterface.GetPotentialCapabilities(this, out potentialCapabilities));
var capabilities =
new jvmtiCapabilities(
jvmtiCapabilities.CapabilityFlags1.CanTagObjects
| jvmtiCapabilities.CapabilityFlags1.CanGetSourceFileName
| jvmtiCapabilities.CapabilityFlags1.CanGetLineNumbers
| jvmtiCapabilities.CapabilityFlags1.CanGetSourceDebugExtension
| jvmtiCapabilities.CapabilityFlags1.CanAccessLocalVariables
| jvmtiCapabilities.CapabilityFlags1.CanGenerateSingleStepEvents
| jvmtiCapabilities.CapabilityFlags1.CanGenerateExceptionEvents
| jvmtiCapabilities.CapabilityFlags1.CanGenerateBreakpointEvents
| jvmtiCapabilities.CapabilityFlags1.CanGenerateFramePopEvents
| jvmtiCapabilities.CapabilityFlags1.CanGenerateAllClassHookEvents
| jvmtiCapabilities.CapabilityFlags1.CanGetBytecodes
| jvmtiCapabilities.CapabilityFlags1.CanSuspend,
jvmtiCapabilities.CapabilityFlags2.CanGetConstantPool
);
JvmtiErrorHandler.ThrowOnFailure(RawInterface.AddCapabilities(this, ref capabilities));
jvmtiCapabilities newCapabilities;
JvmtiErrorHandler.ThrowOnFailure(RawInterface.GetCapabilities(this, out newCapabilities));
}
private static JvmtiEnvironment CreateVirtualMachine(JavaVM virtualMachine, jvmtiEnvHandle handle)
{
return(new JvmtiEnvironment(virtualMachine, handle));
}
internal static JvmtiEnvironment GetOrCreateInstance(JavaVM virtualMachine, jvmtiEnvHandle handle)
{
return(_instances.GetOrAdd(handle, i => CreateVirtualMachine(virtualMachine, i)));
}
public static unsafe int OnLoad(IntPtr vmPtr, IntPtr optionsPtr, IntPtr reserved)
{
_loaded = true;
JavaVM vm = JavaVM.GetOrCreateInstance(new JavaVMHandle(vmPtr));
string optionsString = null;
if (optionsPtr != IntPtr.Zero)
{
optionsString = ModifiedUTF8Encoding.GetString((byte *)optionsPtr);
}
string[] options = new string[0];
if (optionsString != null)
{
options = optionsString.Split(',', ';');
}
#if false
// quick test
GetEnvironmentVersion(vm);
Action <JavaVM> action = GetEnvironmentVersion;
IAsyncResult result = action.BeginInvoke(vm, null, null);
result.AsyncWaitHandle.WaitOne();
#endif
AppDomain.CurrentDomain.AssemblyResolve += HandleAssemblyResolve;
if (options.Contains("ShowAgentExceptions", StringComparer.OrdinalIgnoreCase))
{
AppDomain.CurrentDomain.FirstChanceException += HandleFirstChanceException;
AppDomain.CurrentDomain.UnhandledException += HandleUnhandledException;
//AppDomain.CurrentDomain.ProcessExit += HandleProcessExit;
}
if (options.Contains("DisableStatementStepping", StringComparer.OrdinalIgnoreCase))
{
JavaVM.DisableStatementStepping = true;
}
List <WaitHandle> waitHandles = new List <WaitHandle>();
Binding binding;
/*
* start the wcf services and wait for the client to connect
*/
#if false
/* IJvmEventsService
*/
_jvmEventsPublisherHost = new ServiceHost(typeof(JvmEventsPublisher));
Binding binding = new NetNamedPipeBinding(NetNamedPipeSecurityMode.None)
{
ReceiveTimeout = TimeSpan.MaxValue,
SendTimeout = TimeSpan.MaxValue
};
_jvmEventsPublisherHost.AddServiceEndpoint(typeof(IJvmEventsService), binding, "net.pipe://localhost/Tvl.Java.DebugHost/JvmEventsService/");
IAsyncResult jvmEventsPublisherStartResult = _jvmEventsPublisherHost.BeginOpen(null, null);
waitHandles.Add(jvmEventsPublisherStartResult.AsyncWaitHandle);
/* IJvmToolsInterfaceService
*/
_jvmToolsInterfaceHost = new ServiceHost(typeof(JvmToolsInterfaceService));
binding = new NetNamedPipeBinding(NetNamedPipeSecurityMode.None)
{
ReceiveTimeout = TimeSpan.MaxValue,
SendTimeout = TimeSpan.MaxValue
};
_jvmToolsInterfaceHost.AddServiceEndpoint(typeof(IJvmToolsInterfaceService), binding, "net.pipe://localhost/Tvl.Java.DebugHost/JvmToolsInterfaceService/");
IAsyncResult toolsInterfaceStartResult = _jvmToolsInterfaceHost.BeginOpen(null, null);
waitHandles.Add(toolsInterfaceStartResult.AsyncWaitHandle);
/* IJvmDebugSessionService
*/
_jvmDebugSessionHost = new ServiceHost(typeof(JvmDebugSessionService));
binding = new NetNamedPipeBinding(NetNamedPipeSecurityMode.None)
{
ReceiveTimeout = TimeSpan.MaxValue,
SendTimeout = TimeSpan.MaxValue
};
_jvmDebugSessionHost.AddServiceEndpoint(typeof(IJvmDebugSessionService), binding, "net.pipe://localhost/Tvl.Java.DebugHost/JvmDebugSessionService/");
IAsyncResult debugSessionStartResult = _jvmDebugSessionHost.BeginOpen(null, null);
waitHandles.Add(debugSessionStartResult.AsyncWaitHandle);
#endif
/* IDebugProtocolService
*/
var debugProtocolService = new DebugProtocolService(vm);
_debugProtocolHost = new ServiceHost(debugProtocolService);
binding = new NetNamedPipeBinding(NetNamedPipeSecurityMode.None)
{
MaxReceivedMessageSize = 10 * 1024 * 1024,
ReceiveTimeout = TimeSpan.MaxValue,
SendTimeout = TimeSpan.MaxValue
};
_debugProtocolHost.AddServiceEndpoint(typeof(IDebugProtocolService), binding, "net.pipe://localhost/Tvl.Java.DebugHost/DebugProtocolService/");
IAsyncResult debugProtocolStartResult = _debugProtocolHost.BeginOpen(null, null);
waitHandles.Add(debugProtocolStartResult.AsyncWaitHandle);
/* Wait for the services to finish opening
*/
WaitHandle.WaitAll(waitHandles.ToArray());
EventWaitHandle eventWaitHandle = null;
try
{
eventWaitHandle = EventWaitHandle.OpenExisting(string.Format("JavaDebuggerInitHandle{0}", Process.GetCurrentProcess().Id));
}
catch (WaitHandleCannotBeOpenedException)
{
// must have been launched without the debugger
}
if (eventWaitHandle != null)
{
eventWaitHandle.Set();
Action waitAction = _debuggerAttachComplete.Wait;
IAsyncResult waitResult = waitAction.BeginInvoke(vm.HandleAsyncOperationComplete, null);
DispatcherFrame frame = new DispatcherFrame(true);
JvmtiEnvironment environment = debugProtocolService.Environment;
vm.PushDispatcherFrame(frame, environment, waitResult);
}
return(0);
}
public jvalue(JavaVM virtualMachine, JvmtiEnvironment environment, JniEnvironment nativeEnvironment, Value value)
: this()
{
if (value.Data == 0)
{
return;
}
switch (value.Tag)
{
case Tag.Byte:
ByteValue = (byte)value.Data;
break;
case Tag.Char:
CharValue = (char)value.Data;
break;
case Tag.Float:
IntValue = (int)(uint)value.Data;
break;
case Tag.Int:
IntValue = (int)value.Data;
break;
case Tag.Double:
LongValue = (long)(ulong)value.Data;
break;
case Tag.Long:
LongValue = value.Data;
break;
case Tag.Short:
ShortValue = (short)value.Data;
break;
case Tag.Boolean:
break;
case Tag.Array:
case Tag.Object:
case Tag.String:
case Tag.Thread:
case Tag.ThreadGroup:
case Tag.ClassLoader:
case Tag.ClassObject:
if (value.Data == 0)
{
return;
}
ObjectValue = virtualMachine.GetLocalReferenceForObject(nativeEnvironment, new ObjectId(value.Data)).Value;
break;
case Tag.Void:
case Tag.Invalid:
default:
throw new ArgumentException();
}
}
