BlobCache.cpp revision b63b00ddd1eee59a296c5c5eaac5510c75a49444
1b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross/* 2b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ** Copyright 2011, The Android Open Source Project 3b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ** 4b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ** Licensed under the Apache License, Version 2.0 (the "License"); 5b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ** you may not use this file except in compliance with the License. 6b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ** You may obtain a copy of the License at 7b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ** 8b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ** http://www.apache.org/licenses/LICENSE-2.0 9b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ** 10b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ** Unless required by applicable law or agreed to in writing, software 11b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ** distributed under the License is distributed on an "AS IS" BASIS, 12b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ** See the License for the specific language governing permissions and 14b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ** limitations under the License. 15b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross */ 16b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 17b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross//#define LOG_NDEBUG 0 18b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 19b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross#include "BlobCache.h" 20b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 21b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross#include <inttypes.h> 22b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 23b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross#include <cutils/properties.h> 24b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross#include <log/log.h> 25b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross#include <chrono> 26b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 27b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grossnamespace android { 28b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 29b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross// BlobCache::Header::mMagicNumber value 30b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grossstatic const uint32_t blobCacheMagic = ('_' << 24) + ('B' << 16) + ('b' << 8) + '$'; 31b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 32b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross// BlobCache::Header::mBlobCacheVersion value 33b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grossstatic const uint32_t blobCacheVersion = 3; 34b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 35b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross// BlobCache::Header::mDeviceVersion value 36b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grossstatic const uint32_t blobCacheDeviceVersion = 1; 37b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 38b63b00ddd1eee59a296c5c5eaac5510c75a49444David GrossBlobCache::BlobCache(size_t maxKeySize, size_t maxValueSize, size_t maxTotalSize): 39b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mMaxKeySize(maxKeySize), 40b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mMaxValueSize(maxValueSize), 41b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mMaxTotalSize(maxTotalSize), 42b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mTotalSize(0) { 43b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross int64_t now = std::chrono::steady_clock::now().time_since_epoch().count(); 44b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross#ifdef _WIN32 45b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross srand(now); 46b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross#else 47b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mRandState[0] = (now >> 0) & 0xFFFF; 48b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mRandState[1] = (now >> 16) & 0xFFFF; 49b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mRandState[2] = (now >> 32) & 0xFFFF; 50b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross#endif 51b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ALOGV("initializing random seed using %lld", (unsigned long long)now); 52b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 53b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 54b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grossvoid BlobCache::set(const void* key, size_t keySize, const void* value, 55b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross size_t valueSize) { 56b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (mMaxKeySize < keySize) { 57b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ALOGV("set: not caching because the key is too large: %zu (limit: %zu)", 58b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross keySize, mMaxKeySize); 59b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return; 60b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 61b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (mMaxValueSize < valueSize) { 62b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ALOGV("set: not caching because the value is too large: %zu (limit: %zu)", 63b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross valueSize, mMaxValueSize); 64b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return; 65b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 66b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (mMaxTotalSize < keySize + valueSize) { 67b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ALOGV("set: not caching because the combined key/value size is too " 68b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross "large: %zu (limit: %zu)", keySize + valueSize, mMaxTotalSize); 69b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return; 70b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 71b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (keySize == 0) { 72b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ALOGW("set: not caching because keySize is 0"); 73b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return; 74b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 75b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (valueSize <= 0) { 76b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ALOGW("set: not caching because valueSize is 0"); 77b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return; 78b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 79b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 80b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross std::shared_ptr<Blob> dummyKey(new Blob(key, keySize, false)); 81b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross CacheEntry dummyEntry(dummyKey, NULL); 82b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 83b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross while (true) { 84b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross auto index = std::lower_bound(mCacheEntries.begin(), mCacheEntries.end(), dummyEntry); 85b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (index == mCacheEntries.end() || dummyEntry < *index) { 86b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross // Create a new cache entry. 87b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross std::shared_ptr<Blob> keyBlob(new Blob(key, keySize, true)); 88b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross std::shared_ptr<Blob> valueBlob(new Blob(value, valueSize, true)); 89b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross size_t newTotalSize = mTotalSize + keySize + valueSize; 90b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (mMaxTotalSize < newTotalSize) { 91b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (isCleanable()) { 92b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross // Clean the cache and try again. 93b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross clean(); 94b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross continue; 95b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } else { 96b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ALOGV("set: not caching new key/value pair because the " 97b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross "total cache size limit would be exceeded: %zu " 98b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross "(limit: %zu)", 99b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross keySize + valueSize, mMaxTotalSize); 100b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross break; 101b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 102b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 103b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mCacheEntries.insert(index, CacheEntry(keyBlob, valueBlob)); 104b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mTotalSize = newTotalSize; 105b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ALOGV("set: created new cache entry with %zu byte key and %zu byte value", 106b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross keySize, valueSize); 107b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } else { 108b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross // Update the existing cache entry. 109b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross std::shared_ptr<Blob> valueBlob(new Blob(value, valueSize, true)); 110b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross std::shared_ptr<Blob> oldValueBlob(index->getValue()); 111b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross size_t newTotalSize = mTotalSize + valueSize - oldValueBlob->getSize(); 112b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (mMaxTotalSize < newTotalSize) { 113b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (isCleanable()) { 114b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross // Clean the cache and try again. 115b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross clean(); 116b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross continue; 117b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } else { 118b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ALOGV("set: not caching new value because the total cache " 119b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross "size limit would be exceeded: %zu (limit: %zu)", 120b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross keySize + valueSize, mMaxTotalSize); 121b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross break; 122b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 123b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 124b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross index->setValue(valueBlob); 125b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mTotalSize = newTotalSize; 126b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ALOGV("set: updated existing cache entry with %zu byte key and %zu byte " 127b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross "value", keySize, valueSize); 128b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 129b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross break; 130b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 131b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 132b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 133b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grosssize_t BlobCache::get(const void* key, size_t keySize, void* value, 134b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross size_t valueSize) { 135b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (mMaxKeySize < keySize) { 136b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ALOGV("get: not searching because the key is too large: %zu (limit %zu)", 137b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross keySize, mMaxKeySize); 138b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return 0; 139b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 140b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross std::shared_ptr<Blob> dummyKey(new Blob(key, keySize, false)); 141b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross CacheEntry dummyEntry(dummyKey, NULL); 142b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross auto index = std::lower_bound(mCacheEntries.begin(), mCacheEntries.end(), dummyEntry); 143b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (index == mCacheEntries.end() || dummyEntry < *index) { 144b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ALOGV("get: no cache entry found for key of size %zu", keySize); 145b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return 0; 146b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 147b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 148b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross // The key was found. Return the value if the caller's buffer is large 149b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross // enough. 150b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross std::shared_ptr<Blob> valueBlob(index->getValue()); 151b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross size_t valueBlobSize = valueBlob->getSize(); 152b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (valueBlobSize <= valueSize) { 153b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ALOGV("get: copying %zu bytes to caller's buffer", valueBlobSize); 154b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross memcpy(value, valueBlob->getData(), valueBlobSize); 155b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } else { 156b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ALOGV("get: caller's buffer is too small for value: %zu (needs %zu)", 157b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross valueSize, valueBlobSize); 158b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 159b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return valueBlobSize; 160b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 161b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 162b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grossstatic inline size_t align4(size_t size) { 163b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return (size + 3) & ~3; 164b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 165b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 166b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grosssize_t BlobCache::getFlattenedSize() const { 167b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross size_t size = align4(sizeof(Header) + PROPERTY_VALUE_MAX); 168b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross for (const CacheEntry& e : mCacheEntries) { 169b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross std::shared_ptr<Blob> const& keyBlob = e.getKey(); 170b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross std::shared_ptr<Blob> const& valueBlob = e.getValue(); 171b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross size += align4(sizeof(EntryHeader) + keyBlob->getSize() + valueBlob->getSize()); 172b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 173b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return size; 174b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 175b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 176b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grossint BlobCache::flatten(void* buffer, size_t size) const { 177b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross // Write the cache header 178b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (size < sizeof(Header)) { 179b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ALOGE("flatten: not enough room for cache header"); 180b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return 0; 181b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 182b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross Header* header = reinterpret_cast<Header*>(buffer); 183b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross header->mMagicNumber = blobCacheMagic; 184b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross header->mBlobCacheVersion = blobCacheVersion; 185b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross header->mDeviceVersion = blobCacheDeviceVersion; 186b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross header->mNumEntries = mCacheEntries.size(); 187b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross char buildId[PROPERTY_VALUE_MAX]; 188b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross header->mBuildIdLength = property_get("ro.build.id", buildId, ""); 189b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross memcpy(header->mBuildId, buildId, header->mBuildIdLength); 190b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 191b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross // Write cache entries 192b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross uint8_t* byteBuffer = reinterpret_cast<uint8_t*>(buffer); 193b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross off_t byteOffset = align4(sizeof(Header) + header->mBuildIdLength); 194b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross for (const CacheEntry& e : mCacheEntries) { 195b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross std::shared_ptr<Blob> const& keyBlob = e.getKey(); 196b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross std::shared_ptr<Blob> const& valueBlob = e.getValue(); 197b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross size_t keySize = keyBlob->getSize(); 198b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross size_t valueSize = valueBlob->getSize(); 199b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 200b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross size_t entrySize = sizeof(EntryHeader) + keySize + valueSize; 201b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross size_t totalSize = align4(entrySize); 202b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (byteOffset + totalSize > size) { 203b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ALOGE("flatten: not enough room for cache entries"); 204b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return -EINVAL; 205b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 206b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 207b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross EntryHeader* eheader = reinterpret_cast<EntryHeader*>(&byteBuffer[byteOffset]); 208b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross eheader->mKeySize = keySize; 209b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross eheader->mValueSize = valueSize; 210b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 211b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross memcpy(eheader->mData, keyBlob->getData(), keySize); 212b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross memcpy(eheader->mData + keySize, valueBlob->getData(), valueSize); 213b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 214b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (totalSize > entrySize) { 215b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross // We have padding bytes. Those will get written to storage, and contribute to the CRC, 216b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross // so make sure we zero-them to have reproducible results. 217b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross memset(eheader->mData + keySize + valueSize, 0, totalSize - entrySize); 218b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 219b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 220b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross byteOffset += totalSize; 221b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 222b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 223b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return 0; 224b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 225b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 226b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grossint BlobCache::unflatten(void const* buffer, size_t size) { 227b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross // All errors should result in the BlobCache being in an empty state. 228b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mCacheEntries.clear(); 229b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 230b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross // Read the cache header 231b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (size < sizeof(Header)) { 232b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ALOGE("unflatten: not enough room for cache header"); 233b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return -EINVAL; 234b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 235b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross const Header* header = reinterpret_cast<const Header*>(buffer); 236b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (header->mMagicNumber != blobCacheMagic) { 237b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ALOGE("unflatten: bad magic number: %" PRIu32, header->mMagicNumber); 238b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return -EINVAL; 239b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 240b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross char buildId[PROPERTY_VALUE_MAX]; 241b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross int len = property_get("ro.build.id", buildId, ""); 242b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (header->mBlobCacheVersion != blobCacheVersion || 243b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross header->mDeviceVersion != blobCacheDeviceVersion || 244b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross len != header->mBuildIdLength || 245b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross strncmp(buildId, header->mBuildId, len)) { 246b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross // We treat version mismatches as an empty cache. 247b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return 0; 248b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 249b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 250b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross // Read cache entries 251b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross const uint8_t* byteBuffer = reinterpret_cast<const uint8_t*>(buffer); 252b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross off_t byteOffset = align4(sizeof(Header) + header->mBuildIdLength); 253b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross size_t numEntries = header->mNumEntries; 254b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross for (size_t i = 0; i < numEntries; i++) { 255b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (byteOffset + sizeof(EntryHeader) > size) { 256b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mCacheEntries.clear(); 257b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ALOGE("unflatten: not enough room for cache entry headers"); 258b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return -EINVAL; 259b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 260b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 261b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross const EntryHeader* eheader = reinterpret_cast<const EntryHeader*>( 262b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross &byteBuffer[byteOffset]); 263b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross size_t keySize = eheader->mKeySize; 264b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross size_t valueSize = eheader->mValueSize; 265b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross size_t entrySize = sizeof(EntryHeader) + keySize + valueSize; 266b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 267b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross size_t totalSize = align4(entrySize); 268b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (byteOffset + totalSize > size) { 269b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mCacheEntries.clear(); 270b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ALOGE("unflatten: not enough room for cache entry headers"); 271b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return -EINVAL; 272b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 273b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 274b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross const uint8_t* data = eheader->mData; 275b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross set(data, keySize, data + keySize, valueSize); 276b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 277b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross byteOffset += totalSize; 278b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 279b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 280b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return 0; 281b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 282b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 283b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grosslong int BlobCache::blob_random() { 284b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross#ifdef _WIN32 285b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return rand(); 286b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross#else 287b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return nrand48(mRandState); 288b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross#endif 289b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 290b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 291b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grossvoid BlobCache::clean() { 292b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross // Remove a random cache entry until the total cache size gets below half 293b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross // the maximum total cache size. 294b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross while (mTotalSize > mMaxTotalSize / 2) { 295b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross size_t i = size_t(blob_random() % (mCacheEntries.size())); 296b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross const CacheEntry& entry(mCacheEntries[i]); 297b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mTotalSize -= entry.getKey()->getSize() + entry.getValue()->getSize(); 298b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mCacheEntries.erase(mCacheEntries.begin() + i); 299b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 300b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 301b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 302b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grossbool BlobCache::isCleanable() const { 303b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return mTotalSize > mMaxTotalSize / 2; 304b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 305b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 306b63b00ddd1eee59a296c5c5eaac5510c75a49444David GrossBlobCache::Blob::Blob(const void* data, size_t size, bool copyData) : 307b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mData(copyData ? malloc(size) : data), 308b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mSize(size), 309b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mOwnsData(copyData) { 310b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (data != NULL && copyData) { 311b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross memcpy(const_cast<void*>(mData), data, size); 312b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 313b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 314b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 315b63b00ddd1eee59a296c5c5eaac5510c75a49444David GrossBlobCache::Blob::~Blob() { 316b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (mOwnsData) { 317b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross free(const_cast<void*>(mData)); 318b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 319b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 320b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 321b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grossbool BlobCache::Blob::operator<(const Blob& rhs) const { 322b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (mSize == rhs.mSize) { 323b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return memcmp(mData, rhs.mData, mSize) < 0; 324b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } else { 325b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return mSize < rhs.mSize; 326b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 327b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 328b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 329b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grossconst void* BlobCache::Blob::getData() const { 330b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return mData; 331b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 332b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 333b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grosssize_t BlobCache::Blob::getSize() const { 334b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return mSize; 335b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 336b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 337b63b00ddd1eee59a296c5c5eaac5510c75a49444David GrossBlobCache::CacheEntry::CacheEntry() { 338b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 339b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 340b63b00ddd1eee59a296c5c5eaac5510c75a49444David GrossBlobCache::CacheEntry::CacheEntry( 341b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross const std::shared_ptr<Blob>& key, const std::shared_ptr<Blob>& value): 342b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mKey(key), 343b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mValue(value) { 344b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 345b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 346b63b00ddd1eee59a296c5c5eaac5510c75a49444David GrossBlobCache::CacheEntry::CacheEntry(const CacheEntry& ce): 347b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mKey(ce.mKey), 348b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mValue(ce.mValue) { 349b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 350b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 351b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grossbool BlobCache::CacheEntry::operator<(const CacheEntry& rhs) const { 352b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return *mKey < *rhs.mKey; 353b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 354b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 355b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grossconst BlobCache::CacheEntry& BlobCache::CacheEntry::operator=(const CacheEntry& rhs) { 356b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mKey = rhs.mKey; 357b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mValue = rhs.mValue; 358b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return *this; 359b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 360b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 361b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grossstd::shared_ptr<BlobCache::Blob> BlobCache::CacheEntry::getKey() const { 362b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return mKey; 363b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 364b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 365b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grossstd::shared_ptr<BlobCache::Blob> BlobCache::CacheEntry::getValue() const { 366b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return mValue; 367b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 368b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 369b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grossvoid BlobCache::CacheEntry::setValue(const std::shared_ptr<Blob>& value) { 370b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mValue = value; 371b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 372b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 373b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} // namespace android 374