// SPDX-License-Identifier: GPL-2.0+
/*
 * NILFS dat/inode allocator
 *
 * Copyright (C) 2006-2008 Nippon Telegraph and Telephone Corporation.
 *
 * Originally written by Koji Sato.
 * Two allocators were unified by Ryusuke Konishi and Amagai Yoshiji.
 */

#include <linux/types.h>
#include <linux/buffer_head.h>
#include <linux/fs.h>
#include <linux/bitops.h>
#include <linux/slab.h>
#include "mdt.h"
#include "alloc.h"


/**
 * nilfs_palloc_groups_per_desc_block - get the number of groups that a group
 *                                      descriptor block can maintain
 * @inode: inode of metadata file using this allocator
 *
 * Return: Number of groups that a group descriptor block can maintain.
 */
static inline unsigned long
nilfs_palloc_groups_per_desc_block(const struct inode *inode)
{
        return i_blocksize(inode) /
                sizeof(struct nilfs_palloc_group_desc);
}

/**
 * nilfs_palloc_groups_count - get maximum number of groups
 * @inode: inode of metadata file using this allocator
 *
 * Return: Maximum number of groups.
 */
static inline unsigned long
nilfs_palloc_groups_count(const struct inode *inode)
{
        return 1UL << (BITS_PER_LONG - (inode->i_blkbits + 3 /* log2(8) */));
}

/**
 * nilfs_palloc_init_blockgroup - initialize private variables for allocator
 * @inode: inode of metadata file using this allocator
 * @entry_size: size of the persistent object
 *
 * Return: 0 on success, or a negative error code on failure.
 */
int nilfs_palloc_init_blockgroup(struct inode *inode, unsigned int entry_size)
{
        struct nilfs_mdt_info *mi = NILFS_MDT(inode);

        mi->mi_bgl = kmalloc_obj(*mi->mi_bgl, GFP_NOFS);
        if (!mi->mi_bgl)
                return -ENOMEM;

        bgl_lock_init(mi->mi_bgl);

        nilfs_mdt_set_entry_size(inode, entry_size, 0);

        mi->mi_blocks_per_group =
                DIV_ROUND_UP(nilfs_palloc_entries_per_group(inode),
                             mi->mi_entries_per_block) + 1;
                /*
                 * Number of blocks in a group including entry blocks
                 * and a bitmap block
                 */
        mi->mi_blocks_per_desc_block =
                nilfs_palloc_groups_per_desc_block(inode) *
                mi->mi_blocks_per_group + 1;
                /*
                 * Number of blocks per descriptor including the
                 * descriptor block
                 */
        return 0;
}

/**
 * nilfs_palloc_group - get group number and offset from an entry number
 * @inode: inode of metadata file using this allocator
 * @nr: serial number of the entry (e.g. inode number)
 * @offset: pointer to store offset number in the group
 *
 * Return: Number of the group that contains the entry with the index
 * specified by @nr.
 */
static unsigned long nilfs_palloc_group(const struct inode *inode, __u64 nr,
                                        unsigned long *offset)
{
        __u64 group = nr;

        *offset = do_div(group, nilfs_palloc_entries_per_group(inode));
        return group;
}

/**
 * nilfs_palloc_desc_blkoff - get block offset of a group descriptor block
 * @inode: inode of metadata file using this allocator
 * @group: group number
 *
 * Return: Index number in the metadata file of the descriptor block of
 * the group specified by @group.
 */
static unsigned long
nilfs_palloc_desc_blkoff(const struct inode *inode, unsigned long group)
{
        unsigned long desc_block =
                group / nilfs_palloc_groups_per_desc_block(inode);
        return desc_block * NILFS_MDT(inode)->mi_blocks_per_desc_block;
}

/**
 * nilfs_palloc_bitmap_blkoff - get block offset of a bitmap block
 * @inode: inode of metadata file using this allocator
 * @group: group number
 *
 * nilfs_palloc_bitmap_blkoff() returns block offset of the bitmap
 * block used to allocate/deallocate entries in the specified group.
 *
 * Return: Index number in the metadata file of the bitmap block of
 * the group specified by @group.
 */
static unsigned long
nilfs_palloc_bitmap_blkoff(const struct inode *inode, unsigned long group)
{
        unsigned long desc_offset =
                group % nilfs_palloc_groups_per_desc_block(inode);
        return nilfs_palloc_desc_blkoff(inode, group) + 1 +
                desc_offset * NILFS_MDT(inode)->mi_blocks_per_group;
}

/**
 * nilfs_palloc_group_desc_nfrees - get the number of free entries in a group
 * @desc: pointer to descriptor structure for the group
 * @lock: spin lock protecting @desc
 *
 * Return: Number of free entries written in the group descriptor @desc.
 */
static unsigned long
nilfs_palloc_group_desc_nfrees(const struct nilfs_palloc_group_desc *desc,
                               spinlock_t *lock)
{
        unsigned long nfree;

        spin_lock(lock);
        nfree = le32_to_cpu(desc->pg_nfrees);
        spin_unlock(lock);
        return nfree;
}

/**
 * nilfs_palloc_group_desc_add_entries - adjust count of free entries
 * @desc: pointer to descriptor structure for the group
 * @lock: spin lock protecting @desc
 * @n: delta to be added
 *
 * Return: Number of free entries after adjusting the group descriptor
 * @desc.
 */
static u32
nilfs_palloc_group_desc_add_entries(struct nilfs_palloc_group_desc *desc,
                                    spinlock_t *lock, u32 n)
{
        u32 nfree;

        spin_lock(lock);
        le32_add_cpu(&desc->pg_nfrees, n);
        nfree = le32_to_cpu(desc->pg_nfrees);
        spin_unlock(lock);
        return nfree;
}

/**
 * nilfs_palloc_entry_blkoff - get block offset of an entry block
 * @inode: inode of metadata file using this allocator
 * @nr: serial number of the entry (e.g. inode number)
 *
 * Return: Index number in the metadata file of the block containing
 * the entry specified by @nr.
 */
static unsigned long
nilfs_palloc_entry_blkoff(const struct inode *inode, __u64 nr)
{
        unsigned long group, group_offset;

        group = nilfs_palloc_group(inode, nr, &group_offset);

        return nilfs_palloc_bitmap_blkoff(inode, group) + 1 +
                group_offset / NILFS_MDT(inode)->mi_entries_per_block;
}

/**
 * nilfs_palloc_desc_block_init - initialize buffer of a group descriptor block
 * @inode: inode of metadata file
 * @bh: buffer head of the buffer to be initialized
 * @from: kernel address mapped for a chunk of the block
 *
 * This function does not yet support the case where block size > PAGE_SIZE.
 */
static void nilfs_palloc_desc_block_init(struct inode *inode,
                                         struct buffer_head *bh, void *from)
{
        struct nilfs_palloc_group_desc *desc = from;
        unsigned long n = nilfs_palloc_groups_per_desc_block(inode);
        __le32 nfrees;

        nfrees = cpu_to_le32(nilfs_palloc_entries_per_group(inode));
        while (n-- > 0) {
                desc->pg_nfrees = nfrees;
                desc++;
        }
}

static int nilfs_palloc_get_block(struct inode *inode, unsigned long blkoff,
                                  int create,
                                  void (*init_block)(struct inode *,
                                                     struct buffer_head *,
                                                     void *),
                                  struct buffer_head **bhp,
                                  struct nilfs_bh_assoc *prev,
                                  spinlock_t *lock)
{
        int ret;

        spin_lock(lock);
        if (prev->bh && blkoff == prev->blkoff &&
            likely(buffer_uptodate(prev->bh))) {
                get_bh(prev->bh);
                *bhp = prev->bh;
                spin_unlock(lock);
                return 0;
        }
        spin_unlock(lock);

        ret = nilfs_mdt_get_block(inode, blkoff, create, init_block, bhp);
        if (!ret) {
                spin_lock(lock);
                /*
                 * The following code must be safe for change of the
                 * cache contents during the get block call.
                 */
                brelse(prev->bh);
                get_bh(*bhp);
                prev->bh = *bhp;
                prev->blkoff = blkoff;
                spin_unlock(lock);
        }
        return ret;
}

/**
 * nilfs_palloc_delete_block - delete a block on the persistent allocator file
 * @inode: inode of metadata file using this allocator
 * @blkoff: block offset
 * @prev: nilfs_bh_assoc struct of the last used buffer
 * @lock: spin lock protecting @prev
 *
 * Return: 0 on success, or one of the following negative error codes on
 * failure:
 * * %-EIO      - I/O error (including metadata corruption).
 * * %-ENOENT   - Non-existent block.
 * * %-ENOMEM   - Insufficient memory available.
 */
static int nilfs_palloc_delete_block(struct inode *inode, unsigned long blkoff,
                                     struct nilfs_bh_assoc *prev,
                                     spinlock_t *lock)
{
        spin_lock(lock);
        if (prev->bh && blkoff == prev->blkoff) {
                brelse(prev->bh);
                prev->bh = NULL;
        }
        spin_unlock(lock);
        return nilfs_mdt_delete_block(inode, blkoff);
}

/**
 * nilfs_palloc_get_desc_block - get buffer head of a group descriptor block
 * @inode: inode of metadata file using this allocator
 * @group: group number
 * @create: create flag
 * @bhp: pointer to store the resultant buffer head
 *
 * Return: 0 on success, or a negative error code on failure.
 */
static int nilfs_palloc_get_desc_block(struct inode *inode,
                                       unsigned long group,
                                       int create, struct buffer_head **bhp)
{
        struct nilfs_palloc_cache *cache = NILFS_MDT(inode)->mi_palloc_cache;

        return nilfs_palloc_get_block(inode,
                                      nilfs_palloc_desc_blkoff(inode, group),
                                      create, nilfs_palloc_desc_block_init,
                                      bhp, &cache->prev_desc, &cache->lock);
}

/**
 * nilfs_palloc_get_bitmap_block - get buffer head of a bitmap block
 * @inode: inode of metadata file using this allocator
 * @group: group number
 * @create: create flag
 * @bhp: pointer to store the resultant buffer head
 *
 * Return: 0 on success, or a negative error code on failure.
 */
static int nilfs_palloc_get_bitmap_block(struct inode *inode,
                                         unsigned long group,
                                         int create, struct buffer_head **bhp)
{
        struct nilfs_palloc_cache *cache = NILFS_MDT(inode)->mi_palloc_cache;

        return nilfs_palloc_get_block(inode,
                                      nilfs_palloc_bitmap_blkoff(inode, group),
                                      create, NULL, bhp,
                                      &cache->prev_bitmap, &cache->lock);
}

/**
 * nilfs_palloc_delete_bitmap_block - delete a bitmap block
 * @inode: inode of metadata file using this allocator
 * @group: group number
 *
 * Return: 0 on success, or a negative error code on failure.
 */
static int nilfs_palloc_delete_bitmap_block(struct inode *inode,
                                            unsigned long group)
{
        struct nilfs_palloc_cache *cache = NILFS_MDT(inode)->mi_palloc_cache;

        return nilfs_palloc_delete_block(inode,
                                         nilfs_palloc_bitmap_blkoff(inode,
                                                                    group),
                                         &cache->prev_bitmap, &cache->lock);
}

/**
 * nilfs_palloc_get_entry_block - get buffer head of an entry block
 * @inode: inode of metadata file using this allocator
 * @nr: serial number of the entry (e.g. inode number)
 * @create: create flag
 * @bhp: pointer to store the resultant buffer head
 *
 * Return: 0 on success, or a negative error code on failure.
 */
int nilfs_palloc_get_entry_block(struct inode *inode, __u64 nr,
                                 int create, struct buffer_head **bhp)
{
        struct nilfs_palloc_cache *cache = NILFS_MDT(inode)->mi_palloc_cache;

        return nilfs_palloc_get_block(inode,
                                      nilfs_palloc_entry_blkoff(inode, nr),
                                      create, NULL, bhp,
                                      &cache->prev_entry, &cache->lock);
}

/**
 * nilfs_palloc_delete_entry_block - delete an entry block
 * @inode: inode of metadata file using this allocator
 * @nr: serial number of the entry
 *
 * Return: 0 on success, or a negative error code on failure.
 */
static int nilfs_palloc_delete_entry_block(struct inode *inode, __u64 nr)
{
        struct nilfs_palloc_cache *cache = NILFS_MDT(inode)->mi_palloc_cache;

        return nilfs_palloc_delete_block(inode,
                                         nilfs_palloc_entry_blkoff(inode, nr),
                                         &cache->prev_entry, &cache->lock);
}

/**
 * nilfs_palloc_group_desc_offset - calculate the byte offset of a group
 *                                  descriptor in the folio containing it
 * @inode: inode of metadata file using this allocator
 * @group: group number
 * @bh:    buffer head of the group descriptor block
 *
 * Return: Byte offset in the folio of the group descriptor for @group.
 */
static size_t nilfs_palloc_group_desc_offset(const struct inode *inode,
                                             unsigned long group,
                                             const struct buffer_head *bh)
{
        return offset_in_folio(bh->b_folio, bh->b_data) +
                sizeof(struct nilfs_palloc_group_desc) *
                (group % nilfs_palloc_groups_per_desc_block(inode));
}

/**
 * nilfs_palloc_bitmap_offset - calculate the byte offset of a bitmap block
 *                              in the folio containing it
 * @bh: buffer head of the bitmap block
 *
 * Return: Byte offset in the folio of the bitmap block for @bh.
 */
static size_t nilfs_palloc_bitmap_offset(const struct buffer_head *bh)
{
        return offset_in_folio(bh->b_folio, bh->b_data);
}

/**
 * nilfs_palloc_entry_offset - calculate the byte offset of an entry in the
 *                             folio containing it
 * @inode: inode of metadata file using this allocator
 * @nr:    serial number of the entry (e.g. inode number)
 * @bh:    buffer head of the entry block
 *
 * Return: Byte offset in the folio of the entry @nr.
 */
size_t nilfs_palloc_entry_offset(const struct inode *inode, __u64 nr,
                                 const struct buffer_head *bh)
{
        unsigned long entry_index_in_group, entry_index_in_block;

        nilfs_palloc_group(inode, nr, &entry_index_in_group);
        entry_index_in_block = entry_index_in_group %
                NILFS_MDT(inode)->mi_entries_per_block;

        return offset_in_folio(bh->b_folio, bh->b_data) +
                entry_index_in_block * NILFS_MDT(inode)->mi_entry_size;
}

/**
 * nilfs_palloc_find_available_slot - find available slot in a group
 * @bitmap: bitmap of the group
 * @target: offset number of an entry in the group (start point)
 * @bsize: size in bits
 * @lock: spin lock protecting @bitmap
 * @wrap: whether to wrap around
 *
 * Return: Offset number within the group of the found free entry, or
 * %-ENOSPC if not found.
 */
static int nilfs_palloc_find_available_slot(unsigned char *bitmap,
                                            unsigned long target,
                                            unsigned int bsize,
                                            spinlock_t *lock, bool wrap)
{
        int pos, end = bsize;

        if (likely(target < bsize)) {
                pos = target;
                do {
                        pos = nilfs_find_next_zero_bit(bitmap, end, pos);
                        if (pos >= end)
                                break;
                        if (!nilfs_set_bit_atomic(lock, pos, bitmap))
                                return pos;
                } while (++pos < end);

                end = target;
        }
        if (!wrap)
                return -ENOSPC;

        /* wrap around */
        for (pos = 0; pos < end; pos++) {
                pos = nilfs_find_next_zero_bit(bitmap, end, pos);
                if (pos >= end)
                        break;
                if (!nilfs_set_bit_atomic(lock, pos, bitmap))
                        return pos;
        }

        return -ENOSPC;
}

/**
 * nilfs_palloc_rest_groups_in_desc_block - get the remaining number of groups
 *                                          in a group descriptor block
 * @inode: inode of metadata file using this allocator
 * @curr: current group number
 * @max: maximum number of groups
 *
 * Return: Number of remaining descriptors (= groups) managed by the descriptor
 * block.
 */
static unsigned long
nilfs_palloc_rest_groups_in_desc_block(const struct inode *inode,
                                       unsigned long curr, unsigned long max)
{
        return min_t(unsigned long,
                     nilfs_palloc_groups_per_desc_block(inode) -
                     curr % nilfs_palloc_groups_per_desc_block(inode),
                     max - curr + 1);
}

/**
 * nilfs_palloc_count_desc_blocks - count descriptor blocks number
 * @inode: inode of metadata file using this allocator
 * @desc_blocks: descriptor blocks number [out]
 *
 * Return: 0 on success, or a negative error code on failure.
 */
static int nilfs_palloc_count_desc_blocks(struct inode *inode,
                                            unsigned long *desc_blocks)
{
        __u64 blknum;
        int ret;

        ret = nilfs_bmap_last_key(NILFS_I(inode)->i_bmap, &blknum);
        if (likely(!ret))
                *desc_blocks = DIV_ROUND_UP(
                        (unsigned long)blknum,
                        NILFS_MDT(inode)->mi_blocks_per_desc_block);
        return ret;
}

/**
 * nilfs_palloc_mdt_file_can_grow - check potential opportunity for
 *                                      MDT file growing
 * @inode: inode of metadata file using this allocator
 * @desc_blocks: known current descriptor blocks count
 *
 * Return: true if a group can be added in the metadata file, false if not.
 */
static inline bool nilfs_palloc_mdt_file_can_grow(struct inode *inode,
                                                    unsigned long desc_blocks)
{
        return (nilfs_palloc_groups_per_desc_block(inode) * desc_blocks) <
                        nilfs_palloc_groups_count(inode);
}

/**
 * nilfs_palloc_count_max_entries - count max number of entries that can be
 *                                      described by descriptor blocks count
 * @inode: inode of metadata file using this allocator
 * @nused: current number of used entries
 * @nmaxp: max number of entries [out]
 *
 * Return: 0 on success, or one of the following negative error codes on
 * failure:
 * * %-EIO      - I/O error (including metadata corruption).
 * * %-ENOMEM   - Insufficient memory available.
 * * %-ERANGE   - Number of entries in use is out of range.
 */
int nilfs_palloc_count_max_entries(struct inode *inode, u64 nused, u64 *nmaxp)
{
        unsigned long desc_blocks = 0;
        u64 entries_per_desc_block, nmax;
        int err;

        err = nilfs_palloc_count_desc_blocks(inode, &desc_blocks);
        if (unlikely(err))
                return err;

        entries_per_desc_block = (u64)nilfs_palloc_entries_per_group(inode) *
                                nilfs_palloc_groups_per_desc_block(inode);
        nmax = entries_per_desc_block * desc_blocks;

        if (nused == nmax &&
                        nilfs_palloc_mdt_file_can_grow(inode, desc_blocks))
                nmax += entries_per_desc_block;

        if (nused > nmax)
                return -ERANGE;

        *nmaxp = nmax;
        return 0;
}

/**
 * nilfs_palloc_prepare_alloc_entry - prepare to allocate a persistent object
 * @inode: inode of metadata file using this allocator
 * @req: nilfs_palloc_req structure exchanged for the allocation
 * @wrap: whether to wrap around
 *
 * Return: 0 on success, or one of the following negative error codes on
 * failure:
 * * %-EIO      - I/O error (including metadata corruption).
 * * %-ENOMEM   - Insufficient memory available.
 * * %-ENOSPC   - Entries exhausted (No entries available for allocation).
 * * %-EROFS    - Read only filesystem
 */
int nilfs_palloc_prepare_alloc_entry(struct inode *inode,
                                     struct nilfs_palloc_req *req, bool wrap)
{
        struct buffer_head *desc_bh, *bitmap_bh;
        struct nilfs_palloc_group_desc *desc;
        unsigned char *bitmap;
        size_t doff, boff;
        unsigned long group, maxgroup, ngroups;
        unsigned long group_offset, maxgroup_offset;
        unsigned long n, entries_per_group;
        unsigned long i, j;
        spinlock_t *lock;
        int pos, ret;

        ngroups = nilfs_palloc_groups_count(inode);
        maxgroup = ngroups - 1;
        group = nilfs_palloc_group(inode, req->pr_entry_nr, &group_offset);
        entries_per_group = nilfs_palloc_entries_per_group(inode);

        for (i = 0; i < ngroups; i += n) {
                if (group >= ngroups && wrap) {
                        /* wrap around */
                        group = 0;
                        maxgroup = nilfs_palloc_group(inode, req->pr_entry_nr,
                                                      &maxgroup_offset) - 1;
                }
                ret = nilfs_palloc_get_desc_block(inode, group, 1, &desc_bh);
                if (ret < 0)
                        return ret;

                doff = nilfs_palloc_group_desc_offset(inode, group, desc_bh);
                desc = kmap_local_folio(desc_bh->b_folio, doff);
                n = nilfs_palloc_rest_groups_in_desc_block(inode, group,
                                                           maxgroup);
                for (j = 0; j < n; j++, group++, group_offset = 0) {
                        lock = nilfs_mdt_bgl_lock(inode, group);
                        if (nilfs_palloc_group_desc_nfrees(&desc[j], lock) == 0)
                                continue;

                        kunmap_local(desc);
                        ret = nilfs_palloc_get_bitmap_block(inode, group, 1,
                                                            &bitmap_bh);
                        if (unlikely(ret < 0)) {
                                brelse(desc_bh);
                                return ret;
                        }

                        /*
                         * Re-kmap the folio containing the first (and
                         * subsequent) group descriptors.
                         */
                        desc = kmap_local_folio(desc_bh->b_folio, doff);

                        boff = nilfs_palloc_bitmap_offset(bitmap_bh);
                        bitmap = kmap_local_folio(bitmap_bh->b_folio, boff);
                        pos = nilfs_palloc_find_available_slot(
                                bitmap, group_offset, entries_per_group, lock,
                                wrap);
                        /*
                         * Since the search for a free slot in the second and
                         * subsequent bitmap blocks always starts from the
                         * beginning, the wrap flag only has an effect on the
                         * first search.
                         */
                        kunmap_local(bitmap);
                        if (pos >= 0)
                                goto found;

                        brelse(bitmap_bh);
                }

                kunmap_local(desc);
                brelse(desc_bh);
        }

        /* no entries left */
        return -ENOSPC;

found:
        /* found a free entry */
        nilfs_palloc_group_desc_add_entries(&desc[j], lock, -1);
        req->pr_entry_nr = entries_per_group * group + pos;
        kunmap_local(desc);

        req->pr_desc_bh = desc_bh;
        req->pr_bitmap_bh = bitmap_bh;
        return 0;
}

/**
 * nilfs_palloc_commit_alloc_entry - finish allocation of a persistent object
 * @inode: inode of metadata file using this allocator
 * @req: nilfs_palloc_req structure exchanged for the allocation
 */
void nilfs_palloc_commit_alloc_entry(struct inode *inode,
                                     struct nilfs_palloc_req *req)
{
        mark_buffer_dirty(req->pr_bitmap_bh);
        mark_buffer_dirty(req->pr_desc_bh);
        nilfs_mdt_mark_dirty(inode);

        brelse(req->pr_bitmap_bh);
        brelse(req->pr_desc_bh);
}

/**
 * nilfs_palloc_commit_free_entry - finish deallocating a persistent object
 * @inode: inode of metadata file using this allocator
 * @req: nilfs_palloc_req structure exchanged for the removal
 */
void nilfs_palloc_commit_free_entry(struct inode *inode,
                                    struct nilfs_palloc_req *req)
{
        unsigned long group, group_offset;
        size_t doff, boff;
        struct nilfs_palloc_group_desc *desc;
        unsigned char *bitmap;
        spinlock_t *lock;

        group = nilfs_palloc_group(inode, req->pr_entry_nr, &group_offset);
        doff = nilfs_palloc_group_desc_offset(inode, group, req->pr_desc_bh);
        desc = kmap_local_folio(req->pr_desc_bh->b_folio, doff);

        boff = nilfs_palloc_bitmap_offset(req->pr_bitmap_bh);
        bitmap = kmap_local_folio(req->pr_bitmap_bh->b_folio, boff);
        lock = nilfs_mdt_bgl_lock(inode, group);

        if (!nilfs_clear_bit_atomic(lock, group_offset, bitmap))
                nilfs_warn(inode->i_sb,
                           "%s (ino=%lu): entry number %llu already freed",
                           __func__, inode->i_ino,
                           (unsigned long long)req->pr_entry_nr);
        else
                nilfs_palloc_group_desc_add_entries(desc, lock, 1);

        kunmap_local(bitmap);
        kunmap_local(desc);

        mark_buffer_dirty(req->pr_desc_bh);
        mark_buffer_dirty(req->pr_bitmap_bh);
        nilfs_mdt_mark_dirty(inode);

        brelse(req->pr_bitmap_bh);
        brelse(req->pr_desc_bh);
}

/**
 * nilfs_palloc_abort_alloc_entry - cancel allocation of a persistent object
 * @inode: inode of metadata file using this allocator
 * @req: nilfs_palloc_req structure exchanged for the allocation
 */
void nilfs_palloc_abort_alloc_entry(struct inode *inode,
                                    struct nilfs_palloc_req *req)
{
        struct nilfs_palloc_group_desc *desc;
        size_t doff, boff;
        unsigned char *bitmap;
        unsigned long group, group_offset;
        spinlock_t *lock;

        group = nilfs_palloc_group(inode, req->pr_entry_nr, &group_offset);
        doff = nilfs_palloc_group_desc_offset(inode, group, req->pr_desc_bh);
        desc = kmap_local_folio(req->pr_desc_bh->b_folio, doff);

        boff = nilfs_palloc_bitmap_offset(req->pr_bitmap_bh);
        bitmap = kmap_local_folio(req->pr_bitmap_bh->b_folio, boff);
        lock = nilfs_mdt_bgl_lock(inode, group);

        if (!nilfs_clear_bit_atomic(lock, group_offset, bitmap))
                nilfs_warn(inode->i_sb,
                           "%s (ino=%lu): entry number %llu already freed",
                           __func__, inode->i_ino,
                           (unsigned long long)req->pr_entry_nr);
        else
                nilfs_palloc_group_desc_add_entries(desc, lock, 1);

        kunmap_local(bitmap);
        kunmap_local(desc);

        brelse(req->pr_bitmap_bh);
        brelse(req->pr_desc_bh);

        req->pr_entry_nr = 0;
        req->pr_bitmap_bh = NULL;
        req->pr_desc_bh = NULL;
}

/**
 * nilfs_palloc_prepare_free_entry - prepare to deallocate a persistent object
 * @inode: inode of metadata file using this allocator
 * @req: nilfs_palloc_req structure exchanged for the removal
 *
 * Return: 0 on success, or a negative error code on failure.
 */
int nilfs_palloc_prepare_free_entry(struct inode *inode,
                                    struct nilfs_palloc_req *req)
{
        struct buffer_head *desc_bh, *bitmap_bh;
        unsigned long group, group_offset;
        int ret;

        group = nilfs_palloc_group(inode, req->pr_entry_nr, &group_offset);
        ret = nilfs_palloc_get_desc_block(inode, group, 1, &desc_bh);
        if (ret < 0)
                return ret;
        ret = nilfs_palloc_get_bitmap_block(inode, group, 1, &bitmap_bh);
        if (ret < 0) {
                brelse(desc_bh);
                return ret;
        }

        req->pr_desc_bh = desc_bh;
        req->pr_bitmap_bh = bitmap_bh;
        return 0;
}

/**
 * nilfs_palloc_abort_free_entry - cancel deallocating a persistent object
 * @inode: inode of metadata file using this allocator
 * @req: nilfs_palloc_req structure exchanged for the removal
 */
void nilfs_palloc_abort_free_entry(struct inode *inode,
                                   struct nilfs_palloc_req *req)
{
        brelse(req->pr_bitmap_bh);
        brelse(req->pr_desc_bh);

        req->pr_entry_nr = 0;
        req->pr_bitmap_bh = NULL;
        req->pr_desc_bh = NULL;
}

/**
 * nilfs_palloc_freev - deallocate a set of persistent objects
 * @inode: inode of metadata file using this allocator
 * @entry_nrs: array of entry numbers to be deallocated
 * @nitems: number of entries stored in @entry_nrs
 *
 * Return: 0 on success, or a negative error code on failure.
 */
int nilfs_palloc_freev(struct inode *inode, __u64 *entry_nrs, size_t nitems)
{
        struct buffer_head *desc_bh, *bitmap_bh;
        struct nilfs_palloc_group_desc *desc;
        unsigned char *bitmap;
        size_t doff, boff;
        unsigned long group, group_offset;
        __u64 group_min_nr, last_nrs[8];
        const unsigned long epg = nilfs_palloc_entries_per_group(inode);
        const unsigned int epb = NILFS_MDT(inode)->mi_entries_per_block;
        unsigned int entry_start, end, pos;
        spinlock_t *lock;
        int i, j, k, ret;
        u32 nfree;

        for (i = 0; i < nitems; i = j) {
                int change_group = false;
                int nempties = 0, n = 0;

                group = nilfs_palloc_group(inode, entry_nrs[i], &group_offset);
                ret = nilfs_palloc_get_desc_block(inode, group, 0, &desc_bh);
                if (ret < 0)
                        return ret;
                ret = nilfs_palloc_get_bitmap_block(inode, group, 0,
                                                    &bitmap_bh);
                if (ret < 0) {
                        brelse(desc_bh);
                        return ret;
                }

                /* Get the first entry number of the group */
                group_min_nr = (__u64)group * epg;

                boff = nilfs_palloc_bitmap_offset(bitmap_bh);
                bitmap = kmap_local_folio(bitmap_bh->b_folio, boff);
                lock = nilfs_mdt_bgl_lock(inode, group);

                j = i;
                entry_start = rounddown(group_offset, epb);
                do {
                        if (!nilfs_clear_bit_atomic(lock, group_offset,
                                                    bitmap)) {
                                nilfs_warn(inode->i_sb,
                                           "%s (ino=%lu): entry number %llu already freed",
                                           __func__, inode->i_ino,
                                           (unsigned long long)entry_nrs[j]);
                        } else {
                                n++;
                        }

                        j++;
                        if (j >= nitems || entry_nrs[j] < group_min_nr ||
                            entry_nrs[j] >= group_min_nr + epg) {
                                change_group = true;
                        } else {
                                group_offset = entry_nrs[j] - group_min_nr;
                                if (group_offset >= entry_start &&
                                    group_offset < entry_start + epb) {
                                        /* This entry is in the same block */
                                        continue;
                                }
                        }

                        /* Test if the entry block is empty or not */
                        end = entry_start + epb;
                        pos = nilfs_find_next_bit(bitmap, end, entry_start);
                        if (pos >= end) {
                                last_nrs[nempties++] = entry_nrs[j - 1];
                                if (nempties >= ARRAY_SIZE(last_nrs))
                                        break;
                        }

                        if (change_group)
                                break;

                        /* Go on to the next entry block */
                        entry_start = rounddown(group_offset, epb);
                } while (true);

                kunmap_local(bitmap);
                mark_buffer_dirty(bitmap_bh);
                brelse(bitmap_bh);

                for (k = 0; k < nempties; k++) {
                        ret = nilfs_palloc_delete_entry_block(inode,
                                                              last_nrs[k]);
                        if (ret && ret != -ENOENT)
                                nilfs_warn(inode->i_sb,
                                           "error %d deleting block that object (entry=%llu, ino=%lu) belongs to",
                                           ret, (unsigned long long)last_nrs[k],
                                           inode->i_ino);
                }

                doff = nilfs_palloc_group_desc_offset(inode, group, desc_bh);
                desc = kmap_local_folio(desc_bh->b_folio, doff);
                nfree = nilfs_palloc_group_desc_add_entries(desc, lock, n);
                kunmap_local(desc);
                mark_buffer_dirty(desc_bh);
                nilfs_mdt_mark_dirty(inode);
                brelse(desc_bh);

                if (nfree == nilfs_palloc_entries_per_group(inode)) {
                        ret = nilfs_palloc_delete_bitmap_block(inode, group);
                        if (ret && ret != -ENOENT)
                                nilfs_warn(inode->i_sb,
                                           "error %d deleting bitmap block of group=%lu, ino=%lu",
                                           ret, group, inode->i_ino);
                }
        }
        return 0;
}

void nilfs_palloc_setup_cache(struct inode *inode,
                              struct nilfs_palloc_cache *cache)
{
        NILFS_MDT(inode)->mi_palloc_cache = cache;
        spin_lock_init(&cache->lock);
}

void nilfs_palloc_clear_cache(struct inode *inode)
{
        struct nilfs_palloc_cache *cache = NILFS_MDT(inode)->mi_palloc_cache;

        spin_lock(&cache->lock);
        brelse(cache->prev_desc.bh);
        brelse(cache->prev_bitmap.bh);
        brelse(cache->prev_entry.bh);
        cache->prev_desc.bh = NULL;
        cache->prev_bitmap.bh = NULL;
        cache->prev_entry.bh = NULL;
        spin_unlock(&cache->lock);
}

void nilfs_palloc_destroy_cache(struct inode *inode)
{
        nilfs_palloc_clear_cache(inode);
        NILFS_MDT(inode)->mi_palloc_cache = NULL;
}