LCOV - code coverage report
Current view: top level - fs/f2fs - inode.c (source / functions) Hit Total Coverage
Test: gcov_data_raspi2_real_modules_combined.info Lines: 0 395 0.0 %
Date: 2020-09-30 20:25:40 Functions: 0 19 0.0 %
Branches: 0 286 0.0 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0
       2                 :            : /*
       3                 :            :  * fs/f2fs/inode.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 <linux/buffer_head.h>
      11                 :            : #include <linux/backing-dev.h>
      12                 :            : #include <linux/writeback.h>
      13                 :            : 
      14                 :            : #include "f2fs.h"
      15                 :            : #include "node.h"
      16                 :            : #include "segment.h"
      17                 :            : #include "xattr.h"
      18                 :            : 
      19                 :            : #include <trace/events/f2fs.h>
      20                 :            : 
      21                 :          0 : void f2fs_mark_inode_dirty_sync(struct inode *inode, bool sync)
      22                 :            : {
      23         [ #  # ]:          0 :         if (is_inode_flag_set(inode, FI_NEW_INODE))
      24                 :            :                 return;
      25                 :            : 
      26         [ #  # ]:          0 :         if (f2fs_inode_dirtied(inode, sync))
      27                 :            :                 return;
      28                 :            : 
      29                 :            :         mark_inode_dirty_sync(inode);
      30                 :            : }
      31                 :            : 
      32                 :          0 : void f2fs_set_inode_flags(struct inode *inode)
      33                 :            : {
      34                 :          0 :         unsigned int flags = F2FS_I(inode)->i_flags;
      35                 :            :         unsigned int new_fl = 0;
      36                 :            : 
      37         [ #  # ]:          0 :         if (flags & F2FS_SYNC_FL)
      38                 :            :                 new_fl |= S_SYNC;
      39         [ #  # ]:          0 :         if (flags & F2FS_APPEND_FL)
      40                 :          0 :                 new_fl |= S_APPEND;
      41         [ #  # ]:          0 :         if (flags & F2FS_IMMUTABLE_FL)
      42                 :          0 :                 new_fl |= S_IMMUTABLE;
      43         [ #  # ]:          0 :         if (flags & F2FS_NOATIME_FL)
      44                 :          0 :                 new_fl |= S_NOATIME;
      45         [ #  # ]:          0 :         if (flags & F2FS_DIRSYNC_FL)
      46                 :          0 :                 new_fl |= S_DIRSYNC;
      47         [ #  # ]:          0 :         if (file_is_encrypt(inode))
      48                 :          0 :                 new_fl |= S_ENCRYPTED;
      49         [ #  # ]:          0 :         if (file_is_verity(inode))
      50                 :          0 :                 new_fl |= S_VERITY;
      51         [ #  # ]:          0 :         if (flags & F2FS_CASEFOLD_FL)
      52                 :          0 :                 new_fl |= S_CASEFOLD;
      53                 :          0 :         inode_set_flags(inode, new_fl,
      54                 :            :                         S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC|
      55                 :            :                         S_ENCRYPTED|S_VERITY|S_CASEFOLD);
      56                 :          0 : }
      57                 :            : 
      58                 :          0 : static void __get_inode_rdev(struct inode *inode, struct f2fs_inode *ri)
      59                 :            : {
      60                 :            :         int extra_size = get_extra_isize(inode);
      61                 :            : 
      62   [ #  #  #  # ]:          0 :         if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) ||
      63         [ #  # ]:          0 :                         S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {
      64         [ #  # ]:          0 :                 if (ri->i_addr[extra_size])
      65                 :          0 :                         inode->i_rdev = old_decode_dev(
      66                 :            :                                 le32_to_cpu(ri->i_addr[extra_size]));
      67                 :            :                 else
      68                 :          0 :                         inode->i_rdev = new_decode_dev(
      69                 :          0 :                                 le32_to_cpu(ri->i_addr[extra_size + 1]));
      70                 :            :         }
      71                 :          0 : }
      72                 :            : 
      73                 :          0 : static int __written_first_block(struct f2fs_sb_info *sbi,
      74                 :            :                                         struct f2fs_inode *ri)
      75                 :            : {
      76                 :          0 :         block_t addr = le32_to_cpu(ri->i_addr[offset_in_addr(ri)]);
      77                 :            : 
      78         [ #  # ]:          0 :         if (!__is_valid_data_blkaddr(addr))
      79                 :            :                 return 1;
      80         [ #  # ]:          0 :         if (!f2fs_is_valid_blkaddr(sbi, addr, DATA_GENERIC_ENHANCE))
      81                 :            :                 return -EFSCORRUPTED;
      82                 :          0 :         return 0;
      83                 :            : }
      84                 :            : 
      85                 :          0 : static void __set_inode_rdev(struct inode *inode, struct f2fs_inode *ri)
      86                 :            : {
      87                 :            :         int extra_size = get_extra_isize(inode);
      88                 :            : 
      89         [ #  # ]:          0 :         if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
      90         [ #  # ]:          0 :                 if (old_valid_dev(inode->i_rdev)) {
      91                 :          0 :                         ri->i_addr[extra_size] =
      92                 :          0 :                                 cpu_to_le32(old_encode_dev(inode->i_rdev));
      93                 :          0 :                         ri->i_addr[extra_size + 1] = 0;
      94                 :            :                 } else {
      95                 :          0 :                         ri->i_addr[extra_size] = 0;
      96                 :          0 :                         ri->i_addr[extra_size + 1] =
      97                 :          0 :                                 cpu_to_le32(new_encode_dev(inode->i_rdev));
      98                 :          0 :                         ri->i_addr[extra_size + 2] = 0;
      99                 :            :                 }
     100                 :            :         }
     101                 :          0 : }
     102                 :            : 
     103                 :          0 : static void __recover_inline_status(struct inode *inode, struct page *ipage)
     104                 :            : {
     105                 :            :         void *inline_data = inline_data_addr(inode, ipage);
     106                 :            :         __le32 *start = inline_data;
     107                 :          0 :         __le32 *end = start + MAX_INLINE_DATA(inode) / sizeof(__le32);
     108                 :            : 
     109         [ #  # ]:          0 :         while (start < end) {
     110         [ #  # ]:          0 :                 if (*start++) {
     111                 :          0 :                         f2fs_wait_on_page_writeback(ipage, NODE, true, true);
     112                 :            : 
     113                 :          0 :                         set_inode_flag(inode, FI_DATA_EXIST);
     114                 :          0 :                         set_raw_inline(inode, F2FS_INODE(ipage));
     115                 :          0 :                         set_page_dirty(ipage);
     116                 :          0 :                         return;
     117                 :            :                 }
     118                 :            :         }
     119                 :            :         return;
     120                 :            : }
     121                 :            : 
     122                 :          0 : static bool f2fs_enable_inode_chksum(struct f2fs_sb_info *sbi, struct page *page)
     123                 :            : {
     124                 :          0 :         struct f2fs_inode *ri = &F2FS_NODE(page)->i;
     125                 :            : 
     126         [ #  # ]:          0 :         if (!f2fs_sb_has_inode_chksum(sbi))
     127                 :            :                 return false;
     128                 :            : 
     129   [ #  #  #  # ]:          0 :         if (!IS_INODE(page) || !(ri->i_inline & F2FS_EXTRA_ATTR))
     130                 :            :                 return false;
     131                 :            : 
     132         [ #  # ]:          0 :         if (!F2FS_FITS_IN_INODE(ri, le16_to_cpu(ri->i_extra_isize),
     133                 :            :                                 i_inode_checksum))
     134                 :            :                 return false;
     135                 :            : 
     136                 :          0 :         return true;
     137                 :            : }
     138                 :            : 
     139                 :          0 : static __u32 f2fs_inode_chksum(struct f2fs_sb_info *sbi, struct page *page)
     140                 :            : {
     141                 :          0 :         struct f2fs_node *node = F2FS_NODE(page);
     142                 :          0 :         struct f2fs_inode *ri = &node->i;
     143                 :          0 :         __le32 ino = node->footer.ino;
     144                 :          0 :         __le32 gen = ri->i_generation;
     145                 :            :         __u32 chksum, chksum_seed;
     146                 :          0 :         __u32 dummy_cs = 0;
     147                 :            :         unsigned int offset = offsetof(struct f2fs_inode, i_inode_checksum);
     148                 :            :         unsigned int cs_size = sizeof(dummy_cs);
     149                 :            : 
     150                 :          0 :         chksum = f2fs_chksum(sbi, sbi->s_chksum_seed, (__u8 *)&ino,
     151                 :            :                                                         sizeof(ino));
     152                 :            :         chksum_seed = f2fs_chksum(sbi, chksum, (__u8 *)&gen, sizeof(gen));
     153                 :            : 
     154                 :            :         chksum = f2fs_chksum(sbi, chksum_seed, (__u8 *)ri, offset);
     155                 :            :         chksum = f2fs_chksum(sbi, chksum, (__u8 *)&dummy_cs, cs_size);
     156                 :            :         offset += cs_size;
     157                 :          0 :         chksum = f2fs_chksum(sbi, chksum, (__u8 *)ri + offset,
     158                 :            :                                                 F2FS_BLKSIZE - offset);
     159                 :          0 :         return chksum;
     160                 :            : }
     161                 :            : 
     162                 :          0 : bool f2fs_inode_chksum_verify(struct f2fs_sb_info *sbi, struct page *page)
     163                 :            : {
     164                 :            :         struct f2fs_inode *ri;
     165                 :            :         __u32 provided, calculated;
     166                 :            : 
     167         [ #  # ]:          0 :         if (unlikely(is_sbi_flag_set(sbi, SBI_IS_SHUTDOWN)))
     168                 :            :                 return true;
     169                 :            : 
     170                 :            : #ifdef CONFIG_F2FS_CHECK_FS
     171                 :            :         if (!f2fs_enable_inode_chksum(sbi, page))
     172                 :            : #else
     173   [ #  #  #  # ]:          0 :         if (!f2fs_enable_inode_chksum(sbi, page) ||
     174         [ #  # ]:          0 :                         PageDirty(page) || PageWriteback(page))
     175                 :            : #endif
     176                 :            :                 return true;
     177                 :            : 
     178                 :          0 :         ri = &F2FS_NODE(page)->i;
     179                 :          0 :         provided = le32_to_cpu(ri->i_inode_checksum);
     180                 :          0 :         calculated = f2fs_inode_chksum(sbi, page);
     181                 :            : 
     182         [ #  # ]:          0 :         if (provided != calculated)
     183                 :          0 :                 f2fs_warn(sbi, "checksum invalid, nid = %lu, ino_of_node = %x, %x vs. %x",
     184                 :            :                           page->index, ino_of_node(page), provided, calculated);
     185                 :            : 
     186                 :          0 :         return provided == calculated;
     187                 :            : }
     188                 :            : 
     189                 :          0 : void f2fs_inode_chksum_set(struct f2fs_sb_info *sbi, struct page *page)
     190                 :            : {
     191                 :          0 :         struct f2fs_inode *ri = &F2FS_NODE(page)->i;
     192                 :            : 
     193         [ #  # ]:          0 :         if (!f2fs_enable_inode_chksum(sbi, page))
     194                 :          0 :                 return;
     195                 :            : 
     196                 :          0 :         ri->i_inode_checksum = cpu_to_le32(f2fs_inode_chksum(sbi, page));
     197                 :            : }
     198                 :            : 
     199                 :          0 : static bool sanity_check_inode(struct inode *inode, struct page *node_page)
     200                 :            : {
     201                 :            :         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
     202                 :            :         struct f2fs_inode_info *fi = F2FS_I(inode);
     203                 :            :         unsigned long long iblocks;
     204                 :            : 
     205                 :          0 :         iblocks = le64_to_cpu(F2FS_INODE(node_page)->i_blocks);
     206         [ #  # ]:          0 :         if (!iblocks) {
     207                 :            :                 set_sbi_flag(sbi, SBI_NEED_FSCK);
     208                 :          0 :                 f2fs_warn(sbi, "%s: corrupted inode i_blocks i_ino=%lx iblocks=%llu, run fsck to fix.",
     209                 :            :                           __func__, inode->i_ino, iblocks);
     210                 :          0 :                 return false;
     211                 :            :         }
     212                 :            : 
     213         [ #  # ]:          0 :         if (ino_of_node(node_page) != nid_of_node(node_page)) {
     214                 :            :                 set_sbi_flag(sbi, SBI_NEED_FSCK);
     215                 :          0 :                 f2fs_warn(sbi, "%s: corrupted inode footer i_ino=%lx, ino,nid: [%u, %u] run fsck to fix.",
     216                 :            :                           __func__, inode->i_ino,
     217                 :            :                           ino_of_node(node_page), nid_of_node(node_page));
     218                 :          0 :                 return false;
     219                 :            :         }
     220                 :            : 
     221         [ #  # ]:          0 :         if (f2fs_sb_has_flexible_inline_xattr(sbi)
     222         [ #  # ]:          0 :                         && !f2fs_has_extra_attr(inode)) {
     223                 :            :                 set_sbi_flag(sbi, SBI_NEED_FSCK);
     224                 :          0 :                 f2fs_warn(sbi, "%s: corrupted inode ino=%lx, run fsck to fix.",
     225                 :            :                           __func__, inode->i_ino);
     226                 :          0 :                 return false;
     227                 :            :         }
     228                 :            : 
     229   [ #  #  #  # ]:          0 :         if (f2fs_has_extra_attr(inode) &&
     230                 :            :                         !f2fs_sb_has_extra_attr(sbi)) {
     231                 :            :                 set_sbi_flag(sbi, SBI_NEED_FSCK);
     232                 :          0 :                 f2fs_warn(sbi, "%s: inode (ino=%lx) is with extra_attr, but extra_attr feature is off",
     233                 :            :                           __func__, inode->i_ino);
     234                 :          0 :                 return false;
     235                 :            :         }
     236                 :            : 
     237   [ #  #  #  # ]:          0 :         if (fi->i_extra_isize > F2FS_TOTAL_EXTRA_ATTR_SIZE ||
     238                 :          0 :                         fi->i_extra_isize % sizeof(__le32)) {
     239                 :            :                 set_sbi_flag(sbi, SBI_NEED_FSCK);
     240                 :          0 :                 f2fs_warn(sbi, "%s: inode (ino=%lx) has corrupted i_extra_isize: %d, max: %zu",
     241                 :            :                           __func__, inode->i_ino, fi->i_extra_isize,
     242                 :            :                           F2FS_TOTAL_EXTRA_ATTR_SIZE);
     243                 :          0 :                 return false;
     244                 :            :         }
     245                 :            : 
     246   [ #  #  #  # ]:          0 :         if (f2fs_has_extra_attr(inode) &&
     247         [ #  # ]:          0 :                 f2fs_sb_has_flexible_inline_xattr(sbi) &&
     248         [ #  # ]:          0 :                 f2fs_has_inline_xattr(inode) &&
     249                 :          0 :                 (!fi->i_inline_xattr_size ||
     250                 :            :                 fi->i_inline_xattr_size > MAX_INLINE_XATTR_SIZE)) {
     251                 :            :                 set_sbi_flag(sbi, SBI_NEED_FSCK);
     252                 :          0 :                 f2fs_warn(sbi, "%s: inode (ino=%lx) has corrupted i_inline_xattr_size: %d, max: %zu",
     253                 :            :                           __func__, inode->i_ino, fi->i_inline_xattr_size,
     254                 :            :                           MAX_INLINE_XATTR_SIZE);
     255                 :          0 :                 return false;
     256                 :            :         }
     257                 :            : 
     258         [ #  # ]:          0 :         if (F2FS_I(inode)->extent_tree) {
     259                 :            :                 struct extent_info *ei = &F2FS_I(inode)->extent_tree->largest;
     260                 :            : 
     261   [ #  #  #  # ]:          0 :                 if (ei->len &&
     262                 :          0 :                         (!f2fs_is_valid_blkaddr(sbi, ei->blk,
     263         [ #  # ]:          0 :                                                 DATA_GENERIC_ENHANCE) ||
     264                 :          0 :                         !f2fs_is_valid_blkaddr(sbi, ei->blk + ei->len - 1,
     265                 :            :                                                 DATA_GENERIC_ENHANCE))) {
     266                 :            :                         set_sbi_flag(sbi, SBI_NEED_FSCK);
     267                 :          0 :                         f2fs_warn(sbi, "%s: inode (ino=%lx) extent info [%u, %u, %u] is incorrect, run fsck to fix",
     268                 :            :                                   __func__, inode->i_ino,
     269                 :            :                                   ei->blk, ei->fofs, ei->len);
     270                 :          0 :                         return false;
     271                 :            :                 }
     272                 :            :         }
     273                 :            : 
     274   [ #  #  #  # ]:          0 :         if (f2fs_has_inline_data(inode) &&
     275                 :          0 :                         (!S_ISREG(inode->i_mode) && !S_ISLNK(inode->i_mode))) {
     276                 :            :                 set_sbi_flag(sbi, SBI_NEED_FSCK);
     277                 :          0 :                 f2fs_warn(sbi, "%s: inode (ino=%lx, mode=%u) should not have inline_data, run fsck to fix",
     278                 :            :                           __func__, inode->i_ino, inode->i_mode);
     279                 :          0 :                 return false;
     280                 :            :         }
     281                 :            : 
     282   [ #  #  #  # ]:          0 :         if (f2fs_has_inline_dentry(inode) && !S_ISDIR(inode->i_mode)) {
     283                 :            :                 set_sbi_flag(sbi, SBI_NEED_FSCK);
     284                 :          0 :                 f2fs_warn(sbi, "%s: inode (ino=%lx, mode=%u) should not have inline_dentry, run fsck to fix",
     285                 :            :                           __func__, inode->i_ino, inode->i_mode);
     286                 :          0 :                 return false;
     287                 :            :         }
     288                 :            : 
     289                 :            :         return true;
     290                 :            : }
     291                 :            : 
     292                 :          0 : static int do_read_inode(struct inode *inode)
     293                 :            : {
     294                 :            :         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
     295                 :            :         struct f2fs_inode_info *fi = F2FS_I(inode);
     296                 :            :         struct page *node_page;
     297                 :            :         struct f2fs_inode *ri;
     298                 :            :         projid_t i_projid;
     299                 :            :         int err;
     300                 :            : 
     301                 :            :         /* Check if ino is within scope */
     302         [ #  # ]:          0 :         if (f2fs_check_nid_range(sbi, inode->i_ino))
     303                 :            :                 return -EINVAL;
     304                 :            : 
     305                 :          0 :         node_page = f2fs_get_node_page(sbi, inode->i_ino);
     306         [ #  # ]:          0 :         if (IS_ERR(node_page))
     307                 :          0 :                 return PTR_ERR(node_page);
     308                 :            : 
     309                 :          0 :         ri = F2FS_INODE(node_page);
     310                 :            : 
     311                 :          0 :         inode->i_mode = le16_to_cpu(ri->i_mode);
     312                 :          0 :         i_uid_write(inode, le32_to_cpu(ri->i_uid));
     313                 :          0 :         i_gid_write(inode, le32_to_cpu(ri->i_gid));
     314                 :          0 :         set_nlink(inode, le32_to_cpu(ri->i_links));
     315                 :          0 :         inode->i_size = le64_to_cpu(ri->i_size);
     316                 :          0 :         inode->i_blocks = SECTOR_FROM_BLOCK(le64_to_cpu(ri->i_blocks) - 1);
     317                 :            : 
     318                 :          0 :         inode->i_atime.tv_sec = le64_to_cpu(ri->i_atime);
     319                 :          0 :         inode->i_ctime.tv_sec = le64_to_cpu(ri->i_ctime);
     320                 :          0 :         inode->i_mtime.tv_sec = le64_to_cpu(ri->i_mtime);
     321                 :          0 :         inode->i_atime.tv_nsec = le32_to_cpu(ri->i_atime_nsec);
     322                 :          0 :         inode->i_ctime.tv_nsec = le32_to_cpu(ri->i_ctime_nsec);
     323                 :          0 :         inode->i_mtime.tv_nsec = le32_to_cpu(ri->i_mtime_nsec);
     324                 :          0 :         inode->i_generation = le32_to_cpu(ri->i_generation);
     325         [ #  # ]:          0 :         if (S_ISDIR(inode->i_mode))
     326                 :          0 :                 fi->i_current_depth = le32_to_cpu(ri->i_current_depth);
     327         [ #  # ]:          0 :         else if (S_ISREG(inode->i_mode))
     328                 :          0 :                 fi->i_gc_failures[GC_FAILURE_PIN] =
     329                 :          0 :                                         le16_to_cpu(ri->i_gc_failures);
     330                 :          0 :         fi->i_xattr_nid = le32_to_cpu(ri->i_xattr_nid);
     331                 :          0 :         fi->i_flags = le32_to_cpu(ri->i_flags);
     332         [ #  # ]:          0 :         if (S_ISREG(inode->i_mode))
     333                 :          0 :                 fi->i_flags &= ~F2FS_PROJINHERIT_FL;
     334                 :          0 :         fi->flags = 0;
     335                 :          0 :         fi->i_advise = ri->i_advise;
     336                 :          0 :         fi->i_pino = le32_to_cpu(ri->i_pino);
     337                 :          0 :         fi->i_dir_level = ri->i_dir_level;
     338                 :            : 
     339         [ #  # ]:          0 :         if (f2fs_init_extent_tree(inode, &ri->i_ext))
     340                 :          0 :                 set_page_dirty(node_page);
     341                 :            : 
     342                 :          0 :         get_inline_info(inode, ri);
     343                 :            : 
     344                 :          0 :         fi->i_extra_isize = f2fs_has_extra_attr(inode) ?
     345         [ #  # ]:          0 :                                         le16_to_cpu(ri->i_extra_isize) : 0;
     346                 :            : 
     347         [ #  # ]:          0 :         if (f2fs_sb_has_flexible_inline_xattr(sbi)) {
     348                 :          0 :                 fi->i_inline_xattr_size = le16_to_cpu(ri->i_inline_xattr_size);
     349   [ #  #  #  # ]:          0 :         } else if (f2fs_has_inline_xattr(inode) ||
     350                 :            :                                 f2fs_has_inline_dentry(inode)) {
     351                 :          0 :                 fi->i_inline_xattr_size = DEFAULT_INLINE_XATTR_ADDRS;
     352                 :            :         } else {
     353                 :            : 
     354                 :            :                 /*
     355                 :            :                  * Previous inline data or directory always reserved 200 bytes
     356                 :            :                  * in inode layout, even if inline_xattr is disabled. In order
     357                 :            :                  * to keep inline_dentry's structure for backward compatibility,
     358                 :            :                  * we get the space back only from inline_data.
     359                 :            :                  */
     360                 :          0 :                 fi->i_inline_xattr_size = 0;
     361                 :            :         }
     362                 :            : 
     363         [ #  # ]:          0 :         if (!sanity_check_inode(inode, node_page)) {
     364                 :          0 :                 f2fs_put_page(node_page, 1);
     365                 :          0 :                 return -EFSCORRUPTED;
     366                 :            :         }
     367                 :            : 
     368                 :            :         /* check data exist */
     369   [ #  #  #  # ]:          0 :         if (f2fs_has_inline_data(inode) && !f2fs_exist_data(inode))
     370                 :          0 :                 __recover_inline_status(inode, node_page);
     371                 :            : 
     372                 :            :         /* try to recover cold bit for non-dir inode */
     373   [ #  #  #  # ]:          0 :         if (!S_ISDIR(inode->i_mode) && !is_cold_node(node_page)) {
     374                 :          0 :                 set_cold_node(node_page, false);
     375                 :          0 :                 set_page_dirty(node_page);
     376                 :            :         }
     377                 :            : 
     378                 :            :         /* get rdev by using inline_info */
     379                 :          0 :         __get_inode_rdev(inode, ri);
     380                 :            : 
     381         [ #  # ]:          0 :         if (S_ISREG(inode->i_mode)) {
     382                 :          0 :                 err = __written_first_block(sbi, ri);
     383         [ #  # ]:          0 :                 if (err < 0) {
     384                 :          0 :                         f2fs_put_page(node_page, 1);
     385                 :          0 :                         return err;
     386                 :            :                 }
     387         [ #  # ]:          0 :                 if (!err)
     388                 :          0 :                         set_inode_flag(inode, FI_FIRST_BLOCK_WRITTEN);
     389                 :            :         }
     390                 :            : 
     391         [ #  # ]:          0 :         if (!f2fs_need_inode_block_update(sbi, inode->i_ino))
     392                 :          0 :                 fi->last_disk_size = inode->i_size;
     393                 :            : 
     394         [ #  # ]:          0 :         if (fi->i_flags & F2FS_PROJINHERIT_FL)
     395                 :          0 :                 set_inode_flag(inode, FI_PROJ_INHERIT);
     396                 :            : 
     397   [ #  #  #  #  :          0 :         if (f2fs_has_extra_attr(inode) && f2fs_sb_has_project_quota(sbi) &&
                   #  # ]
     398                 :          0 :                         F2FS_FITS_IN_INODE(ri, fi->i_extra_isize, i_projid))
     399                 :          0 :                 i_projid = (projid_t)le32_to_cpu(ri->i_projid);
     400                 :            :         else
     401                 :            :                 i_projid = F2FS_DEF_PROJID;
     402                 :          0 :         fi->i_projid = make_kprojid(&init_user_ns, i_projid);
     403                 :            : 
     404   [ #  #  #  #  :          0 :         if (f2fs_has_extra_attr(inode) && f2fs_sb_has_inode_crtime(sbi) &&
                   #  # ]
     405                 :          0 :                         F2FS_FITS_IN_INODE(ri, fi->i_extra_isize, i_crtime)) {
     406                 :          0 :                 fi->i_crtime.tv_sec = le64_to_cpu(ri->i_crtime);
     407                 :          0 :                 fi->i_crtime.tv_nsec = le32_to_cpu(ri->i_crtime_nsec);
     408                 :            :         }
     409                 :            : 
     410                 :          0 :         F2FS_I(inode)->i_disk_time[0] = inode->i_atime;
     411                 :          0 :         F2FS_I(inode)->i_disk_time[1] = inode->i_ctime;
     412                 :          0 :         F2FS_I(inode)->i_disk_time[2] = inode->i_mtime;
     413                 :          0 :         F2FS_I(inode)->i_disk_time[3] = F2FS_I(inode)->i_crtime;
     414                 :          0 :         f2fs_put_page(node_page, 1);
     415                 :            : 
     416         [ #  # ]:          0 :         stat_inc_inline_xattr(inode);
     417         [ #  # ]:          0 :         stat_inc_inline_inode(inode);
     418         [ #  # ]:          0 :         stat_inc_inline_dir(inode);
     419                 :            : 
     420                 :            :         return 0;
     421                 :            : }
     422                 :            : 
     423                 :          0 : struct inode *f2fs_iget(struct super_block *sb, unsigned long ino)
     424                 :            : {
     425                 :            :         struct f2fs_sb_info *sbi = F2FS_SB(sb);
     426                 :            :         struct inode *inode;
     427                 :            :         int ret = 0;
     428                 :            : 
     429                 :          0 :         inode = iget_locked(sb, ino);
     430         [ #  # ]:          0 :         if (!inode)
     431                 :            :                 return ERR_PTR(-ENOMEM);
     432                 :            : 
     433         [ #  # ]:          0 :         if (!(inode->i_state & I_NEW)) {
     434                 :          0 :                 trace_f2fs_iget(inode);
     435                 :          0 :                 return inode;
     436                 :            :         }
     437   [ #  #  #  # ]:          0 :         if (ino == F2FS_NODE_INO(sbi) || ino == F2FS_META_INO(sbi))
     438                 :            :                 goto make_now;
     439                 :            : 
     440                 :          0 :         ret = do_read_inode(inode);
     441         [ #  # ]:          0 :         if (ret)
     442                 :            :                 goto bad_inode;
     443                 :            : make_now:
     444         [ #  # ]:          0 :         if (ino == F2FS_NODE_INO(sbi)) {
     445                 :          0 :                 inode->i_mapping->a_ops = &f2fs_node_aops;
     446                 :          0 :                 mapping_set_gfp_mask(inode->i_mapping, GFP_NOFS);
     447         [ #  # ]:          0 :         } else if (ino == F2FS_META_INO(sbi)) {
     448                 :          0 :                 inode->i_mapping->a_ops = &f2fs_meta_aops;
     449                 :          0 :                 mapping_set_gfp_mask(inode->i_mapping, GFP_NOFS);
     450         [ #  # ]:          0 :         } else if (S_ISREG(inode->i_mode)) {
     451                 :          0 :                 inode->i_op = &f2fs_file_inode_operations;
     452                 :          0 :                 inode->i_fop = &f2fs_file_operations;
     453                 :          0 :                 inode->i_mapping->a_ops = &f2fs_dblock_aops;
     454         [ #  # ]:          0 :         } else if (S_ISDIR(inode->i_mode)) {
     455                 :          0 :                 inode->i_op = &f2fs_dir_inode_operations;
     456                 :          0 :                 inode->i_fop = &f2fs_dir_operations;
     457                 :          0 :                 inode->i_mapping->a_ops = &f2fs_dblock_aops;
     458                 :          0 :                 inode_nohighmem(inode);
     459         [ #  # ]:          0 :         } else if (S_ISLNK(inode->i_mode)) {
     460         [ #  # ]:          0 :                 if (file_is_encrypt(inode))
     461                 :          0 :                         inode->i_op = &f2fs_encrypted_symlink_inode_operations;
     462                 :            :                 else
     463                 :          0 :                         inode->i_op = &f2fs_symlink_inode_operations;
     464                 :          0 :                 inode_nohighmem(inode);
     465                 :          0 :                 inode->i_mapping->a_ops = &f2fs_dblock_aops;
     466   [ #  #  #  # ]:          0 :         } else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) ||
     467         [ #  # ]:          0 :                         S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {
     468                 :          0 :                 inode->i_op = &f2fs_special_inode_operations;
     469                 :          0 :                 init_special_inode(inode, inode->i_mode, inode->i_rdev);
     470                 :            :         } else {
     471                 :            :                 ret = -EIO;
     472                 :            :                 goto bad_inode;
     473                 :            :         }
     474                 :          0 :         f2fs_set_inode_flags(inode);
     475                 :          0 :         unlock_new_inode(inode);
     476                 :          0 :         trace_f2fs_iget(inode);
     477                 :          0 :         return inode;
     478                 :            : 
     479                 :            : bad_inode:
     480                 :          0 :         f2fs_inode_synced(inode);
     481                 :          0 :         iget_failed(inode);
     482                 :          0 :         trace_f2fs_iget_exit(inode, ret);
     483                 :          0 :         return ERR_PTR(ret);
     484                 :            : }
     485                 :            : 
     486                 :          0 : struct inode *f2fs_iget_retry(struct super_block *sb, unsigned long ino)
     487                 :            : {
     488                 :            :         struct inode *inode;
     489                 :            : retry:
     490                 :          0 :         inode = f2fs_iget(sb, ino);
     491         [ #  # ]:          0 :         if (IS_ERR(inode)) {
     492         [ #  # ]:          0 :                 if (PTR_ERR(inode) == -ENOMEM) {
     493                 :          0 :                         congestion_wait(BLK_RW_ASYNC, HZ/50);
     494                 :          0 :                         goto retry;
     495                 :            :                 }
     496                 :            :         }
     497                 :          0 :         return inode;
     498                 :            : }
     499                 :            : 
     500                 :          0 : void f2fs_update_inode(struct inode *inode, struct page *node_page)
     501                 :            : {
     502                 :            :         struct f2fs_inode *ri;
     503                 :          0 :         struct extent_tree *et = F2FS_I(inode)->extent_tree;
     504                 :            : 
     505                 :          0 :         f2fs_wait_on_page_writeback(node_page, NODE, true, true);
     506                 :          0 :         set_page_dirty(node_page);
     507                 :            : 
     508                 :          0 :         f2fs_inode_synced(inode);
     509                 :            : 
     510                 :          0 :         ri = F2FS_INODE(node_page);
     511                 :            : 
     512                 :          0 :         ri->i_mode = cpu_to_le16(inode->i_mode);
     513                 :          0 :         ri->i_advise = F2FS_I(inode)->i_advise;
     514                 :          0 :         ri->i_uid = cpu_to_le32(i_uid_read(inode));
     515                 :          0 :         ri->i_gid = cpu_to_le32(i_gid_read(inode));
     516                 :          0 :         ri->i_links = cpu_to_le32(inode->i_nlink);
     517                 :          0 :         ri->i_size = cpu_to_le64(i_size_read(inode));
     518                 :          0 :         ri->i_blocks = cpu_to_le64(SECTOR_TO_BLOCK(inode->i_blocks) + 1);
     519                 :            : 
     520         [ #  # ]:          0 :         if (et) {
     521                 :          0 :                 read_lock(&et->lock);
     522                 :            :                 set_raw_extent(&et->largest, &ri->i_ext);
     523                 :            :                 read_unlock(&et->lock);
     524                 :            :         } else {
     525                 :          0 :                 memset(&ri->i_ext, 0, sizeof(ri->i_ext));
     526                 :            :         }
     527                 :          0 :         set_raw_inline(inode, ri);
     528                 :            : 
     529                 :          0 :         ri->i_atime = cpu_to_le64(inode->i_atime.tv_sec);
     530                 :          0 :         ri->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec);
     531                 :          0 :         ri->i_mtime = cpu_to_le64(inode->i_mtime.tv_sec);
     532                 :          0 :         ri->i_atime_nsec = cpu_to_le32(inode->i_atime.tv_nsec);
     533                 :          0 :         ri->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);
     534                 :          0 :         ri->i_mtime_nsec = cpu_to_le32(inode->i_mtime.tv_nsec);
     535         [ #  # ]:          0 :         if (S_ISDIR(inode->i_mode))
     536                 :          0 :                 ri->i_current_depth =
     537                 :          0 :                         cpu_to_le32(F2FS_I(inode)->i_current_depth);
     538         [ #  # ]:          0 :         else if (S_ISREG(inode->i_mode))
     539                 :          0 :                 ri->i_gc_failures =
     540                 :          0 :                         cpu_to_le16(F2FS_I(inode)->i_gc_failures[GC_FAILURE_PIN]);
     541                 :          0 :         ri->i_xattr_nid = cpu_to_le32(F2FS_I(inode)->i_xattr_nid);
     542                 :          0 :         ri->i_flags = cpu_to_le32(F2FS_I(inode)->i_flags);
     543                 :          0 :         ri->i_pino = cpu_to_le32(F2FS_I(inode)->i_pino);
     544                 :          0 :         ri->i_generation = cpu_to_le32(inode->i_generation);
     545                 :          0 :         ri->i_dir_level = F2FS_I(inode)->i_dir_level;
     546                 :            : 
     547         [ #  # ]:          0 :         if (f2fs_has_extra_attr(inode)) {
     548                 :          0 :                 ri->i_extra_isize = cpu_to_le16(F2FS_I(inode)->i_extra_isize);
     549                 :            : 
     550         [ #  # ]:          0 :                 if (f2fs_sb_has_flexible_inline_xattr(F2FS_I_SB(inode)))
     551                 :          0 :                         ri->i_inline_xattr_size =
     552                 :          0 :                                 cpu_to_le16(F2FS_I(inode)->i_inline_xattr_size);
     553                 :            : 
     554   [ #  #  #  # ]:          0 :                 if (f2fs_sb_has_project_quota(F2FS_I_SB(inode)) &&
     555                 :          0 :                         F2FS_FITS_IN_INODE(ri, F2FS_I(inode)->i_extra_isize,
     556                 :            :                                                                 i_projid)) {
     557                 :            :                         projid_t i_projid;
     558                 :            : 
     559                 :          0 :                         i_projid = from_kprojid(&init_user_ns,
     560                 :            :                                                 F2FS_I(inode)->i_projid);
     561                 :          0 :                         ri->i_projid = cpu_to_le32(i_projid);
     562                 :            :                 }
     563                 :            : 
     564   [ #  #  #  # ]:          0 :                 if (f2fs_sb_has_inode_crtime(F2FS_I_SB(inode)) &&
     565                 :          0 :                         F2FS_FITS_IN_INODE(ri, F2FS_I(inode)->i_extra_isize,
     566                 :            :                                                                 i_crtime)) {
     567                 :          0 :                         ri->i_crtime =
     568                 :          0 :                                 cpu_to_le64(F2FS_I(inode)->i_crtime.tv_sec);
     569                 :          0 :                         ri->i_crtime_nsec =
     570                 :          0 :                                 cpu_to_le32(F2FS_I(inode)->i_crtime.tv_nsec);
     571                 :            :                 }
     572                 :            :         }
     573                 :            : 
     574                 :          0 :         __set_inode_rdev(inode, ri);
     575                 :            : 
     576                 :            :         /* deleted inode */
     577         [ #  # ]:          0 :         if (inode->i_nlink == 0)
     578                 :            :                 clear_inline_node(node_page);
     579                 :            : 
     580                 :          0 :         F2FS_I(inode)->i_disk_time[0] = inode->i_atime;
     581                 :          0 :         F2FS_I(inode)->i_disk_time[1] = inode->i_ctime;
     582                 :          0 :         F2FS_I(inode)->i_disk_time[2] = inode->i_mtime;
     583                 :          0 :         F2FS_I(inode)->i_disk_time[3] = F2FS_I(inode)->i_crtime;
     584                 :            : 
     585                 :            : #ifdef CONFIG_F2FS_CHECK_FS
     586                 :            :         f2fs_inode_chksum_set(F2FS_I_SB(inode), node_page);
     587                 :            : #endif
     588                 :          0 : }
     589                 :            : 
     590                 :          0 : void f2fs_update_inode_page(struct inode *inode)
     591                 :            : {
     592                 :            :         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
     593                 :            :         struct page *node_page;
     594                 :            : retry:
     595                 :          0 :         node_page = f2fs_get_node_page(sbi, inode->i_ino);
     596         [ #  # ]:          0 :         if (IS_ERR(node_page)) {
     597                 :            :                 int err = PTR_ERR(node_page);
     598         [ #  # ]:          0 :                 if (err == -ENOMEM) {
     599                 :          0 :                         cond_resched();
     600                 :          0 :                         goto retry;
     601         [ #  # ]:          0 :                 } else if (err != -ENOENT) {
     602                 :          0 :                         f2fs_stop_checkpoint(sbi, false);
     603                 :            :                 }
     604                 :          0 :                 return;
     605                 :            :         }
     606                 :          0 :         f2fs_update_inode(inode, node_page);
     607                 :          0 :         f2fs_put_page(node_page, 1);
     608                 :            : }
     609                 :            : 
     610                 :          0 : int f2fs_write_inode(struct inode *inode, struct writeback_control *wbc)
     611                 :            : {
     612                 :            :         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
     613                 :            : 
     614   [ #  #  #  # ]:          0 :         if (inode->i_ino == F2FS_NODE_INO(sbi) ||
     615                 :          0 :                         inode->i_ino == F2FS_META_INO(sbi))
     616                 :            :                 return 0;
     617                 :            : 
     618                 :            :         /*
     619                 :            :          * atime could be updated without dirtying f2fs inode in lazytime mode
     620                 :            :          */
     621   [ #  #  #  # ]:          0 :         if (f2fs_is_time_consistent(inode) &&
     622                 :            :                 !is_inode_flag_set(inode, FI_DIRTY_INODE))
     623                 :            :                 return 0;
     624                 :            : 
     625         [ #  # ]:          0 :         if (!f2fs_is_checkpoint_ready(sbi))
     626                 :            :                 return -ENOSPC;
     627                 :            : 
     628                 :            :         /*
     629                 :            :          * We need to balance fs here to prevent from producing dirty node pages
     630                 :            :          * during the urgent cleaning time when runing out of free sections.
     631                 :            :          */
     632                 :          0 :         f2fs_update_inode_page(inode);
     633   [ #  #  #  # ]:          0 :         if (wbc && wbc->nr_to_write)
     634                 :          0 :                 f2fs_balance_fs(sbi, true);
     635                 :            :         return 0;
     636                 :            : }
     637                 :            : 
     638                 :            : /*
     639                 :            :  * Called at the last iput() if i_nlink is zero
     640                 :            :  */
     641                 :          0 : void f2fs_evict_inode(struct inode *inode)
     642                 :            : {
     643                 :            :         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
     644                 :          0 :         nid_t xnid = F2FS_I(inode)->i_xattr_nid;
     645                 :            :         int err = 0;
     646                 :            : 
     647                 :            :         /* some remained atomic pages should discarded */
     648         [ #  # ]:          0 :         if (f2fs_is_atomic_file(inode))
     649                 :          0 :                 f2fs_drop_inmem_pages(inode);
     650                 :            : 
     651                 :          0 :         trace_f2fs_evict_inode(inode);
     652                 :          0 :         truncate_inode_pages_final(&inode->i_data);
     653                 :            : 
     654   [ #  #  #  # ]:          0 :         if (inode->i_ino == F2FS_NODE_INO(sbi) ||
     655                 :          0 :                         inode->i_ino == F2FS_META_INO(sbi))
     656                 :            :                 goto out_clear;
     657                 :            : 
     658         [ #  # ]:          0 :         f2fs_bug_on(sbi, get_dirty_pages(inode));
     659                 :          0 :         f2fs_remove_dirty_inode(inode);
     660                 :            : 
     661                 :          0 :         f2fs_destroy_extent_tree(inode);
     662                 :            : 
     663   [ #  #  #  # ]:          0 :         if (inode->i_nlink || is_bad_inode(inode))
     664                 :            :                 goto no_delete;
     665                 :            : 
     666                 :          0 :         err = dquot_initialize(inode);
     667         [ #  # ]:          0 :         if (err) {
     668                 :            :                 err = 0;
     669                 :            :                 set_sbi_flag(sbi, SBI_QUOTA_NEED_REPAIR);
     670                 :            :         }
     671                 :            : 
     672                 :          0 :         f2fs_remove_ino_entry(sbi, inode->i_ino, APPEND_INO);
     673                 :          0 :         f2fs_remove_ino_entry(sbi, inode->i_ino, UPDATE_INO);
     674                 :          0 :         f2fs_remove_ino_entry(sbi, inode->i_ino, FLUSH_INO);
     675                 :            : 
     676                 :          0 :         sb_start_intwrite(inode->i_sb);
     677                 :          0 :         set_inode_flag(inode, FI_NO_ALLOC);
     678                 :            :         i_size_write(inode, 0);
     679                 :            : retry:
     680         [ #  # ]:          0 :         if (F2FS_HAS_BLOCKS(inode))
     681                 :          0 :                 err = f2fs_truncate(inode);
     682                 :            : 
     683                 :            :         if (time_to_inject(sbi, FAULT_EVICT_INODE)) {
     684                 :            :                 f2fs_show_injection_info(FAULT_EVICT_INODE);
     685                 :            :                 err = -EIO;
     686                 :            :         }
     687                 :            : 
     688         [ #  # ]:          0 :         if (!err) {
     689                 :            :                 f2fs_lock_op(sbi);
     690                 :          0 :                 err = f2fs_remove_inode_page(inode);
     691                 :            :                 f2fs_unlock_op(sbi);
     692         [ #  # ]:          0 :                 if (err == -ENOENT)
     693                 :            :                         err = 0;
     694                 :            :         }
     695                 :            : 
     696                 :            :         /* give more chances, if ENOMEM case */
     697         [ #  # ]:          0 :         if (err == -ENOMEM) {
     698                 :            :                 err = 0;
     699                 :            :                 goto retry;
     700                 :            :         }
     701                 :            : 
     702         [ #  # ]:          0 :         if (err) {
     703                 :          0 :                 f2fs_update_inode_page(inode);
     704         [ #  # ]:          0 :                 if (dquot_initialize_needed(inode))
     705                 :            :                         set_sbi_flag(sbi, SBI_QUOTA_NEED_REPAIR);
     706                 :            :         }
     707                 :          0 :         sb_end_intwrite(inode->i_sb);
     708                 :            : no_delete:
     709                 :          0 :         dquot_drop(inode);
     710                 :            : 
     711         [ #  # ]:          0 :         stat_dec_inline_xattr(inode);
     712         [ #  # ]:          0 :         stat_dec_inline_dir(inode);
     713         [ #  # ]:          0 :         stat_dec_inline_inode(inode);
     714                 :            : 
     715   [ #  #  #  # ]:          0 :         if (likely(!f2fs_cp_error(sbi) &&
     716                 :            :                                 !is_sbi_flag_set(sbi, SBI_CP_DISABLED)))
     717         [ #  # ]:          0 :                 f2fs_bug_on(sbi, is_inode_flag_set(inode, FI_DIRTY_INODE));
     718                 :            :         else
     719                 :          0 :                 f2fs_inode_synced(inode);
     720                 :            : 
     721                 :            :         /* ino == 0, if f2fs_new_inode() was failed t*/
     722         [ #  # ]:          0 :         if (inode->i_ino)
     723                 :          0 :                 invalidate_mapping_pages(NODE_MAPPING(sbi), inode->i_ino,
     724                 :            :                                                         inode->i_ino);
     725         [ #  # ]:          0 :         if (xnid)
     726                 :          0 :                 invalidate_mapping_pages(NODE_MAPPING(sbi), xnid, xnid);
     727         [ #  # ]:          0 :         if (inode->i_nlink) {
     728         [ #  # ]:          0 :                 if (is_inode_flag_set(inode, FI_APPEND_WRITE))
     729                 :          0 :                         f2fs_add_ino_entry(sbi, inode->i_ino, APPEND_INO);
     730         [ #  # ]:          0 :                 if (is_inode_flag_set(inode, FI_UPDATE_WRITE))
     731                 :          0 :                         f2fs_add_ino_entry(sbi, inode->i_ino, UPDATE_INO);
     732                 :            :         }
     733         [ #  # ]:          0 :         if (is_inode_flag_set(inode, FI_FREE_NID)) {
     734                 :          0 :                 f2fs_alloc_nid_failed(sbi, inode->i_ino);
     735                 :          0 :                 clear_inode_flag(inode, FI_FREE_NID);
     736                 :            :         } else {
     737                 :            :                 /*
     738                 :            :                  * If xattr nid is corrupted, we can reach out error condition,
     739                 :            :                  * err & !f2fs_exist_written_data(sbi, inode->i_ino, ORPHAN_INO)).
     740                 :            :                  * In that case, f2fs_check_nid_range() is enough to give a clue.
     741                 :            :                  */
     742                 :            :         }
     743                 :            : out_clear:
     744                 :          0 :         fscrypt_put_encryption_info(inode);
     745                 :            :         fsverity_cleanup_inode(inode);
     746                 :          0 :         clear_inode(inode);
     747                 :          0 : }
     748                 :            : 
     749                 :            : /* caller should call f2fs_lock_op() */
     750                 :          0 : void f2fs_handle_failed_inode(struct inode *inode)
     751                 :            : {
     752                 :            :         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
     753                 :            :         struct node_info ni;
     754                 :            :         int err;
     755                 :            : 
     756                 :            :         /*
     757                 :            :          * clear nlink of inode in order to release resource of inode
     758                 :            :          * immediately.
     759                 :            :          */
     760                 :          0 :         clear_nlink(inode);
     761                 :            : 
     762                 :            :         /*
     763                 :            :          * we must call this to avoid inode being remained as dirty, resulting
     764                 :            :          * in a panic when flushing dirty inodes in gdirty_list.
     765                 :            :          */
     766                 :          0 :         f2fs_update_inode_page(inode);
     767                 :          0 :         f2fs_inode_synced(inode);
     768                 :            : 
     769                 :            :         /* don't make bad inode, since it becomes a regular file. */
     770                 :          0 :         unlock_new_inode(inode);
     771                 :            : 
     772                 :            :         /*
     773                 :            :          * Note: we should add inode to orphan list before f2fs_unlock_op()
     774                 :            :          * so we can prevent losing this orphan when encoutering checkpoint
     775                 :            :          * and following suddenly power-off.
     776                 :            :          */
     777                 :          0 :         err = f2fs_get_node_info(sbi, inode->i_ino, &ni);
     778         [ #  # ]:          0 :         if (err) {
     779                 :            :                 set_sbi_flag(sbi, SBI_NEED_FSCK);
     780                 :          0 :                 f2fs_warn(sbi, "May loss orphan inode, run fsck to fix.");
     781                 :          0 :                 goto out;
     782                 :            :         }
     783                 :            : 
     784         [ #  # ]:          0 :         if (ni.blk_addr != NULL_ADDR) {
     785                 :          0 :                 err = f2fs_acquire_orphan_inode(sbi);
     786         [ #  # ]:          0 :                 if (err) {
     787                 :            :                         set_sbi_flag(sbi, SBI_NEED_FSCK);
     788                 :          0 :                         f2fs_warn(sbi, "Too many orphan inodes, run fsck to fix.");
     789                 :            :                 } else {
     790                 :          0 :                         f2fs_add_orphan_inode(inode);
     791                 :            :                 }
     792                 :          0 :                 f2fs_alloc_nid_done(sbi, inode->i_ino);
     793                 :            :         } else {
     794                 :          0 :                 set_inode_flag(inode, FI_FREE_NID);
     795                 :            :         }
     796                 :            : 
     797                 :            : out:
     798                 :            :         f2fs_unlock_op(sbi);
     799                 :            : 
     800                 :            :         /* iput will drop the inode object */
     801                 :          0 :         iput(inode);
     802                 :          0 : }

Generated by: LCOV version 1.14