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