The following changes since commit a73549f99612f758dec0fdea6ae1c30b6c709a0b:

Merge remote-tracking branch 'remotes/kraxel/tags/ui-20181012-pull-request' into staging (2018-10-12 16:45:51 +0100)

for you to fetch changes up to a7ec0077c2db445d6bae421963188367d2695bd6:

qemu-options: Fix bad "macaddr" property in the documentation (2018-10-15 16:14:15 +0800)

Jason Wang (4):

ne2000: fix possible out of bound access in ne2000_receive

rtl8139: fix possible out of bound access

pcnet: fix possible buffer overflow

net: ignore packet size greater than INT_MAX

Martin Wilck (1):

e1000: indicate dropped packets in HW counters

Thomas Huth (1):

qemu-options: Fix bad "macaddr" property in the documentation

Zhang Chen (15):

filter-rewriter: Add TCP state machine and fix memory leak in connection_track_table

colo-compare: implement the process of checkpoint

colo-compare: use notifier to notify packets comparing result

1;5202;0c1;5202;0c COLO: integrate colo compare with colo frame

COLO: Add block replication into colo process

COLO: Remove colo_state migration struct

COLO: Load dirty pages into SVM's RAM cache firstly

ram/COLO: Record the dirty pages that SVM received

COLO: Flush memory data from ram cache

qapi/migration.json: Rename COLO unknown mode to none mode.

qapi: Add new command to query colo status

savevm: split the process of different stages for loadvm/savevm

filter: Add handle_event method for NetFilterClass

filter-rewriter: handle checkpoint and failover event

docs: Add COLO status diagram to COLO-FT.txt

liujunjie (1):

clean up callback when del virtqueue

zhanghailiang (4):

qmp event: Add COLO_EXIT event to notify users while exited COLO

COLO: flush host dirty ram from cache

COLO: notify net filters about checkpoint/failover event

COLO: quick failover process by kick COLO thread

docs/COLO-FT.txt | 34 ++++++++

hw/net/e1000.c | 16 +++-

hw/net/ne2000.c | 4 +-

hw/net/pcnet.c | 4 +-

hw/net/rtl8139.c | 8 +-

hw/net/trace-events | 3 +

hw/virtio/virtio.c | 2 +

include/exec/ram_addr.h | 1 +

include/migration/colo.h | 11 ++-

include/net/filter.h | 5 ++

migration/Makefile.objs | 2 +-

migration/colo-comm.c | 76 -----------------

migration/colo-failover.c | 2 +-

migration/colo.c | 212 +++++++++++++++++++++++++++++++++++++++++++---

migration/migration.c | 46 ++++++++--

migration/ram.c | 166 +++++++++++++++++++++++++++++++++++-

migration/ram.h | 4 +

migration/savevm.c | 53 ++++++++++--

migration/savevm.h | 5 ++

migration/trace-events | 3 +

net/colo-compare.c | 115 ++++++++++++++++++++++---

net/colo-compare.h | 24 ++++++

net/colo.c | 10 ++-

net/colo.h | 11 +--

net/filter-rewriter.c | 166 +++++++++++++++++++++++++++++++++---

net/filter.c | 17 ++++

net/net.c | 26 +++++-

qapi/migration.json | 80 +++++++++++++++--

qemu-options.hx | 2 +-

vl.c | 2 -

30 files changed, 958 insertions(+), 152 deletions(-)

delete mode 100644 migration/colo-comm.c

create mode 100644 net/colo-compare.h

From: Thomas Huth <thuth@redhat.com>

When using the "-device" option, the property is called "mac".

"macaddr" is only used for the legacy "-net nic" option.

Reported-by: Harald Hoyer <harald@redhat.com>

Reviewed-by: Markus Armbruster <armbru@redhat.com>

Signed-off-by: Thomas Huth <thuth@redhat.com>

qemu-options.hx | 2 +-

1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qemu-options.hx b/qemu-options.hx

--- a/qemu-options.hx

+++ b/qemu-options.hx

@@ -XXX,XX +XXX,XX @@ qemu-system-i386 linux.img \

-netdev socket,id=n2,mcast=230.0.0.1:1234

# launch yet another QEMU instance on same "bus"

qemu-system-i386 linux.img \

- -device e1000,netdev=n3,macaddr=52:54:00:12:34:58 \

+ -device e1000,netdev=n3,mac=52:54:00:12:34:58 \

-netdev socket,id=n3,mcast=230.0.0.1:1234

@end example

2.5.0

From: Zhang Chen <zhangckid@gmail.com>

While do checkpoint, we need to flush all the unhandled packets,

By using the filter notifier mechanism, we can easily to notify

every compare object to do this process, which runs inside

of compare threads as a coroutine.

Signed-off-by: zhanghailiang <zhang.zhanghailiang@huawei.com>

Signed-off-by: Zhang Chen <zhangckid@gmail.com>

Signed-off-by: Zhang Chen <chen.zhang@intel.com>

include/migration/colo.h | 6 ++++

net/colo-compare.c | 78 ++++++++++++++++++++++++++++++++++++++++++++++++

net/colo-compare.h | 22 ++++++++++++++

3 files changed, 106 insertions(+)

create mode 100644 net/colo-compare.h

diff --git a/include/migration/colo.h b/include/migration/colo.h

--- a/include/migration/colo.h

+++ b/include/migration/colo.h

@@ -XXX,XX +XXX,XX @@

#include "qemu-common.h"

#include "qapi/qapi-types-migration.h"

+enum colo_event {

+ COLO_EVENT_NONE,

+ COLO_EVENT_CHECKPOINT,

+ COLO_EVENT_FAILOVER,

+};

+

void colo_info_init(void);

void migrate_start_colo_process(MigrationState *s);

diff --git a/net/colo-compare.c b/net/colo-compare.c

index XXXXXXX..XXXXXXX 100644

--- a/net/colo-compare.c

+++ b/net/colo-compare.c

@@ -XXX,XX +XXX,XX @@

#include "qemu/sockets.h"

#include "colo.h"

#include "sysemu/iothread.h"

+#include "net/colo-compare.h"

+#include "migration/colo.h"

#define TYPE_COLO_COMPARE "colo-compare"

#define COLO_COMPARE(obj) \

OBJECT_CHECK(CompareState, (obj), TYPE_COLO_COMPARE)

+static QTAILQ_HEAD(, CompareState) net_compares =

+ QTAILQ_HEAD_INITIALIZER(net_compares);

+

#define COMPARE_READ_LEN_MAX NET_BUFSIZE

#define MAX_QUEUE_SIZE 1024

@@ -XXX,XX +XXX,XX @@

/* TODO: Should be configurable */

#define REGULAR_PACKET_CHECK_MS 3000

+static QemuMutex event_mtx;

+static QemuCond event_complete_cond;

+static int event_unhandled_count;

+

/*

* + CompareState ++

* | |

@@ -XXX,XX +XXX,XX @@ typedef struct CompareState {

IOThread *iothread;

GMainContext *worker_context;

QEMUTimer *packet_check_timer;

+

+ QEMUBH *event_bh;

+ enum colo_event event;

+

+ QTAILQ_ENTRY(CompareState) next;

} CompareState;

typedef struct CompareClass {

@@ -XXX,XX +XXX,XX @@ static void check_old_packet_regular(void *opaque)

REGULAR_PACKET_CHECK_MS);

}

+/* Public API, Used for COLO frame to notify compare event */

+void colo_notify_compares_event(void *opaque, int event, Error **errp)

+{

+ CompareState *s;

+

+ qemu_mutex_lock(&event_mtx);

+ QTAILQ_FOREACH(s, &net_compares, next) {

+ s->event = event;

+ qemu_bh_schedule(s->event_bh);

+ event_unhandled_count++;

+ }

+ /* Wait all compare threads to finish handling this event */

+ while (event_unhandled_count > 0) {

+ qemu_cond_wait(&event_complete_cond, &event_mtx);

+ }

+

+ qemu_mutex_unlock(&event_mtx);

+}

+

static void colo_compare_timer_init(CompareState *s)

{

AioContext *ctx = iothread_get_aio_context(s->iothread);

@@ -XXX,XX +XXX,XX @@ static void colo_compare_timer_del(CompareState *s)

}

}

+static void colo_flush_packets(void *opaque, void *user_data);

+

+static void colo_compare_handle_event(void *opaque)

+{

+ CompareState *s = opaque;

+

+ switch (s->event) {

+ case COLO_EVENT_CHECKPOINT:

+ g_queue_foreach(&s->conn_list, colo_flush_packets, s);

+ break;

+ case COLO_EVENT_FAILOVER:

+ break;

+ default:

+ break;

+ }

+

+ assert(event_unhandled_count > 0);

+

+ qemu_mutex_lock(&event_mtx);

+ event_unhandled_count--;

+ qemu_cond_broadcast(&event_complete_cond);

+ qemu_mutex_unlock(&event_mtx);

+}

+

static void colo_compare_iothread(CompareState *s)

{

object_ref(OBJECT(s->iothread));

@@ -XXX,XX +XXX,XX @@ static void colo_compare_iothread(CompareState *s)

s, s->worker_context, true);

colo_compare_timer_init(s);

+ s->event_bh = qemu_bh_new(colo_compare_handle_event, s);

}

static char *compare_get_pri_indev(Object *obj, Error **errp)

@@ -XXX,XX +XXX,XX @@ static void colo_compare_complete(UserCreatable *uc, Error **errp)

net_socket_rs_init(&s->pri_rs, compare_pri_rs_finalize, s->vnet_hdr);

net_socket_rs_init(&s->sec_rs, compare_sec_rs_finalize, s->vnet_hdr);

+ QTAILQ_INSERT_TAIL(&net_compares, s, next);

+

g_queue_init(&s->conn_list);

+ qemu_mutex_init(&event_mtx);

+ qemu_cond_init(&event_complete_cond);

+

s->connection_track_table = g_hash_table_new_full(connection_key_hash,

connection_key_equal,

g_free,

@@ -XXX,XX +XXX,XX @@ static void colo_compare_init(Object *obj)

static void colo_compare_finalize(Object *obj)

{

CompareState *s = COLO_COMPARE(obj);

+ CompareState *tmp = NULL;

qemu_chr_fe_deinit(&s->chr_pri_in, false);

qemu_chr_fe_deinit(&s->chr_sec_in, false);

@@ -XXX,XX +XXX,XX @@ static void colo_compare_finalize(Object *obj)

if (s->iothread) {

colo_compare_timer_del(s);

}

+

+ qemu_bh_delete(s->event_bh);

+

+ QTAILQ_FOREACH(tmp, &net_compares, next) {

+ if (tmp == s) {

+ QTAILQ_REMOVE(&net_compares, s, next);

+ break;

+ }

+ }

+

/* Release all unhandled packets after compare thead exited */

g_queue_foreach(&s->conn_list, colo_flush_packets, s);

@@ -XXX,XX +XXX,XX @@ static void colo_compare_finalize(Object *obj)

if (s->iothread) {

object_unref(OBJECT(s->iothread));

}

+

+ qemu_mutex_destroy(&event_mtx);

+ qemu_cond_destroy(&event_complete_cond);

+

g_free(s->pri_indev);

g_free(s->sec_indev);

g_free(s->outdev);

diff --git a/net/colo-compare.h b/net/colo-compare.h

+++ b/net/colo-compare.h

+ * COarse-grain LOck-stepping Virtual Machines for Non-stop Service (COLO)

+ * (a.k.a. Fault Tolerance or Continuous Replication)

+ * Copyright (c) 2017 HUAWEI TECHNOLOGIES CO., LTD.

+ * Copyright (c) 2017 FUJITSU LIMITED

+ * Copyright (c) 2017 Intel Corporation

+ * Authors:

+ * zhanghailiang <zhang.zhanghailiang@huawei.com>

+ * Zhang Chen <zhangckid@gmail.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.

+#ifndef QEMU_COLO_COMPARE_H

+#define QEMU_COLO_COMPARE_H

+void colo_notify_compares_event(void *opaque, int event, Error **errp);

+#endif /* QEMU_COLO_COMPARE_H */

2.5.0

From: Zhang Chen <zhangckid@gmail.com>

For COLO FT, both the PVM and SVM run at the same time,

only sync the state while it needs.

So here, let SVM runs while not doing checkpoint, change

DEFAULT_MIGRATE_X_CHECKPOINT_DELAY to 200*100.

Besides, we forgot to release colo_checkpoint_semd and

colo_delay_timer, fix them here.

Signed-off-by: zhanghailiang <zhang.zhanghailiang@huawei.com>

Signed-off-by: Zhang Chen <zhangckid@gmail.com>

Signed-off-by: Zhang Chen <chen.zhang@intel.com>

Reviewed-by: Dr. David Alan Gilbert <dgilbert@redhat.com>

migration/colo.c | 42 ++++++++++++++++++++++++++++++++++++++++--

migration/migration.c | 6 ++----

2 files changed, 42 insertions(+), 6 deletions(-)

diff --git a/migration/colo.c b/migration/colo.c

--- a/migration/colo.c

+++ b/migration/colo.c

#include "migration/failover.h"

#include "replication.h"

+#include "net/colo-compare.h"

+#include "net/colo.h"

static bool vmstate_loading;

+static Notifier packets_compare_notifier;

#define COLO_BUFFER_BASE_SIZE (4 * 1024 * 1024)

@@ -XXX,XX +XXX,XX @@ static int colo_do_checkpoint_transaction(MigrationState *s,

goto out;

+ colo_notify_compares_event(NULL, COLO_EVENT_CHECKPOINT, &local_err);

+ if (local_err) {

+ goto out;

+ }

+

/* Disable block migration */

migrate_set_block_enabled(false, &local_err);

qemu_savevm_state_header(fb);

@@ -XXX,XX +XXX,XX @@ out:

+static void colo_compare_notify_checkpoint(Notifier *notifier, void *data)

+{

+ colo_checkpoint_notify(data);

+}

+

static void colo_process_checkpoint(MigrationState *s)

{

QIOChannelBuffer *bioc;

@@ -XXX,XX +XXX,XX @@ static void colo_process_checkpoint(MigrationState *s)

goto out;

}

+ packets_compare_notifier.notify = colo_compare_notify_checkpoint;

+ colo_compare_register_notifier(&packets_compare_notifier);

+

/*

* Wait for Secondary finish loading VM states and enter COLO

* restore.

@@ -XXX,XX +XXX,XX @@ out:

qemu_fclose(fb);

}

- timer_del(s->colo_delay_timer);

-

/* Hope this not to be too long to wait here */

qemu_sem_wait(&s->colo_exit_sem);

qemu_sem_destroy(&s->colo_exit_sem);

+

+ /*

+ * It is safe to unregister notifier after failover finished.

+ * Besides, colo_delay_timer and colo_checkpoint_sem can't be

+ * released befor unregister notifier, or there will be use-after-free

+ * error.

+ */

+ colo_compare_unregister_notifier(&packets_compare_notifier);

+ timer_del(s->colo_delay_timer);

+ timer_free(s->colo_delay_timer);

+ qemu_sem_destroy(&s->colo_checkpoint_sem);

+

/*

* Must be called after failover BH is completed,

* Or the failover BH may shutdown the wrong fd that

@@ -XXX,XX +XXX,XX @@ void *colo_process_incoming_thread(void *opaque)

fb = qemu_fopen_channel_input(QIO_CHANNEL(bioc));

object_unref(OBJECT(bioc));

+ qemu_mutex_lock_iothread();

+ vm_start();

+ trace_colo_vm_state_change("stop", "run");

+ qemu_mutex_unlock_iothread();

+

colo_send_message(mis->to_src_file, COLO_MESSAGE_CHECKPOINT_READY,

&local_err);

if (local_err) {

@@ -XXX,XX +XXX,XX @@ void *colo_process_incoming_thread(void *opaque)

goto out;

}

+ qemu_mutex_lock_iothread();

+ vm_stop_force_state(RUN_STATE_COLO);

+ trace_colo_vm_state_change("run", "stop");

+ qemu_mutex_unlock_iothread();

+

/* FIXME: This is unnecessary for periodic checkpoint mode */

colo_send_message(mis->to_src_file, COLO_MESSAGE_CHECKPOINT_REPLY,

&local_err);

@@ -XXX,XX +XXX,XX @@ void *colo_process_incoming_thread(void *opaque)

}

vmstate_loading = false;

+ vm_start();

+ trace_colo_vm_state_change("stop", "run");

qemu_mutex_unlock_iothread();

if (failover_get_state() == FAILOVER_STATUS_RELAUNCH) {

diff --git a/migration/migration.c b/migration/migration.c

--- a/migration/migration.c

+++ b/migration/migration.c

/* Migration XBZRLE default cache size */

#define DEFAULT_MIGRATE_XBZRLE_CACHE_SIZE (64 * 1024 * 1024)

-/* The delay time (in ms) between two COLO checkpoints

- * Note: Please change this default value to 10000 when we support hybrid mode.

- */

-#define DEFAULT_MIGRATE_X_CHECKPOINT_DELAY 200

+/* The delay time (in ms) between two COLO checkpoints */

+#define DEFAULT_MIGRATE_X_CHECKPOINT_DELAY (200 * 100)

#define DEFAULT_MIGRATE_MULTIFD_CHANNELS 2

#define DEFAULT_MIGRATE_MULTIFD_PAGE_COUNT 16

2.5.0

From: Zhang Chen <zhangckid@gmail.com>

We need to know if migration is going into COLO state for

incoming side before start normal migration.

Instead by using the VMStateDescription to send colo_state

from source side to destination side, we use MIG_CMD_ENABLE_COLO

to indicate whether COLO is enabled or not.

Signed-off-by: zhanghailiang <zhang.zhanghailiang@huawei.com>

Signed-off-by: Zhang Chen <zhangckid@gmail.com>

Signed-off-by: Zhang Chen <chen.zhang@intel.com>

Reviewed-by: Dr. David Alan Gilbert <dgilbert@redhat.com>

include/migration/colo.h | 5 ++--

migration/Makefile.objs | 2 +-

migration/colo-comm.c | 76 ------------------------------------------------

migration/colo.c | 13 ++++++++-

migration/migration.c | 23 ++++++++++++++-

migration/savevm.c | 17 +++++++++++

migration/savevm.h | 1 +

migration/trace-events | 1 +

vl.c | 2 --

9 files changed, 57 insertions(+), 83 deletions(-)

delete mode 100644 migration/colo-comm.c

diff --git a/include/migration/colo.h b/include/migration/colo.h

--- a/include/migration/colo.h

+++ b/include/migration/colo.h

@@ -XXX,XX +XXX,XX @@ void migrate_start_colo_process(MigrationState *s);

bool migration_in_colo_state(void);

/* loadvm */

-bool migration_incoming_enable_colo(void);

-void migration_incoming_exit_colo(void);

+void migration_incoming_enable_colo(void);

+void migration_incoming_disable_colo(void);

+bool migration_incoming_colo_enabled(void);

void *colo_process_incoming_thread(void *opaque);

bool migration_incoming_in_colo_state(void);

diff --git a/migration/Makefile.objs b/migration/Makefile.objs

index XXXXXXX..XXXXXXX 100644

--- a/migration/Makefile.objs

+++ b/migration/Makefile.objs

@@ -XXX,XX +XXX,XX @@

common-obj-y += migration.o socket.o fd.o exec.o

common-obj-y += tls.o channel.o savevm.o

-common-obj-y += colo-comm.o colo.o colo-failover.o

+common-obj-y += colo.o colo-failover.o

common-obj-y += vmstate.o vmstate-types.o page_cache.o

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

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

diff --git a/migration/colo-comm.c b/migration/colo-comm.c

deleted file mode 100644

index XXXXXXX..XXXXXXX

--- a/migration/colo-comm.c

+++ /dev/null

@@ -XXX,XX +XXX,XX @@

-/*

- * COarse-grain LOck-stepping Virtual Machines for Non-stop Service (COLO)

- * (a.k.a. Fault Tolerance or Continuous Replication)

- *

- * Copyright (c) 2016 HUAWEI TECHNOLOGIES CO., LTD.

- * Copyright (c) 2016 FUJITSU LIMITED

- * Copyright (c) 2016 Intel Corporation

- *

- * 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 "qemu/osdep.h"

-#include "migration.h"

-#include "migration/colo.h"

-#include "migration/vmstate.h"

-#include "trace.h"

-

-typedef struct {

- bool colo_requested;

-} COLOInfo;

-

-static COLOInfo colo_info;

-

-COLOMode get_colo_mode(void)

-{

- if (migration_in_colo_state()) {

- return COLO_MODE_PRIMARY;

- } else if (migration_incoming_in_colo_state()) {

- return COLO_MODE_SECONDARY;

- } else {

- return COLO_MODE_UNKNOWN;

- }

-}

-

-static int colo_info_pre_save(void *opaque)

-{

- COLOInfo *s = opaque;

-

- s->colo_requested = migrate_colo_enabled();

-

- return 0;

-}

-

-static bool colo_info_need(void *opaque)

-{

- return migrate_colo_enabled();

-}

-

-static const VMStateDescription colo_state = {

- .name = "COLOState",

- .version_id = 1,

- .minimum_version_id = 1,

- .pre_save = colo_info_pre_save,

- .needed = colo_info_need,

- .fields = (VMStateField[]) {

- VMSTATE_BOOL(colo_requested, COLOInfo),

- VMSTATE_END_OF_LIST()

- },

-};

-

-void colo_info_init(void)

-{

- vmstate_register(NULL, 0, &colo_state, &colo_info);

-}

-

-bool migration_incoming_enable_colo(void)

-{

- return colo_info.colo_requested;

-}

-

-void migration_incoming_exit_colo(void)

-{

- colo_info.colo_requested = false;

-}

diff --git a/migration/colo.c b/migration/colo.c

index XXXXXXX..XXXXXXX 100644

--- a/migration/colo.c

+++ b/migration/colo.c

@@ -XXX,XX +XXX,XX @@ static void primary_vm_do_failover(void)

qemu_sem_post(&s->colo_exit_sem);

+COLOMode get_colo_mode(void)

+ if (migration_in_colo_state()) {

+ return COLO_MODE_PRIMARY;

+ } else if (migration_incoming_in_colo_state()) {

+ return COLO_MODE_SECONDARY;

+ return COLO_MODE_UNKNOWN;

void colo_do_failover(MigrationState *s)

{

/* Make sure VM stopped while failover happened. */

@@ -XXX,XX +XXX,XX @@ out:

if (mis->to_src_file) {

qemu_fclose(mis->to_src_file);

- migration_incoming_exit_colo();

+ migration_incoming_disable_colo();

rcu_unregister_thread();

return NULL;

diff --git a/migration/migration.c b/migration/migration.c

--- a/migration/migration.c

+++ b/migration/migration.c

@@ -XXX,XX +XXX,XX @@ int migrate_send_rp_req_pages(MigrationIncomingState *mis, const char *rbname,

return migrate_send_rp_message(mis, msg_type, msglen, bufc);

+static bool migration_colo_enabled;

+bool migration_incoming_colo_enabled(void)

+ return migration_colo_enabled;

+void migration_incoming_disable_colo(void)

+{

+ migration_colo_enabled = false;

+}

+

+void migration_incoming_enable_colo(void)

+{

+ migration_colo_enabled = true;

+}

+

void qemu_start_incoming_migration(const char *uri, Error **errp)

{

const char *p;

@@ -XXX,XX +XXX,XX @@ static void process_incoming_migration_co(void *opaque)

}

/* we get COLO info, and know if we are in COLO mode */

- if (!ret && migration_incoming_enable_colo()) {

+ if (!ret && migration_incoming_colo_enabled()) {

/* Make sure all file formats flush their mutable metadata */

bdrv_invalidate_cache_all(&local_err);

if (local_err) {

@@ -XXX,XX +XXX,XX @@ static void *migration_thread(void *opaque)

qemu_savevm_send_postcopy_advise(s->to_dst_file);

}

+ if (migrate_colo_enabled()) {

+ /* Notify migration destination that we enable COLO */

+ qemu_savevm_send_colo_enable(s->to_dst_file);

qemu_savevm_state_setup(s->to_dst_file);

s->setup_time = qemu_clock_get_ms(QEMU_CLOCK_HOST) - setup_start;

diff --git a/migration/savevm.c b/migration/savevm.c

index XXXXXXX..XXXXXXX 100644

--- a/migration/savevm.c

+++ b/migration/savevm.c

@@ -XXX,XX +XXX,XX @@

#include "io/channel-file.h"

#include "sysemu/replay.h"

#include "qjson.h"

+#include "migration/colo.h"

#ifndef ETH_P_RARP

#define ETH_P_RARP 0x8035

@@ -XXX,XX +XXX,XX @@ enum qemu_vm_cmd {

were previously sent during

precopy but are dirty. */

MIG_CMD_PACKAGED, /* Send a wrapped stream within this stream */

+ MIG_CMD_ENABLE_COLO, /* Enable COLO */

MIG_CMD_POSTCOPY_RESUME, /* resume postcopy on dest */

MIG_CMD_RECV_BITMAP, /* Request for recved bitmap on dst */

MIG_CMD_MAX

@@ -XXX,XX +XXX,XX @@ static void qemu_savevm_command_send(QEMUFile *f,

qemu_fflush(f);

+void qemu_savevm_send_colo_enable(QEMUFile *f)

+{

+ trace_savevm_send_colo_enable();

+ qemu_savevm_command_send(f, MIG_CMD_ENABLE_COLO, 0, NULL);

+}

+

void qemu_savevm_send_ping(QEMUFile *f, uint32_t value)

{

uint32_t buf;

@@ -XXX,XX +XXX,XX @@ static int loadvm_handle_recv_bitmap(MigrationIncomingState *mis,

return 0;

}

+static int loadvm_process_enable_colo(MigrationIncomingState *mis)

+{

+ migration_incoming_enable_colo();

+ return 0;

+}

+

/*

* Process an incoming 'QEMU_VM_COMMAND'

* 0 just a normal return

@@ -XXX,XX +XXX,XX @@ static int loadvm_process_command(QEMUFile *f)

case MIG_CMD_RECV_BITMAP:

return loadvm_handle_recv_bitmap(mis, len);

+

+ case MIG_CMD_ENABLE_COLO:

+ return loadvm_process_enable_colo(mis);

}

return 0;

diff --git a/migration/savevm.h b/migration/savevm.h

index XXXXXXX..XXXXXXX 100644

--- a/migration/savevm.h

+++ b/migration/savevm.h

@@ -XXX,XX +XXX,XX @@ void qemu_savevm_send_postcopy_ram_discard(QEMUFile *f, const char *name,

uint16_t len,

uint64_t *start_list,

uint64_t *length_list);

+void qemu_savevm_send_colo_enable(QEMUFile *f);

int qemu_loadvm_state(QEMUFile *f);

void qemu_loadvm_state_cleanup(void);

diff --git a/migration/trace-events b/migration/trace-events

index XXXXXXX..XXXXXXX 100644

--- a/migration/trace-events

+++ b/migration/trace-events

@@ -XXX,XX +XXX,XX @@ savevm_send_ping(uint32_t val) "0x%x"

savevm_send_postcopy_listen(void) ""

savevm_send_postcopy_run(void) ""

savevm_send_postcopy_resume(void) ""

+savevm_send_colo_enable(void) ""

savevm_send_recv_bitmap(char *name) "%s"

savevm_state_setup(void) ""

savevm_state_resume_prepare(void) ""

diff --git a/vl.c b/vl.c

index XXXXXXX..XXXXXXX 100644

--- a/vl.c

+++ b/vl.c

@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv, char **envp)

#endif

}

- colo_info_init();

-

if (net_init_clients(&err) < 0) {

error_report_err(err);

exit(1);

2.5.0

From: Zhang Chen <zhangckid@gmail.com>

We add almost full TCP state machine in filter-rewriter, except

TCPS_LISTEN and some simplify in VM active close FIN states.

The reason for this simplify job is because guest kernel will track

the TCP status and wait 2MSL time too, if client resend the FIN packet,

guest will resend the last ACK, so we needn't wait 2MSL time in filter-rewriter.

After a net connection is closed, we didn't clear its related resources

in connection_track_table, which will lead to memory leak.

Let's track the state of net connection, if it is closed, its related

resources will be cleared up.

Signed-off-by: zhanghailiang <zhang.zhanghailiang@huawei.com>

Signed-off-by: Zhang Chen <zhangckid@gmail.com>

Signed-off-by: Zhang Chen <chen.zhang@intel.com>

net/colo.c | 2 +-

net/colo.h | 9 ++---

net/filter-rewriter.c | 109 +++++++++++++++++++++++++++++++++++++++++++++-----

3 files changed, 104 insertions(+), 16 deletions(-)

diff --git a/net/colo.c b/net/colo.c

--- a/net/colo.c

+++ b/net/colo.c

@@ -XXX,XX +XXX,XX @@ Connection *connection_new(ConnectionKey *key)

conn->ip_proto = key->ip_proto;

conn->processing = false;

conn->offset = 0;

- conn->syn_flag = 0;

+ conn->tcp_state = TCPS_CLOSED;

conn->pack = 0;

conn->sack = 0;

g_queue_init(&conn->primary_list);

diff --git a/net/colo.h b/net/colo.h

index XXXXXXX..XXXXXXX 100644