fsx: move range generation logic into a common helper
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
@@ -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
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_rangeoperations, so avoid duplicating the code three times and move it into a helper function.Signed-off-by Filipe Manana <[email protected]>--- ltp/fsx.c | 91 +++++++++++++++++++++++++-------------------------------------- 1 file changed, 36 insertions(+), 55 deletions(-)ltp/fsx.c +0
-0@@ -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
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_rangeoperations, so avoid duplicating the code three times and move it into a helper function.Signed-off-by Filipe Manana <[email protected]>--- ltp/fsx.c | 91 +++++++++++++++++++++++++-------------------------------------- 1 file changed, 36 insertions(+), 55 deletions(-)ltp/fsx.c +0
-0@@ -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_alignparameter (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 "caseOP_FOO" part of the code instead of scattering it?
You mean something like the following:
?
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
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_rangeoperations, so avoid duplicating the code three times and move it into a helper function.Signed-off-by Filipe Manana <[email protected]>--- ltp/fsx.c | 91 +++++++++++++++++++++++++-------------------------------------- 1 file changed, 36 insertions(+), 55 deletions(-)ltp/fsx.c +0
-0@@ -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_alignparameter (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 "caseOP_FOO" part of the code instead of scattering it?
Quoted 5 lines
You mean something like the following:
?
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
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
@@ -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
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_rangeoperations, so avoid duplicating the code three times and move it into a helper function.Signed-off-by Filipe Manana <[email protected]>---
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
...
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
-5case 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
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_rangeoperations, so avoid duplicating the code three times and move it into a helper function.Signed-off-by Filipe Manana <[email protected]>---
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...
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
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
@@ -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
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_rangeoperations, so avoid duplicating the code three times and move it into a helper function.Signed-off-by Filipe Manana <[email protected]>---
V2: Turned the first parameter of the helper into a boolean as Darrick suggested.
V3: Added destination offset align by writebdy whenbdy_alignis true.ltp/fsx.c | 94 ++++++++++++++++++++++++++------------------------------------- 1 file changed, 39 insertions(+), 55 deletions(-)ltp/fsx.c +17
-0@@ -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
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_rangeoperations, so avoid duplicating the code three times and move it into a helper function.Signed-off-by Filipe Manana <[email protected]>---
V2: Turned the first parameter of the helper into a boolean as Darrick suggested.
V3: Added destination offset align by writebdy whenbdy_alignis true.ltp/fsx.c | 94 ++++++++++++++++++++++++++------------------------------------- 1 file changed, 39 insertions(+), 55 deletions(-)ltp/fsx.c +22
-0@@ -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