summaryrefslogtreecommitdiffstats
path: root/glusterfsd
diff options
context:
space:
mode:
authorVikas Gorur <vikas@zresearch.com>2009-02-18 17:36:07 +0530
committerVikas Gorur <vikas@zresearch.com>2009-02-18 17:36:07 +0530
commit77adf4cd648dce41f89469dd185deec6b6b53a0b (patch)
tree02e155a5753b398ee572b45793f889b538efab6b /glusterfsd
parentf3b2e6580e5663292ee113c741343c8a43ee133f (diff)
Added all files
Diffstat (limited to 'glusterfsd')
-rw-r--r--glusterfsd/Makefile.am3
-rw-r--r--glusterfsd/src/Makefile.am24
-rw-r--r--glusterfsd/src/fetch-spec.c266
-rw-r--r--glusterfsd/src/glusterfsd.c1123
-rw-r--r--glusterfsd/src/glusterfsd.h78
5 files changed, 1494 insertions, 0 deletions
diff --git a/glusterfsd/Makefile.am b/glusterfsd/Makefile.am
new file mode 100644
index 0000000..d471a3f
--- /dev/null
+++ b/glusterfsd/Makefile.am
@@ -0,0 +1,3 @@
+SUBDIRS = src
+
+CLEANFILES =
diff --git a/glusterfsd/src/Makefile.am b/glusterfsd/src/Makefile.am
new file mode 100644
index 0000000..0609179
--- /dev/null
+++ b/glusterfsd/src/Makefile.am
@@ -0,0 +1,24 @@
+sbin_PROGRAMS = glusterfsd
+
+glusterfsd_SOURCES = glusterfsd.c fetch-spec.c
+glusterfsd_LDADD = $(top_builddir)/libglusterfs/src/libglusterfs.la $(GF_LDADD)
+glusterfsd_LDFLAGS = $(GF_LDFLAGS) $(GF_GLUSTERFS_LDFLAGS)
+noinst_HEADERS = glusterfsd.h
+
+AM_CFLAGS = -fPIC -Wall -D_FILE_OFFSET_BITS=64 -D_GNU_SOURCE -D$(GF_HOST_OS)\
+ -I$(top_srcdir)/libglusterfs/src -DDATADIR=\"$(localstatedir)\" \
+ -DCONFDIR=\"$(sysconfdir)/glusterfs\" $(GF_GLUSTERFS_CFLAGS)
+
+CLEANFILES =
+
+$(top_builddir)/libglusterfs/src/libglusterfs.la:
+ $(MAKE) -C $(top_builddir)/libglusterfs/src/ all
+
+uninstall-local:
+ rm -f $(DESTDIR)$(sbindir)/glusterfs
+
+install-data-local:
+ $(INSTALL) -d -m 755 $(DESTDIR)$(localstatedir)/run
+ $(INSTALL) -d -m 755 $(DESTDIR)$(localstatedir)/log/glusterfs
+ rm -f $(DESTDIR)$(sbindir)/glusterfs
+ ln -s glusterfsd $(DESTDIR)$(sbindir)/glusterfs
diff --git a/glusterfsd/src/fetch-spec.c b/glusterfsd/src/fetch-spec.c
new file mode 100644
index 0000000..4009a55
--- /dev/null
+++ b/glusterfsd/src/fetch-spec.c
@@ -0,0 +1,266 @@
+/*
+ Copyright (c) 2007, 2008 Z RESEARCH, Inc. <http://www.zresearch.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/>.
+*/
+
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <stdlib.h>
+
+#ifndef _CONFIG_H
+#define _CONFIG_H
+#include "config.h"
+#endif /* _CONFIG_H */
+
+#include "glusterfs.h"
+#include "stack.h"
+#include "dict.h"
+#include "transport.h"
+#include "event.h"
+#include "defaults.h"
+
+
+static int
+fetch_cbk (call_frame_t *frame,
+ void *cookie,
+ xlator_t *this,
+ int32_t op_ret,
+ int32_t op_errno,
+ char *spec_data)
+{
+ FILE *spec_fp = NULL;
+
+ spec_fp = frame->local;
+
+ if (op_ret >= 0) {
+ fwrite (spec_data, strlen (spec_data), 1, spec_fp);
+ fflush (spec_fp);
+ fclose (spec_fp);
+ }
+ else {
+ gf_log (frame->this->name, GF_LOG_ERROR,
+ "GETSPEC from server returned -1 (%s)",
+ strerror (op_errno));
+ }
+
+ frame->local = NULL;
+ STACK_DESTROY (frame->root);
+
+ /* exit the child process */
+ exit (op_ret);
+}
+
+
+static int
+fetch_notify (xlator_t *this_xl, int event, void *data, ...)
+{
+ int ret = 0;
+ call_frame_t *frame = NULL;
+
+ switch (event)
+ {
+ case GF_EVENT_CHILD_UP:
+ frame = create_frame (this_xl, this_xl->ctx->pool);
+ frame->local = this_xl->private;
+
+ STACK_WIND (frame, fetch_cbk,
+ this_xl->children->xlator,
+ this_xl->children->xlator->mops->getspec,
+ this_xl->ctx->cmd_args.volfile_id,
+ 0);
+ break;
+ case GF_EVENT_CHILD_DOWN:
+ break;
+ default:
+ ret = default_notify (this_xl, event, data);
+ break;
+ }
+
+ return ret;
+}
+
+
+static int
+fetch_init (xlator_t *xl)
+{
+ return 0;
+}
+
+static xlator_t *
+get_shrub (glusterfs_ctx_t *ctx,
+ const char *remote_host,
+ const char *transport,
+ uint32_t remote_port)
+{
+ int ret = 0;
+ xlator_t *top = NULL;
+ xlator_t *trans = NULL;
+ xlator_list_t *parent = NULL, *tmp = NULL;
+
+ top = CALLOC (1, sizeof (*top));
+ ERR_ABORT (top);
+ trans = CALLOC (1, sizeof (*trans));
+ ERR_ABORT (trans);
+
+ top->name = "top";
+ top->ctx = ctx;
+ top->next = trans;
+ top->init = fetch_init;
+ top->notify = fetch_notify;
+ top->children = (void *) CALLOC (1, sizeof (*top->children));
+ ERR_ABORT (top->children);
+ top->children->xlator = trans;
+
+ trans->name = "trans";
+ trans->ctx = ctx;
+ trans->prev = top;
+ trans->init = fetch_init;
+ trans->notify = default_notify;
+ trans->options = get_new_dict ();
+
+ parent = CALLOC (1, sizeof(*parent));
+ parent->xlator = top;
+ if (trans->parents == NULL)
+ trans->parents = parent;
+ else {
+ tmp = trans->parents;
+ while (tmp->next)
+ tmp = tmp->next;
+ tmp->next = parent;
+ }
+
+ /* TODO: log on failure to set dict */
+ if (remote_host)
+ ret = dict_set_static_ptr (trans->options, "remote-host",
+ (char *)remote_host);
+
+ if (remote_port)
+ ret = dict_set_uint32 (trans->options, "remote-port",
+ remote_port);
+
+ /* 'option remote-subvolume <x>' is needed here even though
+ * its not used
+ */
+ ret = dict_set_static_ptr (trans->options, "remote-subvolume",
+ "brick");
+ ret = dict_set_static_ptr (trans->options, "disable-handshake", "on");
+ ret = dict_set_static_ptr (trans->options, "non-blocking-io", "off");
+
+ if (transport) {
+ char *transport_type = CALLOC (1, strlen (transport) + 10);
+ ERR_ABORT (transport_type);
+ strcpy(transport_type, transport);
+
+ if (strchr (transport_type, ':'))
+ *(strchr (transport_type, ':')) = '\0';
+
+ ret = dict_set_dynstr (trans->options, "transport-type",
+ transport_type);
+ }
+
+ xlator_set_type (trans, "protocol/client");
+
+ if (xlator_tree_init (top) != 0)
+ return NULL;
+
+ return top;
+}
+
+
+static int
+_fetch (glusterfs_ctx_t *ctx,
+ FILE *spec_fp,
+ const char *remote_host,
+ const char *transport,
+ uint32_t remote_port)
+{
+ xlator_t *this = NULL;
+
+ this = get_shrub (ctx, remote_host, transport, remote_port);
+ if (this == NULL)
+ return -1;
+
+ this->private = spec_fp;
+
+ event_dispatch (ctx->event_pool);
+
+ return 0;
+}
+
+
+static int
+_fork_and_fetch (glusterfs_ctx_t *ctx,
+ FILE *spec_fp,
+ const char *remote_host,
+ const char *transport,
+ uint32_t remote_port)
+{
+ int ret;
+
+ ret = fork ();
+ switch (ret) {
+ case -1:
+ perror ("fork()");
+ break;
+ case 0:
+ /* child */
+ ret = _fetch (ctx, spec_fp, remote_host,
+ transport, remote_port);
+ if (ret == -1)
+ exit (ret);
+ default:
+ /* parent */
+ wait (&ret);
+ ret = WEXITSTATUS (ret);
+ }
+ return ret;
+}
+
+FILE *
+fetch_spec (glusterfs_ctx_t *ctx)
+{
+ char *remote_host = NULL;
+ char *transport = NULL;
+ FILE *spec_fp;
+ int32_t ret;
+
+ spec_fp = tmpfile ();
+
+ if (!spec_fp) {
+ perror ("tmpfile ()");
+ return NULL;
+ }
+
+ remote_host = ctx->cmd_args.volfile_server;
+ transport = ctx->cmd_args.volfile_server_transport;
+ if (!transport)
+ transport = "socket";
+
+ ret = _fork_and_fetch (ctx, spec_fp, remote_host, transport,
+ ctx->cmd_args.volfile_server_port);
+
+ if (!ret) {
+ fseek (spec_fp, 0, SEEK_SET);
+ }
+ else {
+ fclose (spec_fp);
+ spec_fp = NULL;
+ }
+
+ return spec_fp;
+}
diff --git a/glusterfsd/src/glusterfsd.c b/glusterfsd/src/glusterfsd.c
new file mode 100644
index 0000000..545f40e
--- /dev/null
+++ b/glusterfsd/src/glusterfsd.c
@@ -0,0 +1,1123 @@
+/*
+ Copyright (c) 2006, 2007, 2008 Z RESEARCH, Inc. <http://www.zresearch.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/>.
+*/
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <sys/resource.h>
+#include <netdb.h>
+#include <signal.h>
+#include <libgen.h>
+
+#include <sys/utsname.h>
+
+#include <stdint.h>
+#include <pthread.h>
+
+#ifndef _CONFIG_H
+#define _CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef HAVE_MALLOC_H
+#include <malloc.h>
+#endif
+
+#ifdef HAVE_MALLOC_STATS
+#ifdef DEBUG
+#include <mcheck.h>
+#endif
+#endif
+
+#include "xlator.h"
+#include "glusterfs.h"
+#include "compat.h"
+#include "logging.h"
+#include "dict.h"
+#include "protocol.h"
+#include "list.h"
+#include "timer.h"
+#include "glusterfsd.h"
+#include "stack.h"
+#include "revision.h"
+#include "common-utils.h"
+#include "event.h"
+
+#include <fnmatch.h>
+
+/* using argp for command line parsing */
+static char gf_doc[] = "";
+static char argp_doc[] = "--volfile-server=SERVER [MOUNT-POINT]\n" \
+ "--volfile=VOLFILE [MOUNT-POINT]";
+const char *argp_program_version = "" \
+ PACKAGE_NAME" "PACKAGE_VERSION" built on "__DATE__" "__TIME__ \
+ "\nRepository revision: " GLUSTERFS_REPOSITORY_REVISION "\n" \
+ "Copyright (c) 2006, 2007, 2008 Z RESEARCH Inc. " \
+ "<http://www.zresearch.com>\n" \
+ "GlusterFS comes with ABSOLUTELY NO WARRANTY.\n" \
+ "You may redistribute copies of GlusterFS under the terms of "\
+ "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 struct argp_option gf_options[] = {
+ {0, 0, 0, 0, "Basic options:"},
+ {"volfile-server", ARGP_VOLFILE_SERVER_KEY, "SERVER", 0,
+ "Server to get the volume file from. This option overrides "
+ "--volfile option"},
+ {"volfile", ARGP_VOLUME_FILE_KEY, "VOLFILE", 0,
+ "File to use as VOLUME_FILE [default: "DEFAULT_CLIENT_VOLUME_FILE" or "
+ DEFAULT_SERVER_VOLUME_FILE"]"},
+ {"spec-file", ARGP_VOLUME_FILE_KEY, "VOLFILE", OPTION_HIDDEN,
+ "File to use as VOLFILE [default : "DEFAULT_CLIENT_VOLUME_FILE" or "
+ DEFAULT_SERVER_VOLUME_FILE"]"},
+ {"log-level", ARGP_LOG_LEVEL_KEY, "LOGLEVEL", 0,
+ "Logging severity. Valid options are DEBUG, NORMAL, WARNING, ERROR, "
+ "CRITICAL and NONE [default: NORMAL]"},
+ {"log-file", ARGP_LOG_FILE_KEY, "LOGFILE", 0,
+ "File to use for logging [default: "
+ DEFAULT_LOG_FILE_DIRECTORY "/" PACKAGE_NAME ".log" "]"},
+
+ {0, 0, 0, 0, "Advanced Options:"},
+ {"volfile-server-port", ARGP_VOLFILE_SERVER_PORT_KEY, "PORT", 0,
+ "Listening port number of volfile server"},
+ {"volfile-server-transport", ARGP_VOLFILE_SERVER_TRANSPORT_KEY,
+ "TRANSPORT", 0,
+ "Transport type to get volfile from server [default: socket]"},
+ {"volfile-id", ARGP_VOLFILE_ID_KEY, "KEY", 0,
+ "'key' of the volfile to be fetched from server"},
+ {"pid-file", ARGP_PID_FILE_KEY, "PIDFILE", 0,
+ "File to use as pid file"},
+ {"no-daemon", ARGP_NO_DAEMON_KEY, 0, 0,
+ "Run in foreground"},
+ {"run-id", ARGP_RUN_ID_KEY, "RUN-ID", OPTION_HIDDEN,
+ "Run ID for the process, used by scripts to keep track of process "
+ "they started, defaults to none"},
+ {"debug", ARGP_DEBUG_KEY, 0, 0,
+ "Run in debug mode. This option sets --no-daemon, --log-level "
+ "to DEBUG and --log-file to console"},
+ {"volume-name", ARGP_VOLUME_NAME_KEY, "VOLUME-NAME", 0,
+ "Volume name to be used for MOUNT-POINT [default: top most volume "
+ "in VOLFILE]"},
+ {"xlator-option", ARGP_XLATOR_OPTION_KEY,"VOLUME-NAME.OPTION=VALUE", 0,
+ "Add/override a translator option for a volume with specified value"},
+
+ {0, 0, 0, 0, "Fuse options:"},
+ {"disable-direct-io-mode", ARGP_DISABLE_DIRECT_IO_MODE_KEY, 0, 0,
+ "Disable direct I/O mode in fuse kernel module"},
+ {"entry-timeout", ARGP_ENTRY_TIMEOUT_KEY, "SECONDS", 0,
+ "Set entry timeout to SECONDS in fuse kernel module [default: 1]"},
+ {"attribute-timeout", ARGP_ATTRIBUTE_TIMEOUT_KEY, "SECONDS", 0,
+ "Set attribute timeout to SECONDS for inodes in fuse kernel module "
+ "[default: 1]"},
+#ifdef GF_DARWIN_HOST_OS
+ {"non-local", ARGP_NON_LOCAL_KEY, 0, 0,
+ "Mount the macfuse volume without '-o local' option"},
+#endif
+ {0, 0, 0, 0, "Miscellaneous Options:"},
+ {0, }
+};
+
+
+static struct argp argp = { gf_options, parse_opts, argp_doc, gf_doc };
+
+
+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 TLA? 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, "TLA Revision : %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 *
+_add_fuse_mount (xlator_t *graph)
+{
+ int ret = 0;
+ cmd_args_t *cmd_args = NULL;
+ xlator_t *top = NULL;
+ glusterfs_ctx_t *ctx = NULL;
+ xlator_list_t *xlchild = NULL;
+
+ ctx = graph->ctx;
+ cmd_args = &ctx->cmd_args;
+
+ xlchild = CALLOC (sizeof (*xlchild), 1);
+ ERR_ABORT (xlchild);
+ xlchild->xlator = graph;
+
+ top = CALLOC (1, sizeof (*top));
+ top->name = 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,
+ "MOUNT-POINT %s initialization failed",
+ cmd_args->mount_point);
+ return NULL;
+ }
+ top->children = xlchild;
+ top->ctx = graph->ctx;
+ top->next = graph;
+ top->options = get_new_dict ();
+
+ ret = dict_set_static_ptr (top->options, ZR_MOUNTPOINT_OPT,
+ cmd_args->mount_point);
+ if (ret < 0) {
+ gf_log ("glusterfs", GF_LOG_DEBUG,
+ "failed to set mount-point to options dictionary");
+ }
+
+ if (cmd_args->fuse_attribute_timeout)
+ ret = dict_set_uint32 (top->options, ZR_ATTR_TIMEOUT_OPT,
+ cmd_args->fuse_attribute_timeout);
+ if (cmd_args->fuse_entry_timeout)
+ ret = dict_set_uint32 (top->options, ZR_ENTRY_TIMEOUT_OPT,
+ cmd_args->fuse_entry_timeout);
+
+#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 == _gf_true) {
+ gf_log ("glusterfs", 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");
+
+ if (cmd_args->non_local)
+ ret = dict_set_uint32 (top->options, "macfuse-local",
+ cmd_args->non_local);
+
+#else /* ! DARWIN HOST OS */
+ if (cmd_args->fuse_direct_io_mode_flag == _gf_true) {
+ ret = dict_set_static_ptr (top->options, ZR_DIRECT_IO_OPT,
+ "enable");
+ } else {
+ ret = dict_set_static_ptr (top->options, ZR_DIRECT_IO_OPT,
+ "disable");
+ }
+
+#endif /* GF_DARWIN_HOST_OS */
+
+ graph->parents = CALLOC (1, sizeof (xlator_list_t));
+ graph->parents->xlator = top;
+
+ return top;
+}
+
+
+static FILE *
+_get_specfp (glusterfs_ctx_t *ctx)
+{
+ int ret = 0;
+ cmd_args_t *cmd_args = NULL;
+ FILE *specfp = NULL;
+ struct stat statbuf;
+
+ cmd_args = &ctx->cmd_args;
+
+ if (cmd_args->volfile_server) {
+ 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,
+ "error while getting volume file from "
+ "server %s", cmd_args->volfile_server);
+ }
+ else {
+ gf_log ("glusterfs", GF_LOG_DEBUG,
+ "loading volume file from server %s",
+ cmd_args->volfile_server);
+ }
+
+ return specfp;
+ }
+
+ ret = stat (cmd_args->volume_file, &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");
+ 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,
+ "volume file %s: %s",
+ cmd_args->volume_file,
+ strerror (errno));
+ return NULL;
+ }
+
+ gf_log ("glusterfs", GF_LOG_DEBUG,
+ "loading volume file %s", cmd_args->volume_file);
+
+ return specfp;
+}
+
+static xlator_t *
+_parse_specfp (glusterfs_ctx_t *ctx,
+ FILE *specfp)
+{
+ 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;
+ }
+
+ /* 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_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->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)
+{
+ glusterfs_ctx_t *ctx = NULL;
+ cmd_args_t *cmd_args = NULL;
+ xlator_cmdline_option_t *option = NULL;
+ int ret = -1;
+ char *dot = NULL;
+ char *equals = NULL;
+
+ ctx = get_global_ctx_ptr ();
+ cmd_args = &ctx->cmd_args;
+
+ option = CALLOC (1, sizeof (xlator_cmdline_option_t));
+ INIT_LIST_HEAD (&option->cmd_args);
+
+ dot = strchr (arg, '.');
+ if (!dot)
+ goto out;
+
+ option->volume = CALLOC ((dot - arg), sizeof (char));
+ strncpy (option->volume, arg, (dot - arg));
+
+ equals = strchr (arg, '=');
+ if (!equals)
+ goto out;
+
+ option->key = CALLOC ((equals - dot), sizeof (char));
+ strncpy (option->key, dot + 1, (equals - dot - 1));
+
+ if (!*(equals + 1))
+ goto out;
+
+ option->value = strdup (equals + 1);
+
+ list_add (&option->cmd_args, &cmd_args->xlator_options);
+
+ ret = 0;
+out:
+ if (ret == -1) {
+ if (option) {
+ if (option->volume)
+ FREE (option->volume);
+ if (option->key)
+ FREE (option->key);
+ if (option->value)
+ FREE (option->value);
+
+ FREE (option);
+ }
+ }
+
+ return ret;
+}
+
+
+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
+parse_opts (int key, char *arg, struct argp_state *state)
+{
+ cmd_args_t *cmd_args = NULL;
+ uint32_t n = 0;
+
+ cmd_args = state->input;
+
+ switch (key) {
+ case ARGP_VOLFILE_SERVER_KEY:
+ cmd_args->volfile_server = strdup (arg);
+ break;
+
+ case ARGP_VOLUME_FILE_KEY:
+ cmd_args->volume_file = strdup (arg);
+ break;
+
+ case ARGP_LOG_LEVEL_KEY:
+ if (strcasecmp (arg, ARGP_LOG_LEVEL_NONE_OPTION) == 0) {
+ cmd_args->log_level = GF_LOG_NONE;
+ break;
+ }
+ if (strcasecmp (arg, ARGP_LOG_LEVEL_TRACE_OPTION) == 0) {
+ cmd_args->log_level = GF_LOG_TRACE;
+ break;
+ }
+ if (strcasecmp (arg, ARGP_LOG_LEVEL_CRITICAL_OPTION) == 0) {
+ cmd_args->log_level = GF_LOG_CRITICAL;
+ break;
+ }
+ if (strcasecmp (arg, ARGP_LOG_LEVEL_ERROR_OPTION) == 0) {
+ cmd_args->log_level = GF_LOG_ERROR;
+ break;
+ }
+ if (strcasecmp (arg, ARGP_LOG_LEVEL_WARNING_OPTION) == 0) {
+ cmd_args->log_level = GF_LOG_WARNING;
+ break;
+ }
+ if (strcasecmp (arg, ARGP_LOG_LEVEL_NORMAL_OPTION) == 0) {
+ cmd_args->log_level = GF_LOG_NORMAL;
+ break;
+ }
+ if (strcasecmp (arg, ARGP_LOG_LEVEL_DEBUG_OPTION) == 0) {
+ cmd_args->log_level = GF_LOG_DEBUG;
+ break;
+ }
+
+ argp_failure (state, -1, 0, "unknown log level %s", arg);
+ break;
+
+ case ARGP_LOG_FILE_KEY:
+ cmd_args->log_file = strdup (arg);
+ break;
+
+ case ARGP_VOLFILE_SERVER_PORT_KEY:
+ n = 0;
+
+ if (gf_string2uint_base10 (arg, &n) == 0) {
+ cmd_args->volfile_server_port = n;
+ break;
+ }
+
+ argp_failure (state, -1, 0,
+ "unknown volfile server port %s", arg);
+ break;
+
+ case ARGP_VOLFILE_SERVER_TRANSPORT_KEY:
+ cmd_args->volfile_server_transport = strdup (arg);
+ break;
+
+ case ARGP_VOLFILE_ID_KEY:
+ cmd_args->volfile_id = strdup (arg);
+ break;
+
+ case ARGP_PID_FILE_KEY:
+ cmd_args->pid_file = strdup (arg);
+ break;
+
+ case ARGP_NO_DAEMON_KEY:
+ cmd_args->no_daemon_mode = ENABLE_NO_DAEMON_MODE;
+ break;
+
+ case ARGP_RUN_ID_KEY:
+ cmd_args->run_id = strdup (arg);
+ break;
+
+ case ARGP_DEBUG_KEY:
+ cmd_args->debug_mode = ENABLE_DEBUG_MODE;
+ break;
+
+ case ARGP_DISABLE_DIRECT_IO_MODE_KEY:
+ cmd_args->fuse_direct_io_mode_flag = _gf_false;
+ break;
+
+ case ARGP_ENTRY_TIMEOUT_KEY:
+ n = 0;
+
+ if (gf_string2uint_base10 (arg, &n) == 0) {
+ cmd_args->fuse_entry_timeout = n;
+ break;
+ }
+
+ argp_failure (state, -1, 0, "unknown entry timeout %s", arg);
+ break;
+
+ case ARGP_ATTRIBUTE_TIMEOUT_KEY:
+ n = 0;
+
+ if (gf_string2uint_base10 (arg, &n) == 0) {
+ cmd_args->fuse_attribute_timeout = n;
+ break;
+ }
+
+ argp_failure (state, -1, 0,
+ "unknown attribute timeout %s", arg);
+ break;
+
+ case ARGP_VOLUME_NAME_KEY:
+ cmd_args->volume_name = strdup (arg);
+ break;
+
+ case ARGP_XLATOR_OPTION_KEY:
+ gf_remember_xlator_option (&cmd_args->xlator_options, arg);
+ break;
+
+#ifdef GF_DARWIN_HOST_OS
+ case ARGP_NON_LOCAL_KEY:
+ cmd_args->non_local = _gf_true;
+ break;
+
+#endif /* DARWIN */
+
+ case ARGP_KEY_NO_ARGS:
+ break;
+
+ case ARGP_KEY_ARG:
+ if (state->arg_num >= 1)
+ argp_usage (state);
+
+ cmd_args->mount_point = strdup (arg);
+ break;
+ }
+
+ return 0;
+}
+
+
+void
+cleanup_and_exit (int signum)
+{
+ glusterfs_ctx_t *ctx = NULL;
+ xlator_t *trav = NULL;
+
+ ctx = get_global_ctx_ptr ();
+
+ gf_log ("glusterfs", GF_LOG_WARNING, "shutting down");
+
+ if (ctx->pidfp) {
+ gf_unlockfd (fileno (ctx->pidfp));
+ fclose (ctx->pidfp);
+ ctx->pidfp = NULL;
+ }
+
+ if (ctx->specfp) {
+ fclose (ctx->specfp);
+ ctx->specfp = NULL;
+ }
+
+ 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 char *
+zr_build_process_uuid ()
+{
+ char tmp_str[1024] = {0,};
+ char hostname[256] = {0,};
+ struct timeval tv = {0,};
+ struct tm now = {0, };
+ char now_str[32];
+
+ if (-1 == gettimeofday(&tv, NULL)) {
+ gf_log ("", GF_LOG_ERROR,
+ "gettimeofday: failed %s",
+ strerror (errno));
+ }
+
+ if (-1 == gethostname (hostname, 256)) {
+ gf_log ("", 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 (tmp_str, 1024, "%s-%d-%s:%ld",
+ hostname, getpid(), now_str, tv.tv_usec);
+
+ return strdup (tmp_str);
+}
+
+#define GF_SERVER_PROCESS 0
+#define GF_CLIENT_PROCESS 1
+
+static uint8_t
+gf_get_process_mode (char *exec_name)
+{
+ char *dup_execname = NULL, *base = NULL;
+ uint8_t ret = 0;
+
+ dup_execname = strdup (exec_name);
+ base = basename (dup_execname);
+
+ if (!strncmp (base, "glusterfsd", 10)) {
+ ret = GF_SERVER_PROCESS;
+ } else {
+ ret = GF_CLIENT_PROCESS;
+ }
+
+ free (dup_execname);
+
+ return ret;
+}
+
+int
+main (int argc, char *argv[])
+{
+ 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 timestr[256] = { 0 };
+ char *base_exec_name = NULL;
+ 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;
+
+ utime = time (NULL);
+ ctx = CALLOC (1, sizeof (glusterfs_ctx_t));
+ ERR_ABORT (ctx);
+ base_exec_name = strdup (argv[0]);
+ process_mode = gf_get_process_mode (base_exec_name);
+ 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 = _gf_true;
+
+ INIT_LIST_HEAD (&cmd_args->xlator_options);
+
+ 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/stdout";
+ cmd_args->no_daemon_mode = ENABLE_NO_DAEMON_MODE;
+ }
+
+ if ((cmd_args->volfile_server == NULL)
+ && (cmd_args->volume_file == NULL)) {
+ if (process_mode == GF_SERVER_PROCESS)
+ cmd_args->volume_file = strdup (DEFAULT_SERVER_VOLUME_FILE);
+ else
+ cmd_args->volume_file = strdup (DEFAULT_CLIENT_VOLUME_FILE);
+ }
+
+ if (cmd_args->log_file == NULL)
+ asprintf (&cmd_args->log_file,
+ DEFAULT_LOG_FILE_DIRECTORY "/%s.log",
+ basename (base_exec_name));
+
+ free (base_exec_name);
+
+ ctx->event_pool = event_pool_new (DEFAULT_EVENT_POOL_SIZE);
+ pthread_mutex_init (&(ctx->lock), NULL);
+ pool = ctx->pool = CALLOC (1, sizeof (call_pool_t));
+ ERR_ABORT (ctx->pool);
+ LOCK_INIT (&pool->lock);
+ INIT_LIST_HEAD (&pool->all_frames);
+
+ if (cmd_args->pid_file != NULL) {
+ ctx->pidfp = fopen (cmd_args->pid_file, "a+");
+ if (ctx->pidfp == NULL) {
+ fprintf (stderr,
+ "unable to open pid file %s. %s. exiting\n",
+ cmd_args->pid_file, strerror (errno));
+ /* do cleanup and exit ?! */
+ return -1;
+ }
+ ret = gf_lockfd (fileno (ctx->pidfp));
+ if (ret == -1) {
+ fprintf (stderr, "unable to lock pid file %s. %s. "
+ "Is another instance of %s running?!\n"
+ "exiting\n", cmd_args->pid_file,
+ strerror (errno), argv[0]);
+ fclose (ctx->pidfp);
+ return -1;
+ }
+ ret = ftruncate (fileno (ctx->pidfp), 0);
+ if (ret == -1) {
+ fprintf (stderr,
+ "unable to truncate file %s. %s. exiting\n",
+ cmd_args->pid_file, strerror (errno));
+ gf_unlockfd (fileno (ctx->pidfp));
+ fclose (ctx->pidfp);
+ return -1;
+ }
+ }
+
+ /* initializing logs */
+ if (cmd_args->run_id) {
+ ret = stat (cmd_args->log_file, &stbuf);
+ /* If its /dev/null, or /dev/stdout, /dev/stderr,
+ * let it use the same, no need to alter
+ */
+ if (((ret == 0) &&
+ (S_ISREG (stbuf.st_mode) || S_ISLNK (stbuf.st_mode))) ||
+ (ret == -1)) {
+ /* Have seperate logfile per run */
+ tm = localtime (&utime);
+ strftime (timestr, 256, "%Y%m%d.%H%M%S", tm);
+ sprintf (tmp_logfile, "%s.%s.%d",
+ cmd_args->log_file, timestr, getpid ());
+
+ /* Create symlink to actual log file */
+ unlink (cmd_args->log_file);
+ symlink (tmp_logfile, cmd_args->log_file);
+
+ FREE (cmd_args->log_file);
+ cmd_args->log_file = strdup (tmp_logfile);
+ }
+ }
+
+ gf_global_variable_init ();
+
+ 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);
+
+ /* 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 HAVE_MALLOC_STATS
+#ifdef DEBUG
+ mtrace ();
+#endif
+ signal (SIGUSR1, (sighandler_t) malloc_stats);
+#endif
+ signal (SIGSEGV, gf_print_trace);
+ signal (SIGABRT, gf_print_trace);
+ signal (SIGPIPE, SIG_IGN);
+ signal (SIGHUP, gf_log_logrotate);
+ signal (SIGTERM, 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]);
+ return -1;
+ }
+ _gf_dump_details (argc, argv);
+ gf_log_volume_file (specfp);
+ 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;
+ }
+ 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;
+ }
+ }
+
+ xl_count++; /* Getting this value right is very important */
+ trav = trav->next;
+ }
+
+ ctx->xl_count = xl_count + 1;
+
+ if (!fuse_volume_found && (cmd_args->mount_point != NULL)) {
+ if ((graph = _add_fuse_mount (graph)) == NULL) {
+ /* _add_fuse_mount() prints necessary
+ * error message
+ */
+ fprintf (stderr, "exiting\n");
+ gf_log ("glusterfs", GF_LOG_ERROR, "exiting");
+ return -1;
+ }
+ }
+
+ /* daemonize now */
+ if (!cmd_args->no_daemon_mode) {
+ if (daemon (0, 0) == -1) {
+ fprintf (stderr, "unable to run in daemon mode: %s",
+ strerror (errno));
+ gf_log ("glusterfs", GF_LOG_ERROR,
+ "unable to run in daemon mode: %s",
+ strerror (errno));
+ return -1;
+ }
+
+ /* we are daemon now */
+ /* update pid file, if given */
+ if (cmd_args->pid_file != NULL) {
+ fprintf (ctx->pidfp, "%d\n", getpid ());
+ fflush (ctx->pidfp);
+ /* we close pid file on exit */
+ }
+ }
+
+ gf_log ("glusterfs", GF_LOG_DEBUG,
+ "running in pid %d", getpid ());
+
+ gf_timer_registry_init (ctx);
+
+ /* 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");
+ return -1;
+ }
+
+ /* Send PARENT_UP notify to all the translators now */
+ graph->notify (graph, GF_EVENT_PARENT_UP, ctx->graph);
+
+ gf_log ("glusterfs", GF_LOG_NORMAL, "Successfully started");
+
+ event_dispatch (ctx->event_pool);
+
+ return 0;
+}
diff --git a/glusterfsd/src/glusterfsd.h b/glusterfsd/src/glusterfsd.h
new file mode 100644
index 0000000..69ad6b0
--- /dev/null
+++ b/glusterfsd/src/glusterfsd.h
@@ -0,0 +1,78 @@
+/*
+ Copyright (c) 2006, 2007, 2008 Z RESEARCH, Inc. <http://www.zresearch.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 __GLUSTERFSD_H__
+#define __GLUSTERFSD_H__
+
+#ifndef _CONFIG_H
+#define _CONFIG_H
+#include "config.h"
+#endif
+
+#define DEFAULT_CLIENT_VOLUME_FILE CONFDIR "/glusterfs.vol"
+#define DEFAULT_SERVER_VOLUME_FILE CONFDIR "/glusterfsd.vol"
+#define DEFAULT_LOG_FILE_DIRECTORY DATADIR "/log/glusterfs"
+#define DEFAULT_LOG_LEVEL GF_LOG_NORMAL
+
+#define DEFAULT_EVENT_POOL_SIZE 16384
+
+#define ARGP_LOG_LEVEL_NONE_OPTION "NONE"
+#define ARGP_LOG_LEVEL_TRACE_OPTION "TRACE"
+#define ARGP_LOG_LEVEL_CRITICAL_OPTION "CRITICAL"
+#define ARGP_LOG_LEVEL_ERROR_OPTION "ERROR"
+#define ARGP_LOG_LEVEL_WARNING_OPTION "WARNING"
+#define ARGP_LOG_LEVEL_NORMAL_OPTION "NORMAL"
+#define ARGP_LOG_LEVEL_DEBUG_OPTION "DEBUG"
+
+#define ENABLE_NO_DAEMON_MODE 1
+#define ENABLE_DEBUG_MODE 1
+
+#define ZR_XLATOR_FUSE "mount/fuse"
+#define ZR_MOUNTPOINT_OPT "mountpoint"
+#define ZR_ATTR_TIMEOUT_OPT "attribute-timeout"
+#define ZR_ENTRY_TIMEOUT_OPT "entry-timeout"
+#define ZR_DIRECT_IO_OPT "direct-io-mode"
+
+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_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_VOLUME_NAME_KEY = 137,
+ ARGP_XLATOR_OPTION_KEY = 138,
+#ifdef GF_DARWIN_HOST_OS
+ ARGP_NON_LOCAL_KEY = 139,
+#endif /* DARWIN */
+ ARGP_VOLFILE_ID_KEY = 143,
+};
+
+/* Moved here from fetch-spec.h */
+FILE *fetch_spec (glusterfs_ctx_t *ctx);
+
+
+#endif /* __GLUSTERFSD_H__ */