/*
* Call this repeatedly, with successively higher values for "iteration",
* to sleep for a period of time not to exceed "maxTotalSleep".
*
* For example, when called with iteration==0 we will sleep for a very
* brief time. On the next call we will sleep for a longer time. When
* the sum total of all sleeps reaches "maxTotalSleep", this returns false.
*
* The initial start time value for "relStartTime" MUST come from the
* dvmGetRelativeTimeUsec call. On the device this must come from the
* monotonic clock source, not the wall clock.
*
* This should be used wherever you might be tempted to call sched_yield()
* in a loop. The problem with sched_yield is that, for a high-priority
* thread, the kernel might not actually transfer control elsewhere.
*
* Returns "false" if we were unable to sleep because our time was up.
*/
bool dvmIterativeSleep(int iteration, int maxTotalSleep, u8 relStartTime)
{
/*
* Minimum sleep is one millisecond, it is important to keep this value
* low to ensure short GC pauses since dvmSuspendAllThreads() uses this
* function.
*/
const int minSleep = 1000;
u8 curTime;
int curDelay;
/*
* Get current time, and see if we've already exceeded the limit.
*/
curTime = dvmGetRelativeTimeUsec();
if (curTime >= relStartTime + maxTotalSleep) {
LOGVV("exsl: sleep exceeded (start=%llu max=%d now=%llu)",
relStartTime, maxTotalSleep, curTime);
return false;
}
/*
* Compute current delay. We're bounded by "maxTotalSleep", so no
* real risk of overflow assuming "usleep" isn't returning early.
* (Besides, 2^30 usec is about 18 minutes by itself.)
*
* For iteration==0 we just call sched_yield(), so the first sleep
* at iteration==1 is actually (minSleep * 2).
*/
curDelay = minSleep;
while (iteration-- > 0)
curDelay *= 2;
assert(curDelay > 0);
if (curTime + curDelay >= relStartTime + maxTotalSleep) {
LOGVV("exsl: reduced delay from %d to %d",
curDelay, (int) ((relStartTime + maxTotalSleep) - curTime));
curDelay = (int) ((relStartTime + maxTotalSleep) - curTime);
}
if (iteration == 0) {
LOGVV("exsl: yield");
sched_yield();
} else {
LOGVV("exsl: sleep for %d", curDelay);
usleep(curDelay);
}
return true;
}
static void callMethod(Thread *self, Object *obj, Method *method)
{
JValue unused;
/* Keep track of the method we're about to call and
* the current time so that other threads can detect
* when this thread wedges and provide useful information.
*/
gDvm.gcHeap->heapWorkerInterpStartTime = dvmGetRelativeTimeUsec();
gDvm.gcHeap->heapWorkerInterpCpuStartTime = dvmGetThreadCpuTimeUsec();
gDvm.gcHeap->heapWorkerCurrentMethod = method;
gDvm.gcHeap->heapWorkerCurrentObject = obj;
/* Call the method.
*
* Don't hold the lock when executing interpreted
* code. It may suspend, and the GC needs to grab
* heapWorkerLock.
*/
dvmUnlockMutex(&gDvm.heapWorkerLock);
if (false) {
/* Log entry/exit; this will likely flood the log enough to
* cause "logcat" to drop entries.
*/
char tmpTag[16];
sprintf(tmpTag, "HW%d", self->systemTid);
LOG(LOG_DEBUG, tmpTag, "Call %s\n", method->clazz->descriptor);
dvmCallMethod(self, method, obj, &unused);
LOG(LOG_DEBUG, tmpTag, " done\n");
} else {
dvmCallMethod(self, method, obj, &unused);
}
dvmLockMutex(&gDvm.heapWorkerLock);
gDvm.gcHeap->heapWorkerCurrentObject = NULL;
gDvm.gcHeap->heapWorkerCurrentMethod = NULL;
gDvm.gcHeap->heapWorkerInterpStartTime = 0LL;
/* Exceptions thrown during these calls interrupt
* the method, but are otherwise ignored.
*/
if (dvmCheckException(self)) {
#if DVM_SHOW_EXCEPTION >= 1
LOGI("Uncaught exception thrown by finalizer (will be discarded):\n");
dvmLogExceptionStackTrace();
#endif
dvmClearException(self);
}
}
/* See documentation comment in header. */
int dvmRawDexFileOpen(const char* fileName, const char* odexOutputName,
RawDexFile** ppRawDexFile, bool isBootstrap)
{
/*
* TODO: This duplicates a lot of code from dvmJarFileOpen() in
* JarFile.c. This should be refactored.
*/
DvmDex* pDvmDex = NULL;
char* cachedName = NULL;
int result = -1;
int dexFd = -1;
int optFd = -1;
u4 modTime = 0;
u4 adler32 = 0;
size_t fileSize = 0;
bool newFile = false;
bool locked = false;
dexFd = open(fileName, O_RDONLY);
if (dexFd < 0) goto bail;
/* If we fork/exec into dexopt, don't let it inherit the open fd. */
dvmSetCloseOnExec(dexFd);
if (verifyMagicAndGetAdler32(dexFd, &adler32) < 0) {
ALOGE("Error with header for %s", fileName);
goto bail;
}
if (getModTimeAndSize(dexFd, &modTime, &fileSize) < 0) {
ALOGE("Error with stat for %s", fileName);
goto bail;
}
/*
* See if the cached file matches. If so, optFd will become a reference
* to the cached file and will have been seeked to just past the "opt"
* header.
*/
if (odexOutputName == NULL) {
cachedName = dexOptGenerateCacheFileName(fileName, NULL);
if (cachedName == NULL)
goto bail;
} else {
cachedName = strdup(odexOutputName);
}
ALOGV("dvmRawDexFileOpen: Checking cache for %s (%s)",
fileName, cachedName);
optFd = dvmOpenCachedDexFile(fileName, cachedName, modTime,
adler32, isBootstrap, &newFile, /*createIfMissing=*/true);
if (optFd < 0) {
ALOGI("Unable to open or create cache for %s (%s)",
fileName, cachedName);
goto bail;
}
locked = true;
/*
* If optFd points to a new file (because there was no cached
* version, or the cached version was stale), generate the
* optimized DEX. The file descriptor returned is still locked,
* and is positioned just past the optimization header.
*/
if (newFile) {
u8 startWhen, copyWhen, endWhen;
bool result;
off_t dexOffset;
dexOffset = lseek(optFd, 0, SEEK_CUR);
result = (dexOffset > 0);
if (result) {
startWhen = dvmGetRelativeTimeUsec();
result = copyFileToFile(optFd, dexFd, fileSize) == 0;
copyWhen = dvmGetRelativeTimeUsec();
}
if (result) {
result = dvmOptimizeDexFile(optFd, dexOffset, fileSize,
fileName, modTime, adler32, isBootstrap);
}
if (!result) {
ALOGE("Unable to extract+optimize DEX from '%s'", fileName);
goto bail;
}
endWhen = dvmGetRelativeTimeUsec();
ALOGD("DEX prep '%s': copy in %dms, rewrite %dms",
fileName,
(int) (copyWhen - startWhen) / 1000,
(int) (endWhen - copyWhen) / 1000);
}
/*
* Map the cached version. This immediately rewinds the fd, so it
* doesn't have to be seeked anywhere in particular.
*/
if (dvmDexFileOpenFromFd(optFd, &pDvmDex) != 0) {
ALOGI("Unable to map cached %s", fileName);
goto bail;
}
if (locked) {
/* unlock the fd */
if (!dvmUnlockCachedDexFile(optFd)) {
/* uh oh -- this process needs to exit or we'll wedge the system */
ALOGE("Unable to unlock DEX file");
goto bail;
}
locked = false;
}
ALOGV("Successfully opened '%s'", fileName);
*ppRawDexFile = (RawDexFile*) calloc(1, sizeof(RawDexFile));
(*ppRawDexFile)->cacheFileName = cachedName;
(*ppRawDexFile)->pDvmDex = pDvmDex;
cachedName = NULL; // don't free it below
result = 0;
bail:
free(cachedName);
if (dexFd >= 0) {
close(dexFd);
}
if (optFd >= 0) {
if (locked)
(void) dvmUnlockCachedDexFile(optFd);
close(optFd);
}
return result;
}
/*
* Open a Jar file. It's okay if it's just a Zip archive without all of
* the Jar trimmings, but we do insist on finding "classes.dex" inside
* or an appropriately-named ".odex" file alongside.
*
* If "isBootstrap" is not set, the optimizer/verifier regards this DEX as
* being part of a different class loader.
*/
int dvmJarFileOpen(const char* fileName, const char* odexOutputName,
JarFile** ppJarFile, bool isBootstrap)
{
/*
* TODO: This function has been duplicated and modified to become
* dvmRawDexFileOpen() in RawDexFile.c. This should be refactored.
*/
ZipArchive archive;
DvmDex* pDvmDex = NULL;
char* cachedName = NULL;
bool archiveOpen = false;
bool locked = false;
int fd = -1;
int result = -1;
/* Even if we're not going to look at the archive, we need to
* open it so we can stuff it into ppJarFile.
*/
if (dexZipOpenArchive(fileName, &archive) != 0)
goto bail;
archiveOpen = true;
/* If we fork/exec into dexopt, don't let it inherit the archive's fd.
*/
dvmSetCloseOnExec(dexZipGetArchiveFd(&archive));
/* First, look for a ".odex" alongside the jar file. It will
* have the same name/path except for the extension.
*/
fd = openAlternateSuffix(fileName, "odex", O_RDONLY, &cachedName);
if (fd >= 0) {
ALOGV("Using alternate file (odex) for %s ...", fileName);
if (!dvmCheckOptHeaderAndDependencies(fd, false, 0, 0, true, true)) {
ALOGE("%s odex has stale dependencies", fileName);
free(cachedName);
cachedName = NULL;
close(fd);
fd = -1;
goto tryArchive;
} else {
ALOGV("%s odex has good dependencies", fileName);
//TODO: make sure that the .odex actually corresponds
// to the classes.dex inside the archive (if present).
// For typical use there will be no classes.dex.
}
} else {
ZipEntry entry;
tryArchive:
/*
* Pre-created .odex absent or stale. Look inside the jar for a
* "classes.dex".
*/
entry = dexZipFindEntry(&archive, kDexInJarName);
if (entry != NULL) {
bool newFile = false;
/*
* We've found the one we want. See if there's an up-to-date copy
* in the cache.
*
* On return, "fd" will be seeked just past the "opt" header.
*
* If a stale .odex file is present and classes.dex exists in
* the archive, this will *not* return an fd pointing to the
* .odex file; the fd will point into dalvik-cache like any
* other jar.
*/
if (odexOutputName == NULL) {
cachedName = dexOptGenerateCacheFileName(fileName,
kDexInJarName);
if (cachedName == NULL)
goto bail;
} else {
cachedName = strdup(odexOutputName);
}
ALOGV("dvmJarFileOpen: Checking cache for %s (%s)",
fileName, cachedName);
fd = dvmOpenCachedDexFile(fileName, cachedName,
dexGetZipEntryModTime(&archive, entry),
dexGetZipEntryCrc32(&archive, entry),
isBootstrap, &newFile, /*createIfMissing=*/true);
if (fd < 0) {
ALOGI("Unable to open or create cache for %s (%s)",
fileName, cachedName);
goto bail;
}
locked = true;
/*
* If fd points to a new file (because there was no cached version,
* or the cached version was stale), generate the optimized DEX.
* The file descriptor returned is still locked, and is positioned
* just past the optimization header.
*/
if (newFile) {
u8 startWhen, extractWhen, endWhen;
bool result;
off_t dexOffset;
dexOffset = lseek(fd, 0, SEEK_CUR);
result = (dexOffset > 0);
if (result) {
startWhen = dvmGetRelativeTimeUsec();
result = dexZipExtractEntryToFile(&archive, entry, fd) == 0;
extractWhen = dvmGetRelativeTimeUsec();
}
if (result) {
result = dvmOptimizeDexFile(fd, dexOffset,
dexGetZipEntryUncompLen(&archive, entry),
fileName,
dexGetZipEntryModTime(&archive, entry),
dexGetZipEntryCrc32(&archive, entry),
isBootstrap);
}
if (!result) {
ALOGE("Unable to extract+optimize DEX from '%s'",
fileName);
goto bail;
}
endWhen = dvmGetRelativeTimeUsec();
ALOGD("DEX prep '%s': unzip in %dms, rewrite %dms",
fileName,
(int) (extractWhen - startWhen) / 1000,
(int) (endWhen - extractWhen) / 1000);
}
} else {
ALOGI("Zip is good, but no %s inside, and no valid .odex "
"file in the same directory", kDexInJarName);
goto bail;
}
}
/*
* Map the cached version. This immediately rewinds the fd, so it
* doesn't have to be seeked anywhere in particular.
*/
if (dvmDexFileOpenFromFd(fd, &pDvmDex) != 0) {
ALOGI("Unable to map %s in %s", kDexInJarName, fileName);
goto bail;
}
if (locked) {
/* unlock the fd */
if (!dvmUnlockCachedDexFile(fd)) {
/* uh oh -- this process needs to exit or we'll wedge the system */
ALOGE("Unable to unlock DEX file");
goto bail;
}
locked = false;
}
ALOGV("Successfully opened '%s' in '%s'", kDexInJarName, fileName);
*ppJarFile = (JarFile*) calloc(1, sizeof(JarFile));
(*ppJarFile)->archive = archive;
(*ppJarFile)->cacheFileName = cachedName;
(*ppJarFile)->pDvmDex = pDvmDex;
cachedName = NULL; // don't free it below
result = 0;
bail:
/* clean up, closing the open file */
if (archiveOpen && result != 0)
dexZipCloseArchive(&archive);
free(cachedName);
if (fd >= 0) {
if (locked)
(void) dvmUnlockCachedDexFile(fd);
close(fd);
}
return result;
}
static void *compilerThreadStart(void *arg)
{
dvmChangeStatus(NULL, THREAD_VMWAIT);
/*
* If we're not running stand-alone, wait a little before
* recieving translation requests on the assumption that process start
* up code isn't worth compiling. We'll resume when the framework
* signals us that the first screen draw has happened, or the timer
* below expires (to catch daemons).
*
* There is a theoretical race between the callback to
* VMRuntime.startJitCompiation and when the compiler thread reaches this
* point. In case the callback happens earlier, in order not to permanently
* hold the system_server (which is not using the timed wait) in
* interpreter-only mode we bypass the delay here.
*/
if (gDvmJit.runningInAndroidFramework &&
!gDvmJit.alreadyEnabledViaFramework) {
/*
* If the current VM instance is the system server (detected by having
* 0 in gDvm.systemServerPid), we will use the indefinite wait on the
* conditional variable to determine whether to start the JIT or not.
* If the system server detects that the whole system is booted in
* safe mode, the conditional variable will never be signaled and the
* system server will remain in the interpreter-only mode. All
* subsequent apps will be started with the --enable-safemode flag
* explicitly appended.
*/
if (gDvm.systemServerPid == 0) {
dvmLockMutex(&gDvmJit.compilerLock);
pthread_cond_wait(&gDvmJit.compilerQueueActivity,
&gDvmJit.compilerLock);
dvmUnlockMutex(&gDvmJit.compilerLock);
ALOGD("JIT started for system_server");
} else {
dvmLockMutex(&gDvmJit.compilerLock);
/*
* TUNING: experiment with the delay & perhaps make it
* target-specific
*/
dvmRelativeCondWait(&gDvmJit.compilerQueueActivity,
&gDvmJit.compilerLock, 3000, 0);
dvmUnlockMutex(&gDvmJit.compilerLock);
}
if (gDvmJit.haltCompilerThread) {
return NULL;
}
}
compilerThreadStartup();
dvmLockMutex(&gDvmJit.compilerLock);
/*
* Since the compiler thread will not touch any objects on the heap once
* being created, we just fake its state as VMWAIT so that it can be a
* bit late when there is suspend request pending.
*/
while (!gDvmJit.haltCompilerThread) {
if (workQueueLength() == 0) {
int cc;
cc = pthread_cond_signal(&gDvmJit.compilerQueueEmpty);
assert(cc == 0);
pthread_cond_wait(&gDvmJit.compilerQueueActivity,
&gDvmJit.compilerLock);
continue;
} else {
do {
CompilerWorkOrder work = workDequeue();
dvmUnlockMutex(&gDvmJit.compilerLock);
#if defined(WITH_JIT_TUNING)
/*
* This is live across setjmp(). Mark it volatile to suppress
* a gcc warning. We should not need this since it is assigned
* only once but gcc is not smart enough.
*/
volatile u8 startTime = dvmGetRelativeTimeUsec();
#endif
/*
* Check whether there is a suspend request on me. This
* is necessary to allow a clean shutdown.
*
* However, in the blocking stress testing mode, let the
* compiler thread continue doing compilations to unblock
* other requesting threads. This may occasionally cause
* shutdown from proceeding cleanly in the standalone invocation
* of the vm but this should be acceptable.
*/
if (!gDvmJit.blockingMode)
dvmCheckSuspendPending(dvmThreadSelf());
/* Is JitTable filling up? */
if (gDvmJit.jitTableEntriesUsed >
(gDvmJit.jitTableSize - gDvmJit.jitTableSize/4)) {
bool resizeFail =
dvmJitResizeJitTable(gDvmJit.jitTableSize * 2);
/*
* If the jit table is full, consider it's time to reset
* the code cache too.
*/
gDvmJit.codeCacheFull |= resizeFail;
}
if (gDvmJit.haltCompilerThread) {
ALOGD("Compiler shutdown in progress - discarding request");
} else if (!gDvmJit.codeCacheFull) {
jmp_buf jmpBuf;
work.bailPtr = &jmpBuf;
bool aborted = setjmp(jmpBuf);
if (!aborted) {
bool codeCompiled = dvmCompilerDoWork(&work);
/*
* Make sure we are still operating with the
* same translation cache version. See
* Issue 4271784 for details.
*/
dvmLockMutex(&gDvmJit.compilerLock);
if ((work.result.cacheVersion ==
gDvmJit.cacheVersion) &&
codeCompiled &&
!work.result.discardResult &&
work.result.codeAddress) {
dvmJitSetCodeAddr(work.pc, work.result.codeAddress,
work.result.instructionSet,
false, /* not method entry */
work.result.profileCodeSize);
}
dvmUnlockMutex(&gDvmJit.compilerLock);
}
dvmCompilerArenaReset();
}
free(work.info);
#if defined(WITH_JIT_TUNING)
gDvmJit.jitTime += dvmGetRelativeTimeUsec() - startTime;
#endif
dvmLockMutex(&gDvmJit.compilerLock);
} while (workQueueLength() != 0);
}
}
pthread_cond_signal(&gDvmJit.compilerQueueEmpty);
dvmUnlockMutex(&gDvmJit.compilerLock);
/*
* As part of detaching the thread we need to call into Java code to update
* the ThreadGroup, and we should not be in VMWAIT state while executing
* interpreted code.
*/
dvmChangeStatus(NULL, THREAD_RUNNING);
if (gDvm.verboseShutdown)
ALOGD("Compiler thread shutting down");
return NULL;
}
static void resetCodeCache(void)
{
Thread* thread;
u8 startTime = dvmGetRelativeTimeUsec();
int inJit = 0;
int byteUsed = gDvmJit.codeCacheByteUsed;
/* If any thread is found stuck in the JIT state, don't reset the cache */
dvmLockThreadList(NULL);
for (thread = gDvm.threadList; thread != NULL; thread = thread->next) {
/*
* Crawl the stack to wipe out the returnAddr field so that
* 1) the soon-to-be-deleted code in the JIT cache won't be used
* 2) or the thread stuck in the JIT land will soon return
* to the interpreter land
*/
crawlDalvikStack(thread, false);
if (thread->inJitCodeCache) {
inJit++;
}
/* Cancel any ongoing trace selection */
dvmDisableSubMode(thread, kSubModeJitTraceBuild);
}
dvmUnlockThreadList();
if (inJit) {
ALOGD("JIT code cache reset delayed (%d bytes %d/%d)",
gDvmJit.codeCacheByteUsed, gDvmJit.numCodeCacheReset,
++gDvmJit.numCodeCacheResetDelayed);
return;
}
/* Lock the mutex to clean up the work queue */
dvmLockMutex(&gDvmJit.compilerLock);
/* Update the translation cache version */
gDvmJit.cacheVersion++;
/* Drain the work queue to free the work orders */
while (workQueueLength()) {
CompilerWorkOrder work = workDequeue();
free(work.info);
}
/* Reset the JitEntry table contents to the initial unpopulated state */
dvmJitResetTable();
UNPROTECT_CODE_CACHE(gDvmJit.codeCache, gDvmJit.codeCacheByteUsed);
/*
* Wipe out the code cache content to force immediate crashes if
* stale JIT'ed code is invoked.
*/
dvmCompilerCacheClear((char *) gDvmJit.codeCache + gDvmJit.templateSize,
gDvmJit.codeCacheByteUsed - gDvmJit.templateSize);
dvmCompilerCacheFlush((intptr_t) gDvmJit.codeCache,
(intptr_t) gDvmJit.codeCache + gDvmJit.codeCacheByteUsed);
PROTECT_CODE_CACHE(gDvmJit.codeCache, gDvmJit.codeCacheByteUsed);
/* Reset the current mark of used bytes to the end of template code */
gDvmJit.codeCacheByteUsed = gDvmJit.templateSize;
gDvmJit.numCompilations = 0;
/* Reset the work queue */
memset(gDvmJit.compilerWorkQueue, 0,
sizeof(CompilerWorkOrder) * COMPILER_WORK_QUEUE_SIZE);
gDvmJit.compilerWorkEnqueueIndex = gDvmJit.compilerWorkDequeueIndex = 0;
gDvmJit.compilerQueueLength = 0;
/* Reset the IC patch work queue */
dvmLockMutex(&gDvmJit.compilerICPatchLock);
gDvmJit.compilerICPatchIndex = 0;
dvmUnlockMutex(&gDvmJit.compilerICPatchLock);
/*
* Reset the inflight compilation address (can only be done in safe points
* or by the compiler thread when its thread state is RUNNING).
*/
gDvmJit.inflightBaseAddr = NULL;
/* All clear now */
gDvmJit.codeCacheFull = false;
dvmUnlockMutex(&gDvmJit.compilerLock);
ALOGD("JIT code cache reset in %lld ms (%d bytes %d/%d)",
(dvmGetRelativeTimeUsec() - startTime) / 1000,
byteUsed, ++gDvmJit.numCodeCacheReset,
gDvmJit.numCodeCacheResetDelayed);
}
/*
* Lock a monitor.
*/
static void lockMonitor(Thread* self, Monitor* mon)
{
ThreadStatus oldStatus;
u4 waitThreshold, samplePercent;
u8 waitStart, waitEnd, waitMs;
if (mon->owner == self) {
mon->lockCount++;
return;
}
if (dvmTryLockMutex(&mon->lock) != 0) {
oldStatus = dvmChangeStatus(self, THREAD_MONITOR);
waitThreshold = gDvm.lockProfThreshold;
if (waitThreshold) {
waitStart = dvmGetRelativeTimeUsec();
}
const Method* currentOwnerMethod = mon->ownerMethod;
u4 currentOwnerPc = mon->ownerPc;
dvmLockMutex(&mon->lock);
if (waitThreshold) {
waitEnd = dvmGetRelativeTimeUsec();
}
dvmChangeStatus(self, oldStatus);
if (waitThreshold) {
waitMs = (waitEnd - waitStart) / 1000;
if (waitMs >= waitThreshold) {
samplePercent = 100;
} else {
samplePercent = 100 * waitMs / waitThreshold;
}
if (samplePercent != 0 && ((u4)rand() % 100 < samplePercent)) {
const char* currentOwnerFileName = "no_method";
u4 currentOwnerLineNumber = 0;
if (currentOwnerMethod != NULL) {
currentOwnerFileName = dvmGetMethodSourceFile(currentOwnerMethod);
if (currentOwnerFileName == NULL) {
currentOwnerFileName = "no_method_file";
}
currentOwnerLineNumber = dvmLineNumFromPC(currentOwnerMethod, currentOwnerPc);
}
logContentionEvent(self, waitMs, samplePercent,
currentOwnerFileName, currentOwnerLineNumber);
}
}
}
mon->owner = self;
assert(mon->lockCount == 0);
// When debugging, save the current monitor holder for future
// acquisition failures to use in sampled logging.
if (gDvm.lockProfThreshold > 0) {
mon->ownerMethod = NULL;
mon->ownerPc = 0;
if (self->interpSave.curFrame == NULL) {
return;
}
const StackSaveArea* saveArea = SAVEAREA_FROM_FP(self->interpSave.curFrame);
if (saveArea == NULL) {
return;
}
mon->ownerMethod = saveArea->method;
mon->ownerPc = (saveArea->xtra.currentPc - saveArea->method->insns);
}
}
int dvmJarFileOpen(const char* fileName, const char* odexOutputName,
JarFile** ppJarFile, bool isBootstrap)
{
ZipArchive archive;
DvmDex* pDvmDex = NULL;
char* cachedName = NULL;
bool archiveOpen = false;
bool locked = false;
int fd = -1;
int result = -1;
if (dexZipOpenArchive(fileName, &archive) != 0)
goto bail;
archiveOpen = true;
dvmSetCloseOnExec(dexZipGetArchiveFd(&archive));
fd = openAlternateSuffix(fileName, "odex", O_RDONLY, &cachedName);
if (fd >= 0) {
ALOGV("Using alternate file (odex) for %s ...", fileName);
if (!dvmCheckOptHeaderAndDependencies(fd, false, 0, 0, true, true)) {
ALOGE("%s odex has stale dependencies", fileName);
free(cachedName);
cachedName = NULL;
close(fd);
fd = -1;
goto tryArchive;
} else {
ALOGV("%s odex has good dependencies", fileName);
}
} else {
ZipEntry entry;
tryArchive:
entry = dexZipFindEntry(&archive, kDexInJarName);
if (entry != NULL) {
bool newFile = false;
if (odexOutputName == NULL) {
cachedName = dexOptGenerateCacheFileName(fileName,
kDexInJarName);
if (cachedName == NULL)
goto bail;
} else {
cachedName = strdup(odexOutputName);
}
ALOGV("dvmJarFileOpen: Checking cache for %s (%s)",
fileName, cachedName);
fd = dvmOpenCachedDexFile(fileName, cachedName,
dexGetZipEntryModTime(&archive, entry),
dexGetZipEntryCrc32(&archive, entry),
isBootstrap, &newFile, /*createIfMissing=*/true);
if (fd < 0) {
ALOGI("Unable to open or create cache for %s (%s)",
fileName, cachedName);
goto bail;
}
locked = true;
/*
Generate the optimized DEX.
*/
if (newFile) {
u8 startWhen, extractWhen, endWhen;
bool result;
off_t dexOffset;
dexOffset = lseek(fd, 0, SEEK_CUR);
result = (dexOffset > 0);
if (result) {
startWhen = dvmGetRelativeTimeUsec();
result = dexZipExtractEntryToFile(&archive, entry, fd) == 0;
extractWhen = dvmGetRelativeTimeUsec();
}
if (result) {
result = dvmOptimizeDexFile(fd, dexOffset,
dexGetZipEntryUncompLen(&archive, entry),
fileName,
dexGetZipEntryModTime(&archive, entry),
dexGetZipEntryCrc32(&archive, entry),
isBootstrap);
}
if (!result) {
ALOGE("Unable to extract+optimize DEX from '%s'",
fileName);
goto bail;
}
endWhen = dvmGetRelativeTimeUsec();
ALOGD("DEX prep '%s': unzip in %dms, rewrite %dms",
fileName,
(int) (extractWhen - startWhen) / 1000,
(int) (endWhen - extractWhen) / 1000);
}
} else {
ALOGI("Zip is good, but no %s inside, and no valid .odex "
"file in the same directory", kDexInJarName);
goto bail;
}
}
if (dvmDexFileOpenFromFd(fd, &pDvmDex) != 0) {
ALOGI("Unable to map %s in %s", kDexInJarName, fileName);
goto bail;
}
if (locked) {
/* unlock the fd */
if (!dvmUnlockCachedDexFile(fd)) {
/* This process needs to exit or we'll wedge the system O_O */
ALOGE("Unable to unlock DEX file");
goto bail;
}
locked = false;
}
ALOGV("Successfully opened '%s' in '%s'", kDexInJarName, fileName);
*ppJarFile = (JarFile*) calloc(1, sizeof(JarFile));
(*ppJarFile)->archive = archive;
(*ppJarFile)->cacheFileName = cachedName;
(*ppJarFile)->pDvmDex = pDvmDex;
cachedName = NULL; // don't free it below
result = 0;
bail:
if (archiveOpen && result != 0)
dexZipCloseArchive(&archive);
free(cachedName);
if (fd >= 0) {
if (locked)
(void) dvmUnlockCachedDexFile(fd);
close(fd);
}
return result;
}
/*
* Perform in-place rewrites on a memory-mapped DEX file.
*
* This happens in a short-lived child process, so we can go nutty with
* loading classes and allocating memory.
*/
static bool rewriteDex(u1* addr, int len, u4* pHeaderFlags,
DexClassLookup** ppClassLookup)
{
u8 prepWhen, loadWhen, verifyOptWhen;
DvmDex* pDvmDex = NULL;
bool doVerify, doOpt;
bool result = false;
*pHeaderFlags = 0;
/* if the DEX is in the wrong byte order, swap it now */
if (dexSwapAndVerify(addr, len) != 0)
goto bail;
#if __BYTE_ORDER != __LITTLE_ENDIAN
*pHeaderFlags |= DEX_OPT_FLAG_BIG;
#endif
if (gDvm.classVerifyMode == VERIFY_MODE_NONE)
doVerify = false;
else if (gDvm.classVerifyMode == VERIFY_MODE_REMOTE)
doVerify = !gDvm.optimizingBootstrapClass;
else /*if (gDvm.classVerifyMode == VERIFY_MODE_ALL)*/
doVerify = true;
if (gDvm.dexOptMode == OPTIMIZE_MODE_NONE)
doOpt = false;
else if (gDvm.dexOptMode == OPTIMIZE_MODE_VERIFIED)
doOpt = doVerify;
else /*if (gDvm.dexOptMode == OPTIMIZE_MODE_ALL)*/
doOpt = true;
/* TODO: decide if this is actually useful */
if (doVerify)
*pHeaderFlags |= DEX_FLAG_VERIFIED;
if (doOpt)
*pHeaderFlags |= DEX_OPT_FLAG_FIELDS | DEX_OPT_FLAG_INVOCATIONS;
/*
* Now that the DEX file can be read directly, create a DexFile struct
* for it.
*/
if (dvmDexFileOpenPartial(addr, len, &pDvmDex) != 0) {
LOGE("Unable to create DexFile\n");
goto bail;
}
/*
* Create the class lookup table. This will eventually be appended
* to the end of the .odex.
*/
*ppClassLookup = dexCreateClassLookup(pDvmDex->pDexFile);
if (*ppClassLookup == NULL)
goto bail;
/*
* If we're not going to attempt to verify or optimize the classes,
* there's no value in loading them, so bail out early.
*/
if (!doVerify && !doOpt) {
result = true;
goto bail;
}
/* this is needed for the next part */
pDvmDex->pDexFile->pClassLookup = *ppClassLookup;
prepWhen = dvmGetRelativeTimeUsec();
/*
* Load all classes found in this DEX file. If they fail to load for
* some reason, they won't get verified (which is as it should be).
*/
if (!loadAllClasses(pDvmDex))
goto bail;
loadWhen = dvmGetRelativeTimeUsec();
/*
* Verify and optimize all classes in the DEX file (command-line
* options permitting).
*
* This is best-effort, so there's really no way for dexopt to
* fail at this point.
*/
verifyAndOptimizeClasses(pDvmDex->pDexFile, doVerify, doOpt);
verifyOptWhen = dvmGetRelativeTimeUsec();
const char* msgStr = "???";
if (doVerify && doOpt)
msgStr = "verify+opt";
else if (doVerify)
msgStr = "verify";
else if (doOpt)
msgStr = "opt";
LOGD("DexOpt: load %dms, %s %dms\n",
(int) (loadWhen - prepWhen) / 1000,
msgStr,
(int) (verifyOptWhen - loadWhen) / 1000);
result = true;
bail:
/* free up storage */
dvmDexFileFree(pDvmDex);
return result;
}
/* Make sure that the HeapWorker thread hasn't spent an inordinate
* amount of time inside a finalizer.
*
* Aborts the VM if the thread appears to be wedged.
*
* The caller must hold the heapWorkerLock to guarantee an atomic
* read of the watchdog values.
*/
void dvmAssertHeapWorkerThreadRunning()
{
if (gDvm.gcHeap->heapWorkerCurrentObject != NULL) {
static const u8 HEAP_WORKER_WATCHDOG_TIMEOUT = 10*1000*1000LL; // 10sec
u8 heapWorkerInterpStartTime = gDvm.gcHeap->heapWorkerInterpStartTime;
u8 now = dvmGetRelativeTimeUsec();
u8 delta = now - heapWorkerInterpStartTime;
if (delta > HEAP_WORKER_WATCHDOG_TIMEOUT &&
(gDvm.debuggerActive || gDvm.nativeDebuggerActive))
{
/*
* Debugger suspension can block the thread indefinitely. For
* best results we should reset this explicitly whenever the
* HeapWorker thread is resumed. Unfortunately this is also
* affected by native debuggers, and we have no visibility
* into how they're manipulating us. So, we ignore the
* watchdog and just reset the timer.
*/
LOGI("Debugger is attached -- suppressing HeapWorker watchdog\n");
gDvm.gcHeap->heapWorkerInterpStartTime = now; /* reset timer */
} else if (delta > HEAP_WORKER_WATCHDOG_TIMEOUT) {
/*
* Before we give up entirely, see if maybe we're just not
* getting any CPU time because we're stuck in a background
* process group. If we successfully move the thread into the
* foreground we'll just leave it there (it doesn't do anything
* if the process isn't GCing).
*/
dvmLockThreadList(NULL);
Thread* thread = dvmGetThreadByHandle(gDvm.heapWorkerHandle);
dvmUnlockThreadList();
if (thread != NULL) {
int priChangeFlags, threadPrio;
SchedPolicy threadPolicy;
priChangeFlags = dvmRaiseThreadPriorityIfNeeded(thread,
&threadPrio, &threadPolicy);
if (priChangeFlags != 0) {
LOGI("HeapWorker watchdog expired, raising priority"
" and retrying\n");
gDvm.gcHeap->heapWorkerInterpStartTime = now;
return;
}
}
char* desc = dexProtoCopyMethodDescriptor(
&gDvm.gcHeap->heapWorkerCurrentMethod->prototype);
LOGE("HeapWorker is wedged: %lldms spent inside %s.%s%s\n",
delta / 1000,
gDvm.gcHeap->heapWorkerCurrentObject->clazz->descriptor,
gDvm.gcHeap->heapWorkerCurrentMethod->name, desc);
free(desc);
dvmDumpAllThreads(true);
/* try to get a debuggerd dump from the target thread */
dvmNukeThread(thread);
/* abort the VM */
dvmAbort();
} else if (delta > HEAP_WORKER_WATCHDOG_TIMEOUT / 2) {
char* desc = dexProtoCopyMethodDescriptor(
&gDvm.gcHeap->heapWorkerCurrentMethod->prototype);
LOGW("HeapWorker may be wedged: %lldms spent inside %s.%s%s\n",
delta / 1000,
gDvm.gcHeap->heapWorkerCurrentObject->clazz->descriptor,
gDvm.gcHeap->heapWorkerCurrentMethod->name, desc);
free(desc);
}
}
}
