// SPDX-License-Identifier: GPL-2.0
/*
 * f2fs shrinker support
 *   the basic infra was copied from fs/ubifs/shrinker.c
 *
 * Copyright (c) 2015 Motorola Mobility
 * Copyright (c) 2015 Jaegeuk Kim <jaegeuk@kernel.org>
 */
#include <linux/fs.h>
#include <linux/f2fs_fs.h>

#include "f2fs.h"
#include "node.h"

static LIST_HEAD(f2fs_list);
static DEFINE_SPINLOCK(f2fs_list_lock);
static unsigned int shrinker_run_no;

static unsigned long __count_nat_entries(struct f2fs_sb_info *sbi)
{
        return NM_I(sbi)->nat_cnt[RECLAIMABLE_NAT];
}

static unsigned long __count_free_nids(struct f2fs_sb_info *sbi)
{
        long count = NM_I(sbi)->nid_cnt[FREE_NID] - MAX_FREE_NIDS;

        return count > 0 ? count : 0;
}

static unsigned long __count_extent_cache(struct f2fs_sb_info *sbi,
                                        enum extent_type type)
{
        struct extent_tree_info *eti = &sbi->extent_tree[type];

        return atomic_read(&eti->total_zombie_tree) +
                                atomic_read(&eti->total_ext_node);
}

unsigned long f2fs_shrink_count(struct shrinker *shrink,
                                struct shrink_control *sc)
{
        struct f2fs_sb_info *sbi;
        struct list_head *p;
        unsigned long count = 0;

        spin_lock(&f2fs_list_lock);
        p = f2fs_list.next;
        while (p != &f2fs_list) {
                sbi = list_entry(p, struct f2fs_sb_info, s_list);

                /* stop f2fs_put_super */
                if (!mutex_trylock(&sbi->umount_mutex)) {
                        p = p->next;
                        continue;
                }
                spin_unlock(&f2fs_list_lock);

                /* count read extent cache entries */
                count += __count_extent_cache(sbi, EX_READ);

                /* count block age extent cache entries */
                count += __count_extent_cache(sbi, EX_BLOCK_AGE);

                /* count clean nat cache entries */
                count += __count_nat_entries(sbi);

                /* count free nids cache entries */
                count += __count_free_nids(sbi);

                spin_lock(&f2fs_list_lock);
                p = p->next;
                mutex_unlock(&sbi->umount_mutex);
        }
        spin_unlock(&f2fs_list_lock);
        return count ?: SHRINK_EMPTY;
}

unsigned long f2fs_shrink_scan(struct shrinker *shrink,
                                struct shrink_control *sc)
{
        unsigned long nr = sc->nr_to_scan;
        struct f2fs_sb_info *sbi;
        struct list_head *p;
        unsigned int run_no;
        unsigned long freed = 0;

        spin_lock(&f2fs_list_lock);
        do {
                run_no = ++shrinker_run_no;
        } while (run_no == 0);
        p = f2fs_list.next;
        while (p != &f2fs_list) {
                sbi = list_entry(p, struct f2fs_sb_info, s_list);

                if (sbi->shrinker_run_no == run_no)
                        break;

                /* stop f2fs_put_super */
                if (!mutex_trylock(&sbi->umount_mutex)) {
                        p = p->next;
                        continue;
                }
                spin_unlock(&f2fs_list_lock);

                sbi->shrinker_run_no = run_no;

                /* shrink extent cache entries */
                freed += f2fs_shrink_age_extent_tree(sbi, nr >> 2);

                /* shrink read extent cache entries */
                freed += f2fs_shrink_read_extent_tree(sbi, nr >> 2);

                /* shrink clean nat cache entries */
                if (freed < nr)
                        freed += f2fs_try_to_free_nats(sbi, nr - freed);

                /* shrink free nids cache entries */
                if (freed < nr)
                        freed += f2fs_try_to_free_nids(sbi, nr - freed);

                spin_lock(&f2fs_list_lock);
                p = p->next;
                list_move_tail(&sbi->s_list, &f2fs_list);
                mutex_unlock(&sbi->umount_mutex);
                if (freed >= nr)
                        break;
        }
        spin_unlock(&f2fs_list_lock);
        return freed;
}

unsigned int f2fs_donate_files(void)
{
        struct f2fs_sb_info *sbi;
        struct list_head *p;
        unsigned int donate_files = 0;

        spin_lock(&f2fs_list_lock);
        p = f2fs_list.next;
        while (p != &f2fs_list) {
                sbi = list_entry(p, struct f2fs_sb_info, s_list);

                /* stop f2fs_put_super */
                if (!mutex_trylock(&sbi->umount_mutex)) {
                        p = p->next;
                        continue;
                }
                spin_unlock(&f2fs_list_lock);

                donate_files += sbi->donate_files;

                spin_lock(&f2fs_list_lock);
                p = p->next;
                mutex_unlock(&sbi->umount_mutex);
        }
        spin_unlock(&f2fs_list_lock);

        return donate_files;
}

static unsigned int do_reclaim_caches(struct f2fs_sb_info *sbi,
                                unsigned int reclaim_caches_kb)
{
        struct inode *inode;
        struct f2fs_inode_info *fi;
        unsigned int nfiles = sbi->donate_files;
        pgoff_t npages = reclaim_caches_kb >> (PAGE_SHIFT - 10);

        while (npages && nfiles--) {
                pgoff_t len;

                spin_lock(&sbi->inode_lock[DONATE_INODE]);
                if (list_empty(&sbi->inode_list[DONATE_INODE])) {
                        spin_unlock(&sbi->inode_lock[DONATE_INODE]);
                        break;
                }
                fi = list_first_entry(&sbi->inode_list[DONATE_INODE],
                                        struct f2fs_inode_info, gdonate_list);
                list_move_tail(&fi->gdonate_list, &sbi->inode_list[DONATE_INODE]);
                inode = igrab(&fi->vfs_inode);
                spin_unlock(&sbi->inode_lock[DONATE_INODE]);

                if (!inode)
                        continue;

                inode_lock(inode);
                if (!is_inode_flag_set(inode, FI_DONATE_FINISHED)) {
                        len = fi->donate_end - fi->donate_start + 1;
                        npages = npages < len ? 0 : npages - len;

                        invalidate_inode_pages2_range(inode->i_mapping,
                                        fi->donate_start, fi->donate_end);
                        set_inode_flag(inode, FI_DONATE_FINISHED);
                }
                inode_unlock(inode);

                iput(inode);
                cond_resched();
        }
        return npages << (PAGE_SHIFT - 10);
}

void f2fs_reclaim_caches(unsigned int reclaim_caches_kb)
{
        struct f2fs_sb_info *sbi;
        struct list_head *p;

        spin_lock(&f2fs_list_lock);
        p = f2fs_list.next;
        while (p != &f2fs_list && reclaim_caches_kb) {
                sbi = list_entry(p, struct f2fs_sb_info, s_list);

                /* stop f2fs_put_super */
                if (!mutex_trylock(&sbi->umount_mutex)) {
                        p = p->next;
                        continue;
                }
                spin_unlock(&f2fs_list_lock);

                reclaim_caches_kb = do_reclaim_caches(sbi, reclaim_caches_kb);

                spin_lock(&f2fs_list_lock);
                p = p->next;
                mutex_unlock(&sbi->umount_mutex);
        }
        spin_unlock(&f2fs_list_lock);
}

void f2fs_join_shrinker(struct f2fs_sb_info *sbi)
{
        spin_lock(&f2fs_list_lock);
        list_add_tail(&sbi->s_list, &f2fs_list);
        spin_unlock(&f2fs_list_lock);
}

void f2fs_leave_shrinker(struct f2fs_sb_info *sbi)
{
        f2fs_shrink_read_extent_tree(sbi, __count_extent_cache(sbi, EX_READ));
        f2fs_shrink_age_extent_tree(sbi,
                                __count_extent_cache(sbi, EX_BLOCK_AGE));

        spin_lock(&f2fs_list_lock);
        list_del_init(&sbi->s_list);
        spin_unlock(&f2fs_list_lock);
}