Merge changes Ic4011b8e,I641bb381 into main (977dfc3e) · Commits · e / os / android_frameworks_base

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

+134 −111

Original line number	Diff line number	Diff line
		@@ -166,7 +166,6 @@ import com.android.modules.utils.TypedXmlSerializer;
		import com.android.server.LocalManagerRegistry;
		import com.android.server.LocalServices;
		import com.android.server.LockGuard;
		import com.android.server.SystemServerInitThreadPool;
		import com.android.server.SystemServiceManager;
		import com.android.server.companion.virtual.VirtualDeviceManagerInternal;
		import com.android.server.pm.PackageList;
		@@ -1038,7 +1037,7 @@ public class AppOpsService extends IAppOpsService.Stub {
		new Ops(pkgName, uidState));
		}

		createSandboxUidStateIfNotExistsForAppLocked(uid);
		createSandboxUidStateIfNotExistsForAppLocked(uid, null);
		}
		} else if (action.equals(ACTION_PACKAGE_REMOVED) && !intent.hasExtra(EXTRA_REPLACING)) {
		synchronized (AppOpsService.this) {
		@@ -1050,69 +1049,8 @@ public class AppOpsService extends IAppOpsService.Stub {
		return;
		}

		ArrayMap<String, String> dstAttributionTags = new ArrayMap<>();
		ArraySet<String> attributionTags = new ArraySet<>();
		attributionTags.add(null);
		if (pkg.getAttributions() != null) {
		int numAttributions = pkg.getAttributions().size();
		for (int attributionNum = 0; attributionNum < numAttributions;
		attributionNum++) {
		ParsedAttribution attribution = pkg.getAttributions().get(attributionNum);
		attributionTags.add(attribution.getTag());

		int numInheritFrom = attribution.getInheritFrom().size();
		for (int inheritFromNum = 0; inheritFromNum < numInheritFrom;
		inheritFromNum++) {
		dstAttributionTags.put(attribution.getInheritFrom().get(inheritFromNum),
		attribution.getTag());
		}
		}
		}

		synchronized (AppOpsService.this) {
		UidState uidState = mUidStates.get(uid);
		if (uidState == null) {
		return;
		}

		Ops ops = uidState.pkgOps.get(pkgName);
		if (ops == null) {
		return;
		}

		// Reset cached package properties to re-initialize when needed
		ops.bypass = null;
		ops.knownAttributionTags.clear();

		// Merge data collected for removed attributions into their successor
		// attributions
		int numOps = ops.size();
		for (int opNum = 0; opNum < numOps; opNum++) {
		Op op = ops.valueAt(opNum);
		for (int deviceIndex = op.mDeviceAttributedOps.size() - 1; deviceIndex >= 0;
		deviceIndex--) {
		ArrayMap<String, AttributedOp> attributedOps =
		op.mDeviceAttributedOps.valueAt(deviceIndex);
		for (int tagIndex = attributedOps.size() - 1; tagIndex >= 0;
		tagIndex--) {
		String tag = attributedOps.keyAt(tagIndex);
		if (attributionTags.contains(tag)) {
		// attribution still exist after upgrade
		continue;
		}

		String newAttributionTag = dstAttributionTags.get(tag);

		AttributedOp newAttributedOp = op.getOrCreateAttribution(op,
		newAttributionTag,
		op.mDeviceAttributedOps.keyAt(deviceIndex));
		newAttributedOp.add(attributedOps.get(tag));
		attributedOps.remove(tag);

		scheduleFastWriteLocked();
		}
		}
		}
		refreshAttributionsLocked(pkg, uid);
		}
		}
		}
		@@ -1136,41 +1074,6 @@ public class AppOpsService extends IAppOpsService.Stub {
		mContext.registerReceiverAsUser(mOnPackageUpdatedReceiver, UserHandle.ALL,
		packageUpdateFilter, null, null);

		synchronized (this) {
		for (int uidNum = mUidStates.size() - 1; uidNum >= 0; uidNum--) {
		int uid = mUidStates.keyAt(uidNum);
		UidState uidState = mUidStates.valueAt(uidNum);

		String[] pkgsInUid = getPackagesForUid(uidState.uid);
		if (ArrayUtils.isEmpty(pkgsInUid) && uid >= Process.FIRST_APPLICATION_UID) {
		uidState.clear();
		mUidStates.removeAt(uidNum);
		scheduleFastWriteLocked();
		continue;
		}

		ArrayMap<String, Ops> pkgs = uidState.pkgOps;

		int numPkgs = pkgs.size();
		for (int pkgNum = 0; pkgNum < numPkgs; pkgNum++) {
		String pkg = pkgs.keyAt(pkgNum);

		String action;
		if (!ArrayUtils.contains(pkgsInUid, pkg)) {
		action = ACTION_PACKAGE_REMOVED;
		} else {
		action = Intent.ACTION_PACKAGE_REPLACED;
		}

		SystemServerInitThreadPool.submit(
		() -> mOnPackageUpdatedReceiver.onReceive(mContext, new Intent(action)
		.setData(Uri.fromParts("package", pkg, null))
		.putExtra(Intent.EXTRA_UID, uid)),
		"Update app-ops uidState in case package " + pkg + " changed");
		}
		}
		}

		prepareInternalCallbacks();

		final IntentFilter packageSuspendFilter = new IntentFilter();
		@@ -1258,47 +1161,62 @@ public class AppOpsService extends IAppOpsService.Stub {
		void initializeUidStates() {
		UserManagerInternal umi = getUserManagerInternal();
		synchronized (this) {
		SparseBooleanArray knownUids = new SparseBooleanArray();

		for (int uid : NON_PACKAGE_UIDS) {
		if (!mUidStates.contains(uid)) {
		mUidStates.put(uid, new UidState(uid));
		}
		knownUids.put(uid, true);
		}

		int[] userIds = umi.getUserIds();
		try (PackageManagerLocal.UnfilteredSnapshot snapshot =
		getPackageManagerLocal().withUnfilteredSnapshot()) {
		Map<String, PackageState> packageStates = snapshot.getPackageStates();
		for (int i = 0; i < userIds.length; i++) {
		int userId = userIds[i];
		initializeUserUidStatesLocked(userId, packageStates);
		}
		initializeUserUidStatesLocked(userId, packageStates, knownUids);
		}

		for (int uid : NON_PACKAGE_UIDS) {
		mUidStates.put(uid, new UidState(uid));
		}
		trimUidStatesLocked(knownUids, packageStates);
		mUidStatesInitialized = true;
		}
		}
		}

		private void initializeUserUidStates(int userId) {
		synchronized (this) {
		try (PackageManagerLocal.UnfilteredSnapshot snapshot =
		getPackageManagerLocal().withUnfilteredSnapshot()) {
		initializeUserUidStatesLocked(userId, snapshot.getPackageStates());
		initializeUserUidStatesLocked(userId, snapshot.getPackageStates(), null);
		}
		}
		}

		private void initializeUserUidStatesLocked(int userId, Map<String,
		PackageState> packageStates) {
		PackageState> packageStates, SparseBooleanArray knownUids) {
		for (Map.Entry<String, PackageState> entry : packageStates.entrySet()) {
		int appId = entry.getValue().getAppId();
		PackageState packageState = entry.getValue();
		if (packageState.isApex()) {
		continue;
		}
		int appId = packageState.getAppId();
		String packageName = entry.getKey();

		initializePackageUidStateLocked(userId, appId, packageName);
		initializePackageUidStateLocked(userId, appId, packageName, knownUids);
		}
		}

		/*
		Be careful not to clear any existing data; only want to add objects that don't already exist.
		*/
		private void initializePackageUidStateLocked(int userId, int appId, String packageName) {
		private void initializePackageUidStateLocked(int userId, int appId, String packageName,
		SparseBooleanArray knownUids) {
		int uid = UserHandle.getUid(userId, appId);
		if (knownUids != null) {
		knownUids.put(uid, true);
		}
		UidState uidState = getUidStateLocked(uid, true);
		Ops ops = uidState.pkgOps.get(packageName);
		if (ops == null) {
		@@ -1316,7 +1234,105 @@ public class AppOpsService extends IAppOpsService.Stub {
		}
		}

		createSandboxUidStateIfNotExistsForAppLocked(uid);
		createSandboxUidStateIfNotExistsForAppLocked(uid, knownUids);
		}

		private void trimUidStatesLocked(SparseBooleanArray knownUids,
		Map<String, PackageState> packageStates) {
		synchronized (this) {
		// Remove what may have been added during persistence parsing
		for (int i = mUidStates.size() - 1; i >= 0; i--) {
		int uid = mUidStates.keyAt(i);
		if (knownUids.get(uid, false)) {
		if (uid >= Process.FIRST_APPLICATION_UID) {
		ArrayMap<String, Ops> pkgOps = mUidStates.valueAt(i).pkgOps;
		for (int j = 0; j < pkgOps.size(); j++) {
		String pkgName = pkgOps.keyAt(j);
		if (!packageStates.containsKey(pkgName)) {
		pkgOps.removeAt(j);
		continue;
		}
		AndroidPackage pkg = packageStates.get(pkgName).getAndroidPackage();
		if (pkg != null) {
		refreshAttributionsLocked(pkg, uid);
		}
		}
		if (pkgOps.isEmpty()) {
		mUidStates.remove(i);
		}
		}
		} else {
		mUidStates.removeAt(i);
		}
		}
		}
		}

		@GuardedBy("this")
		private void refreshAttributionsLocked(AndroidPackage pkg, int uid) {
		String pkgName = pkg.getPackageName();
		ArrayMap<String, String> dstAttributionTags = new ArrayMap<>();
		ArraySet<String> attributionTags = new ArraySet<>();
		attributionTags.add(null);
		if (pkg.getAttributions() != null) {
		int numAttributions = pkg.getAttributions().size();
		for (int attributionNum = 0; attributionNum < numAttributions;
		attributionNum++) {
		ParsedAttribution attribution = pkg.getAttributions().get(attributionNum);
		attributionTags.add(attribution.getTag());

		int numInheritFrom = attribution.getInheritFrom().size();
		for (int inheritFromNum = 0; inheritFromNum < numInheritFrom;
		inheritFromNum++) {
		dstAttributionTags.put(attribution.getInheritFrom().get(inheritFromNum),
		attribution.getTag());
		}
		}
		}

		UidState uidState = mUidStates.get(uid);
		if (uidState == null) {
		return;
		}

		Ops ops = uidState.pkgOps.get(pkgName);
		if (ops == null) {
		return;
		}

		// Reset cached package properties to re-initialize when needed
		ops.bypass = null;
		ops.knownAttributionTags.clear();

		// Merge data collected for removed attributions into their successor
		// attributions
		int numOps = ops.size();
		for (int opNum = 0; opNum < numOps; opNum++) {
		Op op = ops.valueAt(opNum);
		for (int deviceIndex = op.mDeviceAttributedOps.size() - 1; deviceIndex >= 0;
		deviceIndex--) {
		ArrayMap<String, AttributedOp> attributedOps =
		op.mDeviceAttributedOps.valueAt(deviceIndex);
		for (int tagIndex = attributedOps.size() - 1; tagIndex >= 0;
		tagIndex--) {
		String tag = attributedOps.keyAt(tagIndex);
		if (attributionTags.contains(tag)) {
		// attribution still exist after upgrade
		continue;
		}

		String newAttributionTag = dstAttributionTags.get(tag);

		AttributedOp newAttributedOp = op.getOrCreateAttribution(op,
		newAttributionTag,
		op.mDeviceAttributedOps.keyAt(deviceIndex));
		newAttributedOp.add(attributedOps.get(tag));
		attributedOps.remove(tag);

		scheduleFastWriteLocked();
		}
		}
		}
		}

		/**
		@@ -4251,8 +4267,15 @@ public class AppOpsService extends IAppOpsService.Stub {
		return uidState;
		}

		private void createSandboxUidStateIfNotExistsForAppLocked(int uid) {
		private void createSandboxUidStateIfNotExistsForAppLocked(int uid,
		SparseBooleanArray knownUids) {
		if (UserHandle.getAppId(uid) < Process.FIRST_APPLICATION_UID) {
		return;
		}
		final int sandboxUid = Process.toSdkSandboxUid(uid);
		if (knownUids != null) {
		knownUids.put(sandboxUid, true);
		}
		getUidStateLocked(sandboxUid, true);
		}