Commit 4081363f authored by Jaegeuk Kim's avatar Jaegeuk Kim
Browse files

f2fs: introduce F2FS_I_SB, F2FS_M_SB, and F2FS_P_SB 



This patch adds three inline functions to clean up dirty casting codes.

Signed-off-by: default avatarJaegeuk Kim <jaegeuk@kernel.org>
parent 70c8038d

fs/f2fs/checkpoint.c

+7 −11
Original line number Diff line number Diff line
@@ -151,8 +151,7 @@ int ra_meta_pages(struct f2fs_sb_info *sbi, int start, int nrpages, int type) 
static int f2fs_write_meta_page(struct page *page,

				struct writeback_control *wbc)

{

	struct inode *inode = page->mapping->host;

	struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);

	struct f2fs_sb_info *sbi = F2FS_P_SB(page);



	trace_f2fs_writepage(page, META);
@@ -177,7 +176,7 @@ static int f2fs_write_meta_page(struct page *page, 
static int f2fs_write_meta_pages(struct address_space *mapping,

				struct writeback_control *wbc)

{

	struct f2fs_sb_info *sbi = F2FS_SB(mapping->host->i_sb);

	struct f2fs_sb_info *sbi = F2FS_M_SB(mapping);

	long diff, written;



	trace_f2fs_writepages(mapping->host, wbc, META);
@@ -259,15 +258,12 @@ long sync_meta_pages(struct f2fs_sb_info *sbi, enum page_type type, 


static int f2fs_set_meta_page_dirty(struct page *page)

{

	struct address_space *mapping = page->mapping;

	struct f2fs_sb_info *sbi = F2FS_SB(mapping->host->i_sb);



	trace_f2fs_set_page_dirty(page, META);



	SetPageUptodate(page);

	if (!PageDirty(page)) {

		__set_page_dirty_nobuffers(page);

		inc_page_count(sbi, F2FS_DIRTY_META);

		inc_page_count(F2FS_P_SB(page), F2FS_DIRTY_META);

		return 1;

	}

	return 0;
@@ -619,7 +615,7 @@ int get_valid_checkpoint(struct f2fs_sb_info *sbi) 


static int __add_dirty_inode(struct inode *inode, struct dir_inode_entry *new)

{

	struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);

	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);



	if (is_inode_flag_set(F2FS_I(inode), FI_DIRTY_DIR))

		return -EEXIST;
@@ -633,7 +629,7 @@ static int __add_dirty_inode(struct inode *inode, struct dir_inode_entry *new) 


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

{

	struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);

	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);

	struct dir_inode_entry *new;

	int ret = 0;
@@ -656,7 +652,7 @@ void set_dirty_dir_page(struct inode *inode, struct page *page) 


void add_dirty_dir_inode(struct inode *inode)

{

	struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);

	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);

	struct dir_inode_entry *new =

			f2fs_kmem_cache_alloc(inode_entry_slab, GFP_NOFS);

	int ret = 0;
@@ -674,7 +670,7 @@ void add_dirty_dir_inode(struct inode *inode) 


void remove_dirty_dir_inode(struct inode *inode)

{

	struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);

	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);

	struct dir_inode_entry *entry;



	if (!S_ISDIR(inode->i_mode))

fs/f2fs/data.c

+14 −17
Original line number Diff line number Diff line
@@ -236,7 +236,7 @@ static void __set_data_blkaddr(struct dnode_of_data *dn, block_t new_addr) 


int reserve_new_block(struct dnode_of_data *dn)

{

	struct f2fs_sb_info *sbi = F2FS_SB(dn->inode->i_sb);

	struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);



	if (unlikely(is_inode_flag_set(F2FS_I(dn->inode), FI_NO_ALLOC)))

		return -EPERM;
@@ -396,7 +396,6 @@ void update_extent_cache(block_t blk_addr, struct dnode_of_data *dn) 


struct page *find_data_page(struct inode *inode, pgoff_t index, bool sync)

{

	struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);

	struct address_space *mapping = inode->i_mapping;

	struct dnode_of_data dn;

	struct page *page;
@@ -429,7 +428,7 @@ struct page *find_data_page(struct inode *inode, pgoff_t index, bool sync) 
		return page;

	}



	err = f2fs_submit_page_bio(sbi, page, dn.data_blkaddr,

	err = f2fs_submit_page_bio(F2FS_I_SB(inode), page, dn.data_blkaddr,

					sync ? READ_SYNC : READA);

	if (err)

		return ERR_PTR(err);
@@ -451,7 +450,6 @@ struct page *find_data_page(struct inode *inode, pgoff_t index, bool sync) 
 */

struct page *get_lock_data_page(struct inode *inode, pgoff_t index)

{

	struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);

	struct address_space *mapping = inode->i_mapping;

	struct dnode_of_data dn;

	struct page *page;
@@ -490,7 +488,8 @@ struct page *get_lock_data_page(struct inode *inode, pgoff_t index) 
		return page;

	}



	err = f2fs_submit_page_bio(sbi, page, dn.data_blkaddr, READ_SYNC);

	err = f2fs_submit_page_bio(F2FS_I_SB(inode), page,

					dn.data_blkaddr, READ_SYNC);

	if (err)

		return ERR_PTR(err);
@@ -517,7 +516,6 @@ struct page *get_lock_data_page(struct inode *inode, pgoff_t index) 
struct page *get_new_data_page(struct inode *inode,

		struct page *ipage, pgoff_t index, bool new_i_size)

{

	struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);

	struct address_space *mapping = inode->i_mapping;

	struct page *page;

	struct dnode_of_data dn;
@@ -541,8 +539,8 @@ struct page *get_new_data_page(struct inode *inode, 
		zero_user_segment(page, 0, PAGE_CACHE_SIZE);

		SetPageUptodate(page);

	} else {

		err = f2fs_submit_page_bio(sbi, page, dn.data_blkaddr,

								READ_SYNC);

		err = f2fs_submit_page_bio(F2FS_I_SB(inode), page,

						dn.data_blkaddr, READ_SYNC);

		if (err)

			goto put_err;
@@ -573,7 +571,7 @@ struct page *get_new_data_page(struct inode *inode, 


static int __allocate_data_block(struct dnode_of_data *dn)

{

	struct f2fs_sb_info *sbi = F2FS_SB(dn->inode->i_sb);

	struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);

	struct f2fs_summary sum;

	block_t new_blkaddr;

	struct node_info ni;
@@ -614,7 +612,6 @@ static int __allocate_data_block(struct dnode_of_data *dn) 
static int __get_data_block(struct inode *inode, sector_t iblock,

			struct buffer_head *bh_result, int create, bool fiemap)

{

	struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);

	unsigned int blkbits = inode->i_sb->s_blocksize_bits;

	unsigned maxblocks = bh_result->b_size >> blkbits;

	struct dnode_of_data dn;
@@ -630,8 +627,8 @@ static int __get_data_block(struct inode *inode, sector_t iblock, 
		goto out;



	if (create) {

		f2fs_balance_fs(sbi);

		f2fs_lock_op(sbi);

		f2fs_balance_fs(F2FS_I_SB(inode));

		f2fs_lock_op(F2FS_I_SB(inode));

	}



	/* When reading holes, we need its node page */
@@ -707,7 +704,7 @@ static int __get_data_block(struct inode *inode, sector_t iblock, 
	f2fs_put_dnode(&dn);

unlock_out:

	if (create)

		f2fs_unlock_op(sbi);

		f2fs_unlock_op(F2FS_I_SB(inode));

out:

	trace_f2fs_get_data_block(inode, iblock, bh_result, err);

	return err;
@@ -804,7 +801,7 @@ static int f2fs_write_data_page(struct page *page, 
					struct writeback_control *wbc)

{

	struct inode *inode = page->mapping->host;

	struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);

	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);

	loff_t i_size = i_size_read(inode);

	const pgoff_t end_index = ((unsigned long long) i_size)

							>> PAGE_CACHE_SHIFT;
@@ -892,7 +889,7 @@ static int f2fs_write_data_pages(struct address_space *mapping, 
			    struct writeback_control *wbc)

{

	struct inode *inode = mapping->host;

	struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);

	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);

	bool locked = false;

	int ret;

	long diff;
@@ -945,7 +942,7 @@ static int f2fs_write_begin(struct file *file, struct address_space *mapping, 
		struct page **pagep, void **fsdata)

{

	struct inode *inode = mapping->host;

	struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);

	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);

	struct page *page;

	pgoff_t index = ((unsigned long long) pos) >> PAGE_CACHE_SHIFT;

	struct dnode_of_data dn;
@@ -1093,7 +1090,7 @@ static ssize_t f2fs_direct_IO(int rw, struct kiocb *iocb, 
		return 0;



	/* clear fsync mark to recover these blocks */

	fsync_mark_clear(F2FS_SB(inode->i_sb), inode->i_ino);

	fsync_mark_clear(F2FS_I_SB(inode), inode->i_ino);



	trace_f2fs_direct_IO_enter(inode, offset, count, rw);

fs/f2fs/dir.c

+5 −8
Original line number Diff line number Diff line
@@ -284,10 +284,9 @@ static void init_dent_inode(const struct qstr *name, struct page *ipage) 


int update_dent_inode(struct inode *inode, const struct qstr *name)

{

	struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);

	struct page *page;



	page = get_node_page(sbi, inode->i_ino);

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

	if (IS_ERR(page))

		return PTR_ERR(page);
@@ -337,7 +336,6 @@ static int make_empty_dir(struct inode *inode, 
static struct page *init_inode_metadata(struct inode *inode,

		struct inode *dir, const struct qstr *name)

{

	struct f2fs_sb_info *sbi = F2FS_SB(dir->i_sb);

	struct page *page;

	int err;
@@ -360,7 +358,7 @@ static struct page *init_inode_metadata(struct inode *inode, 
		if (err)

			goto put_error;

	} else {

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

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

		if (IS_ERR(page))

			return page;
@@ -381,7 +379,7 @@ static struct page *init_inode_metadata(struct inode *inode, 
		 * we should remove this inode from orphan list.

		 */

		if (inode->i_nlink == 0)

			remove_orphan_inode(sbi, inode->i_ino);

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

		inc_nlink(inode);

	}

	return page;
@@ -571,8 +569,7 @@ void f2fs_delete_entry(struct f2fs_dir_entry *dentry, struct page *page, 
{

	struct	f2fs_dentry_block *dentry_blk;

	unsigned int bit_pos;

	struct address_space *mapping = page->mapping;

	struct inode *dir = mapping->host;

	struct inode *dir = page->mapping->host;

	int slots = GET_DENTRY_SLOTS(le16_to_cpu(dentry->name_len));

	int i;
@@ -594,7 +591,7 @@ void f2fs_delete_entry(struct f2fs_dir_entry *dentry, struct page *page, 
	dir->i_ctime = dir->i_mtime = CURRENT_TIME;



	if (inode) {

		struct f2fs_sb_info *sbi = F2FS_SB(dir->i_sb);

		struct f2fs_sb_info *sbi = F2FS_I_SB(dir);



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

fs/f2fs/f2fs.h

+19 −4
Original line number Diff line number Diff line
@@ -539,6 +539,21 @@ static inline struct f2fs_sb_info *F2FS_SB(struct super_block *sb) 
	return sb->s_fs_info;

}



static inline struct f2fs_sb_info *F2FS_I_SB(struct inode *inode)

{

	return F2FS_SB(inode->i_sb);

}



static inline struct f2fs_sb_info *F2FS_M_SB(struct address_space *mapping)

{

	return F2FS_I_SB(mapping->host);

}



static inline struct f2fs_sb_info *F2FS_P_SB(struct page *page)

{

	return F2FS_M_SB(page->mapping);

}



static inline struct f2fs_super_block *F2FS_RAW_SUPER(struct f2fs_sb_info *sbi)

{

	return (struct f2fs_super_block *)(sbi->raw_super);
@@ -718,7 +733,7 @@ static inline void inc_page_count(struct f2fs_sb_info *sbi, int count_type) 


static inline void inode_inc_dirty_dents(struct inode *inode)

{

	inc_page_count(F2FS_SB(inode->i_sb), F2FS_DIRTY_DENTS);

	inc_page_count(F2FS_I_SB(inode), F2FS_DIRTY_DENTS);

	atomic_inc(&F2FS_I(inode)->dirty_dents);

}
@@ -732,7 +747,7 @@ static inline void inode_dec_dirty_dents(struct inode *inode) 
	if (!S_ISDIR(inode->i_mode))

		return;



	dec_page_count(F2FS_SB(inode->i_sb), F2FS_DIRTY_DENTS);

	dec_page_count(F2FS_I_SB(inode), F2FS_DIRTY_DENTS);

	atomic_dec(&F2FS_I(inode)->dirty_dents);

}
@@ -1359,12 +1374,12 @@ static inline struct f2fs_stat_info *F2FS_STAT(struct f2fs_sb_info *sbi) 
#define stat_inc_inline_inode(inode)					\

	do {								\

		if (f2fs_has_inline_data(inode))			\

			((F2FS_SB(inode->i_sb))->inline_inode++);	\

			((F2FS_I_SB(inode))->inline_inode++);		\

	} while (0)

#define stat_dec_inline_inode(inode)					\

	do {								\

		if (f2fs_has_inline_data(inode))			\

			((F2FS_SB(inode->i_sb))->inline_inode--);	\

			((F2FS_I_SB(inode))->inline_inode--);		\

	} while (0)



#define stat_inc_seg_type(sbi, curseg)					\

fs/f2fs/file.c

+10 −10
Original line number Diff line number Diff line
@@ -33,7 +33,7 @@ static int f2fs_vm_page_mkwrite(struct vm_area_struct *vma, 
{

	struct page *page = vmf->page;

	struct inode *inode = file_inode(vma->vm_file);

	struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);

	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);

	struct dnode_of_data dn;

	int err;
@@ -117,7 +117,7 @@ static int get_parent_ino(struct inode *inode, nid_t *pino) 


static inline bool need_do_checkpoint(struct inode *inode)

{

	struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);

	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);

	bool need_cp = false;



	if (!S_ISREG(inode->i_mode) || inode->i_nlink != 1)
@@ -138,7 +138,7 @@ int f2fs_sync_file(struct file *file, loff_t start, loff_t end, int datasync) 
{

	struct inode *inode = file->f_mapping->host;

	struct f2fs_inode_info *fi = F2FS_I(inode);

	struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);

	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);

	int ret = 0;

	bool need_cp = false;

	struct writeback_control wbc = {
@@ -226,7 +226,7 @@ int f2fs_sync_file(struct file *file, loff_t start, loff_t end, int datasync) 
flush_out:

		remove_dirty_inode(sbi, inode->i_ino, UPDATE_INO);

		clear_inode_flag(fi, FI_UPDATE_WRITE);

		ret = f2fs_issue_flush(F2FS_SB(inode->i_sb));

		ret = f2fs_issue_flush(F2FS_I_SB(inode));

	}

out:

	trace_f2fs_sync_file_exit(inode, need_cp, datasync, ret);
@@ -369,7 +369,7 @@ static int f2fs_file_mmap(struct file *file, struct vm_area_struct *vma) 
int truncate_data_blocks_range(struct dnode_of_data *dn, int count)

{

	int nr_free = 0, ofs = dn->ofs_in_node;

	struct f2fs_sb_info *sbi = F2FS_SB(dn->inode->i_sb);

	struct f2fs_sb_info *sbi = F2FS_I_SB(dn->inode);

	struct f2fs_node *raw_node;

	__le32 *addr;
@@ -432,7 +432,7 @@ static void truncate_partial_data_page(struct inode *inode, u64 from) 


int truncate_blocks(struct inode *inode, u64 from, bool lock)

{

	struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);

	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);

	unsigned int blocksize = inode->i_sb->s_blocksize;

	struct dnode_of_data dn;

	pgoff_t free_from;
@@ -555,7 +555,7 @@ int f2fs_setattr(struct dentry *dentry, struct iattr *attr) 


		truncate_setsize(inode, attr->ia_size);

		f2fs_truncate(inode);

		f2fs_balance_fs(F2FS_SB(inode->i_sb));

		f2fs_balance_fs(F2FS_I_SB(inode));

	}



	__setattr_copy(inode, attr);
@@ -589,7 +589,7 @@ const struct inode_operations f2fs_file_inode_operations = { 
static void fill_zero(struct inode *inode, pgoff_t index,

					loff_t start, loff_t len)

{

	struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);

	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);

	struct page *page;



	if (!len)
@@ -661,7 +661,7 @@ static int punch_hole(struct inode *inode, loff_t offset, loff_t len) 
		if (pg_start < pg_end) {

			struct address_space *mapping = inode->i_mapping;

			loff_t blk_start, blk_end;

			struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);

			struct f2fs_sb_info *sbi = F2FS_I_SB(inode);



			f2fs_balance_fs(sbi);
@@ -682,7 +682,7 @@ static int punch_hole(struct inode *inode, loff_t offset, loff_t len) 
static int expand_inode_data(struct inode *inode, loff_t offset,

					loff_t len, int mode)

{

	struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);

	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);

	pgoff_t index, pg_start, pg_end;

	loff_t new_size = i_size_read(inode);

	loff_t off_start, off_end;