Patchwork [3/3] QAPI: Introduce memchar-read QMP command

login
register
mail settings
Submitter Lei Li
Date Jan. 23, 2013, 9:06 a.m.
Message ID <1358931972-12534-4-git-send-email-lilei@linux.vnet.ibm.com>
Download mbox | patch
Permalink /patch/214855/
State New
Headers show

Comments

Lei Li - Jan. 23, 2013, 9:06 a.m.
Signed-off-by: Lei Li <lilei@linux.vnet.ibm.com>
---
 hmp-commands.hx  |   21 +++++++++++++++++++++
 hmp.c            |   17 +++++++++++++++++
 hmp.h            |    1 +
 qapi-schema.json |   36 ++++++++++++++++++++++++++++++++++++
 qemu-char.c      |   48 ++++++++++++++++++++++++++++++++++++++++++++++++
 qmp-commands.hx  |   33 +++++++++++++++++++++++++++++++++
 6 files changed, 156 insertions(+), 0 deletions(-)
Luiz Capitulino - Jan. 23, 2013, 3:42 p.m.
On Wed, 23 Jan 2013 17:06:12 +0800
Lei Li <lilei@linux.vnet.ibm.com> wrote:

> Signed-off-by: Lei Li <lilei@linux.vnet.ibm.com>
> ---
>  hmp-commands.hx  |   21 +++++++++++++++++++++
>  hmp.c            |   17 +++++++++++++++++
>  hmp.h            |    1 +
>  qapi-schema.json |   36 ++++++++++++++++++++++++++++++++++++
>  qemu-char.c      |   48 ++++++++++++++++++++++++++++++++++++++++++++++++
>  qmp-commands.hx  |   33 +++++++++++++++++++++++++++++++++
>  6 files changed, 156 insertions(+), 0 deletions(-)
> 
> diff --git a/hmp-commands.hx b/hmp-commands.hx
> index bcfea11..bdd48f3 100644
> --- a/hmp-commands.hx
> +++ b/hmp-commands.hx
> @@ -858,6 +858,27 @@ to char device 'memory'.
>  ETEXI
>  
>      {
> +        .name       = "memchar_read",
> +        .args_type  = "device:s,size:i",
> +        .params     = "device size",
> +        .help       = "Provide read interface for CirMemCharDriver. Read from"
> +                      "it and return the data with size.",
> +        .mhandler.cmd = hmp_memchar_read,
> +    },
> +
> +STEXI
> +@item memchar_read @var{device}
> +@findex memchar_read
> +Provide read interface for CirMemCharDriver. Read from char device
> +'memory' and return the data.
> +
> +@var{size} is the size of data want to read from. Refer to unencoded
> +size of the raw data, would adjust to the init size of the memchar
> +if the requested size is larger than it.
> +
> +ETEXI
> +
> +    {
>          .name       = "migrate",
>          .args_type  = "detach:-d,blk:-b,inc:-i,uri:s",
>          .params     = "[-d] [-b] [-i] uri",
> diff --git a/hmp.c b/hmp.c
> index 647316a..1f1df5d 100644
> --- a/hmp.c
> +++ b/hmp.c
> @@ -697,6 +697,23 @@ void hmp_memchar_write(Monitor *mon, const QDict *qdict)
>      hmp_handle_error(mon, &errp);
>  }
>  
> +void hmp_memchar_read(Monitor *mon, const QDict *qdict)
> +{
> +    uint32_t size = qdict_get_int(qdict, "size");
> +    const char *chardev = qdict_get_str(qdict, "device");
> +    MemCharRead *meminfo;
> +    Error *errp = NULL;
> +
> +    meminfo = qmp_memchar_read(chardev, size, false, 0, &errp);
> +    if (errp) {
> +        monitor_printf(mon, "%s\n", error_get_pretty(errp));
> +        error_free(errp);
> +        return;
> +    }
> +
> +    monitor_printf(mon, "%s, \n", meminfo->data);
> +}
> +
>  static void hmp_cont_cb(void *opaque, int err)
>  {
>      if (!err) {
> diff --git a/hmp.h b/hmp.h
> index 06d6ea2..076d8cf 100644
> --- a/hmp.h
> +++ b/hmp.h
> @@ -44,6 +44,7 @@ void hmp_cpu(Monitor *mon, const QDict *qdict);
>  void hmp_memsave(Monitor *mon, const QDict *qdict);
>  void hmp_pmemsave(Monitor *mon, const QDict *qdict);
>  void hmp_memchar_write(Monitor *mon, const QDict *qdict);
> +void hmp_memchar_read(Monitor *mon, const QDict *qdict);
>  void hmp_cont(Monitor *mon, const QDict *qdict);
>  void hmp_system_wakeup(Monitor *mon, const QDict *qdict);
>  void hmp_inject_nmi(Monitor *mon, const QDict *qdict);
> diff --git a/qapi-schema.json b/qapi-schema.json
> index 8202311..ad4e276 100644
> --- a/qapi-schema.json
> +++ b/qapi-schema.json
> @@ -363,6 +363,42 @@
>             '*format': 'DataFormat'} }
>  
>  ##
> +# @MemCharRead
> +#
> +# Result of QMP command memchar-read.
> +#
> +# @data: The data read from memchar as string.
> +#
> +# @count: The numbers of bytes read from.
> +#
> +# Since: 1.4
> +##
> +{ 'type': 'MemCharRead',
> +  'data': { 'data': 'str', 'count': 'int' } }
> +
> +##
> +# @memchar-read:
> +#
> +# Provide read interface for memchardev. Read from the char
> +# device 'memory' and return the data.
> +#
> +# @device: the name of the memory char device.
> +#
> +# @size: the size to read in bytes.
> +#
> +# @format: #optional the format of the data want to read from
> +#          memchardev, by default is 'utf8'.
> +#
> +# Returns: @MemCharRead
> +#          If @device is not a valid memchr device, DeviceNotFound
> +#
> +# Since: 1.4
> +##
> +{ 'command': 'memchar-read',
> +  'data': {'device': 'str', 'size': 'int', '*format': 'DataFormat'},
> +  'returns': 'MemCharRead' }
> +
> +##
>  # @CommandInfo:
>  #
>  # Information about a QMP command
> diff --git a/qemu-char.c b/qemu-char.c
> index dbd1a7c..c45397a 100644
> --- a/qemu-char.c
> +++ b/qemu-char.c
> @@ -2790,6 +2790,54 @@ void qmp_memchar_write(const char *device, int64_t size,
>      }
>  }
>  
> +MemCharRead *qmp_memchar_read(const char *device, int64_t size,
> +                              bool has_format, enum DataFormat format,
> +                              Error **errp)
> +{
> +    CharDriverState *chr;
> +    guchar *read_data;
> +    MemCharRead *meminfo;
> +    size_t count;
> +
> +    chr = qemu_chr_find(device);
> +    if (!chr) {
> +        error_set(errp, QERR_DEVICE_NOT_FOUND, device);
> +        return NULL;
> +    }
> +
> +    if (qemu_is_chr(chr, "memory")) {
> +        error_setg(errp,"%s is not memory char device", device);
> +        return NULL;
> +    }
> +
> +    if (size <= 0) {
> +        error_setg(errp, "size must be greater than zero");
> +        return NULL;
> +    }
> +
> +    /* Return empty strings when the buffer is empty. */
> +    if (cirmem_chr_is_empty(chr)) {
> +        return NULL;
> +    }

You can't just return NULL here, if you have to return MemCharRead. It's
not a problem to have an empty data and 0 size.

> +
> +    count = qemu_chr_cirmem_count(chr);
> +    size = size > count ? count : size;
> +    read_data = g_malloc0(size + 1);
> +
> +    meminfo = g_malloc0(sizeof(MemCharRead));
> +    meminfo->count = cirmem_chr_read(chr, read_data, size);
> +
> +    if (has_format && (format == DATA_FORMAT_BASE64)) {
> +       if (read_data) {
> +           meminfo->data = g_base64_encode(read_data, (size_t)meminfo->count);
> +       }
> +    } else {
> +        meminfo->data = (char *)read_data;
> +    }
> +
> +    return meminfo;
> +}
> +
>  QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename)
>  {
>      char host[65], port[33], width[8], height[8];
> diff --git a/qmp-commands.hx b/qmp-commands.hx
> index 8d10a67..17f83b3 100644
> --- a/qmp-commands.hx
> +++ b/qmp-commands.hx
> @@ -499,6 +499,39 @@ Example:
>  EQMP
>  
>      {
> +        .name       = "memchar-read",
> +        .args_type  = "device:s,size:i,format:s?",
> +        .mhandler.cmd_new = qmp_marshal_input_memchar_read,
> +    },
> +
> +SQMP
> +memchar-read
> +-------------
> +
> +Provide read interface for CirMemCharDriver. Read from the char
> +device memory and return the data with size.
> +
> +Arguments:
> +
> +- "device": the name of the char device, must be unique (json-string)
> +- "size": the memory size wanted to read in bytes (refer to unencoded
> +          size of the raw data), would adjust to the init size of the
> +          memchar if the requested size is larger than it. (json-int)
> +- "format": the data format write to memchardev, default is
> +            utf8. (json-string, optional)
> +          - Possible values: "utf8", "base64"
> +
> +Example:
> +
> +-> { "execute": "memchar-read",
> +                "arguments": { "device": foo,
> +                               "size": 1000,
> +                               "format": "utf8" } }
> +<- { "return": { "data": "data string...", "count": 1000 } }
> +
> +EQMP
> +
> +    {
>          .name       = "xen-save-devices-state",
>          .args_type  = "filename:F",
>      .mhandler.cmd_new = qmp_marshal_input_xen_save_devices_state,
Lei Li - Jan. 24, 2013, 10:24 a.m.
On 01/23/2013 11:42 PM, Luiz Capitulino wrote:
> On Wed, 23 Jan 2013 17:06:12 +0800
> Lei Li <lilei@linux.vnet.ibm.com> wrote:
>
>> Signed-off-by: Lei Li <lilei@linux.vnet.ibm.com>
>> ---
>>   hmp-commands.hx  |   21 +++++++++++++++++++++
>>   hmp.c            |   17 +++++++++++++++++
>>   hmp.h            |    1 +
>>   qapi-schema.json |   36 ++++++++++++++++++++++++++++++++++++
>>   qemu-char.c      |   48 ++++++++++++++++++++++++++++++++++++++++++++++++
>>   qmp-commands.hx  |   33 +++++++++++++++++++++++++++++++++
>>   6 files changed, 156 insertions(+), 0 deletions(-)
>>
>> diff --git a/hmp-commands.hx b/hmp-commands.hx
>> index bcfea11..bdd48f3 100644
>> --- a/hmp-commands.hx
>> +++ b/hmp-commands.hx
>> @@ -858,6 +858,27 @@ to char device 'memory'.
>>   ETEXI
>>   
>>       {
>> +        .name       = "memchar_read",
>> +        .args_type  = "device:s,size:i",
>> +        .params     = "device size",
>> +        .help       = "Provide read interface for CirMemCharDriver. Read from"
>> +                      "it and return the data with size.",
>> +        .mhandler.cmd = hmp_memchar_read,
>> +    },
>> +
>> +STEXI
>> +@item memchar_read @var{device}
>> +@findex memchar_read
>> +Provide read interface for CirMemCharDriver. Read from char device
>> +'memory' and return the data.
>> +
>> +@var{size} is the size of data want to read from. Refer to unencoded
>> +size of the raw data, would adjust to the init size of the memchar
>> +if the requested size is larger than it.
>> +
>> +ETEXI
>> +
>> +    {
>>           .name       = "migrate",
>>           .args_type  = "detach:-d,blk:-b,inc:-i,uri:s",
>>           .params     = "[-d] [-b] [-i] uri",
>> diff --git a/hmp.c b/hmp.c
>> index 647316a..1f1df5d 100644
>> --- a/hmp.c
>> +++ b/hmp.c
>> @@ -697,6 +697,23 @@ void hmp_memchar_write(Monitor *mon, const QDict *qdict)
>>       hmp_handle_error(mon, &errp);
>>   }
>>   
>> +void hmp_memchar_read(Monitor *mon, const QDict *qdict)
>> +{
>> +    uint32_t size = qdict_get_int(qdict, "size");
>> +    const char *chardev = qdict_get_str(qdict, "device");
>> +    MemCharRead *meminfo;
>> +    Error *errp = NULL;
>> +
>> +    meminfo = qmp_memchar_read(chardev, size, false, 0, &errp);
>> +    if (errp) {
>> +        monitor_printf(mon, "%s\n", error_get_pretty(errp));
>> +        error_free(errp);
>> +        return;
>> +    }
>> +
>> +    monitor_printf(mon, "%s, \n", meminfo->data);
>> +}
>> +
>>   static void hmp_cont_cb(void *opaque, int err)
>>   {
>>       if (!err) {
>> diff --git a/hmp.h b/hmp.h
>> index 06d6ea2..076d8cf 100644
>> --- a/hmp.h
>> +++ b/hmp.h
>> @@ -44,6 +44,7 @@ void hmp_cpu(Monitor *mon, const QDict *qdict);
>>   void hmp_memsave(Monitor *mon, const QDict *qdict);
>>   void hmp_pmemsave(Monitor *mon, const QDict *qdict);
>>   void hmp_memchar_write(Monitor *mon, const QDict *qdict);
>> +void hmp_memchar_read(Monitor *mon, const QDict *qdict);
>>   void hmp_cont(Monitor *mon, const QDict *qdict);
>>   void hmp_system_wakeup(Monitor *mon, const QDict *qdict);
>>   void hmp_inject_nmi(Monitor *mon, const QDict *qdict);
>> diff --git a/qapi-schema.json b/qapi-schema.json
>> index 8202311..ad4e276 100644
>> --- a/qapi-schema.json
>> +++ b/qapi-schema.json
>> @@ -363,6 +363,42 @@
>>              '*format': 'DataFormat'} }
>>   
>>   ##
>> +# @MemCharRead
>> +#
>> +# Result of QMP command memchar-read.
>> +#
>> +# @data: The data read from memchar as string.
>> +#
>> +# @count: The numbers of bytes read from.
>> +#
>> +# Since: 1.4
>> +##
>> +{ 'type': 'MemCharRead',
>> +  'data': { 'data': 'str', 'count': 'int' } }
>> +
>> +##
>> +# @memchar-read:
>> +#
>> +# Provide read interface for memchardev. Read from the char
>> +# device 'memory' and return the data.
>> +#
>> +# @device: the name of the memory char device.
>> +#
>> +# @size: the size to read in bytes.
>> +#
>> +# @format: #optional the format of the data want to read from
>> +#          memchardev, by default is 'utf8'.
>> +#
>> +# Returns: @MemCharRead
>> +#          If @device is not a valid memchr device, DeviceNotFound
>> +#
>> +# Since: 1.4
>> +##
>> +{ 'command': 'memchar-read',
>> +  'data': {'device': 'str', 'size': 'int', '*format': 'DataFormat'},
>> +  'returns': 'MemCharRead' }
>> +
>> +##
>>   # @CommandInfo:
>>   #
>>   # Information about a QMP command
>> diff --git a/qemu-char.c b/qemu-char.c
>> index dbd1a7c..c45397a 100644
>> --- a/qemu-char.c
>> +++ b/qemu-char.c
>> @@ -2790,6 +2790,54 @@ void qmp_memchar_write(const char *device, int64_t size,
>>       }
>>   }
>>   
>> +MemCharRead *qmp_memchar_read(const char *device, int64_t size,
>> +                              bool has_format, enum DataFormat format,
>> +                              Error **errp)
>> +{
>> +    CharDriverState *chr;
>> +    guchar *read_data;
>> +    MemCharRead *meminfo;
>> +    size_t count;
>> +
>> +    chr = qemu_chr_find(device);
>> +    if (!chr) {
>> +        error_set(errp, QERR_DEVICE_NOT_FOUND, device);
>> +        return NULL;
>> +    }
>> +
>> +    if (qemu_is_chr(chr, "memory")) {
>> +        error_setg(errp,"%s is not memory char device", device);
>> +        return NULL;
>> +    }
>> +
>> +    if (size <= 0) {
>> +        error_setg(errp, "size must be greater than zero");
>> +        return NULL;
>> +    }
>> +
>> +    /* Return empty strings when the buffer is empty. */
>> +    if (cirmem_chr_is_empty(chr)) {
>> +        return NULL;
>> +    }
> You can't just return NULL here, if you have to return MemCharRead. It's
> not a problem to have an empty data and 0 size.

ok, thanks.

>> +
>> +    count = qemu_chr_cirmem_count(chr);
>> +    size = size > count ? count : size;
>> +    read_data = g_malloc0(size + 1);
>> +
>> +    meminfo = g_malloc0(sizeof(MemCharRead));
>> +    meminfo->count = cirmem_chr_read(chr, read_data, size);
>> +
>> +    if (has_format && (format == DATA_FORMAT_BASE64)) {
>> +       if (read_data) {
>> +           meminfo->data = g_base64_encode(read_data, (size_t)meminfo->count);
>> +       }
>> +    } else {
>> +        meminfo->data = (char *)read_data;
>> +    }
>> +
>> +    return meminfo;
>> +}
>> +
>>   QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename)
>>   {
>>       char host[65], port[33], width[8], height[8];
>> diff --git a/qmp-commands.hx b/qmp-commands.hx
>> index 8d10a67..17f83b3 100644
>> --- a/qmp-commands.hx
>> +++ b/qmp-commands.hx
>> @@ -499,6 +499,39 @@ Example:
>>   EQMP
>>   
>>       {
>> +        .name       = "memchar-read",
>> +        .args_type  = "device:s,size:i,format:s?",
>> +        .mhandler.cmd_new = qmp_marshal_input_memchar_read,
>> +    },
>> +
>> +SQMP
>> +memchar-read
>> +-------------
>> +
>> +Provide read interface for CirMemCharDriver. Read from the char
>> +device memory and return the data with size.
>> +
>> +Arguments:
>> +
>> +- "device": the name of the char device, must be unique (json-string)
>> +- "size": the memory size wanted to read in bytes (refer to unencoded
>> +          size of the raw data), would adjust to the init size of the
>> +          memchar if the requested size is larger than it. (json-int)
>> +- "format": the data format write to memchardev, default is
>> +            utf8. (json-string, optional)
>> +          - Possible values: "utf8", "base64"
>> +
>> +Example:
>> +
>> +-> { "execute": "memchar-read",
>> +                "arguments": { "device": foo,
>> +                               "size": 1000,
>> +                               "format": "utf8" } }
>> +<- { "return": { "data": "data string...", "count": 1000 } }
>> +
>> +EQMP
>> +
>> +    {
>>           .name       = "xen-save-devices-state",
>>           .args_type  = "filename:F",
>>       .mhandler.cmd_new = qmp_marshal_input_xen_save_devices_state,
>

Patch

diff --git a/hmp-commands.hx b/hmp-commands.hx
index bcfea11..bdd48f3 100644
--- a/hmp-commands.hx
+++ b/hmp-commands.hx
@@ -858,6 +858,27 @@  to char device 'memory'.
 ETEXI
 
     {
+        .name       = "memchar_read",
+        .args_type  = "device:s,size:i",
+        .params     = "device size",
+        .help       = "Provide read interface for CirMemCharDriver. Read from"
+                      "it and return the data with size.",
+        .mhandler.cmd = hmp_memchar_read,
+    },
+
+STEXI
+@item memchar_read @var{device}
+@findex memchar_read
+Provide read interface for CirMemCharDriver. Read from char device
+'memory' and return the data.
+
+@var{size} is the size of data want to read from. Refer to unencoded
+size of the raw data, would adjust to the init size of the memchar
+if the requested size is larger than it.
+
+ETEXI
+
+    {
         .name       = "migrate",
         .args_type  = "detach:-d,blk:-b,inc:-i,uri:s",
         .params     = "[-d] [-b] [-i] uri",
diff --git a/hmp.c b/hmp.c
index 647316a..1f1df5d 100644
--- a/hmp.c
+++ b/hmp.c
@@ -697,6 +697,23 @@  void hmp_memchar_write(Monitor *mon, const QDict *qdict)
     hmp_handle_error(mon, &errp);
 }
 
+void hmp_memchar_read(Monitor *mon, const QDict *qdict)
+{
+    uint32_t size = qdict_get_int(qdict, "size");
+    const char *chardev = qdict_get_str(qdict, "device");
+    MemCharRead *meminfo;
+    Error *errp = NULL;
+
+    meminfo = qmp_memchar_read(chardev, size, false, 0, &errp);
+    if (errp) {
+        monitor_printf(mon, "%s\n", error_get_pretty(errp));
+        error_free(errp);
+        return;
+    }
+
+    monitor_printf(mon, "%s, \n", meminfo->data);
+}
+
 static void hmp_cont_cb(void *opaque, int err)
 {
     if (!err) {
diff --git a/hmp.h b/hmp.h
index 06d6ea2..076d8cf 100644
--- a/hmp.h
+++ b/hmp.h
@@ -44,6 +44,7 @@  void hmp_cpu(Monitor *mon, const QDict *qdict);
 void hmp_memsave(Monitor *mon, const QDict *qdict);
 void hmp_pmemsave(Monitor *mon, const QDict *qdict);
 void hmp_memchar_write(Monitor *mon, const QDict *qdict);
+void hmp_memchar_read(Monitor *mon, const QDict *qdict);
 void hmp_cont(Monitor *mon, const QDict *qdict);
 void hmp_system_wakeup(Monitor *mon, const QDict *qdict);
 void hmp_inject_nmi(Monitor *mon, const QDict *qdict);
diff --git a/qapi-schema.json b/qapi-schema.json
index 8202311..ad4e276 100644
--- a/qapi-schema.json
+++ b/qapi-schema.json
@@ -363,6 +363,42 @@ 
            '*format': 'DataFormat'} }
 
 ##
+# @MemCharRead
+#
+# Result of QMP command memchar-read.
+#
+# @data: The data read from memchar as string.
+#
+# @count: The numbers of bytes read from.
+#
+# Since: 1.4
+##
+{ 'type': 'MemCharRead',
+  'data': { 'data': 'str', 'count': 'int' } }
+
+##
+# @memchar-read:
+#
+# Provide read interface for memchardev. Read from the char
+# device 'memory' and return the data.
+#
+# @device: the name of the memory char device.
+#
+# @size: the size to read in bytes.
+#
+# @format: #optional the format of the data want to read from
+#          memchardev, by default is 'utf8'.
+#
+# Returns: @MemCharRead
+#          If @device is not a valid memchr device, DeviceNotFound
+#
+# Since: 1.4
+##
+{ 'command': 'memchar-read',
+  'data': {'device': 'str', 'size': 'int', '*format': 'DataFormat'},
+  'returns': 'MemCharRead' }
+
+##
 # @CommandInfo:
 #
 # Information about a QMP command
diff --git a/qemu-char.c b/qemu-char.c
index dbd1a7c..c45397a 100644
--- a/qemu-char.c
+++ b/qemu-char.c
@@ -2790,6 +2790,54 @@  void qmp_memchar_write(const char *device, int64_t size,
     }
 }
 
+MemCharRead *qmp_memchar_read(const char *device, int64_t size,
+                              bool has_format, enum DataFormat format,
+                              Error **errp)
+{
+    CharDriverState *chr;
+    guchar *read_data;
+    MemCharRead *meminfo;
+    size_t count;
+
+    chr = qemu_chr_find(device);
+    if (!chr) {
+        error_set(errp, QERR_DEVICE_NOT_FOUND, device);
+        return NULL;
+    }
+
+    if (qemu_is_chr(chr, "memory")) {
+        error_setg(errp,"%s is not memory char device", device);
+        return NULL;
+    }
+
+    if (size <= 0) {
+        error_setg(errp, "size must be greater than zero");
+        return NULL;
+    }
+
+    /* Return empty strings when the buffer is empty. */
+    if (cirmem_chr_is_empty(chr)) {
+        return NULL;
+    }
+
+    count = qemu_chr_cirmem_count(chr);
+    size = size > count ? count : size;
+    read_data = g_malloc0(size + 1);
+
+    meminfo = g_malloc0(sizeof(MemCharRead));
+    meminfo->count = cirmem_chr_read(chr, read_data, size);
+
+    if (has_format && (format == DATA_FORMAT_BASE64)) {
+       if (read_data) {
+           meminfo->data = g_base64_encode(read_data, (size_t)meminfo->count);
+       }
+    } else {
+        meminfo->data = (char *)read_data;
+    }
+
+    return meminfo;
+}
+
 QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename)
 {
     char host[65], port[33], width[8], height[8];
diff --git a/qmp-commands.hx b/qmp-commands.hx
index 8d10a67..17f83b3 100644
--- a/qmp-commands.hx
+++ b/qmp-commands.hx
@@ -499,6 +499,39 @@  Example:
 EQMP
 
     {
+        .name       = "memchar-read",
+        .args_type  = "device:s,size:i,format:s?",
+        .mhandler.cmd_new = qmp_marshal_input_memchar_read,
+    },
+
+SQMP
+memchar-read
+-------------
+
+Provide read interface for CirMemCharDriver. Read from the char
+device memory and return the data with size.
+
+Arguments:
+
+- "device": the name of the char device, must be unique (json-string)
+- "size": the memory size wanted to read in bytes (refer to unencoded
+          size of the raw data), would adjust to the init size of the
+          memchar if the requested size is larger than it. (json-int)
+- "format": the data format write to memchardev, default is
+            utf8. (json-string, optional)
+          - Possible values: "utf8", "base64"
+
+Example:
+
+-> { "execute": "memchar-read",
+                "arguments": { "device": foo,
+                               "size": 1000,
+                               "format": "utf8" } }
+<- { "return": { "data": "data string...", "count": 1000 } }
+
+EQMP
+
+    {
         .name       = "xen-save-devices-state",
         .args_type  = "filename:F",
     .mhandler.cmd_new = qmp_marshal_input_xen_save_devices_state,