LXR linux/fs/f2fs/shrinker.c

   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * f2fs shrinker support
   4 *   the basic infra was copied from fs/ubifs/shrinker.c
   5 *
   6 * Copyright (c) 2015 Motorola Mobility
   7 * Copyright (c) 2015 Jaegeuk Kim <jaegeuk@kernel.org>
   8 */
   9#include <linux/fs.h>
  10#include <linux/f2fs_fs.h>
  11
  12#include "f2fs.h"
  13#include "node.h"
  14
  15static LIST_HEAD(f2fs_list);
  16static DEFINE_SPINLOCK(f2fs_list_lock);
  17static unsigned int shrinker_run_no;
  18
  19static unsigned long __count_nat_entries(struct f2fs_sb_info *sbi)
  20{
  21        return NM_I(sbi)->nat_cnt[RECLAIMABLE_NAT];
  22}
  23
  24static unsigned long __count_free_nids(struct f2fs_sb_info *sbi)
  25{
  26        long count = NM_I(sbi)->nid_cnt[FREE_NID] - MAX_FREE_NIDS;
  27
  28        return count > 0 ? count : 0;
  29}
  30
  31static unsigned long __count_extent_cache(struct f2fs_sb_info *sbi)
  32{
  33        return atomic_read(&sbi->total_zombie_tree) +
  34                                atomic_read(&sbi->total_ext_node);
  35}
  36
  37unsigned long f2fs_shrink_count(struct shrinker *shrink,
  38                                struct shrink_control *sc)
  39{
  40        struct f2fs_sb_info *sbi;
  41        struct list_head *p;
  42        unsigned long count = 0;
  43
  44        spin_lock(&f2fs_list_lock);
  45        p = f2fs_list.next;
  46        while (p != &f2fs_list) {
  47                sbi = list_entry(p, struct f2fs_sb_info, s_list);
  48
  49                /* stop f2fs_put_super */
  50                if (!mutex_trylock(&sbi->umount_mutex)) {
  51                        p = p->next;
  52                        continue;
  53                }
  54                spin_unlock(&f2fs_list_lock);
  55
  56                /* count extent cache entries */
  57                count += __count_extent_cache(sbi);
  58
  59                /* count clean nat cache entries */
  60                count += __count_nat_entries(sbi);
  61
  62                /* count free nids cache entries */
  63                count += __count_free_nids(sbi);
  64
  65                spin_lock(&f2fs_list_lock);
  66                p = p->next;
  67                mutex_unlock(&sbi->umount_mutex);
  68        }
  69        spin_unlock(&f2fs_list_lock);
  70        return count;
  71}
  72
  73unsigned long f2fs_shrink_scan(struct shrinker *shrink,
  74                                struct shrink_control *sc)
  75{
  76        unsigned long nr = sc->nr_to_scan;
  77        struct f2fs_sb_info *sbi;
  78        struct list_head *p;
  79        unsigned int run_no;
  80        unsigned long freed = 0;
  81
  82        spin_lock(&f2fs_list_lock);
  83        do {
  84                run_no = ++shrinker_run_no;
  85        } while (run_no == 0);
  86        p = f2fs_list.next;
  87        while (p != &f2fs_list) {
  88                sbi = list_entry(p, struct f2fs_sb_info, s_list);
  89
  90                if (sbi->shrinker_run_no == run_no)
  91                        break;
  92
  93                /* stop f2fs_put_super */
  94                if (!mutex_trylock(&sbi->umount_mutex)) {
  95                        p = p->next;
  96                        continue;
  97                }
  98                spin_unlock(&f2fs_list_lock);
  99
 100                sbi->shrinker_run_no = run_no;
 101
 102                /* shrink extent cache entries */
 103                freed += f2fs_shrink_extent_tree(sbi, nr >> 1);
 104
 105                /* shrink clean nat cache entries */
 106                if (freed < nr)
 107                        freed += f2fs_try_to_free_nats(sbi, nr - freed);
 108
 109                /* shrink free nids cache entries */
 110                if (freed < nr)
 111                        freed += f2fs_try_to_free_nids(sbi, nr - freed);
 112
 113                spin_lock(&f2fs_list_lock);
 114                p = p->next;
 115                list_move_tail(&sbi->s_list, &f2fs_list);
 116                mutex_unlock(&sbi->umount_mutex);
 117                if (freed >= nr)
 118                        break;
 119        }
 120        spin_unlock(&f2fs_list_lock);
 121        return freed;
 122}
 123
 124void f2fs_join_shrinker(struct f2fs_sb_info *sbi)
 125{
 126        spin_lock(&f2fs_list_lock);
 127        list_add_tail(&sbi->s_list, &f2fs_list);
 128        spin_unlock(&f2fs_list_lock);
 129}
 130
 131void f2fs_leave_shrinker(struct f2fs_sb_info *sbi)
 132{
 133        f2fs_shrink_extent_tree(sbi, __count_extent_cache(sbi));
 134
 135        spin_lock(&f2fs_list_lock);
 136        list_del_init(&sbi->s_list);
 137        spin_unlock(&f2fs_list_lock);
 138}
 139