From 79241696fbdebe2583298f12cbaee068ce60c655 Mon Sep 17 00:00:00 2001 From: Anand Avati Date: Mon, 7 Jun 2010 12:37:34 +0000 Subject: dynamic volume changes for graph replacement Signed-off-by: Anand V. Avati Signed-off-by: Anand V. Avati BUG: 971 (dynamic volume management) URL: http://bugs.gluster.com/cgi-bin/bugzilla3/show_bug.cgi?id=971 --- libglusterfs/src/Makefile.am | 18 +- libglusterfs/src/common-utils.c | 83 +---- libglusterfs/src/common-utils.h | 2 - libglusterfs/src/fd.c | 172 ++++++----- libglusterfs/src/fd.h | 41 ++- libglusterfs/src/globals.c | 70 ++++- libglusterfs/src/globals.h | 3 +- libglusterfs/src/glusterfs.h | 101 ++++--- libglusterfs/src/graph.c | 499 ++++++++++++++++++++++++++++++ libglusterfs/src/graph.l | 87 ++++++ libglusterfs/src/graph.y | 651 ++++++++++++++++++++++++++++++++++++++++ libglusterfs/src/inode.c | 17 +- libglusterfs/src/latency.c | 2 +- libglusterfs/src/md5.c | 310 ------------------- libglusterfs/src/md5.h | 78 ----- libglusterfs/src/mem-types.h | 1 + libglusterfs/src/spec.l | 94 ------ libglusterfs/src/spec.y | 626 -------------------------------------- libglusterfs/src/stack.h | 8 +- libglusterfs/src/statedump.c | 152 +++++----- libglusterfs/src/xlator.c | 136 +++++---- libglusterfs/src/xlator.h | 18 +- 22 files changed, 1683 insertions(+), 1486 deletions(-) create mode 100644 libglusterfs/src/graph.c create mode 100644 libglusterfs/src/graph.l create mode 100644 libglusterfs/src/graph.y delete mode 100644 libglusterfs/src/md5.c delete mode 100644 libglusterfs/src/md5.h delete mode 100644 libglusterfs/src/spec.l delete mode 100644 libglusterfs/src/spec.y (limited to 'libglusterfs') diff --git a/libglusterfs/src/Makefile.am b/libglusterfs/src/Makefile.am index acca3f04a..795744883 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 c93dcc41d..694a9040c 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 06933d7c4..80111a26d 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 b01caf765..d26854ebd 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 9c5ebd8d7..c2181d8af 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 9677a169e..d480f089f 100644 --- a/libglusterfs/src/globals.c +++ b/libglusterfs/src/globals.c @@ -24,12 +24,73 @@ #include -#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 (¢ral_log_flag_key, + ret = pthread_key_create (¢ral_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 58f37d185..e09c69511 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 f4134d9ea..b6db51489 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 000000000..a59b427bf --- /dev/null +++ b/libglusterfs/src/graph.c @@ -0,0 +1,499 @@ +/* + Copyright (c) 2010 Gluster, Inc. + 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 + . +*/ + +#ifndef _CONFIG_H +#define _CONFIG_H +#include "config.h" +#endif + +#include "xlator.h" +#include +#include +#include +#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/graph.l b/libglusterfs/src/graph.l new file mode 100644 index 000000000..8d9d2dc36 --- /dev/null +++ b/libglusterfs/src/graph.l @@ -0,0 +1,87 @@ +/* + Copyright (c) 2006-2009 Gluster, Inc. + 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 + . +*/ + + +%x STRING +%option yylineno +%option noinput +%{ + +#define YYSTYPE char * +#include "xlator.h" +#include "y.tab.h" +#include +#define START_STRSIZE 32 + +static char *text; +static int text_asize; +static int text_size; + +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; + 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); + text_size += size; + text[text_size] = 0; +} + +%} + +VOLUME [v][o][l][u][m][e] +END [e][n][d] +SUB [s][u][b] +OPTION [o][p][t][i][o][n] +TYPE [t][y][p][e] +%% +\#.* ; +{VOLUME} return VOLUME_BEGIN; +{TYPE} return TYPE; +{END}[-]{VOLUME} return VOLUME_END; +{SUB}{VOLUME}[Ss] return SUBVOLUME; +{OPTION} return OPTION; +\" BEGIN(STRING); +{ + [^\n\"\\]* { append_string (yytext, yyleng); } + \\. { append_string (yytext + 1, yyleng - 1); } + \" { + if (0) { + yyunput (0, NULL); + } + BEGIN (INITIAL); + yylval = text; + return STRING_TOK; + } +} +[^ \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 000000000..4ac07660f --- /dev/null +++ b/libglusterfs/src/graph.y @@ -0,0 +1,651 @@ +/* + Copyright (c) 2006-2009 Gluster, Inc. + 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 + . +*/ + + +%token VOLUME_BEGIN VOLUME_END OPTION NEWLINE SUBVOLUME ID WHITESPACE COMMENT TYPE STRING_TOK + +%{ +#include +#include +#include +#include +#include +#include +#include + +#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 ", + 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 622857c1a..c57845954 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 5156e8e25..71f982420 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 5f0d0d157..000000000 --- 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 -#include - -#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 -#include - -/* - * 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 ba8f08dbc..000000000 --- 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 daf680eb2..e8d4df5f1 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.l b/libglusterfs/src/spec.l deleted file mode 100644 index 9508e0f55..000000000 --- a/libglusterfs/src/spec.l +++ /dev/null @@ -1,94 +0,0 @@ -/* - Copyright (c) 2006-2009 Gluster, Inc. - 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 - . -*/ - - -%x STRING -%option yylineno -%option noinput -%{ - -#define YYSTYPE char * -#include "xlator.h" -#include "y.tab.h" -#include -#define START_STRSIZE 32 - -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); - text_asize = new_size; - } - memcpy(text + text_size, str, size); - text_size += 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] -END [e][n][d] -SUB [s][u][b] -OPTION [o][p][t][i][o][n] -TYPE [t][y][p][e] -%% -\#.* ; -{VOLUME} return SECTION_BEGIN; -{TYPE} return TYPE; -{END}[-]{VOLUME} return SECTION_END; -{SUB}{VOLUME}[Ss] return SUBSECTION; -{OPTION} return OPTION; -\" BEGIN(STRING); -{ - [^\n\"\\]* { append_string (yytext, yyleng); } - \\. { append_string (yytext + 1, yyleng - 1); } - \" { - if (0) { - yyunput (0, NULL); - } - BEGIN (INITIAL); - yylval = text; - return STRING_TOK; - } -} -[^ \t\r\n\"\\]+ { yylval = strdup (yytext) ; return ID; } -[ \t\r\n]+ ; -%% diff --git a/libglusterfs/src/spec.y b/libglusterfs/src/spec.y deleted file mode 100644 index 805e1e1fb..000000000 --- a/libglusterfs/src/spec.y +++ /dev/null @@ -1,626 +0,0 @@ -/* - Copyright (c) 2006-2009 Gluster, Inc. - 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 - . -*/ - - -%token SECTION_BEGIN SECTION_END OPTION NEWLINE SUBSECTION ID WHITESPACE COMMENT TYPE STRING_TOK - -%{ -#include -#include -#include -#include -#include -#include -#include - -#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 \n", - complete_tree->name, yylineno); - gf_log ("parser", GF_LOG_ERROR, - "Volume %s, before line %d: Please specify " - "option ", - 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 48b5587ac..ac69e389f 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 678ed6c8e..6f30a30ea 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 4a0de3001..e9ace1714 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; } @@ -931,22 +919,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) { @@ -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 8217101e2..142423da2 100644 --- a/libglusterfs/src/xlator.h +++ b/libglusterfs/src/xlator.h @@ -30,7 +30,6 @@ #include -#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); -- cgit