Skip to contentSkip to conversation

qemu-io: add pattern file for write command

PATCH Superseded Denis Plotnikov 3 participants 4 messages Jun 10, 2019 – Jul 11, 2019

v6 of 10 Superseded Latest is v10 →

lore
Share & tools
lore
#0 lore raw

PATCH v6 1/1 qemu-io: add pattern file for write command

The patch allows to provide a pattern file for write command. There was no similar ability before.

---
v6:
* the pattern file is read once to reduce io

v5:
* file name initiated with null to make compilers happy

v4:
* missing signed-off clause added

v3:
* missing file closing added
* exclusive flags processing changed
* buffer void* converted to char* to fix pointer arithmetics
* file reading error processing added

---
 qemu-io-cmds.c | 88 ++++++++++++++++++++++++++++++++++++++++++++++----
 1 file changed, 82 insertions(+), 6 deletions(-)
qemu-io-cmds.c +82 -6
index 09750a23ce..e27203f747 100644
@@ -343,6 +343,69 @@ static void *qemu_io_alloc(BlockBackend *blk, size_t len, int pattern)
     return buf;
 }
 
+static void *qemu_io_alloc_from_file(BlockBackend *blk, size_t len,
+                                     char *file_name)
+{
+    char *buf, *buf_origin;
+    FILE *f = fopen(file_name, "r");
+    int l;
+
+    if (!f) {
+        printf("'%s': %s\n", file_name, strerror(errno));
+        return NULL;
+    }
+
+    if (qemuio_misalign) {
+        len += MISALIGN_OFFSET;
+    }
+    buf_origin = blk_blockalign(blk, len);
+    memset(buf_origin, 0, len);
+
+    buf = buf_origin;
+
+    l = fread(buf, sizeof(char), len, f);
+
+    if (ferror(f)) {
+        printf("'%s': %s\n", file_name, strerror(errno));
+        goto error;
+    }
+
+    if (l == 0) {
+        printf("'%s' is empty\n", file_name);
+        goto error;
+    }
+
+    if (l < len) {
+        char *file_buf = g_malloc(sizeof(char) * l);
+        memcpy(file_buf, buf, l);
+        len -= l;
+        buf += l;
+
+        while (len > 0) {
+            size_t len_to_copy = len > l ? l : len;
+
+            memcpy(buf, file_buf, len_to_copy);
+
+            len -= len_to_copy;
+            buf += len_to_copy;
+        }
+        qemu_vfree(file_buf);
+    }
+
+    if (qemuio_misalign) {
+        buf_origin += MISALIGN_OFFSET;
+    }
+
+    goto out;
+
+error:
+    qemu_vfree(buf);
+    buf_origin = NULL;
+out:
+    fclose(f);
+    return buf_origin;
+}
+
 static void qemu_io_free(void *p)
 {
     if (qemuio_misalign) {
@@ -965,7 +1028,7 @@ static const cmdinfo_t write_cmd = {
     .perm       = BLK_PERM_WRITE,
     .argmin     = 2,
     .argmax     = -1,
-    .args       = "[-bcCfnquz] [-P pattern] off len",
+    .args       = "[-bcCfnquz] [-P pattern | -s source_file] off len",
     .oneline    = "writes a number of bytes at a specified offset",
     .help       = write_help,
 };
@@ -974,7 +1037,7 @@ static int write_f(BlockBackend *blk, int argc, char **argv)
 {
     struct timeval t1, t2;
     bool Cflag = false, qflag = false, bflag = false;
-    bool Pflag = false, zflag = false, cflag = false;
+    bool Pflag = false, zflag = false, cflag = false, sflag = false;
     int flags = 0;
     int c, cnt, ret;
     char *buf = NULL;
@@ -983,8 +1046,9 @@ static int write_f(BlockBackend *blk, int argc, char **argv)
     /* Some compilers get confused and warn if this is not initialized.  */
     int64_t total = 0;
     int pattern = 0xcd;
+    char *file_name = NULL;
 
-    while ((c = getopt(argc, argv, "bcCfnpP:quz")) != -1) {
+    while ((c = getopt(argc, argv, "bcCfnpP:quzs:")) != -1) {
         switch (c) {
         case 'b':
             bflag = true;
@@ -1020,6 +1084,10 @@ static int write_f(BlockBackend *blk, int argc, char **argv)
         case 'z':
             zflag = true;
             break;
+        case 's':
+            sflag = true;
+            file_name = g_strdup(optarg);
+            break;
         default:
             qemuio_command_usage(&write_cmd);
             return -EINVAL;
@@ -1051,8 +1119,9 @@ static int write_f(BlockBackend *blk, int argc, char **argv)
         return -EINVAL;
     }
 
-    if (zflag && Pflag) {
-        printf("-z and -P cannot be specified at the same time\n");
+    if ((int)zflag + (int)Pflag + (int)sflag > 1) {
+        printf("Only one of -z, -P, and -s"
+               "can be specified at the same time\n");
         return -EINVAL;
     }
 
@@ -1088,7 +1157,14 @@ static int write_f(BlockBackend *blk, int argc, char **argv)
     }
 
     if (!zflag) {
-        buf = qemu_io_alloc(blk, count, pattern);
+        if (sflag) {
+            buf = qemu_io_alloc_from_file(blk, count, file_name);
+            if (!buf) {
+                return -EINVAL;
+            }
+        } else {
+            buf = qemu_io_alloc(blk, count, pattern);
+        }
     }
 
     gettimeofday(&t1, NULL);
Signature · 1 line
2.17.0
#1 lore raw
Quoted 28 lines · Denis Plotnikov

The patch allows to provide a pattern file for write command. There was no similar ability before.

---
v6:
* the pattern file is read once to reduce io

v5:
* file name initiated with null to make compilers happy

v4:
* missing signed-off clause added

v3:
* missing file closing added
* exclusive flags processing changed
* buffer void* converted to char* to fix pointer arithmetics
* file reading error processing added

---
  qemu-io-cmds.c | 88 ++++++++++++++++++++++++++++++++++++++++++++++----
  1 file changed, 82 insertions(+), 6 deletions(-)
qemu-io-cmds.c +0 -0
index 09750a23ce..e27203f747 100644

qemu-io-cmds.c static void *qemu_io_alloc(BlockBackend *blk, size_t len, int pattern) · line 351

Quoted 9 lines
qemu-io-cmds.c +6 -0
@@ -343,6 +343,69 @@ static void *qemu_io_alloc(BlockBackend *blk, size_t len, int pattern)
      return buf;
  }
 
+static void *qemu_io_alloc_from_file(BlockBackend *blk, size_t len,
+                                     char *file_name)
+{
+    char *buf, *buf_origin;
+    FILE *f = fopen(file_name, "r");
+    int l;

should be size_t, and could you get it descriptive name pattern_len or like this?

Quoted 19 lines
qemu-io-cmds.c +19 -0
+
+    if (!f) {
+        printf("'%s': %s\n", file_name, strerror(errno));
+        return NULL;
+    }
+
+    if (qemuio_misalign) {
+        len += MISALIGN_OFFSET;
+    }
+    buf_origin = blk_blockalign(blk, len);
+    memset(buf_origin, 0, len);
+
+    buf = buf_origin;
+
+    l = fread(buf, sizeof(char), len, f);
+
+    if (ferror(f)) {
+        printf("'%s': %s\n", file_name, strerror(errno));
+        goto error;

qemu-io-cmds.c static void *qemu_io_alloc(BlockBackend *blk, size_t len, int pattern) · line 380

Quoted 10 lines
qemu-io-cmds.c +10 -0
+    }
+
+    if (l == 0) {
+        printf("'%s' is empty\n", file_name);
+        goto error;
+    }
+
+    if (l < len) {
+        char *file_buf = g_malloc(sizeof(char) * l);
+        memcpy(file_buf, buf, l);

I see no reason to copy it, you can just use buf_origin pointer instead.

qemu-io-cmds.c static void *qemu_io_alloc(BlockBackend *blk, size_t len, int pattern) · line 385

Quoted 5 lines
qemu-io-cmds.c +5 -0
+        len -= l;
+        buf += l;
+
+        while (len > 0) {
+            size_t len_to_copy = len > l ? l : len;

you may use MIN(len, l)

Quoted 95 lines
qemu-io-cmds.c +42 -6
+
+            memcpy(buf, file_buf, len_to_copy);
+
+            len -= len_to_copy;
+            buf += len_to_copy;
+        }
+        qemu_vfree(file_buf);
+    }
+
+    if (qemuio_misalign) {
+        buf_origin += MISALIGN_OFFSET;
+    }
+
+    goto out;
+
+error:
+    qemu_vfree(buf);
+    buf_origin = NULL;
+out:
+    fclose(f);
+    return buf_origin;
+}
+
  static void qemu_io_free(void *p)
  {
      if (qemuio_misalign) {
@@ -965,7 +1028,7 @@ static const cmdinfo_t write_cmd = {
      .perm       = BLK_PERM_WRITE,
      .argmin     = 2,
      .argmax     = -1,
-    .args       = "[-bcCfnquz] [-P pattern] off len",
+    .args       = "[-bcCfnquz] [-P pattern | -s source_file] off len",
      .oneline    = "writes a number of bytes at a specified offset",
      .help       = write_help,
  };
@@ -974,7 +1037,7 @@ static int write_f(BlockBackend *blk, int argc, char **argv)
  {
      struct timeval t1, t2;
      bool Cflag = false, qflag = false, bflag = false;
-    bool Pflag = false, zflag = false, cflag = false;
+    bool Pflag = false, zflag = false, cflag = false, sflag = false;
      int flags = 0;
      int c, cnt, ret;
      char *buf = NULL;
@@ -983,8 +1046,9 @@ static int write_f(BlockBackend *blk, int argc, char **argv)
      /* Some compilers get confused and warn if this is not initialized.  */
      int64_t total = 0;
      int pattern = 0xcd;
+    char *file_name = NULL;
 
-    while ((c = getopt(argc, argv, "bcCfnpP:quz")) != -1) {
+    while ((c = getopt(argc, argv, "bcCfnpP:quzs:")) != -1) {
          switch (c) {
          case 'b':
              bflag = true;
@@ -1020,6 +1084,10 @@ static int write_f(BlockBackend *blk, int argc, char **argv)
          case 'z':
              zflag = true;
              break;
+        case 's':
+            sflag = true;
+            file_name = g_strdup(optarg);
+            break;
          default:
              qemuio_command_usage(&write_cmd);
              return -EINVAL;
@@ -1051,8 +1119,9 @@ static int write_f(BlockBackend *blk, int argc, char **argv)
          return -EINVAL;
      }
 
-    if (zflag && Pflag) {
-        printf("-z and -P cannot be specified at the same time\n");
+    if ((int)zflag + (int)Pflag + (int)sflag > 1) {
+        printf("Only one of -z, -P, and -s"
+               "can be specified at the same time\n");
          return -EINVAL;
      }
 
@@ -1088,7 +1157,14 @@ static int write_f(BlockBackend *blk, int argc, char **argv)
      }
 
      if (!zflag) {
-        buf = qemu_io_alloc(blk, count, pattern);
+        if (sflag) {
+            buf = qemu_io_alloc_from_file(blk, count, file_name);
+            if (!buf) {
+                return -EINVAL;
+            }
+        } else {
+            buf = qemu_io_alloc(blk, count, pattern);
+        }
      }
 
      gettimeofday(&t1, NULL);
Signature · 2 lines
Best regards,
Vladimir
#2 lore raw
Quoted 65 lines · Vladimir Sementsov-Ogievskiy
Quoted 28 lines · Denis Plotnikov

The patch allows to provide a pattern file for write command. There was no similar ability before.

---
v6:
* the pattern file is read once to reduce io

v5:
* file name initiated with null to make compilers happy

v4:
* missing signed-off clause added

v3:
* missing file closing added
* exclusive flags processing changed
* buffer void* converted to char* to fix pointer arithmetics
* file reading error processing added

---
   qemu-io-cmds.c | 88 ++++++++++++++++++++++++++++++++++++++++++++++----
   1 file changed, 82 insertions(+), 6 deletions(-)
qemu-io-cmds.c +0 -0
index 09750a23ce..e27203f747 100644

qemu-io-cmds.c static void *qemu_io_alloc(BlockBackend *blk, size_t len, int pattern) · line 351

Quoted 9 lines
qemu-io-cmds.c +6 -0
@@ -343,6 +343,69 @@ static void *qemu_io_alloc(BlockBackend *blk, size_t len, int pattern)
       return buf;
   }
 
+static void *qemu_io_alloc_from_file(BlockBackend *blk, size_t len,
+                                     char *file_name)
+{
+    char *buf, *buf_origin;
+    FILE *f = fopen(file_name, "r");
+    int l;

should be size_t, and could you get it descriptive name pattern_len or like this?

Quoted 24 lines
qemu-io-cmds.c +24 -0
+
+    if (!f) {
+        printf("'%s': %s\n", file_name, strerror(errno));
+        return NULL;
+    }
+
+    if (qemuio_misalign) {
+        len += MISALIGN_OFFSET;
+    }
+    buf_origin = blk_blockalign(blk, len);
+    memset(buf_origin, 0, len);
+
+    buf = buf_origin;
+
+    l = fread(buf, sizeof(char), len, f);
+
+    if (ferror(f)) {
+        printf("'%s': %s\n", file_name, strerror(errno));
+        goto error;
+    }
+
+    if (l == 0) {
+        printf("'%s' is empty\n", file_name);
+        goto error;
Quoted 8 lines

qemu-io-cmds.c static void *qemu_io_alloc(BlockBackend *blk, size_t len, int pattern) · line 380

Quoted 5 lines
qemu-io-cmds.c +5 -0
+    }
+
+    if (l < len) {
+        char *file_buf = g_malloc(sizeof(char) * l);
+        memcpy(file_buf, buf, l);

I see no reason to copy it, you can just use buf_origin pointer instead.

I use buf_origin to save the beginning pointer to return it from the function avoiding later calculation of the beginning address since pointer of the buf is changed in the loop.

Quoted 106 lines

qemu-io-cmds.c static void *qemu_io_alloc(BlockBackend *blk, size_t len, int pattern) · line 385

Quoted 6 lines
qemu-io-cmds.c +5 -0
+        len -= l;
+        buf += l;
+
+        while (len > 0) {
+            size_t len_to_copy = len > l ? l : len;

you may use MIN(len, l)

Quoted 95 lines
qemu-io-cmds.c +42 -6
+
+            memcpy(buf, file_buf, len_to_copy);
+
+            len -= len_to_copy;
+            buf += len_to_copy;
+        }
+        qemu_vfree(file_buf);
+    }
+
+    if (qemuio_misalign) {
+        buf_origin += MISALIGN_OFFSET;
+    }
+
+    goto out;
+
+error:
+    qemu_vfree(buf);
+    buf_origin = NULL;
+out:
+    fclose(f);
+    return buf_origin;
+}
+
   static void qemu_io_free(void *p)
   {
       if (qemuio_misalign) {
@@ -965,7 +1028,7 @@ static const cmdinfo_t write_cmd = {
       .perm       = BLK_PERM_WRITE,
       .argmin     = 2,
       .argmax     = -1,
-    .args       = "[-bcCfnquz] [-P pattern] off len",
+    .args       = "[-bcCfnquz] [-P pattern | -s source_file] off len",
       .oneline    = "writes a number of bytes at a specified offset",
       .help       = write_help,
   };
@@ -974,7 +1037,7 @@ static int write_f(BlockBackend *blk, int argc, char **argv)
   {
       struct timeval t1, t2;
       bool Cflag = false, qflag = false, bflag = false;
-    bool Pflag = false, zflag = false, cflag = false;
+    bool Pflag = false, zflag = false, cflag = false, sflag = false;
       int flags = 0;
       int c, cnt, ret;
       char *buf = NULL;
@@ -983,8 +1046,9 @@ static int write_f(BlockBackend *blk, int argc, char **argv)
       /* Some compilers get confused and warn if this is not initialized.  */
       int64_t total = 0;
       int pattern = 0xcd;
+    char *file_name = NULL;
 
-    while ((c = getopt(argc, argv, "bcCfnpP:quz")) != -1) {
+    while ((c = getopt(argc, argv, "bcCfnpP:quzs:")) != -1) {
           switch (c) {
           case 'b':
               bflag = true;
@@ -1020,6 +1084,10 @@ static int write_f(BlockBackend *blk, int argc, char **argv)
           case 'z':
               zflag = true;
               break;
+        case 's':
+            sflag = true;
+            file_name = g_strdup(optarg);
+            break;
           default:
               qemuio_command_usage(&write_cmd);
               return -EINVAL;
@@ -1051,8 +1119,9 @@ static int write_f(BlockBackend *blk, int argc, char **argv)
           return -EINVAL;
       }
 
-    if (zflag && Pflag) {
-        printf("-z and -P cannot be specified at the same time\n");
+    if ((int)zflag + (int)Pflag + (int)sflag > 1) {
+        printf("Only one of -z, -P, and -s"
+               "can be specified at the same time\n");
           return -EINVAL;
       }
 
@@ -1088,7 +1157,14 @@ static int write_f(BlockBackend *blk, int argc, char **argv)
       }
 
       if (!zflag) {
-        buf = qemu_io_alloc(blk, count, pattern);
+        if (sflag) {
+            buf = qemu_io_alloc_from_file(blk, count, file_name);
+            if (!buf) {
+                return -EINVAL;
+            }
+        } else {
+            buf = qemu_io_alloc(blk, count, pattern);
+        }
       }
 
       gettimeofday(&t1, NULL);
Signature · 2 lines
Best,
Denis
#3 lore raw
Quoted 26 lines · Denis Plotnikov
Quoted 23 lines · Vladimir Sementsov-Ogievskiy
Quoted 22 lines · Denis Plotnikov

The patch allows to provide a pattern file for write command. There was no similar ability before.

---
v6:
* the pattern file is read once to reduce io

v5:
* file name initiated with null to make compilers happy

v4:
* missing signed-off clause added

v3:
* missing file closing added
* exclusive flags processing changed
* buffer void* converted to char* to fix pointer arithmetics
* file reading error processing added

---
   qemu-io-cmds.c | 88 ++++++++++++++++++++++++++++++++++++++++++++++----
   1 file changed, 82 insertions(+), 6 deletions(-)

[...]

Quoted 2 lines
Quoted 2 lines

qemu-io-cmds.c static void *qemu_io_alloc(BlockBackend *blk, size_t len, int pattern) · line 379

Quoted 2 lines
qemu-io-cmds.c +2 -0
+    if (l < len) {
+        char *file_buf = g_malloc(sizeof(char) * l);

Note that sizeof(char) is guaranteed to be 1.

(C1x standard, 6.5.3.4, paragraph 4.)

Quoted 7 lines
Quoted 4 lines
Quoted 1 line

+ memcpy(file_buf, buf, l);

I see no reason to copy it, you can just use buf_origin pointer instead.

I use buf_origin to save the beginning pointer to return it from the function avoiding later calculation of the beginning address since pointer of the buf is changed in the loop.

The point is that you don’t need file_buf. You can drop it, replace all occurrences of file_buf by buf_origin, and probably use memmove instead of memcpy.

Max