Merge "Restrict state event logging" into rvc-dev am: 938216c073 (590486af) · Commits · e / os / android_frameworks_base

cmds/statsd/src/StatsLogProcessor.cpp

+7 −6

Original line number	Original line	Diff line number	Diff line
	@@ -101,6 +101,7 @@ StatsLogProcessor::StatsLogProcessor(const sp<UidMap>& uidMap,
	mLargestTimestampSeen(0),		mLargestTimestampSeen(0),
	mLastTimestampSeen(0) {		mLastTimestampSeen(0) {
	mPullerManager->ForceClearPullerCache();		mPullerManager->ForceClearPullerCache();
			StateManager::getInstance().updateLogSources(uidMap);
	}		}

	StatsLogProcessor::~StatsLogProcessor() {		StatsLogProcessor::~StatsLogProcessor() {
	@@ -419,6 +420,9 @@ void StatsLogProcessor::OnLogEvent(LogEvent* event, int64_t elapsedRealtimeNs) {
	// The field numbers need to be currently updated by hand with atoms.proto		// The field numbers need to be currently updated by hand with atoms.proto
	if (atomId == android::os::statsd::util::ISOLATED_UID_CHANGED) {		if (atomId == android::os::statsd::util::ISOLATED_UID_CHANGED) {
	onIsolatedUidChangedEventLocked(*event);		onIsolatedUidChangedEventLocked(*event);
			} else {
			// Map the isolated uid to host uid if necessary.
			mapIsolatedUidToHostUidIfNecessaryLocked(event);
	}		}

	StateManager::getInstance().onLogEvent(*event);		StateManager::getInstance().onLogEvent(*event);
	@@ -433,12 +437,6 @@ void StatsLogProcessor::OnLogEvent(LogEvent* event, int64_t elapsedRealtimeNs) {
	mLastPullerCacheClearTimeSec = curTimeSec;		mLastPullerCacheClearTimeSec = curTimeSec;
	}		}


	if (atomId != android::os::statsd::util::ISOLATED_UID_CHANGED) {
	// Map the isolated uid to host uid if necessary.
	mapIsolatedUidToHostUidIfNecessaryLocked(event);
	}

	std::unordered_set<int> uidsWithActiveConfigsChanged;		std::unordered_set<int> uidsWithActiveConfigsChanged;
	std::unordered_map<int, std::vector<int64_t>> activeConfigsPerUid;		std::unordered_map<int, std::vector<int64_t>> activeConfigsPerUid;
	// pass the event to metrics managers.		// pass the event to metrics managers.
	@@ -1054,6 +1052,7 @@ void StatsLogProcessor::notifyAppUpgrade(const int64_t& eventTimeNs, const strin
	const int uid, const int64_t version) {		const int uid, const int64_t version) {
	std::lock_guard<std::mutex> lock(mMetricsMutex);		std::lock_guard<std::mutex> lock(mMetricsMutex);
	VLOG("Received app upgrade");		VLOG("Received app upgrade");
			StateManager::getInstance().notifyAppChanged(apk, mUidMap);
	for (const auto& it : mMetricsManagers) {		for (const auto& it : mMetricsManagers) {
	it.second->notifyAppUpgrade(eventTimeNs, apk, uid, version);		it.second->notifyAppUpgrade(eventTimeNs, apk, uid, version);
	}		}
	@@ -1063,6 +1062,7 @@ void StatsLogProcessor::notifyAppRemoved(const int64_t& eventTimeNs, const strin
	const int uid) {		const int uid) {
	std::lock_guard<std::mutex> lock(mMetricsMutex);		std::lock_guard<std::mutex> lock(mMetricsMutex);
	VLOG("Received app removed");		VLOG("Received app removed");
			StateManager::getInstance().notifyAppChanged(apk, mUidMap);
	for (const auto& it : mMetricsManagers) {		for (const auto& it : mMetricsManagers) {
	it.second->notifyAppRemoved(eventTimeNs, apk, uid);		it.second->notifyAppRemoved(eventTimeNs, apk, uid);
	}		}
	@@ -1071,6 +1071,7 @@ void StatsLogProcessor::notifyAppRemoved(const int64_t& eventTimeNs, const strin
	void StatsLogProcessor::onUidMapReceived(const int64_t& eventTimeNs) {		void StatsLogProcessor::onUidMapReceived(const int64_t& eventTimeNs) {
	std::lock_guard<std::mutex> lock(mMetricsMutex);		std::lock_guard<std::mutex> lock(mMetricsMutex);
	VLOG("Received uid map");		VLOG("Received uid map");
			StateManager::getInstance().updateLogSources(mUidMap);
	for (const auto& it : mMetricsManagers) {		for (const auto& it : mMetricsManagers) {
	it.second->onUidMapReceived(eventTimeNs);		it.second->onUidMapReceived(eventTimeNs);
	}		}

cmds/statsd/src/state/StateManager.cpp

+30 −2

Original line number	Original line	Diff line number	Diff line
	@@ -19,10 +19,18 @@

	#include "StateManager.h"		#include "StateManager.h"

			#include <private/android_filesystem_config.h>

	namespace android {		namespace android {
	namespace os {		namespace os {
	namespace statsd {		namespace statsd {

			StateManager::StateManager()
			: mAllowedPkg({
			"com.android.systemui",
			}) {
			}

	StateManager& StateManager::getInstance() {		StateManager& StateManager::getInstance() {
	static StateManager sStateManager;		static StateManager sStateManager;
	return sStateManager;		return sStateManager;
	@@ -33,10 +41,16 @@ void StateManager::clear() {
	}		}

	void StateManager::onLogEvent(const LogEvent& event) {		void StateManager::onLogEvent(const LogEvent& event) {
			// Only process state events from uids in AID_* and packages that are whitelisted in
			// mAllowedPkg.
			// Whitelisted AIDs are AID_ROOT and all AIDs in [1000, 2000)
			if (event.GetUid() == AID_ROOT \|\| (event.GetUid() >= 1000 && event.GetUid() < 2000) \|\|
			mAllowedLogSources.find(event.GetUid()) != mAllowedLogSources.end()) {
	if (mStateTrackers.find(event.GetTagId()) != mStateTrackers.end()) {		if (mStateTrackers.find(event.GetTagId()) != mStateTrackers.end()) {
	mStateTrackers[event.GetTagId()]->onLogEvent(event);		mStateTrackers[event.GetTagId()]->onLogEvent(event);
	}		}
	}		}
			}

	void StateManager::registerListener(const int32_t atomId, wp<StateListener> listener) {		void StateManager::registerListener(const int32_t atomId, wp<StateListener> listener) {
	// Check if state tracker already exists.		// Check if state tracker already exists.
	@@ -79,6 +93,20 @@ bool StateManager::getStateValue(const int32_t atomId, const HashableDimensionKe
	return false;		return false;
	}		}

			void StateManager::updateLogSources(const sp<UidMap>& uidMap) {
			mAllowedLogSources.clear();
			for (const auto& pkg : mAllowedPkg) {
			auto uids = uidMap->getAppUid(pkg);
			mAllowedLogSources.insert(uids.begin(), uids.end());
			}
			}

			void StateManager::notifyAppChanged(const string& apk, const sp<UidMap>& uidMap) {
			if (mAllowedPkg.find(apk) != mAllowedPkg.end()) {
			updateLogSources(uidMap);
			}
			}

	} // namespace statsd		} // namespace statsd
	} // namespace os		} // namespace os
	} // namespace android		} // namespace android

cmds/statsd/src/state/StateManager.h

+18 −1

Original line number	Original line	Diff line number	Diff line
	@@ -18,7 +18,12 @@
	#include <inttypes.h>		#include <inttypes.h>
	#include <utils/RefBase.h>		#include <utils/RefBase.h>

			#include <set>
			#include <string>
			#include <unordered_map>

	#include "HashableDimensionKey.h"		#include "HashableDimensionKey.h"
			#include "packages/UidMap.h"
	#include "state/StateListener.h"		#include "state/StateListener.h"
	#include "state/StateTracker.h"		#include "state/StateTracker.h"

	@@ -32,7 +37,7 @@ namespace statsd {
	*/		*/
	class StateManager : public virtual RefBase {		class StateManager : public virtual RefBase {
	public:		public:
	StateManager(){};		StateManager();

	~StateManager(){};		~StateManager(){};

	@@ -62,6 +67,11 @@ public:
	bool getStateValue(const int32_t atomId, const HashableDimensionKey& queryKey,		bool getStateValue(const int32_t atomId, const HashableDimensionKey& queryKey,
	FieldValue* output) const;		FieldValue* output) const;

			// Updates mAllowedLogSources with the latest uids for the packages that are allowed to log.
			void updateLogSources(const sp<UidMap>& uidMap);

			void notifyAppChanged(const string& apk, const sp<UidMap>& uidMap);

	inline int getStateTrackersCount() const {		inline int getStateTrackersCount() const {
	return mStateTrackers.size();		return mStateTrackers.size();
	}		}
	@@ -79,6 +89,13 @@ private:

	// Maps state atom ids to StateTrackers		// Maps state atom ids to StateTrackers
	std::unordered_map<int32_t, sp<StateTracker>> mStateTrackers;		std::unordered_map<int32_t, sp<StateTracker>> mStateTrackers;

			// The package names that can log state events.
			const std::set<std::string> mAllowedPkg;

			// The combined uid sources (after translating pkg name to uid).
			// State events from uids that are not in the list will be ignored to avoid state pollution.
			std::set<int32_t> mAllowedLogSources;
	};		};

	} // namespace statsd		} // namespace statsd

cmds/statsd/tests/state/StateTracker_test.cpp

+50 −0

Original line number	Original line	Diff line number	Diff line
	@@ -16,6 +16,7 @@
	#include "state/StateTracker.h"		#include "state/StateTracker.h"

	#include <gtest/gtest.h>		#include <gtest/gtest.h>
			#include <private/android_filesystem_config.h>

	#include "state/StateListener.h"		#include "state/StateListener.h"
	#include "state/StateManager.h"		#include "state/StateManager.h"
	@@ -114,6 +115,55 @@ TEST(StateManagerTest, TestStateManagerGetInstance) {
	EXPECT_EQ(1, StateManager::getInstance().getStateTrackersCount());		EXPECT_EQ(1, StateManager::getInstance().getStateTrackersCount());
	}		}

			TEST(StateManagerTest, TestOnLogEvent) {
			sp<MockUidMap> uidMap = makeMockUidMapForPackage("com.android.systemui", {10111});
			sp<TestStateListener> listener1 = new TestStateListener();
			StateManager mgr;
			mgr.updateLogSources(uidMap);
			// Add StateTracker by registering a listener.
			mgr.registerListener(util::SCREEN_STATE_CHANGED, listener1);

			// log event using AID_ROOT
			std::unique_ptr<LogEvent> event = CreateScreenStateChangedEvent(
			timestampNs, android::view::DisplayStateEnum::DISPLAY_STATE_ON);
			mgr.onLogEvent(*event);

			// check StateTracker was updated by querying for state
			HashableDimensionKey queryKey = DEFAULT_DIMENSION_KEY;
			EXPECT_EQ(android::view::DisplayStateEnum::DISPLAY_STATE_ON,
			getStateInt(mgr, util::SCREEN_STATE_CHANGED, queryKey));

			// log event using mocked uid
			event = CreateScreenStateChangedEvent(
			timestampNs, android::view::DisplayStateEnum::DISPLAY_STATE_OFF, 10111);
			mgr.onLogEvent(*event);

			// check StateTracker was updated by querying for state
			queryKey = DEFAULT_DIMENSION_KEY;
			EXPECT_EQ(android::view::DisplayStateEnum::DISPLAY_STATE_OFF,
			getStateInt(mgr, util::SCREEN_STATE_CHANGED, queryKey));

			// log event using non-whitelisted uid
			event = CreateScreenStateChangedEvent(timestampNs,
			android::view::DisplayStateEnum::DISPLAY_STATE_ON, 10112);
			mgr.onLogEvent(*event);

			// check StateTracker was NOT updated by querying for state
			queryKey = DEFAULT_DIMENSION_KEY;
			EXPECT_EQ(android::view::DisplayStateEnum::DISPLAY_STATE_OFF,
			getStateInt(mgr, util::SCREEN_STATE_CHANGED, queryKey));

			// log event using AID_SYSTEM
			event = CreateScreenStateChangedEvent(
			timestampNs, android::view::DisplayStateEnum::DISPLAY_STATE_ON, AID_SYSTEM);
			mgr.onLogEvent(*event);

			// check StateTracker was updated by querying for state
			queryKey = DEFAULT_DIMENSION_KEY;
			EXPECT_EQ(android::view::DisplayStateEnum::DISPLAY_STATE_ON,
			getStateInt(mgr, util::SCREEN_STATE_CHANGED, queryKey));
			}

	/**		/**
	* Test registering listeners to StateTrackers		* Test registering listeners to StateTrackers
	*		*

cmds/statsd/tests/statsd_test_util.cpp

+12 −3

Original line number	Original line	Diff line number	Diff line
	@@ -635,8 +635,17 @@ sp<MockUidMap> makeMockUidMapForOneHost(int hostUid, const vector<int>& isolated
	return uidMap;		return uidMap;
	}		}

	std::unique_ptr<LogEvent> CreateScreenStateChangedEvent(		sp<MockUidMap> makeMockUidMapForPackage(const string& pkg, const set<int32_t>& uids) {
	uint64_t timestampNs, const android::view::DisplayStateEnum state) {		sp<MockUidMap> uidMap = new StrictMock<MockUidMap>();
			EXPECT_CALL(*uidMap, getAppUid(_)).Times(AnyNumber());
			EXPECT_CALL(*uidMap, getAppUid(pkg)).WillRepeatedly(Return(uids));

			return uidMap;
			}

			std::unique_ptr<LogEvent> CreateScreenStateChangedEvent(uint64_t timestampNs,
			const android::view::DisplayStateEnum state,
			int loggerUid) {
	AStatsEvent* statsEvent = AStatsEvent_obtain();		AStatsEvent* statsEvent = AStatsEvent_obtain();
	AStatsEvent_setAtomId(statsEvent, util::SCREEN_STATE_CHANGED);		AStatsEvent_setAtomId(statsEvent, util::SCREEN_STATE_CHANGED);
	AStatsEvent_overwriteTimestamp(statsEvent, timestampNs);		AStatsEvent_overwriteTimestamp(statsEvent, timestampNs);
	@@ -644,7 +653,7 @@ std::unique_ptr<LogEvent> CreateScreenStateChangedEvent(
	AStatsEvent_addBoolAnnotation(statsEvent, util::ANNOTATION_ID_EXCLUSIVE_STATE, true);		AStatsEvent_addBoolAnnotation(statsEvent, util::ANNOTATION_ID_EXCLUSIVE_STATE, true);
	AStatsEvent_addBoolAnnotation(statsEvent, util::ANNOTATION_ID_STATE_NESTED, false);		AStatsEvent_addBoolAnnotation(statsEvent, util::ANNOTATION_ID_STATE_NESTED, false);

	std::unique_ptr<LogEvent> logEvent = std::make_unique<LogEvent>(/uid=/0, /pid=/0);		std::unique_ptr<LogEvent> logEvent = std::make_unique<LogEvent>(loggerUid, /pid=/0);
	parseStatsEventToLogEvent(statsEvent, logEvent.get());		parseStatsEventToLogEvent(statsEvent, logEvent.get());
	return logEvent;		return logEvent;
	}		}