diff options
Diffstat (limited to 'glusterfsd/src/glusterfsd.c')
| -rw-r--r-- | glusterfsd/src/glusterfsd.c | 2437 |
1 files changed, 1455 insertions, 982 deletions
diff --git a/glusterfsd/src/glusterfsd.c b/glusterfsd/src/glusterfsd.c index 867cdf78e..3cb8f0f51 100644 --- a/glusterfsd/src/glusterfsd.c +++ b/glusterfsd/src/glusterfsd.c @@ -1,22 +1,12 @@ /* - 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/>. -*/ + 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 @@ -59,7 +51,6 @@ #include "compat.h" #include "logging.h" #include "dict.h" -#include "protocol.h" #include "list.h" #include "timer.h" #include "glusterfsd.h" @@ -70,52 +61,51 @@ #include "globals.h" #include "statedump.h" #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" -extern int -gf_log_central_init (glusterfs_ctx_t *ctx, const char *remote_host, - const char *transport, uint32_t remote_port); +#include "daemon.h" +/* 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 ">"; -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:"}, {"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_VOLUME_FILE" or " - DEFAULT_SERVER_VOLUME_FILE"]"}, + "File to use as 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-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" "]"}, @@ -128,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, @@ -140,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"}, + {"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"}, -#ifdef GF_DARWIN_HOST_OS - {"non-local", ARGP_NON_LOCAL_KEY, 0, 0, - "Mount the macfuse volume without '-o local' option"}, -#endif + {"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, } }; @@ -172,248 +209,363 @@ 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; +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); - 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]); +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,}; - 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; + 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 { - if (gf_daemon_buff == 0) - exit (EXIT_SUCCESS); - else - exit (EXIT_FAILURE); + gf_log ("glusterfsd", GF_LOG_ERROR, + "Could not get current working directory"); + goto err; } - } - - /*child continues*/ - close (pipe_fd[0]); - if (daemon (0, 0) == -1) { - gf_log ("glusterfs", GF_LOG_ERROR, - "unable to run in daemon mode: %s", - strerror (errno)); - return -1; - } - return 0; -} + } else + mount_point = gf_strdup (cmd_args->mount_point); -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]); + 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; } - fprintf (gf_log_logfile, "\nPID : %d\n", mypid); + if (cmd_args->fuse_attribute_timeout >= 0) { + ret = dict_set_double (options, ZR_ATTR_TIMEOUT_OPT, + cmd_args->fuse_attribute_timeout); - 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); + if (ret < 0) { + gf_log ("glusterfsd", GF_LOG_ERROR, + "failed to set dict value for key %s", + ZR_ATTR_TIMEOUT_OPT); + goto err; + } } - - 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; - - trav = list; - do { - if (trav->prev == NULL) { - head = trav; + 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; } + } - trav = trav->prev; - } while (trav != NULL); + 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; + } + } - return head; -} + 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; + } + } -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; + 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; + } + } - ctx = graph->ctx; - cmd_args = &ctx->cmd_args; + 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; + } + } - 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; + 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; + } } - 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, - cmd_args->mount_point); - if (ret < 0) { - gf_log ("glusterfs", GF_LOG_DEBUG, - "failed to set mount-point to options dictionary"); + 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->fuse_attribute_timeout >= 0) - ret = dict_set_double (top->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, - cmd_args->fuse_entry_timeout); + 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->volfile_check) - ret = dict_set_int32 (top->options, ZR_STRICT_VOLFILE_CHECK, - cmd_args->volfile_check); + 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; + } + } -#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, - "'direct-io-mode' in fuse causes data corruption " - "if O_APPEND is used. disabling 'direct-io-mode'"); + 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; + } } - 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); + 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; + } + } -#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, + 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 1: /* enable */ - ret = dict_set_static_ptr (top->options, ZR_DIRECT_IO_OPT, + 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 2: /* default */ + case GF_OPTION_DEFERRED: /* default */ default: + gf_log ("", GF_LOG_DEBUG, "fuse direct io type %d", + cmd_args->fuse_direct_io_mode); break; } -#endif /* GF_DARWIN_HOST_OS */ - - graph->parents = CALLOC (1, sizeof (xlator_list_t)); - graph->parents->xlator = top; + 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; + } + } - return top; + 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; } -static xlator_t * -_add_ro_volume (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 = CALLOC (sizeof (*xlchild), 1); - if (!xlchild) { - return NULL; + if (!cmd_args->mount_point) { + gf_log ("", GF_LOG_TRACE, + "mount point not found, not a client process"); + return 0; } - xlchild->xlator = graph; - top = CALLOC (1, sizeof (*top)); - top->name = strdup ("read-only"); - if (xlator_set_type (top, ZR_XLATOR_READ_ONLY) == -1) { - fprintf (stderr, - "read-only volume initialization failed"); - gf_log ("glusterfs", GF_LOG_ERROR, - "read-only initialization failed"); - return NULL; + if (ctx->process_mode != GF_CLIENT_PROCESS) { + gf_log("glusterfsd", GF_LOG_ERROR, + "Not a client process, not performing mount operation"); + return -1; } - 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; + master = GF_CALLOC (1, sizeof (*master), + gfd_mt_xlator_t); + if (!master) + goto err; - return top; + master->name = gf_strdup ("fuse"); + if (!master->name) + goto err; + + if (xlator_set_type (master, "mount/fuse") == -1) { + gf_log ("glusterfsd", GF_LOG_ERROR, + "MOUNT-POINT %s initialization failed", + cmd_args->mount_point); + goto err; + } + + master->ctx = ctx; + master->options = get_new_dict (); + if (!master->options) + goto err; + + ret = set_fuse_mount_options (ctx, master->options); + if (ret) + goto err; + + 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; + } + } + + ret = xlator_init (master); + if (ret) { + gf_log ("", GF_LOG_DEBUG, "failed to initialize fuse translator"); + goto err; + } + + ctx->master = master; + + return 0; + +err: + if (master) { + xlator_destroy (master); + } + + 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; @@ -422,303 +574,80 @@ _get_specfp (glusterfs_ctx_t *ctx) 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); + 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) +gf_remember_backup_volfile_server (char *arg) { - 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; + glusterfs_ctx_t *ctx = NULL; + cmd_args_t *cmd_args = NULL; + int ret = -1; + server_cmdline_t *server = NULL; - 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; - } - } - } + ctx = glusterfsd_ctx; + if (!ctx) + goto out; + cmd_args = &ctx->cmd_args; - if (!found) { - gf_log (xl->name, GF_LOG_WARNING, - "option '%s' is not recognized", - pair->key); - } - return 0; -} + if(!cmd_args) + goto out; -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; + server = GF_CALLOC (1, sizeof (server_cmdline_t), + gfd_mt_server_cmdline_t); + if (!server) + goto out; - trav = xl; + INIT_LIST_HEAD(&server->list); - while (trav->prev) - trav = trav->prev; + server->volfile_server = gf_strdup(arg); - /* 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; + if (!cmd_args->volfile_server) { + cmd_args->volfile_server = server->volfile_server; + cmd_args->curr_server = server; } - - 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; + if (!server->volfile_server) { + gf_log ("", GF_LOG_WARNING, + "xlator option %s is invalid", arg); + goto out; } - /* No error in this phase, just bunch of warning if at all */ - trav = xl; - - while (trav->prev) - trav = trav->prev; + list_add_tail (&server->list, &cmd_args->volfile_servers); - /* Validate again phase */ - while (trav) { - pair = trav->options->members_list; - while (pair) { - _log_if_option_is_invalid (trav, pair); - pair = pair->next; + ret = 0; +out: + if (ret == -1) { + if (server) { + GF_FREE (server->volfile_server); + GF_FREE (server); } - 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 (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) +gf_remember_xlator_option (char *arg) { glusterfs_ctx_t *ctx = NULL; cmd_args_t *cmd_args = NULL; @@ -727,30 +656,51 @@ gf_remember_xlator_option (struct list_head *options, char *arg) char *dot = NULL; char *equals = NULL; - ctx = get_global_ctx_ptr (); + ctx = glusterfsd_ctx; cmd_args = &ctx->cmd_args; - option = CALLOC (1, sizeof (xlator_cmdline_option_t)); + 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) + 1, sizeof (char), + gfd_mt_char); + if (!option->volume) goto out; - option->volume = CALLOC ((dot - arg), sizeof (char)); 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) + 1, sizeof (char), + gfd_mt_char); + if (!option->key) goto out; - option->key = CALLOC ((equals - dot), sizeof (char)); 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 = strdup (equals + 1); + option->value = gf_strdup (equals + 1); list_add (&option->cmd_args, &cmd_args->xlator_options); @@ -758,14 +708,11 @@ gf_remember_xlator_option (struct list_head *options, char *arg) 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); + GF_FREE (option->volume); + GF_FREE (option->key); + GF_FREE (option->value); + + GF_FREE (option); } } @@ -773,77 +720,86 @@ 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; - 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 = 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; + + case ARGP_ACL_KEY: + cmd_args->acl = 1; + gf_remember_xlator_option ("*-md-cache.cache-posix-acl=true"); + break; + + case ARGP_SELINUX_KEY: + cmd_args->selinux = 1; + gf_remember_xlator_option ("*-md-cache.cache-selinux=true"); + break; + + case ARGP_AUX_GFID_MOUNT_KEY: + cmd_args->aux_gfid_mount = 1; + break; + + case ARGP_INODE32_KEY: + cmd_args->enable_ino32 = 1; + break; + + case ARGP_WORM_KEY: + cmd_args->worm = 1; + break; + + case ARGP_MAC_COMPAT_KEY: + if (!arg) + arg = "on"; + + if (gf_string2boolean (arg, &b) == 0) { + cmd_args->mac_compat = b; - if (gf_string2uint_base10 (arg, &n) == 0) { - cmd_args->max_connect_attempts = n; break; } argp_failure (state, -1, 0, - "Invalid limit on connect attempts %s", arg); - break; - - case ARGP_READ_ONLY_KEY: - cmd_args->read_only = 1; + "invalid value \"%s\" for mac-compat", arg); break; case ARGP_VOLUME_FILE_KEY: - cmd_args->volume_file = strdup (arg); - break; + 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); + } - case ARGP_LOG_SERVER_KEY: - cmd_args->log_server = strdup (arg); break; case ARGP_LOG_LEVEL_KEY: @@ -863,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) { @@ -880,7 +836,7 @@ parse_opts (int key, char *arg, struct argp_state *state) break; case ARGP_LOG_FILE_KEY: - cmd_args->log_file = strdup (arg); + cmd_args->log_file = gf_strdup (arg); break; case ARGP_VOLFILE_SERVER_PORT_KEY: @@ -895,28 +851,20 @@ 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 = strdup (arg); + cmd_args->volfile_server_transport = gf_strdup (arg); break; case ARGP_VOLFILE_ID_KEY: - cmd_args->volfile_id = strdup (arg); + cmd_args->volfile_id = gf_strdup (arg); break; case ARGP_PID_FILE_KEY: - cmd_args->pid_file = strdup (arg); + 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: @@ -924,19 +872,25 @@ parse_opts (int key, char *arg, struct argp_state *state) break; case ARGP_RUN_ID_KEY: - cmd_args->run_id = strdup (arg); + cmd_args->run_id = gf_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 = 0; - break; + case ARGP_DIRECT_IO_MODE_KEY: + if (!arg) + arg = "on"; - case ARGP_ENABLE_DIRECT_IO_MODE_KEY: - cmd_args->fuse_direct_io_mode_flag = 1; + if (gf_string2boolean (arg, &b) == 0) { + cmd_args->fuse_direct_io_mode = b; + + break; + } + + argp_failure (state, -1, 0, + "unknown direct I/O mode setting \"%s\"", arg); break; case ARGP_ENTRY_TIMEOUT_KEY: @@ -951,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; @@ -964,25 +930,40 @@ 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; case ARGP_VOLUME_NAME_KEY: - cmd_args->volume_name = strdup (arg); + cmd_args->volume_name = gf_strdup (arg); break; case ARGP_XLATOR_OPTION_KEY: - gf_remember_xlator_option (&cmd_args->xlator_options, arg); - break; + if (gf_remember_xlator_option (arg)) + argp_failure (state, -1, 0, "invalid xlator option %s", + arg); -#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; @@ -990,9 +971,101 @@ parse_opts (int key, char *arg, struct argp_state *state) if (state->arg_num >= 1) argp_usage (state); - cmd_args->mount_point = strdup (arg); + cmd_args->mount_point = gf_strdup (arg); break; - } + + 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; } @@ -1001,74 +1074,108 @@ parse_opts (int key, char *arg, struct argp_state *state) void cleanup_and_exit (int signum) { - glusterfs_ctx_t *ctx = NULL; - xlator_t *trav = NULL; + glusterfs_ctx_t *ctx = NULL; + xlator_t *trav = NULL; - ctx = get_global_ctx_ptr (); + ctx = glusterfsd_ctx; - gf_log ("glusterfs", GF_LOG_WARNING, "shutting down"); + if (!ctx) + return; - if (ctx->pidfp) { - lockf (fileno (ctx->pidfp), F_ULOCK, 0); - fclose (ctx->pidfp); - ctx->pidfp = NULL; - } + gf_log_callingfn ("", GF_LOG_WARNING, + "received signum (%d), shutting down", signum); - if (ctx->specfp) { - fclose (ctx->specfp); - ctx->specfp = NULL; + 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); } - if (ctx->cmd_args.pid_file) { - unlink (ctx->cmd_args.pid_file); - ctx->cmd_args.pid_file = NULL; + 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); } - if (ctx->graph) { - trav = ctx->graph; - ctx->graph = NULL; - while (trav) { + /* 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; } - exit (0); - } else { - gf_log ("glusterfs", GF_LOG_DEBUG, "no graph present"); + trav = trav->next; } +#endif } -static char * -zr_build_process_uuid () +static void +reincarnate (int signum) { - char tmp_str[1024] = {0,}; - char hostname[256] = {0,}; - struct timeval tv = {0,}; - struct tm now = {0, }; - char now_str[32]; + int ret = 0; + glusterfs_ctx_t *ctx = NULL; + cmd_args_t *cmd_args = NULL; - if (-1 == gettimeofday(&tv, NULL)) { - gf_log ("", GF_LOG_ERROR, - "gettimeofday: failed %s", - strerror (errno)); - } + ctx = glusterfsd_ctx; + cmd_args = &ctx->cmd_args; - if (-1 == gethostname (hostname, 256)) { - gf_log ("", GF_LOG_ERROR, - "gethostname: failed %s", - strerror (errno)); + 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"); } - 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); + /* Also, SIGHUP should do logrotate */ + gf_log_logrotate (1); - return strdup (tmp_str); + if (ret < 0) + gf_log ("glusterfsd", GF_LOG_ERROR, + "volume initialization failed."); + + return; } -#define GF_SERVER_PROCESS 0 -#define GF_CLIENT_PROCESS 1 +void +emancipate (glusterfs_ctx_t *ctx, int ret) +{ + /* 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; + } +} static uint8_t gf_get_process_mode (char *exec_name) @@ -1076,422 +1183,788 @@ gf_get_process_mode (char *exec_name) char *dup_execname = NULL, *base = NULL; uint8_t ret = 0; - dup_execname = strdup (exec_name); + dup_execname = gf_strdup (exec_name); base = basename (dup_execname); if (!strncmp (base, "glusterfsd", 10)) { ret = GF_SERVER_PROCESS; + } else if (!strncmp (base, "glusterd", 8)) { + ret = GF_GLUSTERD_PROCESS; } else { ret = GF_CLIENT_PROCESS; } - free (dup_execname); + GF_FREE (dup_execname); return ret; } -int -set_log_file_path (cmd_args_t *cmd_args) + +static int +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] = '-'; - } - ret = asprintf (&cmd_args->log_file, - DEFAULT_LOG_FILE_DIRECTORY "/%s.log", - tmp_str); - if (-1 == ret) { - gf_log ("glusterfsd", GF_LOG_ERROR, - "asprintf failed while setting up log-file"); + cmd_args_t *cmd_args = NULL; + struct rlimit lim = {0, }; + int ret = -1; + + 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; + } + + 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; + } + + 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; + } + + 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; + } + + INIT_LIST_HEAD (&ctx->pool->all_frames); + LOCK_INIT (&ctx->pool->lock); + + /* 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->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->dict_pool = mem_pool_new (dict_t, GF_MEMPOOL_COUNT_OF_DICT_T); + if (!ctx->dict_pool) + goto out; + + ctx->dict_pair_pool = mem_pool_new (data_pair_t, + GF_MEMPOOL_COUNT_OF_DATA_PAIR_T); + if (!ctx->dict_pair_pool) + goto out; + + 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->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); + + 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); } - goto done; - } - - if (cmd_args->volume_file) { - j = 0; - i = 0; - if (cmd_args->volume_file[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] == '/') - tmp_str[j] = '-'; + 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, 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 = gf_set_log_file_path (cmd_args); + if (ret == -1) { + fprintf (stderr, "ERROR: failed to set the log file path\n"); + return -1; } - ret = asprintf (&cmd_args->log_file, - DEFAULT_LOG_FILE_DIRECTORY "/%s.log", - tmp_str); - if (-1 == ret) { - gf_log ("glusterfsd", GF_LOG_ERROR, - "asprintf failed while setting up log-file"); + } + +#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'; } - goto done; } + ptr = ident; +#endif - 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 = 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"); + 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; + } + + gf_log_set_loglevel (cmd_args->log_level); + + 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; } } -done: - return ret; } int -main (int argc, char *argv[]) +parse_cmdline (int argc, char *argv[], 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; - - ret = glusterfs_globals_init (); - if (ret) - return ret; + 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; - 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_attribute_timeout = -1; - - 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->log_file = "/dev/stderr"; cmd_args->no_daemon_mode = ENABLE_NO_DAEMON_MODE; } + 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->volume_file == NULL)) { + && (cmd_args->volfile == NULL)) { if (process_mode == GF_SERVER_PROCESS) - cmd_args->volume_file = strdup (DEFAULT_SERVER_VOLUME_FILE); + 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->volume_file = strdup (DEFAULT_CLIENT_VOLUME_FILE); - } - - if (cmd_args->log_file == NULL) { - ret = set_log_file_path (cmd_args); - if (-1 == ret) { - fprintf (stderr, "failed to set the log file path.. " - "exiting\n"); - return -1; + 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; } } - 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 = CALLOC (1, sizeof (call_pool_t)); - ERR_ABORT (ctx->pool); - LOCK_INIT (&pool->lock); - INIT_LIST_HEAD (&pool->all_frames); - - /* 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 */ 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 ()); /* Create symlink to actual log file */ - unlink (cmd_args->log_file); + sys_unlink (cmd_args->log_file); - tmp_logfile_dyn = strdup (tmp_logfile); + tmp_logfile_dyn = gf_strdup (tmp_logfile); tmp_logfilebase = basename (tmp_logfile_dyn); - ret = symlink (tmp_logfilebase, cmd_args->log_file); - if (-1 == ret) { - fprintf (stderr, "symlink of logfile failed"); - } else { - FREE (cmd_args->log_file); - cmd_args->log_file = strdup (tmp_logfile); + ret = sys_symlink (tmp_logfilebase, + cmd_args->log_file); + if (ret == -1) { + fprintf (stderr, "ERROR: symlink of logfile failed\n"); + goto out; } - FREE (tmp_logfile_dyn); + GF_FREE (cmd_args->log_file); + cmd_args->log_file = gf_strdup (tmp_logfile); + + GF_FREE (tmp_logfile_dyn); } } - gf_global_variable_init (); +#ifdef GF_DARWIN_HOST_OS + if (cmd_args->mount_point) + cmd_args->mac_compat = GF_OPTION_DEFERRED; +#endif - if (gf_log_init (cmd_args->log_file) == -1) { - fprintf (stderr, - "failed to open logfile %s. exiting\n", - cmd_args->log_file); - return -1; + ret = 0; +out: + return ret; +} + + +int +glusterfs_pidfile_setup (glusterfs_ctx_t *ctx) +{ + cmd_args_t *cmd_args = NULL; + int ret = -1; + FILE *pidfp = NULL; + + 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)); + goto out; } - 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)); + 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)); + goto out; } -#ifdef DEBUG - mtrace (); -#endif - 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); + gf_log ("glusterfsd", GF_LOG_TRACE, + "pidfile %s lock acquired", + 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; + } - /* This is used to dump details */ - /* signal (SIGUSR2, (sighandler_t) glusterfs_stats); */ + ctx->pidfp = pidfp; - /* 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; + 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 = &ctx->cmd_args; + + if (!ctx->pidfp) + return 0; + + gf_log ("glusterfsd", GF_LOG_TRACE, + "pidfile %s cleanup", + cmd_args->pid_file); + + if (ctx->cmd_args.pid_file) { + unlink (ctx->cmd_args.pid_file); + ctx->cmd_args.pid_file = NULL; } - 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; + lockf (fileno (ctx->pidfp), F_ULOCK, 0); + fclose (ctx->pidfp); + ctx->pidfp = NULL; + + return 0; +} + +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; } - 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; + ret = ftruncate (fileno (pidfp), 0); + if (ret) { + gf_log ("glusterfsd", GF_LOG_ERROR, + "pidfile %s truncation failed", + cmd_args->pid_file); + return ret; + } - 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; - } + 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; + } + + 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; + + + sigemptyset (&set); + 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) + continue; + + + switch (sig) { + case SIGINT: + case SIGTERM: + cleanup_and_exit (sig); + break; + case SIGHUP: + reincarnate (sig); + break; + case SIGUSR1: + gf_proc_dump_info (sig, glusterfsd_ctx); + break; + case SIGUSR2: + gf_latency_toggle (sig, glusterfsd_ctx); + break; + default: + + break; } + } - xl_count++; /* Getting this value right is very important */ - trav = trav->next; + return NULL; +} + + +void +glusterfsd_print_trace (int signum) +{ + gf_print_trace (signum, glusterfsd_ctx); +} + + +int +glusterfs_signals_setup (glusterfs_ctx_t *ctx) +{ + sigset_t set; + int ret = 0; + + sigemptyset (&set); + + /* common setting for all threads */ + 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, 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) { + 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); + if (ret) { + /* + TODO: + 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; } - ctx->xl_count = xl_count + 1; + return ret; +} + - 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 +daemonize (glusterfs_ctx_t *ctx) +{ + 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) + goto out; + + if (cmd_args->no_daemon_mode) + goto postfork; + + if (cmd_args->debug_mode) + goto postfork; + + 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; } - if (!fuse_volume_found && (cmd_args->mount_point != NULL)) { - /* Check for read-only option and add a read-only translator */ - if (cmd_args->read_only) { - if ((graph = _add_ro_volume (graph)) == NULL) { - /* _add_fuse_mount() prints necessary - * error message - */ - fprintf (stderr, - "failed to load 'ro' option. exiting\n"); - gf_log ("glusterfs", GF_LOG_ERROR, "exiting"); - return -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]); } - 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; + + 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); } - /* 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; - } +postfork: + ret = glusterfs_pidfile_update (ctx); + if (ret) + goto out; - /* 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; - } + glusterfs_signals_setup (ctx); +out: + return ret; +} + + +int +glusterfs_process_volfp (glusterfs_ctx_t *ctx, FILE *fp) +{ + glusterfs_graph_t *graph = NULL; + int ret = -1; + xlator_t *trav = NULL; + + graph = glusterfs_graph_construct (fp); + if (!graph) { + gf_log ("", GF_LOG_ERROR, "failed to construct the graph"); + goto out; + } - /* update pid file, if given */ - fprintf (ctx->pidfp, "%d\n", getpid ()); - fflush (ctx->pidfp); - /* we close pid file on exit */ + 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; } - } else { - /* - * Need to have this line twice because PID is different - * in daemon and non-daemon cases. - */ + } - _gf_dump_details (argc, argv); + ret = glusterfs_graph_prepare (graph, ctx); + if (ret) { + glusterfs_graph_destroy (graph); + goto out; } - gf_log_volume_file (ctx->specfp); + ret = glusterfs_graph_activate (graph, ctx); - gf_log ("glusterfs", GF_LOG_DEBUG, - "running in pid %d", getpid ()); + if (ret) { + glusterfs_graph_destroy (graph); + goto out; + } - gf_timer_registry_init (ctx); + gf_log_dump_graph (fp, graph); - /* 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; + 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); } - /* Send PARENT_UP notify to all the translators now */ - glusterfs_graph_parent_up (graph); + return ret; +} - gf_log ("glusterfs", GF_LOG_NORMAL, "Successfully started"); - 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; +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; + } - if (cmd_args->log_server) { - gf_log_central_init (ctx, cmd_args->log_server, - "socket", cmd_args->log_server_port); + fp = get_volfp (ctx); + + if (!fp) { + gf_log ("glusterfsd", GF_LOG_ERROR, + "Cannot reach volume specification file"); + ret = -1; + goto out; } - event_dispatch (ctx->event_pool); + ret = glusterfs_process_volfp (ctx, fp); + if (ret) + goto out; - return 0; +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 (ctx); + if (ret) + return ret; + + THIS->ctx = ctx; + + ret = glusterfs_ctx_defaults_init (ctx); + if (ret) + goto out; + + ret = parse_cmdline (argc, argv, ctx); + if (ret) + goto out; + + 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); + if (ret) + goto out; + + ret = daemonize (ctx); + 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; + + ret = event_dispatch (ctx->event_pool); + +out: +// glusterfs_ctx_destroy (ctx); + + return ret; } |