java的create vm_JNI_CreateJavaVM（Runtime::Create()）
service zygote /system/bin/app_process -Xzygote /system/bin --zygote --start-system-server
socket zygote stream 666
onrestart write /sys/android_power/request_state wake
onrestart write /sys/power/state on
onrestart restart media
onrestart restart netd
前面的关键字service告诉init进程创建一个名为"zygote"的进程，这个zygote进程要执行的程序是/system/bin/app_process，后面是要传给app_process的参数。
/frameworks/base/cmds/app_process/app_main.cppint main(int argc, char* constargv[])
{
AppRuntime runtime(argv[0], computeArgBlockSize(argc, argv));//Process command line arguments//ignore argv[0]
argc--;
argv++;//Everything up to '--' or first non '-' arg goes to the vm.//
//The first argument after the VM args is the "parent dir", which//is currently unused.//
//After the parent dir, we expect one or more the following internal//arguments ://
//--zygote : Start in zygote mode//--start-system-server : Start the system server.//--application : Start in application (stand alone, non zygote) mode.//--nice-name : The nice name for this process.//
//For non zygote starts, these arguments will be followed by//the main class name. All remaining arguments are passed to//the main method of this class.//
//For zygote starts, all remaining arguments are passed to the zygote.//main function.//
//Note that we must copy argument string values since we will rewrite the//entire argument block when we apply the nice name to argv0.
inti;for (i = 0; i < argc; i++) {if (argv[i][0] != '-') {break;
}if (argv[i][1] == '-' && argv[i][2] == 0) {++i; //Skip --.
break;
}
runtime.addOption(strdup(argv[i]));
}//Parse runtime arguments. Stop at first unrecognized option.
bool zygote = false;
bool startSystemServer= false;
bool application= false;
String8 niceName;
String8 className;++i; //Skip unused "parent dir" argument.
while (i
zygote= true;
niceName=ZYGOTE_NICE_NAME;
}else if (strcmp(arg, "--start-system-server") == 0) {
startSystemServer= true;
}else if (strcmp(arg, "--application") == 0) {
application= true;
}else if (strncmp(arg, "--nice-name=", 12) == 0) {
niceName.setTo(arg+ 12);
}else if (strncmp(arg, "--", 2) != 0) {
className.setTo(arg);break;
}else{--i;break;
}
}
Vectorargs;if (!className.isEmpty()) {//We're not in zygote mode, the only argument we need to pass//to RuntimeInit is the application argument.//
//The Remainder of args get passed to startup class main(). Make//copies of them before we overwrite them with the process name.
args.add(application ? String8("application") : String8("tool"));
runtime.setClassNameAndArgs(className, argc- i, argv +i);
}else{// We're in zygote mode.
maybeCreateDalvikCache();if (startSystemServer) {
args.add(String8("start-system-server"));
}charprop[PROP_VALUE_MAX];if (property_get(ABI_LIST_PROPERTY, prop, NULL) == 0) {
LOG_ALWAYS_FATAL("app_process: Unable to determine ABI list from property %s.",
ABI_LIST_PROPERTY);return 11;
}
String8 abiFlag("--abi-list=");
abiFlag.append(prop);
args.add(abiFlag);//In zygote mode, pass all remaining arguments to the zygote//main() method.
for (; i < argc; ++i) {
args.add(String8(argv[i]));
}
}if (!niceName.isEmpty()) {
runtime.setArgv0(niceName.string());
set_process_name(niceName.string());
}if(zygote) {
runtime.start("com.android.internal.os.ZygoteInit", args);
}else if(className) {
runtime.start("com.android.internal.os.RuntimeInit", args);
}else{
fprintf(stderr,"Error: no class name or --zygote supplied.\n");
app_usage();
LOG_ALWAYS_FATAL("app_process: no class name or --zygote supplied.");return 10;
}
}
/frameworks/base/core/jni/AndroidRuntime.cppvoid AndroidRuntime::start(const char* className, const Vector&options)
{/*start the virtual machine*/JniInvocation jni_invocation;
//load libart.so 初始化JniInvocation::JNI_CreateJavaVM_接口
jni_invocation.Init(NULL);
JNIEnv* env;if (startVm(&mJavaVM, &env) != 0) {return;
}
onVmCreated(env);/** Register android functions.*/
if (startReg(env) < 0) {
ALOGE("Unable to register all android natives\n");return;
}char* slashClassName =toSlashClassName(className);
jclass startClass= env->FindClass(slashClassName);if (startClass ==NULL) {
ALOGE("JavaVM unable to locate class '%s'\n", slashClassName);/*keep going*/}else{
jmethodID startMeth= env->GetStaticMethodID(startClass, "main",
"([Ljava/lang/String;)V");if (startMeth ==NULL) {
ALOGE("JavaVM unable to find main() in '%s'\n", className);/*keep going*/}else{
env->CallStaticVoidMethod(startClass, startMeth, strArray);
}
}
free(slashClassName);
ALOGD("Shutting down VM\n");if (mJavaVM->DetachCurrentThread() !=JNI_OK)
ALOGW("Warning: unable to detach main thread\n");if (mJavaVM->DestroyJavaVM() != 0)
ALOGW("Warning: VM did not shut down cleanly\n");
}int AndroidRuntime::startVm(JavaVM** pJavaVM, JNIEnv**pEnv)
{
//JavaVM 参数配置
................if (JNI_CreateJavaVM(pJavaVM, pEnv, &initArgs) < 0) {
ALOGE("JNI_CreateJavaVM failed\n");gotobail;
}
}
JniInvocation是单例类提供了3个接口，但是实际上真正用到的只有一个接口JNI_CreateJavaVM()
classJniInvocation {public:
JniInvocation();~JniInvocation();//Initialize JNI invocation API. library should specifiy a valid//shared library for opening via dlopen providing a JNI invocation//implementation, or null to allow defaulting via//persist.sys.dalvik.vm.lib.
bool Init(const char*library);//Exposes which library is actually loaded from the given name. The//buffer of size PROPERTY_VALUE_MAX will be used to load the system//property for the default library, if necessary. If no buffer is//provided, the fallback value will be used.
static const char* GetLibrary(const char* library, char*buffer);private:bool FindSymbol(void** pointer, const char*symbol);static JniInvocation&GetJniInvocation();
jint JNI_GetDefaultJavaVMInitArgs(void*vmargs);
jint JNI_CreateJavaVM(JavaVM** p_vm, JNIEnv** p_env, void*vm_args);
jint JNI_GetCreatedJavaVMs(JavaVM** vms, jsize size, jsize*vm_count);static JniInvocation*jni_invocation_;void*handle_;
jint (*JNI_GetDefaultJavaVMInitArgs_)(void*);
jint (*JNI_CreateJavaVM_)(JavaVM**, JNIEnv**, void*);
jint (*JNI_GetCreatedJavaVMs_)(JavaVM**, jsize, jsize*);
friend jint JNI_GetDefaultJavaVMInitArgs(void*vm_args);
friend jint JNI_CreateJavaVM(JavaVM** p_vm, JNIEnv** p_env, void*vm_args);
friend jint JNI_GetCreatedJavaVMs(JavaVM** vms, jsize size, jsize*vm_count);
};
JniInvocation::JniInvocation() :
handle_(NULL),
JNI_GetDefaultJavaVMInitArgs_(NULL),
JNI_CreateJavaVM_(NULL),
JNI_GetCreatedJavaVMs_(NULL) {
LOG_ALWAYS_FATAL_IF(jni_invocation_!= NULL, "JniInvocation instance already initialized");
jni_invocation_= this;
}
//加载libart.sobool JniInvocation::Init(const char*library) {
#ifdef HAVE_ANDROID_OScharbuffer[PROPERTY_VALUE_MAX];#else
char* buffer =NULL;#endiflibrary=GetLibrary(library, buffer);
handle_=dlopen(library, RTLD_NOW);if (handle_ ==NULL) {if (strcmp(library, kLibraryFallback) == 0) {//Nothing else to try.
ALOGE("Failed to dlopen %s: %s", library, dlerror());return false;
}//Note that this is enough to get something like the zygote//running, we can't property_set here to fix this for the future//because we are root and not the system user. See//RuntimeInit.commonInit for where we fix up the property to//avoid future fallbacks.http://b/11463182
ALOGW("Falling back from %s to %s after dlopen error: %s",
library, kLibraryFallback, dlerror());
library=kLibraryFallback;
handle_=dlopen(library, RTLD_NOW);if (handle_ ==NULL) {
ALOGE("Failed to dlopen %s: %s", library, dlerror());return false;
}
}if (!FindSymbol(reinterpret_cast(&JNI_GetDefaultJavaVMInitArgs_),"JNI_GetDefaultJavaVMInitArgs")) {return false;
}
//给函数指针JNI_CreateJavaVM_赋值if (!FindSymbol(reinterpret_cast(&JNI_CreateJavaVM_),"JNI_CreateJavaVM")) {return false;
}if (!FindSymbol(reinterpret_cast(&JNI_GetCreatedJavaVMs_),"JNI_GetCreatedJavaVMs")) {return false;
}return true;
}
jint JniInvocation::JNI_CreateJavaVM(JavaVM** p_vm, JNIEnv** p_env, void*vm_args) {
//调用动态加载的函数指针returnJNI_CreateJavaVM_(p_vm, p_env, vm_args);
}bool JniInvocation::FindSymbol(void** pointer, const char*symbol) {*pointer =dlsym(handle_, symbol);if (*pointer ==NULL) {
ALOGE("Failed to find symbol %s: %s\n", symbol, dlerror());
dlclose(handle_);
handle_=NULL;return false;
}return true;
}
// 实现jni.h中的JNI_CreateJavaVM方法extern "C" jint JNI_CreateJavaVM(JavaVM** p_vm, JNIEnv** p_env, void*vm_args) {returnJniInvocation::GetJniInvocation().JNI_CreateJavaVM(p_vm, p_env, vm_args);
}
.....................
libart.so中的方法在Jni_internal.cc中实现
FindSymbol(reinterpret_cast(&JNI_CreateJavaVM_), "JNI_CreateJavaVM"
//Jni_internal.cc//JNI Invocation interface.
extern "C" jint JNI_CreateJavaVM(JavaVM** p_vm, JNIEnv** p_env, void*vm_args) {const JavaVMInitArgs* args = static_cast(vm_args);if (IsBadJniVersion(args->version)) {
LOG(ERROR)<< "Bad JNI version passed to CreateJavaVM:" << args->version;returnJNI_EVERSION;
}
RuntimeOptions options;for (int i = 0; i < args->nOptions; ++i) {
JavaVMOption* option = &args->options[i];
options.push_back(std::make_pair(std::string(option->optionString), option->extraInfo));
}bool ignore_unrecognized = args->ignoreUnrecognized;if (!Runtime::Create(options, ignore_unrecognized)) {returnJNI_ERR;
}
Runtime* runtime =Runtime::Current();bool started = runtime->Start();if (!started) {
delete Thread::Current()->GetJniEnv();
delete runtime->GetJavaVM();
LOG(WARNING)<< "CreateJavaVM failed";returnJNI_ERR;
}*p_env = Thread::Current()->GetJniEnv();*p_vm = runtime->GetJavaVM();returnJNI_OK;
}extern "C" jint JNI_GetCreatedJavaVMs(JavaVM** vms, jsize, jsize*vm_count) {
Runtime* runtime =Runtime::Current();if (runtime ==nullptr) {*vm_count = 0;
}else{*vm_count = 1;
vms[0] = runtime->GetJavaVM();
}returnJNI_OK;
}//Historically unsupported.
extern "C" jint JNI_GetDefaultJavaVMInitArgs(void* /*vm_args*/) {returnJNI_ERR;
}
很明显，除了JNI_CreateJavaVM()，另外两个方法没什么作用
/art/runtime/jni_internal.cc
extern"C" jint JNI_CreateJavaVM(JavaVM** p_vm, JNIEnv** p_env, void*vm_args) {const JavaVMInitArgs* args = static_cast(vm_args);
// 第一大步：创建Runtimeif (!Runtime::Create(options, ignore_unrecognized)) {returnJNI_ERR;
}
Runtime* runtime =Runtime::Current();
// 第二大步：Runtime::start()
bool started= runtime->Start();
if (!started) {
delete Thread::Current()->GetJniEnv();
delete runtime->GetJavaVM();
LOG(WARNING)<< "CreateJavaVM failed";returnJNI_ERR;
}*p_env = Thread::Current()->GetJniEnv();
*p_vm = runtime->GetJavaVM();returnJNI_OK;
}
instance_是Runtime类的静态成员变量，它指向进程中的一个Runtime单例。这个Runtime单例描述的就是当前进程的ART虚拟机实例。
classRuntime {static Runtime*instance_;
InstructionSet instruction_set_;boolis_zygote_;boolmust_relocate_;boolis_concurrent_gc_enabled_;boolis_explicit_gc_disabled_;booldex2oat_enabled_;boolimage_dex2oat_enabled_;
std::stringboot_class_path_string_;
std::stringclass_path_string_;
gc::Heap*heap_;
ThreadList*thread_list_;
InternTable*intern_table_;
ClassLinker*class_linker_;
JavaVMExt*java_vm_;//A non-zero value indicates that a thread has been created but not yet initialized. Guarded by//the shutdown lock so that threads aren't born while we're shutting down.
size_t threads_being_born_ GUARDED_BY(Locks::runtime_shutdown_lock_);
}
/art/runtime/runtime.cc
bool Runtime::Create(const RuntimeOptions&options, bool ignore_unrecognized) { // Runtime是单例，只会被初始化一次
if (Runtime::instance_ !=NULL) {return false;
}
//这个log初始化需要一点点时间，这个时候LOG(TAG)是打印不出来的
InitLogging(NULL);//Calls Locks::Init() as a side effect.
instance_ = newRuntime;if (!instance_->Init(options, ignore_unrecognized)) {
delete instance_;
instance_=NULL;return false;
}return true;
}
bool Runtime::Init(const RuntimeOptions&raw_options, bool ignore_unrecognized) {
CHECK_EQ(sysconf(_SC_PAGE_SIZE), kPageSize);
MemMap::Init();
//解析Andriod VM的配置参数
std::unique_ptroptions(ParsedOptions::Create(raw_options, ignore_unrecognized));if (options.get() ==nullptr) {
LOG(ERROR)<< "Failed to parse options";return false;
}
VLOG(startup)<< "Runtime::Init -verbose:startup enabled";
QuasiAtomic::Startup();
Monitor::Init(options->lock_profiling_threshold_, options->hook_is_sensitive_thread_);
// boot_class_path_string_ =
// /system/framework/core-libart.jar:/system/framework/conscrypt.jar:/system/framework/okhttp.jar:/system/framework/core-junit.jar:
// /system/framework/bouncycastle.jar:/system/framework/ext.jar:/system/framework/framework.jar:/system/framework/telephony-common.jar:
// /system/framework/voip-common.jar:/system/framework/ims-common.jar:/system/framework/mms-common.jar:/system/framework/android.policy.jar:
// /system/framework/apache-xml.jar:/system/framework/HtcLegacy.jar:/system/framework/mediatek-common.jar:/system/framework/mediatek-framework.jar:
// /system/framework/mediatek-telephony-common.jar:/system/framework/dolby_ds.jar
boot_class_path_string_= options->boot_class_path_string_;
class_path_string_= options->class_path_string_;
properties_= options->properties_;
compiler_callbacks_= options->compiler_callbacks_;
patchoat_executable_= options->patchoat_executable_;
must_relocate_= options->must_relocate_;
is_zygote_= options->is_zygote_;
is_explicit_gc_disabled_= options->is_explicit_gc_disabled_;
dex2oat_enabled_= options->dex2oat_enabled_;
image_dex2oat_enabled_= options->image_dex2oat_enabled_;
vfprintf_= options->hook_vfprintf_;
exit_= options->hook_exit_;
abort_= options->hook_abort_;
default_stack_size_= options->stack_size_;
stack_trace_file_= options->stack_trace_file_;
compiler_executable_= options->compiler_executable_;
compiler_options_= options->compiler_options_;
image_compiler_options_= options->image_compiler_options_;
image_location_= options->image_;
max_spins_before_thin_lock_inflation_= options->max_spins_before_thin_lock_inflation_;
monitor_list_= newMonitorList;
monitor_pool_=MonitorPool::Create();
thread_list_= newThreadList;
intern_table_= newInternTable;
verify_= options->verify_;if (options->interpreter_only_) {
GetInstrumentation()->ForceInterpretOnly();
}
heap_= new gc::Heap(options->heap_initial_size_,
options->heap_growth_limit_,
options->heap_min_free_,
options->heap_max_free_,
options->heap_target_utilization_,
options->foreground_heap_growth_multiplier_,
options->heap_maximum_size_,
options->heap_non_moving_space_capacity_,
options->image_,
options->image_isa_,
options->collector_type_,
options->background_collector_type_,
options->parallel_gc_threads_,
options->conc_gc_threads_,
options->low_memory_mode_,
options->long_pause_log_threshold_,
options->long_gc_log_threshold_,
options->ignore_max_footprint_,
options->use_tlab_,
options->verify_pre_gc_heap_,
options->verify_pre_sweeping_heap_,
options->verify_post_gc_heap_,
options->verify_pre_gc_rosalloc_,
options->verify_pre_sweeping_rosalloc_,
options->verify_post_gc_rosalloc_,
options->use_homogeneous_space_compaction_for_oom_,
options->min_interval_homogeneous_space_compaction_by_oom_);
BlockSignals();
InitPlatformSignalHandlers();// Always initialize the signal chain so that any calls to sigaction get
// correctly routed to the next in the chain regardless of whether we
// have claimed the signal or not.
// 加载如下两个库： // dlsym(RTLD_NEXT, "sigaction");
// dlsym(RTLD_DEFAULT, "sigprocmask");
InitializeSignalChain();
if (implicit_null_checks_ || implicit_so_checks_ || implicit_suspend_checks_) {
//所有信号都要交给fault_manager来处理，所以这个很早就初始化了
fault_manager.Init();
// These need to be in a specific order. The null point check handler must be
// after the suspend check and stack overflow check handlers.
if (implicit_suspend_checks_) { //false
suspend_handler_ = new SuspensionHandler(&fault_manager);
}
if (implicit_so_checks_) { //true
stack_overflow_handler_ = new StackOverflowHandler(&fault_manager);
}
if (implicit_null_checks_) { //ture
null_pointer_handler_ = new NullPointerHandler(&fault_manager);
}
if (kEnableJavaStackTraceHandler) { //false
new JavaStackTraceHandler(&fault_manager);
}
}
java_vm_ = new JavaVMExt(this, options.get());
Thread::Startup();
// ClassLinker needs an attached thread, but we can't fully attach a thread without creating
// objects. We can't supply a thread group yet; it will be fixed later. Since we are the main
// thread, we do not get a java peer.
Thread* self = Thread::Attach("main", false, nullptr, false);
class_linker_ = new ClassLinker(intern_table_);if (GetHeap()->HasImageSpace()) { //android虚拟机启动时，这里为真
class_linker_->InitFromImage();if(kIsDebugBuild) {
GetHeap()->GetImageSpace()->VerifyImageAllocations();
}
} else {
.............
}
}
void Runtime::BlockSignals() {
SignalSet signals;
signals.Add(SIGPIPE);
// SIGQUIT is used to dump the runtime's state (including stack traces).
signals.Add(SIGQUIT);
// SIGUSR1 is used to initiate a GC.
signals.Add(SIGUSR1);
#if defined(HAVE_ANDROID_OS) && defined(MTK_DUMMY_PREDUMP)
signals.Add(SIGSTKFLT);
#endif
signals.Block();
}
//art/runtime/signal_set.h
classSignalSet {public:
SignalSet() {if (sigemptyset(&set_) == -1) {
PLOG(FATAL)<< "sigemptyset failed";
}
}void Add(intsignal) {if (sigaddset(&set_, signal) == -1) {
PLOG(FATAL)<< "sigaddset" << signal << "failed";
}
}voidBlock() {if (sigprocmask(SIG_BLOCK, &set_, NULL) == -1) {
PLOG(FATAL)<< "sigprocmask failed";
}
}intWait() {//Sleep in sigwait() until a signal arrives. gdb causes EINTR failures.
intsignal_number;int rc = TEMP_FAILURE_RETRY(sigwait(&set_, &signal_number));if (rc != 0) {
PLOG(FATAL)<< "sigwait failed";
}returnsignal_number;
}private:
sigset_t set_;
};
//art/runtime/runtime_android.cc
voidRuntime::InitPlatformSignalHandlers() {bool enableHtcSigHandler = false;
#ifdef HAVE_ANDROID_OS
LOG(ERROR)<< "Has define HAVE_ANDROID_OS";charprop_value[PROPERTY_VALUE_MAX];
property_get("persist.dalvik.sighandle.enable", prop_value, IsShippingRom() ? "0" : "1");
enableHtcSigHandler= (strcmp(prop_value, "0") != 0);#endif
if(enableHtcSigHandler) {#if defined(__LP64__)LOG(ERROR)<< "Has define __LP64__";//Follow bionic/libc/bionic/pthread_create.cpp to install alter stack on LP64 platform
stack_t ss;
ss.ss_sp= mmap(NULL, SIGSTKSZ, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);if (ss.ss_sp !=MAP_FAILED) {
ss.ss_size=SIGSTKSZ;
ss.ss_flags= 0;int ret = sigaltstack(&ss, NULL);
LOG(INFO)<< StringPrintf("do sigaltstack at %s, size: %zd-byte, ret: %d", __FUNCTION__, ss.ss_size, ret);
}else{
LOG(INFO)<< StringPrintf("do mmap altstack at %s, size: %d-byte, MAP_FAILED", __FUNCTION__, SIGSTKSZ);
}#endif
structsigaction action;
memset(&action, 0, sizeof(action));
sigemptyset(&action.sa_mask);
action.sa_sigaction= NativeCrashSigHandler;//Use the three-argument sa_sigaction handler.
action.sa_flags |=SA_SIGINFO;//Use the alternate signal stack so we can catch stack overflows.
action.sa_flags |=SA_ONSTACK;//initialize for backup native crash handler
memset(&gOldActionSIGABRT, 0, sizeof(gOldActionSIGABRT));
memset(&gOldActionSIGSEGV, 0, sizeof(gOldActionSIGSEGV));//Register the native crash signal.
int rc = 0;
rc+= sigaction(SIGABRT, &action, &gOldActionSIGABRT);
rc+= sigaction(SIGSEGV, &action, &gOldActionSIGSEGV);
CHECK_EQ(rc,0);
}
}
// art/runtime/fault_handler.h
classFaultManager {public:
FaultManager();~FaultManager();voidInit();voidShutdown();voidEnsureArtActionInFrontOfSignalChain();void HandleFault(int sig, siginfo_t* info, void*context); //接受signal时，首先调用这个函数void HandleNestedSignal(int sig, siginfo_t* info, void*context);void AddHandler(FaultHandler* handler, boolgenerated_code); //添加多个FaultHandler来处理消息void RemoveHandler(FaultHandler*handler);//Note that the following two functions are called in the context of a signal handler.//The IsInGeneratedCode() function checks that the mutator lock is held before it//calls GetMethodAndReturnPCAndSP().//TODO: think about adding lock assertions and fake lock and unlock functions.
void GetMethodAndReturnPcAndSp(siginfo_t* siginfo, void* context, mirror::ArtMethod**out_method,
uintptr_t* out_return_pc, uintptr_t*out_sp)
NO_THREAD_SAFETY_ANALYSIS;bool IsInGeneratedCode(siginfo_t* siginfo, void *context, boolcheck_dex_pc)
NO_THREAD_SAFETY_ANALYSIS;private:
std::vectorgenerated_code_handlers_;
std::vectorother_handlers_;structsigaction oldaction_;boolinitialized_;
DISALLOW_COPY_AND_ASSIGN(FaultManager);
};class FaultHandler {public:explicit FaultHandler(FaultManager*manager);virtual ~FaultHandler() {}
FaultManager*GetFaultManager() {returnmanager_;
}virtual bool Action(int sig, siginfo_t* siginfo, void* context) = 0;protected:
FaultManager* constmanager_;private:
DISALLOW_COPY_AND_ASSIGN(FaultHandler);
};
class NullPointerHandler FINAL : public FaultHandler {
public:
explicit NullPointerHandler(FaultManager* manager);
bool Action(int sig, siginfo_t* siginfo, void* context) OVERRIDE;
private:
DISALLOW_COPY_AND_ASSIGN(NullPointerHandler);
};
class StackOverflowHandler FINAL : public FaultHandler {
public:
explicit StackOverflowHandler(FaultManager* manager);
bool Action(int sig, siginfo_t* siginfo, void* context) OVERRIDE;
private:
DISALLOW_COPY_AND_ASSIGN(StackOverflowHandler);
};
//art/runtime/fault_handler.cc//fault_manager是全局变量，虚拟机里面仅此一份
FaultManager fault_manager;
FaultManager::FaultManager() : initialized_(false) {
sigaction(SIGSEGV, nullptr,&oldaction_);
}static void art_fault_handler(int sig, siginfo_t* info, void*context) {
fault_manager.HandleFault(sig, info, context);
}void FaultManager::AddHandler(FaultHandler* handler, boolgenerated_code) {if(generated_code) {
generated_code_handlers_.push_back(handler);
}else{
other_handlers_.push_back(handler);
}
}voidFaultManager::Init() {
CHECK(!initialized_);structsigaction action;
SetUpArtAction(&action);//Set our signal handler now.
int e = sigaction(SIGSEGV, &action, &oldaction_);if (e != 0) {
VLOG(signals)<< "Failed to claim SEGV:" <
}//Make sure our signal handler is called before any user handlers.
ClaimSignalChain(SIGSEGV, &oldaction_);
initialized_= true;
}static void SetUpArtAction(struct sigaction*action) {
action->sa_sigaction = art_fault_handler; //signal就是通过这个函数处理
sigemptyset(&action->sa_mask);
action->sa_flags = SA_SIGINFO |SA_ONSTACK;#if !defined(__APPLE__) && !defined(__mips__)action->sa_restorer =nullptr;#endif}void FaultManager::HandleFault(int sig, siginfo_t* info, void*context) {//BE CAREFUL ALLOCATING HERE INCLUDING USING LOG(...)//
//If malloc calls abort, it will be holding its lock.//If the handler tries to call malloc, it will deadlock.
VLOG(signals) << "Handling fault";if (IsInGeneratedCode(info, context, true)) {
VLOG(signals)<< "in generated code, looking for handler";for (const auto&handler : generated_code_handlers_) {
VLOG(signals)<< "invoking Action on handler" <Action(sig, info, context)) {
#ifdef TEST_NESTED_SIGNAL//In test mode we want to fall through to stack trace handler//on every signal (in reality this will cause a crash on the first//signal).
break;#else
//We have handled a signal so it's time to return from the//signal handler to the appropriate place.
return;#endif}
}
}//We hit a signal we didn't handle. This might be something for which//we can give more information about so call all registered handlers to see//if it is.
for (const auto&handler : other_handlers_) {if (handler->Action(sig, info, context)) {return;
}
}//Set a breakpoint in this function to catch unhandled signals.
art_sigsegv_fault(); //这个就只打了一行log
//如果系统能处理(也就是我们注册的FaultHandler能处理)则不会调用InvokeUserSignalHandler()
//先系统处理，系统处理不了才给用户处理
//Pass this on to the next handler in the chain, or the default if none.
InvokeUserSignalHandler(sig, info, context);
}
NullPointerHandler::NullPointerHandler(FaultManager*manager) : FaultHandler(manager) {
manager_->AddHandler(this, true);
}
StackOverflowHandler::StackOverflowHandler(FaultManager*manager) : FaultHandler(manager) {
manager_->AddHandler(this, true);
}
//art/sigchainlib/sigchain.cc
extern "C" void InvokeUserSignalHandler(int sig, siginfo_t* info, void*context) {//Check the arguments.
CheckSignalValid(sig);//The signal must have been claimed in order to get here. Check it.
if (!user_sigactions[sig].IsClaimed()) {
printf("InvokeUserSignalHandler() call abort()");
abort();
}const struct sigaction& action =user_sigactions[sig].GetAction();if ((action.sa_flags & SA_SIGINFO) == 0) {if (action.sa_handler !=NULL) {
action.sa_handler(sig);
}else{//M: google seems add dummy libsigchain to avoid external module calling sigchain//and change sigchain.cc to link as static library, but we think sigchain.cc only can work//as shared library, so workaround to call bionic c sigaction() manually.//signal(sig, SIG_DFL);
structsigaction sa;
sigemptyset(&sa.sa_mask);
sa.sa_handler=SIG_DFL;
sa.sa_flags=action.sa_flags;
SigActionFnPtr linked_sigaction= reinterpret_cast(linked_sigaction_sym);
linked_sigaction(sig,&sa, nullptr);
raise(sig);
}
}else{if (action.sa_sigaction !=NULL) {
action.sa_sigaction(sig, info, context);
}else{//M: google seems add dummy libsigchain to avoid external module calling sigchain//and change sigchain.cc to link as static library, but we think sigchain.cc only can work//as shared library, so workaround to call bionic c sigaction() manually.//signal(sig, SIG_DFL);
structsigaction sa;
sigemptyset(&sa.sa_mask);
sa.sa_handler=SIG_DFL;
sa.sa_flags=action.sa_flags;
SigActionFnPtr linked_sigaction= reinterpret_cast(linked_sigaction_sym);
linked_sigaction(sig,&sa, nullptr);
raise(sig);
}
}
}
//User's signal handlers//全局变量 定义每种非可靠信号的用户处理方式
// _NSIG = 32
static SignalAction user_sigactions[_NSIG];classSignalAction {public:
SignalAction() : claimed_(false) {
}//Claim the signal and keep the action specified.
void Claim(const struct sigaction&action) {
action_=action;
claimed_= true;
}//Unclaim the signal and restore the old action.
void Unclaim(intsignal) {
claimed_= false;
sigaction(signal,&action_, NULL); //Restore old action.
}//Get the action associated with this signal.
const struct sigaction& GetAction() const{returnaction_;
}//Is the signal claimed?
bool IsClaimed() const{returnclaimed_;
}//Change the recorded action to that specified.
void SetAction(const struct sigaction&action) {
action_=action;
}private:struct sigaction action_; //Action to be performed.
bool claimed_; //Whether signal is claimed or not.
};
// art/runtime/thread.cc
voidThread::Startup() {
CHECK(!is_started_);
is_started_ = true;
{
MutexLock mu(nullptr, *Locks::thread_suspend_count_lock_);
resume_cond_ = new ConditionVariable("Thread resumption condition variable",
*Locks::thread_suspend_count_lock_);
}
//Allocate a TLS slot.
CHECK_PTHREAD_CALL(pthread_key_create, (&Thread::pthread_key_self_, Thread::ThreadExitCallback), "self key");
//Double-check the TLS slot allocation.
if (pthread_getspecific(pthread_key_self_) !=nullptr) {
LOG(FATAL) << "Newly-created pthread TLS slot is not nullptr";
}
}
创建好ART虚拟机堆后，Runtime类的成员函数Init接着又创建了一个JavaVMExt实例。这个JavaVMExt实例最终是要返回给 调用者的，使得调用者可以通过该JavaVMExt实例来和ART虚拟机交互。再接下来，Runtime类的成员函数Init通过Thread类的成员函 数Attach将当前线程作为ART虚拟机的主线程，使得当前线程可以调用ART虚拟机提供的JNI接口。
Runtime类的成员函数GetHeap返回的便是当前ART虚拟机的堆，也就是前面创建的ART虚拟机堆。通过调用Heap类的成员函数 GetContinuousSpaces可以获得堆里面的连续空间列表。如果这个列表的第一个连续空间是一个Image空间，那么就调用 ClassLinker类的静态成员函数CreateFromImage来创建一个ClassLinker对象。
后面我们分析ART虚拟机的垃圾收集机制时会看到，ART虚拟机的堆包含有三个连续空间和一个不连续空间。三个连续空间分别用来分配不同的对象。当第一个连续空间不是Image空间时，就表明当前进程不是Zygote进程，而是安装应用程序时启动的一个dex2oat进程。安装应用程序时启动的 dex2oat进程也会在内部创建一个ART虚拟机，不过这个ART虚拟机是用来将DEX字节码编译成本地机器指令的，而Zygote进程创建的ART虚 拟机是用来运行应用程序的。
frameworks/base/core/jni/AndroidRuntime.cppclassAndroidRuntime {/*static*/ JavaVM* AndroidRuntime::mJavaVM =NULL;/** return a pointer to the VM running in this process*/
static JavaVM* getJavaVM() { return mJavaVM; }/** return a pointer to the JNIEnv pointer for this thread*//*static*/ JNIEnv* AndroidRuntime::getJNIEnv()
{
JNIEnv* env;
JavaVM* vm = AndroidRuntime::getJavaVM();
assert(vm != NULL);
if (vm->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK)
return NULL;
return env;
}
}
// art/runtime/thread.cc
//创建TLS变量，即线程本地存储变量voidThread::Startup() {
CHECK(!is_started_);
is_started_= true;
{
MutexLock mu(nullptr,*Locks::thread_suspend_count_lock_);
resume_cond_= new ConditionVariable("Thread resumption condition variable",*Locks::thread_suspend_count_lock_);
}//Allocate a TLS slot.
CHECK_PTHREAD_CALL(pthread_key_create, (&Thread::pthread_key_self_, Thread::ThreadExitCallback), "self key");
//Double-check the TLS slot allocation.
if (pthread_getspecific(pthread_key_self_) !=nullptr) {
LOG(FATAL)<< "Newly-created pthread TLS slot is not nullptr";
}
}
inline Thread*Thread::Current() {//We rely on Thread::Current returning NULL for a detached thread, so it's not obvious//that we can replace this with a direct %fs access on x86.
if (!is_started_) {returnNULL;
}else{void* thread = pthread_getspecific(Thread::pthread_key_self_);return reinterpret_cast(thread);
}
}//JNI methods
JNIEnvExt* GetJniEnv() const{returntlsPtr_.jni_env;
}struct JNIEnvExt : publicJNIEnv {
JNIEnvExt(Thread* self, JavaVMExt*vm);~JNIEnvExt();
Thread* constself;
JavaVMExt*vm;
}void Thread::Init(ThreadList* thread_list, JavaVMExt*java_vm) {//This function does all the initialization that must be run by the native thread it applies to.//(When we create a new thread from managed code, we allocate the Thread* in Thread::Create so//we can handshake with the corresponding native thread when it's ready.) Check this native//thread hasn't been through here already...
CHECK(Thread::Current() ==nullptr);
SetUpAlternateSignalStack();
InitCpu();
InitTlsEntryPoints();
RemoveSuspendTrigger();
InitCardTable();
InitTid();//Set pthread_self_ ahead of pthread_setspecific, that makes Thread::Current function, this//avoids pthread_self_ ever being invalid when discovered from Thread::Current().
tlsPtr_.pthread_self =pthread_self();
CHECK(is_started_);
CHECK_PTHREAD_CALL(pthread_setspecific, (Thread::pthread_key_self_,this), "attach self");
DCHECK_EQ(Thread::Current(),this);
tls32_.thin_lock_thread_id= thread_list->AllocThreadId(this);
InitStackHwm();
tlsPtr_.jni_env= new JNIEnvExt(this, java_vm);
thread_list->Register(this);
}
Thread* Thread::Attach(const char* thread_name, boolas_daemon, jobject thread_group,boolcreate_peer) {
Thread*self;
Runtime* runtime =Runtime::Current();if (runtime ==nullptr) {
LOG(ERROR)<< "Thread attaching to non-existent runtime:" <
}
{
MutexLock mu(nullptr,*Locks::runtime_shutdown_lock_);if (runtime->IsShuttingDownLocked()) {
LOG(ERROR)<< "Thread attaching while runtime is shutting down:" <
}else{
Runtime::Current()->StartThreadBirth();
self = new Thread(as_daemon);
self->Init(runtime->GetThreadList(), runtime->GetJavaVM());
Runtime::Current()->EndThreadBirth();
}
}
CHECK_NE(self->GetState(), kRunnable);
self->SetState(kNative);//If we're the main thread, ClassLinker won't be created until after we're attached,//so that thread needs a two-stage attach. Regular threads don't need this hack.//In the compiler, all threads need this hack, because no-one's going to be getting//a native peer!
if(create_peer) {
self->CreatePeer(thread_name, as_daemon, thread_group);
}else{//These aren't necessary, but they improve diagnostics for unit tests & command-line tools.
if (thread_name !=nullptr) {
self->tlsPtr_.name->assign(thread_name);
::art::SetThreadName(thread_name);
}else if (self->GetJniEnv()->check_jni) {
LOG(WARNING)<< *Thread::Current() << "attached without supplying a name";
}
}returnself;
}
art/runtime/gc/heap.cc
Heap::Heap(size_t initial_size, size_t growth_limit, size_t min_free, size_t max_free,
....................
lgrind()),
use_tlab_(use_tlab),
main_space_backup_(nullptr),
min_interval_homogeneous_space_compaction_by_oom_(
min_interval_homogeneous_space_compaction_by_oom),
last_time_homogeneous_space_compaction_by_oom_(NanoTime()),
use_homogeneous_space_compaction_for_oom_(use_homogeneous_space_compaction_for_oom) {
ChangeCollector(desired_collector_type_);
live_bitmap_.reset(new accounting::HeapBitmap(this));
mark_bitmap_.reset(new accounting::HeapBitmap(this));//Requested begin for the alloc space, to follow the mapped image and oat files
byte* requested_alloc_space_begin =nullptr;if (!image_file_name.empty()) {
std::string error_msg;
space::ImageSpace* image_space =space::ImageSpace::Create(image_file_name.c_str(),
image_instruction_set,&error_msg);if (image_space !=nullptr) {
AddSpace(image_space);//Oat files referenced by image files immediately follow them in memory, ensure alloc space//isn't going to get in the middle
byte* oat_file_end_addr = image_space->GetImageHeader().GetOatFileEnd();
CHECK_GT(oat_file_end_addr, image_space->End());
requested_alloc_space_begin=AlignUp(oat_file_end_addr, kPageSize);
}else{
LOG(WARNING)<< "Could not create image space with image file '" << image_file_name << "'. "
<< "Attempting to fall back to imageless running. Error was: " <
}
}
}
参数original_image_file_name描述的就是前面提到的Image文件的路径。如果它的值不等于空的话，那么就以它为参数，调用 ImageSpace类的静态成员函数Create创建一个Image空间，并且调用Heap类的成员函数AddContinuousSpace将该 Image空间作为本进程的ART虚拟机堆的第一个连续空间。
art/runtime/gc/space/image_space.cc
/*我们假设参数original_image_file_name的值等于“/system/framework/boot.art”，那么ImageSpace类的静态成员函数Create的执行逻辑实际上就是：
1. 检查文件/system/framework/boot.art是否存在。如果存在，那么就以它为参数，创建一个Image空间。否则的话，执行下一步。
2. 检查文件/data/dalvik-cache/system@framework@boot.art@classes.dex是否存在。如果存在，那么就以它为参数，创建一个Image空间。否则的话，执行下一步。
3. 调用ImageSpace类的静态成员函数GenerateImage在/data/dalvik-cache目录下生成一个 system@framework@boot.art@classes.dex，然后再以该文件为参数，创建一个Image空间。
*/
ImageSpace* ImageSpace::Create(const char*image_location,constInstructionSet image_isa,
std::string*error_msg) {const bool found_image = FindImageFilename(image_location, image_isa, &system_filename,&has_system, &cache_filename, &dalvik_cache_exists,&has_cache, &is_global_cache);
ImageSpace*space;
bool relocate= Runtime::Current()->ShouldRelocate();
bool can_compile= Runtime::Current()->IsImageDex2OatEnabled();if (!can_compile) {*error_msg = "Not attempting to compile image because -Xnoimage-dex2oat";returnnullptr;
}else if (!dalvik_cache_exists) {*error_msg = StringPrintf("No place to put generated image.");returnnullptr;
}else if (!ImageCreationAllowed(is_global_cache, error_msg)) {returnnullptr;
}else if (!GenerateImage(cache_filename, image_isa, error_msg)) {
*error_msg = StringPrintf("Failed to generate image '%s': %s",
cache_filename.c_str(), error_msg->c_str());//We failed to create files, remove any possibly garbage output.//Since ImageCreationAllowed was true above, we are the zygote//and therefore the only process expected to generate these for//the device.
PruneDexCache(image_isa);returnnullptr;
}else{//Note that we must not use the file descriptor associated with//ScopedFlock::GetFile to Init the image file. We want the file//descriptor (and the associated exclusive lock) to be released when//we leave Create.
ScopedFlock image_lock;
image_lock.Init(cache_filename.c_str(), error_msg);
space= ImageSpace::Init(cache_filename.c_str(), image_location, true, error_msg);if (space ==nullptr) {*error_msg = StringPrintf("Failed to load generated image '%s': %s",
cache_filename.c_str(), error_msg->c_str());
}returnspace;
}
}static bool GenerateImage(const std::string&image_file_name) {const std::string boot_class_path_string(Runtime::Current()->GetBootClassPathString());
std::vector<:string>boot_class_path;
Split(boot_class_path_string,':', boot_class_path);
......
std::vector<:string>arg_vector;
std::string dex2oat(GetAndroidRoot());
dex2oat+= (kIsDebugBuild ? "/bin/dex2oatd" : "/bin/dex2oat");
arg_vector.push_back(dex2oat);
std::string image_option_string("--image=");
image_option_string+=image_file_name;
arg_vector.push_back(image_option_string);
......for (size_t i = 0; i < boot_class_path.size(); i++) {
arg_vector.push_back(std::string("--dex-file=") +boot_class_path[i]);
}
std::string oat_file_option_string("--oat-file=");
oat_file_option_string+=image_file_name;
oat_file_option_string.erase(oat_file_option_string.size()- 3);
oat_file_option_string+= "oat";
arg_vector.push_back(oat_file_option_string);
......
return Exec(arg_vector, error_msg);
}
#echo $BOOTCLASSPATH
/system/framework/core-libart.jar:/system/framework/conscrypt.jar:/system/framework/okhttp.jar:/system/framework/core-junit.jar:/system/framework/bouncycastle.jar:/system/framework/ext.jar:/system/framework/framework.jar:/system/framework/telephony-common.jar:/system/framework/voip-common.jar:/system/framework/ims-common.jar:/system/framework/mms-common.jar:/system/framework/android.policy.jar:/system/framework/apache-xml.jar:/system/framework/HtcLegacy.jar:/system/framework/mediatek-common.jar:/system/framework/mediatek-framework.jar:/system/framework/mediatek-telephony-common.jar:/system/framework/dolby_ds.jar
-----------------------------
ImageSpace类的静态成员函数GenerateImage实际上就调用dex2oat工具在/data/dalvik-cache目录下生成 两个文件：system@framework@boot.art@classes.dex和 system@framework@boot.art@classes.oat。
system@framework@boot.art@classes.dex是一个Image文件，通过--image选项传递给dex2oat工具， 里面包含了一些需要在Zygote进程启动时预加载的类。这些需要预加载的类由/system/framework/framework.jar文件里面 的preloaded-classes文件指定。
system@framework@boot.art@classes.oat是一个OAT文件，通过--oat-file选项传递给dex2oat工 具，它是由系统启动路径中指定的jar文件生成的。每一个jar文件都通过一个--dex-file选项传递给dex2oat工具。这样dex2oat工 具就可以将它们所包含的classes.dex文件里面的DEX字节码翻译成本地机器指令。
这样，我们就得到了一个包含有多个DEX文件的OAT文件system@framework@boot.art@classes.oat。
通过上面的分析，我们就清楚地看到了ART运行时所需要的OAT文件是如何产生的了。其中，由系统启动类路径指定的DEX文件生成的OAT文件称为类型为 BOOT的OAT文件，即boot.art文件。有了这个背景知识之后，接下来我们就继续分析ART运行时是如何加载OAT文件的。
art/runtime/utils.cc
bool Exec(std::vector<:string>& arg_vector, std::string*error_msg) {const std::string command_line(Join(arg_vector, ' '));
CHECK_GE(arg_vector.size(), 1U)<
const char* program = arg_vector[0].c_str();
std::vectorargs;for (size_t i = 0; i < arg_vector.size(); ++i) {const std::string& arg =arg_vector[i];char* arg_str = const_cast(arg.c_str());
CHECK(arg_str!= nullptr) <
args.push_back(arg_str);
}
args.push_back(NULL);//fork and exec
pid_t pid = fork();if (pid == 0) {//no allocation allowed between fork and exec//change process groups, so we don't get reaped by ProcessManager
setpgid(0, 0);
execv(program,&args[0]);
PLOG(ERROR)<< "Failed to execv(" << command_line << ")";
exit(1);
}else{if (pid == -1) {*error_msg = StringPrintf("Failed to execv(%s) because fork failed: %s",
command_line.c_str(), strerror(errno));return false;
}//wait for subprocess to finish
intstatus;
pid_t got_pid= TEMP_FAILURE_RETRY(waitpid(pid, &status, 0));if (got_pid !=pid) {*error_msg = StringPrintf("Failed after fork for execv(%s) because waitpid failed: "
"wanted %d, got %d: %s",
command_line.c_str(), pid, got_pid, strerror(errno));return false;
}if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {*error_msg = StringPrintf("Failed execv(%s) because non-0 exit status",
command_line.c_str());return false;
}
}return true;
}
ART运行时提供了一个OatFile类，通过调用它的静态成员函数Open可以在本进程中加载OAT文件，它的实现如下所示：
/art/runtime/oat_file.cc
OatFile* OatFile::Open(const std::string&filename,const std::string&location,byte*requested_base,
bool executable,
std::string*error_msg) {
CHECK(!filename.empty()) <
CheckLocation(filename);
std::unique_ptrret;if (kUsePortableCompiler &&executable) {//If we are using PORTABLE, use dlopen to deal with relocations.//
//We use our own ELF loader for Quick to deal with legacy apps that//open a generated dex file by name, remove the file, then open//another generated dex file with the same name.
ret.reset(OpenDlopen(filename, location, requested_base, error_msg));
}else{//If we aren't trying to execute, we just use our own ElfFile loader for a couple reasons://
//On target, dlopen may fail when compiling due to selinux restrictions on installd.//
//On host, dlopen is expected to fail when cross compiling, so fall back to OpenElfFile.//This won't work for portable runtime execution because it doesn't process relocations.
std::unique_ptrfile(OS::OpenFileForReading(filename.c_str()));if (file.get() ==NULL) {*error_msg = StringPrintf("Failed to open oat filename for reading: %s", strerror(errno));returnnullptr;
}
ret.reset(OpenElfFile(file.get(), location, requested_base,false, executable, error_msg));//It would be nice to unlink here. But we might have opened the file created by the//ScopedLock, which we better not delete to avoid races. TODO: Investigate how to fix the API//to allow removal when we know the ELF must be borked.
}returnret.release();
}
OatFile* OatFile::OpenDlopen(const std::string&elf_filename,const std::string&location,byte*requested_base,
std::string*error_msg) {
std::unique_ptr oat_file(new OatFile(location, true));
bool success= oat_file->Dlopen(elf_filename, requested_base, error_msg);if (!success) {returnnullptr;
}returnoat_file.release();
}
bool OatFile::Dlopen(const std::string& elf_filename, byte*requested_base,
std::string*error_msg) {char* absolute_path =realpath(elf_filename.c_str(), NULL);if (absolute_path ==NULL) {*error_msg = StringPrintf("Failed to find absolute path for '%s'", elf_filename.c_str());return false;
}
dlopen_handle_=dlopen(absolute_path, RTLD_NOW);
free(absolute_path);if (dlopen_handle_ ==NULL) {*error_msg = StringPrintf("Failed to dlopen '%s': %s", elf_filename.c_str(), dlerror());return false;
}
begin_= reinterpret_cast(dlsym(dlopen_handle_, "oatdata"));if (begin_ ==NULL) {*error_msg = StringPrintf("Failed to find oatdata symbol in '%s': %s", elf_filename.c_str(),
dlerror());return false;
}if (requested_base != NULL && begin_ !=requested_base) {*error_msg = StringPrintf("Failed to find oatdata symbol at expected address: "
"oatdata=%p != expected=%p /proc/self/maps:\n",
begin_, requested_base);
ReadFileToString("/proc/self/maps", error_msg);return false;
}
end_= reinterpret_cast(dlsym(dlopen_handle_, "oatlastword"));if (end_ ==NULL) {*error_msg = StringPrintf("Failed to find oatlastword symbol in '%s': %s", elf_filename.c_str(),
dlerror());return false;
}//Readjust to be non-inclusive upper bound.
end_ +=sizeof(uint32_t);returnSetup(error_msg);
}
OatFile* OatFile::OpenElfFile(File*file,const std::string&location,byte*requested_base,
bool writable,
bool executable,
std::string*error_msg) {
std::unique_ptr oat_file(newOatFile(location, executable));
bool success= oat_file->ElfFileOpen(file, requested_base, writable, executable, error_msg);if (!success) {
CHECK(!error_msg->empty());returnnullptr;
}returnoat_file.release();
}
...................................
classRuntime {static Runtime*instance_;
InstructionSet instruction_set_;boolis_zygote_;boolmust_relocate_;boolis_concurrent_gc_enabled_;boolis_explicit_gc_disabled_;booldex2oat_enabled_;boolimage_dex2oat_enabled_;
std::stringboot_class_path_string_;
std::stringclass_path_string_;
gc::Heap*heap_;
ThreadList*thread_list_;
InternTable*intern_table_;
ClassLinker*class_linker_;
JavaVMExt*java_vm_;
}
//zygote64 进程的初始化
01-04 15:39:58.140 394 394E art : Runtime::Init()01-04 15:39:58.148 394 394 E art : newgc::Heap()01-04 15:39:58.151 394 394E art : space::ImageSpace::Create()01-04 15:39:58.151 394 394E art : ImageSpace::Create()...01-04 15:39:58.178 394 394E art : ...............01-04 15:39:58.178 394 394E art : GenerateImage() .....01-04 15:39:58.199 394 394 E art : GenerateImage: /system/bin/dex2oat --image=/data/dalvik-cache/arm64/system@framework@boot.art --dex-file=/system/framework/core-libart.jar --dex-file=/system/framework/conscrypt.jar --dex-file=/system/framework/okhttp.jar --dex-file=/system/framework/core-junit.jar --dex-file=/system/framework/bouncycastle.jar --dex-file=/system/framework/ext.jar --dex-file=/system/framework/framework.jar --dex-file=/system/framework/telephony-common.jar --dex-file=/system/framework/voip-common.jar --dex-file=/system/framework/ims-common.jar --dex-file=/system/framework/mms-common.jar --dex-file=/system/framework/android.policy.jar --dex-file=/system/framework/apache-xml.jar --dex-file=/system/framework/HtcLegacy.jar --dex-file=/system/framework/mediatek-common.jar --dex-file=/system/framework/mediatek-framework.jar --dex-file=/system/framework/mediatek-telephony-common.jar --dex-file=/system/framework/dolby_ds.jar --oat-file=/data/dalvik-cache/arm64/system@framework@boot.oat --instruction-set=arm64 --instruction-set-feature
...............................//dex2oat编译image文件
01-04 15:41:31.783 394 394 E art : image_space !=nullptr01-04 15:41:31.871 394 394E art : BlockSignals() and InitPlatformSignalHandlers()01-04 15:41:31.871 394 394 E art : boot_class_path_string_:/system/framework/core-libart.jar:/system/framework/conscrypt.jar:/system/framework/okhttp.jar:/system/framework/core-junit.jar:/system/framework/bouncycastle.jar:/system/framework/ext.jar:/system/framework/framework.jar:/system/framework/telephony-common.jar:/system/framework/voip-common.jar:/system/framework/ims-common.jar:/system/framework/mms-common.jar:/system/framework/android.policy.jar:/system/framework/apache-xml.jar:/system/framework/HtcLegacy.jar:/system/framework/mediatek-common.jar:/system/framework/mediatek-framework.jar:/system/framework/mediatek-telephony-common.jar:/system/framework/dolby_ds.jar01-04 15:41:31.871 394 394E art : class_path_string_:01-04 15:41:31.871 394 394 E art : image_location_:/system/framework/boot.art01-04 15:41:31.871 394 394E art : signals.Add(SIGSTKFLT);01-04 15:41:31.871 394 394E art : Runtime::InitPlatformSignalHandlers()01-04 15:41:31.871 394 394E art : Has define HAVE_ANDROID_OS01-04 15:41:31.871 394 394 I art : buildType: userdebug, roAaReport: , roSf: 0
01-04 15:41:31.871 394 394 E art : enableHtcSigHandler == true
01-04 15:41:31.871 394 394E art : Has define __LP64__01-04 15:41:31.871 394 394 I art : do sigaltstack at InitPlatformSignalHandlers, size: 12288-byte, ret: 0
01-04 15:41:31.871 394 394 E art : Runtime::InitPlatformSignalHandlers() action.sa_sigaction =NativeCrashSigHandler01-04 15:41:31.871 394 394E art : InitializeSignalChain()01-04 15:41:31.871 394 394E art : fault_manager.Init()01-04 15:41:31.871 394 394 E art : SetUpArtAction() action->sa_sigaction =art_fault_handler;01-04 15:41:31.871 394 394 E art : newStackOverflowHandler01-04 15:41:31.871 394 394 E art : newNullPointerHandler01-04 15:41:31.881 394 394 E art : HTC+++ is_zygote_ = true
01-04 15:41:31.881 394 394 E art : GetHeap()->HasImageSpace()01-04 15:41:31.886 394 394E art : after initImageSpace01-04 15:41:31.893 394 394 I art : Runtime::Start Zygote: isShippingRom=0
//dex2oat参数：
GenerateImage:/system/bin/dex2oat--image=/data/dalvik-cache/arm64/system@framework@boot.art--dex-file=/system/framework/core-libart.jar--dex-file=/system/framework/conscrypt.jar--dex-file=/system/framework/okhttp.jar--dex-file=/system/framework/core-junit.jar--dex-file=/system/framework/bouncycastle.jar--dex-file=/system/framework/ext.jar--dex-file=/system/framework/framework.jar--dex-file=/system/framework/telephony-common.jar--dex-file=/system/framework/voip-common.jar--dex-file=/system/framework/ims-common.jar--dex-file=/system/framework/mms-common.jar--dex-file=/system/framework/android.policy.jar--dex-file=/system/framework/apache-xml.jar--dex-file=/system/framework/HtcLegacy.jar--dex-file=/system/framework/mediatek-common.jar--dex-file=/system/framework/mediatek-framework.jar--dex-file=/system/framework/mediatek-telephony-common.jar--dex-file=/system/framework/dolby_ds.jar--oat-file=/data/dalvik-cache/arm64/system@framework@boot.oat--instruction-set=arm64 --instruction-set-feature
frameworks/base/cmds/app_process/app_main.cppvoidmain() {//解析虚拟机相关的参数
AppRuntime runtime(argv[0], computeArgBlockSize(argc, argv));if(zygote) {
runtime.start("com.android.internal.os.ZygoteInit", args, zygote);
}else if(className) {
runtime.start("com.android.internal.os.RuntimeInit", args, zygote);
}else{
fprintf(stderr,"Error: no class name or --zygote supplied.\n");
app_usage();
LOG_ALWAYS_FATAL("app_process: no class name or --zygote supplied.");return 10;
}
}/frameworks/base/core/jni/AndroidRuntime.cppvoid AndroidRuntime::start(const char* className, const Vector& options, boolzygote)
{//注册虚拟机创建的相关jni函数，主要是为了JNI_CreateJavaVM函数的调用
JniInvocation jni_invocation;//Init函数会加载libart.so库，使用dlopen()给函数指针JNI_CreateJavaVM找到对应的接口
jni_invocation.Init(NULL);//创建虚拟机
JNIEnv*env;if (startVm(&mJavaVM, &env, zygote) != 0) {return;
}//注册相关的jni函数
if (startReg(env) < 0) {
ALOGE("Unable to register all android natives\n");return;
}/** Start VM. This thread becomes the main thread of the VM, and will
* not return until the VM exits.*/
char* slashClassName =toSlashClassName(className);
jclass startClass= env->FindClass(slashClassName);if (startClass ==NULL) {
ALOGE("JavaVM unable to locate class '%s'\n", slashClassName);/*keep going*/}else{//找到com.android.internal.os.ZygoteInit.java类的main()函数method id 然后去执行
jmethodID startMeth = env->GetStaticMethodID(startClass, "main", "([Ljava/lang/String;)V");if (startMeth ==NULL) {
ALOGE("JavaVM unable to find main() in '%s'\n", className);
}else{
env->CallStaticVoidMethod(startClass, startMeth, strArray);
}
}
}int AndroidRuntime::startVm(JavaVM** pJavaVM, JNIEnv** pEnv, boolzygote)
{if (JNI_CreateJavaVM(pJavaVM, pEnv, &initArgs) < 0) {
ALOGE("JNI_CreateJavaVM failed\n");return -1;
}return 0;
}
java_vm_ext.cc//JNI Invocation interface.
extern "C" jint JNI_CreateJavaVM(JavaVM** p_vm, JNIEnv** p_env, void*vm_args) {const JavaVMInitArgs* args = static_cast(vm_args);
RuntimeOptions options;for (int i = 0; i < args->nOptions; ++i) {
JavaVMOption* option = &args->options[i];
options.push_back(std::make_pair(std::string(option->optionString), option->extraInfo));
}bool ignore_unrecognized = args->ignoreUnrecognized;//创建Runtime
if (!Runtime::Create(options, ignore_unrecognized)) {
ATRACE_END();returnJNI_ERR;
}
Runtime* runtime =Runtime::Current();//调用runtime->Start();
bool started = runtime->Start();*p_env = Thread::Current()->GetJniEnv();*p_vm = runtime->GetJavaVM();returnJNI_OK;
}