[NET] sem2mutex: net/

Semaphore to mutex conversion.

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

Signed-off-by: Arjan van de Ven <arjan@infradead.org>
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>

diff --git a/include/net/xfrm.h b/include/net/xfrm.h
index 156f52ef8a9169bd9894a1cb5d94888bb04870c3..786371365f2b8691f91e95d4cab3cc9c3119e3a2 100644 (file)
--- a/include/net/xfrm.h
+++ b/include/net/xfrm.h
@@ -11,6 +11,7 @@
 #include <linux/crypto.h>
 #include <linux/pfkeyv2.h>
 #include <linux/in6.h>
+#include <linux/mutex.h>
 
 #include <net/sock.h>
 #include <net/dst.h>
@@ -24,7 +25,7 @@ extern struct sock *xfrm_nl;
 extern u32 sysctl_xfrm_aevent_etime;
 extern u32 sysctl_xfrm_aevent_rseqth;
 
-extern struct semaphore xfrm_cfg_sem;
+extern struct mutex xfrm_cfg_mutex;
 
 /* Organization of SPD aka "XFRM rules"
    ------------------------------------

diff --git a/net/atm/ioctl.c b/net/atm/ioctl.c
index eb109af7eb4a45b2cffef7aec1b2b146b6ea733b..851cfa6312af3288b9cdf14d1faa91028b583b88 100644 (file)
--- a/net/atm/ioctl.c
+++ b/net/atm/ioctl.c
@@ -18,6 +18,7 @@
 #include <linux/atmmpc.h>
 #include <net/atmclip.h>
 #include <linux/atmlec.h>
+#include <linux/mutex.h>
 #include <asm/ioctls.h>
 
 #include "resources.h"
@@ -25,22 +26,22 @@
 #include "common.h"
 
 
-static DECLARE_MUTEX(ioctl_mutex);
+static DEFINE_MUTEX(ioctl_mutex);
 static LIST_HEAD(ioctl_list);
 
 
 void register_atm_ioctl(struct atm_ioctl *ioctl)
 {
-       down(&ioctl_mutex);
+       mutex_lock(&ioctl_mutex);
        list_add_tail(&ioctl->list, &ioctl_list);
-       up(&ioctl_mutex);
+       mutex_unlock(&ioctl_mutex);
 }
 
 void deregister_atm_ioctl(struct atm_ioctl *ioctl)
 {
-       down(&ioctl_mutex);
+       mutex_lock(&ioctl_mutex);
        list_del(&ioctl->list);
-       up(&ioctl_mutex);
+       mutex_unlock(&ioctl_mutex);
 }
 
 EXPORT_SYMBOL(register_atm_ioctl);
@@ -137,7 +138,7 @@ int vcc_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
 
        error = -ENOIOCTLCMD;
 
-       down(&ioctl_mutex);
+       mutex_lock(&ioctl_mutex);
        list_for_each(pos, &ioctl_list) {
                struct atm_ioctl * ic = list_entry(pos, struct atm_ioctl, list);
                if (try_module_get(ic->owner)) {
@@ -147,7 +148,7 @@ int vcc_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
                                break;
                }
        }
-       up(&ioctl_mutex);
+       mutex_unlock(&ioctl_mutex);
 
        if (error != -ENOIOCTLCMD)
                goto done;

diff --git a/net/bluetooth/rfcomm/core.c b/net/bluetooth/rfcomm/core.c
index 5b4253c61f628d2c7256f5ac5f196bd20b40f5ce..e99010ce8bb2780055efbf3e7a678543a8ce8745 100644 (file)
--- a/net/bluetooth/rfcomm/core.c
+++ b/net/bluetooth/rfcomm/core.c
@@ -37,6 +37,8 @@
 #include <linux/wait.h>
 #include <linux/device.h>
 #include <linux/net.h>
+#include <linux/mutex.h>
+
 #include <net/sock.h>
 #include <asm/uaccess.h>
 #include <asm/unaligned.h>
@@ -57,9 +59,9 @@ static unsigned int l2cap_mtu = RFCOMM_MAX_L2CAP_MTU;
 
 static struct task_struct *rfcomm_thread;
 
-static DECLARE_MUTEX(rfcomm_sem);
-#define rfcomm_lock()  down(&rfcomm_sem);
-#define rfcomm_unlock()        up(&rfcomm_sem);
+static DEFINE_MUTEX(rfcomm_mutex);
+#define rfcomm_lock()  mutex_lock(&rfcomm_mutex)
+#define rfcomm_unlock()        mutex_unlock(&rfcomm_mutex)
 
 static unsigned long rfcomm_event;
 

diff --git a/net/core/dev.c b/net/core/dev.c
index ee044097f7f2411eb5be43ab545ed3c1ea3fc3e0..08dec6eb922bc6c971f952c4c396bf23e7c7d292 100644 (file)
--- a/net/core/dev.c
+++ b/net/core/dev.c
@@ -81,6 +81,7 @@
 #include <linux/types.h>
 #include <linux/kernel.h>
 #include <linux/sched.h>
+#include <linux/mutex.h>
 #include <linux/string.h>
 #include <linux/mm.h>
 #include <linux/socket.h>
@@ -2931,7 +2932,7 @@ static void netdev_wait_allrefs(struct net_device *dev)
  * 2) Since we run with the RTNL semaphore not held, we can sleep
  *    safely in order to wait for the netdev refcnt to drop to zero.
  */
-static DECLARE_MUTEX(net_todo_run_mutex);
+static DEFINE_MUTEX(net_todo_run_mutex);
 void netdev_run_todo(void)
 {
        struct list_head list = LIST_HEAD_INIT(list);
@@ -2939,7 +2940,7 @@ void netdev_run_todo(void)
 
 
        /* Need to guard against multiple cpu's getting out of order. */
-       down(&net_todo_run_mutex);
+       mutex_lock(&net_todo_run_mutex);
 
        /* Not safe to do outside the semaphore.  We must not return
         * until all unregister events invoked by the local processor
@@ -2996,7 +2997,7 @@ void netdev_run_todo(void)
        }
 
 out:
-       up(&net_todo_run_mutex);
+       mutex_unlock(&net_todo_run_mutex);
 }
 
 /**

diff --git a/net/core/flow.c b/net/core/flow.c
index c4f25385029f86ae4c0bcdd7d3fe0d3b151727df..55789f832edadc23d41851f6009b3d01f6072148 100644 (file)
--- a/net/core/flow.c
+++ b/net/core/flow.c
@@ -20,6 +20,7 @@
 #include <linux/notifier.h>
 #include <linux/cpu.h>
 #include <linux/cpumask.h>
+#include <linux/mutex.h>
 #include <net/flow.h>
 #include <asm/atomic.h>
 #include <asm/semaphore.h>
@@ -287,11 +288,11 @@ static void flow_cache_flush_per_cpu(void *data)
 void flow_cache_flush(void)
 {
        struct flow_flush_info info;
-       static DECLARE_MUTEX(flow_flush_sem);
+       static DEFINE_MUTEX(flow_flush_sem);
 
        /* Don't want cpus going down or up during this. */
        lock_cpu_hotplug();
-       down(&flow_flush_sem);
+       mutex_lock(&flow_flush_sem);
        atomic_set(&info.cpuleft, num_online_cpus());
        init_completion(&info.completion);
 
@@ -301,7 +302,7 @@ void flow_cache_flush(void)
        local_bh_enable();
 
        wait_for_completion(&info.completion);
-       up(&flow_flush_sem);
+       mutex_unlock(&flow_flush_sem);
        unlock_cpu_hotplug();
 }
 

diff --git a/net/ipv4/ipcomp.c b/net/ipv4/ipcomp.c
index d64e2ec8da7b454f0bd6bc273c9b4fde707fcb9e..c95020f7c81e38a2bdb0672fc7ecf5660c2f78d6 100644 (file)
--- a/net/ipv4/ipcomp.c
+++ b/net/ipv4/ipcomp.c
@@ -24,6 +24,7 @@
 #include <linux/list.h>
 #include <linux/vmalloc.h>
 #include <linux/rtnetlink.h>
+#include <linux/mutex.h>
 #include <net/ip.h>
 #include <net/xfrm.h>
 #include <net/icmp.h>
@@ -36,7 +37,7 @@ struct ipcomp_tfms {
        int users;
 };
 
-static DECLARE_MUTEX(ipcomp_resource_sem);
+static DEFINE_MUTEX(ipcomp_resource_mutex);
 static void **ipcomp_scratches;
 static int ipcomp_scratch_users;
 static LIST_HEAD(ipcomp_tfms_list);
@@ -253,7 +254,7 @@ error:
 }
 
 /*
- * Must be protected by xfrm_cfg_sem.  State and tunnel user references are
+ * Must be protected by xfrm_cfg_mutex.  State and tunnel user references are
  * always incremented on success.
  */
 static int ipcomp_tunnel_attach(struct xfrm_state *x)
@@ -411,9 +412,9 @@ static void ipcomp_destroy(struct xfrm_state *x)
        if (!ipcd)
                return;
        xfrm_state_delete_tunnel(x);
-       down(&ipcomp_resource_sem);
+       mutex_lock(&ipcomp_resource_mutex);
        ipcomp_free_data(ipcd);
-       up(&ipcomp_resource_sem);
+       mutex_unlock(&ipcomp_resource_mutex);
        kfree(ipcd);
 }
 
@@ -440,14 +441,14 @@ static int ipcomp_init_state(struct xfrm_state *x)
        if (x->props.mode)
                x->props.header_len += sizeof(struct iphdr);
 
-       down(&ipcomp_resource_sem);
+       mutex_lock(&ipcomp_resource_mutex);
        if (!ipcomp_alloc_scratches())
                goto error;
 
        ipcd->tfms = ipcomp_alloc_tfms(x->calg->alg_name);
        if (!ipcd->tfms)
                goto error;
-       up(&ipcomp_resource_sem);
+       mutex_unlock(&ipcomp_resource_mutex);
 
        if (x->props.mode) {
                err = ipcomp_tunnel_attach(x);
@@ -464,10 +465,10 @@ out:
        return err;
 
 error_tunnel:
-       down(&ipcomp_resource_sem);
+       mutex_lock(&ipcomp_resource_mutex);
 error:
        ipcomp_free_data(ipcd);
-       up(&ipcomp_resource_sem);
+       mutex_unlock(&ipcomp_resource_mutex);
        kfree(ipcd);
        goto out;
 }

diff --git a/net/ipv4/netfilter/ip_queue.c b/net/ipv4/netfilter/ip_queue.c
index 08f80e2ea2aa0fe1a1bd214de7384726dee4f209..1655866c55b9c7b7e9026d2870ae4ef1f2813474 100644 (file)
--- a/net/ipv4/netfilter/ip_queue.c
+++ b/net/ipv4/netfilter/ip_queue.c
@@ -35,6 +35,7 @@
 #include <linux/sysctl.h>
 #include <linux/proc_fs.h>
 #include <linux/security.h>
+#include <linux/mutex.h>
 #include <net/sock.h>
 #include <net/route.h>
 
@@ -61,7 +62,7 @@ static unsigned int queue_dropped = 0;
 static unsigned int queue_user_dropped = 0;
 static struct sock *ipqnl;
 static LIST_HEAD(queue_list);
-static DECLARE_MUTEX(ipqnl_sem);
+static DEFINE_MUTEX(ipqnl_mutex);
 
 static void
 ipq_issue_verdict(struct ipq_queue_entry *entry, int verdict)
@@ -539,7 +540,7 @@ ipq_rcv_sk(struct sock *sk, int len)
        struct sk_buff *skb;
        unsigned int qlen;
 
-       down(&ipqnl_sem);
+       mutex_lock(&ipqnl_mutex);
                        
        for (qlen = skb_queue_len(&sk->sk_receive_queue); qlen; qlen--) {
                skb = skb_dequeue(&sk->sk_receive_queue);
@@ -547,7 +548,7 @@ ipq_rcv_sk(struct sock *sk, int len)
                kfree_skb(skb);
        }
                
-       up(&ipqnl_sem);
+       mutex_unlock(&ipqnl_mutex);
 }
 
 static int
@@ -708,8 +709,8 @@ cleanup_sysctl:
        
 cleanup_ipqnl:
        sock_release(ipqnl->sk_socket);
-       down(&ipqnl_sem);
-       up(&ipqnl_sem);
+       mutex_lock(&ipqnl_mutex);
+       mutex_unlock(&ipqnl_mutex);
        
 cleanup_netlink_notifier:
        netlink_unregister_notifier(&ipq_nl_notifier);

diff --git a/net/ipv4/xfrm4_tunnel.c b/net/ipv4/xfrm4_tunnel.c
index afbb0d4cc305317add1c93b719abbcdcd2bb41ca..b08d56b117f837e226cbf7085fb3badfd515064d 100644 (file)
--- a/net/ipv4/xfrm4_tunnel.c
+++ b/net/ipv4/xfrm4_tunnel.c
@@ -5,6 +5,7 @@
 
 #include <linux/skbuff.h>
 #include <linux/module.h>
+#include <linux/mutex.h>
 #include <net/xfrm.h>
 #include <net/ip.h>
 #include <net/protocol.h>
@@ -26,19 +27,19 @@ static int ipip_xfrm_rcv(struct xfrm_state *x, struct xfrm_decap_state *decap, s
 }
 
 static struct xfrm_tunnel *ipip_handler;
-static DECLARE_MUTEX(xfrm4_tunnel_sem);
+static DEFINE_MUTEX(xfrm4_tunnel_mutex);
 
 int xfrm4_tunnel_register(struct xfrm_tunnel *handler)
 {
        int ret;
 
-       down(&xfrm4_tunnel_sem);
+       mutex_lock(&xfrm4_tunnel_mutex);
        ret = 0;
        if (ipip_handler != NULL)
                ret = -EINVAL;
        if (!ret)
                ipip_handler = handler;
-       up(&xfrm4_tunnel_sem);
+       mutex_unlock(&xfrm4_tunnel_mutex);
 
        return ret;
 }
@@ -49,13 +50,13 @@ int xfrm4_tunnel_deregister(struct xfrm_tunnel *handler)
 {
        int ret;
 
-       down(&xfrm4_tunnel_sem);
+       mutex_lock(&xfrm4_tunnel_mutex);
        ret = 0;
        if (ipip_handler != handler)
                ret = -EINVAL;
        if (!ret)
                ipip_handler = NULL;
-       up(&xfrm4_tunnel_sem);
+       mutex_unlock(&xfrm4_tunnel_mutex);
 
        synchronize_net();
 

diff --git a/net/ipv6/ipcomp6.c b/net/ipv6/ipcomp6.c
index 6107592fbd8cd7d92fa7ff2aff0f415139ceb8d5..3c7b324cd20c01ea4adbb2ac42f8592b824dff11 100644 (file)
--- a/net/ipv6/ipcomp6.c
+++ b/net/ipv6/ipcomp6.c
@@ -50,6 +50,7 @@
 #include <net/protocol.h>
 #include <linux/ipv6.h>
 #include <linux/icmpv6.h>
+#include <linux/mutex.h>
 
 struct ipcomp6_tfms {
        struct list_head list;
@@ -57,7 +58,7 @@ struct ipcomp6_tfms {
        int users;
 };
 
-static DECLARE_MUTEX(ipcomp6_resource_sem);
+static DEFINE_MUTEX(ipcomp6_resource_mutex);
 static void **ipcomp6_scratches;
 static int ipcomp6_scratch_users;
 static LIST_HEAD(ipcomp6_tfms_list);
@@ -405,9 +406,9 @@ static void ipcomp6_destroy(struct xfrm_state *x)
        if (!ipcd)
                return;
        xfrm_state_delete_tunnel(x);
-       down(&ipcomp6_resource_sem);
+       mutex_lock(&ipcomp6_resource_mutex);
        ipcomp6_free_data(ipcd);
-       up(&ipcomp6_resource_sem);
+       mutex_unlock(&ipcomp6_resource_mutex);
        kfree(ipcd);
 
        xfrm6_tunnel_free_spi((xfrm_address_t *)&x->props.saddr);
@@ -436,14 +437,14 @@ static int ipcomp6_init_state(struct xfrm_state *x)
        if (x->props.mode)
                x->props.header_len += sizeof(struct ipv6hdr);
        
-       down(&ipcomp6_resource_sem);
+       mutex_lock(&ipcomp6_resource_mutex);
        if (!ipcomp6_alloc_scratches())
                goto error;
 
        ipcd->tfms = ipcomp6_alloc_tfms(x->calg->alg_name);
        if (!ipcd->tfms)
                goto error;
-       up(&ipcomp6_resource_sem);
+       mutex_unlock(&ipcomp6_resource_mutex);
 
        if (x->props.mode) {
                err = ipcomp6_tunnel_attach(x);
@@ -459,10 +460,10 @@ static int ipcomp6_init_state(struct xfrm_state *x)
 out:
        return err;
 error_tunnel:
-       down(&ipcomp6_resource_sem);
+       mutex_lock(&ipcomp6_resource_mutex);
 error:
        ipcomp6_free_data(ipcd);
-       up(&ipcomp6_resource_sem);
+       mutex_unlock(&ipcomp6_resource_mutex);
        kfree(ipcd);
 
        goto out;

diff --git a/net/ipv6/netfilter/ip6_queue.c b/net/ipv6/netfilter/ip6_queue.c
index af0635084df8217dcc226a82c1a4ea3183e4df58..344eab3b5da82a2feb11b31fbe7c1d991cca4bc9 100644 (file)
--- a/net/ipv6/netfilter/ip6_queue.c
+++ b/net/ipv6/netfilter/ip6_queue.c
@@ -35,6 +35,7 @@
 #include <linux/spinlock.h>
 #include <linux/sysctl.h>
 #include <linux/proc_fs.h>
+#include <linux/mutex.h>
 #include <net/sock.h>
 #include <net/ipv6.h>
 #include <net/ip6_route.h>
@@ -65,7 +66,7 @@ static unsigned int queue_dropped = 0;
 static unsigned int queue_user_dropped = 0;
 static struct sock *ipqnl;
 static LIST_HEAD(queue_list);
-static DECLARE_MUTEX(ipqnl_sem);
+static DEFINE_MUTEX(ipqnl_mutex);
 
 static void
 ipq_issue_verdict(struct ipq_queue_entry *entry, int verdict)
@@ -537,7 +538,7 @@ ipq_rcv_sk(struct sock *sk, int len)
        struct sk_buff *skb;
        unsigned int qlen;
 
-       down(&ipqnl_sem);
+       mutex_lock(&ipqnl_mutex);
                        
        for (qlen = skb_queue_len(&sk->sk_receive_queue); qlen; qlen--) {
                skb = skb_dequeue(&sk->sk_receive_queue);
@@ -545,7 +546,7 @@ ipq_rcv_sk(struct sock *sk, int len)
                kfree_skb(skb);
        }
                
-       up(&ipqnl_sem);
+       mutex_unlock(&ipqnl_mutex);
 }
 
 static int
@@ -704,8 +705,8 @@ cleanup_sysctl:
        
 cleanup_ipqnl:
        sock_release(ipqnl->sk_socket);
-       down(&ipqnl_sem);
-       up(&ipqnl_sem);
+       mutex_lock(&ipqnl_mutex);
+       mutex_unlock(&ipqnl_mutex);
        
 cleanup_netlink_notifier:
        netlink_unregister_notifier(&ipq_nl_notifier);

diff --git a/net/ipv6/xfrm6_tunnel.c b/net/ipv6/xfrm6_tunnel.c
index 8cfc58b96fc2553cbb946765a70c8c6932ba0cff..08f9abbdf1d75c40deb73561541b065384fda13b 100644 (file)
--- a/net/ipv6/xfrm6_tunnel.c
+++ b/net/ipv6/xfrm6_tunnel.c
@@ -31,6 +31,7 @@
 #include <net/protocol.h>
 #include <linux/ipv6.h>
 #include <linux/icmpv6.h>
+#include <linux/mutex.h>
 
 #ifdef CONFIG_IPV6_XFRM6_TUNNEL_DEBUG
 # define X6TDEBUG      3
@@ -357,19 +358,19 @@ static int xfrm6_tunnel_input(struct xfrm_state *x, struct xfrm_decap_state *dec
 }
 
 static struct xfrm6_tunnel *xfrm6_tunnel_handler;
-static DECLARE_MUTEX(xfrm6_tunnel_sem);
+static DEFINE_MUTEX(xfrm6_tunnel_mutex);
 
 int xfrm6_tunnel_register(struct xfrm6_tunnel *handler)
 {
        int ret;
 
-       down(&xfrm6_tunnel_sem);
+       mutex_lock(&xfrm6_tunnel_mutex);
        ret = 0;
        if (xfrm6_tunnel_handler != NULL)
                ret = -EINVAL;
        if (!ret)
                xfrm6_tunnel_handler = handler;
-       up(&xfrm6_tunnel_sem);
+       mutex_unlock(&xfrm6_tunnel_mutex);
 
        return ret;
 }
@@ -380,13 +381,13 @@ int xfrm6_tunnel_deregister(struct xfrm6_tunnel *handler)
 {
        int ret;
 
-       down(&xfrm6_tunnel_sem);
+       mutex_lock(&xfrm6_tunnel_mutex);
        ret = 0;
        if (xfrm6_tunnel_handler != handler)
                ret = -EINVAL;
        if (!ret)
                xfrm6_tunnel_handler = NULL;
-       up(&xfrm6_tunnel_sem);
+       mutex_unlock(&xfrm6_tunnel_mutex);
 
        synchronize_net();
 

diff --git a/net/key/af_key.c b/net/key/af_key.c
index 520fe70d099340f9578cc199c19813e22f59478a..859582275cabd42747d652c73a2e7307e393ca87 100644 (file)
--- a/net/key/af_key.c
+++ b/net/key/af_key.c
@@ -3080,9 +3080,9 @@ static int pfkey_sendmsg(struct kiocb *kiocb,
        if (!hdr)
                goto out;
 
-       down(&xfrm_cfg_sem);
+       mutex_lock(&xfrm_cfg_mutex);
        err = pfkey_process(sk, skb, hdr);
-       up(&xfrm_cfg_sem);
+       mutex_unlock(&xfrm_cfg_mutex);
 
 out:
        if (err && hdr && pfkey_error(hdr, err, sk) == 0)

diff --git a/net/netfilter/nf_sockopt.c b/net/netfilter/nf_sockopt.c
index 61a833a9caa645eae6ca837da097d1b35584b4ee..0e5c5e2047995bf03c422ef68f4233b38154220d 100644 (file)
--- a/net/netfilter/nf_sockopt.c
+++ b/net/netfilter/nf_sockopt.c
@@ -4,6 +4,7 @@
 #include <linux/module.h>
 #include <linux/skbuff.h>
 #include <linux/netfilter.h>
+#include <linux/mutex.h>
 #include <net/sock.h>
 
 #include "nf_internals.h"
@@ -11,7 +12,7 @@
 /* Sockopts only registered and called from user context, so
    net locking would be overkill.  Also, [gs]etsockopt calls may
    sleep. */
-static DECLARE_MUTEX(nf_sockopt_mutex);
+static DEFINE_MUTEX(nf_sockopt_mutex);
 static LIST_HEAD(nf_sockopts);
 
 /* Do exclusive ranges overlap? */
@@ -26,7 +27,7 @@ int nf_register_sockopt(struct nf_sockopt_ops *reg)
        struct list_head *i;
        int ret = 0;
 
-       if (down_interruptible(&nf_sockopt_mutex) != 0)
+       if (mutex_lock_interruptible(&nf_sockopt_mutex) != 0)
                return -EINTR;
 
        list_for_each(i, &nf_sockopts) {
@@ -48,7 +49,7 @@ int nf_register_sockopt(struct nf_sockopt_ops *reg)
 
        list_add(&reg->list, &nf_sockopts);
 out:
-       up(&nf_sockopt_mutex);
+       mutex_unlock(&nf_sockopt_mutex);
        return ret;
 }
 EXPORT_SYMBOL(nf_register_sockopt);
@@ -57,18 +58,18 @@ void nf_unregister_sockopt(struct nf_sockopt_ops *reg)
 {
        /* No point being interruptible: we're probably in cleanup_module() */
  restart:
-       down(&nf_sockopt_mutex);
+       mutex_lock(&nf_sockopt_mutex);
        if (reg->use != 0) {
                /* To be woken by nf_sockopt call... */
                /* FIXME: Stuart Young's name appears gratuitously. */
                set_current_state(TASK_UNINTERRUPTIBLE);
                reg->cleanup_task = current;
-               up(&nf_sockopt_mutex);
+               mutex_unlock(&nf_sockopt_mutex);
                schedule();
                goto restart;
        }
        list_del(&reg->list);
-       up(&nf_sockopt_mutex);
+       mutex_unlock(&nf_sockopt_mutex);
 }
 EXPORT_SYMBOL(nf_unregister_sockopt);
 
@@ -80,7 +81,7 @@ static int nf_sockopt(struct sock *sk, int pf, int val,
        struct nf_sockopt_ops *ops;
        int ret;
 
-       if (down_interruptible(&nf_sockopt_mutex) != 0)
+       if (mutex_lock_interruptible(&nf_sockopt_mutex) != 0)
                return -EINTR;
 
        list_for_each(i, &nf_sockopts) {
@@ -90,7 +91,7 @@ static int nf_sockopt(struct sock *sk, int pf, int val,
                                if (val >= ops->get_optmin
                                    && val < ops->get_optmax) {
                                        ops->use++;
-                                       up(&nf_sockopt_mutex);
+                                       mutex_unlock(&nf_sockopt_mutex);
                                        ret = ops->get(sk, val, opt, len);
                                        goto out;
                                }
@@ -98,22 +99,22 @@ static int nf_sockopt(struct sock *sk, int pf, int val,
                                if (val >= ops->set_optmin
                                    && val < ops->set_optmax) {
                                        ops->use++;
-                                       up(&nf_sockopt_mutex);
+                                       mutex_unlock(&nf_sockopt_mutex);
                                        ret = ops->set(sk, val, opt, *len);
                                        goto out;
                                }
                        }
                }
        }
-       up(&nf_sockopt_mutex);
+       mutex_unlock(&nf_sockopt_mutex);
        return -ENOPROTOOPT;
        
  out:
-       down(&nf_sockopt_mutex);
+       mutex_lock(&nf_sockopt_mutex);
        ops->use--;
        if (ops->cleanup_task)
                wake_up_process(ops->cleanup_task);
-       up(&nf_sockopt_mutex);
+       mutex_unlock(&nf_sockopt_mutex);
        return ret;
 }
 

diff --git a/net/socket.c b/net/socket.c
index 510ae18d220a31aa7e82bc374369e09fcf583158..e3c21d5ec2885aa4fea17eea23621580c07a6fb7 100644 (file)
--- a/net/socket.c
+++ b/net/socket.c
@@ -68,6 +68,7 @@
 #include <linux/netdevice.h>
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
+#include <linux/mutex.h>
 #include <linux/wanrouter.h>
 #include <linux/if_bridge.h>
 #include <linux/if_frad.h>
@@ -826,36 +827,36 @@ static ssize_t sock_aio_write(struct kiocb *iocb, const char __user *ubuf,
  * with module unload.
  */
 
-static DECLARE_MUTEX(br_ioctl_mutex);
+static DEFINE_MUTEX(br_ioctl_mutex);
 static int (*br_ioctl_hook)(unsigned int cmd, void __user *arg) = NULL;
 
 void brioctl_set(int (*hook)(unsigned int, void __user *))
 {
-       down(&br_ioctl_mutex);
+       mutex_lock(&br_ioctl_mutex);
        br_ioctl_hook = hook;
-       up(&br_ioctl_mutex);
+       mutex_unlock(&br_ioctl_mutex);
 }
 EXPORT_SYMBOL(brioctl_set);
 
-static DECLARE_MUTEX(vlan_ioctl_mutex);
+static DEFINE_MUTEX(vlan_ioctl_mutex);
 static int (*vlan_ioctl_hook)(void __user *arg);
 
 void vlan_ioctl_set(int (*hook)(void __user *))
 {
-       down(&vlan_ioctl_mutex);
+       mutex_lock(&vlan_ioctl_mutex);
        vlan_ioctl_hook = hook;
-       up(&vlan_ioctl_mutex);
+       mutex_unlock(&vlan_ioctl_mutex);
 }
 EXPORT_SYMBOL(vlan_ioctl_set);
 
-static DECLARE_MUTEX(dlci_ioctl_mutex);
+static DEFINE_MUTEX(dlci_ioctl_mutex);
 static int (*dlci_ioctl_hook)(unsigned int, void __user *);
 
 void dlci_ioctl_set(int (*hook)(unsigned int, void __user *))
 {
-       down(&dlci_ioctl_mutex);
+       mutex_lock(&dlci_ioctl_mutex);
        dlci_ioctl_hook = hook;
-       up(&dlci_ioctl_mutex);
+       mutex_unlock(&dlci_ioctl_mutex);
 }
 EXPORT_SYMBOL(dlci_ioctl_set);
 
@@ -899,10 +900,10 @@ static long sock_ioctl(struct file *file, unsigned cmd, unsigned long arg)
                        if (!br_ioctl_hook)
                                request_module("bridge");
 
-                       down(&br_ioctl_mutex);
+                       mutex_lock(&br_ioctl_mutex);
                        if (br_ioctl_hook) 
                                err = br_ioctl_hook(cmd, argp);
-                       up(&br_ioctl_mutex);
+                       mutex_unlock(&br_ioctl_mutex);
                        break;
                case SIOCGIFVLAN:
                case SIOCSIFVLAN:
@@ -910,10 +911,10 @@ static long sock_ioctl(struct file *file, unsigned cmd, unsigned long arg)
                        if (!vlan_ioctl_hook)
                                request_module("8021q");
 
-                       down(&vlan_ioctl_mutex);
+                       mutex_lock(&vlan_ioctl_mutex);
                        if (vlan_ioctl_hook)
                                err = vlan_ioctl_hook(argp);
-                       up(&vlan_ioctl_mutex);
+                       mutex_unlock(&vlan_ioctl_mutex);
                        break;
                case SIOCGIFDIVERT:
                case SIOCSIFDIVERT:
@@ -927,9 +928,9 @@ static long sock_ioctl(struct file *file, unsigned cmd, unsigned long arg)
                                request_module("dlci");
 
                        if (dlci_ioctl_hook) {
-                               down(&dlci_ioctl_mutex);
+                               mutex_lock(&dlci_ioctl_mutex);
                                err = dlci_ioctl_hook(cmd, argp);
-                               up(&dlci_ioctl_mutex);
+                               mutex_unlock(&dlci_ioctl_mutex);
                        }
                        break;
                default:

diff --git a/net/sunrpc/cache.c b/net/sunrpc/cache.c
index dcaa0c4453ff4b0a7eb532a5676bfe3d27349e5c..0acccfeeb284ed7b12610bec06cd1bc4cd4ad62e 100644 (file)
--- a/net/sunrpc/cache.c
+++ b/net/sunrpc/cache.c
@@ -26,6 +26,7 @@
 #include <linux/proc_fs.h>
 #include <linux/net.h>
 #include <linux/workqueue.h>
+#include <linux/mutex.h>
 #include <asm/ioctls.h>
 #include <linux/sunrpc/types.h>
 #include <linux/sunrpc/cache.h>
@@ -532,7 +533,7 @@ void cache_clean_deferred(void *owner)
  */
 
 static DEFINE_SPINLOCK(queue_lock);
-static DECLARE_MUTEX(queue_io_sem);
+static DEFINE_MUTEX(queue_io_mutex);
 
 struct cache_queue {
        struct list_head        list;
@@ -561,7 +562,7 @@ cache_read(struct file *filp, char __user *buf, size_t count, loff_t *ppos)
        if (count == 0)
                return 0;
 
-       down(&queue_io_sem); /* protect against multiple concurrent
+       mutex_lock(&queue_io_mutex); /* protect against multiple concurrent
                              * readers on this file */
  again:
        spin_lock(&queue_lock);
@@ -574,7 +575,7 @@ cache_read(struct file *filp, char __user *buf, size_t count, loff_t *ppos)
        }
        if (rp->q.list.next == &cd->queue) {
                spin_unlock(&queue_lock);
-               up(&queue_io_sem);
+               mutex_unlock(&queue_io_mutex);
                BUG_ON(rp->offset);
                return 0;
        }
@@ -621,11 +622,11 @@ cache_read(struct file *filp, char __user *buf, size_t count, loff_t *ppos)
        }
        if (err == -EAGAIN)
                goto again;
-       up(&queue_io_sem);
+       mutex_unlock(&queue_io_mutex);
        return err ? err :  count;
 }
 
-static char write_buf[8192]; /* protected by queue_io_sem */
+static char write_buf[8192]; /* protected by queue_io_mutex */
 
 static ssize_t
 cache_write(struct file *filp, const char __user *buf, size_t count,
@@ -639,10 +640,10 @@ cache_write(struct file *filp, const char __user *buf, size_t count,
        if (count >= sizeof(write_buf))
                return -EINVAL;
 
-       down(&queue_io_sem);
+       mutex_lock(&queue_io_mutex);
 
        if (copy_from_user(write_buf, buf, count)) {
-               up(&queue_io_sem);
+               mutex_unlock(&queue_io_mutex);
                return -EFAULT;
        }
        write_buf[count] = '\0';
@@ -651,7 +652,7 @@ cache_write(struct file *filp, const char __user *buf, size_t count,
        else
                err = -EINVAL;
 
-       up(&queue_io_sem);
+       mutex_unlock(&queue_io_mutex);
        return err ? err : count;
 }
 

diff --git a/net/sunrpc/sched.c b/net/sunrpc/sched.c
index e838d042f7f51e2f0ded4852ddc08441ba8ff687..dff07795bd16af0dbbb5ff1cb51e4729a28ef3ab 100644 (file)
--- a/net/sunrpc/sched.c
+++ b/net/sunrpc/sched.c
@@ -18,6 +18,7 @@
 #include <linux/smp.h>
 #include <linux/smp_lock.h>
 #include <linux/spinlock.h>
+#include <linux/mutex.h>
 
 #include <linux/sunrpc/clnt.h>
 #include <linux/sunrpc/xprt.h>
@@ -62,7 +63,7 @@ static LIST_HEAD(all_tasks);
 /*
  * rpciod-related stuff
  */
-static DECLARE_MUTEX(rpciod_sema);
+static DEFINE_MUTEX(rpciod_mutex);
 static unsigned int            rpciod_users;
 static struct workqueue_struct *rpciod_workqueue;
 
@@ -1047,7 +1048,7 @@ rpciod_up(void)
        struct workqueue_struct *wq;
        int error = 0;
 
-       down(&rpciod_sema);
+       mutex_lock(&rpciod_mutex);
        dprintk("rpciod_up: users %d\n", rpciod_users);
        rpciod_users++;
        if (rpciod_workqueue)
@@ -1070,14 +1071,14 @@ rpciod_up(void)
        rpciod_workqueue = wq;
        error = 0;
 out:
-       up(&rpciod_sema);
+       mutex_unlock(&rpciod_mutex);
        return error;
 }
 
 void
 rpciod_down(void)
 {
-       down(&rpciod_sema);
+       mutex_lock(&rpciod_mutex);
        dprintk("rpciod_down sema %d\n", rpciod_users);
        if (rpciod_users) {
                if (--rpciod_users)
@@ -1094,7 +1095,7 @@ rpciod_down(void)
        destroy_workqueue(rpciod_workqueue);
        rpciod_workqueue = NULL;
  out:
-       up(&rpciod_sema);
+       mutex_unlock(&rpciod_mutex);
 }
 
 #ifdef RPC_DEBUG

diff --git a/net/unix/garbage.c b/net/unix/garbage.c
index 411802bd4d37e604fe7a337bff2c7becaf84fccb..746c2f4a5fa62a290418a0b7780b165678ae7f96 100644 (file)
--- a/net/unix/garbage.c
+++ b/net/unix/garbage.c
@@ -76,6 +76,7 @@
 #include <linux/netdevice.h>
 #include <linux/file.h>
 #include <linux/proc_fs.h>
+#include <linux/mutex.h>
 
 #include <net/sock.h>
 #include <net/af_unix.h>
@@ -169,7 +170,7 @@ static void maybe_unmark_and_push(struct sock *x)
 
 void unix_gc(void)
 {
-       static DECLARE_MUTEX(unix_gc_sem);
+       static DEFINE_MUTEX(unix_gc_sem);
        int i;
        struct sock *s;
        struct sk_buff_head hitlist;
@@ -179,7 +180,7 @@ void unix_gc(void)
         *      Avoid a recursive GC.
         */
 
-       if (down_trylock(&unix_gc_sem))
+       if (!mutex_trylock(&unix_gc_sem))
                return;
 
        spin_lock(&unix_table_lock);
@@ -308,5 +309,5 @@ void unix_gc(void)
         */
 
        __skb_queue_purge(&hitlist);
-       up(&unix_gc_sem);
+       mutex_unlock(&unix_gc_sem);
 }

diff --git a/net/xfrm/xfrm_policy.c b/net/xfrm/xfrm_policy.c
index b46079263e8bf1cbeaa23c26bb29edc9a9d08258..f5eae9febd26acbfca587264794011ef420a87e5 100644 (file)
--- a/net/xfrm/xfrm_policy.c
+++ b/net/xfrm/xfrm_policy.c
@@ -26,8 +26,8 @@
 #include <net/xfrm.h>
 #include <net/ip.h>
 
-DECLARE_MUTEX(xfrm_cfg_sem);
-EXPORT_SYMBOL(xfrm_cfg_sem);
+DEFINE_MUTEX(xfrm_cfg_mutex);
+EXPORT_SYMBOL(xfrm_cfg_mutex);
 
 static DEFINE_RWLOCK(xfrm_policy_lock);
 

diff --git a/net/xfrm/xfrm_user.c b/net/xfrm/xfrm_user.c
index 7b1acd995168b94af410c5f2e1f8a0f3e7c6f7cd..4a7120a7e10fbf6666472a1c260bce3b95818b98 100644 (file)
--- a/net/xfrm/xfrm_user.c
+++ b/net/xfrm/xfrm_user.c
@@ -1486,9 +1486,9 @@ static void xfrm_netlink_rcv(struct sock *sk, int len)
        unsigned int qlen = 0;
 
        do {
-               down(&xfrm_cfg_sem);
+               mutex_lock(&xfrm_cfg_mutex);
                netlink_run_queue(sk, &qlen, &xfrm_user_rcv_msg);
-               up(&xfrm_cfg_sem);
+               mutex_unlock(&xfrm_cfg_mutex);
 
        } while (qlen);
 }