1
int FirstStageMain(int argc, char** argv) {
2
  // ...
3
  const char* path = "/system/bin/init";
4
    const char* args[] = {path, "selinux_setup", nullptr};
5
    auto fd = open("/dev/kmsg", O_WRONLY | O_CLOEXEC);
6
    dup2(fd, STDOUT_FILENO);
7
    dup2(fd, STDERR_FILENO);
8
    close(fd);
9
    execv(path, const_cast<char**>(args));
10

11
    // execv() only returns if an error happened, in which case we
12
    // panic and never fall through this conditional.
13
    PLOG(FATAL) << "execv(\"" << path << "\") failed";
14

15
    return 1;
16
}

1
// ...
2
int main(int argc, char* const argv[])
3
{
4
    // ...
5

6
    AppRuntime runtime(argv[0], computeArgBlockSize(argc, argv));
7
     // ...
8

9
    // Everything up to '--' or first non '-' arg goes to the vm.
10
    //
11
    // The first argument after the VM args is the "parent dir", which
12
    // is currently unused.
13
    //
14
    // After the parent dir, we expect one or more the following internal
15
    // arguments :
16
    //
17
    // --zygote : Start in zygote mode
18
    // --start-system-server : Start the system server.
19
    // --application : Start in application (stand alone, non zygote) mode.
20
    // --nice-name : The nice name for this process.
21
    //
22
    // For non zygote starts, these arguments will be followed by
23
    // the main class name. All remaining arguments are passed to
24
    // the main method of this class.
25
    //
26
    // For zygote starts, all remaining arguments are passed to the zygote.
27
    // main function.
28
    //
29
    // Note that we must copy argument string values since we will rewrite the
30
    // entire argument block when we apply the nice name to argv0.
31
    //
32
    // As an exception to the above rule, anything in "spaced commands"
33
    // goes to the vm even though it has a space in it.
34

35
     // ...
36
    // Parse runtime arguments.  Stop at first unrecognized option.
37
    bool zygote = false;
38
    bool startSystemServer = false;
39
    bool application = false;
40
    String8 niceName;
41
    String8 className;
42

43
    ++i;  // Skip unused "parent dir" argument.
44
    while (i < argc) {
45
        const char* arg = argv[i++];
46
        if (strcmp(arg, "--zygote") == 0) {
47
            zygote = true;
48
            niceName = ZYGOTE_NICE_NAME;
49
        } else if (strcmp(arg, "--start-system-server") == 0) {
50
            startSystemServer = true;
51
        } else if (strcmp(arg, "--application") == 0) {
52
            application = true;
53
        } else if (strncmp(arg, "--nice-name=", 12) == 0) {
54
            niceName = (arg + 12);
55
        } else if (strncmp(arg, "--", 2) != 0) {
56
            className = arg;
57
            break;
58
        } else {
59
            --i;
60
            break;
61
        }
62
    }
63

64
    Vector<String8> args;
65
    if (!className.empty()) {
66
       // ...
67
    } else {
68
        // We're in zygote mode.
69
        maybeCreateDalvikCache();
70

71
        if (startSystemServer) {
72
            args.add(String8("start-system-server"));
73
        }
74

75
        // ...
76
        // In zygote mode, pass all remaining arguments to the zygote
77
        // main() method.
78
        for (; i < argc; ++i) {
79
            args.add(String8(argv[i]));
80
        }
81
    }
82

83
    if (!niceName.empty()) {
84
        runtime.setArgv0(niceName.c_str(), true /* setProcName */);
85
    }
86

87
    if (zygote) {
88
        runtime.start("com.android.internal.os.ZygoteInit", args, zygote);
89
    } else if (!className.empty()) {
90
        runtime.start("com.android.internal.os.RuntimeInit", args, zygote);
91
    } else {
92
        fprintf(stderr, "Error: no class name or --zygote supplied.\n");
93
        app_usage();
94
        LOG_ALWAYS_FATAL("app_process: no class name or --zygote supplied.");
95
    }
96
}

1
/*
2
 * Start the Android runtime.  This involves starting the virtual machine
3
 * and calling the "static void main(String[] args)" method in the class
4
 * named by "className".
5
 *
6
 * Passes the main function two arguments, the class name and the specified
7
 * options string.
8
 */
9
void AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote)
10
{
11
    ALOGD(">>>>>> START %s uid %d <<<<<<\n",
12
            className != NULL ? className : "(unknown)", getuid());
13

14
    static const String8 startSystemServer("start-system-server");
15
    // Whether this is the primary zygote, meaning the zygote which will fork system server.
16
    bool primary_zygote = false;
17

18
    /*
19
     * 'startSystemServer == true' means runtime is obsolete and not run from
20
     * init.rc anymore, so we print out the boot start event here.
21
     */
22
    for (size_t i = 0; i < options.size(); ++i) {
23
        if (options[i] == startSystemServer) {
24
            primary_zygote = true;
25
           /* track our progress through the boot sequence */
26
           const int LOG_BOOT_PROGRESS_START = 3000;
27
           LOG_EVENT_LONG(LOG_BOOT_PROGRESS_START,  ns2ms(systemTime(SYSTEM_TIME_MONOTONIC)));
28
        }
29
    }
30

31
    // ...
32

33
    //const char* kernelHack = getenv("LD_ASSUME_KERNEL");
34
    //ALOGD("Found LD_ASSUME_KERNEL='%s'\n", kernelHack);
35

36
    /* start the virtual machine */
37
    JniInvocation jni_invocation;
38
    jni_invocation.Init(NULL);
39
    JNIEnv* env;
40
    if (startVm(&mJavaVM, &env, zygote, primary_zygote) != 0) {
41
        return;
42
    }
43
    onVmCreated(env);
44

45
    /*
46
     * Register android functions.
47
     */
48
    if (startReg(env) < 0) {
49
        ALOGE("Unable to register all android natives\n");
50
        return;
51
    }
52

53
    /*
54
     * We want to call main() with a String array with arguments in it.
55
     * At present we have two arguments, the class name and an option string.
56
     * Create an array to hold them.
57
     */
58
    jclass stringClass;
59
    jobjectArray strArray;
60
    jstring classNameStr;
61

62
    stringClass = env->FindClass("java/lang/String");
63
    assert(stringClass != NULL);
64
    strArray = env->NewObjectArray(options.size() + 1, stringClass, NULL);
65
    assert(strArray != NULL);
66
    classNameStr = env->NewStringUTF(className);
67
    assert(classNameStr != NULL);
68
    env->SetObjectArrayElement(strArray, 0, classNameStr);
69

70
    for (size_t i = 0; i < options.size(); ++i) {
71
        jstring optionsStr = env->NewStringUTF(options.itemAt(i).c_str());
72
        assert(optionsStr != NULL);
73
        env->SetObjectArrayElement(strArray, i + 1, optionsStr);
74
    }
75

76
    /*
77
     * Start VM.  This thread becomes the main thread of the VM, and will
78
     * not return until the VM exits.
79
     */
80
    char* slashClassName = toSlashClassName(className != NULL ? className : "");
81
    jclass startClass = env->FindClass(slashClassName);
82
    if (startClass == NULL) {
83
        ALOGE("JavaVM unable to locate class '%s'\n", slashClassName);
84
        /* keep going */
85
    } else {
86
        jmethodID startMeth = env->GetStaticMethodID(startClass, "main",
87
            "([Ljava/lang/String;)V");
88
        if (startMeth == NULL) {
89
            ALOGE("JavaVM unable to find main() in '%s'\n", className);
90
            /* keep going */
91
        } else {
92
            env->CallStaticVoidMethod(startClass, startMeth, strArray);
93

94
#if 0
95
            if (env->ExceptionCheck())
96
                threadExitUncaughtException(env);
97
#endif
98
        }
99
    }
100
    free(slashClassName);
101

102
    ALOGD("Shutting down VM\n");
103
    if (mJavaVM->DetachCurrentThread() != JNI_OK)
104
        ALOGW("Warning: unable to detach main thread\n");
105
    if (mJavaVM->DestroyJavaVM() != 0)
106
        ALOGW("Warning: VM did not shut down cleanly\n");
107
}

1
// ...
2

3
// Name the default library providing the JNI Invocation API.
4
static const char* kDefaultJniInvocationLibrary = "libart.so";
5
static const char* kDebugJniInvocationLibrary = "libartd.so";
6

7
// ...
8
bool JniInvocationInit(struct JniInvocationImpl* instance, const char* library_name) {
9
#ifdef __ANDROID__
10
  char buffer[PROP_VALUE_MAX];
11
#else
12
  char* buffer = NULL;
13
#endif
14
  library_name = JniInvocationGetLibrary(library_name, buffer);
15
  DlLibrary library = DlOpenLibrary(library_name);
16
  if (library == NULL) {
17
    if (strcmp(library_name, kDefaultJniInvocationLibrary) == 0) {
18
      // Nothing else to try.
19
      ALOGE("Failed to dlopen %s: %s", library_name, DlGetError());
20
      return false;
21
    }
22
    // Note that this is enough to get something like the zygote
23
    // running, we can't property_set here to fix this for the future
24
    // because we are root and not the system user. See
25
    // RuntimeInit.commonInit for where we fix up the property to
26
    // avoid future fallbacks. http://b/11463182
27
    ALOGW("Falling back from %s to %s after dlopen error: %s",
28
          library_name, kDefaultJniInvocationLibrary, DlGetError());
29
    library_name = kDefaultJniInvocationLibrary;
30
    library = DlOpenLibrary(library_name);
31
    if (library == NULL) {
32
      ALOGE("Failed to dlopen %s: %s", library_name, DlGetError());
33
      return false;
34
    }
35
  }
36

37
  DlSymbol JNI_GetDefaultJavaVMInitArgs_ = FindSymbol(library, "JNI_GetDefaultJavaVMInitArgs");
38
  if (JNI_GetDefaultJavaVMInitArgs_ == NULL) {
39
    return false;
40
  }
41

42
  DlSymbol JNI_CreateJavaVM_ = FindSymbol(library, "JNI_CreateJavaVM");
43
  if (JNI_CreateJavaVM_ == NULL) {
44
    return false;
45
  }
46

47
  DlSymbol JNI_GetCreatedJavaVMs_ = FindSymbol(library, "JNI_GetCreatedJavaVMs");
48
  if (JNI_GetCreatedJavaVMs_ == NULL) {
49
    return false;
50
  }
51

52
  instance->jni_provider_library_name = library_name;
53
  instance->jni_provider_library = library;
54
  instance->JNI_GetDefaultJavaVMInitArgs = (jint (*)(void *)) JNI_GetDefaultJavaVMInitArgs_;
55
  instance->JNI_CreateJavaVM = (jint (*)(JavaVM**, JNIEnv**, void*)) JNI_CreateJavaVM_;
56
  instance->JNI_GetCreatedJavaVMs = (jint (*)(JavaVM**, jsize, jsize*)) JNI_GetCreatedJavaVMs_;
57

58
  return true;
59
}