7 years ago · c9b60788fc
--- 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;
			
--- 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.
			
--- 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, ...);
			
--- 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);
			
--- 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;
			
 
				 }
			
 
				 
			
--- 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;
			
 
				 
			
--- 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);