The following changes since commit 48033ad678ae2def43bf0d543a2c4c3d2a93feaf:

Merge remote-tracking branch 'remotes/vsementsov/tags/pull-nbd-2022-02-09-v2' into staging (2022-02-12 22:04:07 +0000)

for you to fetch changes up to 9d6267b240c114d1a3cd314a08fd6e1339d34b83:

net/eth: Don't consider ESP to be an IPv6 option header (2022-02-14 11:50:44 +0800)

Nick Hudson (1):

hw/net: e1000e: Clear ICR on read when using non MSI-X interrupts

Peter Foley (2):

net/tap: Set return code on failure

net: Fix uninitialized data usage

Philippe Mathieu-Daudé (1):

hw/net/vmxnet3: Log guest-triggerable errors using LOG_GUEST_ERROR

Rao Lei (1):

net/filter: Optimize filter_send to coroutine

Thomas Jansen (1):

net/eth: Don't consider ESP to be an IPv6 option header

Zhang Chen (2):

net/colo-compare.c: Optimize compare order for performance

net/colo-compare.c: Update the default value comments

hw/net/e1000e_core.c | 5 ++++

hw/net/trace-events | 1 +

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

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

net/eth.c | 1 -

net/filter-mirror.c | 66 +++++++++++++++++++++++++++++++++++++++++-----------

net/tap-linux.c | 1 +

net/tap.c | 1 +

8 files changed, 78 insertions(+), 29 deletions(-)

From: Thomas Jansen <mithi@mithi.net>

The IPv6 option headers all have in common that they start with some

common fields, in particular the type of the next header followed by the

extention header length. This is used to traverse the list of the

options. The ESP header does not follow that format, which can break the

IPv6 option header traversal code in eth_parse_ipv6_hdr().

The effect of that is that network interfaces such as vmxnet3 that use

the following call chain

eth_is_ip6_extension_header_type

eth_parse_ipv6_hdr

net_tx_pkt_parse_headers

net_tx_pkt_parse

vmxnet3_process_tx_queue

to send packets from the VM out to the host will drop packets of the

following structure:

Ethernet-Header(IPv6-Header(ESP(encrypted data)))

Note that not all types of network interfaces use the net_tx_pkt_parse

function though, leading to inconsistent behavior regarding sending

those packets. The e1000 network interface for example does not suffer

from this limitation.

By not considering ESP to be an IPv6 header we can allow sending those

packets out to the host on all types of network interfaces.

Fixes: 75020a702151 ("Common definitions for VMWARE devices")

Resolves: https://gitlab.com/qemu-project/qemu/-/issues/149

Buglink: https://bugs.launchpad.net/qemu/+bug/1758091

Signed-off-by: Thomas Jansen <mithi@mithi.net>

net/eth.c | 1 -

1 file changed, 1 deletion(-)

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

--- a/net/eth.c

+++ b/net/eth.c

@@ -XXX,XX +XXX,XX @@ eth_is_ip6_extension_header_type(uint8_t hdr_type)

case IP6_HOP_BY_HOP:

case IP6_ROUTING:

case IP6_FRAGMENT:

- case IP6_ESP:

case IP6_AUTHENTICATION:

case IP6_DESTINATON:

case IP6_MOBILITY:

2.7.4

From: Nick Hudson <skrll@netbsd.org>

In section 7.4.3 of the 82574 datasheet it states that

"In systems that do not support MSI-X, reading the ICR

register clears it's bits..."

Some OSes rely on this.

Signed-off-by: Nick Hudson <skrll@netbsd.org>

hw/net/e1000e_core.c | 5 +++++

hw/net/trace-events | 1 +

2 files changed, 6 insertions(+)

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

--- a/hw/net/e1000e_core.c

+++ b/hw/net/e1000e_core.c

@@ -XXX,XX +XXX,XX @@ e1000e_mac_icr_read(E1000ECore *core, int index)

core->mac[ICR] = 0;

}

+ if (!msix_enabled(core->owner)) {

+ trace_e1000e_irq_icr_clear_nonmsix_icr_read();

+ core->mac[ICR] = 0;

+ }

+

if ((core->mac[ICR] & E1000_ICR_ASSERTED) &&

(core->mac[CTRL_EXT] & E1000_CTRL_EXT_IAME)) {

trace_e1000e_irq_icr_clear_iame();

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

--- a/hw/net/trace-events

+++ b/hw/net/trace-events

@@ -XXX,XX +XXX,XX @@ e1000e_irq_write_ics(uint32_t val) "Adding ICR bits 0x%x"

e1000e_irq_icr_process_iame(void) "Clearing IMS bits due to IAME"

e1000e_irq_read_ics(uint32_t ics) "Current ICS: 0x%x"

e1000e_irq_read_ims(uint32_t ims) "Current IMS: 0x%x"

+e1000e_irq_icr_clear_nonmsix_icr_read(void) "Clearing ICR on read due to non MSI-X int"

e1000e_irq_icr_read_entry(uint32_t icr) "Starting ICR read. Current ICR: 0x%x"

e1000e_irq_icr_read_exit(uint32_t icr) "Ending ICR read. Current ICR: 0x%x"

e1000e_irq_icr_clear_zero_ims(void) "Clearing ICR on read due to zero IMS"

2.7.4

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

Make the comments consistent with the REGULAR_PACKET_CHECK_MS.

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

net/colo-compare.c | 2 +-

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

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

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

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

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

}

if (!s->expired_scan_cycle) {

- /* Set default value to 3000 MS */

+ /* Set default value to 1000 MS */

s->expired_scan_cycle = REGULAR_PACKET_CHECK_MS;

}

2.7.4

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

COLO-compare use the glib function g_queue_find_custom to dump

another VM's networking packet to compare. But this function always

start find from the queue->head(here is the newest packet), It will

reduce the success rate of comparison. So this patch reversed

the order of the queues for performance.

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

Reported-by: leirao <lei.rao@intel.com>

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

1 file changed, 13 insertions(+), 13 deletions(-)

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

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

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

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

/* Use restricted to colo_insert_packet() */

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

{

- return a->tcp_seq - b->tcp_seq;

+ return b->tcp_seq - a->tcp_seq;

}

static void fill_pkt_tcp_info(void *data, uint32_t *max_ack)

@@ -XXX,XX +XXX,XX @@ pri:

if (g_queue_is_empty(&conn->primary_list)) {

return;

}

- ppkt = g_queue_pop_head(&conn->primary_list);

+ ppkt = g_queue_pop_tail(&conn->primary_list);

sec:

if (g_queue_is_empty(&conn->secondary_list)) {

- g_queue_push_head(&conn->primary_list, ppkt);

+ g_queue_push_tail(&conn->primary_list, ppkt);

return;

}

- spkt = g_queue_pop_head(&conn->secondary_list);

+ spkt = g_queue_pop_tail(&conn->secondary_list);

if (ppkt->tcp_seq == ppkt->seq_end) {

colo_release_primary_pkt(s, ppkt);

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

}

}

if (!ppkt) {

- g_queue_push_head(&conn->secondary_list, spkt);

+ g_queue_push_tail(&conn->secondary_list, spkt);

goto pri;

}

}

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

if (mark == COLO_COMPARE_FREE_PRIMARY) {

conn->compare_seq = ppkt->seq_end;

colo_release_primary_pkt(s, ppkt);

- g_queue_push_head(&conn->secondary_list, spkt);

+ g_queue_push_tail(&conn->secondary_list, spkt);

goto pri;

} else if (mark == COLO_COMPARE_FREE_SECONDARY) {

conn->compare_seq = spkt->seq_end;

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

goto pri;

}

} else {

- g_queue_push_head(&conn->primary_list, ppkt);

- g_queue_push_head(&conn->secondary_list, spkt);

+ g_queue_push_tail(&conn->primary_list, ppkt);

+ g_queue_push_tail(&conn->secondary_list, spkt);

#ifdef DEBUG_COLO_PACKETS

qemu_hexdump(stderr, "colo-compare ppkt", ppkt->data, ppkt->size);

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

while (!g_queue_is_empty(&conn->primary_list) &&

!g_queue_is_empty(&conn->secondary_list)) {

- pkt = g_queue_pop_head(&conn->primary_list);

+ pkt = g_queue_pop_tail(&conn->primary_list);

result = g_queue_find_custom(&conn->secondary_list,

pkt, (GCompareFunc)HandlePacket);

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

* timeout, it will trigger a checkpoint request.

*/

trace_colo_compare_main("packet different");

- g_queue_push_head(&conn->primary_list, pkt);

+ g_queue_push_tail(&conn->primary_list, pkt);

colo_compare_inconsistency_notify(s);

break;

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

entry->buf = g_malloc(size);

memcpy(entry->buf, buf, size);

}

- g_queue_push_head(&sendco->send_list, entry);

+ g_queue_push_tail(&sendco->send_list, entry);

if (sendco->done) {

sendco->co = qemu_coroutine_create(_compare_chr_send, sendco);

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

Packet *pkt = NULL;

while (!g_queue_is_empty(&conn->primary_list)) {

- pkt = g_queue_pop_head(&conn->primary_list);

+ pkt = g_queue_pop_tail(&conn->primary_list);

compare_chr_send(s,

pkt->data,

pkt->size,

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

packet_destroy_partial(pkt, NULL);

}

while (!g_queue_is_empty(&conn->secondary_list)) {

- pkt = g_queue_pop_head(&conn->secondary_list);

+ pkt = g_queue_pop_tail(&conn->secondary_list);

packet_destroy(pkt, NULL);

}