vm/Init.cpp

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