两种文件写操作的页缓存数据刷出操作和函数调用路径分析

一、内存映射文件的写操作(MAP_SHARED模式)：
1、写内存时按以下流程标记页为脏：pte_mkdirty(pte),swap_out->……->try_to_swap_out时set_page_dirty(page)
2、文件映射内存同步到磁盘（调用sys_msync）
(1)sys_msync->msync_interval:调用filemap_sync、filemap_fdatasync、ext2_sync_file。
(2)filemap_sync扫描指定范围的内存页表项，对于页表项标记为脏的，将相关页标记为脏；
(3)filemap_fdatasync将脏页的缓冲区加入脏缓冲区链表（inode->i_dirty_data_buffers和lru_list[BUF_DIRTY]链表）。
(4)ext2_sync_file->ext2_fsync_inode:先后调用3个函数，fsync_inode_buffers、fsync_inode_data_buffers、ext2_sync_inode，见一.2.(5)的描述。

(5)ext2_sync_file->ext2_fsync_inode：调用fsync_inode_buffers、fsync_inode_data_buffers、ext2_sync_inode。
fsync_inode_buffers对inode->i_dirty_buffers(元数据，如文件中间指针块)链表中的脏缓冲区调用ll_rw_block刷出到磁盘；
fsync_inode_data_buffers对inode->i_dirty_data_buffers(实际文件数据)链表中的脏缓冲区调用ll_rw_block刷出到磁盘；
ext2_sync_inode调用ext2_update_inode把inode节点所在块写回磁盘。
(6)1个文件元数据脏块的产生场景举例：ext2_get_block->ext2_alloc_branch->buffer_insert_inode_queue

注意:
buffer_insert_inode_queue是把文件元数据脏块加入inode->i_dirty_buffers链表。
buffer_insert_inode_data_queue是把文件本身的脏数据块加入inode->i_dirty_data_buffers链表。

二、普通文件写操作sys_write->generic_file_write:
(1)__grab_cache_page->__find_lock_page
(2)prepare_write、__copy_from_user、commit_write。
(3)最后脏数据块由后台内核线程bdflush或kupdate等异步写回磁盘。

struct address_space_operations ext2_aops = {
    readpage: ext2_readpage,
    writepage: ext2_writepage,
    sync_page: block_sync_page,
    prepare_write: ext2_prepare_write,
    commit_write: generic_commit_write,
    bmap: ext2_bmap,
    direct_IO: ext2_direct_IO,
};


三、sys_fsync刷新文件脏页到磁盘：
(1)sys_fsync主要有两个步骤: 首先调用filemap_fdatasync(对脏页的块缓冲区打BH_Dirty标记)，然后调用ext2_sync_file（刷出脏缓冲区到磁盘）。
(2)filemap_fdatasync先后调用三个函数:lock_page(page),ClearPageDirty(page),write_page(page)
write_page->ext2_writepage->block_write_full_page:调用两个函数， prepare_write(建立页块映射)、commit_write(块缓冲区标记为脏，加入相应链表)。
prepare_write->ext2_prepare_write
commit_write->generic_commit_write
(3)ext2_sync_file见一.2.(5)的描述。


四、综述
(1)3个层面的操作互斥
以上几种方式凡是在文件级别进行操作时一般通过inode->i_sem信号量进行互斥；
对页缓存操作时通过自旋锁pagecache_lock进行互斥；
对页操作时，给页上锁lock_page(page)
给块缓冲区调整lru_list时，通过自旋锁lru_list_lock互斥。

(2)重点关注下几个方式操作同一块缓冲区时的互斥同步问题
后台内核线程kupdate、bdflush刷出脏块，用户进程调用sys_fsync或sys_msync刷出脏块。主要涉及块缓存的状态一致性、所在链表的一致性。
kupdate->……->sync_old_buffers->write_some_buffers->write_locked_buffers->submit_bh->……->do_rw_disk->……->ide_output_data
bdflush->write_some_buffers->write_locked_buffers->submit_bh->……->do_rw_disk->……->ide_output_data

根据kupdate和bdflush的路径，可知它们都调用了write_some_buffers,该函数是自身同步互斥的，保证了数据一致性。
sys_msync和sys_fsync也有相似点，它们都调用了ext2_sync_file进行文件脏块缓冲区的刷出。
最后两边的互斥同步落在write_some_buffers和ll_rw_block之间。代码贴在下面，这里边的关键在于atomic_set_buffer_clean这个原子操作。
它保证了两个函数不会同时操作同一个块缓冲区。


---------------------------------write_some_buffers
#define NRSYNC (32)
static int write_some_buffers(kdev_t dev)
{
    struct buffer_head *next;
    struct buffer_head *array[NRSYNC];
    unsigned int count;
    int nr;

    next = lru_list[BUF_DIRTY];
    nr = nr_buffers_type[BUF_DIRTY];
    count = 0;
    while (next && --nr >= 0) {
        struct buffer_head * bh = next;
        next = bh->b_next_free;

        if (dev && bh->b_dev != dev)
            continue;
        if (test_and_set_bit(BH_Lock, &bh->b_state))
            continue;
        if (atomic_set_buffer_clean(bh)) {
            __refile_buffer(bh);
            get_bh(bh);
            array[count++] = bh;
            if (count < NRSYNC)
                continue;

            spin_unlock(&lru_list_lock);
            write_locked_buffers(array, count);
            return -EAGAIN;
        }
        unlock_buffer(bh);
        __refile_buffer(bh);
    }
    spin_unlock(&lru_list_lock);

    if (count)
        write_locked_buffers(array, count);
    return 0;
}

---------------------------------ll_rw_block
void ll_rw_block(int rw, int nr, struct buffer_head * bhs[])
{
    unsigned int major;
    int correct_size;
    int i;

    if (!nr)
        return;

    major = MAJOR(bhs[0]->b_dev);

    /* Determine correct block size for this device. */
    correct_size = get_hardsect_size(bhs[0]->b_dev);

    /* Verify requested block sizes. */
    for (i = 0; i < nr; i++) {
        struct buffer_head *bh = bhs[i];
        if (bh->b_size % correct_size) {
            printk(KERN_NOTICE "ll_rw_block: device %s: "
                   "only %d-char blocks implemented (%u)\n",
                   kdevname(bhs[0]->b_dev),
                   correct_size, bh->b_size);
            goto sorry;
        }
    }

    if ((rw & WRITE) && is_read_only(bhs[0]->b_dev)) {
        printk(KERN_NOTICE "Can't write to read-only device %s\n",
               kdevname(bhs[0]->b_dev));
        goto sorry;
    }

    for (i = 0; i < nr; i++) {
        struct buffer_head *bh = bhs[i];

        /* Only one thread can actually submit the I/O. */
        if (test_and_set_bit(BH_Lock, &bh->b_state))
            continue;

        /* We have the buffer lock */
        atomic_inc(&bh->b_count);
        bh->b_end_io = end_buffer_io_sync;

        switch(rw) {
        case WRITE:
            if (!atomic_set_buffer_clean(bh))
                /* Hmmph! Nothing to write */
                goto end_io;
            __mark_buffer_clean(bh);
            break;

        case READA:
        case READ:
            if (buffer_uptodate(bh))
                /* Hmmph! Already have it */
                goto end_io;
            break;
        default:
            BUG();
    end_io:
            bh->b_end_io(bh, test_bit(BH_Uptodate, &bh->b_state));
            continue;
        }

        submit_bh(rw, bh);
    }
    return;

sorry:
    /* Make sure we don't get infinite dirty retries.. */
    for (i = 0; i < nr; i++)
        mark_buffer_clean(bhs[i]);
}


(3)关于修改缓冲区数据和异步磁盘IO操作的数据一致性问题：
在request_queue中的bh写到磁盘IO端口的同时generic_file_write修改bh数据内容的问题，其实不存在数据不一致的问题，因为
generic_file_write会设置缓冲区的BH_Dirty标志，因此该缓冲区以后至少还会再写到磁盘一次。

相关论坛帖子：
---------------------------------2.4内核中文件写操作和缓冲区刷新到磁盘之间的竞态存在吗？
既然写文件是异步的，是否有可能一个缓冲区刷新到磁盘的过程中，另一个文件写操作正在改变缓冲区的内容？怎么避免generic_file_write和bdflush、kupdate之间的这种竞态关系？

---------------------------------重温2.4内核的文件写操作和缓冲区时，关于竞态问题的疑惑。
读2.4.18内核的generic_file_write函数，发现里边写page内的块缓冲区时没有使用任何关于块缓冲区buffer层面的同步互斥措施,也没检查缓冲区上锁情况。写文件是异步的，也就是说，将来的某个不确定的时机这个dirty的buffer将被submit_bh到硬盘的request_queue中。假设这样一个情景，即page中的buffer(不妨称之为bufferA)写脏后，在某个时刻提交给request_queue,然后某个时刻do_rw_disk将其中数据拷贝到硬盘接口的IO端口中。正在拷贝的过程中，某个进程调用了文件写操作，也操作这个bufferA中的数据，那么就可能造成数据不一致的情况。两个路径如下：

//1、用户数据拷贝到buffer中时没有检查buffer是不是正写到IO
generic_file_write->__copy_from_user(kaddr+offset, buf, bytes)
//2、缓冲区写到硬盘接口IO（比如可以假设是由kupdate启动的）
kupdate->……->sync_old_buffers->write_some_buffers->write_locked_buffers->submit_bh->……->do_rw_disk->……->ide_output_data
bdflush->write_some_buffers->write_locked_buffers->submit_bh->……->do_rw_disk->……->ide_output_data
是否有可能一个缓冲区刷新到磁盘的过程(路径2执行)中，另一个文件写操作(路径1也执行)正在改变缓冲区的内容？内核中似乎没有避免generic_file_write和bdflush、kupdate之间的这种竞态关系的操作，难道说这种情景是绝对发生不了的？