Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 1e8b3332 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

blockdev: remove bd_block_size_semaphore again 



This reverts the block-device direct access code to the previous
unlocked code, now that fs/buffer.c no longer needs external locking.

With this, fs/block_dev.c is back to the original version, apart from a
whitespace cleanup that I didn't want to revert.

Signed-off-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>
parent 45bce8f3

drivers/char/raw.c

+1 −1
Original line number Diff line number Diff line
@@ -285,7 +285,7 @@ static long raw_ctl_compat_ioctl(struct file *file, unsigned int cmd, 


static const struct file_operations raw_fops = {

	.read		= do_sync_read,

	.aio_read	= blkdev_aio_read,

	.aio_read	= generic_file_aio_read,

	.write		= do_sync_write,

	.aio_write	= blkdev_aio_write,

	.fsync		= blkdev_fsync,

fs/block_dev.c

+4 −101
Original line number Diff line number Diff line
@@ -116,8 +116,6 @@ EXPORT_SYMBOL(invalidate_bdev); 


int set_blocksize(struct block_device *bdev, int size)

{

	struct address_space *mapping;



	/* Size must be a power of two, and between 512 and PAGE_SIZE */

	if (size > PAGE_SIZE || size < 512 || !is_power_of_2(size))

		return -EINVAL;
@@ -126,19 +124,6 @@ int set_blocksize(struct block_device *bdev, int size) 
	if (size < bdev_logical_block_size(bdev))

		return -EINVAL;



	/* Prevent starting I/O or mapping the device */

	percpu_down_write(&bdev->bd_block_size_semaphore);



	/* Check that the block device is not memory mapped */

	mapping = bdev->bd_inode->i_mapping;

	mutex_lock(&mapping->i_mmap_mutex);

	if (mapping_mapped(mapping)) {

		mutex_unlock(&mapping->i_mmap_mutex);

		percpu_up_write(&bdev->bd_block_size_semaphore);

		return -EBUSY;

	}

	mutex_unlock(&mapping->i_mmap_mutex);



	/* Don't change the size if it is same as current */

	if (bdev->bd_block_size != size) {

		sync_blockdev(bdev);
@@ -146,9 +131,6 @@ int set_blocksize(struct block_device *bdev, int size) 
		bdev->bd_inode->i_blkbits = blksize_bits(size);

		kill_bdev(bdev);

	}



	percpu_up_write(&bdev->bd_block_size_semaphore);



	return 0;

}
@@ -459,12 +441,6 @@ static struct inode *bdev_alloc_inode(struct super_block *sb) 
	struct bdev_inode *ei = kmem_cache_alloc(bdev_cachep, GFP_KERNEL);

	if (!ei)

		return NULL;



	if (unlikely(percpu_init_rwsem(&ei->bdev.bd_block_size_semaphore))) {

		kmem_cache_free(bdev_cachep, ei);

		return NULL;

	}



	return &ei->vfs_inode;

}
@@ -473,8 +449,6 @@ static void bdev_i_callback(struct rcu_head *head) 
	struct inode *inode = container_of(head, struct inode, i_rcu);

	struct bdev_inode *bdi = BDEV_I(inode);



	percpu_free_rwsem(&bdi->bdev.bd_block_size_semaphore);



	kmem_cache_free(bdev_cachep, bdi);

}
@@ -1593,22 +1567,6 @@ static long block_ioctl(struct file *file, unsigned cmd, unsigned long arg) 
	return blkdev_ioctl(bdev, mode, cmd, arg);

}



ssize_t blkdev_aio_read(struct kiocb *iocb, const struct iovec *iov,

			unsigned long nr_segs, loff_t pos)

{

	ssize_t ret;

	struct block_device *bdev = I_BDEV(iocb->ki_filp->f_mapping->host);



	percpu_down_read(&bdev->bd_block_size_semaphore);



	ret = generic_file_aio_read(iocb, iov, nr_segs, pos);



	percpu_up_read(&bdev->bd_block_size_semaphore);



	return ret;

}

EXPORT_SYMBOL_GPL(blkdev_aio_read);



/*

 * Write data to the block device.  Only intended for the block device itself

 * and the raw driver which basically is a fake block device.
@@ -1620,16 +1578,12 @@ ssize_t blkdev_aio_write(struct kiocb *iocb, const struct iovec *iov, 
			 unsigned long nr_segs, loff_t pos)

{

	struct file *file = iocb->ki_filp;

	struct block_device *bdev = I_BDEV(file->f_mapping->host);

	struct blk_plug plug;

	ssize_t ret;



	BUG_ON(iocb->ki_pos != pos);



	blk_start_plug(&plug);



	percpu_down_read(&bdev->bd_block_size_semaphore);



	ret = __generic_file_aio_write(iocb, iov, nr_segs, &iocb->ki_pos);

	if (ret > 0 || ret == -EIOCBQUEUED) {

		ssize_t err;
@@ -1638,62 +1592,11 @@ ssize_t blkdev_aio_write(struct kiocb *iocb, const struct iovec *iov, 
		if (err < 0 && ret > 0)

			ret = err;

	}



	percpu_up_read(&bdev->bd_block_size_semaphore);



	blk_finish_plug(&plug);



	return ret;

}

EXPORT_SYMBOL_GPL(blkdev_aio_write);



static int blkdev_mmap(struct file *file, struct vm_area_struct *vma)

{

	int ret;

	struct block_device *bdev = I_BDEV(file->f_mapping->host);



	percpu_down_read(&bdev->bd_block_size_semaphore);



	ret = generic_file_mmap(file, vma);



	percpu_up_read(&bdev->bd_block_size_semaphore);



	return ret;

}



static ssize_t blkdev_splice_read(struct file *file, loff_t *ppos,

				  struct pipe_inode_info *pipe, size_t len,

				  unsigned int flags)

{

	ssize_t ret;

	struct block_device *bdev = I_BDEV(file->f_mapping->host);



	percpu_down_read(&bdev->bd_block_size_semaphore);



	ret = generic_file_splice_read(file, ppos, pipe, len, flags);



	percpu_up_read(&bdev->bd_block_size_semaphore);



	return ret;

}



static ssize_t blkdev_splice_write(struct pipe_inode_info *pipe,

				   struct file *file, loff_t *ppos, size_t len,

				   unsigned int flags)

{

	ssize_t ret;

	struct block_device *bdev = I_BDEV(file->f_mapping->host);



	percpu_down_read(&bdev->bd_block_size_semaphore);



	ret = generic_file_splice_write(pipe, file, ppos, len, flags);



	percpu_up_read(&bdev->bd_block_size_semaphore);



	return ret;

}





/*

 * Try to release a page associated with block device when the system

 * is under memory pressure.
@@ -1724,16 +1627,16 @@ const struct file_operations def_blk_fops = { 
	.llseek		= block_llseek,

	.read		= do_sync_read,

	.write		= do_sync_write,

  	.aio_read	= blkdev_aio_read,

	.aio_read	= generic_file_aio_read,

	.aio_write	= blkdev_aio_write,

	.mmap		= blkdev_mmap,

	.mmap		= generic_file_mmap,

	.fsync		= blkdev_fsync,

	.unlocked_ioctl	= block_ioctl,

#ifdef CONFIG_COMPAT

	.compat_ioctl	= compat_blkdev_ioctl,

#endif

	.splice_read	= blkdev_splice_read,

	.splice_write	= blkdev_splice_write,

	.splice_read	= generic_file_splice_read,

	.splice_write	= generic_file_splice_write,

};



int ioctl_by_bdev(struct block_device *bdev, unsigned cmd, unsigned long arg)

include/linux/fs.h

+0 −4
Original line number Diff line number Diff line
@@ -462,8 +462,6 @@ struct block_device { 
	int			bd_fsfreeze_count;

	/* Mutex for freeze */

	struct mutex		bd_fsfreeze_mutex;

	/* A semaphore that prevents I/O while block size is being changed */

	struct percpu_rw_semaphore	bd_block_size_semaphore;

};



/*
@@ -2379,8 +2377,6 @@ extern int generic_segment_checks(const struct iovec *iov, 
		unsigned long *nr_segs, size_t *count, int access_flags);



/* fs/block_dev.c */

extern ssize_t blkdev_aio_read(struct kiocb *iocb, const struct iovec *iov,

			       unsigned long nr_segs, loff_t pos);

extern ssize_t blkdev_aio_write(struct kiocb *iocb, const struct iovec *iov,

				unsigned long nr_segs, loff_t pos);

extern int blkdev_fsync(struct file *filp, loff_t start, loff_t end,