diff options
Diffstat (limited to 'glusterfsd')
| -rw-r--r-- | glusterfsd/src/Makefile.am | 12 | ||||
| -rw-r--r-- | glusterfsd/src/glusterfsd-mem-types.h | 22 | ||||
| -rw-r--r-- | glusterfsd/src/glusterfsd-mgmt.c | 911 | ||||
| -rw-r--r-- | glusterfsd/src/glusterfsd.c | 850 | ||||
| -rw-r--r-- | glusterfsd/src/glusterfsd.h | 44 |
5 files changed, 1054 insertions, 785 deletions
diff --git a/glusterfsd/src/Makefile.am b/glusterfsd/src/Makefile.am index 17d7a4a81..05a10dee3 100644 --- a/glusterfsd/src/Makefile.am +++ b/glusterfsd/src/Makefile.am @@ -4,15 +4,17 @@ glusterfsd_SOURCES = glusterfsd.c glusterfsd-mgmt.c glusterfsd_LDADD = $(top_builddir)/libglusterfs/src/libglusterfs.la \ $(top_builddir)/rpc/rpc-lib/src/libgfrpc.la \ $(top_builddir)/rpc/xdr/src/libgfxdr.la \ - $(GF_LDADD) -glusterfsd_LDFLAGS = $(GF_LDFLAGS) $(GF_GLUSTERFS_LDFLAGS) + $(GF_LDADD) $(GF_GLUSTERFS_LIBS) +glusterfsd_LDFLAGS = $(GF_LDFLAGS) noinst_HEADERS = glusterfsd.h glusterfsd-mem-types.h -AM_CFLAGS = -fPIC -Wall -D_FILE_OFFSET_BITS=64 -D_GNU_SOURCE -D$(GF_HOST_OS)\ +AM_CPPFLAGS = $(GF_CPPFLAGS) \ -I$(top_srcdir)/libglusterfs/src -DDATADIR=\"$(localstatedir)\" \ - -DCONFDIR=\"$(sysconfdir)/glusterfs\" $(GF_GLUSTERFS_CFLAGS) \ + -DCONFDIR=\"$(sysconfdir)/glusterfs\" \ -I$(top_srcdir)/rpc/rpc-lib/src -I$(top_srcdir)/rpc/xdr/src +AM_CFLAGS = -Wall $(GF_GLUSTERFS_CFLAGS) + CLEANFILES = $(top_builddir)/libglusterfs/src/libglusterfs.la: @@ -24,7 +26,9 @@ uninstall-local: install-data-local: $(INSTALL) -d -m 755 $(DESTDIR)$(localstatedir)/run + $(INSTALL) -d -m 755 $(DESTDIR)$(localstatedir)/run/gluster $(INSTALL) -d -m 755 $(DESTDIR)$(localstatedir)/log/glusterfs + $(INSTALL) -d -m 755 $(DESTDIR)$(sbindir) rm -f $(DESTDIR)$(sbindir)/glusterfs rm -f $(DESTDIR)$(sbindir)/glusterd ln -s glusterfsd $(DESTDIR)$(sbindir)/glusterfs diff --git a/glusterfsd/src/glusterfsd-mem-types.h b/glusterfsd/src/glusterfsd-mem-types.h index a28a7b2e3..7135c0ada 100644 --- a/glusterfsd/src/glusterfsd-mem-types.h +++ b/glusterfsd/src/glusterfsd-mem-types.h @@ -1,22 +1,12 @@ /* - Copyright (c) 2006-2011 Gluster, Inc. <http://www.gluster.com> + Copyright (c) 2006-2012 Red Hat, Inc. <http://www.redhat.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/>. + 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. */ - #ifndef __GLUSTERFSD_MEM_TYPES_H__ #define __GLUSTERFSD_MEM_TYPES_H__ @@ -27,10 +17,10 @@ enum gfd_mem_types_ { gfd_mt_xlator_list_t = GF_MEM_TYPE_START, gfd_mt_xlator_t, + gfd_mt_server_cmdline_t, gfd_mt_xlator_cmdline_option_t, gfd_mt_char, gfd_mt_call_pool_t, - gfd_mt_vol_top_priv_t, gfd_mt_end }; diff --git a/glusterfsd/src/glusterfsd-mgmt.c b/glusterfsd/src/glusterfsd-mgmt.c index 751e5495f..1c9220927 100644 --- a/glusterfsd/src/glusterfsd-mgmt.c +++ b/glusterfsd/src/glusterfsd-mgmt.c @@ -1,28 +1,17 @@ /* - Copyright (c) 2007-2011 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) 2007-2012 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 <sys/types.h> #include <sys/wait.h> #include <stdlib.h> #include <signal.h> -#include <pthread.h> #ifndef _CONFIG_H #define _CONFIG_H @@ -42,25 +31,28 @@ #include "xdr-generic.h" #include "glusterfsd.h" -#include "glusterfsd-mem-types.h" #include "rpcsvc.h" #include "cli1-xdr.h" #include "statedump.h" #include "syncop.h" +#include "xlator.h" -static char is_mgmt_rpc_reconnect; +static gf_boolean_t is_mgmt_rpc_reconnect = _gf_false; int glusterfs_mgmt_pmap_signin (glusterfs_ctx_t *ctx); int glusterfs_volfile_fetch (glusterfs_ctx_t *ctx); int glusterfs_process_volfp (glusterfs_ctx_t *ctx, FILE *fp); int glusterfs_graph_unknown_options (glusterfs_graph_t *graph); +int emancipate(glusterfs_ctx_t *ctx, int ret); int -mgmt_cbk_spec (void *data) +mgmt_cbk_spec (struct rpc_clnt *rpc, void *mydata, void *data) { glusterfs_ctx_t *ctx = NULL; + xlator_t *this = NULL; - ctx = glusterfs_ctx_get (); + this = mydata; + ctx = glusterfsd_ctx; gf_log ("mgmt", GF_LOG_INFO, "Volume file changed"); glusterfs_volfile_fetch (ctx); @@ -69,10 +61,11 @@ mgmt_cbk_spec (void *data) int -mgmt_cbk_event (void *data) +mgmt_cbk_event (struct rpc_clnt *rpc, void *mydata, void *data) { return 0; } + struct iobuf * glusterfs_serialize_reply (rpcsvc_request_t *req, void *arg, struct iovec *outmsg, xdrproc_t xdrproc) @@ -141,11 +134,10 @@ glusterfs_submit_reply (rpcsvc_request_t *req, void *arg, iob = glusterfs_serialize_reply (req, arg, &rsp, xdrproc); if (!iob) { gf_log_callingfn (THIS->name, GF_LOG_ERROR, "Failed to serialize reply"); - goto out; + } else { + iobref_add (iobref, iob); } - iobref_add (iobref, iob); - ret = rpcsvc_submit_generic (req, &rsp, 1, payload, payloadcount, iobref); @@ -183,15 +175,14 @@ glusterfs_terminate_response_send (rpcsvc_request_t *req, int op_ret) if (dict) ret = dict_allocate_and_serialize (dict, &rsp.output.output_val, - (size_t *)&rsp.output.output_len); + &rsp.output.output_len); if (ret == 0) ret = glusterfs_submit_reply (req, &rsp, NULL, 0, NULL, (xdrproc_t)xdr_gd1_mgmt_brick_op_rsp); - if (rsp.output.output_val) - GF_FREE (rsp.output.output_val); + GF_FREE (rsp.output.output_val); if (dict) dict_unref (dict); return ret; @@ -225,80 +216,20 @@ glusterfs_translator_info_response_send (rpcsvc_request_t *req, int ret, if (output) { ret = dict_allocate_and_serialize (output, &rsp.output.output_val, - (size_t *)&rsp.output.output_len); + &rsp.output.output_len); } if (!ret) free_ptr = _gf_true; - ret = glusterfs_submit_reply (req, &rsp, NULL, 0, NULL, - (xdrproc_t)xdr_gd1_mgmt_brick_op_rsp); + glusterfs_submit_reply (req, &rsp, NULL, 0, NULL, + (xdrproc_t)xdr_gd1_mgmt_brick_op_rsp); + ret = 0; if (free_ptr) GF_FREE (rsp.output.output_val); return ret; } int -glusterfs_handle_translator_info_get_cont (gfd_vol_top_priv_t *priv) -{ - int ret = -1; - xlator_t *any = NULL; - xlator_t *xlator = NULL; - glusterfs_graph_t *active = NULL; - glusterfs_ctx_t *ctx = NULL; - char msg[2048] = {0,}; - dict_t *output = NULL; - dict_t *dict = NULL; - - GF_ASSERT (priv); - - dict = dict_new (); - ret = dict_unserialize (priv->xlator_req.input.input_val, - priv->xlator_req.input.input_len, &dict); - if (ret) { - gf_log ("glusterd", GF_LOG_ERROR, "Unable to unserialize dict"); - goto cont; - } - ret = dict_set_double (dict, "time", priv->time); - if (ret) - goto cont; - ret = dict_set_double (dict, "throughput", priv->throughput); - if (ret) - goto cont; - -cont: - ctx = glusterfs_ctx_get (); - GF_ASSERT (ctx); - active = ctx->active; - any = active->first; - - xlator = xlator_search_by_name (any, priv->xlator_req.name); - if (!xlator) { - snprintf (msg, sizeof (msg), "xlator %s is not loaded", - priv->xlator_req.name); - goto out; - } - - output = dict_new (); - ret = xlator->notify (xlator, GF_EVENT_TRANSLATOR_INFO, dict, output); - -out: - ret = glusterfs_translator_info_response_send (priv->req, ret, - msg, output); - - if (priv->xlator_req.name) - free (priv->xlator_req.name); - if (priv->xlator_req.input.input_val) - free (priv->xlator_req.input.input_val); - if (dict) - dict_unref (dict); - if (output) - dict_unref (output); - GF_FREE (priv); - - return ret; -} - -int glusterfs_xlator_op_response_send (rpcsvc_request_t *req, int op_ret, char *msg, dict_t *output) { @@ -317,7 +248,7 @@ glusterfs_xlator_op_response_send (rpcsvc_request_t *req, int op_ret, if (output) { ret = dict_allocate_and_serialize (output, &rsp.output.output_val, - (size_t *)&rsp.output.output_len); + &rsp.output.output_len); } if (!ret) free_ptr = _gf_true; @@ -334,28 +265,35 @@ glusterfs_xlator_op_response_send (rpcsvc_request_t *req, int op_ret, int glusterfs_handle_translator_info_get (rpcsvc_request_t *req) { - int32_t ret = -1; - gd1_mgmt_brick_op_req xlator_req = {0,}; - dict_t *dict = NULL; - xlator_t *this = NULL; - gf1_cli_top_op top_op = 0; - uint32_t blk_size = 0; - uint32_t blk_count = 0; - gfd_vol_top_priv_t *priv = NULL; - pthread_t tid = -1; + int32_t ret = -1; + gd1_mgmt_brick_op_req xlator_req = {0,}; + dict_t *dict = NULL; + xlator_t *this = NULL; + gf1_cli_top_op top_op = 0; + uint32_t blk_size = 0; + uint32_t blk_count = 0; + double time = 0; + double throughput = 0; + xlator_t *any = NULL; + xlator_t *xlator = NULL; + glusterfs_graph_t *active = NULL; + glusterfs_ctx_t *ctx = NULL; + char msg[2048] = {0,}; + dict_t *output = NULL; GF_ASSERT (req); this = THIS; GF_ASSERT (this); - if (!xdr_to_generic (req->msg[0], &xlator_req, - (xdrproc_t)xdr_gd1_mgmt_brick_op_req)) { + ret = xdr_to_generic (req->msg[0], &xlator_req, + (xdrproc_t)xdr_gd1_mgmt_brick_op_req); + if (ret < 0) { //failed to decode msg; req->rpc_err = GARBAGE_ARGS; goto out; } - dict = dict_new (); + dict = dict_new (); ret = dict_unserialize (xlator_req.input.input_val, xlator_req.input.input_len, &dict); @@ -366,14 +304,6 @@ glusterfs_handle_translator_info_get (rpcsvc_request_t *req) goto out; } - priv = GF_MALLOC (sizeof (gfd_vol_top_priv_t), gfd_mt_vol_top_priv_t); - if (!priv) { - gf_log ("glusterd", GF_LOG_ERROR, "failed to allocate memory"); - goto out; - } - priv->xlator_req = xlator_req; - priv->req = req; - ret = dict_get_int32 (dict, "top-op", (int32_t *)&top_op); if ((!ret) && (GF_CLI_TOP_READ_PERF == top_op || GF_CLI_TOP_WRITE_PERF == top_op)) { @@ -383,61 +313,73 @@ glusterfs_handle_translator_info_get (rpcsvc_request_t *req) ret = dict_get_uint32 (dict, "blk-cnt", &blk_count); if (ret) goto cont; - priv->blk_size = blk_size; - priv->blk_count = blk_count; + if (GF_CLI_TOP_READ_PERF == top_op) { - ret = pthread_create (&tid, NULL, - glusterfs_volume_top_read_perf, - priv); + ret = glusterfs_volume_top_read_perf + (blk_size, blk_count, xlator_req.name, + &throughput, &time); } else if ( GF_CLI_TOP_WRITE_PERF == top_op) { - ret = pthread_create (&tid, NULL, - glusterfs_volume_top_write_perf, - priv); + ret = glusterfs_volume_top_write_perf + (blk_size, blk_count, xlator_req.name, + &throughput, &time); } - if (ret) { - gf_log ("glusterd", GF_LOG_ERROR, - "Thread create failed"); + ret = dict_set_double (dict, "time", time); + if (ret) + goto cont; + ret = dict_set_double (dict, "throughput", throughput); + if (ret) goto cont; - } - gf_log ("glusterd", GF_LOG_DEBUG, "Created new thread with " - "tid %u", (unsigned int)tid); - goto out; } cont: - priv->throughput = 0; - priv->time = 0; - ret = glusterfs_handle_translator_info_get_cont (priv); + ctx = glusterfsd_ctx; + GF_ASSERT (ctx); + active = ctx->active; + any = active->first; + + xlator = xlator_search_by_name (any, xlator_req.name); + if (!xlator) { + snprintf (msg, sizeof (msg), "xlator %s is not loaded", + xlator_req.name); + goto out; + } + + output = dict_new (); + ret = xlator->notify (xlator, GF_EVENT_TRANSLATOR_INFO, dict, output); + out: + ret = glusterfs_translator_info_response_send (req, ret, msg, output); + + free (xlator_req.name); + free (xlator_req.input.input_val); + if (output) + dict_unref (output); if (dict) dict_unref (dict); return ret; } -void * -glusterfs_volume_top_write_perf (void *args) +int +glusterfs_volume_top_write_perf (uint32_t blk_size, uint32_t blk_count, + char *brick_path, double *throughput, + double *time) { int32_t fd = -1; int32_t input_fd = -1; char export_path[PATH_MAX]; char *buf = NULL; - uint32_t blk_size = 0; - uint32_t blk_count = 0; int32_t iter = 0; int32_t ret = -1; uint64_t total_blks = 0; struct timeval begin, end = {0,}; - double throughput = 0; - double time = 0; - gfd_vol_top_priv_t *priv = NULL; - - GF_ASSERT (args); - priv = (gfd_vol_top_priv_t *)args; - blk_size = priv->blk_size; - blk_count = priv->blk_count; + GF_ASSERT (brick_path); + GF_ASSERT (throughput); + GF_ASSERT (time); + if (!(blk_size > 0) || ! (blk_count > 0)) + goto out; snprintf (export_path, sizeof (export_path), "%s/%s", - priv->xlator_req.name, ".gf-tmp-stats-perf"); + brick_path, ".gf-tmp-stats-perf"); fd = open (export_path, O_CREAT|O_RDWR, S_IRWXU); if (-1 == fd) { @@ -481,55 +423,46 @@ glusterfs_volume_top_write_perf (void *args) } gettimeofday (&end, NULL); - time = (end.tv_sec - begin.tv_sec) * 1e6 + *time = (end.tv_sec - begin.tv_sec) * 1e6 + (end.tv_usec - begin.tv_usec); - throughput = total_blks / time; + *throughput = total_blks / *time; gf_log ("glusterd", GF_LOG_INFO, "Throughput %.2f Mbps time %.2f secs " - "bytes written %"PRId64, throughput, time, total_blks); + "bytes written %"PRId64, *throughput, *time, total_blks); out: - priv->throughput = throughput; - priv->time = time; - if (fd >= 0) close (fd); if (input_fd >= 0) close (input_fd); - if (buf) - GF_FREE (buf); + GF_FREE (buf); unlink (export_path); - (void)glusterfs_handle_translator_info_get_cont (priv); - - return NULL; + return ret; } -void * -glusterfs_volume_top_read_perf (void *args) +int +glusterfs_volume_top_read_perf (uint32_t blk_size, uint32_t blk_count, + char *brick_path, double *throughput, + double *time) { int32_t fd = -1; int32_t input_fd = -1; int32_t output_fd = -1; char export_path[PATH_MAX]; char *buf = NULL; - uint32_t blk_size = 0; - uint32_t blk_count = 0; int32_t iter = 0; int32_t ret = -1; uint64_t total_blks = 0; struct timeval begin, end = {0,}; - double throughput = 0; - double time = 0; - gfd_vol_top_priv_t *priv = NULL; - - GF_ASSERT (args); - priv = (gfd_vol_top_priv_t *)args; - blk_size = priv->blk_size; - blk_count = priv->blk_count; + GF_ASSERT (brick_path); + GF_ASSERT (throughput); + GF_ASSERT (time); + if (!(blk_size > 0) || ! (blk_count > 0)) + goto out; snprintf (export_path, sizeof (export_path), "%s/%s", - priv->xlator_req.name, ".gf-tmp-stats-perf"); + brick_path, ".gf-tmp-stats-perf"); fd = open (export_path, O_CREAT|O_RDWR, S_IRWXU); if (-1 == fd) { ret = -1; @@ -605,33 +538,27 @@ glusterfs_volume_top_read_perf (void *args) } gettimeofday (&end, NULL); - time = (end.tv_sec - begin.tv_sec) * 1e6 - + (end.tv_usec - begin.tv_usec); - throughput = total_blks / time; + *time = (end.tv_sec - begin.tv_sec) * 1e6 + + (end.tv_usec - begin.tv_usec); + *throughput = total_blks / *time; gf_log ("glusterd", GF_LOG_INFO, "Throughput %.2f Mbps time %.2f secs " - "bytes read %"PRId64, throughput, time, total_blks); + "bytes read %"PRId64, *throughput, *time, total_blks); out: - priv->throughput = throughput; - priv->time = time; - if (fd >= 0) close (fd); if (input_fd >= 0) close (input_fd); if (output_fd >= 0) close (output_fd); - if (buf) - GF_FREE (buf); + GF_FREE (buf); unlink (export_path); - (void)glusterfs_handle_translator_info_get_cont (priv); - - return NULL; + return ret; } int -glusterfs_handle_translator_op (void *data) +glusterfs_handle_translator_op (rpcsvc_request_t *req) { int32_t ret = -1; gd1_mgmt_brick_op_req xlator_req = {0,}; @@ -646,20 +573,20 @@ glusterfs_handle_translator_op (void *data) xlator_t *this = NULL; int i = 0; int count = 0; - rpcsvc_request_t *req = data; GF_ASSERT (req); this = THIS; GF_ASSERT (this); - if (!xdr_to_generic (req->msg[0], &xlator_req, - (xdrproc_t)xdr_gd1_mgmt_brick_op_req)) { + ret = xdr_to_generic (req->msg[0], &xlator_req, + (xdrproc_t)xdr_gd1_mgmt_brick_op_req); + if (ret < 0) { //failed to decode msg; req->rpc_err = GARBAGE_ARGS; goto out; } - ctx = glusterfs_ctx_get (); + ctx = glusterfsd_ctx; active = ctx->active; any = active->first; input = dict_new (); @@ -712,8 +639,7 @@ out: dict_unref (input); if (output) dict_unref (output); - if (xlator_req.name) - free (xlator_req.name); //malloced by xdr + free (xlator_req.name); //malloced by xdr return 0; } @@ -737,7 +663,7 @@ glusterfs_handle_defrag (rpcsvc_request_t *req) this = THIS; GF_ASSERT (this); - ctx = glusterfs_ctx_get (); + ctx = glusterfsd_ctx; GF_ASSERT (ctx); active = ctx->active; @@ -747,8 +673,9 @@ glusterfs_handle_defrag (rpcsvc_request_t *req) } any = active->first; - if (!xdr_to_generic (req->msg[0], &xlator_req, - (xdrproc_t)xdr_gd1_mgmt_brick_op_req)) { + ret = xdr_to_generic (req->msg[0], &xlator_req, + (xdrproc_t)xdr_gd1_mgmt_brick_op_req); + if (ret < 0) { //failed to decode msg; req->rpc_err = GARBAGE_ARGS; goto out; @@ -786,12 +713,10 @@ glusterfs_handle_defrag (rpcsvc_request_t *req) out: if (dict) dict_unref (dict); - if (xlator_req.input.input_val) - free (xlator_req.input.input_val); // malloced by xdr + free (xlator_req.input.input_val); // malloced by xdr if (output) dict_unref (output); - if (xlator_req.name) - free (xlator_req.name); //malloced by xdr + free (xlator_req.name); //malloced by xdr return ret; @@ -818,8 +743,9 @@ glusterfs_handle_brick_status (rpcsvc_request_t *req) this = THIS; GF_ASSERT (this); - if (!xdr_to_generic (req->msg[0], &brick_req, - (xdrproc_t)xdr_gd1_mgmt_brick_op_req)) { + ret = xdr_to_generic (req->msg[0], &brick_req, + (xdrproc_t)xdr_gd1_mgmt_brick_op_req); + if (ret < 0) { req->rpc_err = GARBAGE_ARGS; goto out; } @@ -845,7 +771,7 @@ glusterfs_handle_brick_status (rpcsvc_request_t *req) goto out; } - ctx = glusterfs_ctx_get (); + ctx = glusterfsd_ctx; GF_ASSERT (ctx); active = ctx->active; any = active->first; @@ -903,39 +829,30 @@ glusterfs_handle_brick_status (rpcsvc_request_t *req) rsp.op_errstr = ""; ret = dict_allocate_and_serialize (output, &rsp.output.output_val, - (size_t *)&rsp.output.output_len); + &rsp.output.output_len); if (ret) { gf_log (this->name, GF_LOG_ERROR, "Failed to serialize output dict to rsp"); goto out; } - ret = glusterfs_submit_reply (req, &rsp, NULL, 0, NULL, - (xdrproc_t)xdr_gd1_mgmt_brick_op_rsp); + glusterfs_submit_reply (req, &rsp, NULL, 0, NULL, + (xdrproc_t)xdr_gd1_mgmt_brick_op_rsp); + ret = 0; out: if (dict) dict_unref (dict); if (output) dict_unref (output); - if (brick_req.input.input_val) - free (brick_req.input.input_val); - if (xname) - GF_FREE (xname); - if (msg) - GF_FREE (msg); - if (rsp.output.output_val) - GF_FREE (rsp.output.output_val); + free (brick_req.input.input_val); + GF_FREE (xname); + GF_FREE (msg); + GF_FREE (rsp.output.output_val); return ret; } -static int -glusterfs_command_done (int ret, call_frame_t *sync_frame, void *data) -{ - STACK_DESTROY (sync_frame->root); - return 0; -} int glusterfs_handle_node_status (rpcsvc_request_t *req) @@ -958,8 +875,9 @@ glusterfs_handle_node_status (rpcsvc_request_t *req) GF_ASSERT (req); - if (!xdr_to_generic (req->msg[0], &node_req, - (xdrproc_t)xdr_gd1_mgmt_brick_op_req)) { + ret = xdr_to_generic (req->msg[0], &node_req, + (xdrproc_t)xdr_gd1_mgmt_brick_op_req); + if (ret < 0) { req->rpc_err = GARBAGE_ARGS; goto out; } @@ -985,7 +903,7 @@ glusterfs_handle_node_status (rpcsvc_request_t *req) goto out; } - ctx = glusterfs_ctx_get (); + ctx = glusterfsd_ctx; GF_ASSERT (ctx); active = ctx->active; any = active->first; @@ -1087,29 +1005,25 @@ glusterfs_handle_node_status (rpcsvc_request_t *req) rsp.op_errstr = ""; ret = dict_allocate_and_serialize (output, &rsp.output.output_val, - (size_t *)&rsp.output.output_len); + &rsp.output.output_len); if (ret) { gf_log (THIS->name, GF_LOG_ERROR, "Failed to serialize output dict to rsp"); goto out; } - ret = glusterfs_submit_reply (req, &rsp, NULL, 0, NULL, - (xdrproc_t)xdr_gd1_mgmt_brick_op_rsp); + glusterfs_submit_reply (req, &rsp, NULL, 0, NULL, + (xdrproc_t)xdr_gd1_mgmt_brick_op_rsp); + ret = 0; out: if (dict) dict_unref (dict); - if (node_req.input.input_val) - free (node_req.input.input_val); - if (msg) - GF_FREE (msg); - if (rsp.output.output_val) - GF_FREE (rsp.output.output_val); - if (node_name) - GF_FREE (node_name); - if (subvol_name) - GF_FREE (subvol_name); + free (node_req.input.input_val); + GF_FREE (msg); + GF_FREE (rsp.output.output_val); + GF_FREE (node_name); + GF_FREE (subvol_name); gf_log (THIS->name, GF_LOG_DEBUG, "Returning %d", ret); return ret; @@ -1132,8 +1046,9 @@ glusterfs_handle_nfs_profile (rpcsvc_request_t *req) GF_ASSERT (req); - if (!xdr_to_generic (req->msg[0], &nfs_req, - (xdrproc_t)xdr_gd1_mgmt_brick_op_req)) { + ret = xdr_to_generic (req->msg[0], &nfs_req, + (xdrproc_t)xdr_gd1_mgmt_brick_op_req); + if (ret < 0) { req->rpc_err = GARBAGE_ARGS; goto out; } @@ -1153,7 +1068,7 @@ glusterfs_handle_nfs_profile (rpcsvc_request_t *req) goto out; } - ctx = glusterfs_ctx_get (); + ctx = glusterfsd_ctx; GF_ASSERT (ctx); active = ctx->active; @@ -1185,72 +1100,115 @@ glusterfs_handle_nfs_profile (rpcsvc_request_t *req) rsp.op_errstr = ""; ret = dict_allocate_and_serialize (output, &rsp.output.output_val, - (size_t *)&rsp.output.output_len); + &rsp.output.output_len); if (ret) { gf_log (THIS->name, GF_LOG_ERROR, "Failed to serialize output dict to rsp"); goto out; } - ret = glusterfs_submit_reply (req, &rsp, NULL, 0, NULL, - (xdrproc_t)xdr_gd1_mgmt_brick_op_rsp); + glusterfs_submit_reply (req, &rsp, NULL, 0, NULL, + (xdrproc_t)xdr_gd1_mgmt_brick_op_rsp); + ret = 0; out: - if (nfs_req.input.input_val) - free (nfs_req.input.input_val); + free (nfs_req.input.input_val); if (dict) dict_unref (dict); if (output) dict_unref (output); - if (rsp.output.output_val) - GF_FREE (rsp.output.output_val); + GF_FREE (rsp.output.output_val); gf_log (THIS->name, GF_LOG_DEBUG, "Returning %d", ret); return ret; } int -glusterfs_handle_rpc_msg (rpcsvc_request_t *req) +glusterfs_handle_volume_barrier_op (rpcsvc_request_t *req) { - int ret = -1; - xlator_t *this = THIS; - call_frame_t *frame = NULL; + int32_t ret = -1; + gd1_mgmt_brick_op_req xlator_req = {0,}; + dict_t *dict = NULL; + xlator_t *xlator = NULL; + xlator_t *any = NULL; + dict_t *output = NULL; + char msg[2048] = {0}; + glusterfs_ctx_t *ctx = NULL; + glusterfs_graph_t *active = NULL; + xlator_t *this = NULL; + GF_ASSERT (req); + this = THIS; GF_ASSERT (this); - switch (req->procnum) { - case GLUSTERD_BRICK_TERMINATE: - ret = glusterfs_handle_terminate (req); - break; - case GLUSTERD_BRICK_XLATOR_INFO: - ret = glusterfs_handle_translator_info_get (req); - break; - case GLUSTERD_BRICK_XLATOR_OP: - frame = create_frame (this, this->ctx->pool); - if (!frame) - goto out; - ret = synctask_new (this->ctx->env, - glusterfs_handle_translator_op, - glusterfs_command_done, frame, req); - break; - case GLUSTERD_BRICK_STATUS: - ret = glusterfs_handle_brick_status (req); - break; - case GLUSTERD_BRICK_XLATOR_DEFRAG: - ret = glusterfs_handle_defrag (req); - break; - case GLUSTERD_NODE_PROFILE: - ret = glusterfs_handle_nfs_profile (req); - break; - case GLUSTERD_NODE_STATUS: - ret = glusterfs_handle_node_status (req); - default: - break; + + ctx = glusterfsd_ctx; + GF_ASSERT (ctx); + + active = ctx->active; + if (!active) { + req->rpc_err = GARBAGE_ARGS; + goto out; } + + any = active->first; + ret = xdr_to_generic (req->msg[0], &xlator_req, + (xdrproc_t)xdr_gd1_mgmt_brick_op_req); + if (ret < 0) { + //failed to decode msg; + req->rpc_err = GARBAGE_ARGS; + goto out; + } + dict = dict_new (); + if (!dict) + goto out; + + ret = dict_unserialize (xlator_req.input.input_val, + xlator_req.input.input_len, + &dict); + if (ret < 0) { + gf_log (this->name, GF_LOG_ERROR, + "failed to " + "unserialize req-buffer to dictionary"); + goto out; + } + xlator = xlator_search_by_name (any, xlator_req.name); + if (!xlator) { + snprintf (msg, sizeof (msg), "xlator %s is not loaded", + xlator_req.name); + goto out; + } + + output = dict_new (); + if (!output) { + ret = -1; + goto out; + } + + ret = xlator->notify (xlator, GF_EVENT_VOLUME_BARRIER_OP, + dict, output); + + ret = glusterfs_translator_info_response_send (req, ret, + msg, output); out: + if (dict) + dict_unref (dict); + free (xlator_req.input.input_val); // malloced by xdr + if (output) + dict_unref (output); + free (xlator_req.name); //malloced by xdr + + return ret; + +} +int +glusterfs_handle_rpc_msg (rpcsvc_request_t *req) +{ + int ret = -1; + /* for now, nothing */ return ret; } -rpcclnt_cb_actor_t gluster_cbk_actors[] = { +rpcclnt_cb_actor_t mgmt_cbk_actors[] = { [GF_CBK_FETCHSPEC] = {"FETCHSPEC", GF_CBK_FETCHSPEC, mgmt_cbk_spec }, [GF_CBK_EVENT_NOTIFY] = {"EVENTNOTIFY", GF_CBK_EVENT_NOTIFY, mgmt_cbk_event}, @@ -1261,7 +1219,7 @@ struct rpcclnt_cb_program mgmt_cbk_prog = { .progname = "GlusterFS Callback", .prognum = GLUSTER_CBK_PROGRAM, .progver = GLUSTER_CBK_VERSION, - .actors = gluster_cbk_actors, + .actors = mgmt_cbk_actors, .numactors = GF_CBK_MAXVALUE, }; @@ -1298,14 +1256,15 @@ rpc_clnt_prog_t clnt_handshake_prog = { }; rpcsvc_actor_t glusterfs_actors[] = { - [GLUSTERD_BRICK_NULL] = { "NULL", GLUSTERD_BRICK_NULL, glusterfs_handle_rpc_msg, NULL, NULL, 0}, - [GLUSTERD_BRICK_TERMINATE] = { "TERMINATE", GLUSTERD_BRICK_TERMINATE, glusterfs_handle_rpc_msg, NULL, NULL, 0}, - [GLUSTERD_BRICK_XLATOR_INFO] = { "TRANSLATOR INFO", GLUSTERD_BRICK_XLATOR_INFO, glusterfs_handle_rpc_msg, NULL, NULL, 0}, - [GLUSTERD_BRICK_XLATOR_OP] = { "TRANSLATOR OP", GLUSTERD_BRICK_XLATOR_OP, glusterfs_handle_rpc_msg, NULL, NULL, 0}, - [GLUSTERD_BRICK_STATUS] = {"STATUS", GLUSTERD_BRICK_STATUS, glusterfs_handle_rpc_msg, NULL, NULL, 0}, - [GLUSTERD_BRICK_XLATOR_DEFRAG] = { "TRANSLATOR DEFRAG", GLUSTERD_BRICK_XLATOR_DEFRAG, glusterfs_handle_rpc_msg, NULL, NULL, 0}, - [GLUSTERD_NODE_PROFILE] = {"NFS PROFILE", GLUSTERD_NODE_PROFILE, glusterfs_handle_rpc_msg, NULL, NULL, 0}, - [GLUSTERD_NODE_STATUS] = {"NFS STATUS", GLUSTERD_NODE_STATUS, glusterfs_handle_rpc_msg, NULL, NULL, 0} + [GLUSTERD_BRICK_NULL] = {"NULL", GLUSTERD_BRICK_NULL, glusterfs_handle_rpc_msg, NULL, 0, DRC_NA}, + [GLUSTERD_BRICK_TERMINATE] = {"TERMINATE", GLUSTERD_BRICK_TERMINATE, glusterfs_handle_terminate, NULL, 0, DRC_NA}, + [GLUSTERD_BRICK_XLATOR_INFO] = {"TRANSLATOR INFO", GLUSTERD_BRICK_XLATOR_INFO, glusterfs_handle_translator_info_get, NULL, 0, DRC_NA}, + [GLUSTERD_BRICK_XLATOR_OP] = {"TRANSLATOR OP", GLUSTERD_BRICK_XLATOR_OP, glusterfs_handle_translator_op, NULL, 0, DRC_NA}, + [GLUSTERD_BRICK_STATUS] = {"STATUS", GLUSTERD_BRICK_STATUS, glusterfs_handle_brick_status, NULL, 0, DRC_NA}, + [GLUSTERD_BRICK_XLATOR_DEFRAG] = {"TRANSLATOR DEFRAG", GLUSTERD_BRICK_XLATOR_DEFRAG, glusterfs_handle_defrag, NULL, 0, DRC_NA}, + [GLUSTERD_NODE_PROFILE] = {"NFS PROFILE", GLUSTERD_NODE_PROFILE, glusterfs_handle_nfs_profile, NULL, 0, DRC_NA}, + [GLUSTERD_NODE_STATUS] = {"NFS STATUS", GLUSTERD_NODE_STATUS, glusterfs_handle_node_status, NULL, 0, DRC_NA}, + [GLUSTERD_VOLUME_BARRIER_OP] = {"VOLUME BARRIER OP", GLUSTERD_VOLUME_BARRIER_OP, glusterfs_handle_volume_barrier_op, NULL, 0, DRC_NA}, }; struct rpcsvc_program glusterfs_mop_prog = { @@ -1314,6 +1273,7 @@ struct rpcsvc_program glusterfs_mop_prog = { .progver = GD_BRICK_VERSION, .actors = glusterfs_actors, .numactors = GLUSTERD_BRICK_MAXVALUE, + .synctask = _gf_true, }; int @@ -1373,156 +1333,10 @@ out: /* XXX: move these into @ctx */ -static char oldvolfile[131072]; +static char *oldvolfile = NULL; static int oldvollen = 0; -static int -xlator_equal_rec (xlator_t *xl1, xlator_t *xl2) -{ - xlator_list_t *trav1 = NULL; - xlator_list_t *trav2 = NULL; - int ret = 0; - - if (xl1 == NULL || xl2 == NULL) { - gf_log ("xlator", GF_LOG_DEBUG, "invalid argument"); - return -1; - } - - trav1 = xl1->children; - trav2 = xl2->children; - - while (trav1 && trav2) { - ret = xlator_equal_rec (trav1->xlator, trav2->xlator); - if (ret) { - gf_log ("glusterfsd-mgmt", GF_LOG_DEBUG, - "xlators children not equal"); - goto out; - } - - trav1 = trav1->next; - trav2 = trav2->next; - } - - if (trav1 || trav2) { - ret = -1; - goto out; - } - - if (strcmp (xl1->name, xl2->name)) { - ret = -1; - goto out; - } -out : - return ret; -} - -static gf_boolean_t -is_graph_topology_equal (glusterfs_graph_t *graph1, - glusterfs_graph_t *graph2) -{ - xlator_t *trav1 = NULL; - xlator_t *trav2 = NULL; - gf_boolean_t ret = _gf_true; - - trav1 = graph1->first; - trav2 = graph2->first; - - ret = xlator_equal_rec (trav1, trav2); - - if (ret) { - gf_log ("glusterfsd-mgmt", GF_LOG_DEBUG, - "graphs are not equal"); - ret = _gf_false; - goto out; - } - - ret = _gf_true; - gf_log ("glusterfsd-mgmt", GF_LOG_DEBUG, - "graphs are equal"); -out: - return ret; -} - -/* Function has 3types of return value 0, -ve , 1 - * return 0 =======> reconfiguration of options has succeeded - * return 1 =======> the graph has to be reconstructed and all the xlators should be inited - * return -1(or -ve) =======> Some Internal Error occurred during the operation - */ -static int -glusterfs_volfile_reconfigure (FILE *newvolfile_fp) -{ - glusterfs_graph_t *oldvolfile_graph = NULL; - glusterfs_graph_t *newvolfile_graph = NULL; - FILE *oldvolfile_fp = NULL; - glusterfs_ctx_t *ctx = NULL; - - int ret = -1; - - oldvolfile_fp = tmpfile (); - if (!oldvolfile_fp) - goto out; - - if (!oldvollen) { - ret = 1; // Has to call INIT for the whole graph - goto out; - } - fwrite (oldvolfile, oldvollen, 1, oldvolfile_fp); - fflush (oldvolfile_fp); - - - oldvolfile_graph = glusterfs_graph_construct (oldvolfile_fp); - if (!oldvolfile_graph) { - goto out; - } - - newvolfile_graph = glusterfs_graph_construct (newvolfile_fp); - if (!newvolfile_graph) { - goto out; - } - - if (!is_graph_topology_equal (oldvolfile_graph, - newvolfile_graph)) { - - ret = 1; - gf_log ("glusterfsd-mgmt", GF_LOG_DEBUG, - "Graph topology not equal(should call INIT)"); - goto out; - } - - gf_log ("glusterfsd-mgmt", GF_LOG_DEBUG, - "Only options have changed in the new " - "graph"); - - ctx = glusterfs_ctx_get (); - - if (!ctx) { - gf_log ("glusterfsd-mgmt", GF_LOG_ERROR, - "glusterfs_ctx_get() returned NULL"); - goto out; - } - - oldvolfile_graph = ctx->active; - - if (!oldvolfile_graph) { - gf_log ("glusterfsd-mgmt", GF_LOG_ERROR, - "glusterfs_ctx->active is NULL"); - goto out; - } - - /* */ - ret = glusterfs_graph_reconfigure (oldvolfile_graph, - newvolfile_graph); - if (ret) { - gf_log ("glusterfsd-mgmt", GF_LOG_DEBUG, - "Could not reconfigure new options in old graph"); - goto out; - } - - ret = 0; -out: - return ret; -} int mgmt_getspec_cbk (struct rpc_req *req, struct iovec *iov, int count, @@ -1534,6 +1348,7 @@ mgmt_getspec_cbk (struct rpc_req *req, struct iovec *iov, int count, int ret = 0; ssize_t size = 0; FILE *tmpfp = NULL; + char *volfilebuf = NULL; frame = myframe; ctx = frame->this->ctx; @@ -1553,7 +1368,7 @@ mgmt_getspec_cbk (struct rpc_req *req, struct iovec *iov, int count, if (-1 == rsp.op_ret) { gf_log (frame->this->name, GF_LOG_ERROR, "failed to get the 'volume file' from server"); - ret = -1; + ret = rsp.op_errno; goto out; } @@ -1574,6 +1389,10 @@ mgmt_getspec_cbk (struct rpc_req *req, struct iovec *iov, int count, fwrite (rsp.spec, size, 1, tmpfp); fflush (tmpfp); + if (ferror (tmpfp)) { + ret = -1; + goto out; + } /* Check if only options have changed. No need to reload the * volfile if topology hasn't changed. @@ -1583,10 +1402,19 @@ mgmt_getspec_cbk (struct rpc_req *req, struct iovec *iov, int count, * return -1(or -ve) =======> Some Internal Error occurred during the operation */ - ret = glusterfs_volfile_reconfigure (tmpfp); + ret = glusterfs_volfile_reconfigure (oldvollen, tmpfp, ctx, oldvolfile); if (ret == 0) { gf_log ("glusterfsd-mgmt", GF_LOG_DEBUG, "No need to re-load volfile, reconfigure done"); + if (oldvolfile) + volfilebuf = GF_REALLOC (oldvolfile, size); + else + volfilebuf = GF_CALLOC (1, size, gf_common_mt_char); + if (!volfilebuf) { + ret = -1; + goto out; + } + oldvolfile = volfilebuf; oldvollen = size; memcpy (oldvolfile, rsp.spec, size); goto out; @@ -1598,21 +1426,41 @@ mgmt_getspec_cbk (struct rpc_req *req, struct iovec *iov, int count, } ret = glusterfs_process_volfp (ctx, tmpfp); + /* tmpfp closed */ + tmpfp = NULL; if (ret) goto out; + if (oldvolfile) + volfilebuf = GF_REALLOC (oldvolfile, size); + else + volfilebuf = GF_CALLOC (1, size, gf_common_mt_char); + + if (!volfilebuf) { + ret = -1; + goto out; + } + oldvolfile = volfilebuf; oldvollen = size; memcpy (oldvolfile, rsp.spec, size); if (!is_mgmt_rpc_reconnect) { glusterfs_mgmt_pmap_signin (ctx); - is_mgmt_rpc_reconnect = 1; + is_mgmt_rpc_reconnect = _gf_true; } out: STACK_DESTROY (frame->root); - if (rsp.spec) - free (rsp.spec); + free (rsp.spec); + + emancipate (ctx, ret); + + // Stop if server is running at an unsupported op-version + if (ENOTSUP == ret) { + gf_log ("mgmt", GF_LOG_ERROR, "Server is operating at an " + "op-version which is not supported"); + cleanup_and_exit (0); + } if (ret && ctx && !ctx->active) { /* Do it only for the first time */ @@ -1623,6 +1471,11 @@ out: ctx->cmd_args.volfile_id); cleanup_and_exit (0); } + + + if (tmpfp) + fclose (tmpfp); + return 0; } @@ -1634,6 +1487,7 @@ glusterfs_volfile_fetch (glusterfs_ctx_t *ctx) gf_getspec_req req = {0, }; int ret = 0; call_frame_t *frame = NULL; + dict_t *dict = NULL; cmd_args = &ctx->cmd_args; @@ -1642,9 +1496,40 @@ glusterfs_volfile_fetch (glusterfs_ctx_t *ctx) req.key = cmd_args->volfile_id; req.flags = 0; + dict = dict_new (); + if (!dict) { + ret = -1; + goto out; + } + + // Set the supported min and max op-versions, so glusterd can make a + // decision + ret = dict_set_int32 (dict, "min-op-version", GD_OP_VERSION_MIN); + if (ret) { + gf_log (THIS->name, GF_LOG_ERROR, "Failed to set min-op-version" + " in request dict"); + goto out; + } + + ret = dict_set_int32 (dict, "max-op-version", GD_OP_VERSION_MAX); + if (ret) { + gf_log (THIS->name, GF_LOG_ERROR, "Failed to set max-op-version" + " in request dict"); + goto out; + } + + ret = dict_allocate_and_serialize (dict, &req.xdata.xdata_val, + &req.xdata.xdata_len); + if (ret < 0) { + gf_log (THIS->name, GF_LOG_ERROR, + "Failed to serialize dictionary"); + goto out; + } + ret = mgmt_submit_request (&req, frame, ctx, &clnt_handshake_prog, GF_HNDSK_GETSPEC, mgmt_getspec_cbk, (xdrproc_t)xdr_gf_getspec_req); +out: return ret; } @@ -1679,11 +1564,50 @@ mgmt_event_notify_cbk (struct rpc_req *req, struct iovec *iov, int count, goto out; } out: - if (rsp.dict.dict_val) - free (rsp.dict.dict_val); //malloced by xdr + free (rsp.dict.dict_val); //malloced by xdr return ret; } + +int32_t +glusterfs_rebalance_event_notify_cbk (struct rpc_req *req, struct iovec *iov, + int count, void *myframe) +{ + gf_event_notify_rsp rsp = {0,}; + call_frame_t *frame = NULL; + glusterfs_ctx_t *ctx = NULL; + int ret = 0; + + frame = myframe; + ctx = frame->this->ctx; + + if (-1 == req->rpc_status) { + gf_log (frame->this->name, GF_LOG_ERROR, + "failed to get the rsp from server"); + ret = -1; + goto out; + } + + ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_event_notify_rsp); + if (ret < 0) { + gf_log (frame->this->name, GF_LOG_ERROR, "XDR decoding error"); + ret = -1; + goto out; + } + + if (-1 == rsp.op_ret) { + gf_log (frame->this->name, GF_LOG_ERROR, + "Received error (%s) from server", + strerror (rsp.op_errno)); + ret = -1; + goto out; + } +out: + free (rsp.dict.dict_val); //malloced by xdr + return ret; + +} + int32_t glusterfs_rebalance_event_notify (dict_t *dict) { @@ -1693,7 +1617,7 @@ glusterfs_rebalance_event_notify (dict_t *dict) cmd_args_t *cmd_args = NULL; call_frame_t *frame = NULL; - ctx = glusterfs_ctx_get (); + ctx = glusterfsd_ctx; cmd_args = &ctx->cmd_args; frame = create_frame (THIS, ctx->pool); @@ -1706,15 +1630,15 @@ glusterfs_rebalance_event_notify (dict_t *dict) gf_log ("", GF_LOG_ERROR, "failed to set volname"); ret = dict_allocate_and_serialize (dict, &req.dict.dict_val, - (size_t *)&req.dict.dict_len); + &req.dict.dict_len); } ret = mgmt_submit_request (&req, frame, ctx, &clnt_handshake_prog, - GF_HNDSK_EVENT_NOTIFY, NULL, + GF_HNDSK_EVENT_NOTIFY, + glusterfs_rebalance_event_notify_cbk, (xdrproc_t)xdr_gf_event_notify_req); - if (req.dict.dict_val) - GF_FREE (req.dict.dict_val); + GF_FREE (req.dict.dict_val); STACK_DESTROY (frame->root); return ret; @@ -1724,48 +1648,83 @@ static int mgmt_rpc_notify (struct rpc_clnt *rpc, void *mydata, rpc_clnt_event_t event, void *data) { - xlator_t *this = NULL; - cmd_args_t *cmd_args = NULL; - glusterfs_ctx_t *ctx = NULL; + xlator_t *this = NULL; + glusterfs_ctx_t *ctx = NULL; int ret = 0; + server_cmdline_t *server = NULL; + rpc_transport_t *rpc_trans = NULL; + int need_term = 0; + int emval = 0; this = mydata; + rpc_trans = rpc->conn.trans; ctx = this->ctx; - cmd_args = &ctx->cmd_args; + switch (event) { case RPC_CLNT_DISCONNECT: if (!ctx->active) { - cmd_args->max_connect_attempts--; gf_log ("glusterfsd-mgmt", GF_LOG_ERROR, - "failed to connect with remote-host: %s", + "failed to connect with remote-host: %s (%s)", + ctx->cmd_args.volfile_server, strerror (errno)); + server = ctx->cmd_args.curr_server; + if (server->list.next == &ctx->cmd_args.volfile_servers) { + need_term = 1; + emval = ENOTCONN; + gf_log("glusterfsd-mgmt", GF_LOG_INFO, + "Exhausted all volfile servers"); + break; + } + server = list_entry (server->list.next, typeof(*server), + list); + ctx->cmd_args.curr_server = server; + ctx->cmd_args.volfile_server = server->volfile_server; + + ret = dict_set_str (rpc_trans->options, + "remote-host", + server->volfile_server); + if (ret != 0) { + gf_log ("glusterfsd-mgmt", GF_LOG_ERROR, + "failed to set remote-host: %s", + server->volfile_server); + need_term = 1; + emval = ENOTCONN; + break; + } gf_log ("glusterfsd-mgmt", GF_LOG_INFO, - "%d connect attempts left", - cmd_args->max_connect_attempts); - if (0 >= cmd_args->max_connect_attempts) - cleanup_and_exit (1); + "connecting to next volfile server %s", + server->volfile_server); } break; case RPC_CLNT_CONNECT: rpc_clnt_set_connected (&((struct rpc_clnt*)ctx->mgmt)->conn); ret = glusterfs_volfile_fetch (ctx); - if (ret && ctx && (ctx->active == NULL)) { - /* Do it only for the first time */ - /* Exit the process.. there is some wrong options */ - gf_log ("mgmt", GF_LOG_ERROR, - "failed to fetch volume file (key:%s)", - ctx->cmd_args.volfile_id); - cleanup_and_exit (0); + if (ret) { + emval = ret; + if (!ctx->active) { + need_term = 1; + gf_log ("glusterfsd-mgmt", GF_LOG_ERROR, + "failed to fetch volume file (key:%s)", + ctx->cmd_args.volfile_id); + break; + + } } if (is_mgmt_rpc_reconnect) glusterfs_mgmt_pmap_signin (ctx); + break; default: break; } + if (need_term) { + emancipate (ctx, emval); + cleanup_and_exit (1); + } + return 0; } @@ -1878,7 +1837,7 @@ glusterfs_listener_stop (glusterfs_ctx_t *ctx) if (ret) { this = THIS; - gf_log (this->name, GF_LOG_ERROR, "Failed to unlink linstener " + gf_log (this->name, GF_LOG_ERROR, "Failed to unlink listener " "socket %s, error: %s", cmd_args->sock_file, strerror (errno)); } @@ -1886,6 +1845,24 @@ glusterfs_listener_stop (glusterfs_ctx_t *ctx) } int +glusterfs_mgmt_notify (int32_t op, void *data, ...) +{ + int ret = 0; + switch (op) + { + case GF_EN_DEFRAG_STATUS: + ret = glusterfs_rebalance_event_notify ((dict_t*) data); + break; + + default: + gf_log ("", GF_LOG_ERROR, "Invalid op"); + break; + } + + return ret; +} + +int glusterfs_mgmt_init (glusterfs_ctx_t *ctx) { cmd_args_t *cmd_args = NULL; @@ -1920,16 +1897,20 @@ glusterfs_mgmt_init (glusterfs_ctx_t *ctx) ret = rpc_clnt_register_notify (rpc, mgmt_rpc_notify, THIS); if (ret) { - gf_log (THIS->name, GF_LOG_WARNING, "failed to register notify function"); + gf_log (THIS->name, GF_LOG_WARNING, + "failed to register notify function"); goto out; } - ret = rpcclnt_cbk_program_register (rpc, &mgmt_cbk_prog); + ret = rpcclnt_cbk_program_register (rpc, &mgmt_cbk_prog, THIS); if (ret) { - gf_log (THIS->name, GF_LOG_WARNING, "failed to register callback function"); + gf_log (THIS->name, GF_LOG_WARNING, + "failed to register callback function"); goto out; } + ctx->notify = glusterfs_mgmt_notify; + /* This value should be set before doing the 'rpc_clnt_start()' as the notify function uses this variable */ ctx->mgmt = rpc; @@ -2008,7 +1989,7 @@ mgmt_pmap_signin_cbk (struct rpc_req *req, struct iovec *iov, int count, goto out; } - ctx = glusterfs_ctx_get (); + ctx = glusterfsd_ctx; cmd_args = &ctx->cmd_args; if (!cmd_args->brick_port2) { @@ -2077,7 +2058,7 @@ mgmt_pmap_signout_cbk (struct rpc_req *req, struct iovec *iov, int count, goto out; } - ctx = glusterfs_ctx_get (); + ctx = glusterfsd_ctx; ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_pmap_signout_rsp); if (ret < 0) { gf_log (THIS->name, GF_LOG_ERROR, "XDR decoding failed"); diff --git a/glusterfsd/src/glusterfsd.c b/glusterfsd/src/glusterfsd.c index 8fbbb2f8d..3cb8f0f51 100644 --- a/glusterfsd/src/glusterfsd.c +++ b/glusterfsd/src/glusterfsd.c @@ -1,22 +1,12 @@ /* - Copyright (c) 2006-2011 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> @@ -77,6 +67,7 @@ #include <fnmatch.h> #include "rpc-clnt.h" #include "syncop.h" +#include "client_t.h" #include "daemon.h" @@ -89,14 +80,15 @@ 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-2011 Gluster Inc. " \ - "<http://www.gluster.com>\n" \ - "GlusterFS comes with ABSOLUTELY NO WARRANTY.\n" \ - "You may redistribute copies of GlusterFS under the terms of "\ - "the GNU General Public License."; +const char *argp_program_version = "" + PACKAGE_NAME" "PACKAGE_VERSION" built on "__DATE__" "__TIME__ + "\nRepository revision: " GLUSTERFS_REPOSITORY_REVISION "\n" + "Copyright (c) 2006-2013 Red Hat, Inc. <http://www.redhat.com/>\n" + "GlusterFS comes with ABSOLUTELY NO WARRANTY.\n" + "It is licensed to you under your choice of the GNU Lesser\n" + "General Public License, version 3 or any later version (LGPLv3\n" + "or later), or the GNU General Public License, version 2 (GPLv2),\n" + "in all cases as published by the Free Software Foundation."; const char *argp_program_bug_address = "<" PACKAGE_BUGREPORT ">"; static error_t parse_opts (int32_t key, char *arg, struct argp_state *_state); @@ -106,10 +98,6 @@ static struct argp_option gf_options[] = { {"volfile-server", ARGP_VOLFILE_SERVER_KEY, "SERVER", 0, "Server to get the volume file from. This option overrides " "--volfile option"}, - {"volfile-max-fetch-attempts", ARGP_VOLFILE_MAX_FETCH_ATTEMPTS, - "MAX-ATTEMPTS", 0, "Maximum number of connect attempts to server. " - "This option should be provided with --volfile-server option" - "[default: 1]"}, {"volfile", ARGP_VOLUME_FILE_KEY, "VOLFILE", 0, "File to use as VOLUME_FILE"}, {"spec-file", ARGP_VOLUME_FILE_KEY, "VOLFILE", OPTION_HIDDEN, @@ -117,7 +105,7 @@ static struct argp_option gf_options[] = { {"log-level", ARGP_LOG_LEVEL_KEY, "LOGLEVEL", 0, "Logging severity. Valid options are DEBUG, INFO, WARNING, ERROR, " - "CRITICAL and NONE [default: INFO]"}, + "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" "]"}, @@ -152,6 +140,15 @@ static struct argp_option gf_options[] = { "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, @@ -166,6 +163,8 @@ static struct argp_option gf_options[] = { "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:"}, {"direct-io-mode", ARGP_DIRECT_IO_MODE_KEY, "BOOL", OPTION_ARG_OPTIONAL, @@ -174,9 +173,20 @@ static struct argp_option gf_options[] = { "\"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, @@ -187,6 +197,11 @@ static struct argp_option gf_options[] = { "Enable strict volume file checking"}, {"mem-accounting", ARGP_MEM_ACCOUNTING_KEY, 0, OPTION_HIDDEN, "Enable internal memory accounting"}, + {"fuse-mountopts", ARGP_FUSE_MOUNTOPTS_KEY, "OPTIONS", OPTION_HIDDEN, + "Extra mount options to pass to FUSE"}, + {"use-readdirp", ARGP_FUSE_USE_READDIRP_KEY, "BOOL", OPTION_ARG_OPTIONAL, + "Use readdirp mode in fuse kernel module" + " [default: \"off\"]"}, {0, 0, 0, 0, "Miscellaneous Options:"}, {0, } }; @@ -200,50 +215,17 @@ int glusterfs_mgmt_init (glusterfs_ctx_t *ctx); int glusterfs_listener_init (glusterfs_ctx_t *ctx); int glusterfs_listener_stop (glusterfs_ctx_t *ctx); -int -create_fuse_mount (glusterfs_ctx_t *ctx) + +static int +set_fuse_mount_options (glusterfs_ctx_t *ctx, dict_t *options) { int ret = 0; cmd_args_t *cmd_args = NULL; - xlator_t *master = NULL; char *mount_point = NULL; char cwd[PATH_MAX] = {0,}; cmd_args = &ctx->cmd_args; - if (!cmd_args->mount_point) { - gf_log ("", GF_LOG_TRACE, - "mount point not found, not a client process"); - return 0; - } - - if (ctx->process_mode != GF_CLIENT_PROCESS) { - gf_log("glusterfsd", GF_LOG_ERROR, - "Not a client process, not performing mount operation"); - return -1; - } - - master = GF_CALLOC (1, sizeof (*master), - gfd_mt_xlator_t); - if (!master) - goto err; - - 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; - /* Check if mount-point is absolute path, * if not convert to absolute path by concating with CWD */ @@ -265,7 +247,7 @@ create_fuse_mount (glusterfs_ctx_t *ctx) } else mount_point = gf_strdup (cmd_args->mount_point); - ret = dict_set_dynstr (master->options, ZR_MOUNTPOINT_OPT, mount_point); + ret = dict_set_dynstr (options, ZR_MOUNTPOINT_OPT, mount_point); if (ret < 0) { gf_log ("glusterfsd", GF_LOG_ERROR, "failed to set mount-point to options dictionary"); @@ -273,7 +255,7 @@ create_fuse_mount (glusterfs_ctx_t *ctx) } if (cmd_args->fuse_attribute_timeout >= 0) { - ret = dict_set_double (master->options, ZR_ATTR_TIMEOUT_OPT, + ret = dict_set_double (options, ZR_ATTR_TIMEOUT_OPT, cmd_args->fuse_attribute_timeout); if (ret < 0) { @@ -285,7 +267,7 @@ create_fuse_mount (glusterfs_ctx_t *ctx) } if (cmd_args->fuse_entry_timeout >= 0) { - ret = dict_set_double (master->options, ZR_ENTRY_TIMEOUT_OPT, + ret = dict_set_double (options, ZR_ENTRY_TIMEOUT_OPT, cmd_args->fuse_entry_timeout); if (ret < 0) { gf_log ("glusterfsd", GF_LOG_ERROR, @@ -295,8 +277,19 @@ create_fuse_mount (glusterfs_ctx_t *ctx) } } + if (cmd_args->fuse_negative_timeout >= 0) { + ret = dict_set_double (options, ZR_NEGATIVE_TIMEOUT_OPT, + cmd_args->fuse_negative_timeout); + if (ret < 0) { + gf_log ("glusterfsd", GF_LOG_ERROR, + "failed to set dict value for key %s", + ZR_NEGATIVE_TIMEOUT_OPT); + goto err; + } + } + if (cmd_args->client_pid_set) { - ret = dict_set_int32 (master->options, "client-pid", + ret = dict_set_int32 (options, "client-pid", cmd_args->client_pid); if (ret < 0) { gf_log ("glusterfsd", GF_LOG_ERROR, @@ -307,7 +300,7 @@ create_fuse_mount (glusterfs_ctx_t *ctx) } if (cmd_args->uid_map_root) { - ret = dict_set_int32 (master->options, "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, @@ -318,7 +311,7 @@ create_fuse_mount (glusterfs_ctx_t *ctx) } if (cmd_args->volfile_check) { - ret = dict_set_int32 (master->options, ZR_STRICT_VOLFILE_CHECK, + ret = dict_set_int32 (options, ZR_STRICT_VOLFILE_CHECK, cmd_args->volfile_check); if (ret < 0) { gf_log ("glusterfsd", GF_LOG_ERROR, @@ -329,7 +322,7 @@ create_fuse_mount (glusterfs_ctx_t *ctx) } if (cmd_args->dump_fuse) { - ret = dict_set_static_ptr (master->options, ZR_DUMP_FUSE, + ret = dict_set_static_ptr (options, ZR_DUMP_FUSE, cmd_args->dump_fuse); if (ret < 0) { gf_log ("glusterfsd", GF_LOG_ERROR, @@ -340,7 +333,7 @@ create_fuse_mount (glusterfs_ctx_t *ctx) } if (cmd_args->acl) { - ret = dict_set_static_ptr (master->options, "acl", "on"); + 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"); @@ -348,8 +341,37 @@ create_fuse_mount (glusterfs_ctx_t *ctx) } } + if (cmd_args->selinux) { + ret = dict_set_static_ptr (options, "selinux", "on"); + if (ret < 0) { + gf_log ("glusterfsd", GF_LOG_ERROR, + "failed to set dict value for key selinux"); + goto err; + } + } + + if (cmd_args->aux_gfid_mount) { + ret = dict_set_static_ptr (options, "virtual-gfid-access", + "on"); + if (ret < 0) { + gf_log ("glusterfsd", GF_LOG_ERROR, + "failed to set dict value for key " + "aux-gfid-mount"); + goto err; + } + } + + if (cmd_args->enable_ino32) { + ret = dict_set_static_ptr (options, "enable-ino32", "on"); + if (ret < 0) { + gf_log ("glusterfsd", GF_LOG_ERROR, + "failed to set dict value for key enable-ino32"); + goto err; + } + } + if (cmd_args->read_only) { - ret = dict_set_static_ptr (master->options, "read-only", "on"); + 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"); @@ -357,9 +379,66 @@ create_fuse_mount (glusterfs_ctx_t *ctx) } } + 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 (master->options, ZR_DIRECT_IO_OPT, + ret = dict_set_static_ptr (options, ZR_DIRECT_IO_OPT, "disable"); if (ret < 0) { gf_log ("glusterfsd", GF_LOG_ERROR, @@ -369,7 +448,7 @@ create_fuse_mount (glusterfs_ctx_t *ctx) } break; case GF_OPTION_ENABLE: /* enable */ - ret = dict_set_static_ptr (master->options, ZR_DIRECT_IO_OPT, + ret = dict_set_static_ptr (options, ZR_DIRECT_IO_OPT, "enable"); if (ret < 0) { gf_log ("glusterfsd", GF_LOG_ERROR, @@ -386,8 +465,8 @@ create_fuse_mount (glusterfs_ctx_t *ctx) } if (!cmd_args->no_daemon_mode) { - ret = dict_set_static_ptr (master->options, "sync-mtab", - "enable"); + 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"); @@ -395,6 +474,77 @@ create_fuse_mount (glusterfs_ctx_t *ctx) } } + if (cmd_args->use_readdirp) { + ret = dict_set_str (options, "use-readdirp", + cmd_args->use_readdirp); + if (ret < 0) { + gf_log ("glusterfsd", GF_LOG_ERROR, "failed to set dict" + " value for key use-readdirp"); + goto err; + } + } + ret = 0; +err: + return ret; +} + +int +create_fuse_mount (glusterfs_ctx_t *ctx) +{ + int ret = 0; + cmd_args_t *cmd_args = NULL; + xlator_t *master = NULL; + + cmd_args = &ctx->cmd_args; + + if (!cmd_args->mount_point) { + gf_log ("", GF_LOG_TRACE, + "mount point not found, not a client process"); + return 0; + } + + if (ctx->process_mode != GF_CLIENT_PROCESS) { + gf_log("glusterfsd", GF_LOG_ERROR, + "Not a client process, not performing mount operation"); + return -1; + } + + master = GF_CALLOC (1, sizeof (*master), + gfd_mt_xlator_t); + if (!master) + goto err; + + 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"); @@ -410,7 +560,7 @@ err: xlator_destroy (master); } - return -1; + return 1; } @@ -446,7 +596,58 @@ get_volfp (glusterfs_ctx_t *ctx) } static int -gf_remember_xlator_option (struct list_head *options, char *arg) +gf_remember_backup_volfile_server (char *arg) +{ + glusterfs_ctx_t *ctx = NULL; + cmd_args_t *cmd_args = NULL; + int ret = -1; + server_cmdline_t *server = NULL; + + ctx = glusterfsd_ctx; + if (!ctx) + goto out; + cmd_args = &ctx->cmd_args; + + if(!cmd_args) + goto out; + + server = GF_CALLOC (1, sizeof (server_cmdline_t), + gfd_mt_server_cmdline_t); + if (!server) + goto out; + + INIT_LIST_HEAD(&server->list); + + server->volfile_server = gf_strdup(arg); + + if (!cmd_args->volfile_server) { + cmd_args->volfile_server = server->volfile_server; + cmd_args->curr_server = server; + } + + if (!server->volfile_server) { + gf_log ("", GF_LOG_WARNING, + "xlator option %s is invalid", arg); + goto out; + } + + list_add_tail (&server->list, &cmd_args->volfile_servers); + + ret = 0; +out: + if (ret == -1) { + if (server) { + GF_FREE (server->volfile_server); + GF_FREE (server); + } + } + + return ret; + +} + +static int +gf_remember_xlator_option (char *arg) { glusterfs_ctx_t *ctx = NULL; cmd_args_t *cmd_args = NULL; @@ -455,7 +656,7 @@ gf_remember_xlator_option (struct list_head *options, char *arg) char *dot = NULL; char *equals = NULL; - ctx = glusterfs_ctx_get (); + ctx = glusterfsd_ctx; cmd_args = &ctx->cmd_args; option = GF_CALLOC (1, sizeof (xlator_cmdline_option_t), @@ -507,12 +708,9 @@ gf_remember_xlator_option (struct list_head *options, char *arg) out: if (ret == -1) { if (option) { - if (option->volume) - GF_FREE (option->volume); - if (option->key) - GF_FREE (option->key); - if (option->value) - GF_FREE (option->value); + GF_FREE (option->volume); + GF_FREE (option->key); + GF_FREE (option->value); GF_FREE (option); } @@ -526,7 +724,6 @@ out: static error_t parse_opts (int key, char *arg, struct argp_state *state) { - glusterfs_ctx_t *ctx = NULL; cmd_args_t *cmd_args = NULL; uint32_t n = 0; double d = 0.0; @@ -541,19 +738,8 @@ parse_opts (int key, char *arg, struct argp_state *state) switch (key) { case ARGP_VOLFILE_SERVER_KEY: - cmd_args->volfile_server = gf_strdup (arg); - break; - - case ARGP_VOLFILE_MAX_FETCH_ATTEMPTS: - n = 0; + gf_remember_backup_volfile_server (arg); - 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: @@ -562,6 +748,20 @@ parse_opts (int key, char *arg, struct argp_state *state) 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: @@ -583,8 +783,7 @@ parse_opts (int key, char *arg, struct argp_state *state) break; case ARGP_VOLUME_FILE_KEY: - if (cmd_args->volfile) - GF_FREE (cmd_args->volfile); + GF_FREE (cmd_args->volfile); if (arg[0] != '/') { pwd = getcwd (NULL, PATH_MAX); @@ -706,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; @@ -747,8 +958,9 @@ parse_opts (int key, char *arg, struct argp_state *state) break; case ARGP_XLATOR_OPTION_KEY: - if (gf_remember_xlator_option (&cmd_args->xlator_options, arg)) - argp_failure (state, -1, 0, "invalid xlator option %s", arg); + if (gf_remember_xlator_option (arg)) + argp_failure (state, -1, 0, "invalid xlator option %s", + arg); break; @@ -792,10 +1004,68 @@ parse_opts (int key, char *arg, struct argp_state *state) case ARGP_MEM_ACCOUNTING_KEY: /* TODO: it should have got handled much earlier */ - ctx = glusterfs_ctx_get (); - ctx->mem_accounting = 1; + //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; } @@ -807,7 +1077,7 @@ cleanup_and_exit (int signum) glusterfs_ctx_t *ctx = NULL; xlator_t *trav = NULL; - ctx = glusterfs_ctx_get (); + ctx = glusterfsd_ctx; if (!ctx) return; @@ -820,9 +1090,17 @@ cleanup_and_exit (int signum) ctx->cleanup_started = 1; glusterfs_mgmt_pmap_signout (ctx); - if (ctx->listener) { - (void) glusterfs_listener_stop (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 @@ -866,7 +1144,7 @@ reincarnate (int signum) glusterfs_ctx_t *ctx = NULL; cmd_args_t *cmd_args = NULL; - ctx = glusterfs_ctx_get (); + ctx = glusterfsd_ctx; cmd_args = &ctx->cmd_args; if (cmd_args->volfile_server) { @@ -888,37 +1166,17 @@ reincarnate (int signum) return; } - -static char * -generate_uuid () +void +emancipate (glusterfs_ctx_t *ctx, int ret) { - char tmp_str[1024] = {0,}; - char hostname[256] = {0,}; - struct timeval tv = {0,}; - struct tm now = {0, }; - char now_str[32]; - - if (gettimeofday (&tv, NULL) == -1) { - gf_log ("glusterfsd", GF_LOG_ERROR, - "gettimeofday: failed %s", - strerror (errno)); + /* 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; } - - if (gethostname (hostname, 256) == -1) { - gf_log ("glusterfsd", GF_LOG_ERROR, - "gethostname: failed %s", - strerror (errno)); - } - - localtime_r (&tv.tv_sec, &now); - strftime (now_str, 32, "%Y/%m/%d-%H:%M:%S", &now); - snprintf (tmp_str, 1024, "%s-%d-%s:%" GF_PRI_SUSECONDS, - hostname, getpid(), now_str, tv.tv_usec); - - return gf_strdup (tmp_str); } - static uint8_t gf_get_process_mode (char *exec_name) { @@ -942,82 +1200,20 @@ gf_get_process_mode (char *exec_name) } - -static int -set_log_file_path (cmd_args_t *cmd_args) -{ - 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 = gf_asprintf (&cmd_args->log_file, - DEFAULT_LOG_FILE_DIRECTORY "/%s.log", - tmp_str); - goto done; - } - - if (cmd_args->volfile) { - j = 0; - i = 0; - if (cmd_args->volfile[0] == '/') - i = 1; - for (; i < strlen (cmd_args->volfile); i++,j++) { - tmp_str[j] = cmd_args->volfile[i]; - if (cmd_args->volfile[i] == '/') - tmp_str[j] = '-'; - } - ret = gf_asprintf (&cmd_args->log_file, - DEFAULT_LOG_FILE_DIRECTORY "/%s.log", - tmp_str); - goto done; - } - - if (cmd_args->volfile_server) { - port = 1; - tmp_ptr = "default"; - - if (cmd_args->volfile_server_port) - port = cmd_args->volfile_server_port; - if (cmd_args->volfile_id) - tmp_ptr = cmd_args->volfile_id; - - ret = gf_asprintf (&cmd_args->log_file, - DEFAULT_LOG_FILE_DIRECTORY "/%s-%s-%d.log", - cmd_args->volfile_server, tmp_ptr, port); - } -done: - return ret; -} - - static int glusterfs_ctx_defaults_init (glusterfs_ctx_t *ctx) { - cmd_args_t *cmd_args = NULL; - struct rlimit lim = {0, }; - call_pool_t *pool = NULL; + 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_uuid (); + ctx->process_uuid = generate_glusterfs_ctx_id (); if (!ctx->process_uuid) { gf_log ("", GF_LOG_CRITICAL, "ERROR: glusterfs uuid generation failed"); - return -1; + goto out; } ctx->page_size = 128 * GF_UNIT_KB; @@ -1026,65 +1222,67 @@ glusterfs_ctx_defaults_init (glusterfs_ctx_t *ctx) if (!ctx->iobuf_pool) { gf_log ("", GF_LOG_CRITICAL, "ERROR: glusterfs iobuf pool creation failed"); - return -1; + 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"); - return -1; + goto out; } - pool = GF_CALLOC (1, sizeof (call_pool_t), - gfd_mt_call_pool_t); - if (!pool) { + 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"); - return -1; + goto out; } + INIT_LIST_HEAD (&ctx->pool->all_frames); + LOCK_INIT (&ctx->pool->lock); + /* frame_mem_pool size 112 * 4k */ - pool->frame_mem_pool = mem_pool_new (call_frame_t, 4096); - if (!pool->frame_mem_pool) { + 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"); - return -1; + goto out; } /* stack_mem_pool size 256 * 1024 */ - pool->stack_mem_pool = mem_pool_new (call_stack_t, 1024); - if (!pool->stack_mem_pool) { + 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"); - return -1; + 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"); - return -1; + goto out; } ctx->dict_pool = mem_pool_new (dict_t, GF_MEMPOOL_COUNT_OF_DICT_T); if (!ctx->dict_pool) - return -1; + goto out; ctx->dict_pair_pool = mem_pool_new (data_pair_t, GF_MEMPOOL_COUNT_OF_DATA_PAIR_T); if (!ctx->dict_pair_pool) - return -1; + goto out; ctx->dict_data_pool = mem_pool_new (data_t, GF_MEMPOOL_COUNT_OF_DATA_T); if (!ctx->dict_data_pool) - return -1; - - INIT_LIST_HEAD (&pool->all_frames); - LOCK_INIT (&pool->lock); - ctx->pool = 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 */ @@ -1101,33 +1299,68 @@ glusterfs_ctx_defaults_init (glusterfs_ctx_t *ctx) #endif cmd_args->fuse_attribute_timeout = -1; cmd_args->fuse_entry_timeout = -1; + cmd_args->fopen_keep_cache = GF_OPTION_DEFERRED; INIT_LIST_HEAD (&cmd_args->xlator_options); + INIT_LIST_HEAD (&cmd_args->volfile_servers); lim.rlim_cur = RLIM_INFINITY; lim.rlim_max = RLIM_INFINITY; setrlimit (RLIMIT_CORE, &lim); - return 0; + ret = 0; +out: + + if (ret && ctx) { + if (ctx->pool) { + mem_pool_destroy (ctx->pool->frame_mem_pool); + mem_pool_destroy (ctx->pool->stack_mem_pool); + } + GF_FREE (ctx->pool); + mem_pool_destroy (ctx->stub_mem_pool); + mem_pool_destroy (ctx->dict_pool); + mem_pool_destroy (ctx->dict_data_pool); + mem_pool_destroy (ctx->dict_pair_pool); + } + + return ret; } static int -logging_init (glusterfs_ctx_t *ctx) +logging_init (glusterfs_ctx_t *ctx, const char *progpath) { cmd_args_t *cmd_args = NULL; int ret = 0; + char ident[1024] = {0,}; + char *progname = NULL; + char *ptr = NULL; cmd_args = &ctx->cmd_args; if (cmd_args->log_file == NULL) { - ret = set_log_file_path (cmd_args); + ret = gf_set_log_file_path (cmd_args); if (ret == -1) { fprintf (stderr, "ERROR: failed to set the log file path\n"); return -1; } } - if (gf_log_init (cmd_args->log_file) == -1) { +#ifdef GF_USE_SYSLOG + progname = gf_strdup (progpath); + snprintf (ident, 1024, "%s_%s", basename(progname), + basename(cmd_args->log_file)); + GF_FREE (progname); + /* remove .log suffix */ + if (NULL != (ptr = strrchr(ident, '.'))) { + if (strcmp(ptr, ".log") == 0) { + /* note: ptr points to location in ident only */ + ptr[0] = '\0'; + } + } + ptr = ident; +#endif + + if (gf_log_init (ctx, cmd_args->log_file, ptr) == -1) { fprintf (stderr, "ERROR: failed to open logfile %s\n", cmd_args->log_file); return -1; @@ -1139,12 +1372,12 @@ logging_init (glusterfs_ctx_t *ctx) } void -gf_check_and_set_mem_acct (int argc, char *argv[], glusterfs_ctx_t *ctx) +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) { - ctx->mem_accounting = 1; + gf_mem_acct_enable_set (ctx); break; } } @@ -1153,16 +1386,14 @@ gf_check_and_set_mem_acct (int argc, char *argv[], glusterfs_ctx_t *ctx) int parse_cmdline (int argc, char *argv[], glusterfs_ctx_t *ctx) { - int process_mode = 0; - int ret = 0; - struct stat stbuf = {0, }; - struct tm *tm = NULL; - time_t utime; - char timestr[256]; - char tmp_logfile[1024] = { 0 }; - char *tmp_logfile_dyn = NULL; - char *tmp_logfilebase = NULL; - cmd_args_t *cmd_args = NULL; + int process_mode = 0; + int ret = 0; + struct stat stbuf = {0, }; + char timestr[32]; + char tmp_logfile[1024] = { 0 }; + char *tmp_logfile_dyn = NULL; + char *tmp_logfilebase = NULL; + cmd_args_t *cmd_args = NULL; cmd_args = &ctx->cmd_args; @@ -1219,8 +1450,8 @@ parse_cmdline (int argc, char *argv[], glusterfs_ctx_t *ctx) (S_ISREG (stbuf.st_mode) || S_ISLNK (stbuf.st_mode))) || (ret == -1)) { /* Have separate logfile per run */ - tm = localtime (&utime); - strftime (timestr, 256, "%Y%m%d.%H%M%S", tm); + gf_time_fmt (timestr, sizeof timestr, time (NULL), + gf_timefmt_FT); sprintf (tmp_logfile, "%s.%s.%d", cmd_args->log_file, timestr, getpid ()); @@ -1258,7 +1489,7 @@ int glusterfs_pidfile_setup (glusterfs_ctx_t *ctx) { cmd_args_t *cmd_args = NULL; - int ret = 0; + int ret = -1; FILE *pidfp = NULL; cmd_args = &ctx->cmd_args; @@ -1271,7 +1502,7 @@ glusterfs_pidfile_setup (glusterfs_ctx_t *ctx) gf_log ("glusterfsd", GF_LOG_ERROR, "pidfile %s error (%s)", cmd_args->pid_file, strerror (errno)); - return -1; + goto out; } ret = lockf (fileno (pidfp), F_TLOCK, 0); @@ -1279,7 +1510,7 @@ glusterfs_pidfile_setup (glusterfs_ctx_t *ctx) gf_log ("glusterfsd", GF_LOG_ERROR, "pidfile %s lock error (%s)", cmd_args->pid_file, strerror (errno)); - return ret; + goto out; } gf_log ("glusterfsd", GF_LOG_TRACE, @@ -1291,12 +1522,17 @@ glusterfs_pidfile_setup (glusterfs_ctx_t *ctx) gf_log ("glusterfsd", GF_LOG_ERROR, "pidfile %s unlock error (%s)", cmd_args->pid_file, strerror (errno)); - return ret; + goto out; } ctx->pidfp = pidfp; - return 0; + ret = 0; +out: + if (ret && pidfp) + fclose (pidfp); + + return ret; } @@ -1409,10 +1645,10 @@ glusterfs_sigwaiter (void *arg) reincarnate (sig); break; case SIGUSR1: - gf_proc_dump_info (sig); + gf_proc_dump_info (sig, glusterfsd_ctx); break; case SIGUSR2: - gf_latency_toggle (sig); + gf_latency_toggle (sig, glusterfsd_ctx); break; default: @@ -1424,6 +1660,13 @@ glusterfs_sigwaiter (void *arg) } +void +glusterfsd_print_trace (int signum) +{ + gf_print_trace (signum, glusterfsd_ctx); +} + + int glusterfs_signals_setup (glusterfs_ctx_t *ctx) { @@ -1433,12 +1676,12 @@ glusterfs_signals_setup (glusterfs_ctx_t *ctx) sigemptyset (&set); /* common setting for all threads */ - signal (SIGSEGV, gf_print_trace); - signal (SIGABRT, gf_print_trace); - signal (SIGILL, gf_print_trace); - signal (SIGTRAP, gf_print_trace); - signal (SIGFPE, gf_print_trace); - signal (SIGBUS, gf_print_trace); + signal (SIGSEGV, glusterfsd_print_trace); + signal (SIGABRT, glusterfsd_print_trace); + signal (SIGILL, glusterfsd_print_trace); + signal (SIGTRAP, glusterfsd_print_trace); + signal (SIGFPE, glusterfsd_print_trace); + signal (SIGBUS, glusterfsd_print_trace); signal (SIGINT, cleanup_and_exit); signal (SIGPIPE, SIG_IGN); @@ -1450,7 +1693,7 @@ glusterfs_signals_setup (glusterfs_ctx_t *ctx) ret = pthread_sigmask (SIG_BLOCK, &set, NULL); if (ret) { - gf_log ("", GF_LOG_WARNING, + gf_log ("glusterfsd", GF_LOG_WARNING, "failed to execute pthread_signmask %s", strerror (errno)); return ret; @@ -1464,7 +1707,7 @@ glusterfs_signals_setup (glusterfs_ctx_t *ctx) fallback to signals getting handled by other threads. setup the signal handlers */ - gf_log ("", GF_LOG_WARNING, + gf_log ("glusterfsd", GF_LOG_WARNING, "failed to create pthread %s", strerror (errno)); return ret; @@ -1480,6 +1723,7 @@ 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; @@ -1493,24 +1737,48 @@ daemonize (glusterfs_ctx_t *ctx) 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; + } + ret = os_daemon_return (0, 0); switch (ret) { case -1: + if (ctx->daemon_pipe[0] != -1) { + close (ctx->daemon_pipe[0]); + close (ctx->daemon_pipe[1]); + } + gf_log ("daemonize", GF_LOG_ERROR, "Daemonization failed: %s", strerror(errno)); goto out; case 0: + /* child */ + /* close read */ + close (ctx->daemon_pipe[0]); break; default: - if (ctx->mtab_pid > 0) { - ret = waitpid (ctx->mtab_pid, &cstatus, 0); - if (!(ret == ctx->mtab_pid && cstatus == 0)) { + /* 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, - "/etc/mtab update failed"); + "mount failed"); exit (1); } } - _exit (0); + + err = 1; + read (ctx->daemon_pipe[0], (void *)&err, sizeof (err)); + _exit (err); } postfork: @@ -1559,7 +1827,7 @@ glusterfs_process_volfp (glusterfs_ctx_t *ctx, FILE *fp) goto out; } - gf_log_volume_file (fp); + gf_log_dump_graph (fp, graph); ret = 0; out: @@ -1592,7 +1860,8 @@ glusterfs_volumes_init (glusterfs_ctx_t *ctx) if (cmd_args->volfile_server) { ret = glusterfs_mgmt_init (ctx); - goto out; + /* return, do not emancipate() yet */ + return ret; } fp = get_volfp (ctx); @@ -1609,30 +1878,42 @@ glusterfs_volumes_init (glusterfs_ctx_t *ctx) goto out; out: + emancipate (ctx, ret); return ret; } +/* This is the only legal global pointer */ +glusterfs_ctx_t *glusterfsd_ctx; + int main (int argc, char *argv[]) { glusterfs_ctx_t *ctx = NULL; int ret = -1; + char cmdlinestr[PATH_MAX] = {0,}; - ret = glusterfs_globals_init (); - if (ret) - return ret; - - ctx = glusterfs_ctx_get (); + ctx = glusterfs_ctx_new (); if (!ctx) { gf_log ("glusterfs", GF_LOG_CRITICAL, "ERROR: glusterfs context not initialized"); return ENOMEM; } -#ifndef DEBUG + 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 (argc, argv, ctx); + 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; @@ -1641,14 +1922,23 @@ main (int argc, char *argv[]) if (ret) goto out; - ret = logging_init (ctx); + ret = logging_init (ctx, argv[0]); if (ret) goto out; - /* log the version of glusterfs running here */ - gf_log (argv[0], GF_LOG_INFO, - "Started running %s version %s", - argv[0], PACKAGE_VERSION); + /* 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(); @@ -1660,7 +1950,7 @@ main (int argc, char *argv[]) if (ret) goto out; - ctx->env = syncenv_new (0); + ctx->env = syncenv_new (0, 0, 0); if (!ctx->env) { gf_log ("", GF_LOG_ERROR, "Could not create new sync-environment"); diff --git a/glusterfsd/src/glusterfsd.h b/glusterfsd/src/glusterfsd.h index 21f1cbb6c..9e2a0e56e 100644 --- a/glusterfsd/src/glusterfsd.h +++ b/glusterfsd/src/glusterfsd.h @@ -1,22 +1,12 @@ /* - Copyright (c) 2006-2011 Gluster, Inc. <http://www.gluster.com> - This file is part of GlusterFS. + Copyright (c) 2006-2012 Red Hat, Inc. <http://www.redhat.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/>. + 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. */ - #ifndef __GLUSTERFSD_H__ #define __GLUSTERFSD_H__ @@ -30,8 +20,6 @@ #define DEFAULT_GLUSTERD_VOLFILE CONFDIR "/glusterd.vol" #define DEFAULT_CLIENT_VOLFILE CONFDIR "/glusterfs.vol" #define DEFAULT_SERVER_VOLFILE CONFDIR "/glusterfsd.vol" -#define DEFAULT_LOG_FILE_DIRECTORY DATADIR "/log/glusterfs" -#define DEFAULT_LOG_LEVEL GF_LOG_INFO #define DEFAULT_EVENT_POOL_SIZE 16384 @@ -63,6 +51,7 @@ enum argp_option_keys { ARGP_NO_DAEMON_KEY = 'N', ARGP_RUN_ID_KEY = 'r', ARGP_DEBUG_KEY = 133, + ARGP_NEGATIVE_TIMEOUT_KEY = 134, ARGP_ENTRY_TIMEOUT_KEY = 135, ARGP_ATTRIBUTE_TIMEOUT_KEY = 136, ARGP_VOLUME_NAME_KEY = 137, @@ -86,6 +75,15 @@ enum argp_option_keys { ARGP_WORM_KEY = 155, ARGP_USER_MAP_ROOT_KEY = 156, ARGP_MEM_ACCOUNTING_KEY = 157, + ARGP_SELINUX_KEY = 158, + ARGP_FOPEN_KEEP_CACHE_KEY = 159, + ARGP_GID_TIMEOUT_KEY = 160, + ARGP_FUSE_BACKGROUND_QLEN_KEY = 161, + ARGP_FUSE_CONGESTION_THRESHOLD_KEY = 162, + ARGP_INODE32_KEY = 163, + ARGP_FUSE_MOUNTOPTS_KEY = 164, + ARGP_FUSE_USE_READDIRP_KEY = 165, + ARGP_AUX_GFID_MOUNT_KEY = 166, }; struct _gfd_vol_top_priv_t { @@ -104,6 +102,12 @@ int glusterfs_mgmt_pmap_signin (glusterfs_ctx_t *ctx); int glusterfs_volfile_fetch (glusterfs_ctx_t *ctx); void cleanup_and_exit (int signum); -void *glusterfs_volume_top_read_perf (void *args); -void *glusterfs_volume_top_write_perf (void *args); +int glusterfs_volume_top_write_perf (uint32_t blk_size, uint32_t blk_count, + char *brick_path, double *throughput, + double *time); +int glusterfs_volume_top_read_perf (uint32_t blk_size, uint32_t blk_count, + char *brick_path, double *throughput, + double *time); + +extern glusterfs_ctx_t *glusterfsd_ctx; #endif /* __GLUSTERFSD_H__ */ |