dio: create a dio_aligned() helper function

__blockdev_direct_IO() had two instances of the same code to determine
if a given offset wasn't aligned first to the inode's blkbits and then
to the underlying device's blkbits.   This was confusing enough but
we're about to add code that performs the same check on offsets in bvec
arrays.  Rather than add yet more copies of this code let's have
everyone call a helper.

Signed-off-by: Zach Brown <zach.brown@oracle.com>

diff --git a/fs/direct-io.c b/fs/direct-io.c
index 46712b781e8f33460b5c6a5fdfcb47dd29f19298..0b232c69590df8b99cba23dc75215ee4a95311c8 100644 (file)
--- a/fs/direct-io.c
+++ b/fs/direct-io.c
@@ -1023,6 +1023,39 @@ static inline int drop_refcount(struct dio *dio)
        return ret2;
 }
 
+/*
+ * Returns true if the given offset is aligned to either the IO size
+ * specified by the given blkbits or by the logical block size of the
+ * given block device.
+ *
+ * If the given offset isn't aligned to the blkbits arguments as this is
+ * called then blkbits is set to the block size of the specified block
+ * device.  The call can then return either true or false.
+ *
+ * This bizarre calling convention matches the code paths that
+ * duplicated the functionality that this helper was built from.  We
+ * reproduce the behaviour to avoid introducing subtle bugs.
+ */
+static int dio_aligned(unsigned long offset, unsigned *blkbits,
+                      struct block_device *bdev)
+{
+       unsigned mask = (1 << *blkbits) - 1;
+
+       /* 
+        * Avoid references to bdev if not absolutely needed to give
+        * the early prefetch in the caller enough time.
+        */
+
+       if (offset & mask) {
+               if (bdev)
+                       *blkbits = blksize_bits(bdev_logical_block_size(bdev));
+               mask = (1 << *blkbits) - 1;
+               return !(offset & mask);
+       }
+
+       return 1;
+}
+
 /*
  * This is a library function for use by filesystem drivers.
  *
@@ -1057,7 +1090,6 @@ do_blockdev_direct_IO(int rw, struct kiocb *iocb, struct inode *inode,
        size_t size;
        unsigned long addr;
        unsigned blkbits = inode->i_blkbits;
-       unsigned blocksize_mask = (1 << blkbits) - 1;
        ssize_t retval = -EINVAL;
        loff_t end = offset;
        struct dio *dio;
@@ -1069,33 +1101,16 @@ do_blockdev_direct_IO(int rw, struct kiocb *iocb, struct inode *inode,
        if (rw & WRITE)
                rw = WRITE_ODIRECT;
 
-       /* 
-        * Avoid references to bdev if not absolutely needed to give
-        * the early prefetch in the caller enough time.
-        */
-
-       if (offset & blocksize_mask) {
-               if (bdev)
-                       blkbits = blksize_bits(bdev_logical_block_size(bdev));
-               blocksize_mask = (1 << blkbits) - 1;
-               if (offset & blocksize_mask)
-                       goto out;
-       }
+       if (!dio_aligned(offset, &blkbits, bdev))
+               goto out;
 
        /* Check the memory alignment.  Blocks cannot straddle pages */
        for (seg = 0; seg < nr_segs; seg++) {
                addr = (unsigned long)iov[seg].iov_base;
                size = iov[seg].iov_len;
                end += size;
-               if (unlikely((addr & blocksize_mask) || 
-                            (size & blocksize_mask)))  {
-                       if (bdev)
-                                blkbits = blksize_bits(
-                                        bdev_logical_block_size(bdev));
-                       blocksize_mask = (1 << blkbits) - 1;
-                       if ((addr & blocksize_mask) || (size & blocksize_mask))
-                               goto out;
-               }
+               if (!dio_aligned(addr|size, &blkbits, bdev))
+                       goto out;
        }
 
        dio = kmem_cache_alloc(dio_cache, GFP_KERNEL);