Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 70c8038d authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'for-f2fs-3.17-rc4' of git://git.kernel.org/pub/scm/linux/kernel/git/jaegeuk/f2fs 

Pull f2fs bug fixes from Jaegeuk Kim:
 "This series includes patches to:

   - fix recovery routines
   - fix bugs related to inline_data/xattr
   - fix when casting the dentry names
   - handle EIO or ENOMEM correctly
   - fix memory leak
   - fix lock coverage"

* tag 'for-f2fs-3.17-rc4' of git://git.kernel.org/pub/scm/linux/kernel/git/jaegeuk/f2fs: (28 commits)
  f2fs: reposition unlock_new_inode to prevent accessing invalid inode
  f2fs: fix wrong casting for dentry name
  f2fs: simplify by using a literal
  f2fs: truncate stale block for inline_data
  f2fs: use macro for code readability
  f2fs: introduce need_do_checkpoint for readability
  f2fs: fix incorrect calculation with total/free inode num
  f2fs: remove rename and use rename2
  f2fs: skip if inline_data was converted already
  f2fs: remove rewrite_node_page
  f2fs: avoid double lock in truncate_blocks
  f2fs: prevent checkpoint during roll-forward
  f2fs: add WARN_ON in f2fs_bug_on
  f2fs: handle EIO not to break fs consistency
  f2fs: check s_dirty under cp_mutex
  f2fs: unlock_page when node page is redirtied out
  f2fs: introduce f2fs_cp_error for readability
  f2fs: give a chance to mount again when encountering errors
  f2fs: trigger release_dirty_inode in f2fs_put_super
  f2fs: don't skip checkpoint if there is no dirty node pages
  ...
parents 5a147c9f b73e5282

fs/f2fs/checkpoint.c

+51 −29
Original line number Diff line number Diff line
@@ -160,14 +160,11 @@ static int f2fs_write_meta_page(struct page *page, 
		goto redirty_out;

	if (wbc->for_reclaim)

		goto redirty_out;



	/* Should not write any meta pages, if any IO error was occurred */

	if (unlikely(is_set_ckpt_flags(F2FS_CKPT(sbi), CP_ERROR_FLAG)))

		goto no_write;

	if (unlikely(f2fs_cp_error(sbi)))

		goto redirty_out;



	f2fs_wait_on_page_writeback(page, META);

	write_meta_page(sbi, page);

no_write:

	dec_page_count(sbi, F2FS_DIRTY_META);

	unlock_page(page);

	return 0;
@@ -348,7 +345,7 @@ bool exist_written_data(struct f2fs_sb_info *sbi, nid_t ino, int mode) 
	return e ? true : false;

}



static void release_dirty_inode(struct f2fs_sb_info *sbi)

void release_dirty_inode(struct f2fs_sb_info *sbi)

{

	struct ino_entry *e, *tmp;

	int i;
@@ -446,8 +443,8 @@ static void write_orphan_inodes(struct f2fs_sb_info *sbi, block_t start_blk) 
	struct f2fs_orphan_block *orphan_blk = NULL;

	unsigned int nentries = 0;

	unsigned short index;

	unsigned short orphan_blocks = (unsigned short)((sbi->n_orphans +

		(F2FS_ORPHANS_PER_BLOCK - 1)) / F2FS_ORPHANS_PER_BLOCK);

	unsigned short orphan_blocks =

			(unsigned short)GET_ORPHAN_BLOCKS(sbi->n_orphans);

	struct page *page = NULL;

	struct ino_entry *orphan = NULL;
@@ -737,7 +734,7 @@ retry: 
/*

 * Freeze all the FS-operations for checkpoint.

 */

static void block_operations(struct f2fs_sb_info *sbi)

static int block_operations(struct f2fs_sb_info *sbi)

{

	struct writeback_control wbc = {

		.sync_mode = WB_SYNC_ALL,
@@ -745,6 +742,7 @@ static void block_operations(struct f2fs_sb_info *sbi) 
		.for_reclaim = 0,

	};

	struct blk_plug plug;

	int err = 0;



	blk_start_plug(&plug);
@@ -754,11 +752,15 @@ retry_flush_dents: 
	if (get_pages(sbi, F2FS_DIRTY_DENTS)) {

		f2fs_unlock_all(sbi);

		sync_dirty_dir_inodes(sbi);

		if (unlikely(f2fs_cp_error(sbi))) {

			err = -EIO;

			goto out;

		}

		goto retry_flush_dents;

	}



	/*

	 * POR: we should ensure that there is no dirty node pages

	 * POR: we should ensure that there are no dirty node pages

	 * until finishing nat/sit flush.

	 */

retry_flush_nodes:
@@ -767,9 +769,16 @@ retry_flush_nodes: 
	if (get_pages(sbi, F2FS_DIRTY_NODES)) {

		up_write(&sbi->node_write);

		sync_node_pages(sbi, 0, &wbc);

		if (unlikely(f2fs_cp_error(sbi))) {

			f2fs_unlock_all(sbi);

			err = -EIO;

			goto out;

		}

		goto retry_flush_nodes;

	}

out:

	blk_finish_plug(&plug);

	return err;

}



static void unblock_operations(struct f2fs_sb_info *sbi)
@@ -813,8 +822,11 @@ static void do_checkpoint(struct f2fs_sb_info *sbi, bool is_umount) 
	discard_next_dnode(sbi, NEXT_FREE_BLKADDR(sbi, curseg));



	/* Flush all the NAT/SIT pages */

	while (get_pages(sbi, F2FS_DIRTY_META))

	while (get_pages(sbi, F2FS_DIRTY_META)) {

		sync_meta_pages(sbi, META, LONG_MAX);

		if (unlikely(f2fs_cp_error(sbi)))

			return;

	}



	next_free_nid(sbi, &last_nid);
@@ -825,7 +837,7 @@ static void do_checkpoint(struct f2fs_sb_info *sbi, bool is_umount) 
	ckpt->elapsed_time = cpu_to_le64(get_mtime(sbi));

	ckpt->valid_block_count = cpu_to_le64(valid_user_blocks(sbi));

	ckpt->free_segment_count = cpu_to_le32(free_segments(sbi));

	for (i = 0; i < 3; i++) {

	for (i = 0; i < NR_CURSEG_NODE_TYPE; i++) {

		ckpt->cur_node_segno[i] =

			cpu_to_le32(curseg_segno(sbi, i + CURSEG_HOT_NODE));

		ckpt->cur_node_blkoff[i] =
@@ -833,7 +845,7 @@ static void do_checkpoint(struct f2fs_sb_info *sbi, bool is_umount) 
		ckpt->alloc_type[i + CURSEG_HOT_NODE] =

				curseg_alloc_type(sbi, i + CURSEG_HOT_NODE);

	}

	for (i = 0; i < 3; i++) {

	for (i = 0; i < NR_CURSEG_DATA_TYPE; i++) {

		ckpt->cur_data_segno[i] =

			cpu_to_le32(curseg_segno(sbi, i + CURSEG_HOT_DATA));

		ckpt->cur_data_blkoff[i] =
@@ -848,24 +860,23 @@ static void do_checkpoint(struct f2fs_sb_info *sbi, bool is_umount) 


	/* 2 cp  + n data seg summary + orphan inode blocks */

	data_sum_blocks = npages_for_summary_flush(sbi);

	if (data_sum_blocks < 3)

	if (data_sum_blocks < NR_CURSEG_DATA_TYPE)

		set_ckpt_flags(ckpt, CP_COMPACT_SUM_FLAG);

	else

		clear_ckpt_flags(ckpt, CP_COMPACT_SUM_FLAG);



	orphan_blocks = (sbi->n_orphans + F2FS_ORPHANS_PER_BLOCK - 1)

					/ F2FS_ORPHANS_PER_BLOCK;

	orphan_blocks = GET_ORPHAN_BLOCKS(sbi->n_orphans);

	ckpt->cp_pack_start_sum = cpu_to_le32(1 + cp_payload_blks +

			orphan_blocks);



	if (is_umount) {

		set_ckpt_flags(ckpt, CP_UMOUNT_FLAG);

		ckpt->cp_pack_total_block_count = cpu_to_le32(2 +

		ckpt->cp_pack_total_block_count = cpu_to_le32(F2FS_CP_PACKS+

				cp_payload_blks + data_sum_blocks +

				orphan_blocks + NR_CURSEG_NODE_TYPE);

	} else {

		clear_ckpt_flags(ckpt, CP_UMOUNT_FLAG);

		ckpt->cp_pack_total_block_count = cpu_to_le32(2 +

		ckpt->cp_pack_total_block_count = cpu_to_le32(F2FS_CP_PACKS +

				cp_payload_blks + data_sum_blocks +

				orphan_blocks);

	}
@@ -924,6 +935,9 @@ static void do_checkpoint(struct f2fs_sb_info *sbi, bool is_umount) 
	/* wait for previous submitted node/meta pages writeback */

	wait_on_all_pages_writeback(sbi);



	if (unlikely(f2fs_cp_error(sbi)))

		return;



	filemap_fdatawait_range(NODE_MAPPING(sbi), 0, LONG_MAX);

	filemap_fdatawait_range(META_MAPPING(sbi), 0, LONG_MAX);
@@ -934,15 +948,17 @@ static void do_checkpoint(struct f2fs_sb_info *sbi, bool is_umount) 
	/* Here, we only have one bio having CP pack */

	sync_meta_pages(sbi, META_FLUSH, LONG_MAX);



	if (!is_set_ckpt_flags(ckpt, CP_ERROR_FLAG)) {

		clear_prefree_segments(sbi);

	release_dirty_inode(sbi);



	if (unlikely(f2fs_cp_error(sbi)))

		return;



	clear_prefree_segments(sbi);

	F2FS_RESET_SB_DIRT(sbi);

}

}



/*

 * We guarantee that this checkpoint procedure should not fail.

 * We guarantee that this checkpoint procedure will not fail.

 */

void write_checkpoint(struct f2fs_sb_info *sbi, bool is_umount)

{
@@ -952,7 +968,13 @@ void write_checkpoint(struct f2fs_sb_info *sbi, bool is_umount) 
	trace_f2fs_write_checkpoint(sbi->sb, is_umount, "start block_ops");



	mutex_lock(&sbi->cp_mutex);

	block_operations(sbi);



	if (!sbi->s_dirty)

		goto out;

	if (unlikely(f2fs_cp_error(sbi)))

		goto out;

	if (block_operations(sbi))

		goto out;



	trace_f2fs_write_checkpoint(sbi->sb, is_umount, "finish block_ops");
@@ -976,9 +998,9 @@ void write_checkpoint(struct f2fs_sb_info *sbi, bool is_umount) 
	do_checkpoint(sbi, is_umount);



	unblock_operations(sbi);

	mutex_unlock(&sbi->cp_mutex);



	stat_inc_cp_count(sbi->stat_info);

out:

	mutex_unlock(&sbi->cp_mutex);

	trace_f2fs_write_checkpoint(sbi->sb, is_umount, "finish checkpoint");

}
@@ -999,8 +1021,8 @@ void init_ino_entry_info(struct f2fs_sb_info *sbi) 
	 * for cp pack we can have max 1020*504 orphan entries

	 */

	sbi->n_orphans = 0;

	sbi->max_orphans = (sbi->blocks_per_seg - 2 - NR_CURSEG_TYPE)

				* F2FS_ORPHANS_PER_BLOCK;

	sbi->max_orphans = (sbi->blocks_per_seg - F2FS_CP_PACKS -

			NR_CURSEG_TYPE) * F2FS_ORPHANS_PER_BLOCK;

}



int __init create_checkpoint_caches(void)

fs/f2fs/data.c

+14 −5
Original line number Diff line number Diff line
@@ -53,7 +53,7 @@ static void f2fs_write_end_io(struct bio *bio, int err) 
		struct page *page = bvec->bv_page;



		if (unlikely(err)) {

			SetPageError(page);

			set_page_dirty(page);

			set_bit(AS_EIO, &page->mapping->flags);

			f2fs_stop_checkpoint(sbi);

		}
@@ -739,7 +739,7 @@ static int f2fs_read_data_page(struct file *file, struct page *page) 


	trace_f2fs_readpage(page, DATA);



	/* If the file has inline data, try to read it directlly */

	/* If the file has inline data, try to read it directly */

	if (f2fs_has_inline_data(inode))

		ret = f2fs_read_inline_data(inode, page);

	else
@@ -836,10 +836,19 @@ write: 


	/* Dentry blocks are controlled by checkpoint */

	if (S_ISDIR(inode->i_mode)) {

		if (unlikely(f2fs_cp_error(sbi)))

			goto redirty_out;

		err = do_write_data_page(page, &fio);

		goto done;

	}



	/* we should bypass data pages to proceed the kworkder jobs */

	if (unlikely(f2fs_cp_error(sbi))) {

		SetPageError(page);

		unlock_page(page);

		return 0;

	}



	if (!wbc->for_reclaim)

		need_balance_fs = true;

	else if (has_not_enough_free_secs(sbi, 0))
@@ -927,7 +936,7 @@ static void f2fs_write_failed(struct address_space *mapping, loff_t to) 


	if (to > inode->i_size) {

		truncate_pagecache(inode, inode->i_size);

		truncate_blocks(inode, inode->i_size);

		truncate_blocks(inode, inode->i_size, true);

	}

}
@@ -946,7 +955,7 @@ static int f2fs_write_begin(struct file *file, struct address_space *mapping, 


	f2fs_balance_fs(sbi);

repeat:

	err = f2fs_convert_inline_data(inode, pos + len);

	err = f2fs_convert_inline_data(inode, pos + len, NULL);

	if (err)

		goto fail;

fs/f2fs/debug.c

+2 −2
Original line number Diff line number Diff line
@@ -32,7 +32,7 @@ static void update_general_status(struct f2fs_sb_info *sbi) 
	struct f2fs_stat_info *si = F2FS_STAT(sbi);

	int i;



	/* valid check of the segment numbers */

	/* validation check of the segment numbers */

	si->hit_ext = sbi->read_hit_ext;

	si->total_ext = sbi->total_hit_ext;

	si->ndirty_node = get_pages(sbi, F2FS_DIRTY_NODES);
@@ -152,7 +152,7 @@ static void update_mem_info(struct f2fs_sb_info *sbi) 
	si->base_mem += NR_DIRTY_TYPE * f2fs_bitmap_size(TOTAL_SEGS(sbi));

	si->base_mem += f2fs_bitmap_size(TOTAL_SECS(sbi));



	/* buld nm */

	/* build nm */

	si->base_mem += sizeof(struct f2fs_nm_info);

	si->base_mem += __bitmap_size(sbi, NAT_BITMAP);

fs/f2fs/dir.c

+3 −3
Original line number Diff line number Diff line
@@ -124,7 +124,7 @@ static struct f2fs_dir_entry *find_in_block(struct page *dentry_page, 


		/*

		 * For the most part, it should be a bug when name_len is zero.

		 * We stop here for figuring out where the bugs are occurred.

		 * We stop here for figuring out where the bugs has occurred.

		 */

		f2fs_bug_on(!de->name_len);
@@ -391,7 +391,7 @@ put_error: 
error:

	/* once the failed inode becomes a bad inode, i_mode is S_IFREG */

	truncate_inode_pages(&inode->i_data, 0);

	truncate_blocks(inode, 0);

	truncate_blocks(inode, 0, false);

	remove_dirty_dir_inode(inode);

	remove_inode_page(inode);

	return ERR_PTR(err);

fs/f2fs/f2fs.h

+14 −12
Original line number Diff line number Diff line
@@ -24,7 +24,7 @@ 
#define f2fs_bug_on(condition)	BUG_ON(condition)

#define f2fs_down_write(x, y)	down_write_nest_lock(x, y)

#else

#define f2fs_bug_on(condition)

#define f2fs_bug_on(condition)	WARN_ON(condition)

#define f2fs_down_write(x, y)	down_write(x)

#endif
@@ -395,7 +395,7 @@ enum count_type { 
};



/*

 * The below are the page types of bios used in submti_bio().

 * The below are the page types of bios used in submit_bio().

 * The available types are:

 * DATA			User data pages. It operates as async mode.

 * NODE			Node pages. It operates as async mode.
@@ -799,7 +799,7 @@ static inline block_t __start_cp_addr(struct f2fs_sb_info *sbi) 


	/*

	 * odd numbered checkpoint should at cp segment 0

	 * and even segent must be at cp segment 1

	 * and even segment must be at cp segment 1

	 */

	if (!(ckpt_version & 1))

		start_addr += sbi->blocks_per_seg;
@@ -1096,6 +1096,11 @@ static inline int f2fs_readonly(struct super_block *sb) 
	return sb->s_flags & MS_RDONLY;

}



static inline bool f2fs_cp_error(struct f2fs_sb_info *sbi)

{

	return is_set_ckpt_flags(sbi->ckpt, CP_ERROR_FLAG);

}



static inline void f2fs_stop_checkpoint(struct f2fs_sb_info *sbi)

{

	set_ckpt_flags(sbi->ckpt, CP_ERROR_FLAG);
@@ -1117,7 +1122,7 @@ static inline void f2fs_stop_checkpoint(struct f2fs_sb_info *sbi) 
 */

int f2fs_sync_file(struct file *, loff_t, loff_t, int);

void truncate_data_blocks(struct dnode_of_data *);

int truncate_blocks(struct inode *, u64);

int truncate_blocks(struct inode *, u64, bool);

void f2fs_truncate(struct inode *);

int f2fs_getattr(struct vfsmount *, struct dentry *, struct kstat *);

int f2fs_setattr(struct dentry *, struct iattr *);
@@ -1202,10 +1207,8 @@ int sync_node_pages(struct f2fs_sb_info *, nid_t, struct writeback_control *); 
bool alloc_nid(struct f2fs_sb_info *, nid_t *);

void alloc_nid_done(struct f2fs_sb_info *, nid_t);

void alloc_nid_failed(struct f2fs_sb_info *, nid_t);

void recover_node_page(struct f2fs_sb_info *, struct page *,

		struct f2fs_summary *, struct node_info *, block_t);

void recover_inline_xattr(struct inode *, struct page *);

bool recover_xattr_data(struct inode *, struct page *, block_t);

void recover_xattr_data(struct inode *, struct page *, block_t);

int recover_inode_page(struct f2fs_sb_info *, struct page *);

int restore_node_summary(struct f2fs_sb_info *, unsigned int,

				struct f2fs_summary_block *);
@@ -1238,8 +1241,6 @@ void write_data_page(struct page *, struct dnode_of_data *, block_t *, 
void rewrite_data_page(struct page *, block_t, struct f2fs_io_info *);

void recover_data_page(struct f2fs_sb_info *, struct page *,

				struct f2fs_summary *, block_t, block_t);

void rewrite_node_page(struct f2fs_sb_info *, struct page *,

				struct f2fs_summary *, block_t, block_t);

void allocate_data_block(struct f2fs_sb_info *, struct page *,

		block_t, block_t *, struct f2fs_summary *, int);

void f2fs_wait_on_page_writeback(struct page *, enum page_type);
@@ -1262,6 +1263,7 @@ int ra_meta_pages(struct f2fs_sb_info *, int, int, int); 
long sync_meta_pages(struct f2fs_sb_info *, enum page_type, long);

void add_dirty_inode(struct f2fs_sb_info *, nid_t, int type);

void remove_dirty_inode(struct f2fs_sb_info *, nid_t, int type);

void release_dirty_inode(struct f2fs_sb_info *);

bool exist_written_data(struct f2fs_sb_info *, nid_t, int);

int acquire_orphan_inode(struct f2fs_sb_info *);

void release_orphan_inode(struct f2fs_sb_info *);
@@ -1439,8 +1441,8 @@ extern const struct inode_operations f2fs_special_inode_operations; 
 */

bool f2fs_may_inline(struct inode *);

int f2fs_read_inline_data(struct inode *, struct page *);

int f2fs_convert_inline_data(struct inode *, pgoff_t);

int f2fs_convert_inline_data(struct inode *, pgoff_t, struct page *);

int f2fs_write_inline_data(struct inode *, struct page *, unsigned int);

void truncate_inline_data(struct inode *, u64);

int recover_inline_data(struct inode *, struct page *);

bool recover_inline_data(struct inode *, struct page *);

#endif