2 * COarse-grain LOck-stepping Virtual Machines for Non-stop Service (COLO)
3 * (a.k.a. Fault Tolerance or Continuous Replication)
5 * Copyright (c) 2016 HUAWEI TECHNOLOGIES CO., LTD.
6 * Copyright (c) 2016 FUJITSU LIMITED
7 * Copyright (c) 2016 Intel Corporation
9 * Author: Zhang Chen <zhangchen.fnst@cn.fujitsu.com>
11 * This work is licensed under the terms of the GNU GPL, version 2 or
12 * later. See the COPYING file in the top-level directory.
15 #include "qemu/osdep.h"
16 #include "qemu/error-report.h"
18 #include "qemu-common.h"
19 #include "qapi/qmp/qerror.h"
20 #include "qapi/error.h"
23 #include "qom/object_interfaces.h"
25 #include "qom/object.h"
26 #include "qemu/typedefs.h"
27 #include "net/queue.h"
28 #include "sysemu/char.h"
29 #include "qemu/sockets.h"
30 #include "qapi-visit.h"
33 #define TYPE_COLO_COMPARE "colo-compare"
34 #define COLO_COMPARE(obj) \
35 OBJECT_CHECK(CompareState, (obj), TYPE_COLO_COMPARE)
37 #define COMPARE_READ_LEN_MAX NET_BUFSIZE
38 #define MAX_QUEUE_SIZE 1024
40 /* TODO: Should be configurable */
41 #define REGULAR_PACKET_CHECK_MS 3000
46 +---------------+ +---------------+ +---------------+
47 |conn list +--->conn +--------->conn |
48 +---------------+ +---------------+ +---------------+
50 +---------------+ +---v----+ +---v----+ +---v----+ +---v----+
51 |primary | |secondary |primary | |secondary
52 |packet | |packet + |packet | |packet +
53 +--------+ +--------+ +--------+ +--------+
55 +---v----+ +---v----+ +---v----+ +---v----+
56 |primary | |secondary |primary | |secondary
57 |packet | |packet + |packet | |packet +
58 +--------+ +--------+ +--------+ +--------+
60 +---v----+ +---v----+ +---v----+ +---v----+
61 |primary | |secondary |primary | |secondary
62 |packet | |packet + |packet | |packet +
63 +--------+ +--------+ +--------+ +--------+
65 typedef struct CompareState
{
71 CharBackend chr_pri_in
;
72 CharBackend chr_sec_in
;
74 SocketReadState pri_rs
;
75 SocketReadState sec_rs
;
77 /* connection list: the connections belonged to this NIC could be found
79 * element type: Connection
82 /* hashtable to save connection */
83 GHashTable
*connection_track_table
;
84 /* compare thread, a thread for each NIC */
87 GMainContext
*worker_context
;
88 GMainLoop
*compare_loop
;
91 typedef struct CompareClass
{
92 ObjectClass parent_class
;
100 static int compare_chr_send(CharBackend
*out
,
104 static gint
seq_sorter(Packet
*a
, Packet
*b
, gpointer data
)
106 struct tcphdr
*atcp
, *btcp
;
108 atcp
= (struct tcphdr
*)(a
->transport_header
);
109 btcp
= (struct tcphdr
*)(b
->transport_header
);
110 return ntohl(atcp
->th_seq
) - ntohl(btcp
->th_seq
);
114 * Return 0 on success, if return -1 means the pkt
115 * is unsupported(arp and ipv6) and will be sent later
117 static int packet_enqueue(CompareState
*s
, int mode
)
123 if (mode
== PRIMARY_IN
) {
124 pkt
= packet_new(s
->pri_rs
.buf
, s
->pri_rs
.packet_len
);
126 pkt
= packet_new(s
->sec_rs
.buf
, s
->sec_rs
.packet_len
);
129 if (parse_packet_early(pkt
)) {
130 packet_destroy(pkt
, NULL
);
134 fill_connection_key(pkt
, &key
);
136 conn
= connection_get(s
->connection_track_table
,
140 if (!conn
->processing
) {
141 g_queue_push_tail(&s
->conn_list
, conn
);
142 conn
->processing
= true;
145 if (mode
== PRIMARY_IN
) {
146 if (g_queue_get_length(&conn
->primary_list
) <=
148 g_queue_push_tail(&conn
->primary_list
, pkt
);
149 if (conn
->ip_proto
== IPPROTO_TCP
) {
150 g_queue_sort(&conn
->primary_list
,
151 (GCompareDataFunc
)seq_sorter
,
155 error_report("colo compare primary queue size too big,"
159 if (g_queue_get_length(&conn
->secondary_list
) <=
161 g_queue_push_tail(&conn
->secondary_list
, pkt
);
162 if (conn
->ip_proto
== IPPROTO_TCP
) {
163 g_queue_sort(&conn
->secondary_list
,
164 (GCompareDataFunc
)seq_sorter
,
168 error_report("colo compare secondary queue size too big,"
177 * The IP packets sent by primary and secondary
178 * will be compared in here
179 * TODO support ip fragment, Out-Of-Order
180 * return: 0 means packet same
181 * > 0 || < 0 means packet different
183 static int colo_packet_compare_common(Packet
*ppkt
, Packet
*spkt
)
185 trace_colo_compare_ip_info(ppkt
->size
, inet_ntoa(ppkt
->ip
->ip_src
),
186 inet_ntoa(ppkt
->ip
->ip_dst
), spkt
->size
,
187 inet_ntoa(spkt
->ip
->ip_src
),
188 inet_ntoa(spkt
->ip
->ip_dst
));
190 if (ppkt
->size
== spkt
->size
) {
191 return memcmp(ppkt
->data
, spkt
->data
, spkt
->size
);
193 trace_colo_compare_main("Net packet size are not the same");
199 * Called from the compare thread on the primary
200 * for compare tcp packet
201 * compare_tcp copied from Dr. David Alan Gilbert's branch
203 static int colo_packet_compare_tcp(Packet
*spkt
, Packet
*ppkt
)
205 struct tcphdr
*ptcp
, *stcp
;
208 trace_colo_compare_main("compare tcp");
210 if (ppkt
->size
!= spkt
->size
) {
211 if (trace_event_get_state(TRACE_COLO_COMPARE_MISCOMPARE
)) {
212 trace_colo_compare_main("pkt size not same");
217 ptcp
= (struct tcphdr
*)ppkt
->transport_header
;
218 stcp
= (struct tcphdr
*)spkt
->transport_header
;
221 * The 'identification' field in the IP header is *very* random
222 * it almost never matches. Fudge this by ignoring differences in
223 * unfragmented packets; they'll normally sort themselves out if different
224 * anyway, and it should recover at the TCP level.
225 * An alternative would be to get both the primary and secondary to rewrite
226 * somehow; but that would need some sync traffic to sync the state
228 if (ntohs(ppkt
->ip
->ip_off
) & IP_DF
) {
229 spkt
->ip
->ip_id
= ppkt
->ip
->ip_id
;
230 /* and the sum will be different if the IDs were different */
231 spkt
->ip
->ip_sum
= ppkt
->ip
->ip_sum
;
234 res
= memcmp(ppkt
->data
+ ETH_HLEN
, spkt
->data
+ ETH_HLEN
,
235 (spkt
->size
- ETH_HLEN
));
237 if (res
!= 0 && trace_event_get_state(TRACE_COLO_COMPARE_MISCOMPARE
)) {
238 trace_colo_compare_pkt_info_src(inet_ntoa(ppkt
->ip
->ip_src
),
244 trace_colo_compare_pkt_info_dst(inet_ntoa(ppkt
->ip
->ip_dst
),
250 qemu_hexdump((char *)ppkt
->data
, stderr
,
251 "colo-compare ppkt", ppkt
->size
);
252 qemu_hexdump((char *)spkt
->data
, stderr
,
253 "colo-compare spkt", spkt
->size
);
260 * Called from the compare thread on the primary
261 * for compare udp packet
263 static int colo_packet_compare_udp(Packet
*spkt
, Packet
*ppkt
)
267 trace_colo_compare_main("compare udp");
269 ret
= colo_packet_compare_common(ppkt
, spkt
);
272 trace_colo_compare_udp_miscompare("primary pkt size", ppkt
->size
);
273 qemu_hexdump((char *)ppkt
->data
, stderr
, "colo-compare", ppkt
->size
);
274 trace_colo_compare_udp_miscompare("Secondary pkt size", spkt
->size
);
275 qemu_hexdump((char *)spkt
->data
, stderr
, "colo-compare", spkt
->size
);
282 * Called from the compare thread on the primary
283 * for compare icmp packet
285 static int colo_packet_compare_icmp(Packet
*spkt
, Packet
*ppkt
)
287 trace_colo_compare_main("compare icmp");
289 if (colo_packet_compare_common(ppkt
, spkt
)) {
290 trace_colo_compare_icmp_miscompare("primary pkt size",
292 qemu_hexdump((char *)ppkt
->data
, stderr
, "colo-compare",
294 trace_colo_compare_icmp_miscompare("Secondary pkt size",
296 qemu_hexdump((char *)spkt
->data
, stderr
, "colo-compare",
305 * Called from the compare thread on the primary
306 * for compare other packet
308 static int colo_packet_compare_other(Packet
*spkt
, Packet
*ppkt
)
310 trace_colo_compare_main("compare other");
311 trace_colo_compare_ip_info(ppkt
->size
, inet_ntoa(ppkt
->ip
->ip_src
),
312 inet_ntoa(ppkt
->ip
->ip_dst
), spkt
->size
,
313 inet_ntoa(spkt
->ip
->ip_src
),
314 inet_ntoa(spkt
->ip
->ip_dst
));
315 return colo_packet_compare_common(ppkt
, spkt
);
318 static int colo_old_packet_check_one(Packet
*pkt
, int64_t *check_time
)
320 int64_t now
= qemu_clock_get_ms(QEMU_CLOCK_HOST
);
322 if ((now
- pkt
->creation_ms
) > (*check_time
)) {
323 trace_colo_old_packet_check_found(pkt
->creation_ms
);
330 static void colo_old_packet_check_one_conn(void *opaque
,
333 Connection
*conn
= opaque
;
334 GList
*result
= NULL
;
335 int64_t check_time
= REGULAR_PACKET_CHECK_MS
;
337 result
= g_queue_find_custom(&conn
->primary_list
,
339 (GCompareFunc
)colo_old_packet_check_one
);
342 /* do checkpoint will flush old packet */
343 /* TODO: colo_notify_checkpoint();*/
348 * Look for old packets that the secondary hasn't matched,
349 * if we have some then we have to checkpoint to wake
352 static void colo_old_packet_check(void *opaque
)
354 CompareState
*s
= opaque
;
356 g_queue_foreach(&s
->conn_list
, colo_old_packet_check_one_conn
, NULL
);
360 * Called from the compare thread on the primary
361 * for compare connection
363 static void colo_compare_connection(void *opaque
, void *user_data
)
365 CompareState
*s
= user_data
;
366 Connection
*conn
= opaque
;
368 GList
*result
= NULL
;
371 while (!g_queue_is_empty(&conn
->primary_list
) &&
372 !g_queue_is_empty(&conn
->secondary_list
)) {
373 pkt
= g_queue_pop_tail(&conn
->primary_list
);
374 switch (conn
->ip_proto
) {
376 result
= g_queue_find_custom(&conn
->secondary_list
,
377 pkt
, (GCompareFunc
)colo_packet_compare_tcp
);
380 result
= g_queue_find_custom(&conn
->secondary_list
,
381 pkt
, (GCompareFunc
)colo_packet_compare_udp
);
384 result
= g_queue_find_custom(&conn
->secondary_list
,
385 pkt
, (GCompareFunc
)colo_packet_compare_icmp
);
388 result
= g_queue_find_custom(&conn
->secondary_list
,
389 pkt
, (GCompareFunc
)colo_packet_compare_other
);
394 ret
= compare_chr_send(&s
->chr_out
, pkt
->data
, pkt
->size
);
396 error_report("colo_send_primary_packet failed");
398 trace_colo_compare_main("packet same and release packet");
399 g_queue_remove(&conn
->secondary_list
, result
->data
);
400 packet_destroy(pkt
, NULL
);
403 * If one packet arrive late, the secondary_list or
404 * primary_list will be empty, so we can't compare it
405 * until next comparison.
407 trace_colo_compare_main("packet different");
408 g_queue_push_tail(&conn
->primary_list
, pkt
);
409 /* TODO: colo_notify_checkpoint();*/
415 static int compare_chr_send(CharBackend
*out
,
420 uint32_t len
= htonl(size
);
426 ret
= qemu_chr_fe_write_all(out
, (uint8_t *)&len
, sizeof(len
));
427 if (ret
!= sizeof(len
)) {
431 ret
= qemu_chr_fe_write_all(out
, (uint8_t *)buf
, size
);
439 return ret
< 0 ? ret
: -EIO
;
442 static int compare_chr_can_read(void *opaque
)
444 return COMPARE_READ_LEN_MAX
;
448 * Called from the main thread on the primary for packets
449 * arriving over the socket from the primary.
451 static void compare_pri_chr_in(void *opaque
, const uint8_t *buf
, int size
)
453 CompareState
*s
= COLO_COMPARE(opaque
);
456 ret
= net_fill_rstate(&s
->pri_rs
, buf
, size
);
458 qemu_chr_fe_set_handlers(&s
->chr_pri_in
, NULL
, NULL
, NULL
,
460 error_report("colo-compare primary_in error");
465 * Called from the main thread on the primary for packets
466 * arriving over the socket from the secondary.
468 static void compare_sec_chr_in(void *opaque
, const uint8_t *buf
, int size
)
470 CompareState
*s
= COLO_COMPARE(opaque
);
473 ret
= net_fill_rstate(&s
->sec_rs
, buf
, size
);
475 qemu_chr_fe_set_handlers(&s
->chr_sec_in
, NULL
, NULL
, NULL
,
477 error_report("colo-compare secondary_in error");
482 * Check old packet regularly so it can watch for any packets
483 * that the secondary hasn't produced equivalents of.
485 static gboolean
check_old_packet_regular(void *opaque
)
487 CompareState
*s
= opaque
;
489 /* if have old packet we will notify checkpoint */
490 colo_old_packet_check(s
);
495 static void *colo_compare_thread(void *opaque
)
497 CompareState
*s
= opaque
;
498 GSource
*timeout_source
;
500 s
->worker_context
= g_main_context_new();
502 qemu_chr_fe_set_handlers(&s
->chr_pri_in
, compare_chr_can_read
,
503 compare_pri_chr_in
, NULL
, s
, s
->worker_context
, true);
504 qemu_chr_fe_set_handlers(&s
->chr_sec_in
, compare_chr_can_read
,
505 compare_sec_chr_in
, NULL
, s
, s
->worker_context
, true);
507 s
->compare_loop
= g_main_loop_new(s
->worker_context
, FALSE
);
509 /* To kick any packets that the secondary doesn't match */
510 timeout_source
= g_timeout_source_new(REGULAR_PACKET_CHECK_MS
);
511 g_source_set_callback(timeout_source
,
512 (GSourceFunc
)check_old_packet_regular
, s
, NULL
);
513 g_source_attach(timeout_source
, s
->worker_context
);
515 g_main_loop_run(s
->compare_loop
);
517 g_source_unref(timeout_source
);
518 g_main_loop_unref(s
->compare_loop
);
519 g_main_context_unref(s
->worker_context
);
523 static char *compare_get_pri_indev(Object
*obj
, Error
**errp
)
525 CompareState
*s
= COLO_COMPARE(obj
);
527 return g_strdup(s
->pri_indev
);
530 static void compare_set_pri_indev(Object
*obj
, const char *value
, Error
**errp
)
532 CompareState
*s
= COLO_COMPARE(obj
);
534 g_free(s
->pri_indev
);
535 s
->pri_indev
= g_strdup(value
);
538 static char *compare_get_sec_indev(Object
*obj
, Error
**errp
)
540 CompareState
*s
= COLO_COMPARE(obj
);
542 return g_strdup(s
->sec_indev
);
545 static void compare_set_sec_indev(Object
*obj
, const char *value
, Error
**errp
)
547 CompareState
*s
= COLO_COMPARE(obj
);
549 g_free(s
->sec_indev
);
550 s
->sec_indev
= g_strdup(value
);
553 static char *compare_get_outdev(Object
*obj
, Error
**errp
)
555 CompareState
*s
= COLO_COMPARE(obj
);
557 return g_strdup(s
->outdev
);
560 static void compare_set_outdev(Object
*obj
, const char *value
, Error
**errp
)
562 CompareState
*s
= COLO_COMPARE(obj
);
565 s
->outdev
= g_strdup(value
);
568 static void compare_pri_rs_finalize(SocketReadState
*pri_rs
)
570 CompareState
*s
= container_of(pri_rs
, CompareState
, pri_rs
);
572 if (packet_enqueue(s
, PRIMARY_IN
)) {
573 trace_colo_compare_main("primary: unsupported packet in");
574 compare_chr_send(&s
->chr_out
, pri_rs
->buf
, pri_rs
->packet_len
);
576 /* compare connection */
577 g_queue_foreach(&s
->conn_list
, colo_compare_connection
, s
);
581 static void compare_sec_rs_finalize(SocketReadState
*sec_rs
)
583 CompareState
*s
= container_of(sec_rs
, CompareState
, sec_rs
);
585 if (packet_enqueue(s
, SECONDARY_IN
)) {
586 trace_colo_compare_main("secondary: unsupported packet in");
588 /* compare connection */
589 g_queue_foreach(&s
->conn_list
, colo_compare_connection
, s
);
595 * Return 0 is success.
596 * Return 1 is failed.
598 static int find_and_check_chardev(Chardev
**chr
,
602 *chr
= qemu_chr_find(chr_name
);
604 error_setg(errp
, "Device '%s' not found",
609 if (!qemu_chr_has_feature(*chr
, QEMU_CHAR_FEATURE_RECONNECTABLE
)) {
610 error_setg(errp
, "chardev \"%s\" is not reconnectable",
619 * Called from the main thread on the primary
620 * to setup colo-compare.
622 static void colo_compare_complete(UserCreatable
*uc
, Error
**errp
)
624 CompareState
*s
= COLO_COMPARE(uc
);
626 char thread_name
[64];
627 static int compare_id
;
629 if (!s
->pri_indev
|| !s
->sec_indev
|| !s
->outdev
) {
630 error_setg(errp
, "colo compare needs 'primary_in' ,"
631 "'secondary_in','outdev' property set");
633 } else if (!strcmp(s
->pri_indev
, s
->outdev
) ||
634 !strcmp(s
->sec_indev
, s
->outdev
) ||
635 !strcmp(s
->pri_indev
, s
->sec_indev
)) {
636 error_setg(errp
, "'indev' and 'outdev' could not be same "
637 "for compare module");
641 if (find_and_check_chardev(&chr
, s
->pri_indev
, errp
) ||
642 !qemu_chr_fe_init(&s
->chr_pri_in
, chr
, errp
)) {
646 if (find_and_check_chardev(&chr
, s
->sec_indev
, errp
) ||
647 !qemu_chr_fe_init(&s
->chr_sec_in
, chr
, errp
)) {
651 if (find_and_check_chardev(&chr
, s
->outdev
, errp
) ||
652 !qemu_chr_fe_init(&s
->chr_out
, chr
, errp
)) {
656 net_socket_rs_init(&s
->pri_rs
, compare_pri_rs_finalize
);
657 net_socket_rs_init(&s
->sec_rs
, compare_sec_rs_finalize
);
659 g_queue_init(&s
->conn_list
);
661 s
->connection_track_table
= g_hash_table_new_full(connection_key_hash
,
662 connection_key_equal
,
666 sprintf(thread_name
, "colo-compare %d", compare_id
);
667 qemu_thread_create(&s
->thread
, thread_name
,
668 colo_compare_thread
, s
,
669 QEMU_THREAD_JOINABLE
);
675 static void colo_flush_packets(void *opaque
, void *user_data
)
677 CompareState
*s
= user_data
;
678 Connection
*conn
= opaque
;
681 while (!g_queue_is_empty(&conn
->primary_list
)) {
682 pkt
= g_queue_pop_head(&conn
->primary_list
);
683 compare_chr_send(&s
->chr_out
, pkt
->data
, pkt
->size
);
684 packet_destroy(pkt
, NULL
);
686 while (!g_queue_is_empty(&conn
->secondary_list
)) {
687 pkt
= g_queue_pop_head(&conn
->secondary_list
);
688 packet_destroy(pkt
, NULL
);
692 static void colo_compare_class_init(ObjectClass
*oc
, void *data
)
694 UserCreatableClass
*ucc
= USER_CREATABLE_CLASS(oc
);
696 ucc
->complete
= colo_compare_complete
;
699 static void colo_compare_init(Object
*obj
)
701 object_property_add_str(obj
, "primary_in",
702 compare_get_pri_indev
, compare_set_pri_indev
,
704 object_property_add_str(obj
, "secondary_in",
705 compare_get_sec_indev
, compare_set_sec_indev
,
707 object_property_add_str(obj
, "outdev",
708 compare_get_outdev
, compare_set_outdev
,
712 static void colo_compare_finalize(Object
*obj
)
714 CompareState
*s
= COLO_COMPARE(obj
);
716 qemu_chr_fe_set_handlers(&s
->chr_pri_in
, NULL
, NULL
, NULL
, NULL
,
717 s
->worker_context
, true);
718 qemu_chr_fe_set_handlers(&s
->chr_sec_in
, NULL
, NULL
, NULL
, NULL
,
719 s
->worker_context
, true);
720 qemu_chr_fe_deinit(&s
->chr_out
);
722 g_main_loop_quit(s
->compare_loop
);
723 qemu_thread_join(&s
->thread
);
725 /* Release all unhandled packets after compare thead exited */
726 g_queue_foreach(&s
->conn_list
, colo_flush_packets
, s
);
728 g_queue_clear(&s
->conn_list
);
730 g_hash_table_destroy(s
->connection_track_table
);
731 g_free(s
->pri_indev
);
732 g_free(s
->sec_indev
);
736 static const TypeInfo colo_compare_info
= {
737 .name
= TYPE_COLO_COMPARE
,
738 .parent
= TYPE_OBJECT
,
739 .instance_size
= sizeof(CompareState
),
740 .instance_init
= colo_compare_init
,
741 .instance_finalize
= colo_compare_finalize
,
742 .class_size
= sizeof(CompareClass
),
743 .class_init
= colo_compare_class_init
,
744 .interfaces
= (InterfaceInfo
[]) {
745 { TYPE_USER_CREATABLE
},
750 static void register_types(void)
752 type_register_static(&colo_compare_info
);
755 type_init(register_types
);