系统调用 sync、fsync、fdatasync 总结

sync 函数

sync 函数只是将修改过的数据块缓冲区放入到设备写队列中后立即返回。数据刷新到磁盘的操作完全有内核守护线程处理。因此调用 sync 函数返回后，数据有可能还在内存中，当系统掉电后有可能数据造成丢失。

fsync 及 fdatasync 函数

#include <unistd.h>
int fsync(int fd);
int fdatasync(int fd);

fsync 函数把 fd 对应的文件数据以及文件属性信息（inode等信息）写入到磁盘，并且等待写磁盘操作完成后而返回。应用程序一般都是通过调用该函数确保修改过的数据能够立即写入到磁盘上，比如 redis等。

fdatasync 与 fsync 类似，只不过 fdatasync 只将数据更新到磁盘，而不更新文件属性信息到磁盘。

两个系统调用都不保证包含他们的上级目录的同步。如果需要,要明确的对对应目录调用fsync。

fsync 源码分析

对于 ext2 文件系统，其对应的 file_operations 结构信息如下：

struct file_operations ext2_file_operations = {
llseek: ext2_file_lseek,
read: generic_file_read,
write: generic_file_write,
ioctl: ext2_ioctl,
mmap: generic_file_mmap,
open: ext2_open_file,
release: ext2_release_file,
fsync: ext2_sync_file,
};

当系统调用 fsync 时，系统调用过程如下：

mlinkage long sys_fsync(unsigned int fd)
{
...
file = fget(fd);
if (!file)
goto out;
dentry = file->f_dentry;
inode = dentry->d_inode;
err = -EINVAL;
if (!file->f_op || !file->f_op->fsync)
goto out_putf;
/* We need to protect against concurrent writers.. */
down(&inode->i_sem);
//对脏页的块缓冲区打BH_Dirty标记，同时把把块缓冲区加入到inode->i_dirty_buffers队列队列中
filemap_fdatasync(inode->i_mapping);
//刷出脏缓冲区到磁盘
err = file->f_op->fsync(file, dentry, 0); // ext2_file_operations ext2_sync_file
//等待驱动完成page io操作
filemap_fdatawait(inode->i_mapping);
up(&inode->i_sem);
out_putf:
fput(file);
out:
return err;
}

mapping->dirty_pages 中记录的都是脏页链表，在 filemap_fdatasync 中遍历链表中的脏页，然后从page中获取一个一个块缓冲区 buffer_head，然后打上 BH_Dirty 标记。最后把一个个打了 BH_Dirty 标记的块缓冲区 buffer_head 加入到 inode->i_dirty_buffers 链表中。

调用流程如下

filemap_fdatasync
|-> writepage => ext2_writepage 从脏页转换到脏的缓冲区数据块的转换
|-> block_write_full_page
|-> __block_prepare_write 完成文件内块号到设备上的块号的映射
|-> __block_commit_write 将块缓冲区标记为脏，加入相应链表inode->i_dirty_buffers

调用 file->f_op->fsync，对于ext2 文件系统也即为 ext2_file_operations 之 ext2_sync_file，该函数就是块缓冲区对应的数据刷到磁盘，把 inode 信息刷到磁盘。

调用过程如下

ext2_fsync_inode
 |-> fsync_inode_buffers  对inode->i_dirty_buffers链表中的脏缓冲区调用ll_rw_block刷出到磁盘
     |-> ll_rw_block
 |-> ext2_sync_inode 把inode节点所在块写回磁盘
     |-> ext2_update_inode

其中 fsync_inode_buffers 将 inode->i_dirty_buffers 链表中的脏块缓冲区刷到磁盘中，该函数的实现过程主要分两个阶段：

1、将 inode->i_dirty_buffers 链表中的所有脏缓冲区拷贝到一个临时 inode 对象 tmp 的 tmp.i_dirty_buffers 链表中，并对其中的每一个脏缓冲区安排回写请求（通过 ll_rw_block() 函数）。

2、对tmp对象tmp.i_dirty_buffers链表中的每一个缓冲区调用wait_on_buffer() 函数，以等待该缓冲区被解锁（也即等待该缓冲区的回写请求完成）。由于在第二个阶段期间，当函数通过 wait_on_buffer() 等待某个缓冲区被解锁期间，其他进程可能会对指定 inode 对象对应的文件发出写操作，因此前面已经被解锁的缓冲区可能会再次变脏，因而它们可能会再次进入该 inode 对象的 i_dirty_buffers 链表中。因此为了让这些缓冲区也得到被等待的机会（也即对它们调用 wait_on_buffer() 函数），函数fsync_inode_buffers() 最后调用 osync_inode_buffers( )函数，从而使在第二个阶段期间又变脏的缓冲区都同步地被回写。

int fsync_inode_buffers(struct inode *inode)
{
struct buffer_head *bh;
struct inode tmp;
int err = 0, err2;
INIT_LIST_HEAD(&tmp.i_dirty_buffers);
spin_lock(&lru_list_lock);
/*
第一个while循环完成上述所说的第一个阶段的任务。它先将指定inode对象的I_dirty_buffers链表
中的脏缓冲区从链表中删除。然后判断这个缓冲区的状态是否既不为脏也未被上锁，
如果是这样，则简单地将缓冲区的bh对象的b_inode指针设置为NULL就可以了。
否则就将这个缓冲区加到tmp对象的I_dirty_buffers链表中；
同时对于脏的缓冲区还要调用ll_rw_block()函数安排回写请求
（注意！对于已经加锁的缓冲区我们已经安排了回写请求，因此这里就不必再安排了）。
函数ll_rw_block()将清除BH_Dirty标志位，并设置BH_Lock标志位
*/
while (!list_empty(&inode->i_dirty_buffers)) {
bh = BH_ENTRY(inode->i_dirty_buffers.next);
list_del(&bh->b_inode_buffers);
if (!buffer_dirty(bh) && !buffer_locked(bh))
bh->b_inode = NULL;
else {
bh->b_inode = &tmp;
list_add(&bh->b_inode_buffers, &tmp.i_dirty_buffers);
if (buffer_dirty(bh)) {
atomic_inc(&bh->b_count);
spin_unlock(&lru_list_lock);
ll_rw_block(WRITE, 1, &bh);
brelse(bh);
spin_lock(&lru_list_lock);
}
}
}
/*
接下来的while循环完成第二个阶段的任务。首先调用remove_inode_queue()函数将缓冲区从tmp对象的
I_dirty_buffers链表中摘除。然后，调用wait_on_buffer()函数等待该缓冲区的回写请求被完成(回写操作完成后，
BH_Lock标志将被清除，BH_Uptodate标志将被置位)。
*/
while (!list_empty(&tmp.i_dirty_buffers)) {
bh = BH_ENTRY(tmp.i_dirty_buffers.prev);
remove_inode_queue(bh);
atomic_inc(&bh->b_count);
spin_unlock(&lru_list_lock);
wait_on_buffer(bh);
if (!buffer_uptodate(bh))
err = -EIO;
brelse(bh);
spin_lock(&lru_list_lock);
}
spin_unlock(&lru_list_lock);
/*调用osync_inode_buffers()函数让第二个阶段期间再次变脏且已经被安排了回写的缓冲区再次得到被等待的机会*/
err2 = osync_inode_buffers(inode);
if (err)
return err;
else
return err2;
}

其中 osync_inode_buffers 代码如下：

int osync_inode_buffers(struct inode *inode)
{
struct buffer_head *bh;
struct list_head *list;
int err = 0;
spin_lock(&lru_list_lock);
repeat:
/*for循环从指定inode对象的I_dirty_buffers链表的表尾开始扫描其中的缓冲区，
并判断链表中的最后一个缓冲区是否已被加锁（设置了BH_Lock标志）。
如果是这说明已经对该缓冲区安排了回写操作（也即已经对这个缓冲区调用ll_rw_block()函数），
于是对这个缓冲区调用wait_on_buffer()函数以等待这个缓冲区的回写操作被完成。
从wait_on_buffer()函数醒来以后，立即检查缓冲区的状态是否设置了BH_Uptodate标志，
如果不是，这说明发生了I/O错误。然后，跳转到repeat重新执行for循环。
*/
for (list = inode->i_dirty_buffers.prev;
bh = BH_ENTRY(list), list != &inode->i_dirty_buffers;
list = bh->b_inode_buffers.prev) {
if (buffer_locked(bh)) {
atomic_inc(&bh->b_count);
spin_unlock(&lru_list_lock);
wait_on_buffer(bh);
if (!buffer_uptodate(bh))
err = -EIO;
brelse(bh);
spin_lock(&lru_list_lock);
goto repeat;
}
}
//从for循环退出后，I_dirty_buffers链表中将不再有任何被加锁的缓冲区
spin_unlock(&lru_list_lock);
return err;
}