blob: 2d11a8f4befac2e81b8e35da3f28c56e7f148610 [file] [log] [blame]
Vincenzo Maffione58952132013-11-06 11:44:06 +01001/*
2 * netmap access for qemu
3 *
4 * Copyright (c) 2012-2013 Luigi Rizzo
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24
25
Peter Maydell2744d922016-01-29 17:50:00 +000026#include "qemu/osdep.h"
Vincenzo Maffione58952132013-11-06 11:44:06 +010027#include <sys/ioctl.h>
28#include <net/if.h>
Vincenzo Maffione0a985b32014-02-20 15:40:43 +010029#define NETMAP_WITH_LIBS
Vincenzo Maffione58952132013-11-06 11:44:06 +010030#include <net/netmap.h>
31#include <net/netmap_user.h>
32
33#include "net/net.h"
Vincenzo Maffionef6c65bf2014-02-06 17:02:20 +010034#include "net/tap.h"
Vincenzo Maffione58952132013-11-06 11:44:06 +010035#include "clients.h"
36#include "sysemu/sysemu.h"
37#include "qemu/error-report.h"
Daniel P. Berrangee31f0452016-03-31 14:08:10 +010038#include "qapi/error.h"
Vincenzo Maffione58952132013-11-06 11:44:06 +010039#include "qemu/iov.h"
Veronia Bahaaf348b6d2016-03-20 19:16:19 +020040#include "qemu/cutils.h"
Vincenzo Maffione58952132013-11-06 11:44:06 +010041
Vincenzo Maffione58952132013-11-06 11:44:06 +010042typedef struct NetmapState {
43 NetClientState nc;
Vincenzo Maffioneab685222016-01-25 19:24:35 +010044 struct nm_desc *nmd;
45 char ifname[IFNAMSIZ];
46 struct netmap_ring *tx;
47 struct netmap_ring *rx;
Vincenzo Maffione58952132013-11-06 11:44:06 +010048 bool read_poll;
49 bool write_poll;
50 struct iovec iov[IOV_MAX];
Vincenzo Maffionef6c65bf2014-02-06 17:02:20 +010051 int vnet_hdr_len; /* Current virtio-net header length. */
Vincenzo Maffione58952132013-11-06 11:44:06 +010052} NetmapState;
53
Vincenzo Maffione58952132013-11-06 11:44:06 +010054#ifndef __FreeBSD__
55#define pkt_copy bcopy
56#else
57/* A fast copy routine only for multiples of 64 bytes, non overlapped. */
58static inline void
59pkt_copy(const void *_src, void *_dst, int l)
60{
61 const uint64_t *src = _src;
62 uint64_t *dst = _dst;
63 if (unlikely(l >= 1024)) {
64 bcopy(src, dst, l);
65 return;
66 }
67 for (; l > 0; l -= 64) {
68 *dst++ = *src++;
69 *dst++ = *src++;
70 *dst++ = *src++;
71 *dst++ = *src++;
72 *dst++ = *src++;
73 *dst++ = *src++;
74 *dst++ = *src++;
75 *dst++ = *src++;
76 }
77}
78#endif /* __FreeBSD__ */
79
80/*
81 * Open a netmap device. We assume there is only one queue
82 * (which is the case for the VALE bridge).
83 */
Vincenzo Maffioneab685222016-01-25 19:24:35 +010084static struct nm_desc *netmap_open(const NetdevNetmapOptions *nm_opts,
85 Error **errp)
Vincenzo Maffione58952132013-11-06 11:44:06 +010086{
Vincenzo Maffioneab685222016-01-25 19:24:35 +010087 struct nm_desc *nmd;
Vincenzo Maffione58952132013-11-06 11:44:06 +010088 struct nmreq req;
89
Vincenzo Maffione58952132013-11-06 11:44:06 +010090 memset(&req, 0, sizeof(req));
Vincenzo Maffione58952132013-11-06 11:44:06 +010091
Vincenzo Maffioneab685222016-01-25 19:24:35 +010092 nmd = nm_open(nm_opts->ifname, &req, NETMAP_NO_TX_POLL,
93 NULL);
94 if (nmd == NULL) {
95 error_setg_errno(errp, errno, "Failed to nm_open() %s",
96 nm_opts->ifname);
97 return NULL;
Vincenzo Maffione58952132013-11-06 11:44:06 +010098 }
99
Vincenzo Maffioneab685222016-01-25 19:24:35 +0100100 return nmd;
Vincenzo Maffione58952132013-11-06 11:44:06 +0100101}
102
Vincenzo Maffione58952132013-11-06 11:44:06 +0100103static void netmap_send(void *opaque);
104static void netmap_writable(void *opaque);
105
106/* Set the event-loop handlers for the netmap backend. */
107static void netmap_update_fd_handler(NetmapState *s)
108{
Vincenzo Maffioneab685222016-01-25 19:24:35 +0100109 qemu_set_fd_handler(s->nmd->fd,
Fam Zheng82e1cc42015-06-04 14:45:18 +0800110 s->read_poll ? netmap_send : NULL,
111 s->write_poll ? netmap_writable : NULL,
112 s);
Vincenzo Maffione58952132013-11-06 11:44:06 +0100113}
114
115/* Update the read handler. */
116static void netmap_read_poll(NetmapState *s, bool enable)
117{
118 if (s->read_poll != enable) { /* Do nothing if not changed. */
119 s->read_poll = enable;
120 netmap_update_fd_handler(s);
121 }
122}
123
124/* Update the write handler. */
125static void netmap_write_poll(NetmapState *s, bool enable)
126{
127 if (s->write_poll != enable) {
128 s->write_poll = enable;
129 netmap_update_fd_handler(s);
130 }
131}
132
133static void netmap_poll(NetClientState *nc, bool enable)
134{
135 NetmapState *s = DO_UPCAST(NetmapState, nc, nc);
136
137 if (s->read_poll != enable || s->write_poll != enable) {
Prasad Joshi131e7442014-03-23 14:58:43 +0530138 s->write_poll = enable;
139 s->read_poll = enable;
Vincenzo Maffione58952132013-11-06 11:44:06 +0100140 netmap_update_fd_handler(s);
141 }
142}
143
144/*
145 * The fd_write() callback, invoked if the fd is marked as
146 * writable after a poll. Unregister the handler and flush any
147 * buffered packets.
148 */
149static void netmap_writable(void *opaque)
150{
151 NetmapState *s = opaque;
152
153 netmap_write_poll(s, false);
154 qemu_flush_queued_packets(&s->nc);
155}
156
157static ssize_t netmap_receive(NetClientState *nc,
158 const uint8_t *buf, size_t size)
159{
160 NetmapState *s = DO_UPCAST(NetmapState, nc, nc);
Vincenzo Maffioneab685222016-01-25 19:24:35 +0100161 struct netmap_ring *ring = s->tx;
Vincenzo Maffione58952132013-11-06 11:44:06 +0100162 uint32_t i;
163 uint32_t idx;
164 uint8_t *dst;
165
166 if (unlikely(!ring)) {
167 /* Drop. */
168 return size;
169 }
170
171 if (unlikely(size > ring->nr_buf_size)) {
172 RD(5, "[netmap_receive] drop packet of size %d > %d\n",
173 (int)size, ring->nr_buf_size);
174 return size;
175 }
176
Vincenzo Maffione0a985b32014-02-20 15:40:43 +0100177 if (nm_ring_empty(ring)) {
Vincenzo Maffione58952132013-11-06 11:44:06 +0100178 /* No available slots in the netmap TX ring. */
179 netmap_write_poll(s, true);
180 return 0;
181 }
182
183 i = ring->cur;
184 idx = ring->slot[i].buf_idx;
185 dst = (uint8_t *)NETMAP_BUF(ring, idx);
186
187 ring->slot[i].len = size;
188 ring->slot[i].flags = 0;
189 pkt_copy(buf, dst, size);
Vincenzo Maffione0a985b32014-02-20 15:40:43 +0100190 ring->cur = ring->head = nm_ring_next(ring, i);
Vincenzo Maffioneab685222016-01-25 19:24:35 +0100191 ioctl(s->nmd->fd, NIOCTXSYNC, NULL);
Vincenzo Maffione58952132013-11-06 11:44:06 +0100192
193 return size;
194}
195
196static ssize_t netmap_receive_iov(NetClientState *nc,
197 const struct iovec *iov, int iovcnt)
198{
199 NetmapState *s = DO_UPCAST(NetmapState, nc, nc);
Vincenzo Maffioneab685222016-01-25 19:24:35 +0100200 struct netmap_ring *ring = s->tx;
Vincenzo Maffione58952132013-11-06 11:44:06 +0100201 uint32_t last;
202 uint32_t idx;
203 uint8_t *dst;
204 int j;
205 uint32_t i;
Vincenzo Maffione58952132013-11-06 11:44:06 +0100206
207 if (unlikely(!ring)) {
208 /* Drop the packet. */
209 return iov_size(iov, iovcnt);
210 }
211
Vincenzo Maffionef6c65bf2014-02-06 17:02:20 +0100212 last = i = ring->cur;
Vincenzo Maffione58952132013-11-06 11:44:06 +0100213
Vincenzo Maffione0a985b32014-02-20 15:40:43 +0100214 if (nm_ring_space(ring) < iovcnt) {
Vincenzo Maffione58952132013-11-06 11:44:06 +0100215 /* Not enough netmap slots. */
216 netmap_write_poll(s, true);
217 return 0;
218 }
219
220 for (j = 0; j < iovcnt; j++) {
221 int iov_frag_size = iov[j].iov_len;
222 int offset = 0;
223 int nm_frag_size;
224
225 /* Split each iovec fragment over more netmap slots, if
226 necessary. */
227 while (iov_frag_size) {
228 nm_frag_size = MIN(iov_frag_size, ring->nr_buf_size);
229
Vincenzo Maffione0a985b32014-02-20 15:40:43 +0100230 if (unlikely(nm_ring_empty(ring))) {
Vincenzo Maffione58952132013-11-06 11:44:06 +0100231 /* We run out of netmap slots while splitting the
232 iovec fragments. */
233 netmap_write_poll(s, true);
234 return 0;
235 }
236
237 idx = ring->slot[i].buf_idx;
238 dst = (uint8_t *)NETMAP_BUF(ring, idx);
239
240 ring->slot[i].len = nm_frag_size;
241 ring->slot[i].flags = NS_MOREFRAG;
242 pkt_copy(iov[j].iov_base + offset, dst, nm_frag_size);
243
244 last = i;
Vincenzo Maffione0a985b32014-02-20 15:40:43 +0100245 i = nm_ring_next(ring, i);
Vincenzo Maffione58952132013-11-06 11:44:06 +0100246
247 offset += nm_frag_size;
248 iov_frag_size -= nm_frag_size;
249 }
250 }
251 /* The last slot must not have NS_MOREFRAG set. */
252 ring->slot[last].flags &= ~NS_MOREFRAG;
253
Vincenzo Maffione0a985b32014-02-20 15:40:43 +0100254 /* Now update ring->cur and ring->head. */
255 ring->cur = ring->head = i;
Vincenzo Maffione58952132013-11-06 11:44:06 +0100256
Vincenzo Maffioneab685222016-01-25 19:24:35 +0100257 ioctl(s->nmd->fd, NIOCTXSYNC, NULL);
Vincenzo Maffione58952132013-11-06 11:44:06 +0100258
259 return iov_size(iov, iovcnt);
260}
261
262/* Complete a previous send (backend --> guest) and enable the
263 fd_read callback. */
264static void netmap_send_completed(NetClientState *nc, ssize_t len)
265{
266 NetmapState *s = DO_UPCAST(NetmapState, nc, nc);
267
268 netmap_read_poll(s, true);
269}
270
271static void netmap_send(void *opaque)
272{
273 NetmapState *s = opaque;
Vincenzo Maffioneab685222016-01-25 19:24:35 +0100274 struct netmap_ring *ring = s->rx;
Vincenzo Maffione58952132013-11-06 11:44:06 +0100275
276 /* Keep sending while there are available packets into the netmap
277 RX ring and the forwarding path towards the peer is open. */
Fam Zhenge8dd1d92015-06-04 14:45:15 +0800278 while (!nm_ring_empty(ring)) {
Vincenzo Maffione58952132013-11-06 11:44:06 +0100279 uint32_t i;
280 uint32_t idx;
281 bool morefrag;
282 int iovcnt = 0;
283 int iovsize;
284
285 do {
286 i = ring->cur;
287 idx = ring->slot[i].buf_idx;
288 morefrag = (ring->slot[i].flags & NS_MOREFRAG);
289 s->iov[iovcnt].iov_base = (u_char *)NETMAP_BUF(ring, idx);
290 s->iov[iovcnt].iov_len = ring->slot[i].len;
291 iovcnt++;
292
Vincenzo Maffione0a985b32014-02-20 15:40:43 +0100293 ring->cur = ring->head = nm_ring_next(ring, i);
294 } while (!nm_ring_empty(ring) && morefrag);
Vincenzo Maffione58952132013-11-06 11:44:06 +0100295
Vincenzo Maffione0a985b32014-02-20 15:40:43 +0100296 if (unlikely(nm_ring_empty(ring) && morefrag)) {
Vincenzo Maffione58952132013-11-06 11:44:06 +0100297 RD(5, "[netmap_send] ran out of slots, with a pending"
298 "incomplete packet\n");
299 }
300
301 iovsize = qemu_sendv_packet_async(&s->nc, s->iov, iovcnt,
302 netmap_send_completed);
303
304 if (iovsize == 0) {
305 /* The peer does not receive anymore. Packet is queued, stop
306 * reading from the backend until netmap_send_completed()
307 */
308 netmap_read_poll(s, false);
309 break;
310 }
311 }
312}
313
314/* Flush and close. */
315static void netmap_cleanup(NetClientState *nc)
316{
317 NetmapState *s = DO_UPCAST(NetmapState, nc, nc);
318
319 qemu_purge_queued_packets(nc);
320
321 netmap_poll(nc, false);
Vincenzo Maffioneab685222016-01-25 19:24:35 +0100322 nm_close(s->nmd);
323 s->nmd = NULL;
Vincenzo Maffione58952132013-11-06 11:44:06 +0100324}
325
Vincenzo Maffionef6c65bf2014-02-06 17:02:20 +0100326/* Offloading manipulation support callbacks. */
Vincenzo Maffione9fbad2c2016-02-24 11:30:41 +0100327static int netmap_fd_set_vnet_hdr_len(NetmapState *s, int len)
Vincenzo Maffionef6c65bf2014-02-06 17:02:20 +0100328{
Vincenzo Maffionef6c65bf2014-02-06 17:02:20 +0100329 struct nmreq req;
330
331 /* Issue a NETMAP_BDG_VNET_HDR command to change the virtio-net header
Vincenzo Maffioneab685222016-01-25 19:24:35 +0100332 * length for the netmap adapter associated to 's->ifname'.
Vincenzo Maffionef6c65bf2014-02-06 17:02:20 +0100333 */
334 memset(&req, 0, sizeof(req));
Vincenzo Maffioneab685222016-01-25 19:24:35 +0100335 pstrcpy(req.nr_name, sizeof(req.nr_name), s->ifname);
Vincenzo Maffionef6c65bf2014-02-06 17:02:20 +0100336 req.nr_version = NETMAP_API;
337 req.nr_cmd = NETMAP_BDG_VNET_HDR;
338 req.nr_arg1 = len;
Vincenzo Maffione9fbad2c2016-02-24 11:30:41 +0100339
340 return ioctl(s->nmd->fd, NIOCREGIF, &req);
341}
342
343static bool netmap_has_vnet_hdr_len(NetClientState *nc, int len)
344{
345 NetmapState *s = DO_UPCAST(NetmapState, nc, nc);
346 int prev_len = s->vnet_hdr_len;
347
348 /* Check that we can set the new length. */
349 if (netmap_fd_set_vnet_hdr_len(s, len)) {
350 return false;
351 }
352
353 /* Restore the previous length. */
354 if (netmap_fd_set_vnet_hdr_len(s, prev_len)) {
355 error_report("Failed to restore vnet-hdr length %d on %s: %s",
356 prev_len, s->ifname, strerror(errno));
357 abort();
358 }
359
360 return true;
361}
362
363/* A netmap interface that supports virtio-net headers always
364 * supports UFO, so we use this callback also for the has_ufo hook. */
365static bool netmap_has_vnet_hdr(NetClientState *nc)
366{
367 return netmap_has_vnet_hdr_len(nc, sizeof(struct virtio_net_hdr));
368}
369
370static void netmap_using_vnet_hdr(NetClientState *nc, bool enable)
371{
372}
373
374static void netmap_set_vnet_hdr_len(NetClientState *nc, int len)
375{
376 NetmapState *s = DO_UPCAST(NetmapState, nc, nc);
377 int err;
378
379 err = netmap_fd_set_vnet_hdr_len(s, len);
Vincenzo Maffionef6c65bf2014-02-06 17:02:20 +0100380 if (err) {
Vincenzo Maffione9fbad2c2016-02-24 11:30:41 +0100381 error_report("Unable to set vnet-hdr length %d on %s: %s",
382 len, s->ifname, strerror(errno));
Vincenzo Maffionef6c65bf2014-02-06 17:02:20 +0100383 } else {
384 /* Keep track of the current length. */
385 s->vnet_hdr_len = len;
386 }
387}
388
389static void netmap_set_offload(NetClientState *nc, int csum, int tso4, int tso6,
390 int ecn, int ufo)
391{
392 NetmapState *s = DO_UPCAST(NetmapState, nc, nc);
393
394 /* Setting a virtio-net header length greater than zero automatically
Vincenzo Maffione9fbad2c2016-02-24 11:30:41 +0100395 * enables the offloadings. */
Vincenzo Maffionef6c65bf2014-02-06 17:02:20 +0100396 if (!s->vnet_hdr_len) {
397 netmap_set_vnet_hdr_len(nc, sizeof(struct virtio_net_hdr));
398 }
399}
Vincenzo Maffione58952132013-11-06 11:44:06 +0100400
401/* NetClientInfo methods */
402static NetClientInfo net_netmap_info = {
Eric Blakef394b2e2016-07-13 21:50:23 -0600403 .type = NET_CLIENT_DRIVER_NETMAP,
Vincenzo Maffione58952132013-11-06 11:44:06 +0100404 .size = sizeof(NetmapState),
405 .receive = netmap_receive,
406 .receive_iov = netmap_receive_iov,
407 .poll = netmap_poll,
408 .cleanup = netmap_cleanup,
Vincenzo Maffione9fbad2c2016-02-24 11:30:41 +0100409 .has_ufo = netmap_has_vnet_hdr,
Vincenzo Maffionef6c65bf2014-02-06 17:02:20 +0100410 .has_vnet_hdr = netmap_has_vnet_hdr,
411 .has_vnet_hdr_len = netmap_has_vnet_hdr_len,
412 .using_vnet_hdr = netmap_using_vnet_hdr,
413 .set_offload = netmap_set_offload,
414 .set_vnet_hdr_len = netmap_set_vnet_hdr_len,
Vincenzo Maffione58952132013-11-06 11:44:06 +0100415};
416
417/* The exported init function
418 *
419 * ... -net netmap,ifname="..."
420 */
Kővágó, Zoltáncebea512016-07-13 21:50:12 -0600421int net_init_netmap(const Netdev *netdev,
Markus Armbrustera30ecde2015-05-15 13:58:50 +0200422 const char *name, NetClientState *peer, Error **errp)
Vincenzo Maffione58952132013-11-06 11:44:06 +0100423{
Eric Blakef394b2e2016-07-13 21:50:23 -0600424 const NetdevNetmapOptions *netmap_opts = &netdev->u.netmap;
Vincenzo Maffioneab685222016-01-25 19:24:35 +0100425 struct nm_desc *nmd;
Vincenzo Maffione58952132013-11-06 11:44:06 +0100426 NetClientState *nc;
Vincenzo Maffione39bec4f2015-11-10 10:47:22 +0100427 Error *err = NULL;
Vincenzo Maffione58952132013-11-06 11:44:06 +0100428 NetmapState *s;
429
Vincenzo Maffioneab685222016-01-25 19:24:35 +0100430 nmd = netmap_open(netmap_opts, &err);
Vincenzo Maffione39bec4f2015-11-10 10:47:22 +0100431 if (err) {
432 error_propagate(errp, err);
Vincenzo Maffione58952132013-11-06 11:44:06 +0100433 return -1;
434 }
435 /* Create the object. */
436 nc = qemu_new_net_client(&net_netmap_info, peer, "netmap", name);
437 s = DO_UPCAST(NetmapState, nc, nc);
Vincenzo Maffioneab685222016-01-25 19:24:35 +0100438 s->nmd = nmd;
439 s->tx = NETMAP_TXRING(nmd->nifp, 0);
440 s->rx = NETMAP_RXRING(nmd->nifp, 0);
Vincenzo Maffionef6c65bf2014-02-06 17:02:20 +0100441 s->vnet_hdr_len = 0;
Vincenzo Maffioneab685222016-01-25 19:24:35 +0100442 pstrcpy(s->ifname, sizeof(s->ifname), netmap_opts->ifname);
Vincenzo Maffione58952132013-11-06 11:44:06 +0100443 netmap_read_poll(s, true); /* Initially only poll for reads. */
444
445 return 0;
446}
447