[NET]: sem2mutex part 2
authorIngo Molnar <mingo@elte.hu>
Tue, 21 Mar 2006 06:35:41 +0000 (22:35 -0800)
committerDavid S. Miller <davem@davemloft.net>
Tue, 21 Mar 2006 06:35:41 +0000 (22:35 -0800)
Semaphore to mutex conversion.

The conversion was generated via scripts, and the result was validated
automatically via a script as well.

Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
13 files changed:
include/linux/sunrpc/svcsock.h
include/net/af_unix.h
net/atm/common.c
net/atm/resources.c
net/atm/resources.h
net/bridge/netfilter/ebtables.c
net/ipv4/ipvs/ip_vs_app.c
net/ipv4/netfilter/arp_tables.c
net/ipv4/netfilter/ip_tables.c
net/ipv6/netfilter/ip6_tables.c
net/netfilter/nf_conntrack_core.c
net/sunrpc/svcsock.c
net/unix/af_unix.c

index d33c6face032fd2643cad8ffee544a6a32564b1c..b4acb3d37c3f2556e2b5f01efe587c94c6b8cced 100644 (file)
@@ -36,7 +36,7 @@ struct svc_sock {
 
        struct list_head        sk_deferred;    /* deferred requests that need to
                                                 * be revisted */
-       struct semaphore        sk_sem;         /* to serialize sending data */
+       struct mutex            sk_mutex;       /* to serialize sending data */
 
        int                     (*sk_recvfrom)(struct svc_rqst *rqstp);
        int                     (*sk_sendto)(struct svc_rqst *rqstp);
index bfc1779fc753fcf0c1a13a086bf5fc2b7c999b65..427dac94bc7e38a3e63fb008fa6bb4b12cb04fcf 100644 (file)
@@ -4,6 +4,7 @@
 #include <linux/config.h>
 #include <linux/socket.h>
 #include <linux/un.h>
+#include <linux/mutex.h>
 #include <net/sock.h>
 
 extern void unix_inflight(struct file *fp);
@@ -71,7 +72,7 @@ struct unix_sock {
         struct unix_address     *addr;
         struct dentry          *dentry;
         struct vfsmount                *mnt;
-        struct semaphore        readsem;
+       struct mutex            readlock;
         struct sock            *peer;
         struct sock            *other;
         struct sock            *gc_tree;
index 6656b111cc053de334c9885f0f6ccebe4cadd790..ae002220fa99096aa00edc4ce0fd8df3e5c8694b 100644 (file)
@@ -451,12 +451,12 @@ int vcc_connect(struct socket *sock, int itf, short vpi, int vci)
                dev = try_then_request_module(atm_dev_lookup(itf), "atm-device-%d", itf);
        } else {
                dev = NULL;
-               down(&atm_dev_mutex);
+               mutex_lock(&atm_dev_mutex);
                if (!list_empty(&atm_devs)) {
                        dev = list_entry(atm_devs.next, struct atm_dev, dev_list);
                        atm_dev_hold(dev);
                }
-               up(&atm_dev_mutex);
+               mutex_unlock(&atm_dev_mutex);
        }
        if (!dev)
                return -ENODEV;
index 224190537c90c3e5816df506e8dc9f234dfa5a7e..18ac80698f835906cab6cd9f45971892ef42d46b 100644 (file)
@@ -18,6 +18,8 @@
 #include <linux/bitops.h>
 #include <linux/capability.h>
 #include <linux/delay.h>
+#include <linux/mutex.h>
+
 #include <net/sock.h>   /* for struct sock */
 
 #include "common.h"
@@ -26,7 +28,7 @@
 
 
 LIST_HEAD(atm_devs);
-DECLARE_MUTEX(atm_dev_mutex);
+DEFINE_MUTEX(atm_dev_mutex);
 
 static struct atm_dev *__alloc_atm_dev(const char *type)
 {
@@ -65,9 +67,9 @@ struct atm_dev *atm_dev_lookup(int number)
 {
        struct atm_dev *dev;
 
-       down(&atm_dev_mutex);
+       mutex_lock(&atm_dev_mutex);
        dev = __atm_dev_lookup(number);
-       up(&atm_dev_mutex);
+       mutex_unlock(&atm_dev_mutex);
        return dev;
 }
 
@@ -83,11 +85,11 @@ struct atm_dev *atm_dev_register(const char *type, const struct atmdev_ops *ops,
                    type);
                return NULL;
        }
-       down(&atm_dev_mutex);
+       mutex_lock(&atm_dev_mutex);
        if (number != -1) {
                if ((inuse = __atm_dev_lookup(number))) {
                        atm_dev_put(inuse);
-                       up(&atm_dev_mutex);
+                       mutex_unlock(&atm_dev_mutex);
                        kfree(dev);
                        return NULL;
                }
@@ -112,12 +114,12 @@ struct atm_dev *atm_dev_register(const char *type, const struct atmdev_ops *ops,
                printk(KERN_ERR "atm_dev_register: "
                       "atm_proc_dev_register failed for dev %s\n",
                       type);
-               up(&atm_dev_mutex);
+               mutex_unlock(&atm_dev_mutex);
                kfree(dev);
                return NULL;
        }
        list_add_tail(&dev->dev_list, &atm_devs);
-       up(&atm_dev_mutex);
+       mutex_unlock(&atm_dev_mutex);
 
        return dev;
 }
@@ -133,9 +135,9 @@ void atm_dev_deregister(struct atm_dev *dev)
         * with same number can appear, such we need deregister proc, 
         * release async all vccs and remove them from vccs list too
         */
-       down(&atm_dev_mutex);
+       mutex_lock(&atm_dev_mutex);
        list_del(&dev->dev_list);
-       up(&atm_dev_mutex);
+       mutex_unlock(&atm_dev_mutex);
 
        atm_dev_release_vccs(dev);
        atm_proc_dev_deregister(dev);
@@ -196,16 +198,16 @@ int atm_dev_ioctl(unsigned int cmd, void __user *arg)
                                return -EFAULT;
                        if (get_user(len, &iobuf->length))
                                return -EFAULT;
-                       down(&atm_dev_mutex);
+                       mutex_lock(&atm_dev_mutex);
                        list_for_each(p, &atm_devs)
                                size += sizeof(int);
                        if (size > len) {
-                               up(&atm_dev_mutex);
+                               mutex_unlock(&atm_dev_mutex);
                                return -E2BIG;
                        }
                        tmp_buf = kmalloc(size, GFP_ATOMIC);
                        if (!tmp_buf) {
-                               up(&atm_dev_mutex);
+                               mutex_unlock(&atm_dev_mutex);
                                return -ENOMEM;
                        }
                        tmp_p = tmp_buf;
@@ -213,7 +215,7 @@ int atm_dev_ioctl(unsigned int cmd, void __user *arg)
                                dev = list_entry(p, struct atm_dev, dev_list);
                                *tmp_p++ = dev->number;
                        }
-                       up(&atm_dev_mutex);
+                       mutex_unlock(&atm_dev_mutex);
                        error = ((copy_to_user(buf, tmp_buf, size)) ||
                                        put_user(size, &iobuf->length))
                                                ? -EFAULT : 0;
@@ -400,13 +402,13 @@ static __inline__ void *dev_get_idx(loff_t left)
 
 void *atm_dev_seq_start(struct seq_file *seq, loff_t *pos)
 {
-       down(&atm_dev_mutex);
+       mutex_lock(&atm_dev_mutex);
        return *pos ? dev_get_idx(*pos) : (void *) 1;
 }
 
 void atm_dev_seq_stop(struct seq_file *seq, void *v)
 {
-       up(&atm_dev_mutex);
+       mutex_unlock(&atm_dev_mutex);
 }
  
 void *atm_dev_seq_next(struct seq_file *seq, void *v, loff_t *pos)
index b7fb82a93b42951870a1e327b99b1f8a0f954391..ac7222fee7a8e38db42aa066ca03a241ab323735 100644 (file)
@@ -8,10 +8,11 @@
 
 #include <linux/config.h>
 #include <linux/atmdev.h>
+#include <linux/mutex.h>
 
 
 extern struct list_head atm_devs;
-extern struct semaphore atm_dev_mutex;
+extern struct mutex atm_dev_mutex;
 
 int atm_dev_ioctl(unsigned int cmd, void __user *arg);
 
index cbd4020cc84d6a142c0128496a80de3909b1f58e..4b178b4a2a95213e5cf458d9777198047df19999 100644 (file)
@@ -35,6 +35,7 @@
 #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
@@ -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);
@@ -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,
-   struct semaphore *mutex)
+   struct mutex *mutex)
 {
        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;
-               up(mutex);
+               mutex_unlock(mutex);
        }
        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,
-   int *error, struct semaphore *mutex)
+   int *error, struct mutex *mutex)
 {
        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 *
-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 *
-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 *
-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 *
-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);
 }
@@ -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)) {
-               up(&ebt_mutex);
+               mutex_unlock(&ebt_mutex);
                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");
@@ -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)) {
-               up(&ebt_mutex);
+               mutex_unlock(&ebt_mutex);
                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");
@@ -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)) {
-               up(&ebt_mutex);
+               mutex_unlock(&ebt_mutex);
                ret = -ENOENT;
                goto cleanup_watchers;
        }
-       up(&ebt_mutex);
+       mutex_unlock(&ebt_mutex);
 
        t->u.target = target;
        if (t->u.target == &ebt_standard_target) {
@@ -1015,7 +1016,7 @@ static int do_replace(void __user *user, unsigned int len)
 
        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
@@ -1045,7 +1046,7 @@ static int do_replace(void __user *user, unsigned int len)
        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);
@@ -1068,69 +1069,69 @@ int ebt_register_target(struct ebt_target *target)
 {
        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)) {
-               up(&ebt_mutex);
+               mutex_unlock(&ebt_mutex);
                return -EEXIST;
        }
-       up(&ebt_mutex);
+       mutex_unlock(&ebt_mutex);
 
        return 0;
 }
 
 void ebt_unregister_target(struct ebt_target *target)
 {
-       down(&ebt_mutex);
+       mutex_lock(&ebt_mutex);
        LIST_DELETE(&ebt_targets, target);
-       up(&ebt_mutex);
+       mutex_unlock(&ebt_mutex);
 }
 
 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)) {
-               up(&ebt_mutex);
+               mutex_unlock(&ebt_mutex);
                return -EEXIST;
        }
-       up(&ebt_mutex);
+       mutex_unlock(&ebt_mutex);
 
        return 0;
 }
 
 void ebt_unregister_match(struct ebt_match *match)
 {
-       down(&ebt_mutex);
+       mutex_lock(&ebt_mutex);
        LIST_DELETE(&ebt_matches, match);
-       up(&ebt_mutex);
+       mutex_unlock(&ebt_mutex);
 }
 
 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)) {
-               up(&ebt_mutex);
+               mutex_unlock(&ebt_mutex);
                return -EEXIST;
        }
-       up(&ebt_mutex);
+       mutex_unlock(&ebt_mutex);
 
        return 0;
 }
 
 void ebt_unregister_watcher(struct ebt_watcher *watcher)
 {
-       down(&ebt_mutex);
+       mutex_lock(&ebt_mutex);
        LIST_DELETE(&ebt_watchers, watcher);
-       up(&ebt_mutex);
+       mutex_unlock(&ebt_mutex);
 }
 
 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);
-       ret = down_interruptible(&ebt_mutex);
+       ret = mutex_lock_interruptible(&ebt_mutex);
        if (ret != 0)
                goto free_chainstack;
 
@@ -1194,10 +1195,10 @@ int ebt_register_table(struct ebt_table *table)
                goto free_unlock;
        }
        list_prepend(&ebt_tables, table);
-       up(&ebt_mutex);
+       mutex_unlock(&ebt_mutex);
        return 0;
 free_unlock:
-       up(&ebt_mutex);
+       mutex_unlock(&ebt_mutex);
 free_chainstack:
        if (newinfo->chainstack) {
                for_each_cpu(i)
@@ -1218,9 +1219,9 @@ void ebt_unregister_table(struct ebt_table *table)
                BUGPRINT("Request to unregister NULL table!!!\n");
                return;
        }
-       down(&ebt_mutex);
+       mutex_lock(&ebt_mutex);
        LIST_DELETE(&ebt_tables, table);
-       up(&ebt_mutex);
+       mutex_unlock(&ebt_mutex);
        vfree(table->private->entries);
        if (table->private->chainstack) {
                for_each_cpu(i)
@@ -1281,7 +1282,7 @@ static int update_counters(void __user *user, unsigned int len)
        write_unlock_bh(&t->lock);
        ret = 0;
 unlock_mutex:
-       up(&ebt_mutex);
+       mutex_unlock(&ebt_mutex);
 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;
 }
 
-/* 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)
 {
@@ -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;
-                       up(&ebt_mutex);
+                       mutex_unlock(&ebt_mutex);
                        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;
                }
-               up(&ebt_mutex);
+               mutex_unlock(&ebt_mutex);
                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);
-               up(&ebt_mutex);
+               mutex_unlock(&ebt_mutex);
                break;
 
        default:
-               up(&ebt_mutex);
+               mutex_unlock(&ebt_mutex);
                ret = -EINVAL;
        }
 
@@ -1484,9 +1485,9 @@ static int __init init(void)
 {
        int ret;
 
-       down(&ebt_mutex);
+       mutex_lock(&ebt_mutex);
        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;
 
index 9b176a942ac519f1b24b4953e375707d7e709029..e7752334d29648907dae8183c720f3e90e95a7cd 100644 (file)
@@ -31,6 +31,7 @@
 #include <linux/stat.h>
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
+#include <linux/mutex.h>
 
 #include <net/ip_vs.h>
 
@@ -40,7 +41,7 @@ EXPORT_SYMBOL(register_ip_vs_app_inc);
 
 /* ipvs application list head */
 static LIST_HEAD(ip_vs_app_list);
-static DECLARE_MUTEX(__ip_vs_app_mutex);
+static DEFINE_MUTEX(__ip_vs_app_mutex);
 
 
 /*
@@ -173,11 +174,11 @@ register_ip_vs_app_inc(struct ip_vs_app *app, __u16 proto, __u16 port)
 {
        int result;
 
-       down(&__ip_vs_app_mutex);
+       mutex_lock(&__ip_vs_app_mutex);
 
        result = ip_vs_app_inc_new(app, proto, port);
 
-       up(&__ip_vs_app_mutex);
+       mutex_unlock(&__ip_vs_app_mutex);
 
        return result;
 }
@@ -191,11 +192,11 @@ int register_ip_vs_app(struct ip_vs_app *app)
        /* increase the module use count */
        ip_vs_use_count_inc();
 
-       down(&__ip_vs_app_mutex);
+       mutex_lock(&__ip_vs_app_mutex);
 
        list_add(&app->a_list, &ip_vs_app_list);
 
-       up(&__ip_vs_app_mutex);
+       mutex_unlock(&__ip_vs_app_mutex);
 
        return 0;
 }
@@ -209,7 +210,7 @@ void unregister_ip_vs_app(struct ip_vs_app *app)
 {
        struct ip_vs_app *inc, *nxt;
 
-       down(&__ip_vs_app_mutex);
+       mutex_lock(&__ip_vs_app_mutex);
 
        list_for_each_entry_safe(inc, nxt, &app->incs_list, a_list) {
                ip_vs_app_inc_release(inc);
@@ -217,7 +218,7 @@ void unregister_ip_vs_app(struct ip_vs_app *app)
 
        list_del(&app->a_list);
 
-       up(&__ip_vs_app_mutex);
+       mutex_unlock(&__ip_vs_app_mutex);
 
        /* decrease the module use count */
        ip_vs_use_count_dec();
@@ -498,7 +499,7 @@ static struct ip_vs_app *ip_vs_app_idx(loff_t pos)
 
 static void *ip_vs_app_seq_start(struct seq_file *seq, loff_t *pos)
 {
-       down(&__ip_vs_app_mutex);
+       mutex_lock(&__ip_vs_app_mutex);
 
        return *pos ? ip_vs_app_idx(*pos - 1) : SEQ_START_TOKEN;
 }
@@ -530,7 +531,7 @@ static void *ip_vs_app_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 
 static void ip_vs_app_seq_stop(struct seq_file *seq, void *v)
 {
-       up(&__ip_vs_app_mutex);
+       mutex_unlock(&__ip_vs_app_mutex);
 }
 
 static int ip_vs_app_seq_show(struct seq_file *seq, void *v)
index 9423bd0f070a60dfd91951021d9f96cdbcd6fce2..f7efb3f27bf599b070d25521372d6cd11466ac2e 100644 (file)
@@ -22,7 +22,7 @@
 #include <linux/init.h>
 
 #include <asm/uaccess.h>
-#include <asm/semaphore.h>
+#include <linux/mutex.h>
 
 #include <linux/netfilter/x_tables.h>
 #include <linux/netfilter_arp/arp_tables.h>
index cf5b9db05371504c011d532ab1223cc8cc44932c..39705f9bc1546ea55dc69a5aeca6ae304da1e9f7 100644 (file)
@@ -25,7 +25,7 @@
 #include <linux/icmp.h>
 #include <net/ip.h>
 #include <asm/uaccess.h>
-#include <asm/semaphore.h>
+#include <linux/mutex.h>
 #include <linux/proc_fs.h>
 #include <linux/err.h>
 #include <linux/cpumask.h>
index d74ec335743e1f328a3addd7c004cba9c2c1c989..5a2063bda67689fa591f4aea62317902ad3b4053 100644 (file)
@@ -29,7 +29,7 @@
 #include <linux/icmpv6.h>
 #include <net/ipv6.h>
 #include <asm/uaccess.h>
-#include <asm/semaphore.h>
+#include <linux/mutex.h>
 #include <linux/proc_fs.h>
 #include <linux/cpumask.h>
 
index dc68d00222185c7d4e16ed99a580370cbbebae44..f6498234e26427d16e390ce925e9d8111d214347 100644 (file)
@@ -185,7 +185,7 @@ static struct {
 DEFINE_RWLOCK(nf_ct_cache_lock);
 
 /* This avoids calling kmem_cache_create() with same name simultaneously */
-DECLARE_MUTEX(nf_ct_cache_mutex);
+static DEFINE_MUTEX(nf_ct_cache_mutex);
 
 extern struct nf_conntrack_protocol nf_conntrack_generic_protocol;
 struct nf_conntrack_protocol *
@@ -278,7 +278,7 @@ int nf_conntrack_register_cache(u_int32_t features, const char *name,
                return -EINVAL;
        }
 
-       down(&nf_ct_cache_mutex);
+       mutex_lock(&nf_ct_cache_mutex);
 
        write_lock_bh(&nf_ct_cache_lock);
        /* e.g: multiple helpers are loaded */
@@ -294,7 +294,7 @@ int nf_conntrack_register_cache(u_int32_t features, const char *name,
                        ret = -EBUSY;
 
                write_unlock_bh(&nf_ct_cache_lock);
-               up(&nf_ct_cache_mutex);
+               mutex_unlock(&nf_ct_cache_mutex);
                return ret;
        }
        write_unlock_bh(&nf_ct_cache_lock);
@@ -338,7 +338,7 @@ int nf_conntrack_register_cache(u_int32_t features, const char *name,
 out_free_name:
        kfree(cache_name);
 out_up_mutex:
-       up(&nf_ct_cache_mutex);
+       mutex_unlock(&nf_ct_cache_mutex);
        return ret;
 }
 
@@ -353,12 +353,12 @@ void nf_conntrack_unregister_cache(u_int32_t features)
         * slab cache.
         */
        DEBUGP("nf_conntrack_unregister_cache: 0x%04x\n", features);
-       down(&nf_ct_cache_mutex);
+       mutex_lock(&nf_ct_cache_mutex);
 
        write_lock_bh(&nf_ct_cache_lock);
        if (--nf_ct_cache[features].use > 0) {
                write_unlock_bh(&nf_ct_cache_lock);
-               up(&nf_ct_cache_mutex);
+               mutex_unlock(&nf_ct_cache_mutex);
                return;
        }
        cachep = nf_ct_cache[features].cachep;
@@ -373,7 +373,7 @@ void nf_conntrack_unregister_cache(u_int32_t features)
        kmem_cache_destroy(cachep);
        kfree(name);
 
-       up(&nf_ct_cache_mutex);
+       mutex_unlock(&nf_ct_cache_mutex);
 }
 
 int
@@ -1408,6 +1408,8 @@ void __nf_ct_refresh_acct(struct nf_conn *ct,
 
 #include <linux/netfilter/nfnetlink.h>
 #include <linux/netfilter/nfnetlink_conntrack.h>
+#include <linux/mutex.h>
+
 
 /* Generic function for tcp/udp/sctp/dccp and alike. This needs to be
  * in ip_conntrack_core, since we don't want the protocols to autoload
index 50580620e89704038f1957fb6b95e2cf8e2dbd12..a27905a0ad277a4322d291e333c479794e3383de 100644 (file)
@@ -1296,13 +1296,13 @@ svc_send(struct svc_rqst *rqstp)
                xb->page_len +
                xb->tail[0].iov_len;
 
-       /* Grab svsk->sk_sem to serialize outgoing data. */
-       down(&svsk->sk_sem);
+       /* Grab svsk->sk_mutex to serialize outgoing data. */
+       mutex_lock(&svsk->sk_mutex);
        if (test_bit(SK_DEAD, &svsk->sk_flags))
                len = -ENOTCONN;
        else
                len = svsk->sk_sendto(rqstp);
-       up(&svsk->sk_sem);
+       mutex_unlock(&svsk->sk_mutex);
        svc_sock_release(rqstp);
 
        if (len == -ECONNREFUSED || len == -ENOTCONN || len == -EAGAIN)
@@ -1351,7 +1351,7 @@ svc_setup_socket(struct svc_serv *serv, struct socket *sock,
        svsk->sk_lastrecv = get_seconds();
        INIT_LIST_HEAD(&svsk->sk_deferred);
        INIT_LIST_HEAD(&svsk->sk_ready);
-       sema_init(&svsk->sk_sem, 1);
+       mutex_init(&svsk->sk_mutex);
 
        /* Initialize the socket */
        if (sock->type == SOCK_DGRAM)
index 2b00460f2886e1a10eb5e5bccc785f6f370eba71..2b4cc2eea5b38bd6a686b94cb0136f8b7a18adbf 100644 (file)
@@ -566,7 +566,7 @@ static struct sock * unix_create1(struct socket *sock)
        u->mnt    = NULL;
        spin_lock_init(&u->lock);
        atomic_set(&u->inflight, sock ? 0 : -1);
-       init_MUTEX(&u->readsem); /* single task reading lock */
+       mutex_init(&u->readlock); /* single task reading lock */
        init_waitqueue_head(&u->peer_wait);
        unix_insert_socket(unix_sockets_unbound, sk);
 out:
@@ -623,7 +623,7 @@ static int unix_autobind(struct socket *sock)
        struct unix_address * addr;
        int err;
 
-       down(&u->readsem);
+       mutex_lock(&u->readlock);
 
        err = 0;
        if (u->addr)
@@ -661,7 +661,7 @@ retry:
        spin_unlock(&unix_table_lock);
        err = 0;
 
-out:   up(&u->readsem);
+out:   mutex_unlock(&u->readlock);
        return err;
 }
 
@@ -744,7 +744,7 @@ static int unix_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
                goto out;
        addr_len = err;
 
-       down(&u->readsem);
+       mutex_lock(&u->readlock);
 
        err = -EINVAL;
        if (u->addr)
@@ -816,7 +816,7 @@ static int unix_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
 out_unlock:
        spin_unlock(&unix_table_lock);
 out_up:
-       up(&u->readsem);
+       mutex_unlock(&u->readlock);
 out:
        return err;
 
@@ -1545,7 +1545,7 @@ static int unix_dgram_recvmsg(struct kiocb *iocb, struct socket *sock,
 
        msg->msg_namelen = 0;
 
-       down(&u->readsem);
+       mutex_lock(&u->readlock);
 
        skb = skb_recv_datagram(sk, flags, noblock, &err);
        if (!skb)
@@ -1600,7 +1600,7 @@ static int unix_dgram_recvmsg(struct kiocb *iocb, struct socket *sock,
 out_free:
        skb_free_datagram(sk,skb);
 out_unlock:
-       up(&u->readsem);
+       mutex_unlock(&u->readlock);
 out:
        return err;
 }
@@ -1676,7 +1676,7 @@ static int unix_stream_recvmsg(struct kiocb *iocb, struct socket *sock,
                memset(&tmp_scm, 0, sizeof(tmp_scm));
        }
 
-       down(&u->readsem);
+       mutex_lock(&u->readlock);
 
        do
        {
@@ -1700,7 +1700,7 @@ static int unix_stream_recvmsg(struct kiocb *iocb, struct socket *sock,
                        err = -EAGAIN;
                        if (!timeo)
                                break;
-                       up(&u->readsem);
+                       mutex_unlock(&u->readlock);
 
                        timeo = unix_stream_data_wait(sk, timeo);
 
@@ -1708,7 +1708,7 @@ static int unix_stream_recvmsg(struct kiocb *iocb, struct socket *sock,
                                err = sock_intr_errno(timeo);
                                goto out;
                        }
-                       down(&u->readsem);
+                       mutex_lock(&u->readlock);
                        continue;
                }
 
@@ -1774,7 +1774,7 @@ static int unix_stream_recvmsg(struct kiocb *iocb, struct socket *sock,
                }
        } while (size);
 
-       up(&u->readsem);
+       mutex_unlock(&u->readlock);
        scm_recv(sock, msg, siocb->scm, flags);
 out:
        return copied ? : err;