阅读 568

Android系统启动系列----init进程

Android系统启动系列

  1. Android系统启动系列----init进程
  2. Android系统启动系列----Zygote进程

引言

在开发app的过程中,是不是会有疑问:

  • java程序的运行不是从main方法开始么,怎么app入口是Application的onCreate方法?
  • 那java的运行环境虚拟机Dalvik VM和ART又是什么时候创建的?又是由谁创建的?
  • 安卓是Linux内核,那内核创建后系统又做了什么初始化了整个安卓环境?
  • 当我们的手机或者安卓系统设备按下电源按键的时候,系统都做什么?

当按下电源的那一刻都发生了啥:

Android系统启动流程

今天的分析都是基于Android 6.0系统的分析。


第一步:启动电源

当电源按下,引导芯片代码开始从预定义的地方(固化在ROM)开始执行。加载引导程序到RAM,然后执行。

第二步:执行引导程序(Boot Loader)

通常在运行Android系统之前会先执行Boot Loader引导程序,它不属于Android系统,常见的引导程序有:redboot、uboot、qi bootloader等等。或者自行开发引导程序,它是针对特定主板和芯片的,OEM制造厂商或者运营商在加锁的时候就对这个引导程序做修改,比如魅族就是修改了引导程序,所以刷不了机。

第三步:内核

Android内核与桌面linux内核启动的方式差不多。内核启动时,设置缓存、被保护存储器、计划列表,加载驱动。当内核完成系统设置,它首先在系统文件中寻找”init”文件,然后启动root进程或者系统的第一个进程。

第四步:执行init进程

init进程是Android系统启动的第一个用户空间进程,init进程主要做两个事情。第一:挂载目录,如:挂载了/sys /dev /proc 等目录。第二:解析执行init.rc脚本文件。

系统编译,刷入手机后,init的进程保存在/system/core/bin目录中,对应程序的源代码入口是/system/core/init/init.cpp。

int main(int argc, char** argv) {
	if (!is_first_stage) {
      // Indicate that booting is in progress to background fw loaders, etc.
      close(open("/dev/.booting", O_WRONLY | O_CREAT | O_CLOEXEC, 0000));
  	
  	// 初始化属性服务
      property_init();

      // If arguments are passed both on the command line and in DT,
      // properties set in DT always have priority over the command-line ones.
      process_kernel_dt();
      process_kernel_cmdline();

      // Propogate the kernel variables to internal variables
      // used by init as well as the current required properties.
      export_kernel_boot_props();
  }
  
  ........
  
  //  开始属性服务
  start_property_service();
  
  // 初始化“init.rc”配置文件解析器
  init_parse_config_file("/init.rc");

  action_for_each_trigger("early-init", action_add_queue_tail);
  
  ........
}
复制代码

主要看init.rc脚本文件的解析,在说解析前,先来了解下配置脚本的内容,这是一个内建的脚本语言也叫Android初始化语言,有自己的语法结构,大概介绍下: Android初始化语言由四大类型的声明组成,即Actions(动作)、Commands(命令)、Services(服务)、以及Options(选项)。 Action(动作):动作是以命令流程命名的,有一个触发器决定动作是否发生。

on early-init
    # Set init and its forked children's oom_adj.
    write /proc/1/oom_score_adj -1000

    # Set the security context of /adb_keys if present.
    restorecon /adb_keys

    start ueventd

on init
    sysclktz 0

    # Backward compatibility.
    symlink /system/etc /etc
    symlink /sys/kernel/debug /d

    # Link /vendor to /system/vendor for devices without a vendor partition.
    symlink /system/vendor /vendor

    # Create cgroup mount point for cpu accounting
    mkdir /acct
    mount cgroup none /acct cpuacct
    mkdir /acct/uid
复制代码

以上脚本中,on early-init、on init就是 Action类型的语句,语法格式为:

on <trigger> [&& <trigger>]*     //设置触发器  
   <command>  
   <command>      //动作触发之后要执行的命令
复制代码

Service(服务):服务是init进程启动的程序、当服务退出时init进程会视情况重启服务,语法格式为:

 service <name> <pathname> [ <argument> ]*   //<service的名字><执行程序路径><传递参数>  
   <option>       //option是service的修饰词,影响什么时候、如何启动services  
   <option>  
   ... 
复制代码

下面是默认的init.rc文件,主要的事件及其服务。

Action/Service 描述
on early-init 设置init进程以及它创建的子进程的优先级,设置init进程的安全环境
on init 设置全局环境,为cpu accounting创建cgroup(资源控制)挂载点
on fs 挂载mtd分区
on post-fs 改变系统目录的访问权限
on post-fs-data 改变/data目录以及它的子目录的访问权限
on-boot 基本网络的初始化,内存管理等等
service servicemanager 启动系统管理器管理所有的本地服务,比如位置、音频、Shared preference等等…
service zygote 启动zygote进程

通常在这个阶段,我们可以在屏幕上看到“Android logo”字样或者图标。

我们重点来看看zygote进程相关的属性配置,它是独立的一个rc文件在/system/core/rootdir/init.zygote32.rc

service zygote /system/bin/app_process -Xzygote /system/bin --zygote --start-system-server
    class main
    socket zygote stream 660 root system
    onrestart write /sys/android_power/request_state wake
    onrestart write /sys/power/state on
    onrestart restart media
    onrestart restart netd
    writepid /dev/cpuset/foreground/tasks
复制代码

执行zygote程序,其实是通过执行app_process程序,然后传入xzygote等等参数实现的。先找到app_process程序的源码所在地:/frameworks/base/cmds/app_process/app_main.cpp 直接看程序的main函数:

int main(int argc, char* const argv[])
{
    if (prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0) < 0) {
        // Older kernels don't understand PR_SET_NO_NEW_PRIVS and return
        // EINVAL. Don't die on such kernels.
        if (errno != EINVAL) {
            LOG_ALWAYS_FATAL("PR_SET_NO_NEW_PRIVS failed: %s", strerror(errno));
            return 12;
        }
    }

    AppRuntime runtime(argv[0], computeArgBlockSize(argc, argv));
    // Process command line arguments
    // ignore argv[0]
    argc--;
    argv++;

    int i;
    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 < argc) {
        const char* arg = argv[i++];
        if (strcmp(arg, "--zygote") == 0) {
            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;
        }
    }

    Vector<String8> args;
    if (!className.isEmpty()) {
        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"));
        }

        char prop[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());
    }

	// 如果参数是--zygote,那么runtime.start执行zygote进程
    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;
    }
}
复制代码

上面就是通过app_process进程,启动zygote进程的入口,执行启动zygote的程序的在java层的/frameworks/base/core/java/com/android/internal/os/ZygoteInit.java,接下来我们看看:runtime.start("com.android.internal.os.ZygoteInit", args, zygote)都干了啥。 runtime是AppRuntime类的对象,start函数在其父类AndroidRuntime中声明和实现。AndroidRuntime是不是很熟悉了,Android的运行时,通常app异常的时候这玩意是不是总伴随你左右。原来这玩意这么早就启动在监控系统的一举一动了。

/*
 * Start the Android runtime.  This involves starting the virtual machine
 * and calling the "static void main(String[] args)" method in the class
 * named by "className".
 *
 * Passes the main function two arguments, the class name and the specified
 * options string.
 */
void AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote)
{

    ......
	
    /* start the virtual machine */
    JniInvocation jni_invocation;
    jni_invocation.Init(NULL);
    JNIEnv* env;
    if (startVm(&mJavaVM, &env, zygote) != 0) {  // 1
        return;
    }
    onVmCreated(env);   // 2

    /*
     * Register android functions.
     */
    if (startReg(env) < 0) {
        ALOGE("Unable to register all android natives\n");
        return;
    }

    /*
     * We want to call main() with a String array with arguments in it.
     * At present we have two arguments, the class name and an option string.
     * Create an array to hold them.
     */
    jclass stringClass;
    jobjectArray strArray;
    jstring classNameStr;

    stringClass = env->FindClass("java/lang/String");
    assert(stringClass != NULL);
    strArray = env->NewObjectArray(options.size() + 1, stringClass, NULL);
    assert(strArray != NULL);
    classNameStr = env->NewStringUTF(className);
    assert(classNameStr != NULL);
    env->SetObjectArrayElement(strArray, 0, classNameStr); 

    for (size_t i = 0; i < options.size(); ++i) {
        jstring optionsStr = env->NewStringUTF(options.itemAt(i).string());
        assert(optionsStr != NULL);
        env->SetObjectArrayElement(strArray, i + 1, optionsStr);
    }

    /*
     * 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);  // 3
    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");  // 4
        if (startMeth == NULL) {
            ALOGE("JavaVM unable to find main() in '%s'\n", className);
            /* keep going */
        } else {
            env->CallStaticVoidMethod(startClass, startMeth, strArray);  // 5

#if 0
            if (env->ExceptionCheck())
                threadExitUncaughtException(env);
#endif
        }
    }
	
    ......
}
复制代码
  1. 注释1:startVm顾名思义启动虚拟机,在此启动java虚拟机,当然这个是运行zygote进程的虚拟机,也就回答了文章最开始引言问题,虚拟机由app_process的AndroidRuntime创建。
  2. 注释2:虚拟机创建后的回调处理,主要是创建一些资源。
  3. 注释3:className就是app_process中传入的参数“com.android.internal.os.ZygoteInit”,因为ZygoteInit是java层的,所以需要使用jni来找到ZygoteInit.class,startClass就是ZygoteInit.class
  4. 注释4:通过jni的GetStaticMethodID函数获取到ZygoteInit.java的静态main方法的类似于反射的Mehod对象引用。
  5. 注释5:最后通过JNI的CallStaticVoidMethod函数类似于java反射的invoke方法,调用了4中获取的main方法的Method引用。 (如果对JNI不熟的可以看看JNI系列入门文章

如上就是Zygote进程的启动方式。


总结

  1. 手机按下电源后,加载引导程序到内存中。
  2. 执行引导程序
  3. 启动内核,设置缓存、被保护存储器、计划列表,加载驱动,查找/system/core/bin中init程序文件。
  4. 启动init程序,挂载/sys /dev /proc等等目录,加载和解析init.rc脚本。
  5. 在加载init.rc脚本的时候,启动app_process进程。
  6. 在app_process进程中,根据init.zygote32.rc脚本配置的参数,启动zygote进程。
  7. 最终zygote进程的执行,即ZygoteInit.java文件main方法的执行,是由AndroidRuntime通过JNI的方式调用main方法执行的。在这之前启动了Dalvik VM或者ART虚拟机。

Android系统启动系列

  1. Android系统启动系列----init进程
  2. Android系统启动系列----Zygote进程
关注下面的标签,发现更多相似文章
评论