cmds/app_process/app_main.cpp - LeafOS-Project/android_frameworks_base - Gitiles

 /*
  * Main entry of app process.
  *
  * Starts the interpreted runtime, then starts up the application.
  *
  */

 #define LOG_TAG "appproc"

 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/prctl.h>
 #include <sys/stat.h>
 #include <unistd.h>

 #include <android-base/macros.h>
 #include <binder/IPCThreadState.h>
 #include <hwbinder/IPCThreadState.h>
 #include <utils/Log.h>
 #include <cutils/memory.h>
 #include <cutils/properties.h>
 #include <cutils/trace.h>
 #include <android_runtime/AndroidRuntime.h>
 #include <private/android_filesystem_config.h>  // for AID_SYSTEM

 namespace android {

 static 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();
         hardware::IPCThreadState::self()->stopProcess();
     }

     virtual void onZygoteInit()
     {
         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();
             hardware::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() {
     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/" ABI_STRING, androidRoot);
     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 (!LOG_NDEBUG) {
       String8 argv_String;
       for (int i = 0; i < argc; ++i) {
         argv_String.append("\"");
         argv_String.append(argv[i]);
         argv_String.append("\" ");
       }
       ALOGV("app_process main with argv: %s", argv_String.string());
     }

     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.
     //
     // As an exception to the above rule, anything in "spaced commands"
     // goes to the vm even though it has a space in it.
     const char* spaced_commands[] = { "-cp", "-classpath" };
     // Allow "spaced commands" to be succeeded by exactly 1 argument (regardless of -s).
     bool known_command = false;

     int i;
     for (i = 0; i < argc; i++) {
         if (known_command == true) {
           runtime.addOption(strdup(argv[i]));
           // The static analyzer gets upset that we don't ever free the above
           // string. Since the allocation is from main, leaking it doesn't seem
           // problematic. NOLINTNEXTLINE
           ALOGV("app_process main add known option '%s'", argv[i]);
           known_command = false;
           continue;
         }

         for (int j = 0;
              j < static_cast<int>(sizeof(spaced_commands) / sizeof(spaced_commands[0]));
              ++j) {
           if (strcmp(argv[i], spaced_commands[j]) == 0) {
             known_command = true;
             ALOGV("app_process main found known command '%s'", argv[i]);
           }
         }

         if (argv[i][0] != '-') {
             break;
         }
         if (argv[i][1] == '-' && argv[i][2] == 0) {
             ++i; // Skip --.
             break;
         }

         runtime.addOption(strdup(argv[i]));
         // The static analyzer gets upset that we don't ever free the above
         // string. Since the allocation is from main, leaking it doesn't seem
         // problematic. NOLINTNEXTLINE
         ALOGV("app_process main add option '%s'", 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);

         if (!LOG_NDEBUG) {
           String8 restOfArgs;
           char* const* argv_new = argv + i;
           int argc_new = argc - i;
           for (int k = 0; k < argc_new; ++k) {
             restOfArgs.append("\"");
             restOfArgs.append(argv_new[k]);
             restOfArgs.append("\" ");
           }
           ALOGV("Class name = %s, args = %s", className.string(), restOfArgs.string());
         }
     } 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(), true /* setProcName */);
     }

     if (zygote) {
         runtime.start("com.android.internal.os.ZygoteInit", args, zygote);
     } else if (!className.isEmpty()) {
         runtime.start("com.android.internal.os.RuntimeInit", args, zygote);
     } else {
         fprintf(stderr, "Error: no class name or --zygote supplied.\n");
         app_usage();
         LOG_ALWAYS_FATAL("app_process: no class name or --zygote supplied.");
     }
 }
	/*
	* Main entry of app process.
	*
	* Starts the interpreted runtime, then starts up the application.
	*
	*/

	#define LOG_TAG "appproc"

	#include <stdio.h>
	#include <stdlib.h>
	#include <sys/prctl.h>
	#include <sys/stat.h>
	#include <unistd.h>

	#include <android-base/macros.h>
	#include <binder/IPCThreadState.h>
	#include <hwbinder/IPCThreadState.h>
	#include <utils/Log.h>
	#include <cutils/memory.h>
	#include <cutils/properties.h>
	#include <cutils/trace.h>
	#include <android_runtime/AndroidRuntime.h>
	#include <private/android_filesystem_config.h> // for AID_SYSTEM

	namespace android {

	static 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();
	hardware::IPCThreadState::self()->stopProcess();
	}

	virtual void onZygoteInit()
	{
	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();
	hardware::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() {
	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/" ABI_STRING, androidRoot);
	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 (!LOG_NDEBUG) {
	String8 argv_String;
	for (int i = 0; i < argc; ++i) {
	argv_String.append("\"");
	argv_String.append(argv[i]);
	argv_String.append("\" ");
	}
	ALOGV("app_process main with argv: %s", argv_String.string());
	}

	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.
	//
	// As an exception to the above rule, anything in "spaced commands"
	// goes to the vm even though it has a space in it.
	const char* spaced_commands[] = { "-cp", "-classpath" };
	// Allow "spaced commands" to be succeeded by exactly 1 argument (regardless of -s).
	bool known_command = false;

	int i;
	for (i = 0; i < argc; i++) {
	if (known_command == true) {
	runtime.addOption(strdup(argv[i]));
	// The static analyzer gets upset that we don't ever free the above
	// string. Since the allocation is from main, leaking it doesn't seem
	// problematic. NOLINTNEXTLINE
	ALOGV("app_process main add known option '%s'", argv[i]);
	known_command = false;
	continue;
	}

	for (int j = 0;
	j < static_cast<int>(sizeof(spaced_commands) / sizeof(spaced_commands[0]));
	++j) {
	if (strcmp(argv[i], spaced_commands[j]) == 0) {
	known_command = true;
	ALOGV("app_process main found known command '%s'", argv[i]);
	}
	}

	if (argv[i][0] != '-') {
	break;
	}
	if (argv[i][1] == '-' && argv[i][2] == 0) {
	++i; // Skip --.
	break;
	}

	runtime.addOption(strdup(argv[i]));
	// The static analyzer gets upset that we don't ever free the above
	// string. Since the allocation is from main, leaking it doesn't seem
	// problematic. NOLINTNEXTLINE
	ALOGV("app_process main add option '%s'", 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);

	if (!LOG_NDEBUG) {
	String8 restOfArgs;
	char* const* argv_new = argv + i;
	int argc_new = argc - i;
	for (int k = 0; k < argc_new; ++k) {
	restOfArgs.append("\"");
	restOfArgs.append(argv_new[k]);
	restOfArgs.append("\" ");
	}
	ALOGV("Class name = %s, args = %s", className.string(), restOfArgs.string());
	}
	} 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(), true /* setProcName */);
	}

	if (zygote) {
	runtime.start("com.android.internal.os.ZygoteInit", args, zygote);
	} else if (!className.isEmpty()) {
	runtime.start("com.android.internal.os.RuntimeInit", args, zygote);
	} else {
	fprintf(stderr, "Error: no class name or --zygote supplied.\n");
	app_usage();
	LOG_ALWAYS_FATAL("app_process: no class name or --zygote supplied.");
	}
	}