rfkill: add WARN and BUG_ON paranoia (v2)

[safe/jmp/linux-2.6] / net / rfkill / rfkill.c

diff --git a/net/rfkill/rfkill.c b/net/rfkill/rfkill.c
index 47e0b2d..910699c 100644 (file)
--- a/net/rfkill/rfkill.c
+++ b/net/rfkill/rfkill.c
@@ -76,6 +76,7 @@ static BLOCKING_NOTIFIER_HEAD(rfkill_notifier_list);
  */
 int register_rfkill_notifier(struct notifier_block *nb)
 {
+       BUG_ON(!nb);
        return blocking_notifier_chain_register(&rfkill_notifier_list, nb);
 }
 EXPORT_SYMBOL_GPL(register_rfkill_notifier);
@@ -91,6 +92,7 @@ EXPORT_SYMBOL_GPL(register_rfkill_notifier);
  */
 int unregister_rfkill_notifier(struct notifier_block *nb)
 {
+       BUG_ON(!nb);
        return blocking_notifier_chain_unregister(&rfkill_notifier_list, nb);
 }
 EXPORT_SYMBOL_GPL(unregister_rfkill_notifier);
@@ -202,6 +204,9 @@ static int rfkill_toggle_radio(struct rfkill *rfkill,
                 * RFKILL_STATE_HARD_BLOCKED */
                break;
        default:
+               WARN(1, KERN_WARNING
+                       "rfkill: illegal state %d passed as parameter "
+                       "to rfkill_toggle_radio\n", state);
                return -EINVAL;
        }
 
@@ -236,7 +241,11 @@ static void __rfkill_switch_all(const enum rfkill_type type,
 {
        struct rfkill *rfkill;
 
-       if (unlikely(state >= RFKILL_STATE_MAX))
+       if (WARN((state >= RFKILL_STATE_MAX || type >= RFKILL_TYPE_MAX),
+                       KERN_WARNING
+                       "rfkill: illegal state %d or type %d "
+                       "passed as parameter to __rfkill_switch_all\n",
+                       state, type))
                return;
 
        rfkill_global_states[type].current_state = state;
@@ -334,7 +343,11 @@ int rfkill_force_state(struct rfkill *rfkill, enum rfkill_state state)
 {
        enum rfkill_state oldstate;
 
-       if (unlikely(state >= RFKILL_STATE_MAX))
+       BUG_ON(!rfkill);
+       if (WARN((state >= RFKILL_STATE_MAX),
+                       KERN_WARNING
+                       "rfkill: illegal state %d passed as parameter "
+                       "to rfkill_force_state\n", state))
                return -EINVAL;
 
        mutex_lock(&rfkill->mutex);
@@ -402,12 +415,16 @@ static ssize_t rfkill_state_store(struct device *dev,
                                  const char *buf, size_t count)
 {
        struct rfkill *rfkill = to_rfkill(dev);
-       unsigned int state = simple_strtoul(buf, NULL, 0);
+       unsigned long state;
        int error;
 
        if (!capable(CAP_NET_ADMIN))
                return -EPERM;
 
+       error = strict_strtoul(buf, 0, &state);
+       if (error)
+               return error;
+
        /* RFKILL_STATE_HARD_BLOCKED is illegal here... */
        if (state != RFKILL_STATE_UNBLOCKED &&
            state != RFKILL_STATE_SOFT_BLOCKED)
@@ -427,7 +444,7 @@ static ssize_t rfkill_claim_show(struct device *dev,
 {
        struct rfkill *rfkill = to_rfkill(dev);
 
-       return sprintf(buf, "%d", rfkill->user_claim);
+       return sprintf(buf, "%d\n", rfkill->user_claim);
 }
 
 static ssize_t rfkill_claim_store(struct device *dev,
@@ -435,7 +452,8 @@ static ssize_t rfkill_claim_store(struct device *dev,
                                  const char *buf, size_t count)
 {
        struct rfkill *rfkill = to_rfkill(dev);
-       bool claim = !!simple_strtoul(buf, NULL, 0);
+       unsigned long claim_tmp;
+       bool claim;
        int error;
 
        if (!capable(CAP_NET_ADMIN))
@@ -444,6 +462,11 @@ static ssize_t rfkill_claim_store(struct device *dev,
        if (rfkill->user_claim_unsupported)
                return -EOPNOTSUPP;
 
+       error = strict_strtoul(buf, 0, &claim_tmp);
+       if (error)
+               return error;
+       claim = !!claim_tmp;
+
        /*
         * Take the global lock to make sure the kernel is not in
         * the middle of rfkill_switch_all
@@ -583,10 +606,10 @@ static int rfkill_check_duplicity(const struct rfkill *rfkill)
        memset(seen, 0, sizeof(seen));
 
        list_for_each_entry(p, &rfkill_list, node) {
-               if (p == rfkill) {
-                       WARN_ON(1);
+               if (WARN((p == rfkill), KERN_WARNING
+                               "rfkill: illegal attempt to register "
+                               "an already registered rfkill struct\n"))
                        return -EEXIST;
-               }
                set_bit(p->type, seen);
        }
 
@@ -654,6 +677,12 @@ struct rfkill * __must_check rfkill_allocate(struct device *parent,
        struct rfkill *rfkill;
        struct device *dev;
 
+       if (WARN((type >= RFKILL_TYPE_MAX),
+                       KERN_WARNING
+                       "rfkill: illegal type %d passed as parameter "
+                       "to rfkill_allocate\n", type))
+               return NULL;
+
        rfkill = kzalloc(sizeof(struct rfkill), GFP_KERNEL);
        if (!rfkill)
                return NULL;
@@ -726,11 +755,12 @@ int __must_check rfkill_register(struct rfkill *rfkill)
        struct device *dev = &rfkill->dev;
        int error;
 
-       if (!rfkill->toggle_radio)
-               return -EINVAL;
-       if (rfkill->type >= RFKILL_TYPE_MAX)
-               return -EINVAL;
-       if (rfkill->state >= RFKILL_STATE_MAX)
+       if (WARN((!rfkill || !rfkill->toggle_radio ||
+                       rfkill->type >= RFKILL_TYPE_MAX ||
+                       rfkill->state >= RFKILL_STATE_MAX),
+                       KERN_WARNING
+                       "rfkill: attempt to register a "
+                       "badly initialized rfkill struct\n"))
                return -EINVAL;
 
        snprintf(dev->bus_id, sizeof(dev->bus_id),
@@ -765,6 +795,7 @@ EXPORT_SYMBOL(rfkill_register);
  */
 void rfkill_unregister(struct rfkill *rfkill)
 {
+       BUG_ON(!rfkill);
        device_del(&rfkill->dev);
        rfkill_remove_switch(rfkill);
        rfkill_led_trigger_unregister(rfkill);
@@ -801,9 +832,12 @@ int rfkill_set_default(enum rfkill_type type, enum rfkill_state state)
 {
        int error;
 
-       if (type >= RFKILL_TYPE_MAX ||
-           (state != RFKILL_STATE_SOFT_BLOCKED &&
-            state != RFKILL_STATE_UNBLOCKED))
+       if (WARN((type >= RFKILL_TYPE_MAX ||
+                       (state != RFKILL_STATE_SOFT_BLOCKED &&
+                        state != RFKILL_STATE_UNBLOCKED)),
+                       KERN_WARNING
+                       "rfkill: illegal state %d or type %d passed as "
+                       "parameter to rfkill_set_default\n", state, type))
                return -EINVAL;
 
        mutex_lock(&rfkill_mutex);