]> pilppa.com Git - linux-2.6-omap-h63xx.git/commitdiff
[PATCH] remove ->get_blocks() support
authorBadari Pulavarty <pbadari@us.ibm.com>
Sun, 26 Mar 2006 09:38:02 +0000 (01:38 -0800)
committerLinus Torvalds <torvalds@g5.osdl.org>
Sun, 26 Mar 2006 16:57:01 +0000 (08:57 -0800)
Now that get_block() can handle mapping multiple disk blocks, no need to have
->get_blocks().  This patch removes fs specific ->get_blocks() added for DIO
and makes it users use get_block() instead.

Signed-off-by: Badari Pulavarty <pbadari@us.ibm.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
12 files changed:
fs/block_dev.c
fs/direct-io.c
fs/ext2/inode.c
fs/ext3/inode.c
fs/fat/inode.c
fs/hfs/inode.c
fs/hfsplus/inode.c
fs/jfs/inode.c
fs/ocfs2/aops.c
fs/reiserfs/inode.c
fs/xfs/linux-2.6/xfs_aops.c
include/linux/fs.h

index 9a451a9ffad454dfce77d89fbff9194a622e656b..5983d42df015d2ff32983ddc46e8ae194c3e1063 100644 (file)
@@ -131,9 +131,10 @@ blkdev_get_block(struct inode *inode, sector_t iblock,
 
 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;
index 235ed8d1f11e3b41cb332713108ca53ca063245a..9d1d2aa73e420e17445efa7ace0f6d35155527b8 100644 (file)
@@ -86,12 +86,12 @@ struct dio {
        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
@@ -211,9 +211,9 @@ static struct page *dio_get_page(struct dio *dio)
 
 /*
  * 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)
 {
@@ -493,7 +493,7 @@ static int dio_bio_reap(struct dio *dio)
  * 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
@@ -506,7 +506,7 @@ static int dio_bio_reap(struct dio *dio)
  * 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)
 {
@@ -548,7 +548,8 @@ 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;
@@ -783,11 +784,11 @@ static void dio_zero_block(struct dio *dio, int end)
  * 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)
@@ -947,7 +948,7 @@ out:
 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; 
@@ -969,7 +970,7 @@ direct_io_worker(int rw, struct kiocb *iocb, struct inode *inode,
 
        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;
@@ -1177,7 +1178,7 @@ direct_io_worker(int rw, struct kiocb *iocb, struct inode *inode,
 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;
@@ -1273,7 +1274,7 @@ __blockdev_direct_IO(int rw, struct kiocb *iocb, struct inode *inode,
                (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;
index a717837f272e66a9b422a8383ec3ae92b6da50ec..04af9c45dce23a0f50df3bf735a8749c092c3a85 100644 (file)
@@ -667,18 +667,6 @@ static sector_t ext2_bmap(struct address_space *mapping, sector_t block)
        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)
@@ -687,7 +675,7 @@ ext2_direct_IO(int rw, struct kiocb *iocb, const struct iovec *iov,
        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
index 34e5b0dc9168be42a85272d62f2cc1c580f9e644..0cd126176bbbcf942bb91c4f8e3f1d5bbc554868 100644 (file)
@@ -940,11 +940,11 @@ out:
 
 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 */
@@ -989,18 +989,10 @@ get_block:
        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);
 }
 
 /*
index 297300fe81c21a1523467b2cb4c869b1e8c4d415..404bfc9f7385ff1051c4abff11743346d857889f 100644 (file)
@@ -101,11 +101,11 @@ static int __fat_get_blocks(struct inode *inode, sector_t iblock,
 }
 
 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)
index 39fd85b9b91613136867b4b2690a93590b7288e9..2c564701724f9fdd0266bcfe08f1cfa364c18f32 100644 (file)
@@ -98,17 +98,6 @@ static int hfs_releasepage(struct page *page, gfp_t mask)
        return res ? try_to_free_buffers(page) : 0;
 }
 
-static int hfs_get_blocks(struct inode *inode, sector_t iblock, unsigned long max_blocks,
-                         struct buffer_head *bh_result, int create)
-{
-       int ret;
-
-       ret = hfs_get_block(inode, iblock, bh_result, create);
-       if (!ret)
-               bh_result->b_size = (1 << inode->i_blkbits);
-       return ret;
-}
-
 static ssize_t hfs_direct_IO(int rw, struct kiocb *iocb,
                const struct iovec *iov, loff_t offset, unsigned long nr_segs)
 {
@@ -116,7 +105,7 @@ static ssize_t hfs_direct_IO(int rw, struct kiocb *iocb,
        struct inode *inode = file->f_dentry->d_inode->i_mapping->host;
 
        return blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov,
-                                 offset, nr_segs, hfs_get_blocks, NULL);
+                                 offset, nr_segs, hfs_get_block, NULL);
 }
 
 static int hfs_writepages(struct address_space *mapping,
index 12ed2b7d046bf11ae2023523c52b33ac55975651..9fbe4d2aeece7816d02fab76ea371c99b23976cc 100644 (file)
@@ -93,17 +93,6 @@ static int hfsplus_releasepage(struct page *page, gfp_t mask)
        return res ? try_to_free_buffers(page) : 0;
 }
 
-static int hfsplus_get_blocks(struct inode *inode, sector_t iblock, unsigned long max_blocks,
-                             struct buffer_head *bh_result, int create)
-{
-       int ret;
-
-       ret = hfsplus_get_block(inode, iblock, bh_result, create);
-       if (!ret)
-               bh_result->b_size = (1 << inode->i_blkbits);
-       return ret;
-}
-
 static ssize_t hfsplus_direct_IO(int rw, struct kiocb *iocb,
                const struct iovec *iov, loff_t offset, unsigned long nr_segs)
 {
@@ -111,7 +100,7 @@ static ssize_t hfsplus_direct_IO(int rw, struct kiocb *iocb,
        struct inode *inode = file->f_dentry->d_inode->i_mapping->host;
 
        return blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov,
-                                 offset, nr_segs, hfsplus_get_blocks, NULL);
+                                 offset, nr_segs, hfsplus_get_block, NULL);
 }
 
 static int hfsplus_writepages(struct address_space *mapping,
index 7239ef3394895a7b2aeab80a4a083cb49bcb3e79..04eb78f1252e6b70f0383d63dbb2369dd5ca70f6 100644 (file)
@@ -302,7 +302,7 @@ static ssize_t jfs_direct_IO(int rw, struct kiocb *iocb,
        struct inode *inode = file->f_mapping->host;
 
        return blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov,
-                               offset, nr_segs, jfs_get_blocks, NULL);
+                               offset, nr_segs, jfs_get_block, NULL);
 }
 
 struct address_space_operations jfs_aops = {
index bf931ba1d36478e323f3e1c4ebc54be12ea335fb..0d858d0b25be70f496e1fb0ec863ec4778ae3c57 100644 (file)
@@ -540,7 +540,6 @@ bail:
  *                                     fs_count, map_bh, dio->rw == WRITE);
  */
 static int ocfs2_direct_IO_get_blocks(struct inode *inode, sector_t iblock,
-                                    unsigned long max_blocks,
                                     struct buffer_head *bh_result, int create)
 {
        int ret;
@@ -548,6 +547,7 @@ static int ocfs2_direct_IO_get_blocks(struct inode *inode, sector_t iblock,
        u64 p_blkno;
        int contig_blocks;
        unsigned char blocksize_bits;
+       unsigned long max_blocks = bh_result->b_size >> inode->i_blkbits;
 
        if (!inode || !bh_result) {
                mlog(ML_ERROR, "inode or bh_result is null\n");
index 62e18c19b446c91902f31d5656ba0dacfb4b132f..9857e50f85e723c00637ce6e26604cf8f07b6e7b 100644 (file)
@@ -466,7 +466,6 @@ static int reiserfs_get_block_create_0(struct inode *inode, sector_t block,
    direct_IO request. */
 static int reiserfs_get_blocks_direct_io(struct inode *inode,
                                         sector_t iblock,
-                                        unsigned long max_blocks,
                                         struct buffer_head *bh_result,
                                         int create)
 {
index a79b84f8b55cea9b339f6d339e23cfc5480a352c..c02f7c5b74629caf1ebe53c8d2755546d798e82f 100644 (file)
@@ -1319,12 +1319,12 @@ STATIC int
 xfs_get_blocks_direct(
        struct inode            *inode,
        sector_t                iblock,
-       unsigned long           max_blocks,
        struct buffer_head      *bh_result,
        int                     create)
 {
-       return __xfs_get_block(inode, iblock, max_blocks, bh_result,
-                                       create, 1, BMAPI_WRITE|BMAPI_DIRECT);
+       return __xfs_get_block(inode, iblock,
+                               bh_result->b_size >> inode->i_blkbits,
+                               bh_result, create, 1, BMAPI_WRITE|BMAPI_DIRECT);
 }
 
 STATIC void
index 155d29d5e5e4db72a4a5d8dd23671c8ee183f4c6..9d9674946956f6b78d600f9185e047bcf17f8f77 100644 (file)
@@ -252,9 +252,6 @@ extern void __init files_init(unsigned long);
 struct buffer_head;
 typedef int (get_block_t)(struct inode *inode, sector_t iblock,
                        struct buffer_head *bh_result, int create);
-typedef int (get_blocks_t)(struct inode *inode, sector_t iblock,
-                       unsigned long max_blocks,
-                       struct buffer_head *bh_result, int create);
 typedef void (dio_iodone_t)(struct kiocb *iocb, loff_t offset,
                        ssize_t bytes, void *private);
 
@@ -1645,7 +1642,7 @@ static inline void do_generic_file_read(struct file * filp, loff_t *ppos,
 
 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 lock_type);
 
 enum {
@@ -1656,29 +1653,29 @@ enum {
 
 static inline 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,
+       loff_t offset, unsigned long nr_segs, get_block_t get_block,
        dio_iodone_t end_io)
 {
        return __blockdev_direct_IO(rw, iocb, inode, bdev, iov, offset,
-                               nr_segs, get_blocks, end_io, DIO_LOCKING);
+                               nr_segs, get_block, end_io, DIO_LOCKING);
 }
 
 static inline ssize_t blockdev_direct_IO_no_locking(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,
+       loff_t offset, unsigned long nr_segs, get_block_t get_block,
        dio_iodone_t end_io)
 {
        return __blockdev_direct_IO(rw, iocb, inode, bdev, iov, offset,
-                               nr_segs, get_blocks, end_io, DIO_NO_LOCKING);
+                               nr_segs, get_block, end_io, DIO_NO_LOCKING);
 }
 
 static inline ssize_t blockdev_direct_IO_own_locking(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,
+       loff_t offset, unsigned long nr_segs, get_block_t get_block,
        dio_iodone_t end_io)
 {
        return __blockdev_direct_IO(rw, iocb, inode, bdev, iov, offset,
-                               nr_segs, get_blocks, end_io, DIO_OWN_LOCKING);
+                               nr_segs, get_block, end_io, DIO_OWN_LOCKING);
 }
 
 extern struct file_operations generic_ro_fops;