diff mbox

[v3,07/14] qemu-img: Use BlockBackend as far as possible

Message ID 1422284444-12529-8-git-send-email-mreitz@redhat.com
State New
Headers show

Commit Message

Max Reitz Jan. 26, 2015, 3 p.m. UTC 
Although qemu-img already creates BlockBackends, it does not do accesses
to the images through them. This patch converts all of the bdrv_* calls
for which this is currently possible to blk_* calls. Most of the
remaining calls will probably stay bdrv_* calls because they really do
operate on the BDS level instead of the BB level.

Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 qemu-img.c | 98 ++++++++++++++++++++++++++++++++++----------------------------
 1 file changed, 54 insertions(+), 44 deletions(-)

Comments

Eric Blake Jan. 27, 2015, 3:38 a.m. UTC | #1 
On 01/26/2015 08:00 AM, Max Reitz wrote:
> Although qemu-img already creates BlockBackends, it does not do accesses
> to the images through them. This patch converts all of the bdrv_* calls
> for which this is currently possible to blk_* calls. Most of the
> remaining calls will probably stay bdrv_* calls because they really do
> operate on the BDS level instead of the BB level.
> 
> Signed-off-by: Max Reitz <mreitz@redhat.com>
> ---
>  qemu-img.c | 98 ++++++++++++++++++++++++++++++++++----------------------------
>  1 file changed, 54 insertions(+), 44 deletions(-)
> 
> diff --git a/qemu-img.c b/qemu-img.c
> index 0b23c87..8b4139e 100644
> --- a/qemu-img.c

> @@ -1130,22 +1130,26 @@ static int img_compare(int argc, char **argv)
>      }
>      bs2 = blk_bs(blk2);
>  
> -    buf1 = qemu_blockalign(bs1, IO_BUF_SIZE);
> -    buf2 = qemu_blockalign(bs2, IO_BUF_SIZE);
> -    total_sectors1 = bdrv_nb_sectors(bs1);
> +    buf1 = blk_blockalign(blk1, IO_BUF_SIZE);
> +    buf2 = blk_blockalign(blk2, IO_BUF_SIZE);
> +    total_sectors1 = blk_getlength(blk1);
>      if (total_sectors1 < 0) {
>          error_report("Can't get size of %s: %s",
>                       filename1, strerror(-total_sectors1));
>          ret = 4;
>          goto out;
>      }
> -    total_sectors2 = bdrv_nb_sectors(bs2);
> +    total_sectors2 = blk_getlength(blk2);

The naming feels awkward; your conversion is now using bytes while the
old code was using sectors, so 'total_sectors2' feels weird...

>      if (total_sectors2 < 0) {
>          error_report("Can't get size of %s: %s",
>                       filename2, strerror(-total_sectors2));
>          ret = 4;
>          goto out;
>      }
> +
> +    total_sectors1 /= BDRV_SECTOR_SIZE;
> +    total_sectors2 /= BDRV_SECTOR_SIZE;

...at least you end up converting to sectors after all.  But it makes me
wonder if you should have blk_nb_sectors(), and/or temporary
intermediate variables to avoid cross-unit confusion.

> @@ -1476,13 +1480,14 @@ static int img_convert(int argc, char **argv)
>              goto out;
>          }
>          bs[bs_i] = blk_bs(blk[bs_i]);
> -        bs_sectors[bs_i] = bdrv_nb_sectors(bs[bs_i]);
> +        bs_sectors[bs_i] = blk_getlength(blk[bs_i]);
>          if (bs_sectors[bs_i] < 0) {
>              error_report("Could not get size of %s: %s",
>                           argv[optind + bs_i], strerror(-bs_sectors[bs_i]));
>              ret = -1;
>              goto out;
>          }
> +        bs_sectors[bs_i] /= BDRV_SECTOR_SIZE;

Another instance of the confusion.

>          total_sectors += bs_sectors[bs_i];
>      }
>  
> @@ -1625,16 +1630,19 @@ static int img_convert(int argc, char **argv)
>                                           out_bs->bl.discard_alignment))
>                      );
>  
> -    buf = qemu_blockalign(out_bs, bufsectors * BDRV_SECTOR_SIZE);
> +    buf = blk_blockalign(out_blk, bufsectors * BDRV_SECTOR_SIZE);
>  
>      if (skip_create) {
> -        int64_t output_sectors = bdrv_nb_sectors(out_bs);
> +        int64_t output_sectors = blk_getlength(out_blk);
>          if (output_sectors < 0) {
>              error_report("unable to get output image length: %s\n",
>                           strerror(-output_sectors));
>              ret = -1;
>              goto out;
> -        } else if (output_sectors < total_sectors) {
> +        }
> +
> +        output_sectors /= BDRV_SECTOR_SIZE;
> +        if (output_sectors < total_sectors) {

And another.

> @@ -2585,17 +2591,17 @@ static int img_rebase(int argc, char **argv)
>          uint8_t * buf_new;
>          float local_progress = 0;
>  
> -        buf_old = qemu_blockalign(bs, IO_BUF_SIZE);
> -        buf_new = qemu_blockalign(bs, IO_BUF_SIZE);
> +        buf_old = blk_blockalign(blk, IO_BUF_SIZE);
> +        buf_new = blk_blockalign(blk, IO_BUF_SIZE);
>  
> -        num_sectors = bdrv_nb_sectors(bs);
> +        num_sectors = blk_getlength(blk);
>          if (num_sectors < 0) {
...

> -        if (bs_new_backing) {
> -            new_backing_num_sectors = bdrv_nb_sectors(bs_new_backing);
> +
> +        num_sectors /= BDRV_SECTOR_SIZE;
> +        old_backing_num_sectors /= BDRV_SECTOR_SIZE;

and another.

I did not closely audit if there were any other conversions that should
have been made.  Also, I suspect that a blk_nb_sectors() as a pre-req
patch would make this one feel cleaner if you respin and rebase.  But if
we don't add blk_nb_sectors(), at least this version of the patch
appears to be clean with what it does, so you can consider this to be a
rather weak:

Reviewed-by: Eric Blake <eblake@redhat.com>
Max Reitz Jan. 27, 2015, 3:07 p.m. UTC | #2 
On 2015-01-26 at 22:38, Eric Blake wrote:
> On 01/26/2015 08:00 AM, Max Reitz wrote:
>> Although qemu-img already creates BlockBackends, it does not do accesses
>> to the images through them. This patch converts all of the bdrv_* calls
>> for which this is currently possible to blk_* calls. Most of the
>> remaining calls will probably stay bdrv_* calls because they really do
>> operate on the BDS level instead of the BB level.
>>
>> Signed-off-by: Max Reitz <mreitz@redhat.com>
>> ---
>>   qemu-img.c | 98 ++++++++++++++++++++++++++++++++++----------------------------
>>   1 file changed, 54 insertions(+), 44 deletions(-)
>>
>> diff --git a/qemu-img.c b/qemu-img.c
>> index 0b23c87..8b4139e 100644
>> --- a/qemu-img.c
>> @@ -1130,22 +1130,26 @@ static int img_compare(int argc, char **argv)
>>       }
>>       bs2 = blk_bs(blk2);
>>   
>> -    buf1 = qemu_blockalign(bs1, IO_BUF_SIZE);
>> -    buf2 = qemu_blockalign(bs2, IO_BUF_SIZE);
>> -    total_sectors1 = bdrv_nb_sectors(bs1);
>> +    buf1 = blk_blockalign(blk1, IO_BUF_SIZE);
>> +    buf2 = blk_blockalign(blk2, IO_BUF_SIZE);
>> +    total_sectors1 = blk_getlength(blk1);
>>       if (total_sectors1 < 0) {
>>           error_report("Can't get size of %s: %s",
>>                        filename1, strerror(-total_sectors1));
>>           ret = 4;
>>           goto out;
>>       }
>> -    total_sectors2 = bdrv_nb_sectors(bs2);
>> +    total_sectors2 = blk_getlength(blk2);
> The naming feels awkward; your conversion is now using bytes while the
> old code was using sectors, so 'total_sectors2' feels weird...
>
>>       if (total_sectors2 < 0) {
>>           error_report("Can't get size of %s: %s",
>>                        filename2, strerror(-total_sectors2));
>>           ret = 4;
>>           goto out;
>>       }
>> +
>> +    total_sectors1 /= BDRV_SECTOR_SIZE;
>> +    total_sectors2 /= BDRV_SECTOR_SIZE;
> ...at least you end up converting to sectors after all.  But it makes me
> wonder if you should have blk_nb_sectors(), and/or temporary
> intermediate variables to avoid cross-unit confusion.
>
>> @@ -1476,13 +1480,14 @@ static int img_convert(int argc, char **argv)
>>               goto out;
>>           }
>>           bs[bs_i] = blk_bs(blk[bs_i]);
>> -        bs_sectors[bs_i] = bdrv_nb_sectors(bs[bs_i]);
>> +        bs_sectors[bs_i] = blk_getlength(blk[bs_i]);
>>           if (bs_sectors[bs_i] < 0) {
>>               error_report("Could not get size of %s: %s",
>>                            argv[optind + bs_i], strerror(-bs_sectors[bs_i]));
>>               ret = -1;
>>               goto out;
>>           }
>> +        bs_sectors[bs_i] /= BDRV_SECTOR_SIZE;
> Another instance of the confusion.
>
>>           total_sectors += bs_sectors[bs_i];
>>       }
>>   
>> @@ -1625,16 +1630,19 @@ static int img_convert(int argc, char **argv)
>>                                            out_bs->bl.discard_alignment))
>>                       );
>>   
>> -    buf = qemu_blockalign(out_bs, bufsectors * BDRV_SECTOR_SIZE);
>> +    buf = blk_blockalign(out_blk, bufsectors * BDRV_SECTOR_SIZE);
>>   
>>       if (skip_create) {
>> -        int64_t output_sectors = bdrv_nb_sectors(out_bs);
>> +        int64_t output_sectors = blk_getlength(out_blk);
>>           if (output_sectors < 0) {
>>               error_report("unable to get output image length: %s\n",
>>                            strerror(-output_sectors));
>>               ret = -1;
>>               goto out;
>> -        } else if (output_sectors < total_sectors) {
>> +        }
>> +
>> +        output_sectors /= BDRV_SECTOR_SIZE;
>> +        if (output_sectors < total_sectors) {
> And another.
>
>> @@ -2585,17 +2591,17 @@ static int img_rebase(int argc, char **argv)
>>           uint8_t * buf_new;
>>           float local_progress = 0;
>>   
>> -        buf_old = qemu_blockalign(bs, IO_BUF_SIZE);
>> -        buf_new = qemu_blockalign(bs, IO_BUF_SIZE);
>> +        buf_old = blk_blockalign(blk, IO_BUF_SIZE);
>> +        buf_new = blk_blockalign(blk, IO_BUF_SIZE);
>>   
>> -        num_sectors = bdrv_nb_sectors(bs);
>> +        num_sectors = blk_getlength(blk);
>>           if (num_sectors < 0) {
> ...
>
>> -        if (bs_new_backing) {
>> -            new_backing_num_sectors = bdrv_nb_sectors(bs_new_backing);
>> +
>> +        num_sectors /= BDRV_SECTOR_SIZE;
>> +        old_backing_num_sectors /= BDRV_SECTOR_SIZE;
> and another.
>
> I did not closely audit if there were any other conversions that should
> have been made.  Also, I suspect that a blk_nb_sectors() as a pre-req
> patch would make this one feel cleaner if you respin and rebase.

The reason why I don't want to add blk_nb_sectors() is simply that we 
want to convert all the code to using bytes at a later point anyway, so 
I felt like it'd be a step backwards to introduce blk_nb_sectors().

However, I do see your point and intermediate variables probably don't 
make this any nicer. Also, if we get to convert the code to bytes, 
finding all instances of {blk,bdrv}_nb_sectors() will be one of the 
easier tasks, so I'll just introduce blk_nb_sectors().

Max

> But if
> we don't add blk_nb_sectors(), at least this version of the patch
> appears to be clean with what it does, so you can consider this to be a
> rather weak:
>
> Reviewed-by: Eric Blake <eblake@redhat.com>
>
diff mbox

Patch

diff --git a/qemu-img.c b/qemu-img.c
index 0b23c87..8b4139e 100644
--- a/qemu-img.c
+++ b/qemu-img.c
@@ -1008,19 +1008,19 @@  static int64_t sectors_to_process(int64_t total, int64_t from)
  * Returns 0 in case sectors are filled with 0, 1 if sectors contain non-zero
  * data and negative value on error.
  *
- * @param bs:  Driver used for accessing file
+ * @param blk:  BlockBackend for the image
  * @param sect_num: Number of first sector to check
  * @param sect_count: Number of sectors to check
  * @param filename: Name of disk file we are checking (logging purpose)
  * @param buffer: Allocated buffer for storing read data
  * @param quiet: Flag for quiet mode
  */
-static int check_empty_sectors(BlockDriverState *bs, int64_t sect_num,
+static int check_empty_sectors(BlockBackend *blk, int64_t sect_num,
                                int sect_count, const char *filename,
                                uint8_t *buffer, bool quiet)
 {
     int pnum, ret = 0;
-    ret = bdrv_read(bs, sect_num, buffer, sect_count);
+    ret = blk_read(blk, sect_num, buffer, sect_count);
     if (ret < 0) {
         error_report("Error while reading offset %" PRId64 " of %s: %s",
                      sectors_to_bytes(sect_num), filename, strerror(-ret));
@@ -1130,22 +1130,26 @@  static int img_compare(int argc, char **argv)
     }
     bs2 = blk_bs(blk2);
 
-    buf1 = qemu_blockalign(bs1, IO_BUF_SIZE);
-    buf2 = qemu_blockalign(bs2, IO_BUF_SIZE);
-    total_sectors1 = bdrv_nb_sectors(bs1);
+    buf1 = blk_blockalign(blk1, IO_BUF_SIZE);
+    buf2 = blk_blockalign(blk2, IO_BUF_SIZE);
+    total_sectors1 = blk_getlength(blk1);
     if (total_sectors1 < 0) {
         error_report("Can't get size of %s: %s",
                      filename1, strerror(-total_sectors1));
         ret = 4;
         goto out;
     }
-    total_sectors2 = bdrv_nb_sectors(bs2);
+    total_sectors2 = blk_getlength(blk2);
     if (total_sectors2 < 0) {
         error_report("Can't get size of %s: %s",
                      filename2, strerror(-total_sectors2));
         ret = 4;
         goto out;
     }
+
+    total_sectors1 /= BDRV_SECTOR_SIZE;
+    total_sectors2 /= BDRV_SECTOR_SIZE;
+
     total_sectors = MIN(total_sectors1, total_sectors2);
     progress_base = MAX(total_sectors1, total_sectors2);
 
@@ -1181,7 +1185,7 @@  static int img_compare(int argc, char **argv)
 
         if (allocated1 == allocated2) {
             if (allocated1) {
-                ret = bdrv_read(bs1, sector_num, buf1, nb_sectors);
+                ret = blk_read(blk1, sector_num, buf1, nb_sectors);
                 if (ret < 0) {
                     error_report("Error while reading offset %" PRId64 " of %s:"
                                  " %s", sectors_to_bytes(sector_num), filename1,
@@ -1189,7 +1193,7 @@  static int img_compare(int argc, char **argv)
                     ret = 4;
                     goto out;
                 }
-                ret = bdrv_read(bs2, sector_num, buf2, nb_sectors);
+                ret = blk_read(blk2, sector_num, buf2, nb_sectors);
                 if (ret < 0) {
                     error_report("Error while reading offset %" PRId64
                                  " of %s: %s", sectors_to_bytes(sector_num),
@@ -1216,10 +1220,10 @@  static int img_compare(int argc, char **argv)
             }
 
             if (allocated1) {
-                ret = check_empty_sectors(bs1, sector_num, nb_sectors,
+                ret = check_empty_sectors(blk1, sector_num, nb_sectors,
                                           filename1, buf1, quiet);
             } else {
-                ret = check_empty_sectors(bs2, sector_num, nb_sectors,
+                ret = check_empty_sectors(blk2, sector_num, nb_sectors,
                                           filename2, buf1, quiet);
             }
             if (ret) {
@@ -1236,18 +1240,18 @@  static int img_compare(int argc, char **argv)
     }
 
     if (total_sectors1 != total_sectors2) {
-        BlockDriverState *bs_over;
+        BlockBackend *blk_over;
         int64_t total_sectors_over;
         const char *filename_over;
 
         qprintf(quiet, "Warning: Image size mismatch!\n");
         if (total_sectors1 > total_sectors2) {
             total_sectors_over = total_sectors1;
-            bs_over = bs1;
+            blk_over = blk1;
             filename_over = filename1;
         } else {
             total_sectors_over = total_sectors2;
-            bs_over = bs2;
+            blk_over = blk2;
             filename_over = filename2;
         }
 
@@ -1256,7 +1260,7 @@  static int img_compare(int argc, char **argv)
             if (nb_sectors <= 0) {
                 break;
             }
-            ret = bdrv_is_allocated_above(bs_over, NULL, sector_num,
+            ret = bdrv_is_allocated_above(blk_bs(blk_over), NULL, sector_num,
                                           nb_sectors, &pnum);
             if (ret < 0) {
                 ret = 3;
@@ -1267,7 +1271,7 @@  static int img_compare(int argc, char **argv)
             }
             nb_sectors = pnum;
             if (ret) {
-                ret = check_empty_sectors(bs_over, sector_num, nb_sectors,
+                ret = check_empty_sectors(blk_over, sector_num, nb_sectors,
                                           filename_over, buf1, quiet);
                 if (ret) {
                     if (ret < 0) {
@@ -1476,13 +1480,14 @@  static int img_convert(int argc, char **argv)
             goto out;
         }
         bs[bs_i] = blk_bs(blk[bs_i]);
-        bs_sectors[bs_i] = bdrv_nb_sectors(bs[bs_i]);
+        bs_sectors[bs_i] = blk_getlength(blk[bs_i]);
         if (bs_sectors[bs_i] < 0) {
             error_report("Could not get size of %s: %s",
                          argv[optind + bs_i], strerror(-bs_sectors[bs_i]));
             ret = -1;
             goto out;
         }
+        bs_sectors[bs_i] /= BDRV_SECTOR_SIZE;
         total_sectors += bs_sectors[bs_i];
     }
 
@@ -1625,16 +1630,19 @@  static int img_convert(int argc, char **argv)
                                          out_bs->bl.discard_alignment))
                     );
 
-    buf = qemu_blockalign(out_bs, bufsectors * BDRV_SECTOR_SIZE);
+    buf = blk_blockalign(out_blk, bufsectors * BDRV_SECTOR_SIZE);
 
     if (skip_create) {
-        int64_t output_sectors = bdrv_nb_sectors(out_bs);
+        int64_t output_sectors = blk_getlength(out_blk);
         if (output_sectors < 0) {
             error_report("unable to get output image length: %s\n",
                          strerror(-output_sectors));
             ret = -1;
             goto out;
-        } else if (output_sectors < total_sectors) {
+        }
+
+        output_sectors /= BDRV_SECTOR_SIZE;
+        if (output_sectors < total_sectors) {
             error_report("output file is smaller than input file");
             ret = -1;
             goto out;
@@ -1696,7 +1704,7 @@  static int img_convert(int argc, char **argv)
                 nlow = remainder > bs_sectors[bs_i] - bs_num
                     ? bs_sectors[bs_i] - bs_num : remainder;
 
-                ret = bdrv_read(bs[bs_i], bs_num, buf2, nlow);
+                ret = blk_read(blk[bs_i], bs_num, buf2, nlow);
                 if (ret < 0) {
                     error_report("error while reading sector %" PRId64 ": %s",
                                  bs_num, strerror(-ret));
@@ -1711,7 +1719,7 @@  static int img_convert(int argc, char **argv)
             assert (remainder == 0);
 
             if (!buffer_is_zero(buf, n * BDRV_SECTOR_SIZE)) {
-                ret = bdrv_write_compressed(out_bs, sector_num, buf, n);
+                ret = blk_write_compressed(out_blk, sector_num, buf, n);
                 if (ret != 0) {
                     error_report("error while compressing sector %" PRId64
                                  ": %s", sector_num, strerror(-ret));
@@ -1722,7 +1730,7 @@  static int img_convert(int argc, char **argv)
             qemu_progress_print(100.0 * sector_num / total_sectors, 0);
         }
         /* signal EOF to align */
-        bdrv_write_compressed(out_bs, 0, NULL, 0);
+        blk_write_compressed(out_blk, 0, NULL, 0);
     } else {
         int64_t sectors_to_read, sectors_read, sector_num_next_status;
         bool count_allocated_sectors;
@@ -1823,7 +1831,7 @@  restart:
             }
 
             n1 = n;
-            ret = bdrv_read(bs[bs_i], sector_num - bs_offset, buf, n);
+            ret = blk_read(blk[bs_i], sector_num - bs_offset, buf, n);
             if (ret < 0) {
                 error_report("error while reading sector %" PRId64 ": %s",
                              sector_num - bs_offset, strerror(-ret));
@@ -1836,7 +1844,7 @@  restart:
             while (n > 0) {
                 if (!has_zero_init ||
                     is_allocated_sectors_min(buf1, n, &n1, min_sparse)) {
-                    ret = bdrv_write(out_bs, sector_num, buf1, n1);
+                    ret = blk_write(out_blk, sector_num, buf1, n1);
                     if (ret < 0) {
                         error_report("error while writing sector %" PRId64
                                      ": %s", sector_num, strerror(-ret));
@@ -2260,7 +2268,7 @@  static int img_map(int argc, char **argv)
         printf("%-16s%-16s%-16s%s\n", "Offset", "Length", "Mapped to", "File");
     }
 
-    length = bdrv_getlength(bs);
+    length = blk_getlength(blk);
     while (curr.start + curr.length < length) {
         int64_t nsectors_left;
         int64_t sector_num;
@@ -2429,7 +2437,7 @@  static int img_snapshot(int argc, char **argv)
 static int img_rebase(int argc, char **argv)
 {
     BlockBackend *blk = NULL, *blk_old_backing = NULL, *blk_new_backing = NULL;
-    BlockDriverState *bs = NULL, *bs_old_backing = NULL, *bs_new_backing = NULL;
+    BlockDriverState *bs = NULL;
     char *filename;
     const char *fmt, *cache, *src_cache, *out_basefmt, *out_baseimg;
     int c, flags, src_flags, ret;
@@ -2543,7 +2551,6 @@  static int img_rebase(int argc, char **argv)
             error_free(local_err);
             goto out;
         }
-        bs_old_backing = blk_bs(blk_old_backing);
 
         if (out_baseimg[0]) {
             if (out_basefmt) {
@@ -2562,7 +2569,6 @@  static int img_rebase(int argc, char **argv)
                 error_free(local_err);
                 goto out;
             }
-            bs_new_backing = blk_bs(blk_new_backing);
         }
     }
 
@@ -2585,17 +2591,17 @@  static int img_rebase(int argc, char **argv)
         uint8_t * buf_new;
         float local_progress = 0;
 
-        buf_old = qemu_blockalign(bs, IO_BUF_SIZE);
-        buf_new = qemu_blockalign(bs, IO_BUF_SIZE);
+        buf_old = blk_blockalign(blk, IO_BUF_SIZE);
+        buf_new = blk_blockalign(blk, IO_BUF_SIZE);
 
-        num_sectors = bdrv_nb_sectors(bs);
+        num_sectors = blk_getlength(blk);
         if (num_sectors < 0) {
             error_report("Could not get size of '%s': %s",
                          filename, strerror(-num_sectors));
             ret = -1;
             goto out;
         }
-        old_backing_num_sectors = bdrv_nb_sectors(bs_old_backing);
+        old_backing_num_sectors = blk_getlength(blk_old_backing);
         if (old_backing_num_sectors < 0) {
             char backing_name[PATH_MAX];
 
@@ -2605,14 +2611,20 @@  static int img_rebase(int argc, char **argv)
             ret = -1;
             goto out;
         }
-        if (bs_new_backing) {
-            new_backing_num_sectors = bdrv_nb_sectors(bs_new_backing);
+
+        num_sectors /= BDRV_SECTOR_SIZE;
+        old_backing_num_sectors /= BDRV_SECTOR_SIZE;
+
+        if (blk_new_backing) {
+            new_backing_num_sectors = blk_getlength(blk_new_backing);
             if (new_backing_num_sectors < 0) {
                 error_report("Could not get size of '%s': %s",
                              out_baseimg, strerror(-new_backing_num_sectors));
                 ret = -1;
                 goto out;
             }
+
+            new_backing_num_sectors /= BDRV_SECTOR_SIZE;
         }
 
         if (num_sectors != 0) {
@@ -2651,21 +2663,21 @@  static int img_rebase(int argc, char **argv)
                     n = old_backing_num_sectors - sector;
                 }
 
-                ret = bdrv_read(bs_old_backing, sector, buf_old, n);
+                ret = blk_read(blk_old_backing, sector, buf_old, n);
                 if (ret < 0) {
                     error_report("error while reading from old backing file");
                     goto out;
                 }
             }
 
-            if (sector >= new_backing_num_sectors || !bs_new_backing) {
+            if (sector >= new_backing_num_sectors || !blk_new_backing) {
                 memset(buf_new, 0, n * BDRV_SECTOR_SIZE);
             } else {
                 if (sector + n > new_backing_num_sectors) {
                     n = new_backing_num_sectors - sector;
                 }
 
-                ret = bdrv_read(bs_new_backing, sector, buf_new, n);
+                ret = blk_read(blk_new_backing, sector, buf_new, n);
                 if (ret < 0) {
                     error_report("error while reading from new backing file");
                     goto out;
@@ -2681,8 +2693,8 @@  static int img_rebase(int argc, char **argv)
                 if (compare_sectors(buf_old + written * 512,
                     buf_new + written * 512, n - written, &pnum))
                 {
-                    ret = bdrv_write(bs, sector + written,
-                        buf_old + written * 512, pnum);
+                    ret = blk_write(blk, sector + written,
+                                    buf_old + written * 512, pnum);
                     if (ret < 0) {
                         error_report("Error while writing to COW image: %s",
                             strerror(-ret));
@@ -2747,7 +2759,6 @@  static int img_resize(int argc, char **argv)
     int64_t n, total_size;
     bool quiet = false;
     BlockBackend *blk = NULL;
-    BlockDriverState *bs = NULL;
     QemuOpts *param;
     static QemuOptsList resize_options = {
         .name = "resize_options",
@@ -2829,10 +2840,9 @@  static int img_resize(int argc, char **argv)
         ret = -1;
         goto out;
     }
-    bs = blk_bs(blk);
 
     if (relative) {
-        total_size = bdrv_getlength(bs) + n * relative;
+        total_size = blk_getlength(blk) + n * relative;
     } else {
         total_size = n;
     }
@@ -2842,7 +2852,7 @@  static int img_resize(int argc, char **argv)
         goto out;
     }
 
-    ret = bdrv_truncate(bs, total_size);
+    ret = blk_truncate(blk, total_size);
     switch (ret) {
     case 0:
         qprintf(quiet, "Image resized.\n");