dex文件打开

大家好，又见面了，我是你们的朋友全栈君。

我们知道，要读取一个类代码，或读取类里的方法代码，都需要打开Ｄex文件，然后按前面介绍的格式去分析，并且读取出相应的内容，才可以给虚拟机进行解释执行。现在，我们就来学习和分析Ｄex文件的读取相关的代码。如下：

/*

*Open the specified file read-only. We memory-map the entire thingand

*parse the contents.

*

*This will be called on non-Zip files, especially during VM startup,so

*we don’t want to be too noisy about certain types of failure. (Do

*we want a “quiet” flag?)

*

*On success, we fill out the contents of “pArchive” andreturn 0.

*/

intdexZipOpenArchive(const char* fileName, ZipArchive* pArchive)

{

上面这段代码输入文件名称，输出文件内容对象。

int fd, err;

LOGV(“Opening archive ‘%s’ %p\n”,fileName, pArchive);

memset(pArchive, 0, sizeof(ZipArchive));

上面这行代码清空Ｄex文件对象。

fd = open(fileName, O_RDONLY, 0);

if (fd < 0) {

err = errno ? errno : -1;

LOGV(“Unable to open ‘%s’: %s\n”,fileName, strerror(err));

return err;

}

这段代码调用函数open来打开文件，如果不成功就输出出错提示。

return dexZipPrepArchive(fd, fileName,pArchive);

这行代码调用函数dexZipPrepArchive来生成dex文件对象。

}

在上面这个函数里，主要输入两个参数：fileName和pArchive。其中fileName是输入要打开的dex文件名称，当然它是包括文件路径的；pArchive是打开这个文件后用来表达dex文件内容的对象。代码具体过程是先调用函数memset来清空pArchive文件对象，然后调用函数open打开文件，把文件句柄传送给函数dexZipPrepArchive进

行文件分析，并把相应内容设置给文件对象pArchive。

下面来看一下pArchive对象的结构，如下：

typedefstruct ZipArchive {

/* open Zip archive */

int mFd;

这个zip文件的文件句柄，也就是上面调用open函数打开成功后句柄。

/* mapped file */

MemMapping mMap;

这个是把zip文件映射到内存，加快文件读取，提高文件读取效率。

/* number of entries in the Zip archive */

int mNumEntries;

这个是保存zip文件的入口。

/*

* We know how many entries are in the Ziparchive, so we can have a

* fixed-size hash table. We probe oncollisions.

*/

int mHashTableSize;

ZipHashEntry* mHashTable;

这里是通过hash的方法来提高读取文件速度。

}ZipArchive;

ZipArchive结构保存zip文件的句柄、文件内容映射内存地址、zip入口个数和入口地址（使用hash表达）。

这一段代码实现打开Ｄex文件，由于Ｄex文件采用zip压缩，所以需要先从zip文件里解压出来，才可以恢复到Dex原始数据。

下面来分析这个函数代码，如下：

intdexZipPrepArchive(int fd, const char* debugFileName, ZipArchive*pArchive)

{

这个函数输入文件句柄、文件名称、压缩文件对象。

MemMapping map;

int err;

map.addr = NULL;

memset(pArchive, 0, sizeof(*pArchive));

pArchive->mFd = fd;

这行代码是保存文件句柄。

if (sysMapFileInShmem(pArchive->mFd,&map) != 0) {

err = -1;

LOGW(“Map of ‘%s’ failed\n”,debugFileName);

goto bail;

}

if (map.length < kEOCDLen) {

err = -1;

LOGV(“File ‘%s’ too small to be zip(%zd)\n”, debugFileName,map.length);

goto bail;

}

这段代码映射文件数据到内存。

if (!parseZipArchive(pArchive, &map)) {

err = -1;

LOGV(“Parsing ‘%s’ failed\n”,debugFileName);

goto bail;

}

这段代码是分析zip文件。

/* success */

err = 0;

sysCopyMap(&pArchive->mMap, &map);

map.addr = NULL;

这段代码拷贝到映射位置。

bail:

if (err != 0)

dexZipCloseArchive(pArchive);

if (map.addr != NULL)

sysReleaseShmem(&map);

return err;

}

函数dexZipPrepArchive的处理，主要就是先保存文件句柄，然后创建文件内存映射，调用parseZipArchive函数来分析zip的所有入口点，并记录到相应的hash表里，最后调用sysCopyMap函数来保存到zip文件对象结构里。

由上面分析可知，dex文件是压缩成zip文件，这样可以减少占用空间。dex文件在系统里是怎么样打开的过程呢？其它经过下面的过程：

１）系统初始化虚拟机时，会初始化原始方法gDvmNativeMethodSet集合。

２）在原始方法集合里有一个函数集合dvm_dalvik_system_DexFile，注册它为Ldalvik/system/DexFile串，当虚拟机调用ＤexFile相关函数时，就会调用这些函数来处理Dex文件。

３）在处理Dex文件时，会调用函数集合：dvm_dalvik_system_DexFile，这个函数集合里，主要有如下函数：

constDalvikNativeMethod dvm_dalvik_system_DexFile[] = {

{“openDexFile”, “(Ljava/lang/String;Ljava/lang/String;I)I”,

Dalvik_dalvik_system_DexFile_openDexFile},

{“closeDexFile”, “(I)V”,

Dalvik_dalvik_system_DexFile_closeDexFile},

{“defineClass”, “(Ljava/lang/String;Ljava/lang/ClassLoader;ILjava/security/ProtectionDomain;)Ljava/lang/Class;”,

Dalvik_dalvik_system_DexFile_defineClass},

{“getClassNameList”, “(I)[Ljava/lang/String;”,

Dalvik_dalvik_system_DexFile_getClassNameList},

{“isDexOptNeeded”, “(Ljava/lang/String;)Z”,

Dalvik_dalvik_system_DexFile_isDexOptNeeded},

{NULL, NULL, NULL },

};

openDexFile方法对应的原始函数是Dalvik_dalvik_system_DexFile_openDexFile，它是打开Ｄex文件函数。

closeDexFile方法对应的原始函数是Dalvik_dalvik_system_DexFile_closeDexFile，它是关闭已经打开的Ｄex文件函数。

４）在Dalvik_dalvik_system_DexFile_openDexFile函数里，调用函数dvmJarFileOpen打开JAR或者ZIP压缩的文件。

５）在dvmJarFileOpen函数里，调用dexZipOpenArchive来处理ZIP文件，调用dexZipFindEntry函数读取ZIP解压的文件，调用dvmDexFileOpenFromFd函数读取相应的类数据到内存，并返回给虚拟机。

从上面可知调用函数Dalvik_dalvik_system_DexFile_openDexFile来打开Ｄex文件，这个函数的源码如下：

staticvoid Dalvik_dalvik_system_DexFile_openDexFile(const u4* args,

JValue* pResult)

{

StringObject* sourceNameObj =(StringObject*) args[0];

这行是输入的Jar或Ｄex文件名参数。

StringObject* outputNameObj =(StringObject*) args[1];

这行是输出的文件名参数。

int flags = args[2];

这行是处理的标示。

DexOrJar* pDexOrJar = NULL;

JarFile* pJarFile;

RawDexFile* pRawDexFile;

char* sourceName;

char* outputName;

if (sourceNameObj == NULL) {

dvmThrowException(“Ljava/lang/NullPointerException;”,NULL);

RETURN_VOID();

}

这段代码是当输入文件名称为空对象时，就抛出异常。

sourceName =dvmCreateCstrFromString(sourceNameObj);

这行代码调用函数dvmCreateCstrFromString把java字符串转换Ｃ字符串，由于Ｊava对象表示的字符串并不能立即就使用到Ｃ语言里，所以需要转换才能使用。

if (outputNameObj != NULL)

outputName =dvmCreateCstrFromString(outputNameObj);

else

outputName = NULL;

这段代码是同样把输出字符串转换Ｃ字符串。

/*

* We have to deal with the possibility thatsomebody might try to

* open one of our bootstrap class DEXfiles. The set of dependencies

* will be different, and hence the resultsof optimization might be

* different, which means we’d actually needto have two versions of

* the optimized DEX: one that only knowsabout part of the boot class

* path, and one that knows about everythingin it. The latter might

* optimize field/method accesses based on aclass that appeared later

* in the class path.

*

* We can’t let the user-defined classloader open it and start using

* the classes, since the optimized form ofthe code skips some of

* the method and field resolution that wewould ordinarily do, and

* we’d have the wrong semantics.

*

* We have to reject attempts to manuallyopen a DEX file from the boot

* class path. The easiest way to do thisis by filename, which works

* out because variations in name (e.g.”/system/framework/./ext.jar”)

* result in us hitting a differentdalvik-cache entry. It’s also fine

* if the caller specifies their own outputfile.

*/

if(dvmClassPathContains(gDvm.bootClassPath, sourceName)) {

LOGW(“Refusing to reopen boot DEX’%s’\n”, sourceName);

dvmThrowException(“Ljava/io/IOException;”,

“Re-opening BOOTCLASSPATH DEXfiles is not allowed”);

free(sourceName);

RETURN_VOID();

}

这段代码是判断用户是否加载系统目录下面的Ｄex文件，如果加载就要拒绝这样的操作，因为系统启动时已经加载了一份这样的优化代码，没有必要再次加载一次。

/*

* Try to open it directly as a DEX. Ifthat fails, try it as a Zip

* with a “classes.dex” inside.

*/

if (dvmRawDexFileOpen(sourceName,outputName, &pRawDexFile, false) == 0) {

LOGV(“Opening DEX file ‘%s'(DEX)\n”, sourceName);

pDexOrJar = (DexOrJar*)malloc(sizeof(DexOrJar));

pDexOrJar->isDex = true;

pDexOrJar->pRawDexFile = pRawDexFile;

这段代码是尝试加载Ｄex文件，但基本不存在直接加Ｄex文件的情况，因此在函数dvmRawDexFileOpen还是空函数，没有实际的内容。

}else if (dvmJarFileOpen(sourceName, outputName, &pJarFile, false)== 0) {

LOGV(“Opening DEX file ‘%s'(Jar)\n”, sourceName);

pDexOrJar = (DexOrJar*)malloc(sizeof(DexOrJar));

pDexOrJar->isDex = false;

pDexOrJar->pJarFile = pJarFile;

这段代码是加载Jar文件，就是从这里加载Dex文件到缓存里。

}else {

LOGV(“Unable to open DEX file’%s’\n”, sourceName);

dvmThrowException(“Ljava/io/IOException;”,”unable to open DEX file”);

}

if (pDexOrJar != NULL) {

pDexOrJar->fileName = sourceName;

这行代码保存文件名称到Dex文件对象里。

/* add to hash table */

u4 hash = dvmComputeUtf8Hash(sourceName);

这行代码通过文件名称计算ＨＡＳＨ串，加速对文件的查找速度。

void* result;

dvmHashTableLock(gDvm.userDexFiles);

result =dvmHashTableLookup(gDvm.userDexFiles, hash, pDexOrJar,

hashcmpDexOrJar, true);

dvmHashTableUnlock(gDvm.userDexFiles);

这段代码添加ＨＡＳＨ表里，以便后面查找使用。

if (result != pDexOrJar) {

LOGE(“Pointer has already beenadded?\n”);

dvmAbort();

}

pDexOrJar->okayToFree = true;

}else

free(sourceName);

RETURN_PTR(pDexOrJar);

这行代码返回打开的文件对象。

}

这个函数是通过JAVA调用时输入Ｄex文件名称，然后加载Ｄex文件，最后把这个文件名称放到ＨＡＳＨ表里，然后返回打开的对象。

在上面的函数里，提到使用dvmJarFileOpen函数找到classes.dex文件，并加载到内存里，然后提供后面的函数使用。现在就来分析这个函数的代码，如下：

intdvmJarFileOpen(const char* fileName, const char* odexOutputName,

JarFile** ppJarFile, bool isBootstrap)

{

在这里提供四个参数，第一个参数fileName是输入的Ｊar的文件名称；第二个参数odexOutputName是进行优化后的Ｄex输出文件；第三个参数ppJarFile是已经打开并缓存到内存里的文件对象；第四个参数isBootstrap是指示是否系统里Ｄex文件。

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 thearchive, we need to

* open it so we can stuff it intoppJarFile.

*/

if (dexZipOpenArchive(fileName, &archive)!= 0)

goto bail;

archiveOpen = true;

这段代码是调用前面介绍的函数dexZipOpenArchive来打开Ｚip文件，并缓存到系统内存里。

/* If we fork/exec into dexopt, don’t letit 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 theextension.

*/

fd = openAlternateSuffix(fileName, “odex”,O_RDONLY, &cachedName);

if (fd >= 0) {

这里优先处理优化的Dex文件。

LOGV(“Using alternate file (odex)for %s …\n”, fileName);

if (!dvmCheckOptHeaderAndDependencies(fd,false, 0, 0, true, true)) {

LOGE(“%s odex has staledependencies\n”, fileName);

free(cachedName);

close(fd);

fd = -1;

goto tryArchive;

} else {

LOGV(“%s odex has gooddependencies\n”, fileName);

//TODO: make sure that the .odexactually corresponds

// to the classes.dex inside thearchive (if present).

// For typical use there will beno classes.dex.

}

}else {

ZipEntry entry;

tryArchive:

/*

* Pre-created .odex absent or stale. Look inside the jar for a

* “classes.dex”.

*/

entry = dexZipFindEntry(&archive,kDexInJarName);

这行代码是从压缩包里找到Dex文件，然后打开这个文件。

if (entry != NULL) {

bool newFile = false;

/*

* We’ve found the one we want. Seeif there’s an up-to-date copy

* in the cache.

*

* On return, “fd” will beseeked just past the “opt” header.

*

* If a stale .odex file is presentand classes.dex exists in

* the archive, this will *not*return an fd pointing to the

* .odex file; the fd will point intodalvik-cache like any

* other jar.

*/

if (odexOutputName == NULL) {

cachedName =dexOptGenerateCacheFileName(fileName,

kDexInJarName);

if (cachedName == NULL)

goto bail;

这段代码是把Dex文件进行优化处理，并输出到指定的文件。

} else {

cachedName =strdup(odexOutputName);

}

LOGV(“dvmDexCacheStatus:Checking cache for %s (%s)\n”,

fileName, cachedName);

fd = dvmOpenCachedDexFile(fileName,cachedName,

dexGetZipEntryModTime(&archive,entry),

dexGetZipEntryCrc32(&archive,entry),

isBootstrap, &newFile,/*createIfMissing=*/true);

这段代码创建缓存的优化文件。

if (fd < 0) {

LOGI(“Unable to open orcreate cache for %s (%s)\n”,

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 isstill locked, and is positioned

* just past the optimization header.

*/

if (newFile) {

u8 startWhen, extractWhen,endWhen;

bool result;

off_t dexOffset, fileLen;

dexOffset = lseek(fd, 0,SEEK_CUR);

result = (dexOffset > 0);

if (result) {

startWhen =dvmGetRelativeTimeUsec();

result =dexZipExtractEntryToFile(&archive, entry, fd);

extractWhen =dvmGetRelativeTimeUsec();

这段代码调用函数dexZipExtractEntryToFile从压缩包里解压文件出来。

}

if (result) {

result =dvmOptimizeDexFile(fd, dexOffset,

dexGetZipEntryUncompLen(&archive,entry),

fileName,

dexGetZipEntryModTime(&archive,entry),

dexGetZipEntryCrc32(&archive,entry),

isBootstrap);

这段代码调用函数dvmOptimizeDexFile对Ｄex文件进行优化处理。

}

if (!result) {

LOGE(“Unable toextract+optimize DEX from ‘%s’\n”,

fileName);

goto bail;

}

endWhen =dvmGetRelativeTimeUsec();

LOGD(“DEX prep ‘%s’: unzipin %dms, rewrite %dms\n”,

fileName,

(int) (extractWhen -startWhen) / 1000,

(int) (endWhen – extractWhen)/ 1000);

}

} else {

LOGI(“Zip is good, but no %sinside, and no valid .odex “

“file in the samedirectory\n”, kDexInJarName);

goto bail;

}

}

/*

* Map the cached version. This immediatelyrewinds the fd, so it

* doesn’t have to be seeked anywhere inparticular.

*/

if (dvmDexFileOpenFromFd(fd, &pDvmDex)!= 0) {

LOGI(“Unable to map %s in %s\n”,kDexInJarName, fileName);

goto bail;

}

这段代码是调用函数dvmDexFileOpenFromFd来缓存Ｄex文件，并分析文件的内容。比如标记是否优化的文件，通过签名检查Dex文件是否合法。

if (locked) {

/* unlock the fd */

if (!dvmUnlockCachedDexFile(fd)) {

/* uh oh — this process needs toexit or we’ll wedge the system */

LOGE(“Unable to unlock DEXfile\n”);

goto bail;

}

locked = false;

}

这段代码是保存文件到缓存里，标记这个文件句柄已经保存到缓存。

LOGV(“Successfully opened ‘%s’ in’%s’\n”, kDexInJarName, fileName);

*ppJarFile = (JarFile*) calloc(1,sizeof(JarFile));

(*ppJarFile)->archive = archive;

(*ppJarFile)->cacheFileName =cachedName;

(*ppJarFile)->pDvmDex = pDvmDex;

cachedName = NULL; // don’t free itbelow

result = 0;

这段代码已经成功打开压缩包，并读取Dex文件到内存缓存，这里只是设置一些相关信息返回前面的函数处理。

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;

}

本函数主要流程是打开压缩文件，然后找到Ｄex文件，读取出来，并进行分析，然后拷贝到缓存里，再返回给调用函数

发布者：全栈程序员栈长，转载请注明出处：https://javaforall.cn/153520.html原文链接：https://javaforall.cn