[mirror_qemu.git] / slirp / src / vmstate.c

/*
 * VMState interpreter
 *
 * Copyright (c) 2009-2018 Red Hat Inc
 *
 * Authors:
 *  Juan Quintela <quintela@redhat.com>
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above
 * copyright notice, this list of conditions and the following
 * disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above
 * copyright notice, this list of conditions and the following
 * disclaimer in the documentation and/or other materials provided
 * with the distribution.
 *
 * 3. Neither the name of the copyright holder nor the names of its
 * contributors may be used to endorse or promote products derived
 * from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 * OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include <assert.h>
#include <errno.h>
#include <string.h>
#include <glib.h>

#include "stream.h"
#include "vmstate.h"

static int get_nullptr(SlirpIStream *f, void *pv, size_t size,
                       const VMStateField *field)
{
    if (slirp_istream_read_u8(f) == VMS_NULLPTR_MARKER) {
        return  0;
    }
    g_warning("vmstate: get_nullptr expected VMS_NULLPTR_MARKER");
    return -EINVAL;
}

static int put_nullptr(SlirpOStream *f, void *pv, size_t size,
                       const VMStateField *field)

{
    if (pv == NULL) {
        slirp_ostream_write_u8(f, VMS_NULLPTR_MARKER);
        return 0;
    }
    g_warning("vmstate: put_nullptr must be called with pv == NULL");
    return -EINVAL;
}

const VMStateInfo slirp_vmstate_info_nullptr = {
    .name = "uint64",
    .get  = get_nullptr,
    .put  = put_nullptr,
};

/* 8 bit unsigned int */

static int get_uint8(SlirpIStream *f, void *pv, size_t size, const VMStateField *field)
{
    uint8_t *v = pv;
    *v = slirp_istream_read_u8(f);
    return 0;
}

static int put_uint8(SlirpOStream *f, void *pv, size_t size, const VMStateField *field)
{
    uint8_t *v = pv;
    slirp_ostream_write_u8(f, *v);
    return 0;
}

const VMStateInfo slirp_vmstate_info_uint8 = {
    .name = "uint8",
    .get  = get_uint8,
    .put  = put_uint8,
};

/* 16 bit unsigned int */

static int get_uint16(SlirpIStream *f, void *pv, size_t size,
                      const VMStateField *field)
{
    uint16_t *v = pv;
    *v = slirp_istream_read_u16(f);
    return 0;
}

static int put_uint16(SlirpOStream *f, void *pv, size_t size,
                      const VMStateField *field)
{
    uint16_t *v = pv;
    slirp_ostream_write_u16(f, *v);
    return 0;
}

const VMStateInfo slirp_vmstate_info_uint16 = {
    .name = "uint16",
    .get  = get_uint16,
    .put  = put_uint16,
};

/* 32 bit unsigned int */

static int get_uint32(SlirpIStream *f, void *pv, size_t size,
                      const VMStateField *field)
{
    uint32_t *v = pv;
    *v = slirp_istream_read_u32(f);
    return 0;
}

static int put_uint32(SlirpOStream *f, void *pv, size_t size,
                      const VMStateField *field)
{
    uint32_t *v = pv;
    slirp_ostream_write_u32(f, *v);
    return 0;
}

const VMStateInfo slirp_vmstate_info_uint32 = {
    .name = "uint32",
    .get  = get_uint32,
    .put  = put_uint32,
};

/* 16 bit int */

static int get_int16(SlirpIStream *f, void *pv, size_t size, const VMStateField *field)
{
    int16_t *v = pv;
    *v = slirp_istream_read_i16(f);
    return 0;
}

static int put_int16(SlirpOStream *f, void *pv, size_t size, const VMStateField *field)
{
    int16_t *v = pv;
    slirp_ostream_write_i16(f, *v);
    return 0;
}

const VMStateInfo slirp_vmstate_info_int16 = {
    .name = "int16",
    .get  = get_int16,
    .put  = put_int16,
};

/* 32 bit int */

static int get_int32(SlirpIStream *f, void *pv, size_t size, const VMStateField *field)
{
    int32_t *v = pv;
    *v = slirp_istream_read_i32(f);
    return 0;
}

static int put_int32(SlirpOStream *f, void *pv, size_t size, const VMStateField *field)
{
    int32_t *v = pv;
    slirp_ostream_write_i32(f, *v);
    return 0;
}

const VMStateInfo slirp_vmstate_info_int32 = {
    .name = "int32",
    .get  = get_int32,
    .put  = put_int32,
};

/* vmstate_info_tmp, see VMSTATE_WITH_TMP, the idea is that we allocate
 * a temporary buffer and the pre_load/pre_save methods in the child vmsd
 * copy stuff from the parent into the child and do calculations to fill
 * in fields that don't really exist in the parent but need to be in the
 * stream.
 */
static int get_tmp(SlirpIStream *f, void *pv, size_t size, const VMStateField *field)
{
    int ret;
    const VMStateDescription *vmsd = field->vmsd;
    int version_id = field->version_id;
    void *tmp = g_malloc(size);

    /* Writes the parent field which is at the start of the tmp */
    *(void **)tmp = pv;
    ret = slirp_vmstate_load_state(f, vmsd, tmp, version_id);
    g_free(tmp);
    return ret;
}

static int put_tmp(SlirpOStream *f, void *pv, size_t size, const VMStateField *field)
{
    const VMStateDescription *vmsd = field->vmsd;
    void *tmp = g_malloc(size);
    int ret;

    /* Writes the parent field which is at the start of the tmp */
    *(void **)tmp = pv;
    ret = slirp_vmstate_save_state(f, vmsd, tmp);
    g_free(tmp);

    return ret;
}

const VMStateInfo slirp_vmstate_info_tmp = {
    .name = "tmp",
    .get = get_tmp,
    .put = put_tmp,
};

/* uint8_t buffers */

static int get_buffer(SlirpIStream *f, void *pv, size_t size,
                      const VMStateField *field)
{
    slirp_istream_read(f, pv, size);
    return 0;
}

static int put_buffer(SlirpOStream *f, void *pv, size_t size,
                      const VMStateField *field)
{
    slirp_ostream_write(f, pv, size);
    return 0;
}

const VMStateInfo slirp_vmstate_info_buffer = {
    .name = "buffer",
    .get  = get_buffer,
    .put  = put_buffer,
};

static int vmstate_n_elems(void *opaque, const VMStateField *field)
{
    int n_elems = 1;

    if (field->flags & VMS_ARRAY) {
        n_elems = field->num;
    } else if (field->flags & VMS_VARRAY_INT32) {
        n_elems = *(int32_t *)(opaque + field->num_offset);
    } else if (field->flags & VMS_VARRAY_UINT32) {
        n_elems = *(uint32_t *)(opaque + field->num_offset);
    } else if (field->flags & VMS_VARRAY_UINT16) {
        n_elems = *(uint16_t *)(opaque + field->num_offset);
    } else if (field->flags & VMS_VARRAY_UINT8) {
        n_elems = *(uint8_t *)(opaque + field->num_offset);
    }

    if (field->flags & VMS_MULTIPLY_ELEMENTS) {
        n_elems *= field->num;
    }

    return n_elems;
}

static int vmstate_size(void *opaque, const VMStateField *field)
{
    int size = field->size;

    if (field->flags & VMS_VBUFFER) {
        size = *(int32_t *)(opaque + field->size_offset);
        if (field->flags & VMS_MULTIPLY) {
            size *= field->size;
        }
    }

    return size;
}

static int
vmstate_save_state_v(SlirpOStream *f, const VMStateDescription *vmsd,
                     void *opaque, int version_id)
{
    int ret = 0;
    const VMStateField *field = vmsd->fields;

    if (vmsd->pre_save) {
        ret = vmsd->pre_save(opaque);
        if (ret) {
            g_warning("pre-save failed: %s", vmsd->name);
            return ret;
        }
    }

    while (field->name) {
        if ((field->field_exists &&
             field->field_exists(opaque, version_id)) ||
            (!field->field_exists &&
             field->version_id <= version_id)) {
            void *first_elem = opaque + field->offset;
            int i, n_elems = vmstate_n_elems(opaque, field);
            int size = vmstate_size(opaque, field);

            if (field->flags & VMS_POINTER) {
                first_elem = *(void **)first_elem;
                assert(first_elem || !n_elems || !size);
            }
            for (i = 0; i < n_elems; i++) {
                void *curr_elem = first_elem + size * i;
                ret = 0;

                if (field->flags & VMS_ARRAY_OF_POINTER) {
                    assert(curr_elem);
                    curr_elem = *(void **)curr_elem;
                }
                if (!curr_elem && size) {
                    /* if null pointer write placeholder and do not follow */
                    assert(field->flags & VMS_ARRAY_OF_POINTER);
                    ret = slirp_vmstate_info_nullptr.put(f, curr_elem, size, NULL);
                } else if (field->flags & VMS_STRUCT) {
                    ret = slirp_vmstate_save_state(f, field->vmsd, curr_elem);
                } else if (field->flags & VMS_VSTRUCT) {
                    ret = vmstate_save_state_v(f, field->vmsd, curr_elem,
                                               field->struct_version_id);
                } else {
                    ret = field->info->put(f, curr_elem, size, field);
                }
                if (ret) {
                    g_warning("Save of field %s/%s failed",
                              vmsd->name, field->name);
                    return ret;
                }
            }
        } else {
            if (field->flags & VMS_MUST_EXIST) {
                g_warning("Output state validation failed: %s/%s",
                          vmsd->name, field->name);
                assert(!(field->flags & VMS_MUST_EXIST));
            }
        }
        field++;
    }

    return 0;
}

int slirp_vmstate_save_state(SlirpOStream *f, const VMStateDescription *vmsd,
                             void *opaque)
{
    return vmstate_save_state_v(f, vmsd, opaque, vmsd->version_id);
}

static void vmstate_handle_alloc(void *ptr, VMStateField *field, void *opaque)
{
    if (field->flags & VMS_POINTER && field->flags & VMS_ALLOC) {
        size_t size = vmstate_size(opaque, field);
        size *= vmstate_n_elems(opaque, field);
        if (size) {
            *(void **)ptr = g_malloc(size);
        }
    }
}

int slirp_vmstate_load_state(SlirpIStream *f, const VMStateDescription *vmsd,
                             void *opaque, int version_id)
{
    VMStateField *field = vmsd->fields;
    int ret = 0;

    if (version_id > vmsd->version_id) {
        g_warning("%s: incoming version_id %d is too new "
                  "for local version_id %d",
                  vmsd->name, version_id, vmsd->version_id);
        return -EINVAL;
    }
    if (vmsd->pre_load) {
        int ret = vmsd->pre_load(opaque);
        if (ret) {
            return ret;
        }
    }
    while (field->name) {
        if ((field->field_exists &&
             field->field_exists(opaque, version_id)) ||
            (!field->field_exists &&
             field->version_id <= version_id)) {
            void *first_elem = opaque + field->offset;
            int i, n_elems = vmstate_n_elems(opaque, field);
            int size = vmstate_size(opaque, field);

            vmstate_handle_alloc(first_elem, field, opaque);
            if (field->flags & VMS_POINTER) {
                first_elem = *(void **)first_elem;
                assert(first_elem || !n_elems || !size);
            }
            for (i = 0; i < n_elems; i++) {
                void *curr_elem = first_elem + size * i;

                if (field->flags & VMS_ARRAY_OF_POINTER) {
                    curr_elem = *(void **)curr_elem;
                }
                if (!curr_elem && size) {
                    /* if null pointer check placeholder and do not follow */
                    assert(field->flags & VMS_ARRAY_OF_POINTER);
                    ret = slirp_vmstate_info_nullptr.get(f, curr_elem, size, NULL);
                } else if (field->flags & VMS_STRUCT) {
                    ret = slirp_vmstate_load_state(f, field->vmsd, curr_elem,
                                             field->vmsd->version_id);
                } else if (field->flags & VMS_VSTRUCT) {
                    ret = slirp_vmstate_load_state(f, field->vmsd, curr_elem,
                                             field->struct_version_id);
                } else {
                    ret = field->info->get(f, curr_elem, size, field);
                }
                if (ret < 0) {
                    g_warning("Failed to load %s:%s", vmsd->name,
                              field->name);
                    return ret;
                }
            }
        } else if (field->flags & VMS_MUST_EXIST) {
            g_warning("Input validation failed: %s/%s",
                      vmsd->name, field->name);
            return -1;
        }
        field++;
    }
    if (vmsd->post_load) {
        ret = vmsd->post_load(opaque, version_id);
    }
    return ret;
}
Commit	Line	Data
b92a1ff4 MAL	1	/*
	2	* VMState interpreter
	3	*
	4	* Copyright (c) 2009-2018 Red Hat Inc
	5	*
	6	* Authors:
	7	* Juan Quintela <quintela@redhat.com>
	8	*
87ecdc71 MAL	9	* Redistribution and use in source and binary forms, with or without
	10	* modification, are permitted provided that the following conditions
	11	* are met:
	12	*
	13	* 1. Redistributions of source code must retain the above
	14	* copyright notice, this list of conditions and the following
	15	* disclaimer.
	16	*
	17	* 2. Redistributions in binary form must reproduce the above
	18	* copyright notice, this list of conditions and the following
	19	* disclaimer in the documentation and/or other materials provided
	20	* with the distribution.
	21	*
	22	* 3. Neither the name of the copyright holder nor the names of its
	23	* contributors may be used to endorse or promote products derived
	24	* from this software without specific prior written permission.
	25	*
	26	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	27	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	28	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
	29	* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
	30	* COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
	31	* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
	32	* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	33	* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	34	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
	35	* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	36	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
	37	* OF THE POSSIBILITY OF SUCH DAMAGE.
b92a1ff4 MAL	38	*/
	39	#include <assert.h>
	40	#include <errno.h>
	41	#include <string.h>
	42	#include <glib.h>
	43
	44	#include "stream.h"
	45	#include "vmstate.h"
	46
	47	static int get_nullptr(SlirpIStream f, void pv, size_t size,
	48	const VMStateField *field)
	49	{
	50	if (slirp_istream_read_u8(f) == VMS_NULLPTR_MARKER) {
	51	return 0;
	52	}
	53	g_warning("vmstate: get_nullptr expected VMS_NULLPTR_MARKER");
	54	return -EINVAL;
	55	}
	56
	57	static int put_nullptr(SlirpOStream f, void pv, size_t size,
	58	const VMStateField *field)
	59
	60	{
	61	if (pv == NULL) {
	62	slirp_ostream_write_u8(f, VMS_NULLPTR_MARKER);
	63	return 0;
	64	}
	65	g_warning("vmstate: put_nullptr must be called with pv == NULL");
	66	return -EINVAL;
	67	}
	68
	69	const VMStateInfo slirp_vmstate_info_nullptr = {
	70	.name = "uint64",
	71	.get = get_nullptr,
	72	.put = put_nullptr,
	73	};
	74
	75	/* 8 bit unsigned int */
	76
	77	static int get_uint8(SlirpIStream f, void pv, size_t size, const VMStateField *field)
	78	{
	79	uint8_t *v = pv;
	80	*v = slirp_istream_read_u8(f);
	81	return 0;
	82	}
	83
	84	static int put_uint8(SlirpOStream f, void pv, size_t size, const VMStateField *field)
	85	{
	86	uint8_t *v = pv;
	87	slirp_ostream_write_u8(f, *v);
	88	return 0;
	89	}
	90
	91	const VMStateInfo slirp_vmstate_info_uint8 = {
	92	.name = "uint8",
	93	.get = get_uint8,
	94	.put = put_uint8,
	95	};
	96
	97	/* 16 bit unsigned int */
	98
	99	static int get_uint16(SlirpIStream f, void pv, size_t size,
	100	const VMStateField *field)
	101	{
102	uint16_t *v = pv;
103	*v = slirp_istream_read_u16(f);
104	return 0;
105	}
106
107	static int put_uint16(SlirpOStream f, void pv, size_t size,
108	const VMStateField *field)
109	{
110	uint16_t *v = pv;
111	slirp_ostream_write_u16(f, *v);
112	return 0;
113	}
114
115	const VMStateInfo slirp_vmstate_info_uint16 = {
116	.name = "uint16",
117	.get = get_uint16,
118	.put = put_uint16,
119	};
120
121	/* 32 bit unsigned int */
122
123	static int get_uint32(SlirpIStream f, void pv, size_t size,
124	const VMStateField *field)
125	{
126	uint32_t *v = pv;
127	*v = slirp_istream_read_u32(f);
128	return 0;
129	}
130
131	static int put_uint32(SlirpOStream f, void pv, size_t size,
132	const VMStateField *field)
133	{
134	uint32_t *v = pv;
135	slirp_ostream_write_u32(f, *v);
136	return 0;
137	}
138
139	const VMStateInfo slirp_vmstate_info_uint32 = {
140	.name = "uint32",
141	.get = get_uint32,
142	.put = put_uint32,
143	};
144
145	/* 16 bit int */
146
147	static int get_int16(SlirpIStream f, void pv, size_t size, const VMStateField *field)
148	{
149	int16_t *v = pv;
150	*v = slirp_istream_read_i16(f);
151	return 0;
152	}
153
154	static int put_int16(SlirpOStream f, void pv, size_t size, const VMStateField *field)
155	{
156	int16_t *v = pv;
157	slirp_ostream_write_i16(f, *v);
158	return 0;
159	}
160
161	const VMStateInfo slirp_vmstate_info_int16 = {
162	.name = "int16",
163	.get = get_int16,
164	.put = put_int16,
165	};
166
167	/* 32 bit int */
168
169	static int get_int32(SlirpIStream f, void pv, size_t size, const VMStateField *field)
170	{
171	int32_t *v = pv;
172	*v = slirp_istream_read_i32(f);
173	return 0;
174	}
175
176	static int put_int32(SlirpOStream f, void pv, size_t size, const VMStateField *field)
177	{
178	int32_t *v = pv;
179	slirp_ostream_write_i32(f, *v);
180	return 0;
181	}
182
183	const VMStateInfo slirp_vmstate_info_int32 = {
184	.name = "int32",
185	.get = get_int32,
186	.put = put_int32,
187	};
188
189	/* vmstate_info_tmp, see VMSTATE_WITH_TMP, the idea is that we allocate
190	* a temporary buffer and the pre_load/pre_save methods in the child vmsd
191	* copy stuff from the parent into the child and do calculations to fill
192	* in fields that don't really exist in the parent but need to be in the
193	* stream.
194	*/
195	static int get_tmp(SlirpIStream f, void pv, size_t size, const VMStateField *field)
196	{
197	int ret;
198	const VMStateDescription *vmsd = field->vmsd;
199	int version_id = field->version_id;
200	void *tmp = g_malloc(size);
201
202	/* Writes the parent field which is at the start of the tmp */
203	(void *)tmp = pv;
204	ret = slirp_vmstate_load_state(f, vmsd, tmp, version_id);
205	g_free(tmp);
206	return ret;
207	}
208
209	static int put_tmp(SlirpOStream f, void pv, size_t size, const VMStateField *field)
210	{
211	const VMStateDescription *vmsd = field->vmsd;
212	void *tmp = g_malloc(size);
213	int ret;
214
215	/* Writes the parent field which is at the start of the tmp */
216	(void *)tmp = pv;
217	ret = slirp_vmstate_save_state(f, vmsd, tmp);
218	g_free(tmp);
219
220	return ret;
221	}
222
223	const VMStateInfo slirp_vmstate_info_tmp = {
224	.name = "tmp",
225	.get = get_tmp,
226	.put = put_tmp,
227	};
228
229	/* uint8_t buffers */
230
231	static int get_buffer(SlirpIStream f, void pv, size_t size,
232	const VMStateField *field)
233	{
234	slirp_istream_read(f, pv, size);
235	return 0;
236	}
237
238	static int put_buffer(SlirpOStream f, void pv, size_t size,
239	const VMStateField *field)
240	{
241	slirp_ostream_write(f, pv, size);
242	return 0;
243	}
244
245	const VMStateInfo slirp_vmstate_info_buffer = {
246	.name = "buffer",
247	.get = get_buffer,
248	.put = put_buffer,
249	};
250
251	static int vmstate_n_elems(void opaque, const VMStateField field)
252	{
253	int n_elems = 1;
254
255	if (field->flags & VMS_ARRAY) {
256	n_elems = field->num;
257	} else if (field->flags & VMS_VARRAY_INT32) {
258	n_elems = (int32_t )(opaque + field->num_offset);
259	} else if (field->flags & VMS_VARRAY_UINT32) {
260	n_elems = (uint32_t )(opaque + field->num_offset);
261	} else if (field->flags & VMS_VARRAY_UINT16) {
262	n_elems = (uint16_t )(opaque + field->num_offset);
263	} else if (field->flags & VMS_VARRAY_UINT8) {
264	n_elems = (uint8_t )(opaque + field->num_offset);
265	}
266
267	if (field->flags & VMS_MULTIPLY_ELEMENTS) {
268	n_elems *= field->num;
269	}
270
271	return n_elems;
272	}
273
274	static int vmstate_size(void opaque, const VMStateField field)
275	{
276	int size = field->size;
277
278	if (field->flags & VMS_VBUFFER) {
279	size = (int32_t )(opaque + field->size_offset);
280	if (field->flags & VMS_MULTIPLY) {
281	size *= field->size;
282	}
283	}
284
285	return size;
286	}
287
288	static int
289	vmstate_save_state_v(SlirpOStream f, const VMStateDescription vmsd,
290	void *opaque, int version_id)
291	{
292	int ret = 0;
293	const VMStateField *field = vmsd->fields;
294
295	if (vmsd->pre_save) {
296	ret = vmsd->pre_save(opaque);
297	if (ret) {
298	g_warning("pre-save failed: %s", vmsd->name);
299	return ret;
300	}
301	}
302
303	while (field->name) {
304	if ((field->field_exists &&
305	field->field_exists(opaque, version_id)) \|\|
306	(!field->field_exists &&
307	field->version_id <= version_id)) {
308	void *first_elem = opaque + field->offset;
309	int i, n_elems = vmstate_n_elems(opaque, field);
310	int size = vmstate_size(opaque, field);
311
312	if (field->flags & VMS_POINTER) {
313	first_elem = (void *)first_elem;
314	assert(first_elem \|\| !n_elems \|\| !size);
315	}
316	for (i = 0; i < n_elems; i++) {
317	void curr_elem = first_elem + size i;
318	ret = 0;
319
320	if (field->flags & VMS_ARRAY_OF_POINTER) {
321	assert(curr_elem);
322	curr_elem = (void *)curr_elem;
323	}
324	if (!curr_elem && size) {
325	/* if null pointer write placeholder and do not follow */
326	assert(field->flags & VMS_ARRAY_OF_POINTER);
327	ret = slirp_vmstate_info_nullptr.put(f, curr_elem, size, NULL);
328	} else if (field->flags & VMS_STRUCT) {
329	ret = slirp_vmstate_save_state(f, field->vmsd, curr_elem);
330	} else if (field->flags & VMS_VSTRUCT) {
331	ret = vmstate_save_state_v(f, field->vmsd, curr_elem,
332	field->struct_version_id);
333	} else {
334	ret = field->info->put(f, curr_elem, size, field);
335	}
336	if (ret) {
337	g_warning("Save of field %s/%s failed",
338	vmsd->name, field->name);
339	return ret;
340	}
341	}
342	} else {
343	if (field->flags & VMS_MUST_EXIST) {
344	g_warning("Output state validation failed: %s/%s",
345	vmsd->name, field->name);
346	assert(!(field->flags & VMS_MUST_EXIST));
347	}
348	}
349	field++;
350	}
351
352	return 0;
353	}
354
355	int slirp_vmstate_save_state(SlirpOStream f, const VMStateDescription vmsd,
356	void *opaque)
357	{
358	return vmstate_save_state_v(f, vmsd, opaque, vmsd->version_id);
359	}
360
361	static void vmstate_handle_alloc(void ptr, VMStateField field, void *opaque)
362	{
363	if (field->flags & VMS_POINTER && field->flags & VMS_ALLOC) {
364	size_t size = vmstate_size(opaque, field);
365	size *= vmstate_n_elems(opaque, field);
366	if (size) {
367	(void *)ptr = g_malloc(size);
368	}
369	}
370	}
371
372	int slirp_vmstate_load_state(SlirpIStream f, const VMStateDescription vmsd,
373	void *opaque, int version_id)
374	{
375	VMStateField *field = vmsd->fields;
376	int ret = 0;
377
378	if (version_id > vmsd->version_id) {
379	g_warning("%s: incoming version_id %d is too new "
380	"for local version_id %d",
381	vmsd->name, version_id, vmsd->version_id);
382	return -EINVAL;
383	}
384	if (vmsd->pre_load) {
385	int ret = vmsd->pre_load(opaque);
386	if (ret) {
387	return ret;
388	}
389	}
390	while (field->name) {
391	if ((field->field_exists &&
392	field->field_exists(opaque, version_id)) \|\|
393	(!field->field_exists &&
394	field->version_id <= version_id)) {
395	void *first_elem = opaque + field->offset;
396	int i, n_elems = vmstate_n_elems(opaque, field);
397	int size = vmstate_size(opaque, field);
398
399	vmstate_handle_alloc(first_elem, field, opaque);
400	if (field->flags & VMS_POINTER) {
401	first_elem = (void *)first_elem;
402	assert(first_elem \|\| !n_elems \|\| !size);
403	}
404	for (i = 0; i < n_elems; i++) {
405	void curr_elem = first_elem + size i;
406
407	if (field->flags & VMS_ARRAY_OF_POINTER) {
408	curr_elem = (void *)curr_elem;
409	}
410	if (!curr_elem && size) {
411	/* if null pointer check placeholder and do not follow */
412	assert(field->flags & VMS_ARRAY_OF_POINTER);
413	ret = slirp_vmstate_info_nullptr.get(f, curr_elem, size, NULL);
414	} else if (field->flags & VMS_STRUCT) {
415	ret = slirp_vmstate_load_state(f, field->vmsd, curr_elem,
416	field->vmsd->version_id);
417	} else if (field->flags & VMS_VSTRUCT) {
418	ret = slirp_vmstate_load_state(f, field->vmsd, curr_elem,
419	field->struct_version_id);
420	} else {
421	ret = field->info->get(f, curr_elem, size, field);
422	}
423	if (ret < 0) {
424	g_warning("Failed to load %s:%s", vmsd->name,
425	field->name);
426	return ret;
427	}
428	}
429	} else if (field->flags & VMS_MUST_EXIST) {
430	g_warning("Input validation failed: %s/%s",
431	vmsd->name, field->name);
432	return -1;
433	}
434	field++;
435	}
436	if (vmsd->post_load) {
437	ret = vmsd->post_load(opaque, version_id);
438	}
439	return ret;
440	}