| /* |
| * Main entry of app process. |
| * |
| * Starts the interpreted runtime, then starts up the application. |
| * |
| */ |
| |
| #define LOG_TAG "appproc" |
| |
| #include <binder/IPCThreadState.h> |
| #include <binder/ProcessState.h> |
| #include <utils/Log.h> |
| #include <cutils/memory.h> |
| #include <cutils/process_name.h> |
| #include <cutils/properties.h> |
| #include <cutils/trace.h> |
| #include <android_runtime/AndroidRuntime.h> |
| #include <private/android_filesystem_config.h> // for AID_SYSTEM |
| |
| #include <stdlib.h> |
| #include <stdio.h> |
| #include <unistd.h> |
| #include <sys/prctl.h> |
| |
| namespace android { |
| |
| void app_usage() |
| { |
| fprintf(stderr, |
| "Usage: app_process [java-options] cmd-dir start-class-name [options]\n"); |
| } |
| |
| class AppRuntime : public AndroidRuntime |
| { |
| public: |
| AppRuntime(char* argBlockStart, const size_t argBlockLength) |
| : AndroidRuntime(argBlockStart, argBlockLength) |
| , mClass(NULL) |
| { |
| } |
| |
| void setClassNameAndArgs(const String8& className, int argc, char * const *argv) { |
| mClassName = className; |
| for (int i = 0; i < argc; ++i) { |
| mArgs.add(String8(argv[i])); |
| } |
| } |
| |
| virtual void onVmCreated(JNIEnv* env) |
| { |
| if (mClassName.isEmpty()) { |
| return; // Zygote. Nothing to do here. |
| } |
| |
| /* |
| * This is a little awkward because the JNI FindClass call uses the |
| * class loader associated with the native method we're executing in. |
| * If called in onStarted (from RuntimeInit.finishInit because we're |
| * launching "am", for example), FindClass would see that we're calling |
| * from a boot class' native method, and so wouldn't look for the class |
| * we're trying to look up in CLASSPATH. Unfortunately it needs to, |
| * because the "am" classes are not boot classes. |
| * |
| * The easiest fix is to call FindClass here, early on before we start |
| * executing boot class Java code and thereby deny ourselves access to |
| * non-boot classes. |
| */ |
| char* slashClassName = toSlashClassName(mClassName.string()); |
| mClass = env->FindClass(slashClassName); |
| if (mClass == NULL) { |
| ALOGE("ERROR: could not find class '%s'\n", mClassName.string()); |
| } |
| free(slashClassName); |
| |
| mClass = reinterpret_cast<jclass>(env->NewGlobalRef(mClass)); |
| } |
| |
| virtual void onStarted() |
| { |
| sp<ProcessState> proc = ProcessState::self(); |
| ALOGV("App process: starting thread pool.\n"); |
| proc->startThreadPool(); |
| |
| AndroidRuntime* ar = AndroidRuntime::getRuntime(); |
| ar->callMain(mClassName, mClass, mArgs); |
| |
| IPCThreadState::self()->stopProcess(); |
| } |
| |
| virtual void onZygoteInit() |
| { |
| // Re-enable tracing now that we're no longer in Zygote. |
| atrace_set_tracing_enabled(true); |
| |
| sp<ProcessState> proc = ProcessState::self(); |
| ALOGV("App process: starting thread pool.\n"); |
| proc->startThreadPool(); |
| } |
| |
| virtual void onExit(int code) |
| { |
| if (mClassName.isEmpty()) { |
| // if zygote |
| IPCThreadState::self()->stopProcess(); |
| } |
| |
| AndroidRuntime::onExit(code); |
| } |
| |
| |
| String8 mClassName; |
| Vector<String8> mArgs; |
| jclass mClass; |
| }; |
| |
| } |
| |
| using namespace android; |
| |
| static size_t computeArgBlockSize(int argc, char* const argv[]) { |
| // TODO: This assumes that all arguments are allocated in |
| // contiguous memory. There isn't any documented guarantee |
| // that this is the case, but this is how the kernel does it |
| // (see fs/exec.c). |
| // |
| // Also note that this is a constant for "normal" android apps. |
| // Since they're forked from zygote, the size of their command line |
| // is the size of the zygote command line. |
| // |
| // We change the process name of the process by over-writing |
| // the start of the argument block (argv[0]) with the new name of |
| // the process, so we'd mysteriously start getting truncated process |
| // names if the zygote command line decreases in size. |
| uintptr_t start = reinterpret_cast<uintptr_t>(argv[0]); |
| uintptr_t end = reinterpret_cast<uintptr_t>(argv[argc - 1]); |
| end += strlen(argv[argc - 1]); |
| |
| return (end - start); |
| } |
| |
| static void maybeCreateDalvikCache() { |
| #if defined(__aarch64__) |
| static const char kInstructionSet[] = "arm64"; |
| #elif defined(__x86_64__) |
| static const char kInstructionSet[] = "x86_64"; |
| #elif defined(__arm__) |
| static const char kInstructionSet[] = "arm"; |
| #elif defined(__i386__) |
| static const char kInstructionSet[] = "x86"; |
| #elif defined (__mips__) |
| static const char kInstructionSet[] = "mips"; |
| #else |
| #error "Unknown instruction set" |
| #endif |
| const char* androidRoot = getenv("ANDROID_DATA"); |
| LOG_ALWAYS_FATAL_IF(androidRoot == NULL, "ANDROID_DATA environment variable unset"); |
| |
| char dalvikCacheDir[PATH_MAX]; |
| const int numChars = snprintf(dalvikCacheDir, PATH_MAX, |
| "%s/dalvik-cache/%s", androidRoot, kInstructionSet); |
| LOG_ALWAYS_FATAL_IF((numChars >= PATH_MAX || numChars < 0), |
| "Error constructing dalvik cache : %s", strerror(errno)); |
| |
| int result = mkdir(dalvikCacheDir, 0771); |
| LOG_ALWAYS_FATAL_IF((result < 0 && errno != EEXIST), |
| "Error creating cache dir %s : %s", dalvikCacheDir, strerror(errno)); |
| |
| // We always perform these steps because the directory might |
| // already exist, with wider permissions and a different owner |
| // than we'd like. |
| result = chown(dalvikCacheDir, AID_SYSTEM, AID_SYSTEM); |
| LOG_ALWAYS_FATAL_IF((result < 0), "Error changing dalvik-cache ownership : %s", strerror(errno)); |
| |
| result = chmod(dalvikCacheDir, 0771); |
| LOG_ALWAYS_FATAL_IF((result < 0), |
| "Error changing dalvik-cache permissions : %s", strerror(errno)); |
| } |
| |
| #if defined(__LP64__) |
| static const char ABI_LIST_PROPERTY[] = "ro.product.cpu.abilist64"; |
| static const char ZYGOTE_NICE_NAME[] = "zygote64"; |
| #else |
| static const char ABI_LIST_PROPERTY[] = "ro.product.cpu.abilist32"; |
| static const char ZYGOTE_NICE_NAME[] = "zygote"; |
| #endif |
| |
| int main(int argc, char* const argv[]) |
| { |
| if (prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0) < 0) { |
| // Older kernels don't understand PR_SET_NO_NEW_PRIVS and return |
| // EINVAL. Don't die on such kernels. |
| if (errno != EINVAL) { |
| LOG_ALWAYS_FATAL("PR_SET_NO_NEW_PRIVS failed: %s", strerror(errno)); |
| return 12; |
| } |
| } |
| |
| AppRuntime runtime(argv[0], computeArgBlockSize(argc, argv)); |
| // Process command line arguments |
| // ignore argv[0] |
| argc--; |
| argv++; |
| |
| // Everything up to '--' or first non '-' arg goes to the vm. |
| // |
| // The first argument after the VM args is the "parent dir", which |
| // is currently unused. |
| // |
| // After the parent dir, we expect one or more the following internal |
| // arguments : |
| // |
| // --zygote : Start in zygote mode |
| // --start-system-server : Start the system server. |
| // --application : Start in application (stand alone, non zygote) mode. |
| // --nice-name : The nice name for this process. |
| // |
| // For non zygote starts, these arguments will be followed by |
| // the main class name. All remaining arguments are passed to |
| // the main method of this class. |
| // |
| // For zygote starts, all remaining arguments are passed to the zygote. |
| // main function. |
| |
| |
| 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* niceName = NULL; |
| String8 className; |
| |
| ++i; // Skip unused "parent dir" argument. |
| while (i < argc) { |
| const char* arg = argv[i++]; |
| if (strcmp(arg, "--zygote") == 0) { |
| zygote = true; |
| niceName = ZYGOTE_NICE_NAME; |
| } 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 if (strncmp(arg, "--", 2) != 0) { |
| className.setTo(arg); |
| break; |
| } else { |
| --i; |
| break; |
| } |
| } |
| |
| Vector<String8> args; |
| if (!className.isEmpty()) { |
| // We're not in zygote mode, the only argument we need to pass |
| // to RuntimeInit is the application argument. |
| // |
| // The Remainder of args get passed to startup class main(). Make |
| // copies of them before we overwrite them with the process name. |
| args.add(application ? String8("application") : String8("tool")); |
| runtime.setClassNameAndArgs(className, argc - i, argv + i); |
| } else { |
| // We're in zygote mode. |
| maybeCreateDalvikCache(); |
| |
| if (startSystemServer) { |
| args.add(String8("start-system-server")); |
| } |
| |
| char prop[PROP_VALUE_MAX]; |
| if (property_get(ABI_LIST_PROPERTY, prop, NULL) == 0) { |
| LOG_ALWAYS_FATAL("app_process: Unable to determine ABI list from property %s.", |
| ABI_LIST_PROPERTY); |
| return 11; |
| } |
| |
| String8 abiFlag("--abi-list="); |
| abiFlag.append(prop); |
| args.add(abiFlag); |
| |
| // In zygote mode, pass all remaining arguments to the zygote |
| // main() method. |
| for (; i < argc; ++i) { |
| args.add(String8(argv[i])); |
| } |
| } |
| |
| if (niceName && *niceName) { |
| runtime.setArgv0(niceName); |
| set_process_name(niceName); |
| } |
| |
| if (zygote) { |
| runtime.start("com.android.internal.os.ZygoteInit", args); |
| } else if (className) { |
| runtime.start("com.android.internal.os.RuntimeInit", args); |
| } else { |
| fprintf(stderr, "Error: no class name or --zygote supplied.\n"); |
| app_usage(); |
| LOG_ALWAYS_FATAL("app_process: no class name or --zygote supplied."); |
| return 10; |
| } |
| } |