Linux Kernel: IO

generic_file_read (struct file *filp, char __user *buf, size_t count, loff_t *ppos):
  // iovec 记录了本次读操作要填充的 buffer 和大小
  struct iovec local_iov = { .iov_base = buf, .iov_len = count };
  __generic_file_aio_read(&kiocb, &local_iov, 1, ppos);
    read_descriptor_t desc;
    desc.arg.buf = iov[seg].iov_base;
    desc.count = iov[seg].iov_len;
    do_generic_file_read(filp,ppos,&desc,file_read_actor);
      do_generic_mapping_read(filp->f_mapping,&filp->f_ra,filp,ppos,desc,actor);

do_generic_mapping_read(filp->f_mapping,&filp->f_ra,filp,ppos,desc,actor);
  // ppos 是要读取的 offset (字节), index 是这个 offset 对应的 page cache 中的
  // page index. page index 与 offset 是线性的映射关系
  index = *ppos >> PAGE_CACHE_SHIFT;
  // mapping 是 inode->address_space
  // !! 查找 page cache !!
  page = find_get_page(mapping, index);
    return radix_tree_lookup(&mapping->page_tree, offset);
  // !! page cache miss !!
  if (unlikely(page == NULL)):
    goto no_cached_page;
  else:
    // !! page cache hit !!
    goto page_ok;

no_cached_page:
  // page cache hit, 分配一个新的 page, 加到 page cache 中, 并 readpage
  cached_page = page_cache_alloc_cold(mapping);
  // 新 page 与 mapping 的 index 关联, 加到 page cache 中
  add_to_page_cache_lru(cached_page, mapping, index, GFP_KERNEL);
    // lock page, readpage 是个异步的调用 (dma), do_generic_mapping_read 需要通过 lock_page 阻塞住
    SetPageLocked(page);
  goto read_page;

read_page:
  // NEXT STAGE
  // The read will unlock the page
  mapping->a_ops->readpage(filp, page);
  // 因为 readpage 是异步的, readpage 返回时 page 一般是 !update
  // 这里的 lock_page 会使函数阻塞住, 等待底层读操作的结束
  if (!PageUptodate(page)):
    lock_page(page);
      // TASK_UNINTERRUPTIBLE, 所谓的 D 状态
      __wait_on_bit_lock(page_waitqueue(page), &wait, sync_page, TASK_UNINTERRUPTIBLE);
    unlock_page(page);
  goto page_ok;

page_ok:
  // actor 实际是 file_read_actor, 负责将 page 的数据复制到 desc, 即
  // user space 的 buffer 中
  ret = actor(desc, page, offset, nr);

static int ext2_readpage(struct file *file, struct page *page) {
    return mpage_readpage(page, ext2_get_block);
}

generic_file_write(struct file *file, const char __user *buf,size_t count, loff_t *ppos):
  __generic_file_write_nolock(file, &local_iov, 1, ppos);
    __generic_file_aio_write_nolock(&kiocb, iov, nr_segs, ppos);
      generic_file_buffered_write(iocb, iov, nr_segs, pos, ppos, count, written);

generic_file_buffered_write(struct kiocb *iocb, const struct iovec *iov,
                            unsigned long nr_segs, loff_t pos, loff_t *ppos,
                            size_t count, ssize_t written):
  struct file *file = iocb->ki_filp;
  struct address_space * mapping = file->f_mapping;
  struct address_space_operations *a_ops = mapping->a_ops;
  struct inode  *inode = mapping->host;

  index = pos >> PAGE_CACHE_SHIFT;
  // 查找 page cache, 若不存在, 则新建一个 page
  page = __grab_cache_page(mapping,index,&cached_page,&lru_pvec);
    page = find_lock_page(mapping, index);
    if (!page):
      *cached_page = page_cache_alloc(mapping);
      add_to_page_cache(*cached_page, mapping, index, GFP_KERNEL);
    return *cached_page
  // prepare_write 与具体文件系统相关, 这个函数返回后, 可以保证
  // page 中已经有相应的 buffer_head, 并且 page 中已经包含原始的数据
  // (write 操作需要在原始数据的基础上进行覆盖)
  a_ops->prepare_write(file, page, offset, offset+bytes);
  // 数据被写到 page
  filemap_copy_from_user(page, offset, buf, bytes);
  // 根据 offset 和 size 确定 page 中各个 buffer_head 的状态只有被修改
  // 到的 buffer_head 才会改为 dirty, 后续 sync 时只需要 sync 这一个
  // buffer_head
  a_ops->commit_write(file, page, offset, offset+bytes);
  // balance dirty page (vm_dirty_ratio)
  balance_dirty_pages_ratelimited()
  // 除非指定了 O_SYNC 或 O_DIRECT, 否则 write 操作在 commit_write 就结束了,
  // 真正的 IO 操作发生在 sync 时

struct vm_area_struct {
    // vma 中和 file map 相关的成员
    unsigned long vm_start;
    struct rb_node vm_rb;
    struct vm_operations_struct * vm_ops;
    unsigned long vm_pgoff;
    struct file * vm_file;
    // ...
}

// 实际代码中 handle_pte_fault 对于 file mapping 的调用路径是
// do_file_page -> filemap_getpage 而不是 do_no_page -> filemap_nopage
// 但两者代码基本类似
struct page * filemap_nopage(struct vm_area_struct * area, address, int *type):
  struct file *file = area->vm_file;
  struct address_space *mapping = file->f_mapping;
  struct file_ra_state *ra = &file->f_ra;
  struct inode *inode = mapping->host;

  pgoff = ((address - area->vm_start) >> PAGE_CACHE_SHIFT) + area->vm_pgoff;
  // madvise (MADV_SEQUENTIAL)
  if (VM_SequentialReadHint(area)):
    page_cache_readahead(mapping, ra, file, pgoff, 1);
  // some logic related to ra
  // ...
  // 查找 page cache
  page = find_get_page(mapping, pgoff);
  if (!page)
    goto no_cached_page;
  else:
    // assume page is updated for simple case
    // return minor fault, since no IO issued
    *type = VM_FAULT_MINOR;
    return page

no_cached_page:
  // 分配 page cache 并 readpage
  page_cache_read(file, pgoff);
    page_cache_alloc_cold(mapping);
    add_to_page_cache_lru(page, mapping, offset, GFP_KERNEL);
    mapping->a_ops->readpage(file, page);
  // find page cache again, should hit
  page = find_get_page(mapping, pgoff);
  // major fault here
  *type = VM_FAULT_MAJOR;
  return page

do_page_fault:
  __asm__("movl %%cr2,%0":"=r" (address));
  vma = find_vma(mm, address);
  switch (handle_mm_fault(mm, vma, address, write)) {
             handle_pte_fault(mm, vma, address, write_access, pte, pmd);
               do_no_page(mm, vma, address, write_access, pte, pmd);
                 new_page = vma->vm_ops->nopage(vma, address & PAGE_MASK, &ret);
                   filemap_nopage(vma, address & PAGE_MASK, &ret)
                 entry = mk_pte(new_page, vma->vm_page_prot);
                 set_pte(page_table, entry);
    case VM_FAULT_MINOR:
      tsk->min_flt++;
      break;
    case VM_FAULT_MAJOR:
      tsk->maj_flt++;
      break;
    // case xxx

submit_bio:
  generic_make_request(bio);
    // 计算 bio 包括多少个 sector
    int nr_sectors = bio_sectors(bio);
    q = bdev_get_queue(bio->bi_bdev);
      // block_device->gendisk->request_queue
      return bdev->bd_disk->queue;
    // 若 bio->bi_dev 指向一个分区, 将 bio->bi_sector
    // 转换为相对于 bio->bi_dev->bd_contains 的 sector
    // 并将 bio->bi_dev 变为 bio->bi_dev->bd_contains
    blk_partition_remap(bio);
    // q->make_request_fn 是在 block device driver 初始时
    // 通过 blk_init_queue 指定的, 一般默认的实现为 __make_request
    q->make_request_fn(q, bio);