[PATCH] sem2mutex: blockdev #2

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>
Acked-by: Jens Axboe <axboe@suse.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

diff --git a/block/ioctl.c b/block/ioctl.c
index e1109491c234c0ec50d15d220b81589d52cb10c6..35fdb7dc6512028be4a3d7e1e4012aaadf1b4ddf 100644 (file)
--- a/block/ioctl.c
+++ b/block/ioctl.c
@@ -42,9 +42,9 @@ static int blkpg_ioctl(struct block_device *bdev, struct blkpg_ioctl_arg __user
                                        return -EINVAL;
                        }
                        /* partition number in use? */
-                       down(&bdev->bd_sem);
+                       mutex_lock(&bdev->bd_mutex);
                        if (disk->part[part - 1]) {
-                               up(&bdev->bd_sem);
+                               mutex_unlock(&bdev->bd_mutex);
                                return -EBUSY;
                        }
                        /* overlap? */
@@ -55,13 +55,13 @@ static int blkpg_ioctl(struct block_device *bdev, struct blkpg_ioctl_arg __user
                                        continue;
                                if (!(start+length <= s->start_sect ||
                                      start >= s->start_sect + s->nr_sects)) {
-                                       up(&bdev->bd_sem);
+                                       mutex_unlock(&bdev->bd_mutex);
                                        return -EBUSY;
                                }
                        }
                        /* all seems OK */
                        add_partition(disk, part, start, length);
-                       up(&bdev->bd_sem);
+                       mutex_unlock(&bdev->bd_mutex);
                        return 0;
                case BLKPG_DEL_PARTITION:
                        if (!disk->part[part-1])
@@ -71,9 +71,9 @@ static int blkpg_ioctl(struct block_device *bdev, struct blkpg_ioctl_arg __user
                        bdevp = bdget_disk(disk, part);
                        if (!bdevp)
                                return -ENOMEM;
-                       down(&bdevp->bd_sem);
+                       mutex_lock(&bdevp->bd_mutex);
                        if (bdevp->bd_openers) {
-                               up(&bdevp->bd_sem);
+                               mutex_unlock(&bdevp->bd_mutex);
                                bdput(bdevp);
                                return -EBUSY;
                        }
@@ -81,10 +81,10 @@ static int blkpg_ioctl(struct block_device *bdev, struct blkpg_ioctl_arg __user
                        fsync_bdev(bdevp);
                        invalidate_bdev(bdevp, 0);
 
-                       down(&bdev->bd_sem);
+                       mutex_lock(&bdev->bd_mutex);
                        delete_partition(disk, part);
-                       up(&bdev->bd_sem);
-                       up(&bdevp->bd_sem);
+                       mutex_unlock(&bdev->bd_mutex);
+                       mutex_unlock(&bdevp->bd_mutex);
                        bdput(bdevp);
 
                        return 0;
@@ -102,10 +102,10 @@ static int blkdev_reread_part(struct block_device *bdev)
                return -EINVAL;
        if (!capable(CAP_SYS_ADMIN))
                return -EACCES;
-       if (down_trylock(&bdev->bd_sem))
+       if (!mutex_trylock(&bdev->bd_mutex))
                return -EBUSY;
        res = rescan_partitions(disk, bdev);
-       up(&bdev->bd_sem);
+       mutex_unlock(&bdev->bd_mutex);
        return res;
 }
 

diff --git a/drivers/block/rd.c b/drivers/block/rd.c
index ffd6abd6d5a045f40dd98a92486e1d21ea29e81c..1c54f46d3f701bff756cfcd385a5eac38ac65a8c 100644 (file)
--- a/drivers/block/rd.c
+++ b/drivers/block/rd.c
@@ -310,12 +310,12 @@ static int rd_ioctl(struct inode *inode, struct file *file,
         * cache
         */
        error = -EBUSY;
-       down(&bdev->bd_sem);
+       mutex_lock(&bdev->bd_mutex);
        if (bdev->bd_openers <= 2) {
                truncate_inode_pages(bdev->bd_inode->i_mapping, 0);
                error = 0;
        }
-       up(&bdev->bd_sem);
+       mutex_unlock(&bdev->bd_mutex);
        return error;
 }
 

diff --git a/drivers/s390/block/dasd_ioctl.c b/drivers/s390/block/dasd_ioctl.c
index fafeeae52675ea396a1c71c67f9395fc635b78af..f9930552ab5457a7febfc2fb0c135e4f55843f9b 100644 (file)
--- a/drivers/s390/block/dasd_ioctl.c
+++ b/drivers/s390/block/dasd_ioctl.c
@@ -151,9 +151,9 @@ dasd_ioctl_enable(struct block_device *bdev, int no, long args)
                return -ENODEV;
        dasd_enable_device(device);
        /* Formatting the dasd device can change the capacity. */
-       down(&bdev->bd_sem);
+       mutex_lock(&bdev->bd_mutex);
        i_size_write(bdev->bd_inode, (loff_t)get_capacity(device->gdp) << 9);
-       up(&bdev->bd_sem);
+       mutex_unlock(&bdev->bd_mutex);
        return 0;
 }
 
@@ -184,9 +184,9 @@ dasd_ioctl_disable(struct block_device *bdev, int no, long args)
         * Set i_size to zero, since read, write, etc. check against this
         * value.
         */
-       down(&bdev->bd_sem);
+       mutex_lock(&bdev->bd_mutex);
        i_size_write(bdev->bd_inode, 0);
-       up(&bdev->bd_sem);
+       mutex_unlock(&bdev->bd_mutex);
        return 0;
 }
 

diff --git a/fs/block_dev.c b/fs/block_dev.c
index 6e50346fb1eeea70da97a38d2059249362c10a0f..44d05e6e34dbc941ead6bc23202fae7cc5a04ff2 100644 (file)
--- a/fs/block_dev.c
+++ b/fs/block_dev.c
@@ -265,8 +265,8 @@ static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
            SLAB_CTOR_CONSTRUCTOR)
        {
                memset(bdev, 0, sizeof(*bdev));
-               sema_init(&bdev->bd_sem, 1);
-               sema_init(&bdev->bd_mount_sem, 1);
+               mutex_init(&bdev->bd_mutex);
+               mutex_init(&bdev->bd_mount_mutex);
                INIT_LIST_HEAD(&bdev->bd_inodes);
                INIT_LIST_HEAD(&bdev->bd_list);
                inode_init_once(&ei->vfs_inode);
@@ -574,7 +574,7 @@ static int do_open(struct block_device *bdev, struct file *file)
        }
        owner = disk->fops->owner;
 
-       down(&bdev->bd_sem);
+       mutex_lock(&bdev->bd_mutex);
        if (!bdev->bd_openers) {
                bdev->bd_disk = disk;
                bdev->bd_contains = bdev;
@@ -605,21 +605,21 @@ static int do_open(struct block_device *bdev, struct file *file)
                        if (ret)
                                goto out_first;
                        bdev->bd_contains = whole;
-                       down(&whole->bd_sem);
+                       mutex_lock(&whole->bd_mutex);
                        whole->bd_part_count++;
                        p = disk->part[part - 1];
                        bdev->bd_inode->i_data.backing_dev_info =
                           whole->bd_inode->i_data.backing_dev_info;
                        if (!(disk->flags & GENHD_FL_UP) || !p || !p->nr_sects) {
                                whole->bd_part_count--;
-                               up(&whole->bd_sem);
+                               mutex_unlock(&whole->bd_mutex);
                                ret = -ENXIO;
                                goto out_first;
                        }
                        kobject_get(&p->kobj);
                        bdev->bd_part = p;
                        bd_set_size(bdev, (loff_t) p->nr_sects << 9);
-                       up(&whole->bd_sem);
+                       mutex_unlock(&whole->bd_mutex);
                }
        } else {
                put_disk(disk);
@@ -633,13 +633,13 @@ static int do_open(struct block_device *bdev, struct file *file)
                        if (bdev->bd_invalidated)
                                rescan_partitions(bdev->bd_disk, bdev);
                } else {
-                       down(&bdev->bd_contains->bd_sem);
+                       mutex_lock(&bdev->bd_contains->bd_mutex);
                        bdev->bd_contains->bd_part_count++;
-                       up(&bdev->bd_contains->bd_sem);
+                       mutex_unlock(&bdev->bd_contains->bd_mutex);
                }
        }
        bdev->bd_openers++;
-       up(&bdev->bd_sem);
+       mutex_unlock(&bdev->bd_mutex);
        unlock_kernel();
        return 0;
 
@@ -652,7 +652,7 @@ out_first:
        put_disk(disk);
        module_put(owner);
 out:
-       up(&bdev->bd_sem);
+       mutex_unlock(&bdev->bd_mutex);
        unlock_kernel();
        if (ret)
                bdput(bdev);
@@ -714,7 +714,7 @@ int blkdev_put(struct block_device *bdev)
        struct inode *bd_inode = bdev->bd_inode;
        struct gendisk *disk = bdev->bd_disk;
 
-       down(&bdev->bd_sem);
+       mutex_lock(&bdev->bd_mutex);
        lock_kernel();
        if (!--bdev->bd_openers) {
                sync_blockdev(bdev);
@@ -724,9 +724,9 @@ int blkdev_put(struct block_device *bdev)
                if (disk->fops->release)
                        ret = disk->fops->release(bd_inode, NULL);
        } else {
-               down(&bdev->bd_contains->bd_sem);
+               mutex_lock(&bdev->bd_contains->bd_mutex);
                bdev->bd_contains->bd_part_count--;
-               up(&bdev->bd_contains->bd_sem);
+               mutex_unlock(&bdev->bd_contains->bd_mutex);
        }
        if (!bdev->bd_openers) {
                struct module *owner = disk->fops->owner;
@@ -746,7 +746,7 @@ int blkdev_put(struct block_device *bdev)
                bdev->bd_contains = NULL;
        }
        unlock_kernel();
-       up(&bdev->bd_sem);
+       mutex_unlock(&bdev->bd_mutex);
        bdput(bdev);
        return ret;
 }

diff --git a/fs/buffer.c b/fs/buffer.c
index 1d3683d496f8b0dbab6e3251511532c9904b5236..0d6ca7bac6c8b9af3e77bd8cd5dc953992592419 100644 (file)
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -201,7 +201,7 @@ int fsync_bdev(struct block_device *bdev)
  * freeze_bdev  --  lock a filesystem and force it into a consistent state
  * @bdev:      blockdevice to lock
  *
- * This takes the block device bd_mount_sem to make sure no new mounts
+ * This takes the block device bd_mount_mutex to make sure no new mounts
  * happen on bdev until thaw_bdev() is called.
  * If a superblock is found on this device, we take the s_umount semaphore
  * on it to make sure nobody unmounts until the snapshot creation is done.
@@ -210,7 +210,7 @@ struct super_block *freeze_bdev(struct block_device *bdev)
 {
        struct super_block *sb;
 
-       down(&bdev->bd_mount_sem);
+       mutex_lock(&bdev->bd_mount_mutex);
        sb = get_super(bdev);
        if (sb && !(sb->s_flags & MS_RDONLY)) {
                sb->s_frozen = SB_FREEZE_WRITE;
@@ -264,7 +264,7 @@ void thaw_bdev(struct block_device *bdev, struct super_block *sb)
                drop_super(sb);
        }
 
-       up(&bdev->bd_mount_sem);
+       mutex_unlock(&bdev->bd_mount_mutex);
 }
 EXPORT_SYMBOL(thaw_bdev);
 

diff --git a/fs/super.c b/fs/super.c
index e20b5580afd5791818215c6bf1b3b0c6b7eb2559..8f9c9b3af70cecc89ba37df7865688be7e9f4839 100644 (file)
--- a/fs/super.c
+++ b/fs/super.c
@@ -693,9 +693,9 @@ struct super_block *get_sb_bdev(struct file_system_type *fs_type,
         * will protect the lockfs code from trying to start a snapshot
         * while we are mounting
         */
-       down(&bdev->bd_mount_sem);
+       mutex_lock(&bdev->bd_mount_mutex);
        s = sget(fs_type, test_bdev_super, set_bdev_super, bdev);
-       up(&bdev->bd_mount_sem);
+       mutex_unlock(&bdev->bd_mount_mutex);
        if (IS_ERR(s))
                goto out;
 

diff --git a/include/linux/fs.h b/include/linux/fs.h
index 128d0082522c4ad067bbffd4199b879ba79c977b..009ac96053fe40b0cd13b2122036a9d0b1206f64 100644 (file)
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -397,8 +397,8 @@ struct block_device {
        dev_t                   bd_dev;  /* not a kdev_t - it's a search key */
        struct inode *          bd_inode;       /* will die */
        int                     bd_openers;
-       struct semaphore        bd_sem; /* open/close mutex */
-       struct semaphore        bd_mount_sem;   /* mount mutex */
+       struct mutex            bd_mutex;       /* open/close mutex */
+       struct mutex            bd_mount_mutex; /* mount mutex */
        struct list_head        bd_inodes;
        void *                  bd_holder;
        int                     bd_holders;