In memory QEMUFile
v2 cover In memory QEMUFile
From: "Dr. David Alan Gilbert" <[email protected]>
Hi,
This patch-pair adds the QEMUSizedBuffer based in-memory QEMUFile
written by Stefan Berger and Joel Schopp. I've made some minor fixes (and typo cleanups) and modified the existing test-vmstate to use it for some test cases.
While there's nothing other than test cases using it yet, I think
it's worth going in by itself, since I'm using it in two separate patchsets (postcopy and visitor/BER) and Sanidhya uses it in the periodic vmstate test world. In addition both microcheckpointing and COLO have similar but independent implementations (although they both have some extra-gotcha's so it might not be possible to reuse it), and there was another implementation of the same thing in the Yabusame Postcopy world. Thus it seems best to put in, if only to stop people writing yet another implementation.
Dr. David Alan Gilbert (2):
QEMUSizedBuffer based QEMUFile
Tests: QEMUSizedBuffer/QEMUBuffer
include/migration/qemu-file.h | 28 +++ include/qemu/typedefs.h | 1 + qemu-file.c | 410 ++++++++++++++++++++++++++++++++++++++++++ tests/Makefile | 2 +- tests/test-vmstate.c | 73 ++++---- 5 files changed, 477 insertions(+), 37 deletions(-)
Signature · 2 lines
v2 Comment space fixes 1.9.3
PATCH v2 1/2 QEMUSizedBuffer based QEMUFile
From: "Dr. David Alan Gilbert" <[email protected]>
This is based on Stefan and Joel's patch that creates a QEMUFile that goes to a memory buffer; from:
http://lists.gnu.org/archive/html/qemu-devel/2013-03/msg05036.html
Using the QEMUFile interface, this patch adds support functions for operating on in-memory sized buffers that can be written to or read from.
For minor tweeks/rebase I've done to it:
--- include/migration/qemu-file.h | 28 +++ include/qemu/typedefs.h | 1 + qemu-file.c | 410 ++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 439 insertions(+)
include/migration/qemu-file.h +28 -0
@@ -25,6 +25,8 @@#define QEMU_FILE_H 1#include "exec/cpu-common.h" +#include <stdint.h> +/* This function writes a chunk of data to a file at the given position. * The pos argument can be ignored if the file is only being used for * streaming. The handler should try to write all of the data it can.
@@ -94,11 +96,21 @@ typedef struct QEMUFileOps {QEMURamSaveFunc *save_page; } QEMUFileOps; +struct QEMUSizedBuffer { +struct iovec *iov; +size_t n_iov; +size_t size;/* total allocated size in all iov's */ +size_t used;/* number of used bytes */ +}; + +typedef struct QEMUSizedBuffer QEMUSizedBuffer ; +QEMUFile *qemu_fopen_ops (void *opaque,const QEMUFileOps *ops);QEMUFile *qemu_fopen (const char *filename,const char *mode);QEMUFile *qemu_fdopen (int fd,const char *mode);QEMUFile *qemu_fopen_socket (int fd,const char *mode);QEMUFile *qemu_popen_cmd (const char *command,const char *mode); +QEMUFile *qemu_bufopen (const char *mode,QEMUSizedBuffer *input);int qemu_get_fd (QEMUFile *f);int qemu_fclose (QEMUFile *f);int64_t qemu_ftell (QEMUFile *f);
@@ -111,6 +123,22 @@ void qemu_put_byte(QEMUFile *f, int v);void qemu_put_buffer_async (QEMUFile *f,const uint8_t *buf,int size);bool qemu_file_mode_is_not_valid (const char *mode); +QEMUSizedBuffer *qsb_create (const uint8_t *buffer,size_t len); +QEMUSizedBuffer *qsb_clone (const QEMUSizedBuffer *); +void qsb_free (QEMUSizedBuffer *); +size_t qsb_set_length (QEMUSizedBuffer *qsb,size_t length); +size_t qsb_get_length (const QEMUSizedBuffer *qsb); +ssize_t qsb_get_buffer (const QEMUSizedBuffer *,off_t start,size_t count, +uint8_t **buf); +ssize_t qsb_write_at (QEMUSizedBuffer *qsb,const uint8_t *buf, +off_t pos,size_t count); + + +/* +* For use on files opened with qemu_bufopen +*/ +const QEMUSizedBuffer *qemu_buf_get (QEMUFile *f); +static inline void qemu_put_ubyte (QEMUFile *f,unsigned int v) {qemu_put_byte (f, (int )v);
include/qemu/typedefs.h +1 -0
@@ -60,6 +60,7 @@ typedef struct PCIEAERLog PCIEAERLog;typedef struct PCIEAERErr PCIEAERErr ;typedef struct PCIEPort PCIEPort ;typedef struct PCIESlot PCIESlot ; +typedef struct QEMUSizedBuffer QEMUSizedBuffer ;typedef struct MSIMessage MSIMessage ;typedef struct SerialState SerialState ;typedef struct PCMCIACardState PCMCIACardState ;
qemu-file.c +410 -0
413 lines not on this page · raw message
Signature · 1 line
1.9.3
Re: [Qemu-devel] [PATCH v2 1/2] QEMUSizedBuffer based QEMUFile
Quoted 23 lines · Dr. David Alan Gilbert (git)
From: "Dr. David Alan Gilbert" <[email protected]>
This is based on Stefan and Joel's patch that creates a QEMUFile that goes to a memory buffer; from:
http://lists.gnu.org/archive/html/qemu-devel/2013-03/msg05036.html
Using the QEMUFile interface, this patch adds support functions for operating on in-memory sized buffers that can be written to or read from.
Signed-off-by Stefan Berger <[email protected]>Signed-off-by Joel Schopp <[email protected]>For minor tweeks/rebase I've done to it:
Signed-off-by Dr. David Alan Gilbert <[email protected]>--- include/migration/qemu-file.h | 28 +++ include/qemu/typedefs.h | 1 + qemu-file.c | 410 ++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 439 insertions(+)
include/migration/qemu-file.h void qemu_put_byte(QEMUFile *f, int v); · line 129
Quoted 4 lines
include/migration/qemu-file.h +4
-0+QEMUSizedBuffer *qsb_create (const uint8_t *buffer,size_t len); +QEMUSizedBuffer *qsb_clone (const QEMUSizedBuffer *); +void qsb_free (QEMUSizedBuffer *); +size_t qsb_set_length (QEMUSizedBuffer *qsb,size_t length);
Just on the prototype, I wonder if this should return ssize_t, to allow for the possibility of failure...
Quoted 14 lines
qemu-file.c +14
-0+/** +* Create a QEMUSizedBuffer +* This type of buffer uses scatter-gather lists internally and +* can grow to any size. Any data array in the scatter-gather list +* can hold different amount of bytes. +* +* @buffer: Optional buffer to copy into the QSB +* @len: size of initial buffer; if @buffer is given, buffer must +* hold at least len bytes +* +* Returns a pointer to a QEMUSizedBuffer +*/ +QEMUSizedBuffer *qsb_create (const uint8_t *buffer,size_t len) +{
qemu-file.c uint64_t qemu_get_be64(QEMUFile *f) · line 908
Quoted 10 lines
qemu-file.c +10
-0+QEMUSizedBuffer *qsb; +size_t alloc_len, num_chunks, i, to_copy; +size_t chunk_size = (len >QSB_MAX_CHUNK_SIZE ) + ?QSB_MAX_CHUNK_SIZE + :QSB_CHUNK_SIZE ; + +if (len ==0 ) { +/* we want to allocate at least one chunk */ + len =QSB_CHUNK_SIZE ; + }
So if I call qsb_create("", 0), len is now QSB_CHUNK_SIZE...
Review
Quoted 2 lines
(quoted diff) +2
-0+ + num_chunks = DIV_ROUND_UP(len, chunk_size);
...num_chunks is now 1...
qemu-file.c uint64_t qemu_get_be64(QEMUFile *f) · line 920
Quoted 10 lines
qemu-file.c +10
-0+ alloc_len = num_chunks * chunk_size; + + qsb =g_new0 (QEMUSizedBuffer,1 ); + qsb->iov = g_new0(struct iovec, num_chunks); + qsb->n_iov = num_chunks; + +for (i =0 ; i < num_chunks; i++) { + qsb->iov[i].iov_base =g_malloc0 (chunk_size); + qsb->iov[i].iov_len = chunk_size; +if (buffer) {
...we enter the loop, and have a buffer to copy...
qemu-file.c uint64_t qemu_get_be64(QEMUFile *f) · line 923
Quoted 3 lines
qemu-file.c +3
-0+ to_copy = (len - qsb->used) > chunk_size + ? chunk_size : (len - qsb->used); +memcpy (qsb->iov[i].iov_base, &buffer[qsb->used], to_copy);
...and proceed to dereference QSB_CHUNK_SIZE bytes beyond the end of the empty string that we are converting to a buffer. Oops.
Might be as simple as adding if (buffer) { assert(len); } before modifying len.
Quoted 11 lines
+/**
+ * Set the length of the buffer; the primary usage of this
+ * function is to truncate the number of used bytes in the buffer.
+ * The size will not be extended beyond the current number of
+ * allocated bytes in the QEMUSizedBuffer.
+ *
+ * @qsb: A QEMUSizedBuffer
+ * @new_len: The new length of bytes in the buffer
+ *
+ * Returns the number of bytes the buffer was truncated or extended
+ * to.
Confusing; I'd suggest:
Returns the resulting (possibly new) size of the buffer. Oh, and my earlier question appears to be answered - this function can't fail.
Quoted 4 lines
qemu-file.c +4
-0+ssize_t qsb_get_buffer (const QEMUSizedBuffer *qsb,off_t start, +size_t count,uint8_t **buf) +{ +uint8_t *buffer;
qemu-file.c uint64_t qemu_get_be64(QEMUFile *f) · line 1048
Quoted 10 lines
qemu-file.c +10
-0+const struct iovec *iov; +size_t to_copy, all_copy; +ssize_t index; +off_t s_off; +off_t d_off =0 ; +char *s; + +if (start > qsb->used) { +return 0 ; + }
It feels confusing that this can return 0 while leaving buf un-malloc'd.
It's probably simpler to callers if a non-negative return value ALWAYS
guarantees that buf is valid.
qemu-file.c uint64_t qemu_get_be64(QEMUFile *f) · line 1065
Quoted 5 lines
qemu-file.c +5
-0+ + index =qsb_get_iovec (qsb, start, &s_off); +if (index <0 ) { +return 0 ; + }
Wait - how is a negative value possible? Since we already checked against qsb->used, can't this be assert(index >= 0)?
qemu-file.c uint64_t qemu_get_be64(QEMUFile *f) · line 1107
Quoted 9 lines
qemu-file.c +9
-0+static ssize_t qsb_grow (QEMUSizedBuffer *qsb,size_t new_size) +{ +size_t needed_chunks, i; +size_t chunk_size =QSB_CHUNK_SIZE ; + +if (qsb->size < new_size) { + needed_chunks =DIV_ROUND_UP (new_size - qsb->size, + chunk_size); +
Hmm. Original creation will use chunks larger than QSB_CHUNK_SIZE (up to the maximum chunk size), presumably for efficiency. Should this function likewise use larger chunks if the size to be grown is larger than the default chunk size?
qemu-file.c uint64_t qemu_get_be64(QEMUFile *f) · line 1110
Quoted 3 lines
qemu-file.c +3
-0+ qsb->iov =g_realloc_n (qsb->iov, qsb->n_iov + needed_chunks, +sizeof (struct iovec )); +if (qsb->iov ==NULL ) {
Wait. Can g_realloc_n fail? I know that g_malloc can't fail, and you have to use g_try_malloc instead. Do you need to try a different variant?
qemu-file.c uint64_t qemu_get_be64(QEMUFile *f) · line 1115
Quoted 5 lines
qemu-file.c +5
-0+return -ENOMEM ; + } + +for (i = qsb->n_iov; i < qsb->n_iov + needed_chunks; i++) { + qsb->iov[i].iov_base =g_malloc0 (chunk_size);
Wait. Why do you care about realloc'ing the iov array failing (unlikely, as that's a relatively small allocation unlikely to be more than a megabyte) but completely ignore the possibility of abort'ing when g_malloc0 of a chunk size fails (much bigger, and therefore more likely to fail if memory pressure is high)? Either abort is always fine (no need to ever report -ENOMEM) or you should be using a different allocation function here.
Quoted 8 lines
+/**
+ * Write into the QEMUSizedBuffer at a given position and a given
+ * number of bytes. This function will automatically grow the
+ * QEMUSizedBuffer.
+ *
+ * @qsb: A QEMUSizedBuffer
+ * @source: A byte array to copy data from
+ * @pos: The position withing the @qsb to write data to
s/withing/within/
Quoted 16 lines
+ * @size: The number of bytes to copy into the @qsb
+ *
+ * Returns an error code in case of memory allocation failure,
+ * @size otherwise.
+ */qemu-file.c +11
-0+ssize_t qsb_write_at (QEMUSizedBuffer *qsb,const uint8_t *source, +off_t pos,size_t count) +{ +ssize_t rc =qsb_grow (qsb, pos + count); +size_t to_copy; +size_t all_copy = count; +const struct iovec *iov; +ssize_t index; +char *dest; +off_t d_off, s_off =0 ; +
qemu-file.c uint64_t qemu_get_be64(QEMUFile *f) · line 1159
Quoted 10 lines
qemu-file.c +10
-0+if (rc <0 ) { +return rc; + } + +if (pos + count > qsb->used) { + qsb->used = pos + count; + } + + index =qsb_get_iovec (qsb, pos, &d_off); +if (index <0 ) {
Shouldn't this be an assert, because the prior qsb_grow() should have guaranteed that we are large enough?
Quoted 2 lines
+/**
+ * Create an exact copy of the given QEMUSizedBuffer.
s/exact // - it's definitely a copy representing the same contents, but might have different boundaries for internal iovs, so omitting the word will avoid confusion on whether that was intended. (If you wanted an exact copy, then I would manually allocate each iov to the right size, and memcpy contents over from the original, instead of using qsb_create and qsb_write_at).
Signature · 2 lines
Eric Blake eblake redhat com +1-919-301-3266 Libvirt virtualization library http://libvirt.org
Re: [Qemu-devel] [PATCH v2 1/2] QEMUSizedBuffer based QEMUFile
Quoted 5 lines · * Eric Blake ([email protected]) wrote:
Quoted 4 lines · Dr. David Alan Gilbert (git)
From: "Dr. David Alan Gilbert" <[email protected]>
This is based on Stefan and Joel's patch that creates a QEMUFile that goes to a memory buffer; from:
Hi Eric,
I think I agree with most of your points here; and believe I've nailed
them in the v3 I've just posted.
Dave
Quoted 208 lines
Quoted 19 lines
http://lists.gnu.org/archive/html/qemu-devel/2013-03/msg05036.html
Using the QEMUFile interface, this patch adds support functions for operating on in-memory sized buffers that can be written to or read from.
Signed-off-by Stefan Berger <[email protected]>Signed-off-by Joel Schopp <[email protected]>For minor tweeks/rebase I've done to it:
Signed-off-by Dr. David Alan Gilbert <[email protected]>--- include/migration/qemu-file.h | 28 +++ include/qemu/typedefs.h | 1 + qemu-file.c | 410 ++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 439 insertions(+)include/migration/qemu-file.h void qemu_put_byte(QEMUFile *f, int v); · line 129
Quoted 4 lines
include/migration/qemu-file.h +4
-0+QEMUSizedBuffer *qsb_create (const uint8_t *buffer,size_t len); +QEMUSizedBuffer *qsb_clone (const QEMUSizedBuffer *); +void qsb_free (QEMUSizedBuffer *); +size_t qsb_set_length (QEMUSizedBuffer *qsb,size_t length);Just on the prototype, I wonder if this should return
ssize_t, to allow for the possibility of failure...Quoted 14 lines
qemu-file.c +14
-0+/** +* Create a QEMUSizedBuffer +* This type of buffer uses scatter-gather lists internally and +* can grow to any size. Any data array in the scatter-gather list +* can hold different amount of bytes. +* +* @buffer: Optional buffer to copy into the QSB +* @len: size of initial buffer; if @buffer is given, buffer must +* hold at least len bytes +* +* Returns a pointer to a QEMUSizedBuffer +*/ +QEMUSizedBuffer *qsb_create (const uint8_t *buffer,size_t len) +{qemu-file.c uint64_t qemu_get_be64(QEMUFile *f) · line 908
Quoted 10 lines
qemu-file.c +10
-0+QEMUSizedBuffer *qsb; +size_t alloc_len, num_chunks, i, to_copy; +size_t chunk_size = (len >QSB_MAX_CHUNK_SIZE ) + ?QSB_MAX_CHUNK_SIZE + :QSB_CHUNK_SIZE ; + +if (len ==0 ) { +/* we want to allocate at least one chunk */ + len =QSB_CHUNK_SIZE ; + }So if I call
qsb_create("", 0), len is nowQSB_CHUNK_SIZE...Review
Quoted 2 lines
(quoted diff) +2
-0+ + num_chunks = DIV_ROUND_UP(len, chunk_size);...num_chunks is now 1...
qemu-file.c uint64_t qemu_get_be64(QEMUFile *f) · line 920
Quoted 10 lines
qemu-file.c +10
-0+ alloc_len = num_chunks * chunk_size; + + qsb =g_new0 (QEMUSizedBuffer,1 ); + qsb->iov = g_new0(struct iovec, num_chunks); + qsb->n_iov = num_chunks; + +for (i =0 ; i < num_chunks; i++) { + qsb->iov[i].iov_base =g_malloc0 (chunk_size); + qsb->iov[i].iov_len = chunk_size; +if (buffer) {...we enter the loop, and have a buffer to copy...
qemu-file.c uint64_t qemu_get_be64(QEMUFile *f) · line 923
Quoted 3 lines
qemu-file.c +3
-0+ to_copy = (len - qsb->used) > chunk_size + ? chunk_size : (len - qsb->used); +memcpy (qsb->iov[i].iov_base, &buffer[qsb->used], to_copy);...and proceed to dereference
QSB_CHUNK_SIZEbytes beyond the end of the empty string that we are converting to a buffer. Oops.Might be as simple as adding if (buffer) { assert(len); } before modifying len.
Quoted 11 lines
+/**
+ * Set the length of the buffer; the primary usage of this
+ * function is to truncate the number of used bytes in the buffer.
+ * The size will not be extended beyond the current number of
+ * allocated bytes in the QEMUSizedBuffer.
+ *
+ * @qsb: A QEMUSizedBuffer
+ * @new_len: The new length of bytes in the buffer
+ *
+ * Returns the number of bytes the buffer was truncated or extended
+ * to.Confusing; I'd suggest:
Returns the resulting (possibly new) size of the buffer. Oh, and my earlier question appears to be answered - this function can't fail.
Quoted 4 lines
qemu-file.c +4
-0+ssize_t qsb_get_buffer (const QEMUSizedBuffer *qsb,off_t start, +size_t count,uint8_t **buf) +{ +uint8_t *buffer;qemu-file.c uint64_t qemu_get_be64(QEMUFile *f) · line 1048
Quoted 10 lines
qemu-file.c +10
-0+const struct iovec *iov; +size_t to_copy, all_copy; +ssize_t index; +off_t s_off; +off_t d_off =0 ; +char *s; + +if (start > qsb->used) { +return 0 ; + }It feels confusing that this can return 0 while leaving buf un-malloc'd.
It's probably simpler to callers if a non-negative return value ALWAYS
guarantees that buf is valid.qemu-file.c uint64_t qemu_get_be64(QEMUFile *f) · line 1065
Quoted 5 lines
qemu-file.c +5
-0+ + index =qsb_get_iovec (qsb, start, &s_off); +if (index <0 ) { +return 0 ; + }Wait - how is a negative value possible? Since we already checked against
qsb->used, can't this be assert(index >= 0)?qemu-file.c uint64_t qemu_get_be64(QEMUFile *f) · line 1107
Quoted 9 lines
qemu-file.c +9
-0+static ssize_t qsb_grow (QEMUSizedBuffer *qsb,size_t new_size) +{ +size_t needed_chunks, i; +size_t chunk_size =QSB_CHUNK_SIZE ; + +if (qsb->size < new_size) { + needed_chunks =DIV_ROUND_UP (new_size - qsb->size, + chunk_size); +Hmm. Original creation will use chunks larger than
QSB_CHUNK_SIZE(up to the maximum chunk size), presumably for efficiency. Should this function likewise use larger chunks if the size to be grown is larger than the default chunk size?qemu-file.c uint64_t qemu_get_be64(QEMUFile *f) · line 1110
Quoted 3 lines
qemu-file.c +3
-0+ qsb->iov =g_realloc_n (qsb->iov, qsb->n_iov + needed_chunks, +sizeof (struct iovec )); +if (qsb->iov ==NULL ) {Wait. Can
g_realloc_nfail? I know thatg_malloccan't fail, and you have to useg_try_mallocinstead. Do you need to try a different variant?qemu-file.c uint64_t qemu_get_be64(QEMUFile *f) · line 1115
Quoted 5 lines
qemu-file.c +5
-0+return -ENOMEM ; + } + +for (i = qsb->n_iov; i < qsb->n_iov + needed_chunks; i++) { + qsb->iov[i].iov_base =g_malloc0 (chunk_size);Wait. Why do you care about realloc'ing the iov array failing (unlikely, as that's a relatively small allocation unlikely to be more than a megabyte) but completely ignore the possibility of abort'ing when
g_malloc0of a chunk size fails (much bigger, and therefore more likely to fail if memory pressure is high)? Either abort is always fine (no need to ever report-ENOMEM) or you should be using a different allocation function here.Quoted 8 lines
+/**
+ * Write into the QEMUSizedBuffer at a given position and a given
+ * number of bytes. This function will automatically grow the
+ * QEMUSizedBuffer.
+ *
+ * @qsb: A QEMUSizedBuffer
+ * @source: A byte array to copy data from
+ * @pos: The position withing the @qsb to write data tos/withing/within/
Quoted 16 lines
+ * @size: The number of bytes to copy into the @qsb
+ *
+ * Returns an error code in case of memory allocation failure,
+ * @size otherwise.
+ */qemu-file.c +11
-0+ssize_t qsb_write_at (QEMUSizedBuffer *qsb,const uint8_t *source, +off_t pos,size_t count) +{ +ssize_t rc =qsb_grow (qsb, pos + count); +size_t to_copy; +size_t all_copy = count; +const struct iovec *iov; +ssize_t index; +char *dest; +off_t d_off, s_off =0 ; +qemu-file.c uint64_t qemu_get_be64(QEMUFile *f) · line 1159
Quoted 10 lines
qemu-file.c +10
-0+if (rc <0 ) { +return rc; + } + +if (pos + count > qsb->used) { + qsb->used = pos + count; + } + + index =qsb_get_iovec (qsb, pos, &d_off); +if (index <0 ) {Shouldn't this be an assert, because the prior
qsb_grow()should have guaranteed that we are large enough?Quoted 2 lines
+/**
+ * Create an exact copy of the given QEMUSizedBuffer.
Quoted 11 lines
s/exact // - it's definitely a copy representing the same contents, but might have different boundaries for internal iovs, so omitting the word will avoid confusion on whether that was intended. (If you wanted an exact copy, then I would manually allocate each iov to the right size, and memcpy contents over from the original, instead of using
qsb_createandqsb_write_at).Signature · 2 lines
Eric Blake eblake redhat com +1-919-301-3266 Libvirt virtualization library http://libvirt.org
--
Dr. David Alan Gilbert / [email protected] / Manchester, UK
PATCH v2 2/2 Tests: QEMUSizedBuffer/QEMUBuffer
In reply to Dr. David Alan Gilbert (git)From: "Dr. David Alan Gilbert" <[email protected]>
Modify some of tests/test-vmstate.c to use the in memory file based on QEMUSizedBuffer to provide basic testing of QEMUSizedBuffer and the associated memory backed QEMUFile type.
Only some of the tests are changed so that the fd backed QEMUFile is still tested.
--- tests/Makefile | 2 +- tests/test-vmstate.c | 73 ++++++++++++++++++++++++++-------------------------- 2 files changed, 38 insertions(+), 37 deletions(-)
tests/Makefile +1 -1
@@ -253,7 +253,7 @@ tests/test-qdev-global-props$(EXESUF): tests/test-qdev-global-props.o \ libqemuutil.a libqemustub.a tests/test-vmstate$(EXESUF): tests/test-vmstate.o \ vmstate.o qemu-file.o \ - libqemuutil.a + libqemuutil.a libqemustub.a tests/test-qapi-types.c tests/test-qapi-types.h :\ $(SRC_PATH)/tests/qapi-schema/qapi-schema-test.json $(SRC_PATH)/scripts/qapi-types.py
tests/test-vmstate.c +37 -36
142 lines not on this page · raw message
Signature · 1 line
1.9.3