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

/* * f2fs_dirty_inode() is called from __mark_inode_dirty() * * We should call set_dirty_inode to write the dirty inode through write_inode. */static void f2fs_dirty_inode(struct inode *inode, int flags){	set_inode_flag(F2FS_I(inode), FI_DIRTY_INODE);}

/* * 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){	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;//.........这里部分代码省略.........

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 __f2fs_setxattr(struct inode *inode, int index,			const char *name, const void *value, size_t size,			struct page *ipage, int flags){	struct f2fs_inode_info *fi = F2FS_I(inode);	struct f2fs_xattr_entry *here, *last;	void *base_addr;	int found, newsize;	size_t len;	__u32 new_hsize;	int error = -ENOMEM;	if (name == NULL)		return -EINVAL;	if (value == NULL)		size = 0;	len = strlen(name);	if (len > F2FS_NAME_LEN)		return -ERANGE;	if (size > MAX_VALUE_LEN(inode))		return -E2BIG;	base_addr = read_all_xattrs(inode, ipage);	if (!base_addr)		goto exit;	/* find entry with wanted name. */	here = __find_xattr(base_addr, index, len, name);	found = IS_XATTR_LAST_ENTRY(here) ? 0 : 1;	if ((flags & XATTR_REPLACE) && !found) {		error = -ENODATA;		goto exit;	} else if ((flags & XATTR_CREATE) && found) {		error = -EEXIST;		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 = -ENOSPC;			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.		 */		memset(last, 0, newsize);		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);//.........这里部分代码省略.........

static int find_fsync_dnodes(struct f2fs_sb_info *sbi, struct list_head *head){	unsigned long long cp_ver = cur_cp_version(F2FS_CKPT(sbi));	struct curseg_info *curseg;	struct page *page;	block_t blkaddr;	int err = 0;	/* get node pages in the current segment */	curseg = CURSEG_I(sbi, CURSEG_WARM_NODE);	blkaddr = NEXT_FREE_BLKADDR(sbi, curseg);	/* read node page */	page = alloc_page(GFP_F2FS_ZERO);	if (!page)		return -ENOMEM;	lock_page(page);	while (1) {		struct fsync_inode_entry *entry;		err = f2fs_submit_page_bio(sbi, page, blkaddr, READ_SYNC);		if (err)			return err;		lock_page(page);		if (cp_ver != cpver_of_node(page))			break;		if (!is_fsync_dnode(page))			goto next;		entry = get_fsync_inode(head, ino_of_node(page));		if (entry) {			if (IS_INODE(page) && is_dent_dnode(page))				set_inode_flag(F2FS_I(entry->inode),							FI_INC_LINK);		} else {			if (IS_INODE(page) && is_dent_dnode(page)) {				err = recover_inode_page(sbi, page);				if (err) {					f2fs_msg(sbi->sb, KERN_INFO,					 "%s: recover_inode_page failed: %d",								__func__, err);					break;				}			}			/* add this fsync inode to the list */			entry = kmem_cache_alloc(fsync_entry_slab, GFP_NOFS);			if (!entry) {				err = -ENOMEM;				break;			}			entry->inode = f2fs_iget(sbi->sb, ino_of_node(page));			if (IS_ERR(entry->inode)) {				err = PTR_ERR(entry->inode);				f2fs_msg(sbi->sb, KERN_INFO,					"%s: f2fs_iget failed: %d",					__func__, err);				kmem_cache_free(fsync_entry_slab, entry);				break;			}			list_add_tail(&entry->list, head);		}		entry->blkaddr = blkaddr;		err = recover_inode(entry->inode, page);		if (err && err != -ENOENT) {			f2fs_msg(sbi->sb, KERN_INFO,				"%s: recover_inode failed: %d",				__func__, err);			break;		}next:		/* check next segment */		blkaddr = next_blkaddr_of_node(page);	}	unlock_page(page);	__free_pages(page, 0);	return err;}

int _f2fs_get_encryption_info(struct inode *inode){	struct f2fs_inode_info *fi = F2FS_I(inode);	struct f2fs_crypt_info *crypt_info;	char full_key_descriptor[F2FS_KEY_DESC_PREFIX_SIZE +				(F2FS_KEY_DESCRIPTOR_SIZE * 2) + 1];	struct key *keyring_key = NULL;	struct f2fs_encryption_key *master_key;	struct f2fs_encryption_context ctx;	const struct user_key_payload *ukp;	struct crypto_skcipher *ctfm;	const char *cipher_str;	char raw_key[F2FS_MAX_KEY_SIZE];	char mode;	int res;	res = f2fs_crypto_initialize();	if (res)		return res;retry:	crypt_info = ACCESS_ONCE(fi->i_crypt_info);	if (crypt_info) {		if (!crypt_info->ci_keyring_key ||				key_validate(crypt_info->ci_keyring_key) == 0)			return 0;		f2fs_free_encryption_info(inode, crypt_info);		goto retry;	}	res = f2fs_getxattr(inode, F2FS_XATTR_INDEX_ENCRYPTION,				F2FS_XATTR_NAME_ENCRYPTION_CONTEXT,				&ctx, sizeof(ctx), NULL);	if (res < 0)		return res;	else if (res != sizeof(ctx))		return -EINVAL;	res = 0;	crypt_info = kmem_cache_alloc(f2fs_crypt_info_cachep, GFP_NOFS);	if (!crypt_info)		return -ENOMEM;	crypt_info->ci_flags = ctx.flags;	crypt_info->ci_data_mode = ctx.contents_encryption_mode;	crypt_info->ci_filename_mode = ctx.filenames_encryption_mode;	crypt_info->ci_ctfm = NULL;	crypt_info->ci_keyring_key = NULL;	memcpy(crypt_info->ci_master_key, ctx.master_key_descriptor,				sizeof(crypt_info->ci_master_key));	if (S_ISREG(inode->i_mode))		mode = crypt_info->ci_data_mode;	else if (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode))		mode = crypt_info->ci_filename_mode;	else		BUG();	switch (mode) {	case F2FS_ENCRYPTION_MODE_AES_256_XTS:		cipher_str = "xts(aes)";		break;	case F2FS_ENCRYPTION_MODE_AES_256_CTS:		cipher_str = "cts(cbc(aes))";		break;	default:		printk_once(KERN_WARNING			    "f2fs: unsupported key mode %d (ino %u)/n",			    mode, (unsigned) inode->i_ino);		res = -ENOKEY;		goto out;	}	memcpy(full_key_descriptor, F2FS_KEY_DESC_PREFIX,					F2FS_KEY_DESC_PREFIX_SIZE);	sprintf(full_key_descriptor + F2FS_KEY_DESC_PREFIX_SIZE,					"%*phN", F2FS_KEY_DESCRIPTOR_SIZE,					ctx.master_key_descriptor);	full_key_descriptor[F2FS_KEY_DESC_PREFIX_SIZE +					(2 * F2FS_KEY_DESCRIPTOR_SIZE)] = '/0';	keyring_key = request_key(&key_type_logon, full_key_descriptor, NULL);	if (IS_ERR(keyring_key)) {		res = PTR_ERR(keyring_key);		keyring_key = NULL;		goto out;	}	crypt_info->ci_keyring_key = keyring_key;	BUG_ON(keyring_key->type != &key_type_logon);	ukp = user_key_payload(keyring_key);	if (ukp->datalen != sizeof(struct f2fs_encryption_key)) {		res = -EINVAL;		goto out;	}	master_key = (struct f2fs_encryption_key *)ukp->data;	BUILD_BUG_ON(F2FS_AES_128_ECB_KEY_SIZE !=				F2FS_KEY_DERIVATION_NONCE_SIZE);	BUG_ON(master_key->size != F2FS_AES_256_XTS_KEY_SIZE);	res = f2fs_derive_key_aes(ctx.nonce, master_key->raw,				  raw_key);	if (res)		goto out;//.........这里部分代码省略.........

int f2fs_has_encryption_key(struct inode *inode){	struct f2fs_inode_info *fi = F2FS_I(inode);	return (fi->i_crypt_info != NULL);}

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);//.........这里部分代码省略.........

int f2fs_setxattr(struct inode *inode, int name_index, const char *name,			const void *value, size_t value_len, struct page *ipage){	struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);	struct f2fs_inode_info *fi = F2FS_I(inode);	struct f2fs_xattr_header *header = NULL;	struct f2fs_xattr_entry *here, *last;	struct page *page;	void *base_addr;	int error, found, free, newsize;	size_t name_len;	char *pval;	int ilock;	if (name == NULL)		return -EINVAL;	if (value == NULL)		value_len = 0;	name_len = strlen(name);	if (name_len > F2FS_NAME_LEN || value_len > MAX_VALUE_LEN)		return -ERANGE;	f2fs_balance_fs(sbi);	ilock = mutex_lock_op(sbi);	if (!fi->i_xattr_nid) {		/* Allocate new attribute block */		struct dnode_of_data dn;		if (!alloc_nid(sbi, &fi->i_xattr_nid)) {			error = -ENOSPC;			goto exit;		}		set_new_dnode(&dn, inode, NULL, NULL, fi->i_xattr_nid);		mark_inode_dirty(inode);		page = new_node_page(&dn, XATTR_NODE_OFFSET, ipage);		if (IS_ERR(page)) {			alloc_nid_failed(sbi, fi->i_xattr_nid);			fi->i_xattr_nid = 0;			error = PTR_ERR(page);			goto exit;		}		alloc_nid_done(sbi, fi->i_xattr_nid);		base_addr = page_address(page);		header = XATTR_HDR(base_addr);		header->h_magic = cpu_to_le32(F2FS_XATTR_MAGIC);		header->h_refcount = cpu_to_le32(1);	} else {		/* The inode already has an extended attribute block. */		page = get_node_page(sbi, fi->i_xattr_nid);		if (IS_ERR(page)) {			error = PTR_ERR(page);			goto exit;		}		base_addr = page_address(page);		header = XATTR_HDR(base_addr);	}	if (le32_to_cpu(header->h_magic) != F2FS_XATTR_MAGIC) {		error = -EIO;		goto cleanup;	}	/* find entry with wanted name. */	found = 0;	list_for_each_xattr(here, base_addr) {		if (here->e_name_index != name_index)			continue;		if (here->e_name_len != name_len)			continue;		if (!memcmp(here->e_name, name, name_len)) {			found = 1;			break;		}	}	last = here;	while (!IS_XATTR_LAST_ENTRY(last))		last = XATTR_NEXT_ENTRY(last);	newsize = XATTR_ALIGN(sizeof(struct f2fs_xattr_entry) +			name_len + value_len);	/* 1. Check space */	if (value) {		/* If value is NULL, it is remove operation.		 * In case of update operation, we caculate free.		 */		free = MIN_OFFSET - ((char *)last - (char *)header);		if (found)			free = free - ENTRY_SIZE(here);//.........这里部分代码省略.........

//.........这里部分代码省略.........	unlock_new_inode(inode);	return err;out:	clear_nlink(inode);	unlock_new_inode(inode);	make_bad_inode(inode);	iput(inode);	alloc_nid_failed(sbi, inode->i_ino);	return err;}static int f2fs_mkdir(struct inode *dir, struct dentry *dentry, int mode){	struct f2fs_sb_info *sbi;	struct inode *inode;	int err;	if (dir->i_nlink >= F2FS_LINK_MAX)		return -EMLINK;	sbi = F2FS_SB(dir->i_sb);	f2fs_balance_fs(sbi);	inode = f2fs_new_inode(dir, S_IFDIR | mode);	if (IS_ERR(inode))		return PTR_ERR(inode);	inode->i_op = &f2fs_dir_inode_operations;	inode->i_fop = &f2fs_dir_operations;	inode->i_mapping->a_ops = &f2fs_dblock_aops;	mapping_set_gfp_mask(inode->i_mapping, GFP_F2FS_ZERO);	set_inode_flag(F2FS_I(inode), FI_INC_LINK);	f2fs_lock_op(sbi);	err = f2fs_add_link(dentry, inode);	f2fs_unlock_op(sbi);	if (err)		goto out_fail;	alloc_nid_done(sbi, inode->i_ino);	d_instantiate(dentry, inode);	unlock_new_inode(inode);	return 0;out_fail:	clear_inode_flag(F2FS_I(inode), FI_INC_LINK);	clear_nlink(inode);	unlock_new_inode(inode);	make_bad_inode(inode);	iput(inode);	alloc_nid_failed(sbi, inode->i_ino);	return err;}static int f2fs_rmdir(struct inode *dir, struct dentry *dentry){	struct inode *inode = dentry->d_inode;	if (f2fs_empty_dir(inode))		return f2fs_unlink(dir, dentry);	return -ENOTEMPTY;}static int f2fs_mknod(struct inode *dir, struct dentry *dentry,

static int find_fsync_dnodes(struct f2fs_sb_info *sbi, struct list_head *head){	unsigned long long cp_ver = cur_cp_version(F2FS_CKPT(sbi));	struct curseg_info *curseg;	struct page *page = NULL;	block_t blkaddr;	int err = 0;	/* get node pages in the current segment */	curseg = CURSEG_I(sbi, CURSEG_WARM_NODE);	blkaddr = NEXT_FREE_BLKADDR(sbi, curseg);	ra_meta_pages(sbi, blkaddr, 1, META_POR);	while (1) {		struct fsync_inode_entry *entry;		if (blkaddr < MAIN_BLKADDR(sbi) || blkaddr >= MAX_BLKADDR(sbi))			return 0;		page = get_meta_page(sbi, blkaddr);		if (cp_ver != cpver_of_node(page))			break;		if (!is_fsync_dnode(page))			goto next;		entry = get_fsync_inode(head, ino_of_node(page));		if (entry) {			if (IS_INODE(page) && is_dent_dnode(page))				set_inode_flag(F2FS_I(entry->inode),							FI_INC_LINK);		} else {			if (IS_INODE(page) && is_dent_dnode(page)) {				err = recover_inode_page(sbi, page);				if (err)					break;			}			/* add this fsync inode to the list */			entry = kmem_cache_alloc(fsync_entry_slab, GFP_F2FS_ZERO);			if (!entry) {				err = -ENOMEM;				break;			}			/*			 * CP | dnode(F) | inode(DF)			 * For this case, we should not give up now.			 */			entry->inode = f2fs_iget(sbi->sb, ino_of_node(page));			if (IS_ERR(entry->inode)) {				err = PTR_ERR(entry->inode);				kmem_cache_free(fsync_entry_slab, entry);				if (err == -ENOENT)					goto next;				break;			}			list_add_tail(&entry->list, head);		}		entry->blkaddr = blkaddr;		if (IS_INODE(page)) {			entry->last_inode = blkaddr;			if (is_dent_dnode(page))				entry->last_dentry = blkaddr;		}next:		/* check next segment */		blkaddr = next_blkaddr_of_node(page);		f2fs_put_page(page, 1);		ra_meta_pages_cond(sbi, blkaddr);	}	f2fs_put_page(page, 1);	return err;}

/* * 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);}

/* * 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,						struct inode *inode){	unsigned int bit_pos;	unsigned int level;	unsigned int current_depth;	unsigned long bidx, block;	f2fs_hash_t dentry_hash;	struct f2fs_dir_entry *de;	unsigned int nbucket, nblock;	size_t namelen = name->len;	struct page *dentry_page = NULL;	struct f2fs_dentry_block *dentry_blk = NULL;	int slots = GET_DENTRY_SLOTS(namelen);	struct page *page;	int err = 0;	int i;	dentry_hash = f2fs_dentry_hash(name->name, name->len);	level = 0;	current_depth = F2FS_I(dir)->i_current_depth;	if (F2FS_I(dir)->chash == dentry_hash) {		level = F2FS_I(dir)->clevel;		F2FS_I(dir)->chash = 0;	}start:	if (unlikely(current_depth == MAX_DIR_HASH_DEPTH))		return -ENOSPC;	/* Increase the depth, if required */	if (level == current_depth)		++current_depth;	nbucket = dir_buckets(level);	nblock = bucket_blocks(level);	bidx = dir_block_index(level, (le32_to_cpu(dentry_hash) % nbucket));	for (block = bidx; block <= (bidx + nblock - 1); block++) {		dentry_page = get_new_data_page(dir, NULL, block, true);		if (IS_ERR(dentry_page))			return PTR_ERR(dentry_page);		dentry_blk = kmap(dentry_page);		bit_pos = room_for_filename(dentry_blk, slots);		if (bit_pos < NR_DENTRY_IN_BLOCK)			goto add_dentry;		kunmap(dentry_page);		f2fs_put_page(dentry_page, 1);	}	/* Move to next level to find the empty slot for new dentry */	++level;	goto start;add_dentry:	wait_on_page_writeback(dentry_page);	page = init_inode_metadata(inode, dir, name);	if (IS_ERR(page)) {		err = PTR_ERR(page);		goto fail;	}	de = &dentry_blk->dentry[bit_pos];	de->hash_code = dentry_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(dentry_page);	/* 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, current_depth);fail:	clear_inode_flag(F2FS_I(dir), FI_UPDATE_DIR);	kunmap(dentry_page);	f2fs_put_page(dentry_page, 1);	return err;}

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 = 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;}

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 inode *f2fs_iget_nowait(struct super_block *sb, unsigned long ino){	struct f2fs_iget_args args = {		.ino = ino,		.on_free = 0	};	struct inode *inode = ilookup5(sb, ino, f2fs_iget_test, &args);	if (inode)		return inode;	if (!args.on_free)		return f2fs_iget(sb, ino);	return ERR_PTR(-ENOENT);}static int do_read_inode(struct inode *inode){	struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);	struct f2fs_inode_info *fi = F2FS_I(inode);	struct page *node_page;	struct f2fs_node *rn;	struct f2fs_inode *ri;	/* Check if ino is within scope */	check_nid_range(sbi, inode->i_ino);	node_page = get_node_page(sbi, inode->i_ino);	if (IS_ERR(node_page))		return PTR_ERR(node_page);	rn = page_address(node_page);	ri = &(rn->i);	inode->i_mode = le16_to_cpu(ri->i_mode);	i_uid_write(inode, le32_to_cpu(ri->i_uid));	i_gid_write(inode, 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->data_version = le64_to_cpu(F2FS_CKPT(sbi)->checkpoint_ver) - 1;	fi->i_advise = ri->i_advise;	fi->i_pino = le32_to_cpu(ri->i_pino);	get_extent_info(&fi->ext, ri->i_ext);	f2fs_put_page(node_page, 1);	return 0;}struct inode *f2fs_iget(struct super_block *sb, unsigned long ino){	struct f2fs_sb_info *sbi = F2FS_SB(sb);	struct inode *inode;	int ret;	inode = iget_locked(sb, ino);	if (!inode)		return ERR_PTR(-ENOMEM);	if (!(inode->i_state & I_NEW))		return inode;	if (ino == F2FS_NODE_INO(sbi) || ino == F2FS_META_INO(sbi))		goto make_now;	ret = do_read_inode(inode);	if (ret)		goto bad_inode;	if (!sbi->por_doing && inode->i_nlink == 0) {		ret = -ENOENT;		goto bad_inode;	}make_now:	if (ino == F2FS_NODE_INO(sbi)) {		inode->i_mapping->a_ops = &f2fs_node_aops;		mapping_set_gfp_mask(inode->i_mapping, GFP_F2FS_ZERO);	} else if (ino == F2FS_META_INO(sbi)) {		inode->i_mapping->a_ops = &f2fs_meta_aops;		mapping_set_gfp_mask(inode->i_mapping, GFP_F2FS_ZERO);	} else if (S_ISREG(inode->i_mode)) {		inode->i_op = &f2fs_file_inode_operations;		inode->i_fop = &f2fs_file_operations;		inode->i_mapping->a_ops = &f2fs_dblock_aops;	} else if (S_ISDIR(inode->i_mode)) {		inode->i_op = &f2fs_dir_inode_operations;		inode->i_fop = &f2fs_dir_operations;		inode->i_mapping->a_ops = &f2fs_dblock_aops;		mapping_set_gfp_mask(inode->i_mapping, GFP_HIGHUSER_MOVABLE |				__GFP_ZERO);//.........这里部分代码省略.........

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);//.........这里部分代码省略.........

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 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 __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);//.........这里部分代码省略.........

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);//.........这里部分代码省略.........

void update_inode(struct inode *inode, struct page *node_page){	struct f2fs_inode *ri;	f2fs_wait_on_page_writeback(node_page, NODE);	ri = F2FS_INODE(node_page);	ri->i_mode = cpu_to_le16(inode->i_mode);	ri->i_advise = F2FS_I(inode)->i_advise;	ri->i_uid = cpu_to_le32(inode->i_uid);	ri->i_gid = cpu_to_le32(inode->i_gid);	ri->i_links = cpu_to_le32(inode->i_nlink);	ri->i_size = cpu_to_le64(i_size_read(inode));	ri->i_blocks = cpu_to_le64(inode->i_blocks);	read_lock(&F2FS_I(inode)->ext_lock);	set_raw_extent(&F2FS_I(inode)->ext, &ri->i_ext);	read_unlock(&F2FS_I(inode)->ext_lock);	set_raw_inline(F2FS_I(inode), ri);	ri->i_atime = cpu_to_le64(inode->i_atime.tv_sec);	ri->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec);	ri->i_mtime = cpu_to_le64(inode->i_mtime.tv_sec);	ri->i_atime_nsec = cpu_to_le32(inode->i_atime.tv_nsec);	ri->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);	ri->i_mtime_nsec = cpu_to_le32(inode->i_mtime.tv_nsec);	ri->i_current_depth = cpu_to_le32(F2FS_I(inode)->i_current_depth);	ri->i_xattr_nid = cpu_to_le32(F2FS_I(inode)->i_xattr_nid);	ri->i_flags = cpu_to_le32(F2FS_I(inode)->i_flags);	ri->i_pino = cpu_to_le32(F2FS_I(inode)->i_pino);	ri->i_generation = cpu_to_le32(inode->i_generation);	ri->i_dir_level = F2FS_I(inode)->i_dir_level;	__set_inode_rdev(inode, ri);	set_cold_node(inode, node_page);	set_page_dirty(node_page);	clear_inode_flag(F2FS_I(inode), FI_DIRTY_INODE);}

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);}

static void f2fs_i_callback(struct rcu_head *head){	struct inode *inode = container_of(head, struct inode, i_rcu);	kmem_cache_free(f2fs_inode_cachep, F2FS_I(inode));}

static int f2fs_rename(struct inode *old_dir, struct dentry *old_dentry,			struct inode *new_dir, struct dentry *new_dentry){	struct super_block *sb = old_dir->i_sb;	struct f2fs_sb_info *sbi = F2FS_SB(sb);	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;	}	f2fs_lock_op(sbi);	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;		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);		down_write(&F2FS_I(old_inode)->i_sem);		F2FS_I(old_inode)->i_pino = new_dir->i_ino;		up_write(&F2FS_I(old_inode)->i_sem);		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 {		err = f2fs_add_link(new_dentry, old_inode);		if (err)			goto out_dir;		if (old_dir_entry) {			inc_nlink(new_dir);			update_inode_page(new_dir);		}	}	old_inode->i_ctime = CURRENT_TIME;	mark_inode_dirty(old_inode);	f2fs_delete_entry(old_entry, old_page, NULL);	if (old_dir_entry) {		if (old_dir != new_dir) {			f2fs_set_link(old_inode, old_dir_entry,						old_dir_page, new_dir);			down_write(&F2FS_I(old_inode)->i_sem);			F2FS_I(old_inode)->i_pino = new_dir->i_ino;			up_write(&F2FS_I(old_inode)->i_sem);			update_inode_page(old_inode);		} else {			kunmap(old_dir_page);			f2fs_put_page(old_dir_page, 0);		}		drop_nlink(old_dir);//.........这里部分代码省略.........

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;}

/* * 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;//.........这里部分代码省略.........