F2FS源码分析-3.1 [F2FS 文件创建和删除部分] 一般文件的创建

F2FS的文件创建流程

文件创建流程介绍

linux的文件的创建可以抽象为两个流程

1. 创建一个inode，使得包含文件的元数据信息;
2. 将这个新创建的inode加入父目录的管理当中，可以理解建立父目录与这个新inode的关系。

到具体代码，上述两个抽象流程在F2FS中主要包含了以下几个子流程:

1. 调用vfs_open函数
2. 调用f2fs_create函数: 创建文件inode，并连接到父目录
   1. f2fs_new_inode函数创建inode
   2. f2fs_add_link函数链接到父目录

第一步的vfs_open函数是VFS层面的流程，下面仅针对涉及F2FS的文件创建流程，且经过简化的主要流程进行分析。

前置概念: inode和f2fs_inode_info

众所周知，inode结构是linux的vfs层最核心的结构之一，反应了文件的应该具有的基础信息，但是对于一些文件系统，原生的inode结构的信息并不够，还需要增加一些额外的变量去支持文件系统的某些功能，同时为了保证vfs层对所有文件系统的兼容性，我们直接修改inode结构不是一个明智的方法。针对这种场景，f2fs使用了一种叫f2fs_inode_info的结构去扩展原有的inode的功能。

相互转换

从inode到f2fs_inode_info:

static inline struct f2fs_inode_info *F2FS_I(struct inode *inode)
{
	return container_of(inode, struct f2fs_inode_info, vfs_inode);
}

从f2fs_inode_info到inode:

// vfs的inode其实是f2fs_inode_info结构体的一个内部变量
struct f2fs_inode_info {
	struct inode vfs_inode;		/* serve a vfs inode */
	...
};

// 因此访问可以直接指向
struct f2fs_inode_info *fi = F2FS_I(inode);
fi->vfs_inode // 这里 fi->vfs_inode == inode

从上面代码我们可以看出，f2fs中的inode是f2fs_inode_info当中的一个内部变量，因此可以用container_of这个函数直接获得，也可以通过指针获得。

F2FS中的VFS inode的创建和销毁

我们一般使用VFS提供的new_inode函数创建一个新inode。这个new_inode函数内部会调用new_inode_pseudo函数，然后再调用alloc_inode函数，最后调用f2fs_alloc_inode函数，我们从这里开始分析:

如下代码，显然就是通过内存分配函数先创建一个f2fs_inode_info然后返回给上层:

static struct inode *f2fs_alloc_inode(struct super_block *sb)
{
	struct f2fs_inode_info *fi;

	fi = kmem_cache_alloc(f2fs_inode_cachep, GFP_F2FS_ZERO); //简单直接创建f2fs_inode_info
	if (!fi)
		return NULL;

	init_once((void *) fi); // 这个函数初始化vfs inode部分的原始信息

    // 下面开始初始化f2fs_inode_info部分的原始信息
	atomic_set(&fi->dirty_pages, 0);
	init_rwsem(&fi->i_sem);
	...
	return &fi->vfs_inode; // 返回的vfs_inode给上层
}

当vfs inode的link是0的时候，它应当被销毁。由于vfs inode是f2fs_inode_info的内部变量，它如何被销毁呢:

// 用户传入一个inode销毁
static void f2fs_destroy_inode(struct inode *inode)
{
	call_rcu(&inode->i_rcu, f2fs_i_callback);
}

同样简单直接，free掉这块内存就行

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

f2fs_create函数

这个函数的主要作用是创建vfs_inode，并链接到对应的目录下，核心流程就是先创建该文件的基于f2fs的inode结构(参考xxx)，以及它对应的f2fs的inode page，即f2fs_inode。然后设置函数指针，最后将这个f2fs的inode page链接到对应的目录下。

static int f2fs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
						bool excl)
{
	struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
	struct inode *inode;
	nid_t ino = 0;
	int err;

	inode = f2fs_new_inode(dir, mode); // 创建f2fs特定的inode结构

	inode->i_op = &f2fs_file_inode_operations; // 然后赋值对应的函数指针
	inode->i_fop = &f2fs_file_operations;
	inode->i_mapping->a_ops = &f2fs_dblock_aops;
	ino = inode->i_ino; // 记录该inode的ino

	err = f2fs_add_link(dentry, inode); // 将该inode链接到用户传入的父目录dir中
	if (err)
		goto out;

	f2fs_alloc_nid_done(sbi, ino); // 在f2fs_new_inode函数内分配了ino，在这里完成最后一步

	return 0;
}

f2fs_new_inode函数

下面继续分析f2fs_new_inode函数(只显示主干部分)，这个函数创建inode结构，还没创建对应的f2fs inode page

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 xattr_size = 0;
	int err;

	inode = new_inode(dir->i_sb); // 先创建出来一个没有ino的inode结构，参考前面提及的创建流程

	if (!f2fs_alloc_nid(sbi, &ino)) { // 然后给这个inode分配一个nid，即ino
		goto fail;
	}
    
	nid_free = true;

	inode_init_owner(inode, dir, mode); // 初始化从属信息: 访问模式、父目录等

	inode->i_ino = ino; // 初始化一些元数据信息，例如ino
	inode->i_blocks = 0;
	inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
	F2FS_I(inode)->i_crtime = inode->i_mtime;
	inode->i_generation = sbi->s_next_generation++;

	err = insert_inode_locked(inode); // 将这个inode插入到全局的inode table(VFS行为)

    set_inode_flag(inode, FI_NEW_INODE); // 注意这个标志位后面会用到
    
	......
	// 上面省略代码都在设置法f2fs_inode_info的flag，并在这个函数将部分flag设置到vfs inode中
	f2fs_set_inode_flags(inode); 
	return inode;
}

f2fs_add_link函数

经过上面的函数，我们已经创建了一个f2fs使用的vfs inode，接下来我们要将这个inode链接到父目录的inode当中，建立联系，f2fs_add_link函数直接会调用f2fs_do_add_link函数，因此我们直接分析这个函数。其中f2fs_dir_entry代表是目录项，具体的作用含义在目录项的作用相关章节(新坑待填)介绍，这里可以理解为父目录包含了多个子文件/目录项，每一个目录项对应一个子文件/子目录的关联信息。我们将上一节新创建的inode加入到父目录的管理，也就是在父目录中为这个新inode下创建一个目录项。

static inline int f2fs_add_link(struct dentry *dentry, struct inode *inode)
{
    // 这里的dentry就是新inode的dentry
	return f2fs_do_add_link(d_inode(dentry->d_parent), &dentry->d_name,
				inode, inode->i_ino, inode->i_mode);
}

// dir是父目录
int f2fs_do_add_link(struct inode *dir, const struct qstr *name,
				struct inode *inode, nid_t ino, umode_t mode)
{
	struct f2fs_dir_entry *de = NULL; // 父目录dir的目录项，初始化为NULL
	int err;
    // 如果文件已经加密，则获得解密后的名字fname
	err = fscrypt_setup_filename(dir, name, 0, &fname); 
	if (de) { // 如果找到目录项
		f2fs_put_page(page, 0);
		err = -EEXIST;
	} else if (IS_ERR(page)) {
		err = PTR_ERR(page);
	} else { // 对于一个新inode，它对应的父目录的目录项f2fs_dir_entry应该是不存在的
		err = f2fs_add_dentry(dir, &fname, inode, ino, mode);
	}
	return err;
}

这个f2fs_add_dentry函数提取了文件名字的字符串以及字符串长度:

int f2fs_add_dentry(struct inode *dir, struct fscrypt_name *fname,
				struct inode *inode, nid_t ino, umode_t mode)
{
	struct qstr new_name;
	int err = -EAGAIN;

	new_name.name = fname_name(fname); // 将文件名的字符串格式保存在这里
	new_name.len = fname_len(fname);   // 将文件名的长度保存在这里

    // 在这个函数实现新inode和父inode的链接
	err = f2fs_add_regular_entry(dir, &new_name, fname->usr_fname,
						inode, ino, mode);

	f2fs_update_time(F2FS_I_SB(dir), REQ_TIME); // 更新修改时间
	return err;
}

新inode的f2fs_dir_entry应该是不存在的，注意我们f2fs_new_inode函数一节提到的FI_NEW_INODE的flag。

int f2fs_add_regular_entry(struct inode *dir, const struct qstr *new_name,
				const struct qstr *orig_name,
				struct inode *inode, nid_t ino, umode_t mode)
{
	...
	// 上面的机制比较复杂，在这里不提，在目录项的作用相关章节再提
    // 上面做了一大堆事情可以理解为，根据[文件名的长度]创建一个新的f2fs_dir_entry，然后加入到父目录当中
    // 需要注意的是这个f2fs_dir_entry还没有包含新inode的信息
       
    //  接下来就是要做的就是
    // 	1. 为新的vfs inode创建inode page，初始化与父目录有关的信息
    // 	2. 基于新inode的信息(名字，ino等)更新f2fs_dir_entry
        
	if (inode) {
        // 这个函数就是创建inode page，初始化与父目录有关的信息
		page = f2fs_init_inode_metadata(inode, dir, new_name,
						orig_name, NULL);
	}


    // 基于新inode的信息(名字，ino等)更新f2fs_dir_entry
	f2fs_update_dentry(ino, mode, &d, new_name, dentry_hash, bit_pos);

	set_page_dirty(dentry_page);
	f2fs_update_parent_metadata(dir, inode, current_depth); // 清除FI_NEW_INODE的flag
	return err;
}

由于新inode设置了FI_NEW_INODE，因此f2fs_init_inode_metadata函数就是完成了两个功能:

1. 创建一个新的inode page，然后初始化acl、security等信息。
2. 然后初始化新创建的inode page的名字
3. 再增加inode的引入链接。

struct page *f2fs_init_inode_metadata(struct inode *inode, struct inode *dir,
			const struct qstr *new_name, const struct qstr *orig_name,
			struct page *dpage)
{
	struct page *page;
	int err;

    // 由于新inode设置了FI_NEW_INODE
	if (is_inode_flag_set(inode, FI_NEW_INODE)) {
        // 创建一个新的inode page，然后初始化acl、security等信息。
		page = f2fs_new_inode_page(inode);

		err = f2fs_init_acl(inode, dir, page, dpage);
		if (err)
			goto put_error;

		err = f2fs_init_security(inode, dir, orig_name, page);
		if (err)
			goto put_error;
		}
	} else {
		page = f2fs_get_node_page(F2FS_I_SB(dir), inode->i_ino);
		if (IS_ERR(page))
			return page;
	}

	if (new_name) { // 然后初始化新创建的inode page的名字
		init_dent_inode(new_name, page);
		if (f2fs_encrypted_inode(dir))
			file_set_enc_name(inode);
	}
	// 再增加inode的引入链接。
	if (is_inode_flag_set(inode, FI_INC_LINK))
		f2fs_i_links_write(inode, true);
	return page;
}

将新的inode链接到父目录后，后续用户访问时，可以通过父目录找到新创建的文件的inode，即完成了整个文件的创建流程。