vitalif
/
mirror_qemu
mirror of https://github.com/proxmox/mirror_qemu
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

hw/xen: update Xen PV NIC to XenDevice model 

This allows us to use Xen PV networking with emulated Xen guests, and to
add them on the command line or hotplug.

Signed-off-by: David Woodhouse <dwmw@amazon.co.uk>
Reviewed-by: Paul Durrant <paul@xen.org>
master
David Woodhouse 2023-10-17 13:58:03 +01:00
parent 25511f3e8c
commit 25967ff69f
4 changed files with 383 additions and 119 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
hw/net/meson.build
View File

@ -1,5 +1,5 @@
system_ss.add(when: 'CONFIG_DP8393X', if_true: files('dp8393x.c'))
system_ss.add(when: 'CONFIG_XEN', if_true: files('xen_nic.c'))
system_ss.add(when: 'CONFIG_XEN_BUS', if_true: files('xen_nic.c'))
system_ss.add(when: 'CONFIG_NE2000_COMMON', if_true: files('ne2000.c'))
# PCI network cards

11
hw/net/trace-events
View File

@ -482,3 +482,14 @@ dp8393x_receive_oversize(int size) "oversize packet, pkt_size is %d"
dp8393x_receive_not_netcard(void) "packet not for netcard"
dp8393x_receive_packet(int crba) "Receive packet at 0x%"PRIx32
dp8393x_receive_write_status(int crba) "Write status at 0x%"PRIx32
# xen_nic.c
xen_netdev_realize(int dev, const char *info, const char *peer) "vif%u info '%s' peer '%s'"
xen_netdev_unrealize(int dev) "vif%u"
xen_netdev_create(int dev) "vif%u"
xen_netdev_destroy(int dev) "vif%u"
xen_netdev_disconnect(int dev) "vif%u"
xen_netdev_connect(int dev, unsigned int tx, unsigned int rx, int port) "vif%u tx %u rx %u port %u"
xen_netdev_frontend_changed(const char *dev, int state) "vif%s state %d"
xen_netdev_tx(int dev, int ref, int off, int len, unsigned int flags, const char *c, const char *d, const char *m, const char *e) "vif%u ref %u off %u len %u flags 0x%x%s%s%s%s"
xen_netdev_rx(int dev, int idx, int status, int flags) "vif%u idx %d status %d flags 0x%x"

488
hw/net/xen_nic.c
View File

@ -20,6 +20,13 @@
*/
#include "qemu/osdep.h"
#include "qemu/main-loop.h"
#include "qemu/cutils.h"
#include "qemu/log.h"
#include "qemu/qemu-print.h"
#include "qapi/qmp/qdict.h"
#include "qapi/error.h"
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <sys/wait.h>
@ -27,18 +34,26 @@
#include "net/net.h"
#include "net/checksum.h"
#include "net/util.h"
#include "hw/xen/xen-legacy-backend.h"
#include "hw/xen/xen-backend.h"
#include "hw/xen/xen-bus-helper.h"
#include "hw/qdev-properties.h"
#include "hw/qdev-properties-system.h"
#include "hw/xen/interface/io/netif.h"
#include "hw/xen/interface/io/xs_wire.h"
#include "trace.h"
/* ------------------------------------------------------------- */
struct XenNetDev {
struct XenLegacyDevice xendev; /* must be first */
char *mac;
struct XenDevice xendev; /* must be first */
XenEventChannel *event_channel;
int dev;
int tx_work;
int tx_ring_ref;
int rx_ring_ref;
unsigned int tx_ring_ref;
unsigned int rx_ring_ref;
struct netif_tx_sring *txs;
struct netif_rx_sring *rxs;
netif_tx_back_ring_t tx_ring;
@ -47,6 +62,11 @@ struct XenNetDev {
NICState *nic;
};
typedef struct XenNetDev XenNetDev;
#define TYPE_XEN_NET_DEVICE "xen-net-device"
OBJECT_DECLARE_SIMPLE_TYPE(XenNetDev, XEN_NET_DEVICE)
/* ------------------------------------------------------------- */
static void net_tx_response(struct XenNetDev *netdev, netif_tx_request_t *txp, int8_t st)
@ -68,7 +88,8 @@ static void net_tx_response(struct XenNetDev *netdev, netif_tx_request_t *txp, i
netdev->tx_ring.rsp_prod_pvt = ++i;
RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(&netdev->tx_ring, notify);
if (notify) {
xen_pv_send_notify(&netdev->xendev);
xen_device_notify_event_channel(XEN_DEVICE(netdev),
netdev->event_channel, NULL);
}
if (i == netdev->tx_ring.req_cons) {
@ -104,13 +125,16 @@ static void net_tx_error(struct XenNetDev *netdev, netif_tx_request_t *txp, RING
#endif
}
static void net_tx_packets(struct XenNetDev *netdev)
static bool net_tx_packets(struct XenNetDev *netdev)
{
bool done_something = false;
netif_tx_request_t txreq;
RING_IDX rc, rp;
void *page;
void *tmpbuf = NULL;
assert(qemu_mutex_iothread_locked());
for (;;) {
rc = netdev->tx_ring.req_cons;
rp = netdev->tx_ring.sring->req_prod;
@ -122,49 +146,52 @@ static void net_tx_packets(struct XenNetDev *netdev)
}
memcpy(&txreq, RING_GET_REQUEST(&netdev->tx_ring, rc), sizeof(txreq));
netdev->tx_ring.req_cons = ++rc;
done_something = true;
#if 1
/* should not happen in theory, we don't announce the *
* feature-{sg,gso,whatelse} flags in xenstore (yet?) */
if (txreq.flags & NETTXF_extra_info) {
xen_pv_printf(&netdev->xendev, 0, "FIXME: extra info flag\n");
qemu_log_mask(LOG_UNIMP, "vif%u: FIXME: extra info flag\n",
netdev->dev);
net_tx_error(netdev, &txreq, rc);
continue;
}
if (txreq.flags & NETTXF_more_data) {
xen_pv_printf(&netdev->xendev, 0, "FIXME: more data flag\n");
qemu_log_mask(LOG_UNIMP, "vif%u: FIXME: more data flag\n",
netdev->dev);
net_tx_error(netdev, &txreq, rc);
continue;
}
#endif
if (txreq.size < 14) {
xen_pv_printf(&netdev->xendev, 0, "bad packet size: %d\n",
txreq.size);
qemu_log_mask(LOG_GUEST_ERROR, "vif%u: bad packet size: %d\n",
netdev->dev, txreq.size);
net_tx_error(netdev, &txreq, rc);
continue;
}
if ((txreq.offset + txreq.size) > XEN_PAGE_SIZE) {
xen_pv_printf(&netdev->xendev, 0, "error: page crossing\n");
qemu_log_mask(LOG_GUEST_ERROR, "vif%u: error: page crossing\n",
netdev->dev);
net_tx_error(netdev, &txreq, rc);
continue;
}
xen_pv_printf(&netdev->xendev, 3,
"tx packet ref %d, off %d, len %d, flags 0x%x%s%s%s%s\n",
txreq.gref, txreq.offset, txreq.size, txreq.flags,
(txreq.flags & NETTXF_csum_blank) ? " csum_blank" : "",
(txreq.flags & NETTXF_data_validated) ? " data_validated" : "",
(txreq.flags & NETTXF_more_data) ? " more_data" : "",
(txreq.flags & NETTXF_extra_info) ? " extra_info" : "");
trace_xen_netdev_tx(netdev->dev, txreq.gref, txreq.offset,
txreq.size, txreq.flags,
(txreq.flags & NETTXF_csum_blank) ? " csum_blank" : "",
(txreq.flags & NETTXF_data_validated) ? " data_validated" : "",
(txreq.flags & NETTXF_more_data) ? " more_data" : "",
(txreq.flags & NETTXF_extra_info) ? " extra_info" : "");
page = xen_be_map_grant_ref(&netdev->xendev, txreq.gref,
PROT_READ);
page = xen_device_map_grant_refs(&netdev->xendev, &txreq.gref, 1,
PROT_READ, NULL);
if (page == NULL) {
xen_pv_printf(&netdev->xendev, 0,
"error: tx gref dereference failed (%d)\n",
txreq.gref);
qemu_log_mask(LOG_GUEST_ERROR,
"vif%u: tx gref dereference failed (%d)\n",
netdev->dev, txreq.gref);
net_tx_error(netdev, &txreq, rc);
continue;
}
@ -181,7 +208,8 @@ static void net_tx_packets(struct XenNetDev *netdev)
qemu_send_packet(qemu_get_queue(netdev->nic),
page + txreq.offset, txreq.size);
}
xen_be_unmap_grant_ref(&netdev->xendev, page, txreq.gref);
xen_device_unmap_grant_refs(&netdev->xendev, page, &txreq.gref, 1,
NULL);
net_tx_response(netdev, &txreq, NETIF_RSP_OKAY);
}
if (!netdev->tx_work) {
@ -190,6 +218,7 @@ static void net_tx_packets(struct XenNetDev *netdev)
netdev->tx_work = 0;
}
g_free(tmpbuf);
return done_something;
}
/* ------------------------------------------------------------- */
@ -212,14 +241,13 @@ static void net_rx_response(struct XenNetDev *netdev,
resp->status = (int16_t)st;
}
xen_pv_printf(&netdev->xendev, 3,
"rx response: idx %d, status %d, flags 0x%x\n",
i, resp->status, resp->flags);
trace_xen_netdev_rx(netdev->dev, i, resp->status, resp->flags);
netdev->rx_ring.rsp_prod_pvt = ++i;
RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(&netdev->rx_ring, notify);
if (notify) {
xen_pv_send_notify(&netdev->xendev);
xen_device_notify_event_channel(XEN_DEVICE(netdev),
netdev->event_channel, NULL);
}
}
@ -232,7 +260,9 @@ static ssize_t net_rx_packet(NetClientState *nc, const uint8_t *buf, size_t size
RING_IDX rc, rp;
void *page;
if (netdev->xendev.be_state != XenbusStateConnected) {
assert(qemu_mutex_iothread_locked());
if (xen_device_backend_get_state(&netdev->xendev) != XenbusStateConnected) {
return -1;
}
@ -244,24 +274,26 @@ static ssize_t net_rx_packet(NetClientState *nc, const uint8_t *buf, size_t size
return 0;
}
if (size > XEN_PAGE_SIZE - NET_IP_ALIGN) {
xen_pv_printf(&netdev->xendev, 0, "packet too big (%lu > %ld)",
(unsigned long)size, XEN_PAGE_SIZE - NET_IP_ALIGN);
qemu_log_mask(LOG_GUEST_ERROR, "vif%u: packet too big (%lu > %ld)",
netdev->dev, (unsigned long)size,
XEN_PAGE_SIZE - NET_IP_ALIGN);
return -1;
}
memcpy(&rxreq, RING_GET_REQUEST(&netdev->rx_ring, rc), sizeof(rxreq));
netdev->rx_ring.req_cons = ++rc;
page = xen_be_map_grant_ref(&netdev->xendev, rxreq.gref, PROT_WRITE);
page = xen_device_map_grant_refs(&netdev->xendev, &rxreq.gref, 1,
PROT_WRITE, NULL);
if (page == NULL) {
xen_pv_printf(&netdev->xendev, 0,
"error: rx gref dereference failed (%d)\n",
rxreq.gref);
qemu_log_mask(LOG_GUEST_ERROR,
"vif%u: rx gref dereference failed (%d)\n",
netdev->dev, rxreq.gref);
net_rx_response(netdev, &rxreq, NETIF_RSP_ERROR, 0, 0, 0);
return -1;
}
memcpy(page + NET_IP_ALIGN, buf, size);
xen_be_unmap_grant_ref(&netdev->xendev, page, rxreq.gref);
xen_device_unmap_grant_refs(&netdev->xendev, page, &rxreq.gref, 1, NULL);
net_rx_response(netdev, &rxreq, NETIF_RSP_OKAY, NET_IP_ALIGN, size, 0);
return size;
@ -275,139 +307,361 @@ static NetClientInfo net_xen_info = {
.receive = net_rx_packet,
};
static int net_init(struct XenLegacyDevice *xendev)
static void xen_netdev_realize(XenDevice *xendev, Error **errp)
{
struct XenNetDev *netdev = container_of(xendev, struct XenNetDev, xendev);
ERRP_GUARD();
XenNetDev *netdev = XEN_NET_DEVICE(xendev);
NetClientState *nc;
/* read xenstore entries */
if (netdev->mac == NULL) {
netdev->mac = xenstore_read_be_str(&netdev->xendev, "mac");
}
qemu_macaddr_default_if_unset(&netdev->conf.macaddr);
/* do we have all we need? */
if (netdev->mac == NULL) {
return -1;
}
if (net_parse_macaddr(netdev->conf.macaddr.a, netdev->mac) < 0) {
return -1;
}
xen_device_frontend_printf(xendev, "mac", "%02x:%02x:%02x:%02x:%02x:%02x",
netdev->conf.macaddr.a[0],
netdev->conf.macaddr.a[1],
netdev->conf.macaddr.a[2],
netdev->conf.macaddr.a[3],
netdev->conf.macaddr.a[4],
netdev->conf.macaddr.a[5]);
netdev->nic = qemu_new_nic(&net_xen_info, &netdev->conf,
"xen", NULL, netdev);
object_get_typename(OBJECT(xendev)),
DEVICE(xendev)->id, netdev);
qemu_set_info_str(qemu_get_queue(netdev->nic),
"nic: xenbus vif macaddr=%s", netdev->mac);
nc = qemu_get_queue(netdev->nic);
qemu_format_nic_info_str(nc, netdev->conf.macaddr.a);
/* fill info */
xenstore_write_be_int(&netdev->xendev, "feature-rx-copy", 1);
xenstore_write_be_int(&netdev->xendev, "feature-rx-flip", 0);
xen_device_backend_printf(xendev, "feature-rx-copy", "%u", 1);
xen_device_backend_printf(xendev, "feature-rx-flip", "%u", 0);
return 0;
trace_xen_netdev_realize(netdev->dev, nc->info_str, nc->peer ?
nc->peer->name : "(none)");
}
static int net_connect(struct XenLegacyDevice *xendev)
static bool net_event(void *_xendev)
{
struct XenNetDev *netdev = container_of(xendev, struct XenNetDev, xendev);
int rx_copy;
XenNetDev *netdev = XEN_NET_DEVICE(_xendev);
bool done_something;
if (xenstore_read_fe_int(&netdev->xendev, "tx-ring-ref",
&netdev->tx_ring_ref) == -1) {
return -1;
}
if (xenstore_read_fe_int(&netdev->xendev, "rx-ring-ref",
&netdev->rx_ring_ref) == -1) {
return 1;
}
if (xenstore_read_fe_int(&netdev->xendev, "event-channel",
&netdev->xendev.remote_port) == -1) {
return -1;
done_something = net_tx_packets(netdev);
qemu_flush_queued_packets(qemu_get_queue(netdev->nic));
return done_something;
}
static bool xen_netdev_connect(XenDevice *xendev, Error **errp)
{
XenNetDev *netdev = XEN_NET_DEVICE(xendev);
unsigned int port, rx_copy;
assert(qemu_mutex_iothread_locked());
if (xen_device_frontend_scanf(xendev, "tx-ring-ref", "%u",
&netdev->tx_ring_ref) != 1) {
error_setg(errp, "failed to read tx-ring-ref");
return false;
}
if (xenstore_read_fe_int(&netdev->xendev, "request-rx-copy", &rx_copy) == -1) {
if (xen_device_frontend_scanf(xendev, "rx-ring-ref", "%u",
&netdev->rx_ring_ref) != 1) {
error_setg(errp, "failed to read rx-ring-ref");
return false;
}
if (xen_device_frontend_scanf(xendev, "event-channel", "%u",
&port) != 1) {
error_setg(errp, "failed to read event-channel");
return false;
}
if (xen_device_frontend_scanf(xendev, "request-rx-copy", "%u",
&rx_copy) != 1) {
rx_copy = 0;
}
if (rx_copy == 0) {
xen_pv_printf(&netdev->xendev, 0,
"frontend doesn't support rx-copy.\n");
return -1;
error_setg(errp, "frontend doesn't support rx-copy");
return false;
}
netdev->txs = xen_be_map_grant_ref(&netdev->xendev,
netdev->tx_ring_ref,
PROT_READ | PROT_WRITE);
netdev->txs = xen_device_map_grant_refs(xendev,
&netdev->tx_ring_ref, 1,
PROT_READ | PROT_WRITE,
errp);
if (!netdev->txs) {
return -1;
error_prepend(errp, "failed to map tx grant ref: ");
return false;
}
netdev->rxs = xen_be_map_grant_ref(&netdev->xendev,
netdev->rx_ring_ref,
PROT_READ | PROT_WRITE);
netdev->rxs = xen_device_map_grant_refs(xendev,
&netdev->rx_ring_ref, 1,
PROT_READ | PROT_WRITE,
errp);
if (!netdev->rxs) {
xen_be_unmap_grant_ref(&netdev->xendev, netdev->txs,
netdev->tx_ring_ref);
netdev->txs = NULL;
return -1;
error_prepend(errp, "failed to map rx grant ref: ");
return false;
}
BACK_RING_INIT(&netdev->tx_ring, netdev->txs, XEN_PAGE_SIZE);
BACK_RING_INIT(&netdev->rx_ring, netdev->rxs, XEN_PAGE_SIZE);
xen_be_bind_evtchn(&netdev->xendev);
netdev->event_channel = xen_device_bind_event_channel(xendev, port,
net_event,
netdev,
errp);
if (!netdev->event_channel) {
return false;
}
xen_pv_printf(&netdev->xendev, 1, "ok: tx-ring-ref %d, rx-ring-ref %d, "
"remote port %d, local port %d\n",
netdev->tx_ring_ref, netdev->rx_ring_ref,
netdev->xendev.remote_port, netdev->xendev.local_port);
trace_xen_netdev_connect(netdev->dev, netdev->tx_ring_ref,
netdev->rx_ring_ref, port);
net_tx_packets(netdev);
return 0;
return true;
}
static void net_disconnect(struct XenLegacyDevice *xendev)
static void xen_netdev_disconnect(XenDevice *xendev, Error **errp)
{
struct XenNetDev *netdev = container_of(xendev, struct XenNetDev, xendev);
XenNetDev *netdev = XEN_NET_DEVICE(xendev);
xen_pv_unbind_evtchn(&netdev->xendev);
trace_xen_netdev_disconnect(netdev->dev);
assert(qemu_mutex_iothread_locked());
netdev->tx_ring.sring = NULL;
netdev->rx_ring.sring = NULL;
if (netdev->event_channel) {
xen_device_unbind_event_channel(xendev, netdev->event_channel,
errp);
netdev->event_channel = NULL;
}
if (netdev->txs) {
xen_be_unmap_grant_ref(&netdev->xendev, netdev->txs,
netdev->tx_ring_ref);
xen_device_unmap_grant_refs(xendev, netdev->txs,
&netdev->tx_ring_ref, 1, errp);
netdev->txs = NULL;
}
if (netdev->rxs) {
xen_be_unmap_grant_ref(&netdev->xendev, netdev->rxs,
netdev->rx_ring_ref);
xen_device_unmap_grant_refs(xendev, netdev->rxs,
&netdev->rx_ring_ref, 1, errp);
netdev->rxs = NULL;
}
}
static void net_event(struct XenLegacyDevice *xendev)
/* -------------------------------------------------------------------- */
static void xen_netdev_frontend_changed(XenDevice *xendev,
enum xenbus_state frontend_state,
Error **errp)
{
struct XenNetDev *netdev = container_of(xendev, struct XenNetDev, xendev);
net_tx_packets(netdev);
qemu_flush_queued_packets(qemu_get_queue(netdev->nic));
ERRP_GUARD();
enum xenbus_state backend_state = xen_device_backend_get_state(xendev);
trace_xen_netdev_frontend_changed(xendev->name, frontend_state);
switch (frontend_state) {
case XenbusStateConnected:
if (backend_state == XenbusStateConnected) {
break;
}
xen_netdev_disconnect(xendev, errp);
if (*errp) {
break;
}
if (!xen_netdev_connect(xendev, errp)) {
xen_netdev_disconnect(xendev, NULL);
xen_device_backend_set_state(xendev, XenbusStateClosing);
break;
}
xen_device_backend_set_state(xendev, XenbusStateConnected);
break;
case XenbusStateClosing:
xen_device_backend_set_state(xendev, XenbusStateClosing);
break;
case XenbusStateClosed:
case XenbusStateUnknown:
xen_netdev_disconnect(xendev, errp);
if (*errp) {
break;
}
xen_device_backend_set_state(xendev, XenbusStateClosed);
break;
case XenbusStateInitialised:
/*
* Linux netback does nothing on the frontend going (back) to
* XenbusStateInitialised, so do the same here.
*/
default:
break;
}
}
static int net_free(struct XenLegacyDevice *xendev)
static char *xen_netdev_get_name(XenDevice *xendev, Error **errp)
{
struct XenNetDev *netdev = container_of(xendev, struct XenNetDev, xendev);
XenNetDev *netdev = XEN_NET_DEVICE(xendev);
if (netdev->dev == -1) {
XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev)));
char fe_path[XENSTORE_ABS_PATH_MAX + 1];
int idx = (xen_mode == XEN_EMULATE) ? 0 : 1;
char *value;
/* Theoretically we could go up to INT_MAX here but that's overkill */
while (idx < 100) {
snprintf(fe_path, sizeof(fe_path),
"/local/domain/%u/device/vif/%u",
xendev->frontend_id, idx);
value = qemu_xen_xs_read(xenbus->xsh, XBT_NULL, fe_path, NULL);
if (!value) {
if (errno == ENOENT) {
netdev->dev = idx;
goto found;
}
error_setg(errp, "cannot read %s: %s", fe_path,
strerror(errno));
return NULL;
}
free(value);
idx++;
}
error_setg(errp, "cannot find device index for netdev device");
return NULL;
}
found:
return g_strdup_printf("%u", netdev->dev);
}
static void xen_netdev_unrealize(XenDevice *xendev)
{
XenNetDev *netdev = XEN_NET_DEVICE(xendev);
trace_xen_netdev_unrealize(netdev->dev);
/* Disconnect from the frontend in case this has not already happened */
xen_netdev_disconnect(xendev, NULL);
if (netdev->nic) {
qemu_del_nic(netdev->nic);
netdev->nic = NULL;
}
g_free(netdev->mac);
netdev->mac = NULL;
return 0;
}
/* ------------------------------------------------------------- */
struct XenDevOps xen_netdev_ops = {
.size = sizeof(struct XenNetDev),
.flags = DEVOPS_FLAG_NEED_GNTDEV,
.init = net_init,
.initialise = net_connect,
.event = net_event,
.disconnect = net_disconnect,
.free = net_free,
static Property xen_netdev_properties[] = {
DEFINE_NIC_PROPERTIES(XenNetDev, conf),
DEFINE_PROP_INT32("idx", XenNetDev, dev, -1),
DEFINE_PROP_END_OF_LIST(),
};
static void xen_netdev_class_init(ObjectClass *class, void *data)
{
DeviceClass *dev_class = DEVICE_CLASS(class);
XenDeviceClass *xendev_class = XEN_DEVICE_CLASS(class);
xendev_class->backend = "qnic";
xendev_class->device = "vif";
xendev_class->get_name = xen_netdev_get_name;
xendev_class->realize = xen_netdev_realize;
xendev_class->frontend_changed = xen_netdev_frontend_changed;
xendev_class->unrealize = xen_netdev_unrealize;
set_bit(DEVICE_CATEGORY_NETWORK, dev_class->categories);
dev_class->user_creatable = true;
device_class_set_props(dev_class, xen_netdev_properties);
}
static const TypeInfo xen_net_type_info = {
.name = TYPE_XEN_NET_DEVICE,
.parent = TYPE_XEN_DEVICE,
.instance_size = sizeof(XenNetDev),
.class_init = xen_netdev_class_init,
};
static void xen_net_register_types(void)
{
type_register_static(&xen_net_type_info);
}
type_init(xen_net_register_types)
/* Called to instantiate a XenNetDev when the backend is detected. */
static void xen_net_device_create(XenBackendInstance *backend,
QDict *opts, Error **errp)
{
ERRP_GUARD();
XenBus *xenbus = xen_backend_get_bus(backend);
const char *name = xen_backend_get_name(backend);
XenDevice *xendev = NULL;
unsigned long number;
const char *macstr;
XenNetDev *net;
MACAddr mac;
if (qemu_strtoul(name, NULL, 10, &number) || number >= INT_MAX) {
error_setg(errp, "failed to parse name '%s'", name);
goto fail;
}
trace_xen_netdev_create(number);
macstr = qdict_get_try_str(opts, "mac");
if (macstr == NULL) {
error_setg(errp, "no MAC address found");
goto fail;
}
if (net_parse_macaddr(mac.a, macstr) < 0) {
error_setg(errp, "failed to parse MAC address");
goto fail;
}
xendev = XEN_DEVICE(qdev_new(TYPE_XEN_NET_DEVICE));
net = XEN_NET_DEVICE(xendev);
net->dev = number;
memcpy(&net->conf.macaddr, &mac, sizeof(mac));
if (qdev_realize_and_unref(DEVICE(xendev), BUS(xenbus), errp)) {
xen_backend_set_device(backend, xendev);
return;
}
error_prepend(errp, "realization of net device %lu failed: ",
number);
fail:
if (xendev) {
object_unparent(OBJECT(xendev));
}
}
static void xen_net_device_destroy(XenBackendInstance *backend,
Error **errp)
{
ERRP_GUARD();
XenDevice *xendev = xen_backend_get_device(backend);
XenNetDev *netdev = XEN_NET_DEVICE(xendev);
trace_xen_netdev_destroy(netdev->dev);
object_unparent(OBJECT(xendev));
}
static const XenBackendInfo xen_net_backend_info = {
.type = "qnic",
.create = xen_net_device_create,
.destroy = xen_net_device_destroy,
};
static void xen_net_register_backend(void)
{
xen_backend_register(&xen_net_backend_info);
}
xen_backend_init(xen_net_register_backend);

1
hw/xenpv/xen_machine_pv.c
View File

@ -54,7 +54,6 @@ static void xen_init_pv(MachineState *machine)
}
xen_be_register("vfb", &xen_framebuffer_ops);
xen_be_register("qnic", &xen_netdev_ops);
/* configure framebuffer */
if (vga_interface_type == VGA_XENFB) {