vmstate: Implement VMS_ARRAY_OF_POINTER_AUTO_ALLOC
cover vmstate: Implement VMS_ARRAY_OF_POINTER_AUTO_ALLOC
CI: https://gitlab.com/peterx/qemu/-/pipelines/2424266591
(one checkpatch warning, not relevant to this series)
rfcv1: https://lore.kernel.org/r/[email protected]
rfcv2: https://lore.kernel.org/r/[email protected]
Changelog rfcv2->v1:
- Rebased to latest fabiano's migration-staging branch (bd698d7730)
- Collected new tags
- Patch 1
- Add space between "_type*" [Phil]
- Patch 9
- Slight refactoring on vmstate_load_next() [Fabiano]
- I collected Alexander's tested-by even if strictly I shouldn't when the patch changed; if test fails, it's me to blame.
This is v1, I removed RFC as I we should have reached some form of consensus in general. It is based on Fabiano's migration-staging branch. I've pushed this tree here for easier reference:
https://gitlab.com/peterx/qemu/-/tree/vmstate-array-null
This series implements a new vmstate flag that allows real dynamic array of pointers to be migrated, so that QEMU vmstate core will be able to identify NULL and non-NULL pointers pointing to any kind of VMSD (or base types), then properly allocate memory for them on dest QEMU.
The first planned user of such is Alexander's NVMe migration series here:
https://lore.kernel.org/r/[email protected]
This is another alternative to solve this problem.
I tested analyze-migration.py with this version and it works with an idle dump from the nvme series (after I rebase).
Thanks,
Alexander Mikhalitsyn (1):
tests/unit/test-vmstate: add tests for VMS_ARRAY_OF_POINTER_AUTO_ALLOC
Fabiano Rosas (1):
vmstate: Stop checking size for nullptr compression
Peter Xu (9):
vmstate: Pass in struct itself for VMSTATE_ARRAY_OF_POINTER
vmstate: Pass in struct itself for VMSTATE_VARRAY_OF_POINTER_UINT32
vmstate: Do not set size for VMS_ARRAY_OF_POINTER
vmstate: Update max_elems early and check field compressable once
vmstate: Rename VMS_NULLPTR_MARKER to VMS_MARKER_PTR_NULL
vmstate: Introduce vmstate_save_field_with_vmdesc()
vmstate: Allow vmstate_info_nullptr to emit non-NULL markers
vmstate: Implement load of ptr marker in vmstate core
vmstate: Implement VMS_ARRAY_OF_POINTER_AUTO_ALLOC
include/hw/intc/riscv_aclint.h | 6 +- include/migration/vmstate.h | 88 ++++++++++-- migration/savevm.c | 28 ++++ migration/vmstate-types.c | 36 ++--- migration/vmstate.c | 247 ++++++++++++++++++++++++++------- tests/unit/test-vmstate.c | 90 +++++++++++- roms/seabios-hppa | 2 +- scripts/analyze-migration.py | 22 +-- 8 files changed, 418 insertions(+), 101 deletions(-)
Signature · 1 line
2.50.1
PATCH 1/11 vmstate: Pass in struct itself for VMSTATE_ARRAY_OF_POINTER
Passing in a pointer almost never helps. Convert it to pass in struct for further refactoring on VMS_ARRAY_OF_POINTER.
--- include/migration/vmstate.h | 6 +++--- tests/unit/test-vmstate.c | 2 +- roms/seabios-hppa | 2 +- 3 files changed, 5 insertions(+), 5 deletions(-)
include/migration/vmstate.h +3 -3
@@ -547,9 +547,9 @@ extern const VMStateInfo vmstate_info_qlist; .version_id = (_version), \ .num = (_num), \ .info = &(_info), \ - .size = sizeof(_type), \ + .size = sizeof(_type *), \ .flags = VMS_ARRAY|VMS_ARRAY_OF_POINTER, \ - .offset = vmstate_offset_array(_state, _field, _type, _num), \ + .offset = vmstate_offset_array(_state, _field, _type *, _num), \ }#define VMSTATE_ARRAY_OF_POINTER_TO_STRUCT (_f, _s, _n, _v, _vmsd, _type) { \
@@ -1093,7 +1093,7 @@ extern const VMStateInfo vmstate_info_qlist; VMSTATE_TIMER_PTR_V(_f, _s, 0)#define VMSTATE_TIMER_PTR_ARRAY (_f, _s, _n) \ - VMSTATE_ARRAY_OF_POINTER(_f, _s, _n, 0, vmstate_info_timer, QEMUTimer *) + VMSTATE_ARRAY_OF_POINTER(_f, _s, _n, 0, vmstate_info_timer, QEMUTimer)#define VMSTATE_TIMER_TEST (_f, _s, _test) \ VMSTATE_SINGLE_TEST(_f, _s, _test, 0, vmstate_info_timer, QEMUTimer)
tests/unit/test-vmstate.c +1 -1
@@ -668,7 +668,7 @@ const VMStateDescription vmsd_arpp = { .minimum_version_id = 1, .fields = (const VMStateField []) {VMSTATE_ARRAY_OF_POINTER (ar, TestArrayOfPtrToInt, - AR_SIZE, 0, vmstate_info_int32, int32_t*), +AR_SIZE ,0 , vmstate_info_int32, int32_t),VMSTATE_END_OF_LIST () } };
roms/seabios-hppa +1 -1
@@ -1 +1 @@ -Subproject commit cf3a472f4ddea30d2d483a8ba4b005505f0dabb3 +Subproject commit 1a8ada1fb70643172e251aacbac673c9ecda99e9
Signature · 1 line
2.50.1
Re: [PATCH 01/11] vmstate: Pass in struct itself for VMSTATE_ARRAY_OF_POINTER
Quoted 56 lines · Peter Xu
Passing in a pointer almost never helps. Convert it to pass in struct for further refactoring on
VMS_ARRAY_OF_POINTER.Reviewed-by Alexander Mikhalitsyn <[email protected]>Reviewed-by Fabiano Rosas <[email protected]>Reviewed-by Philippe Mathieu-Daudé <[email protected]>Signed-off-by Peter Xu <[email protected]>--- include/migration/vmstate.h | 6 +++--- tests/unit/test-vmstate.c | 2 +- roms/seabios-hppa | 2 +- 3 files changed, 5 insertions(+), 5 deletions(-)include/migration/vmstate.h +3
-3@@ -547,9 +547,9 @@ extern const VMStateInfo vmstate_info_qlist; .version_id = (_version), \ .num = (_num), \ .info = &(_info), \ - .size = sizeof(_type), \ + .size = sizeof(_type *), \ .flags = VMS_ARRAY|VMS_ARRAY_OF_POINTER, \ - .offset = vmstate_offset_array(_state, _field, _type, _num), \ + .offset = vmstate_offset_array(_state, _field, _type *, _num), \ }#define VMSTATE_ARRAY_OF_POINTER_TO_STRUCT (_f, _s, _n, _v, _vmsd, _type) { \@@ -1093,7 +1093,7 @@ extern const VMStateInfo vmstate_info_qlist; VMSTATE_TIMER_PTR_V(_f, _s, 0)#define VMSTATE_TIMER_PTR_ARRAY (_f, _s, _n) \ - VMSTATE_ARRAY_OF_POINTER(_f, _s, _n, 0, vmstate_info_timer, QEMUTimer *) + VMSTATE_ARRAY_OF_POINTER(_f, _s, _n, 0, vmstate_info_timer, QEMUTimer)#define VMSTATE_TIMER_TEST (_f, _s, _test) \ VMSTATE_SINGLE_TEST(_f, _s, _test, 0, vmstate_info_timer, QEMUTimer)tests/unit/test-vmstate.c +1
-1@@ -668,7 +668,7 @@ const VMStateDescription vmsd_arpp = { .minimum_version_id = 1, .fields = (const VMStateField []) {VMSTATE_ARRAY_OF_POINTER (ar, TestArrayOfPtrToInt, - AR_SIZE, 0, vmstate_info_int32, int32_t*), +AR_SIZE ,0 , vmstate_info_int32, int32_t),VMSTATE_END_OF_LIST () } };roms/seabios-hppa +0
-0
roms/seabios-hppa line 1
Quoted 2 lines
roms/seabios-hppa +1
-1@@ -1 +1 @@ -Subproject commit cf3a472f4ddea30d2d483a8ba4b005505f0dabb3 +Subproject commit 1a8ada1fb70643172e251aacbac673c9ecda99e9
May I delete this hunk?
Re: [PATCH 01/11] vmstate: Pass in struct itself for VMSTATE_ARRAY_OF_POINTER
Quoted 9 lines · Fabiano Rosas
roms/seabios-hppa line 1
Quoted 7 lines
roms/seabios-hppa +1
-1@@ -1 +1 @@ -Subproject commit cf3a472f4ddea30d2d483a8ba4b005505f0dabb3 +Subproject commit 1a8ada1fb70643172e251aacbac673c9ecda99e9May I delete this hunk?
:-D
:-(
Yes..
Signature · 1 line
Peter Xu
PATCH 2/11 vmstate: Pass in struct itself for VMSTATE_VARRAY_OF_POINTER_UINT32
In reply to Peter XuPassing in a pointer almost never helps. Convert it to pass in struct for further refactoring on VMS_ARRAY_OF_POINTER.
--- include/hw/intc/riscv_aclint.h | 6 +++--- include/migration/vmstate.h | 4 ++-- 2 files changed, 5 insertions(+), 5 deletions(-)
include/hw/intc/riscv_aclint.h +3 -3
@@ -80,8 +80,8 @@ enum {RISCV_ACLINT_SWI_SIZE =0x4000 }; -#define VMSTATE_TIMER_PTR_VARRAY (_f, _s, _f_n) \ -VMSTATE_VARRAY_OF_POINTER_UINT32(_f, _s, _f_n, 0, vmstate_info_timer, \ - QEMUTimer *) +#define VMSTATE_TIMER_PTR_VARRAY (_f, _s, _f_n) \ + VMSTATE_VARRAY_OF_POINTER_UINT32(_f, _s, _f_n, 0, vmstate_info_timer, \ + QEMUTimer)#endif
include/migration/vmstate.h +2 -2
@@ -567,9 +567,9 @@ extern const VMStateInfo vmstate_info_qlist; .version_id = (_version), \ .num_offset = vmstate_offset_value(_state, _field_num, uint32_t), \ .info = &(_info), \ - .size = sizeof(_type), \ + .size = sizeof(_type *), \ .flags = VMS_VARRAY_UINT32 | VMS_ARRAY_OF_POINTER | VMS_POINTER, \ - .offset = vmstate_offset_pointer(_state, _field, _type), \ + .offset = vmstate_offset_pointer(_state, _field, _type *), \ }#define VMSTATE_STRUCT_SUB_ARRAY (_field, _state, _start, _num, _version, _vmsd, _type) { \
Signature · 1 line
2.50.1
PATCH 3/11 vmstate: Do not set size for VMS_ARRAY_OF_POINTER
In reply to Peter XuWhen VMS_ARRAY_OF_POINTER is specified, it means the vmstate field is an array of pointers.
The size of the element is not relevant to whatever it is stored inside: it is always the host pointer size.
Let's reserve the "size" field in this case for future use, update vmstate_size() so as to make it still work for array of pointers properly.
When at this, provide rich documentation on how size / size_offset works in vmstate.
--- include/migration/vmstate.h | 20 ++++++++++++++++---- migration/savevm.c | 3 +++ migration/vmstate.c | 10 +++++++++- 3 files changed, 28 insertions(+), 5 deletions(-)
include/migration/vmstate.h +16 -4
@@ -183,11 +183,26 @@ typedef enum {struct VMStateField {const char *name;size_t offset; + +/* +* @size or @size_offset specifies the size of the element embeded in +* the field. Only one of them should be present never both. When +* @size_offset is used together with VMS_VBUFFER, it means the size is +* dynamic calculated instead of a constant. +* +* When the field is an array of any type, this stores the size of one +* element of the array. +* +* NOTE: even if VMS_POINTER or VMS_ARRAY_OF_POINTER may be specified, +* this parameter always reflects the real size of the objects that a +* pointer point to. +*/ size_t size; +size_t size_offset; +size_t start;int num;size_t num_offset; -size_t size_offset;const VMStateInfo *info;enum VMStateFlags flags;const VMStateDescription *vmsd;
@@ -547,7 +562,6 @@ extern const VMStateInfo vmstate_info_qlist; .version_id = (_version), \ .num = (_num), \ .info = &(_info), \ - .size = sizeof(_type *), \ .flags = VMS_ARRAY|VMS_ARRAY_OF_POINTER, \ .offset = vmstate_offset_array(_state, _field, _type *, _num), \ }
@@ -557,7 +571,6 @@ extern const VMStateInfo vmstate_info_qlist; .version_id = (_v), \ .num = (_n), \ .vmsd = &(_vmsd), \ - .size = sizeof(_type *), \ .flags = VMS_ARRAY|VMS_STRUCT|VMS_ARRAY_OF_POINTER, \ .offset = vmstate_offset_array(_s, _f, _type*, _n), \ }
@@ -567,7 +580,6 @@ extern const VMStateInfo vmstate_info_qlist; .version_id = (_version), \ .num_offset = vmstate_offset_value(_state, _field_num, uint32_t), \ .info = &(_info), \ - .size = sizeof(_type *), \ .flags = VMS_VARRAY_UINT32 | VMS_ARRAY_OF_POINTER | VMS_POINTER, \ .offset = vmstate_offset_pointer(_state, _field, _type *), \ }
migration/savevm.c +3 -0
@@ -868,6 +868,9 @@ static void vmstate_check(const VMStateDescription *vmsd)if (field) {while (field->name) { +if (field->flags &VMS_ARRAY_OF_POINTER ) { +assert (field->size ==0 ); + }if (field->flags & (VMS_STRUCT |VMS_VSTRUCT )) {/* Recurse to sub structures */ vmstate_check (field->vmsd);
migration/vmstate.c +9 -1
@@ -110,13 +110,21 @@ static int vmstate_n_elems(void *opaque, const VMStateField *field)static int vmstate_size (void *opaque,const VMStateField *field) { -int size = field->size; +int size;if (field->flags &VMS_VBUFFER ) { size = *(int32_t *)(opaque + field->size_offset);if (field->flags &VMS_MULTIPLY ) { size *= field->size; } + }else if (field->flags &VMS_ARRAY_OF_POINTER ) { +/* +* For an array of pointer, the each element is always size of a +* host pointer. +*/ + size =sizeof (void *); + }else { + size = field->size; }return size;
Signature · 1 line
2.50.1
PATCH 4/11 vmstate: Update max_elems early and check field compressable once
In reply to Peter XuQEMU has a trick in vmstate_save_vmsd_v(), where it will try to compress multiple JSON entries into one with a count to avoid duplicated entries.
That only applies to the cases where vmsd_can_compress() should return true. For example, vmsd_desc_field_start() later (who will take the updated max_elems as the last parameter) will ignore the value passed in when vmsd_can_compress() returns false.
Do that check once at the start of loop, and use it to update max_elems, so that max_elems keeps 1 for uncompressable VMSD fields, which is more straightforward.
This also paves way to make this counter work for ptr marker VMSD fields too.
No functional change intended in this patch alone.
--- migration/vmstate.c | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-)
migration/vmstate.c +5 -3
@@ -556,7 +556,8 @@ static bool vmstate_save_vmsd_v(QEMUFile *f, const VMStateDescription *vmsd,void *curr_elem = first_elem + size * i;const VMStateField *inner_field;bool is_null; -int max_elems = n_elems - i; +/* maximum number of elements to compress in the JSON blob */ +int max_elems =vmsd_can_compress (field) ? (n_elems - i) :1 ; old_offset =qemu_file_transferred (f);if (field->flags &VMS_ARRAY_OF_POINTER ) {
@@ -587,7 +588,8 @@ static bool vmstate_save_vmsd_v(QEMUFile *f, const VMStateDescription *vmsd,* vs. nullptr). Search ahead for the next null/non-null element * and start a new compressed array if found. */ -if (vmdesc && (field->flags &VMS_ARRAY_OF_POINTER ) && +if (vmdesc && max_elems >1 && + (field->flags &VMS_ARRAY_OF_POINTER ) && is_null != is_prev_null) { is_prev_null = is_null;
@@ -626,7 +628,7 @@ static bool vmstate_save_vmsd_v(QEMUFile *f, const VMStateDescription *vmsd, }/* Compressed arrays only care about the first element */ -if (vmdesc_loop &&vmsd_can_compress (field)) { +if (vmdesc_loop && max_elems >1 ) { vmdesc_loop =NULL ; } }
Signature · 1 line
2.50.1
PATCH 5/11 vmstate: Rename VMS_NULLPTR_MARKER to VMS_MARKER_PTR_NULL
In reply to Peter XuPrepare for a new MARKER for non-NULL pointer.
--- include/migration/vmstate.h | 2 +- migration/vmstate-types.c | 4 ++-- tests/unit/test-vmstate.c | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-)
include/migration/vmstate.h +1 -1
@@ -283,7 +283,7 @@ extern const VMStateInfo vmstate_info_uint64;extern const VMStateInfo vmstate_info_fd;/** Put this in the stream when migrating a null pointer.*/ -#define VMS_NULLPTR_MARKER (0x30U)/* '0' */ +#define VMS_MARKER_PTR_NULL (0x30U)/* '0' */ extern const VMStateInfo vmstate_info_nullptr;extern const VMStateInfo vmstate_info_cpudouble;
migration/vmstate-types.c +2 -2
@@ -363,7 +363,7 @@ static bool load_nullptr(QEMUFile *f, void *pv, size_t size, const VMStateField *field, Error **errp) { - if (qemu_get_byte(f) == VMS_NULLPTR_MARKER) { + if (qemu_get_byte(f) == VMS_MARKER_PTR_NULL) {return true; }
@@ -377,7 +377,7 @@ static bool save_nullptr(QEMUFile *f, void *pv, size_t size, {if (pv ==NULL ) { -qemu_put_byte (f,VMS_NULLPTR_MARKER ); +qemu_put_byte (f,VMS_MARKER_PTR_NULL );return true; }
tests/unit/test-vmstate.c +1 -1
@@ -620,7 +620,7 @@ static void test_arr_ptr_str_no0_load(void)static uint8_t wire_arr_ptr_0[] = {0x00 ,0x00 ,0x00 ,0x00 , -VMS_NULLPTR_MARKER , +VMS_MARKER_PTR_NULL ,0x00 ,0x00 ,0x00 ,0x02 ,0x00 ,0x00 ,0x00 ,0x03 ,QEMU_VM_EOF
Signature · 1 line
2.50.1
PATCH 6/11 vmstate: Introduce vmstate_save_field_with_vmdesc()
In reply to Peter XuIntroduce a helper to do both the JSON blob generations and save vmstate. This further shrinks the function a bit. More importantly, we'll need to save two fields in one loop very soon in the future with the JSON blob.
--- migration/vmstate.c | 45 ++++++++++++++++++++++++++++++++------------- 1 file changed, 32 insertions(+), 13 deletions(-)
migration/vmstate.c +32 -13
@@ -514,6 +514,35 @@ static bool vmstate_save_field(QEMUFile *f, void *pv, size_t size,return true; } +/* +* Save a whole VMSD field, including its JSON blob separately when @vmdesc +* is specified. +*/ +static inline bool +vmstate_save_field_with_vmdesc (QEMUFile *f,void *pv,size_t size, +const VMStateDescription *vmsd, +const VMStateField *field,JSONWriter *vmdesc, +int i,int max,Error **errp) +{ +uint64_t old_offset, written_bytes; +bool ok; + +vmsd_desc_field_start (vmsd, vmdesc, field, i, max); + + old_offset =qemu_file_transferred (f); + ok =vmstate_save_field (f, pv, size, field, vmdesc, errp); + written_bytes =qemu_file_transferred (f) - old_offset; + +vmsd_desc_field_end (vmsd, vmdesc, field, written_bytes); + +if (!ok) { +error_prepend (errp,"Save of field %s/%s failed: " , + vmsd->name, field->name); + } + +return ok; +} +static bool vmstate_save_vmsd_v (QEMUFile *f,const VMStateDescription *vmsd,void *opaque,JSONWriter *vmdesc,int version_id,Error **errp)
@@ -542,7 +571,6 @@ static bool vmstate_save_vmsd_v(QEMUFile *f, const VMStateDescription *vmsd,void *first_elem = opaque + field->offset;int i, n_elems =vmstate_n_elems (opaque, field);int size =vmstate_size (opaque, field); -uint64_t old_offset, written_bytes;JSONWriter *vmdesc_loop = vmdesc;bool is_prev_null = false;
@@ -559,7 +587,6 @@ static bool vmstate_save_vmsd_v(QEMUFile *f, const VMStateDescription *vmsd,/* maximum number of elements to compress in the JSON blob */ int max_elems =vmsd_can_compress (field) ? (n_elems - i) :1 ; - old_offset =qemu_file_transferred (f);if (field->flags &VMS_ARRAY_OF_POINTER ) {assert (curr_elem); curr_elem = *(void **)curr_elem;
@@ -606,15 +633,9 @@ static bool vmstate_save_vmsd_v(QEMUFile *f, const VMStateDescription *vmsd, } } -vmsd_desc_field_start (vmsd, vmdesc_loop, inner_field, - i, max_elems); - - ok =vmstate_save_field (f, curr_elem, size, inner_field, - vmdesc_loop, errp); - - written_bytes =qemu_file_transferred (f) - old_offset; -vmsd_desc_field_end (vmsd, vmdesc_loop, inner_field, - written_bytes); + ok =vmstate_save_field_with_vmdesc (f, curr_elem, size, vmsd, + inner_field, vmdesc_loop, + i, max_elems, errp);/* If we used a fake temp field.. free it now */ if (is_null) {
@@ -622,8 +643,6 @@ static bool vmstate_save_vmsd_v(QEMUFile *f, const VMStateDescription *vmsd, }if (!ok) { -error_prepend (errp,"Save of field %s/%s failed: " , - vmsd->name, field->name); goto out; }
Signature · 1 line
2.50.1
PATCH 7/11 vmstate: Allow vmstate_info_nullptr to emit non-NULL markers
In reply to Peter XuWe used to have one vmstate called "nullptr" which is only used to generate one-byte hint to say one pointer is NULL.
Let's extend its use so that it will generate another byte to say the pointer is non-NULL.
With that, the name of the info struct (or functions) do not apply anymore. Update correspondingly.
Update analyze-migration.py to work with the new layout.
No functional change intended yet.
--- include/migration/vmstate.h | 9 +++++++-- migration/vmstate-types.c | 34 ++++++++++++++++------------------ migration/vmstate.c | 25 +++++++++++++------------ scripts/analyze-migration.py | 22 ++++++++++++---------- 4 files changed, 48 insertions(+), 42 deletions(-)
include/migration/vmstate.h +7 -2
@@ -282,9 +282,14 @@ extern const VMStateInfo vmstate_info_uint32;extern const VMStateInfo vmstate_info_uint64;extern const VMStateInfo vmstate_info_fd; -/** Put this in the stream when migrating a null pointer.*/ +/* +* Put this in the stream when migrating a pointer to reflect either a NULL +* or valid pointer. +*/ #define VMS_MARKER_PTR_NULL (0x30U)/* '0' */ -extern const VMStateInfo vmstate_info_nullptr; +#define VMS_MARKER_PTR_VALID (0x31U)/* '1' */ + +extern const VMStateInfo vmstate_info_ptr_marker;extern const VMStateInfo vmstate_info_cpudouble;
migration/vmstate-types.c +16 -18
@@ -359,36 +359,34 @@ const VMStateInfo vmstate_info_fd = { .save = save_fd, }; -static bool load_nullptr (QEMUFile *f,void *pv,size_t size, -const VMStateField *field,Error **errp) +static bool load_ptr_marker (QEMUFile *f,void *pv,size_t size, +const VMStateField *field,Error **errp) { -if (qemu_get_byte (f) ==VMS_MARKER_PTR_NULL ) { +int byte =qemu_get_byte (f); + +if (byte ==VMS_MARKER_PTR_NULL || byte ==VMS_MARKER_PTR_VALID ) { +/* TODO: process PTR_VALID case */ return true; } -error_setg (errp,"vmstate: load_nullptr expected VMS_NULLPTR_MARKER" ); +error_setg (errp,"%s: unexpected ptr marker: %d" , __func__, byte);return false; } -static bool save_nullptr (QEMUFile *f,void *pv,size_t size, -const VMStateField *field,JSONWriter *vmdesc, -Error **errp) +static bool save_ptr_marker (QEMUFile *f,void *pv,size_t size, +const VMStateField *field,JSONWriter *vmdesc, +Error **errp) { -if (pv ==NULL ) { -qemu_put_byte (f,VMS_MARKER_PTR_NULL ); -return true; - } - -error_setg (errp,"vmstate: save_nullptr must be called with pv == NULL" ); -return false; +qemu_put_byte (f, pv ?VMS_MARKER_PTR_VALID :VMS_MARKER_PTR_NULL ); +return true; } -const VMStateInfo vmstate_info_nullptr = { - .name ="nullptr" , - .load = load_nullptr, - .save = save_nullptr, +const VMStateInfo vmstate_info_ptr_marker = { + .name ="ptr-marker" , + .load = load_ptr_marker, + .save = save_ptr_marker, };/* 64 bit unsigned int. See that the received value is the same than the one
migration/vmstate.c +13 -12
@@ -55,12 +55,12 @@ vmstate_field_exists(const VMStateDescription *vmsd, const VMStateField *field, }/* -* Create a fake nullptr field when there's a NULL pointer detected in the +* Create a ptr marker field when there's a NULL pointer detected in the * array of a VMS_ARRAY_OF_POINTER VMSD field. It's needed because we * can't dereference the NULL pointer. */ static const VMStateField * -vmsd_create_fake_nullptr_field (const VMStateField *field) +vmsd_create_ptr_marker_field (const VMStateField *field) {VMStateField *fake =g_new0 (VMStateField,1 );
@@ -71,12 +71,12 @@ vmsd_create_fake_nullptr_field(const VMStateField *field) fake->name = field->name; fake->version_id = field->version_id; -/* Do not need "field_exists" check as it always exists (which is null) */ +/* Do not need "field_exists" check as it always exists */ fake->field_exists =NULL ; -/* See vmstate_info_nullptr - use 1 byte to represent nullptr */ +/* See vmstate_info_ptr_marker - use 1 byte to represent ptr status */ fake->size =1 ; - fake->info = &vmstate_info_nullptr; + fake->info = &vmstate_info_ptr_marker; fake->flags =VMS_SINGLE ;/* All the rest fields shouldn't matter.. */
@@ -278,7 +278,7 @@ bool vmstate_load_vmsd(QEMUFile *f, const VMStateDescription *vmsd,* an array of pointers), use null placeholder and do * not follow. */ - inner_field =vmsd_create_fake_nullptr_field (field); + inner_field =vmsd_create_ptr_marker_field (field); }else { inner_field = field; }
@@ -583,26 +583,27 @@ static bool vmstate_save_vmsd_v(QEMUFile *f, const VMStateDescription *vmsd,for (i =0 ; i < n_elems; i++) {void *curr_elem = first_elem + size * i;const VMStateField *inner_field; -bool is_null;/* maximum number of elements to compress in the JSON blob */ int max_elems =vmsd_can_compress (field) ? (n_elems - i) :1 ; +bool use_marker_field, is_null;if (field->flags &VMS_ARRAY_OF_POINTER ) {assert (curr_elem); curr_elem = *(void **)curr_elem; } -if (!curr_elem && size) { + is_null = !curr_elem && size; + use_marker_field = is_null; + +if (use_marker_field) {/* * If null pointer found (which should only happen in * an array of pointers), use null placeholder and do * not follow. */ - inner_field =vmsd_create_fake_nullptr_field (field); - is_null = true; + inner_field =vmsd_create_ptr_marker_field (field); }else { inner_field = field; - is_null = false; }/*
@@ -638,7 +639,7 @@ static bool vmstate_save_vmsd_v(QEMUFile *f, const VMStateDescription *vmsd, i, max_elems, errp);/* If we used a fake temp field.. free it now */ -if (is_null) { +if (use_marker_field) {g_clear_pointer ((gpointer *)&inner_field, g_free); }
scripts/analyze-migration.py +12 -10
@@ -469,26 +469,26 @@ def __init__(self, desc, file): super(VMSDFieldIntLE, self).__init__(desc, file) self.dtype = '<i%d' % self.size -class VMSDFieldNull(VMSDFieldGeneric): +class VMSDFieldPtrMarker(VMSDFieldGeneric): NULL_PTR_MARKER = b'0' + VALID_PTR_MARKER = b'1' def __init__(self, desc, file): - super(VMSDFieldNull, self).__init__(desc, file) + super(VMSDFieldPtrMarker, self).__init__(desc, file) def __repr__(self): - # A NULL pointer is encoded in the stream as a '0' to - # disambiguate from a mere 0x0 value and avoid consumers - # trying to follow the NULL pointer. Displaying '0', 0x30 or - # 0x0 when analyzing the JSON debug stream could become + # A NULL / non-NULL pointer may be encoded in the stream as a + # '0'/'1' to represent the status of the pointer. Displaying '0', + # 0x30 or 0x0 when analyzing the JSON debug stream could become # confusing, so use an explicit term instead. - return "nullptr" + return "null-ptr" if self.data == self.NULL_PTR_MARKER else "valid-ptr" def __str__(self): return self.__repr__() def read(self): - super(VMSDFieldNull, self).read() - assert(self.data == self.NULL_PTR_MARKER) + super(VMSDFieldPtrMarker, self).read() + assert(self.data in [self.NULL_PTR_MARKER, self.VALID_PTR_MARKER]) return self.data class VMSDFieldBool(VMSDFieldGeneric):
@@ -642,7 +642,9 @@ def getDict(self): "bitmap" : VMSDFieldGeneric, "struct" : VMSDFieldStruct, "capability": VMSDFieldCap, - "nullptr": VMSDFieldNull, + # Keep the old nullptr for old binaries + "nullptr": VMSDFieldPtrMarker, + "ptr-marker": VMSDFieldPtrMarker, "unknown" : VMSDFieldGeneric, }
Signature · 1 line
2.50.1
PATCH 8/11 vmstate: Implement load of ptr marker in vmstate core
In reply to Peter XuThe loader side of ptr marker is pretty straightforward, instead of playing the inner_field trick, just do the load manually assuming the marker layout is a stable ABI (which it is true already).
This will remove some logic while loading VMSD, and hopefully it makes it slightly easier to read. Unfortunately, we still need to keep the sender side because of the JSON blob we're maintaining..
This paves way for future processing of non-NULL markers as well.
When at it, not check "size" anymore for existing NULL markers, and move it under the same VMS_ARRAY_OF_POINTER section because that's the only place that NULL marker can happen (which guarantess size==host ptr size, which is non-zero).
--- migration/vmstate-types.c | 12 ++++------ migration/vmstate.c | 46 ++++++++++++++++++++++++--------------- 2 files changed, 32 insertions(+), 26 deletions(-)
migration/vmstate-types.c +4 -8
@@ -363,14 +363,10 @@ static bool load_ptr_marker(QEMUFile *f, void *pv, size_t size, const VMStateField *field, Error **errp) { - int byte = qemu_get_byte(f); - -if (byte ==VMS_MARKER_PTR_NULL || byte ==VMS_MARKER_PTR_VALID ) { -/* TODO: process PTR_VALID case */ -return true; - } - -error_setg (errp,"%s: unexpected ptr marker: %d" , __func__, byte); +/* +* Load is done in vmstate core, see vmstate_ptr_marker_load(). +*/ +g_assert_not_reached ();return false; }
migration/vmstate.c +28 -18
64 lines not on this page · raw message
Signature · 1 line
2.50.1
PATCH 9/11 vmstate: Implement VMS_ARRAY_OF_POINTER_AUTO_ALLOC
In reply to Peter XuIntroduce a new flag, VMS_ARRAY_OF_POINTER_AUTO_ALLOC, for VMSD field. It must be used together with VMS_ARRAY_OF_POINTER.
It can be used to allow migration of an array of pointers where the pointers may point to NULLs.
Note that we used to allow migration of a NULL pointer within an array that is being migrated. That corresponds to the code around vmstate_info_nullptr where we may get/put one byte showing that the element of an array is NULL.
That usage is fine but very limited, it's because even if it will migrate a NULL pointer with a marker, it still works in a way that both src and dest QEMUs must know exactly which elements of the array are non-NULL, so instead of dynamically loading an array (which can have NULL pointers), it actually only verifies the known NULL pointers are still NULL pointers after migration.
Also, in that case since dest QEMU knows exactly which element is NULL, which is not NULL, dest QEMU's device code will manage all allocations for the elements before invoking vmstate_load_vmsd().
That's not enough per evolving needs of new device states that may want to provide real dynamic array of pointers, like what Alexander proposed here with the NVMe device migration:
https://lore.kernel.org/r/[email protected]
This patch is an alternative approach to address the problem.
Along with the flag, introduce two new macros:
VMSTATE_VARRAY_OF_POINTER_TO_STRUCT_UINT{8|32}_ALLOC()
Which will be used very soon in the NVMe series.
--- include/migration/vmstate.h | 51 ++++++++++++- migration/savevm.c | 27 ++++++- migration/vmstate.c | 145 ++++++++++++++++++++++++++++++------ 3 files changed, 199 insertions(+), 24 deletions(-)
include/migration/vmstate.h +50 -1
@@ -161,8 +161,21 @@ enum VMStateFlags {* structure we are referencing to use. */ VMS_VSTRUCT =0x8000 , +/* +* This is a sub-flag for VMS_ARRAY_OF_POINTER. When this flag is set, +* VMS_ARRAY_OF_POINTER must also be set. When set, it means array +* elements can contain either valid or NULL pointers, vmstate core +* will be responsible for synchronizing the pointer status, providing +* proper memory allocations on the pointer when it is populated on the +* source QEMU. It also means the user of the field must make sure all +* the elements in the array are NULL pointers before loading. This +* should also work with VMS_ALLOC when the array itself also needs to +* be allocated. +*/ +VMS_ARRAY_OF_POINTER_AUTO_ALLOC =0x10000 , +/* Marker for end of list */ -VMS_END =0x10000 + VMS_END = 0x20000, }; typedef enum {
@@ -580,6 +593,42 @@ extern const VMStateInfo vmstate_info_qlist; .offset = vmstate_offset_array(_s, _f, _type*, _n), \ } +/* +* For migrating a dynamically allocated uint{8,32}-indexed array of +* pointers to structures (with NULL entries and with auto memory +* allocation). +* +* _type: type of structure pointed to +* _vmsd: VMSD for structure _type (when VMS_STRUCT is set) +* _info: VMStateInfo for _type (when VMS_STRUCT is not set) +* start: size of (_type) pointed to (for auto memory allocation) +*/ +#define VMSTATE_VARRAY_OF_POINTER_TO_STRUCT_UINT8_ALLOC (\ + _field, _state, _field_num, _version, _vmsd, _type) { \ + .name = (stringify(_field)), \ + .version_id = (_version), \ + .num_offset = vmstate_offset_value(_state, _field_num, uint8_t), \ + .vmsd = &(_vmsd), \ + .size = sizeof(_type), \ + .flags = VMS_POINTER | VMS_VARRAY_UINT8 | \ + VMS_ARRAY_OF_POINTER | VMS_STRUCT | \ + VMS_ARRAY_OF_POINTER_AUTO_ALLOC, \ + .offset = vmstate_offset_pointer(_state, _field, _type *), \ +} + +#define VMSTATE_VARRAY_OF_POINTER_TO_STRUCT_UINT32_ALLOC (\ + _field, _state, _field_num, _version, _vmsd, _type) { \ + .name = (stringify(_field)), \ + .version_id = (_version), \ + .num_offset = vmstate_offset_value(_state, _field_num, uint32_t), \ + .vmsd = &(_vmsd), \ + .size = sizeof(_type), \ + .flags = VMS_POINTER | VMS_VARRAY_UINT32 | \ + VMS_ARRAY_OF_POINTER | VMS_STRUCT | \ + VMS_ARRAY_OF_POINTER_AUTO_ALLOC, \ + .offset = vmstate_offset_pointer(_state, _field, _type *), \ +} +#define VMSTATE_VARRAY_OF_POINTER_UINT32 (_field, _state, _field_num, _version, _info, _type) { \ .name = (stringify(_field)), \ .version_id = (_version), \
migration/savevm.c +26 -1
@@ -869,8 +869,33 @@ static void vmstate_check(const VMStateDescription *vmsd)if (field) {while (field->name) {if (field->flags &VMS_ARRAY_OF_POINTER ) { -assert (field->size ==0 ); +if (field->flags &VMS_ARRAY_OF_POINTER_AUTO_ALLOC ) { +/* +* Size must be provided because dest QEMU needs that +* info to know what to allocate +*/ +assert (field->size || field->size_offset); + }else { +/* +* Otherwise size info isn't useful (because it's +* always the size of host pointer), detect accidental +* setup of sizes in this case. +*/ +assert (field->size ==0 && field->size_offset ==0 ); + } +/* +* VMS_ARRAY_OF_POINTER must be used only together with one +* of VMS_(V)ARRAY* flags. +*/ +assert (field->flags & (VMS_ARRAY |VMS_VARRAY_INT32 | +VMS_VARRAY_UINT16 |VMS_VARRAY_UINT8 | +VMS_VARRAY_UINT32 )); } + +if (field->flags &VMS_ARRAY_OF_POINTER_AUTO_ALLOC ) { +assert (field->flags &VMS_ARRAY_OF_POINTER ); + } +if (field->flags & (VMS_STRUCT |VMS_VSTRUCT )) {/* Recurse to sub structures */ vmstate_check (field->vmsd);
migration/vmstate.c +123 -22
194 lines not on this page · raw message
Signature · 1 line
2.50.1
PATCH 10/11 vmstate: Stop checking size for nullptr compression
In reply to Peter XuFrom: Fabiano Rosas <[email protected]>
The NULL pointer marker code applies only to VMS_ARRAY_OF_POINTER, where the size is never NULL. Move the setting of is_null under VMS_ARRAY_OF_POINTER, so we can stop checking the size.
--- migration/vmstate.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
migration/vmstate.c +3 -3
@@ -682,14 +682,14 @@ static bool vmstate_save_vmsd_v(QEMUFile *f, const VMStateDescription *vmsd,const VMStateField *inner_field;/* maximum number of elements to compress in the JSON blob */ int max_elems =vmsd_can_compress (field) ? (n_elems - i) :1 ; -bool use_marker_field, is_null; +bool use_marker_field, is_null = false;if (field->flags &VMS_ARRAY_OF_POINTER ) {assert (curr_elem); curr_elem = *(void **)curr_elem; + is_null = !curr_elem; } - is_null = !curr_elem && size; use_marker_field = use_dynamic_array || is_null;if (use_marker_field) {
@@ -717,7 +717,7 @@ static bool vmstate_save_vmsd_v(QEMUFile *f, const VMStateDescription *vmsd,for (int j = i +1 ; j < n_elems; j++) {void *elem = *(void **)(first_elem + size * j); -bool elem_is_null = !elem && size; +bool elem_is_null = !elem;if (is_null != elem_is_null) { max_elems = j - i;
Signature · 1 line
2.50.1
PATCH 11/11 tests/unit/test-vmstate: add tests for VMS_ARRAY_OF_POINTER_AUTO_ALLOC
In reply to Peter XuFrom: Alexander Mikhalitsyn <[email protected]>
Add tests for VMSTATE_VARRAY_OF_POINTER_TO_STRUCT_UINT32_ALLOC.
--- tests/unit/test-vmstate.c | 86 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 86 insertions(+)
tests/unit/test-vmstate.c +86 -0
@@ -702,6 +702,88 @@ static void test_arr_ptr_prim_0_load(void) } } +static uint8_t wire_arr_ptr_with_nulls[] = { +VMS_MARKER_PTR_VALID , +0x00 ,0x00 ,0x00 ,0x00 , +VMS_MARKER_PTR_NULL , +VMS_MARKER_PTR_VALID , +0x00 ,0x00 ,0x00 ,0x02 , +VMS_MARKER_PTR_VALID , +0x00 ,0x00 ,0x00 ,0x03 , +QEMU_VM_EOF +}; + +typedef struct { +uint32_t ar_items_num; +TestStructTriv **ar; +}TestVArrayOfPtrToStuctWithNULLs ; + +const VMStateDescription vmsd_arps_with_nulls = { + .name ="test/arps_with_nulls" , + .version_id =1 , + .minimum_version_id =1 , + .fields = (const VMStateField []) { +VMSTATE_VARRAY_OF_POINTER_TO_STRUCT_UINT32_ALLOC ( + ar, TestVArrayOfPtrToStuctWithNULLs, ar_items_num, +0 , vmsd_tst, TestStructTriv), +VMSTATE_END_OF_LIST () + } +}; + +static void test_arr_ptr_nulls_str_save (void ) +{ +TestStructTriv ar[AR_SIZE ] = { {.i =0 }, {.i =1 }, {.i =2 }, {.i =3 } }; +TestVArrayOfPtrToStuctWithNULLs sample = {}; +int idx; + + sample.ar_items_num =AR_SIZE ; + sample.ar = g_new0(TestStructTriv*, sample.ar_items_num); + sample.ar[0 ] =g_new0 (TestStructTriv,1 ); + *sample.ar[0 ] = ar[0 ]; +/* note, sample.ar[1] remains NULL */ + sample.ar[2 ] =g_new0 (TestStructTriv,1 ); + *sample.ar[2 ] = ar[2 ]; + sample.ar[3 ] =g_new0 (TestStructTriv,1 ); + *sample.ar[3 ] = ar[3 ]; + +save_vmstate (&vmsd_arps_with_nulls, &sample); +compare_vmstate (wire_arr_ptr_with_nulls,sizeof (wire_arr_ptr_with_nulls)); + +for (idx =0 ; idx <AR_SIZE ; ++idx) { +g_free (sample.ar[idx]); + } +g_free (sample.ar); +} + +static void test_arr_ptr_nulls_str_load (void ) +{ +TestStructTriv ar_gt[AR_SIZE ] = {{.i =0 }, {.i =0 }, {.i =2 }, {.i =3 } }; +TestVArrayOfPtrToStuctWithNULLs obj = {}; +int idx; + + obj.ar_items_num =AR_SIZE ; + obj.ar = g_new0(TestStructTriv*, obj.ar_items_num); + +save_buffer (wire_arr_ptr_with_nulls,sizeof (wire_arr_ptr_with_nulls)); +SUCCESS (load_vmstate_one ( + &vmsd_arps_with_nulls, &obj,1 , + wire_arr_ptr_with_nulls,sizeof (wire_arr_ptr_with_nulls))); + +for (idx =0 ; idx <AR_SIZE ; ++idx) { +if (idx ==1 ) { + g_assert_cmpint((uintptr_t)(obj.ar[idx]), ==, 0); + }else { +/* compare the target array ar with the ground truth array ar_gt */ + g_assert_cmpint(ar_gt[idx].i, ==, obj.ar[idx]->i); + } + } + +for (idx =0 ; idx <AR_SIZE ; ++idx) { +g_free (obj.ar[idx]); + } +g_free (obj.ar); +} +/* test QTAILQ migration */ typedef struct TestQtailqElement TestQtailqElement ;
@@ -1568,6 +1650,10 @@ int main(int argc, char **argv) test_arr_ptr_prim_0_save);g_test_add_func ("/vmstate/array/ptr/prim/0/load" , test_arr_ptr_prim_0_load); +g_test_add_func ("/vmstate/array/ptr-nulls/str/save" , + test_arr_ptr_nulls_str_save); +g_test_add_func ("/vmstate/array/ptr-nulls/str/load" , + test_arr_ptr_nulls_str_load);g_test_add_func ("/vmstate/qtailq/save/saveq" , test_save_q);g_test_add_func ("/vmstate/qtailq/load/loadq" , test_load_q);g_test_add_func ("/vmstate/gtree/save/savedomain" , test_gtree_save_domain);
Signature · 1 line
2.50.1
Hi Peter,
Quoted 56 lines · Peter Xu
CI: https://gitlab.com/peterx/qemu/-/pipelines/2424266591
(one checkpatch warning, not relevant to this series)rfcv1: https://lore.kernel.org/r/[email protected]
rfcv2: https://lore.kernel.org/r/[email protected]Changelog
rfcv2->v1:- Rebased to latest fabiano's migration-staging branch (
bd698d7730)
- Collected new tags
- Patch 1
- Add space between "_type*" [Phil]
- Patch 9
- Slight refactoring onvmstate_load_next()[Fabiano]
- I collected Alexander's tested-by even if strictly I shouldn't when the patch changed; if test fails, it's me to blame.This is v1, I removed RFC as I we should have reached some form of consensus in general. It is based on Fabiano's migration-staging branch. I've pushed this tree here for easier reference:
https://gitlab.com/peterx/qemu/-/tree/vmstate-array-null
This series implements a new vmstate flag that allows real dynamic array of pointers to be migrated, so that QEMU vmstate core will be able to identify NULL and non-NULL pointers pointing to any kind of VMSD (or base types), then properly allocate memory for them on dest QEMU.
The first planned user of such is Alexander's NVMe migration series here:
https://lore.kernel.org/r/[email protected]
This is another alternative to solve this problem.
I tested
analyze-migration.pywith this version and it works with an idle dump from the nvme series (after I rebase).Thanks,
Alexander Mikhalitsyn (1):
tests/unit/test-vmstate: add tests forVMS_ARRAY_OF_POINTER_AUTO_ALLOCFabiano Rosas (1):
vmstate: Stop checking size for nullptr compressionPeter Xu (9):
vmstate: Pass in struct itself forVMSTATE_ARRAY_OF_POINTER
vmstate: Pass in struct itself forVMSTATE_VARRAY_OF_POINTER_UINT32
vmstate: Do not set size forVMS_ARRAY_OF_POINTER
vmstate: Updatemax_elemsearly and check field compressable once
vmstate: RenameVMS_NULLPTR_MARKERtoVMS_MARKER_PTR_NULL
vmstate: Introducevmstate_save_field_with_vmdesc()
vmstate: Allowvmstate_info_nullptrto emit non-NULL markers
vmstate: Implement load of ptr marker in vmstate core
vmstate: ImplementVMS_ARRAY_OF_POINTER_AUTO_ALLOC
Quoted 13 lines
include/hw/intc/riscv_aclint.h | 6 +- include/migration/vmstate.h | 88 ++++++++++-- migration/savevm.c | 28 ++++ migration/vmstate-types.c | 36 ++--- migration/vmstate.c | 247 ++++++++++++++++++++++++++------- tests/unit/test-vmstate.c | 90 +++++++++++- roms/seabios-hppa | 2 +- scripts/analyze-migration.py | 22 +-- 8 files changed, 418 insertions(+), 101 deletions(-)Signature · 1 line
2.50.1
For the whole series:
Dear friends,
when I can expect this to be landed in master? I would like to prepare and send next version of my
NVMe live migration patchset, that's why I'm asking.
Kind regards,
Alex
Am Mi., 1. Apr. 2026 um 22:28 Uhr schrieb Peter Xu <[email protected]>:
Quoted 70 lines
CI: https://gitlab.com/peterx/qemu/-/pipelines/2424266591
(one checkpatch warning, not relevant to this series)rfcv1: https://lore.kernel.org/r/[email protected]
rfcv2: https://lore.kernel.org/r/[email protected]Changelog
rfcv2->v1:- Rebased to latest fabiano's migration-staging branch (
bd698d7730)
- Collected new tags
- Patch 1
- Add space between "_type*" [Phil]
- Patch 9
- Slight refactoring onvmstate_load_next()[Fabiano]
- I collected Alexander's tested-by even if strictly I shouldn't when the patch changed; if test fails, it's me to blame.This is v1, I removed RFC as I we should have reached some form of consensus in general. It is based on Fabiano's migration-staging branch. I've pushed this tree here for easier reference:
https://gitlab.com/peterx/qemu/-/tree/vmstate-array-null
This series implements a new vmstate flag that allows real dynamic array of pointers to be migrated, so that QEMU vmstate core will be able to identify NULL and non-NULL pointers pointing to any kind of VMSD (or base types), then properly allocate memory for them on dest QEMU.
The first planned user of such is Alexander's NVMe migration series here:
https://lore.kernel.org/r/[email protected]
This is another alternative to solve this problem.
I tested
analyze-migration.pywith this version and it works with an idle dump from the nvme series (after I rebase).Thanks,
Alexander Mikhalitsyn (1):
tests/unit/test-vmstate: add tests forVMS_ARRAY_OF_POINTER_AUTO_ALLOCFabiano Rosas (1):
vmstate: Stop checking size for nullptr compressionPeter Xu (9):
vmstate: Pass in struct itself forVMSTATE_ARRAY_OF_POINTER
vmstate: Pass in struct itself forVMSTATE_VARRAY_OF_POINTER_UINT32
vmstate: Do not set size forVMS_ARRAY_OF_POINTER
vmstate: Updatemax_elemsearly and check field compressable once
vmstate: RenameVMS_NULLPTR_MARKERtoVMS_MARKER_PTR_NULL
vmstate: Introducevmstate_save_field_with_vmdesc()
vmstate: Allowvmstate_info_nullptrto emit non-NULL markers
vmstate: Implement load of ptr marker in vmstate core
vmstate: ImplementVMS_ARRAY_OF_POINTER_AUTO_ALLOCinclude/hw/intc/riscv_aclint.h | 6 +- include/migration/vmstate.h | 88 ++++++++++-- migration/savevm.c | 28 ++++ migration/vmstate-types.c | 36 ++--- migration/vmstate.c | 247 ++++++++++++++++++++++++++------- tests/unit/test-vmstate.c | 90 +++++++++++- roms/seabios-hppa | 2 +- scripts/analyze-migration.py | 22 +-- 8 files changed, 418 insertions(+), 101 deletions(-)--
2.50.1
Quoted 6 lines · Alexander Mikhalitsyn
Dear friends,
when I can expect this to be landed in master? I would like to prepare and send next version of my
NVMe live migration patchset, that's why I'm asking.
I intend to send a pull request as soon as the release happens and the next development cycle opens. Probably by the end of this week, unless we need to have another -rc.
Am Di., 14. Apr. 2026 um 17:23 Uhr schrieb Fabiano Rosas <[email protected]>:
Quoted 5 lines
Quoted 2 lines · Alexander Mikhalitsyn
Dear friends,
Quoted 9 lines
Quoted 4 lines
when I can expect this to be landed in master? I would like to prepare and send next version of my
NVMe live migration patchset, that's why I'm asking.I intend to send a pull request as soon as the release happens and the next development cycle opens. Probably by the end of this week, unless we need to have another -rc.
Thank you, Fabiano! And sorry for bothering with this question ;-)
Kind regards,
Alex