[PATCH] for_each_possible_cpu: network codes

[safe/jmp/linux-2.6] / net / bridge / netfilter / ebtables.c

diff --git a/net/bridge/netfilter/ebtables.c b/net/bridge/netfilter/ebtables.c
index cbd4020..66bd932 100644 (file)
--- a/net/bridge/netfilter/ebtables.c
+++ b/net/bridge/netfilter/ebtables.c
@@ -35,6 +35,7 @@
 #define ASSERT_READ_LOCK(x)
 #define ASSERT_WRITE_LOCK(x)
 #include <linux/netfilter_ipv4/listhelp.h>
 #define ASSERT_READ_LOCK(x)
 #define ASSERT_WRITE_LOCK(x)
 #include <linux/netfilter_ipv4/listhelp.h>

+#include <linux/mutex.h>

 
 #if 0
 /* use this for remote debugging
 
 #if 0
 /* use this for remote debugging


@@ -81,7 +82,7 @@ static void print_string(char *str)
 
 
 
 
 
 

-static DECLARE_MUTEX(ebt_mutex);
+static DEFINE_MUTEX(ebt_mutex);

 static LIST_HEAD(ebt_tables);
 static LIST_HEAD(ebt_targets);
 static LIST_HEAD(ebt_matches);
 static LIST_HEAD(ebt_tables);
 static LIST_HEAD(ebt_targets);
 static LIST_HEAD(ebt_matches);


@@ -296,18 +297,18 @@ letscontinue:
 /* If it succeeds, returns element and locks mutex */
 static inline void *
 find_inlist_lock_noload(struct list_head *head, const char *name, int *error,
 /* If it succeeds, returns element and locks mutex */
 static inline void *
 find_inlist_lock_noload(struct list_head *head, const char *name, int *error,

-   struct semaphore *mutex)
+   struct mutex *mutex)

 {
        void *ret;
 
 {
        void *ret;
 

-       *error = down_interruptible(mutex);
+       *error = mutex_lock_interruptible(mutex);

        if (*error != 0)
                return NULL;
 
        ret = list_named_find(head, name);
        if (!ret) {
                *error = -ENOENT;
        if (*error != 0)
                return NULL;
 
        ret = list_named_find(head, name);
        if (!ret) {
                *error = -ENOENT;

-               up(mutex);
+               mutex_unlock(mutex);

        }
        return ret;
 }
        }
        return ret;
 }


@@ -317,7 +318,7 @@ find_inlist_lock_noload(struct list_head *head, const char *name, int *error,
 #else
 static void *
 find_inlist_lock(struct list_head *head, const char *name, const char *prefix,
 #else
 static void *
 find_inlist_lock(struct list_head *head, const char *name, const char *prefix,

-   int *error, struct semaphore *mutex)
+   int *error, struct mutex *mutex)

 {
        void *ret;
 
 {
        void *ret;
 


@@ -331,25 +332,25 @@ find_inlist_lock(struct list_head *head, const char *name, const char *prefix,
 #endif
 
 static inline struct ebt_table *
 #endif
 
 static inline struct ebt_table *

-find_table_lock(const char *name, int *error, struct semaphore *mutex)
+find_table_lock(const char *name, int *error, struct mutex *mutex)

 {
        return find_inlist_lock(&ebt_tables, name, "ebtable_", error, mutex);
 }
 
 static inline struct ebt_match *
 {
        return find_inlist_lock(&ebt_tables, name, "ebtable_", error, mutex);
 }
 
 static inline struct ebt_match *

-find_match_lock(const char *name, int *error, struct semaphore *mutex)
+find_match_lock(const char *name, int *error, struct mutex *mutex)

 {
        return find_inlist_lock(&ebt_matches, name, "ebt_", error, mutex);
 }
 
 static inline struct ebt_watcher *
 {
        return find_inlist_lock(&ebt_matches, name, "ebt_", error, mutex);
 }
 
 static inline struct ebt_watcher *

-find_watcher_lock(const char *name, int *error, struct semaphore *mutex)
+find_watcher_lock(const char *name, int *error, struct mutex *mutex)

 {
        return find_inlist_lock(&ebt_watchers, name, "ebt_", error, mutex);
 }
 
 static inline struct ebt_target *
 {
        return find_inlist_lock(&ebt_watchers, name, "ebt_", error, mutex);
 }
 
 static inline struct ebt_target *

-find_target_lock(const char *name, int *error, struct semaphore *mutex)
+find_target_lock(const char *name, int *error, struct mutex *mutex)

 {
        return find_inlist_lock(&ebt_targets, name, "ebt_", error, mutex);
 }
 {
        return find_inlist_lock(&ebt_targets, name, "ebt_", error, mutex);
 }


@@ -369,10 +370,10 @@ ebt_check_match(struct ebt_entry_match *m, struct ebt_entry *e,
                return ret;
        m->u.match = match;
        if (!try_module_get(match->me)) {
                return ret;
        m->u.match = match;
        if (!try_module_get(match->me)) {

-               up(&ebt_mutex);
+               mutex_unlock(&ebt_mutex);

                return -ENOENT;
        }
                return -ENOENT;
        }

-       up(&ebt_mutex);
+       mutex_unlock(&ebt_mutex);

        if (match->check &&
           match->check(name, hookmask, e, m->data, m->match_size) != 0) {
                BUGPRINT("match->check failed\n");
        if (match->check &&
           match->check(name, hookmask, e, m->data, m->match_size) != 0) {
                BUGPRINT("match->check failed\n");


@@ -398,10 +399,10 @@ ebt_check_watcher(struct ebt_entry_watcher *w, struct ebt_entry *e,
                return ret;
        w->u.watcher = watcher;
        if (!try_module_get(watcher->me)) {
                return ret;
        w->u.watcher = watcher;
        if (!try_module_get(watcher->me)) {

-               up(&ebt_mutex);
+               mutex_unlock(&ebt_mutex);

                return -ENOENT;
        }
                return -ENOENT;
        }

-       up(&ebt_mutex);
+       mutex_unlock(&ebt_mutex);

        if (watcher->check &&
           watcher->check(name, hookmask, e, w->data, w->watcher_size) != 0) {
                BUGPRINT("watcher->check failed\n");
        if (watcher->check &&
           watcher->check(name, hookmask, e, w->data, w->watcher_size) != 0) {
                BUGPRINT("watcher->check failed\n");


@@ -638,11 +639,11 @@ ebt_check_entry(struct ebt_entry *e, struct ebt_table_info *newinfo,
        if (!target)
                goto cleanup_watchers;
        if (!try_module_get(target->me)) {
        if (!target)
                goto cleanup_watchers;
        if (!try_module_get(target->me)) {

-               up(&ebt_mutex);
+               mutex_unlock(&ebt_mutex);

                ret = -ENOENT;
                goto cleanup_watchers;
        }
                ret = -ENOENT;
                goto cleanup_watchers;
        }

-       up(&ebt_mutex);
+       mutex_unlock(&ebt_mutex);

 
        t->u.target = target;
        if (t->u.target == &ebt_standard_target) {
 
        t->u.target = target;
        if (t->u.target == &ebt_standard_target) {


@@ -828,7 +829,7 @@ static int translate_table(struct ebt_replace *repl,
                                                * sizeof(struct ebt_chainstack));
                if (!newinfo->chainstack)
                        return -ENOMEM;
                                                * sizeof(struct ebt_chainstack));
                if (!newinfo->chainstack)
                        return -ENOMEM;

-               for_each_cpu(i) {
+               for_each_possible_cpu(i) {

                        newinfo->chainstack[i] =
                           vmalloc(udc_cnt * sizeof(struct ebt_chainstack));
                        if (!newinfo->chainstack[i]) {
                        newinfo->chainstack[i] =
                           vmalloc(udc_cnt * sizeof(struct ebt_chainstack));
                        if (!newinfo->chainstack[i]) {


@@ -900,7 +901,7 @@ static void get_counters(struct ebt_counter *oldcounters,
               sizeof(struct ebt_counter) * nentries);
 
        /* add other counters to those of cpu 0 */
               sizeof(struct ebt_counter) * nentries);
 
        /* add other counters to those of cpu 0 */

-       for_each_cpu(cpu) {
+       for_each_possible_cpu(cpu) {

                if (cpu == 0)
                        continue;
                counter_base = COUNTER_BASE(oldcounters, nentries, cpu);
                if (cpu == 0)
                        continue;
                counter_base = COUNTER_BASE(oldcounters, nentries, cpu);


@@ -1015,7 +1016,7 @@ static int do_replace(void __user *user, unsigned int len)
 
        t->private = newinfo;
        write_unlock_bh(&t->lock);
 
        t->private = newinfo;
        write_unlock_bh(&t->lock);

-       up(&ebt_mutex);
+       mutex_unlock(&ebt_mutex);

        /* so, a user can change the chains while having messed up her counter
           allocation. Only reason why this is done is because this way the lock
           is held only once, while this doesn't bring the kernel into a
        /* so, a user can change the chains while having messed up her counter
           allocation. Only reason why this is done is because this way the lock
           is held only once, while this doesn't bring the kernel into a


@@ -1035,7 +1036,7 @@ static int do_replace(void __user *user, unsigned int len)
 
        vfree(table->entries);
        if (table->chainstack) {
 
        vfree(table->entries);
        if (table->chainstack) {

-               for_each_cpu(i)
+               for_each_possible_cpu(i)

                        vfree(table->chainstack[i]);
                vfree(table->chainstack);
        }
                        vfree(table->chainstack[i]);
                vfree(table->chainstack);
        }


@@ -1045,7 +1046,7 @@ static int do_replace(void __user *user, unsigned int len)
        return ret;
 
 free_unlock:
        return ret;
 
 free_unlock:

-       up(&ebt_mutex);
+       mutex_unlock(&ebt_mutex);

 free_iterate:
        EBT_ENTRY_ITERATE(newinfo->entries, newinfo->entries_size,
           ebt_cleanup_entry, NULL);
 free_iterate:
        EBT_ENTRY_ITERATE(newinfo->entries, newinfo->entries_size,
           ebt_cleanup_entry, NULL);


@@ -1053,7 +1054,7 @@ free_counterstmp:
        vfree(counterstmp);
        /* can be initialized in translate_table() */
        if (newinfo->chainstack) {
        vfree(counterstmp);
        /* can be initialized in translate_table() */
        if (newinfo->chainstack) {

-               for_each_cpu(i)
+               for_each_possible_cpu(i)

                        vfree(newinfo->chainstack[i]);
                vfree(newinfo->chainstack);
        }
                        vfree(newinfo->chainstack[i]);
                vfree(newinfo->chainstack);
        }


@@ -1068,69 +1069,69 @@ int ebt_register_target(struct ebt_target *target)
 {
        int ret;
 
 {
        int ret;
 

-       ret = down_interruptible(&ebt_mutex);
+       ret = mutex_lock_interruptible(&ebt_mutex);

        if (ret != 0)
                return ret;
        if (!list_named_insert(&ebt_targets, target)) {
        if (ret != 0)
                return ret;
        if (!list_named_insert(&ebt_targets, target)) {

-               up(&ebt_mutex);
+               mutex_unlock(&ebt_mutex);

                return -EEXIST;
        }
                return -EEXIST;
        }

-       up(&ebt_mutex);
+       mutex_unlock(&ebt_mutex);

 
        return 0;
 }
 
 void ebt_unregister_target(struct ebt_target *target)
 {
 
        return 0;
 }
 
 void ebt_unregister_target(struct ebt_target *target)
 {

-       down(&ebt_mutex);
+       mutex_lock(&ebt_mutex);

        LIST_DELETE(&ebt_targets, target);
        LIST_DELETE(&ebt_targets, target);

-       up(&ebt_mutex);
+       mutex_unlock(&ebt_mutex);

 }
 
 int ebt_register_match(struct ebt_match *match)
 {
        int ret;
 
 }
 
 int ebt_register_match(struct ebt_match *match)
 {
        int ret;
 

-       ret = down_interruptible(&ebt_mutex);
+       ret = mutex_lock_interruptible(&ebt_mutex);

        if (ret != 0)
                return ret;
        if (!list_named_insert(&ebt_matches, match)) {
        if (ret != 0)
                return ret;
        if (!list_named_insert(&ebt_matches, match)) {

-               up(&ebt_mutex);
+               mutex_unlock(&ebt_mutex);

                return -EEXIST;
        }
                return -EEXIST;
        }

-       up(&ebt_mutex);
+       mutex_unlock(&ebt_mutex);

 
        return 0;
 }
 
 void ebt_unregister_match(struct ebt_match *match)
 {
 
        return 0;
 }
 
 void ebt_unregister_match(struct ebt_match *match)
 {

-       down(&ebt_mutex);
+       mutex_lock(&ebt_mutex);

        LIST_DELETE(&ebt_matches, match);
        LIST_DELETE(&ebt_matches, match);

-       up(&ebt_mutex);
+       mutex_unlock(&ebt_mutex);

 }
 
 int ebt_register_watcher(struct ebt_watcher *watcher)
 {
        int ret;
 
 }
 
 int ebt_register_watcher(struct ebt_watcher *watcher)
 {
        int ret;
 

-       ret = down_interruptible(&ebt_mutex);
+       ret = mutex_lock_interruptible(&ebt_mutex);

        if (ret != 0)
                return ret;
        if (!list_named_insert(&ebt_watchers, watcher)) {
        if (ret != 0)
                return ret;
        if (!list_named_insert(&ebt_watchers, watcher)) {

-               up(&ebt_mutex);
+               mutex_unlock(&ebt_mutex);

                return -EEXIST;
        }
                return -EEXIST;
        }

-       up(&ebt_mutex);
+       mutex_unlock(&ebt_mutex);

 
        return 0;
 }
 
 void ebt_unregister_watcher(struct ebt_watcher *watcher)
 {
 
        return 0;
 }
 
 void ebt_unregister_watcher(struct ebt_watcher *watcher)
 {

-       down(&ebt_mutex);
+       mutex_lock(&ebt_mutex);

        LIST_DELETE(&ebt_watchers, watcher);
        LIST_DELETE(&ebt_watchers, watcher);

-       up(&ebt_mutex);
+       mutex_unlock(&ebt_mutex);

 }
 
 int ebt_register_table(struct ebt_table *table)
 }
 
 int ebt_register_table(struct ebt_table *table)


@@ -1178,7 +1179,7 @@ int ebt_register_table(struct ebt_table *table)
 
        table->private = newinfo;
        rwlock_init(&table->lock);
 
        table->private = newinfo;
        rwlock_init(&table->lock);

-       ret = down_interruptible(&ebt_mutex);
+       ret = mutex_lock_interruptible(&ebt_mutex);

        if (ret != 0)
                goto free_chainstack;
 
        if (ret != 0)
                goto free_chainstack;
 


@@ -1194,13 +1195,13 @@ int ebt_register_table(struct ebt_table *table)
                goto free_unlock;
        }
        list_prepend(&ebt_tables, table);
                goto free_unlock;
        }
        list_prepend(&ebt_tables, table);

-       up(&ebt_mutex);
+       mutex_unlock(&ebt_mutex);

        return 0;
 free_unlock:
        return 0;
 free_unlock:

-       up(&ebt_mutex);
+       mutex_unlock(&ebt_mutex);

 free_chainstack:
        if (newinfo->chainstack) {
 free_chainstack:
        if (newinfo->chainstack) {

-               for_each_cpu(i)
+               for_each_possible_cpu(i)

                        vfree(newinfo->chainstack[i]);
                vfree(newinfo->chainstack);
        }
                        vfree(newinfo->chainstack[i]);
                vfree(newinfo->chainstack);
        }


@@ -1218,12 +1219,12 @@ void ebt_unregister_table(struct ebt_table *table)
                BUGPRINT("Request to unregister NULL table!!!\n");
                return;
        }
                BUGPRINT("Request to unregister NULL table!!!\n");
                return;
        }

-       down(&ebt_mutex);
+       mutex_lock(&ebt_mutex);

        LIST_DELETE(&ebt_tables, table);
        LIST_DELETE(&ebt_tables, table);

-       up(&ebt_mutex);
+       mutex_unlock(&ebt_mutex);

        vfree(table->private->entries);
        if (table->private->chainstack) {
        vfree(table->private->entries);
        if (table->private->chainstack) {

-               for_each_cpu(i)
+               for_each_possible_cpu(i)

                        vfree(table->private->chainstack[i]);
                vfree(table->private->chainstack);
        }
                        vfree(table->private->chainstack[i]);
                vfree(table->private->chainstack);
        }


@@ -1281,7 +1282,7 @@ static int update_counters(void __user *user, unsigned int len)
        write_unlock_bh(&t->lock);
        ret = 0;
 unlock_mutex:
        write_unlock_bh(&t->lock);
        ret = 0;
 unlock_mutex:

-       up(&ebt_mutex);
+       mutex_unlock(&ebt_mutex);

 free_tmp:
        vfree(tmp);
        return ret;
 free_tmp:
        vfree(tmp);
        return ret;


@@ -1328,7 +1329,7 @@ static inline int ebt_make_names(struct ebt_entry *e, char *base, char *ubase)
        return 0;
 }
 
        return 0;
 }
 

-/* called with ebt_mutex down */
+/* called with ebt_mutex locked */

 static int copy_everything_to_user(struct ebt_table *t, void __user *user,
    int *len, int cmd)
 {
 static int copy_everything_to_user(struct ebt_table *t, void __user *user,
    int *len, int cmd)
 {


@@ -1440,7 +1441,7 @@ static int do_ebt_get_ctl(struct sock *sk, int cmd, void __user *user, int *len)
        case EBT_SO_GET_INIT_INFO:
                if (*len != sizeof(struct ebt_replace)){
                        ret = -EINVAL;
        case EBT_SO_GET_INIT_INFO:
                if (*len != sizeof(struct ebt_replace)){
                        ret = -EINVAL;

-                       up(&ebt_mutex);
+                       mutex_unlock(&ebt_mutex);

                        break;
                }
                if (cmd == EBT_SO_GET_INFO) {
                        break;
                }
                if (cmd == EBT_SO_GET_INFO) {


@@ -1452,7 +1453,7 @@ static int do_ebt_get_ctl(struct sock *sk, int cmd, void __user *user, int *len)
                        tmp.entries_size = t->table->entries_size;
                        tmp.valid_hooks = t->table->valid_hooks;
                }
                        tmp.entries_size = t->table->entries_size;
                        tmp.valid_hooks = t->table->valid_hooks;
                }

-               up(&ebt_mutex);
+               mutex_unlock(&ebt_mutex);

                if (copy_to_user(user, &tmp, *len) != 0){
                        BUGPRINT("c2u Didn't work\n");
                        ret = -EFAULT;
                if (copy_to_user(user, &tmp, *len) != 0){
                        BUGPRINT("c2u Didn't work\n");
                        ret = -EFAULT;


@@ -1464,11 +1465,11 @@ static int do_ebt_get_ctl(struct sock *sk, int cmd, void __user *user, int *len)
        case EBT_SO_GET_ENTRIES:
        case EBT_SO_GET_INIT_ENTRIES:
                ret = copy_everything_to_user(t, user, len, cmd);
        case EBT_SO_GET_ENTRIES:
        case EBT_SO_GET_INIT_ENTRIES:
                ret = copy_everything_to_user(t, user, len, cmd);

-               up(&ebt_mutex);
+               mutex_unlock(&ebt_mutex);

                break;
 
        default:
                break;
 
        default:

-               up(&ebt_mutex);
+               mutex_unlock(&ebt_mutex);

                ret = -EINVAL;
        }
 
                ret = -EINVAL;
        }
 


@@ -1476,17 +1477,23 @@ static int do_ebt_get_ctl(struct sock *sk, int cmd, void __user *user, int *len)
 }
 
 static struct nf_sockopt_ops ebt_sockopts =
 }
 
 static struct nf_sockopt_ops ebt_sockopts =

-{ { NULL, NULL }, PF_INET, EBT_BASE_CTL, EBT_SO_SET_MAX + 1, do_ebt_set_ctl,
-    EBT_BASE_CTL, EBT_SO_GET_MAX + 1, do_ebt_get_ctl, 0, NULL
+{
+       .pf             = PF_INET,
+       .set_optmin     = EBT_BASE_CTL,
+       .set_optmax     = EBT_SO_SET_MAX + 1,
+       .set            = do_ebt_set_ctl,
+       .get_optmin     = EBT_BASE_CTL,
+       .get_optmax     = EBT_SO_GET_MAX + 1,
+       .get            = do_ebt_get_ctl,

 };
 
 };
 

-static int __init init(void)
+static int __init ebtables_init(void)

 {
        int ret;
 
 {
        int ret;
 

-       down(&ebt_mutex);
+       mutex_lock(&ebt_mutex);

        list_named_insert(&ebt_targets, &ebt_standard_target);
        list_named_insert(&ebt_targets, &ebt_standard_target);

-       up(&ebt_mutex);
+       mutex_unlock(&ebt_mutex);

        if ((ret = nf_register_sockopt(&ebt_sockopts)) < 0)
                return ret;
 
        if ((ret = nf_register_sockopt(&ebt_sockopts)) < 0)
                return ret;
 


@@ -1494,7 +1501,7 @@ static int __init init(void)
        return 0;
 }
 
        return 0;
 }
 

-static void __exit fini(void)
+static void __exit ebtables_fini(void)

 {
        nf_unregister_sockopt(&ebt_sockopts);
        printk(KERN_NOTICE "Ebtables v2.0 unregistered\n");
 {
        nf_unregister_sockopt(&ebt_sockopts);
        printk(KERN_NOTICE "Ebtables v2.0 unregistered\n");


@@ -1509,6 +1516,6 @@ EXPORT_SYMBOL(ebt_unregister_watcher);
 EXPORT_SYMBOL(ebt_register_target);
 EXPORT_SYMBOL(ebt_unregister_target);
 EXPORT_SYMBOL(ebt_do_table);
 EXPORT_SYMBOL(ebt_register_target);
 EXPORT_SYMBOL(ebt_unregister_target);
 EXPORT_SYMBOL(ebt_do_table);

-module_init(init);
-module_exit(fini);
+module_init(ebtables_init);
+module_exit(ebtables_fini);

 MODULE_LICENSE("GPL");
 MODULE_LICENSE("GPL");