dynamic_debug: remove unneeded includes

[deliverable/linux.git] / kernel / params.c

diff --git a/kernel/params.c b/kernel/params.c
index 47f5bf12434a5c20a12a65d5b792b8dce1159c75..be78c904b5646a47d0a2ea5840bb1dbd35fce0f0 100644 (file)
--- a/kernel/params.c
+++ b/kernel/params.c
@@ -85,9 +85,13 @@ bool parameq(const char *a, const char *b)
 
 static int parse_one(char *param,
                     char *val,
+                    const char *doing,
                     const struct kernel_param *params,
                     unsigned num_params,
-                    int (*handle_unknown)(char *param, char *val))
+                    s16 min_level,
+                    s16 max_level,
+                    int (*handle_unknown)(char *param, char *val,
+                                    const char *doing))
 {
        unsigned int i;
        int err;
@@ -95,12 +99,15 @@ static int parse_one(char *param,
        /* Find parameter */
        for (i = 0; i < num_params; i++) {
                if (parameq(param, params[i].name)) {
+                       if (params[i].level < min_level
+                           || params[i].level > max_level)
+                               return 0;
                        /* No one handled NULL, so do it here. */
                        if (!val && params[i].ops->set != param_set_bool
                            && params[i].ops->set != param_set_bint)
                                return -EINVAL;
-                       pr_debug("They are equal!  Calling %p\n",
-                              params[i].ops->set);
+                       pr_debug("handling %s with %p\n", param,
+                               params[i].ops->set);
                        mutex_lock(&param_lock);
                        err = params[i].ops->set(val, &params[i]);
                        mutex_unlock(&param_lock);
@@ -109,11 +116,11 @@ static int parse_one(char *param,
        }
 
        if (handle_unknown) {
-               pr_debug("Unknown argument: calling %p\n", handle_unknown);
-               return handle_unknown(param, val);
+               pr_debug("doing %s: %s='%s'\n", doing, param, val);
+               return handle_unknown(param, val, doing);
        }
 
-       pr_debug("Unknown argument `%s'\n", param);
+       pr_debug("Unknown argument '%s'\n", param);
        return -ENOENT;
 }
 
@@ -170,26 +177,30 @@ static char *next_arg(char *args, char **param, char **val)
 }
 
 /* Args looks like "foo=bar,bar2 baz=fuz wiz". */
-int parse_args(const char *name,
+int parse_args(const char *doing,
               char *args,
               const struct kernel_param *params,
               unsigned num,
-              int (*unknown)(char *param, char *val))
+              s16 min_level,
+              s16 max_level,
+              int (*unknown)(char *param, char *val, const char *doing))
 {
        char *param, *val;
 
-       pr_debug("Parsing ARGS: %s\n", args);
-
        /* Chew leading spaces */
        args = skip_spaces(args);
 
+       if (*args)
+               pr_debug("doing %s, parsing ARGS: '%s'\n", doing, args);
+
        while (*args) {
                int ret;
                int irq_was_disabled;
 
                args = next_arg(args, &param, &val);
                irq_was_disabled = irqs_disabled();
-               ret = parse_one(param, val, params, num, unknown);
+               ret = parse_one(param, val, doing, params, num,
+                               min_level, max_level, unknown);
                if (irq_was_disabled && !irqs_disabled()) {
                        printk(KERN_WARNING "parse_args(): option '%s' enabled "
                                        "irq's!\n", param);
@@ -197,19 +208,19 @@ int parse_args(const char *name,
                switch (ret) {
                case -ENOENT:
                        printk(KERN_ERR "%s: Unknown parameter `%s'\n",
-                              name, param);
+                              doing, param);
                        return ret;
                case -ENOSPC:
                        printk(KERN_ERR
                               "%s: `%s' too large for parameter `%s'\n",
-                              name, val ?: "", param);
+                              doing, val ?: "", param);
                        return ret;
                case 0:
                        break;
                default:
                        printk(KERN_ERR
                               "%s: `%s' invalid for parameter `%s'\n",
-                              name, val ?: "", param);
+                              doing, val ?: "", param);
                        return ret;
                }
        }
@@ -297,35 +308,18 @@ EXPORT_SYMBOL(param_ops_charp);
 /* Actually could be a bool or an int, for historical reasons. */
 int param_set_bool(const char *val, const struct kernel_param *kp)
 {
-       bool v;
-       int ret;
-
        /* No equals means "set"... */
        if (!val) val = "1";
 
        /* One of =[yYnN01] */
-       ret = strtobool(val, &v);
-       if (ret)
-               return ret;
-
-       if (kp->flags & KPARAM_ISBOOL)
-               *(bool *)kp->arg = v;
-       else
-               *(int *)kp->arg = v;
-       return 0;
+       return strtobool(val, kp->arg);
 }
 EXPORT_SYMBOL(param_set_bool);
 
 int param_get_bool(char *buffer, const struct kernel_param *kp)
 {
-       bool val;
-       if (kp->flags & KPARAM_ISBOOL)
-               val = *(bool *)kp->arg;
-       else
-               val = *(int *)kp->arg;
-
        /* Y and N chosen as being relatively non-coder friendly */
-       return sprintf(buffer, "%c", val ? 'Y' : 'N');
+       return sprintf(buffer, "%c", *(bool *)kp->arg ? 'Y' : 'N');
 }
 EXPORT_SYMBOL(param_get_bool);
 
@@ -343,7 +337,6 @@ int param_set_invbool(const char *val, const struct kernel_param *kp)
        struct kernel_param dummy;
 
        dummy.arg = &boolval;
-       dummy.flags = KPARAM_ISBOOL;
        ret = param_set_bool(val, &dummy);
        if (ret == 0)
                *(bool *)kp->arg = !boolval;
@@ -372,7 +365,6 @@ int param_set_bint(const char *val, const struct kernel_param *kp)
        /* Match bool exactly, by re-using it. */
        boolkp = *kp;
        boolkp.arg = &v;
-       boolkp.flags |= KPARAM_ISBOOL;
 
        ret = param_set_bool(val, &boolkp);
        if (ret == 0)
@@ -393,7 +385,7 @@ static int param_array(const char *name,
                       unsigned int min, unsigned int max,
                       void *elem, int elemsize,
                       int (*set)(const char *, const struct kernel_param *kp),
-                      u16 flags,
+                      s16 level,
                       unsigned int *num)
 {
        int ret;
@@ -403,7 +395,7 @@ static int param_array(const char *name,
        /* Get the name right for errors. */
        kp.name = name;
        kp.arg = elem;
-       kp.flags = flags;
+       kp.level = level;
 
        *num = 0;
        /* We expect a comma-separated list of values. */
@@ -444,7 +436,7 @@ static int param_array_set(const char *val, const struct kernel_param *kp)
        unsigned int temp_num;
 
        return param_array(kp->name, val, 1, arr->max, arr->elem,
-                          arr->elemsize, arr->ops->set, kp->flags,
+                          arr->elemsize, arr->ops->set, kp->level,
                           arr->num ?: &temp_num);
 }