vm/DvmDex.c

   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  * VM-specific state associated with a DEX file.
  19  */
  20 #include "Dalvik.h"
  21
  22
  23 /*
  24  * Create auxillary data structures.
  25  *
  26  * We need a 4-byte pointer for every reference to a class, method, field,
  27  * or string constant.  Summed up over all loaded DEX files (including the
  28  * whoppers in the boostrap class path), this adds up to be quite a bit
  29  * of native memory.
  30  *
  31  * For more traditional VMs these values could be stuffed into the loaded
  32  * class file constant pool area, but we don't have that luxury since our
  33  * classes are memory-mapped read-only.
  34  *
  35  * The DEX optimizer will remove the need for some of these (e.g. we won't
  36  * use the entry for virtual methods that are only called through
  37  * invoke-virtual-quick), creating the possibility of some space reduction
  38  * at dexopt time.
  39  */
  40 static DvmDex* allocateAuxStructures(DexFile* pDexFile)
  41 {
  42     DvmDex* pDvmDex;
  43     const DexHeader* pHeader;
  44     u4 stringCount, classCount, methodCount, fieldCount;
  45
  46     pDvmDex = (DvmDex*) calloc(1, sizeof(DvmDex));
  47     if (pDvmDex == NULL)
  48         return NULL;
  49
  50     pDvmDex->pDexFile = pDexFile;
  51     pDvmDex->pHeader = pDexFile->pHeader;
  52
  53     pHeader = pDvmDex->pHeader;
  54
  55     stringCount = pHeader->stringIdsSize;
  56     classCount = pHeader->typeIdsSize;
  57     methodCount = pHeader->methodIdsSize;
  58     fieldCount = pHeader->fieldIdsSize;
  59
  60 #if (DVM_RESOLVER_CACHE == DVM_RC_REDUCING) || \
  61     (DVM_RESOLVER_CACHE == DVM_RC_EXPANDING)
  62     if (pDexFile->indexMap.stringReducedCount > 0)
  63         stringCount = pDexFile->indexMap.stringReducedCount;
  64     if (pDexFile->indexMap.classReducedCount > 0)
  65         classCount = pDexFile->indexMap.classReducedCount;
  66     if (pDexFile->indexMap.methodReducedCount > 0)
  67         methodCount = pDexFile->indexMap.methodReducedCount;
  68     if (pDexFile->indexMap.fieldReducedCount > 0)
  69         fieldCount = pDexFile->indexMap.fieldReducedCount;
  70 #elif (DVM_RESOLVER_CACHE == DVM_RC_NO_CACHE)
  71     stringCount = classCount = methodCount = fieldCount = 0;
  72 #endif
  73
  74     pDvmDex->pResStrings = (struct StringObject**)
  75         calloc(stringCount, sizeof(struct StringObject*));
  76
  77     pDvmDex->pResClasses = (struct ClassObject**)
  78         calloc(classCount, sizeof(struct ClassObject*));
  79
  80     pDvmDex->pResMethods = (struct Method**)
  81         calloc(methodCount, sizeof(struct Method*));
  82
  83     pDvmDex->pResFields = (struct Field**)
  84         calloc(fieldCount, sizeof(struct Field*));
  85
  86     LOGV("+++ DEX %p: allocateAux %d+%d+%d+%d * 4 = %d bytes\n",
  87         pDvmDex, stringCount, classCount, methodCount, fieldCount,
  88         (stringCount + classCount + methodCount + fieldCount) * 4);
  89
  90     pDvmDex->pInterfaceCache = dvmAllocAtomicCache(DEX_INTERFACE_CACHE_SIZE);
  91
  92     if (pDvmDex->pResStrings == NULL ||
  93         pDvmDex->pResClasses == NULL ||
  94         pDvmDex->pResMethods == NULL ||
  95         pDvmDex->pResFields == NULL ||
  96         pDvmDex->pInterfaceCache == NULL)
  97     {
  98         LOGE("Alloc failure in allocateAuxStructures\n");
  99         free(pDvmDex->pResStrings);
 100         free(pDvmDex->pResClasses);
 101         free(pDvmDex->pResMethods);
 102         free(pDvmDex->pResFields);
 103         free(pDvmDex);
 104         return NULL;
 105     }
 106
 107     return pDvmDex;
 108
 109 }
 110
 111 /*
 112  * Given an open optimized DEX file, map it into read-only shared memory and
 113  * parse the contents.
 114  *
 115  * Returns nonzero on error.
 116  */
 117 int dvmDexFileOpenFromFd(int fd, DvmDex** ppDvmDex)
 118 {
 119     DvmDex* pDvmDex;
 120     DexFile* pDexFile;
 121     MemMapping memMap;
 122     int parseFlags = kDexParseDefault;
 123     int result = -1;
 124
 125     if (gDvm.verifyDexChecksum)
 126         parseFlags |= kDexParseVerifyChecksum;
 127
 128     if (lseek(fd, 0, SEEK_SET) < 0) {
 129         LOGE("lseek rewind failed\n");
 130         goto bail;
 131     }
 132
 133     if (sysMapFileInShmemWritableReadOnly(fd, &memMap) != 0) {
 134         LOGE("Unable to map file\n");
 135         goto bail;
 136     }
 137
 138     pDexFile = dexFileParse(memMap.addr, memMap.length, parseFlags);
 139     if (pDexFile == NULL) {
 140         LOGE("DEX parse failed\n");
 141         sysReleaseShmem(&memMap);
 142         goto bail;
 143     }
 144
 145     pDvmDex = allocateAuxStructures(pDexFile);
 146     if (pDvmDex == NULL) {
 147         dexFileFree(pDexFile);
 148         sysReleaseShmem(&memMap);
 149         goto bail;
 150     }
 151
 152     /* tuck this into the DexFile so it gets released later */
 153     sysCopyMap(&pDvmDex->memMap, &memMap);
 154     *ppDvmDex = pDvmDex;
 155     result = 0;
 156
 157 bail:
 158     return result;
 159 }
 160
 161 /*
 162  * Create a DexFile structure for a "partial" DEX.  This is one that is in
 163  * the process of being optimized.  The optimization header isn't finished
 164  * and we won't have any of the auxillary data tables, so we have to do
 165  * the initialization slightly differently.
 166  *
 167  * Returns nonzero on error.
 168  */
 169 int dvmDexFileOpenPartial(const void* addr, int len, DvmDex** ppDvmDex)
 170 {
 171     DvmDex* pDvmDex;
 172     DexFile* pDexFile;
 173     int parseFlags = kDexParseDefault;
 174     int result = -1;
 175
 176     /* -- file is incomplete, new checksum has not yet been calculated
 177     if (gDvm.verifyDexChecksum)
 178         parseFlags |= kDexParseVerifyChecksum;
 179     */
 180
 181     pDexFile = dexFileParse(addr, len, parseFlags);
 182     if (pDexFile == NULL) {
 183         LOGE("DEX parse failed\n");
 184         goto bail;
 185     }
 186     pDvmDex = allocateAuxStructures(pDexFile);
 187     if (pDvmDex == NULL) {
 188         dexFileFree(pDexFile);
 189         goto bail;
 190     }
 191
 192     *ppDvmDex = pDvmDex;
 193     result = 0;
 194
 195 bail:
 196     return result;
 197 }
 198
 199 /*
 200  * Free up the DexFile and any associated data structures.
 201  *
 202  * Note we may be called with a partially-initialized DvmDex.
 203  */
 204 void dvmDexFileFree(DvmDex* pDvmDex)
 205 {
 206     if (pDvmDex == NULL)
 207         return;
 208
 209     dexFileFree(pDvmDex->pDexFile);
 210
 211     LOGV("+++ DEX %p: freeing aux structs\n", pDvmDex);
 212     free(pDvmDex->pResStrings);
 213     free(pDvmDex->pResClasses);
 214     free(pDvmDex->pResMethods);
 215     free(pDvmDex->pResFields);
 216     dvmFreeAtomicCache(pDvmDex->pInterfaceCache);
 217
 218     sysReleaseShmem(&pDvmDex->memMap);
 219     free(pDvmDex);
 220 }
 221
 222
 223 /*
 224  * Change the byte at the specified address to a new value.  If the location
 225  * already has the new value, do nothing.
 226  *
 227  * This requires changing the access permissions to read-write, updating
 228  * the value, and then resetting the permissions.
 229  *
 230  * This does not make any synchronization guarantees.  It's important for the
 231  * caller(s) to work out mutual exclusion, at least on a page granularity,
 232  * to avoid a race where one threads sets read-write, another thread sets
 233  * read-only, and then the first thread does a write.
 234  *
 235  * TODO: if we're back to the original state of the page, use
 236  * madvise(MADV_DONTNEED) to release the private/dirty copy.
 237  *
 238  * Returns "true" on success.
 239  */
 240 bool dvmDexChangeDex1(DvmDex* pDvmDex, u1* addr, u1 newVal)
 241 {
 242     if (*addr == newVal) {
 243         LOGV("+++ byte at %p is already 0x%02x\n", addr, newVal);
 244         return true;
 245     }
 246
 247     LOGV("+++ change byte at %p from 0x%02x to 0x%02x\n", addr, *addr, newVal);
 248     if (sysChangeMapAccess(addr, 1, true, &pDvmDex->memMap) != 0) {
 249         LOGD("NOTE: DEX page access change (->RW) failed\n");
 250         /* expected on files mounted from FAT; keep going (may crash) */
 251     }
 252
 253     *addr = newVal;
 254
 255     if (sysChangeMapAccess(addr, 1, false, &pDvmDex->memMap) != 0) {
 256         LOGD("NOTE: DEX page access change (->RO) failed\n");
 257         /* expected on files mounted from FAT; keep going */
 258     }
 259
 260     return true;
 261 }
 262
 263 /*
 264  * Change the 2-byte value at the specified address to a new value.  If the
 265  * location already has the new value, do nothing.
 266  *
 267  * Otherwise works like dvmDexChangeDex1.
 268  */
 269 bool dvmDexChangeDex2(DvmDex* pDvmDex, u2* addr, u2 newVal)
 270 {
 271     if (*addr == newVal) {
 272         LOGV("+++ value at %p is already 0x%04x\n", addr, newVal);
 273         return true;
 274     }
 275
 276     LOGV("+++ change 2byte at %p from 0x%04x to 0x%04x\n", addr, *addr, newVal);
 277     if (sysChangeMapAccess(addr, 2, true, &pDvmDex->memMap) != 0) {
 278         LOGD("NOTE: DEX page access change (->RW) failed\n");
 279         /* expected on files mounted from FAT; keep going (may crash) */
 280     }
 281
 282     *addr = newVal;
 283
 284     if (sysChangeMapAccess(addr, 2, false, &pDvmDex->memMap) != 0) {
 285         LOGD("NOTE: DEX page access change (->RO) failed\n");
 286         /* expected on files mounted from FAT; keep going */
 287     }
 288
 289     return true;
 290 }
 291