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