Ext4ExtensionFileSystem.swift

// This file is part of ExtendFS which is released under the GNU GPL v3 or later license with an app store exception.
// See the LICENSE file in the root of the repository for full license details.

import Foundation
import FSKit
import UserNotifications

@objc
final class Ext4ExtensionFileSystem: FSUnaryFileSystem & FSUnaryFileSystemOperations {
    static let logger = Logger(subsystem: "com.kpchew.ExtendFS.ext4Extension", category: "Ext4Extension")
    
    @MainActor weak var resource: FSBlockDeviceResource?
    @MainActor weak var volume: Ext4Volume?
    
    @MainActor func setResources(resource: FSBlockDeviceResource?, volume: Ext4Volume?) {
        self.resource = resource
        self.volume = volume
    }
    
    @MainActor func setContainerStatus(_ status: FSContainerStatus) {
        self.containerStatus = status
    }
    
    func sendNotification(title: String, body: String, interruptionLevel: UNNotificationInterruptionLevel = .active) {
        // TODO: not in release build for now until user-accessible settings are available for this
        #if DEBUG
        Task.detached {
            let content = UNMutableNotificationContent()
            content.title = title
            content.body = body
            content.interruptionLevel = interruptionLevel
            let request = UNNotificationRequest(identifier: UUID().uuidString, content: content, trigger: nil)
            let notificationCenter = UNUserNotificationCenter.current()
            do {
                try await notificationCenter.requestAuthorization(options: [.alert])
                try await notificationCenter.add(request)
            } catch {
                Self.logger.error("Couldn't send notification: \(error)")
            }
        }
        #endif
    }
    
    func probeResource(resource: FSResource) async throws -> FSProbeResult {
        Self.logger.log("Probing resource")
        guard let resource = resource as? FSBlockDeviceResource else {
            Self.logger.log("Not block device")
            return .notRecognized
        }
        
        guard let superblock = try Superblock(blockDevice: resource, offset: 1024) else {
            Self.logger.error("Could not read superblock from resource")
            
            var data = Data(count: 1024)
            let readCount = try data.withUnsafeMutableBytes { buffer in
                return try resource.read(into: buffer, startingAt: 0, length: 1024)
            }
            let potentialLuksSignature = String(data: data.subdata(in: 0..<4), encoding: .ascii)
            let potentialLVMSignature = String(data: data.subdata(in: 536..<544), encoding: .ascii)
            if readCount >= 6 && potentialLuksSignature == "LUKS" && data[4] == 0xBA && data[5] == 0xBE {
                Self.logger.error("Disk can't be mounted - LUKS")
                sendNotification(title: "Unsupported Disk", body: "Disk \(resource.bsdName) can't be mounted because it is encrypted with LUKS, which is currently unsupported.")
            } else if readCount >= 1024 && potentialLVMSignature == "LVM2 001" {
                Self.logger.error("Disk can't be mounted - LVM")
                sendNotification(title: "Unsupported Disk", body: "Disk \(resource.bsdName) can't be mounted because it uses LVM, which is currently unsupported.")
            } else {
                Self.logger.error("Disk can't be mounted - not ext2/3/4")
            }
            
            return .notRecognized
        }
        if superblock.magic == 0xEF53 {
            let name = String(data: superblock.volumeName ?? Data(), encoding: .utf8) ?? ""
            let uuid = superblock.uuid ?? UUID()
            // seems like recognized and usableButLimited are treated like notRecognized as of macOS 15.6 (24G84)
            guard superblock.incompatibleFeatures.isSubset(of: Superblock.IncompatibleFeatures.supportedFeatures) else {
                Self.logger.log("Recognized but not usable")
                Self.logger.error("Disk can't be mounted - incompatible features")
                sendNotification(title: "Unsupported Disk", body: "Disk \"\(name)\" was recognized as an ext2/3/4 volume, but can't be mounted because it uses incompatible features.")
                return .recognized(name: name, containerID: FSContainerIdentifier(uuid: uuid))
            }
            
            // FIXME: once FB19241327 is fixed, uncomment these and apply them to the fixed OS version
//            if #available(macOS 26.4, *) {
//                let incompatibleFeaturesForcingReadOnly: Superblock.IncompatibleFeatures = [.needsRecovery, .separateJournalDevice, .multipleMountProtection]
//                guard superblock.incompatibleFeatures.isDisjoint(with: incompatibleFeaturesForcingReadOnly) else {
//                    Self.logger.log("Usable but limited")
//                    return .usableButLimited(name: name, containerID: FSContainerIdentifier(uuid: uuid))
//                }
//                guard superblock.readOnlyCompatibleFeatures.isSubset(of: Superblock.ReadOnlyCompatibleFeatures.supportedFeatures) else {
//                    Self.logger.log("Usable but limited")
//                    return .usableButLimited(name: name, containerID: FSContainerIdentifier(uuid: uuid))
//                }
//            }
            
            if superblock.state.contains(.errorsDetected) {
                Self.logger.log("Errors detected on volume.")
                let errorPolicy = superblock.errorPolicy
                switch errorPolicy {
                case .continue:
                    Self.logger.log("Error policy set to continue, continuing as normal.")
                    break
                case .remountReadOnly:
                    Self.logger.log("Error policy set to remount as read-only, indicating usable but limited.")
//                    if #available(macOS 26.4, *) {
//                        return .usableButLimited(name: name, containerID: FSContainerIdentifier(uuid: uuid))
//                    } else {
//                        return .usable(name: name, containerID: FSContainerIdentifier(uuid: uuid))
//                    }
                    return .usable(name: name, containerID: FSContainerIdentifier(uuid: uuid))
                case .panic:
                    Self.logger.error("Error policy set to panic, indicating recognized but not usable.")
                    sendNotification(title: "Unsupported Disk", body: "Disk \"\(name)\" can't be mounted because it contains errors and the error policy is set to panic.")
                    return .recognized(name: name, containerID: FSContainerIdentifier(uuid: uuid))
                case .unknown:
                    Self.logger.error("Error policy is not recognized.")
                    sendNotification(title: "Unsupported Disk", body: "Disk \"\(name)\" can't be mounted because the error policy is unknown.")
                    return .recognized(name: name, containerID: FSContainerIdentifier(uuid: uuid))
                }
            }
            
            return .usable(name: name, containerID: FSContainerIdentifier(uuid: uuid))
        } else {
            Self.logger.error("Disk can't be mounted - invalid superblock magic")
            sendNotification(title: "Unsupported Disk", body: "Disk \(resource.bsdName) is not a valid ext2/3/4 volume.")
            return .notRecognized
        }
    }

    func loadResource(resource: FSResource, options: FSTaskOptions) async throws -> FSVolume {
        // FIXME: do I need to check probe result here?
        Self.logger.log("Loading resource")
        let probeResult = try await probeResource(resource: resource)
        var readOnly: Bool
        switch probeResult.result {
        case .notRecognized:
            Self.logger.log("Invalid resource")
            await setContainerStatus(.blocked(status: FSError(.resourceUnrecognized)))
            throw FSError(.resourceUnrecognized)
        case .recognized:
            Self.logger.log("Recognized but can't mount")
            await setContainerStatus(.blocked(status: FSError(.resourceUnusable)))
            throw FSError(.resourceUnusable)
        case .usableButLimited:
            readOnly = true
        case .usable:
            readOnly = true // write not supported atm
        @unknown default:
            Self.logger.log("Unknown probe result")
            await setContainerStatus(.blocked(status: FSError(.resourceUnrecognized)))
            throw FSError(.resourceUnrecognized)
        }
        
        guard let resource = resource as? FSBlockDeviceResource else {
            Self.logger.log("Not a block resource")
            await setContainerStatus(.blocked(status: FSError(.resourceUnrecognized)))
            throw FSError(.resourceUnrecognized)
        }
        
        Self.logger.log("load options: \(options.taskOptions, privacy: .public)")
        for option in options.taskOptions {
            switch option {
            case "-f":
                continue
            case "--rdonly":
                Self.logger.log("Read only option provided")
                readOnly = true
            default:
                continue
            }
        }
        
        let volume = try await Ext4Volume(resource: resource, fileSystem: self, readOnly: readOnly)
        await setResources(resource: resource, volume: volume)
        await setContainerStatus(.ready)
        Self.logger.log("Container status ready")
        BlockDeviceReader.useMetadataRead = true
        return volume
    }

    func unloadResource(resource: FSResource, options: FSTaskOptions) async throws {
        Self.logger.log("Unloading resource")
        await setResources(resource: nil, volume: nil)
        await setContainerStatus(.notReady(status: POSIXError(.EAGAIN)))
        return
    }
    
    func didFinishLoading() {
        Self.logger.log("did finish loading")
    }
}

extension Ext4ExtensionFileSystem: FSManageableResourceMaintenanceOperations {
    @MainActor private static func quickCheck(volume: Ext4Volume, task: FSTask) throws {
        let superblock = volume.superblock
        guard superblock.magic == 0xEF53 else {
            task.logMessage("Magic value in superblock did not match expectation. Is this an ext volume?")
            throw POSIXError(.EDEVERR)
        }
        
        if superblock.incompatibleFeatures.contains(.needsRecovery) {
            Self.logger.error("Recovery feature present on disk.")
            throw POSIXError(.EDEVERR)
        }
        
        if superblock.state.contains(.errorsDetected) {
            switch superblock.errorPolicy {
            case .continue:
                break
            case .remountReadOnly:
                break
            case .panic:
                Self.logger.error("Errors detected on disk, and error policy is to panic.")
                throw POSIXError(.EDEVERR)
            case .unknown:
                Self.logger.error("Errors detected on disk, and error policy is unknown.")
                throw POSIXError(.EDEVERR)
            }
        }
        
        if superblock.readOnlyCompatibleFeatures.contains(.supportsMetadataChecksumming) {
            let calculatedChecksum = try superblock.calculateChecksum()
            
            guard let storedChecksum = superblock.checksum, storedChecksum == calculatedChecksum else {
                Self.logger.error("Checksum found on superblock does not match expected value.")
                throw POSIXError(.EDEVERR)
            }
        }
        
    }
    
    /// Makes a "shadow file" of the provided volume.
    ///
    /// A shadow file contains the metadata for the volume, but excludes file data. It is intended to be included in bug reports for hard-to-debug issues.
    /// - Parameters:
    ///   - destination: The directory at which the shadow file should be created.
    ///   - volume: The volume to create a shadow file of.
    ///   - task: The task associated with the check operation that initiated this request.
    private static func makeShadowFile(at destination: URL, volume: Ext4Volume, task: FSTask) async throws {
        #if DEBUG
        let name = "shadow-\(volume.resource.bsdName)"
        let shadowURL = destination.appendingPathComponent(name)
        FileManager.default.createFile(atPath: shadowURL.path(percentEncoded: false), contents: nil)
        // TODO: implement once url options are fixed
        #else
        task.logMessage("Shadow file requested, but this function is not implemented yet. Ignoring.")
        #endif
    }
    
    /// A type of check that can be performed.
    enum CheckType {
        /// A quick, surface-level check.
        case quick
        /// A more complete check.
        ///
        /// Not currently supported.
        case full
    }
    
    func startCheck(task: FSTask, options: FSTaskOptions) throws -> Progress {
        let yes = options.taskOptions.contains("-y")
        let makeShadow = options.taskOptions.contains("-S")
        
        var checkType: CheckType = .full
        for option in options.taskOptions {
            switch option {
            case "-q":
                checkType = .quick
                break
            default:
                continue
            }
        }
        
        if yes {
            task.logMessage("-y option provided, but ExtendFS is read-only. Ignoring option.")
        }
        if checkType == .full {
            task.logMessage("Full check requested, but ExtendFS only supports simple quick checks. A quick check will be run.")
            checkType = .quick
        }
        
        let progress = Progress(totalUnitCount: 100)
        Task {
            await setContainerStatus(.active)
            guard let volume = await volume else {
                await setContainerStatus(.notReady(status: FSError(.resourceDamaged)))
                task.didComplete(error: FSError(.resourceDamaged))
                return
            }
            
            defer {
                progress.completedUnitCount = 100
            }
            
            if makeShadow {
                if let destination = options.url(forOption: "S"), destination.startAccessingSecurityScopedResource() {
                    defer {
                        destination.stopAccessingSecurityScopedResource()
                    }
                    
                    try await Self.makeShadowFile(at: destination, volume: volume, task: task)
                } else {
                    task.logMessage("No valid directory provided to -S option. Shadow file not being created.")
                }
            }
            
            switch checkType {
            case .quick:
                do {
                    try await Self.quickCheck(volume: volume, task: task)
                    await setContainerStatus(.ready)
                    task.didComplete(error: nil)
                } catch {
                    await setContainerStatus(.notReady(status: FSError(.resourceDamaged)))
                    task.didComplete(error: error)
                }
            case .full:
                do {
                    try await Self.quickCheck(volume: volume, task: task)
                    await setContainerStatus(.ready)
                    task.didComplete(error: nil)
                } catch {
                    await setContainerStatus(.notReady(status: FSError(.resourceDamaged)))
                    task.didComplete(error: error)
                }
            }
        }
        return progress
    }
    
    func startFormat(task: FSTask, options: FSTaskOptions) throws -> Progress {
        throw POSIXError(.ENOSYS)
    }
}