Android bootコードフロー1

class core:



service ueventd /sbin/ueventd

service console /system/bin/sh

service adbd /sbin/adbd

service servicemanager /system/bin/servicemanager

service vold /system/bin/vold





class main:



service netd /system/bin/netd

service debuggerd /system/bin/debuggerd

service ril-daemon /system/bin/rild

service surfaceflinger /system/bin/surfaceflinger

service zygote /system/bin/app_process -Xzygote /system/bin --zygote --start-system-server

service drm /system/bin/drmserver

service media /system/bin/mediaserver

service bootanim /system/bin/bootanimation

service dbus /system/bin/dbus-daemon --system --nofork

service bluetoothd /system/bin/bluetoothd -n

service installd /system/bin/installd

service flash_recovery /system/etc/install-recovery.sh

service racoon /system/bin/racoon

service mtpd /system/bin/mtpd

service keystore /system/bin/keystore /data/misc/keystore

service dumpstate /system/bin/dumpstate -s

#      user group

/dev/null                 0666   root       root

/dev/zero                 0666   root       root

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

{

    // These are global variables in ProcessState.cpp

    mArgC = argc;

    mArgV = argv;



    mArgLen = 0;
     
    //    ，        init.rc        ： -Xzygote /system/bin --zygote --start-system-server for (int i=0; i<argc; i++) {

        mArgLen += strlen(argv[i]) + 1;

    }

    mArgLen--;



    AppRuntime runtime;

    const char* argv0 = argv[0];   //-Xzygote



    // Process command line arguments

    // ignore argv[0]

    argc--;           //    4，     3

    argv++;           //argv    argv[1]



    // Everything up to '--' or first non '-' arg goes to the vm

　　
　　 // i = 0，  ：frameworks/base/core/jni/AndroidRuntime.cpp

    int i = runtime.addVmArguments(argc, argv);



    // Parse runtime arguments.  Stop at first unrecognized option.

    bool zygote = false;

    bool startSystemServer = false;

    bool application = false;

    const char* parentDir = NULL;

    const char* niceName = NULL;

    const char* className = NULL;

    while (i < argc) {

        const char* arg = argv[i++];

        if (!parentDir) {

            parentDir = arg;   　　　　　　　　　　　　　　//parentDir = /system/bin

        } else if (strcmp(arg, "--zygote") == 0) {     //  i = 2，arg = argv[1]  ， ：--zygote

            zygote = true;　　　　　　　　　　　　　　　　

            niceName = "zygote";

        } else if (strcmp(arg, "--start-system-server") == 0) {

            startSystemServer = true;

        } else if (strcmp(arg, "--application") == 0) {

            application = true;

        } else if (strncmp(arg, "--nice-name=", 12) == 0) {

            niceName = arg + 12;

        } else {

            className = arg;

            break;

        }

    }



    if (niceName && *niceName) {

        setArgv0(argv0, niceName);

        set_process_name(niceName);

    }



    runtime.mParentDir = parentDir;



    if (zygote) {
　　　　　// zygote = true，   com.android.internal.os.ZygoteInit，  ：startSystemServer

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

    } else if (className) {

        // Remainder of args get passed to startup class main()

        runtime.mClassName = className;

        runtime.mArgC = argc - i;

        runtime.mArgV = argv + i;

        runtime.start("com.android.internal.os.RuntimeInit",

                application ? "application" : "tool");

    } else {

        fprintf(stderr, "Error: no class name or --zygote supplied.
");

        app_usage();

        LOG_ALWAYS_FATAL("app_process: no class name or --zygote supplied.");

        return 10;

    }

}

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

void AndroidRuntime::start(const char* className, const char* options)

{

    LOGD("
>>>>>> AndroidRuntime START %s <<<<<<
",

            className != NULL ? className : "(unknown)");


    ...


    /* start the virtual machine */
    //   dalvik      ，         

    JNIEnv* env;

    if (startVm(&mJavaVM, &env) != 0) {

        return;

    }

    onVmCreated(env);



    /*

     * Register android functions.

     */

    if (startReg(env) < 0) {

        LOGE("Unable to register all android natives
");

        return;

    }



    ...


    /*

     * Start VM.  This thread becomes the main thread of the VM, and will

     * not return until the VM exits.

     */
    //    com.xxx.xxx     com/xxx/xxx

    char* slashClassName = toSlashClassName(className);

    jclass startClass = env->FindClass(slashClassName);

    if (startClass == NULL) {

        LOGE("JavaVM unable to locate class '%s'
", slashClassName);

        /* keep going */

    } else {
　　　　 // jni    java   ，        class，       main   

        jmethodID startMeth = env->GetStaticMethodID(startClass, "main",

            "([Ljava/lang/String;)V");

        if (startMeth == NULL) {

            LOGE("JavaVM unable to find main() in '%s'
", className);

            /* keep going */

        } else {

            env->CallStaticVoidMethod(startClass, startMeth, strArray);

        }

    }

    free(slashClassName);



    LOGD("Shutting down VM
");

    if (mJavaVM->DetachCurrentThread() != JNI_OK)

        LOGW("Warning: unable to detach main thread
");

    if (mJavaVM->DestroyJavaVM() != 0)

        LOGW("Warning: VM did not shut down cleanly
");

}

 public static void main(String argv[]) {

        try {

            // Start profiling the zygote initialization.

            SamplingProfilerIntegration.start();

　　　　　　　
            //   socket server

            registerZygoteSocket();

            EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_START,

                SystemClock.uptimeMillis());

            //     ，  preloadClasses()   preloadResources()，              /system/etc/event-log-tags    

            preload();

            EventLog.writeEvent(LOG_BOOT_PROGRESS_PRELOAD_END,

                SystemClock.uptimeMillis());

　　　　　　　
            　

            // Finish profiling the zygote initialization.

            SamplingProfilerIntegration.writeZygoteSnapshot();



            // Do an initial gc to clean up after startup

            gc();



            // If requested, start system server directly from Zygote

            if (argv.length != 2) {

                throw new RuntimeException(argv[0] + USAGE_STRING);

            }

　　

            if (argv[1].equals("start-system-server")) {
　　　　　　　　　 //    Zygote   main    ，     start-system-server，   startSystemServer() 

                startSystemServer();

            } else if (!argv[1].equals("")) {

                throw new RuntimeException(argv[0] + USAGE_STRING);

            }



            Log.i(TAG, "Accepting command socket connections");



            if (ZYGOTE_FORK_MODE) {

                runForkMode();

            } else {
　　　　　　　　　//     registerZygoteSocket()         server scocket，   ，     Zygote   

                runSelectLoopMode();

            }

　　　　　　　　

            closeServerSocket();

        } catch (MethodAndArgsCaller caller) {

            caller.run();

        } catch (RuntimeException ex) {

            Log.e(TAG, "Zygote died with exception", ex);

            closeServerSocket();

            throw ex;

        }

    }