Android Framework学习条记（4）----Zygote进程

玛卡巴卡的卡巴卡玛  金牌会员 | 2024-7-22 16:50:26 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 839|帖子 839|积分 2517

Zygote的启动流程

Init进程启动后，会加载并执行init.rc文件。该.rc文件中，就包含启动Zygote进程的Action。详见“RC文件剖析”章节。
根据Zygote对应的RC文件，可知Zygote进程是由/system/bin/app_process程序来创建的。
app_process大抵处理流程如下，详见“app_process剖析”章节。

  • 创建AppRuntime
  • 整理传参，并将相应参数传给Runtime或Zygote进程。
  • 利用Runtime调用start方法，传入“com.android.internal.os.ZygoteInit”类和zygote传参，启动zygote。
class AppRuntime 继承自 public AndroidRuntime。调用start方法后，将执行以下步调。详见"AndroidRuntime剖析"章节。

  • 搜集JVM参数，启动VM
  • 注册JNI方法。
  • 利用java的反射，调用com.android.internal.os.ZygoteInit类中的main方法，创建zygote进程。

Zygote代码分析

RC文件剖析

Init.rc中的Zygote内容

init.rc中涉及Zygote的部分有五处。从代码中可以看出，在初始化晚期阶段late-init，会触发Zygote-start行为，而该行为会创建zygote，以及zygote_secondary两个进程。
  1. import /system/etc/init/hw/init.${ro.zygote}.rc
  3. import /system/etc/init/hw/init.boringssl.${ro.zygote}.rc
  5. ...
  7. on late-init
  9.    trigger zygote-start
  11. ...
  13. on zygote-start
  15.     wait_for_prop odsign.verification.done 1
  17.     # A/B update verifier that marks a successful boot.
  19.     exec_start update_verifier
  21.     start statsd
  23.     start netd
  25.     start zygote
  27.     start zygote_secondary
  29. ...
  31. on userspace-reboot-resume
  33.   trigger userspace-reboot-fs-remount
  35.   trigger post-fs-data
  37.   trigger zygote-start
  39.   trigger early-boot
  41.   trigger boot
复制代码
关于怎样启动这两个进程，可以参照init.${ro.zygote}.rc。${ro.zygote}的值，可以通过shell指令“getprop ro.zygote”获取。以下图为例，zygote64_32代表64模式为主，32位模式为辅。

init.zygote64_32.rc

引用了init.zygote64.rc
声明了一个名字为“zygote_secondary”的service。该service将有/system/bin/app_process进程来启动。其中以“-”开头的是JVM参数，-Xzygote /system/bin。以“--”开头的是进程参数，--zygote --socket-name=zygote_secondary --enable-lazy-preload。
创建了两个socket，名字为zygote_secondary和usap_pool_secondary。
  1. import /system/etc/init/hw/init.zygote64.rc
  3. service zygote_secondary /system/bin/app_process32 -Xzygote /system/bin --zygote --socket-name=zygote_secondary --enable-lazy-preload
  4.     class main
  5.     priority -20
  6.     user root
  7.     group root readproc reserved_disk
  8.     socket zygote_secondary stream 660 root system
  9.     socket usap_pool_secondary stream 660 root system
  10.     onrestart restart zygote
  11.     task_profiles ProcessCapacityHigh MaxPerformance
复制代码
init.zygote64.rc

声明了一个名字为“zygote”的service。该service将有/system/bin/app_process进程来启动。其中以“-”开头的是JVM参数，-Xzygote /system/bin。以“--”开头的是进程参数，--zygote --start-system-server --socket-name=zygote。
创建了两个socket，名字为zygote和usap_pool_primary。
  1. service zygote /system/bin/app_process64 -Xzygote /system/bin --zygote --start-system-server --socket-name=zygote
  2.     class main
  3.     priority -20
  4.     user root
  5.     group root readproc reserved_disk
  6.     socket zygote stream 660 root system
  7.     socket usap_pool_primary stream 660 root system
  8.     onrestart exec_background - system system -- /system/bin/vdc volume abort_fuse
  9.     onrestart write /sys/power/state on
  10.     # NOTE: If the wakelock name here is changed, then also
  11.     # update it in SystemSuspend.cpp
  12.     onrestart write /sys/power/wake_lock zygote_kwl
  13.     onrestart restart audioserver
  14.     onrestart restart cameraserver
  15.     onrestart restart media
  16.     onrestart restart --only-if-running media.tuner
  17.     onrestart restart netd
  18.     onrestart restart wificond
  19.     task_profiles ProcessCapacityHigh MaxPerformance
  20.     critical window=${zygote.critical_window.minute:-off} target=zygote-fatal
复制代码
init.boringssl.zygote64_32.rc

包含的都是在某些条件下触发的自测进程。相识即可。
  1. on init && property:ro.product.cpu.abilist32=*
  2.     exec_start boringssl_self_test32
  3. on init && property:ro.product.cpu.abilist64=*
  4.     exec_start boringssl_self_test64
  5. on property:apexd.status=ready && property:ro.product.cpu.abilist32=*
  6.     exec_start boringssl_self_test_apex32
  7. on property:apexd.status=ready && property:ro.product.cpu.abilist64=*
  8.     exec_start boringssl_self_test_apex64
复制代码
app_process剖析 

frameworks/base/cmds/app_process/app_main.cpp
  1. int main(int argc, char* const argv[])
  2. {
  3.     if (!LOG_NDEBUG) {
  4.       String8 argv_String;
  5.       for (int i = 0; i < argc; ++i) {
  6.         argv_String.append(""");
  7.         argv_String.append(argv[i]);
  8.         argv_String.append("" ");
  9.       }
  10.       ALOGV("app_process main with argv: %s", argv_String.c_str());
  11.     }
  13. //步骤1：创建Runtime.--------------------------------------------
  14.     AppRuntime runtime(argv[0], computeArgBlockSize(argc, argv));
  15.     // Process command line arguments
  16.     // ignore argv[0]
  17.     argc--;
  18.     argv++;
  20.     // Everything up to '--' or first non '-' arg goes to the vm.
  21.     //
  22.     // The first argument after the VM args is the "parent dir", which
  23.     // is currently unused.
  24.     //
  25.     // After the parent dir, we expect one or more the following internal
  26.     // arguments :
  27.     //
  28.     // --zygote : Start in zygote mode
  29.     // --start-system-server : Start the system server.
  30.     // --application : Start in application (stand alone, non zygote) mode.
  31.     // --nice-name : The nice name for this process.
  32.     //
  33.     // For non zygote starts, these arguments will be followed by
  34.     // the main class name. All remaining arguments are passed to
  35.     // the main method of this class.
  36.     //
  37.     // For zygote starts, all remaining arguments are passed to the zygote.
  38.     // main function.
  39.     //
  40.     // Note that we must copy argument string values since we will rewrite the
  41.     // entire argument block when we apply the nice name to argv0.
  42.     //
  43.     // As an exception to the above rule, anything in "spaced commands"
  44.     // goes to the vm even though it has a space in it.
  45.     const char* spaced_commands[] = { "-cp", "-classpath" };
  46.     // Allow "spaced commands" to be succeeded by exactly 1 argument (regardless of -s).
  47.     bool known_command = false;
  51. //步骤2：解析传参，将'-'开头的参数传给Runtime.--------------------------------------------
  52.     int i;
  53.     for (i = 0; i < argc; i++) {
  54.         if (known_command == true) {
  55.           runtime.addOption(strdup(argv[i]));
  56.           // The static analyzer gets upset that we don't ever free the above
  57.           // string. Since the allocation is from main, leaking it doesn't seem
  58.           // problematic. NOLINTNEXTLINE
  59.           ALOGV("app_process main add known option '%s'", argv[i]);
  60.           known_command = false;
  61.           continue;
  62.         }
  64.         for (int j = 0;
  65.              j < static_cast<int>(sizeof(spaced_commands) / sizeof(spaced_commands[0]));
  66.              ++j) {
  67.           if (strcmp(argv[i], spaced_commands[j]) == 0) {
  68.             known_command = true;
  69.             ALOGV("app_process main found known command '%s'", argv[i]);
  70.           }
  71.         }
  73.         if (argv[i][0] != '-') {
  74.             break;
  75.         }
  76.         if (argv[i][1] == '-' && argv[i][2] == 0) {
  77.             ++i; // Skip --.
  78.             break;
  79.         }
  81.         runtime.addOption(strdup(argv[i]));
  82.         // The static analyzer gets upset that we don't ever free the above
  83.         // string. Since the allocation is from main, leaking it doesn't seem
  84.         // problematic. NOLINTNEXTLINE
  85.         ALOGV("app_process main add option '%s'", argv[i]);
  86.     }
  88.     // Parse runtime arguments.  Stop at first unrecognized option.
  89.     bool zygote = false;
  90.     bool startSystemServer = false;
  91.     bool application = false;
  92.     String8 niceName;
  93.     String8 className;
  96. //步骤3：整理zygote进程的传参.--------------------------------------------
  97.     ++i;  // Skip unused "parent dir" argument.
  98.     while (i < argc) {
  99.         const char* arg = argv[i++];
  100.         if (strcmp(arg, "--zygote") == 0) {
  101.             zygote = true;
  102.             niceName = ZYGOTE_NICE_NAME;
  103.         } else if (strcmp(arg, "--start-system-server") == 0) {
  104.             startSystemServer = true;
  105.         } else if (strcmp(arg, "--application") == 0) {
  106.             application = true;
  107.         } else if (strncmp(arg, "--nice-name=", 12) == 0) {
  108.             niceName = (arg + 12);
  109.         } else if (strncmp(arg, "--", 2) != 0) {
  110.             className = arg;
  111.             break;
  112.         } else {
  113.             --i;
  114.             break;
  115.         }
  116.     }
  118. //步骤4：根据整理的zygote传参，判断是否是zygote进程，并根据判断结果，补充“--abi-list”和“start-system-server”传参.--------------------------------------------
  119.     Vector<String8> args;
  120.     if (!className.empty()) {
  121.         // We're not in zygote mode, the only argument we need to pass
  122.         // to RuntimeInit is the application argument.
  123.         //
  124.         // The Remainder of args get passed to startup class main(). Make
  125.         // copies of them before we overwrite them with the process name.
  126.         args.add(application ? String8("application") : String8("tool"));
  127.         runtime.setClassNameAndArgs(className, argc - i, argv + i);
  129.         if (!LOG_NDEBUG) {
  130.           String8 restOfArgs;
  131.           char* const* argv_new = argv + i;
  132.           int argc_new = argc - i;
  133.           for (int k = 0; k < argc_new; ++k) {
  134.             restOfArgs.append(""");
  135.             restOfArgs.append(argv_new[k]);
  136.             restOfArgs.append("" ");
  137.           }
  138.           ALOGV("Class name = %s, args = %s", className.c_str(), restOfArgs.c_str());
  139.         }
  140.     } else {
  141.         // We're in zygote mode.
  142.         maybeCreateDalvikCache();
  144.         if (startSystemServer) {
  145.             args.add(String8("start-system-server"));
  146.         }
  148.         char prop[PROP_VALUE_MAX];
  149.         if (property_get(ABI_LIST_PROPERTY, prop, NULL) == 0) {
  150.             LOG_ALWAYS_FATAL("app_process: Unable to determine ABI list from property %s.",
  151.                 ABI_LIST_PROPERTY);
  152.             return 11;
  153.         }
  155.         String8 abiFlag("--abi-list=");
  156.         abiFlag.append(prop);
  157.         args.add(abiFlag);
  159.         // In zygote mode, pass all remaining arguments to the zygote
  160.         // main() method.
  161.         for (; i < argc; ++i) {
  162.             args.add(String8(argv[i]));
  163.         }
  164.     }
  166.     if (!niceName.empty()) {
  167.         runtime.setArgv0(niceName.c_str(), true /* setProcName */);
  168.     }
  169. //步骤5：使用runtime，调用“com.android.internal.os.ZygoteInit”类，并传入传参，启动zygote.--------------------------------------------
  170.     if (zygote) {
  171.         runtime.start("com.android.internal.os.ZygoteInit", args, zygote);
  172.     } else if (!className.empty()) {
  173.         runtime.start("com.android.internal.os.RuntimeInit", args, zygote);
  174.     } else {
  175.         fprintf(stderr, "Error: no class name or --zygote supplied.\n");
  176.         app_usage();
  177.         LOG_ALWAYS_FATAL("app_process: no class name or --zygote supplied.");
  178.     }
  179. }
复制代码
AndroidRuntime剖析

frameworks/base/core/jni/AndroidRuntime.cpp
Runtime的start方法

  1. void AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote)
  2. {
  3.     ALOGD(">>>>>> START %s uid %d <<<<<<\n",
  4.             className != NULL ? className : "(unknown)", getuid());
  6.     static const String8 startSystemServer("start-system-server");
  7.     // Whether this is the primary zygote, meaning the zygote which will fork system server.
  8.     bool primary_zygote = false;
  11. //步骤1：必要的参数及环境变量检查。-----------------------------------
  12.     /*
  13.      * 'startSystemServer == true' means runtime is obsolete and not run from
  14.      * init.rc anymore, so we print out the boot start event here.
  15.      */
  16.     for (size_t i = 0; i < options.size(); ++i) {
  17.         if (options[i] == startSystemServer) {
  18.             primary_zygote = true;
  19.            /* track our progress through the boot sequence */
  20.            const int LOG_BOOT_PROGRESS_START = 3000;
  21.            LOG_EVENT_LONG(LOG_BOOT_PROGRESS_START,  ns2ms(systemTime(SYSTEM_TIME_MONOTONIC)));
  22.         }
  23.     }
  25.     const char* rootDir = getenv("ANDROID_ROOT");
  26.     if (rootDir == NULL) {
  27.         rootDir = "/system";
  28.         if (!hasDir("/system")) {
  29.             LOG_FATAL("No root directory specified, and /system does not exist.");
  30.             return;
  31.         }
  32.         setenv("ANDROID_ROOT", rootDir, 1);
  33.     }
  35.     const char* artRootDir = getenv("ANDROID_ART_ROOT");
  36.     if (artRootDir == NULL) {
  37.         LOG_FATAL("No ART directory specified with ANDROID_ART_ROOT environment variable.");
  38.         return;
  39.     }
  41.     const char* i18nRootDir = getenv("ANDROID_I18N_ROOT");
  42.     if (i18nRootDir == NULL) {
  43.         LOG_FATAL("No runtime directory specified with ANDROID_I18N_ROOT environment variable.");
  44.         return;
  45.     }
  47.     const char* tzdataRootDir = getenv("ANDROID_TZDATA_ROOT");
  48.     if (tzdataRootDir == NULL) {
  49.         LOG_FATAL("No tz data directory specified with ANDROID_TZDATA_ROOT environment variable.");
  50.         return;
  51.     }
  53.     //const char* kernelHack = getenv("LD_ASSUME_KERNEL");
  54.     //ALOGD("Found LD_ASSUME_KERNEL='%s'\n", kernelHack);
  56. //步骤2：启动VM。-----------------------------------
  57.     /* start the virtual machine */
  58.     JniInvocation jni_invocation;
  59.     jni_invocation.Init(NULL);
  60.     JNIEnv* env;
  61.     if (startVm(&mJavaVM, &env, zygote, primary_zygote) != 0) {
  62.         return;
  63.     }
  64.     onVmCreated(env);
  66.     /*
  67.      * Register android functions.
  68.      */
  69. //步骤3：注册JNI方法。-----------------------------------
  70.     if (startReg(env) < 0) {
  71.         ALOGE("Unable to register all android natives\n");
  72.         return;
  73.     }
  75.     /*
  76.      * We want to call main() with a String array with arguments in it.
  77.      * At present we have two arguments, the class name and an option string.
  78.      * Create an array to hold them.
  79.      */
  80.     jclass stringClass;
  81.     jobjectArray strArray;
  82.     jstring classNameStr;
  84.     stringClass = env->FindClass("java/lang/String");
  85.     assert(stringClass != NULL);
  86.     strArray = env->NewObjectArray(options.size() + 1, stringClass, NULL);
  87.     assert(strArray != NULL);
  88.     classNameStr = env->NewStringUTF(className);
  89.     assert(classNameStr != NULL);
  90.     env->SetObjectArrayElement(strArray, 0, classNameStr);
  92.     for (size_t i = 0; i < options.size(); ++i) {
  93.         jstring optionsStr = env->NewStringUTF(options.itemAt(i).c_str());
  94.         assert(optionsStr != NULL);
  95.         env->SetObjectArrayElement(strArray, i + 1, optionsStr);
  96.     }
  98. //步骤4：利用java的反射，调用com.android.internal.os.ZygoteInit类中的main方法，创建zygote进程。-----------------------------------
  99.     /*
  100.      * Start VM.  This thread becomes the main thread of the VM, and will
  101.      * not return until the VM exits.
  102.      */
  103.     char* slashClassName = toSlashClassName(className != NULL ? className : "");
  104.     jclass startClass = env->FindClass(slashClassName);
  105.     if (startClass == NULL) {
  106.         ALOGE("JavaVM unable to locate class '%s'\n", slashClassName);
  107.         /* keep going */
  108.     } else {
  109.         jmethodID startMeth = env->GetStaticMethodID(startClass, "main",
  110.             "([Ljava/lang/String;)V");
  111.         if (startMeth == NULL) {
  112.             ALOGE("JavaVM unable to find main() in '%s'\n", className);
  113.             /* keep going */
  114.         } else {
  115.             env->CallStaticVoidMethod(startClass, startMeth, strArray);
  117. #if 0
  118.             if (env->ExceptionCheck())
  119.                 threadExitUncaughtException(env);
  120. #endif
  121.         }
  122.     }
  123.     free(slashClassName);
  125.     ALOGD("Shutting down VM\n");
  126.     if (mJavaVM->DetachCurrentThread() != JNI_OK)
  127.         ALOGW("Warning: unable to detach main thread\n");
  128.     if (mJavaVM->DestroyJavaVM() != 0)
  129.         ALOGW("Warning: VM did not shut down cleanly\n");
  130. }
复制代码
启动VM

该方法有600+行，都是网络VM参数，并调用JNI_CreateJavaVM启动VM。参数是一个可以做性能优化的点。相识即可。
  1. int AndroidRuntime::startVm(JavaVM** pJavaVM, JNIEnv** pEnv, bool zygote, bool primary_zygote)
  2. {
  3.     JavaVMInitArgs initArgs;
  4.     char propBuf[PROPERTY_VALUE_MAX];
  5.     char jniOptsBuf[sizeof("-Xjniopts:")-1 + PROPERTY_VALUE_MAX];
  6.     char heapstartsizeOptsBuf[sizeof("-Xms")-1 + PROPERTY_VALUE_MAX];
  7.     char heapsizeOptsBuf[sizeof("-Xmx")-1 + PROPERTY_VALUE_MAX];
  8.     char heapgrowthlimitOptsBuf[sizeof("-XX:HeapGrowthLimit=")-1 + PROPERTY_VALUE_MAX];
  9.     char heapminfreeOptsBuf[sizeof("-XX:HeapMinFree=")-1 + PROPERTY_VALUE_MAX];
  10.     char heapmaxfreeOptsBuf[sizeof("-XX:HeapMaxFree=")-1 + PROPERTY_VALUE_MAX];
  11.     char usejitOptsBuf[sizeof("-Xusejit:")-1 + PROPERTY_VALUE_MAX];
  12.     char jitpthreadpriorityOptsBuf[sizeof("-Xjitpthreadpriority:")-1 + PROPERTY_VALUE_MAX];
  13.     char jitmaxsizeOptsBuf[sizeof("-Xjitmaxsize:")-1 + PROPERTY_VALUE_MAX];
  14.     char jitinitialsizeOptsBuf[sizeof("-Xjitinitialsize:")-1 + PROPERTY_VALUE_MAX];
  15.     char jitthresholdOptsBuf[sizeof("-Xjitthreshold:")-1 + PROPERTY_VALUE_MAX];
  16.     char jitprithreadweightOptBuf[sizeof("-Xjitprithreadweight:")-1 + PROPERTY_VALUE_MAX];
  17.     char jittransitionweightOptBuf[sizeof("-Xjittransitionweight:")-1 + PROPERTY_VALUE_MAX];
  18.     char hotstartupsamplesOptsBuf[sizeof("-Xps-hot-startup-method-samples:")-1 + PROPERTY_VALUE_MAX];
  19.     char saveResolvedClassesDelayMsOptsBuf[
  20.             sizeof("-Xps-save-resolved-classes-delay-ms:")-1 + PROPERTY_VALUE_MAX];
  21.     char profileMinSavePeriodOptsBuf[sizeof("-Xps-min-save-period-ms:")-1 + PROPERTY_VALUE_MAX];
  22.     char profileMinFirstSaveOptsBuf[sizeof("-Xps-min-first-save-ms:") - 1 + PROPERTY_VALUE_MAX];
  23.     char profileInlineCacheThresholdOptsBuf[
  24.             sizeof("-Xps-inline-cache-threshold:") - 1 + PROPERTY_VALUE_MAX];
  25.     char madviseWillNeedFileSizeVdex[
  26.             sizeof("-XMadviseWillNeedVdexFileSize:")-1 + PROPERTY_VALUE_MAX];
  27.     char madviseWillNeedFileSizeOdex[
  28.             sizeof("-XMadviseWillNeedOdexFileSize:")-1 + PROPERTY_VALUE_MAX];
  29.     char madviseWillNeedFileSizeArt[
  30.             sizeof("-XMadviseWillNeedArtFileSize:")-1 + PROPERTY_VALUE_MAX];
  31.     char gctypeOptsBuf[sizeof("-Xgc:")-1 + PROPERTY_VALUE_MAX];
  32.     char backgroundgcOptsBuf[sizeof("-XX:BackgroundGC=")-1 + PROPERTY_VALUE_MAX];
  33.     char heaptargetutilizationOptsBuf[sizeof("-XX:HeapTargetUtilization=")-1 + PROPERTY_VALUE_MAX];
  34.     char foregroundHeapGrowthMultiplierOptsBuf[
  35.             sizeof("-XX:ForegroundHeapGrowthMultiplier=")-1 + PROPERTY_VALUE_MAX];
  36.     char finalizerTimeoutMsOptsBuf[sizeof("-XX:FinalizerTimeoutMs=")-1 + PROPERTY_VALUE_MAX];
  37.     char threadSuspendTimeoutOptsBuf[sizeof("-XX:ThreadSuspendTimeout=")-1 + PROPERTY_VALUE_MAX];
  38.     char cachePruneBuf[sizeof("-Xzygote-max-boot-retry=")-1 + PROPERTY_VALUE_MAX];
  39.     char dex2oatXmsImageFlagsBuf[sizeof("-Xms")-1 + PROPERTY_VALUE_MAX];
  40.     char dex2oatXmxImageFlagsBuf[sizeof("-Xmx")-1 + PROPERTY_VALUE_MAX];
  41.     char dex2oatCompilerFilterBuf[sizeof("--compiler-filter=")-1 + PROPERTY_VALUE_MAX];
  42.     char dex2oatImageCompilerFilterBuf[sizeof("--compiler-filter=")-1 + PROPERTY_VALUE_MAX];
  43.     char dex2oatThreadsBuf[sizeof("-j")-1 + PROPERTY_VALUE_MAX];
  44.     char dex2oatThreadsImageBuf[sizeof("-j")-1 + PROPERTY_VALUE_MAX];
  45.     char dex2oatCpuSetBuf[sizeof("--cpu-set=")-1 + PROPERTY_VALUE_MAX];
  46.     char dex2oatCpuSetImageBuf[sizeof("--cpu-set=")-1 + PROPERTY_VALUE_MAX];
  47.     char dex2oat_isa_variant_key[PROPERTY_KEY_MAX];
  48.     char dex2oat_isa_variant[sizeof("--instruction-set-variant=") -1 + PROPERTY_VALUE_MAX];
  49.     char dex2oat_isa_features_key[PROPERTY_KEY_MAX];
  50.     char dex2oat_isa_features[sizeof("--instruction-set-features=") -1 + PROPERTY_VALUE_MAX];
  51.     char dex2oatFlagsBuf[PROPERTY_VALUE_MAX];
  52.     char dex2oatImageFlagsBuf[PROPERTY_VALUE_MAX];
  53.     char extraOptsBuf[PROPERTY_VALUE_MAX];
  54.     char perfettoHprofOptBuf[sizeof("-XX:PerfettoHprof=") + PROPERTY_VALUE_MAX];
  55.     char perfettoJavaHeapStackOptBuf[
  56.             sizeof("-XX:PerfettoJavaHeapStackProf=") + PROPERTY_VALUE_MAX];
  57.     enum {
  58.       kEMDefault,
  59.       kEMIntPortable,
  60.       kEMIntFast,
  61.       kEMJitCompiler,
  62.     } executionMode = kEMDefault;
  63.     char localeOption[sizeof("-Duser.locale=") + PROPERTY_VALUE_MAX];
  64.     char lockProfThresholdBuf[sizeof("-Xlockprofthreshold:")-1 + PROPERTY_VALUE_MAX];
  65.     char nativeBridgeLibrary[sizeof("-XX:NativeBridge=") + PROPERTY_VALUE_MAX];
  66.     char cpuAbiListBuf[sizeof("--cpu-abilist=") + PROPERTY_VALUE_MAX];
  67.     char corePlatformApiPolicyBuf[sizeof("-Xcore-platform-api-policy:") + PROPERTY_VALUE_MAX];
  68.     char methodTraceFileBuf[sizeof("-Xmethod-trace-file:") + PROPERTY_VALUE_MAX];
  69.     char methodTraceFileSizeBuf[sizeof("-Xmethod-trace-file-size:") + PROPERTY_VALUE_MAX];
  70.     std::string fingerprintBuf;
  71.     char javaZygoteForkLoopBuf[sizeof("-XX:ForceJavaZygoteForkLoop=") + PROPERTY_VALUE_MAX];
  72.     char jdwpProviderBuf[sizeof("-XjdwpProvider:") - 1 + PROPERTY_VALUE_MAX];
  73.     char opaqueJniIds[sizeof("-Xopaque-jni-ids:") - 1 + PROPERTY_VALUE_MAX];
  74.     char bootImageBuf[sizeof("-Ximage:") - 1 + PROPERTY_VALUE_MAX];
  76.     // Read if we are using the profile configuration, do this at the start since the last ART args
  77.     // take precedence.
  78.     std::string profile_boot_class_path_flag =
  79.             server_configurable_flags::GetServerConfigurableFlag(RUNTIME_NATIVE_BOOT_NAMESPACE,
  80.                                                                  PROFILE_BOOT_CLASS_PATH,
  81.                                                                  /*default_value=*/"");
  82.     bool profile_boot_class_path;
  83.     switch (ParseBool(profile_boot_class_path_flag)) {
  84.         case ParseBoolResult::kError:
  85.             // Default to the system property.
  86.             profile_boot_class_path =
  87.                     GetBoolProperty("dalvik.vm.profilebootclasspath", /*default_value=*/false);
  88.             break;
  89.         case ParseBoolResult::kTrue:
  90.             profile_boot_class_path = true;
  91.             break;
  92.         case ParseBoolResult::kFalse:
  93.             profile_boot_class_path = false;
  94.             break;
  95.     }
  96.     if (profile_boot_class_path) {
  97.         addOption("-Xcompiler-option");
  98.         addOption("--count-hotness-in-compiled-code");
  99.         addOption("-Xps-profile-boot-class-path");
  100.         addOption("-Xps-profile-aot-code");
  101.         addOption("-Xjitsaveprofilinginfo");
  102.     }
  104.     std::string use_jitzygote_image_flag =
  105.             server_configurable_flags::GetServerConfigurableFlag(RUNTIME_NATIVE_BOOT_NAMESPACE,
  106.                                                                  ENABLE_JITZYGOTE_IMAGE,
  107.                                                                  /*default_value=*/"");
  108.     // Use the APEX boot image for boot class path profiling to get JIT samples on BCP methods.
  109.     // Also use the APEX boot image if it's explicitly enabled via configuration flag.
  110.     const bool use_apex_image = profile_boot_class_path || (use_jitzygote_image_flag == "true");
  111.     if (use_apex_image) {
  112.         ALOGI("Using JIT Zygote image: '%s'\n", kJitZygoteImageOption);
  113.         addOption(kJitZygoteImageOption);
  114.     } else if (parseRuntimeOption("dalvik.vm.boot-image", bootImageBuf, "-Ximage:")) {
  115.         ALOGI("Using dalvik.vm.boot-image: '%s'\n", bootImageBuf);
  116.     } else {
  117.         ALOGI("Using default boot image");
  118.     }
  120.     std::string disable_lock_profiling =
  121.         server_configurable_flags::GetServerConfigurableFlag(RUNTIME_NATIVE_BOOT_NAMESPACE,
  122.                                                              DISABLE_LOCK_PROFILING,
  123.                                                              /*default_value=*/ "");
  124.     if (disable_lock_profiling == "true") {
  125.         addOption(kLockProfThresholdRuntimeOption);
  126.         ALOGI("Disabling lock profiling: '%s'\n", kLockProfThresholdRuntimeOption);
  127.     } else {
  128.         ALOGI("Leaving lock profiling enabled");
  129.     }
  131.     const bool checkJni = GetBoolProperty("dalvik.vm.checkjni", false);
  132.     if (checkJni) {
  133.         ALOGD("CheckJNI is ON");
  135.         /* extended JNI checking */
  136.         addOption("-Xcheck:jni");
  138.         /* with -Xcheck:jni, this provides a JNI function call trace */
  139.         //addOption("-verbose:jni");
  140.     }
  142.     const bool odsignVerificationSuccess = GetBoolProperty("odsign.verification.success", false);
  143.     if (!odsignVerificationSuccess) {
  144.         addOption("-Xdeny-art-apex-data-files");
  145.     }
  147.     property_get("dalvik.vm.execution-mode", propBuf, "");
  148.     if (strcmp(propBuf, "int:portable") == 0) {
  149.         executionMode = kEMIntPortable;
  150.     } else if (strcmp(propBuf, "int:fast") == 0) {
  151.         executionMode = kEMIntFast;
  152.     } else if (strcmp(propBuf, "int:jit") == 0) {
  153.         executionMode = kEMJitCompiler;
  154.     }
  156.     strcpy(jniOptsBuf, "-Xjniopts:");
  157.     if (parseRuntimeOption("dalvik.vm.jniopts", jniOptsBuf, "-Xjniopts:")) {
  158.         ALOGI("JNI options: '%s'\n", jniOptsBuf);
  159.     }
  161.     /* route exit() to our handler */
  162.     addOption("exit", (void*) runtime_exit);
  164.     /* route fprintf() to our handler */
  165.     addOption("vfprintf", (void*) runtime_vfprintf);
  167.     /* register the framework-specific "is sensitive thread" hook */
  168.     addOption("sensitiveThread", (void*) runtime_isSensitiveThread);
  170.     /* enable verbose; standard options are { jni, gc, class } */
  171.     //addOption("-verbose:jni");
  172.     addOption("-verbose:gc");
  173.     //addOption("-verbose:class");
  175.     // On Android, we always want to allow loading the PerfettoHprof plugin.
  176.     // Even with this option set, we will still only actually load the plugin
  177.     // if we are on a userdebug build or the app is debuggable or profileable.
  178.     // This is enforced in art/runtime/runtime.cc.
  179.     //
  180.     // We want to be able to disable this, because this does not work on host,
  181.     // and we do not want to enable it in tests.
  182.     parseRuntimeOption("dalvik.vm.perfetto_hprof", perfettoHprofOptBuf, "-XX:PerfettoHprof=",
  183.                        "true");
  185.     // Enable PerfettoJavaHeapStackProf in the zygote
  186.     parseRuntimeOption("dalvik.vm.perfetto_javaheap", perfettoJavaHeapStackOptBuf,
  187.                        "-XX:PerfettoJavaHeapStackProf=", "true");
  189.     if (primary_zygote) {
  190.         addOption("-Xprimaryzygote");
  191.     }
  193.     /*
  194.      * The default starting and maximum size of the heap.  Larger
  195.      * values should be specified in a product property override.
  196.      */
  197.     parseRuntimeOption("dalvik.vm.heapstartsize", heapstartsizeOptsBuf, "-Xms", "4m");
  198.     parseRuntimeOption("dalvik.vm.heapsize", heapsizeOptsBuf, "-Xmx", "16m");
  200.     parseRuntimeOption("dalvik.vm.heapgrowthlimit", heapgrowthlimitOptsBuf, "-XX:HeapGrowthLimit=");
  201.     parseRuntimeOption("dalvik.vm.heapminfree", heapminfreeOptsBuf, "-XX:HeapMinFree=");
  202.     parseRuntimeOption("dalvik.vm.heapmaxfree", heapmaxfreeOptsBuf, "-XX:HeapMaxFree=");
  203.     parseRuntimeOption("dalvik.vm.heaptargetutilization",
  204.                        heaptargetutilizationOptsBuf,
  205.                        "-XX:HeapTargetUtilization=");
  207.     /* Foreground heap growth multiplier option */
  208.     parseRuntimeOption("dalvik.vm.foreground-heap-growth-multiplier",
  209.                        foregroundHeapGrowthMultiplierOptsBuf,
  210.                        "-XX:ForegroundHeapGrowthMultiplier=");
  211.     /*
  212.      * Finalizer and thread suspend timeouts.
  213.      */
  214.     parseRuntimeOption("dalvik.vm.finalizer-timeout-ms",
  215.                        finalizerTimeoutMsOptsBuf,
  216.                        "-XX:FinalizerTimeoutMs=");
  217.     parseRuntimeOption("dalvik.vm.thread-suspend-timeout-ms",
  218.                        threadSuspendTimeoutOptsBuf,
  219.                        "-XX:ThreadSuspendTimeout=");
  220.     /*
  221.      * JIT related options.
  222.      */
  223.     parseRuntimeOption("dalvik.vm.usejit", usejitOptsBuf, "-Xusejit:");
  224.     parseRuntimeOption("dalvik.vm.jitmaxsize", jitmaxsizeOptsBuf, "-Xjitmaxsize:");
  225.     parseRuntimeOption("dalvik.vm.jitinitialsize", jitinitialsizeOptsBuf, "-Xjitinitialsize:");
  226.     parseRuntimeOption("dalvik.vm.jitthreshold", jitthresholdOptsBuf, "-Xjitthreshold:");
  227.     parseRuntimeOption("dalvik.vm.jitpthreadpriority",
  228.                        jitpthreadpriorityOptsBuf,
  229.                        "-Xjitpthreadpriority:");
  230.     addOption("-Xjitsaveprofilinginfo");
  232.     parseRuntimeOption("dalvik.vm.jitprithreadweight",
  233.                        jitprithreadweightOptBuf,
  234.                        "-Xjitprithreadweight:");
  236.     parseRuntimeOption("dalvik.vm.jittransitionweight", jittransitionweightOptBuf,
  237.                        "-Xjittransitionweight:");
  239.     /*
  240.      * Use default platform configuration as limits for madvising,
  241.      * when no properties are specified.
  242.      */
  243.     parseRuntimeOption("dalvik.vm.madvise.vdexfile.size",
  244.                        madviseWillNeedFileSizeVdex,
  245.                        "-XMadviseWillNeedVdexFileSize:");
  247.     parseRuntimeOption("dalvik.vm.madvise.odexfile.size",
  248.                        madviseWillNeedFileSizeOdex,
  249.                        "-XMadviseWillNeedOdexFileSize:");
  251.     parseRuntimeOption("dalvik.vm.madvise.artfile.size",
  252.                        madviseWillNeedFileSizeArt,
  253.                        "-XMadviseWillNeedArtFileSize:");
  255.     /*
  256.      * Profile related options.
  257.      */
  258.     parseRuntimeOption("dalvik.vm.hot-startup-method-samples", hotstartupsamplesOptsBuf,
  259.             "-Xps-hot-startup-method-samples:");
  261.     parseRuntimeOption("dalvik.vm.ps-resolved-classes-delay-ms", saveResolvedClassesDelayMsOptsBuf,
  262.             "-Xps-save-resolved-classes-delay-ms:");
  264.     parseRuntimeOption("dalvik.vm.ps-min-save-period-ms", profileMinSavePeriodOptsBuf,
  265.             "-Xps-min-save-period-ms:");
  267.     parseRuntimeOption("dalvik.vm.ps-min-first-save-ms", profileMinFirstSaveOptsBuf,
  268.             "-Xps-min-first-save-ms:");
  270.     parseRuntimeOption("dalvik.vm.ps-inline-cache-threshold", profileInlineCacheThresholdOptsBuf,
  271.             "-Xps-inline-cache-threshold:");
  273.     property_get("ro.config.low_ram", propBuf, "");
  274.     if (strcmp(propBuf, "true") == 0) {
  275.       addOption("-XX:LowMemoryMode");
  276.     }
  278.     /*
  279.      * Garbage-collection related options.
  280.      */
  281.     parseRuntimeOption("dalvik.vm.gctype", gctypeOptsBuf, "-Xgc:");
  283.     // If it set, honor the "enable_generational_cc" device configuration;
  284.     // otherwise, let the runtime use its default behavior.
  285.     std::string enable_generational_cc =
  286.         server_configurable_flags::GetServerConfigurableFlag(RUNTIME_NATIVE_BOOT_NAMESPACE,
  287.                                                              ENABLE_GENERATIONAL_CC,
  288.                                                              /*default_value=*/ "");
  289.     if (enable_generational_cc == "true") {
  290.         addOption(kGenerationalCCRuntimeOption);
  291.     } else if (enable_generational_cc == "false") {
  292.         addOption(kNoGenerationalCCRuntimeOption);
  293.     }
  295.     parseRuntimeOption("dalvik.vm.backgroundgctype", backgroundgcOptsBuf, "-XX:BackgroundGC=");
  297.     /*
  298.      * Enable/disable zygote native fork loop.
  299.      */
  300.     parseRuntimeOption("dalvik.vm.force-java-zygote-fork-loop",
  301.                        javaZygoteForkLoopBuf,
  302.                        "-XX:ForceJavaZygoteForkLoop=");
  304.     /*
  305.      * Enable debugging only for apps forked from zygote.
  306.      */
  307.     if (zygote) {
  308.       // Set the JDWP provider and required arguments. By default let the runtime choose how JDWP is
  309.       // implemented. When this is not set the runtime defaults to not allowing JDWP.
  310.       addOption("-XjdwpOptions:suspend=n,server=y");
  311.       parseRuntimeOption("dalvik.vm.jdwp-provider",
  312.                          jdwpProviderBuf,
  313.                          "-XjdwpProvider:",
  314.                          "default");
  315.     }
  317.     // Only pass an explicit opaque-jni-ids to apps forked from zygote
  318.     if (zygote) {
  319.       parseRuntimeOption("dalvik.vm.opaque-jni-ids",
  320.                         opaqueJniIds,
  321.                         "-Xopaque-jni-ids:",
  322.                         "swapable");
  323.     }
  325.     parseRuntimeOption("dalvik.vm.lockprof.threshold",
  326.                        lockProfThresholdBuf,
  327.                        "-Xlockprofthreshold:");
  329.     if (executionMode == kEMIntPortable) {
  330.         addOption("-Xint:portable");
  331.     } else if (executionMode == kEMIntFast) {
  332.         addOption("-Xint:fast");
  333.     } else if (executionMode == kEMJitCompiler) {
  334.         addOption("-Xint:jit");
  335.     }
  337.     // Extra options for JIT.
  338.     parseCompilerOption("dalvik.vm.dex2oat-filter", dex2oatCompilerFilterBuf,
  339.                         "--compiler-filter=", "-Xcompiler-option");
  340.     parseCompilerOption("dalvik.vm.dex2oat-threads", dex2oatThreadsBuf, "-j", "-Xcompiler-option");
  341.     parseCompilerOption("dalvik.vm.dex2oat-cpu-set", dex2oatCpuSetBuf, "--cpu-set=",
  342.                         "-Xcompiler-option");
  344.     // Copy the variant.
  345.     sprintf(dex2oat_isa_variant_key, "dalvik.vm.isa.%s.variant", ABI_STRING);
  346.     parseCompilerOption(dex2oat_isa_variant_key, dex2oat_isa_variant,
  347.                         "--instruction-set-variant=", "-Xcompiler-option");
  348.     // Copy the features.
  349.     sprintf(dex2oat_isa_features_key, "dalvik.vm.isa.%s.features", ABI_STRING);
  350.     parseCompilerOption(dex2oat_isa_features_key, dex2oat_isa_features,
  351.                         "--instruction-set-features=", "-Xcompiler-option");
  353.     /*
  354.      * When running with debug.generate-debug-info, add --generate-debug-info to the compiler
  355.      * options so that both JITted code and the boot image, if it is compiled on device, will
  356.      * include native debugging information.
  357.      */
  358.     property_get("debug.generate-debug-info", propBuf, "");
  359.     bool generate_debug_info = (strcmp(propBuf, "true") == 0);
  360.     if (generate_debug_info) {
  361.         addOption("-Xcompiler-option");
  362.         addOption("--generate-debug-info");
  363.     }
  365.     // The mini-debug-info makes it possible to backtrace through compiled code.
  366.     bool generate_mini_debug_info = property_get_bool("dalvik.vm.minidebuginfo", 0);
  367.     if (generate_mini_debug_info) {
  368.         addOption("-Xcompiler-option");
  369.         addOption("--generate-mini-debug-info");
  370.     }
  372.     property_get("dalvik.vm.dex2oat-flags", dex2oatFlagsBuf, "");
  373.     parseExtraOpts(dex2oatFlagsBuf, "-Xcompiler-option");
  375.     /* extra options; parse this late so it overrides others */
  376.     property_get("dalvik.vm.extra-opts", extraOptsBuf, "");
  377.     parseExtraOpts(extraOptsBuf, NULL);
  379.     // Extra options for boot image generation.
  380.     parseCompilerRuntimeOption("dalvik.vm.image-dex2oat-Xms", dex2oatXmsImageFlagsBuf,
  381.                                "-Xms", "-Ximage-compiler-option");
  382.     parseCompilerRuntimeOption("dalvik.vm.image-dex2oat-Xmx", dex2oatXmxImageFlagsBuf,
  383.                                "-Xmx", "-Ximage-compiler-option");
  385.     parseCompilerOption("dalvik.vm.image-dex2oat-filter", dex2oatImageCompilerFilterBuf,
  386.                         "--compiler-filter=", "-Ximage-compiler-option");
  388.     // If there is a dirty-image-objects file, push it.
  389.     if (hasFile("/system/etc/dirty-image-objects")) {
  390.         addOption("-Ximage-compiler-option");
  391.         addOption("--dirty-image-objects=/system/etc/dirty-image-objects");
  392.     }
  394.     parseCompilerOption("dalvik.vm.image-dex2oat-threads", dex2oatThreadsImageBuf, "-j",
  395.                         "-Ximage-compiler-option");
  396.     parseCompilerOption("dalvik.vm.image-dex2oat-cpu-set", dex2oatCpuSetImageBuf, "--cpu-set=",
  397.                         "-Ximage-compiler-option");
  399.     // The runtime may compile a boot image, when necessary, not using installd. Thus, we need
  400.     // to pass the instruction-set-features/variant as an image-compiler-option.
  401.     // Note: it is OK to reuse the buffer, as the values are exactly the same between
  402.     //       * compiler-option, used for runtime compilation (DexClassLoader)
  403.     //       * image-compiler-option, used for boot-image compilation on device
  404.     parseCompilerOption(dex2oat_isa_variant_key, dex2oat_isa_variant,
  405.                         "--instruction-set-variant=", "-Ximage-compiler-option");
  406.     parseCompilerOption(dex2oat_isa_features_key, dex2oat_isa_features,
  407.                         "--instruction-set-features=", "-Ximage-compiler-option");
  409.     if (generate_debug_info) {
  410.         addOption("-Ximage-compiler-option");
  411.         addOption("--generate-debug-info");
  412.     }
  414.     if (generate_mini_debug_info) {
  415.         addOption("-Ximage-compiler-option");
  416.         addOption("--generate-mini-debug-info");
  417.     }
  419.     property_get("dalvik.vm.image-dex2oat-flags", dex2oatImageFlagsBuf, "");
  420.     parseExtraOpts(dex2oatImageFlagsBuf, "-Ximage-compiler-option");
  422.     /* Set the properties for locale */
  423.     {
  424.         strcpy(localeOption, "-Duser.locale=");
  425.         const std::string locale = readLocale();
  426.         strncat(localeOption, locale.c_str(), PROPERTY_VALUE_MAX);
  427.         addOption(localeOption);
  428.     }
  430.     // Trace files are stored in /data/misc/trace which is writable only in debug mode.
  431.     property_get("ro.debuggable", propBuf, "0");
  432.     if (strcmp(propBuf, "1") == 0) {
  433.         property_get("dalvik.vm.method-trace", propBuf, "false");
  434.         if (strcmp(propBuf, "true") == 0) {
  435.             addOption("-Xmethod-trace");
  436.             parseRuntimeOption("dalvik.vm.method-trace-file",
  437.                                methodTraceFileBuf,
  438.                                "-Xmethod-trace-file:");
  439.             parseRuntimeOption("dalvik.vm.method-trace-file-siz",
  440.                                methodTraceFileSizeBuf,
  441.                                "-Xmethod-trace-file-size:");
  442.             property_get("dalvik.vm.method-trace-stream", propBuf, "false");
  443.             if (strcmp(propBuf, "true") == 0) {
  444.                 addOption("-Xmethod-trace-stream");
  445.             }
  446.         }
  447.     }
  449.     // Native bridge library. "0" means that native bridge is disabled.
  450.     //
  451.     // Note: bridging is only enabled for the zygote. Other runs of
  452.     //       app_process may not have the permissions to mount etc.
  453.     property_get("ro.dalvik.vm.native.bridge", propBuf, "");
  454.     if (propBuf[0] == '\0') {
  455.         ALOGW("ro.dalvik.vm.native.bridge is not expected to be empty");
  456.     } else if (zygote && strcmp(propBuf, "0") != 0) {
  457.         snprintf(nativeBridgeLibrary, sizeof("-XX:NativeBridge=") + PROPERTY_VALUE_MAX,
  458.                  "-XX:NativeBridge=%s", propBuf);
  459.         addOption(nativeBridgeLibrary);
  460.     }
  462. #if defined(__LP64__)
  463.     const char* cpu_abilist_property_name = "ro.product.cpu.abilist64";
  464. #else
  465.     const char* cpu_abilist_property_name = "ro.product.cpu.abilist32";
  466. #endif  // defined(__LP64__)
  467.     property_get(cpu_abilist_property_name, propBuf, "");
  468.     if (propBuf[0] == '\0') {
  469.         ALOGE("%s is not expected to be empty", cpu_abilist_property_name);
  470.         return -1;
  471.     }
  472.     snprintf(cpuAbiListBuf, sizeof(cpuAbiListBuf), "--cpu-abilist=%s", propBuf);
  473.     addOption(cpuAbiListBuf);
  475.     // Dalvik-cache pruning counter.
  476.     parseRuntimeOption("dalvik.vm.zygote.max-boot-retry", cachePruneBuf,
  477.                        "-Xzygote-max-boot-retry=");
  479.     // If set, the property below can be used to enable core platform API violation reporting.
  480.     property_get("persist.debug.dalvik.vm.core_platform_api_policy", propBuf, "");
  481.     if (propBuf[0] != '\0') {
  482.       snprintf(corePlatformApiPolicyBuf,
  483.                sizeof(corePlatformApiPolicyBuf),
  484.                "-Xcore-platform-api-policy:%s",
  485.                propBuf);
  486.       addOption(corePlatformApiPolicyBuf);
  487.     }
  489.     /*
  490.      * Retrieve the build fingerprint and provide it to the runtime. That way, ANR dumps will
  491.      * contain the fingerprint and can be parsed.
  492.      * Fingerprints are potentially longer than PROPERTY_VALUE_MAX, so parseRuntimeOption() cannot
  493.      * be used here.
  494.      * Do not ever re-assign fingerprintBuf as its c_str() value is stored in mOptions.
  495.      */
  496.     std::string fingerprint = GetProperty("ro.build.fingerprint", "");
  497.     if (!fingerprint.empty()) {
  498.         fingerprintBuf = "-Xfingerprint:" + fingerprint;
  499.         addOption(fingerprintBuf.c_str());
  500.     }
  502.     initArgs.version = JNI_VERSION_1_4;
  503.     initArgs.options = mOptions.editArray();
  504.     initArgs.nOptions = mOptions.size();
  505.     initArgs.ignoreUnrecognized = JNI_FALSE;
  507.     /*
  508.      * Initialize the VM.
  509.      *
  510.      * The JavaVM* is essentially per-process, and the JNIEnv* is per-thread.
  511.      * If this call succeeds, the VM is ready, and we can start issuing
  512.      * JNI calls.
  513.      */
  514.     if (JNI_CreateJavaVM(pJavaVM, pEnv, &initArgs) < 0) {
  515.         ALOGE("JNI_CreateJavaVM failed\n");
  516.         return -1;
  517.     }
  519.     return 0;
  520. }
复制代码
注册JNI

将gRegJNI数组里的JNI方法进行注册。RegJNIRec 包含100+个JNI方法。
  1. /*static*/ int AndroidRuntime::startReg(JNIEnv* env)
  2. {
  3.     ATRACE_NAME("RegisterAndroidNatives");
  4.     /*
  5.      * This hook causes all future threads created in this process to be
  6.      * attached to the JavaVM.  (This needs to go away in favor of JNI
  7.      * Attach calls.)
  8.      */
  9.     androidSetCreateThreadFunc((android_create_thread_fn) javaCreateThreadEtc);
  11.     ALOGV("--- registering native functions ---\n");
  13.     /*
  14.      * Every "register" function calls one or more things that return
  15.      * a local reference (e.g. FindClass).  Because we haven't really
  16.      * started the VM yet, they're all getting stored in the base frame
  17.      * and never released.  Use Push/Pop to manage the storage.
  18.      */
  19.     env->PushLocalFrame(200);
  21. //核心步骤：将gRegJNI数组里的JNI方法进行注册。
  23.     if (register_jni_procs(gRegJNI, NELEM(gRegJNI), env) < 0) {
  24.         env->PopLocalFrame(NULL);
  25.         return -1;
  26.     }
  27.     env->PopLocalFrame(NULL);
  29.     //createJavaThread("fubar", quickTest, (void*) "hello");
  31.     return 0;
  32. }
复制代码
  1. static const RegJNIRec gRegJNI[] = {
  2.         REG_JNI(register_com_android_internal_os_RuntimeInit),
  3.         REG_JNI(register_com_android_internal_os_ZygoteInit_nativeZygoteInit),
  4.         REG_JNI(register_android_os_SystemClock),
  5.         REG_JNI(register_android_util_CharsetUtils),
  6.         REG_JNI(register_android_util_EventLog),
  7.         REG_JNI(register_android_util_Log),
  8.         REG_JNI(register_android_util_MemoryIntArray),
  9.         REG_JNI(register_android_app_admin_SecurityLog),
  10.         REG_JNI(register_android_content_AssetManager),
  11.         REG_JNI(register_android_content_StringBlock),
  12.         REG_JNI(register_android_content_XmlBlock),
  13.         REG_JNI(register_android_content_res_ApkAssets),
  14.         REG_JNI(register_android_content_res_ResourceTimer),
  15.         REG_JNI(register_android_text_AndroidCharacter),
  16.         REG_JNI(register_android_text_Hyphenator),
  17.         REG_JNI(register_android_view_InputDevice),
  18.         REG_JNI(register_android_view_KeyCharacterMap),
  19.         REG_JNI(register_android_os_Process),
  20.         REG_JNI(register_android_os_SystemProperties),
  21.         REG_JNI(register_android_os_Binder),
  22.         REG_JNI(register_android_os_Parcel),
  23.         REG_JNI(register_android_os_PerformanceHintManager),
  24.         REG_JNI(register_android_os_HidlMemory),
  25.         REG_JNI(register_android_os_HidlSupport),
  26.         REG_JNI(register_android_os_HwBinder),
  27.         REG_JNI(register_android_os_HwBlob),
  28.         REG_JNI(register_android_os_HwParcel),
  29.         REG_JNI(register_android_os_HwRemoteBinder),
  30.         REG_JNI(register_android_os_NativeHandle),
  31.         REG_JNI(register_android_os_ServiceManager),
  32.         REG_JNI(register_android_os_ServiceManagerNative),
  33.         REG_JNI(register_android_os_storage_StorageManager),
  34.         REG_JNI(register_android_service_DataLoaderService),
  35.         REG_JNI(register_android_view_DisplayEventReceiver),
  36.         REG_JNI(register_android_view_Surface),
  37.         REG_JNI(register_android_view_SurfaceControl),
  38.         REG_JNI(register_android_view_SurfaceControlHdrLayerInfoListener),
  39.         REG_JNI(register_android_view_SurfaceSession),
  40.         REG_JNI(register_android_view_InputApplicationHandle),
  41.         // This must be called after register_android_view_SurfaceControl since it has a dependency
  42.         // on the Java SurfaceControl object that references a native resource via static request.
  43.         REG_JNI(register_android_view_InputWindowHandle),
  44.         REG_JNI(register_android_view_CompositionSamplingListener),
  45.         REG_JNI(register_android_view_TextureView),
  46.         REG_JNI(register_android_view_TunnelModeEnabledListener),
  47.         REG_JNI(register_com_google_android_gles_jni_EGLImpl),
  48.         REG_JNI(register_com_google_android_gles_jni_GLImpl),
  49.         REG_JNI(register_android_opengl_jni_EGL14),
  50.         REG_JNI(register_android_opengl_jni_EGL15),
  51.         REG_JNI(register_android_opengl_jni_EGLExt),
  52.         REG_JNI(register_android_opengl_jni_GLES10),
  53.         REG_JNI(register_android_opengl_jni_GLES10Ext),
  54.         REG_JNI(register_android_opengl_jni_GLES11),
  55.         REG_JNI(register_android_opengl_jni_GLES11Ext),
  56.         REG_JNI(register_android_opengl_jni_GLES20),
  57.         REG_JNI(register_android_opengl_jni_GLES30),
  58.         REG_JNI(register_android_opengl_jni_GLES31),
  59.         REG_JNI(register_android_opengl_jni_GLES31Ext),
  60.         REG_JNI(register_android_opengl_jni_GLES32),
  61.         REG_JNI(register_android_graphics_classes),
  62.         REG_JNI(register_android_graphics_BLASTBufferQueue),
  63.         REG_JNI(register_android_graphics_GraphicBuffer),
  64.         REG_JNI(register_android_graphics_GraphicsStatsService),
  65.         REG_JNI(register_android_graphics_SurfaceTexture),
  66.         REG_JNI(register_android_database_CursorWindow),
  67.         REG_JNI(register_android_database_SQLiteConnection),
  68.         REG_JNI(register_android_database_SQLiteGlobal),
  69.         REG_JNI(register_android_database_SQLiteDebug),
  70.         REG_JNI(register_android_database_SQLiteRawStatement),
  71.         REG_JNI(register_android_os_Debug),
  72.         REG_JNI(register_android_os_FileObserver),
  73.         REG_JNI(register_android_os_GraphicsEnvironment),
  74.         REG_JNI(register_android_os_MessageQueue),
  75.         REG_JNI(register_android_os_SELinux),
  76.         REG_JNI(register_android_os_Trace),
  77.         REG_JNI(register_android_os_UEventObserver),
  78.         REG_JNI(register_android_net_LocalSocketImpl),
  79.         REG_JNI(register_android_os_MemoryFile),
  80.         REG_JNI(register_android_os_SharedMemory),
  81.         REG_JNI(register_android_os_incremental_IncrementalManager),
  82.         REG_JNI(register_com_android_internal_content_om_OverlayConfig),
  83.         REG_JNI(register_com_android_internal_content_om_OverlayManagerImpl),
  84.         REG_JNI(register_com_android_internal_net_NetworkUtilsInternal),
  85.         REG_JNI(register_com_android_internal_os_ClassLoaderFactory),
  86.         REG_JNI(register_com_android_internal_os_LongArrayMultiStateCounter),
  87.         REG_JNI(register_com_android_internal_os_LongMultiStateCounter),
  88.         REG_JNI(register_com_android_internal_os_Zygote),
  89.         REG_JNI(register_com_android_internal_os_ZygoteCommandBuffer),
  90.         REG_JNI(register_com_android_internal_os_ZygoteInit),
  91.         REG_JNI(register_com_android_internal_security_VerityUtils),
  92.         REG_JNI(register_com_android_internal_util_VirtualRefBasePtr),
  93.         REG_JNI(register_android_hardware_Camera),
  94.         REG_JNI(register_android_hardware_camera2_CameraMetadata),
  95.         REG_JNI(register_android_hardware_camera2_DngCreator),
  96.         REG_JNI(register_android_hardware_camera2_impl_CameraExtensionJpegProcessor),
  97.         REG_JNI(register_android_hardware_camera2_utils_SurfaceUtils),
  98.         REG_JNI(register_android_hardware_display_DisplayManagerGlobal),
  99.         REG_JNI(register_android_hardware_HardwareBuffer),
  100.         REG_JNI(register_android_hardware_OverlayProperties),
  101.         REG_JNI(register_android_hardware_SensorManager),
  102.         REG_JNI(register_android_hardware_SerialPort),
  103.         REG_JNI(register_android_hardware_SyncFence),
  104.         REG_JNI(register_android_hardware_UsbDevice),
  105.         REG_JNI(register_android_hardware_UsbDeviceConnection),
  106.         REG_JNI(register_android_hardware_UsbRequest),
  107.         REG_JNI(register_android_hardware_location_ActivityRecognitionHardware),
  108.         REG_JNI(register_android_media_AudioDeviceAttributes),
  109.         REG_JNI(register_android_media_AudioEffectDescriptor),
  110.         REG_JNI(register_android_media_AudioSystem),
  111.         REG_JNI(register_android_media_AudioRecord),
  112.         REG_JNI(register_android_media_AudioTrack),
  113.         REG_JNI(register_android_media_AudioAttributes),
  114.         REG_JNI(register_android_media_AudioProductStrategies),
  115.         REG_JNI(register_android_media_AudioVolumeGroups),
  116.         REG_JNI(register_android_media_AudioVolumeGroupChangeHandler),
  117.         REG_JNI(register_android_media_MediaMetrics),
  118.         REG_JNI(register_android_media_MicrophoneInfo),
  119.         REG_JNI(register_android_media_RemoteDisplay),
  120.         REG_JNI(register_android_media_ToneGenerator),
  121.         REG_JNI(register_android_media_audio_common_AidlConversion),
  122.         REG_JNI(register_android_media_midi),
  124.         REG_JNI(register_android_opengl_classes),
  125.         REG_JNI(register_android_ddm_DdmHandleNativeHeap),
  126.         REG_JNI(register_android_backup_BackupDataInput),
  127.         REG_JNI(register_android_backup_BackupDataOutput),
  128.         REG_JNI(register_android_backup_FileBackupHelperBase),
  129.         REG_JNI(register_android_backup_BackupHelperDispatcher),
  130.         REG_JNI(register_android_app_backup_FullBackup),
  131.         REG_JNI(register_android_app_Activity),
  132.         REG_JNI(register_android_app_ActivityThread),
  133.         REG_JNI(register_android_app_NativeActivity),
  134.         REG_JNI(register_android_util_jar_StrictJarFile),
  135.         REG_JNI(register_android_view_InputChannel),
  136.         REG_JNI(register_android_view_InputEventReceiver),
  137.         REG_JNI(register_android_view_InputEventSender),
  138.         REG_JNI(register_android_view_InputQueue),
  139.         REG_JNI(register_android_view_KeyEvent),
  140.         REG_JNI(register_android_view_MotionEvent),
  141.         REG_JNI(register_android_view_MotionPredictor),
  142.         REG_JNI(register_android_view_PointerIcon),
  143.         REG_JNI(register_android_view_VelocityTracker),
  144.         REG_JNI(register_android_view_VerifiedKeyEvent),
  145.         REG_JNI(register_android_view_VerifiedMotionEvent),
  147.         REG_JNI(register_android_content_res_ObbScanner),
  148.         REG_JNI(register_android_content_res_Configuration),
  150.         REG_JNI(register_android_animation_PropertyValuesHolder),
  151.         REG_JNI(register_android_security_Scrypt),
  152.         REG_JNI(register_com_android_internal_content_F2fsUtils),
  153.         REG_JNI(register_com_android_internal_content_NativeLibraryHelper),
  154.         REG_JNI(register_com_android_internal_os_FuseAppLoop),
  155.         REG_JNI(register_com_android_internal_os_KernelAllocationStats),
  156.         REG_JNI(register_com_android_internal_os_KernelCpuBpfTracking),
  157.         REG_JNI(register_com_android_internal_os_KernelCpuTotalBpfMapReader),
  158.         REG_JNI(register_com_android_internal_os_KernelCpuUidBpfMapReader),
  159.         REG_JNI(register_com_android_internal_os_KernelSingleProcessCpuThreadReader),
  160.         REG_JNI(register_com_android_internal_os_KernelSingleUidTimeReader),
  162.         REG_JNI(register_android_window_WindowInfosListener),
  163.         REG_JNI(register_android_window_ScreenCapture),
  164.         REG_JNI(register_jni_common),
  166.         REG_JNI(register_android_tracing_PerfettoDataSource),
  167.         REG_JNI(register_android_tracing_PerfettoDataSourceInstance),
  168.         REG_JNI(register_android_tracing_PerfettoProducer),
  169. };
复制代码


免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。
回复

使用道具 举报

0 个回复

正序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

玛卡巴卡的卡巴卡玛

金牌会员
这个人很懒什么都没写!

楼主热帖

标签云

挺好的 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表