param: hand arguments after -- straight to init

The kernel passes any args it doesn't need through to init, except it
assumes anything containing '.' belongs to the kernel (for a module).
This change means all users can clearly distinguish which arguments
are for init.

For example, the kernel uses debug ("dee-bug") to mean log everything to
the console, where systemd uses the debug from the Scandinavian "day-boog"
meaning "fail to boot".  If a future versions uses argv[] instead of
reading /proc/cmdline, this confusion will be avoided.

eg: test 'FOO="this is --foo"' -- 'systemd.debug="true true true"'

Gives:
argv[0] = '/debug-init'
argv[1] = 'test'
argv[2] = 'systemd.debug=true true true'
envp[0] = 'HOME=/'
envp[1] = 'TERM=linux'
envp[2] = 'FOO=this is --foo'

Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>

2 files changed, 23 insertions, 14 deletions

diff --git a/kernel/module.c b/kernel/module.c
index 11869408f79b..66e4e0d260a9 100644
--- a/kernel/module.c
+++ b/kernel/module.c
@@ -3193,6 +3193,7 @@ static int load_module(struct load_info *info, const char __user *uargs,
 {
         struct module *mod;
         long err;
+        char *after_dashes;
 
         err = module_sig_check(info);
         if (err)
@@ -3277,10 +3278,15 @@ static int load_module(struct load_info *info, const char __user *uargs,
                 goto ddebug_cleanup;
 
         /* Module is ready to execute: parsing args may do that. */
-        err = parse_args(mod->name, mod->args, mod->kp, mod->num_kp,
-                         -32768, 32767, unknown_module_param_cb);
-        if (err < 0)
+        after_dashes = parse_args(mod->name, mod->args, mod->kp, mod->num_kp,
+                                  -32768, 32767, unknown_module_param_cb);
+        if (IS_ERR(after_dashes)) {
+                err = PTR_ERR(after_dashes);
                 goto bug_cleanup;
+        } else if (after_dashes) {
+                pr_warn("%s: parameters '%s' after `--' ignored\n",
+                       mod->name, after_dashes);
+        }
 
         /* Link in to syfs. */
         err = mod_sysfs_setup(mod, info, mod->kp, mod->num_kp);
diff --git a/kernel/params.c b/kernel/params.c
index b00142e7f3ba..1e52ca233fd9 100644
--- a/kernel/params.c
+++ b/kernel/params.c
@@ -177,13 +177,13 @@ static char *next_arg(char *args, char **param, char **val)
 }
 
 /* Args looks like "foo=bar,bar2 baz=fuz wiz". */
-int parse_args(const char *doing,
-               char *args,
-               const struct kernel_param *params,
-               unsigned num,
-               s16 min_level,
-               s16 max_level,
-               int (*unknown)(char *param, char *val, const char *doing))
+char *parse_args(const char *doing,
+                 char *args,
+                 const struct kernel_param *params,
+                 unsigned num,
+                 s16 min_level,
+                 s16 max_level,
+                 int (*unknown)(char *param, char *val, const char *doing))
 {
         char *param, *val;
 
@@ -198,6 +198,9 @@ int parse_args(const char *doing,
                 int irq_was_disabled;
 
                 args = next_arg(args, &param, &val);
+                /* Stop at -- */
+                if (!val && strcmp(param, "--") == 0)
+                        return args;
                 irq_was_disabled = irqs_disabled();
                 ret = parse_one(param, val, doing, params, num,
                                 min_level, max_level, unknown);
@@ -208,22 +211,22 @@ int parse_args(const char *doing,
                 switch (ret) {
                 case -ENOENT:
                         pr_err("%s: Unknown parameter `%s'\n", doing, param);
-                        return ret;
+                        return ERR_PTR(ret);
                 case -ENOSPC:
                         pr_err("%s: `%s' too large for parameter `%s'\n",
                                doing, val ?: "", param);
-                        return ret;
+                        return ERR_PTR(ret);
                 case 0:
                         break;
                 default:
                         pr_err("%s: `%s' invalid for parameter `%s'\n",
                                doing, val ?: "", param);
-                        return ret;
+                        return ERR_PTR(ret);
                 }
         }
 
         /* All parsed OK. */
-        return 0;
+        return NULL;
 }
 
 /* Lazy bastard, eh? */