文件系统简介：bcachefs（二）

// libbcachefs/fs.c

struct file_operations bch_file_operations = {
  ...
  .read_iter = bch2_read_iter,
  ...
}

ssize_t bch2_read_iter(struct kiocb *iocb, struct iov_iter *iter) {
  ...

  // 为了单刀直入相关代码，跳过常见的 Page Cache 路径，来到了 direct IO
  if (iocb->ki_flags & IOCB_DIRECT) {
    struct blk_plug plug;
    ...
    blk_start_plug(&plug);
    ret = bch2_direct_IO_read(iocb, iter);
    blk_finish_plug(&plug)
    ...

int bch2_direct_IO_read(struct kiocb *req, struct iov_iter *iter) {
  struct file *file = req->ki_filp;
  struct bch_inode_info *inode = file_bch_inode(file);

  struct bio *bio;

  loff_t offset = req->ki_pos;
  size_t shorten;
  ssize_t ret;

  // 根据从 offset 开始，文件还有多少内容
  //   提及 iter 中有多少空间存读出内容
  // 算出读多长的内容
  ret = min_t(loff_t, iter->count,
              max_t(loff_t, 0,
                            i_size_read(&inode->v) /* 读取 struct inode::i_size */ - offset));

  shorten = iter->count - round_up(ret, block_bytes(c) /* 磁盘的 block size */);
  iter->count -= shorten;
  // ↑↑ 代数化简：iter->count == round_up(ret, block_bytes(c)
  //              即本次读文件，需要访问的数据量

  bio = bio_alloc_bioset(...);
  ...

  goto start;
  while (iter->count) {
    ...

start:
    ...
    bio->bi_iter.bi_sector = offset >> 9;
    ...
    // 下面函数，会调用到 __iov_iter_get_pages_alloc() 函数，会减少 iter->count
    ret = bio_iov_iter_get_pages(bio, iter);
    ...

    offset += bio->bi_iter.bi_size;
    ...
    bch2_read(c, rbio_init(bio, opts), inode_inum(inode));
  }

  iter->count += shorten;
  ...
  

void __bch2_read(struct bch_fs *c, struct bch_read_bio *rbio,
                 struct bvec_iter bvec_iter, subvol_inum inum,
                 ..., unsigned flags) {

  struct btree_trans trans; // 本文暂时忽略 btree_trans
  struct btree_iter iter;

  struct bkey_s_c k;

  ...
  while (1) {
    ...
    // 将 POS(...) 设置到 btree_iter::k（注：其类型为 bkey）
    bch2_btree_iter_set_pos(&iter, POS(inum.inum, bvec_iter.bi_sector));


    // 定位 k
    struct bkey_s_c k = bch2_btree_iter_peek_slot(&iter); 

    ...

    // ----logical offset: (offset into file)----·
    //                                           |
    //  extent's logical                         |
    //   start offset                            |
    //        |                                  |
    //        V                                  V
    //        --------------------------------------------
    //        |                 extent                    |
    //        -------------------------------------------- 
    unsigned offset_into_extent = iter.pos.offset - bkey_start_offset(k.k)

    unsigned sectors = k.k->size - offset_into_extent; // 本 extent 内需要读的部分 

    ...
    unsigned bytes = min(sectors, bvec_iter_sectors(bvec_iter)) << 9;
    swap(bvec_iter.bi_size, bytes);

    if (bvec_iter.bi_size == bytes)
      flags |= BCH_READ_LAST_FRAGMENT;

    __bch2_read_extent(&trans, rbio, bvec_iter, iter.pos, BTREE_ID_extents,
                       k, offset_into_extent, ...);
    ...

    // 一次对文件的读，例如通过 read(fd, buf, size)
    // 可能涉及对多个 extents 的访问
    // 当最后一个 extent 被访问后，设置 flags BCH_READ_LAST_FRAGMENT
    // 此处：检测到此 flag，则退出
    if (flags & BCH_READ_LAST_FRAGMENT)
      break;

    swap(bvec_iter.bi_size, bytes);
    bio_advance_iter(&rbio->bio, &bvec_iter, bytes);

    ...
  } // while(1)

  ...
} // __bch2_read()

// 对 BTREE_ITER_IS_EXTENTS，对 iter.pos 再前进一步
struct bpos search_key = btree_iter_search_key(iter);

// 这是因为，如下的情形，刚好指向 extent 在 btree 中的 “key”
//          但这个“key” 位置，因为是 start-of-extent + size-of-extent
// ----iter.pos(offset into file)----·      其实不属于 extent
//                                   |
//                                   V
//        ---------------------------
//        |            extent        |
//        ---------------------------

iter->path = bch2_btree_path_set_pos(trans, iter->path, search_key ...);

unsigned depth_want = path->level;
...

// 再次调用了下述函数，留意这次 path->level 得到了更新
path->level = btree_path_up_until_good_node(trans, path, 0);

while (path->level > depth_want) { // 代入例子，path->level 为 2, depth_want 为 0
  ret = btree_path_node(path, path->level) ?
          btree_path_down(trans, path, ...) : ...;
  if (ret) { /* 出错处理 */ }
}
path->uptodate = BTREE_ITER_UPTODATE;
...

int btree_path_down(struct btree_trans *trans, struct btree_path *path, ...) {
  struct bkey_buf tmp; /* bch2_bkey_buf_init(&tmp); */
  struct btree_path_level *l = path->l + path->level;
  ...
  bch2_bkey_buf_unpack(&tmp, trans->c /* struct bch_fs* */, l->b,
      bch2_btree_node_iter_peek(&l->iter, l->b) /* struct bkey_packed* */ );
  ...
  struct btree *b = bch2_btree_node_get(trans, path, tmp.k,
      path->level - 1 /* 点题：“path_down” */, ...);
  ...
  path->level = level;
  bch2_btree_path_level_init(trans, path, b);
  ...
}

struct btree *b = btree_node_mem_ptr(k);

if (b->hash_val == btree_ptr_hash_val(k))
  // hit ！

void bch2_btree_node_iter_init(struct btree_node_iter *iter,
  struct btree *b, struct bpos *search) {

  ...
  memset(iter, 0, sizeof(*iter));
  ...

  struct bkey_packed *k[MAX_BSETS];

  for (i = 0; i < b->nsets; i++) {
    // 二叉树查找，定位到一个所谓的 cacheline
    k[i] = bch2_bset_search_linear(b, b->set + i, search, ...);
    prefetch_four_cachelines(k[i]);
  }

  struct btree_node_iter_set *pos = iter->data;
  for (i = 0; i < b->nsets; i++) {
    // 通过 end_offset，换算成指针
    // Note：实际上，指针指向本 bset 的结尾
    // 参见：set_btree_bset_end() 函数
    struct bkey_packed *end = btree_bkey_last(b, b->set + i);

    // 在 cacheline 中定位出 bkey_packed
    k[i] = bch2_bset_search_linear(..., search, ..., k[i]);

    if (k[i] != end)
      *pos++ = (struct btree_node_iter_set) {
        __btree_node_key_to_offset(b, k[i]),
        __btree_node_key_to_offset(b, end)
      };
  }
  bch2_btree_node_iter_sort(iter, b);
}

int __bch2_read_extent(... struct bch_read_bio *orig,
                       ... struct bvec_iter iter,
                       ... struct bkey_s_c k,
                       ... unsigned offset_into_extent,
                       ...) {

  if (bkey_extent_is_inline_data(k.k)) {
    // value 直接是 data，而不是一个指向 data 的“指针”
    // 拷贝到 iter 下
    goto out_read_done;
  }

  struct extent_ptr_decoded pick;
                 // 这个函数其实仅仅是从 k 中解析出 bch_extent_ptr
  int pick_ret = bch2_bkey_pick_read_device(..., k, &pick);

  pick.ptr.offset += pick.crc.offset /* 推测起来：extent 开头有个 crc */
                     + offset_into_extent;

  orig->bio.bi_iter = iter;
  orig->bio.bi_iter.bi_sector = pick.ptr.offset;
  // 本次 IO 的 size 为 bvec_iter_sectors(iter);

  submit_bio(&orig->bio);
  ...
}

# bcachefs 命令行工具，包含一个移植到用户态的 bcachefs 库
# 代码阅读推荐使用本仓库
git clone https://evilpiepirate.org/git/bcachefs-tools.git

# 包含 bcachefs 的整个内核源代码，体积较大
git clone https://evilpiepirate.org/git/bcachefs.git