对于一个Android的apk应用程序,其主要的执行代码都在其中的class.dex文件中。在程序第一次被加载的时候,为了提高以后的启动速度和执行效率,Android系统会对这个class.dex文件做一定程度的优化,并生成一个ODEX文件,存放在/data/dalvik-cache目录下。以后再运行这个程序的时候,就只要直接加载这个优化过的ODEX文件就行了,省去了每次都要优化的时间。
不过,这个优化过程会根据不同设备上Dalvik虚拟机的版本、Framework库的不同等因素而不同。在一台设备上被优化过的ODEX文件,拷贝到另一台设备上不一定能够运行。
那么,这个对应的ODEX文件到底包含了哪些内容呢?本文就通过分析Android代码中,对应生成ODEX文件的代码,来一步步解释其中的奥秘。
Android是通过dexopt程序对DEX文件进行优化的,除去一些参数的解释,我们选择其中的processZipFile函数作为切入点,这个函数是dexopt程序用来处理一个待优化的apk文件的(代码位于dalvik\dexopt\OptMain.cpp中):
static int processZipFile(int zipFd, int cacheFd, const char* zipName,
const char *dexoptFlags)
{
……
const char* bcp = getenv("BOOTCLASSPATH");
……
bool isBootstrap = false;
const char* match = strstr(bcp, zipName);
if (match != NULL) {
……
isBootstrap = true;
}
int result = extractAndProcessZip(zipFd, cacheFd, zipName, isBootstrap,
bcp, dexoptFlags);
……
return result;
}
先来说说这个函数的几个入参,zipFd是要优化的那个apk应用程序的文件句柄,cacheFd是要优化后存放的那个ODEX文件的句柄,dexoptFlags表示的是优化模式。
首先,函数要获得系统中环境变量BOOTCLASSPATH的值(这个值通常是设置在init.rc中)。接下来,还要判断一下是要优化的这个程序是否就是BOOTCLASSPATH中的某一个,我们要分析的是优化自己写的程序,所以isBootstrap的值是false。
该函数接下来调用extractAndProcessZip函数。这个函数看起来比较长,我们可以顺着它的处理逻辑来分段解释一下:
static int extractAndProcessZip(int zipFd, int cacheFd,
const char* debugFileName, bool isBootstrap, const char* bootClassPath,
const char* dexoptFlagStr)
{
ZipArchive zippy;
ZipEntry zipEntry;
size_t uncompLen;
long modWhen, crc32;
off_t dexOffset;
int err;
int result = -1;
int dexoptFlags = 0;
DexClassVerifyMode verifyMode = VERIFY_MODE_ALL;
DexOptimizerMode dexOptMode = OPTIMIZE_MODE_VERIFIED;
……
err = dexOptCreateEmptyHeader(cacheFd);
if (err != 0)
goto bail;
……
首先,函数中会调用函数dexOptCreateEmptyHeader(代码位于dalvik\libdex\OptInvocation.cpp中):
int dexOptCreateEmptyHeader(int fd)
{
DexOptHeader optHdr;
ssize_t actual;
……
memset(&optHdr, 0xff, sizeof(optHdr));
optHdr.dexOffset = sizeof(optHdr);
actual = write(fd, &optHdr, sizeof(optHdr));
if (actual != sizeof(optHdr)) {
int err = errno ? errno : -1;
return errno;
}
return 0;
}
这个函数就是构造了一个DexOptHeader结构体,将结构体中的所有字节全部赋值成0xff。不过,函数内还是给结构体中的dexOffset变量赋了值,其值是DexOptHeader结构体的大小。最后,将其写入要优化成的那个ODEX文件中。当然,这个头几乎是空的,没什么用,后面这个头还会被改写。
我们来看看这个结构体是什么样的(代码位于dalvik\libdex\DexFile.h中):
struct DexOptHeader {
u1 magic[8];
u4 dexOffset;
u4 dexLength;
u4 depsOffset;
u4 depsLength;
u4 optOffset;
u4 optLength;
u4 flags;
u4 checksum;
};
1)前面的8个字节magic[8]是魔数头,表明这个文件是一个ODEX文件,其会被设置成“dey\n036\0”;
2)接着的4个字节dexOffset表示ODEX文件中包含的那个DEX文件在ODEX文件中的偏移;
3)接着的4个字节dexLength表示ODEX文件中包含的那个DEX文件的长度;
4)接着的4个字节depsOffset表示依赖库列表段的偏移;
5)接着的4个字节depsLength表示表示依赖库列表段的长度;
6)接着的4个字节optOffset表示优化数据段的偏移;
7)接着的4个字节optLength表示优化数据段的长度。
这也就解释了为什么在dexOptCreateEmptyHeader函数中dexOffset会被设置成结构体DexOptHeader的大小,说明在这个DexOptHeader结构体后面紧接着就会放原始的待优化的那个DEX文件。
好,我们还是回到extractAndProcessZip函数中:
……
dexOffset = lseek(cacheFd, 0, SEEK_CUR);
if (dexOffset < 0)
goto bail;
……
zipEntry = dexZipFindEntry(&zippy, kClassesDex);
if (zipEntry == NULL) {
goto bail;
}
if (dexZipGetEntryInfo(&zippy, zipEntry, NULL, &uncompLen, NULL, NULL,
&modWhen, &crc32) != 0)
{
goto bail;
}
uncompLen = uncompLen;
modWhen = modWhen;
crc32 = crc32;
if (dexZipExtractEntryToFile(&zippy, zipEntry, cacheFd) != 0) {
goto bail;
}
……
首先,会通过读取ODEX文件的当前指针位置来获得DEX文件偏移的大小(其实没必要,前面看到了,这个偏移一定就是DexOptHeader结构体的大小)。然后,找到这个apk文件中,“class.dex”文件的ZIP项(apk文件其实就是一个zip文件)。通过这个ZIP项,可以获得对应文件的一些信息,包括它的长度、修改时间和CRC校验值。最后,将这个class.dex文件直接写到ODEX文件中去。
分析到这里,可以看出在ODEX文件中,其实是包含了一个完整的DEX文件的。不过在后面的优化步骤中,其中的某些指令会被优化(通过rewriteDex函数,有机会会另外介绍这个),和原始的那个DEX文件已经并不完全相同了。
好,我们接着看extractAndProcessZip函数:
……
if (!dvmContinueOptimization(cacheFd, dexOffset, uncompLen, debugFileName,
modWhen, crc32, isBootstrap))
{
goto bail;
}
result = 0;
bail:
……
return result;
}
该函数接着调用了dvmContinueOptimization函数(代码位于dalvik\vm\analysis\DexPrepare.cpp中),接着优化:
bool dvmContinueOptimization(int fd, off_t dexOffset, long dexLength,
const char* fileName, u4 modWhen, u4 crc, bool isBootstrap)
{
DexClassLookup* pClassLookup = NULL;
RegisterMapBuilder* pRegMapBuilder = NULL;
……
off_t depsOffset, optOffset, endOffset, adjOffset;
int depsLength, optLength;
u4 optChecksum;
depsOffset = lseek(fd, 0, SEEK_END);
if (depsOffset < 0) {
goto bail;
}
adjOffset = (depsOffset + 7) & ~(0x07);
if (adjOffset != depsOffset) {
depsOffset = adjOffset;
lseek(fd, depsOffset, SEEK_SET);
}
if (writeDependencies(fd, modWhen, crc) != 0) {
goto bail;
}
……
代码首先通过读取ODEX文件当前末尾的位置,获得了存放所谓依赖(Dependency)库列表的位置。不过,这个依赖库列表必须被存放到64比特对齐的位置,也就是8字节对齐,所以接下来的代码还要计算一下修正后的位置,并把当前文件指针指向那里。接着调用了writeDependencies函数,写入依赖库列表。那么,这个依赖库列表到底是什么东西,该以什么样的格式存放呢?我们接着看writeDependencies函数的实现(代码位于dalvik\vm\analysis\DexPrepare.cpp中):
static int writeDependencies(int fd, u4 modWhen, u4 crc)
{
u1* buf = NULL;
int result = -1;
ssize_t bufLen;
ClassPathEntry* cpe;
int numDeps;
numDeps = 0;
bufLen = 0;
for (cpe = gDvm.bootClassPath; cpe->ptr != NULL; cpe++) {
const char* cacheFileName =
dvmPathToAbsolutePortion(getCacheFileName(cpe));
assert(cacheFileName != NULL);
numDeps++;
bufLen += strlen(cacheFileName) +1;
}
bufLen += 4*4 + numDeps * (4+kSHA1DigestLen);
……
可以看到,所谓的依赖库列表,其实就是全局变量gDvm中bootClassPath变量中存放的所有ClassPathEntry,其实也就是系统环境变量BOOTCLASSPATH中存放的列表。这些指定的库,都会被预先加载进Dalvik虚拟机,供你的程序直接使用。
代码首先将所有的依赖库都遍历一遍,获得该库文件对应的优化文件的绝对路径(依赖库本身也是一个程序,同样是跑在Dalvik虚拟机下的,照样会被优化)。这次遍历其实只是想计算一下到底要开多大的缓存存放全部要写入ODEX文件的数据,所以最后会把这个路径的长度加上1(因为字符串最后要补上“\0”)累加到bufLen变量中。循环结束后,只是得到了所有依赖库路径字符串的长度,还要加上一个头的长度(4个4字节结构体),同时对每个依赖库还要记录下它的SHA1摘要,因此还要加上摘要的长度。
好了,在堆上分配好空间之后,就要开始正式写数据了:
……
buf = (u1*)malloc(bufLen);
set4LE(buf+0, modWhen);
set4LE(buf+4, crc);
set4LE(buf+8, DALVIK_VM_BUILD);
set4LE(buf+12, numDeps);
u1* ptr = buf + 4*4;
for (cpe = gDvm.bootClassPath; cpe->ptr != NULL; cpe++) {
const char* cacheFileName =
dvmPathToAbsolutePortion(getCacheFileName(cpe));
assert(cacheFileName != NULL);
const u1* signature = getSignature(cpe);
int len = strlen(cacheFileName) +1;
……
set4LE(ptr, len);
ptr += 4;
memcpy(ptr, cacheFileName, len);
ptr += len;
memcpy(ptr, signature, kSHA1DigestLen);
ptr += kSHA1DigestLen;
}
assert(ptr == buf + bufLen);
result = sysWriteFully(fd, buf, bufLen, "DexOpt dep info");
free(buf);
return result;
}
首先要写入一个头,其主要有4个4字节组成,结构如下:
1)最开始4个字节写的是前面获得的class.dex文件的修改时间;
2)接着的4个字节是class.dex文件的CRC校验值;
3)接着的4个字节是当前Dalvik虚拟机的版本号,对于Android 4.4.2系统来说,其值是27(代码位于dalvik\vm\DalvikVersion.h中);
#define DALVIK_VM_BUILD 27
4) 最后的4个字节是表示到底有多少个依赖库。
注意,这些值都是以小端(Little-Endian)字节序写入的。
接着,代码又遍历了一遍所有的依赖库,对于每一条依赖库来说,都要写入其优化文件名字符串长度、优化文件名字符串还有这个依赖库的SHA1值。
最后,将缓存里的值全部写入ODEX文件中。
好了,写完了依赖库,我们还是回到dvmContinueOptimization函数中:
……
optOffset = lseek(fd, 0, SEEK_END);
depsLength = optOffset - depsOffset;
adjOffset = (optOffset + 7) & ~(0x07);
if (adjOffset != optOffset) {
optOffset = adjOffset;
lseek(fd, optOffset, SEEK_SET);
}
if (!writeOptData(fd, pClassLookup, pRegMapBuilder)) {
goto bail;
}
……
处理的逻辑和前面很像,也还是要8字节对齐,不过这次要写的是所谓的优化数据(Optimization Data)。那么优化数据包含哪些呢?我们接着看writeOptData函数的实现(代码位于dalvik\vm\analysis\DexPrepare.cpp中):
static bool writeOptData(int fd, const DexClassLookup* pClassLookup,
const RegisterMapBuilder* pRegMapBuilder)
{
if (!writeChunk(fd, (u4) kDexChunkClassLookup,
pClassLookup, pClassLookup->size))
{
return false;
}
if (pRegMapBuilder != NULL) {
if (!writeChunk(fd, (u4) kDexChunkRegisterMaps,
pRegMapBuilder->data, pRegMapBuilder->size))
{
return false;
}
}
if (!writeChunk(fd, (u4) kDexChunkEnd, NULL, 0)) {
return false;
}
return true;
}
可以看出,代码写了两个数据块(Chunk),再写了一个表示结尾的数据块,就结束了。那么,数据块的结构又是怎样的呢?我们接着看writeChunk函数(代码位于dalvik\vm\analysis\DexPrepare.cpp中):
static bool writeChunk(int fd, u4 type, const void* data, size_t size)
{
union {
char raw[8];
struct {
u4 type;
u4 size;
} ts;
} header;
……
header.ts.type = type;
header.ts.size = (u4) size;
if (sysWriteFully(fd, &header, sizeof(header),
"DexOpt opt chunk header write") != 0)
{
return false;
}
if (size > 0) {
if (sysWriteFully(fd, data, size, "DexOpt opt chunk write") != 0)
return false;
}
if ((size & 7) != 0) {
int padSize = 8 - (size & 7);
lseek(fd, padSize, SEEK_CUR);
}
assert( ((int)lseek(fd, 0, SEEK_CUR) & 7) == 0);
return true;
}
可以看到,每一个数据块都有一个8字节的头,前4字节表示这个数据块的类型,后4个字节表示这个数据块占用多少字节的空间。头之后,就是数据块的具体内容。最后,还要保证数据块8字节对齐,适当的在后面填充数据。
数据块的类型主要有三种,分别是(代码位于dalvik\libdex\DexFile.h中):
enum {
kDexChunkClassLookup = 0x434c4b50,
kDexChunkRegisterMaps = 0x524d4150,
kDexChunkEnd = 0x41454e44,
};
第一种类型是用来存放针对该DEX文件的DexClassLookup结构,它主要是用来帮助快速查找DEX中的某个类的,想要具体了解的话,可以参考《Dalvik虚拟机中DexClassLookup结构解析》一文。
最后一种类型只是用来表示数据块结束了,没什么好说的。
第二种类型是用来存放针对该DEX文件的寄存器图(Register Map)信息的,它主要用来帮助Dalvik虚拟机做精确GC用的。在《Dalvik虚拟机中RegisterMap结构解析》一文中,我介绍了一下RegisterMap的大致结构以及用处。不过RegisterMap是针对某一个方法的,而DEX文件中有包含了许多类,每个类又有很多方法,这就需要将大量不同的RegisterMap结构按照某种规则存放下来。我们在前面的代码可以看到,这个块的数据是通过一个叫做RegisterMapBuilder的结构体来储存的,而这个结构体又是通过dvmGenerateRegisterMaps函数获得的(代码位于dalvik\vm\analysis\DexPrepare.cpp内的dvmContinueOptimization函数中):
……
if (dvmDexFileOpenPartial(dexAddr, dexLength, &pDvmDex) != 0) {
success = false;
} else {
if (gDvm.generateRegisterMaps) {
pRegMapBuilder = dvmGenerateRegisterMaps(pDvmDex);
if (pRegMapBuilder == NULL) {
success = false;
}
}
DexHeader* pHeader = (DexHeader*)pDvmDex->pHeader;
updateChecksum(dexAddr, dexLength, pHeader);
dvmDexFileFree(pDvmDex);
}
……
我们先来看看RegisterMapBuilder结构体里有什么(代码位于dalvik\vm\analysis\RegisterMap.h中):
struct RegisterMapBuilder {
void* data;
size_t size;
MemMapping memMap;
};
没什么特别的,有一个存放数据的data域,一个估计是表明数据大小的size域,还有一个私有的memMap域。
既然什么想要的信息都没有,那接下来我们只能顺藤摸瓜,看看这个结构体中的数据是如何生成的(代码位于dalvik\vm\analysis\RegisterMap.cpp中):
RegisterMapBuilder* dvmGenerateRegisterMaps(DvmDex* pDvmDex)
{
RegisterMapBuilder* pBuilder;
pBuilder = (RegisterMapBuilder*) calloc(1, sizeof(RegisterMapBuilder));
if (pBuilder == NULL)
return NULL;
if (sysCreatePrivateMap(4 * 1024 * 1024, &pBuilder->memMap) != 0) {
free(pBuilder);
return NULL;
}
size_t actual = writeMapsAllClasses(pDvmDex, (u1*)pBuilder->memMap.addr,
pBuilder->memMap.length);
if (actual == 0) {
dvmFreeRegisterMapBuilder(pBuilder);
return NULL;
}
pBuilder->data = pBuilder->memMap.addr;
pBuilder->size = actual;
return pBuilder;
}
代码很简单,主要是在内存中开了一个足够大的空间,然后调用函数writeMapsAllClasses对其进行写入,最后将内存空间的地址和实际写入的字节数放到data和size域中。所以,奥秘应该就在函数writeMapsAllClasses函数里(代码位于dalvik\vm\analysis\RegisterMap.cpp中):
static size_t writeMapsAllClasses(DvmDex* pDvmDex, u1* basePtr, size_t length)
{
DexFile* pDexFile = pDvmDex->pDexFile;
u4 count = pDexFile->pHeader->classDefsSize;
RegisterMapClassPool* pClassPool;
u4* offsetTable;
u1* ptr = basePtr;
u4 idx;
pClassPool = (RegisterMapClassPool*) ptr;
ptr += offsetof(RegisterMapClassPool, classDataOffset);
offsetTable = (u4*) ptr;
ptr += count * sizeof(u4);
pClassPool->numClasses = count;
for (idx = 0; idx < count; idx++) {
const DexClassDef* pClassDef;
const char* classDescriptor;
ClassObject* clazz;
pClassDef = dexGetClassDef(pDexFile, idx);
classDescriptor = dexStringByTypeIdx(pDexFile, pClassDef->classIdx);
clazz = NULL;
if ((pClassDef->accessFlags & CLASS_ISPREVERIFIED) != 0)
clazz = dvmLookupClass(classDescriptor, NULL, false);
if (clazz != NULL) {
offsetTable[idx] = ptr - basePtr;
if (!writeMapsAllMethods(pDvmDex, clazz, &ptr,
length - (ptr - basePtr)))
{
return 0;
}
ptr = align32(ptr);
} else {
assert(offsetTable[idx] == 0);
}
}
if (ptr - basePtr >= (int)length) {
dvmAbort();
}
return ptr - basePtr;
}
代码中又涉及到了一个新的结构体RegisterMapMethodPool(代码位于dalvik\vm\analysis\RegisterMap.h中):
struct RegisterMapClassPool {
u4 numClasses;
u4 classDataOffset[1];
};
所以,代码首先写入了DEX文件中存放的所有类的个数。接着遍历DEX文件中的所有类,先是填写一个所谓的偏移表,其中的每一项都是4个字节,有几个类就有几项。每一项的值都表示其后的一块数据相对于结构体头之间的偏移。并且那块数据所代表的类在DEX文件中出现的下标,就是这个偏移表的下标。最后,对每一个类,调用writeMapsAllMethods函数,在指定偏移位置写入数据。注意,每个类的数据并不一定是紧挨着存放的,因为每块数据要32比特对齐。
static bool writeMapsAllMethods(DvmDex* pDvmDex, const ClassObject* clazz,
u1** pPtr, size_t length)
{
RegisterMapMethodPool* pMethodPool;
u1* ptr = *pPtr;
int i, methodCount;
if (clazz->virtualMethodCount + clazz->directMethodCount >= 65536) {
return false;
}
pMethodPool = (RegisterMapMethodPool*) ptr;
ptr += offsetof(RegisterMapMethodPool, methodData);
methodCount = 0;
for (i = 0; i < clazz->directMethodCount; i++) {
const Method* meth = &clazz->directMethods[i];
if (dvmIsMirandaMethod(meth))
continue;
if (!writeMapForMethod(&clazz->directMethods[i], &ptr)) {
return false;
}
methodCount++;
}
for (i = 0; i < clazz->virtualMethodCount; i++) {
const Method* meth = &clazz->virtualMethods[i];
if (dvmIsMirandaMethod(meth))
continue;
if (!writeMapForMethod(&clazz->virtualMethods[i], &ptr)) {
return false;
}
methodCount++;
}
pMethodPool->methodCount = methodCount;
*pPtr = ptr;
return true;
}
这里又引入了一个叫做RegisterMapMethodPool的结构体(代码位于dalvik\vm\analysis\RegisterMap.h中):
struct RegisterMapMethodPool {
u2 methodCount;
u4 methodData[1];
};
也没什么重要的信息,所以还是只能回过头看writeMapsAllMethods函数的实现。通过阅读可以看出,代码遍历了类中所有的函数,不过是以先直接方法后虚拟方法的顺序遍历的(同时还可以看出,一个类中的所有方法数目不能超过65535)。然后对每一个方法调用writeMapForMethod(代码位于dalvik\vm\analysis\RegisterMap.cpp中)函数,顺序的在methodData段写入数据(不用考虑对齐的问题):
static bool writeMapForMethod(const Method* meth, u1** pPtr)
{
if (meth->registerMap == NULL) {
*(*pPtr)++ = kRegMapFormatNone;
return true;
}
size_t mapSize = computeRegisterMapSize(meth->registerMap);
memcpy(*pPtr, meth->registerMap, mapSize);
assert(**pPtr == meth->registerMap->format);
**pPtr &= ~(kRegMapFormatOnHeap);
*pPtr += mapSize;
return true;
}
很简单,直接写入对应方法的寄存器图RegisterMap结构体数据就好了。如果方法没有寄存器图RegisterMap的话,就写入一个字节,值为kRegMapFormatNone(1)。关于RegisterMap的结构以及用处,可以参考《Dalvik虚拟机中RegisterMap结构解析》一文。
最后,再回到函数dvmContinueOptimization中,看看收尾的工作:
……
endOffset = lseek(fd, 0, SEEK_END);
optLength = endOffset - optOffset;
if (!computeFileChecksum(fd, depsOffset,
(optOffset+optLength) - depsOffset, &optChecksum))
{
goto bail;
}
DexOptHeader optHdr;
memset(&optHdr, 0xff, sizeof(optHdr));
memcpy(optHdr.magic, DEX_OPT_MAGIC, 4);
memcpy(optHdr.magic+4, DEX_OPT_MAGIC_VERS, 4);
optHdr.dexOffset = (u4) dexOffset;
optHdr.dexLength = (u4) dexLength;
optHdr.depsOffset = (u4) depsOffset;
optHdr.depsLength = (u4) depsLength;
optHdr.optOffset = (u4) optOffset;
optHdr.optLength = (u4) optLength;
#if __BYTE_ORDER != __LITTLE_ENDIAN
optHdr.flags = DEX_OPT_FLAG_BIG;
#else
optHdr.flags = 0;
#endif
optHdr.checksum = optChecksum;
fsync(fd);
lseek(fd, 0, SEEK_SET);
if (sysWriteFully(fd, &optHdr, sizeof(optHdr), "DexOpt opt header") != 0)
goto bail;
result = true;
bail:
dvmFreeRegisterMapBuilder(pRegMapBuilder);
free(pClassLookup);
return result;
}
这里主要是重写处于ODEX头部的DexOptHeader结构体中的数据。最开始的魔数是“dey\n036\0”(代码位于dalvik\libdex\DexFile.h中):
#define DEX_OPT_MAGIC "dey\n"
#define DEX_OPT_MAGIC_VERS "036\0"
下面是DEX文件的偏移和长度、依赖库列表的偏移和长度以及优化数据的偏移和长度。下面的flags域说明是用的大端字节序还是小端字节序,一般是小端,所以是0。最后是校验和的值,注意这个校验和不是算整个ODEX文件的,而是只算依赖库列表段和优化数据段的。
最后,画张图将整体结构总结一下: