Java 动态调试技术原理及实践

[1] public static void premain(String agentArgs, Instrumentation inst);[2] public static void premain(String agentArgs);

[1] public static void agentmain(String agentArgs, Instrumentation inst);[2] public static void agentmain(String agentArgs);

Premain-Class: classAgent-Class: class

    private void attachAgentToTargetJVM() throws Exception {        List<VirtualMachineDescriptor> virtualMachineDescriptors = VirtualMachine.list();        VirtualMachineDescriptor targetVM = null;        for (VirtualMachineDescriptor descriptor : virtualMachineDescriptors) {            if (descriptor.id().equals(configure.getPid())) {                targetVM = descriptor;                break;            }        }        if (targetVM == null) {            throw new IllegalArgumentException("could not find the target jvm by process id:" + configure.getPid());        }        VirtualMachine virtualMachine = null;        try {            virtualMachine = VirtualMachine.attach(targetVM);            virtualMachine.loadAgent("{agent}", "{params}");        } catch (Exception e) {            if (virtualMachine != null) {                virtualMachine.detach();            }        }    }

  // -agentlib and -agentpath  if (match_option(option, "-agentlib:", &tail) ||          (is_absolute_path = match_option(option, "-agentpath:", &tail))) {      if(tail != NULL) {        const char* pos = strchr(tail, '=');        size_t len = (pos == NULL) ? strlen(tail) : pos - tail;        char* name = strncpy(NEW_C_HEAP_ARRAY(char, len + 1, mtArguments), tail, len);        name[len] = '\0';        char *options = NULL;        if(pos != NULL) {          options = os::strdup_check_oom(pos + 1, mtArguments);        }#if !INCLUDE_JVMTI        if (valid_jdwp_agent(name, is_absolute_path)) {          jio_fprintf(defaultStream::error_stream(),            "Debugging agents are not supported in this VM\n");          return JNI_ERR;        }#endif // !INCLUDE_JVMTI        add_init_agent(name, options, is_absolute_path);      }    // -javaagent    } else if (match_option(option, "-javaagent:", &tail)) {#if !INCLUDE_JVMTI      jio_fprintf(defaultStream::error_stream(),        "Instrumentation agents are not supported in this VM\n");      return JNI_ERR;#else      if (tail != NULL) {        size_t length = strlen(tail) + 1;        char *options = NEW_C_HEAP_ARRAY(char, length, mtArguments);        jio_snprintf(options, length, "%s", tail);        add_init_agent("instrument", options, false);        // java agents need module java.instrument        if (!create_numbered_property("jdk.module.addmods", "java.instrument", addmods_count++)) {          return JNI_ENOMEM;        }      }#endif // !INCLUDE_JVMTI    }

  // -agentlib and -agentpath arguments  static AgentLibraryList _agentList;  static void add_init_agent(const char* name, char* options, bool absolute_path)    { _agentList.add(new AgentLibrary(name, options, absolute_path, NULL)); }

   // Launch -agentlib/-agentpath and converted -Xrun agents  if (Arguments::init_agents_at_startup()) {    create_vm_init_agents();  }  static bool init_agents_at_startup() {    return !_agentList.is_empty();   }

void Threads::create_vm_init_agents() {  AgentLibrary* agent;  for (agent = Arguments::agents(); agent != NULL; agent = agent->next()) {    OnLoadEntry_t  on_load_entry = lookup_agent_on_load(agent);    if (on_load_entry != NULL) {      // Invoke the Agent_OnLoad function      jint err = (*on_load_entry)(&main_vm, agent->options(), NULL);    }  }}

JNIEXPORT jint JNICALLDEF_Agent_OnLoad(JavaVM *vm, char *tail, void * reserved) {    initerror = createNewJPLISAgent(vm, &agent);    if ( initerror == JPLIS_INIT_ERROR_NONE ) {        if (parseArgumentTail(tail, &jarfile, &options) != 0) {            fprintf(stderr, "-javaagent: memory allocation failure.\n");            return JNI_ERR;        }        attributes = readAttributes(jarfile);        premainClass = getAttribute(attributes, "Premain-Class");        /* Save the jarfile name */        agent->mJarfile = jarfile;        /*         * Convert JAR attributes into agent capabilities         */        convertCapabilityAttributes(attributes, agent);        /*         * Track (record) the agent class name and options data         */        initerror = recordCommandLineData(agent, premainClass, options);    }    return result;}

JPLISInitializationError initializeJPLISAgent(JPLISAgent *agent, JavaVM *vm, jvmtiEnv *jvmtienv) {    /* check what capabilities are available */    checkCapabilities(agent);    /* check phase - if live phase then we don't need the VMInit event */    jvmtierror = (*jvmtienv)->GetPhase(jvmtienv, &phase);    /* now turn on the VMInit event */    if ( jvmtierror == JVMTI_ERROR_NONE ) {        jvmtiEventCallbacks callbacks;        memset(&callbacks, 0, sizeof(callbacks));        callbacks.VMInit = &eventHandlerVMInit;        jvmtierror = (*jvmtienv)->SetEventCallbacks(jvmtienv,&callbacks,sizeof(callbacks));    }    if ( jvmtierror == JVMTI_ERROR_NONE ) {        jvmtierror = (*jvmtienv)->SetEventNotificationMode(jvmtienv,JVMTI_ENABLE,JVMTI_EVENT_VM_INIT,NULL);    }    return (jvmtierror == JVMTI_ERROR_NONE)? JPLIS_INIT_ERROR_NONE : JPLIS_INIT_ERROR_FAILURE;}

void JNICALL  eventHandlerVMInit( jvmtiEnv *jvmtienv,JNIEnv *jnienv,jthread thread) {   // ...   success = processJavaStart( environment->mAgent, jnienv);  // ...}jboolean  processJavaStart(JPLISAgent *agent,JNIEnv *jnienv) {    result = createInstrumentationImpl(jnienv, agent);    /*     *  Load the Java agent, and call the premain.     */    if ( result ) {        result = startJavaAgent(agent, jnienv, agent->mAgentClassName, agent->mOptionsString, agent->mPremainCaller);    }    return result;}jboolean startJavaAgent( JPLISAgent *agent,JNIEnv *jnienv,const char *classname,const char *optionsString,jmethodID agentMainMethod) {  // ...    invokeJavaAgentMainMethod(jnienv,agent->mInstrumentationImpl,agentMainMethod, classNameObject,optionsStringObject);  // ...}

// Starts the Attach Listener threadvoid AttachListener::init() {  // 创建线程相关部分代码被去掉了  const char thread_name[] = "Attach Listener";  Handle string = java_lang_String::create_from_str(thread_name, THREAD);  { MutexLocker mu(Threads_lock);    JavaThread* listener_thread = new JavaThread(&attach_listener_thread_entry);    // ...  }}

static void attach_listener_thread_entry(JavaThread* thread, TRAPS) {  AttachListener::set_initialized();  for (;;) {      AttachOperation* op = AttachListener::dequeue();      // find the function to dispatch too      AttachOperationFunctionInfo* info = NULL;      for (int i=0; funcs[i].name != NULL; i++) {        const char* name = funcs[i].name;        if (strcmp(op->name(), name) == 0) {          info = &(funcs[i]); break;        }}       // dispatch to the function that implements this operation        res = (info->func)(op, &st);      //...    }}

static AttachOperationFunctionInfo funcs[] = {  { "agentProperties",  get_agent_properties },  { "datadump",         data_dump },  { "dumpheap",         dump_heap },  { "load",             load_agent },  { "properties",       get_system_properties },  { "threaddump",       thread_dump },  { "inspectheap",      heap_inspection },  { "setflag",          set_flag },  { "printflag",        print_flag },  { "jcmd",             jcmd },  { NULL,               NULL }};

LinuxAttachOperation* LinuxAttachListener::dequeue() {  for (;;) {    // wait for client to connect    struct sockaddr addr;    socklen_t len = sizeof(addr);    RESTARTABLE(::accept(listener(), &addr, &len), s);    // 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) {      ::close(s);      continue;    }    // peer credential look okay so we read the request    LinuxAttachOperation* op = read_request(s);    return op;  }}

  // Start Attach Listener if +StartAttachListener or it can't be started lazily  if (!DisableAttachMechanism) {    AttachListener::vm_start();    if (StartAttachListener || AttachListener::init_at_startup()) {      AttachListener::init();    }  }// Attach Listener is started lazily except in the case when// +ReduseSignalUsage is usedbool AttachListener::init_at_startup() {  if (ReduceSignalUsage) {    return true;  } else {    return false;  }}

void AttachListener::vm_start() {  char fn[UNIX_PATH_MAX];  struct stat64 st;  int ret;  int n = snprintf(fn, UNIX_PATH_MAX, "%s/.java_pid%d",           os::get_temp_directory(), os::current_process_id());  assert(n < (int)UNIX_PATH_MAX, "java_pid file name buffer overflow");  RESTARTABLE(::stat64(fn, &st), ret);  if (ret == 0) {    ret = ::unlink(fn);    if (ret == -1) {      log_debug(attach)("Failed to remove stale attach pid file at %s", fn);    }  }}

  // Signal Dispatcher needs to be started before VMInit event is posted  os::signal_init();

void os::signal_init() {  if (!ReduceSignalUsage) {    // Setup JavaThread for processing signals    EXCEPTION_MARK;    Klass* 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[] = "Signal Dispatcher";    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,CHECK);    os::signal_init_pd();    { MutexLocker mu(Threads_lock);      JavaThread* signal_thread = new JavaThread(&signal_thread_entry);     // ...    }    // Handle ^BREAK    os::signal(SIGBREAK, os::user_handler());  }}

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) {    log_trace(attach)("Failed to find attach file: %s, trying alternate", fn);    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()) {      init();      return true;    }  }  return false;}

    public static VirtualMachine attach(String var0) throws AttachNotSupportedException, IOException {        if (var0 == null) {            throw new NullPointerException("id cannot be null");        } else {            List var1 = AttachProvider.providers();            if (var1.size() == 0) {                throw new AttachNotSupportedException("no providers installed");            } else {                AttachNotSupportedException var2 = null;                Iterator var3 = var1.iterator();                while(var3.hasNext()) {                    AttachProvider var4 = (AttachProvider)var3.next();                    try {                        return var4.attachVirtualMachine(var0);                    } catch (AttachNotSupportedException var6) {                        var2 = var6;                    }                }                throw var2;            }        }    }

public VirtualMachine attachVirtualMachine(String var1) throws AttachNotSupportedException, IOException {        this.checkAttachPermission();        this.testAttachable(var1);        return new BsdVirtualMachine(this, var1);    }BsdVirtualMachine(AttachProvider var1, String var2) throws AttachNotSupportedException, IOException {        int var3 = Integer.parseInt(var2);        this.path = this.findSocketFile(var3);        if (this.path == null) {            File var4 = new File(tmpdir, ".attach_pid" + var3);            createAttachFile(var4.getPath());            try {                sendQuitTo(var3);                int var5 = 0;                long var6 = 200L;                int var8 = (int)(this.attachTimeout() / var6);                do {                    try {                        Thread.sleep(var6);                    } catch (InterruptedException var21) {                        ;                    }                    this.path = this.findSocketFile(var3);                    ++var5;                } while(var5 <= var8 && this.path == null);            } finally {                var4.delete();            }        }        int var24 = socket();        connect(var24, this.path);    }    private String findSocketFile(int var1) {        String var2 = ".java_pid" + var1;        File var3 = new File(tmpdir, var2);        return var3.exists() ? var3.getPath() : null;    }

static jint load_agent(AttachOperation* op, outputStream* out) {  // get agent name and options  const char* agent = op->arg(0);  const char* absParam = op->arg(1);  const char* options = op->arg(2);  // If loading a java agent then need to ensure that the java.instrument module is loaded  if (strcmp(agent, "instrument") == 0) {    Thread* THREAD = Thread::current();    ResourceMark rm(THREAD);    HandleMark hm(THREAD);    JavaValue result(T_OBJECT);    Handle h_module_name = java_lang_String::create_from_str("java.instrument", THREAD);    JavaCalls::call_static(&result,SystemDictionary::module_Modules_klass(),vmSymbols::loadModule_name(),                           vmSymbols::loadModule_signature(),h_module_name,THREAD);  }  return JvmtiExport::load_agent_library(agent, absParam, options, out);

     * The redefinition may change method bodies, the constant pool and attributes.     * The redefinition must not add, remove or rename fields or methods, change the     * signatures of methods, or change inheritance.  These restrictions maybe be     * lifted in future versions.  The class file bytes are not checked, verified and installed     * until after the transformations have been applied, if the resultant bytes are in     * error this method will throw an exception.

    public void redefineClasses(ClassDefinition... var1) throws ClassNotFoundException {        if (!this.isRedefineClassesSupported()) {            throw new UnsupportedOperationException("redefineClasses is not supported in this environment");        } else if (var1 == null) {            throw new NullPointerException("null passed as 'definitions' in redefineClasses");        } else {            for(int var2 = 0; var2 < var1.length; ++var2) {                if (var1[var2] == null) {                    throw new NullPointerException("element of 'definitions' is null in redefineClasses");                }            }            if (var1.length != 0) {                this.redefineClasses0(this.mNativeAgent, var1);            }        }    }    private native void redefineClasses0(long var1, ClassDefinition[] var3) throws ClassNotFoundException;

JNIEXPORT void JNICALL Java_sun_instrument_InstrumentationImpl_redefineClasses0  (JNIEnv * jnienv, jobject implThis, jlong agent, jobjectArray classDefinitions) {    redefineClasses(jnienv, (JPLISAgent*)(intptr_t)agent, classDefinitions);}

// class_count - pre-checked to be greater than or equal to 0// class_definitions - pre-checked for NULLjvmtiError JvmtiEnv::RedefineClasses(jint class_count, const jvmtiClassDefinition* class_definitions) {//TODO: add locking  VM_RedefineClasses op(class_count, class_definitions, jvmti_class_load_kind_redefine);  VMThread::execute(&op);  return (op.check_error());} /* end RedefineClasses */

  // Load the caller's new class definition(s) into _scratch_classes.  // Constant pool merging work is done here as needed. Also calls  // compare_and_normalize_class_versions() to verify the class  // definition(s).  jvmtiError load_new_class_versions(TRAPS);

  // Remove all breakpoints in methods of this class  JvmtiBreakpoints& jvmti_breakpoints = JvmtiCurrentBreakpoints::get_jvmti_breakpoints();  jvmti_breakpoints.clearall_in_class_at_safepoint(the_class());

  // Deoptimize all compiled code that depends on this class  flush_dependent_code(the_class, THREAD);

 SystemDictionary::notice_modification();