1 /* SPDX-License-Identifier: GPL-2.0 */
2 /*
3  * fs/f2fs/segment.h
4  *
5  * Copyright (c) 2012 Samsung Electronics Co., Ltd.
6  *             http://www.samsung.com/
7  */
8 #include <linux/blkdev.h>
9 #include <linux/backing-dev.h>
10 
11 /* constant macro */
12 #define NULL_SEGNO			((unsigned int)(~0))
13 #define NULL_SECNO			((unsigned int)(~0))
14 
15 #define DEF_RECLAIM_PREFREE_SEGMENTS	5	/* 5% over total segments */
16 #define DEF_MAX_RECLAIM_PREFREE_SEGMENTS	4096	/* 8GB in maximum */
17 
18 #define F2FS_MIN_SEGMENTS	9 /* SB + 2 (CP + SIT + NAT) + SSA + MAIN */
19 #define F2FS_MIN_META_SEGMENTS	8 /* SB + 2 (CP + SIT + NAT) + SSA */
20 
21 /* L: Logical segment # in volume, R: Relative segment # in main area */
22 #define GET_L2R_SEGNO(free_i, segno)	((segno) - (free_i)->start_segno)
23 #define GET_R2L_SEGNO(free_i, segno)	((segno) + (free_i)->start_segno)
24 
25 #define IS_DATASEG(t)	((t) <= CURSEG_COLD_DATA)
26 #define IS_NODESEG(t)	((t) >= CURSEG_HOT_NODE && (t) <= CURSEG_COLD_NODE)
27 #define SE_PAGETYPE(se)	((IS_NODESEG((se)->type) ? NODE : DATA))
28 
sanity_check_seg_type(struct f2fs_sb_info * sbi,unsigned short seg_type)29 static inline void sanity_check_seg_type(struct f2fs_sb_info *sbi,
30 						unsigned short seg_type)
31 {
32 	f2fs_bug_on(sbi, seg_type >= NR_PERSISTENT_LOG);
33 }
34 
35 #define IS_HOT(t)	((t) == CURSEG_HOT_NODE || (t) == CURSEG_HOT_DATA)
36 #define IS_WARM(t)	((t) == CURSEG_WARM_NODE || (t) == CURSEG_WARM_DATA)
37 #define IS_COLD(t)	((t) == CURSEG_COLD_NODE || (t) == CURSEG_COLD_DATA)
38 
39 #define IS_CURSEG(sbi, seg)						\
40 	(((seg) == CURSEG_I(sbi, CURSEG_HOT_DATA)->segno) ||	\
41 	 ((seg) == CURSEG_I(sbi, CURSEG_WARM_DATA)->segno) ||	\
42 	 ((seg) == CURSEG_I(sbi, CURSEG_COLD_DATA)->segno) ||	\
43 	 ((seg) == CURSEG_I(sbi, CURSEG_HOT_NODE)->segno) ||	\
44 	 ((seg) == CURSEG_I(sbi, CURSEG_WARM_NODE)->segno) ||	\
45 	 ((seg) == CURSEG_I(sbi, CURSEG_COLD_NODE)->segno) ||	\
46 	 ((seg) == CURSEG_I(sbi, CURSEG_COLD_DATA_PINNED)->segno) ||	\
47 	 ((seg) == CURSEG_I(sbi, CURSEG_ALL_DATA_ATGC)->segno))
48 
49 #define IS_CURSEC(sbi, secno)						\
50 	(((secno) == CURSEG_I(sbi, CURSEG_HOT_DATA)->segno /		\
51 	  (sbi)->segs_per_sec) ||	\
52 	 ((secno) == CURSEG_I(sbi, CURSEG_WARM_DATA)->segno /		\
53 	  (sbi)->segs_per_sec) ||	\
54 	 ((secno) == CURSEG_I(sbi, CURSEG_COLD_DATA)->segno /		\
55 	  (sbi)->segs_per_sec) ||	\
56 	 ((secno) == CURSEG_I(sbi, CURSEG_HOT_NODE)->segno /		\
57 	  (sbi)->segs_per_sec) ||	\
58 	 ((secno) == CURSEG_I(sbi, CURSEG_WARM_NODE)->segno /		\
59 	  (sbi)->segs_per_sec) ||	\
60 	 ((secno) == CURSEG_I(sbi, CURSEG_COLD_NODE)->segno /		\
61 	  (sbi)->segs_per_sec) ||	\
62 	 ((secno) == CURSEG_I(sbi, CURSEG_COLD_DATA_PINNED)->segno /	\
63 	  (sbi)->segs_per_sec) ||	\
64 	 ((secno) == CURSEG_I(sbi, CURSEG_ALL_DATA_ATGC)->segno /	\
65 	  (sbi)->segs_per_sec))
66 
67 #define MAIN_BLKADDR(sbi)						\
68 	(SM_I(sbi) ? SM_I(sbi)->main_blkaddr : 				\
69 		le32_to_cpu(F2FS_RAW_SUPER(sbi)->main_blkaddr))
70 #define SEG0_BLKADDR(sbi)						\
71 	(SM_I(sbi) ? SM_I(sbi)->seg0_blkaddr : 				\
72 		le32_to_cpu(F2FS_RAW_SUPER(sbi)->segment0_blkaddr))
73 
74 #define MAIN_SEGS(sbi)	(SM_I(sbi)->main_segments)
75 #define MAIN_SECS(sbi)	((sbi)->total_sections)
76 
77 #define TOTAL_SEGS(sbi)							\
78 	(SM_I(sbi) ? SM_I(sbi)->segment_count : 				\
79 		le32_to_cpu(F2FS_RAW_SUPER(sbi)->segment_count))
80 #define TOTAL_BLKS(sbi)	(TOTAL_SEGS(sbi) << (sbi)->log_blocks_per_seg)
81 
82 #define MAX_BLKADDR(sbi)	(SEG0_BLKADDR(sbi) + TOTAL_BLKS(sbi))
83 #define SEGMENT_SIZE(sbi)	(1ULL << ((sbi)->log_blocksize +	\
84 					(sbi)->log_blocks_per_seg))
85 
86 #define START_BLOCK(sbi, segno)	(SEG0_BLKADDR(sbi) +			\
87 	 (GET_R2L_SEGNO(FREE_I(sbi), segno) << (sbi)->log_blocks_per_seg))
88 
89 #define NEXT_FREE_BLKADDR(sbi, curseg)					\
90 	(START_BLOCK(sbi, (curseg)->segno) + (curseg)->next_blkoff)
91 
92 #define GET_SEGOFF_FROM_SEG0(sbi, blk_addr)	((blk_addr) - SEG0_BLKADDR(sbi))
93 #define GET_SEGNO_FROM_SEG0(sbi, blk_addr)				\
94 	(GET_SEGOFF_FROM_SEG0(sbi, blk_addr) >> (sbi)->log_blocks_per_seg)
95 #define GET_BLKOFF_FROM_SEG0(sbi, blk_addr)				\
96 	(GET_SEGOFF_FROM_SEG0(sbi, blk_addr) & ((sbi)->blocks_per_seg - 1))
97 
98 #define GET_SEGNO(sbi, blk_addr)					\
99 	((!__is_valid_data_blkaddr(blk_addr)) ?			\
100 	NULL_SEGNO : GET_L2R_SEGNO(FREE_I(sbi),			\
101 		GET_SEGNO_FROM_SEG0(sbi, blk_addr)))
102 #define BLKS_PER_SEC(sbi)					\
103 	((sbi)->segs_per_sec * (sbi)->blocks_per_seg)
104 #define GET_SEC_FROM_SEG(sbi, segno)				\
105 	(((segno) == -1) ? -1: (segno) / (sbi)->segs_per_sec)
106 #define GET_SEG_FROM_SEC(sbi, secno)				\
107 	((secno) * (sbi)->segs_per_sec)
108 #define GET_ZONE_FROM_SEC(sbi, secno)				\
109 	(((secno) == -1) ? -1: (secno) / (sbi)->secs_per_zone)
110 #define GET_ZONE_FROM_SEG(sbi, segno)				\
111 	GET_ZONE_FROM_SEC(sbi, GET_SEC_FROM_SEG(sbi, segno))
112 
113 #define GET_SUM_BLOCK(sbi, segno)				\
114 	((sbi)->sm_info->ssa_blkaddr + (segno))
115 
116 #define GET_SUM_TYPE(footer) ((footer)->entry_type)
117 #define SET_SUM_TYPE(footer, type) ((footer)->entry_type = (type))
118 
119 #define SIT_ENTRY_OFFSET(sit_i, segno)					\
120 	((segno) % (sit_i)->sents_per_block)
121 #define SIT_BLOCK_OFFSET(segno)					\
122 	((segno) / SIT_ENTRY_PER_BLOCK)
123 #define	START_SEGNO(segno)		\
124 	(SIT_BLOCK_OFFSET(segno) * SIT_ENTRY_PER_BLOCK)
125 #define SIT_BLK_CNT(sbi)			\
126 	DIV_ROUND_UP(MAIN_SEGS(sbi), SIT_ENTRY_PER_BLOCK)
127 #define f2fs_bitmap_size(nr)			\
128 	(BITS_TO_LONGS(nr) * sizeof(unsigned long))
129 
130 #define SECTOR_FROM_BLOCK(blk_addr)					\
131 	(((sector_t)blk_addr) << F2FS_LOG_SECTORS_PER_BLOCK)
132 #define SECTOR_TO_BLOCK(sectors)					\
133 	((sectors) >> F2FS_LOG_SECTORS_PER_BLOCK)
134 
135 /*
136  * indicate a block allocation direction: RIGHT and LEFT.
137  * RIGHT means allocating new sections towards the end of volume.
138  * LEFT means the opposite direction.
139  */
140 enum {
141 	ALLOC_RIGHT = 0,
142 	ALLOC_LEFT
143 };
144 
145 /*
146  * In the victim_sel_policy->alloc_mode, there are three block allocation modes.
147  * LFS writes data sequentially with cleaning operations.
148  * SSR (Slack Space Recycle) reuses obsolete space without cleaning operations.
149  * AT_SSR (Age Threshold based Slack Space Recycle) merges fragments into
150  * fragmented segment which has similar aging degree.
151  */
152 enum {
153 	LFS = 0,
154 	SSR,
155 	AT_SSR,
156 };
157 
158 /*
159  * In the victim_sel_policy->gc_mode, there are three gc, aka cleaning, modes.
160  * GC_CB is based on cost-benefit algorithm.
161  * GC_GREEDY is based on greedy algorithm.
162  * GC_AT is based on age-threshold algorithm.
163  */
164 enum {
165 	GC_CB = 0,
166 	GC_GREEDY,
167 	GC_AT,
168 	ALLOC_NEXT,
169 	FLUSH_DEVICE,
170 	MAX_GC_POLICY,
171 };
172 
173 /*
174  * BG_GC means the background cleaning job.
175  * FG_GC means the on-demand cleaning job.
176  */
177 enum {
178 	BG_GC = 0,
179 	FG_GC,
180 };
181 
182 /* for a function parameter to select a victim segment */
183 struct victim_sel_policy {
184 	int alloc_mode;			/* LFS or SSR */
185 	int gc_mode;			/* GC_CB or GC_GREEDY */
186 	unsigned long *dirty_bitmap;	/* dirty segment/section bitmap */
187 	unsigned int max_search;	/*
188 					 * maximum # of segments/sections
189 					 * to search
190 					 */
191 	unsigned int offset;		/* last scanned bitmap offset */
192 	unsigned int ofs_unit;		/* bitmap search unit */
193 	unsigned int min_cost;		/* minimum cost */
194 	unsigned long long oldest_age;	/* oldest age of segments having the same min cost */
195 	unsigned int min_segno;		/* segment # having min. cost */
196 	unsigned long long age;		/* mtime of GCed section*/
197 	unsigned long long age_threshold;/* age threshold */
198 };
199 
200 struct seg_entry {
201 	unsigned int type:6;		/* segment type like CURSEG_XXX_TYPE */
202 	unsigned int valid_blocks:10;	/* # of valid blocks */
203 	unsigned int ckpt_valid_blocks:10;	/* # of valid blocks last cp */
204 	unsigned int padding:6;		/* padding */
205 	unsigned char *cur_valid_map;	/* validity bitmap of blocks */
206 #ifdef CONFIG_F2FS_CHECK_FS
207 	unsigned char *cur_valid_map_mir;	/* mirror of current valid bitmap */
208 #endif
209 	/*
210 	 * # of valid blocks and the validity bitmap stored in the last
211 	 * checkpoint pack. This information is used by the SSR mode.
212 	 */
213 	unsigned char *ckpt_valid_map;	/* validity bitmap of blocks last cp */
214 	unsigned char *discard_map;
215 	unsigned long long mtime;	/* modification time of the segment */
216 };
217 
218 struct sec_entry {
219 	unsigned int valid_blocks;	/* # of valid blocks in a section */
220 };
221 
222 struct segment_allocation {
223 	void (*allocate_segment)(struct f2fs_sb_info *, int, bool);
224 };
225 
226 #define MAX_SKIP_GC_COUNT			16
227 
228 struct revoke_entry {
229 	struct list_head list;
230 	block_t old_addr;		/* for revoking when fail to commit */
231 	pgoff_t index;
232 };
233 
234 struct sit_info {
235 	const struct segment_allocation *s_ops;
236 
237 	block_t sit_base_addr;		/* start block address of SIT area */
238 	block_t sit_blocks;		/* # of blocks used by SIT area */
239 	block_t written_valid_blocks;	/* # of valid blocks in main area */
240 	char *bitmap;			/* all bitmaps pointer */
241 	char *sit_bitmap;		/* SIT bitmap pointer */
242 #ifdef CONFIG_F2FS_CHECK_FS
243 	char *sit_bitmap_mir;		/* SIT bitmap mirror */
244 
245 	/* bitmap of segments to be ignored by GC in case of errors */
246 	unsigned long *invalid_segmap;
247 #endif
248 	unsigned int bitmap_size;	/* SIT bitmap size */
249 
250 	unsigned long *tmp_map;			/* bitmap for temporal use */
251 	unsigned long *dirty_sentries_bitmap;	/* bitmap for dirty sentries */
252 	unsigned int dirty_sentries;		/* # of dirty sentries */
253 	unsigned int sents_per_block;		/* # of SIT entries per block */
254 	struct rw_semaphore sentry_lock;	/* to protect SIT cache */
255 	struct seg_entry *sentries;		/* SIT segment-level cache */
256 	struct sec_entry *sec_entries;		/* SIT section-level cache */
257 
258 	/* for cost-benefit algorithm in cleaning procedure */
259 	unsigned long long elapsed_time;	/* elapsed time after mount */
260 	unsigned long long mounted_time;	/* mount time */
261 	unsigned long long min_mtime;		/* min. modification time */
262 	unsigned long long max_mtime;		/* max. modification time */
263 	unsigned long long dirty_min_mtime;	/* rerange candidates in GC_AT */
264 	unsigned long long dirty_max_mtime;	/* rerange candidates in GC_AT */
265 
266 	unsigned int last_victim[MAX_GC_POLICY]; /* last victim segment # */
267 };
268 
269 struct free_segmap_info {
270 	unsigned int start_segno;	/* start segment number logically */
271 	unsigned int free_segments;	/* # of free segments */
272 	unsigned int free_sections;	/* # of free sections */
273 	spinlock_t segmap_lock;		/* free segmap lock */
274 	unsigned long *free_segmap;	/* free segment bitmap */
275 	unsigned long *free_secmap;	/* free section bitmap */
276 };
277 
278 /* Notice: The order of dirty type is same with CURSEG_XXX in f2fs.h */
279 enum dirty_type {
280 	DIRTY_HOT_DATA,		/* dirty segments assigned as hot data logs */
281 	DIRTY_WARM_DATA,	/* dirty segments assigned as warm data logs */
282 	DIRTY_COLD_DATA,	/* dirty segments assigned as cold data logs */
283 	DIRTY_HOT_NODE,		/* dirty segments assigned as hot node logs */
284 	DIRTY_WARM_NODE,	/* dirty segments assigned as warm node logs */
285 	DIRTY_COLD_NODE,	/* dirty segments assigned as cold node logs */
286 	DIRTY,			/* to count # of dirty segments */
287 	PRE,			/* to count # of entirely obsolete segments */
288 	NR_DIRTY_TYPE
289 };
290 
291 struct dirty_seglist_info {
292 	const struct victim_selection *v_ops;	/* victim selction operation */
293 	unsigned long *dirty_segmap[NR_DIRTY_TYPE];
294 	unsigned long *dirty_secmap;
295 	struct mutex seglist_lock;		/* lock for segment bitmaps */
296 	int nr_dirty[NR_DIRTY_TYPE];		/* # of dirty segments */
297 	unsigned long *victim_secmap;		/* background GC victims */
298 	unsigned long *pinned_secmap;		/* pinned victims from foreground GC */
299 	unsigned int pinned_secmap_cnt;		/* count of victims which has pinned data */
300 	bool enable_pin_section;		/* enable pinning section */
301 };
302 
303 /* victim selection function for cleaning and SSR */
304 struct victim_selection {
305 	int (*get_victim)(struct f2fs_sb_info *, unsigned int *,
306 					int, int, char, unsigned long long);
307 };
308 
309 /* for active log information */
310 struct curseg_info {
311 	struct mutex curseg_mutex;		/* lock for consistency */
312 	struct f2fs_summary_block *sum_blk;	/* cached summary block */
313 	struct rw_semaphore journal_rwsem;	/* protect journal area */
314 	struct f2fs_journal *journal;		/* cached journal info */
315 	unsigned char alloc_type;		/* current allocation type */
316 	unsigned short seg_type;		/* segment type like CURSEG_XXX_TYPE */
317 	unsigned int segno;			/* current segment number */
318 	unsigned short next_blkoff;		/* next block offset to write */
319 	unsigned int zone;			/* current zone number */
320 	unsigned int next_segno;		/* preallocated segment */
321 	int fragment_remained_chunk;		/* remained block size in a chunk for block fragmentation mode */
322 	bool inited;				/* indicate inmem log is inited */
323 };
324 
325 struct sit_entry_set {
326 	struct list_head set_list;	/* link with all sit sets */
327 	unsigned int start_segno;	/* start segno of sits in set */
328 	unsigned int entry_cnt;		/* the # of sit entries in set */
329 };
330 
331 /*
332  * inline functions
333  */
CURSEG_I(struct f2fs_sb_info * sbi,int type)334 static inline struct curseg_info *CURSEG_I(struct f2fs_sb_info *sbi, int type)
335 {
336 	return (struct curseg_info *)(SM_I(sbi)->curseg_array + type);
337 }
338 
get_seg_entry(struct f2fs_sb_info * sbi,unsigned int segno)339 static inline struct seg_entry *get_seg_entry(struct f2fs_sb_info *sbi,
340 						unsigned int segno)
341 {
342 	struct sit_info *sit_i = SIT_I(sbi);
343 	return &sit_i->sentries[segno];
344 }
345 
get_sec_entry(struct f2fs_sb_info * sbi,unsigned int segno)346 static inline struct sec_entry *get_sec_entry(struct f2fs_sb_info *sbi,
347 						unsigned int segno)
348 {
349 	struct sit_info *sit_i = SIT_I(sbi);
350 	return &sit_i->sec_entries[GET_SEC_FROM_SEG(sbi, segno)];
351 }
352 
get_valid_blocks(struct f2fs_sb_info * sbi,unsigned int segno,bool use_section)353 static inline unsigned int get_valid_blocks(struct f2fs_sb_info *sbi,
354 				unsigned int segno, bool use_section)
355 {
356 	/*
357 	 * In order to get # of valid blocks in a section instantly from many
358 	 * segments, f2fs manages two counting structures separately.
359 	 */
360 	if (use_section && __is_large_section(sbi))
361 		return get_sec_entry(sbi, segno)->valid_blocks;
362 	else
363 		return get_seg_entry(sbi, segno)->valid_blocks;
364 }
365 
get_ckpt_valid_blocks(struct f2fs_sb_info * sbi,unsigned int segno,bool use_section)366 static inline unsigned int get_ckpt_valid_blocks(struct f2fs_sb_info *sbi,
367 				unsigned int segno, bool use_section)
368 {
369 	if (use_section && __is_large_section(sbi)) {
370 		unsigned int start_segno = START_SEGNO(segno);
371 		unsigned int blocks = 0;
372 		int i;
373 
374 		for (i = 0; i < sbi->segs_per_sec; i++, start_segno++) {
375 			struct seg_entry *se = get_seg_entry(sbi, start_segno);
376 
377 			blocks += se->ckpt_valid_blocks;
378 		}
379 		return blocks;
380 	}
381 	return get_seg_entry(sbi, segno)->ckpt_valid_blocks;
382 }
383 
seg_info_from_raw_sit(struct seg_entry * se,struct f2fs_sit_entry * rs)384 static inline void seg_info_from_raw_sit(struct seg_entry *se,
385 					struct f2fs_sit_entry *rs)
386 {
387 	se->valid_blocks = GET_SIT_VBLOCKS(rs);
388 	se->ckpt_valid_blocks = GET_SIT_VBLOCKS(rs);
389 	memcpy(se->cur_valid_map, rs->valid_map, SIT_VBLOCK_MAP_SIZE);
390 	memcpy(se->ckpt_valid_map, rs->valid_map, SIT_VBLOCK_MAP_SIZE);
391 #ifdef CONFIG_F2FS_CHECK_FS
392 	memcpy(se->cur_valid_map_mir, rs->valid_map, SIT_VBLOCK_MAP_SIZE);
393 #endif
394 	se->type = GET_SIT_TYPE(rs);
395 	se->mtime = le64_to_cpu(rs->mtime);
396 }
397 
__seg_info_to_raw_sit(struct seg_entry * se,struct f2fs_sit_entry * rs)398 static inline void __seg_info_to_raw_sit(struct seg_entry *se,
399 					struct f2fs_sit_entry *rs)
400 {
401 	unsigned short raw_vblocks = (se->type << SIT_VBLOCKS_SHIFT) |
402 					se->valid_blocks;
403 	rs->vblocks = cpu_to_le16(raw_vblocks);
404 	memcpy(rs->valid_map, se->cur_valid_map, SIT_VBLOCK_MAP_SIZE);
405 	rs->mtime = cpu_to_le64(se->mtime);
406 }
407 
seg_info_to_sit_page(struct f2fs_sb_info * sbi,struct page * page,unsigned int start)408 static inline void seg_info_to_sit_page(struct f2fs_sb_info *sbi,
409 				struct page *page, unsigned int start)
410 {
411 	struct f2fs_sit_block *raw_sit;
412 	struct seg_entry *se;
413 	struct f2fs_sit_entry *rs;
414 	unsigned int end = min(start + SIT_ENTRY_PER_BLOCK,
415 					(unsigned long)MAIN_SEGS(sbi));
416 	int i;
417 
418 	raw_sit = (struct f2fs_sit_block *)page_address(page);
419 	memset(raw_sit, 0, PAGE_SIZE);
420 	for (i = 0; i < end - start; i++) {
421 		rs = &raw_sit->entries[i];
422 		se = get_seg_entry(sbi, start + i);
423 		__seg_info_to_raw_sit(se, rs);
424 	}
425 }
426 
seg_info_to_raw_sit(struct seg_entry * se,struct f2fs_sit_entry * rs)427 static inline void seg_info_to_raw_sit(struct seg_entry *se,
428 					struct f2fs_sit_entry *rs)
429 {
430 	__seg_info_to_raw_sit(se, rs);
431 
432 	memcpy(se->ckpt_valid_map, rs->valid_map, SIT_VBLOCK_MAP_SIZE);
433 	se->ckpt_valid_blocks = se->valid_blocks;
434 }
435 
find_next_inuse(struct free_segmap_info * free_i,unsigned int max,unsigned int segno)436 static inline unsigned int find_next_inuse(struct free_segmap_info *free_i,
437 		unsigned int max, unsigned int segno)
438 {
439 	unsigned int ret;
440 	spin_lock(&free_i->segmap_lock);
441 	ret = find_next_bit(free_i->free_segmap, max, segno);
442 	spin_unlock(&free_i->segmap_lock);
443 	return ret;
444 }
445 
__set_free(struct f2fs_sb_info * sbi,unsigned int segno)446 static inline void __set_free(struct f2fs_sb_info *sbi, unsigned int segno)
447 {
448 	struct free_segmap_info *free_i = FREE_I(sbi);
449 	unsigned int secno = GET_SEC_FROM_SEG(sbi, segno);
450 	unsigned int start_segno = GET_SEG_FROM_SEC(sbi, secno);
451 	unsigned int next;
452 	unsigned int usable_segs = f2fs_usable_segs_in_sec(sbi, segno);
453 
454 	spin_lock(&free_i->segmap_lock);
455 	clear_bit(segno, free_i->free_segmap);
456 	free_i->free_segments++;
457 
458 	next = find_next_bit(free_i->free_segmap,
459 			start_segno + sbi->segs_per_sec, start_segno);
460 	if (next >= start_segno + usable_segs) {
461 		clear_bit(secno, free_i->free_secmap);
462 		free_i->free_sections++;
463 	}
464 	spin_unlock(&free_i->segmap_lock);
465 }
466 
__set_inuse(struct f2fs_sb_info * sbi,unsigned int segno)467 static inline void __set_inuse(struct f2fs_sb_info *sbi,
468 		unsigned int segno)
469 {
470 	struct free_segmap_info *free_i = FREE_I(sbi);
471 	unsigned int secno = GET_SEC_FROM_SEG(sbi, segno);
472 
473 	set_bit(segno, free_i->free_segmap);
474 	free_i->free_segments--;
475 	if (!test_and_set_bit(secno, free_i->free_secmap))
476 		free_i->free_sections--;
477 }
478 
__set_test_and_free(struct f2fs_sb_info * sbi,unsigned int segno,bool inmem)479 static inline void __set_test_and_free(struct f2fs_sb_info *sbi,
480 		unsigned int segno, bool inmem)
481 {
482 	struct free_segmap_info *free_i = FREE_I(sbi);
483 	unsigned int secno = GET_SEC_FROM_SEG(sbi, segno);
484 	unsigned int start_segno = GET_SEG_FROM_SEC(sbi, secno);
485 	unsigned int next;
486 	unsigned int usable_segs = f2fs_usable_segs_in_sec(sbi, segno);
487 
488 	spin_lock(&free_i->segmap_lock);
489 	if (test_and_clear_bit(segno, free_i->free_segmap)) {
490 		free_i->free_segments++;
491 
492 		if (!inmem && IS_CURSEC(sbi, secno))
493 			goto skip_free;
494 		next = find_next_bit(free_i->free_segmap,
495 				start_segno + sbi->segs_per_sec, start_segno);
496 		if (next >= start_segno + usable_segs) {
497 			if (test_and_clear_bit(secno, free_i->free_secmap))
498 				free_i->free_sections++;
499 		}
500 	}
501 skip_free:
502 	spin_unlock(&free_i->segmap_lock);
503 }
504 
__set_test_and_inuse(struct f2fs_sb_info * sbi,unsigned int segno)505 static inline void __set_test_and_inuse(struct f2fs_sb_info *sbi,
506 		unsigned int segno)
507 {
508 	struct free_segmap_info *free_i = FREE_I(sbi);
509 	unsigned int secno = GET_SEC_FROM_SEG(sbi, segno);
510 
511 	spin_lock(&free_i->segmap_lock);
512 	if (!test_and_set_bit(segno, free_i->free_segmap)) {
513 		free_i->free_segments--;
514 		if (!test_and_set_bit(secno, free_i->free_secmap))
515 			free_i->free_sections--;
516 	}
517 	spin_unlock(&free_i->segmap_lock);
518 }
519 
get_sit_bitmap(struct f2fs_sb_info * sbi,void * dst_addr)520 static inline void get_sit_bitmap(struct f2fs_sb_info *sbi,
521 		void *dst_addr)
522 {
523 	struct sit_info *sit_i = SIT_I(sbi);
524 
525 #ifdef CONFIG_F2FS_CHECK_FS
526 	if (memcmp(sit_i->sit_bitmap, sit_i->sit_bitmap_mir,
527 						sit_i->bitmap_size))
528 		f2fs_bug_on(sbi, 1);
529 #endif
530 	memcpy(dst_addr, sit_i->sit_bitmap, sit_i->bitmap_size);
531 }
532 
written_block_count(struct f2fs_sb_info * sbi)533 static inline block_t written_block_count(struct f2fs_sb_info *sbi)
534 {
535 	return SIT_I(sbi)->written_valid_blocks;
536 }
537 
free_segments(struct f2fs_sb_info * sbi)538 static inline unsigned int free_segments(struct f2fs_sb_info *sbi)
539 {
540 	return FREE_I(sbi)->free_segments;
541 }
542 
reserved_segments(struct f2fs_sb_info * sbi)543 static inline unsigned int reserved_segments(struct f2fs_sb_info *sbi)
544 {
545 	return SM_I(sbi)->reserved_segments +
546 			SM_I(sbi)->additional_reserved_segments;
547 }
548 
free_sections(struct f2fs_sb_info * sbi)549 static inline unsigned int free_sections(struct f2fs_sb_info *sbi)
550 {
551 	return FREE_I(sbi)->free_sections;
552 }
553 
prefree_segments(struct f2fs_sb_info * sbi)554 static inline unsigned int prefree_segments(struct f2fs_sb_info *sbi)
555 {
556 	return DIRTY_I(sbi)->nr_dirty[PRE];
557 }
558 
dirty_segments(struct f2fs_sb_info * sbi)559 static inline unsigned int dirty_segments(struct f2fs_sb_info *sbi)
560 {
561 	return DIRTY_I(sbi)->nr_dirty[DIRTY_HOT_DATA] +
562 		DIRTY_I(sbi)->nr_dirty[DIRTY_WARM_DATA] +
563 		DIRTY_I(sbi)->nr_dirty[DIRTY_COLD_DATA] +
564 		DIRTY_I(sbi)->nr_dirty[DIRTY_HOT_NODE] +
565 		DIRTY_I(sbi)->nr_dirty[DIRTY_WARM_NODE] +
566 		DIRTY_I(sbi)->nr_dirty[DIRTY_COLD_NODE];
567 }
568 
overprovision_segments(struct f2fs_sb_info * sbi)569 static inline int overprovision_segments(struct f2fs_sb_info *sbi)
570 {
571 	return SM_I(sbi)->ovp_segments;
572 }
573 
reserved_sections(struct f2fs_sb_info * sbi)574 static inline int reserved_sections(struct f2fs_sb_info *sbi)
575 {
576 	return GET_SEC_FROM_SEG(sbi, reserved_segments(sbi));
577 }
578 
has_curseg_enough_space(struct f2fs_sb_info * sbi,unsigned int node_blocks,unsigned int dent_blocks)579 static inline bool has_curseg_enough_space(struct f2fs_sb_info *sbi,
580 			unsigned int node_blocks, unsigned int dent_blocks)
581 {
582 
583 	unsigned int segno, left_blocks;
584 	int i;
585 
586 	/* check current node segment */
587 	for (i = CURSEG_HOT_NODE; i <= CURSEG_COLD_NODE; i++) {
588 		segno = CURSEG_I(sbi, i)->segno;
589 		left_blocks = f2fs_usable_blks_in_seg(sbi, segno) -
590 				get_seg_entry(sbi, segno)->ckpt_valid_blocks;
591 
592 		if (node_blocks > left_blocks)
593 			return false;
594 	}
595 
596 	/* check current data segment */
597 	segno = CURSEG_I(sbi, CURSEG_HOT_DATA)->segno;
598 	left_blocks = f2fs_usable_blks_in_seg(sbi, segno) -
599 			get_seg_entry(sbi, segno)->ckpt_valid_blocks;
600 	if (dent_blocks > left_blocks)
601 		return false;
602 	return true;
603 }
604 
has_not_enough_free_secs(struct f2fs_sb_info * sbi,int freed,int needed)605 static inline bool has_not_enough_free_secs(struct f2fs_sb_info *sbi,
606 					int freed, int needed)
607 {
608 	unsigned int total_node_blocks = get_pages(sbi, F2FS_DIRTY_NODES) +
609 					get_pages(sbi, F2FS_DIRTY_DENTS) +
610 					get_pages(sbi, F2FS_DIRTY_IMETA);
611 	unsigned int total_dent_blocks = get_pages(sbi, F2FS_DIRTY_DENTS);
612 	unsigned int node_secs = total_node_blocks / BLKS_PER_SEC(sbi);
613 	unsigned int dent_secs = total_dent_blocks / BLKS_PER_SEC(sbi);
614 	unsigned int node_blocks = total_node_blocks % BLKS_PER_SEC(sbi);
615 	unsigned int dent_blocks = total_dent_blocks % BLKS_PER_SEC(sbi);
616 	unsigned int free, need_lower, need_upper;
617 
618 	if (unlikely(is_sbi_flag_set(sbi, SBI_POR_DOING)))
619 		return false;
620 
621 	free = free_sections(sbi) + freed;
622 	need_lower = node_secs + dent_secs + reserved_sections(sbi) + needed;
623 	need_upper = need_lower + (node_blocks ? 1 : 0) + (dent_blocks ? 1 : 0);
624 
625 	if (free > need_upper)
626 		return false;
627 	else if (free <= need_lower)
628 		return true;
629 	return !has_curseg_enough_space(sbi, node_blocks, dent_blocks);
630 }
631 
f2fs_is_checkpoint_ready(struct f2fs_sb_info * sbi)632 static inline bool f2fs_is_checkpoint_ready(struct f2fs_sb_info *sbi)
633 {
634 	if (likely(!is_sbi_flag_set(sbi, SBI_CP_DISABLED)))
635 		return true;
636 	if (likely(!has_not_enough_free_secs(sbi, 0, 0)))
637 		return true;
638 	return false;
639 }
640 
excess_prefree_segs(struct f2fs_sb_info * sbi)641 static inline bool excess_prefree_segs(struct f2fs_sb_info *sbi)
642 {
643 	return prefree_segments(sbi) > SM_I(sbi)->rec_prefree_segments;
644 }
645 
utilization(struct f2fs_sb_info * sbi)646 static inline int utilization(struct f2fs_sb_info *sbi)
647 {
648 	return div_u64((u64)valid_user_blocks(sbi) * 100,
649 					sbi->user_block_count);
650 }
651 
652 /*
653  * Sometimes f2fs may be better to drop out-of-place update policy.
654  * And, users can control the policy through sysfs entries.
655  * There are five policies with triggering conditions as follows.
656  * F2FS_IPU_FORCE - all the time,
657  * F2FS_IPU_SSR - if SSR mode is activated,
658  * F2FS_IPU_UTIL - if FS utilization is over threashold,
659  * F2FS_IPU_SSR_UTIL - if SSR mode is activated and FS utilization is over
660  *                     threashold,
661  * F2FS_IPU_FSYNC - activated in fsync path only for high performance flash
662  *                     storages. IPU will be triggered only if the # of dirty
663  *                     pages over min_fsync_blocks. (=default option)
664  * F2FS_IPU_ASYNC - do IPU given by asynchronous write requests.
665  * F2FS_IPU_NOCACHE - disable IPU bio cache.
666  * F2FS_IPU_HONOR_OPU_WRITE - use OPU write prior to IPU write if inode has
667  *                            FI_OPU_WRITE flag.
668  * F2FS_IPU_DISABLE - disable IPU. (=default option in LFS mode)
669  */
670 #define DEF_MIN_IPU_UTIL	70
671 #define DEF_MIN_FSYNC_BLOCKS	8
672 #define DEF_MIN_HOT_BLOCKS	16
673 
674 #define SMALL_VOLUME_SEGMENTS	(16 * 512)	/* 16GB */
675 
676 enum {
677 	F2FS_IPU_FORCE,
678 	F2FS_IPU_SSR,
679 	F2FS_IPU_UTIL,
680 	F2FS_IPU_SSR_UTIL,
681 	F2FS_IPU_FSYNC,
682 	F2FS_IPU_ASYNC,
683 	F2FS_IPU_NOCACHE,
684 	F2FS_IPU_HONOR_OPU_WRITE,
685 };
686 
curseg_segno(struct f2fs_sb_info * sbi,int type)687 static inline unsigned int curseg_segno(struct f2fs_sb_info *sbi,
688 		int type)
689 {
690 	struct curseg_info *curseg = CURSEG_I(sbi, type);
691 	return curseg->segno;
692 }
693 
curseg_alloc_type(struct f2fs_sb_info * sbi,int type)694 static inline unsigned char curseg_alloc_type(struct f2fs_sb_info *sbi,
695 		int type)
696 {
697 	struct curseg_info *curseg = CURSEG_I(sbi, type);
698 	return curseg->alloc_type;
699 }
700 
curseg_blkoff(struct f2fs_sb_info * sbi,int type)701 static inline unsigned short curseg_blkoff(struct f2fs_sb_info *sbi, int type)
702 {
703 	struct curseg_info *curseg = CURSEG_I(sbi, type);
704 	return curseg->next_blkoff;
705 }
706 
check_seg_range(struct f2fs_sb_info * sbi,unsigned int segno)707 static inline void check_seg_range(struct f2fs_sb_info *sbi, unsigned int segno)
708 {
709 	f2fs_bug_on(sbi, segno > TOTAL_SEGS(sbi) - 1);
710 }
711 
verify_fio_blkaddr(struct f2fs_io_info * fio)712 static inline void verify_fio_blkaddr(struct f2fs_io_info *fio)
713 {
714 	struct f2fs_sb_info *sbi = fio->sbi;
715 
716 	if (__is_valid_data_blkaddr(fio->old_blkaddr))
717 		verify_blkaddr(sbi, fio->old_blkaddr, __is_meta_io(fio) ?
718 					META_GENERIC : DATA_GENERIC);
719 	verify_blkaddr(sbi, fio->new_blkaddr, __is_meta_io(fio) ?
720 					META_GENERIC : DATA_GENERIC_ENHANCE);
721 }
722 
723 /*
724  * Summary block is always treated as an invalid block
725  */
check_block_count(struct f2fs_sb_info * sbi,int segno,struct f2fs_sit_entry * raw_sit)726 static inline int check_block_count(struct f2fs_sb_info *sbi,
727 		int segno, struct f2fs_sit_entry *raw_sit)
728 {
729 	bool is_valid  = test_bit_le(0, raw_sit->valid_map) ? true : false;
730 	int valid_blocks = 0;
731 	int cur_pos = 0, next_pos;
732 	unsigned int usable_blks_per_seg = f2fs_usable_blks_in_seg(sbi, segno);
733 
734 	/* check bitmap with valid block count */
735 	do {
736 		if (is_valid) {
737 			next_pos = find_next_zero_bit_le(&raw_sit->valid_map,
738 					usable_blks_per_seg,
739 					cur_pos);
740 			valid_blocks += next_pos - cur_pos;
741 		} else
742 			next_pos = find_next_bit_le(&raw_sit->valid_map,
743 					usable_blks_per_seg,
744 					cur_pos);
745 		cur_pos = next_pos;
746 		is_valid = !is_valid;
747 	} while (cur_pos < usable_blks_per_seg);
748 
749 	if (unlikely(GET_SIT_VBLOCKS(raw_sit) != valid_blocks)) {
750 		f2fs_err(sbi, "Mismatch valid blocks %d vs. %d",
751 			 GET_SIT_VBLOCKS(raw_sit), valid_blocks);
752 		set_sbi_flag(sbi, SBI_NEED_FSCK);
753 		return -EFSCORRUPTED;
754 	}
755 
756 	if (usable_blks_per_seg < sbi->blocks_per_seg)
757 		f2fs_bug_on(sbi, find_next_bit_le(&raw_sit->valid_map,
758 				sbi->blocks_per_seg,
759 				usable_blks_per_seg) != sbi->blocks_per_seg);
760 
761 	/* check segment usage, and check boundary of a given segment number */
762 	if (unlikely(GET_SIT_VBLOCKS(raw_sit) > usable_blks_per_seg
763 					|| segno > TOTAL_SEGS(sbi) - 1)) {
764 		f2fs_err(sbi, "Wrong valid blocks %d or segno %u",
765 			 GET_SIT_VBLOCKS(raw_sit), segno);
766 		set_sbi_flag(sbi, SBI_NEED_FSCK);
767 		return -EFSCORRUPTED;
768 	}
769 	return 0;
770 }
771 
current_sit_addr(struct f2fs_sb_info * sbi,unsigned int start)772 static inline pgoff_t current_sit_addr(struct f2fs_sb_info *sbi,
773 						unsigned int start)
774 {
775 	struct sit_info *sit_i = SIT_I(sbi);
776 	unsigned int offset = SIT_BLOCK_OFFSET(start);
777 	block_t blk_addr = sit_i->sit_base_addr + offset;
778 
779 	check_seg_range(sbi, start);
780 
781 #ifdef CONFIG_F2FS_CHECK_FS
782 	if (f2fs_test_bit(offset, sit_i->sit_bitmap) !=
783 			f2fs_test_bit(offset, sit_i->sit_bitmap_mir))
784 		f2fs_bug_on(sbi, 1);
785 #endif
786 
787 	/* calculate sit block address */
788 	if (f2fs_test_bit(offset, sit_i->sit_bitmap))
789 		blk_addr += sit_i->sit_blocks;
790 
791 	return blk_addr;
792 }
793 
next_sit_addr(struct f2fs_sb_info * sbi,pgoff_t block_addr)794 static inline pgoff_t next_sit_addr(struct f2fs_sb_info *sbi,
795 						pgoff_t block_addr)
796 {
797 	struct sit_info *sit_i = SIT_I(sbi);
798 	block_addr -= sit_i->sit_base_addr;
799 	if (block_addr < sit_i->sit_blocks)
800 		block_addr += sit_i->sit_blocks;
801 	else
802 		block_addr -= sit_i->sit_blocks;
803 
804 	return block_addr + sit_i->sit_base_addr;
805 }
806 
set_to_next_sit(struct sit_info * sit_i,unsigned int start)807 static inline void set_to_next_sit(struct sit_info *sit_i, unsigned int start)
808 {
809 	unsigned int block_off = SIT_BLOCK_OFFSET(start);
810 
811 	f2fs_change_bit(block_off, sit_i->sit_bitmap);
812 #ifdef CONFIG_F2FS_CHECK_FS
813 	f2fs_change_bit(block_off, sit_i->sit_bitmap_mir);
814 #endif
815 }
816 
get_mtime(struct f2fs_sb_info * sbi,bool base_time)817 static inline unsigned long long get_mtime(struct f2fs_sb_info *sbi,
818 						bool base_time)
819 {
820 	struct sit_info *sit_i = SIT_I(sbi);
821 	time64_t diff, now = ktime_get_boottime_seconds();
822 
823 	if (now >= sit_i->mounted_time)
824 		return sit_i->elapsed_time + now - sit_i->mounted_time;
825 
826 	/* system time is set to the past */
827 	if (!base_time) {
828 		diff = sit_i->mounted_time - now;
829 		if (sit_i->elapsed_time >= diff)
830 			return sit_i->elapsed_time - diff;
831 		return 0;
832 	}
833 	return sit_i->elapsed_time;
834 }
835 
set_summary(struct f2fs_summary * sum,nid_t nid,unsigned int ofs_in_node,unsigned char version)836 static inline void set_summary(struct f2fs_summary *sum, nid_t nid,
837 			unsigned int ofs_in_node, unsigned char version)
838 {
839 	sum->nid = cpu_to_le32(nid);
840 	sum->ofs_in_node = cpu_to_le16(ofs_in_node);
841 	sum->version = version;
842 }
843 
start_sum_block(struct f2fs_sb_info * sbi)844 static inline block_t start_sum_block(struct f2fs_sb_info *sbi)
845 {
846 	return __start_cp_addr(sbi) +
847 		le32_to_cpu(F2FS_CKPT(sbi)->cp_pack_start_sum);
848 }
849 
sum_blk_addr(struct f2fs_sb_info * sbi,int base,int type)850 static inline block_t sum_blk_addr(struct f2fs_sb_info *sbi, int base, int type)
851 {
852 	return __start_cp_addr(sbi) +
853 		le32_to_cpu(F2FS_CKPT(sbi)->cp_pack_total_block_count)
854 				- (base + 1) + type;
855 }
856 
sec_usage_check(struct f2fs_sb_info * sbi,unsigned int secno)857 static inline bool sec_usage_check(struct f2fs_sb_info *sbi, unsigned int secno)
858 {
859 	if (IS_CURSEC(sbi, secno) || (sbi->cur_victim_sec == secno))
860 		return true;
861 	return false;
862 }
863 
864 /*
865  * It is very important to gather dirty pages and write at once, so that we can
866  * submit a big bio without interfering other data writes.
867  * By default, 512 pages for directory data,
868  * 512 pages (2MB) * 8 for nodes, and
869  * 256 pages * 8 for meta are set.
870  */
nr_pages_to_skip(struct f2fs_sb_info * sbi,int type)871 static inline int nr_pages_to_skip(struct f2fs_sb_info *sbi, int type)
872 {
873 	if (sbi->sb->s_bdi->wb.dirty_exceeded)
874 		return 0;
875 
876 	if (type == DATA)
877 		return sbi->blocks_per_seg;
878 	else if (type == NODE)
879 		return 8 * sbi->blocks_per_seg;
880 	else if (type == META)
881 		return 8 * BIO_MAX_VECS;
882 	else
883 		return 0;
884 }
885 
886 /*
887  * When writing pages, it'd better align nr_to_write for segment size.
888  */
nr_pages_to_write(struct f2fs_sb_info * sbi,int type,struct writeback_control * wbc)889 static inline long nr_pages_to_write(struct f2fs_sb_info *sbi, int type,
890 					struct writeback_control *wbc)
891 {
892 	long nr_to_write, desired;
893 
894 	if (wbc->sync_mode != WB_SYNC_NONE)
895 		return 0;
896 
897 	nr_to_write = wbc->nr_to_write;
898 	desired = BIO_MAX_VECS;
899 	if (type == NODE)
900 		desired <<= 1;
901 
902 	wbc->nr_to_write = desired;
903 	return desired - nr_to_write;
904 }
905 
wake_up_discard_thread(struct f2fs_sb_info * sbi,bool force)906 static inline void wake_up_discard_thread(struct f2fs_sb_info *sbi, bool force)
907 {
908 	struct discard_cmd_control *dcc = SM_I(sbi)->dcc_info;
909 	bool wakeup = false;
910 	int i;
911 
912 	if (force)
913 		goto wake_up;
914 
915 	mutex_lock(&dcc->cmd_lock);
916 	for (i = MAX_PLIST_NUM - 1; i >= 0; i--) {
917 		if (i + 1 < dcc->discard_granularity)
918 			break;
919 		if (!list_empty(&dcc->pend_list[i])) {
920 			wakeup = true;
921 			break;
922 		}
923 	}
924 	mutex_unlock(&dcc->cmd_lock);
925 	if (!wakeup || !is_idle(sbi, DISCARD_TIME))
926 		return;
927 wake_up:
928 	dcc->discard_wake = 1;
929 	wake_up_interruptible_all(&dcc->discard_wait_queue);
930 }
931