sheep.h

static inline uint64_t
node_disk_to_vnodes(const struct sd_node *n, struct rb_root *vroot)
{

    uint64_t node_hval = sd_hash(&n->nid, offsetof(typeof(n->nid),
                               io_addr));
    uint64_t hval, disk_vnodes, total = 0;

    for (int j = 0; j < DISK_MAX; j++) {
        if (!n->disks[j].disk_id)
            continue;
        hval = fnv_64a_64(node_hval, n->disks[j].disk_id);
        disk_vnodes = DIV_ROUND_UP(n->disks[j].disk_space, WEIGHT_MIN);
        total += disk_vnodes;
        for (int k = 0; k < disk_vnodes; k++) {
            hval = sd_hash_next(hval);
            struct sd_vnode *v = xmalloc(sizeof(*v));
            v->hash = hval;
            v->node = n;
            if (unlikely(rb_insert(vroot, v, rb, vnode_cmp)))
                panic("vdisk hash collison");
        }
    }
    return total;
}
// 计算该节点上的disk一共需要对应多少个vnode
static inline void
disks_to_vnodes(struct rb_root *nroot, struct rb_root *vroot)
{
    struct sd_node *n;

    rb_for_each_entry(n, nroot, rb)
        n->nr_vnodes = node_disk_to_vnodes(n, vroot);
}

nodes到vnodes的映射：

static inline void
node_to_vnodes(const struct sd_node *n, struct rb_root *vroot)
{
    uint64_t hval = sd_hash(&n->nid, offsetof(typeof(n->nid),
                          io_addr));
    // 逐个记录vnode，vnode信息包含：vnode的hash值，vnode所归属的node的信息
    for (int i = 0; i < n->nr_vnodes; i++) {
        struct sd_vnode *v = xmalloc(sizeof(*v));

        hval = sd_hash_next(hval);
        v->hash = hval;
        v->node = n;
        if (unlikely(rb_insert(vroot, v, rb, vnode_cmp)))
            panic("vdisk hash collison");
    }
}

static inline void
nodes_to_vnodes(struct rb_root *nroot, struct rb_root *vroot)
{
    struct sd_node *n;
    // 从nroot出发逐个去为node分配vnodes
    rb_for_each_entry(n, nroot, rb)
        node_to_vnodes(n, vroot);
}

sheep.h文件

// vnode的结构体：包含所依附的node和hash信息
struct sd_vnode {
    struct rb_node rb;
    const struct sd_node *node;
    uint64_t hash;
};
// vnode基本信息
struct vnode_info {
    struct rb_root vroot;       // vnode的红黑树根 
    struct rb_root nroot;       // node的红黑树根
    int nr_nodes;                 // 映射的nodes的个数 ？ 
    int nr_zones;                 // 映射的分区的个数，应该一样啊 ？
    refcnt_t refcnt;              // 引用计数
};

static inline void sd_init_req(struct sd_req *req, uint8_t opcode)
{
    memset(req, 0, sizeof(*req));
    req->opcode = opcode;
    req->proto_ver = opcode < 0x80 ? SD_PROTO_VER : SD_SHEEP_PROTO_VER;
}
// 判断两个vnode是否为同一个zone
static inline int same_zone(const struct sd_vnode *v1,
                const struct sd_vnode *v2)
{
    return v1->node->zone == v2->node->zone;
}
// 判断是否是同一个vnode
static inline int vnode_cmp(const struct sd_vnode *node1,
                const struct sd_vnode *node2)
{
    return intcmp(node1->hash, node2->hash);
}
/* If v1_hash < oid_hash <= v2_hash, then oid is resident on v2 */
static inline struct sd_vnode *
oid_to_first_vnode(uint64_t oid, struct rb_root *root)
{
    struct sd_vnode dummy = {
        .hash = sd_hash_oid(oid),
    };
    return rb_nsearch(root, &dummy, rb, vnode_cmp);
}
/* Replica are placed along the ring one by one with different zones */
static inline void oid_to_vnodes(uint64_t oid, struct rb_root *root,
                 int nr_copies,
                 const struct sd_vnode **vnodes)
{
    const struct sd_vnode *next = oid_to_first_vnode(oid, root);

    vnodes[0] = next;
    for (int i = 1; i < nr_copies; i++) {
next:
        next = rb_entry(rb_next(&next->rb), struct sd_vnode, rb);
        if (!next) /* Wrap around */
            next = rb_entry(rb_first(root), struct sd_vnode, rb);
        if (unlikely(next == vnodes[0]))
            panic("can't find a valid vnode");
        for (int j = 0; j < i; j++)
            if (same_zone(vnodes[j], next))
                goto next;
        vnodes[i] = next;
    }
}

static inline const struct sd_vnode *
oid_to_vnode(uint64_t oid, struct rb_root *root, int copy_idx)
{
    const struct sd_vnode *vnodes[SD_MAX_COPIES];

    oid_to_vnodes(oid, root, copy_idx + 1, vnodes);

    return vnodes[copy_idx];
}

static inline const struct sd_node *
oid_to_node(uint64_t oid, struct rb_root *root, int copy_idx)
{
    const struct sd_vnode *vnode;

    vnode = oid_to_vnode(oid, root, copy_idx);

    return vnode->node;
}
// 从oid获取其所在的vnode，返回值在nodes参数中
static inline void oid_to_nodes(uint64_t oid, struct rb_root *root,
                int nr_copies,
                const struct sd_node **nodes)
{
    const struct sd_vnode *vnodes[SD_MAX_COPIES];

    oid_to_vnodes(oid, root, nr_copies, vnodes);
    for (int i = 0; i < nr_copies; i++)
        nodes[i] = vnodes[i]->node;
}

static inline int oid_cmp(const uint64_t *oid1, const uint64_t *oid2)
{
    return intcmp(*oid1, *oid2);
}

static inline int node_id_cmp(const struct node_id *node1,
                  const struct node_id *node2)
{
    int cmp = memcmp(node1->addr, node2->addr, sizeof(node1->addr));
    if (cmp != 0)
        return cmp;

    return intcmp(node1->port, node2->port);
}

static inline int node_cmp(const struct sd_node *node1,
               const struct sd_node *node2)
{
    return node_id_cmp(&node1->nid, &node2->nid);
}

static inline int oid_entry_cmp(const struct oid_entry *entry1,
               const struct oid_entry *entry2)
{
    return node_cmp(entry1->node, entry2->node);
}

static inline bool node_eq(const struct sd_node *a, const struct sd_node *b)
{
    return node_cmp(a, b) == 0;
}
// 为node的disks分配vnode，记录在rbtree中
static inline uint64_t
node_disk_to_vnodes(const struct sd_node *n, struct rb_root *vroot)
{

    uint64_t node_hval = sd_hash(&n->nid, offsetof(typeof(n->nid),
                               io_addr));
    uint64_t hval, disk_vnodes, total = 0;

    for (int j = 0; j < DISK_MAX; j++) {
        if (!n->disks[j].disk_id)
            continue;
        hval = fnv_64a_64(node_hval, n->disks[j].disk_id);
        disk_vnodes = DIV_ROUND_UP(n->disks[j].disk_space, WEIGHT_MIN);
        total += disk_vnodes;
        for (int k = 0; k < disk_vnodes; k++) {
            hval = sd_hash_next(hval);
            struct sd_vnode *v = xmalloc(sizeof(*v));
            v->hash = hval;
            v->node = n;
            if (unlikely(rb_insert(vroot, v, rb, vnode_cmp)))
                panic("vdisk hash collison");
        }
    }
    return total;
}
// 一个节点对应的vnode的个数
static inline void
disks_to_vnodes(struct rb_root *nroot, struct rb_root *vroot)
{
    struct sd_node *n;

    rb_for_each_entry(n, nroot, rb)
        n->nr_vnodes = node_disk_to_vnodes(n, vroot);
}
// 非disk模式下：disk到vnode的映射
static inline void
node_to_vnodes(const struct sd_node *n, struct rb_root *vroot)
{
    uint64_t hval = sd_hash(&n->nid, offsetof(typeof(n->nid),
                          io_addr));

    for (int i = 0; i < n->nr_vnodes; i++) {
        struct sd_vnode *v = xmalloc(sizeof(*v));

        hval = sd_hash_next(hval);
        v->hash = hval;
        v->node = n;
        if (unlikely(rb_insert(vroot, v, rb, vnode_cmp)))
            panic("vdisk hash collison");
    }
}

static inline void
nodes_to_vnodes(struct rb_root *nroot, struct rb_root *vroot)
{
    struct sd_node *n;

    rb_for_each_entry(n, nroot, rb)
        node_to_vnodes(n, vroot);
}

// 判断cluster的模式：diskmode或者非disk
static inline bool is_cluster_diskmode(const struct cluster_info *cinfo)
{
    return (cinfo->flags & SD_CLUSTER_FLAG_DISKMODE) > 0;
}

static inline bool is_cluster_autovnodes(const struct cluster_info *cinfo)
{
    return (cinfo->flags & SD_CLUSTER_FLAG_AUTO_VNODES) > 0;
}

static inline size_t count_data_objs(const struct sd_inode *inode)
{
    return DIV_ROUND_UP(inode->vdi_size,
                (1UL << inode->block_size_shift));
}

static inline __attribute__((used)) void __sd_proto_build_bug_ons(void)
{
    /* never called, only for checking BUILD_BUG_ON()s */
    BUILD_BUG_ON(sizeof(struct sd_req) != SD_REQ_SIZE);
    BUILD_BUG_ON(sizeof(struct sd_rsp) != SD_RSP_SIZE);
}

#define SD_FORMAT_VERSION 0x0006
#define SD_CONFIG_SIZE 40

struct sheepdog_config {
    uint64_t ctime;
    uint16_t flags;
    uint8_t copies;
    uint8_t default_store[STORE_LEN];
    uint8_t shutdown;
    uint8_t copy_policy;
    uint8_t block_size_shift;
    uint16_t version;
    uint64_t space;
};