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 /* Search max. number of dirty segments to select a victim segment */ 24 #define DEF_MAX_VICTIM_SEARCH 4096 /* covers 8GB */ 25 26 struct f2fs_gc_kthread { 27 struct task_struct *f2fs_gc_task; 28 wait_queue_head_t gc_wait_queue_head; 29 30 /* for gc sleep time */ 31 unsigned int urgent_sleep_time; 32 unsigned int min_sleep_time; 33 unsigned int max_sleep_time; 34 unsigned int no_gc_sleep_time; 35 36 /* for changing gc mode */ 37 unsigned int gc_idle; 38 unsigned int gc_urgent; 39 unsigned int gc_wake; 40 }; 41 42 struct gc_inode_list { 43 struct list_head ilist; 44 struct radix_tree_root iroot; 45 }; 46 47 /* 48 * inline functions 49 */ 50 static inline block_t free_user_blocks(struct f2fs_sb_info *sbi) 51 { 52 if (free_segments(sbi) < overprovision_segments(sbi)) 53 return 0; 54 else 55 return (free_segments(sbi) - overprovision_segments(sbi)) 56 << sbi->log_blocks_per_seg; 57 } 58 59 static inline block_t limit_invalid_user_blocks(struct f2fs_sb_info *sbi) 60 { 61 return (long)(sbi->user_block_count * LIMIT_INVALID_BLOCK) / 100; 62 } 63 64 static inline block_t limit_free_user_blocks(struct f2fs_sb_info *sbi) 65 { 66 block_t reclaimable_user_blocks = sbi->user_block_count - 67 written_block_count(sbi); 68 return (long)(reclaimable_user_blocks * LIMIT_FREE_BLOCK) / 100; 69 } 70 71 static inline void increase_sleep_time(struct f2fs_gc_kthread *gc_th, 72 unsigned int *wait) 73 { 74 unsigned int min_time = gc_th->min_sleep_time; 75 unsigned int max_time = gc_th->max_sleep_time; 76 77 if (*wait == gc_th->no_gc_sleep_time) 78 return; 79 80 if ((long long)*wait + (long long)min_time > (long long)max_time) 81 *wait = max_time; 82 else 83 *wait += min_time; 84 } 85 86 static inline void decrease_sleep_time(struct f2fs_gc_kthread *gc_th, 87 unsigned int *wait) 88 { 89 unsigned int min_time = gc_th->min_sleep_time; 90 91 if (*wait == gc_th->no_gc_sleep_time) 92 *wait = gc_th->max_sleep_time; 93 94 if ((long long)*wait - (long long)min_time < (long long)min_time) 95 *wait = min_time; 96 else 97 *wait -= min_time; 98 } 99 100 static inline bool has_enough_invalid_blocks(struct f2fs_sb_info *sbi) 101 { 102 block_t invalid_user_blocks = sbi->user_block_count - 103 written_block_count(sbi); 104 /* 105 * Background GC is triggered with the following conditions. 106 * 1. There are a number of invalid blocks. 107 * 2. There is not enough free space. 108 */ 109 if (invalid_user_blocks > limit_invalid_user_blocks(sbi) && 110 free_user_blocks(sbi) < limit_free_user_blocks(sbi)) 111 return true; 112 return false; 113 } 114