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

Commit b8280438 authored by Narayan Kamath's avatar Narayan Kamath
Browse files

Drop support for device configurable "compatibility WAL". 

WAL as a journaling mode is no longer configurable on a
per-device basis. We preserve support for changing this value
via phenotype for now, but this will likely be removed in a
follow up once this change has been vetted.

Test: atest FrameworksCoreTests:android.database
Test: atest CtsDatabaseTestCases
Bug: 123352172
Change-Id: I163bad836b71770946ce12a8bfd19f362033ea83
parent ffafec1f

api/test-current.txt

+0 −1
Original line number Diff line number Diff line
@@ -685,7 +685,6 @@ package android.database.sqlite { 
    method public static int getWALAutoCheckpoint();

    method public static int getWALConnectionPoolSize();

    method public static String getWALSyncMode();

    method public static boolean isCompatibilityWalSupported();

    method public static int releaseMemory();

  }

core/java/android/database/sqlite/SQLiteCompatibilityWalFlags.java

+16 −20
Original line number Diff line number Diff line
@@ -40,8 +40,7 @@ public class SQLiteCompatibilityWalFlags { 
    private static final String TAG = "SQLiteCompatibilityWalFlags";



    private static volatile boolean sInitialized;

    private static volatile boolean sFlagsSet;

    private static volatile boolean sCompatibilityWalSupported;

    private static volatile boolean sLegacyCompatibilityWalEnabled;

    private static volatile String sWALSyncMode;

    private static volatile long sTruncateSize = -1;

    // This flag is used to avoid recursive initialization due to circular dependency on Settings
@@ -54,26 +53,25 @@ public class SQLiteCompatibilityWalFlags { 
     * @hide

     */

    @VisibleForTesting

    public static boolean areFlagsSet() {

    public static boolean isLegacyCompatibilityWalEnabled() {

        initIfNeeded();

        return sFlagsSet;

        return sLegacyCompatibilityWalEnabled;

    }



    /**

     * @hide

     */

    @VisibleForTesting

    public static boolean isCompatibilityWalSupported() {

    public static String getWALSyncMode() {

        initIfNeeded();

        return sCompatibilityWalSupported;

        // The configurable WAL sync mode should only ever be used if the legacy compatibility

        // WAL is enabled. It should *not* have any effect if app developers explicitly turn on

        // WAL for their database using setWriteAheadLoggingEnabled. Throwing an exception here

        // adds an extra layer of checking that we never use it in the wrong place.

        if (!sLegacyCompatibilityWalEnabled) {

            throw new IllegalStateException("isLegacyCompatibilityWalEnabled() == false");

        }



    /**

     * @hide

     */

    @VisibleForTesting

    public static String getWALSyncMode() {

        initIfNeeded();

        return sWALSyncMode;

    }
@@ -131,13 +129,12 @@ public class SQLiteCompatibilityWalFlags { 
            sInitialized = true;

            return;

        }

        sCompatibilityWalSupported = parser.getBoolean("compatibility_wal_supported",

                SQLiteGlobal.isCompatibilityWalSupported());

        sLegacyCompatibilityWalEnabled = parser.getBoolean(

                "legacy_compatibility_wal_enabled", false);

        sWALSyncMode = parser.getString("wal_syncmode", SQLiteGlobal.getWALSyncMode());

        sTruncateSize = parser.getInt("truncate_size", -1);

        Log.i(TAG, "Read compatibility WAL flags: compatibility_wal_supported="

                + sCompatibilityWalSupported + ", wal_syncmode=" + sWALSyncMode);

        sFlagsSet = true;

        Log.i(TAG, "Read compatibility WAL flags: legacy_compatibility_wal_enabled="

                + sLegacyCompatibilityWalEnabled + ", wal_syncmode=" + sWALSyncMode);

        sInitialized = true;

    }
@@ -148,8 +145,7 @@ public class SQLiteCompatibilityWalFlags { 
    @TestApi

    public static void reset() {

        sInitialized = false;

        sFlagsSet = false;

        sCompatibilityWalSupported = false;

        sLegacyCompatibilityWalEnabled = false;

        sWALSyncMode = null;

    }

}

core/java/android/database/sqlite/SQLiteConnection.java

+5 −4
Original line number Diff line number Diff line
@@ -300,12 +300,13 @@ public final class SQLiteConnection implements CancellationSignal.OnCancelListen 
                    (mConfiguration.openFlags & SQLiteDatabase.ENABLE_WRITE_AHEAD_LOGGING) != 0;

            // Use compatibility WAL unless an app explicitly set journal/synchronous mode

            // or DISABLE_COMPATIBILITY_WAL flag is set

            final boolean useCompatibilityWal = mConfiguration.useCompatibilityWal();

            if (walEnabled || useCompatibilityWal) {

            final boolean isCompatibilityWalEnabled =

                    mConfiguration.isLegacyCompatibilityWalEnabled();

            if (walEnabled || isCompatibilityWalEnabled) {

                setJournalMode("WAL");

                if (mConfiguration.syncMode != null) {

                    setSyncMode(mConfiguration.syncMode);

                } else if (useCompatibilityWal && SQLiteCompatibilityWalFlags.areFlagsSet()) {

                } else if (isCompatibilityWalEnabled) {

                    setSyncMode(SQLiteCompatibilityWalFlags.getWALSyncMode());

                } else {

                    setSyncMode(SQLiteGlobal.getWALSyncMode());
@@ -504,7 +505,7 @@ public final class SQLiteConnection implements CancellationSignal.OnCancelListen 
                != mConfiguration.foreignKeyConstraintsEnabled;

        boolean walModeChanged = ((configuration.openFlags ^ mConfiguration.openFlags)

                & (SQLiteDatabase.ENABLE_WRITE_AHEAD_LOGGING

                | SQLiteDatabase.DISABLE_COMPATIBILITY_WAL)) != 0;

                | SQLiteDatabase.ENABLE_LEGACY_COMPATIBILITY_WAL)) != 0;

        boolean localeChanged = !configuration.locale.equals(mConfiguration.locale);



        // Update configuration parameters.

core/java/android/database/sqlite/SQLiteConnectionPool.java

+5 −6
Original line number Diff line number Diff line
@@ -321,7 +321,7 @@ public final class SQLiteConnectionPool implements Closeable { 
            // We should do in-place switching when transitioning from compatibility WAL

            // to rollback journal. Otherwise transient connection state will be lost

            boolean onlyCompatWalChanged = (mConfiguration.openFlags ^ configuration.openFlags)

                    == SQLiteDatabase.DISABLE_COMPATIBILITY_WAL;

                    == SQLiteDatabase.ENABLE_LEGACY_COMPATIBILITY_WAL;



            if (!onlyCompatWalChanged && mConfiguration.openFlags != configuration.openFlags) {

                // If we are changing open flags and WAL mode at the same time, then
@@ -1113,19 +1113,18 @@ public final class SQLiteConnectionPool implements Closeable { 
            if (directories != null) {

                directories.add(new File(mConfiguration.path).getParent());

            }

            boolean isCompatibilityWalEnabled = mConfiguration.isLegacyCompatibilityWalEnabled();

            printer.println("Connection pool for " + mConfiguration.path + ":");

            printer.println("  Open: " + mIsOpen);

            printer.println("  Max connections: " + mMaxConnectionPoolSize);

            printer.println("  Total execution time: " + mTotalExecutionTimeCounter);

            printer.println("  Configuration: openFlags=" + mConfiguration.openFlags

                    + ", useCompatibilityWal=" + mConfiguration.useCompatibilityWal()

                    + ", isLegacyCompatibilityWalEnabled=" + isCompatibilityWalEnabled

                    + ", journalMode=" + TextUtils.emptyIfNull(mConfiguration.journalMode)

                    + ", syncMode=" + TextUtils.emptyIfNull(mConfiguration.syncMode));



            if (SQLiteCompatibilityWalFlags.areFlagsSet()) {

                printer.println("  Compatibility WAL settings: compatibility_wal_supported="

                        + SQLiteCompatibilityWalFlags

                        .isCompatibilityWalSupported() + ", wal_syncmode="

            if (isCompatibilityWalEnabled) {

                printer.println("  Compatibility WAL enabled: wal_syncmode="

                        + SQLiteCompatibilityWalFlags.getWALSyncMode());

            }

            if (mConfiguration.isLookasideConfigSet()) {

core/java/android/database/sqlite/SQLiteDatabase.java

+17 −11
Original line number Diff line number Diff line
@@ -266,12 +266,17 @@ public final class SQLiteDatabase extends SQLiteClosable { 
     */

    public static final int ENABLE_WRITE_AHEAD_LOGGING = 0x20000000;





    // Note: The below value was only used on Android Pie.

    // public static final int DISABLE_COMPATIBILITY_WAL = 0x40000000;



    /**

     * Open flag: Flag for {@link #openDatabase} to disable Compatibility WAL when opening database.

     * Open flag: Flag for {@link #openDatabase} to enable the legacy Compatibility WAL when opening

     * database.

     *

     * @hide

     */

    public static final int DISABLE_COMPATIBILITY_WAL = 0x40000000;

    public static final int ENABLE_LEGACY_COMPATIBILITY_WAL = 0x80000000;



    /**

     * Absolute max value that can be set by {@link #setMaxSqlCacheSize(int)}.
@@ -309,10 +314,8 @@ public final class SQLiteDatabase extends SQLiteClosable { 
        mConfigurationLocked.idleConnectionTimeoutMs = effectiveTimeoutMs;

        mConfigurationLocked.journalMode = journalMode;

        mConfigurationLocked.syncMode = syncMode;

        if (!SQLiteGlobal.isCompatibilityWalSupported() || (

                SQLiteCompatibilityWalFlags.areFlagsSet() && !SQLiteCompatibilityWalFlags

                        .isCompatibilityWalSupported())) {

            mConfigurationLocked.openFlags |= DISABLE_COMPATIBILITY_WAL;

        if (SQLiteCompatibilityWalFlags.isLegacyCompatibilityWalEnabled()) {

            mConfigurationLocked.openFlags |= ENABLE_LEGACY_COMPATIBILITY_WAL;

        }

    }
@@ -2123,15 +2126,18 @@ public final class SQLiteDatabase extends SQLiteClosable { 
            throwIfNotOpenLocked();



            final int oldFlags = mConfigurationLocked.openFlags;

            final boolean walDisabled = (oldFlags & ENABLE_WRITE_AHEAD_LOGGING) == 0;

            final boolean compatibilityWalDisabled = (oldFlags & DISABLE_COMPATIBILITY_WAL) != 0;

            if (walDisabled && compatibilityWalDisabled) {

            final boolean walEnabled = (oldFlags & ENABLE_WRITE_AHEAD_LOGGING) != 0;

            final boolean compatibilityWalEnabled =

                    (oldFlags & ENABLE_LEGACY_COMPATIBILITY_WAL) != 0;

            // WAL was never enabled for this database, so there's nothing left to do.

            if (!walEnabled && !compatibilityWalEnabled) {

                return;

            }



            // If an app explicitly disables WAL, it takes priority over any directive

            // to use the legacy "compatibility WAL" mode.

            mConfigurationLocked.openFlags &= ~ENABLE_WRITE_AHEAD_LOGGING;

            // If an app explicitly disables WAL, compatibility mode should be disabled too

            mConfigurationLocked.openFlags |= DISABLE_COMPATIBILITY_WAL;

            mConfigurationLocked.openFlags &= ~ENABLE_LEGACY_COMPATIBILITY_WAL;



            try {

                mConnectionPoolLocked.reconfigure(mConfigurationLocked);