blob: 136cccdcc636d520f1e3db05bb70d128b4b5be46 [file] [log] [blame]
Loganf7f0ac52011-01-07 03:53:43 +08001/*
2 * Copyright 2010, 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
Loganf7f0ac52011-01-07 03:53:43 +080017#include "CacheReader.h"
18
19#include "ContextManager.h"
Logan4dcd6792011-02-28 05:12:00 +080020#include "DebugHelper.h"
Loganf7f0ac52011-01-07 03:53:43 +080021#include "FileHandle.h"
22#include "ScriptCached.h"
23
24#include <bcc/bcc_cache.h>
25
26#include <llvm/ADT/OwningPtr.h>
27
28#include <errno.h>
29#include <sys/stat.h>
30#include <sys/types.h>
31
32#include <utility>
33#include <vector>
34
35#include <new>
36
Logan856ceb22011-01-07 05:21:26 +080037#include <stdlib.h>
Loganf7f0ac52011-01-07 03:53:43 +080038#include <string.h>
39
40using namespace std;
41
42
43namespace bcc {
44
Logan856ceb22011-01-07 05:21:26 +080045CacheReader::~CacheReader() {
46 if (mpHeader) { free(mpHeader); }
47 if (mpCachedDependTable) { free(mpCachedDependTable); }
48 if (mpPragmaList) { free(mpPragmaList); }
49 if (mpFuncTable) { free(mpFuncTable); }
50}
51
Logane7eb7732011-01-07 07:11:56 +080052ScriptCached *CacheReader::readCacheFile(FileHandle *file, Script *S) {
Loganf7f0ac52011-01-07 03:53:43 +080053 // Check file handle
54 if (!file || file->getFD() < 0) {
55 return NULL;
56 }
57
Logana2e15af2011-01-07 11:46:08 +080058 mFile = file;
59
Loganf7f0ac52011-01-07 03:53:43 +080060 // Allocate ScriptCached object
Logane7eb7732011-01-07 07:11:56 +080061 mpResult.reset(new (nothrow) ScriptCached(S));
Loganf7f0ac52011-01-07 03:53:43 +080062
Logan856ceb22011-01-07 05:21:26 +080063 if (!mpResult) {
Loganf7f0ac52011-01-07 03:53:43 +080064 LOGE("Unable to allocate ScriptCached object.\n");
65 return NULL;
66 }
67
68 bool result = checkFileSize()
69 && readHeader()
70 && checkHeader()
71 && checkMachineIntType()
72 && checkSectionOffsetAndSize()
73 && readStringPool()
74 && checkStringPool()
75 && readDependencyTable()
76 && checkDependency()
77 && readExportVarList()
78 && readExportFuncList()
79 && readPragmaList()
80 && readFuncTable()
Stephen Hines071288a2011-01-27 14:38:26 -080081 && readObjectSlotList()
Loganf7f0ac52011-01-07 03:53:43 +080082 && readContext()
83 && checkContext()
84 //&& readRelocationTable()
85 //&& relocate()
86 ;
87
Logan856ceb22011-01-07 05:21:26 +080088 return result ? mpResult.take() : NULL;
Loganf7f0ac52011-01-07 03:53:43 +080089}
90
91
92bool CacheReader::checkFileSize() {
93 struct stat stfile;
94 if (fstat(mFile->getFD(), &stfile) < 0) {
95 LOGE("Unable to stat cache file.\n");
96 return false;
97 }
98
99 mFileSize = stfile.st_size;
100
101 if (mFileSize < (off_t)sizeof(OBCC_Header) ||
Logan1dc63142011-02-25 17:14:51 +0800102 mFileSize < (off_t)ContextManager::ContextSize) {
Loganf7f0ac52011-01-07 03:53:43 +0800103 LOGE("Cache file is too small to be correct.\n");
104 return false;
105 }
106
107 return true;
108}
109
110
111bool CacheReader::readHeader() {
112 if (mFile->seek(0, SEEK_SET) != 0) {
113 LOGE("Unable to seek to 0. (reason: %s)\n", strerror(errno));
114 return false;
115 }
116
Logan856ceb22011-01-07 05:21:26 +0800117 mpHeader = (OBCC_Header *)malloc(sizeof(OBCC_Header));
118 if (!mpHeader) {
Loganf7f0ac52011-01-07 03:53:43 +0800119 LOGE("Unable to allocate for cache header.\n");
120 return false;
121 }
122
Logan856ceb22011-01-07 05:21:26 +0800123 if (mFile->read(reinterpret_cast<char *>(mpHeader), sizeof(OBCC_Header)) !=
Loganf7f0ac52011-01-07 03:53:43 +0800124 (ssize_t)sizeof(OBCC_Header)) {
125 LOGE("Unable to read cache header.\n");
126 return false;
127 }
128
Logana2e15af2011-01-07 11:46:08 +0800129 // Dirty hack for libRS.
130 // TODO(all): This should be removed in the future.
131 if (mpHeader->libRS_threadable) {
132 mpResult->mLibRSThreadable = true;
133 }
134
Loganf7f0ac52011-01-07 03:53:43 +0800135 return true;
136}
137
138
139bool CacheReader::checkHeader() {
Logan856ceb22011-01-07 05:21:26 +0800140 if (memcmp(mpHeader->magic, OBCC_MAGIC, 4) != 0) {
Loganf7f0ac52011-01-07 03:53:43 +0800141 LOGE("Bad magic word\n");
142 return false;
143 }
144
Logan856ceb22011-01-07 05:21:26 +0800145 if (memcmp(mpHeader->version, OBCC_VERSION, 4) != 0) {
Logane1323992011-01-12 04:47:13 +0800146 mpHeader->version[4 - 1] = '\0'; // ensure c-style string terminated
Shih-wei Liaoa6526652011-01-12 04:42:07 -0800147 LOGI("Cache file format version mismatch: now %s cached %s\n",
Logane1323992011-01-12 04:47:13 +0800148 OBCC_VERSION, mpHeader->version);
149 return false;
150 }
Loganf7f0ac52011-01-07 03:53:43 +0800151 return true;
152}
153
154
155bool CacheReader::checkMachineIntType() {
156 uint32_t number = 0x00000001;
157
158 bool isLittleEndian = (*reinterpret_cast<char *>(&number) == 1);
Logan856ceb22011-01-07 05:21:26 +0800159 if ((isLittleEndian && mpHeader->endianness != 'e') ||
160 (!isLittleEndian && mpHeader->endianness != 'E')) {
Loganf7f0ac52011-01-07 03:53:43 +0800161 LOGE("Machine endianness mismatch.\n");
162 return false;
163 }
164
Logan856ceb22011-01-07 05:21:26 +0800165 if ((unsigned int)mpHeader->sizeof_off_t != sizeof(off_t) ||
166 (unsigned int)mpHeader->sizeof_size_t != sizeof(size_t) ||
167 (unsigned int)mpHeader->sizeof_ptr_t != sizeof(void *)) {
Loganf7f0ac52011-01-07 03:53:43 +0800168 LOGE("Machine integer size mismatch.\n");
169 return false;
170 }
171
172 return true;
173}
174
175
176bool CacheReader::checkSectionOffsetAndSize() {
177#define CHECK_SECTION_OFFSET(NAME) \
178 do { \
Logan856ceb22011-01-07 05:21:26 +0800179 off_t offset = mpHeader-> NAME##_offset; \
180 off_t size = (off_t)mpHeader-> NAME##_size; \
Loganf7f0ac52011-01-07 03:53:43 +0800181 \
182 if (mFileSize < offset || mFileSize < offset + size) { \
183 LOGE(#NAME " section overflow.\n"); \
184 return false; \
185 } \
186 \
187 if (offset % sizeof(int) != 0) { \
Stephen Hines40b7fba2011-03-17 19:50:20 -0700188 LOGE(#NAME " offset must aligned to %d.\n", (int)sizeof(int)); \
Loganf7f0ac52011-01-07 03:53:43 +0800189 return false; \
190 } \
191 \
192 if (size < static_cast<off_t>(sizeof(size_t))) { \
193 LOGE(#NAME " size is too small to be correct.\n"); \
194 return false; \
195 } \
196 } while (0)
197
198 CHECK_SECTION_OFFSET(str_pool);
199 CHECK_SECTION_OFFSET(depend_tab);
Logana2e15af2011-01-07 11:46:08 +0800200 //CHECK_SECTION_OFFSET(reloc_tab);
Loganf7f0ac52011-01-07 03:53:43 +0800201 CHECK_SECTION_OFFSET(export_var_list);
202 CHECK_SECTION_OFFSET(export_func_list);
203 CHECK_SECTION_OFFSET(pragma_list);
204
205#undef CHECK_SECTION_OFFSET
206
Logan856ceb22011-01-07 05:21:26 +0800207 if (mFileSize < mpHeader->context_offset ||
Logan1dc63142011-02-25 17:14:51 +0800208 mFileSize < (off_t)mpHeader->context_offset +
209 (off_t)ContextManager::ContextSize) {
Loganf7f0ac52011-01-07 03:53:43 +0800210 LOGE("context section overflow.\n");
211 return false;
212 }
213
214 long pagesize = sysconf(_SC_PAGESIZE);
Logan856ceb22011-01-07 05:21:26 +0800215 if (mpHeader->context_offset % pagesize != 0) {
Loganf7f0ac52011-01-07 03:53:43 +0800216 LOGE("context offset must aligned to pagesize.\n");
217 return false;
218 }
219
220 // TODO(logan): Move this to some where else.
Logan856ceb22011-01-07 05:21:26 +0800221 if ((uintptr_t)mpHeader->context_cached_addr % pagesize != 0) {
Loganf7f0ac52011-01-07 03:53:43 +0800222 LOGE("cached address is not aligned to pagesize.\n");
223 return false;
224 }
225
226 return true;
227}
228
229
Logan856ceb22011-01-07 05:21:26 +0800230#define CACHE_READER_READ_SECTION(TYPE, AUTO_MANAGED_HOLDER, NAME) \
231 TYPE *NAME##_raw = (TYPE *)malloc(mpHeader->NAME##_size); \
232 \
233 if (!NAME##_raw) { \
234 LOGE("Unable to allocate for " #NAME "\n"); \
235 return false; \
236 } \
237 \
238 /* We have to ensure that some one will deallocate NAME##_raw */ \
239 AUTO_MANAGED_HOLDER = NAME##_raw; \
240 \
241 if (mFile->seek(mpHeader->NAME##_offset, SEEK_SET) == -1) { \
242 LOGE("Unable to seek to " #NAME " section\n"); \
243 return false; \
244 } \
245 \
246 if (mFile->read(reinterpret_cast<char *>(NAME##_raw), \
247 mpHeader->NAME##_size) != (ssize_t)mpHeader->NAME##_size) \
248 { \
249 LOGE("Unable to read " #NAME ".\n"); \
250 return false; \
251 }
252
253
Loganf7f0ac52011-01-07 03:53:43 +0800254bool CacheReader::readStringPool() {
Logan856ceb22011-01-07 05:21:26 +0800255 CACHE_READER_READ_SECTION(OBCC_StringPool,
256 mpResult->mpStringPoolRaw, str_pool);
Loganf7f0ac52011-01-07 03:53:43 +0800257
Logan856ceb22011-01-07 05:21:26 +0800258 char *str_base = reinterpret_cast<char *>(str_pool_raw);
Loganf7f0ac52011-01-07 03:53:43 +0800259
Logan856ceb22011-01-07 05:21:26 +0800260 vector<char const *> &pool = mpResult->mStringPool;
261 for (size_t i = 0; i < str_pool_raw->count; ++i) {
262 char *str = str_base + str_pool_raw->list[i].offset;
Loganf7f0ac52011-01-07 03:53:43 +0800263 pool.push_back(str);
264 }
265
266 return true;
267}
268
269
270bool CacheReader::checkStringPool() {
Logan856ceb22011-01-07 05:21:26 +0800271 OBCC_StringPool *poolR = mpResult->mpStringPoolRaw;
272 vector<char const *> &pool = mpResult->mStringPool;
Loganf7f0ac52011-01-07 03:53:43 +0800273
274 // Ensure that every c-style string is ended with '\0'
275 for (size_t i = 0; i < poolR->count; ++i) {
276 if (pool[i][poolR->list[i].length] != '\0') {
277 LOGE("The %lu-th string does not end with '\\0'.\n", (unsigned long)i);
278 return false;
279 }
280 }
281
282 return true;
283}
284
285
286bool CacheReader::readDependencyTable() {
Logan856ceb22011-01-07 05:21:26 +0800287 CACHE_READER_READ_SECTION(OBCC_DependencyTable, mpCachedDependTable,
288 depend_tab);
Loganf7f0ac52011-01-07 03:53:43 +0800289 return true;
290}
291
292
293bool CacheReader::checkDependency() {
Logan856ceb22011-01-07 05:21:26 +0800294 if (mDependencies.size() != mpCachedDependTable->count) {
295 LOGE("Dependencies count mismatch. (%lu vs %lu)\n",
296 (unsigned long)mDependencies.size(),
297 (unsigned long)mpCachedDependTable->count);
298 return false;
299 }
300
301 vector<char const *> &strPool = mpResult->mStringPool;
Logan75cc8a52011-01-07 06:06:52 +0800302 map<string, pair<uint32_t, unsigned char const *> >::iterator dep;
Logan856ceb22011-01-07 05:21:26 +0800303
304 dep = mDependencies.begin();
305 for (size_t i = 0; i < mpCachedDependTable->count; ++i, ++dep) {
306 string const &depName = dep->first;
Logan856ceb22011-01-07 05:21:26 +0800307 uint32_t depType = dep->second.first;
Logan75cc8a52011-01-07 06:06:52 +0800308 unsigned char const *depSHA1 = dep->second.second;
Logan856ceb22011-01-07 05:21:26 +0800309
310 OBCC_Dependency *depCached =&mpCachedDependTable->table[i];
311 char const *depCachedName = strPool[depCached->res_name_strp_index];
Logan856ceb22011-01-07 05:21:26 +0800312 uint32_t depCachedType = depCached->res_type;
Logan75cc8a52011-01-07 06:06:52 +0800313 unsigned char const *depCachedSHA1 = depCached->sha1;
Logan856ceb22011-01-07 05:21:26 +0800314
315 if (depName != depCachedName) {
316 LOGE("Cache dependency name mismatch:\n");
317 LOGE(" given: %s\n", depName.c_str());
318 LOGE(" cached: %s\n", depCachedName);
319
320 return false;
321 }
322
323 if (memcmp(depSHA1, depCachedSHA1, 20) != 0) {
324 LOGE("Cache dependency %s sha1 mismatch:\n", depCachedName);
325
326#define PRINT_SHA1(PREFIX, X, POSTFIX) \
327 LOGE(PREFIX "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x" \
328 "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x" POSTFIX, \
329 X[0], X[1], X[2], X[3], X[4], X[5], X[6], X[7], X[8], X[9], \
330 X[10],X[11],X[12],X[13],X[14],X[15],X[16],X[17],X[18],X[19]);
331
332 PRINT_SHA1(" given: ", depSHA1, "\n");
333 PRINT_SHA1(" cached: ", depCachedSHA1, "\n");
334
335#undef PRINT_SHA1
336
337 return false;
338 }
339
340 if (depType != depCachedType) {
341 LOGE("Cache dependency %s resource type mismatch.\n", depCachedName);
342 return false;
343 }
344 }
345
Loganf7f0ac52011-01-07 03:53:43 +0800346 return true;
347}
348
349bool CacheReader::readExportVarList() {
Logan856ceb22011-01-07 05:21:26 +0800350 CACHE_READER_READ_SECTION(OBCC_ExportVarList,
351 mpResult->mpExportVars, export_var_list);
Loganf7f0ac52011-01-07 03:53:43 +0800352 return true;
353}
354
355
356bool CacheReader::readExportFuncList() {
Logan856ceb22011-01-07 05:21:26 +0800357 CACHE_READER_READ_SECTION(OBCC_ExportFuncList,
358 mpResult->mpExportFuncs, export_func_list);
Loganf7f0ac52011-01-07 03:53:43 +0800359 return true;
360}
361
362
363bool CacheReader::readPragmaList() {
Logan856ceb22011-01-07 05:21:26 +0800364 CACHE_READER_READ_SECTION(OBCC_PragmaList, mpPragmaList, pragma_list);
Loganf7f0ac52011-01-07 03:53:43 +0800365
Logan856ceb22011-01-07 05:21:26 +0800366 vector<char const *> const &strPool = mpResult->mStringPool;
367 ScriptCached::PragmaList &pragmas = mpResult->mPragmas;
Loganf7f0ac52011-01-07 03:53:43 +0800368
Logan856ceb22011-01-07 05:21:26 +0800369 for (size_t i = 0; i < pragma_list_raw->count; ++i) {
370 OBCC_Pragma *pragma = &pragma_list_raw->list[i];
Loganf7f0ac52011-01-07 03:53:43 +0800371 pragmas.push_back(make_pair(strPool[pragma->key_strp_index],
372 strPool[pragma->value_strp_index]));
373 }
374
375 return true;
376}
377
378
Stephen Hines071288a2011-01-27 14:38:26 -0800379bool CacheReader::readObjectSlotList() {
380 CACHE_READER_READ_SECTION(OBCC_ObjectSlotList,
381 mpResult->mpObjectSlotList, object_slot_list);
382 return true;
383}
384
385
Loganf7f0ac52011-01-07 03:53:43 +0800386bool CacheReader::readFuncTable() {
Logan856ceb22011-01-07 05:21:26 +0800387 CACHE_READER_READ_SECTION(OBCC_FuncTable, mpFuncTable, func_table);
388
389 vector<char const *> &strPool = mpResult->mStringPool;
390 ScriptCached::FuncTable &table = mpResult->mFunctions;
391 for (size_t i = 0; i < func_table_raw->count; ++i) {
392 OBCC_FuncInfo *func = &func_table_raw->table[i];
393 table.insert(make_pair(strPool[func->name_strp_index],
394 make_pair(func->cached_addr, func->size)));
395 }
396
397 return true;
Loganf7f0ac52011-01-07 03:53:43 +0800398}
399
Logan856ceb22011-01-07 05:21:26 +0800400#undef CACHE_READER_READ_SECTION
401
Loganf7f0ac52011-01-07 03:53:43 +0800402
403bool CacheReader::readContext() {
Logan1dc63142011-02-25 17:14:51 +0800404 mpResult->mContext =
405 ContextManager::get().allocateContext(mpHeader->context_cached_addr,
406 mFile->getFD(),
407 mpHeader->context_offset);
Loganf7f0ac52011-01-07 03:53:43 +0800408
Logan856ceb22011-01-07 05:21:26 +0800409 if (!mpResult->mContext) {
Loganf7f0ac52011-01-07 03:53:43 +0800410 // Unable to allocate at cached address. Give up.
Logan42598052011-01-26 22:41:13 +0800411 mIsContextSlotNotAvail = true;
Loganf7f0ac52011-01-07 03:53:43 +0800412 return false;
413
414 // TODO(logan): If relocation is fixed, we should try to allocate the
415 // code in different location, and relocate the context.
416 }
417
418 return true;
419}
420
421
422bool CacheReader::checkContext() {
Logan856ceb22011-01-07 05:21:26 +0800423 uint32_t sum = mpHeader->context_parity_checksum;
424 uint32_t *ptr = reinterpret_cast<uint32_t *>(mpResult->mContext);
Loganf7f0ac52011-01-07 03:53:43 +0800425
Logan1dc63142011-02-25 17:14:51 +0800426 for (size_t i = 0; i < ContextManager::ContextSize / sizeof(uint32_t); ++i) {
Loganf7f0ac52011-01-07 03:53:43 +0800427 sum ^= *ptr++;
428 }
429
430 if (sum != 0) {
431 LOGE("Checksum check failed\n");
432 return false;
433 }
434
435 LOGI("Passed checksum even parity verification.\n");
436 return true;
437}
438
439
440bool CacheReader::readRelocationTable() {
441 // TODO(logan): Not finished.
442 return true;
443}
444
445
446bool CacheReader::relocate() {
447 // TODO(logan): Not finished.
448 return true;
449}
450
451
452} // namespace bcc