Diff for /qemu/qemu-img.c between versions 1.1.1.14 and 1.1.1.15

version 1.1.1.14, 2018/04/24 19:17:22 version 1.1.1.15, 2018/04/24 19:34:36
Line 66  static void help(void) Line 66  static void help(void)
            "  'filename' is a disk image filename\n"             "  'filename' is a disk image filename\n"
            "  'fmt' is the disk image format. It is guessed automatically in most cases\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"             "  'cache' is the cache mode used to write the output disk image, the valid\n"
            "    options are: 'none', 'writeback' (default), 'writethrough', 'directsync'\n"             "    options are: 'none', 'writeback' (default, except for convert), 'writethrough',\n"
            "    and 'unsafe'\n"             "    'directsync' and 'unsafe' (default for convert)\n"
            "  'size' is the disk image size in bytes. Optional suffixes\n"             "  'size' is the disk image size in bytes. Optional suffixes\n"
            "    'k' or 'K' (kilobyte, 1024), 'M' (megabyte, 1024k), 'G' (gigabyte, 1024M)\n"             "    'k' or 'K' (kilobyte, 1024), 'M' (megabyte, 1024k), 'G' (gigabyte, 1024M)\n"
            "    and T (terabyte, 1024G) are supported. 'b' is ignored.\n"             "    and T (terabyte, 1024G) are supported. 'b' is ignored.\n"
Line 428  static int img_check(int argc, char **ar Line 428  static int img_check(int argc, char **ar
         }          }
     }      }
   
       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);      bdrv_delete(bs);
   
     if (ret < 0 || result.check_errors) {      if (ret < 0 || result.check_errors) {
Line 515  static int img_commit(int argc, char **a Line 522  static int img_commit(int argc, char **a
 }  }
   
 /*  /*
  * 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   * Returns true iff the first sector pointed to by 'buf' contains at least
  * a non-NUL byte.   * a non-NUL byte.
  *   *
Line 557  static int is_not_zero(const uint8_t *se Line 530  static int is_not_zero(const uint8_t *se
  */   */
 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) {      if (n <= 0) {
         *pnum = 0;          *pnum = 0;
         return 0;          return 0;
     }      }
     v = is_not_zero(buf, 512);      is_zero = buffer_is_zero(buf, 512);
     for(i = 1; i < n; i++) {      for(i = 1; i < n; i++) {
         buf += 512;          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;
 }  }
   
 /*  /*
Line 737  static int img_convert(int argc, char ** Line 712  static int img_convert(int argc, char **
   
     out_filename = argv[argc - 1];      out_filename = argv[argc - 1];
   
       /* Initialize before goto out */
       qemu_progress_init(progress, 2.0);
   
     if (options && !strcmp(options, "?")) {      if (options && !strcmp(options, "?")) {
         ret = print_block_option_help(out_filename, out_fmt);          ret = print_block_option_help(out_filename, out_fmt);
         goto out;          goto out;
Line 748  static int img_convert(int argc, char ** Line 726  static int img_convert(int argc, char **
         ret = -1;          ret = -1;
         goto out;          goto out;
     }      }
           
     qemu_progress_init(progress, 2.0);  
     qemu_progress_print(0, 100);      qemu_progress_print(0, 100);
   
     bs = g_malloc0(bs_n * sizeof(BlockDriverState *));      bs = g_malloc0(bs_n * sizeof(BlockDriverState *));
Line 955  static int img_convert(int argc, char ** Line 932  static int img_convert(int argc, char **
             if (n < cluster_sectors) {              if (n < cluster_sectors) {
                 memset(buf + n * 512, 0, cluster_size - n * 512);                  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,                  ret = bdrv_write_compressed(out_bs, sector_num, buf,
                                             cluster_sectors);                                              cluster_sectors);
                 if (ret != 0) {                  if (ret != 0) {
Line 1157  static int img_info(int argc, char **arg Line 1134  static int img_info(int argc, char **arg
         if (bdi.cluster_size != 0) {          if (bdi.cluster_size != 0) {
             printf("cluster_size: %d\n", bdi.cluster_size);              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));      bdrv_get_backing_filename(bs, backing_filename, sizeof(backing_filename));
     if (backing_filename[0] != '\0') {      if (backing_filename[0] != '\0') {
         path_combine(backing_filename2, sizeof(backing_filename2),          bdrv_get_full_backing_filename(bs, backing_filename2,
                      filename, backing_filename);                                         sizeof(backing_filename2));
         printf("backing file: %s (actual path: %s)\n",          printf("backing file: %s", backing_filename);
                backing_filename,          if (strcmp(backing_filename, backing_filename2) != 0) {
                backing_filename2);              printf(" (actual path: %s)", backing_filename2);
           }
           putchar('\n');
     }      }
     dump_snapshots(bs);      dump_snapshots(bs);
     bdrv_delete(bs);      bdrv_delete(bs);
Line 1646  static int img_resize(int argc, char **a Line 1628  static int img_resize(int argc, char **a
         printf("Image resized.\n");          printf("Image resized.\n");
         break;          break;
     case -ENOTSUP:      case -ENOTSUP:
         error_report("This image format does not support resize");          error_report("This image does not support resize");
         break;          break;
     case -EACCES:      case -EACCES:
         error_report("Image is read-only");          error_report("Image is read-only");
Line 1687  int main(int argc, char **argv) Line 1669  int main(int argc, char **argv)
     cmdname = argv[1];      cmdname = argv[1];
     argc--; argv++;      argc--; argv++;
   
       qemu_init_main_loop();
   
     /* find the command */      /* find the command */
     for(cmd = img_cmds; cmd->name != NULL; cmd++) {      for(cmd = img_cmds; cmd->name != NULL; cmd++) {
         if (!strcmp(cmdname, cmd->name)) {          if (!strcmp(cmdname, cmd->name)) {

Removed from v.1.1.1.14  
changed lines
  Added in v.1.1.1.15


unix.superglobalmegacorp.com