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