`
sharp2wing
  • 浏览: 271507 次
  • 性别: Icon_minigender_1
  • 来自: 南京
文章分类
社区版块
存档分类
最新评论

System Server 分析

阅读更多
SystemServer 是 Android Java 层的系统服务模块,这个模块主要功能就是管理供 Android 应用开发的 system service.
一.SystemServer 类是如何启动的

让我们从 Android 的启动过程看起,查看 init.rc 文件,就会发现下面这一行service zygote /system/bin/app_process -Xzygote /system/bin –zygote –start-system-server

我们知道 zygote 进程是整个 Android 的孵化器进程,所有的 Activity 进程均是通过它来生成的。我们发现在 zygote 进程启动过程中指定了这么一个参数“– start-system-server” ,这个参数就是在 zygote 进程启动的同时启动 SystemServer 。

那么 SystemServer 是以什么样的形式启动的呢?是单独的一个进程还是线程,分析一下 zygote 进程的启动过程就明白了。在 Android 中 zygote 进程启动其实就是启动 /system/bin/app_process 这个进程,这个进程的源代码在 frameworks/base/cmds/app_process/app_main.cpp 中。

        if (0 == strcmp("--zygote", arg)) {
            bool startSystemServer = (i < argc) ?
                    strcmp(argv[i], "--start-system-server") == 0 : false;
            setArgv0(argv0, "zygote");
            set_process_name("zygote");
            runtime.start("com.android.internal.os.ZygoteInit",
                startSystemServer);
        } else {
            set_process_name(argv0);

            runtime.mClassName = arg;

            // Remainder of args get passed to startup class main()
            runtime.mArgC = argc-i;
            runtime.mArgV = argv+i;

            LOGV("App process is starting with pid=%d, class=%s.\n",
                 getpid(), runtime.getClassName());
            runtime.start();
        }

由于 zygote 进程启动过程有“ –zygote” 这个参数,所以走的是下面这步

runtime.start("com.android.internal.os.ZygoteInit",startSystemServer);

查看对象 runtime 的类型的定义,

class AppRuntime : public AndroidRuntime

因此查看 AndroidRuntime 的 start 方法中的一段代码 (frameworks/base/core/jni/AndroidRuntime.cpp)

    startClass = env->FindClass(slashClassName);
    if (startClass == NULL) {
        LOGE("JavaVM unable to locate class '%s'\n", slashClassName);
        /* keep going */
    } else {
        startMeth = env->GetStaticMethodID(startClass, "main",
            "([Ljava/lang/String;)V");
        if (startMeth == NULL) {
            LOGE("JavaVM unable to find main() in '%s'\n", className);
            /* keep going */
        } else {
            env->CallStaticVoidMethod(startClass, startMeth, strArray);

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

其中 startClass 即为 “com.android.internal.os.ZygoteInit” ,这段代码调用了 com.android.internal.os.ZygoteInit 的 main 函数。

那么再往下看 ZygoteInit 类的 main 函数,其中的一段 MethodAndArgsCaller 代码为

            if (argv[1].equals("true")) {
                startSystemServer();
            } else if (!argv[1].equals("false")) {
                throw new RuntimeException(argv[0] + USAGE_STRING);
            }

调用了 startSystemServer () ,这个函数启动了一个子进程来作为 SystemServer 的载体,

1. 它首先指定 SystemServer 进程的参数 ;

2. 根据指定的参数来创建 SystemServer 进程;

3. 调用 handleSystemServerProcess 启动第一步指定进程参数过程中指定的类,此时为“ com.android.server.SystemServer ” ,启动的这个进程在 ps 查看后显示为” system_server ” 。

    private static boolean startSystemServer()
            throws MethodAndArgsCaller, RuntimeException {
        /* Hardcoded command line to start the system server */
        String args[];
        String ashmem_size = System.getProperty("gralloc.ashmem_size");
        if ((null != ashmem_size) && (0 != ashmem_size.length())) {
            args = new String[] {
                "--setuid=1000",
                "--setgid=1000",
                "--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,3001,3002,3003,3006",
                "--capabilities=130104352,130104352",
                "--rlimit=8,",
                "--runtime-init",
                "--nice-name=system_server",
                "com.android.server.SystemServer",
            };
            args[4] = args[4].concat(ashmem_size);
            args[4] = args[4].concat(",");
            args[4] = args[4].concat(ashmem_size);
        } else {
            args = new String[] {
                "--setuid=1000",
                "--setgid=1000",
                "--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,3001,3002,3003,3006",
                "--capabilities=130104352,130104352",
                "--runtime-init",
                "--nice-name=system_server",
                "com.android.server.SystemServer",
            };
        }
        ZygoteConnection.Arguments parsedArgs = null;

        int pid;

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

            /*
             * Enable debugging of the system process if *either* the command line flags
             * indicate it should be debuggable or the ro.debuggable system property
             * is set to "1"
             */
            int debugFlags = parsedArgs.debugFlags;
            if ("1".equals(SystemProperties.get("ro.debuggable")))
                debugFlags |= Zygote.DEBUG_ENABLE_DEBUGGER;

            int[][] rlimits = new int[0][0];

            if (parsedArgs.rlimits != null) {
                rlimits = parsedArgs.rlimits.toArray(rlimits);
            }

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

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

        return true;
    }

通过以上过程就会调用到 SystemServer 类,且是运行在一个名为“ system_server” 的进程中,这个进程为 zygote 的子进程。

虽然 SystemServer 类是运行在 system_server 中的,但是它并不运行在 system_server 的主线程中。

  /**
     * Finish remaining work for the newly forked system server process.
     */
    private static void handleSystemServerProcess(
            ZygoteConnection.Arguments parsedArgs)
            throws ZygoteInit.MethodAndArgsCaller {

        closeServerSocket();

        /*
         * Pass the remaining arguments to SystemServer.
         * "--nice-name=system_server com.android.server.SystemServer"
         */
        RuntimeInit.zygoteInit(parsedArgs.remainingArgs);
        /* should never reach here */
    }

/**
     * The main function called when started through the zygote process. This
     * could be unified with main(), if the native code in finishInit()
     * were rationalized with Zygote startup.&lt;p&gt;
     *
     */
    public static final void zygoteInit(String[] argv)
            throws ZygoteInit.MethodAndArgsCaller {
        // TODO: Doing this here works, but it seems kind of arbitrary. Find
        // a better place. The goal is to set it up for applications, but not
        // tools like am.
        System.setOut(new AndroidPrintStream(Log.INFO, "System.out"));
        System.setErr(new AndroidPrintStream(Log.WARN, "System.err"));

        commonInit();
        zygoteInitNative();

        int curArg = 0;
        for ( /* curArg */ ; curArg &lt; argv.length; curArg++) {
            String arg = argv[curArg];

            if (arg.equals("--")) {
                curArg++;
                break;
            } else if (!arg.startsWith("--")) {
                break;
            } else if (arg.startsWith("--nice-name=")) {
                String niceName = arg.substring(arg.indexOf('=') + 1);
                Process.setArgV0(niceName);
            }
        }

        if (curArg == argv.length) {
            Slog.e(TAG, "Missing classname argument to RuntimeInit!");
            // let the process exit
            return;
        }

        // Remaining arguments are passed to the start class's static main

        String startClass = argv[curArg++];
        String[] startArgs = new String[argv.length - curArg];

        System.arraycopy(argv, curArg, startArgs, 0, startArgs.length);
        invokeStaticMain(startClass, startArgs);
    }

/**
     * Invokes a static "main(argv[]) method on class "className".
     * Converts various failing exceptions into RuntimeExceptions, with
     * the assumption that they will then cause the VM instance to exit.
     *
     * @param className Fully-qualified class name
     * @param argv Argument vector for main()
     */
    private static void invokeStaticMain(String className, String[] argv)
            throws ZygoteInit.MethodAndArgsCaller {

        // We want to be fairly aggressive about heap utilization, to avoid
        // holding on to a lot of memory that isn't needed.
        VMRuntime.getRuntime().setTargetHeapUtilization(0.75f);

        Class&lt;?&gt; cl;

        try {
            cl = Class.forName(className);
        } catch (ClassNotFoundException ex) {
            throw new RuntimeException(
                    "Missing class when invoking static main " + className,
                    ex);
        }

        Method m;
        try {
            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();
        if (! (Modifier.isStatic(modifiers) &amp;&amp; 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);
    }

由代码可以看出,在调用函数 invokeStaticMain 的最后会抛出一个异常。

public static class MethodAndArgsCaller extends Exception implements Runnable

回过头再看一下 ZygoteInit 类的 main 函数中的一段代码

catch (MethodAndArgsCaller caller) {
caller.run();
}

其实就是在这个抛出的异常中启动了 SystemServer 类,且这个异常为一个 Runnable 类型,因此 SystemServer 类就运行在 system_server 进程中的一个新的线程里。
二.SystemServer 执行内容

1. 执行 frameworks/base/cmds/system_server/library/system_init.cpp 中的 system_init 函数,启动当前进程,也就是进程 system_server 的 pool thread ,以便执行 Binder IPC 操作。

2. 向 SM(Service Manager) 添加系统服务。
分享到:
评论

相关推荐

    thinksystem安装window server2008R2

    在安装Windows Server 2008 R2操作系统的过程中,对于ThinkSystem服务器来说,正确的驱动程序配置至关重要,因为这些驱动能够确保硬件与操作系统之间的完美协同工作。以下是对标题和描述中涉及知识点的详细说明: 1...

    microsoft system clr types for sql server 2014

    标题中的“microsoft system clr types for sql server 2014”是指Microsoft SQL Server 2014的系统公共语言运行库类型(System CLR Types),它是一组.NET Framework类库,用于与SQL Server进行交互,特别是在处理...

    Sun Java System Active Server Pages 4.0

    Sun Java System Active Server Pages 4.0 是一款由Sun Microsystems公司开发的服务器端脚本环境,主要用于构建动态Web应用程序。这个版本是Sun ONE (Open Network Environment) 应用服务器的一部分,它提供了对ASP ...

    Sun Java System Directory Server.5.2

    Sun Java System Directory Server 5.2 是一款由Sun Microsystems开发的企业级 Lightweight Directory Access Protocol (LDAP) 服务器。作为目录服务的核心组件,它被设计用于存储、管理和检索大量结构化数据,如...

    SQL Server2008 System View Print

    "SQL Server 2008 System View Print"提供的打印版资源,为不方便在线查阅或需要离线参考的用户提供了便利。它可能包含了系统视图的详细说明、示例查询以及在实际工作中的应用案例,帮助用户更直观地理解和使用这些...

    init、zygote、system-server、watchdog分析

    ### init、zygote、system-server、watchdog分析 #### 一、概述 在深入探讨`init`、`zygote`、`system-server`以及`watchdog`这些核心组件之前,我们首先来简单了解一下它们的基本功能和作用。 1. **init**:...

    SQL Server查询分析器绿色版

    SQL Server查询分析器是Microsoft SQL Server数据库管理系统中的一个重要工具,主要用于编写、测试和优化SQL查询。这个绿色版意味着它是一个便携式版本,无需安装即可使用,方便在不同计算机上携带和运行。以下是对...

    ThinkSystem SR850 Server Product Guide

    其建议用途包括一般业务整合、数据分析、虚拟化、数据库、密集计算和科学应用程序等。 SR850采用2U的紧凑设计,提供了高级功能和能力,包括最多支持四个插槽和48个DIMM内存插槽,可以混合匹配内部存储,并配备了...

    Microsoft sql server system Report Viewer 2012

    总的来说,Microsoft SQL Server System Report Viewer 2012是开发和展示SQL Server报表不可或缺的组件,它提供了强大的报表查看和交互功能,使得数据分析和决策制定更为便捷。通过正确安装和配置,开发人员可以在...

    hook_system

    在Android系统中,"hook_system"是一个涉及到系统服务核心进程`system_server`的高级技术主题。`system_server`是Android操作系统中的关键组件,它负责管理应用程序的生命周期、处理用户界面事件以及执行各种系统...

    ThinkSystem SR650 Server Product Guide

    SR650服务器设计用于处理广泛的各类工作负载,包括数据库、虚拟化和云计算、虚拟桌面基础架构(VDI)、企业应用程序、协作/电子邮件以及商业分析和大数据分析。SR650服务器采用了Intel Xeon处理器可扩展家族,提供了...

    Wonderware System Platform 培训手册

    1. Wonderware Application Server 3.1: Wonderware Application Server是一个应用程序服务器,负责托管和执行Wonderware System Platform下的应用程序。Beijing TDTK Technology Development Co., Ltd.很可能是一家...

    SQL Server Native Client 10,以便于SQLserver高版本可以链接SQLserver2000

    压缩包内附带链接服务器创建脚本方式,此SQL Server Native Client 10.0无病毒,有64位和32位可供选择。SQL Server Native Client 11.0 不支持连接到 SQL Server 2000 或更早的版本。 通过安装SQL Server Native ...

    Sun Java System Web Server 7.0 管理員指南.pdf

    - **部署架构与前置作业**:部署Web Server时的架构设计与需求分析,特别提到了集群环境下的硬件和软件要求,以及如何配置集群以实现作业复制和容错移转。 #### 虚拟服务器与安全设置 - **虚拟服务器**:通过预设...

    Sun Java System Portal Server 7.2 Developer's Guide.pdf

    ### Sun Java System Portal Server 7.2 Developer's Guide 关键知识点概述 #### 一、产品简介 《Sun Java System Portal Server 7.2 Developer's Guide》是Sun Microsystems为Sun Java System Portal Server 7.2...

    SQL Server 2005 性能分析和调优

    ### SQL Server 2005 性能分析与调优 #### 一、性能优化的思想与流程 在《SQL Server 2005 性能分析和调优》这一主题中,作者首先强调了性能优化的基本思想:通过一系列的方法和技术手段来提升SQL Server 2005的...

    ThinkSystem SR860 Server Product Guide

    5. **适用场景**:SR860 适用于多种业务场景,包括一般业务整合、数据分析、虚拟化、数据库、密集计算和科学应用等。 6. **地区可用性**:ThinkSystem SR860 服务器仅在欧洲、中东、非洲(EMEA)和中国地区可用。 ...

    如何利用Microsoft System Center管理、部署及保护Exchange Server 2007

    System Center 的解决方案可以协同工作,提供一个集成的端到端管理方案,简化 IT 运营并捕获分析有关基础设施和业务流程的信息。这为 IT 部门提供了全面管理物理和虚拟基础设施的能力,同时保持高效和有效。 #### ...

    如何利用Microsoft System Center管理、部署及保护Windows Server 2008

    ### 如何利用Microsoft System Center管理、部署及保护Windows Server 2008 #### 一、Microsoft System Center简介 Microsoft System Center 是微软提供的一系列系统管理解决方案,旨在提高 IT 部门的工作效率与...

    基于python和SQL server的 detect auto classify system

    标题中的“基于python和SQL server的detect auto classify system”指的是一个使用Python编程语言与SQL Server数据库结合构建的自动分类系统。这个系统的核心功能是检测和自动分类数据,可能广泛应用于数据分析、...

Global site tag (gtag.js) - Google Analytics