The following changes since commit 7d0e02405fc02a181319b1ab8681d2f72246b7c6:

Merge remote-tracking branch 'remotes/vivier2/tags/trivial-patches-pull-request' into staging (2019-07-01 17:40:32 +0100)

for you to fetch changes up to 0e8818f023616677416840d6ddc880db8de3c967:

migration/colo.c: Add missed filter notify for Xen COLO. (2019-07-02 10:21:07 +0800)

Cédric Le Goater (1):

ftgmac100: do not link to netdev

Dr. David Alan Gilbert (5):

net/announce: Allow optional list of interfaces

net/announce: Add HMP optional interface list

net/announce: Add optional ID

net/announce: Add HMP optional ID

net/announce: Expand test for stopping self announce

Markus Armbruster (2):

MAINTAINERS: Add qemu-bridge-helper.c to "Network device backends"

qemu-bridge-helper: Document known shortcomings

Stefano Garzarella (4):

net: fix assertion failure when ipv6-prefixlen is not a number

net: avoid using variable length array in net_client_init()

net: use g_strsplit() for parsing host address and port

net: remove unused get_str_sep() function

Zhang Chen (5):

COLO-compare: Add new parameter to communicate with remote colo-frame

COLO-compare: Add remote notification chardev handler frame

COLO-compare: Make the compare_chr_send() can send notification message.

COLO-compare: Add colo-compare remote notify support

migration/colo.c: Add missed filter notify for Xen COLO.

MAINTAINERS | 1 +

hmp-commands.hx | 7 ++-

hw/net/ftgmac100.c | 2 -

hw/net/virtio-net.c | 4 +-

include/net/announce.h | 8 ++-

migration/colo.c | 2 +

monitor/hmp-cmds.c | 41 ++++++++++++-

net/announce.c | 89 +++++++++++++++++++++++----

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

net/net.c | 99 +++++++++++++++----------------

net/trace-events | 3 +-

qapi/net.json | 16 ++++-

qemu-bridge-helper.c | 12 +++-

qemu-options.hx | 33 ++++++++++-

tests/virtio-net-test.c | 57 +++++++++++++++++-

15 files changed, 430 insertions(+), 99 deletions(-)

From: Stefano Garzarella <sgarzare@redhat.com>

net_client_init() uses a variable length array to store the prefix

of 'ipv6-net' parameter (e.g. if ipv6-net=fec0::0/64, the prefix

is 'fec0::0').

This patch introduces g_strsplit() to split the 'ipv6-net' parameter,

so we can remove the variable length array.

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

Signed-off-by: Stefano Garzarella <sgarzare@redhat.com>

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

net/net.c | 31 +++++++++++++++++++------------

1 file changed, 19 insertions(+), 12 deletions(-)

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

static int net_client_init(QemuOpts *opts, bool is_netdev, Error **errp)

+ gchar **substrings = NULL;

void *object = NULL;

Error *err = NULL;

int ret = -1;

@@ -XXX,XX +XXX,XX @@ static int net_client_init(QemuOpts *opts, bool is_netdev, Error **errp)

const char *ip6_net = qemu_opt_get(opts, "ipv6-net");

if (ip6_net) {

- char buf[strlen(ip6_net) + 1];

+ char *prefix_addr;

+ unsigned long prefix_len = 64; /* Default 64bit prefix length. */

+

+ substrings = g_strsplit(ip6_net, "/", 2);

+ if (!substrings || !substrings[0]) {

+ error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "ipv6-net",

+ "a valid IPv6 prefix");

+ goto out;

+ }

- if (get_str_sep(buf, sizeof(buf), &ip6_net, '/') < 0) {

- /* Default 64bit prefix length. */

- qemu_opt_set(opts, "ipv6-prefix", ip6_net, &error_abort);

- qemu_opt_set_number(opts, "ipv6-prefixlen", 64, &error_abort);

- } else {

+ prefix_addr = substrings[0];

+

+ if (substrings[1]) {

/* User-specified prefix length. */

- unsigned long len;

int err;

- qemu_opt_set(opts, "ipv6-prefix", buf, &error_abort);

- err = qemu_strtoul(ip6_net, NULL, 10, &len);

-

+ err = qemu_strtoul(substrings[1], NULL, 10, &prefix_len);

if (err) {

error_setg(errp, QERR_INVALID_PARAMETER_VALUE,

"ipv6-prefixlen", "a number");

goto out;

}

-

- qemu_opt_set_number(opts, "ipv6-prefixlen", len, &error_abort);

}

+

+ qemu_opt_set(opts, "ipv6-prefix", prefix_addr, &error_abort);

+ qemu_opt_set_number(opts, "ipv6-prefixlen", prefix_len,

+ &error_abort);

qemu_opt_unset(opts, "ipv6-net");

}

}

@@ -XXX,XX +XXX,XX @@ static int net_client_init(QemuOpts *opts, bool is_netdev, Error **errp)

out:

error_propagate(errp, err);

+ g_strfreev(substrings);

visit_free(v);

return ret;

}

2.5.0

From: Stefano Garzarella <sgarzare@redhat.com>

Since the get_str_sep() function is no longer used in

net/net.c, we can remove it.

Signed-off-by: Stefano Garzarella <sgarzare@redhat.com>

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

net/net.c | 20 --------------------

1 file changed, 20 deletions(-)

@@ -XXX,XX +XXX,XX @@ static QTAILQ_HEAD(, NetClientState) net_clients;

/***********************************************************/

/* network device redirectors */

-static int get_str_sep(char *buf, int buf_size, const char **pp, int sep)

-{

- const char *p, *p1;

- int len;

- p = *pp;

- p1 = strchr(p, sep);

- if (!p1)

- return -1;

- len = p1 - p;

- p1++;

- if (buf_size > 0) {

- if (len > buf_size - 1)

- len = buf_size - 1;

- memcpy(buf, p, len);

- buf[len] = '\0';

- }

- *pp = p1;

- return 0;

-}

-

int parse_host_port(struct sockaddr_in *saddr, const char *str,

Error **errp)

{

2.5.0

From: Stefano Garzarella <sgarzare@redhat.com>

If 'ipv6-prefixlen' is not a number, the current behaviour

produces an assertion failure:

$ qemu-system-x86_64 -net user,ipv6-net=feca::0/a

qemu-system-x86_64: qemu/util/qemu-option.c:1175: qemu_opts_foreach:

Assertion `!errp || !*errp' failed.

Aborted (core dumped)

This patch fixes it, jumping to the end of the function when

'ipv6-prefixlen' is not a number, and printing the more friendly

message:

$ qemu-system-x86_64 -net user,ipv6-net=feca::0/a

qemu-system-x86_64: Parameter 'ipv6-prefixlen' expects a number

Signed-off-by: Stefano Garzarella <sgarzare@redhat.com>

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

net/net.c | 9 +++++----

1 file changed, 5 insertions(+), 4 deletions(-)

@@ -XXX,XX +XXX,XX @@ static int net_client_init(QemuOpts *opts, bool is_netdev, Error **errp)

if (err) {

error_setg(errp, QERR_INVALID_PARAMETER_VALUE,

- "ipv6-prefix", "a number");

- } else {

- qemu_opt_set_number(opts, "ipv6-prefixlen", len,

- &error_abort);

+ "ipv6-prefixlen", "a number");

+ goto out;

}

+

+ qemu_opt_set_number(opts, "ipv6-prefixlen", len, &error_abort);

}

qemu_opt_unset(opts, "ipv6-net");

}

@@ -XXX,XX +XXX,XX @@ static int net_client_init(QemuOpts *opts, bool is_netdev, Error **errp)

qapi_free_NetLegacy(object);

+out:

error_propagate(errp, err);

visit_free(v);

return ret;

2.5.0

From: Zhang Chen <chen.zhang@intel.com>

This patch make colo-compare can send message to remote COLO frame(Xen) when occur checkpoint.

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

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

1 file changed, 44 insertions(+), 10 deletions(-)

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

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

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

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

SECONDARY_IN,

};

-static void colo_compare_inconsistency_notify(void)

-{

- notifier_list_notify(&colo_compare_notifiers,

- migrate_get_current());

-}

static int compare_chr_send(CompareState *s,

const uint8_t *buf,

@@ -XXX,XX +XXX,XX @@ static int compare_chr_send(CompareState *s,

uint32_t vnet_hdr_len,

bool notify_remote_frame);

+static void notify_remote_frame(CompareState *s)

+{

+ char msg[] = "DO_CHECKPOINT";

+ int ret = 0;

+

+ ret = compare_chr_send(s, (uint8_t *)msg, strlen(msg), 0, true);

+ if (ret < 0) {

+ error_report("Notify Xen COLO-frame failed");

+ }

+}

+

+static void colo_compare_inconsistency_notify(CompareState *s)

+{

+ if (s->notify_dev) {

+ notify_remote_frame(s);

+ } else {

+ notifier_list_notify(&colo_compare_notifiers,

+ migrate_get_current());

+ }

+}

+

static gint seq_sorter(Packet *a, Packet *b, gpointer data)

{

struct tcp_hdr *atcp, *btcp;

@@ -XXX,XX +XXX,XX @@ sec:

qemu_hexdump((char *)spkt->data, stderr,

"colo-compare spkt", spkt->size);

- colo_compare_inconsistency_notify();

+ colo_compare_inconsistency_notify(s);

@@ -XXX,XX +XXX,XX @@ void colo_compare_unregister_notifier(Notifier *notify)

static int colo_old_packet_check_one_conn(Connection *conn,

- void *user_data)

+ CompareState *s)

{

GList *result = NULL;

int64_t check_time = REGULAR_PACKET_CHECK_MS;

@@ -XXX,XX +XXX,XX @@ static int colo_old_packet_check_one_conn(Connection *conn,

if (result) {

/* Do checkpoint will flush old packet */

- colo_compare_inconsistency_notify();

+ colo_compare_inconsistency_notify(s);

return 0;

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

* If we find one old packet, stop finding job and notify

* COLO frame do checkpoint.

*/

- g_queue_find_custom(&s->conn_list, NULL,

+ g_queue_find_custom(&s->conn_list, s,

(GCompareFunc)colo_old_packet_check_one_conn);

@@ -XXX,XX +XXX,XX @@ static void colo_compare_packet(CompareState *s, Connection *conn,

*/

trace_colo_compare_main("packet different");

g_queue_push_head(&conn->primary_list, pkt);

- colo_compare_inconsistency_notify();

+

+ colo_compare_inconsistency_notify(s);

break;

}

@@ -XXX,XX +XXX,XX @@ static void compare_sec_rs_finalize(SocketReadState *sec_rs)

static void compare_notify_rs_finalize(SocketReadState *notify_rs)

{

+ CompareState *s = container_of(notify_rs, CompareState, notify_rs);

+

/* Get Xen colo-frame's notify and handle the message */

+ char *data = g_memdup(notify_rs->buf, notify_rs->packet_len);

+ char msg[] = "COLO_COMPARE_GET_XEN_INIT";

+ int ret;

+

+ if (!strcmp(data, "COLO_USERSPACE_PROXY_INIT")) {

+ ret = compare_chr_send(s, (uint8_t *)msg, strlen(msg), 0, true);

+ if (ret < 0) {

+ error_report("Notify Xen COLO-frame INIT failed");

+ }

+ }

+

+ if (!strcmp(data, "COLO_CHECKPOINT")) {

+ /* colo-compare do checkpoint, flush pri packet and remove sec packet */

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

+ }

2.5.0

From: Zhang Chen <chen.zhang@intel.com>

We need to notify net filter to do checkpoint for Xen COLO, like KVM side.

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

migration/colo.c | 2 ++

1 file changed, 2 insertions(+)

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

--- a/migration/colo.c

+++ b/migration/colo.c

@@ -XXX,XX +XXX,XX @@ ReplicationStatus *qmp_query_xen_replication_status(Error **errp)

void qmp_xen_colo_do_checkpoint(Error **errp)

{

replication_do_checkpoint_all(errp);

+ /* Notify all filters of all NIC to do checkpoint */

+ colo_notify_filters_event(COLO_EVENT_CHECKPOINT, errp);

}

#endif

2.5.0

From: Markus Armbruster <armbru@redhat.com>

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

qemu-bridge-helper.c | 12 +++++++++++-

1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/qemu-bridge-helper.c b/qemu-bridge-helper.c

--- a/qemu-bridge-helper.c

+++ b/qemu-bridge-helper.c

#include "qemu/osdep.h"

2.5.0

From: "Dr. David Alan Gilbert" <dgilbert@redhat.com>

Previously there was a single instance of the timer used by

monitor triggered announces, that's OK, but when combined with the

previous change that lets you have announces for subsets of interfaces

it's a bit restrictive if you want to do different things to different

interfaces.

Add an 'id' field to the announce, and maintain a list of the

timers based on id.

This allows you to for example:

a) Start an announce going on interface eth0 for a long time

b) Start an announce going on interface eth1 for a long time

c) Kill the announce on eth0 while leaving eth1 going.

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

hw/net/virtio-net.c | 4 ++--

include/net/announce.h | 8 ++++++--

net/announce.c | 52 +++++++++++++++++++++++++++++++++++++++++++-------

net/trace-events | 3 ++-

qapi/net.json | 9 +++++++--

5 files changed, 62 insertions(+), 14 deletions(-)

diff --git a/hw/net/virtio-net.c b/hw/net/virtio-net.c

--- a/hw/net/virtio-net.c

+++ b/hw/net/virtio-net.c

@@ -XXX,XX +XXX,XX @@ static int virtio_net_post_load_device(void *opaque, int version_id)

timer_mod(n->announce_timer.tm,

qemu_clock_get_ms(n->announce_timer.type));

} else {

- qemu_announce_timer_del(&n->announce_timer);

+ qemu_announce_timer_del(&n->announce_timer, false);

}

}

@@ -XXX,XX +XXX,XX @@ static void virtio_net_device_unrealize(DeviceState *dev, Error **errp)

virtio_net_del_queue(n, i);

}

- qemu_announce_timer_del(&n->announce_timer);

+ qemu_announce_timer_del(&n->announce_timer, false);

g_free(n->vqs);

qemu_del_nic(n->nic);

virtio_net_rsc_cleanup(n);

diff --git a/include/net/announce.h b/include/net/announce.h

index XXXXXXX..XXXXXXX 100644

--- a/include/net/announce.h

+++ b/include/net/announce.h

@@ -XXX,XX +XXX,XX @@ struct AnnounceTimer {

/* Returns: update the timer to the next time point */

int64_t qemu_announce_timer_step(AnnounceTimer *timer);

-/* Delete the underlying timer and other data */

-void qemu_announce_timer_del(AnnounceTimer *timer);

+/*

+ * Delete the underlying timer and other data

+ * If 'free_named' true and the timer is a named timer, then remove

+ * it from the list of named timers and free the AnnounceTimer itself.

+ */

+void qemu_announce_timer_del(AnnounceTimer *timer, bool free_named);

/*

* Under BQL/main thread

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

index XXXXXXX..XXXXXXX 100644

--- a/net/announce.c

+++ b/net/announce.c

#include "qapi/qapi-commands-net.h"

#include "trace.h"

+static GData *named_timers;

+

int64_t qemu_announce_timer_step(AnnounceTimer *timer)

{

int64_t step;

@@ -XXX,XX +XXX,XX @@ int64_t qemu_announce_timer_step(AnnounceTimer *timer)

return step;

}

-void qemu_announce_timer_del(AnnounceTimer *timer)

+/*

+ * If 'free_named' is true, then remove the timer from the list

+ * and free the timer itself.

+ */

+void qemu_announce_timer_del(AnnounceTimer *timer, bool free_named)

{

+ bool free_timer = false;

if (timer->tm) {

timer_del(timer->tm);

timer_free(timer->tm);

@@ -XXX,XX +XXX,XX @@ void qemu_announce_timer_del(AnnounceTimer *timer)

}

qapi_free_strList(timer->params.interfaces);

timer->params.interfaces = NULL;

+ if (free_named && timer->params.has_id) {

+ AnnounceTimer *list_timer;

+ /*

+ * Sanity check: There should only be one timer on the list with

+ * the id.

+ */

+ list_timer = g_datalist_get_data(&named_timers, timer->params.id);

+ assert(timer == list_timer);

+ free_timer = true;

+ g_datalist_remove_data(&named_timers, timer->params.id);

+ }

+ trace_qemu_announce_timer_del(free_named, free_timer, timer->params.id);

+ g_free(timer->params.id);

+ timer->params.id = NULL;

+

+ if (free_timer) {

+ g_free(timer);

+ }

}

/*

@@ -XXX,XX +XXX,XX @@ void qemu_announce_timer_reset(AnnounceTimer *timer,

* We're under the BQL, so the current timer can't

* be firing, so we should be able to delete it.

*/

- qemu_announce_timer_del(timer);

+ qemu_announce_timer_del(timer, false);

QAPI_CLONE_MEMBERS(AnnounceParameters, &timer->params, params);

timer->round = params->rounds;

@@ -XXX,XX +XXX,XX @@ static void qemu_announce_self_iter(NICState *nic, void *opaque)

skip = false;

}

- trace_qemu_announce_self_iter(nic->ncs->name,

+ trace_qemu_announce_self_iter(timer->params.has_id ? timer->params.id : "_",

+ nic->ncs->name,

qemu_ether_ntoa(&nic->conf->macaddr), skip);

if (!skip) {

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

if (--timer->round) {

qemu_announce_timer_step(timer);

} else {

- qemu_announce_timer_del(timer);

+ qemu_announce_timer_del(timer, true);

@@ -XXX,XX +XXX,XX @@ void qemu_announce_self(AnnounceTimer *timer, AnnounceParameters *params)

if (params->rounds) {

qemu_announce_self_once(timer);

} else {

- qemu_announce_timer_del(timer);

+ qemu_announce_timer_del(timer, true);

}

void qmp_announce_self(AnnounceParameters *params, Error **errp)

{

- static AnnounceTimer announce_timer;

- qemu_announce_self(&announce_timer, params);

+ AnnounceTimer *named_timer;

+ if (!params->has_id) {

+ params->id = g_strdup("");

+ params->has_id = true;

+ }

+ named_timer = g_datalist_get_data(&named_timers, params->id);

+

+ if (!named_timer) {

+ named_timer = g_new0(AnnounceTimer, 1);

+ g_datalist_set_data(&named_timers, params->id, named_timer);

+ }

+

+ qemu_announce_self(named_timer, params);

}

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

index XXXXXXX..XXXXXXX 100644

--- a/net/trace-events

+++ b/net/trace-events

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

# See docs/devel/tracing.txt for syntax documentation.

# announce.c

-qemu_announce_self_iter(const char *name, const char *mac, int skip) "%s:%s skip: %d"

+qemu_announce_self_iter(const char *id, const char *name, const char *mac, int skip) "%s:%s:%s skip: %d"

+qemu_announce_timer_del(bool free_named, bool free_timer, char *id) "free named: %d free timer: %d id: %s"

# vhost-user.c

vhost_user_event(const char *chr, int event) "chr: %s got event: %d"

diff --git a/qapi/net.json b/qapi/net.json

index XXXXXXX..XXXXXXX 100644

--- a/qapi/net.json

+++ b/qapi/net.json

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

# @interfaces: An optional list of interface names, which restricts the

# announcement to the listed interfaces. (Since 4.1)

#

+# @id: A name to be used to identify an instance of announce-timers

+# and to allow it to modified later. Not for use as

+# part of the migration parameters. (Since 4.1)

+#

# Since: 4.0

##

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

'max': 'int',

'rounds': 'int',

'step': 'int',

- '*interfaces': ['str'] } }

+ '*interfaces': ['str'],

+ '*id' : 'str' } }

##

# @announce-self:

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

# -> { "execute": "announce-self",

# "arguments": {

# "initial": 50, "max": 550, "rounds": 10, "step": 50,

-# "interfaces": ["vn2", "vn3"] } }

+# "interfaces": ["vn2", "vn3"], "id": "bob" } }

# <- { "return": {} }

#

# Since: 4.0

2.5.0

From: Zhang Chen <chen.zhang@intel.com>

We add the "notify_dev=chardevID" parameter. After that colo-compare can connect with

remote(currently just for Xen, KVM-COLO didn't need it.) colo-frame through chardev socket,

it can notify remote(Xen) colo-frame to handle checkpoint event.

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

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

qemu-options.hx | 33 ++++++++++++++++++++++++++++++++-

2 files changed, 53 insertions(+), 1 deletion(-)

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

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

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

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

char *pri_indev;

char *sec_indev;

char *outdev;

+ char *notify_dev;

CharBackend chr_pri_in;

CharBackend chr_sec_in;

CharBackend chr_out;

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

s->vnet_hdr = value;

}

+static char *compare_get_notify_dev(Object *obj, Error **errp)

+{

+ CompareState *s = COLO_COMPARE(obj);

+

+ return g_strdup(s->notify_dev);

+}

+

+static void compare_set_notify_dev(Object *obj, const char *value, Error **errp)

+{

+ CompareState *s = COLO_COMPARE(obj);

+

+ g_free(s->notify_dev);

+ s->notify_dev = g_strdup(value);

+}

+

static void compare_pri_rs_finalize(SocketReadState *pri_rs)

{

CompareState *s = container_of(pri_rs, CompareState, pri_rs);

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

(Object **)&s->iothread,

object_property_allow_set_link,

OBJ_PROP_LINK_STRONG, NULL);

+ /* This parameter just for Xen COLO */

+ object_property_add_str(obj, "notify_dev",

+ compare_get_notify_dev, compare_set_notify_dev,

+ NULL);

s->vnet_hdr = false;

object_property_add_bool(obj, "vnet_hdr_support", compare_get_vnet_hdr,

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

g_free(s->pri_indev);

g_free(s->sec_indev);

g_free(s->outdev);

+ g_free(s->notify_dev);

}

static const TypeInfo colo_compare_info = {

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

index XXXXXXX..XXXXXXX 100644

--- a/qemu-options.hx

+++ b/qemu-options.hx

@@ -XXX,XX +XXX,XX @@ Dump the network traffic on netdev @var{dev} to the file specified by

The file format is libpcap, so it can be analyzed with tools such as tcpdump

or Wireshark.

-@item -object colo-compare,id=@var{id},primary_in=@var{chardevid},secondary_in=@var{chardevid},outdev=@var{chardevid},iothread=@var{id}[,vnet_hdr_support]

+@item -object colo-compare,id=@var{id},primary_in=@var{chardevid},secondary_in=@var{chardevid},outdev=@var{chardevid},iothread=@var{id}[,vnet_hdr_support][,notify_dev=@var{id}]

Colo-compare gets packet from primary_in@var{chardevid} and secondary_in@var{chardevid}, than compare primary packet with

secondary packet. If the packets are same, we will output primary

@@ -XXX,XX +XXX,XX @@ do checkpoint and send primary packet to outdev@var{chardevid}.

In order to improve efficiency, we need to put the task of comparison

in another thread. If it has the vnet_hdr_support flag, colo compare

will send/recv packet with vnet_hdr_len.

+If you want to use Xen COLO, will need the notify_dev to notify Xen

+colo-frame to do checkpoint.

we must use it with the help of filter-mirror and filter-redirector.

@example

+KVM COLO

+

primary:

-netdev tap,id=hn0,vhost=off,script=/etc/qemu-ifup,downscript=/etc/qemu-ifdown

-device e1000,id=e0,netdev=hn0,mac=52:a4:00:12:78:66

@@ -XXX,XX +XXX,XX @@ secondary:

-object filter-redirector,id=f1,netdev=hn0,queue=tx,indev=red0

-object filter-redirector,id=f2,netdev=hn0,queue=rx,outdev=red1

+

+Xen COLO

+

+primary:

+-netdev tap,id=hn0,vhost=off,script=/etc/qemu-ifup,downscript=/etc/qemu-ifdown

+-device e1000,id=e0,netdev=hn0,mac=52:a4:00:12:78:66

+-chardev socket,id=mirror0,host=3.3.3.3,port=9003,server,nowait

+-chardev socket,id=compare1,host=3.3.3.3,port=9004,server,nowait

+-chardev socket,id=compare0,host=3.3.3.3,port=9001,server,nowait

+-chardev socket,id=compare0-0,host=3.3.3.3,port=9001

+-chardev socket,id=compare_out,host=3.3.3.3,port=9005,server,nowait

+-chardev socket,id=compare_out0,host=3.3.3.3,port=9005

+-chardev socket,id=notify_way,host=3.3.3.3,port=9009,server,nowait

+-object filter-mirror,id=m0,netdev=hn0,queue=tx,outdev=mirror0

+-object filter-redirector,netdev=hn0,id=redire0,queue=rx,indev=compare_out

+-object filter-redirector,netdev=hn0,id=redire1,queue=rx,outdev=compare0

+-object iothread,id=iothread1

+-object colo-compare,id=comp0,primary_in=compare0-0,secondary_in=compare1,outdev=compare_out0,notify_dev=nofity_way,iothread=iothread1

+

+secondary:

+-netdev tap,id=hn0,vhost=off,script=/etc/qemu-ifup,down script=/etc/qemu-ifdown

+-device e1000,netdev=hn0,mac=52:a4:00:12:78:66

+-chardev socket,id=red0,host=3.3.3.3,port=9003

+-chardev socket,id=red1,host=3.3.3.3,port=9004

+-object filter-redirector,id=f1,netdev=hn0,queue=tx,indev=red0

+-object filter-redirector,id=f2,netdev=hn0,queue=rx,outdev=red1

+

@end example

If you want to know the detail of above command line, you can read

2.5.0

From: Zhang Chen <chen.zhang@intel.com>

Add chardev handler to send notification to remote(current from Xen) colo-frame.

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

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

1 file changed, 39 insertions(+)

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

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

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

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

CharBackend chr_pri_in;

CharBackend chr_sec_in;

CharBackend chr_out;

+ CharBackend chr_notify_dev;

SocketReadState pri_rs;

SocketReadState sec_rs;

+ SocketReadState notify_rs;

bool vnet_hdr;

/*

@@ -XXX,XX +XXX,XX @@ static void compare_sec_chr_in(void *opaque, const uint8_t *buf, int size)

}

+static void compare_notify_chr(void *opaque, const uint8_t *buf, int size)

+{

+ CompareState *s = COLO_COMPARE(opaque);