Dalvik VM 进程系统

系统进程启动流程

Android系统架构

1. Linux Kernel
2. 硬件抽象层 Hardware Abstraction Layer（HAL）
3. 1. Native C/C++ Libraries
   2. Android Runtime
4. Java API Framework
5. System Apps

OS启动流程

1. Boot Rom -> Boot Loader

2. Kernel

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

3. init 进程（pid=1）

init 进程是用户空间的第一个进程

1. 创建和挂载 系统启动所需要的文件目录
2. 初始化 和启动属性服务
3. 解析 init.rc 配置文件并启动 Zygote 进程等服务进程

init.rc 语句类型

init.rc是一个非常重要的配置文件，它是由Android初始化语言(Android Init Language)编写的脚本：

1. Import (引入其他配置文件)

2. Action (它包含了一系列的Command)

   以 on 开头的语句，通过触发器trigger来决定执行相应的service。

3. Commands (init语言中的命令)

4. Services (由init进程启动的服务)

   init生成的子进程，定义在rc文件，每一个service在启动时会通过 fork 方式生成子进程。

   <service的名字><执行程序路径><参数>

5. Options (对服务进行配置的选项)

rc-service 解析

//init.cpp
int main(int argc, char** argv) {
   //...
   ActionManager& am = ActionManager::GetInstance();
   ServiceList& sm = ServiceList::GetInstance();
   LoadBootScripts(am, sm);
   //...
}

static void LoadBootScripts(ActionManager& action_manager, ServiceList& service_list) {
    Parser parser = CreateParser(action_manager, service_list); // 创建解析器
    std::string bootscript = GetProperty("ro.boot.init_rc", "");
    if (bootscript.empty()) {
        parser.ParseConfig("/init.rc"); // 开始解析 
        //...
    } else {
        parser.ParseConfig(bootscript); //
    }
}

Parser CreateParser(ActionManager& action_manager, ServiceList& service_list) {
    Parser parser;
    parser.AddSectionParser("service", std::make_unique<ServiceParser>(&service_list, subcontexts));
    parser.AddSectionParser("on", std::make_unique<ActionParser>(&action_manager, subcontexts));
    parser.AddSectionParser("import", std::make_unique<ImportParser>(&parser));
    return parser;
}

void Parser::ParseData(const std::string& filename, const std::string& data, size_t* parse_errors) {
  for (;;) { // 解析rc的内容，::ParseSection
    section_parser->ParseSection(std::move(args), filename, state.line); // 摘录1
    section_parser->ParseLineSection(std::move(args), state.line); // 摘录2
    section_parser->EndSection(); // 摘录3
  }
}

Result<Success> ServiceParser::ParseSection(std::vector<std::string>&& args, const std::string& filename, int line) {
    //...
    service_ = std::make_unique<Service>(name, restart_action_subcontext, str_args); // (仅是)创建Service对象
    return Success();
}

Result<Success> ServiceParser::ParseLineSection(std::vector<std::string>&& args, int line) {
    return service_ ? service_->ParseLine(std::move(args)) : Success();
}

Result<Success> Service::ParseLine(const std::vector<std::string>& args) {
    static const OptionParserMap parser_map;
    auto parser = parser_map.FindFunction(args);
    if (!parser) return parser.error();
    return std::invoke(*parser, this, args); // 执行Section下的二级动作，一般是对应的配置或动作
}

Result<Success> ServiceParser::EndSection() {
    if (service_) {
        //...
        service_list_->AddService(std::move(service_)); // 把 service_ 添加到 `service_list_`
    }
    return Success();
}

4. Zygote（Android Runtime）

service zygote /system/bin/app_process64 -Xzygote /system/bin --zygote --start-system-server --socket-name=zygote
    class main
    priority -20
    user root
    group root readproc reserved_disk
    socket zygote stream 660 root system
    onrestart write /sys/android_power/request_state wake
    onrestart write /sys/power/state on
    onrestart restart audioserver
    onrestart restart cameraserver
    onrestart restart media
    onrestart restart netd
    onrestart restart wificond
    writepid /dev/cpuset/foreground/tasks

service zygote_secondary /system/bin/app_process32 -Xzygote /system/bin --zygote --socket-name=zygote_secondary --enable-lazy-preload
    class main
    priority -20
    user root
    group root readproc reserved_disk
    socket zygote_secondary stream 660 root system
    onrestart restart zygote
    writepid /dev/cpuset/foreground/tasks

init.cpp#**main()**解析 init.zygote*.rc，并在init进程 fork子进程zygote，到达 app_main.cpp#main()

所有的Java应用程序进程及系统服务SystemServer进程都由 Zygote 进程通过Linux的 fork() 函数孵化出来的；而native程序则由Init程序创建启动。

//>>> init.cpp
int main(int argc, char** argv) {
   //...
   const BuiltinFunctionMap function_map;
   Action::set_function_map(&function_map);
   ; // LoadBootScripts...
}

static const Map builtin_functions = {
   // 这里为 rc 的 cmd 定义了对应的方法
   {"class_start",             {1,     1,    {false,  do_class_start}}},
}

static Result<Success> do_class_start(const BuiltinArguments& args) {
    for (const auto& service : ServiceList::GetInstance()) { // service_list_存放了解析rc得到的服务
        if (service->classnames().count(args[1])) {
            if (auto result = service->StartIfNotDisabled(); // 启动服务：Service::Start()
                !result) {
                LOG(ERROR) << result.error();
            }
        }
    }
    return Success();
}

Result<Success> Service::Start() {
   pid_t pid = -1;
   if (namespace_flags_) {
       pid = clone(nullptr, nullptr, namespace_flags_ | SIGCHLD, nullptr);
   } else {
       pid = fork(); // 服务启动中，从init fork子进程zygote
   } 							 // pid>0 两个进程还一样，执行的继续是父进程
   if (pid == 0) { // pid=0 子进程成功创建，现已开始执行子进程
       umask(077);
       //..
       if (!ExpandArgsAndExecv(args_)) { // 调用 execv 函数，启动service子进程，执行 app_main.cpp 的 main 函数
          PLOG(ERROR) << "cannot execve('" << args_[0] << "')";
       }
   }
}

app_main.cpp#main主要做的事情就是参数解析：

//app_main.cpp
int main(int argc, char* const argv[]) {
    //...
    AppRuntime runtime(argv[0], computeArgBlockSize(argc, argv));
    //...
    if (zygote) {
        runtime.start("com.android.internal.os.ZygoteInit", args, zygote); // 如果启动参数包含了 --zygote
    } else if (className) {
        runtime.start("com.android.internal.os.RuntimeInit", args, zygote); // 如果启动参数包含了 --{$className}
    } else {
        fprintf(stderr, "Error: no class name or --zygote supplied.\n");
        app_usage();
        LOG_ALWAYS_FATAL("app_process: no class name or --zygote supplied.");
    }
}

void AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote) {
    //...
    JNIEnv* env;
    if (startVm(&mJavaVM, &env, zygote) != 0) { //startVM 先在处理虚拟机的启动参数，然后会调用 libart.so 的一个接口: JNI_CreateJavaVM（创建单例的Runtime对象）
        return;
    }
    onVmCreated(env);

    if (startReg(env) < 0) {
        ALOGE("Unable to register all android natives\n");
        return;
    }
    //...
    env->CallStaticVoidMethod(startClass, startMeth, strArray); // 执行直到退出
   //...
}

⌛️startVm

向 VM 注册 Java native 函数

JNI层，这里提及的是_Binder

• AndroidRuntime.cpp

startReg(/*JNIEnv**/env)

static const RegJNIRec gRegJNI[] = {
    //...
    REG_JNI(register_android_os_Binder),
    //...
}
register_jni_procs(gRegJNI, NELEM(gRegJNI), env)

• android_util_Binder.cpp

int register_android_os_Binder(JNIEnv* env)
{
    if (int_register_android_os_Binder(env) < 0)
        return -1;
    if (int_register_android_os_BinderInternal(env) < 0)
        return -1;
    if (int_register_android_os_BinderProxy(env) < 0)
        return -1;
    //....
    return 0;
}

虚拟机启动概述

1. 从property读取一系列启动参数
2. 创建和初始化结构体进程的全局对象**gDVM，以及对应于JavaVM和JNIEnv的内部结构体JavaVMExt、JNIEnvExt**。
3. 初始化java虚拟机，并创建虚拟机线程（startVm）
4. 注册系统的JNI，Java程序通过这些JNI接口来访问底层的资源（startReg）
5. 为Zygote的启动做最后的准备，包括设置SID/UID, 以及mount文件系统
6. 返回 JavaVM 给Native代码，这样它就可以向上访问Java的接口

Zgyote是Android中的第一个art虚拟机，他通过socket的方式与其他进程进行通信。这里的“其他进程” 其实主要是系统进程——SystemServer。

public class ZygoteInit {
    public static void main(String argv[]) {
        ZygoteServer zygoteServer = new ZygoteServer(); // 新建Zygote服务器端
            boolean startSystemServer = false;
            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]);
                }
            }
  
            if (abiList == null) {
                throw new RuntimeException("No ABI list supplied.");
            }
  
            zygoteServer.registerServerSocketFromEnv(socketName); // 注册Socket
  
            if (!enableLazyPreload) { // first fork.
                preload(bootTimingsTraceLog); // 预加载资源到VM：class,resources,OpenGL,SharedLibrary,text,web
            } else {
                Zygote.resetNicePriority();
            }
  
            gcAndFinalize(); // 主动请求GC，因为后面有fork操作
  
            if (startSystemServer) {
                Runnable r = forkSystemServer(abiList, socketName, zygoteServer); // 从zygote fork服务进程
                if (r != null) {
                    r.run(); // {@code r != null} 在子（system_server）进程中。
                    return;
                } // {@code r == null} 在父（zygote）进程中
            }
  
            caller = zygoteServer.runSelectLoop(abiList); // loops forever in the zygote.‼️
        if (caller != null) {
            caller.run();
        }
    }
}

启动系统服务进程- fork

从zygote fork SystemServer进程

• com.android.server.SystemServer.java

public class ZygoteInit {
  private static Runnable forkSystemServer(String abiList, String socketName, ZygoteServer zygoteServer) {
        /* Hardcoded command line to start the system server */
        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",
        };
    
        int pid;
            /* Request to fork the system server process */
            pid = Zygote.forkSystemServer(
                    parsedArgs.uid, parsedArgs.gid,
                    parsedArgs.gids,
                    parsedArgs.runtimeFlags,
                    null,
                    parsedArgs.permittedCapabilities,
                    parsedArgs.effectiveCapabilities);
  
        /* For child process */
        if (pid == 0) {
            if (hasSecondZygote(abiList)) {
                waitForSecondaryZygote(socketName);
            }

            zygoteServer.closeServerSocket(); // 不是zygote进程了，要关闭socket
            return handleSystemServerProcess(parsedArgs); // 新进程SystemServer从这里开始初始化工作
        }

        return null;
  }
}

public class ZygoteInit {
    private static Runnable handleSystemServerProcess(ZygoteConnection.Arguments parsedArgs) {
        final String systemServerClasspath = Os.getenv("SYSTEMSERVERCLASSPATH");
        if (systemServerClasspath != null) {
                    // 1.将"SYSTEMSERVERCLASSPATH"中的AppInfo加载到VM中。
                    prepareSystemServerProfile(systemServerClasspath);
            }
        }
  
        if (parsedArgs.invokeWith != null) { // 2.判断fork args中是否有invokWith参数
            //2.1.使用 wrapper command 执行运行时应用程序。该方法永不返回。
            WrapperInit.execApplication(parsedArgs.invokeWith,
                    parsedArgs.niceName, parsedArgs.targetSdkVersion,
                    VMRuntime.getCurrentInstructionSet(), null, args);
            throw new IllegalStateException("Unexpected return from WrapperInit.execApplication");
        } else { //2.2.通过 zygote 进程启动时调用的主函数。RuntimeInit.applicationInit;
            return ZygoteInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs, cl);
        }
    }
}

ZygoteInit.nativeZygoteInit(); // java -> cpp，创建 Process 和 PoolThread

public class RuntimeInit {
    static class MethodAndArgsCaller implements Runnable {
        public void run() { // 最终返回的主程
            try {
                mMethod.invoke(null, new Object[] { mArgs });
            } catch (Exception ex) {
            }
        }
    }
}

5. System Server

System Server 是Zygote fork 的第一个Java进程， 这个进程非常重要，因为他有很多的系统线程，提供所有核心的系统服务。

public final class SystemServer {
    public static void main(String[] args) {
        new SystemServer().run(); // fr:ZygoteInit#forkSystemServer
    }
}

初始化

1. 初始化必要的SystemServer环境参数，比如系统时间、默认时区、语言、loadLibrary等等

2. 初始化Looper，我们在主线程中使用到的looper就是在SystemServer中进行初始化的

   Looper.prepareMainLooper();
   Looper.getMainLooper().setSlowLogThresholdMs(SLOW_DISPATCH_THRESHOLD_MS, SLOW_DELIVERY_THRESHOLD_MS);
   //...
   Looper.loop();
   

3. 初始化Context，加载framework层资源，只有初始化一个Context才能进行启动Service等操作

   public final class SystemServer {
       private void createSystemContext() {
           ActivityThread activityThread = ActivityThread.systemMain(); //‼️
           mSystemContext = activityThread.getSystemContext(); // ContextImpl.createSystemContext(this);
           mSystemContext.setTheme(DEFAULT_SYSTEM_THEME); // 设置系统主题
   
           final Context systemUiContext = activityThread.getSystemUiContext();
           systemUiContext.setTheme(DEFAULT_SYSTEM_THEME);
       }
   }
   

   class ContextImpl extends Context {
       static ContextImpl createSystemContext(ActivityThread mainThread) {
            //‼️ 创建ApplicationInfo对象、创建ClassLoader
           LoadedApk packageInfo = new LoadedApk(mainThread);
           // 创建系统级的上下文
           ContextImpl context = new ContextImpl(null, mainThread, packageInfo, null, null, null, 0, null);
           context.setResources(packageInfo.getResources());
           context.mResources.updateConfiguration(context.mResourcesManager.getConfiguration(), context.mResourcesManager.getDisplayMetrics());
           return context;
       }
   }
   

4. 初始化**SystemServiceManager**，用来管理启动service，SystemServiceManager中封装了startService等方法。

   public final class SystemServer {
       private void run() {
           try {
               mSystemServiceManager = new SystemServiceManager(mSystemContext);
           }
           try {
               startBootstrapServices(); // 启动引导服务
               startCoreServices(); // 核心服务
               startOtherServices(); // 其它
           }
           //... eg:.loop();
       }
   }
   

Zygote监听并处理 SystemServer 的 SIGCHID 信号，一旦SystemServer崩溃，立即将自己杀死。init会重启Zygote。

创建*systemMain*

    public static 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();
        }
        ActivityThread thread = new ActivityThread(); // 获取资源管理器实例：`ResourcesManager.getInstance();`
        thread.attach(true, 0);
        return thread;
    }

attach到进程

thread.attach(/system/true, /startSeq/0);

public final class ActivityThread extends ClientTransactionHandler {
    private void attach(boolean system, long startSeq) {
        sCurrentActivityThread = this;
        mSystemThread = system;
        if (!system) {
          //... ‼️普通app进程初始化是在 ActivityThread 的 "handleBindApplication()"
        } else {
            android.ddm.DdmHandleAppName.setAppName("system_process", UserHandle.myUserId());
            try {
                mInstrumentation = new Instrumentation(); //‼️
                mInstrumentation.basicInit(this);
                ContextImpl context = ContextImpl.createAppContext(this, getSystemContext().mPackageInfo);
                mInitialApplication = context.mPackageInfo.makeApplication(/*forceDefaultAppClass*/true, /*instrumentation*/null); // 系统服务的"mInitialApplication"对应着"system_process".
                mInitialApplication.onCreate();
            } catch (Exception e) {
                throw new RuntimeException("Unable to instantiate Application():" + e.toString(), e);
            }
        }
        //... eg:ViewRootImpl
    }
}

再说fork

使用 fork() 函数得到的子进程是父进程的一个复制品，它从父进程处继承了整个进程的地址空间:包括进程上下文(进程执行活动全过程的静态描述)、进程堆栈、打开的文件描述符、信号控 制设定、进程优先级、进程组号等。子进程所独有的只有它的进程号，计时器等(只有小量信 息)。因此，使用 fork() 函数的代价是很大的。

写时拷贝 (copy-on-write)

Linux 的 fork() 使用是通过写时拷贝 (copy- on-write) 实现。写时拷贝是一种可以推迟甚至避免拷贝数据的技术。内核此时并不复制整个进程的地址空间，而是让父子进程共享同一个地址空间。只用在需要写入的时候才会复制地址空间，从而使各个进行拥有各自的地址空间。也就是说，资源的复制是在需要写入的时候才会进行，在此之前，只有以只读方式共享。

6. Apps

等这些服务启动之后，AMS 中就 会打开 Launcher 应用的 home Activity，最终就看到了手机的 “桌面”。

⌛️