Commit 9ab97aea authored by Linus Torvalds's avatar Linus Torvalds
Browse files

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

Pull f2fs updates from Jaegeuk Kim:
 "In this round, we've focused on bug fixes since Pixel devices have
  been shipping with f2fs. Some of them were related to hardware
  encryption support which are actually not an issue in mainline, but
  would be better to merge them in order to avoid potential bugs.

  Enhancements:
   - do GC sub-sections when the section is large
   - add a flag in ioctl(SHUTDOWN) to trigger fsck for QA
   - use kvmalloc() in order to give another chance to avoid ENOMEM

  Bug fixes:
   - fix accessing memory boundaries in a malformed iamge
   - GC gives stale unencrypted block
   - GC counts in large sections
   - detect idle time more precisely
   - block allocation of DIO writes
   - race conditions between write_begin and write_checkpoint
   - allow GCs for node segments via ioctl()

  There are various clean-ups and minor bug fixes as well"

* tag 'f2fs-for-4.21' of git://git.kernel.org/pub/scm/linux/kernel/git/jaegeuk/f2fs: (43 commits)
  f2fs: sanity check of xattr entry size
  f2fs: fix use-after-free issue when accessing sbi->stat_info
  f2fs: check PageWriteback flag for ordered case
  f2fs: fix validation of the block count in sanity_check_raw_super
  f2fs: fix missing unlock(sbi->gc_mutex)
  f2fs: fix to dirty inode synchronously
  f2fs: clean up structure extent_node
  f2fs: fix block address for __check_sit_bitmap
  f2fs: fix sbi->extent_list corruption issue
  f2fs: clean up checkpoint flow
  f2fs: flush stale issued discard candidates
  f2fs: correct wrong spelling, issing_*
  f2fs: use kvmalloc, if kmalloc is failed
  f2fs: remove redundant comment of unused wio_mutex
  f2fs: fix to reorder set_page_dirty and wait_on_page_writeback
  f2fs: clear PG_writeback if IPU failed
  f2fs: add an ioctl() to explicitly trigger fsck later
  f2fs: avoid frequent costly fsck triggers
  f2fs: fix m_may_create to make OPU DIO write correctly
  f2fs: fix to update new block address correctly for OPU
  ...
parents 19530313 64beba05

Documentation/ABI/testing/sysfs-fs-f2fs

+9 −0
Original line number Diff line number Diff line
@@ -92,6 +92,15 @@ Contact: "Jaegeuk Kim" <jaegeuk.kim@samsung.com> 
Description:

		 Controls the number of trials to find a victim segment.



What:		/sys/fs/f2fs/<disk>/migration_granularity

Date:		October 2018

Contact:	"Chao Yu" <yuchao0@huawei.com>

Description:

		 Controls migration granularity of garbage collection on large

		 section, it can let GC move partial segment{s} of one section

		 in one GC cycle, so that dispersing heavy overhead GC to

		 multiple lightweight one.



What:		/sys/fs/f2fs/<disk>/dir_level

Date:		March 2014

Contact:	"Jaegeuk Kim" <jaegeuk.kim@samsung.com>

fs/f2fs/acl.c

+11 −9
Original line number Diff line number Diff line
@@ -160,7 +160,7 @@ static void *f2fs_acl_to_disk(struct f2fs_sb_info *sbi, 
	return (void *)f2fs_acl;



fail:

	kfree(f2fs_acl);

	kvfree(f2fs_acl);

	return ERR_PTR(-EINVAL);

}
@@ -190,7 +190,7 @@ static struct posix_acl *__f2fs_get_acl(struct inode *inode, int type, 
		acl = NULL;

	else

		acl = ERR_PTR(retval);

	kfree(value);

	kvfree(value);



	return acl;

}
@@ -240,7 +240,7 @@ static int __f2fs_set_acl(struct inode *inode, int type, 


	error = f2fs_setxattr(inode, name_index, "", value, size, ipage, 0);



	kfree(value);

	kvfree(value);

	if (!error)

		set_cached_acl(inode, type, acl);
@@ -352,12 +352,14 @@ static int f2fs_acl_create(struct inode *dir, umode_t *mode, 
		return PTR_ERR(p);



	clone = f2fs_acl_clone(p, GFP_NOFS);

	if (!clone)

		goto no_mem;

	if (!clone) {

		ret = -ENOMEM;

		goto release_acl;

	}



	ret = f2fs_acl_create_masq(clone, mode);

	if (ret < 0)

		goto no_mem_clone;

		goto release_clone;



	if (ret == 0)

		posix_acl_release(clone);
@@ -371,11 +373,11 @@ static int f2fs_acl_create(struct inode *dir, umode_t *mode, 


	return 0;



no_mem_clone:

release_clone:

	posix_acl_release(clone);

no_mem:

release_acl:

	posix_acl_release(p);

	return -ENOMEM;

	return ret;

}



int f2fs_init_acl(struct inode *inode, struct inode *dir, struct page *ipage,

fs/f2fs/checkpoint.c

+12 −21
Original line number Diff line number Diff line
@@ -44,7 +44,7 @@ repeat: 
		cond_resched();

		goto repeat;

	}

	f2fs_wait_on_page_writeback(page, META, true);

	f2fs_wait_on_page_writeback(page, META, true, true);

	if (!PageUptodate(page))

		SetPageUptodate(page);

	return page;
@@ -370,9 +370,8 @@ continue_unlock: 
				goto continue_unlock;

			}



			f2fs_wait_on_page_writeback(page, META, true);

			f2fs_wait_on_page_writeback(page, META, true, true);



			BUG_ON(PageWriteback(page));

			if (!clear_page_dirty_for_io(page))

				goto continue_unlock;
@@ -911,7 +910,7 @@ free_fail_no_cp: 
	f2fs_put_page(cp1, 1);

	f2fs_put_page(cp2, 1);

fail_no_cp:

	kfree(sbi->ckpt);

	kvfree(sbi->ckpt);

	return -EINVAL;

}
@@ -1290,11 +1289,11 @@ static void commit_checkpoint(struct f2fs_sb_info *sbi, 
	struct page *page = f2fs_grab_meta_page(sbi, blk_addr);

	int err;



	f2fs_wait_on_page_writeback(page, META, true, true);



	memcpy(page_address(page), src, PAGE_SIZE);

	set_page_dirty(page);



	f2fs_wait_on_page_writeback(page, META, true);

	f2fs_bug_on(sbi, PageWriteback(page));

	set_page_dirty(page);

	if (unlikely(!clear_page_dirty_for_io(page)))

		f2fs_bug_on(sbi, 1);
@@ -1328,11 +1327,9 @@ static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc) 
	int err;



	/* Flush all the NAT/SIT pages */

	while (get_pages(sbi, F2FS_DIRTY_META)) {

	f2fs_sync_meta_pages(sbi, META, LONG_MAX, FS_CP_META_IO);

		if (unlikely(f2fs_cp_error(sbi)))

			break;

	}

	f2fs_bug_on(sbi, get_pages(sbi, F2FS_DIRTY_META) &&

					!f2fs_cp_error(sbi));



	/*

	 * modify checkpoint
@@ -1405,14 +1402,6 @@ static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc) 
		for (i = 0; i < nm_i->nat_bits_blocks; i++)

			f2fs_update_meta_page(sbi, nm_i->nat_bits +

					(i << F2FS_BLKSIZE_BITS), blk + i);



		/* Flush all the NAT BITS pages */

		while (get_pages(sbi, F2FS_DIRTY_META)) {

			f2fs_sync_meta_pages(sbi, META, LONG_MAX,

							FS_CP_META_IO);

			if (unlikely(f2fs_cp_error(sbi)))

				break;

		}

	}



	/* write out checkpoint buffer at block 0 */
@@ -1448,6 +1437,8 @@ static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc) 


	/* Here, we have one bio having CP pack except cp pack 2 page */

	f2fs_sync_meta_pages(sbi, META, LONG_MAX, FS_CP_META_IO);

	f2fs_bug_on(sbi, get_pages(sbi, F2FS_DIRTY_META) &&

					!f2fs_cp_error(sbi));



	/* wait for previous submitted meta pages writeback */

	f2fs_wait_on_all_pages_writeback(sbi);
@@ -1465,7 +1456,7 @@ static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc) 
	 * invalidate intermediate page cache borrowed from meta inode

	 * which are used for migration of encrypted inode's blocks.

	 */

	if (f2fs_sb_has_encrypt(sbi->sb))

	if (f2fs_sb_has_encrypt(sbi))

		invalidate_mapping_pages(META_MAPPING(sbi),

				MAIN_BLKADDR(sbi), MAX_BLKADDR(sbi) - 1);

fs/f2fs/data.c

+112 −48
Original line number Diff line number Diff line
@@ -372,29 +372,6 @@ static bool __has_merged_page(struct f2fs_bio_info *io, struct inode *inode, 
	return false;

}



static bool has_merged_page(struct f2fs_sb_info *sbi, struct inode *inode,

						struct page *page, nid_t ino,

						enum page_type type)

{

	enum page_type btype = PAGE_TYPE_OF_BIO(type);

	enum temp_type temp;

	struct f2fs_bio_info *io;

	bool ret = false;



	for (temp = HOT; temp < NR_TEMP_TYPE; temp++) {

		io = sbi->write_io[btype] + temp;



		down_read(&io->io_rwsem);

		ret = __has_merged_page(io, inode, page, ino);

		up_read(&io->io_rwsem);



		/* TODO: use HOT temp only for meta pages now. */

		if (ret || btype == META)

			break;

	}

	return ret;

}



static void __f2fs_submit_merged_write(struct f2fs_sb_info *sbi,

				enum page_type type, enum temp_type temp)

{
@@ -420,12 +397,18 @@ static void __submit_merged_write_cond(struct f2fs_sb_info *sbi, 
				nid_t ino, enum page_type type, bool force)

{

	enum temp_type temp;



	if (!force && !has_merged_page(sbi, inode, page, ino, type))

		return;

	bool ret = true;



	for (temp = HOT; temp < NR_TEMP_TYPE; temp++) {

		if (!force)	{

			enum page_type btype = PAGE_TYPE_OF_BIO(type);

			struct f2fs_bio_info *io = sbi->write_io[btype] + temp;



			down_read(&io->io_rwsem);

			ret = __has_merged_page(io, inode, page, ino);

			up_read(&io->io_rwsem);

		}

		if (ret)

			__f2fs_submit_merged_write(sbi, type, temp);



		/* TODO: use HOT temp only for meta pages now. */
@@ -643,7 +626,7 @@ static void __set_data_blkaddr(struct dnode_of_data *dn) 
 */

void f2fs_set_data_blkaddr(struct dnode_of_data *dn)

{

	f2fs_wait_on_page_writeback(dn->node_page, NODE, true);

	f2fs_wait_on_page_writeback(dn->node_page, NODE, true, true);

	__set_data_blkaddr(dn);

	if (set_page_dirty(dn->node_page))

		dn->node_changed = true;
@@ -673,7 +656,7 @@ int f2fs_reserve_new_blocks(struct dnode_of_data *dn, blkcnt_t count) 
	trace_f2fs_reserve_new_blocks(dn->inode, dn->nid,

						dn->ofs_in_node, count);



	f2fs_wait_on_page_writeback(dn->node_page, NODE, true);

	f2fs_wait_on_page_writeback(dn->node_page, NODE, true, true);



	for (; count > 0; dn->ofs_in_node++) {

		block_t blkaddr = datablock_addr(dn->inode,
@@ -957,6 +940,9 @@ int f2fs_preallocate_blocks(struct kiocb *iocb, struct iov_iter *from) 
			return err;

	}



	if (direct_io && allow_outplace_dio(inode, iocb, from))

		return 0;



	if (is_inode_flag_set(inode, FI_NO_PREALLOC))

		return 0;
@@ -970,6 +956,7 @@ int f2fs_preallocate_blocks(struct kiocb *iocb, struct iov_iter *from) 
	map.m_next_pgofs = NULL;

	map.m_next_extent = NULL;

	map.m_seg_type = NO_CHECK_TYPE;

	map.m_may_create = true;



	if (direct_io) {

		map.m_seg_type = f2fs_rw_hint_to_seg_type(iocb->ki_hint);
@@ -1028,7 +1015,7 @@ int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map, 
	unsigned int maxblocks = map->m_len;

	struct dnode_of_data dn;

	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);

	int mode = create ? ALLOC_NODE : LOOKUP_NODE;

	int mode = map->m_may_create ? ALLOC_NODE : LOOKUP_NODE;

	pgoff_t pgofs, end_offset, end;

	int err = 0, ofs = 1;

	unsigned int ofs_in_node, last_ofs_in_node;
@@ -1048,6 +1035,10 @@ int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map, 
	end = pgofs + maxblocks;



	if (!create && f2fs_lookup_extent_cache(inode, pgofs, &ei)) {

		if (test_opt(sbi, LFS) && flag == F2FS_GET_BLOCK_DIO &&

							map->m_may_create)

			goto next_dnode;



		map->m_pblk = ei.blk + pgofs - ei.fofs;

		map->m_len = min((pgoff_t)maxblocks, ei.fofs + ei.len - pgofs);

		map->m_flags = F2FS_MAP_MAPPED;
@@ -1062,7 +1053,7 @@ int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map, 
	}



next_dnode:

	if (create)

	if (map->m_may_create)

		__do_map_lock(sbi, flag, true);



	/* When reading holes, we need its node page */
@@ -1099,12 +1090,14 @@ next_block: 


	if (is_valid_data_blkaddr(sbi, blkaddr)) {

		/* use out-place-update for driect IO under LFS mode */

		if (test_opt(sbi, LFS) && create &&

				flag == F2FS_GET_BLOCK_DIO) {

		if (test_opt(sbi, LFS) && flag == F2FS_GET_BLOCK_DIO &&

							map->m_may_create) {

			err = __allocate_data_block(&dn, map->m_seg_type);

			if (!err)

			if (!err) {

				blkaddr = dn.data_blkaddr;

				set_inode_flag(inode, FI_APPEND_WRITE);

			}

		}

	} else {

		if (create) {

			if (unlikely(f2fs_cp_error(sbi))) {
@@ -1209,7 +1202,7 @@ skip: 


	f2fs_put_dnode(&dn);



	if (create) {

	if (map->m_may_create) {

		__do_map_lock(sbi, flag, false);

		f2fs_balance_fs(sbi, dn.node_changed);

	}
@@ -1235,7 +1228,7 @@ sync_out: 
	}

	f2fs_put_dnode(&dn);

unlock_out:

	if (create) {

	if (map->m_may_create) {

		__do_map_lock(sbi, flag, false);

		f2fs_balance_fs(sbi, dn.node_changed);

	}
@@ -1257,6 +1250,7 @@ bool f2fs_overwrite_io(struct inode *inode, loff_t pos, size_t len) 
	map.m_next_pgofs = NULL;

	map.m_next_extent = NULL;

	map.m_seg_type = NO_CHECK_TYPE;

	map.m_may_create = false;

	last_lblk = F2FS_BLK_ALIGN(pos + len);



	while (map.m_lblk < last_lblk) {
@@ -1271,7 +1265,7 @@ bool f2fs_overwrite_io(struct inode *inode, loff_t pos, size_t len) 


static int __get_data_block(struct inode *inode, sector_t iblock,

			struct buffer_head *bh, int create, int flag,

			pgoff_t *next_pgofs, int seg_type)

			pgoff_t *next_pgofs, int seg_type, bool may_write)

{

	struct f2fs_map_blocks map;

	int err;
@@ -1281,6 +1275,7 @@ static int __get_data_block(struct inode *inode, sector_t iblock, 
	map.m_next_pgofs = next_pgofs;

	map.m_next_extent = NULL;

	map.m_seg_type = seg_type;

	map.m_may_create = may_write;



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

	if (!err) {
@@ -1297,7 +1292,16 @@ static int get_data_block(struct inode *inode, sector_t iblock, 
{

	return __get_data_block(inode, iblock, bh_result, create,

							flag, next_pgofs,

							NO_CHECK_TYPE);

							NO_CHECK_TYPE, create);

}



static int get_data_block_dio_write(struct inode *inode, sector_t iblock,

			struct buffer_head *bh_result, int create)

{

	return __get_data_block(inode, iblock, bh_result, create,

				F2FS_GET_BLOCK_DIO, NULL,

				f2fs_rw_hint_to_seg_type(inode->i_write_hint),

				true);

}



static int get_data_block_dio(struct inode *inode, sector_t iblock,
@@ -1305,8 +1309,8 @@ static int get_data_block_dio(struct inode *inode, sector_t iblock, 
{

	return __get_data_block(inode, iblock, bh_result, create,

				F2FS_GET_BLOCK_DIO, NULL,

						f2fs_rw_hint_to_seg_type(

							inode->i_write_hint));

				f2fs_rw_hint_to_seg_type(inode->i_write_hint),

				false);

}



static int get_data_block_bmap(struct inode *inode, sector_t iblock,
@@ -1318,7 +1322,7 @@ static int get_data_block_bmap(struct inode *inode, sector_t iblock, 


	return __get_data_block(inode, iblock, bh_result, create,

						F2FS_GET_BLOCK_BMAP, NULL,

						NO_CHECK_TYPE);

						NO_CHECK_TYPE, create);

}



static inline sector_t logical_to_blk(struct inode *inode, loff_t offset)
@@ -1525,6 +1529,7 @@ static int f2fs_mpage_readpages(struct address_space *mapping, 
	map.m_next_pgofs = NULL;

	map.m_next_extent = NULL;

	map.m_seg_type = NO_CHECK_TYPE;

	map.m_may_create = false;



	for (; nr_pages; nr_pages--) {

		if (pages) {
@@ -1855,6 +1860,8 @@ got_it: 
		if (fio->need_lock == LOCK_REQ)

			f2fs_unlock_op(fio->sbi);

		err = f2fs_inplace_write_data(fio);

		if (err && PageWriteback(page))

			end_page_writeback(page);

		trace_f2fs_do_write_data_page(fio->page, IPU);

		set_inode_flag(inode, FI_UPDATE_WRITE);

		return err;
@@ -2142,12 +2149,11 @@ continue_unlock: 
			if (PageWriteback(page)) {

				if (wbc->sync_mode != WB_SYNC_NONE)

					f2fs_wait_on_page_writeback(page,

								DATA, true);

							DATA, true, true);

				else

					goto continue_unlock;

			}



			BUG_ON(PageWriteback(page));

			if (!clear_page_dirty_for_io(page))

				goto continue_unlock;
@@ -2324,6 +2330,7 @@ static int prepare_write_begin(struct f2fs_sb_info *sbi, 
	bool locked = false;

	struct extent_info ei = {0,0,0};

	int err = 0;

	int flag;



	/*

	 * we already allocated all the blocks, so we don't need to get
@@ -2333,9 +2340,15 @@ static int prepare_write_begin(struct f2fs_sb_info *sbi, 
			!is_inode_flag_set(inode, FI_NO_PREALLOC))

		return 0;



	/* f2fs_lock_op avoids race between write CP and convert_inline_page */

	if (f2fs_has_inline_data(inode) && pos + len > MAX_INLINE_DATA(inode))

		flag = F2FS_GET_BLOCK_DEFAULT;

	else

		flag = F2FS_GET_BLOCK_PRE_AIO;



	if (f2fs_has_inline_data(inode) ||

			(pos & PAGE_MASK) >= i_size_read(inode)) {

		__do_map_lock(sbi, F2FS_GET_BLOCK_PRE_AIO, true);

		__do_map_lock(sbi, flag, true);

		locked = true;

	}

restart:
@@ -2373,6 +2386,7 @@ restart: 
				f2fs_put_dnode(&dn);

				__do_map_lock(sbi, F2FS_GET_BLOCK_PRE_AIO,

								true);

				WARN_ON(flag != F2FS_GET_BLOCK_PRE_AIO);

				locked = true;

				goto restart;

			}
@@ -2386,7 +2400,7 @@ out: 
	f2fs_put_dnode(&dn);

unlock_out:

	if (locked)

		__do_map_lock(sbi, F2FS_GET_BLOCK_PRE_AIO, false);

		__do_map_lock(sbi, flag, false);

	return err;

}
@@ -2457,7 +2471,7 @@ repeat: 
		}

	}



	f2fs_wait_on_page_writeback(page, DATA, false);

	f2fs_wait_on_page_writeback(page, DATA, false, true);



	if (len == PAGE_SIZE || PageUptodate(page))

		return 0;
@@ -2548,6 +2562,53 @@ static int check_direct_IO(struct inode *inode, struct iov_iter *iter, 
	return 0;

}



static void f2fs_dio_end_io(struct bio *bio)

{

	struct f2fs_private_dio *dio = bio->bi_private;



	dec_page_count(F2FS_I_SB(dio->inode),

			dio->write ? F2FS_DIO_WRITE : F2FS_DIO_READ);



	bio->bi_private = dio->orig_private;

	bio->bi_end_io = dio->orig_end_io;



	kvfree(dio);



	bio_endio(bio);

}



static void f2fs_dio_submit_bio(struct bio *bio, struct inode *inode,

							loff_t file_offset)

{

	struct f2fs_private_dio *dio;

	bool write = (bio_op(bio) == REQ_OP_WRITE);

	int err;



	dio = f2fs_kzalloc(F2FS_I_SB(inode),

			sizeof(struct f2fs_private_dio), GFP_NOFS);

	if (!dio) {

		err = -ENOMEM;

		goto out;

	}



	dio->inode = inode;

	dio->orig_end_io = bio->bi_end_io;

	dio->orig_private = bio->bi_private;

	dio->write = write;



	bio->bi_end_io = f2fs_dio_end_io;

	bio->bi_private = dio;



	inc_page_count(F2FS_I_SB(inode),

			write ? F2FS_DIO_WRITE : F2FS_DIO_READ);



	submit_bio(bio);

	return;

out:

	bio->bi_status = BLK_STS_IOERR;

	bio_endio(bio);

}



static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter *iter)

{

	struct address_space *mapping = iocb->ki_filp->f_mapping;
@@ -2594,7 +2655,10 @@ static ssize_t f2fs_direct_IO(struct kiocb *iocb, struct iov_iter *iter) 
			down_read(&fi->i_gc_rwsem[READ]);

	}



	err = blockdev_direct_IO(iocb, inode, iter, get_data_block_dio);

	err = __blockdev_direct_IO(iocb, inode, inode->i_sb->s_bdev,

			iter, rw == WRITE ? get_data_block_dio_write :

			get_data_block_dio, NULL, f2fs_dio_submit_bio,

			DIO_LOCKING | DIO_SKIP_HOLES);



	if (do_opu)

		up_read(&fi->i_gc_rwsem[READ]);

fs/f2fs/debug.c

+9 −16
Original line number Diff line number Diff line
@@ -53,6 +53,8 @@ static void update_general_status(struct f2fs_sb_info *sbi) 
	si->vw_cnt = atomic_read(&sbi->vw_cnt);

	si->max_aw_cnt = atomic_read(&sbi->max_aw_cnt);

	si->max_vw_cnt = atomic_read(&sbi->max_vw_cnt);

	si->nr_dio_read = get_pages(sbi, F2FS_DIO_READ);

	si->nr_dio_write = get_pages(sbi, F2FS_DIO_WRITE);

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

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

	si->nr_rd_data = get_pages(sbi, F2FS_RD_DATA);
@@ -62,7 +64,7 @@ static void update_general_status(struct f2fs_sb_info *sbi) 
		si->nr_flushed =

			atomic_read(&SM_I(sbi)->fcc_info->issued_flush);

		si->nr_flushing =

			atomic_read(&SM_I(sbi)->fcc_info->issing_flush);

			atomic_read(&SM_I(sbi)->fcc_info->queued_flush);

		si->flush_list_empty =

			llist_empty(&SM_I(sbi)->fcc_info->issue_list);

	}
@@ -70,7 +72,7 @@ static void update_general_status(struct f2fs_sb_info *sbi) 
		si->nr_discarded =

			atomic_read(&SM_I(sbi)->dcc_info->issued_discard);

		si->nr_discarding =

			atomic_read(&SM_I(sbi)->dcc_info->issing_discard);

			atomic_read(&SM_I(sbi)->dcc_info->queued_discard);

		si->nr_discard_cmd =

			atomic_read(&SM_I(sbi)->dcc_info->discard_cmd_cnt);

		si->undiscard_blks = SM_I(sbi)->dcc_info->undiscard_blks;
@@ -197,7 +199,7 @@ static void update_mem_info(struct f2fs_sb_info *sbi) 
	si->base_mem += 2 * SIT_VBLOCK_MAP_SIZE * MAIN_SEGS(sbi);

	si->base_mem += SIT_VBLOCK_MAP_SIZE * MAIN_SEGS(sbi);

	si->base_mem += SIT_VBLOCK_MAP_SIZE;

	if (sbi->segs_per_sec > 1)

	if (__is_large_section(sbi))

		si->base_mem += MAIN_SECS(sbi) * sizeof(struct sec_entry);

	si->base_mem += __bitmap_size(sbi, SIT_BITMAP);
@@ -374,6 +376,8 @@ 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, "  - DIO (R: %4d, W: %4d)\n",

			   si->nr_dio_read, si->nr_dio_write);

		seq_printf(s, "  - IO_R (Data: %4d, Node: %4d, Meta: %4d\n",

			   si->nr_rd_data, si->nr_rd_node, si->nr_rd_meta);

		seq_printf(s, "  - IO_W (CP: %4d, Data: %4d, Flush: (%4d %4d %4d), "
@@ -444,18 +448,7 @@ static int stat_show(struct seq_file *s, void *v) 
	return 0;

}



static int stat_open(struct inode *inode, struct file *file)

{

	return single_open(file, stat_show, inode->i_private);

}



static const struct file_operations stat_fops = {

	.owner = THIS_MODULE,

	.open = stat_open,

	.read = seq_read,

	.llseek = seq_lseek,

	.release = single_release,

};

DEFINE_SHOW_ATTRIBUTE(stat);



int f2fs_build_stats(struct f2fs_sb_info *sbi)

{
@@ -510,7 +503,7 @@ void f2fs_destroy_stats(struct f2fs_sb_info *sbi) 
	list_del(&si->stat_list);

	mutex_unlock(&f2fs_stat_mutex);



	kfree(si);

	kvfree(si);

}



int __init f2fs_create_root_stats(void)

CRA Git | Maintained and supported by SUSTech CRA and CCSE