Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit ad02ac14 authored by Gavin Corkery's avatar Gavin Corkery
Browse files

Move Watchdog rollback logging to separate class 

Decouple most of the watchdog rollback logging from Rollback
Package Health Observer. This allows for easier testing and
will facilitate future Watchdog logging requests from Staging
Manager.

Test: atest WatchdogRollbackLoggerTest
Test: atest StagedRollbackTest, check logs to ensure everything works
      as before
Bug: 138782888

Change-Id: I380c52322153873655ae07be11a3472926011345
parent 4a8fc13d

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

+9 −159
Original line number Diff line number Diff line
@@ -16,19 +16,13 @@ 


package com.android.server.rollback;



import static android.util.StatsLog.WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_REASON__REASON_APP_CRASH;

import static android.util.StatsLog.WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_REASON__REASON_APP_NOT_RESPONDING;

import static android.util.StatsLog.WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_REASON__REASON_EXPLICIT_HEALTH_CHECK;

import static android.util.StatsLog.WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_REASON__REASON_NATIVE_CRASH;

import static android.util.StatsLog.WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_REASON__REASON_UNKNOWN;



import android.annotation.NonNull;

import android.annotation.Nullable;

import android.content.BroadcastReceiver;

import android.content.Context;

import android.content.Intent;

import android.content.IntentFilter;

import android.content.pm.ApplicationInfo;

import android.content.pm.PackageInstaller;

import android.content.pm.PackageManager;

import android.content.pm.VersionedPackage;
@@ -75,8 +69,6 @@ public final class RollbackPackageHealthObserver implements PackageHealthObserve 
    private static final String TAG = "RollbackPackageHealthObserver";

    private static final String NAME = "rollback-observer";



    private static final String LOGGING_PARENT_KEY = "android.content.pm.LOGGING_PARENT";



    private final Context mContext;

    private final Handler mHandler;

    private final File mLastStagedRollbackIdsFile;
@@ -162,67 +154,8 @@ public final class RollbackPackageHealthObserver implements PackageHealthObserve 
        Iterator<Integer> rollbackIterator = rollbackIds.iterator();

        while (rollbackIterator.hasNext()) {

            int rollbackId = rollbackIterator.next();

            logRollbackStatusOnBoot(rollbackId, rollbackManager.getRecentlyCommittedRollbacks());

        }

    }



    private void logRollbackStatusOnBoot(int rollbackId,

            List<RollbackInfo> recentlyCommittedRollbacks) {

        PackageInstaller packageInstaller = mContext.getPackageManager().getPackageInstaller();



        RollbackInfo rollback = null;

        for (RollbackInfo info : recentlyCommittedRollbacks) {

            if (rollbackId == info.getRollbackId()) {

                rollback = info;

                break;

            }

        }



        if (rollback == null) {

            Slog.e(TAG, "rollback info not found for last staged rollback: " + rollbackId);

            return;

        }



        // Identify the logging parent for this rollback. When all configurations are correct, each

        // package in the rollback refers to the same logging parent, except for the logging parent

        // itself. If a logging parent is missing for a package, we use the package itself for

        // logging. This might result in over-logging, but we prefer this over no logging.

        final Set<String> loggingPackageNames = new ArraySet<>();

        for (PackageRollbackInfo packageRollback : rollback.getPackages()) {

            final String loggingParentName = getLoggingParentName(packageRollback.getPackageName());

            if (loggingParentName != null) {

                loggingPackageNames.add(loggingParentName);

            } else {

                loggingPackageNames.add(packageRollback.getPackageName());

            }

        }



        // Use the version of the logging parent that was installed before

        // we rolled back for logging purposes.

        final List<VersionedPackage> oldLoggingPackages = new ArrayList<>();

        for (PackageRollbackInfo packageRollback : rollback.getPackages()) {

            if (loggingPackageNames.contains(packageRollback.getPackageName())) {

                oldLoggingPackages.add(packageRollback.getVersionRolledBackFrom());

            }

        }



        int sessionId = rollback.getCommittedSessionId();

        PackageInstaller.SessionInfo sessionInfo = packageInstaller.getSessionInfo(sessionId);

        if (sessionInfo == null) {

            Slog.e(TAG, "On boot completed, could not load session id " + sessionId);

            return;

        }



        for (VersionedPackage oldLoggingPackage : oldLoggingPackages) {

            if (sessionInfo.isStagedSessionApplied()) {

                logEvent(oldLoggingPackage,

                        StatsLog.WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_TYPE__ROLLBACK_SUCCESS,

                        WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_REASON__REASON_UNKNOWN, "");

            } else if (sessionInfo.isStagedSessionFailed()) {

                logEvent(oldLoggingPackage,

                        StatsLog.WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_TYPE__ROLLBACK_FAILURE,

                        WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_REASON__REASON_UNKNOWN, "");

            }

            WatchdogRollbackLogger.logRollbackStatusOnBoot(

                    mContext, rollbackId, rollbackManager.getRecentlyCommittedRollbacks());

        }

    }
@@ -255,22 +188,6 @@ public final class RollbackPackageHealthObserver implements PackageHealthObserve 
        return null;

    }



    @Nullable

    private String getLoggingParentName(String packageName) {

        PackageManager packageManager = mContext.getPackageManager();

        try {

            ApplicationInfo ai = packageManager.getApplicationInfo(packageName,

                    PackageManager.GET_META_DATA);

            if (ai.metaData == null) {

                return null;

            }

            return ai.metaData.getString(LOGGING_PARENT_KEY);

        } catch (Exception e) {

            Slog.w(TAG, "Unable to discover logging parent package: " + packageName, e);

            return null;

        }

    }



    private BroadcastReceiver listenForStagedSessionReady(RollbackManager rollbackManager,

            int rollbackId, @Nullable VersionedPackage logPackage) {

        BroadcastReceiver sessionUpdatedReceiver = new BroadcastReceiver() {
@@ -306,14 +223,14 @@ public final class RollbackPackageHealthObserver implements PackageHealthObserve 
                        // successful or not. If logPackage is null, then there is nothing to log.

                        saveStagedRollbackId(rollbackId);

                    }

                    logEvent(logPackage,

                    WatchdogRollbackLogger.logEvent(logPackage,

                            StatsLog

                            .WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_TYPE__ROLLBACK_BOOT_TRIGGERED,

                            WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_REASON__REASON_UNKNOWN,

                            "");

                } else if (sessionInfo.isStagedSessionFailed()

                        && markStagedSessionHandled(rollbackId)) {

                    logEvent(logPackage,

                    WatchdogRollbackLogger.logEvent(logPackage,

                            StatsLog.WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_TYPE__ROLLBACK_FAILURE,

                            WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_REASON__REASON_UNKNOWN,

                            "");
@@ -383,47 +300,6 @@ public final class RollbackPackageHealthObserver implements PackageHealthObserve 
        }

    }



    private static String rollbackTypeToString(int type) {

        switch (type) {

            case StatsLog.WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_TYPE__ROLLBACK_INITIATE:

                return "ROLLBACK_INITIATE";

            case StatsLog.WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_TYPE__ROLLBACK_SUCCESS:

                return "ROLLBACK_SUCCESS";

            case StatsLog.WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_TYPE__ROLLBACK_FAILURE:

                return "ROLLBACK_FAILURE";

            case StatsLog.WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_TYPE__ROLLBACK_BOOT_TRIGGERED:

                return "ROLLBACK_BOOT_TRIGGERED";

            default:

                return "UNKNOWN";

        }

    }



    private static String rollbackReasonToString(int reason) {

        switch (reason) {

            case StatsLog.WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_REASON__REASON_NATIVE_CRASH:

                return "REASON_NATIVE_CRASH";

            case StatsLog.WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_REASON__REASON_EXPLICIT_HEALTH_CHECK:

                return "REASON_EXPLICIT_HEALTH_CHECK";

            case StatsLog.WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_REASON__REASON_APP_CRASH:

                return "REASON_APP_CRASH";

            case StatsLog.WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_REASON__REASON_APP_NOT_RESPONDING:

                return "REASON_APP_NOT_RESPONDING";

            default:

                return "UNKNOWN";

        }

    }



    private static void logEvent(@Nullable VersionedPackage logPackage, int type,

            int rollbackReason, @NonNull String failingPackageName) {

        Slog.i(TAG, "Watchdog event occurred with type: " + rollbackTypeToString(type)

                + " logPackage: " + logPackage

                + " rollbackReason: " + rollbackReasonToString(rollbackReason)

                + " failedPackageName: " + failingPackageName);

        if (logPackage != null) {

            StatsLog.logWatchdogRollbackOccurred(type, logPackage.getPackageName(),

                    logPackage.getLongVersionCode(), rollbackReason, failingPackageName);

        }

    }



    /**

     * Returns true if the package name is the name of a module.
@@ -446,7 +322,7 @@ public final class RollbackPackageHealthObserver implements PackageHealthObserve 
    private void rollbackPackage(RollbackInfo rollback, VersionedPackage failedPackage,

            @FailureReasons int rollbackReason) {

        final RollbackManager rollbackManager = mContext.getSystemService(RollbackManager.class);

        int reasonToLog = mapFailureReasonToMetric(rollbackReason);

        int reasonToLog = WatchdogRollbackLogger.mapFailureReasonToMetric(rollbackReason);

        final String failedPackageToLog;

        if (rollbackReason == PackageWatchdog.FAILURE_REASON_NATIVE_CRASH) {

            failedPackageToLog = SystemProperties.get(
@@ -456,20 +332,11 @@ public final class RollbackPackageHealthObserver implements PackageHealthObserve 
        }

        VersionedPackage logPackageTemp = null;

        if (isModule(failedPackage.getPackageName())) {

            String logPackageName = getLoggingParentName(failedPackage.getPackageName());

            if (logPackageName == null) {

                logPackageName = failedPackage.getPackageName();

            }

            try {

                logPackageTemp = new VersionedPackage(logPackageName, mContext.getPackageManager()

                        .getPackageInfo(logPackageName, 0 /* flags */).getLongVersionCode());

            } catch (PackageManager.NameNotFoundException e) {

                logPackageTemp = null;

            }

            logPackageTemp = WatchdogRollbackLogger.getLogPackage(mContext, failedPackage);

        }



        final VersionedPackage logPackage = logPackageTemp;

        logEvent(logPackage,

        WatchdogRollbackLogger.logEvent(logPackage,

                StatsLog.WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_TYPE__ROLLBACK_INITIATE,

                reasonToLog, failedPackageToLog);

        final LocalIntentReceiver rollbackReceiver = new LocalIntentReceiver((Intent result) -> {
@@ -487,7 +354,7 @@ public final class RollbackPackageHealthObserver implements PackageHealthObserve 
                    handleStagedSessionChange(rollbackManager, rollbackId, listener,

                            logPackage);

                } else {

                    logEvent(logPackage,

                    WatchdogRollbackLogger.logEvent(logPackage,

                            StatsLog.WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_TYPE__ROLLBACK_SUCCESS,

                            reasonToLog, failedPackageToLog);

                }
@@ -495,7 +362,7 @@ public final class RollbackPackageHealthObserver implements PackageHealthObserve 
                if (rollback.isStaged()) {

                    markStagedSessionHandled(rollback.getRollbackId());

                }

                logEvent(logPackage,

                WatchdogRollbackLogger.logEvent(logPackage,

                        StatsLog.WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_TYPE__ROLLBACK_FAILURE,

                        reasonToLog, failedPackageToLog);

            }
@@ -527,21 +394,4 @@ public final class RollbackPackageHealthObserver implements PackageHealthObserve 
            rollbackPackage(rollback, sample, PackageWatchdog.FAILURE_REASON_NATIVE_CRASH);

        }

    }





    private int mapFailureReasonToMetric(@FailureReasons int failureReason) {

        switch (failureReason) {

            case PackageWatchdog.FAILURE_REASON_NATIVE_CRASH:

                return WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_REASON__REASON_NATIVE_CRASH;

            case PackageWatchdog.FAILURE_REASON_EXPLICIT_HEALTH_CHECK:

                return WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_REASON__REASON_EXPLICIT_HEALTH_CHECK;

            case PackageWatchdog.FAILURE_REASON_APP_CRASH:

                return WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_REASON__REASON_APP_CRASH;

            case PackageWatchdog.FAILURE_REASON_APP_NOT_RESPONDING:

                return WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_REASON__REASON_APP_NOT_RESPONDING;

            default:

                return WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_REASON__REASON_UNKNOWN;

        }

    }



}

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

0 → 100644
+216 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2020 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



package com.android.server.rollback;



import static android.util.StatsLog.WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_REASON__REASON_APP_CRASH;

import static android.util.StatsLog.WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_REASON__REASON_APP_NOT_RESPONDING;

import static android.util.StatsLog.WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_REASON__REASON_EXPLICIT_HEALTH_CHECK;

import static android.util.StatsLog.WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_REASON__REASON_NATIVE_CRASH;

import static android.util.StatsLog.WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_REASON__REASON_UNKNOWN;



import android.annotation.NonNull;

import android.annotation.Nullable;

import android.content.Context;

import android.content.pm.ApplicationInfo;

import android.content.pm.PackageInstaller;

import android.content.pm.PackageManager;

import android.content.pm.VersionedPackage;

import android.content.rollback.PackageRollbackInfo;

import android.content.rollback.RollbackInfo;

import android.util.ArraySet;

import android.util.Slog;

import android.util.StatsLog;



import com.android.internal.annotations.VisibleForTesting;

import com.android.server.PackageWatchdog;



import java.util.ArrayList;

import java.util.List;

import java.util.Set;



/**

 * This class handles the logic for logging Watchdog-triggered rollback events.

 */

public final class WatchdogRollbackLogger {

    private static final String TAG = "WatchdogRollbackLogger";



    private static final String LOGGING_PARENT_KEY = "android.content.pm.LOGGING_PARENT";



    private WatchdogRollbackLogger() {

    }



    @Nullable

    private static String getLoggingParentName(Context context, @NonNull String packageName) {

        PackageManager packageManager = context.getPackageManager();

        try {

            ApplicationInfo ai = packageManager.getApplicationInfo(packageName,

                    PackageManager.GET_META_DATA);

            if (ai.metaData == null) {

                return null;

            }

            return ai.metaData.getString(LOGGING_PARENT_KEY);

        } catch (Exception e) {

            Slog.w(TAG, "Unable to discover logging parent package: " + packageName, e);

            return null;

        }

    }



    @VisibleForTesting

    static VersionedPackage getLogPackage(Context context,

            @NonNull VersionedPackage failingPackage) {

        String logPackageName;

        VersionedPackage loggingParent;

        logPackageName = getLoggingParentName(context, failingPackage.getPackageName());

        if (logPackageName == null) {

            return failingPackage;

        }

        try {

            loggingParent = new VersionedPackage(logPackageName, context.getPackageManager()

                    .getPackageInfo(logPackageName, 0 /* flags */).getLongVersionCode());

        } catch (PackageManager.NameNotFoundException e) {

            return failingPackage;

        }

        return loggingParent;

    }



    static void logRollbackStatusOnBoot(Context context, int rollbackId,

            List<RollbackInfo> recentlyCommittedRollbacks) {

        PackageInstaller packageInstaller = context.getPackageManager().getPackageInstaller();



        RollbackInfo rollback = null;

        for (RollbackInfo info : recentlyCommittedRollbacks) {

            if (rollbackId == info.getRollbackId()) {

                rollback = info;

                break;

            }

        }



        if (rollback == null) {

            Slog.e(TAG, "rollback info not found for last staged rollback: " + rollbackId);

            return;

        }



        // Identify the logging parent for this rollback. When all configurations are correct, each

        // package in the rollback refers to the same logging parent, except for the logging parent

        // itself. If a logging parent is missing for a package, we use the package itself for

        // logging. This might result in over-logging, but we prefer this over no logging.

        final Set<String> loggingPackageNames = new ArraySet<>();

        for (PackageRollbackInfo packageRollback : rollback.getPackages()) {

            final String loggingParentName = getLoggingParentName(context,

                    packageRollback.getPackageName());

            if (loggingParentName != null) {

                loggingPackageNames.add(loggingParentName);

            } else {

                loggingPackageNames.add(packageRollback.getPackageName());

            }

        }



        // Use the version of the logging parent that was installed before

        // we rolled back for logging purposes.

        final List<VersionedPackage> oldLoggingPackages = new ArrayList<>();

        for (PackageRollbackInfo packageRollback : rollback.getPackages()) {

            if (loggingPackageNames.contains(packageRollback.getPackageName())) {

                oldLoggingPackages.add(packageRollback.getVersionRolledBackFrom());

            }

        }



        int sessionId = rollback.getCommittedSessionId();

        PackageInstaller.SessionInfo sessionInfo = packageInstaller.getSessionInfo(sessionId);

        if (sessionInfo == null) {

            Slog.e(TAG, "On boot completed, could not load session id " + sessionId);

            return;

        }



        for (VersionedPackage oldLoggingPackage : oldLoggingPackages) {

            if (sessionInfo.isStagedSessionApplied()) {

                logEvent(oldLoggingPackage,

                        StatsLog.WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_TYPE__ROLLBACK_SUCCESS,

                        WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_REASON__REASON_UNKNOWN, "");

            } else if (sessionInfo.isStagedSessionFailed()) {

                logEvent(oldLoggingPackage,

                        StatsLog.WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_TYPE__ROLLBACK_FAILURE,

                        WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_REASON__REASON_UNKNOWN, "");

            }

        }

    }



    /**

     * Log a Watchdog rollback event to statsd.

     *

     * @param logPackage the package to associate the rollback with.

     * @param type the state of the rollback.

     * @param rollbackReason the reason Watchdog triggered a rollback, if known.

     * @param failingPackageName the failing package or process which triggered the rollback.

     */

    public static void logEvent(@Nullable VersionedPackage logPackage, int type,

            int rollbackReason, @NonNull String failingPackageName) {

        Slog.i(TAG, "Watchdog event occurred with type: " + rollbackTypeToString(type)

                + " logPackage: " + logPackage

                + " rollbackReason: " + rollbackReasonToString(rollbackReason)

                + " failedPackageName: " + failingPackageName);

        if (logPackage != null) {

            StatsLog.logWatchdogRollbackOccurred(type, logPackage.getPackageName(),

                    logPackage.getVersionCode(), rollbackReason, failingPackageName);

        }

    }



    @VisibleForTesting

    static int mapFailureReasonToMetric(@PackageWatchdog.FailureReasons int failureReason) {

        switch (failureReason) {

            case PackageWatchdog.FAILURE_REASON_NATIVE_CRASH:

                return WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_REASON__REASON_NATIVE_CRASH;

            case PackageWatchdog.FAILURE_REASON_EXPLICIT_HEALTH_CHECK:

                return WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_REASON__REASON_EXPLICIT_HEALTH_CHECK;

            case PackageWatchdog.FAILURE_REASON_APP_CRASH:

                return WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_REASON__REASON_APP_CRASH;

            case PackageWatchdog.FAILURE_REASON_APP_NOT_RESPONDING:

                return WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_REASON__REASON_APP_NOT_RESPONDING;

            default:

                return WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_REASON__REASON_UNKNOWN;

        }

    }



    private static String rollbackTypeToString(int type) {

        switch (type) {

            case StatsLog.WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_TYPE__ROLLBACK_INITIATE:

                return "ROLLBACK_INITIATE";

            case StatsLog.WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_TYPE__ROLLBACK_SUCCESS:

                return "ROLLBACK_SUCCESS";

            case StatsLog.WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_TYPE__ROLLBACK_FAILURE:

                return "ROLLBACK_FAILURE";

            case StatsLog.WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_TYPE__ROLLBACK_BOOT_TRIGGERED:

                return "ROLLBACK_BOOT_TRIGGERED";

            default:

                return "UNKNOWN";

        }

    }



    private static String rollbackReasonToString(int reason) {

        switch (reason) {

            case StatsLog.WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_REASON__REASON_NATIVE_CRASH:

                return "REASON_NATIVE_CRASH";

            case StatsLog.WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_REASON__REASON_EXPLICIT_HEALTH_CHECK:

                return "REASON_EXPLICIT_HEALTH_CHECK";

            case StatsLog.WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_REASON__REASON_APP_CRASH:

                return "REASON_APP_CRASH";

            case StatsLog.WATCHDOG_ROLLBACK_OCCURRED__ROLLBACK_REASON__REASON_APP_NOT_RESPONDING:

                return "REASON_APP_NOT_RESPONDING";

            default:

                return "UNKNOWN";

        }

    }

}

services/tests/servicestests/src/com/android/server/rollback/WatchdogRollbackLoggerTest.java

0 → 100644
+119 −0

File added.

Preview size limit exceeded, changes collapsed.