Merge changes If00f36da,I995f1647,I226fc2ab (c50ac5df) · Commits · e / os / android_frameworks_base

services/core/java/com/android/server/rollback/AppDataRollbackHelper.java

+53 −125

Original line number	Original line	Diff line number	Diff line
	@@ -23,17 +23,12 @@ import android.util.IntArray;
	import android.util.Slog;		import android.util.Slog;
	import android.util.SparseLongArray;		import android.util.SparseLongArray;

			import com.android.internal.annotations.GuardedBy;
	import com.android.internal.annotations.VisibleForTesting;		import com.android.internal.annotations.VisibleForTesting;
	import com.android.server.pm.Installer;		import com.android.server.pm.Installer;
	import com.android.server.pm.Installer.InstallerException;		import com.android.server.pm.Installer.InstallerException;

	import java.util.ArrayList;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.Iterator;
	import java.util.List;		import java.util.List;
	import java.util.Map;
	import java.util.Set;

	/**		/**
	* Encapsulates the logic for initiating userdata snapshots and rollbacks via installd.		* Encapsulates the logic for initiating userdata snapshots and rollbacks via installd.
	@@ -56,6 +51,8 @@ public class AppDataRollbackHelper {
	* {@code userIds}. Updates said {@code packageRollbackInfo} with the inodes of the CE user data		* {@code userIds}. Updates said {@code packageRollbackInfo} with the inodes of the CE user data
	* snapshot folders.		* snapshot folders.
	*/		*/
			@GuardedBy("rollback.getLock")
			// TODO(b/136241838): Move into Rollback and synchronize there.
	public void snapshotAppData(		public void snapshotAppData(
	int snapshotId, PackageRollbackInfo packageRollbackInfo, int[] userIds) {		int snapshotId, PackageRollbackInfo packageRollbackInfo, int[] userIds) {
	for (int user : userIds) {		for (int user : userIds) {
	@@ -92,6 +89,8 @@ public class AppDataRollbackHelper {
	* to {@code packageRollbackInfo} are restricted to the removal or addition of {@code		* to {@code packageRollbackInfo} are restricted to the removal or addition of {@code
	* userId} to the list of pending backups or restores.		* userId} to the list of pending backups or restores.
	*/		*/
			@GuardedBy("rollback.getLock")
			// TODO(b/136241838): Move into Rollback and synchronize there.
	public boolean restoreAppData(int rollbackId, PackageRollbackInfo packageRollbackInfo,		public boolean restoreAppData(int rollbackId, PackageRollbackInfo packageRollbackInfo,
	int userId, int appId, String seInfo) {		int userId, int appId, String seInfo) {
	int storageFlags = Installer.FLAG_STORAGE_DE;		int storageFlags = Installer.FLAG_STORAGE_DE;
	@@ -135,6 +134,8 @@ public class AppDataRollbackHelper {
	* Deletes an app data snapshot with a given {@code rollbackId} for a specified package		* Deletes an app data snapshot with a given {@code rollbackId} for a specified package
	* {@code packageName} for a given {@code user}.		* {@code packageName} for a given {@code user}.
	*/		*/
			@GuardedBy("rollback.getLock")
			// TODO(b/136241838): Move into Rollback and synchronize there.
	public void destroyAppDataSnapshot(int rollbackId, PackageRollbackInfo packageRollbackInfo,		public void destroyAppDataSnapshot(int rollbackId, PackageRollbackInfo packageRollbackInfo,
	int user) {		int user) {
	int storageFlags = Installer.FLAG_STORAGE_DE;		int storageFlags = Installer.FLAG_STORAGE_DE;
	@@ -156,103 +157,42 @@ public class AppDataRollbackHelper {
	}		}

	/**		/**
	* Computes the list of pending backups for {@code userId} given lists of rollbacks.		* Commits the pending backups and restores for a given {@code userId} and {@code rollback}. If
	* Packages pending backup for the given user are added to {@code pendingBackupPackages} along		* the rollback has a pending backup, it is updated with a mapping from {@code userId} to inode
	* with their corresponding {@code PackageRollbackInfo}.		* of the CE user data snapshot.
	*		*
	* @return the list of rollbacks that have pending backups. Note that some of the		* @return true if any backups or restores were found for the userId
	* backups won't be performed, because they might be counteracted by pending restores.
	*/		*/
	private static List<Rollback> computePendingBackups(int userId,		@GuardedBy("rollback.getLock")
	Map<String, PackageRollbackInfo> pendingBackupPackages,		boolean commitPendingBackupAndRestoreForUser(int userId, Rollback rollback) {
	List<Rollback> rollbacks) {		boolean foundBackupOrRestore = false;
	List<Rollback> rollbacksWithPendingBackups = new ArrayList<>();

	for (Rollback rollback : rollbacks) {
	for (PackageRollbackInfo info : rollback.info.getPackages()) {		for (PackageRollbackInfo info : rollback.info.getPackages()) {
			boolean hasPendingBackup = false;
			boolean hasPendingRestore = false;
	final IntArray pendingBackupUsers = info.getPendingBackups();		final IntArray pendingBackupUsers = info.getPendingBackups();
	if (pendingBackupUsers != null) {		if (pendingBackupUsers != null) {
	final int idx = pendingBackupUsers.indexOf(userId);		if (pendingBackupUsers.indexOf(userId) != -1) {
	if (idx != -1) {		hasPendingBackup = true;
	pendingBackupPackages.put(info.getPackageName(), info);		foundBackupOrRestore = true;
	if (rollbacksWithPendingBackups.indexOf(rollback) == -1) {
	rollbacksWithPendingBackups.add(rollback);
	}
	}
	}
	}		}
	}		}
	return rollbacksWithPendingBackups;
	}

	/**
	* Computes the list of pending restores for {@code userId} given lists of rollbacks.
	* Packages pending restore are added to {@code pendingRestores} along with their corresponding
	* {@code PackageRollbackInfo}.
	*
	* @return the list of rollbacks that have pending restores. Note that some of the
	* restores won't be performed, because they might be counteracted by pending backups.
	*/
	private static List<Rollback> computePendingRestores(int userId,
	Map<String, PackageRollbackInfo> pendingRestorePackages,
	List<Rollback> rollbacks) {
	List<Rollback> rollbacksWithPendingRestores = new ArrayList<>();

	for (Rollback rollback : rollbacks) {		RestoreInfo ri = info.getRestoreInfo(userId);
	for (PackageRollbackInfo info : rollback.info.getPackages()) {
	final RestoreInfo ri = info.getRestoreInfo(userId);
	if (ri != null) {		if (ri != null) {
	pendingRestorePackages.put(info.getPackageName(), info);		hasPendingRestore = true;
	if (rollbacksWithPendingRestores.indexOf(rollback) == -1) {		foundBackupOrRestore = true;
	rollbacksWithPendingRestores.add(rollback);
	}
	}
	}		}
	}

	return rollbacksWithPendingRestores;
	}

	/**
	* Commits the list of pending backups and restores for a given {@code userId}. For rollbacks
	* with pending backups, updates the {@code Rollback} instance with a mapping from
	* {@code userId} to inode of the CE user data snapshot.
	*
	* @return the set of rollbacks with changes that should be stored on disk.
	*/
	public Set<Rollback> commitPendingBackupAndRestoreForUser(int userId,
	List<Rollback> rollbacks) {

	final Map<String, PackageRollbackInfo> pendingBackupPackages = new HashMap<>();
	final List<Rollback> pendingBackups = computePendingBackups(userId,
	pendingBackupPackages, rollbacks);

	final Map<String, PackageRollbackInfo> pendingRestorePackages = new HashMap<>();		if (hasPendingBackup && hasPendingRestore) {
	final List<Rollback> pendingRestores = computePendingRestores(userId,		// Remove unnecessary backup, i.e. when user did not unlock their phone between the
	pendingRestorePackages, rollbacks);

	// First remove unnecessary backups, i.e. when user did not unlock their phone between the
	// request to backup data and the request to restore it.		// request to backup data and the request to restore it.
	Iterator<Map.Entry<String, PackageRollbackInfo>> iter =		info.removePendingBackup(userId);
	pendingBackupPackages.entrySet().iterator();		info.removePendingRestoreInfo(userId);
	while (iter.hasNext()) {		continue;
	PackageRollbackInfo backupPackage = iter.next().getValue();
	PackageRollbackInfo restorePackage =
	pendingRestorePackages.get(backupPackage.getPackageName());
	if (restorePackage != null) {
	backupPackage.removePendingBackup(userId);
	backupPackage.removePendingRestoreInfo(userId);
	iter.remove();
	pendingRestorePackages.remove(backupPackage.getPackageName());
	}
	}		}

	if (!pendingBackupPackages.isEmpty()) {		if (hasPendingBackup) {
	for (Rollback rollback : pendingBackups) {		int idx = pendingBackupUsers.indexOf(userId);
	for (PackageRollbackInfo info : rollback.info.getPackages()) {
	final IntArray pendingBackupUsers = info.getPendingBackups();
	final int idx = pendingBackupUsers.indexOf(userId);
	if (idx != -1) {
	try {		try {
	long ceSnapshotInode = mInstaller.snapshotAppData(info.getPackageName(),		long ceSnapshotInode = mInstaller.snapshotAppData(info.getPackageName(),
	userId, rollback.info.getRollbackId(),		userId, rollback.info.getRollbackId(),
	@@ -265,15 +205,8 @@ public class AppDataRollbackHelper {
	+ info.getPackageName() + ", userId: " + userId, ie);		+ info.getPackageName() + ", userId: " + userId, ie);
	}		}
	}		}
	}
	}
	}

	if (!pendingRestorePackages.isEmpty()) {		if (hasPendingRestore) {
	for (Rollback rollback : pendingRestores) {
	for (PackageRollbackInfo info : rollback.info.getPackages()) {
	final RestoreInfo ri = info.getRestoreInfo(userId);
	if (ri != null) {
	try {		try {
	mInstaller.restoreAppDataSnapshot(info.getPackageName(), ri.appId,		mInstaller.restoreAppDataSnapshot(info.getPackageName(), ri.appId,
	ri.seInfo, userId, rollback.info.getRollbackId(),		ri.seInfo, userId, rollback.info.getRollbackId(),
	@@ -285,12 +218,7 @@ public class AppDataRollbackHelper {
	}		}
	}		}
	}		}
	}		return foundBackupOrRestore;
	}

	final Set<Rollback> changed = new HashSet<>(pendingBackups);
	changed.addAll(pendingRestores);
	return changed;
	}		}

	/**		/**

services/core/java/com/android/server/rollback/Rollback.java

+112 −9

Original line number	Original line	Diff line number	Diff line
	@@ -18,19 +18,27 @@ package com.android.server.rollback;

	import android.annotation.IntDef;		import android.annotation.IntDef;
	import android.annotation.NonNull;		import android.annotation.NonNull;
			import android.content.rollback.PackageRollbackInfo;
	import android.content.rollback.RollbackInfo;		import android.content.rollback.RollbackInfo;

			import com.android.internal.annotations.GuardedBy;

	import java.io.File;		import java.io.File;
	import java.lang.annotation.Retention;		import java.lang.annotation.Retention;
	import java.lang.annotation.RetentionPolicy;		import java.lang.annotation.RetentionPolicy;
	import java.text.ParseException;		import java.text.ParseException;
	import java.time.Instant;		import java.time.Instant;
	import java.util.ArrayList;		import java.util.ArrayList;
			import java.util.List;


	/**		/**
	* Information about a rollback available for a set of atomically installed		* Information about a rollback available for a set of atomically installed packages.
	* packages.		*
			* <p>When accessing the state of a Rollback object, the caller is responsible for synchronization.
			* The lock object provided by {@link #getLock} should be acquired when accessing any of the mutable
			* state of a Rollback, including from the {@link RollbackInfo} and any of the
			* {@link PackageRollbackInfo} objects held within.
	*/		*/
	class Rollback {		class Rollback {
	@IntDef(flag = true, prefix = { "ROLLBACK_STATE_" }, value = {		@IntDef(flag = true, prefix = { "ROLLBACK_STATE_" }, value = {
	@@ -57,9 +65,19 @@ class Rollback {
	*/		*/
	static final int ROLLBACK_STATE_COMMITTED = 3;		static final int ROLLBACK_STATE_COMMITTED = 3;

			/**
			* The session ID for the staged session if this rollback data represents a staged session,
			* {@code -1} otherwise.
			*/
			private final int mStagedSessionId;

	/**		/**
	* The rollback info for this rollback.		* The rollback info for this rollback.
			*
			* <p>Any access to this field that touches any mutable state should be synchronized on
			* {@link #getLock}.
	*/		*/
			@GuardedBy("getLock")
	public final RollbackInfo info;		public final RollbackInfo info;

	/**		/**
	@@ -74,23 +92,20 @@ class Rollback {
	* The timestamp is not applicable for all rollback states, but we make		* The timestamp is not applicable for all rollback states, but we make
	* sure to keep it non-null to avoid potential errors there.		* sure to keep it non-null to avoid potential errors there.
	*/		*/
			@GuardedBy("mLock")
	private @NonNull Instant mTimestamp;		private @NonNull Instant mTimestamp;

	/**
	* The session ID for the staged session if this rollback data represents a staged session,
	* {@code -1} otherwise.
	*/
	private final int mStagedSessionId;

	/**		/**
	* The current state of the rollback.		* The current state of the rollback.
	* ENABLING, AVAILABLE, or COMMITTED.		* ENABLING, AVAILABLE, or COMMITTED.
	*/		*/
			@GuardedBy("mLock")
	private @RollbackState int mState;		private @RollbackState int mState;

	/**		/**
	* The id of the post-reboot apk session for a staged install, if any.		* The id of the post-reboot apk session for a staged install, if any.
	*/		*/
			@GuardedBy("mLock")
	private int mApkSessionId = -1;		private int mApkSessionId = -1;

	/**		/**
	@@ -98,9 +113,16 @@ class Rollback {
	* for this rollback because it has just been committed but the rollback		* for this rollback because it has just been committed but the rollback
	* has not yet been fully applied.		* has not yet been fully applied.
	*/		*/
	// NOTE: All accesses to this field are from the RollbackManager handler thread.		@GuardedBy("mLock")
	private boolean mRestoreUserDataInProgress = false;		private boolean mRestoreUserDataInProgress = false;

			/**
			* Lock object to guard all access to Rollback state.
			*
			* @see #getLock
			*/
			private final Object mLock = new Object();

	/**		/**
	* Constructs a new, empty Rollback instance.		* Constructs a new, empty Rollback instance.
	*		*
	@@ -134,9 +156,24 @@ class Rollback {
	mRestoreUserDataInProgress = restoreUserDataInProgress;		mRestoreUserDataInProgress = restoreUserDataInProgress;
	}		}

			/**
			* Returns a lock object that should be acquired before accessing any Rollback state from
			* {@link RollbackManagerServiceImpl}.
			*
			* <p>Note that while holding this lock, the lock for {@link RollbackManagerServiceImpl} should
			* not be acquired (but it is ok to acquire this lock while already holding the lock for that
			* class).
			*/
			// TODO(b/136241838): Move rollback functionality into this class and synchronize on the lock
			// internally. Remove this method once this has been done for all cases.
			Object getLock() {
			return mLock;
			}

	/**		/**
	* Whether the rollback is for rollback of a staged install.		* Whether the rollback is for rollback of a staged install.
	*/		*/
			@GuardedBy("getLock")
	boolean isStaged() {		boolean isStaged() {
	return info.isStaged();		return info.isStaged();
	}		}
	@@ -151,6 +188,7 @@ class Rollback {
	/**		/**
	* Returns the time when the upgrade occurred, for purposes of expiring rollback data.		* Returns the time when the upgrade occurred, for purposes of expiring rollback data.
	*/		*/
			@GuardedBy("getLock")
	Instant getTimestamp() {		Instant getTimestamp() {
	return mTimestamp;		return mTimestamp;
	}		}
	@@ -158,6 +196,7 @@ class Rollback {
	/**		/**
	* Sets the time at which upgrade occurred.		* Sets the time at which upgrade occurred.
	*/		*/
			@GuardedBy("getLock")
	void setTimestamp(Instant timestamp) {		void setTimestamp(Instant timestamp) {
	mTimestamp = timestamp;		mTimestamp = timestamp;
	}		}
	@@ -173,6 +212,7 @@ class Rollback {
	/**		/**
	* Returns true if the rollback is in the ENABLING state.		* Returns true if the rollback is in the ENABLING state.
	*/		*/
			@GuardedBy("getLock")
	boolean isEnabling() {		boolean isEnabling() {
	return mState == ROLLBACK_STATE_ENABLING;		return mState == ROLLBACK_STATE_ENABLING;
	}		}
	@@ -180,6 +220,7 @@ class Rollback {
	/**		/**
	* Returns true if the rollback is in the AVAILABLE state.		* Returns true if the rollback is in the AVAILABLE state.
	*/		*/
			@GuardedBy("getLock")
	boolean isAvailable() {		boolean isAvailable() {
	return mState == ROLLBACK_STATE_AVAILABLE;		return mState == ROLLBACK_STATE_AVAILABLE;
	}		}
	@@ -187,6 +228,7 @@ class Rollback {
	/**		/**
	* Returns true if the rollback is in the COMMITTED state.		* Returns true if the rollback is in the COMMITTED state.
	*/		*/
			@GuardedBy("getLock")
	boolean isCommitted() {		boolean isCommitted() {
	return mState == ROLLBACK_STATE_COMMITTED;		return mState == ROLLBACK_STATE_COMMITTED;
	}		}
	@@ -194,6 +236,7 @@ class Rollback {
	/**		/**
	* Sets the state of the rollback to AVAILABLE.		* Sets the state of the rollback to AVAILABLE.
	*/		*/
			@GuardedBy("getLock")
	void setAvailable() {		void setAvailable() {
	mState = ROLLBACK_STATE_AVAILABLE;		mState = ROLLBACK_STATE_AVAILABLE;
	}		}
	@@ -201,6 +244,7 @@ class Rollback {
	/**		/**
	* Sets the state of the rollback to COMMITTED.		* Sets the state of the rollback to COMMITTED.
	*/		*/
			@GuardedBy("getLock")
	void setCommitted() {		void setCommitted() {
	mState = ROLLBACK_STATE_COMMITTED;		mState = ROLLBACK_STATE_COMMITTED;
	}		}
	@@ -208,6 +252,7 @@ class Rollback {
	/**		/**
	* Returns the id of the post-reboot apk session for a staged install, if any.		* Returns the id of the post-reboot apk session for a staged install, if any.
	*/		*/
			@GuardedBy("getLock")
	int getApkSessionId() {		int getApkSessionId() {
	return mApkSessionId;		return mApkSessionId;
	}		}
	@@ -215,6 +260,7 @@ class Rollback {
	/**		/**
	* Sets the id of the post-reboot apk session for a staged install.		* Sets the id of the post-reboot apk session for a staged install.
	*/		*/
			@GuardedBy("getLock")
	void setApkSessionId(int apkSessionId) {		void setApkSessionId(int apkSessionId) {
	mApkSessionId = apkSessionId;		mApkSessionId = apkSessionId;
	}		}
	@@ -223,6 +269,7 @@ class Rollback {
	* Returns true if we are expecting the package manager to call restoreUserData for this		* Returns true if we are expecting the package manager to call restoreUserData for this
	* rollback because it has just been committed but the rollback has not yet been fully applied.		* rollback because it has just been committed but the rollback has not yet been fully applied.
	*/		*/
			@GuardedBy("getLock")
	boolean isRestoreUserDataInProgress() {		boolean isRestoreUserDataInProgress() {
	return mRestoreUserDataInProgress;		return mRestoreUserDataInProgress;
	}		}
	@@ -231,10 +278,65 @@ class Rollback {
	* Sets whether we are expecting the package manager to call restoreUserData for this		* Sets whether we are expecting the package manager to call restoreUserData for this
	* rollback because it has just been committed but the rollback has not yet been fully applied.		* rollback because it has just been committed but the rollback has not yet been fully applied.
	*/		*/
			@GuardedBy("getLock")
	void setRestoreUserDataInProgress(boolean restoreUserDataInProgress) {		void setRestoreUserDataInProgress(boolean restoreUserDataInProgress) {
	mRestoreUserDataInProgress = restoreUserDataInProgress;		mRestoreUserDataInProgress = restoreUserDataInProgress;
	}		}

			/**
			* Returns true if this rollback includes the package with the provided {@code packageName}.
			*/
			@GuardedBy("getLock")
			boolean includesPackage(String packageName) {
			for (PackageRollbackInfo info : info.getPackages()) {
			if (info.getPackageName().equals(packageName)) {
			return true;
			}
			}
			return false;
			}

			/**
			* Returns true if this rollback includes the package with the provided {@code packageName}
			* with a <i>version rolled back from</i> that is not {@code versionCode}.
			*/
			@GuardedBy("getLock")
			boolean includesPackageWithDifferentVersion(String packageName, long versionCode) {
			for (PackageRollbackInfo info : info.getPackages()) {
			if (info.getPackageName().equals(packageName)
			&& info.getVersionRolledBackFrom().getLongVersionCode() != versionCode) {
			return true;
			}
			}
			return false;
			}

			/**
			* Returns a list containing the names of all the packages included in this rollback.
			*/
			@GuardedBy("getLock")
			List<String> getPackageNames() {
			List<String> result = new ArrayList<>();
			for (PackageRollbackInfo info : info.getPackages()) {
			result.add(info.getPackageName());
			}
			return result;
			}

			/**
			* Returns a list containing the names of all the apex packages included in this rollback.
			*/
			@GuardedBy("getLock")
			List<String> getApexPackageNames() {
			List<String> result = new ArrayList<>();
			for (PackageRollbackInfo info : info.getPackages()) {
			if (info.isApex()) {
			result.add(info.getPackageName());
			}
			}
			return result;
			}

	static String rollbackStateToString(@RollbackState int state) {		static String rollbackStateToString(@RollbackState int state) {
	switch (state) {		switch (state) {
	case Rollback.ROLLBACK_STATE_ENABLING: return "enabling";		case Rollback.ROLLBACK_STATE_ENABLING: return "enabling";
	@@ -254,6 +356,7 @@ class Rollback {
	throw new ParseException("Invalid rollback state: " + state, 0);		throw new ParseException("Invalid rollback state: " + state, 0);
	}		}

			@GuardedBy("getLock")
	String getStateAsString() {		String getStateAsString() {
	return rollbackStateToString(mState);		return rollbackStateToString(mState);
	}		}