Snap for 10878163 from c890a4c8d26e58384b215aae881b4632a87eb1d5 to 24Q1-release (ef6509eb) · Commits · e / os / android_frameworks_native

cmds/servicemanager/ServiceManager.cpp

+19 −2

Original line number	Diff line number	Diff line
		@@ -18,6 +18,7 @@

		#include <android-base/logging.h>
		#include <android-base/properties.h>
		#include <android-base/strings.h>
		#include <binder/BpBinder.h>
		#include <binder/IPCThreadState.h>
		#include <binder/ProcessState.h>
		@@ -117,10 +118,26 @@ static bool isVintfDeclared(const std::string& name) {
		});

		if (!found) {
		std::set<std::string> instances;
		forEachManifest([&](const ManifestWithDescription& mwd) {
		std::set<std::string> res = mwd.manifest->getAidlInstances(aname.package, aname.iface);
		instances.insert(res.begin(), res.end());
		return true;
		});

		std::string available;
		if (instances.empty()) {
		available = "No alternative instances declared in VINTF";
		} else {
		// for logging only. We can't return this information to the client
		// because they may not have permissions to find or list those
		// instances
		available = "VINTF declared instances: " + base::Join(instances, ", ");
		}
		// Although it is tested, explicitly rebuilding qualified name, in case it
		// becomes something unexpected.
		ALOGI("Could not find %s.%s/%s in the VINTF manifest.", aname.package.c_str(),
		aname.iface.c_str(), aname.instance.c_str());
		ALOGI("Could not find %s.%s/%s in the VINTF manifest. %s.", aname.package.c_str(),
		aname.iface.c_str(), aname.instance.c_str(), available.c_str());
		}

		return found;

opengl/libs/EGL/MultifileBlobCache.cpp

+11 −5

Original line number	Diff line number	Diff line
		@@ -48,9 +48,8 @@ namespace {
		void freeHotCacheEntry(android::MultifileHotCache& entry) {
		if (entry.entryFd != -1) {
		// If we have an fd, then this entry was added to hot cache via INIT or GET
		// We need to unmap and close the entry
		// We need to unmap the entry
		munmap(entry.entryBuffer, entry.entrySize);
		close(entry.entryFd);
		} else {
		// Otherwise, this was added to hot cache during SET, so it was never mapped
		// and fd was only on the deferred thread.
		@@ -143,6 +142,7 @@ MultifileBlobCache::MultifileBlobCache(size_t maxKeySize, size_t maxValueSize, s
		if (result != sizeof(MultifileHeader)) {
		ALOGE("Error reading MultifileHeader from cache entry (%s): %s",
		fullPath.c_str(), std::strerror(errno));
		close(fd);
		return;
		}

		@@ -152,6 +152,7 @@ MultifileBlobCache::MultifileBlobCache(size_t maxKeySize, size_t maxValueSize, s
		if (remove(fullPath.c_str()) != 0) {
		ALOGE("Error removing %s: %s", fullPath.c_str(), std::strerror(errno));
		}
		close(fd);
		continue;
		}

		@@ -161,6 +162,10 @@ MultifileBlobCache::MultifileBlobCache(size_t maxKeySize, size_t maxValueSize, s
		// Memory map the file
		uint8_t* mappedEntry = reinterpret_cast<uint8_t*>(
		mmap(nullptr, fileSize, PROT_READ, MAP_PRIVATE, fd, 0));

		// We can close the file now and the mmap will remain
		close(fd);

		if (mappedEntry == MAP_FAILED) {
		ALOGE("Failed to mmap cacheEntry, error: %s", std::strerror(errno));
		return;
		@@ -206,13 +211,11 @@ MultifileBlobCache::MultifileBlobCache(size_t maxKeySize, size_t maxValueSize, s
		if (!addToHotCache(entryHash, fd, mappedEntry, fileSize)) {
		ALOGE("INIT Failed to add %u to hot cache", entryHash);
		munmap(mappedEntry, fileSize);
		close(fd);
		return;
		}
		} else {
		// If we're not keeping it in hot cache, unmap it now
		munmap(mappedEntry, fileSize);
		close(fd);
		}
		}
		closedir(dir);
		@@ -401,9 +404,12 @@ EGLsizeiANDROID MultifileBlobCache::get(const void* key, EGLsizeiANDROID keySize
		// Memory map the file
		cacheEntry =
		reinterpret_cast<uint8_t*>(mmap(nullptr, fileSize, PROT_READ, MAP_PRIVATE, fd, 0));

		// We can close the file now and the mmap will remain
		close(fd);

		if (cacheEntry == MAP_FAILED) {
		ALOGE("Failed to mmap cacheEntry, error: %s", std::strerror(errno));
		close(fd);
		return 0;
		}

opengl/libs/EGL/MultifileBlobCache_test.cpp

+54 −0

Original line number	Diff line number	Diff line
		@@ -42,6 +42,8 @@ protected:

		virtual void TearDown() { mMBC.reset(); }

		int getFileDescriptorCount();

		std::unique_ptr<TemporaryFile> mTempFile;
		std::unique_ptr<MultifileBlobCache> mMBC;
		};
		@@ -216,4 +218,56 @@ TEST_F(MultifileBlobCacheTest, CacheMinKeyAndValueSizeSucceeds) {
		ASSERT_EQ('y', buf[0]);
		}

		int MultifileBlobCacheTest::getFileDescriptorCount() {
		DIR* directory = opendir("/proc/self/fd");

		int fileCount = 0;
		struct dirent* entry;
		while ((entry = readdir(directory)) != NULL) {
		fileCount++;
		// printf("File: %s\n", entry->d_name);
		}

		closedir(directory);
		return fileCount;
		}

		TEST_F(MultifileBlobCacheTest, EnsureFileDescriptorsClosed) {
		// Populate the cache with a bunch of entries
		size_t kLargeNumberOfEntries = 1024;
		for (int i = 0; i < kLargeNumberOfEntries; i++) {
		// printf("Caching: %i", i);

		// Use the index as the key and value
		mMBC->set(&i, sizeof(i), &i, sizeof(i));

		int result = 0;
		ASSERT_EQ(sizeof(i), mMBC->get(&i, sizeof(i), &result, sizeof(result)));
		ASSERT_EQ(i, result);
		}

		// Ensure we don't have a bunch of open fds
		ASSERT_LT(getFileDescriptorCount(), kLargeNumberOfEntries / 2);

		// Close the cache so everything writes out
		mMBC->finish();
		mMBC.reset();

		// Now open it again and ensure we still don't have a bunch of open fds
		mMBC.reset(
		new MultifileBlobCache(kMaxKeySize, kMaxValueSize, kMaxTotalSize, &mTempFile->path[0]));

		// Check after initialization
		ASSERT_LT(getFileDescriptorCount(), kLargeNumberOfEntries / 2);

		for (int i = 0; i < kLargeNumberOfEntries; i++) {
		int result = 0;
		ASSERT_EQ(sizeof(i), mMBC->get(&i, sizeof(i), &result, sizeof(result)));
		ASSERT_EQ(i, result);
		}

		// And again after we've actually used it
		ASSERT_LT(getFileDescriptorCount(), kLargeNumberOfEntries / 2);
		}

		} // namespace android

services/inputflinger/InputDeviceMetricsCollector.cpp

+22 −15

Original line number	Diff line number	Diff line
		@@ -64,14 +64,13 @@ int32_t linuxBusToInputDeviceBusEnum(int32_t linuxBus, bool isUsiStylus) {
		class : public InputDeviceMetricsLogger {
		nanoseconds getCurrentTime() override { return nanoseconds(systemTime(SYSTEM_TIME_MONOTONIC)); }

		void logInputDeviceUsageReported(const InputDeviceInfo& info,
		void logInputDeviceUsageReported(const MetricsDeviceInfo& info,
		const DeviceUsageReport& report) override {
		const int32_t durationMillis =
		std::chrono::duration_cast<std::chrono::milliseconds>(report.usageDuration).count();
		const static std::vector<int32_t> empty;
		const auto& identifier = info.getIdentifier();

		ALOGD_IF(DEBUG, "Usage session reported for device: %s", identifier.name.c_str());
		ALOGD_IF(DEBUG, "Usage session reported for device id: %d", info.deviceId);
		ALOGD_IF(DEBUG, " Total duration: %dms", durationMillis);
		ALOGD_IF(DEBUG, " Source breakdown:");

		@@ -96,11 +95,9 @@ class : public InputDeviceMetricsLogger {
		ALOGD_IF(DEBUG, " - uid: %s\t duration: %dms", uid.toString().c_str(),
		durMillis);
		}
		util::stats_write(util::INPUTDEVICE_USAGE_REPORTED, identifier.vendor, identifier.product,
		identifier.version,
		linuxBusToInputDeviceBusEnum(identifier.bus,
		info.getUsiVersion().has_value()),
		durationMillis, sources, durationsPerSource, uids, durationsPerUid);
		util::stats_write(util::INPUTDEVICE_USAGE_REPORTED, info.vendor, info.product, info.version,
		linuxBusToInputDeviceBusEnum(info.bus, info.isUsiStylus), durationMillis,
		sources, durationsPerSource, uids, durationsPerUid);
		}
		} sStatsdLogger;

		@@ -116,7 +113,7 @@ bool isIgnoredInputDeviceId(int32_t deviceId) {

		} // namespace

		InputDeviceUsageSource getUsageSourceForKeyArgs(const InputDeviceInfo& info,
		InputDeviceUsageSource getUsageSourceForKeyArgs(int32_t keyboardType,
		const NotifyKeyArgs& keyArgs) {
		if (!isFromSource(keyArgs.source, AINPUT_SOURCE_KEYBOARD)) {
		return InputDeviceUsageSource::UNKNOWN;
		@@ -132,7 +129,7 @@ InputDeviceUsageSource getUsageSourceForKeyArgs(const InputDeviceInfo& info,
		return InputDeviceUsageSource::GAMEPAD;
		}

		if (info.getKeyboardType() == AINPUT_KEYBOARD_TYPE_ALPHABETIC) {
		if (keyboardType == AINPUT_KEYBOARD_TYPE_ALPHABETIC) {
		return InputDeviceUsageSource::KEYBOARD;
		}

		@@ -232,8 +229,8 @@ void InputDeviceMetricsCollector::notifyConfigurationChanged(

		void InputDeviceMetricsCollector::notifyKey(const NotifyKeyArgs& args) {
		reportCompletedSessions();
		const SourceProvider getSources = [&args](const InputDeviceInfo& info) {
		return std::set{getUsageSourceForKeyArgs(info, args)};
		const SourceProvider getSources = [&args](const MetricsDeviceInfo& info) {
		return std::set{getUsageSourceForKeyArgs(info.keyboardType, args)};
		};
		onInputDeviceUsage(DeviceId{args.deviceId}, nanoseconds(args.eventTime), getSources);

		@@ -291,13 +288,23 @@ void InputDeviceMetricsCollector::dump(std::string& dump) {
		}

		void InputDeviceMetricsCollector::onInputDevicesChanged(const std::vector<InputDeviceInfo>& infos) {
		std::map<DeviceId, InputDeviceInfo> newDeviceInfos;
		std::map<DeviceId, MetricsDeviceInfo> newDeviceInfos;

		for (const InputDeviceInfo& info : infos) {
		if (isIgnoredInputDeviceId(info.getId())) {
		continue;
		}
		newDeviceInfos.emplace(info.getId(), info);
		const auto& i = info.getIdentifier();
		newDeviceInfos.emplace(info.getId(),
		MetricsDeviceInfo{
		.deviceId = info.getId(),
		.vendor = i.vendor,
		.product = i.product,
		.version = i.version,
		.bus = i.bus,
		.isUsiStylus = info.getUsiVersion().has_value(),
		.keyboardType = info.getKeyboardType(),
		});
		}

		for (auto [deviceId, info] : mLoggedDeviceInfos) {
		@@ -311,7 +318,7 @@ void InputDeviceMetricsCollector::onInputDevicesChanged(const std::vector<InputD
		}

		void InputDeviceMetricsCollector::onInputDeviceRemoved(DeviceId deviceId,
		const InputDeviceInfo& info) {
		const MetricsDeviceInfo& info) {
		auto it = mActiveUsageSessions.find(deviceId);
		if (it == mActiveUsageSessions.end()) {
		return;

services/inputflinger/InputDeviceMetricsCollector.h

+19 −5

Original line number	Diff line number	Diff line
		@@ -79,7 +79,7 @@ enum class InputDeviceUsageSource : int32_t {
		};

		/** Returns the InputDeviceUsageSource that corresponds to the key event. */
		InputDeviceUsageSource getUsageSourceForKeyArgs(const InputDeviceInfo&, const NotifyKeyArgs&);
		InputDeviceUsageSource getUsageSourceForKeyArgs(int32_t keyboardType, const NotifyKeyArgs&);

		/** Returns the InputDeviceUsageSources that correspond to the motion event. */
		std::set<InputDeviceUsageSource> getUsageSourcesForMotionArgs(const NotifyMotionArgs&);
		@@ -110,7 +110,19 @@ public:
		UidUsageBreakdown uidBreakdown;
		};

		virtual void logInputDeviceUsageReported(const InputDeviceInfo&, const DeviceUsageReport&) = 0;
		// A subset of information from the InputDeviceInfo class that is used for metrics collection,
		// used to avoid copying and storing all of the fields and strings in InputDeviceInfo.
		struct MetricsDeviceInfo {
		int32_t deviceId;
		int32_t vendor;
		int32_t product;
		int32_t version;
		int32_t bus;
		bool isUsiStylus;
		int32_t keyboardType;
		};
		virtual void logInputDeviceUsageReported(const MetricsDeviceInfo&,
		const DeviceUsageReport&) = 0;
		virtual ~InputDeviceMetricsLogger() = default;
		};

		@@ -153,8 +165,9 @@ private:
		}

		using Uid = gui::Uid;
		using MetricsDeviceInfo = InputDeviceMetricsLogger::MetricsDeviceInfo;

		std::map<DeviceId, InputDeviceInfo> mLoggedDeviceInfos;
		std::map<DeviceId, MetricsDeviceInfo> mLoggedDeviceInfos;

		using Interaction = std::tuple<DeviceId, std::chrono::nanoseconds, std::set<Uid>>;
		SyncQueue<Interaction> mInteractionsQueue;
		@@ -188,8 +201,9 @@ private:
		std::map<DeviceId, ActiveSession> mActiveUsageSessions;

		void onInputDevicesChanged(const std::vector<InputDeviceInfo>& infos);
		void onInputDeviceRemoved(DeviceId deviceId, const InputDeviceInfo& info);
		using SourceProvider = std::function<std::set<InputDeviceUsageSource>(const InputDeviceInfo&)>;
		void onInputDeviceRemoved(DeviceId deviceId, const MetricsDeviceInfo& info);
		using SourceProvider =
		std::function<std::set<InputDeviceUsageSource>(const MetricsDeviceInfo&)>;
		void onInputDeviceUsage(DeviceId deviceId, std::chrono::nanoseconds eventTime,
		const SourceProvider& getSources);
		void onInputDeviceInteraction(const Interaction&);