btrfs: cleanup for open-coded alignment

Though most of the btrfs codes are using ALIGN macro for page alignment,
there are still some codes using open-coded alignment like the
following:
------
        u64 mask = ((u64)root->stripesize - 1);
        u64 ret = (val + mask) & ~mask;
------
Or even hidden one:
------
        num_bytes = (end - start + blocksize) & ~(blocksize - 1);
------

Sometimes these open-coded alignment is not so easy to understand for
newbie like me.

This commit changes the open-coded alignment to the ALIGN macro for a
better readability.

Also there is a previous patch from David Sterba with similar changes,
but the patch is for 3.2 kernel and seems not merged.
http://www.spinics.net/lists/linux-btrfs/msg12747.html

Cc: David Sterba <dave@jikos.cz>
Signed-off-by: Qu Wenruo <quwenruo@cn.fujitsu.com>
Signed-off-by: Josef Bacik <jbacik@fusionio.com>

1 files changed, 15 insertions, 22 deletions

diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index be09654e11b9..9ef7a5b1b77e 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -233,8 +233,7 @@ static noinline int cow_file_range_inline(struct btrfs_trans_handle *trans,
         u64 isize = i_size_read(inode);
         u64 actual_end = min(end + 1, isize);
         u64 inline_len = actual_end - start;
-        u64 aligned_end = (end + root->sectorsize - 1) &
-                        ~((u64)root->sectorsize - 1);
+        u64 aligned_end = ALIGN(end, root->sectorsize);
         u64 data_len = inline_len;
         int ret;
 
@@ -391,7 +390,7 @@ again:
          * a compressed extent to 128k.
          */
         total_compressed = min(total_compressed, max_uncompressed);
-        num_bytes = (end - start + blocksize) & ~(blocksize - 1);
+        num_bytes = ALIGN(end - start + 1, blocksize);
         num_bytes = max(blocksize,  num_bytes);
         total_in = 0;
         ret = 0;
@@ -490,15 +489,13 @@ cont:
                  * up to a block size boundary so the allocator does sane
                  * things
                  */
-                total_compressed = (total_compressed + blocksize - 1) &
-                        ~(blocksize - 1);
+                total_compressed = ALIGN(total_compressed, blocksize);
 
                 /*
                  * one last check to make sure the compression is really a
                  * win, compare the page count read with the blocks on disk
                  */
-                total_in = (total_in + PAGE_CACHE_SIZE - 1) &
-                        ~(PAGE_CACHE_SIZE - 1);
+                total_in = ALIGN(total_in, PAGE_CACHE_SIZE);
                 if (total_compressed >= total_in) {
                         will_compress = 0;
                 } else {
@@ -856,7 +853,7 @@ static noinline int __cow_file_range(struct btrfs_trans_handle *trans,
 
         BUG_ON(btrfs_is_free_space_inode(inode));
 
-        num_bytes = (end - start + blocksize) & ~(blocksize - 1);
+        num_bytes = ALIGN(end - start + 1, blocksize);
         num_bytes = max(blocksize,  num_bytes);
         disk_num_bytes = num_bytes;
 
@@ -4015,7 +4012,6 @@ int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
         u64 extent_num_bytes = 0;
         u64 extent_offset = 0;
         u64 item_end = 0;
-        u64 mask = root->sectorsize - 1;
         u32 found_type = (u8)-1;
         int found_extent;
         int del_item;
@@ -4039,7 +4035,8 @@ int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
          * extent just the way it is.
          */
         if (root->ref_cows || root == root->fs_info->tree_root)
-                btrfs_drop_extent_cache(inode, (new_size + mask) & (~mask), (u64)-1, 0);
+                btrfs_drop_extent_cache(inode, ALIGN(new_size,
+                                        root->sectorsize), (u64)-1, 0);
 
         /*
          * This function is also used to drop the items in the log tree before
@@ -4118,10 +4115,9 @@ search_again:
                         if (!del_item) {
                                 u64 orig_num_bytes =
                                         btrfs_file_extent_num_bytes(leaf, fi);
-                                extent_num_bytes = new_size -
-                                        found_key.offset + root->sectorsize - 1;
-                                extent_num_bytes = extent_num_bytes &
-                                        ~((u64)root->sectorsize - 1);
+                                extent_num_bytes = ALIGN(new_size -
+                                                found_key.offset,
+                                                root->sectorsize);
                                 btrfs_set_file_extent_num_bytes(leaf, fi,
                                                          extent_num_bytes);
                                 num_dec = (orig_num_bytes -
@@ -4357,9 +4353,8 @@ int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size)
         struct extent_map *em = NULL;
         struct extent_state *cached_state = NULL;
         struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
-        u64 mask = root->sectorsize - 1;
-        u64 hole_start = (oldsize + mask) & ~mask;
-        u64 block_end = (size + mask) & ~mask;
+        u64 hole_start = ALIGN(oldsize, root->sectorsize);
+        u64 block_end = ALIGN(size, root->sectorsize);
         u64 last_byte;
         u64 cur_offset;
         u64 hole_size;
@@ -4392,7 +4387,7 @@ int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size)
                         break;
                 }
                 last_byte = min(extent_map_end(em), block_end);
-                last_byte = (last_byte + mask) & ~mask;
+                last_byte = ALIGN(last_byte , root->sectorsize);
                 if (!test_bit(EXTENT_FLAG_PREALLOC, &em->flags)) {
                         struct extent_map *hole_em;
                         hole_size = last_byte - cur_offset;
@@ -6111,8 +6106,7 @@ again:
         } else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
                 size_t size;
                 size = btrfs_file_extent_inline_len(leaf, item);
-                extent_end = (extent_start + size + root->sectorsize - 1) &
-                        ~((u64)root->sectorsize - 1);
+                extent_end = ALIGN(extent_start + size, root->sectorsize);
         }
 
         if (start >= extent_end) {
@@ -6184,8 +6178,7 @@ again:
                 copy_size = min_t(u64, PAGE_CACHE_SIZE - pg_offset,
                                 size - extent_offset);
                 em->start = extent_start + extent_offset;
-                em->len = (copy_size + root->sectorsize - 1) &
-                        ~((u64)root->sectorsize - 1);
+                em->len = ALIGN(copy_size, root->sectorsize);
                 em->orig_block_len = em->len;
                 em->orig_start = em->start;
                 if (compress_type) {