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

Commit 11d5d6ff authored by Treehugger Robot's avatar Treehugger Robot Committed by Gerrit Code Review
Browse files

Merge changes I3ac40130,I6acce43c into main 

* changes:
  Updating the flag reset deprecation flag
  Removing old code
parents f1a4cf55 7f3fcc75

packages/CrashRecovery/aconfig/flags.aconfig

+2 −2
Original line number Diff line number Diff line
@@ -26,8 +26,8 @@ flag { 
}



flag {

    name: "reenable_settings_resets"

    name: "deprecate_flags_and_settings_resets"

    namespace: "modularization"

    description: "Re-enables settings resets only, deletes flag resets"

    description: "Deletes flag and settings resets"

    bug: "333847376"

}

services/core/java/com/android/server/RescueParty.java

+0 −105
Original line number Diff line number Diff line
@@ -58,7 +58,6 @@ import java.io.File; 
import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;
@@ -493,14 +492,6 @@ public class RescueParty { 


    private static void executeRescueLevelInternalOld(Context context, int level, @Nullable

            String failedPackage) throws Exception {



        // Note: DeviceConfig reset is disabled currently and would be enabled using the flag,

        // after we have figured out a way to reset flags without interfering with trunk

        // development. TODO: b/287618292 For enabling flag resets.

        if (!Flags.allowRescuePartyFlagResets() && level <= LEVEL_RESET_SETTINGS_TRUSTED_DEFAULTS) {

            return;

        }



        CrashRecoveryStatsLog.write(CrashRecoveryStatsLog.RESCUE_PARTY_RESET_REPORTED,

                level, levelToString(level));

        // Try our best to reset all settings possible, and once finished
@@ -508,43 +499,10 @@ public class RescueParty { 
        Exception res = null;

        switch (level) {

            case LEVEL_RESET_SETTINGS_UNTRUSTED_DEFAULTS:

                try {

                    resetAllSettingsIfNecessary(context, Settings.RESET_MODE_UNTRUSTED_DEFAULTS,

                            level);

                } catch (Exception e) {

                    res = e;

                }

                try {

                    resetDeviceConfig(context, /*isScoped=*/true, failedPackage);

                } catch (Exception e) {

                    res = e;

                }

                break;

            case LEVEL_RESET_SETTINGS_UNTRUSTED_CHANGES:

                try {

                    resetAllSettingsIfNecessary(context, Settings.RESET_MODE_UNTRUSTED_CHANGES,

                            level);

                } catch (Exception e) {

                    res = e;

                }

                try {

                    resetDeviceConfig(context, /*isScoped=*/true, failedPackage);

                } catch (Exception e) {

                    res = e;

                }

                break;

            case LEVEL_RESET_SETTINGS_TRUSTED_DEFAULTS:

                try {

                    resetAllSettingsIfNecessary(context, Settings.RESET_MODE_TRUSTED_DEFAULTS,

                            level);

                } catch (Exception e) {

                    res = e;

                }

                try {

                    resetDeviceConfig(context, /*isScoped=*/false, failedPackage);

                } catch (Exception e) {

                    res = e;

                }

                break;

            case LEVEL_WARM_REBOOT:

                executeWarmReboot(context, level, failedPackage);
@@ -572,16 +530,8 @@ public class RescueParty { 
                level, levelToString(level));

        switch (level) {

            case RESCUE_LEVEL_SCOPED_DEVICE_CONFIG_RESET:

                // Enable deviceConfig reset behind flag

                if (Flags.allowRescuePartyFlagResets()) {

                    resetDeviceConfig(context, /*isScoped=*/true, failedPackage);

                }

                break;

            case RESCUE_LEVEL_ALL_DEVICE_CONFIG_RESET:

                // Enable deviceConfig reset behind flag

                if (Flags.allowRescuePartyFlagResets()) {

                    resetDeviceConfig(context, /*isScoped=*/false, failedPackage);

                }

                break;

            case RESCUE_LEVEL_WARM_REBOOT:

                executeWarmReboot(context, level, failedPackage);
@@ -732,61 +682,6 @@ public class RescueParty { 
        }

    }



    private static void resetDeviceConfig(Context context, boolean isScoped,

            @Nullable String failedPackage) throws Exception {

        final ContentResolver resolver = context.getContentResolver();

        try {

            if (!isScoped || failedPackage == null) {

                resetAllAffectedNamespaces(context);

            } else {

                performScopedReset(context, failedPackage);

            }

        } catch (Exception e) {

            throw new RuntimeException("Failed to reset config settings", e);

        }

    }



    private static void resetAllAffectedNamespaces(Context context) {

        RescuePartyObserver rescuePartyObserver = RescuePartyObserver.getInstance(context);

        Set<String> allAffectedNamespaces = rescuePartyObserver.getAllAffectedNamespaceSet();



        Slog.w(TAG,

                "Performing reset for all affected namespaces: "

                        + Arrays.toString(allAffectedNamespaces.toArray()));

        Iterator<String> it = allAffectedNamespaces.iterator();

        while (it.hasNext()) {

            String namespace = it.next();

            // Don't let RescueParty reset the namespace for RescueParty switches.

            if (NAMESPACE_CONFIGURATION.equals(namespace)) {

                continue;

            }

            DeviceConfig.resetToDefaults(DEVICE_CONFIG_RESET_MODE, namespace);

        }

    }



    private static void performScopedReset(Context context, @NonNull String failedPackage) {

        RescuePartyObserver rescuePartyObserver = RescuePartyObserver.getInstance(context);

        Set<String> affectedNamespaces = rescuePartyObserver.getAffectedNamespaceSet(

                failedPackage);

        // If we can't find namespaces affected for current package,

        // skip this round of reset.

        if (affectedNamespaces != null) {

            Slog.w(TAG,

                    "Performing scoped reset for package: " + failedPackage

                            + ", affected namespaces: "

                            + Arrays.toString(affectedNamespaces.toArray()));

            Iterator<String> it = affectedNamespaces.iterator();

            while (it.hasNext()) {

                String namespace = it.next();

                // Don't let RescueParty reset the namespace for RescueParty switches.

                if (NAMESPACE_CONFIGURATION.equals(namespace)) {

                    continue;

                }

                DeviceConfig.resetToDefaults(DEVICE_CONFIG_RESET_MODE, namespace);

            }

        }

    }



    /**

     * Handle mitigation action for package failures. This observer will be register to Package

     * Watchdog and will receive calls about package failures. This observer is persistent so it

services/tests/mockingservicestests/src/com/android/server/RescuePartyTest.java

+8 −147
Original line number Diff line number Diff line
@@ -74,7 +74,6 @@ import java.util.Arrays; 
import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.concurrent.Executor;

import java.util.concurrent.TimeUnit;
@@ -227,9 +226,6 @@ public class RescuePartyTest { 
        setCrashRecoveryPropRescueBootCount(0);

        SystemProperties.set(RescueParty.PROP_ENABLE_RESCUE, Boolean.toString(true));

        SystemProperties.set(PROP_DEVICE_CONFIG_DISABLE_FLAG, Boolean.toString(false));



        // enable flag resets for tests

        mSetFlagsRule.enableFlags(Flags.FLAG_ALLOW_RESCUE_PARTY_FLAG_RESETS);

    }



    @After
@@ -250,9 +246,6 @@ public class RescuePartyTest { 


        noteBoot(1);



        verifySettingsResets(Settings.RESET_MODE_UNTRUSTED_DEFAULTS, /*resetNamespaces=*/ null,

                verifiedTimesMap);



        // Record DeviceConfig accesses

        RescuePartyObserver observer = RescuePartyObserver.getInstance(mMockContext);

        DeviceConfig.MonitorCallback monitorCallback = mMonitorCallbackCaptor.getValue();
@@ -262,15 +255,8 @@ public class RescuePartyTest { 
        final String[] expectedAllResetNamespaces = new String[]{NAMESPACE1, NAMESPACE2};



        noteBoot(2);



        verifySettingsResets(Settings.RESET_MODE_UNTRUSTED_CHANGES, expectedAllResetNamespaces,

                verifiedTimesMap);



        noteBoot(3);



        verifySettingsResets(Settings.RESET_MODE_TRUSTED_DEFAULTS, expectedAllResetNamespaces,

                verifiedTimesMap);



        noteBoot(4);

        assertTrue(RescueParty.isRebootPropertySet());
@@ -296,7 +282,6 @@ public class RescuePartyTest { 
        final String[] expectedAllResetNamespaces = new String[]{NAMESPACE1, NAMESPACE2};



        noteBoot(1);

        verifyDeviceConfigReset(expectedAllResetNamespaces, verifiedTimesMap);



        noteBoot(2);

        assertTrue(RescueParty.isRebootPropertySet());
@@ -321,20 +306,9 @@ public class RescuePartyTest { 
        mSetFlagsRule.disableFlags(Flags.FLAG_RECOVERABILITY_DETECTION);



        noteAppCrash(1, true);



        verifySettingsResets(Settings.RESET_MODE_UNTRUSTED_DEFAULTS, /*resetNamespaces=*/ null,

                /*configResetVerifiedTimesMap=*/ null);



        noteAppCrash(2, true);



        verifySettingsResets(Settings.RESET_MODE_UNTRUSTED_CHANGES, /*resetNamespaces=*/ null,

                /*configResetVerifiedTimesMap=*/ null);



        noteAppCrash(3, true);



        verifySettingsResets(Settings.RESET_MODE_TRUSTED_DEFAULTS, /*resetNamespaces=*/ null,

                /*configResetVerifiedTimesMap=*/ null);



        noteAppCrash(4, true);

        assertTrue(RescueParty.isRebootPropertySet());
@@ -362,10 +336,8 @@ public class RescuePartyTest { 
        final String[] expectedAllResetNamespaces = new String[]{NAMESPACE1, NAMESPACE2};



        noteAppCrash(1, true);

        verifyDeviceConfigReset(expectedResetNamespaces, verifiedTimesMap);



        noteAppCrash(2, true);

        verifyDeviceConfigReset(expectedAllResetNamespaces, verifiedTimesMap);



        noteAppCrash(3, true);

        assertTrue(RescueParty.isRebootPropertySet());
@@ -385,26 +357,13 @@ public class RescuePartyTest { 
    }



    @Test

    public void testNonPersistentAppOnlyPerformsFlagResets() {

    public void testNonPersistentAppDoesntDoAnything() {

        // this is old test where the flag needs to be disabled

        mSetFlagsRule.disableFlags(Flags.FLAG_RECOVERABILITY_DETECTION);



        noteAppCrash(1, false);



        verifySettingsResets(Settings.RESET_MODE_UNTRUSTED_DEFAULTS, /*resetNamespaces=*/ null,

                /*configResetVerifiedTimesMap=*/ null);



        noteAppCrash(2, false);



        verifySettingsResets(Settings.RESET_MODE_UNTRUSTED_CHANGES, /*resetNamespaces=*/ null,

                /*configResetVerifiedTimesMap=*/ null);



        noteAppCrash(3, false);



        verifySettingsResets(Settings.RESET_MODE_TRUSTED_DEFAULTS, /*resetNamespaces=*/ null,

                /*configResetVerifiedTimesMap=*/ null);



        noteAppCrash(4, false);

        assertFalse(RescueParty.isRebootPropertySet());



        noteAppCrash(5, false);
@@ -430,10 +389,8 @@ public class RescuePartyTest { 
        final String[] expectedAllResetNamespaces = new String[]{NAMESPACE1, NAMESPACE2};



        noteAppCrash(1, false);

        verifyDeviceConfigReset(expectedResetNamespaces, verifiedTimesMap);



        noteAppCrash(2, false);

        verifyDeviceConfigReset(expectedAllResetNamespaces, verifiedTimesMap);



        noteAppCrash(3, false);

        assertFalse(RescueParty.isRebootPropertySet());
@@ -488,87 +445,12 @@ public class RescuePartyTest { 
        HashMap<String, Integer> verifiedTimesMap = new HashMap<String, Integer>();

        observer.execute(new VersionedPackage(

                CALLING_PACKAGE1, 1), PackageWatchdog.FAILURE_REASON_APP_CRASH, 1);

        verifySettingsResets(Settings.RESET_MODE_UNTRUSTED_DEFAULTS, expectedResetNamespaces,

                verifiedTimesMap);



        observer.execute(new VersionedPackage(

                CALLING_PACKAGE1, 1), PackageWatchdog.FAILURE_REASON_APP_NOT_RESPONDING, 2);

        verifySettingsResets(Settings.RESET_MODE_UNTRUSTED_CHANGES, expectedResetNamespaces,

                verifiedTimesMap);



        observer.execute(new VersionedPackage(

                CALLING_PACKAGE1, 1), PackageWatchdog.FAILURE_REASON_APP_NOT_RESPONDING, 3);

        verifySettingsResets(Settings.RESET_MODE_TRUSTED_DEFAULTS, expectedAllResetNamespaces,

                verifiedTimesMap);



        observer.execute(new VersionedPackage(

                CALLING_PACKAGE1, 1), PackageWatchdog.FAILURE_REASON_APP_NOT_RESPONDING, 4);

        assertFalse(RescueParty.isRebootPropertySet());



        observer.execute(new VersionedPackage(

                CALLING_PACKAGE1, 1), PackageWatchdog.FAILURE_REASON_APP_NOT_RESPONDING, 5);

        assertFalse(RescueParty.isFactoryResetPropertySet());

    }



    @Test

    public void testNonDeviceConfigSettingsOnlyResetOncePerLevel() {

        // this is old test where the flag needs to be disabled

        mSetFlagsRule.disableFlags(Flags.FLAG_RECOVERABILITY_DETECTION);



        RescueParty.onSettingsProviderPublished(mMockContext);

        verify(() -> DeviceConfig.setMonitorCallback(eq(mMockContentResolver),

                any(Executor.class),

                mMonitorCallbackCaptor.capture()));



        // Record DeviceConfig accesses

        RescuePartyObserver observer = RescuePartyObserver.getInstance(mMockContext);

        DeviceConfig.MonitorCallback monitorCallback = mMonitorCallbackCaptor.getValue();

        monitorCallback.onDeviceConfigAccess(CALLING_PACKAGE1, NAMESPACE1);

        monitorCallback.onDeviceConfigAccess(CALLING_PACKAGE1, NAMESPACE2);

        monitorCallback.onDeviceConfigAccess(CALLING_PACKAGE2, NAMESPACE2);

        monitorCallback.onDeviceConfigAccess(CALLING_PACKAGE2, NAMESPACE3);

        // Fake DeviceConfig value changes

        monitorCallback.onNamespaceUpdate(NAMESPACE1);

        monitorCallback.onNamespaceUpdate(NAMESPACE2);

        monitorCallback.onNamespaceUpdate(NAMESPACE3);

        // Perform and verify scoped resets

        final String[] expectedPackage1ResetNamespaces = new String[]{NAMESPACE1, NAMESPACE2};

        final String[] expectedPackage2ResetNamespaces = new String[]{NAMESPACE2, NAMESPACE3};

        final String[] expectedAllResetNamespaces =

                new String[]{NAMESPACE1, NAMESPACE2, NAMESPACE3};

        HashMap<String, Integer> verifiedTimesMap = new HashMap<String, Integer>();

        observer.execute(new VersionedPackage(

                CALLING_PACKAGE1, 1), PackageWatchdog.FAILURE_REASON_APP_CRASH, 1);

        verifySettingsResets(Settings.RESET_MODE_UNTRUSTED_DEFAULTS,

                expectedPackage1ResetNamespaces, verifiedTimesMap);



        // Settings.Global & Settings.Secure should still remain the same execution times.

        observer.execute(new VersionedPackage(

                CALLING_PACKAGE2, 1), PackageWatchdog.FAILURE_REASON_APP_CRASH, 1);

        verifySettingsResets(Settings.RESET_MODE_UNTRUSTED_DEFAULTS,

                expectedPackage2ResetNamespaces, verifiedTimesMap);



        observer.execute(new VersionedPackage(

                CALLING_PACKAGE1, 1), PackageWatchdog.FAILURE_REASON_APP_NOT_RESPONDING, 2);

        verifySettingsResets(Settings.RESET_MODE_UNTRUSTED_CHANGES,

                expectedPackage1ResetNamespaces, verifiedTimesMap);



        // Settings.Global & Settings.Secure should still remain the same execution times.

        observer.execute(new VersionedPackage(

                CALLING_PACKAGE2, 1), PackageWatchdog.FAILURE_REASON_APP_NOT_RESPONDING, 2);

        verifySettingsResets(Settings.RESET_MODE_UNTRUSTED_CHANGES,

                expectedPackage2ResetNamespaces, verifiedTimesMap);



        observer.execute(new VersionedPackage(

                CALLING_PACKAGE1, 1), PackageWatchdog.FAILURE_REASON_APP_NOT_RESPONDING, 3);

        verifySettingsResets(Settings.RESET_MODE_TRUSTED_DEFAULTS, expectedAllResetNamespaces,

                verifiedTimesMap);



        // Settings.Global & Settings.Secure should still remain the same execution times.

        observer.execute(new VersionedPackage(

                CALLING_PACKAGE2, 1), PackageWatchdog.FAILURE_REASON_APP_NOT_RESPONDING, 3);

        verifySettingsResets(Settings.RESET_MODE_TRUSTED_DEFAULTS, expectedAllResetNamespaces,

                verifiedTimesMap);



        observer.execute(new VersionedPackage(

                CALLING_PACKAGE1, 1), PackageWatchdog.FAILURE_REASON_APP_NOT_RESPONDING, 4);
@@ -863,27 +745,27 @@ public class RescuePartyTest { 


        assertEquals(observer.onHealthCheckFailed(sFailingPackage,

                PackageWatchdog.FAILURE_REASON_APP_NOT_RESPONDING, 2),

                PackageHealthObserverImpact.USER_IMPACT_LEVEL_20);

                PackageHealthObserverImpact.USER_IMPACT_LEVEL_40);



        assertEquals(observer.onHealthCheckFailed(sFailingPackage,

                PackageWatchdog.FAILURE_REASON_APP_NOT_RESPONDING, 3),

                PackageHealthObserverImpact.USER_IMPACT_LEVEL_20);

                PackageHealthObserverImpact.USER_IMPACT_LEVEL_40);



        assertEquals(observer.onHealthCheckFailed(sFailingPackage,

                PackageWatchdog.FAILURE_REASON_APP_NOT_RESPONDING, 4),

                PackageHealthObserverImpact.USER_IMPACT_LEVEL_20);

                PackageHealthObserverImpact.USER_IMPACT_LEVEL_40);



        assertEquals(observer.onHealthCheckFailed(sFailingPackage,

                PackageWatchdog.FAILURE_REASON_APP_NOT_RESPONDING, 5),

                PackageHealthObserverImpact.USER_IMPACT_LEVEL_20);

                PackageHealthObserverImpact.USER_IMPACT_LEVEL_40);



        assertEquals(observer.onHealthCheckFailed(sFailingPackage,

                PackageWatchdog.FAILURE_REASON_APP_NOT_RESPONDING, 6),

                PackageHealthObserverImpact.USER_IMPACT_LEVEL_20);

                PackageHealthObserverImpact.USER_IMPACT_LEVEL_40);



        assertEquals(observer.onHealthCheckFailed(sFailingPackage,

                PackageWatchdog.FAILURE_REASON_APP_NOT_RESPONDING, 7),

                PackageHealthObserverImpact.USER_IMPACT_LEVEL_20);

                PackageHealthObserverImpact.USER_IMPACT_LEVEL_40);

    }



    @Test
@@ -906,7 +788,7 @@ public class RescuePartyTest { 
        mSetFlagsRule.enableFlags(Flags.FLAG_RECOVERABILITY_DETECTION);

        RescuePartyObserver observer = RescuePartyObserver.getInstance(mMockContext);



        assertEquals(observer.onBootLoop(1), PackageHealthObserverImpact.USER_IMPACT_LEVEL_20);

        assertEquals(observer.onBootLoop(1), PackageHealthObserverImpact.USER_IMPACT_LEVEL_40);

        assertEquals(observer.onBootLoop(2), PackageHealthObserverImpact.USER_IMPACT_LEVEL_50);

        assertEquals(observer.onBootLoop(3), PackageHealthObserverImpact.USER_IMPACT_LEVEL_71);

        assertEquals(observer.onBootLoop(4), PackageHealthObserverImpact.USER_IMPACT_LEVEL_75);
@@ -1037,7 +919,6 @@ public class RescuePartyTest { 
    private void verifySettingsResets(int resetMode, String[] resetNamespaces,

            HashMap<String, Integer> configResetVerifiedTimesMap) {

        verifyOnlySettingsReset(resetMode);

        verifyDeviceConfigReset(resetNamespaces, configResetVerifiedTimesMap);

    }



    private void verifyOnlySettingsReset(int resetMode) {
@@ -1054,26 +935,6 @@ public class RescuePartyTest { 
                eq(resetMode), anyInt()), never());

    }



    private void verifyDeviceConfigReset(String[] resetNamespaces,

            Map<String, Integer> configResetVerifiedTimesMap) {

        if (resetNamespaces == null) {

            verify(() -> DeviceConfig.resetToDefaults(anyInt(), anyString()), never());

        } else {

            for (String namespace : resetNamespaces) {

                int verifiedTimes = 0;

                if (configResetVerifiedTimesMap != null

                        && configResetVerifiedTimesMap.get(namespace) != null) {

                    verifiedTimes = configResetVerifiedTimesMap.get(namespace);

                }

                verify(() -> DeviceConfig.resetToDefaults(RescueParty.DEVICE_CONFIG_RESET_MODE,

                        namespace), times(verifiedTimes + 1));

                if (configResetVerifiedTimesMap != null) {

                    configResetVerifiedTimesMap.put(namespace, verifiedTimes + 1);

                }

            }

        }

    }



    private void noteBoot(int mitigationCount) {

        RescuePartyObserver.getInstance(mMockContext).executeBootLoopMitigation(mitigationCount);

    }