vm/Globals.h

   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  * Variables with library scope.
  19  *
  20  * Prefer this over scattered static and global variables -- it's easier to
  21  * view the state in a debugger, it makes clean shutdown simpler, we can
  22  * trivially dump the state into a crash log, and it dodges most naming
  23  * collisions that will arise when we are embedded in a larger program.
  24  *
  25  * If we want multiple VMs per process, this can get stuffed into TLS (or
  26  * accessed through a Thread field).  May need to pass it around for some
  27  * of the early initialization functions.
  28  */
  29 #ifndef _DALVIK_GLOBALS
  30 #define _DALVIK_GLOBALS
  31
  32 #include <stdarg.h>
  33 #include <pthread.h>
  34
  35 #define MAX_BREAKPOINTS 20      /* used for a debugger optimization */
  36
  37 // fwd
  38 typedef struct GcHeap GcHeap;   /* heap internal structure */
  39
  40 /*
  41  * One of these for each -ea/-da/-esa/-dsa on the command line.
  42  */
  43 typedef struct AssertionControl {
  44     char*   pkgOrClass;         /* package/class string, or NULL for esa/dsa */
  45     int     pkgOrClassLen;      /* string length, for quick compare */
  46     bool    enable;             /* enable or disable */
  47     bool    isPackage;          /* string ended with "..."? */
  48 } AssertionControl;
  49
  50 /*
  51  * Execution mode, e.g. interpreter vs. JIT.
  52  */
  53 typedef enum ExecutionMode {
  54     kExecutionModeUnknown = 0,
  55     kExecutionModeInterpPortable,
  56     kExecutionModeInterpFast,
  57 } ExecutionMode;
  58
  59 /*
  60  * All fields are initialized to zero.
  61  *
  62  * Storage allocated here must be freed by a subsystem shutdown function or
  63  * from within freeGlobals().
  64  */
  65 struct DvmGlobals {
  66     /*
  67      * Some options from the command line or environment.
  68      */
  69     char*       bootClassPathStr;
  70     char*       classPathStr;
  71
  72     unsigned int    heapSizeStart;
  73     unsigned int    heapSizeMax;
  74     unsigned int    stackSize;
  75
  76     bool        verboseGc;
  77     bool        verboseJni;
  78     bool        verboseClass;
  79
  80     bool        jdwpAllowed;        // debugging allowed for this process?
  81     bool        jdwpConfigured;     // has debugging info been provided?
  82     int         jdwpTransport;
  83     bool        jdwpServer;
  84     char*       jdwpHost;
  85     int         jdwpPort;
  86     bool        jdwpSuspend;
  87
  88     int         (*vfprintfHook)(FILE*, const char*, va_list);
  89     void        (*exitHook)(int);
  90     void        (*abortHook)(void);
  91
  92     int         jniGrefLimit;       // 0 means no limit
  93     bool        reduceSignals;
  94     bool        noQuitHandler;
  95     bool        verifyDexChecksum;
  96     char*       stackTraceFile;     // for SIGQUIT-inspired output
  97
  98     bool        logStdio;
  99
 100     DexOptimizerMode    dexOptMode;
 101     DexClassVerifyMode  classVerifyMode;
 102     bool        generateRegisterMaps;
 103
 104     int         assertionCtrlCount;
 105     AssertionControl*   assertionCtrl;
 106
 107     ExecutionMode   executionMode;
 108
 109     /*
 110      * VM init management.
 111      */
 112     bool        initializing;
 113     int         initExceptionCount;
 114     bool        optimizing;
 115
 116     /*
 117      * java.lang.System properties set from the command line.
 118      */
 119     int         numProps;
 120     int         maxProps;
 121     char**      propList;
 122
 123     /*
 124      * Where the VM goes to find system classes.
 125      */
 126     ClassPathEntry* bootClassPath;
 127     /* used by the DEX optimizer to load classes from an unfinished DEX */
 128     DvmDex*     bootClassPathOptExtra;
 129     bool        optimizingBootstrapClass;
 130
 131     /*
 132      * Loaded classes, hashed by class name.  Each entry is a ClassObject*,
 133      * allocated in GC space.
 134      */
 135     HashTable*  loadedClasses;
 136
 137     /*
 138      * Value for the next class serial number to be assigned.  This is
 139      * incremented as we load classes.  Failed loads and races may result
 140      * in some numbers being skipped, and the serial number is not
 141      * guaranteed to start at 1, so the current value should not be used
 142      * as a count of loaded classes.
 143      */
 144     volatile int classSerialNumber;
 145
 146     /*
 147      * Classes with a low classSerialNumber are probably in the zygote, and
 148      * their InitiatingLoaderList is not used, to promote sharing. The list is
 149      * kept here instead.
 150      */
 151     InitiatingLoaderList* initiatingLoaderList;
 152
 153     /*
 154      * Interned strings.
 155      */
 156     HashTable*  internedStrings;
 157
 158     /*
 159      * Quick lookups for popular classes used internally.
 160      */
 161     ClassObject* unlinkedJavaLangClass;    // see unlinkedJavaLangClassObject
 162     ClassObject* classJavaLangClass;
 163     ClassObject* classJavaLangClassArray;
 164     ClassObject* classJavaLangError;
 165     ClassObject* classJavaLangObject;
 166     ClassObject* classJavaLangObjectArray;
 167     ClassObject* classJavaLangRuntimeException;
 168     ClassObject* classJavaLangString;
 169     ClassObject* classJavaLangThread;
 170     ClassObject* classJavaLangVMThread;
 171     ClassObject* classJavaLangThreadGroup;
 172     ClassObject* classJavaLangThrowable;
 173     ClassObject* classJavaLangStackTraceElement;
 174     ClassObject* classJavaLangStackTraceElementArray;
 175     ClassObject* classJavaLangAnnotationAnnotationArray;
 176     ClassObject* classJavaLangAnnotationAnnotationArrayArray;
 177     ClassObject* classJavaLangReflectAccessibleObject;
 178     ClassObject* classJavaLangReflectConstructor;
 179     ClassObject* classJavaLangReflectConstructorArray;
 180     ClassObject* classJavaLangReflectField;
 181     ClassObject* classJavaLangReflectFieldArray;
 182     ClassObject* classJavaLangReflectMethod;
 183     ClassObject* classJavaLangReflectMethodArray;
 184     ClassObject* classJavaLangReflectProxy;
 185     ClassObject* classJavaLangExceptionInInitializerError;
 186     ClassObject* classJavaLangRefReference;
 187     ClassObject* classJavaSecurityAccessController;
 188     ClassObject* classOrgApacheHarmonyLangAnnotationAnnotationFactory;
 189     ClassObject* classOrgApacheHarmonyLangAnnotationAnnotationMember;
 190     ClassObject* classOrgApacheHarmonyLangAnnotationAnnotationMemberArray;
 191
 192     /* synthetic classes for arrays of primitives */
 193     ClassObject* classArrayBoolean;
 194     ClassObject* classArrayChar;
 195     ClassObject* classArrayFloat;
 196     ClassObject* classArrayDouble;
 197     ClassObject* classArrayByte;
 198     ClassObject* classArrayShort;
 199     ClassObject* classArrayInt;
 200     ClassObject* classArrayLong;
 201
 202     /* method offsets - Object */
 203     int         voffJavaLangObject_equals;
 204     int         voffJavaLangObject_hashCode;
 205     int         voffJavaLangObject_toString;
 206     int         voffJavaLangObject_finalize;
 207
 208     /* field offsets - Class */
 209     int         offJavaLangClass_pd;
 210
 211     /* field offsets - String */
 212     volatile int javaLangStringReady;   /* 0=not init, 1=ready, -1=initing */
 213     int         offJavaLangString_value;
 214     int         offJavaLangString_count;
 215     int         offJavaLangString_offset;
 216     int         offJavaLangString_hashCode;
 217
 218     /* field offsets - Thread */
 219     int         offJavaLangThread_vmThread;
 220     int         offJavaLangThread_group;
 221     int         offJavaLangThread_daemon;
 222     int         offJavaLangThread_name;
 223     int         offJavaLangThread_priority;
 224
 225     /* method offsets - Thread */
 226     int         voffJavaLangThread_run;
 227
 228     /* field offsets - VMThread */
 229     int         offJavaLangVMThread_thread;
 230     int         offJavaLangVMThread_vmData;
 231
 232     /* method offsets - ThreadGroup */
 233     int         voffJavaLangThreadGroup_removeThread;
 234
 235     /* field offsets - Throwable */
 236     int         offJavaLangThrowable_stackState;
 237     int         offJavaLangThrowable_message;
 238     int         offJavaLangThrowable_cause;
 239
 240     /* field offsets - java.lang.reflect.* */
 241     int         offJavaLangReflectAccessibleObject_flag;
 242     int         offJavaLangReflectConstructor_slot;
 243     int         offJavaLangReflectConstructor_declClass;
 244     int         offJavaLangReflectField_slot;
 245     int         offJavaLangReflectField_declClass;
 246     int         offJavaLangReflectMethod_slot;
 247     int         offJavaLangReflectMethod_declClass;
 248
 249     /* field offsets - java.lang.ref.Reference */
 250     int         offJavaLangRefReference_referent;
 251     int         offJavaLangRefReference_queue;
 252     int         offJavaLangRefReference_queueNext;
 253     int         offJavaLangRefReference_vmData;
 254
 255 #if FANCY_REFERENCE_SUBCLASS
 256     /* method offsets - java.lang.ref.Reference */
 257     int         voffJavaLangRefReference_clear;
 258     int         voffJavaLangRefReference_enqueue;
 259 #else
 260     /* method pointers - java.lang.ref.Reference */
 261     Method*     methJavaLangRefReference_enqueueInternal;
 262 #endif
 263
 264     /* field offsets - java.nio.Buffer and java.nio.DirectByteBufferImpl */
 265     //int         offJavaNioBuffer_capacity;
 266     //int         offJavaNioDirectByteBufferImpl_pointer;
 267
 268     /* method pointers - java.security.AccessController */
 269     volatile bool javaSecurityAccessControllerReady;
 270     Method*     methJavaSecurityAccessController_doPrivileged[4];
 271
 272     /* constructor method pointers; no vtable involved, so use Method* */
 273     Method*     methJavaLangStackTraceElement_init;
 274     Method*     methJavaLangExceptionInInitializerError_init;
 275     Method*     methJavaLangReflectConstructor_init;
 276     Method*     methJavaLangReflectField_init;
 277     Method*     methJavaLangReflectMethod_init;
 278     Method*     methOrgApacheHarmonyLangAnnotationAnnotationMember_init;
 279
 280     /* static method pointers - android.lang.annotation.* */
 281     Method*
 282         methOrgApacheHarmonyLangAnnotationAnnotationFactory_createAnnotation;
 283
 284     /* direct method pointers - java.lang.reflect.Proxy */
 285     Method*     methJavaLangReflectProxy_constructorPrototype;
 286
 287     /* field offsets - java.lang.reflect.Proxy */
 288     int         offJavaLangReflectProxy_h;
 289
 290     /* fake native entry point method */
 291     Method*     methFakeNativeEntry;
 292
 293     /*
 294      * VM-synthesized primitive classes, for arrays.
 295      */
 296     ClassObject* volatile primitiveClass[PRIM_MAX];
 297
 298     /*
 299      * A placeholder ClassObject used during ClassObject
 300      * construction.
 301      */
 302     ClassObject  unlinkedJavaLangClassObject;
 303
 304     /*
 305      * Thread list.  This always has at least one element in it (main),
 306      * and main is always the first entry.
 307      *
 308      * The threadListLock is used for several things, including the thread
 309      * start condition variable.  Generally speaking, you must hold the
 310      * threadListLock when:
 311      *  - adding/removing items from the list
 312      *  - waiting on or signaling threadStartCond
 313      *  - examining the Thread struct for another thread (this is to avoid
 314      *    one thread freeing the Thread struct while another thread is
 315      *    perusing it)
 316      */
 317     Thread*     threadList;
 318     pthread_mutex_t threadListLock;
 319
 320     pthread_cond_t threadStartCond;
 321
 322     /*
 323      * The thread code grabs this before suspending all threads.  There
 324      * are four things that can cause a "suspend all":
 325      *  (1) the GC is starting;
 326      *  (2) the debugger has sent a "suspend all" request;
 327      *  (3) a thread has hit a breakpoint or exception that the debugger
 328      *      has marked as a "suspend all" event;
 329      *  (4) the SignalCatcher caught a signal that requires suspension.
 330      *
 331      * Because we use "safe point" self-suspension, it is never safe to
 332      * do a blocking "lock" call on this mutex -- if it has been acquired,
 333      * somebody is probably trying to put you to sleep.  The leading '_' is
 334      * intended as a reminder that this lock is special.
 335      *
 336      * This lock is also held while attaching an externally-created thread
 337      * through JNI.  That way we can correctly set the initial suspend state.
 338      */
 339     pthread_mutex_t _threadSuspendLock;
 340
 341     /*
 342      * Guards Thread->suspendCount for all threads, and provides the lock
 343      * for the condition variable that all suspended threads sleep on
 344      * (threadSuspendCountCond).
 345      *
 346      * This has to be separate from threadListLock because of the way
 347      * threads put themselves to sleep.
 348      */
 349     pthread_mutex_t threadSuspendCountLock;
 350
 351     /*
 352      * Suspended threads sleep on this.  They should sleep on the condition
 353      * variable until their "suspend count" is zero.
 354      *
 355      * Paired with "threadSuspendCountLock".
 356      */
 357     pthread_cond_t  threadSuspendCountCond;
 358
 359     /*
 360      * MUTEX ORDERING: when locking multiple mutexes, always grab them in
 361      * this order to avoid deadlock:
 362      *
 363      *  (1) _threadSuspendLock      (use lockThreadSuspend())
 364      *  (2) threadListLock          (use dvmLockThreadList())
 365      *  (3) threadSuspendCountLock  (use lockThreadSuspendCount())
 366      */
 367
 368
 369     /*
 370      * Thread ID bitmap.  We want threads to have small integer IDs so
 371      * we can use them in "thin locks".
 372      */
 373     BitVector*  threadIdMap;
 374
 375     /*
 376      * Manage exit conditions.  The VM exits when all non-daemon threads
 377      * have exited.  If the main thread returns early, we need to sleep
 378      * on a condition variable.
 379      */
 380     int         nonDaemonThreadCount;   /* must hold threadListLock to access */
 381     //pthread_mutex_t vmExitLock;
 382     pthread_cond_t  vmExitCond;
 383
 384     /*
 385      * The set of DEX files loaded by custom class loaders.
 386      */
 387     HashTable*  userDexFiles;
 388
 389     /*
 390      * JNI global reference table.
 391      */
 392     ReferenceTable  jniGlobalRefTable;
 393     pthread_mutex_t jniGlobalRefLock;
 394     int         jniGlobalRefHiMark;
 395     int         jniGlobalRefLoMark;
 396
 397     /*
 398      * Native shared library table.
 399      */
 400     HashTable*  nativeLibs;
 401
 402     /*
 403      * GC heap lock.  Functions like gcMalloc() acquire this before making
 404      * any changes to the heap.  It is held throughout garbage collection.
 405      */
 406     pthread_mutex_t gcHeapLock;
 407
 408     /* Opaque pointer representing the heap. */
 409     GcHeap*     gcHeap;
 410
 411     /*
 412      * Pre-allocated object for out-of-memory errors.
 413      */
 414     Object*     outOfMemoryObj;
 415
 416     /* pre-allocated general failure exception */
 417     Object*     internalErrorObj;
 418
 419     /* Monitor list, so we can free them */
 420     /*volatile*/ Monitor* monitorList;
 421
 422     /* Monitor for Thread.sleep() implementation */
 423     Monitor*    threadSleepMon;
 424
 425     /* set when we create a second heap inside the zygote */
 426     bool        newZygoteHeapAllocated;
 427
 428     /*
 429      * TLS keys.
 430      */
 431     pthread_key_t pthreadKeySelf;       /* Thread*, for dvmThreadSelf */
 432
 433     /*
 434      * JNI allows you to have multiple VMs, but we limit ourselves to 1,
 435      * so "vmList" is really just a pointer to the one and only VM.
 436      */
 437     JavaVM*     vmList;
 438
 439     /*
 440      * Cache results of "A instanceof B".
 441      */
 442     AtomicCache* instanceofCache;
 443
 444     /* instruction width table, used for optimization and verification */
 445     InstructionWidth*   instrWidth;
 446     /* instruction flags table, used for verification */
 447     InstructionFlags*   instrFlags;
 448     /* instruction format table, used for verification */
 449     InstructionFormat*  instrFormat;
 450
 451     /*
 452      * Bootstrap class loader linear allocator.
 453      */
 454     LinearAllocHdr* pBootLoaderAlloc;
 455
 456
 457     /*
 458      * Heap worker thread.
 459      */
 460     bool            heapWorkerInitialized;
 461     bool            heapWorkerReady;
 462     bool            haltHeapWorker;
 463     pthread_t       heapWorkerHandle;
 464     pthread_mutex_t heapWorkerLock;
 465     pthread_cond_t  heapWorkerCond;
 466     pthread_cond_t  heapWorkerIdleCond;
 467     pthread_mutex_t heapWorkerListLock;
 468
 469     /*
 470      * Compute some stats on loaded classes.
 471      */
 472     int         numLoadedClasses;
 473     int         numDeclaredMethods;
 474     int         numDeclaredInstFields;
 475     int         numDeclaredStaticFields;
 476
 477     /* when using a native debugger, set this to suppress watchdog timers */
 478     bool        nativeDebuggerActive;
 479
 480     /*
 481      * JDWP debugger support.
 482      */
 483     bool        debuggerConnected;      /* debugger or DDMS is connected */
 484     bool        debuggerActive;         /* debugger is making requests */
 485     JdwpState*  jdwpState;
 486
 487     /*
 488      * Registry of objects known to the debugger.
 489      */
 490     HashTable*  dbgRegistry;
 491
 492     /*
 493      * Breakpoint optimization table.  This is global and NOT explicitly
 494      * synchronized, but all operations that modify the table are made
 495      * from relatively-synchronized functions.  False-positives are
 496      * possible, false-negatives (i.e. missing a breakpoint) should not be.
 497      */
 498     const u2*   debugBreakAddr[MAX_BREAKPOINTS];
 499
 500     /*
 501      * Single-step control struct.  We currently only allow one thread to
 502      * be single-stepping at a time, which is all that really makes sense,
 503      * but it's possible we may need to expand this to be per-thread.
 504      */
 505     StepControl stepControl;
 506
 507     /*
 508      * DDM features embedded in the VM.
 509      */
 510     bool        ddmThreadNotification;
 511
 512     /*
 513      * Zygote (partially-started process) support
 514      */
 515     bool        zygote;
 516
 517     /*
 518      * Used for tracking allocations that we report to DDMS.  When the feature
 519      * is enabled (through a DDMS request) the "allocRecords" pointer becomes
 520      * non-NULL.
 521      */
 522     pthread_mutex_t allocTrackerLock;
 523     AllocRecord*    allocRecords;
 524     int             allocRecordHead;        /* most-recently-added entry */
 525     int             allocRecordCount;       /* #of valid entries */
 526
 527 #ifdef WITH_ALLOC_LIMITS
 528     /* set on first use of an alloc limit, never cleared */
 529     bool        checkAllocLimits;
 530     /* allocation limit, for setGlobalAllocationLimit() regression testing */
 531     int         allocationLimit;
 532 #endif
 533
 534 #ifdef WITH_DEADLOCK_PREDICTION
 535     /* global lock on history tree accesses */
 536     pthread_mutex_t deadlockHistoryLock;
 537
 538     enum { kDPOff=0, kDPWarn, kDPErr, kDPAbort } deadlockPredictMode;
 539 #endif
 540
 541 #ifdef WITH_PROFILER
 542     /*
 543      * When a profiler is enabled, this is incremented.  Distinct profilers
 544      * include "dmtrace" method tracing, emulator method tracing, and
 545      * possibly instruction counting.
 546      *
 547      * The purpose of this is to have a single value that the interpreter
 548      * can check to see if any profiling activity is enabled.
 549      */
 550     volatile int activeProfilers;
 551
 552     /*
 553      * State for method-trace profiling.
 554      */
 555     MethodTraceState methodTrace;
 556
 557     /*
 558      * State for emulator tracing.
 559      */
 560     void*       emulatorTracePage;
 561     int         emulatorTraceEnableCount;
 562
 563     /*
 564      * Global state for memory allocation profiling.
 565      */
 566     AllocProfState allocProf;
 567
 568     /*
 569      * Pointers to the original methods for things that have been inlined.
 570      * This makes it easy for us to output method entry/exit records for
 571      * the method calls we're not actually making.
 572      */
 573     Method**    inlinedMethods;
 574
 575     /*
 576      * Dalvik instruction counts (256 entries).
 577      */
 578     int*        executedInstrCounts;
 579     bool        instructionCountEnableCount;
 580 #endif
 581
 582     /*
 583      * Signal catcher thread (for SIGQUIT).
 584      */
 585     pthread_t   signalCatcherHandle;
 586     bool        haltSignalCatcher;
 587
 588     /*
 589      * Stdout/stderr conversion thread.
 590      */
 591     bool            haltStdioConverter;
 592     bool            stdioConverterReady;
 593     pthread_t       stdioConverterHandle;
 594     pthread_mutex_t stdioConverterLock;
 595     pthread_cond_t  stdioConverterCond;
 596
 597     /*
 598      * pid of the system_server process. We track it so that when system server
 599      * crashes the Zygote process will be killed and restarted.
 600      */
 601     pid_t systemServerPid;
 602
 603 //#define COUNT_PRECISE_METHODS
 604 #ifdef COUNT_PRECISE_METHODS
 605     PointerSet* preciseMethods;
 606 #endif
 607 };
 608
 609 extern struct DvmGlobals gDvm;
 610
 611 #endif /*_DALVIK_GLOBALS*/