features/shard: Introducing sharding translator

Based on the high-level design by Anand V. Avati which can be found @
https://gist.github.com/avati/af04f1030dcf52e16535#sharding-xlator-stripe-20

Still to-do:
        * complete implementation of inode write fops - [f]truncate,
          zerofill, fallocate, discard
        * introduce transaction mechanism in inode write fops
        * complete readv
        * Handle open with O_TRUNC
        * Handle unlinking of all shards during unlink/rename
        * Compute total ia_size and ia_blocks in lookup, readdirp, etc
        * wind fsync/flush on all shards

        Note: Most of the items above are related. Once we come up
        with a clean way to determine the last shard/shard count for
        a file/file size and the mgmt of sparse regions of the file,
        implementing them becomes trivial.

Change-Id: Id871379b53a4a916e4baa2e06f197dd8c0043b0f
BUG: 1200082
Signed-off-by: Krutika Dhananjay <kdhananj@redhat.com>
Reviewed-on: http://review.gluster.org/9841
Tested-by: Gluster Build System <jenkins@build.gluster.com>
Reviewed-by: Vijay Bellur <vbellur@redhat.com>

1 files changed, 118 insertions, 0 deletions

diff --git a/xlators/features/shard/src/shard.h b/xlators/features/shard/src/shard.h
new file mode 100644
index 00000000000..03d881079e6
--- /dev/null
+++ b/xlators/features/shard/src/shard.h
@@ -0,0 +1,118 @@
+/*
+  Copyright (c) 2015 Red Hat, Inc. <http://www.redhat.com>
+  This file is part of GlusterFS.
+
+  This file is licensed to you under your choice of the GNU Lesser
+  General Public License, version 3 or any later version (LGPLv3 or
+  later), or the GNU General Public License, version 2 (GPLv2), in all
+  cases as published by the Free Software Foundation.
+*/
+
+
+#ifndef __SHARD_H__
+#define __SHARD_H__
+
+#ifndef _CONFIG_H
+#define _CONFIG_H
+#include "config.h"
+#endif
+
+#include "xlator.h"
+#include "compat-errno.h"
+
+#define GF_SHARD_DIR ".shard"
+#define SHARD_MIN_BLOCK_SIZE  (128*GF_UNIT_KB)
+#define GF_XATTR_SHARD_BLOCK_SIZE "trusted.glusterfs.shard.block-size"
+#define SHARD_ROOT_GFID "be318638-e8a0-4c6d-977d-7a937aa84806"
+#define SHARD_INODE_LRU_LIMIT 4096
+
+#define get_lowest_block(off, shard_size) (off / shard_size)
+#define get_highest_block(off, len, shard_size) ((off+len-1) / shard_size)
+
+#define SHARD_ENTRY_FOP_CHECK(loc, op_errno, label) do {               \
+        if ((loc->name && !strcmp (GF_SHARD_DIR, loc->name)) &&        \
+            (((loc->parent) &&                                          \
+            __is_root_gfid (loc->parent->gfid)) ||                     \
+            __is_root_gfid (loc->pargfid))) {                           \
+                    op_errno = EPERM;                                  \
+                    goto label;                                        \
+        }                                                              \
+                                                                       \
+        if ((loc->parent &&                                            \
+            __is_shard_dir (loc->parent->gfid)) ||                     \
+            __is_shard_dir (loc->pargfid)) {                           \
+                    op_errno = EPERM;                                  \
+                    goto label;                                        \
+        }                                                              \
+} while (0)
+
+#define SHARD_INODE_OP_CHECK(gfid, err, label) do {                    \
+        if (__is_shard_dir(gfid)) {                                    \
+                err = EPERM;                                           \
+                goto label;                                            \
+        }                                                              \
+} while (0)
+
+#define SHARD_STACK_UNWIND(fop, frame, params ...) do {       \
+        shard_local_t *__local = NULL;                         \
+        if (frame) {                                           \
+                __local = frame->local;                        \
+                frame->local = NULL;                           \
+        }                                                      \
+        STACK_UNWIND_STRICT (fop, frame, params);              \
+        if (__local) {                                         \
+                shard_local_wipe (__local);                    \
+                mem_put (__local);                             \
+        }                                                      \
+} while (0)                                                    \
+
+typedef struct shard_priv {
+        uint64_t block_size;
+        uuid_t dot_shard_gfid;
+        inode_table_t *inode_table;
+        inode_t *dot_shard_inode;
+} shard_priv_t;
+
+typedef struct {
+        loc_t *loc;
+        short type;
+        char *domain;
+} shard_lock_t;
+
+typedef struct shard_local {
+        int op_ret;
+        int op_errno;
+        int first_block;
+        int last_block;
+        int num_blocks;
+        int call_count;
+        int eexist_count;
+        int xflag;
+        int count;
+        uint32_t flags;
+        uint64_t block_size;
+        off_t offset;
+        size_t total_size;
+        uuid_t shard_gfid;
+        loc_t loc;
+        loc_t dot_shard_loc;
+        fd_t *fd;
+        dict_t *xattr_req;
+        inode_t **inode_list;
+        struct iovec *vector;
+        struct iobref *iobref;
+        struct {
+                int lock_count;
+                fop_inodelk_cbk_t inodelk_cbk;
+                shard_lock_t *shard_lock;
+        } lock;
+} shard_local_t;
+
+typedef struct shard_inode_ctx {
+        uint32_t rdev;
+        uint64_t block_size; /* The block size with which this inode is
+                                sharded */
+        mode_t mode;
+} shard_inode_ctx_t;
+
+#endif /* __SHARD_H__ */