Commit 4d57b86d authored by Chao Yu's avatar Chao Yu Committed by Jaegeuk Kim
Browse files

f2fs: clean up symbol namespace 



As Ted reported:

"Hi, I was looking at f2fs's sources recently, and I noticed that there
is a very large number of non-static symbols which don't have a f2fs
prefix.  There's well over a hundred (see attached below).

As one example, in fs/f2fs/dir.c there is:

unsigned char get_de_type(struct f2fs_dir_entry *de)

This function is clearly only useful for f2fs, but it has a generic
name.  This means that if any other file system tries to have the same
symbol name, there will be a symbol conflict and the kernel would not
successfully build.  It also means that when someone is looking f2fs
sources, it's not at all obvious whether a function such as
read_data_page(), invalidate_blocks(), is a generic kernel function
found in the fs, mm, or block layers, or a f2fs specific function.

You might want to fix this at some point.  Hopefully Kent's bcachefs
isn't similarly using genericly named functions, since that might
cause conflicts with f2fs's functions --- but just as this would be a
problem that we would rightly insist that Kent fix, this is something
that we should have rightly insisted that f2fs should have fixed
before it was integrated into the mainline kernel.

acquire_orphan_inode
add_ino_entry
add_orphan_inode
allocate_data_block
allocate_new_segments
alloc_nid
alloc_nid_done
alloc_nid_failed
available_free_memory
...."

This patch adds "f2fs_" prefix for all non-static symbols in order to:
a) avoid conflict with other kernel generic symbols;
b) to indicate the function is f2fs specific one instead of generic
one;

Reported-by: default avatarTheodore Ts'o <tytso@mit.edu>
Signed-off-by: default avatarChao Yu <yuchao0@huawei.com>
Signed-off-by: default avatarJaegeuk Kim <jaegeuk@kernel.org>
parent 2e79d951

fs/f2fs/checkpoint.c

+68 −66
Original line number Diff line number Diff line
@@ -24,7 +24,7 @@ 
#include <trace/events/f2fs.h>



static struct kmem_cache *ino_entry_slab;

struct kmem_cache *inode_entry_slab;

struct kmem_cache *f2fs_inode_entry_slab;



void f2fs_stop_checkpoint(struct f2fs_sb_info *sbi, bool end_io)

{
@@ -36,7 +36,7 @@ void f2fs_stop_checkpoint(struct f2fs_sb_info *sbi, bool end_io) 
/*

 * We guarantee no failure on the returned page.

 */

struct page *grab_meta_page(struct f2fs_sb_info *sbi, pgoff_t index)

struct page *f2fs_grab_meta_page(struct f2fs_sb_info *sbi, pgoff_t index)

{

	struct address_space *mapping = META_MAPPING(sbi);

	struct page *page = NULL;
@@ -108,18 +108,19 @@ out: 
	return page;

}



struct page *get_meta_page(struct f2fs_sb_info *sbi, pgoff_t index)

struct page *f2fs_get_meta_page(struct f2fs_sb_info *sbi, pgoff_t index)

{

	return __get_meta_page(sbi, index, true);

}



/* for POR only */

struct page *get_tmp_page(struct f2fs_sb_info *sbi, pgoff_t index)

struct page *f2fs_get_tmp_page(struct f2fs_sb_info *sbi, pgoff_t index)

{

	return __get_meta_page(sbi, index, false);

}



bool is_valid_meta_blkaddr(struct f2fs_sb_info *sbi, block_t blkaddr, int type)

bool f2fs_is_valid_meta_blkaddr(struct f2fs_sb_info *sbi,

					block_t blkaddr, int type)

{

	switch (type) {

	case META_NAT:
@@ -153,7 +154,7 @@ bool is_valid_meta_blkaddr(struct f2fs_sb_info *sbi, block_t blkaddr, int type) 
/*

 * Readahead CP/NAT/SIT/SSA pages

 */

int ra_meta_pages(struct f2fs_sb_info *sbi, block_t start, int nrpages,

int f2fs_ra_meta_pages(struct f2fs_sb_info *sbi, block_t start, int nrpages,

							int type, bool sync)

{

	struct page *page;
@@ -175,7 +176,7 @@ int ra_meta_pages(struct f2fs_sb_info *sbi, block_t start, int nrpages, 
	blk_start_plug(&plug);

	for (; nrpages-- > 0; blkno++) {



		if (!is_valid_meta_blkaddr(sbi, blkno, type))

		if (!f2fs_is_valid_meta_blkaddr(sbi, blkno, type))

			goto out;



		switch (type) {
@@ -219,7 +220,7 @@ out: 
	return blkno - start;

}



void ra_meta_pages_cond(struct f2fs_sb_info *sbi, pgoff_t index)

void f2fs_ra_meta_pages_cond(struct f2fs_sb_info *sbi, pgoff_t index)

{

	struct page *page;

	bool readahead = false;
@@ -230,7 +231,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, BIO_MAX_PAGES, META_POR, true);

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

}



static int __f2fs_write_meta_page(struct page *page,
@@ -251,7 +252,7 @@ static int __f2fs_write_meta_page(struct page *page, 
	if (wbc->for_reclaim && page->index < GET_SUM_BLOCK(sbi, 0))

		goto redirty_out;



	write_meta_page(sbi, page, io_type);

	f2fs_do_write_meta_page(sbi, page, io_type);

	dec_page_count(sbi, F2FS_DIRTY_META);



	if (wbc->for_reclaim)
@@ -296,7 +297,7 @@ static int f2fs_write_meta_pages(struct address_space *mapping, 


	trace_f2fs_writepages(mapping->host, wbc, META);

	diff = nr_pages_to_write(sbi, META, wbc);

	written = sync_meta_pages(sbi, META, wbc->nr_to_write, FS_META_IO);

	written = f2fs_sync_meta_pages(sbi, META, wbc->nr_to_write, FS_META_IO);

	mutex_unlock(&sbi->cp_mutex);

	wbc->nr_to_write = max((long)0, wbc->nr_to_write - written - diff);

	return 0;
@@ -307,7 +308,7 @@ skip_write: 
	return 0;

}



long sync_meta_pages(struct f2fs_sb_info *sbi, enum page_type type,

long f2fs_sync_meta_pages(struct f2fs_sb_info *sbi, enum page_type type,

				long nr_to_write, enum iostat_type io_type)

{

	struct address_space *mapping = META_MAPPING(sbi);
@@ -457,20 +458,20 @@ static void __remove_ino_entry(struct f2fs_sb_info *sbi, nid_t ino, int type) 
	spin_unlock(&im->ino_lock);

}



void add_ino_entry(struct f2fs_sb_info *sbi, nid_t ino, int type)

void f2fs_add_ino_entry(struct f2fs_sb_info *sbi, nid_t ino, int type)

{

	/* add new dirty ino entry into list */

	__add_ino_entry(sbi, ino, 0, type);

}



void remove_ino_entry(struct f2fs_sb_info *sbi, nid_t ino, int type)

void f2fs_remove_ino_entry(struct f2fs_sb_info *sbi, nid_t ino, int type)

{

	/* remove dirty ino entry from list */

	__remove_ino_entry(sbi, ino, type);

}



/* mode should be APPEND_INO or UPDATE_INO */

bool exist_written_data(struct f2fs_sb_info *sbi, nid_t ino, int mode)

bool f2fs_exist_written_data(struct f2fs_sb_info *sbi, nid_t ino, int mode)

{

	struct inode_management *im = &sbi->im[mode];

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

}



void release_ino_entry(struct f2fs_sb_info *sbi, bool all)

void f2fs_release_ino_entry(struct f2fs_sb_info *sbi, bool all)

{

	struct ino_entry *e, *tmp;

	int i;
@@ -500,13 +501,13 @@ void release_ino_entry(struct f2fs_sb_info *sbi, bool all) 
	}

}



void set_dirty_device(struct f2fs_sb_info *sbi, nid_t ino,

void f2fs_set_dirty_device(struct f2fs_sb_info *sbi, nid_t ino,

					unsigned int devidx, int type)

{

	__add_ino_entry(sbi, ino, devidx, type);

}



bool is_dirty_device(struct f2fs_sb_info *sbi, nid_t ino,

bool f2fs_is_dirty_device(struct f2fs_sb_info *sbi, nid_t ino,

					unsigned int devidx, int type)

{

	struct inode_management *im = &sbi->im[type];
@@ -521,7 +522,7 @@ bool is_dirty_device(struct f2fs_sb_info *sbi, nid_t ino, 
	return is_dirty;

}



int acquire_orphan_inode(struct f2fs_sb_info *sbi)

int f2fs_acquire_orphan_inode(struct f2fs_sb_info *sbi)

{

	struct inode_management *im = &sbi->im[ORPHAN_INO];

	int err = 0;
@@ -544,7 +545,7 @@ int acquire_orphan_inode(struct f2fs_sb_info *sbi) 
	return err;

}



void release_orphan_inode(struct f2fs_sb_info *sbi)

void f2fs_release_orphan_inode(struct f2fs_sb_info *sbi)

{

	struct inode_management *im = &sbi->im[ORPHAN_INO];
@@ -554,14 +555,14 @@ void release_orphan_inode(struct f2fs_sb_info *sbi) 
	spin_unlock(&im->ino_lock);

}



void add_orphan_inode(struct inode *inode)

void f2fs_add_orphan_inode(struct inode *inode)

{

	/* add new orphan ino entry into list */

	__add_ino_entry(F2FS_I_SB(inode), inode->i_ino, 0, ORPHAN_INO);

	update_inode_page(inode);

	f2fs_update_inode_page(inode);

}



void remove_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino)

void f2fs_remove_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino)

{

	/* remove orphan entry from orphan list */

	__remove_ino_entry(sbi, ino, ORPHAN_INO);
@@ -571,7 +572,7 @@ static int recover_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino) 
{

	struct inode *inode;

	struct node_info ni;

	int err = acquire_orphan_inode(sbi);

	int err = f2fs_acquire_orphan_inode(sbi);



	if (err)

		goto err_out;
@@ -599,7 +600,7 @@ static int recover_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino) 
	/* truncate all the data during iput */

	iput(inode);



	get_node_info(sbi, ino, &ni);

	f2fs_get_node_info(sbi, ino, &ni);



	/* ENOMEM was fully retried in f2fs_evict_inode. */

	if (ni.blk_addr != NULL_ADDR) {
@@ -617,7 +618,7 @@ err_out: 
	return err;

}



int recover_orphan_inodes(struct f2fs_sb_info *sbi)

int f2fs_recover_orphan_inodes(struct f2fs_sb_info *sbi)

{

	block_t start_blk, orphan_blocks, i, j;

	unsigned int s_flags = sbi->sb->s_flags;
@@ -645,10 +646,10 @@ int recover_orphan_inodes(struct f2fs_sb_info *sbi) 
	start_blk = __start_cp_addr(sbi) + 1 + __cp_payload(sbi);

	orphan_blocks = __start_sum_addr(sbi) - 1 - __cp_payload(sbi);



	ra_meta_pages(sbi, start_blk, orphan_blocks, META_CP, true);

	f2fs_ra_meta_pages(sbi, start_blk, orphan_blocks, META_CP, true);



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

		struct page *page = get_meta_page(sbi, start_blk + i);

		struct page *page = f2fs_get_meta_page(sbi, start_blk + i);

		struct f2fs_orphan_block *orphan_blk;



		orphan_blk = (struct f2fs_orphan_block *)page_address(page);
@@ -698,7 +699,7 @@ static void write_orphan_inodes(struct f2fs_sb_info *sbi, block_t start_blk) 
	/* loop for each orphan inode entry and write them in Jornal block */

	list_for_each_entry(orphan, head, list) {

		if (!page) {

			page = grab_meta_page(sbi, start_blk++);

			page = f2fs_grab_meta_page(sbi, start_blk++);

			orphan_blk =

				(struct f2fs_orphan_block *)page_address(page);

			memset(orphan_blk, 0, sizeof(*orphan_blk));
@@ -740,7 +741,7 @@ static int get_checkpoint_version(struct f2fs_sb_info *sbi, block_t cp_addr, 
	size_t crc_offset = 0;

	__u32 crc = 0;



	*cp_page = get_meta_page(sbi, cp_addr);

	*cp_page = f2fs_get_meta_page(sbi, cp_addr);

	*cp_block = (struct f2fs_checkpoint *)page_address(*cp_page);



	crc_offset = le32_to_cpu((*cp_block)->checksum_offset);
@@ -793,7 +794,7 @@ invalid_cp1: 
	return NULL;

}



int get_valid_checkpoint(struct f2fs_sb_info *sbi)

int f2fs_get_valid_checkpoint(struct f2fs_sb_info *sbi)

{

	struct f2fs_checkpoint *cp_block;

	struct f2fs_super_block *fsb = sbi->raw_super;
@@ -837,7 +838,7 @@ int get_valid_checkpoint(struct f2fs_sb_info *sbi) 
	memcpy(sbi->ckpt, cp_block, blk_size);



	/* Sanity checking of checkpoint */

	if (sanity_check_ckpt(sbi))

	if (f2fs_sanity_check_ckpt(sbi))

		goto free_fail_no_cp;



	if (cur_page == cp1)
@@ -856,7 +857,7 @@ int get_valid_checkpoint(struct f2fs_sb_info *sbi) 
		void *sit_bitmap_ptr;

		unsigned char *ckpt = (unsigned char *)sbi->ckpt;



		cur_page = get_meta_page(sbi, cp_blk_no + i);

		cur_page = f2fs_get_meta_page(sbi, cp_blk_no + i);

		sit_bitmap_ptr = page_address(cur_page);

		memcpy(ckpt + i * blk_size, sit_bitmap_ptr, blk_size);

		f2fs_put_page(cur_page, 1);
@@ -901,7 +902,7 @@ static void __remove_dirty_inode(struct inode *inode, enum inode_type type) 
	stat_dec_dirty_inode(F2FS_I_SB(inode), type);

}



void update_dirty_page(struct inode *inode, struct page *page)

void f2fs_update_dirty_page(struct inode *inode, struct page *page)

{

	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);

	enum inode_type type = S_ISDIR(inode->i_mode) ? DIR_INODE : FILE_INODE;
@@ -920,7 +921,7 @@ void update_dirty_page(struct inode *inode, struct page *page) 
	f2fs_trace_pid(page);

}



void remove_dirty_inode(struct inode *inode)

void f2fs_remove_dirty_inode(struct inode *inode)

{

	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);

	enum inode_type type = S_ISDIR(inode->i_mode) ? DIR_INODE : FILE_INODE;
@@ -937,7 +938,7 @@ void remove_dirty_inode(struct inode *inode) 
	spin_unlock(&sbi->inode_lock[type]);

}



int sync_dirty_inodes(struct f2fs_sb_info *sbi, enum inode_type type)

int f2fs_sync_dirty_inodes(struct f2fs_sb_info *sbi, enum inode_type type)

{

	struct list_head *head;

	struct inode *inode;
@@ -1020,7 +1021,7 @@ int f2fs_sync_inode_meta(struct f2fs_sb_info *sbi) 


			/* it's on eviction */

			if (is_inode_flag_set(inode, FI_DIRTY_INODE))

				update_inode_page(inode);

				f2fs_update_inode_page(inode);

			iput(inode);

		}

	}
@@ -1060,7 +1061,7 @@ retry_flush_dents: 
	/* write all the dirty dentry pages */

	if (get_pages(sbi, F2FS_DIRTY_DENTS)) {

		f2fs_unlock_all(sbi);

		err = sync_dirty_inodes(sbi, DIR_INODE);

		err = f2fs_sync_dirty_inodes(sbi, DIR_INODE);

		if (err)

			goto out;

		cond_resched();
@@ -1088,7 +1089,7 @@ retry_flush_nodes: 


	if (get_pages(sbi, F2FS_DIRTY_NODES)) {

		up_write(&sbi->node_write);

		err = sync_node_pages(sbi, &wbc, false, FS_CP_NODE_IO);

		err = f2fs_sync_node_pages(sbi, &wbc, false, FS_CP_NODE_IO);

		if (err) {

			up_write(&sbi->node_change);

			f2fs_unlock_all(sbi);
@@ -1182,10 +1183,10 @@ static void commit_checkpoint(struct f2fs_sb_info *sbi, 


	/*

	 * pagevec_lookup_tag and lock_page again will take

	 * some extra time. Therefore, update_meta_pages and

	 * sync_meta_pages are combined in this function.

	 * some extra time. Therefore, f2fs_update_meta_pages and

	 * f2fs_sync_meta_pages are combined in this function.

	 */

	struct page *page = grab_meta_page(sbi, blk_addr);

	struct page *page = f2fs_grab_meta_page(sbi, blk_addr);

	int err;



	memcpy(page_address(page), src, PAGE_SIZE);
@@ -1223,7 +1224,7 @@ static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc) 


	/* Flush all the NAT/SIT pages */

	while (get_pages(sbi, F2FS_DIRTY_META)) {

		sync_meta_pages(sbi, META, LONG_MAX, FS_CP_META_IO);

		f2fs_sync_meta_pages(sbi, META, LONG_MAX, FS_CP_META_IO);

		if (unlikely(f2fs_cp_error(sbi)))

			return -EIO;

	}
@@ -1252,7 +1253,7 @@ static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc) 
	}



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

	data_sum_blocks = npages_for_summary_flush(sbi, false);

	data_sum_blocks = f2fs_npages_for_summary_flush(sbi, false);

	spin_lock_irqsave(&sbi->cp_lock, flags);

	if (data_sum_blocks < NR_CURSEG_DATA_TYPE)

		__set_ckpt_flags(ckpt, CP_COMPACT_SUM_FLAG);
@@ -1297,22 +1298,23 @@ static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc) 


		blk = start_blk + sbi->blocks_per_seg - nm_i->nat_bits_blocks;

		for (i = 0; i < nm_i->nat_bits_blocks; i++)

			update_meta_page(sbi, nm_i->nat_bits +

			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)) {

			sync_meta_pages(sbi, META, LONG_MAX, FS_CP_META_IO);

			f2fs_sync_meta_pages(sbi, META, LONG_MAX,

							FS_CP_META_IO);

			if (unlikely(f2fs_cp_error(sbi)))

				return -EIO;

		}

	}



	/* write out checkpoint buffer at block 0 */

	update_meta_page(sbi, ckpt, start_blk++);

	f2fs_update_meta_page(sbi, ckpt, start_blk++);



	for (i = 1; i < 1 + cp_payload_blks; i++)

		update_meta_page(sbi, (char *)ckpt + i * F2FS_BLKSIZE,

		f2fs_update_meta_page(sbi, (char *)ckpt + i * F2FS_BLKSIZE,

							start_blk++);



	if (orphan_num) {
@@ -1320,7 +1322,7 @@ static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc) 
		start_blk += orphan_blocks;

	}



	write_data_summaries(sbi, start_blk);

	f2fs_write_data_summaries(sbi, start_blk);

	start_blk += data_sum_blocks;



	/* Record write statistics in the hot node summary */
@@ -1331,7 +1333,7 @@ static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc) 
	seg_i->journal->info.kbytes_written = cpu_to_le64(kbytes_written);



	if (__remain_node_summaries(cpc->reason)) {

		write_node_summaries(sbi, start_blk);

		f2fs_write_node_summaries(sbi, start_blk);

		start_blk += NR_CURSEG_NODE_TYPE;

	}
@@ -1340,7 +1342,7 @@ static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc) 
	percpu_counter_set(&sbi->alloc_valid_block_count, 0);



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

	sync_meta_pages(sbi, META, LONG_MAX, FS_CP_META_IO);

	f2fs_sync_meta_pages(sbi, META, LONG_MAX, FS_CP_META_IO);



	/* wait for previous submitted meta pages writeback */

	wait_on_all_pages_writeback(sbi);
@@ -1357,7 +1359,7 @@ static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc) 
	commit_checkpoint(sbi, ckpt, start_blk);

	wait_on_all_pages_writeback(sbi);



	release_ino_entry(sbi, false);

	f2fs_release_ino_entry(sbi, false);



	if (unlikely(f2fs_cp_error(sbi)))

		return -EIO;
@@ -1382,7 +1384,7 @@ static int do_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc) 
/*

 * We guarantee that this checkpoint procedure will not fail.

 */

int write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)

int f2fs_write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)

{

	struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);

	unsigned long long ckpt_ver;
@@ -1415,7 +1417,7 @@ int write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc) 


	/* this is the case of multiple fstrims without any changes */

	if (cpc->reason & CP_DISCARD) {

		if (!exist_trim_candidates(sbi, cpc)) {

		if (!f2fs_exist_trim_candidates(sbi, cpc)) {

			unblock_operations(sbi);

			goto out;

		}
@@ -1423,8 +1425,8 @@ int write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc) 
		if (NM_I(sbi)->dirty_nat_cnt == 0 &&

				SIT_I(sbi)->dirty_sentries == 0 &&

				prefree_segments(sbi) == 0) {

			flush_sit_entries(sbi, cpc);

			clear_prefree_segments(sbi, cpc);

			f2fs_flush_sit_entries(sbi, cpc);

			f2fs_clear_prefree_segments(sbi, cpc);

			unblock_operations(sbi);

			goto out;

		}
@@ -1439,15 +1441,15 @@ int write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc) 
	ckpt->checkpoint_ver = cpu_to_le64(++ckpt_ver);



	/* write cached NAT/SIT entries to NAT/SIT area */

	flush_nat_entries(sbi, cpc);

	flush_sit_entries(sbi, cpc);

	f2fs_flush_nat_entries(sbi, cpc);

	f2fs_flush_sit_entries(sbi, cpc);



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

	err = do_checkpoint(sbi, cpc);

	if (err)

		release_discard_addrs(sbi);

		f2fs_release_discard_addrs(sbi);

	else

		clear_prefree_segments(sbi, cpc);

		f2fs_clear_prefree_segments(sbi, cpc);



	unblock_operations(sbi);

	stat_inc_cp_count(sbi->stat_info);
@@ -1464,7 +1466,7 @@ out: 
	return err;

}



void init_ino_entry_info(struct f2fs_sb_info *sbi)

void f2fs_init_ino_entry_info(struct f2fs_sb_info *sbi)

{

	int i;
@@ -1482,23 +1484,23 @@ void init_ino_entry_info(struct f2fs_sb_info *sbi) 
				F2FS_ORPHANS_PER_BLOCK;

}



int __init create_checkpoint_caches(void)

int __init f2fs_create_checkpoint_caches(void)

{

	ino_entry_slab = f2fs_kmem_cache_create("f2fs_ino_entry",

			sizeof(struct ino_entry));

	if (!ino_entry_slab)

		return -ENOMEM;

	inode_entry_slab = f2fs_kmem_cache_create("f2fs_inode_entry",

	f2fs_inode_entry_slab = f2fs_kmem_cache_create("f2fs_inode_entry",

			sizeof(struct inode_entry));

	if (!inode_entry_slab) {

	if (!f2fs_inode_entry_slab) {

		kmem_cache_destroy(ino_entry_slab);

		return -ENOMEM;

	}

	return 0;

}



void destroy_checkpoint_caches(void)

void f2fs_destroy_checkpoint_caches(void)

{

	kmem_cache_destroy(ino_entry_slab);

	kmem_cache_destroy(inode_entry_slab);

	kmem_cache_destroy(f2fs_inode_entry_slab);

}

fs/f2fs/data.c

+58 −57

File changed.

Preview size limit exceeded, changes collapsed.

fs/f2fs/dir.c

+34 −34
Original line number Diff line number Diff line
@@ -65,7 +65,7 @@ static void set_de_type(struct f2fs_dir_entry *de, umode_t mode) 
	de->file_type = f2fs_type_by_mode[(mode & S_IFMT) >> S_SHIFT];

}



unsigned char get_de_type(struct f2fs_dir_entry *de)

unsigned char f2fs_get_de_type(struct f2fs_dir_entry *de)

{

	if (de->file_type < F2FS_FT_MAX)

		return f2fs_filetype_table[de->file_type];
@@ -97,14 +97,14 @@ static struct f2fs_dir_entry *find_in_block(struct page *dentry_page, 
	dentry_blk = (struct f2fs_dentry_block *)page_address(dentry_page);



	make_dentry_ptr_block(NULL, &d, dentry_blk);

	de = find_target_dentry(fname, namehash, max_slots, &d);

	de = f2fs_find_target_dentry(fname, namehash, max_slots, &d);

	if (de)

		*res_page = dentry_page;



	return de;

}



struct f2fs_dir_entry *find_target_dentry(struct fscrypt_name *fname,

struct f2fs_dir_entry *f2fs_find_target_dentry(struct fscrypt_name *fname,

			f2fs_hash_t namehash, int *max_slots,

			struct f2fs_dentry_ptr *d)

{
@@ -171,7 +171,7 @@ static struct f2fs_dir_entry *find_in_level(struct inode *dir, 


	for (; bidx < end_block; bidx++) {

		/* no need to allocate new dentry pages to all the indices */

		dentry_page = find_data_page(dir, bidx);

		dentry_page = f2fs_find_data_page(dir, bidx);

		if (IS_ERR(dentry_page)) {

			if (PTR_ERR(dentry_page) == -ENOENT) {

				room = true;
@@ -210,7 +210,7 @@ struct f2fs_dir_entry *__f2fs_find_entry(struct inode *dir, 


	if (f2fs_has_inline_dentry(dir)) {

		*res_page = NULL;

		de = find_in_inline_dir(dir, fname, res_page);

		de = f2fs_find_in_inline_dir(dir, fname, res_page);

		goto out;

	}
@@ -319,7 +319,7 @@ static void init_dent_inode(const struct qstr *name, struct page *ipage) 
	set_page_dirty(ipage);

}



void do_make_empty_dir(struct inode *inode, struct inode *parent,

void f2fs_do_make_empty_dir(struct inode *inode, struct inode *parent,

					struct f2fs_dentry_ptr *d)

{

	struct qstr dot = QSTR_INIT(".", 1);
@@ -340,23 +340,23 @@ static int make_empty_dir(struct inode *inode, 
	struct f2fs_dentry_ptr d;



	if (f2fs_has_inline_dentry(inode))

		return make_empty_inline_dir(inode, parent, page);

		return f2fs_make_empty_inline_dir(inode, parent, page);



	dentry_page = get_new_data_page(inode, page, 0, true);

	dentry_page = f2fs_get_new_data_page(inode, page, 0, true);

	if (IS_ERR(dentry_page))

		return PTR_ERR(dentry_page);



	dentry_blk = page_address(dentry_page);



	make_dentry_ptr_block(NULL, &d, dentry_blk);

	do_make_empty_dir(inode, parent, &d);

	f2fs_do_make_empty_dir(inode, parent, &d);



	set_page_dirty(dentry_page);

	f2fs_put_page(dentry_page, 1);

	return 0;

}



struct page *init_inode_metadata(struct inode *inode, struct inode *dir,

struct page *f2fs_init_inode_metadata(struct inode *inode, struct inode *dir,

			const struct qstr *new_name, const struct qstr *orig_name,

			struct page *dpage)

{
@@ -365,7 +365,7 @@ struct page *init_inode_metadata(struct inode *inode, struct inode *dir, 
	int err;



	if (is_inode_flag_set(inode, FI_NEW_INODE)) {

		page = new_inode_page(inode);

		page = f2fs_new_inode_page(inode);

		if (IS_ERR(page))

			return page;
@@ -395,7 +395,7 @@ struct page *init_inode_metadata(struct inode *inode, struct inode *dir, 
				goto put_error;

		}

	} else {

		page = get_node_page(F2FS_I_SB(dir), inode->i_ino);

		page = f2fs_get_node_page(F2FS_I_SB(dir), inode->i_ino);

		if (IS_ERR(page))

			return page;

	}
@@ -418,19 +418,19 @@ struct page *init_inode_metadata(struct inode *inode, struct inode *dir, 
		 * we should remove this inode from orphan list.

		 */

		if (inode->i_nlink == 0)

			remove_orphan_inode(F2FS_I_SB(dir), inode->i_ino);

			f2fs_remove_orphan_inode(F2FS_I_SB(dir), inode->i_ino);

		f2fs_i_links_write(inode, true);

	}

	return page;



put_error:

	clear_nlink(inode);

	update_inode(inode, page);

	f2fs_update_inode(inode, page);

	f2fs_put_page(page, 1);

	return ERR_PTR(err);

}



void update_parent_metadata(struct inode *dir, struct inode *inode,

void f2fs_update_parent_metadata(struct inode *dir, struct inode *inode,

						unsigned int current_depth)

{

	if (inode && is_inode_flag_set(inode, FI_NEW_INODE)) {
@@ -448,7 +448,7 @@ void update_parent_metadata(struct inode *dir, struct inode *inode, 
		clear_inode_flag(inode, FI_INC_LINK);

}



int room_for_filename(const void *bitmap, int slots, int max_slots)

int f2fs_room_for_filename(const void *bitmap, int slots, int max_slots)

{

	int bit_start = 0;

	int zero_start, zero_end;
@@ -537,12 +537,12 @@ start: 
				(le32_to_cpu(dentry_hash) % nbucket));



	for (block = bidx; block <= (bidx + nblock - 1); block++) {

		dentry_page = get_new_data_page(dir, NULL, block, true);

		dentry_page = f2fs_get_new_data_page(dir, NULL, block, true);

		if (IS_ERR(dentry_page))

			return PTR_ERR(dentry_page);



		dentry_blk = page_address(dentry_page);

		bit_pos = room_for_filename(&dentry_blk->dentry_bitmap,

		bit_pos = f2fs_room_for_filename(&dentry_blk->dentry_bitmap,

						slots, NR_DENTRY_IN_BLOCK);

		if (bit_pos < NR_DENTRY_IN_BLOCK)

			goto add_dentry;
@@ -558,7 +558,7 @@ add_dentry: 


	if (inode) {

		down_write(&F2FS_I(inode)->i_sem);

		page = init_inode_metadata(inode, dir, new_name,

		page = f2fs_init_inode_metadata(inode, dir, new_name,

						orig_name, NULL);

		if (IS_ERR(page)) {

			err = PTR_ERR(page);
@@ -576,7 +576,7 @@ add_dentry: 
		f2fs_put_page(page, 1);

	}



	update_parent_metadata(dir, inode, current_depth);

	f2fs_update_parent_metadata(dir, inode, current_depth);

fail:

	if (inode)

		up_write(&F2FS_I(inode)->i_sem);
@@ -586,7 +586,7 @@ fail: 
	return err;

}



int __f2fs_do_add_link(struct inode *dir, struct fscrypt_name *fname,

int f2fs_add_dentry(struct inode *dir, struct fscrypt_name *fname,

				struct inode *inode, nid_t ino, umode_t mode)

{

	struct qstr new_name;
@@ -610,7 +610,7 @@ int __f2fs_do_add_link(struct inode *dir, struct fscrypt_name *fname, 
 * Caller should grab and release a rwsem by calling f2fs_lock_op() and

 * f2fs_unlock_op().

 */

int __f2fs_add_link(struct inode *dir, const struct qstr *name,

int f2fs_do_add_link(struct inode *dir, const struct qstr *name,

				struct inode *inode, nid_t ino, umode_t mode)

{

	struct fscrypt_name fname;
@@ -639,7 +639,7 @@ int __f2fs_add_link(struct inode *dir, const struct qstr *name, 
	} else if (IS_ERR(page)) {

		err = PTR_ERR(page);

	} else {

		err = __f2fs_do_add_link(dir, &fname, inode, ino, mode);

		err = f2fs_add_dentry(dir, &fname, inode, ino, mode);

	}

	fscrypt_free_filename(&fname);

	return err;
@@ -651,7 +651,7 @@ int f2fs_do_tmpfile(struct inode *inode, struct inode *dir) 
	int err = 0;



	down_write(&F2FS_I(inode)->i_sem);

	page = init_inode_metadata(inode, dir, NULL, NULL, NULL);

	page = f2fs_init_inode_metadata(inode, dir, NULL, NULL, NULL);

	if (IS_ERR(page)) {

		err = PTR_ERR(page);

		goto fail;
@@ -683,9 +683,9 @@ void f2fs_drop_nlink(struct inode *dir, struct inode *inode) 
	up_write(&F2FS_I(inode)->i_sem);



	if (inode->i_nlink == 0)

		add_orphan_inode(inode);

		f2fs_add_orphan_inode(inode);

	else

		release_orphan_inode(sbi);

		f2fs_release_orphan_inode(sbi);

}



/*
@@ -703,7 +703,7 @@ void f2fs_delete_entry(struct f2fs_dir_entry *dentry, struct page *page, 
	f2fs_update_time(F2FS_I_SB(dir), REQ_TIME);



	if (F2FS_OPTION(F2FS_I_SB(dir)).fsync_mode == FSYNC_MODE_STRICT)

		add_ino_entry(F2FS_I_SB(dir), dir->i_ino, TRANS_DIR_INO);

		f2fs_add_ino_entry(F2FS_I_SB(dir), dir->i_ino, TRANS_DIR_INO);



	if (f2fs_has_inline_dentry(dir))

		return f2fs_delete_inline_entry(dentry, page, dir, inode);
@@ -729,13 +729,13 @@ void f2fs_delete_entry(struct f2fs_dir_entry *dentry, struct page *page, 
		f2fs_drop_nlink(dir, inode);



	if (bit_pos == NR_DENTRY_IN_BLOCK &&

			!truncate_hole(dir, page->index, page->index + 1)) {

		clear_radix_tree_dirty_tag(page);

		!f2fs_truncate_hole(dir, page->index, page->index + 1)) {

		f2fs_clear_radix_tree_dirty_tag(page);

		clear_page_dirty_for_io(page);

		ClearPagePrivate(page);

		ClearPageUptodate(page);

		inode_dec_dirty_pages(dir);

		remove_dirty_inode(dir);

		f2fs_remove_dirty_inode(dir);

	}

	f2fs_put_page(page, 1);

}
@@ -752,7 +752,7 @@ bool f2fs_empty_dir(struct inode *dir) 
		return f2fs_empty_inline_dir(dir);



	for (bidx = 0; bidx < nblock; bidx++) {

		dentry_page = get_lock_data_page(dir, bidx, false);

		dentry_page = f2fs_get_lock_data_page(dir, bidx, false);

		if (IS_ERR(dentry_page)) {

			if (PTR_ERR(dentry_page) == -ENOENT)

				continue;
@@ -800,7 +800,7 @@ int f2fs_fill_dentries(struct dir_context *ctx, struct f2fs_dentry_ptr *d, 
			continue;

		}



		d_type = get_de_type(de);

		d_type = f2fs_get_de_type(de);



		de_name.name = d->filename[bit_pos];

		de_name.len = le16_to_cpu(de->name_len);
@@ -824,7 +824,7 @@ int f2fs_fill_dentries(struct dir_context *ctx, struct f2fs_dentry_ptr *d, 
			return 1;



		if (sbi->readdir_ra == 1)

			ra_node_page(sbi, le32_to_cpu(de->ino));

			f2fs_ra_node_page(sbi, le32_to_cpu(de->ino));



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

		ctx->pos = start_pos + bit_pos;
@@ -874,7 +874,7 @@ static int f2fs_readdir(struct file *file, struct dir_context *ctx) 
			page_cache_sync_readahead(inode->i_mapping, ra, file, n,

				min(npages - n, (pgoff_t)MAX_DIR_RA_PAGES));



		dentry_page = get_lock_data_page(inode, n, false);

		dentry_page = f2fs_get_lock_data_page(inode, n, false);

		if (IS_ERR(dentry_page)) {

			err = PTR_ERR(dentry_page);

			if (err == -ENOENT) {

fs/f2fs/extent_cache.c

+11 −11
Original line number Diff line number Diff line
@@ -49,7 +49,7 @@ static struct rb_entry *__lookup_rb_tree_slow(struct rb_root *root, 
	return NULL;

}



struct rb_entry *__lookup_rb_tree(struct rb_root *root,

struct rb_entry *f2fs_lookup_rb_tree(struct rb_root *root,

				struct rb_entry *cached_re, unsigned int ofs)

{

	struct rb_entry *re;
@@ -61,7 +61,7 @@ struct rb_entry *__lookup_rb_tree(struct rb_root *root, 
	return re;

}



struct rb_node **__lookup_rb_tree_for_insert(struct f2fs_sb_info *sbi,

struct rb_node **f2fs_lookup_rb_tree_for_insert(struct f2fs_sb_info *sbi,

				struct rb_root *root, struct rb_node **parent,

				unsigned int ofs)

{
@@ -92,7 +92,7 @@ struct rb_node **__lookup_rb_tree_for_insert(struct f2fs_sb_info *sbi, 
 * in order to simpfy the insertion after.

 * tree must stay unchanged between lookup and insertion.

 */

struct rb_entry *__lookup_rb_tree_ret(struct rb_root *root,

struct rb_entry *f2fs_lookup_rb_tree_ret(struct rb_root *root,

				struct rb_entry *cached_re,

				unsigned int ofs,

				struct rb_entry **prev_entry,
@@ -159,7 +159,7 @@ lookup_neighbors: 
	return re;

}



bool __check_rb_tree_consistence(struct f2fs_sb_info *sbi,

bool f2fs_check_rb_tree_consistence(struct f2fs_sb_info *sbi,

						struct rb_root *root)

{

#ifdef CONFIG_F2FS_CHECK_FS
@@ -390,7 +390,7 @@ static bool f2fs_lookup_extent_tree(struct inode *inode, pgoff_t pgofs, 
		goto out;

	}



	en = (struct extent_node *)__lookup_rb_tree(&et->root,

	en = (struct extent_node *)f2fs_lookup_rb_tree(&et->root,

				(struct rb_entry *)et->cached_en, pgofs);

	if (!en)

		goto out;
@@ -470,7 +470,7 @@ static struct extent_node *__insert_extent_tree(struct inode *inode, 
		goto do_insert;

	}



	p = __lookup_rb_tree_for_insert(sbi, &et->root, &parent, ei->fofs);

	p = f2fs_lookup_rb_tree_for_insert(sbi, &et->root, &parent, ei->fofs);

do_insert:

	en = __attach_extent_node(sbi, et, ei, parent, p);

	if (!en)
@@ -520,7 +520,7 @@ static void f2fs_update_extent_tree_range(struct inode *inode, 
	__drop_largest_extent(inode, fofs, len);



	/* 1. lookup first extent node in range [fofs, fofs + len - 1] */

	en = (struct extent_node *)__lookup_rb_tree_ret(&et->root,

	en = (struct extent_node *)f2fs_lookup_rb_tree_ret(&et->root,

					(struct rb_entry *)et->cached_en, fofs,

					(struct rb_entry **)&prev_en,

					(struct rb_entry **)&next_en,
@@ -773,7 +773,7 @@ void f2fs_update_extent_cache(struct dnode_of_data *dn) 
	else

		blkaddr = dn->data_blkaddr;



	fofs = start_bidx_of_node(ofs_of_node(dn->node_page), dn->inode) +

	fofs = f2fs_start_bidx_of_node(ofs_of_node(dn->node_page), dn->inode) +

								dn->ofs_in_node;

	f2fs_update_extent_tree_range(dn->inode, fofs, blkaddr, 1);

}
@@ -788,7 +788,7 @@ void f2fs_update_extent_cache_range(struct dnode_of_data *dn, 
	f2fs_update_extent_tree_range(dn->inode, fofs, blkaddr, len);

}



void init_extent_cache_info(struct f2fs_sb_info *sbi)

void f2fs_init_extent_cache_info(struct f2fs_sb_info *sbi)

{

	INIT_RADIX_TREE(&sbi->extent_tree_root, GFP_NOIO);

	mutex_init(&sbi->extent_tree_lock);
@@ -800,7 +800,7 @@ void init_extent_cache_info(struct f2fs_sb_info *sbi) 
	atomic_set(&sbi->total_ext_node, 0);

}



int __init create_extent_cache(void)

int __init f2fs_create_extent_cache(void)

{

	extent_tree_slab = f2fs_kmem_cache_create("f2fs_extent_tree",

			sizeof(struct extent_tree));
@@ -815,7 +815,7 @@ int __init create_extent_cache(void) 
	return 0;

}



void destroy_extent_cache(void)

void f2fs_destroy_extent_cache(void)

{

	kmem_cache_destroy(extent_node_slab);

	kmem_cache_destroy(extent_tree_slab);

fs/f2fs/f2fs.h

+157 −148

File changed.

Preview size limit exceeded, changes collapsed.

CRA Git | Maintained and supported by SUSTech CRA and CCSE