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_MIN_SLEEP_TIME 30000 /* milliseconds */ 17 #define DEF_GC_THREAD_MAX_SLEEP_TIME 60000 18 #define DEF_GC_THREAD_NOGC_SLEEP_TIME 300000 /* wait 5 min */ 19 #define LIMIT_INVALID_BLOCK 40 /* percentage over total user space */ 20 #define LIMIT_FREE_BLOCK 40 /* percentage over invalid + free space */ 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 min_sleep_time; 31 unsigned int max_sleep_time; 32 unsigned int no_gc_sleep_time; 33 34 /* for changing gc mode */ 35 unsigned int gc_idle; 36 }; 37 38 struct inode_entry { 39 struct list_head list; 40 struct inode *inode; 41 }; 42 43 struct gc_inode_list { 44 struct list_head ilist; 45 struct radix_tree_root iroot; 46 }; 47 48 /* 49 * inline functions 50 */ 51 static inline block_t free_user_blocks(struct f2fs_sb_info *sbi) 52 { 53 if (free_segments(sbi) < overprovision_segments(sbi)) 54 return 0; 55 else 56 return (free_segments(sbi) - overprovision_segments(sbi)) 57 << sbi->log_blocks_per_seg; 58 } 59 60 static inline block_t limit_invalid_user_blocks(struct f2fs_sb_info *sbi) 61 { 62 return (long)(sbi->user_block_count * LIMIT_INVALID_BLOCK) / 100; 63 } 64 65 static inline block_t limit_free_user_blocks(struct f2fs_sb_info *sbi) 66 { 67 block_t reclaimable_user_blocks = sbi->user_block_count - 68 written_block_count(sbi); 69 return (long)(reclaimable_user_blocks * LIMIT_FREE_BLOCK) / 100; 70 } 71 72 static inline long increase_sleep_time(struct f2fs_gc_kthread *gc_th, long wait) 73 { 74 if (wait == gc_th->no_gc_sleep_time) 75 return wait; 76 77 wait += gc_th->min_sleep_time; 78 if (wait > gc_th->max_sleep_time) 79 wait = gc_th->max_sleep_time; 80 return wait; 81 } 82 83 static inline long decrease_sleep_time(struct f2fs_gc_kthread *gc_th, long wait) 84 { 85 if (wait == gc_th->no_gc_sleep_time) 86 wait = gc_th->max_sleep_time; 87 88 wait -= gc_th->min_sleep_time; 89 if (wait <= gc_th->min_sleep_time) 90 wait = gc_th->min_sleep_time; 91 return wait; 92 } 93 94 static inline bool has_enough_invalid_blocks(struct f2fs_sb_info *sbi) 95 { 96 block_t invalid_user_blocks = sbi->user_block_count - 97 written_block_count(sbi); 98 /* 99 * Background GC is triggered with the following conditions. 100 * 1. There are a number of invalid blocks. 101 * 2. There is not enough free space. 102 */ 103 if (invalid_user_blocks > limit_invalid_user_blocks(sbi) && 104 free_user_blocks(sbi) < limit_free_user_blocks(sbi)) 105 return true; 106 return false; 107 } 108 109 static inline int is_idle(struct f2fs_sb_info *sbi) 110 { 111 struct block_device *bdev = sbi->sb->s_bdev; 112 struct request_queue *q = bdev_get_queue(bdev); 113 struct request_list *rl = &q->root_rl; 114 return !(rl->count[BLK_RW_SYNC]) && !(rl->count[BLK_RW_ASYNC]); 115 } 116