LU-9120 lnet: sysfs functions for module params

Allow transaction timeout and retry count module parameters to be
set and shown via sysfs.

Test-Parameters: forbuildonly
Signed-off-by: Amir Shehata <ashehata@whamcloud.com>
Change-Id: Ica3819f9343a4b45cb0ae322f85f936230fa8138
Reviewed-on: https://review.whamcloud.com/32861
Reviewed-by: Sonia Sharma <sharmaso@whamcloud.com>
Reviewed-by: Olaf Weber <olaf.weber@hpe.com>
Tested-by: Jenkins

diff --git a/lnet/lnet/api-ni.c b/lnet/lnet/api-ni.c
index aa35054..0b6bdc2 100644 (file)
--- a/lnet/lnet/api-ni.c
+++ b/lnet/lnet/api-ni.c
@@ -140,15 +140,42 @@ MODULE_PARM_DESC(lnet_peer_discovery_disabled,
                "Set to 1 to disable peer discovery on this node.");
 
 unsigned lnet_transaction_timeout = 5;
-module_param(lnet_transaction_timeout, uint, 0444);
-MODULE_PARM_DESC(lnet_transaction_timeout,
-               "Time in seconds to wait for a REPLY or an ACK");
+static int transaction_to_set(const char *val, cfs_kernel_param_arg_t *kp);
+static struct kernel_param_ops param_ops_transaction_timeout = {
+       .set = transaction_to_set,
+       .get = param_get_int,
+};
+
+#define param_check_transaction_timeout(name, p) \
+               __param_check(name, p, int)
+#ifdef HAVE_KERNEL_PARAM_OPS
+module_param(lnet_transaction_timeout, transaction_timeout, S_IRUGO|S_IWUSR);
+#else
+module_param_call(lnet_transaction_timeout, transaction_to_set, param_get_int,
+                 &lnet_transaction_timeout, S_IRUGO|S_IWUSR);
+#endif
+MODULE_PARM_DESC(lnet_peer_discovery_disabled,
+               "Set to 1 to disable peer discovery on this node.");
 
 unsigned lnet_retry_count = 0;
-module_param(lnet_retry_count, uint, 0444);
+static int retry_count_set(const char *val, cfs_kernel_param_arg_t *kp);
+static struct kernel_param_ops param_ops_retry_count = {
+       .set = retry_count_set,
+       .get = param_get_int,
+};
+
+#define param_check_retry_count(name, p) \
+               __param_check(name, p, int)
+#ifdef HAVE_KERNEL_PARAM_OPS
+module_param(lnet_retry_count, retry_count, S_IRUGO|S_IWUSR);
+#else
+module_param_call(lnet_retry_count, retry_count_set, param_get_int,
+                 &lnet_retry_count, S_IRUGO|S_IWUSR);
+#endif
 MODULE_PARM_DESC(lnet_retry_count,
                 "Maximum number of times to retry transmitting a message");
 
+
 unsigned lnet_lnd_timeout = LNET_LND_DEFAULT_TIMEOUT;
 
 /*
@@ -253,6 +280,103 @@ discovery_set(const char *val, cfs_kernel_param_arg_t *kp)
 }
 
 static int
+transaction_to_set(const char *val, cfs_kernel_param_arg_t *kp)
+{
+       int rc;
+       unsigned *transaction_to = (unsigned *)kp->arg;
+       unsigned long value;
+
+       rc = kstrtoul(val, 0, &value);
+       if (rc) {
+               CERROR("Invalid module parameter value for 'lnet_transaction_timeout'\n");
+               return rc;
+       }
+
+       /*
+        * The purpose of locking the api_mutex here is to ensure that
+        * the correct value ends up stored properly.
+        */
+       mutex_lock(&the_lnet.ln_api_mutex);
+
+       if (the_lnet.ln_state != LNET_STATE_RUNNING) {
+               mutex_unlock(&the_lnet.ln_api_mutex);
+               return 0;
+       }
+
+       if (value < lnet_retry_count || value == 0) {
+               mutex_unlock(&the_lnet.ln_api_mutex);
+               CERROR("Invalid value for lnet_transaction_timeout (%lu). "
+                      "Has to be greater than lnet_retry_count (%u)\n",
+                      value, lnet_retry_count);
+               return -EINVAL;
+       }
+
+       if (value == *transaction_to) {
+               mutex_unlock(&the_lnet.ln_api_mutex);
+               return 0;
+       }
+
+       *transaction_to = value;
+       if (lnet_retry_count == 0)
+               lnet_lnd_timeout = value;
+       else
+               lnet_lnd_timeout = value / lnet_retry_count;
+
+       mutex_unlock(&the_lnet.ln_api_mutex);
+
+       return 0;
+}
+
+static int
+retry_count_set(const char *val, cfs_kernel_param_arg_t *kp)
+{
+       int rc;
+       unsigned *retry_count = (unsigned *)kp->arg;
+       unsigned long value;
+
+       rc = kstrtoul(val, 0, &value);
+       if (rc) {
+               CERROR("Invalid module parameter value for 'lnet_retry_count'\n");
+               return rc;
+       }
+
+       /*
+        * The purpose of locking the api_mutex here is to ensure that
+        * the correct value ends up stored properly.
+        */
+       mutex_lock(&the_lnet.ln_api_mutex);
+
+       if (the_lnet.ln_state != LNET_STATE_RUNNING) {
+               mutex_unlock(&the_lnet.ln_api_mutex);
+               return 0;
+       }
+
+       if (value > lnet_transaction_timeout) {
+               mutex_unlock(&the_lnet.ln_api_mutex);
+               CERROR("Invalid value for lnet_retry_count (%lu). "
+                      "Has to be smaller than lnet_transaction_timeout (%u)\n",
+                      value, lnet_transaction_timeout);
+               return -EINVAL;
+       }
+
+       if (value == *retry_count) {
+               mutex_unlock(&the_lnet.ln_api_mutex);
+               return 0;
+       }
+
+       *retry_count = value;
+
+       if (value == 0)
+               lnet_lnd_timeout = lnet_transaction_timeout;
+       else
+               lnet_lnd_timeout = lnet_transaction_timeout / value;
+
+       mutex_unlock(&the_lnet.ln_api_mutex);
+
+       return 0;
+}
+
+static int
 intf_max_set(const char *val, cfs_kernel_param_arg_t *kp)
 {
        int value, rc;