BlobCache.cpp revision 79c0b79406117a800ed4dd965b3d329cdc8903ff
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) { 15579c0b79406117a800ed4dd965b3d329cdc8903ffDavid Gross void *dummy; 15679c0b79406117a800ed4dd965b3d329cdc8903ffDavid Gross return get(key, keySize, &dummy, 15779c0b79406117a800ed4dd965b3d329cdc8903ffDavid Gross [value, valueSize](size_t allocSize) { 15879c0b79406117a800ed4dd965b3d329cdc8903ffDavid Gross return (allocSize <= valueSize ? value : nullptr); 15979c0b79406117a800ed4dd965b3d329cdc8903ffDavid Gross }); 16079c0b79406117a800ed4dd965b3d329cdc8903ffDavid Gross} 16179c0b79406117a800ed4dd965b3d329cdc8903ffDavid Gross 16279c0b79406117a800ed4dd965b3d329cdc8903ffDavid Grosssize_t BlobCache::get(const void* key, size_t keySize, void** value, 16379c0b79406117a800ed4dd965b3d329cdc8903ffDavid Gross std::function<void*(size_t)> alloc) { 164b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (mMaxKeySize < keySize) { 165b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ALOGV("get: not searching because the key is too large: %zu (limit %zu)", 166b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross keySize, mMaxKeySize); 16779c0b79406117a800ed4dd965b3d329cdc8903ffDavid Gross *value = nullptr; 168b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return 0; 169b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 170b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross std::shared_ptr<Blob> dummyKey(new Blob(key, keySize, false)); 171b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross CacheEntry dummyEntry(dummyKey, NULL); 172b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross auto index = std::lower_bound(mCacheEntries.begin(), mCacheEntries.end(), dummyEntry); 173b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (index == mCacheEntries.end() || dummyEntry < *index) { 174b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ALOGV("get: no cache entry found for key of size %zu", keySize); 17579c0b79406117a800ed4dd965b3d329cdc8903ffDavid Gross *value = nullptr; 176b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return 0; 177b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 178b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 17979c0b79406117a800ed4dd965b3d329cdc8903ffDavid Gross // The key was found. Return the value if we can allocate a buffer. 180b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross std::shared_ptr<Blob> valueBlob(index->getValue()); 181b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross size_t valueBlobSize = valueBlob->getSize(); 18279c0b79406117a800ed4dd965b3d329cdc8903ffDavid Gross void *buf = alloc(valueBlobSize); 18379c0b79406117a800ed4dd965b3d329cdc8903ffDavid Gross if (buf != nullptr) { 184b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ALOGV("get: copying %zu bytes to caller's buffer", valueBlobSize); 18579c0b79406117a800ed4dd965b3d329cdc8903ffDavid Gross memcpy(buf, valueBlob->getData(), valueBlobSize); 18679c0b79406117a800ed4dd965b3d329cdc8903ffDavid Gross *value = buf; 187b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } else { 18879c0b79406117a800ed4dd965b3d329cdc8903ffDavid Gross ALOGV("get: cannot allocate caller's buffer: needs %zu", valueBlobSize); 18979c0b79406117a800ed4dd965b3d329cdc8903ffDavid Gross *value = nullptr; 190b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 191b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return valueBlobSize; 192b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 193b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 194b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grossstatic inline size_t align4(size_t size) { 195b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return (size + 3) & ~3; 196b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 197b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 198b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grosssize_t BlobCache::getFlattenedSize() const { 199b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross size_t size = align4(sizeof(Header) + PROPERTY_VALUE_MAX); 200b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross for (const CacheEntry& e : mCacheEntries) { 201b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross std::shared_ptr<Blob> const& keyBlob = e.getKey(); 202b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross std::shared_ptr<Blob> const& valueBlob = e.getValue(); 203b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross size += align4(sizeof(EntryHeader) + keyBlob->getSize() + valueBlob->getSize()); 204b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 205b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return size; 206b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 207b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 208b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grossint BlobCache::flatten(void* buffer, size_t size) const { 209b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross // Write the cache header 210b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (size < sizeof(Header)) { 211b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ALOGE("flatten: not enough room for cache header"); 212b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return 0; 213b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 214b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross Header* header = reinterpret_cast<Header*>(buffer); 215b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross header->mMagicNumber = blobCacheMagic; 216b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross header->mBlobCacheVersion = blobCacheVersion; 217b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross header->mDeviceVersion = blobCacheDeviceVersion; 218b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross header->mNumEntries = mCacheEntries.size(); 219b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross char buildId[PROPERTY_VALUE_MAX]; 220b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross header->mBuildIdLength = property_get("ro.build.id", buildId, ""); 221b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross memcpy(header->mBuildId, buildId, header->mBuildIdLength); 222b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 223b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross // Write cache entries 224b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross uint8_t* byteBuffer = reinterpret_cast<uint8_t*>(buffer); 225b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross off_t byteOffset = align4(sizeof(Header) + header->mBuildIdLength); 226b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross for (const CacheEntry& e : mCacheEntries) { 227b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross std::shared_ptr<Blob> const& keyBlob = e.getKey(); 228b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross std::shared_ptr<Blob> const& valueBlob = e.getValue(); 229b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross size_t keySize = keyBlob->getSize(); 230b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross size_t valueSize = valueBlob->getSize(); 231b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 232b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross size_t entrySize = sizeof(EntryHeader) + keySize + valueSize; 233b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross size_t totalSize = align4(entrySize); 234b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (byteOffset + totalSize > size) { 235b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ALOGE("flatten: not enough room for cache entries"); 236b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return -EINVAL; 237b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 238b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 239b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross EntryHeader* eheader = reinterpret_cast<EntryHeader*>(&byteBuffer[byteOffset]); 240b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross eheader->mKeySize = keySize; 241b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross eheader->mValueSize = valueSize; 242b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 243b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross memcpy(eheader->mData, keyBlob->getData(), keySize); 244b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross memcpy(eheader->mData + keySize, valueBlob->getData(), valueSize); 245b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 246b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (totalSize > entrySize) { 247b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross // We have padding bytes. Those will get written to storage, and contribute to the CRC, 248b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross // so make sure we zero-them to have reproducible results. 249b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross memset(eheader->mData + keySize + valueSize, 0, totalSize - entrySize); 250b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 251b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 252b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross byteOffset += totalSize; 253b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 254b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 255b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return 0; 256b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 257b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 258b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grossint BlobCache::unflatten(void const* buffer, size_t size) { 259b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross // All errors should result in the BlobCache being in an empty state. 260b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mCacheEntries.clear(); 261b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 262b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross // Read the cache header 263b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (size < sizeof(Header)) { 264b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ALOGE("unflatten: not enough room for cache header"); 265b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return -EINVAL; 266b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 267b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross const Header* header = reinterpret_cast<const Header*>(buffer); 268b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (header->mMagicNumber != blobCacheMagic) { 269b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross ALOGE("unflatten: bad magic number: %" PRIu32, header->mMagicNumber); 270b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return -EINVAL; 271b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 272b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross char buildId[PROPERTY_VALUE_MAX]; 273b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross int len = property_get("ro.build.id", buildId, ""); 274b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (header->mBlobCacheVersion != blobCacheVersion || 275b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross header->mDeviceVersion != blobCacheDeviceVersion || 276b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross len != header->mBuildIdLength || 277b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross strncmp(buildId, header->mBuildId, len)) { 278b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross // We treat version mismatches as an empty cache. 279b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return 0; 280b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 281b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 282b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross // Read cache entries 283b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross const uint8_t* byteBuffer = reinterpret_cast<const uint8_t*>(buffer); 284b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross off_t byteOffset = align4(sizeof(Header) + header->mBuildIdLength); 285b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross size_t numEntries = header->mNumEntries; 286b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross for (size_t i = 0; i < numEntries; i++) { 287b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (byteOffset + sizeof(EntryHeader) > size) { 288b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mCacheEntries.clear(); 28959572bdc906880f9b03aa8abd4e2d2095a012538David Gross ALOGE("unflatten: not enough room for cache entry header"); 290b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return -EINVAL; 291b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 292b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 293b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross const EntryHeader* eheader = reinterpret_cast<const EntryHeader*>( 294b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross &byteBuffer[byteOffset]); 295b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross size_t keySize = eheader->mKeySize; 296b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross size_t valueSize = eheader->mValueSize; 297b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross size_t entrySize = sizeof(EntryHeader) + keySize + valueSize; 298b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 299b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross size_t totalSize = align4(entrySize); 300b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (byteOffset + totalSize > size) { 301b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mCacheEntries.clear(); 30259572bdc906880f9b03aa8abd4e2d2095a012538David Gross ALOGE("unflatten: not enough room for cache entry"); 303b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return -EINVAL; 304b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 305b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 306b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross const uint8_t* data = eheader->mData; 307b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross set(data, keySize, data + keySize, valueSize); 308b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 309b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross byteOffset += totalSize; 310b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 311b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 312b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return 0; 313b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 314b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 315b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grosslong int BlobCache::blob_random() { 316b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross#ifdef _WIN32 317b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return rand(); 318b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross#else 319b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return nrand48(mRandState); 320b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross#endif 321b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 322b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 323b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grossvoid BlobCache::clean() { 324b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross // Remove a random cache entry until the total cache size gets below half 325b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross // the maximum total cache size. 326b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross while (mTotalSize > mMaxTotalSize / 2) { 327b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross size_t i = size_t(blob_random() % (mCacheEntries.size())); 328b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross const CacheEntry& entry(mCacheEntries[i]); 329b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mTotalSize -= entry.getKey()->getSize() + entry.getValue()->getSize(); 330b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mCacheEntries.erase(mCacheEntries.begin() + i); 331b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 332b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 333b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 334b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grossbool BlobCache::isCleanable() const { 335b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return mTotalSize > mMaxTotalSize / 2; 336b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 337b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 338b63b00ddd1eee59a296c5c5eaac5510c75a49444David GrossBlobCache::Blob::Blob(const void* data, size_t size, bool copyData) : 339b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mData(copyData ? malloc(size) : data), 340b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mSize(size), 341b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mOwnsData(copyData) { 342b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (data != NULL && copyData) { 343b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross memcpy(const_cast<void*>(mData), data, size); 344b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 345b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 346b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 347b63b00ddd1eee59a296c5c5eaac5510c75a49444David GrossBlobCache::Blob::~Blob() { 348b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (mOwnsData) { 349b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross free(const_cast<void*>(mData)); 350b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 351b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 352b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 353b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grossbool BlobCache::Blob::operator<(const Blob& rhs) const { 354b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross if (mSize == rhs.mSize) { 355b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return memcmp(mData, rhs.mData, mSize) < 0; 356b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } else { 357b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return mSize < rhs.mSize; 358b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross } 359b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 360b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 361b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grossconst void* BlobCache::Blob::getData() const { 362b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return mData; 363b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 364b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 365b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grosssize_t BlobCache::Blob::getSize() const { 366b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return mSize; 367b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 368b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 369b63b00ddd1eee59a296c5c5eaac5510c75a49444David GrossBlobCache::CacheEntry::CacheEntry() { 370b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 371b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 372b63b00ddd1eee59a296c5c5eaac5510c75a49444David GrossBlobCache::CacheEntry::CacheEntry( 373b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross const std::shared_ptr<Blob>& key, const std::shared_ptr<Blob>& value): 374b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mKey(key), 375b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mValue(value) { 376b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 377b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 378b63b00ddd1eee59a296c5c5eaac5510c75a49444David GrossBlobCache::CacheEntry::CacheEntry(const CacheEntry& ce): 379b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mKey(ce.mKey), 380b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mValue(ce.mValue) { 381b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 382b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 383b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grossbool BlobCache::CacheEntry::operator<(const CacheEntry& rhs) const { 384b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return *mKey < *rhs.mKey; 385b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 386b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 387b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grossconst BlobCache::CacheEntry& BlobCache::CacheEntry::operator=(const CacheEntry& rhs) { 388b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mKey = rhs.mKey; 389b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mValue = rhs.mValue; 390b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return *this; 391b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 392b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 393b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grossstd::shared_ptr<BlobCache::Blob> BlobCache::CacheEntry::getKey() const { 394b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return mKey; 395b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 396b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 397b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grossstd::shared_ptr<BlobCache::Blob> BlobCache::CacheEntry::getValue() const { 398b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross return mValue; 399b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 400b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 401b63b00ddd1eee59a296c5c5eaac5510c75a49444David Grossvoid BlobCache::CacheEntry::setValue(const std::shared_ptr<Blob>& value) { 402b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross mValue = value; 403b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} 404b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross 405b63b00ddd1eee59a296c5c5eaac5510c75a49444David Gross} // namespace android 406