f2fs: fix to do sanity check with block address in main area

author Chao Yu <yuchao0@huawei.com>

Wed, 1 Aug 2018 11:13:44 +0000 (19:13 +0800)

committer Jaegeuk Kim <jaegeuk@kernel.org>

Wed, 1 Aug 2018 18:52:32 +0000 (11:52 -0700)
author Chao Yu <yuchao0@huawei.com>
Wed, 1 Aug 2018 11:13:44 +0000 (19:13 +0800)
committer Jaegeuk Kim <jaegeuk@kernel.org>
Wed, 1 Aug 2018 18:52:32 +0000 (11:52 -0700)
diff --git a/fs/f2fs/checkpoint.c b/fs/f2fs/checkpoint.c

index 9455228..b766f78 100644 (file)
--- a/fs/f2fs/checkpoint.c
+++ b/fs/f2fs/checkpoint.c
@@ -86,8 +86,10 @@ repeat:
         fio.page = page;
  
         if (f2fs_submit_page_bio(&fio)) {
-               f2fs_put_page(page, 1);
-               goto repeat;
+               memset(page_address(page), 0, PAGE_SIZE);
+               f2fs_stop_checkpoint(sbi, false);
+               f2fs_bug_on(sbi, 1);
+               return page;
         }
  
         lock_page(page);
@@ -143,8 +145,14 @@ bool f2fs_is_valid_blkaddr(struct f2fs_sb_info *sbi,
         case META_POR:
         case DATA_GENERIC:
                 if (unlikely(blkaddr >= MAX_BLKADDR(sbi) ||
-                       blkaddr < MAIN_BLKADDR(sbi)))
+                       blkaddr < MAIN_BLKADDR(sbi))) {
+                       if (type == DATA_GENERIC) {
+                               f2fs_msg(sbi->sb, KERN_WARNING,
+                                       "access invalid blkaddr:%u", blkaddr);
+                               WARN_ON(1);
+                       }
                         return false;
+               }
                 break;
         case META_GENERIC:
                 if (unlikely(blkaddr < SEG0_BLKADDR(sbi) ||
@@ -771,6 +779,14 @@ static struct page *validate_checkpoint(struct f2fs_sb_info *sbi,
                                         &cp_page_1, version);
         if (err)
                 goto invalid_cp1;
+
+       if (le32_to_cpu(cp_block->cp_pack_total_block_count) >
+                                       sbi->blocks_per_seg) {
+               f2fs_msg(sbi->sb, KERN_WARNING,
+                       "invalid cp_pack_total_block_count:%u",
+                       le32_to_cpu(cp_block->cp_pack_total_block_count));
+               goto invalid_cp1;
+       }
         pre_version = *version;
  
         cp_addr += le32_to_cpu(cp_block->cp_pack_total_block_count) - 1;
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c

index 635a98d..4064ce2 100644 (file)
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -441,7 +441,10 @@ int f2fs_submit_page_bio(struct f2fs_io_info *fio)
         struct page *page = fio->encrypted_page ?
                         fio->encrypted_page : fio->page;
  
-       verify_block_addr(fio, fio->new_blkaddr);
+       if (!f2fs_is_valid_blkaddr(fio->sbi, fio->new_blkaddr,
+                       __is_meta_io(fio) ? META_GENERIC : DATA_GENERIC))
+               return -EFAULT;
+
         trace_f2fs_submit_page_bio(page, fio);
         f2fs_trace_ios(fio, 0);
  
@@ -1045,6 +1048,12 @@ next_dnode:
  next_block:
         blkaddr = datablock_addr(dn.inode, dn.node_page, dn.ofs_in_node);
  
+       if (__is_valid_data_blkaddr(blkaddr) &&
+               !f2fs_is_valid_blkaddr(sbi, blkaddr, DATA_GENERIC)) {
+               err = -EFAULT;
+               goto sync_out;
+       }
+
         if (!is_valid_data_blkaddr(sbi, blkaddr)) {
                 if (create) {
                         if (unlikely(f2fs_cp_error(sbi))) {
@@ -1500,6 +1509,10 @@ got_it:
                                 SetPageUptodate(page);
                                 goto confused;
                         }
+
+                       if (!f2fs_is_valid_blkaddr(F2FS_I_SB(inode), block_nr,
+                                                               DATA_GENERIC))
+                               goto set_error_page;
                 } else {
                         zero_user_segment(page, 0, PAGE_SIZE);
                         if (!PageUptodate(page))
@@ -1700,11 +1713,13 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
                         f2fs_lookup_extent_cache(inode, page->index, &ei)) {
                 fio->old_blkaddr = ei.blk + page->index - ei.fofs;
  
-               if (is_valid_data_blkaddr(fio->sbi, fio->old_blkaddr)) {
-                       ipu_force = true;
-                       fio->need_lock = LOCK_DONE;
-                       goto got_it;
-               }
+               if (!f2fs_is_valid_blkaddr(fio->sbi, fio->old_blkaddr,
+                                                       DATA_GENERIC))
+                       return -EFAULT;
+
+               ipu_force = true;
+               fio->need_lock = LOCK_DONE;
+               goto got_it;
         }
  
         /* Deadlock due to between page->lock and f2fs_lock_op */
@@ -1723,6 +1738,12 @@ int f2fs_do_write_data_page(struct f2fs_io_info *fio)
                 goto out_writepage;
         }
  got_it:
+       if (__is_valid_data_blkaddr(fio->old_blkaddr) &&
+               !f2fs_is_valid_blkaddr(fio->sbi, fio->old_blkaddr,
+                                                       DATA_GENERIC)) {
+               err = -EFAULT;
+               goto out_writepage;
+       }
         /*
          * If current allocation needs SSR,
          * it had better in-place writes for updated data.
diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h

index 75a14d2..c8c865f 100644 (file)
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -2669,6 +2669,9 @@ static inline void f2fs_update_iostat(struct f2fs_sb_info *sbi,
         spin_unlock(&sbi->iostat_lock);
  }
  
+#define __is_meta_io(fio) (PAGE_TYPE_OF_BIO(fio->type) == META &&      \
+                               (!is_read_io(fio->op) || fio->is_meta))
+
  bool f2fs_is_valid_blkaddr(struct f2fs_sb_info *sbi,
                                         block_t blkaddr, int type);
  void f2fs_msg(struct super_block *sb, const char *level, const char *fmt, ...);
diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c

index 0d1ee20..5e29d40 100644 (file)
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -420,6 +420,13 @@ static loff_t f2fs_seek_block(struct file *file, loff_t offset, int whence)
                         blkaddr = datablock_addr(dn.inode,
                                         dn.node_page, dn.ofs_in_node);
  
+                       if (__is_valid_data_blkaddr(blkaddr) &&
+                               !f2fs_is_valid_blkaddr(F2FS_I_SB(inode),
+                                               blkaddr, DATA_GENERIC)) {
+                               f2fs_put_dnode(&dn);
+                               goto fail;
+                       }
+
                         if (__found_offset(F2FS_I_SB(inode), blkaddr, dirty,
                                                         pgofs, whence)) {
                                 f2fs_put_dnode(&dn);
@@ -514,6 +521,11 @@ void f2fs_truncate_data_blocks_range(struct dnode_of_data *dn, int count)
  
                 dn->data_blkaddr = NULL_ADDR;
                 f2fs_set_data_blkaddr(dn);
+
+               if (__is_valid_data_blkaddr(blkaddr) &&
+                       !f2fs_is_valid_blkaddr(sbi, blkaddr, DATA_GENERIC))
+                       continue;
+
                 f2fs_invalidate_blocks(sbi, blkaddr);
                 if (dn->ofs_in_node == 0 && IS_INODE(dn->node_page))
                         clear_inode_flag(dn->inode, FI_FIRST_BLOCK_WRITTEN);
diff --git a/fs/f2fs/inode.c b/fs/f2fs/inode.c

index f490393..b52440f 100644 (file)
--- a/fs/f2fs/inode.c
+++ b/fs/f2fs/inode.c
@@ -236,6 +236,23 @@ static bool sanity_check_inode(struct inode *inode, struct page *node_page)
                         __func__, inode->i_ino);
                 return false;
         }
+
+       if (F2FS_I(inode)->extent_tree) {
+               struct extent_info *ei = &F2FS_I(inode)->extent_tree->largest;
+
+               if (ei->len &&
+                       (!f2fs_is_valid_blkaddr(sbi, ei->blk, DATA_GENERIC) ||
+                       !f2fs_is_valid_blkaddr(sbi, ei->blk + ei->len - 1,
+                                                       DATA_GENERIC))) {
+                       set_sbi_flag(sbi, SBI_NEED_FSCK);
+                       f2fs_msg(sbi->sb, KERN_WARNING,
+                               "%s: inode (ino=%lx) extent info [%u, %u, %u] "
+                               "is incorrect, run fsck to fix",
+                               __func__, inode->i_ino,
+                               ei->blk, ei->fofs, ei->len);
+                       return false;
+               }
+       }
         return true;
  }
  
diff --git a/fs/f2fs/node.c b/fs/f2fs/node.c

index 8266473..b18b752 100644 (file)
--- a/fs/f2fs/node.c
+++ b/fs/f2fs/node.c
@@ -1401,6 +1401,10 @@ static int __write_node_page(struct page *page, bool atomic, bool *submitted,
                 return 0;
         }
  
+       if (__is_valid_data_blkaddr(ni.blk_addr) &&
+               !f2fs_is_valid_blkaddr(sbi, ni.blk_addr, DATA_GENERIC))
+               goto redirty_out;
+
         if (atomic && !test_opt(sbi, NOBARRIER))
                 fio.op_flags |= REQ_PREFLUSH | REQ_FUA;
  
diff --git a/fs/f2fs/segment.h b/fs/f2fs/segment.h

index a7460da..b5bd328 100644 (file)
--- a/fs/f2fs/segment.h
+++ b/fs/f2fs/segment.h
@@ -645,8 +645,7 @@ static inline void verify_block_addr(struct f2fs_io_info *fio, block_t blk_addr)
  {
         struct f2fs_sb_info *sbi = fio->sbi;
  
-       if (PAGE_TYPE_OF_BIO(fio->type) == META &&
-                               (!is_read_io(fio->op) || fio->is_meta))
+       if (__is_meta_io(fio))
                 verify_blkaddr(sbi, blk_addr, META_GENERIC);
         else
                 verify_blkaddr(sbi, blk_addr, DATA_GENERIC);
author	Chao Yu <yuchao0@huawei.com>
	Wed, 1 Aug 2018 11:13:44 +0000 (19:13 +0800)
committer	Jaegeuk Kim <jaegeuk@kernel.org>
	Wed, 1 Aug 2018 18:52:32 +0000 (11:52 -0700)
fs/f2fs/checkpoint.c		patch \| blob \| history
fs/f2fs/data.c		patch \| blob \| history
fs/f2fs/f2fs.h		patch \| blob \| history
fs/f2fs/file.c		patch \| blob \| history
fs/f2fs/inode.c		patch \| blob \| history
fs/f2fs/node.c		patch \| blob \| history
fs/f2fs/segment.h		patch \| blob \| history