LXR linux/fs/f2fs/gc.h

   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * fs/f2fs/gc.h
   4 *
   5 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
   6 *             http://www.samsung.com/
   7 */
   8#define GC_THREAD_MIN_WB_PAGES          1       /*
   9                                                 * a threshold to determine
  10                                                 * whether IO subsystem is idle
  11                                                 * or not
  12                                                 */
  13#define DEF_GC_THREAD_URGENT_SLEEP_TIME 500     /* 500 ms */
  14#define DEF_GC_THREAD_MIN_SLEEP_TIME    30000   /* milliseconds */
  15#define DEF_GC_THREAD_MAX_SLEEP_TIME    60000
  16#define DEF_GC_THREAD_NOGC_SLEEP_TIME   300000  /* wait 5 min */
  17#define LIMIT_INVALID_BLOCK     40 /* percentage over total user space */
  18#define LIMIT_FREE_BLOCK        40 /* percentage over invalid + free space */
  19
  20#define DEF_GC_FAILED_PINNED_FILES      2048
  21
  22/* Search max. number of dirty segments to select a victim segment */
  23#define DEF_MAX_VICTIM_SEARCH 4096 /* covers 8GB */
  24
  25struct f2fs_gc_kthread {
  26        struct task_struct *f2fs_gc_task;
  27        wait_queue_head_t gc_wait_queue_head;
  28
  29        /* for gc sleep time */
  30        unsigned int urgent_sleep_time;
  31        unsigned int min_sleep_time;
  32        unsigned int max_sleep_time;
  33        unsigned int no_gc_sleep_time;
  34
  35        /* for changing gc mode */
  36        unsigned int gc_wake;
  37};
  38
  39struct gc_inode_list {
  40        struct list_head ilist;
  41        struct radix_tree_root iroot;
  42};
  43
  44/*
  45 * inline functions
  46 */
  47static inline block_t free_user_blocks(struct f2fs_sb_info *sbi)
  48{
  49        if (free_segments(sbi) < overprovision_segments(sbi))
  50                return 0;
  51        else
  52                return (free_segments(sbi) - overprovision_segments(sbi))
  53                        << sbi->log_blocks_per_seg;
  54}
  55
  56static inline block_t limit_invalid_user_blocks(struct f2fs_sb_info *sbi)
  57{
  58        return (long)(sbi->user_block_count * LIMIT_INVALID_BLOCK) / 100;
  59}
  60
  61static inline block_t limit_free_user_blocks(struct f2fs_sb_info *sbi)
  62{
  63        block_t reclaimable_user_blocks = sbi->user_block_count -
  64                written_block_count(sbi);
  65        return (long)(reclaimable_user_blocks * LIMIT_FREE_BLOCK) / 100;
  66}
  67
  68static inline void increase_sleep_time(struct f2fs_gc_kthread *gc_th,
  69                                                        unsigned int *wait)
  70{
  71        unsigned int min_time = gc_th->min_sleep_time;
  72        unsigned int max_time = gc_th->max_sleep_time;
  73
  74        if (*wait == gc_th->no_gc_sleep_time)
  75                return;
  76
  77        if ((long long)*wait + (long long)min_time > (long long)max_time)
  78                *wait = max_time;
  79        else
  80                *wait += min_time;
  81}
  82
  83static inline void decrease_sleep_time(struct f2fs_gc_kthread *gc_th,
  84                                                        unsigned int *wait)
  85{
  86        unsigned int min_time = gc_th->min_sleep_time;
  87
  88        if (*wait == gc_th->no_gc_sleep_time)
  89                *wait = gc_th->max_sleep_time;
  90
  91        if ((long long)*wait - (long long)min_time < (long long)min_time)
  92                *wait = min_time;
  93        else
  94                *wait -= min_time;
  95}
  96
  97static inline bool has_enough_invalid_blocks(struct f2fs_sb_info *sbi)
  98{
  99        block_t invalid_user_blocks = sbi->user_block_count -
 100                                        written_block_count(sbi);
 101        /*
 102         * Background GC is triggered with the following conditions.
 103         * 1. There are a number of invalid blocks.
 104         * 2. There is not enough free space.
 105         */
 106        if (invalid_user_blocks > limit_invalid_user_blocks(sbi) &&
 107                        free_user_blocks(sbi) < limit_free_user_blocks(sbi))
 108                return true;
 109        return false;
 110}
 111