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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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: 1172 ScopedShutdown() : armed_(true) { 1173 } 1174 1175 ~ScopedShutdown() { 1176 if (armed_) { 1177 dvmShutdown(); 1178 } 1179 } 1180 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 */ 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 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 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 */ 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