1
2
3
4
5
6
7
8
9
10
11
12
13
14
15#include "qemu/osdep.h"
16#include "qemu/error-report.h"
17#include "trace.h"
18#include "qemu-common.h"
19#include "qapi/qmp/qerror.h"
20#include "qapi/error.h"
21#include "net/net.h"
22#include "net/eth.h"
23#include "qom/object_interfaces.h"
24#include "qemu/iov.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"
31#include "net/colo.h"
32
33#define TYPE_COLO_COMPARE "colo-compare"
34#define COLO_COMPARE(obj) \
35 OBJECT_CHECK(CompareState, (obj), TYPE_COLO_COMPARE)
36
37#define COMPARE_READ_LEN_MAX NET_BUFSIZE
38#define MAX_QUEUE_SIZE 1024
39
40
41#define REGULAR_PACKET_CHECK_MS 3000
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65typedef struct CompareState {
66 Object parent;
67
68 char *pri_indev;
69 char *sec_indev;
70 char *outdev;
71 CharBackend chr_pri_in;
72 CharBackend chr_sec_in;
73 CharBackend chr_out;
74 SocketReadState pri_rs;
75 SocketReadState sec_rs;
76
77
78
79
80
81 GQueue conn_list;
82
83 GHashTable *connection_track_table;
84
85 QemuThread thread;
86
87 QEMUTimer *timer;
88 QemuMutex timer_check_lock;
89} CompareState;
90
91typedef struct CompareClass {
92 ObjectClass parent_class;
93} CompareClass;
94
95enum {
96 PRIMARY_IN = 0,
97 SECONDARY_IN,
98};
99
100static int compare_chr_send(CharBackend *out,
101 const uint8_t *buf,
102 uint32_t size);
103
104
105
106
107
108static int packet_enqueue(CompareState *s, int mode)
109{
110 ConnectionKey key;
111 Packet *pkt = NULL;
112 Connection *conn;
113
114 if (mode == PRIMARY_IN) {
115 pkt = packet_new(s->pri_rs.buf, s->pri_rs.packet_len);
116 } else {
117 pkt = packet_new(s->sec_rs.buf, s->sec_rs.packet_len);
118 }
119
120 if (parse_packet_early(pkt)) {
121 packet_destroy(pkt, NULL);
122 pkt = NULL;
123 return -1;
124 }
125 fill_connection_key(pkt, &key);
126
127 conn = connection_get(s->connection_track_table,
128 &key,
129 &s->conn_list);
130
131 if (!conn->processing) {
132 g_queue_push_tail(&s->conn_list, conn);
133 conn->processing = true;
134 }
135
136 if (mode == PRIMARY_IN) {
137 if (g_queue_get_length(&conn->primary_list) <=
138 MAX_QUEUE_SIZE) {
139 g_queue_push_tail(&conn->primary_list, pkt);
140 } else {
141 error_report("colo compare primary queue size too big,"
142 "drop packet");
143 }
144 } else {
145 if (g_queue_get_length(&conn->secondary_list) <=
146 MAX_QUEUE_SIZE) {
147 g_queue_push_tail(&conn->secondary_list, pkt);
148 } else {
149 error_report("colo compare secondary queue size too big,"
150 "drop packet");
151 }
152 }
153
154 return 0;
155}
156
157
158
159
160
161
162
163
164static int colo_packet_compare(Packet *ppkt, Packet *spkt)
165{
166 trace_colo_compare_ip_info(ppkt->size, inet_ntoa(ppkt->ip->ip_src),
167 inet_ntoa(ppkt->ip->ip_dst), spkt->size,
168 inet_ntoa(spkt->ip->ip_src),
169 inet_ntoa(spkt->ip->ip_dst));
170
171 if (ppkt->size == spkt->size) {
172 return memcmp(ppkt->data, spkt->data, spkt->size);
173 } else {
174 return -1;
175 }
176}
177
178
179
180
181
182
183static int colo_packet_compare_tcp(Packet *spkt, Packet *ppkt)
184{
185 struct tcphdr *ptcp, *stcp;
186 int res;
187
188 trace_colo_compare_main("compare tcp");
189 if (ppkt->size != spkt->size) {
190 if (trace_event_get_state(TRACE_COLO_COMPARE_MISCOMPARE)) {
191 trace_colo_compare_main("pkt size not same");
192 }
193 return -1;
194 }
195
196 ptcp = (struct tcphdr *)ppkt->transport_header;
197 stcp = (struct tcphdr *)spkt->transport_header;
198
199
200
201
202
203
204
205
206
207 if (ntohs(ppkt->ip->ip_off) & IP_DF) {
208 spkt->ip->ip_id = ppkt->ip->ip_id;
209
210 spkt->ip->ip_sum = ppkt->ip->ip_sum;
211 }
212
213 res = memcmp(ppkt->data + ETH_HLEN, spkt->data + ETH_HLEN,
214 (spkt->size - ETH_HLEN));
215
216 if (res != 0 && trace_event_get_state(TRACE_COLO_COMPARE_MISCOMPARE)) {
217 trace_colo_compare_pkt_info_src(inet_ntoa(ppkt->ip->ip_src),
218 ntohl(stcp->th_seq),
219 ntohl(stcp->th_ack),
220 res, stcp->th_flags,
221 spkt->size);
222
223 trace_colo_compare_pkt_info_dst(inet_ntoa(ppkt->ip->ip_dst),
224 ntohl(ptcp->th_seq),
225 ntohl(ptcp->th_ack),
226 res, ptcp->th_flags,
227 ppkt->size);
228
229 qemu_hexdump((char *)ppkt->data, stderr,
230 "colo-compare ppkt", ppkt->size);
231 qemu_hexdump((char *)spkt->data, stderr,
232 "colo-compare spkt", spkt->size);
233 }
234
235 return res;
236}
237
238
239
240
241
242static int colo_packet_compare_udp(Packet *spkt, Packet *ppkt)
243{
244 int ret;
245
246 trace_colo_compare_main("compare udp");
247 ret = colo_packet_compare(ppkt, spkt);
248
249 if (ret) {
250 trace_colo_compare_udp_miscompare("primary pkt size", ppkt->size);
251 qemu_hexdump((char *)ppkt->data, stderr, "colo-compare", ppkt->size);
252 trace_colo_compare_udp_miscompare("Secondary pkt size", spkt->size);
253 qemu_hexdump((char *)spkt->data, stderr, "colo-compare", spkt->size);
254 }
255
256 return ret;
257}
258
259
260
261
262
263static int colo_packet_compare_icmp(Packet *spkt, Packet *ppkt)
264{
265 int network_length;
266
267 trace_colo_compare_main("compare icmp");
268 network_length = ppkt->ip->ip_hl * 4;
269 if (ppkt->size != spkt->size ||
270 ppkt->size < network_length + ETH_HLEN) {
271 return -1;
272 }
273
274 if (colo_packet_compare(ppkt, spkt)) {
275 trace_colo_compare_icmp_miscompare("primary pkt size",
276 ppkt->size);
277 qemu_hexdump((char *)ppkt->data, stderr, "colo-compare",
278 ppkt->size);
279 trace_colo_compare_icmp_miscompare("Secondary pkt size",
280 spkt->size);
281 qemu_hexdump((char *)spkt->data, stderr, "colo-compare",
282 spkt->size);
283 return -1;
284 } else {
285 return 0;
286 }
287}
288
289
290
291
292
293static int colo_packet_compare_other(Packet *spkt, Packet *ppkt)
294{
295 trace_colo_compare_main("compare other");
296 trace_colo_compare_ip_info(ppkt->size, inet_ntoa(ppkt->ip->ip_src),
297 inet_ntoa(ppkt->ip->ip_dst), spkt->size,
298 inet_ntoa(spkt->ip->ip_src),
299 inet_ntoa(spkt->ip->ip_dst));
300 return colo_packet_compare(ppkt, spkt);
301}
302
303static int colo_old_packet_check_one(Packet *pkt, int64_t *check_time)
304{
305 int64_t now = qemu_clock_get_ms(QEMU_CLOCK_HOST);
306
307 if ((now - pkt->creation_ms) > (*check_time)) {
308 trace_colo_old_packet_check_found(pkt->creation_ms);
309 return 0;
310 } else {
311 return 1;
312 }
313}
314
315static void colo_old_packet_check_one_conn(void *opaque,
316 void *user_data)
317{
318 Connection *conn = opaque;
319 GList *result = NULL;
320 int64_t check_time = REGULAR_PACKET_CHECK_MS;
321
322 result = g_queue_find_custom(&conn->primary_list,
323 &check_time,
324 (GCompareFunc)colo_old_packet_check_one);
325
326 if (result) {
327
328
329 }
330}
331
332
333
334
335
336
337static void colo_old_packet_check(void *opaque)
338{
339 CompareState *s = opaque;
340
341 g_queue_foreach(&s->conn_list, colo_old_packet_check_one_conn, NULL);
342}
343
344
345
346
347
348static void colo_compare_connection(void *opaque, void *user_data)
349{
350 CompareState *s = user_data;
351 Connection *conn = opaque;
352 Packet *pkt = NULL;
353 GList *result = NULL;
354 int ret;
355
356 while (!g_queue_is_empty(&conn->primary_list) &&
357 !g_queue_is_empty(&conn->secondary_list)) {
358 qemu_mutex_lock(&s->timer_check_lock);
359 pkt = g_queue_pop_tail(&conn->primary_list);
360 qemu_mutex_unlock(&s->timer_check_lock);
361 switch (conn->ip_proto) {
362 case IPPROTO_TCP:
363 result = g_queue_find_custom(&conn->secondary_list,
364 pkt, (GCompareFunc)colo_packet_compare_tcp);
365 break;
366 case IPPROTO_UDP:
367 result = g_queue_find_custom(&conn->secondary_list,
368 pkt, (GCompareFunc)colo_packet_compare_udp);
369 break;
370 case IPPROTO_ICMP:
371 result = g_queue_find_custom(&conn->secondary_list,
372 pkt, (GCompareFunc)colo_packet_compare_icmp);
373 break;
374 default:
375 result = g_queue_find_custom(&conn->secondary_list,
376 pkt, (GCompareFunc)colo_packet_compare_other);
377 break;
378 }
379
380 if (result) {
381 ret = compare_chr_send(&s->chr_out, pkt->data, pkt->size);
382 if (ret < 0) {
383 error_report("colo_send_primary_packet failed");
384 }
385 trace_colo_compare_main("packet same and release packet");
386 g_queue_remove(&conn->secondary_list, result->data);
387 packet_destroy(pkt, NULL);
388 } else {
389
390
391
392
393
394 trace_colo_compare_main("packet different");
395 qemu_mutex_lock(&s->timer_check_lock);
396 g_queue_push_tail(&conn->primary_list, pkt);
397 qemu_mutex_unlock(&s->timer_check_lock);
398
399 break;
400 }
401 }
402}
403
404static int compare_chr_send(CharBackend *out,
405 const uint8_t *buf,
406 uint32_t size)
407{
408 int ret = 0;
409 uint32_t len = htonl(size);
410
411 if (!size) {
412 return 0;
413 }
414
415 ret = qemu_chr_fe_write_all(out, (uint8_t *)&len, sizeof(len));
416 if (ret != sizeof(len)) {
417 goto err;
418 }
419
420 ret = qemu_chr_fe_write_all(out, (uint8_t *)buf, size);
421 if (ret != size) {
422 goto err;
423 }
424
425 return 0;
426
427err:
428 return ret < 0 ? ret : -EIO;
429}
430
431static int compare_chr_can_read(void *opaque)
432{
433 return COMPARE_READ_LEN_MAX;
434}
435
436
437
438
439
440static void compare_pri_chr_in(void *opaque, const uint8_t *buf, int size)
441{
442 CompareState *s = COLO_COMPARE(opaque);
443 int ret;
444
445 ret = net_fill_rstate(&s->pri_rs, buf, size);
446 if (ret == -1) {
447 qemu_chr_fe_set_handlers(&s->chr_pri_in, NULL, NULL, NULL,
448 NULL, NULL, true);
449 error_report("colo-compare primary_in error");
450 }
451}
452
453
454
455
456
457static void compare_sec_chr_in(void *opaque, const uint8_t *buf, int size)
458{
459 CompareState *s = COLO_COMPARE(opaque);
460 int ret;
461
462 ret = net_fill_rstate(&s->sec_rs, buf, size);
463 if (ret == -1) {
464 qemu_chr_fe_set_handlers(&s->chr_sec_in, NULL, NULL, NULL,
465 NULL, NULL, true);
466 error_report("colo-compare secondary_in error");
467 }
468}
469
470static void *colo_compare_thread(void *opaque)
471{
472 GMainContext *worker_context;
473 GMainLoop *compare_loop;
474 CompareState *s = opaque;
475
476 worker_context = g_main_context_new();
477
478 qemu_chr_fe_set_handlers(&s->chr_pri_in, compare_chr_can_read,
479 compare_pri_chr_in, NULL, s, worker_context, true);
480 qemu_chr_fe_set_handlers(&s->chr_sec_in, compare_chr_can_read,
481 compare_sec_chr_in, NULL, s, worker_context, true);
482
483 compare_loop = g_main_loop_new(worker_context, FALSE);
484
485 g_main_loop_run(compare_loop);
486
487 g_main_loop_unref(compare_loop);
488 g_main_context_unref(worker_context);
489 return NULL;
490}
491
492static char *compare_get_pri_indev(Object *obj, Error **errp)
493{
494 CompareState *s = COLO_COMPARE(obj);
495
496 return g_strdup(s->pri_indev);
497}
498
499static void compare_set_pri_indev(Object *obj, const char *value, Error **errp)
500{
501 CompareState *s = COLO_COMPARE(obj);
502
503 g_free(s->pri_indev);
504 s->pri_indev = g_strdup(value);
505}
506
507static char *compare_get_sec_indev(Object *obj, Error **errp)
508{
509 CompareState *s = COLO_COMPARE(obj);
510
511 return g_strdup(s->sec_indev);
512}
513
514static void compare_set_sec_indev(Object *obj, const char *value, Error **errp)
515{
516 CompareState *s = COLO_COMPARE(obj);
517
518 g_free(s->sec_indev);
519 s->sec_indev = g_strdup(value);
520}
521
522static char *compare_get_outdev(Object *obj, Error **errp)
523{
524 CompareState *s = COLO_COMPARE(obj);
525
526 return g_strdup(s->outdev);
527}
528
529static void compare_set_outdev(Object *obj, const char *value, Error **errp)
530{
531 CompareState *s = COLO_COMPARE(obj);
532
533 g_free(s->outdev);
534 s->outdev = g_strdup(value);
535}
536
537static void compare_pri_rs_finalize(SocketReadState *pri_rs)
538{
539 CompareState *s = container_of(pri_rs, CompareState, pri_rs);
540
541 if (packet_enqueue(s, PRIMARY_IN)) {
542 trace_colo_compare_main("primary: unsupported packet in");
543 compare_chr_send(&s->chr_out, pri_rs->buf, pri_rs->packet_len);
544 } else {
545
546 g_queue_foreach(&s->conn_list, colo_compare_connection, s);
547 }
548}
549
550static void compare_sec_rs_finalize(SocketReadState *sec_rs)
551{
552 CompareState *s = container_of(sec_rs, CompareState, sec_rs);
553
554 if (packet_enqueue(s, SECONDARY_IN)) {
555 trace_colo_compare_main("secondary: unsupported packet in");
556 } else {
557
558 g_queue_foreach(&s->conn_list, colo_compare_connection, s);
559 }
560}
561
562
563
564
565
566
567static int find_and_check_chardev(CharDriverState **chr,
568 char *chr_name,
569 Error **errp)
570{
571 *chr = qemu_chr_find(chr_name);
572 if (*chr == NULL) {
573 error_setg(errp, "Device '%s' not found",
574 chr_name);
575 return 1;
576 }
577
578 if (!qemu_chr_has_feature(*chr, QEMU_CHAR_FEATURE_RECONNECTABLE)) {
579 error_setg(errp, "chardev \"%s\" is not reconnectable",
580 chr_name);
581 return 1;
582 }
583
584 return 0;
585}
586
587
588
589
590
591static void check_old_packet_regular(void *opaque)
592{
593 CompareState *s = opaque;
594
595 timer_mod(s->timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) +
596 REGULAR_PACKET_CHECK_MS);
597
598
599
600
601
602 qemu_mutex_lock(&s->timer_check_lock);
603 colo_old_packet_check(s);
604 qemu_mutex_unlock(&s->timer_check_lock);
605}
606
607
608
609
610
611static void colo_compare_complete(UserCreatable *uc, Error **errp)
612{
613 CompareState *s = COLO_COMPARE(uc);
614 CharDriverState *chr;
615 char thread_name[64];
616 static int compare_id;
617
618 if (!s->pri_indev || !s->sec_indev || !s->outdev) {
619 error_setg(errp, "colo compare needs 'primary_in' ,"
620 "'secondary_in','outdev' property set");
621 return;
622 } else if (!strcmp(s->pri_indev, s->outdev) ||
623 !strcmp(s->sec_indev, s->outdev) ||
624 !strcmp(s->pri_indev, s->sec_indev)) {
625 error_setg(errp, "'indev' and 'outdev' could not be same "
626 "for compare module");
627 return;
628 }
629
630 if (find_and_check_chardev(&chr, s->pri_indev, errp) ||
631 !qemu_chr_fe_init(&s->chr_pri_in, chr, errp)) {
632 return;
633 }
634
635 if (find_and_check_chardev(&chr, s->sec_indev, errp) ||
636 !qemu_chr_fe_init(&s->chr_sec_in, chr, errp)) {
637 return;
638 }
639
640 if (find_and_check_chardev(&chr, s->outdev, errp) ||
641 !qemu_chr_fe_init(&s->chr_out, chr, errp)) {
642 return;
643 }
644
645 net_socket_rs_init(&s->pri_rs, compare_pri_rs_finalize);
646 net_socket_rs_init(&s->sec_rs, compare_sec_rs_finalize);
647
648 g_queue_init(&s->conn_list);
649 qemu_mutex_init(&s->timer_check_lock);
650
651 s->connection_track_table = g_hash_table_new_full(connection_key_hash,
652 connection_key_equal,
653 g_free,
654 connection_destroy);
655
656 sprintf(thread_name, "colo-compare %d", compare_id);
657 qemu_thread_create(&s->thread, thread_name,
658 colo_compare_thread, s,
659 QEMU_THREAD_JOINABLE);
660 compare_id++;
661
662
663 s->timer = timer_new_ms(QEMU_CLOCK_VIRTUAL,
664 check_old_packet_regular, s);
665 timer_mod(s->timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) +
666 REGULAR_PACKET_CHECK_MS);
667
668 return;
669}
670
671static void colo_compare_class_init(ObjectClass *oc, void *data)
672{
673 UserCreatableClass *ucc = USER_CREATABLE_CLASS(oc);
674
675 ucc->complete = colo_compare_complete;
676}
677
678static void colo_compare_init(Object *obj)
679{
680 object_property_add_str(obj, "primary_in",
681 compare_get_pri_indev, compare_set_pri_indev,
682 NULL);
683 object_property_add_str(obj, "secondary_in",
684 compare_get_sec_indev, compare_set_sec_indev,
685 NULL);
686 object_property_add_str(obj, "outdev",
687 compare_get_outdev, compare_set_outdev,
688 NULL);
689}
690
691static void colo_compare_finalize(Object *obj)
692{
693 CompareState *s = COLO_COMPARE(obj);
694
695 qemu_chr_fe_deinit(&s->chr_pri_in);
696 qemu_chr_fe_deinit(&s->chr_sec_in);
697 qemu_chr_fe_deinit(&s->chr_out);
698
699 g_queue_free(&s->conn_list);
700
701 if (qemu_thread_is_self(&s->thread)) {
702
703 g_queue_foreach(&s->conn_list, colo_compare_connection, s);
704 qemu_thread_join(&s->thread);
705 }
706
707 if (s->timer) {
708 timer_del(s->timer);
709 }
710
711 qemu_mutex_destroy(&s->timer_check_lock);
712
713 g_free(s->pri_indev);
714 g_free(s->sec_indev);
715 g_free(s->outdev);
716}
717
718static const TypeInfo colo_compare_info = {
719 .name = TYPE_COLO_COMPARE,
720 .parent = TYPE_OBJECT,
721 .instance_size = sizeof(CompareState),
722 .instance_init = colo_compare_init,
723 .instance_finalize = colo_compare_finalize,
724 .class_size = sizeof(CompareClass),
725 .class_init = colo_compare_class_init,
726 .interfaces = (InterfaceInfo[]) {
727 { TYPE_USER_CREATABLE },
728 { }
729 }
730};
731
732static void register_types(void)
733{
734 type_register_static(&colo_compare_info);
735}
736
737type_init(register_types);
738