The following changes since commit f670b3eec7f5d1ed8c4573ef244e7b8c6b32001b:

Merge tag 'migration-20230213-pull-request' of https://gitlab.com/juan.quintela/qemu into staging (2023-02-13 11:54:05 +0000)

for you to fetch changes up to e4b953a26da11d214f91516cb9b0542eab5afaa0:

vdpa: fix VHOST_BACKEND_F_IOTLB_ASID flag check (2023-02-14 14:00:30 +0800)

Christian Svensson (1):

net: Increase L2TPv3 buffer to fit jumboframes

Eugenio Pérez (1):

vdpa: fix VHOST_BACKEND_F_IOTLB_ASID flag check

Fiona Ebner (1):

hw/net/vmxnet3: allow VMXNET3_MAX_MTU itself as a value

Joelle van Dyne (1):

vmnet: stop recieving events when VM is stopped

Laurent Vivier (1):

net: stream: add a new option to automatically reconnect

Qiang Liu (2):

hw/net/lan9118: log [read|write]b when mode_16bit is enabled rather than abort

hw/net/can/xlnx-zynqmp-can: fix assertion failures in transfer_fifo()

Thomas Huth (3):

net: Move the code to collect available NIC models to a separate function

net: Restore printing of the help text with "-nic help"

net: Replace "Supported NIC models" with "Available NIC models"

hw/net/can/xlnx-zynqmp-can.c | 9 +++-

hw/net/lan9118.c | 17 ++++----

hw/net/vmxnet3.c | 2 +-

hw/pci/pci.c | 29 +------------

include/net/net.h | 14 ++++++

net/l2tpv3.c | 2 +-

net/net.c | 50 +++++++++++++++++++--

net/stream.c | 53 ++++++++++++++++++++++-

net/vhost-vdpa.c | 2 +-

net/vmnet-common.m | 48 ++++++++++++++------

net/vmnet_int.h | 2 +

qapi/net.json | 7 ++-

qemu-options.hx | 6 +--

tests/qtest/netdev-socket.c | 101 +++++++++++++++++++++++++++++++++++++++++++

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

From: Thomas Huth <thuth@redhat.com>

The code that collects the available NIC models is not really specific

to PCI anymore and will be required in the next patch, too, so let's

move this into a new separate function in net.c instead.

Signed-off-by: Thomas Huth <thuth@redhat.com>

hw/pci/pci.c | 29 +----------------------------

include/net/net.h | 14 ++++++++++++++

net/net.c | 34 ++++++++++++++++++++++++++++++++++

3 files changed, 49 insertions(+), 28 deletions(-)

@@ -XXX,XX +XXX,XX @@ void net_socket_rs_init(SocketReadState *rs,

bool vnet_hdr);

NetClientState *qemu_get_peer(NetClientState *nc, int queue_index);

+/**

+ * qemu_get_nic_models:

+ * @device_type: Defines which devices should be taken into consideration

+ * (e.g. TYPE_DEVICE for all devices, or TYPE_PCI_DEVICE for PCI)

+ *

+ * Get an array of pointers to names of NIC devices that are available in

+ * the QEMU binary. The array is terminated with a NULL pointer entry.

+ * The caller is responsible for freeing the memory when it is not required

+ * anymore, e.g. with g_ptr_array_free(..., true).

+ *

+ * Returns: Pointer to the array that contains the pointers to the names.

+ */

+GPtrArray *qemu_get_nic_models(const char *device_type);

+

/* NIC info */

#define MAX_NICS 8

@@ -XXX,XX +XXX,XX @@ static int nic_get_free_idx(void)

return -1;

+GPtrArray *qemu_get_nic_models(const char *device_type)

+{

+ GPtrArray *nic_models = g_ptr_array_new();

+ GSList *list = object_class_get_list_sorted(device_type, false);

+

+ while (list) {

+ DeviceClass *dc = OBJECT_CLASS_CHECK(DeviceClass, list->data,

+ TYPE_DEVICE);

+ GSList *next;

+ if (test_bit(DEVICE_CATEGORY_NETWORK, dc->categories) &&

+ dc->user_creatable) {

+ const char *name = object_class_get_name(list->data);

+ /*

+ * A network device might also be something else than a NIC, see

+ * e.g. the "rocker" device. Thus we have to look for the "netdev"

+ * property, too. Unfortunately, some devices like virtio-net only

+ * create this property during instance_init, so we have to create

+ * a temporary instance here to be able to check it.

+ */

+ Object *obj = object_new_with_class(OBJECT_CLASS(dc));

+ if (object_property_find(obj, "netdev")) {

+ g_ptr_array_add(nic_models, (gpointer)name);

+ }

+ object_unref(obj);

+ }

+ next = list->next;

+ g_slist_free_1(list);

+ list = next;

+ }

+ g_ptr_array_add(nic_models, NULL);

+

+ return nic_models;

+}

+

int qemu_show_nic_models(const char *arg, const char *const *models)

int i;

From: Thomas Huth <thuth@redhat.com>

Running QEMU with "-nic help" used to work in QEMU 5.2 and earlier versions

(it showed the available netdev backends), but this feature got broken during

some refactoring in version 6.0. Let's restore the old behavior, and while

we're at it, let's also print the available NIC models here now since this

option can be used to configure both, netdev backend and model in one go.

Fixes: ad6f932fe8 ("net: do not exit on "netdev_add help" monitor command")

Signed-off-by: Thomas Huth <thuth@redhat.com>

net/net.c | 14 ++++++++++++--

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

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

--- a/net/net.c

+++ b/net/net.c

@@ -XXX,XX +XXX,XX @@ static int net_param_nic(void *dummy, QemuOpts *opts, Error **errp)

const char *type;

type = qemu_opt_get(opts, "type");

- if (type && g_str_equal(type, "none")) {

- return 0; /* Nothing to do, default_net is cleared in vl.c */

+ if (type) {

+ if (g_str_equal(type, "none")) {

+ return 0; /* Nothing to do, default_net is cleared in vl.c */

+ }

+ if (is_help_option(type)) {

+ GPtrArray *nic_models = qemu_get_nic_models(TYPE_DEVICE);

+ show_netdevs();

+ printf("\n");

+ qemu_show_nic_models(type, (const char **)nic_models->pdata);

+ g_ptr_array_free(nic_models, true);

+ exit(0);

+ }

}

idx = nic_get_free_idx();

From: Thomas Huth <thuth@redhat.com>

Just because a NIC model is compiled into the QEMU binary does not

necessary mean that it can be used with each and every machine.

So let's rather talk about "available" models instead of "supported"

models, just to avoid confusion.

Reviewed-by: Claudio Fontana <cfontana@suse.de>

Signed-off-by: Thomas Huth <thuth@redhat.com>

net/net.c | 2 +-

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

@@ -XXX,XX +XXX,XX @@ int qemu_show_nic_models(const char *arg, const char *const *models)

return 0;

From: Qiang Liu <cyruscyliu@gmail.com>

This patch replaces hw_error to guest error log for [read|write]b

accesses when mode_16bit is enabled. This avoids aborting qemu.

Fixes: 1248f8d4cbc3 ("hw/lan9118: Add basic 16-bit mode support.")

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

Reported-by: Qiang Liu <cyruscyliu@gmail.com>

Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>

Signed-off-by: Qiang Liu <cyruscyliu@gmail.com>

Suggested-by: Philippe Mathieu-Daudé <philmd@linaro.org>

hw/net/lan9118.c | 17 ++++++++---------

1 file changed, 8 insertions(+), 9 deletions(-)

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

--- a/hw/net/lan9118.c

+++ b/hw/net/lan9118.c

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

#include "migration/vmstate.h"

#include "net/net.h"

#include "net/eth.h"

-#include "hw/hw.h"

#include "hw/irq.h"

#include "hw/net/lan9118.h"

#include "hw/ptimer.h"

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

#ifdef DEBUG_LAN9118

#define DPRINTF(fmt, ...) \

do { printf("lan9118: " fmt , ## __VA_ARGS__); } while (0)

-#define BADF(fmt, ...) \

-do { hw_error("lan9118: error: " fmt , ## __VA_ARGS__);} while (0)

#else

#define DPRINTF(fmt, ...) do {} while(0)

-#define BADF(fmt, ...) \

-do { fprintf(stderr, "lan9118: error: " fmt , ## __VA_ARGS__);} while (0)

#endif

/* The tx and rx fifo ports are a range of aliased 32-bit registers */

@@ -XXX,XX +XXX,XX @@ static uint32_t do_phy_read(lan9118_state *s, int reg)

case 30: /* Interrupt mask */

return s->phy_int_mask;

default:

- BADF("PHY read reg %d\n", reg);

+ qemu_log_mask(LOG_GUEST_ERROR,

+ "do_phy_read: PHY read reg %d\n", reg);

return 0;

}

}

@@ -XXX,XX +XXX,XX @@ static void do_phy_write(lan9118_state *s, int reg, uint32_t val)

phy_update_irq(s);

break;

default:

- BADF("PHY write reg %d = 0x%04x\n", reg, val);

+ qemu_log_mask(LOG_GUEST_ERROR,

+ "do_phy_write: PHY write reg %d = 0x%04x\n", reg, val);

}

}

@@ -XXX,XX +XXX,XX @@ static void lan9118_16bit_mode_write(void *opaque, hwaddr offset,

return;

}

- hw_error("lan9118_write: Bad size 0x%x\n", size);

+ qemu_log_mask(LOG_GUEST_ERROR,

+ "lan9118_16bit_mode_write: Bad size 0x%x\n", size);

}

static uint64_t lan9118_readl(void *opaque, hwaddr offset,

@@ -XXX,XX +XXX,XX @@ static uint64_t lan9118_16bit_mode_read(void *opaque, hwaddr offset,

return lan9118_readl(opaque, offset, size);

}

- hw_error("lan9118_read: Bad size 0x%x\n", size);

+ qemu_log_mask(LOG_GUEST_ERROR,

+ "lan9118_16bit_mode_read: Bad size 0x%x\n", size);

return 0;

}

From: Laurent Vivier <lvivier@redhat.com>

In stream mode, if the server shuts down there is currently

no way to reconnect the client to a new server without removing

the NIC device and the netdev backend (or to reboot).

This patch introduces a reconnect option that specifies a delay

to try to reconnect with the same parameters.

Add a new test in qtest to test the reconnect option and the

connect/disconnect events.

Signed-off-by: Laurent Vivier <lvivier@redhat.com>

Signed-off-by: Jason Wang <jasowang@redhat.com>

---

net/stream.c | 53 ++++++++++++++++++++++-

qapi/net.json | 7 ++-

qemu-options.hx | 6 +--

tests/qtest/netdev-socket.c | 101 ++++++++++++++++++++++++++++++++++++++++++++

4 files changed, 162 insertions(+), 5 deletions(-)

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

index XXXXXXX..XXXXXXX 100644

--- a/net/stream.c

+++ b/net/stream.c

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

#include "io/channel-socket.h"

#include "io/net-listener.h"

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

+#include "qapi/qapi-visit-sockets.h"

+#include "qapi/clone-visitor.h"

typedef struct NetStreamState {

NetClientState nc;

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

guint ioc_write_tag;

SocketReadState rs;

unsigned int send_index; /* number of bytes sent*/

+ uint32_t reconnect;

+ guint timer_tag;

+ SocketAddress *addr;

} NetStreamState;

static void net_stream_listen(QIONetListener *listener,

QIOChannelSocket *cioc,

void *opaque);

+static void net_stream_arm_reconnect(NetStreamState *s);

static gboolean net_stream_writable(QIOChannel *ioc,

GIOCondition condition,

@@ -XXX,XX +XXX,XX @@ static gboolean net_stream_send(QIOChannel *ioc,

qemu_set_info_str(&s->nc, "%s", "");

qapi_event_send_netdev_stream_disconnected(s->nc.name);

+ net_stream_arm_reconnect(s);

return G_SOURCE_REMOVE;

}

@@ -XXX,XX +XXX,XX @@ static gboolean net_stream_send(QIOChannel *ioc,

static void net_stream_cleanup(NetClientState *nc)

{

NetStreamState *s = DO_UPCAST(NetStreamState, nc, nc);

+ if (s->timer_tag) {

+ g_source_remove(s->timer_tag);

+ s->timer_tag = 0;

+ }

+ if (s->addr) {

+ qapi_free_SocketAddress(s->addr);

+ s->addr = NULL;

+ }

if (s->ioc) {

if (QIO_CHANNEL_SOCKET(s->ioc)->fd != -1) {

if (s->ioc_read_tag) {

@@ -XXX,XX +XXX,XX @@ static void net_stream_client_connected(QIOTask *task, gpointer opaque)

error:

object_unref(OBJECT(s->ioc));

s->ioc = NULL;

+ net_stream_arm_reconnect(s);

+}

+

+static gboolean net_stream_reconnect(gpointer data)

+{

+ NetStreamState *s = data;

+ QIOChannelSocket *sioc;

+

+ s->timer_tag = 0;

+

+ sioc = qio_channel_socket_new();

+ s->ioc = QIO_CHANNEL(sioc);

+ qio_channel_socket_connect_async(sioc, s->addr,

+ net_stream_client_connected, s,

+ NULL, NULL);

+ return G_SOURCE_REMOVE;

+}

+

+static void net_stream_arm_reconnect(NetStreamState *s)

+{

+ if (s->reconnect && s->timer_tag == 0) {

+ s->timer_tag = g_timeout_add_seconds(s->reconnect,

+ net_stream_reconnect, s);

+ }

}

static int net_stream_client_init(NetClientState *peer,

const char *model,

const char *name,

SocketAddress *addr,

+ uint32_t reconnect,

Error **errp)

{

NetStreamState *s;

@@ -XXX,XX +XXX,XX @@ static int net_stream_client_init(NetClientState *peer,

s->ioc = QIO_CHANNEL(sioc);

s->nc.link_down = true;

+ s->reconnect = reconnect;

+ if (reconnect) {

+ s->addr = QAPI_CLONE(SocketAddress, addr);

+ }

qio_channel_socket_connect_async(sioc, addr,

net_stream_client_connected, s,

NULL, NULL);

@@ -XXX,XX +XXX,XX @@ int net_init_stream(const Netdev *netdev, const char *name,

sock = &netdev->u.stream;

if (!sock->has_server || !sock->server) {

- return net_stream_client_init(peer, "stream", name, sock->addr, errp);

+ return net_stream_client_init(peer, "stream", name, sock->addr,

+ sock->has_reconnect ? sock->reconnect : 0,

+ errp);

+ }

+ if (sock->has_reconnect) {

+ error_setg(errp, "'reconnect' option is incompatible with "

+ "socket in server mode");

+ return -1;

}

return net_stream_server_init(peer, "stream", name, sock->addr, errp);

}

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

index XXXXXXX..XXXXXXX 100644

--- a/qapi/net.json

+++ b/qapi/net.json

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

# @addr: socket address to listen on (server=true)

# or connect to (server=false)

# @server: create server socket (default: false)

+# @reconnect: For a client socket, if a socket is disconnected,

+# then attempt a reconnect after the given number of seconds.

+# Setting this to zero disables this function. (default: 0)

+# (since 8.0)

#

# Only SocketAddress types 'unix', 'inet' and 'fd' are supported.

#

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

{ 'struct': 'NetdevStreamOptions',

'data': {

'addr': 'SocketAddress',

- '*server': 'bool' } }

+ '*server': 'bool',

+ '*reconnect': 'uint32' } }

##

# @NetdevDgramOptions:

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

index XXXXXXX..XXXXXXX 100644

--- a/qemu-options.hx

+++ b/qemu-options.hx

@@ -XXX,XX +XXX,XX @@ DEF("netdev", HAS_ARG, QEMU_OPTION_netdev,

"-netdev socket,id=str[,fd=h][,udp=host:port][,localaddr=host:port]\n"

" configure a network backend to connect to another network\n"

" using an UDP tunnel\n"

- "-netdev stream,id=str[,server=on|off],addr.type=inet,addr.host=host,addr.port=port[,to=maxport][,numeric=on|off][,keep-alive=on|off][,mptcp=on|off][,addr.ipv4=on|off][,addr.ipv6=on|off]\n"

- "-netdev stream,id=str[,server=on|off],addr.type=unix,addr.path=path[,abstract=on|off][,tight=on|off]\n"

- "-netdev stream,id=str[,server=on|off],addr.type=fd,addr.str=file-descriptor\n"

+ "-netdev stream,id=str[,server=on|off],addr.type=inet,addr.host=host,addr.port=port[,to=maxport][,numeric=on|off][,keep-alive=on|off][,mptcp=on|off][,addr.ipv4=on|off][,addr.ipv6=on|off][,reconnect=seconds]\n"

+ "-netdev stream,id=str[,server=on|off],addr.type=unix,addr.path=path[,abstract=on|off][,tight=on|off][,reconnect=seconds]\n"

+ "-netdev stream,id=str[,server=on|off],addr.type=fd,addr.str=file-descriptor[,reconnect=seconds]\n"

" configure a network backend to connect to another network\n"

" using a socket connection in stream mode.\n"

"-netdev dgram,id=str,remote.type=inet,remote.host=maddr,remote.port=port[,local.type=inet,local.host=addr]\n"

diff --git a/tests/qtest/netdev-socket.c b/tests/qtest/netdev-socket.c

index XXXXXXX..XXXXXXX 100644

--- a/tests/qtest/netdev-socket.c

+++ b/tests/qtest/netdev-socket.c

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

#include <glib/gstdio.h>

#include "../unit/socket-helpers.h"

#include "libqtest.h"

+#include "qapi/qmp/qstring.h"

+#include "qemu/sockets.h"

+#include "qapi/qobject-input-visitor.h"

+#include "qapi/qapi-visit-sockets.h"

#define CONNECTION_TIMEOUT 60

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

qtest_quit(qts0);

}

+static void wait_stream_connected(QTestState *qts, const char *id,

+ SocketAddress **addr)

+{

+ QDict *resp, *data;

+ QString *qstr;

+ QObject *obj;

+ Visitor *v = NULL;

+

+ resp = qtest_qmp_eventwait_ref(qts, "NETDEV_STREAM_CONNECTED");

+ g_assert_nonnull(resp);

+ data = qdict_get_qdict(resp, "data");

+ g_assert_nonnull(data);

+

+ qstr = qobject_to(QString, qdict_get(data, "netdev-id"));

+ g_assert_nonnull(data);

+

+ g_assert(!strcmp(qstring_get_str(qstr), id));

+

+ obj = qdict_get(data, "addr");

+

+ v = qobject_input_visitor_new(obj);

+ visit_type_SocketAddress(v, NULL, addr, NULL);

+ visit_free(v);

+ qobject_unref(resp);

+}

+

+static void wait_stream_disconnected(QTestState *qts, const char *id)

+{

+ QDict *resp, *data;

+ QString *qstr;

+

+ resp = qtest_qmp_eventwait_ref(qts, "NETDEV_STREAM_DISCONNECTED");

+ g_assert_nonnull(resp);

+ data = qdict_get_qdict(resp, "data");

+ g_assert_nonnull(data);

+

+ qstr = qobject_to(QString, qdict_get(data, "netdev-id"));

+ g_assert_nonnull(data);

+

+ g_assert(!strcmp(qstring_get_str(qstr), id));

+ qobject_unref(resp);

+}

+

+static void test_stream_inet_reconnect(void)

+{

+ QTestState *qts0, *qts1;

+ int port;

+ SocketAddress *addr;

+

+ port = inet_get_free_port(false);

+ qts0 = qtest_initf("-nodefaults -M none "

+ "-netdev stream,id=st0,server=true,addr.type=inet,"

+ "addr.ipv4=on,addr.ipv6=off,"

+ "addr.host=127.0.0.1,addr.port=%d", port);

+

+ EXPECT_STATE(qts0, "st0: index=0,type=stream,\r\n", 0);

+

+ qts1 = qtest_initf("-nodefaults -M none "

+ "-netdev stream,server=false,id=st0,addr.type=inet,"

+ "addr.ipv4=on,addr.ipv6=off,reconnect=1,"

+ "addr.host=127.0.0.1,addr.port=%d", port);

+

+ wait_stream_connected(qts0, "st0", &addr);

+ g_assert_cmpint(addr->type, ==, SOCKET_ADDRESS_TYPE_INET);

+ g_assert_cmpstr(addr->u.inet.host, ==, "127.0.0.1");

+ qapi_free_SocketAddress(addr);

+

+ /* kill server */

+ qtest_quit(qts0);

+

+ /* check client has been disconnected */

+ wait_stream_disconnected(qts1, "st0");

+

+ /* restart server */

+ qts0 = qtest_initf("-nodefaults -M none "

+ "-netdev stream,id=st0,server=true,addr.type=inet,"

+ "addr.ipv4=on,addr.ipv6=off,"

+ "addr.host=127.0.0.1,addr.port=%d", port);

+

+ /* wait connection events*/

+ wait_stream_connected(qts0, "st0", &addr);

+ g_assert_cmpint(addr->type, ==, SOCKET_ADDRESS_TYPE_INET);

+ g_assert_cmpstr(addr->u.inet.host, ==, "127.0.0.1");

+ qapi_free_SocketAddress(addr);

+

+ wait_stream_connected(qts1, "st0", &addr);

+ g_assert_cmpint(addr->type, ==, SOCKET_ADDRESS_TYPE_INET);

+ g_assert_cmpstr(addr->u.inet.host, ==, "127.0.0.1");

+ g_assert_cmpint(atoi(addr->u.inet.port), ==, port);

+ qapi_free_SocketAddress(addr);

+

+ qtest_quit(qts1);

+ qtest_quit(qts0);

+}

+

static void test_stream_inet_ipv6(void)

{

QTestState *qts0, *qts1;

@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)

#ifndef _WIN32

qtest_add_func("/netdev/dgram/mcast", test_dgram_mcast);

#endif

+ qtest_add_func("/netdev/stream/inet/reconnect",

+ test_stream_inet_reconnect);

}

if (has_ipv6) {

qtest_add_func("/netdev/stream/inet/ipv6", test_stream_inet_ipv6);

--

2.7.4

From: Eugenio Pérez <eperezma@redhat.com>

VHOST_BACKEND_F_IOTLB_ASID is the feature bit, not the bitmask. Since

the device under test also provided VHOST_BACKEND_F_IOTLB_MSG_V2 and

VHOST_BACKEND_F_IOTLB_BATCH, this went unnoticed.

Fixes: c1a1008685 ("vdpa: always start CVQ in SVQ mode if possible")

Signed-off-by: Eugenio Pérez <eperezma@redhat.com>

Reviewed-by: Michael S. Tsirkin <mst@redhat.com>

Acked-by: Jason Wang <jasowang@redhat.com>

net/vhost-vdpa.c | 2 +-

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

diff --git a/net/vhost-vdpa.c b/net/vhost-vdpa.c

--- a/net/vhost-vdpa.c

+++ b/net/vhost-vdpa.c

@@ -XXX,XX +XXX,XX @@ static int vhost_vdpa_net_cvq_start(NetClientState *nc)

g_strerror(errno), errno);

return -1;

}

- if (!(backend_features & VHOST_BACKEND_F_IOTLB_ASID) ||

+ if (!(backend_features & BIT_ULL(VHOST_BACKEND_F_IOTLB_ASID)) ||

!vhost_vdpa_net_valid_svq_features(v->dev->features, NULL)) {

return 0;

}