聊聊ext4文件create和truncat实现

// inode操作函数表定义
const struct inode_operations ext4_dir_inode_operations = {
	.create		= ext4_create,
	.lookup		= ext4_lookup,
	.link		= ext4_link,
	.unlink		= ext4_unlink,
	.symlink	= ext4_symlink,
	.mkdir		= ext4_mkdir,
	.rmdir		= ext4_rmdir,
	.mknod		= ext4_mknod,
	.tmpfile	= ext4_tmpfile,
	.rename		= ext4_rename2,
	.setattr	= ext4_setattr,
	.getattr	= ext4_getattr,
	.listxattr	= ext4_listxattr,
	.get_acl	= ext4_get_acl,
	.set_acl	= ext4_set_acl,
	.fiemap         = ext4_fiemap,
};


// 超级块操作函数定义表
static const struct super_operations ext4_sops = {
	.alloc_inode	= ext4_alloc_inode,
	.destroy_inode	= ext4_destroy_inode,
	.write_inode	= ext4_write_inode,
	.dirty_inode	= ext4_dirty_inode,
	.drop_inode	= ext4_drop_inode,
	.evict_inode	= ext4_evict_inode,
	.put_super	= ext4_put_super,
	.sync_fs	= ext4_sync_fs,
	.freeze_fs	= ext4_freeze,
	.unfreeze_fs	= ext4_unfreeze,
	.statfs		= ext4_statfs,
	.remount_fs	= ext4_remount,
	.show_options	= ext4_show_options,
#ifdef CONFIG_QUOTA
	.quota_read	= ext4_quota_read,
	.quota_write	= ext4_quota_write,
	.get_dquots	= ext4_get_dquots,
#endif
	.bdev_try_to_free_page = bdev_try_to_free_page,
};

// 用户态发起文件创建的系统调用，首先是进入vfs层的vfs_create函数
int vfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
		bool want_excl)
{
	// 调用实际文件系统的create方法，这里调用的是ext4_dir_inode_operations->create方法
	error = dir->i_op->create(dir, dentry, mode, want_excl);
	return error;
}

// esxt4文件系统定义inode创建的宏
#define ext4_new_inode(handle, dir, mode, qstr, goal, owner, i_flags) \
	__ext4_new_inode((handle), (dir), (mode), (qstr), (goal), (owner), \
			 i_flags, 0, 0, 0)


static int ext4_create(struct inode *dir, struct dentry *dentry, umode_t mode,
		       bool excl)
{
	handle_t *handle;
	struct inode *inode;
	int err, credits, retries = 0;
	// 新文件所在的目录 quota初始化
	err = dquot_initialize(dir);
	if (err)
		return err;

	credits = (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) +
		   EXT4_INDEX_EXTRA_TRANS_BLOCKS + 3);
retry:
	// 申请和初始化一个inode，这里实际调用__ext4_new_inode 初始化一个inode
	inode = ext4_new_inode_start_handle(dir, mode, &dentry->d_name, 0,
					    NULL, EXT4_HT_DIR, credits);
	// 获取日志的处理函数上下文
	handle = ext4_journal_current_handle();
	err = PTR_ERR(inode);
	if (!IS_ERR(inode)) {
		// 设置新文件对应的inode的i_node和文件操作函数
		inode->i_op = &ext4_file_inode_operations;
		inode->i_fop = &ext4_file_operations;

		// 设置 inode->i_mapping的操作函数表
		ext4_set_aops(inode);

		// 在父目录中添加一个目录项，全程采用记录日志过程
		// 读取父目录的inode,找到对应的i_blocks,然后在对应的blokc中添加一条{inode 文件名称}数据到block
		err = ext4_add_nondir(handle, dentry, inode);
		if (!err && IS_DIRSYNC(dir))
			// 设置handle 同步模式 
			ext4_handle_sync(handle);
	}
	if (handle)
		// journal 日志的事务处理
		ext4_journal_stop(handle);
	// ext4_should_retry_alloc 事务提交
	if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries))
		goto retry;
	return err;
}

long vfs_truncate(const struct path *path, loff_t length)
{
	error = do_truncate(path->dentry, length, 0, NULL);
}
// ext4_truncate要么成功要么失败，不能在一个inode上出现中间状态
int ext4_truncate(struct inode *inode)
{
	struct ext4_inode_info *ei = EXT4_I(inode);
	unsigned int credits;
	int err = 0;
	handle_t *handle;
	struct address_space *mapping = inode->i_mapping;

	// 判断文件inode是否包含inline数据(应该是很小的数据)
	if (ext4_has_inline_data(inode)) {
		int has_inline = 1;
		// 如果是包含inline数据直接执行truncate操作然后返回
		// 这里的实现逻辑基本是:ext4_journal_start开启一个truncate事务 -> ext4_orphan_add 把对应truncate的文件添加到超级块的孤儿列表-> 文件对应的block空间清理 -> 完成之前操作调用ext4_orphan_del从超级块的孤儿列表中移除 -> ext4_handle_sync 或者 ext4_journal_stop 事务日志处理或者提交
		err = ext4_inline_data_truncate(inode, &has_inline);
		if (err)
			return err;
		if (has_inline)
			return 0;
	}

	/* If we zero-out tail of the page, we have to create jinode for jbd2 */
	if (inode->i_size & (inode->i_sb->s_blocksize - 1)) {
		if (ext4_inode_attach_jinode(inode) < 0)
			return 0;
	}
	
	// 如下是计算此次truncate操作需要清理该inode的block个数
	if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
		credits = ext4_writepage_trans_blocks(inode);
	else
		credits = ext4_blocks_for_truncate(inode);

	// 开启基于日志的事务
	handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE, credits);
	if (IS_ERR(handle))
		return PTR_ERR(handle);

	if (inode->i_size & (inode->i_sb->s_blocksize - 1))
		ext4_block_truncate_page(handle, mapping, inode->i_size);


	// 把inode添加到孤儿列表，一个truncate可能会被分割为多个事务，如果机器宕机，重启会基于日志恢复，会标记该inode为脏。
	err = ext4_orphan_add(handle, inode);
	if (err)
		goto out_stop;

	down_write(&EXT4_I(inode)->i_data_sem);

	// 释放该inode的预分配空间
	ext4_discard_preallocations(inode);

	// 由于ext4支持基于间接数据块和基于extent方式存储数据，需要判断下是哪种模式
	if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
		// 如果是基于extent方式
		// 这里进行的操作，第一步是从extent status tree空间清理，第二步是开始事务模式，查找inode对应的ext4_ext_path，ext4_ext_path包含了extent先关数据结构和block之间的信息，进行extent的空间清理
		err = ext4_ext_truncate(handle, inode);
	else
		// 基于间接数据块方式
		ext4_ind_truncate(handle, inode);

	up_write(&ei->i_data_sem);
	if (err)
		goto out_stop;

	if (IS_SYNC(inode))
		// 设置handle 同步模式 
		ext4_handle_sync(handle);

out_stop:
	
	if (inode->i_nlink)
		ext4_orphan_del(handle, inode);

	// 更新inode的属性
	inode->i_mtime = inode->i_ctime = current_time(inode);
	// 标记inode为脏
	ext4_mark_inode_dirty(handle, inode);
	// 日志提交
	ext4_journal_stop(handle);

	trace_ext4_truncate_exit(inode);
	return err;
}