Commit b92a1ff4 authored by Marc-André Lureau's avatar Marc-André Lureau Committed by Samuel Thibault
Browse files

slirp: adapt a subset of QEMU vmstate code 



Add vmstate serialization code adapted from QEMU.

Keep only the bits that are required for libslirp.

Introduce a IStream/OStream interface to replace QEMU QFile
abstraction.

Signed-off-by: default avatarMarc-André Lureau <marcandre.lureau@redhat.com>
Message-Id: <20190212162524.31504-2-marcandre.lureau@redhat.com>
Signed-off-by: default avatarSamuel Thibault <samuel.thibault@ens-lyon.org>
parent ffe02f55

slirp/Makefile.objs

+2 −0
Original line number Diff line number Diff line
@@ -21,6 +21,7 @@ slirp.mo-objs = \ 
	slirp.o \

	socket.o \

	state.o \

	stream.o \

	tcp_input.o \

	tcp_output.o \

	tcp_subr.o \
@@ -29,6 +30,7 @@ slirp.mo-objs = \ 
	udp.o \

	udp6.o \

	util.o \

	vmstate.o \

	$(NULL)



slirp.mo-cflags = -DG_LOG_DOMAIN=\"Slirp\" -DWITH_QEMU

slirp/libslirp.h

+2 −0
Original line number Diff line number Diff line
@@ -3,6 +3,7 @@ 


#include <stdint.h>

#include <stdbool.h>

#include <sys/types.h>



#ifdef _WIN32

#include <winsock2.h>
@@ -26,6 +27,7 @@ enum { 
    SLIRP_POLL_HUP = 1 << 4,

};



typedef ssize_t (*SlirpReadCb)(void *buf, size_t len, void *opaque);

typedef ssize_t (*SlirpWriteCb)(const void *buf, size_t len, void *opaque);

typedef void (*SlirpTimerCb)(void *opaque);

typedef int (*SlirpAddPollCb)(int fd, int events, void *opaque);

slirp/stream.c

0 → 100644
+119 −0
Original line number Diff line number Diff line 
/*

 * libslirp io streams

 *

 * Copyright (c) 2018 Red Hat, Inc.

 *

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to deal

 * in the Software without restriction, including without limitation the rights

 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

 * copies of the Software, and to permit persons to whom the Software is

 * furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included in

 * all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

 * THE SOFTWARE.

 */

#include "stream.h"

#include <glib.h>



bool slirp_istream_read(SlirpIStream *f, void *buf, size_t size)

{

    return f->read_cb(buf, size, f->opaque) == size;

}



bool slirp_ostream_write(SlirpOStream *f, const void *buf, size_t size)

{

    return f->write_cb(buf, size, f->opaque) == size;

}



uint8_t slirp_istream_read_u8(SlirpIStream *f)

{

    uint8_t b;



    if (slirp_istream_read(f, &b, sizeof(b))) {

        return b;

    }



    return 0;

}



bool slirp_ostream_write_u8(SlirpOStream *f, uint8_t b)

{

    return slirp_ostream_write(f, &b, sizeof(b));

}



uint16_t slirp_istream_read_u16(SlirpIStream *f)

{

    uint16_t b;



    if (slirp_istream_read(f, &b, sizeof(b))) {

        return GUINT16_FROM_BE(b);

    }



    return 0;

}



bool slirp_ostream_write_u16(SlirpOStream *f, uint16_t b)

{

    b =  GUINT16_TO_BE(b);

    return slirp_ostream_write(f, &b, sizeof(b));

}



uint32_t slirp_istream_read_u32(SlirpIStream *f)

{

    uint32_t b;



    if (slirp_istream_read(f, &b, sizeof(b))) {

        return GUINT32_FROM_BE(b);

    }



    return 0;

}



bool slirp_ostream_write_u32(SlirpOStream *f, uint32_t b)

{

    b = GUINT32_TO_BE(b);

    return slirp_ostream_write(f, &b, sizeof(b));

}



int16_t slirp_istream_read_i16(SlirpIStream *f)

{

    int16_t b;



    if (slirp_istream_read(f, &b, sizeof(b))) {

        return GINT16_FROM_BE(b);

    }



    return 0;

}



bool slirp_ostream_write_i16(SlirpOStream *f, int16_t b)

{

    b = GINT16_TO_BE(b);

    return slirp_ostream_write(f, &b, sizeof(b));

}



int32_t slirp_istream_read_i32(SlirpIStream *f)

{

    int32_t b;



    if (slirp_istream_read(f, &b, sizeof(b))) {

        return GINT32_FROM_BE(b);

    }



    return 0;

}



bool slirp_ostream_write_i32(SlirpOStream *f, int32_t b)

{

    b = GINT32_TO_BE(b);

    return slirp_ostream_write(f, &b, sizeof(b));

}

slirp/stream.h

0 → 100644
+34 −0
Original line number Diff line number Diff line 
#ifndef STREAM_H_

#define STREAM_H_



#include "libslirp.h"



typedef struct SlirpIStream {

    SlirpReadCb read_cb;

    void *opaque;

} SlirpIStream;



typedef struct SlirpOStream {

    SlirpWriteCb write_cb;

    void *opaque;

} SlirpOStream;



bool slirp_istream_read(SlirpIStream *f, void *buf, size_t size);

bool slirp_ostream_write(SlirpOStream *f, const void *buf, size_t size);



uint8_t slirp_istream_read_u8(SlirpIStream *f);

bool slirp_ostream_write_u8(SlirpOStream *f, uint8_t b);



uint16_t slirp_istream_read_u16(SlirpIStream *f);

bool slirp_ostream_write_u16(SlirpOStream *f, uint16_t b);



uint32_t slirp_istream_read_u32(SlirpIStream *f);

bool slirp_ostream_write_u32(SlirpOStream *f, uint32_t b);



int16_t slirp_istream_read_i16(SlirpIStream *f);

bool slirp_ostream_write_i16(SlirpOStream *f, int16_t b);



int32_t slirp_istream_read_i32(SlirpIStream *f);

bool slirp_ostream_write_i32(SlirpOStream *f, int32_t b);



#endif /* STREAM_H_ */

slirp/vmstate.c

0 → 100644
+413 −0
Original line number Diff line number Diff line 
/*

 * VMState interpreter

 *

 * Copyright (c) 2009-2018 Red Hat Inc

 *

 * Authors:

 *  Juan Quintela <quintela@redhat.com>

 *

 * This work is licensed under the terms of the GNU GPL, version 2 or later.

 * See the COPYING file in the top-level directory.

 */

#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;

}