fs/f2fs/recovery.c

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