diff options
Diffstat (limited to 'glusterfsd/src/glusterfsd.c')
| -rw-r--r-- | glusterfsd/src/glusterfsd.c | 754 |
1 files changed, 332 insertions, 422 deletions
diff --git a/glusterfsd/src/glusterfsd.c b/glusterfsd/src/glusterfsd.c index 771af423ea5..dae41f33fef 100644 --- a/glusterfsd/src/glusterfsd.c +++ b/glusterfsd/src/glusterfsd.c @@ -47,38 +47,32 @@ #include <malloc.h> #endif -#ifdef HAVE_MALLOC_STATS -#ifdef DEBUG -#include <mcheck.h> -#endif -#endif - -#include "xlator.h" -#include "glusterfs.h" -#include "compat.h" -#include "logging.h" +#include <glusterfs/xlator.h> +#include <glusterfs/glusterfs.h> +#include <glusterfs/compat.h> +#include <glusterfs/logging.h> #include "glusterfsd-messages.h" -#include "dict.h" -#include "list.h" -#include "timer.h" +#include <glusterfs/dict.h> +#include <glusterfs/list.h> +#include <glusterfs/timer.h> #include "glusterfsd.h" -#include "revision.h" -#include "common-utils.h" -#include "gf-event.h" -#include "statedump.h" -#include "latency.h" +#include <glusterfs/revision.h> +#include <glusterfs/common-utils.h> +#include <glusterfs/gf-event.h> +#include <glusterfs/statedump.h> +#include <glusterfs/latency.h> #include "glusterfsd-mem-types.h" -#include "syscall.h" -#include "call-stub.h" +#include <glusterfs/syscall.h> +#include <glusterfs/call-stub.h> #include <fnmatch.h> #include "rpc-clnt.h" -#include "syncop.h" -#include "client_t.h" +#include <glusterfs/syncop.h> +#include <glusterfs/client_t.h> #include "netgroups.h" #include "exports.h" -#include "monitoring.h" +#include <glusterfs/monitoring.h> -#include "daemon.h" +#include <glusterfs/daemon.h> /* using argp for command line parsing */ static char gf_doc[] = ""; @@ -198,12 +192,13 @@ static struct argp_option gf_options[] = { {"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"}, + "Do not purge the cache on file open [default: false]"}, {"global-timer-wheel", ARGP_GLOBAL_TIMER_WHEEL, "BOOL", OPTION_ARG_OPTIONAL, "Instantiate process global timer-wheel"}, {"thin-client", ARGP_THIN_CLIENT_KEY, 0, 0, "Enables thin mount and connects via gfproxyd daemon"}, - + {"global-threading", ARGP_GLOBAL_THREADING_KEY, "BOOL", OPTION_ARG_OPTIONAL, + "Use the global thread pool instead of io-threads"}, {0, 0, 0, 0, "Fuse options:"}, {"direct-io-mode", ARGP_DIRECT_IO_MODE_KEY, "BOOL|auto", OPTION_ARG_OPTIONAL, "Specify direct I/O strategy [default: \"auto\"]"}, @@ -219,6 +214,12 @@ static struct argp_option gf_options[] = { "[default: 300]"}, {"resolve-gids", ARGP_RESOLVE_GIDS_KEY, 0, 0, "Resolve all auxiliary groups in fuse translator (max 32 otherwise)"}, + {"lru-limit", ARGP_FUSE_LRU_LIMIT_KEY, "N", 0, + "Set fuse module's limit for number of inodes kept in LRU list to N " + "[default: 65536]"}, + {"invalidate-limit", ARGP_FUSE_INVALIDATE_LIMIT_KEY, "N", 0, + "Suspend inode invalidations implied by 'lru-limit' if the number of " + "outstanding invalidations reaches N"}, {"background-qlen", ARGP_FUSE_BACKGROUND_QLEN_KEY, "N", 0, "Set fuse module's background queue length to N " "[default: 64]"}, @@ -267,6 +268,15 @@ static struct argp_option gf_options[] = { {"fuse-flush-handle-interrupt", ARGP_FUSE_FLUSH_HANDLE_INTERRUPT_KEY, "BOOL", OPTION_ARG_OPTIONAL | OPTION_HIDDEN, "handle interrupt in fuse FLUSH handler"}, + {"auto-invalidation", ARGP_FUSE_AUTO_INVAL_KEY, "BOOL", OPTION_ARG_OPTIONAL, + "controls whether fuse-kernel can auto-invalidate " + "attribute, dentry and page-cache. " + "Disable this only if same files/directories are not accessed across " + "two different mounts concurrently [default: \"on\"]"}, + {"fuse-dev-eperm-ratelimit-ns", ARGP_FUSE_DEV_EPERM_RATELIMIT_NS_KEY, + "OPTIONS", OPTION_HIDDEN, + "rate limit reading from fuse device upon EPERM failure"}, + {"brick-mux", ARGP_BRICK_MUX_KEY, 0, 0, "Enable brick mux. "}, {0, 0, 0, 0, "Miscellaneous Options:"}, { 0, @@ -282,8 +292,12 @@ int glusterfs_mgmt_init(glusterfs_ctx_t *ctx); int glusterfs_listener_init(glusterfs_ctx_t *ctx); -int -glusterfs_listener_stop(glusterfs_ctx_t *ctx); + +#define DICT_SET_VAL(method, dict, key, val, msgid) \ + if (method(dict, key, val)) { \ + gf_smsg("glusterfsd", GF_LOG_ERROR, 0, msgid, "key=%s", key); \ + goto err; \ + } static int set_fuse_mount_options(glusterfs_ctx_t *ctx, dict_t *options) @@ -305,172 +319,97 @@ set_fuse_mount_options(glusterfs_ctx_t *ctx, dict_t *options) ret = gf_asprintf(&mount_point, "%s/%s", cwd, cmd_args->mount_point); if (ret == -1) { - gf_msg("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_1, - "Could not create absolute mountpoint " - "path"); + gf_smsg("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_1, + "gf_asprintf failed", NULL); goto err; } } else { - gf_msg("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_2, - "Could not get current working directory"); + gf_smsg("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_2, + "getcwd failed", NULL); 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_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_3, - "failed to set mount-point to options dictionary"); - goto err; + } else { + mount_point = gf_strdup(cmd_args->mount_point); } + DICT_SET_VAL(dict_set_dynstr_sizen, options, ZR_MOUNTPOINT_OPT, mount_point, + glusterfsd_msg_3); 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_msg("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_4, - "failed to set dict value " - "for key " ZR_ATTR_TIMEOUT_OPT); - goto err; - } + DICT_SET_VAL(dict_set_double, options, ZR_ATTR_TIMEOUT_OPT, + cmd_args->fuse_attribute_timeout, glusterfsd_msg_3); } 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_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4, - "failed to set dict value for key " ZR_ENTRY_TIMEOUT_OPT); - goto err; - } + DICT_SET_VAL(dict_set_double, options, ZR_ENTRY_TIMEOUT_OPT, + cmd_args->fuse_entry_timeout, glusterfsd_msg_3); } 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_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4, - "failed to set dict value for key " ZR_NEGATIVE_TIMEOUT_OPT); - goto err; - } + DICT_SET_VAL(dict_set_double, options, ZR_NEGATIVE_TIMEOUT_OPT, + cmd_args->fuse_negative_timeout, glusterfsd_msg_3); } if (cmd_args->client_pid_set) { - ret = dict_set_int32(options, "client-pid", cmd_args->client_pid); - if (ret < 0) { - gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4, - "failed to set dict value for key client-pid"); - goto err; - } + DICT_SET_VAL(dict_set_int32_sizen, options, "client-pid", + cmd_args->client_pid, glusterfsd_msg_3); } if (cmd_args->uid_map_root) { - ret = dict_set_int32(options, "uid-map-root", cmd_args->uid_map_root); - if (ret < 0) { - gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4, - "failed to set dict value for key " - "uid-map-root"); - goto err; - } + DICT_SET_VAL(dict_set_int32_sizen, options, "uid-map-root", + cmd_args->uid_map_root, glusterfsd_msg_3); } if (cmd_args->volfile_check) { - ret = dict_set_int32(options, ZR_STRICT_VOLFILE_CHECK, - cmd_args->volfile_check); - if (ret < 0) { - gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4, - "failed to set dict value for key " ZR_STRICT_VOLFILE_CHECK); - goto err; - } + DICT_SET_VAL(dict_set_int32_sizen, options, ZR_STRICT_VOLFILE_CHECK, + cmd_args->volfile_check, glusterfsd_msg_3); } if (cmd_args->dump_fuse) { - ret = dict_set_static_ptr(options, ZR_DUMP_FUSE, cmd_args->dump_fuse); - if (ret < 0) { - gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4, - "failed to set dict value for key " ZR_DUMP_FUSE); - goto err; - } + DICT_SET_VAL(dict_set_static_ptr, options, ZR_DUMP_FUSE, + cmd_args->dump_fuse, glusterfsd_msg_3); } if (cmd_args->acl) { - ret = dict_set_static_ptr(options, "acl", "on"); - if (ret < 0) { - gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4, - "failed to set dict value for key acl"); - goto err; - } + DICT_SET_VAL(dict_set_static_ptr, options, "acl", "on", + glusterfsd_msg_3); } if (cmd_args->selinux) { - ret = dict_set_static_ptr(options, "selinux", "on"); - if (ret < 0) { - gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4, - "failed to set dict value for key selinux"); - goto err; - } + DICT_SET_VAL(dict_set_static_ptr, options, "selinux", "on", + glusterfsd_msg_3); } if (cmd_args->capability) { - ret = dict_set_static_ptr(options, "capability", "on"); - if (ret < 0) { - gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4, - "failed to set dict value for key capability"); - goto err; - } + DICT_SET_VAL(dict_set_static_ptr, options, "capability", "on", + glusterfsd_msg_3); } if (cmd_args->aux_gfid_mount) { - ret = dict_set_static_ptr(options, "virtual-gfid-access", "on"); - if (ret < 0) { - gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4, - "failed to set dict value for key " - "aux-gfid-mount"); - goto err; - } + DICT_SET_VAL(dict_set_static_ptr, options, "virtual-gfid-access", "on", + glusterfsd_msg_3); } if (cmd_args->enable_ino32) { - ret = dict_set_static_ptr(options, "enable-ino32", "on"); - if (ret < 0) { - gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4, - "failed to set dict value for key " - "enable-ino32"); - goto err; - } + DICT_SET_VAL(dict_set_static_ptr, options, "enable-ino32", "on", + glusterfsd_msg_3); } if (cmd_args->read_only) { - ret = dict_set_static_ptr(options, "read-only", "on"); - if (ret < 0) { - gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4, - "failed to set dict value for key read-only"); - goto err; - } + DICT_SET_VAL(dict_set_static_ptr, options, "read-only", "on", + glusterfsd_msg_3); } switch (cmd_args->fopen_keep_cache) { case GF_OPTION_ENABLE: - ret = dict_set_static_ptr(options, "fopen-keep-cache", "on"); - if (ret < 0) { - gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4, - "failed to set dict value for key " - "fopen-keep-cache"); - goto err; - } + + DICT_SET_VAL(dict_set_static_ptr, options, "fopen-keep-cache", "on", + glusterfsd_msg_3); break; case GF_OPTION_DISABLE: - ret = dict_set_static_ptr(options, "fopen-keep-cache", "off"); - if (ret < 0) { - gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4, - "failed to set dict value for key " - "fopen-keep-cache"); - goto err; - } + DICT_SET_VAL(dict_set_static_ptr, options, "fopen-keep-cache", + "off", glusterfsd_msg_3); break; - case GF_OPTION_DEFERRED: /* default */ default: gf_msg_debug("glusterfsd", 0, "fopen-keep-cache mode %d", cmd_args->fopen_keep_cache); @@ -478,63 +417,43 @@ set_fuse_mount_options(glusterfs_ctx_t *ctx, dict_t *options) } if (cmd_args->gid_timeout_set) { - ret = dict_set_int32(options, "gid-timeout", cmd_args->gid_timeout); - if (ret < 0) { - gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4, - "failed to set dict value for key gid-timeout"); - goto err; - } + DICT_SET_VAL(dict_set_int32_sizen, options, "gid-timeout", + cmd_args->gid_timeout, glusterfsd_msg_3); } if (cmd_args->resolve_gids) { - ret = dict_set_static_ptr(options, "resolve-gids", "on"); - if (ret < 0) { - gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4, - "failed to set dict value for key " - "resolve-gids"); - goto err; - } + DICT_SET_VAL(dict_set_static_ptr, options, "resolve-gids", "on", + glusterfsd_msg_3); + } + + if (cmd_args->lru_limit >= 0) { + DICT_SET_VAL(dict_set_int32_sizen, options, "lru-limit", + cmd_args->lru_limit, glusterfsd_msg_3); + } + + if (cmd_args->invalidate_limit >= 0) { + DICT_SET_VAL(dict_set_int32_sizen, options, "invalidate-limit", + cmd_args->invalidate_limit, glusterfsd_msg_3); } if (cmd_args->background_qlen) { - ret = dict_set_int32(options, "background-qlen", - cmd_args->background_qlen); - if (ret < 0) { - gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4, - "failed to set dict value for key " - "background-qlen"); - goto err; - } + DICT_SET_VAL(dict_set_int32_sizen, options, "background-qlen", + cmd_args->background_qlen, glusterfsd_msg_3); } if (cmd_args->congestion_threshold) { - ret = dict_set_int32(options, "congestion-threshold", - cmd_args->congestion_threshold); - if (ret < 0) { - gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4, - "failed to set dict value for key " - "congestion-threshold"); - goto err; - } + DICT_SET_VAL(dict_set_int32_sizen, options, "congestion-threshold", + cmd_args->congestion_threshold, glusterfsd_msg_3); } 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_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_5, - "failed to set 'disable' for key " ZR_DIRECT_IO_OPT); - goto err; - } + DICT_SET_VAL(dict_set_static_ptr, options, ZR_DIRECT_IO_OPT, + "disable", glusterfsd_msg_3); break; case GF_OPTION_ENABLE: /* enable */ - ret = dict_set_static_ptr(options, ZR_DIRECT_IO_OPT, "enable"); - if (ret < 0) { - gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_6, - "failed to set 'enable' for key " ZR_DIRECT_IO_OPT); - goto err; - } + DICT_SET_VAL(dict_set_static_ptr, options, ZR_DIRECT_IO_OPT, + "enable", glusterfsd_msg_3); break; - case GF_OPTION_DEFERRED: /* auto */ default: gf_msg_debug("glusterfsd", 0, "fuse direct io type %d", cmd_args->fuse_direct_io_mode); @@ -543,134 +462,83 @@ set_fuse_mount_options(glusterfs_ctx_t *ctx, dict_t *options) switch (cmd_args->no_root_squash) { case GF_OPTION_ENABLE: /* enable */ - ret = dict_set_static_ptr(options, "no-root-squash", "enable"); - if (ret < 0) { - gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_6, - "failed to set 'enable' for key " - "no-root-squash"); - goto err; - } + DICT_SET_VAL(dict_set_static_ptr, options, "no-root-squash", + "enable", glusterfsd_msg_3); break; - case GF_OPTION_DISABLE: /* disable/default */ default: - ret = dict_set_static_ptr(options, "no-root-squash", "disable"); - if (ret < 0) { - gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_5, - "failed to set 'disable' for key " - "no-root-squash"); - goto err; - } + DICT_SET_VAL(dict_set_static_ptr, options, "no-root-squash", + "disable", glusterfsd_msg_3); gf_msg_debug("glusterfsd", 0, "fuse no-root-squash mode %d", cmd_args->no_root_squash); break; } if (!cmd_args->no_daemon_mode) { - ret = dict_set_static_ptr(options, "sync-to-mount", "enable"); - if (ret < 0) { - gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4, - "failed to set dict value for key sync-mtab"); - goto err; - } + DICT_SET_VAL(dict_set_static_ptr, options, "sync-to-mount", "enable", + glusterfsd_msg_3); } if (cmd_args->use_readdirp) { - ret = dict_set_str(options, "use-readdirp", cmd_args->use_readdirp); - if (ret < 0) { - gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4, - "failed to set dict value for key " - "use-readdirp"); - goto err; - } + DICT_SET_VAL(dict_set_static_ptr, options, "use-readdirp", + cmd_args->use_readdirp, glusterfsd_msg_3); } if (cmd_args->event_history) { ret = dict_set_str(options, "event-history", cmd_args->event_history); - if (ret < 0) { - gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4, - "failed to set dict value for key " - "event-history"); - goto err; - } + DICT_SET_VAL(dict_set_static_ptr, options, "event-history", + cmd_args->event_history, glusterfsd_msg_3); } if (cmd_args->thin_client) { - ret = dict_set_static_ptr(options, "thin-client", "on"); - if (ret < 0) { - gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4, - "failed to set dict value for key " - "thin-client"); - goto err; - } + DICT_SET_VAL(dict_set_static_ptr, options, "thin-client", "on", + glusterfsd_msg_3); } if (cmd_args->reader_thread_count) { - ret = dict_set_uint32(options, "reader-thread-count", - cmd_args->reader_thread_count); - if (ret < 0) { - gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4, - "failed to set dict value for key " - "reader-thread-count"); - goto err; - } + DICT_SET_VAL(dict_set_uint32, options, "reader-thread-count", + cmd_args->reader_thread_count, glusterfsd_msg_3); } + + DICT_SET_VAL(dict_set_uint32, options, "auto-invalidation", + cmd_args->fuse_auto_inval, glusterfsd_msg_3); + switch (cmd_args->kernel_writeback_cache) { case GF_OPTION_ENABLE: - ret = dict_set_static_ptr(options, "kernel-writeback-cache", "on"); - if (ret < 0) { - gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4, - "failed to set dict value for key " - "kernel-writeback-cache"); - goto err; - } + DICT_SET_VAL(dict_set_static_ptr, options, "kernel-writeback-cache", + "on", glusterfsd_msg_3); break; case GF_OPTION_DISABLE: - ret = dict_set_static_ptr(options, "kernel-writeback-cache", "off"); - if (ret < 0) { - gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4, - "failed to set dict value for key " - "kernel-writeback-cache"); - goto err; - } + DICT_SET_VAL(dict_set_static_ptr, options, "kernel-writeback-cache", + "off", glusterfsd_msg_3); break; - case GF_OPTION_DEFERRED: /* default */ default: gf_msg_debug("glusterfsd", 0, "kernel-writeback-cache mode %d", cmd_args->kernel_writeback_cache); break; } if (cmd_args->attr_times_granularity) { - ret = dict_set_uint32(options, "attr-times-granularity", - cmd_args->attr_times_granularity); - if (ret < 0) { - gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4, - "failed to set dict value for key " - "attr-times-granularity"); - goto err; - } + DICT_SET_VAL(dict_set_uint32, options, "attr-times-granularity", + cmd_args->attr_times_granularity, glusterfsd_msg_3); } switch (cmd_args->fuse_flush_handle_interrupt) { case GF_OPTION_ENABLE: - ret = dict_set_static_ptr(options, "flush-handle-interrupt", "on"); - if (ret < 0) { - gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4, - "failed to set dict value for key " - "flush-handle-interrupt"); - goto err; - } + DICT_SET_VAL(dict_set_static_ptr, options, "flush-handle-interrupt", + "on", glusterfsd_msg_3); break; case GF_OPTION_DISABLE: - ret = dict_set_static_ptr(options, "flush-handle-interrupt", "off"); - if (ret < 0) { - gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4, - "failed to set dict value for key " - "flush-handle-interrupt"); - goto err; - } + DICT_SET_VAL(dict_set_static_ptr, options, "flush-handle-interrupt", + "off", glusterfsd_msg_3); break; - case GF_OPTION_DEFERRED: /* default */ default: gf_msg_debug("glusterfsd", 0, "fuse-flush-handle-interrupt mode %d", cmd_args->fuse_flush_handle_interrupt); break; } + if (cmd_args->global_threading) { + DICT_SET_VAL(dict_set_static_ptr, options, "global-threading", "on", + glusterfsd_msg_3); + } + if (cmd_args->fuse_dev_eperm_ratelimit_ns) { + DICT_SET_VAL(dict_set_uint32, options, "fuse-dev-eperm-ratelimit-ns", + cmd_args->fuse_dev_eperm_ratelimit_ns, glusterfsd_msg_3); + } ret = 0; err: @@ -685,7 +553,6 @@ create_fuse_mount(glusterfs_ctx_t *ctx) xlator_t *master = NULL; cmd_args = &ctx->cmd_args; - if (!cmd_args->mount_point) { gf_msg_trace("glusterfsd", 0, "mount point not found, not a client process"); @@ -693,8 +560,7 @@ create_fuse_mount(glusterfs_ctx_t *ctx) } if (ctx->process_mode != GF_CLIENT_PROCESS) { - gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_7, - "Not a client process, not performing mount operation"); + gf_smsg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_7, NULL); return -1; } @@ -707,13 +573,13 @@ create_fuse_mount(glusterfs_ctx_t *ctx) goto err; if (xlator_set_type(master, "mount/fuse") == -1) { - gf_msg("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_8, - "MOUNT-POINT %s initialization failed", cmd_args->mount_point); + gf_smsg("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_8, + "MOUNT-POINT=%s", cmd_args->mount_point, NULL); goto err; } master->ctx = ctx; - master->options = get_new_dict(); + master->options = dict_new(); if (!master->options) goto err; @@ -725,8 +591,8 @@ create_fuse_mount(glusterfs_ctx_t *ctx) ret = dict_set_static_ptr(master->options, ZR_FUSE_MOUNTOPTS, cmd_args->fuse_mountopts); if (ret < 0) { - gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_4, - "failed to set dict value for key " ZR_FUSE_MOUNTOPTS); + gf_smsg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_3, + ZR_FUSE_MOUNTOPTS, NULL); goto err; } } @@ -752,23 +618,14 @@ err: static FILE * get_volfp(glusterfs_ctx_t *ctx) { - int ret = 0; cmd_args_t *cmd_args = NULL; FILE *specfp = NULL; - struct stat statbuf; cmd_args = &ctx->cmd_args; - ret = sys_lstat(cmd_args->volfile, &statbuf); - if (ret == -1) { - gf_msg("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_9, - "loading volume file %s failed", cmd_args->volfile); - return NULL; - } - if ((specfp = fopen(cmd_args->volfile, "r")) == NULL) { - gf_msg("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_9, - "loading volume file %s failed", cmd_args->volfile); + gf_smsg("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_9, + "volume_file=%s", cmd_args->volfile, NULL); return NULL; } @@ -824,8 +681,7 @@ gf_remember_xlator_option(char *arg) dot = strchr(arg, '.'); if (!dot) { - gf_msg("", GF_LOG_WARNING, 0, glusterfsd_msg_10, - "xlator option %s is invalid", arg); + gf_smsg("", GF_LOG_WARNING, 0, glusterfsd_msg_10, "arg=%s", arg, NULL); goto out; } @@ -838,8 +694,7 @@ gf_remember_xlator_option(char *arg) equals = strchr(arg, '='); if (!equals) { - gf_msg("", GF_LOG_WARNING, 0, glusterfsd_msg_10, - "xlator option %s is invalid", arg); + gf_smsg("", GF_LOG_WARNING, 0, glusterfsd_msg_10, "arg=%s", arg, NULL); goto out; } @@ -851,8 +706,7 @@ gf_remember_xlator_option(char *arg) option->key[(equals - dot - 1)] = '\0'; if (!*(equals + 1)) { - gf_msg("", GF_LOG_WARNING, 0, glusterfsd_msg_10, - "xlator option %s is invalid", arg); + gf_smsg("", GF_LOG_WARNING, 0, glusterfsd_msg_10, "arg=%s", arg, NULL); goto out; } @@ -1073,6 +927,10 @@ parse_opts(int key, char *arg, struct argp_state *state) cmd_args->thin_client = _gf_true; break; + case ARGP_BRICK_MUX_KEY: + cmd_args->brick_mux = _gf_true; + break; + case ARGP_PID_FILE_KEY: cmd_args->pid_file = gf_strdup(arg); break; @@ -1190,7 +1048,6 @@ parse_opts(int key, char *arg, struct argp_state *state) case ARGP_KEY_ARG: if (state->arg_num >= 1) argp_usage(state); - cmd_args->mount_point = gf_strdup(arg); break; @@ -1203,19 +1060,21 @@ parse_opts(int key, char *arg, struct argp_state *state) 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; + if (arg != NULL) { + 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); } - argp_failure(state, -1, 0, "wrong brick (listen) port %s", - arg); + break; } - break; } argp_failure(state, -1, 0, "unknown brick (listen) port %s", arg); @@ -1257,6 +1116,21 @@ parse_opts(int key, char *arg, struct argp_state *state) cmd_args->resolve_gids = 1; break; + case ARGP_FUSE_LRU_LIMIT_KEY: + if (!gf_string2int32(arg, &cmd_args->lru_limit)) + break; + + argp_failure(state, -1, 0, "unknown LRU limit option %s", arg); + break; + + case ARGP_FUSE_INVALIDATE_LIMIT_KEY: + if (!gf_string2int32(arg, &cmd_args->invalidate_limit)) + break; + + argp_failure(state, -1, 0, "unknown invalidate limit option %s", + arg); + break; + case ARGP_FUSE_BACKGROUND_QLEN_KEY: if (!gf_string2int(arg, &cmd_args->background_qlen)) break; @@ -1464,6 +1338,46 @@ parse_opts(int key, char *arg, struct argp_state *state) "unknown fuse flush handle interrupt setting \"%s\"", arg); break; + + case ARGP_FUSE_AUTO_INVAL_KEY: + if (!arg) + arg = "yes"; + + if (gf_string2boolean(arg, &b) == 0) { + cmd_args->fuse_auto_inval = b; + break; + } + + break; + + case ARGP_GLOBAL_THREADING_KEY: + if (!arg || (*arg == 0)) { + arg = "yes"; + } + + if (gf_string2boolean(arg, &b) == 0) { + cmd_args->global_threading = b; + break; + } + + argp_failure(state, -1, 0, + "Invalid value for global threading \"%s\"", arg); + break; + + case ARGP_FUSE_DEV_EPERM_RATELIMIT_NS_KEY: + if (gf_string2uint32(arg, &cmd_args->fuse_dev_eperm_ratelimit_ns)) { + argp_failure(state, -1, 0, + "Non-numerical value for " + "'fuse-dev-eperm-ratelimit-ns' option %s", + arg); + } else if (cmd_args->fuse_dev_eperm_ratelimit_ns > 1000000000) { + argp_failure(state, -1, 0, + "Invalid 'fuse-dev-eperm-ratelimit-ns' value %s. " + "Valid range: [\"0, 1000000000\"]", + arg); + } + + break; } return 0; } @@ -1481,11 +1395,6 @@ should_call_fini(glusterfs_ctx_t *ctx, xlator_t *trav) return _gf_true; } - /* This is the only one known to be safe in glusterfsd. */ - if (!strcmp(trav->type, "experimental/fdl")) { - return _gf_true; - } - return _gf_false; } @@ -1574,11 +1483,20 @@ cleanup_and_exit(int signum) #endif trav = NULL; + + /* previously we were releasing the cleanup mutex lock before the + process exit. As we are releasing the cleanup mutex lock, before + the process can exit some other thread which is blocked on + cleanup mutex lock is acquiring the cleanup mutex lock and + trying to acquire some resources which are already freed as a + part of cleanup. To avoid this, we are exiting the process without + releasing the cleanup mutex lock. This will not cause any lock + related issues as the process which acquired the lock is going down + */ + /* NOTE: Only the least significant 8 bits i.e (signum & 255) + will be available to parent process on calling exit() */ + exit(abs(signum)); } - pthread_mutex_unlock(&ctx->cleanup_lock); - /* NOTE: Only the least significant 8 bits i.e (signum & 255) - will be available to parent process on calling exit() */ - exit(abs(signum)); } static void @@ -1591,22 +1509,18 @@ reincarnate(int signum) ctx = glusterfsd_ctx; cmd_args = &ctx->cmd_args; + gf_msg_trace("gluster", 0, "received reincarnate request (sig:HUP)"); + if (cmd_args->volfile_server) { - gf_msg("glusterfsd", GF_LOG_INFO, 0, glusterfsd_msg_11, - "Fetching the volume file from server..."); + gf_smsg("glusterfsd", GF_LOG_INFO, 0, glusterfsd_msg_11, NULL); ret = glusterfs_volfile_fetch(ctx); - } else { - gf_msg_debug("glusterfsd", 0, - "Not reloading volume specification file" - " on SIGHUP"); } /* Also, SIGHUP should do logrotate */ gf_log_logrotate(1); if (ret < 0) - gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_12, - "volume initialization failed."); + gf_smsg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_12, NULL); return; } @@ -1658,8 +1572,7 @@ glusterfs_ctx_defaults_init(glusterfs_ctx_t *ctx) ret = xlator_mem_acct_init(THIS, gfd_mt_end); if (ret != 0) { - gf_msg(THIS->name, GF_LOG_CRITICAL, 0, glusterfsd_msg_34, - "memory accounting init failed."); + gf_smsg(THIS->name, GF_LOG_CRITICAL, 0, glusterfsd_msg_34, NULL); return ret; } @@ -1673,8 +1586,7 @@ glusterfs_ctx_defaults_init(glusterfs_ctx_t *ctx) ctx->process_uuid = generate_glusterfs_ctx_id(); if (!ctx->process_uuid) { - gf_msg("", GF_LOG_CRITICAL, 0, glusterfsd_msg_13, - "ERROR: glusterfs uuid generation failed"); + gf_smsg("", GF_LOG_CRITICAL, 0, glusterfsd_msg_13, NULL); goto out; } @@ -1682,23 +1594,20 @@ glusterfs_ctx_defaults_init(glusterfs_ctx_t *ctx) ctx->iobuf_pool = iobuf_pool_new(); if (!ctx->iobuf_pool) { - gf_msg("", GF_LOG_CRITICAL, 0, glusterfsd_msg_14, - "ERROR: glusterfs iobuf pool creation failed"); + gf_smsg("", GF_LOG_CRITICAL, 0, glusterfsd_msg_14, "iobuf", NULL); goto out; } - ctx->event_pool = event_pool_new(DEFAULT_EVENT_POOL_SIZE, - STARTING_EVENT_THREADS); + ctx->event_pool = gf_event_pool_new(DEFAULT_EVENT_POOL_SIZE, + STARTING_EVENT_THREADS); if (!ctx->event_pool) { - gf_msg("", GF_LOG_CRITICAL, 0, glusterfsd_msg_14, - "ERROR: glusterfs event pool creation failed"); + gf_smsg("", GF_LOG_CRITICAL, 0, glusterfsd_msg_14, "event", NULL); goto out; } ctx->pool = GF_CALLOC(1, sizeof(call_pool_t), gfd_mt_call_pool_t); if (!ctx->pool) { - gf_msg("", GF_LOG_CRITICAL, 0, glusterfsd_msg_14, - "ERROR: glusterfs call pool creation failed"); + gf_smsg("", GF_LOG_CRITICAL, 0, glusterfsd_msg_14, "call", NULL); goto out; } @@ -1708,22 +1617,19 @@ glusterfs_ctx_defaults_init(glusterfs_ctx_t *ctx) /* 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_msg("", GF_LOG_CRITICAL, 0, glusterfsd_msg_14, - "ERROR: glusterfs frame pool creation failed"); + gf_smsg("", GF_LOG_CRITICAL, 0, glusterfsd_msg_14, "frame", NULL); 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_msg("", GF_LOG_CRITICAL, 0, glusterfsd_msg_14, - "ERROR: glusterfs stack pool creation failed"); + gf_smsg("", GF_LOG_CRITICAL, 0, glusterfsd_msg_14, "stack", NULL); goto out; } ctx->stub_mem_pool = mem_pool_new(call_stub_t, 1024); if (!ctx->stub_mem_pool) { - gf_msg("", GF_LOG_CRITICAL, 0, glusterfsd_msg_14, - "ERROR: glusterfs stub pool creation failed"); + gf_smsg("", GF_LOG_CRITICAL, 0, glusterfsd_msg_14, "stub", NULL); goto out; } @@ -1781,6 +1687,10 @@ glusterfs_ctx_defaults_init(glusterfs_ctx_t *ctx) INIT_LIST_HEAD(&cmd_args->xlator_options); INIT_LIST_HEAD(&cmd_args->volfile_servers); + ctx->pxl_count = 0; + pthread_mutex_init(&ctx->fd_lock, NULL); + pthread_cond_init(&ctx->fd_cond, NULL); + INIT_LIST_HEAD(&ctx->janitor_fds); lim.rlim_cur = RLIM_INFINITY; lim.rlim_max = RLIM_INFINITY; @@ -2069,7 +1979,7 @@ parse_cmdline(int argc, char *argv[], glusterfs_ctx_t *ctx) struct stat stbuf = { 0, }; - char timestr[32]; + char timestr[GF_TIMESTR_SIZE]; char tmp_logfile[1024] = {0}; char *tmp_logfile_dyn = NULL; char *tmp_logfilebase = NULL; @@ -2085,6 +1995,11 @@ parse_cmdline(int argc, char *argv[], glusterfs_ctx_t *ctx) ctx->ssl_cert_depth = glusterfs_read_secure_access_file(); } + /* Need to set lru_limit to below 0 to indicate there was nothing + specified. This is needed as 0 is a valid option, and may not be + default value. */ + cmd_args->lru_limit = -1; + argp_parse(&argp, argc, argv, ARGP_IN_ORDER, NULL, cmd_args); if (cmd_args->print_xlatordir || cmd_args->print_statedumpdir || @@ -2126,9 +2041,7 @@ parse_cmdline(int argc, char *argv[], glusterfs_ctx_t *ctx) /* 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_msg("glusterfs", GF_LOG_CRITICAL, 0, glusterfsd_msg_15, - "ERROR: '--volfile-id' is mandatory if '-s' OR " - "'--volfile-server' option is given"); + gf_smsg("glusterfs", GF_LOG_CRITICAL, 0, glusterfsd_msg_15, NULL); ret = -1; goto out; } @@ -2145,8 +2058,8 @@ parse_cmdline(int argc, char *argv[], glusterfs_ctx_t *ctx) and exit */ ret = sys_stat(cmd_args->volfile, &stbuf); if (ret) { - gf_msg("glusterfs", GF_LOG_CRITICAL, errno, glusterfsd_msg_16, - "ERROR: parsing the volfile failed"); + gf_smsg("glusterfs", GF_LOG_CRITICAL, errno, glusterfsd_msg_16, + NULL); /* argp_usage (argp.) */ fprintf(stderr, "USAGE: %s [options] [mountpoint]\n", argv[0]); goto out; @@ -2170,8 +2083,8 @@ parse_cmdline(int argc, char *argv[], glusterfs_ctx_t *ctx) if (((ret == 0) && (S_ISREG(stbuf.st_mode) || S_ISLNK(stbuf.st_mode))) || (ret == -1)) { - /* Have separate logfile per run */ - gf_time_fmt(timestr, sizeof timestr, time(NULL), gf_timefmt_FT); + /* Have separate logfile per run. */ + gf_time_fmt(timestr, sizeof timestr, gf_time(), gf_timefmt_FT); sprintf(tmp_logfile, "%s.%s.%d", cmd_args->log_file, timestr, getpid()); @@ -2198,9 +2111,7 @@ parse_cmdline(int argc, char *argv[], glusterfs_ctx_t *ctx) compatibility with third party applications */ if (cmd_args->max_connect_attempts) { - gf_msg("glusterfs", GF_LOG_WARNING, 0, glusterfsd_msg_33, - "obsolete option '--volfile-max-fecth-attempts or " - "fetch-attempts' was provided"); + gf_smsg("glusterfs", GF_LOG_WARNING, 0, glusterfsd_msg_33, NULL); } #ifdef GF_DARWIN_HOST_OS @@ -2227,8 +2138,8 @@ glusterfs_pidfile_setup(glusterfs_ctx_t *ctx) pidfp = fopen(cmd_args->pid_file, "a+"); if (!pidfp) { - gf_msg("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_17, - "pidfile %s open failed", cmd_args->pid_file); + gf_smsg("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_17, + "pidfile=%s", cmd_args->pid_file, NULL); goto out; } @@ -2279,29 +2190,29 @@ glusterfs_pidfile_update(glusterfs_ctx_t *ctx, pid_t pid) ret = lockf(fileno(pidfp), F_TLOCK, 0); if (ret) { - gf_msg("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_18, - "pidfile %s lock failed", cmd_args->pid_file); + gf_smsg("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_18, + "pidfile=%s", cmd_args->pid_file, NULL); return ret; } ret = sys_ftruncate(fileno(pidfp), 0); if (ret) { - gf_msg("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_20, - "pidfile %s truncation failed", cmd_args->pid_file); + gf_smsg("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_20, + "pidfile=%s", cmd_args->pid_file, NULL); return ret; } ret = fprintf(pidfp, "%d\n", pid); if (ret <= 0) { - gf_msg("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_21, - "pidfile %s write failed", cmd_args->pid_file); + gf_smsg("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_21, + "pidfile=%s", cmd_args->pid_file, NULL); return ret; } ret = fflush(pidfp); if (ret) { - gf_msg("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_21, - "pidfile %s write failed", cmd_args->pid_file); + gf_smsg("glusterfsd", GF_LOG_ERROR, errno, glusterfsd_msg_21, + "pidfile=%s", cmd_args->pid_file, NULL); return ret; } @@ -2388,10 +2299,13 @@ glusterfs_signals_setup(glusterfs_ctx_t *ctx) sigaddset(&set, SIGUSR1); /* gf_proc_dump_info */ sigaddset(&set, SIGUSR2); + /* Signals needed for asynchronous framework. */ + sigaddset(&set, GF_ASYNC_SIGQUEUE); + sigaddset(&set, GF_ASYNC_SIGCTRL); + ret = pthread_sigmask(SIG_BLOCK, &set, NULL); if (ret) { - gf_msg("glusterfsd", GF_LOG_WARNING, errno, glusterfsd_msg_22, - "failed to execute pthread_sigmask"); + gf_smsg("glusterfsd", GF_LOG_WARNING, errno, glusterfsd_msg_22, NULL); return ret; } @@ -2403,8 +2317,7 @@ glusterfs_signals_setup(glusterfs_ctx_t *ctx) fallback to signals getting handled by other threads. setup the signal handlers */ - gf_msg("glusterfsd", GF_LOG_WARNING, errno, glusterfsd_msg_23, - "failed to create pthread"); + gf_smsg("glusterfsd", GF_LOG_WARNING, errno, glusterfsd_msg_23, NULL); return ret; } @@ -2427,9 +2340,6 @@ daemonize(glusterfs_ctx_t *ctx) goto out; if (cmd_args->no_daemon_mode) { - ret = glusterfs_pidfile_update(ctx, getpid()); - if (ret) - goto out; goto postfork; } @@ -2453,8 +2363,7 @@ daemonize(glusterfs_ctx_t *ctx) sys_close(ctx->daemon_pipe[1]); } - gf_msg("daemonize", GF_LOG_ERROR, errno, glusterfsd_msg_24, - "daemonization failed"); + gf_smsg("daemonize", GF_LOG_ERROR, errno, glusterfsd_msg_24, NULL); goto out; case 0: /* child */ @@ -2475,8 +2384,8 @@ daemonize(glusterfs_ctx_t *ctx) } else { err = cstatus; } - gf_msg("daemonize", GF_LOG_ERROR, 0, glusterfsd_msg_25, - "mount failed"); + gf_smsg("daemonize", GF_LOG_ERROR, 0, glusterfsd_msg_25, + NULL); exit(err); } } @@ -2485,13 +2394,28 @@ daemonize(glusterfs_ctx_t *ctx) will be available to parent process on calling exit() */ if (err) _exit(abs(err)); - ret = glusterfs_pidfile_update(ctx, child_pid); - if (ret) - _exit(1); + + /* Update pid in parent only for glusterd process */ + if (ctx->process_mode == GF_GLUSTERD_PROCESS) { + ret = glusterfs_pidfile_update(ctx, child_pid); + if (ret) + exit(1); + } _exit(0); } postfork: + /* Update pid in child either process_mode is not belong to glusterd + or process is spawned in no daemon mode + */ + if ((ctx->process_mode != GF_GLUSTERD_PROCESS) || + (cmd_args->no_daemon_mode)) { + ret = glusterfs_pidfile_update(ctx, getpid()); + if (ret) + goto out; + } + gf_log("glusterfs", GF_LOG_INFO, "Pid of current running process is %d", + getpid()); ret = gf_log_inject_timer_event(ctx); glusterfs_signals_setup(ctx); @@ -2541,24 +2465,6 @@ out: #endif int -glusterfs_graph_fini(glusterfs_graph_t *graph) -{ - xlator_t *trav = NULL; - - trav = graph->first; - - while (trav) { - if (trav->init_succeeded) { - trav->fini(trav); - trav->init_succeeded = 0; - } - trav = trav->next; - } - - return 0; -} - -int glusterfs_process_volfp(glusterfs_ctx_t *ctx, FILE *fp) { glusterfs_graph_t *graph = NULL; @@ -2570,16 +2476,13 @@ glusterfs_process_volfp(glusterfs_ctx_t *ctx, FILE *fp) graph = glusterfs_graph_construct(fp); if (!graph) { - gf_msg("", GF_LOG_ERROR, 0, glusterfsd_msg_26, - "failed to construct the graph"); + gf_smsg("", GF_LOG_ERROR, 0, glusterfsd_msg_26, NULL); goto out; } for (trav = graph->first; trav; trav = trav->next) { if (strcmp(trav->type, "mount/fuse") == 0) { - gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_27, - "fuse xlator cannot be specified in volume " - "file"); + gf_smsg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_27, NULL); goto out; } } @@ -2618,6 +2521,9 @@ out: xl = graph->first; if ((ctx->active != graph) && (xl && !strcmp(xl->type, "protocol/server"))) { + /* Take dict ref for every graph xlator to avoid dict leak + at the time of graph destroying + */ glusterfs_graph_fini(graph); glusterfs_graph_destroy(graph); } @@ -2657,8 +2563,7 @@ glusterfs_volumes_init(glusterfs_ctx_t *ctx) fp = get_volfp(ctx); if (!fp) { - gf_msg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_28, - "Cannot reach volume specification file"); + gf_smsg("glusterfsd", GF_LOG_ERROR, 0, glusterfsd_msg_28, NULL); ret = -1; goto out; } @@ -2685,14 +2590,11 @@ main(int argc, char *argv[]) }; cmd_args_t *cmd = NULL; - mem_pools_init_early(); - gf_check_and_set_mem_acct(argc, argv); ctx = glusterfs_ctx_new(); if (!ctx) { - gf_msg("glusterfs", GF_LOG_CRITICAL, 0, glusterfsd_msg_29, - "ERROR: glusterfs context not initialized"); + gf_smsg("glusterfs", GF_LOG_CRITICAL, 0, glusterfsd_msg_29, NULL); return ENOMEM; } glusterfsd_ctx = ctx; @@ -2754,6 +2656,12 @@ main(int argc, char *argv[]) if (ret) goto out; + /* set brick_mux mode only for server process */ + if ((ctx->process_mode != GF_SERVER_PROCESS) && cmd->brick_mux) { + gf_smsg("glusterfs", GF_LOG_CRITICAL, 0, glusterfsd_msg_43, NULL); + goto out; + } + /* log the version of glusterfs running here along with the actual command line options. */ { @@ -2765,15 +2673,14 @@ main(int argc, char *argv[]) len = snprintf(cmdlinestr + pos, sizeof(cmdlinestr) - pos, " %s", argv[i]); if ((len <= 0) || (len >= (sizeof(cmdlinestr) - pos))) { - gf_msg("glusterfs", GF_LOG_ERROR, 0, glusterfsd_msg_29, - "failed to create command line string"); + gf_smsg("glusterfs", GF_LOG_ERROR, 0, glusterfsd_msg_029, NULL); ret = -1; goto out; } } - gf_msg(argv[0], GF_LOG_INFO, 0, glusterfsd_msg_30, - "Started running %s version %s (args: %s)", argv[0], - PACKAGE_VERSION, cmdlinestr); + gf_smsg(argv[0], GF_LOG_INFO, 0, glusterfsd_msg_30, "arg=%s", argv[0], + "version=%s", PACKAGE_VERSION, "cmdlinestr=%s", cmdlinestr, + NULL); ctx->cmdlinestr = gf_strdup(cmdlinestr); } @@ -2793,7 +2700,12 @@ main(int argc, char *argv[]) * the parent, but we want to do it as soon as possible after that in * case something else depends on pool allocations. */ - mem_pools_init_late(); + mem_pools_init(); + + ret = gf_async_init(ctx); + if (ret < 0) { + goto out; + } #ifdef GF_LINUX_HOST_OS ret = set_oom_score_adj(ctx); @@ -2803,26 +2715,24 @@ main(int argc, char *argv[]) ctx->env = syncenv_new(0, 0, 0); if (!ctx->env) { - gf_msg("", GF_LOG_ERROR, 0, glusterfsd_msg_31, - "Could not create new sync-environment"); + gf_smsg("", GF_LOG_ERROR, 0, glusterfsd_msg_31, NULL); goto out; } /* do this _after_ daemonize() */ - if (cmd->global_timer_wheel) { - if (!glusterfs_ctx_tw_get(ctx)) { - ret = -1; - goto out; - } + if (!glusterfs_ctx_tw_get(ctx)) { + ret = -1; + goto out; } ret = glusterfs_volumes_init(ctx); if (ret) goto out; - ret = event_dispatch(ctx->event_pool); + ret = gf_event_dispatch(ctx->event_pool); out: - // glusterfs_ctx_destroy (ctx); + // glusterfs_ctx_destroy (ctx); + gf_async_fini(); return ret; } |