Android系统启动-综述—1

Posted hellokitty2

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Android系统启动-综述—1相关的知识,希望对你有一定的参考价值。

基于-Android 6.0

一、概述

Android 系统底层基于Linux Kernel, 当 Kernel 启动过程会创建 init 进程, 该进程是所有用户空间的鼻祖, init 进程会启动 servicemanager(binder服务管家), Zygote 进程(Java进程的鼻祖). Zygote 进程会创建 system_server 进程以及各种app进程,下图是这几个系统重量级进程之间的层级关系。

二、init

init 是 Linux 系统中用户空间的第一个进程(pid=1), Kernel 启动后会调用 /system/core/init/Init.cpp 的 main() 方法。

2.1 Init.main

int main(int argc, char** argv) 
    ...
    klog_init();  //初始化kernel log
    property_init(); //创建一块共享的内存空间,用于属性服务
    signal_handler_init();  //初始化子进程退出的信号处理过程

    property_load_boot_defaults(); //加载/default.prop文件
    start_property_service();   //启动属性服务器(通过socket通信)
    init_parse_config_file("/init.rc"); //解析init.rc文件

    //执行rc文件中触发器为 on early-init的语句
    action_for_each_trigger("early-init", action_add_queue_tail);
    //执行rc文件中触发器为 on init的语句
    action_for_each_trigger("init", action_add_queue_tail);
    //执行rc文件中触发器为 on late-init的语句
    action_for_each_trigger("late-init", action_add_queue_tail);

    while (true) 
        if (!waiting_for_exec) 
            execute_one_command();
            restart_processes();
        
        int timeout = -1;
        if (process_needs_restart) 
            timeout = (process_needs_restart - gettime()) * 1000;
            if (timeout < 0)
                timeout = 0;
        
        if (!action_queue_empty() || cur_action) 
            timeout = 0;
        

        epoll_event ev;
        //循环 等待事件发生
        int nr = TEMP_FAILURE_RETRY(epoll_wait(epoll_fd, &ev, 1, timeout));
        if (nr == -1) 
            ERROR("epoll_wait failed: %s\\n", strerror(errno));
         else if (nr == 1) 
            ((void (*)()) ev.data.ptr)();
        
    
    return 0;


init进程的主要功能点:

(1) 分析和运行所有的 init.rc 文件; 
(2) 生成设备驱动节点;(通过rc文件创建)
(3) 处理子进程的终止(signal 方式);
(4) 提供属性服务 property service。


2.2 Zygote自动重启机制

当 init 解析到下面这条语句,便会启动 Zygote 进程

service zygote /system/bin/app_process -Xzygote /system/bin --zygote --start-system-server
    class main                            //伴随着main class的启动而启动  TODO:??
    socket zygote stream 660 root system  //创建socket
    onrestart write /sys/android_power/request_state wake
    onrestart write /sys/power/state on
    onrestart restart media               //当zygote重启时,则会重启media
    onrestart restart netd                //当zygote重启时,则会重启netd

当 init 子进程(Zygote)退出时,会产生 SIGCHLD 信号,并发送给 init 进程,通过 socket 套接字传递数据,调用到 wait_for_one_process()方法,根据是否是 oneshot,来决定是重启子进程,还是放弃启动。由于缺省模式 oneshot=false,因此 Zygote 一旦被杀便会再次由init进程拉起。

 

接下来,便是进入了Zygote进程.


三、Zygote

当 Zygote 进程启动后, 便会执行到 frameworks/base/cmds/app_process/App_main.cpp 文件的 main()方法。整个调用流程:

App_main.main
    AndroidRuntime.start
        AndroidRuntime.startVm
        AndroidRuntime.startReg
        ZygoteInit.main (首次进入Java世界)
            registerZygoteSocket
            preload
            startSystemServer
            runSelectLoop

3.1 App_main.main

int main(int argc, char* const argv[])

    AppRuntime runtime(argv[0], computeArgBlockSize(argc, argv));
    while (i < argc) 
        ...//参数解析
    

    //设置进程名
    if (!niceName.isEmpty()) 
        runtime.setArgv0(niceName.string());
        set_process_name(niceName.string());
    

    if (zygote) 
        // 启动AppRuntime,见小节[3.2]
        runtime.start("com.android.internal.os.ZygoteInit", args, zygote); //TODO: 怎么启动的?
     else if (className) 
        runtime.start("com.android.internal.os.RuntimeInit", args, zygote);
    

在 app_process 进程启动过程,有两个分支://TODO: 区别是啥?

(1) 当 zygote 为 true 时,则执行 ZygoteInit.main()
(2) 当 zygote 为 false 时,则执行 RuntimeInit.main()


3.2 AndroidRuntime::start

[-> AndroidRuntime.cpp]

void AndroidRuntime::start(const char* className, const Vector<String8>& options)

    ...
    // 虚拟机创建
    if (startVm(&mJavaVM, &env, zygote) != 0) 
        return;
    
    onVmCreated(env);

    // JNI方法注册
    if (startReg(env) < 0) 
        return;
    
    ...
    // 调用 ZygoteInit.main()方法[见小节3.3]
    env->CallStaticVoidMethod(startClass, startMeth, strArray);


3.3 ZygoteInit.main

[–>ZygoteInit.java]

public static void main(String argv[]) 
    try 
        ...
        registerZygoteSocket(socketName); //为 Zygote 注册 socket
        preload(); //预加载类和资源[见小节3.4]
        ...
        if (startSystemServer) 
            startSystemServer(abiList, socketName);//启动 system_server [见小节3.5]
        
        Log.i(TAG, "Accepting command socket connections");
        runSelectLoop(abiList); //进入循环模式[见小节3.6]
        ...
     catch (MethodAndArgsCaller caller) 
        caller.run(); //启动system_server中会讲到。
    
    ...


3.4 ZygoteInit.preload

[–>ZygoteInit.java]

static void preload() 
    Log.d(TAG, "begin preload");
    preloadClasses();
    preloadResources();
    preloadOpenGL();
    preloadSharedLibraries();
    WebViewFactory.prepareWebViewInZygote();
    Log.d(TAG, "end preload");


3.5 ZygoteInit.startSystemServer

[–>ZygoteInit.java]

private static boolean startSystemServer(String abiList, String socketName)
        throws MethodAndArgsCaller, RuntimeException 
    ...

    // fork 子进程 system_server
    pid = Zygote.forkSystemServer(
            parsedArgs.uid, parsedArgs.gid,
            parsedArgs.gids,
            parsedArgs.debugFlags,
            null,
            parsedArgs.permittedCapabilities,
            parsedArgs.effectiveCapabilities);
    ...

    if (pid == 0) 
        if (hasSecondZygote(abiList)) 
            waitForSecondaryZygote(socketName);
        
        //进入 system_server 进程[见小节4.1]
        handleSystemServerProcess(parsedArgs);
    
    return true;


3.6 ZygoteInit.runSelectLoop

[–>ZygoteInit.java]

private static void runSelectLoop(String abiList) throws MethodAndArgsCaller 
    ArrayList<FileDescriptor> fds = new ArrayList<FileDescriptor>();
    ArrayList<ZygoteConnection> peers = new ArrayList<ZygoteConnection>();

    //sServerSocket 是 socket 通信中的服务端,即 zygote 进程
    fds.add(sServerSocket.getFileDescriptor());
    peers.add(null);

    while (true) 
        StructPollfd[] pollFds = new StructPollfd[fds.size()];
        for (int i = 0; i < pollFds.length; ++i) 
            pollFds[i] = new StructPollfd();
            pollFds[i].fd = fds.get(i);
            pollFds[i].events = (short) POLLIN;
        
        ...
        Os.poll(pollFds, -1);

        for (int i = pollFds.length - 1; i >= 0; --i) 
            //采用I/O多路复用机制,当客户端发出连接请求或者数据处理请求时,则执行 continue
            if ((pollFds[i].revents & POLLIN) == 0) 
                continue;
            
            if (i == 0) 
                //创建客户端连接
                ZygoteConnection newPeer = acceptCommandPeer(abiList);
                peers.add(newPeer);
                fds.add(newPeer.getFileDesciptor());
             else 
                //处理客户端数据事务
                boolean done = peers.get(i).runOnce();
                if (done) 
                    peers.remove(i);
                    fds.remove(i);
                
            
        
    

Zygote 进程创建 Java 虚拟机,并注册JNI方法,真正成为Java进程的母体,用于孵化Java进程. 在创建完 system_server 进程后,zygote 功成身退,调用 runSelectLoop(),随时待命,当接收到请求创建新进程请求时立即唤醒并执行相应工作。


四、system_server

Zygote 通过 fork 后创建 system_server 进程,在小节[3.5]执行完 startSystemServer() 方法后,进入到了 handleSystemServerProcess() 方法,如下所示。

4.1 handleSystemServerProcess

[–>ZygoteInit.java]

private static void handleSystemServerProcess( ZygoteConnection.Arguments parsedArgs) 
    throws ZygoteInit.MethodAndArgsCaller 
    ...
    if (parsedArgs.niceName != null) 
         //设置当前进程名为"system_server"  #######
        Process.setArgV0(parsedArgs.niceName);
    

    final String systemServerClasspath = Os.getenv("SYSTEMSERVERCLASSPATH");
    if (systemServerClasspath != null) 
        //执行dex优化操作,比如 services.jar
        performSystemServerDexOpt(systemServerClasspath);
    

    if (parsedArgs.invokeWith != null) 
        ...
     else 
        ClassLoader cl = null;
        if (systemServerClasspath != null) 
            cl = new PathClassLoader(systemServerClasspath, ClassLoader.getSystemClassLoader());
            Thread.currentThread().setContextClassLoader(cl);
        
        //[见小节4.2]
        RuntimeInit.zygoteInit(parsedArgs.targetSdkVersion, parsedArgs.remainingArgs, cl);
    

system_server 进程创建 PathClassLoader 类加载器。

4.2 RuntimeInit.zygoteInit

[–> RuntimeInit.java]

public static final void zygoteInit(int targetSdkVersion, String[] argv, ClassLoader classLoader) 
    throws ZygoteInit.MethodAndArgsCaller 

    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "RuntimeInit");
    redirectLogStreams(); //重定向log输出

    commonInit(); //通用的一些初始化
    nativeZygoteInit(); //zygote 初始化
    applicationInit(targetSdkVersion, argv, classLoader); // [见小节3.4]


Binder线程池启动

nativeZygoteInit() 方法经过层层调用,会进入 app_main.cpp 中的 onZygoteInit() 方法, Binder线程池的创建也是在这个过程,如下:

virtual void onZygoteInit() 
    sp<ProcessState> proc = ProcessState::self();
    proc->startThreadPool(); //启动新binder线程池


捕获特殊异常

applicationInit() 方法经过层层调用,会抛出异常 ZygoteInit.MethodAndArgsCaller(m, argv), 具体过程如下:

protected static Runnable applicationInit(int targetSdkVersion, String[] argv,
        ClassLoader classLoader) 
    ...
    VMRuntime.getRuntime().setTargetHeapUtilization(0.75f);
    VMRuntime.getRuntime().setTargetSdkVersion(targetSdkVersion);
    final Arguments args = new Arguments(argv);
    //找到目标类的静态 main()方法
    invokeStaticMain(args.startClass, args.startArgs, classLoader);


private static void invokeStaticMain(String className, String[] argv, ClassLoader classLoader)
            throws ZygoteInit.MethodAndArgsCaller 
    //此处的 className 等于 SystemServer
    Class<?> cl = Class.forName(className, true, classLoader);
    Method  m = cl.getMethod("main", new Class[]  String[].class ); //TODO: 参数2是什么意思?
    //抛出异常 Runnable 对象
    throw new ZygoteInit.MethodAndArgsCaller(m, argv);

设置虚拟机的堆利用率 0.75 和置 TargetSdk 版本;并抛出异常,然后由 ZygoteInit.main() 捕获该异常, 见下文

4.3 ZygoteInit.main

[–>ZygoteInit.java]

public static void main(String argv[]) 
    try 
        startSystemServer(abiList, socketName); //抛出 MethodAndArgsCaller 异常
        ....
     catch (MethodAndArgsCaller caller) 
        caller.run(); //此处通过反射,会调用 SystemServer.main() 方法 [见小节4.4]
     catch (RuntimeException ex) 
        ...
    


static class MethodAndArgsCaller implements Runnable 
    private final Method mMethod;
    private final String[] mArgs;

    public MethodAndArgsCaller(Method method, String[] args) 
        mMethod = method;
        mArgs = args;
    

    public void run() 
        //执行 SystemServer.main()
        mMethod.invoke(null, new Object[]  mArgs ); //TODO: 参数2是什么意思?
    


采用抛出异常的方式,用于栈帧清空,提供利用率,以至于现在大家看到的每个Java进程的调用栈如下:

    ...
    at com.android.server.SystemServer.main(SystemServer.java:175)
    at java.lang.reflect.Method.invoke!(Native method)
    at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:738)
    at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:628)


4.4 SystemServer.main

[–>SystemServer.java]

public final class SystemServer 
    ...
    public static void main(String[] args) 
        //先初始化 SystemServer 对象,再调用对象的 run() 方法
        new SystemServer().run();
    


4.5 SystemServer.run

[–>SystemServer.java]

private void run() 
    if (System.currentTimeMillis() < EARLIEST_SUPPORTED_TIME) 
        Slog.w(TAG, "System clock is before 1970; setting to 1970.");
        SystemClock.setCurrentTimeMillis(EARLIEST_SUPPORTED_TIME);
    
    ...

    Slog.i(TAG, "Entered the Android system server!");
    EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_SYSTEM_RUN, SystemClock.uptimeMillis());
    Looper.prepareMainLooper(); //准备主线程looper

    //加载 android_servers.so 库,该库包含的源码在 frameworks/base/services/ 目录下 //TODO: 这个库是什么作用?
    System.loadLibrary("android_servers");

    //检测上次关机过程是否失败,该方法可能不会返回
    performPendingShutdown();
    createSystemContext(); //初始化系统上下文

    //创建系统服务管理
    mSystemServiceManager = new SystemServiceManager(mSystemContext);
    LocalServices.addService(SystemServiceManager.class, mSystemServiceManager);

    //启动各种系统服务
    try 
        startBootstrapServices(); // 启动引导服务
        startCoreServices();      // 启动核心服务
        startOtherServices();     // 启动其他服务[见小节4.6]
     catch (Throwable ex) 
        Slog.e("System", "************ Failure starting system services", ex);
        throw ex;
    

    //一直循环执行
    Looper.loop();
    throw new RuntimeException("Main thread loop unexpectedly exited");


4.6 服务启动

public final class SystemServer 
    private void startBootstrapServices() 
      ...
      //phase100
      mSystemServiceManager.startBootPhase(SystemService.PHASE_WAIT_FOR_DEFAULT_DISPLAY);
      ...
    

    private void startOtherServices() 
        ...
        //phase480 和phase500
        mSystemServiceManager.startBootPhase(SystemService.PHASE_LOCK_SETTINGS_READY);
        mSystemServiceManager.startBootPhase(SystemService.PHASE_SYSTEM_SERVICES_READY);
        ...
        //[见小节4.7]
        mActivityManagerService.systemReady(new Runnable() 
           @Override
           public void run() 
               //phase550
               mSystemServiceManager.startBootPhase(SystemService.PHASE_ACTIVITY_MANAGER_READY);
               ...
               //phase600
               mSystemServiceManager.startBootPhase(SystemService.PHASE_THIRD_PARTY_APPS_CAN_START);
            
        
    


start: 创建 AMS, PMS, LightsService, DMS.
phase100: 进入 Phase100, 创建 PKMS, WMS, IMS, DBMS, LockSettingsService, JobSchedulerService, MmsService 等服务;
phase480 && 500: 进入 Phase480, 调用 WMS, PMS, PKMS, DisplayManagerService 这4个服务的 systemReady(); #######
Phase550: 进入 phase550, 执行 AMS.systemReady(), 启动 SystemUI, WebViewFactory, Watchdog.
Phase600: 进入 phase600, 执行 AMS.systemReady(), 执行各种服务的 systemRunning().
Phase1000: 进入1000, 执行 finishBooting, 启动启动 on-hold 进程. //TODO: 什么是 on-hold 进程?

4.7 AMS.systemReady

public final class ActivityManagerService extends ActivityManagerNative implements Watchdog.Monitor,
    BatteryStatsImpl.BatteryCallback 

    public void systemReady(final Runnable goingCallback) 
        ... //update相关
        mSystemReady = true;

        //杀掉所有非 persistent 进程
        removeProcessLocked(proc, true, false, "system update done");
        mProcessesReady = true;

        goingCallback.run();  //[见小节1.6.2]

        addAppLocked(info, false, null); //启动所有的 persistent 进程
        mBooting = true;

        //启动 home ##########
        startHomeActivityLocked(mCurrentUserId, "systemReady");
        //恢复栈顶的 Activity
        mStackSupervisor.resumeTopActivitiesLocked();
    


System_server 主线程的启动工作,总算完成,进入 Looper.loop() 状态,等待其他线程通过 handler 发送消息再处理。


五、app

对于普通的 app 进程,跟 system_server 进程的启动过来有些类似。不同的是 app 进程是发消息给 system_server 进程, 由 system_server 向 zygote 发出创建进程的请求。

理解Android进程创建流程,可知进程创建后,接下来会进入 ActivityThread.main() 过程。

5.1 ActivityThread.main

public static void main(String[] args) 
    ...
    Environment.initForCurrentUser();
    ...
    Process.setArgV0("<pre-initialized>");
    //创建主线程looper
    Looper.prepareMainLooper();

    ActivityThread thread = new ActivityThread();
    thread.attach(false); //attach到系统进程

    if (sMainThreadHandler == null) 
        sMainThreadHandler = thread.getHandler();
    

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


5.2 调用栈对比

App进程的主线程调用栈的栈底如下:

    ...
    at android.app.ActivityThread.main(ActivityThread.java:5442)
    at java.lang.reflect.Method.invoke!(Native method)
    at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:738)
    at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:628)

跟前面介绍的system_server进程调用栈对比:

    at com.android.server.SystemServer.main(SystemServer.java:175)
    at java.lang.reflect.Method.invoke!(Native method)
    at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:738)
    at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:628)

 

六、启动日志分析

以下列举启动部分重要进程以及关键节点会打印出的log

/system/bin/vold: 383
/system/bin/lmkd: 432
/system/bin/surfaceflinger: 434
/system/bin/debuggerd64: 537
/system/bin/mediaserver: 540
/system/bin/installd: 541
/system/vendor/bin/thermal-engine: 552

zygote64: 557
zygote: 558
system_server: 1274


6.1 before zygote 日志

//启动vold, 再列举当前系统所支持的文件系统.  执行到system/vold/main.cpp的main()
11-23 14:36:47.474   383   383 I vold    : Vold 3.0 (the awakening) firing up  
11-23 14:36:47.475   383   383 V vold    : Detected support for: ext4 vfat   
//使用内核的lmk策略
11-23 14:36:47.927   432   432 I lowmemorykiller: Using in-kernel low memory killer interface
//启动SurfaceFlinger
11-23 14:36:48.041   434   434 I SurfaceFlinger: SurfaceFlinger is starting
11-23 14:36:48.042   434   434 I SurfaceFlinger: SurfaceFlinger\'s main thread ready to run. Initializing graphics H/W...
// 开机动画
11-23 14:36:48.583   508   508 I BootAnimation: bootanimation launching ...
// debuggerd
11-23 14:36:50.306   537   537 I         : debuggerd: starting
// installd启动
11-23 14:36:50.311   541   541 I installd: installd firing up
// thermal守护进程
11-23 14:36:50.369   552   552 I ThermalEngine: Thermal daemon started


6.2 zygote 日志

// Zygote64进程(Zygote):  AndroidRuntime::start
11-23 14:36:51.260   557   557 D AndroidRuntime: >>>>>> START com.android.internal.os.ZygoteInit uid 0 <<<<<<
// Zygote64进程:  AndroidRuntime::startVm
11-23 14:36:51.304   557   557 D AndroidRuntime: CheckJNI is OFF

// 执行ZygoteInit.preload()
11-23 14:36:52.134   557   557 D Zygote  : begin preload
// 执行ZygoteInit.preloadClasses(), 预加载3860个classes, 花费时长746ms
11-23 14:36:52.134   557   557 I Zygote  : Preloading classes...
11-23 14:36:52.881   557   557 I Zygote  : ...preloaded 3860 classes in 746ms.

// 执行ZygoteInit.preloadClasses(), 预加载86组资源, 花费时长179ms
11-23 14:36:53.114   557   557 I Zygote  : Preloading resources...
11-23 14:36:53.293   557   557 I Zygote  : ...preloaded 86 resources in 179ms.

// 执行ZygoteInit.preloadSharedLibraries()
11-23 14:36:53.494   557   557 I Zygote  : Preloading shared libraries...
11-23 14:36:53.503   557   557 D Zygote  : end preload

// 执行com_android_internal_os_Zygote_nativeForkSystemServer(),成功fork出system_server进程
11-23 14:36:53.544   557   557 I Zygote  : System server process 1274 has been created
// Zygote开始进入runSelectLoop()
11-23 14:36:53.546   557   557 I Zygote  : Accepting command socket connections


6.3 system_server 日志

//进入system_server, 建立跟Zygote进程的socket通道
11-23 14:36:53.586  1274  1274 I Zygote  : Process: zygote socket opened, supported ABIS: armeabi-v7a,armeabi
// 执行SystemServer.run()
11-23 14:36:53.618  1274  1274 I SystemServer: Entered the Android system server!   <===> boot_progress_system_run
// 等待installd准备就绪
11-23 14:36:53.707  1274  1274 I Installer: Waiting for installd to be ready.

//服务启动
11-23 14:36:53.732  1274  1274 I ActivityManager: Memory class: 192

//phase100
11-23 14:36:53.883  1274  1274 I SystemServiceManager: Starting phase 100
11-23 14:36:53.902  1274  1274 I SystemServer: Package Manager
11-23 14:37:03.816  1274  1274 I SystemServer: User Service
...
11-23 14:37:03.940  1274  1274 I SystemServer: Init Watchdog
11-23 14:37:03.941  1274  1274 I SystemServer: Input Manager
11-23 14:37:03.946  1274  1274 I SystemServer: Window Manager
...
11-23 14:37:04.081  1274  1274 I SystemServiceManager: Starting com.android.server.MountService$Lifecycle
11-23 14:37:04.088  1274  2717 D MountService: Thinking about reset, mSystemReady=false, mDaemonConnected=true
11-23 14:37:04.088  1274  1274 I SystemServiceManager: Starting com.android.server.UiModeManagerService
11-23 14:37:04.520  1274  1274 I SystemServer: NetworkTimeUpdateService

//phase480 && 500
11-23 14:37:05.056  1274  1274 I SystemServiceManager: Starting phase 480
11-23 14:37:05.061  1274  1274 I SystemServiceManager: Starting phase 500
11-23 14:37:05.231  1274  1274 I ActivityManager: System now ready  <==> boot_progress_ams_ready
11-23 14:37:05.234  1274  1274 I SystemServer: Making services ready
11-23 14:37:05.243  1274  1274 I SystemServer: WebViewFactory preparation

//phase550
11-23 14:37:05.234  1274  1274 I SystemServiceManager: Starting phase 550
11-23 14:37:05.237  1274  1288 I ActivityManager: Force stopping com.android.providers.media appid=10010 user=-1: vold reset

//Phase600
11-23 14:37:06.066  1274  1274 I SystemServiceManager: Starting phase 600
11-23 14:37:06.236  1274  1274 D MountService: onStartUser 0


6.4 logcat 小技巧

通过 adb bugreport 抓取log信息。先看 zygote 是否起来, 再看 system_server 主线程的运行情况,再看 ActivityManager 情况。

adb logcat -s Zygote
adb logcat -s SystemServer
adb logcat -s SystemServiceManager
adb logcat | grep "1359 1359" //system_server情况
adb logcat -s ActivityManager

现场调试命令

cat proc/[pid]/stack //查看kernel调用栈
debuggerd -b [pid] //也不可以不带参数-b, 则直接输出到/data/tombstones/目录
kill -3 [pid] //生成/data/anr/traces.txt文件
lsof [pid] //查看进程所打开的文件

 

七、总结

各大核心进程启动后,都会进入各种对象所相应的 main() 方法,如下

7.1 进程main方法

进程                主方法
---------------------------------------
init进程            Init.main()
zygote进程          ZygoteInit.main()
app_process进程     RuntimeInit.main()
system_server进程   SystemServer.main()
app进程             ActivityThread.main()

注意 app_process 进程是指通过 /system/bin/app_process 启动的进程,且后面跟的参数不带 –zygote,即并非启动 zygote 进程。比如常见的有通过 adb shell 方式来执行 am、pm 等命令,便是这种方式。

7.2 重启相关进程

关于重要进程重启的过程,会触发哪些关联进程重启名单:

zygote:触发 media、netd 以及子进程(包括 system_server 进程)重启;
system_server: 触发 zygote 重启;
surfaceflinger:触发 zygote 重启;
servicemanager: 触发 zygote、healthd、media、surfaceflinger、drm 重启;

所以,surfaceflinger,servicemanager,zygote 自身以及 system_server 进程被杀都会触发 Zygote 重启。

 

参考:

Android系统启动-综述: http://gityuan.com/2016/02/01/android-booting/

 

嵌入式开发综述

0、嵌入式系统开发流程:

 

 

 

1、S5PV210内部结构图

2、S5PV210系统启动三阶段正解

      根据S5PV210芯片手册第6章所述S5PV210 consists of 64KB ROM and 96KB SRAM as internal memory(意思210芯片有两块片上内存,ROM:64KB,SRAM:96KB),并且在系统启动的时候这两块片上内存各有所用。

      启动分3个阶段,详情且看下图:

1、iROM code: 包含一些较小简单的代码
      iROM code存放在210内部64kB的ROM中,用于初始化系统时钟,堆栈等

2、从外设(NAND/SD/MMC/oneNAND等)存储设备拷贝前96KB代码到SRAM。其中这96KB的代码分为两部分(First Bootloader and second Bootloader)
      当这段代码成功执行完后会加载第二部分的启动代码,并且会根据启动方式键值检测启动方式。

      First Bootloader: 较短的初始化代码,用于初始化系统硬件资源,如中断向量、看门狗、TLB、MMU以及内存等;程序存放在外部memory device上,由iROM把这部分代码从外部boot device上读取到内部96KB的SRAM中。First bootloader执行完后接着就加载Second bootloader。
      Second bootloader: 较大的代码,初始化系统时钟,UART和DRAM控制器,

3、通过 Second bootloader代码段的初始化工作后把操作系统镜像从外设(NAND/SD/MMC/oneNAND等)存储设备拷贝到DRAM中,启动就此完成,接着 Second bootloader跳跳转运行操作系统。

3、嵌入式Linux文件I/O操作

 

底层文件操作函数包括:open、close、read、write、ioctl、lseek、fcntl、select、poll

标准I/O操作函数包括:fopen、fclose、fread、fwrite

4、嵌入式Linux多任务编程

1、任务、进程及线程的关系

2、进程控制——fork

3、进程间通信(3种管道、信号、信号量、共享内存、消息队列)

4、多线程——pthread

5、嵌入式Linux网络编程

1、TCP

2、UDP

3、套接字

6、嵌入式Linux驱动编程

1、设备分类:块设备、字符设备、网络设备

2、系统结构

7、嵌入式Linux应用编程

1、C语言程序开发

2、Qt界面开发

3、MiniGUI界面开发

4、X11多媒体程序开发

5、Android程序开发

6、网络通讯开发

以上是关于Android系统启动-综述—1的主要内容,如果未能解决你的问题,请参考以下文章

Android Framework启动过程(android内核剖析笔记)

Android Framework启动过程(android内核剖析笔记)

嵌入式开发综述

线程模型的综述

基于知识图谱的推荐系统研究综述

综述 | 图嵌入推荐系统技术