文件系统与IO优化

// 系统调用read的实现
SYSCALL_DEFINE3(read, unsigned int, fd, char __user *, buf, size_t, count)
{
    struct fd f = fdget_pos(fd);
    ssize_t ret = -EBADF;
    
    if (f.file) {
        loff_t pos = file_pos_read(f.file);
        ret = vfs_read(f.file, buf, count, &pos);
        if (ret >= 0)
            file_pos_write(f.file, pos);
        fdput_pos(f);
    }
    return ret;
}

// VFS读取函数
ssize_t vfs_read(struct file *file, char __user *buf, size_t count, loff_t *pos)
{
    ssize_t ret;
    
    if (!(file->f_mode & FMODE_READ))
        return -EBADF;
    if (!(file->f_mode & FMODE_CAN_READ))
        return -EINVAL;
    if (unlikely(!access_ok(buf, count)))
        return -EFAULT;
    
    ret = rw_verify_area(READ, file, pos, count);
    if (!ret) {
        if (count > MAX_RW_COUNT)
            count = MAX_RW_COUNT;
        ret = __vfs_read(file, buf, count, pos);
        if (ret > 0) {
            fsnotify_access(file);
            add_rchar(current, ret);
        }
        inc_syscr(current);
    }
    
    return ret;
}

// 从PageCache读取
ssize_t generic_file_read_iter(struct kiocb *iocb, struct iov_iter *iter)
{
    struct file *file = iocb->ki_filp;
    ssize_t retval = 0;
    loff_t *ppos = &iocb->ki_pos;
    loff_t pos = *ppos;
    
    // 尝试从PageCache读取
    do {
        struct page *page;
        pgoff_t index;
        unsigned long offset;
        unsigned long nr, ret;
        
        index = pos >> PAGE_SHIFT;
        offset = pos & ~PAGE_MASK;
        
        // 查找页缓存
        page = find_get_page(mapping, index);
        if (!page) {
            // PageCache Miss，需要从磁盘读取
            page_cache_sync_readahead(mapping, ra, file, index,
                                     last_index - index);
            page = find_get_page(mapping, index);
            if (unlikely(!page))
                goto no_cached_page;
        }
        
        // 从页缓存复制到用户空间
        ret = copy_page_to_iter(page, offset, nr, iter);
        
    } while (iov_iter_count(iter) && !ret);
    
    return retval;
}

// 后台回写线程
static int wb_writeback(struct bdi_writeback *wb,
                       struct wb_writeback_work *work)
{
    unsigned long wb_start = jiffies;
    long nr_pages = work->nr_pages;
    struct inode *inode;
    struct writeback_control wbc = {
        .sync_mode = work->sync_mode,
        .tagged_writepages = work->tagged_writepages,
        .for_kupdate = work->for_kupdate,
        .for_background = work->for_background,
        .range_cyclic = work->range_cyclic,
    };
    
    while (!list_empty(&wb->b_io)) {
        inode = wb_inode(wb->b_io.prev);
        
        // 回写inode的脏页
        __writeback_single_inode(inode, &wbc);
    }
    
    return nr_pages - wbc.nr_to_write;
}

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/time.h>
#include <string.h>

#define FILE_SIZE (100 * 1024 * 1024)  // 100MB
#define BUFFER_SIZE 4096

// 计算时间差（毫秒）
long time_diff_ms(struct timeval *start, struct timeval *end) {
    return (end->tv_sec - start->tv_sec) * 1000 +
           (end->tv_usec - start->tv_usec) / 1000;
}

// 测试普通写入
void test_normal_write() {
    int fd;
    char buffer[BUFFER_SIZE];
    struct timeval start, end;
    
    memset(buffer, 'A', BUFFER_SIZE);
    
    printf("=== 普通写入测试 ===\n");
    gettimeofday(&start, NULL);
    
    fd = open("/tmp/test_normal.dat", O_WRONLY | O_CREAT | O_TRUNC, 0644);
    if (fd < 0) {
        perror("open");
        return;
    }
    
    for (int i = 0; i < FILE_SIZE / BUFFER_SIZE; i++) {
        write(fd, buffer, BUFFER_SIZE);
    }
    
    close(fd);
    gettimeofday(&end, NULL);
    
    printf("写入100MB耗时: %ld ms\n", time_diff_ms(&start, &end));
    printf("写入速度: %.2f MB/s\n\n", 
           100.0 / (time_diff_ms(&start, &end) / 1000.0));
}

// 测试同步写入
void test_sync_write() {
    int fd;
    char buffer[BUFFER_SIZE];
    struct timeval start, end;
    
    memset(buffer, 'A', BUFFER_SIZE);
    
    printf("=== 同步写入测试 (O_SYNC) ===\n");
    gettimeofday(&start, NULL);
    
    fd = open("/tmp/test_sync.dat", O_WRONLY | O_CREAT | O_TRUNC | O_SYNC, 0644);
    if (fd < 0) {
        perror("open");
        return;
    }
    
    for (int i = 0; i < FILE_SIZE / BUFFER_SIZE; i++) {
        write(fd, buffer, BUFFER_SIZE);
    }
    
    close(fd);
    gettimeofday(&end, NULL);
    
    printf("写入100MB耗时: %ld ms\n", time_diff_ms(&start, &end));
    printf("写入速度: %.2f MB/s\n\n", 
           100.0 / (time_diff_ms(&start, &end) / 1000.0));
}

// 测试读取（PageCache命中）
void test_cached_read() {
    int fd;
    char buffer[BUFFER_SIZE];
    struct timeval start, end;
    
    printf("=== PageCache命中读取测试 ===\n");
    
    // 先读一次，填充PageCache
    fd = open("/tmp/test_normal.dat", O_RDONLY);
    if (fd < 0) {
        perror("open");
        return;
    }
    while (read(fd, buffer, BUFFER_SIZE) > 0);
    close(fd);
    
    // 再次读取，应该全部命中PageCache
    gettimeofday(&start, NULL);
    fd = open("/tmp/test_normal.dat", O_RDONLY);
    while (read(fd, buffer, BUFFER_SIZE) > 0);
    close(fd);
    gettimeofday(&end, NULL);
    
    printf("读取100MB耗时: %ld ms\n", time_diff_ms(&start, &end));
    printf("读取速度: %.2f MB/s\n\n", 
           100.0 / (time_diff_ms(&start, &end) / 1000.0));
}

int main() {
    test_normal_write();
    test_sync_write();
    test_cached_read();
    
    // 清理测试文件
    unlink("/tmp/test_normal.dat");
    unlink("/tmp/test_sync.dat");
    
    return 0;
}