[sheepdog] [PATCH 1/2] sheep: rename files for store_driver
Liu Yuan
namei.unix at gmail.com
Wed Mar 18 02:50:22 CET 2015
On Tue, Mar 17, 2015 at 06:00:53PM +0900, Saeki Masaki wrote:
> This change is a preparation patch for add store_driver.
> Put files together to the new folder.
>
> and fix little style problem in md.c
>
> Signed-off-by: Masaki Saeki <saeki.masaki at po.ntts.co.jp>
> ---
> sheep/Makefile.am | 6 +-
> sheep/md.c | 878 ---------------------------------------------
> sheep/plain_store.c | 759 ---------------------------------------
> sheep/store.c | 511 --------------------------
> sheep/store/common.c | 511 ++++++++++++++++++++++++++
> sheep/store/md.c | 878 +++++++++++++++++++++++++++++++++++++++++++++
> sheep/store/plain_store.c | 759 +++++++++++++++++++++++++++++++++++++++
> 7 files changed, 2152 insertions(+), 2150 deletions(-)
> delete mode 100644 sheep/md.c
> delete mode 100644 sheep/plain_store.c
> delete mode 100644 sheep/store.c
> create mode 100644 sheep/store/common.c
> create mode 100644 sheep/store/md.c
> create mode 100644 sheep/store/plain_store.c
>
> diff --git a/sheep/Makefile.am b/sheep/Makefile.am
> index 7a08838..3ddd761 100644
> --- a/sheep/Makefile.am
> +++ b/sheep/Makefile.am
> @@ -24,10 +24,12 @@ AM_CPPFLAGS = -I$(top_builddir)/include -I$(top_srcdir)/include \
>
> sbin_PROGRAMS = sheep
>
> -sheep_SOURCES = sheep.c group.c request.c gateway.c store.c vdi.c \
> +sheep_SOURCES = sheep.c group.c request.c gateway.c vdi.c \
> journal.c ops.c recovery.c cluster/local.c \
> object_cache.c object_list_cache.c \
> - plain_store.c config.c migrate.c md.c
> + store/common.c store/md.c \
> + store/plain_store.c \
> + config.c migrate.c
>
> if BUILD_HTTP
> sheep_SOURCES += http/http.c http/kv.c http/s3.c http/swift.c \
> diff --git a/sheep/md.c b/sheep/md.c
> deleted file mode 100644
> index c00d7a5..0000000
> --- a/sheep/md.c
> +++ /dev/null
> @@ -1,878 +0,0 @@
> -/*
> - * Copyright (C) 2013 Taobao Inc.
> - *
> - * Liu Yuan <namei.unix at gmail.com>
> - *
> - * This program is free software; you can redistribute it and/or
> - * modify it under the terms of the GNU General Public License version
> - * 2 as published by the Free Software Foundation.
> - *
> - * You should have received a copy of the GNU General Public License
> - * along with this program. If not, see <http://www.gnu.org/licenses/>.
> - */
> -
> -#include "sheep_priv.h"
> -
> -#define MD_VDISK_SIZE ((uint64_t)1*1024*1024*1024) /* 1G */
> -
> -#define NONE_EXIST_PATH "/all/disks/are/broken/,ps/ノ厂経7/!"
> -
> -struct md md = {
> - .vroot = RB_ROOT,
> - .root = RB_ROOT,
> - .lock = SD_RW_LOCK_INITIALIZER,
> -};
> -
> -static inline uint32_t nr_online_disks(void)
> -{
> - uint32_t nr;
> -
> - sd_read_lock(&md.lock);
> - nr = md.nr_disks;
> - sd_rw_unlock(&md.lock);
> -
> - return nr;
> -}
> -
> -static inline int vdisk_number(const struct disk *disk)
> -{
> - return DIV_ROUND_UP(disk->space, MD_VDISK_SIZE);
> -}
> -
> -static int disk_cmp(const struct disk *d1, const struct disk *d2)
> -{
> - return strcmp(d1->path, d2->path);
> -}
> -
> -static int vdisk_cmp(const struct vdisk *d1, const struct vdisk *d2)
> -{
> - return intcmp(d1->hash, d2->hash);
> -}
> -
> -static struct vdisk *vdisk_insert(struct vdisk *new)
> -{
> - return rb_insert(&md.vroot, new, rb, vdisk_cmp);
> -}
> -
> -/* If v1_hash < hval <= v2_hash, then oid is resident in v2 */
> -static struct vdisk *hval_to_vdisk(uint64_t hval)
> -{
> - struct vdisk dummy = { .hash = hval };
> -
> - return rb_nsearch(&md.vroot, &dummy, rb, vdisk_cmp);
> -}
> -
> -static struct vdisk *oid_to_vdisk(uint64_t oid)
> -{
> - return hval_to_vdisk(sd_hash_oid(oid));
> -}
> -
> -static void create_vdisks(const struct disk *disk)
> -{
> - uint64_t hval = sd_hash(disk->path, strlen(disk->path));
> - const struct sd_node *n = &sys->this_node;
> - uint64_t node_hval;
> - int nr;
> -
> - if (is_cluster_diskmode(&sys->cinfo)) {
> - node_hval = sd_hash(&n->nid, offsetof(typeof(n->nid), io_addr));
> - hval = fnv_64a_64(node_hval, hval);
> - nr = DIV_ROUND_UP(disk->space, WEIGHT_MIN);
> - if (0 == n->nid.port)
> - return;
> - } else
> - nr = vdisk_number(disk);
> -
> - for (int i = 0; i < nr; 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 vdisk_free(struct vdisk *v)
> -{
> - rb_erase(&v->rb, &md.vroot);
> - free(v);
> -}
> -
> -static void remove_vdisks(const struct disk *disk)
> -{
> - uint64_t hval = sd_hash(disk->path, strlen(disk->path));
> - const struct sd_node *n = &sys->this_node;
> - uint64_t node_hval;
> - int nr;
> -
> - if (is_cluster_diskmode(&sys->cinfo)) {
> - node_hval = sd_hash(&n->nid, offsetof(typeof(n->nid), io_addr));
> - hval = fnv_64a_64(node_hval, hval);
> - nr = DIV_ROUND_UP(disk->space, WEIGHT_MIN);
> - } else
> - nr = vdisk_number(disk);
> -
> - for (int i = 0; i < nr; i++) {
> - struct vdisk *v;
> -
> - hval = sd_hash_next(hval);
> - v = hval_to_vdisk(hval);
> - assert(v->hash == hval);
> -
> - vdisk_free(v);
> - }
> -}
> -
> -static inline void trim_last_slash(char *path)
> -{
> - assert(path[0]);
> - while (path[strlen(path) - 1] == '/')
> - path[strlen(path) - 1] = '\0';
> -}
> -
> -static struct disk *path_to_disk(const char *path)
> -{
> - struct disk key = {};
> -
> - pstrcpy(key.path, sizeof(key.path), path);
> - trim_last_slash(key.path);
> -
> - return rb_search(&md.root, &key, rb, disk_cmp);
> -}
> -
> -size_t get_store_objsize(uint64_t oid)
> -{
> - if (is_erasure_oid(oid)) {
> - uint8_t policy = get_vdi_copy_policy(oid_to_vid(oid));
> - int d;
> - ec_policy_to_dp(policy, &d, NULL);
> - return get_vdi_object_size(oid_to_vid(oid)) / d;
> - }
> - return get_objsize(oid, get_vdi_object_size(oid_to_vid(oid)));
> -}
> -
> -static int get_total_object_size(uint64_t oid, const char *wd, uint32_t epoch,
> - uint8_t ec_index, struct vnode_info *vinfo,
> - void *total)
> -{
> - uint64_t *t = total;
> - struct stat s;
> - char path[PATH_MAX];
> -
> - snprintf(path, PATH_MAX, "%s/%016" PRIx64, wd, oid);
> - if (stat(path, &s) == 0)
> - *t += s.st_blocks * SECTOR_SIZE;
> - else
> - *t += get_store_objsize(oid);
> -
> - return SD_RES_SUCCESS;
> -}
> -
> -static int64_t find_string_integer(const char *str, const char *delimiter)
> -{
> - char *pos = strstr(str, delimiter), *p;
> - int64_t ret;
> -
> - ret = strtoll(pos + 1, &p, 10);
> - if (ret == LLONG_MAX || p == pos + 1) {
> - sd_err("%s strtoul failed, delimiter %s, %m", str, delimiter);
> - return -1;
> - }
> -
> - return ret;
> -}
> -
> -/* If cleanup is true, temporary objects will be removed */
> -static int for_each_object_in_path(const char *path,
> - int (*func)(uint64_t, const char *, uint32_t,
> - uint8_t, struct vnode_info *,
> - void *),
> - bool cleanup, struct vnode_info *vinfo,
> - void *arg)
> -{
> - DIR *dir;
> - struct dirent *d;
> - uint64_t oid;
> - int ret = SD_RES_SUCCESS;
> - char file_name[PATH_MAX];
> -
> - dir = opendir(path);
> - if (unlikely(!dir)) {
> - sd_err("failed to open %s, %m", path);
> - return SD_RES_EIO;
> - }
> -
> - while ((d = readdir(dir))) {
> - uint32_t epoch = 0;
> - uint8_t ec_index = SD_MAX_COPIES;
> -
> - /* skip ".", ".." and ".stale" */
> - if (unlikely(!strncmp(d->d_name, ".", 1)))
> - continue;
> -
> - sd_debug("%s, %s", path, d->d_name);
> - oid = strtoull(d->d_name, NULL, 16);
> - if (oid == 0 || oid == ULLONG_MAX)
> - continue;
> -
> - /* don't call callback against temporary objects */
> - if (is_tmp_dentry(d->d_name)) {
> - if (cleanup) {
> - snprintf(file_name, sizeof(file_name),
> - "%s/%s", path, d->d_name);
> - sd_debug("remove tmp object %s", file_name);
> - if (unlink(file_name) < 0)
> - sd_err("failed to unlink %s: %m",
> - file_name);
> - }
> - continue;
> - }
> -
> - if (is_stale_dentry(d->d_name)) {
> - epoch = find_string_integer(d->d_name, ".");
> - if (epoch < 0)
> - continue;
> - }
> -
> - if (is_ec_dentry(d->d_name)) {
> - ec_index = find_string_integer(d->d_name, "_");
> - if (ec_index < 0)
> - continue;
> - }
> -
> - ret = func(oid, path, epoch, ec_index, vinfo, arg);
> - if (ret != SD_RES_SUCCESS)
> - break;
> - }
> - closedir(dir);
> - return ret;
> -}
> -
> -static uint64_t get_path_free_size(const char *path, uint64_t *used)
> -{
> - struct statvfs fs;
> - uint64_t size;
> -
> - if (statvfs(path, &fs) < 0) {
> - sd_err("get disk %s space failed %m", path);
> - return 0;
> - }
> - size = (int64_t)fs.f_frsize * fs.f_bavail;
> -
> - if (!used)
> - goto out;
> - if (for_each_object_in_path(path, get_total_object_size, false,
> - NULL, used)
> - != SD_RES_SUCCESS)
> - return 0;
> -out:
> - return size;
> -}
> -
> -/*
> - * If path is broken during initialization or not support xattr return 0. We can
> - * safely use 0 to represent failure case because 0 space path can be
> - * considered as broken path.
> - */
> -static uint64_t init_path_space(const char *path, bool purge)
> -{
> - uint64_t size;
> - char stale[PATH_MAX];
> -
> - if (!is_xattr_enabled(path)) {
> - sd_warn("multi-disk support need xattr feature for path: %s",
> - path);
> - goto broken_path;
> - }
> -
> - if (purge && purge_directory(path) < 0)
> - sd_err("failed to purge %s", path);
> -
> - snprintf(stale, PATH_MAX, "%s/.stale", path);
> - if (xmkdir(stale, sd_def_dmode) < 0) {
> - sd_err("can't mkdir for %s, %m", stale);
> - 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;
> - } else {
> - sd_err("%s, %m", path);
> - goto broken_path;
> - }
> - }
> -
> - return size;
> -create:
> - size = get_path_free_size(path, NULL);
> - if (!size)
> - goto broken_path;
> - if (setxattr(path, MDNAME, &size, MDSIZE, 0) < 0) {
> - sd_err("%s, %m", path);
> - goto broken_path;
> - }
> - return size;
> -broken_path:
> - return 0;
> -}
> -
> -/* We don't need lock at init stage */
> -bool md_add_disk(const char *path, bool purge)
> -{
> - struct disk *new;
> -
> - 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);
> - trim_last_slash(new->path);
> - new->space = init_path_space(new->path, purge);
> - if (!new->space) {
> - free(new);
> - return false;
> - }
> -
> - create_vdisks(new);
> - rb_insert(&md.root, new, rb, disk_cmp);
> - 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;
> -}
> -
> -static inline void md_remove_disk(struct disk *disk)
> -{
> - sd_info("%s from multi-disk array", disk->path);
> - rb_erase(&disk->rb, &md.root);
> - md.nr_disks--;
> - remove_vdisks(disk);
> - free(disk);
> -}
> -
> -uint64_t md_init_space(void)
> -{
> - return md.space;
> -}
> -
> -static const char *md_get_object_dir_nolock(uint64_t oid)
> -{
> - const struct vdisk *vd;
> -
> - if (unlikely(md.nr_disks == 0))
> - return NONE_EXIST_PATH; /* To generate EIO */
> -
> - vd = oid_to_vdisk(oid);
> - return vd->disk->path;
> -}
> -
> -const char *md_get_object_dir(uint64_t oid)
> -{
> - const char *p;
> -
> - sd_read_lock(&md.lock);
> - p = md_get_object_dir_nolock(oid);
> - sd_rw_unlock(&md.lock);
> -
> - return p;
> -}
> -
> -struct process_path_arg {
> - const char *path;
> - struct vnode_info *vinfo;
> - int (*func)(uint64_t oid, const char *, uint32_t, uint8_t,
> - struct vnode_info *, void *arg);
> - bool cleanup;
> - void *opaque;
> - int result;
> -};
> -
> -static void *thread_process_path(void *arg)
> -{
> - int ret;
> - struct process_path_arg *parg = (struct process_path_arg *)arg;
> -
> - ret = for_each_object_in_path(parg->path, parg->func, parg->cleanup,
> - parg->vinfo, parg->opaque);
> - if (ret != SD_RES_SUCCESS)
> - parg->result = ret;
> -
> - return arg;
> -}
> -
> -main_fn int for_each_object_in_wd(int (*func)(uint64_t oid, const char *path,
> - uint32_t epoch, uint8_t ec_index,
> - struct vnode_info *vinfo, void *arg),
> - bool cleanup, void *arg)
> -{
> - int ret = SD_RES_SUCCESS;
> - const struct disk *disk;
> - struct process_path_arg *thread_args, *path_arg;
> - struct vnode_info *vinfo;
> - void *ret_arg;
> - sd_thread_t *thread_array;
> - int nr_thread = 0, idx = 0;
> -
> - sd_read_lock(&md.lock);
> -
> - rb_for_each_entry(disk, &md.root, rb) {
> - nr_thread++;
> - }
> -
> - thread_args = xmalloc(nr_thread * sizeof(struct process_path_arg));
> - thread_array = xmalloc(nr_thread * sizeof(sd_thread_t));
> -
> - vinfo = get_vnode_info();
> -
> - rb_for_each_entry(disk, &md.root, rb) {
> - thread_args[idx].path = disk->path;
> - thread_args[idx].vinfo = vinfo;
> - thread_args[idx].func = func;
> - thread_args[idx].cleanup = cleanup;
> - thread_args[idx].opaque = arg;
> - thread_args[idx].result = SD_RES_SUCCESS;
> - ret = sd_thread_create_with_idx("foreach wd",
> - thread_array + idx,
> - thread_process_path,
> - (void *)(thread_args + idx));
> - if (ret) {
> - /*
> - * If we can't create enough threads to process
> - * files, the data-consistent will be broken if
> - * we continued.
> - */
> - panic("Failed to create thread for path %s",
> - disk->path);
> - }
> - idx++;
> - }
> -
> - sd_debug("Create %d threads for all path", nr_thread);
> - /* wait for all threads to exit */
> - for (idx = 0; idx < nr_thread; idx++) {
> - ret = sd_thread_join(thread_array[idx], &ret_arg);
> - if (ret)
> - sd_err("Failed to join thread");
> - if (ret_arg) {
> - path_arg = (struct process_path_arg *)ret_arg;
> - if (path_arg->result != SD_RES_SUCCESS)
> - sd_err("%s, %s", path_arg->path,
> - sd_strerror(path_arg->result));
> - }
> - }
> -
> - put_vnode_info(vinfo);
> - sd_rw_unlock(&md.lock);
> -
> - free(thread_args);
> - free(thread_array);
> - return ret;
> -}
> -
> -int for_each_object_in_stale(int (*func)(uint64_t oid, const char *path,
> - uint32_t epoch, uint8_t,
> - struct vnode_info *, void *arg),
> - void *arg)
> -{
> - int ret = SD_RES_SUCCESS;
> - char path[PATH_MAX];
> - const struct disk *disk;
> -
> - sd_read_lock(&md.lock);
> - rb_for_each_entry(disk, &md.root, rb) {
> - snprintf(path, sizeof(path), "%s/.stale", disk->path);
> - ret = for_each_object_in_path(path, func, false, NULL, arg);
> - if (ret != SD_RES_SUCCESS)
> - break;
> - }
> - sd_rw_unlock(&md.lock);
> - return ret;
> -}
> -
> -
> -int for_each_obj_path(int (*func)(const char *path))
> -{
> - int ret = SD_RES_SUCCESS;
> - const struct disk *disk;
> -
> - sd_read_lock(&md.lock);
> - rb_for_each_entry(disk, &md.root, rb) {
> - ret = func(disk->path);
> - if (ret != SD_RES_SUCCESS)
> - break;
> - }
> - sd_rw_unlock(&md.lock);
> - return ret;
> -}
> -
> -struct md_work {
> - struct work work;
> - char path[PATH_MAX];
> -};
> -
> -static inline void kick_recover(void)
> -{
> - struct vnode_info *vinfo = get_vnode_info();
> -
> - if (is_cluster_diskmode(&sys->cinfo))
> - sys->cdrv->update_node(&sys->this_node);
> - else {
> - start_recovery(vinfo, vinfo, false);
> - put_vnode_info(vinfo);
> - }
> -}
> -
> -static void md_do_recover(struct work *work)
> -{
> - struct md_work *mw = container_of(work, struct md_work, work);
> - struct disk *disk;
> - int nr = 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(disk);
> - nr = md.nr_disks;
> -out:
> - sd_rw_unlock(&md.lock);
> -
> - if (disk) {
> - if (nr > 0) {
> - update_node_disks();
> - kick_recover();
> - } else {
> - leave_cluster();
> - }
> - }
> -
> - free(mw);
> -}
> -
> -int md_handle_eio(const char *fault_path)
> -{
> - struct md_work *mw;
> -
> - if (nr_online_disks() == 0)
> - return SD_RES_EIO;
> -
> - mw = xzalloc(sizeof(*mw));
> - mw->work.done = md_do_recover;
> - pstrcpy(mw->path, PATH_MAX, fault_path);
> - queue_work(sys->md_wqueue, &mw->work);
> -
> - /* Fool the requester to retry */
> - return SD_RES_NETWORK_ERROR;
> -}
> -
> -static inline bool md_access(const char *path)
> -{
> - if (access(path, R_OK | W_OK) < 0) {
> - if (unlikely(errno != ENOENT))
> - sd_err("failed to check %s, %m", path);
> - return false;
> - }
> -
> - return true;
> -}
> -
> -static int get_old_new_path(uint64_t oid, uint32_t epoch, uint8_t ec_index,
> - const char *path, char *old, char *new)
> -{
> - if (!epoch) {
> - if (!is_erasure_oid(oid)) {
> - snprintf(old, PATH_MAX, "%s/%016" PRIx64, path, oid);
> - snprintf(new, PATH_MAX, "%s/%016" PRIx64,
> - md_get_object_dir_nolock(oid), oid);
> - } else {
> - snprintf(old, PATH_MAX, "%s/%016" PRIx64"_%d", path,
> - oid, ec_index);
> - snprintf(new, PATH_MAX, "%s/%016" PRIx64"_%d",
> - md_get_object_dir_nolock(oid), oid, ec_index);
> - }
> - } else {
> - if (!is_erasure_oid(oid)) {
> - snprintf(old, PATH_MAX,
> - "%s/.stale/%016"PRIx64".%"PRIu32, path,
> - oid, epoch);
> - snprintf(new, PATH_MAX,
> - "%s/.stale/%016"PRIx64".%"PRIu32,
> - md_get_object_dir_nolock(oid), oid, epoch);
> - } else {
> - snprintf(old, PATH_MAX,
> - "%s/.stale/%016"PRIx64"_%d.%"PRIu32, path,
> - oid, ec_index, epoch);
> - snprintf(new, PATH_MAX,
> - "%s/.stale/%016"PRIx64"_%d.%"PRIu32,
> - md_get_object_dir_nolock(oid),
> - oid, ec_index ,epoch);
> - }
> - }
> -
> - if (!md_access(old))
> - return -1;
> -
> - return 0;
> -}
> -
> -static int md_move_object(uint64_t oid, const char *old, const char *new)
> -{
> - struct strbuf buf = STRBUF_INIT;
> - int fd, ret = -1;
> - size_t sz = get_store_objsize(oid);
> -
> - fd = open(old, O_RDONLY);
> - if (fd < 0) {
> - sd_err("failed to open %s", old);
> - goto out;
> - }
> -
> - ret = strbuf_read(&buf, fd, sz);
> - if (ret != sz) {
> - sd_err("failed to read %s, size %zu, %d, %m", old, sz, ret);
> - ret = -1;
> - goto out_close;
> - }
> -
> - if (atomic_create_and_write(new, buf.buf, buf.len, false) < 0) {
> - if (errno != EEXIST) {
> - sd_err("failed to create %s", new);
> - ret = -1;
> - goto out_close;
> - }
> - }
> - unlink(old);
> - ret = 0;
> -out_close:
> - close(fd);
> -out:
> - strbuf_release(&buf);
> - return ret;
> -}
> -
> -static int md_check_and_move(uint64_t oid, uint32_t epoch, uint8_t ec_index,
> - const char *path)
> -{
> - char old[PATH_MAX], new[PATH_MAX];
> -
> - if (get_old_new_path(oid, epoch, ec_index, path, old, new) < 0)
> - return SD_RES_EIO;
> - /*
> - * Recovery thread and main thread might try to recover the same object.
> - * Either one succeeds, the other will fail and proceed and end up
> - * trying to move the object to where it is already in place, in this
> - * case we simply return.
> - */
> - if (!strcmp(old, new))
> - return SD_RES_SUCCESS;
> -
> - /* We can't use rename(2) across device */
> - if (md_move_object(oid, old, new) < 0) {
> - sd_err("move old %s to new %s failed", old, new);
> - return SD_RES_EIO;
> - }
> -
> - sd_debug("from %s to %s", old, new);
> - return SD_RES_SUCCESS;
> -}
> -
> -static int scan_wd(uint64_t oid, uint32_t epoch, uint8_t ec_index)
> -{
> - int ret = SD_RES_EIO;
> - const struct disk *disk;
> -
> - sd_read_lock(&md.lock);
> - rb_for_each_entry(disk, &md.root, rb) {
> - ret = md_check_and_move(oid, epoch, ec_index, disk->path);
> - if (ret == SD_RES_SUCCESS)
> - break;
> - }
> - sd_rw_unlock(&md.lock);
> - return ret;
> -}
> -
> -bool md_exist(uint64_t oid, uint8_t ec_index, char *path)
> -{
> - if (md_access(path))
> - return true;
> - /*
> - * We have to iterate the WD because we don't have epoch-like history
> - * track to locate the objects for multiple disk failure. Simply do
> - * hard iteration simplify the code a lot.
> - */
> - if (scan_wd(oid, 0, ec_index) == SD_RES_SUCCESS)
> - return true;
> -
> - return false;
> -}
> -
> -int md_get_stale_path(uint64_t oid, uint32_t epoch, uint8_t ec_index,
> - char *path)
> -{
> - if (unlikely(!epoch))
> - panic("invalid 0 epoch");
> -
> - if (is_erasure_oid(oid)) {
> - if (unlikely(ec_index >= SD_MAX_COPIES))
> - panic("invalid ec index %d", ec_index);
> -
> - snprintf(path, PATH_MAX, "%s/.stale/%016"PRIx64"_%d.%"PRIu32,
> - md_get_object_dir(oid), oid, ec_index, epoch);
> - } else
> - snprintf(path, PATH_MAX, "%s/.stale/%016"PRIx64".%"PRIu32,
> - md_get_object_dir(oid), oid, epoch);
> -
> - if (md_access(path))
> - return SD_RES_SUCCESS;
> -
> - if (scan_wd(oid, epoch, ec_index) == SD_RES_SUCCESS)
> - return SD_RES_SUCCESS;
> -
> - return SD_RES_NO_OBJ;
> -}
> -
> -uint32_t md_get_info(struct sd_md_info *info)
> -{
> - uint32_t ret = sizeof(*info);
> - const struct disk *disk;
> - int i = 0;
> -
> - memset(info, 0, ret);
> - sd_read_lock(&md.lock);
> - rb_for_each_entry(disk, &md.root, rb) {
> - info->disk[i].idx = i;
> - 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_rw_unlock(&md.lock);
> - return ret;
> -}
> -
> -static inline void md_del_disk(const char *path)
> -{
> - struct disk *disk = path_to_disk(path);
> -
> - if (!disk) {
> - sd_err("invalid path %s", path);
> - return;
> - }
> - md_remove_disk(disk);
> -}
> -
> -#ifdef HAVE_DISKVNODES
> -void update_node_disks(void)
> -{
> - const struct disk *disk;
> - int i = 0;
> - bool rb_empty = false;
> -
> - if (!sys)
> - return;
> -
> - memset(sys->this_node.disks, 0, sizeof(struct disk_info) * DISK_MAX);
> - sd_read_lock(&md.lock);
> - rb_for_each_entry(disk, &md.root, rb) {
> - sys->this_node.disks[i].disk_id =
> - sd_hash(disk->path, strlen(disk->path));
> - sys->this_node.disks[i].disk_space = disk->space;
> - i++;
> - }
> - sd_rw_unlock(&md.lock);
> -
> - if (RB_EMPTY_ROOT(&md.vroot))
> - rb_empty = true;
> - sd_write_lock(&md.lock);
> - rb_for_each_entry(disk, &md.root, rb) {
> - if (!rb_empty)
> - remove_vdisks(disk);
> - create_vdisks(disk);
> - }
> - sd_rw_unlock(&md.lock);
> -}
> -#else
> -void update_node_disks(void)
> -{
> -}
> -#endif
> -
> -static int do_plug_unplug(char *disks, bool plug)
> -{
> - const char *path;
> - int old_nr, ret = SD_RES_UNKNOWN;
> -
> - sd_write_lock(&md.lock);
> - old_nr = md.nr_disks;
> - path = strtok(disks, ",");
> - do {
> - if (plug) {
> - if (!md_add_disk(path, true))
> - sd_err("failed to add %s", path);
> - } else {
> - md_del_disk(path);
> - }
> - } while ((path = strtok(NULL, ",")));
> -
> - /* If no disks change, bail out */
> - if (old_nr == md.nr_disks)
> - goto out;
> -
> - ret = SD_RES_SUCCESS;
> -out:
> - sd_rw_unlock(&md.lock);
> -
> - if (ret == SD_RES_SUCCESS) {
> - update_node_disks();
> - kick_recover();
> - }
> -
> - return ret;
> -}
> -
> -int md_plug_disks(char *disks)
> -{
> - return do_plug_unplug(disks, true);
> -}
> -
> -int md_unplug_disks(char *disks)
> -{
> - return do_plug_unplug(disks, false);
> -}
> -
> -uint64_t md_get_size(uint64_t *used)
> -{
> - uint64_t fsize = 0;
> - const struct disk *disk;
> -
> - *used = 0;
> - sd_read_lock(&md.lock);
> - rb_for_each_entry(disk, &md.root, rb) {
> - fsize += get_path_free_size(disk->path, used);
> - }
> - sd_rw_unlock(&md.lock);
> -
> - return fsize + *used;
> -}
> -
> -uint32_t md_nr_disks(void)
> -{
> - return nr_online_disks();
> -}
> diff --git a/sheep/plain_store.c b/sheep/plain_store.c
> deleted file mode 100644
> index 4c19832..0000000
> --- a/sheep/plain_store.c
> +++ /dev/null
> @@ -1,759 +0,0 @@
> -/*
> - * Copyright (C) 2012 Nippon Telegraph and Telephone Corporation.
> - *
> - * This program is free software; you can redistribute it and/or
> - * modify it under the terms of the GNU General Public License version
> - * 2 as published by the Free Software Foundation.
> - *
> - * You should have received a copy of the GNU General Public License
> - * along with this program. If not, see <http://www.gnu.org/licenses/>.
> - */
> -
> -#include <libgen.h>
> -#include <linux/falloc.h>
> -
> -#include "sheep_priv.h"
> -
> -#ifndef FALLOC_FL_PUNCH_HOLE
> -#define FALLOC_FL_PUNCH_HOLE 0x02
> -#endif
> -
> -#define sector_algined(x) ({ ((x) & (SECTOR_SIZE - 1)) == 0; })
> -
> -static inline bool iocb_is_aligned(const struct siocb *iocb)
> -{
> - return sector_algined(iocb->offset) && sector_algined(iocb->length);
> -}
> -
> -static int prepare_iocb(uint64_t oid, const struct siocb *iocb, bool create)
> -{
> - int syncflag = create ? O_SYNC : O_DSYNC;
> - int flags = syncflag | O_RDWR;
> -
> - if (uatomic_is_true(&sys->use_journal) || sys->nosync == true)
> - flags &= ~syncflag;
> -
> - if (sys->backend_dio && iocb_is_aligned(iocb)) {
> - if (!is_aligned_to_pagesize(iocb->buf))
> - panic("Memory isn't aligned to pagesize %p", iocb->buf);
> - flags |= O_DIRECT;
> - }
> -
> - if (create)
> - flags |= O_CREAT | O_EXCL;
> -
> - return flags;
> -}
> -
> -static int get_store_path(uint64_t oid, uint8_t ec_index, char *path)
> -{
> - if (is_erasure_oid(oid)) {
> - if (unlikely(ec_index >= SD_MAX_COPIES))
> - panic("invalid ec_index %d", ec_index);
> - return snprintf(path, PATH_MAX, "%s/%016"PRIx64"_%d",
> - md_get_object_dir(oid), oid, ec_index);
> - }
> -
> - return snprintf(path, PATH_MAX, "%s/%016" PRIx64,
> - md_get_object_dir(oid), oid);
> -}
> -
> -static int get_store_tmp_path(uint64_t oid, uint8_t ec_index, char *path)
> -{
> - if (is_erasure_oid(oid)) {
> - if (unlikely(ec_index >= SD_MAX_COPIES))
> - panic("invalid ec_index %d", ec_index);
> - return snprintf(path, PATH_MAX, "%s/%016"PRIx64"_%d.tmp",
> - md_get_object_dir(oid), oid, ec_index);
> - }
> -
> - return snprintf(path, PATH_MAX, "%s/%016" PRIx64".tmp",
> - md_get_object_dir(oid), oid);
> -}
> -
> -static int get_store_stale_path(uint64_t oid, uint32_t epoch, uint8_t ec_index,
> - char *path)
> -{
> - return md_get_stale_path(oid, epoch, ec_index, path);
> -}
> -
> -/*
> - * Check if oid is in this nodes (if oid is in the wrong place, it will be moved
> - * to the correct one after this call in a MD setup.
> - */
> -bool default_exist(uint64_t oid, uint8_t ec_index)
> -{
> - char path[PATH_MAX];
> -
> - get_store_path(oid, ec_index, path);
> -
> - return md_exist(oid, ec_index, path);
> -}
> -
> -static int err_to_sderr(const char *path, uint64_t oid, int err)
> -{
> - struct stat s;
> - char p[PATH_MAX], *dir;
> -
> - /* Use a temporary buffer since dirname() may modify its argument. */
> - pstrcpy(p, sizeof(p), path);
> - dir = dirname(p);
> -
> - sd_debug("%s", path);
> - switch (err) {
> - case ENOENT:
> - if (stat(dir, &s) < 0) {
> - sd_err("%s corrupted", dir);
> - return md_handle_eio(dir);
> - }
> - sd_debug("object %016" PRIx64 " not found locally", oid);
> - return SD_RES_NO_OBJ;
> - case ENOSPC:
> - /* TODO: stop automatic recovery */
> - sd_err("diskfull, oid=%"PRIx64, oid);
> - return SD_RES_NO_SPACE;
> - case EMFILE:
> - case ENFILE:
> - case EINTR:
> - case EAGAIN:
> - case EEXIST:
> - sd_err("%m, oid=%"PRIx64, oid);
> - /* make gateway try again */
> - return SD_RES_NETWORK_ERROR;
> - default:
> - sd_err("oid=%"PRIx64", %m", oid);
> - return md_handle_eio(dir);
> - }
> -}
> -
> -static int discard(int fd, uint64_t start, uint32_t end)
> -{
> - int ret = xfallocate(fd, FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE,
> - start, end - start);
> - if (ret < 0) {
> - if (errno == ENOSYS || errno == EOPNOTSUPP)
> - sd_info("FALLOC_FL_PUNCH_HOLE is not supported "
> - "on this filesystem");
> - else
> - sd_err("failed to discard object, %m");
> - }
> -
> - return ret;
> -}
> -
> -/* Trim zero blocks of the beginning and end of the object. */
> -static int default_trim(int fd, uint64_t oid, const struct siocb *iocb,
> - uint64_t *poffset, uint32_t *plen)
> -{
> - trim_zero_blocks(iocb->buf, poffset, plen);
> -
> - if (iocb->offset < *poffset) {
> - sd_debug("discard between %d, %ld, %" PRIx64, iocb->offset,
> - *poffset, oid);
> -
> - if (discard(fd, iocb->offset, *poffset) < 0)
> - return -1;
> - }
> -
> - if (*poffset + *plen < iocb->offset + iocb->length) {
> - uint64_t end = iocb->offset + iocb->length;
> - uint32_t object_size = get_vdi_object_size(oid_to_vid(oid));
> - if (end == get_objsize(oid, object_size))
> - /* This is necessary to punch the last block */
> - end = round_up(end, BLOCK_SIZE);
> - sd_debug("discard between %ld, %ld, %" PRIx64, *poffset + *plen,
> - end, oid);
> -
> - if (discard(fd, *poffset + *plen, end) < 0)
> - return -1;
> - }
> -
> - return 0;
> -}
> -
> -int default_write(uint64_t oid, const struct siocb *iocb)
> -{
> - int flags = prepare_iocb(oid, iocb, false), fd,
> - ret = SD_RES_SUCCESS;
> - char path[PATH_MAX];
> - ssize_t size;
> - uint32_t len = iocb->length;
> - uint64_t offset = iocb->offset;
> - static bool trim_is_supported = true;
> -
> - if (iocb->epoch < sys_epoch()) {
> - sd_debug("%"PRIu32" sys %"PRIu32, iocb->epoch, sys_epoch());
> - return SD_RES_OLD_NODE_VER;
> - }
> -
> - if (uatomic_is_true(&sys->use_journal) &&
> - unlikely(journal_write_store(oid, iocb->buf, iocb->length,
> - iocb->offset, false))
> - != SD_RES_SUCCESS) {
> - sd_err("turn off journaling");
> - uatomic_set_false(&sys->use_journal);
> - flags |= O_DSYNC;
> - sync();
> - }
> -
> - get_store_path(oid, iocb->ec_index, path);
> -
> - /*
> - * Make sure oid is in the right place because oid might be misplaced
> - * in a wrong place, due to 'shutdown/restart with less/more disks' or
> - * any bugs. We need call err_to_sderr() to return EIO if disk is broken
> - */
> - if (!default_exist(oid, iocb->ec_index))
> - return err_to_sderr(path, oid, ENOENT);
> -
> - fd = open(path, flags, sd_def_fmode);
> - if (unlikely(fd < 0))
> - return err_to_sderr(path, oid, errno);
> -
> - if (trim_is_supported && is_sparse_object(oid)) {
> - if (default_trim(fd, oid, iocb, &offset, &len) < 0) {
> - trim_is_supported = false;
> - offset = iocb->offset;
> - len = iocb->length;
> - }
> - }
> -
> - size = xpwrite(fd, iocb->buf, len, offset);
> - if (unlikely(size != len)) {
> - sd_err("failed to write object %"PRIx64", path=%s, offset=%"
> - PRId32", size=%"PRId32", result=%zd, %m", oid, path,
> - iocb->offset, iocb->length, size);
> - ret = err_to_sderr(path, oid, errno);
> - goto out;
> - }
> -out:
> - close(fd);
> - return ret;
> -}
> -
> -static int make_stale_dir(const char *path)
> -{
> - char p[PATH_MAX];
> -
> - snprintf(p, PATH_MAX, "%s/.stale", path);
> - if (xmkdir(p, sd_def_dmode) < 0) {
> - sd_err("%s failed, %m", p);
> - return SD_RES_EIO;
> - }
> - return SD_RES_SUCCESS;
> -}
> -
> -static int purge_dir(const char *path)
> -{
> - if (purge_directory(path) < 0)
> - return SD_RES_EIO;
> -
> - return SD_RES_SUCCESS;
> -}
> -
> -static int purge_stale_dir(const char *path)
> -{
> - char p[PATH_MAX];
> -
> - snprintf(p, PATH_MAX, "%s/.stale", path);
> -
> - if (purge_directory_async(p) < 0)
> - return SD_RES_EIO;
> -
> - return SD_RES_SUCCESS;
> -}
> -
> -int default_cleanup(void)
> -{
> - int ret;
> -
> - ret = for_each_obj_path(purge_stale_dir);
> - if (ret != SD_RES_SUCCESS)
> - return ret;
> -
> - return SD_RES_SUCCESS;
> -}
> -
> -static int init_vdi_state(uint64_t oid, const char *wd, uint32_t epoch)
> -{
> - int ret;
> - struct sd_inode *inode = xzalloc(SD_INODE_HEADER_SIZE);
> - struct siocb iocb = {
> - .epoch = epoch,
> - .buf = inode,
> - .length = SD_INODE_HEADER_SIZE,
> - };
> -
> - ret = default_read(oid, &iocb);
> - if (ret != SD_RES_SUCCESS) {
> - sd_err("failed to read inode header %" PRIx64 " %" PRId32
> - "wat %s", oid, epoch, wd);
> - goto out;
> - }
> - add_vdi_state_unordered(oid_to_vid(oid), inode->nr_copies,
> - vdi_is_snapshot(inode), inode->copy_policy,
> - inode->block_size_shift, inode->parent_vdi_id);
> -
> - if (inode->name[0] == '\0')
> - atomic_set_bit(oid_to_vid(oid), sys->vdi_deleted);
> -
> - atomic_set_bit(oid_to_vid(oid), sys->vdi_inuse);
> -
> - ret = SD_RES_SUCCESS;
> -out:
> - free(inode);
> - return ret;
> -}
> -
> -static int init_objlist_and_vdi_bitmap(uint64_t oid, const char *wd,
> - uint32_t epoch, uint8_t ec_index,
> - struct vnode_info *vinfo,
> - void *arg)
> -{
> - int ret;
> - objlist_cache_insert(oid);
> -
> - if (is_vdi_obj(oid)) {
> - sd_debug("found the VDI object %" PRIx64" epoch %"PRIu32
> - " at %s", oid, epoch, wd);
> - ret = init_vdi_state(oid, wd, epoch);
> - if (ret != SD_RES_SUCCESS)
> - return ret;
> - }
> - return SD_RES_SUCCESS;
> -}
> -
> -int default_init(void)
> -{
> - int ret;
> -
> - sd_debug("use plain store driver");
> - ret = for_each_obj_path(make_stale_dir);
> - if (ret != SD_RES_SUCCESS)
> - return ret;
> -
> - for_each_object_in_stale(init_objlist_and_vdi_bitmap, NULL);
> -
> - return for_each_object_in_wd(init_objlist_and_vdi_bitmap, true, NULL);
> -}
> -
> -static int default_read_from_path(uint64_t oid, const char *path,
> - const struct siocb *iocb)
> -{
> - int flags = prepare_iocb(oid, iocb, false), fd,
> - ret = SD_RES_SUCCESS;
> - ssize_t size;
> -
> - /*
> - * Make sure oid is in the right place because oid might be misplaced
> - * in a wrong place, due to 'shutdown/restart with less disks' or any
> - * bugs. We need call err_to_sderr() to return EIO if disk is broken.
> - *
> - * For stale path, get_store_stale_path already does default_exist job.
> - */
> - if (!is_stale_path(path) && !default_exist(oid, iocb->ec_index))
> - return err_to_sderr(path, oid, ENOENT);
> -
> - fd = open(path, flags);
> - if (fd < 0)
> - return err_to_sderr(path, oid, errno);
> -
> - size = xpread(fd, iocb->buf, iocb->length, iocb->offset);
> - if (size < 0) {
> - sd_err("failed to read object %"PRIx64", path=%s, offset=%"
> - PRId32", size=%"PRId32", result=%zd, %m", oid, path,
> - iocb->offset, iocb->length, size);
> - ret = err_to_sderr(path, oid, errno);
> - }
> - close(fd);
> - return ret;
> -}
> -
> -int default_read(uint64_t oid, const struct siocb *iocb)
> -{
> - int ret;
> - char path[PATH_MAX];
> -
> - get_store_path(oid, iocb->ec_index, path);
> - ret = default_read_from_path(oid, path, iocb);
> -
> - /*
> - * If the request is against the older epoch, try to read from
> - * the stale directory
> - */
> - if (ret == SD_RES_NO_OBJ && iocb->epoch > 0 &&
> - iocb->epoch < sys_epoch()) {
> - get_store_stale_path(oid, iocb->epoch, iocb->ec_index, path);
> - ret = default_read_from_path(oid, path, iocb);
> - }
> -
> - return ret;
> -}
> -
> -int default_create_and_write(uint64_t oid, const struct siocb *iocb)
> -{
> - char path[PATH_MAX], tmp_path[PATH_MAX], *dir;
> - int flags = prepare_iocb(oid, iocb, true);
> - int ret, fd;
> - uint32_t len = iocb->length;
> - uint32_t object_size = 0;
> - size_t obj_size;
> - uint64_t offset = iocb->offset;
> -
> - sd_debug("%"PRIx64, oid);
> - get_store_path(oid, iocb->ec_index, path);
> - get_store_tmp_path(oid, iocb->ec_index, tmp_path);
> -
> - if (uatomic_is_true(&sys->use_journal) &&
> - journal_write_store(oid, iocb->buf, iocb->length,
> - iocb->offset, true)
> - != SD_RES_SUCCESS) {
> - sd_err("turn off journaling");
> - uatomic_set_false(&sys->use_journal);
> - flags |= O_SYNC;
> - sync();
> - }
> -
> - fd = open(tmp_path, flags, sd_def_fmode);
> - if (fd < 0) {
> - if (errno == EEXIST) {
> - /*
> - * This happens if node membership changes during object
> - * creation; while gateway retries a CREATE request,
> - * recovery process could also recover the object at the
> - * same time. They should try to write the same date,
> - * so it is okay to simply return success here.
> - */
> - sd_debug("%s exists", tmp_path);
> - return SD_RES_SUCCESS;
> - }
> -
> - sd_err("failed to open %s: %m", tmp_path);
> - return err_to_sderr(path, oid, errno);
> - }
> -
> - obj_size = get_store_objsize(oid);
> -
> - trim_zero_blocks(iocb->buf, &offset, &len);
> -
> - object_size = get_vdi_object_size(oid_to_vid(oid));
> -
> - if (offset != 0 || len != get_objsize(oid, object_size)) {
> - if (is_sparse_object(oid))
> - ret = xftruncate(fd, obj_size);
> - else
> - ret = prealloc(fd, obj_size);
> - if (ret < 0) {
> - ret = err_to_sderr(path, oid, errno);
> - goto out;
> - }
> - }
> -
> - ret = xpwrite(fd, iocb->buf, len, offset);
> - if (ret != len) {
> - sd_err("failed to write object. %m");
> - ret = err_to_sderr(path, oid, errno);
> - goto out;
> - }
> -
> - ret = rename(tmp_path, path);
> - if (ret < 0) {
> - sd_err("failed to rename %s to %s: %m", tmp_path, path);
> - ret = err_to_sderr(path, oid, errno);
> - goto out;
> - }
> -
> - close(fd);
> -
> - if (uatomic_is_true(&sys->use_journal) || sys->nosync == true) {
> - objlist_cache_insert(oid);
> - return SD_RES_SUCCESS;
> - }
> -
> - pstrcpy(tmp_path, sizeof(tmp_path), path);
> - dir = dirname(tmp_path);
> - fd = open(dir, O_DIRECTORY | O_RDONLY);
> - if (fd < 0) {
> - sd_err("failed to open directory %s: %m", dir);
> - return err_to_sderr(path, oid, errno);
> - }
> -
> - if (fsync(fd) != 0) {
> - sd_err("failed to write directory %s: %m", dir);
> - ret = err_to_sderr(path, oid, errno);
> - close(fd);
> - if (unlink(path) != 0)
> - sd_err("failed to unlink %s: %m", path);
> - return ret;
> - }
> - close(fd);
> - objlist_cache_insert(oid);
> - return SD_RES_SUCCESS;
> -
> -out:
> - if (unlink(tmp_path) != 0)
> - sd_err("failed to unlink %s: %m", tmp_path);
> - close(fd);
> - return ret;
> -}
> -
> -int default_link(uint64_t oid, uint32_t tgt_epoch)
> -{
> - char path[PATH_MAX], stale_path[PATH_MAX];
> -
> - sd_debug("try link %"PRIx64" from snapshot with epoch %d", oid,
> - tgt_epoch);
> -
> - snprintf(path, PATH_MAX, "%s/%016"PRIx64, md_get_object_dir(oid), oid);
> - get_store_stale_path(oid, tgt_epoch, 0, stale_path);
> -
> - if (link(stale_path, path) < 0) {
> - /*
> - * Recovery thread and main thread might try to recover the
> - * same object and we might get EEXIST in such case.
> - */
> - if (errno == EEXIST)
> - goto out;
> -
> - sd_debug("failed to link from %s to %s, %m", stale_path, path);
> - return err_to_sderr(path, oid, errno);
> - }
> -out:
> - return SD_RES_SUCCESS;
> -}
> -
> -/*
> - * For replicated object, if any of the replica belongs to this node, we
> - * consider it not stale.
> - *
> - * For erasure coded object, since every copy is unique and if it migrates to
> - * other node(index gets changed even it has some other copy belongs to it)
> - * because of hash ring changes, we consider it stale.
> - */
> -static bool oid_stale(uint64_t oid, int ec_index, struct vnode_info *vinfo)
> -{
> - uint32_t i, nr_copies;
> - const struct sd_vnode *v;
> - bool ret = true;
> - const struct sd_vnode *obj_vnodes[SD_MAX_COPIES];
> -
> - nr_copies = get_obj_copy_number(oid, vinfo->nr_zones);
> - oid_to_vnodes(oid, &vinfo->vroot, nr_copies, obj_vnodes);
> - for (i = 0; i < nr_copies; i++) {
> - v = obj_vnodes[i];
> - if (vnode_is_local(v)) {
> - if (ec_index < SD_MAX_COPIES) {
> - if (i == ec_index)
> - ret = false;
> - } else {
> - ret = false;
> - }
> - break;
> - }
> - }
> -
> - return ret;
> -}
> -
> -static int move_object_to_stale_dir(uint64_t oid, const char *wd,
> - uint32_t epoch, uint8_t ec_index,
> - struct vnode_info *vinfo, void *arg)
> -{
> - char path[PATH_MAX], stale_path[PATH_MAX];
> - uint32_t tgt_epoch = *(uint32_t *)arg;
> -
> - /* ec_index from md.c is reliable so we can directly use it */
> - if (ec_index < SD_MAX_COPIES) {
> - snprintf(path, PATH_MAX, "%s/%016"PRIx64"_%d",
> - md_get_object_dir(oid), oid, ec_index);
> - snprintf(stale_path, PATH_MAX,
> - "%s/.stale/%016"PRIx64"_%d.%"PRIu32,
> - md_get_object_dir(oid), oid, ec_index, tgt_epoch);
> - } else {
> - snprintf(path, PATH_MAX, "%s/%016" PRIx64,
> - md_get_object_dir(oid), oid);
> - snprintf(stale_path, PATH_MAX, "%s/.stale/%016"PRIx64".%"PRIu32,
> - md_get_object_dir(oid), oid, tgt_epoch);
> - }
> -
> - if (unlikely(rename(path, stale_path)) < 0) {
> - sd_err("failed to move stale object %" PRIX64 " to %s, %m", oid,
> - path);
> - return SD_RES_EIO;
> - }
> -
> - sd_debug("moved object %"PRIx64, oid);
> - return SD_RES_SUCCESS;
> -}
> -
> -static int check_stale_objects(uint64_t oid, const char *wd, uint32_t epoch,
> - uint8_t ec_index, struct vnode_info *vinfo,
> - void *arg)
> -{
> - if (oid_stale(oid, ec_index, vinfo))
> - return move_object_to_stale_dir(oid, wd, 0, ec_index,
> - NULL, arg);
> -
> - return SD_RES_SUCCESS;
> -}
> -
> -int default_update_epoch(uint32_t epoch)
> -{
> - assert(epoch);
> - return for_each_object_in_wd(check_stale_objects, false, &epoch);
> -}
> -
> -int default_format(void)
> -{
> - unsigned ret;
> -
> - sd_debug("try get a clean store");
> - ret = for_each_obj_path(purge_dir);
> - if (ret != SD_RES_SUCCESS)
> - return ret;
> -
> - if (sys->enable_object_cache)
> - object_cache_format();
> -
> - return SD_RES_SUCCESS;
> -}
> -
> -int default_remove_object(uint64_t oid, uint8_t ec_index)
> -{
> - char path[PATH_MAX];
> -
> - if (uatomic_is_true(&sys->use_journal))
> - journal_remove_object(oid);
> -
> - get_store_path(oid, ec_index, path);
> -
> - if (unlink(path) < 0) {
> - if (errno == ENOENT)
> - return SD_RES_NO_OBJ;
> -
> - sd_err("failed, %s, %m", path);
> - return SD_RES_EIO;
> - }
> -
> - return SD_RES_SUCCESS;
> -}
> -
> -#define SHA1NAME "user.obj.sha1"
> -
> -static int get_object_sha1(const char *path, uint8_t *sha1)
> -{
> - if (getxattr(path, SHA1NAME, sha1, SHA1_DIGEST_SIZE)
> - != SHA1_DIGEST_SIZE) {
> - if (errno == ENODATA)
> - sd_debug("sha1 is not cached yet, %s", path);
> - else
> - sd_err("fail to get xattr, %s", path);
> - return -1;
> - }
> -
> - return 0;
> -}
> -
> -static int set_object_sha1(const char *path, const uint8_t *sha1)
> -{
> - int ret;
> -
> - ret = setxattr(path, SHA1NAME, sha1, SHA1_DIGEST_SIZE, 0);
> - if (ret < 0)
> - sd_err("fail to set sha1, %s", path);
> -
> - return ret;
> -}
> -
> -static int get_object_path(uint64_t oid, uint32_t epoch, char *path,
> - size_t size)
> -{
> - if (default_exist(oid, 0)) {
> - snprintf(path, PATH_MAX, "%s/%016"PRIx64,
> - md_get_object_dir(oid), oid);
> - } else {
> - get_store_stale_path(oid, epoch, 0, path);
> - if (access(path, F_OK) < 0) {
> - if (errno == ENOENT)
> - return SD_RES_NO_OBJ;
> - return SD_RES_EIO;
> - }
> -
> - }
> -
> - return SD_RES_SUCCESS;
> -}
> -
> -int default_get_hash(uint64_t oid, uint32_t epoch, uint8_t *sha1)
> -{
> - int ret;
> - void *buf;
> - struct siocb iocb = {};
> - uint32_t length;
> - bool is_readonly_obj = oid_is_readonly(oid);
> - char path[PATH_MAX];
> -
> - ret = get_object_path(oid, epoch, path, sizeof(path));
> - if (ret != SD_RES_SUCCESS)
> - return ret;
> -
> - if (is_readonly_obj) {
> - if (get_object_sha1(path, sha1) == 0) {
> - sd_debug("use cached sha1 digest %s",
> - sha1_to_hex(sha1));
> - return SD_RES_SUCCESS;
> - }
> - }
> -
> - length = get_store_objsize(oid);
> - buf = valloc(length);
> - if (buf == NULL)
> - return SD_RES_NO_MEM;
> -
> - iocb.epoch = epoch;
> - iocb.buf = buf;
> - iocb.length = length;
> -
> - ret = default_read_from_path(oid, path, &iocb);
> - if (ret != SD_RES_SUCCESS) {
> - free(buf);
> - return ret;
> - }
> -
> - get_buffer_sha1(buf, length, sha1);
> - free(buf);
> -
> - sd_debug("the message digest of %"PRIx64" at epoch %d is %s", oid,
> - epoch, sha1_to_hex(sha1));
> -
> - if (is_readonly_obj)
> - set_object_sha1(path, sha1);
> -
> - return ret;
> -}
> -
> -int default_purge_obj(void)
> -{
> - uint32_t tgt_epoch = get_latest_epoch();
> -
> - return for_each_object_in_wd(move_object_to_stale_dir, true,
> - &tgt_epoch);
> -}
> -
> -static struct store_driver plain_store = {
> - .name = "plain",
> - .init = default_init,
> - .exist = default_exist,
> - .create_and_write = default_create_and_write,
> - .write = default_write,
> - .read = default_read,
> - .link = default_link,
> - .update_epoch = default_update_epoch,
> - .cleanup = default_cleanup,
> - .format = default_format,
> - .remove_object = default_remove_object,
> - .get_hash = default_get_hash,
> - .purge_obj = default_purge_obj,
> -};
> -
> -add_store_driver(plain_store);
> diff --git a/sheep/store.c b/sheep/store.c
> deleted file mode 100644
> index 8843fb8..0000000
> --- a/sheep/store.c
> +++ /dev/null
> @@ -1,511 +0,0 @@
> -/*
> - * Copyright (C) 2009-2011 Nippon Telegraph and Telephone Corporation.
> - *
> - * This program is free software; you can redistribute it and/or
> - * modify it under the terms of the GNU General Public License version
> - * 2 as published by the Free Software Foundation.
> - *
> - * You should have received a copy of the GNU General Public License
> - * along with this program. If not, see <http://www.gnu.org/licenses/>.
> - */
> -
> -#include "sheep_priv.h"
> -
> -char *obj_path;
> -char *epoch_path;
> -
> -struct store_driver *sd_store;
> -LIST_HEAD(store_drivers);
> -
> -int update_epoch_log(uint32_t epoch, struct sd_node *nodes, size_t nr_nodes)
> -{
> - int ret, len, nodes_len;
> - time_t t;
> - char path[PATH_MAX], *buf;
> -
> - sd_debug("update epoch: %d, %zu", epoch, nr_nodes);
> -
> - /* Piggyback the epoch creation time for 'dog cluster info' */
> - time(&t);
> - nodes_len = nr_nodes * sizeof(struct sd_node);
> - len = nodes_len + sizeof(time_t);
> - buf = xmalloc(len);
> - memcpy(buf, nodes, nodes_len);
> - memcpy(buf + nodes_len, &t, sizeof(time_t));
> -
> - /*
> - * rb field is unused in epoch file, zero-filling it
> - * is good for epoch file recovery because it is unified
> - */
> - for (int i = 0; i < nr_nodes; i++)
> - memset(buf + i * sizeof(struct sd_node)
> - + offsetof(struct sd_node, rb),
> - 0, sizeof(struct rb_node));
> -
> - snprintf(path, sizeof(path), "%s%08u", epoch_path, epoch);
> -
> - ret = atomic_create_and_write(path, buf, len, true);
> -
> - free(buf);
> - return ret;
> -}
> -
> -static int do_epoch_log_read(uint32_t epoch, struct sd_node *nodes, int len,
> - int *nr_nodes, time_t *timestamp)
> -{
> - int fd, ret, buf_len;
> - char path[PATH_MAX];
> - struct stat epoch_stat;
> -
> - snprintf(path, sizeof(path), "%s%08u", epoch_path, epoch);
> - fd = open(path, O_RDONLY);
> - if (fd < 0) {
> - sd_debug("failed to open epoch %"PRIu32" log, %m", epoch);
> - goto err;
> - }
> -
> - memset(&epoch_stat, 0, sizeof(epoch_stat));
> - ret = fstat(fd, &epoch_stat);
> - if (ret < 0) {
> - sd_err("failed to stat epoch %"PRIu32" log, %m", epoch);
> - goto err;
> - }
> -
> - buf_len = epoch_stat.st_size - sizeof(*timestamp);
> - if (buf_len < 0) {
> - sd_err("invalid epoch %"PRIu32" log", epoch);
> - goto err;
> - }
> - if (len < buf_len) {
> - close(fd);
> - return SD_RES_BUFFER_SMALL;
> - }
> -
> - ret = xread(fd, nodes, buf_len);
> - if (ret < 0) {
> - sd_err("failed to read epoch %"PRIu32" log, %m", epoch);
> - goto err;
> - }
> -
> - /* Broken epoch, just ignore */
> - if (ret % sizeof(struct sd_node) != 0) {
> - sd_err("invalid epoch %"PRIu32" log", epoch);
> - goto err;
> - }
> -
> - *nr_nodes = ret / sizeof(struct sd_node);
> -
> - if (timestamp) {
> - ret = xread(fd, timestamp, sizeof(*timestamp));
> - if (ret != sizeof(*timestamp)) {
> - sd_err("invalid epoch %"PRIu32" log", epoch);
> - goto err;
> - }
> - }
> -
> - close(fd);
> - return SD_RES_SUCCESS;
> -err:
> - if (fd >= 0)
> - close(fd);
> - return SD_RES_NO_TAG;
> -}
> -
> -int epoch_log_read(uint32_t epoch, struct sd_node *nodes,
> - int len, int *nr_nodes)
> -{
> - return do_epoch_log_read(epoch, nodes, len, nr_nodes, NULL);
> -}
> -
> -int epoch_log_read_with_timestamp(uint32_t epoch, struct sd_node *nodes,
> - int len, int *nr_nodes, time_t *timestamp)
> -{
> - return do_epoch_log_read(epoch, nodes, len, nr_nodes, timestamp);
> -}
> -
> -uint32_t get_latest_epoch(void)
> -{
> - DIR *dir;
> - struct dirent *d;
> - uint32_t e, epoch = 0;
> - char *p;
> -
> - dir = opendir(epoch_path);
> - if (!dir)
> - panic("failed to get the latest epoch: %m");
> -
> - while ((d = readdir(dir))) {
> - e = strtol(d->d_name, &p, 10);
> - if (d->d_name == p)
> - continue;
> -
> - if (strlen(d->d_name) != 8)
> - continue;
> -
> - if (e > epoch)
> - epoch = e;
> - }
> - closedir(dir);
> -
> - return epoch;
> -}
> -
> -int lock_base_dir(const char *d)
> -{
> -#define LOCK_PATH "/lock"
> - char *lock_path;
> - int ret = 0;
> - int fd, len = strlen(d) + strlen(LOCK_PATH) + 1;
> -
> - lock_path = xzalloc(len);
> - snprintf(lock_path, len, "%s" LOCK_PATH, d);
> -
> - fd = open(lock_path, O_WRONLY|O_CREAT, sd_def_fmode);
> - if (fd < 0) {
> - sd_err("failed to open lock file %s (%m)", lock_path);
> - ret = -1;
> - goto out;
> - }
> -
> - if (lockf(fd, F_TLOCK, 1) < 0) {
> - if (errno == EACCES || errno == EAGAIN)
> - sd_err("another sheep daemon is using %s", d);
> - else
> - sd_err("unable to get base dir lock (%m)");
> - ret = -1;
> - goto out;
> - }
> -
> -out:
> - free(lock_path);
> - return ret;
> -}
> -
> -int init_base_path(const char *d)
> -{
> - if (xmkdir(d, sd_def_dmode) < 0) {
> - sd_err("cannot create the directory %s (%m)", d);
> - return -1;
> - }
> -
> - return 0;
> -}
> -
> -static inline int check_path_len(const char *path)
> -{
> - int len = strlen(path);
> - if (len > PATH_MAX) {
> - sd_err("insanely long object directory %s", path);
> - return -1;
> - }
> -
> - return 0;
> -}
> -
> -static int is_meta_store(const char *path)
> -{
> - char conf[PATH_MAX];
> - char epoch[PATH_MAX];
> -
> - snprintf(conf, PATH_MAX, "%s/config", path);
> - snprintf(epoch, PATH_MAX, "%s/epoch", path);
> - if (!access(conf, R_OK) && !access(epoch, R_OK))
> - return true;
> -
> - return false;
> -}
> -
> -static int init_obj_path(const char *base_path, char *argp)
> -{
> - char *p;
> - int len;
> -
> - if (check_path_len(base_path) < 0)
> - return -1;
> -
> -#define OBJ_PATH "/obj"
> - len = strlen(base_path) + strlen(OBJ_PATH) + 1;
> - obj_path = xzalloc(len);
> - snprintf(obj_path, len, "%s" OBJ_PATH, base_path);
> -
> - /* Eat up the first component */
> - strtok(argp, ",");
> - p = strtok(NULL, ",");
> - if (!p) {
> - /*
> - * If We have only one path, meta-store and object-store share
> - * it. This is helpful to upgrade old sheep cluster to
> - * the MD-enabled.
> - */
> - md_add_disk(obj_path, false);
> - } else {
> - do {
> - if (is_meta_store(p)) {
> - sd_err("%s is meta-store, abort", p);
> - return -1;
> - }
> - md_add_disk(p, false);
> - } while ((p = strtok(NULL, ",")));
> - }
> -
> - if (md_nr_disks() <= 0) {
> - sd_err("There isn't any available disk!");
> - return -1;
> - }
> -
> - return xmkdir(obj_path, sd_def_dmode);
> -}
> -
> -static int init_epoch_path(const char *base_path)
> -{
> -#define EPOCH_PATH "/epoch/"
> - int len = strlen(base_path) + strlen(EPOCH_PATH) + 1;
> - epoch_path = xzalloc(len);
> - snprintf(epoch_path, len, "%s" EPOCH_PATH, base_path);
> -
> - return xmkdir(epoch_path, sd_def_dmode);
> -}
> -
> -/*
> - * If the node is gateway, this function only finds the store driver.
> - * Otherwise, this function initializes the backend store
> - */
> -int init_store_driver(bool is_gateway)
> -{
> - char driver_name[STORE_LEN], *p;
> -
> - pstrcpy(driver_name, sizeof(driver_name), (char *)sys->cinfo.store);
> -
> - p = memchr(driver_name, '\0', STORE_LEN);
> - if (!p) {
> - /*
> - * If the driver name is not NUL terminated we are in deep
> - * trouble, let's get out here.
> - */
> - sd_debug("store name not NUL terminated");
> - return SD_RES_NO_STORE;
> - }
> -
> - /*
> - * The store file might not exist in case this is a new sheep that
> - * never joined a cluster before.
> - */
> - if (p == driver_name)
> - return 0;
> -
> - sd_store = find_store_driver(driver_name);
> - if (!sd_store) {
> - sd_debug("store %s not found", driver_name);
> - return SD_RES_NO_STORE;
> - }
> -
> - if (is_gateway)
> - return SD_RES_SUCCESS;
> -
> - return sd_store->init();
> -}
> -
> -int init_disk_space(const char *base_path)
> -{
> - int ret = SD_RES_SUCCESS;
> - uint64_t space_size = 0, mds;
> - struct statvfs fs;
> -
> - if (sys->gateway_only)
> - goto out;
> -
> - /* We need to init md even we don't need to update sapce */
> - mds = md_init_space();
> -
> - /* If it is restarted */
> - ret = get_node_space(&space_size);
> - if (space_size != 0) {
> - sys->disk_space = space_size;
> - goto out;
> - }
> -
> - /* User has specified the space at startup */
> - if (sys->disk_space) {
> - ret = set_node_space(sys->disk_space);
> - goto out;
> - }
> -
> - if (mds) {
> - sys->disk_space = mds;
> - } else {
> - ret = statvfs(base_path, &fs);
> - if (ret < 0) {
> - sd_debug("get disk space failed %m");
> - ret = SD_RES_EIO;
> - goto out;
> - }
> - sys->disk_space = (uint64_t)fs.f_frsize * fs.f_bavail;
> - }
> -
> - ret = set_node_space(sys->disk_space);
> -out:
> - sd_debug("disk free space is %" PRIu64, sys->disk_space);
> - return ret;
> -}
> -
> -/* Initialize all the global pathnames used internally */
> -int init_global_pathnames(const char *d, char *argp)
> -{
> - int ret;
> -
> - ret = init_obj_path(d, argp);
> - if (ret)
> - return ret;
> -
> - ret = init_epoch_path(d);
> - if (ret)
> - return ret;
> -
> - init_config_path(d);
> -
> - return 0;
> -}
> -
> -/* Write data to both local object cache (if enabled) and backends */
> -int sd_write_object(uint64_t oid, char *data, unsigned int datalen,
> - uint64_t offset, bool create)
> -{
> - struct sd_req hdr;
> - int ret;
> -
> - if (sys->enable_object_cache && object_is_cached(oid)) {
> - ret = object_cache_write(oid, data, datalen, offset,
> - create);
> - if (ret == SD_RES_NO_CACHE)
> - goto forward_write;
> -
> - if (ret != 0) {
> - sd_err("write cache failed %" PRIx64 " %" PRIx32, oid,
> - ret);
> - return ret;
> - }
> - }
> -
> -forward_write:
> - if (create)
> - sd_init_req(&hdr, SD_OP_CREATE_AND_WRITE_OBJ);
> - else
> - sd_init_req(&hdr, SD_OP_WRITE_OBJ);
> - hdr.flags = SD_FLAG_CMD_WRITE;
> - hdr.data_length = datalen;
> -
> - hdr.obj.oid = oid;
> - hdr.obj.offset = offset;
> -
> - ret = exec_local_req(&hdr, data);
> - if (ret != SD_RES_SUCCESS)
> - sd_err("failed to write object %" PRIx64 ", %s", oid,
> - sd_strerror(ret));
> -
> - return ret;
> -}
> -
> -int read_backend_object(uint64_t oid, char *data, unsigned int datalen,
> - uint64_t offset)
> -{
> - struct sd_req hdr;
> - int ret;
> -
> - sd_init_req(&hdr, SD_OP_READ_OBJ);
> - hdr.data_length = datalen;
> - hdr.obj.oid = oid;
> - hdr.obj.offset = offset;
> -
> - ret = exec_local_req(&hdr, data);
> - if (ret != SD_RES_SUCCESS)
> - sd_err("failed to read object %" PRIx64 ", %s", oid,
> - sd_strerror(ret));
> - return ret;
> -}
> -
> -/*
> - * Read data firstly from local object cache(if enabled), if fail,
> - * try read backends
> - */
> -int sd_read_object(uint64_t oid, char *data, unsigned int datalen,
> - uint64_t offset)
> -{
> - int ret;
> -
> - if (sys->enable_object_cache && object_is_cached(oid)) {
> - ret = object_cache_read(oid, data, datalen, offset);
> - if (ret != SD_RES_SUCCESS) {
> - sd_err("try forward read %" PRIx64 " %s", oid,
> - sd_strerror(ret));
> - goto forward_read;
> - }
> - return ret;
> - }
> -
> -forward_read:
> - return read_backend_object(oid, data, datalen, offset);
> -}
> -
> -int sd_remove_object(uint64_t oid)
> -{
> - struct sd_req hdr;
> - int ret;
> -
> - if (sys->enable_object_cache && object_is_cached(oid)) {
> - ret = object_cache_remove(oid);
> - if (ret != SD_RES_SUCCESS)
> - return ret;
> - }
> -
> - sd_init_req(&hdr, SD_OP_REMOVE_OBJ);
> - hdr.obj.oid = oid;
> -
> - ret = exec_local_req(&hdr, NULL);
> - if (ret != SD_RES_SUCCESS)
> - sd_err("failed to remove object %" PRIx64 ", %s", oid,
> - sd_strerror(ret));
> -
> - return ret;
> -}
> -
> -int sd_discard_object(uint64_t oid)
> -{
> - int ret;
> - struct sd_req hdr;
> -
> - sd_init_req(&hdr, SD_OP_DISCARD_OBJ);
> - hdr.obj.oid = oid;
> -
> - ret = exec_local_req(&hdr, NULL);
> - if (ret != SD_RES_SUCCESS)
> - sd_err("Failed to discard data obj %"PRIu64" %s", oid,
> - sd_strerror(ret));
> -
> - return ret;
> -}
> -
> -int sd_dec_object_refcnt(uint64_t data_oid, uint32_t generation,
> - uint32_t refcnt)
> -{
> - struct sd_req hdr;
> - int ret;
> - uint64_t ledger_oid = data_oid_to_ledger_oid(data_oid);
> -
> - sd_debug("%"PRIx64", %" PRId32 ", %" PRId32,
> - data_oid, generation, refcnt);
> -
> - if (generation == 0 && refcnt == 0)
> - return sd_remove_object(data_oid);
> -
> - sd_init_req(&hdr, SD_OP_DECREF_OBJ);
> - hdr.ref.oid = ledger_oid;
> - hdr.ref.generation = generation;
> - hdr.ref.count = refcnt;
> -
> - ret = exec_local_req(&hdr, NULL);
> - if (ret != SD_RES_SUCCESS)
> - sd_err("failed to decrement reference %" PRIx64 ", %s",
> - ledger_oid, sd_strerror(ret));
> -
> - return ret;
> -}
> diff --git a/sheep/store/common.c b/sheep/store/common.c
> new file mode 100644
> index 0000000..8843fb8
> --- /dev/null
> +++ b/sheep/store/common.c
> @@ -0,0 +1,511 @@
> +/*
> + * Copyright (C) 2009-2011 Nippon Telegraph and Telephone Corporation.
> + *
> + * This program is free software; you can redistribute it and/or
> + * modify it under the terms of the GNU General Public License version
> + * 2 as published by the Free Software Foundation.
> + *
> + * You should have received a copy of the GNU General Public License
> + * along with this program. If not, see <http://www.gnu.org/licenses/>.
> + */
> +
> +#include "sheep_priv.h"
> +
> +char *obj_path;
> +char *epoch_path;
> +
> +struct store_driver *sd_store;
> +LIST_HEAD(store_drivers);
> +
> +int update_epoch_log(uint32_t epoch, struct sd_node *nodes, size_t nr_nodes)
> +{
> + int ret, len, nodes_len;
> + time_t t;
> + char path[PATH_MAX], *buf;
> +
> + sd_debug("update epoch: %d, %zu", epoch, nr_nodes);
> +
> + /* Piggyback the epoch creation time for 'dog cluster info' */
> + time(&t);
> + nodes_len = nr_nodes * sizeof(struct sd_node);
> + len = nodes_len + sizeof(time_t);
> + buf = xmalloc(len);
> + memcpy(buf, nodes, nodes_len);
> + memcpy(buf + nodes_len, &t, sizeof(time_t));
> +
> + /*
> + * rb field is unused in epoch file, zero-filling it
> + * is good for epoch file recovery because it is unified
> + */
> + for (int i = 0; i < nr_nodes; i++)
> + memset(buf + i * sizeof(struct sd_node)
> + + offsetof(struct sd_node, rb),
> + 0, sizeof(struct rb_node));
> +
> + snprintf(path, sizeof(path), "%s%08u", epoch_path, epoch);
> +
> + ret = atomic_create_and_write(path, buf, len, true);
> +
> + free(buf);
> + return ret;
> +}
> +
> +static int do_epoch_log_read(uint32_t epoch, struct sd_node *nodes, int len,
> + int *nr_nodes, time_t *timestamp)
> +{
> + int fd, ret, buf_len;
> + char path[PATH_MAX];
> + struct stat epoch_stat;
> +
> + snprintf(path, sizeof(path), "%s%08u", epoch_path, epoch);
> + fd = open(path, O_RDONLY);
> + if (fd < 0) {
> + sd_debug("failed to open epoch %"PRIu32" log, %m", epoch);
> + goto err;
> + }
> +
> + memset(&epoch_stat, 0, sizeof(epoch_stat));
> + ret = fstat(fd, &epoch_stat);
> + if (ret < 0) {
> + sd_err("failed to stat epoch %"PRIu32" log, %m", epoch);
> + goto err;
> + }
> +
> + buf_len = epoch_stat.st_size - sizeof(*timestamp);
> + if (buf_len < 0) {
> + sd_err("invalid epoch %"PRIu32" log", epoch);
> + goto err;
> + }
> + if (len < buf_len) {
> + close(fd);
> + return SD_RES_BUFFER_SMALL;
> + }
> +
> + ret = xread(fd, nodes, buf_len);
> + if (ret < 0) {
> + sd_err("failed to read epoch %"PRIu32" log, %m", epoch);
> + goto err;
> + }
> +
> + /* Broken epoch, just ignore */
> + if (ret % sizeof(struct sd_node) != 0) {
> + sd_err("invalid epoch %"PRIu32" log", epoch);
> + goto err;
> + }
> +
> + *nr_nodes = ret / sizeof(struct sd_node);
> +
> + if (timestamp) {
> + ret = xread(fd, timestamp, sizeof(*timestamp));
> + if (ret != sizeof(*timestamp)) {
> + sd_err("invalid epoch %"PRIu32" log", epoch);
> + goto err;
> + }
> + }
> +
> + close(fd);
> + return SD_RES_SUCCESS;
> +err:
> + if (fd >= 0)
> + close(fd);
> + return SD_RES_NO_TAG;
> +}
> +
> +int epoch_log_read(uint32_t epoch, struct sd_node *nodes,
> + int len, int *nr_nodes)
> +{
> + return do_epoch_log_read(epoch, nodes, len, nr_nodes, NULL);
> +}
> +
> +int epoch_log_read_with_timestamp(uint32_t epoch, struct sd_node *nodes,
> + int len, int *nr_nodes, time_t *timestamp)
> +{
> + return do_epoch_log_read(epoch, nodes, len, nr_nodes, timestamp);
> +}
> +
> +uint32_t get_latest_epoch(void)
> +{
> + DIR *dir;
> + struct dirent *d;
> + uint32_t e, epoch = 0;
> + char *p;
> +
> + dir = opendir(epoch_path);
> + if (!dir)
> + panic("failed to get the latest epoch: %m");
> +
> + while ((d = readdir(dir))) {
> + e = strtol(d->d_name, &p, 10);
> + if (d->d_name == p)
> + continue;
> +
> + if (strlen(d->d_name) != 8)
> + continue;
> +
> + if (e > epoch)
> + epoch = e;
> + }
> + closedir(dir);
> +
> + return epoch;
> +}
> +
> +int lock_base_dir(const char *d)
> +{
> +#define LOCK_PATH "/lock"
> + char *lock_path;
> + int ret = 0;
> + int fd, len = strlen(d) + strlen(LOCK_PATH) + 1;
> +
> + lock_path = xzalloc(len);
> + snprintf(lock_path, len, "%s" LOCK_PATH, d);
> +
> + fd = open(lock_path, O_WRONLY|O_CREAT, sd_def_fmode);
> + if (fd < 0) {
> + sd_err("failed to open lock file %s (%m)", lock_path);
> + ret = -1;
> + goto out;
> + }
> +
> + if (lockf(fd, F_TLOCK, 1) < 0) {
> + if (errno == EACCES || errno == EAGAIN)
> + sd_err("another sheep daemon is using %s", d);
> + else
> + sd_err("unable to get base dir lock (%m)");
> + ret = -1;
> + goto out;
> + }
> +
> +out:
> + free(lock_path);
> + return ret;
> +}
> +
> +int init_base_path(const char *d)
> +{
> + if (xmkdir(d, sd_def_dmode) < 0) {
> + sd_err("cannot create the directory %s (%m)", d);
> + return -1;
> + }
> +
> + return 0;
> +}
> +
> +static inline int check_path_len(const char *path)
> +{
> + int len = strlen(path);
> + if (len > PATH_MAX) {
> + sd_err("insanely long object directory %s", path);
> + return -1;
> + }
> +
> + return 0;
> +}
> +
> +static int is_meta_store(const char *path)
> +{
> + char conf[PATH_MAX];
> + char epoch[PATH_MAX];
> +
> + snprintf(conf, PATH_MAX, "%s/config", path);
> + snprintf(epoch, PATH_MAX, "%s/epoch", path);
> + if (!access(conf, R_OK) && !access(epoch, R_OK))
> + return true;
> +
> + return false;
> +}
> +
> +static int init_obj_path(const char *base_path, char *argp)
> +{
> + char *p;
> + int len;
> +
> + if (check_path_len(base_path) < 0)
> + return -1;
> +
> +#define OBJ_PATH "/obj"
> + len = strlen(base_path) + strlen(OBJ_PATH) + 1;
> + obj_path = xzalloc(len);
> + snprintf(obj_path, len, "%s" OBJ_PATH, base_path);
> +
> + /* Eat up the first component */
> + strtok(argp, ",");
> + p = strtok(NULL, ",");
> + if (!p) {
> + /*
> + * If We have only one path, meta-store and object-store share
> + * it. This is helpful to upgrade old sheep cluster to
> + * the MD-enabled.
> + */
> + md_add_disk(obj_path, false);
> + } else {
> + do {
> + if (is_meta_store(p)) {
> + sd_err("%s is meta-store, abort", p);
> + return -1;
> + }
> + md_add_disk(p, false);
> + } while ((p = strtok(NULL, ",")));
> + }
> +
> + if (md_nr_disks() <= 0) {
> + sd_err("There isn't any available disk!");
> + return -1;
> + }
> +
> + return xmkdir(obj_path, sd_def_dmode);
> +}
> +
> +static int init_epoch_path(const char *base_path)
> +{
> +#define EPOCH_PATH "/epoch/"
> + int len = strlen(base_path) + strlen(EPOCH_PATH) + 1;
> + epoch_path = xzalloc(len);
> + snprintf(epoch_path, len, "%s" EPOCH_PATH, base_path);
> +
> + return xmkdir(epoch_path, sd_def_dmode);
> +}
> +
> +/*
> + * If the node is gateway, this function only finds the store driver.
> + * Otherwise, this function initializes the backend store
> + */
> +int init_store_driver(bool is_gateway)
> +{
> + char driver_name[STORE_LEN], *p;
> +
> + pstrcpy(driver_name, sizeof(driver_name), (char *)sys->cinfo.store);
> +
> + p = memchr(driver_name, '\0', STORE_LEN);
> + if (!p) {
> + /*
> + * If the driver name is not NUL terminated we are in deep
> + * trouble, let's get out here.
> + */
> + sd_debug("store name not NUL terminated");
> + return SD_RES_NO_STORE;
> + }
> +
> + /*
> + * The store file might not exist in case this is a new sheep that
> + * never joined a cluster before.
> + */
> + if (p == driver_name)
> + return 0;
> +
> + sd_store = find_store_driver(driver_name);
> + if (!sd_store) {
> + sd_debug("store %s not found", driver_name);
> + return SD_RES_NO_STORE;
> + }
> +
> + if (is_gateway)
> + return SD_RES_SUCCESS;
> +
> + return sd_store->init();
> +}
> +
> +int init_disk_space(const char *base_path)
> +{
> + int ret = SD_RES_SUCCESS;
> + uint64_t space_size = 0, mds;
> + struct statvfs fs;
> +
> + if (sys->gateway_only)
> + goto out;
> +
> + /* We need to init md even we don't need to update sapce */
> + mds = md_init_space();
> +
> + /* If it is restarted */
> + ret = get_node_space(&space_size);
> + if (space_size != 0) {
> + sys->disk_space = space_size;
> + goto out;
> + }
> +
> + /* User has specified the space at startup */
> + if (sys->disk_space) {
> + ret = set_node_space(sys->disk_space);
> + goto out;
> + }
> +
> + if (mds) {
> + sys->disk_space = mds;
> + } else {
> + ret = statvfs(base_path, &fs);
> + if (ret < 0) {
> + sd_debug("get disk space failed %m");
> + ret = SD_RES_EIO;
> + goto out;
> + }
> + sys->disk_space = (uint64_t)fs.f_frsize * fs.f_bavail;
> + }
> +
> + ret = set_node_space(sys->disk_space);
> +out:
> + sd_debug("disk free space is %" PRIu64, sys->disk_space);
> + return ret;
> +}
> +
> +/* Initialize all the global pathnames used internally */
> +int init_global_pathnames(const char *d, char *argp)
> +{
> + int ret;
> +
> + ret = init_obj_path(d, argp);
> + if (ret)
> + return ret;
> +
> + ret = init_epoch_path(d);
> + if (ret)
> + return ret;
> +
> + init_config_path(d);
> +
> + return 0;
> +}
> +
> +/* Write data to both local object cache (if enabled) and backends */
> +int sd_write_object(uint64_t oid, char *data, unsigned int datalen,
> + uint64_t offset, bool create)
> +{
> + struct sd_req hdr;
> + int ret;
> +
> + if (sys->enable_object_cache && object_is_cached(oid)) {
> + ret = object_cache_write(oid, data, datalen, offset,
> + create);
> + if (ret == SD_RES_NO_CACHE)
> + goto forward_write;
> +
> + if (ret != 0) {
> + sd_err("write cache failed %" PRIx64 " %" PRIx32, oid,
> + ret);
> + return ret;
> + }
> + }
> +
> +forward_write:
> + if (create)
> + sd_init_req(&hdr, SD_OP_CREATE_AND_WRITE_OBJ);
> + else
> + sd_init_req(&hdr, SD_OP_WRITE_OBJ);
> + hdr.flags = SD_FLAG_CMD_WRITE;
> + hdr.data_length = datalen;
> +
> + hdr.obj.oid = oid;
> + hdr.obj.offset = offset;
> +
> + ret = exec_local_req(&hdr, data);
> + if (ret != SD_RES_SUCCESS)
> + sd_err("failed to write object %" PRIx64 ", %s", oid,
> + sd_strerror(ret));
> +
> + return ret;
> +}
> +
> +int read_backend_object(uint64_t oid, char *data, unsigned int datalen,
> + uint64_t offset)
> +{
> + struct sd_req hdr;
> + int ret;
> +
> + sd_init_req(&hdr, SD_OP_READ_OBJ);
> + hdr.data_length = datalen;
> + hdr.obj.oid = oid;
> + hdr.obj.offset = offset;
> +
> + ret = exec_local_req(&hdr, data);
> + if (ret != SD_RES_SUCCESS)
> + sd_err("failed to read object %" PRIx64 ", %s", oid,
> + sd_strerror(ret));
> + return ret;
> +}
> +
> +/*
> + * Read data firstly from local object cache(if enabled), if fail,
> + * try read backends
> + */
> +int sd_read_object(uint64_t oid, char *data, unsigned int datalen,
> + uint64_t offset)
> +{
> + int ret;
> +
> + if (sys->enable_object_cache && object_is_cached(oid)) {
> + ret = object_cache_read(oid, data, datalen, offset);
> + if (ret != SD_RES_SUCCESS) {
> + sd_err("try forward read %" PRIx64 " %s", oid,
> + sd_strerror(ret));
> + goto forward_read;
> + }
> + return ret;
> + }
> +
> +forward_read:
> + return read_backend_object(oid, data, datalen, offset);
> +}
> +
> +int sd_remove_object(uint64_t oid)
> +{
> + struct sd_req hdr;
> + int ret;
> +
> + if (sys->enable_object_cache && object_is_cached(oid)) {
> + ret = object_cache_remove(oid);
> + if (ret != SD_RES_SUCCESS)
> + return ret;
> + }
> +
> + sd_init_req(&hdr, SD_OP_REMOVE_OBJ);
> + hdr.obj.oid = oid;
> +
> + ret = exec_local_req(&hdr, NULL);
> + if (ret != SD_RES_SUCCESS)
> + sd_err("failed to remove object %" PRIx64 ", %s", oid,
> + sd_strerror(ret));
> +
> + return ret;
> +}
> +
> +int sd_discard_object(uint64_t oid)
> +{
> + int ret;
> + struct sd_req hdr;
> +
> + sd_init_req(&hdr, SD_OP_DISCARD_OBJ);
> + hdr.obj.oid = oid;
> +
> + ret = exec_local_req(&hdr, NULL);
> + if (ret != SD_RES_SUCCESS)
> + sd_err("Failed to discard data obj %"PRIu64" %s", oid,
> + sd_strerror(ret));
> +
> + return ret;
> +}
> +
> +int sd_dec_object_refcnt(uint64_t data_oid, uint32_t generation,
> + uint32_t refcnt)
> +{
> + struct sd_req hdr;
> + int ret;
> + uint64_t ledger_oid = data_oid_to_ledger_oid(data_oid);
> +
> + sd_debug("%"PRIx64", %" PRId32 ", %" PRId32,
> + data_oid, generation, refcnt);
> +
> + if (generation == 0 && refcnt == 0)
> + return sd_remove_object(data_oid);
> +
> + sd_init_req(&hdr, SD_OP_DECREF_OBJ);
> + hdr.ref.oid = ledger_oid;
> + hdr.ref.generation = generation;
> + hdr.ref.count = refcnt;
> +
> + ret = exec_local_req(&hdr, NULL);
> + if (ret != SD_RES_SUCCESS)
> + sd_err("failed to decrement reference %" PRIx64 ", %s",
> + ledger_oid, sd_strerror(ret));
> +
> + return ret;
> +}
> diff --git a/sheep/store/md.c b/sheep/store/md.c
> new file mode 100644
> index 0000000..87ab759
> --- /dev/null
> +++ b/sheep/store/md.c
> @@ -0,0 +1,878 @@
> +/*
> + * Copyright (C) 2013 Taobao Inc.
> + *
> + * Liu Yuan <namei.unix at gmail.com>
> + *
> + * This program is free software; you can redistribute it and/or
> + * modify it under the terms of the GNU General Public License version
> + * 2 as published by the Free Software Foundation.
> + *
> + * You should have received a copy of the GNU General Public License
> + * along with this program. If not, see <http://www.gnu.org/licenses/>.
> + */
> +
> +#include "sheep_priv.h"
> +
> +#define MD_VDISK_SIZE ((uint64_t)1*1024*1024*1024) /* 1G */
> +
> +#define NONE_EXIST_PATH "/all/disks/are/broken/,ps/ノ厂経7/!"
why NONE_EXIST_PATH is changed? And I don't think imbed japanese in to the assic
code is good idea.
By the way, please use git format-patch to generate a series of patches and send
them by git send-email to get a chain of patches under a single topic. For now
your patches are split into different topics on my Mutt client.
Thanks,
Yuan
More information about the sheepdog
mailing list