Merge git://github.com/rustyrussell/linux

* git://github.com/rustyrussell/linux:
  params: make dashes and underscores in parameter names truly equal
  kmod: prevent kmod_loop_msg overflow in __request_module()

4 files changed, 39 insertions, 10 deletions

diff --git a/include/linux/moduleparam.h b/include/linux/moduleparam.h
index ddaae98c53f9..fffb10bd5514 100644
--- a/include/linux/moduleparam.h
+++ b/include/linux/moduleparam.h
@@ -262,6 +262,26 @@ static inline void __kernel_param_unlock(void)
                             .str = &__param_string_##name, 0, perm);    \
         __MODULE_PARM_TYPE(name, "string")
 
+/**
+ * parameq - checks if two parameter names match
+ * @name1: parameter name 1
+ * @name2: parameter name 2
+ *
+ * Returns true if the two parameter names are equal.
+ * Dashes (-) are considered equal to underscores (_).
+ */
+extern bool parameq(const char *name1, const char *name2);
+
+/**
+ * parameqn - checks if two parameter names match
+ * @name1: parameter name 1
+ * @name2: parameter name 2
+ * @n: the length to compare
+ *
+ * Similar to parameq(), except it compares @n characters.
+ */
+extern bool parameqn(const char *name1, const char *name2, size_t n);
+
 /* Called on module insert or kernel boot */
 extern int parse_args(const char *name,
                       char *args,
diff --git a/init/main.c b/init/main.c
index 03b408dff825..63f5f6f8dc3b 100644
--- a/init/main.c
+++ b/init/main.c
@@ -163,7 +163,7 @@ static int __init obsolete_checksetup(char *line)
         p = __setup_start;
         do {
                 int n = strlen(p->str);
-                if (!strncmp(line, p->str, n)) {
+                if (parameqn(line, p->str, n)) {
                         if (p->early) {
                                 /* Already done in parse_early_param?
                                  * (Needs exact match on param part).
@@ -392,7 +392,7 @@ static int __init do_early_param(char *param, char *val)
         const struct obs_kernel_param *p;
 
         for (p = __setup_start; p < __setup_end; p++) {
-                if ((p->early && strcmp(param, p->str) == 0) ||
+                if ((p->early && parameq(param, p->str)) ||
                     (strcmp(param, "console") == 0 &&
                      strcmp(p->str, "earlycon") == 0)
                 ) {
diff --git a/kernel/kmod.c b/kernel/kmod.c
index ddc7644c1305..a4bea97c75b6 100644
--- a/kernel/kmod.c
+++ b/kernel/kmod.c
@@ -114,10 +114,12 @@ int __request_module(bool wait, const char *fmt, ...)
         atomic_inc(&kmod_concurrent);
         if (atomic_read(&kmod_concurrent) > max_modprobes) {
                 /* We may be blaming an innocent here, but unlikely */
-                if (kmod_loop_msg++ < 5)
+                if (kmod_loop_msg < 5) {
                         printk(KERN_ERR
                                "request_module: runaway loop modprobe %s\n",
                                module_name);
+                        kmod_loop_msg++;
+                }
                 atomic_dec(&kmod_concurrent);
                 return -ENOMEM;
         }
diff --git a/kernel/params.c b/kernel/params.c
index 22df3e0d142a..821788947e40 100644
--- a/kernel/params.c
+++ b/kernel/params.c
@@ -67,20 +67,27 @@ static void maybe_kfree_parameter(void *param)
         }
 }
 
-static inline char dash2underscore(char c)
+static char dash2underscore(char c)
 {
         if (c == '-')
                 return '_';
         return c;
 }
 
-static inline int parameq(const char *input, const char *paramname)
+bool parameqn(const char *a, const char *b, size_t n)
 {
-        unsigned int i;
-        for (i = 0; dash2underscore(input[i]) == paramname[i]; i++)
-                if (input[i] == '\0')
-                        return 1;
-        return 0;
+        size_t i;
+
+        for (i = 0; i < n; i++) {
+                if (dash2underscore(a[i]) != dash2underscore(b[i]))
+                        return false;
+        }
+        return true;
+}
+
+bool parameq(const char *a, const char *b)
+{
+        return parameqn(a, b, strlen(a)+1);
 }
 
 static int parse_one(char *param,