Merge branch 'upstream'

Conflicts:
	api/src/glfs-fops.c
	api/src/glfs-handleops.c

Change-Id: I6811674cc4ec4be6fa6e4cdebb4bc428194bebd8

4 files changed, 230 insertions, 8 deletions

diff --git a/xlators/mgmt/glusterd/src/glusterd-geo-rep.c b/xlators/mgmt/glusterd/src/glusterd-geo-rep.c
index c5c76e11a..3969db17c 100644
--- a/xlators/mgmt/glusterd/src/glusterd-geo-rep.c
+++ b/xlators/mgmt/glusterd/src/glusterd-geo-rep.c
@@ -1295,6 +1295,158 @@ glusterd_check_gsync_running (glusterd_volinfo_t *volinfo, gf_boolean_t *flag)
         return 0;
 }
 
+/*
+ * is_geo_rep_active:
+ *      This function reads the state_file and sets is_active to 1 if the
+ *      monitor status is neither "Stopped" or "Not Started"
+ *
+ * RETURN VALUE:
+ *       0: On successful read of state_file.
+ *      -1: error.
+ */
+
+static int
+is_geo_rep_active (glusterd_volinfo_t *volinfo, char *slave,
+                   char *conf_path, int *is_active)
+{
+        dict_t                 *confd                      = NULL;
+        char                   *statefile                  = NULL;
+        char                   *master                     = NULL;
+        char                    monitor_status[PATH_MAX]   = "";
+        int                     ret                        = -1;
+        xlator_t               *this                       = NULL;
+
+        this = THIS;
+        GF_ASSERT (this);
+
+        master = volinfo->volname;
+
+        confd = dict_new ();
+        if (!confd) {
+                gf_log ("", GF_LOG_ERROR, "Not able to create dict.");
+                goto out;
+        }
+
+        ret = glusterd_gsync_get_config (master, slave, conf_path,
+                                         confd);
+        if (ret) {
+                gf_log ("", GF_LOG_ERROR, "Unable to get configuration data "
+                        "for %s(master), %s(slave)", master, slave);
+                ret = -1;
+                goto out;
+        }
+
+        ret = dict_get_param (confd, "state_file", &statefile);
+        if (ret) {
+                gf_log ("", GF_LOG_ERROR, "Unable to get state_file's name "
+                        "for %s(master), %s(slave). Please check gsync "
+                        "config file.", master, slave);
+                ret = -1;
+                goto out;
+        }
+
+        ret = glusterd_gsync_read_frm_status (statefile, monitor_status,
+                                              sizeof (monitor_status));
+        if (ret <= 0) {
+                gf_log ("", GF_LOG_ERROR, "Unable to read the status "
+                        "file for %s(master), %s(slave)", master, slave);
+                strncpy (monitor_status, "defunct", sizeof (monitor_status));
+        }
+
+        if ((!strcmp(monitor_status, "Stopped")) ||
+            (!strcmp(monitor_status, "Not Started"))) {
+                *is_active = 0;
+        } else {
+                *is_active = 1;
+        }
+        ret = 0;
+out:
+        if (confd)
+                dict_destroy (confd);
+        return ret;
+}
+
+/*
+ * _get_slave_status:
+ *      Called for each slave in the volume from dict_foreach.
+ *      It calls is_geo_rep_active to get the monitor status.
+ *
+ * RETURN VALUE:
+ *      0: On successful read of state_file from is_geo_rep_active.
+ *         When it is found geo-rep is already active from previous calls.
+ *         When there is no slave.
+ *     -1: On error.
+ */
+
+int
+_get_slave_status (dict_t *dict, char *key, data_t *value, void *data)
+{
+        gsync_status_param_t          *param               = NULL;
+        char                          *slave               = NULL;
+        char                          *slave_ip            = NULL;
+        char                          *slave_vol           = NULL;
+        char                          *errmsg              = NULL;
+        char                           conf_path[PATH_MAX] = "";
+        int                            ret                 = -1;
+        glusterd_conf_t               *priv                = NULL;
+        xlator_t                      *this                = NULL;
+
+        param = (gsync_status_param_t *)data;
+
+        GF_ASSERT (param);
+        GF_ASSERT (param->volinfo);
+
+        if (param->is_active) {
+                ret = 0;
+                goto out;
+        }
+
+        this = THIS;
+        GF_ASSERT (this);
+
+        if (this)
+                priv = this->private;
+        if (priv == NULL) {
+                gf_log ("", GF_LOG_ERROR, "priv of glusterd not present");
+                goto out;
+        }
+
+        slave = strchr(value->data, ':');
+        if (!slave) {
+                ret = 0;
+                goto out;
+        }
+        slave++;
+
+        ret = glusterd_get_slave_info (slave, &slave_ip, &slave_vol, &errmsg);
+        if (ret) {
+                if (errmsg)
+                        gf_log ("", GF_LOG_ERROR, "Unable to fetch "
+                                "slave details. Error: %s", errmsg);
+                else
+                        gf_log ("", GF_LOG_ERROR,
+                                "Unable to fetch slave details.");
+                ret = -1;
+                goto out;
+        }
+
+        ret = snprintf (conf_path, sizeof(conf_path) - 1,
+                        "%s/"GEOREP"/%s_%s_%s/gsyncd.conf",
+                        priv->workdir, param->volinfo->volname,
+                        slave_ip, slave_vol);
+        if (ret < 0) {
+                gf_log ("", GF_LOG_ERROR, "Unable to assign conf_path.");
+                ret = -1;
+                goto out;
+        }
+        conf_path[ret] = '\0';
+
+        ret = is_geo_rep_active (param->volinfo,slave, conf_path,
+                                 &param->is_active);
+out:
+        return ret;
+}
+
 static int
 glusterd_op_verify_gsync_running (glusterd_volinfo_t *volinfo,
                                   char *slave, char *conf_path,
@@ -2462,7 +2614,7 @@ glusterd_gsync_configure (glusterd_volinfo_t *volinfo, char *slave,
                 goto out;
         }
 
-        if (!strcmp (op_name, "state_file")) {
+        if ((!strcmp (op_name, "state_file")) && (op_value)) {
 
                 ret = lstat (op_value, &stbuf);
                 if (ret) {
diff --git a/xlators/mgmt/glusterd/src/glusterd-op-sm.h b/xlators/mgmt/glusterd/src/glusterd-op-sm.h
index 62f991933..1125368ce 100644
--- a/xlators/mgmt/glusterd/src/glusterd-op-sm.h
+++ b/xlators/mgmt/glusterd/src/glusterd-op-sm.h
@@ -165,6 +165,11 @@ typedef struct glusterd_gsync_status_temp {
         char *node;
 }glusterd_gsync_status_temp_t;
 
+typedef struct gsync_status_param {
+        int is_active;
+        glusterd_volinfo_t *volinfo;
+}gsync_status_param_t;
+
 typedef enum cli_cmd_type_ {
         PER_REPLICA,
         ALL_REPLICA,
diff --git a/xlators/mgmt/glusterd/src/glusterd-quota.c b/xlators/mgmt/glusterd/src/glusterd-quota.c
index 3c8dcf8dd..ffde532bd 100644
--- a/xlators/mgmt/glusterd/src/glusterd-quota.c
+++ b/xlators/mgmt/glusterd/src/glusterd-quota.c
@@ -28,6 +28,8 @@
 #include <sys/wait.h>
 #include <dlfcn.h>
 
+/* Any negative pid to make it special client */
+#define QUOTA_CRAWL_PID "-100"
 
 const char *gd_quota_op_list[GF_QUOTA_OPTION_TYPE_DEFAULT_SOFT_LIMIT+1] = {
         [GF_QUOTA_OPTION_TYPE_NONE]               = "none",
@@ -158,7 +160,8 @@ out:
 }
 
 int32_t
-glusterd_quota_initiate_fs_crawl (glusterd_conf_t *priv, char *volname)
+glusterd_quota_initiate_fs_crawl (glusterd_conf_t *priv, char *volname,
+                                  int type)
 {
         pid_t                      pid;
         int32_t                    ret              = 0;
@@ -178,6 +181,7 @@ glusterd_quota_initiate_fs_crawl (glusterd_conf_t *priv, char *volname)
                          "-s", "localhost",
                          "--volfile-id", volname,
 			 "--use-readdirp=no",
+                         "--client-pid", QUOTA_CRAWL_PID,
                          "-l", DEFAULT_LOG_FILE_DIRECTORY"/quota-crawl.log",
                          mountdir, NULL);
 
@@ -210,7 +214,19 @@ glusterd_quota_initiate_fs_crawl (glusterd_conf_t *priv, char *volname)
                         exit (EXIT_FAILURE);
                 }
                 runinit (&runner);
-                runner_add_args (&runner, "/usr/bin/find", "find", ".", NULL);
+
+                if (type == GF_QUOTA_OPTION_TYPE_ENABLE)
+
+                        runner_add_args (&runner, "/usr/bin/find", "find", ".",
+                                         NULL);
+
+                else if (type == GF_QUOTA_OPTION_TYPE_DISABLE)
+
+                        runner_add_args (&runner, "/usr/bin/find", ".",
+                                         "-exec", "/usr/bin/setfattr", "-n",
+                                         VIRTUAL_QUOTA_XATTR_CLEANUP_KEY, "-v",
+                                         "1", "{}", "\\", ";", NULL);
+
                 if (runner_start (&runner) == -1)
                         _exit (EXIT_FAILURE);
 
@@ -325,7 +341,8 @@ out:
 }
 
 int32_t
-glusterd_quota_disable (glusterd_volinfo_t *volinfo, char **op_errstr)
+glusterd_quota_disable (glusterd_volinfo_t *volinfo, char **op_errstr,
+                        gf_boolean_t *crawl)
 {
         int32_t    ret            = -1;
         int        i              =  0;
@@ -381,6 +398,8 @@ glusterd_quota_disable (glusterd_volinfo_t *volinfo, char **op_errstr)
         if (ret)
                 goto out;
 
+        *crawl = _gf_true;
+
         (void) glusterd_clean_up_quota_store (volinfo);
 
         ret = 0;
@@ -1045,7 +1064,8 @@ glusterd_op_quota (dict_t *dict, char **op_errstr, dict_t *rsp_dict)
                         break;
 
                 case GF_QUOTA_OPTION_TYPE_DISABLE:
-                        ret = glusterd_quota_disable (volinfo, op_errstr);
+                        ret = glusterd_quota_disable (volinfo, op_errstr,
+                                                      &start_crawl);
                         if (ret < 0)
                                 goto out;
 
@@ -1129,7 +1149,7 @@ glusterd_op_quota (dict_t *dict, char **op_errstr, dict_t *rsp_dict)
         }
 
         if (rsp_dict && start_crawl == _gf_true)
-                glusterd_quota_initiate_fs_crawl (priv, volname);
+                glusterd_quota_initiate_fs_crawl (priv, volname, type);
 
         if (priv->op_version > GD_OP_VERSION_MIN) {
                 ret = glusterd_quotad_op (type);
diff --git a/xlators/mgmt/glusterd/src/glusterd-volume-ops.c b/xlators/mgmt/glusterd/src/glusterd-volume-ops.c
index df2562ba6..051e7d756 100644
--- a/xlators/mgmt/glusterd/src/glusterd-volume-ops.c
+++ b/xlators/mgmt/glusterd/src/glusterd-volume-ops.c
@@ -30,6 +30,8 @@
 #define glusterd_op_start_volume_args_get(dict, volname, flags) \
         glusterd_op_stop_volume_args_get (dict, volname, flags)
 
+extern int
+_get_slave_status (dict_t *this, char *key, data_t *value, void *data);
 
 int
 __glusterd_handle_create_volume (rpcsvc_request_t *req)
@@ -921,7 +923,7 @@ glusterd_op_stage_start_volume (dict_t *dict, char **op_errstr)
         gf_boolean_t                            exists = _gf_false;
         glusterd_volinfo_t                      *volinfo = NULL;
         glusterd_brickinfo_t                    *brickinfo = NULL;
-        char                                    msg[2048];
+        char                                    msg[2048] = {0,};
         glusterd_conf_t                         *priv = NULL;
         xlator_t                                *this = NULL;
         uuid_t                                  volume_id = {0,};
@@ -1059,6 +1061,7 @@ glusterd_op_stage_stop_volume (dict_t *dict, char **op_errstr)
         glusterd_volinfo_t                      *volinfo = NULL;
         char                                    msg[2048] = {0};
         xlator_t                                *this = NULL;
+        gsync_status_param_t                    param = {0,};
 
         this = THIS;
         GF_ASSERT (this);
@@ -1102,7 +1105,22 @@ glusterd_op_stage_stop_volume (dict_t *dict, char **op_errstr)
         if (ret && (is_run == _gf_false))
                 gf_log (this->name, GF_LOG_WARNING, "Unable to get the status"
                         " of active "GEOREP" session");
-        if (is_run) {
+
+        param.volinfo = volinfo;
+        ret = dict_foreach (volinfo->gsync_slaves, _get_slave_status, &param);
+
+        if (ret) {
+                gf_log (this->name, GF_LOG_WARNING, "_get_slave_satus failed");
+                snprintf (msg, sizeof(msg), GEOREP" Unable to get the status "
+                          "of active "GEOREP" session for the volume '%s'.\n"
+                          "Please check the log file for more info. Use "
+                          "'force' option to ignore and stop the volume.",
+                          volname);
+                ret = -1;
+                goto out;
+        }
+
+        if (is_run && param.is_active) {
                 gf_log (this->name, GF_LOG_WARNING, GEOREP" sessions active"
                         "for the volume %s ", volname);
                 snprintf (msg, sizeof(msg), GEOREP" sessions are active "
@@ -1756,6 +1774,9 @@ glusterd_op_stop_volume (dict_t *dict)
         glusterd_volinfo_t                      *volinfo = NULL;
         glusterd_brickinfo_t                    *brickinfo = NULL;
         xlator_t                                *this = NULL;
+        char                                    mountdir[PATH_MAX] = {0,};
+        runner_t                                runner = {0,};
+        char                                    pidfile[PATH_MAX] = {0,};
 
         this = THIS;
         GF_ASSERT (this);
@@ -1783,6 +1804,30 @@ glusterd_op_stop_volume (dict_t *dict)
         if (ret)
                 goto out;
 
+        /* If quota auxiliary mount is present, unmount it */
+        GLUSTERFS_GET_AUX_MOUNT_PIDFILE (pidfile, volname);
+
+        if (!gf_is_service_running (pidfile, NULL)) {
+                gf_log (this->name, GF_LOG_DEBUG, "Aux mount of volume %s "
+                        "absent", volname);
+        } else {
+                GLUSTERD_GET_QUOTA_AUX_MOUNT_PATH (mountdir, volname, "/");
+
+                runinit (&runner);
+                runner_add_args (&runner, "umount",
+
+                #if GF_LINUX_HOST_OS
+                                "-l",
+                #endif
+                                mountdir, NULL);
+                ret = runner_run_reuse (&runner);
+                if (ret)
+                        gf_log (this->name, GF_LOG_ERROR, "umount on %s failed, "
+                                "reason : %s", mountdir, strerror (errno));
+
+                runner_end (&runner);
+        }
+
         ret = glusterd_nodesvcs_handle_graph_change (volinfo);
 out:
         return ret;