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 25 struct 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 39 struct gc_inode_list { 40 struct list_head ilist; 41 struct radix_tree_root iroot; 42 }; 43 44 /* 45 * inline functions 46 */ 47 static 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 56 static 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 61 static 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 68 static 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 83 static 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 97 static 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