0 Предисловие
В предыдущей статье мы описали"Реализация агента на основе JVMTI"и«Реализация агента на основе инструмента Java»Существует два способа реализации Агента, каждый из которых будет разделен на:Агент при запуске, Агент во время выполнения.
заМеханизм срабатывания агента при запуске, в предыдущем разделе"Принцип работы агента JVMTI и анализ исходного кода ядра", был проанализирован на исходном уровне следующим образом:
Но дляМеханизм срабатывания агента во время выполнения, но подробно не объяснял, основная цель этого раздела — проанализировать механизм работы JVMTI Attach на уровне исходного кода.
1 Что такое прикрепить
Механизм Attach — это способность JVM обеспечивать своего рода связь между процессами JVM, которая позволяет одному процессу передавать команды другому процессу и позволять ему выполнять некоторые внутренние операции..
Например: чтобы позволить другому процессу JVM сбрасывать поток, сначала запустите процесс jstack, а затем передайте параметр pid, чтобы сообщить ему, какой процесс должен сбрасывать поток.Поскольку есть два процесса, он должен включать процесс Inter-communication , а также определение протокола передачи, например: какую операцию выполнять, какие параметры передавать и т.д.
Иногда, когда мы чувствуем, что нить где-то застряла, и хотим знать, где она, первая мысль — продолжить.Дамп потока, и часто используемая команда - jstack, мы можем увидеть следующий стек потоков:
2014-06-18 12:56:14 Full thread dump Java HotSpot(TM) 64-Bit Server VM (24.51-b03 mixed mode):
"Attach Listener" daemon prio=5 tid=0x00007fb0c6800800 nid=0x440b waiting on condition [0x0000000000000000]
java.lang.Thread.State: RUNNABLE
"Service Thread" daemon prio=5 tid=0x00007fb0c584d800 nid=0x5303 runnable [0x0000000000000000]
java.lang.Thread.State: RUNNABLE
"C2 CompilerThread1" daemon prio=5 tid=0x00007fb0c482e000 nid=0x5103 waiting on condition [0x0000000000000000]
java.lang.Thread.State: RUNNABLE
"C2 CompilerThread0" daemon prio=5 tid=0x00007fb0c482c800 nid=0x4f03 waiting on condition [0x0000000000000000]
java.lang.Thread.State: RUNNABLE
"Signal Dispatcher" daemon prio=5 tid=0x00007fb0c4815800 nid=0x4d03 runnable [0x0000000000000000]
java.lang.Thread.State: RUNNABLE
"Finalizer" daemon prio=5 tid=0x00007fb0c4813800 nid=0x3903 in Object.wait() [0x00000001187d2000]
java.lang.Thread.State: WAITING (on object monitor)
at java.lang.Object.wait(Native Method)
- waiting on <0x00000007aaa85568> (a java.lang.ref.ReferenceQueue$Lock)
at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:135)
- locked <0x00000007aaa85568> (a java.lang.ref.ReferenceQueue$Lock)
at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:151)
at java.lang.ref.Finalizer$FinalizerThread.run(Finalizer.java:189)
"Reference Handler" daemon prio=5 tid=0x00007fb0c4800000 nid=0x3703 in Object.wait() [0x00000001186cf000]
java.lang.Thread.State: WAITING (on object monitor)
at java.lang.Object.wait(Native Method)
- waiting on <0x00000007aaa850f0> (a java.lang.ref.Reference$Lock)
at java.lang.Object.wait(Object.java:503)
at java.lang.ref.Reference$ReferenceHandler.run(Reference.java:133)
- locked <0x00000007aaa850f0> (a java.lang.ref.Reference$Lock)
"main" prio=5 tid=0x00007fb0c5800800 nid=0x1903 waiting on condition [0x0000000107962000]
java.lang.Thread.State: TIMED_WAITING (sleeping)
at java.lang.Thread.sleep(Native Method)
at Test.main(Test.java:5)
"VM Thread" prio=5 tid=0x00007fb0c583d800 nid=0x3503 runnable
"GC task thread#0 (ParallelGC)" prio=5 tid=0x00007fb0c401e000 nid=0x2503 runnable
"GC task thread#1 (ParallelGC)" prio=5 tid=0x00007fb0c401e800 nid=0x2703 runnable
"GC task thread#2 (ParallelGC)" prio=5 tid=0x00007fb0c401f800 nid=0x2903 runnable
"GC task thread#3 (ParallelGC)" prio=5 tid=0x00007fb0c4020000 nid=0x2b03 runnable
"GC task thread#4 (ParallelGC)" prio=5 tid=0x00007fb0c4020800 nid=0x2d03 runnable
"GC task thread#5 (ParallelGC)" prio=5 tid=0x00007fb0c4021000 nid=0x2f03 runnable
"GC task thread#6 (ParallelGC)" prio=5 tid=0x00007fb0c4022000 nid=0x3103 runnable
"GC task thread#7 (ParallelGC)" prio=5 tid=0x00007fb0c4022800 nid=0x3303 runnable
"VM Periodic Task Thread" prio=5 tid=0x00007fb0c5845000 nid=0x5503 waiting on condition
В приведенном выше журнале дампа потоков отображаются два потока:«Прикрепить прослушиватель» и «Диспетчер сигналов», эти два потока являются ключом к механизму Attach.
Так как же JVM запускает эти два потока?JVM имеет много потоков, в основном реализованных в теле метода create_vm в thread.cpp.:
JvmtiExport::enter_live_phase();
// 1. Signal Dispatcher 需要在发布VMInit事件之前启动
os::signal_init();
// 2. Start Attach Listener 如果配置 +StartAttachListener; 否则会延迟启动
if (!DisableAttachMechanism) {
if (StartAttachListener || AttachListener::init_at_startup()) {
AttachListener::init();
}
}
Параметры, связанные с JVM: DisableAttachMechanism, StartAttachListener, ReduceSignalUsage по умолчанию имеют значение false.:
product(bool, DisableAttachMechanism, false, "Disable mechanism that allows tools to Attach to this VM”);
product(bool, StartAttachListener, false, "Always start Attach Listener at VM startup");
product(bool, ReduceSignalUsage, false, "Reduce the use of OS signals in Java and/or the VM”);
Как показано в исходном коде create_vm выше, поток AttachListener может не создаваться при запуске, тогдаКак поток AttachListener создается в журнале стека потоков выше? Это требует внимания к другому потоку «Диспетчер сигналов»., как следует из названия, он обрабатывает сигналы, и этот поток обязательно создается при запуске JVM.
1.1 Ветка диспетчера сигналов
в os.cppsignal_init()В функции запускается поток диспетчера сигналов,Поток диспетчера сигналов в основном используется для обработки сигналов, ожидания сигналов и распределения обработки., можно посмотреть подробнееsignal_thread_entryМетоды:
// 该方法用于Signal Dispatcher线程处理接受到的信号
static void signal_thread_entry(JavaThread* thread, TRAPS) {
os::set_priority(thread, NearMaxPriority);
while (true) {
int sig;
{
// FIXME : Currently we have not decieded what should be the status
// for this java thread blocked here. Once we decide about
// that we should fix this. 等待信号
sig = os::signal_wait();
}
if (sig == os::sigexitnum_pd()) {
// Terminate the signal thread
return;
}
switch (sig) {
case SIGBREAK: {
// Check if the signal is a trigger to start the Attach Listener - in that
// case don't print stack traces.
if (!DisableAttachMechanism && AttachListener::is_init_trigger()) {
continue;
}
// Print stack traces
// Any SIGBREAK operations added here should make sure to flush
// the output stream (e.g. tty->flush()) after output. See 4803766.
// Each module also prints an extra carriage return after its output.
VM_PrintThreads op;
VMThread::execute(&op);
VM_PrintJNI jni_op;
VMThread::execute(&jni_op);
VM_FindDeadlocks op1(tty);
VMThread::execute(&op1);
Universe::print_heap_at_SIGBREAK();
if (PrintClassHistogram) {
VM_GC_HeapInspection op1(gclog_or_tty, true /* force full GC before heap inspection */,
true /* need_prologue */);
VMThread::execute(&op1);
}
if (JvmtiExport::should_post_data_dump()) {
JvmtiExport::post_data_dump();
}
break;
}
default: {
// Dispatch the signal to java
HandleMark hm(THREAD);
klassOop k = SystemDictionary::resolve_or_null(vmSymbolHandles::sun_misc_Signal(), THREAD);
KlassHandle klass (THREAD, k);
if (klass.not_null()) {
JavaValue result(T_VOID);
JavaCallArguments args;
args.push_int(sig);
JavaCalls::call_static(
&result,
klass,
vmSymbolHandles::dispatch_name(),
vmSymbolHandles::int_void_signature(),
&args,
THREAD
);
}
if (HAS_PENDING_EXCEPTION) {
// tty is initialized early so we don't expect it to be null, but
// if it is we can't risk doing an initialization that might
// trigger additional out-of-memory conditions
if (tty != NULL) {
char klass_name[256];
char tmp_sig_name[16];
const char* sig_name = "UNKNOWN";
instanceKlass::cast(PENDING_EXCEPTION->klass())->
name()->as_klass_external_name(klass_name, 256);
if (os::exception_name(sig, tmp_sig_name, 16) != NULL)
sig_name = tmp_sig_name;
warning("Exception %s occurred dispatching signal %s to handler"
"- the VM may need to be forcibly terminated",
klass_name, sig_name );
}
CLEAR_PENDING_EXCEPTION;
}
}
}
}
}
можно увидеть сквозьos::signal_wait();дождитесь сигнала, что в Linux делаетсяsem_wait()реализовать,Когда получен сигнал SIGBREAK (#define в JVM на самом деле SIGQUIT), он инициирует выполнение AttachListener::is_init_trigger() для инициализации потока прослушивателя подключения..
- При первом получении сигнала он начнет инициализироваться, когда инициализация прошла успешно, он вернется напрямую, иНе возвращает никакой информации о стеке потока (возвращается операцией файла сокета) и не требует инициализации во второй раз.. Если инициализация не удалась, информация о стеке потоков будет напечатана непосредственно в потоке вывода консоли;
- сигнал второго времени, если он был инициализирован, информация о стеке потока будет напечатана непосредственно в консоли. Если он не инициализирован, продолжайте инициализацию и следуйте тому же процессу, что и в первый раз;
Например: мы частоИспользуйте операцию kill -3 pid для вывода информации о стеке потока., вы можете видеть, что конкретная реализация выполняется в потоке Signal Dispatcher,Поскольку kill -3 pid не создает файл .attach_pid#pid, поэтому инициализация не удалась, поэтому информация о стеке потока выводится на консоль.
1.2 Прикрепить ветку слушателя
Поток Attach Listener отвечает за получение внешних команд, выполнение команд и возврат результатов отправителю.. При запуске JVM, если не указано+StartAttachListener, поток прослушивателя присоединения не будет запущен.
в полученииquitПосле сигнала он будет вызванAttachListener::is_init_trigger()метод,AttachListener::is_init_trigger()будет вызван в течениеAttachListener::init()Запускается поток Attach Listener, реализация инициализации в разных операционных системах отличается, в linux это реализовано в файле attachListener_Linux.cpp.
AttachListener::is_init_trigger()код показывает, как показано ниже:
bool AttachListener::is_init_trigger() {
if (init_at_startup() || is_initialized()) {
return false; // initialized at startup or already initialized
}
char fn[PATH_MAX+1];
sprintf(fn, ".Attach_pid%d", os::current_process_id());
int ret;
struct stat64 st;
RESTARTABLE(::stat64(fn, &st), ret);
if (ret == -1) {
snprintf(fn, sizeof(fn), "%s/.Attach_pid%d",
os::get_temp_directory(), os::current_process_id());
RESTARTABLE(::stat64(fn, &st), ret);
}
if (ret == 0) {
// simple check to avoid starting the Attach mechanism when
// a bogus user creates the file
if (st.st_uid == geteuid()) {
// 创建AttachListener线程
init();
return true;
}
}
return false;
}
во-первыхОпределите, есть ли файл .Attach_pid в текущем каталоге процесса., если нет, он создаст его в /tmp/tmp/.Attach_pid,Когда uid файла совпадает с его собственным (в целях безопасности), снова вызовите метод init.
// Starts the Attach Listener thread
void AttachListener::init() {
EXCEPTION_MARK;
klassOop k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_Thread(), true, CHECK);
instanceKlassHandle klass (THREAD, k);
instanceHandle thread_oop = klass->allocate_instance_handle(CHECK);
const char thread_name[] = "Attach Listener";
Handle string = java_lang_String::create_from_str(thread_name, CHECK);
// Initialize thread_oop to put it into the system threadGroup
Handle thread_group (THREAD, Universe::system_thread_group());
JavaValue result(T_VOID);
JavaCalls::call_special(&result, thread_oop,
klass,
vmSymbols::object_initializer_name(),
vmSymbols::threadgroup_string_void_signature(),
thread_group,
string,
CHECK);
KlassHandle group(THREAD, SystemDictionary::ThreadGroup_klass());
JavaCalls::call_special(&result,
thread_group,
group,
vmSymbols::add_method_name(),
vmSymbols::thread_void_signature(),
thread_oop, // ARG 1
CHECK);
{ MutexLocker mu(Threads_lock);
JavaThread* listener_thread = new JavaThread(&Attach_listener_thread_entry);
// Check that thread and osthread were created
if (listener_thread == NULL || listener_thread->osthread() == NULL) {
vm_exit_during_initialization("java.lang.OutOfMemoryError",
"unable to create new native thread");
}
java_lang_Thread::set_thread(thread_oop(), listener_thread);
java_lang_Thread::set_daemon(thread_oop());
listener_thread->set_threadObj(thread_oop());
Threads::add(listener_thread);
Thread::start(listener_thread);
}
}
В этот момент появилась нижняя строка, и я увидел, что поток был создан и назван Attach Listener.Давайте взглянем на метод init его подкласса LinuxAttachListener в системе Linux.:
int LinuxAttachListener::init() {
char path[UNIX_PATH_MAX]; // socket file
char initial_path[UNIX_PATH_MAX]; // socket file during setup
int listener; // listener socket (file descriptor)
// register function to cleanup
::atexit(listener_cleanup);
int n = snprintf(path, UNIX_PATH_MAX, "%s/.java_pid%d",
os::get_temp_directory(), os::current_process_id());
if (n < (int)UNIX_PATH_MAX) {
n = snprintf(initial_path, UNIX_PATH_MAX, "%s.tmp", path);
}
if (n >= (int)UNIX_PATH_MAX) {
return -1;
}
// create the listener socket
listener = ::socket(PF_UNIX, SOCK_STREAM, 0);
if (listener == -1) {
return -1;
}
// bind socket
struct sockaddr_un addr;
addr.sun_family = AF_UNIX;
strcpy(addr.sun_path, initial_path);
::unlink(initial_path);
int res = ::bind(listener, (struct sockaddr*)&addr, sizeof(addr));
if (res == -1) {
RESTARTABLE(::close(listener), res);
return -1;
}
// put in listen mode, set permissions, and rename into place
res = ::listen(listener, 5);
if (res == 0) {
RESTARTABLE(::chmod(initial_path, S_IREAD|S_IWRITE), res);
if (res == 0) {
res = ::rename(initial_path, path);
}
}
if (res == -1) {
RESTARTABLE(::close(listener), res);
::unlink(initial_path);
return -1;
}
set_path(path);
set_listener(listener);
return 0;
}
Обратите внимание, что он создал прослушивающий сокет и создал файл /tmp/.java_pid, который является файлом, который клиент опрашивал и ждал перед этим., С генерацией этого файла это означает, что процесс создания аттача завершился успешно.
Когда поток прослушивателя присоединения получает запрос,Конкретная обработка запроса реализована в теле метода attach_listener_thread_entry.:
static void attach_listener_thread_entry(JavaThread* thread, TRAPS) {
os::set_priority(thread, NearMaxPriority);
if (AttachListener::pd_init() != 0) {
return;
}
AttachListener::set_initialized();
for (;;) {
AttachOperation* op = AttachListener::dequeue();
if (op == NULL) {
return; // dequeue failed or shutdown
}
ResourceMark rm;
bufferedStream st;
jint res = JNI_OK;
// handle special detachall operation
if (strcmp(op->name(), AttachOperation::detachall_operation_name()) == 0) {
AttachListener::detachall();
} else {
// find the function to dispatch too
AttachOperationFunctionInfo* info = NULL;
for (int i=0; funcs[i].name != NULL; i++) {
const char* name = funcs[i].name;
assert(strlen(name) <= AttachOperation::name_length_max, "operation <= name_length_max");
if (strcmp(op->name(), name) == 0) {
info = &(funcs[i]);
break;
}
}
// check for platform dependent attach operation
if (info == NULL) {
info = AttachListener::pd_find_operation(op->name());
}
if (info != NULL) {
// dispatch to the function that implements this operation
res = (info->func)(op, &st);
} else {
st.print("Operation %s not recognized!", op->name());
res = JNI_ERR;
}
}
// operation complete - send result and output to client
op->complete(res, &st);
}
}
Из кода этоПродолжайте брать AttachOperation из очереди, а затем найдите метод, соответствующий команде запроса для выполнения., такие как команда jstack, упомянутая в начале, найдите отношение сопоставления { "threaddump", thread_dump}, а затем выполните метод thread_dump.
Существует много типов AttachOperation, таких как: дамп памяти, дамп потока, статистика информации о классе (например, загруженные классы и размеры, количество экземпляров и т. д.), динамическая загрузка агентов и динамическая установка флагов vm (но не всех флагов). можно установить, т.к. некоторые флаги используются в процессе запуска jvm и являются одноразовыми), вывести флаг vm, получить системные свойства и т.д., эти соответствующие исходники (AttachListener.cpp)следующим образом:
static AttachOperationFunctionInfo funcs[] = {
// 第二个参数是命令对应的处理函数
{ "agentProperties", get_agent_properties },
{ "datadump", data_dump },
{ "dumpheap", dump_heap },
{ "load", JvmtiExport::load_agent_library },
{ "properties", get_system_properties },
{ "threaddump", thread_dump },
{ "inspectheap", heap_inspection },
{ "setflag", set_flag },
{ "printflag", print_flag },
{ "jcmd", jcmd },
{ NULL, NULL }
};
Посмотрим, что он хочет назватьAttachListener::dequeue();:
AttachOperation* AttachListener::dequeue() {
JavaThread* thread = JavaThread::current();
ThreadBlockInVM tbivm(thread);
thread->set_suspend_equivalent();
// cleared by handle_special_suspend_equivalent_condition() or
// java_suspend_self() via check_and_wait_while_suspended()
AttachOperation* op = LinuxAttachListener::dequeue();
// were we externally suspended while we were waiting?
thread->check_and_wait_while_suspended();
return op;
}
в конце концов позвонитLinuxAttachListener::dequeue():
LinuxAttachOperation* LinuxAttachListener::dequeue() {
for (;;) {
int s;
// wait for client to connect
struct sockaddr addr;
socklen_t len = sizeof(addr);
// 如果没有请求的话，会一直accept在那里
RESTARTABLE(::accept(listener(), &addr, &len), s);
if (s == -1) {
return NULL; // log a warning?
}
// get the credentials of the peer and check the effective uid/guid
// - check with jeff on this.
struct ucred cred_info;
socklen_t optlen = sizeof(cred_info);
if (::getsockopt(s, SOL_SOCKET, SO_PEERCRED, (void*)&cred_info, &optlen) == -1) {
int res;
RESTARTABLE(::close(s), res);
continue;
}
uid_t euid = geteuid();
gid_t egid = getegid();
if (cred_info.uid != euid || cred_info.gid != egid) {
int res;
RESTARTABLE(::close(s), res);
continue;
}
// peer credential look okay so we read the request
LinuxAttachOperation* op = read_request(s);
if (op == NULL) {
int res;
RESTARTABLE(::close(s), res);
continue;
} else {
return op;
}
}
}
Как вы можете видеть в приведенном выше коде,Если запроса нет, он всегда примет там, когда придет запрос, он создаст сокет, прочитает данные, сконструирует return LinuxAttachOperation, найдет операцию, соответствующую запросу, вызовет операцию для получения результата и напишет результат в файл для этого сокета, если вы удалите файл сокета, jstack/jmap будет иметь сообщение об ошибке, невозможное открыть файл сокета:........
1.3 Блок-схема команд jstack/jmap
Реализация jstack используется для иллюстрации процесса запуска механизма Attach.Реализация команды jstack на самом деле представляет собой класс с именем JStack.java., команда jstack сначала подключится к целевому процессу JVM и сгенерирует класс VirtualMachine; в системе Linux ее классом реализации является LinuxVirtualMachine, вызовет метод remoteDataDump и распечатает информацию о стеке;JStack.javaПосле кода он перейдет к следующему методу:
private static void runThreadDump(String pid, String args[]) throws Exception {
VirtualMachine vm = null;
try {
// jstack命令首先会attach到目标JVM进程
vm = VirtualMachine.Attach(pid);
} catch (Exception x) {
String msg = x.getMessage();
if (msg != null) {
System.err.println(pid + ": " + msg);
} else {
x.printStackTrace();
}
if ((x instanceof AttachNotSupportedException) &&
(loadSAClass() != null)) {
System.err.println("The -F option can be used when the target " +
"process is not responding");
}
System.exit(1);
}
// Cast to HotSpotVirtualMachine as this is implementation specific
// method.
// 输出堆栈信息
InputStream in = ((HotSpotVirtualMachine)vm).remoteDataDump((Object[])args);
// read to EOF and just print output
byte b[] = new byte[256];
int n;
do {
n = in.read(b);
if (n > 0) {
String s = new String(b, 0, n, "UTF-8");
System.out.print(s);
}
} while (n > 0);
in.close();
vm.detach();
}
Так как же VirtualMachine подключается к целевому процессу JVM? Пожалуйста, обрати вниманиеVirtualMachine.Attach(pid);Эта строка кода является ключом к запуску подключения pid.Если это под Linux, конкретная логика реализации находится вsun.tools.attach.LinuxVirtualMachineконструктор:
LinuxVirtualMachine(AttachProvider provider, String vmid) throws AttachNotSupportedException, IOException
{
super(provider, vmid);
// This provider only understands pids
int pid;
try {
pid = Integer.parseInt(vmid);
} catch (NumberFormatException x) {
throw new AttachNotSupportedException("Invalid process identifier");
}
// Find the socket file. If not found then we attempt to start the
// Attach mechanism in the target VM by sending it a QUIT signal.
// Then we attempt to find the socket file again.
path = findSocketFile(pid);
if (path == null) {
File f = createAttachFile(pid);
try {
// On LinuxThreads each thread is a process and we don't have the
// pid of the VMThread which has SIGQUIT unblocked. To workaround
// this we get the pid of the "manager thread" that is created
// by the first call to pthread_create. This is parent of all
// threads (except the initial thread).
if (isLinuxThreads) {
int mpid;
try {
mpid = getLinuxThreadsManager(pid);
} catch (IOException x) {
throw new AttachNotSupportedException(x.getMessage());
}
assert(mpid >= 1);
sendQuitToChildrenOf(mpid);
} else {
sendQuitTo(pid);
}
// give the target VM time to start the Attach mechanism
int i = 0;
long delay = 200;
int retries = (int)(AttachTimeout() / delay);
do {
try {
Thread.sleep(delay);
} catch (InterruptedException x) { }
path = findSocketFile(pid);
i++;
} while (i <= retries && path == null);
if (path == null) {
throw new AttachNotSupportedException(
"Unable to open socket file: target process not responding " +
"or HotSpot VM not loaded");
}
} finally {
f.delete();
}
}
// Check that the file owner/permission to avoid Attaching to
// bogus process
checkPermissions(path);
// Check that we can connect to the process
// - this ensures we throw the permission denied error now rather than
// later when we attempt to enqueue a command.
int s = socket();
try {
connect(s, path);
} finally {
close(s);
}
}
- Узнайте, существует ли каталог /tmp
".java_pid"+pidдокумент;- Если файл не существует, сначала создайте его
"/proc/" + pid + "/cwd/" + ".attach_pid" + pidдокумент;- пройти через
killотправить командуSIGQUITСигнал отправляется целевому процессу JVM.Поскольку все потоки, кроме сигнального потока в JVM, установили экран для этого сигнала, сигнал не может быть получен, поэтому сигнал передается в“Signal Dispatcher”;- После того, как целевой процесс JVM получит сигнал, он
/tmpСоздано в каталоге".java_pid"+pidдокумент;- когда нашли
/tmpсуществует в каталоге".java_pid"+pidдокумент,LinuxVirtualMachineбудет подключаться к файловому дескриптору через системный вызов connect, а затем использоватьfdвести коммуникацию между сторонами;
JVM принимает соответствующую логическую обработку сигнала SIGQUIT,впередиsignal_thread_entryреализован в методе.
ФронтJStack.javaВ исходном коде информация о выходном стеке получается вызовомremoteDataDumpметод реализован,Этот метод заключается в получении информации о стеке целевой JVM путем записи инструкции threaddump в вышеупомянутый fd и чтения возвращенного результата..
2 Код Java реализует агент динамического присоединения
Агент динамического подключения Java и вышеупомянутоеJStack.javaРеализация в основном похожа.В java-коде присоединения используйте метод присоединения VirtualMachine в собственном инструменте sun.jar:
VirtualMachine vm = VirtualMachine.attach(processid);
vm.loadAgent(agentpath, args)
существуетHotSpotVirtualMachine.javaсередина,loadAgentИсходный код метода выглядит следующим образом:
public void loadAgent(String agent, String options) throws AgentLoadException, AgentInitializationException, IOException
{
String args = agent;
if (options != null) {
args = args + "=" + options;
}
try {
loadAgentLibrary("instrument", args);
} .....
}
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();
}
}
существуетLinuxVirtualMachine.javaсерединаexecuteметод:
InputStream execute(String cmd, Object ... args) throws AgentLoadException, IOException {
assert args.length <= 3; // includes null
// did we detach?
String p;
synchronized (this) {
if (this.path == null) {
throw new IOException("Detached from target VM");
}
p = this.path;
}
// create UNIX socket
int s = socket();
// connect to target VM
try {
connect(s, p);
} catch (IOException x) {
close(s);
throw x;
}
IOException ioe = null;
// connected - write request
// <ver> <cmd> <args...>
try {
writeString(s, PROTOCOL_VERSION);
writeString(s, cmd);
for (int i=0; i<3; i++) {
if (i < args.length && args[i] != null) {
writeString(s, (String)args[i]);
} else {
writeString(s, "");
}
}
} catch (IOException x) {
ioe = x;
}
// Create an input stream to read reply
SocketInputStream sis = new SocketInputStream(s);
// Read the command completion status
int completionStatus;
try {
completionStatus = readInt(sis);
} catch (IOException x) {
sis.close();
if (ioe != null) {
throw ioe;
} else {
throw x;
}
}
....
}
То есть писать в сокет, формат такой:
<ver> <cmd> <args...>
Конкретное содержание:
1 load instrument agentPath=path.jar
Поскольку агент загрузки отправляет команду загрузки в сокет, это соответствует работе JVM:
static AttachOperationFunctionInfo funcs[] = {
{ "agentProperties", get_agent_properties },
{ "datadump", data_dump },
#ifndef SERVICES_KERNEL
{ "dumpheap", dump_heap },
#endif // SERVICES_KERNEL
{ "load", JvmtiExport::load_agent_library },
{ "properties", get_system_properties },
{ "threaddump", thread_dump },
{ "inspectheap", heap_inspection },
{ "setflag", set_flag },
{ "printflag", print_flag },
{ NULL, NULL }
};
"load", JvmtiExport::load_agent_library, конкретный исходный код выглядит следующим образом:
jint JvmtiExport::load_agent_library(AttachOperation* op, outputStream* st) {
char ebuf[1024];
char buffer[JVM_MAXPATHLEN];
void* library;
jint result = JNI_ERR;
const char* agent = op->arg(0);
const char* absParam = op->arg(1);
const char* options = op->arg(2);
bool is_absolute_path = (absParam != NULL) && (strcmp(absParam,"true")==0);
if (is_absolute_path) {
library = os::dll_load(agent, ebuf, sizeof ebuf);
} else {
// Try to load the agent from the standard dll directory
os::dll_build_name(buffer, sizeof(buffer), Arguments::get_dll_dir(), agent);
library = os::dll_load(buffer, ebuf, sizeof ebuf);
if (library == NULL) {
// not found - try local path
char ns[1] = {0};
os::dll_build_name(buffer, sizeof(buffer), ns, agent);
library = os::dll_load(buffer, ebuf, sizeof ebuf);
}
}
if (library != NULL) {
// Lookup the Agent_OnAttach function
OnAttachEntry_t on_attach_entry = NULL;
const char *on_attach_symbols[] = AGENT_ONATTACH_SYMBOLS;
for (uint symbol_index = 0; symbol_index < ARRAY_SIZE(on_attach_symbols); symbol_index++) {
on_attach_entry =
CAST_TO_FN_PTR(OnAttachEntry_t, os::dll_lookup(library, on_attach_symbols[symbol_index]));
if (on_attach_entry != NULL) break;
}
if (on_attach_entry == NULL) {
// Agent_OnAttach missing - unload library
os::dll_unload(library);
} else {
// Invoke the Agent_OnAttach function
JavaThread* THREAD = JavaThread::current();
{
extern struct JavaVM_ main_vm;
JvmtiThreadEventMark jem(THREAD);
JvmtiJavaThreadEventTransition jet(THREAD);
result = (*on_attach_entry)(&main_vm, (char*)options, NULL);
}
if (HAS_PENDING_EXCEPTION) {
CLEAR_PENDING_EXCEPTION;
}
if (result == JNI_OK) {
Arguments::add_loaded_agent(agent, (char*)options, is_absolute_path, library);
}
// Agent_OnAttach executed so completion status is JNI_OK
st->print_cr("%d", result);
result = JNI_OK;
}
}
return result;
}
#define AGENT_ONATTACH_SYMBOLS {"Agent_OnAttach"}
3 Запустите агент при подключении инструмента
Загрузите динамическую библиотеку инструмента и вызовите метод в динамической библиотеке инструмента.Agent_OnAttachметод:
JNIEXPORT jint JNICALL Agent_OnAttach(JavaVM* vm, char *args, void * reserved) {
.....
initerror = createNewJPLISAgent(vm, &agent);
if ( initerror == JPLIS_INIT_ERROR_NONE ) {
......
if (parseArgumentTail(args, &jarfile, &options) != 0) {
return JNI_ENOMEM;
}
attributes = readAttributes( jarfile );
if (attributes == NULL) {
fprintf(stderr, "Error opening zip file or JAR manifest missing: %s\n", jarfile);
free(jarfile);
if (options != NULL) free(options);
return AGENT_ERROR_BADJAR;
}
agentClass = getAttribute(attributes, "Agent-Class");
if (agentClass == NULL) {
fprintf(stderr, "Failed to find Agent-Class manifest attribute from %s\n",
jarfile);
free(jarfile);
if (options != NULL) free(options);
freeAttributes(attributes);
return AGENT_ERROR_BADJAR;
}
if (appendClassPath(agent, jarfile)) {
fprintf(stderr, "Unable to add %s to system class path "
"- not supported by system class loader or configuration error!\n",
jarfile);
free(jarfile);
if (options != NULL) free(options);
freeAttributes(attributes);
return AGENT_ERROR_NOTONCP;
}
oldLen = strlen(agentClass);
newLen = modifiedUtf8LengthOfUtf8(agentClass, oldLen);
if (newLen == oldLen) {
agentClass = strdup(agentClass);
} else {
char* str = (char*)malloc( newLen+1 );
if (str != NULL) {
convertUtf8ToModifiedUtf8(agentClass, oldLen, str, newLen);
}
agentClass = str;
}
if (agentClass == NULL) {
free(jarfile);
if (options != NULL) free(options);
freeAttributes(attributes);
return JNI_ENOMEM;
}
bootClassPath = getAttribute(attributes, "Boot-Class-Path");
if (bootClassPath != NULL) {
appendBootClassPath(agent, jarfile, bootClassPath);
}
convertCapabilityAtrributes(attributes, agent);
success = createInstrumentationImpl(jni_env, agent);
jplis_assert(success);
/*
* Turn on the ClassFileLoadHook.
*/
if (success) {
success = setLivePhaseEventHandlers(agent);
jplis_assert(success);
}
if (success) {
success = startJavaAgent(agent,
jni_env,
agentClass,
options,
agent->mAgentmainCaller);
}
if (!success) {
fprintf(stderr, "Agent failed to start!\n");
result = AGENT_ERROR_STARTFAIL;
}
if (options != NULL) free(options);
free(agentClass);
freeAttributes(attributes);
}
return result;
}
В начале приведенного выше кодаcreateNewJPLISAgentиon_loadТо же самое можно сказать и о регистрации некоторых функций ловушек.Подробнее см.:"Принцип работы агента JVMTI и анализ исходного кода ядра".
вышеAgent_OnAttachМы также видели в коде, читаем конфигурацию MANIFEST Agent-Class в загруженном банке:
agentClass = getAttribute(attributes, "Agent-Class");
Создайте и сгенерируйте объекты sun.instrument.InstrumentationImpl:
success = createInstrumentationImpl(jni_env, agent);
Через объект InstrumentationImplloadClassAndCallAgentmainметод для инициализации класса в Agent-Class и вызова класса в классеagentmainМетоды:
success = startJavaAgent(agent, jni_env, agentClass, options, agent->mAgentmainCaller);
То есть определилon_attachВ классе необходимо иметьagentmainреализация метода:
public class MyTransformer {
public static void agentmain(String agentArgs, Instrumentation inst) throws ClassNotFoundException, UnmodifiableClassException, NotFoundException, CannotCompileException, IOException{
....
}
}