summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorAnand Avati <avati@gluster.com>2010-06-07 12:37:34 +0000
committerAnand V. Avati <avati@dev.gluster.com>2010-06-07 11:58:50 -0700
commit79241696fbdebe2583298f12cbaee068ce60c655 (patch)
tree42e60d351e328fa34f17242c6c3359a8c01e8fa3
parentc4ebd25a176d6d51d702b1009e261c3c27237a48 (diff)
dynamic volume changes for graph replacement
Signed-off-by: Anand V. Avati <avati@blackhole.gluster.com> Signed-off-by: Anand V. Avati <avati@dev.gluster.com> BUG: 971 (dynamic volume management) URL: http://bugs.gluster.com/cgi-bin/bugzilla3/show_bug.cgi?id=971
-rw-r--r--contrib/md5/md5.c (renamed from libglusterfs/src/md5.c)0
-rw-r--r--contrib/md5/md5.h (renamed from libglusterfs/src/md5.h)0
-rw-r--r--glusterfsd/src/fetch-spec.c4
-rw-r--r--glusterfsd/src/glusterfsd.c1301
-rw-r--r--glusterfsd/src/glusterfsd.h32
-rw-r--r--libglusterfs/src/Makefile.am18
-rw-r--r--libglusterfs/src/common-utils.c83
-rw-r--r--libglusterfs/src/common-utils.h2
-rw-r--r--libglusterfs/src/fd.c172
-rw-r--r--libglusterfs/src/fd.h41
-rw-r--r--libglusterfs/src/globals.c70
-rw-r--r--libglusterfs/src/globals.h3
-rw-r--r--libglusterfs/src/glusterfs.h101
-rw-r--r--libglusterfs/src/graph.c499
-rw-r--r--libglusterfs/src/graph.l (renamed from libglusterfs/src/spec.l)35
-rw-r--r--libglusterfs/src/graph.y651
-rw-r--r--libglusterfs/src/inode.c17
-rw-r--r--libglusterfs/src/latency.c2
-rw-r--r--libglusterfs/src/mem-types.h1
-rw-r--r--libglusterfs/src/spec.y626
-rw-r--r--libglusterfs/src/stack.h8
-rw-r--r--libglusterfs/src/statedump.c152
-rw-r--r--libglusterfs/src/xlator.c136
-rw-r--r--libglusterfs/src/xlator.h18
-rw-r--r--xlators/cluster/afr/src/Makefile.am6
-rw-r--r--xlators/mount/fuse/src/fuse-bridge.c395
-rw-r--r--xlators/protocol/client/src/client-protocol.c2
-rw-r--r--xlators/protocol/server/src/Makefile.am3
-rw-r--r--xlators/protocol/server/src/server-protocol.c2
-rw-r--r--xlators/storage/posix/src/Makefile.am5
30 files changed, 2383 insertions, 2002 deletions
diff --git a/libglusterfs/src/md5.c b/contrib/md5/md5.c
index 5f0d0d157bf..5f0d0d157bf 100644
--- a/libglusterfs/src/md5.c
+++ b/contrib/md5/md5.c
diff --git a/libglusterfs/src/md5.h b/contrib/md5/md5.h
index ba8f08dbcfa..ba8f08dbcfa 100644
--- a/libglusterfs/src/md5.h
+++ b/contrib/md5/md5.h
diff --git a/glusterfsd/src/fetch-spec.c b/glusterfsd/src/fetch-spec.c
index 239b3c90227..f8dcb75844f 100644
--- a/glusterfsd/src/fetch-spec.c
+++ b/glusterfsd/src/fetch-spec.c
@@ -34,6 +34,8 @@
#include "defaults.h"
+#if 0
+
int glusterfs_graph_parent_up (xlator_t *graph);
static int
@@ -297,3 +299,5 @@ fetch_spec (glusterfs_ctx_t *ctx)
return spec_fp;
}
+
+#endif
diff --git a/glusterfsd/src/glusterfsd.c b/glusterfsd/src/glusterfsd.c
index cf486d84f7e..01d155a2d4b 100644
--- a/glusterfsd/src/glusterfsd.c
+++ b/glusterfsd/src/glusterfsd.c
@@ -1,5 +1,5 @@
/*
- Copyright (c) 2006-2009 Gluster, Inc. <http://www.gluster.com>
+ Copyright (c) 2006-2010 Gluster, Inc. <http://www.gluster.com>
This file is part of GlusterFS.
GlusterFS is GF_FREE software; you can redistribute it and/or modify
@@ -70,6 +70,7 @@
#include "statedump.h"
#include "latency.h"
#include "glusterfsd-mem-types.h"
+#include "syscall.h"
#include <fnmatch.h>
@@ -94,7 +95,7 @@ const char *argp_program_version = "" \
"the GNU General Public License.";
const char *argp_program_bug_address = "<" PACKAGE_BUGREPORT ">";
-error_t parse_opts (int32_t key, char *arg, struct argp_state *_state);
+static error_t parse_opts (int32_t key, char *arg, struct argp_state *_state);
static struct argp_option gf_options[] = {
{0, 0, 0, 0, "Basic options:"},
@@ -106,11 +107,11 @@ static struct argp_option gf_options[] = {
"This option should be provided with --volfile-server option"
"[default: 1]"},
{"volfile", ARGP_VOLUME_FILE_KEY, "VOLFILE", 0,
- "File to use as VOLUME_FILE [default: "DEFAULT_CLIENT_VOLUME_FILE" or "
- DEFAULT_SERVER_VOLUME_FILE"]"},
+ "File to use as VOLUME_FILE [default: "DEFAULT_CLIENT_VOLFILE" or "
+ DEFAULT_SERVER_VOLFILE"]"},
{"spec-file", ARGP_VOLUME_FILE_KEY, "VOLFILE", OPTION_HIDDEN,
- "File to use as VOLFILE [default : "DEFAULT_CLIENT_VOLUME_FILE" or "
- DEFAULT_SERVER_VOLUME_FILE"]"},
+ "File to use as VOLFILE [default : "DEFAULT_CLIENT_VOLFILE" or "
+ DEFAULT_SERVER_VOLFILE"]"},
{"log-server", ARGP_LOG_SERVER_KEY, "LOG SERVER", 0,
"Server to use as the central log server."
"--log-server option"},
@@ -174,194 +175,83 @@ static struct argp_option gf_options[] = {
static struct argp argp = { gf_options, parse_opts, argp_doc, gf_doc };
-/* Make use of pipe to synchronize daemonization */
-int
-gf_daemon (int *pipe_fd)
-{
- pid_t pid = -1;
- int ret = -1;
- int gf_daemon_buff = 0;
-
- if (pipe (pipe_fd) < 0) {
- gf_log ("glusterfs", GF_LOG_ERROR,
- "pipe creation error- %s", strerror (errno));
- return -1;
- }
-
- if ((pid = fork ()) < 0) {
- gf_log ("glusterfs", GF_LOG_ERROR, "fork error: %s",
- strerror (errno));
- return -1;
- } else if (pid != 0) {
- close (pipe_fd[1]);
- ret = read (pipe_fd[0], &gf_daemon_buff,
- sizeof (int));
- close (pipe_fd[0]);
-
- if (ret == -1) {
- gf_log ("glusterfs", GF_LOG_ERROR,
- "read error on pipe- %s", strerror (errno));
- return ret;
- } else if (ret == 0) {
- gf_log ("glusterfs", GF_LOG_ERROR,
- "end of file- %s", strerror (errno));
- return -1;
- } else {
- if (gf_daemon_buff == 0)
- exit (EXIT_SUCCESS);
- else
- exit (EXIT_FAILURE);
- }
- }
-
- /*child continues*/
- close (pipe_fd[0]);
- if (os_daemon (0, 0) == -1) {
- gf_log ("glusterfs", GF_LOG_ERROR,
- "unable to run in daemon mode: %s",
- strerror (errno));
- return -1;
- }
- return 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);
-}
-
-static xlator_t *
-gf_get_first_xlator (xlator_t *list)
-{
- xlator_t *trav = NULL, *head = NULL;
+int glusterfs_pidfile_cleanup (glusterfs_ctx_t *ctx);
+int glusterfs_volumes_init (glusterfs_ctx_t *ctx);
- trav = list;
- do {
- if (trav->prev == NULL) {
- head = trav;
- }
-
- trav = trav->prev;
- } while (trav != NULL);
-
- return head;
-}
-
-static xlator_t *
-_add_fuse_mount (xlator_t *graph)
+int
+create_fuse_mount (glusterfs_ctx_t *ctx)
{
int ret = 0;
cmd_args_t *cmd_args = NULL;
- xlator_t *top = NULL;
- glusterfs_ctx_t *ctx = NULL;
- xlator_list_t *xlchild = NULL;
+ xlator_t *master = NULL;
- ctx = graph->ctx;
cmd_args = &ctx->cmd_args;
- xlchild = GF_CALLOC (sizeof (*xlchild), 1,
- gfd_mt_xlator_list_t);
- ERR_ABORT (xlchild);
- xlchild->xlator = graph;
+ if (!cmd_args->mount_point)
+ return 0;
- top = GF_CALLOC (1, sizeof (*top),
- gfd_mt_xlator_t);
- top->name = gf_strdup ("fuse");
- if (xlator_set_type (top, ZR_XLATOR_FUSE) == -1) {
- fprintf (stderr,
- "MOUNT-POINT %s initialization failed",
- cmd_args->mount_point);
- gf_log ("glusterfs", GF_LOG_ERROR,
+ master = GF_CALLOC (1, sizeof (*master),
+ gfd_mt_xlator_t);
+ if (!master)
+ goto err;
+
+ master->name = gf_strdup ("fuse");
+ if (!master->name)
+ goto err;
+
+ if (xlator_set_type (master, ZR_XLATOR_FUSE) == -1) {
+ gf_log ("glusterfsd", GF_LOG_ERROR,
"MOUNT-POINT %s initialization failed",
cmd_args->mount_point);
- return NULL;
+ goto err;
}
- top->children = xlchild;
- top->ctx = graph->ctx;
- top->next = gf_get_first_xlator (graph);
- top->options = get_new_dict ();
- ret = dict_set_static_ptr (top->options, ZR_MOUNTPOINT_OPT,
+ master->ctx = ctx;
+ master->options = get_new_dict ();
+
+ ret = dict_set_static_ptr (master->options, ZR_MOUNTPOINT_OPT,
cmd_args->mount_point);
if (ret < 0) {
- gf_log ("glusterfs", GF_LOG_DEBUG,
+ gf_log ("glusterfsd", GF_LOG_ERROR,
"failed to set mount-point to options dictionary");
+ goto err;
}
if (cmd_args->fuse_attribute_timeout >= 0)
- ret = dict_set_double (top->options, ZR_ATTR_TIMEOUT_OPT,
+ ret = dict_set_double (master->options, ZR_ATTR_TIMEOUT_OPT,
cmd_args->fuse_attribute_timeout);
if (cmd_args->fuse_entry_timeout)
- ret = dict_set_double (top->options, ZR_ENTRY_TIMEOUT_OPT,
+ ret = dict_set_double (master->options, ZR_ENTRY_TIMEOUT_OPT,
cmd_args->fuse_entry_timeout);
if (cmd_args->volfile_check)
- ret = dict_set_int32 (top->options, ZR_STRICT_VOLFILE_CHECK,
+ ret = dict_set_int32 (master->options, ZR_STRICT_VOLFILE_CHECK,
cmd_args->volfile_check);
if (cmd_args->dump_fuse)
- ret = dict_set_static_ptr (top->options, ZR_DUMP_FUSE,
+ ret = dict_set_static_ptr (master->options, ZR_DUMP_FUSE,
cmd_args->dump_fuse);
#ifdef GF_DARWIN_HOST_OS
/* On Darwin machines, O_APPEND is not handled,
* which may corrupt the data
*/
+
if (cmd_args->fuse_direct_io_mode_flag == 1) {
- gf_log ("glusterfs", GF_LOG_DEBUG,
+ gf_log ("glusterfsd", GF_LOG_DEBUG,
"'direct-io-mode' in fuse causes data corruption "
"if O_APPEND is used. disabling 'direct-io-mode'");
}
ret = dict_set_static_ptr (top->options, ZR_DIRECT_IO_OPT, "disable");
+
#else /* ! DARWIN HOST OS */
switch (cmd_args->fuse_direct_io_mode_flag) {
case 0: /* disable */
- ret = dict_set_static_ptr (top->options, ZR_DIRECT_IO_OPT,
+ ret = dict_set_static_ptr (master->options, ZR_DIRECT_IO_OPT,
"disable");
break;
case 1: /* enable */
- ret = dict_set_static_ptr (top->options, ZR_DIRECT_IO_OPT,
+ ret = dict_set_static_ptr (master->options, ZR_DIRECT_IO_OPT,
"enable");
break;
case 2: /* default */
@@ -371,60 +261,25 @@ _add_fuse_mount (xlator_t *graph)
#endif /* GF_DARWIN_HOST_OS */
- graph->parents = GF_CALLOC (1, sizeof (xlator_list_t),
- gfd_mt_xlator_list_t);
- graph->parents->xlator = top;
-
- return top;
-}
+ ret = xlator_init (master);
+ if (ret)
+ goto err;
-static xlator_t *
-_add_volume (xlator_t *graph, const char *voltype)
-{
- cmd_args_t *cmd_args = NULL;
- xlator_t *top = NULL;
- glusterfs_ctx_t *ctx = NULL;
- xlator_list_t *xlchild = NULL;
- char *shortvoltype = (char *)voltype;
+ ctx->master = master;
- ctx = graph->ctx;
- cmd_args = &ctx->cmd_args;
- for (;;) {
- if (*(shortvoltype++) == '/')
- break;
- assert (*shortvoltype);
- }
-
- xlchild = CALLOC (sizeof (*xlchild), 1);
- if (!xlchild) {
- return NULL;
- }
- xlchild->xlator = graph;
+ return 0;
- top = CALLOC (1, sizeof (*top));
- top->name = strdup (shortvoltype);
- if (xlator_set_type (top, voltype) == -1) {
- fprintf (stderr,
- "%s volume initialization failed",
- shortvoltype);
- gf_log ("glusterfs", GF_LOG_ERROR,
- "%s initialization failed", shortvoltype);
- return NULL;
+err:
+ if (master) {
+ xlator_destroy (master);
}
- top->children = xlchild;
- top->ctx = graph->ctx;
- top->next = gf_get_first_xlator (graph);
- top->options = get_new_dict ();
- graph->parents = CALLOC (1, sizeof (xlator_list_t));
- graph->parents->xlator = top;
-
- return top;
+ return -1;
}
static FILE *
-_get_specfp (glusterfs_ctx_t *ctx)
+get_volfp (glusterfs_ctx_t *ctx)
{
int ret = 0;
cmd_args_t *cmd_args = NULL;
@@ -434,18 +289,15 @@ _get_specfp (glusterfs_ctx_t *ctx)
cmd_args = &ctx->cmd_args;
if (cmd_args->volfile_server) {
- specfp = fetch_spec (ctx);
+// specfp = fetch_spec (ctx);
if (specfp == NULL) {
- fprintf (stderr,
- "error while getting volume file from "
- "server %s\n", cmd_args->volfile_server);
- gf_log ("glusterfs", GF_LOG_ERROR,
+ gf_log ("glusterfsd", GF_LOG_ERROR,
"error while getting volume file from "
"server %s", cmd_args->volfile_server);
}
else {
- gf_log ("glusterfs", GF_LOG_DEBUG,
+ gf_log ("glusterfsd", GF_LOG_DEBUG,
"loading volume file from server %s",
cmd_args->volfile_server);
}
@@ -453,284 +305,27 @@ _get_specfp (glusterfs_ctx_t *ctx)
return specfp;
}
- ret = stat (cmd_args->volume_file, &statbuf);
+ ret = sys_lstat (cmd_args->volfile, &statbuf);
if (ret == -1) {
- fprintf (stderr, "%s: %s\n",
- cmd_args->volume_file, strerror (errno));
- gf_log ("glusterfs", GF_LOG_ERROR,
- "%s: %s", cmd_args->volume_file, strerror (errno));
- return NULL;
- }
- if (!(S_ISREG (statbuf.st_mode) || S_ISLNK (statbuf.st_mode))) {
- fprintf (stderr,
- "provide a valid volume file\n");
- gf_log ("glusterfs", GF_LOG_ERROR,
- "provide a valid volume file");
+ gf_log ("glusterfsd", GF_LOG_ERROR,
+ "%s: %s", cmd_args->volfile, strerror (errno));
return NULL;
}
- if ((specfp = fopen (cmd_args->volume_file, "r")) == NULL) {
- fprintf (stderr, "volume file %s: %s\n",
- cmd_args->volume_file,
- strerror (errno));
- gf_log ("glusterfs", GF_LOG_ERROR,
+
+ if ((specfp = fopen (cmd_args->volfile, "r")) == NULL) {
+ gf_log ("glusterfsd", GF_LOG_ERROR,
"volume file %s: %s",
- cmd_args->volume_file,
+ cmd_args->volfile,
strerror (errno));
return NULL;
}
- gf_log ("glusterfs", GF_LOG_DEBUG,
- "loading volume file %s", cmd_args->volume_file);
+ gf_log ("glusterfsd", GF_LOG_DEBUG,
+ "loading volume file %s", cmd_args->volfile);
return specfp;
}
-static xlator_t *
-_parse_specfp (glusterfs_ctx_t *ctx,
- FILE *specfp)
-{
- int spec_fd = 0;
- cmd_args_t *cmd_args = NULL;
- xlator_t *tree = NULL, *trav = NULL, *new_tree = NULL;
-
- cmd_args = &ctx->cmd_args;
-
- fseek (specfp, 0L, SEEK_SET);
-
- tree = file_to_xlator_tree (ctx, specfp);
- trav = tree;
-
- if (tree == NULL) {
- if (cmd_args->volfile_server) {
- fprintf (stderr,
- "error in parsing volume file given by "
- "server %s\n", cmd_args->volfile_server);
- gf_log ("glusterfs", GF_LOG_ERROR,
- "error in parsing volume file given by "
- "server %s", cmd_args->volfile_server);
- }
- else {
- fprintf (stderr,
- "error in parsing volume file %s\n",
- cmd_args->volume_file);
- gf_log ("glusterfs", GF_LOG_ERROR,
- "error in parsing volume file %s",
- cmd_args->volume_file);
- }
- return NULL;
- }
-
- spec_fd = fileno (specfp);
- get_checksum_for_file (spec_fd, &ctx->volfile_checksum);
-
- /* if volume_name is given, then we attach to it */
- if (cmd_args->volume_name) {
- while (trav) {
- if (strcmp (trav->name, cmd_args->volume_name) == 0) {
- new_tree = trav;
- break;
- }
- trav = trav->next;
- }
-
- if (!trav) {
- if (cmd_args->volfile_server) {
- fprintf (stderr,
- "volume %s not found in volume "
- "file given by server %s\n",
- cmd_args->volume_name,
- cmd_args->volfile_server);
- gf_log ("glusterfs", GF_LOG_ERROR,
- "volume %s not found in volume "
- "file given by server %s",
- cmd_args->volume_name,
- cmd_args->volfile_server);
- } else {
- fprintf (stderr,
- "volume %s not found in volume "
- "file %s\n",
- cmd_args->volume_name,
- cmd_args->volume_file);
- gf_log ("glusterfs", GF_LOG_ERROR,
- "volume %s not found in volume "
- "file %s", cmd_args->volume_name,
- cmd_args->volume_file);
- }
- return NULL;
- }
- tree = trav;
- }
- return tree;
-}
-
-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;
-}
-
-static int
-_xlator_graph_init (xlator_t *xl)
-{
- volume_opt_list_t *vol_opt = NULL;
- data_pair_t *pair = NULL;
- xlator_t *trav = NULL;
- int ret = -1;
-
- trav = xl;
-
- while (trav->prev)
- trav = trav->prev;
-
- /* Validate phase */
- while (trav) {
- /* Get the first volume_option */
- list_for_each_entry (vol_opt,
- &trav->volume_options, list)
- break;
- if ((ret =
- validate_xlator_volume_options (trav,
- vol_opt->given_opt)) < 0) {
- gf_log (trav->name, GF_LOG_ERROR,
- "validating translator failed");
- return ret;
- }
- trav = trav->next;
- }
-
-
- trav = xl;
- while (trav->prev)
- trav = trav->prev;
- /* Initialization phase */
- while (trav) {
- if (!trav->ready) {
- if ((ret = xlator_tree_init (trav)) < 0) {
- gf_log ("glusterfs", GF_LOG_ERROR,
- "initializing translator failed");
- return ret;
- }
- }
- trav = trav->next;
- }
-
- /* No error in this phase, just bunch of warning if at all */
- trav = xl;
-
- while (trav->prev)
- trav = trav->prev;
-
- /* 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 ret;
-}
-
-int
-glusterfs_graph_parent_up (xlator_t *graph)
-{
- xlator_t *trav = NULL;
- int ret = -1;
-
- trav = graph;
-
- while (trav->prev)
- trav = trav->prev;
-
- while (trav) {
- if (!xlator_has_parent (trav)) {
- ret = trav->notify (trav, GF_EVENT_PARENT_UP, trav);
- }
-
- if (ret)
- break;
-
- trav = trav->next;
- }
-
- return ret;
-}
-
-int
-glusterfs_graph_init (xlator_t *graph, int fuse)
-{
- volume_opt_list_t *vol_opt = NULL;
-
- if (fuse) {
- /* FUSE needs to be initialized earlier than the
- other translators */
- list_for_each_entry (vol_opt,
- &graph->volume_options, list)
- break;
- if (validate_xlator_volume_options (graph,
- vol_opt->given_opt) == -1) {
- gf_log (graph->name, GF_LOG_ERROR,
- "validating translator failed");
- return -1;
- }
-
- if (graph->mem_acct_init (graph) != 0)
- return -1;
-
- if (xlator_init (graph) != 0)
- return -1;
-
- graph->ready = 1;
- }
- if (_xlator_graph_init (graph) == -1)
- return -1;
-
- /* check server or fuse is given */
- if (graph->ctx->top == NULL) {
- fprintf (stderr, "no valid translator loaded at the top, or"
- "no mount point given. exiting\n");
- gf_log ("glusterfs", GF_LOG_ERROR,
- "no valid translator loaded at the top or "
- "no mount point given. exiting");
- return -1;
- }
-
- return 0;
-}
static int
gf_remember_xlator_option (struct list_head *options, char *arg)
@@ -742,7 +337,7 @@ gf_remember_xlator_option (struct list_head *options, char *arg)
char *dot = NULL;
char *equals = NULL;
- ctx = get_global_ctx_ptr ();
+ ctx = glusterfs_ctx_get ();
cmd_args = &ctx->cmd_args;
option = GF_CALLOC (1, sizeof (xlator_cmdline_option_t),
@@ -791,42 +386,8 @@ out:
}
-static void
-gf_add_cmdline_options (xlator_t *graph, cmd_args_t *cmd_args)
-{
- int ret = 0;
- xlator_t *trav = graph;
- xlator_cmdline_option_t *cmd_option = NULL;
-
- 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 ("glusterfs", GF_LOG_WARNING,
- "adding option '%s' for "
- "volume '%s' with value '%s'",
- cmd_option->key, trav->name,
- cmd_option->value);
- } else {
- gf_log ("glusterfs", GF_LOG_WARNING,
- "adding option '%s' for "
- "volume '%s' failed: %s",
- cmd_option->key, trav->name,
- strerror (-ret));
- }
- }
- }
- trav = trav->next;
- }
-}
-
-error_t
+static error_t
parse_opts (int key, char *arg, struct argp_state *state)
{
cmd_args_t *cmd_args = NULL;
@@ -861,10 +422,16 @@ parse_opts (int key, char *arg, struct argp_state *state)
break;
case ARGP_VOLUME_FILE_KEY:
- cmd_args->volume_file = gf_strdup (arg);
+ if (cmd_args->volfile)
+ GF_FREE (cmd_args->volfile);
+
+ cmd_args->volfile = gf_strdup (arg);
break;
case ARGP_LOG_SERVER_KEY:
+ if (cmd_args->log_server)
+ GF_FREE (cmd_args->log_server);
+
cmd_args->log_server = gf_strdup (arg);
break;
@@ -1017,48 +584,40 @@ parse_opts (int key, char *arg, struct argp_state *state)
}
-void
+static void
cleanup_and_exit (int signum)
{
glusterfs_ctx_t *ctx = NULL;
- xlator_t *trav = NULL;
- ctx = get_global_ctx_ptr ();
+ ctx = glusterfs_ctx_get ();
- gf_log ("glusterfs", GF_LOG_WARNING, "shutting down");
+ gf_log ("glusterfsd", GF_LOG_NORMAL, "shutting down");
- if (ctx->pidfp) {
- lockf (fileno (ctx->pidfp), F_ULOCK, 0);
- fclose (ctx->pidfp);
- ctx->pidfp = NULL;
- }
+ glusterfs_pidfile_cleanup (ctx);
- if (ctx->specfp) {
- fclose (ctx->specfp);
- ctx->specfp = NULL;
- }
+ exit (0);
+}
- if (ctx->cmd_args.pid_file) {
- unlink (ctx->cmd_args.pid_file);
- ctx->cmd_args.pid_file = NULL;
- }
- if (ctx->graph) {
- trav = ctx->graph;
- ctx->graph = NULL;
- while (trav) {
- trav->fini (trav);
- trav = trav->next;
- }
- exit (0);
- } else {
- gf_log ("glusterfs", GF_LOG_DEBUG, "no graph present");
- }
+static void
+reincarnate (int signum)
+{
+ int ret = 0;
+ glusterfs_ctx_t *ctx = NULL;
+
+ ctx = glusterfs_ctx_get ();
+
+ gf_log ("glusterfsd", GF_LOG_NORMAL,
+ "Reloading volfile ...");
+
+ ret = glusterfs_volumes_init (ctx);
+
+ return;
}
static char *
-zr_build_process_uuid ()
+generate_uuid ()
{
char tmp_str[1024] = {0,};
char hostname[256] = {0,};
@@ -1066,14 +625,14 @@ zr_build_process_uuid ()
struct tm now = {0, };
char now_str[32];
- if (-1 == gettimeofday(&tv, NULL)) {
- gf_log ("", GF_LOG_ERROR,
+ if (gettimeofday (&tv, NULL) == -1) {
+ gf_log ("glusterfsd", GF_LOG_ERROR,
"gettimeofday: failed %s",
strerror (errno));
}
- if (-1 == gethostname (hostname, 256)) {
- gf_log ("", GF_LOG_ERROR,
+ if (gethostname (hostname, 256) == -1) {
+ gf_log ("glusterfsd", GF_LOG_ERROR,
"gethostname: failed %s",
strerror (errno));
}
@@ -1094,6 +653,7 @@ zr_build_process_uuid ()
#define GF_SERVER_PROCESS 0
#define GF_CLIENT_PROCESS 1
+
static uint8_t
gf_get_process_mode (char *exec_name)
{
@@ -1114,7 +674,9 @@ gf_get_process_mode (char *exec_name)
return ret;
}
-int
+
+
+static int
set_log_file_path (cmd_args_t *cmd_args)
{
int i = 0;
@@ -1134,30 +696,31 @@ set_log_file_path (cmd_args_t *cmd_args)
if (cmd_args->mount_point[i] == '/')
tmp_str[j] = '-';
}
+
ret = gf_asprintf (&cmd_args->log_file,
DEFAULT_LOG_FILE_DIRECTORY "/%s.log",
tmp_str);
- if (-1 == ret) {
+ if (ret == -1) {
gf_log ("glusterfsd", GF_LOG_ERROR,
"asprintf failed while setting up log-file");
}
goto done;
}
- if (cmd_args->volume_file) {
+ if (cmd_args->volfile) {
j = 0;
i = 0;
- if (cmd_args->volume_file[0] == '/')
+ if (cmd_args->volfile[0] == '/')
i = 1;
- for (; i < strlen (cmd_args->volume_file); i++,j++) {
- tmp_str[j] = cmd_args->volume_file[i];
- if (cmd_args->volume_file[i] == '/')
+ for (; i < strlen (cmd_args->volfile); i++,j++) {
+ tmp_str[j] = cmd_args->volfile[i];
+ if (cmd_args->volfile[i] == '/')
tmp_str[j] = '-';
}
ret = gf_asprintf (&cmd_args->log_file,
DEFAULT_LOG_FILE_DIRECTORY "/%s.log",
tmp_str);
- if (-1 == ret) {
+ if (ret == -1) {
gf_log ("glusterfsd", GF_LOG_ERROR,
"asprintf failed while setting up log-file");
}
@@ -1185,91 +748,120 @@ done:
return ret;
}
-int
-main (int argc, char *argv[])
+
+static int
+glusterfs_ctx_defaults_init (glusterfs_ctx_t *ctx)
{
- glusterfs_ctx_t *ctx = NULL;
- cmd_args_t *cmd_args = NULL;
- call_pool_t *pool = NULL;
- struct stat stbuf;
- char tmp_logfile[1024] = { 0 };
- char *tmp_logfile_dyn = NULL;
- char *tmp_logfilebase = NULL;
- char timestr[256] = { 0 };
- time_t utime;
- struct tm *tm = NULL;
- int ret = 0;
- struct rlimit lim;
- FILE *specfp = NULL;
- xlator_t *graph = NULL;
- xlator_t *trav = NULL;
- int fuse_volume_found = 0;
- int xl_count = 0;
- uint8_t process_mode = 0;
- int pipe_fd[2];
- int gf_success = 0;
- int gf_failure = -1;
+ cmd_args_t *cmd_args = NULL;
+ struct rlimit lim = {0, };
+ call_pool_t *pool = NULL;
- ret = glusterfs_globals_init ();
- if (ret)
- return ret;
+ xlator_mem_acct_init (THIS, gfd_mt_end);
- ret = xlator_mem_acct_init (THIS, gfd_mt_end);
- if (ret)
- return ret;
+ ctx->process_uuid = generate_uuid ();
+ if (!ctx->process_uuid)
+ return -1;
+
+ ctx->page_size = 128 * GF_UNIT_KB;
+
+ ctx->iobuf_pool = iobuf_pool_new (8 * GF_UNIT_MB, ctx->page_size);
+ if (!ctx->iobuf_pool)
+ return -1;
+
+ ctx->event_pool = event_pool_new (DEFAULT_EVENT_POOL_SIZE);
+ if (!ctx->event_pool)
+ return -1;
+
+ pool = GF_CALLOC (1, sizeof (call_pool_t),
+ gfd_mt_call_pool_t);
+ if (!pool)
+ return -1;
+ INIT_LIST_HEAD (&pool->all_frames);
+ LOCK_INIT (&pool->lock);
+ ctx->pool = pool;
+
+ pthread_mutex_init (&(ctx->lock), NULL);
- utime = time (NULL);
- ctx = glusterfs_ctx_get ();
- process_mode = gf_get_process_mode (argv[0]);
- set_global_ctx_ptr (ctx);
- ctx->process_uuid = zr_build_process_uuid ();
cmd_args = &ctx->cmd_args;
/* parsing command line arguments */
cmd_args->log_level = DEFAULT_LOG_LEVEL;
- cmd_args->fuse_direct_io_mode_flag = 2;
+ cmd_args->fuse_direct_io_mode_flag = _gf_true;
cmd_args->fuse_attribute_timeout = -1;
INIT_LIST_HEAD (&cmd_args->xlator_options);
- argp_parse (&argp, argc, argv, ARGP_IN_ORDER, NULL, cmd_args);
+ lim.rlim_cur = RLIM_INFINITY;
+ lim.rlim_max = RLIM_INFINITY;
+ setrlimit (RLIMIT_CORE, &lim);
- if (ENABLE_DEBUG_MODE == cmd_args->debug_mode) {
- cmd_args->log_level = GF_LOG_DEBUG;
- cmd_args->log_file = "/dev/stdout";
- cmd_args->no_daemon_mode = ENABLE_NO_DAEMON_MODE;
- }
+ return 0;
+}
- if ((cmd_args->volfile_server == NULL)
- && (cmd_args->volume_file == NULL)) {
- if (process_mode == GF_SERVER_PROCESS)
- cmd_args->volume_file = gf_strdup (DEFAULT_SERVER_VOLUME_FILE);
- else
- cmd_args->volume_file = gf_strdup (DEFAULT_CLIENT_VOLUME_FILE);
- }
+
+static int
+logging_init (glusterfs_ctx_t *ctx)
+{
+ cmd_args_t *cmd_args = NULL;
+ int ret = 0;
+
+ cmd_args = &ctx->cmd_args;
if (cmd_args->log_file == NULL) {
ret = set_log_file_path (cmd_args);
- if (-1 == ret) {
+ if (ret == -1) {
fprintf (stderr, "failed to set the log file path.. "
"exiting\n");
return -1;
}
}
- ctx->page_size = 128 * GF_UNIT_KB;
- ctx->iobuf_pool = iobuf_pool_new (8 * GF_UNIT_MB, ctx->page_size);
- ctx->event_pool = event_pool_new (DEFAULT_EVENT_POOL_SIZE);
- pthread_mutex_init (&(ctx->lock), NULL);
- pool = ctx->pool = GF_CALLOC (1, sizeof (call_pool_t),
- gfd_mt_call_pool_t);
- ERR_ABORT (ctx->pool);
- LOCK_INIT (&pool->lock);
- INIT_LIST_HEAD (&pool->all_frames);
+ if (gf_log_init (cmd_args->log_file) == -1) {
+ fprintf (stderr,
+ "failed to open logfile %s. exiting\n",
+ cmd_args->log_file);
+ return -1;
+ }
+
+ gf_log_set_loglevel (cmd_args->log_level);
+
+ return 0;
+}
+
+
+int
+parse_cmdline (int argc, char *argv[], cmd_args_t *cmd_args)
+{
+ int process_mode = 0;
+ int ret = 0;
+ struct stat stbuf = {0, };
+ struct tm *tm = NULL;
+ time_t utime;
+ char timestr[256];
+ char tmp_logfile[1024] = { 0 };
+ char *tmp_logfile_dyn = NULL;
+ char *tmp_logfilebase = NULL;
+
+ argp_parse (&argp, argc, argv, ARGP_IN_ORDER, NULL, cmd_args);
+
+ if (ENABLE_DEBUG_MODE == cmd_args->debug_mode) {
+ cmd_args->log_level = GF_LOG_DEBUG;
+ cmd_args->log_file = "/dev/stderr";
+ cmd_args->no_daemon_mode = ENABLE_NO_DAEMON_MODE;
+ }
+
+ process_mode = gf_get_process_mode (argv[0]);
+
+ if ((cmd_args->volfile_server == NULL)
+ && (cmd_args->volfile == NULL)) {
+ if (process_mode == GF_SERVER_PROCESS)
+ cmd_args->volfile = gf_strdup (DEFAULT_SERVER_VOLFILE);
+ else
+ cmd_args->volfile = gf_strdup (DEFAULT_CLIENT_VOLFILE);
+ }
- /* initializing logs */
if (cmd_args->run_id) {
- ret = stat (cmd_args->log_file, &stbuf);
+ ret = sys_lstat (cmd_args->log_file, &stbuf);
/* If its /dev/null, or /dev/stdout, /dev/stderr,
* let it use the same, no need to alter
*/
@@ -1283,12 +875,13 @@ main (int argc, char *argv[])
cmd_args->log_file, timestr, getpid ());
/* Create symlink to actual log file */
- unlink (cmd_args->log_file);
+ sys_unlink (cmd_args->log_file);
tmp_logfile_dyn = gf_strdup (tmp_logfile);
tmp_logfilebase = basename (tmp_logfile_dyn);
- ret = symlink (tmp_logfilebase, cmd_args->log_file);
- if (-1 == ret) {
+ ret = sys_symlink (tmp_logfilebase,
+ cmd_args->log_file);
+ if (ret == -1) {
fprintf (stderr, "symlink of logfile failed");
} else {
GF_FREE (cmd_args->log_file);
@@ -1299,218 +892,346 @@ main (int argc, char *argv[])
}
}
- gf_global_variable_init ();
+ return 0;
+}
- if (gf_log_init (cmd_args->log_file) == -1) {
- fprintf (stderr,
- "failed to open logfile %s. exiting\n",
- cmd_args->log_file);
- return -1;
- }
- gf_log_set_loglevel (cmd_args->log_level);
- gf_proc_dump_init();
- /* setting up environment */
- lim.rlim_cur = RLIM_INFINITY;
- lim.rlim_max = RLIM_INFINITY;
- if (setrlimit (RLIMIT_CORE, &lim) == -1) {
- fprintf (stderr, "ignoring %s\n",
- strerror (errno));
- }
-#ifdef DEBUG
- mtrace ();
-#endif
+int
+glusterfs_pidfile_setup (glusterfs_ctx_t *ctx)
+{
+ cmd_args_t *cmd_args = NULL;
+ int ret = 0;
+ FILE *pidfp = NULL;
- signal (SIGUSR1, gf_proc_dump_info);
- signal (SIGUSR2, gf_latency_toggle);
- signal (SIGSEGV, gf_print_trace);
- signal (SIGABRT, gf_print_trace);
- signal (SIGPIPE, SIG_IGN);
- signal (SIGHUP, gf_log_logrotate);
- signal (SIGTERM, cleanup_and_exit);
- /* if used inside GDB, then this is overridden, hence making
- it a safer option */
- signal (SIGINT, cleanup_and_exit);
-
- /* This is used to dump details */
- /* signal (SIGUSR2, (sighandler_t) glusterfs_stats); */
-
- /* getting and parsing volume file */
- if ((specfp = _get_specfp (ctx)) == NULL) {
- /* _get_specfp() prints necessary error message */
- gf_log ("glusterfs", GF_LOG_ERROR, "exiting\n");
- argp_help (&argp, stderr, ARGP_HELP_SEE, (char *) argv[0]);
+ cmd_args = &ctx->cmd_args;
+
+ if (!cmd_args->pid_file)
+ return 0;
+
+ pidfp = fopen (cmd_args->pid_file, "a+");
+ if (!pidfp) {
+ gf_log ("glusterfsd", GF_LOG_ERROR,
+ "pidfile %s error (%s)",
+ cmd_args->pid_file, strerror (errno));
return -1;
}
- if ((graph = _parse_specfp (ctx, specfp)) == NULL) {
- /* _parse_specfp() prints necessary error message */
- fprintf (stderr, "exiting\n");
- gf_log ("glusterfs", GF_LOG_ERROR, "exiting");
- return -1;
+ ret = lockf (fileno (pidfp), F_TLOCK, 0);
+ if (ret) {
+ gf_log ("glusterfsd", GF_LOG_ERROR,
+ "pidfile %s lock error (%s)",
+ cmd_args->pid_file, strerror (errno));
+ return ret;
}
- ctx->specfp = specfp;
- /* check whether MOUNT-POINT argument and fuse volume are given
- * at same time or not. If not, add argument MOUNT-POINT to graph
- * as top volume if given
- */
- trav = graph;
- fuse_volume_found = 0;
-
- while (trav) {
- if (strcmp (trav->type, ZR_XLATOR_FUSE) == 0) {
- if (dict_get (trav->options,
- ZR_MOUNTPOINT_OPT) != NULL) {
- trav->ctx = graph->ctx;
- fuse_volume_found = 1;
- }
- }
+ gf_log ("glusterfsd", GF_LOG_TRACE,
+ "pidfile %s lock acquired",
+ cmd_args->pid_file);
+
+ ret = lockf (fileno (pidfp), F_ULOCK, 0);
+
+ ctx->pidfp = pidfp;
+
+ return 0;
+}
+
+
+int
+glusterfs_pidfile_cleanup (glusterfs_ctx_t *ctx)
+{
+ cmd_args_t *cmd_args = NULL;
+
+ cmd_args = &ctx->cmd_args;
- xl_count++; /* Getting this value right is very important */
- trav = trav->next;
+ if (!ctx->pidfp)
+ return 0;
+
+ gf_log ("glusterfsd", GF_LOG_TRACE,
+ "pidfile %s unlocking",
+ cmd_args->pid_file);
+
+ lockf (fileno (ctx->pidfp), F_ULOCK, 0);
+ fclose (ctx->pidfp);
+ ctx->pidfp = NULL;
+
+ if (ctx->cmd_args.pid_file) {
+ unlink (ctx->cmd_args.pid_file);
+ ctx->cmd_args.pid_file = NULL;
}
- ctx->xl_count = xl_count + 1;
+ return 0;
+}
- if (cmd_args->read_only && !fuse_volume_found &&
- (cmd_args->mount_point == NULL)) {
- gf_log ("glusterfs", GF_LOG_ERROR,
- "'--read-only' option is valid only on client side");
- fprintf (stderr, "'--read-only' option is valid only "
- "on client side, exiting\n");
- return -1;
+int
+glusterfs_pidfile_update (glusterfs_ctx_t *ctx)
+{
+ cmd_args_t *cmd_args = NULL;
+ int ret = 0;
+ FILE *pidfp = NULL;
+
+ cmd_args = &ctx->cmd_args;
+
+ pidfp = ctx->pidfp;
+ if (!pidfp)
+ return 0;
+
+ ret = lockf (fileno (pidfp), F_TLOCK, 0);
+ if (ret) {
+ gf_log ("glusterfsd", GF_LOG_ERROR,
+ "pidfile %s lock failed",
+ cmd_args->pid_file);
+ return ret;
}
- if (graph && !fuse_volume_found && (cmd_args->mount_point != NULL)) {
- /* Check for read-only option and add a read-only translator */
- if (cmd_args->read_only)
- graph = _add_volume (graph, ZR_XLATOR_READ_ONLY);
- if (graph
-#ifndef GF_DARWIN_HOST_OS
- && cmd_args->mac_compat
-#endif
- )
- graph = _add_volume (graph, ZR_XLATOR_MAC_COMPAT);
- if (graph)
- graph = _add_fuse_mount (graph);
+
+ ret = ftruncate (fileno (pidfp), 0);
+ if (ret) {
+ gf_log ("glusterfsd", GF_LOG_ERROR,
+ "pidfile %s truncation failed",
+ cmd_args->pid_file);
+ return ret;
}
- if (!graph) {
- fprintf (stderr, "failed to complete xlator graph, exiting\n");
- gf_log ("glusterfs", GF_LOG_ERROR, "exiting");
- return -1;
+
+ ret = fprintf (pidfp, "%d\n", getpid ());
+ if (ret <= 0) {
+ gf_log ("glusterfsd", GF_LOG_ERROR,
+ "pidfile %s write failed",
+ cmd_args->pid_file);
+ return ret;
}
- /* daemonize now */
- if (!cmd_args->no_daemon_mode) {
- if (gf_daemon (pipe_fd) == -1) {
- gf_log ("glusterfs", GF_LOG_ERROR,
- "unable to run in daemon mode: %s",
- strerror (errno));
- return -1;
+ ret = fflush (pidfp);
+ if (ret) {
+ gf_log ("glusterfsd", GF_LOG_ERROR,
+ "pidfile %s write failed",
+ cmd_args->pid_file);
+ return ret;
+ }
+
+ gf_log ("glusterfsd", GF_LOG_DEBUG,
+ "pidfile %s updated with pid %d",
+ cmd_args->pid_file, getpid ());
+
+ return 0;
+}
+
+
+void *
+glusterfs_sigwaiter (void *arg)
+{
+ sigset_t set;
+ int ret = 0;
+ int sig = 0;
+
+
+ sigaddset (&set, SIGINT); /* cleanup_and_exit */
+ sigaddset (&set, SIGTERM); /* cleanup_and_exit */
+ sigaddset (&set, SIGHUP); /* reincarnate */
+ sigaddset (&set, SIGUSR1); /* gf_proc_dump_info */
+ sigaddset (&set, SIGUSR2); /* gf_latency_toggle */
+
+ for (;;) {
+ ret = sigwait (&set, &sig);
+ if (ret) {
+ gf_log ("sigwaiter", GF_LOG_ERROR,
+ "sigwait returned error (%s)",
+ strerror (ret));
+ continue;
}
- /* we are daemon now */
- _gf_dump_details (argc, argv);
- if (cmd_args->pid_file != NULL) {
- ctx->pidfp = fopen (cmd_args->pid_file, "a+");
- if (ctx->pidfp == NULL) {
- gf_log ("glusterfs", GF_LOG_ERROR,
- "unable to open pid file %s, %s.",
- cmd_args->pid_file,
- strerror (errno));
- if (write (pipe_fd[1], &gf_failure,
- sizeof (int)) < 0) {
- gf_log ("glusterfs", GF_LOG_ERROR,
- "Write on pipe error");
- }
- /* do cleanup and exit ?! */
- return -1;
- }
- ret = lockf (fileno (ctx->pidfp),
- (F_LOCK | F_TLOCK), 0);
- if (ret == -1) {
- gf_log ("glusterfs", GF_LOG_ERROR,
- "Is another instance of %s running?",
- argv[0]);
- fclose (ctx->pidfp);
- if (write (pipe_fd[1], &gf_failure,
- sizeof (int)) < 0) {
- gf_log ("glusterfs", GF_LOG_ERROR,
- "Write on pipe error");
- }
- return ret;
- }
- ret = ftruncate (fileno (ctx->pidfp), 0);
- if (ret == -1) {
- gf_log ("glusterfs", GF_LOG_ERROR,
- "unable to truncate file %s. %s.",
- cmd_args->pid_file,
- strerror (errno));
- lockf (fileno (ctx->pidfp), F_ULOCK, 0);
- fclose (ctx->pidfp);
- if (write (pipe_fd[1], &gf_failure,
- sizeof (int)) < 0) {
- gf_log ("glusterfs", GF_LOG_ERROR,
- "Write on pipe error");
- }
- return ret;
- }
+ gf_log ("sigwaiter", GF_LOG_DEBUG,
+ "received signal %d", sig);
- /* update pid file, if given */
- fprintf (ctx->pidfp, "%d\n", getpid ());
- fflush (ctx->pidfp);
- /* we close pid file on exit */
+ switch (sig) {
+ case SIGINT:
+ case SIGTERM:
+ cleanup_and_exit (sig);
+ break;
+ case SIGHUP:
+ reincarnate (sig);
+ break;
+ case SIGUSR1:
+ gf_proc_dump_info (sig);
+ break;
+ case SIGUSR2:
+ gf_latency_toggle (sig);
+ break;
+ default:
+ gf_log ("sigwaiter", GF_LOG_ERROR,
+ "unhandled signal: %d", sig);
+ break;
}
- } else {
- /*
- * Need to have this line twice because PID is different
- * in daemon and non-daemon cases.
- */
+ }
- _gf_dump_details (argc, argv);
+ return NULL;
+}
+
+
+int
+glusterfs_signals_setup (glusterfs_ctx_t *ctx)
+{
+ sigset_t set;
+ int ret = 0;
+
+ sigemptyset (&set);
+
+ /* common setting for all threads */
+ signal (SIGSEGV, gf_print_trace);
+ signal (SIGABRT, gf_print_trace);
+ signal (SIGILL, gf_print_trace);
+ signal (SIGTRAP, gf_print_trace);
+ signal (SIGFPE, gf_print_trace);
+ signal (SIGBUS, gf_print_trace);
+ signal (SIGPIPE, SIG_IGN);
+
+ /* block these signals from non-sigwaiter threads */
+ sigaddset (&set, SIGINT); /* cleanup_and_exit */
+ sigaddset (&set, SIGTERM); /* cleanup_and_exit */
+ sigaddset (&set, SIGHUP); /* reincarnate */
+ sigaddset (&set, SIGUSR1); /* gf_proc_dump_info */
+ sigaddset (&set, SIGUSR2); /* gf_latency_toggle */
+
+ ret = pthread_sigmask (SIG_BLOCK, &set, NULL);
+ if (ret)
+ return ret;
+
+ ret = pthread_create (&ctx->sigwaiter, NULL, glusterfs_sigwaiter,
+ (void *) &set);
+ if (ret) {
+ /*
+ TODO:
+ fallback to signals getting handled by other threads.
+ setup the signal handlers
+ */
+ return ret;
}
- gf_log_volume_file (ctx->specfp);
+ return ret;
+}
- gf_log ("glusterfs", GF_LOG_DEBUG,
- "running in pid %d", getpid ());
- gf_timer_registry_init (ctx);
+int
+daemonize (glusterfs_ctx_t *ctx)
+{
+ int ret = 0;
+ cmd_args_t *cmd_args = NULL;
- /* override xlator options with command line options
- * where applicable
- */
- gf_add_cmdline_options (graph, cmd_args);
-
- ctx->graph = graph;
- if (glusterfs_graph_init (graph, fuse_volume_found) != 0) {
- gf_log ("glusterfs", GF_LOG_ERROR,
- "translator initialization failed. exiting");
- if (!cmd_args->no_daemon_mode &&
- (write (pipe_fd[1], &gf_failure, sizeof (int)) < 0)) {
- gf_log ("glusterfs", GF_LOG_ERROR,
- "Write on pipe failed,"
- "daemonize problem.exiting: %s",
- strerror (errno));
- }
- return -1;
+
+ cmd_args = &ctx->cmd_args;
+
+ ret = glusterfs_pidfile_setup (ctx);
+ if (ret)
+ return ret;
+
+ if (cmd_args->no_daemon_mode)
+ goto postfork;
+
+ if (cmd_args->debug_mode)
+ goto postfork;
+
+ daemon (0, 0);
+
+postfork:
+ ret = glusterfs_pidfile_update (ctx);
+ if (ret)
+ return ret;
+
+ glusterfs_signals_setup (ctx);
+
+ return ret;
+}
+
+
+int
+glusterfs_volumes_init (glusterfs_ctx_t *ctx)
+{
+ FILE *fp = NULL;
+ glusterfs_graph_t *graph = NULL;
+ int ret = 0;
+
+ fp = get_volfp (ctx);
+
+ if (!fp) {
+ gf_log ("glusterfsd", GF_LOG_ERROR,
+ "Cannot reach volume specification file");
+ ret = -1;
+ goto out;
}
- /* Send PARENT_UP notify to all the translators now */
- glusterfs_graph_parent_up (graph);
+ graph = glusterfs_graph_construct (fp);
- gf_log ("glusterfs", GF_LOG_NORMAL, "Successfully started");
+ if (!graph) {
+ ret = -1;
+ goto out;
+ }
- if (!cmd_args->no_daemon_mode &&
- (write (pipe_fd[1], &gf_success, sizeof (int)) < 0)) {
- gf_log ("glusterfs", GF_LOG_ERROR,
- "Write on pipe failed,"
- "daemonize problem. exiting: %s",
- strerror (errno));
- return -1;
+ ret = glusterfs_graph_prepare (graph, ctx);
+
+ if (ret) {
+ glusterfs_graph_destroy (graph);
+ ret = -1;
+ goto out;
}
- event_dispatch (ctx->event_pool);
+ ret = glusterfs_graph_activate (ctx, graph);
- return 0;
+ if (ret) {
+ glusterfs_graph_destroy (graph);
+ ret = -1;
+ goto out;
+ }
+
+out:
+ if (fp)
+ fclose (fp);
+
+ return ret;
+}
+
+
+int
+main (int argc, char *argv[])
+{
+ glusterfs_ctx_t *ctx = NULL;
+ int ret = -1;
+
+ ret = glusterfs_globals_init ();
+ if (ret)
+ return ret;
+
+ ctx = glusterfs_ctx_get ();
+ if (!ctx)
+ return ENOMEM;
+
+ ret = glusterfs_ctx_defaults_init (ctx);
+ if (ret)
+ goto out;
+
+ ret = parse_cmdline (argc, argv, &ctx->cmd_args);
+ if (ret)
+ goto out;
+
+ ret = logging_init (ctx);
+ if (ret)
+ goto out;
+
+ gf_proc_dump_init();
+
+ ret = create_fuse_mount (ctx);
+ if (ret)
+ goto out;
+
+ ret = daemonize (ctx);
+ if (ret)
+ goto out;
+
+ ret = glusterfs_volumes_init (ctx);
+ if (ret)
+ goto out;
+
+ ret = event_dispatch (ctx->event_pool);
+
+out:
+// glusterfs_ctx_destroy (ctx);
+
+ return ret;
}
diff --git a/glusterfsd/src/glusterfsd.h b/glusterfsd/src/glusterfsd.h
index 929e27d7037..62916711752 100644
--- a/glusterfsd/src/glusterfsd.h
+++ b/glusterfsd/src/glusterfsd.h
@@ -25,8 +25,8 @@
#include "config.h"
#endif
-#define DEFAULT_CLIENT_VOLUME_FILE CONFDIR "/glusterfs.vol"
-#define DEFAULT_SERVER_VOLUME_FILE CONFDIR "/glusterfsd.vol"
+#define DEFAULT_CLIENT_VOLFILE CONFDIR "/glusterfs.vol"
+#define DEFAULT_SERVER_VOLFILE CONFDIR "/glusterfsd.vol"
#define DEFAULT_LOG_FILE_DIRECTORY DATADIR "/log/glusterfs"
#define DEFAULT_LOG_LEVEL GF_LOG_NORMAL
@@ -54,26 +54,26 @@
#define ZR_DUMP_FUSE "dump-fuse"
enum argp_option_keys {
- ARGP_VOLFILE_SERVER_KEY = 's',
- ARGP_VOLUME_FILE_KEY = 'f',
- ARGP_LOG_LEVEL_KEY = 'L',
- ARGP_LOG_FILE_KEY = 'l',
- ARGP_VOLFILE_SERVER_PORT_KEY = 131,
- ARGP_VOLFILE_SERVER_TRANSPORT_KEY = 132,
+ ARGP_VOLFILE_SERVER_KEY = 's',
+ ARGP_VOLUME_FILE_KEY = 'f',
+ ARGP_LOG_LEVEL_KEY = 'L',
+ ARGP_LOG_FILE_KEY = 'l',
+ ARGP_VOLFILE_SERVER_PORT_KEY = 131,
+ ARGP_VOLFILE_SERVER_TRANSPORT_KEY = 132,
ARGP_PID_FILE_KEY = 'p',
- ARGP_NO_DAEMON_KEY = 'N',
- ARGP_RUN_ID_KEY = 'r',
- ARGP_DEBUG_KEY = 133,
- ARGP_DISABLE_DIRECT_IO_MODE_KEY = 134,
- ARGP_ENTRY_TIMEOUT_KEY = 135,
- ARGP_ATTRIBUTE_TIMEOUT_KEY = 136,
+ ARGP_NO_DAEMON_KEY = 'N',
+ ARGP_RUN_ID_KEY = 'r',
+ ARGP_DEBUG_KEY = 133,
+ ARGP_DISABLE_DIRECT_IO_MODE_KEY = 134,
+ ARGP_ENTRY_TIMEOUT_KEY = 135,
+ ARGP_ATTRIBUTE_TIMEOUT_KEY = 136,
ARGP_VOLUME_NAME_KEY = 137,
ARGP_XLATOR_OPTION_KEY = 138,
- ARGP_ENABLE_DIRECT_IO_MODE_KEY = 139,
+ ARGP_ENABLE_DIRECT_IO_MODE_KEY = 139,
#ifdef GF_DARWIN_HOST_OS
ARGP_NON_LOCAL_KEY = 140,
#endif /* DARWIN */
- ARGP_VOLFILE_ID_KEY = 143,
+ ARGP_VOLFILE_ID_KEY = 143,
ARGP_VOLFILE_CHECK_KEY = 144,
ARGP_VOLFILE_MAX_FETCH_ATTEMPTS = 145,
ARGP_LOG_SERVER_KEY = 146,
diff --git a/libglusterfs/src/Makefile.am b/libglusterfs/src/Makefile.am
index acca3f04a01..79574488332 100644
--- a/libglusterfs/src/Makefile.am
+++ b/libglusterfs/src/Makefile.am
@@ -1,21 +1,21 @@
libglusterfs_la_CFLAGS = -fPIC -Wall -g -shared -nostartfiles $(GF_CFLAGS) $(GF_DARWIN_LIBGLUSTERFS_CFLAGS)
-libglusterfs_la_CPPFLAGS = -D_FILE_OFFSET_BITS=64 -D__USE_FILE_OFFSET64 -D_GNU_SOURCE -DXLATORDIR=\"$(libdir)/glusterfs/$(PACKAGE_VERSION)/xlator\" -D$(GF_HOST_OS) -DLIBDIR=\"$(libdir)/glusterfs/$(PACKAGE_VERSION)/auth\" -I$(CONTRIBDIR)/rbtree -DSCHEDULERDIR=\"$(libdir)/glusterfs/$(PACKAGE_VERSION)/scheduler\"
+libglusterfs_la_CPPFLAGS = -D_FILE_OFFSET_BITS=64 -D__USE_FILE_OFFSET64 -D_GNU_SOURCE -DXLATORDIR=\"$(libdir)/glusterfs/$(PACKAGE_VERSION)/xlator\" -D$(GF_HOST_OS) -DLIBDIR=\"$(libdir)/glusterfs/$(PACKAGE_VERSION)/auth\" -I$(CONTRIBDIR)/rbtree -DSCHEDULERDIR=\"$(libdir)/glusterfs/$(PACKAGE_VERSION)/scheduler\" -I$(CONTRIBDIR)/md5
libglusterfs_la_LIBADD = @LEXLIB@
lib_LTLIBRARIES = libglusterfs.la
-libglusterfs_la_SOURCES = dict.c spec.lex.c y.tab.c xlator.c logging.c hashfn.c defaults.c common-utils.c timer.c inode.c call-stub.c compat.c fd.c compat-errno.c event.c mem-pool.c gf-dirent.c syscall.c iobuf.c globals.c statedump.c stack.c checksum.c md5.c $(CONTRIBDIR)/rbtree/rb.c rbthash.c latency.c
+libglusterfs_la_SOURCES = dict.c graph.lex.c y.tab.c xlator.c logging.c hashfn.c defaults.c common-utils.c timer.c inode.c call-stub.c compat.c fd.c compat-errno.c event.c mem-pool.c gf-dirent.c syscall.c iobuf.c globals.c statedump.c stack.c checksum.c $(CONTRIBDIR)/md5/md5.c $(CONTRIBDIR)/rbtree/rb.c rbthash.c latency.c graph.c
-noinst_HEADERS = common-utils.h defaults.h dict.h glusterfs.h hashfn.h logging.h xlator.h stack.h timer.h list.h inode.h call-stub.h compat.h fd.h revision.h compat-errno.h event.h mem-pool.h byte-order.h gf-dirent.h locking.h syscall.h iobuf.h globals.h statedump.h checksum.h md5.h $(CONTRIBDIR)/rbtree/rb.h rbthash.h iatt.h latency.h
+noinst_HEADERS = common-utils.h defaults.h dict.h glusterfs.h hashfn.h logging.h xlator.h stack.h timer.h list.h inode.h call-stub.h compat.h fd.h revision.h compat-errno.h event.h mem-pool.h byte-order.h gf-dirent.h locking.h syscall.h iobuf.h globals.h statedump.h checksum.h $(CONTRIBDIR)/md5/md5.h $(CONTRIBDIR)/rbtree/rb.h rbthash.h iatt.h latency.h
-EXTRA_DIST = spec.l spec.y
+EXTRA_DIST = graph.l graph.y
-spec.lex.c: spec.l y.tab.h
- $(LEX) -t $(srcdir)/spec.l > $@
+graph.lex.c: graph.l y.tab.h
+ $(LEX) -t $(srcdir)/graph.l > $@
-y.tab.c y.tab.h: spec.y
- $(YACC) -d $(srcdir)/spec.y
+y.tab.c y.tab.h: graph.y
+ $(YACC) -d $(srcdir)/graph.y
-CLEANFILES = spec.lex.c y.tab.c y.tab.h
+CLEANFILES = graph.lex.c y.tab.c y.tab.h
diff --git a/libglusterfs/src/common-utils.c b/libglusterfs/src/common-utils.c
index c93dcc41d15..694a9040c95 100644
--- a/libglusterfs/src/common-utils.c
+++ b/libglusterfs/src/common-utils.c
@@ -48,7 +48,6 @@
typedef int32_t (*rw_op_t)(int32_t fd, char *buf, int32_t size);
typedef int32_t (*rwv_op_t)(int32_t fd, const struct iovec *buf, int32_t size);
-static glusterfs_ctx_t *gf_global_ctx;
struct dnscache6 {
@@ -179,85 +178,6 @@ err:
return -1;
}
-char *gf_fop_list[GF_FOP_MAXVALUE];
-char *gf_mgmt_list[GF_MGMT_MAXVALUE];
-
-void
-gf_global_variable_init()
-{
- gf_fop_list[GF_FOP_NULL] = "NULL";
- gf_fop_list[GF_FOP_STAT] = "STAT";
- gf_fop_list[GF_FOP_READLINK] = "READLINK";
- gf_fop_list[GF_FOP_MKNOD] = "MKNOD";
- gf_fop_list[GF_FOP_MKDIR] = "MKDIR";
- gf_fop_list[GF_FOP_UNLINK] = "UNLINK";
- gf_fop_list[GF_FOP_RMDIR] = "RMDIR";
- gf_fop_list[GF_FOP_SYMLINK] = "SYMLINK";
- gf_fop_list[GF_FOP_RENAME] = "RENAME";
- gf_fop_list[GF_FOP_LINK] = "LINK";
- gf_fop_list[GF_FOP_TRUNCATE] = "TRUNCATE";
- gf_fop_list[GF_FOP_OPEN] = "OPEN";
- gf_fop_list[GF_FOP_READ] = "READ";
- gf_fop_list[GF_FOP_WRITE] = "WRITE";
- gf_fop_list[GF_FOP_STATFS] = "STATFS";
- gf_fop_list[GF_FOP_FLUSH] = "FLUSH";
- gf_fop_list[GF_FOP_FSYNC] = "FSYNC";
- gf_fop_list[GF_FOP_SETXATTR] = "SETXATTR";
- gf_fop_list[GF_FOP_GETXATTR] = "GETXATTR";
- gf_fop_list[GF_FOP_REMOVEXATTR] = "REMOVEXATTR";
- gf_fop_list[GF_FOP_OPENDIR] = "OPENDIR";
- gf_fop_list[GF_FOP_FSYNCDIR] = "FSYNCDIR";
- gf_fop_list[GF_FOP_ACCESS] = "ACCESS";
- gf_fop_list[GF_FOP_CREATE] = "CREATE";
- gf_fop_list[GF_FOP_FTRUNCATE] = "FTRUNCATE";
- gf_fop_list[GF_FOP_FSTAT] = "FSTAT";
- gf_fop_list[GF_FOP_LK] = "LK";
- gf_fop_list[GF_FOP_LOOKUP] = "LOOKUP";
- gf_fop_list[GF_FOP_READDIR] = "READDIR";
- gf_fop_list[GF_FOP_INODELK] = "INODELK";
- gf_fop_list[GF_FOP_FINODELK] = "FINODELK";
- gf_fop_list[GF_FOP_ENTRYLK] = "ENTRYLK";
- gf_fop_list[GF_FOP_FENTRYLK] = "FENTRYLK";
- gf_fop_list[GF_FOP_CHECKSUM] = "CHECKSUM";
- gf_fop_list[GF_FOP_XATTROP] = "XATTROP";
- gf_fop_list[GF_FOP_FXATTROP] = "FXATTROP";
- gf_fop_list[GF_FOP_FSETXATTR] = "FSETXATTR";
- gf_fop_list[GF_FOP_FGETXATTR] = "FGETXATTR";
- gf_fop_list[GF_FOP_RCHECKSUM] = "RCHECKSUM";
- gf_fop_list[GF_FOP_SETATTR] = "SETATTR";
- gf_fop_list[GF_FOP_FSETATTR] = "FSETATTR";
- gf_fop_list[GF_FOP_READDIRP] = "READDIRP";
- gf_fop_list[GF_FOP_GETSPEC] = "GETSPEC";
- gf_fop_list[GF_FOP_FORGET] = "FORGET";
- gf_fop_list[GF_FOP_RELEASE] = "RELEASE";
- gf_fop_list[GF_FOP_RELEASEDIR] = "RELEASEDIR";
-
- gf_fop_list[GF_MGMT_NULL] = "NULL";
-
- /* Are there any more variables to be included? All global
- variables initialization should go here */
-
- return;
-}
-
-void
-set_global_ctx_ptr (glusterfs_ctx_t *ctx)
-{
- gf_global_ctx = ctx;
-}
-
-/*
- * Don't use this function other than in glusterfsd.c. libglusterfsclient does
- * not set gf_global_ctx since there can be multiple glusterfs-contexts
- * initialized in a single process. Instead access the context from ctx member
- * of the xlator object.
- */
-
-glusterfs_ctx_t *
-get_global_ctx_ptr (void)
-{
- return gf_global_ctx;
-}
void
gf_log_volume_file (FILE *specfp)
@@ -397,8 +317,7 @@ gf_print_trace (int32_t signum)
/* Pending frames, (if any), list them in order */
ret = write (fd, "pending frames:\n", 16);
{
- extern glusterfs_ctx_t *gf_global_ctx;
- glusterfs_ctx_t *ctx = gf_global_ctx;
+ glusterfs_ctx_t *ctx = glusterfs_ctx_get ();
struct list_head *trav = ((call_pool_t *)ctx->pool)->all_frames.next;
while (trav != (&((call_pool_t *)ctx->pool)->all_frames)) {
call_frame_t *tmp = (call_frame_t *)(&((call_stack_t *)trav)->frames);
diff --git a/libglusterfs/src/common-utils.h b/libglusterfs/src/common-utils.h
index 06933d7c45a..80111a26ddc 100644
--- a/libglusterfs/src/common-utils.h
+++ b/libglusterfs/src/common-utils.h
@@ -82,8 +82,6 @@ enum _gf_boolean
typedef enum _gf_boolean gf_boolean_t;
void gf_global_variable_init(void);
-void set_global_ctx_ptr (glusterfs_ctx_t *ctx);
-glusterfs_ctx_t *get_global_ctx_ptr (void);
in_addr_t gf_resolve_ip (const char *hostname, void **dnscache);
diff --git a/libglusterfs/src/fd.c b/libglusterfs/src/fd.c
index b01caf765ff..d26854ebdfb 100644
--- a/libglusterfs/src/fd.c
+++ b/libglusterfs/src/fd.c
@@ -30,17 +30,18 @@
#endif
-static uint32_t
+static int
gf_fd_fdtable_expand (fdtable_t *fdtable, uint32_t nr);
+
static fd_t *
_fd_ref (fd_t *fd);
-/*
- Allocate in memory chunks of power of 2 starting from 1024B
+/*
+ Allocate in memory chunks of power of 2 starting from 1024B
Assumes fdtable->lock is held
*/
-static inline uint32_t
+static inline int
gf_roundup_power_of_two (uint32_t nr)
{
uint32_t result = 1;
@@ -58,6 +59,7 @@ gf_roundup_power_of_two (uint32_t nr)
return result;
}
+
static int
gf_fd_chain_fd_entries (fdentry_t *entries, uint32_t startidx,
uint32_t endcount)
@@ -80,18 +82,17 @@ gf_fd_chain_fd_entries (fdentry_t *entries, uint32_t startidx,
}
-static uint32_t
+static int
gf_fd_fdtable_expand (fdtable_t *fdtable, uint32_t nr)
{
- fdentry_t *oldfds = NULL;
- uint32_t oldmax_fds = -1;
-
- if (fdtable == NULL || nr < 0)
- {
+ fdentry_t *oldfds = NULL;
+ uint32_t oldmax_fds = -1;
+
+ if (fdtable == NULL || nr < 0) {
gf_log ("fd", GF_LOG_ERROR, "invalid argument");
return EINVAL;
}
-
+
nr /= (1024 / sizeof (fdentry_t));
nr = gf_roundup_power_of_two (nr + 1);
nr *= (1024 / sizeof (fdentry_t));
@@ -102,7 +103,7 @@ gf_fd_fdtable_expand (fdtable_t *fdtable, uint32_t nr)
fdtable->fdentries = GF_CALLOC (nr, sizeof (fdentry_t),
gf_common_mt_fdentry_t);
ERR_ABORT (fdtable->fdentries);
- fdtable->max_fds = nr;
+ fdtable->max_fds = nr;
if (oldfds) {
uint32_t cpy = oldmax_fds * sizeof (fdentry_t);
@@ -121,8 +122,9 @@ gf_fd_fdtable_expand (fdtable_t *fdtable, uint32_t nr)
return 0;
}
+
fdtable_t *
-gf_fd_fdtable_alloc (void)
+gf_fd_fdtable_alloc (void)
{
fdtable_t *fdtable = NULL;
@@ -141,6 +143,7 @@ gf_fd_fdtable_alloc (void)
return fdtable;
}
+
fdentry_t *
__gf_fd_fdtable_get_all_fds (fdtable_t *fdtable, uint32_t *count)
{
@@ -160,10 +163,12 @@ out:
return fdentries;
}
+
fdentry_t *
gf_fd_fdtable_get_all_fds (fdtable_t *fdtable, uint32_t *count)
{
fdentry_t *entries = NULL;
+
if (fdtable) {
pthread_mutex_lock (&fdtable->lock);
{
@@ -175,14 +180,15 @@ gf_fd_fdtable_get_all_fds (fdtable_t *fdtable, uint32_t *count)
return entries;
}
-void
+
+void
gf_fd_fdtable_destroy (fdtable_t *fdtable)
{
struct list_head list = {0, };
fd_t *fd = NULL;
fdentry_t *fdentries = NULL;
uint32_t fd_count = 0;
- int32_t i = 0;
+ int32_t i = 0;
INIT_LIST_HEAD (&list);
@@ -210,20 +216,21 @@ gf_fd_fdtable_destroy (fdtable_t *fdtable)
}
}
-int32_t
+
+int
gf_fd_unused_get (fdtable_t *fdtable, fd_t *fdptr)
{
int32_t fd = -1;
fdentry_t *fde = NULL;
int error;
int alloc_attempts = 0;
-
+
if (fdtable == NULL || fdptr == NULL)
{
gf_log ("fd", GF_LOG_ERROR, "invalid argument");
return EINVAL;
}
-
+
pthread_mutex_lock (&fdtable->lock);
{
fd_alloc_try_again:
@@ -268,20 +275,18 @@ out:
}
-inline void
+inline void
gf_fd_put (fdtable_t *fdtable, int32_t fd)
{
fd_t *fdptr = NULL;
fdentry_t *fde = NULL;
- if (fdtable == NULL || fd < 0)
- {
+ if (fdtable == NULL || fd < 0) {
gf_log ("fd", GF_LOG_ERROR, "invalid argument");
return;
}
-
- if (!(fd < fdtable->max_fds))
- {
+
+ if (!(fd < fdtable->max_fds)) {
gf_log ("fd", GF_LOG_ERROR, "invalid argument");
return;
}
@@ -316,16 +321,14 @@ fd_t *
gf_fd_fdptr_get (fdtable_t *fdtable, int64_t fd)
{
fd_t *fdptr = NULL;
-
- if (fdtable == NULL || fd < 0)
- {
+
+ if (fdtable == NULL || fd < 0) {
gf_log ("fd", GF_LOG_ERROR, "invalid argument");
errno = EINVAL;
return NULL;
}
-
- if (!(fd < fdtable->max_fds))
- {
+
+ if (!(fd < fdtable->max_fds)) {
gf_log ("fd", GF_LOG_ERROR, "invalid argument");
errno = EINVAL;
return NULL;
@@ -343,14 +346,16 @@ gf_fd_fdptr_get (fdtable_t *fdtable, int64_t fd)
return fdptr;
}
+
fd_t *
_fd_ref (fd_t *fd)
{
++fd->refcount;
-
+
return fd;
}
+
fd_t *
fd_ref (fd_t *fd)
{
@@ -364,10 +369,11 @@ fd_ref (fd_t *fd)
LOCK (&fd->inode->lock);
refed_fd = _fd_ref (fd);
UNLOCK (&fd->inode->lock);
-
+
return refed_fd;
}
+
fd_t *
_fd_unref (fd_t *fd)
{
@@ -375,25 +381,26 @@ _fd_unref (fd_t *fd)
--fd->refcount;
- if (fd->refcount == 0){
+ if (fd->refcount == 0) {
list_del_init (&fd->inode_list);
}
-
+
return fd;
}
+
static void
fd_destroy (fd_t *fd)
{
xlator_t *xl = NULL;
- int i = 0;
+ int i = 0;
xlator_t *old_THIS = NULL;
if (fd == NULL){
gf_log ("xlator", GF_LOG_ERROR, "invalid arugument");
goto out;
}
-
+
if (fd->inode == NULL){
gf_log ("xlator", GF_LOG_ERROR, "fd->inode is NULL");
goto out;
@@ -402,7 +409,7 @@ fd_destroy (fd_t *fd)
goto out;
if (IA_ISDIR (fd->inode->ia_type)) {
- for (i = 0; i < fd->inode->table->xl->ctx->xl_count; i++) {
+ for (i = 0; i < fd->inode->table->xl->graph->xl_count; i++) {
if (fd->_ctx[i].key) {
xl = (xlator_t *)(long)fd->_ctx[i].key;
old_THIS = THIS;
@@ -413,7 +420,7 @@ fd_destroy (fd_t *fd)
}
}
} else {
- for (i = 0; i < fd->inode->table->xl->ctx->xl_count; i++) {
+ for (i = 0; i < fd->inode->table->xl->graph->xl_count; i++) {
if (fd->_ctx[i].key) {
xl = (xlator_t *)(long)fd->_ctx[i].key;
old_THIS = THIS;
@@ -424,18 +431,18 @@ fd_destroy (fd_t *fd)
}
}
}
-
+
LOCK_DESTROY (&fd->lock);
GF_FREE (fd->_ctx);
inode_unref (fd->inode);
fd->inode = (inode_t *)0xaaaaaaaa;
GF_FREE (fd);
-
out:
return;
}
+
void
fd_unref (fd_t *fd)
{
@@ -445,14 +452,14 @@ fd_unref (fd_t *fd)
gf_log ("fd.c", GF_LOG_ERROR, "fd is NULL");
return;
}
-
+
LOCK (&fd->inode->lock);
{
_fd_unref (fd);
refcount = fd->refcount;
}
UNLOCK (&fd->inode->lock);
-
+
if (refcount == 0) {
fd_destroy (fd);
}
@@ -460,6 +467,7 @@ fd_unref (fd_t *fd)
return ;
}
+
fd_t *
fd_bind (fd_t *fd)
{
@@ -476,7 +484,7 @@ fd_bind (fd_t *fd)
list_add (&fd->inode_list, &inode->fd_list);
}
UNLOCK (&inode->lock);
-
+
return fd;
}
@@ -484,22 +492,23 @@ fd_t *
fd_create (inode_t *inode, pid_t pid)
{
fd_t *fd = NULL;
-
+
if (inode == NULL) {
gf_log ("fd", GF_LOG_ERROR, "invalid argument");
return NULL;
}
-
+
fd = GF_CALLOC (1, sizeof (fd_t), gf_common_mt_fd_t);
ERR_ABORT (fd);
-
+
fd->_ctx = GF_CALLOC (1, (sizeof (struct _fd_ctx) *
- inode->table->xl->ctx->xl_count),
+ inode->table->xl->graph->xl_count),
gf_common_mt_fd_ctx);
+
fd->inode = inode_ref (inode);
fd->pid = pid;
INIT_LIST_HEAD (&fd->inode_list);
-
+
LOCK_INIT (&fd->lock);
LOCK (&inode->lock);
@@ -509,6 +518,7 @@ fd_create (inode_t *inode, pid_t pid)
return fd;
}
+
fd_t *
fd_lookup (inode_t *inode, pid_t pid)
{
@@ -537,24 +547,26 @@ fd_lookup (inode_t *inode, pid_t pid)
}
}
UNLOCK (&inode->lock);
-
+
return fd;
}
+
uint8_t
fd_list_empty (inode_t *inode)
{
- uint8_t empty = 0;
+ uint8_t empty = 0;
LOCK (&inode->lock);
{
empty = list_empty (&inode->fd_list);
}
UNLOCK (&inode->lock);
-
+
return empty;
}
+
int
__fd_ctx_set (fd_t *fd, xlator_t *xlator, uint64_t value)
{
@@ -564,8 +576,8 @@ __fd_ctx_set (fd_t *fd, xlator_t *xlator, uint64_t value)
if (!fd || !xlator)
return -1;
-
- for (index = 0; index < xlator->ctx->xl_count; index++) {
+
+ for (index = 0; index < xlator->graph->xl_count; index++) {
if (!fd->_ctx[index].key) {
if (set_idx == -1)
set_idx = index;
@@ -577,12 +589,12 @@ __fd_ctx_set (fd_t *fd, xlator_t *xlator, uint64_t value)
break;
}
}
-
+
if (set_idx == -1) {
ret = -1;
goto out;
}
-
+
fd->_ctx[set_idx].key = (uint64_t)(long) xlator;
fd->_ctx[set_idx].value = value;
@@ -598,7 +610,7 @@ fd_ctx_set (fd_t *fd, xlator_t *xlator, uint64_t value)
if (!fd || !xlator)
return -1;
-
+
LOCK (&fd->lock);
{
ret = __fd_ctx_set (fd, xlator, value);
@@ -609,7 +621,7 @@ fd_ctx_set (fd_t *fd, xlator_t *xlator, uint64_t value)
}
-int
+int
__fd_ctx_get (fd_t *fd, xlator_t *xlator, uint64_t *value)
{
int index = 0;
@@ -617,26 +629,26 @@ __fd_ctx_get (fd_t *fd, xlator_t *xlator, uint64_t *value)
if (!fd || !xlator)
return -1;
-
- for (index = 0; index < xlator->ctx->xl_count; index++) {
+
+ for (index = 0; index < xlator->graph->xl_count; index++) {
if (fd->_ctx[index].key == (uint64_t)(long)xlator)
break;
}
-
- if (index == xlator->ctx->xl_count) {
+
+ if (index == xlator->graph->xl_count) {
ret = -1;
goto out;
}
- if (value)
+ if (value)
*value = fd->_ctx[index].value;
-
+
out:
return ret;
}
-int
+int
fd_ctx_get (fd_t *fd, xlator_t *xlator, uint64_t *value)
{
int ret = 0;
@@ -654,7 +666,7 @@ fd_ctx_get (fd_t *fd, xlator_t *xlator, uint64_t *value)
}
-int
+int
__fd_ctx_del (fd_t *fd, xlator_t *xlator, uint64_t *value)
{
int index = 0;
@@ -662,20 +674,20 @@ __fd_ctx_del (fd_t *fd, xlator_t *xlator, uint64_t *value)
if (!fd || !xlator)
return -1;
-
- for (index = 0; index < xlator->ctx->xl_count; index++) {
+
+ for (index = 0; index < xlator->graph->xl_count; index++) {
if (fd->_ctx[index].key == (uint64_t)(long)xlator)
break;
}
-
- if (index == xlator->ctx->xl_count) {
+
+ if (index == xlator->graph->xl_count) {
ret = -1;
goto out;
}
-
- if (value)
- *value = fd->_ctx[index].value;
-
+
+ if (value)
+ *value = fd->_ctx[index].value;
+
fd->_ctx[index].key = 0;
fd->_ctx[index].value = 0;
@@ -684,14 +696,14 @@ out:
}
-int
+int
fd_ctx_del (fd_t *fd, xlator_t *xlator, uint64_t *value)
{
int ret = 0;
if (!fd || !xlator)
return -1;
-
+
LOCK (&fd->lock);
{
ret = __fd_ctx_del (fd, xlator, value);
@@ -709,7 +721,7 @@ fd_dump (fd_t *fd, char *prefix)
if (!fd)
return;
-
+
memset(key, 0, sizeof(key));
gf_proc_dump_build_key(key, prefix, "pid");
gf_proc_dump_write(key, "%d", fd->pid);
@@ -733,10 +745,11 @@ fdentry_dump (fdentry_t *fdentry, char *prefix)
if (GF_FDENTRY_ALLOCATED != fdentry->next_free)
return;
- if (fdentry->fd)
+ if (fdentry->fd)
fd_dump(fdentry->fd, prefix);
}
+
void
fdtable_dump (fdtable_t *fdtable, char *prefix)
{
@@ -746,7 +759,7 @@ fdtable_dump (fdtable_t *fdtable, char *prefix)
if (!fdtable)
return;
-
+
ret = pthread_mutex_trylock (&fdtable->lock);
if (ret) {
@@ -763,7 +776,7 @@ fdtable_dump (fdtable_t *fdtable, char *prefix)
gf_proc_dump_write(key, "%d", fdtable->first_free);
for ( i = 0 ; i < fdtable->max_fds; i++) {
- if (GF_FDENTRY_ALLOCATED ==
+ if (GF_FDENTRY_ALLOCATED ==
fdtable->fdentries[i].next_free) {
gf_proc_dump_build_key(key, prefix, "fdentry[%d]", i);
gf_proc_dump_add_section(key);
@@ -773,4 +786,3 @@ fdtable_dump (fdtable_t *fdtable, char *prefix)
pthread_mutex_unlock(&fdtable->lock);
}
-
diff --git a/libglusterfs/src/fd.h b/libglusterfs/src/fd.h
index 9c5ebd8d786..c2181d8af17 100644
--- a/libglusterfs/src/fd.h
+++ b/libglusterfs/src/fd.h
@@ -33,9 +33,10 @@
struct _inode;
struct _dict;
+
struct _fd_ctx {
- uint64_t key;
- uint64_t value;
+ uint64_t key;
+ uint64_t value;
};
/* If this structure changes, please have mercy on the booster maintainer
@@ -55,12 +56,14 @@ struct _fd {
};
typedef struct _fd fd_t;
+
struct fd_table_entry {
fd_t *fd;
int next_free;
};
typedef struct fd_table_entry fdentry_t;
+
struct _fdtable {
int refcount;
uint32_t max_fds;
@@ -70,6 +73,7 @@ struct _fdtable {
};
typedef struct _fdtable fdtable_t;
+
/* Signifies no more entries in the fd table. */
#define GF_FDTABLE_END -1
@@ -81,58 +85,77 @@ typedef struct _fdtable fdtable_t;
#include "logging.h"
#include "xlator.h"
-inline void
+
+inline void
gf_fd_put (fdtable_t *fdtable, int32_t fd);
+
fd_t *
gf_fd_fdptr_get (fdtable_t *fdtable, int64_t fd);
+
fdtable_t *
gf_fd_fdtable_alloc (void);
-int32_t
+
+int
gf_fd_unused_get (fdtable_t *fdtable, fd_t *fdptr);
+
fdentry_t *
gf_fd_fdtable_get_all_fds (fdtable_t *fdtable, uint32_t *count);
-void
+
+void
gf_fd_fdtable_destroy (fdtable_t *fdtable);
+
fd_t *
fd_ref (fd_t *fd);
+
void
fd_unref (fd_t *fd);
+
fd_t *
fd_create (struct _inode *inode, pid_t pid);
+
fd_t *
fd_lookup (struct _inode *inode, pid_t pid);
+
uint8_t
fd_list_empty (struct _inode *inode);
+
fd_t *
fd_bind (fd_t *fd);
+
int
fd_ctx_set (fd_t *fd, xlator_t *xlator, uint64_t value);
-int
+
+int
fd_ctx_get (fd_t *fd, xlator_t *xlator, uint64_t *value);
-int
+
+int
fd_ctx_del (fd_t *fd, xlator_t *xlator, uint64_t *value);
+
int
__fd_ctx_set (fd_t *fd, xlator_t *xlator, uint64_t value);
-int
+
+int
__fd_ctx_get (fd_t *fd, xlator_t *xlator, uint64_t *value);
-int
+
+int
__fd_ctx_del (fd_t *fd, xlator_t *xlator, uint64_t *value);
+
#endif /* _FD_H */
diff --git a/libglusterfs/src/globals.c b/libglusterfs/src/globals.c
index 9677a169ecb..d480f089fcb 100644
--- a/libglusterfs/src/globals.c
+++ b/libglusterfs/src/globals.c
@@ -24,12 +24,73 @@
#include <pthread.h>
-#include "globals.h"
#include "glusterfs.h"
+#include "globals.h"
#include "xlator.h"
#include "mem-pool.h"
+/* gf_*_list[] */
+
+char *gf_fop_list[GF_FOP_MAXVALUE];
+char *gf_mgmt_list[GF_MGMT_MAXVALUE];
+
+
+void
+gf_op_list_init()
+{
+ gf_fop_list[GF_FOP_NULL] = "NULL";
+ gf_fop_list[GF_FOP_STAT] = "STAT";
+ gf_fop_list[GF_FOP_READLINK] = "READLINK";
+ gf_fop_list[GF_FOP_MKNOD] = "MKNOD";
+ gf_fop_list[GF_FOP_MKDIR] = "MKDIR";
+ gf_fop_list[GF_FOP_UNLINK] = "UNLINK";
+ gf_fop_list[GF_FOP_RMDIR] = "RMDIR";
+ gf_fop_list[GF_FOP_SYMLINK] = "SYMLINK";
+ gf_fop_list[GF_FOP_RENAME] = "RENAME";
+ gf_fop_list[GF_FOP_LINK] = "LINK";
+ gf_fop_list[GF_FOP_TRUNCATE] = "TRUNCATE";
+ gf_fop_list[GF_FOP_OPEN] = "OPEN";
+ gf_fop_list[GF_FOP_READ] = "READ";
+ gf_fop_list[GF_FOP_WRITE] = "WRITE";
+ gf_fop_list[GF_FOP_STATFS] = "STATFS";
+ gf_fop_list[GF_FOP_FLUSH] = "FLUSH";
+ gf_fop_list[GF_FOP_FSYNC] = "FSYNC";
+ gf_fop_list[GF_FOP_SETXATTR] = "SETXATTR";
+ gf_fop_list[GF_FOP_GETXATTR] = "GETXATTR";
+ gf_fop_list[GF_FOP_REMOVEXATTR] = "REMOVEXATTR";
+ gf_fop_list[GF_FOP_OPENDIR] = "OPENDIR";
+ gf_fop_list[GF_FOP_FSYNCDIR] = "FSYNCDIR";
+ gf_fop_list[GF_FOP_ACCESS] = "ACCESS";
+ gf_fop_list[GF_FOP_CREATE] = "CREATE";
+ gf_fop_list[GF_FOP_FTRUNCATE] = "FTRUNCATE";
+ gf_fop_list[GF_FOP_FSTAT] = "FSTAT";
+ gf_fop_list[GF_FOP_LK] = "LK";
+ gf_fop_list[GF_FOP_LOOKUP] = "LOOKUP";
+ gf_fop_list[GF_FOP_READDIR] = "READDIR";
+ gf_fop_list[GF_FOP_INODELK] = "INODELK";
+ gf_fop_list[GF_FOP_FINODELK] = "FINODELK";
+ gf_fop_list[GF_FOP_ENTRYLK] = "ENTRYLK";
+ gf_fop_list[GF_FOP_FENTRYLK] = "FENTRYLK";
+ gf_fop_list[GF_FOP_CHECKSUM] = "CHECKSUM";
+ gf_fop_list[GF_FOP_XATTROP] = "XATTROP";
+ gf_fop_list[GF_FOP_FXATTROP] = "FXATTROP";
+ gf_fop_list[GF_FOP_FSETXATTR] = "FSETXATTR";
+ gf_fop_list[GF_FOP_FGETXATTR] = "FGETXATTR";
+ gf_fop_list[GF_FOP_RCHECKSUM] = "RCHECKSUM";
+ gf_fop_list[GF_FOP_SETATTR] = "SETATTR";
+ gf_fop_list[GF_FOP_FSETATTR] = "FSETATTR";
+ gf_fop_list[GF_FOP_READDIRP] = "READDIRP";
+ gf_fop_list[GF_FOP_GETSPEC] = "GETSPEC";
+ gf_fop_list[GF_FOP_FORGET] = "FORGET";
+ gf_fop_list[GF_FOP_RELEASE] = "RELEASE";
+ gf_fop_list[GF_FOP_RELEASEDIR] = "RELEASEDIR";
+
+ gf_fop_list[GF_MGMT_NULL] = "NULL";
+ return;
+}
+
+
/* CTX */
static glusterfs_ctx_t *glusterfs_ctx;
@@ -48,6 +109,7 @@ glusterfs_ctx_init ()
goto out;
}
+ INIT_LIST_HEAD (&glusterfs_ctx->graphs);
ret = pthread_mutex_init (&glusterfs_ctx->lock, NULL);
out:
@@ -168,7 +230,7 @@ glusterfs_central_log_flag_init ()
{
int ret = 0;
- ret = pthread_key_create (&central_log_flag_key,
+ ret = pthread_key_create (&central_log_flag_key,
glusterfs_central_log_flag_destroy);
if (ret != 0) {
@@ -194,7 +256,7 @@ glusterfs_central_log_flag_get ()
long flag = 0;
flag = (long) pthread_getspecific (central_log_flag_key);
-
+
return flag;
}
@@ -211,6 +273,8 @@ glusterfs_globals_init ()
{
int ret = 0;
+ gf_op_list_init ();
+
ret = glusterfs_ctx_init ();
if (ret)
goto out;
diff --git a/libglusterfs/src/globals.h b/libglusterfs/src/globals.h
index 58f37d185bd..e09c695113c 100644
--- a/libglusterfs/src/globals.h
+++ b/libglusterfs/src/globals.h
@@ -27,13 +27,14 @@
#define GF_REQUEST_MAXGROUPS 16
#include "glusterfs.h"
-#include "xlator.h"
/* CTX */
#define CTX (glusterfs_ctx_get())
glusterfs_ctx_t *glusterfs_ctx_get ();
+#include "xlator.h"
+
/* THIS */
#define THIS (*__glusterfs_this_location())
diff --git a/libglusterfs/src/glusterfs.h b/libglusterfs/src/glusterfs.h
index f4134d9ea25..b6db51489c1 100644
--- a/libglusterfs/src/glusterfs.h
+++ b/libglusterfs/src/glusterfs.h
@@ -45,6 +45,7 @@
#include "list.h"
#include "logging.h"
+
#define GF_YES 1
#define GF_NO 0
@@ -95,7 +96,7 @@ typedef enum {
GF_FOP_WRITE,
GF_FOP_STATFS,
GF_FOP_FLUSH,
- GF_FOP_FSYNC,
+ GF_FOP_FSYNC, /* 15 */
GF_FOP_SETXATTR,
GF_FOP_GETXATTR,
GF_FOP_REMOVEXATTR,
@@ -104,7 +105,7 @@ typedef enum {
GF_FOP_ACCESS,
GF_FOP_CREATE,
GF_FOP_FTRUNCATE,
- GF_FOP_FSTAT,
+ GF_FOP_FSTAT, /* 25 */
GF_FOP_LK,
GF_FOP_LOOKUP,
GF_FOP_READDIR,
@@ -141,6 +142,7 @@ typedef enum {
GF_OP_TYPE_MAX,
} gf_op_type_t;
+
/* NOTE: all the miscellaneous flags used by GlusterFS should be listed here */
typedef enum {
GF_LK_GETLK = 0,
@@ -148,32 +150,38 @@ typedef enum {
GF_LK_SETLKW,
} glusterfs_lk_cmds_t;
+
typedef enum {
GF_LK_F_RDLCK = 0,
GF_LK_F_WRLCK,
GF_LK_F_UNLCK
} glusterfs_lk_types_t;
+
typedef enum {
- GF_LOCK_POSIX,
+ GF_LOCK_POSIX,
GF_LOCK_INTERNAL
} gf_lk_domain_t;
+
typedef enum {
ENTRYLK_LOCK,
ENTRYLK_UNLOCK,
ENTRYLK_LOCK_NB
} entrylk_cmd;
+
typedef enum {
ENTRYLK_RDLCK,
ENTRYLK_WRLCK
} entrylk_type;
+
typedef enum {
GF_XATTROP_ADD_ARRAY,
} gf_xattrop_flags_t;
+
#define GF_SET_IF_NOT_PRESENT 0x1 /* default behaviour */
#define GF_SET_OVERWRITE 0x2 /* Overwrite with the buf given */
#define GF_SET_DIR_ONLY 0x4
@@ -186,17 +194,18 @@ typedef enum {
#define GF_REPLICATE_TRASH_DIR ".landfill"
struct _xlator_cmdline_option {
- struct list_head cmd_args;
- char *volume;
- char *key;
- char *value;
+ struct list_head cmd_args;
+ char *volume;
+ char *key;
+ char *value;
};
typedef struct _xlator_cmdline_option xlator_cmdline_option_t;
+
struct _cmd_args {
/* basic options */
char *volfile_server;
- char *volume_file;
+ char *volfile;
char *log_server;
gf_loglevel_t log_level;
char *log_file;
@@ -229,41 +238,61 @@ struct _cmd_args {
};
typedef struct _cmd_args cmd_args_t;
-struct _glusterfs_ctx {
- cmd_args_t cmd_args;
- char *process_uuid;
- FILE *specfp;
- FILE *pidfp;
- char fin;
- void *timer;
- void *ib;
- void *pool;
- void *graph;
- void *top; /* either fuse or server protocol */
- void *event_pool;
- void *iobuf_pool;
- pthread_mutex_t lock;
- int xl_count;
- uint32_t volfile_checksum;
- size_t page_size;
- unsigned char measure_latency; /* toggle switch for latency measurement */
+
+struct _glusterfs_graph {
+ struct list_head list;
+ char graph_uuid[128];
+ struct timeval dob;
+ void *first;
+ void *top; /* selected by -n */
+ int xl_count;
+ uint32_t volfile_checksum;
};
+typedef struct _glusterfs_graph glusterfs_graph_t;
+
+struct _glusterfs_ctx {
+ cmd_args_t cmd_args;
+ char *process_uuid;
+ FILE *pidfp;
+ char fin;
+ void *timer;
+ void *ib;
+ void *pool;
+ void *event_pool;
+ void *iobuf_pool;
+ pthread_mutex_t lock;
+ size_t page_size;
+ struct list_head graphs; /* double linked list of graphs - one per volfile parse */
+ glusterfs_graph_t *active; /* the latest graph in use */
+ void *master; /* fuse, or libglusterfsclient (however, not protocol/server) */
+ void *mgmt; /* xlator implementing MOPs for centralized logging, volfile server */
+ unsigned char measure_latency; /* toggle switch for latency measurement */
+ pthread_t sigwaiter;
+};
typedef struct _glusterfs_ctx glusterfs_ctx_t;
+
typedef enum {
- GF_EVENT_PARENT_UP = 1,
- GF_EVENT_POLLIN,
- GF_EVENT_POLLOUT,
- GF_EVENT_POLLERR,
- GF_EVENT_CHILD_UP,
- GF_EVENT_CHILD_DOWN,
- GF_EVENT_CHILD_CONNECTING,
- GF_EVENT_TRANSPORT_CLEANUP,
- GF_EVENT_TRANSPORT_CONNECTED,
- GF_EVENT_VOLFILE_MODIFIED,
+ GF_EVENT_PARENT_UP = 1,
+ GF_EVENT_POLLIN,
+ GF_EVENT_POLLOUT,
+ GF_EVENT_POLLERR,
+ GF_EVENT_CHILD_UP,
+ GF_EVENT_CHILD_DOWN,
+ GF_EVENT_CHILD_CONNECTING,
+ GF_EVENT_TRANSPORT_CLEANUP,
+ GF_EVENT_TRANSPORT_CONNECTED,
+ GF_EVENT_VOLFILE_MODIFIED,
+ GF_EVENT_GRAPH_NEW,
} glusterfs_event_t;
+
#define GF_MUST_CHECK __attribute__((warn_unused_result))
+int glusterfs_graph_prepare (glusterfs_graph_t *graph, glusterfs_ctx_t *ctx);
+int glusterfs_graph_destroy (glusterfs_graph_t *graph);
+int glusterfs_graph_activate (glusterfs_ctx_t *ctx, glusterfs_graph_t *graph);
+glusterfs_graph_t *glusterfs_graph_construct (FILE *fp);
+glusterfs_graph_t *glusterfs_graph_new ();
#endif /* _GLUSTERFS_H */
diff --git a/libglusterfs/src/graph.c b/libglusterfs/src/graph.c
new file mode 100644
index 00000000000..a59b427bffe
--- /dev/null
+++ b/libglusterfs/src/graph.c
@@ -0,0 +1,499 @@
+/*
+ Copyright (c) 2010 Gluster, Inc. <http://www.gluster.com>
+ This file is part of GlusterFS.
+
+ GlusterFS is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published
+ by the Free Software Foundation; either version 3 of the License,
+ or (at your option) any later version.
+
+ GlusterFS is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see
+ <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _CONFIG_H
+#define _CONFIG_H
+#include "config.h"
+#endif
+
+#include "xlator.h"
+#include <dlfcn.h>
+#include <netdb.h>
+#include <fnmatch.h>
+#include "defaults.h"
+
+
+
+
+#if 0
+static void
+_gf_dump_details (int argc, char **argv)
+{
+ extern FILE *gf_log_logfile;
+ int i = 0;
+ char timestr[256];
+ time_t utime = 0;
+ struct tm *tm = NULL;
+ pid_t mypid = 0;
+ struct utsname uname_buf = {{0, }, };
+ int uname_ret = -1;
+
+ utime = time (NULL);
+ tm = localtime (&utime);
+ mypid = getpid ();
+ uname_ret = uname (&uname_buf);
+
+ /* Which git? What time? */
+ strftime (timestr, 256, "%Y-%m-%d %H:%M:%S", tm);
+ fprintf (gf_log_logfile,
+ "========================================"
+ "========================================\n");
+ fprintf (gf_log_logfile, "Version : %s %s built on %s %s\n",
+ PACKAGE_NAME, PACKAGE_VERSION, __DATE__, __TIME__);
+ fprintf (gf_log_logfile, "git: %s\n",
+ GLUSTERFS_REPOSITORY_REVISION);
+ fprintf (gf_log_logfile, "Starting Time: %s\n", timestr);
+ fprintf (gf_log_logfile, "Command line : ");
+ for (i = 0; i < argc; i++) {
+ fprintf (gf_log_logfile, "%s ", argv[i]);
+ }
+
+ fprintf (gf_log_logfile, "\nPID : %d\n", mypid);
+
+ if (uname_ret == 0) {
+ fprintf (gf_log_logfile, "System name : %s\n",
+ uname_buf.sysname);
+ fprintf (gf_log_logfile, "Nodename : %s\n",
+ uname_buf.nodename);
+ fprintf (gf_log_logfile, "Kernel Release : %s\n",
+ uname_buf.release);
+ fprintf (gf_log_logfile, "Hardware Identifier: %s\n",
+ uname_buf.machine);
+ }
+
+
+ fprintf (gf_log_logfile, "\n");
+ fflush (gf_log_logfile);
+}
+#endif
+
+
+static int
+_log_if_option_is_invalid (xlator_t *xl, data_pair_t *pair)
+{
+ volume_opt_list_t *vol_opt = NULL;
+ volume_option_t *opt = NULL;
+ int i = 0;
+ int index = 0;
+ int found = 0;
+
+ /* Get the first volume_option */
+ list_for_each_entry (vol_opt, &xl->volume_options, list) {
+ /* Warn for extra option */
+ if (!vol_opt->given_opt)
+ break;
+
+ opt = vol_opt->given_opt;
+ for (index = 0;
+ ((index < ZR_OPTION_MAX_ARRAY_SIZE) &&
+ (opt[index].key && opt[index].key[0])); index++)
+ for (i = 0; (i < ZR_VOLUME_MAX_NUM_KEY) &&
+ opt[index].key[i]; i++) {
+ if (fnmatch (opt[index].key[i],
+ pair->key,
+ FNM_NOESCAPE) == 0) {
+ found = 1;
+ break;
+ }
+ }
+ }
+
+ if (!found) {
+ gf_log (xl->name, GF_LOG_WARNING,
+ "option '%s' is not recognized",
+ pair->key);
+ }
+ return 0;
+}
+
+
+int
+glusterfs_graph_insert (glusterfs_graph_t *graph, glusterfs_ctx_t *ctx,
+ const char *type, const char *name)
+{
+ xlator_t *ixl = NULL;
+ xlator_list_t *xlchild = NULL;
+ xlator_list_t *xlparent = NULL;
+
+ ixl = GF_CALLOC (1, sizeof (*ixl), gf_common_mt_xlator_t);
+ if (!ixl)
+ return -1;
+
+ ixl->ctx = ctx;
+ ixl->graph = graph;
+ ixl->options = get_new_dict ();
+ if (!ixl->options)
+ goto err;
+
+ ixl->name = gf_strdup (name);
+ if (!ixl->name)
+ goto err;
+
+ if (xlator_set_type (ixl, type) == -1) {
+ gf_log ("glusterfs", GF_LOG_ERROR,
+ "%s (%s) initialization failed",
+ name, type);
+ return -1;
+ }
+
+
+ /* children */
+ xlchild = GF_CALLOC (sizeof (*xlchild), 1, gf_common_mt_xlator_list_t);
+ if (!xlchild)
+ goto err;
+ xlchild->xlator = graph->top;
+ ixl->children = xlchild; xlchild = NULL;
+
+
+ /* parent */
+ xlparent = GF_CALLOC (sizeof (*xlparent), 1,
+ gf_common_mt_xlator_list_t);
+ if (!xlparent)
+ goto err;
+ xlparent->xlator = ixl;
+
+ ixl->next = graph->first;
+ graph->first = ixl;
+
+ xlparent->next = ((xlator_t *)graph->top)->parents;
+ ((xlator_t *)graph->top)->parents = xlparent;
+
+ graph->top = ixl;
+
+ graph->xl_count++;
+
+ return 0;
+err:
+ xlator_destroy (ixl);
+ return -1;
+}
+
+
+int
+glusterfs_graph_readonly (glusterfs_graph_t *graph, glusterfs_ctx_t *ctx)
+{
+ int ret = 0;
+ cmd_args_t *cmd_args = NULL;
+
+ cmd_args = &ctx->cmd_args;
+
+ if (!cmd_args->read_only)
+ return 0;
+
+ ret = glusterfs_graph_insert (graph, ctx, "features/read-only",
+ "readonly-autoload");
+ return ret;
+}
+
+
+int
+glusterfs_graph_mac_compat (glusterfs_graph_t *graph, glusterfs_ctx_t *ctx)
+{
+ int ret = 0;
+ cmd_args_t *cmd_args = NULL;
+
+ cmd_args = &ctx->cmd_args;
+
+#ifdef GF_DARWIN_HOST_OS
+ if (!cmd_args->mac_compat)
+ return 0;
+
+ ret = glusterfs_graph_insert (graph, ctx, ZR_XLATOR_MAC_COMPAT,
+ "mac-compat-autoload");
+#endif
+
+ return ret;
+}
+
+
+static void
+gf_add_cmdline_options (glusterfs_graph_t *graph, cmd_args_t *cmd_args)
+{
+ int ret = 0;
+ xlator_t *trav = NULL;
+ xlator_cmdline_option_t *cmd_option = NULL;
+
+ trav = graph->first;
+
+ while (trav) {
+ list_for_each_entry (cmd_option,
+ &cmd_args->xlator_options, cmd_args) {
+ if (!fnmatch (cmd_option->volume,
+ trav->name, FNM_NOESCAPE)) {
+ ret = dict_set_str (trav->options,
+ cmd_option->key,
+ cmd_option->value);
+ if (ret == 0) {
+ gf_log (trav->name, GF_LOG_WARNING,
+ "adding option '%s' for "
+ "volume '%s' with value '%s'",
+ cmd_option->key, trav->name,
+ cmd_option->value);
+ } else {
+ gf_log (trav->name, GF_LOG_WARNING,
+ "adding option '%s' for "
+ "volume '%s' failed: %s",
+ cmd_option->key, trav->name,
+ strerror (-ret));
+ }
+ }
+ }
+ trav = trav->next;
+ }
+}
+
+
+int
+glusterfs_graph_validate_options (glusterfs_graph_t *graph)
+{
+ volume_opt_list_t *vol_opt = NULL;
+ xlator_t *trav = NULL;
+ int ret = -1;
+
+ trav = graph->first;
+
+ while (trav) {
+ if (list_empty (&trav->volume_options))
+ continue;
+
+ vol_opt = list_entry (trav->volume_options.next,
+ volume_opt_list_t, list);
+
+ ret = validate_xlator_volume_options (trav,
+ vol_opt->given_opt);
+ if (ret) {
+ gf_log (trav->name, GF_LOG_ERROR,
+ "validating translator failed");
+ return ret;
+ }
+ trav = trav->next;
+ }
+
+ return 0;
+}
+
+
+int
+glusterfs_graph_init (glusterfs_graph_t *graph)
+{
+ xlator_t *trav = NULL;
+ int ret = -1;
+
+ trav = graph->first;
+
+ while (trav) {
+ ret = xlator_init (trav);
+ if (ret) {
+ gf_log (trav->name, GF_LOG_ERROR,
+ "initializing translator failed");
+ return ret;
+ }
+ trav = trav->next;
+ }
+
+ return 0;
+}
+
+
+int
+glusterfs_graph_unknown_options (glusterfs_graph_t *graph)
+{
+ data_pair_t *pair = NULL;
+ xlator_t *trav = NULL;
+
+ trav = graph->first;
+
+ /* Validate again phase */
+ while (trav) {
+ pair = trav->options->members_list;
+ while (pair) {
+ _log_if_option_is_invalid (trav, pair);
+ pair = pair->next;
+ }
+ trav = trav->next;
+ }
+
+ return 0;
+}
+
+
+void
+fill_uuid (char *uuid, int size)
+{
+ char hostname[256] = {0,};
+ struct timeval tv = {0,};
+ struct tm now = {0, };
+ char now_str[32];
+
+ if (gettimeofday (&tv, NULL) == -1) {
+ gf_log ("graph", GF_LOG_ERROR,
+ "gettimeofday: failed %s",
+ strerror (errno));
+ }
+
+ if (gethostname (hostname, 256) == -1) {
+ gf_log ("graph", GF_LOG_ERROR,
+ "gethostname: failed %s",
+ strerror (errno));
+ }
+
+ localtime_r (&tv.tv_sec, &now);
+ strftime (now_str, 32, "%Y/%m/%d-%H:%M:%S", &now);
+ snprintf (uuid, size, "%s-%d-%s:%ld",
+ hostname, getpid(), now_str, tv.tv_usec);
+
+ return;
+}
+
+
+int
+glusterfs_graph_settop (glusterfs_graph_t *graph, glusterfs_ctx_t *ctx)
+{
+ const char *volume_name = NULL;
+ xlator_t *trav = NULL;
+
+ volume_name = ctx->cmd_args.volume_name;
+
+ if (!volume_name) {
+ graph->top = graph->first;
+ return 0;
+ }
+
+ for (trav = graph->first; trav; trav = trav->next) {
+ if (strcmp (trav->name, volume_name) == 0) {
+ graph->top = trav;
+ return 0;
+ }
+ }
+
+ return -1;
+}
+
+
+int
+glusterfs_graph_parent_up (glusterfs_graph_t *graph)
+{
+ xlator_t *trav = NULL;
+ int ret = -1;
+
+ trav = graph->first;
+
+ while (trav) {
+ if (!xlator_has_parent (trav)) {
+ ret = xlator_notify (trav, GF_EVENT_PARENT_UP, trav);
+ }
+
+ if (ret)
+ break;
+
+ trav = trav->next;
+ }
+
+ return ret;
+}
+
+
+int
+glusterfs_graph_prepare (glusterfs_graph_t *graph, glusterfs_ctx_t *ctx)
+{
+ xlator_t *trav = NULL;
+ int ret = 0;
+
+ /* XXX: CHECKSUM */
+
+ /* XXX: attach to -n volname */
+ ret = glusterfs_graph_settop (graph, ctx);
+ if (ret)
+ return -1;
+
+ /* XXX: RO VOLUME */
+ ret = glusterfs_graph_readonly (graph, ctx);
+ if (ret)
+ return -1;
+
+ /* XXX: MAC COMPAT */
+ ret = glusterfs_graph_mac_compat (graph, ctx);
+ if (ret)
+ return -1;
+
+ /* XXX: this->ctx setting */
+ for (trav = graph->first; trav; trav = trav->next) {
+ trav->ctx = ctx;
+ }
+
+ /* XXX: DOB setting */
+ gettimeofday (&graph->dob, NULL);
+
+ fill_uuid (graph->graph_uuid, 128);
+
+ /* XXX: --xlator-option additions */
+ gf_add_cmdline_options (graph, &ctx->cmd_args);
+
+
+ return 0;
+}
+
+
+int
+glusterfs_graph_activate (glusterfs_ctx_t *ctx, glusterfs_graph_t *graph)
+{
+ int ret = 0;
+
+ /* XXX: all xlator options validation */
+ ret = glusterfs_graph_validate_options (graph);
+ if (ret)
+ return ret;
+
+ /* XXX: perform init () */
+ ret = glusterfs_graph_init (graph);
+ if (ret)
+ return ret;
+
+ ret = glusterfs_graph_unknown_options (graph);
+ if (ret)
+ return ret;
+
+ /* XXX: log full graph (_gf_dump_details) */
+
+ list_add (&graph->list, &ctx->graphs);
+ ctx->active = graph;
+
+ /* XXX: attach to master and set active pointer */
+ if (ctx->master)
+ ret = xlator_notify (ctx->master, GF_EVENT_GRAPH_NEW, graph);
+ if (ret)
+ return ret;
+
+ /* XXX: perform parent up */
+ ret = glusterfs_graph_parent_up (graph);
+ if (ret)
+ return ret;
+
+
+ return 0;
+}
+
+
+int
+glusterfs_graph_destroy (glusterfs_graph_t *graph)
+{
+ return 0;
+}
+
+
diff --git a/libglusterfs/src/spec.l b/libglusterfs/src/graph.l
index 9508e0f5539..8d9d2dc3611 100644
--- a/libglusterfs/src/spec.l
+++ b/libglusterfs/src/graph.l
@@ -33,21 +33,21 @@ static char *text;
static int text_asize;
static int text_size;
-void new_string(void)
-{
- text = malloc(START_STRSIZE);
- text_asize = START_STRSIZE;
- text_size = 0;
- *text = 0;
-}
-
void append_string(const char *str, int size)
{
int new_size = text_size + size + 1;
if (new_size > text_asize) {
new_size += START_STRSIZE - 1;
new_size &= -START_STRSIZE;
- text = realloc(text, new_size);
+ if (!text) {
+ text = GF_CALLOC (1, new_size,
+ gf_common_mt_char);
+ } else {
+ text = GF_REALLOC (text, new_size);
+ }
+ if (!text)
+ gf_log ("parser", GF_LOG_ERROR,
+ "out of memory");
text_asize = new_size;
}
memcpy(text + text_size, str, size);
@@ -55,13 +55,6 @@ void append_string(const char *str, int size)
text[text_size] = 0;
}
-void alloc_string(const char *str, int size)
-{
- text = malloc(size + 1);
- memcpy(text, str, size);
- text[size] = 0;
-}
-
%}
VOLUME [v][o][l][u][m][e]
@@ -71,10 +64,10 @@ OPTION [o][p][t][i][o][n]
TYPE [t][y][p][e]
%%
\#.* ;
-{VOLUME} return SECTION_BEGIN;
+{VOLUME} return VOLUME_BEGIN;
{TYPE} return TYPE;
-{END}[-]{VOLUME} return SECTION_END;
-{SUB}{VOLUME}[Ss] return SUBSECTION;
+{END}[-]{VOLUME} return VOLUME_END;
+{SUB}{VOLUME}[Ss] return SUBVOLUME;
{OPTION} return OPTION;
\" BEGIN(STRING);
<STRING>{
@@ -83,12 +76,12 @@ TYPE [t][y][p][e]
\" {
if (0) {
yyunput (0, NULL);
- }
+ }
BEGIN (INITIAL);
yylval = text;
return STRING_TOK;
}
}
-[^ \t\r\n\"\\]+ { yylval = strdup (yytext) ; return ID; }
+[^ \t\r\n\"\\]+ { yylval = gf_strdup (yytext) ; return ID; }
[ \t\r\n]+ ;
%%
diff --git a/libglusterfs/src/graph.y b/libglusterfs/src/graph.y
new file mode 100644
index 00000000000..4ac07660f95
--- /dev/null
+++ b/libglusterfs/src/graph.y
@@ -0,0 +1,651 @@
+/*
+ Copyright (c) 2006-2009 Gluster, Inc. <http://www.gluster.com>
+ This file is part of GlusterFS.
+
+ GlusterFS is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published
+ by the Free Software Foundation; either version 3 of the License,
+ or (at your option) any later version.
+
+ GlusterFS is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see
+ <http://www.gnu.org/licenses/>.
+*/
+
+
+%token VOLUME_BEGIN VOLUME_END OPTION NEWLINE SUBVOLUME ID WHITESPACE COMMENT TYPE STRING_TOK
+
+%{
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <sys/mman.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+
+#include "xlator.h"
+#include "logging.h"
+
+static int new_volume (char *name);
+static int volume_type (char *type);
+static int volume_option (char *key, char *value);
+static int volume_sub (char *sub);
+static int volume_end (void);
+static void sub_error (void);
+static void type_error (void);
+static void option_error (void);
+
+#define YYSTYPE char *
+#define GF_CMD_BUFFER_LEN (8 * GF_UNIT_KB)
+
+int yyerror (const char *);
+int yylex ();
+%}
+
+
+%%
+VOLUMES: VOLUME | VOLUMES VOLUME;
+
+VOLUME: VOLUME_HEADER VOLUME_DATA VOLUME_FOOTER;
+VOLUME_HEADER: VOLUME_BEGIN WORD {if (new_volume ($2) == -1) { YYABORT; }};
+VOLUME_FOOTER: VOLUME_END {if (volume_end () == -1) { YYABORT; }};
+
+VOLUME_DATA: TYPE_LINE OPTIONS_LINE SUBVOLUME_LINE OPTIONS_LINE |
+ TYPE_LINE SUBVOLUME_LINE OPTIONS_LINE |
+ TYPE_LINE OPTIONS_LINE SUBVOLUME_LINE |
+ TYPE_LINE SUBVOLUME_LINE |
+ TYPE_LINE OPTIONS_LINE |
+ OPTIONS_LINE SUBVOLUME_LINE OPTIONS_LINE | /* error case */
+ OPTIONS_LINE; /* error case */
+
+TYPE_LINE: TYPE WORD {if (volume_type ($2) == -1) { YYABORT; }} | TYPE { type_error(); YYABORT; };
+
+SUBVOLUME_LINE: SUBVOLUME WORDS | SUBVOLUME { sub_error (); YYABORT; };
+
+OPTIONS_LINE: OPTION_LINE | OPTIONS_LINE OPTION_LINE;
+
+OPTION_LINE: OPTION WORD WORD {if (volume_option ($2, $3) == -1) { YYABORT; }} |
+ OPTION WORD { option_error (); YYABORT; } |
+ OPTION { option_error (); YYABORT; };
+
+WORDS: WORD {if (volume_sub ($1) == -1) {YYABORT; }} | WORDS WORD { if (volume_sub ($2) == -1) { YYABORT; }};
+WORD: ID | STRING_TOK ;
+%%
+
+xlator_t *curr;
+glusterfs_graph_t *construct;
+
+
+static void
+type_error (void)
+{
+ extern int yylineno;
+
+ gf_log ("parser", GF_LOG_ERROR,
+ "Volume %s, before line %d: Please specify volume type",
+ curr->name, yylineno);
+ return;
+}
+
+
+static void
+sub_error (void)
+{
+ extern int yylineno;
+
+ gf_log ("parser", GF_LOG_ERROR,
+ "Volume %s, before line %d: Please specify subvolumes",
+ curr->name, yylineno);
+ return;
+}
+
+
+static void
+option_error (void)
+{
+ extern int yylineno;
+
+ gf_log ("parser", GF_LOG_ERROR,
+ "Volume %s, before line %d: Please specify "
+ "option <key> <value>",
+ curr->name, yylineno);
+ return;
+}
+
+
+static int
+new_volume (char *name)
+{
+ extern int yylineno;
+ xlator_t *trav = NULL;
+ int ret = 0;
+
+ if (!name) {
+ gf_log ("parser", GF_LOG_DEBUG,
+ "Invalid argument name: '%s'", name);
+ ret = -1;
+ goto out;
+ }
+
+ if (curr) {
+ gf_log ("parser", GF_LOG_ERROR,
+ "new volume (%s) defintion in line %d unexpected",
+ name, yylineno);
+ ret = -1;
+ goto out;
+ }
+
+ curr = (void *) GF_CALLOC (1, sizeof (*curr),
+ gf_common_mt_xlator_t);
+
+ if (!curr) {
+ gf_log ("parser", GF_LOG_ERROR, "Out of memory");
+ ret = -1;
+ goto out;
+ }
+
+ trav = construct->first;
+
+ while (trav) {
+ if (!strcmp (name, trav->name)) {
+ gf_log ("parser", GF_LOG_ERROR,
+ "Line %d: volume '%s' defined again",
+ yylineno, name);
+ ret = -1;
+ goto out;
+ }
+ trav = trav->next;
+ }
+
+ curr->name = gf_strdup (name);
+ if (!curr->name) {
+ GF_FREE (curr);
+ ret = -1;
+ goto out;
+ }
+
+ curr->options = get_new_dict ();
+
+ if (!curr->options) {
+ GF_FREE (curr->name);
+ GF_FREE (curr);
+ ret = -1;
+ goto out;
+ }
+
+ curr->next = construct->first;
+ if (curr->next)
+ curr->next->prev = curr;
+
+ curr->graph = construct;
+
+ construct->first = curr;
+
+ construct->xl_count++;
+
+ gf_log ("parser", GF_LOG_TRACE, "New node for '%s'", name);
+
+out:
+ GF_FREE (name);
+
+ return ret;
+}
+
+
+static int
+volume_type (char *type)
+{
+ extern int yylineno;
+ int32_t ret = 0;
+
+ if (!type) {
+ gf_log ("parser", GF_LOG_DEBUG, "Invalid argument type");
+ ret = -1;
+ goto out;
+ }
+
+ ret = xlator_set_type (curr, type);
+ if (ret) {
+ gf_log ("parser", GF_LOG_ERROR,
+ "Volume '%s', line %d: type '%s' is not valid or "
+ "not found on this machine",
+ curr->name, yylineno, type);
+ ret = -1;
+ goto out;
+ }
+
+ gf_log ("parser", GF_LOG_TRACE, "Type:%s:%s", curr->name, type);
+
+out:
+ GF_FREE (type);
+
+ return 0;
+}
+
+
+static int
+volume_option (char *key, char *value)
+{
+ extern int yylineno;
+ int ret = 0;
+ char *set_value = NULL;
+
+ if (!key || !value){
+ gf_log ("parser", GF_LOG_ERROR, "Invalid argument");
+ ret = -1;
+ goto out;
+ }
+
+ set_value = gf_strdup (value);
+ ret = dict_set_dynstr (curr->options, key, set_value);
+
+ if (ret == 1) {
+ gf_log ("parser", GF_LOG_ERROR,
+ "Volume '%s', line %d: duplicate entry "
+ "('option %s') present",
+ curr->name, yylineno, key);
+ ret = -1;
+ goto out;
+ }
+
+ gf_log ("parser", GF_LOG_TRACE, "Option:%s:%s:%s",
+ curr->name, key, value);
+
+out:
+ GF_FREE (key);
+ GF_FREE (value);
+
+ return 0;
+}
+
+
+static int
+volume_sub (char *sub)
+{
+ extern int yylineno;
+ xlator_t *trav = NULL;
+ xlator_list_t *xlchild = NULL;
+ xlator_list_t *tmp = NULL;
+ xlator_list_t *xlparent = NULL;
+ int ret = 0;
+
+ if (!sub) {
+ gf_log ("parser", GF_LOG_ERROR, "Invalid subvolumes argument");
+ ret = -1;
+ goto out;
+ }
+
+ trav = construct->first;
+
+ while (trav) {
+ if (!strcmp (sub, trav->name))
+ break;
+ trav = trav->next;
+ }
+
+ if (!trav) {
+ gf_log ("parser", GF_LOG_ERROR,
+ "Volume '%s', line %d: subvolume '%s' is not defined "
+ "prior to usage",
+ curr->name, yylineno, sub);
+ ret = -1;
+ goto out;
+ }
+
+ if (trav == curr) {
+ gf_log ("parser", GF_LOG_ERROR,
+ "Volume '%s', line %d: has '%s' itself as subvolume",
+ curr->name, yylineno, sub);
+ ret = -1;
+ goto out;
+ }
+
+ xlparent = (void *) GF_CALLOC (1, sizeof (*xlparent),
+ gf_common_mt_xlator_list_t);
+
+ if (!xlparent) {
+ gf_log ("parser", GF_LOG_ERROR, "Out of memory");
+ ret = -1;
+ goto out;
+ }
+
+ xlparent->xlator = curr;
+
+ tmp = trav->parents;
+ if (tmp == NULL) {
+ trav->parents = xlparent;
+ } else {
+ while (tmp->next)
+ tmp = tmp->next;
+ tmp->next = xlparent;
+ }
+
+ xlchild = (void *) GF_CALLOC (1, sizeof(*xlchild),
+ gf_common_mt_xlator_list_t);
+ if (!xlchild) {
+ gf_log ("parser", GF_LOG_ERROR, "Out of memory");
+ ret = -1;
+ goto out;
+ }
+
+ xlchild->xlator = trav;
+
+ tmp = curr->children;
+ if (tmp == NULL) {
+ curr->children = xlchild;
+ } else {
+ while (tmp->next)
+ tmp = tmp->next;
+ tmp->next = xlchild;
+ }
+
+ gf_log ("parser", GF_LOG_TRACE, "child:%s->%s", curr->name, sub);
+
+out:
+ GF_FREE (sub);
+
+ return 0;
+}
+
+
+static int
+volume_end (void)
+{
+ if (!curr->fops) {
+ gf_log ("parser", GF_LOG_ERROR,
+ "\"type\" not specified for volume %s", curr->name);
+ return -1;
+ }
+ gf_log ("parser", GF_LOG_TRACE, "end:%s", curr->name);
+
+ curr = NULL;
+ return 0;
+}
+
+
+int
+yywrap ()
+{
+ return 1;
+}
+
+
+int
+yyerror (const char *str)
+{
+ extern char *yytext;
+ extern int yylineno;
+
+ if (curr && curr->name) {
+ if (!strcmp (yytext, "volume")) {
+ gf_log ("parser", GF_LOG_ERROR,
+ "'end-volume' not defined for volume '%s'",
+ curr->name);
+ } else if (!strcmp (yytext, "type")) {
+ gf_log ("parser", GF_LOG_ERROR,
+ "line %d: duplicate 'type' defined for "
+ "volume '%s'",
+ yylineno, curr->name);
+ } else if (!strcmp (yytext, "subvolumes")) {
+ gf_log ("parser", GF_LOG_ERROR,
+ "line %d: duplicate 'subvolumes' defined for "
+ "volume '%s'",
+ yylineno, curr->name);
+ } else if (curr) {
+ gf_log ("parser", GF_LOG_ERROR,
+ "syntax error: line %d (volume '%s'): \"%s\""
+ "\nallowed tokens are 'volume', 'type', "
+ "'subvolumes', 'option', 'end-volume'()",
+ yylineno, curr->name,
+ yytext);
+ } else {
+ gf_log ("parser", GF_LOG_ERROR,
+ "syntax error: line %d (just after volume "
+ "'%s'): \"%s\"\n(%s)",
+ yylineno, curr->name,
+ yytext,
+ "allowed tokens are 'volume', 'type', "
+ "'subvolumes', 'option', 'end-volume'");
+ }
+ } else {
+ gf_log ("parser", GF_LOG_ERROR,
+ "syntax error in line %d: \"%s\" \n"
+ "(allowed tokens are 'volume', 'type', "
+ "'subvolumes', 'option', 'end-volume')\n",
+ yylineno, yytext);
+ }
+
+ return -1;
+}
+
+
+static int
+execute_cmd (char *cmd, char **result, size_t size)
+{
+ FILE *fpp = NULL;
+ int i = 0;
+ int status = 0;
+ int character = 0;
+ char *buf = *result;
+
+ fpp = popen (cmd, "r");
+ if (!fpp) {
+ gf_log ("parser", GF_LOG_ERROR, "%s: failed to popen", cmd);
+ return -1;
+ }
+
+ while ((character = fgetc (fpp)) != EOF) {
+ if (i == size) {
+ size *= 2;
+ buf = *result = GF_REALLOC (*result, size);
+ }
+
+ buf[i++] = character;
+ }
+
+ if (i > 0) {
+ i--;
+ buf[i] = '\0';
+ }
+
+ status = pclose (fpp);
+ if (status == -1 || !WIFEXITED (status) ||
+ ((WEXITSTATUS (status)) != 0)) {
+ i = -1;
+ buf[0] = '\0';
+ }
+
+ return i;
+}
+
+
+static int
+preprocess (FILE *srcfp, FILE *dstfp)
+{
+ int ret = 0;
+ int i = 0;
+ char *cmd = NULL;
+ char *result = NULL;
+ size_t cmd_buf_size = GF_CMD_BUFFER_LEN;
+ char escaped = 0;
+ char in_backtick = 0;
+ int line = 1;
+ int column = 0;
+ int backtick_line = 0;
+ int backtick_column = 0;
+ int character = 0;
+
+
+ fseek (srcfp, 0L, SEEK_SET);
+ fseek (dstfp, 0L, SEEK_SET);
+
+ cmd = GF_CALLOC (cmd_buf_size, 1,
+ gf_common_mt_char);
+ if (cmd == NULL) {
+ gf_log ("parser", GF_LOG_ERROR, "Out of memory");
+ return -1;
+ }
+
+ result = GF_CALLOC (cmd_buf_size * 2, 1,
+ gf_common_mt_char);
+ if (result == NULL) {
+ GF_FREE (cmd);
+ gf_log ("parser", GF_LOG_ERROR, "Out of memory");
+ return -1;
+ }
+
+ while ((character = fgetc (srcfp)) != EOF) {
+ if ((character == '`') && !escaped) {
+ if (in_backtick) {
+ cmd[i] = '\0';
+ result[0] = '\0';
+
+ ret = execute_cmd (cmd, &result,
+ 2 * cmd_buf_size);
+ if (ret < 0) {
+ ret = -1;
+ goto out;
+ }
+ fwrite (result, ret, 1, dstfp);
+ } else {
+ i = 0;
+ cmd[i] = '\0';
+
+ backtick_column = column;
+ backtick_line = line;
+ }
+
+ in_backtick = !in_backtick;
+ } else {
+ if (in_backtick) {
+ if (i == cmd_buf_size) {
+ cmd_buf_size *= 2;
+ cmd = GF_REALLOC (cmd, cmd_buf_size);
+ if (cmd == NULL) {
+ return -1;
+ }
+
+ result = GF_REALLOC (result,
+ 2 * cmd_buf_size);
+ if (result == NULL) {
+ GF_FREE (cmd);
+ return -1;
+ }
+ }
+
+ cmd[i++] = character;
+ } else {
+ fputc (character, dstfp);
+ }
+ }
+
+ if (character == '\\') {
+ escaped = !escaped;
+ } else {
+ escaped = 0;
+ }
+
+ if (character == '\n') {
+ line++;
+ column = 0;
+ } else {
+ column++;
+ }
+ }
+
+ if (in_backtick) {
+ gf_log ("parser", GF_LOG_ERROR,
+ "Unterminated backtick in volume specfication file at line (%d), column (%d).",
+ line, column);
+ ret = -1;
+ }
+
+out:
+ fseek (srcfp, 0L, SEEK_SET);
+ fseek (dstfp, 0L, SEEK_SET);
+ GF_FREE (cmd);
+ GF_FREE (result);
+
+ return ret;
+}
+
+
+extern FILE *yyin;
+
+glusterfs_graph_t *
+glusterfs_graph_new ()
+{
+ glusterfs_graph_t *graph = NULL;
+
+ graph = GF_CALLOC (1, sizeof (*graph),
+ gf_common_mt_glusterfs_graph_t);
+ if (!graph)
+ return NULL;
+
+ INIT_LIST_HEAD (&graph->list);
+
+ gettimeofday (&graph->dob, NULL);
+
+ return graph;
+}
+
+
+glusterfs_graph_t *
+glusterfs_graph_construct (FILE *fp)
+{
+ int ret = 0;
+ glusterfs_graph_t *graph = NULL;
+ FILE *tmp_file = NULL;
+
+ graph = glusterfs_graph_new ();
+ if (!graph)
+ return NULL;
+
+ tmp_file = tmpfile ();
+
+ if (tmp_file == NULL) {
+ gf_log ("parser", GF_LOG_ERROR,
+ "cannot create temparory file");
+
+ glusterfs_graph_destroy (graph);
+ return NULL;
+ }
+
+ ret = preprocess (fp, tmp_file);
+ if (ret < 0) {
+ gf_log ("parser", GF_LOG_ERROR,
+ "parsing of backticks failed");
+
+ glusterfs_graph_destroy (graph);
+ fclose (tmp_file);
+ return NULL;
+ }
+
+ yyin = tmp_file;
+
+ construct = graph;
+
+ ret = yyparse ();
+
+ construct = NULL;
+
+ fclose (tmp_file);
+
+ if (ret == 1) {
+ gf_log ("parser", GF_LOG_DEBUG,
+ "parsing of volfile failed, please review it "
+ "once more");
+
+ glusterfs_graph_destroy (graph);
+ return NULL;
+ }
+
+ return graph;
+}
+
diff --git a/libglusterfs/src/inode.c b/libglusterfs/src/inode.c
index 622857c1ab0..c5784595426 100644
--- a/libglusterfs/src/inode.c
+++ b/libglusterfs/src/inode.c
@@ -281,7 +281,7 @@ __inode_destroy (inode_t *inode)
if (!inode->_ctx)
goto noctx;
- for (index = 0; index < inode->table->xl->ctx->xl_count; index++) {
+ for (index = 0; index < inode->table->xl->graph->xl_count; index++) {
if (inode->_ctx[index].key) {
xl = (xlator_t *)(long)inode->_ctx[index].key;
old_THIS = THIS;
@@ -474,8 +474,9 @@ __inode_create (inode_table_t *table)
INIT_LIST_HEAD (&newi->dentry_list);
newi->_ctx = GF_CALLOC (1, (sizeof (struct _inode_ctx) *
- table->xl->ctx->xl_count),
+ table->xl->graph->xl_count),
gf_common_mt_inode_ctx);
+
if (newi->_ctx == NULL) {
gf_log ("inode", GF_LOG_ERROR, "out of memory");
LOCK_DESTROY (&newi->lock);
@@ -1173,7 +1174,7 @@ __inode_ctx_put2 (inode_t *inode, xlator_t *xlator, uint64_t value1,
int index = 0;
int put_idx = -1;
- for (index = 0; index < xlator->ctx->xl_count; index++) {
+ for (index = 0; index < xlator->graph->xl_count; index++) {
if (!inode->_ctx[index].key) {
if (put_idx == -1)
put_idx = index;
@@ -1225,12 +1226,12 @@ __inode_ctx_get2 (inode_t *inode, xlator_t *xlator, uint64_t *value1,
int index = 0;
int ret = 0;
- for (index = 0; index < xlator->ctx->xl_count; index++) {
+ for (index = 0; index < xlator->graph->xl_count; index++) {
if (inode->_ctx[index].xl_key == xlator)
break;
}
- if (index == xlator->ctx->xl_count) {
+ if (index == xlator->graph->xl_count) {
ret = -1;
goto out;
}
@@ -1277,12 +1278,12 @@ inode_ctx_del2 (inode_t *inode, xlator_t *xlator, uint64_t *value1,
LOCK (&inode->lock);
{
- for (index = 0; index < xlator->ctx->xl_count; index++) {
+ for (index = 0; index < xlator->graph->xl_count; index++) {
if (inode->_ctx[index].xl_key == xlator)
break;
}
- if (index == xlator->ctx->xl_count) {
+ if (index == xlator->graph->xl_count) {
ret = -1;
goto unlock;
}
@@ -1371,7 +1372,7 @@ inode_dump (inode_t *inode, char *prefix)
if (!inode->_ctx)
goto out;
- for (i = 0; i < inode->table->xl->ctx->xl_count; i++) {
+ for (i = 0; i < inode->table->xl->graph->xl_count; i++) {
if (inode->_ctx[i].key) {
xl = (xlator_t *)(long)inode->_ctx[i].key;
if (xl->dumpops && xl->dumpops->inodectx)
diff --git a/libglusterfs/src/latency.c b/libglusterfs/src/latency.c
index 5156e8e2551..71f9824209f 100644
--- a/libglusterfs/src/latency.c
+++ b/libglusterfs/src/latency.c
@@ -174,7 +174,7 @@ gf_latency_toggle (int signum)
{
glusterfs_ctx_t *ctx = NULL;
- ctx = get_global_ctx_ptr ();
+ ctx = glusterfs_ctx_get ();
if (ctx) {
ctx->measure_latency = !ctx->measure_latency;
diff --git a/libglusterfs/src/mem-types.h b/libglusterfs/src/mem-types.h
index daf680eb2a7..e8d4df5f18f 100644
--- a/libglusterfs/src/mem-types.h
+++ b/libglusterfs/src/mem-types.h
@@ -77,6 +77,7 @@ enum gf_common_mem_types_ {
gf_common_mt_rpcsvc_conn_t,
gf_common_mt_rpcsvc_program_t,
gf_common_mt_rpcsvc_stage_t,
+ gf_common_mt_glusterfs_graph_t,
gf_common_mt_end
};
#endif
diff --git a/libglusterfs/src/spec.y b/libglusterfs/src/spec.y
deleted file mode 100644
index 805e1e1fbae..00000000000
--- a/libglusterfs/src/spec.y
+++ /dev/null
@@ -1,626 +0,0 @@
-/*
- Copyright (c) 2006-2009 Gluster, Inc. <http://www.gluster.com>
- This file is part of GlusterFS.
-
- GlusterFS is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published
- by the Free Software Foundation; either version 3 of the License,
- or (at your option) any later version.
-
- GlusterFS is distributed in the hope that it will be useful, but
- WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program. If not, see
- <http://www.gnu.org/licenses/>.
-*/
-
-
-%token SECTION_BEGIN SECTION_END OPTION NEWLINE SUBSECTION ID WHITESPACE COMMENT TYPE STRING_TOK
-
-%{
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-#include <errno.h>
-#include <sys/mman.h>
-#include <sys/types.h>
-#include <sys/wait.h>
-
-#include "xlator.h"
-#include "logging.h"
-
-static int new_section (char *name);
-static int section_type (char *type);
-static int section_option (char *key, char *value);
-static int section_sub (char *sub);
-static int section_end (void);
-static void sub_error (void);
-static void type_error (void);
-static void option_error (void);
-
-#define YYSTYPE char *
-#define GF_CMD_BUFFER_LEN (8 * GF_UNIT_KB)
-
-int yyerror (const char *);
-int yylex ();
-%}
-
-
-%%
-SECTIONS: SECTION | SECTIONS SECTION;
-
-SECTION: SECTION_HEADER SECTION_DATA SECTION_FOOTER;
-SECTION_HEADER: SECTION_BEGIN WORD {if( -1 == new_section ($2)) { YYABORT; } };
-SECTION_FOOTER: SECTION_END {if( -1 == section_end ()) { YYABORT; } };
-
-SECTION_DATA: TYPE_LINE OPTIONS_LINE SUBSECTION_LINE OPTIONS_LINE |
- TYPE_LINE SUBSECTION_LINE OPTIONS_LINE |
- TYPE_LINE OPTIONS_LINE SUBSECTION_LINE |
- TYPE_LINE SUBSECTION_LINE |
- TYPE_LINE OPTIONS_LINE |
- OPTIONS_LINE SUBSECTION_LINE OPTIONS_LINE | /* error case */
- OPTIONS_LINE; /* error case */
-
-TYPE_LINE: TYPE WORD {if ( -1 == section_type ($2)) { YYABORT; }} | TYPE { type_error(); YYABORT; };
-
-SUBSECTION_LINE: SUBSECTION WORDS | SUBSECTION { sub_error (); YYABORT; };
-
-OPTIONS_LINE: OPTION_LINE | OPTIONS_LINE OPTION_LINE;
-
-OPTION_LINE: OPTION WORD WORD {if(-1 == section_option($2,$3)){YYABORT;} } |
- OPTION WORD { option_error (); YYABORT; } |
- OPTION { option_error (); YYABORT; };
-
-WORDS: WORD {if (-1 == section_sub ($1)) {YYABORT; } } | WORDS WORD { if (-1 == section_sub ($2)) { YYABORT; } };
-WORD: ID | STRING_TOK ;
-%%
-
-xlator_t *complete_tree = NULL;
-xlator_t *tree = NULL;
-glusterfs_ctx_t *gctx;
-
-static void
-type_error (void)
-{
- extern int yylineno;
-
- fprintf (stderr, "Volume '%s', before line %d: Please specify volume 'type'.",
- complete_tree->name, yylineno);
- gf_log ("parser", GF_LOG_ERROR,
- "Volume '%s', before line %d: Please specify volume 'type'.",
- complete_tree->name, yylineno);
- return;
-}
-
-static void
-sub_error (void)
-{
- extern int yylineno;
-
- fprintf (stderr, "Volume %s, before line %d: Please specify subvolumes for the volume. ",
- complete_tree->name, yylineno);
- gf_log ("parser", GF_LOG_ERROR,
- "Volume %s, before line %d: Please specify subvolumes for the volume. ",
- complete_tree->name, yylineno);
- return;
-}
-
-static void
-option_error (void)
-{
- extern int yylineno;
-
- fprintf (stderr, "Volume %s, before line %d: Please specify "
- "option <key> <value> \n",
- complete_tree->name, yylineno);
- gf_log ("parser", GF_LOG_ERROR,
- "Volume %s, before line %d: Please specify "
- "option <key> <value>",
- complete_tree->name, yylineno);
- return;
-}
-
-static int
-cut_tree (xlator_t *tree)
-{
- xlator_t *trav = tree, *prev = tree;
-
- if (!tree) {
- gf_log ("parser", GF_LOG_DEBUG, "Translator tree not found");
- return -1;
- }
-
- gf_log ("parser", GF_LOG_DEBUG, "Failed to build translator graph");
-
- while (prev) {
- trav = prev->next;
- dict_destroy (prev->options);
- FREE (prev->name);
- FREE (prev);
- prev = trav;
- }
-
- return 0;
-}
-
-
-static int
-new_section (char *name)
-{
- extern int yylineno;
- xlator_t *trav = complete_tree;
- xlator_t *node = NULL;
-
- node = (void *) calloc (1, sizeof (*node));
- if (!node) {
- gf_log ("parser", GF_LOG_ERROR, "Out of memory");
- return -1;
- }
-
- if (!name) {
- gf_log ("parser", GF_LOG_DEBUG,
- "Invalid argument name: '%s'", name);
- FREE (node);
- return -1;
- }
-
- while (trav) {
- if (!strcmp (name, trav->name)) {
- fprintf (stderr,
- "Line %d: volume '%s' defined again\n",
- yylineno, name);
- gf_log ("parser", GF_LOG_ERROR,
- "Line %d: volume '%s' defined again",
- yylineno, name);
- return -1;
- }
- trav = trav->next;
- }
-
- node->ctx = gctx;
- node->name = name;
- node->next = complete_tree;
- if (complete_tree)
- complete_tree->prev = node;
- node->options = get_new_dict ();
- complete_tree = node;
-
- tree = node;
- gf_log ("parser", GF_LOG_TRACE, "New node for '%s'", name);
-
- return 0;
-}
-
-static int
-section_type (char *type)
-{
- extern int yylineno;
- int32_t ret = -1;
- if (!type) {
- gf_log ("parser", GF_LOG_DEBUG, "Invalid argument type");
- return -1;
- }
-
- ret = xlator_set_type (tree, type);
- if (ret) {
- fprintf (stderr, "Volume '%s', line %d: type '%s' is not "
- "valid or not found on this machine\n",
- complete_tree->name, yylineno, type);
- gf_log ("parser", GF_LOG_ERROR,
- "Volume '%s', line %d: type '%s' is not valid or "
- "not found on this machine",
- complete_tree->name, yylineno, type);
- return -1;
- }
- gf_log ("parser", GF_LOG_TRACE, "Type:%s:%s", tree->name, type);
-
- return 0;
-}
-
-
-static int
-section_option (char *key, char *value)
-{
- extern int yylineno;
-
- int ret = 0;
-
- if (!key || !value){
- fprintf (stderr, "Invalid argument\n");
- gf_log ("parser", GF_LOG_ERROR, "Invalid argument");
- return -1;
- }
-
- ret = dict_set (tree->options, key, str_to_data (value));
-
- if (ret == 1) {
- gf_log ("parser", GF_LOG_ERROR,
- "Volume '%s', line %d: duplicate entry "
- "('option %s') present",
- tree->name, yylineno, key);
- return -1;
- }
- gf_log ("parser", GF_LOG_TRACE, "Option:%s:%s:%s",
- tree->name, key, value);
-
- return 0;
-}
-
-static int
-section_sub (char *sub)
-{
- extern int yylineno;
- xlator_t *trav = complete_tree;
- xlator_list_t *xlchild, *tmp, *xlparent;
-
- if (!sub) {
- fprintf (stderr, "Invalid subvolumes argument\n");
- gf_log ("parser", GF_LOG_ERROR, "Invalid subvolumes argument");
- return -1;
- }
-
- while (trav) {
- if (!strcmp (sub, trav->name))
- break;
- trav = trav->next;
- }
- if (!trav) {
- fprintf (stderr,
- "Volume '%s', line %d: subvolume '%s' is not "
- "defined prior to usage\n",
- complete_tree->name, yylineno, sub);
- gf_log ("parser", GF_LOG_ERROR,
- "Volume '%s', line %d: subvolume '%s' is not defined "
- "prior to usage",
- complete_tree->name, yylineno, sub);
- return -1;
- }
-
- if (trav == tree) {
- fprintf (stderr, "Volume '%s', line %d: has '%s' itself as "
- "subvolume\n",
- complete_tree->name, yylineno, sub);
- gf_log ("parser", GF_LOG_ERROR,
- "Volume '%s', line %d: has '%s' itself as subvolume",
- complete_tree->name, yylineno, sub);
- return -1;
- }
-
- xlparent = (void *) calloc (1, sizeof (*xlparent));
- if (!xlparent) {
- gf_log ("parser", GF_LOG_ERROR, "Out of memory");
- return -1;
- }
- xlparent->xlator = tree;
-
- tmp = trav->parents;
- if (tmp == NULL) {
- trav->parents = xlparent;
- } else {
- while (tmp->next)
- tmp = tmp->next;
- tmp->next = xlparent;
- }
-
- xlchild = (void *) calloc (1, sizeof(*xlchild));
- if (!xlchild) {
- FREE (xlparent);
- gf_log ("parser", GF_LOG_ERROR, "Out of memory");
- return -1;
- }
- xlchild->xlator = trav;
-
- tmp = tree->children;
- if (tmp == NULL) {
- tree->children = xlchild;
- } else {
- while (tmp->next)
- tmp = tmp->next;
- tmp->next = xlchild;
- }
-
- gf_log ("parser", GF_LOG_TRACE, "child:%s->%s", tree->name, sub);
-
- return 0;
-}
-
-static int
-section_end (void)
-{
- if (!tree->fops) {
- fprintf (stderr,
- "\"type\" not specified for volume %s\n", tree->name);
- gf_log ("parser", GF_LOG_ERROR,
- "\"type\" not specified for volume %s", tree->name);
- return -1;
- }
- gf_log ("parser", GF_LOG_TRACE, "end:%s", tree->name);
-
- tree = NULL;
- return 0;
-}
-
-int
-yywrap ()
-{
- return 1;
-}
-
-int
-yyerror (const char *str)
-{
- extern char *yytext;
- extern int yylineno;
-
- if (complete_tree && complete_tree->name)
- {
- if (!strcmp (yytext, "volume"))
- {
- fprintf (stderr,
- "'end-volume' not defined for volume '%s'\n",
- complete_tree->name);
- gf_log ("parser", GF_LOG_ERROR,
- "'end-volume' not defined for volume '%s'",
- complete_tree->name);
- }
- else if (!strcmp (yytext, "type"))
- {
- fprintf (stderr, "line %d: duplicate 'type' defined "
- "for volume '%s'",
- yylineno, complete_tree->name);
- gf_log ("parser", GF_LOG_ERROR,
- "line %d: duplicate 'type' defined for "
- "volume '%s'",
- yylineno, complete_tree->name);
- }
- else if (!strcmp (yytext, "subvolumes"))
- {
- fprintf (stderr, "line %d: duplicate 'subvolumes' "
- "defined for volume '%s'",
- yylineno, complete_tree->name);
- gf_log ("parser", GF_LOG_ERROR,
- "line %d: duplicate 'subvolumes' defined for "
- "volume '%s'",
- yylineno, complete_tree->name);
- }
- else if (tree)
- {
- fprintf (stderr,
- "syntax error: line %d (volume '%s'): \"%s\""
- "\nallowed tokens are 'volume', 'type', "
- "'subvolumes', 'option', 'end-volume'",
- yylineno, complete_tree->name,
- yytext);
-
- gf_log ("parser", GF_LOG_ERROR,
- "syntax error: line %d (volume '%s'): \"%s\""
- "\nallowed tokens are 'volume', 'type', "
- "'subvolumes', 'option', 'end-volume'()",
- yylineno, complete_tree->name,
- yytext);
- }
- else
- {
- fprintf (stderr,
- "syntax error: line %d (just after volume "
- "'%s'): \"%s\"\n(%s)",
- yylineno, complete_tree->name,
- yytext,
- "allowed tokens are 'volume', 'type', "
- "'subvolumes', 'option', 'end-volume'");
- gf_log ("parser", GF_LOG_ERROR,
- "syntax error: line %d (just after volume "
- "'%s'): \"%s\"\n(%s)",
- yylineno, complete_tree->name,
- yytext,
- "allowed tokens are 'volume', 'type', "
- "'subvolumes', 'option', 'end-volume'");
- }
- }
- else
- {
- fprintf (stderr,
- "syntax error in line %d: \"%s\" \n"
- "(allowed tokens are 'volume', 'type', "
- "'subvolumes', 'option', 'end-volume')\n",
- yylineno, yytext);
- gf_log ("parser", GF_LOG_ERROR,
- "syntax error in line %d: \"%s\" \n"
- "(allowed tokens are 'volume', 'type', "
- "'subvolumes', 'option', 'end-volume')\n",
- yylineno, yytext);
- }
-
- cut_tree (tree);
- complete_tree = NULL;
- return 0;
-}
-
-static int
-execute_cmd (char *cmd, char **result, size_t size)
-{
- FILE *fpp = NULL;
- int i = 0, status = 0;
- int character = 0;
- char *buf = *result;
-
- fpp = popen (cmd, "r");
- if (!fpp) {
- gf_log ("parser", GF_LOG_ERROR, "%s: failed to popen", cmd);
- return -1;
- }
-
- while ((character = fgetc (fpp)) != EOF) {
- if (i == size) {
- size *= 2;
- buf = *result = realloc (*result, size);
- }
-
- buf[i++] = character;
- }
-
- if (i > 0) {
- i--;
- buf[i] = '\0';
- }
-
- status = pclose (fpp);
- if (status == -1 || !WIFEXITED (status) ||
- ((WEXITSTATUS (status)) != 0)) {
- i = -1;
- buf[0] = '\0';
- }
-
- return i;
-}
-
-static int
-parse_backtick (FILE *srcfp, FILE *dstfp)
-{
- int ret = 0, i = 0;
- char *cmd = NULL, *result = NULL;
- size_t cmd_buf_size = GF_CMD_BUFFER_LEN;
- char escaped = 0, in_backtick = 0;
- int line = 1, column = 0, backtick_line = 0, backtick_column = 0;
- int character = 0;
-
- fseek (srcfp, 0L, SEEK_SET);
- fseek (dstfp, 0L, SEEK_SET);
-
- cmd = CALLOC (cmd_buf_size, 1);
- if (cmd == NULL) {
- gf_log ("parser", GF_LOG_ERROR, "Out of memory");
- return -1;
- }
-
- result = CALLOC (cmd_buf_size * 2, 1);
- if (result == NULL) {
- FREE (cmd);
- gf_log ("parser", GF_LOG_ERROR, "Out of memory");
- return -1;
- }
-
- while ((character = fgetc (srcfp)) != EOF) {
- if ((character == '`') && !escaped) {
- if (in_backtick) {
- cmd[i] = '\0';
- result[0] = '\0';
-
- ret = execute_cmd (cmd, &result,
- 2 * cmd_buf_size);
- if (ret < 0) {
- ret = -1;
- goto out;
- }
- fwrite (result, ret, 1, dstfp);
- } else {
- i = 0;
- cmd[i] = '\0';
-
- backtick_column = column;
- backtick_line = line;
- }
-
- in_backtick = !in_backtick;
- } else {
- if (in_backtick) {
- if (i == cmd_buf_size) {
- cmd_buf_size *= 2;
- cmd = realloc (cmd, cmd_buf_size);
- if (cmd == NULL) {
- return -1;
- }
-
- result = realloc (result,
- 2 * cmd_buf_size);
- if (result == NULL) {
- free (cmd);
- return -1;
- }
- }
-
- cmd[i++] = character;
- } else {
- fputc (character, dstfp);
- }
- }
-
- if (character == '\\') {
- escaped = !escaped;
- } else {
- escaped = 0;
- }
-
- if (character == '\n') {
- line++;
- column = 0;
- } else {
- column++;
- }
- }
-
- if (in_backtick) {
- gf_log ("parser", GF_LOG_ERROR,
- "Unterminated backtick in volume specfication file at line (%d), column (%d).",
- line, column);
- ret = -1;
- }
-
-out:
- fseek (srcfp, 0L, SEEK_SET);
- fseek (dstfp, 0L, SEEK_SET);
- free (cmd);
- free (result);
-
- return ret;
-}
-
-extern FILE *yyin;
-xlator_t *
-file_to_xlator_tree (glusterfs_ctx_t *ctx,
- FILE *fp)
-{
- int32_t ret = 0;
- xlator_t *tmp_tree = NULL;
- FILE *tmp_file = NULL;
- char *buffer = NULL;
-
- tmp_file = tmpfile ();
- if (NULL == tmp_file) {
- gf_log ("parser", GF_LOG_ERROR,
- "cannot create temparory file");
- return NULL;
- }
-
- ret = parse_backtick (fp, tmp_file);
- if (ret < 0) {
- gf_log ("parser", GF_LOG_ERROR,
- "parsing of backticks failed");
- fclose (tmp_file);
- FREE (buffer);
- return NULL;
- }
-
- gctx = ctx;
- yyin = tmp_file;
- ret = yyparse ();
-
- fclose (tmp_file);
- FREE (buffer);
-
- if (1 == ret) {
- gf_log ("parser", GF_LOG_DEBUG,
- "parsing of volfile failed, please review it "
- "once more");
- tree = complete_tree = NULL;
- return NULL;
- }
-
- tmp_tree = complete_tree;
- tree = complete_tree = NULL;
-
- return tmp_tree;
-}
diff --git a/libglusterfs/src/stack.h b/libglusterfs/src/stack.h
index 48b5587ac4f..ac69e389f22 100644
--- a/libglusterfs/src/stack.h
+++ b/libglusterfs/src/stack.h
@@ -143,7 +143,7 @@ FRAME_DESTROY (call_frame_t *frame)
static inline void
STACK_DESTROY (call_stack_t *stack)
{
- glusterfs_ctx_t *ctx = get_global_ctx_ptr ();
+ glusterfs_ctx_t *ctx = glusterfs_ctx_get ();
if (ctx && ctx->measure_latency) {
gettimeofday (&stack->frames.end, NULL);
@@ -330,18 +330,18 @@ copy_frame (call_frame_t *frame)
{
list_add (&newstack->all_frames, &oldstack->all_frames);
newstack->pool->cnt++;
-
}
UNLOCK (&oldstack->pool->lock);
return &newstack->frames;
}
+
static inline call_frame_t *
create_frame (xlator_t *xl, call_pool_t *pool)
{
- call_stack_t *stack = NULL;
- glusterfs_ctx_t *ctx = get_global_ctx_ptr ();
+ call_stack_t *stack = NULL;
+ glusterfs_ctx_t *ctx = glusterfs_ctx_get ();
if (!xl || !pool) {
return NULL;
diff --git a/libglusterfs/src/statedump.c b/libglusterfs/src/statedump.c
index 678ed6c8ecd..6f30a30ea78 100644
--- a/libglusterfs/src/statedump.c
+++ b/libglusterfs/src/statedump.c
@@ -33,17 +33,20 @@ extern xlator_t global_xlator;
static pthread_mutex_t gf_proc_dump_mutex;
static int gf_dump_fd = -1;
-static void
+
+static void
gf_proc_dump_lock (void)
{
- pthread_mutex_lock(&gf_proc_dump_mutex);
+ pthread_mutex_lock (&gf_proc_dump_mutex);
}
-static void
+
+static void
gf_proc_dump_unlock (void)
{
- pthread_mutex_unlock(&gf_proc_dump_mutex);
-}
+ pthread_mutex_unlock (&gf_proc_dump_mutex);
+}
+
static int
gf_proc_dump_open (void)
@@ -51,10 +54,10 @@ gf_proc_dump_open (void)
char path[256];
int dump_fd = -1;
- memset(path, 0, sizeof(path));
- snprintf(path, sizeof(path), "%s.%d",GF_DUMP_LOGFILE_ROOT, getpid());
+ memset (path, 0, sizeof (path));
+ snprintf (path, sizeof (path), "%s.%d", GF_DUMP_LOGFILE_ROOT, getpid ());
- dump_fd = open(path, O_CREAT|O_RDWR|O_TRUNC|O_APPEND, 0600);
+ dump_fd = open (path, O_CREAT|O_RDWR|O_TRUNC|O_APPEND, 0600);
if (dump_fd < 0) {
gf_log("", GF_LOG_ERROR, "Unable to open file: %s"
" errno: %d", path, errno);
@@ -65,56 +68,59 @@ gf_proc_dump_open (void)
return 0;
}
+
static void
gf_proc_dump_close (void)
{
- close(gf_dump_fd);
+ close (gf_dump_fd);
gf_dump_fd = -1;
}
+
void
-gf_proc_dump_add_section (char *key, ...)
+gf_proc_dump_add_section (char *key, ...)
{
-
+
char buf[GF_DUMP_MAX_BUF_LEN];
va_list ap;
int ret;
assert(key);
-
- memset(buf, 0, sizeof(buf));
- snprintf(buf, GF_DUMP_MAX_BUF_LEN, "\n[");
- va_start(ap, key);
- vsnprintf(buf + strlen(buf),
- GF_DUMP_MAX_BUF_LEN - strlen(buf), key, ap);
- va_end(ap);
- snprintf(buf + strlen(buf),
- GF_DUMP_MAX_BUF_LEN - strlen(buf), "]\n");
- ret = write(gf_dump_fd, buf, strlen(buf));
+
+ memset (buf, 0, sizeof(buf));
+ snprintf (buf, GF_DUMP_MAX_BUF_LEN, "\n[");
+ va_start (ap, key);
+ vsnprintf (buf + strlen(buf),
+ GF_DUMP_MAX_BUF_LEN - strlen (buf), key, ap);
+ va_end (ap);
+ snprintf (buf + strlen(buf),
+ GF_DUMP_MAX_BUF_LEN - strlen (buf), "]\n");
+ ret = write (gf_dump_fd, buf, strlen (buf));
}
+
void
-gf_proc_dump_write (char *key, char *value,...)
-{
-
- char buf[GF_DUMP_MAX_BUF_LEN];
- int offset = 0;
+gf_proc_dump_write (char *key, char *value,...)
+{
+
+ char buf[GF_DUMP_MAX_BUF_LEN];
+ int offset = 0;
va_list ap;
int ret;
-
- offset = strlen(key);
-
- memset(buf, 0, GF_DUMP_MAX_BUF_LEN);
- snprintf(buf, GF_DUMP_MAX_BUF_LEN, "%s",key);
- snprintf(buf + offset, GF_DUMP_MAX_BUF_LEN - offset, "=");
+
+ offset = strlen (key);
+
+ memset (buf, 0, GF_DUMP_MAX_BUF_LEN);
+ snprintf (buf, GF_DUMP_MAX_BUF_LEN, "%s", key);
+ snprintf (buf + offset, GF_DUMP_MAX_BUF_LEN - offset, "=");
offset += 1;
- va_start(ap, value);
- vsnprintf(buf + offset, GF_DUMP_MAX_BUF_LEN - offset, value, ap);
- va_end(ap);
+ va_start (ap, value);
+ vsnprintf (buf + offset, GF_DUMP_MAX_BUF_LEN - offset, value, ap);
+ va_end (ap);
- offset = strlen(buf);
- snprintf(buf + offset, GF_DUMP_MAX_BUF_LEN - offset, "\n");
- ret = write(gf_dump_fd, buf, strlen(buf));
+ offset = strlen (buf);
+ snprintf (buf + offset, GF_DUMP_MAX_BUF_LEN - offset, "\n");
+ ret = write (gf_dump_fd, buf, strlen (buf));
}
static void
@@ -165,20 +171,20 @@ gf_proc_dump_mem_info ()
#ifdef HAVE_MALLOC_STATS
struct mallinfo info;
- memset(&info, 0, sizeof(struct mallinfo));
- info = mallinfo();
-
- gf_proc_dump_add_section("mallinfo");
- gf_proc_dump_write("mallinfo_arena", "%d", info.arena);
- gf_proc_dump_write("mallinfo_ordblks", "%d", info.ordblks);
- gf_proc_dump_write("mallinfo_smblks","%d", info.smblks);
- gf_proc_dump_write("mallinfo_hblks","%d", info.hblks);
- gf_proc_dump_write("mallinfo_hblkhd", "%d", info.hblkhd);
- gf_proc_dump_write("mallinfo_usmblks","%d", info.usmblks);
- gf_proc_dump_write("mallinfo_fsmblks","%d", info.fsmblks);
- gf_proc_dump_write("mallinfo_uordblks","%d", info.uordblks);
- gf_proc_dump_write("mallinfo_fordblks", "%d", info.fordblks);
- gf_proc_dump_write("mallinfo_keepcost", "%d", info.keepcost);
+ memset (&info, 0, sizeof (struct mallinfo));
+ info = mallinfo ();
+
+ gf_proc_dump_add_section ("mallinfo");
+ gf_proc_dump_write ("mallinfo_arena", "%d", info.arena);
+ gf_proc_dump_write ("mallinfo_ordblks", "%d", info.ordblks);
+ gf_proc_dump_write ("mallinfo_smblks", "%d", info.smblks);
+ gf_proc_dump_write ("mallinfo_hblks", "%d", info.hblks);
+ gf_proc_dump_write ("mallinfo_hblkhd", "%d", info.hblkhd);
+ gf_proc_dump_write ("mallinfo_usmblks", "%d", info.usmblks);
+ gf_proc_dump_write ("mallinfo_fsmblks", "%d", info.fsmblks);
+ gf_proc_dump_write ("mallinfo_uordblks", "%d", info.uordblks);
+ gf_proc_dump_write ("mallinfo_fordblks", "%d", info.fordblks);
+ gf_proc_dump_write ("mallinfo_keepcost", "%d", info.keepcost);
#endif
gf_proc_dump_xlator_mem_info(&global_xlator);
@@ -203,12 +209,11 @@ gf_proc_dump_xlator_info (xlator_t *this_xl)
continue;
}
if (this_xl->dumpops->priv)
- this_xl->dumpops->priv(this_xl);
+ this_xl->dumpops->priv (this_xl);
if (this_xl->dumpops->inode)
- this_xl->dumpops->inode(this_xl);
+ this_xl->dumpops->inode (this_xl);
if (this_xl->dumpops->fd)
- this_xl->dumpops->fd(this_xl);
-
+ this_xl->dumpops->fd (this_xl);
this_xl = this_xl->next;
}
@@ -221,44 +226,45 @@ gf_proc_dump_info (int signum)
{
int ret = -1;
glusterfs_ctx_t *ctx = NULL;
-
- gf_proc_dump_lock();
- ret = gf_proc_dump_open();
- if (ret < 0)
+
+ gf_proc_dump_lock ();
+ ret = gf_proc_dump_open ();
+ if (ret < 0)
goto out;
- gf_proc_dump_mem_info();
- ctx = get_global_ctx_ptr();
+ gf_proc_dump_mem_info ();
+ ctx = glusterfs_ctx_get ();
if (ctx) {
- iobuf_stats_dump(ctx->iobuf_pool);
- gf_proc_dump_pending_frames(ctx->pool);
- gf_proc_dump_xlator_info(ctx->graph);
+ iobuf_stats_dump (ctx->iobuf_pool);
+ gf_proc_dump_pending_frames (ctx->pool);
+ gf_proc_dump_xlator_info (ctx->active->first);
}
-
- gf_proc_dump_close();
+
+ gf_proc_dump_close ();
out:
- gf_proc_dump_unlock();
+ gf_proc_dump_unlock ();
return;
}
-void
+
+void
gf_proc_dump_fini (void)
{
- pthread_mutex_destroy(&gf_proc_dump_mutex);
+ pthread_mutex_destroy (&gf_proc_dump_mutex);
}
void
gf_proc_dump_init ()
{
- pthread_mutex_init(&gf_proc_dump_mutex, NULL);
+ pthread_mutex_init (&gf_proc_dump_mutex, NULL);
return;
}
+
void
gf_proc_dump_cleanup (void)
{
- pthread_mutex_destroy(&gf_proc_dump_mutex);
+ pthread_mutex_destroy (&gf_proc_dump_mutex);
}
-
diff --git a/libglusterfs/src/xlator.c b/libglusterfs/src/xlator.c
index 4a0de300163..e9ace1714ca 100644
--- a/libglusterfs/src/xlator.c
+++ b/libglusterfs/src/xlator.c
@@ -703,6 +703,7 @@ xlator_set_type (xlator_t *xl,
gf_log ("xlator", GF_LOG_DEBUG, "%s", dlerror ());
return -1;
}
+ xl->dlhandle = handle;
if (!(xl->fops = dlsym (handle, "fops"))) {
gf_log ("xlator", GF_LOG_DEBUG, "dlsym(fops) on %s",
@@ -813,52 +814,26 @@ xlator_search_by_name (xlator_t *any, const char *name)
}
-static int32_t
-xlator_init_rec (xlator_t *xl)
+static int
+__xlator_init(xlator_t *xl)
{
- xlator_t *trav = NULL;
- int32_t ret = 0;
+ xlator_t *old_THIS = NULL;
+ int ret = 0;
- if (xl == NULL) {
- gf_log ("xlator", GF_LOG_DEBUG, "invalid argument");
- return 0;
- }
+ old_THIS = THIS;
+ THIS = xl;
- trav = xl;
- while (trav->prev)
- trav = trav->prev;
+ ret = xl->init (xl);
- while (trav) {
- ret = -1;
- if (trav->mem_acct_init)
- trav->mem_acct_init (trav);
- if (trav->init && !trav->ready) {
- ret = xlator_init (trav);
- if (ret) {
- gf_log (trav->name, GF_LOG_ERROR,
- "Initialization of volume '%s' failed,"
- " review your volfile again",
- trav->name);
- break;
- } else {
- trav->init_succeeded = 1;
- }
- } else {
- gf_log (trav->name, GF_LOG_DEBUG, "No init() found");
- }
- /* This 'xl' is checked */
- trav->ready = 1;
- trav = trav->next;
- }
+ THIS = old_THIS;
- return ret;
+ return ret;
}
-int32_t
-xlator_tree_init (xlator_t *xl)
+int
+xlator_init (xlator_t *xl)
{
- xlator_t *top = NULL;
int32_t ret = 0;
if (xl == NULL) {
@@ -866,17 +841,30 @@ xlator_tree_init (xlator_t *xl)
return 0;
}
- top = xl;
-/*
- while (top->parents)
- top = top->parents->xlator;
-*/
- ret = xlator_init_rec (top);
+ ret = -1;
- if (ret == 0 && top->notify) {
- top->notify (top, GF_EVENT_PARENT_UP, NULL);
- }
+ if (xl->mem_acct_init)
+ xl->mem_acct_init (xl);
+
+ if (!xl->init) {
+ gf_log (xl->name, GF_LOG_DEBUG, "No init() found");
+ goto out;
+ }
+
+ ret = __xlator_init (xl);
+ if (ret) {
+ gf_log (xl->name, GF_LOG_ERROR,
+ "Initialization of volume '%s' failed,"
+ " review your volfile again",
+ xl->name);
+ goto out;
+ }
+
+ xl->init_succeeded = 1;
+
+ ret = 0;
+out:
return ret;
}
@@ -932,22 +920,6 @@ xlator_notify (xlator_t *xl, int event, void *data, ...)
int
-xlator_init (xlator_t *xl)
-{
- xlator_t *old_THIS = NULL;
- int ret = 0;
-
- old_THIS = THIS;
- THIS = xl;
-
- ret = xl->init (xl);
-
- THIS = old_THIS;
-
- return ret;
-}
-
-int
xlator_mem_acct_init (xlator_t *xl, int num_types)
{
int i = 0;
@@ -1064,3 +1036,43 @@ loc_copy (loc_t *dst, loc_t *src)
out:
return ret;
}
+
+
+int
+xlator_list_destroy (xlator_list_t *list)
+{
+ xlator_list_t *next = NULL;
+
+ while (list) {
+ next = list->next;
+ GF_FREE (list);
+ list = next;
+ }
+
+ return 0;
+}
+
+
+int
+xlator_destroy (xlator_t *xl)
+{
+ if (!xl)
+ return 0;
+
+ if (xl->name)
+ GF_FREE (xl->name);
+ if (xl->type)
+ GF_FREE (xl->type);
+ if (xl->dlhandle)
+ dlclose (xl->dlhandle);
+ if (xl->options)
+ dict_destroy (xl->options);
+
+ xlator_list_destroy (xl->children);
+
+ xlator_list_destroy (xl->parents);
+
+ GF_FREE (xl);
+
+ return 0;
+}
diff --git a/libglusterfs/src/xlator.h b/libglusterfs/src/xlator.h
index 8217101e2ab..142423da2f3 100644
--- a/libglusterfs/src/xlator.h
+++ b/libglusterfs/src/xlator.h
@@ -30,7 +30,6 @@
#include <inttypes.h>
-#include "glusterfs.h"
#include "logging.h"
#include "common-utils.h"
#include "dict.h"
@@ -819,10 +818,11 @@ struct _xlator {
dict_t *options;
/* Set after doing dlopen() */
+ void *dlhandle;
struct xlator_fops *fops;
struct xlator_cbks *cbks;
struct xlator_dumpops *dumpops;
- struct list_head volume_options; /* list of volume_option_t */
+ struct list_head volume_options; /* list of volume_option_t */
void (*fini) (xlator_t *this);
int32_t (*init) (xlator_t *this);
@@ -833,12 +833,13 @@ struct _xlator {
fop_latency_t latencies[GF_FOP_MAXVALUE];
/* Misc */
- glusterfs_ctx_t *ctx;
- inode_table_t *itable;
- char ready;
- char init_succeeded;
- void *private;
- struct mem_acct mem_acct;
+ glusterfs_ctx_t *ctx;
+ glusterfs_graph_t *graph; /* not set for fuse */
+ inode_table_t *itable;
+ char ready;
+ char init_succeeded;
+ void *private;
+ struct mem_acct mem_acct;
};
#define xlator_has_parent(xl) (xl->parents != NULL)
@@ -852,6 +853,7 @@ xlator_t *file_to_xlator_tree (glusterfs_ctx_t *ctx,
int xlator_notify (xlator_t *this, int32_t event, void *data, ...);
int xlator_init (xlator_t *this);
+int xlator_destroy (xlator_t *xl);
int32_t xlator_tree_init (xlator_t *xl);
int32_t xlator_tree_free (xlator_t *xl);
diff --git a/xlators/cluster/afr/src/Makefile.am b/xlators/cluster/afr/src/Makefile.am
index 1a8ddadb798..fe5a8216569 100644
--- a/xlators/cluster/afr/src/Makefile.am
+++ b/xlators/cluster/afr/src/Makefile.am
@@ -1,7 +1,7 @@
xlator_LTLIBRARIES = afr.la
xlatordir = $(libdir)/glusterfs/$(PACKAGE_VERSION)/xlator/cluster
-afr_la_LDFLAGS = -module -avoidversion
+afr_la_LDFLAGS = -module -avoidversion
afr_la_SOURCES = afr.c afr-dir-read.c afr-dir-write.c afr-inode-read.c afr-inode-write.c afr-open.c afr-transaction.c afr-self-heal-data.c afr-self-heal-common.c afr-self-heal-metadata.c afr-self-heal-entry.c afr-self-heal-algorithm.c
afr_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la
@@ -9,9 +9,9 @@ afr_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la
noinst_HEADERS = afr.h afr-transaction.h afr-inode-write.h afr-inode-read.h afr-dir-read.h afr-dir-write.h afr-self-heal.h afr-self-heal-common.h afr-self-heal-algorithm.h
AM_CFLAGS = -fPIC -D_FILE_OFFSET_BITS=64 -D_GNU_SOURCE -Wall -D$(GF_HOST_OS) \
- -I$(top_srcdir)/libglusterfs/src -shared -nostartfiles $(GF_CFLAGS)
+ -I$(top_srcdir)/libglusterfs/src -I$(top_srcdir)/contrib/md5 -shared -nostartfiles $(GF_CFLAGS)
-CLEANFILES =
+CLEANFILES =
uninstall-local:
rm -f $(DESTDIR)$(xlatordir)/replicate.so
diff --git a/xlators/mount/fuse/src/fuse-bridge.c b/xlators/mount/fuse/src/fuse-bridge.c
index 74087fc6da4..483c6c9fec5 100644
--- a/xlators/mount/fuse/src/fuse-bridge.c
+++ b/xlators/mount/fuse/src/fuse-bridge.c
@@ -91,23 +91,31 @@ struct fuse_private {
size_t volfile_size;
char *mount_point;
struct iobuf *iobuf;
+
pthread_t fuse_thread;
char fuse_thread_started;
+
uint32_t direct_io_mode;
size_t *msg0_len_p;
+
double entry_timeout;
double attribute_timeout;
- pthread_cond_t first_call_cond;
- pthread_mutex_t first_call_mutex;
- char first_call;
+
+ pthread_cond_t sync_cond;
+ pthread_mutex_t sync_mutex;
+ char child_up;
+
+ char init_recvd;
+
gf_boolean_t strict_volfile_check;
- pthread_cond_t child_up_cond;
- pthread_mutex_t child_up_mutex;
- char child_up_value;
+
fuse_handler_t **fuse_ops;
fuse_handler_t **fuse_ops0;
pthread_mutex_t fuse_dump_mutex;
int fuse_dump_fd;
+
+ glusterfs_graph_t *next_graph;
+ xlator_t *active_subvol;
};
typedef struct fuse_private fuse_private_t;
@@ -138,8 +146,7 @@ typedef struct fuse_private fuse_private_t;
free_state (state); \
return; \
} \
- xl = frame->this->children ? \
- frame->this->children->xlator : NULL; \
+ xl = fuse_state_subvol (state); \
\
frame->root->state = state; \
frame->root->op = op_num; \
@@ -190,6 +197,35 @@ typedef struct {
} fuse_state_t;
+xlator_t *
+fuse_state_subvol (fuse_state_t *state)
+{
+ xlator_t *subvol = NULL;
+
+ if (!state)
+ return NULL;
+
+ if (state->loc.inode)
+ subvol = state->loc.inode->table->xl;
+
+ if (state->fd)
+ subvol = state->fd->inode->table->xl;
+
+ return subvol;
+}
+
+
+xlator_t *
+fuse_active_subvol (xlator_t *fuse)
+{
+ fuse_private_t *priv = NULL;
+
+ priv = fuse->private;
+
+ return priv->active_subvol;
+}
+
+
static void
free_state (fuse_state_t *state)
{
@@ -231,7 +267,6 @@ get_state (xlator_t *this, fuse_in_header_t *finh)
if (!state)
return NULL;
state->pool = this->ctx->pool;
- state->itable = this->itable;
state->finh = finh;
state->this = this;
@@ -349,12 +384,14 @@ send_fuse_err (xlator_t *this, fuse_in_header_t *finh, int error)
}
static inode_t *
-fuse_ino_to_inode (uint64_t ino, inode_table_t *table)
+fuse_ino_to_inode (uint64_t ino, xlator_t *fuse)
{
- inode_t *inode = NULL;
+ inode_t *inode = NULL;
+ xlator_t *active_subvol = NULL;
if (ino == 1) {
- inode = table->root;
+ active_subvol = fuse_active_subvol (fuse);
+ inode = active_subvol->itable->root;
} else {
inode = (inode_t *) (unsigned long) ino;
inode_ref (inode);
@@ -390,13 +427,13 @@ fuse_loc_fill (loc_t *loc, fuse_state_t *state, ino_t ino,
if (name) {
parent = loc->parent;
if (!parent) {
- parent = fuse_ino_to_inode (par, state->itable);
+ parent = fuse_ino_to_inode (par, state->this);
loc->parent = parent;
}
inode = loc->inode;
if (!inode) {
- inode = inode_grep (state->itable, parent, name);
+ inode = inode_grep (parent->table, parent, name);
loc->inode = inode;
}
@@ -411,7 +448,7 @@ fuse_loc_fill (loc_t *loc, fuse_state_t *state, ino_t ino,
} else {
inode = loc->inode;
if (!inode) {
- inode = fuse_ino_to_inode (ino, state->itable);
+ inode = fuse_ino_to_inode (ino, state->this);
loc->inode = inode;
}
@@ -593,13 +630,15 @@ fuse_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
{
fuse_state_t *state = NULL;
call_frame_t *prev = NULL;
+ inode_table_t *itable = NULL;
state = frame->root->state;
prev = cookie;
if (op_ret == -1 && state->is_revalidate == 1) {
+ itable = state->loc.inode->table;
inode_unref (state->loc.inode);
- state->loc.inode = inode_new (state->itable);
+ state->loc.inode = inode_new (itable);
state->is_revalidate = 2;
STACK_WIND (frame, fuse_lookup_cbk,
@@ -639,7 +678,7 @@ fuse_lookup (xlator_t *this, fuse_in_header_t *finh, void *msg)
"%"PRIu64": LOOKUP %s", finh->unique,
state->loc.path);
- state->loc.inode = inode_new (state->itable);
+ state->loc.inode = inode_new (state->loc.parent->table);
} else {
gf_log ("glusterfs-fuse", GF_LOG_TRACE,
"%"PRIu64": LOOKUP %s(%"PRId64")", finh->unique,
@@ -667,7 +706,7 @@ fuse_forget (xlator_t *this, fuse_in_header_t *finh, void *msg)
return;
}
- fuse_inode = fuse_ino_to_inode (finh->nodeid, this->itable);
+ fuse_inode = fuse_ino_to_inode (finh->nodeid, this);
inode_forget (fuse_inode, ffi->nlookup);
inode_unref (fuse_inode);
@@ -1371,7 +1410,7 @@ fuse_mknod (xlator_t *this, fuse_in_header_t *finh, void *msg)
return;
}
- state->loc.inode = inode_new (state->itable);
+ state->loc.inode = inode_new (state->loc.parent->table);
gf_log ("glusterfs-fuse", GF_LOG_TRACE,
"%"PRIu64": MKNOD %s", finh->unique,
@@ -1404,7 +1443,7 @@ fuse_mkdir (xlator_t *this, fuse_in_header_t *finh, void *msg)
return;
}
- state->loc.inode = inode_new (state->itable);
+ state->loc.inode = inode_new (state->loc.parent->table);
gf_log ("glusterfs-fuse", GF_LOG_TRACE,
"%"PRIu64": MKDIR %s", finh->unique,
@@ -1501,7 +1540,7 @@ fuse_symlink (xlator_t *this, fuse_in_header_t *finh, void *msg)
return;
}
- state->loc.inode = inode_new (state->itable);
+ state->loc.inode = inode_new (state->loc.parent->table);
gf_log ("glusterfs-fuse", GF_LOG_TRACE,
"%"PRIu64": SYMLINK %s -> %s", finh->unique,
@@ -1541,7 +1580,7 @@ fuse_rename_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
}
buf->ia_blksize = this->ctx->page_size;
- inode_rename (state->itable,
+ inode_rename (state->loc.parent->table,
state->loc.parent, state->loc.name,
state->loc2.parent, state->loc2.name,
state->loc.inode, buf);
@@ -1790,7 +1829,7 @@ fuse_create (xlator_t *this, fuse_in_header_t *finh, void *msg)
return;
}
- state->loc.inode = inode_new (state->itable);
+ state->loc.inode = inode_new (state->loc.parent->table);
fd = fd_create (state->loc.inode, finh->pid);
state->fd = fd;
@@ -2530,9 +2569,7 @@ fuse_xattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
fuse_in_header_t *finh = NULL;
data_t *value_data = NULL;
fuse_private_t *priv = NULL;
- struct stat st;
- char *file = NULL;
- int32_t fd = -1;
+ int ret = -1;
int32_t len = 0;
data_pair_t *trav = NULL;
@@ -2550,39 +2587,12 @@ fuse_xattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
/* if callback for getxattr */
value_data = dict_get (dict, state->name);
if (value_data) {
- send_fuse_xattr (this, finh, value_data->data,
- value_data->len, /* Don't return the value for '\0' */
- state->size);
- /* if(op_ret >...)...else if...else */
- } else if (!strcmp (state->name, "user.glusterfs-booster-volfile")) {
- if (!priv->volfile) {
- memset (&st, 0, sizeof (st));
- fd = fileno (this->ctx->specfp);
- if (fstat (fd, &st) != 0) {
- gf_log (this->name,
- GF_LOG_ERROR,
- "fstat on fd (%d) failed (%s)", fd, strerror (errno));
- send_fuse_err (this, finh, ENODATA);
- }
-
- priv->volfile_size = st.st_size;
- file = priv->volfile = GF_CALLOC (1, priv->volfile_size,
- gf_fuse_mt_char);
- len = lseek (fd, 0, SEEK_SET);
- while ((len = read (fd, file, GF_UNIT_KB)) > 0) {
- file += len;
- }
- }
- send_fuse_xattr (this, finh, priv->volfile,
- priv->volfile_size, state->size);
- /* if(op_ret >...)...else if...else */
- } else if (!strcmp (state->name, "user.glusterfs-booster-path")) {
- send_fuse_xattr (this, finh, state->loc.path,
- strlen (state->loc.path) + 1, state->size);
- } else if (!strcmp (state->name, "user.glusterfs-booster-mount")) {
- send_fuse_xattr (this, finh, priv->mount_point,
- strlen (priv->mount_point) + 1, state->size);
+ ret = value_data->len; /* Don't return the value for '\0' */
+ value = value_data->data;
+
+ send_fuse_xattr (this, finh, value, ret, state->size);
+ /* if(ret >...)...else if...else */
} else {
send_fuse_err (this, finh, ENODATA);
} /* if(value_data)...else */
@@ -2608,17 +2618,14 @@ fuse_xattr_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
} else {
/* if failure - no need to check if listxattr or getxattr */
if (op_errno != ENODATA) {
- if (op_errno == ENOTSUP)
- {
+ if (op_errno == ENOTSUP) {
GF_LOG_OCCASIONALLY (gf_fuse_xattr_enotsup_log,
"glusterfs-fuse",
GF_LOG_ERROR,
"extended attribute not "
"supported by the backend "
"storage");
- }
- else
- {
+ } else {
gf_log ("glusterfs-fuse", GF_LOG_WARNING,
"%"PRIu64": %s() %s => -1 (%s)",
frame->root->unique,
@@ -2937,7 +2944,7 @@ fuse_init (xlator_t *this, fuse_in_header_t *finh, void *msg)
priv = this->private;
- if (!priv->first_call) {
+ if (priv->init_recvd) {
gf_log ("glusterfs-fuse", GF_LOG_ERROR,
"got INIT after first message");
@@ -2945,6 +2952,8 @@ fuse_init (xlator_t *this, fuse_in_header_t *finh, void *msg)
goto out;
}
+ priv->init_recvd = 1;
+
if (fini->major != FUSE_KERNEL_VERSION) {
gf_log ("glusterfs-fuse", GF_LOG_ERROR,
"unsupported FUSE protocol version %d.%d",
@@ -3014,6 +3023,13 @@ fuse_destroy (xlator_t *this, fuse_in_header_t *finh, void *msg)
}
+
+struct fuse_first_lookup {
+ pthread_mutex_t mutex;
+ pthread_cond_t cond;
+ char fin;
+};
+
int
fuse_first_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
int32_t op_ret, int32_t op_errno,
@@ -3021,8 +3037,10 @@ fuse_first_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
struct iatt *postparent)
{
fuse_private_t *priv = NULL;
+ struct fuse_first_lookup *stub = NULL;
priv = this->private;
+ stub = frame->local;
if (op_ret == 0) {
gf_log (this->name, GF_LOG_TRACE,
@@ -3031,13 +3049,14 @@ fuse_first_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
gf_log (this->name, GF_LOG_DEBUG,
"first lookup on root failed.");
}
- STACK_DESTROY (frame->root);
- pthread_mutex_lock (&priv->first_call_mutex);
+
+ pthread_mutex_lock (&stub->mutex);
{
- priv->first_call = 0;
- pthread_cond_broadcast (&priv->first_call_cond);
+ stub->fin = 1;
+ pthread_cond_broadcast (&stub->cond);
}
- pthread_mutex_unlock (&priv->first_call_mutex);
+ pthread_mutex_unlock (&stub->mutex);
+
return 0;
}
@@ -3045,45 +3064,100 @@ fuse_first_lookup_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
int
fuse_first_lookup (xlator_t *this)
{
- fuse_private_t *priv = NULL;
- loc_t loc;
- call_frame_t *frame = NULL;
- xlator_t *xl = NULL;
- dict_t *dict = NULL;
+ fuse_private_t *priv = NULL;
+ loc_t loc = {0, };
+ call_frame_t *frame = NULL;
+ xlator_t *xl = NULL;
+ dict_t *dict = NULL;
+ struct fuse_first_lookup stub;
priv = this->private;
- pthread_cond_init (&priv->first_call_cond, NULL);
- pthread_mutex_init (&priv->first_call_mutex, NULL);
-
loc.path = "/";
loc.name = "";
loc.ino = 1;
- loc.inode = fuse_ino_to_inode (1, this->itable);
+ loc.inode = fuse_ino_to_inode (1, this);
loc.parent = NULL;
dict = dict_new ();
frame = create_frame (this, this->ctx->pool);
frame->root->type = GF_OP_TYPE_FOP;
- xl = this->children->xlator;
+
+ xl = priv->active_subvol;
+
+ pthread_mutex_init (&stub.mutex, NULL);
+ pthread_cond_init (&stub.cond, NULL);
+ stub.fin = 0;
+
+ frame->local = &stub;
STACK_WIND (frame, fuse_first_lookup_cbk, xl, xl->fops->lookup,
&loc, dict);
dict_unref (dict);
- pthread_mutex_lock (&priv->first_call_mutex);
+ pthread_mutex_lock (&stub.mutex);
{
- while (priv->first_call) {
- pthread_cond_wait (&priv->first_call_cond,
- &priv->first_call_mutex);
+ while (!stub.fin) {
+ pthread_cond_wait (&stub.cond, &stub.mutex);
}
}
- pthread_mutex_unlock (&priv->first_call_mutex);
+ pthread_mutex_unlock (&stub.mutex);
+
+ pthread_mutex_destroy (&stub.mutex);
+ pthread_cond_destroy (&stub.cond);
+
+ frame->local = NULL;
+ STACK_DESTROY (frame->root);
return 0;
}
+int
+fuse_graph_sync (xlator_t *this)
+{
+ fuse_private_t *priv = NULL;
+ int need_first_lookup = 0;
+ struct timeval now = {0, };
+ struct timespec timeout = {0, };
+ int ret = 0;
+
+ priv = this->private;
+
+ pthread_mutex_lock (&priv->sync_mutex);
+ {
+ if (!priv->next_graph)
+ goto unlock;
+
+ priv->active_subvol = priv->next_graph->top;
+ priv->next_graph = NULL;
+ need_first_lookup = 1;
+
+ gettimeofday (&now, NULL);
+ timeout.tv_sec = now.tv_sec + MAX_FUSE_PROC_DELAY;
+ timeout.tv_nsec = now.tv_usec * 1000;
+
+ while (!priv->child_up) {
+ ret = pthread_cond_timedwait (&priv->sync_cond,
+ &priv->sync_mutex,
+ &timeout);
+ if (ret != 0) {
+ gf_log (this->name, GF_LOG_DEBUG,
+ "timedwait returned non zero value "
+ "ret: %d errno: %d", ret, errno);
+ break;
+ }
+ }
+ }
+unlock:
+ pthread_mutex_unlock (&priv->sync_mutex);
+
+ if (need_first_lookup)
+ fuse_first_lookup (this);
+
+ return 0;
+}
+
static void *
fuse_thread_proc (void *data)
@@ -3098,10 +3172,6 @@ fuse_thread_proc (void *data)
void *msg = NULL;
const size_t msg0_size = sizeof (*finh) + 128;
fuse_handler_t **fuse_ops = NULL;
- int ret = -1;
-
- struct timeval now;
- struct timespec timeout;
this = data;
priv = this->private;
@@ -3114,28 +3184,10 @@ fuse_thread_proc (void *data)
->page_size;
priv->msg0_len_p = &iov_in[0].iov_len;
- pthread_mutex_lock (&priv->child_up_mutex);
- {
- gettimeofday (&now, NULL);
- timeout.tv_sec = now.tv_sec + MAX_FUSE_PROC_DELAY;
- timeout.tv_nsec = now.tv_usec * 1000;
-
- while (priv->child_up_value) {
-
- ret = pthread_cond_timedwait (&priv->child_up_cond,
- &priv->child_up_mutex,
- &timeout);
- if (ret != 0) {
- gf_log (this->name, GF_LOG_DEBUG,
- " pthread_cond_timedout returned non zero value"
- " ret: %d errno: %d", ret, errno);
- break;
- }
- }
- }
- pthread_mutex_unlock (&priv->child_up_mutex);
-
for (;;) {
+ if (priv->init_recvd)
+ fuse_graph_sync (this);
+
iobuf = iobuf_get (this->ctx->iobuf_pool);
/* Add extra 128 byte to the first iov so that it can
* accomodate "ordinary" non-write requests. It's not
@@ -3161,14 +3213,6 @@ fuse_thread_proc (void *data)
res = readv (priv->fd, iov_in, 2);
- if (priv->first_call) {
- if (priv->first_call > 1) {
- priv->first_call--;
- } else {
- fuse_first_lookup (this);
- }
- }
-
if (res == -1) {
if (errno == ENODEV || errno == EBADF) {
gf_log ("glusterfs-fuse", GF_LOG_NORMAL,
@@ -3187,11 +3231,13 @@ fuse_thread_proc (void *data)
goto cont_err;
}
if (res < sizeof (finh)) {
- gf_log ("glusterfs-fuse", GF_LOG_WARNING, "short read on /dev/fuse");
+ gf_log ("glusterfs-fuse", GF_LOG_WARNING,
+ "short read on /dev/fuse");
break;
}
finh = (fuse_in_header_t *)iov_in[0].iov_base;
+
if (res != finh->len
#ifdef GF_DARWIN_HOST_OS
/* work around fuse4bsd/MacFUSE msg size miscalculation bug,
@@ -3203,7 +3249,8 @@ fuse_thread_proc (void *data)
res == finh->len + ((struct fuse_write_in *)(finh + 1))->size)
#endif
) {
- gf_log ("glusterfs-fuse", GF_LOG_WARNING, "inconsistent read on /dev/fuse");
+ gf_log ("glusterfs-fuse", GF_LOG_WARNING,
+ "inconsistent read on /dev/fuse");
break;
}
@@ -3313,8 +3360,8 @@ fuse_priv_dump (xlator_t *this)
private->entry_timeout);
gf_proc_dump_write("xlator.mount.fuse.attribute_timeout", "%lf",
private->attribute_timeout);
- gf_proc_dump_write("xlator.mount.fuse.first_call", "%d",
- (int)private->first_call);
+ gf_proc_dump_write("xlator.mount.fuse.init_recvd", "%d",
+ (int)private->init_recvd);
gf_proc_dump_write("xlator.mount.fuse.strict_volfile_check", "%d",
(int)private->strict_volfile_check);
@@ -3322,55 +3369,87 @@ fuse_priv_dump (xlator_t *this)
}
-int32_t
+int
+fuse_graph_setup (xlator_t *this, glusterfs_graph_t *graph)
+{
+ inode_table_t *itable = NULL;
+ int ret = 0;
+ fuse_private_t *priv = NULL;
+
+ priv = this->private;
+
+ itable = inode_table_new (0, graph->top);
+ if (!itable)
+ return -1;
+
+ ((xlator_t *)graph->top)->itable = itable;
+
+ pthread_mutex_lock (&priv->sync_mutex);
+ {
+ priv->next_graph = graph;
+ priv->child_up = 0;
+
+ pthread_cond_signal (&priv->sync_cond);
+ }
+ pthread_mutex_unlock (&priv->sync_mutex);
+
+ return ret;
+}
+
+
+int
notify (xlator_t *this, int32_t event, void *data, ...)
{
- int32_t ret = 0;
- fuse_private_t *private = NULL;
+ int32_t ret = 0;
+ fuse_private_t *private = NULL;
+ glusterfs_graph_t *graph = NULL;
private = this->private;
switch (event)
{
- case GF_EVENT_CHILD_UP:
- case GF_EVENT_CHILD_CONNECTING:
- {
- pthread_mutex_lock (&private->child_up_mutex);
- {
- private->child_up_value = 0;
- pthread_cond_broadcast (&private->child_up_cond);
- }
- pthread_mutex_unlock (&private->child_up_mutex);
+ case GF_EVENT_GRAPH_NEW:
+ graph = data;
- break;
- }
+ ret = fuse_graph_setup (this, graph);
+ if (ret)
+ break;
- case GF_EVENT_PARENT_UP:
- {
- if (!private->fuse_thread_started)
- {
+ if (!private->fuse_thread_started) {
private->fuse_thread_started = 1;
ret = pthread_create (&private->fuse_thread, NULL,
fuse_thread_proc, this);
-
if (ret != 0) {
- gf_log ("glusterfs-fuse", GF_LOG_DEBUG,
+ gf_log (this->name, GF_LOG_DEBUG,
"pthread_create() failed (%s)",
strerror (errno));
-
- /* If fuse thread is not started, that means,
- its hung, we can't use this process. */
- raise (SIGTERM);
+ break;
}
}
- default_notify (this, GF_EVENT_PARENT_UP, data);
+ break;
+
+// case GF_EVENT_CHILD_CONNECTING:
+
+ case GF_EVENT_CHILD_UP:
+ {
+ /* set priv->active_subvol */
+ /* set priv->first_lookup = 1 */
+
+ pthread_mutex_lock (&private->sync_mutex);
+ {
+ private->child_up = 1;
+ pthread_cond_broadcast (&private->sync_cond);
+ }
+ pthread_mutex_unlock (&private->sync_mutex);
+
break;
}
+
case GF_EVENT_VOLFILE_MODIFIED:
{
- gf_log ("fuse", GF_LOG_CRITICAL,
+ gf_log (this->name, GF_LOG_CRITICAL,
"Remote volume file changed, try re-mounting.");
if (private->strict_volfile_check) {
//fuse_session_remove_chan (private->ch);
@@ -3385,7 +3464,8 @@ notify (xlator_t *this, int32_t event, void *data, ...)
default:
break;
}
- return 0;
+
+ return ret;
}
int32_t
@@ -3603,17 +3683,10 @@ init (xlator_t *this_xl)
priv->fuse_dump_fd = ret;
}
- fsname = this_xl->ctx->cmd_args.volume_file;
+ fsname = this_xl->ctx->cmd_args.volfile;
fsname = (fsname ? fsname : this_xl->ctx->cmd_args.volfile_server);
fsname = (fsname ? fsname : "glusterfs");
- this_xl->itable = inode_table_new (0, this_xl);
- if (!this_xl->itable) {
- gf_log ("glusterfs-fuse", GF_LOG_ERROR,
- "Out of memory");
-
- goto cleanup_exit;
- }
priv->fd = gf_fuse_mount (priv->mount_point, fsname,
"allow_other,default_permissions,"
@@ -3621,14 +3694,10 @@ init (xlator_t *this_xl)
if (priv->fd == -1)
goto cleanup_exit;
- this_xl->ctx->top = this_xl;
-
- priv->first_call = 2;
-
pthread_mutex_init (&priv->fuse_dump_mutex, NULL);
- pthread_cond_init (&priv->child_up_cond, NULL);
- pthread_mutex_init (&priv->child_up_mutex, NULL);
- priv->child_up_value = 1;
+ pthread_cond_init (&priv->sync_cond, NULL);
+ pthread_mutex_init (&priv->sync_mutex, NULL);
+ priv->child_up = 0;
for (i = 0; i < FUSE_OP_HIGH; i++) {
if (!fuse_std_ops[i])
diff --git a/xlators/protocol/client/src/client-protocol.c b/xlators/protocol/client/src/client-protocol.c
index 446b3a6499d..50030f8cf78 100644
--- a/xlators/protocol/client/src/client-protocol.c
+++ b/xlators/protocol/client/src/client-protocol.c
@@ -6327,7 +6327,7 @@ protocol_client_handshake (xlator_t *this, transport_t *trans)
ret = dict_set_str (options, "volfile-key",
this->ctx->cmd_args.volfile_id);
ret = dict_set_uint32 (options, "volfile-checksum",
- this->ctx->volfile_checksum);
+ this->graph->volfile_checksum);
}
dict_len = dict_serialized_length (options);
diff --git a/xlators/protocol/server/src/Makefile.am b/xlators/protocol/server/src/Makefile.am
index faf82ee21d3..8ca1783ef27 100644
--- a/xlators/protocol/server/src/Makefile.am
+++ b/xlators/protocol/server/src/Makefile.am
@@ -12,8 +12,9 @@ noinst_HEADERS = server-protocol.h server-helpers.h
AM_CFLAGS = -fPIC -D_FILE_OFFSET_BITS=64 -D_GNU_SOURCE -Wall -D$(GF_HOST_OS) \
-I$(top_srcdir)/libglusterfs/src -shared -nostartfiles \
+ -I$(top_srcdir)/contrib/md5/ \
-DDATADIR=\"$(localstatedir)\" -DCONFDIR=\"$(sysconfdir)/glusterfs\" \
$(GF_CFLAGS) -I$(top_srcdir)/xlators/protocol/lib/src
-CLEANFILES =
+CLEANFILES =
diff --git a/xlators/protocol/server/src/server-protocol.c b/xlators/protocol/server/src/server-protocol.c
index b5f90c3a5dc..31f3e7aca3c 100644
--- a/xlators/protocol/server/src/server-protocol.c
+++ b/xlators/protocol/server/src/server-protocol.c
@@ -6406,7 +6406,7 @@ init (xlator_t *this)
}
}
#endif
- this->ctx->top = this;
+ this->graph->top = this;
ret = 0;
out:
diff --git a/xlators/storage/posix/src/Makefile.am b/xlators/storage/posix/src/Makefile.am
index 9acaad65185..693cc51de9c 100644
--- a/xlators/storage/posix/src/Makefile.am
+++ b/xlators/storage/posix/src/Makefile.am
@@ -5,13 +5,14 @@ xlatordir = $(libdir)/glusterfs/$(PACKAGE_VERSION)/xlator/storage
posix_la_LDFLAGS = -module -avoidversion
posix_la_SOURCES = posix.c
-posix_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la
+posix_la_LIBADD = $(top_builddir)/libglusterfs/src/libglusterfs.la
noinst_HEADERS = posix.h
AM_CFLAGS = -fPIC -fno-strict-aliasing -D_FILE_OFFSET_BITS=64 -D_GNU_SOURCE -D$(GF_HOST_OS) -Wall \
-I$(top_srcdir)/libglusterfs/src -shared -nostartfiles \
+ -I$(top_srcdir)/contrib/md5 \
$(GF_CFLAGS)
-CLEANFILES =
+CLEANFILES =