Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * fs/f2fs/recovery.c
0004  *
0005  * Copyright (c) 2012 Samsung Electronics Co., Ltd.
0006  *             http://www.samsung.com/
0007  */
0008 #include <asm/unaligned.h>
0009 #include <linux/fs.h>
0010 #include <linux/f2fs_fs.h>
0011 #include <linux/sched/mm.h>
0012 #include "f2fs.h"
0013 #include "node.h"
0014 #include "segment.h"
0015 
0016 /*
0017  * Roll forward recovery scenarios.
0018  *
0019  * [Term] F: fsync_mark, D: dentry_mark
0020  *
0021  * 1. inode(x) | CP | inode(x) | dnode(F)
0022  * -> Update the latest inode(x).
0023  *
0024  * 2. inode(x) | CP | inode(F) | dnode(F)
0025  * -> No problem.
0026  *
0027  * 3. inode(x) | CP | dnode(F) | inode(x)
0028  * -> Recover to the latest dnode(F), and drop the last inode(x)
0029  *
0030  * 4. inode(x) | CP | dnode(F) | inode(F)
0031  * -> No problem.
0032  *
0033  * 5. CP | inode(x) | dnode(F)
0034  * -> The inode(DF) was missing. Should drop this dnode(F).
0035  *
0036  * 6. CP | inode(DF) | dnode(F)
0037  * -> No problem.
0038  *
0039  * 7. CP | dnode(F) | inode(DF)
0040  * -> If f2fs_iget fails, then goto next to find inode(DF).
0041  *
0042  * 8. CP | dnode(F) | inode(x)
0043  * -> If f2fs_iget fails, then goto next to find inode(DF).
0044  *    But it will fail due to no inode(DF).
0045  */
0046 
0047 static struct kmem_cache *fsync_entry_slab;
0048 
0049 #if IS_ENABLED(CONFIG_UNICODE)
0050 extern struct kmem_cache *f2fs_cf_name_slab;
0051 #endif
0052 
0053 bool f2fs_space_for_roll_forward(struct f2fs_sb_info *sbi)
0054 {
0055     s64 nalloc = percpu_counter_sum_positive(&sbi->alloc_valid_block_count);
0056 
0057     if (sbi->last_valid_block_count + nalloc > sbi->user_block_count)
0058         return false;
0059     if (NM_I(sbi)->max_rf_node_blocks &&
0060         percpu_counter_sum_positive(&sbi->rf_node_block_count) >=
0061                         NM_I(sbi)->max_rf_node_blocks)
0062         return false;
0063     return true;
0064 }
0065 
0066 static struct fsync_inode_entry *get_fsync_inode(struct list_head *head,
0067                                 nid_t ino)
0068 {
0069     struct fsync_inode_entry *entry;
0070 
0071     list_for_each_entry(entry, head, list)
0072         if (entry->inode->i_ino == ino)
0073             return entry;
0074 
0075     return NULL;
0076 }
0077 
0078 static struct fsync_inode_entry *add_fsync_inode(struct f2fs_sb_info *sbi,
0079             struct list_head *head, nid_t ino, bool quota_inode)
0080 {
0081     struct inode *inode;
0082     struct fsync_inode_entry *entry;
0083     int err;
0084 
0085     inode = f2fs_iget_retry(sbi->sb, ino);
0086     if (IS_ERR(inode))
0087         return ERR_CAST(inode);
0088 
0089     err = f2fs_dquot_initialize(inode);
0090     if (err)
0091         goto err_out;
0092 
0093     if (quota_inode) {
0094         err = dquot_alloc_inode(inode);
0095         if (err)
0096             goto err_out;
0097     }
0098 
0099     entry = f2fs_kmem_cache_alloc(fsync_entry_slab,
0100                     GFP_F2FS_ZERO, true, NULL);
0101     entry->inode = inode;
0102     list_add_tail(&entry->list, head);
0103 
0104     return entry;
0105 err_out:
0106     iput(inode);
0107     return ERR_PTR(err);
0108 }
0109 
0110 static void del_fsync_inode(struct fsync_inode_entry *entry, int drop)
0111 {
0112     if (drop) {
0113         /* inode should not be recovered, drop it */
0114         f2fs_inode_synced(entry->inode);
0115     }
0116     iput(entry->inode);
0117     list_del(&entry->list);
0118     kmem_cache_free(fsync_entry_slab, entry);
0119 }
0120 
0121 static int init_recovered_filename(const struct inode *dir,
0122                    struct f2fs_inode *raw_inode,
0123                    struct f2fs_filename *fname,
0124                    struct qstr *usr_fname)
0125 {
0126     int err;
0127 
0128     memset(fname, 0, sizeof(*fname));
0129     fname->disk_name.len = le32_to_cpu(raw_inode->i_namelen);
0130     fname->disk_name.name = raw_inode->i_name;
0131 
0132     if (WARN_ON(fname->disk_name.len > F2FS_NAME_LEN))
0133         return -ENAMETOOLONG;
0134 
0135     if (!IS_ENCRYPTED(dir)) {
0136         usr_fname->name = fname->disk_name.name;
0137         usr_fname->len = fname->disk_name.len;
0138         fname->usr_fname = usr_fname;
0139     }
0140 
0141     /* Compute the hash of the filename */
0142     if (IS_ENCRYPTED(dir) && IS_CASEFOLDED(dir)) {
0143         /*
0144          * In this case the hash isn't computable without the key, so it
0145          * was saved on-disk.
0146          */
0147         if (fname->disk_name.len + sizeof(f2fs_hash_t) > F2FS_NAME_LEN)
0148             return -EINVAL;
0149         fname->hash = get_unaligned((f2fs_hash_t *)
0150                 &raw_inode->i_name[fname->disk_name.len]);
0151     } else if (IS_CASEFOLDED(dir)) {
0152         err = f2fs_init_casefolded_name(dir, fname);
0153         if (err)
0154             return err;
0155         f2fs_hash_filename(dir, fname);
0156 #if IS_ENABLED(CONFIG_UNICODE)
0157         /* Case-sensitive match is fine for recovery */
0158         kmem_cache_free(f2fs_cf_name_slab, fname->cf_name.name);
0159         fname->cf_name.name = NULL;
0160 #endif
0161     } else {
0162         f2fs_hash_filename(dir, fname);
0163     }
0164     return 0;
0165 }
0166 
0167 static int recover_dentry(struct inode *inode, struct page *ipage,
0168                         struct list_head *dir_list)
0169 {
0170     struct f2fs_inode *raw_inode = F2FS_INODE(ipage);
0171     nid_t pino = le32_to_cpu(raw_inode->i_pino);
0172     struct f2fs_dir_entry *de;
0173     struct f2fs_filename fname;
0174     struct qstr usr_fname;
0175     struct page *page;
0176     struct inode *dir, *einode;
0177     struct fsync_inode_entry *entry;
0178     int err = 0;
0179     char *name;
0180 
0181     entry = get_fsync_inode(dir_list, pino);
0182     if (!entry) {
0183         entry = add_fsync_inode(F2FS_I_SB(inode), dir_list,
0184                             pino, false);
0185         if (IS_ERR(entry)) {
0186             dir = ERR_CAST(entry);
0187             err = PTR_ERR(entry);
0188             goto out;
0189         }
0190     }
0191 
0192     dir = entry->inode;
0193     err = init_recovered_filename(dir, raw_inode, &fname, &usr_fname);
0194     if (err)
0195         goto out;
0196 retry:
0197     de = __f2fs_find_entry(dir, &fname, &page);
0198     if (de && inode->i_ino == le32_to_cpu(de->ino))
0199         goto out_put;
0200 
0201     if (de) {
0202         einode = f2fs_iget_retry(inode->i_sb, le32_to_cpu(de->ino));
0203         if (IS_ERR(einode)) {
0204             WARN_ON(1);
0205             err = PTR_ERR(einode);
0206             if (err == -ENOENT)
0207                 err = -EEXIST;
0208             goto out_put;
0209         }
0210 
0211         err = f2fs_dquot_initialize(einode);
0212         if (err) {
0213             iput(einode);
0214             goto out_put;
0215         }
0216 
0217         err = f2fs_acquire_orphan_inode(F2FS_I_SB(inode));
0218         if (err) {
0219             iput(einode);
0220             goto out_put;
0221         }
0222         f2fs_delete_entry(de, page, dir, einode);
0223         iput(einode);
0224         goto retry;
0225     } else if (IS_ERR(page)) {
0226         err = PTR_ERR(page);
0227     } else {
0228         err = f2fs_add_dentry(dir, &fname, inode,
0229                     inode->i_ino, inode->i_mode);
0230     }
0231     if (err == -ENOMEM)
0232         goto retry;
0233     goto out;
0234 
0235 out_put:
0236     f2fs_put_page(page, 0);
0237 out:
0238     if (file_enc_name(inode))
0239         name = "<encrypted>";
0240     else
0241         name = raw_inode->i_name;
0242     f2fs_notice(F2FS_I_SB(inode), "%s: ino = %x, name = %s, dir = %lx, err = %d",
0243             __func__, ino_of_node(ipage), name,
0244             IS_ERR(dir) ? 0 : dir->i_ino, err);
0245     return err;
0246 }
0247 
0248 static int recover_quota_data(struct inode *inode, struct page *page)
0249 {
0250     struct f2fs_inode *raw = F2FS_INODE(page);
0251     struct iattr attr;
0252     uid_t i_uid = le32_to_cpu(raw->i_uid);
0253     gid_t i_gid = le32_to_cpu(raw->i_gid);
0254     int err;
0255 
0256     memset(&attr, 0, sizeof(attr));
0257 
0258     attr.ia_vfsuid = VFSUIDT_INIT(make_kuid(inode->i_sb->s_user_ns, i_uid));
0259     attr.ia_vfsgid = VFSGIDT_INIT(make_kgid(inode->i_sb->s_user_ns, i_gid));
0260 
0261     if (!vfsuid_eq(attr.ia_vfsuid, i_uid_into_vfsuid(&init_user_ns, inode)))
0262         attr.ia_valid |= ATTR_UID;
0263     if (!vfsgid_eq(attr.ia_vfsgid, i_gid_into_vfsgid(&init_user_ns, inode)))
0264         attr.ia_valid |= ATTR_GID;
0265 
0266     if (!attr.ia_valid)
0267         return 0;
0268 
0269     err = dquot_transfer(&init_user_ns, inode, &attr);
0270     if (err)
0271         set_sbi_flag(F2FS_I_SB(inode), SBI_QUOTA_NEED_REPAIR);
0272     return err;
0273 }
0274 
0275 static void recover_inline_flags(struct inode *inode, struct f2fs_inode *ri)
0276 {
0277     if (ri->i_inline & F2FS_PIN_FILE)
0278         set_inode_flag(inode, FI_PIN_FILE);
0279     else
0280         clear_inode_flag(inode, FI_PIN_FILE);
0281     if (ri->i_inline & F2FS_DATA_EXIST)
0282         set_inode_flag(inode, FI_DATA_EXIST);
0283     else
0284         clear_inode_flag(inode, FI_DATA_EXIST);
0285 }
0286 
0287 static int recover_inode(struct inode *inode, struct page *page)
0288 {
0289     struct f2fs_inode *raw = F2FS_INODE(page);
0290     char *name;
0291     int err;
0292 
0293     inode->i_mode = le16_to_cpu(raw->i_mode);
0294 
0295     err = recover_quota_data(inode, page);
0296     if (err)
0297         return err;
0298 
0299     i_uid_write(inode, le32_to_cpu(raw->i_uid));
0300     i_gid_write(inode, le32_to_cpu(raw->i_gid));
0301 
0302     if (raw->i_inline & F2FS_EXTRA_ATTR) {
0303         if (f2fs_sb_has_project_quota(F2FS_I_SB(inode)) &&
0304             F2FS_FITS_IN_INODE(raw, le16_to_cpu(raw->i_extra_isize),
0305                                 i_projid)) {
0306             projid_t i_projid;
0307             kprojid_t kprojid;
0308 
0309             i_projid = (projid_t)le32_to_cpu(raw->i_projid);
0310             kprojid = make_kprojid(&init_user_ns, i_projid);
0311 
0312             if (!projid_eq(kprojid, F2FS_I(inode)->i_projid)) {
0313                 err = f2fs_transfer_project_quota(inode,
0314                                 kprojid);
0315                 if (err)
0316                     return err;
0317                 F2FS_I(inode)->i_projid = kprojid;
0318             }
0319         }
0320     }
0321 
0322     f2fs_i_size_write(inode, le64_to_cpu(raw->i_size));
0323     inode->i_atime.tv_sec = le64_to_cpu(raw->i_atime);
0324     inode->i_ctime.tv_sec = le64_to_cpu(raw->i_ctime);
0325     inode->i_mtime.tv_sec = le64_to_cpu(raw->i_mtime);
0326     inode->i_atime.tv_nsec = le32_to_cpu(raw->i_atime_nsec);
0327     inode->i_ctime.tv_nsec = le32_to_cpu(raw->i_ctime_nsec);
0328     inode->i_mtime.tv_nsec = le32_to_cpu(raw->i_mtime_nsec);
0329 
0330     F2FS_I(inode)->i_advise = raw->i_advise;
0331     F2FS_I(inode)->i_flags = le32_to_cpu(raw->i_flags);
0332     f2fs_set_inode_flags(inode);
0333     F2FS_I(inode)->i_gc_failures[GC_FAILURE_PIN] =
0334                 le16_to_cpu(raw->i_gc_failures);
0335 
0336     recover_inline_flags(inode, raw);
0337 
0338     f2fs_mark_inode_dirty_sync(inode, true);
0339 
0340     if (file_enc_name(inode))
0341         name = "<encrypted>";
0342     else
0343         name = F2FS_INODE(page)->i_name;
0344 
0345     f2fs_notice(F2FS_I_SB(inode), "recover_inode: ino = %x, name = %s, inline = %x",
0346             ino_of_node(page), name, raw->i_inline);
0347     return 0;
0348 }
0349 
0350 static unsigned int adjust_por_ra_blocks(struct f2fs_sb_info *sbi,
0351                 unsigned int ra_blocks, unsigned int blkaddr,
0352                 unsigned int next_blkaddr)
0353 {
0354     if (blkaddr + 1 == next_blkaddr)
0355         ra_blocks = min_t(unsigned int, RECOVERY_MAX_RA_BLOCKS,
0356                             ra_blocks * 2);
0357     else if (next_blkaddr % sbi->blocks_per_seg)
0358         ra_blocks = max_t(unsigned int, RECOVERY_MIN_RA_BLOCKS,
0359                             ra_blocks / 2);
0360     return ra_blocks;
0361 }
0362 
0363 static int find_fsync_dnodes(struct f2fs_sb_info *sbi, struct list_head *head,
0364                 bool check_only)
0365 {
0366     struct curseg_info *curseg;
0367     struct page *page = NULL;
0368     block_t blkaddr;
0369     unsigned int loop_cnt = 0;
0370     unsigned int ra_blocks = RECOVERY_MAX_RA_BLOCKS;
0371     unsigned int free_blocks = MAIN_SEGS(sbi) * sbi->blocks_per_seg -
0372                         valid_user_blocks(sbi);
0373     int err = 0;
0374 
0375     /* get node pages in the current segment */
0376     curseg = CURSEG_I(sbi, CURSEG_WARM_NODE);
0377     blkaddr = NEXT_FREE_BLKADDR(sbi, curseg);
0378 
0379     while (1) {
0380         struct fsync_inode_entry *entry;
0381 
0382         if (!f2fs_is_valid_blkaddr(sbi, blkaddr, META_POR))
0383             return 0;
0384 
0385         page = f2fs_get_tmp_page(sbi, blkaddr);
0386         if (IS_ERR(page)) {
0387             err = PTR_ERR(page);
0388             break;
0389         }
0390 
0391         if (!is_recoverable_dnode(page)) {
0392             f2fs_put_page(page, 1);
0393             break;
0394         }
0395 
0396         if (!is_fsync_dnode(page))
0397             goto next;
0398 
0399         entry = get_fsync_inode(head, ino_of_node(page));
0400         if (!entry) {
0401             bool quota_inode = false;
0402 
0403             if (!check_only &&
0404                     IS_INODE(page) && is_dent_dnode(page)) {
0405                 err = f2fs_recover_inode_page(sbi, page);
0406                 if (err) {
0407                     f2fs_put_page(page, 1);
0408                     break;
0409                 }
0410                 quota_inode = true;
0411             }
0412 
0413             /*
0414              * CP | dnode(F) | inode(DF)
0415              * For this case, we should not give up now.
0416              */
0417             entry = add_fsync_inode(sbi, head, ino_of_node(page),
0418                                 quota_inode);
0419             if (IS_ERR(entry)) {
0420                 err = PTR_ERR(entry);
0421                 if (err == -ENOENT) {
0422                     err = 0;
0423                     goto next;
0424                 }
0425                 f2fs_put_page(page, 1);
0426                 break;
0427             }
0428         }
0429         entry->blkaddr = blkaddr;
0430 
0431         if (IS_INODE(page) && is_dent_dnode(page))
0432             entry->last_dentry = blkaddr;
0433 next:
0434         /* sanity check in order to detect looped node chain */
0435         if (++loop_cnt >= free_blocks ||
0436             blkaddr == next_blkaddr_of_node(page)) {
0437             f2fs_notice(sbi, "%s: detect looped node chain, blkaddr:%u, next:%u",
0438                     __func__, blkaddr,
0439                     next_blkaddr_of_node(page));
0440             f2fs_put_page(page, 1);
0441             err = -EINVAL;
0442             break;
0443         }
0444 
0445         ra_blocks = adjust_por_ra_blocks(sbi, ra_blocks, blkaddr,
0446                         next_blkaddr_of_node(page));
0447 
0448         /* check next segment */
0449         blkaddr = next_blkaddr_of_node(page);
0450         f2fs_put_page(page, 1);
0451 
0452         f2fs_ra_meta_pages_cond(sbi, blkaddr, ra_blocks);
0453     }
0454     return err;
0455 }
0456 
0457 static void destroy_fsync_dnodes(struct list_head *head, int drop)
0458 {
0459     struct fsync_inode_entry *entry, *tmp;
0460 
0461     list_for_each_entry_safe(entry, tmp, head, list)
0462         del_fsync_inode(entry, drop);
0463 }
0464 
0465 static int check_index_in_prev_nodes(struct f2fs_sb_info *sbi,
0466             block_t blkaddr, struct dnode_of_data *dn)
0467 {
0468     struct seg_entry *sentry;
0469     unsigned int segno = GET_SEGNO(sbi, blkaddr);
0470     unsigned short blkoff = GET_BLKOFF_FROM_SEG0(sbi, blkaddr);
0471     struct f2fs_summary_block *sum_node;
0472     struct f2fs_summary sum;
0473     struct page *sum_page, *node_page;
0474     struct dnode_of_data tdn = *dn;
0475     nid_t ino, nid;
0476     struct inode *inode;
0477     unsigned int offset;
0478     block_t bidx;
0479     int i;
0480 
0481     sentry = get_seg_entry(sbi, segno);
0482     if (!f2fs_test_bit(blkoff, sentry->cur_valid_map))
0483         return 0;
0484 
0485     /* Get the previous summary */
0486     for (i = CURSEG_HOT_DATA; i <= CURSEG_COLD_DATA; i++) {
0487         struct curseg_info *curseg = CURSEG_I(sbi, i);
0488 
0489         if (curseg->segno == segno) {
0490             sum = curseg->sum_blk->entries[blkoff];
0491             goto got_it;
0492         }
0493     }
0494 
0495     sum_page = f2fs_get_sum_page(sbi, segno);
0496     if (IS_ERR(sum_page))
0497         return PTR_ERR(sum_page);
0498     sum_node = (struct f2fs_summary_block *)page_address(sum_page);
0499     sum = sum_node->entries[blkoff];
0500     f2fs_put_page(sum_page, 1);
0501 got_it:
0502     /* Use the locked dnode page and inode */
0503     nid = le32_to_cpu(sum.nid);
0504     if (dn->inode->i_ino == nid) {
0505         tdn.nid = nid;
0506         if (!dn->inode_page_locked)
0507             lock_page(dn->inode_page);
0508         tdn.node_page = dn->inode_page;
0509         tdn.ofs_in_node = le16_to_cpu(sum.ofs_in_node);
0510         goto truncate_out;
0511     } else if (dn->nid == nid) {
0512         tdn.ofs_in_node = le16_to_cpu(sum.ofs_in_node);
0513         goto truncate_out;
0514     }
0515 
0516     /* Get the node page */
0517     node_page = f2fs_get_node_page(sbi, nid);
0518     if (IS_ERR(node_page))
0519         return PTR_ERR(node_page);
0520 
0521     offset = ofs_of_node(node_page);
0522     ino = ino_of_node(node_page);
0523     f2fs_put_page(node_page, 1);
0524 
0525     if (ino != dn->inode->i_ino) {
0526         int ret;
0527 
0528         /* Deallocate previous index in the node page */
0529         inode = f2fs_iget_retry(sbi->sb, ino);
0530         if (IS_ERR(inode))
0531             return PTR_ERR(inode);
0532 
0533         ret = f2fs_dquot_initialize(inode);
0534         if (ret) {
0535             iput(inode);
0536             return ret;
0537         }
0538     } else {
0539         inode = dn->inode;
0540     }
0541 
0542     bidx = f2fs_start_bidx_of_node(offset, inode) +
0543                 le16_to_cpu(sum.ofs_in_node);
0544 
0545     /*
0546      * if inode page is locked, unlock temporarily, but its reference
0547      * count keeps alive.
0548      */
0549     if (ino == dn->inode->i_ino && dn->inode_page_locked)
0550         unlock_page(dn->inode_page);
0551 
0552     set_new_dnode(&tdn, inode, NULL, NULL, 0);
0553     if (f2fs_get_dnode_of_data(&tdn, bidx, LOOKUP_NODE))
0554         goto out;
0555 
0556     if (tdn.data_blkaddr == blkaddr)
0557         f2fs_truncate_data_blocks_range(&tdn, 1);
0558 
0559     f2fs_put_dnode(&tdn);
0560 out:
0561     if (ino != dn->inode->i_ino)
0562         iput(inode);
0563     else if (dn->inode_page_locked)
0564         lock_page(dn->inode_page);
0565     return 0;
0566 
0567 truncate_out:
0568     if (f2fs_data_blkaddr(&tdn) == blkaddr)
0569         f2fs_truncate_data_blocks_range(&tdn, 1);
0570     if (dn->inode->i_ino == nid && !dn->inode_page_locked)
0571         unlock_page(dn->inode_page);
0572     return 0;
0573 }
0574 
0575 static int do_recover_data(struct f2fs_sb_info *sbi, struct inode *inode,
0576                     struct page *page)
0577 {
0578     struct dnode_of_data dn;
0579     struct node_info ni;
0580     unsigned int start, end;
0581     int err = 0, recovered = 0;
0582 
0583     /* step 1: recover xattr */
0584     if (IS_INODE(page)) {
0585         err = f2fs_recover_inline_xattr(inode, page);
0586         if (err)
0587             goto out;
0588     } else if (f2fs_has_xattr_block(ofs_of_node(page))) {
0589         err = f2fs_recover_xattr_data(inode, page);
0590         if (!err)
0591             recovered++;
0592         goto out;
0593     }
0594 
0595     /* step 2: recover inline data */
0596     err = f2fs_recover_inline_data(inode, page);
0597     if (err) {
0598         if (err == 1)
0599             err = 0;
0600         goto out;
0601     }
0602 
0603     /* step 3: recover data indices */
0604     start = f2fs_start_bidx_of_node(ofs_of_node(page), inode);
0605     end = start + ADDRS_PER_PAGE(page, inode);
0606 
0607     set_new_dnode(&dn, inode, NULL, NULL, 0);
0608 retry_dn:
0609     err = f2fs_get_dnode_of_data(&dn, start, ALLOC_NODE);
0610     if (err) {
0611         if (err == -ENOMEM) {
0612             memalloc_retry_wait(GFP_NOFS);
0613             goto retry_dn;
0614         }
0615         goto out;
0616     }
0617 
0618     f2fs_wait_on_page_writeback(dn.node_page, NODE, true, true);
0619 
0620     err = f2fs_get_node_info(sbi, dn.nid, &ni, false);
0621     if (err)
0622         goto err;
0623 
0624     f2fs_bug_on(sbi, ni.ino != ino_of_node(page));
0625 
0626     if (ofs_of_node(dn.node_page) != ofs_of_node(page)) {
0627         f2fs_warn(sbi, "Inconsistent ofs_of_node, ino:%lu, ofs:%u, %u",
0628               inode->i_ino, ofs_of_node(dn.node_page),
0629               ofs_of_node(page));
0630         err = -EFSCORRUPTED;
0631         goto err;
0632     }
0633 
0634     for (; start < end; start++, dn.ofs_in_node++) {
0635         block_t src, dest;
0636 
0637         src = f2fs_data_blkaddr(&dn);
0638         dest = data_blkaddr(dn.inode, page, dn.ofs_in_node);
0639 
0640         if (__is_valid_data_blkaddr(src) &&
0641             !f2fs_is_valid_blkaddr(sbi, src, META_POR)) {
0642             err = -EFSCORRUPTED;
0643             goto err;
0644         }
0645 
0646         if (__is_valid_data_blkaddr(dest) &&
0647             !f2fs_is_valid_blkaddr(sbi, dest, META_POR)) {
0648             err = -EFSCORRUPTED;
0649             goto err;
0650         }
0651 
0652         /* skip recovering if dest is the same as src */
0653         if (src == dest)
0654             continue;
0655 
0656         /* dest is invalid, just invalidate src block */
0657         if (dest == NULL_ADDR) {
0658             f2fs_truncate_data_blocks_range(&dn, 1);
0659             continue;
0660         }
0661 
0662         if (!file_keep_isize(inode) &&
0663             (i_size_read(inode) <= ((loff_t)start << PAGE_SHIFT)))
0664             f2fs_i_size_write(inode,
0665                 (loff_t)(start + 1) << PAGE_SHIFT);
0666 
0667         /*
0668          * dest is reserved block, invalidate src block
0669          * and then reserve one new block in dnode page.
0670          */
0671         if (dest == NEW_ADDR) {
0672             f2fs_truncate_data_blocks_range(&dn, 1);
0673             f2fs_reserve_new_block(&dn);
0674             continue;
0675         }
0676 
0677         /* dest is valid block, try to recover from src to dest */
0678         if (f2fs_is_valid_blkaddr(sbi, dest, META_POR)) {
0679 
0680             if (src == NULL_ADDR) {
0681                 err = f2fs_reserve_new_block(&dn);
0682                 while (err &&
0683                        IS_ENABLED(CONFIG_F2FS_FAULT_INJECTION))
0684                     err = f2fs_reserve_new_block(&dn);
0685                 /* We should not get -ENOSPC */
0686                 f2fs_bug_on(sbi, err);
0687                 if (err)
0688                     goto err;
0689             }
0690 retry_prev:
0691             /* Check the previous node page having this index */
0692             err = check_index_in_prev_nodes(sbi, dest, &dn);
0693             if (err) {
0694                 if (err == -ENOMEM) {
0695                     memalloc_retry_wait(GFP_NOFS);
0696                     goto retry_prev;
0697                 }
0698                 goto err;
0699             }
0700 
0701             /* write dummy data page */
0702             f2fs_replace_block(sbi, &dn, src, dest,
0703                         ni.version, false, false);
0704             recovered++;
0705         }
0706     }
0707 
0708     copy_node_footer(dn.node_page, page);
0709     fill_node_footer(dn.node_page, dn.nid, ni.ino,
0710                     ofs_of_node(page), false);
0711     set_page_dirty(dn.node_page);
0712 err:
0713     f2fs_put_dnode(&dn);
0714 out:
0715     f2fs_notice(sbi, "recover_data: ino = %lx (i_size: %s) recovered = %d, err = %d",
0716             inode->i_ino, file_keep_isize(inode) ? "keep" : "recover",
0717             recovered, err);
0718     return err;
0719 }
0720 
0721 static int recover_data(struct f2fs_sb_info *sbi, struct list_head *inode_list,
0722         struct list_head *tmp_inode_list, struct list_head *dir_list)
0723 {
0724     struct curseg_info *curseg;
0725     struct page *page = NULL;
0726     int err = 0;
0727     block_t blkaddr;
0728     unsigned int ra_blocks = RECOVERY_MAX_RA_BLOCKS;
0729 
0730     /* get node pages in the current segment */
0731     curseg = CURSEG_I(sbi, CURSEG_WARM_NODE);
0732     blkaddr = NEXT_FREE_BLKADDR(sbi, curseg);
0733 
0734     while (1) {
0735         struct fsync_inode_entry *entry;
0736 
0737         if (!f2fs_is_valid_blkaddr(sbi, blkaddr, META_POR))
0738             break;
0739 
0740         page = f2fs_get_tmp_page(sbi, blkaddr);
0741         if (IS_ERR(page)) {
0742             err = PTR_ERR(page);
0743             break;
0744         }
0745 
0746         if (!is_recoverable_dnode(page)) {
0747             f2fs_put_page(page, 1);
0748             break;
0749         }
0750 
0751         entry = get_fsync_inode(inode_list, ino_of_node(page));
0752         if (!entry)
0753             goto next;
0754         /*
0755          * inode(x) | CP | inode(x) | dnode(F)
0756          * In this case, we can lose the latest inode(x).
0757          * So, call recover_inode for the inode update.
0758          */
0759         if (IS_INODE(page)) {
0760             err = recover_inode(entry->inode, page);
0761             if (err) {
0762                 f2fs_put_page(page, 1);
0763                 break;
0764             }
0765         }
0766         if (entry->last_dentry == blkaddr) {
0767             err = recover_dentry(entry->inode, page, dir_list);
0768             if (err) {
0769                 f2fs_put_page(page, 1);
0770                 break;
0771             }
0772         }
0773         err = do_recover_data(sbi, entry->inode, page);
0774         if (err) {
0775             f2fs_put_page(page, 1);
0776             break;
0777         }
0778 
0779         if (entry->blkaddr == blkaddr)
0780             list_move_tail(&entry->list, tmp_inode_list);
0781 next:
0782         ra_blocks = adjust_por_ra_blocks(sbi, ra_blocks, blkaddr,
0783                         next_blkaddr_of_node(page));
0784 
0785         /* check next segment */
0786         blkaddr = next_blkaddr_of_node(page);
0787         f2fs_put_page(page, 1);
0788 
0789         f2fs_ra_meta_pages_cond(sbi, blkaddr, ra_blocks);
0790     }
0791     if (!err)
0792         f2fs_allocate_new_segments(sbi);
0793     return err;
0794 }
0795 
0796 int f2fs_recover_fsync_data(struct f2fs_sb_info *sbi, bool check_only)
0797 {
0798     struct list_head inode_list, tmp_inode_list;
0799     struct list_head dir_list;
0800     int err;
0801     int ret = 0;
0802     unsigned long s_flags = sbi->sb->s_flags;
0803     bool need_writecp = false;
0804     bool fix_curseg_write_pointer = false;
0805 #ifdef CONFIG_QUOTA
0806     int quota_enabled;
0807 #endif
0808 
0809     if (s_flags & SB_RDONLY) {
0810         f2fs_info(sbi, "recover fsync data on readonly fs");
0811         sbi->sb->s_flags &= ~SB_RDONLY;
0812     }
0813 
0814 #ifdef CONFIG_QUOTA
0815     /* Turn on quotas so that they are updated correctly */
0816     quota_enabled = f2fs_enable_quota_files(sbi, s_flags & SB_RDONLY);
0817 #endif
0818 
0819     INIT_LIST_HEAD(&inode_list);
0820     INIT_LIST_HEAD(&tmp_inode_list);
0821     INIT_LIST_HEAD(&dir_list);
0822 
0823     /* prevent checkpoint */
0824     f2fs_down_write(&sbi->cp_global_sem);
0825 
0826     /* step #1: find fsynced inode numbers */
0827     err = find_fsync_dnodes(sbi, &inode_list, check_only);
0828     if (err || list_empty(&inode_list))
0829         goto skip;
0830 
0831     if (check_only) {
0832         ret = 1;
0833         goto skip;
0834     }
0835 
0836     need_writecp = true;
0837 
0838     /* step #2: recover data */
0839     err = recover_data(sbi, &inode_list, &tmp_inode_list, &dir_list);
0840     if (!err)
0841         f2fs_bug_on(sbi, !list_empty(&inode_list));
0842     else
0843         f2fs_bug_on(sbi, sbi->sb->s_flags & SB_ACTIVE);
0844 skip:
0845     fix_curseg_write_pointer = !check_only || list_empty(&inode_list);
0846 
0847     destroy_fsync_dnodes(&inode_list, err);
0848     destroy_fsync_dnodes(&tmp_inode_list, err);
0849 
0850     /* truncate meta pages to be used by the recovery */
0851     truncate_inode_pages_range(META_MAPPING(sbi),
0852             (loff_t)MAIN_BLKADDR(sbi) << PAGE_SHIFT, -1);
0853 
0854     if (err) {
0855         truncate_inode_pages_final(NODE_MAPPING(sbi));
0856         truncate_inode_pages_final(META_MAPPING(sbi));
0857     }
0858 
0859     /*
0860      * If fsync data succeeds or there is no fsync data to recover,
0861      * and the f2fs is not read only, check and fix zoned block devices'
0862      * write pointer consistency.
0863      */
0864     if (!err && fix_curseg_write_pointer && !f2fs_readonly(sbi->sb) &&
0865             f2fs_sb_has_blkzoned(sbi)) {
0866         err = f2fs_fix_curseg_write_pointer(sbi);
0867         ret = err;
0868     }
0869 
0870     if (!err)
0871         clear_sbi_flag(sbi, SBI_POR_DOING);
0872 
0873     f2fs_up_write(&sbi->cp_global_sem);
0874 
0875     /* let's drop all the directory inodes for clean checkpoint */
0876     destroy_fsync_dnodes(&dir_list, err);
0877 
0878     if (need_writecp) {
0879         set_sbi_flag(sbi, SBI_IS_RECOVERED);
0880 
0881         if (!err) {
0882             struct cp_control cpc = {
0883                 .reason = CP_RECOVERY,
0884             };
0885             err = f2fs_write_checkpoint(sbi, &cpc);
0886         }
0887     }
0888 
0889 #ifdef CONFIG_QUOTA
0890     /* Turn quotas off */
0891     if (quota_enabled)
0892         f2fs_quota_off_umount(sbi->sb);
0893 #endif
0894     sbi->sb->s_flags = s_flags; /* Restore SB_RDONLY status */
0895 
0896     return ret ? ret : err;
0897 }
0898 
0899 int __init f2fs_create_recovery_cache(void)
0900 {
0901     fsync_entry_slab = f2fs_kmem_cache_create("f2fs_fsync_inode_entry",
0902                     sizeof(struct fsync_inode_entry));
0903     if (!fsync_entry_slab)
0904         return -ENOMEM;
0905     return 0;
0906 }
0907 
0908 void f2fs_destroy_recovery_cache(void)
0909 {
0910     kmem_cache_destroy(fsync_entry_slab);
0911 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!