Diff for /qemu/qemu-io.c between versions 1.1.1.3 and 1.1.1.4

version 1.1.1.3, 2018/04/24 18:24:46 version 1.1.1.4, 2018/04/24 18:34:33
Line 61  static void *qemu_io_alloc(size_t len, i Line 61  static void *qemu_io_alloc(size_t len, i
   
         if (misalign)          if (misalign)
                 len += MISALIGN_OFFSET;                  len += MISALIGN_OFFSET;
         buf = qemu_memalign(512, len);          buf = qemu_blockalign(bs, len);
         memset(buf, pattern, len);          memset(buf, pattern, len);
         if (misalign)          if (misalign)
                 buf += MISALIGN_OFFSET;                  buf += MISALIGN_OFFSET;
Line 135  create_iovec(QEMUIOVector *qiov, char ** Line 135  create_iovec(QEMUIOVector *qiov, char **
   
         for (i = 0; i < nr_iov; i++) {          for (i = 0; i < nr_iov; i++) {
                 char *arg = argv[i];                  char *arg = argv[i];
                 uint64_t len;                  int64_t len;
   
                 len = cvtnum(arg);                  len = cvtnum(arg);
                 if (len < 0) {                  if (len < 0) {
Line 144  create_iovec(QEMUIOVector *qiov, char ** Line 144  create_iovec(QEMUIOVector *qiov, char **
                 }                  }
   
                 /* should be SIZE_T_MAX, but that doesn't exist */                  /* should be SIZE_T_MAX, but that doesn't exist */
                 if (len > UINT_MAX) {                  if (len > INT_MAX) {
                         printf("too large length argument -- %s\n", arg);                          printf("too large length argument -- %s\n", arg);
                         goto fail;                          goto fail;
                 }                  }
Line 326  read_help(void) Line 326  read_help(void)
 " -l, -- length for pattern verification (only with -P)\n"  " -l, -- length for pattern verification (only with -P)\n"
 " -p, -- use bdrv_pread to read the file\n"  " -p, -- use bdrv_pread to read the file\n"
 " -P, -- use a pattern to verify read data\n"  " -P, -- use a pattern to verify read data\n"
 " -q, -- quite mode, do not show I/O statistics\n"  " -q, -- quiet mode, do not show I/O statistics\n"
 " -s, -- start offset for pattern verification (only with -P)\n"  " -s, -- start offset for pattern verification (only with -P)\n"
 " -v, -- dump buffer to standard output\n"  " -v, -- dump buffer to standard output\n"
 "\n");  "\n");
Line 509  readv_help(void) Line 509  readv_help(void)
 " -C, -- report statistics in a machine parsable format\n"  " -C, -- report statistics in a machine parsable format\n"
 " -P, -- use a pattern to verify read data\n"  " -P, -- use a pattern to verify read data\n"
 " -v, -- dump buffer to standard output\n"  " -v, -- dump buffer to standard output\n"
 " -q, -- quite mode, do not show I/O statistics\n"  " -q, -- quiet mode, do not show I/O statistics\n"
 "\n");  "\n");
 }  }
   
Line 633  write_help(void) Line 633  write_help(void)
 " -p, -- use bdrv_pwrite to write the file\n"  " -p, -- use bdrv_pwrite to write the file\n"
 " -P, -- use different pattern to fill file\n"  " -P, -- use different pattern to fill file\n"
 " -C, -- report statistics in a machine parsable format\n"  " -C, -- report statistics in a machine parsable format\n"
 " -q, -- quite mode, do not show I/O statistics\n"  " -q, -- quiet mode, do not show I/O statistics\n"
 "\n");  "\n");
 }  }
   
Line 765  writev_help(void) Line 765  writev_help(void)
 " filled with a set pattern (0xcdcdcdcd).\n"  " filled with a set pattern (0xcdcdcdcd).\n"
 " -P, -- use different pattern to fill file\n"  " -P, -- use different pattern to fill file\n"
 " -C, -- report statistics in a machine parsable format\n"  " -C, -- report statistics in a machine parsable format\n"
 " -q, -- quite mode, do not show I/O statistics\n"  " -q, -- quiet mode, do not show I/O statistics\n"
 "\n");  "\n");
 }  }
   
Line 1100  aio_read_help(void) Line 1100  aio_read_help(void)
 " -C, -- report statistics in a machine parsable format\n"  " -C, -- report statistics in a machine parsable format\n"
 " -P, -- use a pattern to verify read data\n"  " -P, -- use a pattern to verify read data\n"
 " -v, -- dump buffer to standard output\n"  " -v, -- dump buffer to standard output\n"
 " -q, -- quite mode, do not show I/O statistics\n"  " -q, -- quiet mode, do not show I/O statistics\n"
 "\n");  "\n");
 }  }
   
Line 1131  aio_read_f(int argc, char **argv) Line 1131  aio_read_f(int argc, char **argv)
                 case 'P':                  case 'P':
                         ctx->Pflag = 1;                          ctx->Pflag = 1;
                         ctx->pattern = parse_pattern(optarg);                          ctx->pattern = parse_pattern(optarg);
                         if (ctx->pattern < 0)                          if (ctx->pattern < 0) {
                                   free(ctx);
                                 return 0;                                  return 0;
                           }
                         break;                          break;
                 case 'q':                  case 'q':
                         ctx->qflag = 1;                          ctx->qflag = 1;
Line 1198  aio_write_help(void) Line 1200  aio_write_help(void)
 " used to ensure all outstanding aio requests have been completed\n"  " used to ensure all outstanding aio requests have been completed\n"
 " -P, -- use different pattern to fill file\n"  " -P, -- use different pattern to fill file\n"
 " -C, -- report statistics in a machine parsable format\n"  " -C, -- report statistics in a machine parsable format\n"
 " -q, -- quite mode, do not show I/O statistics\n"  " -q, -- quiet mode, do not show I/O statistics\n"
 "\n");  "\n");
 }  }
   
Line 1394  static const cmdinfo_t info_cmd = { Line 1396  static const cmdinfo_t info_cmd = {
         .oneline        = "prints information about the current file",          .oneline        = "prints information about the current file",
 };  };
   
   static void
   discard_help(void)
   {
           printf(
   "\n"
   " discards a range of bytes from the given offset\n"
   "\n"
   " Example:\n"
   " 'discard 512 1k' - discards 1 kilobyte from 512 bytes into the file\n"
   "\n"
   " Discards a segment of the currently open file.\n"
   " -C, -- report statistics in a machine parsable format\n"
   " -q, -- quiet mode, do not show I/O statistics\n"
   "\n");
   }
   
   static int discard_f(int argc, char **argv);
   
   static const cmdinfo_t discard_cmd = {
           .name           = "discard",
           .altname        = "d",
           .cfunc          = discard_f,
           .argmin         = 2,
           .argmax         = -1,
           .args           = "[-Cq] off len",
           .oneline        = "discards a number of bytes at a specified offset",
           .help           = discard_help,
   };
   
   static int
   discard_f(int argc, char **argv)
   {
           struct timeval t1, t2;
           int Cflag = 0, qflag = 0;
           int c, ret;
           int64_t offset;
           int count;
   
           while ((c = getopt(argc, argv, "Cq")) != EOF) {
                   switch (c) {
                   case 'C':
                           Cflag = 1;
                           break;
                   case 'q':
                           qflag = 1;
                           break;
                   default:
                           return command_usage(&discard_cmd);
                   }
           }
   
           if (optind != argc - 2) {
                   return command_usage(&discard_cmd);
           }
   
           offset = cvtnum(argv[optind]);
           if (offset < 0) {
                   printf("non-numeric length argument -- %s\n", argv[optind]);
                   return 0;
           }
   
           optind++;
           count = cvtnum(argv[optind]);
           if (count < 0) {
                   printf("non-numeric length argument -- %s\n", argv[optind]);
                   return 0;
           }
   
           gettimeofday(&t1, NULL);
           ret = bdrv_discard(bs, offset >> BDRV_SECTOR_BITS, count >> BDRV_SECTOR_BITS);
           gettimeofday(&t2, NULL);
   
           if (ret < 0) {
                   printf("discard failed: %s\n", strerror(-ret));
                   goto out;
           }
   
           /* Finally, report back -- -C gives a parsable format */
           if (!qflag) {
                   t2 = tsub(t2, t1);
                   print_report("discard", &t2, offset, count, count, 1, Cflag);
           }
   
   out:
           return 0;
   }
   
 static int  static int
 alloc_f(int argc, char **argv)  alloc_f(int argc, char **argv)
 {  {
Line 1427  alloc_f(int argc, char **argv) Line 1516  alloc_f(int argc, char **argv)
   
         cvtstr(offset, s1, sizeof(s1));          cvtstr(offset, s1, sizeof(s1));
   
         if (nb_sectors == 1)          printf("%d/%d sectors allocated at offset %s\n",
                 printf("sector allocated at offset %s\n", s1);                 sum_alloc, nb_sectors, s1);
         else  
                 printf("%d/%d sectors allocated at offset %s\n",  
                         sum_alloc, nb_sectors, s1);  
         return 0;          return 0;
 }  }
   
Line 1446  static const cmdinfo_t alloc_cmd = { Line 1532  static const cmdinfo_t alloc_cmd = {
 };  };
   
 static int  static int
   map_f(int argc, char **argv)
   {
           int64_t offset;
           int64_t nb_sectors;
           char s1[64];
           int num, num_checked;
           int ret;
           const char *retstr;
   
           offset = 0;
           nb_sectors = bs->total_sectors;
   
           do {
                   num_checked = MIN(nb_sectors, INT_MAX);
                   ret = bdrv_is_allocated(bs, offset, num_checked, &num);
                   retstr = ret ? "    allocated" : "not allocated";
                   cvtstr(offset << 9ULL, s1, sizeof(s1));
                   printf("[% 24" PRId64 "] % 8d/% 8d sectors %s at offset %s (%d)\n",
                                   offset << 9ULL, num, num_checked, retstr, s1, ret);
   
                   offset += num;
                   nb_sectors -= num;
           } while(offset < bs->total_sectors);
   
           return 0;
   }
   
   static const cmdinfo_t map_cmd = {
          .name           = "map",
          .argmin         = 0,
          .argmax         = 0,
          .cfunc          = map_f,
          .args           = "",
          .oneline        = "prints the allocated areas of a file",
   };
   
   
   static int
 close_f(int argc, char **argv)  close_f(int argc, char **argv)
 {  {
         bdrv_close(bs);          bdrv_close(bs);
Line 1474  static int openfile(char *name, int flag Line 1598  static int openfile(char *name, int flag
                 }                  }
         } else {          } else {
                 bs = bdrv_new("hda");                  bs = bdrv_new("hda");
                 if (!bs)  
                         return 1;  
   
                 if (bdrv_open(bs, name, flags, NULL) < 0) {                  if (bdrv_open(bs, name, flags, NULL) < 0) {
                         fprintf(stderr, "%s: can't open device %s\n", progname, name);                          fprintf(stderr, "%s: can't open device %s\n", progname, name);
Line 1682  int main(int argc, char **argv) Line 1804  int main(int argc, char **argv)
         add_command(&truncate_cmd);          add_command(&truncate_cmd);
         add_command(&length_cmd);          add_command(&length_cmd);
         add_command(&info_cmd);          add_command(&info_cmd);
           add_command(&discard_cmd);
         add_command(&alloc_cmd);          add_command(&alloc_cmd);
           add_command(&map_cmd);
   
         add_args_command(init_args_command);          add_args_command(init_args_command);
         add_check_command(init_check_command);          add_check_command(init_check_command);

Removed from v.1.1.1.3  
changed lines
  Added in v.1.1.1.4


unix.superglobalmegacorp.com