Android SystemServer的创建过程

最新推荐文章于 2024-08-17 11:15:23 发布
置顶 最新推荐文章于 2024-08-17 11:15:23 发布
阅读量678 收藏
点赞数
分类专栏： Android开发

SystemServer进程是有Zygote fork出来的一个进程，下面来看看zygote进程的执行过程

frameworks/base/cmds/app_process/app_main.cpp

int main(int argc, char* const argv[])
{
   // zygote进程是由init进程通过fork而来
    AppRuntime runtime;

    if (zygote) {
        runtime.start("com.android.internal.os.ZygoteInit",
                startSystemServer ? "start-system-server" : "");
    }
}

/frameworks/base/core/jni/AndroidRuntime.cpp

void AndroidRuntime::start(const char* className, const char* options)
{
    /*
     * 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;
    jstring optionsStr;

    stringClass = env->FindClass("java/lang/String");
    assert(stringClass != NULL);
    strArray = env->NewObjectArray(2, stringClass, NULL);
    assert(strArray != NULL);
    classNameStr = env->NewStringUTF(className);
    assert(classNameStr != NULL);
    env->SetObjectArrayElement(strArray, 0, classNameStr);
    optionsStr = env->NewStringUTF(options);
    env->SetObjectArrayElement(strArray, 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);
    // 得到"com.android.internal.os.ZygoteInit"类
    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 {
            // 调用ZygoteInit类的main方法
            env->CallStaticVoidMethod(startClass, startMeth, strArray);

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

下面就进入到了com.android.internal.os.ZygoteInit的main方法中。

public static void main(String argv[]) {  
    try {  
        ……  
        // 启动SystemServer
        if (argv[1].equals("start-system-server")) {  
            startSystemServer();  
        }   
        ……  
    } catch (MethodAndArgsCaller caller) {  
        caller.run();  
    } catch (RuntimeException ex) {  
        ……  
    }  
} 
private static boolean startSystemServer()
        throws MethodAndArgsCaller, RuntimeException {
    long capabilities = posixCapabilitiesAsBits(
        OsConstants.CAP_KILL,
        OsConstants.CAP_NET_ADMIN,
        OsConstants.CAP_NET_BIND_SERVICE,
        OsConstants.CAP_NET_BROADCAST,
        OsConstants.CAP_NET_RAW,
        OsConstants.CAP_SYS_MODULE,
        OsConstants.CAP_SYS_NICE,
        OsConstants.CAP_SYS_RESOURCE,
        OsConstants.CAP_SYS_TIME,
        OsConstants.CAP_SYS_TTY_CONFIG
    );
    /* 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,1032,3001,3002,3003,3006,3007",
        "--capabilities=" + capabilities + "," + capabilities,
        "--runtime-init",
        "--nice-name=system_server",
        "com.android.server.SystemServer",
    };
    ZygoteConnection.Arguments parsedArgs = null;

    int pid;

    try {
        parsedArgs = new ZygoteConnection.Arguments(args);
        ZygoteConnection.applyDebuggerSystemProperty(parsedArgs);
        ZygoteConnection.applyInvokeWithSystemProperty(parsedArgs);

        /* Request to fork the system server process */
        pid = Zygote.forkSystemServer(
                parsedArgs.uid, parsedArgs.gid,
                parsedArgs.gids,
                parsedArgs.debugFlags,
                null,
                parsedArgs.permittedCapabilities,
                parsedArgs.effectiveCapabilities);
    } catch (IllegalArgumentException ex) {
        throw new RuntimeException(ex);
    }

    /* For child process */
    if (pid == 0) {
        handleSystemServerProcess(parsedArgs);
    }

    return true;
}

设置进程的参数是system_server，对应的类是com.android.server.SystemServer。
Zygote.forkSystemServer真正地fork一个进程,参数前面已经设置好了，所以，这个fork出来的进程就是system_server,而这个进程是zygote的子进程

创建得到SystemServer进程之后，下面执行handleSystemServerProcess方法。

private static void handleSystemServerProcess(
        ZygoteConnection.Arguments parsedArgs)
        throws ZygoteInit.MethodAndArgsCaller {

    // 修改进程名为system_server  
    if (parsedArgs.niceName != null) {
        Process.setArgV0(parsedArgs.niceName);
    }

    if (parsedArgs.invokeWith != null) {
        WrapperInit.execApplication(parsedArgs.invokeWith,
                parsedArgs.niceName, parsedArgs.targetSdkVersion,
                null, parsedArgs.remainingArgs);
    } else {
        //最终会调用该方法
        RuntimeInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs);
    }
}

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

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

    redirectLogStreams();
    // 做一些常规初始化  
    commonInit();
    // native层的初始化  
    nativeZygoteInit();
    // 调用应用程序java层的main 方法
    applicationInit(targetSdkVersion, argv);
}
private static void applicationInit(int targetSdkVersion, String[] argv)  
            throws ZygoteInit.MethodAndArgsCaller {  
        nativeSetExitWithoutCleanup(true);  

        VMRuntime.getRuntime().setTargetHeapUtilization(0.75f);  
        VMRuntime.getRuntime().setTargetSdkVersion(targetSdkVersion);  

        final Arguments args;  
        try {  
            args = new Arguments(argv);  
        } catch (IllegalArgumentException ex) {  
            Slog.e(TAG, ex.getMessage());  
            return;  
        }  

        // 调用传递过来的类的静态main方法
        invokeStaticMain(args.startClass, args.startArgs);  
} 
private static void invokeStaticMain(String className, String[] argv)  
            throws ZygoteInit.MethodAndArgsCaller {  
        Class<?> cl;  

        try {  
            // 加载com.android.server.SystemServer这个类  
            cl = Class.forName(className);  
        } catch (ClassNotFoundException ex) {  
            throw new RuntimeException(  
                    "Missing class when invoking static main " + className,  
                    ex);  
        }  

        Method m;  
        try {  
            // 获得main方法  
            m = cl.getMethod("main", new Class[] { String[].class });  
        } catch (NoSuchMethodException ex) {  
            throw new RuntimeException(  
                    "Missing static main on " + className, ex);  
        } catch (SecurityException ex) {  
            throw new RuntimeException(  
                    "Problem getting static main on " + className, ex);  
        }  

        int modifiers = m.getModifiers();  
        // 判断main函数的类型  
        if (! (Modifier.isStatic(modifiers) && Modifier.isPublic(modifiers))) {  
            throw new RuntimeException(  
                    "Main method is not public and static on " + className);  
        }  

        /* 
         * This throw gets caught in ZygoteInit.main(), which responds 
         * by invoking the exception's run() method. This arrangement 
         * clears up all the stack frames that were required in setting 
         * up the process. 
         */  
        throw new ZygoteInit.MethodAndArgsCaller(m, argv);  
}

ZygoteInit.MethodAndArgsCaller是一个继承自Exception的类，invokeStaticMain最后并没有直接调用com.android.server.SystemServer的main 方法，而是抛出了一个ZygoteInit.MethodAndArgsCalle类型的异常。

public static void main(String argv[]) {  
    try {  
        ……  

        if (argv[1].equals("start-system-server")) {  
            startSystemServer();  
        }   
        ……  
    } catch (MethodAndArgsCaller caller) {  
        caller.run();  
    } catch (RuntimeException ex) {  
        ……  
    }  
}

main函数中通过try-catch最终捕获到了MethodAndArgsCaller异常，并通过异常类的run函数来处理。

public static class MethodAndArgsCaller extends Exception  
            implements Runnable {  
    /** method to call */  
    private final Method mMethod;  

    /** argument array */  
    private final String[] mArgs;  

    // 构造函数将参数保存下来      
    public MethodAndArgsCaller(Method method, String[] args) {  
            mMethod = method;  
            mArgs = args;  
        }  

        // run函数调用main函数  
    public void run() {  
            try {  
                mMethod.invoke(null, new Object[] { mArgs });  
            } catch (IllegalAccessException ex) {  
                throw new RuntimeException(ex);  
            } catch (InvocationTargetException ex) {  
                ……  
            }  
        }  
    }  
}

参考文章：
http://blog.csdn.net/hu3167343/article/details/38375167

欢迎关注微信公众号：DroidMind
精品内容独家发布平台


呈现与博客不一样的技术干货

DroidMind
关注
专栏目录
Android 8.1zygote服务 SystemServer启动流程 Activity创建
02-26
Android zygote服务/SystemServer启动流程/Activity创建,本文档继承Android init的分析，继续往下分析Zygote进程、SystemServer进程的创建、Activity的建立
Android系统启动系列5 SystemServer进程下
liuwg1226的专栏
11-10 1565
一　概述 上一篇文章介绍了 SystemServer 的 main 函数是怎么被调用的，本篇主要分析 SystemServer 进程启动的时候，主要做了哪些事情，SystemServer 中运行的服务有八十多种，包括 ActivityManagerService(AMS)，WindowManagerService(WMS)，PackagManagerService(PMS)等，这些系统服务都是以一个线程的方式存在 Systemserver 进程中。接下来我们来看这些服务是怎么被启动的． 二　SystemSe
【Android FrameWork】SystemServer
03-26 544
Android系统在启动的时候有两个非常重要的进程，一个是Zygote，另一个就是system_server。
Android大脑--systemserver进程
最新发布
niurenwo的专栏
08-17 1097
系统native进程的文章就先告一段落了，从这篇文章开始写Java层的文章，本文同样延续自述的方式来介绍**systemserver**进程，通过本文您将了解到**systemserver**进程是啥？它包含那么多的服务，是如何管理它们的？如何启动它们的
【Android】AMS（二）SystemServer作用和启动一个新的Activity流程
每天不是在写bug就是在写bug的路上
06-06 939
SystemServer作用和启动一个新的Activity流程
Android Framework分析SystemServer进程
工宗浩生财指南针
06-16 590
如上所示，SystemServer主要由三个部分组成：main()方法、启动各种系统服务的run()方法，以及三个启动服务的方法：startCoreServices()、startOtherServices()和startBootstrapServices()。如上所示，在“run”方法中，首先调用“startCoreServices”方法以启动核心服务，接着调用“startOtherServices”方法以启动其他服务，最后调用“startBootstrapServices”方法以启动引导服务。
Android SystemServer 启动流程分析
程序员Android
07-09 1684
和你一起终身学习，这里是程序员Android经典好文推荐，通过阅读本文，您将收获以下知识点:一、SystemServer 启动的服务有哪些二、SystemServer启动总体流程概述三、SystemServer 如何启动，是谁启动的？四、 SystemServer 启动入门 main 方法五、SystemServer Run 方法初始与启动六、SystemServer 的引导服务有哪些七、Syst...
Android启动-SystemServer的启动过程介绍
01-12
Android启动，第三阶段，SystemServer创建。 紧接上两篇《 Android启动-init介绍》和《Android启动-Zygote启动介绍》Linux内核启动之后,执行第一个进程 Init-->init创建Zygote-->fork出SystemServer。 这里...
Android 按键消息流程源码分析
05-08
- **wmHandlerThread的创建**：在系统启动过程中，SystemServer会创建一个专门用于处理按键消息的`Handler`线程`wmHandlerThread`。 - **InputManagerService的创建**：随后创建`InputManagerService`实例，其中传入...
android系统从systemserver开始的launcher启动详细流程.doc
10-07
Android 系统启动流程是一个复杂的过程，从 SystemServer 开始到 Launcher 的启动涉及到多个组件和服务的协作。本文将详细介绍 Android 系统从 SystemServer 开始的 Launcher 启动流程，并对其中的关键组件和服务...
android系统从systemserver开始的launcher启动详细流程
07-28
2. **ActivityManagerService初始化**：systemserver创建ActivityManagerService并初始化。 3. **启动Launcher**：ActivityManagerService调用相关方法启动Launcher应用。 4. **创建Launcher进程**：通过Zygote进程...
Android 10.0 系统启动之SystemServer进程-[Android取经之路]
纸上得来终觉浅，绝知此事要躬行
05-01 3111
[Android取经之路] 的源码都基于Android-Q（10.0） 进行分析 [Android取经之路] 系列文章： 《系统启动篇》 Android系统架构 Android是怎么启动的 Android 10.0系统启动之init进程 Android10.0系统启动之Zygote进程 Android 10.0 系统启动之SystemServer进程 Android 10.0 系统服务之ActivityMnagerService Android10.0系统启动之Launcher(桌面)启动流程 And
Android Framework 之 SystemServer
milan-xiao-tiejiang的博客
08-01 778
SystemServer是Android系统中的一个核心组件，负责启动和管理许多重要的系统服务。
Android系统启动（三） — SystemServer处理过程
xingyu19911016的博客
01-13 1449
AMSWMSPMS具体来说，Binder。
【Android】system_server 创建和启动流程
yang553566463的博客
11-21 4289
SystemServer进程的创建和启动流程 在将SystemServer的启动流程之前，先回顾一下上一篇章的内容： 上篇文章中，我们介绍了从init进程到zygote进程再到SystemServer进程开始创建的流程，大致是这样的： 1、执行app_main.cpp文件的main方法（init进程中） 2、main方法中初始化AndroidRuntime 3、执行runtime.start()启动Android运行时环境，其中，start()方法内部通过startVM方法创建了虚拟机，通过startReg
android的system_server进程的启动
weixin_43228946的博客
04-01 1242
android的system_server进程的启动
Android SystemServer 进程
Lud的博客
04-02 3692
SystemServer 是系统的核心之一，大部分android提供的服务都运行在这个进程中，SystemServer 中运行的服务大概有八十多种。为了防止应用进程对系统造成破坏，Android应用进程没有权限直接访问设备的底层资源，只能通过 SystemServer 中的服务代理访问。通过 Binder 用户进程使用 SystemServer 中的服务并没有太多不便之处。
Android SystemServer介绍
liuning1985622的博客
05-02 292
SystemServer是Android系统中的一个重要进程，它负责启动和管理系统中的各种服务。这些服务包括WindowManagerServer(WMS)、ActivityManagerService(AMS)和PackageManagerServer(PMS)等。SystemServer进程在系统中的名称为"system_server"。SystemServer的主要职责是启动和管理系统服务。它在系统启动时被启动，并负责创建和初始化系统服务。
Android framework层SystemServer类详解
lvyaer_1122的博客
04-24 851
SystemServer类主要是启动系统服务的，系统服务分为三类：引导服务BootstrapServices，核心服务CoreServices，其他服务OtherServices。
Android12SystemServer启动流程
09-07
Android 12 SystemServer 的启动流程如下： 1. 引导加载：系统启动时，先加载引导程序，进行硬件初始化、内核加载等操作。 2. Zygote 进程启动：Zygote 是 Android 系统中的一个特殊进程，负责孵化其他应用进程。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值