sheepdog: do not blindly memset all read buffers

[qemu.git] / qemu-img.c

diff --git a/qemu-img.c b/qemu-img.c
index 86127f0b1142fc976f5864efc7d79c51f669f4f0..80cfb9b167a428ea3dab7c9c9c768c2e2f33c867 100644 (file)
--- a/qemu-img.c
+++ b/qemu-img.c
@@ -66,8 +66,8 @@ static void help(void)
            "  'filename' is a disk image filename\n"
            "  'fmt' is the disk image format. It is guessed automatically in most cases\n"
            "  'cache' is the cache mode used to write the output disk image, the valid\n"
            "  'filename' is a disk image filename\n"
            "  'fmt' is the disk image format. It is guessed automatically in most cases\n"
            "  'cache' is the cache mode used to write the output disk image, the valid\n"

-           "    options are: 'none', 'writeback' (default), 'writethrough', 'directsync'\n"
-           "    and 'unsafe'\n"
+           "    options are: 'none', 'writeback' (default, except for convert), 'writethrough',\n"
+           "    'directsync' and 'unsafe' (default for convert)\n"

            "  'size' is the disk image size in bytes. Optional suffixes\n"
            "    'k' or 'K' (kilobyte, 1024), 'M' (megabyte, 1024k), 'G' (gigabyte, 1024M)\n"
            "    and T (terabyte, 1024G) are supported. 'b' is ignored.\n"
            "  'size' is the disk image size in bytes. Optional suffixes\n"
            "    'k' or 'K' (kilobyte, 1024), 'M' (megabyte, 1024k), 'G' (gigabyte, 1024M)\n"
            "    and T (terabyte, 1024G) are supported. 'b' is ignored.\n"


@@ -85,6 +85,12 @@ static void help(void)
            "  '-S' indicates the consecutive number of bytes that must contain only zeros\n"
            "       for qemu-img to create a sparse image during conversion\n"
            "\n"
            "  '-S' indicates the consecutive number of bytes that must contain only zeros\n"
            "       for qemu-img to create a sparse image during conversion\n"
            "\n"

+           "Parameters to check subcommand:\n"
+           "  '-r' tries to repair any inconsistencies that are found during the check.\n"
+           "       '-r leaks' repairs only cluster leaks, whereas '-r all' fixes all\n"
+           "       kinds of errors, with a higher risk of choosing the wrong fix or\n"
+           "       hiding corruption that has already occured.\n"
+           "\n"

            "Parameters to snapshot subcommand:\n"
            "  'snapshot' is the name of the snapshot to create, apply or delete\n"
            "  '-a' applies a snapshot (revert disk to saved state)\n"
            "Parameters to snapshot subcommand:\n"
            "  'snapshot' is the name of the snapshot to create, apply or delete\n"
            "  '-a' applies a snapshot (revert disk to saved state)\n"


@@ -332,8 +338,9 @@ static int img_create(int argc, char **argv)
     /* Get image size, if specified */
     if (optind < argc) {
         int64_t sval;
     /* Get image size, if specified */
     if (optind < argc) {
         int64_t sval;

-        sval = strtosz_suffix(argv[optind++], NULL, STRTOSZ_DEFSUFFIX_B);
-        if (sval < 0) {
+        char *end;
+        sval = strtosz_suffix(argv[optind++], &end, STRTOSZ_DEFSUFFIX_B);
+        if (sval < 0 || *end) {

             error_report("Invalid image size specified! You may use k, M, G or "
                   "T suffixes for ");
             error_report("kilobytes, megabytes, gigabytes and terabytes.");
             error_report("Invalid image size specified! You may use k, M, G or "
                   "T suffixes for ");
             error_report("kilobytes, megabytes, gigabytes and terabytes.");


@@ -371,10 +378,12 @@ static int img_check(int argc, char **argv)
     const char *filename, *fmt;
     BlockDriverState *bs;
     BdrvCheckResult result;
     const char *filename, *fmt;
     BlockDriverState *bs;
     BdrvCheckResult result;

+    int fix = 0;
+    int flags = BDRV_O_FLAGS;

 
     fmt = NULL;
     for(;;) {
 
     fmt = NULL;
     for(;;) {

-        c = getopt(argc, argv, "f:h");
+        c = getopt(argc, argv, "f:hr:");

         if (c == -1) {
             break;
         }
         if (c == -1) {
             break;
         }


@@ -386,6 +395,17 @@ static int img_check(int argc, char **argv)
         case 'f':
             fmt = optarg;
             break;
         case 'f':
             fmt = optarg;
             break;

+        case 'r':
+            flags |= BDRV_O_RDWR;
+
+            if (!strcmp(optarg, "leaks")) {
+                fix = BDRV_FIX_LEAKS;
+            } else if (!strcmp(optarg, "all")) {
+                fix = BDRV_FIX_LEAKS | BDRV_FIX_ERRORS;
+            } else {
+                help();
+            }
+            break;

         }
     }
     if (optind >= argc) {
         }
     }
     if (optind >= argc) {


@@ -393,11 +413,11 @@ static int img_check(int argc, char **argv)
     }
     filename = argv[optind++];
 
     }
     filename = argv[optind++];
 

-    bs = bdrv_new_open(filename, fmt, BDRV_O_FLAGS);
+    bs = bdrv_new_open(filename, fmt, flags);

     if (!bs) {
         return 1;
     }
     if (!bs) {
         return 1;
     }

-    ret = bdrv_check(bs, &result);
+    ret = bdrv_check(bs, &result, fix);

 
     if (ret == -ENOTSUP) {
         error_report("This image format does not support checks");
 
     if (ret == -ENOTSUP) {
         error_report("This image format does not support checks");


@@ -405,6 +425,16 @@ static int img_check(int argc, char **argv)
         return 1;
     }
 
         return 1;
     }
 

+    if (result.corruptions_fixed || result.leaks_fixed) {
+        printf("The following inconsistencies were found and repaired:\n\n"
+               "    %d leaked clusters\n"
+               "    %d corruptions\n\n"
+               "Double checking the fixed image now...\n",
+               result.leaks_fixed,
+               result.corruptions_fixed);
+        ret = bdrv_check(bs, &result, 0);
+    }
+

     if (!(result.corruptions || result.leaks || result.check_errors)) {
         printf("No errors were found on the image.\n");
     } else {
     if (!(result.corruptions || result.leaks || result.check_errors)) {
         printf("No errors were found on the image.\n");
     } else {


@@ -427,6 +457,13 @@ static int img_check(int argc, char **argv)
         }
     }
 
         }
     }
 

+    if (result.bfi.total_clusters != 0 && result.bfi.allocated_clusters != 0) {
+        printf("%" PRId64 "/%" PRId64 "= %0.2f%% allocated, %0.2f%% fragmented\n",
+        result.bfi.allocated_clusters, result.bfi.total_clusters,
+        result.bfi.allocated_clusters * 100.0 / result.bfi.total_clusters,
+        result.bfi.fragmented_clusters * 100.0 / result.bfi.allocated_clusters);
+    }
+

     bdrv_delete(bs);
 
     if (ret < 0 || result.check_errors) {
     bdrv_delete(bs);
 
     if (ret < 0 || result.check_errors) {


@@ -513,40 +550,6 @@ static int img_commit(int argc, char **argv)
     return 0;
 }
 
     return 0;
 }
 

-/*
- * Checks whether the sector is not a zero sector.
- *
- * Attention! The len must be a multiple of 4 * sizeof(long) due to
- * restriction of optimizations in this function.
- */
-static int is_not_zero(const uint8_t *sector, int len)
-{
-    /*
-     * Use long as the biggest available internal data type that fits into the
-     * CPU register and unroll the loop to smooth out the effect of memory
-     * latency.
-     */
-
-    int i;
-    long d0, d1, d2, d3;
-    const long * const data = (const long *) sector;
-
-    len /= sizeof(long);
-
-    for(i = 0; i < len; i += 4) {
-        d0 = data[i + 0];
-        d1 = data[i + 1];
-        d2 = data[i + 2];
-        d3 = data[i + 3];
-
-        if (d0 || d1 || d2 || d3) {
-            return 1;
-        }
-    }
-
-    return 0;
-}
-

 /*
  * Returns true iff the first sector pointed to by 'buf' contains at least
  * a non-NUL byte.
 /*
  * Returns true iff the first sector pointed to by 'buf' contains at least
  * a non-NUL byte.


@@ -556,20 +559,22 @@ static int is_not_zero(const uint8_t *sector, int len)
  */
 static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
 {
  */
 static int is_allocated_sectors(const uint8_t *buf, int n, int *pnum)
 {

-    int v, i;
+    bool is_zero;
+    int i;

 
     if (n <= 0) {
         *pnum = 0;
         return 0;
     }
 
     if (n <= 0) {
         *pnum = 0;
         return 0;
     }

-    v = is_not_zero(buf, 512);
+    is_zero = buffer_is_zero(buf, 512);

     for(i = 1; i < n; i++) {
         buf += 512;
     for(i = 1; i < n; i++) {
         buf += 512;

-        if (v != is_not_zero(buf, 512))
+        if (is_zero != buffer_is_zero(buf, 512)) {

             break;
             break;

+        }

     }
     *pnum = i;
     }
     *pnum = i;

-    return v;
+    return !is_zero;

 }
 
 /*
 }
 
 /*


@@ -710,8 +715,9 @@ static int img_convert(int argc, char **argv)
         case 'S':
         {
             int64_t sval;
         case 'S':
         {
             int64_t sval;

-            sval = strtosz_suffix(optarg, NULL, STRTOSZ_DEFSUFFIX_B);
-            if (sval < 0) {
+            char *end;
+            sval = strtosz_suffix(optarg, &end, STRTOSZ_DEFSUFFIX_B);
+            if (sval < 0 || *end) {

                 error_report("Invalid minimum zero buffer size for sparse output specified");
                 return 1;
             }
                 error_report("Invalid minimum zero buffer size for sparse output specified");
                 return 1;
             }


@@ -735,6 +741,9 @@ static int img_convert(int argc, char **argv)
 
     out_filename = argv[argc - 1];
 
 
     out_filename = argv[argc - 1];
 

+    /* Initialize before goto out */
+    qemu_progress_init(progress, 2.0);
+

     if (options && !strcmp(options, "?")) {
         ret = print_block_option_help(out_filename, out_fmt);
         goto out;
     if (options && !strcmp(options, "?")) {
         ret = print_block_option_help(out_filename, out_fmt);
         goto out;


@@ -746,8 +755,7 @@ static int img_convert(int argc, char **argv)
         ret = -1;
         goto out;
     }
         ret = -1;
         goto out;
     }

-        
-    qemu_progress_init(progress, 2.0);
+

     qemu_progress_print(0, 100);
 
     bs = g_malloc0(bs_n * sizeof(BlockDriverState *));
     qemu_progress_print(0, 100);
 
     bs = g_malloc0(bs_n * sizeof(BlockDriverState *));


@@ -953,7 +961,7 @@ static int img_convert(int argc, char **argv)
             if (n < cluster_sectors) {
                 memset(buf + n * 512, 0, cluster_size - n * 512);
             }
             if (n < cluster_sectors) {
                 memset(buf + n * 512, 0, cluster_size - n * 512);
             }

-            if (is_not_zero(buf, cluster_size)) {
+            if (!buffer_is_zero(buf, cluster_size)) {

                 ret = bdrv_write_compressed(out_bs, sector_num, buf,
                                             cluster_sectors);
                 if (ret != 0) {
                 ret = bdrv_write_compressed(out_bs, sector_num, buf,
                                             cluster_sectors);
                 if (ret != 0) {


@@ -1099,7 +1107,7 @@ static int img_info(int argc, char **argv)
     int c;
     const char *filename, *fmt;
     BlockDriverState *bs;
     int c;
     const char *filename, *fmt;
     BlockDriverState *bs;

-    char fmt_name[128], size_buf[128], dsize_buf[128];
+    char size_buf[128], dsize_buf[128];

     uint64_t total_sectors;
     int64_t allocated_size;
     char backing_filename[1024];
     uint64_t total_sectors;
     int64_t allocated_size;
     char backing_filename[1024];


@@ -1131,7 +1139,6 @@ static int img_info(int argc, char **argv)
     if (!bs) {
         return 1;
     }
     if (!bs) {
         return 1;
     }

-    bdrv_get_format(bs, fmt_name, sizeof(fmt_name));

     bdrv_get_geometry(bs, &total_sectors);
     get_human_readable_size(size_buf, sizeof(size_buf), total_sectors * 512);
     allocated_size = bdrv_get_allocated_file_size(bs);
     bdrv_get_geometry(bs, &total_sectors);
     get_human_readable_size(size_buf, sizeof(size_buf), total_sectors * 512);
     allocated_size = bdrv_get_allocated_file_size(bs);


@@ -1145,7 +1152,7 @@ static int img_info(int argc, char **argv)
            "file format: %s\n"
            "virtual size: %s (%" PRId64 " bytes)\n"
            "disk size: %s\n",
            "file format: %s\n"
            "virtual size: %s (%" PRId64 " bytes)\n"
            "disk size: %s\n",

-           filename, fmt_name, size_buf,
+           filename, bdrv_get_format_name(bs), size_buf,

            (total_sectors * 512),
            dsize_buf);
     if (bdrv_is_encrypted(bs)) {
            (total_sectors * 512),
            dsize_buf);
     if (bdrv_is_encrypted(bs)) {


@@ -1155,14 +1162,19 @@ static int img_info(int argc, char **argv)
         if (bdi.cluster_size != 0) {
             printf("cluster_size: %d\n", bdi.cluster_size);
         }
         if (bdi.cluster_size != 0) {
             printf("cluster_size: %d\n", bdi.cluster_size);
         }

+        if (bdi.is_dirty) {
+            printf("cleanly shut down: no\n");
+        }

     }
     bdrv_get_backing_filename(bs, backing_filename, sizeof(backing_filename));
     if (backing_filename[0] != '\0') {
     }
     bdrv_get_backing_filename(bs, backing_filename, sizeof(backing_filename));
     if (backing_filename[0] != '\0') {

-        path_combine(backing_filename2, sizeof(backing_filename2),
-                     filename, backing_filename);
-        printf("backing file: %s (actual path: %s)\n",
-               backing_filename,
-               backing_filename2);
+        bdrv_get_full_backing_filename(bs, backing_filename2,
+                                       sizeof(backing_filename2));
+        printf("backing file: %s", backing_filename);
+        if (strcmp(backing_filename, backing_filename2) != 0) {
+            printf(" (actual path: %s)", backing_filename2);
+        }
+        putchar('\n');

     }
     dump_snapshots(bs);
     bdrv_delete(bs);
     }
     dump_snapshots(bs);
     bdrv_delete(bs);


@@ -1418,6 +1430,8 @@ static int img_rebase(int argc, char **argv)
      */
     if (!unsafe) {
         uint64_t num_sectors;
      */
     if (!unsafe) {
         uint64_t num_sectors;

+        uint64_t old_backing_num_sectors;
+        uint64_t new_backing_num_sectors;

         uint64_t sector;
         int n;
         uint8_t * buf_old;
         uint64_t sector;
         int n;
         uint8_t * buf_old;


@@ -1428,6 +1442,8 @@ static int img_rebase(int argc, char **argv)
         buf_new = qemu_blockalign(bs, IO_BUF_SIZE);
 
         bdrv_get_geometry(bs, &num_sectors);
         buf_new = qemu_blockalign(bs, IO_BUF_SIZE);
 
         bdrv_get_geometry(bs, &num_sectors);

+        bdrv_get_geometry(bs_old_backing, &old_backing_num_sectors);
+        bdrv_get_geometry(bs_new_backing, &new_backing_num_sectors);

 
         local_progress = (float)100 /
             (num_sectors / MIN(num_sectors, IO_BUF_SIZE / 512));
 
         local_progress = (float)100 /
             (num_sectors / MIN(num_sectors, IO_BUF_SIZE / 512));


@@ -1446,16 +1462,36 @@ static int img_rebase(int argc, char **argv)
                 continue;
             }
 
                 continue;
             }
 

-            /* Read old and new backing file */
-            ret = bdrv_read(bs_old_backing, sector, buf_old, n);
-            if (ret < 0) {
-                error_report("error while reading from old backing file");
-                goto out;
+            /*
+             * Read old and new backing file and take into consideration that
+             * backing files may be smaller than the COW image.
+             */
+            if (sector >= old_backing_num_sectors) {
+                memset(buf_old, 0, n * BDRV_SECTOR_SIZE);
+            } else {
+                if (sector + n > old_backing_num_sectors) {
+                    n = old_backing_num_sectors - sector;
+                }
+
+                ret = bdrv_read(bs_old_backing, sector, buf_old, n);
+                if (ret < 0) {
+                    error_report("error while reading from old backing file");
+                    goto out;
+                }

             }
             }

-            ret = bdrv_read(bs_new_backing, sector, buf_new, n);
-            if (ret < 0) {
-                error_report("error while reading from new backing file");
-                goto out;
+
+            if (sector >= new_backing_num_sectors) {
+                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);
+                if (ret < 0) {
+                    error_report("error while reading from new backing file");
+                    goto out;
+                }

             }
 
             /* If they differ, we need to write to the COW file */
             }
 
             /* If they differ, we need to write to the COW file */


@@ -1620,7 +1656,7 @@ static int img_resize(int argc, char **argv)
         printf("Image resized.\n");
         break;
     case -ENOTSUP:
         printf("Image resized.\n");
         break;
     case -ENOTSUP:

-        error_report("This image format does not support resize");
+        error_report("This image does not support resize");

         break;
     case -EACCES:
         error_report("Image is read-only");
         break;
     case -EACCES:
         error_report("Image is read-only");


@@ -1661,6 +1697,8 @@ int main(int argc, char **argv)
     cmdname = argv[1];
     argc--; argv++;
 
     cmdname = argv[1];
     argc--; argv++;
 

+    qemu_init_main_loop();
+

     /* find the command */
     for(cmd = img_cmds; cmd->name != NULL; cmd++) {
         if (!strcmp(cmdname, cmd->name)) {
     /* find the command */
     for(cmd = img_cmds; cmd->name != NULL; cmd++) {
         if (!strcmp(cmdname, cmd->name)) {