Linux 的文件系统及文件缓存知识点整理

struct ext4_inode {  __le16  i_mode;    /* File mode */  __le16  i_uid;    /* Low 16 bits of Owner Uid */  __le32  i_size_lo;  /* Size in bytes */  __le32  i_atime;  /* Access time */  __le32  i_ctime;  /* Inode Change time */  __le32  i_mtime;  /* Modification time */  __le32  i_dtime;  /* Deletion Time */  __le16  i_gid;    /* Low 16 bits of Group Id */  __le16  i_links_count;  /* Links count */  __le32  i_blocks_lo;  /* Blocks count */  __le32  i_flags;  /* File flags */......  __le32  i_block[EXT4_N_BLOCKS];/* Pointers to blocks */  __le32  i_generation;  /* File version (for NFS) */  __le32  i_file_acl_lo;  /* File ACL */  __le32  i_size_high;......};

#define  EXT4_NDIR_BLOCKS    12#define  EXT4_IND_BLOCK      EXT4_NDIR_BLOCKS#define  EXT4_DIND_BLOCK      (EXT4_IND_BLOCK + 1)#define  EXT4_TIND_BLOCK      (EXT4_DIND_BLOCK + 1)#define  EXT4_N_BLOCKS      (EXT4_TIND_BLOCK + 1)

struct ext4_extent_header {  __le16  eh_magic;  /* probably will support different formats */  __le16  eh_entries;  /* number of valid entries */  __le16  eh_max;    /* capacity of store in entries */  __le16  eh_depth;  /* has tree real underlying blocks? */  __le32  eh_generation;  /* generation of the tree */};

/* * This is the extent on-disk structure. * It's used at the bottom of the tree. */struct ext4_extent {  __le32  ee_block;  /* first logical block extent covers */  __le16  ee_len;    /* number of blocks covered by extent */  __le16  ee_start_hi;  /* high 16 bits of physical block */  __le32  ee_start_lo;  /* low 32 bits of physical block */};/* * This is index on-disk structure. * It's used at all the levels except the bottom. */struct ext4_extent_idx {  __le32  ei_block;  /* index covers logical blocks from 'block' */  __le32  ei_leaf_lo;  /* pointer to the physical block of the next *         * level. leaf or next index could be there */  __le16  ei_leaf_hi;  /* high 16 bits of physical block */  __u16  ei_unused;};如果文件不大，inode里面的i_block中，可以放得下一个ext4_extent_header和4项ext4_extent。所以这个时候，eh_depth为0，也即inode里面的就是叶子节点，树高度为0。

const struct file_operations ext4_file_operations = {......  .read_iter  = ext4_file_read_iter,  .write_iter  = ext4_file_write_iter,......}

ssize_tgeneric_file_read_iter(struct kiocb *iocb, struct iov_iter *iter){......    if (iocb->ki_flags & IOCB_DIRECT) {......        struct address_space *mapping = file->f_mapping;......        retval = mapping->a_ops->direct_IO(iocb, iter);    }......    retval = generic_file_buffered_read(iocb, iter, retval);}

ssize_t __generic_file_write_iter(struct kiocb *iocb, struct iov_iter *from){......    if (iocb->ki_flags & IOCB_DIRECT) {......        written = generic_file_direct_write(iocb, from);......    } else {......    written = generic_perform_write(file, from, iocb->ki_pos);......    }}generic_file_read_iter和__generic_file_write_iter有相似的逻辑，就是要区分是否用缓存。因此，根据是否使用内存做缓存，我们可以把文件的I/O操作分为两种类型。

ssize_t generic_perform_write(struct file *file,        struct iov_iter *i, loff_t pos){  struct address_space *mapping = file->f_mapping;  const struct address_space_operations *a_ops = mapping->a_ops;  do {    struct page *page;    unsigned long offset;  /* Offset into pagecache page */    unsigned long bytes;  /* Bytes to write to page */    status = a_ops->write_begin(file, mapping, pos, bytes, flags,            &page, &fsdata);    copied = iov_iter_copy_from_user_atomic(page, i, offset, bytes);    flush_dcache_page(page);    status = a_ops->write_end(file, mapping, pos, bytes, copied,            page, fsdata);    pos += copied;    written += copied;

    balance_dirty_pages_ratelimited(mapping);  } while (iov_iter_count(i));}

struct page *grab_cache_page_write_begin(struct address_space *mapping,          pgoff_t index, unsigned flags){  struct page *page;  int fgp_flags = FGP_LOCK|FGP_WRITE|FGP_CREAT;  page = pagecache_get_page(mapping, index, fgp_flags,      mapping_gfp_mask(mapping));  if (page)    wait_for_stable_page(page);  return page;}

size_t iov_iter_copy_from_user_atomic(struct page *page,    struct iov_iter *i, unsigned long offset, size_t bytes){  char *kaddr = kmap_atomic(page), *p = kaddr + offset;  iterate_all_kinds(i, bytes, v,    copyin((p += v.iov_len) - v.iov_len, v.iov_base, v.iov_len),    memcpy_from_page((p += v.bv_len) - v.bv_len, v.bv_page,         v.bv_offset, v.bv_len),    memcpy((p += v.iov_len) - v.iov_len, v.iov_base, v.iov_len)  )  kunmap_atomic(kaddr);  return bytes;}

/** * balance_dirty_pages_ratelimited - balance dirty memory state * @mapping: address_space which was dirtied * * Processes which are dirtying memory should call in here once for each page * which was newly dirtied.  The function will periodically check the system's * dirty state and will initiate writeback if needed.  */void balance_dirty_pages_ratelimited(struct address_space *mapping){  struct inode *inode = mapping->host;  struct backing_dev_info *bdi = inode_to_bdi(inode);  struct bdi_writeback *wb = NULL;  int ratelimit;......  if (unlikely(current->nr_dirtied >= ratelimit))    balance_dirty_pages(mapping, wb, current->nr_dirtied);......}

static ssize_t generic_file_buffered_read(struct kiocb *iocb,    struct iov_iter *iter, ssize_t written){  struct file *filp = iocb->ki_filp;  struct address_space *mapping = filp->f_mapping;  struct inode *inode = mapping->host;  for (;;) {    struct page *page;    pgoff_t end_index;    loff_t isize;    page = find_get_page(mapping, index);    if (!page) {      if (iocb->ki_flags & IOCB_NOWAIT)        goto would_block;      page_cache_sync_readahead(mapping,          ra, filp,          index, last_index - index);      page = find_get_page(mapping, index);      if (unlikely(page == NULL))        goto no_cached_page;    }    if (PageReadahead(page)) {      page_cache_async_readahead(mapping,          ra, filp, page,          index, last_index - index);    }    /*     * Ok, we have the page, and it's up-to-date, so     * now we can copy it to user space...     */    ret = copy_page_to_iter(page, offset, nr, iter);    }}