Merge "Move some of the logic from egl_cache_t into FileBlobCache" (7c3c1cf3) · Commits · e / os / platform_frameworks_native

opengl/libs/Android.bp

+14 −2

Original line number	Diff line number	Diff line
		@@ -122,6 +122,16 @@ cc_library_static {
		},
		}

		cc_library_static {
		name: "libEGL_blobCache",
		defaults: ["egl_libs_defaults"],
		srcs: [
		"EGL/BlobCache.cpp",
		"EGL/FileBlobCache.cpp",
		],
		export_include_dirs: ["EGL"],
		}

		cc_library_shared {
		name: "libEGL",
		defaults: ["egl_libs_defaults"],
		@@ -133,7 +143,6 @@ cc_library_shared {
		"EGL/egl.cpp",
		"EGL/eglApi.cpp",
		"EGL/Loader.cpp",
		"EGL/BlobCache.cpp",
		],
		shared_libs: [
		"libvndksupport",
		@@ -143,7 +152,10 @@ cc_library_shared {
		"libhidltransport",
		"libutils",
		],
		static_libs: ["libEGL_getProcAddress"],
		static_libs: [
		"libEGL_getProcAddress",
		"libEGL_blobCache",
		],
		ldflags: ["-Wl,--exclude-libs=ALL"],
		export_include_dirs: ["EGL/include"],
		}

opengl/libs/EGL/BlobCache.cpp

+1 −1

Original line number	Diff line number	Diff line
		@@ -37,9 +37,9 @@ static const uint32_t blobCacheVersion = 3;
		static const uint32_t blobCacheDeviceVersion = 1;

		BlobCache::BlobCache(size_t maxKeySize, size_t maxValueSize, size_t maxTotalSize):
		mMaxTotalSize(maxTotalSize),
		mMaxKeySize(maxKeySize),
		mMaxValueSize(maxValueSize),
		mMaxTotalSize(maxTotalSize),
		mTotalSize(0) {
		int64_t now = std::chrono::steady_clock::now().time_since_epoch().count();
		#ifdef _WIN32

opengl/libs/EGL/BlobCache.h

+8 −7

Original line number	Diff line number	Diff line
		@@ -97,6 +97,14 @@ public:
		//
		int unflatten(void const* buffer, size_t size);

		protected:
		// mMaxTotalSize is the maximum size that all cache entries can occupy. This
		// includes space for both keys and values. When a call to BlobCache::set
		// would otherwise cause this limit to be exceeded, either the key/value
		// pair passed to BlobCache::set will not be cached or other cache entries
		// will be evicted from the cache to make room for the new entry.
		const size_t mMaxTotalSize;

		private:
		// Copying is disallowed.
		BlobCache(const BlobCache&);
		@@ -220,13 +228,6 @@ private:
		// simply not add the key/value pair to the cache.
		const size_t mMaxValueSize;

		// mMaxTotalSize is the maximum size that all cache entries can occupy. This
		// includes space for both keys and values. When a call to BlobCache::set
		// would otherwise cause this limit to be exceeded, either the key/value
		// pair passed to BlobCache::set will not be cached or other cache entries
		// will be evicted from the cache to make room for the new entry.
		const size_t mMaxTotalSize;

		// mTotalSize is the total combined size of all keys and values currently in
		// the cache.
		size_t mTotalSize;

opengl/libs/EGL/FileBlobCache.cpp

0 → 100644

+185 −0

Original line number	Diff line number	Diff line
		/*
		** Copyright 2017, The Android Open Source Project
		**
		** Licensed under the Apache License, Version 2.0 (the "License");
		** you may not use this file except in compliance with the License.
		** You may obtain a copy of the License at
		**
		** http://www.apache.org/licenses/LICENSE-2.0
		**
		** Unless required by applicable law or agreed to in writing, software
		** distributed under the License is distributed on an "AS IS" BASIS,
		** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		** See the License for the specific language governing permissions and
		** limitations under the License.
		*/

		#include "FileBlobCache.h"

		#include <inttypes.h>
		#include <log/log.h>
		#include <sys/mman.h>
		#include <sys/stat.h>


		// Cache file header
		static const char* cacheFileMagic = "EGL$";
		static const size_t cacheFileHeaderSize = 8;

		namespace android {

		static uint32_t crc32c(const uint8_t* buf, size_t len) {
		const uint32_t polyBits = 0x82F63B78;
		uint32_t r = 0;
		for (size_t i = 0; i < len; i++) {
		r ^= buf[i];
		for (int j = 0; j < 8; j++) {
		if (r & 1) {
		r = (r >> 1) ^ polyBits;
		} else {
		r >>= 1;
		}
		}
		}
		return r;
		}

		FileBlobCache::FileBlobCache(size_t maxKeySize, size_t maxValueSize, size_t maxTotalSize,
		const std::string& filename)
		: BlobCache(maxKeySize, maxValueSize, maxTotalSize)
		, mFilename(filename) {
		if (mFilename.length() > 0) {
		size_t headerSize = cacheFileHeaderSize;

		int fd = open(mFilename.c_str(), O_RDONLY, 0);
		if (fd == -1) {
		if (errno != ENOENT) {
		ALOGE("error opening cache file %s: %s (%d)", mFilename.c_str(),
		strerror(errno), errno);
		}
		return;
		}

		struct stat statBuf;
		if (fstat(fd, &statBuf) == -1) {
		ALOGE("error stat'ing cache file: %s (%d)", strerror(errno), errno);
		close(fd);
		return;
		}

		// Sanity check the size before trying to mmap it.
		size_t fileSize = statBuf.st_size;
		if (fileSize > mMaxTotalSize * 2) {
		ALOGE("cache file is too large: %#" PRIx64,
		static_cast<off64_t>(statBuf.st_size));
		close(fd);
		return;
		}

		uint8_t* buf = reinterpret_cast<uint8_t*>(mmap(NULL, fileSize,
		PROT_READ, MAP_PRIVATE, fd, 0));
		if (buf == MAP_FAILED) {
		ALOGE("error mmaping cache file: %s (%d)", strerror(errno),
		errno);
		close(fd);
		return;
		}

		// Check the file magic and CRC
		size_t cacheSize = fileSize - headerSize;
		if (memcmp(buf, cacheFileMagic, 4) != 0) {
		ALOGE("cache file has bad mojo");
		close(fd);
		return;
		}
		uint32_t* crc = reinterpret_cast<uint32_t*>(buf + 4);
		if (crc32c(buf + headerSize, cacheSize) != *crc) {
		ALOGE("cache file failed CRC check");
		close(fd);
		return;
		}

		int err = unflatten(buf + headerSize, cacheSize);
		if (err < 0) {
		ALOGE("error reading cache contents: %s (%d)", strerror(-err),
		-err);
		munmap(buf, fileSize);
		close(fd);
		return;
		}

		munmap(buf, fileSize);
		close(fd);
		}
		}

		void FileBlobCache::writeToFile() {
		if (mFilename.length() > 0) {
		size_t cacheSize = getFlattenedSize();
		size_t headerSize = cacheFileHeaderSize;
		const char* fname = mFilename.c_str();

		// Try to create the file with no permissions so we can write it
		// without anyone trying to read it.
		int fd = open(fname, O_CREAT \| O_EXCL \| O_RDWR, 0);
		if (fd == -1) {
		if (errno == EEXIST) {
		// The file exists, delete it and try again.
		if (unlink(fname) == -1) {
		// No point in retrying if the unlink failed.
		ALOGE("error unlinking cache file %s: %s (%d)", fname,
		strerror(errno), errno);
		return;
		}
		// Retry now that we've unlinked the file.
		fd = open(fname, O_CREAT \| O_EXCL \| O_RDWR, 0);
		}
		if (fd == -1) {
		ALOGE("error creating cache file %s: %s (%d)", fname,
		strerror(errno), errno);
		return;
		}
		}

		size_t fileSize = headerSize + cacheSize;

		uint8_t* buf = new uint8_t [fileSize];
		if (!buf) {
		ALOGE("error allocating buffer for cache contents: %s (%d)",
		strerror(errno), errno);
		close(fd);
		unlink(fname);
		return;
		}

		int err = flatten(buf + headerSize, cacheSize);
		if (err < 0) {
		ALOGE("error writing cache contents: %s (%d)", strerror(-err),
		-err);
		delete [] buf;
		close(fd);
		unlink(fname);
		return;
		}

		// Write the file magic and CRC
		memcpy(buf, cacheFileMagic, 4);
		uint32_t* crc = reinterpret_cast<uint32_t*>(buf + 4);
		*crc = crc32c(buf + headerSize, cacheSize);

		if (write(fd, buf, fileSize) == -1) {
		ALOGE("error writing cache file: %s (%d)", strerror(errno),
		errno);
		delete [] buf;
		close(fd);
		unlink(fname);
		return;
		}

		delete [] buf;
		fchmod(fd, S_IRUSR);
		close(fd);
		}
		}

		}
		No newline at end of file

opengl/libs/EGL/FileBlobCache.h

0 → 100644

+43 −0

Original line number	Diff line number	Diff line
		/*
		** Copyright 2017, The Android Open Source Project
		**
		** Licensed under the Apache License, Version 2.0 (the "License");
		** you may not use this file except in compliance with the License.
		** You may obtain a copy of the License at
		**
		** http://www.apache.org/licenses/LICENSE-2.0
		**
		** Unless required by applicable law or agreed to in writing, software
		** distributed under the License is distributed on an "AS IS" BASIS,
		** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		** See the License for the specific language governing permissions and
		** limitations under the License.
		*/

		#ifndef ANDROID_FILE_BLOB_CACHE_H
		#define ANDROID_FILE_BLOB_CACHE_H

		#include "BlobCache.h"
		#include <string>

		namespace android {

		class FileBlobCache : public BlobCache {
		public:
		// FileBlobCache attempts to load the saved cache contents from disk into
		// BlobCache.
		FileBlobCache(size_t maxKeySize, size_t maxValueSize, size_t maxTotalSize,
		const std::string& filename);

		// writeToFile attempts to save the current contents of BlobCache to
		// disk.
		void writeToFile();

		private:
		// mFilename is the name of the file for storing cache contents.
		std::string mFilename;
		};

		} // namespace android

		#endif // ANDROID_BLOB_CACHE_H