1 /*
2 * Copyright (C) 2008 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 /*
18 * Dalvik initialization, shutdown, and command-line argument processing.
19 */
20 #define __STDC_LIMIT_MACROS
21 #include <stdlib.h>
22 #include <stdio.h>
23 #include <signal.h>
24 #include <limits.h>
25 #include <ctype.h>
26 #include <sys/wait.h>
27 #include <unistd.h>
28
29 #include "Dalvik.h"
30 #include "test/Test.h"
31 #include "mterp/Mterp.h"
32 #include "Hash.h"
33
34 #define kMinHeapStartSize (1*1024*1024)
35 #define kMinHeapSize (2*1024*1024)
36 #define kMaxHeapSize (1*1024*1024*1024)
37
38 /*
39 * Register VM-agnostic native methods for system classes.
40 */
41 extern int jniRegisterSystemMethods(JNIEnv* env);
42
43 /* fwd */
44 static bool registerSystemNatives(JNIEnv* pEnv);
45 static bool initJdwp();
46 static bool initZygote();
47
48
49 /* global state */
50 struct DvmGlobals gDvm;
51 struct DvmJniGlobals gDvmJni;
52
53 /* JIT-specific global state */
54 #if defined(WITH_JIT)
55 struct DvmJitGlobals gDvmJit;
56
57 #if defined(WITH_JIT_TUNING)
58 /*
59 * Track the number of hits in the inline cache for predicted chaining.
60 * Use an ugly global variable here since it is accessed in assembly code.
61 */
62 int gDvmICHitCount;
63 #endif
64
65 #endif
66
67 /*
68 * Show usage.
69 *
70 * We follow the tradition of unhyphenated compound words.
71 */
usage(const char * progName)72 static void usage(const char* progName)
73 {
74 dvmFprintf(stderr, "%s: [options] class [argument ...]\n", progName);
75 dvmFprintf(stderr, "%s: [options] -jar file.jar [argument ...]\n",progName);
76 dvmFprintf(stderr, "\n");
77 dvmFprintf(stderr, "The following standard options are recognized:\n");
78 dvmFprintf(stderr, " -classpath classpath\n");
79 dvmFprintf(stderr, " -Dproperty=value\n");
80 dvmFprintf(stderr, " -verbose:tag ('gc', 'jni', or 'class')\n");
81 dvmFprintf(stderr, " -ea[:<package name>... |:<class name>]\n");
82 dvmFprintf(stderr, " -da[:<package name>... |:<class name>]\n");
83 dvmFprintf(stderr, " (-enableassertions, -disableassertions)\n");
84 dvmFprintf(stderr, " -esa\n");
85 dvmFprintf(stderr, " -dsa\n");
86 dvmFprintf(stderr,
87 " (-enablesystemassertions, -disablesystemassertions)\n");
88 dvmFprintf(stderr, " -showversion\n");
89 dvmFprintf(stderr, " -help\n");
90 dvmFprintf(stderr, "\n");
91 dvmFprintf(stderr, "The following extended options are recognized:\n");
92 dvmFprintf(stderr, " -Xrunjdwp:<options>\n");
93 dvmFprintf(stderr, " -Xbootclasspath:bootclasspath\n");
94 dvmFprintf(stderr, " -Xcheck:tag (e.g. 'jni')\n");
95 dvmFprintf(stderr, " -XmsN (min heap, must be multiple of 1K, >= 1MB)\n");
96 dvmFprintf(stderr, " -XmxN (max heap, must be multiple of 1K, >= 2MB)\n");
97 dvmFprintf(stderr, " -XssN (stack size, >= %dKB, <= %dKB)\n",
98 kMinStackSize / 1024, kMaxStackSize / 1024);
99 dvmFprintf(stderr, " -Xverify:{none,remote,all}\n");
100 dvmFprintf(stderr, " -Xrs\n");
101 #if defined(WITH_JIT)
102 dvmFprintf(stderr,
103 " -Xint (extended to accept ':portable', ':fast' and ':jit')\n");
104 #else
105 dvmFprintf(stderr,
106 " -Xint (extended to accept ':portable' and ':fast')\n");
107 #endif
108 dvmFprintf(stderr, "\n");
109 dvmFprintf(stderr, "These are unique to Dalvik:\n");
110 dvmFprintf(stderr, " -Xzygote\n");
111 dvmFprintf(stderr, " -Xdexopt:{none,verified,all,full}\n");
112 dvmFprintf(stderr, " -Xnoquithandler\n");
113 dvmFprintf(stderr,
114 " -Xjnigreflimit:N (must be multiple of 100, >= 200)\n");
115 dvmFprintf(stderr, " -Xjniopts:{warnonly,forcecopy}\n");
116 dvmFprintf(stderr, " -Xjnitrace:substring (eg NativeClass or nativeMethod)\n");
117 dvmFprintf(stderr, " -Xstacktracefile:<filename>\n");
118 dvmFprintf(stderr, " -Xgc:[no]precise\n");
119 dvmFprintf(stderr, " -Xgc:[no]preverify\n");
120 dvmFprintf(stderr, " -Xgc:[no]postverify\n");
121 dvmFprintf(stderr, " -Xgc:[no]concurrent\n");
122 dvmFprintf(stderr, " -Xgc:[no]verifycardtable\n");
123 dvmFprintf(stderr, " -XX:+DisableExplicitGC\n");
124 dvmFprintf(stderr, " -X[no]genregmap\n");
125 dvmFprintf(stderr, " -Xverifyopt:[no]checkmon\n");
126 dvmFprintf(stderr, " -Xcheckdexsum\n");
127 #if defined(WITH_JIT)
128 dvmFprintf(stderr, " -Xincludeselectedop\n");
129 dvmFprintf(stderr, " -Xjitop:hexopvalue[-endvalue]"
130 "[,hexopvalue[-endvalue]]*\n");
131 dvmFprintf(stderr, " -Xincludeselectedmethod\n");
132 dvmFprintf(stderr, " -Xjitthreshold:decimalvalue\n");
133 dvmFprintf(stderr, " -Xjitblocking\n");
134 dvmFprintf(stderr, " -Xjitmethod:signature[,signature]* "
135 "(eg Ljava/lang/String\\;replace)\n");
136 dvmFprintf(stderr, " -Xjitcheckcg\n");
137 dvmFprintf(stderr, " -Xjitverbose\n");
138 dvmFprintf(stderr, " -Xjitprofile\n");
139 dvmFprintf(stderr, " -Xjitdisableopt\n");
140 dvmFprintf(stderr, " -Xjitsuspendpoll\n");
141 #endif
142 dvmFprintf(stderr, "\n");
143 dvmFprintf(stderr, "Configured with:"
144 " debugger"
145 " profiler"
146 " hprof"
147 #ifdef WITH_TRACKREF_CHECKS
148 " trackref_checks"
149 #endif
150 #ifdef WITH_INSTR_CHECKS
151 " instr_checks"
152 #endif
153 #ifdef WITH_EXTRA_OBJECT_VALIDATION
154 " extra_object_validation"
155 #endif
156 #ifdef WITH_EXTRA_GC_CHECKS
157 " extra_gc_checks"
158 #endif
159 #if !defined(NDEBUG) && defined(WITH_DALVIK_ASSERT)
160 " dalvik_assert"
161 #endif
162 #ifdef WITH_JNI_STACK_CHECK
163 " jni_stack_check"
164 #endif
165 #ifdef EASY_GDB
166 " easy_gdb"
167 #endif
168 #ifdef CHECK_MUTEX
169 " check_mutex"
170 #endif
171 #if defined(WITH_JIT)
172 " jit(" ARCH_VARIANT ")"
173 #endif
174 #if defined(WITH_SELF_VERIFICATION)
175 " self_verification"
176 #endif
177 #if ANDROID_SMP != 0
178 " smp"
179 #endif
180 );
181 #ifdef DVM_SHOW_EXCEPTION
182 dvmFprintf(stderr, " show_exception=%d", DVM_SHOW_EXCEPTION);
183 #endif
184 dvmFprintf(stderr, "\n\n");
185 }
186
187 /*
188 * Show helpful information on JDWP options.
189 */
showJdwpHelp()190 static void showJdwpHelp()
191 {
192 dvmFprintf(stderr,
193 "Example: -Xrunjdwp:transport=dt_socket,address=8000,server=y\n");
194 dvmFprintf(stderr,
195 "Example: -Xrunjdwp:transport=dt_socket,address=localhost:6500,server=n\n");
196 }
197
198 /*
199 * Show version and copyright info.
200 */
showVersion()201 static void showVersion()
202 {
203 dvmFprintf(stdout, "DalvikVM version %d.%d.%d\n",
204 DALVIK_MAJOR_VERSION, DALVIK_MINOR_VERSION, DALVIK_BUG_VERSION);
205 dvmFprintf(stdout,
206 "Copyright (C) 2007 The Android Open Source Project\n\n"
207 "This software is built from source code licensed under the "
208 "Apache License,\n"
209 "Version 2.0 (the \"License\"). You may obtain a copy of the "
210 "License at\n\n"
211 " http://www.apache.org/licenses/LICENSE-2.0\n\n"
212 "See the associated NOTICE file for this software for further "
213 "details.\n");
214 }
215
216 /*
217 * Parse a string of the form /[0-9]+[kKmMgG]?/, which is used to specify
218 * memory sizes. [kK] indicates kilobytes, [mM] megabytes, and
219 * [gG] gigabytes.
220 *
221 * "s" should point just past the "-Xm?" part of the string.
222 * "min" specifies the lowest acceptable value described by "s".
223 * "div" specifies a divisor, e.g. 1024 if the value must be a multiple
224 * of 1024.
225 *
226 * The spec says the -Xmx and -Xms options must be multiples of 1024. It
227 * doesn't say anything about -Xss.
228 *
229 * Returns 0 (a useless size) if "s" is malformed or specifies a low or
230 * non-evenly-divisible value.
231 */
parseMemOption(const char * s,size_t div)232 static size_t parseMemOption(const char *s, size_t div)
233 {
234 /* strtoul accepts a leading [+-], which we don't want,
235 * so make sure our string starts with a decimal digit.
236 */
237 if (isdigit(*s)) {
238 const char *s2;
239 size_t val;
240
241 val = strtoul(s, (char **)&s2, 10);
242 if (s2 != s) {
243 /* s2 should be pointing just after the number.
244 * If this is the end of the string, the user
245 * has specified a number of bytes. Otherwise,
246 * there should be exactly one more character
247 * that specifies a multiplier.
248 */
249 if (*s2 != '\0') {
250 char c;
251
252 /* The remainder of the string is either a single multiplier
253 * character, or nothing to indicate that the value is in
254 * bytes.
255 */
256 c = *s2++;
257 if (*s2 == '\0') {
258 size_t mul;
259
260 if (c == '\0') {
261 mul = 1;
262 } else if (c == 'k' || c == 'K') {
263 mul = 1024;
264 } else if (c == 'm' || c == 'M') {
265 mul = 1024 * 1024;
266 } else if (c == 'g' || c == 'G') {
267 mul = 1024 * 1024 * 1024;
268 } else {
269 /* Unknown multiplier character.
270 */
271 return 0;
272 }
273
274 if (val <= SIZE_MAX / mul) {
275 val *= mul;
276 } else {
277 /* Clamp to a multiple of 1024.
278 */
279 val = SIZE_MAX & ~(1024-1);
280 }
281 } else {
282 /* There's more than one character after the
283 * numeric part.
284 */
285 return 0;
286 }
287 }
288
289 /* The man page says that a -Xm value must be
290 * a multiple of 1024.
291 */
292 if (val % div == 0) {
293 return val;
294 }
295 }
296 }
297
298 return 0;
299 }
300
301 /*
302 * Handle one of the JDWP name/value pairs.
303 *
304 * JDWP options are:
305 * help: if specified, show help message and bail
306 * transport: may be dt_socket or dt_shmem
307 * address: for dt_socket, "host:port", or just "port" when listening
308 * server: if "y", wait for debugger to attach; if "n", attach to debugger
309 * timeout: how long to wait for debugger to connect / listen
310 *
311 * Useful with server=n (these aren't supported yet):
312 * onthrow=<exception-name>: connect to debugger when exception thrown
313 * onuncaught=y|n: connect to debugger when uncaught exception thrown
314 * launch=<command-line>: launch the debugger itself
315 *
316 * The "transport" option is required, as is "address" if server=n.
317 */
handleJdwpOption(const char * name,const char * value)318 static bool handleJdwpOption(const char* name, const char* value)
319 {
320 if (strcmp(name, "transport") == 0) {
321 if (strcmp(value, "dt_socket") == 0) {
322 gDvm.jdwpTransport = kJdwpTransportSocket;
323 } else if (strcmp(value, "dt_android_adb") == 0) {
324 gDvm.jdwpTransport = kJdwpTransportAndroidAdb;
325 } else {
326 ALOGE("JDWP transport '%s' not supported", value);
327 return false;
328 }
329 } else if (strcmp(name, "server") == 0) {
330 if (*value == 'n')
331 gDvm.jdwpServer = false;
332 else if (*value == 'y')
333 gDvm.jdwpServer = true;
334 else {
335 ALOGE("JDWP option 'server' must be 'y' or 'n'");
336 return false;
337 }
338 } else if (strcmp(name, "suspend") == 0) {
339 if (*value == 'n')
340 gDvm.jdwpSuspend = false;
341 else if (*value == 'y')
342 gDvm.jdwpSuspend = true;
343 else {
344 ALOGE("JDWP option 'suspend' must be 'y' or 'n'");
345 return false;
346 }
347 } else if (strcmp(name, "address") == 0) {
348 /* this is either <port> or <host>:<port> */
349 const char* colon = strchr(value, ':');
350 char* end;
351 long port;
352
353 if (colon != NULL) {
354 free(gDvm.jdwpHost);
355 gDvm.jdwpHost = (char*) malloc(colon - value +1);
356 strncpy(gDvm.jdwpHost, value, colon - value +1);
357 gDvm.jdwpHost[colon-value] = '\0';
358 value = colon + 1;
359 }
360 if (*value == '\0') {
361 ALOGE("JDWP address missing port");
362 return false;
363 }
364 port = strtol(value, &end, 10);
365 if (*end != '\0') {
366 ALOGE("JDWP address has junk in port field '%s'", value);
367 return false;
368 }
369 gDvm.jdwpPort = port;
370 } else if (strcmp(name, "launch") == 0 ||
371 strcmp(name, "onthrow") == 0 ||
372 strcmp(name, "oncaught") == 0 ||
373 strcmp(name, "timeout") == 0)
374 {
375 /* valid but unsupported */
376 ALOGI("Ignoring JDWP option '%s'='%s'", name, value);
377 } else {
378 ALOGI("Ignoring unrecognized JDWP option '%s'='%s'", name, value);
379 }
380
381 return true;
382 }
383
384 /*
385 * Parse the latter half of a -Xrunjdwp/-agentlib:jdwp= string, e.g.:
386 * "transport=dt_socket,address=8000,server=y,suspend=n"
387 */
parseJdwpOptions(const char * str)388 static bool parseJdwpOptions(const char* str)
389 {
390 char* mangle = strdup(str);
391 char* name = mangle;
392 bool result = false;
393
394 /*
395 * Process all of the name=value pairs.
396 */
397 while (true) {
398 char* value;
399 char* comma;
400
401 value = strchr(name, '=');
402 if (value == NULL) {
403 ALOGE("JDWP opts: garbage at '%s'", name);
404 goto bail;
405 }
406
407 comma = strchr(name, ','); // use name, not value, for safety
408 if (comma != NULL) {
409 if (comma < value) {
410 ALOGE("JDWP opts: found comma before '=' in '%s'", mangle);
411 goto bail;
412 }
413 *comma = '\0';
414 }
415
416 *value++ = '\0'; // stomp the '='
417
418 if (!handleJdwpOption(name, value))
419 goto bail;
420
421 if (comma == NULL) {
422 /* out of options */
423 break;
424 }
425 name = comma+1;
426 }
427
428 /*
429 * Make sure the combination of arguments makes sense.
430 */
431 if (gDvm.jdwpTransport == kJdwpTransportUnknown) {
432 ALOGE("JDWP opts: must specify transport");
433 goto bail;
434 }
435 if (!gDvm.jdwpServer && (gDvm.jdwpHost == NULL || gDvm.jdwpPort == 0)) {
436 ALOGE("JDWP opts: when server=n, must specify host and port");
437 goto bail;
438 }
439 // transport mandatory
440 // outbound server address
441
442 gDvm.jdwpConfigured = true;
443 result = true;
444
445 bail:
446 free(mangle);
447 return result;
448 }
449
450 /*
451 * Handle one of the four kinds of assertion arguments.
452 *
453 * "pkgOrClass" is the last part of an enable/disable line. For a package
454 * the arg looks like "-ea:com.google.fubar...", for a class it looks
455 * like "-ea:com.google.fubar.Wahoo". The string we get starts at the ':'.
456 *
457 * For system assertions (-esa/-dsa), "pkgOrClass" is NULL.
458 *
459 * Multiple instances of these arguments can be specified, e.g. you can
460 * enable assertions for a package and then disable them for one class in
461 * the package.
462 */
enableAssertions(const char * pkgOrClass,bool enable)463 static bool enableAssertions(const char* pkgOrClass, bool enable)
464 {
465 AssertionControl* pCtrl = &gDvm.assertionCtrl[gDvm.assertionCtrlCount++];
466 pCtrl->enable = enable;
467
468 if (pkgOrClass == NULL) {
469 /* enable or disable for all system classes */
470 pCtrl->isPackage = false;
471 pCtrl->pkgOrClass = NULL;
472 pCtrl->pkgOrClassLen = 0;
473 } else {
474 if (*pkgOrClass == '\0') {
475 /* global enable/disable for all but system */
476 pCtrl->isPackage = false;
477 pCtrl->pkgOrClass = strdup("");
478 pCtrl->pkgOrClassLen = 0;
479 } else {
480 pCtrl->pkgOrClass = dvmDotToSlash(pkgOrClass+1); // skip ':'
481 if (pCtrl->pkgOrClass == NULL) {
482 /* can happen if class name includes an illegal '/' */
483 ALOGW("Unable to process assertion arg '%s'", pkgOrClass);
484 return false;
485 }
486
487 int len = strlen(pCtrl->pkgOrClass);
488 if (len >= 3 && strcmp(pCtrl->pkgOrClass + len-3, "///") == 0) {
489 /* mark as package, truncate two of the three slashes */
490 pCtrl->isPackage = true;
491 *(pCtrl->pkgOrClass + len-2) = '\0';
492 pCtrl->pkgOrClassLen = len - 2;
493 } else {
494 /* just a class */
495 pCtrl->isPackage = false;
496 pCtrl->pkgOrClassLen = len;
497 }
498 }
499 }
500
501 return true;
502 }
503
504 /*
505 * Turn assertions on when requested to do so by the Zygote.
506 *
507 * This is a bit sketchy. We can't (easily) go back and fiddle with all
508 * of the classes that have already been initialized, so this only
509 * affects classes that have yet to be loaded. If some or all assertions
510 * have been enabled through some other means, we don't want to mess with
511 * it here, so we do nothing. Finally, we assume that there's room in
512 * "assertionCtrl" to hold at least one entry; this is guaranteed by the
513 * allocator.
514 *
515 * This must only be called from the main thread during zygote init.
516 */
dvmLateEnableAssertions()517 void dvmLateEnableAssertions()
518 {
519 if (gDvm.assertionCtrl == NULL) {
520 ALOGD("Not late-enabling assertions: no assertionCtrl array");
521 return;
522 } else if (gDvm.assertionCtrlCount != 0) {
523 ALOGD("Not late-enabling assertions: some asserts already configured");
524 return;
525 }
526 ALOGD("Late-enabling assertions");
527
528 /* global enable for all but system */
529 AssertionControl* pCtrl = gDvm.assertionCtrl;
530 pCtrl->pkgOrClass = strdup("");
531 pCtrl->pkgOrClassLen = 0;
532 pCtrl->isPackage = false;
533 pCtrl->enable = true;
534 gDvm.assertionCtrlCount = 1;
535 }
536
537
538 /*
539 * Release memory associated with the AssertionCtrl array.
540 */
freeAssertionCtrl()541 static void freeAssertionCtrl()
542 {
543 int i;
544
545 for (i = 0; i < gDvm.assertionCtrlCount; i++)
546 free(gDvm.assertionCtrl[i].pkgOrClass);
547 free(gDvm.assertionCtrl);
548 }
549
550 #if defined(WITH_JIT)
551 /* Parse -Xjitop to selectively turn on/off certain opcodes for JIT */
processXjitop(const char * opt)552 static void processXjitop(const char *opt)
553 {
554 if (opt[7] == ':') {
555 const char *startPtr = &opt[8];
556 char *endPtr = NULL;
557
558 do {
559 long startValue, endValue;
560
561 startValue = strtol(startPtr, &endPtr, 16);
562 if (startPtr != endPtr) {
563 /* Just in case value is out of range */
564 startValue %= kNumPackedOpcodes;
565
566 if (*endPtr == '-') {
567 endValue = strtol(endPtr+1, &endPtr, 16);
568 endValue %= kNumPackedOpcodes;
569 } else {
570 endValue = startValue;
571 }
572
573 for (; startValue <= endValue; startValue++) {
574 ALOGW("Dalvik opcode %x is selected for debugging",
575 (unsigned int) startValue);
576 /* Mark the corresponding bit to 1 */
577 gDvmJit.opList[startValue >> 3] |= 1 << (startValue & 0x7);
578 }
579
580 if (*endPtr == 0) {
581 break;
582 }
583
584 startPtr = endPtr + 1;
585
586 continue;
587 } else {
588 if (*endPtr != 0) {
589 dvmFprintf(stderr,
590 "Warning: Unrecognized opcode value substring "
591 "%s\n", endPtr);
592 }
593 break;
594 }
595 } while (1);
596 } else {
597 int i;
598 for (i = 0; i < (kNumPackedOpcodes+7)/8; i++) {
599 gDvmJit.opList[i] = 0xff;
600 }
601 dvmFprintf(stderr, "Warning: select all opcodes\n");
602 }
603 }
604
605 /* Parse -Xjitmethod to selectively turn on/off certain methods for JIT */
processXjitmethod(const char * opt)606 static void processXjitmethod(const char *opt)
607 {
608 char *buf = strdup(&opt[12]);
609 char *start, *end;
610
611 gDvmJit.methodTable = dvmHashTableCreate(8, NULL);
612
613 start = buf;
614 /*
615 * Break comma-separated method signatures and enter them into the hash
616 * table individually.
617 */
618 do {
619 int hashValue;
620
621 end = strchr(start, ',');
622 if (end) {
623 *end = 0;
624 }
625
626 hashValue = dvmComputeUtf8Hash(start);
627
628 dvmHashTableLookup(gDvmJit.methodTable, hashValue,
629 strdup(start),
630 (HashCompareFunc) strcmp, true);
631 if (end) {
632 start = end + 1;
633 } else {
634 break;
635 }
636 } while (1);
637 free(buf);
638 }
639 #endif
640
641 /*
642 * Process an argument vector full of options. Unlike standard C programs,
643 * argv[0] does not contain the name of the program.
644 *
645 * If "ignoreUnrecognized" is set, we ignore options starting with "-X" or "_"
646 * that we don't recognize. Otherwise, we return with an error as soon as
647 * we see anything we can't identify.
648 *
649 * Returns 0 on success, -1 on failure, and 1 for the special case of
650 * "-version" where we want to stop without showing an error message.
651 */
processOptions(int argc,const char * const argv[],bool ignoreUnrecognized)652 static int processOptions(int argc, const char* const argv[],
653 bool ignoreUnrecognized)
654 {
655 int i;
656
657 ALOGV("VM options (%d):", argc);
658 for (i = 0; i < argc; i++)
659 ALOGV(" %d: '%s'", i, argv[i]);
660
661 /*
662 * Over-allocate AssertionControl array for convenience. If allocated,
663 * the array must be able to hold at least one entry, so that the
664 * zygote-time activation can do its business.
665 */
666 assert(gDvm.assertionCtrl == NULL);
667 if (argc > 0) {
668 gDvm.assertionCtrl =
669 (AssertionControl*) malloc(sizeof(AssertionControl) * argc);
670 if (gDvm.assertionCtrl == NULL)
671 return -1;
672 assert(gDvm.assertionCtrlCount == 0);
673 }
674
675 for (i = 0; i < argc; i++) {
676 if (strcmp(argv[i], "-help") == 0) {
677 /* show usage and stop */
678 return -1;
679
680 } else if (strcmp(argv[i], "-version") == 0) {
681 /* show version and stop */
682 showVersion();
683 return 1;
684 } else if (strcmp(argv[i], "-showversion") == 0) {
685 /* show version and continue */
686 showVersion();
687
688 } else if (strcmp(argv[i], "-classpath") == 0 ||
689 strcmp(argv[i], "-cp") == 0)
690 {
691 /* set classpath */
692 if (i == argc-1) {
693 dvmFprintf(stderr, "Missing classpath path list\n");
694 return -1;
695 }
696 free(gDvm.classPathStr); /* in case we have compiled-in default */
697 gDvm.classPathStr = strdup(argv[++i]);
698
699 } else if (strncmp(argv[i], "-Xbootclasspath:",
700 sizeof("-Xbootclasspath:")-1) == 0)
701 {
702 /* set bootclasspath */
703 const char* path = argv[i] + sizeof("-Xbootclasspath:")-1;
704
705 if (*path == '\0') {
706 dvmFprintf(stderr, "Missing bootclasspath path list\n");
707 return -1;
708 }
709 free(gDvm.bootClassPathStr);
710 gDvm.bootClassPathStr = strdup(path);
711
712 } else if (strncmp(argv[i], "-Xbootclasspath/a:",
713 sizeof("-Xbootclasspath/a:")-1) == 0) {
714 const char* appPath = argv[i] + sizeof("-Xbootclasspath/a:")-1;
715
716 if (*(appPath) == '\0') {
717 dvmFprintf(stderr, "Missing appending bootclasspath path list\n");
718 return -1;
719 }
720 char* allPath;
721
722 if (asprintf(&allPath, "%s:%s", gDvm.bootClassPathStr, appPath) < 0) {
723 dvmFprintf(stderr, "Can't append to bootclasspath path list\n");
724 return -1;
725 }
726 free(gDvm.bootClassPathStr);
727 gDvm.bootClassPathStr = allPath;
728
729 } else if (strncmp(argv[i], "-Xbootclasspath/p:",
730 sizeof("-Xbootclasspath/p:")-1) == 0) {
731 const char* prePath = argv[i] + sizeof("-Xbootclasspath/p:")-1;
732
733 if (*(prePath) == '\0') {
734 dvmFprintf(stderr, "Missing prepending bootclasspath path list\n");
735 return -1;
736 }
737 char* allPath;
738
739 if (asprintf(&allPath, "%s:%s", prePath, gDvm.bootClassPathStr) < 0) {
740 dvmFprintf(stderr, "Can't prepend to bootclasspath path list\n");
741 return -1;
742 }
743 free(gDvm.bootClassPathStr);
744 gDvm.bootClassPathStr = allPath;
745
746 } else if (strncmp(argv[i], "-D", 2) == 0) {
747 /* Properties are handled in managed code. We just check syntax. */
748 if (strchr(argv[i], '=') == NULL) {
749 dvmFprintf(stderr, "Bad system property setting: \"%s\"\n",
750 argv[i]);
751 return -1;
752 }
753 gDvm.properties->push_back(argv[i] + 2);
754
755 } else if (strcmp(argv[i], "-jar") == 0) {
756 // TODO: handle this; name of jar should be in argv[i+1]
757 dvmFprintf(stderr, "-jar not yet handled\n");
758 assert(false);
759
760 } else if (strncmp(argv[i], "-Xms", 4) == 0) {
761 size_t val = parseMemOption(argv[i]+4, 1024);
762 if (val != 0) {
763 if (val >= kMinHeapStartSize && val <= kMaxHeapSize) {
764 gDvm.heapStartingSize = val;
765 } else {
766 dvmFprintf(stderr,
767 "Invalid -Xms '%s', range is %dKB to %dKB\n",
768 argv[i], kMinHeapStartSize/1024, kMaxHeapSize/1024);
769 return -1;
770 }
771 } else {
772 dvmFprintf(stderr, "Invalid -Xms option '%s'\n", argv[i]);
773 return -1;
774 }
775 } else if (strncmp(argv[i], "-Xmx", 4) == 0) {
776 size_t val = parseMemOption(argv[i]+4, 1024);
777 if (val != 0) {
778 if (val >= kMinHeapSize && val <= kMaxHeapSize) {
779 gDvm.heapMaximumSize = val;
780 } else {
781 dvmFprintf(stderr,
782 "Invalid -Xmx '%s', range is %dKB to %dKB\n",
783 argv[i], kMinHeapSize/1024, kMaxHeapSize/1024);
784 return -1;
785 }
786 } else {
787 dvmFprintf(stderr, "Invalid -Xmx option '%s'\n", argv[i]);
788 return -1;
789 }
790 } else if (strncmp(argv[i], "-XX:HeapGrowthLimit=", 20) == 0) {
791 size_t val = parseMemOption(argv[i] + 20, 1024);
792 if (val != 0) {
793 gDvm.heapGrowthLimit = val;
794 } else {
795 dvmFprintf(stderr, "Invalid -XX:HeapGrowthLimit option '%s'\n", argv[i]);
796 return -1;
797 }
798 } else if (strncmp(argv[i], "-Xss", 4) == 0) {
799 size_t val = parseMemOption(argv[i]+4, 1);
800 if (val != 0) {
801 if (val >= kMinStackSize && val <= kMaxStackSize) {
802 gDvm.stackSize = val;
803 if (val > gDvm.mainThreadStackSize) {
804 gDvm.mainThreadStackSize = val;
805 }
806 } else {
807 dvmFprintf(stderr, "Invalid -Xss '%s', range is %d to %d\n",
808 argv[i], kMinStackSize, kMaxStackSize);
809 return -1;
810 }
811 } else {
812 dvmFprintf(stderr, "Invalid -Xss option '%s'\n", argv[i]);
813 return -1;
814 }
815
816 } else if (strncmp(argv[i], "-XX:mainThreadStackSize=", strlen("-XX:mainThreadStackSize=")) == 0) {
817 size_t val = parseMemOption(argv[i] + strlen("-XX:mainThreadStackSize="), 1);
818 if (val != 0) {
819 if (val >= kMinStackSize && val <= kMaxStackSize) {
820 gDvm.mainThreadStackSize = val;
821 } else {
822 dvmFprintf(stderr, "Invalid -XX:mainThreadStackSize '%s', range is %d to %d\n",
823 argv[i], kMinStackSize, kMaxStackSize);
824 return -1;
825 }
826 } else {
827 dvmFprintf(stderr, "Invalid -XX:mainThreadStackSize option '%s'\n", argv[i]);
828 return -1;
829 }
830
831 } else if (strncmp(argv[i], "-XX:+DisableExplicitGC", 22) == 0) {
832 gDvm.disableExplicitGc = true;
833 } else if (strcmp(argv[i], "-verbose") == 0 ||
834 strcmp(argv[i], "-verbose:class") == 0)
835 {
836 // JNI spec says "-verbose:gc,class" is valid, but cmd line
837 // doesn't work that way; may want to support.
838 gDvm.verboseClass = true;
839 } else if (strcmp(argv[i], "-verbose:jni") == 0) {
840 gDvm.verboseJni = true;
841 } else if (strcmp(argv[i], "-verbose:gc") == 0) {
842 gDvm.verboseGc = true;
843 } else if (strcmp(argv[i], "-verbose:shutdown") == 0) {
844 gDvm.verboseShutdown = true;
845
846 } else if (strncmp(argv[i], "-enableassertions", 17) == 0) {
847 enableAssertions(argv[i] + 17, true);
848 } else if (strncmp(argv[i], "-ea", 3) == 0) {
849 enableAssertions(argv[i] + 3, true);
850 } else if (strncmp(argv[i], "-disableassertions", 18) == 0) {
851 enableAssertions(argv[i] + 18, false);
852 } else if (strncmp(argv[i], "-da", 3) == 0) {
853 enableAssertions(argv[i] + 3, false);
854 } else if (strcmp(argv[i], "-enablesystemassertions") == 0 ||
855 strcmp(argv[i], "-esa") == 0)
856 {
857 enableAssertions(NULL, true);
858 } else if (strcmp(argv[i], "-disablesystemassertions") == 0 ||
859 strcmp(argv[i], "-dsa") == 0)
860 {
861 enableAssertions(NULL, false);
862
863 } else if (strncmp(argv[i], "-Xcheck:jni", 11) == 0) {
864 /* nothing to do now -- was handled during JNI init */
865
866 } else if (strcmp(argv[i], "-Xdebug") == 0) {
867 /* accept but ignore */
868
869 } else if (strncmp(argv[i], "-Xrunjdwp:", 10) == 0 ||
870 strncmp(argv[i], "-agentlib:jdwp=", 15) == 0)
871 {
872 const char* tail;
873
874 if (argv[i][1] == 'X')
875 tail = argv[i] + 10;
876 else
877 tail = argv[i] + 15;
878
879 if (strncmp(tail, "help", 4) == 0 || !parseJdwpOptions(tail)) {
880 showJdwpHelp();
881 return 1;
882 }
883 } else if (strcmp(argv[i], "-Xrs") == 0) {
884 gDvm.reduceSignals = true;
885 } else if (strcmp(argv[i], "-Xnoquithandler") == 0) {
886 /* disables SIGQUIT handler thread while still blocking SIGQUIT */
887 /* (useful if we don't want thread but system still signals us) */
888 gDvm.noQuitHandler = true;
889 } else if (strcmp(argv[i], "-Xzygote") == 0) {
890 gDvm.zygote = true;
891 #if defined(WITH_JIT)
892 gDvmJit.runningInAndroidFramework = true;
893 #endif
894 } else if (strncmp(argv[i], "-Xdexopt:", 9) == 0) {
895 if (strcmp(argv[i] + 9, "none") == 0)
896 gDvm.dexOptMode = OPTIMIZE_MODE_NONE;
897 else if (strcmp(argv[i] + 9, "verified") == 0)
898 gDvm.dexOptMode = OPTIMIZE_MODE_VERIFIED;
899 else if (strcmp(argv[i] + 9, "all") == 0)
900 gDvm.dexOptMode = OPTIMIZE_MODE_ALL;
901 else if (strcmp(argv[i] + 9, "full") == 0)
902 gDvm.dexOptMode = OPTIMIZE_MODE_FULL;
903 else {
904 dvmFprintf(stderr, "Unrecognized dexopt option '%s'\n",argv[i]);
905 return -1;
906 }
907 } else if (strncmp(argv[i], "-Xverify:", 9) == 0) {
908 if (strcmp(argv[i] + 9, "none") == 0)
909 gDvm.classVerifyMode = VERIFY_MODE_NONE;
910 else if (strcmp(argv[i] + 9, "remote") == 0)
911 gDvm.classVerifyMode = VERIFY_MODE_REMOTE;
912 else if (strcmp(argv[i] + 9, "all") == 0)
913 gDvm.classVerifyMode = VERIFY_MODE_ALL;
914 else {
915 dvmFprintf(stderr, "Unrecognized verify option '%s'\n",argv[i]);
916 return -1;
917 }
918 } else if (strncmp(argv[i], "-Xjnigreflimit:", 15) == 0) {
919 int lim = atoi(argv[i] + 15);
920 if (lim < 200 || (lim % 100) != 0) {
921 dvmFprintf(stderr, "Bad value for -Xjnigreflimit: '%s'\n",
922 argv[i]+15);
923 return -1;
924 }
925 gDvm.jniGrefLimit = lim;
926 } else if (strncmp(argv[i], "-Xjnitrace:", 11) == 0) {
927 gDvm.jniTrace = strdup(argv[i] + 11);
928 } else if (strcmp(argv[i], "-Xlog-stdio") == 0) {
929 gDvm.logStdio = true;
930
931 } else if (strncmp(argv[i], "-Xint", 5) == 0) {
932 if (argv[i][5] == ':') {
933 if (strcmp(argv[i] + 6, "portable") == 0)
934 gDvm.executionMode = kExecutionModeInterpPortable;
935 else if (strcmp(argv[i] + 6, "fast") == 0)
936 gDvm.executionMode = kExecutionModeInterpFast;
937 #ifdef WITH_JIT
938 else if (strcmp(argv[i] + 6, "jit") == 0)
939 gDvm.executionMode = kExecutionModeJit;
940 #endif
941 else {
942 dvmFprintf(stderr,
943 "Warning: Unrecognized interpreter mode %s\n",argv[i]);
944 /* keep going */
945 }
946 } else {
947 /* disable JIT if it was enabled by default */
948 gDvm.executionMode = kExecutionModeInterpFast;
949 }
950
951 } else if (strncmp(argv[i], "-Xlockprofthreshold:", 20) == 0) {
952 gDvm.lockProfThreshold = atoi(argv[i] + 20);
953
954 #ifdef WITH_JIT
955 } else if (strncmp(argv[i], "-Xjitop", 7) == 0) {
956 processXjitop(argv[i]);
957 } else if (strncmp(argv[i], "-Xjitmethod", 11) == 0) {
958 processXjitmethod(argv[i]);
959 } else if (strncmp(argv[i], "-Xjitblocking", 13) == 0) {
960 gDvmJit.blockingMode = true;
961 } else if (strncmp(argv[i], "-Xjitthreshold:", 15) == 0) {
962 gDvmJit.threshold = atoi(argv[i] + 15);
963 } else if (strncmp(argv[i], "-Xincludeselectedop", 19) == 0) {
964 gDvmJit.includeSelectedOp = true;
965 } else if (strncmp(argv[i], "-Xincludeselectedmethod", 23) == 0) {
966 gDvmJit.includeSelectedMethod = true;
967 } else if (strncmp(argv[i], "-Xjitcheckcg", 12) == 0) {
968 gDvmJit.checkCallGraph = true;
969 /* Need to enable blocking mode due to stack crawling */
970 gDvmJit.blockingMode = true;
971 } else if (strncmp(argv[i], "-Xjitverbose", 12) == 0) {
972 gDvmJit.printMe = true;
973 } else if (strncmp(argv[i], "-Xjitprofile", 12) == 0) {
974 gDvmJit.profileMode = kTraceProfilingContinuous;
975 } else if (strncmp(argv[i], "-Xjitdisableopt", 15) == 0) {
976 /* Disable selected optimizations */
977 if (argv[i][15] == ':') {
978 sscanf(argv[i] + 16, "%x", &gDvmJit.disableOpt);
979 /* Disable all optimizations */
980 } else {
981 gDvmJit.disableOpt = -1;
982 }
983 } else if (strncmp(argv[i], "-Xjitsuspendpoll", 16) == 0) {
984 gDvmJit.genSuspendPoll = true;
985 #endif
986
987 } else if (strncmp(argv[i], "-Xstacktracefile:", 17) == 0) {
988 gDvm.stackTraceFile = strdup(argv[i]+17);
989
990 } else if (strcmp(argv[i], "-Xgenregmap") == 0) {
991 gDvm.generateRegisterMaps = true;
992 } else if (strcmp(argv[i], "-Xnogenregmap") == 0) {
993 gDvm.generateRegisterMaps = false;
994
995 } else if (strcmp(argv[i], "Xverifyopt:checkmon") == 0) {
996 gDvm.monitorVerification = true;
997 } else if (strcmp(argv[i], "Xverifyopt:nocheckmon") == 0) {
998 gDvm.monitorVerification = false;
999
1000 } else if (strncmp(argv[i], "-Xgc:", 5) == 0) {
1001 if (strcmp(argv[i] + 5, "precise") == 0)
1002 gDvm.preciseGc = true;
1003 else if (strcmp(argv[i] + 5, "noprecise") == 0)
1004 gDvm.preciseGc = false;
1005 else if (strcmp(argv[i] + 5, "preverify") == 0)
1006 gDvm.preVerify = true;
1007 else if (strcmp(argv[i] + 5, "nopreverify") == 0)
1008 gDvm.preVerify = false;
1009 else if (strcmp(argv[i] + 5, "postverify") == 0)
1010 gDvm.postVerify = true;
1011 else if (strcmp(argv[i] + 5, "nopostverify") == 0)
1012 gDvm.postVerify = false;
1013 else if (strcmp(argv[i] + 5, "concurrent") == 0)
1014 gDvm.concurrentMarkSweep = true;
1015 else if (strcmp(argv[i] + 5, "noconcurrent") == 0)
1016 gDvm.concurrentMarkSweep = false;
1017 else if (strcmp(argv[i] + 5, "verifycardtable") == 0)
1018 gDvm.verifyCardTable = true;
1019 else if (strcmp(argv[i] + 5, "noverifycardtable") == 0)
1020 gDvm.verifyCardTable = false;
1021 else {
1022 dvmFprintf(stderr, "Bad value for -Xgc");
1023 return -1;
1024 }
1025 ALOGV("Precise GC configured %s", gDvm.preciseGc ? "ON" : "OFF");
1026
1027 } else if (strcmp(argv[i], "-Xcheckdexsum") == 0) {
1028 gDvm.verifyDexChecksum = true;
1029
1030 } else if (strcmp(argv[i], "-Xprofile:threadcpuclock") == 0) {
1031 gDvm.profilerClockSource = kProfilerClockSourceThreadCpu;
1032 } else if (strcmp(argv[i], "-Xprofile:wallclock") == 0) {
1033 gDvm.profilerClockSource = kProfilerClockSourceWall;
1034 } else if (strcmp(argv[i], "-Xprofile:dualclock") == 0) {
1035 gDvm.profilerClockSource = kProfilerClockSourceDual;
1036
1037 } else {
1038 if (!ignoreUnrecognized) {
1039 dvmFprintf(stderr, "Unrecognized option '%s'\n", argv[i]);
1040 return -1;
1041 }
1042 }
1043 }
1044
1045 return 0;
1046 }
1047
1048 /*
1049 * Set defaults for fields altered or modified by arguments.
1050 *
1051 * Globals are initialized to 0 (a/k/a NULL or false).
1052 */
setCommandLineDefaults()1053 static void setCommandLineDefaults()
1054 {
1055 const char* envStr = getenv("CLASSPATH");
1056 if (envStr != NULL) {
1057 gDvm.classPathStr = strdup(envStr);
1058 } else {
1059 gDvm.classPathStr = strdup(".");
1060 }
1061 envStr = getenv("BOOTCLASSPATH");
1062 if (envStr != NULL) {
1063 gDvm.bootClassPathStr = strdup(envStr);
1064 } else {
1065 gDvm.bootClassPathStr = strdup(".");
1066 }
1067
1068 gDvm.properties = new std::vector<std::string>();
1069
1070 /* Defaults overridden by -Xms and -Xmx.
1071 * TODO: base these on a system or application-specific default
1072 */
1073 gDvm.heapStartingSize = 2 * 1024 * 1024; // Spec says 16MB; too big for us.
1074 gDvm.heapMaximumSize = 16 * 1024 * 1024; // Spec says 75% physical mem
1075 gDvm.heapGrowthLimit = 0; // 0 means no growth limit
1076 gDvm.stackSize = kDefaultStackSize;
1077 gDvm.mainThreadStackSize = kDefaultStackSize;
1078
1079 gDvm.concurrentMarkSweep = true;
1080
1081 /* gDvm.jdwpSuspend = true; */
1082
1083 /* allowed unless zygote config doesn't allow it */
1084 gDvm.jdwpAllowed = true;
1085
1086 /* default verification and optimization modes */
1087 gDvm.classVerifyMode = VERIFY_MODE_ALL;
1088 gDvm.dexOptMode = OPTIMIZE_MODE_VERIFIED;
1089 gDvm.monitorVerification = false;
1090 gDvm.generateRegisterMaps = true;
1091 gDvm.registerMapMode = kRegisterMapModeTypePrecise;
1092
1093 /*
1094 * Default execution mode.
1095 *
1096 * This should probably interact with the mterp code somehow, e.g. if
1097 * we know we're using the "desktop" build we should probably be
1098 * using "portable" rather than "fast".
1099 */
1100 #if defined(WITH_JIT)
1101 gDvm.executionMode = kExecutionModeJit;
1102 #else
1103 gDvm.executionMode = kExecutionModeInterpFast;
1104 #endif
1105
1106 /*
1107 * SMP support is a compile-time define, but we may want to have
1108 * dexopt target a differently-configured device.
1109 */
1110 gDvm.dexOptForSmp = (ANDROID_SMP != 0);
1111
1112 /*
1113 * Default profiler configuration.
1114 */
1115 gDvm.profilerClockSource = kProfilerClockSourceDual;
1116 }
1117
1118
1119 /*
1120 * Handle a SIGBUS, which frequently occurs because somebody replaced an
1121 * optimized DEX file out from under us.
1122 */
busCatcher(int signum,siginfo_t * info,void * context)1123 static void busCatcher(int signum, siginfo_t* info, void* context)
1124 {
1125 void* addr = info->si_addr;
1126
1127 ALOGE("Caught a SIGBUS (%d), addr=%p", signum, addr);
1128
1129 /*
1130 * If we return at this point the SIGBUS just keeps happening, so we
1131 * remove the signal handler and allow it to kill us. TODO: restore
1132 * the original, which points to a debuggerd stub; if we don't then
1133 * debuggerd won't be notified.
1134 */
1135 signal(SIGBUS, SIG_DFL);
1136 }
1137
1138 /*
1139 * Configure signals. We need to block SIGQUIT so that the signal only
1140 * reaches the dump-stack-trace thread.
1141 *
1142 * This can be disabled with the "-Xrs" flag.
1143 */
blockSignals()1144 static void blockSignals()
1145 {
1146 sigset_t mask;
1147 int cc;
1148
1149 sigemptyset(&mask);
1150 sigaddset(&mask, SIGQUIT);
1151 sigaddset(&mask, SIGUSR1); // used to initiate heap dump
1152 #if defined(WITH_JIT) && defined(WITH_JIT_TUNING)
1153 sigaddset(&mask, SIGUSR2); // used to investigate JIT internals
1154 #endif
1155 //sigaddset(&mask, SIGPIPE);
1156 cc = sigprocmask(SIG_BLOCK, &mask, NULL);
1157 assert(cc == 0);
1158
1159 if (false) {
1160 /* TODO: save the old sigaction in a global */
1161 struct sigaction sa;
1162 memset(&sa, 0, sizeof(sa));
1163 sa.sa_sigaction = busCatcher;
1164 sa.sa_flags = SA_SIGINFO;
1165 cc = sigaction(SIGBUS, &sa, NULL);
1166 assert(cc == 0);
1167 }
1168 }
1169
1170 class ScopedShutdown {
1171 public:
ScopedShutdown()1172 ScopedShutdown() : armed_(true) {
1173 }
1174
~ScopedShutdown()1175 ~ScopedShutdown() {
1176 if (armed_) {
1177 dvmShutdown();
1178 }
1179 }
1180
disarm()1181 void disarm() {
1182 armed_ = false;
1183 }
1184
1185 private:
1186 bool armed_;
1187 };
1188
1189 /*
1190 * VM initialization. Pass in any options provided on the command line.
1191 * Do not pass in the class name or the options for the class.
1192 *
1193 * Returns 0 on success.
1194 */
dvmStartup(int argc,const char * const argv[],bool ignoreUnrecognized,JNIEnv * pEnv)1195 std::string dvmStartup(int argc, const char* const argv[],
1196 bool ignoreUnrecognized, JNIEnv* pEnv)
1197 {
1198 ScopedShutdown scopedShutdown;
1199
1200 assert(gDvm.initializing);
1201
1202 ALOGV("VM init args (%d):", argc);
1203 for (int i = 0; i < argc; i++) {
1204 ALOGV(" %d: '%s'", i, argv[i]);
1205 }
1206 setCommandLineDefaults();
1207
1208 /*
1209 * Process the option flags (if any).
1210 */
1211 int cc = processOptions(argc, argv, ignoreUnrecognized);
1212 if (cc != 0) {
1213 if (cc < 0) {
1214 dvmFprintf(stderr, "\n");
1215 usage("dalvikvm");
1216 }
1217 return "syntax error";
1218 }
1219
1220 #if WITH_EXTRA_GC_CHECKS > 1
1221 /* only "portable" interp has the extra goodies */
1222 if (gDvm.executionMode != kExecutionModeInterpPortable) {
1223 ALOGI("Switching to 'portable' interpreter for GC checks");
1224 gDvm.executionMode = kExecutionModeInterpPortable;
1225 }
1226 #endif
1227
1228 /* Configure group scheduling capabilities */
1229 if (!access("/dev/cpuctl/tasks", F_OK)) {
1230 ALOGV("Using kernel group scheduling");
1231 gDvm.kernelGroupScheduling = 1;
1232 } else {
1233 ALOGV("Using kernel scheduler policies");
1234 }
1235
1236 /* configure signal handling */
1237 if (!gDvm.reduceSignals)
1238 blockSignals();
1239
1240 /* verify system page size */
1241 if (sysconf(_SC_PAGESIZE) != SYSTEM_PAGE_SIZE) {
1242 return StringPrintf("expected page size %d, got %d",
1243 SYSTEM_PAGE_SIZE, (int) sysconf(_SC_PAGESIZE));
1244 }
1245
1246 /* mterp setup */
1247 ALOGV("Using executionMode %d", gDvm.executionMode);
1248 dvmCheckAsmConstants();
1249
1250 /*
1251 * Initialize components.
1252 */
1253 if (!dvmAllocTrackerStartup()) {
1254 return "dvmAllocTrackerStartup failed";
1255 }
1256 if (!dvmGcStartup()) {
1257 return "dvmGcStartup failed";
1258 }
1259 if (!dvmThreadStartup()) {
1260 return "dvmThreadStartup failed";
1261 }
1262 if (!dvmInlineNativeStartup()) {
1263 return "dvmInlineNativeStartup";
1264 }
1265 if (!dvmRegisterMapStartup()) {
1266 return "dvmRegisterMapStartup failed";
1267 }
1268 if (!dvmInstanceofStartup()) {
1269 return "dvmInstanceofStartup failed";
1270 }
1271 if (!dvmClassStartup()) {
1272 return "dvmClassStartup failed";
1273 }
1274
1275 /*
1276 * At this point, the system is guaranteed to be sufficiently
1277 * initialized that we can look up classes and class members. This
1278 * call populates the gDvm instance with all the class and member
1279 * references that the VM wants to use directly.
1280 */
1281 if (!dvmFindRequiredClassesAndMembers()) {
1282 return "dvmFindRequiredClassesAndMembers failed";
1283 }
1284
1285 if (!dvmStringInternStartup()) {
1286 return "dvmStringInternStartup failed";
1287 }
1288 if (!dvmNativeStartup()) {
1289 return "dvmNativeStartup failed";
1290 }
1291 if (!dvmInternalNativeStartup()) {
1292 return "dvmInternalNativeStartup failed";
1293 }
1294 if (!dvmJniStartup()) {
1295 return "dvmJniStartup failed";
1296 }
1297 if (!dvmProfilingStartup()) {
1298 return "dvmProfilingStartup failed";
1299 }
1300
1301 /*
1302 * Create a table of methods for which we will substitute an "inline"
1303 * version for performance.
1304 */
1305 if (!dvmCreateInlineSubsTable()) {
1306 return "dvmCreateInlineSubsTable failed";
1307 }
1308
1309 /*
1310 * Miscellaneous class library validation.
1311 */
1312 if (!dvmValidateBoxClasses()) {
1313 return "dvmValidateBoxClasses failed";
1314 }
1315
1316 /*
1317 * Do the last bits of Thread struct initialization we need to allow
1318 * JNI calls to work.
1319 */
1320 if (!dvmPrepMainForJni(pEnv)) {
1321 return "dvmPrepMainForJni failed";
1322 }
1323
1324 /*
1325 * Explicitly initialize java.lang.Class. This doesn't happen
1326 * automatically because it's allocated specially (it's an instance
1327 * of itself). Must happen before registration of system natives,
1328 * which make some calls that throw assertions if the classes they
1329 * operate on aren't initialized.
1330 */
1331 if (!dvmInitClass(gDvm.classJavaLangClass)) {
1332 return "couldn't initialized java.lang.Class";
1333 }
1334
1335 /*
1336 * Register the system native methods, which are registered through JNI.
1337 */
1338 if (!registerSystemNatives(pEnv)) {
1339 return "couldn't register system natives";
1340 }
1341
1342 /*
1343 * Do some "late" initialization for the memory allocator. This may
1344 * allocate storage and initialize classes.
1345 */
1346 if (!dvmCreateStockExceptions()) {
1347 return "dvmCreateStockExceptions failed";
1348 }
1349
1350 /*
1351 * At this point, the VM is in a pretty good state. Finish prep on
1352 * the main thread (specifically, create a java.lang.Thread object to go
1353 * along with our Thread struct). Note we will probably be executing
1354 * some interpreted class initializer code in here.
1355 */
1356 if (!dvmPrepMainThread()) {
1357 return "dvmPrepMainThread failed";
1358 }
1359
1360 /*
1361 * Make sure we haven't accumulated any tracked references. The main
1362 * thread should be starting with a clean slate.
1363 */
1364 if (dvmReferenceTableEntries(&dvmThreadSelf()->internalLocalRefTable) != 0)
1365 {
1366 ALOGW("Warning: tracked references remain post-initialization");
1367 dvmDumpReferenceTable(&dvmThreadSelf()->internalLocalRefTable, "MAIN");
1368 }
1369
1370 /* general debugging setup */
1371 if (!dvmDebuggerStartup()) {
1372 return "dvmDebuggerStartup failed";
1373 }
1374
1375 if (!dvmGcStartupClasses()) {
1376 return "dvmGcStartupClasses failed";
1377 }
1378
1379 /*
1380 * Init for either zygote mode or non-zygote mode. The key difference
1381 * is that we don't start any additional threads in Zygote mode.
1382 */
1383 if (gDvm.zygote) {
1384 if (!initZygote()) {
1385 return "initZygote failed";
1386 }
1387 } else {
1388 if (!dvmInitAfterZygote()) {
1389 return "dvmInitAfterZygote failed";
1390 }
1391 }
1392
1393
1394 #ifndef NDEBUG
1395 if (!dvmTestHash())
1396 ALOGE("dvmTestHash FAILED");
1397 if (false /*noisy!*/ && !dvmTestIndirectRefTable())
1398 ALOGE("dvmTestIndirectRefTable FAILED");
1399 #endif
1400
1401 if (dvmCheckException(dvmThreadSelf())) {
1402 dvmLogExceptionStackTrace();
1403 return "Exception pending at end of VM initialization";
1404 }
1405
1406 scopedShutdown.disarm();
1407 return "";
1408 }
1409
loadJniLibrary(const char * name)1410 static void loadJniLibrary(const char* name) {
1411 std::string mappedName(StringPrintf(OS_SHARED_LIB_FORMAT_STR, name));
1412 char* reason = NULL;
1413 if (!dvmLoadNativeCode(mappedName.c_str(), NULL, &reason)) {
1414 ALOGE("dvmLoadNativeCode failed for \"%s\": %s", name, reason);
1415 dvmAbort();
1416 }
1417 }
1418
1419 /*
1420 * Register java.* natives from our class libraries. We need to do
1421 * this after we're ready for JNI registration calls, but before we
1422 * do any class initialization.
1423 *
1424 * If we get this wrong, we will blow up in the ThreadGroup class init if
1425 * interpreted code makes any reference to System. It will likely do this
1426 * since it wants to do some java.io.File setup (e.g. for static in/out/err).
1427 *
1428 * We need to have gDvm.initializing raised here so that JNI FindClass
1429 * won't try to use the system/application class loader.
1430 */
registerSystemNatives(JNIEnv * pEnv)1431 static bool registerSystemNatives(JNIEnv* pEnv)
1432 {
1433 // Main thread is always first in list.
1434 Thread* self = gDvm.threadList;
1435
1436 // Must set this before allowing JNI-based method registration.
1437 self->status = THREAD_NATIVE;
1438
1439 // Most JNI libraries can just use System.loadLibrary, but you can't
1440 // if you're the library that implements System.loadLibrary!
1441 loadJniLibrary("javacore");
1442 loadJniLibrary("nativehelper");
1443
1444 // Back to run mode.
1445 self->status = THREAD_RUNNING;
1446
1447 return true;
1448 }
1449
1450
1451 /*
1452 * Do zygote-mode-only initialization.
1453 */
initZygote()1454 static bool initZygote()
1455 {
1456 /* zygote goes into its own process group */
1457 setpgid(0,0);
1458
1459 return true;
1460 }
1461
1462 /*
1463 * Do non-zygote-mode initialization. This is done during VM init for
1464 * standard startup, or after a "zygote fork" when creating a new process.
1465 */
dvmInitAfterZygote()1466 bool dvmInitAfterZygote()
1467 {
1468 u8 startHeap, startQuit, startJdwp;
1469 u8 endHeap, endQuit, endJdwp;
1470
1471 startHeap = dvmGetRelativeTimeUsec();
1472
1473 /*
1474 * Post-zygote heap initialization, including starting
1475 * the HeapWorker thread.
1476 */
1477 if (!dvmGcStartupAfterZygote())
1478 return false;
1479
1480 endHeap = dvmGetRelativeTimeUsec();
1481 startQuit = dvmGetRelativeTimeUsec();
1482
1483 /* start signal catcher thread that dumps stacks on SIGQUIT */
1484 if (!gDvm.reduceSignals && !gDvm.noQuitHandler) {
1485 if (!dvmSignalCatcherStartup())
1486 return false;
1487 }
1488
1489 /* start stdout/stderr copier, if requested */
1490 if (gDvm.logStdio) {
1491 if (!dvmStdioConverterStartup())
1492 return false;
1493 }
1494
1495 endQuit = dvmGetRelativeTimeUsec();
1496 startJdwp = dvmGetRelativeTimeUsec();
1497
1498 /*
1499 * Start JDWP thread. If the command-line debugger flags specified
1500 * "suspend=y", this will pause the VM. We probably want this to
1501 * come last.
1502 */
1503 if (!initJdwp()) {
1504 ALOGD("JDWP init failed; continuing anyway");
1505 }
1506
1507 endJdwp = dvmGetRelativeTimeUsec();
1508
1509 ALOGV("thread-start heap=%d quit=%d jdwp=%d total=%d usec",
1510 (int)(endHeap-startHeap), (int)(endQuit-startQuit),
1511 (int)(endJdwp-startJdwp), (int)(endJdwp-startHeap));
1512
1513 #ifdef WITH_JIT
1514 if (gDvm.executionMode == kExecutionModeJit) {
1515 if (!dvmCompilerStartup())
1516 return false;
1517 }
1518 #endif
1519
1520 return true;
1521 }
1522
1523 /*
1524 * Prepare for a connection to a JDWP-compliant debugger.
1525 *
1526 * Note this needs to happen fairly late in the startup process, because
1527 * we need to have all of the java.* native methods registered (which in
1528 * turn requires JNI to be fully prepped).
1529 *
1530 * There are several ways to initialize:
1531 * server=n
1532 * We immediately try to connect to host:port. Bail on failure. On
1533 * success, send VM_START (suspending the VM if "suspend=y").
1534 * server=y suspend=n
1535 * Passively listen for a debugger to connect. Return immediately.
1536 * server=y suspend=y
1537 * Wait until debugger connects. Send VM_START ASAP, suspending the
1538 * VM after the message is sent.
1539 *
1540 * This gets more complicated with a nonzero value for "timeout".
1541 */
initJdwp()1542 static bool initJdwp()
1543 {
1544 assert(!gDvm.zygote);
1545
1546 /*
1547 * Init JDWP if the debugger is enabled. This may connect out to a
1548 * debugger, passively listen for a debugger, or block waiting for a
1549 * debugger.
1550 */
1551 if (gDvm.jdwpAllowed && gDvm.jdwpConfigured) {
1552 JdwpStartupParams params;
1553
1554 if (gDvm.jdwpHost != NULL) {
1555 if (strlen(gDvm.jdwpHost) >= sizeof(params.host)-1) {
1556 ALOGE("ERROR: hostname too long: '%s'", gDvm.jdwpHost);
1557 return false;
1558 }
1559 strcpy(params.host, gDvm.jdwpHost);
1560 } else {
1561 params.host[0] = '\0';
1562 }
1563 params.transport = gDvm.jdwpTransport;
1564 params.server = gDvm.jdwpServer;
1565 params.suspend = gDvm.jdwpSuspend;
1566 params.port = gDvm.jdwpPort;
1567
1568 gDvm.jdwpState = dvmJdwpStartup(¶ms);
1569 if (gDvm.jdwpState == NULL) {
1570 ALOGW("WARNING: debugger thread failed to initialize");
1571 /* TODO: ignore? fail? need to mimic "expected" behavior */
1572 }
1573 }
1574
1575 /*
1576 * If a debugger has already attached, send the "welcome" message. This
1577 * may cause us to suspend all threads.
1578 */
1579 if (dvmJdwpIsActive(gDvm.jdwpState)) {
1580 //dvmChangeStatus(NULL, THREAD_RUNNING);
1581 if (!dvmJdwpPostVMStart(gDvm.jdwpState, gDvm.jdwpSuspend)) {
1582 ALOGW("WARNING: failed to post 'start' message to debugger");
1583 /* keep going */
1584 }
1585 //dvmChangeStatus(NULL, THREAD_NATIVE);
1586 }
1587
1588 return true;
1589 }
1590
1591 /*
1592 * An alternative to JNI_CreateJavaVM/dvmStartup that does the first bit
1593 * of initialization and then returns with "initializing" still set. (Used
1594 * by DexOpt command-line utility.)
1595 *
1596 * Attempting to use JNI or internal natives will fail. It's best
1597 * if no bytecode gets executed, which means no <clinit>, which means
1598 * no exception-throwing. (In practice we need to initialize Class and
1599 * Object, and probably some exception classes.)
1600 *
1601 * Returns 0 on success.
1602 */
dvmPrepForDexOpt(const char * bootClassPath,DexOptimizerMode dexOptMode,DexClassVerifyMode verifyMode,int dexoptFlags)1603 int dvmPrepForDexOpt(const char* bootClassPath, DexOptimizerMode dexOptMode,
1604 DexClassVerifyMode verifyMode, int dexoptFlags)
1605 {
1606 gDvm.initializing = true;
1607 gDvm.optimizing = true;
1608
1609 /* configure signal handling */
1610 blockSignals();
1611
1612 /* set some defaults */
1613 setCommandLineDefaults();
1614 free(gDvm.bootClassPathStr);
1615 gDvm.bootClassPathStr = strdup(bootClassPath);
1616
1617 /* set opt/verify modes */
1618 gDvm.dexOptMode = dexOptMode;
1619 gDvm.classVerifyMode = verifyMode;
1620 gDvm.generateRegisterMaps = (dexoptFlags & DEXOPT_GEN_REGISTER_MAPS) != 0;
1621 if (dexoptFlags & DEXOPT_SMP) {
1622 assert((dexoptFlags & DEXOPT_UNIPROCESSOR) == 0);
1623 gDvm.dexOptForSmp = true;
1624 } else if (dexoptFlags & DEXOPT_UNIPROCESSOR) {
1625 gDvm.dexOptForSmp = false;
1626 } else {
1627 gDvm.dexOptForSmp = (ANDROID_SMP != 0);
1628 }
1629
1630 /*
1631 * Initialize the heap, some basic thread control mutexes, and
1632 * get the bootclasspath prepped.
1633 *
1634 * We can't load any classes yet because we may not yet have a source
1635 * for things like java.lang.Object and java.lang.Class.
1636 */
1637 if (!dvmGcStartup())
1638 goto fail;
1639 if (!dvmThreadStartup())
1640 goto fail;
1641 if (!dvmInlineNativeStartup())
1642 goto fail;
1643 if (!dvmRegisterMapStartup())
1644 goto fail;
1645 if (!dvmInstanceofStartup())
1646 goto fail;
1647 if (!dvmClassStartup())
1648 goto fail;
1649
1650 /*
1651 * We leave gDvm.initializing set to "true" so that, if we're not
1652 * able to process the "core" classes, we don't go into a death-spin
1653 * trying to throw a "class not found" exception.
1654 */
1655
1656 return 0;
1657
1658 fail:
1659 dvmShutdown();
1660 return 1;
1661 }
1662
1663
1664 /*
1665 * All threads have stopped. Finish the shutdown procedure.
1666 *
1667 * We can also be called if startup fails partway through, so be prepared
1668 * to deal with partially initialized data.
1669 *
1670 * Free any storage allocated in gGlobals.
1671 *
1672 * We can't dlclose() shared libs we've loaded, because it's possible a
1673 * thread not associated with the VM is running code in one.
1674 *
1675 * This is called from the JNI DestroyJavaVM function, which can be
1676 * called from any thread. (In practice, this will usually run in the
1677 * same thread that started the VM, a/k/a the main thread, but we don't
1678 * want to assume that.)
1679 */
dvmShutdown()1680 void dvmShutdown()
1681 {
1682 ALOGV("VM shutting down");
1683
1684 if (CALC_CACHE_STATS)
1685 dvmDumpAtomicCacheStats(gDvm.instanceofCache);
1686
1687 /*
1688 * Stop our internal threads.
1689 */
1690 dvmGcThreadShutdown();
1691
1692 if (gDvm.jdwpState != NULL)
1693 dvmJdwpShutdown(gDvm.jdwpState);
1694 free(gDvm.jdwpHost);
1695 gDvm.jdwpHost = NULL;
1696 free(gDvm.jniTrace);
1697 gDvm.jniTrace = NULL;
1698 free(gDvm.stackTraceFile);
1699 gDvm.stackTraceFile = NULL;
1700
1701 /* tell signal catcher to shut down if it was started */
1702 dvmSignalCatcherShutdown();
1703
1704 /* shut down stdout/stderr conversion */
1705 dvmStdioConverterShutdown();
1706
1707 #ifdef WITH_JIT
1708 if (gDvm.executionMode == kExecutionModeJit) {
1709 /* shut down the compiler thread */
1710 dvmCompilerShutdown();
1711 }
1712 #endif
1713
1714 /*
1715 * Kill any daemon threads that still exist. Actively-running threads
1716 * are likely to crash the process if they continue to execute while
1717 * the VM shuts down.
1718 */
1719 dvmSlayDaemons();
1720
1721 if (gDvm.verboseShutdown)
1722 ALOGD("VM cleaning up");
1723
1724 dvmDebuggerShutdown();
1725 dvmProfilingShutdown();
1726 dvmJniShutdown();
1727 dvmStringInternShutdown();
1728 dvmThreadShutdown();
1729 dvmClassShutdown();
1730 dvmRegisterMapShutdown();
1731 dvmInstanceofShutdown();
1732 dvmInlineNativeShutdown();
1733 dvmGcShutdown();
1734 dvmAllocTrackerShutdown();
1735
1736 /* these must happen AFTER dvmClassShutdown has walked through class data */
1737 dvmNativeShutdown();
1738 dvmInternalNativeShutdown();
1739
1740 dvmFreeInlineSubsTable();
1741
1742 free(gDvm.bootClassPathStr);
1743 free(gDvm.classPathStr);
1744 delete gDvm.properties;
1745
1746 freeAssertionCtrl();
1747
1748 /*
1749 * We want valgrind to report anything we forget to free as "definitely
1750 * lost". If there's a pointer in the global chunk, it would be reported
1751 * as "still reachable". Erasing the memory fixes this.
1752 *
1753 * This must be erased to zero if we want to restart the VM within this
1754 * process.
1755 */
1756 memset(&gDvm, 0xcd, sizeof(gDvm));
1757 }
1758
1759
1760 /*
1761 * fprintf() wrapper that calls through the JNI-specified vfprintf hook if
1762 * one was specified.
1763 */
dvmFprintf(FILE * fp,const char * format,...)1764 int dvmFprintf(FILE* fp, const char* format, ...)
1765 {
1766 va_list args;
1767 int result;
1768
1769 va_start(args, format);
1770 if (gDvm.vfprintfHook != NULL)
1771 result = (*gDvm.vfprintfHook)(fp, format, args);
1772 else
1773 result = vfprintf(fp, format, args);
1774 va_end(args);
1775
1776 return result;
1777 }
1778
1779 #ifdef __GLIBC__
1780 #include <execinfo.h>
1781 /*
1782 * glibc-only stack dump function. Requires link with "--export-dynamic".
1783 *
1784 * TODO: move this into libs/cutils and make it work for all platforms.
1785 */
dvmPrintNativeBackTrace()1786 void dvmPrintNativeBackTrace()
1787 {
1788 size_t MAX_STACK_FRAMES = 64;
1789 void* stackFrames[MAX_STACK_FRAMES];
1790 size_t frameCount = backtrace(stackFrames, MAX_STACK_FRAMES);
1791
1792 /*
1793 * TODO: in practice, we may find that we should use backtrace_symbols_fd
1794 * to avoid allocation, rather than use our own custom formatting.
1795 */
1796 char** strings = backtrace_symbols(stackFrames, frameCount);
1797 if (strings == NULL) {
1798 ALOGE("backtrace_symbols failed: %s", strerror(errno));
1799 return;
1800 }
1801
1802 size_t i;
1803 for (i = 0; i < frameCount; ++i) {
1804 ALOGW("#%-2d %s", i, strings[i]);
1805 }
1806 free(strings);
1807 }
1808 #else
dvmPrintNativeBackTrace()1809 void dvmPrintNativeBackTrace() {
1810 /* Hopefully, you're on an Android device and debuggerd will do this. */
1811 }
1812 #endif
1813
1814 /*
1815 * Abort the VM. We get here on fatal errors. Try very hard not to use
1816 * this; whenever possible, return an error to somebody responsible.
1817 */
dvmAbort()1818 void dvmAbort()
1819 {
1820 /*
1821 * Leave gDvm.lastMessage on the stack frame which can be decoded in the
1822 * tombstone file. This is for situations where we only have tombstone files
1823 * but no logs (ie b/5372634).
1824 *
1825 * For example, in the tombstone file you usually see this:
1826 *
1827 * #00 pc 00050ef2 /system/lib/libdvm.so (dvmAbort)
1828 * #01 pc 00077670 /system/lib/libdvm.so (_Z15dvmClassStartupv)
1829 * :
1830 *
1831 * stack:
1832 * :
1833 * #00 beed2658 00000000
1834 * beed265c 7379732f
1835 * beed2660 2f6d6574
1836 * beed2664 6d617266
1837 * beed2668 726f7765
1838 * beed266c 6f632f6b
1839 * beed2670 6a2e6572
1840 * beed2674 00007261
1841 * beed2678 00000000
1842 *
1843 * The ascii values between beed265c and beed2674 belongs to messageBuffer
1844 * and it can be decoded as "/system/framework/core.jar".
1845 */
1846 const int messageLength = 512;
1847 char messageBuffer[messageLength] = {0};
1848 int result = 0;
1849
1850 snprintf(messageBuffer, messageLength, "%s", gDvm.lastMessage);
1851
1852 /* So that messageBuffer[] looks like useful stuff to the compiler */
1853 for (int i = 0; i < messageLength && messageBuffer[i]; i++) {
1854 result += messageBuffer[i];
1855 }
1856
1857 ALOGE("VM aborting");
1858
1859 fflush(NULL); // flush all open file buffers
1860
1861 /* JNI-supplied abort hook gets right of first refusal */
1862 if (gDvm.abortHook != NULL)
1863 (*gDvm.abortHook)();
1864
1865 /*
1866 * On the device, debuggerd will give us a stack trace.
1867 * On the host, we have to help ourselves.
1868 */
1869 dvmPrintNativeBackTrace();
1870
1871 /*
1872 * If we call abort(), all threads in the process receives a SIBABRT.
1873 * debuggerd dumps the stack trace of the main thread, whether or not
1874 * that was the thread that failed.
1875 *
1876 * By stuffing a value into a bogus address, we cause a segmentation
1877 * fault in the current thread, and get a useful log from debuggerd.
1878 * We can also trivially tell the difference between a VM crash and
1879 * a deliberate abort by looking at the fault address.
1880 */
1881 *((char*)0xdeadd00d) = result;
1882 abort();
1883
1884 /* notreached */
1885 }
1886