BCache源码浅析之二数据结构与操作

2.主流程与数据结构

2.1 bcache初始化

(1) register_bcache

首先read_super得到超级快的信息，根据该信息能的知道是主设备还是cache设备

(2) register_bdev 主设备注册：

cached_dev_init : 初始化struct cached_dev中的先关结构

disk包含了gendisk和

cache_accounting包含了统计信息

sb_* 用于管理super block io

running表明了主设备的状态

io* 用于记录顺序读写信息

cached_dev_init ==> bcache_device_init 会注册request queue, 并初始化gendisk

cached_dev_init ==>bch_cached_dev_request_init注册request queue的回调

cached_dev_init==>bch_cached_dev_writeback_init 初始化writeback模块

（3） register_cache ==》 register_cache_set

struct cache :

每个cache设备与一个bch_allocator_thread关联，用于bucket的分配

sb* : 用于访问cache设备的超级块

cache_set: 一个cache set中可以有一个或多个cache 设备， bch_cache_set_alloc用于分配一个cache-set; bch_cache_sets是全局cache_set的list.

DECLARE_FIFO(long,free)[RESERVE_NR];用于记录可用的bucket, bcache用bucket来管理磁盘空间。

最后会关联cache与cache_set

ca->set = c; //ca为cache,c为cache_set

ca->set->cache[ca->sb.nr_this_dev]= ca;

c->cache_by_alloc[c->caches_loaded++]= ca;

(4）bch_cache_set_alloc

首先从super block中获取bucket size, block_size等参数， 然后依次调用如下初始化函数：

c->bio_split = bioset_create

c->uuids = alloc_bucket_pages

c-->moving_gc_wq =create_workqueue("bcache_gc")

bch_journal_alloc(c) ；//journal 初始化

bch_btree_cache_alloc(c) ；//建立btree node的分配缓存管理结构

bch_open_buckets_alloc(c) ；//初始化c->data_buckets 一共为6个

bch_bset_sort_state_init；//用于bset中的sort操作

（5） 关联主设备与cache设备bch_cached_dev_attach

a. 主设别状态检察

b. uuid检察，若uuid未分配则写分配uuid并写入bch_uuid_write

c. bcache_device_attach关联cache 与主设备

d. bch_cached_dev_run运行主设备

e. 建立link文件bcache_device_link

bch_cached_dev_run

a. add_disk(d->disk); 这样block层会知道有block设备增加了

b. kobject_uevent_env 发送uevent

c. 建立dev 与bcache链接文件

2.2 btree的基本数据结构

（1） bucket

缓存设备会按照bucket大小划分成很多bucket，bucket的大小最好是设置成与缓存设备ssd的擦除大小一致，一般建议128k~2M+，默认是512k。bucket内空间是追加分配的，只记录当前分配到哪个偏移了，下一次分配的时候从当前记录位置往后分配。另外在选择bucket来缓存数据时有两个优先原则：1）优先考虑io连续性，即使io可能来自于不同的生产者；2）其次考虑相关性，同一个进程产生的数据尽量缓存到相同的bucket里

struct bucket {

atomic_t pin;

uint16_t prio;/*每次hit都会增加，然后所有的bucket的优先级编号都会周期性地减少，不常用的会被回收，这个优先级编号主要是用来实现lru替换的*/

uint8_t gen;//generation，用来invalidate bucket用的。

uint8_t last_gc;/* Most out of date gen in the btree */

uint16_t gc_mark;/* Bitfield used by GC. See below for field */

};

(2) bkey

bcache使用了b+tree, b+tree的node和叶节点指向的数据，最终存到bucket对应的cache disk中的位置。b+树节点中的关键结构就是bkey，bkey就是记录缓存设备缓存数据和后端设备数据的映射关系的，其结构如下。

struct bkey {

__u64 high;

__u64 low;

__u64 ptr[];

};

/*

KEY_INODE:表示一个后端设备的id编号（后端设备在cache set中一般以bdev0，bdev1这种方式出现）

KEY_SIZE：表示该bkey所对应缓存数据的大小

KEY_DIRTY：表示该块缓存数据是否是脏数据

KEY_PTRS：表示cache设备的个数（多个ptr是用来支持多个cache设备的，多个cache设备只对脏数据和元数据做镜像）

KEY_OFFSET：bkey所缓存的hdd上的那段数据区域的结束地址

PTR_DEV：cache设备

PTR_OFFSET：在缓存设备中缓存的数据的起始地址

PTR_GEN：对应cache的bucket的迭代数（版本）

*/

由于key中记录了PTR_OFFSET，因此根据该信息能够得到bucket

static inlinesize_t PTR_BUCKET_NR(struct cache_set *c,

const struct bkey *k,

unsigned ptr) {

return sector_to_bucket(c, PTR_OFFSET(k,ptr));

}

BEKY 的比较函数如下：

static__always_inline int64_t bkey_cmp(const struct bkey *l,

const structbkey *r) {

return unlikely(KEY_INODE(l) !=KEY_INODE(r))

? (int64_t) KEY_INODE(l) -(int64_t) KEY_INODE(r)

: (int64_t) KEY_OFFSET(l) -(int64_t) KEY_OFFSET(r);

}

（3） bset

一个bset是一个bkey的数组，在内存中的bset是一段连续的内存，并且以bkey排序的，内存中一个btree node只有4个bset。

struct btree {

。。。。。。

struct btree_keys keys;

。。。。。。。

}

struct btree_keys{

。。。。。。

/*

*Sets of sorted keys - the real btree node - plus a binary search tree

*

*set[0] is special; set[0]->tree, set[0]->prev and set[0]->data point

*to the memory we have allocated for this btree node. Additionally,

*set[0]->data points to the entire btree node as it exists on disk.

*/

struct bset_tree set[MAX_BSETS]; //MAX_BESTS = 4

};

struct bset_tree {

.......

struct bset *data;

}

struct bset {

__u64 csum;

__u64 magic;

__u64 seq;

__u32 version;

__u32 keys;

union {

struct bkey start[0];

__u64 d[0];

};

};

(4) B+ Tree

bcache中以b+tree来维护索引，一个btree node里包含4个bset，每个bset中是排序的bkey。每个btree node以一个bkey来标识，该bkey是其子节点中所有bkey中的最大值，不同于标准的b+树那(父节点存放子节点的地址指针); bcache中的b+树中非叶子节点中存放的bkey用于查找其子节点（并不是存的地址指针），而是根据bkey计算hash，再到hash表中取查找btree node（mca_find函数实现）。叶子节点中的bkey存放的就是实际的映射了（根据这些key可以找到缓存数据以及在hdd上的位置）。

btree 叶节点的遍历： bch_btree_map_keys ==》

intbch_btree_map_keys(struct btree_op *op, struct cache_set *c,

struct bkey *from, btree_map_keys_fn*fn, int flags)

{

return btree_root(map_keys_recurse, c, op, from, fn, flags); //遍历btree+进行查找

}

#definebtree_root(fn, c, op, ...) \

({ \

int _r = -EINTR; \

do { \

struct btree *_b = (c)->root; \

bool _w = insert_lock(op, _b); \

rw_lock(_w, _b, _b->level); \

if (_b == (c)->root && \

_w == insert_lock(op, _b)) { \

_b->parent = NULL; \

_r = bch_btree_ ## fn(_b, op, ##__VA_ARGS__); \

} \

rw_unlock(_w, _b); \

bch_cannibalize_unlock(c); \

if (_r == -EINTR) \

schedule(); \

} while (_r == -EINTR); \

\

finish_wait(&(c)->btree_cache_wait,&(op)->wait); \

_r; \

})

static intbch_btree_map_keys_recurse(struct btree *b, struct btree_op *op,

struct bkey *from, btree_map_keys_fn *fn,

int flags) {

。。。。。

bch_btree_iter_init(&b->keys,&iter, from);

while ((k =bch_btree_iter_next_filter(&iter, &b->keys, bch_ptr_bad))) {

ret = !b->level

? fn(op, b, k) //已经到页节点了

: btree(map_keys_recurse,k, b, op, from, fn, flags); //非页节点

from = NULL;

if (ret != MAP_CONTINUE)

return ret;

}

if (!b->level && (flags &MAP_END_KEY))

ret = fn(op, b,&KEY(KEY_INODE(&b->key),

KEY_OFFSET(&b->key), 0));

return ret;

}

#define btree(fn,key, b, op, ...) \

({ \

int _r, l = (b)->level - 1; \

bool _w = l <= (op)->lock; \

struct btree *_child =bch_btree_node_get((b)->c, op, key, l, _w);\

if (!IS_ERR(_child)) { \

_child->parent = (b); \

_r = bch_btree_ ## fn(_child, op, ##__VA_ARGS__); \

rw_unlock(_w, _child); \

} else \

_r = PTR_ERR(_child); \

_r; \

})

struct btree*bch_btree_node_get(struct cache_set *c, struct btree_op *op,

struct bkey *k, int level, bool write) {

。。。。。。

retry:

b = mca_find(c, k);

if (!b) { //若key 对应的btree不存在，则先申请分配一个bucket,并

mutex_lock(&c->bucket_lock);

b = mca_alloc(c, op, k, level);

mutex_unlock(&c->bucket_lock);

。。。。。。

bch_btree_node_read(b);

} else {

rw_lock(write, b, level);

if (PTR_HASH(c, &b->key) !=PTR_HASH(c, k)) {

rw_unlock(write, b);

goto retry;

}

}

。。。。。。

return b;

}

static structbtree *mca_find(struct cache_set *c, struct bkey *k)

{

struct btree *b;

rcu_read_lock();

hlist_for_each_entry_rcu(b, mca_hash(c,k), hash) //根据key的hash从hlist中取出下一个btree节点

if (PTR_HASH(c, &b->key) ==PTR_HASH(c, k))

goto out;

b = NULL;

out:

rcu_read_unlock();

return b;

}

为了提高性能， 使用了cache_set中有btree的缓存

struct list_head btree_cache;

struct list_head btree_cache_freeable;

struct list_head btree_cache_freed;

如果btree不存在时，先从cache_set中的btree_cache中分配，失败则最终从kzalloc中分配。（相关机制较简单， 不在详细分析 mca_bucket_alloc, mca_data_alloc, mca_reap）

bch_btree_iter_init和bch_btree_iter_next_filter为btree的访问迭代器，其基本工作原理就是

（1）bch_btree_iter_init 根据要search的bkeys,遍历btree中的bset, bset中的bkey.然后将满足条件的bkey集合以{bkey_start, bkey_end}元素形式添加到heap中。 heap的排序比较函数为：btree_iter_cmp

static inline boolbtree_iter_cmp(struct btree_iter_set l, struct btree_iter_set r) {

return bkey_cmp(l.k, r.k) > 0;

}

bch_btree_iter_init==> __bch_btree_iter_init {

for (; start <= bset_tree_last(b);start++) {

ret = bch_bset_search(b, start,search);

bch_btree_iter_push(iter, ret,bset_bkey_last(start->data));

}

}

(2) bch_btree_iter_next_filter则根据heap中的bkey范围，每次返回一个bkey.

3.底层IO

3.1 Closure

bcache里的closure就是一个引用计数来管理回调或对象析构的机制

structclosure {

union {

struct {

structworkqueue_struct *wq;

struct task_struct *task;

struct llist_node list;

closure_fn *fn;

};

struct work_struct work;

};

struct closure *parent; //父closure对象

atomic_t remaining;

};

当调用closure_get后，需要调用closure_put来减少引用计数。 closure_init后引用计数被设为1； closuer实现较为简单，下面只分析几种常用的使用方法.

(1) Basicusage

foo_endio(struct bio *bio, int error) {

closure_put(cl);

}

closure_init(cl); // ref to 1

do_stuff();

closure_get(cl); //ref to 2

bio1->bi_endio = foo_endio;

do_more_stuff();

closure_get(cl); ref to 3

bio2->bi_endio = foo_endio;

bio_submit(bio1);

bio_submit(bio2); //当bio1 bio2完成后ref set to 1

continue_at(cl, complete_some_read,system_wq); ref--, 如果ref == 0则complete_some_read在system_wq中执行。

continue_at如果wq参数为0，则同步执行。

上面的例子是异步执行方法，它还支持同步应用: A __closure_wait(ref++), B closure_sync会使调用task让出cpu,; C __closure_wake_up(ref--)能唤醒等待的task

最后closure还支持parent机制， closure_init， 如果parent不为NULL, 会closure_get(parent)

closure_put_after_sub时， 如果当前ref==0, 则closure_put(parent)

3.2 基本io.c

bch_bio_max_sectors: 合并bio中的请求，并返回一次最大传输长度

bch_generic_make_request:根据设备能支持一次最大传输长度， 拆分传输。

bch_bbio_alloc： 分配一个对cache设备的bio,

其中bio->bi_bdev = PTR_CACHE(c, &b->key,0)->bdev;

bch_submit_bbio提交对cache设备的io

bch_bbio_endio对cache设备的io的回调

bch_bio_map： 对bio中的bio_vec分配物理地址， 当base参数不为0时执行如下代码：

bv->bv_page =is_vmalloc_addr(base)

? vmalloc_to_page(base)

: virt_to_page(base);

下面时对block层bio操作的小结：

1. bio_alloc_pages:为bio中的每个bio_vec分配物理内存页

2. bio_initbio初始化； bio_reset reinit bio

3.bio_sumit异步提交bio；submit_bio_wait同步提交

4.拆分bio: bio_next_split

5. bioset_create:create bioset, bio_alloc_bioset: allocate a bio for I/O according to bioset