2370 lines
114 KiB
Diff
2370 lines
114 KiB
Diff
From 4dcae48a47d1c2123d5ec86f3e2d6ef1adab8a83 Mon Sep 17 00:00:00 2001
|
|
From: Marian Koncek <mkoncek@redhat.com>
|
|
Date: Wed, 30 Sep 2020 13:04:45 +0200
|
|
Subject: [PATCH] Remove dependency on jna
|
|
|
|
---
|
|
.../net/bytebuddy/agent/VirtualMachine.java | 2275 +++--------------
|
|
1 file changed, 357 insertions(+), 1918 deletions(-)
|
|
|
|
diff --git a/byte-buddy-agent/src/main/java/net/bytebuddy/agent/VirtualMachine.java b/byte-buddy-agent/src/main/java/net/bytebuddy/agent/VirtualMachine.java
|
|
index 245581d..80cab63 100644
|
|
--- a/byte-buddy-agent/src/main/java/net/bytebuddy/agent/VirtualMachine.java
|
|
+++ b/byte-buddy-agent/src/main/java/net/bytebuddy/agent/VirtualMachine.java
|
|
@@ -15,13 +15,6 @@
|
|
*/
|
|
package net.bytebuddy.agent;
|
|
|
|
-import com.sun.jna.*;
|
|
-import com.sun.jna.platform.win32.*;
|
|
-import com.sun.jna.ptr.IntByReference;
|
|
-import com.sun.jna.win32.StdCallLibrary;
|
|
-import com.sun.jna.win32.W32APIOptions;
|
|
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
|
|
-
|
|
import java.io.*;
|
|
import java.net.ServerSocket;
|
|
import java.net.Socket;
|
|
@@ -227,23 +220,6 @@ public interface VirtualMachine {
|
|
this.connection = connection;
|
|
}
|
|
|
|
- /**
|
|
- * Attaches to the supplied process id using the default JNA implementation.
|
|
- *
|
|
- * @param processId The process id.
|
|
- * @return A suitable virtual machine implementation.
|
|
- * @throws IOException If an IO exception occurs during establishing the connection.
|
|
- */
|
|
- public static VirtualMachine attach(String processId) throws IOException {
|
|
- if (Platform.isWindows()) {
|
|
- return attach(processId, new Connection.ForJnaWindowsNamedPipe.Factory());
|
|
- } else if (Platform.isSolaris()) {
|
|
- return attach(processId, new Connection.ForJnaSolarisDoor.Factory(15, 100, TimeUnit.MILLISECONDS));
|
|
- } else {
|
|
- return attach(processId, Connection.ForJnaPosixSocket.Factory.withDefaultTemporaryFolder(15, 100, TimeUnit.MILLISECONDS));
|
|
- }
|
|
- }
|
|
-
|
|
/**
|
|
* Attaches to the supplied process id using the supplied connection factory.
|
|
*
|
|
@@ -515,7 +491,6 @@ public interface VirtualMachine {
|
|
/**
|
|
* {@inheritDoc}
|
|
*/
|
|
- @SuppressFBWarnings(value = "DMI_HARDCODED_ABSOLUTE_FILENAME", justification = "File name convention is specified.")
|
|
public Connection connect(String processId) throws IOException {
|
|
File socket = new File(temporaryDirectory, SOCKET_FILE_PREFIX + processId);
|
|
if (!socket.exists()) {
|
|
@@ -679,1949 +654,413 @@ public interface VirtualMachine {
|
|
*/
|
|
protected abstract int read(T connection, byte[] buffer) throws IOException;
|
|
}
|
|
+ }
|
|
+ }
|
|
|
|
- /**
|
|
- * Implements a connection for a Posix socket in JNA.
|
|
- */
|
|
- class ForJnaPosixSocket extends OnPersistentByteChannel<Integer> {
|
|
+ /**
|
|
+ * A virtual machine attachment implementation for OpenJ9 or any compatible JVM.
|
|
+ */
|
|
+ class ForOpenJ9 extends AbstractBase {
|
|
|
|
- /**
|
|
- * The JNA library to use.
|
|
- */
|
|
- private final PosixLibrary library;
|
|
+ /**
|
|
+ * The temporary folder for attachment files for OpenJ9 VMs.
|
|
+ */
|
|
+ private static final String IBM_TEMPORARY_FOLDER = "com.ibm.tools.attach.directory";
|
|
|
|
- /**
|
|
- * The POSIX socket.
|
|
- */
|
|
- private final File socket;
|
|
+ /**
|
|
+ * The socket on which this VM and the target VM communicate.
|
|
+ */
|
|
+ private final Socket socket;
|
|
|
|
- /**
|
|
- * Creates a connection for a virtual posix socket implemented in JNA.
|
|
- *
|
|
- * @param library The JNA library to use.
|
|
- * @param socket The POSIX socket.
|
|
- */
|
|
- protected ForJnaPosixSocket(PosixLibrary library, File socket) {
|
|
- this.library = library;
|
|
- this.socket = socket;
|
|
- }
|
|
+ /**
|
|
+ * Creates a new virtual machine connection for OpenJ9.
|
|
+ *
|
|
+ * @param socket The socket on which this VM and the target VM communicate.
|
|
+ */
|
|
+ protected ForOpenJ9(Socket socket) {
|
|
+ this.socket = socket;
|
|
+ }
|
|
|
|
- @Override
|
|
- protected Integer connect() {
|
|
- int handle = library.socket(1, 1, 0);
|
|
+ /**
|
|
+ * Attaches to the supplied process id.
|
|
+ *
|
|
+ * @param processId The process id.
|
|
+ * @param timeout The timeout for establishing the socket connection.
|
|
+ * @param dispatcher The connector to use to communicate with the target VM.
|
|
+ * @return A suitable virtual machine implementation.
|
|
+ * @throws IOException If an IO exception occurs during establishing the connection.
|
|
+ */
|
|
+ public static VirtualMachine attach(String processId, int timeout, Dispatcher dispatcher) throws IOException {
|
|
+ File directory = new File(System.getProperty(IBM_TEMPORARY_FOLDER, dispatcher.getTemporaryFolder()), ".com_ibm_tools_attach");
|
|
+ RandomAccessFile attachLock = new RandomAccessFile(new File(directory, "_attachlock"), "rw");
|
|
+ try {
|
|
+ FileLock attachLockLock = attachLock.getChannel().lock();
|
|
+ try {
|
|
+ List<Properties> virtualMachines;
|
|
+ RandomAccessFile master = new RandomAccessFile(new File(directory, "_master"), "rw");
|
|
try {
|
|
- PosixLibrary.SocketAddress address = new PosixLibrary.SocketAddress();
|
|
+ FileLock masterLock = master.getChannel().lock();
|
|
try {
|
|
- address.setPath(socket.getAbsolutePath());
|
|
- library.connect(handle, address, address.size());
|
|
- return handle;
|
|
- } finally {
|
|
- address = null;
|
|
- }
|
|
- } catch (RuntimeException exception) {
|
|
- library.close(handle);
|
|
- throw exception;
|
|
- }
|
|
- }
|
|
-
|
|
- @Override
|
|
- protected int read(Integer handle, byte[] buffer) {
|
|
- int read = library.read(handle, ByteBuffer.wrap(buffer), buffer.length);
|
|
- return read == 0 ? -1 : read;
|
|
- }
|
|
-
|
|
- @Override
|
|
- protected void write(Integer handle, byte[] buffer) {
|
|
- library.write(handle, ByteBuffer.wrap(buffer), buffer.length);
|
|
- }
|
|
-
|
|
- @Override
|
|
- protected void close(Integer handle) {
|
|
- library.close(handle);
|
|
- }
|
|
-
|
|
- /**
|
|
- * {@inheritDoc}
|
|
- */
|
|
- public void close() {
|
|
- /* do nothing */
|
|
- }
|
|
-
|
|
- /**
|
|
- * A JNA library binding for Posix sockets.
|
|
- */
|
|
- protected interface PosixLibrary extends Library {
|
|
-
|
|
- /**
|
|
- * Sends a kill command.
|
|
- *
|
|
- * @param processId The process id to kill.
|
|
- * @param signal The signal to send.
|
|
- * @return The return code.
|
|
- * @throws LastErrorException If an error occurs.
|
|
- */
|
|
- int kill(int processId, int signal) throws LastErrorException;
|
|
-
|
|
- /**
|
|
- * Creates a POSIX socket connection.
|
|
- *
|
|
- * @param domain The socket's domain.
|
|
- * @param type The socket's type.
|
|
- * @param protocol The protocol version.
|
|
- * @return A handle to the socket that was created or {@code 0} if no socket could be created.
|
|
- * @throws LastErrorException If an error occurs.
|
|
- */
|
|
- int socket(int domain, int type, int protocol) throws LastErrorException;
|
|
-
|
|
- /**
|
|
- * Connects a socket connection.
|
|
- *
|
|
- * @param handle The socket's handle.
|
|
- * @param address The address of the POSIX socket.
|
|
- * @param length The length of the socket value.
|
|
- * @return The return code.
|
|
- * @throws LastErrorException If an error occurs.
|
|
- */
|
|
- int connect(int handle, SocketAddress address, int length) throws LastErrorException;
|
|
-
|
|
- /**
|
|
- * Reads from a POSIX socket.
|
|
- *
|
|
- * @param handle The socket's handle.
|
|
- * @param buffer The buffer to read from.
|
|
- * @param count The bytes being read.
|
|
- * @return The amount of bytes that could be read.
|
|
- * @throws LastErrorException If an error occurs.
|
|
- */
|
|
- int read(int handle, ByteBuffer buffer, int count) throws LastErrorException;
|
|
-
|
|
- /**
|
|
- * Writes to a POSIX socket.
|
|
- *
|
|
- * @param handle The socket's handle.
|
|
- * @param buffer The buffer to write to.
|
|
- * @param count The bytes being written.
|
|
- * @return The return code.
|
|
- * @throws LastErrorException If an error occurs.
|
|
- */
|
|
- int write(int handle, ByteBuffer buffer, int count) throws LastErrorException;
|
|
-
|
|
- /**
|
|
- * Closes the socket connection.
|
|
- *
|
|
- * @param handle The handle of the connection.
|
|
- * @return The return code.
|
|
- * @throws LastErrorException If an error occurs.
|
|
- */
|
|
- int close(int handle) throws LastErrorException;
|
|
-
|
|
- /**
|
|
- * Represents an address for a POSIX socket.
|
|
- */
|
|
- class SocketAddress extends Structure {
|
|
-
|
|
- /**
|
|
- * The socket family.
|
|
- */
|
|
- @SuppressWarnings("unused")
|
|
- @SuppressFBWarnings(value = "URF_UNREAD_PUBLIC_OR_PROTECTED_FIELD", justification = "Field required by native implementation.")
|
|
- public short family = 1;
|
|
-
|
|
- /**
|
|
- * The socket path.
|
|
- */
|
|
- public byte[] path = new byte[100];
|
|
-
|
|
- /**
|
|
- * Sets the socket path.
|
|
- *
|
|
- * @param path The socket path.
|
|
- */
|
|
- protected void setPath(String path) {
|
|
- try {
|
|
- System.arraycopy(path.getBytes("UTF-8"), 0, this.path, 0, path.length());
|
|
- System.arraycopy(new byte[]{0}, 0, this.path, path.length(), 1);
|
|
- } catch (UnsupportedEncodingException exception) {
|
|
- throw new IllegalStateException(exception);
|
|
+ File[] vmFolder = directory.listFiles();
|
|
+ if (vmFolder == null) {
|
|
+ throw new IllegalStateException("No descriptor files found in " + directory);
|
|
}
|
|
- }
|
|
-
|
|
- @Override
|
|
- protected List<String> getFieldOrder() {
|
|
- return Arrays.asList("family", "path");
|
|
- }
|
|
- }
|
|
- }
|
|
-
|
|
- /**
|
|
- * A factory for a POSIX socket connection to a JVM using JNA.
|
|
- */
|
|
- public static class Factory extends Connection.Factory.ForSocketFile {
|
|
-
|
|
- /**
|
|
- * The socket library API.
|
|
- */
|
|
- private final PosixLibrary library;
|
|
-
|
|
- /**
|
|
- * Creates a connection factory for a POSIX socket using JNA.
|
|
- *
|
|
- * @param temporaryDirectory The temporary directory to use.
|
|
- * @param attempts The maximum amount of attempts for checking the establishment of a socket connection.
|
|
- * @param pause The pause between two checks for an established socket connection.
|
|
- * @param timeUnit The time unit of the pause time.
|
|
- */
|
|
- @SuppressWarnings("deprecation")
|
|
- public Factory(String temporaryDirectory, int attempts, long pause, TimeUnit timeUnit) {
|
|
- super(temporaryDirectory, attempts, pause, timeUnit);
|
|
- library = Native.loadLibrary("c", PosixLibrary.class);
|
|
- }
|
|
-
|
|
- /**
|
|
- * Creates a connection factory for a POSIX socket using JNA while locating the default temporary directory used on the
|
|
- * current platform.
|
|
- *
|
|
- * @param attempts The maximum amount of attempts for checking the establishment of a socket connection.
|
|
- * @param pause The pause between two checks for an established socket connection.
|
|
- * @param timeUnit The time unit of the pause time.
|
|
- * @return An appropriate connection factory.
|
|
- */
|
|
- @SuppressWarnings("deprecation")
|
|
- public static Connection.Factory withDefaultTemporaryFolder(int attempts, long pause, TimeUnit timeUnit) {
|
|
- String temporaryDirectory;
|
|
- if (Platform.isMac()) {
|
|
- MacLibrary library = Native.loadLibrary("c", MacLibrary.class);
|
|
- Memory memory = new Memory(4096);
|
|
- try {
|
|
- long length = library.confstr(MacLibrary.CS_DARWIN_USER_TEMP_DIR, memory, memory.size());
|
|
- if (length == 0 || length > 4096) {
|
|
- temporaryDirectory = "/tmp";
|
|
- } else {
|
|
- temporaryDirectory = memory.getString(0);
|
|
+ long userId = dispatcher.userId();
|
|
+ virtualMachines = new ArrayList<Properties>();
|
|
+ for (File aVmFolder : vmFolder) {
|
|
+ if (aVmFolder.isDirectory() && dispatcher.getOwnerIdOf(aVmFolder) == userId) {
|
|
+ File attachInfo = new File(aVmFolder, "attachInfo");
|
|
+ if (attachInfo.isFile()) {
|
|
+ Properties virtualMachine = new Properties();
|
|
+ FileInputStream inputStream = new FileInputStream(attachInfo);
|
|
+ try {
|
|
+ virtualMachine.load(inputStream);
|
|
+ } finally {
|
|
+ inputStream.close();
|
|
+ }
|
|
+ int targetProcessId = Integer.parseInt(virtualMachine.getProperty("processId"));
|
|
+ long targetUserId;
|
|
+ try {
|
|
+ targetUserId = Long.parseLong(virtualMachine.getProperty("userUid"));
|
|
+ } catch (NumberFormatException ignored) {
|
|
+ targetUserId = 0L;
|
|
+ }
|
|
+ if (userId != 0L && targetUserId == 0L) {
|
|
+ targetUserId = dispatcher.getOwnerIdOf(attachInfo);
|
|
+ }
|
|
+ if (targetProcessId == 0L || dispatcher.isExistingProcess(targetProcessId)) {
|
|
+ virtualMachines.add(virtualMachine);
|
|
+ } else if (userId == 0L || targetUserId == userId) {
|
|
+ File[] vmFile = aVmFolder.listFiles();
|
|
+ if (vmFile != null) {
|
|
+ for (File aVmFile : vmFile) {
|
|
+ if (!aVmFile.delete()) {
|
|
+ aVmFile.deleteOnExit();
|
|
+ }
|
|
+ }
|
|
+ }
|
|
+ if (!aVmFolder.delete()) {
|
|
+ aVmFolder.deleteOnExit();
|
|
+ }
|
|
+ }
|
|
+ }
|
|
}
|
|
- } finally {
|
|
- memory = null;
|
|
}
|
|
- } else {
|
|
- temporaryDirectory = "/tmp";
|
|
+ } finally {
|
|
+ masterLock.release();
|
|
}
|
|
- return new Factory(temporaryDirectory, attempts, pause, timeUnit);
|
|
- }
|
|
-
|
|
- @Override
|
|
- protected void kill(String processId, int signal) {
|
|
- library.kill(Integer.parseInt(processId), signal);
|
|
- }
|
|
-
|
|
- @Override
|
|
- public Connection doConnect(File socket) {
|
|
- return new Connection.ForJnaPosixSocket(library, socket);
|
|
- }
|
|
-
|
|
- /**
|
|
- * A library for reading a Mac user's temporary directory.
|
|
- */
|
|
- public interface MacLibrary extends Library {
|
|
-
|
|
- /**
|
|
- * The temporary directory.
|
|
- */
|
|
- int CS_DARWIN_USER_TEMP_DIR = 65537;
|
|
-
|
|
- /**
|
|
- * Reads a configuration dependant variable into a memory segment.
|
|
- *
|
|
- * @param name The name of the variable.
|
|
- * @param buffer The buffer to read the variable into.
|
|
- * @param length The length of the buffer.
|
|
- * @return The amount of bytes written to the buffer.
|
|
- */
|
|
- long confstr(int name, Pointer buffer, long length);
|
|
+ } finally {
|
|
+ master.close();
|
|
}
|
|
- }
|
|
- }
|
|
-
|
|
- /**
|
|
- * Implements a connection for a Windows named pipe in JNA.
|
|
- */
|
|
- class ForJnaWindowsNamedPipe implements Connection {
|
|
-
|
|
- /**
|
|
- * Indicates a memory release.
|
|
- */
|
|
- private static final int MEM_RELEASE = 0x8000;
|
|
-
|
|
- /**
|
|
- * The library to use for communicating with Windows native functions.
|
|
- */
|
|
- private final WindowsLibrary library;
|
|
-
|
|
- /**
|
|
- * The library to use for communicating with Windows attachment extension that is included as a DLL.
|
|
- */
|
|
- private final WindowsAttachLibrary attachLibrary;
|
|
-
|
|
- /**
|
|
- * The handle of the target VM's process.
|
|
- */
|
|
- private final WinNT.HANDLE process;
|
|
-
|
|
- /**
|
|
- * A pointer to the code that was injected into the target process.
|
|
- */
|
|
- private final WinDef.LPVOID code;
|
|
-
|
|
- /**
|
|
- * A source of random values being used for generating pipe names.
|
|
- */
|
|
- private final SecureRandom random;
|
|
-
|
|
- /**
|
|
- * Creates a new connection via a named pipe.
|
|
- *
|
|
- * @param library The library to use for communicating with Windows native functions.
|
|
- * @param attachLibrary The library to use for communicating with Windows attachment extension that is included as a DLL.
|
|
- * @param process The handle of the target VM's process.
|
|
- * @param code A pointer to the code that was injected into the target process.
|
|
- */
|
|
- protected ForJnaWindowsNamedPipe(WindowsLibrary library,
|
|
- WindowsAttachLibrary attachLibrary,
|
|
- WinNT.HANDLE process,
|
|
- WinDef.LPVOID code) {
|
|
- this.library = library;
|
|
- this.attachLibrary = attachLibrary;
|
|
- this.process = process;
|
|
- this.code = code;
|
|
- random = new SecureRandom();
|
|
- }
|
|
-
|
|
- /**
|
|
- * {@inheritDoc}
|
|
- */
|
|
- public Response execute(String protocol, String... argument) {
|
|
- if (!"1".equals(protocol)) {
|
|
- throw new IllegalArgumentException("Unknown protocol version: " + protocol);
|
|
- } else if (argument.length > 4) {
|
|
- throw new IllegalArgumentException("Cannot supply more then four arguments to Windows attach mechanism: " + Arrays.asList(argument));
|
|
+ Properties target = null;
|
|
+ for (Properties virtualMachine : virtualMachines) {
|
|
+ if (virtualMachine.getProperty("processId").equalsIgnoreCase(processId)) {
|
|
+ target = virtualMachine;
|
|
+ break;
|
|
+ }
|
|
}
|
|
- String name = "\\\\.\\pipe\\javatool" + Math.abs(random.nextInt() + 1);
|
|
- WinNT.HANDLE pipe = Kernel32.INSTANCE.CreateNamedPipe(name,
|
|
- WinBase.PIPE_ACCESS_INBOUND,
|
|
- WinBase.PIPE_TYPE_BYTE | WinBase.PIPE_READMODE_BYTE | WinBase.PIPE_WAIT,
|
|
- 1,
|
|
- 4096,
|
|
- 8192,
|
|
- WinBase.NMPWAIT_USE_DEFAULT_WAIT,
|
|
- null);
|
|
- if (pipe == null) {
|
|
- throw new Win32Exception(Native.getLastError());
|
|
+ if (target == null) {
|
|
+ throw new IllegalStateException("Could not locate target process info in " + directory);
|
|
}
|
|
+ ServerSocket serverSocket = new ServerSocket(0);
|
|
try {
|
|
- WinDef.LPVOID data = attachLibrary.allocate_remote_argument(process,
|
|
- name,
|
|
- argument.length < 1 ? null : argument[0],
|
|
- argument.length < 2 ? null : argument[1],
|
|
- argument.length < 3 ? null : argument[2],
|
|
- argument.length < 4 ? null : argument[3]);
|
|
- if (data == null) {
|
|
- throw new Win32Exception(Native.getLastError());
|
|
- }
|
|
+ serverSocket.setSoTimeout(timeout);
|
|
+ File receiver = new File(directory, target.getProperty("vmId"));
|
|
+ String key = Long.toHexString(new SecureRandom().nextLong());
|
|
+ File reply = new File(receiver, "replyInfo");
|
|
try {
|
|
- WinNT.HANDLE thread = library.CreateRemoteThread(process, null, 0, code.getPointer(), data.getPointer(), null, null);
|
|
- if (thread == null) {
|
|
- throw new Win32Exception(Native.getLastError());
|
|
+ if (reply.createNewFile()) {
|
|
+ dispatcher.setPermissions(reply, 0600);
|
|
}
|
|
+ FileOutputStream outputStream = new FileOutputStream(reply);
|
|
try {
|
|
- int result = Kernel32.INSTANCE.WaitForSingleObject(thread, WinBase.INFINITE);
|
|
- if (result != 0) {
|
|
- throw new Win32Exception(result);
|
|
- }
|
|
- IntByReference exitCode = new IntByReference();
|
|
- if (!library.GetExitCodeThread(thread, exitCode)) {
|
|
- throw new Win32Exception(Native.getLastError());
|
|
- } else if (exitCode.getValue() != 0) {
|
|
- throw new IllegalStateException("Target could not dispatch command successfully");
|
|
- }
|
|
- if (!Kernel32.INSTANCE.ConnectNamedPipe(pipe, null)) {
|
|
- int code = Native.getLastError();
|
|
- if (code != WinError.ERROR_PIPE_CONNECTED) {
|
|
- throw new Win32Exception(code);
|
|
- }
|
|
- }
|
|
- return new NamedPipeResponse(pipe);
|
|
+ outputStream.write(key.getBytes("UTF-8"));
|
|
+ outputStream.write("\n".getBytes("UTF-8"));
|
|
+ outputStream.write(Long.toString(serverSocket.getLocalPort()).getBytes("UTF-8"));
|
|
+ outputStream.write("\n".getBytes("UTF-8"));
|
|
} finally {
|
|
- if (!Kernel32.INSTANCE.CloseHandle(thread)) {
|
|
- throw new Win32Exception(Native.getLastError());
|
|
- }
|
|
- }
|
|
- } finally {
|
|
- if (!library.VirtualFreeEx(process, data.getPointer(), 0, MEM_RELEASE)) {
|
|
- throw new Win32Exception(Native.getLastError());
|
|
+ outputStream.close();
|
|
}
|
|
- }
|
|
- } catch (Throwable throwable) {
|
|
- if (!Kernel32.INSTANCE.CloseHandle(pipe)) {
|
|
- throw new Win32Exception(Native.getLastError());
|
|
- } else if (throwable instanceof RuntimeException) {
|
|
- throw (RuntimeException) throwable;
|
|
- } else {
|
|
- throw new IllegalStateException(throwable);
|
|
- }
|
|
- }
|
|
- }
|
|
-
|
|
- /**
|
|
- * {@inheritDoc}
|
|
- */
|
|
- public void close() {
|
|
- try {
|
|
- if (!library.VirtualFreeEx(process, code.getPointer(), 0, MEM_RELEASE)) {
|
|
- throw new Win32Exception(Native.getLastError());
|
|
- }
|
|
- } finally {
|
|
- if (!Kernel32.INSTANCE.CloseHandle(process)) {
|
|
- throw new Win32Exception(Native.getLastError());
|
|
- }
|
|
- }
|
|
- }
|
|
-
|
|
- /**
|
|
- * A library for interacting with Windows.
|
|
- */
|
|
- protected interface WindowsLibrary extends StdCallLibrary {
|
|
-
|
|
- /**
|
|
- * Changes the state of memory in a given process.
|
|
- *
|
|
- * @param process The process in which to change the memory.
|
|
- * @param address The address of the memory to allocate.
|
|
- * @param size The size of the allocated region.
|
|
- * @param allocationType The allocation type.
|
|
- * @param protect The memory protection.
|
|
- * @return A pointer to the allocated memory.
|
|
- */
|
|
- @SuppressWarnings({"unused", "checkstyle:methodname"})
|
|
- Pointer VirtualAllocEx(WinNT.HANDLE process, Pointer address, int size, int allocationType, int protect);
|
|
-
|
|
- /**
|
|
- * Frees memory in the given process.
|
|
- *
|
|
- * @param process The process in which to change the memory.
|
|
- * @param address The address of the memory to free.
|
|
- * @param size The size of the freed region.
|
|
- * @param freeType The freeing type.
|
|
- * @return {@code true} if the operation succeeded.
|
|
- */
|
|
- @SuppressWarnings("checkstyle:methodname")
|
|
- boolean VirtualFreeEx(WinNT.HANDLE process, Pointer address, int size, int freeType);
|
|
-
|
|
- /**
|
|
- * An alternative implementation of
|
|
- * {@link Kernel32#CreateRemoteThread(WinNT.HANDLE, WinBase.SECURITY_ATTRIBUTES, int, WinBase.FOREIGN_THREAD_START_ROUTINE, Pointer, WinDef.DWORD, Pointer)}
|
|
- * that uses a pointer as the {@code code} argument rather then a structure to avoid accessing foreign memory.
|
|
- *
|
|
- * @param process A handle of the target process.
|
|
- * @param securityAttributes The security attributes to use or {@code null} if no attributes are provided.
|
|
- * @param stackSize The stack size or {@code 0} for using the system default.
|
|
- * @param code A pointer to the code to execute.
|
|
- * @param argument A pointer to the argument to provide to the code being executed.
|
|
- * @param creationFlags The creation flags or {@code null} if no flags are set.
|
|
- * @param threadId A pointer to the thread id or {@code null} if no thread reference is set.
|
|
- * @return A handle to the created remote thread or {@code null} if the creation failed.
|
|
- */
|
|
- @SuppressWarnings("checkstyle:methodname")
|
|
- WinNT.HANDLE CreateRemoteThread(WinNT.HANDLE process,
|
|
- WinBase.SECURITY_ATTRIBUTES securityAttributes,
|
|
- int stackSize,
|
|
- Pointer code,
|
|
- Pointer argument,
|
|
- WinDef.DWORD creationFlags,
|
|
- Pointer threadId);
|
|
-
|
|
- /**
|
|
- * Receives the exit code of a given thread.
|
|
- *
|
|
- * @param thread A handle to the targeted thread.
|
|
- * @param exitCode A reference to the exit code value.
|
|
- * @return {@code true} if the exit code retrieval succeeded.
|
|
- */
|
|
- @SuppressWarnings("checkstyle:methodname")
|
|
- boolean GetExitCodeThread(WinNT.HANDLE thread, IntByReference exitCode);
|
|
- }
|
|
-
|
|
- /**
|
|
- * A library for interacting with Windows.
|
|
- */
|
|
- protected interface WindowsAttachLibrary extends StdCallLibrary {
|
|
-
|
|
- /**
|
|
- * Allocates the code to invoke on the remote VM.
|
|
- *
|
|
- * @param process A handle to the target process.
|
|
- * @return A pointer to the allocated code or {@code null} if the code could not be allocated.
|
|
- */
|
|
- @SuppressWarnings("checkstyle:methodname")
|
|
- WinDef.LPVOID allocate_remote_code(WinNT.HANDLE process);
|
|
-
|
|
- /**
|
|
- * Allocates the remote argument to supply to the remote code upon execution.
|
|
- *
|
|
- * @param process A handle to the target process.
|
|
- * @param pipe The name of the pipe used for supplying an answer.
|
|
- * @param argument0 The first argument or {@code null} if no such argument is provided.
|
|
- * @param argument1 The second argument or {@code null} if no such argument is provided.
|
|
- * @param argument2 The third argument or {@code null} if no such argument is provided.
|
|
- * @param argument3 The forth argument or {@code null} if no such argument is provided.
|
|
- * @return A pointer to the allocated argument or {@code null} if the argument could not be allocated.
|
|
- */
|
|
- @SuppressWarnings("checkstyle:methodname")
|
|
- WinDef.LPVOID allocate_remote_argument(WinNT.HANDLE process,
|
|
- String pipe,
|
|
- String argument0,
|
|
- String argument1,
|
|
- String argument2,
|
|
- String argument3);
|
|
- }
|
|
-
|
|
- /**
|
|
- * A response that is sent via a named pipe.
|
|
- */
|
|
- protected static class NamedPipeResponse implements Response {
|
|
-
|
|
- /**
|
|
- * A handle of the named pipe.
|
|
- */
|
|
- private final WinNT.HANDLE pipe;
|
|
-
|
|
- /**
|
|
- * Creates a new response via a named pipe.
|
|
- *
|
|
- * @param pipe The handle of the named pipe.
|
|
- */
|
|
- protected NamedPipeResponse(WinNT.HANDLE pipe) {
|
|
- this.pipe = pipe;
|
|
- }
|
|
-
|
|
- /**
|
|
- * {@inheritDoc}
|
|
- */
|
|
- public int read(byte[] buffer) {
|
|
- IntByReference read = new IntByReference();
|
|
- if (!Kernel32.INSTANCE.ReadFile(pipe, buffer, buffer.length, read, null)) {
|
|
- int code = Native.getLastError();
|
|
- if (code == WinError.ERROR_BROKEN_PIPE) {
|
|
- return -1;
|
|
- } else {
|
|
- throw new Win32Exception(code);
|
|
- }
|
|
- }
|
|
- return read.getValue();
|
|
- }
|
|
-
|
|
- /**
|
|
- * {@inheritDoc}
|
|
- */
|
|
- public void close() {
|
|
- try {
|
|
- if (!Kernel32.INSTANCE.DisconnectNamedPipe(pipe)) {
|
|
- throw new Win32Exception(Native.getLastError());
|
|
- }
|
|
- } finally {
|
|
- if (!Kernel32.INSTANCE.CloseHandle(pipe)) {
|
|
- throw new Win32Exception(Native.getLastError());
|
|
- }
|
|
- }
|
|
- }
|
|
- }
|
|
-
|
|
- /**
|
|
- * A factory for establishing a connection to a JVM using a named pipe in JNA.
|
|
- */
|
|
- public static class Factory implements Connection.Factory {
|
|
-
|
|
- /**
|
|
- * The name of the native code library that is included in this artifact to support Windows attachment.
|
|
- * This property can be set by other libraries that shade Byte Buddy agent and relocates the library.
|
|
- */
|
|
- public static final String LIBRARY_NAME = "net.bytebuddy.library.name";
|
|
-
|
|
- /**
|
|
- * The library to use for communicating with Windows native functions.
|
|
- */
|
|
- private final WindowsLibrary library;
|
|
-
|
|
- /**
|
|
- * The library to use for communicating with Windows attachment extension that is included as a DLL.
|
|
- */
|
|
- private final WindowsAttachLibrary attachLibrary;
|
|
-
|
|
- /**
|
|
- * Creates a new connection factory for Windows using JNA.
|
|
- */
|
|
- @SuppressWarnings("deprecation")
|
|
- public Factory() {
|
|
- library = Native.loadLibrary("kernel32", WindowsLibrary.class, W32APIOptions.DEFAULT_OPTIONS);
|
|
- attachLibrary = Native.loadLibrary(System.getProperty(LIBRARY_NAME, "attach_hotspot_windows"), WindowsAttachLibrary.class);
|
|
- }
|
|
-
|
|
- /**
|
|
- * {@inheritDoc}
|
|
- */
|
|
- public Connection connect(String processId) {
|
|
- WinNT.HANDLE process = Kernel32.INSTANCE.OpenProcess(WinNT.PROCESS_ALL_ACCESS, false, Integer.parseInt(processId));
|
|
- if (process == null) {
|
|
- throw new Win32Exception(Native.getLastError());
|
|
- }
|
|
- try {
|
|
- WinDef.LPVOID code = attachLibrary.allocate_remote_code(process);
|
|
- if (code == null) {
|
|
- throw new Win32Exception(Native.getLastError());
|
|
- }
|
|
- return new ForJnaWindowsNamedPipe(library, attachLibrary, process, code);
|
|
- } catch (Throwable throwable) {
|
|
- if (!Kernel32.INSTANCE.CloseHandle(process)) {
|
|
- throw new Win32Exception(Native.getLastError());
|
|
- } else if (throwable instanceof RuntimeException) {
|
|
- throw (RuntimeException) throwable;
|
|
- } else {
|
|
- throw new IllegalStateException(throwable);
|
|
- }
|
|
- }
|
|
- }
|
|
- }
|
|
- }
|
|
-
|
|
- /**
|
|
- * A connection to a VM using a Solaris door.
|
|
- */
|
|
- class ForJnaSolarisDoor implements Connection {
|
|
-
|
|
- /**
|
|
- * The library to use for interacting with Solaris.
|
|
- */
|
|
- private final SolarisLibrary library;
|
|
-
|
|
- /**
|
|
- * The socket used for communication.
|
|
- */
|
|
- private final File socket;
|
|
-
|
|
- /**
|
|
- * Creates a new connection using a Solaris door.
|
|
- *
|
|
- * @param library The library to use for interacting with Solaris.
|
|
- * @param socket The socket used for communication.
|
|
- */
|
|
- protected ForJnaSolarisDoor(SolarisLibrary library, File socket) {
|
|
- this.library = library;
|
|
- this.socket = socket;
|
|
- }
|
|
-
|
|
- /**
|
|
- * {@inheritDoc}
|
|
- */
|
|
- @SuppressFBWarnings(value = {"UWF_UNWRITTEN_PUBLIC_OR_PROTECTED_FIELD", "URF_UNREAD_PUBLIC_OR_PROTECTED_FIELD"}, justification = "This pattern is required for use of JNA.")
|
|
- public Connection.Response execute(String protocol, String... argument) throws IOException {
|
|
- int handle = library.open(socket.getAbsolutePath(), 2);
|
|
- try {
|
|
- SolarisLibrary.DoorArgument door = new SolarisLibrary.DoorArgument();
|
|
- try {
|
|
- ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
|
|
- outputStream.write(protocol.getBytes("UTF-8"));
|
|
- outputStream.write(0);
|
|
- for (String anArgument : argument) {
|
|
- if (anArgument != null) {
|
|
- outputStream.write(anArgument.getBytes("UTF-8"));
|
|
- }
|
|
- outputStream.write(0);
|
|
- }
|
|
- door.dataSize = outputStream.size();
|
|
- Memory dataPointer = new Memory(outputStream.size());
|
|
- try {
|
|
- dataPointer.write(0, outputStream.toByteArray(), 0, outputStream.size());
|
|
- door.dataPointer = dataPointer;
|
|
- Memory result = new Memory(128);
|
|
- try {
|
|
- door.resultPointer = result;
|
|
- door.resultSize = (int) result.size();
|
|
- if (library.door_call(handle, door) != 0) {
|
|
- throw new IllegalStateException("Door call to target VM failed");
|
|
- } else if (door.resultSize < 4 || door.resultPointer.getInt(0) != 0) {
|
|
- throw new IllegalStateException("Target VM could not execute door call");
|
|
- } else if (door.descriptorCount != 1 || door.descriptorPointer == null) {
|
|
- throw new IllegalStateException("Did not receive communication descriptor from target VM");
|
|
- } else {
|
|
- return new Response(library, door.descriptorPointer.getInt(4));
|
|
- }
|
|
- } finally {
|
|
- result = null;
|
|
- }
|
|
- } finally {
|
|
- dataPointer = null;
|
|
- }
|
|
- } finally {
|
|
- door = null;
|
|
- }
|
|
- } finally {
|
|
- library.close(handle);
|
|
- }
|
|
- }
|
|
-
|
|
- /**
|
|
- * {@inheritDoc}
|
|
- */
|
|
- public void close() {
|
|
- /* do nothing */
|
|
- }
|
|
-
|
|
- /**
|
|
- * A library for interacting with Solaris.
|
|
- */
|
|
- protected interface SolarisLibrary extends Library {
|
|
-
|
|
- /**
|
|
- * Sends a kill signal to the target VM.
|
|
- *
|
|
- * @param processId The target process's id.
|
|
- * @param signal The signal to send.
|
|
- * @return The return code.
|
|
- * @throws LastErrorException If an error occurred while sending the signal.
|
|
- */
|
|
- int kill(int processId, int signal) throws LastErrorException;
|
|
-
|
|
- /**
|
|
- * Opens a file.
|
|
- *
|
|
- * @param file The file name.
|
|
- * @param flags the flags for opening.
|
|
- * @return The file descriptor.
|
|
- * @throws LastErrorException If the file could not be opened.
|
|
- */
|
|
- int open(String file, int flags) throws LastErrorException;
|
|
-
|
|
- /**
|
|
- * Reads from a handle.
|
|
- *
|
|
- * @param handle The handle representing the source being read.
|
|
- * @param buffer The buffer to read to.
|
|
- * @param length The buffer length.
|
|
- * @return The amount of bytes being read.
|
|
- * @throws LastErrorException If a read operation failed.
|
|
- */
|
|
- int read(int handle, ByteBuffer buffer, int length) throws LastErrorException;
|
|
-
|
|
- /**
|
|
- * Releases a descriptor.
|
|
- *
|
|
- * @param descriptor The descriptor to release.
|
|
- * @return The return code.
|
|
- * @throws LastErrorException If the descriptor could not be closed.
|
|
- */
|
|
- int close(int descriptor) throws LastErrorException;
|
|
-
|
|
- /**
|
|
- * Executes a door call.
|
|
- *
|
|
- * @param descriptor The door's descriptor.
|
|
- * @param argument A pointer to the argument.
|
|
- * @return The door's handle.
|
|
- * @throws LastErrorException If the door call failed.
|
|
- */
|
|
- @SuppressWarnings("checkstyle:methodname")
|
|
- int door_call(int descriptor, DoorArgument argument) throws LastErrorException;
|
|
-
|
|
- /**
|
|
- * A structure representing the argument to a Solaris door operation.
|
|
- */
|
|
- class DoorArgument extends Structure {
|
|
-
|
|
- /**
|
|
- * A pointer to the operation argument.
|
|
- */
|
|
- public Pointer dataPointer;
|
|
-
|
|
- /**
|
|
- * The size of the argument being pointed to.
|
|
- */
|
|
- public int dataSize;
|
|
-
|
|
- /**
|
|
- * A pointer to the operation descriptor.
|
|
- */
|
|
- public Pointer descriptorPointer;
|
|
-
|
|
- /**
|
|
- * The size of the operation argument.
|
|
- */
|
|
- public int descriptorCount;
|
|
-
|
|
- /**
|
|
- * A pointer to the operation result.
|
|
- */
|
|
- public Pointer resultPointer;
|
|
-
|
|
- /**
|
|
- * The size of the operation argument.
|
|
- */
|
|
- public int resultSize;
|
|
-
|
|
- @Override
|
|
- protected List<String> getFieldOrder() {
|
|
- return Arrays.asList("dataPointer", "dataSize", "descriptorPointer", "descriptorCount", "resultPointer", "resultSize");
|
|
- }
|
|
- }
|
|
- }
|
|
-
|
|
- /**
|
|
- * A response from a VM using a Solaris door.
|
|
- */
|
|
- protected static class Response implements Connection.Response {
|
|
-
|
|
- /**
|
|
- * The Solaris library to use.
|
|
- */
|
|
- private final SolarisLibrary library;
|
|
-
|
|
- /**
|
|
- * The door handle.
|
|
- */
|
|
- private final int handle;
|
|
-
|
|
- /**
|
|
- * Creates a response from a VM using a Solaris door.
|
|
- *
|
|
- * @param library The Solaris library to use.
|
|
- * @param handle The door handle.
|
|
- */
|
|
- protected Response(SolarisLibrary library, int handle) {
|
|
- this.library = library;
|
|
- this.handle = handle;
|
|
- }
|
|
-
|
|
- /**
|
|
- * {@inheritDoc}
|
|
- */
|
|
- public int read(byte[] buffer) {
|
|
- int read = library.read(handle, ByteBuffer.wrap(buffer), buffer.length);
|
|
- return read == 0 ? -1 : read;
|
|
- }
|
|
-
|
|
- /**
|
|
- * {@inheritDoc}
|
|
- */
|
|
- public void close() {
|
|
- library.close(handle);
|
|
- }
|
|
- }
|
|
-
|
|
- /**
|
|
- * A factory for establishing a connection to a JVM using a Solaris door in JNA.
|
|
- */
|
|
- public static class Factory extends Connection.Factory.ForSocketFile {
|
|
-
|
|
- /**
|
|
- * The library to use for interacting with Solaris.
|
|
- */
|
|
- private final SolarisLibrary library;
|
|
-
|
|
- /**
|
|
- * Creates a new connection factory for a Solaris VM.
|
|
- *
|
|
- * @param attempts The maximum amount of attempts for checking the establishment of a socket connection.
|
|
- * @param pause The pause between two checks for an established socket connection.
|
|
- * @param timeUnit The time unit of the pause time.
|
|
- */
|
|
- @SuppressWarnings("deprecation")
|
|
- public Factory(int attempts, long pause, TimeUnit timeUnit) {
|
|
- super("/tmp", attempts, pause, timeUnit);
|
|
- library = Native.loadLibrary("c", SolarisLibrary.class);
|
|
- }
|
|
-
|
|
- /**
|
|
- * {@inheritDoc}
|
|
- */
|
|
- protected void kill(String processId, int signal) {
|
|
- library.kill(Integer.parseInt(processId), signal);
|
|
- }
|
|
-
|
|
- /**
|
|
- * {@inheritDoc}
|
|
- */
|
|
- protected Connection doConnect(File socket) {
|
|
- return new ForJnaSolarisDoor(library, socket);
|
|
- }
|
|
- }
|
|
- }
|
|
- }
|
|
- }
|
|
-
|
|
- /**
|
|
- * A virtual machine attachment implementation for OpenJ9 or any compatible JVM.
|
|
- */
|
|
- class ForOpenJ9 extends AbstractBase {
|
|
-
|
|
- /**
|
|
- * The temporary folder for attachment files for OpenJ9 VMs.
|
|
- */
|
|
- private static final String IBM_TEMPORARY_FOLDER = "com.ibm.tools.attach.directory";
|
|
-
|
|
- /**
|
|
- * The socket on which this VM and the target VM communicate.
|
|
- */
|
|
- private final Socket socket;
|
|
-
|
|
- /**
|
|
- * Creates a new virtual machine connection for OpenJ9.
|
|
- *
|
|
- * @param socket The socket on which this VM and the target VM communicate.
|
|
- */
|
|
- protected ForOpenJ9(Socket socket) {
|
|
- this.socket = socket;
|
|
- }
|
|
-
|
|
- /**
|
|
- * Attaches to the supplied process id using the default JNA implementation.
|
|
- *
|
|
- * @param processId The process id.
|
|
- * @return A suitable virtual machine implementation.
|
|
- * @throws IOException If an IO exception occurs during establishing the connection.
|
|
- */
|
|
- public static VirtualMachine attach(String processId) throws IOException {
|
|
- return attach(processId, 5000, Platform.isWindows()
|
|
- ? new Dispatcher.ForJnaWindowsEnvironment()
|
|
- : new Dispatcher.ForJnaPosixEnvironment(15, 100, TimeUnit.MILLISECONDS));
|
|
- }
|
|
-
|
|
- /**
|
|
- * Attaches to the supplied process id.
|
|
- *
|
|
- * @param processId The process id.
|
|
- * @param timeout The timeout for establishing the socket connection.
|
|
- * @param dispatcher The connector to use to communicate with the target VM.
|
|
- * @return A suitable virtual machine implementation.
|
|
- * @throws IOException If an IO exception occurs during establishing the connection.
|
|
- */
|
|
- public static VirtualMachine attach(String processId, int timeout, Dispatcher dispatcher) throws IOException {
|
|
- File directory = new File(System.getProperty(IBM_TEMPORARY_FOLDER, dispatcher.getTemporaryFolder()), ".com_ibm_tools_attach");
|
|
- RandomAccessFile attachLock = new RandomAccessFile(new File(directory, "_attachlock"), "rw");
|
|
- try {
|
|
- FileLock attachLockLock = attachLock.getChannel().lock();
|
|
- try {
|
|
- List<Properties> virtualMachines;
|
|
- RandomAccessFile master = new RandomAccessFile(new File(directory, "_master"), "rw");
|
|
- try {
|
|
- FileLock masterLock = master.getChannel().lock();
|
|
- try {
|
|
- File[] vmFolder = directory.listFiles();
|
|
- if (vmFolder == null) {
|
|
- throw new IllegalStateException("No descriptor files found in " + directory);
|
|
- }
|
|
- long userId = dispatcher.userId();
|
|
- virtualMachines = new ArrayList<Properties>();
|
|
- for (File aVmFolder : vmFolder) {
|
|
- if (aVmFolder.isDirectory() && dispatcher.getOwnerIdOf(aVmFolder) == userId) {
|
|
- File attachInfo = new File(aVmFolder, "attachInfo");
|
|
- if (attachInfo.isFile()) {
|
|
- Properties virtualMachine = new Properties();
|
|
- FileInputStream inputStream = new FileInputStream(attachInfo);
|
|
- try {
|
|
- virtualMachine.load(inputStream);
|
|
- } finally {
|
|
- inputStream.close();
|
|
- }
|
|
- int targetProcessId = Integer.parseInt(virtualMachine.getProperty("processId"));
|
|
- long targetUserId;
|
|
- try {
|
|
- targetUserId = Long.parseLong(virtualMachine.getProperty("userUid"));
|
|
- } catch (NumberFormatException ignored) {
|
|
- targetUserId = 0L;
|
|
- }
|
|
- if (userId != 0L && targetUserId == 0L) {
|
|
- targetUserId = dispatcher.getOwnerIdOf(attachInfo);
|
|
- }
|
|
- if (targetProcessId == 0L || dispatcher.isExistingProcess(targetProcessId)) {
|
|
- virtualMachines.add(virtualMachine);
|
|
- } else if (userId == 0L || targetUserId == userId) {
|
|
- File[] vmFile = aVmFolder.listFiles();
|
|
- if (vmFile != null) {
|
|
- for (File aVmFile : vmFile) {
|
|
- if (!aVmFile.delete()) {
|
|
- aVmFile.deleteOnExit();
|
|
- }
|
|
- }
|
|
- }
|
|
- if (!aVmFolder.delete()) {
|
|
- aVmFolder.deleteOnExit();
|
|
- }
|
|
- }
|
|
- }
|
|
- }
|
|
- }
|
|
- } finally {
|
|
- masterLock.release();
|
|
- }
|
|
- } finally {
|
|
- master.close();
|
|
- }
|
|
- Properties target = null;
|
|
- for (Properties virtualMachine : virtualMachines) {
|
|
- if (virtualMachine.getProperty("processId").equalsIgnoreCase(processId)) {
|
|
- target = virtualMachine;
|
|
- break;
|
|
- }
|
|
- }
|
|
- if (target == null) {
|
|
- throw new IllegalStateException("Could not locate target process info in " + directory);
|
|
- }
|
|
- ServerSocket serverSocket = new ServerSocket(0);
|
|
- try {
|
|
- serverSocket.setSoTimeout(timeout);
|
|
- File receiver = new File(directory, target.getProperty("vmId"));
|
|
- String key = Long.toHexString(new SecureRandom().nextLong());
|
|
- File reply = new File(receiver, "replyInfo");
|
|
- try {
|
|
- if (reply.createNewFile()) {
|
|
- dispatcher.setPermissions(reply, 0600);
|
|
- }
|
|
- FileOutputStream outputStream = new FileOutputStream(reply);
|
|
- try {
|
|
- outputStream.write(key.getBytes("UTF-8"));
|
|
- outputStream.write("\n".getBytes("UTF-8"));
|
|
- outputStream.write(Long.toString(serverSocket.getLocalPort()).getBytes("UTF-8"));
|
|
- outputStream.write("\n".getBytes("UTF-8"));
|
|
- } finally {
|
|
- outputStream.close();
|
|
- }
|
|
- Map<RandomAccessFile, FileLock> locks = new HashMap<RandomAccessFile, FileLock>();
|
|
- try {
|
|
- String pid = Long.toString(dispatcher.pid());
|
|
- for (Properties virtualMachine : virtualMachines) {
|
|
- if (!virtualMachine.getProperty("processId").equalsIgnoreCase(pid)) {
|
|
- String attachNotificationSync = virtualMachine.getProperty("attachNotificationSync");
|
|
- RandomAccessFile syncFile = new RandomAccessFile(attachNotificationSync == null
|
|
- ? new File(directory, "attachNotificationSync")
|
|
- : new File(attachNotificationSync), "rw");
|
|
- try {
|
|
- locks.put(syncFile, syncFile.getChannel().lock());
|
|
- } catch (IOException ignored) {
|
|
- syncFile.close();
|
|
- }
|
|
- }
|
|
- }
|
|
- int notifications = 0;
|
|
- File[] item = directory.listFiles();
|
|
- if (item != null) {
|
|
- for (File anItem : item) {
|
|
- String name = anItem.getName();
|
|
- if (!name.startsWith(".trash_")
|
|
- && !name.equalsIgnoreCase("_attachlock")
|
|
- && !name.equalsIgnoreCase("_master")
|
|
- && !name.equalsIgnoreCase("_notifier")) {
|
|
- notifications += 1;
|
|
- }
|
|
- }
|
|
- }
|
|
- boolean global = Boolean.parseBoolean(target.getProperty("globalSemaphore"));
|
|
- dispatcher.incrementSemaphore(directory, "_notifier", global, notifications);
|
|
- try {
|
|
- Socket socket = serverSocket.accept();
|
|
- String answer = new String(read(socket), "UTF-8");
|
|
- if (answer.contains(' ' + key + ' ')) {
|
|
- return new ForOpenJ9(socket);
|
|
- } else {
|
|
- socket.close();
|
|
- throw new IllegalStateException("Unexpected answered to attachment: " + answer);
|
|
- }
|
|
- } finally {
|
|
- dispatcher.decrementSemaphore(directory, "_notifier", global, notifications);
|
|
- }
|
|
- } finally {
|
|
- for (Map.Entry<RandomAccessFile, FileLock> entry : locks.entrySet()) {
|
|
- try {
|
|
- try {
|
|
- entry.getValue().release();
|
|
- } finally {
|
|
- entry.getKey().close();
|
|
- }
|
|
- } catch (Throwable ignored) {
|
|
- /* do nothing */
|
|
- }
|
|
- }
|
|
- }
|
|
- } finally {
|
|
- if (!reply.delete()) {
|
|
- reply.deleteOnExit();
|
|
- }
|
|
- }
|
|
- } finally {
|
|
- serverSocket.close();
|
|
- }
|
|
- } finally {
|
|
- attachLockLock.release();
|
|
- }
|
|
- } finally {
|
|
- attachLock.close();
|
|
- }
|
|
- }
|
|
-
|
|
- /**
|
|
- * {@inheritDoc}
|
|
- */
|
|
- public Properties getSystemProperties() throws IOException {
|
|
- write(socket, "ATTACH_GETSYSTEMPROPERTIES".getBytes("UTF-8"));
|
|
- Properties properties = new Properties();
|
|
- properties.load(new ByteArrayInputStream(read(socket)));
|
|
- return properties;
|
|
- }
|
|
-
|
|
- /**
|
|
- * {@inheritDoc}
|
|
- */
|
|
- public Properties getAgentProperties() throws IOException {
|
|
- write(socket, "ATTACH_GETAGENTPROPERTIES".getBytes("UTF-8"));
|
|
- Properties properties = new Properties();
|
|
- properties.load(new ByteArrayInputStream(read(socket)));
|
|
- return properties;
|
|
- }
|
|
-
|
|
- /**
|
|
- * {@inheritDoc}
|
|
- */
|
|
- public void loadAgent(String jarFile, String argument) throws IOException {
|
|
- write(socket, ("ATTACH_LOADAGENT(instrument," + jarFile + '=' + (argument == null ? "" : argument) + ')').getBytes("UTF-8"));
|
|
- String answer = new String(read(socket), "UTF-8");
|
|
- if (answer.startsWith("ATTACH_ERR")) {
|
|
- throw new IllegalStateException("Target VM failed loading agent: " + answer);
|
|
- } else if (!answer.startsWith("ATTACH_ACK") && !answer.startsWith("ATTACH_RESULT=")) {
|
|
- throw new IllegalStateException("Unexpected response: " + answer);
|
|
- }
|
|
- }
|
|
-
|
|
- /**
|
|
- * {@inheritDoc}
|
|
- */
|
|
- public void loadAgentPath(String path, String argument) throws IOException {
|
|
- write(socket, ("ATTACH_LOADAGENTPATH(" + path + (argument == null ? "" : (',' + argument)) + ')').getBytes("UTF-8"));
|
|
- String answer = new String(read(socket), "UTF-8");
|
|
- if (answer.startsWith("ATTACH_ERR")) {
|
|
- throw new IllegalStateException("Target VM failed loading native agent: " + answer);
|
|
- } else if (!answer.startsWith("ATTACH_ACK") && !answer.startsWith("ATTACH_RESULT=")) {
|
|
- throw new IllegalStateException("Unexpected response: " + answer);
|
|
- }
|
|
- }
|
|
-
|
|
- /**
|
|
- * {@inheritDoc}
|
|
- */
|
|
- public void loadAgentLibrary(String library, String argument) throws IOException {
|
|
- write(socket, ("ATTACH_LOADAGENTLIBRARY(" + library + (argument == null ? "" : (',' + argument)) + ')').getBytes("UTF-8"));
|
|
- String answer = new String(read(socket), "UTF-8");
|
|
- if (answer.startsWith("ATTACH_ERR")) {
|
|
- throw new IllegalStateException("Target VM failed loading native library: " + answer);
|
|
- } else if (!answer.startsWith("ATTACH_ACK") && !answer.startsWith("ATTACH_RESULT=")) {
|
|
- throw new IllegalStateException("Unexpected response: " + answer);
|
|
- }
|
|
- }
|
|
-
|
|
- /**
|
|
- * {@inheritDoc}
|
|
- */
|
|
- public void startManagementAgent(Properties properties) throws IOException {
|
|
- ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
|
|
- properties.store(outputStream, null);
|
|
- write(socket, "ATTACH_START_MANAGEMENT_AGENT".getBytes("UTF-8"));
|
|
- write(socket, outputStream.toByteArray());
|
|
- String answer = new String(read(socket), "UTF-8");
|
|
- if (answer.startsWith("ATTACH_ERR")) {
|
|
- throw new IllegalStateException("Target VM could not start management agent: " + answer);
|
|
- } else if (!answer.startsWith("ATTACH_ACK") && !answer.startsWith("ATTACH_RESULT=")) {
|
|
- throw new IllegalStateException("Unexpected response: " + answer);
|
|
- }
|
|
- }
|
|
-
|
|
- /**
|
|
- * {@inheritDoc}
|
|
- */
|
|
- public String startLocalManagementAgent() throws IOException {
|
|
- write(socket, "ATTACH_START_LOCAL_MANAGEMENT_AGENT".getBytes("UTF-8"));
|
|
- String answer = new String(read(socket), "UTF-8");
|
|
- if (answer.startsWith("ATTACH_ERR")) {
|
|
- throw new IllegalStateException("Target VM could not start management agent: " + answer);
|
|
- } else if (answer.startsWith("ATTACH_ACK")) {
|
|
- return answer.substring("ATTACH_ACK".length());
|
|
- } else if (answer.startsWith("ATTACH_RESULT=")) {
|
|
- return answer.substring("ATTACH_RESULT=".length());
|
|
- } else {
|
|
- throw new IllegalStateException("Unexpected response: " + answer);
|
|
- }
|
|
- }
|
|
-
|
|
- /**
|
|
- * {@inheritDoc}
|
|
- */
|
|
- public void detach() throws IOException {
|
|
- try {
|
|
- write(socket, "ATTACH_DETACH".getBytes("UTF-8"));
|
|
- read(socket); // The answer is intentionally ignored.
|
|
- } finally {
|
|
- socket.close();
|
|
- }
|
|
- }
|
|
-
|
|
- /**
|
|
- * Writes the supplied value to the target socket.
|
|
- *
|
|
- * @param socket The socket to write to.
|
|
- * @param value The value being written.
|
|
- * @throws IOException If an I/O exception occurs.
|
|
- */
|
|
- private static void write(Socket socket, byte[] value) throws IOException {
|
|
- socket.getOutputStream().write(value);
|
|
- socket.getOutputStream().write(0);
|
|
- socket.getOutputStream().flush();
|
|
- }
|
|
-
|
|
- /**
|
|
- * Reads a {@code '\0'}-terminated value from the target socket.
|
|
- *
|
|
- * @param socket The socket to read from.
|
|
- * @return The value that was read.
|
|
- * @throws IOException If an I/O exception occurs.
|
|
- */
|
|
- private static byte[] read(Socket socket) throws IOException {
|
|
- ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
|
|
- byte[] buffer = new byte[1024];
|
|
- int length;
|
|
- while ((length = socket.getInputStream().read(buffer)) != -1) {
|
|
- if (length > 0 && buffer[length - 1] == 0) {
|
|
- outputStream.write(buffer, 0, length - 1);
|
|
- break;
|
|
- } else {
|
|
- outputStream.write(buffer, 0, length);
|
|
- }
|
|
- }
|
|
- return outputStream.toByteArray();
|
|
- }
|
|
-
|
|
- /**
|
|
- * A dispatcher for native operations being used for communication with an OpenJ9 virtual machine.
|
|
- */
|
|
- public interface Dispatcher {
|
|
-
|
|
- /**
|
|
- * Returns this machine's temporary folder.
|
|
- *
|
|
- * @return The temporary folder.
|
|
- */
|
|
- String getTemporaryFolder();
|
|
-
|
|
- /**
|
|
- * Returns the process id of this process.
|
|
- *
|
|
- * @return The process id of this process.
|
|
- */
|
|
- int pid();
|
|
-
|
|
- /**
|
|
- * Returns the user id of this process.
|
|
- *
|
|
- * @return The user id of this process
|
|
- */
|
|
- int userId();
|
|
-
|
|
- /**
|
|
- * Returns {@code true} if the supplied process id is a running process.
|
|
- *
|
|
- * @param processId The process id to evaluate.
|
|
- * @return {@code true} if the supplied process id is currently running.
|
|
- */
|
|
- boolean isExistingProcess(int processId);
|
|
-
|
|
- /**
|
|
- * Returns the user id of the owner of the supplied file.
|
|
- *
|
|
- * @param file The file for which to locate the owner.
|
|
- * @return The owner id of the supplied file.
|
|
- */
|
|
- int getOwnerIdOf(File file);
|
|
-
|
|
- /**
|
|
- * Sets permissions for the supplied file.
|
|
- *
|
|
- * @param file The file for which to set the permissions.
|
|
- * @param permissions The permission bits to set.
|
|
- */
|
|
- void setPermissions(File file, int permissions);
|
|
-
|
|
- /**
|
|
- * Increments a semaphore.
|
|
- *
|
|
- * @param directory The sempahore's control directory.
|
|
- * @param name The semaphore's name.
|
|
- * @param global {@code true} if the semaphore is in the global namespace (only applicable on Windows).
|
|
- * @param count The amount of increments.
|
|
- */
|
|
- void incrementSemaphore(File directory, String name, boolean global, int count);
|
|
-
|
|
- /**
|
|
- * Decrements a semaphore.
|
|
- *
|
|
- * @param directory The sempahore's control directory.
|
|
- * @param name The semaphore's name.
|
|
- * @param global {@code true} if the semaphore is in the global namespace (only applicable on Windows).
|
|
- * @param count The amount of decrements.
|
|
- */
|
|
- void decrementSemaphore(File directory, String name, boolean global, int count);
|
|
-
|
|
- /**
|
|
- * A connector implementation for a POSIX environment using JNA.
|
|
- */
|
|
- class ForJnaPosixEnvironment implements Dispatcher {
|
|
-
|
|
- /**
|
|
- * The JNA library to use.
|
|
- */
|
|
- private final PosixLibrary library;
|
|
-
|
|
- /**
|
|
- * The maximum amount of attempts for checking the result of a foreign process.
|
|
- */
|
|
- private final int attempts;
|
|
-
|
|
- /**
|
|
- * The pause between two checks for another process to return.
|
|
- */
|
|
- private final long pause;
|
|
-
|
|
- /**
|
|
- * The time unit of the pause time.
|
|
- */
|
|
- private final TimeUnit timeUnit;
|
|
-
|
|
- /**
|
|
- * Creates a new connector for a POSIX enviornment using JNA.
|
|
- *
|
|
- * @param attempts The maximum amount of attempts for checking the result of a foreign process.
|
|
- * @param pause The pause between two checks for another process to return.
|
|
- * @param timeUnit The time unit of the pause time.
|
|
- */
|
|
- @SuppressWarnings("deprecation")
|
|
- public ForJnaPosixEnvironment(int attempts, long pause, TimeUnit timeUnit) {
|
|
- this.attempts = attempts;
|
|
- this.pause = pause;
|
|
- this.timeUnit = timeUnit;
|
|
- library = Native.loadLibrary("c", PosixLibrary.class);
|
|
- }
|
|
-
|
|
- /**
|
|
- * {@inheritDoc}
|
|
- */
|
|
- public String getTemporaryFolder() {
|
|
- String temporaryFolder = System.getenv("TMPDIR");
|
|
- return temporaryFolder == null ? "/tmp" : temporaryFolder;
|
|
- }
|
|
-
|
|
- /**
|
|
- * {@inheritDoc}
|
|
- */
|
|
- public int pid() {
|
|
- return library.getpid();
|
|
- }
|
|
-
|
|
- /**
|
|
- * {@inheritDoc}
|
|
- */
|
|
- public int userId() {
|
|
- return library.getuid();
|
|
- }
|
|
-
|
|
- /**
|
|
- * {@inheritDoc}
|
|
- */
|
|
- public boolean isExistingProcess(int processId) {
|
|
- return library.kill(processId, PosixLibrary.NULL_SIGNAL) != PosixLibrary.ESRCH;
|
|
- }
|
|
-
|
|
- /**
|
|
- * {@inheritDoc}
|
|
- */
|
|
- @SuppressFBWarnings(value = "OS_OPEN_STREAM", justification = "The stream life-cycle is bound to its process.")
|
|
- public int getOwnerIdOf(File file) {
|
|
- try {
|
|
- // The binding for 'stat' is very platform dependant. To avoid the complexity of binding the correct method,
|
|
- // stat is called as a separate command. This is less efficient but more portable.
|
|
- String statUserSwitch = Platform.isMac() ? "-f" : "-c";
|
|
- Process process = Runtime.getRuntime().exec("stat " + statUserSwitch + " %u " + file.getAbsolutePath());
|
|
- int attempts = this.attempts;
|
|
- boolean exited = false;
|
|
- String line = new BufferedReader(new InputStreamReader(process.getInputStream(), "UTF-8")).readLine();
|
|
- do {
|
|
+ Map<RandomAccessFile, FileLock> locks = new HashMap<RandomAccessFile, FileLock>();
|
|
try {
|
|
- if (process.exitValue() != 0) {
|
|
- throw new IllegalStateException("Error while executing stat");
|
|
- }
|
|
- exited = true;
|
|
- break;
|
|
- } catch (IllegalThreadStateException ignored) {
|
|
- try {
|
|
- Thread.sleep(timeUnit.toMillis(pause));
|
|
- } catch (InterruptedException exception) {
|
|
- Thread.currentThread().interrupt();
|
|
- throw new IllegalStateException(exception);
|
|
+ String pid = Long.toString(dispatcher.pid());
|
|
+ for (Properties virtualMachine : virtualMachines) {
|
|
+ if (!virtualMachine.getProperty("processId").equalsIgnoreCase(pid)) {
|
|
+ String attachNotificationSync = virtualMachine.getProperty("attachNotificationSync");
|
|
+ RandomAccessFile syncFile = new RandomAccessFile(attachNotificationSync == null
|
|
+ ? new File(directory, "attachNotificationSync")
|
|
+ : new File(attachNotificationSync), "rw");
|
|
+ try {
|
|
+ locks.put(syncFile, syncFile.getChannel().lock());
|
|
+ } catch (IOException ignored) {
|
|
+ syncFile.close();
|
|
+ }
|
|
+ }
|
|
}
|
|
- }
|
|
- } while (--attempts > 0);
|
|
- if (!exited) {
|
|
- process.destroy();
|
|
- throw new IllegalStateException("Command for stat did not exit in time");
|
|
- }
|
|
- return Integer.parseInt(line);
|
|
- } catch (IOException exception) {
|
|
- throw new IllegalStateException("Unable to execute stat command", exception);
|
|
- }
|
|
- }
|
|
-
|
|
- /**
|
|
- * {@inheritDoc}
|
|
- */
|
|
- public void setPermissions(File file, int permissions) {
|
|
- library.chmod(file.getAbsolutePath(), permissions);
|
|
- }
|
|
-
|
|
- /**
|
|
- * {@inheritDoc}
|
|
- */
|
|
- public void incrementSemaphore(File directory, String name, boolean global, int count) {
|
|
- notifySemaphore(directory, name, count, (short) 1, (short) 0, false);
|
|
- }
|
|
-
|
|
- /**
|
|
- * {@inheritDoc}
|
|
- */
|
|
- public void decrementSemaphore(File directory, String name, boolean global, int count) {
|
|
- notifySemaphore(directory, name, count, (short) -1, (short) (PosixLibrary.SEM_UNDO | PosixLibrary.IPC_NOWAIT), true);
|
|
- }
|
|
-
|
|
- /**
|
|
- * Notifies a POSIX semaphore.
|
|
- *
|
|
- * @param directory The semaphore's directory.
|
|
- * @param name The semaphore's name.
|
|
- * @param count The amount of notifications to send.
|
|
- * @param operation The operation to apply.
|
|
- * @param flags The flags to set.
|
|
- * @param acceptUnavailable {@code true} if a {@code EAGAIN} code should be accepted.
|
|
- */
|
|
- @SuppressFBWarnings(value = {"URF_UNREAD_PUBLIC_OR_PROTECTED_FIELD", "UUF_UNUSED_PUBLIC_OR_PROTECTED_FIELD"}, justification = "Modifier is required by JNA.")
|
|
- private void notifySemaphore(File directory, String name, int count, short operation, short flags, boolean acceptUnavailable) {
|
|
- int semaphore = library.semget(library.ftok(new File(directory, name).getAbsolutePath(), 0xA1), 2, 0666);
|
|
- PosixLibrary.SemaphoreOperation target = new PosixLibrary.SemaphoreOperation();
|
|
- target.operation = operation;
|
|
- target.flags = flags;
|
|
- try {
|
|
- while (count-- > 0) {
|
|
- try {
|
|
- library.semop(semaphore, target, 1);
|
|
- } catch (LastErrorException exception) {
|
|
- if (acceptUnavailable && (Native.getLastError() == PosixLibrary.EAGAIN
|
|
- || Native.getLastError() == PosixLibrary.EDEADLK)) {
|
|
- break;
|
|
- } else {
|
|
- throw exception;
|
|
+ int notifications = 0;
|
|
+ File[] item = directory.listFiles();
|
|
+ if (item != null) {
|
|
+ for (File anItem : item) {
|
|
+ String name = anItem.getName();
|
|
+ if (!name.startsWith(".trash_")
|
|
+ && !name.equalsIgnoreCase("_attachlock")
|
|
+ && !name.equalsIgnoreCase("_master")
|
|
+ && !name.equalsIgnoreCase("_notifier")) {
|
|
+ notifications += 1;
|
|
+ }
|
|
+ }
|
|
}
|
|
- }
|
|
- }
|
|
- } finally {
|
|
- target = null;
|
|
- }
|
|
- }
|
|
-
|
|
- /**
|
|
- * An API for interaction with POSIX systems.
|
|
- */
|
|
- protected interface PosixLibrary extends Library {
|
|
-
|
|
- /**
|
|
- * A null signal.
|
|
- */
|
|
- int NULL_SIGNAL = 0;
|
|
-
|
|
- /**
|
|
- * Indicates that a process does not exist.
|
|
- */
|
|
- int ESRCH = 3;
|
|
-
|
|
- /**
|
|
- * Indicates that a request timed out.
|
|
- */
|
|
- int EAGAIN = 11;
|
|
-
|
|
- /**
|
|
- * Indicates a dead lock on a resource.
|
|
- */
|
|
- int EDEADLK = 35;
|
|
-
|
|
- /**
|
|
- * Indicates that a semaphore's operations should be undone at process shutdown.
|
|
- */
|
|
- short SEM_UNDO = 0x1000;
|
|
-
|
|
- /**
|
|
- * Indicates that one should not wait for the release of a semaphore if it is not currently available.
|
|
- */
|
|
- short IPC_NOWAIT = 04000;
|
|
-
|
|
- /**
|
|
- * Runs the {@code getpid} command.
|
|
- *
|
|
- * @return The command's return value.
|
|
- * @throws LastErrorException If an error occurred.
|
|
- */
|
|
- int getpid() throws LastErrorException;
|
|
-
|
|
- /**
|
|
- * Runs the {@code getuid} command.
|
|
- *
|
|
- * @return The command's return value.
|
|
- * @throws LastErrorException If an error occurred.
|
|
- */
|
|
- int getuid() throws LastErrorException;
|
|
-
|
|
- /**
|
|
- * Runs the {@code kill} command.
|
|
- *
|
|
- * @param processId The target process id.
|
|
- * @param signal The signal to send.
|
|
- * @return The command's return value.
|
|
- * @throws LastErrorException If an error occurred.
|
|
- */
|
|
- int kill(int processId, int signal) throws LastErrorException;
|
|
-
|
|
- /**
|
|
- * Runs the {@code chmod} command.
|
|
- *
|
|
- * @param path The file path.
|
|
- * @param mode The mode to set.
|
|
- * @return The return code.
|
|
- * @throws LastErrorException If an error occurred.
|
|
- */
|
|
- int chmod(String path, int mode) throws LastErrorException;
|
|
-
|
|
- /**
|
|
- * Runs the {@code ftok} command.
|
|
- *
|
|
- * @param path The file path.
|
|
- * @param id The id being used for creating the generated key.
|
|
- * @return The generated key.
|
|
- * @throws LastErrorException If an error occurred.
|
|
- */
|
|
- int ftok(String path, int id) throws LastErrorException;
|
|
-
|
|
- /**
|
|
- * Runs the {@code semget} command.
|
|
- *
|
|
- * @param key The key of the semaphore.
|
|
- * @param count The initial count of the semaphore.
|
|
- * @param flags The flags to set.
|
|
- * @return The id of the semaphore.
|
|
- * @throws LastErrorException If an error occurred.
|
|
- */
|
|
- int semget(int key, int count, int flags) throws LastErrorException;
|
|
-
|
|
- /**
|
|
- * Runs the {@code semop} command.
|
|
- *
|
|
- * @param id The id of the semaphore.
|
|
- * @param operation The initial count of the semaphore.
|
|
- * @param flags The flags to set.
|
|
- * @return The return code.
|
|
- * @throws LastErrorException If the operation was not successful.
|
|
- */
|
|
- int semop(int id, SemaphoreOperation operation, int flags) throws LastErrorException;
|
|
-
|
|
- /**
|
|
- * A structure to represent a semaphore operation for {@code semop}.
|
|
- */
|
|
- class SemaphoreOperation extends Structure {
|
|
-
|
|
- /**
|
|
- * The semaphore number.
|
|
- */
|
|
- @SuppressWarnings("unused")
|
|
- public short number;
|
|
-
|
|
- /**
|
|
- * The operation to execute.
|
|
- */
|
|
- public short operation;
|
|
-
|
|
- /**
|
|
- * The flags being set for the operation.
|
|
- */
|
|
- public short flags;
|
|
-
|
|
- @Override
|
|
- protected List<String> getFieldOrder() {
|
|
- return Arrays.asList("number", "operation", "flags");
|
|
- }
|
|
- }
|
|
- }
|
|
- }
|
|
-
|
|
- /**
|
|
- * A connector implementation for a Windows environment using JNA.
|
|
- */
|
|
- class ForJnaWindowsEnvironment implements Dispatcher {
|
|
-
|
|
- /**
|
|
- * Indicates a missing user id what is not supported on Windows.
|
|
- */
|
|
- private static final int NO_USER_ID = 0;
|
|
-
|
|
- /**
|
|
- * The name of the creation mutex.
|
|
- */
|
|
- private static final String CREATION_MUTEX_NAME = "j9shsemcreationMutex";
|
|
-
|
|
- /**
|
|
- * A library to use for interacting with Windows.
|
|
- */
|
|
- private final WindowsLibrary library;
|
|
-
|
|
- /**
|
|
- * Creates a new connector for a Windows environment using JNA.
|
|
- */
|
|
- @SuppressWarnings("deprecation")
|
|
- public ForJnaWindowsEnvironment() {
|
|
- library = Native.loadLibrary("kernel32", WindowsLibrary.class, W32APIOptions.DEFAULT_OPTIONS);
|
|
- }
|
|
-
|
|
- /**
|
|
- * {@inheritDoc}
|
|
- */
|
|
- public String getTemporaryFolder() {
|
|
- WinDef.DWORD length = new WinDef.DWORD(WinDef.MAX_PATH);
|
|
- char[] path = new char[length.intValue()];
|
|
- if (Kernel32.INSTANCE.GetTempPath(length, path).intValue() == 0) {
|
|
- throw new Win32Exception(Kernel32.INSTANCE.GetLastError());
|
|
- }
|
|
- return Native.toString(path);
|
|
- }
|
|
-
|
|
- /**
|
|
- * {@inheritDoc}
|
|
- */
|
|
- public int pid() {
|
|
- return Kernel32.INSTANCE.GetCurrentProcessId();
|
|
- }
|
|
-
|
|
- /**
|
|
- * {@inheritDoc}
|
|
- */
|
|
- public int userId() {
|
|
- return NO_USER_ID;
|
|
- }
|
|
-
|
|
- /**
|
|
- * {@inheritDoc}
|
|
- */
|
|
- public boolean isExistingProcess(int processId) {
|
|
- WinNT.HANDLE handle = Kernel32.INSTANCE.OpenProcess(WinNT.PROCESS_QUERY_INFORMATION, false, processId);
|
|
- if (handle == null) {
|
|
- throw new Win32Exception(Kernel32.INSTANCE.GetLastError());
|
|
- }
|
|
- IntByReference exists = new IntByReference();
|
|
- if (!Kernel32.INSTANCE.GetExitCodeProcess(handle, exists)) {
|
|
- throw new Win32Exception(Kernel32.INSTANCE.GetLastError());
|
|
- }
|
|
- return exists.getValue() == WinBase.STILL_ACTIVE;
|
|
- }
|
|
-
|
|
- /**
|
|
- * {@inheritDoc}
|
|
- */
|
|
- public int getOwnerIdOf(File file) {
|
|
- return NO_USER_ID;
|
|
- }
|
|
-
|
|
- /**
|
|
- * {@inheritDoc}
|
|
- */
|
|
- public void setPermissions(File file, int permissions) {
|
|
- /* do nothing */
|
|
- }
|
|
-
|
|
- /**
|
|
- * {@inheritDoc}
|
|
- */
|
|
- public void incrementSemaphore(File directory, String name, boolean global, int count) {
|
|
- AttachmentHandle handle = openSemaphore(directory, name, global);
|
|
- try {
|
|
- while (count-- > 0) {
|
|
- if (!library.ReleaseSemaphore(handle.getHandle(), 1, null)) {
|
|
- throw new Win32Exception(Kernel32.INSTANCE.GetLastError());
|
|
- }
|
|
- }
|
|
- } finally {
|
|
- handle.close();
|
|
- }
|
|
- }
|
|
-
|
|
- /**
|
|
- * {@inheritDoc}
|
|
- */
|
|
- public void decrementSemaphore(File directory, String name, boolean global, int count) {
|
|
- AttachmentHandle handle = openSemaphore(directory, name, global);
|
|
- try {
|
|
- while (count-- > 0) {
|
|
- int result = Kernel32.INSTANCE.WaitForSingleObject(handle.getHandle(), 0);
|
|
- switch (result) {
|
|
- case WinBase.WAIT_ABANDONED:
|
|
- case WinBase.WAIT_OBJECT_0:
|
|
- break;
|
|
- case WinError.WAIT_TIMEOUT:
|
|
- return;
|
|
- default:
|
|
- throw new Win32Exception(result);
|
|
- }
|
|
- }
|
|
- } finally {
|
|
- handle.close();
|
|
- }
|
|
- }
|
|
-
|
|
- /**
|
|
- * Opens a semaphore for signaling another process that an attachment is performed.
|
|
- *
|
|
- * @param directory The control directory.
|
|
- * @param name The semaphore's name.
|
|
- * @param global {@code true} if the semaphore is in the global namespace.
|
|
- * @return A handle for signaling an attachment to the target process.
|
|
- */
|
|
- private AttachmentHandle openSemaphore(File directory, String name, boolean global) {
|
|
- WinNT.SECURITY_DESCRIPTOR securityDescriptor = new WinNT.SECURITY_DESCRIPTOR(64 * 1024);
|
|
- try {
|
|
- if (!Advapi32.INSTANCE.InitializeSecurityDescriptor(securityDescriptor, WinNT.SECURITY_DESCRIPTOR_REVISION)) {
|
|
- throw new Win32Exception(Kernel32.INSTANCE.GetLastError());
|
|
- }
|
|
- if (!Advapi32.INSTANCE.SetSecurityDescriptorDacl(securityDescriptor, true, null, true)) {
|
|
- throw new Win32Exception(Kernel32.INSTANCE.GetLastError());
|
|
- }
|
|
- WindowsLibrary.SecurityAttributes securityAttributes = new WindowsLibrary.SecurityAttributes();
|
|
- try {
|
|
- securityAttributes.length = new WinDef.DWORD(securityAttributes.size());
|
|
- securityAttributes.securityDescriptor = securityDescriptor.getPointer();
|
|
- WinNT.HANDLE mutex = library.CreateMutex(securityAttributes, false, CREATION_MUTEX_NAME);
|
|
- if (mutex == null) {
|
|
- int lastError = Kernel32.INSTANCE.GetLastError();
|
|
- if (lastError == WinError.ERROR_ALREADY_EXISTS) {
|
|
- mutex = library.OpenMutex(WinNT.STANDARD_RIGHTS_REQUIRED | WinNT.SYNCHRONIZE | 0x0001, false, CREATION_MUTEX_NAME);
|
|
- if (mutex == null) {
|
|
- throw new Win32Exception(Kernel32.INSTANCE.GetLastError());
|
|
+ boolean global = Boolean.parseBoolean(target.getProperty("globalSemaphore"));
|
|
+ dispatcher.incrementSemaphore(directory, "_notifier", global, notifications);
|
|
+ try {
|
|
+ Socket socket = serverSocket.accept();
|
|
+ String answer = new String(read(socket), "UTF-8");
|
|
+ if (answer.contains(' ' + key + ' ')) {
|
|
+ return new ForOpenJ9(socket);
|
|
+ } else {
|
|
+ socket.close();
|
|
+ throw new IllegalStateException("Unexpected answered to attachment: " + answer);
|
|
}
|
|
- } else {
|
|
- throw new Win32Exception(lastError);
|
|
+ } finally {
|
|
+ dispatcher.decrementSemaphore(directory, "_notifier", global, notifications);
|
|
}
|
|
- }
|
|
- int result = Kernel32.INSTANCE.WaitForSingleObject(mutex, 2000);
|
|
- switch (result) {
|
|
- case WinBase.WAIT_FAILED:
|
|
- case WinError.WAIT_TIMEOUT:
|
|
- throw new Win32Exception(result);
|
|
- default:
|
|
+ } finally {
|
|
+ for (Map.Entry<RandomAccessFile, FileLock> entry : locks.entrySet()) {
|
|
try {
|
|
- String target = (global ? "Global\\" : "")
|
|
- + (directory.getAbsolutePath() + '_' + name).replaceAll("[^a-zA-Z0-9_]", "")
|
|
- + "_semaphore";
|
|
- WinNT.HANDLE parent = library.OpenSemaphoreW(WindowsLibrary.SEMAPHORE_ALL_ACCESS, false, target);
|
|
- if (parent == null) {
|
|
- parent = library.CreateSemaphoreW(null, 0, Integer.MAX_VALUE, target);
|
|
- if (parent == null) {
|
|
- throw new Win32Exception(Kernel32.INSTANCE.GetLastError());
|
|
- }
|
|
- WinNT.HANDLE child = library.CreateSemaphoreW(null, 0, Integer.MAX_VALUE, target + "_set0");
|
|
- if (child == null) {
|
|
- throw new Win32Exception(Kernel32.INSTANCE.GetLastError());
|
|
- }
|
|
- return new AttachmentHandle(parent, child);
|
|
- } else {
|
|
- WinNT.HANDLE child = library.OpenSemaphoreW(WindowsLibrary.SEMAPHORE_ALL_ACCESS, false, target + "_set0");
|
|
- if (child == null) {
|
|
- throw new Win32Exception(Kernel32.INSTANCE.GetLastError());
|
|
- }
|
|
- return new AttachmentHandle(parent, child);
|
|
- }
|
|
- } finally {
|
|
- if (!library.ReleaseMutex(mutex)) {
|
|
- throw new Win32Exception(Native.getLastError());
|
|
+ try {
|
|
+ entry.getValue().release();
|
|
+ } finally {
|
|
+ entry.getKey().close();
|
|
}
|
|
+ } catch (Throwable ignored) {
|
|
+ /* do nothing */
|
|
}
|
|
+ }
|
|
}
|
|
} finally {
|
|
- securityAttributes = null;
|
|
+ if (!reply.delete()) {
|
|
+ reply.deleteOnExit();
|
|
+ }
|
|
}
|
|
} finally {
|
|
- securityDescriptor = null;
|
|
+ serverSocket.close();
|
|
}
|
|
+ } finally {
|
|
+ attachLockLock.release();
|
|
}
|
|
+ } finally {
|
|
+ attachLock.close();
|
|
+ }
|
|
+ }
|
|
|
|
- /**
|
|
- * A library for interacting with Windows.
|
|
- */
|
|
- protected interface WindowsLibrary extends StdCallLibrary {
|
|
+ /**
|
|
+ * {@inheritDoc}
|
|
+ */
|
|
+ public Properties getSystemProperties() throws IOException {
|
|
+ write(socket, "ATTACH_GETSYSTEMPROPERTIES".getBytes("UTF-8"));
|
|
+ Properties properties = new Properties();
|
|
+ properties.load(new ByteArrayInputStream(read(socket)));
|
|
+ return properties;
|
|
+ }
|
|
|
|
- /**
|
|
- * Indicates that a semaphore requires all access rights.
|
|
- */
|
|
- int SEMAPHORE_ALL_ACCESS = 0x1F0003;
|
|
+ /**
|
|
+ * {@inheritDoc}
|
|
+ */
|
|
+ public Properties getAgentProperties() throws IOException {
|
|
+ write(socket, "ATTACH_GETAGENTPROPERTIES".getBytes("UTF-8"));
|
|
+ Properties properties = new Properties();
|
|
+ properties.load(new ByteArrayInputStream(read(socket)));
|
|
+ return properties;
|
|
+ }
|
|
|
|
- /**
|
|
- * Opens an existing semaphore.
|
|
- *
|
|
- * @param access The access rights.
|
|
- * @param inheritHandle {@code true} if the handle is inherited.
|
|
- * @param name The semaphore's name.
|
|
- * @return The handle or {@code null} if the handle could not be created.
|
|
- */
|
|
- @SuppressWarnings("checkstyle:methodname")
|
|
- WinNT.HANDLE OpenSemaphoreW(int access, boolean inheritHandle, String name);
|
|
+ /**
|
|
+ * {@inheritDoc}
|
|
+ */
|
|
+ public void loadAgent(String jarFile, String argument) throws IOException {
|
|
+ write(socket, ("ATTACH_LOADAGENT(instrument," + jarFile + '=' + (argument == null ? "" : argument) + ')').getBytes("UTF-8"));
|
|
+ String answer = new String(read(socket), "UTF-8");
|
|
+ if (answer.startsWith("ATTACH_ERR")) {
|
|
+ throw new IllegalStateException("Target VM failed loading agent: " + answer);
|
|
+ } else if (!answer.startsWith("ATTACH_ACK") && !answer.startsWith("ATTACH_RESULT=")) {
|
|
+ throw new IllegalStateException("Unexpected response: " + answer);
|
|
+ }
|
|
+ }
|
|
|
|
- /**
|
|
- * Creates a new semaphore.
|
|
- *
|
|
- * @param securityAttributes The security attributes for the created semaphore.
|
|
- * @param count The initial count for the semaphore.
|
|
- * @param maximumCount The maximum count for the semaphore.
|
|
- * @param name The semaphore's name.
|
|
- * @return The handle or {@code null} if the handle could not be created.
|
|
- */
|
|
- @SuppressWarnings("checkstyle:methodname")
|
|
- WinNT.HANDLE CreateSemaphoreW(WinBase.SECURITY_ATTRIBUTES securityAttributes, long count, long maximumCount, String name);
|
|
+ /**
|
|
+ * {@inheritDoc}
|
|
+ */
|
|
+ public void loadAgentPath(String path, String argument) throws IOException {
|
|
+ write(socket, ("ATTACH_LOADAGENTPATH(" + path + (argument == null ? "" : (',' + argument)) + ')').getBytes("UTF-8"));
|
|
+ String answer = new String(read(socket), "UTF-8");
|
|
+ if (answer.startsWith("ATTACH_ERR")) {
|
|
+ throw new IllegalStateException("Target VM failed loading native agent: " + answer);
|
|
+ } else if (!answer.startsWith("ATTACH_ACK") && !answer.startsWith("ATTACH_RESULT=")) {
|
|
+ throw new IllegalStateException("Unexpected response: " + answer);
|
|
+ }
|
|
+ }
|
|
|
|
- /**
|
|
- * Releases the semaphore.
|
|
- *
|
|
- * @param handle The semaphore's handle.
|
|
- * @param count The amount with which to increase the semaphore.
|
|
- * @param previousCount The previous count of the semaphore or {@code null}.
|
|
- * @return {@code true} if the semaphore was successfully released.
|
|
- */
|
|
- @SuppressWarnings("checkstyle:methodname")
|
|
- boolean ReleaseSemaphore(WinNT.HANDLE handle, long count, Long previousCount);
|
|
+ /**
|
|
+ * {@inheritDoc}
|
|
+ */
|
|
+ public void loadAgentLibrary(String library, String argument) throws IOException {
|
|
+ write(socket, ("ATTACH_LOADAGENTLIBRARY(" + library + (argument == null ? "" : (',' + argument)) + ')').getBytes("UTF-8"));
|
|
+ String answer = new String(read(socket), "UTF-8");
|
|
+ if (answer.startsWith("ATTACH_ERR")) {
|
|
+ throw new IllegalStateException("Target VM failed loading native library: " + answer);
|
|
+ } else if (!answer.startsWith("ATTACH_ACK") && !answer.startsWith("ATTACH_RESULT=")) {
|
|
+ throw new IllegalStateException("Unexpected response: " + answer);
|
|
+ }
|
|
+ }
|
|
|
|
- /**
|
|
- * Create or opens a mutex.
|
|
- *
|
|
- * @param attributes The mutex's security attributes.
|
|
- * @param owner {@code true} if the caller is supposed to be the initial owner.
|
|
- * @param name The mutex name.
|
|
- * @return The handle to the mutex or {@code null} if the mutex could not be created.
|
|
- */
|
|
- @SuppressWarnings("checkstyle:methodname")
|
|
- WinNT.HANDLE CreateMutex(SecurityAttributes attributes, boolean owner, String name);
|
|
+ /**
|
|
+ * {@inheritDoc}
|
|
+ */
|
|
+ public void startManagementAgent(Properties properties) throws IOException {
|
|
+ ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
|
|
+ properties.store(outputStream, null);
|
|
+ write(socket, "ATTACH_START_MANAGEMENT_AGENT".getBytes("UTF-8"));
|
|
+ write(socket, outputStream.toByteArray());
|
|
+ String answer = new String(read(socket), "UTF-8");
|
|
+ if (answer.startsWith("ATTACH_ERR")) {
|
|
+ throw new IllegalStateException("Target VM could not start management agent: " + answer);
|
|
+ } else if (!answer.startsWith("ATTACH_ACK") && !answer.startsWith("ATTACH_RESULT=")) {
|
|
+ throw new IllegalStateException("Unexpected response: " + answer);
|
|
+ }
|
|
+ }
|
|
|
|
- /**
|
|
- * Opens an existing object.
|
|
- *
|
|
- * @param access The required access privileges.
|
|
- * @param inherit {@code true} if the mutex should be inherited.
|
|
- * @param name The mutex's name.
|
|
- * @return The handle or {@code null} if the mutex could not be opened.
|
|
- */
|
|
- @SuppressWarnings("checkstyle:methodname")
|
|
- WinNT.HANDLE OpenMutex(int access, boolean inherit, String name);
|
|
+ /**
|
|
+ * {@inheritDoc}
|
|
+ */
|
|
+ public String startLocalManagementAgent() throws IOException {
|
|
+ write(socket, "ATTACH_START_LOCAL_MANAGEMENT_AGENT".getBytes("UTF-8"));
|
|
+ String answer = new String(read(socket), "UTF-8");
|
|
+ if (answer.startsWith("ATTACH_ERR")) {
|
|
+ throw new IllegalStateException("Target VM could not start management agent: " + answer);
|
|
+ } else if (answer.startsWith("ATTACH_ACK")) {
|
|
+ return answer.substring("ATTACH_ACK".length());
|
|
+ } else if (answer.startsWith("ATTACH_RESULT=")) {
|
|
+ return answer.substring("ATTACH_RESULT=".length());
|
|
+ } else {
|
|
+ throw new IllegalStateException("Unexpected response: " + answer);
|
|
+ }
|
|
+ }
|
|
|
|
- /**
|
|
- * Releases the supplied mutex.
|
|
- *
|
|
- * @param handle The handle to the mutex.
|
|
- * @return {@code true} if the handle was successfully released.
|
|
- */
|
|
- @SuppressWarnings("checkstyle:methodname")
|
|
- boolean ReleaseMutex(WinNT.HANDLE handle);
|
|
+ /**
|
|
+ * {@inheritDoc}
|
|
+ */
|
|
+ public void detach() throws IOException {
|
|
+ try {
|
|
+ write(socket, "ATTACH_DETACH".getBytes("UTF-8"));
|
|
+ read(socket); // The answer is intentionally ignored.
|
|
+ } finally {
|
|
+ socket.close();
|
|
+ }
|
|
+ }
|
|
|
|
- /**
|
|
- * A structure representing a mutex's security attributes.
|
|
- */
|
|
- @SuppressFBWarnings(value = {"URF_UNREAD_PUBLIC_OR_PROTECTED_FIELD", "UUF_UNUSED_PUBLIC_OR_PROTECTED_FIELD"}, justification = "Field required by native implementation.")
|
|
- class SecurityAttributes extends Structure {
|
|
-
|
|
- /**
|
|
- * The descriptor's length.
|
|
- */
|
|
- public WinDef.DWORD length;
|
|
-
|
|
- /**
|
|
- * A pointer to the descriptor.
|
|
- */
|
|
- public Pointer securityDescriptor;
|
|
-
|
|
- /**
|
|
- * {@code true} if the attributes are inherited.
|
|
- */
|
|
- @SuppressWarnings("unused")
|
|
- public boolean inherit;
|
|
-
|
|
- @Override
|
|
- protected List<String> getFieldOrder() {
|
|
- return Arrays.asList("length", "securityDescriptor", "inherit");
|
|
- }
|
|
- }
|
|
+ /**
|
|
+ * Writes the supplied value to the target socket.
|
|
+ *
|
|
+ * @param socket The socket to write to.
|
|
+ * @param value The value being written.
|
|
+ * @throws IOException If an I/O exception occurs.
|
|
+ */
|
|
+ private static void write(Socket socket, byte[] value) throws IOException {
|
|
+ socket.getOutputStream().write(value);
|
|
+ socket.getOutputStream().write(0);
|
|
+ socket.getOutputStream().flush();
|
|
+ }
|
|
+
|
|
+ /**
|
|
+ * Reads a {@code '\0'}-terminated value from the target socket.
|
|
+ *
|
|
+ * @param socket The socket to read from.
|
|
+ * @return The value that was read.
|
|
+ * @throws IOException If an I/O exception occurs.
|
|
+ */
|
|
+ private static byte[] read(Socket socket) throws IOException {
|
|
+ ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
|
|
+ byte[] buffer = new byte[1024];
|
|
+ int length;
|
|
+ while ((length = socket.getInputStream().read(buffer)) != -1) {
|
|
+ if (length > 0 && buffer[length - 1] == 0) {
|
|
+ outputStream.write(buffer, 0, length - 1);
|
|
+ break;
|
|
+ } else {
|
|
+ outputStream.write(buffer, 0, length);
|
|
}
|
|
+ }
|
|
+ return outputStream.toByteArray();
|
|
+ }
|
|
|
|
- /**
|
|
- * A handle for an attachment which is represented by a pair of handles.
|
|
- */
|
|
- protected static class AttachmentHandle implements Closeable {
|
|
+ /**
|
|
+ * A dispatcher for native operations being used for communication with an OpenJ9 virtual machine.
|
|
+ */
|
|
+ public interface Dispatcher {
|
|
|
|
- /**
|
|
- * The parent handle.
|
|
- */
|
|
- private final WinNT.HANDLE parent;
|
|
+ /**
|
|
+ * Returns this machine's temporary folder.
|
|
+ *
|
|
+ * @return The temporary folder.
|
|
+ */
|
|
+ String getTemporaryFolder();
|
|
|
|
- /**
|
|
- * The child handle.
|
|
- */
|
|
- private final WinNT.HANDLE child;
|
|
+ /**
|
|
+ * Returns the process id of this process.
|
|
+ *
|
|
+ * @return The process id of this process.
|
|
+ */
|
|
+ int pid();
|
|
|
|
- /**
|
|
- * Creates a new attachment handle.
|
|
- *
|
|
- * @param parent The parent handle.
|
|
- * @param child The child handle.
|
|
- */
|
|
- protected AttachmentHandle(WinNT.HANDLE parent, WinNT.HANDLE child) {
|
|
- this.parent = parent;
|
|
- this.child = child;
|
|
- }
|
|
+ /**
|
|
+ * Returns the user id of this process.
|
|
+ *
|
|
+ * @return The user id of this process
|
|
+ */
|
|
+ int userId();
|
|
|
|
- /**
|
|
- * Returns the handle on which signals are to be sent.
|
|
- *
|
|
- * @return The handle on which signals are to be sent.
|
|
- */
|
|
- protected WinNT.HANDLE getHandle() {
|
|
- return child;
|
|
- }
|
|
+ /**
|
|
+ * Returns {@code true} if the supplied process id is a running process.
|
|
+ *
|
|
+ * @param processId The process id to evaluate.
|
|
+ * @return {@code true} if the supplied process id is currently running.
|
|
+ */
|
|
+ boolean isExistingProcess(int processId);
|
|
|
|
- /**
|
|
- * {@inheritDoc}
|
|
- */
|
|
- public void close() {
|
|
- boolean closed;
|
|
- try {
|
|
- if (!Kernel32.INSTANCE.CloseHandle(child)) {
|
|
- throw new Win32Exception(Kernel32.INSTANCE.GetLastError());
|
|
- }
|
|
- } finally {
|
|
- closed = Kernel32.INSTANCE.CloseHandle(parent);
|
|
- }
|
|
- if (!closed) {
|
|
- throw new Win32Exception(Kernel32.INSTANCE.GetLastError());
|
|
- }
|
|
- }
|
|
- }
|
|
- }
|
|
+ /**
|
|
+ * Returns the user id of the owner of the supplied file.
|
|
+ *
|
|
+ * @param file The file for which to locate the owner.
|
|
+ * @return The owner id of the supplied file.
|
|
+ */
|
|
+ int getOwnerIdOf(File file);
|
|
+
|
|
+ /**
|
|
+ * Sets permissions for the supplied file.
|
|
+ *
|
|
+ * @param file The file for which to set the permissions.
|
|
+ * @param permissions The permission bits to set.
|
|
+ */
|
|
+ void setPermissions(File file, int permissions);
|
|
+
|
|
+ /**
|
|
+ * Increments a semaphore.
|
|
+ *
|
|
+ * @param directory The sempahore's control directory.
|
|
+ * @param name The semaphore's name.
|
|
+ * @param global {@code true} if the semaphore is in the global namespace (only applicable on Windows).
|
|
+ * @param count The amount of increments.
|
|
+ */
|
|
+ void incrementSemaphore(File directory, String name, boolean global, int count);
|
|
+
|
|
+ /**
|
|
+ * Decrements a semaphore.
|
|
+ *
|
|
+ * @param directory The sempahore's control directory.
|
|
+ * @param name The semaphore's name.
|
|
+ * @param global {@code true} if the semaphore is in the global namespace (only applicable on Windows).
|
|
+ * @param count The amount of decrements.
|
|
+ */
|
|
+ void decrementSemaphore(File directory, String name, boolean global, int count);
|
|
}
|
|
}
|
|
}
|
|
--
|
|
2.26.2
|
|
|