Reply back to CLI on error, by validating each xlator's opts

Signed-off-by: Kaushik BV <kaushikbv@gluster.com>
Signed-off-by: Vijay Bellur <vijay@dev.gluster.com>

BUG: 1159 ()
URL: http://bugs.gluster.com/cgi-bin/bugzilla3/show_bug.cgi?id=1159

4 files changed, 343 insertions, 2 deletions

diff --git a/xlators/performance/io-cache/src/io-cache.c b/xlators/performance/io-cache/src/io-cache.c
index e95b5cfd21b..b094f97c4ef 100644
--- a/xlators/performance/io-cache/src/io-cache.c
+++ b/xlators/performance/io-cache/src/io-cache.c
@@ -1476,6 +1476,143 @@ mem_acct_init (xlator_t *this)
 }
 
 int
+validate_options (xlator_t *this, dict_t *options, char **op_errstr)
+{
+        int32_t          cache_timeout;
+        int64_t          min_file_size = 0;
+        int64_t          max_file_size = 0;
+        char            *tmp = NULL;
+        uint64_t         cache_size;
+        char            *cache_size_string = NULL;
+        int              ret = 0;
+
+
+        if (dict_get (options, "cache-timeout")) {
+                cache_timeout = data_to_uint32 (dict_get (options,
+                                "cache-timeout"));
+                if (cache_timeout < 0){
+                        gf_log (this->name, GF_LOG_WARNING,
+                                "cache-timeout %d seconds invalid,"
+                                                " has to be  >=0", cache_timeout);
+                        *op_errstr = gf_strdup ("Error, should be >= 0");
+                        ret = -1;
+                        goto out;
+                }
+                
+
+                if (cache_timeout > 60){
+                        gf_log (this->name, GF_LOG_WARNING,
+                                "cache-timeout %d seconds invalid,"
+                                                " has to be  <=60", cache_timeout);
+                        *op_errstr = gf_strdup ("Error, should be <= 60");
+                        ret = -1;
+                        goto out;
+                }
+
+                        
+
+                gf_log (this->name, GF_LOG_DEBUG,
+                        "Validated cache-timeout revalidate cache");
+        }
+
+
+        if (dict_get (options, "cache-size"))
+                cache_size_string = data_to_str (dict_get (options, 
+                                "cache-size"));
+        if (cache_size_string) {
+                if (gf_string2bytesize (cache_size_string, 
+                    &cache_size) != 0) {
+                            gf_log ("io-cache", GF_LOG_ERROR, 
+                                    "invalid number format \"%s\" of "
+                                                    "\"option cache-size\" Defaulting"
+                                                    "to old value", cache_size_string);
+                            *op_errstr = gf_strdup ("Error, Invalid Format");       
+                            ret = -1;
+                            goto out;
+                    }
+
+                    if (cache_size < ( 4 * GF_UNIT_MB)) {
+                            gf_log(this->name, GF_LOG_WARNING, "Reconfiguration"
+                                            "'option cache-size %s' failed , Max value"
+                                                            "can be 4MiB, Defaulting to old value (%d)"
+                                                            , cache_size_string, cache_size);
+                            *op_errstr = gf_strdup ("Error, Cannot be less than 4MB");
+                            ret = -1;
+                            goto out;
+                    }
+
+                    if (cache_size > ( 6 * GF_UNIT_GB)) {
+                            gf_log(this->name, GF_LOG_WARNING, "Validation"
+                                            "'option cache-size %s' failed , Max value"
+                                                            "can be 6GiB, Defaulting to old value (%d)"
+                                                            , cache_size_string, cache_size);
+                            *op_errstr = gf_strdup ("Error, Cannot be more than 6GB");
+                            ret = -1;
+                            goto out;
+                    }
+                        
+
+                    gf_log (this->name, GF_LOG_DEBUG, "Validated "
+                                    " cache-size %"PRIu64"", cache_size);
+        }
+
+ 
+        tmp = data_to_str (dict_get (options, "min-file-size"));
+        if (tmp != NULL) {
+                if (gf_string2bytesize (tmp,
+                    (uint64_t *)&min_file_size)
+                    != 0) {
+                        gf_log ("io-cache", GF_LOG_WARNING, 
+                                "invalid number format \"%s\" of "
+                                                "\"option min-file-size\"", tmp);
+                        *op_errstr = gf_strdup ("Error, Invalid Format");
+                        ret = -1;
+                        goto out;
+                    }
+                
+                    gf_log (this->name, GF_LOG_DEBUG, 
+                            "Validated min-file-size %"PRIu64"", 
+                            min_file_size);
+        }
+
+
+        tmp = data_to_str (dict_get (options, "max-file-size"));
+        if (tmp != NULL) {
+                if (gf_string2bytesize (tmp,
+                    (uint64_t *)&max_file_size)
+                    != 0) {
+                        gf_log ("io-cache", GF_LOG_WARNING,
+                                "invalid number format \"%s\" of "
+                                                "\"option max-file-size\"", tmp);
+                        *op_errstr = gf_strdup ("Error, Invalid Format");
+                        ret = -1;       
+                        goto out;
+                    }
+
+                
+                    gf_log (this->name, GF_LOG_WARNING,
+                            "Validated max-file-size %"PRIu64"",
+                            max_file_size);
+        }
+  
+        if ((max_file_size >= 0) & (min_file_size > max_file_size)) {
+                gf_log ("io-cache", GF_LOG_WARNING, "minimum size (%"
+                                PRIu64") of a file that can be cached is "
+                                                "greater than maximum size (%"PRIu64"). ",
+                                                min_file_size, max_file_size);
+                *op_errstr = gf_strdup ("Error, min-file-size greater"
+                                "than max-file-size");
+                ret = -1;
+                goto out;
+        }
+
+
+out:    
+                return ret;
+
+}
+
+int
 reconfigure (xlator_t *this, dict_t *options)
 {
 	ioc_table_t     *table = NULL;
@@ -1518,6 +1655,9 @@ reconfigure (xlator_t *this, dict_t *options)
 				"Reconfiguring %d seconds to"
 				" revalidate cache", table->cache_timeout);
 		}
+                else 
+                        table->cache_timeout = 1;
+                        
 
 
 		if (dict_get (options, "cache-size"))
@@ -1557,6 +1697,8 @@ reconfigure (xlator_t *this, dict_t *options)
 				" cache-size %"PRIu64"", table->cache_size);
 			table->cache_size = cache_size;
 		}
+                else
+                        table->cache_size = IOC_CACHE_SIZE;
 
 	
 		if (dict_get (options, "priority")) {
@@ -1626,6 +1768,10 @@ reconfigure (xlator_t *this, dict_t *options)
 
 		table->min_file_size = min_file_size;
 		table->max_file_size = max_file_size;
+                if (!data_to_str (dict_get (options, "min-file-size")))
+                    table->min_file_size = 0;
+                if (data_to_str (dict_get (options, "max-file-size")))
+                    table->max_file_size = 0;
 	}
 	
 	ioc_table_unlock (table);
diff --git a/xlators/performance/io-threads/src/io-threads.c b/xlators/performance/io-threads/src/io-threads.c
index b593e90e449..fe3274fc0fa 100644
--- a/xlators/performance/io-threads/src/io-threads.c
+++ b/xlators/performance/io-threads/src/io-threads.c
@@ -2084,6 +2084,44 @@ mem_acct_init (xlator_t *this)
         return ret;
 }
 
+int
+validate_options ( xlator_t *this, dict_t *options, char **op_errstr)
+{
+        int              ret = 0;
+        int              thread_count;
+        
+
+        if (dict_get (options, "thread-count")) {
+                thread_count = data_to_int32 (dict_get (options,
+                                              "thread-count"));
+
+                if (thread_count < IOT_MIN_THREADS) {
+                        gf_log ("io-threads", GF_LOG_DEBUG,
+                                "volume set thread_count WRONG,it is lesser");
+                        ret = -1;
+                        *op_errstr = gf_strdup ("LESSER Than min. threads");
+                        goto out;
+                }
+
+                if (thread_count > IOT_MAX_THREADS) {
+                        gf_log ("io-threads", GF_LOG_DEBUG,
+                                "volume set thread_count WRONG,it is greater");
+                        *op_errstr = gf_strdup ("GREATER than max. threads");
+                        ret = -1;
+                        goto out;
+                }
+
+
+        }
+
+        ret = 0;
+
+out:
+                return ret;
+
+        
+}
+
 
 int
 reconfigure ( xlator_t *this, dict_t *options)
@@ -2095,6 +2133,8 @@ reconfigure ( xlator_t *this, dict_t *options)
         conf = this->private;
         if (!conf)
                 goto out;
+        
+        thread_count = conf->max_count;
 
 	if (dict_get (options, "thread-count")) {
                 thread_count = data_to_int32 (dict_get (options,
@@ -2116,6 +2156,8 @@ reconfigure ( xlator_t *this, dict_t *options)
 
 		conf->max_count = thread_count;
         }
+        else 
+                conf->max_count = thread_count;
 
 	ret = 0;
 
diff --git a/xlators/performance/quick-read/src/quick-read.c b/xlators/performance/quick-read/src/quick-read.c
index 6751089b331..91243561e3c 100644
--- a/xlators/performance/quick-read/src/quick-read.c
+++ b/xlators/performance/quick-read/src/quick-read.c
@@ -2411,6 +2411,91 @@ mem_acct_init (xlator_t *this)
 }
 
 
+int
+validate_options (xlator_t *this, dict_t *options, char **op_errstr)
+{
+        char         *str  = NULL;
+        int32_t       ret  = -1;
+        int32_t       cache_timeout;
+ 
+        if (!this)
+                goto out;
+
+        
+
+        ret = dict_get_str (this->options, "cache-timeout", &str);
+        if (ret == 0) {
+                ret = gf_string2uint_base10 (str, 
+                                             (unsigned int *)&cache_timeout);
+                if (ret != 0) {
+                        gf_log (this->name, GF_LOG_ERROR,
+                                "invalid cache-timeout value %s", str);
+                        *op_errstr = "Invalid Format!!";
+                        ret = -1;
+                        goto out;
+                } 
+                if (ret < 1  || ret > 60) {
+                        gf_log (this->name, GF_LOG_ERROR,
+                                "invalid cache-timeout value %s", str);
+                        *op_errstr = "Range 1 <= value <= 60";
+                                        ret = -1;
+                        goto out;
+                }
+        }
+
+
+        ret =0;
+out:
+                return ret;
+
+}
+
+int
+reconfigure (xlator_t *this, dict_t *options)
+{
+       
+                
+        
+        char         *str  = NULL;
+        int32_t       ret  = -1;
+        qr_private_t *priv = NULL;
+        qr_conf_t    *conf = NULL;
+        int32_t       cache_timeout;
+ 
+        if (!this)
+                goto out;
+        
+        priv = this->private;
+        if (!priv)
+                goto out;
+        
+        conf = &priv->conf;
+        if (!conf)
+                goto out;
+        
+        cache_timeout = conf->cache_timeout;
+        ret = dict_get_str (this->options, "cache-timeout", &str);
+        if (ret == 0) {
+                ret = gf_string2uint_base10 (str, 
+                                             (unsigned int *)&conf->cache_timeout);
+                if (ret != 0) {
+                        gf_log (this->name, GF_LOG_ERROR,
+                                "invalid cache-timeout value %s", str);
+                        ret = -1;
+                        goto out;
+                } 
+                conf->cache_timeout = cache_timeout;
+        }
+        else
+                conf->cache_timeout = 1;
+        
+        ret = 0;
+out:
+        return ret;
+
+}
+
+
 int32_t
 qr_get_priority_list (const char *opt_str, struct list_head *first)
 {
diff --git a/xlators/performance/write-behind/src/write-behind.c b/xlators/performance/write-behind/src/write-behind.c
index db3ca28be35..ef596dfbeaa 100644
--- a/xlators/performance/write-behind/src/write-behind.c
+++ b/xlators/performance/write-behind/src/write-behind.c
@@ -2728,6 +2728,71 @@ mem_acct_init (xlator_t *this)
 }
 
 int
+validate_options (xlator_t *this, dict_t *options, char **op_errstr)
+{
+        char         *str=NULL;
+        uint64_t     window_size;
+        gf_boolean_t flush_behind;
+
+        int          ret = 0;
+
+
+
+        ret = dict_get_str (options, "cache-size", 
+                            &str);
+        if (ret == 0) {
+                ret = gf_string2bytesize (str, &window_size);
+                if (ret != 0) {
+                        gf_log(this->name, GF_LOG_WARNING, "Validation"
+                                        "'option cache-size %s failed , Invalid"
+                                                        " number format, ", str);
+                        *op_errstr = gf_strdup ("Error, Invalid num format");
+                        ret = -1;
+                        goto out;
+                }
+
+                if (window_size < (524288)) {
+                        gf_log(this->name, GF_LOG_WARNING, "Validation"
+                                        "'option cache-size %s' failed , Min value"
+                                                        "should be 512KiB ", str);
+                        *op_errstr = gf_strdup ("Error, Should be min 512KB");
+                        ret = -1;
+                        goto out;
+                }
+
+                if (window_size > (1073741824)) {
+                        gf_log(this->name, GF_LOG_WARNING, "Reconfiguration"
+                                        "'option cache-size %s' failed , Max value"
+                                                        "can be 1 GiB", str);
+                        *op_errstr = gf_strdup ("Error, Max Value is 1GB");
+                        ret = -1;
+                        goto out;
+                }
+
+        
+                gf_log(this->name, GF_LOG_DEBUG, "Validated "
+                                "'option cache-size %s '", str);
+        }
+        ret = dict_get_str (options, "flush-behind", 
+                            &str);
+        if (ret == 0) {
+                ret = gf_string2boolean (str, 
+                                         &flush_behind);
+                if (ret == -1) {
+                        gf_log (this->name, GF_LOG_WARNING,
+                                "'flush-behind' takes only boolean arguments");
+                        *op_errstr = gf_strdup ("Error, should be boolean");
+                        ret = -1;
+                        goto out;
+                }
+        }
+        ret =0;
+out:
+                return ret;
+
+}
+
+int
 reconfigure (xlator_t *this, dict_t *options)
 {
 	char	     *str=NULL;
@@ -2750,7 +2815,7 @@ reconfigure (xlator_t *this, dict_t *options)
 			goto out;
                 }
 
-		if (window_size < (2^19)) {
+		if (window_size < (512 * GF_UNIT_KB)) {
                         gf_log(this->name, GF_LOG_ERROR, "Reconfiguration"
 			      "'option cache-size %s' failed , Max value"
 			      "can be 512KiB, Defaulting to old value (%d)"
@@ -2759,7 +2824,7 @@ reconfigure (xlator_t *this, dict_t *options)
 			goto out;
                 }
 
-		if (window_size > (2^30)) {
+		if (window_size > (2 * GF_UNIT_GB)) {
                         gf_log(this->name, GF_LOG_ERROR, "Reconfiguration"
 			      "'option cache-size %s' failed , Max value"
 			      "can be 1 GiB, Defaulting to old value (%d)"
@@ -2773,6 +2838,9 @@ reconfigure (xlator_t *this, dict_t *options)
 			      "'option cache-size %s ' to %d"
 			      , str, conf->window_size);
         }
+        else
+                conf->window_size = WB_WINDOW_SIZE;
+                
 out:
 	return 0;