Zimuzo | c4073cc | 2019-01-18 18:39:18 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2019 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
| 17 | package com.android.server.rollback; |
| 18 | |
Zimuzo | ff99176 | 2019-02-01 19:25:44 +0000 | [diff] [blame] | 19 | import android.content.BroadcastReceiver; |
Zimuzo | c4073cc | 2019-01-18 18:39:18 +0000 | [diff] [blame] | 20 | import android.content.Context; |
| 21 | import android.content.Intent; |
Zimuzo | ff99176 | 2019-02-01 19:25:44 +0000 | [diff] [blame] | 22 | import android.content.IntentFilter; |
| 23 | import android.content.pm.PackageInstaller; |
Zimuzo | 03eeb13 | 2019-01-30 15:13:56 +0000 | [diff] [blame] | 24 | import android.content.pm.PackageManager; |
Zimuzo | c119780 | 2019-01-30 12:05:41 +0000 | [diff] [blame] | 25 | import android.content.pm.VersionedPackage; |
Richard Uhler | 0e96192 | 2019-01-25 13:07:08 +0000 | [diff] [blame] | 26 | import android.content.rollback.PackageRollbackInfo; |
Zimuzo | c4073cc | 2019-01-18 18:39:18 +0000 | [diff] [blame] | 27 | import android.content.rollback.RollbackInfo; |
| 28 | import android.content.rollback.RollbackManager; |
| 29 | import android.os.Handler; |
| 30 | import android.os.HandlerThread; |
Zimuzo | ff99176 | 2019-02-01 19:25:44 +0000 | [diff] [blame] | 31 | import android.os.PowerManager; |
Zimuzo | 03eeb13 | 2019-01-30 15:13:56 +0000 | [diff] [blame] | 32 | import android.text.TextUtils; |
Zimuzo | 9e57ecb | 2019-02-04 15:34:08 +0000 | [diff] [blame] | 33 | import android.util.Pair; |
Zimuzo | 03eeb13 | 2019-01-30 15:13:56 +0000 | [diff] [blame] | 34 | import android.util.Slog; |
| 35 | import android.util.StatsLog; |
Zimuzo | c4073cc | 2019-01-18 18:39:18 +0000 | [diff] [blame] | 36 | |
Zimuzo | 03eeb13 | 2019-01-30 15:13:56 +0000 | [diff] [blame] | 37 | import com.android.internal.R; |
Zimuzo | c4073cc | 2019-01-18 18:39:18 +0000 | [diff] [blame] | 38 | import com.android.server.PackageWatchdog; |
| 39 | import com.android.server.PackageWatchdog.PackageHealthObserver; |
Zimuzo | e5009cd | 2019-01-23 18:11:58 +0000 | [diff] [blame] | 40 | import com.android.server.PackageWatchdog.PackageHealthObserverImpact; |
Zimuzo | c4073cc | 2019-01-18 18:39:18 +0000 | [diff] [blame] | 41 | |
Richard Uhler | bf5b5c4 | 2019-01-28 15:26:37 +0000 | [diff] [blame] | 42 | import java.util.Collections; |
Zimuzo | c4073cc | 2019-01-18 18:39:18 +0000 | [diff] [blame] | 43 | import java.util.List; |
| 44 | |
| 45 | /** |
| 46 | * {@code PackageHealthObserver} for {@code RollbackManagerService}. |
| 47 | * |
| 48 | * @hide |
| 49 | */ |
| 50 | public final class RollbackPackageHealthObserver implements PackageHealthObserver { |
| 51 | private static final String TAG = "RollbackPackageHealthObserver"; |
| 52 | private static final String NAME = "rollback-observer"; |
| 53 | private Context mContext; |
| 54 | private Handler mHandler; |
| 55 | |
| 56 | RollbackPackageHealthObserver(Context context) { |
| 57 | mContext = context; |
| 58 | HandlerThread handlerThread = new HandlerThread("RollbackPackageHealthObserver"); |
| 59 | handlerThread.start(); |
| 60 | mHandler = handlerThread.getThreadHandler(); |
| 61 | PackageWatchdog.getInstance(mContext).registerHealthObserver(this); |
| 62 | } |
| 63 | |
| 64 | @Override |
Zimuzo | 71d931e | 2019-02-01 13:08:16 +0000 | [diff] [blame] | 65 | public int onHealthCheckFailed(VersionedPackage failedPackage) { |
Zimuzo | 03eeb13 | 2019-01-30 15:13:56 +0000 | [diff] [blame] | 66 | VersionedPackage moduleMetadataPackage = getModuleMetadataPackage(); |
| 67 | if (moduleMetadataPackage == null) { |
| 68 | // Ignore failure, no mainline update available |
| 69 | return PackageHealthObserverImpact.USER_IMPACT_NONE; |
| 70 | } |
| 71 | |
Zimuzo | 9e57ecb | 2019-02-04 15:34:08 +0000 | [diff] [blame] | 72 | if (getAvailableRollback(mContext.getSystemService(RollbackManager.class), |
| 73 | failedPackage, moduleMetadataPackage) == null) { |
Zimuzo | e5009cd | 2019-01-23 18:11:58 +0000 | [diff] [blame] | 74 | // Don't handle the notification, no rollbacks available for the package |
| 75 | return PackageHealthObserverImpact.USER_IMPACT_NONE; |
Zimuzo | c4073cc | 2019-01-18 18:39:18 +0000 | [diff] [blame] | 76 | } |
Zimuzo | e5009cd | 2019-01-23 18:11:58 +0000 | [diff] [blame] | 77 | // Rollback is available, we may get a callback into #execute |
| 78 | return PackageHealthObserverImpact.USER_IMPACT_MEDIUM; |
| 79 | } |
| 80 | |
| 81 | @Override |
Zimuzo | 71d931e | 2019-02-01 13:08:16 +0000 | [diff] [blame] | 82 | public boolean execute(VersionedPackage failedPackage) { |
Zimuzo | 03eeb13 | 2019-01-30 15:13:56 +0000 | [diff] [blame] | 83 | VersionedPackage moduleMetadataPackage = getModuleMetadataPackage(); |
| 84 | if (moduleMetadataPackage == null) { |
| 85 | // Ignore failure, no mainline update available |
Zimuzo | e5009cd | 2019-01-23 18:11:58 +0000 | [diff] [blame] | 86 | return false; |
| 87 | } |
| 88 | |
Zimuzo | 03eeb13 | 2019-01-30 15:13:56 +0000 | [diff] [blame] | 89 | RollbackManager rollbackManager = mContext.getSystemService(RollbackManager.class); |
Zimuzo | 9e57ecb | 2019-02-04 15:34:08 +0000 | [diff] [blame] | 90 | Pair<RollbackInfo, Boolean> rollbackPair = getAvailableRollback(rollbackManager, |
Zimuzo | 71d931e | 2019-02-01 13:08:16 +0000 | [diff] [blame] | 91 | failedPackage, moduleMetadataPackage); |
Zimuzo | 9e57ecb | 2019-02-04 15:34:08 +0000 | [diff] [blame] | 92 | if (rollbackPair == null) { |
| 93 | Slog.w(TAG, "Expected rollback but no valid rollback found for package: [ " |
Zimuzo | 71d931e | 2019-02-01 13:08:16 +0000 | [diff] [blame] | 94 | + failedPackage.getPackageName() + "] with versionCode: [" |
| 95 | + failedPackage.getVersionCode() + "]"); |
Zimuzo | 03eeb13 | 2019-01-30 15:13:56 +0000 | [diff] [blame] | 96 | return false; |
| 97 | } |
Zimuzo | ff99176 | 2019-02-01 19:25:44 +0000 | [diff] [blame] | 98 | |
Zimuzo | 9e57ecb | 2019-02-04 15:34:08 +0000 | [diff] [blame] | 99 | RollbackInfo rollback = rollbackPair.first; |
| 100 | // We only log mainline package rollbacks, so check if rollback contains the |
| 101 | // module metadata provider, if it does, the rollback is a mainline rollback |
| 102 | boolean hasModuleMetadataPackage = rollbackPair.second; |
Zimuzo | 03eeb13 | 2019-01-30 15:13:56 +0000 | [diff] [blame] | 103 | |
Zimuzo | 9e57ecb | 2019-02-04 15:34:08 +0000 | [diff] [blame] | 104 | if (hasModuleMetadataPackage) { |
| 105 | StatsLog.write(StatsLog.WATCHDOG_ROLLBACK_OCCURRED, |
| 106 | StatsLog.WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_TYPE__ROLLBACK_INITIATE, |
| 107 | moduleMetadataPackage.getPackageName(), |
| 108 | moduleMetadataPackage.getVersionCode()); |
| 109 | } |
Zimuzo | e5009cd | 2019-01-23 18:11:58 +0000 | [diff] [blame] | 110 | LocalIntentReceiver rollbackReceiver = new LocalIntentReceiver((Intent result) -> { |
Zimuzo | 9e57ecb | 2019-02-04 15:34:08 +0000 | [diff] [blame] | 111 | if (hasModuleMetadataPackage) { |
| 112 | int status = result.getIntExtra(RollbackManager.EXTRA_STATUS, |
| 113 | RollbackManager.STATUS_FAILURE); |
| 114 | if (status == RollbackManager.STATUS_SUCCESS) { |
| 115 | StatsLog.write(StatsLog.WATCHDOG_ROLLBACK_OCCURRED, |
| 116 | StatsLog.WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_TYPE__ROLLBACK_SUCCESS, |
| 117 | moduleMetadataPackage.getPackageName(), |
| 118 | moduleMetadataPackage.getVersionCode()); |
Zimuzo | ff99176 | 2019-02-01 19:25:44 +0000 | [diff] [blame] | 119 | if (rollback.isStaged()) { |
| 120 | int rollbackId = rollback.getRollbackId(); |
| 121 | BroadcastReceiver listener = |
| 122 | listenForStagedSessionReady(rollbackManager, rollbackId); |
| 123 | handleStagedSessionChange(rollbackManager, rollbackId, listener); |
| 124 | } |
Zimuzo | 9e57ecb | 2019-02-04 15:34:08 +0000 | [diff] [blame] | 125 | } else { |
| 126 | StatsLog.write(StatsLog.WATCHDOG_ROLLBACK_OCCURRED, |
| 127 | StatsLog.WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_TYPE__ROLLBACK_FAILURE, |
| 128 | moduleMetadataPackage.getPackageName(), |
| 129 | moduleMetadataPackage.getVersionCode()); |
| 130 | } |
Zimuzo | e5009cd | 2019-01-23 18:11:58 +0000 | [diff] [blame] | 131 | } |
| 132 | }); |
| 133 | |
Zimuzo | e5009cd | 2019-01-23 18:11:58 +0000 | [diff] [blame] | 134 | mHandler.post(() -> |
Zimuzo | c119780 | 2019-01-30 12:05:41 +0000 | [diff] [blame] | 135 | rollbackManager.commitRollback(rollback.getRollbackId(), |
Zimuzo | 9e57ecb | 2019-02-04 15:34:08 +0000 | [diff] [blame] | 136 | Collections.singletonList(failedPackage), |
Richard Uhler | e87368e | 2019-01-24 16:34:14 +0000 | [diff] [blame] | 137 | rollbackReceiver.getIntentSender())); |
Zimuzo | e5009cd | 2019-01-23 18:11:58 +0000 | [diff] [blame] | 138 | // Assume rollback executed successfully |
| 139 | return true; |
| 140 | } |
| 141 | |
| 142 | @Override |
| 143 | public String getName() { |
| 144 | return NAME; |
Zimuzo | c4073cc | 2019-01-18 18:39:18 +0000 | [diff] [blame] | 145 | } |
| 146 | |
| 147 | /** |
| 148 | * Start observing health of {@code packages} for {@code durationMs}. |
| 149 | * This may cause {@code packages} to be rolled back if they crash too freqeuntly. |
| 150 | */ |
| 151 | public void startObservingHealth(List<String> packages, long durationMs) { |
| 152 | PackageWatchdog.getInstance(mContext).startObservingHealth(this, packages, durationMs); |
| 153 | } |
| 154 | |
Zimuzo | 9e57ecb | 2019-02-04 15:34:08 +0000 | [diff] [blame] | 155 | private Pair<RollbackInfo, Boolean> getAvailableRollback(RollbackManager rollbackManager, |
Zimuzo | 71d931e | 2019-02-01 13:08:16 +0000 | [diff] [blame] | 156 | VersionedPackage failedPackage, VersionedPackage moduleMetadataPackage) { |
Zimuzo | c119780 | 2019-01-30 12:05:41 +0000 | [diff] [blame] | 157 | for (RollbackInfo rollback : rollbackManager.getAvailableRollbacks()) { |
Zimuzo | 03eeb13 | 2019-01-30 15:13:56 +0000 | [diff] [blame] | 158 | // We only rollback mainline packages, so check if rollback contains the |
| 159 | // module metadata provider, if it does, the rollback is a mainline rollback |
| 160 | boolean hasModuleMetadataPackage = false; |
| 161 | boolean hasFailedPackage = false; |
Zimuzo | e5009cd | 2019-01-23 18:11:58 +0000 | [diff] [blame] | 162 | for (PackageRollbackInfo packageRollback : rollback.getPackages()) { |
Zimuzo | 03eeb13 | 2019-01-30 15:13:56 +0000 | [diff] [blame] | 163 | hasModuleMetadataPackage |= packageRollback.getPackageName().equals( |
Zimuzo | 71d931e | 2019-02-01 13:08:16 +0000 | [diff] [blame] | 164 | moduleMetadataPackage.getPackageName()); |
| 165 | hasFailedPackage |= packageRollback.getPackageName().equals( |
| 166 | failedPackage.getPackageName()) |
Zimuzo | 972e1cd | 2019-01-28 16:30:01 +0000 | [diff] [blame] | 167 | && packageRollback.getVersionRolledBackFrom().getVersionCode() |
Zimuzo | 71d931e | 2019-02-01 13:08:16 +0000 | [diff] [blame] | 168 | == failedPackage.getVersionCode(); |
Zimuzo | 03eeb13 | 2019-01-30 15:13:56 +0000 | [diff] [blame] | 169 | } |
Zimuzo | 9e57ecb | 2019-02-04 15:34:08 +0000 | [diff] [blame] | 170 | if (hasFailedPackage) { |
| 171 | return new Pair<RollbackInfo, Boolean>(rollback, hasModuleMetadataPackage); |
Zimuzo | e5009cd | 2019-01-23 18:11:58 +0000 | [diff] [blame] | 172 | } |
| 173 | } |
| 174 | return null; |
Zimuzo | c4073cc | 2019-01-18 18:39:18 +0000 | [diff] [blame] | 175 | } |
Zimuzo | 03eeb13 | 2019-01-30 15:13:56 +0000 | [diff] [blame] | 176 | |
| 177 | private VersionedPackage getModuleMetadataPackage() { |
| 178 | String packageName = mContext.getResources().getString( |
| 179 | R.string.config_defaultModuleMetadataProvider); |
Zimuzo | 9e57ecb | 2019-02-04 15:34:08 +0000 | [diff] [blame] | 180 | if (TextUtils.isEmpty(packageName)) { |
Zimuzo | 03eeb13 | 2019-01-30 15:13:56 +0000 | [diff] [blame] | 181 | return null; |
| 182 | } |
| 183 | |
| 184 | try { |
| 185 | return new VersionedPackage(packageName, mContext.getPackageManager().getPackageInfo( |
| 186 | packageName, 0 /* flags */).getLongVersionCode()); |
| 187 | } catch (PackageManager.NameNotFoundException e) { |
| 188 | Slog.w(TAG, "Module metadata provider not found"); |
| 189 | return null; |
| 190 | } |
| 191 | } |
Zimuzo | ff99176 | 2019-02-01 19:25:44 +0000 | [diff] [blame] | 192 | |
| 193 | private BroadcastReceiver listenForStagedSessionReady(RollbackManager rollbackManager, |
| 194 | int rollbackId) { |
| 195 | BroadcastReceiver sessionUpdatedReceiver = new BroadcastReceiver() { |
| 196 | @Override |
| 197 | public void onReceive(Context context, Intent intent) { |
| 198 | handleStagedSessionChange(rollbackManager, |
| 199 | rollbackId, this /* BroadcastReceiver */); |
| 200 | } |
| 201 | }; |
| 202 | IntentFilter sessionUpdatedFilter = |
| 203 | new IntentFilter(PackageInstaller.ACTION_SESSION_UPDATED); |
| 204 | mContext.registerReceiver(sessionUpdatedReceiver, sessionUpdatedFilter); |
| 205 | return sessionUpdatedReceiver; |
| 206 | } |
| 207 | |
| 208 | private void handleStagedSessionChange(RollbackManager rollbackManager, int rollbackId, |
| 209 | BroadcastReceiver listener) { |
| 210 | PackageInstaller packageInstaller = |
| 211 | mContext.getPackageManager().getPackageInstaller(); |
| 212 | List<RollbackInfo> recentRollbacks = |
| 213 | rollbackManager.getRecentlyCommittedRollbacks(); |
| 214 | for (int i = 0; i < recentRollbacks.size(); i++) { |
| 215 | RollbackInfo recentRollback = recentRollbacks.get(i); |
| 216 | int sessionId = recentRollback.getCommittedSessionId(); |
| 217 | if ((rollbackId == recentRollback.getRollbackId()) |
| 218 | && (sessionId != PackageInstaller.SessionInfo.INVALID_ID)) { |
| 219 | PackageInstaller.SessionInfo sessionInfo = |
| 220 | packageInstaller.getSessionInfo(sessionId); |
Dario Freni | 60a96c1 | 2019-02-24 21:01:29 +0000 | [diff] [blame] | 221 | if (sessionInfo.isStagedSessionReady()) { |
Zimuzo | ff99176 | 2019-02-01 19:25:44 +0000 | [diff] [blame] | 222 | mContext.unregisterReceiver(listener); |
| 223 | mContext.getSystemService(PowerManager.class).reboot("Rollback staged install"); |
Dario Freni | 60a96c1 | 2019-02-24 21:01:29 +0000 | [diff] [blame] | 224 | } else if (sessionInfo.isStagedSessionFailed()) { |
Zimuzo | ff99176 | 2019-02-01 19:25:44 +0000 | [diff] [blame] | 225 | mContext.unregisterReceiver(listener); |
| 226 | } |
| 227 | } |
| 228 | } |
| 229 | } |
Zimuzo | c4073cc | 2019-01-18 18:39:18 +0000 | [diff] [blame] | 230 | } |