1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * fs/f2fs/recovery.c
4 *
5 * Copyright (c) 2012 Samsung Electronics Co., Ltd.
6 * http://www.samsung.com/
7 */
8 #include <linux/fs.h>
9 #include <linux/f2fs_fs.h>
10 #include "f2fs.h"
11 #include "node.h"
12 #include "segment.h"
13
14 /*
15 * Roll forward recovery scenarios.
16 *
17 * [Term] F: fsync_mark, D: dentry_mark
18 *
19 * 1. inode(x) | CP | inode(x) | dnode(F)
20 * -> Update the latest inode(x).
21 *
22 * 2. inode(x) | CP | inode(F) | dnode(F)
23 * -> No problem.
24 *
25 * 3. inode(x) | CP | dnode(F) | inode(x)
26 * -> Recover to the latest dnode(F), and drop the last inode(x)
27 *
28 * 4. inode(x) | CP | dnode(F) | inode(F)
29 * -> No problem.
30 *
31 * 5. CP | inode(x) | dnode(F)
32 * -> The inode(DF) was missing. Should drop this dnode(F).
33 *
34 * 6. CP | inode(DF) | dnode(F)
35 * -> No problem.
36 *
37 * 7. CP | dnode(F) | inode(DF)
38 * -> If f2fs_iget fails, then goto next to find inode(DF).
39 *
40 * 8. CP | dnode(F) | inode(x)
41 * -> If f2fs_iget fails, then goto next to find inode(DF).
42 * But it will fail due to no inode(DF).
43 */
44
45 static struct kmem_cache *fsync_entry_slab;
46
f2fs_space_for_roll_forward(struct f2fs_sb_info * sbi)47 bool f2fs_space_for_roll_forward(struct f2fs_sb_info *sbi)
48 {
49 s64 nalloc = percpu_counter_sum_positive(&sbi->alloc_valid_block_count);
50
51 if (sbi->last_valid_block_count + nalloc > sbi->user_block_count)
52 return false;
53 return true;
54 }
55
get_fsync_inode(struct list_head * head,nid_t ino)56 static struct fsync_inode_entry *get_fsync_inode(struct list_head *head,
57 nid_t ino)
58 {
59 struct fsync_inode_entry *entry;
60
61 list_for_each_entry(entry, head, list)
62 if (entry->inode->i_ino == ino)
63 return entry;
64
65 return NULL;
66 }
67
add_fsync_inode(struct f2fs_sb_info * sbi,struct list_head * head,nid_t ino,bool quota_inode)68 static struct fsync_inode_entry *add_fsync_inode(struct f2fs_sb_info *sbi,
69 struct list_head *head, nid_t ino, bool quota_inode)
70 {
71 struct inode *inode;
72 struct fsync_inode_entry *entry;
73 int err;
74
75 inode = f2fs_iget_retry(sbi->sb, ino);
76 if (IS_ERR(inode))
77 return ERR_CAST(inode);
78
79 err = dquot_initialize(inode);
80 if (err)
81 goto err_out;
82
83 if (quota_inode) {
84 err = dquot_alloc_inode(inode);
85 if (err)
86 goto err_out;
87 }
88
89 entry = f2fs_kmem_cache_alloc(fsync_entry_slab, GFP_F2FS_ZERO);
90 entry->inode = inode;
91 list_add_tail(&entry->list, head);
92
93 return entry;
94 err_out:
95 iput(inode);
96 return ERR_PTR(err);
97 }
98
del_fsync_inode(struct fsync_inode_entry * entry,int drop)99 static void del_fsync_inode(struct fsync_inode_entry *entry, int drop)
100 {
101 if (drop) {
102 /* inode should not be recovered, drop it */
103 f2fs_inode_synced(entry->inode);
104 }
105 iput(entry->inode);
106 list_del(&entry->list);
107 kmem_cache_free(fsync_entry_slab, entry);
108 }
109
init_recovered_filename(const struct inode * dir,struct f2fs_inode * raw_inode,struct f2fs_filename * fname,struct qstr * usr_fname)110 static int init_recovered_filename(const struct inode *dir,
111 struct f2fs_inode *raw_inode,
112 struct f2fs_filename *fname,
113 struct qstr *usr_fname)
114 {
115 int err;
116
117 memset(fname, 0, sizeof(*fname));
118 fname->disk_name.len = le32_to_cpu(raw_inode->i_namelen);
119 fname->disk_name.name = raw_inode->i_name;
120
121 if (WARN_ON(fname->disk_name.len > F2FS_NAME_LEN))
122 return -ENAMETOOLONG;
123
124 if (!IS_ENCRYPTED(dir)) {
125 usr_fname->name = fname->disk_name.name;
126 usr_fname->len = fname->disk_name.len;
127 fname->usr_fname = usr_fname;
128 }
129
130 /* Compute the hash of the filename */
131 if (IS_CASEFOLDED(dir)) {
132 err = f2fs_init_casefolded_name(dir, fname);
133 if (err)
134 return err;
135 f2fs_hash_filename(dir, fname);
136 #ifdef CONFIG_UNICODE
137 /* Case-sensitive match is fine for recovery */
138 kfree(fname->cf_name.name);
139 fname->cf_name.name = NULL;
140 #endif
141 } else {
142 f2fs_hash_filename(dir, fname);
143 }
144 return 0;
145 }
146
recover_dentry(struct inode * inode,struct page * ipage,struct list_head * dir_list)147 static int recover_dentry(struct inode *inode, struct page *ipage,
148 struct list_head *dir_list)
149 {
150 struct f2fs_inode *raw_inode = F2FS_INODE(ipage);
151 nid_t pino = le32_to_cpu(raw_inode->i_pino);
152 struct f2fs_dir_entry *de;
153 struct f2fs_filename fname;
154 struct qstr usr_fname;
155 struct page *page;
156 struct inode *dir, *einode;
157 struct fsync_inode_entry *entry;
158 int err = 0;
159 char *name;
160
161 entry = get_fsync_inode(dir_list, pino);
162 if (!entry) {
163 entry = add_fsync_inode(F2FS_I_SB(inode), dir_list,
164 pino, false);
165 if (IS_ERR(entry)) {
166 dir = ERR_CAST(entry);
167 err = PTR_ERR(entry);
168 goto out;
169 }
170 }
171
172 dir = entry->inode;
173 err = init_recovered_filename(dir, raw_inode, &fname, &usr_fname);
174 if (err)
175 goto out;
176 retry:
177 de = __f2fs_find_entry(dir, &fname, &page);
178 if (de && inode->i_ino == le32_to_cpu(de->ino))
179 goto out_put;
180
181 if (de) {
182 einode = f2fs_iget_retry(inode->i_sb, le32_to_cpu(de->ino));
183 if (IS_ERR(einode)) {
184 WARN_ON(1);
185 err = PTR_ERR(einode);
186 if (err == -ENOENT)
187 err = -EEXIST;
188 goto out_put;
189 }
190
191 err = dquot_initialize(einode);
192 if (err) {
193 iput(einode);
194 goto out_put;
195 }
196
197 err = f2fs_acquire_orphan_inode(F2FS_I_SB(inode));
198 if (err) {
199 iput(einode);
200 goto out_put;
201 }
202 f2fs_delete_entry(de, page, dir, einode);
203 iput(einode);
204 goto retry;
205 } else if (IS_ERR(page)) {
206 err = PTR_ERR(page);
207 } else {
208 err = f2fs_add_dentry(dir, &fname, inode,
209 inode->i_ino, inode->i_mode);
210 }
211 if (err == -ENOMEM)
212 goto retry;
213 goto out;
214
215 out_put:
216 f2fs_put_page(page, 0);
217 out:
218 if (file_enc_name(inode))
219 name = "<encrypted>";
220 else
221 name = raw_inode->i_name;
222 f2fs_notice(F2FS_I_SB(inode), "%s: ino = %x, name = %s, dir = %lx, err = %d",
223 __func__, ino_of_node(ipage), name,
224 IS_ERR(dir) ? 0 : dir->i_ino, err);
225 return err;
226 }
227
recover_quota_data(struct inode * inode,struct page * page)228 static int recover_quota_data(struct inode *inode, struct page *page)
229 {
230 struct f2fs_inode *raw = F2FS_INODE(page);
231 struct iattr attr;
232 uid_t i_uid = le32_to_cpu(raw->i_uid);
233 gid_t i_gid = le32_to_cpu(raw->i_gid);
234 int err;
235
236 memset(&attr, 0, sizeof(attr));
237
238 attr.ia_uid = make_kuid(inode->i_sb->s_user_ns, i_uid);
239 attr.ia_gid = make_kgid(inode->i_sb->s_user_ns, i_gid);
240
241 if (!uid_eq(attr.ia_uid, inode->i_uid))
242 attr.ia_valid |= ATTR_UID;
243 if (!gid_eq(attr.ia_gid, inode->i_gid))
244 attr.ia_valid |= ATTR_GID;
245
246 if (!attr.ia_valid)
247 return 0;
248
249 err = dquot_transfer(inode, &attr);
250 if (err)
251 set_sbi_flag(F2FS_I_SB(inode), SBI_QUOTA_NEED_REPAIR);
252 return err;
253 }
254
recover_inline_flags(struct inode * inode,struct f2fs_inode * ri)255 static void recover_inline_flags(struct inode *inode, struct f2fs_inode *ri)
256 {
257 if (ri->i_inline & F2FS_PIN_FILE)
258 set_inode_flag(inode, FI_PIN_FILE);
259 else
260 clear_inode_flag(inode, FI_PIN_FILE);
261 if (ri->i_inline & F2FS_DATA_EXIST)
262 set_inode_flag(inode, FI_DATA_EXIST);
263 else
264 clear_inode_flag(inode, FI_DATA_EXIST);
265 }
266
recover_inode(struct inode * inode,struct page * page)267 static int recover_inode(struct inode *inode, struct page *page)
268 {
269 struct f2fs_inode *raw = F2FS_INODE(page);
270 char *name;
271 int err;
272
273 inode->i_mode = le16_to_cpu(raw->i_mode);
274
275 err = recover_quota_data(inode, page);
276 if (err)
277 return err;
278
279 i_uid_write(inode, le32_to_cpu(raw->i_uid));
280 i_gid_write(inode, le32_to_cpu(raw->i_gid));
281
282 if (raw->i_inline & F2FS_EXTRA_ATTR) {
283 if (f2fs_sb_has_project_quota(F2FS_I_SB(inode)) &&
284 F2FS_FITS_IN_INODE(raw, le16_to_cpu(raw->i_extra_isize),
285 i_projid)) {
286 projid_t i_projid;
287 kprojid_t kprojid;
288
289 i_projid = (projid_t)le32_to_cpu(raw->i_projid);
290 kprojid = make_kprojid(&init_user_ns, i_projid);
291
292 if (!projid_eq(kprojid, F2FS_I(inode)->i_projid)) {
293 err = f2fs_transfer_project_quota(inode,
294 kprojid);
295 if (err)
296 return err;
297 F2FS_I(inode)->i_projid = kprojid;
298 }
299 }
300 }
301
302 f2fs_i_size_write(inode, le64_to_cpu(raw->i_size));
303 inode->i_atime.tv_sec = le64_to_cpu(raw->i_atime);
304 inode->i_ctime.tv_sec = le64_to_cpu(raw->i_ctime);
305 inode->i_mtime.tv_sec = le64_to_cpu(raw->i_mtime);
306 inode->i_atime.tv_nsec = le32_to_cpu(raw->i_atime_nsec);
307 inode->i_ctime.tv_nsec = le32_to_cpu(raw->i_ctime_nsec);
308 inode->i_mtime.tv_nsec = le32_to_cpu(raw->i_mtime_nsec);
309
310 F2FS_I(inode)->i_advise = raw->i_advise;
311 F2FS_I(inode)->i_flags = le32_to_cpu(raw->i_flags);
312 f2fs_set_inode_flags(inode);
313 F2FS_I(inode)->i_gc_failures[GC_FAILURE_PIN] =
314 le16_to_cpu(raw->i_gc_failures);
315
316 recover_inline_flags(inode, raw);
317
318 f2fs_mark_inode_dirty_sync(inode, true);
319
320 if (file_enc_name(inode))
321 name = "<encrypted>";
322 else
323 name = F2FS_INODE(page)->i_name;
324
325 f2fs_notice(F2FS_I_SB(inode), "recover_inode: ino = %x, name = %s, inline = %x",
326 ino_of_node(page), name, raw->i_inline);
327 return 0;
328 }
329
find_fsync_dnodes(struct f2fs_sb_info * sbi,struct list_head * head,bool check_only)330 static int find_fsync_dnodes(struct f2fs_sb_info *sbi, struct list_head *head,
331 bool check_only)
332 {
333 struct curseg_info *curseg;
334 struct page *page = NULL;
335 block_t blkaddr;
336 unsigned int loop_cnt = 0;
337 unsigned int free_blocks = MAIN_SEGS(sbi) * sbi->blocks_per_seg -
338 valid_user_blocks(sbi);
339 int err = 0;
340
341 /* get node pages in the current segment */
342 curseg = CURSEG_I(sbi, CURSEG_WARM_NODE);
343 blkaddr = NEXT_FREE_BLKADDR(sbi, curseg);
344
345 while (1) {
346 struct fsync_inode_entry *entry;
347
348 if (!f2fs_is_valid_blkaddr(sbi, blkaddr, META_POR))
349 return 0;
350
351 page = f2fs_get_tmp_page(sbi, blkaddr);
352 if (IS_ERR(page)) {
353 err = PTR_ERR(page);
354 break;
355 }
356
357 if (!is_recoverable_dnode(page)) {
358 f2fs_put_page(page, 1);
359 break;
360 }
361
362 if (!is_fsync_dnode(page))
363 goto next;
364
365 entry = get_fsync_inode(head, ino_of_node(page));
366 if (!entry) {
367 bool quota_inode = false;
368
369 if (!check_only &&
370 IS_INODE(page) && is_dent_dnode(page)) {
371 err = f2fs_recover_inode_page(sbi, page);
372 if (err) {
373 f2fs_put_page(page, 1);
374 break;
375 }
376 quota_inode = true;
377 }
378
379 /*
380 * CP | dnode(F) | inode(DF)
381 * For this case, we should not give up now.
382 */
383 entry = add_fsync_inode(sbi, head, ino_of_node(page),
384 quota_inode);
385 if (IS_ERR(entry)) {
386 err = PTR_ERR(entry);
387 if (err == -ENOENT) {
388 err = 0;
389 goto next;
390 }
391 f2fs_put_page(page, 1);
392 break;
393 }
394 }
395 entry->blkaddr = blkaddr;
396
397 if (IS_INODE(page) && is_dent_dnode(page))
398 entry->last_dentry = blkaddr;
399 next:
400 /* sanity check in order to detect looped node chain */
401 if (++loop_cnt >= free_blocks ||
402 blkaddr == next_blkaddr_of_node(page)) {
403 f2fs_notice(sbi, "%s: detect looped node chain, blkaddr:%u, next:%u",
404 __func__, blkaddr,
405 next_blkaddr_of_node(page));
406 f2fs_put_page(page, 1);
407 err = -EINVAL;
408 break;
409 }
410
411 /* check next segment */
412 blkaddr = next_blkaddr_of_node(page);
413 f2fs_put_page(page, 1);
414
415 f2fs_ra_meta_pages_cond(sbi, blkaddr);
416 }
417 return err;
418 }
419
destroy_fsync_dnodes(struct list_head * head,int drop)420 static void destroy_fsync_dnodes(struct list_head *head, int drop)
421 {
422 struct fsync_inode_entry *entry, *tmp;
423
424 list_for_each_entry_safe(entry, tmp, head, list)
425 del_fsync_inode(entry, drop);
426 }
427
check_index_in_prev_nodes(struct f2fs_sb_info * sbi,block_t blkaddr,struct dnode_of_data * dn)428 static int check_index_in_prev_nodes(struct f2fs_sb_info *sbi,
429 block_t blkaddr, struct dnode_of_data *dn)
430 {
431 struct seg_entry *sentry;
432 unsigned int segno = GET_SEGNO(sbi, blkaddr);
433 unsigned short blkoff = GET_BLKOFF_FROM_SEG0(sbi, blkaddr);
434 struct f2fs_summary_block *sum_node;
435 struct f2fs_summary sum;
436 struct page *sum_page, *node_page;
437 struct dnode_of_data tdn = *dn;
438 nid_t ino, nid;
439 struct inode *inode;
440 unsigned int offset, ofs_in_node, max_addrs;
441 block_t bidx;
442 int i;
443
444 sentry = get_seg_entry(sbi, segno);
445 if (!f2fs_test_bit(blkoff, sentry->cur_valid_map))
446 return 0;
447
448 /* Get the previous summary */
449 for (i = CURSEG_HOT_DATA; i <= CURSEG_COLD_DATA; i++) {
450 struct curseg_info *curseg = CURSEG_I(sbi, i);
451 if (curseg->segno == segno) {
452 sum = curseg->sum_blk->entries[blkoff];
453 goto got_it;
454 }
455 }
456
457 sum_page = f2fs_get_sum_page(sbi, segno);
458 if (IS_ERR(sum_page))
459 return PTR_ERR(sum_page);
460 sum_node = (struct f2fs_summary_block *)page_address(sum_page);
461 sum = sum_node->entries[blkoff];
462 f2fs_put_page(sum_page, 1);
463 got_it:
464 /* Use the locked dnode page and inode */
465 nid = le32_to_cpu(sum.nid);
466 ofs_in_node = le16_to_cpu(sum.ofs_in_node);
467
468 max_addrs = ADDRS_PER_PAGE(dn->node_page, dn->inode);
469 if (ofs_in_node >= max_addrs) {
470 f2fs_err(sbi, "Inconsistent ofs_in_node:%u in summary, ino:%lu, nid:%u, max:%u",
471 ofs_in_node, dn->inode->i_ino, nid, max_addrs);
472 return -EFSCORRUPTED;
473 }
474
475 if (dn->inode->i_ino == nid) {
476 tdn.nid = nid;
477 if (!dn->inode_page_locked)
478 lock_page(dn->inode_page);
479 tdn.node_page = dn->inode_page;
480 tdn.ofs_in_node = ofs_in_node;
481 goto truncate_out;
482 } else if (dn->nid == nid) {
483 tdn.ofs_in_node = ofs_in_node;
484 goto truncate_out;
485 }
486
487 /* Get the node page */
488 node_page = f2fs_get_node_page(sbi, nid);
489 if (IS_ERR(node_page))
490 return PTR_ERR(node_page);
491
492 offset = ofs_of_node(node_page);
493 ino = ino_of_node(node_page);
494 f2fs_put_page(node_page, 1);
495
496 if (ino != dn->inode->i_ino) {
497 int ret;
498
499 /* Deallocate previous index in the node page */
500 inode = f2fs_iget_retry(sbi->sb, ino);
501 if (IS_ERR(inode))
502 return PTR_ERR(inode);
503
504 ret = dquot_initialize(inode);
505 if (ret) {
506 iput(inode);
507 return ret;
508 }
509 } else {
510 inode = dn->inode;
511 }
512
513 bidx = f2fs_start_bidx_of_node(offset, inode) +
514 le16_to_cpu(sum.ofs_in_node);
515
516 /*
517 * if inode page is locked, unlock temporarily, but its reference
518 * count keeps alive.
519 */
520 if (ino == dn->inode->i_ino && dn->inode_page_locked)
521 unlock_page(dn->inode_page);
522
523 set_new_dnode(&tdn, inode, NULL, NULL, 0);
524 if (f2fs_get_dnode_of_data(&tdn, bidx, LOOKUP_NODE))
525 goto out;
526
527 if (tdn.data_blkaddr == blkaddr)
528 f2fs_truncate_data_blocks_range(&tdn, 1);
529
530 f2fs_put_dnode(&tdn);
531 out:
532 if (ino != dn->inode->i_ino)
533 iput(inode);
534 else if (dn->inode_page_locked)
535 lock_page(dn->inode_page);
536 return 0;
537
538 truncate_out:
539 if (f2fs_data_blkaddr(&tdn) == blkaddr)
540 f2fs_truncate_data_blocks_range(&tdn, 1);
541 if (dn->inode->i_ino == nid && !dn->inode_page_locked)
542 unlock_page(dn->inode_page);
543 return 0;
544 }
545
do_recover_data(struct f2fs_sb_info * sbi,struct inode * inode,struct page * page)546 static int do_recover_data(struct f2fs_sb_info *sbi, struct inode *inode,
547 struct page *page)
548 {
549 struct dnode_of_data dn;
550 struct node_info ni;
551 unsigned int start, end;
552 int err = 0, recovered = 0;
553
554 /* step 1: recover xattr */
555 if (IS_INODE(page)) {
556 err = f2fs_recover_inline_xattr(inode, page);
557 if (err)
558 goto out;
559 } else if (f2fs_has_xattr_block(ofs_of_node(page))) {
560 err = f2fs_recover_xattr_data(inode, page);
561 if (!err)
562 recovered++;
563 goto out;
564 }
565
566 /* step 2: recover inline data */
567 err = f2fs_recover_inline_data(inode, page);
568 if (err) {
569 if (err == 1)
570 err = 0;
571 goto out;
572 }
573
574 /* step 3: recover data indices */
575 start = f2fs_start_bidx_of_node(ofs_of_node(page), inode);
576 end = start + ADDRS_PER_PAGE(page, inode);
577
578 set_new_dnode(&dn, inode, NULL, NULL, 0);
579 retry_dn:
580 err = f2fs_get_dnode_of_data(&dn, start, ALLOC_NODE);
581 if (err) {
582 if (err == -ENOMEM) {
583 congestion_wait(BLK_RW_ASYNC, DEFAULT_IO_TIMEOUT);
584 goto retry_dn;
585 }
586 goto out;
587 }
588
589 f2fs_wait_on_page_writeback(dn.node_page, NODE, true, true);
590
591 err = f2fs_get_node_info(sbi, dn.nid, &ni);
592 if (err)
593 goto err;
594
595 f2fs_bug_on(sbi, ni.ino != ino_of_node(page));
596
597 if (ofs_of_node(dn.node_page) != ofs_of_node(page)) {
598 f2fs_warn(sbi, "Inconsistent ofs_of_node, ino:%lu, ofs:%u, %u",
599 inode->i_ino, ofs_of_node(dn.node_page),
600 ofs_of_node(page));
601 err = -EFSCORRUPTED;
602 goto err;
603 }
604
605 for (; start < end; start++, dn.ofs_in_node++) {
606 block_t src, dest;
607
608 src = f2fs_data_blkaddr(&dn);
609 dest = data_blkaddr(dn.inode, page, dn.ofs_in_node);
610
611 if (__is_valid_data_blkaddr(src) &&
612 !f2fs_is_valid_blkaddr(sbi, src, META_POR)) {
613 err = -EFSCORRUPTED;
614 goto err;
615 }
616
617 if (__is_valid_data_blkaddr(dest) &&
618 !f2fs_is_valid_blkaddr(sbi, dest, META_POR)) {
619 err = -EFSCORRUPTED;
620 goto err;
621 }
622
623 /* skip recovering if dest is the same as src */
624 if (src == dest)
625 continue;
626
627 /* dest is invalid, just invalidate src block */
628 if (dest == NULL_ADDR) {
629 f2fs_truncate_data_blocks_range(&dn, 1);
630 continue;
631 }
632
633 if (!file_keep_isize(inode) &&
634 (i_size_read(inode) <= ((loff_t)start << PAGE_SHIFT)))
635 f2fs_i_size_write(inode,
636 (loff_t)(start + 1) << PAGE_SHIFT);
637
638 /*
639 * dest is reserved block, invalidate src block
640 * and then reserve one new block in dnode page.
641 */
642 if (dest == NEW_ADDR) {
643 f2fs_truncate_data_blocks_range(&dn, 1);
644 f2fs_reserve_new_block(&dn);
645 continue;
646 }
647
648 /* dest is valid block, try to recover from src to dest */
649 if (f2fs_is_valid_blkaddr(sbi, dest, META_POR)) {
650
651 if (src == NULL_ADDR) {
652 err = f2fs_reserve_new_block(&dn);
653 while (err &&
654 IS_ENABLED(CONFIG_F2FS_FAULT_INJECTION))
655 err = f2fs_reserve_new_block(&dn);
656 /* We should not get -ENOSPC */
657 f2fs_bug_on(sbi, err);
658 if (err)
659 goto err;
660 }
661 retry_prev:
662 /* Check the previous node page having this index */
663 err = check_index_in_prev_nodes(sbi, dest, &dn);
664 if (err) {
665 if (err == -ENOMEM) {
666 congestion_wait(BLK_RW_ASYNC,
667 DEFAULT_IO_TIMEOUT);
668 goto retry_prev;
669 }
670 goto err;
671 }
672
673 if (f2fs_is_valid_blkaddr(sbi, dest,
674 DATA_GENERIC_ENHANCE_UPDATE)) {
675 f2fs_err(sbi, "Inconsistent dest blkaddr:%u, ino:%lu, ofs:%u",
676 dest, inode->i_ino, dn.ofs_in_node);
677 err = -EFSCORRUPTED;
678 goto err;
679 }
680
681 /* write dummy data page */
682 f2fs_replace_block(sbi, &dn, src, dest,
683 ni.version, false, false);
684 recovered++;
685 }
686 }
687
688 copy_node_footer(dn.node_page, page);
689 fill_node_footer(dn.node_page, dn.nid, ni.ino,
690 ofs_of_node(page), false);
691 set_page_dirty(dn.node_page);
692 err:
693 f2fs_put_dnode(&dn);
694 out:
695 f2fs_notice(sbi, "recover_data: ino = %lx (i_size: %s) recovered = %d, err = %d",
696 inode->i_ino, file_keep_isize(inode) ? "keep" : "recover",
697 recovered, err);
698 return err;
699 }
700
recover_data(struct f2fs_sb_info * sbi,struct list_head * inode_list,struct list_head * tmp_inode_list,struct list_head * dir_list)701 static int recover_data(struct f2fs_sb_info *sbi, struct list_head *inode_list,
702 struct list_head *tmp_inode_list, struct list_head *dir_list)
703 {
704 struct curseg_info *curseg;
705 struct page *page = NULL;
706 int err = 0;
707 block_t blkaddr;
708
709 /* get node pages in the current segment */
710 curseg = CURSEG_I(sbi, CURSEG_WARM_NODE);
711 blkaddr = NEXT_FREE_BLKADDR(sbi, curseg);
712
713 while (1) {
714 struct fsync_inode_entry *entry;
715
716 if (!f2fs_is_valid_blkaddr(sbi, blkaddr, META_POR))
717 break;
718
719 f2fs_ra_meta_pages_cond(sbi, blkaddr);
720
721 page = f2fs_get_tmp_page(sbi, blkaddr);
722 if (IS_ERR(page)) {
723 err = PTR_ERR(page);
724 break;
725 }
726
727 if (!is_recoverable_dnode(page)) {
728 f2fs_put_page(page, 1);
729 break;
730 }
731
732 entry = get_fsync_inode(inode_list, ino_of_node(page));
733 if (!entry)
734 goto next;
735 /*
736 * inode(x) | CP | inode(x) | dnode(F)
737 * In this case, we can lose the latest inode(x).
738 * So, call recover_inode for the inode update.
739 */
740 if (IS_INODE(page)) {
741 err = recover_inode(entry->inode, page);
742 if (err) {
743 f2fs_put_page(page, 1);
744 break;
745 }
746 }
747 if (entry->last_dentry == blkaddr) {
748 err = recover_dentry(entry->inode, page, dir_list);
749 if (err) {
750 f2fs_put_page(page, 1);
751 break;
752 }
753 }
754 err = do_recover_data(sbi, entry->inode, page);
755 if (err) {
756 f2fs_put_page(page, 1);
757 break;
758 }
759
760 if (entry->blkaddr == blkaddr)
761 list_move_tail(&entry->list, tmp_inode_list);
762 next:
763 /* check next segment */
764 blkaddr = next_blkaddr_of_node(page);
765 f2fs_put_page(page, 1);
766 }
767 if (!err)
768 f2fs_allocate_new_segments(sbi);
769 return err;
770 }
771
f2fs_recover_fsync_data(struct f2fs_sb_info * sbi,bool check_only)772 int f2fs_recover_fsync_data(struct f2fs_sb_info *sbi, bool check_only)
773 {
774 struct list_head inode_list, tmp_inode_list;
775 struct list_head dir_list;
776 int err;
777 int ret = 0;
778 unsigned long s_flags = sbi->sb->s_flags;
779 bool need_writecp = false;
780 bool fix_curseg_write_pointer = false;
781 #ifdef CONFIG_QUOTA
782 int quota_enabled;
783 #endif
784
785 if (s_flags & SB_RDONLY) {
786 f2fs_info(sbi, "recover fsync data on readonly fs");
787 sbi->sb->s_flags &= ~SB_RDONLY;
788 }
789
790 #ifdef CONFIG_QUOTA
791 /* Needed for iput() to work correctly and not trash data */
792 sbi->sb->s_flags |= SB_ACTIVE;
793 /* Turn on quotas so that they are updated correctly */
794 quota_enabled = f2fs_enable_quota_files(sbi, s_flags & SB_RDONLY);
795 #endif
796
797 INIT_LIST_HEAD(&inode_list);
798 INIT_LIST_HEAD(&tmp_inode_list);
799 INIT_LIST_HEAD(&dir_list);
800
801 /* prevent checkpoint */
802 mutex_lock(&sbi->cp_mutex);
803
804 /* step #1: find fsynced inode numbers */
805 err = find_fsync_dnodes(sbi, &inode_list, check_only);
806 if (err || list_empty(&inode_list))
807 goto skip;
808
809 if (check_only) {
810 ret = 1;
811 goto skip;
812 }
813
814 need_writecp = true;
815
816 /* step #2: recover data */
817 err = recover_data(sbi, &inode_list, &tmp_inode_list, &dir_list);
818 if (!err)
819 f2fs_bug_on(sbi, !list_empty(&inode_list));
820 else {
821 /* restore s_flags to let iput() trash data */
822 sbi->sb->s_flags = s_flags;
823 }
824 skip:
825 fix_curseg_write_pointer = !check_only || list_empty(&inode_list);
826
827 destroy_fsync_dnodes(&inode_list, err);
828 destroy_fsync_dnodes(&tmp_inode_list, err);
829
830 /* truncate meta pages to be used by the recovery */
831 truncate_inode_pages_range(META_MAPPING(sbi),
832 (loff_t)MAIN_BLKADDR(sbi) << PAGE_SHIFT, -1);
833
834 if (err) {
835 truncate_inode_pages_final(NODE_MAPPING(sbi));
836 truncate_inode_pages_final(META_MAPPING(sbi));
837 }
838
839 /*
840 * If fsync data succeeds or there is no fsync data to recover,
841 * and the f2fs is not read only, check and fix zoned block devices'
842 * write pointer consistency.
843 */
844 if (!err && fix_curseg_write_pointer && !f2fs_readonly(sbi->sb) &&
845 f2fs_sb_has_blkzoned(sbi)) {
846 err = f2fs_fix_curseg_write_pointer(sbi);
847 ret = err;
848 }
849
850 if (!err)
851 clear_sbi_flag(sbi, SBI_POR_DOING);
852
853 mutex_unlock(&sbi->cp_mutex);
854
855 /* let's drop all the directory inodes for clean checkpoint */
856 destroy_fsync_dnodes(&dir_list, err);
857
858 if (need_writecp) {
859 set_sbi_flag(sbi, SBI_IS_RECOVERED);
860
861 if (!err) {
862 struct cp_control cpc = {
863 .reason = CP_RECOVERY,
864 };
865 err = f2fs_write_checkpoint(sbi, &cpc);
866 }
867 }
868
869 #ifdef CONFIG_QUOTA
870 /* Turn quotas off */
871 if (quota_enabled)
872 f2fs_quota_off_umount(sbi->sb);
873 #endif
874 sbi->sb->s_flags = s_flags; /* Restore SB_RDONLY status */
875
876 return ret ? ret: err;
877 }
878
f2fs_create_recovery_cache(void)879 int __init f2fs_create_recovery_cache(void)
880 {
881 fsync_entry_slab = f2fs_kmem_cache_create("f2fs_fsync_inode_entry",
882 sizeof(struct fsync_inode_entry));
883 if (!fsync_entry_slab)
884 return -ENOMEM;
885 return 0;
886 }
887
f2fs_destroy_recovery_cache(void)888 void f2fs_destroy_recovery_cache(void)
889 {
890 kmem_cache_destroy(fsync_entry_slab);
891 }
892