[sheepdog] =?yes?q?=5BPATCH=20v2=202/4=5D=20md=3A=20make=20vdisk=20management=20dynamic?=
Liu Yuan
namei.unix at gmail.com
Tue Sep 3 10:45:08 CEST 2013
This removes the roof limit of disks that one sheep can manage.
The vnode creation algorithm isn't changed, but the calculation of vdisk number
is changed:
we assign each vdisk 1G bytes, so, e.g, 160G will have 160 vdisks and 1T
will have 1024 vdisks.
In this way, we only need to add/remove associated vdisks from vdisk ring by
plug/unplug physical disks.
vdisks are now managed by rbtree instead of a fixed array.
Signed-off-by: Liu Yuan <namei.unix at gmail.com>
---
sheep/md.c | 360 +++++++++++++++++++++++-----------------------------
sheep/sheep_priv.h | 2 +-
2 files changed, 163 insertions(+), 199 deletions(-)
diff --git a/sheep/md.c b/sheep/md.c
index d51a7c6..e433f28 100644
--- a/sheep/md.c
+++ b/sheep/md.c
@@ -13,98 +13,85 @@
#include "sheep_priv.h"
-#define MD_DEFAULT_VDISKS 128
-#define MD_MAX_VDISK (MD_MAX_DISK * MD_DEFAULT_VDISKS)
+#define MD_VDISK_SIZE ((uint64_t)1*1024*1024*1024) /* 1G */
+
+#define NONE_EXIST_PATH "/all/disks/are/broken/,ps/əʌo7/!"
struct disk {
+ struct list_node list;
char path[PATH_MAX];
- uint16_t nr_vdisks;
uint64_t space;
};
struct vdisk {
- uint16_t idx;
- uint64_t id;
+ struct rb_node rb;
+ struct disk *disk;
+ uint64_t hash;
};
-static struct disk md_disks[MD_MAX_DISK];
-static struct vdisk md_vds[MD_MAX_VDISK];
+struct md {
+ struct rb_root vroot;
+ struct list_head disk_list;
+ struct sd_lock lock;
+ uint64_t space;
+ uint32_t nr_disks;
+};
-static struct sd_lock md_lock = SD_LOCK_INITIALIZER;
-static int md_nr_disks; /* Protected by md_lock */
-static int md_nr_vds;
+static struct md md = {
+ .vroot = RB_ROOT,
+ .disk_list = LIST_HEAD_INIT(md.disk_list),
+ .lock = SD_LOCK_INITIALIZER,
+};
static inline int nr_online_disks(void)
{
int nr;
- sd_read_lock(&md_lock);
- nr = md_nr_disks;
- sd_unlock(&md_lock);
+ sd_read_lock(&md.lock);
+ nr = md.nr_disks;
+ sd_unlock(&md.lock);
return nr;
}
-static struct vdisk *oid_to_vdisk_from(struct vdisk *vds, int nr, uint64_t oid)
+static inline int vdisk_number(struct disk *disk)
{
- uint64_t id = sd_hash_oid(oid);
- int start, end, pos;
-
- start = 0;
- end = nr - 1;
-
- if (id > vds[end].id || id < vds[start].id)
- return &vds[start];
-
- for (;;) {
- pos = (end - start) / 2 + start;
- if (vds[pos].id < id) {
- if (vds[pos + 1].id >= id)
- return &vds[pos + 1];
- start = pos;
- } else
- end = pos;
- }
+ return DIV_ROUND_UP(disk->space, MD_VDISK_SIZE);
}
static int vdisk_cmp(const struct vdisk *d1, const struct vdisk *d2)
{
- return intcmp(d1->id, d2->id);
+ return intcmp(d1->hash, d2->hash);
}
-static inline int disk_to_vdisks(const struct disk *ds, int idx, struct vdisk *vds)
+static struct vdisk *vdisk_insert(struct vdisk *new)
{
- int nr = 0;
- const struct disk *d = ds + idx;
- uint64_t hval = sd_hash(d->path, strlen(d->path));
-
- for (int i = 0; i < d->nr_vdisks; i++) {
- hval = sd_hash_next(hval);
-
- vds[nr].id = hval;
- vds[nr].idx = idx;
-
- nr++;
- }
-
- return nr;
+ return rb_insert(&md.vroot, new, rb, vdisk_cmp);
}
-static inline int disks_to_vdisks(const struct disk *ds, int nmds, struct vdisk *vds)
+/* If v1_hash < oid <= v2_hash, then oid is resident in v2 */
+static struct vdisk *oid_to_vdisk(uint64_t oid)
{
- int nr_vdisks = 0;
-
- for (int i = 0; i < nmds; i++)
- nr_vdisks += disk_to_vdisks(ds, i, vds + nr_vdisks);
+ struct vdisk dummy = {
+ .hash = sd_hash_oid(oid),
+ };
- xqsort(vds, nr_vdisks, vdisk_cmp);
-
- return nr_vdisks;
+ return rb_find(&md.vroot, &dummy, rb, vdisk_cmp);
}
-static inline struct vdisk *oid_to_vdisk(uint64_t oid)
+static void create_vdisks(struct disk *disk)
{
- return oid_to_vdisk_from(md_vds, md_nr_vds, oid);
+ uint64_t hval = sd_hash(disk->path, strlen(disk->path));
+
+ for (int i = 0; i < vdisk_number(disk); i++) {
+ struct vdisk *v = xmalloc(sizeof(*v));
+
+ hval = sd_hash_next(hval);
+ v->hash = hval;
+ v->disk = disk;
+ if (unlikely(vdisk_insert(v)))
+ panic("vdisk hash collison");
+ }
}
static inline void trim_last_slash(char *path)
@@ -114,56 +101,19 @@ static inline void trim_last_slash(char *path)
path[strlen(path) - 1] = '\0';
}
-static int path_to_disk_idx(char *path)
+static struct disk *path_to_disk(char *path)
{
- int i;
+ struct disk *disk;
trim_last_slash(path);
- for (i = 0; i < md_nr_disks; i++)
- if (strcmp(md_disks[i].path, path) == 0)
- return i;
-
- return -1;
-}
-
-bool md_add_disk(char *path)
-{
- if (path_to_disk_idx(path) != -1) {
- sd_err("duplicate path %s", path);
- return false;
+ list_for_each_entry(disk, &md.disk_list, list) {
+ if (strcmp(disk->path, path) == 0)
+ return disk;
}
- if (xmkdir(path, sd_def_dmode) < 0) {
- sd_err("can't mkdir for %s, %m", path);
- return false;
- }
-
- md_nr_disks++;
-
- pstrcpy(md_disks[md_nr_disks - 1].path, PATH_MAX, path);
- sd_info("%s, nr %d", md_disks[md_nr_disks - 1].path, md_nr_disks);
- return true;
-}
-
-static inline void calculate_vdisks(struct disk *disks, int nr_disks,
- uint64_t total)
-{
- uint64_t avg_size = total / nr_disks;
- float factor;
- int i;
-
- for (i = 0; i < nr_disks; i++) {
- factor = (float)disks[i].space / (float)avg_size;
- md_disks[i].nr_vdisks = rintf(MD_DEFAULT_VDISKS * factor);
- sd_debug("%s has %d vdisks, free space %" PRIu64,
- md_disks[i].path, md_disks[i].nr_vdisks,
- md_disks[i].space);
- }
+ return NULL;
}
-#define MDNAME "user.md.size"
-#define MDSIZE sizeof(uint64_t)
-
static int get_total_object_size(uint64_t oid, char *wd, uint32_t epoch,
void *total)
{
@@ -272,6 +222,8 @@ static uint64_t init_path_space(char *path)
goto broken_path;
}
+#define MDNAME "user.md.size"
+#define MDSIZE sizeof(uint64_t)
if (getxattr(path, MDNAME, &size, MDSIZE) < 0) {
if (errno == ENODATA) {
goto create;
@@ -295,81 +247,94 @@ broken_path:
return 0;
}
-static inline void md_remove_disk(int idx)
+/* We don't need lock at init stage */
+bool md_add_disk(char *path)
{
- int i;
+ struct disk *new;
- sd_info("%s from multi-disk array", md_disks[idx].path);
- /*
- * We need to keep last disk path to generate EIO when all disks are
- * broken
- */
- for (i = idx; i < md_nr_disks - 1; i++)
- md_disks[i] = md_disks[i + 1];
+ if (path_to_disk(path)) {
+ sd_err("duplicate path %s", path);
+ return false;
+ }
+
+ if (xmkdir(path, sd_def_dmode) < 0) {
+ sd_err("can't mkdir for %s, %m", path);
+ return false;
+ }
+
+ new = xmalloc(sizeof(*new));
+ pstrcpy(new->path, PATH_MAX, path);
+ new->space = init_path_space(new->path);
+ if (!new->space) {
+ free(new);
+ return false;
+ }
- md_nr_disks--;
+ create_vdisks(new);
+ list_add(&new->list, &md.disk_list);
+ md.space += new->space;
+ md.nr_disks++;
+
+ sd_info("%s, vdisk nr %d, total disk %d", new->path, vdisk_number(new),
+ md.nr_disks);
+ return true;
}
-uint64_t md_init_space(void)
+static inline void md_remove_disk(struct disk *disk)
{
- uint64_t total;
- int i;
-
-reinit:
- if (!md_nr_disks)
- return 0;
- total = 0;
+ struct vdisk *v;
- for (i = 0; i < md_nr_disks; i++) {
- md_disks[i].space = init_path_space(md_disks[i].path);
- if (!md_disks[i].space) {
- md_remove_disk(i);
- goto reinit;
- }
- total += md_disks[i].space;
+ sd_info("%s from multi-disk array", disk->path);
+ list_del(&disk->list);
+ md.nr_disks--;
+ rb_for_each_entry(v, &md.vroot, rb) {
+ if (v->disk == disk)
+ rb_erase(&v->rb, &md.vroot);
}
- calculate_vdisks(md_disks, md_nr_disks, total);
- md_nr_vds = disks_to_vdisks(md_disks, md_nr_disks, md_vds);
+ free(disk);
+}
- return total;
+uint64_t md_init_space(void)
+{
+ return md.space;
}
-char *md_get_object_path(uint64_t oid)
+static const char *md_get_object_path_nolock(uint64_t oid)
{
struct vdisk *vd;
- char *p;
- sd_read_lock(&md_lock);
- vd = oid_to_vdisk(oid);
- p = md_disks[vd->idx].path;
- sd_unlock(&md_lock);
- sd_debug("%d, %s", vd->idx, p);
+ if (md.nr_disks == 0)
+ return NONE_EXIST_PATH; /* To generate EIO */
- return p;
+ vd = oid_to_vdisk(oid);
+ return vd->disk->path;
}
-static char *md_get_object_path_nolock(uint64_t oid)
+const char *md_get_object_path(uint64_t oid)
{
- struct vdisk *vd;
+ const char *p;
- vd = oid_to_vdisk(oid);
- return md_disks[vd->idx].path;
+ sd_read_lock(&md.lock);
+ p = md_get_object_path_nolock(oid);
+ sd_unlock(&md.lock);
+
+ return p;
}
int for_each_object_in_wd(int (*func)(uint64_t oid, char *path, uint32_t epoch,
void *arg),
bool cleanup, void *arg)
{
- int i, ret = SD_RES_SUCCESS;
+ int ret = SD_RES_SUCCESS;
+ struct disk *disk;
- sd_read_lock(&md_lock);
- for (i = 0; i < md_nr_disks; i++) {
- ret = for_each_object_in_path(md_disks[i].path, func,
- cleanup, arg);
+ sd_read_lock(&md.lock);
+ list_for_each_entry(disk, &md.disk_list, list) {
+ ret = for_each_object_in_path(disk->path, func, cleanup, arg);
if (ret != SD_RES_SUCCESS)
break;
}
- sd_unlock(&md_lock);
+ sd_unlock(&md.lock);
return ret;
}
@@ -377,33 +342,35 @@ int for_each_object_in_stale(int (*func)(uint64_t oid, char *path,
uint32_t epoch, void *arg),
void *arg)
{
- int i, ret = SD_RES_SUCCESS;
+ int ret = SD_RES_SUCCESS;
char path[PATH_MAX];
+ struct disk *disk;
- sd_read_lock(&md_lock);
- for (i = 0; i < md_nr_disks; i++) {
- snprintf(path, sizeof(path), "%s/.stale", md_disks[i].path);
+ sd_read_lock(&md.lock);
+ list_for_each_entry(disk, &md.disk_list, list) {
+ snprintf(path, sizeof(path), "%s/.stale", disk->path);
sd_err("%s", path);
ret = for_each_object_in_path(path, func, false, arg);
if (ret != SD_RES_SUCCESS)
break;
}
- sd_unlock(&md_lock);
+ sd_unlock(&md.lock);
return ret;
}
int for_each_obj_path(int (*func)(char *path))
{
- int i, ret = SD_RES_SUCCESS;
+ int ret = SD_RES_SUCCESS;
+ struct disk *disk;
- sd_read_lock(&md_lock);
- for (i = 0; i < md_nr_disks; i++) {
- ret = func(md_disks[i].path);
+ sd_read_lock(&md.lock);
+ list_for_each_entry(disk, &md.disk_list, list) {
+ ret = func(disk->path);
if (ret != SD_RES_SUCCESS)
break;
}
- sd_unlock(&md_lock);
+ sd_unlock(&md.lock);
return ret;
}
@@ -423,18 +390,18 @@ static inline void kick_recover(void)
static void md_do_recover(struct work *work)
{
struct md_work *mw = container_of(work, struct md_work, work);
- int idx, nr = 0;
+ struct disk *disk;
+ int nr = 0;
- sd_write_lock(&md_lock);
- idx = path_to_disk_idx(mw->path);
- if (idx < 0)
+ sd_write_lock(&md.lock);
+ disk = path_to_disk(mw->path);
+ if (!disk)
/* Just ignore the duplicate EIO of the same path */
goto out;
- md_remove_disk(idx);
- md_init_space();
- nr = md_nr_disks;
+ md_remove_disk(disk);
+ nr = md.nr_disks;
out:
- sd_unlock(&md_lock);
+ sd_unlock(&md.lock);
if (nr > 0)
kick_recover();
@@ -549,15 +516,16 @@ static int md_check_and_move(uint64_t oid, uint32_t epoch, char *path)
static int scan_wd(uint64_t oid, uint32_t epoch)
{
- int i, ret = SD_RES_EIO;
+ int ret = SD_RES_EIO;
+ struct disk *disk;
- sd_read_lock(&md_lock);
- for (i = 0; i < md_nr_disks; i++) {
- ret = md_check_and_move(oid, epoch, md_disks[i].path);
+ sd_read_lock(&md.lock);
+ list_for_each_entry(disk, &md.disk_list, list) {
+ ret = md_check_and_move(oid, epoch, disk->path);
if (ret == SD_RES_SUCCESS)
break;
}
- sd_unlock(&md_lock);
+ sd_unlock(&md.lock);
return ret;
}
@@ -597,40 +565,42 @@ int md_get_stale_path(uint64_t oid, uint32_t epoch, char *path)
uint32_t md_get_info(struct sd_md_info *info)
{
uint32_t ret = sizeof(*info);
- int i;
+ struct disk *disk;
+ int i = 0;
memset(info, 0, ret);
- sd_read_lock(&md_lock);
- for (i = 0; i < md_nr_disks; i++) {
+ sd_read_lock(&md.lock);
+ list_for_each_entry(disk, &md.disk_list, list) {
info->disk[i].idx = i;
- pstrcpy(info->disk[i].path, PATH_MAX, md_disks[i].path);
+ pstrcpy(info->disk[i].path, PATH_MAX, disk->path);
/* FIXME: better handling failure case. */
info->disk[i].free = get_path_free_size(info->disk[i].path,
&info->disk[i].used);
+ i++;
}
- info->nr = md_nr_disks;
- sd_unlock(&md_lock);
+ info->nr = md.nr_disks;
+ sd_unlock(&md.lock);
return ret;
}
static inline void md_del_disk(char *path)
{
- int idx = path_to_disk_idx(path);
+ struct disk *disk = path_to_disk(path);
- if (idx < 0) {
+ if (!disk) {
sd_err("invalid path %s", path);
return;
}
- md_remove_disk(idx);
+ md_remove_disk(disk);
}
static int do_plug_unplug(char *disks, bool plug)
{
char *path;
- int old_nr, cur_nr = 0, ret = SD_RES_UNKNOWN;
+ int old_nr, ret = SD_RES_UNKNOWN;
- sd_write_lock(&md_lock);
- old_nr = md_nr_disks;
+ sd_write_lock(&md.lock);
+ old_nr = md.nr_disks;
path = strtok(disks, ",");
do {
if (plug) {
@@ -642,22 +612,14 @@ static int do_plug_unplug(char *disks, bool plug)
} while ((path = strtok(NULL, ",")));
/* If no disks change, bail out */
- if (old_nr == md_nr_disks)
+ if (old_nr == md.nr_disks)
goto out;
- md_init_space();
- cur_nr = md_nr_disks;
-
ret = SD_RES_SUCCESS;
out:
- sd_unlock(&md_lock);
+ sd_unlock(&md.lock);
- /*
- * We have to kick recover aggressively because there is possibility
- * that nr of disks are removed during md_init_space() happens to equal
- * nr of disks we added.
- */
- if (cur_nr > 0 && ret == SD_RES_SUCCESS)
+ if (ret == SD_RES_SUCCESS)
kick_recover();
return ret;
@@ -676,12 +638,14 @@ int md_unplug_disks(char *disks)
uint64_t md_get_size(uint64_t *used)
{
uint64_t fsize = 0;
- *used = 0;
+ struct disk *disk;
- sd_read_lock(&md_lock);
- for (int i = 0; i < md_nr_disks; i++)
- fsize += get_path_free_size(md_disks[i].path, used);
- sd_unlock(&md_lock);
+ *used = 0;
+ sd_read_lock(&md.lock);
+ list_for_each_entry(disk, &md.disk_list, list) {
+ fsize += get_path_free_size(disk->path, used);
+ }
+ sd_unlock(&md.lock);
return fsize + *used;
}
diff --git a/sheep/sheep_priv.h b/sheep/sheep_priv.h
index 8029f48..0feffef 100644
--- a/sheep/sheep_priv.h
+++ b/sheep/sheep_priv.h
@@ -439,7 +439,7 @@ int journal_remove_object(uint64_t oid);
/* md.c */
bool md_add_disk(char *path);
uint64_t md_init_space(void);
-char *md_get_object_path(uint64_t oid);
+const char *md_get_object_path(uint64_t oid);
int md_handle_eio(char *);
bool md_exist(uint64_t oid);
int md_get_stale_path(uint64_t oid, uint32_t epoch, char *path);
--
1.7.9.5
More information about the sheepdog
mailing list