From c45cba4e8959cc3224c293423fdc1f33d3e657c8 Mon Sep 17 00:00:00 2001

From: Jiffin Tony Thottan <jthottan@redhat.com>

Date: Mon, 16 Oct 2017 14:24:29 +0530

Subject: [PATCH 50/74] Revert "glusterd: (storhaug) remove ganesha"

This reverts commit 843e1b04b554ab887ec656ae7b468bb93ee4e2f7.

Change-Id: I06b5450344c33f26da3d94b6f67051d41dfbba17

Signed-off-by: Jiffin Tony Thottan <jthottan@redhat.com>

---

 cli/src/cli-cmd-global.c                           |  54 ++

 cli/src/cli-cmd-parser.c                           | 106 +++

 cli/src/cli-cmd.c                                  |   3 +-

 cli/src/cli-rpc-ops.c                              |  79 ++

 cli/src/cli.h                                      |   3 +

 xlators/mgmt/glusterd/src/Makefile.am              |   4 +-

 xlators/mgmt/glusterd/src/glusterd-errno.h         |   2 +-

 xlators/mgmt/glusterd/src/glusterd-ganesha.c       | 898 +++++++++++++++++++++

 xlators/mgmt/glusterd/src/glusterd-handler.c       |  77 ++

 xlators/mgmt/glusterd/src/glusterd-messages.h      |   8 +

 xlators/mgmt/glusterd/src/glusterd-op-sm.c         |  47 ++

 .../mgmt/glusterd/src/glusterd-snapshot-utils.c    | 196 +++++

 .../mgmt/glusterd/src/glusterd-snapshot-utils.h    |   7 +

 xlators/mgmt/glusterd/src/glusterd-snapshot.c      |  96 +++

 xlators/mgmt/glusterd/src/glusterd-store.h         |   1 +

 xlators/mgmt/glusterd/src/glusterd-volume-ops.c    |  34 +

 xlators/mgmt/glusterd/src/glusterd-volume-set.c    |   6 +

 xlators/mgmt/glusterd/src/glusterd.h               |  16 +-

 18 files changed, 1633 insertions(+), 4 deletions(-)

 create mode 100644 xlators/mgmt/glusterd/src/glusterd-ganesha.c

diff --git a/cli/src/cli-cmd-global.c b/cli/src/cli-cmd-global.c

index 9873192..881506b 100644

--- a/cli/src/cli-cmd-global.c

+++ b/cli/src/cli-cmd-global.c

@@ -32,6 +32,8 @@ extern rpc_clnt_prog_t *cli_rpc_prog;

 int

 cli_cmd_global_help_cbk (struct cli_state *state, struct cli_cmd_word *in_word,

                          const char **words, int wordcount);

+int cli_cmd_ganesha_cbk (struct cli_state *state, struct cli_cmd_word *word,

+                                         const char **words, int wordcount);

 int

 cli_cmd_get_state_cbk (struct cli_state *state, struct cli_cmd_word *word,

                               const char **words, int wordcount);

@@ -46,6 +48,10 @@ struct cli_cmd global_cmds[] = {

           cli_cmd_get_state_cbk,

           "Get local state representation of mentioned daemon",

         },

+        { "nfs-ganesha {enable| disable} ",

+           cli_cmd_ganesha_cbk,

+          "Enable/disable NFS-Ganesha support",

+        },

         {NULL,  NULL,  NULL}

 };

@@ -86,6 +92,54 @@ out:

 }

+int cli_cmd_ganesha_cbk (struct cli_state *state, struct cli_cmd_word *word,

+                         const char **words, int wordcount)

+

+{

+         int                     sent        =   0;

+         int                     parse_error =   0;

+         int                     ret         =  -1;

+         rpc_clnt_procedure_t    *proc       =  NULL;

+         call_frame_t            *frame      =  NULL;

+         dict_t                  *options    =  NULL;

+         cli_local_t             *local      =  NULL;

+         char                    *op_errstr  =  NULL;

+

+        proc = &cli_rpc_prog->proctable[GLUSTER_CLI_GANESHA];

+

+        frame = create_frame (THIS, THIS->ctx->pool);

+        if (!frame)

+                goto out;

+

+        ret = cli_cmd_ganesha_parse (state, words, wordcount,

+                                     &options, &op_errstr);

+        if (ret) {

+                if (op_errstr) {

+                    cli_err ("%s", op_errstr);

+                    GF_FREE (op_errstr);

+                } else

+                    cli_usage_out (word->pattern);

+                parse_error = 1;

+                goto out;

+        }

+

+        CLI_LOCAL_INIT (local, words, frame, options);

+

+        if (proc->fn) {

+                ret = proc->fn (frame, THIS, options);

+        }

+

+out:

+        if (ret) {

+                cli_cmd_sent_status_get (&sent);

+                if ((sent == 0) && (parse_error == 0))

+                        cli_out ("Setting global option failed");

+        }

+

+        CLI_STACK_DESTROY (frame);

+        return ret;

+}

+

 int

 cli_cmd_get_state_cbk (struct cli_state *state, struct cli_cmd_word *word,

                        const char **words, int wordcount)

diff --git a/cli/src/cli-cmd-parser.c b/cli/src/cli-cmd-parser.c

index 216e050..a4c601b 100644

--- a/cli/src/cli-cmd-parser.c

+++ b/cli/src/cli-cmd-parser.c

@@ -840,6 +840,112 @@ out:

                 return ret;

 }

+/* Parsing global option for NFS-Ganesha config

+ *  gluster nfs-ganesha enable/disable */

+

+int32_t

+cli_cmd_ganesha_parse (struct cli_state *state,

+                       const char **words, int wordcount,

+                       dict_t **options, char **op_errstr)

+{

+        dict_t  *dict     =       NULL;

+        int     ret       =       -1;

+        char    *key      =       NULL;

+        char    *value    =       NULL;

+        char    *w        =       NULL;

+        char   *opwords[] =      { "enable", "disable", NULL };

+        const char      *question       =       NULL;

+        gf_answer_t     answer          =       GF_ANSWER_NO;

+

+

+        GF_ASSERT (words);

+        GF_ASSERT (options);

+

+        dict = dict_new ();

+

+        if (!dict)

+                goto out;

+

+        if (wordcount != 2)

+                goto out;

+

+        key   = (char *) words[0];

+        value = (char *) words[1];

+

+        if (!key || !value) {

+                cli_out ("Usage : nfs-ganesha <enable/disable>");

+                ret = -1;

+                goto out;

+        }

+

+        ret = gf_strip_whitespace (value, strlen (value));

+        if (ret == -1)

+                goto out;

+

+        if (strcmp (key, "nfs-ganesha")) {

+                gf_asprintf (op_errstr, "Global option: error: ' %s '"

+                          "is not a valid global option.", key);

+                ret = -1;

+                goto out;

+        }

+

+        w = str_getunamb (value, opwords);

+        if (!w) {

+                cli_out ("Invalid global option \n"

+                         "Usage : nfs-ganesha <enable/disable>");

+                ret = -1;

+                goto out;

+        }

+

+        question = "Enabling NFS-Ganesha requires Gluster-NFS to be"

+                   " disabled across the trusted pool. Do you "

+                   "still want to continue?\n";

+

+        if (strcmp (value, "enable") == 0) {

+                answer = cli_cmd_get_confirmation (state, question);

+                if (GF_ANSWER_NO == answer) {

+                        gf_log ("cli", GF_LOG_ERROR, "Global operation "

+                                "cancelled, exiting");

+                        ret = -1;

+                        goto out;

+                }

+        }

+        cli_out ("This will take a few minutes to complete. Please wait ..");

+

+        ret = dict_set_str (dict, "key", key);

+        if (ret) {

+               gf_log (THIS->name, GF_LOG_ERROR, "dict set on key failed");

+                goto out;

+        }

+

+        ret = dict_set_str (dict, "value", value);

+        if (ret) {

+               gf_log (THIS->name, GF_LOG_ERROR, "dict set on value failed");

+                goto out;

+        }

+

+        ret = dict_set_str (dict, "globalname", "All");

+        if (ret) {

+                gf_log (THIS->name, GF_LOG_ERROR, "dict set on global"

+                        " key failed.");

+                goto out;

+        }

+

+        ret = dict_set_int32 (dict, "hold_global_locks", _gf_true);

+        if (ret) {

+                gf_log (THIS->name, GF_LOG_ERROR, "dict set on global key "

+                        "failed.");

+                goto out;

+        }

+

+        *options = dict;

+out:

+        if (ret)

+                dict_unref (dict);

+

+        return ret;

+}

+

 int32_t

 cli_cmd_get_state_parse (struct cli_state *state,

                          const char **words, int wordcount,

diff --git a/cli/src/cli-cmd.c b/cli/src/cli-cmd.c

index 236009b..8a75041 100644

--- a/cli/src/cli-cmd.c

+++ b/cli/src/cli-cmd.c

@@ -369,7 +369,8 @@ cli_cmd_submit (struct rpc_clnt* rpc, void *req, call_frame_t *frame,

         unsigned        timeout = 0;

         if ((GLUSTER_CLI_PROFILE_VOLUME == procnum) ||

-            (GLUSTER_CLI_HEAL_VOLUME == procnum))

+            (GLUSTER_CLI_HEAL_VOLUME == procnum) ||

+            (GLUSTER_CLI_GANESHA == procnum))

                 timeout = cli_ten_minutes_timeout;

         else

                 timeout = cli_default_conn_timeout;

diff --git a/cli/src/cli-rpc-ops.c b/cli/src/cli-rpc-ops.c

index eb1ca77..67e29a0 100644

--- a/cli/src/cli-rpc-ops.c

+++ b/cli/src/cli-rpc-ops.c

@@ -2232,6 +2232,60 @@ out:

         return ret;

 }

+int

+gf_cli_ganesha_cbk (struct rpc_req *req, struct iovec *iov,

+                        int count, void *myframe)

+{

+        gf_cli_rsp           rsp   = {0,};

+        int                  ret   = -1;

+        dict_t               *dict = NULL;

+

+        GF_ASSERT (myframe);

+

+        if (-1 == req->rpc_status) {

+                goto out;

+        }

+

+        ret = xdr_to_generic (*iov, &rsp, (xdrproc_t)xdr_gf_cli_rsp);

+        if (ret < 0) {

+                gf_log (((call_frame_t *) myframe)->this->name, GF_LOG_ERROR,

+                        "Failed to decode xdr response");

+                goto out;

+        }

+

+        gf_log ("cli", GF_LOG_DEBUG, "Received resp to ganesha");

+

+        dict = dict_new ();

+

+        if (!dict) {

+                ret = -1;

+                goto out;

+        }

+

+        ret = dict_unserialize (rsp.dict.dict_val, rsp.dict.dict_len, &dict);

+        if (ret)

+                goto out;

+

+        if (rsp.op_ret) {

+                if (strcmp (rsp.op_errstr, ""))

+                        cli_err ("nfs-ganesha: failed: %s", rsp.op_errstr);

+                else

+                        cli_err ("nfs-ganesha: failed");

+        }

+

+        else {

+                cli_out("nfs-ganesha : success ");

+        }

+

+        ret = rsp.op_ret;

+

+out:

+        if (dict)

+                dict_unref (dict);

+        cli_cmd_broadcast_response (ret);

+        return ret;

+}

+

 char *

 is_server_debug_xlator (void *myframe)

 {

@@ -4840,6 +4894,30 @@ out:

 }

 int32_t

+gf_cli_ganesha (call_frame_t *frame, xlator_t *this, void *data)

+{

+        gf_cli_req              req =  { {0,} } ;

+        int                     ret = 0;

+        dict_t                  *dict = NULL;

+

+        if (!frame || !this ||  !data) {

+                ret = -1;

+                goto out;

+        }

+

+        dict = data;

+

+        ret = cli_to_glusterd (&req, frame, gf_cli_ganesha_cbk,

+                               (xdrproc_t) xdr_gf_cli_req, dict,

+                               GLUSTER_CLI_GANESHA, this, cli_rpc_prog,

+                               NULL);

+out:

+        gf_log ("cli", GF_LOG_DEBUG, "Returning %d", ret);

+

+        return ret;

+}

+

+int32_t

 gf_cli_set_volume (call_frame_t *frame, xlator_t *this,

                          void *data)

 {

@@ -12008,6 +12086,7 @@ struct rpc_clnt_procedure gluster_cli_actors[GLUSTER_CLI_MAXVALUE] = {

         [GLUSTER_CLI_SYS_EXEC]         = {"SYS_EXEC", gf_cli_sys_exec},

         [GLUSTER_CLI_SNAP]             = {"SNAP", gf_cli_snapshot},

         [GLUSTER_CLI_BARRIER_VOLUME]   = {"BARRIER VOLUME", gf_cli_barrier_volume},

+        [GLUSTER_CLI_GANESHA]          = {"GANESHA", gf_cli_ganesha},

         [GLUSTER_CLI_GET_VOL_OPT]      = {"GET_VOL_OPT", gf_cli_get_vol_opt},

         [GLUSTER_CLI_BITROT]           = {"BITROT", gf_cli_bitrot},

         [GLUSTER_CLI_ATTACH_TIER]      = {"ATTACH_TIER", gf_cli_attach_tier},

diff --git a/cli/src/cli.h b/cli/src/cli.h

index 68dcb8c..c9bf93d 100644

--- a/cli/src/cli.h

+++ b/cli/src/cli.h

@@ -255,6 +255,9 @@ cli_cmd_bitrot_parse (const char **words, int wordcount, dict_t **opt);

 int32_t

 cli_cmd_volume_set_parse (struct cli_state *state, const char **words,

                           int wordcount, dict_t **options, char **op_errstr);

+int32_t

+cli_cmd_ganesha_parse (struct cli_state *state, const char **words,

+                       int wordcount, dict_t **options, char **op_errstr);

 int32_t

 cli_cmd_get_state_parse (struct cli_state *state, const char **words,

diff --git a/xlators/mgmt/glusterd/src/Makefile.am b/xlators/mgmt/glusterd/src/Makefile.am

index 4858dee..23ebf37 100644

--- a/xlators/mgmt/glusterd/src/Makefile.am

+++ b/xlators/mgmt/glusterd/src/Makefile.am

@@ -5,7 +5,7 @@ glusterd_la_LDFLAGS = -module $(GF_XLATOR_DEFAULT_LDFLAGS)

 glusterd_la_SOURCES = glusterd.c glusterd-handler.c glusterd-sm.c \

 	glusterd-op-sm.c glusterd-utils.c glusterd-rpc-ops.c \

 	glusterd-store.c glusterd-handshake.c glusterd-pmap.c \

-	glusterd-volgen.c glusterd-rebalance.c \

+	glusterd-volgen.c glusterd-rebalance.c glusterd-ganesha.c \

 	glusterd-quota.c glusterd-bitrot.c glusterd-geo-rep.c \

 	glusterd-replace-brick.c glusterd-log-ops.c glusterd-tier.c \

 	glusterd-volume-ops.c glusterd-brick-ops.c glusterd-mountbroker.c \

@@ -48,6 +48,8 @@ AM_CPPFLAGS = $(GF_CPPFLAGS) -I$(top_srcdir)/libglusterfs/src \

 	-I$(CONTRIBDIR)/mount -I$(CONTRIBDIR)/userspace-rcu \

 	-DSBIN_DIR=\"$(sbindir)\" -DDATADIR=\"$(localstatedir)\" \

 	-DGSYNCD_PREFIX=\"$(GLUSTERFS_LIBEXECDIR)\" \

+	-DCONFDIR=\"$(localstatedir)/run/gluster/shared_storage/nfs-ganesha\" \

+	-DGANESHA_PREFIX=\"$(libexecdir)/ganesha\" \

 	-DSYNCDAEMON_COMPILE=$(SYNCDAEMON_COMPILE) $(XML_CPPFLAGS)

diff --git a/xlators/mgmt/glusterd/src/glusterd-errno.h b/xlators/mgmt/glusterd/src/glusterd-errno.h

index bfb56b5..3301e44 100644

--- a/xlators/mgmt/glusterd/src/glusterd-errno.h

+++ b/xlators/mgmt/glusterd/src/glusterd-errno.h

@@ -27,7 +27,7 @@ enum glusterd_op_errno {

         EG_ISSNAP      = 30813,          /* Volume is a snap volume           */

         EG_GEOREPRUN   = 30814,          /* Geo-Replication is running        */

         EG_NOTTHINP    = 30815,          /* Bricks are not thinly provisioned */

-        EG_NOGANESHA   = 30816,          /* obsolete ganesha is not enabled   */

+        EG_NOGANESHA   = 30816,          /* Global nfs-ganesha is not enabled */

 };

 #endif

diff --git a/xlators/mgmt/glusterd/src/glusterd-ganesha.c b/xlators/mgmt/glusterd/src/glusterd-ganesha.c

new file mode 100644

index 0000000..4346bad

--- /dev/null

+++ b/xlators/mgmt/glusterd/src/glusterd-ganesha.c

@@ -0,0 +1,898 @@

+/*

+   Copyright (c) 2015 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 "common-utils.h"

+#include "glusterd.h"

+#include "glusterd-op-sm.h"

+#include "glusterd-store.h"

+#include "glusterd-utils.h"

+#include "glusterd-nfs-svc.h"

+#include "glusterd-volgen.h"

+#include "glusterd-messages.h"

+#include "syscall.h"

+

+#include <ctype.h>

+

+int start_ganesha (char **op_errstr);

+

+

+typedef struct service_command {

+        char *binary;

+        char *service;

+        int (*action) (struct service_command *, char *);

+} service_command;

+

+/* parsing_ganesha_ha_conf will allocate the returned string

+ * to be freed (GF_FREE) by the caller

+ * return NULL if error or not found */

+static char*

+parsing_ganesha_ha_conf(const char *key) {

+#define MAX_LINE 1024

+        char scratch[MAX_LINE * 2] = {0,};

+        char *value = NULL, *pointer = NULL, *end_pointer = NULL;

+        FILE *fp;

+

+        fp = fopen (GANESHA_HA_CONF, "r");

+        if (fp == NULL) {

+                gf_msg (THIS->name, GF_LOG_ERROR, errno,

+                        GD_MSG_FILE_OP_FAILED, "couldn't open the file %s",

+                        GANESHA_HA_CONF);

+                goto end_ret;

+        }

+        while ((pointer = fgets (scratch, MAX_LINE, fp)) != NULL) {

+                /* Read config file until we get matching "^[[:space:]]*key" */

+                if (*pointer == '#') {

+                        continue;

+                }

+                while (isblank(*pointer)) {

+                        pointer++;

+                }

+                if (strncmp (pointer, key, strlen (key))) {

+                        continue;

+                }

+                pointer += strlen (key);

+                /* key found : if we fail to parse, we'll return an error

+                 * rather than trying next one

+                 * - supposition : conf file is bash compatible : no space

+                 *   around the '=' */

+                if (*pointer != '=') {

+                        gf_msg (THIS->name, GF_LOG_ERROR, errno,

+                                GD_MSG_GET_CONFIG_INFO_FAILED,

+                                "Parsing %s failed at key %s",

+                                GANESHA_HA_CONF, key);

+                        goto end_close;

+                }

+                pointer++;  /* jump the '=' */

+

+                if (*pointer == '"' || *pointer == '\'') {

+                        /* dont get the quote */

+                        pointer++;

+                }

+                end_pointer = pointer;

+                /* stop at the next closing quote or  blank/newline */

+                do {

+                        end_pointer++;

+                } while (!(*end_pointer == '\'' || *end_pointer == '"' ||

+                                isspace(*end_pointer) || *end_pointer == '\0'));

+                *end_pointer = '\0';

+

+                /* got it. copy it and return */

+                value = gf_strdup (pointer);

+                break;

+        }

+

+end_close:

+        fclose(fp);

+end_ret:

+        return value;

+}

+

+static int

+sc_systemctl_action (struct service_command *sc, char *command)

+{

+        runner_t        runner   = {0,};

+

+        runinit (&runner);

+        runner_add_args (&runner, sc->binary, command, sc->service, NULL);

+        return runner_run (&runner);

+}

+

+static int

+sc_service_action (struct service_command *sc, char *command)

+{

+        runner_t      runner = {0,};

+

+        runinit (&runner);

+        runner_add_args (&runner, sc->binary, sc->service, command, NULL);

+        return runner_run (&runner);

+}

+

+static int

+manage_service (char *action)

+{

+        struct stat stbuf       = {0,};

+        int     i               = 0;

+        int     ret             = 0;

+        struct service_command sc_list[] = {

+                { .binary  = "/usr/bin/systemctl",

+                  .service = "nfs-ganesha",

+                  .action  = sc_systemctl_action

+                },

+                { .binary  = "/sbin/invoke-rc.d",

+                  .service = "nfs-ganesha",

+                  .action  = sc_service_action

+                },

+                { .binary  = "/sbin/service",

+                  .service = "nfs-ganesha",

+                  .action  = sc_service_action

+                },

+                { .binary  = NULL

+                }

+        };

+

+        while (sc_list[i].binary != NULL) {

+                ret = sys_stat (sc_list[i].binary, &stbuf);

+                if (ret == 0) {

+                        gf_msg_debug (THIS->name, 0,

+                                "%s found.", sc_list[i].binary);

+                        if (strcmp (sc_list[i].binary, "/usr/bin/systemctl") == 0)

+                                ret = sc_systemctl_action (&sc_list[i], action);

+                        else

+                                ret = sc_service_action (&sc_list[i], action);

+

+                        return ret;

+                }

+                i++;

+        }

+        gf_msg (THIS->name, GF_LOG_ERROR, 0,

+                GD_MSG_UNRECOGNIZED_SVC_MNGR,

+                "Could not %s NFS-Ganesha.Service manager for distro"

+                " not recognized.", action);

+        return ret;

+}

+

+/*

+ * Check if the cluster is a ganesha cluster or not *

+ */

+gf_boolean_t

+glusterd_is_ganesha_cluster () {

+        int                ret      = -1;

+        glusterd_conf_t   *priv     = NULL;

+        xlator_t          *this     = NULL;

+        gf_boolean_t       ret_bool = _gf_false;

+

+        this = THIS;

+        GF_VALIDATE_OR_GOTO ("ganesha", this, out);

+        priv = this->private;

+        GF_VALIDATE_OR_GOTO (this->name, priv, out);

+

+        ret = dict_get_str_boolean (priv->opts,

+                                    GLUSTERD_STORE_KEY_GANESHA_GLOBAL,

+                                    _gf_false);

+        if (ret == _gf_true) {

+                ret_bool = _gf_true;

+                gf_msg_debug (this->name, 0,

+                              "nfs-ganesha is enabled for the cluster");

+        } else

+                gf_msg_debug (this->name, 0,

+                              "nfs-ganesha is disabled for the cluster");

+

+out:

+        return ret_bool;

+

+}

+

+/* Check if ganesha.enable is set to 'on', that checks if

+ * a  particular volume is exported via NFS-Ganesha */

+gf_boolean_t

+glusterd_check_ganesha_export (glusterd_volinfo_t *volinfo) {

+

+        char *value              = NULL;

+        gf_boolean_t is_exported = _gf_false;

+        int ret                 = 0;

+

+        ret = glusterd_volinfo_get (volinfo, "ganesha.enable", &value);

+        if ((ret == 0) && value) {

+                if (strcmp (value, "on") == 0) {

+                        gf_msg_debug (THIS->name, 0, "ganesha.enable set"

+                                " to %s", value);

+                        is_exported = _gf_true;

+                }

+        }

+        return is_exported;

+}

+

+/* *

+ * The below function is called as part of commit phase for volume set option

+ * "ganesha.enable". If the value is "on", it creates export configuration file

+ * and then export the volume via dbus command. Incase of "off", the volume

+ * will be already unexported during stage phase, so it will remove the conf

+ * file from shared storage

+ */

+int

+glusterd_check_ganesha_cmd (char *key, char *value, char **errstr, dict_t *dict)

+{

+        int                ret = 0;

+        char               *volname = NULL;

+

+        GF_ASSERT (key);

+        GF_ASSERT (value);

+        GF_ASSERT (dict);

+

+        if ((strcmp (key, "ganesha.enable") == 0)) {

+                if ((strcmp (value, "on")) && (strcmp (value, "off"))) {

+                        gf_asprintf (errstr, "Invalid value"

+                                " for volume set command. Use on/off only.");

+                        ret = -1;

+                        goto out;

+                }

+                if (strcmp (value, "on") == 0) {

+                        ret = glusterd_handle_ganesha_op (dict, errstr, key,

+                                                        value);

+

+                 } else if (is_origin_glusterd (dict)) {

+                        ret = dict_get_str (dict, "volname", &volname);

+                        if (ret) {

+                                gf_msg ("glusterd-ganesha", GF_LOG_ERROR, errno,

+                                GD_MSG_DICT_GET_FAILED,

+                                "Unable to get volume name");

+                                goto out;

+                        }

+                        ret = manage_export_config (volname, "off", errstr);

+                 }

+        }

+out:

+        if (ret) {

+                gf_msg ("glusterd-ganesha", GF_LOG_ERROR, 0,

+                        GD_MSG_NFS_GNS_OP_HANDLE_FAIL,

+                        "Handling NFS-Ganesha"

+                        " op failed.");

+        }

+        return ret;

+}

+

+int

+glusterd_op_stage_set_ganesha (dict_t *dict, char **op_errstr)

+{

+        int                             ret                     = -1;

+        int                             value                   = -1;

+        gf_boolean_t                    option                  = _gf_false;

+        char                            *str                    = NULL;

+        glusterd_conf_t                 *priv                   = NULL;

+        xlator_t                        *this                   = NULL;

+

+        GF_ASSERT (dict);

+        this = THIS;

+        GF_ASSERT (this);

+        priv = this->private;

+        GF_ASSERT (priv);

+

+        value = dict_get_str_boolean (dict, "value", _gf_false);

+        if (value == -1) {

+                gf_msg (this->name, GF_LOG_ERROR, errno,

+                        GD_MSG_DICT_GET_FAILED,

+                        "value not present.");

+                goto out;

+        }

+        /* This dict_get will fail if the user had never set the key before */

+        /*Ignoring the ret value and proceeding */

+        ret = dict_get_str (priv->opts, GLUSTERD_STORE_KEY_GANESHA_GLOBAL, &str);

+        if (ret == -1) {

+                gf_msg (this->name, GF_LOG_WARNING, errno,

+                        GD_MSG_DICT_GET_FAILED, "Global dict not present.");

+                ret = 0;

+                goto out;

+        }

+        /* Validity of the value is already checked */

+        ret = gf_string2boolean (str, &option);

+        /* Check if the feature is already enabled, fail in that case */

+        if (value == option) {

+                gf_asprintf (op_errstr, "nfs-ganesha is already %sd.", str);

+                ret = -1;

+                goto out;

+        }

+

+        if (value) {

+                ret =  start_ganesha (op_errstr);

+                if (ret) {

+                        gf_msg (THIS->name, GF_LOG_ERROR, 0,

+                                GD_MSG_NFS_GNS_START_FAIL,

+                                "Could not start NFS-Ganesha");

+

+                }

+        } else {

+                ret =  stop_ganesha (op_errstr);

+                if (ret)

+                        gf_msg_debug (THIS->name, 0, "Could not stop "

+                                                "NFS-Ganesha.");

+        }