[PATCH] remove ->get_blocks() support

static int

blkdev_get_blocks(struct inode *inode, sector_t iblock,

		unsigned long max_blocks, struct buffer_head *bh, int create)

		struct buffer_head *bh, int create)

{

	sector_t end_block = max_block(I_BDEV(inode));

	unsigned long max_blocks = bh->b_size >> inode->i_blkbits;

	if ((iblock + max_blocks) > end_block) {

		max_blocks = end_block - iblock;

	unsigned first_block_in_page;	/* doesn't change, Used only once */

	int boundary;			/* prev block is at a boundary */

	int reap_counter;		/* rate limit reaping */

	get_blocks_t *get_blocks;	/* block mapping function */

	get_block_t *get_block;		/* block mapping function */

	dio_iodone_t *end_io;		/* IO completion function */

	sector_t final_block_in_bio;	/* current final block in bio + 1 */

	sector_t next_block_for_io;	/* next block to be put under IO,

					   in dio_blocks units */

	struct buffer_head map_bh;	/* last get_blocks() result */

	struct buffer_head map_bh;	/* last get_block() result */

	/*

	 * Deferred addition of a page to the dio.  These variables are

/*

 * Called when all DIO BIO I/O has been completed - let the filesystem

 * know, if it registered an interest earlier via get_blocks.  Pass the

 * know, if it registered an interest earlier via get_block.  Pass the

 * private field of the map buffer_head so that filesystems can use it

 * to hold additional state between get_blocks calls and dio_complete.

 * to hold additional state between get_block calls and dio_complete.

 */

static void dio_complete(struct dio *dio, loff_t offset, ssize_t bytes)

{

 * The fs is allowed to map lots of blocks at once.  If it wants to do that,

 * it uses the passed inode-relative block number as the file offset, as usual.

 *

 * get_blocks() is passed the number of i_blkbits-sized blocks which direct_io

 * get_block() is passed the number of i_blkbits-sized blocks which direct_io

 * has remaining to do.  The fs should not map more than this number of blocks.

 *

 * If the fs has mapped a lot of blocks, it should populate bh->b_size to

 * In the case of filesystem holes: the fs may return an arbitrarily-large

 * hole by returning an appropriate value in b_size and by clearing

 * buffer_mapped().  However the direct-io code will only process holes one

 * block at a time - it will repeatedly call get_blocks() as it walks the hole.

 * block at a time - it will repeatedly call get_block() as it walks the hole.

 */

static int get_more_blocks(struct dio *dio)

{

		 * at a higher level for inside-i_size block-instantiating

		 * writes.

		 */

		ret = (*dio->get_blocks)(dio->inode, fs_startblk, fs_count,

		map_bh->b_size = fs_count << dio->blkbits;

		ret = (*dio->get_block)(dio->inode, fs_startblk,

						map_bh, create);

	}

	return ret;

 * happily perform page-sized but 512-byte aligned IOs.  It is important that

 * blockdev IO be able to have fine alignment and large sizes.

 *

 * So what we do is to permit the ->get_blocks function to populate bh.b_size

 * So what we do is to permit the ->get_block function to populate bh.b_size

 * with the size of IO which is permitted at this offset and this i_blkbits.

 *

 * For best results, the blockdev should be set up with 512-byte i_blkbits and

 * it should set b_size to PAGE_SIZE or more inside get_blocks().  This gives

 * it should set b_size to PAGE_SIZE or more inside get_block().  This gives

 * fine alignment but still allows this function to work in PAGE_SIZE units.

 */

static int do_direct_IO(struct dio *dio)

static ssize_t

direct_io_worker(int rw, struct kiocb *iocb, struct inode *inode, 

	const struct iovec *iov, loff_t offset, unsigned long nr_segs, 

	unsigned blkbits, get_blocks_t get_blocks, dio_iodone_t end_io,

	unsigned blkbits, get_block_t get_block, dio_iodone_t end_io,

	struct dio *dio)

{

	unsigned long user_addr; 

	dio->boundary = 0;

	dio->reap_counter = 0;

	dio->get_blocks = get_blocks;

	dio->get_block = get_block;

	dio->end_io = end_io;

	dio->map_bh.b_private = NULL;

	dio->final_block_in_bio = -1;

ssize_t

__blockdev_direct_IO(int rw, struct kiocb *iocb, struct inode *inode,

	struct block_device *bdev, const struct iovec *iov, loff_t offset, 

	unsigned long nr_segs, get_blocks_t get_blocks, dio_iodone_t end_io,

	unsigned long nr_segs, get_block_t get_block, dio_iodone_t end_io,

	int dio_lock_type)

{

	int seg;

		(end > i_size_read(inode)));

	retval = direct_io_worker(rw, iocb, inode, iov, offset,

				nr_segs, blkbits, get_blocks, end_io, dio);

				nr_segs, blkbits, get_block, end_io, dio);

	if (rw == READ && dio_lock_type == DIO_LOCKING)

		release_i_mutex = 0;

	return generic_block_bmap(mapping,block,ext2_get_block);

}

static int

ext2_get_blocks(struct inode *inode, sector_t iblock, unsigned long max_blocks,

			struct buffer_head *bh_result, int create)

{

	int ret;

	ret = ext2_get_block(inode, iblock, bh_result, create);

	if (ret == 0)

		bh_result->b_size = (1 << inode->i_blkbits);

	return ret;

}

static ssize_t

ext2_direct_IO(int rw, struct kiocb *iocb, const struct iovec *iov,

			loff_t offset, unsigned long nr_segs)

	struct inode *inode = file->f_mapping->host;

	return blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov,

				offset, nr_segs, ext2_get_blocks, NULL);

				offset, nr_segs, ext2_get_block, NULL);

}

static int

static int

ext3_direct_io_get_blocks(struct inode *inode, sector_t iblock,

		unsigned long max_blocks,

		struct buffer_head *bh_result, int create)

{

	handle_t *handle = journal_current_handle();

	int ret = 0;

	unsigned max_blocks = bh_result->b_size >> inode->i_blkbits;

	if (!create)

		goto get_block;		/* A read */

	return ret;

}

static int ext3_get_blocks(struct inode *inode, sector_t iblock,

		unsigned long maxblocks, struct buffer_head *bh_result,

		int create)

{

	return ext3_direct_io_get_blocks(inode, iblock, maxblocks,

					bh_result, create);

}

static int ext3_get_block(struct inode *inode, sector_t iblock,

			struct buffer_head *bh_result, int create)

{

	return ext3_get_blocks(inode, iblock, 1, bh_result, create);

	return ext3_direct_io_get_blocks(inode, iblock, bh_result, create);

}

/*

}

static int fat_get_blocks(struct inode *inode, sector_t iblock,

			  unsigned long max_blocks,

			  struct buffer_head *bh_result, int create)

{

	struct super_block *sb = inode->i_sb;

	int err;

	unsigned long max_blocks = bh_result->b_size >> inode->i_blkbits;

	err = __fat_get_blocks(inode, iblock, &max_blocks, bh_result, create);

	if (err)