【深入内核篇】Android启动过程

一、Android 启动全景图

1.1 从按下电源键到桌面显示

Android 的启动过程从硬件到用户界面，经历六个阶段：

1. Boot ROM (出厂固化代码)
     └── 加载 Bootloader 到内存
2. Bootloader (LK/ABL)
     ├── Verified Boot (AVB/dm-verity)
     ├── A/B Slot 选择
     └── 加载 Linux Kernel
3. Linux Kernel
     ├── start_kernel() → rest_init() → kernel_init()
     └── 挂载根文件系统 → 执行 /init
4. Init Process
     ├── FirstStageMain → SetupSelinux → SecondStageMain
     ├── 解析 init.rc → 启动关键服务
     └── 启动 Zygote
5. Zygote
     ├── AndroidRuntime::start()
     ├── 预加载类 + 资源
     ├── fork SystemServer
     └── runSelectLoop (socket 监听)
6. SystemServer
     ├── 启动引导服务 (AMS/PMS/PowerManager)
     ├── 启动核心服务 (Battery/UsageStats)
     ├── 启动其他服务 (WMS/Input/StatusBar)
     └── systemReady → 启动 Launcher

1.2 AOSP 关键源码路径速查

阶段	AOSP 路径
Bootloader	bootable/bootloader/lk/ (Little Kernel)
Kernel	kernel/ / common/ (Android Common Kernel)
Init	system/core/init/
Init.rc	system/core/rootdir/init.rc
SELinux	system/core/init/selinux.cpp
Zygote	frameworks/base/core/jni/AndroidRuntime.cpp
Zygote (Java)	frameworks/base/core/java/com/android/internal/os/ZygoteInit.java
SystemServer	frameworks/base/services/java/com/android/server/SystemServer.java
AMS	frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
PMS	frameworks/base/services/core/java/com/android/server/pm/PackageManagerService.java
WMS	frameworks/base/services/core/java/com/android/server/wm/WindowManagerService.java

---

二、Boot ROM 与 Bootloader

2.1 Boot ROM

Boot ROM 是芯片出厂时固化在 SoC 内部的代码，存储在掩膜 ROM 中，不可修改。它是系统上电后执行的第一条指令。

Boot ROM 的职责：

• 初始化最小硬件（CPU、时钟、看门狗）
• 从 eMMC/UFS 或 SD 卡加载 Bootloader 的第一阶段到内部 SRAM
• 验证 Bootloader 的签名（Secure Boot）
• 跳转到 Bootloader 入口

源码：Boot ROM 代码由 SoC 厂商（Qualcomm、MediaTek、Samsung）编写，不公开。但 AOSP 中 bootable/bootloader/ 提供了参考实现。

2.2 Little Kernel (LK) / ABL

Android 设备通常使用 Little Kernel (LK) 作为 Bootloader，在较新的设备中可能使用 **ABL (Android Bootloader)**。两者都是从 Qualcomm 的 LK 派生。

AOSP 源码路径：bootable/bootloader/lk/

LK 的主要功能：

LK 启动流程:
├── arch_init()           # 架构相关初始化
├── platform_init()       # 平台相关初始化
├── target_init()         # 设备特定初始化
│   ├── 初始化 DDR 内存控制器
│   ├── 初始化 eMMC/UFS 控制器
│   └── 初始化显示（为 Recovery/充电画面做准备）
├── apps_init()
│   ├── aboot_init()      # Android Boot 初始化
│   │   ├── 读取 misc 分区（判断 Recovery 模式）
│   │   ├── 读取 bootloader 消息
│   │   └── 加载 boot/recovery 分区
│   └── fastboot_init()   # Fastboot 模式
└── 跳转到 Kernel

2.3 Verified Boot (AVB 2.0)

Android Verified Boot (AVB) 是 Android 的安全启动链验证机制。

AOSP 源码路径：external/avb/

验证链：

HW Root of Trust (eFuse 中的公钥哈希)
  │
  ├── 验证 Bootloader (vbmeta 分区签名)
  │     ├── 验证 boot 分区 (Kernel + ramdisk)
  │     │     ├── dm-verity: 验证 system 分区
  │     │     ├── dm-verity: 验证 vendor 分区
  │     │     └── dm-verity: 验证 product 分区
  │     └── 验证其他分区 (odm, dtbo 等)
  │
  └── 任意一环验证失败 → 设备进入受限模式 (黄色/红色警告)

vbmeta 结构 (external/avb/libavb/avb_vbmeta_image.h)：

typedef struct AvbVBMetaImageHeader {
    uint8_t magic[4];       // "AVB0"
    uint32_t required_libavb_version_major;
    uint32_t required_libavb_version_minor;
    uint64_t authentication_data_block_size;
    uint64_t auxiliary_data_block_size;
    uint32_t algorithm_type;  // SHA256_RSA2048, SHA256_RSA4096, etc.
    uint8_t hash[64];         // Image hash
    uint8_t signature[512];   // RSA signature
    uint8_t public_key[520];  // Public key
    // ...
} AVB_ATTR_PACKED AvbVBMetaImageHeader;

2.4 A/B Slot 选择

Android 7.0 引入的 A/B（Seamless）系统更新机制：

设备分区布局:
├── boot_a  (活动)
├── boot_b  (备用)
├── system_a (活动)
├── system_b (备用)
├── vendor_a (活动)
├── vendor_b (备用)
└── misc (存储 slot 状态)

启动时选择逻辑:
1. 读取 misc 分区中的 slot-suffix 和 slot-retry-count
2. 如果 retry-count == 0 → 切换到另一个 slot（上次启动失败）
3. 选择 slot → 加载对应的 boot_{slot}.img
4. 启动成功后 → update_engine 标记 slot-successful

源码参考：system/update_engine/ (A/B 更新引擎)

---

三、Linux Kernel 启动

3.1 start_kernel()

当 Bootloader 将内核镜像加载到内存并跳转到内核入口后，内核执行 start_kernel()。

AOSP 内核仓库：https://android.googlesource.com/kernel/common/

// init/main.c (Linux Kernel)
asmlinkage __visible void __init __no_sanitize_address start_kernel(void)
{
    char *command_line;
    char *after_dashes;

    // 1. 架构相关设置
    setup_arch(&command_line);

    // 2. 解析内核命令行参数 (androidboot.*)
    //    androidboot.hardware=qcom
    //    androidboot.slot_suffix=_a
    //    androidboot.verifiedbootstate=green
    parse_early_param();

    // 3. 内存管理初始化
    mm_init();

    // 4. 调度器初始化
    sched_init();

    // 5. 中断控制器初始化
    init_IRQ();

    // 6. 定时器初始化
    init_timers();

    // 7. 控制台初始化
    console_init();

    // 8. 启动第一个用户态进程
    arch_call_rest_init();
}

3.2 rest_init() → kernel_init()

// init/main.c
noinline void __ref rest_init(void)
{
    // 1. 创建 kernel_init 内核线程（PID=1，即未来的 init 进程）
    pid = kernel_thread(kernel_init, NULL, CLONE_FS);
    
    // 2. 创建 kthreadd 内核线程（PID=2，所有内核线程的父进程）
    pid = kernel_thread(kthreadd, NULL, CLONE_FS | CLONE_FILES);
    
    // 3. 当前线程变为 idle 进程（PID=0）
    do_idle();
}

static int __ref kernel_init(void *unused)
{
    kernel_init_freeable();
    // 挂载文件系统、加载内核模块、创建设备节点
    
    // 尝试执行 ramdisk 中的 /init
    if (ramdisk_execute_command) {
        ret = run_init_process(ramdisk_execute_command);
    }
    
    // 尝试执行根文件系统中的 /init
    if (!try_to_run_init_process("/init"))
        return 0;
    
    panic("No working init found. Try passing init= option to kernel.");
}

关键点：kernel_init 首先尝试执行 ramdisk 中的 /init，这就是 Android 的 init 进程入口。

---

四、Init 进程 —— 用户空间的第一个进程

4.1 Android init 的整体流程

AOSP 源码路径：system/core/init/

main() [system/core/init/main.cpp]
  ├── FirstStageMain()    [first_stage_init.cpp]
  │     ├── 挂载基本文件系统 (/dev, /proc, /sys)
  │     ├── 加载内核模块
  │     ├── 创建 /dev/kmsg (内核日志设备)
  │     └── 切换到第二阶段 init
  │
  ├── SetupSelinux()      [selinux.cpp]
  │     ├── 加载 SEPolicy (从 /vendor/etc/selinux 或 /system/etc/selinux)
  │     ├── 从内核读取安全上下文
  │     └── 将 init 进程设置为 enforcing 模式
  │
  ├── SecondStageMain()   [init.cpp]
  │     ├── 解析 /system/etc/init/hw/init.rc
  │     ├── 解析 /system/etc/init/*.rc
  │     ├── 解析 /vendor/etc/init/*.rc
  │     ├── 解析 /odm/etc/init/*.rc
  │     ├── 构建 Action 和 Service 的链表
  │     ├── 触发 early-init
  │     ├── 启动 ueventd (冷插拔设备)
  │     └── 进入主循环
  │
  └── 主循环 (epoll)
        ├── 监听 property 变化
        ├── 监听子进程退出 (SIGCHLD)
        ├── 执行 Action 的 command
        └── 重启崩溃的关键服务

4.2 FirstStageMain 详解

源码：system/core/init/first_stage_init.cpp

int FirstStageMain(int argc, char** argv) {
    // 1. 检查是否从 ramdisk 启动
    if (argc > 1 && strcmp(argv[1], "first_stage_console") == 0) {
        // 启动控制台用于调试
    }

    // 2. 清空 umask (确保文件权限正确)
    umask(0);

    // 3. 挂载基础文件系统
    CHECKCALL(mount("tmpfs", "/dev", "tmpfs", MS_NOSUID, "mode=0755"));
    CHECKCALL(mkdir("/dev/pts", 0755));
    CHECKCALL(mkdir("/dev/socket", 0755));
    CHECKCALL(mount("devpts", "/dev/pts", "devpts", 0, NULL));
    CHECKCALL(mount("proc", "/proc", "proc", 0, NULL));
    CHECKCALL(mount("sysfs", "/sys", "sysfs", 0, NULL));

    // 4. 创建 /dev/kmsg（内核日志输出）
    InitKernelLogging(argv);

    // 5. 加载内核模块
    // 遍历 /lib/modules 目录，通过 modprobe 加载
    Modprobe::LoadListedModules();

    // 6. 切换到第二阶段
    const char* path = "/system/bin/init";
    const char* args[] = {path, "selinux_setup", nullptr};
    execv(path, const_cast<char**>(args));

    // execv 不会返回，失败则进入 panic
    return EXIT_FAILURE;
}

4.3 SELinux 初始化

源码：system/core/init/selinux.cpp

int SetupSelinux(char** argv) {
    // 1. 初始化内核日志
    InitKernelLogging(argv);

    // 2. 挂载 selinuxfs
    if (mount("selinuxfs", "/sys/fs/selinux", "selinuxfs", 0, 0) == -1) {
        // 内核可能不支持 SELinux
    }

    // 3. 加载策略文件
    // 读取 /vendor/etc/selinux/precompiled_sepolicy
    // 或编译 /system/etc/selinux/plat_sepolicy.cil + 
    //          /vendor/etc/selinux/vendor_sepolicy.cil
    bool success = false;
    if (IsSplitPolicyDevice()) {
        success = LoadSplitPolicy();  // Treble 设备
    } else {
        success = LoadMonolithicPolicy();  // 旧设备
    }

    // 4. 设置 enforcing 模式
    // 从内核命令行读取 androidboot.selinux
    // permissive: 记录违规但不阻止
    // enforcing: 严格阻止违规操作
    bool is_enforcing = security_getenforce() == 1;
    if (cmdline == "androidboot.selinux=permissive") {
        is_enforcing = false;
    }
    security_setenforce(is_enforcing);

    // 5. 切换到第二阶段的真正 init
    const char* path = "/system/bin/init";
    const char* args[] = {path, "second_stage", nullptr};
    execv(path, const_cast<char**>(args));
}

4.4 SecondStageMain 详解

源码：system/core/init/init.cpp

int SecondStageMain(int argc, char** argv) {
    // 1. 设置信号处理
    // SIGCHLD: 子进程退出时回收 (waitpid)
    signal(SIGCHLD, ReapAnyOutstandingChildren);

    // 2. 初始化属性服务 (Property Service)
    property_init();

    // 3. 从 DT (Device Tree) 和 cmdline 导入属性
    process_kernel_dt();
    process_kernel_cmdline();

    // 4. 初始化 SELinux 并恢复上下文
    SelinuxInitialize();

    // 5. 创建 epoll 句柄
    epoll_fd = epoll_create1(EPOLL_CLOEXEC);

    // 6. 加载启动脚本 (init.rc)
    ActionManager& am = ActionManager::GetInstance();
    ServiceList& sm = ServiceList::GetInstance();
    Parser parser = CreateParser(am, sm);
    parser.ParseConfig("/system/etc/init/hw/init.rc");
    parser.ParseConfig("/system/etc/init");
    parser.ParseConfig("/vendor/etc/init");
    parser.ParseConfig("/odm/etc/init");
    parser.ParseConfig("/product/etc/init");

    // 7. 触发 early-init
    am.QueueEventTrigger("early-init");

    // 8. 触发 init
    am.QueueEventTrigger("init");

    // 9. 循环处理事件
    while (true) {
        // 检查是否有待处理的 action
        if (!(waiting_for_exec || IsWaitingForProperty())) {
            am.ExecuteOneCommand();
        }
        // 重启需要重启的服务
        RestartProcesses();

        // epoll 等待事件
        int timeout = -1;
        if (am.HasMoreCommands()) timeout = 0;
        epoll_event ev;
        int nr = TEMP_FAILURE_RETRY(epoll_wait(epoll_fd, &ev, 1, timeout));
        if (nr == -1) continue;
        // 处理 property 变化、子进程退出等事件
    }
}

4.5 init.rc 语法与处理

源码路径：system/core/rootdir/init.rc

# 全局配置
on early-init
    # 设置初始进程 OOM 调整值
    write /proc/1/oom_score_adj -1000
    # 挂载系统分区
    mount_all /vendor/etc/fstab.${ro.hardware} --early

on init
    # 设置环境变量
    export ANDROID_ROOT /system
    export ANDROID_DATA /data
    # 创建关键目录
    mkdir /data 0771 system system
    mkdir /data/app 0771 system system

# late-init: 分阶段启动
on late-init
    trigger early-fs      # 挂载文件系统
    trigger fs             # 完成文件系统挂载
    trigger post-fs        # 文件系统权限设置
    trigger zygote-start   # 启动 Zygote
    trigger early-boot     # 早期启动
    trigger boot           # 核心启动（触发 class_start core）
    trigger nonencrypted   # 非加密设备

# 服务定义
service zygote /system/bin/app_process64 -Xzygote /system/bin --zygote --start-system-server
    class main
    user root
    group root readproc reserved_disk
    socket zygote stream 660 root system    # 创建 /dev/socket/zygote
    socket usap_pool_primary stream 660 root system
    onrestart restart audioserver
    onrestart restart cameraserver
    onrestart restart media
    onrestart restart netd
    writepid /dev/cpuset/foreground/tasks

service servicemanager /system/bin/servicemanager
    class core animation
    user system
    group system readproc
    critical
    shutdown critical

service surfaceflinger /system/bin/surfaceflinger
    class core animation
    user system
    group graphics drmrpc readproc
    onrestart restart zygote
    writepid /dev/cpuset/system-background/tasks

init.rc 的处理（system/core/init/parser.cpp）：

// 解析器将 init.rc 中的 Action 和 Service 解析为内部数据结构
// Action: 触发关键字 + 命令列表
// Service: 服务名 + 二进制路径 + 选项 (socket, user, group 等)

void Parser::ParseConfig(const std::string& path) {
    // 递归解析目录中的所有 .rc 文件
    // 逐行解析，识别 on/service/import 等关键字
    // 构建 Action 和 Service 对象
}

---

五、Zygote —— Android 的进程孵化器

5.1 Zygote 启动流程

源码路径：

• Native 层：frameworks/base/core/jni/AndroidRuntime.cpp
• Java 层：frameworks/base/core/java/com/android/internal/os/ZygoteInit.java

app_process (zygote 的入口二进制文件)
  │
  └── main() [frameworks/base/cmds/app_process/app_main.cpp]
        │
        ├── AppRuntime 初始化 (继承 AndroidRuntime)
        ├── 解析参数: --zygote --start-system-server
        └── runtime.start("com.android.internal.os.ZygoteInit", args)
              │
              └── AndroidRuntime::start() [AndroidRuntime.cpp]
                    ├── 1. startVm()          # 启动 ART 虚拟机
                    ├── 2. startReg()         # 注册 JNI 方法
                    ├── 3. 找到 ZygoteInit.main()
                    └── 4. 通过 JNI 调用 ZygoteInit.main()
                          │
                          └── ZygoteInit.main() [ZygoteInit.java]
                                ├── preloadClasses()    # 预加载 4500+ 类
                                ├── preloadResources()  # 预加载主题和资源
                                ├── preloadSharedLibraries()
                                ├── registerZygoteSocket()  # 注册 socket
                                ├── forkSystemServer()      # fork SystemServer
                                └── runSelectLoop()         # 等待 fork 请求

5.2 app_process 的 main 函数

源码：frameworks/base/cmds/app_process/app_main.cpp

int main(int argc, char* const argv[]) {
    AppRuntime runtime(argv[0], computeArgBlockSize(argc, argv));
    
    // 解析命令行参数
    bool zygote = false;
    bool startSystemServer = false;
    
    while (i < argc) {
        if (strcmp(argv[i], "--zygote") == 0) {
            zygote = true;
            // 根据 ABI 确定进程名
            niceName = ZYGOTE_NICE_NAME;  // "zygote" 或 "zygote64"
        } else if (strcmp(argv[i], "--start-system-server") == 0) {
            startSystemServer = true;
        }
    }

    if (zygote) {
        // 启动 Zygote 模式
        runtime.start("com.android.internal.os.ZygoteInit", args, zygote);
    } else {
        // 启动普通应用模式（如 am, pm 命令）
        runtime.start("com.android.internal.os.RuntimeInit", args, zygote);
    }
}

5.3 AndroidRuntime::start() —— ART 启动

源码：frameworks/base/core/jni/AndroidRuntime.cpp

void AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote) {
    // 1. 设置进程名
    set_process_name(niceName);

    // 2. 启动 ART 虚拟机
    JniInvocation jni_invocation;
    jni_invocation.Init(NULL);
    JNIEnv* env;
    
    if (startVm(&mJavaVM, &env, zygote, primary_zygote) != 0) {
        return;  // VM 启动失败
    }
    onVmCreated(env);

    // 3. 注册 Android JNI 方法
    if (startReg(env) < 0) {
        ALOGE("Unable to register all android natives\n");
        return;
    }

    // 4. 构建 ZygoteInit 的 main() 调用
    jclass stringClass = env->FindClass("java/lang/String");
    jobjectArray strArray = env->NewObjectArray(options.size() + 1, stringClass, NULL);
    
    jstring classNameStr = env->NewStringUTF(className);
    env->SetObjectArrayElement(strArray, 0, classNameStr);
    for (size_t i = 0; i < options.size(); ++i) {
        jstring optionStr = env->NewStringUTF(options.itemAt(i).string());
        env->SetObjectArrayElement(strArray, i + 1, optionStr);
    }

    // 5. 加载 ZygoteInit 类并调用 main()
    char* slashClassName = toSlashClassName(className);
    jclass startClass = env->FindClass(slashClassName);
    
    jmethodID startMeth = env->GetStaticMethodID(startClass, "main",
        "([Ljava/lang/String;)V");
    
    env->CallStaticVoidMethod(startClass, startMeth, strArray);
}

5.4 预加载 —— Zygote 的核心价值

源码：frameworks/base/core/java/com/android/internal/os/ZygoteInit.java

public class ZygoteInit {
    public static void main(String[] argv) {
        ZygoteServer zygoteServer = null;

        try {
            // 1. 设置进程优先级
            Process.setThreadPriority(Process.THREAD_PRIORITY_DEFAULT);

            // 2. 预加载（Zygote 的最大优势）
            preloadClasses();  // 预加载 ~4500+ 类
            preloadResources();  // 预加载系统资源
            nativePreloadAppProcessHALs();  // 预加载 HAL
            maybePreloadHeavyResources();  // 预加载 WebView、字体等

            // 3. 创建 Zygote Socket
            zygoteServer = new ZygoteServer();
            zygoteServer.registerZygoteSocket();
            // 创建的 socket: /dev/socket/zygote

            // 4. 延迟预加载（非关键路径）
            warmUpJcaProviders();

            // 5. Fork SystemServer
            Runnable systemServerRunnable = () -> {
                // SystemServer 的启动逻辑
                handleSystemServerProcess(parsedArgs);
            };

            boolean startSystemServer = argv.contains("--start-system-server");
            if (startSystemServer) {
                pid = zygoteServer.forkSystemServer(
                    systemServerArgs, ...);
            }

            // 6. 进入 select 循环，等待 fork 请求
            zygoteServer.runSelectLoop();
            
        } catch (Throwable ex) {
            Log.e(TAG, "System zygote died with fatal error", ex);
            throw ex;
        } finally {
            if (zygoteServer != null) {
                zygoteServer.closeServerSocket();
            }
        }
    }
}

预加载机制的意义：

当 Zygote fork 子进程时，子进程继承了 Zygote 的地址空间（写时复制, Copy-on-Write），因此：

• 所有预加载的类已经存在于内存中，子进程无需再次加载
• 所有预加载的资源已经就位
• 应用启动时间显著减少（典型减少 1-2 秒）

预加载的类列表：frameworks/base/config/preloaded-classes，包含 ~4500 个核心类。

5.5 runSelectLoop —— Socket 监听

// ZygoteServer.java
Runnable runSelectLoop() {
    ArrayList<FileDescriptor> socketFDs = new ArrayList<>();
    ArrayList<ZygoteConnection> peers = new ArrayList<>();

    socketFDs.add(zygoteSocket.getFileDescriptor());
    peers.add(null);

    while (true) {
        // 1. 检查是否有待处理的 USAP (Unspecialized App Process) 请求
        pollUSAP();

        // 2. select/poll 等待连接
        Os.poll(pollFDs, -1);  // 无限等待

        // 3. 处理新的 fork 请求
        for (int i = 1; i < pollFDs.length; i++) {
            if (pollFDs[i].revents & POLLIN) {
                ZygoteConnection connection = peers.get(i);
                // processCommand 中会调用 forkAndSpecialize()
                Runnable command = connection.processCommand(this, ...);
                // 在子进程中执行命令 (如 RuntimeInit.applicationInit)
                if (command != null) {
                    return command;
                }
            }
        }

        // 4. 处理新的 socket 连接
        if (socketFDs.get(0).revents & POLLIN) {
            ZygoteConnection newPeer = zygoteSocket.acceptCommandPeer();
            peers.add(newPeer);
            socketFDs.add(newPeer.getFileDescriptor());
        }
    }
}

5.6 forkSystemServer —— fork 系统服务进程

// Zygote.java
static int forkSystemServer(int uid, int gid, int[] gids,
        int runtimeFlags, int[][] rlimits,
        long permittedCapabilities, long effectiveCapabilities) {
    
    // 调用 native fork
    int pid = nativeForkSystemServer(
        uid, gid, gids,
        runtimeFlags, rlimits,
        permittedCapabilities, effectiveCapabilities);

    if (pid == 0) {
        // 子进程 (SystemServer)
        // 设置进程名
        Process.setArgV0("system_server");
    }

    return pid;
}

Native fork 实现（frameworks/base/core/jni/com_android_internal_os_Zygote.cpp）：

static pid_t ForkCommon(JNIEnv* env, bool is_system_server,
                         const std::vector<int>& fds_to_close,
                         const std::vector<int>& fds_to_ignore) {
    // 设置 fork 前的信号处理
    SetSignalHandlers();

    // fork() !!
    pid_t pid = fork();

    if (pid == 0) {
        // 子进程
        DetachDescriptors(env, fds_to_close);
        // 清除 Zygote 特定的资源
    } else {
        // 父进程 (Zygote)
        // 继续运行 select loop
    }

    return pid;
}

---

六、SystemServer —— Android 服务的大本营

6.1 SystemServer.main()

源码：frameworks/base/services/java/com/android/server/SystemServer.java

public final class SystemServer {
    
    public static void main(String[] args) {
        new SystemServer().run();
    }

    private void run() {
        // 1. 设置当前线程为 "android.server.SystemServer"
        Looper.prepareMainLooper();
        android.os.Process.setThreadPriority(
            android.os.Process.THREAD_PRIORITY_FOREGROUND);

        // 2. 初始化系统上下文
        createSystemContext();

        // 3. 创建 SystemServiceManager（服务管理器）
        mSystemServiceManager = new SystemServiceManager(mSystemContext);
        LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);

        // 4. 启动三大类服务
        try {
            t.traceBegin("StartServices");
            startBootstrapServices(t);  // 引导服务
            startCoreServices(t);       // 核心服务
            startOtherServices(t);      // 其他服务
        } catch (Throwable ex) {
            throw ex;
        } finally {
            t.traceEnd();
        }

        // 5. 主线程进入 Looper 循环
        Looper.loop();
        throw new RuntimeException("Main thread loop unexpectedly exited");
    }
}

6.2 startBootstrapServices() —— 引导服务

引导服务是系统运行的基础，它们之间没有严格的依赖顺序，但都需要在其他服务启动之前就绪：

private void startBootstrapServices(@NonNull TimingsTraceAndSlog t) {
    // 1. Installer (安装守护进程)
    //    AOSP 路径: frameworks/base/services/core/java/com/android/server/pm/Installer.java
    //    负责 APK 安装、oat 文件生成
    t.traceBegin("StartInstaller");
    Installer installer = mSystemServiceManager.startService(Installer.class);
    t.traceEnd();

    // 2. ActivityManagerService (AMS) —— 四大组件管理核心
    //    AOSP 路径: frameworks/base/services/core/java/com/android/server/am/
    t.traceBegin("StartActivityManager");
    mActivityManagerService = mSystemServiceManager.startService(
        ActivityManagerService.Lifecycle.class).getService();
    mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
    mActivityManagerService.setInstaller(installer);
    t.traceEnd();

    // 3. PowerManagerService —— 电源管理
    //    负责 WakeLock、屏幕状态、电池管理
    mPowerManagerService = mSystemServiceManager.startService(
        PowerManagerService.class);

    // 4. DisplayManagerService —— 显示管理
    //    负责多屏、分辨率、刷新率
    mDisplayManagerService = mSystemServiceManager.startService(
        DisplayManagerService.class);

    // 5. PackageManagerService (PMS) —— 包管理核心
    //    AOSP 路径: frameworks/base/services/core/java/com/android/server/pm/
    //    负责 APK 的安装、卸载、权限、签名
    try {
        mPackageManagerService = PackageManagerService.main(
            mSystemContext, installer, ...);
    } catch (Exception e) {
        // 系统无法启动
    }

    // 6. UserManagerService —— 多用户管理
    mSystemServiceManager.startService(UserManagerService.class);
}

6.3 startCoreServices() —— 核心服务

private void startCoreServices(@NonNull TimingsTraceAndSlog t) {
    // 1. BatteryService —— 电池状态
    mSystemServiceManager.startService(BatteryService.class);

    // 2. UsageStatsService —— 应用使用统计
    mSystemServiceManager.startService(UsageStatsService.class);

    // 3. WebViewUpdateService —— WebView 更新服务
    mSystemServiceManager.startService(WebViewUpdateService.class);

    // 4. BinderCallsStatsService —— Binder 调用统计
    mSystemServiceManager.startService(BinderCallsStatsService.class);
}

6.4 startOtherServices() —— 系统服务的主战场

这是 SystemServer 中最长的函数（约 1000+ 行），按阶段启动 80+ 个服务：

private void startOtherServices(@NonNull TimingsTraceAndSlog t) {
    // ========== 阶段 1: 准备 ==========
    // 1. WindowManagerService (WMS)
    //    AOSP: frameworks/base/services/core/java/com/android/server/wm/
    wm = WindowManagerService.main(context, inputManager, ...);
    ServiceManager.addService(Context.WINDOW_SERVICE, wm, ...);
    inputManager.setWindowManagerCallbacks(wm.getInputManagerCallback());

    // 2. InputManagerService
    //    负责键盘、触摸、鼠标事件分发
    inputManager = new InputManagerService(context);

    // ========== 阶段 2: 启动 AMS ==========
    mActivityManagerService.setWindowManager(wm);
    mActivityManagerService.systemReady(() -> {
        // 这个回调在所有服务就绪后执行
    });

    // ========== 阶段 3: 启动各种 Manager ==========
    // 3. StatusBarManagerService —— 状态栏管理
    statusBar = new StatusBarManagerService(context);

    // 4. NetworkManagementService —— 网络管理
    networkManagement = NetworkManagementService.create(context);

    // 5. ConnectivityService —— 网络连接
    connectivity = new ConnectivityService(context, networkManagement, ...);

    // 6. NotificationManagerService —— 通知管理
    notification = new NotificationManagerService(context);

    // 7. LocationManagerService —— 位置
    location = new LocationManagerService(context);

    // 8. AudioService —— 音频
    audioService = new AudioService(context);

    // 9. BluetoothService —— 蓝牙
    bluetooth = new BluetoothService(context);

    // 10. TelephonyManagerService —— 电话
    telephony = new TelephonyManagerService(context);

    // ... 还有 60+ 个服务

    // ========== 阶段 4: 最终启动 ==========
    // 所有服务就绪后，调用 AMS.systemReady()
    mActivityManagerService.systemReady(() -> {
        // 启动 Launcher (SystemUI / Launcher3)
    });
}

6.5 AMS.systemReady() —— 启动桌面

// ActivityManagerService.java
public void systemReady(final Runnable goingCallback, TimingsTraceAndSlog t) {
    // 1. 执行回调
    if (goingCallback != null) goingCallback.run();

    // 2. 启动 Home Activity
    startHomeActivityLocked(mCurrentUserId, "systemReady");

    // 3. 恢复顶层 Activity
    mStackSupervisor.resumeFocusedStackTopActivityLocked();
}

boolean startHomeActivityLocked(int userId, String reason) {
    // 构造 Intent: ACTION_MAIN + CATEGORY_HOME
    Intent intent = getHomeIntent();
    
    // 解析哪个应用是 Launcher
    // 通过 PM.resolveActivity(ACTION_MAIN, CATEGORY_HOME)
    ActivityInfo aInfo = resolveActivityInfo(intent, ...);

    // 启动 Launcher Activity
    mActivityStartController.startHomeActivity(intent, aInfo, myReason);
}

Launcher 的 Intent 解析过程：

Intent getHomeIntent() {
    Intent intent = new Intent(Intent.ACTION_MAIN);
    intent.addCategory(Intent.CATEGORY_HOME);
    return intent;
}
// PackageManagerService 会找到 AndroidManifest.xml 中声明此 IntentFilter 的 Activity
// 通常是: com.android.launcher3 或 com.google.android.apps.nexuslauncher

---

七、关键服务启动时序图

时间轴 ──────────────────────────────────────────────>

Boot ROM (0ms)
  │
Bootloader (~100ms)
  │
Kernel (~500ms)
  │
Init (~200ms)
  ├── ueventd 启动 (冷插拔设备节点)
  ├── ServiceManager 启动 (Binder 服务注册中心)
  ├── hwservicemanager 启动 (HIDL 服务注册中心)
  ├── vold 启动 (Volume Daemon, 挂载存储)
  ├── SurfaceFlinger 启动 (合成+显示)
  │
Zygote (~800ms)  ← 预加载 4500+ 类
  │
SystemServer (~3000ms)
  ├── AMS 启动
  ├── PMS 启动 (扫描已安装应用, ~2000ms)
  ├── WMS 启动
  ├── InputManagerService 启动
  ├── StatusBarManagerService 启动
  │   ...
  └── AMS.systemReady()
        │
Launcher 显示 (~4000ms)  ← 用户看到桌面
        │
Boot Complete 广播 (~4500ms)
        │
用户可操作 (~5000ms)

---

八、启动性能分析

8.1 关键性能指标

阶段	典型耗时	可优化点
Bootloader	100-500ms	跳过不必要的硬件初始化
Kernel	300-800ms	精简内核配置，延迟加载模块
Init	100-300ms	延迟非关键 rc 脚本
Zygote 预加载	600-1200ms	减少预加载类数量，升级 ART
PMS 扫描	1000-3000ms	使用 PackageCache，并行扫描
SystemServer	1500-3000ms	延迟非关键服务启动

8.2 bootchart 分析工具

# 启用 bootchart
adb shell 'touch /data/bootchart/enabled'
adb reboot

# 分析启动时序
adb root
adb shell 'cd /data/bootchart && tar -czf /sdcard/bootchart.tgz *'
adb pull /sdcard/bootchart.tgz

# 使用 bootchart 生成 SVG 图表
bootchart bootchart.tgz

8.3 systrace 分析

# 抓取启动过程的 trace
python systrace.py --time=15 -o boot_trace.html \
    am wm view res dalvik sched freq idle disk load

# 或者使用 Perfetto（Android 10+）
adb shell perfetto \
  -c - --txt \
  -o /data/misc/perfetto-traces/trace \
  <<EOF
  buffers: { size_kb: 63488 }
  data_sources: {
    config {
      name: "linux.ftrace"
      ftrace_config {
        ftrace_events: "sched/sched_switch"
        ftrace_events: "power/suspend_resume"
        ftrace_events: "sched/sched_wakeup"
        ftrace_events: "sched/sched_process_free"
        ftrace_events: "task/task_newtask"
        ftrace_events: "task/task_rename"
        atrace_categories: "am"
        atrace_categories: "pm"
        atrace_categories: "wm"
        atrace_categories: "view"
      }
    }
  }
  duration_ms: 15000
EOF

---

九、ServiceManager 与 Binder 服务注册

9.1 ServiceManager —— 服务的黄页

ServiceManager 是 Android 中第一个启动的 Native 进程（由 init.rc 中的 class core 触发）。它是 Binder IPC 的”注册中心”，所有系统服务通过它注册和查找。

源码路径：frameworks/native/cmds/servicemanager/

// frameworks/native/cmds/servicemanager/main.cpp
int main(int argc, char** argv) {
    // ServiceManager 的 Binder handle 固定为 0
    // 所有客户端都知道通过 handle 0 找到 SM
    sp<ServiceManager> manager = sp<ServiceManager>::make();

    // 注册为 Binder 上下文管理器
    if (binder_become_context_manager(manager) != OK) {
        LOG(FATAL) << "failed to become context manager";
    }

    // 进入 Binder 循环，等待请求
    IPCThreadState::self()->joinThreadPool();
}

服务注册流程：

// AMS 启动后注册到 ServiceManager
// frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
public void setSystemProcess() {
    ServiceManager.addService(Context.ACTIVITY_SERVICE, this, 
        /* allowIsolated= */ false, DUMP_FLAG_PRIORITY_CRITICAL);
    ServiceManager.addService("activity", this, ...);
    ServiceManager.addService("activity_manager", this, ...);
}

服务查找流程（Client 端）：

// frameworks/base/core/java/android/app/ActivityManager.java
// 应用进程通过以下方式获取 AMS 的 Binder 代理
IBinder b = ServiceManager.getService("activity");
IActivityManager am = IActivityManager.Stub.asInterface(b);

9.2 Binder 驱动初始化

Binder 驱动在 Kernel 启动时加载（/dev/binder），它是 Android 进程间通信的基础设施：

• Binder 节点：每个 Binder 服务对应一个内核中的 binder_node 对象
• Binder 引用：客户端持有服务的 binder_ref 引用
• 线程池：每个进程可以启动多个 Binder 线程处理并发请求
• 死亡通知：通过 linkToDeath() 监听服务端进程崩溃

Binder 的一次通信：

Client Process                 Kernel                  Server Process
     │                           │                          │
     ├─ transact()               │                          │
     │  └─ ioctl(BINDER_WRITE)   │                          │
     │     ├─ copy_from_user()   │                          │
     │     └─ 调度 Server 线程   │                          │
     │                           ├─ wake up Server thread   │
     │                           │                          ├─ onTransact()
     │                           │                          │  └─ 执行业务逻辑
     │                           │  write reply data        │
     │                           ├─ wake Client thread      │
     │  return result            │                          │

---

十、SurfaceFlinger 启动与显示就绪

10.1 SurfaceFlinger 的启动时机

SurfaceFlinger 由 init.rc 在 class core 阶段启动：

service surfaceflinger /system/bin/surfaceflinger
    class core animation
    user system
    group graphics drmrpc readproc
    onrestart restart zygote

为什么 SurfaceFlinger 要在 Zygote 之前启动？

因为 Zygote fork SystemServer 后，SystemServer 中的 WMS（WindowManagerService）和 AMS（ActivityManagerService）需要与 SurfaceFlinger 通信来创建窗口和渲染 UI。如果 SurfaceFlinger 未就绪，这些服务将阻塞。

10.2 SurfaceFlinger 的初始化

源码路径：frameworks/native/services/surfaceflinger/

// frameworks/native/services/surfaceflinger/main_surfaceflinger.cpp
int main(int, char**) {
    // 1. 设置进程优先级
    setpriority(PRIO_PROCESS, 0, PRIORITY_URGENT_DISPLAY);

    // 2. 初始化 Binder
    sp<ProcessState> ps(ProcessState::self());
    ps->startThreadPool();

    // 3. 创建 SurfaceFlinger 实例
    sp<SurfaceFlinger> flinger = surfaceflinger::createSurfaceFlinger();

    // 4. 初始化
    flinger->init();

    // 5. 注册到 ServiceManager
    sp<IServiceManager> sm(defaultServiceManager());
    sm->addService(String16(SurfaceFlinger::getServiceName()), flinger, ...);

    // 6. 运行主循环
    flinger->run();
}

10.3 BootAnimation —— 启动动画

在 SystemServer 启动期间，用户看到的是启动动画。BootAnimation 由 init.rc 启动：

service bootanim /system/bin/bootanimation
    class animation
    user graphics
    group graphics audio
    disabled  # 默认不启动，由 SurfaceFlinger 触发
    oneshot

启动动画生命周期：

1. SurfaceFlinger 就绪后，发送 bootanim 属性变化通知
2. BootAnimation 开始播放（/system/media/bootanimation.zip）
3. AMS.systemReady() 后 → WMS 调用 SurfaceFlinger.stopBootAnim() → 动画停止
4. 用户看到桌面

---

十一、PackageManagerService 扫描过程

11.1 PMS.scanDirTracedLI()

PMS 的启动中最耗时的一步是扫描已安装应用：

// frameworks/base/services/core/java/com/android/server/pm/PackageManagerService.java
private void scanDirTracedLI(File scanDir, int scanFlags, int packageParserCacheMaxSize) {
    // 遍历 /data/app, /system/app, /system/priv-app, /vendor/app, /product/app 等
    // 每个目录下可能有数百个 APK

    File[] files = scanDir.listFiles();
    for (File file : files) {
        // 为每个 APK 创建 PackageParser
        // 解析 AndroidManifest.xml（提取组件、权限、签名）
        // 提取 DEX 引用
        // 更新包数据库（packages.xml）
    }
}

PMS 扫描优化（Android 10+）：

• 并行扫描：多个分区可并行扫描
• PackageCache：缓存上次扫描结果（/data/system/package_cache/）
• 增量扫描：对比时间戳，只重新扫描有变化的 APK

---

十二、总结

Android 启动过程是一个精密的八步流水线：

1. Boot ROM：SoC 固化的启动代码，加载 Bootloader
2. **Bootloader (LK/ABL)**：Verified Boot 验证，A/B slot 选择，加载 Kernel
3. Kernel：start_kernel() → rest_init() → kernel_init() → /init
4. Init First Stage：挂载基础文件系统，加载内核模块，初始化 SELinux
5. Init Second Stage：解析 init.rc，触发 early-init → init → late-init，启动 Zygote
6. Zygote：启动 ART，预加载 4500+ 类，fork SystemServer，socket 监听 fork 请求
7. SystemServer：启动 AMS/PMS/WMS 等 80+ 系统服务
8. Launcher：AMS.systemReady() → startHomeActivityLocked → 用户看到桌面

理解启动过程的意义不仅在于系统级调试和性能优化，更在于理解 Android 作为 Linux 衍生系统的设计哲学：通过 Zygote 的 Copy-on-Write 和预加载机制，将应用启动时间从秒级减少到百毫秒级。

---

参考资源

• AOSP init 源码
• AOSP ZygoteInit.java
• AOSP SystemServer.java
• AOSP init.rc
• Android Boot Time Optimization
• Android Verified Boot
• A/B (Seamless) System Updates
• Android Common Kernel