Merge "f2fs: remove unneeded disable_nat_bits()" (e8333601) · Commits · e / devices / android_kernel_oneplus_sm8150

fs/f2fs/checkpoint.c

+45 −16

Original line number	Diff line number	Diff line
		@@ -70,6 +70,7 @@ static struct page __get_meta_page(struct f2fs_sb_info sbi, pgoff_t index,
		.encrypted_page = NULL,
		.is_meta = is_meta,
		};
		int err;

		if (unlikely(!is_meta))
		fio.op_flags &= ~REQ_META;
		@@ -84,11 +85,10 @@ static struct page __get_meta_page(struct f2fs_sb_info sbi, pgoff_t index,

		fio.page = page;

		if (f2fs_submit_page_bio(&fio)) {
		memset(page_address(page), 0, PAGE_SIZE);
		f2fs_stop_checkpoint(sbi, false);
		f2fs_bug_on(sbi, 1);
		return page;
		err = f2fs_submit_page_bio(&fio);
		if (err) {
		f2fs_put_page(page, 1);
		return ERR_PTR(err);
		}

		lock_page(page);
		@@ -97,13 +97,10 @@ static struct page __get_meta_page(struct f2fs_sb_info sbi, pgoff_t index,
		goto repeat;
		}

		/*
		* if there is any IO error when accessing device, make our filesystem
		* readonly and make sure do not write checkpoint with non-uptodate
		* meta page.
		*/
		if (unlikely(!PageUptodate(page)))
		f2fs_stop_checkpoint(sbi, false);
		if (unlikely(!PageUptodate(page))) {
		f2fs_put_page(page, 1);
		return ERR_PTR(-EIO);
		}
		out:
		return page;
		}
		@@ -113,6 +110,22 @@ struct page get_meta_page(struct f2fs_sb_info sbi, pgoff_t index)
		return __get_meta_page(sbi, index, true);
		}

		struct page f2fs_get_meta_page_nofail(struct f2fs_sb_info sbi, pgoff_t index)
		{
		struct page *page;
		int count = 0;

		retry:
		page = __get_meta_page(sbi, index, true);
		if (IS_ERR(page)) {
		if (PTR_ERR(page) == -EIO &&
		++count <= DEFAULT_RETRY_IO_COUNT)
		goto retry;
		f2fs_stop_checkpoint(sbi, false);
		}
		return page;
		}

		/* for POR only */
		struct page get_tmp_page(struct f2fs_sb_info sbi, pgoff_t index)
		{
		@@ -614,7 +627,9 @@ 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);
		err = get_node_info(sbi, ino, &ni);
		if (err)
		goto err_out;

		/* ENOMEM was fully retried in f2fs_evict_inode. */
		if (ni.blk_addr != NULL_ADDR) {
		@@ -663,9 +678,15 @@ int recover_orphan_inodes(struct f2fs_sb_info *sbi)
		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;
		struct f2fs_orphan_block *orphan_blk;

		page = get_meta_page(sbi, start_blk + i);
		if (IS_ERR(page)) {
		err = PTR_ERR(page);
		goto out;
		}

		orphan_blk = (struct f2fs_orphan_block *)page_address(page);
		for (j = 0; j < le32_to_cpu(orphan_blk->entry_count); j++) {
		nid_t ino = le32_to_cpu(orphan_blk->ino[j]);
		@@ -756,6 +777,9 @@ static int get_checkpoint_version(struct f2fs_sb_info *sbi, block_t cp_addr,
		__u32 crc = 0;

		*cp_page = get_meta_page(sbi, cp_addr);
		if (IS_ERR(*cp_page))
		return PTR_ERR(*cp_page);

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

		crc_offset = le32_to_cpu((*cp_block)->checksum_offset);
		@@ -881,6 +905,8 @@ int get_valid_checkpoint(struct f2fs_sb_info *sbi)
		unsigned char ckpt = (unsigned char )sbi->ckpt;

		cur_page = get_meta_page(sbi, cp_blk_no + i);
		if (IS_ERR(cur_page))
		goto free_fail_no_cp;
		sit_bitmap_ptr = page_address(cur_page);
		memcpy(ckpt + i * blk_size, sit_bitmap_ptr, blk_size);
		f2fs_put_page(cur_page, 1);
		@@ -1463,7 +1489,10 @@ 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);
		err = flush_nat_entries(sbi, cpc);
		if (err)
		goto stop;

		flush_sit_entries(sbi, cpc);

		/* unlock all the fs_lock[] in do_checkpoint() */
		@@ -1472,7 +1501,7 @@ int write_checkpoint(struct f2fs_sb_info sbi, struct cp_control cpc)
		release_discard_addrs(sbi);
		else
		clear_prefree_segments(sbi, cpc);

		stop:
		unblock_operations(sbi);
		stat_inc_cp_count(sbi->stat_info);

fs/f2fs/data.c

+22 −3

Original line number	Diff line number	Diff line
		@@ -912,6 +912,10 @@ static int __allocate_data_block(struct dnode_of_data *dn, int seg_type)
		if (unlikely(is_inode_flag_set(dn->inode, FI_NO_ALLOC)))
		return -EPERM;

		err = get_node_info(sbi, dn->nid, &ni);
		if (err)
		return err;

		dn->data_blkaddr = datablock_addr(dn->inode,
		dn->node_page, dn->ofs_in_node);
		if (dn->data_blkaddr == NEW_ADDR)
		@@ -921,7 +925,6 @@ static int __allocate_data_block(struct dnode_of_data *dn, int seg_type)
		return err;

		alloc:
		get_node_info(sbi, dn->nid, &ni);
		set_summary(&sum, dn->nid, dn->ofs_in_node, ni.version);

		allocate_data_block(sbi, NULL, dn->data_blkaddr, &dn->data_blkaddr,
		@@ -1324,7 +1327,12 @@ static int f2fs_xattr_fiemap(struct inode *inode,
		if (!page)
		return -ENOMEM;

		get_node_info(sbi, inode->i_ino, &ni);
		err = get_node_info(sbi, inode->i_ino, &ni);
		if (err) {
		f2fs_put_page(page, 1);
		return err;
		}


		phys = (__u64)blk_to_logical(inode, ni.blk_addr);
		offset = offsetof(struct f2fs_inode, i_addr) +
		@@ -1351,7 +1359,11 @@ static int f2fs_xattr_fiemap(struct inode *inode,
		if (!page)
		return -ENOMEM;

		get_node_info(sbi, xnid, &ni);
		err = get_node_info(sbi, xnid, &ni);
		if (err) {
		f2fs_put_page(page, 1);
		return err;
		}

		phys = (__u64)blk_to_logical(inode, ni.blk_addr);
		len = inode->i_sb->s_blocksize;
		@@ -1752,6 +1764,7 @@ int do_write_data_page(struct f2fs_io_info *fio)
		struct inode *inode = page->mapping->host;
		struct dnode_of_data dn;
		struct extent_info ei = {0,0,0};
		struct node_info ni;
		bool ipu_force = false;
		int err = 0;

		@@ -1820,6 +1833,12 @@ int do_write_data_page(struct f2fs_io_info *fio)
		fio->need_lock = LOCK_REQ;
		}

		err = get_node_info(fio->sbi, dn.nid, &ni);
		if (err)
		goto out_writepage;

		fio->version = ni.version;

		err = encrypt_one_page(fio);
		if (err)
		goto out_writepage;

fs/f2fs/f2fs.h

+8 −4

Original line number	Diff line number	Diff line
		@@ -510,6 +510,8 @@ enum {
		*/
		};

		#define DEFAULT_RETRY_IO_COUNT 8 /* maximum retry read IO count */

		#define F2FS_LINK_MAX 0xffffffff /* maximum link count per file */

		#define MAX_DIR_RA_PAGES 4 /* maximum ra pages of dir */
		@@ -1010,6 +1012,7 @@ struct f2fs_io_info {
		bool is_meta; /* indicate borrow meta inode mapping or not */
		enum iostat_type io_type; /* io type */
		struct writeback_control io_wbc; / writeback control */
		unsigned char version; /* version of the node */
		};

		#define is_read_io(rw) ((rw) == READ)
		@@ -2756,7 +2759,7 @@ bool available_free_memory(struct f2fs_sb_info *sbi, int type);
		int need_dentry_mark(struct f2fs_sb_info *sbi, nid_t nid);
		bool is_checkpointed_node(struct f2fs_sb_info *sbi, nid_t nid);
		bool need_inode_block_update(struct f2fs_sb_info *sbi, nid_t ino);
		void get_node_info(struct f2fs_sb_info sbi, nid_t nid, struct node_info ni);
		int get_node_info(struct f2fs_sb_info sbi, nid_t nid, struct node_info ni);
		pgoff_t get_next_page_offset(struct dnode_of_data *dn, pgoff_t pgofs);
		int get_dnode_of_data(struct dnode_of_data *dn, pgoff_t index, int mode);
		int truncate_inode_blocks(struct inode *inode, pgoff_t from);
		@@ -2773,7 +2776,7 @@ int fsync_node_pages(struct f2fs_sb_info sbi, struct inode inode,
		struct writeback_control *wbc, bool atomic);
		int sync_node_pages(struct f2fs_sb_info sbi, struct writeback_control wbc,
		bool do_balance, enum iostat_type io_type);
		void build_free_nids(struct f2fs_sb_info *sbi, bool sync, bool mount);
		int build_free_nids(struct f2fs_sb_info *sbi, bool sync, bool mount);
		bool alloc_nid(struct f2fs_sb_info sbi, nid_t nid);
		void alloc_nid_done(struct f2fs_sb_info *sbi, nid_t nid);
		void alloc_nid_failed(struct f2fs_sb_info *sbi, nid_t nid);
		@@ -2781,9 +2784,9 @@ int try_to_free_nids(struct f2fs_sb_info *sbi, int nr_shrink);
		void recover_inline_xattr(struct inode inode, struct page page);
		int recover_xattr_data(struct inode inode, struct page page);
		int recover_inode_page(struct f2fs_sb_info sbi, struct page page);
		void restore_node_summary(struct f2fs_sb_info *sbi,
		int restore_node_summary(struct f2fs_sb_info *sbi,
		unsigned int segno, struct f2fs_summary_block *sum);
		void flush_nat_entries(struct f2fs_sb_info sbi, struct cp_control cpc);
		int flush_nat_entries(struct f2fs_sb_info sbi, struct cp_control cpc);
		int build_node_manager(struct f2fs_sb_info *sbi);
		void destroy_node_manager(struct f2fs_sb_info *sbi);
		int __init create_node_manager_caches(void);
		@@ -2855,6 +2858,7 @@ enum rw_hint io_type_to_rw_hint(struct f2fs_sb_info *sbi, enum page_type type,
		void f2fs_stop_checkpoint(struct f2fs_sb_info *sbi, bool end_io);
		struct page grab_meta_page(struct f2fs_sb_info sbi, pgoff_t index);
		struct page get_meta_page(struct f2fs_sb_info sbi, pgoff_t index);
		struct page f2fs_get_meta_page_nofail(struct f2fs_sb_info sbi, pgoff_t index);
		struct page get_tmp_page(struct f2fs_sb_info sbi, pgoff_t index);
		bool f2fs_is_valid_blkaddr(struct f2fs_sb_info *sbi,
		block_t blkaddr, int type);

fs/f2fs/file.c

+6 −1

Original line number	Diff line number	Diff line
		@@ -1058,7 +1058,12 @@ static int __clone_blkaddrs(struct inode src_inode, struct inode dst_inode,
		if (ret)
		return ret;

		get_node_info(sbi, dn.nid, &ni);
		ret = get_node_info(sbi, dn.nid, &ni);
		if (ret) {
		f2fs_put_dnode(&dn);
		return ret;
		}

		ilen = min((pgoff_t)
		ADDRS_PER_PAGE(dn.node_page, dst_inode) -
		dn.ofs_in_node, len - i);

fs/f2fs/gc.c

+26 −3

Original line number	Diff line number	Diff line
		@@ -526,7 +526,11 @@ static int gc_node_segment(struct f2fs_sb_info *sbi,
		continue;
		}

		get_node_info(sbi, nid, &ni);
		if (get_node_info(sbi, nid, &ni)) {
		f2fs_put_page(node_page, 1);
		continue;
		}

		if (ni.blk_addr != start_addr + off) {
		f2fs_put_page(node_page, 1);
		continue;
		@@ -585,7 +589,10 @@ static bool is_alive(struct f2fs_sb_info sbi, struct f2fs_summary sum,
		if (IS_ERR(node_page))
		return false;

		get_node_info(sbi, nid, dni);
		if (get_node_info(sbi, nid, dni)) {
		f2fs_put_page(node_page, 1);
		return false;
		}

		if (sum->version != dni->version) {
		f2fs_msg(sbi->sb, KERN_WARNING,
		@@ -665,7 +672,11 @@ static int move_data_block(struct inode *inode, block_t bidx,
		*/
		f2fs_wait_on_page_writeback(page, DATA, true);

		get_node_info(fio.sbi, dn.nid, &ni);
		err = get_node_info(fio.sbi, dn.nid, &ni);
		if (err)
		goto put_out;


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

		/* read page */
		@@ -987,6 +998,18 @@ static int do_garbage_collect(struct f2fs_sb_info *sbi,
		/* reference all summary page */
		while (segno < end_segno) {
		sum_page = get_sum_page(sbi, segno++);
		if (IS_ERR(sum_page)) {
		int err = PTR_ERR(sum_page);

		end_segno = segno - 1;
		for (segno = start_segno; segno < end_segno; segno++) {
		sum_page = find_get_page(META_MAPPING(sbi),
		GET_SUM_BLOCK(sbi, segno));
		f2fs_put_page(sum_page, 0);
		f2fs_put_page(sum_page, 0);
		}
		return err;
		}
		unlock_page(sum_page);
		}