Merge "Bug fixes and testing support for DiscreteRegistry" into sc-dev am: bd45b82617 (6145fb55) · Commits · e / os / android_frameworks_base

core/java/android/app/AppOpsManager.java

+17 −6

Original line number	Original line	Diff line number	Diff line
	@@ -6511,13 +6511,21 @@ public class AppOpsManager {
	NoteOpEvent note = new NoteOpEvent(discreteAccessTime, discreteAccessDuration, null);		NoteOpEvent note = new NoteOpEvent(discreteAccessTime, discreteAccessDuration, null);
	accessEvents.append(key, note);		accessEvents.append(key, note);
	AttributedOpEntry access = new AttributedOpEntry(mOp, false, accessEvents, null);		AttributedOpEntry access = new AttributedOpEntry(mOp, false, accessEvents, null);
	for (int i = discreteAccesses.size() - 1; i >= 0; i--) {		int insertionPoint = discreteAccesses.size() - 1;
	if (discreteAccesses.get(i).getLastAccessTime(OP_FLAGS_ALL) < discreteAccessTime) {		for (; insertionPoint >= 0; insertionPoint--) {
	discreteAccesses.add(i + 1, access);		if (discreteAccesses.get(insertionPoint).getLastAccessTime(OP_FLAGS_ALL)
	return;		< discreteAccessTime) {
			break;
	}		}
	}		}
	discreteAccesses.add(0, access);		insertionPoint++;
			if (insertionPoint < discreteAccesses.size() && discreteAccesses.get(
			insertionPoint).getLastAccessTime(OP_FLAGS_ALL) == discreteAccessTime) {
			discreteAccesses.set(insertionPoint, mergeAttributedOpEntries(
			Arrays.asList(discreteAccesses.get(insertionPoint), access)));
			} else {
			discreteAccesses.add(insertionPoint, access);
			}
	}		}

	/**		/**
	@@ -9858,8 +9866,11 @@ public class AppOpsManager {
	NoteOpEvent reject = a.getLastRejectEvent(uidState, uidState, flags);		NoteOpEvent reject = a.getLastRejectEvent(uidState, uidState, flags);

	if (access != null) {		if (access != null) {
			NoteOpEvent existingAccess = accessEvents.get(key);
			if (existingAccess == null \|\| existingAccess.getDuration() == -1) {
	accessEvents.append(key, access);		accessEvents.append(key, access);
	}		}
			}
	if (reject != null) {		if (reject != null) {
	rejectEvents.append(key, reject);		rejectEvents.append(key, reject);
	}		}

services/core/java/com/android/server/appop/DiscreteRegistry.java

+73 −22

Original line number	Original line	Diff line number	Diff line
	@@ -92,8 +92,8 @@ final class DiscreteRegistry {
	"discrete_history_quantization_millis";		"discrete_history_quantization_millis";
	private static final String PROPERTY_DISCRETE_FLAGS = "discrete_history_op_flags";		private static final String PROPERTY_DISCRETE_FLAGS = "discrete_history_op_flags";
	private static final String PROPERTY_DISCRETE_OPS_LIST = "discrete_history_ops_cslist";		private static final String PROPERTY_DISCRETE_OPS_LIST = "discrete_history_ops_cslist";
	private static final String DEFAULT_DISCRETE_OPS = OP_CAMERA + "," + OP_RECORD_AUDIO + ","		private static final String DEFAULT_DISCRETE_OPS = OP_FINE_LOCATION + "," + OP_COARSE_LOCATION
	+ OP_FINE_LOCATION + "," + OP_COARSE_LOCATION;		+ "," + OP_CAMERA + "," + OP_RECORD_AUDIO;
	private static final long DEFAULT_DISCRETE_HISTORY_CUTOFF = Duration.ofHours(24).toMillis();		private static final long DEFAULT_DISCRETE_HISTORY_CUTOFF = Duration.ofHours(24).toMillis();
	private static final long MAXIMUM_DISCRETE_HISTORY_CUTOFF = Duration.ofDays(30).toMillis();		private static final long MAXIMUM_DISCRETE_HISTORY_CUTOFF = Duration.ofDays(30).toMillis();
	private static final long DEFAULT_DISCRETE_HISTORY_QUANTIZATION =		private static final long DEFAULT_DISCRETE_HISTORY_QUANTIZATION =
	@@ -104,7 +104,6 @@ final class DiscreteRegistry {
	private static int[] sDiscreteOps;		private static int[] sDiscreteOps;
	private static int sDiscreteFlags;		private static int sDiscreteFlags;


	private static final String TAG_HISTORY = "h";		private static final String TAG_HISTORY = "h";
	private static final String ATTR_VERSION = "v";		private static final String ATTR_VERSION = "v";
	private static final int CURRENT_VERSION = 1;		private static final int CURRENT_VERSION = 1;
	@@ -144,6 +143,8 @@ final class DiscreteRegistry {
	@GuardedBy("mOnDiskLock")		@GuardedBy("mOnDiskLock")
	private DiscreteOps mCachedOps = null;		private DiscreteOps mCachedOps = null;

			private boolean mDebugMode = false;

	DiscreteRegistry(Object inMemoryLock) {		DiscreteRegistry(Object inMemoryLock) {
	mInMemoryLock = inMemoryLock;		mInMemoryLock = inMemoryLock;
	}		}
	@@ -159,40 +160,35 @@ final class DiscreteRegistry {
	AsyncTask.THREAD_POOL_EXECUTOR, (DeviceConfig.Properties p) -> {		AsyncTask.THREAD_POOL_EXECUTOR, (DeviceConfig.Properties p) -> {
	setDiscreteHistoryParameters(p);		setDiscreteHistoryParameters(p);
	});		});
	sDiscreteHistoryCutoff = DeviceConfig.getLong(DeviceConfig.NAMESPACE_PRIVACY,		setDiscreteHistoryParameters(DeviceConfig.getProperties(DeviceConfig.NAMESPACE_PRIVACY));
	PROPERTY_DISCRETE_HISTORY_CUTOFF, DEFAULT_DISCRETE_HISTORY_CUTOFF);
	sDiscreteHistoryQuantization = DeviceConfig.getLong(DeviceConfig.NAMESPACE_PRIVACY,
	PROPERTY_DISCRETE_HISTORY_QUANTIZATION, DEFAULT_DISCRETE_HISTORY_QUANTIZATION);
	sDiscreteFlags = DeviceConfig.getInt(DeviceConfig.NAMESPACE_PRIVACY,
	PROPERTY_DISCRETE_FLAGS, OP_FLAGS_DISCRETE);
	sDiscreteOps = parseOpsList(DeviceConfig.getString(DeviceConfig.NAMESPACE_PRIVACY,
	PROPERTY_DISCRETE_OPS_LIST, DEFAULT_DISCRETE_OPS));
	}		}

	private void setDiscreteHistoryParameters(DeviceConfig.Properties p) {		private void setDiscreteHistoryParameters(DeviceConfig.Properties p) {
	if (p.getKeyset().contains(PROPERTY_DISCRETE_HISTORY_CUTOFF)) {		if (p.getKeyset().contains(PROPERTY_DISCRETE_HISTORY_CUTOFF)) {
	sDiscreteHistoryCutoff = p.getLong(PROPERTY_DISCRETE_HISTORY_CUTOFF,		sDiscreteHistoryCutoff = p.getLong(PROPERTY_DISCRETE_HISTORY_CUTOFF,
	DEFAULT_DISCRETE_HISTORY_CUTOFF);		DEFAULT_DISCRETE_HISTORY_CUTOFF);
	if (!Build.IS_DEBUGGABLE) {		if (!Build.IS_DEBUGGABLE && !mDebugMode) {
	sDiscreteHistoryCutoff = min(MAXIMUM_DISCRETE_HISTORY_CUTOFF,		sDiscreteHistoryCutoff = min(MAXIMUM_DISCRETE_HISTORY_CUTOFF,
	sDiscreteHistoryCutoff);		sDiscreteHistoryCutoff);
	}		}
			} else {
			sDiscreteHistoryCutoff = DEFAULT_DISCRETE_HISTORY_CUTOFF;
	}		}
	if (p.getKeyset().contains(PROPERTY_DISCRETE_HISTORY_QUANTIZATION)) {		if (p.getKeyset().contains(PROPERTY_DISCRETE_HISTORY_QUANTIZATION)) {
	sDiscreteHistoryQuantization = p.getLong(PROPERTY_DISCRETE_HISTORY_QUANTIZATION,		sDiscreteHistoryQuantization = p.getLong(PROPERTY_DISCRETE_HISTORY_QUANTIZATION,
	DEFAULT_DISCRETE_HISTORY_QUANTIZATION);		DEFAULT_DISCRETE_HISTORY_QUANTIZATION);
	if (!Build.IS_DEBUGGABLE) {		if (!Build.IS_DEBUGGABLE && !mDebugMode) {
	sDiscreteHistoryQuantization = max(DEFAULT_DISCRETE_HISTORY_QUANTIZATION,		sDiscreteHistoryQuantization = max(DEFAULT_DISCRETE_HISTORY_QUANTIZATION,
	sDiscreteHistoryQuantization);		sDiscreteHistoryQuantization);
	}		}
			} else {
			sDiscreteHistoryQuantization = DEFAULT_DISCRETE_HISTORY_QUANTIZATION;
	}		}
	if (p.getKeyset().contains(PROPERTY_DISCRETE_FLAGS)) {		sDiscreteFlags = p.getKeyset().contains(PROPERTY_DISCRETE_FLAGS) ? sDiscreteFlags =
	sDiscreteFlags = p.getInt(PROPERTY_DISCRETE_FLAGS, OP_FLAGS_DISCRETE);		p.getInt(PROPERTY_DISCRETE_FLAGS, OP_FLAGS_DISCRETE) : OP_FLAGS_DISCRETE;
	}		sDiscreteOps = p.getKeyset().contains(PROPERTY_DISCRETE_OPS_LIST) ? parseOpsList(
	if (p.getKeyset().contains(PROPERTY_DISCRETE_OPS_LIST)) {		p.getString(PROPERTY_DISCRETE_OPS_LIST, DEFAULT_DISCRETE_OPS)) : parseOpsList(
	sDiscreteOps = parseOpsList(p.getString(PROPERTY_DISCRETE_OPS_LIST,		DEFAULT_DISCRETE_OPS);
	DEFAULT_DISCRETE_OPS));
	}
	}		}

	void recordDiscreteAccess(int uid, String packageName, int op, @Nullable String attributionTag,		void recordDiscreteAccess(int uid, String packageName, int op, @Nullable String attributionTag,
	@@ -232,6 +228,8 @@ final class DiscreteRegistry {
	@Nullable String packageNameFilter, @Nullable String[] opNamesFilter,		@Nullable String packageNameFilter, @Nullable String[] opNamesFilter,
	@Nullable String attributionTagFilter, @AppOpsManager.OpFlags int flagsFilter) {		@Nullable String attributionTagFilter, @AppOpsManager.OpFlags int flagsFilter) {
	DiscreteOps discreteOps = getAllDiscreteOps();		DiscreteOps discreteOps = getAllDiscreteOps();
			beginTimeMillis = max(beginTimeMillis, Instant.now().minus(sDiscreteHistoryCutoff,
			ChronoUnit.MILLIS).toEpochMilli());
	discreteOps.filter(beginTimeMillis, endTimeMillis, filter, uidFilter, packageNameFilter,		discreteOps.filter(beginTimeMillis, endTimeMillis, filter, uidFilter, packageNameFilter,
	opNamesFilter, attributionTagFilter, flagsFilter);		opNamesFilter, attributionTagFilter, flagsFilter);
	discreteOps.applyToHistoricalOps(result);		discreteOps.applyToHistoricalOps(result);
	@@ -282,6 +280,18 @@ final class DiscreteRegistry {
	}		}
	}		}

			void offsetHistory(long offset) {
			synchronized (mOnDiskLock) {
			DiscreteOps discreteOps;
			synchronized (mInMemoryLock) {
			discreteOps = getAllDiscreteOps();
			clearHistory();
			}
			discreteOps.offsetHistory(offset);
			persistDiscreteOpsLocked(discreteOps);
			}
			}

	void dump(@NonNull PrintWriter pw, int uidFilter, @Nullable String packageNameFilter,		void dump(@NonNull PrintWriter pw, int uidFilter, @Nullable String packageNameFilter,
	@Nullable String attributionTagFilter,		@Nullable String attributionTagFilter,
	@AppOpsManager.HistoricalOpsRequestFilter int filter, int dumpOp,		@AppOpsManager.HistoricalOpsRequestFilter int filter, int dumpOp,
	@@ -363,6 +373,13 @@ final class DiscreteRegistry {
	}		}
	}		}

			private void offsetHistory(long offset) {
			int nUids = mUids.size();
			for (int i = 0; i < nUids; i++) {
			mUids.valueAt(i).offsetHistory(offset);
			}
			}

	private void clearHistory(int uid, String packageName) {		private void clearHistory(int uid, String packageName) {
	if (mUids.containsKey(uid)) {		if (mUids.containsKey(uid)) {
	mUids.get(uid).clearPackage(packageName);		mUids.get(uid).clearPackage(packageName);
	@@ -549,6 +566,13 @@ final class DiscreteRegistry {
	}		}
	}		}

			private void offsetHistory(long offset) {
			int nPackages = mPackages.size();
			for (int i = 0; i < nPackages; i++) {
			mPackages.valueAt(i).offsetHistory(offset);
			}
			}

	private void clearPackage(String packageName) {		private void clearPackage(String packageName) {
	mPackages.remove(packageName);		mPackages.remove(packageName);
	}		}
	@@ -656,6 +680,13 @@ final class DiscreteRegistry {
	}		}
	}		}

			private void offsetHistory(long offset) {
			int nOps = mPackageOps.size();
			for (int i = 0; i < nOps; i++) {
			mPackageOps.valueAt(i).offsetHistory(offset);
			}
			}

	private DiscreteOp getOrCreateDiscreteOp(int op) {		private DiscreteOp getOrCreateDiscreteOp(int op) {
	DiscreteOp result = mPackageOps.get(op);		DiscreteOp result = mPackageOps.get(op);
	if (result == null) {		if (result == null) {
	@@ -749,12 +780,29 @@ final class DiscreteRegistry {
	}		}
	}		}

			private void offsetHistory(long offset) {
			int nTags = mAttributedOps.size();
			for (int i = 0; i < nTags; i++) {
			List<DiscreteOpEvent> list = mAttributedOps.valueAt(i);

			int n = list.size();
			for (int j = 0; j < n; j++) {
			DiscreteOpEvent event = list.get(j);
			list.set(j, new DiscreteOpEvent(event.mNoteTime - offset, event.mNoteDuration,
			event.mUidState, event.mOpFlag));
			}
			}
			}

	void addDiscreteAccess(@Nullable String attributionTag,		void addDiscreteAccess(@Nullable String attributionTag,
	@AppOpsManager.OpFlags int flags, @AppOpsManager.UidState int uidState,		@AppOpsManager.OpFlags int flags, @AppOpsManager.UidState int uidState,
	long accessTime, long accessDuration) {		long accessTime, long accessDuration) {
	List<DiscreteOpEvent> attributedOps = getOrCreateDiscreteOpEventsList(		List<DiscreteOpEvent> attributedOps = getOrCreateDiscreteOpEventsList(
	attributionTag);		attributionTag);
	accessTime = accessTime / sDiscreteHistoryQuantization * sDiscreteHistoryQuantization;		accessTime = accessTime / sDiscreteHistoryQuantization * sDiscreteHistoryQuantization;
			accessDuration = accessDuration == -1 ? -1
			: (accessDuration + sDiscreteHistoryQuantization - 1)
			/ sDiscreteHistoryQuantization * sDiscreteHistoryQuantization;

	int nAttributedOps = attributedOps.size();		int nAttributedOps = attributedOps.size();
	int i = nAttributedOps;		int i = nAttributedOps;
	@@ -764,8 +812,7 @@ final class DiscreteRegistry {
	break;		break;
	}		}
	if (previousOp.mOpFlag == flags && previousOp.mUidState == uidState) {		if (previousOp.mOpFlag == flags && previousOp.mUidState == uidState) {
	if (accessDuration != previousOp.mNoteDuration		if (accessDuration != previousOp.mNoteDuration) {
	&& accessDuration > sDiscreteHistoryQuantization) {
	break;		break;
	} else {		} else {
	return;		return;
	@@ -983,5 +1030,9 @@ final class DiscreteRegistry {
	}		}
	return true;		return true;
	}		}

			void setDebugMode(boolean debugMode) {
			this.mDebugMode = debugMode;
			}
	}		}

services/core/java/com/android/server/appop/HistoricalRegistry.java

+6 −0

Original line number	Original line	Diff line number	Diff line
	@@ -553,6 +553,11 @@ final class HistoricalRegistry {
	if (mMode == AppOpsManager.HISTORICAL_MODE_DISABLED) {		if (mMode == AppOpsManager.HISTORICAL_MODE_DISABLED) {
	clearHistoryOnDiskDLocked();		clearHistoryOnDiskDLocked();
	}		}
			if (mMode == AppOpsManager.HISTORICAL_MODE_ENABLED_PASSIVE) {
			mDiscreteRegistry.setDebugMode(true);
			} else {
			mDiscreteRegistry.setDebugMode(false);
			}
	}		}
	if (mBaseSnapshotInterval != baseSnapshotInterval) {		if (mBaseSnapshotInterval != baseSnapshotInterval) {
	mBaseSnapshotInterval = baseSnapshotInterval;		mBaseSnapshotInterval = baseSnapshotInterval;
	@@ -591,6 +596,7 @@ final class HistoricalRegistry {
	mPersistence.persistHistoricalOpsDLocked(history);		mPersistence.persistHistoricalOpsDLocked(history);
	}		}
	}		}
			mDiscreteRegistry.offsetHistory(offsetMillis);
	}		}

	void addHistoricalOps(HistoricalOps ops) {		void addHistoricalOps(HistoricalOps ops) {