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

Commit 09cb6464 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

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

Pull f2fs updates from Jaegeuk Kim:
 "This patch series contains several performance tuning patches
  regarding to the IO submission flow, in addition to supporting new
  features such as a ZBC-base drive and multiple devices.

  It also includes some major bug fixes such as:
   - checkpoint version control
   - fdatasync-related roll-forward recovery routine
   - memory boundary or null-pointer access in corner cases
   - missing error cases

  It has various minor clean-up patches as well"

* tag 'for-f2fs-4.10' of git://git.kernel.org/pub/scm/linux/kernel/git/jaegeuk/f2fs: (66 commits)
  f2fs: fix a missing size change in f2fs_setattr
  f2fs: fix to access nullified flush_cmd_control pointer
  f2fs: free meta pages if sanity check for ckpt is failed
  f2fs: detect wrong layout
  f2fs: call sync_fs when f2fs is idle
  Revert "f2fs: use percpu_counter for # of dirty pages in inode"
  f2fs: return AOP_WRITEPAGE_ACTIVATE for writepage
  f2fs: do not activate auto_recovery for fallocated i_size
  f2fs: fix to determine start_cp_addr by sbi->cur_cp_pack
  f2fs: fix 32-bit build
  f2fs: set ->owner for debugfs status file's file_operations
  f2fs: fix incorrect free inode count in ->statfs
  f2fs: drop duplicate header timer.h
  f2fs: fix wrong AUTO_RECOVER condition
  f2fs: do not recover i_size if it's valid
  f2fs: fix fdatasync
  f2fs: fix to account total free nid correctly
  f2fs: fix an infinite loop when flush nodes in cp
  f2fs: don't wait writeback for datas during checkpoint
  f2fs: fix wrong written_valid_blocks counting
  ...
parents 19d37ce2 c0ed4405

fs/f2fs/acl.c

+1 −1
Original line number Diff line number Diff line
@@ -384,7 +384,7 @@ int f2fs_init_acl(struct inode *inode, struct inode *dir, struct page *ipage, 
	if (error)

		return error;



	f2fs_mark_inode_dirty_sync(inode);

	f2fs_mark_inode_dirty_sync(inode, true);



	if (default_acl) {

		error = __f2fs_set_acl(inode, ACL_TYPE_DEFAULT, default_acl,

fs/f2fs/checkpoint.c

+25 −9
Original line number Diff line number Diff line
@@ -228,7 +228,7 @@ void ra_meta_pages_cond(struct f2fs_sb_info *sbi, pgoff_t index) 
	f2fs_put_page(page, 0);



	if (readahead)

		ra_meta_pages(sbi, index, MAX_BIO_BLOCKS(sbi), META_POR, true);

		ra_meta_pages(sbi, index, BIO_MAX_PAGES, META_POR, true);

}



static int f2fs_write_meta_page(struct page *page,
@@ -770,7 +770,12 @@ int get_valid_checkpoint(struct f2fs_sb_info *sbi) 


	/* Sanity checking of checkpoint */

	if (sanity_check_ckpt(sbi))

		goto fail_no_cp;

		goto free_fail_no_cp;



	if (cur_page == cp1)

		sbi->cur_cp_pack = 1;

	else

		sbi->cur_cp_pack = 2;



	if (cp_blks <= 1)

		goto done;
@@ -793,6 +798,9 @@ int get_valid_checkpoint(struct f2fs_sb_info *sbi) 
	f2fs_put_page(cp2, 1);

	return 0;



free_fail_no_cp:

	f2fs_put_page(cp1, 1);

	f2fs_put_page(cp2, 1);

fail_no_cp:

	kfree(sbi->ckpt);

	return -EINVAL;
@@ -921,6 +929,10 @@ int f2fs_sync_inode_meta(struct f2fs_sb_info *sbi) 
		inode = igrab(&fi->vfs_inode);

		spin_unlock(&sbi->inode_lock[DIRTY_META]);

		if (inode) {

			sync_inode_metadata(inode, 0);



			/* it's on eviction */

			if (is_inode_flag_set(inode, FI_DIRTY_INODE))

				update_inode_page(inode);

			iput(inode);

		}
@@ -987,7 +999,7 @@ static void unblock_operations(struct f2fs_sb_info *sbi) 
{

	up_write(&sbi->node_write);



	build_free_nids(sbi);

	build_free_nids(sbi, false);

	f2fs_unlock_all(sbi);

}
@@ -998,7 +1010,7 @@ static void wait_on_all_pages_writeback(struct f2fs_sb_info *sbi) 
	for (;;) {

		prepare_to_wait(&sbi->cp_wait, &wait, TASK_UNINTERRUPTIBLE);



		if (!atomic_read(&sbi->nr_wb_bios))

		if (!get_pages(sbi, F2FS_WB_CP_DATA))

			break;



		io_schedule_timeout(5*HZ);
@@ -1123,7 +1135,7 @@ static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc) 
				le32_to_cpu(ckpt->checksum_offset)))

				= cpu_to_le32(crc32);



	start_blk = __start_cp_addr(sbi);

	start_blk = __start_cp_next_addr(sbi);



	/* need to wait for end_io results */

	wait_on_all_pages_writeback(sbi);
@@ -1184,9 +1196,9 @@ static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc) 
	if (unlikely(f2fs_cp_error(sbi)))

		return -EIO;



	clear_prefree_segments(sbi, cpc);

	clear_sbi_flag(sbi, SBI_IS_DIRTY);

	clear_sbi_flag(sbi, SBI_NEED_CP);

	__set_cp_next_pack(sbi);



	/*

	 * redirty superblock if metadata like node page or inode cache is
@@ -1261,8 +1273,12 @@ int write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc) 


	/* unlock all the fs_lock[] in do_checkpoint() */

	err = do_checkpoint(sbi, cpc);



	if (err) {

		release_discard_addrs(sbi);

	} else {

		clear_prefree_segments(sbi, cpc);

		f2fs_wait_all_discard_bio(sbi);

	}



	unblock_operations(sbi);

	stat_inc_cp_count(sbi->stat_info);

fs/f2fs/data.c

+127 −65
Original line number Diff line number Diff line
@@ -29,6 +29,26 @@ 
#include "trace.h"

#include <trace/events/f2fs.h>



static bool __is_cp_guaranteed(struct page *page)

{

	struct address_space *mapping = page->mapping;

	struct inode *inode;

	struct f2fs_sb_info *sbi;



	if (!mapping)

		return false;



	inode = mapping->host;

	sbi = F2FS_I_SB(inode);



	if (inode->i_ino == F2FS_META_INO(sbi) ||

			inode->i_ino ==  F2FS_NODE_INO(sbi) ||

			S_ISDIR(inode->i_mode) ||

			is_cold_data(page))

		return true;

	return false;

}



static void f2fs_read_end_io(struct bio *bio)

{

	struct bio_vec *bvec;
@@ -71,6 +91,7 @@ static void f2fs_write_end_io(struct bio *bio) 


	bio_for_each_segment_all(bvec, bio, i) {

		struct page *page = bvec->bv_page;

		enum count_type type = WB_DATA_TYPE(page);



		fscrypt_pullback_bio_page(&page, true);
@@ -78,15 +99,57 @@ static void f2fs_write_end_io(struct bio *bio) 
			mapping_set_error(page->mapping, -EIO);

			f2fs_stop_checkpoint(sbi, true);

		}

		dec_page_count(sbi, type);

		clear_cold_data(page);

		end_page_writeback(page);

	}

	if (atomic_dec_and_test(&sbi->nr_wb_bios) &&

	if (!get_pages(sbi, F2FS_WB_CP_DATA) &&

				wq_has_sleeper(&sbi->cp_wait))

		wake_up(&sbi->cp_wait);



	bio_put(bio);

}



/*

 * Return true, if pre_bio's bdev is same as its target device.

 */

struct block_device *f2fs_target_device(struct f2fs_sb_info *sbi,

				block_t blk_addr, struct bio *bio)

{

	struct block_device *bdev = sbi->sb->s_bdev;

	int i;



	for (i = 0; i < sbi->s_ndevs; i++) {

		if (FDEV(i).start_blk <= blk_addr &&

					FDEV(i).end_blk >= blk_addr) {

			blk_addr -= FDEV(i).start_blk;

			bdev = FDEV(i).bdev;

			break;

		}

	}

	if (bio) {

		bio->bi_bdev = bdev;

		bio->bi_iter.bi_sector = SECTOR_FROM_BLOCK(blk_addr);

	}

	return bdev;

}



int f2fs_target_device_index(struct f2fs_sb_info *sbi, block_t blkaddr)

{

	int i;



	for (i = 0; i < sbi->s_ndevs; i++)

		if (FDEV(i).start_blk <= blkaddr && FDEV(i).end_blk >= blkaddr)

			return i;

	return 0;

}



static bool __same_bdev(struct f2fs_sb_info *sbi,

				block_t blk_addr, struct bio *bio)

{

	return f2fs_target_device(sbi, blk_addr, NULL) == bio->bi_bdev;

}



/*

 * Low-level block read/write IO operations.

 */
@@ -97,8 +160,7 @@ static struct bio *__bio_alloc(struct f2fs_sb_info *sbi, block_t blk_addr, 


	bio = f2fs_bio_alloc(npages);



	bio->bi_bdev = sbi->sb->s_bdev;

	bio->bi_iter.bi_sector = SECTOR_FROM_BLOCK(blk_addr);

	f2fs_target_device(sbi, blk_addr, bio);

	bio->bi_end_io = is_read ? f2fs_read_end_io : f2fs_write_end_io;

	bio->bi_private = is_read ? NULL : sbi;
@@ -109,8 +171,7 @@ static inline void __submit_bio(struct f2fs_sb_info *sbi, 
				struct bio *bio, enum page_type type)

{

	if (!is_read_io(bio_op(bio))) {

		atomic_inc(&sbi->nr_wb_bios);

		if (f2fs_sb_mounted_hmsmr(sbi->sb) &&

		if (f2fs_sb_mounted_blkzoned(sbi->sb) &&

			current->plug && (type == DATA || type == NODE))

			blk_finish_plug(current->plug);

	}
@@ -268,22 +329,24 @@ void f2fs_submit_page_mbio(struct f2fs_io_info *fio) 
		verify_block_addr(sbi, fio->old_blkaddr);

	verify_block_addr(sbi, fio->new_blkaddr);



	bio_page = fio->encrypted_page ? fio->encrypted_page : fio->page;



	if (!is_read)

		inc_page_count(sbi, WB_DATA_TYPE(bio_page));



	down_write(&io->io_rwsem);



	if (io->bio && (io->last_block_in_bio != fio->new_blkaddr - 1 ||

	    (io->fio.op != fio->op || io->fio.op_flags != fio->op_flags)))

	    (io->fio.op != fio->op || io->fio.op_flags != fio->op_flags) ||

			!__same_bdev(sbi, fio->new_blkaddr, io->bio)))

		__submit_merged_bio(io);

alloc_new:

	if (io->bio == NULL) {

		int bio_blocks = MAX_BIO_BLOCKS(sbi);



		io->bio = __bio_alloc(sbi, fio->new_blkaddr,

						bio_blocks, is_read);

						BIO_MAX_PAGES, is_read);

		io->fio = *fio;

	}



	bio_page = fio->encrypted_page ? fio->encrypted_page : fio->page;



	if (bio_add_page(io->bio, bio_page, PAGE_SIZE, 0) <

							PAGE_SIZE) {

		__submit_merged_bio(io);
@@ -588,7 +651,6 @@ static int __allocate_data_block(struct dnode_of_data *dn) 
	struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);

	struct f2fs_summary sum;

	struct node_info ni;

	int seg = CURSEG_WARM_DATA;

	pgoff_t fofs;

	blkcnt_t count = 1;
@@ -606,11 +668,8 @@ static int __allocate_data_block(struct dnode_of_data *dn) 
	get_node_info(sbi, dn->nid, &ni);

	set_summary(&sum, dn->nid, dn->ofs_in_node, ni.version);



	if (dn->ofs_in_node == 0 && dn->inode_page == dn->node_page)

		seg = CURSEG_DIRECT_IO;



	allocate_data_block(sbi, NULL, dn->data_blkaddr, &dn->data_blkaddr,

								&sum, seg);

						&sum, CURSEG_WARM_DATA);

	set_data_blkaddr(dn);



	/* update i_size */
@@ -622,11 +681,18 @@ static int __allocate_data_block(struct dnode_of_data *dn) 
	return 0;

}



ssize_t f2fs_preallocate_blocks(struct kiocb *iocb, struct iov_iter *from)

static inline bool __force_buffered_io(struct inode *inode, int rw)

{

	return ((f2fs_encrypted_inode(inode) && S_ISREG(inode->i_mode)) ||

			(rw == WRITE && test_opt(F2FS_I_SB(inode), LFS)) ||

			F2FS_I_SB(inode)->s_ndevs);

}



int f2fs_preallocate_blocks(struct kiocb *iocb, struct iov_iter *from)

{

	struct inode *inode = file_inode(iocb->ki_filp);

	struct f2fs_map_blocks map;

	ssize_t ret = 0;

	int err = 0;



	map.m_lblk = F2FS_BLK_ALIGN(iocb->ki_pos);

	map.m_len = F2FS_BYTES_TO_BLK(iocb->ki_pos + iov_iter_count(from));
@@ -638,19 +704,22 @@ ssize_t f2fs_preallocate_blocks(struct kiocb *iocb, struct iov_iter *from) 
	map.m_next_pgofs = NULL;



	if (iocb->ki_flags & IOCB_DIRECT) {

		ret = f2fs_convert_inline_inode(inode);

		if (ret)

			return ret;

		return f2fs_map_blocks(inode, &map, 1, F2FS_GET_BLOCK_PRE_DIO);

		err = f2fs_convert_inline_inode(inode);

		if (err)

			return err;

		return f2fs_map_blocks(inode, &map, 1,

			__force_buffered_io(inode, WRITE) ?

				F2FS_GET_BLOCK_PRE_AIO :

				F2FS_GET_BLOCK_PRE_DIO);

	}

	if (iocb->ki_pos + iov_iter_count(from) > MAX_INLINE_DATA) {

		ret = f2fs_convert_inline_inode(inode);

		if (ret)

			return ret;

		err = f2fs_convert_inline_inode(inode);

		if (err)

			return err;

	}

	if (!f2fs_has_inline_data(inode))

		return f2fs_map_blocks(inode, &map, 1, F2FS_GET_BLOCK_PRE_AIO);

	return ret;

	return err;

}



/*
@@ -674,7 +743,6 @@ int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map, 
	unsigned int ofs_in_node, last_ofs_in_node;

	blkcnt_t prealloc;

	struct extent_info ei;

	bool allocated = false;

	block_t blkaddr;



	if (!maxblocks)
@@ -714,7 +782,7 @@ int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map, 
	}



	prealloc = 0;

	ofs_in_node = dn.ofs_in_node;

	last_ofs_in_node = ofs_in_node = dn.ofs_in_node;

	end_offset = ADDRS_PER_PAGE(dn.node_page, inode);



next_block:
@@ -733,10 +801,8 @@ int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map, 
				}

			} else {

				err = __allocate_data_block(&dn);

				if (!err) {

				if (!err)

					set_inode_flag(inode, FI_APPEND_WRITE);

					allocated = true;

				}

			}

			if (err)

				goto sync_out;
@@ -791,7 +857,6 @@ int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map, 
		err = reserve_new_blocks(&dn, prealloc);

		if (err)

			goto sync_out;

		allocated = dn.node_changed;



		map->m_len += dn.ofs_in_node - ofs_in_node;

		if (prealloc && dn.ofs_in_node != last_ofs_in_node + 1) {
@@ -810,9 +875,8 @@ int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map, 


	if (create) {

		f2fs_unlock_op(sbi);

		f2fs_balance_fs(sbi, allocated);

		f2fs_balance_fs(sbi, dn.node_changed);

	}

	allocated = false;

	goto next_dnode;



sync_out:
@@ -820,7 +884,7 @@ int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map, 
unlock_out:

	if (create) {

		f2fs_unlock_op(sbi);

		f2fs_balance_fs(sbi, allocated);

		f2fs_balance_fs(sbi, dn.node_changed);

	}

out:

	trace_f2fs_map_blocks(inode, map, err);
@@ -832,19 +896,19 @@ static int __get_data_block(struct inode *inode, sector_t iblock, 
			pgoff_t *next_pgofs)

{

	struct f2fs_map_blocks map;

	int ret;

	int err;



	map.m_lblk = iblock;

	map.m_len = bh->b_size >> inode->i_blkbits;

	map.m_next_pgofs = next_pgofs;



	ret = f2fs_map_blocks(inode, &map, create, flag);

	if (!ret) {

	err = f2fs_map_blocks(inode, &map, create, flag);

	if (!err) {

		map_bh(bh, inode->i_sb, map.m_pblk);

		bh->b_state = (bh->b_state & ~F2FS_MAP_FLAGS) | map.m_flags;

		bh->b_size = map.m_len << inode->i_blkbits;

	}

	return ret;

	return err;

}



static int get_data_block(struct inode *inode, sector_t iblock,
@@ -889,7 +953,6 @@ int f2fs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo, 
	struct buffer_head map_bh;

	sector_t start_blk, last_blk;

	pgoff_t next_pgofs;

	loff_t isize;

	u64 logical = 0, phys = 0, size = 0;

	u32 flags = 0;

	int ret = 0;
@@ -906,13 +969,6 @@ int f2fs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo, 


	inode_lock(inode);



	isize = i_size_read(inode);

	if (start >= isize)

		goto out;



	if (start + len > isize)

		len = isize - start;



	if (logical_to_blk(inode, len) == 0)

		len = blk_to_logical(inode, 1);
@@ -931,13 +987,11 @@ int f2fs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo, 
	/* HOLE */

	if (!buffer_mapped(&map_bh)) {

		start_blk = next_pgofs;

		/* Go through holes util pass the EOF */

		if (blk_to_logical(inode, start_blk) < isize)



		if (blk_to_logical(inode, start_blk) < blk_to_logical(inode,

					F2FS_I_SB(inode)->max_file_blocks))

			goto prep_next;

		/* Found a hole beyond isize means no more extents.

		 * Note that the premise is that filesystems don't

		 * punch holes beyond isize and keep size unchanged.

		 */



		flags |= FIEMAP_EXTENT_LAST;

	}
@@ -980,7 +1034,6 @@ static struct bio *f2fs_grab_bio(struct inode *inode, block_t blkaddr, 
{

	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);

	struct fscrypt_ctx *ctx = NULL;

	struct block_device *bdev = sbi->sb->s_bdev;

	struct bio *bio;



	if (f2fs_encrypted_inode(inode) && S_ISREG(inode->i_mode)) {
@@ -998,8 +1051,7 @@ static struct bio *f2fs_grab_bio(struct inode *inode, block_t blkaddr, 
			fscrypt_release_ctx(ctx);

		return ERR_PTR(-ENOMEM);

	}

	bio->bi_bdev = bdev;

	bio->bi_iter.bi_sector = SECTOR_FROM_BLOCK(blkaddr);

	f2fs_target_device(sbi, blkaddr, bio);

	bio->bi_end_io = f2fs_read_end_io;

	bio->bi_private = ctx;
@@ -1094,7 +1146,8 @@ static int f2fs_mpage_readpages(struct address_space *mapping, 
		 * This page will go to BIO.  Do we need to send this

		 * BIO off first?

		 */

		if (bio && (last_block_in_bio != block_nr - 1)) {

		if (bio && (last_block_in_bio != block_nr - 1 ||

			!__same_bdev(F2FS_I_SB(inode), block_nr, bio))) {

submit_and_realloc:

			__submit_bio(F2FS_I_SB(inode), bio, DATA);

			bio = NULL;
@@ -1309,7 +1362,6 @@ static int f2fs_write_data_page(struct page *page, 
	if (err && err != -ENOENT)

		goto redirty_out;



	clear_cold_data(page);

out:

	inode_dec_dirty_pages(inode);

	if (err)
@@ -1330,6 +1382,8 @@ static int f2fs_write_data_page(struct page *page, 


redirty_out:

	redirty_page_for_writepage(wbc, page);

	if (!err)

		return AOP_WRITEPAGE_ACTIVATE;

	unlock_page(page);

	return err;

}
@@ -1425,6 +1479,15 @@ static int f2fs_write_cache_pages(struct address_space *mapping, 


			ret = mapping->a_ops->writepage(page, wbc);

			if (unlikely(ret)) {

				/*

				 * keep nr_to_write, since vfs uses this to

				 * get # of written pages.

				 */

				if (ret == AOP_WRITEPAGE_ACTIVATE) {

					unlock_page(page);

					ret = 0;

					continue;

				}

				done_index = page->index + 1;

				done = 1;

				break;
@@ -1712,7 +1775,6 @@ static int f2fs_write_end(struct file *file, 
		goto unlock_out;



	set_page_dirty(page);

	clear_cold_data(page);



	if (pos + copied > i_size_read(inode))

		f2fs_i_size_write(inode, pos + copied);
@@ -1749,9 +1811,7 @@ static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter *iter) 
	if (err)

		return err;



	if (f2fs_encrypted_inode(inode) && S_ISREG(inode->i_mode))

		return 0;

	if (test_opt(F2FS_I_SB(inode), LFS))

	if (__force_buffered_io(inode, rw))

		return 0;



	trace_f2fs_direct_IO_enter(inode, offset, count, rw);
@@ -1783,12 +1843,14 @@ void f2fs_invalidate_page(struct page *page, unsigned int offset, 
		return;



	if (PageDirty(page)) {

		if (inode->i_ino == F2FS_META_INO(sbi))

		if (inode->i_ino == F2FS_META_INO(sbi)) {

			dec_page_count(sbi, F2FS_DIRTY_META);

		else if (inode->i_ino == F2FS_NODE_INO(sbi))

		} else if (inode->i_ino == F2FS_NODE_INO(sbi)) {

			dec_page_count(sbi, F2FS_DIRTY_NODES);

		else

		} else {

			inode_dec_dirty_pages(inode);

			remove_dirty_inode(inode);

		}

	}



	/* This is atomic written page, keep Private */

fs/f2fs/debug.c

+17 −12
Original line number Diff line number Diff line
@@ -50,7 +50,8 @@ static void update_general_status(struct f2fs_sb_info *sbi) 
	si->ndirty_files = sbi->ndirty_inode[FILE_INODE];

	si->ndirty_all = sbi->ndirty_inode[DIRTY_META];

	si->inmem_pages = get_pages(sbi, F2FS_INMEM_PAGES);

	si->wb_bios = atomic_read(&sbi->nr_wb_bios);

	si->nr_wb_cp_data = get_pages(sbi, F2FS_WB_CP_DATA);

	si->nr_wb_data = get_pages(sbi, F2FS_WB_DATA);

	si->total_count = (int)sbi->user_block_count / sbi->blocks_per_seg;

	si->rsvd_segs = reserved_segments(sbi);

	si->overp_segs = overprovision_segments(sbi);
@@ -74,7 +75,8 @@ static void update_general_status(struct f2fs_sb_info *sbi) 
	si->dirty_nats = NM_I(sbi)->dirty_nat_cnt;

	si->sits = MAIN_SEGS(sbi);

	si->dirty_sits = SIT_I(sbi)->dirty_sentries;

	si->fnids = NM_I(sbi)->fcnt;

	si->free_nids = NM_I(sbi)->nid_cnt[FREE_NID_LIST];

	si->alloc_nids = NM_I(sbi)->nid_cnt[ALLOC_NID_LIST];

	si->bg_gc = sbi->bg_gc;

	si->util_free = (int)(free_user_blocks(sbi) >> sbi->log_blocks_per_seg)

		* 100 / (int)(sbi->user_block_count >> sbi->log_blocks_per_seg)
@@ -194,7 +196,9 @@ static void update_mem_info(struct f2fs_sb_info *sbi) 
		si->cache_mem += sizeof(struct flush_cmd_control);



	/* free nids */

	si->cache_mem += NM_I(sbi)->fcnt * sizeof(struct free_nid);

	si->cache_mem += (NM_I(sbi)->nid_cnt[FREE_NID_LIST] +

				NM_I(sbi)->nid_cnt[ALLOC_NID_LIST]) *

				sizeof(struct free_nid);

	si->cache_mem += NM_I(sbi)->nat_cnt * sizeof(struct nat_entry);

	si->cache_mem += NM_I(sbi)->dirty_nat_cnt *

					sizeof(struct nat_entry_set);
@@ -310,22 +314,22 @@ static int stat_show(struct seq_file *s, void *v) 
		seq_printf(s, "  - Inner Struct Count: tree: %d(%d), node: %d\n",

				si->ext_tree, si->zombie_tree, si->ext_node);

		seq_puts(s, "\nBalancing F2FS Async:\n");

		seq_printf(s, "  - inmem: %4lld, wb_bios: %4d\n",

			   si->inmem_pages, si->wb_bios);

		seq_printf(s, "  - nodes: %4lld in %4d\n",

		seq_printf(s, "  - inmem: %4d, wb_cp_data: %4d, wb_data: %4d\n",

			   si->inmem_pages, si->nr_wb_cp_data, si->nr_wb_data);

		seq_printf(s, "  - nodes: %4d in %4d\n",

			   si->ndirty_node, si->node_pages);

		seq_printf(s, "  - dents: %4lld in dirs:%4d (%4d)\n",

		seq_printf(s, "  - dents: %4d in dirs:%4d (%4d)\n",

			   si->ndirty_dent, si->ndirty_dirs, si->ndirty_all);

		seq_printf(s, "  - datas: %4lld in files:%4d\n",

		seq_printf(s, "  - datas: %4d in files:%4d\n",

			   si->ndirty_data, si->ndirty_files);

		seq_printf(s, "  - meta: %4lld in %4d\n",

		seq_printf(s, "  - meta: %4d in %4d\n",

			   si->ndirty_meta, si->meta_pages);

		seq_printf(s, "  - imeta: %4lld\n",

		seq_printf(s, "  - imeta: %4d\n",

			   si->ndirty_imeta);

		seq_printf(s, "  - NATs: %9d/%9d\n  - SITs: %9d/%9d\n",

			   si->dirty_nats, si->nats, si->dirty_sits, si->sits);

		seq_printf(s, "  - free_nids: %9d\n",

			   si->fnids);

		seq_printf(s, "  - free_nids: %9d, alloc_nids: %9d\n",

			   si->free_nids, si->alloc_nids);

		seq_puts(s, "\nDistribution of User Blocks:");

		seq_puts(s, " [ valid | invalid | free ]\n");

		seq_puts(s, "  [");
@@ -373,6 +377,7 @@ static int stat_open(struct inode *inode, struct file *file) 
}



static const struct file_operations stat_fops = {

	.owner = THIS_MODULE,

	.open = stat_open,

	.read = seq_read,

	.llseek = seq_lseek,

fs/f2fs/dir.c

+17 −13
Original line number Diff line number Diff line
@@ -136,7 +136,7 @@ struct f2fs_dir_entry *find_target_dentry(struct fscrypt_name *fname, 


		/* show encrypted name */

		if (fname->hash) {

			if (de->hash_code == fname->hash)

			if (de->hash_code == cpu_to_le32(fname->hash))

				goto found;

		} else if (de_name.len == name->len &&

			de->hash_code == namehash &&
@@ -313,7 +313,7 @@ void f2fs_set_link(struct inode *dir, struct f2fs_dir_entry *de, 
	set_page_dirty(page);



	dir->i_mtime = dir->i_ctime = current_time(dir);

	f2fs_mark_inode_dirty_sync(dir);

	f2fs_mark_inode_dirty_sync(dir, false);

	f2fs_put_page(page, 1);

}
@@ -466,7 +466,7 @@ void update_parent_metadata(struct inode *dir, struct inode *inode, 
		clear_inode_flag(inode, FI_NEW_INODE);

	}

	dir->i_mtime = dir->i_ctime = current_time(dir);

	f2fs_mark_inode_dirty_sync(dir);

	f2fs_mark_inode_dirty_sync(dir, false);



	if (F2FS_I(dir)->i_current_depth != current_depth)

		f2fs_i_depth_write(dir, current_depth);
@@ -731,7 +731,7 @@ void f2fs_delete_entry(struct f2fs_dir_entry *dentry, struct page *page, 
	set_page_dirty(page);



	dir->i_ctime = dir->i_mtime = current_time(dir);

	f2fs_mark_inode_dirty_sync(dir);

	f2fs_mark_inode_dirty_sync(dir, false);



	if (inode)

		f2fs_drop_nlink(dir, inode);
@@ -742,6 +742,7 @@ void f2fs_delete_entry(struct f2fs_dir_entry *dentry, struct page *page, 
		ClearPagePrivate(page);

		ClearPageUptodate(page);

		inode_dec_dirty_pages(dir);

		remove_dirty_inode(dir);

	}

	f2fs_put_page(page, 1);

}
@@ -784,7 +785,7 @@ bool f2fs_empty_dir(struct inode *dir) 
	return true;

}



bool f2fs_fill_dentries(struct dir_context *ctx, struct f2fs_dentry_ptr *d,

int f2fs_fill_dentries(struct dir_context *ctx, struct f2fs_dentry_ptr *d,

			unsigned int start_pos, struct fscrypt_str *fstr)

{

	unsigned char d_type = DT_UNKNOWN;
@@ -819,7 +820,7 @@ bool f2fs_fill_dentries(struct dir_context *ctx, struct f2fs_dentry_ptr *d, 
						(u32)de->hash_code, 0,

						&de_name, fstr);

			if (err)

				return true;

				return err;



			de_name = *fstr;

			fstr->len = save_len;
@@ -827,12 +828,12 @@ bool f2fs_fill_dentries(struct dir_context *ctx, struct f2fs_dentry_ptr *d, 


		if (!dir_emit(ctx, de_name.name, de_name.len,

					le32_to_cpu(de->ino), d_type))

			return true;

			return 1;



		bit_pos += GET_DENTRY_SLOTS(le16_to_cpu(de->name_len));

		ctx->pos = start_pos + bit_pos;

	}

	return false;

	return 0;

}



static int f2fs_readdir(struct file *file, struct dir_context *ctx)
@@ -871,17 +872,21 @@ static int f2fs_readdir(struct file *file, struct dir_context *ctx) 
		dentry_page = get_lock_data_page(inode, n, false);

		if (IS_ERR(dentry_page)) {

			err = PTR_ERR(dentry_page);

			if (err == -ENOENT)

			if (err == -ENOENT) {

				err = 0;

				continue;

			else

			} else {

				goto out;

			}

		}



		dentry_blk = kmap(dentry_page);



		make_dentry_ptr(inode, &d, (void *)dentry_blk, 1);



		if (f2fs_fill_dentries(ctx, &d, n * NR_DENTRY_IN_BLOCK, &fstr)) {

		err = f2fs_fill_dentries(ctx, &d,

				n * NR_DENTRY_IN_BLOCK, &fstr);

		if (err) {

			kunmap(dentry_page);

			f2fs_put_page(dentry_page, 1);

			break;
@@ -891,10 +896,9 @@ static int f2fs_readdir(struct file *file, struct dir_context *ctx) 
		kunmap(dentry_page);

		f2fs_put_page(dentry_page, 1);

	}

	err = 0;

out:

	fscrypt_fname_free_buffer(&fstr);

	return err;

	return err < 0 ? err : 0;

}



static int f2fs_dir_open(struct inode *inode, struct file *filp)