4f66cb3f53
* No new functionality was added, this was already possible via -Djava.class.path=classpath * However, this makes it a bit more compatible with other tools that use -cp to invoke the main class. * Also update the benchmarks README for correct up-to-date vogar instructions. Test: vogar --mode app_process --benchmark frameworks/base/core/tests/benchmarks/src/android/os/ParcelBenchmark.java Bug: 31807538 Change-Id: Idb04600fed3dd955437ccac832617dcfd1b52b63
355 lines
12 KiB
C++
355 lines
12 KiB
C++
/*
|
|
* 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 <binder/IPCThreadState.h>
|
|
#include <binder/ProcessState.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();
|
|
}
|
|
|
|
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();
|
|
}
|
|
|
|
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__) && !defined(__LP64__)
|
|
static const char kInstructionSet[] = "mips";
|
|
#elif defined (__mips__) && defined(__LP64__)
|
|
static const char kInstructionSet[] = "mips64";
|
|
#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) {
|
|
LOG_ALWAYS_FATAL("PR_SET_NO_NEW_PRIVS failed: %s", strerror(errno));
|
|
}
|
|
|
|
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]));
|
|
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]));
|
|
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) {
|
|
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.");
|
|
}
|
|
}
|