Spec-Zone .ru
спецификации, руководства, описания, API
|
|
Spec-Zone .ru
спецификации, руководства, описания, API
|
С введением DTrace на Солярисе 10, поддержка DTrace была добавлена к Java SE 6 HotSpot VM. Горячая точка и hotspot_jni провайдеры делают доступным зонды, которые могут использоваться, чтобы контролировать внутреннее состояние JVM и действия так же как приложение Java, которое работает. Все зонды являются зондами USDT и получаются доступ, используя идентификатор процесса процесса JVM. Тестовые детали перечисляются в следующем разделе, и API обеспечивается в ссылочном разделе.
Провайдер горячей точки делает доступным зонды, которые могут использоваться, чтобы отследить продолжительность жизни VM, поток запускают и останавливают события, GC и статистику пула памяти, компиляции метода, и действие монитора. С флагом запуска включаются дополнительные зонды, который может использоваться, чтобы контролировать рабочую программу Java, такую как метод вводят и возвращают зонды, и объектные выделения. Все зонды горячей точки происходят в библиотеке VM (libjvm.so), таким образом, им также обеспечивают из программ, которые встраивают VM.
У многих из зондов в провайдере есть параметры, которые могут быть исследованы, чтобы обеспечить более подробную информацию о состоянии VM. Многими из параметров этих зондов являются непрозрачные ID, которые могут использоваться, чтобы соединить тестовые взрывы друг с другом, однако строки и другие данные также обеспечиваются. Когда строковые значения обеспечиваются, они всегда присутствуют как пара: указатель на незавершенный изменил данные UTF-8 (см. ), и значение длины, которое указывает на степень тех данных. Поскольку строковые данные (даже когда ни один из символов не вне диапазона ASCII), как гарантируют, не будут завершены символом NUL, необходимо использовать завершенный длиной copyinstr(), внутренний, чтобы считать строковые данные из процесса.
Зонды, которые касаются жизненного цикла VM, обозначаются ниже. В это время ни у одного нет параметров.
| vm-init-begin | Зонд, который стреляет так же, как инициализация VM, начинается |
| vm-init-end | Зонд, который стреляет, когда инициализация VM заканчивается, и VM, готов запустить рабочий код программы |
| vm-shutdown | Зонд, который стреляет как VM, завершает работу из-за завершения программы или ошибки |
Два зонда доступны для отслеживания потока, запускают и останавливают события.
| thread-start | Зонд, который стреляет, когда поток запускается. Обеспечивает упомянутые ниже параметры |
| thread-stop | Зонд, который стреляет, когда поток завершился. Обеспечивает упомянутые ниже параметры |
У каждого из этих зондов есть следующие параметры:
| args[0] | Указатель на UTF-8 представляет в виде строки данные, которые содержат имя потока |
| args[1] | Длина потока называет данные (в байтах) |
| args[2] | ID потока Java. Это - значение, которое будет соответствовать другому HotSpot зонды VM, которые содержат параметр потока |
| args[3] | Собственный ID потока / ID потока ОС. Это - ID, присвоенный операционной системой узла |
| args[4] | Булево значение, которое указывает, является ли этот поток демоном или нет. Значение 0 указывает на поток недемона |
Два зонда доступны для отслеживания действия загрузки и разгрузки класса.
| class-loaded | Зонд, который стреляет, когда класс был загружен |
| class-unloaded | Зонд, который стреляет, когда класс был разгружен от системы |
У каждого из этих зондов есть следующие параметры:
| args[0] | Указатель на UTF-8 представляет в виде строки данные, которые содержат имя класса, который был загружен |
| args[1] | Длина данных имени класса (в байтах) |
| args[2] | ID загрузчика класса, который является уникальным идентификатором для загрузчика класса в VM. Это - загрузчик класса, который загрузил класс |
| args[3] | Булево значение, которое указывает, является ли класс совместно используемым классом (если класс был загружен из совместно используемого архива), |
Зонды доступны, который может использоваться, чтобы измерить продолжительность цикла сборки "мусора" в масштабе всей системы (для тех сборщиков "мусора", у которых есть определенный, начинаются и заканчиваются). Каждый пул памяти может быть прослежен независимо. Зонды для отдельных пулов передают имя распределителя памяти, имя пула, и объединяют информацию об использовании в пул и при начинании и при конце набора пула.
Обеспеченные связанные с GC зонды:
| gc-begin | Зонд, который стреляет, когда набор в масштабе всей системы собирается запуститься. Это - один параметр (аргумент [0]) булево значение, которое указывает, должно ли это быть Полным GC. |
| gc-end | Зонд, который стреляет, когда набор в масштабе всей системы завершился. Никакие параметры. |
| mem-pool-gc-begin | Зонд, который стреляет, когда отдельный пул памяти собирается быть собранным. Обеспечивает упомянутые ниже параметры |
| mem-pool-gc-end | Зонд, который стреляет после отдельного пула памяти, был собран. Обеспечивает упомянутые ниже параметры |
Пул памяти зондирует параметры:
| args[0] | Указатель на UTF-8 представляет в виде строки данные, которые содержат имя менеджера, который управляет этим пулом памяти |
| args[1] | Длина менеджера называет данные (в байтах) |
| args[2] | Указатель на UTF-8 представляет в виде строки данные, которые содержат имя пула памяти |
| args[3] | Длина памяти объединяет данные имени в пул (в байтах) |
| args[4] | Начальный размер пула памяти (в байтах) |
| args[5] | Объем памяти в использовании в пуле памяти (в байтах) |
| args[6] | Число фиксировавших страниц в пуле памяти |
| args[7] | Максимальный размер пула памяти |
Зонды доступны, чтобы указать, какие методы компилируются и который компилятор. Зонды также доступны, чтобы отследить установку и удаление скомпилированных методов.
Зонды, которые отмечают начинание и конец компиляции метода:
| method-compile-begin | Зонд, который стреляет как компиляция метода, начинается. Обеспечивает упомянутые ниже параметры |
| method-compile-end | Зонд, который стреляет, когда компиляция метода завершается. В дополнение к упомянутым ниже параметрам argv[8] является булевым значением, которое указывает, была ли компиляция успешна |
Компиляция метода зондирует параметры:
| args[0] | Указатель на UTF-8 представляет в виде строки данные, которые содержат имя компилятора, который компилирует этот метод |
| args[1] | Длина компилятора называет данные (в байтах) |
| args[2] | Указатель на UTF-8 представляет в виде строки данные, которые содержат имя класса скомпилированного метода |
| args[3] | Длина данных имени класса (в байтах) |
| args[4] | Указатель на UTF-8 представляет в виде строки данные, которые содержат имя скомпилированного метода |
| args[5] | Длина данных имени метода (в байтах) |
| args[6] | Указатель на UTF-8 представляет в виде строки данные, которые содержат подпись скомпилированного метода |
| args[7] | Длина данных подписи (в байтах) |
Когда скомпилированные методы устанавливаются для выполнения или удаляются, следующие зонды запускаются:
| compiled-method-load | Зонд, который стреляет, когда скомпилированный метод устанавливается. В дополнение к упомянутым ниже параметрам argv[6] содержит указатель на скомпилированный код, и argv[7] является размером скомпилированного кода |
| compiled-method-unload | Зонд, который стреляет, когда скомпилированный метод удаляется. Обеспечивает упомянутые ниже параметры |
Скомпилированный метод, загружающий тестовые параметры:
| args[0] | Указатель на UTF-8 представляет в виде строки данные, которые содержат имя класса устанавливаемого метода |
| args[1] | Длина данных имени класса (в байтах) |
| args[2] | Указатель на UTF-8 представляет в виде строки данные, которые содержат имя устанавливаемого метода |
| args[3] | Длина данных имени метода (в байтах) |
| args[4] | Указатель на UTF-8 представляет в виде строки данные, которые содержат подпись устанавливаемого метода |
| args[5] | Длина данных подписи (в байтах) |
Поскольку приложение Java работает, потоки будут вводить и выходить из мониторов, ожидать на мониторах, и выполнять уведомления. Зонды доступны для всех, ожидают и события уведомления, так же как для записи монитора, с которой спорят, и событий выхода. Запись монитора, с которой спорят, является ситуацией, где поток пытается ввести монитор, когда другой поток уже находится в мониторе. Споривший следит за развитием события выхода, происходит, когда поток листы монитор и другие потоки ожидает, чтобы войти в монитор. Таким образом, спорил, входят и утверждал, что события выхода, возможно, не соответствуют друг до друга относительно потока, который встречается с этими событиями, хотя ожидается, что выход, с которым спорят, от одного потока должен соответствовать до спорившего, вводят в другой поток (поток, ожидающий, чтобы ввести монитор).
Все следят за развитием событий, обеспечивают ID потока, ID монитора, и тип класса объекта как параметры. Ожидается, что поток и класс помогут карте вернуться к программе Java, в то время как ID монитора может предоставить соответствие информации между тестовыми взрывами.
Так как существование этих зондов в VM вызывает ухудшение производительности, они будут только стрелять, если флаг VM -XX:+ExtendedDTraceProbes будет установлен на командной строке java. Этот флаг может быть включен и выключен динамически во время выполнения при использовании утилиты jinfo.
Если вышеупомянутый флаг выключен, зонды монитора все еще присутствуют в зонде, перечисляющем доступный от dtrace, но останутся бездействующими и никогда не будут стрелять. Это предназначается, что это ограничение удаляется в будущих выпусках VM, где эти зонды будут включены все время без воздействия к производительности.
Доступные зонды:
| monitor-contended-enter | Зонд, который стреляет как поток, пытается ввести монитор, с которым спорят, |
| monitor-contended-entered | Зонд, который стреляет, когда поток успешно вводит монитор, с которым спорят, |
| monitor-contended-exit | Зонд, который стреляет, когда поток листы монитор и другие потоки ожидают, чтобы войти |
| monitor-wait | Зонд, который стреляет как поток, начинает ожидание на мониторе через Object.wait (). У зонда есть дополнительный параметр, args [4], который является 'длинным' значением, которое указывает на используемый тайм-аут. |
| monitor-waited | Зонд, который стреляет, когда поток завершает Object.wait (). |
| monitor-notify | Зонд, который стреляет, когда поток вызывает Object.notify (), чтобы уведомить официантов относительно монитора |
| monitor-notifyAll | Зонд, который стреляет, когда поток вызывает Object.notifyAll (), чтобы уведомить официантов относительно монитора |
Параметры зонда монитора:
| args[0] | Идентификатор потока Java для потока, выполняющего работу монитора |
| args[1] | Уникальный, но непрозрачный идентификатор для определенного монитора, на который выполняется действие |
| args[2] | Указатель на UTF-8 представляет в виде строки данные, которые содержат имя класса действовавшего объекта |
| args[3] | Длина данных имени класса (в байтах) |
Несколько зондов обеспечиваются, чтобы позволить мелкомодульное исследование выполнения потока Java. Они состоят из зондов, которые стреляют в любое время, метод вводится или возвращается из, так же как зонд, который стреляет всякий раз, когда объект Java был выделен.
Так как существование этих зондов в VM вызывает ухудшение производительности, они будут только стрелять, если VM включат флагу ExtendedDTraceProbes. По умолчанию зонды являются всем подарком в любом перечислении зондов в VM, но являются бездействующими без соответствующего флага. Это предназначается, что это ограничение удаляется в будущих выпусках VM, где эти зонды будут включены все время без воздействия к производительности.
Зонды записи и возврата метода:
| method-entry | Зонд, который стреляет, когда метод вводится. |
| method-return | Зонд, который стреляет, когда метод возвращается, или обычно или из-за исключения. |
Параметры зонда метода:
| args[0] | ID потока Java потока, который вводит или оставляет метод |
| args[1] | Указатель на UTF-8 представляет в виде строки данные, которые содержат имя класса метода |
| args[2] | Длина данных имени класса (в байтах) |
| args[3] | Указатель на UTF-8 представляет в виде строки данные, которые содержат имя метода |
| args[4] | Длина данных имени метода (в байтах) |
| args[5] | Указатель на UTF-8 представляет в виде строки данные, которые содержат подпись метода |
| args[6] | Длина данных подписи (в байтах) |
Доступный зонд выделения:
| object-alloc | Зонд, который стреляет, когда любой объект выделяется, при условии, что флаг ExtendedDTraceProbes включается. |
У объектного зонда выделения есть следующие параметры:
| args[0] | ID потока Java потока, который выделяет объект |
| args[1] | Указатель на UTF-8 представляет в виде строки данные, которые содержат имя класса выделяемого объекта |
| args[2] | Длина данных имени класса (в байтах) |
| args[3] | Размер выделяемого объекта |
Чтобы вызвать от собственного кода до кода Java, из-за встраивания VM в приложении или выполнении собственного кода в пределах приложения Java, собственный код должен позвонить через интерфейс JNI. Интерфейс JNI обеспечивает много методов для того, чтобы они вызвали код Java и исследовали состояние VM. Зонды DTrace обеспечиваются в точке входа и точке возврата для каждого из этих методов. Зонды обеспечиваются hotspot_jni провайдером. Имя зонда является именем метода JNI, добавленного с "-записи" для зондов записи, и "-возврат" для зондов возврата. Параметрами, доступными в каждом зонде записи, являются параметры, которые были обеспечены для функции (за исключением методов Invoke*, которые опускают параметры, которые передают к методу Java). У зондов возврата есть возвращаемое значение метода как параметр (при наличии).
provider hotspot {
probe vm-init-begin();
probe vm-init-end();
probe vm-shutdown();
probe class-loaded(
char* class_name, uintptr_t class_name_len, uintptr_t class_loader_id, bool is_shared);
probe class-unloaded(
char* class_name, uintptr_t class_name_len, uintptr_t class_loader_id, bool is_shared);
probe gc-begin(bool is_full);
probe gc-end();
probe mem-pool-gc-begin(
char* mgr_name, uintptr_t mgr_name_len, char* pool_name, uintptr_t pool_name_len,
uintptr_t initial_size, uintptr_t used, uintptr_t committed, uintptr_t max_size);
probe mem-pool-gc-end(
char* mgr_name, uintptr_t mgr_name_len, char* pool_name, uintptr_t pool_name_len,
uintptr_t initial_size, uintptr_t used, uintptr_t committed, uintptr_t max_size);
probe thread-start(
char* thread_name, uintptr_t thread_name_length,
uintptr_t java_thread_id, uintptr_t native_thread_id, bool is_daemon);
probe thread-stop(
char* thread_name, uintptr_t thread_name_length,
uintptr_t java_thread_id, uintptr_t native_thread_id, bool is_daemon);
probe method-compile-begin(
char* class_name, uintptr_t class_name_len,
char* method_name, uintptr_t method_name_len,
char* signature, uintptr_t signature_len);
probe method-compile-end(
char* class_name, uintptr_t class_name_len,
char* method_name, uintptr_t method_name_len,
char* signature, uintptr_t signature_len,
bool is_success);
probe compiled-method-load(
char* class_name, uintptr_t class_name_len,
char* method_name, uintptr_t method_name_len,
char* signature, uintptr_t signature_len,
void* code, uintptr_t code_size);
probe compiled-method-unload(
char* class_name, uintptr_t class_name_len,
char* method_name, uintptr_t method_name_len,
char* signature, uintptr_t signature_len);
probe monitor-contended-enter(
uintptr_t java_thread_id, uintptr_t monitor_id,
char* class_name, uintptr_t class_name_len);
probe monitor-contended-entered(
uintptr_t java_thread_id, uintptr_t monitor_id,
char* class_name, uintptr_t class_name_len);
probe monitor-contended-exit(
uintptr_t java_thread_id, uintptr_t monitor_id,
char* class_name, uintptr_t class_name_len);
probe monitor-wait(
uintptr_t java_thread_id, uintptr_t monitor_id,
char* class_name, uintptr_t class_name_len,
uintptr_t timeout);
probe monitor-waited(
uintptr_t java_thread_id, uintptr_t monitor_id,
char* class_name, uintptr_t class_name_len);
probe monitor-notify(
uintptr_t java_thread_id, uintptr_t monitor_id,
char* class_name, uintptr_t class_name_len);
probe monitor-notifyAll(
uintptr_t java_thread_id, uintptr_t monitor_id,
char* class_name, uintptr_t class_name_len);
probe method-entry(
uintptr_t java_thread_id, char* class_name, uintptr_t class_name_len,
char* method_name, uintptr_t method_name_len,
char* signature, uintptr_t signature_len);
probe method-return(
uintptr_t java_thread_id, char* class_name, uintptr_t class_name_len,
char* method_name, uintptr_t method_name_len,
char* signature, uintptr_t signature_len);
probe object-alloc(
uintptr_t java_thread_id, char* class_name, uintptr_t class_name_len,
uintptr_t size);
};
provider hotspot_jni {
probe AllocObject-entry(void*, void*);
probe AllocObject-return(void*);
probe AttachCurrentThreadAsDaemon-entry(void*, void**, void*);
probe AttachCurrentThreadAsDaemon-return(uint32_t);
probe AttachCurrentThread-entry(void*, void**, void*);
probe AttachCurrentThread-return(uint32_t);
probe CallBooleanMethodA-entry(void*, void*, uintptr_t);
probe CallBooleanMethodA-return(uintptr_t);
probe CallBooleanMethod-entry(void*, void*, uintptr_t);
probe CallBooleanMethod-return(uintptr_t);
probe CallBooleanMethodV-entry(void*, void*, uintptr_t);
probe CallBooleanMethodV-return(uintptr_t);
probe CallByteMethodA-entry(void*, void*, uintptr_t);
probe CallByteMethodA-return(char);
probe CallByteMethod-entry(void*, void*, uintptr_t);
probe CallByteMethod-return(char);
probe CallByteMethodV-entry(void*, void*, uintptr_t);
probe CallByteMethodV-return(char);
probe CallCharMethodA-entry(void*, void*, uintptr_t);
probe CallCharMethodA-return(uint16_t);
probe CallCharMethod-entry(void*, void*, uintptr_t);
probe CallCharMethod-return(uint16_t);
probe CallCharMethodV-entry(void*, void*, uintptr_t);
probe CallCharMethodV-return(uint16_t);
probe CallDoubleMethodA-entry(void*, void*, uintptr_t);
probe CallDoubleMethodA-return(double);
probe CallDoubleMethod-entry(void*, void*, uintptr_t);
probe CallDoubleMethod-return(double);
probe CallDoubleMethodV-entry(void*, void*, uintptr_t);
probe CallDoubleMethodV-return(double);
probe CallFloatMethodA-entry(void*, void*, uintptr_t);
probe CallFloatMethodA-return(float);
probe CallFloatMethod-entry(void*, void*, uintptr_t);
probe CallFloatMethod-return(float);
probe CallFloatMethodV-entry(void*, void*, uintptr_t);
probe CallFloatMethodV-return(float);
probe CallIntMethodA-entry(void*, void*, uintptr_t);
probe CallIntMethodA-return(uint32_t);
probe CallIntMethod-entry(void*, void*, uintptr_t);
probe CallIntMethod-return(uint32_t);
probe CallIntMethodV-entry(void*, void*, uintptr_t);
probe CallIntMethodV-return(uint32_t);
probe CallLongMethodA-entry(void*, void*, uintptr_t);
probe CallLongMethodA-return(uintptr_t);
probe CallLongMethod-entry(void*, void*, uintptr_t);
probe CallLongMethod-return(uintptr_t);
probe CallLongMethodV-entry(void*, void*, uintptr_t);
probe CallLongMethodV-return(uintptr_t);
probe CallNonvirtualBooleanMethodA-entry(void*, void*, void*, uintptr_t);
probe CallNonvirtualBooleanMethodA-return(uintptr_t);
probe CallNonvirtualBooleanMethod-entry(void*, void*, void*, uintptr_t);
probe CallNonvirtualBooleanMethod-return(uintptr_t);
probe CallNonvirtualBooleanMethodV-entry(void*, void*, void*, uintptr_t);
probe CallNonvirtualBooleanMethodV-return(uintptr_t);
probe CallNonvirtualByteMethodA-entry(void*, void*, void*, uintptr_t);
probe CallNonvirtualByteMethodA-return(char);
probe CallNonvirtualByteMethod-entry(void*, void*, void*, uintptr_t);
probe CallNonvirtualByteMethod-return(char);
probe CallNonvirtualByteMethodV-entry(void*, void*, void*, uintptr_t);
probe CallNonvirtualByteMethodV-return(char);
probe CallNonvirtualCharMethodA-entry(void*, void*, void*, uintptr_t);
probe CallNonvirtualCharMethodA-return(uint16_t);
probe CallNonvirtualCharMethod-entry(void*, void*, void*, uintptr_t);
probe CallNonvirtualCharMethod-return(uint16_t);
probe CallNonvirtualCharMethodV-entry(void*, void*, void*, uintptr_t);
probe CallNonvirtualCharMethodV-return(uint16_t);
probe CallNonvirtualDoubleMethodA-entry(void*, void*, void*, uintptr_t);
probe CallNonvirtualDoubleMethodA-return(double);
probe CallNonvirtualDoubleMethod-entry(void*, void*, void*, uintptr_t);
probe CallNonvirtualDoubleMethod-return(double);
probe CallNonvirtualDoubleMethodV-entry(void*, void*, void*, uintptr_t);
probe CallNonvirtualDoubleMethodV-return(double);
probe CallNonvirtualFloatMethodA-entry(void*, void*, void*, uintptr_t);
probe CallNonvirtualFloatMethodA-return(float);
probe CallNonvirtualFloatMethod-entry(void*, void*, void*, uintptr_t);
probe CallNonvirtualFloatMethod-return(float);
probe CallNonvirtualFloatMethodV-entry(void*, void*, void*, uintptr_t);
probe CallNonvirtualFloatMethodV-return(float);
probe CallNonvirtualIntMethodA-entry(void*, void*, void*, uintptr_t);
probe CallNonvirtualIntMethodA-return(uint32_t);
probe CallNonvirtualIntMethod-entry(void*, void*, void*, uintptr_t);
probe CallNonvirtualIntMethod-return(uint3t);
probe CallNonvirtualIntMethodV-entry(void*, void*, void*, uintptr_t);
probe CallNonvirtualIntMethodV-return(uint32_t);
probe CallNonvirtualLongMethodA-entry(void*, void*, void*, uintptr_t);
probe CallNonvirtualLongMethodA-return(uintptr_t);
probe CallNonvirtualLongMethod-entry(void*, void*, void*, uintptr_t);
probe CallNonvirtualLongMethod-return(uintptr_t);
probe CallNonvirtualLongMethodV-entry(void*, void*, void*, uintptr_t);
probe CallNonvirtualLongMethodV-return(uintptr_t);
probe CallNonvirtualObjectMethodA-entry(void*, void*, void*, uintptr_t);
probe CallNonvirtualObjectMethodA-return(void*);
probe CallNonvirtualObjectMethod-entry(void*, void*, void*, uintptr_t);
probe CallNonvirtualObjectMethod-return(void*);
probe CallNonvirtualObjectMethodV-entry(void*, void*, void*, uintptr_t);
probe CallNonvirtualObjectMethodV-return(void*);
probe CallNonvirtualShortMethodA-entry(void*, void*, void*, uintptr_t);
probe CallNonvirtualShortMethodA-return(uint16_t);
probe CallNonvirtualShortMethod-entry(void*, void*, void*, uintptr_t);
probe CallNonvirtualShortMethod-return(uint16_t);
probe CallNonvirtualShortMethodV-entry(void*, void*, void*, uintptr_t);
probe CallNonvirtualShortMethodV-return(uint16_t);
probe CallNonvirtualVoidMethodA-entry(void*, void*, void*, uintptr_t);
probe CallNonvirtualVoidMethodA-return();
probe CallNonvirtualVoidMethod-entry(void*, void*, void*, uintptr_t);
probe CallNonvirtualVoidMethod-return();
probe CallNonvirtualVoidMethodV-entry(void*, void*, void*, uintptr_t);
probe CallNonvirtualVoidMethodV-return();
probe CallObjectMethodA-entry(void*, void*, uintptr_t);
probe CallObjectMethodA-return(void*);
probe CallObjectMethod-entry(void*, void*, uintptr_t);
probe CallObjectMethod-return(void*);
probe CallObjectMethodV-entry(void*, void*, uintptr_t);
probe CallObjectMethodV-return(void*);
probe CallShortMethodA-entry(void*, void*, uintptr_t);
probe CallShortMethodA-return(uint16_t);
probe CallShortMethod-entry(void*, void*, uintptr_t);
probe CallShortMethod-return(uint16_t);
probe CallShortMethodV-entry(void*, void*, uintptr_t);
probe CallShortMethodV-return(uint16_t);
probe CallStaticBooleanMethodA-entry(void*, void*, uintptr_t);
probe CallStaticBooleanMethodA-return(uintptr_t);
probe CallStaticBooleanMethod-entry(void*, void*, uintptr_t);
probe CallStaticBooleanMethod-return(uintptr_t);
probe CallStaticBooleanMethodV-entry(void*, void*, uintptr_t);
probe CallStaticBooleanMethodV-return(uintptr_t);
probe CallStaticByteMethodA-entry(void*, void*, uintptr_t);
probe CallStaticByteMethodA-return(char);
probe CallStaticByteMethod-entry(void*, void*, uintptr_t);
probe CallStaticByteMethod-return(char);
probe CallStaticByteMethodV-entry(void*, void*, uintptr_t);
probe CallStaticByteMethodV-return(char);
probe CallStaticCharMethodA-entry(void*, void*, uintptr_t);
probe CallStaticCharMethodA-return(uint16_t);
probe CallStaticCharMethod-entry(void*, void*, uintptr_t);
probe CallStaticCharMethod-return(uint16_t);
probe CallStaticCharMethodV-entry(void*, void*, uintptr_t);
probe CallStaticCharMethodV-return(uint16_t);
probe CallStaticDoubleMethodA-entry(void*, void*, uintptr_t);
probe CallStaticDoubleMethodA-return(double);
probe CallStaticDoubleMethod-entry(void*, void*, uintptr_t);
probe CallStaticDoubleMethod-return(double);
probe CallStaticDoubleMethodV-entry(void*, void*, uintptr_t);
probe CallStaticDoubleMethodV-return(double);
probe CallStaticFloatMethodA-entry(void*, void*, uintptr_t);
probe CallStaticFloatMethodA-return(float);
probe CallStaticFloatMethod-entry(void*, void*, uintptr_t);
probe CallStaticFloatMethod-return(float);
probe CallStaticFloatMethodV-entry(void*, void*, uintptr_t);
probe CallStaticFloatMethodV-return(float);
probe CallStaticIntMethodA-entry(void*, void*, uintptr_t);
probe CallStaticIntMethodA-return(uint32_t);
probe CallStaticIntMethod-entry(void*, void*, uintptr_t);
probe CallStaticIntMethod-return(uint32_t);
probe CallStaticIntMethodentry(void*, void*, uintptr_t);
probe CallStaticIntMethodV-return(uint32_t);
probe CallStaticLongMethodA-entry(void*, void*, uintptr_t);
probe CallStaticLongMethodA-return(uintptr_t);
probe CallStaticLongMethod-entry(void*, void*, uintptr_t);
probe CallStaticLongMethod-return(uintptr_t);
probe CallStaticLongMethodV-entry(void*, void*, uintptr_t);
probe CallStaticLongMethodV-return(uintptr_t);
probe CallStaticObjectMethodA-entry(void*, void*, uintptr_t);
probe CallStaticObjectMethodA-return(void*);
probe CallStaticObjectMethod-entry(void*, void*, uintptr_t);
probe CallStaticObjectMethod-return(void*);
probe CallStaticObjectMethodV-entry(void*, void*, uintptr_t);
probe CallStaticObjectMethodV-return(void*);
probe CallStaticShortMethodA-entry(void*, void*, uintptr_t);
probe CallStaticShortMethodA-return(uint16_t);
probe CallStaticShortMethod-entry(void*, void*, uintptr_t);
probe CallStaticShortMethod-return(uint16_t);
probe CallStaticShortMethodV-entry(void*, void*, uintptr_t);
probe CallStaticShortMethodV-return(uint16_t);
probe CallStaticVoidMethodA-entry(void*, void*, uintptr_t);
probe CallStaticVoidMethodA-return();
probe CallStaticVoidMethod-entry(void*, void*, uintptr_t);
probe CallStaticVoidMethod-return();
probe CallStaticVoidMethodV-entry(void*, void*, uintptr_t);
probe CallStaticVoidMethodV-return();
probe CallVoidMethodA-entry(void*, void*, uintptr_t);
probe CallVoidMethodA-return();
probe CallVoidMethod-entry(void*, void*, uintptr_t);
probe CallVoidMethod-return();
probe CallVoidMethodV-entry(void*, void*, uintptr_t);
probe CallVoidMethodV-return();
probe CreateJavaVM-entry(void**, void**, void*);
probe CreateJavaVM-return(uint32_t);
probe DefineClass-entry(void*, const char*, void*, char, uintptr_t);
probe DefineClass-return(void*);
probe DeleteGlobalRef-entry(void*, void*);
probe DeleteGlobalRef-return();
probe DeleteLocalRef-entry(void*, void*);
probe DeleteLocalRef-return();
probe DeleteWeakGlobalRef-entry(void*, void*);
probe DeleteWeakGlobalRef-return();
probe DestroyJavaVM-entry(void*);
probe DestroyJavaVM-return(uint32_t);
probe DetachCurrentThread-entry(void*);
probe DetachCurrentThread-return(uint32_t);
probe EnsureLocalCapacity-entry(void*, uint32_t);
probe EnsureLocalCapacity-return(uint32_t);
probe ExceptionCheck-entry(void*);
probe ExceptionCheck-return(uintptr_t);
probe ExceptionClear-entry(void*);
probe ExceptionClear-return();
probe ExceptionDescribe-entry(void*);
probe ExceptionDescribe-return();
probe ExceptionOccurred-entry(void*);
probe ExceptionOccurred-return(void*);
probe FatalError-entry(void* env, const char*);
probe FatalError-return();
probe FindClass-entry(void*, const char*);
probe FindClass-return(void*);
probe FromReflectedField-entry(void*, void*);
probe FromReflectedField-return(uintptr_t);
probe FromReflectedMethod-entry(void*, void*);
probe FromReflectedMethod-return(uintptr_t);
probe GetArrayLength-entry(void*, void*);
probe GetArrayLength-return(uintptr_t);
probe GetBooleanArrayElements-entry(void*, void*, uintptr_t*);
probe GetBooleanArrayElements-return(uintptr_t*);
probe GetBooleanArrayRegion-entry(void*, void*, uintptr_t, uintptr_t, uintptr_t*);
probe GetBooleanArrayRegion-return();
probe GetBooleanField-entry(void*, void*, uintptr_t);
probe GetBooleanField-return(uintptr_t);
probe GetByteArrayElements-entry(void*, void*, uintptr_t*);
probe GetByteArrayElements-return(char*);
probe GetByteArrayRegion-entry(void*, void*, uintptr_t, uintptr_t, char*);
probe GetByteArrayRegion-return();
probe GetByteField-entry(void*, void*, uintptr_t);
probe GetByteField-return(char);
probe GetCharArrayElements-entry(void*, void*, uintptr_t*);
probe GetCharArrayElements-return(uint16_t*);
probe GetCharArrayRegion-entry(void*, void*, uintptr_t, uintptr_t, uint16_t*);
probe GetCharArrayRegion-return();
probe GetCharField-entry(void*, void*, uintptr_t);
probe GetCharField-return(uint16_t);
probe GetCreatedJavaVMs-eintptr_t*);
probe GetCreatedJavaVMs-return(uintptr_t);
probe GetCreateJavaVMs-entry(void*, uintptr_t, uintptr_t*);
probe GetCreateJavaVMs-return(uint32_t);
probe GetDefaultJavaVMInitArgs-entry(void*);
probe GetDefaultJavaVMInitArgs-return(uint32_t);
probe GetDirectBufferAddress-entry(void*, void*);
probe GetDirectBufferAddress-return(void*);
probe GetDirectBufferCapacity-entry(void*, void*);
probe GetDirectBufferCapacity-return(uintptr_t);
probe GetDoubleArrayElements-entry(void*, void*, uintptr_t*);
probe GetDoubleArrayElements-return(double*);
probe GetDoubleArrayRegion-entry(void*, void*, uintptr_t, uintptr_t, double*);
probe GetDoubleArrayRegion-return();
probe GetDoubleField-entry(void*, void*, uintptr_t);
probe GetDoubleField-return(double);
probe GetEnv-entry(void*, void*, void*);
probe GetEnv-return(uint32_t);
probe GetFieldID-entry(void*, void*, const char*, const char*);
probe GetFieldID-return(uintptr_t);
probe GetFloatArrayElements-entry(void*, void*, uintptr_t*);
probe GetFloatArrayElements-return(float*);
probe GetFloatArrayRegion-entry(void*, void*, uintptr_t, uintptr_t, float*);
probe GetFloatArrayRegion-return();
probe GetFloatField-entry(void*, void*, uintptr_t);
probe GetFloatField-return(float);
probe GetIntArrayElements-entry(void*, void*, uintptr_t*);
probe GetIntArrayElements-return(uint32_t*);
probe GetIntArrayRegion-entry(void*, void*, uintptr_t, uintptr_t, uint32_t*);
probe GetIntArrayRegion-return();
probe GetIntField-entry(void*, void*, uintptr_t);
probe GetIntField-return(uint32_t);
probe GetJavaVM-entry(void*, void**);
probe GetJavaVM-return(uint32_t);
probe GetLongArrayElements-entry(void*, void*, uintptr_t*);
probe GetLongArrayElements-return(uintptr_t*);
probe GetLongArrayRegion-entry(void*, void*, uintptr_t, uintptr_t, uintptr_t*);
probe GetLongArrayRegion-return();
probe GetLongField-entry(void*, void*, uintptr_t);
probe GetLongField-return(uintptr_t);
probe GetMethodID-entry(void*, void*, const char*, const char*);
probe GetMethodID-return(uintptr_t);
probe GetObjectArrayElement-entry(void*, void*, uintptr_t);
probe GetObjectArrayElement-return(void*);
probe GetObjectClass-entry(void*, void*);
probe GetObjectClass-return(void*);
probe GetObjectField-entry(void*, void*, uintptr_t);
probe GetObjectField-return(void*);
probe GetObjectRefType-entry(void*, void*);
probe GetObjectRefType-return(void*);
probe GetPrimitiveArrayCritical-entry(void*, void*, uintptr_t*);
probe GetPrimitiveArrayCritical-return(void*);
probe GetShortArrayElements-entry(void*, void*, uintptr_t*);
probe GetShortArrayElements-return(uint16_t*);
probe GetShortArrayRegion-entry(void*, void*, uintptr_t, uintptr_t, uint16_t*);
probe GetShortArrayRegion-return();
probe GetShortField-entry(void*, void*, uintptr_t);
probe GetShortField-return(uint16_t);
probe GetStaticBooleanField-entry(void*, void*, uintptr_t);
probe GetStaticBooleanField-return(uintptr_t);
probe GetStaticByteField-entry(void*, void*, uintptr_t);
probe GetStaticByteField-return(char);
probe GetStaticCharField-entry(void*, void*, uintptr_t);
probe GetStaticCharField-return(uint16_t);
probe GetStaticDoubleField-entry(void*, void*, uintptr_t);
probe GetStaticDoubleField-return(double);
probe GetStaticFieldID-entry(void*, void*, const char*, const char*);
probe GetStaticFieldID-return(uintptr_t);
probe GetStaticFloatField-entry(void*, void*, uintptr_t);
probe GetStaticFloatField-return(float);
probe GetStaticIntField-entry(void*, void*, uintptr_t);
probe GetStaticIntField-return(uint32_t);
probe GetStaticLongField-entry(void*, void*, uintptr_t);
probe GetStaticLongField-return(uintptr_t);
probe GetStaticMethodID-entry(void*, void*, const char*, const char*);
probe GetStaticMethodID-return(uintptr_t);
probe GetStaticObjectField-entry(void*, void*, uintptr_t);
probe GetStaticObjectField-return(void*);
probe GetStaticShortField-entry(void*, void*, uintptr_t);
probe GetStaticShortField-return(uint16_t);
pro GetStringChars-entry(void*, void*, uintptr_t*);
probe GetStringChars-return(const uint16_t*);
probe GetStringCritical-entry(void*, void*, uintptr_t*);
probe GetStringCritical-return(const uint16_t*);
probe GetStringLength-entry(void*, void*);
probe GetStringLength-return(uintptr_t);
probe GetStringRegion-entry(void*, void*, uintptr_t, uintptr_t, uint16_t*);
probe GetStringRegion-return();
probe GetStringUTFChars-entry(void*, void*, uintptr_t*);
probe GetStringUTFChars-return(const char*);
probe GetStringUTFLength-entry(void*, void*);
probe GetStringUTFLength-return(uintptr_t);
probe GetStringUTFRegion-entry(void*, void*, uintptr_t, uintptr_t, char*);
probe GetStringUTFRegion-return();
probe GetSuperclass-entry(void*, void*);
probe GetSuperclass-return(void*);
probe GetVersion-entry(void*);
probe GetVersion-return(uint32_t);
probe IsAssignableFrom-entry(void*, void*, void*);
probe IsAssignableFrom-return(uintptr_t);
probe IsInstanceOf-entry(void*, void*, void*);
probe IsInstanceOf-return(uintptr_t);
probe IsSameObject-entry(void*, void*, void*);
probe IsSameObject-return(uintptr_t);
probe MonitorEnter-entry(void*, void*);
probe MonitorEnter-return(uint32_t);
probe MonitorExit-entry(void*, void*);
probe MonitorExit-return(uint32_t);
probe NewBooleanArray-entry(void*, uintptr_t);
probe NewBooleanArray-return(void*);
probe NewByteArray-entry(void*, uintptr_t);
probe NewByteArray-return(void*);
probe NewCharArray-entry(void*, uintptr_t);
probe NewCharArray-return(void*);
probe NewDirectByteBuffer-entry(void*, void*, uintptr_t);
probe NewDirectByteBuffer-return(void*);
probe NewDoubleArray-entry(void*, uintptr_t);
probe NewDoubleArray-return(void*);
probe NewFloatArray-entry(void*, uintptr_t);
probe NewFloatArray-return(void*);
probe NewGlobalRef-entry(void*, void*);
probe NewGlobalRef-return(void*);
probe NewIntArray-entry(void*, uintptr_t);
probe NewIntArray-return(void*);
probe NewLocalRef-entry(void*, void*);
probe NewLocalRef-return(void*);
probe NewLongArray-entry(void*, uintptr_t);
probe NewLongArray-return(void*);
probe NewObjectA-entry(void*, void*, uintptr_t);
probe NewObjectA-return(void*);
probe NewObjectArray-entry(void*, uintptr_t, void*, void*);
probe NewObjectArray-return(void*);
probe NewObject-entry(void*, void*, uintptr_t);
probe NewObject-return(void*);
probe NewObjectV-entry(void*, void*, uintptr_t);
probe NewObjectV-return(void*);
probe NewShortArray-entry(void*, uintptr_t);
probe NewShortArray-return(void*);
probe NewString-entry(void*, const uint16_t*, uintptr_t);
probe NewString-return(void*);
probe NewStringUTF-entry(void*, const char*);
probe NewStringUTF-return(void*);
probe NewWeakGlobalRef-entry(void*, void*);
probe NewWeakGlobalRef-return(void*);
probe PopLocalFrame-entry(void*, void*);
probe PopLocalFrame-return(void*);
probe PushLocalFrame-entry(void*, uint32_t);
probe PushLocalFrame-return(uint32_t);
probe RegisterNatives-entry(void*, void*, const void*, uint32_t);
probe RegisterNatives-return(uint32_t);
probe ReleaseBooleanArrayElements-entry(void*, void*, uintptr_t*, uint32_t);
probe ReleaseBooleanArrayElements-return();
probe ReleaseByteArrayElements-entry(void*, void*, char*, uint32_t);
probe ReleaseByteArrayElements-return();
probe ReleaseCharArrayElements-entry(void*, void*, uint16_t*, uint32_t);
probe ReleaseCharArrayElements-return();
probe ReleaseDoubleArrayElements-entry(void*, void*, double*, uint32_t);
probe ReleaseDoubleArrayElements-return();
probe ReleaseFloatArrayElements-entry(void*, void*, float*, uint32_t);
probe ReleaseFloatArrayElements-return();
probe ReleaseIntArrayElements-entry(void*, void*, uint32_t*, uint32_t);
probe ReleaseIntArrayElements-return();
probe ReleaseLongArrayElements-entry(void*, void*, uintptr_t*, uint32_t);
probe ReleaseLongArrayElements-return();
probe ReleaseObjectArrayElements-entry(void*, void*, void**, uint32_t);
probe ReleaseObjectArrayElements-return();
probe Releasey(void*, void*, void*, uint32_t);
probe ReleasePrimitiveArrayCritical-return();
probe ReleaseShortArrayElements-entry(void*, void*, uint16_t*, uint32_t);
probe ReleaseShortArrayElements-return();
probe ReleaseStringChars-entry(void*, void*, const uint16_t*);
probe ReleaseStringChars-return();
probe ReleaseStringCritical-entry(void*, void*, const uint16_t*);
probe ReleaseStringCritical-return();
probe ReleaseStringUTFChars-entry(void*, void*, const char*);
probe ReleaseStringUTFChars-return();
probe SetBooleanArrayRegion-entry(void*, void*, uintptr_t, uintptr_t, const uintptr_t*);
probe SetBooleanArrayRegion-return();
probe SetBooleanField-entry(void*, void*, uintptr_t, uintptr_t);
probe SetBooleanField-return();
probe SetByteArrayRegion-entry(void*, void*, uintptr_t, uintptr_t, const char*);
probe SetByteArrayRegion-return();
probe SetByteField-entry(void*, void*, uintptr_t, char);
probe SetByteField-return();
probe SetCharArrayRegion-entry(void*, void*, uintptr_t, uintptr_t, const uint16_t*);
probe SetCharArrayRegion-return();
probe SetCharField-entry(void*, void*, uintptr_t, uint16_t);
probe SetCharField-return();
probe SetDoubleArrayRegion-entry(void*, void*, uintptr_t, uintptr_t, const double*);
probe SetDoubleArrayRegion-return();
probe SetDoubleField-entry(void*, void*, uintptr_t, double);
probe SetDoubleField-return();
probe SetFloatArrayRegion-entry(void*, void*, uintptr_t, uintptr_t, const float*);
probe SetFloatArrayRegion-return();
probe SetFloatField-entry(void*, void*, uintptr_t, float);
probe SetFloatField-return();
probe SetIntArrayRegion-entry(void*, void*, uintptr_t, uintptr_t, const uint32_t*);
probe SetIntArrayRegion-return();
probe SetIntField-entry(void*, void*, uintptr_t, uint32_t);
probe SetIntField-return();
probe SetLongArrayRegion-entry(void*, void*, uintptr_t, uintptr_t, const uintptr_t*);
probe SetLongArrayRegion-return();
probe SetLongField-entry(void*, void*, uintptr_t, uintptr_t);
probe SetLongField-return();
probe SetObjectArrayElement-entry(void*, void*, uintptr_t, void*);
probe SetObjectArrayElement-return();
probe SetObjectField-entry(void*, void*, uintptr_t, void*);
probe SetObjectField-return();
probe SetShortArrayRegion-entry(void*, void*, uintptr_t, uintptr_t, const uint16_t*);
probe SetShortArrayRegion-return();
probe SetShortField-entry(void*, void*, uintptr_t, uint16_t);
probe SetShortField-return();
probe SetStaticBooleanField-entry(void*, void*, uintptr_t, uintptr_t);
probe SetStaticBooleanField-return();
probe SetStaticByteField-entry(void*, void*, uintptr_t, char);
probe SetStaticByteField-return();
probe SetStaticCharField-entry(void*, void*, uintptr_t, uint16_t);
probe SetStaticCharField-return();
probe SetStaticDoubleField-entry(void*, void*, uintptr_t, double);
probe SetStaticDoubleField-return();
probe SetStaticFloatField-entry(void*, void*, uintptr_t, float);
probe SetStaticFloatField-return();
probe SetStaticIntField-entry(void*, void*, uintptr_t, uint32_t);
probe SetStaticIntField-return();
probe SetStaticLongField-entry(void*, void*, uintptr_t, uintptr_t);
probe SetStaticLongField-return();
probe SetStaticObjectField-entry(void*, void*, uintptr_t, void*);
probe SetStaticObjectField-return();
probe SetStaticShortField-entry(void*, void*, uintptr_t, uint16_t);
probe SetStaticShortField-return();
probe Throw-entry(void*, void*);
probe ThrowNew-entry(void*, void*, const char*);
probe ThrowNew-return(uint32_t);
probe Throw-return(uint32_t);
probe ToReflectedField-entry(void*, void*, uintptr_t, uintptr_t);
probe ToReflectedField-return(void*);
probe ToReflectedMethod-entry(void*, void*, uintptr_t, uintptr_t);
probe ToReflectedMethod-return(void*);
probe UnregisterNatives-entry(void*, void*);
probe UnregisterNatives-return(uint32_t);
};
