Commit 32d9c561 authored by Peter Maydell's avatar Peter Maydell
Browse files

Merge remote-tracking branch 'remotes/juanquintela/tags/migration/20141015' into staging 



migration/next for 20141015

# gpg: Signature made Wed 15 Oct 2014 09:21:54 BST using RSA key ID 5872D723
# gpg: Can't check signature: public key not found

* remotes/juanquintela/tags/migration/20141015:
  migration: catch unknown flag combinations in ram_load
  qemu-file: Move stdio implementation to qemu-file-stdio.c
  qemu-file: Move unix and socket implementations to qemu-file-unix.c
  qemu-file: Use qemu_file_is_writable() on stdio_fclose()
  qemu-file: Make qemu_file_is_writable() non-static
  qemu-file: Add copyright header to qemu-file.c
  vmstate: Allow dynamic allocation for VBUFFER during migration
  block/migration: Disable cache invalidate for incoming migration
  Tests: QEMUSizedBuffer/QEMUBuffer
  QEMUSizedBuffer based QEMUFile

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents 88e65996 5b0e9dd4

Makefile.objs

+1 −1
Original line number Diff line number Diff line
@@ -50,7 +50,7 @@ common-obj-$(CONFIG_LINUX) += fsdev/ 


common-obj-y += migration.o migration-tcp.o

common-obj-y += vmstate.o

common-obj-y += qemu-file.o

common-obj-y += qemu-file.o qemu-file-unix.o qemu-file-stdio.o

common-obj-$(CONFIG_RDMA) += migration-rdma.o

common-obj-y += qemu-char.o #aio.o

common-obj-y += block-migration.o

arch_init.c

+32 −30
Original line number Diff line number Diff line
@@ -1040,8 +1040,7 @@ void ram_handle_compressed(void *host, uint8_t ch, uint64_t size) 


static int ram_load(QEMUFile *f, void *opaque, int version_id)

{

    ram_addr_t addr;

    int flags, ret = 0;

    int flags = 0, ret = 0;

    static uint64_t seq_iter;



    seq_iter++;
@@ -1050,21 +1049,24 @@ static int ram_load(QEMUFile *f, void *opaque, int version_id) 
        ret = -EINVAL;

    }



    while (!ret) {

        addr = qemu_get_be64(f);

    while (!ret && !(flags & RAM_SAVE_FLAG_EOS)) {

        ram_addr_t addr, total_ram_bytes;

        void *host;

        uint8_t ch;



        addr = qemu_get_be64(f);

        flags = addr & ~TARGET_PAGE_MASK;

        addr &= TARGET_PAGE_MASK;



        if (flags & RAM_SAVE_FLAG_MEM_SIZE) {

        switch (flags & ~RAM_SAVE_FLAG_CONTINUE) {

        case RAM_SAVE_FLAG_MEM_SIZE:

            /* Synchronize RAM block list */

            char id[256];

            ram_addr_t length;

            ram_addr_t total_ram_bytes = addr;



            while (total_ram_bytes) {

            total_ram_bytes = addr;

            while (!ret && total_ram_bytes) {

                RAMBlock *block;

                uint8_t len;

                char id[256];

                ram_addr_t length;



                len = qemu_get_byte(f);

                qemu_get_buffer(f, (uint8_t *)id, len);
@@ -1088,16 +1090,11 @@ static int ram_load(QEMUFile *f, void *opaque, int version_id) 
                                 "accept migration", id);

                    ret = -EINVAL;

                }

                if (ret) {

                    break;

                }



                total_ram_bytes -= length;

            }

        } else if (flags & RAM_SAVE_FLAG_COMPRESS) {

            void *host;

            uint8_t ch;



            break;

        case RAM_SAVE_FLAG_COMPRESS:

            host = host_from_stream_offset(f, addr, flags);

            if (!host) {

                error_report("Illegal RAM offset " RAM_ADDR_FMT, addr);
@@ -1107,9 +1104,8 @@ static int ram_load(QEMUFile *f, void *opaque, int version_id) 


            ch = qemu_get_byte(f);

            ram_handle_compressed(host, ch, TARGET_PAGE_SIZE);

        } else if (flags & RAM_SAVE_FLAG_PAGE) {

            void *host;



            break;

        case RAM_SAVE_FLAG_PAGE:

            host = host_from_stream_offset(f, addr, flags);

            if (!host) {

                error_report("Illegal RAM offset " RAM_ADDR_FMT, addr);
@@ -1118,8 +1114,9 @@ static int ram_load(QEMUFile *f, void *opaque, int version_id) 
            }



            qemu_get_buffer(f, host, TARGET_PAGE_SIZE);

        } else if (flags & RAM_SAVE_FLAG_XBZRLE) {

            void *host = host_from_stream_offset(f, addr, flags);

            break;

        case RAM_SAVE_FLAG_XBZRLE:

            host = host_from_stream_offset(f, addr, flags);

            if (!host) {

                error_report("Illegal RAM offset " RAM_ADDR_FMT, addr);

                ret = -EINVAL;
@@ -1132,18 +1129,23 @@ static int ram_load(QEMUFile *f, void *opaque, int version_id) 
                ret = -EINVAL;

                break;

            }

        } else if (flags & RAM_SAVE_FLAG_HOOK) {

            ram_control_load_hook(f, flags);

        } else if (flags & RAM_SAVE_FLAG_EOS) {

            break;

        case RAM_SAVE_FLAG_EOS:

            /* normal exit */

            break;

        default:

            if (flags & RAM_SAVE_FLAG_HOOK) {

                ram_control_load_hook(f, flags);

            } else {

            error_report("Unknown migration flags: %#x", flags);

                error_report("Unknown combination of migration flags: %#x",

                             flags);

                ret = -EINVAL;

            break;

            }

        }

        if (!ret) {

            ret = qemu_file_get_error(f);

        }

    }



    DPRINTF("Completed load of VM with exit code %d seq iteration "

            "%" PRIu64 "\n", ret, seq_iter);

block.c

+5 −13
Original line number Diff line number Diff line
@@ -5043,6 +5043,11 @@ void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp) 
        return;

    }



    if (!(bs->open_flags & BDRV_O_INCOMING)) {

        return;

    }

    bs->open_flags &= ~BDRV_O_INCOMING;



    if (bs->drv->bdrv_invalidate_cache) {

        bs->drv->bdrv_invalidate_cache(bs, &local_err);

    } else if (bs->file) {
@@ -5078,19 +5083,6 @@ void bdrv_invalidate_cache_all(Error **errp) 
    }

}



void bdrv_clear_incoming_migration_all(void)

{

    BlockDriverState *bs;



    QTAILQ_FOREACH(bs, &bdrv_states, device_list) {

        AioContext *aio_context = bdrv_get_aio_context(bs);



        aio_context_acquire(aio_context);

        bs->open_flags = bs->open_flags & ~(BDRV_O_INCOMING);

        aio_context_release(aio_context);

    }

}



int bdrv_flush(BlockDriverState *bs)

{

    Coroutine *co;

include/migration/qemu-file.h

+27 −0
Original line number Diff line number Diff line
@@ -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,19 @@ 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 */

};



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);
@@ -110,6 +120,23 @@ 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);

bool qemu_file_is_writable(QEMUFile *f);



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)

{

include/migration/vmstate.h

+11 −0
Original line number Diff line number Diff line
@@ -484,6 +484,17 @@ extern const VMStateInfo vmstate_info_bitmap; 
    .start        = (_start),                                        \

}



#define VMSTATE_VBUFFER_ALLOC_UINT32(_field, _state, _version, _test, _start, _field_size) { \

    .name         = (stringify(_field)),                             \

    .version_id   = (_version),                                      \

    .field_exists = (_test),                                         \

    .size_offset  = vmstate_offset_value(_state, _field_size, uint32_t),\

    .info         = &vmstate_info_buffer,                            \

    .flags        = VMS_VBUFFER|VMS_POINTER|VMS_ALLOC,               \

    .offset       = offsetof(_state, _field),                        \

    .start        = (_start),                                        \

}



#define VMSTATE_BUFFER_UNSAFE_INFO(_field, _state, _version, _info, _size) { \

    .name       = (stringify(_field)),                               \

    .version_id = (_version),                                        \