btrfs: avoid repeated computations in btrfs_mark_ordered_io_finished()

We're computing a few values several times:

1) The current ordered extent's end offset inside the while loop, we have
   computed it and stored it in the 'entry_end' variable but then we
   compute it again later as the first argument to the min() macro;

2) The end file offset, open coded 3 times;

3) The current length (stored in variable 'len') computed 2 times, one
   inside an assertion and the other when assigning to the 'len' variable.

So use existing variables and add new ones to prevent repeating these
expressions and reduce the source code.

We were also subtracting one from the result of min() macro call and
then adding 1 back in the next line, making both operations pointless.
So just remove the decrement and increment by 1.

This also reduces very slightly the object code.

Before:

  $ size fs/btrfs/btrfs.ko
     text	   data	    bss	    dec	    hex	filename
  1916576	 161679	  15592	2093847	 1ff317	fs/btrfs/btrfs.ko

After:

  $ size fs/btrfs/btrfs.ko
     text	   data	    bss	    dec	    hex	filename
  1916556	 161679	  15592	2093827	 1ff303	fs/btrfs/btrfs.ko

Reviewed-by: Qu Wenruo <wqu@suse.com>
Reviewed-by: Anand Jain <asj@kernel.org>
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Reviewed-by: David Sterba <dsterba@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>

diff --git a/fs/btrfs/ordered-data.c b/fs/btrfs/ordered-data.c
index 8a8aa6ed405bd4107268120e4d9f89b5d3d45237..dfda952dcf7b2b0546c044cff9c2e45497f950c6 100644 (file)
--- a/fs/btrfs/ordered-data.c
+++ b/fs/btrfs/ordered-data.c
@@ -483,16 +483,15 @@ void btrfs_mark_ordered_io_finished(struct btrfs_inode *inode,
        struct btrfs_ordered_extent *entry = NULL;
        unsigned long flags;
        u64 cur = file_offset;
+       const u64 end = file_offset + num_bytes;
 
-       trace_btrfs_writepage_end_io_hook(inode, file_offset,
-                                         file_offset + num_bytes - 1,
-                                         uptodate);
+       trace_btrfs_writepage_end_io_hook(inode, file_offset, end - 1, uptodate);
 
        spin_lock_irqsave(&inode->ordered_tree_lock, flags);
-       while (cur < file_offset + num_bytes) {
+       while (cur < end) {
                u64 entry_end;
-               u64 end;
-               u32 len;
+               u64 this_end;
+               u64 len;
 
                node = ordered_tree_search(inode, cur);
                /* No ordered extents at all */
@@ -535,10 +534,9 @@ void btrfs_mark_ordered_io_finished(struct btrfs_inode *inode,
                 *      |
                 *      cur
                 */
-               end = min(entry->file_offset + entry->num_bytes,
-                         file_offset + num_bytes) - 1;
-               ASSERT(end + 1 - cur < U32_MAX);
-               len = end + 1 - cur;
+               this_end = min(entry_end, end);
+               len = this_end - cur;
+               ASSERT(len < U32_MAX);
 
                if (can_finish_ordered_extent(entry, folio, cur, len, uptodate)) {
                        spin_unlock_irqrestore(&inode->ordered_tree_lock, flags);