Android系统ODEX文件格式解析

对于一个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文件的，而是只算依赖库列表段和优化数据段的。

最后，画张图将整体结构总结一下：