| 1 | The following changes since commit e607bbee553cfe73072870cef458cfa4e78133e2: | 1 | The following changes since commit 90218a9a393c7925f330e7dcc08658e2a01d3bd4: |
|---|---|---|---|
| 2 | 2 | ||
| 3 | Merge remote-tracking branch 'remotes/edgar/tags/edgar/xilinx-next-2018-01-26.for-upstream' into staging (2018-01-26 14:24:25 +0000) | 3 | Merge remote-tracking branch 'remotes/huth-gitlab/tags/pull-request-2020-07-21' into staging (2020-07-21 10:24:38 +0100) |
| 4 | 4 | ||
| 5 | are available in the git repository at: | 5 | are available in the git repository at: |
| 6 | 6 | ||
| 7 | https://github.com/jasowang/qemu.git tags/net-pull-request | 7 | https://github.com/jasowang/qemu.git tags/net-pull-request |
| 8 | 8 | ||
| 9 | for you to fetch changes up to bf4835a4d5338bb7424827715df22570a8adc67c: | 9 | for you to fetch changes up to 5519724a13664b43e225ca05351c60b4468e4555: |
| 10 | 10 | ||
| 11 | MAINTAINERS: update Dmitry Fleytman email (2018-01-29 16:05:38 +0800) | 11 | hw/net/xgmac: Fix buffer overflow in xgmac_enet_send() (2020-07-21 21:30:39 +0800) |
| 12 | 12 | ||
| 13 | ---------------------------------------------------------------- | 13 | ---------------------------------------------------------------- |
| 14 | 14 | ||
| 15 | ---------------------------------------------------------------- | 15 | ---------------------------------------------------------------- |
| 16 | Mao Zhongyi (2): | 16 | Andrew (1): |
| 17 | colo: modified the payload compare function | 17 | hw/net: Added plen fix for IPv6 |
| 18 | colo: compare the packet based on the tcp sequence number | ||
| 19 | 18 | ||
| 20 | Philippe Mathieu-Daudé (1): | 19 | Mauro Matteo Cascella (1): |
| 21 | MAINTAINERS: update Dmitry Fleytman email | 20 | hw/net/xgmac: Fix buffer overflow in xgmac_enet_send() |
| 22 | 21 | ||
| 23 | Thomas Huth (3): | 22 | hw/net/net_tx_pkt.c | 23 +++++++++++++++++++++++ |
| 24 | net: Allow hubports to connect to other netdevs | 23 | hw/net/net_tx_pkt.h | 14 ++++++++++++++ |
| 25 | net: Allow netdevs to be used with 'hostfwd_add' and 'hostfwd_remove' | 24 | hw/net/xgmac.c | 14 ++++++++++++-- |
| 26 | qemu-doc: Get rid of "vlan=X" example in the documentation | 25 | include/net/eth.h | 1 + |
| 27 | 26 | 4 files changed, 50 insertions(+), 2 deletions(-) | |
| 28 | MAINTAINERS | 8 +- | ||
| 29 | hmp-commands.hx | 4 +- | ||
| 30 | net/colo-compare.c | 411 +++++++++++++++++++++++++++++++++-------------------- | ||
| 31 | net/colo.c | 9 ++ | ||
| 32 | net/colo.h | 15 ++ | ||
| 33 | net/hub.c | 27 +++- | ||
| 34 | net/hub.h | 3 +- | ||
| 35 | net/net.c | 2 +- | ||
| 36 | net/slirp.c | 33 +++-- | ||
| 37 | net/trace-events | 2 +- | ||
| 38 | qapi/net.json | 4 +- | ||
| 39 | qemu-options.hx | 12 +- | ||
| 40 | 12 files changed, 347 insertions(+), 183 deletions(-) | ||
| 41 | 27 | ||
| 42 | 28 | diff view generated by jsdifflib |
Deleted patch | |||
|---|---|---|---|
| 1 | From: Mao Zhongyi <maozy.fnst@cn.fujitsu.com> | ||
| 2 | 1 | ||
| 3 | Modified the function colo_packet_compare_common to prepare for the | ||
| 4 | tcp packet comparison in the next patch. | ||
| 5 | |||
| 6 | Cc: Zhang Chen <zhangckid@gmail.com> | ||
| 7 | Cc: Li Zhijian <lizhijian@cn.fujitsu.com> | ||
| 8 | Cc: Jason Wang <jasowang@redhat.com> | ||
| 9 | |||
| 10 | Signed-off-by: Mao Zhongyi <maozy.fnst@cn.fujitsu.com> | ||
| 11 | Signed-off-by: Li Zhijian <lizhijian@cn.fujitsu.com> | ||
| 12 | Signed-off-by: Zhang Chen <zhangckid@gmail.com> | ||
| 13 | Reviewed-by: Zhang Chen <zhangckid@gmail.com> | ||
| 14 | Signed-off-by: Jason Wang <jasowang@redhat.com> | ||
| 15 | --- | ||
| 16 | net/colo-compare.c | 88 +++++++++++++++++++++++++++--------------------------- | ||
| 17 | 1 file changed, 44 insertions(+), 44 deletions(-) | ||
| 18 | |||
| 19 | diff --git a/net/colo-compare.c b/net/colo-compare.c | ||
| 20 | index XXXXXXX..XXXXXXX 100644 | ||
| 21 | --- a/net/colo-compare.c | ||
| 22 | +++ b/net/colo-compare.c | ||
| 23 | @@ -XXX,XX +XXX,XX @@ static int packet_enqueue(CompareState *s, int mode, Connection **con) | ||
| 24 | * return: 0 means packet same | ||
| 25 | * > 0 || < 0 means packet different | ||
| 26 | */ | ||
| 27 | -static int colo_packet_compare_common(Packet *ppkt, | ||
| 28 | - Packet *spkt, | ||
| 29 | - int poffset, | ||
| 30 | - int soffset) | ||
| 31 | +static int colo_compare_packet_payload(Packet *ppkt, | ||
| 32 | + Packet *spkt, | ||
| 33 | + uint16_t poffset, | ||
| 34 | + uint16_t soffset, | ||
| 35 | + uint16_t len) | ||
| 36 | + | ||
| 37 | { | ||
| 38 | if (trace_event_get_state_backends(TRACE_COLO_COMPARE_MISCOMPARE)) { | ||
| 39 | char pri_ip_src[20], pri_ip_dst[20], sec_ip_src[20], sec_ip_dst[20]; | ||
| 40 | @@ -XXX,XX +XXX,XX @@ static int colo_packet_compare_common(Packet *ppkt, | ||
| 41 | sec_ip_src, sec_ip_dst); | ||
| 42 | } | ||
| 43 | |||
| 44 | - poffset = ppkt->vnet_hdr_len + poffset; | ||
| 45 | - soffset = ppkt->vnet_hdr_len + soffset; | ||
| 46 | - | ||
| 47 | - if (ppkt->size - poffset == spkt->size - soffset) { | ||
| 48 | - return memcmp(ppkt->data + poffset, | ||
| 49 | - spkt->data + soffset, | ||
| 50 | - spkt->size - soffset); | ||
| 51 | - } else { | ||
| 52 | - trace_colo_compare_main("Net packet size are not the same"); | ||
| 53 | - return -1; | ||
| 54 | - } | ||
| 55 | + return memcmp(ppkt->data + poffset, spkt->data + soffset, len); | ||
| 56 | } | ||
| 57 | |||
| 58 | /* | ||
| 59 | @@ -XXX,XX +XXX,XX @@ static int colo_packet_compare_tcp(Packet *spkt, Packet *ppkt) | ||
| 60 | * the secondary guest's timestamp. COLO just focus on payload, | ||
| 61 | * so we just need skip this field. | ||
| 62 | */ | ||
| 63 | - if (ptcp->th_off > 5) { | ||
| 64 | - ptrdiff_t ptcp_offset, stcp_offset; | ||
| 65 | |||
| 66 | - ptcp_offset = ppkt->transport_header - (uint8_t *)ppkt->data | ||
| 67 | - + (ptcp->th_off * 4) - ppkt->vnet_hdr_len; | ||
| 68 | - stcp_offset = spkt->transport_header - (uint8_t *)spkt->data | ||
| 69 | - + (stcp->th_off * 4) - spkt->vnet_hdr_len; | ||
| 70 | + ptrdiff_t ptcp_offset, stcp_offset; | ||
| 71 | |||
| 72 | - /* | ||
| 73 | - * When network is busy, some tcp options(like sack) will unpredictable | ||
| 74 | - * occur in primary side or secondary side. it will make packet size | ||
| 75 | - * not same, but the two packet's payload is identical. colo just | ||
| 76 | - * care about packet payload, so we skip the option field. | ||
| 77 | - */ | ||
| 78 | - res = colo_packet_compare_common(ppkt, spkt, ptcp_offset, stcp_offset); | ||
| 79 | - } else if (ptcp->th_sum == stcp->th_sum) { | ||
| 80 | - res = colo_packet_compare_common(ppkt, spkt, ETH_HLEN, ETH_HLEN); | ||
| 81 | + ptcp_offset = ppkt->transport_header - (uint8_t *)ppkt->data | ||
| 82 | + + (ptcp->th_off << 2) - ppkt->vnet_hdr_len; | ||
| 83 | + stcp_offset = spkt->transport_header - (uint8_t *)spkt->data | ||
| 84 | + + (stcp->th_off << 2) - spkt->vnet_hdr_len; | ||
| 85 | + if (ppkt->size - ptcp_offset == spkt->size - stcp_offset) { | ||
| 86 | + res = colo_compare_packet_payload(ppkt, spkt, | ||
| 87 | + ptcp_offset, stcp_offset, | ||
| 88 | + ppkt->size - ptcp_offset); | ||
| 89 | } else { | ||
| 90 | + trace_colo_compare_main("TCP: payload size of packets are different"); | ||
| 91 | res = -1; | ||
| 92 | } | ||
| 93 | |||
| 94 | @@ -XXX,XX +XXX,XX @@ static int colo_packet_compare_tcp(Packet *spkt, Packet *ppkt) | ||
| 95 | */ | ||
| 96 | static int colo_packet_compare_udp(Packet *spkt, Packet *ppkt) | ||
| 97 | { | ||
| 98 | - int ret; | ||
| 99 | - int network_header_length = ppkt->ip->ip_hl * 4; | ||
| 100 | + uint16_t network_header_length = ppkt->ip->ip_hl << 2; | ||
| 101 | + uint16_t offset = network_header_length + ETH_HLEN + ppkt->vnet_hdr_len; | ||
| 102 | |||
| 103 | trace_colo_compare_main("compare udp"); | ||
| 104 | |||
| 105 | @@ -XXX,XX +XXX,XX @@ static int colo_packet_compare_udp(Packet *spkt, Packet *ppkt) | ||
| 106 | * other field like TOS,TTL,IP Checksum. we only need to compare | ||
| 107 | * the ip payload here. | ||
| 108 | */ | ||
| 109 | - ret = colo_packet_compare_common(ppkt, spkt, | ||
| 110 | - network_header_length + ETH_HLEN, | ||
| 111 | - network_header_length + ETH_HLEN); | ||
| 112 | - | ||
| 113 | - if (ret) { | ||
| 114 | + if (ppkt->size != spkt->size) { | ||
| 115 | + trace_colo_compare_main("UDP: payload size of packets are different"); | ||
| 116 | + return -1; | ||
| 117 | + } | ||
| 118 | + if (colo_compare_packet_payload(ppkt, spkt, offset, offset, | ||
| 119 | + ppkt->size - offset)) { | ||
| 120 | trace_colo_compare_udp_miscompare("primary pkt size", ppkt->size); | ||
| 121 | trace_colo_compare_udp_miscompare("Secondary pkt size", spkt->size); | ||
| 122 | if (trace_event_get_state_backends(TRACE_COLO_COMPARE_MISCOMPARE)) { | ||
| 123 | @@ -XXX,XX +XXX,XX @@ static int colo_packet_compare_udp(Packet *spkt, Packet *ppkt) | ||
| 124 | qemu_hexdump((char *)spkt->data, stderr, "colo-compare sec pkt", | ||
| 125 | spkt->size); | ||
| 126 | } | ||
| 127 | + return -1; | ||
| 128 | + } else { | ||
| 129 | + return 0; | ||
| 130 | } | ||
| 131 | - | ||
| 132 | - return ret; | ||
| 133 | } | ||
| 134 | |||
| 135 | /* | ||
| 136 | @@ -XXX,XX +XXX,XX @@ static int colo_packet_compare_udp(Packet *spkt, Packet *ppkt) | ||
| 137 | */ | ||
| 138 | static int colo_packet_compare_icmp(Packet *spkt, Packet *ppkt) | ||
| 139 | { | ||
| 140 | - int network_header_length = ppkt->ip->ip_hl * 4; | ||
| 141 | + uint16_t network_header_length = ppkt->ip->ip_hl << 2; | ||
| 142 | + uint16_t offset = network_header_length + ETH_HLEN + ppkt->vnet_hdr_len; | ||
| 143 | |||
| 144 | trace_colo_compare_main("compare icmp"); | ||
| 145 | |||
| 146 | @@ -XXX,XX +XXX,XX @@ static int colo_packet_compare_icmp(Packet *spkt, Packet *ppkt) | ||
| 147 | * other field like TOS,TTL,IP Checksum. we only need to compare | ||
| 148 | * the ip payload here. | ||
| 149 | */ | ||
| 150 | - if (colo_packet_compare_common(ppkt, spkt, | ||
| 151 | - network_header_length + ETH_HLEN, | ||
| 152 | - network_header_length + ETH_HLEN)) { | ||
| 153 | + if (ppkt->size != spkt->size) { | ||
| 154 | + trace_colo_compare_main("ICMP: payload size of packets are different"); | ||
| 155 | + return -1; | ||
| 156 | + } | ||
| 157 | + if (colo_compare_packet_payload(ppkt, spkt, offset, offset, | ||
| 158 | + ppkt->size - offset)) { | ||
| 159 | trace_colo_compare_icmp_miscompare("primary pkt size", | ||
| 160 | ppkt->size); | ||
| 161 | trace_colo_compare_icmp_miscompare("Secondary pkt size", | ||
| 162 | @@ -XXX,XX +XXX,XX @@ static int colo_packet_compare_icmp(Packet *spkt, Packet *ppkt) | ||
| 163 | */ | ||
| 164 | static int colo_packet_compare_other(Packet *spkt, Packet *ppkt) | ||
| 165 | { | ||
| 166 | + uint16_t offset = ppkt->vnet_hdr_len; | ||
| 167 | + | ||
| 168 | trace_colo_compare_main("compare other"); | ||
| 169 | if (trace_event_get_state_backends(TRACE_COLO_COMPARE_MISCOMPARE)) { | ||
| 170 | char pri_ip_src[20], pri_ip_dst[20], sec_ip_src[20], sec_ip_dst[20]; | ||
| 171 | @@ -XXX,XX +XXX,XX @@ static int colo_packet_compare_other(Packet *spkt, Packet *ppkt) | ||
| 172 | sec_ip_src, sec_ip_dst); | ||
| 173 | } | ||
| 174 | |||
| 175 | - return colo_packet_compare_common(ppkt, spkt, 0, 0); | ||
| 176 | + if (ppkt->size != spkt->size) { | ||
| 177 | + trace_colo_compare_main("Other: payload size of packets are different"); | ||
| 178 | + return -1; | ||
| 179 | + } | ||
| 180 | + return colo_compare_packet_payload(ppkt, spkt, offset, offset, | ||
| 181 | + ppkt->size - offset); | ||
| 182 | } | ||
| 183 | |||
| 184 | static int colo_old_packet_check_one(Packet *pkt, int64_t *check_time) | ||
| 185 | -- | ||
| 186 | 2.7.4 | ||
| 187 | |||
| 188 | diff view generated by jsdifflib |
| 1 | From: Mao Zhongyi <maozy.fnst@cn.fujitsu.com> | 1 | From: Andrew <andrew@daynix.com> |
|---|---|---|---|
| 2 | 2 | ||
| 3 | Packet size some time different or when network is busy. | 3 | Buglink: https://bugzilla.redhat.com/show_bug.cgi?id=1708065 |
| 4 | Based on same payload size, but TCP protocol can not | 4 | With network backend with 'virtual header' - there was an issue |
| 5 | guarantee send the same one packet in the same way, | 5 | in 'plen' field. Overall, during TSO, 'plen' would be changed, |
| 6 | but with 'vheader' this field should be set to the size of the | ||
| 7 | payload itself instead of '0'. | ||
| 6 | 8 | ||
| 7 | like that: | 9 | Signed-off-by: Andrew Melnychenko <andrew@daynix.com> |
| 8 | We send this payload: | ||
| 9 | ------------------------------ | ||
| 10 | | header |1|2|3|4|5|6|7|8|9|0| | ||
| 11 | ------------------------------ | ||
| 12 | |||
| 13 | primary: | ||
| 14 | ppkt1: | ||
| 15 | ---------------- | ||
| 16 | | header |1|2|3| | ||
| 17 | ---------------- | ||
| 18 | ppkt2: | ||
| 19 | ------------------------ | ||
| 20 | | header |4|5|6|7|8|9|0| | ||
| 21 | ------------------------ | ||
| 22 | |||
| 23 | secondary: | ||
| 24 | spkt1: | ||
| 25 | ------------------------------ | ||
| 26 | | header |1|2|3|4|5|6|7|8|9|0| | ||
| 27 | ------------------------------ | ||
| 28 | |||
| 29 | In the original method, ppkt1 and ppkt2 are different in size and | ||
| 30 | spkt1, so they can't compare and trigger the checkpoint. | ||
| 31 | |||
| 32 | I have tested FTP get 200M and 1G file many times, I found that | ||
| 33 | the performance was less than 1% of the native. | ||
| 34 | |||
| 35 | Now I reconstructed the comparison of TCP packets based on the | ||
| 36 | TCP sequence number. first of all, ppkt1 and spkt1 have the same | ||
| 37 | starting sequence number, so they can compare, even though their | ||
| 38 | length is different. And then ppkt1 with a smaller payload length | ||
| 39 | is used as the comparison length, if the payload is same, send | ||
| 40 | out the ppkt1 and record the offset(the length of ppkt1 payload) | ||
| 41 | in spkt1. The next comparison, ppkt2 and spkt1 can be compared | ||
| 42 | from the recorded position of spkt1. | ||
| 43 | |||
| 44 | like that: | ||
| 45 | ---------------- | ||
| 46 | | header |1|2|3| ppkt1 | ||
| 47 | ---------|-----| | ||
| 48 | | | | ||
| 49 | ---------v-----v-------------- | ||
| 50 | | header |1|2|3|4|5|6|7|8|9|0| spkt1 | ||
| 51 | ---------------|\------------| | ||
| 52 | | \offset | | ||
| 53 | ---------v-------------v | ||
| 54 | | header |4|5|6|7|8|9|0| ppkt2 | ||
| 55 | ------------------------ | ||
| 56 | |||
| 57 | In this way, the performance can reach native 20% in my multiple | ||
| 58 | tests. | ||
| 59 | |||
| 60 | Cc: Zhang Chen <zhangckid@gmail.com> | ||
| 61 | Cc: Li Zhijian <lizhijian@cn.fujitsu.com> | ||
| 62 | Cc: Jason Wang <jasowang@redhat.com> | ||
| 63 | |||
| 64 | Signed-off-by: Mao Zhongyi <maozy.fnst@cn.fujitsu.com> | ||
| 65 | Signed-off-by: Li Zhijian <lizhijian@cn.fujitsu.com> | ||
| 66 | Signed-off-by: Zhang Chen <zhangckid@gmail.com> | ||
| 67 | Reviewed-by: Zhang Chen <zhangckid@gmail.com> | ||
| 68 | Tested-by: Zhang Chen <zhangckid@gmail.com> | ||
| 69 | Signed-off-by: Jason Wang <jasowang@redhat.com> | 10 | Signed-off-by: Jason Wang <jasowang@redhat.com> |
| 70 | --- | 11 | --- |
| 71 | net/colo-compare.c | 343 +++++++++++++++++++++++++++++++++++------------------ | 12 | hw/net/net_tx_pkt.c | 23 +++++++++++++++++++++++ |
| 72 | net/colo.c | 9 ++ | 13 | hw/net/net_tx_pkt.h | 14 ++++++++++++++ |
| 73 | net/colo.h | 15 +++ | 14 | include/net/eth.h | 1 + |
| 74 | net/trace-events | 2 +- | 15 | 3 files changed, 38 insertions(+) |
| 75 | 4 files changed, 250 insertions(+), 119 deletions(-) | ||
| 76 | 16 | ||
| 77 | diff --git a/net/colo-compare.c b/net/colo-compare.c | 17 | diff --git a/hw/net/net_tx_pkt.c b/hw/net/net_tx_pkt.c |
| 78 | index XXXXXXX..XXXXXXX 100644 | 18 | index XXXXXXX..XXXXXXX 100644 |
| 79 | --- a/net/colo-compare.c | 19 | --- a/hw/net/net_tx_pkt.c |
| 80 | +++ b/net/colo-compare.c | 20 | +++ b/hw/net/net_tx_pkt.c |
| 81 | @@ -XXX,XX +XXX,XX @@ | 21 | @@ -XXX,XX +XXX,XX @@ bool net_tx_pkt_send(struct NetTxPkt *pkt, NetClientState *nc) |
| 82 | #define COMPARE_READ_LEN_MAX NET_BUFSIZE | 22 | |
| 83 | #define MAX_QUEUE_SIZE 1024 | 23 | if (pkt->has_virt_hdr || |
| 84 | 24 | pkt->virt_hdr.gso_type == VIRTIO_NET_HDR_GSO_NONE) { | |
| 85 | +#define COLO_COMPARE_FREE_PRIMARY 0x01 | 25 | + net_tx_pkt_fix_ip6_payload_len(pkt); |
| 86 | +#define COLO_COMPARE_FREE_SECONDARY 0x02 | 26 | net_tx_pkt_sendv(pkt, nc, pkt->vec, |
| 27 | pkt->payload_frags + NET_TX_PKT_PL_START_FRAG); | ||
| 28 | return true; | ||
| 29 | @@ -XXX,XX +XXX,XX @@ bool net_tx_pkt_send_loopback(struct NetTxPkt *pkt, NetClientState *nc) | ||
| 30 | |||
| 31 | return res; | ||
| 32 | } | ||
| 87 | + | 33 | + |
| 88 | /* TODO: Should be configurable */ | 34 | +void net_tx_pkt_fix_ip6_payload_len(struct NetTxPkt *pkt) |
| 89 | #define REGULAR_PACKET_CHECK_MS 3000 | ||
| 90 | |||
| 91 | @@ -XXX,XX +XXX,XX @@ static gint seq_sorter(Packet *a, Packet *b, gpointer data) | ||
| 92 | return ntohl(atcp->th_seq) - ntohl(btcp->th_seq); | ||
| 93 | } | ||
| 94 | |||
| 95 | +static void fill_pkt_tcp_info(void *data, uint32_t *max_ack) | ||
| 96 | +{ | 35 | +{ |
| 97 | + Packet *pkt = data; | 36 | + struct iovec *l2 = &pkt->vec[NET_TX_PKT_L2HDR_FRAG]; |
| 98 | + struct tcphdr *tcphd; | 37 | + if (eth_get_l3_proto(l2, 1, l2->iov_len) == ETH_P_IPV6) { |
| 99 | + | 38 | + struct ip6_header *ip6 = (struct ip6_header *) pkt->l3_hdr; |
| 100 | + tcphd = (struct tcphdr *)pkt->transport_header; | 39 | + /* |
| 101 | + | 40 | + * TODO: if qemu would support >64K packets - add jumbo option check |
| 102 | + pkt->tcp_seq = ntohl(tcphd->th_seq); | 41 | + * something like that: |
| 103 | + pkt->tcp_ack = ntohl(tcphd->th_ack); | 42 | + * 'if (ip6->ip6_plen == 0 && !has_jumbo_option(ip6)) {' |
| 104 | + *max_ack = *max_ack > pkt->tcp_ack ? *max_ack : pkt->tcp_ack; | 43 | + */ |
| 105 | + pkt->header_size = pkt->transport_header - (uint8_t *)pkt->data | 44 | + if (ip6->ip6_plen == 0) { |
| 106 | + + (tcphd->th_off << 2) - pkt->vnet_hdr_len; | 45 | + if (pkt->payload_len <= ETH_MAX_IP_DGRAM_LEN) { |
| 107 | + pkt->payload_size = pkt->size - pkt->header_size; | 46 | + ip6->ip6_plen = htons(pkt->payload_len); |
| 108 | + pkt->seq_end = pkt->tcp_seq + pkt->payload_size; | 47 | + } |
| 109 | + pkt->flags = tcphd->th_flags; | 48 | + /* |
| 110 | +} | 49 | + * TODO: if qemu would support >64K packets |
| 111 | + | 50 | + * add jumbo option for packets greater then 65,535 bytes |
| 112 | /* | 51 | + */ |
| 113 | * Return 1 on success, if return 0 means the | ||
| 114 | * packet will be dropped | ||
| 115 | */ | ||
| 116 | -static int colo_insert_packet(GQueue *queue, Packet *pkt) | ||
| 117 | +static int colo_insert_packet(GQueue *queue, Packet *pkt, uint32_t *max_ack) | ||
| 118 | { | ||
| 119 | if (g_queue_get_length(queue) <= MAX_QUEUE_SIZE) { | ||
| 120 | if (pkt->ip->ip_p == IPPROTO_TCP) { | ||
| 121 | + fill_pkt_tcp_info(pkt, max_ack); | ||
| 122 | g_queue_insert_sorted(queue, | ||
| 123 | pkt, | ||
| 124 | (GCompareDataFunc)seq_sorter, | ||
| 125 | @@ -XXX,XX +XXX,XX @@ static int packet_enqueue(CompareState *s, int mode, Connection **con) | ||
| 126 | } | ||
| 127 | |||
| 128 | if (mode == PRIMARY_IN) { | ||
| 129 | - if (!colo_insert_packet(&conn->primary_list, pkt)) { | ||
| 130 | + if (!colo_insert_packet(&conn->primary_list, pkt, &conn->pack)) { | ||
| 131 | error_report("colo compare primary queue size too big," | ||
| 132 | "drop packet"); | ||
| 133 | } | ||
| 134 | } else { | ||
| 135 | - if (!colo_insert_packet(&conn->secondary_list, pkt)) { | ||
| 136 | + if (!colo_insert_packet(&conn->secondary_list, pkt, &conn->sack)) { | ||
| 137 | error_report("colo compare secondary queue size too big," | ||
| 138 | "drop packet"); | ||
| 139 | } | ||
| 140 | @@ -XXX,XX +XXX,XX @@ static int packet_enqueue(CompareState *s, int mode, Connection **con) | ||
| 141 | return 0; | ||
| 142 | } | ||
| 143 | |||
| 144 | +static inline bool after(uint32_t seq1, uint32_t seq2) | ||
| 145 | +{ | ||
| 146 | + return (int32_t)(seq1 - seq2) > 0; | ||
| 147 | +} | ||
| 148 | + | ||
| 149 | +static void colo_release_primary_pkt(CompareState *s, Packet *pkt) | ||
| 150 | +{ | ||
| 151 | + int ret; | ||
| 152 | + ret = compare_chr_send(s, | ||
| 153 | + pkt->data, | ||
| 154 | + pkt->size, | ||
| 155 | + pkt->vnet_hdr_len); | ||
| 156 | + if (ret < 0) { | ||
| 157 | + error_report("colo send primary packet failed"); | ||
| 158 | + } | ||
| 159 | + trace_colo_compare_main("packet same and release packet"); | ||
| 160 | + packet_destroy(pkt, NULL); | ||
| 161 | +} | ||
| 162 | + | ||
| 163 | /* | ||
| 164 | * The IP packets sent by primary and secondary | ||
| 165 | * will be compared in here | ||
| 166 | @@ -XXX,XX +XXX,XX @@ static int colo_compare_packet_payload(Packet *ppkt, | ||
| 167 | } | ||
| 168 | |||
| 169 | /* | ||
| 170 | - * Called from the compare thread on the primary | ||
| 171 | - * for compare tcp packet | ||
| 172 | - * compare_tcp copied from Dr. David Alan Gilbert's branch | ||
| 173 | - */ | ||
| 174 | -static int colo_packet_compare_tcp(Packet *spkt, Packet *ppkt) | ||
| 175 | + * return true means that the payload is consist and | ||
| 176 | + * need to make the next comparison, false means do | ||
| 177 | + * the checkpoint | ||
| 178 | +*/ | ||
| 179 | +static bool colo_mark_tcp_pkt(Packet *ppkt, Packet *spkt, | ||
| 180 | + int8_t *mark, uint32_t max_ack) | ||
| 181 | { | ||
| 182 | - struct tcphdr *ptcp, *stcp; | ||
| 183 | - int res; | ||
| 184 | + *mark = 0; | ||
| 185 | + | ||
| 186 | + if (ppkt->tcp_seq == spkt->tcp_seq && ppkt->seq_end == spkt->seq_end) { | ||
| 187 | + if (colo_compare_packet_payload(ppkt, spkt, | ||
| 188 | + ppkt->header_size, spkt->header_size, | ||
| 189 | + ppkt->payload_size)) { | ||
| 190 | + *mark = COLO_COMPARE_FREE_SECONDARY | COLO_COMPARE_FREE_PRIMARY; | ||
| 191 | + return true; | ||
| 192 | + } | 52 | + } |
| 193 | + } | 53 | + } |
| 194 | + if (ppkt->tcp_seq == spkt->tcp_seq && ppkt->seq_end == spkt->seq_end) { | 54 | +} |
| 195 | + if (colo_compare_packet_payload(ppkt, spkt, | 55 | diff --git a/hw/net/net_tx_pkt.h b/hw/net/net_tx_pkt.h |
| 196 | + ppkt->header_size, spkt->header_size, | 56 | index XXXXXXX..XXXXXXX 100644 |
| 197 | + ppkt->payload_size)) { | 57 | --- a/hw/net/net_tx_pkt.h |
| 198 | + *mark = COLO_COMPARE_FREE_SECONDARY | COLO_COMPARE_FREE_PRIMARY; | 58 | +++ b/hw/net/net_tx_pkt.h |
| 199 | + return true; | 59 | @@ -XXX,XX +XXX,XX @@ bool net_tx_pkt_parse(struct NetTxPkt *pkt); |
| 200 | + } | 60 | */ |
| 201 | + } | 61 | bool net_tx_pkt_has_fragments(struct NetTxPkt *pkt); |
| 62 | |||
| 63 | +/** | ||
| 64 | + * Fix IPv6 'plen' field. | ||
| 65 | + * If ipv6 payload length field is 0 - then there should be Hop-by-Hop | ||
| 66 | + * option for packets greater than 65,535. | ||
| 67 | + * For packets with a payload less than 65,535: fix 'plen' field. | ||
| 68 | + * For backends with vheader, we need just one packet with proper | ||
| 69 | + * payload size. For now, qemu drops every packet with size greater 64K | ||
| 70 | + * (see net_tx_pkt_send()) so, there is no reason to add jumbo option to ip6 | ||
| 71 | + * hop-by-hop extension if it's missed | ||
| 72 | + * | ||
| 73 | + * @pkt packet | ||
| 74 | + */ | ||
| 75 | +void net_tx_pkt_fix_ip6_payload_len(struct NetTxPkt *pkt); | ||
| 202 | + | 76 | + |
| 203 | + /* one part of secondary packet payload still need to be compared */ | 77 | #endif |
| 204 | + if (!after(ppkt->seq_end, spkt->seq_end)) { | 78 | diff --git a/include/net/eth.h b/include/net/eth.h |
| 205 | + if (colo_compare_packet_payload(ppkt, spkt, | ||
| 206 | + ppkt->header_size + ppkt->offset, | ||
| 207 | + spkt->header_size + spkt->offset, | ||
| 208 | + ppkt->payload_size - ppkt->offset)) { | ||
| 209 | + if (!after(ppkt->tcp_ack, max_ack)) { | ||
| 210 | + *mark = COLO_COMPARE_FREE_PRIMARY; | ||
| 211 | + spkt->offset += ppkt->payload_size - ppkt->offset; | ||
| 212 | + return true; | ||
| 213 | + } else { | ||
| 214 | + /* secondary guest hasn't ack the data, don't send | ||
| 215 | + * out this packet | ||
| 216 | + */ | ||
| 217 | + return false; | ||
| 218 | + } | ||
| 219 | + } | ||
| 220 | + } else { | ||
| 221 | + /* primary packet is longer than secondary packet, compare | ||
| 222 | + * the same part and mark the primary packet offset | ||
| 223 | + */ | ||
| 224 | + if (colo_compare_packet_payload(ppkt, spkt, | ||
| 225 | + ppkt->header_size + ppkt->offset, | ||
| 226 | + spkt->header_size + spkt->offset, | ||
| 227 | + spkt->payload_size - spkt->offset)) { | ||
| 228 | + *mark = COLO_COMPARE_FREE_SECONDARY; | ||
| 229 | + ppkt->offset += spkt->payload_size - spkt->offset; | ||
| 230 | + return true; | ||
| 231 | + } | ||
| 232 | + } | ||
| 233 | |||
| 234 | - trace_colo_compare_main("compare tcp"); | ||
| 235 | + return false; | ||
| 236 | +} | ||
| 237 | |||
| 238 | - ptcp = (struct tcphdr *)ppkt->transport_header; | ||
| 239 | - stcp = (struct tcphdr *)spkt->transport_header; | ||
| 240 | +static void colo_compare_tcp(CompareState *s, Connection *conn) | ||
| 241 | +{ | ||
| 242 | + Packet *ppkt = NULL, *spkt = NULL; | ||
| 243 | + int8_t mark; | ||
| 244 | |||
| 245 | /* | ||
| 246 | - * The 'identification' field in the IP header is *very* random | ||
| 247 | - * it almost never matches. Fudge this by ignoring differences in | ||
| 248 | - * unfragmented packets; they'll normally sort themselves out if different | ||
| 249 | - * anyway, and it should recover at the TCP level. | ||
| 250 | - * An alternative would be to get both the primary and secondary to rewrite | ||
| 251 | - * somehow; but that would need some sync traffic to sync the state | ||
| 252 | - */ | ||
| 253 | - if (ntohs(ppkt->ip->ip_off) & IP_DF) { | ||
| 254 | - spkt->ip->ip_id = ppkt->ip->ip_id; | ||
| 255 | - /* and the sum will be different if the IDs were different */ | ||
| 256 | - spkt->ip->ip_sum = ppkt->ip->ip_sum; | ||
| 257 | + * If ppkt and spkt have the same payload, but ppkt's ACK | ||
| 258 | + * is greater than spkt's ACK, in this case we can not | ||
| 259 | + * send the ppkt because it will cause the secondary guest | ||
| 260 | + * to miss sending some data in the next. Therefore, we | ||
| 261 | + * record the maximum ACK in the current queue at both | ||
| 262 | + * primary side and secondary side. Only when the ack is | ||
| 263 | + * less than the smaller of the two maximum ack, then we | ||
| 264 | + * can ensure that the packet's payload is acknowledged by | ||
| 265 | + * primary and secondary. | ||
| 266 | + */ | ||
| 267 | + uint32_t min_ack = conn->pack > conn->sack ? conn->sack : conn->pack; | ||
| 268 | + | ||
| 269 | +pri: | ||
| 270 | + if (g_queue_is_empty(&conn->primary_list)) { | ||
| 271 | + return; | ||
| 272 | } | ||
| 273 | + ppkt = g_queue_pop_head(&conn->primary_list); | ||
| 274 | +sec: | ||
| 275 | + if (g_queue_is_empty(&conn->secondary_list)) { | ||
| 276 | + g_queue_push_head(&conn->primary_list, ppkt); | ||
| 277 | + return; | ||
| 278 | + } | ||
| 279 | + spkt = g_queue_pop_head(&conn->secondary_list); | ||
| 280 | |||
| 281 | - /* | ||
| 282 | - * Check tcp header length for tcp option field. | ||
| 283 | - * th_off > 5 means this tcp packet have options field. | ||
| 284 | - * The tcp options maybe always different. | ||
| 285 | - * for example: | ||
| 286 | - * From RFC 7323. | ||
| 287 | - * TCP Timestamps option (TSopt): | ||
| 288 | - * Kind: 8 | ||
| 289 | - * | ||
| 290 | - * Length: 10 bytes | ||
| 291 | - * | ||
| 292 | - * +-------+-------+---------------------+---------------------+ | ||
| 293 | - * |Kind=8 | 10 | TS Value (TSval) |TS Echo Reply (TSecr)| | ||
| 294 | - * +-------+-------+---------------------+---------------------+ | ||
| 295 | - * 1 1 4 4 | ||
| 296 | - * | ||
| 297 | - * In this case the primary guest's timestamp always different with | ||
| 298 | - * the secondary guest's timestamp. COLO just focus on payload, | ||
| 299 | - * so we just need skip this field. | ||
| 300 | - */ | ||
| 301 | + if (ppkt->tcp_seq == ppkt->seq_end) { | ||
| 302 | + colo_release_primary_pkt(s, ppkt); | ||
| 303 | + ppkt = NULL; | ||
| 304 | + } | ||
| 305 | |||
| 306 | - ptrdiff_t ptcp_offset, stcp_offset; | ||
| 307 | + if (ppkt && conn->compare_seq && !after(ppkt->seq_end, conn->compare_seq)) { | ||
| 308 | + trace_colo_compare_main("pri: this packet has compared"); | ||
| 309 | + colo_release_primary_pkt(s, ppkt); | ||
| 310 | + ppkt = NULL; | ||
| 311 | + } | ||
| 312 | |||
| 313 | - ptcp_offset = ppkt->transport_header - (uint8_t *)ppkt->data | ||
| 314 | - + (ptcp->th_off << 2) - ppkt->vnet_hdr_len; | ||
| 315 | - stcp_offset = spkt->transport_header - (uint8_t *)spkt->data | ||
| 316 | - + (stcp->th_off << 2) - spkt->vnet_hdr_len; | ||
| 317 | - if (ppkt->size - ptcp_offset == spkt->size - stcp_offset) { | ||
| 318 | - res = colo_compare_packet_payload(ppkt, spkt, | ||
| 319 | - ptcp_offset, stcp_offset, | ||
| 320 | - ppkt->size - ptcp_offset); | ||
| 321 | + if (spkt->tcp_seq == spkt->seq_end) { | ||
| 322 | + packet_destroy(spkt, NULL); | ||
| 323 | + if (!ppkt) { | ||
| 324 | + goto pri; | ||
| 325 | + } else { | ||
| 326 | + goto sec; | ||
| 327 | + } | ||
| 328 | } else { | ||
| 329 | - trace_colo_compare_main("TCP: payload size of packets are different"); | ||
| 330 | - res = -1; | ||
| 331 | + if (conn->compare_seq && !after(spkt->seq_end, conn->compare_seq)) { | ||
| 332 | + trace_colo_compare_main("sec: this packet has compared"); | ||
| 333 | + packet_destroy(spkt, NULL); | ||
| 334 | + if (!ppkt) { | ||
| 335 | + goto pri; | ||
| 336 | + } else { | ||
| 337 | + goto sec; | ||
| 338 | + } | ||
| 339 | + } | ||
| 340 | + if (!ppkt) { | ||
| 341 | + g_queue_push_head(&conn->secondary_list, spkt); | ||
| 342 | + goto pri; | ||
| 343 | + } | ||
| 344 | } | ||
| 345 | |||
| 346 | - if (res != 0 && | ||
| 347 | - trace_event_get_state_backends(TRACE_COLO_COMPARE_MISCOMPARE)) { | ||
| 348 | - char pri_ip_src[20], pri_ip_dst[20], sec_ip_src[20], sec_ip_dst[20]; | ||
| 349 | - | ||
| 350 | - strcpy(pri_ip_src, inet_ntoa(ppkt->ip->ip_src)); | ||
| 351 | - strcpy(pri_ip_dst, inet_ntoa(ppkt->ip->ip_dst)); | ||
| 352 | - strcpy(sec_ip_src, inet_ntoa(spkt->ip->ip_src)); | ||
| 353 | - strcpy(sec_ip_dst, inet_ntoa(spkt->ip->ip_dst)); | ||
| 354 | - | ||
| 355 | - trace_colo_compare_ip_info(ppkt->size, pri_ip_src, | ||
| 356 | - pri_ip_dst, spkt->size, | ||
| 357 | - sec_ip_src, sec_ip_dst); | ||
| 358 | - | ||
| 359 | - trace_colo_compare_tcp_info("pri tcp packet", | ||
| 360 | - ntohl(ptcp->th_seq), | ||
| 361 | - ntohl(ptcp->th_ack), | ||
| 362 | - res, ptcp->th_flags, | ||
| 363 | - ppkt->size); | ||
| 364 | - | ||
| 365 | - trace_colo_compare_tcp_info("sec tcp packet", | ||
| 366 | - ntohl(stcp->th_seq), | ||
| 367 | - ntohl(stcp->th_ack), | ||
| 368 | - res, stcp->th_flags, | ||
| 369 | - spkt->size); | ||
| 370 | + if (colo_mark_tcp_pkt(ppkt, spkt, &mark, min_ack)) { | ||
| 371 | + trace_colo_compare_tcp_info("pri", | ||
| 372 | + ppkt->tcp_seq, ppkt->tcp_ack, | ||
| 373 | + ppkt->header_size, ppkt->payload_size, | ||
| 374 | + ppkt->offset, ppkt->flags); | ||
| 375 | + | ||
| 376 | + trace_colo_compare_tcp_info("sec", | ||
| 377 | + spkt->tcp_seq, spkt->tcp_ack, | ||
| 378 | + spkt->header_size, spkt->payload_size, | ||
| 379 | + spkt->offset, spkt->flags); | ||
| 380 | + | ||
| 381 | + if (mark == COLO_COMPARE_FREE_PRIMARY) { | ||
| 382 | + conn->compare_seq = ppkt->seq_end; | ||
| 383 | + colo_release_primary_pkt(s, ppkt); | ||
| 384 | + g_queue_push_head(&conn->secondary_list, spkt); | ||
| 385 | + goto pri; | ||
| 386 | + } | ||
| 387 | + if (mark == COLO_COMPARE_FREE_SECONDARY) { | ||
| 388 | + conn->compare_seq = spkt->seq_end; | ||
| 389 | + packet_destroy(spkt, NULL); | ||
| 390 | + goto sec; | ||
| 391 | + } | ||
| 392 | + if (mark == (COLO_COMPARE_FREE_PRIMARY | COLO_COMPARE_FREE_SECONDARY)) { | ||
| 393 | + conn->compare_seq = ppkt->seq_end; | ||
| 394 | + colo_release_primary_pkt(s, ppkt); | ||
| 395 | + packet_destroy(spkt, NULL); | ||
| 396 | + goto pri; | ||
| 397 | + } | ||
| 398 | + } else { | ||
| 399 | + g_queue_push_head(&conn->primary_list, ppkt); | ||
| 400 | + g_queue_push_head(&conn->secondary_list, spkt); | ||
| 401 | |||
| 402 | qemu_hexdump((char *)ppkt->data, stderr, | ||
| 403 | "colo-compare ppkt", ppkt->size); | ||
| 404 | qemu_hexdump((char *)spkt->data, stderr, | ||
| 405 | "colo-compare spkt", spkt->size); | ||
| 406 | - } | ||
| 407 | |||
| 408 | - return res; | ||
| 409 | + /* | ||
| 410 | + * colo_compare_inconsistent_notify(); | ||
| 411 | + * TODO: notice to checkpoint(); | ||
| 412 | + */ | ||
| 413 | + } | ||
| 414 | } | ||
| 415 | |||
| 416 | + | ||
| 417 | /* | ||
| 418 | * Called from the compare thread on the primary | ||
| 419 | * for compare udp packet | ||
| 420 | @@ -XXX,XX +XXX,XX @@ static void colo_old_packet_check(void *opaque) | ||
| 421 | (GCompareFunc)colo_old_packet_check_one_conn); | ||
| 422 | } | ||
| 423 | |||
| 424 | -/* | ||
| 425 | - * Called from the compare thread on the primary | ||
| 426 | - * for compare packet with secondary list of the | ||
| 427 | - * specified connection when a new packet was | ||
| 428 | - * queued to it. | ||
| 429 | - */ | ||
| 430 | -static void colo_compare_connection(void *opaque, void *user_data) | ||
| 431 | +static void colo_compare_packet(CompareState *s, Connection *conn, | ||
| 432 | + int (*HandlePacket)(Packet *spkt, | ||
| 433 | + Packet *ppkt)) | ||
| 434 | { | ||
| 435 | - CompareState *s = user_data; | ||
| 436 | - Connection *conn = opaque; | ||
| 437 | Packet *pkt = NULL; | ||
| 438 | GList *result = NULL; | ||
| 439 | - int ret; | ||
| 440 | |||
| 441 | while (!g_queue_is_empty(&conn->primary_list) && | ||
| 442 | !g_queue_is_empty(&conn->secondary_list)) { | ||
| 443 | pkt = g_queue_pop_head(&conn->primary_list); | ||
| 444 | - switch (conn->ip_proto) { | ||
| 445 | - case IPPROTO_TCP: | ||
| 446 | - result = g_queue_find_custom(&conn->secondary_list, | ||
| 447 | - pkt, (GCompareFunc)colo_packet_compare_tcp); | ||
| 448 | - break; | ||
| 449 | - case IPPROTO_UDP: | ||
| 450 | - result = g_queue_find_custom(&conn->secondary_list, | ||
| 451 | - pkt, (GCompareFunc)colo_packet_compare_udp); | ||
| 452 | - break; | ||
| 453 | - case IPPROTO_ICMP: | ||
| 454 | - result = g_queue_find_custom(&conn->secondary_list, | ||
| 455 | - pkt, (GCompareFunc)colo_packet_compare_icmp); | ||
| 456 | - break; | ||
| 457 | - default: | ||
| 458 | - result = g_queue_find_custom(&conn->secondary_list, | ||
| 459 | - pkt, (GCompareFunc)colo_packet_compare_other); | ||
| 460 | - break; | ||
| 461 | - } | ||
| 462 | + result = g_queue_find_custom(&conn->secondary_list, | ||
| 463 | + pkt, (GCompareFunc)HandlePacket); | ||
| 464 | |||
| 465 | if (result) { | ||
| 466 | - ret = compare_chr_send(s, | ||
| 467 | - pkt->data, | ||
| 468 | - pkt->size, | ||
| 469 | - pkt->vnet_hdr_len); | ||
| 470 | - if (ret < 0) { | ||
| 471 | - error_report("colo_send_primary_packet failed"); | ||
| 472 | - } | ||
| 473 | - trace_colo_compare_main("packet same and release packet"); | ||
| 474 | + colo_release_primary_pkt(s, pkt); | ||
| 475 | g_queue_remove(&conn->secondary_list, result->data); | ||
| 476 | - packet_destroy(pkt, NULL); | ||
| 477 | } else { | ||
| 478 | /* | ||
| 479 | * If one packet arrive late, the secondary_list or | ||
| 480 | @@ -XXX,XX +XXX,XX @@ static void colo_compare_connection(void *opaque, void *user_data) | ||
| 481 | } | ||
| 482 | } | ||
| 483 | |||
| 484 | +/* | ||
| 485 | + * Called from the compare thread on the primary | ||
| 486 | + * for compare packet with secondary list of the | ||
| 487 | + * specified connection when a new packet was | ||
| 488 | + * queued to it. | ||
| 489 | + */ | ||
| 490 | +static void colo_compare_connection(void *opaque, void *user_data) | ||
| 491 | +{ | ||
| 492 | + CompareState *s = user_data; | ||
| 493 | + Connection *conn = opaque; | ||
| 494 | + | ||
| 495 | + switch (conn->ip_proto) { | ||
| 496 | + case IPPROTO_TCP: | ||
| 497 | + colo_compare_tcp(s, conn); | ||
| 498 | + break; | ||
| 499 | + case IPPROTO_UDP: | ||
| 500 | + colo_compare_packet(s, conn, colo_packet_compare_udp); | ||
| 501 | + break; | ||
| 502 | + case IPPROTO_ICMP: | ||
| 503 | + colo_compare_packet(s, conn, colo_packet_compare_icmp); | ||
| 504 | + break; | ||
| 505 | + default: | ||
| 506 | + colo_compare_packet(s, conn, colo_packet_compare_other); | ||
| 507 | + break; | ||
| 508 | + } | ||
| 509 | +} | ||
| 510 | + | ||
| 511 | static int compare_chr_send(CompareState *s, | ||
| 512 | const uint8_t *buf, | ||
| 513 | uint32_t size, | ||
| 514 | diff --git a/net/colo.c b/net/colo.c | ||
| 515 | index XXXXXXX..XXXXXXX 100644 | 79 | index XXXXXXX..XXXXXXX 100644 |
| 516 | --- a/net/colo.c | 80 | --- a/include/net/eth.h |
| 517 | +++ b/net/colo.c | 81 | +++ b/include/net/eth.h |
| 518 | @@ -XXX,XX +XXX,XX @@ Connection *connection_new(ConnectionKey *key) | 82 | @@ -XXX,XX +XXX,XX @@ struct tcp_hdr { |
| 519 | conn->processing = false; | 83 | |
| 520 | conn->offset = 0; | 84 | #define ip6_nxt ip6_ctlun.ip6_un1.ip6_un1_nxt |
| 521 | conn->syn_flag = 0; | 85 | #define ip6_ecn_acc ip6_ctlun.ip6_un3.ip6_un3_ecn |
| 522 | + conn->pack = 0; | 86 | +#define ip6_plen ip6_ctlun.ip6_un1.ip6_un1_plen |
| 523 | + conn->sack = 0; | 87 | |
| 524 | g_queue_init(&conn->primary_list); | 88 | #define PKT_GET_ETH_HDR(p) \ |
| 525 | g_queue_init(&conn->secondary_list); | 89 | ((struct eth_header *)(p)) |
| 526 | |||
| 527 | @@ -XXX,XX +XXX,XX @@ Packet *packet_new(const void *data, int size, int vnet_hdr_len) | ||
| 528 | pkt->size = size; | ||
| 529 | pkt->creation_ms = qemu_clock_get_ms(QEMU_CLOCK_HOST); | ||
| 530 | pkt->vnet_hdr_len = vnet_hdr_len; | ||
| 531 | + pkt->tcp_seq = 0; | ||
| 532 | + pkt->tcp_ack = 0; | ||
| 533 | + pkt->seq_end = 0; | ||
| 534 | + pkt->header_size = 0; | ||
| 535 | + pkt->payload_size = 0; | ||
| 536 | + pkt->offset = 0; | ||
| 537 | + pkt->flags = 0; | ||
| 538 | |||
| 539 | return pkt; | ||
| 540 | } | ||
| 541 | diff --git a/net/colo.h b/net/colo.h | ||
| 542 | index XXXXXXX..XXXXXXX 100644 | ||
| 543 | --- a/net/colo.h | ||
| 544 | +++ b/net/colo.h | ||
| 545 | @@ -XXX,XX +XXX,XX @@ typedef struct Packet { | ||
| 546 | int64_t creation_ms; | ||
| 547 | /* Get vnet_hdr_len from filter */ | ||
| 548 | uint32_t vnet_hdr_len; | ||
| 549 | + uint32_t tcp_seq; /* sequence number */ | ||
| 550 | + uint32_t tcp_ack; /* acknowledgement number */ | ||
| 551 | + /* the sequence number of the last byte of the packet */ | ||
| 552 | + uint32_t seq_end; | ||
| 553 | + uint8_t header_size; /* the header length */ | ||
| 554 | + uint16_t payload_size; /* the payload length */ | ||
| 555 | + /* record the payload offset(the length that has been compared) */ | ||
| 556 | + uint16_t offset; | ||
| 557 | + uint8_t flags; /* Flags(aka Control bits) */ | ||
| 558 | } Packet; | ||
| 559 | |||
| 560 | typedef struct ConnectionKey { | ||
| 561 | @@ -XXX,XX +XXX,XX @@ typedef struct Connection { | ||
| 562 | /* flag to enqueue unprocessed_connections */ | ||
| 563 | bool processing; | ||
| 564 | uint8_t ip_proto; | ||
| 565 | + /* record the sequence number that has been compared */ | ||
| 566 | + uint32_t compare_seq; | ||
| 567 | + /* the maximum of acknowledgement number in primary_list queue */ | ||
| 568 | + uint32_t pack; | ||
| 569 | + /* the maximum of acknowledgement number in secondary_list queue */ | ||
| 570 | + uint32_t sack; | ||
| 571 | /* offset = secondary_seq - primary_seq */ | ||
| 572 | tcp_seq offset; | ||
| 573 | /* | ||
| 574 | diff --git a/net/trace-events b/net/trace-events | ||
| 575 | index XXXXXXX..XXXXXXX 100644 | ||
| 576 | --- a/net/trace-events | ||
| 577 | +++ b/net/trace-events | ||
| 578 | @@ -XXX,XX +XXX,XX @@ colo_compare_icmp_miscompare(const char *sta, int size) ": %s = %d" | ||
| 579 | colo_compare_ip_info(int psize, const char *sta, const char *stb, int ssize, const char *stc, const char *std) "ppkt size = %d, ip_src = %s, ip_dst = %s, spkt size = %d, ip_src = %s, ip_dst = %s" | ||
| 580 | colo_old_packet_check_found(int64_t old_time) "%" PRId64 | ||
| 581 | colo_compare_miscompare(void) "" | ||
| 582 | -colo_compare_tcp_info(const char *pkt, uint32_t seq, uint32_t ack, int res, uint32_t flag, int size) "side: %s seq/ack= %u/%u res= %d flags= 0x%x pkt_size: %d\n" | ||
| 583 | +colo_compare_tcp_info(const char *pkt, uint32_t seq, uint32_t ack, int hdlen, int pdlen, int offset, int flags) "%s: seq/ack= %u/%u hdlen= %d pdlen= %d offset= %d flags=%d\n" | ||
| 584 | |||
| 585 | # net/filter-rewriter.c | ||
| 586 | colo_filter_rewriter_debug(void) "" | ||
| 587 | -- | 90 | -- |
| 588 | 2.7.4 | 91 | 2.5.0 |
| 589 | 92 | ||
| 590 | 93 | diff view generated by jsdifflib |
Deleted patch | |||
|---|---|---|---|
| 1 | From: Thomas Huth <thuth@redhat.com> | ||
| 2 | 1 | ||
| 3 | QEMU can emulate hubs to connect NICs and netdevs. This is currently | ||
| 4 | primarily used for the mis-named 'vlan' feature of the networking | ||
| 5 | subsystem. Now the 'vlan' feature has been marked as deprecated, since | ||
| 6 | its name is rather confusing and the users often rather mis-configure | ||
| 7 | their network when trying to use it. But while the 'vlan' parameter | ||
| 8 | should be removed at one point in time, the basic idea of emulating | ||
| 9 | a hub in QEMU is still good: It's useful for bundling up the output of | ||
| 10 | multiple NICs into one single l2tp netdev for example. | ||
| 11 | |||
| 12 | Now to be able to use the hubport feature without 'vlan's, there is one | ||
| 13 | missing piece: The possibility to connect a hubport to a netdev, too. | ||
| 14 | This patch adds this possibility by introducing a new "netdev=..." | ||
| 15 | parameter to the hubports. | ||
| 16 | |||
| 17 | To bundle up the output of multiple NICs into one socket netdev, you can | ||
| 18 | now run QEMU with these parameters for example: | ||
| 19 | |||
| 20 | qemu-system-ppc64 ... -netdev socket,id=s1,connect=:11122 \ | ||
| 21 | -netdev hubport,hubid=1,id=h1,netdev=s1 \ | ||
| 22 | -netdev hubport,hubid=1,id=h2 -device e1000,netdev=h2 \ | ||
| 23 | -netdev hubport,hubid=1,id=h3 -device virtio-net-pci,netdev=h3 | ||
| 24 | |||
| 25 | For using the socket netdev, you have got to start another QEMU as the | ||
| 26 | receiving side first, for example with network dumping enabled: | ||
| 27 | |||
| 28 | qemu-system-x86_64 -M isapc -netdev socket,id=s0,listen=:11122 \ | ||
| 29 | -device ne2k_isa,netdev=s0 \ | ||
| 30 | -object filter-dump,id=f1,netdev=s0,file=/tmp/dump.dat | ||
| 31 | |||
| 32 | After the ppc64 guest tried to boot from both NICs, you can see in the | ||
| 33 | dump file (using Wireshark, for example), that the output of both NICs | ||
| 34 | (the e1000 and the virtio-net-pci) has been successfully transfered | ||
| 35 | via the socket netdev in this case. | ||
| 36 | |||
| 37 | Suggested-by: Paolo Bonzini <pbonzini@redhat.com> | ||
| 38 | Signed-off-by: Thomas Huth <thuth@redhat.com> | ||
| 39 | Signed-off-by: Jason Wang <jasowang@redhat.com> | ||
| 40 | --- | ||
| 41 | net/hub.c | 27 +++++++++++++++++++++------ | ||
| 42 | net/hub.h | 3 ++- | ||
| 43 | net/net.c | 2 +- | ||
| 44 | qapi/net.json | 4 +++- | ||
| 45 | qemu-options.hx | 8 +++++--- | ||
| 46 | 5 files changed, 32 insertions(+), 12 deletions(-) | ||
| 47 | |||
| 48 | diff --git a/net/hub.c b/net/hub.c | ||
| 49 | index XXXXXXX..XXXXXXX 100644 | ||
| 50 | --- a/net/hub.c | ||
| 51 | +++ b/net/hub.c | ||
| 52 | @@ -XXX,XX +XXX,XX @@ | ||
| 53 | */ | ||
| 54 | |||
| 55 | #include "qemu/osdep.h" | ||
| 56 | +#include "qapi/error.h" | ||
| 57 | #include "monitor/monitor.h" | ||
| 58 | #include "net/net.h" | ||
| 59 | #include "clients.h" | ||
| 60 | @@ -XXX,XX +XXX,XX @@ static NetClientInfo net_hub_port_info = { | ||
| 61 | .cleanup = net_hub_port_cleanup, | ||
| 62 | }; | ||
| 63 | |||
| 64 | -static NetHubPort *net_hub_port_new(NetHub *hub, const char *name) | ||
| 65 | +static NetHubPort *net_hub_port_new(NetHub *hub, const char *name, | ||
| 66 | + NetClientState *hubpeer) | ||
| 67 | { | ||
| 68 | NetClientState *nc; | ||
| 69 | NetHubPort *port; | ||
| 70 | @@ -XXX,XX +XXX,XX @@ static NetHubPort *net_hub_port_new(NetHub *hub, const char *name) | ||
| 71 | name = default_name; | ||
| 72 | } | ||
| 73 | |||
| 74 | - nc = qemu_new_net_client(&net_hub_port_info, NULL, "hub", name); | ||
| 75 | + nc = qemu_new_net_client(&net_hub_port_info, hubpeer, "hub", name); | ||
| 76 | port = DO_UPCAST(NetHubPort, nc, nc); | ||
| 77 | port->id = id; | ||
| 78 | port->hub = hub; | ||
| 79 | @@ -XXX,XX +XXX,XX @@ static NetHubPort *net_hub_port_new(NetHub *hub, const char *name) | ||
| 80 | |||
| 81 | /** | ||
| 82 | * Create a port on a given hub | ||
| 83 | + * @hub_id: Number of the hub | ||
| 84 | * @name: Net client name or NULL for default name. | ||
| 85 | + * @hubpeer: Peer to use (if "netdev=id" has been specified) | ||
| 86 | * | ||
| 87 | * If there is no existing hub with the given id then a new hub is created. | ||
| 88 | */ | ||
| 89 | -NetClientState *net_hub_add_port(int hub_id, const char *name) | ||
| 90 | +NetClientState *net_hub_add_port(int hub_id, const char *name, | ||
| 91 | + NetClientState *hubpeer) | ||
| 92 | { | ||
| 93 | NetHub *hub; | ||
| 94 | NetHubPort *port; | ||
| 95 | @@ -XXX,XX +XXX,XX @@ NetClientState *net_hub_add_port(int hub_id, const char *name) | ||
| 96 | hub = net_hub_new(hub_id); | ||
| 97 | } | ||
| 98 | |||
| 99 | - port = net_hub_port_new(hub, name); | ||
| 100 | + port = net_hub_port_new(hub, name, hubpeer); | ||
| 101 | return &port->nc; | ||
| 102 | } | ||
| 103 | |||
| 104 | @@ -XXX,XX +XXX,XX @@ NetClientState *net_hub_port_find(int hub_id) | ||
| 105 | } | ||
| 106 | } | ||
| 107 | |||
| 108 | - nc = net_hub_add_port(hub_id, NULL); | ||
| 109 | + nc = net_hub_add_port(hub_id, NULL, NULL); | ||
| 110 | return nc; | ||
| 111 | } | ||
| 112 | |||
| 113 | @@ -XXX,XX +XXX,XX @@ int net_init_hubport(const Netdev *netdev, const char *name, | ||
| 114 | NetClientState *peer, Error **errp) | ||
| 115 | { | ||
| 116 | const NetdevHubPortOptions *hubport; | ||
| 117 | + NetClientState *hubpeer = NULL; | ||
| 118 | |||
| 119 | assert(netdev->type == NET_CLIENT_DRIVER_HUBPORT); | ||
| 120 | assert(!peer); | ||
| 121 | hubport = &netdev->u.hubport; | ||
| 122 | |||
| 123 | - net_hub_add_port(hubport->hubid, name); | ||
| 124 | + if (hubport->has_netdev) { | ||
| 125 | + hubpeer = qemu_find_netdev(hubport->netdev); | ||
| 126 | + if (!hubpeer) { | ||
| 127 | + error_setg(errp, "netdev '%s' not found", hubport->netdev); | ||
| 128 | + return -1; | ||
| 129 | + } | ||
| 130 | + } | ||
| 131 | + | ||
| 132 | + net_hub_add_port(hubport->hubid, name, hubpeer); | ||
| 133 | + | ||
| 134 | return 0; | ||
| 135 | } | ||
| 136 | |||
| 137 | diff --git a/net/hub.h b/net/hub.h | ||
| 138 | index XXXXXXX..XXXXXXX 100644 | ||
| 139 | --- a/net/hub.h | ||
| 140 | +++ b/net/hub.h | ||
| 141 | @@ -XXX,XX +XXX,XX @@ | ||
| 142 | |||
| 143 | #include "qemu-common.h" | ||
| 144 | |||
| 145 | -NetClientState *net_hub_add_port(int hub_id, const char *name); | ||
| 146 | +NetClientState *net_hub_add_port(int hub_id, const char *name, | ||
| 147 | + NetClientState *hubpeer); | ||
| 148 | NetClientState *net_hub_find_client_by_name(int hub_id, const char *name); | ||
| 149 | void net_hub_info(Monitor *mon); | ||
| 150 | void net_hub_check_clients(void); | ||
| 151 | diff --git a/net/net.c b/net/net.c | ||
| 152 | index XXXXXXX..XXXXXXX 100644 | ||
| 153 | --- a/net/net.c | ||
| 154 | +++ b/net/net.c | ||
| 155 | @@ -XXX,XX +XXX,XX @@ static int net_client_init1(const void *object, bool is_netdev, Error **errp) | ||
| 156 | /* Do not add to a vlan if it's a nic with a netdev= parameter. */ | ||
| 157 | if (netdev->type != NET_CLIENT_DRIVER_NIC || | ||
| 158 | !opts->u.nic.has_netdev) { | ||
| 159 | - peer = net_hub_add_port(net->has_vlan ? net->vlan : 0, NULL); | ||
| 160 | + peer = net_hub_add_port(net->has_vlan ? net->vlan : 0, NULL, NULL); | ||
| 161 | } | ||
| 162 | |||
| 163 | if (net->has_vlan && !vlan_warned) { | ||
| 164 | diff --git a/qapi/net.json b/qapi/net.json | ||
| 165 | index XXXXXXX..XXXXXXX 100644 | ||
| 166 | --- a/qapi/net.json | ||
| 167 | +++ b/qapi/net.json | ||
| 168 | @@ -XXX,XX +XXX,XX @@ | ||
| 169 | # Connect two or more net clients through a software hub. | ||
| 170 | # | ||
| 171 | # @hubid: hub identifier number | ||
| 172 | +# @netdev: used to connect hub to a netdev instead of a device (since 2.12) | ||
| 173 | # | ||
| 174 | # Since: 1.2 | ||
| 175 | ## | ||
| 176 | { 'struct': 'NetdevHubPortOptions', | ||
| 177 | 'data': { | ||
| 178 | - 'hubid': 'int32' } } | ||
| 179 | + 'hubid': 'int32', | ||
| 180 | + '*netdev': 'str' } } | ||
| 181 | |||
| 182 | ## | ||
| 183 | # @NetdevNetmapOptions: | ||
| 184 | diff --git a/qemu-options.hx b/qemu-options.hx | ||
| 185 | index XXXXXXX..XXXXXXX 100644 | ||
| 186 | --- a/qemu-options.hx | ||
| 187 | +++ b/qemu-options.hx | ||
| 188 | @@ -XXX,XX +XXX,XX @@ DEF("netdev", HAS_ARG, QEMU_OPTION_netdev, | ||
| 189 | #endif | ||
| 190 | "-netdev vhost-user,id=str,chardev=dev[,vhostforce=on|off]\n" | ||
| 191 | " configure a vhost-user network, backed by a chardev 'dev'\n" | ||
| 192 | - "-netdev hubport,id=str,hubid=n\n" | ||
| 193 | + "-netdev hubport,id=str,hubid=n[,netdev=nd]\n" | ||
| 194 | " configure a hub port on QEMU VLAN 'n'\n", QEMU_ARCH_ALL) | ||
| 195 | DEF("net", HAS_ARG, QEMU_OPTION_net, | ||
| 196 | "-net nic[,vlan=n][,netdev=nd][,macaddr=mac][,model=type][,name=str][,addr=str][,vectors=v]\n" | ||
| 197 | @@ -XXX,XX +XXX,XX @@ vde_switch -F -sock /tmp/myswitch | ||
| 198 | qemu-system-i386 linux.img -net nic -net vde,sock=/tmp/myswitch | ||
| 199 | @end example | ||
| 200 | |||
| 201 | -@item -netdev hubport,id=@var{id},hubid=@var{hubid} | ||
| 202 | +@item -netdev hubport,id=@var{id},hubid=@var{hubid}[,netdev=@var{nd}] | ||
| 203 | |||
| 204 | Create a hub port on QEMU "vlan" @var{hubid}. | ||
| 205 | |||
| 206 | The hubport netdev lets you connect a NIC to a QEMU "vlan" instead of a single | ||
| 207 | netdev. @code{-net} and @code{-device} with parameter @option{vlan} create the | ||
| 208 | -required hub automatically. | ||
| 209 | +required hub automatically. Alternatively, you can also connect the hubport | ||
| 210 | +to another netdev with ID @var{nd} by using the @option{netdev=@var{nd}} | ||
| 211 | +option. | ||
| 212 | |||
| 213 | @item -netdev vhost-user,chardev=@var{id}[,vhostforce=on|off][,queues=n] | ||
| 214 | |||
| 215 | -- | ||
| 216 | 2.7.4 | ||
| 217 | |||
| 218 | diff view generated by jsdifflib |
Deleted patch | |||
|---|---|---|---|
| 1 | From: Thomas Huth <thuth@redhat.com> | ||
| 2 | 1 | ||
| 3 | It does not make much sense to limit these commands to the legacy 'vlan' | ||
| 4 | concept only, they should work with the modern netdevs, too. So now | ||
| 5 | it is possible to use this command with one, two or three parameters. | ||
| 6 | |||
| 7 | With one parameter, the command installs a hostfwd rule on the default | ||
| 8 | "user" network: | ||
| 9 | hostfwd_add tcp:... | ||
| 10 | |||
| 11 | With two parameters, the command installs a hostfwd rule on a netdev | ||
| 12 | (that's the new way of using this command): | ||
| 13 | hostfwd_add netdev_id tcp:... | ||
| 14 | |||
| 15 | With three parameters, the command installs a rule on a 'vlan' (aka hub): | ||
| 16 | hostfwd_add hub_id name tcp:... | ||
| 17 | |||
| 18 | Same applies to the hostfwd_remove command now. | ||
| 19 | |||
| 20 | Signed-off-by: Thomas Huth <thuth@redhat.com> | ||
| 21 | Signed-off-by: Jason Wang <jasowang@redhat.com> | ||
| 22 | --- | ||
| 23 | hmp-commands.hx | 4 ++-- | ||
| 24 | net/slirp.c | 33 +++++++++++++++++++++++---------- | ||
| 25 | 2 files changed, 25 insertions(+), 12 deletions(-) | ||
| 26 | |||
| 27 | diff --git a/hmp-commands.hx b/hmp-commands.hx | ||
| 28 | index XXXXXXX..XXXXXXX 100644 | ||
| 29 | --- a/hmp-commands.hx | ||
| 30 | +++ b/hmp-commands.hx | ||
| 31 | @@ -XXX,XX +XXX,XX @@ ETEXI | ||
| 32 | { | ||
| 33 | .name = "hostfwd_add", | ||
| 34 | .args_type = "arg1:s,arg2:s?,arg3:s?", | ||
| 35 | - .params = "[vlan_id name] [tcp|udp]:[hostaddr]:hostport-[guestaddr]:guestport", | ||
| 36 | + .params = "[hub_id name]|[netdev_id] [tcp|udp]:[hostaddr]:hostport-[guestaddr]:guestport", | ||
| 37 | .help = "redirect TCP or UDP connections from host to guest (requires -net user)", | ||
| 38 | .cmd = hmp_hostfwd_add, | ||
| 39 | }, | ||
| 40 | @@ -XXX,XX +XXX,XX @@ ETEXI | ||
| 41 | { | ||
| 42 | .name = "hostfwd_remove", | ||
| 43 | .args_type = "arg1:s,arg2:s?,arg3:s?", | ||
| 44 | - .params = "[vlan_id name] [tcp|udp]:[hostaddr]:hostport", | ||
| 45 | + .params = "[hub_id name]|[netdev_id] [tcp|udp]:[hostaddr]:hostport", | ||
| 46 | .help = "remove host-to-guest TCP or UDP redirection", | ||
| 47 | .cmd = hmp_hostfwd_remove, | ||
| 48 | }, | ||
| 49 | diff --git a/net/slirp.c b/net/slirp.c | ||
| 50 | index XXXXXXX..XXXXXXX 100644 | ||
| 51 | --- a/net/slirp.c | ||
| 52 | +++ b/net/slirp.c | ||
| 53 | @@ -XXX,XX +XXX,XX @@ error: | ||
| 54 | return -1; | ||
| 55 | } | ||
| 56 | |||
| 57 | -static SlirpState *slirp_lookup(Monitor *mon, const char *vlan, | ||
| 58 | - const char *stack) | ||
| 59 | +static SlirpState *slirp_lookup(Monitor *mon, const char *hub_id, | ||
| 60 | + const char *name) | ||
| 61 | { | ||
| 62 | - | ||
| 63 | - if (vlan) { | ||
| 64 | + if (name) { | ||
| 65 | NetClientState *nc; | ||
| 66 | - nc = net_hub_find_client_by_name(strtol(vlan, NULL, 0), stack); | ||
| 67 | - if (!nc) { | ||
| 68 | - monitor_printf(mon, "unrecognized (vlan-id, stackname) pair\n"); | ||
| 69 | - return NULL; | ||
| 70 | + if (hub_id) { | ||
| 71 | + nc = net_hub_find_client_by_name(strtol(hub_id, NULL, 0), name); | ||
| 72 | + if (!nc) { | ||
| 73 | + monitor_printf(mon, "unrecognized (vlan-id, stackname) pair\n"); | ||
| 74 | + return NULL; | ||
| 75 | + } | ||
| 76 | + } else { | ||
| 77 | + nc = qemu_find_netdev(name); | ||
| 78 | + if (!nc) { | ||
| 79 | + monitor_printf(mon, "unrecognized netdev id '%s'\n", name); | ||
| 80 | + return NULL; | ||
| 81 | + } | ||
| 82 | } | ||
| 83 | if (strcmp(nc->model, "user")) { | ||
| 84 | monitor_printf(mon, "invalid device specified\n"); | ||
| 85 | @@ -XXX,XX +XXX,XX @@ void hmp_hostfwd_remove(Monitor *mon, const QDict *qdict) | ||
| 86 | const char *arg2 = qdict_get_try_str(qdict, "arg2"); | ||
| 87 | const char *arg3 = qdict_get_try_str(qdict, "arg3"); | ||
| 88 | |||
| 89 | - if (arg2) { | ||
| 90 | + if (arg3) { | ||
| 91 | s = slirp_lookup(mon, arg1, arg2); | ||
| 92 | src_str = arg3; | ||
| 93 | + } else if (arg2) { | ||
| 94 | + s = slirp_lookup(mon, NULL, arg1); | ||
| 95 | + src_str = arg2; | ||
| 96 | } else { | ||
| 97 | s = slirp_lookup(mon, NULL, NULL); | ||
| 98 | src_str = arg1; | ||
| 99 | @@ -XXX,XX +XXX,XX @@ void hmp_hostfwd_add(Monitor *mon, const QDict *qdict) | ||
| 100 | const char *arg2 = qdict_get_try_str(qdict, "arg2"); | ||
| 101 | const char *arg3 = qdict_get_try_str(qdict, "arg3"); | ||
| 102 | |||
| 103 | - if (arg2) { | ||
| 104 | + if (arg3) { | ||
| 105 | s = slirp_lookup(mon, arg1, arg2); | ||
| 106 | redir_str = arg3; | ||
| 107 | + } else if (arg2) { | ||
| 108 | + s = slirp_lookup(mon, NULL, arg1); | ||
| 109 | + redir_str = arg2; | ||
| 110 | } else { | ||
| 111 | s = slirp_lookup(mon, NULL, NULL); | ||
| 112 | redir_str = arg1; | ||
| 113 | -- | ||
| 114 | 2.7.4 | ||
| 115 | |||
| 116 | diff view generated by jsdifflib |
Deleted patch | |||
|---|---|---|---|
| 1 | From: Thomas Huth <thuth@redhat.com> | ||
| 2 | 1 | ||
| 3 | The vlan concept is marked as deprecated, so we should not use | ||
| 4 | this for examples in the documentation anymore. | ||
| 5 | |||
| 6 | Signed-off-by: Thomas Huth <thuth@redhat.com> | ||
| 7 | Signed-off-by: Jason Wang <jasowang@redhat.com> | ||
| 8 | --- | ||
| 9 | qemu-options.hx | 4 ++-- | ||
| 10 | 1 file changed, 2 insertions(+), 2 deletions(-) | ||
| 11 | |||
| 12 | diff --git a/qemu-options.hx b/qemu-options.hx | ||
| 13 | index XXXXXXX..XXXXXXX 100644 | ||
| 14 | --- a/qemu-options.hx | ||
| 15 | +++ b/qemu-options.hx | ||
| 16 | @@ -XXX,XX +XXX,XX @@ qemu-system-i386 linux.img -net nic -net tap | ||
| 17 | #launch a QEMU instance with two NICs, each one connected | ||
| 18 | #to a TAP device | ||
| 19 | qemu-system-i386 linux.img \ | ||
| 20 | - -net nic,vlan=0 -net tap,vlan=0,ifname=tap0 \ | ||
| 21 | - -net nic,vlan=1 -net tap,vlan=1,ifname=tap1 | ||
| 22 | + -netdev tap,id=nd0,ifname=tap0 -device e1000,netdev=nd0 \ | ||
| 23 | + -netdev tap,id=nd1,ifname=tap1 -device rtl8139,netdev=nd1 | ||
| 24 | @end example | ||
| 25 | |||
| 26 | @example | ||
| 27 | -- | ||
| 28 | 2.7.4 | ||
| 29 | |||
| 30 | diff view generated by jsdifflib |
| 1 | From: Philippe Mathieu-Daudé <f4bug@amsat.org> | 1 | From: Mauro Matteo Cascella <mcascell@redhat.com> |
|---|---|---|---|
| 2 | 2 | ||
| 3 | gently asked by his automatic reply :) | 3 | A buffer overflow issue was reported by Mr. Ziming Zhang, CC'd here. It |
| 4 | occurs while sending an Ethernet frame due to missing break statements | ||
| 5 | and improper checking of the buffer size. | ||
| 4 | 6 | ||
| 5 | Signed-off-by: Philippe Mathieu-Daudé <f4bug@amsat.org> | 7 | Reported-by: Ziming Zhang <ezrakiez@gmail.com> |
| 8 | Signed-off-by: Mauro Matteo Cascella <mcascell@redhat.com> | ||
| 9 | Reviewed-by: Peter Maydell <peter.maydell@linaro.org> | ||
| 6 | Signed-off-by: Jason Wang <jasowang@redhat.com> | 10 | Signed-off-by: Jason Wang <jasowang@redhat.com> |
| 7 | --- | 11 | --- |
| 8 | MAINTAINERS | 8 ++++---- | 12 | hw/net/xgmac.c | 14 ++++++++++++-- |
| 9 | 1 file changed, 4 insertions(+), 4 deletions(-) | 13 | 1 file changed, 12 insertions(+), 2 deletions(-) |
| 10 | 14 | ||
| 11 | diff --git a/MAINTAINERS b/MAINTAINERS | 15 | diff --git a/hw/net/xgmac.c b/hw/net/xgmac.c |
| 12 | index XXXXXXX..XXXXXXX 100644 | 16 | index XXXXXXX..XXXXXXX 100644 |
| 13 | --- a/MAINTAINERS | 17 | --- a/hw/net/xgmac.c |
| 14 | +++ b/MAINTAINERS | 18 | +++ b/hw/net/xgmac.c |
| 15 | @@ -XXX,XX +XXX,XX @@ F: hw/scsi/mfi.h | 19 | @@ -XXX,XX +XXX,XX @@ static void xgmac_enet_send(XgmacState *s) |
| 16 | F: tests/megasas-test.c | 20 | } |
| 17 | 21 | len = (bd.buffer1_size & 0xfff) + (bd.buffer2_size & 0xfff); | |
| 18 | Network packet abstractions | 22 | |
| 19 | -M: Dmitry Fleytman <dmitry@daynix.com> | 23 | + /* |
| 20 | +M: Dmitry Fleytman <dmitry.fleytman@gmail.com> | 24 | + * FIXME: these cases of malformed tx descriptors (bad sizes) |
| 21 | S: Maintained | 25 | + * should probably be reported back to the guest somehow |
| 22 | F: include/net/eth.h | 26 | + * rather than simply silently stopping processing, but we |
| 23 | F: net/eth.c | 27 | + * don't know what the hardware does in this situation. |
| 24 | @@ -XXX,XX +XXX,XX @@ F: hw/net/net_rx_pkt* | 28 | + * This will only happen for buggy guests anyway. |
| 25 | F: hw/net/net_tx_pkt* | 29 | + */ |
| 26 | 30 | if ((bd.buffer1_size & 0xfff) > 2048) { | |
| 27 | Vmware | 31 | DEBUGF_BRK("qemu:%s:ERROR...ERROR...ERROR... -- " |
| 28 | -M: Dmitry Fleytman <dmitry@daynix.com> | 32 | "xgmac buffer 1 len on send > 2048 (0x%x)\n", |
| 29 | +M: Dmitry Fleytman <dmitry.fleytman@gmail.com> | 33 | __func__, bd.buffer1_size & 0xfff); |
| 30 | S: Maintained | 34 | + break; |
| 31 | F: hw/net/vmxnet* | 35 | } |
| 32 | F: hw/scsi/vmw_pvscsi* | 36 | if ((bd.buffer2_size & 0xfff) != 0) { |
| 33 | @@ -XXX,XX +XXX,XX @@ F: hw/mem/nvdimm.c | 37 | DEBUGF_BRK("qemu:%s:ERROR...ERROR...ERROR... -- " |
| 34 | F: include/hw/mem/nvdimm.h | 38 | "xgmac buffer 2 len on send != 0 (0x%x)\n", |
| 35 | 39 | __func__, bd.buffer2_size & 0xfff); | |
| 36 | e1000x | 40 | + break; |
| 37 | -M: Dmitry Fleytman <dmitry@daynix.com> | 41 | } |
| 38 | +M: Dmitry Fleytman <dmitry.fleytman@gmail.com> | 42 | - if (len >= sizeof(frame)) { |
| 39 | S: Maintained | 43 | + if (frame_size + len >= sizeof(frame)) { |
| 40 | F: hw/net/e1000x* | 44 | DEBUGF_BRK("qemu:%s: buffer overflow %d read into %zu " |
| 41 | 45 | - "buffer\n" , __func__, len, sizeof(frame)); | |
| 42 | e1000e | 46 | + "buffer\n" , __func__, frame_size + len, sizeof(frame)); |
| 43 | -M: Dmitry Fleytman <dmitry@daynix.com> | 47 | DEBUGF_BRK("qemu:%s: buffer1.size=%d; buffer2.size=%d\n", |
| 44 | +M: Dmitry Fleytman <dmitry.fleytman@gmail.com> | 48 | __func__, bd.buffer1_size, bd.buffer2_size); |
| 45 | S: Maintained | 49 | + break; |
| 46 | F: hw/net/e1000e* | 50 | } |
| 47 | 51 | ||
| 52 | cpu_physical_memory_read(bd.buffer1_addr, ptr, len); | ||
| 48 | -- | 53 | -- |
| 49 | 2.7.4 | 54 | 2.5.0 |
| 50 | 55 | ||
| 51 | 56 | diff view generated by jsdifflib |