summaryrefslogtreecommitdiffstats
path: root/libglusterfs
diff options
context:
space:
mode:
authorAnand Avati <avati@gluster.com>2010-06-07 12:37:34 +0000
committerAnand V. Avati <avati@dev.gluster.com>2010-06-07 11:58:50 -0700
commit79241696fbdebe2583298f12cbaee068ce60c655 (patch)
tree42e60d351e328fa34f17242c6c3359a8c01e8fa3 /libglusterfs
parentc4ebd25a176d6d51d702b1009e261c3c27237a48 (diff)
dynamic volume changes for graph replacement
Signed-off-by: Anand V. Avati <avati@blackhole.gluster.com> Signed-off-by: Anand V. Avati <avati@dev.gluster.com> BUG: 971 (dynamic volume management) URL: http://bugs.gluster.com/cgi-bin/bugzilla3/show_bug.cgi?id=971
Diffstat (limited to 'libglusterfs')
-rw-r--r--libglusterfs/src/Makefile.am18
-rw-r--r--libglusterfs/src/common-utils.c83
-rw-r--r--libglusterfs/src/common-utils.h2
-rw-r--r--libglusterfs/src/fd.c172
-rw-r--r--libglusterfs/src/fd.h41
-rw-r--r--libglusterfs/src/globals.c70
-rw-r--r--libglusterfs/src/globals.h3
-rw-r--r--libglusterfs/src/glusterfs.h101
-rw-r--r--libglusterfs/src/graph.c499
-rw-r--r--libglusterfs/src/graph.l (renamed from libglusterfs/src/spec.l)35
-rw-r--r--libglusterfs/src/graph.y651
-rw-r--r--libglusterfs/src/inode.c17
-rw-r--r--libglusterfs/src/latency.c2
-rw-r--r--libglusterfs/src/md5.c310
-rw-r--r--libglusterfs/src/md5.h78
-rw-r--r--libglusterfs/src/mem-types.h1
-rw-r--r--libglusterfs/src/spec.y626
-rw-r--r--libglusterfs/src/stack.h8
-rw-r--r--libglusterfs/src/statedump.c152
-rw-r--r--libglusterfs/src/xlator.c136
-rw-r--r--libglusterfs/src/xlator.h18
21 files changed, 1610 insertions, 1413 deletions
diff --git a/libglusterfs/src/Makefile.am b/libglusterfs/src/Makefile.am
index acca3f04a01..79574488332 100644
--- a/libglusterfs/src/Makefile.am
+++ b/libglusterfs/src/Makefile.am
@@ -1,21 +1,21 @@
libglusterfs_la_CFLAGS = -fPIC -Wall -g -shared -nostartfiles $(GF_CFLAGS) $(GF_DARWIN_LIBGLUSTERFS_CFLAGS)
-libglusterfs_la_CPPFLAGS = -D_FILE_OFFSET_BITS=64 -D__USE_FILE_OFFSET64 -D_GNU_SOURCE -DXLATORDIR=\"$(libdir)/glusterfs/$(PACKAGE_VERSION)/xlator\" -D$(GF_HOST_OS) -DLIBDIR=\"$(libdir)/glusterfs/$(PACKAGE_VERSION)/auth\" -I$(CONTRIBDIR)/rbtree -DSCHEDULERDIR=\"$(libdir)/glusterfs/$(PACKAGE_VERSION)/scheduler\"
+libglusterfs_la_CPPFLAGS = -D_FILE_OFFSET_BITS=64 -D__USE_FILE_OFFSET64 -D_GNU_SOURCE -DXLATORDIR=\"$(libdir)/glusterfs/$(PACKAGE_VERSION)/xlator\" -D$(GF_HOST_OS) -DLIBDIR=\"$(libdir)/glusterfs/$(PACKAGE_VERSION)/auth\" -I$(CONTRIBDIR)/rbtree -DSCHEDULERDIR=\"$(libdir)/glusterfs/$(PACKAGE_VERSION)/scheduler\" -I$(CONTRIBDIR)/md5
libglusterfs_la_LIBADD = @LEXLIB@
lib_LTLIBRARIES = libglusterfs.la
-libglusterfs_la_SOURCES = dict.c spec.lex.c y.tab.c xlator.c logging.c hashfn.c defaults.c common-utils.c timer.c inode.c call-stub.c compat.c fd.c compat-errno.c event.c mem-pool.c gf-dirent.c syscall.c iobuf.c globals.c statedump.c stack.c checksum.c md5.c $(CONTRIBDIR)/rbtree/rb.c rbthash.c latency.c
+libglusterfs_la_SOURCES = dict.c graph.lex.c y.tab.c xlator.c logging.c hashfn.c defaults.c common-utils.c timer.c inode.c call-stub.c compat.c fd.c compat-errno.c event.c mem-pool.c gf-dirent.c syscall.c iobuf.c globals.c statedump.c stack.c checksum.c $(CONTRIBDIR)/md5/md5.c $(CONTRIBDIR)/rbtree/rb.c rbthash.c latency.c graph.c
-noinst_HEADERS = common-utils.h defaults.h dict.h glusterfs.h hashfn.h logging.h xlator.h stack.h timer.h list.h inode.h call-stub.h compat.h fd.h revision.h compat-errno.h event.h mem-pool.h byte-order.h gf-dirent.h locking.h syscall.h iobuf.h globals.h statedump.h checksum.h md5.h $(CONTRIBDIR)/rbtree/rb.h rbthash.h iatt.h latency.h
+noinst_HEADERS = common-utils.h defaults.h dict.h glusterfs.h hashfn.h logging.h xlator.h stack.h timer.h list.h inode.h call-stub.h compat.h fd.h revision.h compat-errno.h event.h mem-pool.h byte-order.h gf-dirent.h locking.h syscall.h iobuf.h globals.h statedump.h checksum.h $(CONTRIBDIR)/md5/md5.h $(CONTRIBDIR)/rbtree/rb.h rbthash.h iatt.h latency.h
-EXTRA_DIST = spec.l spec.y
+EXTRA_DIST = graph.l graph.y
-spec.lex.c: spec.l y.tab.h
- $(LEX) -t $(srcdir)/spec.l > $@
+graph.lex.c: graph.l y.tab.h
+ $(LEX) -t $(srcdir)/graph.l > $@
-y.tab.c y.tab.h: spec.y
- $(YACC) -d $(srcdir)/spec.y
+y.tab.c y.tab.h: graph.y
+ $(YACC) -d $(srcdir)/graph.y
-CLEANFILES = spec.lex.c y.tab.c y.tab.h
+CLEANFILES = graph.lex.c y.tab.c y.tab.h
diff --git a/libglusterfs/src/common-utils.c b/libglusterfs/src/common-utils.c
index c93dcc41d15..694a9040c95 100644
--- a/libglusterfs/src/common-utils.c
+++ b/libglusterfs/src/common-utils.c
@@ -48,7 +48,6 @@
typedef int32_t (*rw_op_t)(int32_t fd, char *buf, int32_t size);
typedef int32_t (*rwv_op_t)(int32_t fd, const struct iovec *buf, int32_t size);
-static glusterfs_ctx_t *gf_global_ctx;
struct dnscache6 {
@@ -179,85 +178,6 @@ err:
return -1;
}
-char *gf_fop_list[GF_FOP_MAXVALUE];
-char *gf_mgmt_list[GF_MGMT_MAXVALUE];
-
-void
-gf_global_variable_init()
-{
- gf_fop_list[GF_FOP_NULL] = "NULL";
- gf_fop_list[GF_FOP_STAT] = "STAT";
- gf_fop_list[GF_FOP_READLINK] = "READLINK";
- gf_fop_list[GF_FOP_MKNOD] = "MKNOD";
- gf_fop_list[GF_FOP_MKDIR] = "MKDIR";
- gf_fop_list[GF_FOP_UNLINK] = "UNLINK";
- gf_fop_list[GF_FOP_RMDIR] = "RMDIR";
- gf_fop_list[GF_FOP_SYMLINK] = "SYMLINK";
- gf_fop_list[GF_FOP_RENAME] = "RENAME";
- gf_fop_list[GF_FOP_LINK] = "LINK";
- gf_fop_list[GF_FOP_TRUNCATE] = "TRUNCATE";
- gf_fop_list[GF_FOP_OPEN] = "OPEN";
- gf_fop_list[GF_FOP_READ] = "READ";
- gf_fop_list[GF_FOP_WRITE] = "WRITE";
- gf_fop_list[GF_FOP_STATFS] = "STATFS";
- gf_fop_list[GF_FOP_FLUSH] = "FLUSH";
- gf_fop_list[GF_FOP_FSYNC] = "FSYNC";
- gf_fop_list[GF_FOP_SETXATTR] = "SETXATTR";
- gf_fop_list[GF_FOP_GETXATTR] = "GETXATTR";
- gf_fop_list[GF_FOP_REMOVEXATTR] = "REMOVEXATTR";
- gf_fop_list[GF_FOP_OPENDIR] = "OPENDIR";
- gf_fop_list[GF_FOP_FSYNCDIR] = "FSYNCDIR";
- gf_fop_list[GF_FOP_ACCESS] = "ACCESS";
- gf_fop_list[GF_FOP_CREATE] = "CREATE";
- gf_fop_list[GF_FOP_FTRUNCATE] = "FTRUNCATE";
- gf_fop_list[GF_FOP_FSTAT] = "FSTAT";
- gf_fop_list[GF_FOP_LK] = "LK";
- gf_fop_list[GF_FOP_LOOKUP] = "LOOKUP";
- gf_fop_list[GF_FOP_READDIR] = "READDIR";
- gf_fop_list[GF_FOP_INODELK] = "INODELK";
- gf_fop_list[GF_FOP_FINODELK] = "FINODELK";
- gf_fop_list[GF_FOP_ENTRYLK] = "ENTRYLK";
- gf_fop_list[GF_FOP_FENTRYLK] = "FENTRYLK";
- gf_fop_list[GF_FOP_CHECKSUM] = "CHECKSUM";
- gf_fop_list[GF_FOP_XATTROP] = "XATTROP";
- gf_fop_list[GF_FOP_FXATTROP] = "FXATTROP";
- gf_fop_list[GF_FOP_FSETXATTR] = "FSETXATTR";
- gf_fop_list[GF_FOP_FGETXATTR] = "FGETXATTR";
- gf_fop_list[GF_FOP_RCHECKSUM] = "RCHECKSUM";
- gf_fop_list[GF_FOP_SETATTR] = "SETATTR";
- gf_fop_list[GF_FOP_FSETATTR] = "FSETATTR";
- gf_fop_list[GF_FOP_READDIRP] = "READDIRP";
- gf_fop_list[GF_FOP_GETSPEC] = "GETSPEC";
- gf_fop_list[GF_FOP_FORGET] = "FORGET";
- gf_fop_list[GF_FOP_RELEASE] = "RELEASE";
- gf_fop_list[GF_FOP_RELEASEDIR] = "RELEASEDIR";
-
- gf_fop_list[GF_MGMT_NULL] = "NULL";
-
- /* Are there any more variables to be included? All global
- variables initialization should go here */
-
- return;
-}
-
-void
-set_global_ctx_ptr (glusterfs_ctx_t *ctx)
-{
- gf_global_ctx = ctx;
-}
-
-/*
- * Don't use this function other than in glusterfsd.c. libglusterfsclient does
- * not set gf_global_ctx since there can be multiple glusterfs-contexts
- * initialized in a single process. Instead access the context from ctx member
- * of the xlator object.
- */
-
-glusterfs_ctx_t *
-get_global_ctx_ptr (void)
-{
- return gf_global_ctx;
-}
void
gf_log_volume_file (FILE *specfp)
@@ -397,8 +317,7 @@ gf_print_trace (int32_t signum)
/* Pending frames, (if any), list them in order */
ret = write (fd, "pending frames:\n", 16);
{
- extern glusterfs_ctx_t *gf_global_ctx;
- glusterfs_ctx_t *ctx = gf_global_ctx;
+ glusterfs_ctx_t *ctx = glusterfs_ctx_get ();
struct list_head *trav = ((call_pool_t *)ctx->pool)->all_frames.next;
while (trav != (&((call_pool_t *)ctx->pool)->all_frames)) {
call_frame_t *tmp = (call_frame_t *)(&((call_stack_t *)trav)->frames);
diff --git a/libglusterfs/src/common-utils.h b/libglusterfs/src/common-utils.h
index 06933d7c45a..80111a26ddc 100644
--- a/libglusterfs/src/common-utils.h
+++ b/libglusterfs/src/common-utils.h
@@ -82,8 +82,6 @@ enum _gf_boolean
typedef enum _gf_boolean gf_boolean_t;
void gf_global_variable_init(void);
-void set_global_ctx_ptr (glusterfs_ctx_t *ctx);
-glusterfs_ctx_t *get_global_ctx_ptr (void);
in_addr_t gf_resolve_ip (const char *hostname, void **dnscache);
diff --git a/libglusterfs/src/fd.c b/libglusterfs/src/fd.c
index b01caf765ff..d26854ebdfb 100644
--- a/libglusterfs/src/fd.c
+++ b/libglusterfs/src/fd.c
@@ -30,17 +30,18 @@
#endif
-static uint32_t
+static int
gf_fd_fdtable_expand (fdtable_t *fdtable, uint32_t nr);
+
static fd_t *
_fd_ref (fd_t *fd);
-/*
- Allocate in memory chunks of power of 2 starting from 1024B
+/*
+ Allocate in memory chunks of power of 2 starting from 1024B
Assumes fdtable->lock is held
*/
-static inline uint32_t
+static inline int
gf_roundup_power_of_two (uint32_t nr)
{
uint32_t result = 1;
@@ -58,6 +59,7 @@ gf_roundup_power_of_two (uint32_t nr)
return result;
}
+
static int
gf_fd_chain_fd_entries (fdentry_t *entries, uint32_t startidx,
uint32_t endcount)
@@ -80,18 +82,17 @@ gf_fd_chain_fd_entries (fdentry_t *entries, uint32_t startidx,
}
-static uint32_t
+static int
gf_fd_fdtable_expand (fdtable_t *fdtable, uint32_t nr)
{
- fdentry_t *oldfds = NULL;
- uint32_t oldmax_fds = -1;
-
- if (fdtable == NULL || nr < 0)
- {
+ fdentry_t *oldfds = NULL;
+ uint32_t oldmax_fds = -1;
+
+ if (fdtable == NULL || nr < 0) {
gf_log ("fd", GF_LOG_ERROR, "invalid argument");
return EINVAL;
}
-
+
nr /= (1024 / sizeof (fdentry_t));
nr = gf_roundup_power_of_two (nr + 1);
nr *= (1024 / sizeof (fdentry_t));
@@ -102,7 +103,7 @@ gf_fd_fdtable_expand (fdtable_t *fdtable, uint32_t nr)
fdtable->fdentries = GF_CALLOC (nr, sizeof (fdentry_t),
gf_common_mt_fdentry_t);
ERR_ABORT (fdtable->fdentries);
- fdtable->max_fds = nr;
+ fdtable->max_fds = nr;
if (oldfds) {
uint32_t cpy = oldmax_fds * sizeof (fdentry_t);
@@ -121,8 +122,9 @@ gf_fd_fdtable_expand (fdtable_t *fdtable, uint32_t nr)
return 0;
}
+
fdtable_t *
-gf_fd_fdtable_alloc (void)
+gf_fd_fdtable_alloc (void)
{
fdtable_t *fdtable = NULL;
@@ -141,6 +143,7 @@ gf_fd_fdtable_alloc (void)
return fdtable;
}
+
fdentry_t *
__gf_fd_fdtable_get_all_fds (fdtable_t *fdtable, uint32_t *count)
{
@@ -160,10 +163,12 @@ out:
return fdentries;
}
+
fdentry_t *
gf_fd_fdtable_get_all_fds (fdtable_t *fdtable, uint32_t *count)
{
fdentry_t *entries = NULL;
+
if (fdtable) {
pthread_mutex_lock (&fdtable->lock);
{
@@ -175,14 +180,15 @@ gf_fd_fdtable_get_all_fds (fdtable_t *fdtable, uint32_t *count)
return entries;
}
-void
+
+void
gf_fd_fdtable_destroy (fdtable_t *fdtable)
{
struct list_head list = {0, };
fd_t *fd = NULL;
fdentry_t *fdentries = NULL;
uint32_t fd_count = 0;
- int32_t i = 0;
+ int32_t i = 0;
INIT_LIST_HEAD (&list);
@@ -210,20 +216,21 @@ gf_fd_fdtable_destroy (fdtable_t *fdtable)
}
}
-int32_t
+
+int
gf_fd_unused_get (fdtable_t *fdtable, fd_t *fdptr)
{
int32_t fd = -1;
fdentry_t *fde = NULL;
int error;
int alloc_attempts = 0;
-
+
if (fdtable == NULL || fdptr == NULL)
{
gf_log ("fd", GF_LOG_ERROR, "invalid argument");
return EINVAL;
}
-
+
pthread_mutex_lock (&fdtable->lock);
{
fd_alloc_try_again:
@@ -268,20 +275,18 @@ out:
}
-inline void
+inline void
gf_fd_put (fdtable_t *fdtable, int32_t fd)
{
fd_t *fdptr = NULL;
fdentry_t *fde = NULL;
- if (fdtable == NULL || fd < 0)
- {
+ if (fdtable == NULL || fd < 0) {
gf_log ("fd", GF_LOG_ERROR, "invalid argument");
return;
}
-
- if (!(fd < fdtable->max_fds))
- {
+
+ if (!(fd < fdtable->max_fds)) {
gf_log ("fd", GF_LOG_ERROR, "invalid argument");
return;
}
@@ -316,16 +321,14 @@ fd_t *
gf_fd_fdptr_get (fdtable_t *fdtable, int64_t fd)
{
fd_t *fdptr = NULL;
-
- if (fdtable == NULL || fd < 0)
- {
+
+ if (fdtable == NULL || fd < 0) {
gf_log ("fd", GF_LOG_ERROR, "invalid argument");
errno = EINVAL;
return NULL;
}
-
- if (!(fd < fdtable->max_fds))
- {
+
+ if (!(fd < fdtable->max_fds)) {
gf_log ("fd", GF_LOG_ERROR, "invalid argument");
errno = EINVAL;
return NULL;
@@ -343,14 +346,16 @@ gf_fd_fdptr_get (fdtable_t *fdtable, int64_t fd)
return fdptr;
}
+
fd_t *
_fd_ref (fd_t *fd)
{
++fd->refcount;
-
+
return fd;
}
+
fd_t *
fd_ref (fd_t *fd)
{
@@ -364,10 +369,11 @@ fd_ref (fd_t *fd)
LOCK (&fd->inode->lock);
refed_fd = _fd_ref (fd);
UNLOCK (&fd->inode->lock);
-
+
return refed_fd;
}
+
fd_t *
_fd_unref (fd_t *fd)
{
@@ -375,25 +381,26 @@ _fd_unref (fd_t *fd)
--fd->refcount;
- if (fd->refcount == 0){
+ if (fd->refcount == 0) {
list_del_init (&fd->inode_list);
}
-
+
return fd;
}
+
static void
fd_destroy (fd_t *fd)
{
xlator_t *xl = NULL;
- int i = 0;
+ int i = 0;
xlator_t *old_THIS = NULL;
if (fd == NULL){
gf_log ("xlator", GF_LOG_ERROR, "invalid arugument");
goto out;
}
-
+
if (fd->inode == NULL){
gf_log ("xlator", GF_LOG_ERROR, "fd->inode is NULL");
goto out;
@@ -402,7 +409,7 @@ fd_destroy (fd_t *fd)
goto out;
if (IA_ISDIR (fd->inode->ia_type)) {
- for (i = 0; i < fd->inode->table->xl->ctx->xl_count; i++) {
+ for (i = 0; i < fd->inode->table->xl->graph->xl_count; i++) {
if (fd->_ctx[i].key) {
xl = (xlator_t *)(long)fd->_ctx[i].key;
old_THIS = THIS;
@@ -413,7 +420,7 @@ fd_destroy (fd_t *fd)
}
}
} else {
- for (i = 0; i < fd->inode->table->xl->ctx->xl_count; i++) {
+ for (i = 0; i < fd->inode->table->xl->graph->xl_count; i++) {
if (fd->_ctx[i].key) {
xl = (xlator_t *)(long)fd->_ctx[i].key;
old_THIS = THIS;
@@ -424,18 +431,18 @@ fd_destroy (fd_t *fd)
}
}
}
-
+
LOCK_DESTROY (&fd->lock);
GF_FREE (fd->_ctx);
inode_unref (fd->inode);
fd->inode = (inode_t *)0xaaaaaaaa;
GF_FREE (fd);
-
out:
return;
}
+
void
fd_unref (fd_t *fd)
{
@@ -445,14 +452,14 @@ fd_unref (fd_t *fd)
gf_log ("fd.c", GF_LOG_ERROR, "fd is NULL");
return;
}
-
+
LOCK (&fd->inode->lock);
{
_fd_unref (fd);
refcount = fd->refcount;
}
UNLOCK (&fd->inode->lock);
-
+
if (refcount == 0) {
fd_destroy (fd);
}
@@ -460,6 +467,7 @@ fd_unref (fd_t *fd)
return ;
}
+
fd_t *
fd_bind (fd_t *fd)
{
@@ -476,7 +484,7 @@ fd_bind (fd_t *fd)
list_add (&fd->inode_list, &inode->fd_list);
}
UNLOCK (&inode->lock);
-
+
return fd;
}
@@ -484,22 +492,23 @@ fd_t *
fd_create (inode_t *inode, pid_t pid)
{
fd_t *fd = NULL;
-
+
if (inode == NULL) {
gf_log ("fd", GF_LOG_ERROR, "invalid argument");
return NULL;
}
-
+
fd = GF_CALLOC (1, sizeof (fd_t), gf_common_mt_fd_t);
ERR_ABORT (fd);
-
+
fd->_ctx = GF_CALLOC (1, (sizeof (struct _fd_ctx) *
- inode->table->xl->ctx->xl_count),
+ inode->table->xl->graph->xl_count),
gf_common_mt_fd_ctx);
+
fd->inode = inode_ref (inode);
fd->pid = pid;
INIT_LIST_HEAD (&fd->inode_list);
-
+
LOCK_INIT (&fd->lock);
LOCK (&inode->lock);
@@ -509,6 +518,7 @@ fd_create (inode_t *inode, pid_t pid)
return fd;
}
+
fd_t *
fd_lookup (inode_t *inode, pid_t pid)
{
@@ -537,24 +547,26 @@ fd_lookup (inode_t *inode, pid_t pid)
}
}
UNLOCK (&inode->lock);
-
+
return fd;
}
+
uint8_t
fd_list_empty (inode_t *inode)
{
- uint8_t empty = 0;
+ uint8_t empty = 0;
LOCK (&inode->lock);
{
empty = list_empty (&inode->fd_list);
}
UNLOCK (&inode->lock);
-
+
return empty;
}
+
int
__fd_ctx_set (fd_t *fd, xlator_t *xlator, uint64_t value)
{
@@ -564,8 +576,8 @@ __fd_ctx_set (fd_t *fd, xlator_t *xlator, uint64_t value)
if (!fd || !xlator)
return -1;
-
- for (index = 0; index < xlator->ctx->xl_count; index++) {
+
+ for (index = 0; index < xlator->graph->xl_count; index++) {
if (!fd->_ctx[index].key) {
if (set_idx == -1)
set_idx = index;
@@ -577,12 +589,12 @@ __fd_ctx_set (fd_t *fd, xlator_t *xlator, uint64_t value)
break;
}
}
-
+
if (set_idx == -1) {
ret = -1;
goto out;
}
-
+
fd->_ctx[set_idx].key = (uint64_t)(long) xlator;
fd->_ctx[set_idx].value = value;
@@ -598,7 +610,7 @@ fd_ctx_set (fd_t *fd, xlator_t *xlator, uint64_t value)
if (!fd || !xlator)
return -1;
-
+
LOCK (&fd->lock);
{
ret = __fd_ctx_set (fd, xlator, value);
@@ -609,7 +621,7 @@ fd_ctx_set (fd_t *fd, xlator_t *xlator, uint64_t value)
}
-int
+int
__fd_ctx_get (fd_t *fd, xlator_t *xlator, uint64_t *value)
{
int index = 0;
@@ -617,26 +629,26 @@ __fd_ctx_get (fd_t *fd, xlator_t *xlator, uint64_t *value)
if (!fd || !xlator)
return -1;
-
- for (index = 0; index < xlator->ctx->xl_count; index++) {
+
+ for (index = 0; index < xlator->graph->xl_count; index++) {
if (fd->_ctx[index].key == (uint64_t)(long)xlator)
break;
}
-
- if (index == xlator->ctx->xl_count) {
+
+ if (index == xlator->graph->xl_count) {
ret = -1;
goto out;
}
- if (value)
+ if (value)
*value = fd->_ctx[index].value;
-
+
out:
return ret;
}
-int
+int
fd_ctx_get (fd_t *fd, xlator_t *xlator, uint64_t *value)
{
int ret = 0;
@@ -654,7 +666,7 @@ fd_ctx_get (fd_t *fd, xlator_t *xlator, uint64_t *value)
}
-int
+int
__fd_ctx_del (fd_t *fd, xlator_t *xlator, uint64_t *value)
{
int index = 0;
@@ -662,20 +674,20 @@ __fd_ctx_del (fd_t *fd, xlator_t *xlator, uint64_t *value)
if (!fd || !xlator)
return -1;
-
- for (index = 0; index < xlator->ctx->xl_count; index++) {
+
+ for (index = 0; index < xlator->graph->xl_count; index++) {
if (fd->_ctx[index].key == (uint64_t)(long)xlator)
break;
}
-
- if (index == xlator->ctx->xl_count) {
+
+ if (index == xlator->graph->xl_count) {
ret = -1;
goto out;
}
-
- if (value)
- *value = fd->_ctx[index].value;
-
+
+ if (value)
+ *value = fd->_ctx[index].value;
+
fd->_ctx[index].key = 0;
fd->_ctx[index].value = 0;
@@ -684,14 +696,14 @@ out:
}
-int
+int
fd_ctx_del (fd_t *fd, xlator_t *xlator, uint64_t *value)
{
int ret = 0;
if (!fd || !xlator)
return -1;
-
+
LOCK (&fd->lock);
{
ret = __fd_ctx_del (fd, xlator, value);
@@ -709,7 +721,7 @@ fd_dump (fd_t *fd, char *prefix)
if (!fd)
return;
-
+
memset(key, 0, sizeof(key));
gf_proc_dump_build_key(key, prefix, "pid");
gf_proc_dump_write(key, "%d", fd->pid);
@@ -733,10 +745,11 @@ fdentry_dump (fdentry_t *fdentry, char *prefix)
if (GF_FDENTRY_ALLOCATED != fdentry->next_free)
return;
- if (fdentry->fd)
+ if (fdentry->fd)
fd_dump(fdentry->fd, prefix);
}
+
void
fdtable_dump (fdtable_t *fdtable, char *prefix)
{
@@ -746,7 +759,7 @@ fdtable_dump (fdtable_t *fdtable, char *prefix)
if (!fdtable)
return;
-
+
ret = pthread_mutex_trylock (&fdtable->lock);
if (ret) {
@@ -763,7 +776,7 @@ fdtable_dump (fdtable_t *fdtable, char *prefix)
gf_proc_dump_write(key, "%d", fdtable->first_free);
for ( i = 0 ; i < fdtable->max_fds; i++) {
- if (GF_FDENTRY_ALLOCATED ==
+ if (GF_FDENTRY_ALLOCATED ==
fdtable->fdentries[i].next_free) {
gf_proc_dump_build_key(key, prefix, "fdentry[%d]", i);
gf_proc_dump_add_section(key);
@@ -773,4 +786,3 @@ fdtable_dump (fdtable_t *fdtable, char *prefix)
pthread_mutex_unlock(&fdtable->lock);
}
-
diff --git a/libglusterfs/src/fd.h b/libglusterfs/src/fd.h
index 9c5ebd8d786..c2181d8af17 100644
--- a/libglusterfs/src/fd.h
+++ b/libglusterfs/src/fd.h
@@ -33,9 +33,10 @@
struct _inode;
struct _dict;
+
struct _fd_ctx {
- uint64_t key;
- uint64_t value;
+ uint64_t key;
+ uint64_t value;
};
/* If this structure changes, please have mercy on the booster maintainer
@@ -55,12 +56,14 @@ struct _fd {
};
typedef struct _fd fd_t;
+
struct fd_table_entry {
fd_t *fd;
int next_free;
};
typedef struct fd_table_entry fdentry_t;
+
struct _fdtable {
int refcount;
uint32_t max_fds;
@@ -70,6 +73,7 @@ struct _fdtable {
};
typedef struct _fdtable fdtable_t;
+
/* Signifies no more entries in the fd table. */
#define GF_FDTABLE_END -1
@@ -81,58 +85,77 @@ typedef struct _fdtable fdtable_t;
#include "logging.h"
#include "xlator.h"
-inline void
+
+inline void
gf_fd_put (fdtable_t *fdtable, int32_t fd);
+
fd_t *
gf_fd_fdptr_get (fdtable_t *fdtable, int64_t fd);
+
fdtable_t *
gf_fd_fdtable_alloc (void);
-int32_t
+
+int
gf_fd_unused_get (fdtable_t *fdtable, fd_t *fdptr);
+
fdentry_t *
gf_fd_fdtable_get_all_fds (fdtable_t *fdtable, uint32_t *count);
-void
+
+void
gf_fd_fdtable_destroy (fdtable_t *fdtable);
+
fd_t *
fd_ref (fd_t *fd);
+
void
fd_unref (fd_t *fd);
+
fd_t *
fd_create (struct _inode *inode, pid_t pid);
+
fd_t *
fd_lookup (struct _inode *inode, pid_t pid);
+
uint8_t
fd_list_empty (struct _inode *inode);
+
fd_t *
fd_bind (fd_t *fd);
+
int
fd_ctx_set (fd_t *fd, xlator_t *xlator, uint64_t value);
-int
+
+int
fd_ctx_get (fd_t *fd, xlator_t *xlator, uint64_t *value);
-int
+
+int
fd_ctx_del (fd_t *fd, xlator_t *xlator, uint64_t *value);
+
int
__fd_ctx_set (fd_t *fd, xlator_t *xlator, uint64_t value);
-int
+
+int
__fd_ctx_get (fd_t *fd, xlator_t *xlator, uint64_t *value);
-int
+
+int
__fd_ctx_del (fd_t *fd, xlator_t *xlator, uint64_t *value);
+
#endif /* _FD_H */
diff --git a/libglusterfs/src/globals.c b/libglusterfs/src/globals.c
index 9677a169ecb..d480f089fcb 100644
--- a/libglusterfs/src/globals.c
+++ b/libglusterfs/src/globals.c
@@ -24,12 +24,73 @@
#include <pthread.h>
-#include "globals.h"
#include "glusterfs.h"
+#include "globals.h"
#include "xlator.h"
#include "mem-pool.h"
+/* gf_*_list[] */
+
+char *gf_fop_list[GF_FOP_MAXVALUE];
+char *gf_mgmt_list[GF_MGMT_MAXVALUE];
+
+
+void
+gf_op_list_init()
+{
+ gf_fop_list[GF_FOP_NULL] = "NULL";
+ gf_fop_list[GF_FOP_STAT] = "STAT";
+ gf_fop_list[GF_FOP_READLINK] = "READLINK";
+ gf_fop_list[GF_FOP_MKNOD] = "MKNOD";
+ gf_fop_list[GF_FOP_MKDIR] = "MKDIR";
+ gf_fop_list[GF_FOP_UNLINK] = "UNLINK";
+ gf_fop_list[GF_FOP_RMDIR] = "RMDIR";
+ gf_fop_list[GF_FOP_SYMLINK] = "SYMLINK";
+ gf_fop_list[GF_FOP_RENAME] = "RENAME";
+ gf_fop_list[GF_FOP_LINK] = "LINK";
+ gf_fop_list[GF_FOP_TRUNCATE] = "TRUNCATE";
+ gf_fop_list[GF_FOP_OPEN] = "OPEN";
+ gf_fop_list[GF_FOP_READ] = "READ";
+ gf_fop_list[GF_FOP_WRITE] = "WRITE";
+ gf_fop_list[GF_FOP_STATFS] = "STATFS";
+ gf_fop_list[GF_FOP_FLUSH] = "FLUSH";
+ gf_fop_list[GF_FOP_FSYNC] = "FSYNC";
+ gf_fop_list[GF_FOP_SETXATTR] = "SETXATTR";
+ gf_fop_list[GF_FOP_GETXATTR] = "GETXATTR";
+ gf_fop_list[GF_FOP_REMOVEXATTR] = "REMOVEXATTR";
+ gf_fop_list[GF_FOP_OPENDIR] = "OPENDIR";
+ gf_fop_list[GF_FOP_FSYNCDIR] = "FSYNCDIR";
+ gf_fop_list[GF_FOP_ACCESS] = "ACCESS";
+ gf_fop_list[GF_FOP_CREATE] = "CREATE";
+ gf_fop_list[GF_FOP_FTRUNCATE] = "FTRUNCATE";
+ gf_fop_list[GF_FOP_FSTAT] = "FSTAT";
+ gf_fop_list[GF_FOP_LK] = "LK";
+ gf_fop_list[GF_FOP_LOOKUP] = "LOOKUP";
+ gf_fop_list[GF_FOP_READDIR] = "READDIR";
+ gf_fop_list[GF_FOP_INODELK] = "INODELK";
+ gf_fop_list[GF_FOP_FINODELK] = "FINODELK";
+ gf_fop_list[GF_FOP_ENTRYLK] = "ENTRYLK";
+ gf_fop_list[GF_FOP_FENTRYLK] = "FENTRYLK";
+ gf_fop_list[GF_FOP_CHECKSUM] = "CHECKSUM";
+ gf_fop_list[GF_FOP_XATTROP] = "XATTROP";
+ gf_fop_list[GF_FOP_FXATTROP] = "FXATTROP";
+ gf_fop_list[GF_FOP_FSETXATTR] = "FSETXATTR";
+ gf_fop_list[GF_FOP_FGETXATTR] = "FGETXATTR";
+ gf_fop_list[GF_FOP_RCHECKSUM] = "RCHECKSUM";
+ gf_fop_list[GF_FOP_SETATTR] = "SETATTR";
+ gf_fop_list[GF_FOP_FSETATTR] = "FSETATTR";
+ gf_fop_list[GF_FOP_READDIRP] = "READDIRP";
+ gf_fop_list[GF_FOP_GETSPEC] = "GETSPEC";
+ gf_fop_list[GF_FOP_FORGET] = "FORGET";
+ gf_fop_list[GF_FOP_RELEASE] = "RELEASE";
+ gf_fop_list[GF_FOP_RELEASEDIR] = "RELEASEDIR";
+
+ gf_fop_list[GF_MGMT_NULL] = "NULL";
+ return;
+}
+
+
/* CTX */
static glusterfs_ctx_t *glusterfs_ctx;
@@ -48,6 +109,7 @@ glusterfs_ctx_init ()
goto out;
}
+ INIT_LIST_HEAD (&glusterfs_ctx->graphs);
ret = pthread_mutex_init (&glusterfs_ctx->lock, NULL);
out:
@@ -168,7 +230,7 @@ glusterfs_central_log_flag_init ()
{
int ret = 0;
- ret = pthread_key_create (&central_log_flag_key,
+ ret = pthread_key_create (&central_log_flag_key,
glusterfs_central_log_flag_destroy);
if (ret != 0) {
@@ -194,7 +256,7 @@ glusterfs_central_log_flag_get ()
long flag = 0;
flag = (long) pthread_getspecific (central_log_flag_key);
-
+
return flag;
}
@@ -211,6 +273,8 @@ glusterfs_globals_init ()
{
int ret = 0;
+ gf_op_list_init ();
+
ret = glusterfs_ctx_init ();
if (ret)
goto out;
diff --git a/libglusterfs/src/globals.h b/libglusterfs/src/globals.h
index 58f37d185bd..e09c695113c 100644
--- a/libglusterfs/src/globals.h
+++ b/libglusterfs/src/globals.h
@@ -27,13 +27,14 @@
#define GF_REQUEST_MAXGROUPS 16
#include "glusterfs.h"
-#include "xlator.h"
/* CTX */
#define CTX (glusterfs_ctx_get())
glusterfs_ctx_t *glusterfs_ctx_get ();
+#include "xlator.h"
+
/* THIS */
#define THIS (*__glusterfs_this_location())
diff --git a/libglusterfs/src/glusterfs.h b/libglusterfs/src/glusterfs.h
index f4134d9ea25..b6db51489c1 100644
--- a/libglusterfs/src/glusterfs.h
+++ b/libglusterfs/src/glusterfs.h
@@ -45,6 +45,7 @@
#include "list.h"
#include "logging.h"
+
#define GF_YES 1
#define GF_NO 0
@@ -95,7 +96,7 @@ typedef enum {
GF_FOP_WRITE,
GF_FOP_STATFS,
GF_FOP_FLUSH,
- GF_FOP_FSYNC,
+ GF_FOP_FSYNC, /* 15 */
GF_FOP_SETXATTR,
GF_FOP_GETXATTR,
GF_FOP_REMOVEXATTR,
@@ -104,7 +105,7 @@ typedef enum {
GF_FOP_ACCESS,
GF_FOP_CREATE,
GF_FOP_FTRUNCATE,
- GF_FOP_FSTAT,
+ GF_FOP_FSTAT, /* 25 */
GF_FOP_LK,
GF_FOP_LOOKUP,
GF_FOP_READDIR,
@@ -141,6 +142,7 @@ typedef enum {
GF_OP_TYPE_MAX,
} gf_op_type_t;
+
/* NOTE: all the miscellaneous flags used by GlusterFS should be listed here */
typedef enum {
GF_LK_GETLK = 0,
@@ -148,32 +150,38 @@ typedef enum {
GF_LK_SETLKW,
} glusterfs_lk_cmds_t;
+
typedef enum {
GF_LK_F_RDLCK = 0,
GF_LK_F_WRLCK,
GF_LK_F_UNLCK
} glusterfs_lk_types_t;
+
typedef enum {
- GF_LOCK_POSIX,
+ GF_LOCK_POSIX,
GF_LOCK_INTERNAL
} gf_lk_domain_t;
+
typedef enum {
ENTRYLK_LOCK,
ENTRYLK_UNLOCK,
ENTRYLK_LOCK_NB
} entrylk_cmd;
+
typedef enum {
ENTRYLK_RDLCK,
ENTRYLK_WRLCK
} entrylk_type;
+
typedef enum {
GF_XATTROP_ADD_ARRAY,
} gf_xattrop_flags_t;
+
#define GF_SET_IF_NOT_PRESENT 0x1 /* default behaviour */
#define GF_SET_OVERWRITE 0x2 /* Overwrite with the buf given */
#define GF_SET_DIR_ONLY 0x4
@@ -186,17 +194,18 @@ typedef enum {
#define GF_REPLICATE_TRASH_DIR ".landfill"
struct _xlator_cmdline_option {
- struct list_head cmd_args;
- char *volume;
- char *key;
- char *value;
+ struct list_head cmd_args;
+ char *volume;
+ char *key;
+ char *value;
};
typedef struct _xlator_cmdline_option xlator_cmdline_option_t;
+
struct _cmd_args {
/* basic options */
char *volfile_server;
- char *volume_file;
+ char *volfile;
char *log_server;
gf_loglevel_t log_level;
char *log_file;
@@ -229,41 +238,61 @@ struct _cmd_args {
};
typedef struct _cmd_args cmd_args_t;
-struct _glusterfs_ctx {
- cmd_args_t cmd_args;
- char *process_uuid;
- FILE *specfp;
- FILE *pidfp;
- char fin;
- void *timer;
- void *ib;
- void *pool;
- void *graph;
- void *top; /* either fuse or server protocol */
- void *event_pool;
- void *iobuf_pool;
- pthread_mutex_t lock;
- int xl_count;
- uint32_t volfile_checksum;
- size_t page_size;
- unsigned char measure_latency; /* toggle switch for latency measurement */
+
+struct _glusterfs_graph {
+ struct list_head list;
+ char graph_uuid[128];
+ struct timeval dob;
+ void *first;
+ void *top; /* selected by -n */
+ int xl_count;
+ uint32_t volfile_checksum;
};
+typedef struct _glusterfs_graph glusterfs_graph_t;
+
+struct _glusterfs_ctx {
+ cmd_args_t cmd_args;
+ char *process_uuid;
+ FILE *pidfp;
+ char fin;
+ void *timer;
+ void *ib;
+ void *pool;
+ void *event_pool;
+ void *iobuf_pool;
+ pthread_mutex_t lock;
+ size_t page_size;
+ struct list_head graphs; /* double linked list of graphs - one per volfile parse */
+ glusterfs_graph_t *active; /* the latest graph in use */
+ void *master; /* fuse, or libglusterfsclient (however, not protocol/server) */
+ void *mgmt; /* xlator implementing MOPs for centralized logging, volfile server */
+ unsigned char measure_latency; /* toggle switch for latency measurement */
+ pthread_t sigwaiter;
+};
typedef struct _glusterfs_ctx glusterfs_ctx_t;
+
typedef enum {
- GF_EVENT_PARENT_UP = 1,
- GF_EVENT_POLLIN,
- GF_EVENT_POLLOUT,
- GF_EVENT_POLLERR,
- GF_EVENT_CHILD_UP,
- GF_EVENT_CHILD_DOWN,
- GF_EVENT_CHILD_CONNECTING,
- GF_EVENT_TRANSPORT_CLEANUP,
- GF_EVENT_TRANSPORT_CONNECTED,
- GF_EVENT_VOLFILE_MODIFIED,
+ GF_EVENT_PARENT_UP = 1,
+ GF_EVENT_POLLIN,
+ GF_EVENT_POLLOUT,
+ GF_EVENT_POLLERR,
+ GF_EVENT_CHILD_UP,
+ GF_EVENT_CHILD_DOWN,
+ GF_EVENT_CHILD_CONNECTING,
+ GF_EVENT_TRANSPORT_CLEANUP,
+ GF_EVENT_TRANSPORT_CONNECTED,
+ GF_EVENT_VOLFILE_MODIFIED,
+ GF_EVENT_GRAPH_NEW,
} glusterfs_event_t;
+
#define GF_MUST_CHECK __attribute__((warn_unused_result))
+int glusterfs_graph_prepare (glusterfs_graph_t *graph, glusterfs_ctx_t *ctx);
+int glusterfs_graph_destroy (glusterfs_graph_t *graph);
+int glusterfs_graph_activate (glusterfs_ctx_t *ctx, glusterfs_graph_t *graph);
+glusterfs_graph_t *glusterfs_graph_construct (FILE *fp);
+glusterfs_graph_t *glusterfs_graph_new ();
#endif /* _GLUSTERFS_H */
diff --git a/libglusterfs/src/graph.c b/libglusterfs/src/graph.c
new file mode 100644
index 00000000000..a59b427bffe
--- /dev/null
+++ b/libglusterfs/src/graph.c
@@ -0,0 +1,499 @@
+/*
+ Copyright (c) 2010 Gluster, Inc. <http://www.gluster.com>
+ This file is part of GlusterFS.
+
+ GlusterFS is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published
+ by the Free Software Foundation; either version 3 of the License,
+ or (at your option) any later version.
+
+ GlusterFS is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see
+ <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _CONFIG_H
+#define _CONFIG_H
+#include "config.h"
+#endif
+
+#include "xlator.h"
+#include <dlfcn.h>
+#include <netdb.h>
+#include <fnmatch.h>
+#include "defaults.h"
+
+
+
+
+#if 0
+static void
+_gf_dump_details (int argc, char **argv)
+{
+ extern FILE *gf_log_logfile;
+ int i = 0;
+ char timestr[256];
+ time_t utime = 0;
+ struct tm *tm = NULL;
+ pid_t mypid = 0;
+ struct utsname uname_buf = {{0, }, };
+ int uname_ret = -1;
+
+ utime = time (NULL);
+ tm = localtime (&utime);
+ mypid = getpid ();
+ uname_ret = uname (&uname_buf);
+
+ /* Which git? What time? */
+ strftime (timestr, 256, "%Y-%m-%d %H:%M:%S", tm);
+ fprintf (gf_log_logfile,
+ "========================================"
+ "========================================\n");
+ fprintf (gf_log_logfile, "Version : %s %s built on %s %s\n",
+ PACKAGE_NAME, PACKAGE_VERSION, __DATE__, __TIME__);
+ fprintf (gf_log_logfile, "git: %s\n",
+ GLUSTERFS_REPOSITORY_REVISION);
+ fprintf (gf_log_logfile, "Starting Time: %s\n", timestr);
+ fprintf (gf_log_logfile, "Command line : ");
+ for (i = 0; i < argc; i++) {
+ fprintf (gf_log_logfile, "%s ", argv[i]);
+ }
+
+ fprintf (gf_log_logfile, "\nPID : %d\n", mypid);
+
+ if (uname_ret == 0) {
+ fprintf (gf_log_logfile, "System name : %s\n",
+ uname_buf.sysname);
+ fprintf (gf_log_logfile, "Nodename : %s\n",
+ uname_buf.nodename);
+ fprintf (gf_log_logfile, "Kernel Release : %s\n",
+ uname_buf.release);
+ fprintf (gf_log_logfile, "Hardware Identifier: %s\n",
+ uname_buf.machine);
+ }
+
+
+ fprintf (gf_log_logfile, "\n");
+ fflush (gf_log_logfile);
+}
+#endif
+
+
+static int
+_log_if_option_is_invalid (xlator_t *xl, data_pair_t *pair)
+{
+ volume_opt_list_t *vol_opt = NULL;
+ volume_option_t *opt = NULL;
+ int i = 0;
+ int index = 0;
+ int found = 0;
+
+ /* Get the first volume_option */
+ list_for_each_entry (vol_opt, &xl->volume_options, list) {
+ /* Warn for extra option */
+ if (!vol_opt->given_opt)
+ break;
+
+ opt = vol_opt->given_opt;
+ for (index = 0;
+ ((index < ZR_OPTION_MAX_ARRAY_SIZE) &&
+ (opt[index].key && opt[index].key[0])); index++)
+ for (i = 0; (i < ZR_VOLUME_MAX_NUM_KEY) &&
+ opt[index].key[i]; i++) {
+ if (fnmatch (opt[index].key[i],
+ pair->key,
+ FNM_NOESCAPE) == 0) {
+ found = 1;
+ break;
+ }
+ }
+ }
+
+ if (!found) {
+ gf_log (xl->name, GF_LOG_WARNING,
+ "option '%s' is not recognized",
+ pair->key);
+ }
+ return 0;
+}
+
+
+int
+glusterfs_graph_insert (glusterfs_graph_t *graph, glusterfs_ctx_t *ctx,
+ const char *type, const char *name)
+{
+ xlator_t *ixl = NULL;
+ xlator_list_t *xlchild = NULL;
+ xlator_list_t *xlparent = NULL;
+
+ ixl = GF_CALLOC (1, sizeof (*ixl), gf_common_mt_xlator_t);
+ if (!ixl)
+ return -1;
+
+ ixl->ctx = ctx;
+ ixl->graph = graph;
+ ixl->options = get_new_dict ();
+ if (!ixl->options)
+ goto err;
+
+ ixl->name = gf_strdup (name);
+ if (!ixl->name)
+ goto err;
+
+ if (xlator_set_type (ixl, type) == -1) {
+ gf_log ("glusterfs", GF_LOG_ERROR,
+ "%s (%s) initialization failed",
+ name, type);
+ return -1;
+ }
+
+
+ /* children */
+ xlchild = GF_CALLOC (sizeof (*xlchild), 1, gf_common_mt_xlator_list_t);
+ if (!xlchild)
+ goto err;
+ xlchild->xlator = graph->top;
+ ixl->children = xlchild; xlchild = NULL;
+
+
+ /* parent */
+ xlparent = GF_CALLOC (sizeof (*xlparent), 1,
+ gf_common_mt_xlator_list_t);
+ if (!xlparent)
+ goto err;
+ xlparent->xlator = ixl;
+
+ ixl->next = graph->first;
+ graph->first = ixl;
+
+ xlparent->next = ((xlator_t *)graph->top)->parents;
+ ((xlator_t *)graph->top)->parents = xlparent;
+
+ graph->top = ixl;
+
+ graph->xl_count++;
+
+ return 0;
+err:
+ xlator_destroy (ixl);
+ return -1;
+}
+
+
+int
+glusterfs_graph_readonly (glusterfs_graph_t *graph, glusterfs_ctx_t *ctx)
+{
+ int ret = 0;
+ cmd_args_t *cmd_args = NULL;
+
+ cmd_args = &ctx->cmd_args;
+
+ if (!cmd_args->read_only)
+ return 0;
+
+ ret = glusterfs_graph_insert (graph, ctx, "features/read-only",
+ "readonly-autoload");
+ return ret;
+}
+
+
+int
+glusterfs_graph_mac_compat (glusterfs_graph_t *graph, glusterfs_ctx_t *ctx)
+{
+ int ret = 0;
+ cmd_args_t *cmd_args = NULL;
+
+ cmd_args = &ctx->cmd_args;
+
+#ifdef GF_DARWIN_HOST_OS
+ if (!cmd_args->mac_compat)
+ return 0;
+
+ ret = glusterfs_graph_insert (graph, ctx, ZR_XLATOR_MAC_COMPAT,
+ "mac-compat-autoload");
+#endif
+
+ return ret;
+}
+
+
+static void
+gf_add_cmdline_options (glusterfs_graph_t *graph, cmd_args_t *cmd_args)
+{
+ int ret = 0;
+ xlator_t *trav = NULL;
+ xlator_cmdline_option_t *cmd_option = NULL;
+
+ trav = graph->first;
+
+ while (trav) {
+ list_for_each_entry (cmd_option,
+ &cmd_args->xlator_options, cmd_args) {
+ if (!fnmatch (cmd_option->volume,
+ trav->name, FNM_NOESCAPE)) {
+ ret = dict_set_str (trav->options,
+ cmd_option->key,
+ cmd_option->value);
+ if (ret == 0) {
+ gf_log (trav->name, GF_LOG_WARNING,
+ "adding option '%s' for "
+ "volume '%s' with value '%s'",
+ cmd_option->key, trav->name,
+ cmd_option->value);
+ } else {
+ gf_log (trav->name, GF_LOG_WARNING,
+ "adding option '%s' for "
+ "volume '%s' failed: %s",
+ cmd_option->key, trav->name,
+ strerror (-ret));
+ }
+ }
+ }
+ trav = trav->next;
+ }
+}
+
+
+int
+glusterfs_graph_validate_options (glusterfs_graph_t *graph)
+{
+ volume_opt_list_t *vol_opt = NULL;
+ xlator_t *trav = NULL;
+ int ret = -1;
+
+ trav = graph->first;
+
+ while (trav) {
+ if (list_empty (&trav->volume_options))
+ continue;
+
+ vol_opt = list_entry (trav->volume_options.next,
+ volume_opt_list_t, list);
+
+ ret = validate_xlator_volume_options (trav,
+ vol_opt->given_opt);
+ if (ret) {
+ gf_log (trav->name, GF_LOG_ERROR,
+ "validating translator failed");
+ return ret;
+ }
+ trav = trav->next;
+ }
+
+ return 0;
+}
+
+
+int
+glusterfs_graph_init (glusterfs_graph_t *graph)
+{
+ xlator_t *trav = NULL;
+ int ret = -1;
+
+ trav = graph->first;
+
+ while (trav) {
+ ret = xlator_init (trav);
+ if (ret) {
+ gf_log (trav->name, GF_LOG_ERROR,
+ "initializing translator failed");
+ return ret;
+ }
+ trav = trav->next;
+ }
+
+ return 0;
+}
+
+
+int
+glusterfs_graph_unknown_options (glusterfs_graph_t *graph)
+{
+ data_pair_t *pair = NULL;
+ xlator_t *trav = NULL;
+
+ trav = graph->first;
+
+ /* Validate again phase */
+ while (trav) {
+ pair = trav->options->members_list;
+ while (pair) {
+ _log_if_option_is_invalid (trav, pair);
+ pair = pair->next;
+ }
+ trav = trav->next;
+ }
+
+ return 0;
+}
+
+
+void
+fill_uuid (char *uuid, int size)
+{
+ char hostname[256] = {0,};
+ struct timeval tv = {0,};
+ struct tm now = {0, };
+ char now_str[32];
+
+ if (gettimeofday (&tv, NULL) == -1) {
+ gf_log ("graph", GF_LOG_ERROR,
+ "gettimeofday: failed %s",
+ strerror (errno));
+ }
+
+ if (gethostname (hostname, 256) == -1) {
+ gf_log ("graph", GF_LOG_ERROR,
+ "gethostname: failed %s",
+ strerror (errno));
+ }
+
+ localtime_r (&tv.tv_sec, &now);
+ strftime (now_str, 32, "%Y/%m/%d-%H:%M:%S", &now);
+ snprintf (uuid, size, "%s-%d-%s:%ld",
+ hostname, getpid(), now_str, tv.tv_usec);
+
+ return;
+}
+
+
+int
+glusterfs_graph_settop (glusterfs_graph_t *graph, glusterfs_ctx_t *ctx)
+{
+ const char *volume_name = NULL;
+ xlator_t *trav = NULL;
+
+ volume_name = ctx->cmd_args.volume_name;
+
+ if (!volume_name) {
+ graph->top = graph->first;
+ return 0;
+ }
+
+ for (trav = graph->first; trav; trav = trav->next) {
+ if (strcmp (trav->name, volume_name) == 0) {
+ graph->top = trav;
+ return 0;
+ }
+ }
+
+ return -1;
+}
+
+
+int
+glusterfs_graph_parent_up (glusterfs_graph_t *graph)
+{
+ xlator_t *trav = NULL;
+ int ret = -1;
+
+ trav = graph->first;
+
+ while (trav) {
+ if (!xlator_has_parent (trav)) {
+ ret = xlator_notify (trav, GF_EVENT_PARENT_UP, trav);
+ }
+
+ if (ret)
+ break;
+
+ trav = trav->next;
+ }
+
+ return ret;
+}
+
+
+int
+glusterfs_graph_prepare (glusterfs_graph_t *graph, glusterfs_ctx_t *ctx)
+{
+ xlator_t *trav = NULL;
+ int ret = 0;
+
+ /* XXX: CHECKSUM */
+
+ /* XXX: attach to -n volname */
+ ret = glusterfs_graph_settop (graph, ctx);
+ if (ret)
+ return -1;
+
+ /* XXX: RO VOLUME */
+ ret = glusterfs_graph_readonly (graph, ctx);
+ if (ret)
+ return -1;
+
+ /* XXX: MAC COMPAT */
+ ret = glusterfs_graph_mac_compat (graph, ctx);
+ if (ret)
+ return -1;
+
+ /* XXX: this->ctx setting */
+ for (trav = graph->first; trav; trav = trav->next) {
+ trav->ctx = ctx;
+ }
+
+ /* XXX: DOB setting */
+ gettimeofday (&graph->dob, NULL);
+
+ fill_uuid (graph->graph_uuid, 128);
+
+ /* XXX: --xlator-option additions */
+ gf_add_cmdline_options (graph, &ctx->cmd_args);
+
+
+ return 0;
+}
+
+
+int
+glusterfs_graph_activate (glusterfs_ctx_t *ctx, glusterfs_graph_t *graph)
+{
+ int ret = 0;
+
+ /* XXX: all xlator options validation */
+ ret = glusterfs_graph_validate_options (graph);
+ if (ret)
+ return ret;
+
+ /* XXX: perform init () */
+ ret = glusterfs_graph_init (graph);
+ if (ret)
+ return ret;
+
+ ret = glusterfs_graph_unknown_options (graph);
+ if (ret)
+ return ret;
+
+ /* XXX: log full graph (_gf_dump_details) */
+
+ list_add (&graph->list, &ctx->graphs);
+ ctx->active = graph;
+
+ /* XXX: attach to master and set active pointer */
+ if (ctx->master)
+ ret = xlator_notify (ctx->master, GF_EVENT_GRAPH_NEW, graph);
+ if (ret)
+ return ret;
+
+ /* XXX: perform parent up */
+ ret = glusterfs_graph_parent_up (graph);
+ if (ret)
+ return ret;
+
+
+ return 0;
+}
+
+
+int
+glusterfs_graph_destroy (glusterfs_graph_t *graph)
+{
+ return 0;
+}
+
+
diff --git a/libglusterfs/src/spec.l b/libglusterfs/src/graph.l
index 9508e0f5539..8d9d2dc3611 100644
--- a/libglusterfs/src/spec.l
+++ b/libglusterfs/src/graph.l
@@ -33,21 +33,21 @@ static char *text;
static int text_asize;
static int text_size;
-void new_string(void)
-{
- text = malloc(START_STRSIZE);
- text_asize = START_STRSIZE;
- text_size = 0;
- *text = 0;
-}
-
void append_string(const char *str, int size)
{
int new_size = text_size + size + 1;
if (new_size > text_asize) {
new_size += START_STRSIZE - 1;
new_size &= -START_STRSIZE;
- text = realloc(text, new_size);
+ if (!text) {
+ text = GF_CALLOC (1, new_size,
+ gf_common_mt_char);
+ } else {
+ text = GF_REALLOC (text, new_size);
+ }
+ if (!text)
+ gf_log ("parser", GF_LOG_ERROR,
+ "out of memory");
text_asize = new_size;
}
memcpy(text + text_size, str, size);
@@ -55,13 +55,6 @@ void append_string(const char *str, int size)
text[text_size] = 0;
}
-void alloc_string(const char *str, int size)
-{
- text = malloc(size + 1);
- memcpy(text, str, size);
- text[size] = 0;
-}
-
%}
VOLUME [v][o][l][u][m][e]
@@ -71,10 +64,10 @@ OPTION [o][p][t][i][o][n]
TYPE [t][y][p][e]
%%
\#.* ;
-{VOLUME} return SECTION_BEGIN;
+{VOLUME} return VOLUME_BEGIN;
{TYPE} return TYPE;
-{END}[-]{VOLUME} return SECTION_END;
-{SUB}{VOLUME}[Ss] return SUBSECTION;
+{END}[-]{VOLUME} return VOLUME_END;
+{SUB}{VOLUME}[Ss] return SUBVOLUME;
{OPTION} return OPTION;
\" BEGIN(STRING);
<STRING>{
@@ -83,12 +76,12 @@ TYPE [t][y][p][e]
\" {
if (0) {
yyunput (0, NULL);
- }
+ }
BEGIN (INITIAL);
yylval = text;
return STRING_TOK;
}
}
-[^ \t\r\n\"\\]+ { yylval = strdup (yytext) ; return ID; }
+[^ \t\r\n\"\\]+ { yylval = gf_strdup (yytext) ; return ID; }
[ \t\r\n]+ ;
%%
diff --git a/libglusterfs/src/graph.y b/libglusterfs/src/graph.y
new file mode 100644
index 00000000000..4ac07660f95
--- /dev/null
+++ b/libglusterfs/src/graph.y
@@ -0,0 +1,651 @@
+/*
+ Copyright (c) 2006-2009 Gluster, Inc. <http://www.gluster.com>
+ This file is part of GlusterFS.
+
+ GlusterFS is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published
+ by the Free Software Foundation; either version 3 of the License,
+ or (at your option) any later version.
+
+ GlusterFS is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see
+ <http://www.gnu.org/licenses/>.
+*/
+
+
+%token VOLUME_BEGIN VOLUME_END OPTION NEWLINE SUBVOLUME ID WHITESPACE COMMENT TYPE STRING_TOK
+
+%{
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <sys/mman.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+
+#include "xlator.h"
+#include "logging.h"
+
+static int new_volume (char *name);
+static int volume_type (char *type);
+static int volume_option (char *key, char *value);
+static int volume_sub (char *sub);
+static int volume_end (void);
+static void sub_error (void);
+static void type_error (void);
+static void option_error (void);
+
+#define YYSTYPE char *
+#define GF_CMD_BUFFER_LEN (8 * GF_UNIT_KB)
+
+int yyerror (const char *);
+int yylex ();
+%}
+
+
+%%
+VOLUMES: VOLUME | VOLUMES VOLUME;
+
+VOLUME: VOLUME_HEADER VOLUME_DATA VOLUME_FOOTER;
+VOLUME_HEADER: VOLUME_BEGIN WORD {if (new_volume ($2) == -1) { YYABORT; }};
+VOLUME_FOOTER: VOLUME_END {if (volume_end () == -1) { YYABORT; }};
+
+VOLUME_DATA: TYPE_LINE OPTIONS_LINE SUBVOLUME_LINE OPTIONS_LINE |
+ TYPE_LINE SUBVOLUME_LINE OPTIONS_LINE |
+ TYPE_LINE OPTIONS_LINE SUBVOLUME_LINE |
+ TYPE_LINE SUBVOLUME_LINE |
+ TYPE_LINE OPTIONS_LINE |
+ OPTIONS_LINE SUBVOLUME_LINE OPTIONS_LINE | /* error case */
+ OPTIONS_LINE; /* error case */
+
+TYPE_LINE: TYPE WORD {if (volume_type ($2) == -1) { YYABORT; }} | TYPE { type_error(); YYABORT; };
+
+SUBVOLUME_LINE: SUBVOLUME WORDS | SUBVOLUME { sub_error (); YYABORT; };
+
+OPTIONS_LINE: OPTION_LINE | OPTIONS_LINE OPTION_LINE;
+
+OPTION_LINE: OPTION WORD WORD {if (volume_option ($2, $3) == -1) { YYABORT; }} |
+ OPTION WORD { option_error (); YYABORT; } |
+ OPTION { option_error (); YYABORT; };
+
+WORDS: WORD {if (volume_sub ($1) == -1) {YYABORT; }} | WORDS WORD { if (volume_sub ($2) == -1) { YYABORT; }};
+WORD: ID | STRING_TOK ;
+%%
+
+xlator_t *curr;
+glusterfs_graph_t *construct;
+
+
+static void
+type_error (void)
+{
+ extern int yylineno;
+
+ gf_log ("parser", GF_LOG_ERROR,
+ "Volume %s, before line %d: Please specify volume type",
+ curr->name, yylineno);
+ return;
+}
+
+
+static void
+sub_error (void)
+{
+ extern int yylineno;
+
+ gf_log ("parser", GF_LOG_ERROR,
+ "Volume %s, before line %d: Please specify subvolumes",
+ curr->name, yylineno);
+ return;
+}
+
+
+static void
+option_error (void)
+{
+ extern int yylineno;
+
+ gf_log ("parser", GF_LOG_ERROR,
+ "Volume %s, before line %d: Please specify "
+ "option <key> <value>",
+ curr->name, yylineno);
+ return;
+}
+
+
+static int
+new_volume (char *name)
+{
+ extern int yylineno;
+ xlator_t *trav = NULL;
+ int ret = 0;
+
+ if (!name) {
+ gf_log ("parser", GF_LOG_DEBUG,
+ "Invalid argument name: '%s'", name);
+ ret = -1;
+ goto out;
+ }
+
+ if (curr) {
+ gf_log ("parser", GF_LOG_ERROR,
+ "new volume (%s) defintion in line %d unexpected",
+ name, yylineno);
+ ret = -1;
+ goto out;
+ }
+
+ curr = (void *) GF_CALLOC (1, sizeof (*curr),
+ gf_common_mt_xlator_t);
+
+ if (!curr) {
+ gf_log ("parser", GF_LOG_ERROR, "Out of memory");
+ ret = -1;
+ goto out;
+ }
+
+ trav = construct->first;
+
+ while (trav) {
+ if (!strcmp (name, trav->name)) {
+ gf_log ("parser", GF_LOG_ERROR,
+ "Line %d: volume '%s' defined again",
+ yylineno, name);
+ ret = -1;
+ goto out;
+ }
+ trav = trav->next;
+ }
+
+ curr->name = gf_strdup (name);
+ if (!curr->name) {
+ GF_FREE (curr);
+ ret = -1;
+ goto out;
+ }
+
+ curr->options = get_new_dict ();
+
+ if (!curr->options) {
+ GF_FREE (curr->name);
+ GF_FREE (curr);
+ ret = -1;
+ goto out;
+ }
+
+ curr->next = construct->first;
+ if (curr->next)
+ curr->next->prev = curr;
+
+ curr->graph = construct;
+
+ construct->first = curr;
+
+ construct->xl_count++;
+
+ gf_log ("parser", GF_LOG_TRACE, "New node for '%s'", name);
+
+out:
+ GF_FREE (name);
+
+ return ret;
+}
+
+
+static int
+volume_type (char *type)
+{
+ extern int yylineno;
+ int32_t ret = 0;
+
+ if (!type) {
+ gf_log ("parser", GF_LOG_DEBUG, "Invalid argument type");
+ ret = -1;
+ goto out;
+ }
+
+ ret = xlator_set_type (curr, type);
+ if (ret) {
+ gf_log ("parser", GF_LOG_ERROR,
+ "Volume '%s', line %d: type '%s' is not valid or "
+ "not found on this machine",
+ curr->name, yylineno, type);
+ ret = -1;
+ goto out;
+ }
+
+ gf_log ("parser", GF_LOG_TRACE, "Type:%s:%s", curr->name, type);
+
+out:
+ GF_FREE (type);
+
+ return 0;
+}
+
+
+static int
+volume_option (char *key, char *value)
+{
+ extern int yylineno;
+ int ret = 0;
+ char *set_value = NULL;
+
+ if (!key || !value){
+ gf_log ("parser", GF_LOG_ERROR, "Invalid argument");
+ ret = -1;
+ goto out;
+ }
+
+ set_value = gf_strdup (value);
+ ret = dict_set_dynstr (curr->options, key, set_value);
+
+ if (ret == 1) {
+ gf_log ("parser", GF_LOG_ERROR,
+ "Volume '%s', line %d: duplicate entry "
+ "('option %s') present",
+ curr->name, yylineno, key);
+ ret = -1;
+ goto out;
+ }
+
+ gf_log ("parser", GF_LOG_TRACE, "Option:%s:%s:%s",
+ curr->name, key, value);
+
+out:
+ GF_FREE (key);
+ GF_FREE (value);
+
+ return 0;
+}
+
+
+static int
+volume_sub (char *sub)
+{
+ extern int yylineno;
+ xlator_t *trav = NULL;
+ xlator_list_t *xlchild = NULL;
+ xlator_list_t *tmp = NULL;
+ xlator_list_t *xlparent = NULL;
+ int ret = 0;
+
+ if (!sub) {
+ gf_log ("parser", GF_LOG_ERROR, "Invalid subvolumes argument");
+ ret = -1;
+ goto out;
+ }
+
+ trav = construct->first;
+
+ while (trav) {
+ if (!strcmp (sub, trav->name))
+ break;
+ trav = trav->next;
+ }
+
+ if (!trav) {
+ gf_log ("parser", GF_LOG_ERROR,
+ "Volume '%s', line %d: subvolume '%s' is not defined "
+ "prior to usage",
+ curr->name, yylineno, sub);
+ ret = -1;
+ goto out;
+ }
+
+ if (trav == curr) {
+ gf_log ("parser", GF_LOG_ERROR,
+ "Volume '%s', line %d: has '%s' itself as subvolume",
+ curr->name, yylineno, sub);
+ ret = -1;
+ goto out;
+ }
+
+ xlparent = (void *) GF_CALLOC (1, sizeof (*xlparent),
+ gf_common_mt_xlator_list_t);
+
+ if (!xlparent) {
+ gf_log ("parser", GF_LOG_ERROR, "Out of memory");
+ ret = -1;
+ goto out;
+ }
+
+ xlparent->xlator = curr;
+
+ tmp = trav->parents;
+ if (tmp == NULL) {
+ trav->parents = xlparent;
+ } else {
+ while (tmp->next)
+ tmp = tmp->next;
+ tmp->next = xlparent;
+ }
+
+ xlchild = (void *) GF_CALLOC (1, sizeof(*xlchild),
+ gf_common_mt_xlator_list_t);
+ if (!xlchild) {
+ gf_log ("parser", GF_LOG_ERROR, "Out of memory");
+ ret = -1;
+ goto out;
+ }
+
+ xlchild->xlator = trav;
+
+ tmp = curr->children;
+ if (tmp == NULL) {
+ curr->children = xlchild;
+ } else {
+ while (tmp->next)
+ tmp = tmp->next;
+ tmp->next = xlchild;
+ }
+
+ gf_log ("parser", GF_LOG_TRACE, "child:%s->%s", curr->name, sub);
+
+out:
+ GF_FREE (sub);
+
+ return 0;
+}
+
+
+static int
+volume_end (void)
+{
+ if (!curr->fops) {
+ gf_log ("parser", GF_LOG_ERROR,
+ "\"type\" not specified for volume %s", curr->name);
+ return -1;
+ }
+ gf_log ("parser", GF_LOG_TRACE, "end:%s", curr->name);
+
+ curr = NULL;
+ return 0;
+}
+
+
+int
+yywrap ()
+{
+ return 1;
+}
+
+
+int
+yyerror (const char *str)
+{
+ extern char *yytext;
+ extern int yylineno;
+
+ if (curr && curr->name) {
+ if (!strcmp (yytext, "volume")) {
+ gf_log ("parser", GF_LOG_ERROR,
+ "'end-volume' not defined for volume '%s'",
+ curr->name);
+ } else if (!strcmp (yytext, "type")) {
+ gf_log ("parser", GF_LOG_ERROR,
+ "line %d: duplicate 'type' defined for "
+ "volume '%s'",
+ yylineno, curr->name);
+ } else if (!strcmp (yytext, "subvolumes")) {
+ gf_log ("parser", GF_LOG_ERROR,
+ "line %d: duplicate 'subvolumes' defined for "
+ "volume '%s'",
+ yylineno, curr->name);
+ } else if (curr) {
+ gf_log ("parser", GF_LOG_ERROR,
+ "syntax error: line %d (volume '%s'): \"%s\""
+ "\nallowed tokens are 'volume', 'type', "
+ "'subvolumes', 'option', 'end-volume'()",
+ yylineno, curr->name,
+ yytext);
+ } else {
+ gf_log ("parser", GF_LOG_ERROR,
+ "syntax error: line %d (just after volume "
+ "'%s'): \"%s\"\n(%s)",
+ yylineno, curr->name,
+ yytext,
+ "allowed tokens are 'volume', 'type', "
+ "'subvolumes', 'option', 'end-volume'");
+ }
+ } else {
+ gf_log ("parser", GF_LOG_ERROR,
+ "syntax error in line %d: \"%s\" \n"
+ "(allowed tokens are 'volume', 'type', "
+ "'subvolumes', 'option', 'end-volume')\n",
+ yylineno, yytext);
+ }
+
+ return -1;
+}
+
+
+static int
+execute_cmd (char *cmd, char **result, size_t size)
+{
+ FILE *fpp = NULL;
+ int i = 0;
+ int status = 0;
+ int character = 0;
+ char *buf = *result;
+
+ fpp = popen (cmd, "r");
+ if (!fpp) {
+ gf_log ("parser", GF_LOG_ERROR, "%s: failed to popen", cmd);
+ return -1;
+ }
+
+ while ((character = fgetc (fpp)) != EOF) {
+ if (i == size) {
+ size *= 2;
+ buf = *result = GF_REALLOC (*result, size);
+ }
+
+ buf[i++] = character;
+ }
+
+ if (i > 0) {
+ i--;
+ buf[i] = '\0';
+ }
+
+ status = pclose (fpp);
+ if (status == -1 || !WIFEXITED (status) ||
+ ((WEXITSTATUS (status)) != 0)) {
+ i = -1;
+ buf[0] = '\0';
+ }
+
+ return i;
+}
+
+
+static int
+preprocess (FILE *srcfp, FILE *dstfp)
+{
+ int ret = 0;
+ int i = 0;
+ char *cmd = NULL;
+ char *result = NULL;
+ size_t cmd_buf_size = GF_CMD_BUFFER_LEN;
+ char escaped = 0;
+ char in_backtick = 0;
+ int line = 1;
+ int column = 0;
+ int backtick_line = 0;
+ int backtick_column = 0;
+ int character = 0;
+
+
+ fseek (srcfp, 0L, SEEK_SET);
+ fseek (dstfp, 0L, SEEK_SET);
+
+ cmd = GF_CALLOC (cmd_buf_size, 1,
+ gf_common_mt_char);
+ if (cmd == NULL) {
+ gf_log ("parser", GF_LOG_ERROR, "Out of memory");
+ return -1;
+ }
+
+ result = GF_CALLOC (cmd_buf_size * 2, 1,
+ gf_common_mt_char);
+ if (result == NULL) {
+ GF_FREE (cmd);
+ gf_log ("parser", GF_LOG_ERROR, "Out of memory");
+ return -1;
+ }
+
+ while ((character = fgetc (srcfp)) != EOF) {
+ if ((character == '`') && !escaped) {
+ if (in_backtick) {
+ cmd[i] = '\0';
+ result[0] = '\0';
+
+ ret = execute_cmd (cmd, &result,
+ 2 * cmd_buf_size);
+ if (ret < 0) {
+ ret = -1;
+ goto out;
+ }
+ fwrite (result, ret, 1, dstfp);
+ } else {
+ i = 0;
+ cmd[i] = '\0';
+
+ backtick_column = column;
+ backtick_line = line;
+ }
+
+ in_backtick = !in_backtick;
+ } else {
+ if (in_backtick) {
+ if (i == cmd_buf_size) {
+ cmd_buf_size *= 2;
+ cmd = GF_REALLOC (cmd, cmd_buf_size);
+ if (cmd == NULL) {
+ return -1;
+ }
+
+ result = GF_REALLOC (result,
+ 2 * cmd_buf_size);
+ if (result == NULL) {
+ GF_FREE (cmd);
+ return -1;
+ }
+ }
+
+ cmd[i++] = character;
+ } else {
+ fputc (character, dstfp);
+ }
+ }
+
+ if (character == '\\') {
+ escaped = !escaped;
+ } else {
+ escaped = 0;
+ }
+
+ if (character == '\n') {
+ line++;
+ column = 0;
+ } else {
+ column++;
+ }
+ }
+
+ if (in_backtick) {
+ gf_log ("parser", GF_LOG_ERROR,
+ "Unterminated backtick in volume specfication file at line (%d), column (%d).",
+ line, column);
+ ret = -1;
+ }
+
+out:
+ fseek (srcfp, 0L, SEEK_SET);
+ fseek (dstfp, 0L, SEEK_SET);
+ GF_FREE (cmd);
+ GF_FREE (result);
+
+ return ret;
+}
+
+
+extern FILE *yyin;
+
+glusterfs_graph_t *
+glusterfs_graph_new ()
+{
+ glusterfs_graph_t *graph = NULL;
+
+ graph = GF_CALLOC (1, sizeof (*graph),
+ gf_common_mt_glusterfs_graph_t);
+ if (!graph)
+ return NULL;
+
+ INIT_LIST_HEAD (&graph->list);
+
+ gettimeofday (&graph->dob, NULL);
+
+ return graph;
+}
+
+
+glusterfs_graph_t *
+glusterfs_graph_construct (FILE *fp)
+{
+ int ret = 0;
+ glusterfs_graph_t *graph = NULL;
+ FILE *tmp_file = NULL;
+
+ graph = glusterfs_graph_new ();
+ if (!graph)
+ return NULL;
+
+ tmp_file = tmpfile ();
+
+ if (tmp_file == NULL) {
+ gf_log ("parser", GF_LOG_ERROR,
+ "cannot create temparory file");
+
+ glusterfs_graph_destroy (graph);
+ return NULL;
+ }
+
+ ret = preprocess (fp, tmp_file);
+ if (ret < 0) {
+ gf_log ("parser", GF_LOG_ERROR,
+ "parsing of backticks failed");
+
+ glusterfs_graph_destroy (graph);
+ fclose (tmp_file);
+ return NULL;
+ }
+
+ yyin = tmp_file;
+
+ construct = graph;
+
+ ret = yyparse ();
+
+ construct = NULL;
+
+ fclose (tmp_file);
+
+ if (ret == 1) {
+ gf_log ("parser", GF_LOG_DEBUG,
+ "parsing of volfile failed, please review it "
+ "once more");
+
+ glusterfs_graph_destroy (graph);
+ return NULL;
+ }
+
+ return graph;
+}
+
diff --git a/libglusterfs/src/inode.c b/libglusterfs/src/inode.c
index 622857c1ab0..c5784595426 100644
--- a/libglusterfs/src/inode.c
+++ b/libglusterfs/src/inode.c
@@ -281,7 +281,7 @@ __inode_destroy (inode_t *inode)
if (!inode->_ctx)
goto noctx;
- for (index = 0; index < inode->table->xl->ctx->xl_count; index++) {
+ for (index = 0; index < inode->table->xl->graph->xl_count; index++) {
if (inode->_ctx[index].key) {
xl = (xlator_t *)(long)inode->_ctx[index].key;
old_THIS = THIS;
@@ -474,8 +474,9 @@ __inode_create (inode_table_t *table)
INIT_LIST_HEAD (&newi->dentry_list);
newi->_ctx = GF_CALLOC (1, (sizeof (struct _inode_ctx) *
- table->xl->ctx->xl_count),
+ table->xl->graph->xl_count),
gf_common_mt_inode_ctx);
+
if (newi->_ctx == NULL) {
gf_log ("inode", GF_LOG_ERROR, "out of memory");
LOCK_DESTROY (&newi->lock);
@@ -1173,7 +1174,7 @@ __inode_ctx_put2 (inode_t *inode, xlator_t *xlator, uint64_t value1,
int index = 0;
int put_idx = -1;
- for (index = 0; index < xlator->ctx->xl_count; index++) {
+ for (index = 0; index < xlator->graph->xl_count; index++) {
if (!inode->_ctx[index].key) {
if (put_idx == -1)
put_idx = index;
@@ -1225,12 +1226,12 @@ __inode_ctx_get2 (inode_t *inode, xlator_t *xlator, uint64_t *value1,
int index = 0;
int ret = 0;
- for (index = 0; index < xlator->ctx->xl_count; index++) {
+ for (index = 0; index < xlator->graph->xl_count; index++) {
if (inode->_ctx[index].xl_key == xlator)
break;
}
- if (index == xlator->ctx->xl_count) {
+ if (index == xlator->graph->xl_count) {
ret = -1;
goto out;
}
@@ -1277,12 +1278,12 @@ inode_ctx_del2 (inode_t *inode, xlator_t *xlator, uint64_t *value1,
LOCK (&inode->lock);
{
- for (index = 0; index < xlator->ctx->xl_count; index++) {
+ for (index = 0; index < xlator->graph->xl_count; index++) {
if (inode->_ctx[index].xl_key == xlator)
break;
}
- if (index == xlator->ctx->xl_count) {
+ if (index == xlator->graph->xl_count) {
ret = -1;
goto unlock;
}
@@ -1371,7 +1372,7 @@ inode_dump (inode_t *inode, char *prefix)
if (!inode->_ctx)
goto out;
- for (i = 0; i < inode->table->xl->ctx->xl_count; i++) {
+ for (i = 0; i < inode->table->xl->graph->xl_count; i++) {
if (inode->_ctx[i].key) {
xl = (xlator_t *)(long)inode->_ctx[i].key;
if (xl->dumpops && xl->dumpops->inodectx)
diff --git a/libglusterfs/src/latency.c b/libglusterfs/src/latency.c
index 5156e8e2551..71f9824209f 100644
--- a/libglusterfs/src/latency.c
+++ b/libglusterfs/src/latency.c
@@ -174,7 +174,7 @@ gf_latency_toggle (int signum)
{
glusterfs_ctx_t *ctx = NULL;
- ctx = get_global_ctx_ptr ();
+ ctx = glusterfs_ctx_get ();
if (ctx) {
ctx->measure_latency = !ctx->measure_latency;
diff --git a/libglusterfs/src/md5.c b/libglusterfs/src/md5.c
deleted file mode 100644
index 5f0d0d157bf..00000000000
--- a/libglusterfs/src/md5.c
+++ /dev/null
@@ -1,310 +0,0 @@
-/*
- * RFC 1321 compliant MD5 implementation
- *
- * Copyright (C) 2001-2003 Christophe Devine
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program; if not, visit the http://fsf.org website.
- */
-
-
-#include <inttypes.h>
-#include <string.h>
-
-#include "md5.h"
-
-void md5_begin(md_context *ctx)
-{
- ctx->A = 0x67452301;
- ctx->B = 0xEFCDAB89;
- ctx->C = 0x98BADCFE;
- ctx->D = 0x10325476;
-
- ctx->totalN = ctx->totalN2 = 0;
-}
-
-static void md5_process(md_context *ctx, const uint8_t data[CSUM_CHUNK])
-{
- uint32_t X[16], A, B, C, D;
-
- A = ctx->A;
- B = ctx->B;
- C = ctx->C;
- D = ctx->D;
-
- X[0] = IVAL(data, 0);
- X[1] = IVAL(data, 4);
- X[2] = IVAL(data, 8);
- X[3] = IVAL(data, 12);
- X[4] = IVAL(data, 16);
- X[5] = IVAL(data, 20);
- X[6] = IVAL(data, 24);
- X[7] = IVAL(data, 28);
- X[8] = IVAL(data, 32);
- X[9] = IVAL(data, 36);
- X[10] = IVAL(data, 40);
- X[11] = IVAL(data, 44);
- X[12] = IVAL(data, 48);
- X[13] = IVAL(data, 52);
- X[14] = IVAL(data, 56);
- X[15] = IVAL(data, 60);
-
-#define S(x,n) ((x << n) | ((x & 0xFFFFFFFF) >> (32 - n)))
-
-#define P(a,b,c,d,k,s,t) a += F(b,c,d) + X[k] + t, a = S(a,s) + b
-
-#define F(x,y,z) (z ^ (x & (y ^ z)))
-
- P(A, B, C, D, 0, 7, 0xD76AA478);
- P(D, A, B, C, 1, 12, 0xE8C7B756);
- P(C, D, A, B, 2, 17, 0x242070DB);
- P(B, C, D, A, 3, 22, 0xC1BDCEEE);
- P(A, B, C, D, 4, 7, 0xF57C0FAF);
- P(D, A, B, C, 5, 12, 0x4787C62A);
- P(C, D, A, B, 6, 17, 0xA8304613);
- P(B, C, D, A, 7, 22, 0xFD469501);
- P(A, B, C, D, 8, 7, 0x698098D8);
- P(D, A, B, C, 9, 12, 0x8B44F7AF);
- P(C, D, A, B, 10, 17, 0xFFFF5BB1);
- P(B, C, D, A, 11, 22, 0x895CD7BE);
- P(A, B, C, D, 12, 7, 0x6B901122);
- P(D, A, B, C, 13, 12, 0xFD987193);
- P(C, D, A, B, 14, 17, 0xA679438E);
- P(B, C, D, A, 15, 22, 0x49B40821);
-
-#undef F
-#define F(x,y,z) (y ^ (z & (x ^ y)))
-
- P(A, B, C, D, 1, 5, 0xF61E2562);
- P(D, A, B, C, 6, 9, 0xC040B340);
- P(C, D, A, B, 11, 14, 0x265E5A51);
- P(B, C, D, A, 0, 20, 0xE9B6C7AA);
- P(A, B, C, D, 5, 5, 0xD62F105D);
- P(D, A, B, C, 10, 9, 0x02441453);
- P(C, D, A, B, 15, 14, 0xD8A1E681);
- P(B, C, D, A, 4, 20, 0xE7D3FBC8);
- P(A, B, C, D, 9, 5, 0x21E1CDE6);
- P(D, A, B, C, 14, 9, 0xC33707D6);
- P(C, D, A, B, 3, 14, 0xF4D50D87);
- P(B, C, D, A, 8, 20, 0x455A14ED);
- P(A, B, C, D, 13, 5, 0xA9E3E905);
- P(D, A, B, C, 2, 9, 0xFCEFA3F8);
- P(C, D, A, B, 7, 14, 0x676F02D9);
- P(B, C, D, A, 12, 20, 0x8D2A4C8A);
-
-#undef F
-#define F(x,y,z) (x ^ y ^ z)
-
- P(A, B, C, D, 5, 4, 0xFFFA3942);
- P(D, A, B, C, 8, 11, 0x8771F681);
- P(C, D, A, B, 11, 16, 0x6D9D6122);
- P(B, C, D, A, 14, 23, 0xFDE5380C);
- P(A, B, C, D, 1, 4, 0xA4BEEA44);
- P(D, A, B, C, 4, 11, 0x4BDECFA9);
- P(C, D, A, B, 7, 16, 0xF6BB4B60);
- P(B, C, D, A, 10, 23, 0xBEBFBC70);
- P(A, B, C, D, 13, 4, 0x289B7EC6);
- P(D, A, B, C, 0, 11, 0xEAA127FA);
- P(C, D, A, B, 3, 16, 0xD4EF3085);
- P(B, C, D, A, 6, 23, 0x04881D05);
- P(A, B, C, D, 9, 4, 0xD9D4D039);
- P(D, A, B, C, 12, 11, 0xE6DB99E5);
- P(C, D, A, B, 15, 16, 0x1FA27CF8);
- P(B, C, D, A, 2, 23, 0xC4AC5665);
-
-#undef F
-#define F(x,y,z) (y ^ (x | ~z))
-
- P(A, B, C, D, 0, 6, 0xF4292244);
- P(D, A, B, C, 7, 10, 0x432AFF97);
- P(C, D, A, B, 14, 15, 0xAB9423A7);
- P(B, C, D, A, 5, 21, 0xFC93A039);
- P(A, B, C, D, 12, 6, 0x655B59C3);
- P(D, A, B, C, 3, 10, 0x8F0CCC92);
- P(C, D, A, B, 10, 15, 0xFFEFF47D);
- P(B, C, D, A, 1, 21, 0x85845DD1);
- P(A, B, C, D, 8, 6, 0x6FA87E4F);
- P(D, A, B, C, 15, 10, 0xFE2CE6E0);
- P(C, D, A, B, 6, 15, 0xA3014314);
- P(B, C, D, A, 13, 21, 0x4E0811A1);
- P(A, B, C, D, 4, 6, 0xF7537E82);
- P(D, A, B, C, 11, 10, 0xBD3AF235);
- P(C, D, A, B, 2, 15, 0x2AD7D2BB);
- P(B, C, D, A, 9, 21, 0xEB86D391);
-
-#undef F
-
- ctx->A += A;
- ctx->B += B;
- ctx->C += C;
- ctx->D += D;
-}
-
-void md5_update(md_context *ctx, const uint8_t *input, uint32_t length)
-{
- uint32_t left, fill;
-
- if (!length)
- return;
-
- left = ctx->totalN & 0x3F;
- fill = CSUM_CHUNK - left;
-
- ctx->totalN += length;
- ctx->totalN &= 0xFFFFFFFF;
-
- if (ctx->totalN < length)
- ctx->totalN2++;
-
- if (left && length >= fill) {
- memcpy(ctx->buffer + left, input, fill);
- md5_process(ctx, ctx->buffer);
- length -= fill;
- input += fill;
- left = 0;
- }
-
- while (length >= CSUM_CHUNK) {
- md5_process(ctx, input);
- length -= CSUM_CHUNK;
- input += CSUM_CHUNK;
- }
-
- if (length)
- memcpy(ctx->buffer + left, input, length);
-}
-
-static uint8_t md5_padding[CSUM_CHUNK] = { 0x80 };
-
-void md5_result(md_context *ctx, uint8_t digest[MD5_DIGEST_LEN])
-{
- uint32_t last, padn;
- uint32_t high, low;
- uint8_t msglen[8];
-
- high = (ctx->totalN >> 29)
- | (ctx->totalN2 << 3);
- low = (ctx->totalN << 3);
-
- SIVAL(msglen, 0, low);
- SIVAL(msglen, 4, high);
-
- last = ctx->totalN & 0x3F;
- padn = last < 56 ? 56 - last : 120 - last;
-
- md5_update(ctx, md5_padding, padn);
- md5_update(ctx, msglen, 8);
-
- SIVAL(digest, 0, ctx->A);
- SIVAL(digest, 4, ctx->B);
- SIVAL(digest, 8, ctx->C);
- SIVAL(digest, 12, ctx->D);
-}
-
-void get_md5(uint8_t *out, const uint8_t *input, int n)
-{
- md_context ctx;
- md5_begin(&ctx);
- md5_update(&ctx, input, n);
- md5_result(&ctx, out);
-}
-
-#ifdef TEST_MD5
-
-#include <stdlib.h>
-#include <stdio.h>
-
-/*
- * those are the standard RFC 1321 test vectors
- */
-
-static struct {
- char *str, *md5;
-} tests[] = {
- { "",
- "d41d8cd98f00b204e9800998ecf8427e" },
- { "a",
- "0cc175b9c0f1b6a831c399e269772661" },
- { "abc",
- "900150983cd24fb0d6963f7d28e17f72" },
- { "message digest",
- "f96b697d7cb7938d525a2f31aaf161d0" },
- { "abcdefghijklmnopqrstuvwxyz",
- "c3fcd3d76192e4007dfb496cca67e13b" },
- { "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
- "d174ab98d277d9f5a5611c2c9f419d9f" },
- { "12345678901234567890123456789012345678901234567890123456789012345678901234567890",
- "57edf4a22be3c955ac49da2e2107b67a" },
- { NULL, NULL }
-};
-
-int main(int argc, char *argv[])
-{
- FILE *f;
- int i, j;
- char output[33];
- md_context ctx;
- uint8_t buf[1000];
- uint8_t md5sum[MD5_DIGEST_LEN];
-
- if (argc < 2) {
- printf("\nMD5 Validation Tests:\n\n");
-
- for (i = 0; tests[i].str; i++) {
- char *str = tests[i].str;
- char *chk = tests[i].md5;
-
- printf(" Test %d ", i + 1);
-
- get_md5(md5sum, str, strlen(str));
-
- for (j = 0; j < MD5_DIGEST_LEN; j++)
- sprintf(output + j * 2, "%02x", md5sum[j]);
-
- if (memcmp(output, chk, 32)) {
- printf("failed!\n");
- return 1;
- }
-
- printf("passed.\n");
- }
-
- printf("\n");
- return 0;
- }
-
- while (--argc) {
- if (!(f = fopen(*++argv, "rb"))) {
- perror("fopen");
- return 1;
- }
-
- md5_begin(&ctx);
-
- while ((i = fread(buf, 1, sizeof buf, f)) > 0)
- md5_update(&ctx, buf, i);
-
- fclose(f);
-
- md5_result(&ctx, md5sum);
-
- for (j = 0; j < MD5_DIGEST_LEN; j++)
- printf("%02x", md5sum[j]);
-
- printf(" %s\n", *argv);
- }
-
- return 0;
-}
-
-#endif
diff --git a/libglusterfs/src/md5.h b/libglusterfs/src/md5.h
deleted file mode 100644
index ba8f08dbcfa..00000000000
--- a/libglusterfs/src/md5.h
+++ /dev/null
@@ -1,78 +0,0 @@
-/* rsync-3.0.6/byteorder.h */
-
-/*
- * Simple byteorder handling.
- *
- * Copyright (C) 1992-1995 Andrew Tridgell
- * Copyright (C) 2007-2008 Wayne Davison
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program; if not, visit the http://fsf.org website.
- */
-
-#undef CAREFUL_ALIGNMENT
-
-/* We know that the x86 can handle misalignment and has the same
- * byte order (LSB-first) as the 32-bit numbers we transmit. */
-
-#ifdef __i386__
-#define CAREFUL_ALIGNMENT 0
-#endif
-
-#ifndef CAREFUL_ALIGNMENT
-#define CAREFUL_ALIGNMENT 1
-#endif
-
-#define CVAL(buf,pos) (((unsigned char *)(buf))[pos])
-#define UVAL(buf,pos) ((uint32_t)CVAL(buf,pos))
-#define SCVAL(buf,pos,val) (CVAL(buf,pos) = (val))
-
-#if CAREFUL_ALIGNMENT
-#define PVAL(buf,pos) (UVAL(buf,pos)|UVAL(buf,(pos)+1)<<8)
-#define IVAL(buf,pos) (PVAL(buf,pos)|PVAL(buf,(pos)+2)<<16)
-#define SSVALX(buf,pos,val) (CVAL(buf,pos)=(val)&0xFF,CVAL(buf,pos+1)=(val)>>8)
-#define SIVALX(buf,pos,val) (SSVALX(buf,pos,val&0xFFFF),SSVALX(buf,pos+2,val>>16))
-#define SIVAL(buf,pos,val) SIVALX((buf),(pos),((uint32_t)(val)))
-#else
-
-/* this handles things for architectures like the 386 that can handle
- alignment errors */
-
-/*
- WARNING: This section is dependent on the length of int32
- being correct. set CAREFUL_ALIGNMENT if it is not.
-*/
-
-#define IVAL(buf,pos) (*(uint32_t *)((char *)(buf) + (pos)))
-#define SIVAL(buf,pos,val) IVAL(buf,pos)=((uint32_t)(val))
-#endif
-
-/* The include file for both the MD4 and MD5 routines. */
-
-#define MD5_DIGEST_LEN 16
-#define MAX_DIGEST_LEN MD5_DIGEST_LEN
-
-#define CSUM_CHUNK 64
-
-typedef struct {
- uint32_t A, B, C, D;
- uint32_t totalN; /* bit count, lower 32 bits */
- uint32_t totalN2; /* bit count, upper 32 bits */
- uint8_t buffer[CSUM_CHUNK];
-} md_context;
-
-void md5_begin(md_context *ctx);
-void md5_update(md_context *ctx, const uint8_t *input, uint32_t length);
-void md5_result(md_context *ctx, uint8_t digest[MD5_DIGEST_LEN]);
-
-void get_md5(uint8_t digest[MD5_DIGEST_LEN], const uint8_t *input, int n);
diff --git a/libglusterfs/src/mem-types.h b/libglusterfs/src/mem-types.h
index daf680eb2a7..e8d4df5f18f 100644
--- a/libglusterfs/src/mem-types.h
+++ b/libglusterfs/src/mem-types.h
@@ -77,6 +77,7 @@ enum gf_common_mem_types_ {
gf_common_mt_rpcsvc_conn_t,
gf_common_mt_rpcsvc_program_t,
gf_common_mt_rpcsvc_stage_t,
+ gf_common_mt_glusterfs_graph_t,
gf_common_mt_end
};
#endif
diff --git a/libglusterfs/src/spec.y b/libglusterfs/src/spec.y
deleted file mode 100644
index 805e1e1fbae..00000000000
--- a/libglusterfs/src/spec.y
+++ /dev/null
@@ -1,626 +0,0 @@
-/*
- Copyright (c) 2006-2009 Gluster, Inc. <http://www.gluster.com>
- This file is part of GlusterFS.
-
- GlusterFS is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published
- by the Free Software Foundation; either version 3 of the License,
- or (at your option) any later version.
-
- GlusterFS is distributed in the hope that it will be useful, but
- WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program. If not, see
- <http://www.gnu.org/licenses/>.
-*/
-
-
-%token SECTION_BEGIN SECTION_END OPTION NEWLINE SUBSECTION ID WHITESPACE COMMENT TYPE STRING_TOK
-
-%{
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-#include <errno.h>
-#include <sys/mman.h>
-#include <sys/types.h>
-#include <sys/wait.h>
-
-#include "xlator.h"
-#include "logging.h"
-
-static int new_section (char *name);
-static int section_type (char *type);
-static int section_option (char *key, char *value);
-static int section_sub (char *sub);
-static int section_end (void);
-static void sub_error (void);
-static void type_error (void);
-static void option_error (void);
-
-#define YYSTYPE char *
-#define GF_CMD_BUFFER_LEN (8 * GF_UNIT_KB)
-
-int yyerror (const char *);
-int yylex ();
-%}
-
-
-%%
-SECTIONS: SECTION | SECTIONS SECTION;
-
-SECTION: SECTION_HEADER SECTION_DATA SECTION_FOOTER;
-SECTION_HEADER: SECTION_BEGIN WORD {if( -1 == new_section ($2)) { YYABORT; } };
-SECTION_FOOTER: SECTION_END {if( -1 == section_end ()) { YYABORT; } };
-
-SECTION_DATA: TYPE_LINE OPTIONS_LINE SUBSECTION_LINE OPTIONS_LINE |
- TYPE_LINE SUBSECTION_LINE OPTIONS_LINE |
- TYPE_LINE OPTIONS_LINE SUBSECTION_LINE |
- TYPE_LINE SUBSECTION_LINE |
- TYPE_LINE OPTIONS_LINE |
- OPTIONS_LINE SUBSECTION_LINE OPTIONS_LINE | /* error case */
- OPTIONS_LINE; /* error case */
-
-TYPE_LINE: TYPE WORD {if ( -1 == section_type ($2)) { YYABORT; }} | TYPE { type_error(); YYABORT; };
-
-SUBSECTION_LINE: SUBSECTION WORDS | SUBSECTION { sub_error (); YYABORT; };
-
-OPTIONS_LINE: OPTION_LINE | OPTIONS_LINE OPTION_LINE;
-
-OPTION_LINE: OPTION WORD WORD {if(-1 == section_option($2,$3)){YYABORT;} } |
- OPTION WORD { option_error (); YYABORT; } |
- OPTION { option_error (); YYABORT; };
-
-WORDS: WORD {if (-1 == section_sub ($1)) {YYABORT; } } | WORDS WORD { if (-1 == section_sub ($2)) { YYABORT; } };
-WORD: ID | STRING_TOK ;
-%%
-
-xlator_t *complete_tree = NULL;
-xlator_t *tree = NULL;
-glusterfs_ctx_t *gctx;
-
-static void
-type_error (void)
-{
- extern int yylineno;
-
- fprintf (stderr, "Volume '%s', before line %d: Please specify volume 'type'.",
- complete_tree->name, yylineno);
- gf_log ("parser", GF_LOG_ERROR,
- "Volume '%s', before line %d: Please specify volume 'type'.",
- complete_tree->name, yylineno);
- return;
-}
-
-static void
-sub_error (void)
-{
- extern int yylineno;
-
- fprintf (stderr, "Volume %s, before line %d: Please specify subvolumes for the volume. ",
- complete_tree->name, yylineno);
- gf_log ("parser", GF_LOG_ERROR,
- "Volume %s, before line %d: Please specify subvolumes for the volume. ",
- complete_tree->name, yylineno);
- return;
-}
-
-static void
-option_error (void)
-{
- extern int yylineno;
-
- fprintf (stderr, "Volume %s, before line %d: Please specify "
- "option <key> <value> \n",
- complete_tree->name, yylineno);
- gf_log ("parser", GF_LOG_ERROR,
- "Volume %s, before line %d: Please specify "
- "option <key> <value>",
- complete_tree->name, yylineno);
- return;
-}
-
-static int
-cut_tree (xlator_t *tree)
-{
- xlator_t *trav = tree, *prev = tree;
-
- if (!tree) {
- gf_log ("parser", GF_LOG_DEBUG, "Translator tree not found");
- return -1;
- }
-
- gf_log ("parser", GF_LOG_DEBUG, "Failed to build translator graph");
-
- while (prev) {
- trav = prev->next;
- dict_destroy (prev->options);
- FREE (prev->name);
- FREE (prev);
- prev = trav;
- }
-
- return 0;
-}
-
-
-static int
-new_section (char *name)
-{
- extern int yylineno;
- xlator_t *trav = complete_tree;
- xlator_t *node = NULL;
-
- node = (void *) calloc (1, sizeof (*node));
- if (!node) {
- gf_log ("parser", GF_LOG_ERROR, "Out of memory");
- return -1;
- }
-
- if (!name) {
- gf_log ("parser", GF_LOG_DEBUG,
- "Invalid argument name: '%s'", name);
- FREE (node);
- return -1;
- }
-
- while (trav) {
- if (!strcmp (name, trav->name)) {
- fprintf (stderr,
- "Line %d: volume '%s' defined again\n",
- yylineno, name);
- gf_log ("parser", GF_LOG_ERROR,
- "Line %d: volume '%s' defined again",
- yylineno, name);
- return -1;
- }
- trav = trav->next;
- }
-
- node->ctx = gctx;
- node->name = name;
- node->next = complete_tree;
- if (complete_tree)
- complete_tree->prev = node;
- node->options = get_new_dict ();
- complete_tree = node;
-
- tree = node;
- gf_log ("parser", GF_LOG_TRACE, "New node for '%s'", name);
-
- return 0;
-}
-
-static int
-section_type (char *type)
-{
- extern int yylineno;
- int32_t ret = -1;
- if (!type) {
- gf_log ("parser", GF_LOG_DEBUG, "Invalid argument type");
- return -1;
- }
-
- ret = xlator_set_type (tree, type);
- if (ret) {
- fprintf (stderr, "Volume '%s', line %d: type '%s' is not "
- "valid or not found on this machine\n",
- complete_tree->name, yylineno, type);
- gf_log ("parser", GF_LOG_ERROR,
- "Volume '%s', line %d: type '%s' is not valid or "
- "not found on this machine",
- complete_tree->name, yylineno, type);
- return -1;
- }
- gf_log ("parser", GF_LOG_TRACE, "Type:%s:%s", tree->name, type);
-
- return 0;
-}
-
-
-static int
-section_option (char *key, char *value)
-{
- extern int yylineno;
-
- int ret = 0;
-
- if (!key || !value){
- fprintf (stderr, "Invalid argument\n");
- gf_log ("parser", GF_LOG_ERROR, "Invalid argument");
- return -1;
- }
-
- ret = dict_set (tree->options, key, str_to_data (value));
-
- if (ret == 1) {
- gf_log ("parser", GF_LOG_ERROR,
- "Volume '%s', line %d: duplicate entry "
- "('option %s') present",
- tree->name, yylineno, key);
- return -1;
- }
- gf_log ("parser", GF_LOG_TRACE, "Option:%s:%s:%s",
- tree->name, key, value);
-
- return 0;
-}
-
-static int
-section_sub (char *sub)
-{
- extern int yylineno;
- xlator_t *trav = complete_tree;
- xlator_list_t *xlchild, *tmp, *xlparent;
-
- if (!sub) {
- fprintf (stderr, "Invalid subvolumes argument\n");
- gf_log ("parser", GF_LOG_ERROR, "Invalid subvolumes argument");
- return -1;
- }
-
- while (trav) {
- if (!strcmp (sub, trav->name))
- break;
- trav = trav->next;
- }
- if (!trav) {
- fprintf (stderr,
- "Volume '%s', line %d: subvolume '%s' is not "
- "defined prior to usage\n",
- complete_tree->name, yylineno, sub);
- gf_log ("parser", GF_LOG_ERROR,
- "Volume '%s', line %d: subvolume '%s' is not defined "
- "prior to usage",
- complete_tree->name, yylineno, sub);
- return -1;
- }
-
- if (trav == tree) {
- fprintf (stderr, "Volume '%s', line %d: has '%s' itself as "
- "subvolume\n",
- complete_tree->name, yylineno, sub);
- gf_log ("parser", GF_LOG_ERROR,
- "Volume '%s', line %d: has '%s' itself as subvolume",
- complete_tree->name, yylineno, sub);
- return -1;
- }
-
- xlparent = (void *) calloc (1, sizeof (*xlparent));
- if (!xlparent) {
- gf_log ("parser", GF_LOG_ERROR, "Out of memory");
- return -1;
- }
- xlparent->xlator = tree;
-
- tmp = trav->parents;
- if (tmp == NULL) {
- trav->parents = xlparent;
- } else {
- while (tmp->next)
- tmp = tmp->next;
- tmp->next = xlparent;
- }
-
- xlchild = (void *) calloc (1, sizeof(*xlchild));
- if (!xlchild) {
- FREE (xlparent);
- gf_log ("parser", GF_LOG_ERROR, "Out of memory");
- return -1;
- }
- xlchild->xlator = trav;
-
- tmp = tree->children;
- if (tmp == NULL) {
- tree->children = xlchild;
- } else {
- while (tmp->next)
- tmp = tmp->next;
- tmp->next = xlchild;
- }
-
- gf_log ("parser", GF_LOG_TRACE, "child:%s->%s", tree->name, sub);
-
- return 0;
-}
-
-static int
-section_end (void)
-{
- if (!tree->fops) {
- fprintf (stderr,
- "\"type\" not specified for volume %s\n", tree->name);
- gf_log ("parser", GF_LOG_ERROR,
- "\"type\" not specified for volume %s", tree->name);
- return -1;
- }
- gf_log ("parser", GF_LOG_TRACE, "end:%s", tree->name);
-
- tree = NULL;
- return 0;
-}
-
-int
-yywrap ()
-{
- return 1;
-}
-
-int
-yyerror (const char *str)
-{
- extern char *yytext;
- extern int yylineno;
-
- if (complete_tree && complete_tree->name)
- {
- if (!strcmp (yytext, "volume"))
- {
- fprintf (stderr,
- "'end-volume' not defined for volume '%s'\n",
- complete_tree->name);
- gf_log ("parser", GF_LOG_ERROR,
- "'end-volume' not defined for volume '%s'",
- complete_tree->name);
- }
- else if (!strcmp (yytext, "type"))
- {
- fprintf (stderr, "line %d: duplicate 'type' defined "
- "for volume '%s'",
- yylineno, complete_tree->name);
- gf_log ("parser", GF_LOG_ERROR,
- "line %d: duplicate 'type' defined for "
- "volume '%s'",
- yylineno, complete_tree->name);
- }
- else if (!strcmp (yytext, "subvolumes"))
- {
- fprintf (stderr, "line %d: duplicate 'subvolumes' "
- "defined for volume '%s'",
- yylineno, complete_tree->name);
- gf_log ("parser", GF_LOG_ERROR,
- "line %d: duplicate 'subvolumes' defined for "
- "volume '%s'",
- yylineno, complete_tree->name);
- }
- else if (tree)
- {
- fprintf (stderr,
- "syntax error: line %d (volume '%s'): \"%s\""
- "\nallowed tokens are 'volume', 'type', "
- "'subvolumes', 'option', 'end-volume'",
- yylineno, complete_tree->name,
- yytext);
-
- gf_log ("parser", GF_LOG_ERROR,
- "syntax error: line %d (volume '%s'): \"%s\""
- "\nallowed tokens are 'volume', 'type', "
- "'subvolumes', 'option', 'end-volume'()",
- yylineno, complete_tree->name,
- yytext);
- }
- else
- {
- fprintf (stderr,
- "syntax error: line %d (just after volume "
- "'%s'): \"%s\"\n(%s)",
- yylineno, complete_tree->name,
- yytext,
- "allowed tokens are 'volume', 'type', "
- "'subvolumes', 'option', 'end-volume'");
- gf_log ("parser", GF_LOG_ERROR,
- "syntax error: line %d (just after volume "
- "'%s'): \"%s\"\n(%s)",
- yylineno, complete_tree->name,
- yytext,
- "allowed tokens are 'volume', 'type', "
- "'subvolumes', 'option', 'end-volume'");
- }
- }
- else
- {
- fprintf (stderr,
- "syntax error in line %d: \"%s\" \n"
- "(allowed tokens are 'volume', 'type', "
- "'subvolumes', 'option', 'end-volume')\n",
- yylineno, yytext);
- gf_log ("parser", GF_LOG_ERROR,
- "syntax error in line %d: \"%s\" \n"
- "(allowed tokens are 'volume', 'type', "
- "'subvolumes', 'option', 'end-volume')\n",
- yylineno, yytext);
- }
-
- cut_tree (tree);
- complete_tree = NULL;
- return 0;
-}
-
-static int
-execute_cmd (char *cmd, char **result, size_t size)
-{
- FILE *fpp = NULL;
- int i = 0, status = 0;
- int character = 0;
- char *buf = *result;
-
- fpp = popen (cmd, "r");
- if (!fpp) {
- gf_log ("parser", GF_LOG_ERROR, "%s: failed to popen", cmd);
- return -1;
- }
-
- while ((character = fgetc (fpp)) != EOF) {
- if (i == size) {
- size *= 2;
- buf = *result = realloc (*result, size);
- }
-
- buf[i++] = character;
- }
-
- if (i > 0) {
- i--;
- buf[i] = '\0';
- }
-
- status = pclose (fpp);
- if (status == -1 || !WIFEXITED (status) ||
- ((WEXITSTATUS (status)) != 0)) {
- i = -1;
- buf[0] = '\0';
- }
-
- return i;
-}
-
-static int
-parse_backtick (FILE *srcfp, FILE *dstfp)
-{
- int ret = 0, i = 0;
- char *cmd = NULL, *result = NULL;
- size_t cmd_buf_size = GF_CMD_BUFFER_LEN;
- char escaped = 0, in_backtick = 0;
- int line = 1, column = 0, backtick_line = 0, backtick_column = 0;
- int character = 0;
-
- fseek (srcfp, 0L, SEEK_SET);
- fseek (dstfp, 0L, SEEK_SET);
-
- cmd = CALLOC (cmd_buf_size, 1);
- if (cmd == NULL) {
- gf_log ("parser", GF_LOG_ERROR, "Out of memory");
- return -1;
- }
-
- result = CALLOC (cmd_buf_size * 2, 1);
- if (result == NULL) {
- FREE (cmd);
- gf_log ("parser", GF_LOG_ERROR, "Out of memory");
- return -1;
- }
-
- while ((character = fgetc (srcfp)) != EOF) {
- if ((character == '`') && !escaped) {
- if (in_backtick) {
- cmd[i] = '\0';
- result[0] = '\0';
-
- ret = execute_cmd (cmd, &result,
- 2 * cmd_buf_size);
- if (ret < 0) {
- ret = -1;
- goto out;
- }
- fwrite (result, ret, 1, dstfp);
- } else {
- i = 0;
- cmd[i] = '\0';
-
- backtick_column = column;
- backtick_line = line;
- }
-
- in_backtick = !in_backtick;
- } else {
- if (in_backtick) {
- if (i == cmd_buf_size) {
- cmd_buf_size *= 2;
- cmd = realloc (cmd, cmd_buf_size);
- if (cmd == NULL) {
- return -1;
- }
-
- result = realloc (result,
- 2 * cmd_buf_size);
- if (result == NULL) {
- free (cmd);
- return -1;
- }
- }
-
- cmd[i++] = character;
- } else {
- fputc (character, dstfp);
- }
- }
-
- if (character == '\\') {
- escaped = !escaped;
- } else {
- escaped = 0;
- }
-
- if (character == '\n') {
- line++;
- column = 0;
- } else {
- column++;
- }
- }
-
- if (in_backtick) {
- gf_log ("parser", GF_LOG_ERROR,
- "Unterminated backtick in volume specfication file at line (%d), column (%d).",
- line, column);
- ret = -1;
- }
-
-out:
- fseek (srcfp, 0L, SEEK_SET);
- fseek (dstfp, 0L, SEEK_SET);
- free (cmd);
- free (result);
-
- return ret;
-}
-
-extern FILE *yyin;
-xlator_t *
-file_to_xlator_tree (glusterfs_ctx_t *ctx,
- FILE *fp)
-{
- int32_t ret = 0;
- xlator_t *tmp_tree = NULL;
- FILE *tmp_file = NULL;
- char *buffer = NULL;
-
- tmp_file = tmpfile ();
- if (NULL == tmp_file) {
- gf_log ("parser", GF_LOG_ERROR,
- "cannot create temparory file");
- return NULL;
- }
-
- ret = parse_backtick (fp, tmp_file);
- if (ret < 0) {
- gf_log ("parser", GF_LOG_ERROR,
- "parsing of backticks failed");
- fclose (tmp_file);
- FREE (buffer);
- return NULL;
- }
-
- gctx = ctx;
- yyin = tmp_file;
- ret = yyparse ();
-
- fclose (tmp_file);
- FREE (buffer);
-
- if (1 == ret) {
- gf_log ("parser", GF_LOG_DEBUG,
- "parsing of volfile failed, please review it "
- "once more");
- tree = complete_tree = NULL;
- return NULL;
- }
-
- tmp_tree = complete_tree;
- tree = complete_tree = NULL;
-
- return tmp_tree;
-}
diff --git a/libglusterfs/src/stack.h b/libglusterfs/src/stack.h
index 48b5587ac4f..ac69e389f22 100644
--- a/libglusterfs/src/stack.h
+++ b/libglusterfs/src/stack.h
@@ -143,7 +143,7 @@ FRAME_DESTROY (call_frame_t *frame)
static inline void
STACK_DESTROY (call_stack_t *stack)
{
- glusterfs_ctx_t *ctx = get_global_ctx_ptr ();
+ glusterfs_ctx_t *ctx = glusterfs_ctx_get ();
if (ctx && ctx->measure_latency) {
gettimeofday (&stack->frames.end, NULL);
@@ -330,18 +330,18 @@ copy_frame (call_frame_t *frame)
{
list_add (&newstack->all_frames, &oldstack->all_frames);
newstack->pool->cnt++;
-
}
UNLOCK (&oldstack->pool->lock);
return &newstack->frames;
}
+
static inline call_frame_t *
create_frame (xlator_t *xl, call_pool_t *pool)
{
- call_stack_t *stack = NULL;
- glusterfs_ctx_t *ctx = get_global_ctx_ptr ();
+ call_stack_t *stack = NULL;
+ glusterfs_ctx_t *ctx = glusterfs_ctx_get ();
if (!xl || !pool) {
return NULL;
diff --git a/libglusterfs/src/statedump.c b/libglusterfs/src/statedump.c
index 678ed6c8ecd..6f30a30ea78 100644
--- a/libglusterfs/src/statedump.c
+++ b/libglusterfs/src/statedump.c
@@ -33,17 +33,20 @@ extern xlator_t global_xlator;
static pthread_mutex_t gf_proc_dump_mutex;
static int gf_dump_fd = -1;
-static void
+
+static void
gf_proc_dump_lock (void)
{
- pthread_mutex_lock(&gf_proc_dump_mutex);
+ pthread_mutex_lock (&gf_proc_dump_mutex);
}
-static void
+
+static void
gf_proc_dump_unlock (void)
{
- pthread_mutex_unlock(&gf_proc_dump_mutex);
-}
+ pthread_mutex_unlock (&gf_proc_dump_mutex);
+}
+
static int
gf_proc_dump_open (void)
@@ -51,10 +54,10 @@ gf_proc_dump_open (void)
char path[256];
int dump_fd = -1;
- memset(path, 0, sizeof(path));
- snprintf(path, sizeof(path), "%s.%d",GF_DUMP_LOGFILE_ROOT, getpid());
+ memset (path, 0, sizeof (path));
+ snprintf (path, sizeof (path), "%s.%d", GF_DUMP_LOGFILE_ROOT, getpid ());
- dump_fd = open(path, O_CREAT|O_RDWR|O_TRUNC|O_APPEND, 0600);
+ dump_fd = open (path, O_CREAT|O_RDWR|O_TRUNC|O_APPEND, 0600);
if (dump_fd < 0) {
gf_log("", GF_LOG_ERROR, "Unable to open file: %s"
" errno: %d", path, errno);
@@ -65,56 +68,59 @@ gf_proc_dump_open (void)
return 0;
}
+
static void
gf_proc_dump_close (void)
{
- close(gf_dump_fd);
+ close (gf_dump_fd);
gf_dump_fd = -1;
}
+
void
-gf_proc_dump_add_section (char *key, ...)
+gf_proc_dump_add_section (char *key, ...)
{
-
+
char buf[GF_DUMP_MAX_BUF_LEN];
va_list ap;
int ret;
assert(key);
-
- memset(buf, 0, sizeof(buf));
- snprintf(buf, GF_DUMP_MAX_BUF_LEN, "\n[");
- va_start(ap, key);
- vsnprintf(buf + strlen(buf),
- GF_DUMP_MAX_BUF_LEN - strlen(buf), key, ap);
- va_end(ap);
- snprintf(buf + strlen(buf),
- GF_DUMP_MAX_BUF_LEN - strlen(buf), "]\n");
- ret = write(gf_dump_fd, buf, strlen(buf));
+
+ memset (buf, 0, sizeof(buf));
+ snprintf (buf, GF_DUMP_MAX_BUF_LEN, "\n[");
+ va_start (ap, key);
+ vsnprintf (buf + strlen(buf),
+ GF_DUMP_MAX_BUF_LEN - strlen (buf), key, ap);
+ va_end (ap);
+ snprintf (buf + strlen(buf),
+ GF_DUMP_MAX_BUF_LEN - strlen (buf), "]\n");
+ ret = write (gf_dump_fd, buf, strlen (buf));
}
+
void
-gf_proc_dump_write (char *key, char *value,...)
-{
-
- char buf[GF_DUMP_MAX_BUF_LEN];
- int offset = 0;
+gf_proc_dump_write (char *key, char *value,...)
+{
+
+ char buf[GF_DUMP_MAX_BUF_LEN];
+ int offset = 0;
va_list ap;
int ret;
-
- offset = strlen(key);
-
- memset(buf, 0, GF_DUMP_MAX_BUF_LEN);
- snprintf(buf, GF_DUMP_MAX_BUF_LEN, "%s",key);
- snprintf(buf + offset, GF_DUMP_MAX_BUF_LEN - offset, "=");
+
+ offset = strlen (key);
+
+ memset (buf, 0, GF_DUMP_MAX_BUF_LEN);
+ snprintf (buf, GF_DUMP_MAX_BUF_LEN, "%s", key);
+ snprintf (buf + offset, GF_DUMP_MAX_BUF_LEN - offset, "=");
offset += 1;
- va_start(ap, value);
- vsnprintf(buf + offset, GF_DUMP_MAX_BUF_LEN - offset, value, ap);
- va_end(ap);
+ va_start (ap, value);
+ vsnprintf (buf + offset, GF_DUMP_MAX_BUF_LEN - offset, value, ap);
+ va_end (ap);
- offset = strlen(buf);
- snprintf(buf + offset, GF_DUMP_MAX_BUF_LEN - offset, "\n");
- ret = write(gf_dump_fd, buf, strlen(buf));
+ offset = strlen (buf);
+ snprintf (buf + offset, GF_DUMP_MAX_BUF_LEN - offset, "\n");
+ ret = write (gf_dump_fd, buf, strlen (buf));
}
static void
@@ -165,20 +171,20 @@ gf_proc_dump_mem_info ()
#ifdef HAVE_MALLOC_STATS
struct mallinfo info;
- memset(&info, 0, sizeof(struct mallinfo));
- info = mallinfo();
-
- gf_proc_dump_add_section("mallinfo");
- gf_proc_dump_write("mallinfo_arena", "%d", info.arena);
- gf_proc_dump_write("mallinfo_ordblks", "%d", info.ordblks);
- gf_proc_dump_write("mallinfo_smblks","%d", info.smblks);
- gf_proc_dump_write("mallinfo_hblks","%d", info.hblks);
- gf_proc_dump_write("mallinfo_hblkhd", "%d", info.hblkhd);
- gf_proc_dump_write("mallinfo_usmblks","%d", info.usmblks);
- gf_proc_dump_write("mallinfo_fsmblks","%d", info.fsmblks);
- gf_proc_dump_write("mallinfo_uordblks","%d", info.uordblks);
- gf_proc_dump_write("mallinfo_fordblks", "%d", info.fordblks);
- gf_proc_dump_write("mallinfo_keepcost", "%d", info.keepcost);
+ memset (&info, 0, sizeof (struct mallinfo));
+ info = mallinfo ();
+
+ gf_proc_dump_add_section ("mallinfo");
+ gf_proc_dump_write ("mallinfo_arena", "%d", info.arena);
+ gf_proc_dump_write ("mallinfo_ordblks", "%d", info.ordblks);
+ gf_proc_dump_write ("mallinfo_smblks", "%d", info.smblks);
+ gf_proc_dump_write ("mallinfo_hblks", "%d", info.hblks);
+ gf_proc_dump_write ("mallinfo_hblkhd", "%d", info.hblkhd);
+ gf_proc_dump_write ("mallinfo_usmblks", "%d", info.usmblks);
+ gf_proc_dump_write ("mallinfo_fsmblks", "%d", info.fsmblks);
+ gf_proc_dump_write ("mallinfo_uordblks", "%d", info.uordblks);
+ gf_proc_dump_write ("mallinfo_fordblks", "%d", info.fordblks);
+ gf_proc_dump_write ("mallinfo_keepcost", "%d", info.keepcost);
#endif
gf_proc_dump_xlator_mem_info(&global_xlator);
@@ -203,12 +209,11 @@ gf_proc_dump_xlator_info (xlator_t *this_xl)
continue;
}
if (this_xl->dumpops->priv)
- this_xl->dumpops->priv(this_xl);
+ this_xl->dumpops->priv (this_xl);
if (this_xl->dumpops->inode)
- this_xl->dumpops->inode(this_xl);
+ this_xl->dumpops->inode (this_xl);
if (this_xl->dumpops->fd)
- this_xl->dumpops->fd(this_xl);
-
+ this_xl->dumpops->fd (this_xl);
this_xl = this_xl->next;
}
@@ -221,44 +226,45 @@ gf_proc_dump_info (int signum)
{
int ret = -1;
glusterfs_ctx_t *ctx = NULL;
-
- gf_proc_dump_lock();
- ret = gf_proc_dump_open();
- if (ret < 0)
+
+ gf_proc_dump_lock ();
+ ret = gf_proc_dump_open ();
+ if (ret < 0)
goto out;
- gf_proc_dump_mem_info();
- ctx = get_global_ctx_ptr();
+ gf_proc_dump_mem_info ();
+ ctx = glusterfs_ctx_get ();
if (ctx) {
- iobuf_stats_dump(ctx->iobuf_pool);
- gf_proc_dump_pending_frames(ctx->pool);
- gf_proc_dump_xlator_info(ctx->graph);
+ iobuf_stats_dump (ctx->iobuf_pool);
+ gf_proc_dump_pending_frames (ctx->pool);
+ gf_proc_dump_xlator_info (ctx->active->first);
}
-
- gf_proc_dump_close();
+
+ gf_proc_dump_close ();
out:
- gf_proc_dump_unlock();
+ gf_proc_dump_unlock ();
return;
}
-void
+
+void
gf_proc_dump_fini (void)
{
- pthread_mutex_destroy(&gf_proc_dump_mutex);
+ pthread_mutex_destroy (&gf_proc_dump_mutex);
}
void
gf_proc_dump_init ()
{
- pthread_mutex_init(&gf_proc_dump_mutex, NULL);
+ pthread_mutex_init (&gf_proc_dump_mutex, NULL);
return;
}
+
void
gf_proc_dump_cleanup (void)
{
- pthread_mutex_destroy(&gf_proc_dump_mutex);
+ pthread_mutex_destroy (&gf_proc_dump_mutex);
}
-
diff --git a/libglusterfs/src/xlator.c b/libglusterfs/src/xlator.c
index 4a0de300163..e9ace1714ca 100644
--- a/libglusterfs/src/xlator.c
+++ b/libglusterfs/src/xlator.c
@@ -703,6 +703,7 @@ xlator_set_type (xlator_t *xl,
gf_log ("xlator", GF_LOG_DEBUG, "%s", dlerror ());
return -1;
}
+ xl->dlhandle = handle;
if (!(xl->fops = dlsym (handle, "fops"))) {
gf_log ("xlator", GF_LOG_DEBUG, "dlsym(fops) on %s",
@@ -813,52 +814,26 @@ xlator_search_by_name (xlator_t *any, const char *name)
}
-static int32_t
-xlator_init_rec (xlator_t *xl)
+static int
+__xlator_init(xlator_t *xl)
{
- xlator_t *trav = NULL;
- int32_t ret = 0;
+ xlator_t *old_THIS = NULL;
+ int ret = 0;
- if (xl == NULL) {
- gf_log ("xlator", GF_LOG_DEBUG, "invalid argument");
- return 0;
- }
+ old_THIS = THIS;
+ THIS = xl;
- trav = xl;
- while (trav->prev)
- trav = trav->prev;
+ ret = xl->init (xl);
- while (trav) {
- ret = -1;
- if (trav->mem_acct_init)
- trav->mem_acct_init (trav);
- if (trav->init && !trav->ready) {
- ret = xlator_init (trav);
- if (ret) {
- gf_log (trav->name, GF_LOG_ERROR,
- "Initialization of volume '%s' failed,"
- " review your volfile again",
- trav->name);
- break;
- } else {
- trav->init_succeeded = 1;
- }
- } else {
- gf_log (trav->name, GF_LOG_DEBUG, "No init() found");
- }
- /* This 'xl' is checked */
- trav->ready = 1;
- trav = trav->next;
- }
+ THIS = old_THIS;
- return ret;
+ return ret;
}
-int32_t
-xlator_tree_init (xlator_t *xl)
+int
+xlator_init (xlator_t *xl)
{
- xlator_t *top = NULL;
int32_t ret = 0;
if (xl == NULL) {
@@ -866,17 +841,30 @@ xlator_tree_init (xlator_t *xl)
return 0;
}
- top = xl;
-/*
- while (top->parents)
- top = top->parents->xlator;
-*/
- ret = xlator_init_rec (top);
+ ret = -1;
- if (ret == 0 && top->notify) {
- top->notify (top, GF_EVENT_PARENT_UP, NULL);
- }
+ if (xl->mem_acct_init)
+ xl->mem_acct_init (xl);
+
+ if (!xl->init) {
+ gf_log (xl->name, GF_LOG_DEBUG, "No init() found");
+ goto out;
+ }
+
+ ret = __xlator_init (xl);
+ if (ret) {
+ gf_log (xl->name, GF_LOG_ERROR,
+ "Initialization of volume '%s' failed,"
+ " review your volfile again",
+ xl->name);
+ goto out;
+ }
+
+ xl->init_succeeded = 1;
+
+ ret = 0;
+out:
return ret;
}
@@ -932,22 +920,6 @@ xlator_notify (xlator_t *xl, int event, void *data, ...)
int
-xlator_init (xlator_t *xl)
-{
- xlator_t *old_THIS = NULL;
- int ret = 0;
-
- old_THIS = THIS;
- THIS = xl;
-
- ret = xl->init (xl);
-
- THIS = old_THIS;
-
- return ret;
-}
-
-int
xlator_mem_acct_init (xlator_t *xl, int num_types)
{
int i = 0;
@@ -1064,3 +1036,43 @@ loc_copy (loc_t *dst, loc_t *src)
out:
return ret;
}
+
+
+int
+xlator_list_destroy (xlator_list_t *list)
+{
+ xlator_list_t *next = NULL;
+
+ while (list) {
+ next = list->next;
+ GF_FREE (list);
+ list = next;
+ }
+
+ return 0;
+}
+
+
+int
+xlator_destroy (xlator_t *xl)
+{
+ if (!xl)
+ return 0;
+
+ if (xl->name)
+ GF_FREE (xl->name);
+ if (xl->type)
+ GF_FREE (xl->type);
+ if (xl->dlhandle)
+ dlclose (xl->dlhandle);
+ if (xl->options)
+ dict_destroy (xl->options);
+
+ xlator_list_destroy (xl->children);
+
+ xlator_list_destroy (xl->parents);
+
+ GF_FREE (xl);
+
+ return 0;
+}
diff --git a/libglusterfs/src/xlator.h b/libglusterfs/src/xlator.h
index 8217101e2ab..142423da2f3 100644
--- a/libglusterfs/src/xlator.h
+++ b/libglusterfs/src/xlator.h
@@ -30,7 +30,6 @@
#include <inttypes.h>
-#include "glusterfs.h"
#include "logging.h"
#include "common-utils.h"
#include "dict.h"
@@ -819,10 +818,11 @@ struct _xlator {
dict_t *options;
/* Set after doing dlopen() */
+ void *dlhandle;
struct xlator_fops *fops;
struct xlator_cbks *cbks;
struct xlator_dumpops *dumpops;
- struct list_head volume_options; /* list of volume_option_t */
+ struct list_head volume_options; /* list of volume_option_t */
void (*fini) (xlator_t *this);
int32_t (*init) (xlator_t *this);
@@ -833,12 +833,13 @@ struct _xlator {
fop_latency_t latencies[GF_FOP_MAXVALUE];
/* Misc */
- glusterfs_ctx_t *ctx;
- inode_table_t *itable;
- char ready;
- char init_succeeded;
- void *private;
- struct mem_acct mem_acct;
+ glusterfs_ctx_t *ctx;
+ glusterfs_graph_t *graph; /* not set for fuse */
+ inode_table_t *itable;
+ char ready;
+ char init_succeeded;
+ void *private;
+ struct mem_acct mem_acct;
};
#define xlator_has_parent(xl) (xl->parents != NULL)
@@ -852,6 +853,7 @@ xlator_t *file_to_xlator_tree (glusterfs_ctx_t *ctx,
int xlator_notify (xlator_t *this, int32_t event, void *data, ...);
int xlator_init (xlator_t *this);
+int xlator_destroy (xlator_t *xl);
int32_t xlator_tree_init (xlator_t *xl);
int32_t xlator_tree_free (xlator_t *xl);
generated by cgit (git 2.34.1) at 2024-11-14 15:18:01 +0000