cmds/app_process/app_main.cpp - platform/frameworks/base - Git at Google

 /*
  * 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]) + 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, 0711);
     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_ROOT, AID_ROOT);
     LOG_ALWAYS_FATAL_IF((result < 0), "Error changing dalvik-cache ownership : %s", strerror(errno));

     result = chmod(dalvikCacheDir, 0711);
     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.
     //
     // Note that we must copy argument string values since we will rewrite the
     // entire argument block when we apply the nice name to argv0.

     int i;
     for (i = 0; i < argc; i++) {
         if (argv[i][0] != '-') {
             break;
         }
         if (argv[i][1] == '-' && argv[i][2] == 0) {
             ++i; // Skip --.
             break;
         }
         runtime.addOption(strdup(argv[i]));
     }

     // Parse runtime arguments.  Stop at first unrecognized option.
     bool zygote = false;
     bool startSystemServer = false;
     bool application = false;
     String8 niceName;
     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.setTo(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.isEmpty()) {
         runtime.setArgv0(niceName.string());
         set_process_name(niceName.string());
     }

     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;
     }
 }
	/*
	* 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]) + 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, 0711);
	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_ROOT, AID_ROOT);
	LOG_ALWAYS_FATAL_IF((result < 0), "Error changing dalvik-cache ownership : %s", strerror(errno));

	result = chmod(dalvikCacheDir, 0711);
	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.
	//
	// Note that we must copy argument string values since we will rewrite the
	// entire argument block when we apply the nice name to argv0.

	int i;
	for (i = 0; i < argc; i++) {
	if (argv[i][0] != '-') {
	break;
	}
	if (argv[i][1] == '-' && argv[i][2] == 0) {
	++i; // Skip --.
	break;
	}
	runtime.addOption(strdup(argv[i]));
	}

	// Parse runtime arguments. Stop at first unrecognized option.
	bool zygote = false;
	bool startSystemServer = false;
	bool application = false;
	String8 niceName;
	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.setTo(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.isEmpty()) {
	runtime.setArgv0(niceName.string());
	set_process_name(niceName.string());
	}

	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;
	}
	}