xref: /packages/providers/MediaProvider/src/com/android/providers/media/fuse/FuseDaemon.java

/*
 * Copyright (C) 2019 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.providers.media.fuse;

import android.os.ParcelFileDescriptor;
import android.util.Log;

import androidx.annotation.NonNull;

import com.android.internal.annotations.GuardedBy;
import com.android.providers.media.FdAccessResult;
import com.android.providers.media.MediaProvider;
import com.android.providers.media.util.FileUtils;

import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.Objects;

/**
 * Starts a FUSE session to handle FUSE messages from the kernel.
 */
public final class FuseDaemon extends Thread {
    public static final String TAG = "FuseDaemonThread";
    private static final int POLL_INTERVAL_MS = 100;
    private static final int POLL_COUNT = 50;

    private final Object mLock = new Object();
    private final MediaProvider mMediaProvider;
    private final int mFuseDeviceFd;
    private final String mPath;
    private final boolean mUncachedMode;
    private final String[] mSupportedTranscodingRelativePaths;
    private final String[] mSupportedUncachedRelativePaths;
    private final ExternalStorageServiceImpl mService;
    @GuardedBy("mLock")
    private long mPtr;

    public FuseDaemon(@NonNull MediaProvider mediaProvider,
            @NonNull ExternalStorageServiceImpl service, @NonNull ParcelFileDescriptor fd,
            @NonNull String sessionId, @NonNull String path, boolean uncachedMode,
            String[] supportedTranscodingRelativePaths, String[] supportedUncachedRelativePaths) {
        mMediaProvider = Objects.requireNonNull(mediaProvider);
        mService = Objects.requireNonNull(service);
        setName(Objects.requireNonNull(sessionId));
        mFuseDeviceFd = Objects.requireNonNull(fd).detachFd();
        mPath = Objects.requireNonNull(path);
        mUncachedMode = uncachedMode;
        mSupportedTranscodingRelativePaths
                = Objects.requireNonNull(supportedTranscodingRelativePaths);
        mSupportedUncachedRelativePaths
                = Objects.requireNonNull(supportedUncachedRelativePaths);
    }

    /** Starts a FUSE session. Does not return until the lower filesystem is unmounted. */
    @Override
    public void run() {
        final long ptr;
        synchronized (mLock) {
            mPtr = native_new(mMediaProvider);
            if (mPtr == 0) {
                throw new IllegalStateException("Unable to create native FUSE daemon");
            }
            ptr = mPtr;
        }

        Log.i(TAG, "Starting thread for " + getName() + " ...");
        native_start(ptr, mFuseDeviceFd, mPath, mUncachedMode,
                mSupportedTranscodingRelativePaths,
                mSupportedUncachedRelativePaths); // Blocks
        Log.i(TAG, "Exiting thread for " + getName() + " ...");

        synchronized (mLock) {
            native_delete(mPtr);
            mPtr = 0;
        }
        mService.onExitSession(getName());
        Log.i(TAG, "Exited thread for " + getName());
    }

    @Override
    public synchronized void start() {
        super.start();

        // Wait for native_start
        waitForStart();

        // Initialize device id
        initializeDeviceId();
    }

    private void initializeDeviceId() {
        synchronized (mLock) {
            if (mPtr == 0) {
                Log.e(TAG, "initializeDeviceId failed, FUSE daemon unavailable");
                return;
            }
            String path = FileUtils.toFuseFile(new File(mPath)).getAbsolutePath();
            native_initialize_device_id(mPtr, path);
        }
    }

    private void waitForStart() {
        int count = POLL_COUNT;
        while (count-- > 0) {
            synchronized (mLock) {
                if (mPtr != 0 && native_is_started(mPtr)) {
                    return;
                }
            }
            try {
                Log.v(TAG, "Waiting " + POLL_INTERVAL_MS + "ms for FUSE start. Count " + count);
                Thread.sleep(POLL_INTERVAL_MS);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                Log.e(TAG, "Interrupted while starting FUSE", e);
            }
        }
        throw new IllegalStateException("Failed to start FUSE");
    }

    /** Waits for any running FUSE sessions to return. */
    public void waitForExit() {
        int waitMs = POLL_COUNT * POLL_INTERVAL_MS;
        Log.i(TAG, "Waiting " + waitMs + "ms for FUSE " + getName() + " to exit...");

        try {
            join(waitMs);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new IllegalStateException("Interrupted while terminating FUSE " + getName());
        }

        if (isAlive()) {
            throw new IllegalStateException("Failed to exit FUSE " + getName() + " successfully");
        }

        Log.i(TAG, "Exited FUSE " + getName() + " successfully");
    }

    /**
     * Checks if file with {@code path} should be opened via FUSE to avoid cache inconcistencies.
     * May place a F_RDLCK or F_WRLCK with fcntl(2) depending on {@code readLock}
     *
     * @return {@code true} if the file should be opened via FUSE, {@code false} otherwise
     */
    public boolean shouldOpenWithFuse(String path, boolean readLock, int fd) {
        synchronized (mLock) {
            if (mPtr == 0) {
                Log.i(TAG, "shouldOpenWithFuse failed, FUSE daemon unavailable");
                return false;
            }
            return native_should_open_with_fuse(mPtr, path, readLock, fd);
        }
    }

    /**
     * Checks if the FuseDaemon uses the FUSE passthrough feature.
     *
     * @return {@code true} if the FuseDaemon uses FUSE passthrough, {@code false} otherwise
     */
    public boolean usesFusePassthrough() {
        synchronized (mLock) {
            if (mPtr == 0) {
                Log.i(TAG, "usesFusePassthrough failed, FUSE daemon unavailable");
                return false;
            }
            return native_uses_fuse_passthrough(mPtr);
        }
    }

    /**
     * Invalidates FUSE VFS dentry cache for {@code path}
     */
    public void invalidateFuseDentryCache(String path) {
        synchronized (mLock) {
            if (mPtr == 0) {
                Log.i(TAG, "invalidateFuseDentryCache failed, FUSE daemon unavailable");
                return;
            }
            native_invalidate_fuse_dentry_cache(mPtr, path);
        }
    }

    public FdAccessResult checkFdAccess(ParcelFileDescriptor fileDescriptor, int uid)
            throws IOException {
        synchronized (mLock) {
            if (mPtr == 0) {
                throw new IOException("FUSE daemon unavailable");
            }
            return native_check_fd_access(mPtr, fileDescriptor.getFd(), uid);
        }
    }

    /**
     * Sets up volume's database backup to external storage to recover during a rollback.
     */
    public void setupVolumeDbBackup() throws IOException {
        synchronized (mLock) {
            if (mPtr == 0) {
                throw new IOException("FUSE daemon unavailable");
            }
            native_setup_volume_db_backup(mPtr);
        }
    }

    /**
     * Sets up public volume's database backup to external storage to recover during a rollback.
     */
    public void setupPublicVolumeDbBackup(String volumeName) throws IOException {
        synchronized (mLock) {
            if (mPtr == 0) {
                throw new IOException("FUSE daemon unavailable");
            }
            native_setup_public_volume_db_backup(mPtr, volumeName);
        }
    }

    /**
     * Deletes entry for given key from external storage.
     */
    public void deleteDbBackup(String key) throws IOException {
        synchronized (mLock) {
            if (mPtr == 0) {
                throw new IOException("FUSE daemon unavailable");
            }
            native_delete_db_backup(mPtr, key);
        }
    }

    /**
     * Backs up given key-value pair in external storage for provided volume.
     */
    public void backupVolumeDbData(String volumeName, String key, String value) throws IOException {
        synchronized (mLock) {
            if (mPtr == 0) {
                throw new IOException("FUSE daemon unavailable");
            }
            native_backup_volume_db_data(mPtr, volumeName, key, value);
        }
    }

    /**
     * Reads backed up file paths for given volume from external storage.
     */
    public String[] readBackedUpFilePaths(String volumeName, String lastReadValue, int limit)
            throws IOException {
        synchronized (mLock) {
            if (mPtr == 0) {
                throw new IOException("FUSE daemon unavailable");
            }
            return native_read_backed_up_file_paths(mPtr, volumeName, lastReadValue, limit);
        }
    }

    /**
     * Reads backed up data for given file from external storage.
     */
    public String readBackedUpData(String filePath) throws IOException {
        synchronized (mLock) {
            if (mPtr == 0) {
                throw new IOException("FUSE daemon unavailable");
            }
            return native_read_backed_up_data(mPtr, filePath);
        }
    }

    /**
     * Reads owner id for given owner package identifier from external storage.
     */
    public String readFromOwnershipBackup(String ownerPackageIdentifier) throws IOException {
        synchronized (mLock) {
            if (mPtr == 0) {
                throw new IOException("FUSE daemon unavailable");
            }
            return native_read_ownership(mPtr, ownerPackageIdentifier);
        }
    }

    /**
     * Creates owner id to owner package identifier and vice versa relation in external storage.
     */
    public void createOwnerIdRelation(String ownerId, String ownerPackageIdentifier)
            throws IOException {
        synchronized (mLock) {
            if (mPtr == 0) {
                throw new IOException("FUSE daemon unavailable");
            }
            native_create_owner_id_relation(mPtr, ownerId, ownerPackageIdentifier);
        }
    }

    /**
     * Removes owner id to owner package identifier and vice versa relation in external storage.
     */
    public void removeOwnerIdRelation(String ownerId, String ownerPackageIdentifier)
            throws IOException {
        synchronized (mLock) {
            if (mPtr == 0) {
                throw new IOException("FUSE daemon unavailable");
            }
            native_remove_owner_id_relation(mPtr, ownerId, ownerPackageIdentifier);
        }
    }

    /**
     * Reads all owner id relations from external storage.
     */
    public HashMap<String, String> readOwnerIdRelations() throws IOException {
        synchronized (mLock) {
            if (mPtr == 0) {
                throw new IOException("FUSE daemon unavailable");
            }
            return native_read_owner_relations(mPtr);
        }
    }

    private native long native_new(MediaProvider mediaProvider);

    // Takes ownership of the passed in file descriptor!
    private native void native_start(long daemon, int deviceFd, String path,
            boolean uncachedMode, String[] supportedTranscodingRelativePaths,
            String[] supportedUncachedRelativePaths);

    private native void native_delete(long daemon);
    private native boolean native_should_open_with_fuse(long daemon, String path, boolean readLock,
            int fd);
    private native boolean native_uses_fuse_passthrough(long daemon);
    private native void native_invalidate_fuse_dentry_cache(long daemon, String path);
    private native boolean native_is_started(long daemon);
    private native FdAccessResult native_check_fd_access(long daemon, int fd, int uid);
    private native void native_initialize_device_id(long daemon, String path);
    private native void native_setup_volume_db_backup(long daemon);
    private native void native_setup_public_volume_db_backup(long daemon, String volumeName);
    private native void native_delete_db_backup(long daemon, String key);
    private native void native_backup_volume_db_data(long daemon, String volumeName, String key,
            String value);
    private native String[] native_read_backed_up_file_paths(long daemon, String volumeName,
            String lastReadValue, int limit);
    private native String native_read_backed_up_data(long daemon, String key);
    private native String native_read_ownership(long daemon, String ownerPackageIdentifier);
    private native void native_create_owner_id_relation(long daemon, String ownerId,
            String ownerPackageIdentifier);
    private native void native_remove_owner_id_relation(long daemon, String ownerId,
            String ownerPackageIdentifier);
    private native HashMap<String, String> native_read_owner_relations(long daemon);
    public static native boolean native_is_fuse_thread();
}