]> git.proxmox.com Git - ceph.git/blob - ceph/src/seastar/dpdk/examples/netmap_compat/lib/compat_netmap.c
update sources to ceph Nautilus 14.2.1
[ceph.git] / ceph / src / seastar / dpdk / examples / netmap_compat / lib / compat_netmap.c
1 /*-
2 * BSD LICENSE
3 *
4 * Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 *
11 * * Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 * * Neither the name of Intel Corporation nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 */
33
34 #include <errno.h>
35 #include <inttypes.h>
36 #include <poll.h>
37 #include <stdio.h>
38 #include <stdlib.h>
39 #include <net/if.h>
40 #include <sys/types.h>
41 #include <sys/resource.h>
42 #include <sys/mman.h>
43
44 #include <rte_common.h>
45 #include <rte_errno.h>
46 #include <rte_ethdev.h>
47 #include <rte_log.h>
48 #include <rte_malloc.h>
49 #include <rte_mbuf.h>
50 #include <rte_memzone.h>
51 #include <rte_spinlock.h>
52 #include <rte_string_fns.h>
53
54 #include "compat_netmap.h"
55
56 struct netmap_port {
57 struct rte_mempool *pool;
58 struct netmap_if *nmif;
59 struct rte_eth_conf eth_conf;
60 struct rte_eth_txconf tx_conf;
61 struct rte_eth_rxconf rx_conf;
62 int32_t socket_id;
63 uint16_t nr_tx_rings;
64 uint16_t nr_rx_rings;
65 uint32_t nr_tx_slots;
66 uint32_t nr_rx_slots;
67 uint16_t tx_burst;
68 uint16_t rx_burst;
69 uint32_t fd;
70 };
71
72 struct fd_port {
73 uint32_t port;
74 };
75
76 #ifndef POLLRDNORM
77 #define POLLRDNORM 0x0040
78 #endif
79
80 #ifndef POLLWRNORM
81 #define POLLWRNORM 0x0100
82 #endif
83
84 #define FD_PORT_FREE UINT32_MAX
85 #define FD_PORT_RSRV (FD_PORT_FREE - 1)
86
87 struct netmap_state {
88 struct rte_netmap_conf conf;
89 uintptr_t buf_start;
90 void *mem;
91 uint32_t mem_sz;
92 uint32_t netif_memsz;
93 };
94
95
96 #define COMPAT_NETMAP_MAX_NOFILE (2 * RTE_MAX_ETHPORTS)
97 #define COMPAT_NETMAP_MAX_BURST 64
98 #define COMPAT_NETMAP_MAX_PKT_PER_SYNC (2 * COMPAT_NETMAP_MAX_BURST)
99
100 static struct netmap_port ports[RTE_MAX_ETHPORTS];
101 static struct netmap_state netmap;
102
103 static struct fd_port fd_port[COMPAT_NETMAP_MAX_NOFILE];
104 static const int next_fd_start = RLIMIT_NOFILE + 1;
105 static rte_spinlock_t netmap_lock;
106
107 #define IDX_TO_FD(x) ((x) + next_fd_start)
108 #define FD_TO_IDX(x) ((x) - next_fd_start)
109 #define FD_VALID(x) ((x) >= next_fd_start && \
110 (x) < (typeof (x))(RTE_DIM(fd_port) + next_fd_start))
111
112 #define PORT_NUM_RINGS (2 * netmap.conf.max_rings)
113 #define PORT_NUM_SLOTS (PORT_NUM_RINGS * netmap.conf.max_slots)
114
115 #define BUF_IDX(port, ring, slot) \
116 (((port) * PORT_NUM_RINGS + (ring)) * netmap.conf.max_slots + \
117 (slot))
118
119 #define NETMAP_IF_RING_OFS(rid, rings, slots) ({\
120 struct netmap_if *_if; \
121 struct netmap_ring *_rg; \
122 sizeof(*_if) + \
123 (rings) * sizeof(_if->ring_ofs[0]) + \
124 (rid) * sizeof(*_rg) + \
125 (slots) * sizeof(_rg->slot[0]); \
126 })
127
128 static void netmap_unregif(uint32_t idx, uint32_t port);
129
130
131 static int32_t
132 ifname_to_portid(const char *ifname, uint8_t *port)
133 {
134 char *endptr;
135 uint64_t portid;
136
137 errno = 0;
138 portid = strtoul(ifname, &endptr, 10);
139 if (endptr == ifname || *endptr != '\0' ||
140 portid >= RTE_DIM(ports) || errno != 0)
141 return -EINVAL;
142
143 *port = (uint8_t)portid;
144 return 0;
145 }
146
147 /**
148 * Given a dpdk mbuf, fill in the Netmap slot in ring r and its associated
149 * buffer with the data held by the mbuf.
150 * Note that mbuf chains are not supported.
151 */
152 static void
153 mbuf_to_slot(struct rte_mbuf *mbuf, struct netmap_ring *r, uint32_t index)
154 {
155 char *data;
156 uint16_t length;
157
158 data = rte_pktmbuf_mtod(mbuf, char *);
159 length = rte_pktmbuf_data_len(mbuf);
160
161 if (length > r->nr_buf_size)
162 length = 0;
163
164 r->slot[index].len = length;
165 rte_memcpy(NETMAP_BUF(r, r->slot[index].buf_idx), data, length);
166 }
167
168 /**
169 * Given a Netmap ring and a slot index for that ring, construct a dpdk mbuf
170 * from the data held in the buffer associated with the slot.
171 * Allocation/deallocation of the dpdk mbuf are the responsability of the
172 * caller.
173 * Note that mbuf chains are not supported.
174 */
175 static void
176 slot_to_mbuf(struct netmap_ring *r, uint32_t index, struct rte_mbuf *mbuf)
177 {
178 char *data;
179 uint16_t length;
180
181 rte_pktmbuf_reset(mbuf);
182 length = r->slot[index].len;
183 data = rte_pktmbuf_append(mbuf, length);
184
185 if (data != NULL)
186 rte_memcpy(data, NETMAP_BUF(r, r->slot[index].buf_idx), length);
187 }
188
189 static int32_t
190 fd_reserve(void)
191 {
192 uint32_t i;
193
194 for (i = 0; i != RTE_DIM(fd_port) && fd_port[i].port != FD_PORT_FREE;
195 i++)
196 ;
197
198 if (i == RTE_DIM(fd_port))
199 return -ENOMEM;
200
201 fd_port[i].port = FD_PORT_RSRV;
202 return IDX_TO_FD(i);
203 }
204
205 static int32_t
206 fd_release(int32_t fd)
207 {
208 uint32_t idx, port;
209
210 idx = FD_TO_IDX(fd);
211
212 if (!FD_VALID(fd) || (port = fd_port[idx].port) == FD_PORT_FREE)
213 return -EINVAL;
214
215 /* if we still have a valid port attached, release the port */
216 if (port < RTE_DIM(ports) && ports[port].fd == idx) {
217 netmap_unregif(idx, port);
218 }
219
220 fd_port[idx].port = FD_PORT_FREE;
221 return 0;
222 }
223
224 static int
225 check_nmreq(struct nmreq *req, uint8_t *port)
226 {
227 int32_t rc;
228 uint8_t portid;
229
230 if (req == NULL)
231 return -EINVAL;
232
233 if (req->nr_version != NETMAP_API) {
234 req->nr_version = NETMAP_API;
235 return -EINVAL;
236 }
237
238 if ((rc = ifname_to_portid(req->nr_name, &portid)) != 0) {
239 RTE_LOG(ERR, USER1, "Invalid interface name:\"%s\" "
240 "in NIOCGINFO call\n", req->nr_name);
241 return rc;
242 }
243
244 if (ports[portid].pool == NULL) {
245 RTE_LOG(ERR, USER1, "Misconfigured portid %hhu\n", portid);
246 return -EINVAL;
247 }
248
249 *port = portid;
250 return 0;
251 }
252
253 /**
254 * Simulate a Netmap NIOCGINFO ioctl: given a struct nmreq holding an interface
255 * name (a port number in our case), fill the struct nmreq in with advisory
256 * information about the interface: number of rings and their size, total memory
257 * required in the map, ...
258 * Those are preconfigured using rte_eth_{,tx,rx}conf and
259 * rte_netmap_port_conf structures
260 * and calls to rte_netmap_init_port() in the Netmap application.
261 */
262 static int
263 ioctl_niocginfo(__rte_unused int fd, void * param)
264 {
265 uint8_t portid;
266 struct nmreq *req;
267 int32_t rc;
268
269 req = (struct nmreq *)param;
270 if ((rc = check_nmreq(req, &portid)) != 0)
271 return rc;
272
273 req->nr_tx_rings = (uint16_t)(ports[portid].nr_tx_rings - 1);
274 req->nr_rx_rings = (uint16_t)(ports[portid].nr_rx_rings - 1);
275 req->nr_tx_slots = ports[portid].nr_tx_slots;
276 req->nr_rx_slots = ports[portid].nr_rx_slots;
277
278 /* in current implementation we have all NETIFs shared aone region. */
279 req->nr_memsize = netmap.mem_sz;
280 req->nr_offset = 0;
281
282 return 0;
283 }
284
285 static void
286 netmap_ring_setup(struct netmap_ring *ring, uint8_t port, uint32_t ringid,
287 uint32_t num_slots)
288 {
289 uint32_t j;
290
291 ring->buf_ofs = netmap.buf_start - (uintptr_t)ring;
292 ring->num_slots = num_slots;
293 ring->cur = 0;
294 ring->reserved = 0;
295 ring->nr_buf_size = netmap.conf.max_bufsz;
296 ring->flags = 0;
297 ring->ts.tv_sec = 0;
298 ring->ts.tv_usec = 0;
299
300 for (j = 0; j < ring->num_slots; j++) {
301 ring->slot[j].buf_idx = BUF_IDX(port, ringid, j);
302 ring->slot[j].len = 0;
303 ring->flags = 0;
304 }
305 }
306
307 static int
308 netmap_regif(struct nmreq *req, uint32_t idx, uint8_t port)
309 {
310 struct netmap_if *nmif;
311 struct netmap_ring *ring;
312 uint32_t i, slots, start_ring;
313 int32_t rc;
314
315 if (ports[port].fd < RTE_DIM(fd_port)) {
316 RTE_LOG(ERR, USER1, "port %hhu already in use by fd: %u\n",
317 port, IDX_TO_FD(ports[port].fd));
318 return -EBUSY;
319 }
320 if (fd_port[idx].port != FD_PORT_RSRV) {
321 RTE_LOG(ERR, USER1, "fd: %u is misconfigured\n",
322 IDX_TO_FD(idx));
323 return -EBUSY;
324 }
325
326 nmif = ports[port].nmif;
327
328 /* setup netmap_if fields. */
329 memset(nmif, 0, netmap.netif_memsz);
330
331 /* only ALL rings supported right now. */
332 if (req->nr_ringid != 0)
333 return -EINVAL;
334
335 snprintf(nmif->ni_name, sizeof(nmif->ni_name), "%s", req->nr_name);
336 nmif->ni_version = req->nr_version;
337
338 /* Netmap uses ni_(r|t)x_rings + 1 */
339 nmif->ni_rx_rings = ports[port].nr_rx_rings - 1;
340 nmif->ni_tx_rings = ports[port].nr_tx_rings - 1;
341
342 /*
343 * Setup TX rings and slots.
344 * Refer to the comments in netmap.h for details
345 */
346
347 slots = 0;
348 for (i = 0; i < nmif->ni_tx_rings + 1; i++) {
349
350 nmif->ring_ofs[i] = NETMAP_IF_RING_OFS(i,
351 PORT_NUM_RINGS, slots);
352
353 ring = NETMAP_TXRING(nmif, i);
354 netmap_ring_setup(ring, port, i, ports[port].nr_tx_slots);
355 ring->avail = ring->num_slots;
356
357 slots += ports[port].nr_tx_slots;
358 }
359
360 /*
361 * Setup RX rings and slots.
362 * Refer to the comments in netmap.h for details
363 */
364
365 start_ring = i;
366
367 for (; i < nmif->ni_rx_rings + 1 + start_ring; i++) {
368
369 nmif->ring_ofs[i] = NETMAP_IF_RING_OFS(i,
370 PORT_NUM_RINGS, slots);
371
372 ring = NETMAP_RXRING(nmif, (i - start_ring));
373 netmap_ring_setup(ring, port, i, ports[port].nr_rx_slots);
374 ring->avail = 0;
375
376 slots += ports[port].nr_rx_slots;
377 }
378
379 if ((rc = rte_eth_dev_start(port)) < 0) {
380 RTE_LOG(ERR, USER1,
381 "Couldn't start ethernet device %s (error %d)\n",
382 req->nr_name, rc);
383 return rc;
384 }
385
386 /* setup fdi <--> port relationtip. */
387 ports[port].fd = idx;
388 fd_port[idx].port = port;
389
390 req->nr_memsize = netmap.mem_sz;
391 req->nr_offset = (uintptr_t)nmif - (uintptr_t)netmap.mem;
392
393 return 0;
394 }
395
396 /**
397 * Simulate a Netmap NIOCREGIF ioctl:
398 */
399 static int
400 ioctl_niocregif(int32_t fd, void * param)
401 {
402 uint8_t portid;
403 int32_t rc;
404 uint32_t idx;
405 struct nmreq *req;
406
407 req = (struct nmreq *)param;
408 if ((rc = check_nmreq(req, &portid)) != 0)
409 return rc;
410
411 idx = FD_TO_IDX(fd);
412
413 rte_spinlock_lock(&netmap_lock);
414 rc = netmap_regif(req, idx, portid);
415 rte_spinlock_unlock(&netmap_lock);
416
417 return rc;
418 }
419
420 static void
421 netmap_unregif(uint32_t idx, uint32_t port)
422 {
423 fd_port[idx].port = FD_PORT_RSRV;
424 ports[port].fd = UINT32_MAX;
425 rte_eth_dev_stop((uint8_t)port);
426 }
427
428 /**
429 * Simulate a Netmap NIOCUNREGIF ioctl: put an interface running in Netmap
430 * mode back in "normal" mode. In our case, we just stop the port associated
431 * with this file descriptor.
432 */
433 static int
434 ioctl_niocunregif(int fd)
435 {
436 uint32_t idx, port;
437 int32_t rc;
438
439 idx = FD_TO_IDX(fd);
440
441 rte_spinlock_lock(&netmap_lock);
442
443 port = fd_port[idx].port;
444 if (port < RTE_DIM(ports) && ports[port].fd == idx) {
445 netmap_unregif(idx, port);
446 rc = 0;
447 } else {
448 RTE_LOG(ERR, USER1,
449 "%s: %d is not associated with valid port\n",
450 __func__, fd);
451 rc = -EINVAL;
452 }
453
454 rte_spinlock_unlock(&netmap_lock);
455 return rc;
456 }
457
458 /**
459 * A call to rx_sync_ring will try to fill a Netmap RX ring with as many
460 * packets as it can hold coming from its dpdk port.
461 */
462 static inline int
463 rx_sync_ring(struct netmap_ring *ring, uint8_t port, uint16_t ring_number,
464 uint16_t max_burst)
465 {
466 int32_t i, n_rx;
467 uint16_t burst_size;
468 uint32_t cur_slot, n_free_slots;
469 struct rte_mbuf *rx_mbufs[COMPAT_NETMAP_MAX_BURST];
470
471 n_free_slots = ring->num_slots - (ring->avail + ring->reserved);
472 n_free_slots = RTE_MIN(n_free_slots, max_burst);
473 cur_slot = (ring->cur + ring->avail) & (ring->num_slots - 1);
474
475 while (n_free_slots) {
476 burst_size = (uint16_t)RTE_MIN(n_free_slots, RTE_DIM(rx_mbufs));
477
478 /* receive up to burst_size packets from the NIC's queue */
479 n_rx = rte_eth_rx_burst(port, ring_number, rx_mbufs,
480 burst_size);
481
482 if (n_rx == 0)
483 return 0;
484 if (unlikely(n_rx < 0))
485 return -1;
486
487 /* Put those n_rx packets in the Netmap structures */
488 for (i = 0; i < n_rx ; i++) {
489 mbuf_to_slot(rx_mbufs[i], ring, cur_slot);
490 rte_pktmbuf_free(rx_mbufs[i]);
491 cur_slot = NETMAP_RING_NEXT(ring, cur_slot);
492 }
493
494 /* Update the Netmap ring structure to reflect the change */
495 ring->avail += n_rx;
496 n_free_slots -= n_rx;
497 }
498
499 return 0;
500 }
501
502 static inline int
503 rx_sync_if(uint32_t port)
504 {
505 uint16_t burst;
506 uint32_t i, rc;
507 struct netmap_if *nifp;
508 struct netmap_ring *r;
509
510 nifp = ports[port].nmif;
511 burst = ports[port].rx_burst;
512 rc = 0;
513
514 for (i = 0; i < nifp->ni_rx_rings + 1; i++) {
515 r = NETMAP_RXRING(nifp, i);
516 rx_sync_ring(r, (uint8_t)port, (uint16_t)i, burst);
517 rc += r->avail;
518 }
519
520 return rc;
521 }
522
523 /**
524 * Simulate a Netmap NIOCRXSYNC ioctl:
525 */
526 static int
527 ioctl_niocrxsync(int fd)
528 {
529 uint32_t idx, port;
530
531 idx = FD_TO_IDX(fd);
532 if ((port = fd_port[idx].port) < RTE_DIM(ports) &&
533 ports[port].fd == idx) {
534 return rx_sync_if(fd_port[idx].port);
535 } else {
536 return -EINVAL;
537 }
538 }
539
540 /**
541 * A call to tx_sync_ring will try to empty a Netmap TX ring by converting its
542 * buffers into rte_mbufs and sending them out on the rings's dpdk port.
543 */
544 static int
545 tx_sync_ring(struct netmap_ring *ring, uint8_t port, uint16_t ring_number,
546 struct rte_mempool *pool, uint16_t max_burst)
547 {
548 uint32_t i, n_tx;
549 uint16_t burst_size;
550 uint32_t cur_slot, n_used_slots;
551 struct rte_mbuf *tx_mbufs[COMPAT_NETMAP_MAX_BURST];
552
553 n_used_slots = ring->num_slots - ring->avail;
554 n_used_slots = RTE_MIN(n_used_slots, max_burst);
555 cur_slot = (ring->cur + ring->avail) & (ring->num_slots - 1);
556
557 while (n_used_slots) {
558 burst_size = (uint16_t)RTE_MIN(n_used_slots, RTE_DIM(tx_mbufs));
559
560 for (i = 0; i < burst_size; i++) {
561 tx_mbufs[i] = rte_pktmbuf_alloc(pool);
562 if (tx_mbufs[i] == NULL)
563 goto err;
564
565 slot_to_mbuf(ring, cur_slot, tx_mbufs[i]);
566 cur_slot = NETMAP_RING_NEXT(ring, cur_slot);
567 }
568
569 n_tx = rte_eth_tx_burst(port, ring_number, tx_mbufs,
570 burst_size);
571
572 /* Update the Netmap ring structure to reflect the change */
573 ring->avail += n_tx;
574 n_used_slots -= n_tx;
575
576 /* Return the mbufs that failed to transmit to their pool */
577 if (unlikely(n_tx != burst_size)) {
578 for (i = n_tx; i < burst_size; i++)
579 rte_pktmbuf_free(tx_mbufs[i]);
580 break;
581 }
582 }
583
584 return 0;
585
586 err:
587 for (; i == 0; --i)
588 rte_pktmbuf_free(tx_mbufs[i]);
589
590 RTE_LOG(ERR, USER1,
591 "Couldn't get mbuf from mempool is the mempool too small?\n");
592 return -1;
593 }
594
595 static int
596 tx_sync_if(uint32_t port)
597 {
598 uint16_t burst;
599 uint32_t i, rc;
600 struct netmap_if *nifp;
601 struct netmap_ring *r;
602 struct rte_mempool *mp;
603
604 nifp = ports[port].nmif;
605 mp = ports[port].pool;
606 burst = ports[port].tx_burst;
607 rc = 0;
608
609 for (i = 0; i < nifp->ni_tx_rings + 1; i++) {
610 r = NETMAP_TXRING(nifp, i);
611 tx_sync_ring(r, (uint8_t)port, (uint16_t)i, mp, burst);
612 rc += r->avail;
613 }
614
615 return rc;
616 }
617
618 /**
619 * Simulate a Netmap NIOCTXSYNC ioctl:
620 */
621 static inline int
622 ioctl_nioctxsync(int fd)
623 {
624 uint32_t idx, port;
625
626 idx = FD_TO_IDX(fd);
627 if ((port = fd_port[idx].port) < RTE_DIM(ports) &&
628 ports[port].fd == idx) {
629 return tx_sync_if(fd_port[idx].port);
630 } else {
631 return -EINVAL;
632 }
633 }
634
635 /**
636 * Give the library a mempool of rte_mbufs with which it can do the
637 * rte_mbuf <--> netmap slot conversions.
638 */
639 int
640 rte_netmap_init(const struct rte_netmap_conf *conf)
641 {
642 size_t buf_ofs, nmif_sz, sz;
643 size_t port_rings, port_slots, port_bufs;
644 uint32_t i, port_num;
645
646 port_num = RTE_MAX_ETHPORTS;
647 port_rings = 2 * conf->max_rings;
648 port_slots = port_rings * conf->max_slots;
649 port_bufs = port_slots;
650
651 nmif_sz = NETMAP_IF_RING_OFS(port_rings, port_rings, port_slots);
652 sz = nmif_sz * port_num;
653
654 buf_ofs = RTE_ALIGN_CEIL(sz, RTE_CACHE_LINE_SIZE);
655 sz = buf_ofs + port_bufs * conf->max_bufsz * port_num;
656
657 if (sz > UINT32_MAX ||
658 (netmap.mem = rte_zmalloc_socket(__func__, sz,
659 RTE_CACHE_LINE_SIZE, conf->socket_id)) == NULL) {
660 RTE_LOG(ERR, USER1, "%s: failed to allocate %zu bytes\n",
661 __func__, sz);
662 return -ENOMEM;
663 }
664
665 netmap.mem_sz = sz;
666 netmap.netif_memsz = nmif_sz;
667 netmap.buf_start = (uintptr_t)netmap.mem + buf_ofs;
668 netmap.conf = *conf;
669
670 rte_spinlock_init(&netmap_lock);
671
672 /* Mark all ports as unused and set NETIF pointer. */
673 for (i = 0; i != RTE_DIM(ports); i++) {
674 ports[i].fd = UINT32_MAX;
675 ports[i].nmif = (struct netmap_if *)
676 ((uintptr_t)netmap.mem + nmif_sz * i);
677 }
678
679 /* Mark all fd_ports as unused. */
680 for (i = 0; i != RTE_DIM(fd_port); i++) {
681 fd_port[i].port = FD_PORT_FREE;
682 }
683
684 return 0;
685 }
686
687
688 int
689 rte_netmap_init_port(uint8_t portid, const struct rte_netmap_port_conf *conf)
690 {
691 int32_t ret;
692 uint16_t i;
693 uint16_t rx_slots, tx_slots;
694
695 if (conf == NULL ||
696 portid >= RTE_DIM(ports) ||
697 conf->nr_tx_rings > netmap.conf.max_rings ||
698 conf->nr_rx_rings > netmap.conf.max_rings) {
699 RTE_LOG(ERR, USER1, "%s(%hhu): invalid parameters\n",
700 __func__, portid);
701 return -EINVAL;
702 }
703
704 rx_slots = (uint16_t)rte_align32pow2(conf->nr_rx_slots);
705 tx_slots = (uint16_t)rte_align32pow2(conf->nr_tx_slots);
706
707 if (tx_slots > netmap.conf.max_slots ||
708 rx_slots > netmap.conf.max_slots) {
709 RTE_LOG(ERR, USER1, "%s(%hhu): invalid parameters\n",
710 __func__, portid);
711 return -EINVAL;
712 }
713
714 ret = rte_eth_dev_configure(portid, conf->nr_rx_rings,
715 conf->nr_tx_rings, conf->eth_conf);
716
717 if (ret < 0) {
718 RTE_LOG(ERR, USER1, "Couldn't configure port %hhu\n", portid);
719 return ret;
720 }
721
722 for (i = 0; i < conf->nr_tx_rings; i++) {
723 ret = rte_eth_tx_queue_setup(portid, i, tx_slots,
724 conf->socket_id, NULL);
725
726 if (ret < 0) {
727 RTE_LOG(ERR, USER1,
728 "Couldn't configure TX queue %"PRIu16" of "
729 "port %"PRIu8"\n",
730 i, portid);
731 return ret;
732 }
733
734 ret = rte_eth_rx_queue_setup(portid, i, rx_slots,
735 conf->socket_id, NULL, conf->pool);
736
737 if (ret < 0) {
738 RTE_LOG(ERR, USER1,
739 "Couldn't configure RX queue %"PRIu16" of "
740 "port %"PRIu8"\n",
741 i, portid);
742 return ret;
743 }
744 }
745
746 /* copy config to the private storage. */
747 ports[portid].eth_conf = conf->eth_conf[0];
748 ports[portid].pool = conf->pool;
749 ports[portid].socket_id = conf->socket_id;
750 ports[portid].nr_tx_rings = conf->nr_tx_rings;
751 ports[portid].nr_rx_rings = conf->nr_rx_rings;
752 ports[portid].nr_tx_slots = tx_slots;
753 ports[portid].nr_rx_slots = rx_slots;
754 ports[portid].tx_burst = conf->tx_burst;
755 ports[portid].rx_burst = conf->rx_burst;
756
757 return 0;
758 }
759
760 int
761 rte_netmap_close(__rte_unused int fd)
762 {
763 int32_t rc;
764
765 rte_spinlock_lock(&netmap_lock);
766 rc = fd_release(fd);
767 rte_spinlock_unlock(&netmap_lock);
768
769 if (rc < 0) {
770 errno =-rc;
771 rc = -1;
772 }
773 return rc;
774 }
775
776 int rte_netmap_ioctl(int fd, uint32_t op, void *param)
777 {
778 int ret;
779
780 if (!FD_VALID(fd)) {
781 errno = EBADF;
782 return -1;
783 }
784
785 switch (op) {
786
787 case NIOCGINFO:
788 ret = ioctl_niocginfo(fd, param);
789 break;
790
791 case NIOCREGIF:
792 ret = ioctl_niocregif(fd, param);
793 break;
794
795 case NIOCUNREGIF:
796 ret = ioctl_niocunregif(fd);
797 break;
798
799 case NIOCRXSYNC:
800 ret = ioctl_niocrxsync(fd);
801 break;
802
803 case NIOCTXSYNC:
804 ret = ioctl_nioctxsync(fd);
805 break;
806
807 default:
808 ret = -ENOTTY;
809 }
810
811 if (ret < 0) {
812 errno = -ret;
813 ret = -1;
814 } else {
815 ret = 0;
816 }
817
818 return ret;
819 }
820
821 void *
822 rte_netmap_mmap(void *addr, size_t length,
823 int prot, int flags, int fd, off_t offset)
824 {
825 static const int cprot = PROT_WRITE | PROT_READ;
826
827 if (!FD_VALID(fd) || length + offset > netmap.mem_sz ||
828 (prot & cprot) != cprot ||
829 ((flags & MAP_FIXED) != 0 && addr != NULL)) {
830
831 errno = EINVAL;
832 return MAP_FAILED;
833 }
834
835 return (void *)((uintptr_t)netmap.mem + (uintptr_t)offset);
836 }
837
838 /**
839 * Return a "fake" file descriptor with a value above RLIMIT_NOFILE so that
840 * any attempt to use that file descriptor with the usual API will fail.
841 */
842 int
843 rte_netmap_open(__rte_unused const char *pathname, __rte_unused int flags)
844 {
845 int fd;
846
847 rte_spinlock_lock(&netmap_lock);
848 fd = fd_reserve();
849 rte_spinlock_unlock(&netmap_lock);
850
851 if (fd < 0) {
852 errno = -fd;
853 fd = -1;
854 }
855 return fd;
856 }
857
858 /**
859 * Doesn't support timeout other than 0 or infinite (negative) timeout
860 */
861 int
862 rte_netmap_poll(struct pollfd *fds, nfds_t nfds, int timeout)
863 {
864 int32_t count_it, ret;
865 uint32_t i, idx, port;
866 uint32_t want_rx, want_tx;
867
868 if (timeout > 0)
869 return -1;
870
871 ret = 0;
872 do {
873 for (i = 0; i < nfds; i++) {
874
875 count_it = 0;
876
877 if (!FD_VALID(fds[i].fd) || fds[i].events == 0) {
878 fds[i].revents = 0;
879 continue;
880 }
881
882 idx = FD_TO_IDX(fds[i].fd);
883 if ((port = fd_port[idx].port) >= RTE_DIM(ports) ||
884 ports[port].fd != idx) {
885
886 fds[i].revents |= POLLERR;
887 ret++;
888 continue;
889 }
890
891 want_rx = fds[i].events & (POLLIN | POLLRDNORM);
892 want_tx = fds[i].events & (POLLOUT | POLLWRNORM);
893
894 if (want_rx && rx_sync_if(port) > 0) {
895 fds[i].revents = (uint16_t)
896 (fds[i].revents | want_rx);
897 count_it = 1;
898 }
899 if (want_tx && tx_sync_if(port) > 0) {
900 fds[i].revents = (uint16_t)
901 (fds[i].revents | want_tx);
902 count_it = 1;
903 }
904
905 ret += count_it;
906 }
907 }
908 while ((ret == 0 && timeout < 0) || timeout);
909
910 return ret;
911 }