summaryrefslogtreecommitdiffstats
path: root/glusterfsd/src/glusterfsd.c
diff options
context:
space:
mode:
Diffstat (limited to 'glusterfsd/src/glusterfsd.c')
-rw-r--r--glusterfsd/src/glusterfsd.c1541
1 files changed, 1137 insertions, 404 deletions
diff --git a/glusterfsd/src/glusterfsd.c b/glusterfsd/src/glusterfsd.c
index 01d155a2d..3cb8f0f51 100644
--- a/glusterfsd/src/glusterfsd.c
+++ b/glusterfsd/src/glusterfsd.c
@@ -1,22 +1,12 @@
/*
- 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
- 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/>.
-*/
+ Copyright (c) 2006-2013 Red Hat, Inc. <http://www.redhat.com>
+ This file is part of GlusterFS.
+ This file is licensed to you under your choice of the GNU Lesser
+ General Public License, version 3 or any later version (LGPLv3 or
+ later), or the GNU General Public License, version 2 (GPLv2), in all
+ cases as published by the Free Software Foundation.
+*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
@@ -25,6 +15,7 @@
#include <sys/types.h>
#include <sys/resource.h>
#include <sys/file.h>
+#include <sys/wait.h>
#include <netdb.h>
#include <signal.h>
#include <libgen.h>
@@ -38,6 +29,7 @@
#include <time.h>
#include <semaphore.h>
#include <errno.h>
+#include <pwd.h>
#ifndef _CONFIG_H
#define _CONFIG_H
@@ -71,28 +63,32 @@
#include "latency.h"
#include "glusterfsd-mem-types.h"
#include "syscall.h"
-
+#include "call-stub.h"
#include <fnmatch.h>
+#include "rpc-clnt.h"
+#include "syncop.h"
+#include "client_t.h"
-#ifdef GF_DARWIN_HOST_OS
#include "daemon.h"
-#else
-#define os_daemon(u, v) daemon (u, v)
-#endif
+/* process mode definitions */
+#define GF_SERVER_PROCESS 0
+#define GF_CLIENT_PROCESS 1
+#define GF_GLUSTERD_PROCESS 2
/* 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-2009 Gluster Inc. " \
- "<http://www.gluster.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_version = ""
+ PACKAGE_NAME" "PACKAGE_VERSION" built on "__DATE__" "__TIME__
+ "\nRepository revision: " GLUSTERFS_REPOSITORY_REVISION "\n"
+ "Copyright (c) 2006-2013 Red Hat, Inc. <http://www.redhat.com/>\n"
+ "GlusterFS comes with ABSOLUTELY NO WARRANTY.\n"
+ "It is licensed to you under your choice of the GNU Lesser\n"
+ "General Public License, version 3 or any later version (LGPLv3\n"
+ "or later), or the GNU General Public License, version 2 (GPLv2),\n"
+ "in all cases as published by the Free Software Foundation.";
const char *argp_program_bug_address = "<" PACKAGE_BUGREPORT ">";
static error_t parse_opts (int32_t key, char *arg, struct argp_state *_state);
@@ -102,23 +98,14 @@ static struct argp_option gf_options[] = {
{"volfile-server", ARGP_VOLFILE_SERVER_KEY, "SERVER", 0,
"Server to get the volume file from. This option overrides "
"--volfile option"},
- {"volfile-max-fetch-attempts", ARGP_VOLFILE_MAX_FETCH_ATTEMPTS,
- "MAX-ATTEMPTS", 0, "Maximum number of connect attempts to server. "
- "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_VOLFILE" or "
- DEFAULT_SERVER_VOLFILE"]"},
+ "File to use as VOLUME_FILE"},
{"spec-file", ARGP_VOLUME_FILE_KEY, "VOLFILE", OPTION_HIDDEN,
- "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"},
+ "File to use as VOLUME FILE"},
{"log-level", ARGP_LOG_LEVEL_KEY, "LOGLEVEL", 0,
- "Logging severity. Valid options are DEBUG, NORMAL, WARNING, ERROR, "
- "CRITICAL and NONE [default: NORMAL]"},
+ "Logging severity. Valid options are DEBUG, INFO, WARNING, ERROR, "
+ "CRITICAL, TRACE and NONE [default: INFO]"},
{"log-file", ARGP_LOG_FILE_KEY, "LOGFILE", 0,
"File to use for logging [default: "
DEFAULT_LOG_FILE_DIRECTORY "/" PACKAGE_NAME ".log" "]"},
@@ -131,10 +118,10 @@ static struct argp_option gf_options[] = {
"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"},
- {"log-server-port", ARGP_LOG_SERVER_PORT_KEY, "PORT", 0,
- "Listening port number of log server"},
{"pid-file", ARGP_PID_FILE_KEY, "PIDFILE", 0,
"File to use as pid file"},
+ {"socket-file", ARGP_SOCK_FILE_KEY, "SOCKFILE", 0,
+ "File to use as unix-socket"},
{"no-daemon", ARGP_NO_DAEMON_KEY, 0, 0,
"Run in foreground"},
{"run-id", ARGP_RUN_ID_KEY, "RUN-ID", OPTION_HIDDEN,
@@ -143,31 +130,78 @@ static struct argp_option gf_options[] = {
{"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"},
+ {"volume-name", ARGP_VOLUME_NAME_KEY, "XLATOR-NAME", 0,
+ "Translator name to be used for MOUNT-POINT [default: top most volume "
+ "definition in VOLFILE]"},
+ {"xlator-option", ARGP_XLATOR_OPTION_KEY,"XLATOR-NAME.OPTION=VALUE", 0,
+ "Add/override an option for a translator in volume file with specified"
+ " value"},
{"read-only", ARGP_READ_ONLY_KEY, 0, 0,
"Mount the filesystem in 'read-only' mode"},
- {"mac-compat", ARGP_MAC_COMPAT_KEY, 0, 0,
- "Provide stubs for attributes needed for seamless operation on Macs"},
+ {"acl", ARGP_ACL_KEY, 0, 0,
+ "Mount the filesystem with POSIX ACL support"},
+ {"selinux", ARGP_SELINUX_KEY, 0, 0,
+ "Enable SELinux label (extened attributes) support on inodes"},
+#ifdef GF_LINUX_HOST_OS
+ {"aux-gfid-mount", ARGP_AUX_GFID_MOUNT_KEY, 0, 0,
+ "Enable access to filesystem through gfid directly"},
+#endif
+ {"enable-ino32", ARGP_INODE32_KEY, "BOOL", OPTION_ARG_OPTIONAL,
+ "Use 32-bit inodes when mounting to workaround broken applications"
+ "that don't support 64-bit inodes"},
+ {"worm", ARGP_WORM_KEY, 0, 0,
+ "Mount the filesystem in 'worm' mode"},
+ {"mac-compat", ARGP_MAC_COMPAT_KEY, "BOOL", OPTION_ARG_OPTIONAL,
+ "Provide stubs for attributes needed for seamless operation on Macs "
+#ifdef GF_DARWIN_HOST_OS
+ "[default: \"on\" on client side, else \"off\"]"
+#else
+ "[default: \"off\"]"
+#endif
+ },
+ {"brick-name", ARGP_BRICK_NAME_KEY, "BRICK-NAME", OPTION_HIDDEN,
+ "Brick name to be registered with Gluster portmapper" },
+ {"brick-port", ARGP_BRICK_PORT_KEY, "BRICK-PORT", OPTION_HIDDEN,
+ "Brick Port to be registered with Gluster portmapper" },
+ {"fopen-keep-cache", ARGP_FOPEN_KEEP_CACHE_KEY, "BOOL", OPTION_ARG_OPTIONAL,
+ "Do not purge the cache on file open"},
{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"
- " [default if big writes are supported]"},
- {"enable-direct-io-mode", ARGP_ENABLE_DIRECT_IO_MODE_KEY, 0, 0,
- "Force direct I/O mode in fuse kernel module"},
+ {"direct-io-mode", ARGP_DIRECT_IO_MODE_KEY, "BOOL", OPTION_ARG_OPTIONAL,
+ "Use direct I/O mode in fuse kernel module"
+ " [default: \"off\" if big writes are supported, else "
+ "\"on\" for fds not opened with O_RDONLY]"},
{"entry-timeout", ARGP_ENTRY_TIMEOUT_KEY, "SECONDS", 0,
"Set entry timeout to SECONDS in fuse kernel module [default: 1]"},
+ {"negative-timeout", ARGP_NEGATIVE_TIMEOUT_KEY, "SECONDS", 0,
+ "Set negative timeout to SECONDS in fuse kernel module [default: 0]"},
{"attribute-timeout", ARGP_ATTRIBUTE_TIMEOUT_KEY, "SECONDS", 0,
"Set attribute timeout to SECONDS for inodes in fuse kernel module "
"[default: 1]"},
+ {"gid-timeout", ARGP_GID_TIMEOUT_KEY, "SECONDS", 0,
+ "Set auxilary group list timeout to SECONDS for fuse translator "
+ "[default: 0]"},
+ {"background-qlen", ARGP_FUSE_BACKGROUND_QLEN_KEY, "N", 0,
+ "Set fuse module's background queue length to N "
+ "[default: 64]"},
+ {"congestion-threshold", ARGP_FUSE_CONGESTION_THRESHOLD_KEY, "N", 0,
+ "Set fuse module's congestion threshold to N "
+ "[default: 48]"},
+ {"client-pid", ARGP_CLIENT_PID_KEY, "PID", OPTION_HIDDEN,
+ "client will authenticate itself with process id PID to server"},
+ {"user-map-root", ARGP_USER_MAP_ROOT_KEY, "USER", OPTION_HIDDEN,
+ "replace USER with root in messages"},
{"dump-fuse", ARGP_DUMP_FUSE_KEY, "PATH", 0,
"Dump fuse traffic to PATH"},
{"volfile-check", ARGP_VOLFILE_CHECK_KEY, 0, 0,
"Enable strict volume file checking"},
+ {"mem-accounting", ARGP_MEM_ACCOUNTING_KEY, 0, OPTION_HIDDEN,
+ "Enable internal memory accounting"},
+ {"fuse-mountopts", ARGP_FUSE_MOUNTOPTS_KEY, "OPTIONS", OPTION_HIDDEN,
+ "Extra mount options to pass to FUSE"},
+ {"use-readdirp", ARGP_FUSE_USE_READDIRP_KEY, "BOOL", OPTION_ARG_OPTIONAL,
+ "Use readdirp mode in fuse kernel module"
+ " [default: \"off\"]"},
{0, 0, 0, 0, "Miscellaneous Options:"},
{0, }
};
@@ -177,6 +211,282 @@ static struct argp argp = { gf_options, parse_opts, argp_doc, gf_doc };
int glusterfs_pidfile_cleanup (glusterfs_ctx_t *ctx);
int glusterfs_volumes_init (glusterfs_ctx_t *ctx);
+int glusterfs_mgmt_init (glusterfs_ctx_t *ctx);
+int glusterfs_listener_init (glusterfs_ctx_t *ctx);
+int glusterfs_listener_stop (glusterfs_ctx_t *ctx);
+
+
+static int
+set_fuse_mount_options (glusterfs_ctx_t *ctx, dict_t *options)
+{
+ int ret = 0;
+ cmd_args_t *cmd_args = NULL;
+ char *mount_point = NULL;
+ char cwd[PATH_MAX] = {0,};
+
+ cmd_args = &ctx->cmd_args;
+
+ /* Check if mount-point is absolute path,
+ * if not convert to absolute path by concating with CWD
+ */
+ if (cmd_args->mount_point[0] != '/') {
+ if (getcwd (cwd, PATH_MAX) != NULL) {
+ ret = gf_asprintf (&mount_point, "%s/%s", cwd,
+ cmd_args->mount_point);
+ if (ret == -1) {
+ gf_log ("glusterfsd", GF_LOG_ERROR,
+ "Could not create absolute mountpoint "
+ "path");
+ goto err;
+ }
+ } else {
+ gf_log ("glusterfsd", GF_LOG_ERROR,
+ "Could not get current working directory");
+ goto err;
+ }
+ } else
+ mount_point = gf_strdup (cmd_args->mount_point);
+
+ ret = dict_set_dynstr (options, ZR_MOUNTPOINT_OPT, mount_point);
+ if (ret < 0) {
+ 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 (options, ZR_ATTR_TIMEOUT_OPT,
+ cmd_args->fuse_attribute_timeout);
+
+ if (ret < 0) {
+ gf_log ("glusterfsd", GF_LOG_ERROR,
+ "failed to set dict value for key %s",
+ ZR_ATTR_TIMEOUT_OPT);
+ goto err;
+ }
+ }
+
+ if (cmd_args->fuse_entry_timeout >= 0) {
+ ret = dict_set_double (options, ZR_ENTRY_TIMEOUT_OPT,
+ cmd_args->fuse_entry_timeout);
+ if (ret < 0) {
+ gf_log ("glusterfsd", GF_LOG_ERROR,
+ "failed to set dict value for key %s",
+ ZR_ENTRY_TIMEOUT_OPT);
+ goto err;
+ }
+ }
+
+ if (cmd_args->fuse_negative_timeout >= 0) {
+ ret = dict_set_double (options, ZR_NEGATIVE_TIMEOUT_OPT,
+ cmd_args->fuse_negative_timeout);
+ if (ret < 0) {
+ gf_log ("glusterfsd", GF_LOG_ERROR,
+ "failed to set dict value for key %s",
+ ZR_NEGATIVE_TIMEOUT_OPT);
+ goto err;
+ }
+ }
+
+ if (cmd_args->client_pid_set) {
+ ret = dict_set_int32 (options, "client-pid",
+ cmd_args->client_pid);
+ if (ret < 0) {
+ gf_log ("glusterfsd", GF_LOG_ERROR,
+ "failed to set dict value for key %s",
+ "client-pid");
+ goto err;
+ }
+ }
+
+ if (cmd_args->uid_map_root) {
+ ret = dict_set_int32 (options, "uid-map-root",
+ cmd_args->uid_map_root);
+ if (ret < 0) {
+ gf_log ("glusterfsd", GF_LOG_ERROR,
+ "failed to set dict value for key %s",
+ "uid-map-root");
+ goto err;
+ }
+ }
+
+ if (cmd_args->volfile_check) {
+ ret = dict_set_int32 (options, ZR_STRICT_VOLFILE_CHECK,
+ cmd_args->volfile_check);
+ if (ret < 0) {
+ gf_log ("glusterfsd", GF_LOG_ERROR,
+ "failed to set dict value for key %s",
+ ZR_STRICT_VOLFILE_CHECK);
+ goto err;
+ }
+ }
+
+ if (cmd_args->dump_fuse) {
+ ret = dict_set_static_ptr (options, ZR_DUMP_FUSE,
+ cmd_args->dump_fuse);
+ if (ret < 0) {
+ gf_log ("glusterfsd", GF_LOG_ERROR,
+ "failed to set dict value for key %s",
+ ZR_DUMP_FUSE);
+ goto err;
+ }
+ }
+
+ if (cmd_args->acl) {
+ ret = dict_set_static_ptr (options, "acl", "on");
+ if (ret < 0) {
+ gf_log ("glusterfsd", GF_LOG_ERROR,
+ "failed to set dict value for key acl");
+ goto err;
+ }
+ }
+
+ if (cmd_args->selinux) {
+ ret = dict_set_static_ptr (options, "selinux", "on");
+ if (ret < 0) {
+ gf_log ("glusterfsd", GF_LOG_ERROR,
+ "failed to set dict value for key selinux");
+ goto err;
+ }
+ }
+
+ if (cmd_args->aux_gfid_mount) {
+ ret = dict_set_static_ptr (options, "virtual-gfid-access",
+ "on");
+ if (ret < 0) {
+ gf_log ("glusterfsd", GF_LOG_ERROR,
+ "failed to set dict value for key "
+ "aux-gfid-mount");
+ goto err;
+ }
+ }
+
+ if (cmd_args->enable_ino32) {
+ ret = dict_set_static_ptr (options, "enable-ino32", "on");
+ if (ret < 0) {
+ gf_log ("glusterfsd", GF_LOG_ERROR,
+ "failed to set dict value for key enable-ino32");
+ goto err;
+ }
+ }
+
+ if (cmd_args->read_only) {
+ ret = dict_set_static_ptr (options, "read-only", "on");
+ if (ret < 0) {
+ gf_log ("glusterfsd", GF_LOG_ERROR,
+ "failed to set dict value for key read-only");
+ goto err;
+ }
+ }
+
+ switch (cmd_args->fopen_keep_cache) {
+ case GF_OPTION_ENABLE:
+ ret = dict_set_static_ptr(options, "fopen-keep-cache",
+ "on");
+ if (ret < 0) {
+ gf_log("glusterfsd", GF_LOG_ERROR,
+ "failed to set dict value for key "
+ "fopen-keep-cache");
+ goto err;
+ }
+ break;
+ case GF_OPTION_DISABLE:
+ ret = dict_set_static_ptr(options, "fopen-keep-cache",
+ "off");
+ if (ret < 0) {
+ gf_log("glusterfsd", GF_LOG_ERROR,
+ "failed to set dict value for key "
+ "fopen-keep-cache");
+ goto err;
+ }
+ break;
+ case GF_OPTION_DEFERRED: /* default */
+ default:
+ gf_log ("glusterfsd", GF_LOG_DEBUG,
+ "fopen-keep-cache mode %d",
+ cmd_args->fopen_keep_cache);
+ break;
+ }
+
+ if (cmd_args->gid_timeout) {
+ ret = dict_set_int32(options, "gid-timeout",
+ cmd_args->gid_timeout);
+ if (ret < 0) {
+ gf_log("glusterfsd", GF_LOG_ERROR, "failed to set dict "
+ "value for key gid-timeout");
+ goto err;
+ }
+ }
+ if (cmd_args->background_qlen) {
+ ret = dict_set_int32 (options, "background-qlen",
+ cmd_args->background_qlen);
+ if (ret < 0) {
+ gf_log("glusterfsd", GF_LOG_ERROR, "failed to set dict "
+ "value for key background-qlen");
+ goto err;
+ }
+ }
+ if (cmd_args->congestion_threshold) {
+ ret = dict_set_int32 (options, "congestion-threshold",
+ cmd_args->congestion_threshold);
+ if (ret < 0) {
+ gf_log("glusterfsd", GF_LOG_ERROR, "failed to set dict "
+ "value for key congestion-threshold");
+ goto err;
+ }
+ }
+
+ switch (cmd_args->fuse_direct_io_mode) {
+ case GF_OPTION_DISABLE: /* disable */
+ ret = dict_set_static_ptr (options, ZR_DIRECT_IO_OPT,
+ "disable");
+ if (ret < 0) {
+ gf_log ("glusterfsd", GF_LOG_ERROR,
+ "failed to set 'disable' for key %s",
+ ZR_DIRECT_IO_OPT);
+ goto err;
+ }
+ break;
+ case GF_OPTION_ENABLE: /* enable */
+ ret = dict_set_static_ptr (options, ZR_DIRECT_IO_OPT,
+ "enable");
+ if (ret < 0) {
+ gf_log ("glusterfsd", GF_LOG_ERROR,
+ "failed to set 'enable' for key %s",
+ ZR_DIRECT_IO_OPT);
+ goto err;
+ }
+ break;
+ case GF_OPTION_DEFERRED: /* default */
+ default:
+ gf_log ("", GF_LOG_DEBUG, "fuse direct io type %d",
+ cmd_args->fuse_direct_io_mode);
+ break;
+ }
+
+ if (!cmd_args->no_daemon_mode) {
+ ret = dict_set_static_ptr (options, "sync-to-mount",
+ "enable");
+ if (ret < 0) {
+ gf_log ("glusterfsd", GF_LOG_ERROR,
+ "failed to set dict value for key sync-mtab");
+ goto err;
+ }
+ }
+
+ if (cmd_args->use_readdirp) {
+ ret = dict_set_str (options, "use-readdirp",
+ cmd_args->use_readdirp);
+ if (ret < 0) {
+ gf_log ("glusterfsd", GF_LOG_ERROR, "failed to set dict"
+ " value for key use-readdirp");
+ goto err;
+ }
+ }
+ ret = 0;
+err:
+ return ret;
+}
int
create_fuse_mount (glusterfs_ctx_t *ctx)
@@ -187,8 +497,17 @@ create_fuse_mount (glusterfs_ctx_t *ctx)
cmd_args = &ctx->cmd_args;
- if (!cmd_args->mount_point)
+ if (!cmd_args->mount_point) {
+ gf_log ("", GF_LOG_TRACE,
+ "mount point not found, not a client process");
return 0;
+ }
+
+ if (ctx->process_mode != GF_CLIENT_PROCESS) {
+ gf_log("glusterfsd", GF_LOG_ERROR,
+ "Not a client process, not performing mount operation");
+ return -1;
+ }
master = GF_CALLOC (1, sizeof (*master),
gfd_mt_xlator_t);
@@ -199,7 +518,7 @@ create_fuse_mount (glusterfs_ctx_t *ctx)
if (!master->name)
goto err;
- if (xlator_set_type (master, ZR_XLATOR_FUSE) == -1) {
+ if (xlator_set_type (master, "mount/fuse") == -1) {
gf_log ("glusterfsd", GF_LOG_ERROR,
"MOUNT-POINT %s initialization failed",
cmd_args->mount_point);
@@ -208,62 +527,29 @@ create_fuse_mount (glusterfs_ctx_t *ctx)
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 ("glusterfsd", GF_LOG_ERROR,
- "failed to set mount-point to options dictionary");
+ if (!master->options)
goto err;
- }
-
- if (cmd_args->fuse_attribute_timeout >= 0)
- 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 (master->options, ZR_ENTRY_TIMEOUT_OPT,
- cmd_args->fuse_entry_timeout);
- if (cmd_args->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 (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 ("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");
+ ret = set_fuse_mount_options (ctx, master->options);
+ if (ret)
+ goto err;
-#else /* ! DARWIN HOST OS */
- switch (cmd_args->fuse_direct_io_mode_flag) {
- case 0: /* disable */
- ret = dict_set_static_ptr (master->options, ZR_DIRECT_IO_OPT,
- "disable");
- break;
- case 1: /* enable */
- ret = dict_set_static_ptr (master->options, ZR_DIRECT_IO_OPT,
- "enable");
- break;
- case 2: /* default */
- default:
- break;
+ if (cmd_args->fuse_mountopts) {
+ ret = dict_set_static_ptr (master->options, ZR_FUSE_MOUNTOPTS,
+ cmd_args->fuse_mountopts);
+ if (ret < 0) {
+ gf_log ("glusterfsd", GF_LOG_ERROR,
+ "failed to set dict value for key %s",
+ ZR_FUSE_MOUNTOPTS);
+ goto err;
+ }
}
-#endif /* GF_DARWIN_HOST_OS */
-
ret = xlator_init (master);
- if (ret)
+ if (ret) {
+ gf_log ("", GF_LOG_DEBUG, "failed to initialize fuse translator");
goto err;
+ }
ctx->master = master;
@@ -274,7 +560,7 @@ err:
xlator_destroy (master);
}
- return -1;
+ return 1;
}
@@ -288,23 +574,6 @@ get_volfp (glusterfs_ctx_t *ctx)
cmd_args = &ctx->cmd_args;
- if (cmd_args->volfile_server) {
-// specfp = fetch_spec (ctx);
-
- if (specfp == NULL) {
- gf_log ("glusterfsd", GF_LOG_ERROR,
- "error while getting volume file from "
- "server %s", cmd_args->volfile_server);
- }
- else {
- gf_log ("glusterfsd", GF_LOG_DEBUG,
- "loading volume file from server %s",
- cmd_args->volfile_server);
- }
-
- return specfp;
- }
-
ret = sys_lstat (cmd_args->volfile, &statbuf);
if (ret == -1) {
gf_log ("glusterfsd", GF_LOG_ERROR,
@@ -326,9 +595,59 @@ get_volfp (glusterfs_ctx_t *ctx)
return specfp;
}
+static int
+gf_remember_backup_volfile_server (char *arg)
+{
+ glusterfs_ctx_t *ctx = NULL;
+ cmd_args_t *cmd_args = NULL;
+ int ret = -1;
+ server_cmdline_t *server = NULL;
+
+ ctx = glusterfsd_ctx;
+ if (!ctx)
+ goto out;
+ cmd_args = &ctx->cmd_args;
+
+ if(!cmd_args)
+ goto out;
+
+ server = GF_CALLOC (1, sizeof (server_cmdline_t),
+ gfd_mt_server_cmdline_t);
+ if (!server)
+ goto out;
+
+ INIT_LIST_HEAD(&server->list);
+
+ server->volfile_server = gf_strdup(arg);
+
+ if (!cmd_args->volfile_server) {
+ cmd_args->volfile_server = server->volfile_server;
+ cmd_args->curr_server = server;
+ }
+
+ if (!server->volfile_server) {
+ gf_log ("", GF_LOG_WARNING,
+ "xlator option %s is invalid", arg);
+ goto out;
+ }
+
+ list_add_tail (&server->list, &cmd_args->volfile_servers);
+
+ ret = 0;
+out:
+ if (ret == -1) {
+ if (server) {
+ GF_FREE (server->volfile_server);
+ GF_FREE (server);
+ }
+ }
+
+ return ret;
+
+}
static int
-gf_remember_xlator_option (struct list_head *options, char *arg)
+gf_remember_xlator_option (char *arg)
{
glusterfs_ctx_t *ctx = NULL;
cmd_args_t *cmd_args = NULL;
@@ -337,31 +656,49 @@ gf_remember_xlator_option (struct list_head *options, char *arg)
char *dot = NULL;
char *equals = NULL;
- ctx = glusterfs_ctx_get ();
+ ctx = glusterfsd_ctx;
cmd_args = &ctx->cmd_args;
option = GF_CALLOC (1, sizeof (xlator_cmdline_option_t),
gfd_mt_xlator_cmdline_option_t);
+ if (!option)
+ goto out;
+
INIT_LIST_HEAD (&option->cmd_args);
dot = strchr (arg, '.');
- if (!dot)
+ if (!dot) {
+ gf_log ("", GF_LOG_WARNING,
+ "xlator option %s is invalid", arg);
goto out;
+ }
- option->volume = GF_CALLOC ((dot - arg), sizeof (char),
+ option->volume = GF_CALLOC ((dot - arg) + 1, sizeof (char),
gfd_mt_char);
+ if (!option->volume)
+ goto out;
+
strncpy (option->volume, arg, (dot - arg));
equals = strchr (arg, '=');
- if (!equals)
+ if (!equals) {
+ gf_log ("", GF_LOG_WARNING,
+ "xlator option %s is invalid", arg);
goto out;
+ }
- option->key = GF_CALLOC ((equals - dot), sizeof (char),
+ option->key = GF_CALLOC ((equals - dot) + 1, sizeof (char),
gfd_mt_char);
+ if (!option->key)
+ goto out;
+
strncpy (option->key, dot + 1, (equals - dot - 1));
- if (!*(equals + 1))
+ if (!*(equals + 1)) {
+ gf_log ("", GF_LOG_WARNING,
+ "xlator option %s is invalid", arg);
goto out;
+ }
option->value = gf_strdup (equals + 1);
@@ -371,12 +708,9 @@ gf_remember_xlator_option (struct list_head *options, char *arg)
out:
if (ret == -1) {
if (option) {
- if (option->volume)
- GF_FREE (option->volume);
- if (option->key)
- GF_FREE (option->key);
- if (option->value)
- GF_FREE (option->value);
+ GF_FREE (option->volume);
+ GF_FREE (option->key);
+ GF_FREE (option->value);
GF_FREE (option);
}
@@ -390,49 +724,82 @@ out:
static error_t
parse_opts (int key, char *arg, struct argp_state *state)
{
- cmd_args_t *cmd_args = NULL;
- uint32_t n = 0;
- double d = 0.0;
+ cmd_args_t *cmd_args = NULL;
+ uint32_t n = 0;
+ double d = 0.0;
+ gf_boolean_t b = _gf_false;
+ char *pwd = NULL;
+ char tmp_buf[2048] = {0,};
+ char *tmp_str = NULL;
+ char *port_str = NULL;
+ struct passwd *pw = NULL;
cmd_args = state->input;
switch (key) {
case ARGP_VOLFILE_SERVER_KEY:
- cmd_args->volfile_server = gf_strdup (arg);
+ gf_remember_backup_volfile_server (arg);
+
break;
- case ARGP_VOLFILE_MAX_FETCH_ATTEMPTS:
- n = 0;
+ case ARGP_READ_ONLY_KEY:
+ cmd_args->read_only = 1;
+ break;
- if (gf_string2uint_base10 (arg, &n) == 0) {
- cmd_args->max_connect_attempts = n;
- break;
- }
+ case ARGP_ACL_KEY:
+ cmd_args->acl = 1;
+ gf_remember_xlator_option ("*-md-cache.cache-posix-acl=true");
+ break;
- argp_failure (state, -1, 0,
- "Invalid limit on connect attempts %s", arg);
+ case ARGP_SELINUX_KEY:
+ cmd_args->selinux = 1;
+ gf_remember_xlator_option ("*-md-cache.cache-selinux=true");
break;
- case ARGP_READ_ONLY_KEY:
- cmd_args->read_only = 1;
+ case ARGP_AUX_GFID_MOUNT_KEY:
+ cmd_args->aux_gfid_mount = 1;
break;
- case ARGP_MAC_COMPAT_KEY:
- cmd_args->mac_compat = 1;
+ case ARGP_INODE32_KEY:
+ cmd_args->enable_ino32 = 1;
break;
- case ARGP_VOLUME_FILE_KEY:
- if (cmd_args->volfile)
- GF_FREE (cmd_args->volfile);
+ case ARGP_WORM_KEY:
+ cmd_args->worm = 1;
+ break;
+
+ case ARGP_MAC_COMPAT_KEY:
+ if (!arg)
+ arg = "on";
- cmd_args->volfile = gf_strdup (arg);
+ if (gf_string2boolean (arg, &b) == 0) {
+ cmd_args->mac_compat = b;
+
+ break;
+ }
+
+ argp_failure (state, -1, 0,
+ "invalid value \"%s\" for mac-compat", arg);
break;
- case ARGP_LOG_SERVER_KEY:
- if (cmd_args->log_server)
- GF_FREE (cmd_args->log_server);
+ case ARGP_VOLUME_FILE_KEY:
+ GF_FREE (cmd_args->volfile);
+
+ if (arg[0] != '/') {
+ pwd = getcwd (NULL, PATH_MAX);
+ if (!pwd) {
+ argp_failure (state, -1, errno,
+ "getcwd failed with error no %d",
+ errno);
+ break;
+ }
+ snprintf (tmp_buf, 1024, "%s/%s", pwd, arg);
+ cmd_args->volfile = gf_strdup (tmp_buf);
+ free (pwd);
+ } else {
+ cmd_args->volfile = gf_strdup (arg);
+ }
- cmd_args->log_server = gf_strdup (arg);
break;
case ARGP_LOG_LEVEL_KEY:
@@ -452,8 +819,8 @@ parse_opts (int key, char *arg, struct argp_state *state)
cmd_args->log_level = GF_LOG_WARNING;
break;
}
- if (strcasecmp (arg, ARGP_LOG_LEVEL_NORMAL_OPTION) == 0) {
- cmd_args->log_level = GF_LOG_NORMAL;
+ if (strcasecmp (arg, ARGP_LOG_LEVEL_INFO_OPTION) == 0) {
+ cmd_args->log_level = GF_LOG_INFO;
break;
}
if (strcasecmp (arg, ARGP_LOG_LEVEL_DEBUG_OPTION) == 0) {
@@ -484,18 +851,6 @@ parse_opts (int key, char *arg, struct argp_state *state)
"unknown volfile server port %s", arg);
break;
- case ARGP_LOG_SERVER_PORT_KEY:
- n = 0;
-
- if (gf_string2uint_base10 (arg, &n) == 0) {
- cmd_args->log_server_port = n;
- break;
- }
-
- argp_failure (state, -1, 0,
- "unknown log server port %s", arg);
- break;
-
case ARGP_VOLFILE_SERVER_TRANSPORT_KEY:
cmd_args->volfile_server_transport = gf_strdup (arg);
break;
@@ -508,6 +863,10 @@ parse_opts (int key, char *arg, struct argp_state *state)
cmd_args->pid_file = gf_strdup (arg);
break;
+ case ARGP_SOCK_FILE_KEY:
+ cmd_args->sock_file = gf_strdup (arg);
+ break;
+
case ARGP_NO_DAEMON_KEY:
cmd_args->no_daemon_mode = ENABLE_NO_DAEMON_MODE;
break;
@@ -520,12 +879,18 @@ parse_opts (int key, char *arg, struct argp_state *state)
cmd_args->debug_mode = ENABLE_DEBUG_MODE;
break;
- case ARGP_DISABLE_DIRECT_IO_MODE_KEY:
- cmd_args->fuse_direct_io_mode_flag = 0;
- break;
+ case ARGP_DIRECT_IO_MODE_KEY:
+ if (!arg)
+ arg = "on";
+
+ if (gf_string2boolean (arg, &b) == 0) {
+ cmd_args->fuse_direct_io_mode = b;
+
+ break;
+ }
- case ARGP_ENABLE_DIRECT_IO_MODE_KEY:
- cmd_args->fuse_direct_io_mode_flag = 1;
+ argp_failure (state, -1, 0,
+ "unknown direct I/O mode setting \"%s\"", arg);
break;
case ARGP_ENTRY_TIMEOUT_KEY:
@@ -540,6 +905,18 @@ parse_opts (int key, char *arg, struct argp_state *state)
argp_failure (state, -1, 0, "unknown entry timeout %s", arg);
break;
+ case ARGP_NEGATIVE_TIMEOUT_KEY:
+ d = 0.0;
+
+ gf_string2double (arg, &d);
+ if (!(d < 0.0)) {
+ cmd_args->fuse_negative_timeout = d;
+ break;
+ }
+
+ argp_failure (state, -1, 0, "unknown negative timeout %s", arg);
+ break;
+
case ARGP_ATTRIBUTE_TIMEOUT_KEY:
d = 0.0;
@@ -553,6 +930,25 @@ parse_opts (int key, char *arg, struct argp_state *state)
"unknown attribute timeout %s", arg);
break;
+ case ARGP_CLIENT_PID_KEY:
+ if (gf_string2int (arg, &cmd_args->client_pid) == 0) {
+ cmd_args->client_pid_set = 1;
+ break;
+ }
+
+ argp_failure (state, -1, 0,
+ "unknown client pid %s", arg);
+ break;
+
+ case ARGP_USER_MAP_ROOT_KEY:
+ pw = getpwnam (arg);
+ if (pw)
+ cmd_args->uid_map_root = pw->pw_uid;
+ else
+ argp_failure (state, -1, 0,
+ "user %s does not exist", arg);
+ break;
+
case ARGP_VOLFILE_CHECK_KEY:
cmd_args->volfile_check = 1;
break;
@@ -562,7 +958,10 @@ parse_opts (int key, char *arg, struct argp_state *state)
break;
case ARGP_XLATOR_OPTION_KEY:
- gf_remember_xlator_option (&cmd_args->xlator_options, arg);
+ if (gf_remember_xlator_option (arg))
+ argp_failure (state, -1, 0, "invalid xlator option %s",
+ arg);
+
break;
case ARGP_KEY_NO_ARGS:
@@ -578,24 +977,163 @@ parse_opts (int key, char *arg, struct argp_state *state)
case ARGP_DUMP_FUSE_KEY:
cmd_args->dump_fuse = gf_strdup (arg);
break;
- }
+ case ARGP_BRICK_NAME_KEY:
+ cmd_args->brick_name = gf_strdup (arg);
+ break;
+ case ARGP_BRICK_PORT_KEY:
+ n = 0;
+
+ port_str = strtok_r (arg, ",", &tmp_str);
+ if (gf_string2uint_base10 (port_str, &n) == 0) {
+ cmd_args->brick_port = n;
+ port_str = strtok_r (NULL, ",", &tmp_str);
+ if (port_str) {
+ if (gf_string2uint_base10 (port_str, &n) == 0)
+ cmd_args->brick_port2 = n;
+ break;
+
+ argp_failure (state, -1, 0,
+ "wrong brick (listen) port %s", arg);
+ }
+ break;
+ }
+
+ argp_failure (state, -1, 0,
+ "unknown brick (listen) port %s", arg);
+ break;
+
+ case ARGP_MEM_ACCOUNTING_KEY:
+ /* TODO: it should have got handled much earlier */
+ //gf_mem_acct_enable_set (THIS->ctx);
+ break;
+
+ case ARGP_FOPEN_KEEP_CACHE_KEY:
+ if (!arg)
+ arg = "on";
+
+ if (gf_string2boolean (arg, &b) == 0) {
+ cmd_args->fopen_keep_cache = b;
+
+ break;
+ }
+
+ argp_failure (state, -1, 0,
+ "unknown cache setting \"%s\"", arg);
+
+ break;
+
+ case ARGP_GID_TIMEOUT_KEY:
+ if (!gf_string2int(arg, &cmd_args->gid_timeout))
+ break;
+
+ argp_failure(state, -1, 0, "unknown group list timeout %s", arg);
+ break;
+ case ARGP_FUSE_BACKGROUND_QLEN_KEY:
+ if (!gf_string2int (arg, &cmd_args->background_qlen))
+ break;
+
+ argp_failure (state, -1, 0,
+ "unknown background qlen option %s", arg);
+ break;
+ case ARGP_FUSE_CONGESTION_THRESHOLD_KEY:
+ if (!gf_string2int (arg, &cmd_args->congestion_threshold))
+ break;
+
+ argp_failure (state, -1, 0,
+ "unknown congestion threshold option %s", arg);
+ break;
+
+ case ARGP_FUSE_MOUNTOPTS_KEY:
+ cmd_args->fuse_mountopts = gf_strdup (arg);
+ break;
+
+ case ARGP_FUSE_USE_READDIRP_KEY:
+ if (!arg)
+ arg = "yes";
+
+ if (gf_string2boolean (arg, &b) == 0) {
+ if (b) {
+ cmd_args->use_readdirp = "yes";
+ } else {
+ cmd_args->use_readdirp = "no";
+ }
+
+ break;
+ }
+
+ argp_failure (state, -1, 0,
+ "unknown use-readdirp setting \"%s\"", arg);
+ break;
+
+ }
return 0;
}
-static void
+void
cleanup_and_exit (int signum)
{
- glusterfs_ctx_t *ctx = NULL;
+ glusterfs_ctx_t *ctx = NULL;
+ xlator_t *trav = NULL;
- ctx = glusterfs_ctx_get ();
+ ctx = glusterfsd_ctx;
+
+ if (!ctx)
+ return;
- gf_log ("glusterfsd", GF_LOG_NORMAL, "shutting down");
+ gf_log_callingfn ("", GF_LOG_WARNING,
+ "received signum (%d), shutting down", signum);
+
+ if (ctx->cleanup_started)
+ return;
+
+ ctx->cleanup_started = 1;
+ glusterfs_mgmt_pmap_signout (ctx);
+
+ /* below part is a racy code where the rpcsvc object is freed.
+ * But in another thread (epoll thread), upon poll error in the
+ * socket the transports are cleaned up where again rpcsvc object
+ * is accessed (which is already freed by the below function).
+ * Since the process is about to be killed dont execute the function
+ * below.
+ */
+ /* if (ctx->listener) { */
+ /* (void) glusterfs_listener_stop (ctx); */
+ /* } */
+
+ /* Call fini() of FUSE xlator first:
+ * so there are no more requests coming and
+ * 'umount' of mount point is done properly */
+ trav = ctx->master;
+ if (trav && trav->fini) {
+ THIS = trav;
+ trav->fini (trav);
+ }
glusterfs_pidfile_cleanup (ctx);
exit (0);
+#if 0
+ /* TODO: Properly do cleanup_and_exit(), with synchronization */
+ if (ctx->mgmt) {
+ /* cleanup the saved-frames before last unref */
+ rpc_clnt_connection_cleanup (&ctx->mgmt->conn);
+ rpc_clnt_unref (ctx->mgmt);
+ }
+
+ /* call fini() of each xlator */
+ trav = NULL;
+ if (ctx->active)
+ trav = ctx->active->top;
+ while (trav) {
+ if (trav->fini) {
+ THIS = trav;
+ trav->fini (trav);
+ }
+ trav = trav->next;
+ }
+#endif
}
@@ -604,56 +1142,41 @@ reincarnate (int signum)
{
int ret = 0;
glusterfs_ctx_t *ctx = NULL;
+ cmd_args_t *cmd_args = NULL;
+
+ ctx = glusterfsd_ctx;
+ cmd_args = &ctx->cmd_args;
- ctx = glusterfs_ctx_get ();
+ if (cmd_args->volfile_server) {
+ gf_log ("glusterfsd", GF_LOG_INFO,
+ "Fetching the volume file from server...");
+ ret = glusterfs_volfile_fetch (ctx);
+ } else {
+ gf_log ("glusterfsd", GF_LOG_DEBUG,
+ "Not reloading volume specification file on SIGHUP");
+ }
- gf_log ("glusterfsd", GF_LOG_NORMAL,
- "Reloading volfile ...");
+ /* Also, SIGHUP should do logrotate */
+ gf_log_logrotate (1);
- ret = glusterfs_volumes_init (ctx);
+ if (ret < 0)
+ gf_log ("glusterfsd", GF_LOG_ERROR,
+ "volume initialization failed.");
return;
}
-
-static char *
-generate_uuid ()
+void
+emancipate (glusterfs_ctx_t *ctx, int ret)
{
- char tmp_str[1024] = {0,};
- char hostname[256] = {0,};
- struct timeval tv = {0,};
- struct tm now = {0, };
- char now_str[32];
-
- if (gettimeofday (&tv, NULL) == -1) {
- gf_log ("glusterfsd", GF_LOG_ERROR,
- "gettimeofday: failed %s",
- strerror (errno));
- }
-
- if (gethostname (hostname, 256) == -1) {
- gf_log ("glusterfsd", GF_LOG_ERROR,
- "gethostname: failed %s",
- strerror (errno));
+ /* break free from the parent */
+ if (ctx->daemon_pipe[1] != -1) {
+ write (ctx->daemon_pipe[1], (void *) &ret, sizeof (ret));
+ close (ctx->daemon_pipe[1]);
+ ctx->daemon_pipe[1] = -1;
}
-
- localtime_r (&tv.tv_sec, &now);
- strftime (now_str, 32, "%Y/%m/%d-%H:%M:%S", &now);
- snprintf (tmp_str, 1024, "%s-%d-%s:%"
-#ifdef GF_DARWIN_HOST_OS
- PRId32,
-#else
- "ld",
-#endif
- hostname, getpid(), now_str, tv.tv_usec);
-
- return gf_strdup (tmp_str);
}
-#define GF_SERVER_PROCESS 0
-#define GF_CLIENT_PROCESS 1
-
-
static uint8_t
gf_get_process_mode (char *exec_name)
{
@@ -665,6 +1188,8 @@ gf_get_process_mode (char *exec_name)
if (!strncmp (base, "glusterfsd", 10)) {
ret = GF_SERVER_PROCESS;
+ } else if (!strncmp (base, "glusterd", 8)) {
+ ret = GF_GLUSTERD_PROCESS;
} else {
ret = GF_CLIENT_PROCESS;
}
@@ -675,150 +1200,168 @@ gf_get_process_mode (char *exec_name)
}
-
static int
-set_log_file_path (cmd_args_t *cmd_args)
+glusterfs_ctx_defaults_init (glusterfs_ctx_t *ctx)
{
- int i = 0;
- int j = 0;
- int ret = 0;
- int port = 0;
- char *tmp_ptr = NULL;
- char tmp_str[1024] = {0,};
-
- if (cmd_args->mount_point) {
- j = 0;
- i = 0;
- if (cmd_args->mount_point[0] == '/')
- i = 1;
- for (; i < strlen (cmd_args->mount_point); i++,j++) {
- tmp_str[j] = cmd_args->mount_point[i];
- if (cmd_args->mount_point[i] == '/')
- tmp_str[j] = '-';
- }
+ cmd_args_t *cmd_args = NULL;
+ struct rlimit lim = {0, };
+ int ret = -1;
- ret = gf_asprintf (&cmd_args->log_file,
- DEFAULT_LOG_FILE_DIRECTORY "/%s.log",
- tmp_str);
- if (ret == -1) {
- gf_log ("glusterfsd", GF_LOG_ERROR,
- "asprintf failed while setting up log-file");
- }
- goto done;
- }
-
- if (cmd_args->volfile) {
- j = 0;
- i = 0;
- if (cmd_args->volfile[0] == '/')
- i = 1;
- 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 (ret == -1) {
- gf_log ("glusterfsd", GF_LOG_ERROR,
- "asprintf failed while setting up log-file");
- }
- goto done;
+ xlator_mem_acct_init (THIS, gfd_mt_end);
+
+ ctx->process_uuid = generate_glusterfs_ctx_id ();
+ if (!ctx->process_uuid) {
+ gf_log ("", GF_LOG_CRITICAL,
+ "ERROR: glusterfs uuid generation failed");
+ goto out;
}
- if (cmd_args->volfile_server) {
- port = 1;
- tmp_ptr = "default";
-
- if (cmd_args->volfile_server_port)
- port = cmd_args->volfile_server_port;
- if (cmd_args->volfile_id)
- tmp_ptr = cmd_args->volfile_id;
-
- ret = gf_asprintf (&cmd_args->log_file,
- DEFAULT_LOG_FILE_DIRECTORY "/%s-%s-%d.log",
- cmd_args->volfile_server, tmp_ptr, port);
- if (-1 == ret) {
- gf_log ("glusterfsd", GF_LOG_ERROR,
- "asprintf failed while setting up log-file");
- }
+ ctx->page_size = 128 * GF_UNIT_KB;
+
+ ctx->iobuf_pool = iobuf_pool_new ();
+ if (!ctx->iobuf_pool) {
+ gf_log ("", GF_LOG_CRITICAL,
+ "ERROR: glusterfs iobuf pool creation failed");
+ goto out;
}
-done:
- return ret;
-}
+ ctx->event_pool = event_pool_new (DEFAULT_EVENT_POOL_SIZE);
+ if (!ctx->event_pool) {
+ gf_log ("", GF_LOG_CRITICAL,
+ "ERROR: glusterfs event pool creation failed");
+ goto out;
+ }
-static int
-glusterfs_ctx_defaults_init (glusterfs_ctx_t *ctx)
-{
- cmd_args_t *cmd_args = NULL;
- struct rlimit lim = {0, };
- call_pool_t *pool = NULL;
+ ctx->pool = GF_CALLOC (1, sizeof (call_pool_t), gfd_mt_call_pool_t);
+ if (!ctx->pool) {
+ gf_log ("", GF_LOG_CRITICAL,
+ "ERROR: glusterfs call pool creation failed");
+ goto out;
+ }
- xlator_mem_acct_init (THIS, gfd_mt_end);
+ INIT_LIST_HEAD (&ctx->pool->all_frames);
+ LOCK_INIT (&ctx->pool->lock);
- ctx->process_uuid = generate_uuid ();
- if (!ctx->process_uuid)
- return -1;
+ /* frame_mem_pool size 112 * 4k */
+ ctx->pool->frame_mem_pool = mem_pool_new (call_frame_t, 4096);
+ if (!ctx->pool->frame_mem_pool) {
+ gf_log ("", GF_LOG_CRITICAL,
+ "ERROR: glusterfs frame pool creation failed");
+ goto out;
+ }
+ /* stack_mem_pool size 256 * 1024 */
+ ctx->pool->stack_mem_pool = mem_pool_new (call_stack_t, 1024);
+ if (!ctx->pool->stack_mem_pool) {
+ gf_log ("", GF_LOG_CRITICAL,
+ "ERROR: glusterfs stack pool creation failed");
+ goto out;
+ }
- ctx->page_size = 128 * GF_UNIT_KB;
+ ctx->stub_mem_pool = mem_pool_new (call_stub_t, 1024);
+ if (!ctx->stub_mem_pool) {
+ gf_log ("", GF_LOG_CRITICAL,
+ "ERROR: glusterfs stub pool creation failed");
+ goto out;
+ }
- ctx->iobuf_pool = iobuf_pool_new (8 * GF_UNIT_MB, ctx->page_size);
- if (!ctx->iobuf_pool)
- return -1;
+ ctx->dict_pool = mem_pool_new (dict_t, GF_MEMPOOL_COUNT_OF_DICT_T);
+ if (!ctx->dict_pool)
+ goto out;
- ctx->event_pool = event_pool_new (DEFAULT_EVENT_POOL_SIZE);
- if (!ctx->event_pool)
- return -1;
+ ctx->dict_pair_pool = mem_pool_new (data_pair_t,
+ GF_MEMPOOL_COUNT_OF_DATA_PAIR_T);
+ if (!ctx->dict_pair_pool)
+ goto out;
- 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;
+ ctx->dict_data_pool = mem_pool_new (data_t, GF_MEMPOOL_COUNT_OF_DATA_T);
+ if (!ctx->dict_data_pool)
+ goto out;
pthread_mutex_init (&(ctx->lock), NULL);
+ ctx->clienttable = gf_clienttable_alloc();
+ if (!ctx->clienttable)
+ goto out;
+
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;
+
+ cmd_args->mac_compat = GF_OPTION_DISABLE;
+#ifdef GF_DARWIN_HOST_OS
+ /* On Darwin machines, O_APPEND is not handled,
+ * which may corrupt the data
+ */
+ cmd_args->fuse_direct_io_mode = GF_OPTION_DISABLE;
+#else
+ cmd_args->fuse_direct_io_mode = GF_OPTION_DEFERRED;
+#endif
cmd_args->fuse_attribute_timeout = -1;
+ cmd_args->fuse_entry_timeout = -1;
+ cmd_args->fopen_keep_cache = GF_OPTION_DEFERRED;
INIT_LIST_HEAD (&cmd_args->xlator_options);
+ INIT_LIST_HEAD (&cmd_args->volfile_servers);
lim.rlim_cur = RLIM_INFINITY;
lim.rlim_max = RLIM_INFINITY;
setrlimit (RLIMIT_CORE, &lim);
- return 0;
-}
+ ret = 0;
+out:
+ if (ret && ctx) {
+ if (ctx->pool) {
+ mem_pool_destroy (ctx->pool->frame_mem_pool);
+ mem_pool_destroy (ctx->pool->stack_mem_pool);
+ }
+ GF_FREE (ctx->pool);
+ mem_pool_destroy (ctx->stub_mem_pool);
+ mem_pool_destroy (ctx->dict_pool);
+ mem_pool_destroy (ctx->dict_data_pool);
+ mem_pool_destroy (ctx->dict_pair_pool);
+ }
+
+ return ret;
+}
static int
-logging_init (glusterfs_ctx_t *ctx)
+logging_init (glusterfs_ctx_t *ctx, const char *progpath)
{
cmd_args_t *cmd_args = NULL;
int ret = 0;
+ char ident[1024] = {0,};
+ char *progname = NULL;
+ char *ptr = NULL;
cmd_args = &ctx->cmd_args;
if (cmd_args->log_file == NULL) {
- ret = set_log_file_path (cmd_args);
+ ret = gf_set_log_file_path (cmd_args);
if (ret == -1) {
- fprintf (stderr, "failed to set the log file path.. "
- "exiting\n");
+ fprintf (stderr, "ERROR: failed to set the log file path\n");
return -1;
}
}
- if (gf_log_init (cmd_args->log_file) == -1) {
- fprintf (stderr,
- "failed to open logfile %s. exiting\n",
+#ifdef GF_USE_SYSLOG
+ progname = gf_strdup (progpath);
+ snprintf (ident, 1024, "%s_%s", basename(progname),
+ basename(cmd_args->log_file));
+ GF_FREE (progname);
+ /* remove .log suffix */
+ if (NULL != (ptr = strrchr(ident, '.'))) {
+ if (strcmp(ptr, ".log") == 0) {
+ /* note: ptr points to location in ident only */
+ ptr[0] = '\0';
+ }
+ }
+ ptr = ident;
+#endif
+
+ if (gf_log_init (ctx, cmd_args->log_file, ptr) == -1) {
+ fprintf (stderr, "ERROR: failed to open logfile %s\n",
cmd_args->log_file);
return -1;
}
@@ -828,19 +1371,31 @@ logging_init (glusterfs_ctx_t *ctx)
return 0;
}
+void
+gf_check_and_set_mem_acct (glusterfs_ctx_t *ctx, int argc, char *argv[])
+{
+ int i = 0;
+ for (i = 0; i < argc; i++) {
+ if (strcmp (argv[i], "--mem-accounting") == 0) {
+ gf_mem_acct_enable_set (ctx);
+ break;
+ }
+ }
+}
int
-parse_cmdline (int argc, char *argv[], cmd_args_t *cmd_args)
+parse_cmdline (int argc, char *argv[], glusterfs_ctx_t *ctx)
{
- 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;
+ int process_mode = 0;
+ int ret = 0;
+ struct stat stbuf = {0, };
+ char timestr[32];
+ char tmp_logfile[1024] = { 0 };
+ char *tmp_logfile_dyn = NULL;
+ char *tmp_logfilebase = NULL;
+ cmd_args_t *cmd_args = NULL;
+
+ cmd_args = &ctx->cmd_args;
argp_parse (&argp, argc, argv, ARGP_IN_ORDER, NULL, cmd_args);
@@ -851,13 +1406,39 @@ parse_cmdline (int argc, char *argv[], cmd_args_t *cmd_args)
}
process_mode = gf_get_process_mode (argv[0]);
+ ctx->process_mode = process_mode;
+
+ /* Make sure after the parsing cli, if '--volfile-server' option is
+ given, then '--volfile-id' is mandatory */
+ if (cmd_args->volfile_server && !cmd_args->volfile_id) {
+ gf_log ("glusterfs", GF_LOG_CRITICAL,
+ "ERROR: '--volfile-id' is mandatory if '-s' OR "
+ "'--volfile-server' option is given");
+ ret = -1;
+ goto out;
+ }
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 if (process_mode == GF_GLUSTERD_PROCESS)
+ cmd_args->volfile = gf_strdup (DEFAULT_GLUSTERD_VOLFILE);
else
cmd_args->volfile = gf_strdup (DEFAULT_CLIENT_VOLFILE);
+
+ /* Check if the volfile exists, if not give usage output
+ and exit */
+ ret = stat (cmd_args->volfile, &stbuf);
+ if (ret) {
+ gf_log ("glusterfs", GF_LOG_CRITICAL,
+ "ERROR: parsing the volfile failed (%s)\n",
+ strerror (errno));
+ /* argp_usage (argp.) */
+ fprintf (stderr, "USAGE: %s [options] [mountpoint]\n",
+ argv[0]);
+ goto out;
+ }
}
if (cmd_args->run_id) {
@@ -868,9 +1449,9 @@ parse_cmdline (int argc, char *argv[], cmd_args_t *cmd_args)
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);
+ /* Have separate logfile per run */
+ gf_time_fmt (timestr, sizeof timestr, time (NULL),
+ gf_timefmt_FT);
sprintf (tmp_logfile, "%s.%s.%d",
cmd_args->log_file, timestr, getpid ());
@@ -882,17 +1463,25 @@ parse_cmdline (int argc, char *argv[], cmd_args_t *cmd_args)
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);
- cmd_args->log_file = gf_strdup (tmp_logfile);
+ fprintf (stderr, "ERROR: symlink of logfile failed\n");
+ goto out;
}
+ GF_FREE (cmd_args->log_file);
+ cmd_args->log_file = gf_strdup (tmp_logfile);
+
GF_FREE (tmp_logfile_dyn);
}
}
- return 0;
+#ifdef GF_DARWIN_HOST_OS
+ if (cmd_args->mount_point)
+ cmd_args->mac_compat = GF_OPTION_DEFERRED;
+#endif
+
+ ret = 0;
+out:
+ return ret;
}
@@ -900,7 +1489,7 @@ int
glusterfs_pidfile_setup (glusterfs_ctx_t *ctx)
{
cmd_args_t *cmd_args = NULL;
- int ret = 0;
+ int ret = -1;
FILE *pidfp = NULL;
cmd_args = &ctx->cmd_args;
@@ -913,7 +1502,7 @@ glusterfs_pidfile_setup (glusterfs_ctx_t *ctx)
gf_log ("glusterfsd", GF_LOG_ERROR,
"pidfile %s error (%s)",
cmd_args->pid_file, strerror (errno));
- return -1;
+ goto out;
}
ret = lockf (fileno (pidfp), F_TLOCK, 0);
@@ -921,7 +1510,7 @@ glusterfs_pidfile_setup (glusterfs_ctx_t *ctx)
gf_log ("glusterfsd", GF_LOG_ERROR,
"pidfile %s lock error (%s)",
cmd_args->pid_file, strerror (errno));
- return ret;
+ goto out;
}
gf_log ("glusterfsd", GF_LOG_TRACE,
@@ -929,17 +1518,28 @@ glusterfs_pidfile_setup (glusterfs_ctx_t *ctx)
cmd_args->pid_file);
ret = lockf (fileno (pidfp), F_ULOCK, 0);
+ if (ret) {
+ gf_log ("glusterfsd", GF_LOG_ERROR,
+ "pidfile %s unlock error (%s)",
+ cmd_args->pid_file, strerror (errno));
+ goto out;
+ }
ctx->pidfp = pidfp;
- return 0;
+ ret = 0;
+out:
+ if (ret && pidfp)
+ fclose (pidfp);
+
+ return ret;
}
int
glusterfs_pidfile_cleanup (glusterfs_ctx_t *ctx)
{
- cmd_args_t *cmd_args = NULL;
+ cmd_args_t *cmd_args = NULL;
cmd_args = &ctx->cmd_args;
@@ -947,18 +1547,18 @@ glusterfs_pidfile_cleanup (glusterfs_ctx_t *ctx)
return 0;
gf_log ("glusterfsd", GF_LOG_TRACE,
- "pidfile %s unlocking",
+ "pidfile %s cleanup",
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;
}
+ lockf (fileno (ctx->pidfp), F_ULOCK, 0);
+ fclose (ctx->pidfp);
+ ctx->pidfp = NULL;
+
return 0;
}
@@ -1023,6 +1623,7 @@ glusterfs_sigwaiter (void *arg)
int sig = 0;
+ sigemptyset (&set);
sigaddset (&set, SIGINT); /* cleanup_and_exit */
sigaddset (&set, SIGTERM); /* cleanup_and_exit */
sigaddset (&set, SIGHUP); /* reincarnate */
@@ -1031,15 +1632,9 @@ glusterfs_sigwaiter (void *arg)
for (;;) {
ret = sigwait (&set, &sig);
- if (ret) {
- gf_log ("sigwaiter", GF_LOG_ERROR,
- "sigwait returned error (%s)",
- strerror (ret));
+ if (ret)
continue;
- }
- gf_log ("sigwaiter", GF_LOG_DEBUG,
- "received signal %d", sig);
switch (sig) {
case SIGINT:
@@ -1050,14 +1645,13 @@ glusterfs_sigwaiter (void *arg)
reincarnate (sig);
break;
case SIGUSR1:
- gf_proc_dump_info (sig);
+ gf_proc_dump_info (sig, glusterfsd_ctx);
break;
case SIGUSR2:
- gf_latency_toggle (sig);
+ gf_latency_toggle (sig, glusterfsd_ctx);
break;
default:
- gf_log ("sigwaiter", GF_LOG_ERROR,
- "unhandled signal: %d", sig);
+
break;
}
}
@@ -1066,6 +1660,13 @@ glusterfs_sigwaiter (void *arg)
}
+void
+glusterfsd_print_trace (int signum)
+{
+ gf_print_trace (signum, glusterfsd_ctx);
+}
+
+
int
glusterfs_signals_setup (glusterfs_ctx_t *ctx)
{
@@ -1075,24 +1676,28 @@ glusterfs_signals_setup (glusterfs_ctx_t *ctx)
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 (SIGSEGV, glusterfsd_print_trace);
+ signal (SIGABRT, glusterfsd_print_trace);
+ signal (SIGILL, glusterfsd_print_trace);
+ signal (SIGTRAP, glusterfsd_print_trace);
+ signal (SIGFPE, glusterfsd_print_trace);
+ signal (SIGBUS, glusterfsd_print_trace);
+ signal (SIGINT, cleanup_and_exit);
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)
+ if (ret) {
+ gf_log ("glusterfsd", GF_LOG_WARNING,
+ "failed to execute pthread_signmask %s",
+ strerror (errno));
return ret;
+ }
ret = pthread_create (&ctx->sigwaiter, NULL, glusterfs_sigwaiter,
(void *) &set);
@@ -1102,6 +1707,9 @@ glusterfs_signals_setup (glusterfs_ctx_t *ctx)
fallback to signals getting handled by other threads.
setup the signal handlers
*/
+ gf_log ("glusterfsd", GF_LOG_WARNING,
+ "failed to create pthread %s",
+ strerror (errno));
return ret;
}
@@ -1112,15 +1720,16 @@ glusterfs_signals_setup (glusterfs_ctx_t *ctx)
int
daemonize (glusterfs_ctx_t *ctx)
{
- int ret = 0;
+ int ret = -1;
cmd_args_t *cmd_args = NULL;
-
+ int cstatus = 0;
+ int err = 0;
cmd_args = &ctx->cmd_args;
ret = glusterfs_pidfile_setup (ctx);
if (ret)
- return ret;
+ goto out;
if (cmd_args->no_daemon_mode)
goto postfork;
@@ -1128,92 +1737,209 @@ daemonize (glusterfs_ctx_t *ctx)
if (cmd_args->debug_mode)
goto postfork;
- daemon (0, 0);
+ ret = pipe (ctx->daemon_pipe);
+ if (ret) {
+ /* If pipe() fails, retain daemon_pipe[] = {-1, -1}
+ and parent will just not wait for child status
+ */
+ ctx->daemon_pipe[0] = -1;
+ ctx->daemon_pipe[1] = -1;
+ }
+
+ ret = os_daemon_return (0, 0);
+ switch (ret) {
+ case -1:
+ if (ctx->daemon_pipe[0] != -1) {
+ close (ctx->daemon_pipe[0]);
+ close (ctx->daemon_pipe[1]);
+ }
+
+ gf_log ("daemonize", GF_LOG_ERROR,
+ "Daemonization failed: %s", strerror(errno));
+ goto out;
+ case 0:
+ /* child */
+ /* close read */
+ close (ctx->daemon_pipe[0]);
+ break;
+ default:
+ /* parent */
+ /* close write */
+ close (ctx->daemon_pipe[1]);
+
+ if (ctx->mnt_pid > 0) {
+ ret = waitpid (ctx->mnt_pid, &cstatus, 0);
+ if (!(ret == ctx->mnt_pid && cstatus == 0)) {
+ gf_log ("daemonize", GF_LOG_ERROR,
+ "mount failed");
+ exit (1);
+ }
+ }
+
+ err = 1;
+ read (ctx->daemon_pipe[0], (void *)&err, sizeof (err));
+ _exit (err);
+ }
postfork:
ret = glusterfs_pidfile_update (ctx);
if (ret)
- return ret;
+ goto out;
glusterfs_signals_setup (ctx);
-
+out:
return ret;
}
int
-glusterfs_volumes_init (glusterfs_ctx_t *ctx)
+glusterfs_process_volfp (glusterfs_ctx_t *ctx, FILE *fp)
{
- 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;
- }
+ int ret = -1;
+ xlator_t *trav = NULL;
graph = glusterfs_graph_construct (fp);
-
if (!graph) {
- ret = -1;
+ gf_log ("", GF_LOG_ERROR, "failed to construct the graph");
goto out;
}
- ret = glusterfs_graph_prepare (graph, ctx);
+ for (trav = graph->first; trav; trav = trav->next) {
+ if (strcmp (trav->type, "mount/fuse") == 0) {
+ gf_log ("glusterfsd", GF_LOG_ERROR,
+ "fuse xlator cannot be specified "
+ "in volume file");
+ goto out;
+ }
+ }
+ ret = glusterfs_graph_prepare (graph, ctx);
if (ret) {
glusterfs_graph_destroy (graph);
- ret = -1;
goto out;
}
- ret = glusterfs_graph_activate (ctx, graph);
+ ret = glusterfs_graph_activate (graph, ctx);
if (ret) {
glusterfs_graph_destroy (graph);
- ret = -1;
goto out;
}
+ gf_log_dump_graph (fp, graph);
+
+ ret = 0;
out:
if (fp)
fclose (fp);
+ if (ret && !ctx->active) {
+ /* there is some error in setting up the first graph itself */
+ cleanup_and_exit (0);
+ }
+
return ret;
}
int
+glusterfs_volumes_init (glusterfs_ctx_t *ctx)
+{
+ FILE *fp = NULL;
+ cmd_args_t *cmd_args = NULL;
+ int ret = 0;
+
+ cmd_args = &ctx->cmd_args;
+
+ if (cmd_args->sock_file) {
+ ret = glusterfs_listener_init (ctx);
+ if (ret)
+ goto out;
+ }
+
+ if (cmd_args->volfile_server) {
+ ret = glusterfs_mgmt_init (ctx);
+ /* return, do not emancipate() yet */
+ return ret;
+ }
+
+ fp = get_volfp (ctx);
+
+ if (!fp) {
+ gf_log ("glusterfsd", GF_LOG_ERROR,
+ "Cannot reach volume specification file");
+ ret = -1;
+ goto out;
+ }
+
+ ret = glusterfs_process_volfp (ctx, fp);
+ if (ret)
+ goto out;
+
+out:
+ emancipate (ctx, ret);
+ return ret;
+}
+
+
+/* This is the only legal global pointer */
+glusterfs_ctx_t *glusterfsd_ctx;
+
+int
main (int argc, char *argv[])
{
glusterfs_ctx_t *ctx = NULL;
int ret = -1;
+ char cmdlinestr[PATH_MAX] = {0,};
+
+ ctx = glusterfs_ctx_new ();
+ if (!ctx) {
+ gf_log ("glusterfs", GF_LOG_CRITICAL,
+ "ERROR: glusterfs context not initialized");
+ return ENOMEM;
+ }
+ glusterfsd_ctx = ctx;
+
+#ifdef DEBUG
+ gf_mem_acct_enable_set (ctx);
+#else
+ /* Enable memory accounting on the fly based on argument */
+ gf_check_and_set_mem_acct (ctx, argc, argv);
+#endif
- ret = glusterfs_globals_init ();
+ ret = glusterfs_globals_init (ctx);
if (ret)
return ret;
- ctx = glusterfs_ctx_get ();
- if (!ctx)
- return ENOMEM;
+ THIS->ctx = ctx;
ret = glusterfs_ctx_defaults_init (ctx);
if (ret)
goto out;
- ret = parse_cmdline (argc, argv, &ctx->cmd_args);
+ ret = parse_cmdline (argc, argv, ctx);
if (ret)
goto out;
- ret = logging_init (ctx);
+ ret = logging_init (ctx, argv[0]);
if (ret)
goto out;
+ /* log the version of glusterfs running here along with the actual
+ command line options. */
+ {
+ int i = 0;
+ strcpy (cmdlinestr, argv[0]);
+ for (i = 1; i < argc; i++) {
+ strcat (cmdlinestr, " ");
+ strcat (cmdlinestr, argv[i]);
+ }
+ gf_log (argv[0], GF_LOG_INFO,
+ "Started running %s version %s (%s)",
+ argv[0], PACKAGE_VERSION, cmdlinestr);
+ }
+
gf_proc_dump_init();
ret = create_fuse_mount (ctx);
@@ -1224,6 +1950,13 @@ main (int argc, char *argv[])
if (ret)
goto out;
+ ctx->env = syncenv_new (0, 0, 0);
+ if (!ctx->env) {
+ gf_log ("", GF_LOG_ERROR,
+ "Could not create new sync-environment");
+ goto out;
+ }
+
ret = glusterfs_volumes_init (ctx);
if (ret)
goto out;
generated by cgit (git 2.34.1) at 2026-01-05 13:43:38 +0000