Skip to contentSkip to conversation

fsx: move range generation logic into a common helper

PATCH In review [email protected] 3 participants 10 messages Apr 8, 2020 – Apr 20, 2020 Btrfs file system

lore
Share & tools
lore
#0 lore raw

PATCH 4/4 fsx: move range generation logic into a common helper

From: Filipe Manana <[email protected]>

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.

---
 ltp/fsx.c | 91 +++++++++++++++++++++++++--------------------------------------
 1 file changed, 36 insertions(+), 55 deletions(-)
ltp/fsx.c +36 -55
index 89a5f60e..8873cd01 100644
@@ -1930,6 +1930,36 @@ range_overlaps(
 	return llabs((unsigned long long)off1 - off0) < size;
 }
 
+static void generate_dest_range(unsigned long op,
+				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 (op == OP_COPY_RANGE) {
+		*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);
+		*dst_offset = *dst_offset & ~(block_size - 1);
+	} while (range_overlaps(*src_offset, *dst_offset, *size) ||
+		 *dst_offset + *size > max_range_end);
+}
+
 int
 test(void)
 {
@@ -2004,63 +2034,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(op, 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(op, 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(op, maxfilelen, &offset, &size, &offset2);
+		break;
 	}
 
 have_op:
Signature · 1 line
2.11.0
#1 lore raw
Quoted 19 lines · On Wed, Apr 08, 2020 at 11:36:27AM +0100, [email protected] wrote:

From: Filipe Manana <[email protected]>

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.

---
 ltp/fsx.c | 91 +++++++++++++++++++++++++--------------------------------------
 1 file changed, 36 insertions(+), 55 deletions(-)
ltp/fsx.c +0 -0
index 89a5f60e..8873cd01 100644
@@ -1930,6 +1930,36 @@ range_overlaps(
 	return llabs((unsigned long long)off1 - off0) < size;
 }
 

ltp/fsx.c range_overlaps( · line 1942

Quoted 10 lines
ltp/fsx.c +10 -0
+static void generate_dest_range(unsigned long op,
+				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 (op == OP_COPY_RANGE) {

It feels funny that we pass in @op just to let COPY RANGE relax the block size alignment requirements. How about passing a block_align parameter (instead of op) which would be the subject of the if test? This way we concentrate the alignment requirement knowlege of each type of call in the "case OP_FOO" part of the code instead of scattering it?

--D

Quoted 96 lines
ltp/fsx.c +26 -55
+		*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);
+		*dst_offset = *dst_offset & ~(block_size - 1);
+	} while (range_overlaps(*src_offset, *dst_offset, *size) ||
+		 *dst_offset + *size > max_range_end);
+}
+
 int
 test(void)
 {
@@ -2004,63 +2034,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(op, 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(op, 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(op, maxfilelen, &offset, &size, &offset2);
+		break;
 	}
 
 have_op:
Signature · 1 line
2.11.0
#2 lore raw
Quoted 21 lines · Darrick J. Wong
Quoted 19 lines · On Wed, Apr 08, 2020 at 11:36:27AM +0100, [email protected] wrote:

From: Filipe Manana <[email protected]>

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.

---
 ltp/fsx.c | 91 +++++++++++++++++++++++++--------------------------------------
 1 file changed, 36 insertions(+), 55 deletions(-)
ltp/fsx.c +0 -0
index 89a5f60e..8873cd01 100644
@@ -1930,6 +1930,36 @@ range_overlaps(
      return llabs((unsigned long long)off1 - off0) < size;
 }
 
Quoted 16 lines

ltp/fsx.c range_overlaps( · line 1942

Quoted 10 lines
ltp/fsx.c +10 -0
+static void generate_dest_range(unsigned long op,
+                             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 (op == OP_COPY_RANGE) {

It feels funny that we pass in @op just to let COPY RANGE relax the block size alignment requirements. How about passing a block_align parameter (instead of op) which would be the subject of the if test? This way we concentrate the alignment requirement knowlege of each type of call in the "case OP_FOO" part of the code instead of scattering it?

You mean something like the following:

https://pastebin.com/e2NZKbZV

?

Quoted 99 lines

--D

Quoted 96 lines
ltp/fsx.c +26 -56
+             *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);
+             *dst_offset = *dst_offset & ~(block_size - 1);
+     } while (range_overlaps(*src_offset, *dst_offset, *size) ||
+              *dst_offset + *size > max_range_end);
+}
+
 int
 test(void)
 {
@@ -2004,63 +2034,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(op, 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(op, 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(op, maxfilelen, &offset, &size, &offset2);
+             break;
      }
 
 have_op:
--

2.11.0

#3 lore raw
Quoted 39 lines · Filipe Manana
Quoted 21 lines · Darrick J. Wong
Quoted 19 lines · On Wed, Apr 08, 2020 at 11:36:27AM +0100, [email protected] wrote:

From: Filipe Manana <[email protected]>

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.

---
 ltp/fsx.c | 91 +++++++++++++++++++++++++--------------------------------------
 1 file changed, 36 insertions(+), 55 deletions(-)
ltp/fsx.c +0 -0
index 89a5f60e..8873cd01 100644
@@ -1930,6 +1930,36 @@ range_overlaps(
      return llabs((unsigned long long)off1 - off0) < size;
 }
 
Quoted 16 lines

ltp/fsx.c range_overlaps( · line 1942

Quoted 10 lines
ltp/fsx.c +10 -0
+static void generate_dest_range(unsigned long op,
+                             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 (op == OP_COPY_RANGE) {

It feels funny that we pass in @op just to let COPY RANGE relax the block size alignment requirements. How about passing a block_align parameter (instead of op) which would be the subject of the if test? This way we concentrate the alignment requirement knowlege of each type of call in the "case OP_FOO" part of the code instead of scattering it?

Quoted 5 lines

You mean something like the following:

https://pastebin.com/e2NZKbZV

?

Yep.

--D

Quoted 101 lines
Quoted 101 lines

--D

Quoted 96 lines
ltp/fsx.c +26 -56
+             *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);
+             *dst_offset = *dst_offset & ~(block_size - 1);
+     } while (range_overlaps(*src_offset, *dst_offset, *size) ||
+              *dst_offset + *size > max_range_end);
+}
+
 int
 test(void)
 {
@@ -2004,63 +2034,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(op, 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(op, 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(op, maxfilelen, &offset, &size, &offset2);
+             break;
      }
 
 have_op:
--

2.11.0

#4 lore raw

PATCH v2 4/4 fsx: move range generation logic into a common helper

In reply to [email protected]

From: Filipe Manana <[email protected]>

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.

---

V2: Turned the first parameter of the helper into a boolean as Darrick suggested.

 ltp/fsx.c | 91 +++++++++++++++++++++++++--------------------------------------
 1 file changed, 36 insertions(+), 55 deletions(-)
ltp/fsx.c +36 -55
index 89a5f60e..9bfc98e0 100644
@@ -1930,6 +1930,36 @@ range_overlaps(
 	return llabs((unsigned long long)off1 - off0) < size;
 }
 
+static void generate_dest_range(bool readbdy_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 (readbdy_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);
+		*dst_offset = *dst_offset & ~(block_size - 1);
+	} while (range_overlaps(*src_offset, *dst_offset, *size) ||
+		 *dst_offset + *size > max_range_end);
+}
+
 int
 test(void)
 {
@@ -2004,63 +2034,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:
Signature · 1 line
2.11.0
#5 lore raw
Quoted 18 lines · On Wed, Apr 08, 2020 at 07:12:08PM +0100, [email protected] wrote:

From: Filipe Manana <[email protected]>

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.

---

V2: Turned the first parameter of the helper into a boolean as Darrick suggested.

 ltp/fsx.c | 91 +++++++++++++++++++++++++--------------------------------------
 1 file changed, 36 insertions(+), 55 deletions(-)
ltp/fsx.c +0 -0
index 89a5f60e..9bfc98e0 100644

...

Quoted 3 lines
ltp/fsx.c +0 -0
@@ -2004,63 +2034,14 @@ test(void)
 			keep_size = random() % 2;
 		break;

...

Quoted 6 lines
ltp/fsx.c +0 -5
 	case OP_COPY_RANGE:
-		{
-			int tries = 0;
-
-			TRIM_OFF_LEN(offset, size, file_size);
-			offset -= offset % readbdy;

ltp/fsx.c test(void) · line 2059

Quoted 10 lines
ltp/fsx.c +0 -10
-			if (o_direct)
-				size -= size % readbdy;
-			do {
-				if (tries++ >= 30) {
-					size = 0;
-					break;
-				}
-				offset2 = random();
-				TRIM_OFF(offset2, maxfilelen);
-				offset2 -= offset2 % writebdy;

It looks like this writebdy bit is lost in the new helper...

Brian

Quoted 12 lines
ltp/fsx.c +2 -4
-			} while (range_overlaps(offset, offset2, size) ||
-				 offset2 + size > maxfilelen);
-			break;
-		}
+		generate_dest_range(true, maxfilelen, &offset, &size, &offset2);
+		break;
 	}
 
 have_op:
Signature · 1 line
2.11.0
#6 lore raw
Quoted 42 lines · Brian Foster
Quoted 18 lines · On Wed, Apr 08, 2020 at 07:12:08PM +0100, [email protected] wrote:

From: Filipe Manana <[email protected]>

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.

---

V2: Turned the first parameter of the helper into a boolean as Darrick suggested.

 ltp/fsx.c | 91 +++++++++++++++++++++++++--------------------------------------
 1 file changed, 36 insertions(+), 55 deletions(-)
ltp/fsx.c +0 -0
index 89a5f60e..9bfc98e0 100644

...

Quoted 3 lines
ltp/fsx.c +0 -0
@@ -2004,63 +2034,14 @@ test(void)
                      keep_size = random() % 2;
              break;

...

Quoted 6 lines

case OP_COPY_RANGE:

ltp/fsx.c +0 -5
-             {
-                     int tries = 0;
-
-                     TRIM_OFF_LEN(offset, size, file_size);
-                     offset -= offset % readbdy;

ltp/fsx.c test(void) · line 2059

Quoted 10 lines
ltp/fsx.c +0 -10
-                     if (o_direct)
-                             size -= size % readbdy;
-                     do {
-                             if (tries++ >= 30) {
-                                     size = 0;
-                                     break;
-                             }
-                             offset2 = random();
-                             TRIM_OFF(offset2, maxfilelen);
-                             offset2 -= offset2 % writebdy;
Quoted 1 line

It looks like this writebdy bit is lost in the new helper...

Yes, thanks for pointing out. I'll send a v3.

Quoted 16 lines

Brian

Quoted 12 lines
ltp/fsx.c +2 -5
-                     } while (range_overlaps(offset, offset2, size) ||
-                              offset2 + size > maxfilelen);
-                     break;
-             }
+             generate_dest_range(true, maxfilelen, &offset, &size, &offset2);
+             break;
      }
 
 have_op:
--

2.11.0

#7 lore raw

PATCH 4/4 fsx: move range generation logic into a common helper

In reply to [email protected]

From: Filipe Manana <[email protected]>

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.

---

V2: Turned the first parameter of the helper into a boolean as Darrick suggested.
V3: Added destination offset align by writebdy when bdy_align is true.

 ltp/fsx.c | 94 ++++++++++++++++++++++++++-------------------------------------
 1 file changed, 39 insertions(+), 55 deletions(-)
ltp/fsx.c +39 -55
index 89a5f60e..2e51169b 100644
@@ -1930,6 +1930,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)
 {
@@ -2004,63 +2037,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:
Signature · 1 line
2.11.0
#8 lore raw
Quoted 40 lines · On Fri, Apr 17, 2020 at 06:32:21PM +0100, [email protected] wrote:

From: Filipe Manana <[email protected]>

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.

---

V2: Turned the first parameter of the helper into a boolean as Darrick suggested.
V3: Added destination offset align by writebdy when bdy_align is true.

 ltp/fsx.c | 94 ++++++++++++++++++++++++++-------------------------------------
 1 file changed, 39 insertions(+), 55 deletions(-)
ltp/fsx.c +17 -0
index 89a5f60e..2e51169b 100644
@@ -1930,6 +1930,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);
+	}

ltp/fsx.c range_overlaps( · line 1959

Quoted 10 lines
ltp/fsx.c +10 -0
+
+	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;

That still doesn't look right (and either way we might as well use consistent logic for readbdy and writebdy).

Brian

Quoted 82 lines
ltp/fsx.c +12 -55
+		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)
 {
@@ -2004,63 +2037,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:
Signature · 1 line
2.11.0
#9 lore raw
Quoted 47 lines · Brian Foster
Quoted 45 lines · On Fri, Apr 17, 2020 at 06:32:21PM +0100, [email protected] wrote:

From: Filipe Manana <[email protected]>

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.

---

V2: Turned the first parameter of the helper into a boolean as Darrick suggested.
V3: Added destination offset align by writebdy when bdy_align is true.

 ltp/fsx.c | 94 ++++++++++++++++++++++++++-------------------------------------
 1 file changed, 39 insertions(+), 55 deletions(-)
ltp/fsx.c +22 -0
index 89a5f60e..2e51169b 100644
@@ -1930,6 +1930,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;
Quoted 8 lines

ltp/fsx.c range_overlaps( · line 1959

Quoted 5 lines
ltp/fsx.c +5 -0
+             }
+             *dst_offset = random();
+             TRIM_OFF(*dst_offset, max_range_end);
+             if (bdy_align)
+                     *dst_offset = *dst_offset & writebdy;

That still doesn't look right (and either way we might as well use consistent logic for readbdy and writebdy).

Right, I made the mistakes of using & instead of % and = instead of -=. They were not intentional, just a friday afternoon type of thing. Thanks, correct in the next version.

Quoted 86 lines

Brian

Quoted 82 lines
ltp/fsx.c +12 -56
+             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)
 {
@@ -2004,63 +2037,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:
--

2.11.0