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