[mirror_ubuntu-hirsute-kernel.git] / fs / f2fs / gc.h

/* SPDX-License-Identifier: GPL-2.0 */
/*
 * fs/f2fs/gc.h
 *
 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
 *             http://www.samsung.com/
 */
#define GC_THREAD_MIN_WB_PAGES		1	/*
						 * a threshold to determine
						 * whether IO subsystem is idle
						 * or not
						 */
#define DEF_GC_THREAD_URGENT_SLEEP_TIME	500	/* 500 ms */
#define DEF_GC_THREAD_MIN_SLEEP_TIME	30000	/* milliseconds */
#define DEF_GC_THREAD_MAX_SLEEP_TIME	60000
#define DEF_GC_THREAD_NOGC_SLEEP_TIME	300000	/* wait 5 min */

/* choose candidates from sections which has age of more than 7 days */
#define DEF_GC_THREAD_AGE_THRESHOLD		(60 * 60 * 24 * 7)
#define DEF_GC_THREAD_CANDIDATE_RATIO		20	/* select 20% oldest sections as candidates */
#define DEF_GC_THREAD_MAX_CANDIDATE_COUNT	10	/* select at most 10 sections as candidates */
#define DEF_GC_THREAD_AGE_WEIGHT		60	/* age weight */
#define DEFAULT_ACCURACY_CLASS			10000	/* accuracy class */

#define LIMIT_INVALID_BLOCK	40 /* percentage over total user space */
#define LIMIT_FREE_BLOCK	40 /* percentage over invalid + free space */

#define DEF_GC_FAILED_PINNED_FILES	2048

/* Search max. number of dirty segments to select a victim segment */
#define DEF_MAX_VICTIM_SEARCH 4096 /* covers 8GB */

struct f2fs_gc_kthread {
	struct task_struct *f2fs_gc_task;
	wait_queue_head_t gc_wait_queue_head;

	/* for gc sleep time */
	unsigned int urgent_sleep_time;
	unsigned int min_sleep_time;
	unsigned int max_sleep_time;
	unsigned int no_gc_sleep_time;

	/* for changing gc mode */
	unsigned int gc_wake;
};

struct gc_inode_list {
	struct list_head ilist;
	struct radix_tree_root iroot;
};

struct victim_info {
	unsigned long long mtime;	/* mtime of section */
	unsigned int segno;		/* section No. */
};

struct victim_entry {
	struct rb_node rb_node;		/* rb node located in rb-tree */
	union {
		struct {
			unsigned long long mtime;	/* mtime of section */
			unsigned int segno;		/* segment No. */
		};
		struct victim_info vi;	/* victim info */
	};
	struct list_head list;
};

/*
 * inline functions
 */

/*
 * On a Zoned device zone-capacity can be less than zone-size and if
 * zone-capacity is not aligned to f2fs segment size(2MB), then the segment
 * starting just before zone-capacity has some blocks spanning across the
 * zone-capacity, these blocks are not usable.
 * Such spanning segments can be in free list so calculate the sum of usable
 * blocks in currently free segments including normal and spanning segments.
 */
static inline block_t free_segs_blk_count_zoned(struct f2fs_sb_info *sbi)
{
	block_t free_seg_blks = 0;
	struct free_segmap_info *free_i = FREE_I(sbi);
	int j;

	spin_lock(&free_i->segmap_lock);
	for (j = 0; j < MAIN_SEGS(sbi); j++)
		if (!test_bit(j, free_i->free_segmap))
			free_seg_blks += f2fs_usable_blks_in_seg(sbi, j);
	spin_unlock(&free_i->segmap_lock);

	return free_seg_blks;
}

static inline block_t free_segs_blk_count(struct f2fs_sb_info *sbi)
{
	if (f2fs_sb_has_blkzoned(sbi))
		return free_segs_blk_count_zoned(sbi);

	return free_segments(sbi) << sbi->log_blocks_per_seg;
}

static inline block_t free_user_blocks(struct f2fs_sb_info *sbi)
{
	block_t free_blks, ovp_blks;

	free_blks = free_segs_blk_count(sbi);
	ovp_blks = overprovision_segments(sbi) << sbi->log_blocks_per_seg;

	if (free_blks < ovp_blks)
		return 0;

	return free_blks - ovp_blks;
}

static inline block_t limit_invalid_user_blocks(struct f2fs_sb_info *sbi)
{
	return (long)(sbi->user_block_count * LIMIT_INVALID_BLOCK) / 100;
}

static inline block_t limit_free_user_blocks(struct f2fs_sb_info *sbi)
{
	block_t reclaimable_user_blocks = sbi->user_block_count -
		written_block_count(sbi);
	return (long)(reclaimable_user_blocks * LIMIT_FREE_BLOCK) / 100;
}

static inline void increase_sleep_time(struct f2fs_gc_kthread *gc_th,
							unsigned int *wait)
{
	unsigned int min_time = gc_th->min_sleep_time;
	unsigned int max_time = gc_th->max_sleep_time;

	if (*wait == gc_th->no_gc_sleep_time)
		return;

	if ((long long)*wait + (long long)min_time > (long long)max_time)
		*wait = max_time;
	else
		*wait += min_time;
}

static inline void decrease_sleep_time(struct f2fs_gc_kthread *gc_th,
							unsigned int *wait)
{
	unsigned int min_time = gc_th->min_sleep_time;

	if (*wait == gc_th->no_gc_sleep_time)
		*wait = gc_th->max_sleep_time;

	if ((long long)*wait - (long long)min_time < (long long)min_time)
		*wait = min_time;
	else
		*wait -= min_time;
}

static inline bool has_enough_invalid_blocks(struct f2fs_sb_info *sbi)
{
	block_t invalid_user_blocks = sbi->user_block_count -
					written_block_count(sbi);
	/*
	 * Background GC is triggered with the following conditions.
	 * 1. There are a number of invalid blocks.
	 * 2. There is not enough free space.
	 */
	if (invalid_user_blocks > limit_invalid_user_blocks(sbi) &&
			free_user_blocks(sbi) < limit_free_user_blocks(sbi))
		return true;
	return false;
}
Commit	Line	Data
d29fbcdb	1	/* SPDX-License-Identifier: GPL-2.0 */
0a8165d7	2	/*
7bc09003 JK	3	* fs/f2fs/gc.h
	4	*
	5	* Copyright (c) 2012 Samsung Electronics Co., Ltd.
	6	* http://www.samsung.com/
7bc09003	7	*/
7bc09003 JK	8	#define GC_THREAD_MIN_WB_PAGES 1 /*
	9	* a threshold to determine
	10	* whether IO subsystem is idle
	11	* or not
	12	*/
d9872a69	13	#define DEF_GC_THREAD_URGENT_SLEEP_TIME 500 /* 500 ms */
b59d0bae NJ	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 */
093749e2 CY	17
	18	/* choose candidates from sections which has age of more than 7 days */
	19	#define DEF_GC_THREAD_AGE_THRESHOLD (60 * 60 * 24 * 7)
	20	#define DEF_GC_THREAD_CANDIDATE_RATIO 20 /* select 20% oldest sections as candidates */
	21	#define DEF_GC_THREAD_MAX_CANDIDATE_COUNT 10 /* select at most 10 sections as candidates */
	22	#define DEF_GC_THREAD_AGE_WEIGHT 60 /* age weight */
	23	#define DEFAULT_ACCURACY_CLASS 10000 /* accuracy class */
	24
7bc09003 JK	25	#define LIMIT_INVALID_BLOCK 40 /* percentage over total user space */
	26	#define LIMIT_FREE_BLOCK 40 /* percentage over invalid + free space */
	27
1ad71a27 JK	28	#define DEF_GC_FAILED_PINNED_FILES 2048
1ad71a27 JK	29
7bc09003	30	/* Search max. number of dirty segments to select a victim segment */
b1c57c1c	31	#define DEF_MAX_VICTIM_SEARCH 4096 /* covers 8GB */
7bc09003	32
7bc09003 JK	33	struct f2fs_gc_kthread {
	34	struct task_struct *f2fs_gc_task;
	35	wait_queue_head_t gc_wait_queue_head;
b59d0bae NJ	36
b59d0bae NJ	37	/* for gc sleep time */
d9872a69	38	unsigned int urgent_sleep_time;
b59d0bae NJ	39	unsigned int min_sleep_time;
	40	unsigned int max_sleep_time;
	41	unsigned int no_gc_sleep_time;
d2dc095f NJ	42
d2dc095f NJ	43	/* for changing gc mode */
d9872a69	44	unsigned int gc_wake;
7bc09003 JK	45	};
7bc09003 JK	46
7dda2af8 CL	47	struct gc_inode_list {
	48	struct list_head ilist;
	49	struct radix_tree_root iroot;
	50	};
	51
093749e2 CY	52	struct victim_info {
	53	unsigned long long mtime; /* mtime of section */
	54	unsigned int segno; /* section No. */
	55	};
	56
	57	struct victim_entry {
	58	struct rb_node rb_node; /* rb node located in rb-tree */
	59	union {
	60	struct {
	61	unsigned long long mtime; /* mtime of section */
	62	unsigned int segno; /* segment No. */
	63	};
	64	struct victim_info vi; /* victim info */
	65	};
	66	struct list_head list;
	67	};
	68
0a8165d7	69	/*
7bc09003 JK	70	* inline functions
7bc09003 JK	71	*/
de881df9 AR	72
	73	/*
	74	* On a Zoned device zone-capacity can be less than zone-size and if
	75	* zone-capacity is not aligned to f2fs segment size(2MB), then the segment
	76	* starting just before zone-capacity has some blocks spanning across the
	77	* zone-capacity, these blocks are not usable.
	78	* Such spanning segments can be in free list so calculate the sum of usable
	79	* blocks in currently free segments including normal and spanning segments.
	80	*/
	81	static inline block_t free_segs_blk_count_zoned(struct f2fs_sb_info *sbi)
	82	{
	83	block_t free_seg_blks = 0;
	84	struct free_segmap_info *free_i = FREE_I(sbi);
	85	int j;
	86
	87	spin_lock(&free_i->segmap_lock);
	88	for (j = 0; j < MAIN_SEGS(sbi); j++)
	89	if (!test_bit(j, free_i->free_segmap))
	90	free_seg_blks += f2fs_usable_blks_in_seg(sbi, j);
	91	spin_unlock(&free_i->segmap_lock);
	92
	93	return free_seg_blks;
	94	}
	95
	96	static inline block_t free_segs_blk_count(struct f2fs_sb_info *sbi)
	97	{
	98	if (f2fs_sb_has_blkzoned(sbi))
	99	return free_segs_blk_count_zoned(sbi);
	100
	101	return free_segments(sbi) << sbi->log_blocks_per_seg;
	102	}
	103
7bc09003 JK	104	static inline block_t free_user_blocks(struct f2fs_sb_info *sbi)
7bc09003 JK	105	{
de881df9 AR	106	block_t free_blks, ovp_blks;
	107
	108	free_blks = free_segs_blk_count(sbi);
	109	ovp_blks = overprovision_segments(sbi) << sbi->log_blocks_per_seg;
	110
	111	if (free_blks < ovp_blks)
7bc09003	112	return 0;
de881df9 AR	113
de881df9 AR	114	return free_blks - ovp_blks;
7bc09003 JK	115	}
	116
	117	static inline block_t limit_invalid_user_blocks(struct f2fs_sb_info *sbi)
	118	{
	119	return (long)(sbi->user_block_count * LIMIT_INVALID_BLOCK) / 100;
	120	}
	121
	122	static inline block_t limit_free_user_blocks(struct f2fs_sb_info *sbi)
	123	{
	124	block_t reclaimable_user_blocks = sbi->user_block_count -
	125	written_block_count(sbi);
	126	return (long)(reclaimable_user_blocks * LIMIT_FREE_BLOCK) / 100;
	127	}
	128
88dd8934	129	static inline void increase_sleep_time(struct f2fs_gc_kthread *gc_th,
b8c502b8	130	unsigned int *wait)
7bc09003	131	{
b8c502b8 CY	132	unsigned int min_time = gc_th->min_sleep_time;
	133	unsigned int max_time = gc_th->max_sleep_time;
	134
88dd8934 CY	135	if (*wait == gc_th->no_gc_sleep_time)
88dd8934 CY	136	return;
6cb968d9	137
b8c502b8 CY	138	if ((long long)*wait + (long long)min_time > (long long)max_time)
	139	*wait = max_time;
	140	else
	141	*wait += min_time;
7bc09003 JK	142	}
7bc09003 JK	143
88dd8934	144	static inline void decrease_sleep_time(struct f2fs_gc_kthread *gc_th,
b8c502b8	145	unsigned int *wait)
7bc09003	146	{
b8c502b8 CY	147	unsigned int min_time = gc_th->min_sleep_time;
b8c502b8 CY	148
88dd8934 CY	149	if (*wait == gc_th->no_gc_sleep_time)
88dd8934 CY	150	*wait = gc_th->max_sleep_time;
6cb968d9	151
b8c502b8 CY	152	if ((long long)*wait - (long long)min_time < (long long)min_time)
	153	*wait = min_time;
	154	else
	155	*wait -= min_time;
7bc09003 JK	156	}
	157
	158	static inline bool has_enough_invalid_blocks(struct f2fs_sb_info *sbi)
	159	{
	160	block_t invalid_user_blocks = sbi->user_block_count -
	161	written_block_count(sbi);
	162	/*
e1c42045	163	* Background GC is triggered with the following conditions.
7bc09003 JK	164	* 1. There are a number of invalid blocks.
	165	* 2. There is not enough free space.
	166	*/
	167	if (invalid_user_blocks > limit_invalid_user_blocks(sbi) &&
	168	free_user_blocks(sbi) < limit_free_user_blocks(sbi))
	169	return true;
	170	return false;
	171	}