1 /*
2  * Copyright (C) 2006 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #define LOG_TAG "AndroidRuntime"
18 //#define LOG_NDEBUG 0
19 
20 #include <android_runtime/AndroidRuntime.h>
21 #include <binder/IBinder.h>
22 #include <binder/IPCThreadState.h>
23 #include <binder/IServiceManager.h>
24 #include <utils/Log.h>
25 #include <utils/misc.h>
26 #include <binder/Parcel.h>
27 #include <utils/threads.h>
28 #include <cutils/properties.h>
29 
30 #include <SkGraphics.h>
31 #include <SkImageDecoder.h>
32 
33 #include "jni.h"
34 #include "JNIHelp.h"
35 #include "JniInvocation.h"
36 #include "android_util_Binder.h"
37 
38 #include <stdio.h>
39 #include <signal.h>
40 #include <sys/stat.h>
41 #include <sys/types.h>
42 #include <signal.h>
43 #include <dirent.h>
44 #include <assert.h>
45 
46 #include <string>
47 #include <vector>
48 
49 
50 using namespace android;
51 
52 extern int register_android_os_Binder(JNIEnv* env);
53 extern int register_android_os_Process(JNIEnv* env);
54 extern int register_android_graphics_Bitmap(JNIEnv*);
55 extern int register_android_graphics_BitmapFactory(JNIEnv*);
56 extern int register_android_graphics_BitmapRegionDecoder(JNIEnv*);
57 extern int register_android_graphics_Camera(JNIEnv* env);
58 extern int register_android_graphics_CreateJavaOutputStreamAdaptor(JNIEnv* env);
59 extern int register_android_graphics_Graphics(JNIEnv* env);
60 extern int register_android_graphics_Interpolator(JNIEnv* env);
61 extern int register_android_graphics_MaskFilter(JNIEnv* env);
62 extern int register_android_graphics_Movie(JNIEnv* env);
63 extern int register_android_graphics_NinePatch(JNIEnv*);
64 extern int register_android_graphics_PathEffect(JNIEnv* env);
65 extern int register_android_graphics_Shader(JNIEnv* env);
66 extern int register_android_graphics_Typeface(JNIEnv* env);
67 extern int register_android_graphics_YuvImage(JNIEnv* env);
68 
69 extern int register_com_google_android_gles_jni_EGLImpl(JNIEnv* env);
70 extern int register_com_google_android_gles_jni_GLImpl(JNIEnv* env);
71 extern int register_android_opengl_jni_EGL14(JNIEnv* env);
72 extern int register_android_opengl_jni_EGLExt(JNIEnv* env);
73 extern int register_android_opengl_jni_GLES10(JNIEnv* env);
74 extern int register_android_opengl_jni_GLES10Ext(JNIEnv* env);
75 extern int register_android_opengl_jni_GLES11(JNIEnv* env);
76 extern int register_android_opengl_jni_GLES11Ext(JNIEnv* env);
77 extern int register_android_opengl_jni_GLES20(JNIEnv* env);
78 extern int register_android_opengl_jni_GLES30(JNIEnv* env);
79 extern int register_android_opengl_jni_GLES31(JNIEnv* env);
80 extern int register_android_opengl_jni_GLES31Ext(JNIEnv* env);
81 
82 extern int register_android_hardware_Camera(JNIEnv *env);
83 extern int register_android_hardware_camera2_CameraMetadata(JNIEnv *env);
84 extern int register_android_hardware_camera2_legacy_LegacyCameraDevice(JNIEnv *env);
85 extern int register_android_hardware_camera2_legacy_PerfMeasurement(JNIEnv *env);
86 extern int register_android_hardware_camera2_DngCreator(JNIEnv *env);
87 extern int register_android_hardware_Radio(JNIEnv *env);
88 extern int register_android_hardware_SensorManager(JNIEnv *env);
89 extern int register_android_hardware_SerialPort(JNIEnv *env);
90 extern int register_android_hardware_SoundTrigger(JNIEnv *env);
91 extern int register_android_hardware_UsbDevice(JNIEnv *env);
92 extern int register_android_hardware_UsbDeviceConnection(JNIEnv *env);
93 extern int register_android_hardware_UsbRequest(JNIEnv *env);
94 extern int register_android_hardware_location_ActivityRecognitionHardware(JNIEnv* env);
95 
96 extern int register_android_media_AudioRecord(JNIEnv *env);
97 extern int register_android_media_AudioSystem(JNIEnv *env);
98 extern int register_android_media_AudioTrack(JNIEnv *env);
99 extern int register_android_media_JetPlayer(JNIEnv *env);
100 extern int register_android_media_ToneGenerator(JNIEnv *env);
101 
102 namespace android {
103 
104 /*
105  * JNI-based registration functions.  Note these are properly contained in
106  * namespace android.
107  */
108 extern int register_android_content_AssetManager(JNIEnv* env);
109 extern int register_android_util_EventLog(JNIEnv* env);
110 extern int register_android_util_Log(JNIEnv* env);
111 extern int register_android_content_StringBlock(JNIEnv* env);
112 extern int register_android_content_XmlBlock(JNIEnv* env);
113 extern int register_android_emoji_EmojiFactory(JNIEnv* env);
114 extern int register_android_graphics_Canvas(JNIEnv* env);
115 extern int register_android_graphics_CanvasProperty(JNIEnv* env);
116 extern int register_android_graphics_ColorFilter(JNIEnv* env);
117 extern int register_android_graphics_DrawFilter(JNIEnv* env);
118 extern int register_android_graphics_FontFamily(JNIEnv* env);
119 extern int register_android_graphics_LayerRasterizer(JNIEnv*);
120 extern int register_android_graphics_Matrix(JNIEnv* env);
121 extern int register_android_graphics_Paint(JNIEnv* env);
122 extern int register_android_graphics_Path(JNIEnv* env);
123 extern int register_android_graphics_PathMeasure(JNIEnv* env);
124 extern int register_android_graphics_Picture(JNIEnv*);
125 extern int register_android_graphics_PorterDuff(JNIEnv* env);
126 extern int register_android_graphics_Rasterizer(JNIEnv* env);
127 extern int register_android_graphics_Region(JNIEnv* env);
128 extern int register_android_graphics_SurfaceTexture(JNIEnv* env);
129 extern int register_android_graphics_Xfermode(JNIEnv* env);
130 extern int register_android_graphics_pdf_PdfDocument(JNIEnv* env);
131 extern int register_android_graphics_pdf_PdfEditor(JNIEnv* env);
132 extern int register_android_graphics_pdf_PdfRenderer(JNIEnv* env);
133 extern int register_android_view_DisplayEventReceiver(JNIEnv* env);
134 extern int register_android_view_DisplayListCanvas(JNIEnv* env);
135 extern int register_android_view_GraphicBuffer(JNIEnv* env);
136 extern int register_android_view_HardwareLayer(JNIEnv* env);
137 extern int register_android_view_RenderNode(JNIEnv* env);
138 extern int register_android_view_RenderNodeAnimator(JNIEnv* env);
139 extern int register_android_view_Surface(JNIEnv* env);
140 extern int register_android_view_SurfaceControl(JNIEnv* env);
141 extern int register_android_view_SurfaceSession(JNIEnv* env);
142 extern int register_android_view_TextureView(JNIEnv* env);
143 extern int register_android_view_ThreadedRenderer(JNIEnv* env);
144 extern int register_com_android_internal_view_animation_NativeInterpolatorFactoryHelper(JNIEnv *env);
145 extern int register_android_database_CursorWindow(JNIEnv* env);
146 extern int register_android_database_SQLiteConnection(JNIEnv* env);
147 extern int register_android_database_SQLiteGlobal(JNIEnv* env);
148 extern int register_android_database_SQLiteDebug(JNIEnv* env);
149 extern int register_android_nio_utils(JNIEnv* env);
150 extern int register_android_os_Debug(JNIEnv* env);
151 extern int register_android_os_MessageQueue(JNIEnv* env);
152 extern int register_android_os_Parcel(JNIEnv* env);
153 extern int register_android_os_SELinux(JNIEnv* env);
154 extern int register_android_os_SystemProperties(JNIEnv *env);
155 extern int register_android_os_SystemClock(JNIEnv* env);
156 extern int register_android_os_Trace(JNIEnv* env);
157 extern int register_android_os_FileObserver(JNIEnv *env);
158 extern int register_android_os_UEventObserver(JNIEnv* env);
159 extern int register_android_os_MemoryFile(JNIEnv* env);
160 extern int register_android_net_LocalSocketImpl(JNIEnv* env);
161 extern int register_android_net_NetworkUtils(JNIEnv* env);
162 extern int register_android_net_TrafficStats(JNIEnv* env);
163 extern int register_android_text_AndroidCharacter(JNIEnv *env);
164 extern int register_android_text_StaticLayout(JNIEnv *env);
165 extern int register_android_text_AndroidBidi(JNIEnv *env);
166 extern int register_android_opengl_classes(JNIEnv *env);
167 extern int register_android_ddm_DdmHandleNativeHeap(JNIEnv *env);
168 extern int register_android_server_NetworkManagementSocketTagger(JNIEnv* env);
169 extern int register_android_backup_BackupDataInput(JNIEnv *env);
170 extern int register_android_backup_BackupDataOutput(JNIEnv *env);
171 extern int register_android_backup_FileBackupHelperBase(JNIEnv *env);
172 extern int register_android_backup_BackupHelperDispatcher(JNIEnv *env);
173 extern int register_android_app_backup_FullBackup(JNIEnv *env);
174 extern int register_android_app_ActivityThread(JNIEnv *env);
175 extern int register_android_app_NativeActivity(JNIEnv *env);
176 extern int register_android_media_RemoteDisplay(JNIEnv *env);
177 extern int register_android_view_InputChannel(JNIEnv* env);
178 extern int register_android_view_InputDevice(JNIEnv* env);
179 extern int register_android_view_InputEventReceiver(JNIEnv* env);
180 extern int register_android_view_InputEventSender(JNIEnv* env);
181 extern int register_android_view_InputQueue(JNIEnv* env);
182 extern int register_android_view_KeyCharacterMap(JNIEnv *env);
183 extern int register_android_view_KeyEvent(JNIEnv* env);
184 extern int register_android_view_MotionEvent(JNIEnv* env);
185 extern int register_android_view_PointerIcon(JNIEnv* env);
186 extern int register_android_view_VelocityTracker(JNIEnv* env);
187 extern int register_android_content_res_ObbScanner(JNIEnv* env);
188 extern int register_android_content_res_Configuration(JNIEnv* env);
189 extern int register_android_animation_PropertyValuesHolder(JNIEnv *env);
190 extern int register_com_android_internal_content_NativeLibraryHelper(JNIEnv *env);
191 extern int register_com_android_internal_net_NetworkStatsFactory(JNIEnv *env);
192 extern int register_com_android_internal_os_Zygote(JNIEnv *env);
193 extern int register_com_android_internal_util_VirtualRefBasePtr(JNIEnv *env);
194 
195 static AndroidRuntime* gCurRuntime = NULL;
196 
197 /*
198  * Code written in the Java Programming Language calls here from main().
199  */
com_android_internal_os_RuntimeInit_nativeFinishInit(JNIEnv * env,jobject clazz)200 static void com_android_internal_os_RuntimeInit_nativeFinishInit(JNIEnv* env, jobject clazz)
201 {
202     gCurRuntime->onStarted();
203 }
204 
com_android_internal_os_RuntimeInit_nativeZygoteInit(JNIEnv * env,jobject clazz)205 static void com_android_internal_os_RuntimeInit_nativeZygoteInit(JNIEnv* env, jobject clazz)
206 {
207     gCurRuntime->onZygoteInit();
208 }
209 
com_android_internal_os_RuntimeInit_nativeSetExitWithoutCleanup(JNIEnv * env,jobject clazz,jboolean exitWithoutCleanup)210 static void com_android_internal_os_RuntimeInit_nativeSetExitWithoutCleanup(JNIEnv* env,
211         jobject clazz, jboolean exitWithoutCleanup)
212 {
213     gCurRuntime->setExitWithoutCleanup(exitWithoutCleanup);
214 }
215 
216 /*
217  * JNI registration.
218  */
219 static JNINativeMethod gMethods[] = {
220     { "nativeFinishInit", "()V",
221         (void*) com_android_internal_os_RuntimeInit_nativeFinishInit },
222     { "nativeZygoteInit", "()V",
223         (void*) com_android_internal_os_RuntimeInit_nativeZygoteInit },
224     { "nativeSetExitWithoutCleanup", "(Z)V",
225         (void*) com_android_internal_os_RuntimeInit_nativeSetExitWithoutCleanup },
226 };
227 
register_com_android_internal_os_RuntimeInit(JNIEnv * env)228 int register_com_android_internal_os_RuntimeInit(JNIEnv* env)
229 {
230     return jniRegisterNativeMethods(env, "com/android/internal/os/RuntimeInit",
231         gMethods, NELEM(gMethods));
232 }
233 
234 // ----------------------------------------------------------------------
235 
236 /*static*/ JavaVM* AndroidRuntime::mJavaVM = NULL;
237 
AndroidRuntime(char * argBlockStart,const size_t argBlockLength)238 AndroidRuntime::AndroidRuntime(char* argBlockStart, const size_t argBlockLength) :
239         mExitWithoutCleanup(false),
240         mArgBlockStart(argBlockStart),
241         mArgBlockLength(argBlockLength)
242 {
243     SkGraphics::Init();
244     // There is also a global font cache, but its budget is specified by
245     // SK_DEFAULT_FONT_CACHE_COUNT_LIMIT and SK_DEFAULT_FONT_CACHE_LIMIT.
246 
247     // Pre-allocate enough space to hold a fair number of options.
248     mOptions.setCapacity(20);
249 
250     assert(gCurRuntime == NULL);        // one per process
251     gCurRuntime = this;
252 }
253 
~AndroidRuntime()254 AndroidRuntime::~AndroidRuntime()
255 {
256     SkGraphics::Term();
257 }
258 
259 /*
260  * Register native methods using JNI.
261  */
registerNativeMethods(JNIEnv * env,const char * className,const JNINativeMethod * gMethods,int numMethods)262 /*static*/ int AndroidRuntime::registerNativeMethods(JNIEnv* env,
263     const char* className, const JNINativeMethod* gMethods, int numMethods)
264 {
265     return jniRegisterNativeMethods(env, className, gMethods, numMethods);
266 }
267 
setArgv0(const char * argv0)268 void AndroidRuntime::setArgv0(const char* argv0) {
269     memset(mArgBlockStart, 0, mArgBlockLength);
270     strlcpy(mArgBlockStart, argv0, mArgBlockLength);
271 }
272 
callMain(const String8 & className,jclass clazz,const Vector<String8> & args)273 status_t AndroidRuntime::callMain(const String8& className, jclass clazz,
274     const Vector<String8>& args)
275 {
276     JNIEnv* env;
277     jmethodID methodId;
278 
279     ALOGD("Calling main entry %s", className.string());
280 
281     env = getJNIEnv();
282     if (clazz == NULL || env == NULL) {
283         return UNKNOWN_ERROR;
284     }
285 
286     methodId = env->GetStaticMethodID(clazz, "main", "([Ljava/lang/String;)V");
287     if (methodId == NULL) {
288         ALOGE("ERROR: could not find method %s.main(String[])\n", className.string());
289         return UNKNOWN_ERROR;
290     }
291 
292     /*
293      * We want to call main() with a String array with our arguments in it.
294      * Create an array and populate it.
295      */
296     jclass stringClass;
297     jobjectArray strArray;
298 
299     const size_t numArgs = args.size();
300     stringClass = env->FindClass("java/lang/String");
301     strArray = env->NewObjectArray(numArgs, stringClass, NULL);
302 
303     for (size_t i = 0; i < numArgs; i++) {
304         jstring argStr = env->NewStringUTF(args[i].string());
305         env->SetObjectArrayElement(strArray, i, argStr);
306     }
307 
308     env->CallStaticVoidMethod(clazz, methodId, strArray);
309     return NO_ERROR;
310 }
311 
312 /*
313  * The VM calls this through the "exit" hook.
314  */
runtime_exit(int code)315 static void runtime_exit(int code)
316 {
317     gCurRuntime->exit(code);
318 }
319 
320 /*
321  * The VM calls this through the "vfprintf" hook.
322  *
323  * We ignore "fp" and just write the results to the log file.
324  */
runtime_vfprintf(FILE * fp,const char * format,va_list ap)325 static void runtime_vfprintf(FILE* fp, const char* format, va_list ap)
326 {
327     LOG_PRI_VA(ANDROID_LOG_INFO, "vm-printf", format, ap);
328 }
329 
330 /**
331  * The VM calls this when mutex contention debugging is enabled to
332  * determine whether or not the blocked thread was a "sensitive thread"
333  * for user responsiveness/smoothess.
334  *
335  * Our policy for this is whether or not we're tracing any StrictMode
336  * events on this thread (which we might've inherited via Binder calls
337  * into us)
338  */
runtime_isSensitiveThread()339 static bool runtime_isSensitiveThread() {
340     IPCThreadState* state = IPCThreadState::selfOrNull();
341     return state && state->getStrictModePolicy() != 0;
342 }
343 
hasDir(const char * dir)344 static int hasDir(const char* dir)
345 {
346     struct stat s;
347     int res = stat(dir, &s);
348     if (res == 0) {
349         return S_ISDIR(s.st_mode);
350     }
351     return 0;
352 }
353 
hasFile(const char * file)354 static bool hasFile(const char* file) {
355     struct stat s;
356     int res = stat(file, &s);
357     if (res == 0) {
358         return S_ISREG(s.st_mode);
359     }
360     return false;
361 }
362 
363 // Convenience wrapper over the property API that returns an
364 // std::string.
getProperty(const char * key,const char * defaultValue)365 std::string getProperty(const char* key, const char* defaultValue) {
366     std::vector<char> temp(PROPERTY_VALUE_MAX);
367     const int len = property_get(key, &temp[0], defaultValue);
368     if (len < 0) {
369         return "";
370     }
371     return std::string(&temp[0], len);
372 }
373 
374 /*
375  * Read the persistent locale. Inspects the following system properties
376  * (in order) and returns the first non-empty property in the list :
377  *
378  * (1) persist.sys.locale
379  * (2) persist.sys.language/country/localevar (country and localevar are
380  * inspected iff. language is non-empty.
381  * (3) ro.product.locale
382  * (4) ro.product.locale.language/region
383  *
384  * Note that we need to inspect persist.sys.language/country/localevar to
385  * preserve language settings for devices that are upgrading from Lollipop
386  * to M. The same goes for ro.product.locale.language/region as well.
387  */
readLocale()388 const std::string readLocale()
389 {
390     const std::string locale = getProperty("persist.sys.locale", "");
391     if (!locale.empty()) {
392         return locale;
393     }
394 
395     const std::string language = getProperty("persist.sys.language", "");
396     if (!language.empty()) {
397         const std::string country = getProperty("persist.sys.country", "");
398         const std::string variant = getProperty("persist.sys.localevar", "");
399 
400         std::string out = language;
401         if (!country.empty()) {
402             out = out + "-" + country;
403         }
404 
405         if (!variant.empty()) {
406             out = out + "-" + variant;
407         }
408 
409         return out;
410     }
411 
412     const std::string productLocale = getProperty("ro.product.locale", "");
413     if (!productLocale.empty()) {
414         return productLocale;
415     }
416 
417     // If persist.sys.locale and ro.product.locale are missing,
418     // construct a locale value from the individual locale components.
419     const std::string productLanguage = getProperty("ro.product.locale.language", "en");
420     const std::string productRegion = getProperty("ro.product.locale.region", "US");
421 
422     return productLanguage + "-" + productRegion;
423 }
424 
addOption(const char * optionString,void * extraInfo)425 void AndroidRuntime::addOption(const char* optionString, void* extraInfo)
426 {
427     JavaVMOption opt;
428     opt.optionString = optionString;
429     opt.extraInfo = extraInfo;
430     mOptions.add(opt);
431 }
432 
433 /*
434  * Parse a property containing space-separated options that should be
435  * passed directly to the VM, e.g. "-Xmx32m -verbose:gc -Xregenmap".
436  *
437  * This will cut up "extraOptsBuf" as we chop it into individual options.
438  *
439  * If "quotingArg" is non-null, it is passed before each extra option in mOptions.
440  *
441  * Adds the strings, if any, to mOptions.
442  */
parseExtraOpts(char * extraOptsBuf,const char * quotingArg)443 void AndroidRuntime::parseExtraOpts(char* extraOptsBuf, const char* quotingArg)
444 {
445     char* start = extraOptsBuf;
446     char* end = NULL;
447     while (*start != '\0') {
448         while (*start == ' ')                   /* skip leading whitespace */
449             start++;
450         if (*start == '\0')                     /* was trailing ws, bail */
451             break;
452 
453         end = start+1;
454         while (*end != ' ' && *end != '\0')     /* find end of token */
455             end++;
456         if (*end == ' ')
457             *end++ = '\0';          /* mark end, advance to indicate more */
458 
459         if (quotingArg != NULL) {
460             addOption(quotingArg);
461         }
462         addOption(start);
463         start = end;
464     }
465 }
466 
467 /*
468  * Reads a "property" into "buffer" with a default of "defaultArg". If
469  * the property is non-empty, it is treated as a runtime option such
470  * as "-Xmx32m".
471  *
472  * The "runtimeArg" is a prefix for the option such as "-Xms" or "-Xmx".
473  *
474  * If an argument is found, it is added to mOptions.
475  *
476  * If an option is found, it is added to mOptions and true is
477  * returned. Otherwise false is returned.
478  */
parseRuntimeOption(const char * property,char * buffer,const char * runtimeArg,const char * defaultArg)479 bool AndroidRuntime::parseRuntimeOption(const char* property,
480                                         char* buffer,
481                                         const char* runtimeArg,
482                                         const char* defaultArg)
483 {
484     strcpy(buffer, runtimeArg);
485     size_t runtimeArgLen = strlen(runtimeArg);
486     property_get(property, buffer+runtimeArgLen, defaultArg);
487     if (buffer[runtimeArgLen] == '\0') {
488         return false;
489     }
490     addOption(buffer);
491     return true;
492 }
493 
494 /*
495  * Reads a "property" into "buffer". If the property is non-empty, it
496  * is treated as a dex2oat compiler option that should be
497  * passed as a quoted option, e.g. "-Ximage-compiler-option --compiler-filter=verify-none".
498  *
499  * The "compilerArg" is a prefix for the option such as "--compiler-filter=".
500  *
501  * The "quotingArg" should be "-Ximage-compiler-option" or "-Xcompiler-option".
502  *
503  * If an option is found, it is added to mOptions and true is
504  * returned. Otherwise false is returned.
505  */
parseCompilerOption(const char * property,char * buffer,const char * compilerArg,const char * quotingArg)506 bool AndroidRuntime::parseCompilerOption(const char* property,
507                                          char* buffer,
508                                          const char* compilerArg,
509                                          const char* quotingArg)
510 {
511     strcpy(buffer, compilerArg);
512     size_t compilerArgLen = strlen(compilerArg);
513     property_get(property, buffer+compilerArgLen, "");
514     if (buffer[compilerArgLen] == '\0') {
515         return false;
516     }
517     addOption(quotingArg);
518     addOption(buffer);
519     return true;
520 }
521 
522 /*
523  * Reads a "property" into "buffer". If the property is non-empty, it
524  * is treated as a dex2oat compiler runtime option that should be
525  * passed as a quoted option, e.g. "-Ximage-compiler-option
526  * --runtime-arg -Ximage-compiler-option -Xmx32m".
527  *
528  * The "runtimeArg" is a prefix for the option such as "-Xms" or "-Xmx".
529  *
530  * The "quotingArg" should be "-Ximage-compiler-option" or "-Xcompiler-option".
531  *
532  * If an option is found, it is added to mOptions and true is
533  * returned. Otherwise false is returned.
534  */
parseCompilerRuntimeOption(const char * property,char * buffer,const char * runtimeArg,const char * quotingArg)535 bool AndroidRuntime::parseCompilerRuntimeOption(const char* property,
536                                                 char* buffer,
537                                                 const char* runtimeArg,
538                                                 const char* quotingArg)
539 {
540     strcpy(buffer, runtimeArg);
541     size_t runtimeArgLen = strlen(runtimeArg);
542     property_get(property, buffer+runtimeArgLen, "");
543     if (buffer[runtimeArgLen] == '\0') {
544         return false;
545     }
546     addOption(quotingArg);
547     addOption("--runtime-arg");
548     addOption(quotingArg);
549     addOption(buffer);
550     return true;
551 }
552 
553 /*
554  * Start the Dalvik Virtual Machine.
555  *
556  * Various arguments, most determined by system properties, are passed in.
557  * The "mOptions" vector is updated.
558  *
559  * CAUTION: when adding options in here, be careful not to put the
560  * char buffer inside a nested scope.  Adding the buffer to the
561  * options using mOptions.add() does not copy the buffer, so if the
562  * buffer goes out of scope the option may be overwritten.  It's best
563  * to put the buffer at the top of the function so that it is more
564  * unlikely that someone will surround it in a scope at a later time
565  * and thus introduce a bug.
566  *
567  * Returns 0 on success.
568  */
startVm(JavaVM ** pJavaVM,JNIEnv ** pEnv,bool zygote)569 int AndroidRuntime::startVm(JavaVM** pJavaVM, JNIEnv** pEnv, bool zygote)
570 {
571     JavaVMInitArgs initArgs;
572     char propBuf[PROPERTY_VALUE_MAX];
573     char stackTraceFileBuf[sizeof("-Xstacktracefile:")-1 + PROPERTY_VALUE_MAX];
574     char jniOptsBuf[sizeof("-Xjniopts:")-1 + PROPERTY_VALUE_MAX];
575     char heapstartsizeOptsBuf[sizeof("-Xms")-1 + PROPERTY_VALUE_MAX];
576     char heapsizeOptsBuf[sizeof("-Xmx")-1 + PROPERTY_VALUE_MAX];
577     char heapgrowthlimitOptsBuf[sizeof("-XX:HeapGrowthLimit=")-1 + PROPERTY_VALUE_MAX];
578     char heapminfreeOptsBuf[sizeof("-XX:HeapMinFree=")-1 + PROPERTY_VALUE_MAX];
579     char heapmaxfreeOptsBuf[sizeof("-XX:HeapMaxFree=")-1 + PROPERTY_VALUE_MAX];
580     char usejitOptsBuf[sizeof("-Xusejit:")-1 + PROPERTY_VALUE_MAX];
581     char jitcodecachesizeOptsBuf[sizeof("-Xjitcodecachesize:")-1 + PROPERTY_VALUE_MAX];
582     char jitthresholdOptsBuf[sizeof("-Xjitthreshold:")-1 + PROPERTY_VALUE_MAX];
583     char gctypeOptsBuf[sizeof("-Xgc:")-1 + PROPERTY_VALUE_MAX];
584     char backgroundgcOptsBuf[sizeof("-XX:BackgroundGC=")-1 + PROPERTY_VALUE_MAX];
585     char heaptargetutilizationOptsBuf[sizeof("-XX:HeapTargetUtilization=")-1 + PROPERTY_VALUE_MAX];
586     char cachePruneBuf[sizeof("-Xzygote-max-boot-retry=")-1 + PROPERTY_VALUE_MAX];
587     char dex2oatXmsImageFlagsBuf[sizeof("-Xms")-1 + PROPERTY_VALUE_MAX];
588     char dex2oatXmxImageFlagsBuf[sizeof("-Xmx")-1 + PROPERTY_VALUE_MAX];
589     char dex2oatXmsFlagsBuf[sizeof("-Xms")-1 + PROPERTY_VALUE_MAX];
590     char dex2oatXmxFlagsBuf[sizeof("-Xmx")-1 + PROPERTY_VALUE_MAX];
591     char dex2oatCompilerFilterBuf[sizeof("--compiler-filter=")-1 + PROPERTY_VALUE_MAX];
592     char dex2oatImageCompilerFilterBuf[sizeof("--compiler-filter=")-1 + PROPERTY_VALUE_MAX];
593     char dex2oatThreadsBuf[sizeof("-j")-1 + PROPERTY_VALUE_MAX];
594     char dex2oatThreadsImageBuf[sizeof("-j")-1 + PROPERTY_VALUE_MAX];
595     char dex2oat_isa_variant_key[PROPERTY_KEY_MAX];
596     char dex2oat_isa_variant[sizeof("--instruction-set-variant=") -1 + PROPERTY_VALUE_MAX];
597     char dex2oat_isa_features_key[PROPERTY_KEY_MAX];
598     char dex2oat_isa_features[sizeof("--instruction-set-features=") -1 + PROPERTY_VALUE_MAX];
599     char dex2oatFlagsBuf[PROPERTY_VALUE_MAX];
600     char dex2oatImageFlagsBuf[PROPERTY_VALUE_MAX];
601     char extraOptsBuf[PROPERTY_VALUE_MAX];
602     char voldDecryptBuf[PROPERTY_VALUE_MAX];
603     enum {
604       kEMDefault,
605       kEMIntPortable,
606       kEMIntFast,
607       kEMJitCompiler,
608     } executionMode = kEMDefault;
609     char profilePeriod[sizeof("-Xprofile-period:")-1 + PROPERTY_VALUE_MAX];
610     char profileDuration[sizeof("-Xprofile-duration:")-1 + PROPERTY_VALUE_MAX];
611     char profileInterval[sizeof("-Xprofile-interval:")-1 + PROPERTY_VALUE_MAX];
612     char profileBackoff[sizeof("-Xprofile-backoff:")-1 + PROPERTY_VALUE_MAX];
613     char profileTopKThreshold[sizeof("-Xprofile-top-k-threshold:")-1 + PROPERTY_VALUE_MAX];
614     char profileTopKChangeThreshold[sizeof("-Xprofile-top-k-change-threshold:")-1 +
615                                     PROPERTY_VALUE_MAX];
616     char profileType[sizeof("-Xprofile-type:")-1 + PROPERTY_VALUE_MAX];
617     char profileMaxStackDepth[sizeof("-Xprofile-max-stack-depth:")-1 + PROPERTY_VALUE_MAX];
618     char localeOption[sizeof("-Duser.locale=") + PROPERTY_VALUE_MAX];
619     char lockProfThresholdBuf[sizeof("-Xlockprofthreshold:")-1 + PROPERTY_VALUE_MAX];
620     char nativeBridgeLibrary[sizeof("-XX:NativeBridge=") + PROPERTY_VALUE_MAX];
621     char cpuAbiListBuf[sizeof("--cpu-abilist=") + PROPERTY_VALUE_MAX];
622     char methodTraceFileBuf[sizeof("-Xmethod-trace-file:") + PROPERTY_VALUE_MAX];
623     char methodTraceFileSizeBuf[sizeof("-Xmethod-trace-file-size:") + PROPERTY_VALUE_MAX];
624     char fingerprintBuf[sizeof("-Xfingerprint:") + PROPERTY_VALUE_MAX];
625 
626     bool checkJni = false;
627     property_get("dalvik.vm.checkjni", propBuf, "");
628     if (strcmp(propBuf, "true") == 0) {
629         checkJni = true;
630     } else if (strcmp(propBuf, "false") != 0) {
631         /* property is neither true nor false; fall back on kernel parameter */
632         property_get("ro.kernel.android.checkjni", propBuf, "");
633         if (propBuf[0] == '1') {
634             checkJni = true;
635         }
636     }
637     ALOGD("CheckJNI is %s\n", checkJni ? "ON" : "OFF");
638     if (checkJni) {
639         /* extended JNI checking */
640         addOption("-Xcheck:jni");
641 
642         /* with -Xcheck:jni, this provides a JNI function call trace */
643         //addOption("-verbose:jni");
644     }
645 
646     property_get("dalvik.vm.execution-mode", propBuf, "");
647     if (strcmp(propBuf, "int:portable") == 0) {
648         executionMode = kEMIntPortable;
649     } else if (strcmp(propBuf, "int:fast") == 0) {
650         executionMode = kEMIntFast;
651     } else if (strcmp(propBuf, "int:jit") == 0) {
652         executionMode = kEMJitCompiler;
653     }
654 
655     parseRuntimeOption("dalvik.vm.stack-trace-file", stackTraceFileBuf, "-Xstacktracefile:");
656 
657     strcpy(jniOptsBuf, "-Xjniopts:");
658     if (parseRuntimeOption("dalvik.vm.jniopts", jniOptsBuf, "-Xjniopts:")) {
659         ALOGI("JNI options: '%s'\n", jniOptsBuf);
660     }
661 
662     /* route exit() to our handler */
663     addOption("exit", (void*) runtime_exit);
664 
665     /* route fprintf() to our handler */
666     addOption("vfprintf", (void*) runtime_vfprintf);
667 
668     /* register the framework-specific "is sensitive thread" hook */
669     addOption("sensitiveThread", (void*) runtime_isSensitiveThread);
670 
671     /* enable verbose; standard options are { jni, gc, class } */
672     //addOption("-verbose:jni");
673     addOption("-verbose:gc");
674     //addOption("-verbose:class");
675 
676     /*
677      * The default starting and maximum size of the heap.  Larger
678      * values should be specified in a product property override.
679      */
680     parseRuntimeOption("dalvik.vm.heapstartsize", heapstartsizeOptsBuf, "-Xms", "4m");
681     parseRuntimeOption("dalvik.vm.heapsize", heapsizeOptsBuf, "-Xmx", "16m");
682 
683     parseRuntimeOption("dalvik.vm.heapgrowthlimit", heapgrowthlimitOptsBuf, "-XX:HeapGrowthLimit=");
684     parseRuntimeOption("dalvik.vm.heapminfree", heapminfreeOptsBuf, "-XX:HeapMinFree=");
685     parseRuntimeOption("dalvik.vm.heapmaxfree", heapmaxfreeOptsBuf, "-XX:HeapMaxFree=");
686     parseRuntimeOption("dalvik.vm.heaptargetutilization",
687                        heaptargetutilizationOptsBuf,
688                        "-XX:HeapTargetUtilization=");
689 
690     /*
691      * JIT related options.
692      */
693     parseRuntimeOption("dalvik.vm.usejit", usejitOptsBuf, "-Xusejit:");
694     parseRuntimeOption("dalvik.vm.jitcodecachesize", jitcodecachesizeOptsBuf, "-Xjitcodecachesize:");
695     parseRuntimeOption("dalvik.vm.jitthreshold", jitthresholdOptsBuf, "-Xjitthreshold:");
696 
697     property_get("ro.config.low_ram", propBuf, "");
698     if (strcmp(propBuf, "true") == 0) {
699       addOption("-XX:LowMemoryMode");
700     }
701 
702     parseRuntimeOption("dalvik.vm.gctype", gctypeOptsBuf, "-Xgc:");
703     parseRuntimeOption("dalvik.vm.backgroundgctype", backgroundgcOptsBuf, "-XX:BackgroundGC=");
704 
705     /*
706      * Enable debugging only for apps forked from zygote.
707      * Set suspend=y to pause during VM init and use android ADB transport.
708      */
709     if (zygote) {
710       addOption("-agentlib:jdwp=transport=dt_android_adb,suspend=n,server=y");
711     }
712 
713     parseRuntimeOption("dalvik.vm.lockprof.threshold",
714                        lockProfThresholdBuf,
715                        "-Xlockprofthreshold:");
716 
717     if (executionMode == kEMIntPortable) {
718         addOption("-Xint:portable");
719     } else if (executionMode == kEMIntFast) {
720         addOption("-Xint:fast");
721     } else if (executionMode == kEMJitCompiler) {
722         addOption("-Xint:jit");
723     }
724 
725     // If we are booting without the real /data, don't spend time compiling.
726     property_get("vold.decrypt", voldDecryptBuf, "");
727     bool skip_compilation = ((strcmp(voldDecryptBuf, "trigger_restart_min_framework") == 0) ||
728                              (strcmp(voldDecryptBuf, "1") == 0));
729 
730     // Extra options for boot.art/boot.oat image generation.
731     parseCompilerRuntimeOption("dalvik.vm.image-dex2oat-Xms", dex2oatXmsImageFlagsBuf,
732                                "-Xms", "-Ximage-compiler-option");
733     parseCompilerRuntimeOption("dalvik.vm.image-dex2oat-Xmx", dex2oatXmxImageFlagsBuf,
734                                "-Xmx", "-Ximage-compiler-option");
735     if (skip_compilation) {
736         addOption("-Ximage-compiler-option");
737         addOption("--compiler-filter=verify-none");
738     } else {
739         parseCompilerOption("dalvik.vm.image-dex2oat-filter", dex2oatImageCompilerFilterBuf,
740                             "--compiler-filter=", "-Ximage-compiler-option");
741     }
742 
743     // Make sure there is a preloaded-classes file.
744     if (!hasFile("/system/etc/preloaded-classes")) {
745         ALOGE("Missing preloaded-classes file, /system/etc/preloaded-classes not found: %s\n",
746               strerror(errno));
747         return -1;
748     }
749     addOption("-Ximage-compiler-option");
750     addOption("--image-classes=/system/etc/preloaded-classes");
751 
752     // If there is a compiled-classes file, push it.
753     if (hasFile("/system/etc/compiled-classes")) {
754         addOption("-Ximage-compiler-option");
755         addOption("--compiled-classes=/system/etc/compiled-classes");
756     }
757 
758     property_get("dalvik.vm.image-dex2oat-flags", dex2oatImageFlagsBuf, "");
759     parseExtraOpts(dex2oatImageFlagsBuf, "-Ximage-compiler-option");
760 
761     // Extra options for DexClassLoader.
762     parseCompilerRuntimeOption("dalvik.vm.dex2oat-Xms", dex2oatXmsFlagsBuf,
763                                "-Xms", "-Xcompiler-option");
764     parseCompilerRuntimeOption("dalvik.vm.dex2oat-Xmx", dex2oatXmxFlagsBuf,
765                                "-Xmx", "-Xcompiler-option");
766     if (skip_compilation) {
767         addOption("-Xcompiler-option");
768         addOption("--compiler-filter=verify-none");
769 
770         // We skip compilation when a minimal runtime is brought up for decryption. In that case
771         // /data is temporarily backed by a tmpfs, which is usually small.
772         // If the system image contains prebuilts, they will be relocated into the tmpfs. In this
773         // specific situation it is acceptable to *not* relocate and run out of the prebuilts
774         // directly instead.
775         addOption("--runtime-arg");
776         addOption("-Xnorelocate");
777     } else {
778         parseCompilerOption("dalvik.vm.dex2oat-filter", dex2oatCompilerFilterBuf,
779                             "--compiler-filter=", "-Xcompiler-option");
780     }
781     parseCompilerOption("dalvik.vm.dex2oat-threads", dex2oatThreadsBuf, "-j", "-Xcompiler-option");
782     parseCompilerOption("dalvik.vm.image-dex2oat-threads", dex2oatThreadsImageBuf, "-j",
783                         "-Ximage-compiler-option");
784 
785     // The runtime will compile a boot image, when necessary, not using installd. Thus, we need to
786     // pass the instruction-set-features/variant as an image-compiler-option.
787     // TODO: Find a better way for the instruction-set.
788 #if defined(__arm__)
789     constexpr const char* instruction_set = "arm";
790 #elif defined(__aarch64__)
791     constexpr const char* instruction_set = "arm64";
792 #elif defined(__mips__) && !defined(__LP64__)
793     constexpr const char* instruction_set = "mips";
794 #elif defined(__mips__) && defined(__LP64__)
795     constexpr const char* instruction_set = "mips64";
796 #elif defined(__i386__)
797     constexpr const char* instruction_set = "x86";
798 #elif defined(__x86_64__)
799     constexpr const char* instruction_set = "x86_64";
800 #else
801     constexpr const char* instruction_set = "unknown";
802 #endif
803     // Note: it is OK to reuse the buffer, as the values are exactly the same between
804     //       * compiler-option, used for runtime compilation (DexClassLoader)
805     //       * image-compiler-option, used for boot-image compilation on device
806 
807     // Copy the variant.
808     sprintf(dex2oat_isa_variant_key, "dalvik.vm.isa.%s.variant", instruction_set);
809     parseCompilerOption(dex2oat_isa_variant_key, dex2oat_isa_variant,
810                         "--instruction-set-variant=", "-Ximage-compiler-option");
811     parseCompilerOption(dex2oat_isa_variant_key, dex2oat_isa_variant,
812                         "--instruction-set-variant=", "-Xcompiler-option");
813     // Copy the features.
814     sprintf(dex2oat_isa_features_key, "dalvik.vm.isa.%s.features", instruction_set);
815     parseCompilerOption(dex2oat_isa_features_key, dex2oat_isa_features,
816                         "--instruction-set-features=", "-Ximage-compiler-option");
817     parseCompilerOption(dex2oat_isa_features_key, dex2oat_isa_features,
818                         "--instruction-set-features=", "-Xcompiler-option");
819 
820 
821     property_get("dalvik.vm.dex2oat-flags", dex2oatFlagsBuf, "");
822     parseExtraOpts(dex2oatFlagsBuf, "-Xcompiler-option");
823 
824     /* extra options; parse this late so it overrides others */
825     property_get("dalvik.vm.extra-opts", extraOptsBuf, "");
826     parseExtraOpts(extraOptsBuf, NULL);
827 
828     /* Set the properties for locale */
829     {
830         strcpy(localeOption, "-Duser.locale=");
831         const std::string locale = readLocale();
832         strncat(localeOption, locale.c_str(), PROPERTY_VALUE_MAX);
833         addOption(localeOption);
834     }
835 
836     /*
837      * Set profiler options
838      */
839     // Whether or not the profiler should be enabled.
840     property_get("dalvik.vm.profiler", propBuf, "0");
841     if (propBuf[0] == '1') {
842         addOption("-Xenable-profiler");
843     }
844 
845     // Whether the profile should start upon app startup or be delayed by some random offset
846     // (in seconds) that is bound between 0 and a fixed value.
847     property_get("dalvik.vm.profile.start-immed", propBuf, "0");
848     if (propBuf[0] == '1') {
849         addOption("-Xprofile-start-immediately");
850     }
851 
852     // Number of seconds during profile runs.
853     parseRuntimeOption("dalvik.vm.profile.period-secs", profilePeriod, "-Xprofile-period:");
854 
855     // Length of each profile run (seconds).
856     parseRuntimeOption("dalvik.vm.profile.duration-secs",
857                        profileDuration,
858                        "-Xprofile-duration:");
859 
860     // Polling interval during profile run (microseconds).
861     parseRuntimeOption("dalvik.vm.profile.interval-us", profileInterval, "-Xprofile-interval:");
862 
863     // Coefficient for period backoff.  The the period is multiplied
864     // by this value after each profile run.
865     parseRuntimeOption("dalvik.vm.profile.backoff-coeff", profileBackoff, "-Xprofile-backoff:");
866 
867     // Top K% of samples that are considered relevant when
868     // deciding if the app should be recompiled.
869     parseRuntimeOption("dalvik.vm.profile.top-k-thr",
870                        profileTopKThreshold,
871                        "-Xprofile-top-k-threshold:");
872 
873     // The threshold after which a change in the structure of the
874     // top K% profiled samples becomes significant and triggers
875     // recompilation. A change in profile is considered
876     // significant if X% (top-k-change-threshold) of the top K%
877     // (top-k-threshold property) samples has changed.
878     parseRuntimeOption("dalvik.vm.profile.top-k-ch-thr",
879                        profileTopKChangeThreshold,
880                        "-Xprofile-top-k-change-threshold:");
881 
882     // Type of profile data.
883     parseRuntimeOption("dalvik.vm.profiler.type", profileType, "-Xprofile-type:");
884 
885     // Depth of bounded stack data
886     parseRuntimeOption("dalvik.vm.profile.stack-depth",
887                        profileMaxStackDepth,
888                        "-Xprofile-max-stack-depth:");
889 
890     /*
891      * Tracing options.
892      */
893     property_get("dalvik.vm.method-trace", propBuf, "false");
894     if (strcmp(propBuf, "true") == 0) {
895         addOption("-Xmethod-trace");
896         parseRuntimeOption("dalvik.vm.method-trace-file",
897                            methodTraceFileBuf,
898                            "-Xmethod-trace-file:");
899         parseRuntimeOption("dalvik.vm.method-trace-file-siz",
900                            methodTraceFileSizeBuf,
901                            "-Xmethod-trace-file-size:");
902         property_get("dalvik.vm.method-trace-stream", propBuf, "false");
903         if (strcmp(propBuf, "true") == 0) {
904             addOption("-Xmethod-trace-stream");
905         }
906     }
907 
908     // Native bridge library. "0" means that native bridge is disabled.
909     property_get("ro.dalvik.vm.native.bridge", propBuf, "");
910     if (propBuf[0] == '\0') {
911         ALOGW("ro.dalvik.vm.native.bridge is not expected to be empty");
912     } else if (strcmp(propBuf, "0") != 0) {
913         snprintf(nativeBridgeLibrary, sizeof("-XX:NativeBridge=") + PROPERTY_VALUE_MAX,
914                  "-XX:NativeBridge=%s", propBuf);
915         addOption(nativeBridgeLibrary);
916     }
917 
918 #if defined(__LP64__)
919     const char* cpu_abilist_property_name = "ro.product.cpu.abilist64";
920 #else
921     const char* cpu_abilist_property_name = "ro.product.cpu.abilist32";
922 #endif  // defined(__LP64__)
923     property_get(cpu_abilist_property_name, propBuf, "");
924     if (propBuf[0] == '\0') {
925         ALOGE("%s is not expected to be empty", cpu_abilist_property_name);
926         return -1;
927     }
928     snprintf(cpuAbiListBuf, sizeof(cpuAbiListBuf), "--cpu-abilist=%s", propBuf);
929     addOption(cpuAbiListBuf);
930 
931     // Dalvik-cache pruning counter.
932     parseRuntimeOption("dalvik.vm.zygote.max-boot-retry", cachePruneBuf,
933                        "-Xzygote-max-boot-retry=");
934 
935     /*
936      * When running with debug.generate-debug-info, add --generate-debug-info to
937      * the compiler options so that the boot image, if it is compiled on device,
938      * will include native debugging information.
939      */
940     property_get("debug.generate-debug-info", propBuf, "");
941     if (strcmp(propBuf, "true") == 0) {
942         addOption("-Xcompiler-option");
943         addOption("--generate-debug-info");
944         addOption("-Ximage-compiler-option");
945         addOption("--generate-debug-info");
946     }
947 
948     /*
949      * Retrieve the build fingerprint and provide it to the runtime. That way, ANR dumps will
950      * contain the fingerprint and can be parsed.
951      */
952     parseRuntimeOption("ro.build.fingerprint", fingerprintBuf, "-Xfingerprint:");
953 
954     initArgs.version = JNI_VERSION_1_4;
955     initArgs.options = mOptions.editArray();
956     initArgs.nOptions = mOptions.size();
957     initArgs.ignoreUnrecognized = JNI_FALSE;
958 
959     /*
960      * Initialize the VM.
961      *
962      * The JavaVM* is essentially per-process, and the JNIEnv* is per-thread.
963      * If this call succeeds, the VM is ready, and we can start issuing
964      * JNI calls.
965      */
966     if (JNI_CreateJavaVM(pJavaVM, pEnv, &initArgs) < 0) {
967         ALOGE("JNI_CreateJavaVM failed\n");
968         return -1;
969     }
970 
971     return 0;
972 }
973 
toSlashClassName(const char * className)974 char* AndroidRuntime::toSlashClassName(const char* className)
975 {
976     char* result = strdup(className);
977     for (char* cp = result; *cp != '\0'; cp++) {
978         if (*cp == '.') {
979             *cp = '/';
980         }
981     }
982     return result;
983 }
984 
985 /** Create a Java string from an ASCII or Latin-1 string */
NewStringLatin1(JNIEnv * env,const char * bytes)986 jstring AndroidRuntime::NewStringLatin1(JNIEnv* env, const char* bytes) {
987     if (!bytes) return NULL;
988     int length = strlen(bytes);
989     jchar* buffer = (jchar *)alloca(length * sizeof(jchar));
990     if (!buffer) return NULL;
991     jchar* chp = buffer;
992     for (int i = 0; i < length; i++) {
993         *chp++ = *bytes++;
994     }
995     return env->NewString(buffer, length);
996 }
997 
998 
999 /*
1000  * Start the Android runtime.  This involves starting the virtual machine
1001  * and calling the "static void main(String[] args)" method in the class
1002  * named by "className".
1003  *
1004  * Passes the main function two arguments, the class name and the specified
1005  * options string.
1006  */
start(const char * className,const Vector<String8> & options,bool zygote)1007 void AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote)
1008 {
1009     ALOGD(">>>>>> START %s uid %d <<<<<<\n",
1010             className != NULL ? className : "(unknown)", getuid());
1011 
1012     static const String8 startSystemServer("start-system-server");
1013 
1014     /*
1015      * 'startSystemServer == true' means runtime is obsolete and not run from
1016      * init.rc anymore, so we print out the boot start event here.
1017      */
1018     for (size_t i = 0; i < options.size(); ++i) {
1019         if (options[i] == startSystemServer) {
1020            /* track our progress through the boot sequence */
1021            const int LOG_BOOT_PROGRESS_START = 3000;
1022            LOG_EVENT_LONG(LOG_BOOT_PROGRESS_START,  ns2ms(systemTime(SYSTEM_TIME_MONOTONIC)));
1023         }
1024     }
1025 
1026     const char* rootDir = getenv("ANDROID_ROOT");
1027     if (rootDir == NULL) {
1028         rootDir = "/system";
1029         if (!hasDir("/system")) {
1030             LOG_FATAL("No root directory specified, and /android does not exist.");
1031             return;
1032         }
1033         setenv("ANDROID_ROOT", rootDir, 1);
1034     }
1035 
1036     //const char* kernelHack = getenv("LD_ASSUME_KERNEL");
1037     //ALOGD("Found LD_ASSUME_KERNEL='%s'\n", kernelHack);
1038 
1039     /* start the virtual machine */
1040     JniInvocation jni_invocation;
1041     jni_invocation.Init(NULL);
1042     JNIEnv* env;
1043     if (startVm(&mJavaVM, &env, zygote) != 0) {
1044         return;
1045     }
1046     onVmCreated(env);
1047 
1048     /*
1049      * Register android functions.
1050      */
1051     if (startReg(env) < 0) {
1052         ALOGE("Unable to register all android natives\n");
1053         return;
1054     }
1055 
1056     /*
1057      * We want to call main() with a String array with arguments in it.
1058      * At present we have two arguments, the class name and an option string.
1059      * Create an array to hold them.
1060      */
1061     jclass stringClass;
1062     jobjectArray strArray;
1063     jstring classNameStr;
1064 
1065     stringClass = env->FindClass("java/lang/String");
1066     assert(stringClass != NULL);
1067     strArray = env->NewObjectArray(options.size() + 1, stringClass, NULL);
1068     assert(strArray != NULL);
1069     classNameStr = env->NewStringUTF(className);
1070     assert(classNameStr != NULL);
1071     env->SetObjectArrayElement(strArray, 0, classNameStr);
1072 
1073     for (size_t i = 0; i < options.size(); ++i) {
1074         jstring optionsStr = env->NewStringUTF(options.itemAt(i).string());
1075         assert(optionsStr != NULL);
1076         env->SetObjectArrayElement(strArray, i + 1, optionsStr);
1077     }
1078 
1079     /*
1080      * Start VM.  This thread becomes the main thread of the VM, and will
1081      * not return until the VM exits.
1082      */
1083     char* slashClassName = toSlashClassName(className);
1084     jclass startClass = env->FindClass(slashClassName);
1085     if (startClass == NULL) {
1086         ALOGE("JavaVM unable to locate class '%s'\n", slashClassName);
1087         /* keep going */
1088     } else {
1089         jmethodID startMeth = env->GetStaticMethodID(startClass, "main",
1090             "([Ljava/lang/String;)V");
1091         if (startMeth == NULL) {
1092             ALOGE("JavaVM unable to find main() in '%s'\n", className);
1093             /* keep going */
1094         } else {
1095             env->CallStaticVoidMethod(startClass, startMeth, strArray);
1096 
1097 #if 0
1098             if (env->ExceptionCheck())
1099                 threadExitUncaughtException(env);
1100 #endif
1101         }
1102     }
1103     free(slashClassName);
1104 
1105     ALOGD("Shutting down VM\n");
1106     if (mJavaVM->DetachCurrentThread() != JNI_OK)
1107         ALOGW("Warning: unable to detach main thread\n");
1108     if (mJavaVM->DestroyJavaVM() != 0)
1109         ALOGW("Warning: VM did not shut down cleanly\n");
1110 }
1111 
exit(int code)1112 void AndroidRuntime::exit(int code)
1113 {
1114     if (mExitWithoutCleanup) {
1115         ALOGI("VM exiting with result code %d, cleanup skipped.", code);
1116         ::_exit(code);
1117     } else {
1118         ALOGI("VM exiting with result code %d.", code);
1119         onExit(code);
1120         ::exit(code);
1121     }
1122 }
1123 
onVmCreated(JNIEnv * env)1124 void AndroidRuntime::onVmCreated(JNIEnv* env)
1125 {
1126     // If AndroidRuntime had anything to do here, we'd have done it in 'start'.
1127 }
1128 
1129 /*
1130  * Get the JNIEnv pointer for this thread.
1131  *
1132  * Returns NULL if the slot wasn't allocated or populated.
1133  */
getJNIEnv()1134 /*static*/ JNIEnv* AndroidRuntime::getJNIEnv()
1135 {
1136     JNIEnv* env;
1137     JavaVM* vm = AndroidRuntime::getJavaVM();
1138     assert(vm != NULL);
1139 
1140     if (vm->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK)
1141         return NULL;
1142     return env;
1143 }
1144 
1145 /*
1146  * Makes the current thread visible to the VM.
1147  *
1148  * The JNIEnv pointer returned is only valid for the current thread, and
1149  * thus must be tucked into thread-local storage.
1150  */
javaAttachThread(const char * threadName,JNIEnv ** pEnv)1151 static int javaAttachThread(const char* threadName, JNIEnv** pEnv)
1152 {
1153     JavaVMAttachArgs args;
1154     JavaVM* vm;
1155     jint result;
1156 
1157     vm = AndroidRuntime::getJavaVM();
1158     assert(vm != NULL);
1159 
1160     args.version = JNI_VERSION_1_4;
1161     args.name = (char*) threadName;
1162     args.group = NULL;
1163 
1164     result = vm->AttachCurrentThread(pEnv, (void*) &args);
1165     if (result != JNI_OK)
1166         ALOGI("NOTE: attach of thread '%s' failed\n", threadName);
1167 
1168     return result;
1169 }
1170 
1171 /*
1172  * Detach the current thread from the set visible to the VM.
1173  */
javaDetachThread(void)1174 static int javaDetachThread(void)
1175 {
1176     JavaVM* vm;
1177     jint result;
1178 
1179     vm = AndroidRuntime::getJavaVM();
1180     assert(vm != NULL);
1181 
1182     result = vm->DetachCurrentThread();
1183     if (result != JNI_OK)
1184         ALOGE("ERROR: thread detach failed\n");
1185     return result;
1186 }
1187 
1188 /*
1189  * When starting a native thread that will be visible from the VM, we
1190  * bounce through this to get the right attach/detach action.
1191  * Note that this function calls free(args)
1192  */
javaThreadShell(void * args)1193 /*static*/ int AndroidRuntime::javaThreadShell(void* args) {
1194     void* start = ((void**)args)[0];
1195     void* userData = ((void **)args)[1];
1196     char* name = (char*) ((void **)args)[2];        // we own this storage
1197     free(args);
1198     JNIEnv* env;
1199     int result;
1200 
1201     /* hook us into the VM */
1202     if (javaAttachThread(name, &env) != JNI_OK)
1203         return -1;
1204 
1205     /* start the thread running */
1206     result = (*(android_thread_func_t)start)(userData);
1207 
1208     /* unhook us */
1209     javaDetachThread();
1210     free(name);
1211 
1212     return result;
1213 }
1214 
1215 /*
1216  * This is invoked from androidCreateThreadEtc() via the callback
1217  * set with androidSetCreateThreadFunc().
1218  *
1219  * We need to create the new thread in such a way that it gets hooked
1220  * into the VM before it really starts executing.
1221  */
javaCreateThreadEtc(android_thread_func_t entryFunction,void * userData,const char * threadName,int32_t threadPriority,size_t threadStackSize,android_thread_id_t * threadId)1222 /*static*/ int AndroidRuntime::javaCreateThreadEtc(
1223                                 android_thread_func_t entryFunction,
1224                                 void* userData,
1225                                 const char* threadName,
1226                                 int32_t threadPriority,
1227                                 size_t threadStackSize,
1228                                 android_thread_id_t* threadId)
1229 {
1230     void** args = (void**) malloc(3 * sizeof(void*));   // javaThreadShell must free
1231     int result;
1232 
1233     if (!threadName)
1234         threadName = "unnamed thread";
1235 
1236     args[0] = (void*) entryFunction;
1237     args[1] = userData;
1238     args[2] = (void*) strdup(threadName);   // javaThreadShell must free
1239 
1240     result = androidCreateRawThreadEtc(AndroidRuntime::javaThreadShell, args,
1241         threadName, threadPriority, threadStackSize, threadId);
1242     return result;
1243 }
1244 
1245 /*
1246  * Create a thread that is visible from the VM.
1247  *
1248  * This is called from elsewhere in the library.
1249  */
createJavaThread(const char * name,void (* start)(void *),void * arg)1250 /*static*/ android_thread_id_t AndroidRuntime::createJavaThread(const char* name,
1251     void (*start)(void *), void* arg)
1252 {
1253     android_thread_id_t threadId = 0;
1254     javaCreateThreadEtc((android_thread_func_t) start, arg, name,
1255         ANDROID_PRIORITY_DEFAULT, 0, &threadId);
1256     return threadId;
1257 }
1258 
1259 #if 0
1260 static void quickTest(void* arg)
1261 {
1262     const char* str = (const char*) arg;
1263 
1264     printf("In quickTest: %s\n", str);
1265 }
1266 #endif
1267 
1268 #ifdef NDEBUG
1269     #define REG_JNI(name)      { name }
1270     struct RegJNIRec {
1271         int (*mProc)(JNIEnv*);
1272     };
1273 #else
1274     #define REG_JNI(name)      { name, #name }
1275     struct RegJNIRec {
1276         int (*mProc)(JNIEnv*);
1277         const char* mName;
1278     };
1279 #endif
1280 
1281 typedef void (*RegJAMProc)();
1282 
register_jni_procs(const RegJNIRec array[],size_t count,JNIEnv * env)1283 static int register_jni_procs(const RegJNIRec array[], size_t count, JNIEnv* env)
1284 {
1285     for (size_t i = 0; i < count; i++) {
1286         if (array[i].mProc(env) < 0) {
1287 #ifndef NDEBUG
1288             ALOGD("----------!!! %s failed to load\n", array[i].mName);
1289 #endif
1290             return -1;
1291         }
1292     }
1293     return 0;
1294 }
1295 
1296 static const RegJNIRec gRegJNI[] = {
1297     REG_JNI(register_com_android_internal_os_RuntimeInit),
1298     REG_JNI(register_android_os_SystemClock),
1299     REG_JNI(register_android_util_EventLog),
1300     REG_JNI(register_android_util_Log),
1301     REG_JNI(register_android_content_AssetManager),
1302     REG_JNI(register_android_content_StringBlock),
1303     REG_JNI(register_android_content_XmlBlock),
1304     REG_JNI(register_android_emoji_EmojiFactory),
1305     REG_JNI(register_android_text_AndroidCharacter),
1306     REG_JNI(register_android_text_StaticLayout),
1307     REG_JNI(register_android_text_AndroidBidi),
1308     REG_JNI(register_android_view_InputDevice),
1309     REG_JNI(register_android_view_KeyCharacterMap),
1310     REG_JNI(register_android_os_Process),
1311     REG_JNI(register_android_os_SystemProperties),
1312     REG_JNI(register_android_os_Binder),
1313     REG_JNI(register_android_os_Parcel),
1314     REG_JNI(register_android_nio_utils),
1315     REG_JNI(register_android_graphics_Graphics),
1316     REG_JNI(register_android_view_DisplayEventReceiver),
1317     REG_JNI(register_android_view_RenderNode),
1318     REG_JNI(register_android_view_RenderNodeAnimator),
1319     REG_JNI(register_android_view_GraphicBuffer),
1320     REG_JNI(register_android_view_DisplayListCanvas),
1321     REG_JNI(register_android_view_HardwareLayer),
1322     REG_JNI(register_android_view_ThreadedRenderer),
1323     REG_JNI(register_android_view_Surface),
1324     REG_JNI(register_android_view_SurfaceControl),
1325     REG_JNI(register_android_view_SurfaceSession),
1326     REG_JNI(register_android_view_TextureView),
1327     REG_JNI(register_com_android_internal_view_animation_NativeInterpolatorFactoryHelper),
1328     REG_JNI(register_com_google_android_gles_jni_EGLImpl),
1329     REG_JNI(register_com_google_android_gles_jni_GLImpl),
1330     REG_JNI(register_android_opengl_jni_EGL14),
1331     REG_JNI(register_android_opengl_jni_EGLExt),
1332     REG_JNI(register_android_opengl_jni_GLES10),
1333     REG_JNI(register_android_opengl_jni_GLES10Ext),
1334     REG_JNI(register_android_opengl_jni_GLES11),
1335     REG_JNI(register_android_opengl_jni_GLES11Ext),
1336     REG_JNI(register_android_opengl_jni_GLES20),
1337     REG_JNI(register_android_opengl_jni_GLES30),
1338     REG_JNI(register_android_opengl_jni_GLES31),
1339     REG_JNI(register_android_opengl_jni_GLES31Ext),
1340 
1341     REG_JNI(register_android_graphics_Bitmap),
1342     REG_JNI(register_android_graphics_BitmapFactory),
1343     REG_JNI(register_android_graphics_BitmapRegionDecoder),
1344     REG_JNI(register_android_graphics_Camera),
1345     REG_JNI(register_android_graphics_CreateJavaOutputStreamAdaptor),
1346     REG_JNI(register_android_graphics_Canvas),
1347     REG_JNI(register_android_graphics_CanvasProperty),
1348     REG_JNI(register_android_graphics_ColorFilter),
1349     REG_JNI(register_android_graphics_DrawFilter),
1350     REG_JNI(register_android_graphics_FontFamily),
1351     REG_JNI(register_android_graphics_Interpolator),
1352     REG_JNI(register_android_graphics_LayerRasterizer),
1353     REG_JNI(register_android_graphics_MaskFilter),
1354     REG_JNI(register_android_graphics_Matrix),
1355     REG_JNI(register_android_graphics_Movie),
1356     REG_JNI(register_android_graphics_NinePatch),
1357     REG_JNI(register_android_graphics_Paint),
1358     REG_JNI(register_android_graphics_Path),
1359     REG_JNI(register_android_graphics_PathMeasure),
1360     REG_JNI(register_android_graphics_PathEffect),
1361     REG_JNI(register_android_graphics_Picture),
1362     REG_JNI(register_android_graphics_PorterDuff),
1363     REG_JNI(register_android_graphics_Rasterizer),
1364     REG_JNI(register_android_graphics_Region),
1365     REG_JNI(register_android_graphics_Shader),
1366     REG_JNI(register_android_graphics_SurfaceTexture),
1367     REG_JNI(register_android_graphics_Typeface),
1368     REG_JNI(register_android_graphics_Xfermode),
1369     REG_JNI(register_android_graphics_YuvImage),
1370     REG_JNI(register_android_graphics_pdf_PdfDocument),
1371     REG_JNI(register_android_graphics_pdf_PdfEditor),
1372     REG_JNI(register_android_graphics_pdf_PdfRenderer),
1373 
1374     REG_JNI(register_android_database_CursorWindow),
1375     REG_JNI(register_android_database_SQLiteConnection),
1376     REG_JNI(register_android_database_SQLiteGlobal),
1377     REG_JNI(register_android_database_SQLiteDebug),
1378     REG_JNI(register_android_os_Debug),
1379     REG_JNI(register_android_os_FileObserver),
1380     REG_JNI(register_android_os_MessageQueue),
1381     REG_JNI(register_android_os_SELinux),
1382     REG_JNI(register_android_os_Trace),
1383     REG_JNI(register_android_os_UEventObserver),
1384     REG_JNI(register_android_net_LocalSocketImpl),
1385     REG_JNI(register_android_net_NetworkUtils),
1386     REG_JNI(register_android_net_TrafficStats),
1387     REG_JNI(register_android_os_MemoryFile),
1388     REG_JNI(register_com_android_internal_os_Zygote),
1389     REG_JNI(register_com_android_internal_util_VirtualRefBasePtr),
1390     REG_JNI(register_android_hardware_Camera),
1391     REG_JNI(register_android_hardware_camera2_CameraMetadata),
1392     REG_JNI(register_android_hardware_camera2_legacy_LegacyCameraDevice),
1393     REG_JNI(register_android_hardware_camera2_legacy_PerfMeasurement),
1394     REG_JNI(register_android_hardware_camera2_DngCreator),
1395     REG_JNI(register_android_hardware_Radio),
1396     REG_JNI(register_android_hardware_SensorManager),
1397     REG_JNI(register_android_hardware_SerialPort),
1398     REG_JNI(register_android_hardware_SoundTrigger),
1399     REG_JNI(register_android_hardware_UsbDevice),
1400     REG_JNI(register_android_hardware_UsbDeviceConnection),
1401     REG_JNI(register_android_hardware_UsbRequest),
1402     REG_JNI(register_android_hardware_location_ActivityRecognitionHardware),
1403     REG_JNI(register_android_media_AudioRecord),
1404     REG_JNI(register_android_media_AudioSystem),
1405     REG_JNI(register_android_media_AudioTrack),
1406     REG_JNI(register_android_media_JetPlayer),
1407     REG_JNI(register_android_media_RemoteDisplay),
1408     REG_JNI(register_android_media_ToneGenerator),
1409 
1410     REG_JNI(register_android_opengl_classes),
1411     REG_JNI(register_android_server_NetworkManagementSocketTagger),
1412     REG_JNI(register_android_ddm_DdmHandleNativeHeap),
1413     REG_JNI(register_android_backup_BackupDataInput),
1414     REG_JNI(register_android_backup_BackupDataOutput),
1415     REG_JNI(register_android_backup_FileBackupHelperBase),
1416     REG_JNI(register_android_backup_BackupHelperDispatcher),
1417     REG_JNI(register_android_app_backup_FullBackup),
1418     REG_JNI(register_android_app_ActivityThread),
1419     REG_JNI(register_android_app_NativeActivity),
1420     REG_JNI(register_android_view_InputChannel),
1421     REG_JNI(register_android_view_InputEventReceiver),
1422     REG_JNI(register_android_view_InputEventSender),
1423     REG_JNI(register_android_view_InputQueue),
1424     REG_JNI(register_android_view_KeyEvent),
1425     REG_JNI(register_android_view_MotionEvent),
1426     REG_JNI(register_android_view_PointerIcon),
1427     REG_JNI(register_android_view_VelocityTracker),
1428 
1429     REG_JNI(register_android_content_res_ObbScanner),
1430     REG_JNI(register_android_content_res_Configuration),
1431 
1432     REG_JNI(register_android_animation_PropertyValuesHolder),
1433     REG_JNI(register_com_android_internal_content_NativeLibraryHelper),
1434     REG_JNI(register_com_android_internal_net_NetworkStatsFactory),
1435 };
1436 
1437 /*
1438  * Register android native functions with the VM.
1439  */
startReg(JNIEnv * env)1440 /*static*/ int AndroidRuntime::startReg(JNIEnv* env)
1441 {
1442     /*
1443      * This hook causes all future threads created in this process to be
1444      * attached to the JavaVM.  (This needs to go away in favor of JNI
1445      * Attach calls.)
1446      */
1447     androidSetCreateThreadFunc((android_create_thread_fn) javaCreateThreadEtc);
1448 
1449     ALOGV("--- registering native functions ---\n");
1450 
1451     /*
1452      * Every "register" function calls one or more things that return
1453      * a local reference (e.g. FindClass).  Because we haven't really
1454      * started the VM yet, they're all getting stored in the base frame
1455      * and never released.  Use Push/Pop to manage the storage.
1456      */
1457     env->PushLocalFrame(200);
1458 
1459     if (register_jni_procs(gRegJNI, NELEM(gRegJNI), env) < 0) {
1460         env->PopLocalFrame(NULL);
1461         return -1;
1462     }
1463     env->PopLocalFrame(NULL);
1464 
1465     //createJavaThread("fubar", quickTest, (void*) "hello");
1466 
1467     return 0;
1468 }
1469 
getRuntime()1470 AndroidRuntime* AndroidRuntime::getRuntime()
1471 {
1472     return gCurRuntime;
1473 }
1474 
1475 /**
1476  * Used by WithFramework to register native functions.
1477  */
1478 extern "C"
Java_com_android_internal_util_WithFramework_registerNatives(JNIEnv * env,jclass clazz)1479 jint Java_com_android_internal_util_WithFramework_registerNatives(
1480         JNIEnv* env, jclass clazz) {
1481     return register_jni_procs(gRegJNI, NELEM(gRegJNI), env);
1482 }
1483 
1484 /**
1485  * Used by LoadClass to register native functions.
1486  */
1487 extern "C"
Java_LoadClass_registerNatives(JNIEnv * env,jclass clazz)1488 jint Java_LoadClass_registerNatives(JNIEnv* env, jclass clazz) {
1489     return register_jni_procs(gRegJNI, NELEM(gRegJNI), env);
1490 }
1491 
1492 }   // namespace android
1493