btrfs: Refactor btrfs_get_extent_fiemap

Make btrfs_get_extent_fiemap a bit more friendly. First step is to
rename the closely related, yet arbitrary named
range_start/found_end/found variables. They define the delalloc range
that is found in case a real extent wasn't found. Subsequently remove
an unnecessary check for hole_em since it's guaranteed to be set i.e the
check is always true. Top it off by giving all comments a refresh.

No functional changes.

Signed-off-by: Nikolay Borisov <nborisov@suse.com>
Reviewed-by: David Sterba <dsterba@suse.com>
[ reformatted a few more comments ]
Signed-off-by: David Sterba <dsterba@suse.com>

diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index a35f636..6a6732b 100644 (file)
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -6949,10 +6949,10 @@ struct extent_map *btrfs_get_extent_fiemap(struct btrfs_inode *inode,
 {
        struct extent_map *em;
        struct extent_map *hole_em = NULL;
-       u64 range_start = start;
+       u64 delalloc_start = start;
        u64 end;
-       u64 found;
-       u64 found_end;
+       u64 delalloc_len;
+       u64 delalloc_end;
        int err = 0;
 
        em = btrfs_get_extent(inode, NULL, 0, start, len, 0);
@@ -6980,80 +6980,84 @@ struct extent_map *btrfs_get_extent_fiemap(struct btrfs_inode *inode,
        em = NULL;
 
        /* ok, we didn't find anything, lets look for delalloc */
-       found = count_range_bits(&inode->io_tree, &range_start,
+       delalloc_len = count_range_bits(&inode->io_tree, &delalloc_start,
                                 end, len, EXTENT_DELALLOC, 1);
-       found_end = range_start + found;
-       if (found_end < range_start)
-               found_end = (u64)-1;
+       delalloc_end = delalloc_start + delalloc_len;
+       if (delalloc_end < delalloc_start)
+               delalloc_end = (u64)-1;
 
        /*
-        * we didn't find anything useful, return
-        * the original results from get_extent()
+        * We didn't find anything useful, return the original results from
+        * get_extent()
         */
-       if (range_start > end || found_end <= start) {
+       if (delalloc_start > end || delalloc_end <= start) {
                em = hole_em;
                hole_em = NULL;
                goto out;
        }
 
-       /* adjust the range_start to make sure it doesn't
-        * go backwards from the start they passed in
+       /*
+        * Adjust the delalloc_start to make sure it doesn't go backwards from
+        * the start they passed in
         */
-       range_start = max(start, range_start);
-       found = found_end - range_start;
+       delalloc_start = max(start, delalloc_start);
+       delalloc_len = delalloc_end - delalloc_start;
 
-       if (found > 0) {
-               u64 hole_start = start;
+       if (delalloc_len > 0) {
+               u64 hole_start;
                u64 hole_len = len;
+               const u64 hole_end = extent_map_end(hole_em);
 
                em = alloc_extent_map();
                if (!em) {
                        err = -ENOMEM;
                        goto out;
                }
+               em->bdev = NULL;
+
+               ASSERT(hole_em);
                /*
-                * when btrfs_get_extent can't find anything it
-                * returns one huge hole
+                * When btrfs_get_extent can't find anything it returns one
+                * huge hole
                 *
-                * make sure what it found really fits our range, and
-                * adjust to make sure it is based on the start from
-                * the caller
+                * Make sure what it found really fits our range, and adjust to
+                * make sure it is based on the start from the caller
                 */
-               if (hole_em) {
-                       u64 calc_end = extent_map_end(hole_em);
-
-                       if (calc_end <= start || (hole_em->start > end)) {
-                               free_extent_map(hole_em);
-                               hole_em = NULL;
-                       } else {
-                               hole_start = max(hole_em->start, start);
-                               hole_len = calc_end - hole_start;
-                       }
+               if (hole_end <= start || hole_em->start > end) {
+                      free_extent_map(hole_em);
+                      hole_em = NULL;
+               } else {
+                      hole_start = max(hole_em->start, start);
+                      hole_len = hole_end - hole_start;
                }
-               em->bdev = NULL;
-               if (hole_em && range_start > hole_start) {
-                       /* our hole starts before our delalloc, so we
-                        * have to return just the parts of the hole
-                        * that go until  the delalloc starts
+
+               if (hole_em && delalloc_start > hole_start) {
+                       /*
+                        * Our hole starts before our delalloc, so we have to
+                        * return just the parts of the hole that go until the
+                        * delalloc starts
                         */
-                       em->len = min(hole_len,
-                                     range_start - hole_start);
+                       em->len = min(hole_len, delalloc_start - hole_start);
                        em->start = hole_start;
                        em->orig_start = hole_start;
                        /*
-                        * don't adjust block start at all,
-                        * it is fixed at EXTENT_MAP_HOLE
+                        * Don't adjust block start at all, it is fixed at
+                        * EXTENT_MAP_HOLE
                         */
                        em->block_start = hole_em->block_start;
                        em->block_len = hole_len;
                        if (test_bit(EXTENT_FLAG_PREALLOC, &hole_em->flags))
                                set_bit(EXTENT_FLAG_PREALLOC, &em->flags);
                } else {
-                       em->start = range_start;
-                       em->len = found;
-                       em->orig_start = range_start;
+                       /*
+                        * Hole is out of passed range or it starts after
+                        * delalloc range
+                        */
+                       em->start = delalloc_start;
+                       em->len = delalloc_len;
+                       em->orig_start = delalloc_start;
                        em->block_start = EXTENT_MAP_DELALLOC;
-                       em->block_len = found;
+                       em->block_len = delalloc_len;
                }
        } else {
                return hole_em;