fsx: move range generation logic into a common helper

We have very similar code that generates the destination range for clone,
dedupe and copy_file_range operations, so avoid duplicating the code three
times and move it into a helper function.

Signed-off-by: Filipe Manana <fdmanana@suse.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Eryu Guan <guaneryu@gmail.com>

diff --git a/ltp/fsx.c b/ltp/fsx.c
index 40cbd401b105ba9d1ee21d509d350350d12444e5..7c76655a6359915c8aadf5a75bab2176f32d394f 100644 (file)
--- a/ltp/fsx.c
+++ b/ltp/fsx.c
@@ -1939,6 +1939,39 @@ range_overlaps(
        return llabs((unsigned long long)off1 - off0) < size;
 }
 
+static void generate_dest_range(bool bdy_align,
+                               unsigned long max_range_end,
+                               unsigned long *src_offset,
+                               unsigned long *size,
+                               unsigned long *dst_offset)
+{
+       int tries = 0;
+
+       TRIM_OFF_LEN(*src_offset, *size, file_size);
+       if (bdy_align) {
+               *src_offset -= *src_offset % readbdy;
+               if (o_direct)
+                       *size -= *size % readbdy;
+       } else {
+               *src_offset = *src_offset & ~(block_size - 1);
+               *size = *size & ~(block_size - 1);
+       }
+
+       do {
+               if (tries++ >= 30) {
+                       *size = 0;
+                       break;
+               }
+               *dst_offset = random();
+               TRIM_OFF(*dst_offset, max_range_end);
+               if (bdy_align)
+                       *dst_offset -= *dst_offset % writebdy;
+               else
+                       *dst_offset = *dst_offset & ~(block_size - 1);
+       } while (range_overlaps(*src_offset, *dst_offset, *size) ||
+                *dst_offset + *size > max_range_end);
+}
+
 int
 test(void)
 {
@@ -2013,63 +2046,14 @@ test(void)
                        keep_size = random() % 2;
                break;
        case OP_CLONE_RANGE:
-               {
-                       int tries = 0;
-
-                       TRIM_OFF_LEN(offset, size, file_size);
-                       offset = offset & ~(block_size - 1);
-                       size = size & ~(block_size - 1);
-                       do {
-                               if (tries++ >= 30) {
-                                       size = 0;
-                                       break;
-                               }
-                               offset2 = random();
-                               TRIM_OFF(offset2, maxfilelen);
-                               offset2 = offset2 & ~(block_size - 1);
-                       } while (range_overlaps(offset, offset2, size) ||
-                                offset2 + size > maxfilelen);
-                       break;
-               }
+               generate_dest_range(false, maxfilelen, &offset, &size, &offset2);
+               break;
        case OP_DEDUPE_RANGE:
-               {
-                       int tries = 0;
-
-                       TRIM_OFF_LEN(offset, size, file_size);
-                       offset = offset & ~(block_size - 1);
-                       size = size & ~(block_size - 1);
-                       do {
-                               if (tries++ >= 30) {
-                                       size = 0;
-                                       break;
-                               }
-                               offset2 = random();
-                               TRIM_OFF(offset2, file_size);
-                               offset2 = offset2 & ~(block_size - 1);
-                       } while (range_overlaps(offset, offset2, size) ||
-                                offset2 + size > file_size);
-                       break;
-               }
+               generate_dest_range(false, file_size, &offset, &size, &offset2);
+               break;
        case OP_COPY_RANGE:
-               {
-                       int tries = 0;
-
-                       TRIM_OFF_LEN(offset, size, file_size);
-                       offset -= offset % readbdy;
-                       if (o_direct)
-                               size -= size % readbdy;
-                       do {
-                               if (tries++ >= 30) {
-                                       size = 0;
-                                       break;
-                               }
-                               offset2 = random();
-                               TRIM_OFF(offset2, maxfilelen);
-                               offset2 -= offset2 % writebdy;
-                       } while (range_overlaps(offset, offset2, size) ||
-                                offset2 + size > maxfilelen);
-                       break;
-               }
+               generate_dest_range(true, maxfilelen, &offset, &size, &offset2);
+               break;
        }
 
 have_op: