Android 系统启动

要点

在这里插入图片描述

流程

在这里插入图片描述

Init进程启动过程

init进程是Android系统中用户空间的第一个进程,进程号pid为1,是Android系统启动流程中一个关键的步骤,作为第一个进程,它被赋予了很多极其重要的工作职责,比如创建Zygote(孵化器)和属性服务等。

Init进程开启前几步流程

在Init进程开启前还有几步流程的,这里我们先来了解下Android系统启动流程的前几步。如下,当我们按下启动电源时,系统启动后会加载引导程序,引导程序又启动Linux 内核,在Linux 内核加载完成后,第一件事就是要启动init 进程。

  1. 启动电源以及系统启动:当电源按下时引导芯片代码从预定义的地方(固化在ROM)开始执行。加载引导程序BootLoader到RAM中。
  2. 引导程序BootLoader:引导程序BootLoader是在Android操作系统开始运行前的一个小程序,它的主要作用是把系统OS拉起来并运行
  3. Linux内核启动:当内核启动时,设置缓存、被保护存储器、计划列表、加载驱动。在内核完成系统设置后,它首先在系统文件中寻找init.rc文件,并启动init进程
  4. init进程启动
Init进程做了哪些事?

在Linux内核加载完成后,会启动init进程,同时在系统文件中寻找init.rc文件,init进程的main方法如下(system\core\init.init.cpp 核心代码):


int main(int argc, char** argv) {
 //1、创建和挂载启动所需的文件目录,其中挂载了
 //tmpfs、devpts、proc、sysfs和selinuxfs共5种文件系统
 //这些都是系统运行时目录,只在系统运行时才会存在,系统停止时会消失
 mount("tmpfs", "/dev", "tmpfs", MS_NOSUID, "mode=0755");
 mkdir("/dev/pts", 0755);
 mkdir("/dev/socket", 0755);
 mount("devpts", "/dev/pts", "devpts", 0, NULL);
 #define MAKE_STR(x) __STRING(x)
 mount("proc", "/proc", "proc", 0, "hidepid=2,gid=" MAKE_STR(AID_READPROC));
 chmod("/proc/cmdline", 0440);
 gid_t groups[] = { AID_READPROC };
 setgroups(arraysize(groups), groups);
 mount("sysfs", "/sys", "sysfs", 0, NULL);
 mount("selinuxfs", "/sys/fs/selinux", "selinuxfs", 0, NULL);
 mknod("/dev/kmsg", S_IFCHR | 0600, makedev(1, 11));
 mknod("/dev/random", S_IFCHR | 0666, makedev(1, 8));
 mknod("/dev/urandom", S_IFCHR | 0666, makedev(1, 9));

//2、对属性服务进行初始化
 property_init();

//3、用于设置子进程信号处理函数,系统会在子进程暂停、终止时发出SIGCHLD信号

//而signal_handler_init()函数就是用来接收SIGCHLD信号的(其内部只处理SIGCHLD信号)
//,如收到子进程终止信号,方法内部会层层处理,最终找到子进程并移除子进程的所有信息。
//再在6处重新开启进程。
//这个信号处理主要为了防止init进程的子进程成为僵尸进程。
//在UNIX/Linux中,父进程使用fork创建子进程,在子进程终止之后,
//如果父进程并不知道子进程已经终止了,这时子进程虽然已经退出了,
//但是在系统进程表中还为它保留了一定的信息(比如进程号、退出状态、运行时间等),
//这个子进程就被称作僵尸进程。系统进程表是一项有限资源,如果系统进程表被僵尸
//进程耗尽的话,系统就可能无法创建新的进程了。
 signal_handler_init();

//4、启动属性服务
//Windows 平台上有一个注册表管理器,Android也提供了一个类似的机制,叫作属性服务.
//注册表管理器记录用户、软件的一些使用信息。即使系统或者软件重启,其还是能够根据
//之前注册表中的记录,进行相应的初始化工作

//其实属性服务就是一个Socket 能够同时处理多个用户(client)请求
 start_property_service();
 
 //5、解析init.rc 配置文件
 parser.ParseConfig("/init.rc");
 
 //6、重启死去的进程
 restart_processes();
}
init.rc 文件简介

init.rc文件中配置了一些init要开启的进程,这些进程在init 进程中创建如zygote进程、serviceManager进程、surfaceFligner进程、mediaServer进程。

init进程启动总结,总的来说主要做了以下三件事
  • 创建和挂载启动所需的文件目录。
  • 初始化和启动属性服务。
  • 解析init.rc配置文件并启动Zygote进程。

Zygote进程启动过程

在Android系统中,DVM和ART、应用程序进程以及运行系统的关键服务的SystemServer进程都是由Zygote进程来创建的,我们也将它称为孵化器。它通过fock(复制进程)的形式来创建应用程序进程和SystemServer进程,由于Zygote进程在启动时会创建DVM或者ART,因此通过fock而创建的应用程序进程和SystemServer进程可以在内部获取一个DVM或者ART的实例副本。

Zygote进程是在init进程启动时创建的,起初Zygote进程的名称并不是叫“zygote”,而是叫“app_process”,这个名称是在Android.mk中定义的,Zygote进程启动后,Linux系统下的pctrl系统会调用app_process,将其名称换成了“zygote”。

Zygote进程的启动过程

Android 8.0对init.rc文件进行了拆分,每个服务对应一个rc文件。在init.rc中通过安卓初始化语言import 语句来引入Zygote 的rc文件。然后通过ServiceParse类的parseSection、parseLineSection进行解析rc文件中的Service语句,得到可执行程序路径,运行可执行程序,启动Zygote进程。init启动Zygote时主要是调用app_main.cpp的main函数中的AppRuntime的start方法来启动Zygote进程的。

#init.rc

import /init.${ro.zygote}.rc // 根据{ro.zygote}的值动态加载对应的Zygote.rc文件

#init.zygote32.rc

service zygote /system/bin/app_process -Xzygote /system/bin --zygote --start-system-server
    class main
    priority -20
    user root
    group root readproc
    socket zygote stream 660 root system
    onrestart write /sys/android_power/request_state wake
    onrestart write /sys/power/state on
    onrestart restart audioserver //audioserver进程终止了就重启进程
    onrestart restart cameraserver//进程终止了就重启进程
    onrestart restart media//进程终止了就重启进程
    onrestart restart netd
    onrestart restart wificond
    writepid /dev/cpuset/foreground/tasks
/*
如上脚本:
1、zygote  要开启的进程名
2、app_process 要执行程序名,位置在/system/bin/路径下
3、main classname
4、如果audioserver、cameraserver、media等进程终止了,就需要进行restart(重启)
*/

#frameworks\base\cmds\app_process\app_main.cpp

int main(int argc, char* const argv[]){
/*
Zygote 进程都是通过fock 自身来创建子进程的,
这样Zygote 进程以及它的子进程都可以进入app_main.cpp的main函数,
因此main函数中为了区分当前运行在哪个进程,进行如下判断。
*/

 while (i < argc) {
      const char* arg = argv[i++];
      //如果当前运行在Zygote进程中则将zygote设置为true
        if (strcmp(arg, "--zygote") == 0) {
            zygote = true;
            niceName = ZYGOTE_NICE_NAME;
      //如果当前运行在SystemServer进程中则处将startSystemServer 设置为true
        } 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;
        }
    }

...


 if (zygote) {//如果为zygote进程则调用Runtime的start方法。
        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.");
    }

}

#frameworks\base\core\jni\AndroidRuntime.cpp

    //开启JVM 
    JniInvocation jni_invocation;
    jni_invocation.Init(NULL);
    JNIEnv* env;
    if (startVm(&mJavaVM, &env, zygote) != 0) {
        return;
    }
   //为jvm注册jni方法
    if (startReg(env) < 0) {
        ALOGE("Unable to register all android natives\n");
        return;
    }

jstring classNameStr;
// 从app_main.cppde的main方法可知className为com.android.internal.os.ZygoteInit
classNameStr = env->NewStringUTF(className);

// 找到ZygoteInit 类
 char* slashClassName = toSlashClassName(className);
    jclass startClass = env->FindClass(slashClassName);
    
 if (startClass == NULL) {
        ALOGE("JavaVM unable to locate class '%s'\n", slashClassName);
     
    } else {// 找到ZygoteInit 类的main方法。
        jmethodID startMeth = env->GetStaticMethodID(startClass, "main",
            "([Ljava/lang/String;)V");
        if (startMeth == NULL) {
            ALOGE("JavaVM unable to find main() in '%s'\n", className);
         
        } else {
        // 通过jni调用ZygoteInit的main 方法。
            env->CallStaticVoidMethod(startClass, startMeth, strArray);

#if 0      
            if (env->ExceptionCheck())
                threadExitUncaughtException(env);
#endif
        }
    }

/*
这里为何要使用JNI呢?因为ZygoteInit的main方法是由Java语言编写的,
当前的运行逻辑在Native中,这就需要通过JNI来调用Java。这样Zygote
就从Native层进入了Java框架层。

在我们通过JNI调用ZygoteInit的main方法后,Zygote便进入了Java框架层,
此前是没有任何代码进入Java框架层的,换句话说是Zygote开创了Java框架层
*/

#ZygoteInit&main

  public static void main(String argv[]) {
        ...
        try {
		...				
          	//1. 创建一个 Server 端的 Socket,socketName 为 zygote
          	//Zygote进程将SystemServer进程启动后,就会在这个服务器端
          	//的Socket上等待AMS请求Zygote进程来创建新的应用程序进程。
            zygoteServer.registerServerSocketFromEnv(socketName);
            
            if (!enableLazyPreload) {
                bootTimingsTraceLog.traceBegin("ZygotePreload");
                EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_START,
                    SystemClock.uptimeMillis());
              	//2. 预加载资源和类
                preload(bootTimingsTraceLog);
                EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_END,
                    SystemClock.uptimeMillis());
                bootTimingsTraceLog.traceEnd(); 
            } else {
                Zygote.resetNicePriority();
            }
		...
            if (startSystemServer) {
              	//3. 启动 SystemServer 进程,system_server;启动的类名为
              	//com.android.server.SystemServer
              	//系统的服务会由SystemServer进程启动起来
                Runnable r = forkSystemServer(abiList, socketName, zygoteServer);
		    //4. 等待 AMS 请求
		    //调用ZygoteServer的runSelectLoop方法来等待AMS请求创建新的应用程序进程
		    //AMS请求成功时会通过ZygoteConnection的runOnce函数来创建一个新的应用程
		    //序进程
            caller = zygoteServer.runSelectLoop(abiList);
        } catch (Throwable ex) {
            Log.e(TAG, "System zygote died with exception", ex);
            throw ex;
        } finally {
            zygoteServer.closeServerSocket();
        }
    }
Zygote进程启动总结:Zygote进程启动共主要如下几件事
  • 创建AppRuntime并调用其start方法,启动Zygote进程。
  • 创建Java虚拟机并为Java虚拟机注册JNI方法。
  • 通过JNI调用ZygoteInit的main函数进入Zygote的Java框架层。
  • 通过registerZygoteSocket方法创建服务器端Socket,并通过runSelectLoop方法等待AMS的请求来创建新的应用程序进程。
  • 启动SystemServer进程。

SystemSever的处理过程

Zygote进程启动了SystemServer进程。具体是在ZygoteInit.java的startSystemServer方法中启动了SystemServer进程。SystemServer进程主要用于创建系统服务,我们熟知的AMS、WMS和PMS都是由它来创建的。

#ZygoteInit.java

        //当前进程运行在SystemSever进程中
        if (pid == 0) {
            if (hasSecondZygote(abiList)) {
                waitForSecondaryZygote(socketName);
            }
            //SystemServer 进程复制了Zygote进程的地址空间,因此也会得到Zygote进程创建
            //的Socket,这个Socket对于SystemServer进程没有用处,因此,需要注释1处的代
            //码来关闭该Socket
            zygoteServer.closeServerSocket();
            //启动SystemSever进程
            handleSystemServerProcess(parsedArgs);
        }

 private static void handleSystemServerProcess(
            ZygoteConnection.Arguments parsedArgs)
            throws Zygote.MethodAndArgsCaller {
 
            ClassLoader cl = null;
            if (systemServerClasspath != null) {
            //创建PathClassLoader
                cl = createPathClassLoader(systemServerClasspath, parsedArgs.targetSdkVersion);
                Thread.currentThread().setContextClassLoader(cl);
            }
             //调用了ZygoteInit的zygoteInit方法作用:
             //1、启动Binder线程池。
             //2、进入SystemServer的main方法
            ZygoteInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs, cl);

 public static final void zygoteInit(int targetSdkVersion, String[] argv,
            ClassLoader classLoader) throws Zygote.MethodAndArgsCaller {
        if (RuntimeInit.DEBUG) {
            Slog.d(RuntimeInit.TAG, "RuntimeInit: Starting application from zygote");
        }

        Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ZygoteInit");
        RuntimeInit.redirectLogStreams();

        RuntimeInit.commonInit();
             //启动Binder线程池:
             //这样SystemServer进程就可以使用Binder与其
             //他进程进行通信了。具体是调用nativeZygoteInit 这个native方法最终
             //是app_main.cpp中AndroidRuntime的子类AppRuntime的onZygoteInit
             //方法开启。
        ZygoteInit.nativeZygoteInit();
        //进入SystemServer的main方法
        //内部通过反射调用找到SystemServer类,调用类的main方法。
        RuntimeInit.applicationInit(targetSdkVersion, argv, classLoader);
    }
}

#SystemSever.java

...
           //创建Looper
            Looper.prepareMainLooper();

            // 加载动态库libandroid_sever.so
            System.loadLibrary("android_servers");

            // Check whether we failed to shut down last time we tried.
            // This call may not return.
            performPendingShutdown();

            // 创建系统context
            createSystemContext();

            //创建SystemServiceManager,它会对系统服务进行创建、启动和生命周期管理
            mSystemServiceManager = new SystemServiceManager(mSystemContext);

            traceBeginAndSlog("StartServices");
            //分批启动系统服务,这些服务的父类均为SystemService.
            startBootstrapServices();//启动引导服务:用SystemServiceManager启动了ActivityManagerService、PowerManagerService、PackageManagerService等服务
            startCoreServices();//启动核心服务:启动了DropBoxManagerService、BatteryService、UsageStatsService和WebViewUpdateService
            startOtherServices();//启动其他服务:启动了CameraService、AlarmManagerService、VrManagerService等服务
            SystemServerInitThreadPool.shutdown();
SystemServer进程被创建后,主要做了如下工作:
  • 启动Binder线程池,这样就可以与其他进程进行通信。
  • 创建SystemServiceManager,其用于对系统的服务进行创建、启动和生命周期管理
  • 启动各种系统服务。

Launcher 启动过程

系统启动的最后一步是启动一个app用来显示系统中已经安装的应用程序,这个应用程序就叫作Launcher。

Launcher app 启动时会使用系统的PackageManagerService,获得系统中已经安装的应用程序的信息,并将这些信息封装成一个快捷图标列表显示在系统屏幕上。用户点击这些快捷图标时就启动相应的应用程序。

Launcher的启动过程

我们知道Zygote进程的主要作用就是孵化应用进程,Zygote进程启动后有一步要做的就是开启一个Socket等待AMS请求创建应用进程。

SystemServer进程在启动的过程中会启动ASM,PackageManagerService,等各种服务。ASM会请求Zygote进程中的Socket,请求创建启动Launcher进程。PackageManagerService启动后会将系统中的应用程序安装完成。这样launcher就可以查询PMS中的应用信息,显示在桌面上啦!

Launcher的主要总用小结
  • 作为Android系统的启动器,用于启动应用程序。
  • 作为Android系统的桌面,用于显示和管理应用程序的快捷图标或者其他桌面组件。

Android系统启动流程总结

Android系统启动流程主要有以下几个部分:

1.启动电源以及系统启动

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

2.引导程序BootLoader

引导程序BootLoader是在Android操作系统开始运行前的一个小程序,它的主要作用是把系统OS拉起来并运行。

3.Linux内核启动

当内核启动时,设置缓存、被保护存储器、计划列表、加载驱动。当内核完成系统设置时,它首先在系统文件中寻找init.rc文件,并启动init进程。

4.init进程启动

初始化和启动属性服务,解析rc文件启动Zygote进程。

5.Zygote进程启动

创建Java虚拟机并为Java虚拟机注册JNI方法,创建服务器端Socket等待AMS请求,启动SystemServer进程。

6.SystemServer进程启动

启动Binder线程池和SystemServiceManager,并且启动各种系统服务。

7.Launcher启动

被SystemServer进程启动的AMS会启动Launcher,Launcher启动后会将已安装应用的快捷图标显示到界面上。

The end

参考
安卓进阶解密:微信读书版

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值