Android源码流程梳理—Android U SystemServer启动流程

简介

基于Android U梳理
在线opengrouk：http://www.aospxref.com/
  在Android系统中，SystemServer是一个至关重要的组件，它负责启动和管理系统中的各种服务。在系统启动过程中，SystemServer扮演着关键的角色，它负责初始化和启动核心系统服务，为整个Android系统的正常运行奠定基础。

  了解SystemServer的启动流程有助于我们深入理解Android系统启动的关键步骤和原理，为系统调优和定制化提供重要参考。

代码分析

Zygote进程启动SystemServer

Zygote进程，通过fork()函数，最终孵化出system_server的进程，通过反射的方法启动。
/frameworks/base/core/java/com/android/internal/os/ZygoteInit.java

private static Runnable forkSystemServer(String abiList, String socketName,
                                         ZygoteServer zygoteServer) {
    // 省略了一部分代码...
    
    // 硬编码的命令行参数，用于启动SystemServer
    String[] args = {
            "--setuid=1000", // 设置用户ID为1000
            "--setgid=1000", // 设置组ID为1000
            "--setgroups=1001,1002,1003,1004,1005,1006,1007,1008,1009,1010,1018,1021,1023,"
                    + "1024,1032,1065,3001,3002,3003,3005,3006,3007,3009,3010,3011,3012", // 设置附加组ID列表
            "--capabilities=" + capabilities + "," + capabilities, // 设置进程的能力（权限）
            "--nice-name=system_server", // 设置进程的名称为system_server
            "--runtime-args", // 添加运行时参数
            "--target-sdk-version=" + VMRuntime.SDK_VERSION_CUR_DEVELOPMENT, // 设置目标SDK版本
            "com.android.server.SystemServer", // 启动的主类名
    };
    ZygoteArguments parsedArgs; // 解析后的参数对象
  
    int pid; // 进程标识符
  
    try {
        // 创建ZygoteCommandBuffer来处理命令行参数
        ZygoteCommandBuffer commandBuffer = new ZygoteCommandBuffer(args);
        try {
            // 解析命令缓冲区以获取ZygoteArguments实例
            parsedArgs = ZygoteArguments.getInstance(commandBuffer);
        } catch (EOFException e) {
            // 如果解析过程中发生意外错误，抛出断言错误
            throw new AssertionError("Unexpected argument error for forking system server", e);
        }
        // 省略了一部分代码...
        
        // 请求forkSystemServer进程
        pid = Zygote.forkSystemServer(
                parsedArgs.mUid, parsedArgs.mGid,
                parsedArgs.mGids,
                parsedArgs.mRuntimeFlags,
                null,
                parsedArgs.mPermittedCapabilities,
                parsedArgs.mEffectiveCapabilities);
    } catch (IllegalArgumentException ex) {
        // 如果捕获到非法参数异常，抛出运行时异常
        throw new RuntimeException(ex);
    }
  
    // 当pid=0时，将去执行handleSystemServerProcess
    if (pid == 0) {
        // 如果存在第二个Zygote，等待它启动
        if (hasSecondZygote(abiList)) {
            waitForSecondaryZygote(socketName);
        }
        
        // 关闭Zygote服务器的套接字
        zygoteServer.closeServerSocket();
        // 返回一个处理SystemServer进程的Runnable
        return handleSystemServerProcess(parsedArgs);
    }
  
    // 对于父进程，返回null
    return null;
}

  调用Zygote.forkSystemServer去创建了一个新进程，并返回pid，而当pid=0时，将去执行handleSystemServerProcess，继续看这个函数的实现

private static Runnable handleSystemServerProcess(ZygoteConnection.Arguments parsedArgs) {
    // 设置umask为0077，这意味着新创建的文件和目录将默认仅对所有者有读写执行权限。
    // ...

    // 从环境变量中获取SYSTEMSERVE的类路径。
    final String systemServerClasspath = Os.getenv("SYSTEMSERVERCLASSPATH");
    if (systemServerClasspath != null) {
        // 如果SYSTEMSERVE类路径不为空，这部分代码可能一些初始化操作。
        // ...
    } else {
        // 如果SYSTEMSERVE类路径为空，则初始化一个类加载器变量为null。
        ClassLoader cl = null;
        // 再次检查SYSTEMSERVE类路径是否不为空，这里看起来有点多余，因为在else分支里，
        if (systemServerClasspath != null) {
            // 如果SYSTEMSERVE类路径不为空，则创建一个路径类加载器，加载SystemServer的类。
            cl = createPathClassLoader(systemServerClasspath, parsedArgs.targetSdkVersion);

            // 设置当前线程的上下文类加载器为刚刚创建的类加载器。
            Thread.currentThread().setContextClassLoader(cl);
        }
 
        /*
         * 将剩余的参数传递给SystemServer。
         */
        // 调用ZygoteInit的zygoteInit方法来初始化SystemServer，传入目标SDK版本，剩余参数和类加载器。
        return ZygoteInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs, cl);
    }
}

实际上调用了ZygoteInit.zygoteInit

public static Runnable zygoteInit(int targetSdkVersion, long[] disabledCompatChanges,
        String[] argv, ClassLoader classLoader) {
    // 如果RuntimeInit类中的DEBUG标志为真，打印一条调试信息到日志中。
    // 这条信息表明从zygote开始启动应用程序。
    if (RuntimeInit.DEBUG) {
        Slog.d(RuntimeInit.TAG, "RuntimeInit: Starting application from zygote");
    }

    // 开始追踪活动管理器相关的Trace（追踪）标签，标记为"ZygoteInit"。
    // 这有助于分析和调试应用程序启动时的性能问题。
    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ZygoteInit");

    // 重定向标准输出流（System.out和System.err）到日志流，这样打印的信息可以通过logcat查看。
    RuntimeInit.redirectLogStreams();

    // 执行一些通用的初始化操作，这些操作对于所有应用程序都是必要的。
    RuntimeInit.commonInit();

    // 调用本地方法nativeZygoteInit，这是一个JNI调用，用于执行一些特定于本地代码的初始化操作。
    ZygoteInit.nativeZygoteInit();

    // 最后，调用RuntimeInit的applicationInit方法，传入目标SDK版本号、禁用的兼容性更改列表、参数数组和类加载器，
    // 这个方法将会完成应用程序的初始化并返回一个Runnable对象，这个对象实际上是SystemServer的入口点。
    return RuntimeInit.applicationInit(targetSdkVersion, disabledCompatChanges, argv, classLoader);
}

  用于初始化SystemServer进程。它首先检查是否开启了调试模式，如果是，则记录启动信息。接着，它开始Trace追踪，这对于后续分析性能是有帮助的。然后，它会重定向日志流，执行一些通用初始化操作，并调用本地方法进行特定的初始化。最后，它调用RuntimeInit.applicationInit方法来完成SystemServer进程的初始化，并返回一个可执行的Runnable对象。

protected static Runnable applicationInit(int targetSdkVersion, long[] disabledCompatChanges,
        String[] argv, ClassLoader classLoader) {
    nativeSetExitWithoutCleanup(true);

    VMRuntime.getRuntime().setTargetSdkVersion(targetSdkVersion);
    VMRuntime.getRuntime().setDisabledCompatChanges(disabledCompatChanges);

    final Arguments args = new Arguments(argv);

    // The end of of the RuntimeInit event (see #zygoteInit).
    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);

    // Remaining arguments are passed to the start class's static main
    return findStaticMain(args.startClass, args.startArgs, classLoader);
}

protected static Runnable findStaticMain(String className, String[] argv,
        ClassLoader classLoader) {
    Class<?> cl;

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

    Method m;
    try {
        //通过反射获取SystemServer的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();
    if (! (Modifier.isStatic(modifiers) && Modifier.isPublic(modifiers))) {
        throw new RuntimeException(
                "Main method is not public and static on " + className);
    }
    //反射调用main方法
    return new MethodAndArgsCaller(m, argv);
}

SystemServer流程入口

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

public SystemServer() {
    // 检查系统是否处于工厂测试模式
    mFactoryTestMode = FactoryTest.getMode();

    // 记录系统启动的次数
    mStartCount = SystemProperties.getInt(SYSPROP_START_COUNT, 0) + 1;
    // 这两行代码记录了系统的实际启动时间和系统的运行时间。
    mRuntimeStartElapsedTime = SystemClock.elapsedRealtime();
    mRuntimeStartUptime = SystemClock.uptimeMillis();
    // 设置了进程的启动时间
    Process.setStartTimes(mRuntimeStartElapsedTime, mRuntimeStartUptime,
            mRuntimeStartElapsedTime, mRuntimeStartUptime);

    // 用于确定系统是否处于运行时重启状态
    mRuntimeRestart = mStartCount > 1;
}

  在 SystemServer 类初始化时，它执行了一些重要的操作，记录了系统启动的次数、启动的时间以及是否是运行时重启或者重新启动。

    private void run() {
        // 创建一个用于记录时间和日志的对象
        TimingsTraceAndSlog t = new TimingsTraceAndSlog();
        try {
            // 开始追踪"初始化服务之前"的部分
            t.traceBegin("InitBeforeStartServices");

            // 设置一些系统属性，记录系统启动次数、启动经过的时间等信息
            SystemProperties.set(SYSPROP_START_COUNT, String.valueOf(mStartCount));
            SystemProperties.set(SYSPROP_START_ELAPSED, String.valueOf(mRuntimeStartElapsedTime));
            SystemProperties.set(SYSPROP_START_UPTIME, String.valueOf(mRuntimeStartUptime));

            // 写入系统启动事件日志
            EventLog.writeEvent(EventLogTags.SYSTEM_SERVER_START, mStartCount, mRuntimeStartUptime, mRuntimeStartElapsedTime);

            // 如果需要，初始化系统时区设置
            SystemTimeZone.initializeTimeZoneSettingsIfRequired();

            // 如果系统语言属性被设置，则将其转换为相应的语言标签，并清除相关的系统属性
            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", "");
            }
            ...
            // 记录进入Android SystemServer的日志
            Slog.i(TAG, "Entered the Android system server!");
            // 记录系统启动时间，并写入事件日志
            final long uptimeMillis = SystemClock.elapsedRealtime();
            EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_SYSTEM_RUN, uptimeMillis);
            // 如果不是重新启动，记录SystemServer初始化开始的时间
            if (!mRuntimeRestart) {
                FrameworkStatsLog.write(FrameworkStatsLog.BOOT_TIME_EVENT_ELAPSED_TIME_REPORTED, FrameworkStatsLog.BOOT_TIME_EVENT_ELAPSED_TIME__EVENT__SYSTEM_SERVER_INIT_START, uptimeMillis);
            }
            ...

            // 初始化Zygote启动参数
            ZygoteInit.preload(new TimingsTraceLog("ZygoteInit", Trace.TRACE_TAG_SYSTEM_SERVER));
            ...

            // 开始启动服务。
            try {
                // 开始追踪"启动服务"的部分
                t.traceBegin("StartServices");

                // 启动引导服务
                startBootstrapServices(t);
                // 启动核心服务
                startCoreServices(t);
                // 启动其他服务
                startOtherServices(t);
                // 启动Apex服务
                startApexServices(t);

                // 在启动所有服务后更新看门狗超时设置
                // 以便在启动SystemServer时使用默认超时
                updateWatchdogTimeout(t);
            } catch (Throwable ex) {
                // 如果启动服务时发生异常，记录错误并抛出异常
                Slog.e("System", "******************************************");
                Slog.e("System", "************ Failure starting system services", ex);
                throw ex;
            } finally {
                // 结束追踪"启动服务"的部分
                t.traceEnd(); // StartServices
            }
            ...
            // 如果不是运行时重启且不是首次启动或升级，则记录SystemServer器就绪的时间
            if (!mRuntimeRestart && !isFirstBootOrUpgrade()) {
                final long uptimeMillis = SystemClock.elapsedRealtime();
                FrameworkStatsLog.write(FrameworkStatsLog.BOOT_TIME_EVENT_ELAPSED_TIME_REPORTED, FrameworkStatsLog.BOOT_TIME_EVENT_ELAPSED_TIME__EVENT__SYSTEM_SERVER_READY, uptimeMillis);
                // 设定SystemServer启动的最大允许时间
                final long maxUptimeMillis = 60 * 1000;
                // 如果SystemServer初始化时间过长，记录警告信息
                if (uptimeMillis > maxUptimeMillis) {
                    Slog.wtf(SYSTEM_SERVER_TIMING_TAG, "SystemServer init took too long. uptimeMillis=" + uptimeMillis);
                }
            }

            // 进入消息循环，SystemServer主线程将一直运行
            Looper.loop();
            // 如果消息循环意外退出，则抛出异常
            throw new RuntimeException("Main thread loop unexpectedly exited");
        }
    }

  这段代码是AndroidSystemServer的启动流程的核心部分，负责初始化和启动系统级服务。代码中包含了服务的启动顺序、异常处理、性能追踪、严格模式设置、系统启动时间记录等关键步骤。在完成所有服务的启动后，SystemServer进入一个无限循环，等待处理消息。如果循环意外退出，则会抛出一个运行时异常。

启动核心服务

            // 开始启动服务。
            try {
                // 开始追踪"启动服务"的部分
                t.traceBegin("StartServices");

                // 启动引导服务
                startBootstrapServices(t);
                // 启动核心服务
                startCoreServices(t);
                // 启动其他服务
                startOtherServices(t);
                // 启动Apex服务
                startApexServices(t);

                // 在启动所有服务后更新看门狗超时设置
                // 以便在启动SystemServer时使用默认超时
                updateWatchdogTimeout(t);
            } catch (Throwable ex) {
                // 如果启动服务时发生异常，记录错误并抛出异常
                Slog.e("System", "******************************************");
                Slog.e("System", "************ Failure starting system services", ex);
                throw ex;
            } finally {
                // 结束追踪"启动服务"的部分
                t.traceEnd(); // StartServices
            }

private void startBootstrapServices(@NonNull TimingsTraceAndSlog t) {
    // 初始化 ArtModuleServiceManager
    ArtModuleServiceInitializer.setArtModuleServiceManager(new ArtModuleServiceManager());

    // 启动 Watchdog
    final Watchdog watchdog = Watchdog.getInstance();
    watchdog.start();
    mDumper.addDumpable(watchdog);

    // 读取系统配置
    Slog.i(TAG, "Reading configuration...");
    final String TAG_SYSTEM_CONFIG = "ReadingSystemConfig";
    SystemServerInitThreadPool.submit(SystemConfig::getInstance, TAG_SYSTEM_CONFIG);

    // 初始化平台兼容性服务
    PlatformCompat platformCompat = new PlatformCompat(mSystemContext);
    ServiceManager.addService(Context.PLATFORM_COMPAT_SERVICE, platformCompat);
    ServiceManager.addService(Context.PLATFORM_COMPAT_NATIVE_SERVICE, new PlatformCompatNative(platformCompat));
    AppCompatCallbacks.install(new long[0]);

    // 启动文件完整性服务
    mSystemServiceManager.startService(FileIntegrityService.class);

    // 启动安装服务
    Installer installer = mSystemServiceManager.startService(Installer.class);

    // 启动设备标识策略服务
    mSystemServiceManager.startService(DeviceIdentifiersPolicyService.class);

    // 启动 UriGrantsManagerService
    mSystemServiceManager.startService(UriGrantsManagerService.Lifecycle.class);

    // 启动 PowerStatsService
    mSystemServiceManager.startService(PowerStatsService.class);

    // 启动 IStatsService
    startIStatsService();

    // 启动 MemtrackProxyService
    startMemtrackProxyService();

    // 启动访问检查服务
    mSystemServiceManager.startService(AccessCheckingService.class);

    // 启动 ActivityTaskManagerService
    ActivityTaskManagerService atm = mSystemServiceManager.startService(ActivityTaskManagerService.Lifecycle.class).getService();
    // 启动 ActivityManagerService 
    mActivityManagerService = ActivityManagerService.Lifecycle.startService(mSystemServiceManager, atm);
    mActivityManagerService.setSystemServiceManager(mSystemServiceManager);
    mActivityManagerService.setInstaller(installer);
    mWindowManagerGlobalLock = atm.getGlobalLock();

    // 启动 DataLoaderManagerService
    mDataLoaderManagerService = mSystemServiceManager.startService(DataLoaderManagerService.class);

    // 启动增量服务
    mIncrementalServiceHandle = startIncrementalService();

    // 启动 PowerManagerService
    mPowerManagerService = mSystemServiceManager.startService(PowerManagerService.class);

    // 启动 ThermalManagerService
    mSystemServiceManager.startService(ThermalManagerService.class);

    // 启动 HintManagerService
    mSystemServiceManager.startService(HintManagerService.class);

    // 初始化活动管理服务的电源管理
    mActivityManagerService.initPowerManagement();
    ...
    // 启动 RecoverySystemService
    mSystemServiceManager.startService(RecoverySystemService.Lifecycle.class);

    // 如果启用了显示卸载功能，则启动 DisplayOffloadService
    if (SystemProperties.getBoolean("config.enable_display_offload", false)) {
        mSystemServiceManager.startService(WEAR_DISPLAYOFFLOAD_SERVICE_CLASS);
    }

    // 如果启用了辅助图形功能，则启动 SidekickService
    if (SystemProperties.getBoolean("config.enable_sidekick_graphics", false)) {
        mSystemServiceManager.startService(WEAR_SIDEKICK_SERVICE_CLASS);
    }

    // 启动 DisplayManagerService
    mDisplayManagerService = mSystemServiceManager.startService(DisplayManagerService.class);

    // 启动系统服务等待默认显示
    mSystemServiceManager.startBootPhase(t, SystemService.PHASE_WAIT_FOR_DEFAULT_DISPLAY);
	if (!mRuntimeRestart) {
    // 如果不是运行时重启，则记录包管理器初始化开始的事件
    FrameworkStatsLog.write(FrameworkStatsLog.BOOT_TIME_EVENT_ELAPSED_TIME_REPORTED,
            FrameworkStatsLog.BOOT_TIME_EVENT_ELAPSED_TIME__EVENT__PACKAGE_MANAGER_INIT_START,
            SystemClock.elapsedRealtime());
	}

	// 创建域验证服务
	DomainVerificationService domainVerificationService = new DomainVerificationService(
        mSystemContext, SystemConfig.getInstance(), platformCompat);
	// 启动域验证服务
	mSystemServiceManager.startService(domainVerificationService);

	try {
    	// 暂停看门狗监视当前线程，用于包管理器主线程
    	Watchdog.getInstance().pauseWatchingCurrentThread("packagemanagermain");
    	// 初始化包管理器服务
    	mPackageManagerService = PackageManagerService.main(
            mSystemContext, installer, domainVerificationService,
            mFactoryTestMode != FactoryTest.FACTORY_TEST_OFF);
	} finally {
    	// 恢复看门狗监视当前线程，用于包管理器主线程
    	Watchdog.getInstance().resumeWatchingCurrentThread("packagemanagermain");
	}

	// 检查是否是首次启动
	mFirstBoot = mPackageManagerService.isFirstBoot();
	// 获取包管理器
	mPackageManager = mSystemContext.getPackageManager();

	// 添加 DexUseManagerLocal 实例到本地管理器注册表
	LocalManagerRegistry.addManager(
        DexUseManagerLocal.class, DexUseManagerLocal.createInstance(mSystemContext));

	if (!mRuntimeRestart && !isFirstBootOrUpgrade()) {
    	// 如果不是运行时重启且不是首次启动或升级，则记录包管理器初始化完成的事件
    	FrameworkStatsLog.write(FrameworkStatsLog.BOOT_TIME_EVENT_ELAPSED_TIME_REPORTED,
            FrameworkStatsLog.BOOT_TIME_EVENT_ELAPSED_TIME__EVENT__PACKAGE_MANAGER_INIT_READY,
            SystemClock.elapsedRealtime());
	}

	// 检查是否禁用 OTA DexOpt
	boolean disableOtaDexopt = SystemProperties.getBoolean("config.disable_otadexopt", 	false);
	if (!disableOtaDexopt) {
    	try {
        	// 暂停看门狗监视当前线程，用于执行移动应用的线程
        	Watchdog.getInstance().pauseWatchingCurrentThread("moveab");
        	// 启动 OTA DexOpt 服务
        	OtaDexoptService.main(mSystemContext, mPackageManagerService);
    	} catch (Throwable e) {
        	// 报告异常情况
        	reportWtf("starting OtaDexOptService", e);
    	} finally {
        	// 恢复看门狗监视当前线程，用于执行移动应用的线程
        	Watchdog.getInstance().resumeWatchingCurrentThread("moveab");
 	   }
	}

	// 启动用户管理服务
	mSystemServiceManager.startService(UserManagerService.LifeCycle.class);

	// 初始化属性缓存
	AttributeCache.init(mSystemContext);

	// 设置活动管理服务为系统进程
	mActivityManagerService.setSystemProcess();
	// 注册包接收器
	platformCompat.registerPackageReceiver(mSystemContext);
	watchdog.init(mSystemContext, mActivityManagerService);
	// 设置显示管理服务的调度策略
	mDisplayManagerService.setupSchedulerPolicies();

	// 启动叠加管理服务
	mSystemServiceManager.startService(new OverlayManagerService(mSystemContext));

	// 创建资源管理服务
	ResourcesManagerService resourcesService = new ResourcesManagerService(mSystemContext);
	// 设置活动管理服务
	resourcesService.setActivityManagerService(mActivityManagerService);
	// 启动资源管理服务
	mSystemServiceManager.startService(resourcesService);

	// 启动传感器隐私服务
	mSystemServiceManager.startService(new SensorPrivacyService(mSystemContext));

	// 如果系统属性中定义了顶部显示插入值大于0，则更新系统 UI 上下文并通知显示管理服务
	if (SystemProperties.getInt("persist.sys.displayinset.top", 0) > 0) {
    	mActivityManagerService.updateSystemUiContext();
    	LocalServices.getService(DisplayManagerInternal.class).onOverlayChanged();
	}

	// 启动传感器服务
	mSystemServiceManager.startService(SensorService.class);

启动了一系列Service，常见的AMS和ATMS和SensorService，WatchDog都是在这里启动的。