1 /*
2  * Main entry of app process.
3  *
4  * Starts the interpreted runtime, then starts up the application.
5  *
6  */
7 
8 #define LOG_TAG "appproc"
9 
10 #include <stdio.h>
11 #include <stdlib.h>
12 #include <sys/prctl.h>
13 #include <sys/stat.h>
14 #include <unistd.h>
15 
16 #include <binder/IPCThreadState.h>
17 #include <binder/ProcessState.h>
18 #include <utils/Log.h>
19 #include <cutils/memory.h>
20 #include <cutils/process_name.h>
21 #include <cutils/properties.h>
22 #include <cutils/trace.h>
23 #include <android_runtime/AndroidRuntime.h>
24 #include <private/android_filesystem_config.h>  // for AID_SYSTEM
25 
26 namespace android {
27 
app_usage()28 static void app_usage()
29 {
30     fprintf(stderr,
31         "Usage: app_process [java-options] cmd-dir start-class-name [options]\n");
32 }
33 
34 class AppRuntime : public AndroidRuntime
35 {
36 public:
AppRuntime(char * argBlockStart,const size_t argBlockLength)37     AppRuntime(char* argBlockStart, const size_t argBlockLength)
38         : AndroidRuntime(argBlockStart, argBlockLength)
39         , mClass(NULL)
40     {
41     }
42 
setClassNameAndArgs(const String8 & className,int argc,char * const * argv)43     void setClassNameAndArgs(const String8& className, int argc, char * const *argv) {
44         mClassName = className;
45         for (int i = 0; i < argc; ++i) {
46              mArgs.add(String8(argv[i]));
47         }
48     }
49 
onVmCreated(JNIEnv * env)50     virtual void onVmCreated(JNIEnv* env)
51     {
52         if (mClassName.isEmpty()) {
53             return; // Zygote. Nothing to do here.
54         }
55 
56         /*
57          * This is a little awkward because the JNI FindClass call uses the
58          * class loader associated with the native method we're executing in.
59          * If called in onStarted (from RuntimeInit.finishInit because we're
60          * launching "am", for example), FindClass would see that we're calling
61          * from a boot class' native method, and so wouldn't look for the class
62          * we're trying to look up in CLASSPATH. Unfortunately it needs to,
63          * because the "am" classes are not boot classes.
64          *
65          * The easiest fix is to call FindClass here, early on before we start
66          * executing boot class Java code and thereby deny ourselves access to
67          * non-boot classes.
68          */
69         char* slashClassName = toSlashClassName(mClassName.string());
70         mClass = env->FindClass(slashClassName);
71         if (mClass == NULL) {
72             ALOGE("ERROR: could not find class '%s'\n", mClassName.string());
73         }
74         free(slashClassName);
75 
76         mClass = reinterpret_cast<jclass>(env->NewGlobalRef(mClass));
77     }
78 
onStarted()79     virtual void onStarted()
80     {
81         sp<ProcessState> proc = ProcessState::self();
82         ALOGV("App process: starting thread pool.\n");
83         proc->startThreadPool();
84 
85         AndroidRuntime* ar = AndroidRuntime::getRuntime();
86         ar->callMain(mClassName, mClass, mArgs);
87 
88         IPCThreadState::self()->stopProcess();
89     }
90 
onZygoteInit()91     virtual void onZygoteInit()
92     {
93         sp<ProcessState> proc = ProcessState::self();
94         ALOGV("App process: starting thread pool.\n");
95         proc->startThreadPool();
96     }
97 
onExit(int code)98     virtual void onExit(int code)
99     {
100         if (mClassName.isEmpty()) {
101             // if zygote
102             IPCThreadState::self()->stopProcess();
103         }
104 
105         AndroidRuntime::onExit(code);
106     }
107 
108 
109     String8 mClassName;
110     Vector<String8> mArgs;
111     jclass mClass;
112 };
113 
114 }
115 
116 using namespace android;
117 
computeArgBlockSize(int argc,char * const argv[])118 static size_t computeArgBlockSize(int argc, char* const argv[]) {
119     // TODO: This assumes that all arguments are allocated in
120     // contiguous memory. There isn't any documented guarantee
121     // that this is the case, but this is how the kernel does it
122     // (see fs/exec.c).
123     //
124     // Also note that this is a constant for "normal" android apps.
125     // Since they're forked from zygote, the size of their command line
126     // is the size of the zygote command line.
127     //
128     // We change the process name of the process by over-writing
129     // the start of the argument block (argv[0]) with the new name of
130     // the process, so we'd mysteriously start getting truncated process
131     // names if the zygote command line decreases in size.
132     uintptr_t start = reinterpret_cast<uintptr_t>(argv[0]);
133     uintptr_t end = reinterpret_cast<uintptr_t>(argv[argc - 1]);
134     end += strlen(argv[argc - 1]) + 1;
135     return (end - start);
136 }
137 
maybeCreateDalvikCache()138 static void maybeCreateDalvikCache() {
139 #if defined(__aarch64__)
140     static const char kInstructionSet[] = "arm64";
141 #elif defined(__x86_64__)
142     static const char kInstructionSet[] = "x86_64";
143 #elif defined(__arm__)
144     static const char kInstructionSet[] = "arm";
145 #elif defined(__i386__)
146     static const char kInstructionSet[] = "x86";
147 #elif defined (__mips__) && !defined(__LP64__)
148     static const char kInstructionSet[] = "mips";
149 #elif defined (__mips__) && defined(__LP64__)
150     static const char kInstructionSet[] = "mips64";
151 #else
152 #error "Unknown instruction set"
153 #endif
154     const char* androidRoot = getenv("ANDROID_DATA");
155     LOG_ALWAYS_FATAL_IF(androidRoot == NULL, "ANDROID_DATA environment variable unset");
156 
157     char dalvikCacheDir[PATH_MAX];
158     const int numChars = snprintf(dalvikCacheDir, PATH_MAX,
159             "%s/dalvik-cache/%s", androidRoot, kInstructionSet);
160     LOG_ALWAYS_FATAL_IF((numChars >= PATH_MAX || numChars < 0),
161             "Error constructing dalvik cache : %s", strerror(errno));
162 
163     int result = mkdir(dalvikCacheDir, 0711);
164     LOG_ALWAYS_FATAL_IF((result < 0 && errno != EEXIST),
165             "Error creating cache dir %s : %s", dalvikCacheDir, strerror(errno));
166 
167     // We always perform these steps because the directory might
168     // already exist, with wider permissions and a different owner
169     // than we'd like.
170     result = chown(dalvikCacheDir, AID_ROOT, AID_ROOT);
171     LOG_ALWAYS_FATAL_IF((result < 0), "Error changing dalvik-cache ownership : %s", strerror(errno));
172 
173     result = chmod(dalvikCacheDir, 0711);
174     LOG_ALWAYS_FATAL_IF((result < 0),
175             "Error changing dalvik-cache permissions : %s", strerror(errno));
176 }
177 
178 #if defined(__LP64__)
179 static const char ABI_LIST_PROPERTY[] = "ro.product.cpu.abilist64";
180 static const char ZYGOTE_NICE_NAME[] = "zygote64";
181 #else
182 static const char ABI_LIST_PROPERTY[] = "ro.product.cpu.abilist32";
183 static const char ZYGOTE_NICE_NAME[] = "zygote";
184 #endif
185 
main(int argc,char * const argv[])186 int main(int argc, char* const argv[])
187 {
188     if (prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0) < 0) {
189         // Older kernels don't understand PR_SET_NO_NEW_PRIVS and return
190         // EINVAL. Don't die on such kernels.
191         if (errno != EINVAL) {
192             LOG_ALWAYS_FATAL("PR_SET_NO_NEW_PRIVS failed: %s", strerror(errno));
193             return 12;
194         }
195     }
196 
197     AppRuntime runtime(argv[0], computeArgBlockSize(argc, argv));
198     // Process command line arguments
199     // ignore argv[0]
200     argc--;
201     argv++;
202 
203     // Everything up to '--' or first non '-' arg goes to the vm.
204     //
205     // The first argument after the VM args is the "parent dir", which
206     // is currently unused.
207     //
208     // After the parent dir, we expect one or more the following internal
209     // arguments :
210     //
211     // --zygote : Start in zygote mode
212     // --start-system-server : Start the system server.
213     // --application : Start in application (stand alone, non zygote) mode.
214     // --nice-name : The nice name for this process.
215     //
216     // For non zygote starts, these arguments will be followed by
217     // the main class name. All remaining arguments are passed to
218     // the main method of this class.
219     //
220     // For zygote starts, all remaining arguments are passed to the zygote.
221     // main function.
222     //
223     // Note that we must copy argument string values since we will rewrite the
224     // entire argument block when we apply the nice name to argv0.
225 
226     int i;
227     for (i = 0; i < argc; i++) {
228         if (argv[i][0] != '-') {
229             break;
230         }
231         if (argv[i][1] == '-' && argv[i][2] == 0) {
232             ++i; // Skip --.
233             break;
234         }
235         runtime.addOption(strdup(argv[i]));
236     }
237 
238     // Parse runtime arguments.  Stop at first unrecognized option.
239     bool zygote = false;
240     bool startSystemServer = false;
241     bool application = false;
242     String8 niceName;
243     String8 className;
244 
245     ++i;  // Skip unused "parent dir" argument.
246     while (i < argc) {
247         const char* arg = argv[i++];
248         if (strcmp(arg, "--zygote") == 0) {
249             zygote = true;
250             niceName = ZYGOTE_NICE_NAME;
251         } else if (strcmp(arg, "--start-system-server") == 0) {
252             startSystemServer = true;
253         } else if (strcmp(arg, "--application") == 0) {
254             application = true;
255         } else if (strncmp(arg, "--nice-name=", 12) == 0) {
256             niceName.setTo(arg + 12);
257         } else if (strncmp(arg, "--", 2) != 0) {
258             className.setTo(arg);
259             break;
260         } else {
261             --i;
262             break;
263         }
264     }
265 
266     Vector<String8> args;
267     if (!className.isEmpty()) {
268         // We're not in zygote mode, the only argument we need to pass
269         // to RuntimeInit is the application argument.
270         //
271         // The Remainder of args get passed to startup class main(). Make
272         // copies of them before we overwrite them with the process name.
273         args.add(application ? String8("application") : String8("tool"));
274         runtime.setClassNameAndArgs(className, argc - i, argv + i);
275     } else {
276         // We're in zygote mode.
277         maybeCreateDalvikCache();
278 
279         if (startSystemServer) {
280             args.add(String8("start-system-server"));
281         }
282 
283         char prop[PROP_VALUE_MAX];
284         if (property_get(ABI_LIST_PROPERTY, prop, NULL) == 0) {
285             LOG_ALWAYS_FATAL("app_process: Unable to determine ABI list from property %s.",
286                 ABI_LIST_PROPERTY);
287             return 11;
288         }
289 
290         String8 abiFlag("--abi-list=");
291         abiFlag.append(prop);
292         args.add(abiFlag);
293 
294         // In zygote mode, pass all remaining arguments to the zygote
295         // main() method.
296         for (; i < argc; ++i) {
297             args.add(String8(argv[i]));
298         }
299     }
300 
301     if (!niceName.isEmpty()) {
302         runtime.setArgv0(niceName.string());
303         set_process_name(niceName.string());
304     }
305 
306     if (zygote) {
307         runtime.start("com.android.internal.os.ZygoteInit", args, zygote);
308     } else if (className) {
309         runtime.start("com.android.internal.os.RuntimeInit", args, zygote);
310     } else {
311         fprintf(stderr, "Error: no class name or --zygote supplied.\n");
312         app_usage();
313         LOG_ALWAYS_FATAL("app_process: no class name or --zygote supplied.");
314         return 10;
315     }
316 }
317