自学教程：C++ F2FS_I_SB函数代码示例

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_I_SB(inode);	loff_t i_size = i_size_read(inode);	const pgoff_t end_index = ((unsigned long long) i_size)							>> PAGE_CACHE_SHIFT;	unsigned offset = 0;	bool need_balance_fs = false;	int err = 0;	struct f2fs_io_info fio = {		.sbi = sbi,		.type = DATA,		.rw = (wbc->sync_mode == WB_SYNC_ALL) ? WRITE_SYNC : WRITE,		.page = page,		.encrypted_page = NULL,	};	trace_f2fs_writepage(page, DATA);	if (page->index < end_index)		goto write;	/*	 * If the offset is out-of-range of file size,	 * this page does not have to be written to disk.	 */	offset = i_size & (PAGE_CACHE_SIZE - 1);	if ((page->index >= end_index + 1) || !offset)		goto out;	zero_user_segment(page, offset, PAGE_CACHE_SIZE);write:	if (unlikely(is_sbi_flag_set(sbi, SBI_POR_DOING)))		goto redirty_out;	if (f2fs_is_drop_cache(inode))		goto out;	if (f2fs_is_volatile_file(inode) && !wbc->for_reclaim &&			available_free_memory(sbi, BASE_CHECK))		goto redirty_out;	/* Dentry blocks are controlled by checkpoint */	if (S_ISDIR(inode->i_mode)) {		if (unlikely(f2fs_cp_error(sbi)))			goto redirty_out;		err = do_write_data_page(&fio);		goto done;	}	/* we should bypass data pages to proceed the kworkder jobs */	if (unlikely(f2fs_cp_error(sbi))) {		SetPageError(page);		goto out;	}	if (!wbc->for_reclaim)		need_balance_fs = true;	else if (has_not_enough_free_secs(sbi, 0))		goto redirty_out;	err = -EAGAIN;	f2fs_lock_op(sbi);	if (f2fs_has_inline_data(inode))		err = f2fs_write_inline_data(inode, page);	if (err == -EAGAIN)		err = do_write_data_page(&fio);	f2fs_unlock_op(sbi);done:	if (err && err != -ENOENT)		goto redirty_out;	clear_cold_data(page);out:	inode_dec_dirty_pages(inode);	if (err)		ClearPageUptodate(page);	unlock_page(page);	if (need_balance_fs)		f2fs_balance_fs(sbi);	if (wbc->for_reclaim)		f2fs_submit_merged_bio(sbi, DATA, WRITE);	return 0;redirty_out:	redirty_page_for_writepage(wbc, page);	return AOP_WRITEPAGE_ACTIVATE;}static int __f2fs_writepage(struct page *page, struct writeback_control *wbc,			void *data){	struct address_space *mapping = data;	int ret = mapping->a_ops->writepage(page, wbc);	mapping_set_error(mapping, ret);	return ret;}/* * This function was copied from write_cche_pages from mm/page-writeback.c.//.........这里部分代码省略.........

static int recover_dentry(struct inode *inode, struct page *ipage){	struct f2fs_inode *raw_inode = F2FS_INODE(ipage);	nid_t pino = le32_to_cpu(raw_inode->i_pino);	struct f2fs_dir_entry *de;	struct qstr name;	struct page *page;	struct inode *dir, *einode;	int err = 0;	dir = f2fs_iget(inode->i_sb, pino);	if (IS_ERR(dir)) {		err = PTR_ERR(dir);		goto out;	}	if (file_enc_name(inode)) {		iput(dir);		return 0;	}	name.len = le32_to_cpu(raw_inode->i_namelen);	name.name = raw_inode->i_name;	if (unlikely(name.len > F2FS_NAME_LEN)) {		WARN_ON(1);		err = -ENAMETOOLONG;		goto out_err;	}retry:	de = f2fs_find_entry(dir, &name, &page);	if (de && inode->i_ino == le32_to_cpu(de->ino))		goto out_unmap_put;	if (de) {		einode = f2fs_iget(inode->i_sb, le32_to_cpu(de->ino));		if (IS_ERR(einode)) {			WARN_ON(1);			err = PTR_ERR(einode);			if (err == -ENOENT)				err = -EEXIST;			goto out_unmap_put;		}		err = acquire_orphan_inode(F2FS_I_SB(inode));		if (err) {			iput(einode);			goto out_unmap_put;		}		f2fs_delete_entry(de, page, dir, einode);		iput(einode);		goto retry;	}	err = __f2fs_add_link(dir, &name, inode, inode->i_ino, inode->i_mode);	if (err)		goto out_err;	if (is_inode_flag_set(F2FS_I(dir), FI_DELAY_IPUT)) {		iput(dir);	} else {		add_dirty_dir_inode(dir);		set_inode_flag(F2FS_I(dir), FI_DELAY_IPUT);	}	goto out;out_unmap_put:	f2fs_dentry_kunmap(dir, page);	f2fs_put_page(page, 0);out_err:	iput(dir);out:	f2fs_msg(inode->i_sb, KERN_NOTICE,			"%s: ino = %x, name = %s, dir = %lx, err = %d",			__func__, ino_of_node(ipage), raw_inode->i_name,			IS_ERR(dir) ? 0 : dir->i_ino, err);	return err;}

static int do_read_inode(struct inode *inode){	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);	struct f2fs_inode_info *fi = F2FS_I(inode);	struct page *node_page;	struct f2fs_inode *ri;	/* Check if ino is within scope */	if (check_nid_range(sbi, inode->i_ino)) {		f2fs_msg(inode->i_sb, KERN_ERR, "bad inode number: %lu",			 (unsigned long) inode->i_ino);		WARN_ON(1);		return -EINVAL;	}	node_page = get_node_page(sbi, inode->i_ino);	if (IS_ERR(node_page))		return PTR_ERR(node_page);	ri = F2FS_INODE(node_page);	inode->i_mode = le16_to_cpu(ri->i_mode);	inode->i_uid = le32_to_cpu(ri->i_uid);	inode->i_gid = le32_to_cpu(ri->i_gid);	set_nlink(inode, le32_to_cpu(ri->i_links));	inode->i_size = le64_to_cpu(ri->i_size);	inode->i_blocks = le64_to_cpu(ri->i_blocks);	inode->i_atime.tv_sec = le64_to_cpu(ri->i_atime);	inode->i_ctime.tv_sec = le64_to_cpu(ri->i_ctime);	inode->i_mtime.tv_sec = le64_to_cpu(ri->i_mtime);	inode->i_atime.tv_nsec = le32_to_cpu(ri->i_atime_nsec);	inode->i_ctime.tv_nsec = le32_to_cpu(ri->i_ctime_nsec);	inode->i_mtime.tv_nsec = le32_to_cpu(ri->i_mtime_nsec);	inode->i_generation = le32_to_cpu(ri->i_generation);	fi->i_current_depth = le32_to_cpu(ri->i_current_depth);	fi->i_xattr_nid = le32_to_cpu(ri->i_xattr_nid);	fi->i_flags = le32_to_cpu(ri->i_flags);	fi->flags = 0;	fi->i_advise = ri->i_advise;	fi->i_pino = le32_to_cpu(ri->i_pino);	fi->i_dir_level = ri->i_dir_level;	f2fs_init_extent_tree(inode, &ri->i_ext);	get_inline_info(fi, ri);	/* check data exist */	if (f2fs_has_inline_data(inode) && !f2fs_exist_data(inode))		__recover_inline_status(inode, node_page);	/* get rdev by using inline_info */	__get_inode_rdev(inode, ri);	if (__written_first_block(ri))		set_inode_flag(F2FS_I(inode), FI_FIRST_BLOCK_WRITTEN);	f2fs_put_page(node_page, 1);	stat_inc_inline_xattr(inode);	stat_inc_inline_inode(inode);	stat_inc_inline_dir(inode);	return 0;}

static inline int write_all_xattrs(struct inode *inode, __u32 hsize,				void *txattr_addr, struct page *ipage){	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);	size_t inline_size = 0;	void *xattr_addr;	struct page *xpage;	nid_t new_nid = 0;	int err;	inline_size = inline_xattr_size(inode);	if (hsize > inline_size && !F2FS_I(inode)->i_xattr_nid)		if (!alloc_nid(sbi, &new_nid))			return -ENOSPC;	/* write to inline xattr */	if (inline_size) {		struct page *page = NULL;		void *inline_addr;		if (ipage) {			inline_addr = inline_xattr_addr(ipage);			f2fs_wait_on_page_writeback(ipage, NODE);		} else {			page = get_node_page(sbi, inode->i_ino);			if (IS_ERR(page)) {				alloc_nid_failed(sbi, new_nid);				return PTR_ERR(page);			}			inline_addr = inline_xattr_addr(page);			f2fs_wait_on_page_writeback(page, NODE);		}		memcpy(inline_addr, txattr_addr, inline_size);		f2fs_put_page(page, 1);		/* no need to use xattr node block */		if (hsize <= inline_size) {			err = truncate_xattr_node(inode, ipage);			alloc_nid_failed(sbi, new_nid);			return err;		}	}	/* write to xattr node block */	if (F2FS_I(inode)->i_xattr_nid) {		xpage = get_node_page(sbi, F2FS_I(inode)->i_xattr_nid);		if (IS_ERR(xpage)) {			alloc_nid_failed(sbi, new_nid);			return PTR_ERR(xpage);		}		f2fs_bug_on(sbi, new_nid);		f2fs_wait_on_page_writeback(xpage, NODE);	} else {		struct dnode_of_data dn;		set_new_dnode(&dn, inode, NULL, NULL, new_nid);		xpage = new_node_page(&dn, XATTR_NODE_OFFSET, ipage);		if (IS_ERR(xpage)) {			alloc_nid_failed(sbi, new_nid);			return PTR_ERR(xpage);		}		alloc_nid_done(sbi, new_nid);	}	xattr_addr = page_address(xpage);	memcpy(xattr_addr, txattr_addr + inline_size, PAGE_SIZE -						sizeof(struct node_footer));	set_page_dirty(xpage);	f2fs_put_page(xpage, 1);	/* need to checkpoint during fsync */	F2FS_I(inode)->xattr_ver = cur_cp_version(F2FS_CKPT(sbi));	return 0;}

int f2fs_convert_inline_page(struct dnode_of_data *dn, struct page *page){	void *src_addr, *dst_addr;	struct f2fs_io_info fio = {		.type = DATA,		.rw = WRITE_SYNC | REQ_PRIO,	};	int dirty, err;	f2fs_bug_on(F2FS_I_SB(dn->inode), page->index);	if (!f2fs_exist_data(dn->inode))		goto clear_out;	err = f2fs_reserve_block(dn, 0);	if (err)		return err;	f2fs_wait_on_page_writeback(page, DATA);	if (PageUptodate(page))		goto no_update;	zero_user_segment(page, MAX_INLINE_DATA, PAGE_CACHE_SIZE);	/* Copy the whole inline data block */	src_addr = inline_data_addr(dn->inode_page);	dst_addr = kmap_atomic(page);	memcpy(dst_addr, src_addr, MAX_INLINE_DATA);	flush_dcache_page(page);	kunmap_atomic(dst_addr);	SetPageUptodate(page);no_update:	/* clear dirty state */	dirty = clear_page_dirty_for_io(page);	/* write data page to try to make data consistent */	set_page_writeback(page);	fio.blk_addr = dn->data_blkaddr;	write_data_page(page, dn, &fio);	update_extent_cache(dn);	f2fs_wait_on_page_writeback(page, DATA);	if (dirty)		inode_dec_dirty_pages(dn->inode);	/* this converted inline_data should be recovered. */	set_inode_flag(F2FS_I(dn->inode), FI_APPEND_WRITE);	/* clear inline data and flag after data writeback */	truncate_inline_data(dn->inode_page);clear_out:	stat_dec_inline_inode(dn->inode);	f2fs_clear_inline_inode(dn->inode);	sync_inode_page(dn);	f2fs_put_dnode(dn);	return 0;}int f2fs_convert_inline_inode(struct inode *inode){	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);	struct dnode_of_data dn;	struct page *ipage, *page;	int err = 0;	page = grab_cache_page(inode->i_mapping, 0);	if (!page)		return -ENOMEM;	f2fs_lock_op(sbi);	ipage = get_node_page(sbi, inode->i_ino);	if (IS_ERR(ipage)) {		err = PTR_ERR(ipage);		goto out;	}	set_new_dnode(&dn, inode, ipage, ipage, 0);	if (f2fs_has_inline_data(inode))		err = f2fs_convert_inline_page(&dn, page);	f2fs_put_dnode(&dn);out:	f2fs_unlock_op(sbi);	f2fs_put_page(page, 1);	return err;}int f2fs_write_inline_data(struct inode *inode, struct page *page){	void *src_addr, *dst_addr;	struct dnode_of_data dn;	int err;	set_new_dnode(&dn, inode, NULL, NULL, 0);	err = get_dnode_of_data(&dn, 0, LOOKUP_NODE);	if (err)		return err;//.........这里部分代码省略.........

//.........这里部分代码省略.........	if (size > MAX_VALUE_LEN(inode))		return -E2BIG;	error = read_all_xattrs(inode, ipage, &base_addr);	if (error)		return error;	/* find entry with wanted name. */	here = __find_xattr(base_addr, index, len, name);	found = IS_XATTR_LAST_ENTRY(here) ? 0 : 1;	if (found) {		if ((flags & XATTR_CREATE)) {			error = -EEXIST;			goto exit;		}		if (f2fs_xattr_value_same(here, value, size))			goto exit;	} else if ((flags & XATTR_REPLACE)) {		error = -ENODATA;		goto exit;	}	last = here;	while (!IS_XATTR_LAST_ENTRY(last))		last = XATTR_NEXT_ENTRY(last);	newsize = XATTR_ALIGN(sizeof(struct f2fs_xattr_entry) + len + size);	/* 1. Check space */	if (value) {		int free;		/*		 * If value is NULL, it is remove operation.		 * In case of update operation, we calculate free.		 */		free = MIN_OFFSET(inode) - ((char *)last - (char *)base_addr);		if (found)			free = free + ENTRY_SIZE(here);		if (unlikely(free < newsize)) {			error = -E2BIG;			goto exit;		}	}	/* 2. Remove old entry */	if (found) {		/*		 * If entry is found, remove old entry.		 * If not found, remove operation is not needed.		 */		struct f2fs_xattr_entry *next = XATTR_NEXT_ENTRY(here);		int oldsize = ENTRY_SIZE(here);		memmove(here, next, (char *)last - (char *)next);		last = (struct f2fs_xattr_entry *)((char *)last - oldsize);		memset(last, 0, oldsize);	}	new_hsize = (char *)last - (char *)base_addr;	/* 3. Write new entry */	if (value) {		char *pval;		/*		 * Before we come here, old entry is removed.		 * We just write new entry.		 */		last->e_name_index = index;		last->e_name_len = len;		memcpy(last->e_name, name, len);		pval = last->e_name + len;		memcpy(pval, value, size);		last->e_value_size = cpu_to_le16(size);		new_hsize += newsize;	}	error = write_all_xattrs(inode, new_hsize, base_addr, ipage);	if (error)		goto exit;	if (is_inode_flag_set(inode, FI_ACL_MODE)) {		inode->i_mode = F2FS_I(inode)->i_acl_mode;		inode->i_ctime = current_time(inode);		clear_inode_flag(inode, FI_ACL_MODE);	}	if (index == F2FS_XATTR_INDEX_ENCRYPTION &&			!strcmp(name, F2FS_XATTR_NAME_ENCRYPTION_CONTEXT))		f2fs_set_encrypted_inode(inode);	f2fs_mark_inode_dirty_sync(inode, true);	if (!error && S_ISDIR(inode->i_mode))		set_sbi_flag(F2FS_I_SB(inode), SBI_NEED_CP);exit:	kzfree(base_addr);	return error;}

static struct inode *f2fs_new_inode(struct inode *dir, umode_t mode){	struct f2fs_sb_info *sbi = F2FS_I_SB(dir);	nid_t ino;	struct inode *inode;	bool nid_free = false;	int err;	inode = new_inode(dir->i_sb);	if (!inode)		return ERR_PTR(-ENOMEM);	f2fs_lock_op(sbi);	if (!alloc_nid(sbi, &ino)) {		f2fs_unlock_op(sbi);		err = -ENOSPC;		goto fail;	}	f2fs_unlock_op(sbi);	inode_init_owner(inode, dir, mode);	inode->i_ino = ino;	inode->i_blocks = 0;	inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;	inode->i_generation = sbi->s_next_generation++;	err = insert_inode_locked(inode);	if (err) {		err = -EINVAL;		nid_free = true;		goto out;	}	/* If the directory encrypted, then we should encrypt the inode. */	if (f2fs_encrypted_inode(dir) && f2fs_may_encrypt(inode))		f2fs_set_encrypted_inode(inode);	if (f2fs_may_inline_data(inode))		set_inode_flag(F2FS_I(inode), FI_INLINE_DATA);	if (f2fs_may_inline_dentry(inode))		set_inode_flag(F2FS_I(inode), FI_INLINE_DENTRY);	f2fs_init_extent_tree(inode, NULL);	stat_inc_inline_xattr(inode);	stat_inc_inline_inode(inode);	stat_inc_inline_dir(inode);	trace_f2fs_new_inode(inode, 0);	mark_inode_dirty(inode);	return inode;out:	clear_nlink(inode);	unlock_new_inode(inode);fail:	trace_f2fs_new_inode(inode, err);	make_bad_inode(inode);	if (nid_free)		set_inode_flag(F2FS_I(inode), FI_FREE_NID);	iput(inode);	return ERR_PTR(err);}

static int recover_dentry(struct inode *inode, struct page *ipage,						struct list_head *dir_list){	struct f2fs_inode *raw_inode = F2FS_INODE(ipage);	nid_t pino = le32_to_cpu(raw_inode->i_pino);	struct f2fs_dir_entry *de;	struct fscrypt_name fname;	struct page *page;	struct inode *dir, *einode;	struct fsync_inode_entry *entry;	int err = 0;	char *name;	entry = get_fsync_inode(dir_list, pino);	if (!entry) {		entry = add_fsync_inode(F2FS_I_SB(inode), dir_list,							pino, false);		if (IS_ERR(entry)) {			dir = ERR_CAST(entry);			err = PTR_ERR(entry);			goto out;		}	}	dir = entry->inode;	memset(&fname, 0, sizeof(struct fscrypt_name));	fname.disk_name.len = le32_to_cpu(raw_inode->i_namelen);	fname.disk_name.name = raw_inode->i_name;	if (unlikely(fname.disk_name.len > F2FS_NAME_LEN)) {		WARN_ON(1);		err = -ENAMETOOLONG;		goto out;	}retry:	de = __f2fs_find_entry(dir, &fname, &page);	if (de && inode->i_ino == le32_to_cpu(de->ino))		goto out_put;	if (de) {		einode = f2fs_iget_retry(inode->i_sb, le32_to_cpu(de->ino));		if (IS_ERR(einode)) {			WARN_ON(1);			err = PTR_ERR(einode);			if (err == -ENOENT)				err = -EEXIST;			goto out_put;		}		err = dquot_initialize(einode);		if (err) {			iput(einode);			goto out_put;		}		err = f2fs_acquire_orphan_inode(F2FS_I_SB(inode));		if (err) {			iput(einode);			goto out_put;		}		f2fs_delete_entry(de, page, dir, einode);		iput(einode);		goto retry;	} else if (IS_ERR(page)) {		err = PTR_ERR(page);	} else {		err = f2fs_add_dentry(dir, &fname, inode,					inode->i_ino, inode->i_mode);	}	if (err == -ENOMEM)		goto retry;	goto out;out_put:	f2fs_put_page(page, 0);out:	if (file_enc_name(inode))		name = "<encrypted>";	else		name = raw_inode->i_name;	f2fs_msg(inode->i_sb, KERN_NOTICE,			"%s: ino = %x, name = %s, dir = %lx, err = %d",			__func__, ino_of_node(ipage), name,			IS_ERR(dir) ? 0 : dir->i_ino, err);	return err;}

//.........这里部分代码省略.........			goto got_it;		/*		 * Then do more f2fs_map_blocks() calls until we are		 * done with this page.		 */		map.m_flags = 0;		if (block_in_file < last_block) {			map.m_lblk = block_in_file;			map.m_len = last_block - block_in_file;			if (f2fs_map_blocks(inode, &map, 0, false))				goto set_error_page;		}got_it:		if ((map.m_flags & F2FS_MAP_MAPPED)) {			block_nr = map.m_pblk + block_in_file - map.m_lblk;			SetPageMappedToDisk(page);			if (!PageUptodate(page) && !cleancache_get_page(page)) {				SetPageUptodate(page);				goto confused;			}		} else {			zero_user_segment(page, 0, PAGE_CACHE_SIZE);			SetPageUptodate(page);			unlock_page(page);			goto next_page;		}		/*		 * This page will go to BIO.  Do we need to send this		 * BIO off first?		 */		if (bio && (last_block_in_bio != block_nr - 1)) {submit_and_realloc:			submit_bio(READ, bio);			bio = NULL;		}		if (bio == NULL) {			struct f2fs_crypto_ctx *ctx = NULL;			if (f2fs_encrypted_inode(inode) &&					S_ISREG(inode->i_mode)) {				struct page *cpage;				ctx = f2fs_get_crypto_ctx(inode);				if (IS_ERR(ctx))					goto set_error_page;				/* wait the page to be moved by cleaning */				cpage = find_lock_page(						META_MAPPING(F2FS_I_SB(inode)),						block_nr);				if (cpage) {					f2fs_wait_on_page_writeback(cpage,									DATA);					f2fs_put_page(cpage, 1);				}			}			bio = bio_alloc(GFP_KERNEL,				min_t(int, nr_pages, bio_get_nr_vecs(bdev)));			if (!bio) {				if (ctx)					f2fs_release_crypto_ctx(ctx);				goto set_error_page;			}			bio->bi_bdev = bdev;			bio->bi_sector = SECTOR_FROM_BLOCK(block_nr);			bio->bi_end_io = f2fs_read_end_io;			bio->bi_private = ctx;		}		if (bio_add_page(bio, page, blocksize, 0) < blocksize)			goto submit_and_realloc;		last_block_in_bio = block_nr;		goto next_page;set_error_page:		SetPageError(page);		zero_user_segment(page, 0, PAGE_CACHE_SIZE);		unlock_page(page);		goto next_page;confused:		if (bio) {			submit_bio(READ, bio);			bio = NULL;		}		unlock_page(page);next_page:		if (pages)			page_cache_release(page);	}	BUG_ON(pages && !list_empty(pages));	if (bio)		submit_bio(READ, bio);	return 0;}

/* * f2fs_map_blocks() now supported readahead/bmap/rw direct_IO with * f2fs_map_blocks structure. * If original data blocks are allocated, then give them to blockdev. * Otherwise, *     a. preallocate requested block addresses *     b. do not use extent cache for better performance *     c. give the block addresses to blockdev */static int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map,						int create, int flag){	unsigned int maxblocks = map->m_len;	struct dnode_of_data dn;	int mode = create ? ALLOC_NODE : LOOKUP_NODE_RA;	pgoff_t pgofs, end_offset;	int err = 0, ofs = 1;	struct extent_info ei;	bool allocated = false;	map->m_len = 0;	map->m_flags = 0;	/* it only supports block size == page size */	pgofs =	(pgoff_t)map->m_lblk;	if (f2fs_lookup_extent_cache(inode, pgofs, &ei)) {		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;		goto out;	}	if (create)		f2fs_lock_op(F2FS_I_SB(inode));	/* When reading holes, we need its node page */	set_new_dnode(&dn, inode, NULL, NULL, 0);	err = get_dnode_of_data(&dn, pgofs, mode);	if (err) {		if (err == -ENOENT)			err = 0;		goto unlock_out;	}	if (dn.data_blkaddr == NEW_ADDR) {		if (flag == F2FS_GET_BLOCK_BMAP) {			err = -ENOENT;			goto put_out;		} else if (flag == F2FS_GET_BLOCK_READ ||				flag == F2FS_GET_BLOCK_DIO) {			goto put_out;		}		/*		 * if it is in fiemap call path (flag = F2FS_GET_BLOCK_FIEMAP),		 * mark it as mapped and unwritten block.		 */	}	if (dn.data_blkaddr != NULL_ADDR) {		map->m_flags = F2FS_MAP_MAPPED;		map->m_pblk = dn.data_blkaddr;		if (dn.data_blkaddr == NEW_ADDR)			map->m_flags |= F2FS_MAP_UNWRITTEN;	} else if (create) {		err = __allocate_data_block(&dn);		if (err)			goto put_out;		allocated = true;		map->m_flags = F2FS_MAP_NEW | F2FS_MAP_MAPPED;		map->m_pblk = dn.data_blkaddr;	} else {		if (flag == F2FS_GET_BLOCK_BMAP)			err = -ENOENT;		goto put_out;	}	end_offset = ADDRS_PER_PAGE(dn.node_page, F2FS_I(inode));	map->m_len = 1;	dn.ofs_in_node++;	pgofs++;get_next:	if (dn.ofs_in_node >= end_offset) {		if (allocated)			sync_inode_page(&dn);		allocated = false;		f2fs_put_dnode(&dn);		set_new_dnode(&dn, inode, NULL, NULL, 0);		err = get_dnode_of_data(&dn, pgofs, mode);		if (err) {			if (err == -ENOENT)				err = 0;			goto unlock_out;		}		if (dn.data_blkaddr == NEW_ADDR &&				flag != F2FS_GET_BLOCK_FIEMAP)			goto put_out;//.........这里部分代码省略.........

static int f2fs_write_begin(struct file *file, struct address_space *mapping,		loff_t pos, unsigned len, unsigned flags,		struct page **pagep, void **fsdata){	struct inode *inode = mapping->host;	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);	struct page *page = NULL;	struct page *ipage;	pgoff_t index = ((unsigned long long) pos) >> PAGE_CACHE_SHIFT;	struct dnode_of_data dn;	int err = 0;	trace_f2fs_write_begin(inode, pos, len, flags);	f2fs_balance_fs(sbi);	/*	 * We should check this at this moment to avoid deadlock on inode page	 * and #0 page. The locking rule for inline_data conversion should be:	 * lock_page(page #0) -> lock_page(inode_page)	 */	if (index != 0) {		err = f2fs_convert_inline_inode(inode);		if (err)			goto fail;	}repeat:	page = grab_cache_page_write_begin(mapping, index, flags);	if (!page) {		err = -ENOMEM;		goto fail;	}	*pagep = page;	f2fs_lock_op(sbi);	/* check inline_data */	ipage = get_node_page(sbi, inode->i_ino);	if (IS_ERR(ipage)) {		err = PTR_ERR(ipage);		goto unlock_fail;	}	set_new_dnode(&dn, inode, ipage, ipage, 0);	if (f2fs_has_inline_data(inode)) {		if (pos + len <= MAX_INLINE_DATA) {			read_inline_data(page, ipage);			set_inode_flag(F2FS_I(inode), FI_DATA_EXIST);			sync_inode_page(&dn);			goto put_next;		}		err = f2fs_convert_inline_page(&dn, page);		if (err)			goto put_fail;	}	err = f2fs_get_block(&dn, index);	if (err)		goto put_fail;put_next:	f2fs_put_dnode(&dn);	f2fs_unlock_op(sbi);	f2fs_wait_on_page_writeback(page, DATA);	if (len == PAGE_CACHE_SIZE)		goto out_update;	if (PageUptodate(page))		goto out_clear;	if ((pos & PAGE_CACHE_MASK) >= i_size_read(inode)) {		unsigned start = pos & (PAGE_CACHE_SIZE - 1);		unsigned end = start + len;		/* Reading beyond i_size is simple: memset to zero */		zero_user_segments(page, 0, start, end, PAGE_CACHE_SIZE);		goto out_update;	}	if (dn.data_blkaddr == NEW_ADDR) {		zero_user_segment(page, 0, PAGE_CACHE_SIZE);	} else {		struct f2fs_io_info fio = {			.sbi = sbi,			.type = DATA,			.rw = READ_SYNC,			.blk_addr = dn.data_blkaddr,			.page = page,			.encrypted_page = NULL,		};		err = f2fs_submit_page_bio(&fio);		if (err)			goto fail;		lock_page(page);		if (unlikely(!PageUptodate(page))) {			err = -EIO;			goto fail;//.........这里部分代码省略.........

int f2fs_add_inline_entry(struct inode *dir, const struct qstr *new_name,				const struct qstr *orig_name,				struct inode *inode, nid_t ino, umode_t mode){	struct f2fs_sb_info *sbi = F2FS_I_SB(dir);	struct page *ipage;	unsigned int bit_pos;	f2fs_hash_t name_hash;	struct f2fs_inline_dentry *inline_dentry = NULL;	struct f2fs_dentry_ptr d;	int slots = GET_DENTRY_SLOTS(new_name->len);	struct page *page = NULL;	int err = 0;	ipage = get_node_page(sbi, dir->i_ino);	if (IS_ERR(ipage))		return PTR_ERR(ipage);	inline_dentry = inline_data_addr(ipage);	bit_pos = room_for_filename(&inline_dentry->dentry_bitmap,						slots, NR_INLINE_DENTRY);	if (bit_pos >= NR_INLINE_DENTRY) {		err = f2fs_convert_inline_dir(dir, ipage, inline_dentry);		if (err)			return err;		err = -EAGAIN;		goto out;	}	if (inode) {		down_write(&F2FS_I(inode)->i_sem);		page = init_inode_metadata(inode, dir, new_name,						orig_name, ipage);		if (IS_ERR(page)) {			err = PTR_ERR(page);			goto fail;		}	}	f2fs_wait_on_page_writeback(ipage, NODE, true);	name_hash = f2fs_dentry_hash(new_name, NULL);	make_dentry_ptr_inline(NULL, &d, inline_dentry);	f2fs_update_dentry(ino, mode, &d, new_name, name_hash, bit_pos);	set_page_dirty(ipage);	/* we don't need to mark_inode_dirty now */	if (inode) {		f2fs_i_pino_write(inode, dir->i_ino);		f2fs_put_page(page, 1);	}	update_parent_metadata(dir, inode, 0);fail:	if (inode)		up_write(&F2FS_I(inode)->i_sem);out:	f2fs_put_page(ipage, 1);	return err;}

static inline int write_all_xattrs(struct inode *inode, __u32 hsize,				void *txattr_addr, struct page *ipage){	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);	size_t inline_size = inline_xattr_size(inode);	struct page *in_page = NULL;	void *xattr_addr;	void *inline_addr = NULL;	struct page *xpage;	nid_t new_nid = 0;	int err = 0;	if (hsize > inline_size && !F2FS_I(inode)->i_xattr_nid)		if (!alloc_nid(sbi, &new_nid))			return -ENOSPC;	/* write to inline xattr */	if (inline_size) {		if (ipage) {			inline_addr = inline_xattr_addr(inode, ipage);		} else {			in_page = get_node_page(sbi, inode->i_ino);			if (IS_ERR(in_page)) {				alloc_nid_failed(sbi, new_nid);				return PTR_ERR(in_page);			}			inline_addr = inline_xattr_addr(inode, in_page);		}		f2fs_wait_on_page_writeback(ipage ? ipage : in_page,							NODE, true);		/* no need to use xattr node block */		if (hsize <= inline_size) {			err = truncate_xattr_node(inode);			alloc_nid_failed(sbi, new_nid);			if (err) {				f2fs_put_page(in_page, 1);				return err;			}			memcpy(inline_addr, txattr_addr, inline_size);			set_page_dirty(ipage ? ipage : in_page);			goto in_page_out;		}	}	/* write to xattr node block */	if (F2FS_I(inode)->i_xattr_nid) {		xpage = get_node_page(sbi, F2FS_I(inode)->i_xattr_nid);		if (IS_ERR(xpage)) {			alloc_nid_failed(sbi, new_nid);			goto in_page_out;		}		f2fs_bug_on(sbi, new_nid);		f2fs_wait_on_page_writeback(xpage, NODE, true);	} else {		struct dnode_of_data dn;		set_new_dnode(&dn, inode, NULL, NULL, new_nid);		xpage = new_node_page(&dn, XATTR_NODE_OFFSET);		if (IS_ERR(xpage)) {			alloc_nid_failed(sbi, new_nid);			goto in_page_out;		}		alloc_nid_done(sbi, new_nid);	}	xattr_addr = page_address(xpage);	if (inline_size)		memcpy(inline_addr, txattr_addr, inline_size);	memcpy(xattr_addr, txattr_addr + inline_size, VALID_XATTR_BLOCK_SIZE);	if (inline_size)		set_page_dirty(ipage ? ipage : in_page);	set_page_dirty(xpage);	f2fs_put_page(xpage, 1);in_page_out:	f2fs_put_page(in_page, 1);	return err;}

struct dentry *f2fs_get_parent(struct dentry *child){	struct qstr dotdot = {.len = 2, .name = ".."};	unsigned long ino = f2fs_inode_by_name(child->d_inode, &dotdot);	if (!ino)		return ERR_PTR(-ENOENT);	return d_obtain_alias(f2fs_iget(child->d_inode->i_sb, ino));}static int __recover_dot_dentries(struct inode *dir, nid_t pino){	struct f2fs_sb_info *sbi = F2FS_I_SB(dir);	struct qstr dot = {.len = 1, .name = "."};	struct qstr dotdot = {.len = 2, .name = ".."};	struct f2fs_dir_entry *de;	struct page *page;	int err = 0;	f2fs_lock_op(sbi);	de = f2fs_find_entry(dir, &dot, &page);	if (de) {		f2fs_dentry_kunmap(dir, page);		f2fs_put_page(page, 0);	} else {		err = __f2fs_add_link(dir, &dot, NULL, dir->i_ino, S_IFDIR);		if (err)			goto out;	}	de = f2fs_find_entry(dir, &dotdot, &page);	if (de) {		f2fs_dentry_kunmap(dir, page);		f2fs_put_page(page, 0);	} else {		err = __f2fs_add_link(dir, &dotdot, NULL, pino, S_IFDIR);	}out:	if (!err) {		clear_inode_flag(F2FS_I(dir), FI_INLINE_DOTS);		mark_inode_dirty(dir);	}	f2fs_unlock_op(sbi);	return err;}static struct dentry *f2fs_lookup(struct inode *dir, struct dentry *dentry,					struct nameidata *nd){	struct inode *inode = NULL;	struct f2fs_dir_entry *de;	struct page *page;	nid_t ino;	int err = 0;	if (dentry->d_name.len > F2FS_NAME_LEN)		return ERR_PTR(-ENAMETOOLONG);	de = f2fs_find_entry(dir, &dentry->d_name, &page);	if (!de)		return d_splice_alias(inode, dentry);	ino = le32_to_cpu(de->ino);	f2fs_dentry_kunmap(dir, page);	f2fs_put_page(page, 0);	inode = f2fs_iget(dir->i_sb, ino);	if (IS_ERR(inode))		return ERR_CAST(inode);	if (f2fs_has_inline_dots(inode)) {		err = __recover_dot_dentries(inode, dir->i_ino);		if (err)			goto err_out;	}	return d_splice_alias(inode, dentry);err_out:	iget_failed(inode);	return ERR_PTR(err);}static int f2fs_unlink(struct inode *dir, struct dentry *dentry){	struct f2fs_sb_info *sbi = F2FS_I_SB(dir);	struct inode *inode = dentry->d_inode;	struct f2fs_dir_entry *de;	struct page *page;	int err = -ENOENT;	trace_f2fs_unlink_enter(dir, dentry);	f2fs_balance_fs(sbi);	de = f2fs_find_entry(dir, &dentry->d_name, &page);	if (!de)		goto fail;	f2fs_lock_op(sbi);	err = acquire_orphan_inode(sbi);//.........这里部分代码省略.........

struct dentry *f2fs_get_parent(struct dentry *child){	struct qstr dotdot = {.len = 2, .name = ".."};	unsigned long ino = f2fs_inode_by_name(child->d_inode, &dotdot);	if (!ino)		return ERR_PTR(-ENOENT);	return d_obtain_alias(f2fs_iget(child->d_inode->i_sb, ino));}static struct dentry *f2fs_lookup(struct inode *dir, struct dentry *dentry,					struct nameidata *nd){	struct inode *inode = NULL;	struct f2fs_dir_entry *de;	struct page *page;	if (dentry->d_name.len > F2FS_NAME_LEN)		return ERR_PTR(-ENAMETOOLONG);	de = f2fs_find_entry(dir, &dentry->d_name, &page, nd ? nd->flags : 0);	if (de) {		nid_t ino = le32_to_cpu(de->ino);		if (!f2fs_has_inline_dentry(dir))			kunmap(page);		f2fs_put_page(page, 0);		inode = f2fs_iget(dir->i_sb, ino);		if (IS_ERR(inode))			return ERR_CAST(inode);	}	return d_splice_alias(inode, dentry);}static int f2fs_unlink(struct inode *dir, struct dentry *dentry){	struct f2fs_sb_info *sbi = F2FS_I_SB(dir);	struct inode *inode = dentry->d_inode;	struct f2fs_dir_entry *de;	struct page *page;	int err = -ENOENT;	trace_f2fs_unlink_enter(dir, dentry);	f2fs_balance_fs(sbi);	de = f2fs_find_entry(dir, &dentry->d_name, &page, 0);	if (!de)		goto fail;	f2fs_lock_op(sbi);	err = acquire_orphan_inode(sbi);	if (err) {		f2fs_unlock_op(sbi);		if (!f2fs_has_inline_dentry(dir))			kunmap(page);		f2fs_put_page(page, 0);		goto fail;	}	f2fs_delete_entry(de, page, dir, inode);	f2fs_unlock_op(sbi);	/* In order to evict this inode, we set it dirty */	mark_inode_dirty(inode);fail:	trace_f2fs_unlink_exit(inode, err);	return err;}static int f2fs_symlink(struct inode *dir, struct dentry *dentry,					const char *symname){	struct f2fs_sb_info *sbi = F2FS_I_SB(dir);	struct inode *inode;	size_t symlen = strlen(symname) + 1;	int err;	f2fs_balance_fs(sbi);	inode = f2fs_new_inode(dir, S_IFLNK | S_IRWXUGO);	if (IS_ERR(inode))		return PTR_ERR(inode);	inode->i_op = &f2fs_symlink_inode_operations;	inode->i_mapping->a_ops = &f2fs_dblock_aops;	f2fs_lock_op(sbi);	err = f2fs_add_link(dentry, inode);	if (err)		goto out;	f2fs_unlock_op(sbi);	err = page_symlink(inode, symname, symlen);	alloc_nid_done(sbi, inode->i_ino);	d_instantiate(dentry, inode);	unlock_new_inode(inode);	return err;out:	handle_failed_inode(inode);	return err;//.........这里部分代码省略.........

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_I_SB(inode);	nid_t ino = inode->i_ino;	int ret = 0;	bool need_cp = false;	struct writeback_control wbc = {		.sync_mode = WB_SYNC_ALL,		.nr_to_write = LONG_MAX,		.for_reclaim = 0,	};	if (unlikely(f2fs_readonly(inode->i_sb)))		return 0;	trace_f2fs_sync_file_enter(inode);	/* if fdatasync is triggered, let's do in-place-update */	if (get_dirty_pages(inode) <= SM_I(sbi)->min_fsync_blocks)		set_inode_flag(fi, FI_NEED_IPU);	ret = filemap_write_and_wait_range(inode->i_mapping, start, end);	clear_inode_flag(fi, FI_NEED_IPU);	if (ret) {		trace_f2fs_sync_file_exit(inode, need_cp, datasync, ret);		return ret;	}	/* if the inode is dirty, let's recover all the time */	if (!datasync && is_inode_flag_set(fi, FI_DIRTY_INODE)) {		update_inode_page(inode);		goto go_write;	}	/*	 * if there is no written data, don't waste time to write recovery info.	 */	if (!is_inode_flag_set(fi, FI_APPEND_WRITE) &&			!exist_written_data(sbi, ino, APPEND_INO)) {		/* it may call write_inode just prior to fsync */		if (need_inode_page_update(sbi, ino))			goto go_write;		if (is_inode_flag_set(fi, FI_UPDATE_WRITE) ||				exist_written_data(sbi, ino, UPDATE_INO))			goto flush_out;		goto out;	}go_write:	/* guarantee free sections for fsync */	f2fs_balance_fs(sbi);	/*	 * Both of fdatasync() and fsync() are able to be recovered from	 * sudden-power-off.	 */	down_read(&fi->i_sem);	need_cp = need_do_checkpoint(inode);	up_read(&fi->i_sem);	if (need_cp) {		/* all the dirty node pages should be flushed for POR */		ret = f2fs_sync_fs(inode->i_sb, 1);		/*		 * We've secured consistency through sync_fs. Following pino		 * will be used only for fsynced inodes after checkpoint.		 */		try_to_fix_pino(inode);		goto out;	}sync_nodes:	sync_node_pages(sbi, ino, &wbc);	/* if cp_error was enabled, we should avoid infinite loop */	if (unlikely(f2fs_cp_error(sbi)))		goto out;	if (need_inode_block_update(sbi, ino)) {		mark_inode_dirty_sync(inode);		f2fs_write_inode(inode, NULL);		goto sync_nodes;	}	ret = wait_on_node_pages_writeback(sbi, ino);	if (ret)		goto out;	/* once recovery info is written, don't need to tack this */	remove_dirty_inode(sbi, ino, APPEND_INO);	clear_inode_flag(fi, FI_APPEND_WRITE);flush_out:	remove_dirty_inode(sbi, ino, UPDATE_INO);	clear_inode_flag(fi, FI_UPDATE_WRITE);	ret = f2fs_issue_flush(sbi);out:	trace_f2fs_sync_file_exit(inode, need_cp, datasync, ret);//.........这里部分代码省略.........

/* * Called at the last iput() if i_nlink is zero */void f2fs_evict_inode(struct inode *inode){	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);	nid_t xnid = F2FS_I(inode)->i_xattr_nid;	int err = 0;	/* some remained atomic pages should discarded */	if (f2fs_is_atomic_file(inode))		drop_inmem_pages(inode);	trace_f2fs_evict_inode(inode);	truncate_inode_pages_final(&inode->i_data);	if (inode->i_ino == F2FS_NODE_INO(sbi) ||			inode->i_ino == F2FS_META_INO(sbi))		goto out_clear;	f2fs_bug_on(sbi, get_dirty_pages(inode));	remove_dirty_inode(inode);	f2fs_destroy_extent_tree(inode);	if (inode->i_nlink || is_bad_inode(inode))		goto no_delete;	remove_ino_entry(sbi, inode->i_ino, APPEND_INO);	remove_ino_entry(sbi, inode->i_ino, UPDATE_INO);	sb_start_intwrite(inode->i_sb);	set_inode_flag(inode, FI_NO_ALLOC);	i_size_write(inode, 0);retry:	if (F2FS_HAS_BLOCKS(inode))		err = f2fs_truncate(inode);#ifdef CONFIG_F2FS_FAULT_INJECTION	if (time_to_inject(sbi, FAULT_EVICT_INODE)) {		f2fs_show_injection_info(FAULT_EVICT_INODE);		err = -EIO;	}#endif	if (!err) {		f2fs_lock_op(sbi);		err = remove_inode_page(inode);		f2fs_unlock_op(sbi);		if (err == -ENOENT)			err = 0;	}	/* give more chances, if ENOMEM case */	if (err == -ENOMEM) {		err = 0;		goto retry;	}	if (err)		update_inode_page(inode);	sb_end_intwrite(inode->i_sb);no_delete:	stat_dec_inline_xattr(inode);	stat_dec_inline_dir(inode);	stat_dec_inline_inode(inode);	/* ino == 0, if f2fs_new_inode() was failed t*/	if (inode->i_ino)		invalidate_mapping_pages(NODE_MAPPING(sbi), inode->i_ino,							inode->i_ino);	if (xnid)		invalidate_mapping_pages(NODE_MAPPING(sbi), xnid, xnid);	if (inode->i_nlink) {		if (is_inode_flag_set(inode, FI_APPEND_WRITE))			add_ino_entry(sbi, inode->i_ino, APPEND_INO);		if (is_inode_flag_set(inode, FI_UPDATE_WRITE))			add_ino_entry(sbi, inode->i_ino, UPDATE_INO);	}	if (is_inode_flag_set(inode, FI_FREE_NID)) {		alloc_nid_failed(sbi, inode->i_ino);		clear_inode_flag(inode, FI_FREE_NID);	}	f2fs_bug_on(sbi, err &&		!exist_written_data(sbi, inode->i_ino, ORPHAN_INO));out_clear:	fscrypt_put_encryption_info(inode, NULL);	clear_inode(inode);}

int f2fs_add_inline_entry(struct inode *dir, const struct qstr *name,						struct inode *inode){	struct f2fs_sb_info *sbi = F2FS_I_SB(dir);	struct page *ipage;	unsigned int bit_pos;	f2fs_hash_t name_hash;	struct f2fs_dir_entry *de;	size_t namelen = name->len;	struct f2fs_inline_dentry *dentry_blk = NULL;	int slots = GET_DENTRY_SLOTS(namelen);	struct page *page;	int err = 0;	int i;	name_hash = f2fs_dentry_hash(name);	ipage = get_node_page(sbi, dir->i_ino);	if (IS_ERR(ipage))		return PTR_ERR(ipage);	dentry_blk = inline_data_addr(ipage);	bit_pos = room_for_filename(&dentry_blk->dentry_bitmap,						slots, NR_INLINE_DENTRY);	if (bit_pos >= NR_INLINE_DENTRY) {		err = f2fs_convert_inline_dir(dir, ipage, dentry_blk);		if (!err)			err = -EAGAIN;		goto out;	}	down_write(&F2FS_I(inode)->i_sem);	page = init_inode_metadata(inode, dir, name, ipage);	if (IS_ERR(page)) {		err = PTR_ERR(page);		goto fail;	}	f2fs_wait_on_page_writeback(ipage, NODE);	de = &dentry_blk->dentry[bit_pos];	de->hash_code = name_hash;	de->name_len = cpu_to_le16(namelen);	memcpy(dentry_blk->filename[bit_pos], name->name, name->len);	de->ino = cpu_to_le32(inode->i_ino);	set_de_type(de, inode);	for (i = 0; i < slots; i++)		test_and_set_bit_le(bit_pos + i, &dentry_blk->dentry_bitmap);	set_page_dirty(ipage);	/* we don't need to mark_inode_dirty now */	F2FS_I(inode)->i_pino = dir->i_ino;	update_inode(inode, page);	f2fs_put_page(page, 1);	update_parent_metadata(dir, inode, 0);fail:	up_write(&F2FS_I(inode)->i_sem);	if (is_inode_flag_set(F2FS_I(dir), FI_UPDATE_DIR)) {		update_inode(dir, ipage);		clear_inode_flag(F2FS_I(dir), FI_UPDATE_DIR);	}out:	f2fs_put_page(ipage, 1);	return err;}

static int f2fs_rename(struct inode *old_dir, struct dentry *old_dentry,			struct inode *new_dir, struct dentry *new_dentry){	struct f2fs_sb_info *sbi = F2FS_I_SB(old_dir);	struct inode *old_inode = old_dentry->d_inode;	struct inode *new_inode = new_dentry->d_inode;	struct page *old_dir_page;	struct page *old_page, *new_page;	struct f2fs_dir_entry *old_dir_entry = NULL;	struct f2fs_dir_entry *old_entry;	struct f2fs_dir_entry *new_entry;	int err = -ENOENT;	f2fs_balance_fs(sbi);	old_entry = f2fs_find_entry(old_dir, &old_dentry->d_name, &old_page);	if (!old_entry)		goto out;	if (S_ISDIR(old_inode->i_mode)) {		err = -EIO;		old_dir_entry = f2fs_parent_dir(old_inode, &old_dir_page);		if (!old_dir_entry)			goto out_old;	}	if (new_inode) {		err = -ENOTEMPTY;		if (old_dir_entry && !f2fs_empty_dir(new_inode))			goto out_dir;		err = -ENOENT;		new_entry = f2fs_find_entry(new_dir, &new_dentry->d_name,						&new_page);		if (!new_entry)			goto out_dir;		f2fs_lock_op(sbi);		err = acquire_orphan_inode(sbi);		if (err)			goto put_out_dir;		if (update_dent_inode(old_inode, &new_dentry->d_name)) {			release_orphan_inode(sbi);			goto put_out_dir;		}		f2fs_set_link(new_dir, new_entry, new_page, old_inode);		new_inode->i_ctime = CURRENT_TIME;		down_write(&F2FS_I(new_inode)->i_sem);		if (old_dir_entry)			drop_nlink(new_inode);		drop_nlink(new_inode);		up_write(&F2FS_I(new_inode)->i_sem);		mark_inode_dirty(new_inode);		if (!new_inode->i_nlink)			add_orphan_inode(sbi, new_inode->i_ino);		else			release_orphan_inode(sbi);		update_inode_page(old_inode);		update_inode_page(new_inode);	} else {		f2fs_lock_op(sbi);		err = f2fs_add_link(new_dentry, old_inode);		if (err) {			f2fs_unlock_op(sbi);			goto out_dir;		}		if (old_dir_entry) {			inc_nlink(new_dir);			update_inode_page(new_dir);		}	}	down_write(&F2FS_I(old_inode)->i_sem);	file_lost_pino(old_inode);	up_write(&F2FS_I(old_inode)->i_sem);	old_inode->i_ctime = CURRENT_TIME;	mark_inode_dirty(old_inode);	f2fs_delete_entry(old_entry, old_page, old_dir, NULL);	if (old_dir_entry) {		if (old_dir != new_dir) {			f2fs_set_link(old_inode, old_dir_entry,						old_dir_page, new_dir);			update_inode_page(old_inode);		} else {			f2fs_dentry_kunmap(old_inode, old_dir_page);			f2fs_put_page(old_dir_page, 0);		}//.........这里部分代码省略.........

static int __f2fs_convert_inline_data(struct inode *inode, struct page *page){	int err = 0;	struct page *ipage;	struct dnode_of_data dn;	void *src_addr, *dst_addr;	block_t new_blk_addr;	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);	struct f2fs_io_info fio = {		.type = DATA,		.rw = WRITE_SYNC | REQ_PRIO,	};	f2fs_lock_op(sbi);	ipage = get_node_page(sbi, inode->i_ino);	if (IS_ERR(ipage)) {		err = PTR_ERR(ipage);		goto out;	}	/* someone else converted inline_data already */	if (!f2fs_has_inline_data(inode))		goto out;	/*	 * i_addr[0] is not used for inline data,	 * so reserving new block will not destroy inline data	 */	set_new_dnode(&dn, inode, ipage, NULL, 0);	err = f2fs_reserve_block(&dn, 0);	if (err)		goto out;	f2fs_wait_on_page_writeback(page, DATA);	zero_user_segment(page, MAX_INLINE_DATA, PAGE_CACHE_SIZE);	/* Copy the whole inline data block */	src_addr = inline_data_addr(ipage);	dst_addr = kmap(page);	memcpy(dst_addr, src_addr, MAX_INLINE_DATA);	kunmap(page);	SetPageUptodate(page);	/* write data page to try to make data consistent */	set_page_writeback(page);	write_data_page(page, &dn, &new_blk_addr, &fio);	update_extent_cache(new_blk_addr, &dn);	f2fs_wait_on_page_writeback(page, DATA);	/* clear inline data and flag after data writeback */	zero_user_segment(ipage, INLINE_DATA_OFFSET,				 INLINE_DATA_OFFSET + MAX_INLINE_DATA);	clear_inode_flag(F2FS_I(inode), FI_INLINE_DATA);	stat_dec_inline_inode(inode);	sync_inode_page(&dn);	f2fs_put_dnode(&dn);out:	f2fs_unlock_op(sbi);	return err;}int f2fs_convert_inline_data(struct inode *inode, pgoff_t to_size,						struct page *page){	struct page *new_page = page;	int err;	if (!f2fs_has_inline_data(inode))		return 0;	else if (to_size <= MAX_INLINE_DATA)		return 0;	if (!page || page->index != 0) {		new_page = grab_cache_page(inode->i_mapping, 0);		if (!new_page)			return -ENOMEM;	}	err = __f2fs_convert_inline_data(inode, new_page);	if (!page || page->index != 0)		f2fs_put_page(new_page, 1);	return err;}int f2fs_write_inline_data(struct inode *inode,				struct page *page, unsigned size){	void *src_addr, *dst_addr;	struct page *ipage;	struct dnode_of_data dn;	int err;	set_new_dnode(&dn, inode, NULL, NULL, 0);	err = get_dnode_of_data(&dn, 0, LOOKUP_NODE);	if (err)		return err;	ipage = dn.inode_page;	f2fs_wait_on_page_writeback(ipage, NODE);//.........这里部分代码省略.........

static int f2fs_cross_rename(struct inode *old_dir, struct dentry *old_dentry,			     struct inode *new_dir, struct dentry *new_dentry){	struct f2fs_sb_info *sbi = F2FS_I_SB(old_dir);	struct inode *old_inode = old_dentry->d_inode;	struct inode *new_inode = new_dentry->d_inode;	struct page *old_dir_page, *new_dir_page;	struct page *old_page, *new_page;	struct f2fs_dir_entry *old_dir_entry = NULL, *new_dir_entry = NULL;	struct f2fs_dir_entry *old_entry, *new_entry;	int old_nlink = 0, new_nlink = 0;	int err = -ENOENT;	f2fs_balance_fs(sbi);	old_entry = f2fs_find_entry(old_dir, &old_dentry->d_name, &old_page);	if (!old_entry)		goto out;	new_entry = f2fs_find_entry(new_dir, &new_dentry->d_name, &new_page);	if (!new_entry)		goto out_old;	/* prepare for updating ".." directory entry info later */	if (old_dir != new_dir) {		if (S_ISDIR(old_inode->i_mode)) {			err = -EIO;			old_dir_entry = f2fs_parent_dir(old_inode,							&old_dir_page);			if (!old_dir_entry)				goto out_new;		}		if (S_ISDIR(new_inode->i_mode)) {			err = -EIO;			new_dir_entry = f2fs_parent_dir(new_inode,							&new_dir_page);			if (!new_dir_entry)				goto out_old_dir;		}	}	/*	 * If cross rename between file and directory those are not	 * in the same directory, we will inc nlink of file's parent	 * later, so we should check upper boundary of its nlink.	 */	if ((!old_dir_entry || !new_dir_entry) &&				old_dir_entry != new_dir_entry) {		old_nlink = old_dir_entry ? -1 : 1;		new_nlink = -old_nlink;		err = -EMLINK;		if ((old_nlink > 0 && old_inode->i_nlink >= F2FS_LINK_MAX) ||			(new_nlink > 0 && new_inode->i_nlink >= F2FS_LINK_MAX))			goto out_new_dir;	}	f2fs_lock_op(sbi);	err = update_dent_inode(old_inode, &new_dentry->d_name);	if (err)		goto out_unlock;	err = update_dent_inode(new_inode, &old_dentry->d_name);	if (err)		goto out_undo;	/* update ".." directory entry info of old dentry */	if (old_dir_entry)		f2fs_set_link(old_inode, old_dir_entry, old_dir_page, new_dir);	/* update ".." directory entry info of new dentry */	if (new_dir_entry)		f2fs_set_link(new_inode, new_dir_entry, new_dir_page, old_dir);	/* update directory entry info of old dir inode */	f2fs_set_link(old_dir, old_entry, old_page, new_inode);	down_write(&F2FS_I(old_inode)->i_sem);	file_lost_pino(old_inode);	up_write(&F2FS_I(old_inode)->i_sem);	update_inode_page(old_inode);	old_dir->i_ctime = CURRENT_TIME;	if (old_nlink) {		down_write(&F2FS_I(old_dir)->i_sem);		if (old_nlink < 0)			drop_nlink(old_dir);		else			inc_nlink(old_dir);		up_write(&F2FS_I(old_dir)->i_sem);	}	mark_inode_dirty(old_dir);	update_inode_page(old_dir);	/* update directory entry info of new dir inode */	f2fs_set_link(new_dir, new_entry, new_page, old_inode);	down_write(&F2FS_I(new_inode)->i_sem);//.........这里部分代码省略.........

/* * Called at the last iput() if i_nlink is zero */void f2fs_evict_inode(struct inode *inode){	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);	struct f2fs_inode_info *fi = F2FS_I(inode);	nid_t xnid = fi->i_xattr_nid;	int err = 0;	/* some remained atomic pages should discarded */	if (f2fs_is_atomic_file(inode))		commit_inmem_pages(inode, true);	trace_f2fs_evict_inode(inode);	truncate_inode_pages(&inode->i_data, 0);	if (inode->i_ino == F2FS_NODE_INO(sbi) ||			inode->i_ino == F2FS_META_INO(sbi))		goto out_clear;	f2fs_bug_on(sbi, get_dirty_pages(inode));	remove_dirty_dir_inode(inode);	f2fs_destroy_extent_tree(inode);	if (inode->i_nlink || is_bad_inode(inode))		goto no_delete;	set_inode_flag(fi, FI_NO_ALLOC);	i_size_write(inode, 0);	if (F2FS_HAS_BLOCKS(inode))		err = f2fs_truncate(inode, true);	if (!err) {		f2fs_lock_op(sbi);		err = remove_inode_page(inode);		f2fs_unlock_op(sbi);	}no_delete:	stat_dec_inline_xattr(inode);	stat_dec_inline_dir(inode);	stat_dec_inline_inode(inode);	invalidate_mapping_pages(NODE_MAPPING(sbi), inode->i_ino, inode->i_ino);	if (xnid)		invalidate_mapping_pages(NODE_MAPPING(sbi), xnid, xnid);	if (is_inode_flag_set(fi, FI_APPEND_WRITE))		add_dirty_inode(sbi, inode->i_ino, APPEND_INO);	if (is_inode_flag_set(fi, FI_UPDATE_WRITE))		add_dirty_inode(sbi, inode->i_ino, UPDATE_INO);	if (is_inode_flag_set(fi, FI_FREE_NID)) {		if (err && err != -ENOENT)			alloc_nid_done(sbi, inode->i_ino);		else			alloc_nid_failed(sbi, inode->i_ino);		clear_inode_flag(fi, FI_FREE_NID);	}	if (err && err != -ENOENT) {		if (!exist_written_data(sbi, inode->i_ino, ORPHAN_INO)) {			/*			 * get here because we failed to release resource			 * of inode previously, reminder our user to run fsck			 * for fixing.			 */			set_sbi_flag(sbi, SBI_NEED_FSCK);			f2fs_msg(sbi->sb, KERN_WARNING,				"inode (ino:%lu) resource leak, run fsck "				"to fix this issue!", inode->i_ino);		}	}out_clear:#ifdef CONFIG_F2FS_FS_ENCRYPTION	if (fi->i_crypt_info)		f2fs_free_encryption_info(inode, fi->i_crypt_info);#endif	end_writeback(inode);}

int f2fs_convert_inline_page(struct dnode_of_data *dn, struct page *page){	struct f2fs_io_info fio = {		.sbi = F2FS_I_SB(dn->inode),		.type = DATA,		.op = REQ_OP_WRITE,		.op_flags = REQ_SYNC | REQ_PRIO,		.page = page,		.encrypted_page = NULL,	};	int dirty, err;	if (!f2fs_exist_data(dn->inode))		goto clear_out;	err = f2fs_reserve_block(dn, 0);	if (err)		return err;	f2fs_bug_on(F2FS_P_SB(page), PageWriteback(page));	read_inline_data(page, dn->inode_page);	set_page_dirty(page);	/* clear dirty state */	dirty = clear_page_dirty_for_io(page);	/* write data page to try to make data consistent */	set_page_writeback(page);	fio.old_blkaddr = dn->data_blkaddr;	set_inode_flag(dn->inode, FI_HOT_DATA);	write_data_page(dn, &fio);	f2fs_wait_on_page_writeback(page, DATA, true);	if (dirty) {		inode_dec_dirty_pages(dn->inode);		remove_dirty_inode(dn->inode);	}	/* this converted inline_data should be recovered. */	set_inode_flag(dn->inode, FI_APPEND_WRITE);	/* clear inline data and flag after data writeback */	truncate_inline_inode(dn->inode, dn->inode_page, 0);	clear_inline_node(dn->inode_page);clear_out:	stat_dec_inline_inode(dn->inode);	clear_inode_flag(dn->inode, FI_INLINE_DATA);	f2fs_put_dnode(dn);	return 0;}int f2fs_convert_inline_inode(struct inode *inode){	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);	struct dnode_of_data dn;	struct page *ipage, *page;	int err = 0;	if (!f2fs_has_inline_data(inode))		return 0;	page = f2fs_grab_cache_page(inode->i_mapping, 0, false);	if (!page)		return -ENOMEM;	f2fs_lock_op(sbi);	ipage = get_node_page(sbi, inode->i_ino);	if (IS_ERR(ipage)) {		err = PTR_ERR(ipage);		goto out;	}	set_new_dnode(&dn, inode, ipage, ipage, 0);	if (f2fs_has_inline_data(inode))		err = f2fs_convert_inline_page(&dn, page);	f2fs_put_dnode(&dn);out:	f2fs_unlock_op(sbi);	f2fs_put_page(page, 1);	f2fs_balance_fs(sbi, dn.node_changed);	return err;}int f2fs_write_inline_data(struct inode *inode, struct page *page){	void *src_addr, *dst_addr;	struct dnode_of_data dn;	int err;	set_new_dnode(&dn, inode, NULL, NULL, 0);	err = get_dnode_of_data(&dn, 0, LOOKUP_NODE);	if (err)		return err;//.........这里部分代码省略.........

struct page *init_inode_metadata(struct inode *inode, struct inode *dir,                                 const struct qstr *name, struct page *dpage){    struct page *page;    int err;    if (is_inode_flag_set(F2FS_I(inode), FI_NEW_INODE)) {        page = new_inode_page(inode);        if (IS_ERR(page))            return page;        if (S_ISDIR(inode->i_mode)) {            err = make_empty_dir(inode, dir, page);            if (err)                goto error;        }        err = f2fs_init_acl(inode, dir, page, dpage);        if (err)            goto put_error;        err = f2fs_init_security(inode, dir, name, page);        if (err)            goto put_error;    } else {        page = get_node_page(F2FS_I_SB(dir), inode->i_ino);        if (IS_ERR(page))            return page;        set_cold_node(inode, page);    }    if (name)        init_dent_inode(name, page);    /*     * This file should be checkpointed during fsync.     * We lost i_pino from now on.     */    if (is_inode_flag_set(F2FS_I(inode), FI_INC_LINK)) {        file_lost_pino(inode);        /*         * If link the tmpfile to alias through linkat path,         * we should remove this inode from orphan list.         */        if (inode->i_nlink == 0)            remove_orphan_inode(F2FS_I_SB(dir), inode->i_ino);        inc_nlink(inode);    }    return page;put_error:    f2fs_put_page(page, 1);error:    /* once the failed inode becomes a bad inode, i_mode is S_IFREG */    truncate_inode_pages(&inode->i_data, 0);    truncate_blocks(inode, 0, false);    remove_dirty_dir_inode(inode);    remove_inode_page(inode);    return ERR_PTR(err);}

int f2fs_add_inline_entry(struct inode *dir, const struct qstr *name,			struct inode *inode, nid_t ino, umode_t mode){	struct f2fs_sb_info *sbi = F2FS_I_SB(dir);	struct page *ipage;	unsigned int bit_pos;	f2fs_hash_t name_hash;	size_t namelen = name->len;	struct f2fs_inline_dentry *dentry_blk = NULL;	struct f2fs_dentry_ptr d;	int slots = GET_DENTRY_SLOTS(namelen);	struct page *page = NULL;	int err = 0;	ipage = get_node_page(sbi, dir->i_ino);	if (IS_ERR(ipage))		return PTR_ERR(ipage);	dentry_blk = inline_data_addr(ipage);	bit_pos = room_for_filename(&dentry_blk->dentry_bitmap,						slots, NR_INLINE_DENTRY);	if (bit_pos >= NR_INLINE_DENTRY) {		err = f2fs_convert_inline_dir(dir, ipage, dentry_blk);		if (!err)			err = -EAGAIN;		goto out;	}	if (inode) {		down_write(&F2FS_I(inode)->i_sem);		page = init_inode_metadata(inode, dir, name, ipage);		if (IS_ERR(page)) {			err = PTR_ERR(page);			goto fail;		}	}	f2fs_wait_on_page_writeback(ipage, NODE);	name_hash = f2fs_dentry_hash(name);	make_dentry_ptr(&d, (void *)dentry_blk, 2);	f2fs_update_dentry(ino, mode, &d, name, name_hash, bit_pos);	set_page_dirty(ipage);	/* we don't need to mark_inode_dirty now */	if (inode) {		F2FS_I(inode)->i_pino = dir->i_ino;		update_inode(inode, page);		f2fs_put_page(page, 1);	}	update_parent_metadata(dir, inode, 0);fail:	if (inode)		up_write(&F2FS_I(inode)->i_sem);	if (is_inode_flag_set(F2FS_I(dir), FI_UPDATE_DIR)) {		update_inode(dir, ipage);		clear_inode_flag(F2FS_I(dir), FI_UPDATE_DIR);	}out:	f2fs_put_page(ipage, 1);	return err;}