// SPDX-License-Identifier: GPL-2.0

#include <linux/crc32.h>
#include "messages.h"
#include "fs.h"
#include "accessors.h"
#include "volumes.h"

static const struct btrfs_csums {
        u16             size;
        const char      name[10];
} btrfs_csums[] = {
        [BTRFS_CSUM_TYPE_CRC32] = { .size = 4, .name = "crc32c" },
        [BTRFS_CSUM_TYPE_XXHASH] = { .size = 8, .name = "xxhash64" },
        [BTRFS_CSUM_TYPE_SHA256] = { .size = 32, .name = "sha256" },
        [BTRFS_CSUM_TYPE_BLAKE2] = { .size = 32, .name = "blake2b" },
};

/* This exists for btrfs-progs usages. */
u16 btrfs_csum_type_size(u16 type)
{
        return btrfs_csums[type].size;
}

int btrfs_super_csum_size(const struct btrfs_super_block *s)
{
        u16 t = btrfs_super_csum_type(s);

        /* csum type is validated at mount time. */
        return btrfs_csum_type_size(t);
}

const char *btrfs_super_csum_name(u16 csum_type)
{
        /* csum type is validated at mount time. */
        return btrfs_csums[csum_type].name;
}

size_t __attribute_const__ btrfs_get_num_csums(void)
{
        return ARRAY_SIZE(btrfs_csums);
}

void btrfs_csum(u16 csum_type, const u8 *data, size_t len, u8 *out)
{
        switch (csum_type) {
        case BTRFS_CSUM_TYPE_CRC32:
                put_unaligned_le32(~crc32c(~0, data, len), out);
                break;
        case BTRFS_CSUM_TYPE_XXHASH:
                put_unaligned_le64(xxh64(data, len, 0), out);
                break;
        case BTRFS_CSUM_TYPE_SHA256:
                sha256(data, len, out);
                break;
        case BTRFS_CSUM_TYPE_BLAKE2:
                blake2b(NULL, 0, data, len, out, 32);
                break;
        default:
                /* Checksum type is validated at mount time. */
                BUG();
        }
}

void btrfs_csum_init(struct btrfs_csum_ctx *ctx, u16 csum_type)
{
        ctx->csum_type = csum_type;
        switch (ctx->csum_type) {
        case BTRFS_CSUM_TYPE_CRC32:
                ctx->crc32 = ~0;
                break;
        case BTRFS_CSUM_TYPE_XXHASH:
                xxh64_reset(&ctx->xxh64, 0);
                break;
        case BTRFS_CSUM_TYPE_SHA256:
                sha256_init(&ctx->sha256);
                break;
        case BTRFS_CSUM_TYPE_BLAKE2:
                blake2b_init(&ctx->blake2b, 32);
                break;
        default:
                /* Checksume type is validated at mount time. */
                BUG();
        }
}

void btrfs_csum_update(struct btrfs_csum_ctx *ctx, const u8 *data, size_t len)
{
        switch (ctx->csum_type) {
        case BTRFS_CSUM_TYPE_CRC32:
                ctx->crc32 = crc32c(ctx->crc32, data, len);
                break;
        case BTRFS_CSUM_TYPE_XXHASH:
                xxh64_update(&ctx->xxh64, data, len);
                break;
        case BTRFS_CSUM_TYPE_SHA256:
                sha256_update(&ctx->sha256, data, len);
                break;
        case BTRFS_CSUM_TYPE_BLAKE2:
                blake2b_update(&ctx->blake2b, data, len);
                break;
        default:
                /* Checksum type is validated at mount time. */
                BUG();
        }
}

void btrfs_csum_final(struct btrfs_csum_ctx *ctx, u8 *out)
{
        switch (ctx->csum_type) {
        case BTRFS_CSUM_TYPE_CRC32:
                put_unaligned_le32(~ctx->crc32, out);
                break;
        case BTRFS_CSUM_TYPE_XXHASH:
                put_unaligned_le64(xxh64_digest(&ctx->xxh64), out);
                break;
        case BTRFS_CSUM_TYPE_SHA256:
                sha256_final(&ctx->sha256, out);
                break;
        case BTRFS_CSUM_TYPE_BLAKE2:
                blake2b_final(&ctx->blake2b, out);
                break;
        default:
                /* Checksum type is validated at mount time. */
                BUG();
        }
}

/*
 * We support the following block sizes for all systems:
 *
 * - 4K
 *   This is the most common block size. For PAGE SIZE > 4K cases the subpage
 *   mode is used.
 *
 * - PAGE_SIZE
 *   The straightforward block size to support.
 *
 * And extra support for the following block sizes based on the kernel config:
 *
 * - MIN_BLOCKSIZE
 *   This is either 4K (regular builds) or 2K (debug builds)
 *   This allows testing subpage routines on x86_64.
 */
bool __attribute_const__ btrfs_supported_blocksize(u32 blocksize)
{
        /* @blocksize should be validated first. */
        ASSERT(is_power_of_2(blocksize) && blocksize >= BTRFS_MIN_BLOCKSIZE &&
               blocksize <= BTRFS_MAX_BLOCKSIZE);

        if (blocksize == PAGE_SIZE || blocksize == SZ_4K || blocksize == BTRFS_MIN_BLOCKSIZE)
                return true;
#ifdef CONFIG_BTRFS_EXPERIMENTAL
        /*
         * For bs > ps support it's done by specifying a minimal folio order
         * for filemap, thus implying large data folios.
         * For HIGHMEM systems, we can not always access the content of a (large)
         * folio in one go, but go through them page by page.
         *
         * A lot of features don't implement a proper PAGE sized loop for large
         * folios, this includes:
         *
         * - compression
         * - verity
         * - encoded write
         *
         * Considering HIGHMEM is such a pain to deal with and it's going
         * to be deprecated eventually, just reject HIGHMEM && bs > ps cases.
         */
        if (IS_ENABLED(CONFIG_HIGHMEM) && blocksize > PAGE_SIZE)
                return false;
        return true;
#endif
        return false;
}

/*
 * Start exclusive operation @type, return true on success.
 */
bool btrfs_exclop_start(struct btrfs_fs_info *fs_info,
                        enum btrfs_exclusive_operation type)
{
        bool ret = false;

        spin_lock(&fs_info->super_lock);
        if (fs_info->exclusive_operation == BTRFS_EXCLOP_NONE) {
                fs_info->exclusive_operation = type;
                ret = true;
        }
        spin_unlock(&fs_info->super_lock);

        return ret;
}

/*
 * Conditionally allow to enter the exclusive operation in case it's compatible
 * with the running one.  This must be paired with btrfs_exclop_start_unlock()
 * and btrfs_exclop_finish().
 *
 * Compatibility:
 * - the same type is already running
 * - when trying to add a device and balance has been paused
 * - not BTRFS_EXCLOP_NONE - this is intentionally incompatible and the caller
 *   must check the condition first that would allow none -> @type
 */
bool btrfs_exclop_start_try_lock(struct btrfs_fs_info *fs_info,
                                 enum btrfs_exclusive_operation type)
{
        spin_lock(&fs_info->super_lock);
        if (fs_info->exclusive_operation == type ||
            (fs_info->exclusive_operation == BTRFS_EXCLOP_BALANCE_PAUSED &&
             type == BTRFS_EXCLOP_DEV_ADD))
                return true;

        spin_unlock(&fs_info->super_lock);
        return false;
}

void btrfs_exclop_start_unlock(struct btrfs_fs_info *fs_info)
{
        spin_unlock(&fs_info->super_lock);
}

void btrfs_exclop_finish(struct btrfs_fs_info *fs_info)
{
        spin_lock(&fs_info->super_lock);
        WRITE_ONCE(fs_info->exclusive_operation, BTRFS_EXCLOP_NONE);
        spin_unlock(&fs_info->super_lock);
        sysfs_notify(&fs_info->fs_devices->fsid_kobj, NULL, "exclusive_operation");
}

void btrfs_exclop_balance(struct btrfs_fs_info *fs_info,
                          enum btrfs_exclusive_operation op)
{
        switch (op) {
        case BTRFS_EXCLOP_BALANCE_PAUSED:
                spin_lock(&fs_info->super_lock);
                ASSERT(fs_info->exclusive_operation == BTRFS_EXCLOP_BALANCE ||
                       fs_info->exclusive_operation == BTRFS_EXCLOP_DEV_ADD ||
                       fs_info->exclusive_operation == BTRFS_EXCLOP_NONE ||
                       fs_info->exclusive_operation == BTRFS_EXCLOP_BALANCE_PAUSED);
                fs_info->exclusive_operation = BTRFS_EXCLOP_BALANCE_PAUSED;
                spin_unlock(&fs_info->super_lock);
                break;
        case BTRFS_EXCLOP_BALANCE:
                spin_lock(&fs_info->super_lock);
                ASSERT(fs_info->exclusive_operation == BTRFS_EXCLOP_BALANCE_PAUSED);
                fs_info->exclusive_operation = BTRFS_EXCLOP_BALANCE;
                spin_unlock(&fs_info->super_lock);
                break;
        default:
                btrfs_warn(fs_info,
                        "invalid exclop balance operation %d requested", op);
        }
}

void __btrfs_set_fs_incompat(struct btrfs_fs_info *fs_info, u64 flag,
                             const char *name)
{
        struct btrfs_super_block *disk_super;
        u64 features;

        disk_super = fs_info->super_copy;
        features = btrfs_super_incompat_flags(disk_super);
        if (!(features & flag)) {
                spin_lock(&fs_info->super_lock);
                features = btrfs_super_incompat_flags(disk_super);
                if (!(features & flag)) {
                        features |= flag;
                        btrfs_set_super_incompat_flags(disk_super, features);
                        btrfs_info(fs_info,
                                "setting incompat feature flag for %s (0x%llx)",
                                name, flag);
                }
                spin_unlock(&fs_info->super_lock);
                set_bit(BTRFS_FS_FEATURE_CHANGED, &fs_info->flags);
        }
}

void __btrfs_clear_fs_incompat(struct btrfs_fs_info *fs_info, u64 flag,
                               const char *name)
{
        struct btrfs_super_block *disk_super;
        u64 features;

        disk_super = fs_info->super_copy;
        features = btrfs_super_incompat_flags(disk_super);
        if (features & flag) {
                spin_lock(&fs_info->super_lock);
                features = btrfs_super_incompat_flags(disk_super);
                if (features & flag) {
                        features &= ~flag;
                        btrfs_set_super_incompat_flags(disk_super, features);
                        btrfs_info(fs_info,
                                "clearing incompat feature flag for %s (0x%llx)",
                                name, flag);
                }
                spin_unlock(&fs_info->super_lock);
                set_bit(BTRFS_FS_FEATURE_CHANGED, &fs_info->flags);
        }
}

void __btrfs_set_fs_compat_ro(struct btrfs_fs_info *fs_info, u64 flag,
                              const char *name)
{
        struct btrfs_super_block *disk_super;
        u64 features;

        disk_super = fs_info->super_copy;
        features = btrfs_super_compat_ro_flags(disk_super);
        if (!(features & flag)) {
                spin_lock(&fs_info->super_lock);
                features = btrfs_super_compat_ro_flags(disk_super);
                if (!(features & flag)) {
                        features |= flag;
                        btrfs_set_super_compat_ro_flags(disk_super, features);
                        btrfs_info(fs_info,
                                "setting compat-ro feature flag for %s (0x%llx)",
                                name, flag);
                }
                spin_unlock(&fs_info->super_lock);
                set_bit(BTRFS_FS_FEATURE_CHANGED, &fs_info->flags);
        }
}

void __btrfs_clear_fs_compat_ro(struct btrfs_fs_info *fs_info, u64 flag,
                                const char *name)
{
        struct btrfs_super_block *disk_super;
        u64 features;

        disk_super = fs_info->super_copy;
        features = btrfs_super_compat_ro_flags(disk_super);
        if (features & flag) {
                spin_lock(&fs_info->super_lock);
                features = btrfs_super_compat_ro_flags(disk_super);
                if (features & flag) {
                        features &= ~flag;
                        btrfs_set_super_compat_ro_flags(disk_super, features);
                        btrfs_info(fs_info,
                                "clearing compat-ro feature flag for %s (0x%llx)",
                                name, flag);
                }
                spin_unlock(&fs_info->super_lock);
                set_bit(BTRFS_FS_FEATURE_CHANGED, &fs_info->flags);
        }
}