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
author: Anand Avati <avati@gluster.com> 2010-06-07 12:37:34 +0000
committer: Anand V. Avati <avati@dev.gluster.com> 2010-06-07 11:58:50 -0700
commit: 79241696fbdebe2583298f12cbaee068ce60c655 (patch)
tree: 42e60d351e328fa34f17242c6c3359a8c01e8fa3 /libglusterfs/src
parent: c4ebd25a176d6d51d702b1009e261c3c27237a48 (diff)
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);
author	Anand Avati <avati@gluster.com>	2010-06-07 12:37:34 +0000
committer	Anand V. Avati <avati@dev.gluster.com>	2010-06-07 11:58:50 -0700
commit	79241696fbdebe2583298f12cbaee068ce60c655 (patch)
tree	42e60d351e328fa34f17242c6c3359a8c01e8fa3 /libglusterfs/src
parent	c4ebd25a176d6d51d702b1009e261c3c27237a48 (diff)