Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0
2 : : /*
3 : : * fs/f2fs/gc.c
4 : : *
5 : : * Copyright (c) 2012 Samsung Electronics Co., Ltd.
6 : : * http://www.samsung.com/
7 : : */
8 : : #include <linux/fs.h>
9 : : #include <linux/module.h>
10 : : #include <linux/backing-dev.h>
11 : : #include <linux/init.h>
12 : : #include <linux/f2fs_fs.h>
13 : : #include <linux/kthread.h>
14 : : #include <linux/delay.h>
15 : : #include <linux/freezer.h>
16 : :
17 : : #include "f2fs.h"
18 : : #include "node.h"
19 : : #include "segment.h"
20 : : #include "gc.h"
21 : : #include <trace/events/f2fs.h>
22 : :
23 : 0 : static int gc_thread_func(void *data)
24 : : {
25 : : struct f2fs_sb_info *sbi = data;
26 : 0 : struct f2fs_gc_kthread *gc_th = sbi->gc_thread;
27 : 0 : wait_queue_head_t *wq = &sbi->gc_thread->gc_wait_queue_head;
28 : : unsigned int wait_ms;
29 : :
30 : 0 : wait_ms = gc_th->min_sleep_time;
31 : :
32 : 0 : set_freezable();
33 : : do {
34 : 0 : wait_event_interruptible_timeout(*wq,
35 : : kthread_should_stop() || freezing(current) ||
36 : : gc_th->gc_wake,
37 : : msecs_to_jiffies(wait_ms));
38 : :
39 : : /* give it a try one time */
40 : 0 : if (gc_th->gc_wake)
41 : 0 : gc_th->gc_wake = 0;
42 : :
43 : 0 : if (try_to_freeze()) {
44 : 0 : stat_other_skip_bggc_count(sbi);
45 : 0 : continue;
46 : : }
47 : 0 : if (kthread_should_stop())
48 : : break;
49 : :
50 : 0 : if (sbi->sb->s_writers.frozen >= SB_FREEZE_WRITE) {
51 : : increase_sleep_time(gc_th, &wait_ms);
52 : 0 : stat_other_skip_bggc_count(sbi);
53 : 0 : continue;
54 : : }
55 : :
56 : : if (time_to_inject(sbi, FAULT_CHECKPOINT)) {
57 : : f2fs_show_injection_info(FAULT_CHECKPOINT);
58 : : f2fs_stop_checkpoint(sbi, false);
59 : : }
60 : :
61 : 0 : if (!sb_start_write_trylock(sbi->sb)) {
62 : 0 : stat_other_skip_bggc_count(sbi);
63 : 0 : continue;
64 : : }
65 : :
66 : : /*
67 : : * [GC triggering condition]
68 : : * 0. GC is not conducted currently.
69 : : * 1. There are enough dirty segments.
70 : : * 2. IO subsystem is idle by checking the # of writeback pages.
71 : : * 3. IO subsystem is idle by checking the # of requests in
72 : : * bdev's request list.
73 : : *
74 : : * Note) We have to avoid triggering GCs frequently.
75 : : * Because it is possible that some segments can be
76 : : * invalidated soon after by user update or deletion.
77 : : * So, I'd like to wait some time to collect dirty segments.
78 : : */
79 : 0 : if (sbi->gc_mode == GC_URGENT) {
80 : 0 : wait_ms = gc_th->urgent_sleep_time;
81 : 0 : mutex_lock(&sbi->gc_mutex);
82 : 0 : goto do_gc;
83 : : }
84 : :
85 : 0 : if (!mutex_trylock(&sbi->gc_mutex)) {
86 : 0 : stat_other_skip_bggc_count(sbi);
87 : 0 : goto next;
88 : : }
89 : :
90 : 0 : if (!is_idle(sbi, GC_TIME)) {
91 : : increase_sleep_time(gc_th, &wait_ms);
92 : 0 : mutex_unlock(&sbi->gc_mutex);
93 : 0 : stat_io_skip_bggc_count(sbi);
94 : 0 : goto next;
95 : : }
96 : :
97 : 0 : if (has_enough_invalid_blocks(sbi))
98 : : decrease_sleep_time(gc_th, &wait_ms);
99 : : else
100 : : increase_sleep_time(gc_th, &wait_ms);
101 : : do_gc:
102 : 0 : stat_inc_bggc_count(sbi);
103 : :
104 : : /* if return value is not zero, no victim was selected */
105 : 0 : if (f2fs_gc(sbi, test_opt(sbi, FORCE_FG_GC), true, NULL_SEGNO))
106 : 0 : wait_ms = gc_th->no_gc_sleep_time;
107 : :
108 : 0 : trace_f2fs_background_gc(sbi->sb, wait_ms,
109 : : prefree_segments(sbi), free_segments(sbi));
110 : :
111 : : /* balancing f2fs's metadata periodically */
112 : 0 : f2fs_balance_fs_bg(sbi);
113 : : next:
114 : 0 : sb_end_write(sbi->sb);
115 : :
116 : 0 : } while (!kthread_should_stop());
117 : 0 : return 0;
118 : : }
119 : :
120 : 0 : int f2fs_start_gc_thread(struct f2fs_sb_info *sbi)
121 : : {
122 : : struct f2fs_gc_kthread *gc_th;
123 : 0 : dev_t dev = sbi->sb->s_bdev->bd_dev;
124 : : int err = 0;
125 : :
126 : 0 : gc_th = f2fs_kmalloc(sbi, sizeof(struct f2fs_gc_kthread), GFP_KERNEL);
127 : 0 : if (!gc_th) {
128 : : err = -ENOMEM;
129 : : goto out;
130 : : }
131 : :
132 : 0 : gc_th->urgent_sleep_time = DEF_GC_THREAD_URGENT_SLEEP_TIME;
133 : 0 : gc_th->min_sleep_time = DEF_GC_THREAD_MIN_SLEEP_TIME;
134 : 0 : gc_th->max_sleep_time = DEF_GC_THREAD_MAX_SLEEP_TIME;
135 : 0 : gc_th->no_gc_sleep_time = DEF_GC_THREAD_NOGC_SLEEP_TIME;
136 : :
137 : 0 : gc_th->gc_wake= 0;
138 : :
139 : 0 : sbi->gc_thread = gc_th;
140 : 0 : init_waitqueue_head(&sbi->gc_thread->gc_wait_queue_head);
141 : 0 : sbi->gc_thread->f2fs_gc_task = kthread_run(gc_thread_func, sbi,
142 : : "f2fs_gc-%u:%u", MAJOR(dev), MINOR(dev));
143 : 0 : if (IS_ERR(gc_th->f2fs_gc_task)) {
144 : : err = PTR_ERR(gc_th->f2fs_gc_task);
145 : 0 : kvfree(gc_th);
146 : 0 : sbi->gc_thread = NULL;
147 : : }
148 : : out:
149 : 0 : return err;
150 : : }
151 : :
152 : 0 : void f2fs_stop_gc_thread(struct f2fs_sb_info *sbi)
153 : : {
154 : 0 : struct f2fs_gc_kthread *gc_th = sbi->gc_thread;
155 : 0 : if (!gc_th)
156 : 0 : return;
157 : 0 : kthread_stop(gc_th->f2fs_gc_task);
158 : 0 : kvfree(gc_th);
159 : 0 : sbi->gc_thread = NULL;
160 : : }
161 : :
162 : : static int select_gc_type(struct f2fs_sb_info *sbi, int gc_type)
163 : : {
164 : 0 : int gc_mode = (gc_type == BG_GC) ? GC_CB : GC_GREEDY;
165 : :
166 : 0 : switch (sbi->gc_mode) {
167 : : case GC_IDLE_CB:
168 : : gc_mode = GC_CB;
169 : : break;
170 : : case GC_IDLE_GREEDY:
171 : : case GC_URGENT:
172 : : gc_mode = GC_GREEDY;
173 : : break;
174 : : }
175 : : return gc_mode;
176 : : }
177 : :
178 : 0 : static void select_policy(struct f2fs_sb_info *sbi, int gc_type,
179 : : int type, struct victim_sel_policy *p)
180 : : {
181 : : struct dirty_seglist_info *dirty_i = DIRTY_I(sbi);
182 : :
183 : 0 : if (p->alloc_mode == SSR) {
184 : 0 : p->gc_mode = GC_GREEDY;
185 : 0 : p->dirty_segmap = dirty_i->dirty_segmap[type];
186 : 0 : p->max_search = dirty_i->nr_dirty[type];
187 : 0 : p->ofs_unit = 1;
188 : : } else {
189 : 0 : p->gc_mode = select_gc_type(sbi, gc_type);
190 : 0 : p->dirty_segmap = dirty_i->dirty_segmap[DIRTY];
191 : 0 : p->max_search = dirty_i->nr_dirty[DIRTY];
192 : 0 : p->ofs_unit = sbi->segs_per_sec;
193 : : }
194 : :
195 : : /* we need to check every dirty segments in the FG_GC case */
196 : 0 : if (gc_type != FG_GC &&
197 : 0 : (sbi->gc_mode != GC_URGENT) &&
198 : 0 : p->max_search > sbi->max_victim_search)
199 : 0 : p->max_search = sbi->max_victim_search;
200 : :
201 : : /* let's select beginning hot/small space first in no_heap mode*/
202 : 0 : if (test_opt(sbi, NOHEAP) &&
203 : 0 : (type == CURSEG_HOT_DATA || IS_NODESEG(type)))
204 : 0 : p->offset = 0;
205 : : else
206 : 0 : p->offset = SIT_I(sbi)->last_victim[p->gc_mode];
207 : 0 : }
208 : :
209 : : static unsigned int get_max_cost(struct f2fs_sb_info *sbi,
210 : : struct victim_sel_policy *p)
211 : : {
212 : : /* SSR allocates in a segment unit */
213 : 0 : if (p->alloc_mode == SSR)
214 : 0 : return sbi->blocks_per_seg;
215 : 0 : if (p->gc_mode == GC_GREEDY)
216 : 0 : return 2 * sbi->blocks_per_seg * p->ofs_unit;
217 : 0 : else if (p->gc_mode == GC_CB)
218 : : return UINT_MAX;
219 : : else /* No other gc_mode */
220 : : return 0;
221 : : }
222 : :
223 : 0 : static unsigned int check_bg_victims(struct f2fs_sb_info *sbi)
224 : : {
225 : : struct dirty_seglist_info *dirty_i = DIRTY_I(sbi);
226 : : unsigned int secno;
227 : :
228 : : /*
229 : : * If the gc_type is FG_GC, we can select victim segments
230 : : * selected by background GC before.
231 : : * Those segments guarantee they have small valid blocks.
232 : : */
233 : 0 : for_each_set_bit(secno, dirty_i->victim_secmap, MAIN_SECS(sbi)) {
234 : 0 : if (sec_usage_check(sbi, secno))
235 : 0 : continue;
236 : 0 : clear_bit(secno, dirty_i->victim_secmap);
237 : 0 : return GET_SEG_FROM_SEC(sbi, secno);
238 : : }
239 : : return NULL_SEGNO;
240 : : }
241 : :
242 : 0 : static unsigned int get_cb_cost(struct f2fs_sb_info *sbi, unsigned int segno)
243 : : {
244 : : struct sit_info *sit_i = SIT_I(sbi);
245 : 0 : unsigned int secno = GET_SEC_FROM_SEG(sbi, segno);
246 : 0 : unsigned int start = GET_SEG_FROM_SEC(sbi, secno);
247 : : unsigned long long mtime = 0;
248 : : unsigned int vblocks;
249 : : unsigned char age = 0;
250 : : unsigned char u;
251 : : unsigned int i;
252 : :
253 : 0 : for (i = 0; i < sbi->segs_per_sec; i++)
254 : 0 : mtime += get_seg_entry(sbi, start + i)->mtime;
255 : 0 : vblocks = get_valid_blocks(sbi, segno, true);
256 : :
257 : : mtime = div_u64(mtime, sbi->segs_per_sec);
258 : 0 : vblocks = div_u64(vblocks, sbi->segs_per_sec);
259 : :
260 : 0 : u = (vblocks * 100) >> sbi->log_blocks_per_seg;
261 : :
262 : : /* Handle if the system time has changed by the user */
263 : 0 : if (mtime < sit_i->min_mtime)
264 : 0 : sit_i->min_mtime = mtime;
265 : 0 : if (mtime > sit_i->max_mtime)
266 : 0 : sit_i->max_mtime = mtime;
267 : 0 : if (sit_i->max_mtime != sit_i->min_mtime)
268 : 0 : age = 100 - div64_u64(100 * (mtime - sit_i->min_mtime),
269 : : sit_i->max_mtime - sit_i->min_mtime);
270 : :
271 : 0 : return UINT_MAX - ((100 * (100 - u) * age) / (100 + u));
272 : : }
273 : :
274 : 0 : static inline unsigned int get_gc_cost(struct f2fs_sb_info *sbi,
275 : : unsigned int segno, struct victim_sel_policy *p)
276 : : {
277 : 0 : if (p->alloc_mode == SSR)
278 : 0 : return get_seg_entry(sbi, segno)->ckpt_valid_blocks;
279 : :
280 : : /* alloc_mode == LFS */
281 : 0 : if (p->gc_mode == GC_GREEDY)
282 : 0 : return get_valid_blocks(sbi, segno, true);
283 : : else
284 : 0 : return get_cb_cost(sbi, segno);
285 : : }
286 : :
287 : : static unsigned int count_bits(const unsigned long *addr,
288 : : unsigned int offset, unsigned int len)
289 : : {
290 : 0 : unsigned int end = offset + len, sum = 0;
291 : :
292 : 0 : while (offset < end) {
293 : 0 : if (test_bit(offset++, addr))
294 : 0 : ++sum;
295 : : }
296 : 0 : return sum;
297 : : }
298 : :
299 : : /*
300 : : * This function is called from two paths.
301 : : * One is garbage collection and the other is SSR segment selection.
302 : : * When it is called during GC, it just gets a victim segment
303 : : * and it does not remove it from dirty seglist.
304 : : * When it is called from SSR segment selection, it finds a segment
305 : : * which has minimum valid blocks and removes it from dirty seglist.
306 : : */
307 : 0 : static int get_victim_by_default(struct f2fs_sb_info *sbi,
308 : : unsigned int *result, int gc_type, int type, char alloc_mode)
309 : : {
310 : : struct dirty_seglist_info *dirty_i = DIRTY_I(sbi);
311 : : struct sit_info *sm = SIT_I(sbi);
312 : : struct victim_sel_policy p;
313 : : unsigned int secno, last_victim;
314 : : unsigned int last_segment;
315 : : unsigned int nsearched = 0;
316 : :
317 : 0 : mutex_lock(&dirty_i->seglist_lock);
318 : 0 : last_segment = MAIN_SECS(sbi) * sbi->segs_per_sec;
319 : :
320 : 0 : p.alloc_mode = alloc_mode;
321 : 0 : select_policy(sbi, gc_type, type, &p);
322 : :
323 : 0 : p.min_segno = NULL_SEGNO;
324 : 0 : p.min_cost = get_max_cost(sbi, &p);
325 : :
326 : 0 : if (*result != NULL_SEGNO) {
327 : 0 : if (get_valid_blocks(sbi, *result, false) &&
328 : 0 : !sec_usage_check(sbi, GET_SEC_FROM_SEG(sbi, *result)))
329 : 0 : p.min_segno = *result;
330 : : goto out;
331 : : }
332 : :
333 : 0 : if (p.max_search == 0)
334 : : goto out;
335 : :
336 : 0 : if (__is_large_section(sbi) && p.alloc_mode == LFS) {
337 : 0 : if (sbi->next_victim_seg[BG_GC] != NULL_SEGNO) {
338 : 0 : p.min_segno = sbi->next_victim_seg[BG_GC];
339 : 0 : *result = p.min_segno;
340 : 0 : sbi->next_victim_seg[BG_GC] = NULL_SEGNO;
341 : 0 : goto got_result;
342 : : }
343 : 0 : if (gc_type == FG_GC &&
344 : 0 : sbi->next_victim_seg[FG_GC] != NULL_SEGNO) {
345 : 0 : p.min_segno = sbi->next_victim_seg[FG_GC];
346 : 0 : *result = p.min_segno;
347 : 0 : sbi->next_victim_seg[FG_GC] = NULL_SEGNO;
348 : 0 : goto got_result;
349 : : }
350 : : }
351 : :
352 : 0 : last_victim = sm->last_victim[p.gc_mode];
353 : 0 : if (p.alloc_mode == LFS && gc_type == FG_GC) {
354 : 0 : p.min_segno = check_bg_victims(sbi);
355 : 0 : if (p.min_segno != NULL_SEGNO)
356 : : goto got_it;
357 : : }
358 : :
359 : : while (1) {
360 : : unsigned long cost;
361 : : unsigned int segno;
362 : :
363 : 0 : segno = find_next_bit(p.dirty_segmap, last_segment, p.offset);
364 : 0 : if (segno >= last_segment) {
365 : 0 : if (sm->last_victim[p.gc_mode]) {
366 : : last_segment =
367 : : sm->last_victim[p.gc_mode];
368 : 0 : sm->last_victim[p.gc_mode] = 0;
369 : 0 : p.offset = 0;
370 : 0 : continue;
371 : : }
372 : : break;
373 : : }
374 : :
375 : 0 : p.offset = segno + p.ofs_unit;
376 : 0 : if (p.ofs_unit > 1) {
377 : 0 : p.offset -= segno % p.ofs_unit;
378 : 0 : nsearched += count_bits(p.dirty_segmap,
379 : : p.offset - p.ofs_unit,
380 : : p.ofs_unit);
381 : : } else {
382 : 0 : nsearched++;
383 : : }
384 : :
385 : : #ifdef CONFIG_F2FS_CHECK_FS
386 : : /*
387 : : * skip selecting the invalid segno (that is failed due to block
388 : : * validity check failure during GC) to avoid endless GC loop in
389 : : * such cases.
390 : : */
391 : : if (test_bit(segno, sm->invalid_segmap))
392 : : goto next;
393 : : #endif
394 : :
395 : 0 : secno = GET_SEC_FROM_SEG(sbi, segno);
396 : :
397 : 0 : if (sec_usage_check(sbi, secno))
398 : : goto next;
399 : : /* Don't touch checkpointed data */
400 : 0 : if (unlikely(is_sbi_flag_set(sbi, SBI_CP_DISABLED) &&
401 : : get_ckpt_valid_blocks(sbi, segno) &&
402 : : p.alloc_mode != SSR))
403 : : goto next;
404 : 0 : if (gc_type == BG_GC && test_bit(secno, dirty_i->victim_secmap))
405 : : goto next;
406 : :
407 : 0 : cost = get_gc_cost(sbi, segno, &p);
408 : :
409 : 0 : if (p.min_cost > cost) {
410 : 0 : p.min_segno = segno;
411 : 0 : p.min_cost = cost;
412 : : }
413 : : next:
414 : 0 : if (nsearched >= p.max_search) {
415 : 0 : if (!sm->last_victim[p.gc_mode] && segno <= last_victim)
416 : 0 : sm->last_victim[p.gc_mode] = last_victim + 1;
417 : : else
418 : 0 : sm->last_victim[p.gc_mode] = segno + 1;
419 : 0 : sm->last_victim[p.gc_mode] %=
420 : 0 : (MAIN_SECS(sbi) * sbi->segs_per_sec);
421 : 0 : break;
422 : : }
423 : : }
424 : 0 : if (p.min_segno != NULL_SEGNO) {
425 : : got_it:
426 : 0 : *result = (p.min_segno / p.ofs_unit) * p.ofs_unit;
427 : : got_result:
428 : 0 : if (p.alloc_mode == LFS) {
429 : 0 : secno = GET_SEC_FROM_SEG(sbi, p.min_segno);
430 : 0 : if (gc_type == FG_GC)
431 : 0 : sbi->cur_victim_sec = secno;
432 : : else
433 : 0 : set_bit(secno, dirty_i->victim_secmap);
434 : : }
435 : :
436 : : }
437 : : out:
438 : 0 : if (p.min_segno != NULL_SEGNO)
439 : 0 : trace_f2fs_get_victim(sbi->sb, type, gc_type, &p,
440 : : sbi->cur_victim_sec,
441 : : prefree_segments(sbi), free_segments(sbi));
442 : 0 : mutex_unlock(&dirty_i->seglist_lock);
443 : :
444 : 0 : return (p.min_segno == NULL_SEGNO) ? 0 : 1;
445 : : }
446 : :
447 : : static const struct victim_selection default_v_ops = {
448 : : .get_victim = get_victim_by_default,
449 : : };
450 : :
451 : : static struct inode *find_gc_inode(struct gc_inode_list *gc_list, nid_t ino)
452 : : {
453 : : struct inode_entry *ie;
454 : :
455 : 0 : ie = radix_tree_lookup(&gc_list->iroot, ino);
456 : 0 : if (ie)
457 : 0 : return ie->inode;
458 : : return NULL;
459 : : }
460 : :
461 : 0 : static void add_gc_inode(struct gc_inode_list *gc_list, struct inode *inode)
462 : : {
463 : : struct inode_entry *new_ie;
464 : :
465 : 0 : if (inode == find_gc_inode(gc_list, inode->i_ino)) {
466 : 0 : iput(inode);
467 : 0 : return;
468 : : }
469 : 0 : new_ie = f2fs_kmem_cache_alloc(f2fs_inode_entry_slab, GFP_NOFS);
470 : 0 : new_ie->inode = inode;
471 : :
472 : 0 : f2fs_radix_tree_insert(&gc_list->iroot, inode->i_ino, new_ie);
473 : 0 : list_add_tail(&new_ie->list, &gc_list->ilist);
474 : : }
475 : :
476 : 0 : static void put_gc_inode(struct gc_inode_list *gc_list)
477 : : {
478 : : struct inode_entry *ie, *next_ie;
479 : 0 : list_for_each_entry_safe(ie, next_ie, &gc_list->ilist, list) {
480 : 0 : radix_tree_delete(&gc_list->iroot, ie->inode->i_ino);
481 : 0 : iput(ie->inode);
482 : : list_del(&ie->list);
483 : 0 : kmem_cache_free(f2fs_inode_entry_slab, ie);
484 : : }
485 : 0 : }
486 : :
487 : 0 : static int check_valid_map(struct f2fs_sb_info *sbi,
488 : : unsigned int segno, int offset)
489 : : {
490 : : struct sit_info *sit_i = SIT_I(sbi);
491 : : struct seg_entry *sentry;
492 : : int ret;
493 : :
494 : 0 : down_read(&sit_i->sentry_lock);
495 : : sentry = get_seg_entry(sbi, segno);
496 : 0 : ret = f2fs_test_bit(offset, sentry->cur_valid_map);
497 : 0 : up_read(&sit_i->sentry_lock);
498 : 0 : return ret;
499 : : }
500 : :
501 : : /*
502 : : * This function compares node address got in summary with that in NAT.
503 : : * On validity, copy that node with cold status, otherwise (invalid node)
504 : : * ignore that.
505 : : */
506 : 0 : static int gc_node_segment(struct f2fs_sb_info *sbi,
507 : : struct f2fs_summary *sum, unsigned int segno, int gc_type)
508 : : {
509 : : struct f2fs_summary *entry;
510 : : block_t start_addr;
511 : : int off;
512 : : int phase = 0;
513 : 0 : bool fggc = (gc_type == FG_GC);
514 : : int submitted = 0;
515 : :
516 : 0 : start_addr = START_BLOCK(sbi, segno);
517 : :
518 : : next_step:
519 : : entry = sum;
520 : :
521 : 0 : if (fggc && phase == 2)
522 : 0 : atomic_inc(&sbi->wb_sync_req[NODE]);
523 : :
524 : 0 : for (off = 0; off < sbi->blocks_per_seg; off++, entry++) {
525 : 0 : nid_t nid = le32_to_cpu(entry->nid);
526 : : struct page *node_page;
527 : : struct node_info ni;
528 : : int err;
529 : :
530 : : /* stop BG_GC if there is not enough free sections. */
531 : 0 : if (gc_type == BG_GC && has_not_enough_free_secs(sbi, 0, 0))
532 : 0 : return submitted;
533 : :
534 : 0 : if (check_valid_map(sbi, segno, off) == 0)
535 : 0 : continue;
536 : :
537 : 0 : if (phase == 0) {
538 : 0 : f2fs_ra_meta_pages(sbi, NAT_BLOCK_OFFSET(nid), 1,
539 : : META_NAT, true);
540 : 0 : continue;
541 : : }
542 : :
543 : 0 : if (phase == 1) {
544 : 0 : f2fs_ra_node_page(sbi, nid);
545 : 0 : continue;
546 : : }
547 : :
548 : : /* phase == 2 */
549 : 0 : node_page = f2fs_get_node_page(sbi, nid);
550 : 0 : if (IS_ERR(node_page))
551 : 0 : continue;
552 : :
553 : : /* block may become invalid during f2fs_get_node_page */
554 : 0 : if (check_valid_map(sbi, segno, off) == 0) {
555 : 0 : f2fs_put_page(node_page, 1);
556 : 0 : continue;
557 : : }
558 : :
559 : 0 : if (f2fs_get_node_info(sbi, nid, &ni)) {
560 : 0 : f2fs_put_page(node_page, 1);
561 : 0 : continue;
562 : : }
563 : :
564 : 0 : if (ni.blk_addr != start_addr + off) {
565 : 0 : f2fs_put_page(node_page, 1);
566 : 0 : continue;
567 : : }
568 : :
569 : 0 : err = f2fs_move_node_page(node_page, gc_type);
570 : 0 : if (!err && gc_type == FG_GC)
571 : 0 : submitted++;
572 : 0 : stat_inc_node_blk_count(sbi, 1, gc_type);
573 : : }
574 : :
575 : 0 : if (++phase < 3)
576 : : goto next_step;
577 : :
578 : 0 : if (fggc)
579 : 0 : atomic_dec(&sbi->wb_sync_req[NODE]);
580 : : return submitted;
581 : : }
582 : :
583 : : /*
584 : : * Calculate start block index indicating the given node offset.
585 : : * Be careful, caller should give this node offset only indicating direct node
586 : : * blocks. If any node offsets, which point the other types of node blocks such
587 : : * as indirect or double indirect node blocks, are given, it must be a caller's
588 : : * bug.
589 : : */
590 : 0 : block_t f2fs_start_bidx_of_node(unsigned int node_ofs, struct inode *inode)
591 : : {
592 : : unsigned int indirect_blks = 2 * NIDS_PER_BLOCK + 4;
593 : : unsigned int bidx;
594 : :
595 : 0 : if (node_ofs == 0)
596 : : return 0;
597 : :
598 : 0 : if (node_ofs <= 2) {
599 : 0 : bidx = node_ofs - 1;
600 : 0 : } else if (node_ofs <= indirect_blks) {
601 : 0 : int dec = (node_ofs - 4) / (NIDS_PER_BLOCK + 1);
602 : 0 : bidx = node_ofs - 2 - dec;
603 : : } else {
604 : 0 : int dec = (node_ofs - indirect_blks - 3) / (NIDS_PER_BLOCK + 1);
605 : 0 : bidx = node_ofs - 5 - dec;
606 : : }
607 : 0 : return bidx * ADDRS_PER_BLOCK(inode) + ADDRS_PER_INODE(inode);
608 : : }
609 : :
610 : 0 : static bool is_alive(struct f2fs_sb_info *sbi, struct f2fs_summary *sum,
611 : : struct node_info *dni, block_t blkaddr, unsigned int *nofs)
612 : : {
613 : : struct page *node_page;
614 : : nid_t nid;
615 : : unsigned int ofs_in_node;
616 : : block_t source_blkaddr;
617 : :
618 : 0 : nid = le32_to_cpu(sum->nid);
619 : 0 : ofs_in_node = le16_to_cpu(sum->ofs_in_node);
620 : :
621 : 0 : node_page = f2fs_get_node_page(sbi, nid);
622 : 0 : if (IS_ERR(node_page))
623 : : return false;
624 : :
625 : 0 : if (f2fs_get_node_info(sbi, nid, dni)) {
626 : 0 : f2fs_put_page(node_page, 1);
627 : 0 : return false;
628 : : }
629 : :
630 : 0 : if (sum->version != dni->version) {
631 : 0 : f2fs_warn(sbi, "%s: valid data with mismatched node version.",
632 : : __func__);
633 : : set_sbi_flag(sbi, SBI_NEED_FSCK);
634 : : }
635 : :
636 : 0 : *nofs = ofs_of_node(node_page);
637 : 0 : source_blkaddr = datablock_addr(NULL, node_page, ofs_in_node);
638 : 0 : f2fs_put_page(node_page, 1);
639 : :
640 : 0 : if (source_blkaddr != blkaddr) {
641 : : #ifdef CONFIG_F2FS_CHECK_FS
642 : : unsigned int segno = GET_SEGNO(sbi, blkaddr);
643 : : unsigned long offset = GET_BLKOFF_FROM_SEG0(sbi, blkaddr);
644 : :
645 : : if (unlikely(check_valid_map(sbi, segno, offset))) {
646 : : if (!test_and_set_bit(segno, SIT_I(sbi)->invalid_segmap)) {
647 : : f2fs_err(sbi, "mismatched blkaddr %u (source_blkaddr %u) in seg %u\n",
648 : : blkaddr, source_blkaddr, segno);
649 : : f2fs_bug_on(sbi, 1);
650 : : }
651 : : }
652 : : #endif
653 : : return false;
654 : : }
655 : 0 : return true;
656 : : }
657 : :
658 : 0 : static int ra_data_block(struct inode *inode, pgoff_t index)
659 : : {
660 : : struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
661 : 0 : struct address_space *mapping = inode->i_mapping;
662 : : struct dnode_of_data dn;
663 : : struct page *page;
664 : 0 : struct extent_info ei = {0, 0, 0};
665 : 0 : struct f2fs_io_info fio = {
666 : : .sbi = sbi,
667 : 0 : .ino = inode->i_ino,
668 : : .type = DATA,
669 : : .temp = COLD,
670 : : .op = REQ_OP_READ,
671 : : .op_flags = 0,
672 : : .encrypted_page = NULL,
673 : : .in_list = false,
674 : : .retry = false,
675 : : };
676 : : int err;
677 : :
678 : 0 : page = f2fs_grab_cache_page(mapping, index, true);
679 : 0 : if (!page)
680 : : return -ENOMEM;
681 : :
682 : 0 : if (f2fs_lookup_extent_cache(inode, index, &ei)) {
683 : 0 : dn.data_blkaddr = ei.blk + index - ei.fofs;
684 : 0 : if (unlikely(!f2fs_is_valid_blkaddr(sbi, dn.data_blkaddr,
685 : : DATA_GENERIC_ENHANCE_READ))) {
686 : : err = -EFSCORRUPTED;
687 : : goto put_page;
688 : : }
689 : : goto got_it;
690 : : }
691 : :
692 : : set_new_dnode(&dn, inode, NULL, NULL, 0);
693 : 0 : err = f2fs_get_dnode_of_data(&dn, index, LOOKUP_NODE);
694 : 0 : if (err)
695 : : goto put_page;
696 : 0 : f2fs_put_dnode(&dn);
697 : :
698 : 0 : if (!__is_valid_data_blkaddr(dn.data_blkaddr)) {
699 : : err = -ENOENT;
700 : : goto put_page;
701 : : }
702 : 0 : if (unlikely(!f2fs_is_valid_blkaddr(sbi, dn.data_blkaddr,
703 : : DATA_GENERIC_ENHANCE))) {
704 : : err = -EFSCORRUPTED;
705 : : goto put_page;
706 : : }
707 : : got_it:
708 : : /* read page */
709 : 0 : fio.page = page;
710 : 0 : fio.new_blkaddr = fio.old_blkaddr = dn.data_blkaddr;
711 : :
712 : : /*
713 : : * don't cache encrypted data into meta inode until previous dirty
714 : : * data were writebacked to avoid racing between GC and flush.
715 : : */
716 : 0 : f2fs_wait_on_page_writeback(page, DATA, true, true);
717 : :
718 : 0 : f2fs_wait_on_block_writeback(inode, dn.data_blkaddr);
719 : :
720 : 0 : fio.encrypted_page = f2fs_pagecache_get_page(META_MAPPING(sbi),
721 : 0 : dn.data_blkaddr,
722 : : FGP_LOCK | FGP_CREAT, GFP_NOFS);
723 : 0 : if (!fio.encrypted_page) {
724 : : err = -ENOMEM;
725 : : goto put_page;
726 : : }
727 : :
728 : 0 : err = f2fs_submit_page_bio(&fio);
729 : 0 : if (err)
730 : : goto put_encrypted_page;
731 : 0 : f2fs_put_page(fio.encrypted_page, 0);
732 : 0 : f2fs_put_page(page, 1);
733 : 0 : return 0;
734 : : put_encrypted_page:
735 : 0 : f2fs_put_page(fio.encrypted_page, 1);
736 : : put_page:
737 : 0 : f2fs_put_page(page, 1);
738 : 0 : return err;
739 : : }
740 : :
741 : : /*
742 : : * Move data block via META_MAPPING while keeping locked data page.
743 : : * This can be used to move blocks, aka LBAs, directly on disk.
744 : : */
745 : 0 : static int move_data_block(struct inode *inode, block_t bidx,
746 : : int gc_type, unsigned int segno, int off)
747 : : {
748 : 0 : struct f2fs_io_info fio = {
749 : : .sbi = F2FS_I_SB(inode),
750 : 0 : .ino = inode->i_ino,
751 : : .type = DATA,
752 : : .temp = COLD,
753 : : .op = REQ_OP_READ,
754 : : .op_flags = 0,
755 : : .encrypted_page = NULL,
756 : : .in_list = false,
757 : : .retry = false,
758 : : };
759 : : struct dnode_of_data dn;
760 : : struct f2fs_summary sum;
761 : : struct node_info ni;
762 : : struct page *page, *mpage;
763 : : block_t newaddr;
764 : : int err = 0;
765 : 0 : bool lfs_mode = test_opt(fio.sbi, LFS);
766 : :
767 : : /* do not read out */
768 : 0 : page = f2fs_grab_cache_page(inode->i_mapping, bidx, false);
769 : 0 : if (!page)
770 : : return -ENOMEM;
771 : :
772 : 0 : if (!check_valid_map(F2FS_I_SB(inode), segno, off)) {
773 : : err = -ENOENT;
774 : : goto out;
775 : : }
776 : :
777 : 0 : if (f2fs_is_atomic_file(inode)) {
778 : 0 : F2FS_I(inode)->i_gc_failures[GC_FAILURE_ATOMIC]++;
779 : 0 : F2FS_I_SB(inode)->skipped_atomic_files[gc_type]++;
780 : : err = -EAGAIN;
781 : 0 : goto out;
782 : : }
783 : :
784 : 0 : if (f2fs_is_pinned_file(inode)) {
785 : 0 : f2fs_pin_file_control(inode, true);
786 : : err = -EAGAIN;
787 : 0 : goto out;
788 : : }
789 : :
790 : : set_new_dnode(&dn, inode, NULL, NULL, 0);
791 : 0 : err = f2fs_get_dnode_of_data(&dn, bidx, LOOKUP_NODE);
792 : 0 : if (err)
793 : : goto out;
794 : :
795 : 0 : if (unlikely(dn.data_blkaddr == NULL_ADDR)) {
796 : : ClearPageUptodate(page);
797 : : err = -ENOENT;
798 : 0 : goto put_out;
799 : : }
800 : :
801 : : /*
802 : : * don't cache encrypted data into meta inode until previous dirty
803 : : * data were writebacked to avoid racing between GC and flush.
804 : : */
805 : 0 : f2fs_wait_on_page_writeback(page, DATA, true, true);
806 : :
807 : 0 : f2fs_wait_on_block_writeback(inode, dn.data_blkaddr);
808 : :
809 : 0 : err = f2fs_get_node_info(fio.sbi, dn.nid, &ni);
810 : 0 : if (err)
811 : : goto put_out;
812 : :
813 : 0 : set_summary(&sum, dn.nid, dn.ofs_in_node, ni.version);
814 : :
815 : : /* read page */
816 : 0 : fio.page = page;
817 : 0 : fio.new_blkaddr = fio.old_blkaddr = dn.data_blkaddr;
818 : :
819 : 0 : if (lfs_mode)
820 : 0 : down_write(&fio.sbi->io_order_lock);
821 : :
822 : 0 : mpage = f2fs_grab_cache_page(META_MAPPING(fio.sbi),
823 : 0 : fio.old_blkaddr, false);
824 : 0 : if (!mpage)
825 : : goto up_out;
826 : :
827 : 0 : fio.encrypted_page = mpage;
828 : :
829 : : /* read source block in mpage */
830 : 0 : if (!PageUptodate(mpage)) {
831 : 0 : err = f2fs_submit_page_bio(&fio);
832 : 0 : if (err) {
833 : 0 : f2fs_put_page(mpage, 1);
834 : 0 : goto up_out;
835 : : }
836 : 0 : lock_page(mpage);
837 : 0 : if (unlikely(mpage->mapping != META_MAPPING(fio.sbi) ||
838 : : !PageUptodate(mpage))) {
839 : : err = -EIO;
840 : 0 : f2fs_put_page(mpage, 1);
841 : 0 : goto up_out;
842 : : }
843 : : }
844 : :
845 : 0 : f2fs_allocate_data_block(fio.sbi, NULL, fio.old_blkaddr, &newaddr,
846 : : &sum, CURSEG_COLD_DATA, NULL, false);
847 : :
848 : 0 : fio.encrypted_page = f2fs_pagecache_get_page(META_MAPPING(fio.sbi),
849 : : newaddr, FGP_LOCK | FGP_CREAT, GFP_NOFS);
850 : 0 : if (!fio.encrypted_page) {
851 : : err = -ENOMEM;
852 : 0 : f2fs_put_page(mpage, 1);
853 : 0 : goto recover_block;
854 : : }
855 : :
856 : : /* write target block */
857 : 0 : f2fs_wait_on_page_writeback(fio.encrypted_page, DATA, true, true);
858 : 0 : memcpy(page_address(fio.encrypted_page),
859 : : page_address(mpage), PAGE_SIZE);
860 : 0 : f2fs_put_page(mpage, 1);
861 : 0 : invalidate_mapping_pages(META_MAPPING(fio.sbi),
862 : 0 : fio.old_blkaddr, fio.old_blkaddr);
863 : :
864 : 0 : set_page_dirty(fio.encrypted_page);
865 : 0 : if (clear_page_dirty_for_io(fio.encrypted_page))
866 : 0 : dec_page_count(fio.sbi, F2FS_DIRTY_META);
867 : :
868 : 0 : set_page_writeback(fio.encrypted_page);
869 : : ClearPageError(page);
870 : :
871 : : /* allocate block address */
872 : 0 : f2fs_wait_on_page_writeback(dn.node_page, NODE, true, true);
873 : :
874 : 0 : fio.op = REQ_OP_WRITE;
875 : 0 : fio.op_flags = REQ_SYNC;
876 : 0 : fio.new_blkaddr = newaddr;
877 : 0 : f2fs_submit_page_write(&fio);
878 : 0 : if (fio.retry) {
879 : : err = -EAGAIN;
880 : 0 : if (PageWriteback(fio.encrypted_page))
881 : 0 : end_page_writeback(fio.encrypted_page);
882 : : goto put_page_out;
883 : : }
884 : :
885 : 0 : f2fs_update_iostat(fio.sbi, FS_GC_DATA_IO, F2FS_BLKSIZE);
886 : :
887 : 0 : f2fs_update_data_blkaddr(&dn, newaddr);
888 : 0 : set_inode_flag(inode, FI_APPEND_WRITE);
889 : 0 : if (page->index == 0)
890 : 0 : set_inode_flag(inode, FI_FIRST_BLOCK_WRITTEN);
891 : : put_page_out:
892 : 0 : f2fs_put_page(fio.encrypted_page, 1);
893 : : recover_block:
894 : 0 : if (err)
895 : 0 : f2fs_do_replace_block(fio.sbi, &sum, newaddr, fio.old_blkaddr,
896 : : true, true);
897 : : up_out:
898 : 0 : if (lfs_mode)
899 : 0 : up_write(&fio.sbi->io_order_lock);
900 : : put_out:
901 : 0 : f2fs_put_dnode(&dn);
902 : : out:
903 : 0 : f2fs_put_page(page, 1);
904 : 0 : return err;
905 : : }
906 : :
907 : 0 : static int move_data_page(struct inode *inode, block_t bidx, int gc_type,
908 : : unsigned int segno, int off)
909 : : {
910 : : struct page *page;
911 : : int err = 0;
912 : :
913 : 0 : page = f2fs_get_lock_data_page(inode, bidx, true);
914 : 0 : if (IS_ERR(page))
915 : 0 : return PTR_ERR(page);
916 : :
917 : 0 : if (!check_valid_map(F2FS_I_SB(inode), segno, off)) {
918 : : err = -ENOENT;
919 : : goto out;
920 : : }
921 : :
922 : 0 : if (f2fs_is_atomic_file(inode)) {
923 : 0 : F2FS_I(inode)->i_gc_failures[GC_FAILURE_ATOMIC]++;
924 : 0 : F2FS_I_SB(inode)->skipped_atomic_files[gc_type]++;
925 : : err = -EAGAIN;
926 : 0 : goto out;
927 : : }
928 : 0 : if (f2fs_is_pinned_file(inode)) {
929 : 0 : if (gc_type == FG_GC)
930 : 0 : f2fs_pin_file_control(inode, true);
931 : : err = -EAGAIN;
932 : : goto out;
933 : : }
934 : :
935 : 0 : if (gc_type == BG_GC) {
936 : 0 : if (PageWriteback(page)) {
937 : : err = -EAGAIN;
938 : : goto out;
939 : : }
940 : 0 : set_page_dirty(page);
941 : : set_cold_data(page);
942 : : } else {
943 : 0 : struct f2fs_io_info fio = {
944 : : .sbi = F2FS_I_SB(inode),
945 : 0 : .ino = inode->i_ino,
946 : : .type = DATA,
947 : : .temp = COLD,
948 : : .op = REQ_OP_WRITE,
949 : : .op_flags = REQ_SYNC,
950 : : .old_blkaddr = NULL_ADDR,
951 : : .page = page,
952 : : .encrypted_page = NULL,
953 : : .need_lock = LOCK_REQ,
954 : : .io_type = FS_GC_DATA_IO,
955 : : };
956 : : bool is_dirty = PageDirty(page);
957 : :
958 : : retry:
959 : 0 : f2fs_wait_on_page_writeback(page, DATA, true, true);
960 : :
961 : 0 : set_page_dirty(page);
962 : 0 : if (clear_page_dirty_for_io(page)) {
963 : 0 : inode_dec_dirty_pages(inode);
964 : 0 : f2fs_remove_dirty_inode(inode);
965 : : }
966 : :
967 : : set_cold_data(page);
968 : :
969 : 0 : err = f2fs_do_write_data_page(&fio);
970 : 0 : if (err) {
971 : : clear_cold_data(page);
972 : 0 : if (err == -ENOMEM) {
973 : 0 : congestion_wait(BLK_RW_ASYNC, HZ/50);
974 : 0 : goto retry;
975 : : }
976 : 0 : if (is_dirty)
977 : 0 : set_page_dirty(page);
978 : : }
979 : : }
980 : : out:
981 : 0 : f2fs_put_page(page, 1);
982 : 0 : return err;
983 : : }
984 : :
985 : : /*
986 : : * This function tries to get parent node of victim data block, and identifies
987 : : * data block validity. If the block is valid, copy that with cold status and
988 : : * modify parent node.
989 : : * If the parent node is not valid or the data block address is different,
990 : : * the victim data block is ignored.
991 : : */
992 : 0 : static int gc_data_segment(struct f2fs_sb_info *sbi, struct f2fs_summary *sum,
993 : : struct gc_inode_list *gc_list, unsigned int segno, int gc_type)
994 : : {
995 : 0 : struct super_block *sb = sbi->sb;
996 : : struct f2fs_summary *entry;
997 : : block_t start_addr;
998 : : int off;
999 : : int phase = 0;
1000 : : int submitted = 0;
1001 : :
1002 : 0 : start_addr = START_BLOCK(sbi, segno);
1003 : :
1004 : : next_step:
1005 : : entry = sum;
1006 : :
1007 : 0 : for (off = 0; off < sbi->blocks_per_seg; off++, entry++) {
1008 : : struct page *data_page;
1009 : : struct inode *inode;
1010 : : struct node_info dni; /* dnode info for the data */
1011 : : unsigned int ofs_in_node, nofs;
1012 : : block_t start_bidx;
1013 : 0 : nid_t nid = le32_to_cpu(entry->nid);
1014 : :
1015 : : /* stop BG_GC if there is not enough free sections. */
1016 : 0 : if (gc_type == BG_GC && has_not_enough_free_secs(sbi, 0, 0))
1017 : 0 : return submitted;
1018 : :
1019 : 0 : if (check_valid_map(sbi, segno, off) == 0)
1020 : 0 : continue;
1021 : :
1022 : 0 : if (phase == 0) {
1023 : 0 : f2fs_ra_meta_pages(sbi, NAT_BLOCK_OFFSET(nid), 1,
1024 : : META_NAT, true);
1025 : 0 : continue;
1026 : : }
1027 : :
1028 : 0 : if (phase == 1) {
1029 : 0 : f2fs_ra_node_page(sbi, nid);
1030 : 0 : continue;
1031 : : }
1032 : :
1033 : : /* Get an inode by ino with checking validity */
1034 : 0 : if (!is_alive(sbi, entry, &dni, start_addr + off, &nofs))
1035 : 0 : continue;
1036 : :
1037 : 0 : if (phase == 2) {
1038 : 0 : f2fs_ra_node_page(sbi, dni.ino);
1039 : 0 : continue;
1040 : : }
1041 : :
1042 : 0 : ofs_in_node = le16_to_cpu(entry->ofs_in_node);
1043 : :
1044 : 0 : if (phase == 3) {
1045 : 0 : inode = f2fs_iget(sb, dni.ino);
1046 : 0 : if (IS_ERR(inode) || is_bad_inode(inode))
1047 : 0 : continue;
1048 : :
1049 : 0 : if (!down_write_trylock(
1050 : : &F2FS_I(inode)->i_gc_rwsem[WRITE])) {
1051 : 0 : iput(inode);
1052 : 0 : sbi->skipped_gc_rwsem++;
1053 : 0 : continue;
1054 : : }
1055 : :
1056 : 0 : start_bidx = f2fs_start_bidx_of_node(nofs, inode) +
1057 : : ofs_in_node;
1058 : :
1059 : 0 : if (f2fs_post_read_required(inode)) {
1060 : 0 : int err = ra_data_block(inode, start_bidx);
1061 : :
1062 : 0 : up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1063 : 0 : if (err) {
1064 : 0 : iput(inode);
1065 : 0 : continue;
1066 : : }
1067 : 0 : add_gc_inode(gc_list, inode);
1068 : 0 : continue;
1069 : : }
1070 : :
1071 : 0 : data_page = f2fs_get_read_data_page(inode,
1072 : : start_bidx, REQ_RAHEAD, true);
1073 : 0 : up_write(&F2FS_I(inode)->i_gc_rwsem[WRITE]);
1074 : 0 : if (IS_ERR(data_page)) {
1075 : 0 : iput(inode);
1076 : 0 : continue;
1077 : : }
1078 : :
1079 : 0 : f2fs_put_page(data_page, 0);
1080 : 0 : add_gc_inode(gc_list, inode);
1081 : 0 : continue;
1082 : : }
1083 : :
1084 : : /* phase 4 */
1085 : 0 : inode = find_gc_inode(gc_list, dni.ino);
1086 : 0 : if (inode) {
1087 : : struct f2fs_inode_info *fi = F2FS_I(inode);
1088 : : bool locked = false;
1089 : : int err;
1090 : :
1091 : 0 : if (S_ISREG(inode->i_mode)) {
1092 : 0 : if (!down_write_trylock(&fi->i_gc_rwsem[READ]))
1093 : 0 : continue;
1094 : 0 : if (!down_write_trylock(
1095 : : &fi->i_gc_rwsem[WRITE])) {
1096 : 0 : sbi->skipped_gc_rwsem++;
1097 : 0 : up_write(&fi->i_gc_rwsem[READ]);
1098 : 0 : continue;
1099 : : }
1100 : : locked = true;
1101 : :
1102 : : /* wait for all inflight aio data */
1103 : 0 : inode_dio_wait(inode);
1104 : : }
1105 : :
1106 : 0 : start_bidx = f2fs_start_bidx_of_node(nofs, inode)
1107 : : + ofs_in_node;
1108 : 0 : if (f2fs_post_read_required(inode))
1109 : 0 : err = move_data_block(inode, start_bidx,
1110 : : gc_type, segno, off);
1111 : : else
1112 : 0 : err = move_data_page(inode, start_bidx, gc_type,
1113 : : segno, off);
1114 : :
1115 : 0 : if (!err && (gc_type == FG_GC ||
1116 : : f2fs_post_read_required(inode)))
1117 : 0 : submitted++;
1118 : :
1119 : 0 : if (locked) {
1120 : 0 : up_write(&fi->i_gc_rwsem[WRITE]);
1121 : 0 : up_write(&fi->i_gc_rwsem[READ]);
1122 : : }
1123 : :
1124 : 0 : stat_inc_data_blk_count(sbi, 1, gc_type);
1125 : : }
1126 : : }
1127 : :
1128 : 0 : if (++phase < 5)
1129 : : goto next_step;
1130 : :
1131 : : return submitted;
1132 : : }
1133 : :
1134 : 0 : static int __get_victim(struct f2fs_sb_info *sbi, unsigned int *victim,
1135 : : int gc_type)
1136 : : {
1137 : : struct sit_info *sit_i = SIT_I(sbi);
1138 : : int ret;
1139 : :
1140 : 0 : down_write(&sit_i->sentry_lock);
1141 : 0 : ret = DIRTY_I(sbi)->v_ops->get_victim(sbi, victim, gc_type,
1142 : : NO_CHECK_TYPE, LFS);
1143 : 0 : up_write(&sit_i->sentry_lock);
1144 : 0 : return ret;
1145 : : }
1146 : :
1147 : 0 : static int do_garbage_collect(struct f2fs_sb_info *sbi,
1148 : : unsigned int start_segno,
1149 : : struct gc_inode_list *gc_list, int gc_type)
1150 : : {
1151 : : struct page *sum_page;
1152 : : struct f2fs_summary_block *sum;
1153 : : struct blk_plug plug;
1154 : : unsigned int segno = start_segno;
1155 : 0 : unsigned int end_segno = start_segno + sbi->segs_per_sec;
1156 : : int seg_freed = 0, migrated = 0;
1157 : 0 : unsigned char type = IS_DATASEG(get_seg_entry(sbi, segno)->type) ?
1158 : 0 : SUM_TYPE_DATA : SUM_TYPE_NODE;
1159 : : int submitted = 0;
1160 : :
1161 : 0 : if (__is_large_section(sbi))
1162 : 0 : end_segno = rounddown(end_segno, sbi->segs_per_sec);
1163 : :
1164 : : /* readahead multi ssa blocks those have contiguous address */
1165 : 0 : if (__is_large_section(sbi))
1166 : 0 : f2fs_ra_meta_pages(sbi, GET_SUM_BLOCK(sbi, segno),
1167 : 0 : end_segno - segno, META_SSA, true);
1168 : :
1169 : : /* reference all summary page */
1170 : 0 : while (segno < end_segno) {
1171 : 0 : sum_page = f2fs_get_sum_page(sbi, segno++);
1172 : 0 : if (IS_ERR(sum_page)) {
1173 : : int err = PTR_ERR(sum_page);
1174 : :
1175 : 0 : end_segno = segno - 1;
1176 : 0 : for (segno = start_segno; segno < end_segno; segno++) {
1177 : : sum_page = find_get_page(META_MAPPING(sbi),
1178 : 0 : GET_SUM_BLOCK(sbi, segno));
1179 : 0 : f2fs_put_page(sum_page, 0);
1180 : 0 : f2fs_put_page(sum_page, 0);
1181 : : }
1182 : : return err;
1183 : : }
1184 : 0 : unlock_page(sum_page);
1185 : : }
1186 : :
1187 : 0 : blk_start_plug(&plug);
1188 : :
1189 : 0 : for (segno = start_segno; segno < end_segno; segno++) {
1190 : :
1191 : : /* find segment summary of victim */
1192 : : sum_page = find_get_page(META_MAPPING(sbi),
1193 : 0 : GET_SUM_BLOCK(sbi, segno));
1194 : 0 : f2fs_put_page(sum_page, 0);
1195 : :
1196 : 0 : if (get_valid_blocks(sbi, segno, false) == 0)
1197 : : goto freed;
1198 : 0 : if (__is_large_section(sbi) &&
1199 : 0 : migrated >= sbi->migration_granularity)
1200 : : goto skip;
1201 : 0 : if (!PageUptodate(sum_page) || unlikely(f2fs_cp_error(sbi)))
1202 : : goto skip;
1203 : :
1204 : : sum = page_address(sum_page);
1205 : 0 : if (type != GET_SUM_TYPE((&sum->footer))) {
1206 : 0 : f2fs_err(sbi, "Inconsistent segment (%u) type [%d, %d] in SSA and SIT",
1207 : : segno, type, GET_SUM_TYPE((&sum->footer)));
1208 : : set_sbi_flag(sbi, SBI_NEED_FSCK);
1209 : 0 : f2fs_stop_checkpoint(sbi, false);
1210 : 0 : goto skip;
1211 : : }
1212 : :
1213 : : /*
1214 : : * this is to avoid deadlock:
1215 : : * - lock_page(sum_page) - f2fs_replace_block
1216 : : * - check_valid_map() - down_write(sentry_lock)
1217 : : * - down_read(sentry_lock) - change_curseg()
1218 : : * - lock_page(sum_page)
1219 : : */
1220 : 0 : if (type == SUM_TYPE_NODE)
1221 : 0 : submitted += gc_node_segment(sbi, sum->entries, segno,
1222 : : gc_type);
1223 : : else
1224 : 0 : submitted += gc_data_segment(sbi, sum->entries, gc_list,
1225 : : segno, gc_type);
1226 : :
1227 : 0 : stat_inc_seg_count(sbi, type, gc_type);
1228 : :
1229 : : freed:
1230 : 0 : if (gc_type == FG_GC &&
1231 : 0 : get_valid_blocks(sbi, segno, false) == 0)
1232 : 0 : seg_freed++;
1233 : 0 : migrated++;
1234 : :
1235 : 0 : if (__is_large_section(sbi) && segno + 1 < end_segno)
1236 : 0 : sbi->next_victim_seg[gc_type] = segno + 1;
1237 : : skip:
1238 : 0 : f2fs_put_page(sum_page, 0);
1239 : : }
1240 : :
1241 : 0 : if (submitted)
1242 : 0 : f2fs_submit_merged_write(sbi,
1243 : : (type == SUM_TYPE_NODE) ? NODE : DATA);
1244 : :
1245 : 0 : blk_finish_plug(&plug);
1246 : :
1247 : 0 : stat_inc_call_count(sbi->stat_info);
1248 : :
1249 : 0 : return seg_freed;
1250 : : }
1251 : :
1252 : 0 : int f2fs_gc(struct f2fs_sb_info *sbi, bool sync,
1253 : : bool background, unsigned int segno)
1254 : : {
1255 : 0 : int gc_type = sync ? FG_GC : BG_GC;
1256 : : int sec_freed = 0, seg_freed = 0, total_freed = 0;
1257 : : int ret = 0;
1258 : : struct cp_control cpc;
1259 : 0 : unsigned int init_segno = segno;
1260 : 0 : struct gc_inode_list gc_list = {
1261 : : .ilist = LIST_HEAD_INIT(gc_list.ilist),
1262 : : .iroot = RADIX_TREE_INIT(gc_list.iroot, GFP_NOFS),
1263 : : };
1264 : 0 : unsigned long long last_skipped = sbi->skipped_atomic_files[FG_GC];
1265 : : unsigned long long first_skipped;
1266 : : unsigned int skipped_round = 0, round = 0;
1267 : :
1268 : 0 : trace_f2fs_gc_begin(sbi->sb, sync, background,
1269 : : get_pages(sbi, F2FS_DIRTY_NODES),
1270 : : get_pages(sbi, F2FS_DIRTY_DENTS),
1271 : : get_pages(sbi, F2FS_DIRTY_IMETA),
1272 : : free_sections(sbi),
1273 : : free_segments(sbi),
1274 : : reserved_segments(sbi),
1275 : : prefree_segments(sbi));
1276 : :
1277 : 0 : cpc.reason = __get_cp_reason(sbi);
1278 : 0 : sbi->skipped_gc_rwsem = 0;
1279 : : first_skipped = last_skipped;
1280 : : gc_more:
1281 : 0 : if (unlikely(!(sbi->sb->s_flags & SB_ACTIVE))) {
1282 : : ret = -EINVAL;
1283 : : goto stop;
1284 : : }
1285 : 0 : if (unlikely(f2fs_cp_error(sbi))) {
1286 : : ret = -EIO;
1287 : : goto stop;
1288 : : }
1289 : :
1290 : 0 : if (gc_type == BG_GC && has_not_enough_free_secs(sbi, 0, 0)) {
1291 : : /*
1292 : : * For example, if there are many prefree_segments below given
1293 : : * threshold, we can make them free by checkpoint. Then, we
1294 : : * secure free segments which doesn't need fggc any more.
1295 : : */
1296 : 0 : if (prefree_segments(sbi) &&
1297 : : !is_sbi_flag_set(sbi, SBI_CP_DISABLED)) {
1298 : 0 : ret = f2fs_write_checkpoint(sbi, &cpc);
1299 : 0 : if (ret)
1300 : : goto stop;
1301 : : }
1302 : 0 : if (has_not_enough_free_secs(sbi, 0, 0))
1303 : : gc_type = FG_GC;
1304 : : }
1305 : :
1306 : : /* f2fs_balance_fs doesn't need to do BG_GC in critical path. */
1307 : 0 : if (gc_type == BG_GC && !background) {
1308 : : ret = -EINVAL;
1309 : : goto stop;
1310 : : }
1311 : 0 : if (!__get_victim(sbi, &segno, gc_type)) {
1312 : : ret = -ENODATA;
1313 : : goto stop;
1314 : : }
1315 : :
1316 : 0 : seg_freed = do_garbage_collect(sbi, segno, &gc_list, gc_type);
1317 : 0 : if (gc_type == FG_GC && seg_freed == sbi->segs_per_sec)
1318 : 0 : sec_freed++;
1319 : 0 : total_freed += seg_freed;
1320 : :
1321 : 0 : if (gc_type == FG_GC) {
1322 : 0 : if (sbi->skipped_atomic_files[FG_GC] > last_skipped ||
1323 : 0 : sbi->skipped_gc_rwsem)
1324 : 0 : skipped_round++;
1325 : : last_skipped = sbi->skipped_atomic_files[FG_GC];
1326 : 0 : round++;
1327 : : }
1328 : :
1329 : 0 : if (gc_type == FG_GC && seg_freed)
1330 : 0 : sbi->cur_victim_sec = NULL_SEGNO;
1331 : :
1332 : 0 : if (sync)
1333 : : goto stop;
1334 : :
1335 : 0 : if (has_not_enough_free_secs(sbi, sec_freed, 0)) {
1336 : 0 : if (skipped_round <= MAX_SKIP_GC_COUNT ||
1337 : 0 : skipped_round * 2 < round) {
1338 : 0 : segno = NULL_SEGNO;
1339 : 0 : goto gc_more;
1340 : : }
1341 : :
1342 : 0 : if (first_skipped < last_skipped &&
1343 : 0 : (last_skipped - first_skipped) >
1344 : 0 : sbi->skipped_gc_rwsem) {
1345 : 0 : f2fs_drop_inmem_pages_all(sbi, true);
1346 : 0 : segno = NULL_SEGNO;
1347 : 0 : goto gc_more;
1348 : : }
1349 : 0 : if (gc_type == FG_GC && !is_sbi_flag_set(sbi, SBI_CP_DISABLED))
1350 : 0 : ret = f2fs_write_checkpoint(sbi, &cpc);
1351 : : }
1352 : : stop:
1353 : 0 : SIT_I(sbi)->last_victim[ALLOC_NEXT] = 0;
1354 : 0 : SIT_I(sbi)->last_victim[FLUSH_DEVICE] = init_segno;
1355 : :
1356 : 0 : trace_f2fs_gc_end(sbi->sb, ret, total_freed, sec_freed,
1357 : : get_pages(sbi, F2FS_DIRTY_NODES),
1358 : : get_pages(sbi, F2FS_DIRTY_DENTS),
1359 : : get_pages(sbi, F2FS_DIRTY_IMETA),
1360 : : free_sections(sbi),
1361 : : free_segments(sbi),
1362 : : reserved_segments(sbi),
1363 : : prefree_segments(sbi));
1364 : :
1365 : 0 : mutex_unlock(&sbi->gc_mutex);
1366 : :
1367 : 0 : put_gc_inode(&gc_list);
1368 : :
1369 : 0 : if (sync && !ret)
1370 : 0 : ret = sec_freed ? 0 : -EAGAIN;
1371 : 0 : return ret;
1372 : : }
1373 : :
1374 : 0 : void f2fs_build_gc_manager(struct f2fs_sb_info *sbi)
1375 : : {
1376 : 0 : DIRTY_I(sbi)->v_ops = &default_v_ops;
1377 : :
1378 : 0 : sbi->gc_pin_file_threshold = DEF_GC_FAILED_PINNED_FILES;
1379 : :
1380 : : /* give warm/cold data area from slower device */
1381 : 0 : if (f2fs_is_multi_device(sbi) && !__is_large_section(sbi))
1382 : 0 : SIT_I(sbi)->last_victim[ALLOC_NEXT] =
1383 : 0 : GET_SEGNO(sbi, FDEV(0).end_blk) + 1;
1384 : 0 : }
1385 : :
1386 : 0 : static int free_segment_range(struct f2fs_sb_info *sbi, unsigned int start,
1387 : : unsigned int end)
1388 : : {
1389 : : int type;
1390 : : unsigned int segno, next_inuse;
1391 : : int err = 0;
1392 : :
1393 : : /* Move out cursegs from the target range */
1394 : 0 : for (type = CURSEG_HOT_DATA; type < NR_CURSEG_TYPE; type++)
1395 : 0 : allocate_segment_for_resize(sbi, type, start, end);
1396 : :
1397 : : /* do GC to move out valid blocks in the range */
1398 : 0 : for (segno = start; segno <= end; segno += sbi->segs_per_sec) {
1399 : 0 : struct gc_inode_list gc_list = {
1400 : : .ilist = LIST_HEAD_INIT(gc_list.ilist),
1401 : : .iroot = RADIX_TREE_INIT(gc_list.iroot, GFP_NOFS),
1402 : : };
1403 : :
1404 : 0 : mutex_lock(&sbi->gc_mutex);
1405 : 0 : do_garbage_collect(sbi, segno, &gc_list, FG_GC);
1406 : 0 : mutex_unlock(&sbi->gc_mutex);
1407 : 0 : put_gc_inode(&gc_list);
1408 : :
1409 : 0 : if (get_valid_blocks(sbi, segno, true))
1410 : 0 : return -EAGAIN;
1411 : : }
1412 : :
1413 : 0 : err = f2fs_sync_fs(sbi->sb, 1);
1414 : 0 : if (err)
1415 : : return err;
1416 : :
1417 : 0 : next_inuse = find_next_inuse(FREE_I(sbi), end + 1, start);
1418 : 0 : if (next_inuse <= end) {
1419 : 0 : f2fs_err(sbi, "segno %u should be free but still inuse!",
1420 : : next_inuse);
1421 : 0 : f2fs_bug_on(sbi, 1);
1422 : : }
1423 : 0 : return err;
1424 : : }
1425 : :
1426 : 0 : static void update_sb_metadata(struct f2fs_sb_info *sbi, int secs)
1427 : : {
1428 : : struct f2fs_super_block *raw_sb = F2FS_RAW_SUPER(sbi);
1429 : 0 : int section_count = le32_to_cpu(raw_sb->section_count);
1430 : 0 : int segment_count = le32_to_cpu(raw_sb->segment_count);
1431 : 0 : int segment_count_main = le32_to_cpu(raw_sb->segment_count_main);
1432 : 0 : long long block_count = le64_to_cpu(raw_sb->block_count);
1433 : 0 : int segs = secs * sbi->segs_per_sec;
1434 : :
1435 : 0 : raw_sb->section_count = cpu_to_le32(section_count + secs);
1436 : 0 : raw_sb->segment_count = cpu_to_le32(segment_count + segs);
1437 : 0 : raw_sb->segment_count_main = cpu_to_le32(segment_count_main + segs);
1438 : 0 : raw_sb->block_count = cpu_to_le64(block_count +
1439 : : (long long)segs * sbi->blocks_per_seg);
1440 : 0 : }
1441 : :
1442 : 0 : static void update_fs_metadata(struct f2fs_sb_info *sbi, int secs)
1443 : : {
1444 : 0 : int segs = secs * sbi->segs_per_sec;
1445 : 0 : long long user_block_count =
1446 : 0 : le64_to_cpu(F2FS_CKPT(sbi)->user_block_count);
1447 : :
1448 : 0 : SM_I(sbi)->segment_count = (int)SM_I(sbi)->segment_count + segs;
1449 : 0 : MAIN_SEGS(sbi) = (int)MAIN_SEGS(sbi) + segs;
1450 : 0 : FREE_I(sbi)->free_sections = (int)FREE_I(sbi)->free_sections + secs;
1451 : 0 : FREE_I(sbi)->free_segments = (int)FREE_I(sbi)->free_segments + segs;
1452 : 0 : F2FS_CKPT(sbi)->user_block_count = cpu_to_le64(user_block_count +
1453 : : (long long)segs * sbi->blocks_per_seg);
1454 : 0 : }
1455 : :
1456 : 0 : int f2fs_resize_fs(struct f2fs_sb_info *sbi, __u64 block_count)
1457 : : {
1458 : : __u64 old_block_count, shrunk_blocks;
1459 : : unsigned int secs;
1460 : : int gc_mode, gc_type;
1461 : : int err = 0;
1462 : : __u32 rem;
1463 : :
1464 : 0 : old_block_count = le64_to_cpu(F2FS_RAW_SUPER(sbi)->block_count);
1465 : 0 : if (block_count > old_block_count)
1466 : : return -EINVAL;
1467 : :
1468 : : /* new fs size should align to section size */
1469 : 0 : div_u64_rem(block_count, BLKS_PER_SEC(sbi), &rem);
1470 : 0 : if (rem)
1471 : : return -EINVAL;
1472 : :
1473 : 0 : if (block_count == old_block_count)
1474 : : return 0;
1475 : :
1476 : 0 : if (is_sbi_flag_set(sbi, SBI_NEED_FSCK)) {
1477 : 0 : f2fs_err(sbi, "Should run fsck to repair first.");
1478 : 0 : return -EFSCORRUPTED;
1479 : : }
1480 : :
1481 : 0 : if (test_opt(sbi, DISABLE_CHECKPOINT)) {
1482 : 0 : f2fs_err(sbi, "Checkpoint should be enabled.");
1483 : 0 : return -EINVAL;
1484 : : }
1485 : :
1486 : 0 : freeze_bdev(sbi->sb->s_bdev);
1487 : :
1488 : 0 : shrunk_blocks = old_block_count - block_count;
1489 : 0 : secs = div_u64(shrunk_blocks, BLKS_PER_SEC(sbi));
1490 : : spin_lock(&sbi->stat_lock);
1491 : 0 : if (shrunk_blocks + valid_user_blocks(sbi) +
1492 : 0 : sbi->current_reserved_blocks + sbi->unusable_block_count +
1493 : 0 : F2FS_OPTION(sbi).root_reserved_blocks > sbi->user_block_count)
1494 : : err = -ENOSPC;
1495 : : else
1496 : 0 : sbi->user_block_count -= shrunk_blocks;
1497 : : spin_unlock(&sbi->stat_lock);
1498 : 0 : if (err) {
1499 : 0 : thaw_bdev(sbi->sb->s_bdev, sbi->sb);
1500 : 0 : return err;
1501 : : }
1502 : :
1503 : 0 : mutex_lock(&sbi->resize_mutex);
1504 : : set_sbi_flag(sbi, SBI_IS_RESIZEFS);
1505 : :
1506 : 0 : mutex_lock(&DIRTY_I(sbi)->seglist_lock);
1507 : :
1508 : 0 : MAIN_SECS(sbi) -= secs;
1509 : :
1510 : 0 : for (gc_mode = 0; gc_mode < MAX_GC_POLICY; gc_mode++)
1511 : 0 : if (SIT_I(sbi)->last_victim[gc_mode] >=
1512 : 0 : MAIN_SECS(sbi) * sbi->segs_per_sec)
1513 : 0 : SIT_I(sbi)->last_victim[gc_mode] = 0;
1514 : :
1515 : 0 : for (gc_type = BG_GC; gc_type <= FG_GC; gc_type++)
1516 : 0 : if (sbi->next_victim_seg[gc_type] >=
1517 : 0 : MAIN_SECS(sbi) * sbi->segs_per_sec)
1518 : 0 : sbi->next_victim_seg[gc_type] = NULL_SEGNO;
1519 : :
1520 : 0 : mutex_unlock(&DIRTY_I(sbi)->seglist_lock);
1521 : :
1522 : 0 : err = free_segment_range(sbi, MAIN_SECS(sbi) * sbi->segs_per_sec,
1523 : 0 : MAIN_SEGS(sbi) - 1);
1524 : 0 : if (err)
1525 : : goto out;
1526 : :
1527 : 0 : update_sb_metadata(sbi, -secs);
1528 : :
1529 : 0 : err = f2fs_commit_super(sbi, false);
1530 : 0 : if (err) {
1531 : 0 : update_sb_metadata(sbi, secs);
1532 : 0 : goto out;
1533 : : }
1534 : :
1535 : 0 : mutex_lock(&sbi->cp_mutex);
1536 : 0 : update_fs_metadata(sbi, -secs);
1537 : : clear_sbi_flag(sbi, SBI_IS_RESIZEFS);
1538 : : set_sbi_flag(sbi, SBI_IS_DIRTY);
1539 : 0 : mutex_unlock(&sbi->cp_mutex);
1540 : :
1541 : 0 : err = f2fs_sync_fs(sbi->sb, 1);
1542 : 0 : if (err) {
1543 : 0 : mutex_lock(&sbi->cp_mutex);
1544 : 0 : update_fs_metadata(sbi, secs);
1545 : 0 : mutex_unlock(&sbi->cp_mutex);
1546 : 0 : update_sb_metadata(sbi, secs);
1547 : 0 : f2fs_commit_super(sbi, false);
1548 : : }
1549 : : out:
1550 : 0 : if (err) {
1551 : : set_sbi_flag(sbi, SBI_NEED_FSCK);
1552 : 0 : f2fs_err(sbi, "resize_fs failed, should run fsck to repair!");
1553 : :
1554 : 0 : MAIN_SECS(sbi) += secs;
1555 : : spin_lock(&sbi->stat_lock);
1556 : 0 : sbi->user_block_count += shrunk_blocks;
1557 : : spin_unlock(&sbi->stat_lock);
1558 : : }
1559 : : clear_sbi_flag(sbi, SBI_IS_RESIZEFS);
1560 : 0 : mutex_unlock(&sbi->resize_mutex);
1561 : 0 : thaw_bdev(sbi->sb->s_bdev, sbi->sb);
1562 : 0 : return err;
1563 : : }
|
