[PATCH] sem2mutex: misc static one-file mutexes

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>
Cc: Dave Jones <davej@codemonkey.org.uk>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Ralf Baechle <ralf@linux-mips.org>
Cc: Jens Axboe <axboe@suse.de>
Cc: Neil Brown <neilb@cse.unsw.edu.au>
Acked-by: Alasdair G Kergon <agk@redhat.com>
Cc: Greg KH <greg@kroah.com>
Cc: Dominik Brodowski <linux@dominikbrodowski.net>
Cc: Adam Belay <ambx1@neo.rr.com>
Cc: Martin Schwidefsky <schwidefsky@de.ibm.com>
Cc: "David S. Miller" <davem@davemloft.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

diff --git a/arch/arm26/kernel/traps.c b/arch/arm26/kernel/traps.c
index 5847ea5d7747f6f73dd86bbd6f18af2eaa930ef9..a79de041b50e5c9795b33fa02563eee185ff26cb 100644 (file)
--- a/arch/arm26/kernel/traps.c
+++ b/arch/arm26/kernel/traps.c
@@ -34,7 +34,7 @@
 #include <asm/system.h>
 #include <asm/uaccess.h>
 #include <asm/unistd.h>
-#include <asm/semaphore.h>
+#include <linux/mutex.h>
 
 #include "ptrace.h"
 
@@ -207,19 +207,19 @@ void die_if_kernel(const char *str, struct pt_regs *regs, int err)
        die(str, regs, err);
 }
 
-static DECLARE_MUTEX(undef_sem);
+static DEFINE_MUTEX(undef_mutex);
 static int (*undef_hook)(struct pt_regs *);
 
 int request_undef_hook(int (*fn)(struct pt_regs *))
 {
        int ret = -EBUSY;
 
-       down(&undef_sem);
+       mutex_lock(&undef_mutex);
        if (undef_hook == NULL) {
                undef_hook = fn;
                ret = 0;
        }
-       up(&undef_sem);
+       mutex_unlock(&undef_mutex);
 
        return ret;
 }
@@ -228,12 +228,12 @@ int release_undef_hook(int (*fn)(struct pt_regs *))
 {
        int ret = -EINVAL;
 
-       down(&undef_sem);
+       mutex_lock(&undef_mutex);
        if (undef_hook == fn) {
                undef_hook = NULL;
                ret = 0;
        }
-       up(&undef_sem);
+       mutex_unlock(&undef_mutex);
 
        return ret;
 }

diff --git a/arch/i386/kernel/cpu/cpufreq/powernow-k8.c b/arch/i386/kernel/cpu/cpufreq/powernow-k8.c
index e5bc06480ff99fbf39f83c0836c6cc004e6cacc6..1e70823e1cb583ea8a8ff78c66472169f0cecf96 100644 (file)
--- a/arch/i386/kernel/cpu/cpufreq/powernow-k8.c
+++ b/arch/i386/kernel/cpu/cpufreq/powernow-k8.c
@@ -40,6 +40,7 @@
 
 #ifdef CONFIG_X86_POWERNOW_K8_ACPI
 #include <linux/acpi.h>
+#include <linux/mutex.h>
 #include <acpi/processor.h>
 #endif
 
@@ -49,7 +50,7 @@
 #include "powernow-k8.h"
 
 /* serialize freq changes  */
-static DECLARE_MUTEX(fidvid_sem);
+static DEFINE_MUTEX(fidvid_mutex);
 
 static struct powernow_k8_data *powernow_data[NR_CPUS];
 
@@ -943,17 +944,17 @@ static int powernowk8_target(struct cpufreq_policy *pol, unsigned targfreq, unsi
        if (cpufreq_frequency_table_target(pol, data->powernow_table, targfreq, relation, &newstate))
                goto err_out;
 
-       down(&fidvid_sem);
+       mutex_lock(&fidvid_mutex);
 
        powernow_k8_acpi_pst_values(data, newstate);
 
        if (transition_frequency(data, newstate)) {
                printk(KERN_ERR PFX "transition frequency failed\n");
                ret = 1;
-               up(&fidvid_sem);
+               mutex_unlock(&fidvid_mutex);
                goto err_out;
        }
-       up(&fidvid_sem);
+       mutex_unlock(&fidvid_mutex);
 
        pol->cur = find_khz_freq_from_fid(data->currfid);
        ret = 0;

diff --git a/arch/i386/kernel/cpu/mtrr/main.c b/arch/i386/kernel/cpu/mtrr/main.c
index 3b4618bed70d56fd1bc79087652b7b3c10791376..fff90bda473323a7fd0364d6db35475bbb862cd8 100644 (file)
--- a/arch/i386/kernel/cpu/mtrr/main.c
+++ b/arch/i386/kernel/cpu/mtrr/main.c
@@ -36,6 +36,7 @@
 #include <linux/pci.h>
 #include <linux/smp.h>
 #include <linux/cpu.h>
+#include <linux/mutex.h>
 
 #include <asm/mtrr.h>
 
@@ -47,7 +48,7 @@
 u32 num_var_ranges = 0;
 
 unsigned int *usage_table;
-static DECLARE_MUTEX(mtrr_sem);
+static DEFINE_MUTEX(mtrr_mutex);
 
 u32 size_or_mask, size_and_mask;
 
@@ -333,7 +334,7 @@ int mtrr_add_page(unsigned long base, unsigned long size,
        /* No CPU hotplug when we change MTRR entries */
        lock_cpu_hotplug();
        /*  Search for existing MTRR  */
-       down(&mtrr_sem);
+       mutex_lock(&mtrr_mutex);
        for (i = 0; i < num_var_ranges; ++i) {
                mtrr_if->get(i, &lbase, &lsize, &ltype);
                if (base >= lbase + lsize)
@@ -371,7 +372,7 @@ int mtrr_add_page(unsigned long base, unsigned long size,
                printk(KERN_INFO "mtrr: no more MTRRs available\n");
        error = i;
  out:
-       up(&mtrr_sem);
+       mutex_unlock(&mtrr_mutex);
        unlock_cpu_hotplug();
        return error;
 }
@@ -464,7 +465,7 @@ int mtrr_del_page(int reg, unsigned long base, unsigned long size)
        max = num_var_ranges;
        /* No CPU hotplug when we change MTRR entries */
        lock_cpu_hotplug();
-       down(&mtrr_sem);
+       mutex_lock(&mtrr_mutex);
        if (reg < 0) {
                /*  Search for existing MTRR  */
                for (i = 0; i < max; ++i) {
@@ -503,7 +504,7 @@ int mtrr_del_page(int reg, unsigned long base, unsigned long size)
                set_mtrr(reg, 0, 0, 0);
        error = reg;
  out:
-       up(&mtrr_sem);
+       mutex_unlock(&mtrr_mutex);
        unlock_cpu_hotplug();
        return error;
 }
@@ -685,7 +686,7 @@ void mtrr_ap_init(void)
        if (!mtrr_if || !use_intel())
                return;
        /*
-        * Ideally we should hold mtrr_sem here to avoid mtrr entries changed,
+        * Ideally we should hold mtrr_mutex here to avoid mtrr entries changed,
         * but this routine will be called in cpu boot time, holding the lock
         * breaks it. This routine is called in two cases: 1.very earily time
         * of software resume, when there absolutely isn't mtrr entry changes;

diff --git a/arch/i386/kernel/microcode.c b/arch/i386/kernel/microcode.c
index 55bc365b87536196f42f43bc45200f4983c98aaa..dd780a00553f3eeeeb038c25824d8a8346a00114 100644 (file)
--- a/arch/i386/kernel/microcode.c
+++ b/arch/i386/kernel/microcode.c
@@ -81,6 +81,7 @@
 #include <linux/miscdevice.h>
 #include <linux/spinlock.h>
 #include <linux/mm.h>
+#include <linux/mutex.h>
 
 #include <asm/msr.h>
 #include <asm/uaccess.h>
@@ -114,7 +115,7 @@ MODULE_LICENSE("GPL");
 static DEFINE_SPINLOCK(microcode_update_lock);
 
 /* no concurrent ->write()s are allowed on /dev/cpu/microcode */
-static DECLARE_MUTEX(microcode_sem);
+static DEFINE_MUTEX(microcode_mutex);
 
 static void __user *user_buffer;       /* user area microcode data buffer */
 static unsigned int user_buffer_size;  /* it's size */
@@ -444,7 +445,7 @@ static ssize_t microcode_write (struct file *file, const char __user *buf, size_
                return -EINVAL;
        }
 
-       down(&microcode_sem);
+       mutex_lock(&microcode_mutex);
 
        user_buffer = (void __user *) buf;
        user_buffer_size = (int) len;
@@ -453,7 +454,7 @@ static ssize_t microcode_write (struct file *file, const char __user *buf, size_
        if (!ret)
                ret = (ssize_t)len;
 
-       up(&microcode_sem);
+       mutex_unlock(&microcode_mutex);
 
        return ret;
 }

diff --git a/arch/mips/lasat/sysctl.c b/arch/mips/lasat/sysctl.c
index 8ff43a1c1e99c43f8cbbf5f49310f448b5fc87b4..e3d5aaa90f0db260ee78026df04ff603f4690c8c 100644 (file)
--- a/arch/mips/lasat/sysctl.c
+++ b/arch/mips/lasat/sysctl.c
@@ -30,12 +30,13 @@
 #include <linux/string.h>
 #include <linux/net.h>
 #include <linux/inet.h>
+#include <linux/mutex.h>
 #include <asm/uaccess.h>
 
 #include "sysctl.h"
 #include "ds1603.h"
 
-static DECLARE_MUTEX(lasat_info_sem);
+static DEFINE_MUTEX(lasat_info_mutex);
 
 /* Strategy function to write EEPROM after changing string entry */
 int sysctl_lasatstring(ctl_table *table, int *name, int nlen,
@@ -43,17 +44,17 @@ int sysctl_lasatstring(ctl_table *table, int *name, int nlen,
                void *newval, size_t newlen, void **context)
 {
        int r;
-       down(&lasat_info_sem);
+       mutex_lock(&lasat_info_mutex);
        r = sysctl_string(table, name,
                          nlen, oldval, oldlenp, newval, newlen, context);
        if (r < 0) {
-               up(&lasat_info_sem);
+               mutex_unlock(&lasat_info_mutex);
                return r;
        }
        if (newval && newlen) {
                lasat_write_eeprom_info();
        }
-       up(&lasat_info_sem);
+       mutex_unlock(&lasat_info_mutex);
        return 1;
 }
 
@@ -63,14 +64,14 @@ int proc_dolasatstring(ctl_table *table, int write, struct file *filp,
                       void *buffer, size_t *lenp, loff_t *ppos)
 {
        int r;
-       down(&lasat_info_sem);
+       mutex_lock(&lasat_info_mutex);
        r = proc_dostring(table, write, filp, buffer, lenp, ppos);
        if ( (!write) || r) {
-               up(&lasat_info_sem);
+               mutex_unlock(&lasat_info_mutex);
                return r;
        }
        lasat_write_eeprom_info();
-       up(&lasat_info_sem);
+       mutex_unlock(&lasat_info_mutex);
        return 0;
 }
 
@@ -79,14 +80,14 @@ int proc_dolasatint(ctl_table *table, int write, struct file *filp,
                       void *buffer, size_t *lenp, loff_t *ppos)
 {
        int r;
-       down(&lasat_info_sem);
+       mutex_lock(&lasat_info_mutex);
        r = proc_dointvec(table, write, filp, buffer, lenp, ppos);
        if ( (!write) || r) {
-               up(&lasat_info_sem);
+               mutex_unlock(&lasat_info_mutex);
                return r;
        }
        lasat_write_eeprom_info();
-       up(&lasat_info_sem);
+       mutex_unlock(&lasat_info_mutex);
        return 0;
 }
 
@@ -98,7 +99,7 @@ int proc_dolasatrtc(ctl_table *table, int write, struct file *filp,
                       void *buffer, size_t *lenp, loff_t *ppos)
 {
        int r;
-       down(&lasat_info_sem);
+       mutex_lock(&lasat_info_mutex);
        if (!write) {
                rtctmp = ds1603_read();
                /* check for time < 0 and set to 0 */
@@ -107,11 +108,11 @@ int proc_dolasatrtc(ctl_table *table, int write, struct file *filp,
        }
        r = proc_dointvec(table, write, filp, buffer, lenp, ppos);
        if ( (!write) || r) {
-               up(&lasat_info_sem);
+               mutex_unlock(&lasat_info_mutex);
                return r;
        }
        ds1603_set(rtctmp);
-       up(&lasat_info_sem);
+       mutex_unlock(&lasat_info_mutex);
        return 0;
 }
 #endif
@@ -122,16 +123,16 @@ int sysctl_lasat_intvec(ctl_table *table, int *name, int nlen,
                    void *newval, size_t newlen, void **context)
 {
        int r;
-       down(&lasat_info_sem);
+       mutex_lock(&lasat_info_mutex);
        r = sysctl_intvec(table, name, nlen, oldval, oldlenp, newval, newlen, context);
        if (r < 0) {
-               up(&lasat_info_sem);
+               mutex_unlock(&lasat_info_mutex);
                return r;
        }
        if (newval && newlen) {
                lasat_write_eeprom_info();
        }
-       up(&lasat_info_sem);
+       mutex_unlock(&lasat_info_mutex);
        return 1;
 }
 
@@ -142,19 +143,19 @@ int sysctl_lasat_rtc(ctl_table *table, int *name, int nlen,
                    void *newval, size_t newlen, void **context)
 {
        int r;
-       down(&lasat_info_sem);
+       mutex_lock(&lasat_info_mutex);
        rtctmp = ds1603_read();
        if (rtctmp < 0)
                rtctmp = 0;
        r = sysctl_intvec(table, name, nlen, oldval, oldlenp, newval, newlen, context);
        if (r < 0) {
-               up(&lasat_info_sem);
+               mutex_unlock(&lasat_info_mutex);
                return r;
        }
        if (newval && newlen) {
                ds1603_set(rtctmp);
        }
-       up(&lasat_info_sem);
+       mutex_unlock(&lasat_info_mutex);
        return 1;
 }
 #endif
@@ -192,13 +193,13 @@ int proc_lasat_ip(ctl_table *table, int write, struct file *filp,
                return 0;
        }
 
-       down(&lasat_info_sem);
+       mutex_lock(&lasat_info_mutex);
        if (write) {
                len = 0;
                p = buffer;
                while (len < *lenp) {
                        if(get_user(c, p++)) {
-                               up(&lasat_info_sem);
+                               mutex_unlock(&lasat_info_mutex);
                                return -EFAULT;
                        }
                        if (c == 0 || c == '\n')
@@ -209,7 +210,7 @@ int proc_lasat_ip(ctl_table *table, int write, struct file *filp,
                        len = sizeof(proc_lasat_ipbuf) - 1;
                if (copy_from_user(proc_lasat_ipbuf, buffer, len))
                {
-                       up(&lasat_info_sem);
+                       mutex_unlock(&lasat_info_mutex);
                        return -EFAULT;
                }
                proc_lasat_ipbuf[len] = 0;
@@ -230,12 +231,12 @@ int proc_lasat_ip(ctl_table *table, int write, struct file *filp,
                        len = *lenp;
                if (len)
                        if(copy_to_user(buffer, proc_lasat_ipbuf, len)) {
-                               up(&lasat_info_sem);
+                               mutex_unlock(&lasat_info_mutex);
                                return -EFAULT;
                        }
                if (len < *lenp) {
                        if(put_user('\n', ((char *) buffer) + len)) {
-                               up(&lasat_info_sem);
+                               mutex_unlock(&lasat_info_mutex);
                                return -EFAULT;
                        }
                        len++;
@@ -244,7 +245,7 @@ int proc_lasat_ip(ctl_table *table, int write, struct file *filp,
                *ppos += len;
        }
        update_bcastaddr();
-       up(&lasat_info_sem);
+       mutex_unlock(&lasat_info_mutex);
        return 0;
 }
 #endif /* defined(CONFIG_INET) */
@@ -256,10 +257,10 @@ static int sysctl_lasat_eeprom_value(ctl_table *table, int *name, int nlen,
 {
        int r;
 
-       down(&lasat_info_sem);
+       mutex_lock(&lasat_info_mutex);
        r = sysctl_intvec(table, name, nlen, oldval, oldlenp, newval, newlen, context);
        if (r < 0) {
-               up(&lasat_info_sem);
+               mutex_unlock(&lasat_info_mutex);
                return r;
        }
 
@@ -271,7 +272,7 @@ static int sysctl_lasat_eeprom_value(ctl_table *table, int *name, int nlen,
                lasat_write_eeprom_info();
                lasat_init_board_info();
        }
-       up(&lasat_info_sem);
+       mutex_unlock(&lasat_info_mutex);
 
        return 0;
 }
@@ -280,10 +281,10 @@ int proc_lasat_eeprom_value(ctl_table *table, int write, struct file *filp,
                       void *buffer, size_t *lenp, loff_t *ppos)
 {
        int r;
-       down(&lasat_info_sem);
+       mutex_lock(&lasat_info_mutex);
        r = proc_dointvec(table, write, filp, buffer, lenp, ppos);
        if ( (!write) || r) {
-               up(&lasat_info_sem);
+               mutex_unlock(&lasat_info_mutex);
                return r;
        }
        if (filp && filp->f_dentry)
@@ -294,7 +295,7 @@ int proc_lasat_eeprom_value(ctl_table *table, int write, struct file *filp,
                        lasat_board_info.li_eeprom_info.debugaccess = lasat_board_info.li_debugaccess;
        }
        lasat_write_eeprom_info();
-       up(&lasat_info_sem);
+       mutex_unlock(&lasat_info_mutex);
        return 0;
 }
 

diff --git a/arch/powerpc/mm/imalloc.c b/arch/powerpc/mm/imalloc.c
index 8b0c132bc163f174b512b7d48515e12d071f3732..add8c1a9af68ae12db88b1501f7b3f5d1c2ad1e4 100644 (file)
--- a/arch/powerpc/mm/imalloc.c
+++ b/arch/powerpc/mm/imalloc.c
@@ -13,12 +13,12 @@
 #include <asm/uaccess.h>
 #include <asm/pgalloc.h>
 #include <asm/pgtable.h>
-#include <asm/semaphore.h>
+#include <linux/mutex.h>
 #include <asm/cacheflush.h>
 
 #include "mmu_decl.h"
 
-static DECLARE_MUTEX(imlist_sem);
+static DEFINE_MUTEX(imlist_mutex);
 struct vm_struct * imlist = NULL;
 
 static int get_free_im_addr(unsigned long size, unsigned long *im_addr)
@@ -257,7 +257,7 @@ struct vm_struct * im_get_free_area(unsigned long size)
        struct vm_struct *area;
        unsigned long addr;
        
-       down(&imlist_sem);
+       mutex_lock(&imlist_mutex);
        if (get_free_im_addr(size, &addr)) {
                printk(KERN_ERR "%s() cannot obtain addr for size 0x%lx\n",
                                __FUNCTION__, size);
@@ -272,7 +272,7 @@ struct vm_struct * im_get_free_area(unsigned long size)
                        __FUNCTION__, addr, size);
        }
 next_im_done:
-       up(&imlist_sem);
+       mutex_unlock(&imlist_mutex);
        return area;
 }
 
@@ -281,9 +281,9 @@ struct vm_struct * im_get_area(unsigned long v_addr, unsigned long size,
 {
        struct vm_struct *area;
 
-       down(&imlist_sem);
+       mutex_lock(&imlist_mutex);
        area = __im_get_area(v_addr, size, criteria);
-       up(&imlist_sem);
+       mutex_unlock(&imlist_mutex);
        return area;
 }
 
@@ -297,17 +297,17 @@ void im_free(void * addr)
                printk(KERN_ERR "Trying to %s bad address (%p)\n", __FUNCTION__,                        addr);
                return;
        }
-       down(&imlist_sem);
+       mutex_lock(&imlist_mutex);
        for (p = &imlist ; (tmp = *p) ; p = &tmp->next) {
                if (tmp->addr == addr) {
                        *p = tmp->next;
                        unmap_vm_area(tmp);
                        kfree(tmp);
-                       up(&imlist_sem);
+                       mutex_unlock(&imlist_mutex);
                        return;
                }
        }
-       up(&imlist_sem);
+       mutex_unlock(&imlist_mutex);
        printk(KERN_ERR "Trying to %s nonexistent area (%p)\n", __FUNCTION__,
                        addr);
 }

diff --git a/arch/powerpc/platforms/cell/spu_base.c b/arch/powerpc/platforms/cell/spu_base.c
index d75ae03df68679e9bd05d9d97c5ef00d0b18d174..a8fa1eeeb17443753177ff857369fbdd635df81a 100644 (file)
--- a/arch/powerpc/platforms/cell/spu_base.c
+++ b/arch/powerpc/platforms/cell/spu_base.c
@@ -32,7 +32,7 @@
 
 #include <asm/io.h>
 #include <asm/prom.h>
-#include <asm/semaphore.h>
+#include <linux/mutex.h>
 #include <asm/spu.h>
 #include <asm/mmu_context.h>
 
@@ -342,7 +342,7 @@ spu_free_irqs(struct spu *spu)
 }
 
 static LIST_HEAD(spu_list);
-static DECLARE_MUTEX(spu_mutex);
+static DEFINE_MUTEX(spu_mutex);
 
 static void spu_init_channels(struct spu *spu)
 {
@@ -382,7 +382,7 @@ struct spu *spu_alloc(void)
 {
        struct spu *spu;
 
-       down(&spu_mutex);
+       mutex_lock(&spu_mutex);
        if (!list_empty(&spu_list)) {
                spu = list_entry(spu_list.next, struct spu, list);
                list_del_init(&spu->list);
@@ -391,7 +391,7 @@ struct spu *spu_alloc(void)
                pr_debug("No SPU left\n");
                spu = NULL;
        }
-       up(&spu_mutex);
+       mutex_unlock(&spu_mutex);
 
        if (spu)
                spu_init_channels(spu);
@@ -402,9 +402,9 @@ EXPORT_SYMBOL_GPL(spu_alloc);
 
 void spu_free(struct spu *spu)
 {
-       down(&spu_mutex);
+       mutex_lock(&spu_mutex);
        list_add_tail(&spu->list, &spu_list);
-       up(&spu_mutex);
+       mutex_unlock(&spu_mutex);
 }
 EXPORT_SYMBOL_GPL(spu_free);
 
@@ -633,14 +633,14 @@ static int __init create_spu(struct device_node *spe)
        spu->wbox_callback = NULL;
        spu->stop_callback = NULL;
 
-       down(&spu_mutex);
+       mutex_lock(&spu_mutex);
        spu->number = number++;
        ret = spu_request_irqs(spu);
        if (ret)
                goto out_unmap;
 
        list_add(&spu->list, &spu_list);
-       up(&spu_mutex);
+       mutex_unlock(&spu_mutex);
 
        pr_debug(KERN_DEBUG "Using SPE %s %02x %p %p %p %p %d\n",
                spu->name, spu->isrc, spu->local_store,
@@ -648,7 +648,7 @@ static int __init create_spu(struct device_node *spe)
        goto out;
 
 out_unmap:
-       up(&spu_mutex);
+       mutex_unlock(&spu_mutex);
        spu_unmap(spu);
 out_free:
        kfree(spu);
@@ -668,10 +668,10 @@ static void destroy_spu(struct spu *spu)
 static void cleanup_spu_base(void)
 {
        struct spu *spu, *tmp;
-       down(&spu_mutex);
+       mutex_lock(&spu_mutex);
        list_for_each_entry_safe(spu, tmp, &spu_list, list)
                destroy_spu(spu);
-       up(&spu_mutex);
+       mutex_unlock(&spu_mutex);
 }
 module_exit(cleanup_spu_base);
 

diff --git a/arch/powerpc/platforms/powermac/cpufreq_64.c b/arch/powerpc/platforms/powermac/cpufreq_64.c
index a415e8d2f7aff2e6fb0c0e71d8d28a685a3d64b5..b57e465a1b71d3ceb3409f6efd84a233c0c871e5 100644 (file)
--- a/arch/powerpc/platforms/powermac/cpufreq_64.c
+++ b/arch/powerpc/platforms/powermac/cpufreq_64.c
@@ -21,6 +21,7 @@
 #include <linux/cpufreq.h>
 #include <linux/init.h>
 #include <linux/completion.h>
+#include <linux/mutex.h>
 #include <asm/prom.h>
 #include <asm/machdep.h>
 #include <asm/irq.h>
@@ -90,7 +91,7 @@ static void (*g5_switch_volt)(int speed_mode);
 static int (*g5_switch_freq)(int speed_mode);
 static int (*g5_query_freq)(void);
 
-static DECLARE_MUTEX(g5_switch_mutex);
+static DEFINE_MUTEX(g5_switch_mutex);
 
 
 static struct smu_sdbp_fvt *g5_fvt_table;      /* table of op. points */
@@ -327,7 +328,7 @@ static int g5_cpufreq_target(struct cpufreq_policy *policy,
        if (g5_pmode_cur == newstate)
                return 0;
 
-       down(&g5_switch_mutex);
+       mutex_lock(&g5_switch_mutex);
 
        freqs.old = g5_cpu_freqs[g5_pmode_cur].frequency;
        freqs.new = g5_cpu_freqs[newstate].frequency;
@@ -337,7 +338,7 @@ static int g5_cpufreq_target(struct cpufreq_policy *policy,
        rc = g5_switch_freq(newstate);
        cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE);
 
-       up(&g5_switch_mutex);
+       mutex_unlock(&g5_switch_mutex);
 
        return rc;
 }

diff --git a/drivers/macintosh/smu.c b/drivers/macintosh/smu.c
index 4eb05d7143d80281f9f610373ad4af8cb5abb37d..f4516ca7aa3a20ee13f100e7d06fa9e18eded116 100644 (file)
--- a/drivers/macintosh/smu.c
+++ b/drivers/macintosh/smu.c
@@ -35,6 +35,7 @@
 #include <linux/delay.h>
 #include <linux/sysdev.h>
 #include <linux/poll.h>
+#include <linux/mutex.h>
 
 #include <asm/byteorder.h>
 #include <asm/io.h>
@@ -92,7 +93,7 @@ struct smu_device {
  * for now, just hard code that
  */
 static struct smu_device       *smu;
-static DECLARE_MUTEX(smu_part_access);
+static DEFINE_MUTEX(smu_part_access);
 
 static void smu_i2c_retry(unsigned long data);
 
@@ -976,11 +977,11 @@ struct smu_sdbp_header *__smu_get_sdb_partition(int id, unsigned int *size,
 
        if (interruptible) {
                int rc;
-               rc = down_interruptible(&smu_part_access);
+               rc = mutex_lock_interruptible(&smu_part_access);
                if (rc)
                        return ERR_PTR(rc);
        } else
-               down(&smu_part_access);
+               mutex_lock(&smu_part_access);
 
        part = (struct smu_sdbp_header *)get_property(smu->of_node,
                                                      pname, size);
@@ -990,7 +991,7 @@ struct smu_sdbp_header *__smu_get_sdb_partition(int id, unsigned int *size,
                if (part != NULL && size)
                        *size = part->len << 2;
        }
-       up(&smu_part_access);
+       mutex_unlock(&smu_part_access);
        return part;
 }
 

diff --git a/drivers/md/kcopyd.c b/drivers/md/kcopyd.c
index 8b3515f394a6ef93c115f00073bea02c071707ac..0d54e8b7d9de158172ff5ba2d54455952f7e8d95 100644 (file)
--- a/drivers/md/kcopyd.c
+++ b/drivers/md/kcopyd.c
@@ -590,51 +590,51 @@ static void client_del(struct kcopyd_client *kc)
        up(&_client_lock);
 }
 
-static DECLARE_MUTEX(kcopyd_init_lock);
+static DEFINE_MUTEX(kcopyd_init_lock);
 static int kcopyd_clients = 0;
 
 static int kcopyd_init(void)
 {
        int r;
 
-       down(&kcopyd_init_lock);
+       mutex_lock(&kcopyd_init_lock);
 
        if (kcopyd_clients) {
                /* Already initialized. */
                kcopyd_clients++;
-               up(&kcopyd_init_lock);
+               mutex_unlock(&kcopyd_init_lock);
                return 0;
        }
 
        r = jobs_init();
        if (r) {
-               up(&kcopyd_init_lock);
+               mutex_unlock(&kcopyd_init_lock);
                return r;
        }
 
        _kcopyd_wq = create_singlethread_workqueue("kcopyd");
        if (!_kcopyd_wq) {
                jobs_exit();
-               up(&kcopyd_init_lock);
+               mutex_unlock(&kcopyd_init_lock);
                return -ENOMEM;
        }
 
        kcopyd_clients++;
        INIT_WORK(&_kcopyd_work, do_work, NULL);
-       up(&kcopyd_init_lock);
+       mutex_unlock(&kcopyd_init_lock);
        return 0;
 }
 
 static void kcopyd_exit(void)
 {
-       down(&kcopyd_init_lock);
+       mutex_lock(&kcopyd_init_lock);
        kcopyd_clients--;
        if (!kcopyd_clients) {
                jobs_exit();
                destroy_workqueue(_kcopyd_wq);
                _kcopyd_wq = NULL;
        }
-       up(&kcopyd_init_lock);
+       mutex_unlock(&kcopyd_init_lock);
 }
 
 int kcopyd_client_create(unsigned int nr_pages, struct kcopyd_client **result)

diff --git a/drivers/net/wan/dscc4.c b/drivers/net/wan/dscc4.c
index 1ff5de076d216ced4663d489d0be537d94ffd745..4505540e3c591611182645433ac5dbc353e07a2a 100644 (file)
--- a/drivers/net/wan/dscc4.c
+++ b/drivers/net/wan/dscc4.c
@@ -105,6 +105,7 @@
 #include <linux/delay.h>
 #include <net/syncppp.h>
 #include <linux/hdlc.h>
+#include <linux/mutex.h>
 
 /* Version */
 static const char version[] = "$Id: dscc4.c,v 1.173 2003/09/20 23:55:34 romieu Exp $ for Linux\n";
@@ -112,7 +113,7 @@ static int debug;
 static int quartz;
 
 #ifdef CONFIG_DSCC4_PCI_RST
-static DECLARE_MUTEX(dscc4_sem);
+static DEFINE_MUTEX(dscc4_mutex);
 static u32 dscc4_pci_config_store[16];
 #endif
 
@@ -1018,7 +1019,7 @@ static void dscc4_pci_reset(struct pci_dev *pdev, void __iomem *ioaddr)
 {
        int i;
 
-       down(&dscc4_sem);
+       mutex_lock(&dscc4_mutex);
        for (i = 0; i < 16; i++)
                pci_read_config_dword(pdev, i << 2, dscc4_pci_config_store + i);
 
@@ -1039,7 +1040,7 @@ static void dscc4_pci_reset(struct pci_dev *pdev, void __iomem *ioaddr)
 
        for (i = 0; i < 16; i++)
                pci_write_config_dword(pdev, i << 2, dscc4_pci_config_store[i]);
-       up(&dscc4_sem);
+       mutex_unlock(&dscc4_mutex);
 }
 #else
 #define dscc4_pci_reset(pdev,ioaddr)   do {} while (0)

diff --git a/drivers/parport/share.c b/drivers/parport/share.c
index ea62bed6bc8329932d2080e1f1675b557a89c9c7..bbbfd79adbafc84788d02003703e4238d15735ba 100644 (file)
--- a/drivers/parport/share.c
+++ b/drivers/parport/share.c
@@ -32,6 +32,7 @@
 #include <linux/kmod.h>
 
 #include <linux/spinlock.h>
+#include <linux/mutex.h>
 #include <asm/irq.h>
 
 #undef PARPORT_PARANOID
@@ -50,7 +51,7 @@ static DEFINE_SPINLOCK(full_list_lock);
 
 static LIST_HEAD(drivers);
 
-static DECLARE_MUTEX(registration_lock);
+static DEFINE_MUTEX(registration_lock);
 
 /* What you can do to a port that's gone away.. */
 static void dead_write_lines (struct parport *p, unsigned char b){}
@@ -158,11 +159,11 @@ int parport_register_driver (struct parport_driver *drv)
        if (list_empty(&portlist))
                get_lowlevel_driver ();
 
-       down(&registration_lock);
+       mutex_lock(&registration_lock);
        list_for_each_entry(port, &portlist, list)
                drv->attach(port);
        list_add(&drv->list, &drivers);
-       up(&registration_lock);
+       mutex_unlock(&registration_lock);
 
        return 0;
 }
@@ -188,11 +189,11 @@ void parport_unregister_driver (struct parport_driver *drv)
 {
        struct parport *port;
 
-       down(&registration_lock);
+       mutex_lock(&registration_lock);
        list_del_init(&drv->list);
        list_for_each_entry(port, &portlist, list)
                drv->detach(port);
-       up(&registration_lock);
+       mutex_unlock(&registration_lock);
 }
 
 static void free_port (struct parport *port)
@@ -366,7 +367,7 @@ void parport_announce_port (struct parport *port)
 #endif
 
        parport_proc_register(port);
-       down(&registration_lock);
+       mutex_lock(&registration_lock);
        spin_lock_irq(&parportlist_lock);
        list_add_tail(&port->list, &portlist);
        for (i = 1; i < 3; i++) {
@@ -383,7 +384,7 @@ void parport_announce_port (struct parport *port)
                if (slave)
                        attach_driver_chain(slave);
        }
-       up(&registration_lock);
+       mutex_unlock(&registration_lock);
 }
 
 /**
@@ -409,7 +410,7 @@ void parport_remove_port(struct parport *port)
 {
        int i;
 
-       down(&registration_lock);
+       mutex_lock(&registration_lock);
 
        /* Spread the word. */
        detach_driver_chain (port);
@@ -436,7 +437,7 @@ void parport_remove_port(struct parport *port)
        }
        spin_unlock(&parportlist_lock);
 
-       up(&registration_lock);
+       mutex_unlock(&registration_lock);
 
        parport_proc_unregister(port);
 

diff --git a/drivers/pci/hotplug/rpadlpar_core.c b/drivers/pci/hotplug/rpadlpar_core.c
index 3eefe2cec72d1aef2ad849820fd3b683d7704645..46825fee3ae456f1bc47ed5dec4d9fc88437c234 100644 (file)
--- a/drivers/pci/hotplug/rpadlpar_core.c
+++ b/drivers/pci/hotplug/rpadlpar_core.c
@@ -19,7 +19,7 @@
 #include <linux/string.h>
 
 #include <asm/pci-bridge.h>
-#include <asm/semaphore.h>
+#include <linux/mutex.h>
 #include <asm/rtas.h>
 #include <asm/vio.h>
 
@@ -27,7 +27,7 @@
 #include "rpaphp.h"
 #include "rpadlpar.h"
 
-static DECLARE_MUTEX(rpadlpar_sem);
+static DEFINE_MUTEX(rpadlpar_mutex);
 
 #define DLPAR_MODULE_NAME "rpadlpar_io"
 
@@ -300,7 +300,7 @@ int dlpar_add_slot(char *drc_name)
        int node_type;
        int rc = -EIO;
 
-       if (down_interruptible(&rpadlpar_sem))
+       if (mutex_lock_interruptible(&rpadlpar_mutex))
                return -ERESTARTSYS;
 
        /* Find newly added node */
@@ -324,7 +324,7 @@ int dlpar_add_slot(char *drc_name)
 
        printk(KERN_INFO "%s: slot %s added\n", DLPAR_MODULE_NAME, drc_name);
 exit:
-       up(&rpadlpar_sem);
+       mutex_unlock(&rpadlpar_mutex);
        return rc;
 }
 
@@ -417,7 +417,7 @@ int dlpar_remove_slot(char *drc_name)
        int node_type;
        int rc = 0;
 
-       if (down_interruptible(&rpadlpar_sem))
+       if (mutex_lock_interruptible(&rpadlpar_mutex))
                return -ERESTARTSYS;
 
        dn = find_dlpar_node(drc_name, &node_type);
@@ -439,7 +439,7 @@ int dlpar_remove_slot(char *drc_name)
        }
        printk(KERN_INFO "%s: slot %s removed\n", DLPAR_MODULE_NAME, drc_name);
 exit:
-       up(&rpadlpar_sem);
+       mutex_unlock(&rpadlpar_mutex);
        return rc;
 }
 

diff --git a/drivers/pci/hotplug/sgi_hotplug.c b/drivers/pci/hotplug/sgi_hotplug.c
index c402da8e78aec8b0cb2af023fc821f27fb0ad4ff..8cb9abde736b43e40e6a72d6008838e60697c02d 100644 (file)
--- a/drivers/pci/hotplug/sgi_hotplug.c
+++ b/drivers/pci/hotplug/sgi_hotplug.c
@@ -15,6 +15,7 @@
 #include <linux/pci.h>
 #include <linux/proc_fs.h>
 #include <linux/types.h>
+#include <linux/mutex.h>
 
 #include <asm/sn/addrs.h>
 #include <asm/sn/l1.h>
@@ -81,7 +82,7 @@ static struct hotplug_slot_ops sn_hotplug_slot_ops = {
        .get_power_status       = get_power_status,
 };
 
-static DECLARE_MUTEX(sn_hotplug_sem);
+static DEFINE_MUTEX(sn_hotplug_mutex);
 
 static ssize_t path_show (struct hotplug_slot *bss_hotplug_slot,
                          char *buf)
@@ -346,7 +347,7 @@ static int enable_slot(struct hotplug_slot *bss_hotplug_slot)
        int rc;
 
        /* Serialize the Linux PCI infrastructure */
-       down(&sn_hotplug_sem);
+       mutex_lock(&sn_hotplug_mutex);
 
        /*
         * Power-on and initialize the slot in the SN
@@ -354,7 +355,7 @@ static int enable_slot(struct hotplug_slot *bss_hotplug_slot)
         */
        rc = sn_slot_enable(bss_hotplug_slot, slot->device_num);
        if (rc) {
-               up(&sn_hotplug_sem);
+               mutex_unlock(&sn_hotplug_mutex);
                return rc;
        }
 
@@ -362,7 +363,7 @@ static int enable_slot(struct hotplug_slot *bss_hotplug_slot)
                                  PCI_DEVFN(slot->device_num + 1, 0));
        if (!num_funcs) {
                dev_dbg(slot->pci_bus->self, "no device in slot\n");
-               up(&sn_hotplug_sem);
+               mutex_unlock(&sn_hotplug_mutex);
                return -ENODEV;
        }
 
@@ -402,7 +403,7 @@ static int enable_slot(struct hotplug_slot *bss_hotplug_slot)
        if (new_ppb)
                pci_bus_add_devices(new_bus);
 
-       up(&sn_hotplug_sem);
+       mutex_unlock(&sn_hotplug_mutex);
 
        if (rc == 0)
                dev_dbg(slot->pci_bus->self,
@@ -422,7 +423,7 @@ static int disable_slot(struct hotplug_slot *bss_hotplug_slot)
        int rc;
 
        /* Acquire update access to the bus */
-       down(&sn_hotplug_sem);
+       mutex_lock(&sn_hotplug_mutex);
 
        /* is it okay to bring this slot down? */
        rc = sn_slot_disable(bss_hotplug_slot, slot->device_num,
@@ -450,7 +451,7 @@ static int disable_slot(struct hotplug_slot *bss_hotplug_slot)
                             PCI_REQ_SLOT_DISABLE);
  leaving:
        /* Release the bus lock */
-       up(&sn_hotplug_sem);
+       mutex_unlock(&sn_hotplug_mutex);
 
        return rc;
 }
@@ -462,9 +463,9 @@ static inline int get_power_status(struct hotplug_slot *bss_hotplug_slot,
        struct pcibus_info *pcibus_info;
 
        pcibus_info = SN_PCIBUS_BUSSOFT_INFO(slot->pci_bus);
-       down(&sn_hotplug_sem);
+       mutex_lock(&sn_hotplug_mutex);
        *value = pcibus_info->pbi_enabled_devices & (1 << slot->device_num);
-       up(&sn_hotplug_sem);
+       mutex_unlock(&sn_hotplug_mutex);
        return 0;
 }
 

diff --git a/drivers/pnp/isapnp/core.c b/drivers/pnp/isapnp/core.c
index b1b4b683cbdd5ed06886343ee389032048e2d5ca..ac7c2bb6c69e683a148b4285550b99dfd1bb7c00 100644 (file)
--- a/drivers/pnp/isapnp/core.c
+++ b/drivers/pnp/isapnp/core.c
@@ -42,6 +42,7 @@
 #include <linux/delay.h>
 #include <linux/init.h>
 #include <linux/isapnp.h>
+#include <linux/mutex.h>
 #include <asm/io.h>
 
 #if 0
@@ -92,7 +93,7 @@ MODULE_LICENSE("GPL");
 #define _LTAG_FIXEDMEM32RANGE  0x86
 
 static unsigned char isapnp_checksum_value;
-static DECLARE_MUTEX(isapnp_cfg_mutex);
+static DEFINE_MUTEX(isapnp_cfg_mutex);
 static int isapnp_detected;
 static int isapnp_csn_count;
 
@@ -903,7 +904,7 @@ int isapnp_cfg_begin(int csn, int logdev)
 {
        if (csn < 1 || csn > isapnp_csn_count || logdev > 10)
                return -EINVAL;
-       down(&isapnp_cfg_mutex);
+       mutex_lock(&isapnp_cfg_mutex);
        isapnp_wait();
        isapnp_key();
        isapnp_wake(csn);
@@ -929,7 +930,7 @@ int isapnp_cfg_begin(int csn, int logdev)
 int isapnp_cfg_end(void)
 {
        isapnp_wait();
-       up(&isapnp_cfg_mutex);
+       mutex_unlock(&isapnp_cfg_mutex);
        return 0;
 }
 

diff --git a/drivers/s390/char/raw3270.c b/drivers/s390/char/raw3270.c
index bd06607a5dcc169ee3e1528fc5674525006f93fe..eecb2afad5c25ce460acdeba66041b7d5f291838 100644 (file)
--- a/drivers/s390/char/raw3270.c
+++ b/drivers/s390/char/raw3270.c
@@ -28,6 +28,7 @@
 #include <linux/major.h>
 #include <linux/kdev_t.h>
 #include <linux/device.h>
+#include <linux/mutex.h>
 
 struct class *class3270;
 
@@ -59,7 +60,7 @@ struct raw3270 {
 #define RAW3270_FLAGS_CONSOLE  8       /* Device is the console. */
 
 /* Semaphore to protect global data of raw3270 (devices, views, etc). */
-static DECLARE_MUTEX(raw3270_sem);
+static DEFINE_MUTEX(raw3270_mutex);
 
 /* List of 3270 devices. */
 static struct list_head raw3270_devices = LIST_HEAD_INIT(raw3270_devices);
@@ -815,7 +816,7 @@ raw3270_setup_device(struct ccw_device *cdev, struct raw3270 *rp, char *ascebc)
         * number for it. Note: there is no device with minor 0,
         * see special case for fs3270.c:fs3270_open().
         */
-       down(&raw3270_sem);
+       mutex_lock(&raw3270_mutex);
        /* Keep the list sorted. */
        minor = RAW3270_FIRSTMINOR;
        rp->minor = -1;
@@ -832,7 +833,7 @@ raw3270_setup_device(struct ccw_device *cdev, struct raw3270 *rp, char *ascebc)
                rp->minor = minor;
                list_add_tail(&rp->list, &raw3270_devices);
        }
-       up(&raw3270_sem);
+       mutex_unlock(&raw3270_mutex);
        /* No free minor number? Then give up. */
        if (rp->minor == -1)
                return -EUSERS;
@@ -1003,7 +1004,7 @@ raw3270_add_view(struct raw3270_view *view, struct raw3270_fn *fn, int minor)
 
        if (minor <= 0)
                return -ENODEV;
-       down(&raw3270_sem);
+       mutex_lock(&raw3270_mutex);
        rc = -ENODEV;
        list_for_each_entry(rp, &raw3270_devices, list) {
                if (rp->minor != minor)
@@ -1024,7 +1025,7 @@ raw3270_add_view(struct raw3270_view *view, struct raw3270_fn *fn, int minor)
                spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
                break;
        }
-       up(&raw3270_sem);
+       mutex_unlock(&raw3270_mutex);
        return rc;
 }
 
@@ -1038,7 +1039,7 @@ raw3270_find_view(struct raw3270_fn *fn, int minor)
        struct raw3270_view *view, *tmp;
        unsigned long flags;
 
-       down(&raw3270_sem);
+       mutex_lock(&raw3270_mutex);
        view = ERR_PTR(-ENODEV);
        list_for_each_entry(rp, &raw3270_devices, list) {
                if (rp->minor != minor)
@@ -1057,7 +1058,7 @@ raw3270_find_view(struct raw3270_fn *fn, int minor)
                spin_unlock_irqrestore(get_ccwdev_lock(rp->cdev), flags);
                break;
        }
-       up(&raw3270_sem);
+       mutex_unlock(&raw3270_mutex);
        return view;
 }
 
@@ -1104,7 +1105,7 @@ raw3270_delete_device(struct raw3270 *rp)
        struct ccw_device *cdev;
 
        /* Remove from device chain. */
-       down(&raw3270_sem);
+       mutex_lock(&raw3270_mutex);
        if (rp->clttydev)
                class_device_destroy(class3270,
                                     MKDEV(IBM_TTY3270_MAJOR, rp->minor));
@@ -1112,7 +1113,7 @@ raw3270_delete_device(struct raw3270 *rp)
                class_device_destroy(class3270,
                                     MKDEV(IBM_FS3270_MAJOR, rp->minor));
        list_del_init(&rp->list);
-       up(&raw3270_sem);
+       mutex_unlock(&raw3270_mutex);
 
        /* Disconnect from ccw_device. */
        cdev = rp->cdev;
@@ -1208,13 +1209,13 @@ int raw3270_register_notifier(void (*notifier)(int, int))
        if (!np)
                return -ENOMEM;
        np->notifier = notifier;
-       down(&raw3270_sem);
+       mutex_lock(&raw3270_mutex);
        list_add_tail(&np->list, &raw3270_notifier);
        list_for_each_entry(rp, &raw3270_devices, list) {
                get_device(&rp->cdev->dev);
                notifier(rp->minor, 1);
        }
-       up(&raw3270_sem);
+       mutex_unlock(&raw3270_mutex);
        return 0;
 }
 
@@ -1222,14 +1223,14 @@ void raw3270_unregister_notifier(void (*notifier)(int, int))
 {
        struct raw3270_notifier *np;
 
-       down(&raw3270_sem);
+       mutex_lock(&raw3270_mutex);
        list_for_each_entry(np, &raw3270_notifier, list)
                if (np->notifier == notifier) {
                        list_del(&np->list);
                        kfree(np);
                        break;
                }
-       up(&raw3270_sem);
+       mutex_unlock(&raw3270_mutex);
 }
 
 /*
@@ -1256,10 +1257,10 @@ raw3270_set_online (struct ccw_device *cdev)
                goto failure;
        raw3270_create_attributes(rp);
        set_bit(RAW3270_FLAGS_READY, &rp->flags);
-       down(&raw3270_sem);
+       mutex_lock(&raw3270_mutex);
        list_for_each_entry(np, &raw3270_notifier, list)
                np->notifier(rp->minor, 1);
-       up(&raw3270_sem);
+       mutex_unlock(&raw3270_mutex);
        return 0;
 
 failure:
@@ -1307,10 +1308,10 @@ raw3270_remove (struct ccw_device *cdev)
        }
        spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
 
-       down(&raw3270_sem);
+       mutex_lock(&raw3270_mutex);
        list_for_each_entry(np, &raw3270_notifier, list)
                np->notifier(rp->minor, 0);
-       up(&raw3270_sem);
+       mutex_unlock(&raw3270_mutex);
 
        /* Reset 3270 device. */
        raw3270_reset_device(rp);
@@ -1370,13 +1371,13 @@ raw3270_init(void)
        rc = ccw_driver_register(&raw3270_ccw_driver);
        if (rc == 0) {
                /* Create attributes for early (= console) device. */
-               down(&raw3270_sem);
+               mutex_lock(&raw3270_mutex);
                class3270 = class_create(THIS_MODULE, "3270");
                list_for_each_entry(rp, &raw3270_devices, list) {
                        get_device(&rp->cdev->dev);
                        raw3270_create_attributes(rp);
                }
-               up(&raw3270_sem);
+               mutex_unlock(&raw3270_mutex);
        }
        return rc;
 }

diff --git a/drivers/telephony/phonedev.c b/drivers/telephony/phonedev.c
index 3c987f49f6b4c382a46e01a66c6f519ecdfd2124..7a6db1c5c8c5bf491f8f9b237d18b2b812e0dcf3 100644 (file)
--- a/drivers/telephony/phonedev.c
+++ b/drivers/telephony/phonedev.c
@@ -29,6 +29,7 @@
 #include <linux/kmod.h>
 #include <linux/sem.h>
 #include <linux/devfs_fs_kernel.h>
+#include <linux/mutex.h>
 
 #define PHONE_NUM_DEVICES      256
 
@@ -37,7 +38,7 @@
  */
 
 static struct phone_device *phone_device[PHONE_NUM_DEVICES];
-static DECLARE_MUTEX(phone_lock);
+static DEFINE_MUTEX(phone_lock);
 
 /*
  *    Open a phone device.
@@ -53,14 +54,14 @@ static int phone_open(struct inode *inode, struct file *file)
        if (minor >= PHONE_NUM_DEVICES)
                return -ENODEV;
 
-       down(&phone_lock);
+       mutex_lock(&phone_lock);
        p = phone_device[minor];
        if (p)
                new_fops = fops_get(p->f_op);
        if (!new_fops) {
-               up(&phone_lock);
+               mutex_unlock(&phone_lock);
                request_module("char-major-%d-%d", PHONE_MAJOR, minor);
-               down(&phone_lock);
+               mutex_lock(&phone_lock);
                p = phone_device[minor];
                if (p == NULL || (new_fops = fops_get(p->f_op)) == NULL)
                {
@@ -78,7 +79,7 @@ static int phone_open(struct inode *inode, struct file *file)
        }
        fops_put(old_fops);
 end:
-       up(&phone_lock);
+       mutex_unlock(&phone_lock);
        return err;
 }
 
@@ -100,18 +101,18 @@ int phone_register_device(struct phone_device *p, int unit)
                end = unit + 1;  /* enter the loop at least one time */
        }
        
-       down(&phone_lock);
+       mutex_lock(&phone_lock);
        for (i = base; i < end; i++) {
                if (phone_device[i] == NULL) {
                        phone_device[i] = p;
                        p->minor = i;
                        devfs_mk_cdev(MKDEV(PHONE_MAJOR,i),
                                S_IFCHR|S_IRUSR|S_IWUSR, "phone/%d", i);
-                       up(&phone_lock);
+                       mutex_unlock(&phone_lock);
                        return 0;
                }
        }
-       up(&phone_lock);
+       mutex_unlock(&phone_lock);
        return -ENFILE;
 }
 
@@ -121,12 +122,12 @@ int phone_register_device(struct phone_device *p, int unit)
 
 void phone_unregister_device(struct phone_device *pfd)
 {
-       down(&phone_lock);
+       mutex_lock(&phone_lock);
        if (phone_device[pfd->minor] != pfd)
                panic("phone: bad unregister");
        devfs_remove("phone/%d", pfd->minor);
        phone_device[pfd->minor] = NULL;
-       up(&phone_lock);
+       mutex_unlock(&phone_lock);
 }
 
 

diff --git a/net/ipv4/ipvs/ip_vs_ctl.c b/net/ipv4/ipvs/ip_vs_ctl.c
index 7f0288b25fa16e77e017665e8788a0d20d98c5d9..f28ec68821622d7036132137f2af56f314f31a75 100644 (file)
--- a/net/ipv4/ipvs/ip_vs_ctl.c
+++ b/net/ipv4/ipvs/ip_vs_ctl.c
@@ -34,6 +34,7 @@
 
 #include <linux/netfilter.h>
 #include <linux/netfilter_ipv4.h>
+#include <linux/mutex.h>
 
 #include <net/ip.h>
 #include <net/route.h>
@@ -44,7 +45,7 @@
 #include <net/ip_vs.h>
 
 /* semaphore for IPVS sockopts. And, [gs]etsockopt may sleep. */
-static DECLARE_MUTEX(__ip_vs_mutex);
+static DEFINE_MUTEX(__ip_vs_mutex);
 
 /* lock for service table */
 static DEFINE_RWLOCK(__ip_vs_svc_lock);
@@ -1950,7 +1951,7 @@ do_ip_vs_set_ctl(struct sock *sk, int cmd, void __user *user, unsigned int len)
        /* increase the module use count */
        ip_vs_use_count_inc();
 
-       if (down_interruptible(&__ip_vs_mutex)) {
+       if (mutex_lock_interruptible(&__ip_vs_mutex)) {
                ret = -ERESTARTSYS;
                goto out_dec;
        }
@@ -2041,7 +2042,7 @@ do_ip_vs_set_ctl(struct sock *sk, int cmd, void __user *user, unsigned int len)
                ip_vs_service_put(svc);
 
   out_unlock:
-       up(&__ip_vs_mutex);
+       mutex_unlock(&__ip_vs_mutex);
   out_dec:
        /* decrease the module use count */
        ip_vs_use_count_dec();
@@ -2211,7 +2212,7 @@ do_ip_vs_get_ctl(struct sock *sk, int cmd, void __user *user, int *len)
        if (copy_from_user(arg, user, get_arglen[GET_CMDID(cmd)]) != 0)
                return -EFAULT;
 
-       if (down_interruptible(&__ip_vs_mutex))
+       if (mutex_lock_interruptible(&__ip_vs_mutex))
                return -ERESTARTSYS;
 
        switch (cmd) {
@@ -2330,7 +2331,7 @@ do_ip_vs_get_ctl(struct sock *sk, int cmd, void __user *user, int *len)
        }
 
   out:
-       up(&__ip_vs_mutex);
+       mutex_unlock(&__ip_vs_mutex);
        return ret;
 }
 

diff --git a/net/ipv4/netfilter/ipt_hashlimit.c b/net/ipv4/netfilter/ipt_hashlimit.c
index dc1521c5aa810bf8016f7ff5732bc6a282d022a0..ba5e23505e88dded2d1b84786b93b1ea3da97dc2 100644 (file)
--- a/net/ipv4/netfilter/ipt_hashlimit.c
+++ b/net/ipv4/netfilter/ipt_hashlimit.c
@@ -40,6 +40,7 @@
 
 /* FIXME: this is just for IP_NF_ASSERRT */
 #include <linux/netfilter_ipv4/ip_conntrack.h>
+#include <linux/mutex.h>
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Harald Welte <laforge@netfilter.org>");
@@ -92,7 +93,7 @@ struct ipt_hashlimit_htable {
 };
 
 static DEFINE_SPINLOCK(hashlimit_lock);        /* protects htables list */
-static DECLARE_MUTEX(hlimit_mutex);    /* additional checkentry protection */
+static DEFINE_MUTEX(hlimit_mutex);     /* additional checkentry protection */
 static HLIST_HEAD(hashlimit_htables);
 static kmem_cache_t *hashlimit_cachep __read_mostly;
 
@@ -542,13 +543,13 @@ hashlimit_checkentry(const char *tablename,
         * call vmalloc, and that can sleep.  And we cannot just re-search
         * the list of htable's in htable_create(), since then we would
         * create duplicate proc files. -HW */
-       down(&hlimit_mutex);
+       mutex_lock(&hlimit_mutex);
        r->hinfo = htable_find_get(r->name);
        if (!r->hinfo && (htable_create(r) != 0)) {
-               up(&hlimit_mutex);
+               mutex_unlock(&hlimit_mutex);
                return 0;
        }
-       up(&hlimit_mutex);
+       mutex_unlock(&hlimit_mutex);
 
        /* Ugly hack: For SMP, we only want to use one set */
        r->u.master = r;

diff --git a/net/netlink/genetlink.c b/net/netlink/genetlink.c
index 43e72419c868b38d660fef2a89519bd9898f2a64..f329b72578f568440d8e0ef331210eb6408a9bb8 100644 (file)
--- a/net/netlink/genetlink.c
+++ b/net/netlink/genetlink.c
@@ -13,26 +13,27 @@
 #include <linux/socket.h>
 #include <linux/string.h>
 #include <linux/skbuff.h>
+#include <linux/mutex.h>
 #include <net/sock.h>
 #include <net/genetlink.h>
 
 struct sock *genl_sock = NULL;
 
-static DECLARE_MUTEX(genl_sem); /* serialization of message processing */
+static DEFINE_MUTEX(genl_mutex); /* serialization of message processing */
 
 static void genl_lock(void)
 {
-       down(&genl_sem);
+       mutex_lock(&genl_mutex);
 }
 
 static int genl_trylock(void)
 {
-       return down_trylock(&genl_sem);
+       return !mutex_trylock(&genl_mutex);
 }
 
 static void genl_unlock(void)
 {
-       up(&genl_sem);
+       mutex_unlock(&genl_mutex);
 
        if (genl_sock && genl_sock->sk_receive_queue.qlen)
                genl_sock->sk_data_ready(genl_sock, 0);