[linux.git] / block / fops.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (C) 1991, 1992  Linus Torvalds
 * Copyright (C) 2001  Andrea Arcangeli <[email protected]> SuSE
 * Copyright (C) 2016 - 2020 Christoph Hellwig
 */
#include <linux/init.h>
#include <linux/mm.h>
#include <linux/blkdev.h>
#include <linux/buffer_head.h>
#include <linux/mpage.h>
#include <linux/uio.h>
#include <linux/namei.h>
#include <linux/task_io_accounting_ops.h>
#include <linux/falloc.h>
#include <linux/suspend.h>
#include <linux/fs.h>
#include "blk.h"

static inline struct inode *bdev_file_inode(struct file *file)
{
	return file->f_mapping->host;
}

static int blkdev_get_block(struct inode *inode, sector_t iblock,
		struct buffer_head *bh, int create)
{
	bh->b_bdev = I_BDEV(inode);
	bh->b_blocknr = iblock;
	set_buffer_mapped(bh);
	return 0;
}

static unsigned int dio_bio_write_op(struct kiocb *iocb)
{
	unsigned int op = REQ_OP_WRITE | REQ_SYNC | REQ_IDLE;

	/* avoid the need for a I/O completion work item */
	if (iocb->ki_flags & IOCB_DSYNC)
		op |= REQ_FUA;
	return op;
}

#define DIO_INLINE_BIO_VECS 4

static void blkdev_bio_end_io_simple(struct bio *bio)
{
	struct task_struct *waiter = bio->bi_private;

	WRITE_ONCE(bio->bi_private, NULL);
	blk_wake_io_task(waiter);
}

static ssize_t __blkdev_direct_IO_simple(struct kiocb *iocb,
		struct iov_iter *iter, unsigned int nr_pages)
{
	struct block_device *bdev = iocb->ki_filp->private_data;
	struct bio_vec inline_vecs[DIO_INLINE_BIO_VECS], *vecs;
	loff_t pos = iocb->ki_pos;
	bool should_dirty = false;
	struct bio bio;
	ssize_t ret;

	if ((pos | iov_iter_alignment(iter)) &
	    (bdev_logical_block_size(bdev) - 1))
		return -EINVAL;

	if (nr_pages <= DIO_INLINE_BIO_VECS)
		vecs = inline_vecs;
	else {
		vecs = kmalloc_array(nr_pages, sizeof(struct bio_vec),
				     GFP_KERNEL);
		if (!vecs)
			return -ENOMEM;
	}

	bio_init(&bio, vecs, nr_pages);
	bio_set_dev(&bio, bdev);
	bio.bi_iter.bi_sector = pos >> SECTOR_SHIFT;
	bio.bi_write_hint = iocb->ki_hint;
	bio.bi_private = current;
	bio.bi_end_io = blkdev_bio_end_io_simple;
	bio.bi_ioprio = iocb->ki_ioprio;

	ret = bio_iov_iter_get_pages(&bio, iter);
	if (unlikely(ret))
		goto out;
	ret = bio.bi_iter.bi_size;

	if (iov_iter_rw(iter) == READ) {
		bio.bi_opf = REQ_OP_READ;
		if (iter_is_iovec(iter))
			should_dirty = true;
	} else {
		bio.bi_opf = dio_bio_write_op(iocb);
		task_io_account_write(ret);
	}
	if (iocb->ki_flags & IOCB_NOWAIT)
		bio.bi_opf |= REQ_NOWAIT;
	if (iocb->ki_flags & IOCB_HIPRI)
		bio_set_polled(&bio, iocb);

	submit_bio(&bio);
	for (;;) {
		set_current_state(TASK_UNINTERRUPTIBLE);
		if (!READ_ONCE(bio.bi_private))
			break;
		if (!(iocb->ki_flags & IOCB_HIPRI) || !bio_poll(&bio, NULL, 0))
			blk_io_schedule();
	}
	__set_current_state(TASK_RUNNING);

	bio_release_pages(&bio, should_dirty);
	if (unlikely(bio.bi_status))
		ret = blk_status_to_errno(bio.bi_status);

out:
	if (vecs != inline_vecs)
		kfree(vecs);

	bio_uninit(&bio);

	return ret;
}

enum {
	DIO_SHOULD_DIRTY	= 1,
	DIO_IS_SYNC		= 2,
};

struct blkdev_dio {
	union {
		struct kiocb		*iocb;
		struct task_struct	*waiter;
	};
	size_t			size;
	atomic_t		ref;
	unsigned int		flags;
	struct bio		bio ____cacheline_aligned_in_smp;
};

static struct bio_set blkdev_dio_pool;

static void blkdev_bio_end_io(struct bio *bio)
{
	struct blkdev_dio *dio = bio->bi_private;
	bool should_dirty = dio->flags & DIO_SHOULD_DIRTY;

	if (bio->bi_status && !dio->bio.bi_status)
		dio->bio.bi_status = bio->bi_status;

	if (atomic_dec_and_test(&dio->ref)) {
		if (!(dio->flags & DIO_IS_SYNC)) {
			struct kiocb *iocb = dio->iocb;
			ssize_t ret;

			WRITE_ONCE(iocb->private, NULL);

			if (likely(!dio->bio.bi_status)) {
				ret = dio->size;
				iocb->ki_pos += ret;
			} else {
				ret = blk_status_to_errno(dio->bio.bi_status);
			}

			dio->iocb->ki_complete(iocb, ret);
			bio_put(&dio->bio);
		} else {
			struct task_struct *waiter = dio->waiter;

			WRITE_ONCE(dio->waiter, NULL);
			blk_wake_io_task(waiter);
		}
	}

	if (should_dirty) {
		bio_check_pages_dirty(bio);
	} else {
		bio_release_pages(bio, false);
		bio_put(bio);
	}
}

static ssize_t __blkdev_direct_IO(struct kiocb *iocb, struct iov_iter *iter,
		unsigned int nr_pages)
{
	struct block_device *bdev = iocb->ki_filp->private_data;
	struct blk_plug plug;
	struct blkdev_dio *dio;
	struct bio *bio;
	bool is_read = (iov_iter_rw(iter) == READ), is_sync;
	loff_t pos = iocb->ki_pos;
	int ret = 0;

	if ((pos | iov_iter_alignment(iter)) &
	    (bdev_logical_block_size(bdev) - 1))
		return -EINVAL;

	bio = bio_alloc_kiocb(iocb, nr_pages, &blkdev_dio_pool);

	dio = container_of(bio, struct blkdev_dio, bio);
	atomic_set(&dio->ref, 1);
	/*
	 * Grab an extra reference to ensure the dio structure which is embedded
	 * into the first bio stays around.
	 */
	bio_get(bio);

	is_sync = is_sync_kiocb(iocb);
	if (is_sync) {
		dio->flags = DIO_IS_SYNC;
		dio->waiter = current;
	} else {
		dio->flags = 0;
		dio->iocb = iocb;
	}

	dio->size = 0;
	if (is_read && iter_is_iovec(iter))
		dio->flags |= DIO_SHOULD_DIRTY;

	blk_start_plug(&plug);

	for (;;) {
		bio_set_dev(bio, bdev);
		bio->bi_iter.bi_sector = pos >> SECTOR_SHIFT;
		bio->bi_write_hint = iocb->ki_hint;
		bio->bi_private = dio;
		bio->bi_end_io = blkdev_bio_end_io;
		bio->bi_ioprio = iocb->ki_ioprio;

		ret = bio_iov_iter_get_pages(bio, iter);
		if (unlikely(ret)) {
			bio->bi_status = BLK_STS_IOERR;
			bio_endio(bio);
			break;
		}

		if (is_read) {
			bio->bi_opf = REQ_OP_READ;
			if (dio->flags & DIO_SHOULD_DIRTY)
				bio_set_pages_dirty(bio);
		} else {
			bio->bi_opf = dio_bio_write_op(iocb);
			task_io_account_write(bio->bi_iter.bi_size);
		}
		if (iocb->ki_flags & IOCB_NOWAIT)
			bio->bi_opf |= REQ_NOWAIT;

		dio->size += bio->bi_iter.bi_size;
		pos += bio->bi_iter.bi_size;

		nr_pages = bio_iov_vecs_to_alloc(iter, BIO_MAX_VECS);
		if (!nr_pages) {
			submit_bio(bio);
			break;
		}
		atomic_inc(&dio->ref);
		submit_bio(bio);
		bio = bio_alloc(GFP_KERNEL, nr_pages);
	}

	blk_finish_plug(&plug);

	if (!is_sync)
		return -EIOCBQUEUED;

	for (;;) {
		set_current_state(TASK_UNINTERRUPTIBLE);
		if (!READ_ONCE(dio->waiter))
			break;
		blk_io_schedule();
	}
	__set_current_state(TASK_RUNNING);

	if (!ret)
		ret = blk_status_to_errno(dio->bio.bi_status);
	if (likely(!ret))
		ret = dio->size;

	bio_put(&dio->bio);
	return ret;
}

static void blkdev_bio_end_io_async(struct bio *bio)
{
	struct blkdev_dio *dio = container_of(bio, struct blkdev_dio, bio);
	struct kiocb *iocb = dio->iocb;
	ssize_t ret;

	if (likely(!bio->bi_status)) {
		ret = dio->size;
		iocb->ki_pos += ret;
	} else {
		ret = blk_status_to_errno(bio->bi_status);
	}

	iocb->ki_complete(iocb, ret);

	if (dio->flags & DIO_SHOULD_DIRTY) {
		bio_check_pages_dirty(bio);
	} else {
		bio_release_pages(bio, false);
		bio_put(bio);
	}
}

static ssize_t __blkdev_direct_IO_async(struct kiocb *iocb,
					struct iov_iter *iter,
					unsigned int nr_pages)
{
	struct block_device *bdev = iocb->ki_filp->private_data;
	struct blkdev_dio *dio;
	struct bio *bio;
	loff_t pos = iocb->ki_pos;
	int ret = 0;

	if ((pos | iov_iter_alignment(iter)) &
	    (bdev_logical_block_size(bdev) - 1))
		return -EINVAL;

	bio = bio_alloc_kiocb(iocb, nr_pages, &blkdev_dio_pool);
	dio = container_of(bio, struct blkdev_dio, bio);
	dio->flags = 0;
	dio->iocb = iocb;
	bio_set_dev(bio, bdev);
	bio->bi_iter.bi_sector = pos >> SECTOR_SHIFT;
	bio->bi_write_hint = iocb->ki_hint;
	bio->bi_end_io = blkdev_bio_end_io_async;
	bio->bi_ioprio = iocb->ki_ioprio;

	if (iov_iter_is_bvec(iter)) {
		/*
		 * Users don't rely on the iterator being in any particular
		 * state for async I/O returning -EIOCBQUEUED, hence we can
		 * avoid expensive iov_iter_advance(). Bypass
		 * bio_iov_iter_get_pages() and set the bvec directly.
		 */
		bio_iov_bvec_set(bio, iter);
	} else {
		ret = bio_iov_iter_get_pages(bio, iter);
		if (unlikely(ret)) {
			bio->bi_status = BLK_STS_IOERR;
			bio_endio(bio);
			return ret;
		}
	}
	dio->size = bio->bi_iter.bi_size;

	if (iov_iter_rw(iter) == READ) {
		bio->bi_opf = REQ_OP_READ;
		if (iter_is_iovec(iter)) {
			dio->flags |= DIO_SHOULD_DIRTY;
			bio_set_pages_dirty(bio);
		}
	} else {
		bio->bi_opf = dio_bio_write_op(iocb);
		task_io_account_write(bio->bi_iter.bi_size);
	}

	if (iocb->ki_flags & IOCB_HIPRI) {
		bio->bi_opf |= REQ_POLLED | REQ_NOWAIT;
		submit_bio(bio);
		WRITE_ONCE(iocb->private, bio);
	} else {
		if (iocb->ki_flags & IOCB_NOWAIT)
			bio->bi_opf |= REQ_NOWAIT;
		submit_bio(bio);
	}
	return -EIOCBQUEUED;
}

static ssize_t blkdev_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
{
	unsigned int nr_pages;

	if (!iov_iter_count(iter))
		return 0;

	nr_pages = bio_iov_vecs_to_alloc(iter, BIO_MAX_VECS + 1);
	if (likely(nr_pages <= BIO_MAX_VECS)) {
		if (is_sync_kiocb(iocb))
			return __blkdev_direct_IO_simple(iocb, iter, nr_pages);
		return __blkdev_direct_IO_async(iocb, iter, nr_pages);
	}
	return __blkdev_direct_IO(iocb, iter, bio_max_segs(nr_pages));
}

static int blkdev_writepage(struct page *page, struct writeback_control *wbc)
{
	return block_write_full_page(page, blkdev_get_block, wbc);
}

static int blkdev_readpage(struct file * file, struct page * page)
{
	return block_read_full_page(page, blkdev_get_block);
}

static void blkdev_readahead(struct readahead_control *rac)
{
	mpage_readahead(rac, blkdev_get_block);
}

static int blkdev_write_begin(struct file *file, struct address_space *mapping,
		loff_t pos, unsigned len, unsigned flags, struct page **pagep,
		void **fsdata)
{
	return block_write_begin(mapping, pos, len, flags, pagep,
				 blkdev_get_block);
}

static int blkdev_write_end(struct file *file, struct address_space *mapping,
		loff_t pos, unsigned len, unsigned copied, struct page *page,
		void *fsdata)
{
	int ret;
	ret = block_write_end(file, mapping, pos, len, copied, page, fsdata);

	unlock_page(page);
	put_page(page);

	return ret;
}

static int blkdev_writepages(struct address_space *mapping,
			     struct writeback_control *wbc)
{
	return generic_writepages(mapping, wbc);
}

const struct address_space_operations def_blk_aops = {
	.set_page_dirty	= __set_page_dirty_buffers,
	.readpage	= blkdev_readpage,
	.readahead	= blkdev_readahead,
	.writepage	= blkdev_writepage,
	.write_begin	= blkdev_write_begin,
	.write_end	= blkdev_write_end,
	.writepages	= blkdev_writepages,
	.direct_IO	= blkdev_direct_IO,
	.migratepage	= buffer_migrate_page_norefs,
	.is_dirty_writeback = buffer_check_dirty_writeback,
};

/*
 * for a block special file file_inode(file)->i_size is zero
 * so we compute the size by hand (just as in block_read/write above)
 */
static loff_t blkdev_llseek(struct file *file, loff_t offset, int whence)
{
	struct inode *bd_inode = bdev_file_inode(file);
	loff_t retval;

	inode_lock(bd_inode);
	retval = fixed_size_llseek(file, offset, whence, i_size_read(bd_inode));
	inode_unlock(bd_inode);
	return retval;
}

static int blkdev_fsync(struct file *filp, loff_t start, loff_t end,
		int datasync)
{
	struct block_device *bdev = filp->private_data;
	int error;

	error = file_write_and_wait_range(filp, start, end);
	if (error)
		return error;

	/*
	 * There is no need to serialise calls to blkdev_issue_flush with
	 * i_mutex and doing so causes performance issues with concurrent
	 * O_SYNC writers to a block device.
	 */
	error = blkdev_issue_flush(bdev);
	if (error == -EOPNOTSUPP)
		error = 0;

	return error;
}

static int blkdev_open(struct inode *inode, struct file *filp)
{
	struct block_device *bdev;

	/*
	 * Preserve backwards compatibility and allow large file access
	 * even if userspace doesn't ask for it explicitly. Some mkfs
	 * binary needs it. We might want to drop this workaround
	 * during an unstable branch.
	 */
	filp->f_flags |= O_LARGEFILE;
	filp->f_mode |= FMODE_NOWAIT | FMODE_BUF_RASYNC;

	if (filp->f_flags & O_NDELAY)
		filp->f_mode |= FMODE_NDELAY;
	if (filp->f_flags & O_EXCL)
		filp->f_mode |= FMODE_EXCL;
	if ((filp->f_flags & O_ACCMODE) == 3)
		filp->f_mode |= FMODE_WRITE_IOCTL;

	bdev = blkdev_get_by_dev(inode->i_rdev, filp->f_mode, filp);
	if (IS_ERR(bdev))
		return PTR_ERR(bdev);

	filp->private_data = bdev;
	filp->f_mapping = bdev->bd_inode->i_mapping;
	filp->f_wb_err = filemap_sample_wb_err(filp->f_mapping);
	return 0;
}

static int blkdev_close(struct inode *inode, struct file *filp)
{
	struct block_device *bdev = filp->private_data;

	blkdev_put(bdev, filp->f_mode);
	return 0;
}

/*
 * Write data to the block device.  Only intended for the block device itself
 * and the raw driver which basically is a fake block device.
 *
 * Does not take i_mutex for the write and thus is not for general purpose
 * use.
 */
static ssize_t blkdev_write_iter(struct kiocb *iocb, struct iov_iter *from)
{
	struct block_device *bdev = iocb->ki_filp->private_data;
	struct inode *bd_inode = bdev->bd_inode;
	loff_t size = bdev_nr_bytes(bdev);
	struct blk_plug plug;
	size_t shorted = 0;
	ssize_t ret;

	if (bdev_read_only(bdev))
		return -EPERM;

	if (IS_SWAPFILE(bd_inode) && !is_hibernate_resume_dev(bd_inode->i_rdev))
		return -ETXTBSY;

	if (!iov_iter_count(from))
		return 0;

	if (iocb->ki_pos >= size)
		return -ENOSPC;

	if ((iocb->ki_flags & (IOCB_NOWAIT | IOCB_DIRECT)) == IOCB_NOWAIT)
		return -EOPNOTSUPP;

	size -= iocb->ki_pos;
	if (iov_iter_count(from) > size) {
		shorted = iov_iter_count(from) - size;
		iov_iter_truncate(from, size);
	}

	blk_start_plug(&plug);
	ret = __generic_file_write_iter(iocb, from);
	if (ret > 0)
		ret = generic_write_sync(iocb, ret);
	iov_iter_reexpand(from, iov_iter_count(from) + shorted);
	blk_finish_plug(&plug);
	return ret;
}

static ssize_t blkdev_read_iter(struct kiocb *iocb, struct iov_iter *to)
{
	struct block_device *bdev = iocb->ki_filp->private_data;
	loff_t size = bdev_nr_bytes(bdev);
	size_t count = iov_iter_count(to);
	loff_t pos = iocb->ki_pos;
	size_t shorted = 0;
	ssize_t ret = 0;

	if (unlikely(pos + count > size)) {
		if (pos >= size)
			return 0;
		size -= pos;
		if (count > size) {
			shorted = count - size;
			iov_iter_truncate(to, size);
		}
	}

	if (iocb->ki_flags & IOCB_DIRECT) {
		struct address_space *mapping = iocb->ki_filp->f_mapping;

		if (iocb->ki_flags & IOCB_NOWAIT) {
			if (filemap_range_needs_writeback(mapping, iocb->ki_pos,
						iocb->ki_pos + count - 1))
				return -EAGAIN;
		} else {
			ret = filemap_write_and_wait_range(mapping,
						iocb->ki_pos,
					        iocb->ki_pos + count - 1);
			if (ret < 0)
				return ret;
		}

		file_accessed(iocb->ki_filp);

		ret = blkdev_direct_IO(iocb, to);
		if (ret >= 0) {
			iocb->ki_pos += ret;
			count -= ret;
		}
		if (ret < 0 || !count)
			return ret;
	}

	ret = filemap_read(iocb, to, ret);

	if (unlikely(shorted))
		iov_iter_reexpand(to, iov_iter_count(to) + shorted);
	return ret;
}

#define	BLKDEV_FALLOC_FL_SUPPORTED					\
		(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE |		\
		 FALLOC_FL_ZERO_RANGE | FALLOC_FL_NO_HIDE_STALE)

static long blkdev_fallocate(struct file *file, int mode, loff_t start,
			     loff_t len)
{
	struct inode *inode = bdev_file_inode(file);
	struct block_device *bdev = I_BDEV(inode);
	loff_t end = start + len - 1;
	loff_t isize;
	int error;

	/* Fail if we don't recognize the flags. */
	if (mode & ~BLKDEV_FALLOC_FL_SUPPORTED)
		return -EOPNOTSUPP;

	/* Don't go off the end of the device. */
	isize = bdev_nr_bytes(bdev);
	if (start >= isize)
		return -EINVAL;
	if (end >= isize) {
		if (mode & FALLOC_FL_KEEP_SIZE) {
			len = isize - start;
			end = start + len - 1;
		} else
			return -EINVAL;
	}

	/*
	 * Don't allow IO that isn't aligned to logical block size.
	 */
	if ((start | len) & (bdev_logical_block_size(bdev) - 1))
		return -EINVAL;

	filemap_invalidate_lock(inode->i_mapping);

	/* Invalidate the page cache, including dirty pages. */
	error = truncate_bdev_range(bdev, file->f_mode, start, end);
	if (error)
		goto fail;

	switch (mode) {
	case FALLOC_FL_ZERO_RANGE:
	case FALLOC_FL_ZERO_RANGE | FALLOC_FL_KEEP_SIZE:
		error = blkdev_issue_zeroout(bdev, start >> SECTOR_SHIFT,
					     len >> SECTOR_SHIFT, GFP_KERNEL,
					     BLKDEV_ZERO_NOUNMAP);
		break;
	case FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE:
		error = blkdev_issue_zeroout(bdev, start >> SECTOR_SHIFT,
					     len >> SECTOR_SHIFT, GFP_KERNEL,
					     BLKDEV_ZERO_NOFALLBACK);
		break;
	case FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE | FALLOC_FL_NO_HIDE_STALE:
		error = blkdev_issue_discard(bdev, start >> SECTOR_SHIFT,
					     len >> SECTOR_SHIFT, GFP_KERNEL, 0);
		break;
	default:
		error = -EOPNOTSUPP;
	}

 fail:
	filemap_invalidate_unlock(inode->i_mapping);
	return error;
}

const struct file_operations def_blk_fops = {
	.open		= blkdev_open,
	.release	= blkdev_close,
	.llseek		= blkdev_llseek,
	.read_iter	= blkdev_read_iter,
	.write_iter	= blkdev_write_iter,
	.iopoll		= iocb_bio_iopoll,
	.mmap		= generic_file_mmap,
	.fsync		= blkdev_fsync,
	.unlocked_ioctl	= blkdev_ioctl,
#ifdef CONFIG_COMPAT
	.compat_ioctl	= compat_blkdev_ioctl,
#endif
	.splice_read	= generic_file_splice_read,
	.splice_write	= iter_file_splice_write,
	.fallocate	= blkdev_fallocate,
};

static __init int blkdev_init(void)
{
	return bioset_init(&blkdev_dio_pool, 4,
				offsetof(struct blkdev_dio, bio),
				BIOSET_NEED_BVECS|BIOSET_PERCPU_CACHE);
}
module_init(blkdev_init);
Commit	Line	Data
cd82cca7 CH	1	// SPDX-License-Identifier: GPL-2.0-only
	2	/*
	3	* Copyright (C) 1991, 1992 Linus Torvalds
	4	* Copyright (C) 2001 Andrea Arcangeli <[email protected]> SuSE
	5	* Copyright (C) 2016 - 2020 Christoph Hellwig
	6	*/
	7	#include <linux/init.h>
	8	#include <linux/mm.h>
	9	#include <linux/blkdev.h>
	10	#include <linux/buffer_head.h>
	11	#include <linux/mpage.h>
	12	#include <linux/uio.h>
	13	#include <linux/namei.h>
	14	#include <linux/task_io_accounting_ops.h>
	15	#include <linux/falloc.h>
	16	#include <linux/suspend.h>
f278eb3d	17	#include <linux/fs.h>
cd82cca7 CH	18	#include "blk.h"
cd82cca7 CH	19
fac7c6d5	20	static inline struct inode bdev_file_inode(struct file file)
cd82cca7 CH	21	{
	22	return file->f_mapping->host;
	23	}
	24
	25	static int blkdev_get_block(struct inode *inode, sector_t iblock,
	26	struct buffer_head *bh, int create)
	27	{
	28	bh->b_bdev = I_BDEV(inode);
	29	bh->b_blocknr = iblock;
	30	set_buffer_mapped(bh);
	31	return 0;
	32	}
	33
	34	static unsigned int dio_bio_write_op(struct kiocb *iocb)
	35	{
	36	unsigned int op = REQ_OP_WRITE \| REQ_SYNC \| REQ_IDLE;
	37
	38	/* avoid the need for a I/O completion work item */
	39	if (iocb->ki_flags & IOCB_DSYNC)
	40	op \|= REQ_FUA;
	41	return op;
	42	}
	43
	44	#define DIO_INLINE_BIO_VECS 4
	45
	46	static void blkdev_bio_end_io_simple(struct bio *bio)
	47	{
	48	struct task_struct *waiter = bio->bi_private;
	49
	50	WRITE_ONCE(bio->bi_private, NULL);
	51	blk_wake_io_task(waiter);
	52	}
	53
	54	static ssize_t __blkdev_direct_IO_simple(struct kiocb *iocb,
	55	struct iov_iter *iter, unsigned int nr_pages)
	56	{
fac7c6d5	57	struct block_device *bdev = iocb->ki_filp->private_data;
cd82cca7 CH	58	struct bio_vec inline_vecs[DIO_INLINE_BIO_VECS], *vecs;
	59	loff_t pos = iocb->ki_pos;
	60	bool should_dirty = false;
	61	struct bio bio;
	62	ssize_t ret;
cd82cca7 CH	63
	64	if ((pos \| iov_iter_alignment(iter)) &
	65	(bdev_logical_block_size(bdev) - 1))
	66	return -EINVAL;
	67
	68	if (nr_pages <= DIO_INLINE_BIO_VECS)
	69	vecs = inline_vecs;
	70	else {
	71	vecs = kmalloc_array(nr_pages, sizeof(struct bio_vec),
	72	GFP_KERNEL);
	73	if (!vecs)
	74	return -ENOMEM;
	75	}
	76
	77	bio_init(&bio, vecs, nr_pages);
	78	bio_set_dev(&bio, bdev);
6549a874	79	bio.bi_iter.bi_sector = pos >> SECTOR_SHIFT;
cd82cca7 CH	80	bio.bi_write_hint = iocb->ki_hint;
	81	bio.bi_private = current;
	82	bio.bi_end_io = blkdev_bio_end_io_simple;
	83	bio.bi_ioprio = iocb->ki_ioprio;
	84
	85	ret = bio_iov_iter_get_pages(&bio, iter);
	86	if (unlikely(ret))
	87	goto out;
	88	ret = bio.bi_iter.bi_size;
	89
	90	if (iov_iter_rw(iter) == READ) {
	91	bio.bi_opf = REQ_OP_READ;
	92	if (iter_is_iovec(iter))
	93	should_dirty = true;
	94	} else {
	95	bio.bi_opf = dio_bio_write_op(iocb);
	96	task_io_account_write(ret);
	97	}
	98	if (iocb->ki_flags & IOCB_NOWAIT)
	99	bio.bi_opf \|= REQ_NOWAIT;
	100	if (iocb->ki_flags & IOCB_HIPRI)
	101	bio_set_polled(&bio, iocb);
	102
3e08773c	103	submit_bio(&bio);
cd82cca7 CH	104	for (;;) {
	105	set_current_state(TASK_UNINTERRUPTIBLE);
	106	if (!READ_ONCE(bio.bi_private))
	107	break;
5a72e899	108	if (!(iocb->ki_flags & IOCB_HIPRI) \|\| !bio_poll(&bio, NULL, 0))
cd82cca7 CH	109	blk_io_schedule();
	110	}
	111	__set_current_state(TASK_RUNNING);
	112
	113	bio_release_pages(&bio, should_dirty);
	114	if (unlikely(bio.bi_status))
	115	ret = blk_status_to_errno(bio.bi_status);
	116
	117	out:
	118	if (vecs != inline_vecs)
	119	kfree(vecs);
	120
	121	bio_uninit(&bio);
	122
	123	return ret;
	124	}
	125
09ce8744	126	enum {
e71aa913 PB	127	DIO_SHOULD_DIRTY = 1,
e71aa913 PB	128	DIO_IS_SYNC = 2,
09ce8744 JA	129	};
09ce8744 JA	130
cd82cca7 CH	131	struct blkdev_dio {
	132	union {
	133	struct kiocb *iocb;
	134	struct task_struct *waiter;
	135	};
	136	size_t size;
	137	atomic_t ref;
09ce8744	138	unsigned int flags;
6155631a	139	struct bio bio ____cacheline_aligned_in_smp;
cd82cca7 CH	140	};
	141
	142	static struct bio_set blkdev_dio_pool;
	143
cd82cca7 CH	144	static void blkdev_bio_end_io(struct bio *bio)
	145	{
	146	struct blkdev_dio *dio = bio->bi_private;
09ce8744	147	bool should_dirty = dio->flags & DIO_SHOULD_DIRTY;
cd82cca7 CH	148
	149	if (bio->bi_status && !dio->bio.bi_status)
	150	dio->bio.bi_status = bio->bi_status;
	151
e71aa913	152	if (atomic_dec_and_test(&dio->ref)) {
09ce8744	153	if (!(dio->flags & DIO_IS_SYNC)) {
cd82cca7 CH	154	struct kiocb *iocb = dio->iocb;
	155	ssize_t ret;
	156
3e08773c CH	157	WRITE_ONCE(iocb->private, NULL);
3e08773c CH	158
cd82cca7 CH	159	if (likely(!dio->bio.bi_status)) {
	160	ret = dio->size;
	161	iocb->ki_pos += ret;
	162	} else {
	163	ret = blk_status_to_errno(dio->bio.bi_status);
	164	}
	165
6b19b766	166	dio->iocb->ki_complete(iocb, ret);
e71aa913	167	bio_put(&dio->bio);
cd82cca7 CH	168	} else {
	169	struct task_struct *waiter = dio->waiter;
	170
	171	WRITE_ONCE(dio->waiter, NULL);
	172	blk_wake_io_task(waiter);
	173	}
	174	}
	175
	176	if (should_dirty) {
	177	bio_check_pages_dirty(bio);
	178	} else {
	179	bio_release_pages(bio, false);
	180	bio_put(bio);
	181	}
	182	}
	183
	184	static ssize_t __blkdev_direct_IO(struct kiocb iocb, struct iov_iter iter,
	185	unsigned int nr_pages)
	186	{
fac7c6d5	187	struct block_device *bdev = iocb->ki_filp->private_data;
cd82cca7 CH	188	struct blk_plug plug;
	189	struct blkdev_dio *dio;
	190	struct bio *bio;
cd82cca7 CH	191	bool is_read = (iov_iter_rw(iter) == READ), is_sync;
cd82cca7 CH	192	loff_t pos = iocb->ki_pos;
cd82cca7 CH	193	int ret = 0;
	194
	195	if ((pos \| iov_iter_alignment(iter)) &
	196	(bdev_logical_block_size(bdev) - 1))
	197	return -EINVAL;
	198
	199	bio = bio_alloc_kiocb(iocb, nr_pages, &blkdev_dio_pool);
	200
	201	dio = container_of(bio, struct blkdev_dio, bio);
e71aa913 PB	202	atomic_set(&dio->ref, 1);
	203	/*
	204	* Grab an extra reference to ensure the dio structure which is embedded
	205	* into the first bio stays around.
	206	*/
	207	bio_get(bio);
	208
09ce8744 JA	209	is_sync = is_sync_kiocb(iocb);
	210	if (is_sync) {
	211	dio->flags = DIO_IS_SYNC;
cd82cca7	212	dio->waiter = current;
cd82cca7	213	} else {
09ce8744	214	dio->flags = 0;
cd82cca7 CH	215	dio->iocb = iocb;
	216	}
	217
	218	dio->size = 0;
09ce8744 JA	219	if (is_read && iter_is_iovec(iter))
09ce8744 JA	220	dio->flags \|= DIO_SHOULD_DIRTY;
cd82cca7	221
25d207dc	222	blk_start_plug(&plug);
cd82cca7 CH	223
	224	for (;;) {
	225	bio_set_dev(bio, bdev);
6549a874	226	bio->bi_iter.bi_sector = pos >> SECTOR_SHIFT;
cd82cca7 CH	227	bio->bi_write_hint = iocb->ki_hint;
	228	bio->bi_private = dio;
	229	bio->bi_end_io = blkdev_bio_end_io;
	230	bio->bi_ioprio = iocb->ki_ioprio;
	231
	232	ret = bio_iov_iter_get_pages(bio, iter);
	233	if (unlikely(ret)) {
	234	bio->bi_status = BLK_STS_IOERR;
	235	bio_endio(bio);
	236	break;
	237	}
	238
	239	if (is_read) {
	240	bio->bi_opf = REQ_OP_READ;
09ce8744	241	if (dio->flags & DIO_SHOULD_DIRTY)
cd82cca7 CH	242	bio_set_pages_dirty(bio);
	243	} else {
	244	bio->bi_opf = dio_bio_write_op(iocb);
	245	task_io_account_write(bio->bi_iter.bi_size);
	246	}
	247	if (iocb->ki_flags & IOCB_NOWAIT)
	248	bio->bi_opf \|= REQ_NOWAIT;
	249
	250	dio->size += bio->bi_iter.bi_size;
	251	pos += bio->bi_iter.bi_size;
	252
	253	nr_pages = bio_iov_vecs_to_alloc(iter, BIO_MAX_VECS);
	254	if (!nr_pages) {
3e08773c	255	submit_bio(bio);
cd82cca7 CH	256	break;
cd82cca7 CH	257	}
e71aa913	258	atomic_inc(&dio->ref);
cd82cca7 CH	259	submit_bio(bio);
	260	bio = bio_alloc(GFP_KERNEL, nr_pages);
	261	}
	262
25d207dc	263	blk_finish_plug(&plug);
cd82cca7 CH	264
	265	if (!is_sync)
	266	return -EIOCBQUEUED;
	267
	268	for (;;) {
	269	set_current_state(TASK_UNINTERRUPTIBLE);
	270	if (!READ_ONCE(dio->waiter))
	271	break;
25d207dc	272	blk_io_schedule();
cd82cca7 CH	273	}
	274	__set_current_state(TASK_RUNNING);
	275
	276	if (!ret)
	277	ret = blk_status_to_errno(dio->bio.bi_status);
	278	if (likely(!ret))
	279	ret = dio->size;
	280
	281	bio_put(&dio->bio);
	282	return ret;
	283	}
	284
54a88eb8 PB	285	static void blkdev_bio_end_io_async(struct bio *bio)
	286	{
	287	struct blkdev_dio *dio = container_of(bio, struct blkdev_dio, bio);
	288	struct kiocb *iocb = dio->iocb;
	289	ssize_t ret;
	290
	291	if (likely(!bio->bi_status)) {
	292	ret = dio->size;
	293	iocb->ki_pos += ret;
	294	} else {
	295	ret = blk_status_to_errno(bio->bi_status);
	296	}
	297
b6773cdb	298	iocb->ki_complete(iocb, ret);
54a88eb8 PB	299
	300	if (dio->flags & DIO_SHOULD_DIRTY) {
	301	bio_check_pages_dirty(bio);
	302	} else {
	303	bio_release_pages(bio, false);
	304	bio_put(bio);
	305	}
	306	}
	307
	308	static ssize_t __blkdev_direct_IO_async(struct kiocb *iocb,
	309	struct iov_iter *iter,
	310	unsigned int nr_pages)
	311	{
	312	struct block_device *bdev = iocb->ki_filp->private_data;
	313	struct blkdev_dio *dio;
	314	struct bio *bio;
	315	loff_t pos = iocb->ki_pos;
	316	int ret = 0;
	317
	318	if ((pos \| iov_iter_alignment(iter)) &
	319	(bdev_logical_block_size(bdev) - 1))
	320	return -EINVAL;
	321
	322	bio = bio_alloc_kiocb(iocb, nr_pages, &blkdev_dio_pool);
	323	dio = container_of(bio, struct blkdev_dio, bio);
	324	dio->flags = 0;
	325	dio->iocb = iocb;
	326	bio_set_dev(bio, bdev);
	327	bio->bi_iter.bi_sector = pos >> SECTOR_SHIFT;
	328	bio->bi_write_hint = iocb->ki_hint;
	329	bio->bi_end_io = blkdev_bio_end_io_async;
	330	bio->bi_ioprio = iocb->ki_ioprio;
	331
1bb6b810 PB	332	if (iov_iter_is_bvec(iter)) {
	333	/*
	334	* Users don't rely on the iterator being in any particular
	335	* state for async I/O returning -EIOCBQUEUED, hence we can
	336	* avoid expensive iov_iter_advance(). Bypass
	337	* bio_iov_iter_get_pages() and set the bvec directly.
	338	*/
	339	bio_iov_bvec_set(bio, iter);
	340	} else {
	341	ret = bio_iov_iter_get_pages(bio, iter);
	342	if (unlikely(ret)) {
	343	bio->bi_status = BLK_STS_IOERR;
	344	bio_endio(bio);
	345	return ret;
	346	}
54a88eb8 PB	347	}
	348	dio->size = bio->bi_iter.bi_size;
	349
	350	if (iov_iter_rw(iter) == READ) {
	351	bio->bi_opf = REQ_OP_READ;
	352	if (iter_is_iovec(iter)) {
	353	dio->flags \|= DIO_SHOULD_DIRTY;
	354	bio_set_pages_dirty(bio);
	355	}
	356	} else {
	357	bio->bi_opf = dio_bio_write_op(iocb);
	358	task_io_account_write(bio->bi_iter.bi_size);
	359	}
	360
54a88eb8	361	if (iocb->ki_flags & IOCB_HIPRI) {
842e39b0	362	bio->bi_opf \|= REQ_POLLED \| REQ_NOWAIT;
54a88eb8 PB	363	submit_bio(bio);
	364	WRITE_ONCE(iocb->private, bio);
	365	} else {
842e39b0 PB	366	if (iocb->ki_flags & IOCB_NOWAIT)
842e39b0 PB	367	bio->bi_opf \|= REQ_NOWAIT;
54a88eb8 PB	368	submit_bio(bio);
	369	}
	370	return -EIOCBQUEUED;
	371	}
	372
cd82cca7 CH	373	static ssize_t blkdev_direct_IO(struct kiocb iocb, struct iov_iter iter)
	374	{
	375	unsigned int nr_pages;
	376
	377	if (!iov_iter_count(iter))
	378	return 0;
	379
	380	nr_pages = bio_iov_vecs_to_alloc(iter, BIO_MAX_VECS + 1);
54a88eb8 PB	381	if (likely(nr_pages <= BIO_MAX_VECS)) {
	382	if (is_sync_kiocb(iocb))
	383	return __blkdev_direct_IO_simple(iocb, iter, nr_pages);
	384	return __blkdev_direct_IO_async(iocb, iter, nr_pages);
	385	}
cd82cca7 CH	386	return __blkdev_direct_IO(iocb, iter, bio_max_segs(nr_pages));
	387	}
	388
	389	static int blkdev_writepage(struct page page, struct writeback_control wbc)
	390	{
	391	return block_write_full_page(page, blkdev_get_block, wbc);
	392	}
	393
	394	static int blkdev_readpage(struct file * file, struct page * page)
	395	{
	396	return block_read_full_page(page, blkdev_get_block);
	397	}
	398
	399	static void blkdev_readahead(struct readahead_control *rac)
	400	{
	401	mpage_readahead(rac, blkdev_get_block);
	402	}
	403
	404	static int blkdev_write_begin(struct file file, struct address_space mapping,
	405	loff_t pos, unsigned len, unsigned flags, struct page **pagep,
	406	void **fsdata)
	407	{
	408	return block_write_begin(mapping, pos, len, flags, pagep,
	409	blkdev_get_block);
	410	}
	411
	412	static int blkdev_write_end(struct file file, struct address_space mapping,
	413	loff_t pos, unsigned len, unsigned copied, struct page *page,
	414	void *fsdata)
	415	{
	416	int ret;
	417	ret = block_write_end(file, mapping, pos, len, copied, page, fsdata);
	418
	419	unlock_page(page);
	420	put_page(page);
	421
	422	return ret;
	423	}
	424
	425	static int blkdev_writepages(struct address_space *mapping,
	426	struct writeback_control *wbc)
	427	{
	428	return generic_writepages(mapping, wbc);
	429	}
	430
	431	const struct address_space_operations def_blk_aops = {
	432	.set_page_dirty = __set_page_dirty_buffers,
	433	.readpage = blkdev_readpage,
	434	.readahead = blkdev_readahead,
	435	.writepage = blkdev_writepage,
	436	.write_begin = blkdev_write_begin,
	437	.write_end = blkdev_write_end,
	438	.writepages = blkdev_writepages,
	439	.direct_IO = blkdev_direct_IO,
	440	.migratepage = buffer_migrate_page_norefs,
	441	.is_dirty_writeback = buffer_check_dirty_writeback,
	442	};
	443
	444	/*
	445	* for a block special file file_inode(file)->i_size is zero
	446	* so we compute the size by hand (just as in block_read/write above)
	447	*/
	448	static loff_t blkdev_llseek(struct file *file, loff_t offset, int whence)
	449	{
450	struct inode *bd_inode = bdev_file_inode(file);
451	loff_t retval;
452
453	inode_lock(bd_inode);
454	retval = fixed_size_llseek(file, offset, whence, i_size_read(bd_inode));
455	inode_unlock(bd_inode);
456	return retval;
457	}
458
459	static int blkdev_fsync(struct file *filp, loff_t start, loff_t end,
460	int datasync)
461	{
fac7c6d5	462	struct block_device *bdev = filp->private_data;
cd82cca7 CH	463	int error;
	464
	465	error = file_write_and_wait_range(filp, start, end);
	466	if (error)
	467	return error;
	468
	469	/*
	470	* There is no need to serialise calls to blkdev_issue_flush with
	471	* i_mutex and doing so causes performance issues with concurrent
	472	* O_SYNC writers to a block device.
	473	*/
	474	error = blkdev_issue_flush(bdev);
	475	if (error == -EOPNOTSUPP)
	476	error = 0;
	477
	478	return error;
	479	}
	480
	481	static int blkdev_open(struct inode inode, struct file filp)
	482	{
	483	struct block_device *bdev;
	484
	485	/*
	486	* Preserve backwards compatibility and allow large file access
	487	* even if userspace doesn't ask for it explicitly. Some mkfs
	488	* binary needs it. We might want to drop this workaround
	489	* during an unstable branch.
	490	*/
	491	filp->f_flags \|= O_LARGEFILE;
	492	filp->f_mode \|= FMODE_NOWAIT \| FMODE_BUF_RASYNC;
	493
	494	if (filp->f_flags & O_NDELAY)
	495	filp->f_mode \|= FMODE_NDELAY;
	496	if (filp->f_flags & O_EXCL)
	497	filp->f_mode \|= FMODE_EXCL;
	498	if ((filp->f_flags & O_ACCMODE) == 3)
	499	filp->f_mode \|= FMODE_WRITE_IOCTL;
	500
	501	bdev = blkdev_get_by_dev(inode->i_rdev, filp->f_mode, filp);
	502	if (IS_ERR(bdev))
	503	return PTR_ERR(bdev);
fac7c6d5 PB	504
fac7c6d5 PB	505	filp->private_data = bdev;
cd82cca7 CH	506	filp->f_mapping = bdev->bd_inode->i_mapping;
	507	filp->f_wb_err = filemap_sample_wb_err(filp->f_mapping);
	508	return 0;
	509	}
	510
	511	static int blkdev_close(struct inode inode, struct file filp)
	512	{
fac7c6d5	513	struct block_device *bdev = filp->private_data;
cd82cca7 CH	514
	515	blkdev_put(bdev, filp->f_mode);
	516	return 0;
	517	}
	518
cd82cca7 CH	519	/*
	520	* Write data to the block device. Only intended for the block device itself
	521	* and the raw driver which basically is a fake block device.
	522	*
	523	* Does not take i_mutex for the write and thus is not for general purpose
	524	* use.
	525	*/
	526	static ssize_t blkdev_write_iter(struct kiocb iocb, struct iov_iter from)
	527	{
fac7c6d5 PB	528	struct block_device *bdev = iocb->ki_filp->private_data;
fac7c6d5 PB	529	struct inode *bd_inode = bdev->bd_inode;
138c1a38	530	loff_t size = bdev_nr_bytes(bdev);
cd82cca7 CH	531	struct blk_plug plug;
	532	size_t shorted = 0;
	533	ssize_t ret;
	534
fac7c6d5	535	if (bdev_read_only(bdev))
cd82cca7 CH	536	return -EPERM;
	537
	538	if (IS_SWAPFILE(bd_inode) && !is_hibernate_resume_dev(bd_inode->i_rdev))
	539	return -ETXTBSY;
	540
	541	if (!iov_iter_count(from))
	542	return 0;
	543
	544	if (iocb->ki_pos >= size)
	545	return -ENOSPC;
	546
	547	if ((iocb->ki_flags & (IOCB_NOWAIT \| IOCB_DIRECT)) == IOCB_NOWAIT)
	548	return -EOPNOTSUPP;
	549
	550	size -= iocb->ki_pos;
	551	if (iov_iter_count(from) > size) {
	552	shorted = iov_iter_count(from) - size;
	553	iov_iter_truncate(from, size);
	554	}
	555
	556	blk_start_plug(&plug);
	557	ret = __generic_file_write_iter(iocb, from);
	558	if (ret > 0)
	559	ret = generic_write_sync(iocb, ret);
	560	iov_iter_reexpand(from, iov_iter_count(from) + shorted);
	561	blk_finish_plug(&plug);
	562	return ret;
	563	}
	564
	565	static ssize_t blkdev_read_iter(struct kiocb iocb, struct iov_iter to)
	566	{
fac7c6d5	567	struct block_device *bdev = iocb->ki_filp->private_data;
138c1a38	568	loff_t size = bdev_nr_bytes(bdev);
ceaa7625	569	size_t count = iov_iter_count(to);
cd82cca7 CH	570	loff_t pos = iocb->ki_pos;
cd82cca7 CH	571	size_t shorted = 0;
ceaa7625	572	ssize_t ret = 0;
cd82cca7	573
ceaa7625	574	if (unlikely(pos + count > size)) {
6450fe1f PB	575	if (pos >= size)
	576	return 0;
	577	size -= pos;
ceaa7625 JA	578	if (count > size) {
ceaa7625 JA	579	shorted = count - size;
6450fe1f PB	580	iov_iter_truncate(to, size);
6450fe1f PB	581	}
cd82cca7 CH	582	}
cd82cca7 CH	583
ceaa7625 JA	584	if (iocb->ki_flags & IOCB_DIRECT) {
	585	struct address_space *mapping = iocb->ki_filp->f_mapping;
	586
	587	if (iocb->ki_flags & IOCB_NOWAIT) {
	588	if (filemap_range_needs_writeback(mapping, iocb->ki_pos,
	589	iocb->ki_pos + count - 1))
	590	return -EAGAIN;
	591	} else {
	592	ret = filemap_write_and_wait_range(mapping,
	593	iocb->ki_pos,
	594	iocb->ki_pos + count - 1);
	595	if (ret < 0)
	596	return ret;
	597	}
	598
	599	file_accessed(iocb->ki_filp);
	600
	601	ret = blkdev_direct_IO(iocb, to);
	602	if (ret >= 0) {
	603	iocb->ki_pos += ret;
	604	count -= ret;
	605	}
	606	if (ret < 0 \|\| !count)
	607	return ret;
	608	}
	609
	610	ret = filemap_read(iocb, to, ret);
6450fe1f PB	611
	612	if (unlikely(shorted))
	613	iov_iter_reexpand(to, iov_iter_count(to) + shorted);
cd82cca7 CH	614	return ret;
	615	}
	616
	617	#define BLKDEV_FALLOC_FL_SUPPORTED \
	618	(FALLOC_FL_KEEP_SIZE \| FALLOC_FL_PUNCH_HOLE \| \
	619	FALLOC_FL_ZERO_RANGE \| FALLOC_FL_NO_HIDE_STALE)
	620
	621	static long blkdev_fallocate(struct file *file, int mode, loff_t start,
	622	loff_t len)
	623	{
f278eb3d ML	624	struct inode *inode = bdev_file_inode(file);
f278eb3d ML	625	struct block_device *bdev = I_BDEV(inode);
cd82cca7 CH	626	loff_t end = start + len - 1;
	627	loff_t isize;
	628	int error;
	629
	630	/* Fail if we don't recognize the flags. */
	631	if (mode & ~BLKDEV_FALLOC_FL_SUPPORTED)
	632	return -EOPNOTSUPP;
	633
	634	/* Don't go off the end of the device. */
2a93ad8f	635	isize = bdev_nr_bytes(bdev);
cd82cca7 CH	636	if (start >= isize)
	637	return -EINVAL;
	638	if (end >= isize) {
	639	if (mode & FALLOC_FL_KEEP_SIZE) {
	640	len = isize - start;
	641	end = start + len - 1;
	642	} else
	643	return -EINVAL;
	644	}
	645
	646	/*
	647	* Don't allow IO that isn't aligned to logical block size.
	648	*/
	649	if ((start \| len) & (bdev_logical_block_size(bdev) - 1))
	650	return -EINVAL;
	651
f278eb3d ML	652	filemap_invalidate_lock(inode->i_mapping);
f278eb3d ML	653
cd82cca7 CH	654	/* Invalidate the page cache, including dirty pages. */
	655	error = truncate_bdev_range(bdev, file->f_mode, start, end);
	656	if (error)
f278eb3d	657	goto fail;
cd82cca7 CH	658
	659	switch (mode) {
	660	case FALLOC_FL_ZERO_RANGE:
	661	case FALLOC_FL_ZERO_RANGE \| FALLOC_FL_KEEP_SIZE:
6549a874 PB	662	error = blkdev_issue_zeroout(bdev, start >> SECTOR_SHIFT,
	663	len >> SECTOR_SHIFT, GFP_KERNEL,
	664	BLKDEV_ZERO_NOUNMAP);
cd82cca7 CH	665	break;
cd82cca7 CH	666	case FALLOC_FL_PUNCH_HOLE \| FALLOC_FL_KEEP_SIZE:
6549a874 PB	667	error = blkdev_issue_zeroout(bdev, start >> SECTOR_SHIFT,
	668	len >> SECTOR_SHIFT, GFP_KERNEL,
	669	BLKDEV_ZERO_NOFALLBACK);
cd82cca7 CH	670	break;
cd82cca7 CH	671	case FALLOC_FL_PUNCH_HOLE \| FALLOC_FL_KEEP_SIZE \| FALLOC_FL_NO_HIDE_STALE:
6549a874 PB	672	error = blkdev_issue_discard(bdev, start >> SECTOR_SHIFT,
6549a874 PB	673	len >> SECTOR_SHIFT, GFP_KERNEL, 0);
cd82cca7 CH	674	break;
cd82cca7 CH	675	default:
f278eb3d	676	error = -EOPNOTSUPP;
cd82cca7	677	}
cd82cca7	678
f278eb3d ML	679	fail:
	680	filemap_invalidate_unlock(inode->i_mapping);
	681	return error;
cd82cca7 CH	682	}
	683
	684	const struct file_operations def_blk_fops = {
	685	.open = blkdev_open,
	686	.release = blkdev_close,
	687	.llseek = blkdev_llseek,
	688	.read_iter = blkdev_read_iter,
	689	.write_iter = blkdev_write_iter,
3e08773c	690	.iopoll = iocb_bio_iopoll,
cd82cca7 CH	691	.mmap = generic_file_mmap,
cd82cca7 CH	692	.fsync = blkdev_fsync,
8a709512	693	.unlocked_ioctl = blkdev_ioctl,
cd82cca7 CH	694	#ifdef CONFIG_COMPAT
	695	.compat_ioctl = compat_blkdev_ioctl,
	696	#endif
	697	.splice_read = generic_file_splice_read,
	698	.splice_write = iter_file_splice_write,
	699	.fallocate = blkdev_fallocate,
	700	};
	701
	702	static __init int blkdev_init(void)
	703	{
	704	return bioset_init(&blkdev_dio_pool, 4,
	705	offsetof(struct blkdev_dio, bio),
	706	BIOSET_NEED_BVECS\|BIOSET_PERCPU_CACHE);
	707	}
	708	module_init(blkdev_init);