2
* xen paravirt network card backend
4
* (c) Gerd Hoffmann <kraxel@redhat.com>
6
* This program is free software; you can redistribute it and/or modify
7
* it under the terms of the GNU General Public License as published by
8
* the Free Software Foundation; under version 2 of the License.
10
* This program is distributed in the hope that it will be useful,
11
* but WITHOUT ANY WARRANTY; without even the implied warranty of
12
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13
* GNU General Public License for more details.
15
* You should have received a copy of the GNU General Public License along
16
* with this program; if not, see <http://www.gnu.org/licenses/>.
29
#include <sys/socket.h>
30
#include <sys/ioctl.h>
31
#include <sys/types.h>
38
#include <xen/io/xenbus.h>
39
#include <xen/io/netif.h>
43
#include "qemu-char.h"
44
#include "xen_backend.h"
46
/* ------------------------------------------------------------- */
49
struct XenDevice xendev; /* must be first */
54
struct netif_tx_sring *txs;
55
struct netif_rx_sring *rxs;
56
netif_tx_back_ring_t tx_ring;
57
netif_rx_back_ring_t rx_ring;
61
/* ------------------------------------------------------------- */
63
static void net_tx_response(struct XenNetDev *netdev, netif_tx_request_t *txp, int8_t st)
65
RING_IDX i = netdev->tx_ring.rsp_prod_pvt;
66
netif_tx_response_t *resp;
69
resp = RING_GET_RESPONSE(&netdev->tx_ring, i);
74
if (txp->flags & NETTXF_extra_info)
75
RING_GET_RESPONSE(&netdev->tx_ring, ++i)->status = NETIF_RSP_NULL;
78
netdev->tx_ring.rsp_prod_pvt = ++i;
79
RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(&netdev->tx_ring, notify);
81
xen_be_send_notify(&netdev->xendev);
83
if (i == netdev->tx_ring.req_cons) {
85
RING_FINAL_CHECK_FOR_REQUESTS(&netdev->tx_ring, more_to_do);
91
static void net_tx_error(struct XenNetDev *netdev, netif_tx_request_t *txp, RING_IDX end)
95
* Hmm, why netback fails everything in the ring?
96
* Should we do that even when not supporting SG and TSO?
98
RING_IDX cons = netdev->tx_ring.req_cons;
101
make_tx_response(netif, txp, NETIF_RSP_ERROR);
104
txp = RING_GET_REQUEST(&netdev->tx_ring, cons++);
106
netdev->tx_ring.req_cons = cons;
107
netif_schedule_work(netif);
110
net_tx_response(netdev, txp, NETIF_RSP_ERROR);
114
static void net_tx_packets(struct XenNetDev *netdev)
116
netif_tx_request_t txreq;
122
rc = netdev->tx_ring.req_cons;
123
rp = netdev->tx_ring.sring->req_prod;
124
xen_rmb(); /* Ensure we see queued requests up to 'rp'. */
127
if (RING_REQUEST_CONS_OVERFLOW(&netdev->tx_ring, rc))
129
memcpy(&txreq, RING_GET_REQUEST(&netdev->tx_ring, rc), sizeof(txreq));
130
netdev->tx_ring.req_cons = ++rc;
133
/* should not happen in theory, we don't announce the *
134
* feature-{sg,gso,whatelse} flags in xenstore (yet?) */
135
if (txreq.flags & NETTXF_extra_info) {
136
xen_be_printf(&netdev->xendev, 0, "FIXME: extra info flag\n");
137
net_tx_error(netdev, &txreq, rc);
140
if (txreq.flags & NETTXF_more_data) {
141
xen_be_printf(&netdev->xendev, 0, "FIXME: more data flag\n");
142
net_tx_error(netdev, &txreq, rc);
147
if (txreq.size < 14) {
148
xen_be_printf(&netdev->xendev, 0, "bad packet size: %d\n", txreq.size);
149
net_tx_error(netdev, &txreq, rc);
153
if ((txreq.offset + txreq.size) > XC_PAGE_SIZE) {
154
xen_be_printf(&netdev->xendev, 0, "error: page crossing\n");
155
net_tx_error(netdev, &txreq, rc);
159
xen_be_printf(&netdev->xendev, 3, "tx packet ref %d, off %d, len %d, flags 0x%x%s%s%s%s\n",
160
txreq.gref, txreq.offset, txreq.size, txreq.flags,
161
(txreq.flags & NETTXF_csum_blank) ? " csum_blank" : "",
162
(txreq.flags & NETTXF_data_validated) ? " data_validated" : "",
163
(txreq.flags & NETTXF_more_data) ? " more_data" : "",
164
(txreq.flags & NETTXF_extra_info) ? " extra_info" : "");
166
page = xc_gnttab_map_grant_ref(netdev->xendev.gnttabdev,
168
txreq.gref, PROT_READ);
170
xen_be_printf(&netdev->xendev, 0, "error: tx gref dereference failed (%d)\n",
172
net_tx_error(netdev, &txreq, rc);
175
if (txreq.flags & NETTXF_csum_blank) {
176
/* have read-only mapping -> can't fill checksum in-place */
178
tmpbuf = qemu_malloc(XC_PAGE_SIZE);
179
memcpy(tmpbuf, page + txreq.offset, txreq.size);
180
net_checksum_calculate(tmpbuf, txreq.size);
181
qemu_send_packet(netdev->vs, tmpbuf, txreq.size);
183
qemu_send_packet(netdev->vs, page + txreq.offset, txreq.size);
185
xc_gnttab_munmap(netdev->xendev.gnttabdev, page, 1);
186
net_tx_response(netdev, &txreq, NETIF_RSP_OKAY);
188
if (!netdev->tx_work)
195
/* ------------------------------------------------------------- */
197
static void net_rx_response(struct XenNetDev *netdev,
198
netif_rx_request_t *req, int8_t st,
199
uint16_t offset, uint16_t size,
202
RING_IDX i = netdev->rx_ring.rsp_prod_pvt;
203
netif_rx_response_t *resp;
206
resp = RING_GET_RESPONSE(&netdev->rx_ring, i);
207
resp->offset = offset;
210
resp->status = (int16_t)size;
212
resp->status = (int16_t)st;
214
xen_be_printf(&netdev->xendev, 3, "rx response: idx %d, status %d, flags 0x%x\n",
215
i, resp->status, resp->flags);
217
netdev->rx_ring.rsp_prod_pvt = ++i;
218
RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(&netdev->rx_ring, notify);
220
xen_be_send_notify(&netdev->xendev);
223
#define NET_IP_ALIGN 2
225
static int net_rx_ok(VLANClientState *vc)
227
struct XenNetDev *netdev = vc->opaque;
230
if (netdev->xendev.be_state != XenbusStateConnected)
233
rc = netdev->rx_ring.req_cons;
234
rp = netdev->rx_ring.sring->req_prod;
237
if (rc == rp || RING_REQUEST_CONS_OVERFLOW(&netdev->rx_ring, rc)) {
238
xen_be_printf(&netdev->xendev, 2, "%s: no rx buffers (%d/%d)\n",
239
__FUNCTION__, rc, rp);
245
static ssize_t net_rx_packet(VLANClientState *vc, const uint8_t *buf, size_t size)
247
struct XenNetDev *netdev = vc->opaque;
248
netif_rx_request_t rxreq;
252
if (netdev->xendev.be_state != XenbusStateConnected)
255
rc = netdev->rx_ring.req_cons;
256
rp = netdev->rx_ring.sring->req_prod;
257
xen_rmb(); /* Ensure we see queued requests up to 'rp'. */
259
if (rc == rp || RING_REQUEST_CONS_OVERFLOW(&netdev->rx_ring, rc)) {
260
xen_be_printf(&netdev->xendev, 2, "no buffer, drop packet\n");
263
if (size > XC_PAGE_SIZE - NET_IP_ALIGN) {
264
xen_be_printf(&netdev->xendev, 0, "packet too big (%lu > %ld)",
265
(unsigned long)size, XC_PAGE_SIZE - NET_IP_ALIGN);
269
memcpy(&rxreq, RING_GET_REQUEST(&netdev->rx_ring, rc), sizeof(rxreq));
270
netdev->rx_ring.req_cons = ++rc;
272
page = xc_gnttab_map_grant_ref(netdev->xendev.gnttabdev,
274
rxreq.gref, PROT_WRITE);
276
xen_be_printf(&netdev->xendev, 0, "error: rx gref dereference failed (%d)\n",
278
net_rx_response(netdev, &rxreq, NETIF_RSP_ERROR, 0, 0, 0);
281
memcpy(page + NET_IP_ALIGN, buf, size);
282
xc_gnttab_munmap(netdev->xendev.gnttabdev, page, 1);
283
net_rx_response(netdev, &rxreq, NETIF_RSP_OKAY, NET_IP_ALIGN, size, 0);
288
/* ------------------------------------------------------------- */
290
static int net_init(struct XenDevice *xendev)
292
struct XenNetDev *netdev = container_of(xendev, struct XenNetDev, xendev);
295
/* read xenstore entries */
296
if (netdev->mac == NULL)
297
netdev->mac = xenstore_read_be_str(&netdev->xendev, "mac");
299
/* do we have all we need? */
300
if (netdev->mac == NULL)
303
vlan = qemu_find_vlan(netdev->xendev.dev, 1);
304
netdev->vs = qemu_new_vlan_client(vlan, "xen", NULL,
305
net_rx_ok, net_rx_packet, NULL,
307
snprintf(netdev->vs->info_str, sizeof(netdev->vs->info_str),
308
"nic: xenbus vif macaddr=%s", netdev->mac);
311
xenstore_write_be_int(&netdev->xendev, "feature-rx-copy", 1);
312
xenstore_write_be_int(&netdev->xendev, "feature-rx-flip", 0);
317
static int net_connect(struct XenDevice *xendev)
319
struct XenNetDev *netdev = container_of(xendev, struct XenNetDev, xendev);
322
if (xenstore_read_fe_int(&netdev->xendev, "tx-ring-ref",
323
&netdev->tx_ring_ref) == -1)
325
if (xenstore_read_fe_int(&netdev->xendev, "rx-ring-ref",
326
&netdev->rx_ring_ref) == -1)
328
if (xenstore_read_fe_int(&netdev->xendev, "event-channel",
329
&netdev->xendev.remote_port) == -1)
332
if (xenstore_read_fe_int(&netdev->xendev, "request-rx-copy", &rx_copy) == -1)
335
xen_be_printf(&netdev->xendev, 0, "frontend doesn't support rx-copy.\n");
339
netdev->txs = xc_gnttab_map_grant_ref(netdev->xendev.gnttabdev,
342
PROT_READ | PROT_WRITE);
343
netdev->rxs = xc_gnttab_map_grant_ref(netdev->xendev.gnttabdev,
346
PROT_READ | PROT_WRITE);
347
if (!netdev->txs || !netdev->rxs)
349
BACK_RING_INIT(&netdev->tx_ring, netdev->txs, XC_PAGE_SIZE);
350
BACK_RING_INIT(&netdev->rx_ring, netdev->rxs, XC_PAGE_SIZE);
352
xen_be_bind_evtchn(&netdev->xendev);
354
xen_be_printf(&netdev->xendev, 1, "ok: tx-ring-ref %d, rx-ring-ref %d, "
355
"remote port %d, local port %d\n",
356
netdev->tx_ring_ref, netdev->rx_ring_ref,
357
netdev->xendev.remote_port, netdev->xendev.local_port);
359
net_tx_packets(netdev);
363
static void net_disconnect(struct XenDevice *xendev)
365
struct XenNetDev *netdev = container_of(xendev, struct XenNetDev, xendev);
367
xen_be_unbind_evtchn(&netdev->xendev);
370
xc_gnttab_munmap(netdev->xendev.gnttabdev, netdev->txs, 1);
374
xc_gnttab_munmap(netdev->xendev.gnttabdev, netdev->rxs, 1);
378
qemu_del_vlan_client(netdev->vs);
383
static void net_event(struct XenDevice *xendev)
385
struct XenNetDev *netdev = container_of(xendev, struct XenNetDev, xendev);
386
net_tx_packets(netdev);
389
static int net_free(struct XenDevice *xendev)
391
struct XenNetDev *netdev = container_of(xendev, struct XenNetDev, xendev);
393
qemu_free(netdev->mac);
397
/* ------------------------------------------------------------- */
399
struct XenDevOps xen_netdev_ops = {
400
.size = sizeof(struct XenNetDev),
401
.flags = DEVOPS_FLAG_NEED_GNTDEV,
403
.connect = net_connect,
405
.disconnect = net_disconnect,