vnc: added missing name->keysym pairs for Polish national characters

[qemu.git] / migration.c

diff --git a/migration.c b/migration.c
index dcde7c38da1547014b87aafc6581be159089547c..af3a1f27027c83cb482595f8bf641dfabd9443d0 100644 (file)
--- a/migration.c
+++ b/migration.c
@@ -18,111 +18,143 @@
 #include "sysemu.h"
 #include "block.h"
 #include "qemu_socket.h"
 #include "sysemu.h"
 #include "block.h"
 #include "qemu_socket.h"

+#include "block-migration.h"
+#include "qemu-objects.h"

 
 //#define DEBUG_MIGRATION
 
 #ifdef DEBUG_MIGRATION
 
 //#define DEBUG_MIGRATION
 
 #ifdef DEBUG_MIGRATION

-#define dprintf(fmt, ...) \
+#define DPRINTF(fmt, ...) \

     do { printf("migration: " fmt, ## __VA_ARGS__); } while (0)
 #else
     do { printf("migration: " fmt, ## __VA_ARGS__); } while (0)
 #else

-#define dprintf(fmt, ...) \
+#define DPRINTF(fmt, ...) \

     do { } while (0)
 #endif
 
 /* Migration speed throttling */
     do { } while (0)
 #endif
 
 /* Migration speed throttling */

-static uint32_t max_throttle = (32 << 20);
+static int64_t max_throttle = (32 << 20);

 
 static MigrationState *current_migration;
 
 
 static MigrationState *current_migration;
 

-void qemu_start_incoming_migration(const char *uri)
+static NotifierList migration_state_notifiers =
+    NOTIFIER_LIST_INITIALIZER(migration_state_notifiers);
+
+int qemu_start_incoming_migration(const char *uri)

 {
     const char *p;
 {
     const char *p;

+    int ret;

 
     if (strstart(uri, "tcp:", &p))
 
     if (strstart(uri, "tcp:", &p))

-        tcp_start_incoming_migration(p);
+        ret = tcp_start_incoming_migration(p);

 #if !defined(WIN32)
     else if (strstart(uri, "exec:", &p))
 #if !defined(WIN32)
     else if (strstart(uri, "exec:", &p))

-        exec_start_incoming_migration(p);
+        ret =  exec_start_incoming_migration(p);

     else if (strstart(uri, "unix:", &p))
     else if (strstart(uri, "unix:", &p))

-        unix_start_incoming_migration(p);
+        ret = unix_start_incoming_migration(p);

     else if (strstart(uri, "fd:", &p))
     else if (strstart(uri, "fd:", &p))

-        fd_start_incoming_migration(p);
+        ret = fd_start_incoming_migration(p);

 #endif
 #endif

-    else
+    else {

         fprintf(stderr, "unknown migration protocol: %s\n", uri);
         fprintf(stderr, "unknown migration protocol: %s\n", uri);

+        ret = -EPROTONOSUPPORT;
+    }
+    return ret;
+}
+
+void process_incoming_migration(QEMUFile *f)
+{
+    if (qemu_loadvm_state(f) < 0) {
+        fprintf(stderr, "load of migration failed\n");
+        exit(0);
+    }
+    qemu_announce_self();
+    DPRINTF("successfully loaded vm state\n");
+
+    incoming_expected = false;
+
+    if (autostart)
+        vm_start();

 }
 
 }
 

-void do_migrate(Monitor *mon, const QDict *qdict, QObject **ret_data)
+int do_migrate(Monitor *mon, const QDict *qdict, QObject **ret_data)

 {
     MigrationState *s = NULL;
     const char *p;
 {
     MigrationState *s = NULL;
     const char *p;

-    int detach = qdict_get_int(qdict, "detach");
+    int detach = qdict_get_try_bool(qdict, "detach", 0);
+    int blk = qdict_get_try_bool(qdict, "blk", 0);
+    int inc = qdict_get_try_bool(qdict, "inc", 0);

     const char *uri = qdict_get_str(qdict, "uri");
     const char *uri = qdict_get_str(qdict, "uri");

-    
-    if (strstart(uri, "tcp:", &p))
-        s = tcp_start_outgoing_migration(p, max_throttle, detach, 
-                                         (int)qdict_get_int(qdict, "blk"), 
-                                         (int)qdict_get_int(qdict, "inc"));
+
+    if (current_migration &&
+        current_migration->get_status(current_migration) == MIG_STATE_ACTIVE) {
+        monitor_printf(mon, "migration already in progress\n");
+        return -1;
+    }
+
+    if (qemu_savevm_state_blocked(mon)) {
+        return -1;
+    }
+
+    if (strstart(uri, "tcp:", &p)) {
+        s = tcp_start_outgoing_migration(mon, p, max_throttle, detach,
+                                         blk, inc);

 #if !defined(WIN32)
 #if !defined(WIN32)

-    else if (strstart(uri, "exec:", &p))
-        s = exec_start_outgoing_migration(p, max_throttle, detach, 
-                                          (int)qdict_get_int(qdict, "blk"), 
-                                          (int)qdict_get_int(qdict, "inc"));
-    else if (strstart(uri, "unix:", &p))
-        s = unix_start_outgoing_migration(p, max_throttle, detach, 
-                                         (int)qdict_get_int(qdict, "blk"), 
-                                          (int)qdict_get_int(qdict, "inc"));
-    else if (strstart(uri, "fd:", &p))
+    } else if (strstart(uri, "exec:", &p)) {
+        s = exec_start_outgoing_migration(mon, p, max_throttle, detach,
+                                          blk, inc);
+    } else if (strstart(uri, "unix:", &p)) {
+        s = unix_start_outgoing_migration(mon, p, max_throttle, detach,
+                                          blk, inc);
+    } else if (strstart(uri, "fd:", &p)) {

         s = fd_start_outgoing_migration(mon, p, max_throttle, detach, 
         s = fd_start_outgoing_migration(mon, p, max_throttle, detach, 

-                                        (int)qdict_get_int(qdict, "blk"), 
-                                        (int)qdict_get_int(qdict, "inc"));
+                                        blk, inc);

 #endif
 #endif

-    else
+    } else {

         monitor_printf(mon, "unknown migration protocol: %s\n", uri);
         monitor_printf(mon, "unknown migration protocol: %s\n", uri);

+        return -1;
+    }

 
 

-    if (s == NULL)
+    if (s == NULL) {

         monitor_printf(mon, "migration failed\n");
         monitor_printf(mon, "migration failed\n");

-    else {
-        if (current_migration)
-            current_migration->release(current_migration);
+        return -1;
+    }

 
 

-        current_migration = s;
+    if (current_migration) {
+        current_migration->release(current_migration);

     }
     }

+
+    current_migration = s;
+    notifier_list_notify(&migration_state_notifiers);
+    return 0;

 }
 
 }
 

-void do_migrate_cancel(Monitor *mon, const QDict *qdict, QObject **ret_data)
+int do_migrate_cancel(Monitor *mon, const QDict *qdict, QObject **ret_data)

 {
     MigrationState *s = current_migration;
 
     if (s)
         s->cancel(s);
 {
     MigrationState *s = current_migration;
 
     if (s)
         s->cancel(s);

+
+    return 0;

 }
 
 }
 

-void do_migrate_set_speed(Monitor *mon, const QDict *qdict, QObject **ret_data)
+int do_migrate_set_speed(Monitor *mon, const QDict *qdict, QObject **ret_data)

 {
 {

-    double d;
-    char *ptr;
+    int64_t d;

     FdMigrationState *s;
     FdMigrationState *s;

-    const char *value = qdict_get_str(qdict, "value");
-
-    d = strtod(value, &ptr);
-    switch (*ptr) {
-    case 'G': case 'g':
-        d *= 1024;
-    case 'M': case 'm':
-        d *= 1024;
-    case 'K': case 'k':
-        d *= 1024;
-    default:
-        break;
-    }

 
 

-    max_throttle = (uint32_t)d;
+    d = qdict_get_int(qdict, "value");
+    if (d < 0) {
+        d = 0;
+    }
+    max_throttle = d;

 
     s = migrate_to_fms(current_migration);
     if (s && s->file) {
         qemu_file_set_rate_limit(s->file, max_throttle);
     }
 
     s = migrate_to_fms(current_migration);
     if (s && s->file) {
         qemu_file_set_rate_limit(s->file, max_throttle);
     }

+
+    return 0;

 }
 
 /* amount of nanoseconds we are willing to wait for migration to be down.
 }
 
 /* amount of nanoseconds we are willing to wait for migration to be down.


@@ -136,47 +168,92 @@ uint64_t migrate_max_downtime(void)
     return max_downtime;
 }
 
     return max_downtime;
 }
 

-void do_migrate_set_downtime(Monitor *mon, const QDict *qdict)
+int do_migrate_set_downtime(Monitor *mon, const QDict *qdict,
+                            QObject **ret_data)

 {
 {

-    char *ptr;

     double d;
     double d;

-    const char *value = qdict_get_str(qdict, "value");
-
-    d = strtod(value, &ptr);
-    if (!strcmp(ptr,"ms")) {
-        d *= 1000000;
-    } else if (!strcmp(ptr,"us")) {
-        d *= 1000;
-    } else if (!strcmp(ptr,"ns")) {
-    } else {
-        /* all else considered to be seconds */
-        d *= 1000000000;
-    }

 
 

+    d = qdict_get_double(qdict, "value") * 1e9;
+    d = MAX(0, MIN(UINT64_MAX, d));

     max_downtime = (uint64_t)d;
     max_downtime = (uint64_t)d;

+
+    return 0;
+}
+
+static void migrate_print_status(Monitor *mon, const char *name,
+                                 const QDict *status_dict)
+{
+    QDict *qdict;
+
+    qdict = qobject_to_qdict(qdict_get(status_dict, name));
+
+    monitor_printf(mon, "transferred %s: %" PRIu64 " kbytes\n", name,
+                        qdict_get_int(qdict, "transferred") >> 10);
+    monitor_printf(mon, "remaining %s: %" PRIu64 " kbytes\n", name,
+                        qdict_get_int(qdict, "remaining") >> 10);
+    monitor_printf(mon, "total %s: %" PRIu64 " kbytes\n", name,
+                        qdict_get_int(qdict, "total") >> 10);
+}
+
+void do_info_migrate_print(Monitor *mon, const QObject *data)
+{
+    QDict *qdict;
+
+    qdict = qobject_to_qdict(data);
+
+    monitor_printf(mon, "Migration status: %s\n",
+                   qdict_get_str(qdict, "status"));
+
+    if (qdict_haskey(qdict, "ram")) {
+        migrate_print_status(mon, "ram", qdict);
+    }
+
+    if (qdict_haskey(qdict, "disk")) {
+        migrate_print_status(mon, "disk", qdict);
+    }
+}
+
+static void migrate_put_status(QDict *qdict, const char *name,
+                               uint64_t trans, uint64_t rem, uint64_t total)
+{
+    QObject *obj;
+
+    obj = qobject_from_jsonf("{ 'transferred': %" PRId64 ", "
+                               "'remaining': %" PRId64 ", "
+                               "'total': %" PRId64 " }", trans, rem, total);
+    qdict_put_obj(qdict, name, obj);

 }
 
 }
 

-void do_info_migrate(Monitor *mon)
+void do_info_migrate(Monitor *mon, QObject **ret_data)

 {
 {

+    QDict *qdict;

     MigrationState *s = current_migration;
 
     if (s) {
     MigrationState *s = current_migration;
 
     if (s) {

-        monitor_printf(mon, "Migration status: ");

         switch (s->get_status(s)) {
         case MIG_STATE_ACTIVE:
         switch (s->get_status(s)) {
         case MIG_STATE_ACTIVE:

-            monitor_printf(mon, "active\n");
-            monitor_printf(mon, "transferred ram: %" PRIu64 " kbytes\n", ram_bytes_transferred() >> 10);
-            monitor_printf(mon, "remaining ram: %" PRIu64 " kbytes\n", ram_bytes_remaining() >> 10);
-            monitor_printf(mon, "total ram: %" PRIu64 " kbytes\n", ram_bytes_total() >> 10);
+            qdict = qdict_new();
+            qdict_put(qdict, "status", qstring_from_str("active"));
+
+            migrate_put_status(qdict, "ram", ram_bytes_transferred(),
+                               ram_bytes_remaining(), ram_bytes_total());
+
+            if (blk_mig_active()) {
+                migrate_put_status(qdict, "disk", blk_mig_bytes_transferred(),
+                                   blk_mig_bytes_remaining(),
+                                   blk_mig_bytes_total());
+            }
+
+            *ret_data = QOBJECT(qdict);

             break;
         case MIG_STATE_COMPLETED:
             break;
         case MIG_STATE_COMPLETED:

-            monitor_printf(mon, "completed\n");
+            *ret_data = qobject_from_jsonf("{ 'status': 'completed' }");

             break;
         case MIG_STATE_ERROR:
             break;
         case MIG_STATE_ERROR:

-            monitor_printf(mon, "failed\n");
+            *ret_data = qobject_from_jsonf("{ 'status': 'failed' }");

             break;
         case MIG_STATE_CANCELLED:
             break;
         case MIG_STATE_CANCELLED:

-            monitor_printf(mon, "cancelled\n");
+            *ret_data = qobject_from_jsonf("{ 'status': 'cancelled' }");

             break;
         }
     }
             break;
         }
     }


@@ -184,30 +261,36 @@ void do_info_migrate(Monitor *mon)
 
 /* shared migration helpers */
 
 
 /* shared migration helpers */
 

-void migrate_fd_monitor_suspend(FdMigrationState *s)
+void migrate_fd_monitor_suspend(FdMigrationState *s, Monitor *mon)

 {
 {

-    s->mon_resume = cur_mon;
-    if (monitor_suspend(cur_mon) == 0)
-        dprintf("suspending monitor\n");
-    else
-        monitor_printf(cur_mon, "terminal does not allow synchronous "
+    s->mon = mon;
+    if (monitor_suspend(mon) == 0) {
+        DPRINTF("suspending monitor\n");
+    } else {
+        monitor_printf(mon, "terminal does not allow synchronous "

                        "migration, continuing detached\n");
                        "migration, continuing detached\n");

+    }

 }
 
 void migrate_fd_error(FdMigrationState *s)
 {
 }
 
 void migrate_fd_error(FdMigrationState *s)
 {

-    dprintf("setting error state\n");
+    DPRINTF("setting error state\n");

     s->state = MIG_STATE_ERROR;
     s->state = MIG_STATE_ERROR;

+    notifier_list_notify(&migration_state_notifiers);

     migrate_fd_cleanup(s);
 }
 
     migrate_fd_cleanup(s);
 }
 

-void migrate_fd_cleanup(FdMigrationState *s)
+int migrate_fd_cleanup(FdMigrationState *s)

 {
 {

+    int ret = 0;
+

     qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
 
     if (s->file) {
     qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
 
     if (s->file) {

-        dprintf("closing file\n");
-        qemu_fclose(s->file);
+        DPRINTF("closing file\n");
+        if (qemu_fclose(s->file) != 0) {
+            ret = -1;
+        }

         s->file = NULL;
     }
 
         s->file = NULL;
     }
 


@@ -215,10 +298,13 @@ void migrate_fd_cleanup(FdMigrationState *s)
         close(s->fd);
 
     /* Don't resume monitor until we've flushed all of the buffers */
         close(s->fd);
 
     /* Don't resume monitor until we've flushed all of the buffers */

-    if (s->mon_resume)
-        monitor_resume(s->mon_resume);
+    if (s->mon) {
+        monitor_resume(s->mon);
+    }

 
     s->fd = -1;
 
     s->fd = -1;

+
+    return ret;

 }
 
 void migrate_fd_put_notify(void *opaque)
 }
 
 void migrate_fd_put_notify(void *opaque)


@@ -241,8 +327,15 @@ ssize_t migrate_fd_put_buffer(void *opaque, const void *data, size_t size)
     if (ret == -1)
         ret = -(s->get_error(s));
 
     if (ret == -1)
         ret = -(s->get_error(s));
 

-    if (ret == -EAGAIN)
+    if (ret == -EAGAIN) {

         qemu_set_fd_handler2(s->fd, NULL, NULL, migrate_fd_put_notify, s);
         qemu_set_fd_handler2(s->fd, NULL, NULL, migrate_fd_put_notify, s);

+    } else if (ret < 0) {
+        if (s->mon) {
+            monitor_resume(s->mon);
+        }
+        s->state = MIG_STATE_ERROR;
+        notifier_list_notify(&migration_state_notifiers);
+    }

 
     return ret;
 }
 
     return ret;
 }


@@ -258,11 +351,11 @@ void migrate_fd_connect(FdMigrationState *s)
                                       migrate_fd_wait_for_unfreeze,
                                       migrate_fd_close);
 
                                       migrate_fd_wait_for_unfreeze,
                                       migrate_fd_close);
 

-    dprintf("beginning savevm\n");
-    ret = qemu_savevm_state_begin(s->file, s->mig_state.blk, 
+    DPRINTF("beginning savevm\n");
+    ret = qemu_savevm_state_begin(s->mon, s->file, s->mig_state.blk,

                                   s->mig_state.shared);
     if (ret < 0) {
                                   s->mig_state.shared);
     if (ret < 0) {

-        dprintf("failed, %d\n", ret);
+        DPRINTF("failed, %d\n", ret);

         migrate_fd_error(s);
         return;
     }
         migrate_fd_error(s);
         return;
     }


@@ -275,21 +368,19 @@ void migrate_fd_put_ready(void *opaque)
     FdMigrationState *s = opaque;
 
     if (s->state != MIG_STATE_ACTIVE) {
     FdMigrationState *s = opaque;
 
     if (s->state != MIG_STATE_ACTIVE) {

-        dprintf("put_ready returning because of non-active state\n");
+        DPRINTF("put_ready returning because of non-active state\n");

         return;
     }
 
         return;
     }
 

-    dprintf("iterate\n");
-    if (qemu_savevm_state_iterate(s->file) == 1) {
+    DPRINTF("iterate\n");
+    if (qemu_savevm_state_iterate(s->mon, s->file) == 1) {

         int state;
         int old_vm_running = vm_running;
 
         int state;
         int old_vm_running = vm_running;
 

-        dprintf("done iterating\n");
-        vm_stop(0);
+        DPRINTF("done iterating\n");
+        vm_stop(VMSTOP_MIGRATE);

 
 

-        qemu_aio_flush();
-        bdrv_flush_all();
-        if ((qemu_savevm_state_complete(s->file)) < 0) {
+        if ((qemu_savevm_state_complete(s->mon, s->file)) < 0) {

             if (old_vm_running) {
                 vm_start();
             }
             if (old_vm_running) {
                 vm_start();
             }


@@ -297,8 +388,14 @@ void migrate_fd_put_ready(void *opaque)
         } else {
             state = MIG_STATE_COMPLETED;
         }
         } else {
             state = MIG_STATE_COMPLETED;
         }

-        migrate_fd_cleanup(s);
+        if (migrate_fd_cleanup(s) < 0) {
+            if (old_vm_running) {
+                vm_start();
+            }
+            state = MIG_STATE_ERROR;
+        }

         s->state = state;
         s->state = state;

+        notifier_list_notify(&migration_state_notifiers);

     }
 }
 
     }
 }
 


@@ -315,9 +412,11 @@ void migrate_fd_cancel(MigrationState *mig_state)
     if (s->state != MIG_STATE_ACTIVE)
         return;
 
     if (s->state != MIG_STATE_ACTIVE)
         return;
 

-    dprintf("cancelling migration\n");
+    DPRINTF("cancelling migration\n");

 
     s->state = MIG_STATE_CANCELLED;
 
     s->state = MIG_STATE_CANCELLED;

+    notifier_list_notify(&migration_state_notifiers);
+    qemu_savevm_state_cancel(s->mon, s->file);

 
     migrate_fd_cleanup(s);
 }
 
     migrate_fd_cleanup(s);
 }


@@ -326,13 +425,14 @@ void migrate_fd_release(MigrationState *mig_state)
 {
     FdMigrationState *s = migrate_to_fms(mig_state);
 
 {
     FdMigrationState *s = migrate_to_fms(mig_state);
 

-    dprintf("releasing state\n");
+    DPRINTF("releasing state\n");

    
     if (s->state == MIG_STATE_ACTIVE) {
         s->state = MIG_STATE_CANCELLED;
    
     if (s->state == MIG_STATE_ACTIVE) {
         s->state = MIG_STATE_CANCELLED;

+        notifier_list_notify(&migration_state_notifiers);

         migrate_fd_cleanup(s);
     }
         migrate_fd_cleanup(s);
     }

-    free(s);
+    qemu_free(s);

 }
 
 void migrate_fd_wait_for_unfreeze(void *opaque)
 }
 
 void migrate_fd_wait_for_unfreeze(void *opaque)


@@ -340,7 +440,7 @@ void migrate_fd_wait_for_unfreeze(void *opaque)
     FdMigrationState *s = opaque;
     int ret;
 
     FdMigrationState *s = opaque;
     int ret;
 

-    dprintf("wait for unfreeze\n");
+    DPRINTF("wait for unfreeze\n");

     if (s->state != MIG_STATE_ACTIVE)
         return;
 
     if (s->state != MIG_STATE_ACTIVE)
         return;
 


@@ -361,3 +461,22 @@ int migrate_fd_close(void *opaque)
     qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
     return s->close(s);
 }
     qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
     return s->close(s);
 }

+
+void add_migration_state_change_notifier(Notifier *notify)
+{
+    notifier_list_add(&migration_state_notifiers, notify);
+}
+
+void remove_migration_state_change_notifier(Notifier *notify)
+{
+    notifier_list_remove(&migration_state_notifiers, notify);
+}
+
+int get_migration_state(void)
+{
+    if (current_migration) {
+        return migrate_fd_get_status(current_migration);
+    } else {
+        return MIG_STATE_ERROR;
+    }
+}