Commit b2312c68 authored by Peter Maydell's avatar Peter Maydell
Browse files

Merge remote-tracking branch 'remotes/amit-migration/tags/for-juan-201509' into staging 



Migration queue

# gpg: Signature made Tue 29 Sep 2015 07:13:55 BST using RSA key ID 854083B6
# gpg: Good signature from "Amit Shah <amit@amitshah.net>"
# gpg:                 aka "Amit Shah <amit@kernel.org>"
# gpg:                 aka "Amit Shah <amitshah@gmx.net>"

* remotes/amit-migration/tags/for-juan-201509:
  ram_find_and_save_block: Split out the finding
  Move dirty page search state into separate structure
  migration: Use g_new() & friends where that makes obvious sense
  migration: qemu-file more size_t'ifying
  migration: size_t'ify some of qemu-file
  Init page sizes in qtest
  Split out end of migration code from migration_thread
  migration/ram.c: Use RAMBlock rather than MemoryRegion
  vmstate: Remove redefinition of VMSTATE_UINT32_ARRAY

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents 6996a002 b9e60928

include/migration/qemu-file.h

+9 −9
Original line number Diff line number Diff line
@@ -31,15 +31,15 @@ 
 * 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.

 */

typedef int (QEMUFilePutBufferFunc)(void *opaque, const uint8_t *buf,

                                    int64_t pos, int size);

typedef ssize_t (QEMUFilePutBufferFunc)(void *opaque, const uint8_t *buf,

                                        int64_t pos, size_t size);



/* Read a chunk of data from a file at the given position.  The pos argument

 * can be ignored if the file is only be used for streaming.  The number of

 * bytes actually read should be returned.

 */

typedef int (QEMUFileGetBufferFunc)(void *opaque, uint8_t *buf,

                                    int64_t pos, int size);

typedef ssize_t (QEMUFileGetBufferFunc)(void *opaque, uint8_t *buf,

                                        int64_t pos, size_t size);



/* Close a file

 *
@@ -126,13 +126,13 @@ int qemu_get_fd(QEMUFile *f); 
int qemu_fclose(QEMUFile *f);

int64_t qemu_ftell(QEMUFile *f);

int64_t qemu_ftell_fast(QEMUFile *f);

void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size);

void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, size_t size);

void qemu_put_byte(QEMUFile *f, int v);

/*

 * put_buffer without copying the buffer.

 * The buffer should be available till it is sent asynchronously.

 */

void qemu_put_buffer_async(QEMUFile *f, const uint8_t *buf, int size);

void qemu_put_buffer_async(QEMUFile *f, const uint8_t *buf, size_t size);

bool qemu_file_mode_is_not_valid(const char *mode);

bool qemu_file_is_writable(QEMUFile *f);
@@ -161,8 +161,8 @@ static inline void qemu_put_ubyte(QEMUFile *f, unsigned int v) 
void qemu_put_be16(QEMUFile *f, unsigned int v);

void qemu_put_be32(QEMUFile *f, unsigned int v);

void qemu_put_be64(QEMUFile *f, uint64_t v);

int qemu_peek_buffer(QEMUFile *f, uint8_t **buf, int size, size_t offset);

int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size);

size_t qemu_peek_buffer(QEMUFile *f, uint8_t **buf, size_t size, size_t offset);

size_t qemu_get_buffer(QEMUFile *f, uint8_t *buf, size_t size);

ssize_t qemu_put_compression_data(QEMUFile *f, const uint8_t *p, size_t size,

                                  int level);

int qemu_put_qemu_file(QEMUFile *f_des, QEMUFile *f_src);
@@ -237,7 +237,7 @@ static inline void qemu_get_8s(QEMUFile *f, uint8_t *pv) 
}



// Signed versions for type safety

static inline void qemu_put_sbuffer(QEMUFile *f, const int8_t *buf, int size)

static inline void qemu_put_sbuffer(QEMUFile *f, const int8_t *buf, size_t size)

{

    qemu_put_buffer(f, (const uint8_t *)buf, size);

}

include/migration/vmstate.h

+0 −3
Original line number Diff line number Diff line
@@ -754,9 +754,6 @@ extern const VMStateInfo vmstate_info_bitmap; 
#define VMSTATE_UINT32_SUB_ARRAY(_f, _s, _start, _num)                \

    VMSTATE_SUB_ARRAY(_f, _s, _start, _num, 0, vmstate_info_uint32, uint32_t)



#define VMSTATE_UINT32_ARRAY(_f, _s, _n)                              \

    VMSTATE_UINT32_ARRAY_V(_f, _s, _n, 0)



#define VMSTATE_INT64_ARRAY_V(_f, _s, _n, _v)                         \

    VMSTATE_ARRAY(_f, _s, _n, _v, vmstate_info_int64, int64_t)

migration/migration.c

+48 −29
Original line number Diff line number Diff line
@@ -86,7 +86,7 @@ MigrationIncomingState *migration_incoming_get_current(void) 


MigrationIncomingState *migration_incoming_state_new(QEMUFile* f)

{

    mis_current = g_malloc0(sizeof(MigrationIncomingState));

    mis_current = g_new0(MigrationIncomingState, 1);

    mis_current->file = f;

    QLIST_INIT(&mis_current->loadvm_handlers);
@@ -913,6 +913,50 @@ int64_t migrate_xbzrle_cache_size(void) 
    return s->xbzrle_cache_size;

}



/**

 * migration_completion: Used by migration_thread when there's not much left.

 *   The caller 'breaks' the loop when this returns.

 *

 * @s: Current migration state

 * @*old_vm_running: Pointer to old_vm_running flag

 * @*start_time: Pointer to time to update

 */

static void migration_completion(MigrationState *s, bool *old_vm_running,

                                 int64_t *start_time)

{

    int ret;



    qemu_mutex_lock_iothread();

    *start_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);

    qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER);

    *old_vm_running = runstate_is_running();



    ret = global_state_store();

    if (!ret) {

        ret = vm_stop_force_state(RUN_STATE_FINISH_MIGRATE);

        if (ret >= 0) {

            qemu_file_set_rate_limit(s->file, INT64_MAX);

            qemu_savevm_state_complete(s->file);

        }

    }

    qemu_mutex_unlock_iothread();



    if (ret < 0) {

        goto fail;

    }



    if (qemu_file_get_error(s->file)) {

        trace_migration_completion_file_err();

        goto fail;

    }



    migrate_set_state(s, MIGRATION_STATUS_ACTIVE, MIGRATION_STATUS_COMPLETED);

    return;



fail:

    migrate_set_state(s, MIGRATION_STATUS_ACTIVE, MIGRATION_STATUS_FAILED);

}



/* migration thread support */



static void *migration_thread(void *opaque)
@@ -943,36 +987,11 @@ static void *migration_thread(void *opaque) 
            if (pending_size && pending_size >= max_size) {

                qemu_savevm_state_iterate(s->file);

            } else {

                int ret;



                qemu_mutex_lock_iothread();

                start_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);

                qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER);

                old_vm_running = runstate_is_running();



                ret = global_state_store();

                if (!ret) {

                    ret = vm_stop_force_state(RUN_STATE_FINISH_MIGRATE);

                    if (ret >= 0) {

                        qemu_file_set_rate_limit(s->file, INT64_MAX);

                        qemu_savevm_state_complete(s->file);

                    }

                }

                qemu_mutex_unlock_iothread();



                if (ret < 0) {

                    migrate_set_state(s, MIGRATION_STATUS_ACTIVE,

                                      MIGRATION_STATUS_FAILED);

                    break;

                }



                if (!qemu_file_get_error(s->file)) {

                    migrate_set_state(s, MIGRATION_STATUS_ACTIVE,

                                      MIGRATION_STATUS_COMPLETED);

                trace_migration_thread_low_pending(pending_size);

                migration_completion(s, &old_vm_running, &start_time);

                break;

            }

        }

        }



        if (qemu_file_get_error(s->file)) {

            migrate_set_state(s, MIGRATION_STATUS_ACTIVE,

migration/qemu-file-buf.c

+5 −4
Original line number Diff line number Diff line
@@ -372,7 +372,8 @@ typedef struct QEMUBuffer { 
    bool qsb_allocated;

} QEMUBuffer;



static int buf_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)

static ssize_t buf_get_buffer(void *opaque, uint8_t *buf, int64_t pos,

                              size_t size)

{

    QEMUBuffer *s = opaque;

    ssize_t len = qsb_get_length(s->qsb) - pos;
@@ -387,8 +388,8 @@ static int buf_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size) 
    return qsb_get_buffer(s->qsb, pos, len, buf);

}



static int buf_put_buffer(void *opaque, const uint8_t *buf,

                          int64_t pos, int size)

static ssize_t buf_put_buffer(void *opaque, const uint8_t *buf,

                              int64_t pos, size_t size)

{

    QEMUBuffer *s = opaque;
@@ -439,7 +440,7 @@ QEMUFile *qemu_bufopen(const char *mode, QEMUSizedBuffer *input) 
        return NULL;

    }



    s = g_malloc0(sizeof(QEMUBuffer));

    s = g_new0(QEMUBuffer, 1);

    s->qsb = input;



    if (s->qsb == NULL) {

migration/qemu-file-stdio.c

+8 −7
Original line number Diff line number Diff line
@@ -37,11 +37,11 @@ static int stdio_get_fd(void *opaque) 
    return fileno(s->stdio_file);

}



static int stdio_put_buffer(void *opaque, const uint8_t *buf, int64_t pos,

                            int size)

static ssize_t stdio_put_buffer(void *opaque, const uint8_t *buf, int64_t pos,

                                size_t size)

{

    QEMUFileStdio *s = opaque;

    int res;

    size_t res;



    res = fwrite(buf, 1, size, s->stdio_file);
@@ -51,11 +51,12 @@ static int stdio_put_buffer(void *opaque, const uint8_t *buf, int64_t pos, 
    return res;

}



static int stdio_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)

static ssize_t stdio_get_buffer(void *opaque, uint8_t *buf, int64_t pos,

                                size_t size)

{

    QEMUFileStdio *s = opaque;

    FILE *fp = s->stdio_file;

    int bytes;

    ssize_t bytes;



    for (;;) {

        clearerr(fp);
@@ -143,7 +144,7 @@ QEMUFile *qemu_popen_cmd(const char *command, const char *mode) 
        return NULL;

    }



    s = g_malloc0(sizeof(QEMUFileStdio));

    s = g_new0(QEMUFileStdio, 1);



    s->stdio_file = stdio_file;
@@ -175,7 +176,7 @@ QEMUFile *qemu_fopen(const char *filename, const char *mode) 
        return NULL;

    }



    s = g_malloc0(sizeof(QEMUFileStdio));

    s = g_new0(QEMUFileStdio, 1);



    s->stdio_file = fopen(filename, mode);

    if (!s->stdio_file) {