学习- Android启动流程

Bootloader(配置启动Linux)---> 加载 kernel (内核) --> 创建init进程

--> init进程启动 system/core/init/init.cpp 代码 -->

{
init.cpp ---> LoadBootScripts()---> parser.ParseConfig(bootscript)
}
aosp/system/core/init/parser.h

{
加载 system/core/rootdir/init.rc 配置 ---> trigger zygote-start

import /init.${ro.zygote}.rc
查看架构得出 执行文件是 init.zygote64_32.rc
adb shell getprop | findstr ro.zygote --> 得到 init.zygote64_32.rc

执行
service zygote /system/bin/app_process64 -Xzygote /system/bin --zygote --start-system-server --socket-name=zygote
service zygote_secondary /system/bin/app_process32 -Xzygote /system/bin --zygote --socket-name=zygote_secondary

--zygote 创建 zygote进程
-start-system-server
--socket-name=zygote 创建zygote名字的socket

1.3、调用system/core/init/service.cpp # Service::start 函数创建zygote进程和/system/core/init/util.cpp # create_socket函数创建名为zygote 的socket

但它们进程的可执行文件都是app_process，对应的源码在/frameworks/base/cmds/app_process/app_main.cpp。

}
---> app_main.cpp执行文件-->

{
argv[0] --zygote
AppRuntime runtime(argv[0], computeArgBlockSize(argc, argv));
runtime.start("com.android.internal.os.ZygoteInit", args, zygote);
runtime.start("com.android.internal.os.RuntimeInit", args, zygote);
}
--->
AppRuntime runtime

{

// 判断system-server 是否启动
static const String8 startSystemServer("start-system-server");

/*
 * 'startSystemServer == true' means runtime is obsolete and not run from
 * init.rc anymore, so we print out the boot start event here.
 */
for (size_t i = 0; i < options.size(); ++i) {
    if (options[i] == startSystemServer) {
       /* track our progress through the boot sequence */
       const int LOG_BOOT_PROGRESS_START = 3000;
       LOG_EVENT_LONG(LOG_BOOT_PROGRESS_START,  ns2ms(systemTime(SYSTEM_TIME_MONOTONIC)));
    }
}
// 创建目录
const char* rootDir = getenv("ANDROID_ROOT");
if (rootDir == NULL) {
    rootDir = "/system";
    if (!hasDir("/system")) {
        LOG_FATAL("No root directory specified, and /android does not exist.");
        return;
    }
    setenv("ANDROID_ROOT", rootDir, 1);
}

//const char* kernelHack = getenv("LD_ASSUME_KERNEL");
//ALOGD("Found LD_ASSUME_KERNEL='%s'\n", kernelHack);

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

/*
 * 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);
// className = com.android.internal.os.ZygoteInit
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 != NULL ? 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 {
    // 将zygote 的初始化传递到zygoteInit  运行到了com.android.internal.os.ZygoteInit 的main方法
        env->CallStaticVoidMethod(startClass, startMeth, strArray);

if 0

        if (env->ExceptionCheck())
            threadExitUncaughtException(env);

endif

    }
}
free(slashClassName);

}

---> ZygoteInit.java main方法

{

fork system-server 进程
Zygote.forkSystemServer(
parsedArgs.uid, parsedArgs.gid,
parsedArgs.gids,
parsedArgs.runtimeFlags,
null,
parsedArgs.permittedCapabilities,
parsedArgs.effectiveCapabilities);

String args[] = {
"--setuid=1000",
"--setgid=1000",
"--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,1021,1023,1024,1032,1065,3001,3002,3003,3006,3007,3009,3010",
"--capabilities=" + capabilities + "," + capabilities,
"--nice-name=system_server",
"--runtime-args",
"--target-sdk-version=" + VMRuntime.SDK_VERSION_CUR_DEVELOPMENT,
"com.android.server.SystemServer",
};

2: 配置system-server
forkSystemServer(abiList, socketName, zygoteServer);-->Zygote.forkSystemServer()(fork system-server 进程) -->handleSystemServerProcess()

--> RuntimeInit.applicationInit(targetSdkVersion, argv, classLoader);-- findStaticMain(args.startClass, args.startArgs, classLoader);
调用 SystemServer main 方法 处理 system _server 进程

}

1: 上电 启动Bootloader

内核世界
BootLoader:引导加载程序 BootLoader启动Linux系统 是上电后在操作系统执行前的第一段代码.

作用:
1:初始化硬件设备
2:加载操作系统内核
3:加载内存空间映射图

Android 基于linux系统  在这个系统中内核加载和启动是由BootLoader完成的

BootLoader  加载 kernel  -- init进程
idle 是linux的第一个进程 init是Linux的第一个用户进程

idle进程 pid=0 init pid=1  
idle 是init_task退化而来 是Linux系统的第一个进程 是唯一一个没通过fork和kernel_thread产生的进程.
init_task 是Linux内核中所有进程的雏形


idle进程是通过汇编实现的是init和kthread的父进程   执行 start_kernel 加载操作系统内核   调用 rest_init进程和kthreadd进程 进入linux进程


start_kernel 调用rest_init函数 开始了linux的进程

BootLoader --->  start_kernel  --> rest_init  --> init进程 (开启了linux进程)

2:进入Linux世界

init 执行到了 system/core/init/init.cpp代码

    main--->  LoadBootScripts(am, sm);-->  parser.ParseConfig("/init.rc"); 启动zygote
    
init.rc  system/core/rootdir/init.rc    

        import /init.${ro.zygote}.rc
        adb shell getprop | findstr ro.zygote  --> 得到 init.zygote64_32.rc

        /system/core/rootdir/init.zygote64_32.rc
        
        ---> 
        service zygote /system/bin/app_process64 -Xzygote /system/bin --zygote --start-system-server --socket-name=zygote
        
        
        service zygote_secondary /system/bin/app_process32 -Xzygote /system/bin --zygote --socket-name=zygote_secondary
        
        文件位置
        /frameworks/base/cmds/app_process/app_main.cpp
        
        到service 指令时就会相应地调用system/core/init/service.cpp   启动服务调用到 service.cpp 
        
        system/core/init/service.cpp # Service::start   函数创建zygote进程和/system/core/init/util.cpp # create_socket函数创建名为zygote 的socket
        
        app_main.cpp  代码  创建 AndroidRuntime.cpp
        \frameworks\base\core\jni\AndroidRuntime.cpp
            
             runtime.start("com.android.internal.os.ZygoteInit", args, zygote);
             runtime.start("com.android.internal.os.RuntimeInit", args, zygote);
             
        //jni调用传入的className 即 com.android.internal.os.ZygoteInit的main函数
        env->CallStaticVoidMethod(startClass, startMeth, strArray);

/frameworks/base/core/java/com/android/internal/os/ZygoteInit.java

ZygoteInit.java main--> ZygoteServer ZygoteServer 是Zygote进程的Socket通讯服务端的管理类
ZygoteHooks.startZygoteNoThreadCreation(); 启动 zygote

init 进程 启动流程  BootLoader  --> kernel---> 启动init进程
         
    BootLoader --->  start_kernel  --> rest_init  --> init进程 (开启了linux进程)    
         
         
init.cpp---> init.rc--->    /system/core/rootdir/init.zygote64_32.rc  通过Server.cpp 启动了Zygote进程   

    然后执行
    
    /frameworks/base/cmds/app_process/app_main.cpp
    
    main{
    AndroidRuntime.cpp
      runtime.start("com.android.internal.os.ZygoteInit", args, zygote);
      runtime.start("com.android.internal.os.RuntimeInit", args, zygote);
      
     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);
    }
         
    // 启动到了  java ZygoteInit.java  的main 方法 来到了java世界    

java世界

ZygoteInit
fork system-server 进程
String socketName = "zygote";
String abiList = null;
boolean enableLazyPreload = false;
for (int i = 1; i < argv.length; i++) {
if ("start-system-server".equals(argv[i])) {
startSystemServer = true;
} else if ("--enable-lazy-preload".equals(argv[i])) {
enableLazyPreload = true;
} else if (argv[i].startsWith(ABI_LIST_ARG)) {
abiList = argv[i].substring(ABI_LIST_ARG.length());
} else if (argv[i].startsWith(SOCKET_NAME_ARG)) {
socketName = argv[i].substring(SOCKET_NAME_ARG.length());
} else {
throw new RuntimeException("Unknown command line argument: " + argv[i]);
}
}

    Runnable r = forkSystemServer(abiList, socketName, zygoteServer);        
         
                pid = Zygote.forkSystemServer(
                parsedArgs.uid, parsedArgs.gid,
                parsedArgs.gids,
                parsedArgs.runtimeFlags,
                null,
                parsedArgs.permittedCapabilities,
                parsedArgs.effectiveCapabilities);
         

         String args[] = {
        "--setuid=1000",
        "--setgid=1000",
        "--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,1021,1023,1024,1032,1065,3001,3002,3003,3006,3007,3009,3010",
        "--capabilities=" + capabilities + "," + capabilities,
        "--nice-name=system_server",
        "--runtime-args",
        "--target-sdk-version=" + VMRuntime.SDK_VERSION_CUR_DEVELOPMENT,
        "com.android.server.SystemServer",   //className
    };
    
    
    fork进程
    
          pid = Zygote.forkSystemServer(
                parsedArgs.uid, parsedArgs.gid,
                parsedArgs.gids,
                parsedArgs.runtimeFlags,
                null,
                parsedArgs.permittedCapabilities,
                parsedArgs.effectiveCapabilities);
    
        完成fok进程后操作
         handleSystemServerProcess(parsedArgs)
         
         ZygoteInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs, cl)--->RuntimeInit.applicationInit(targetSdkVersion, argv, classLoader)
         -->findStaticMain(args.startClass, args.startArgs, classLoader)
         
         --通过反射 调用 SystemServer main方法
         
         
         最后回到  ZygoteInit
         
            Runnable r = forkSystemServer(abiList, socketName, zygoteServer);

            // {@code r == null} in the parent (zygote) process, and {@code r != null} in the
            // child (system_server) process.
            if (r != null) {
                r.run();
                return;
            }
         
          zygoteServer.runSelectLoop(abiList);
          --> if (i == 0) {
                ZygoteConnection newPeer = acceptCommandPeer(abiList);
                peers.add(newPeer);
                fds.add(newPeer.getFileDesciptor());
            }
            -->
        //创建Socket
private ZygoteConnection acceptCommandPeer(String abiList) {
    try {
        return createNewConnection(mServerSocket.accept(), abiList);
    } catch (IOException ex) {
        throw new RuntimeException(
                "IOException during accept()", ex);
    }
}
            

         
启动了SystemServer


        1:处理默认语言 城市
       if (!SystemProperties.get("persist.sys.language").isEmpty()) {
            final String languageTag = Locale.getDefault().toLanguageTag();

            SystemProperties.set("persist.sys.locale", languageTag);
            SystemProperties.set("persist.sys.language", "");
            SystemProperties.set("persist.sys.country", "");
            SystemProperties.set("persist.sys.localevar", "");
        }
        2:初始化MainLooper
        
                        android.os.Process.setThreadPriority(
            android.os.Process.THREAD_PRIORITY_FOREGROUND);
        android.os.Process.setCanSelfBackground(false);
        Looper.prepareMainLooper();
        Looper.getMainLooper().setSlowLogThresholdMs(
                SLOW_DISPATCH_THRESHOLD_MS, SLOW_DELIVERY_THRESHOLD_MS);

        3:创建系统的 Context
            createSystemContext()
            
              private void createSystemContext() {
              创建系统的 Context  初始化 ActivityThread  
                    ActivityThread activityThread = ActivityThread.systemMain();
                    mSystemContext = activityThread.getSystemContext();
                    mSystemContext.setTheme(DEFAULT_SYSTEM_THEME);
                    设置 主题
                    final Context systemUiContext = activityThread.getSystemUiContext();
                    systemUiContext.setTheme(DEFAULT_SYSTEM_THEME);
                }
                
        ActivityThread 
                 systemMain(){
                 
                         // The system process on low-memory devices do not get to use hardware
                            // accelerated drawing, since this can add too much overhead to the
                        // process.
                    if (!ActivityManager.isHighEndGfx()) {
                        ThreadedRenderer.disable(true);
                    } else {
                        ThreadedRenderer.enableForegroundTrimming();
                    }
                        // 创建 Instrumentation Application  
                        ActivityThread thread = new ActivityThread();
                        thread.attach(true, 0);
                 }
        4:创建 SystemServiceManager 系统服务管理类  管理系统服务(SystemService)的生命周期
        
        
        5:启动服务
        --->
        startBootstrapServices();
                Installer:安装器
                DeviceIdentifiersPolicyService: 设备标识符 的服务
                ActivityManagerService : 主要负责Android中四大组件的启动、通信、部分生命周期的管理等等
                PowerManagerService :上电服务管理
                StartRecoverySystemService 恢复设置服务\
                StartLightsService: 背光亮度服务
                DisplayManagerService: 显示器服务
                PackageManagerService: 包管理服务
        --->        
        startCoreServices();
                BatteryService: 电池服务
                WebViewUpdateService
                BinderCallsStatsService
        --->        
        startOtherServices();
        NetworkManagementService 网络服务
        TelephonyRegistry 电话
        AlarmManagerService 通知
        WindowManagerService Window管理服务
        
        --->            
        启动Luancher
           mActivityManagerService.systemReady(() -> {
            //在接收到这个引导阶段之后，服务可以广播Intents
             mSystemServiceManager.startBootPhase(
                SystemService.PHASE_ACTIVITY_MANAGER_READY);
                // SYSTEMUI   启动了
            startSystemUi(context, windowManagerF);
            //启动看门狗
                  Watchdog.getInstance().start();
            // 三方程序可以启动了
            mSystemServiceManager.startBootPhase(
                SystemService.PHASE_THIRD_PARTY_APPS_CAN_START);
            
           }
           
           ActivityManagerService   mActivityManagerService.systemReady(() -> {}
           
    
           systemReady(final Runnable goingCallback, TimingsTraceLog traceLog) {
             startHomeActivityLocked(currentUserId, "systemReady");
           }
            
            
            
            
        ...

bootloader 加载 init.cpp

init.cpp :/system/core/init/init.cpp 挂载 init.rc

init.rc /system/core/rootdir/init.rc ---> trigger zygote-start zygote 启动

BootLoader---> linux内核 加载各种驱动 --->加载init.rc(加载配置文件)

--->