1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2016-2017 Intel Corporation 3 */ 4 5 #include <rte_atomic.h> 6 #include <rte_branch_prediction.h> 7 #include <rte_byteorder.h> 8 #include <rte_common.h> 9 #include <rte_mbuf.h> 10 #include <rte_ethdev_driver.h> 11 #include <rte_ethdev_vdev.h> 12 #include <rte_malloc.h> 13 #include <rte_bus_vdev.h> 14 #include <rte_kvargs.h> 15 #include <rte_net.h> 16 #include <rte_debug.h> 17 #include <rte_ip.h> 18 #include <rte_string_fns.h> 19 #include <rte_ethdev.h> 20 #include <rte_errno.h> 21 #include <rte_cycles.h> 22 23 #include <sys/types.h> 24 #include <sys/stat.h> 25 #include <sys/socket.h> 26 #include <sys/ioctl.h> 27 #include <sys/utsname.h> 28 #include <sys/mman.h> 29 #include <errno.h> 30 #include <signal.h> 31 #include <stdbool.h> 32 #include <stdint.h> 33 #include <sys/uio.h> 34 #include <unistd.h> 35 #include <arpa/inet.h> 36 #include <net/if.h> 37 #include <linux/if_tun.h> 38 #include <linux/if_ether.h> 39 #include <fcntl.h> 40 #include <ctype.h> 41 42 #include <tap_rss.h> 43 #include <rte_eth_tap.h> 44 #include <tap_flow.h> 45 #include <tap_netlink.h> 46 #include <tap_tcmsgs.h> 47 48 /* Linux based path to the TUN device */ 49 #define TUN_TAP_DEV_PATH "/dev/net/tun" 50 #define DEFAULT_TAP_NAME "dtap" 51 #define DEFAULT_TUN_NAME "dtun" 52 53 #define ETH_TAP_IFACE_ARG "iface" 54 #define ETH_TAP_REMOTE_ARG "remote" 55 #define ETH_TAP_MAC_ARG "mac" 56 #define ETH_TAP_MAC_FIXED "fixed" 57 58 #define ETH_TAP_USR_MAC_FMT "xx:xx:xx:xx:xx:xx" 59 #define ETH_TAP_CMP_MAC_FMT "0123456789ABCDEFabcdef" 60 #define ETH_TAP_MAC_ARG_FMT ETH_TAP_MAC_FIXED "|" ETH_TAP_USR_MAC_FMT 61 62 #define TAP_GSO_MBUFS_PER_CORE 128 63 #define TAP_GSO_MBUF_SEG_SIZE 128 64 #define TAP_GSO_MBUF_CACHE_SIZE 4 65 #define TAP_GSO_MBUFS_NUM \ 66 (TAP_GSO_MBUFS_PER_CORE * TAP_GSO_MBUF_CACHE_SIZE) 67 68 /* IPC key for queue fds sync */ 69 #define TAP_MP_KEY "tap_mp_sync_queues" 70 71 #define TAP_IOV_DEFAULT_MAX 1024 72 73 static int tap_devices_count; 74 75 static const char *valid_arguments[] = { 76 ETH_TAP_IFACE_ARG, 77 ETH_TAP_REMOTE_ARG, 78 ETH_TAP_MAC_ARG, 79 NULL 80 }; 81 82 static volatile uint32_t tap_trigger; /* Rx trigger */ 83 84 static struct rte_eth_link pmd_link = { 85 .link_speed = ETH_SPEED_NUM_10G, 86 .link_duplex = ETH_LINK_FULL_DUPLEX, 87 .link_status = ETH_LINK_DOWN, 88 .link_autoneg = ETH_LINK_FIXED, 89 }; 90 91 static void 92 tap_trigger_cb(int sig __rte_unused) 93 { 94 /* Valid trigger values are nonzero */ 95 tap_trigger = (tap_trigger + 1) | 0x80000000; 96 } 97 98 /* Specifies on what netdevices the ioctl should be applied */ 99 enum ioctl_mode { 100 LOCAL_AND_REMOTE, 101 LOCAL_ONLY, 102 REMOTE_ONLY, 103 }; 104 105 /* Message header to synchronize queues via IPC */ 106 struct ipc_queues { 107 char port_name[RTE_DEV_NAME_MAX_LEN]; 108 int rxq_count; 109 int txq_count; 110 /* 111 * The file descriptors are in the dedicated part 112 * of the Unix message to be translated by the kernel. 113 */ 114 }; 115 116 static int tap_intr_handle_set(struct rte_eth_dev *dev, int set); 117 118 /** 119 * Tun/Tap allocation routine 120 * 121 * @param[in] pmd 122 * Pointer to private structure. 123 * 124 * @param[in] is_keepalive 125 * Keepalive flag 126 * 127 * @return 128 * -1 on failure, fd on success 129 */ 130 static int 131 tun_alloc(struct pmd_internals *pmd, int is_keepalive) 132 { 133 struct ifreq ifr; 134 #ifdef IFF_MULTI_QUEUE 135 unsigned int features; 136 #endif 137 int fd, signo, flags; 138 139 memset(&ifr, 0, sizeof(struct ifreq)); 140 141 /* 142 * Do not set IFF_NO_PI as packet information header will be needed 143 * to check if a received packet has been truncated. 144 */ 145 ifr.ifr_flags = (pmd->type == ETH_TUNTAP_TYPE_TAP) ? 146 IFF_TAP : IFF_TUN | IFF_POINTOPOINT; 147 strlcpy(ifr.ifr_name, pmd->name, IFNAMSIZ); 148 149 fd = open(TUN_TAP_DEV_PATH, O_RDWR); 150 if (fd < 0) { 151 TAP_LOG(ERR, "Unable to open %s interface", TUN_TAP_DEV_PATH); 152 goto error; 153 } 154 155 #ifdef IFF_MULTI_QUEUE 156 /* Grab the TUN features to verify we can work multi-queue */ 157 if (ioctl(fd, TUNGETFEATURES, &features) < 0) { 158 TAP_LOG(ERR, "unable to get TUN/TAP features"); 159 goto error; 160 } 161 TAP_LOG(DEBUG, "%s Features %08x", TUN_TAP_DEV_PATH, features); 162 163 if (features & IFF_MULTI_QUEUE) { 164 TAP_LOG(DEBUG, " Multi-queue support for %d queues", 165 RTE_PMD_TAP_MAX_QUEUES); 166 ifr.ifr_flags |= IFF_MULTI_QUEUE; 167 } else 168 #endif 169 { 170 ifr.ifr_flags |= IFF_ONE_QUEUE; 171 TAP_LOG(DEBUG, " Single queue only support"); 172 } 173 174 /* Set the TUN/TAP configuration and set the name if needed */ 175 if (ioctl(fd, TUNSETIFF, (void *)&ifr) < 0) { 176 TAP_LOG(WARNING, "Unable to set TUNSETIFF for %s: %s", 177 ifr.ifr_name, strerror(errno)); 178 goto error; 179 } 180 181 /* 182 * Name passed to kernel might be wildcard like dtun%d 183 * and need to find the resulting device. 184 */ 185 TAP_LOG(DEBUG, "Device name is '%s'", ifr.ifr_name); 186 strlcpy(pmd->name, ifr.ifr_name, RTE_ETH_NAME_MAX_LEN); 187 188 if (is_keepalive) { 189 /* 190 * Detach the TUN/TAP keep-alive queue 191 * to avoid traffic through it 192 */ 193 ifr.ifr_flags = IFF_DETACH_QUEUE; 194 if (ioctl(fd, TUNSETQUEUE, (void *)&ifr) < 0) { 195 TAP_LOG(WARNING, 196 "Unable to detach keep-alive queue for %s: %s", 197 ifr.ifr_name, strerror(errno)); 198 goto error; 199 } 200 } 201 202 flags = fcntl(fd, F_GETFL); 203 if (flags == -1) { 204 TAP_LOG(WARNING, 205 "Unable to get %s current flags\n", 206 ifr.ifr_name); 207 goto error; 208 } 209 210 /* Always set the file descriptor to non-blocking */ 211 flags |= O_NONBLOCK; 212 if (fcntl(fd, F_SETFL, flags) < 0) { 213 TAP_LOG(WARNING, 214 "Unable to set %s to nonblocking: %s", 215 ifr.ifr_name, strerror(errno)); 216 goto error; 217 } 218 219 /* Find a free realtime signal */ 220 for (signo = SIGRTMIN + 1; signo < SIGRTMAX; signo++) { 221 struct sigaction sa; 222 223 if (sigaction(signo, NULL, &sa) == -1) { 224 TAP_LOG(WARNING, 225 "Unable to get current rt-signal %d handler", 226 signo); 227 goto error; 228 } 229 230 /* Already have the handler we want on this signal */ 231 if (sa.sa_handler == tap_trigger_cb) 232 break; 233 234 /* Is handler in use by application */ 235 if (sa.sa_handler != SIG_DFL) { 236 TAP_LOG(DEBUG, 237 "Skipping used rt-signal %d", signo); 238 continue; 239 } 240 241 sa = (struct sigaction) { 242 .sa_flags = SA_RESTART, 243 .sa_handler = tap_trigger_cb, 244 }; 245 246 if (sigaction(signo, &sa, NULL) == -1) { 247 TAP_LOG(WARNING, 248 "Unable to set rt-signal %d handler\n", signo); 249 goto error; 250 } 251 252 /* Found a good signal to use */ 253 TAP_LOG(DEBUG, 254 "Using rt-signal %d", signo); 255 break; 256 } 257 258 if (signo == SIGRTMAX) { 259 TAP_LOG(WARNING, "All rt-signals are in use\n"); 260 261 /* Disable trigger globally in case of error */ 262 tap_trigger = 0; 263 TAP_LOG(NOTICE, "No Rx trigger signal available\n"); 264 } else { 265 /* Enable signal on file descriptor */ 266 if (fcntl(fd, F_SETSIG, signo) < 0) { 267 TAP_LOG(WARNING, "Unable to set signo %d for fd %d: %s", 268 signo, fd, strerror(errno)); 269 goto error; 270 } 271 if (fcntl(fd, F_SETFL, flags | O_ASYNC) < 0) { 272 TAP_LOG(WARNING, "Unable to set fcntl flags: %s", 273 strerror(errno)); 274 goto error; 275 } 276 277 if (fcntl(fd, F_SETOWN, getpid()) < 0) { 278 TAP_LOG(WARNING, "Unable to set fcntl owner: %s", 279 strerror(errno)); 280 goto error; 281 } 282 } 283 return fd; 284 285 error: 286 if (fd >= 0) 287 close(fd); 288 return -1; 289 } 290 291 static void 292 tap_verify_csum(struct rte_mbuf *mbuf) 293 { 294 uint32_t l2 = mbuf->packet_type & RTE_PTYPE_L2_MASK; 295 uint32_t l3 = mbuf->packet_type & RTE_PTYPE_L3_MASK; 296 uint32_t l4 = mbuf->packet_type & RTE_PTYPE_L4_MASK; 297 unsigned int l2_len = sizeof(struct rte_ether_hdr); 298 unsigned int l3_len; 299 uint16_t cksum = 0; 300 void *l3_hdr; 301 void *l4_hdr; 302 303 if (l2 == RTE_PTYPE_L2_ETHER_VLAN) 304 l2_len += 4; 305 else if (l2 == RTE_PTYPE_L2_ETHER_QINQ) 306 l2_len += 8; 307 /* Don't verify checksum for packets with discontinuous L2 header */ 308 if (unlikely(l2_len + sizeof(struct rte_ipv4_hdr) > 309 rte_pktmbuf_data_len(mbuf))) 310 return; 311 l3_hdr = rte_pktmbuf_mtod_offset(mbuf, void *, l2_len); 312 if (l3 == RTE_PTYPE_L3_IPV4 || l3 == RTE_PTYPE_L3_IPV4_EXT) { 313 struct rte_ipv4_hdr *iph = l3_hdr; 314 315 /* ihl contains the number of 4-byte words in the header */ 316 l3_len = 4 * (iph->version_ihl & 0xf); 317 if (unlikely(l2_len + l3_len > rte_pktmbuf_data_len(mbuf))) 318 return; 319 /* check that the total length reported by header is not 320 * greater than the total received size 321 */ 322 if (l2_len + rte_be_to_cpu_16(iph->total_length) > 323 rte_pktmbuf_data_len(mbuf)) 324 return; 325 326 cksum = ~rte_raw_cksum(iph, l3_len); 327 mbuf->ol_flags |= cksum ? 328 PKT_RX_IP_CKSUM_BAD : 329 PKT_RX_IP_CKSUM_GOOD; 330 } else if (l3 == RTE_PTYPE_L3_IPV6) { 331 struct rte_ipv6_hdr *iph = l3_hdr; 332 333 l3_len = sizeof(struct rte_ipv6_hdr); 334 /* check that the total length reported by header is not 335 * greater than the total received size 336 */ 337 if (l2_len + l3_len + rte_be_to_cpu_16(iph->payload_len) > 338 rte_pktmbuf_data_len(mbuf)) 339 return; 340 } else { 341 /* IPv6 extensions are not supported */ 342 return; 343 } 344 if (l4 == RTE_PTYPE_L4_UDP || l4 == RTE_PTYPE_L4_TCP) { 345 l4_hdr = rte_pktmbuf_mtod_offset(mbuf, void *, l2_len + l3_len); 346 /* Don't verify checksum for multi-segment packets. */ 347 if (mbuf->nb_segs > 1) 348 return; 349 if (l3 == RTE_PTYPE_L3_IPV4) 350 cksum = ~rte_ipv4_udptcp_cksum(l3_hdr, l4_hdr); 351 else if (l3 == RTE_PTYPE_L3_IPV6) 352 cksum = ~rte_ipv6_udptcp_cksum(l3_hdr, l4_hdr); 353 mbuf->ol_flags |= cksum ? 354 PKT_RX_L4_CKSUM_BAD : 355 PKT_RX_L4_CKSUM_GOOD; 356 } 357 } 358 359 static uint64_t 360 tap_rx_offload_get_port_capa(void) 361 { 362 /* 363 * No specific port Rx offload capabilities. 364 */ 365 return 0; 366 } 367 368 static uint64_t 369 tap_rx_offload_get_queue_capa(void) 370 { 371 return DEV_RX_OFFLOAD_SCATTER | 372 DEV_RX_OFFLOAD_IPV4_CKSUM | 373 DEV_RX_OFFLOAD_UDP_CKSUM | 374 DEV_RX_OFFLOAD_TCP_CKSUM; 375 } 376 377 static void 378 tap_rxq_pool_free(struct rte_mbuf *pool) 379 { 380 struct rte_mbuf *mbuf = pool; 381 uint16_t nb_segs = 1; 382 383 if (mbuf == NULL) 384 return; 385 386 while (mbuf->next) { 387 mbuf = mbuf->next; 388 nb_segs++; 389 } 390 pool->nb_segs = nb_segs; 391 rte_pktmbuf_free(pool); 392 } 393 394 /* Callback to handle the rx burst of packets to the correct interface and 395 * file descriptor(s) in a multi-queue setup. 396 */ 397 static uint16_t 398 pmd_rx_burst(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts) 399 { 400 struct rx_queue *rxq = queue; 401 struct pmd_process_private *process_private; 402 uint16_t num_rx; 403 unsigned long num_rx_bytes = 0; 404 uint32_t trigger = tap_trigger; 405 406 if (trigger == rxq->trigger_seen) 407 return 0; 408 409 process_private = rte_eth_devices[rxq->in_port].process_private; 410 for (num_rx = 0; num_rx < nb_pkts; ) { 411 struct rte_mbuf *mbuf = rxq->pool; 412 struct rte_mbuf *seg = NULL; 413 struct rte_mbuf *new_tail = NULL; 414 uint16_t data_off = rte_pktmbuf_headroom(mbuf); 415 int len; 416 417 len = readv(process_private->rxq_fds[rxq->queue_id], 418 *rxq->iovecs, 419 1 + (rxq->rxmode->offloads & DEV_RX_OFFLOAD_SCATTER ? 420 rxq->nb_rx_desc : 1)); 421 if (len < (int)sizeof(struct tun_pi)) 422 break; 423 424 /* Packet couldn't fit in the provided mbuf */ 425 if (unlikely(rxq->pi.flags & TUN_PKT_STRIP)) { 426 rxq->stats.ierrors++; 427 continue; 428 } 429 430 len -= sizeof(struct tun_pi); 431 432 mbuf->pkt_len = len; 433 mbuf->port = rxq->in_port; 434 while (1) { 435 struct rte_mbuf *buf = rte_pktmbuf_alloc(rxq->mp); 436 437 if (unlikely(!buf)) { 438 rxq->stats.rx_nombuf++; 439 /* No new buf has been allocated: do nothing */ 440 if (!new_tail || !seg) 441 goto end; 442 443 seg->next = NULL; 444 tap_rxq_pool_free(mbuf); 445 446 goto end; 447 } 448 seg = seg ? seg->next : mbuf; 449 if (rxq->pool == mbuf) 450 rxq->pool = buf; 451 if (new_tail) 452 new_tail->next = buf; 453 new_tail = buf; 454 new_tail->next = seg->next; 455 456 /* iovecs[0] is reserved for packet info (pi) */ 457 (*rxq->iovecs)[mbuf->nb_segs].iov_len = 458 buf->buf_len - data_off; 459 (*rxq->iovecs)[mbuf->nb_segs].iov_base = 460 (char *)buf->buf_addr + data_off; 461 462 seg->data_len = RTE_MIN(seg->buf_len - data_off, len); 463 seg->data_off = data_off; 464 465 len -= seg->data_len; 466 if (len <= 0) 467 break; 468 mbuf->nb_segs++; 469 /* First segment has headroom, not the others */ 470 data_off = 0; 471 } 472 seg->next = NULL; 473 mbuf->packet_type = rte_net_get_ptype(mbuf, NULL, 474 RTE_PTYPE_ALL_MASK); 475 if (rxq->rxmode->offloads & DEV_RX_OFFLOAD_CHECKSUM) 476 tap_verify_csum(mbuf); 477 478 /* account for the receive frame */ 479 bufs[num_rx++] = mbuf; 480 num_rx_bytes += mbuf->pkt_len; 481 } 482 end: 483 rxq->stats.ipackets += num_rx; 484 rxq->stats.ibytes += num_rx_bytes; 485 486 if (trigger && num_rx < nb_pkts) 487 rxq->trigger_seen = trigger; 488 489 return num_rx; 490 } 491 492 static uint64_t 493 tap_tx_offload_get_port_capa(void) 494 { 495 /* 496 * No specific port Tx offload capabilities. 497 */ 498 return 0; 499 } 500 501 static uint64_t 502 tap_tx_offload_get_queue_capa(void) 503 { 504 return DEV_TX_OFFLOAD_MULTI_SEGS | 505 DEV_TX_OFFLOAD_IPV4_CKSUM | 506 DEV_TX_OFFLOAD_UDP_CKSUM | 507 DEV_TX_OFFLOAD_TCP_CKSUM | 508 DEV_TX_OFFLOAD_TCP_TSO; 509 } 510 511 /* Finalize l4 checksum calculation */ 512 static void 513 tap_tx_l4_cksum(uint16_t *l4_cksum, uint16_t l4_phdr_cksum, 514 uint32_t l4_raw_cksum) 515 { 516 if (l4_cksum) { 517 uint32_t cksum; 518 519 cksum = __rte_raw_cksum_reduce(l4_raw_cksum); 520 cksum += l4_phdr_cksum; 521 522 cksum = ((cksum & 0xffff0000) >> 16) + (cksum & 0xffff); 523 cksum = (~cksum) & 0xffff; 524 if (cksum == 0) 525 cksum = 0xffff; 526 *l4_cksum = cksum; 527 } 528 } 529 530 /* Accumaulate L4 raw checksums */ 531 static void 532 tap_tx_l4_add_rcksum(char *l4_data, unsigned int l4_len, uint16_t *l4_cksum, 533 uint32_t *l4_raw_cksum) 534 { 535 if (l4_cksum == NULL) 536 return; 537 538 *l4_raw_cksum = __rte_raw_cksum(l4_data, l4_len, *l4_raw_cksum); 539 } 540 541 /* L3 and L4 pseudo headers checksum offloads */ 542 static void 543 tap_tx_l3_cksum(char *packet, uint64_t ol_flags, unsigned int l2_len, 544 unsigned int l3_len, unsigned int l4_len, uint16_t **l4_cksum, 545 uint16_t *l4_phdr_cksum, uint32_t *l4_raw_cksum) 546 { 547 void *l3_hdr = packet + l2_len; 548 549 if (ol_flags & (PKT_TX_IP_CKSUM | PKT_TX_IPV4)) { 550 struct rte_ipv4_hdr *iph = l3_hdr; 551 uint16_t cksum; 552 553 iph->hdr_checksum = 0; 554 cksum = rte_raw_cksum(iph, l3_len); 555 iph->hdr_checksum = (cksum == 0xffff) ? cksum : ~cksum; 556 } 557 if (ol_flags & PKT_TX_L4_MASK) { 558 void *l4_hdr; 559 560 l4_hdr = packet + l2_len + l3_len; 561 if ((ol_flags & PKT_TX_L4_MASK) == PKT_TX_UDP_CKSUM) 562 *l4_cksum = &((struct rte_udp_hdr *)l4_hdr)->dgram_cksum; 563 else if ((ol_flags & PKT_TX_L4_MASK) == PKT_TX_TCP_CKSUM) 564 *l4_cksum = &((struct rte_tcp_hdr *)l4_hdr)->cksum; 565 else 566 return; 567 **l4_cksum = 0; 568 if (ol_flags & PKT_TX_IPV4) 569 *l4_phdr_cksum = rte_ipv4_phdr_cksum(l3_hdr, 0); 570 else 571 *l4_phdr_cksum = rte_ipv6_phdr_cksum(l3_hdr, 0); 572 *l4_raw_cksum = __rte_raw_cksum(l4_hdr, l4_len, 0); 573 } 574 } 575 576 static inline int 577 tap_write_mbufs(struct tx_queue *txq, uint16_t num_mbufs, 578 struct rte_mbuf **pmbufs, 579 uint16_t *num_packets, unsigned long *num_tx_bytes) 580 { 581 int i; 582 uint16_t l234_hlen; 583 struct pmd_process_private *process_private; 584 585 process_private = rte_eth_devices[txq->out_port].process_private; 586 587 for (i = 0; i < num_mbufs; i++) { 588 struct rte_mbuf *mbuf = pmbufs[i]; 589 struct iovec iovecs[mbuf->nb_segs + 2]; 590 struct tun_pi pi = { .flags = 0, .proto = 0x00 }; 591 struct rte_mbuf *seg = mbuf; 592 char m_copy[mbuf->data_len]; 593 int proto; 594 int n; 595 int j; 596 int k; /* current index in iovecs for copying segments */ 597 uint16_t seg_len; /* length of first segment */ 598 uint16_t nb_segs; 599 uint16_t *l4_cksum; /* l4 checksum (pseudo header + payload) */ 600 uint32_t l4_raw_cksum = 0; /* TCP/UDP payload raw checksum */ 601 uint16_t l4_phdr_cksum = 0; /* TCP/UDP pseudo header checksum */ 602 uint16_t is_cksum = 0; /* in case cksum should be offloaded */ 603 604 l4_cksum = NULL; 605 if (txq->type == ETH_TUNTAP_TYPE_TUN) { 606 /* 607 * TUN and TAP are created with IFF_NO_PI disabled. 608 * For TUN PMD this mandatory as fields are used by 609 * Kernel tun.c to determine whether its IP or non IP 610 * packets. 611 * 612 * The logic fetches the first byte of data from mbuf 613 * then compares whether its v4 or v6. If first byte 614 * is 4 or 6, then protocol field is updated. 615 */ 616 char *buff_data = rte_pktmbuf_mtod(seg, void *); 617 proto = (*buff_data & 0xf0); 618 pi.proto = (proto == 0x40) ? 619 rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4) : 620 ((proto == 0x60) ? 621 rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV6) : 622 0x00); 623 } 624 625 k = 0; 626 iovecs[k].iov_base = π 627 iovecs[k].iov_len = sizeof(pi); 628 k++; 629 630 nb_segs = mbuf->nb_segs; 631 if (txq->csum && 632 ((mbuf->ol_flags & (PKT_TX_IP_CKSUM | PKT_TX_IPV4) || 633 (mbuf->ol_flags & PKT_TX_L4_MASK) == PKT_TX_UDP_CKSUM || 634 (mbuf->ol_flags & PKT_TX_L4_MASK) == PKT_TX_TCP_CKSUM))) { 635 is_cksum = 1; 636 637 /* Support only packets with at least layer 4 638 * header included in the first segment 639 */ 640 seg_len = rte_pktmbuf_data_len(mbuf); 641 l234_hlen = mbuf->l2_len + mbuf->l3_len + mbuf->l4_len; 642 if (seg_len < l234_hlen) 643 return -1; 644 645 /* To change checksums, work on a * copy of l2, l3 646 * headers + l4 pseudo header 647 */ 648 rte_memcpy(m_copy, rte_pktmbuf_mtod(mbuf, void *), 649 l234_hlen); 650 tap_tx_l3_cksum(m_copy, mbuf->ol_flags, 651 mbuf->l2_len, mbuf->l3_len, mbuf->l4_len, 652 &l4_cksum, &l4_phdr_cksum, 653 &l4_raw_cksum); 654 iovecs[k].iov_base = m_copy; 655 iovecs[k].iov_len = l234_hlen; 656 k++; 657 658 /* Update next iovecs[] beyond l2, l3, l4 headers */ 659 if (seg_len > l234_hlen) { 660 iovecs[k].iov_len = seg_len - l234_hlen; 661 iovecs[k].iov_base = 662 rte_pktmbuf_mtod(seg, char *) + 663 l234_hlen; 664 tap_tx_l4_add_rcksum(iovecs[k].iov_base, 665 iovecs[k].iov_len, l4_cksum, 666 &l4_raw_cksum); 667 k++; 668 nb_segs++; 669 } 670 seg = seg->next; 671 } 672 673 for (j = k; j <= nb_segs; j++) { 674 iovecs[j].iov_len = rte_pktmbuf_data_len(seg); 675 iovecs[j].iov_base = rte_pktmbuf_mtod(seg, void *); 676 if (is_cksum) 677 tap_tx_l4_add_rcksum(iovecs[j].iov_base, 678 iovecs[j].iov_len, l4_cksum, 679 &l4_raw_cksum); 680 seg = seg->next; 681 } 682 683 if (is_cksum) 684 tap_tx_l4_cksum(l4_cksum, l4_phdr_cksum, l4_raw_cksum); 685 686 /* copy the tx frame data */ 687 n = writev(process_private->txq_fds[txq->queue_id], iovecs, j); 688 if (n <= 0) 689 return -1; 690 691 (*num_packets)++; 692 (*num_tx_bytes) += rte_pktmbuf_pkt_len(mbuf); 693 } 694 return 0; 695 } 696 697 /* Callback to handle sending packets from the tap interface 698 */ 699 static uint16_t 700 pmd_tx_burst(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts) 701 { 702 struct tx_queue *txq = queue; 703 uint16_t num_tx = 0; 704 uint16_t num_packets = 0; 705 unsigned long num_tx_bytes = 0; 706 uint32_t max_size; 707 int i; 708 709 if (unlikely(nb_pkts == 0)) 710 return 0; 711 712 struct rte_mbuf *gso_mbufs[MAX_GSO_MBUFS]; 713 max_size = *txq->mtu + (RTE_ETHER_HDR_LEN + RTE_ETHER_CRC_LEN + 4); 714 for (i = 0; i < nb_pkts; i++) { 715 struct rte_mbuf *mbuf_in = bufs[num_tx]; 716 struct rte_mbuf **mbuf; 717 uint16_t num_mbufs = 0; 718 uint16_t tso_segsz = 0; 719 int ret; 720 int num_tso_mbufs; 721 uint16_t hdrs_len; 722 uint64_t tso; 723 724 tso = mbuf_in->ol_flags & PKT_TX_TCP_SEG; 725 if (tso) { 726 struct rte_gso_ctx *gso_ctx = &txq->gso_ctx; 727 728 /* TCP segmentation implies TCP checksum offload */ 729 mbuf_in->ol_flags |= PKT_TX_TCP_CKSUM; 730 731 /* gso size is calculated without RTE_ETHER_CRC_LEN */ 732 hdrs_len = mbuf_in->l2_len + mbuf_in->l3_len + 733 mbuf_in->l4_len; 734 tso_segsz = mbuf_in->tso_segsz + hdrs_len; 735 if (unlikely(tso_segsz == hdrs_len) || 736 tso_segsz > *txq->mtu) { 737 txq->stats.errs++; 738 break; 739 } 740 gso_ctx->gso_size = tso_segsz; 741 /* 'mbuf_in' packet to segment */ 742 num_tso_mbufs = rte_gso_segment(mbuf_in, 743 gso_ctx, /* gso control block */ 744 (struct rte_mbuf **)&gso_mbufs, /* out mbufs */ 745 RTE_DIM(gso_mbufs)); /* max tso mbufs */ 746 747 /* ret contains the number of new created mbufs */ 748 if (num_tso_mbufs < 0) 749 break; 750 751 mbuf = gso_mbufs; 752 num_mbufs = num_tso_mbufs; 753 } else { 754 /* stats.errs will be incremented */ 755 if (rte_pktmbuf_pkt_len(mbuf_in) > max_size) 756 break; 757 758 /* ret 0 indicates no new mbufs were created */ 759 num_tso_mbufs = 0; 760 mbuf = &mbuf_in; 761 num_mbufs = 1; 762 } 763 764 ret = tap_write_mbufs(txq, num_mbufs, mbuf, 765 &num_packets, &num_tx_bytes); 766 if (ret == -1) { 767 txq->stats.errs++; 768 /* free tso mbufs */ 769 if (num_tso_mbufs > 0) 770 rte_pktmbuf_free_bulk(mbuf, num_tso_mbufs); 771 break; 772 } 773 num_tx++; 774 /* free original mbuf */ 775 rte_pktmbuf_free(mbuf_in); 776 /* free tso mbufs */ 777 if (num_tso_mbufs > 0) 778 rte_pktmbuf_free_bulk(mbuf, num_tso_mbufs); 779 } 780 781 txq->stats.opackets += num_packets; 782 txq->stats.errs += nb_pkts - num_tx; 783 txq->stats.obytes += num_tx_bytes; 784 785 return num_tx; 786 } 787 788 static const char * 789 tap_ioctl_req2str(unsigned long request) 790 { 791 switch (request) { 792 case SIOCSIFFLAGS: 793 return "SIOCSIFFLAGS"; 794 case SIOCGIFFLAGS: 795 return "SIOCGIFFLAGS"; 796 case SIOCGIFHWADDR: 797 return "SIOCGIFHWADDR"; 798 case SIOCSIFHWADDR: 799 return "SIOCSIFHWADDR"; 800 case SIOCSIFMTU: 801 return "SIOCSIFMTU"; 802 } 803 return "UNKNOWN"; 804 } 805 806 static int 807 tap_ioctl(struct pmd_internals *pmd, unsigned long request, 808 struct ifreq *ifr, int set, enum ioctl_mode mode) 809 { 810 short req_flags = ifr->ifr_flags; 811 int remote = pmd->remote_if_index && 812 (mode == REMOTE_ONLY || mode == LOCAL_AND_REMOTE); 813 814 if (!pmd->remote_if_index && mode == REMOTE_ONLY) 815 return 0; 816 /* 817 * If there is a remote netdevice, apply ioctl on it, then apply it on 818 * the tap netdevice. 819 */ 820 apply: 821 if (remote) 822 strlcpy(ifr->ifr_name, pmd->remote_iface, IFNAMSIZ); 823 else if (mode == LOCAL_ONLY || mode == LOCAL_AND_REMOTE) 824 strlcpy(ifr->ifr_name, pmd->name, IFNAMSIZ); 825 switch (request) { 826 case SIOCSIFFLAGS: 827 /* fetch current flags to leave other flags untouched */ 828 if (ioctl(pmd->ioctl_sock, SIOCGIFFLAGS, ifr) < 0) 829 goto error; 830 if (set) 831 ifr->ifr_flags |= req_flags; 832 else 833 ifr->ifr_flags &= ~req_flags; 834 break; 835 case SIOCGIFFLAGS: 836 case SIOCGIFHWADDR: 837 case SIOCSIFHWADDR: 838 case SIOCSIFMTU: 839 break; 840 default: 841 TAP_LOG(WARNING, "%s: ioctl() called with wrong arg", 842 pmd->name); 843 return -EINVAL; 844 } 845 if (ioctl(pmd->ioctl_sock, request, ifr) < 0) 846 goto error; 847 if (remote-- && mode == LOCAL_AND_REMOTE) 848 goto apply; 849 return 0; 850 851 error: 852 TAP_LOG(DEBUG, "%s(%s) failed: %s(%d)", ifr->ifr_name, 853 tap_ioctl_req2str(request), strerror(errno), errno); 854 return -errno; 855 } 856 857 static int 858 tap_link_set_down(struct rte_eth_dev *dev) 859 { 860 struct pmd_internals *pmd = dev->data->dev_private; 861 struct ifreq ifr = { .ifr_flags = IFF_UP }; 862 863 dev->data->dev_link.link_status = ETH_LINK_DOWN; 864 return tap_ioctl(pmd, SIOCSIFFLAGS, &ifr, 0, LOCAL_ONLY); 865 } 866 867 static int 868 tap_link_set_up(struct rte_eth_dev *dev) 869 { 870 struct pmd_internals *pmd = dev->data->dev_private; 871 struct ifreq ifr = { .ifr_flags = IFF_UP }; 872 873 dev->data->dev_link.link_status = ETH_LINK_UP; 874 return tap_ioctl(pmd, SIOCSIFFLAGS, &ifr, 1, LOCAL_AND_REMOTE); 875 } 876 877 static int 878 tap_dev_start(struct rte_eth_dev *dev) 879 { 880 int err, i; 881 882 err = tap_intr_handle_set(dev, 1); 883 if (err) 884 return err; 885 886 err = tap_link_set_up(dev); 887 if (err) 888 return err; 889 890 for (i = 0; i < dev->data->nb_tx_queues; i++) 891 dev->data->tx_queue_state[i] = RTE_ETH_QUEUE_STATE_STARTED; 892 for (i = 0; i < dev->data->nb_rx_queues; i++) 893 dev->data->rx_queue_state[i] = RTE_ETH_QUEUE_STATE_STARTED; 894 895 return err; 896 } 897 898 /* This function gets called when the current port gets stopped. 899 */ 900 static void 901 tap_dev_stop(struct rte_eth_dev *dev) 902 { 903 int i; 904 905 for (i = 0; i < dev->data->nb_tx_queues; i++) 906 dev->data->tx_queue_state[i] = RTE_ETH_QUEUE_STATE_STOPPED; 907 for (i = 0; i < dev->data->nb_rx_queues; i++) 908 dev->data->rx_queue_state[i] = RTE_ETH_QUEUE_STATE_STOPPED; 909 910 tap_intr_handle_set(dev, 0); 911 tap_link_set_down(dev); 912 } 913 914 static int 915 tap_dev_configure(struct rte_eth_dev *dev) 916 { 917 struct pmd_internals *pmd = dev->data->dev_private; 918 919 if (dev->data->nb_rx_queues > RTE_PMD_TAP_MAX_QUEUES) { 920 TAP_LOG(ERR, 921 "%s: number of rx queues %d exceeds max num of queues %d", 922 dev->device->name, 923 dev->data->nb_rx_queues, 924 RTE_PMD_TAP_MAX_QUEUES); 925 return -1; 926 } 927 if (dev->data->nb_tx_queues > RTE_PMD_TAP_MAX_QUEUES) { 928 TAP_LOG(ERR, 929 "%s: number of tx queues %d exceeds max num of queues %d", 930 dev->device->name, 931 dev->data->nb_tx_queues, 932 RTE_PMD_TAP_MAX_QUEUES); 933 return -1; 934 } 935 936 TAP_LOG(INFO, "%s: %s: TX configured queues number: %u", 937 dev->device->name, pmd->name, dev->data->nb_tx_queues); 938 939 TAP_LOG(INFO, "%s: %s: RX configured queues number: %u", 940 dev->device->name, pmd->name, dev->data->nb_rx_queues); 941 942 return 0; 943 } 944 945 static uint32_t 946 tap_dev_speed_capa(void) 947 { 948 uint32_t speed = pmd_link.link_speed; 949 uint32_t capa = 0; 950 951 if (speed >= ETH_SPEED_NUM_10M) 952 capa |= ETH_LINK_SPEED_10M; 953 if (speed >= ETH_SPEED_NUM_100M) 954 capa |= ETH_LINK_SPEED_100M; 955 if (speed >= ETH_SPEED_NUM_1G) 956 capa |= ETH_LINK_SPEED_1G; 957 if (speed >= ETH_SPEED_NUM_5G) 958 capa |= ETH_LINK_SPEED_2_5G; 959 if (speed >= ETH_SPEED_NUM_5G) 960 capa |= ETH_LINK_SPEED_5G; 961 if (speed >= ETH_SPEED_NUM_10G) 962 capa |= ETH_LINK_SPEED_10G; 963 if (speed >= ETH_SPEED_NUM_20G) 964 capa |= ETH_LINK_SPEED_20G; 965 if (speed >= ETH_SPEED_NUM_25G) 966 capa |= ETH_LINK_SPEED_25G; 967 if (speed >= ETH_SPEED_NUM_40G) 968 capa |= ETH_LINK_SPEED_40G; 969 if (speed >= ETH_SPEED_NUM_50G) 970 capa |= ETH_LINK_SPEED_50G; 971 if (speed >= ETH_SPEED_NUM_56G) 972 capa |= ETH_LINK_SPEED_56G; 973 if (speed >= ETH_SPEED_NUM_100G) 974 capa |= ETH_LINK_SPEED_100G; 975 976 return capa; 977 } 978 979 static int 980 tap_dev_info(struct rte_eth_dev *dev, struct rte_eth_dev_info *dev_info) 981 { 982 struct pmd_internals *internals = dev->data->dev_private; 983 984 dev_info->if_index = internals->if_index; 985 dev_info->max_mac_addrs = 1; 986 dev_info->max_rx_pktlen = (uint32_t)RTE_ETHER_MAX_VLAN_FRAME_LEN; 987 dev_info->max_rx_queues = RTE_PMD_TAP_MAX_QUEUES; 988 dev_info->max_tx_queues = RTE_PMD_TAP_MAX_QUEUES; 989 dev_info->min_rx_bufsize = 0; 990 dev_info->speed_capa = tap_dev_speed_capa(); 991 dev_info->rx_queue_offload_capa = tap_rx_offload_get_queue_capa(); 992 dev_info->rx_offload_capa = tap_rx_offload_get_port_capa() | 993 dev_info->rx_queue_offload_capa; 994 dev_info->tx_queue_offload_capa = tap_tx_offload_get_queue_capa(); 995 dev_info->tx_offload_capa = tap_tx_offload_get_port_capa() | 996 dev_info->tx_queue_offload_capa; 997 dev_info->hash_key_size = TAP_RSS_HASH_KEY_SIZE; 998 /* 999 * limitation: TAP supports all of IP, UDP and TCP hash 1000 * functions together and not in partial combinations 1001 */ 1002 dev_info->flow_type_rss_offloads = ~TAP_RSS_HF_MASK; 1003 1004 return 0; 1005 } 1006 1007 static int 1008 tap_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *tap_stats) 1009 { 1010 unsigned int i, imax; 1011 unsigned long rx_total = 0, tx_total = 0, tx_err_total = 0; 1012 unsigned long rx_bytes_total = 0, tx_bytes_total = 0; 1013 unsigned long rx_nombuf = 0, ierrors = 0; 1014 const struct pmd_internals *pmd = dev->data->dev_private; 1015 1016 /* rx queue statistics */ 1017 imax = (dev->data->nb_rx_queues < RTE_ETHDEV_QUEUE_STAT_CNTRS) ? 1018 dev->data->nb_rx_queues : RTE_ETHDEV_QUEUE_STAT_CNTRS; 1019 for (i = 0; i < imax; i++) { 1020 tap_stats->q_ipackets[i] = pmd->rxq[i].stats.ipackets; 1021 tap_stats->q_ibytes[i] = pmd->rxq[i].stats.ibytes; 1022 rx_total += tap_stats->q_ipackets[i]; 1023 rx_bytes_total += tap_stats->q_ibytes[i]; 1024 rx_nombuf += pmd->rxq[i].stats.rx_nombuf; 1025 ierrors += pmd->rxq[i].stats.ierrors; 1026 } 1027 1028 /* tx queue statistics */ 1029 imax = (dev->data->nb_tx_queues < RTE_ETHDEV_QUEUE_STAT_CNTRS) ? 1030 dev->data->nb_tx_queues : RTE_ETHDEV_QUEUE_STAT_CNTRS; 1031 1032 for (i = 0; i < imax; i++) { 1033 tap_stats->q_opackets[i] = pmd->txq[i].stats.opackets; 1034 tap_stats->q_obytes[i] = pmd->txq[i].stats.obytes; 1035 tx_total += tap_stats->q_opackets[i]; 1036 tx_err_total += pmd->txq[i].stats.errs; 1037 tx_bytes_total += tap_stats->q_obytes[i]; 1038 } 1039 1040 tap_stats->ipackets = rx_total; 1041 tap_stats->ibytes = rx_bytes_total; 1042 tap_stats->ierrors = ierrors; 1043 tap_stats->rx_nombuf = rx_nombuf; 1044 tap_stats->opackets = tx_total; 1045 tap_stats->oerrors = tx_err_total; 1046 tap_stats->obytes = tx_bytes_total; 1047 return 0; 1048 } 1049 1050 static int 1051 tap_stats_reset(struct rte_eth_dev *dev) 1052 { 1053 int i; 1054 struct pmd_internals *pmd = dev->data->dev_private; 1055 1056 for (i = 0; i < RTE_PMD_TAP_MAX_QUEUES; i++) { 1057 pmd->rxq[i].stats.ipackets = 0; 1058 pmd->rxq[i].stats.ibytes = 0; 1059 pmd->rxq[i].stats.ierrors = 0; 1060 pmd->rxq[i].stats.rx_nombuf = 0; 1061 1062 pmd->txq[i].stats.opackets = 0; 1063 pmd->txq[i].stats.errs = 0; 1064 pmd->txq[i].stats.obytes = 0; 1065 } 1066 1067 return 0; 1068 } 1069 1070 static void 1071 tap_dev_close(struct rte_eth_dev *dev) 1072 { 1073 int i; 1074 struct pmd_internals *internals = dev->data->dev_private; 1075 struct pmd_process_private *process_private = dev->process_private; 1076 struct rx_queue *rxq; 1077 1078 tap_link_set_down(dev); 1079 if (internals->nlsk_fd != -1) { 1080 tap_flow_flush(dev, NULL); 1081 tap_flow_implicit_flush(internals, NULL); 1082 tap_nl_final(internals->nlsk_fd); 1083 internals->nlsk_fd = -1; 1084 } 1085 1086 for (i = 0; i < RTE_PMD_TAP_MAX_QUEUES; i++) { 1087 if (process_private->rxq_fds[i] != -1) { 1088 rxq = &internals->rxq[i]; 1089 close(process_private->rxq_fds[i]); 1090 process_private->rxq_fds[i] = -1; 1091 tap_rxq_pool_free(rxq->pool); 1092 rte_free(rxq->iovecs); 1093 rxq->pool = NULL; 1094 rxq->iovecs = NULL; 1095 } 1096 if (process_private->txq_fds[i] != -1) { 1097 close(process_private->txq_fds[i]); 1098 process_private->txq_fds[i] = -1; 1099 } 1100 } 1101 1102 if (internals->remote_if_index) { 1103 /* Restore initial remote state */ 1104 ioctl(internals->ioctl_sock, SIOCSIFFLAGS, 1105 &internals->remote_initial_flags); 1106 } 1107 1108 rte_mempool_free(internals->gso_ctx_mp); 1109 internals->gso_ctx_mp = NULL; 1110 1111 if (internals->ka_fd != -1) { 1112 close(internals->ka_fd); 1113 internals->ka_fd = -1; 1114 } 1115 /* 1116 * Since TUN device has no more opened file descriptors 1117 * it will be removed from kernel 1118 */ 1119 } 1120 1121 static void 1122 tap_rx_queue_release(void *queue) 1123 { 1124 struct rx_queue *rxq = queue; 1125 struct pmd_process_private *process_private; 1126 1127 if (!rxq) 1128 return; 1129 process_private = rte_eth_devices[rxq->in_port].process_private; 1130 if (process_private->rxq_fds[rxq->queue_id] != -1) { 1131 close(process_private->rxq_fds[rxq->queue_id]); 1132 process_private->rxq_fds[rxq->queue_id] = -1; 1133 tap_rxq_pool_free(rxq->pool); 1134 rte_free(rxq->iovecs); 1135 rxq->pool = NULL; 1136 rxq->iovecs = NULL; 1137 } 1138 } 1139 1140 static void 1141 tap_tx_queue_release(void *queue) 1142 { 1143 struct tx_queue *txq = queue; 1144 struct pmd_process_private *process_private; 1145 1146 if (!txq) 1147 return; 1148 process_private = rte_eth_devices[txq->out_port].process_private; 1149 1150 if (process_private->txq_fds[txq->queue_id] != -1) { 1151 close(process_private->txq_fds[txq->queue_id]); 1152 process_private->txq_fds[txq->queue_id] = -1; 1153 } 1154 } 1155 1156 static int 1157 tap_link_update(struct rte_eth_dev *dev, int wait_to_complete __rte_unused) 1158 { 1159 struct rte_eth_link *dev_link = &dev->data->dev_link; 1160 struct pmd_internals *pmd = dev->data->dev_private; 1161 struct ifreq ifr = { .ifr_flags = 0 }; 1162 1163 if (pmd->remote_if_index) { 1164 tap_ioctl(pmd, SIOCGIFFLAGS, &ifr, 0, REMOTE_ONLY); 1165 if (!(ifr.ifr_flags & IFF_UP) || 1166 !(ifr.ifr_flags & IFF_RUNNING)) { 1167 dev_link->link_status = ETH_LINK_DOWN; 1168 return 0; 1169 } 1170 } 1171 tap_ioctl(pmd, SIOCGIFFLAGS, &ifr, 0, LOCAL_ONLY); 1172 dev_link->link_status = 1173 ((ifr.ifr_flags & IFF_UP) && (ifr.ifr_flags & IFF_RUNNING) ? 1174 ETH_LINK_UP : 1175 ETH_LINK_DOWN); 1176 return 0; 1177 } 1178 1179 static int 1180 tap_promisc_enable(struct rte_eth_dev *dev) 1181 { 1182 struct pmd_internals *pmd = dev->data->dev_private; 1183 struct ifreq ifr = { .ifr_flags = IFF_PROMISC }; 1184 int ret; 1185 1186 ret = tap_ioctl(pmd, SIOCSIFFLAGS, &ifr, 1, LOCAL_AND_REMOTE); 1187 if (ret != 0) 1188 return ret; 1189 1190 if (pmd->remote_if_index && !pmd->flow_isolate) { 1191 dev->data->promiscuous = 1; 1192 ret = tap_flow_implicit_create(pmd, TAP_REMOTE_PROMISC); 1193 if (ret != 0) { 1194 /* Rollback promisc flag */ 1195 tap_ioctl(pmd, SIOCSIFFLAGS, &ifr, 0, LOCAL_AND_REMOTE); 1196 /* 1197 * rte_eth_dev_promiscuous_enable() rollback 1198 * dev->data->promiscuous in the case of failure. 1199 */ 1200 return ret; 1201 } 1202 } 1203 1204 return 0; 1205 } 1206 1207 static int 1208 tap_promisc_disable(struct rte_eth_dev *dev) 1209 { 1210 struct pmd_internals *pmd = dev->data->dev_private; 1211 struct ifreq ifr = { .ifr_flags = IFF_PROMISC }; 1212 int ret; 1213 1214 ret = tap_ioctl(pmd, SIOCSIFFLAGS, &ifr, 0, LOCAL_AND_REMOTE); 1215 if (ret != 0) 1216 return ret; 1217 1218 if (pmd->remote_if_index && !pmd->flow_isolate) { 1219 dev->data->promiscuous = 0; 1220 ret = tap_flow_implicit_destroy(pmd, TAP_REMOTE_PROMISC); 1221 if (ret != 0) { 1222 /* Rollback promisc flag */ 1223 tap_ioctl(pmd, SIOCSIFFLAGS, &ifr, 1, LOCAL_AND_REMOTE); 1224 /* 1225 * rte_eth_dev_promiscuous_disable() rollback 1226 * dev->data->promiscuous in the case of failure. 1227 */ 1228 return ret; 1229 } 1230 } 1231 1232 return 0; 1233 } 1234 1235 static int 1236 tap_allmulti_enable(struct rte_eth_dev *dev) 1237 { 1238 struct pmd_internals *pmd = dev->data->dev_private; 1239 struct ifreq ifr = { .ifr_flags = IFF_ALLMULTI }; 1240 int ret; 1241 1242 ret = tap_ioctl(pmd, SIOCSIFFLAGS, &ifr, 1, LOCAL_AND_REMOTE); 1243 if (ret != 0) 1244 return ret; 1245 1246 if (pmd->remote_if_index && !pmd->flow_isolate) { 1247 dev->data->all_multicast = 1; 1248 ret = tap_flow_implicit_create(pmd, TAP_REMOTE_ALLMULTI); 1249 if (ret != 0) { 1250 /* Rollback allmulti flag */ 1251 tap_ioctl(pmd, SIOCSIFFLAGS, &ifr, 0, LOCAL_AND_REMOTE); 1252 /* 1253 * rte_eth_dev_allmulticast_enable() rollback 1254 * dev->data->all_multicast in the case of failure. 1255 */ 1256 return ret; 1257 } 1258 } 1259 1260 return 0; 1261 } 1262 1263 static int 1264 tap_allmulti_disable(struct rte_eth_dev *dev) 1265 { 1266 struct pmd_internals *pmd = dev->data->dev_private; 1267 struct ifreq ifr = { .ifr_flags = IFF_ALLMULTI }; 1268 int ret; 1269 1270 ret = tap_ioctl(pmd, SIOCSIFFLAGS, &ifr, 0, LOCAL_AND_REMOTE); 1271 if (ret != 0) 1272 return ret; 1273 1274 if (pmd->remote_if_index && !pmd->flow_isolate) { 1275 dev->data->all_multicast = 0; 1276 ret = tap_flow_implicit_destroy(pmd, TAP_REMOTE_ALLMULTI); 1277 if (ret != 0) { 1278 /* Rollback allmulti flag */ 1279 tap_ioctl(pmd, SIOCSIFFLAGS, &ifr, 1, LOCAL_AND_REMOTE); 1280 /* 1281 * rte_eth_dev_allmulticast_disable() rollback 1282 * dev->data->all_multicast in the case of failure. 1283 */ 1284 return ret; 1285 } 1286 } 1287 1288 return 0; 1289 } 1290 1291 static int 1292 tap_mac_set(struct rte_eth_dev *dev, struct rte_ether_addr *mac_addr) 1293 { 1294 struct pmd_internals *pmd = dev->data->dev_private; 1295 enum ioctl_mode mode = LOCAL_ONLY; 1296 struct ifreq ifr; 1297 int ret; 1298 1299 if (pmd->type == ETH_TUNTAP_TYPE_TUN) { 1300 TAP_LOG(ERR, "%s: can't MAC address for TUN", 1301 dev->device->name); 1302 return -ENOTSUP; 1303 } 1304 1305 if (rte_is_zero_ether_addr(mac_addr)) { 1306 TAP_LOG(ERR, "%s: can't set an empty MAC address", 1307 dev->device->name); 1308 return -EINVAL; 1309 } 1310 /* Check the actual current MAC address on the tap netdevice */ 1311 ret = tap_ioctl(pmd, SIOCGIFHWADDR, &ifr, 0, LOCAL_ONLY); 1312 if (ret < 0) 1313 return ret; 1314 if (rte_is_same_ether_addr( 1315 (struct rte_ether_addr *)&ifr.ifr_hwaddr.sa_data, 1316 mac_addr)) 1317 return 0; 1318 /* Check the current MAC address on the remote */ 1319 ret = tap_ioctl(pmd, SIOCGIFHWADDR, &ifr, 0, REMOTE_ONLY); 1320 if (ret < 0) 1321 return ret; 1322 if (!rte_is_same_ether_addr( 1323 (struct rte_ether_addr *)&ifr.ifr_hwaddr.sa_data, 1324 mac_addr)) 1325 mode = LOCAL_AND_REMOTE; 1326 ifr.ifr_hwaddr.sa_family = AF_LOCAL; 1327 rte_memcpy(ifr.ifr_hwaddr.sa_data, mac_addr, RTE_ETHER_ADDR_LEN); 1328 ret = tap_ioctl(pmd, SIOCSIFHWADDR, &ifr, 1, mode); 1329 if (ret < 0) 1330 return ret; 1331 rte_memcpy(&pmd->eth_addr, mac_addr, RTE_ETHER_ADDR_LEN); 1332 if (pmd->remote_if_index && !pmd->flow_isolate) { 1333 /* Replace MAC redirection rule after a MAC change */ 1334 ret = tap_flow_implicit_destroy(pmd, TAP_REMOTE_LOCAL_MAC); 1335 if (ret < 0) { 1336 TAP_LOG(ERR, 1337 "%s: Couldn't delete MAC redirection rule", 1338 dev->device->name); 1339 return ret; 1340 } 1341 ret = tap_flow_implicit_create(pmd, TAP_REMOTE_LOCAL_MAC); 1342 if (ret < 0) { 1343 TAP_LOG(ERR, 1344 "%s: Couldn't add MAC redirection rule", 1345 dev->device->name); 1346 return ret; 1347 } 1348 } 1349 1350 return 0; 1351 } 1352 1353 static int 1354 tap_gso_ctx_setup(struct rte_gso_ctx *gso_ctx, struct rte_eth_dev *dev) 1355 { 1356 uint32_t gso_types; 1357 char pool_name[64]; 1358 struct pmd_internals *pmd = dev->data->dev_private; 1359 int ret; 1360 1361 /* initialize GSO context */ 1362 gso_types = DEV_TX_OFFLOAD_TCP_TSO; 1363 if (!pmd->gso_ctx_mp) { 1364 /* 1365 * Create private mbuf pool with TAP_GSO_MBUF_SEG_SIZE 1366 * bytes size per mbuf use this pool for both direct and 1367 * indirect mbufs 1368 */ 1369 ret = snprintf(pool_name, sizeof(pool_name), "mp_%s", 1370 dev->device->name); 1371 if (ret < 0 || ret >= (int)sizeof(pool_name)) { 1372 TAP_LOG(ERR, 1373 "%s: failed to create mbuf pool name for device %s," 1374 "device name too long or output error, ret: %d\n", 1375 pmd->name, dev->device->name, ret); 1376 return -ENAMETOOLONG; 1377 } 1378 pmd->gso_ctx_mp = rte_pktmbuf_pool_create(pool_name, 1379 TAP_GSO_MBUFS_NUM, TAP_GSO_MBUF_CACHE_SIZE, 0, 1380 RTE_PKTMBUF_HEADROOM + TAP_GSO_MBUF_SEG_SIZE, 1381 SOCKET_ID_ANY); 1382 if (!pmd->gso_ctx_mp) { 1383 TAP_LOG(ERR, 1384 "%s: failed to create mbuf pool for device %s\n", 1385 pmd->name, dev->device->name); 1386 return -1; 1387 } 1388 } 1389 1390 gso_ctx->direct_pool = pmd->gso_ctx_mp; 1391 gso_ctx->indirect_pool = pmd->gso_ctx_mp; 1392 gso_ctx->gso_types = gso_types; 1393 gso_ctx->gso_size = 0; /* gso_size is set in tx_burst() per packet */ 1394 gso_ctx->flag = 0; 1395 1396 return 0; 1397 } 1398 1399 static int 1400 tap_setup_queue(struct rte_eth_dev *dev, 1401 struct pmd_internals *internals, 1402 uint16_t qid, 1403 int is_rx) 1404 { 1405 int ret; 1406 int *fd; 1407 int *other_fd; 1408 const char *dir; 1409 struct pmd_internals *pmd = dev->data->dev_private; 1410 struct pmd_process_private *process_private = dev->process_private; 1411 struct rx_queue *rx = &internals->rxq[qid]; 1412 struct tx_queue *tx = &internals->txq[qid]; 1413 struct rte_gso_ctx *gso_ctx; 1414 1415 if (is_rx) { 1416 fd = &process_private->rxq_fds[qid]; 1417 other_fd = &process_private->txq_fds[qid]; 1418 dir = "rx"; 1419 gso_ctx = NULL; 1420 } else { 1421 fd = &process_private->txq_fds[qid]; 1422 other_fd = &process_private->rxq_fds[qid]; 1423 dir = "tx"; 1424 gso_ctx = &tx->gso_ctx; 1425 } 1426 if (*fd != -1) { 1427 /* fd for this queue already exists */ 1428 TAP_LOG(DEBUG, "%s: fd %d for %s queue qid %d exists", 1429 pmd->name, *fd, dir, qid); 1430 gso_ctx = NULL; 1431 } else if (*other_fd != -1) { 1432 /* Only other_fd exists. dup it */ 1433 *fd = dup(*other_fd); 1434 if (*fd < 0) { 1435 *fd = -1; 1436 TAP_LOG(ERR, "%s: dup() failed.", pmd->name); 1437 return -1; 1438 } 1439 TAP_LOG(DEBUG, "%s: dup fd %d for %s queue qid %d (%d)", 1440 pmd->name, *other_fd, dir, qid, *fd); 1441 } else { 1442 /* Both RX and TX fds do not exist (equal -1). Create fd */ 1443 *fd = tun_alloc(pmd, 0); 1444 if (*fd < 0) { 1445 *fd = -1; /* restore original value */ 1446 TAP_LOG(ERR, "%s: tun_alloc() failed.", pmd->name); 1447 return -1; 1448 } 1449 TAP_LOG(DEBUG, "%s: add %s queue for qid %d fd %d", 1450 pmd->name, dir, qid, *fd); 1451 } 1452 1453 tx->mtu = &dev->data->mtu; 1454 rx->rxmode = &dev->data->dev_conf.rxmode; 1455 if (gso_ctx) { 1456 ret = tap_gso_ctx_setup(gso_ctx, dev); 1457 if (ret) 1458 return -1; 1459 } 1460 1461 tx->type = pmd->type; 1462 1463 return *fd; 1464 } 1465 1466 static int 1467 tap_rx_queue_setup(struct rte_eth_dev *dev, 1468 uint16_t rx_queue_id, 1469 uint16_t nb_rx_desc, 1470 unsigned int socket_id, 1471 const struct rte_eth_rxconf *rx_conf __rte_unused, 1472 struct rte_mempool *mp) 1473 { 1474 struct pmd_internals *internals = dev->data->dev_private; 1475 struct pmd_process_private *process_private = dev->process_private; 1476 struct rx_queue *rxq = &internals->rxq[rx_queue_id]; 1477 struct rte_mbuf **tmp = &rxq->pool; 1478 long iov_max = sysconf(_SC_IOV_MAX); 1479 1480 if (iov_max <= 0) { 1481 TAP_LOG(WARNING, 1482 "_SC_IOV_MAX is not defined. Using %d as default", 1483 TAP_IOV_DEFAULT_MAX); 1484 iov_max = TAP_IOV_DEFAULT_MAX; 1485 } 1486 uint16_t nb_desc = RTE_MIN(nb_rx_desc, iov_max - 1); 1487 struct iovec (*iovecs)[nb_desc + 1]; 1488 int data_off = RTE_PKTMBUF_HEADROOM; 1489 int ret = 0; 1490 int fd; 1491 int i; 1492 1493 if (rx_queue_id >= dev->data->nb_rx_queues || !mp) { 1494 TAP_LOG(WARNING, 1495 "nb_rx_queues %d too small or mempool NULL", 1496 dev->data->nb_rx_queues); 1497 return -1; 1498 } 1499 1500 rxq->mp = mp; 1501 rxq->trigger_seen = 1; /* force initial burst */ 1502 rxq->in_port = dev->data->port_id; 1503 rxq->queue_id = rx_queue_id; 1504 rxq->nb_rx_desc = nb_desc; 1505 iovecs = rte_zmalloc_socket(dev->device->name, sizeof(*iovecs), 0, 1506 socket_id); 1507 if (!iovecs) { 1508 TAP_LOG(WARNING, 1509 "%s: Couldn't allocate %d RX descriptors", 1510 dev->device->name, nb_desc); 1511 return -ENOMEM; 1512 } 1513 rxq->iovecs = iovecs; 1514 1515 dev->data->rx_queues[rx_queue_id] = rxq; 1516 fd = tap_setup_queue(dev, internals, rx_queue_id, 1); 1517 if (fd == -1) { 1518 ret = fd; 1519 goto error; 1520 } 1521 1522 (*rxq->iovecs)[0].iov_len = sizeof(struct tun_pi); 1523 (*rxq->iovecs)[0].iov_base = &rxq->pi; 1524 1525 for (i = 1; i <= nb_desc; i++) { 1526 *tmp = rte_pktmbuf_alloc(rxq->mp); 1527 if (!*tmp) { 1528 TAP_LOG(WARNING, 1529 "%s: couldn't allocate memory for queue %d", 1530 dev->device->name, rx_queue_id); 1531 ret = -ENOMEM; 1532 goto error; 1533 } 1534 (*rxq->iovecs)[i].iov_len = (*tmp)->buf_len - data_off; 1535 (*rxq->iovecs)[i].iov_base = 1536 (char *)(*tmp)->buf_addr + data_off; 1537 data_off = 0; 1538 tmp = &(*tmp)->next; 1539 } 1540 1541 TAP_LOG(DEBUG, " RX TUNTAP device name %s, qid %d on fd %d", 1542 internals->name, rx_queue_id, 1543 process_private->rxq_fds[rx_queue_id]); 1544 1545 return 0; 1546 1547 error: 1548 tap_rxq_pool_free(rxq->pool); 1549 rxq->pool = NULL; 1550 rte_free(rxq->iovecs); 1551 rxq->iovecs = NULL; 1552 return ret; 1553 } 1554 1555 static int 1556 tap_tx_queue_setup(struct rte_eth_dev *dev, 1557 uint16_t tx_queue_id, 1558 uint16_t nb_tx_desc __rte_unused, 1559 unsigned int socket_id __rte_unused, 1560 const struct rte_eth_txconf *tx_conf) 1561 { 1562 struct pmd_internals *internals = dev->data->dev_private; 1563 struct pmd_process_private *process_private = dev->process_private; 1564 struct tx_queue *txq; 1565 int ret; 1566 uint64_t offloads; 1567 1568 if (tx_queue_id >= dev->data->nb_tx_queues) 1569 return -1; 1570 dev->data->tx_queues[tx_queue_id] = &internals->txq[tx_queue_id]; 1571 txq = dev->data->tx_queues[tx_queue_id]; 1572 txq->out_port = dev->data->port_id; 1573 txq->queue_id = tx_queue_id; 1574 1575 offloads = tx_conf->offloads | dev->data->dev_conf.txmode.offloads; 1576 txq->csum = !!(offloads & 1577 (DEV_TX_OFFLOAD_IPV4_CKSUM | 1578 DEV_TX_OFFLOAD_UDP_CKSUM | 1579 DEV_TX_OFFLOAD_TCP_CKSUM)); 1580 1581 ret = tap_setup_queue(dev, internals, tx_queue_id, 0); 1582 if (ret == -1) 1583 return -1; 1584 TAP_LOG(DEBUG, 1585 " TX TUNTAP device name %s, qid %d on fd %d csum %s", 1586 internals->name, tx_queue_id, 1587 process_private->txq_fds[tx_queue_id], 1588 txq->csum ? "on" : "off"); 1589 1590 return 0; 1591 } 1592 1593 static int 1594 tap_mtu_set(struct rte_eth_dev *dev, uint16_t mtu) 1595 { 1596 struct pmd_internals *pmd = dev->data->dev_private; 1597 struct ifreq ifr = { .ifr_mtu = mtu }; 1598 int err = 0; 1599 1600 err = tap_ioctl(pmd, SIOCSIFMTU, &ifr, 1, LOCAL_AND_REMOTE); 1601 if (!err) 1602 dev->data->mtu = mtu; 1603 1604 return err; 1605 } 1606 1607 static int 1608 tap_set_mc_addr_list(struct rte_eth_dev *dev __rte_unused, 1609 struct rte_ether_addr *mc_addr_set __rte_unused, 1610 uint32_t nb_mc_addr __rte_unused) 1611 { 1612 /* 1613 * Nothing to do actually: the tap has no filtering whatsoever, every 1614 * packet is received. 1615 */ 1616 return 0; 1617 } 1618 1619 static int 1620 tap_nl_msg_handler(struct nlmsghdr *nh, void *arg) 1621 { 1622 struct rte_eth_dev *dev = arg; 1623 struct pmd_internals *pmd = dev->data->dev_private; 1624 struct ifinfomsg *info = NLMSG_DATA(nh); 1625 1626 if (nh->nlmsg_type != RTM_NEWLINK || 1627 (info->ifi_index != pmd->if_index && 1628 info->ifi_index != pmd->remote_if_index)) 1629 return 0; 1630 return tap_link_update(dev, 0); 1631 } 1632 1633 static void 1634 tap_dev_intr_handler(void *cb_arg) 1635 { 1636 struct rte_eth_dev *dev = cb_arg; 1637 struct pmd_internals *pmd = dev->data->dev_private; 1638 1639 tap_nl_recv(pmd->intr_handle.fd, tap_nl_msg_handler, dev); 1640 } 1641 1642 static int 1643 tap_lsc_intr_handle_set(struct rte_eth_dev *dev, int set) 1644 { 1645 struct pmd_internals *pmd = dev->data->dev_private; 1646 int ret; 1647 1648 /* In any case, disable interrupt if the conf is no longer there. */ 1649 if (!dev->data->dev_conf.intr_conf.lsc) { 1650 if (pmd->intr_handle.fd != -1) { 1651 goto clean; 1652 } 1653 return 0; 1654 } 1655 if (set) { 1656 pmd->intr_handle.fd = tap_nl_init(RTMGRP_LINK); 1657 if (unlikely(pmd->intr_handle.fd == -1)) 1658 return -EBADF; 1659 return rte_intr_callback_register( 1660 &pmd->intr_handle, tap_dev_intr_handler, dev); 1661 } 1662 1663 clean: 1664 do { 1665 ret = rte_intr_callback_unregister(&pmd->intr_handle, 1666 tap_dev_intr_handler, dev); 1667 if (ret >= 0) { 1668 break; 1669 } else if (ret == -EAGAIN) { 1670 rte_delay_ms(100); 1671 } else { 1672 TAP_LOG(ERR, "intr callback unregister failed: %d", 1673 ret); 1674 break; 1675 } 1676 } while (true); 1677 1678 tap_nl_final(pmd->intr_handle.fd); 1679 pmd->intr_handle.fd = -1; 1680 1681 return 0; 1682 } 1683 1684 static int 1685 tap_intr_handle_set(struct rte_eth_dev *dev, int set) 1686 { 1687 int err; 1688 1689 err = tap_lsc_intr_handle_set(dev, set); 1690 if (err < 0) { 1691 if (!set) 1692 tap_rx_intr_vec_set(dev, 0); 1693 return err; 1694 } 1695 err = tap_rx_intr_vec_set(dev, set); 1696 if (err && set) 1697 tap_lsc_intr_handle_set(dev, 0); 1698 return err; 1699 } 1700 1701 static const uint32_t* 1702 tap_dev_supported_ptypes_get(struct rte_eth_dev *dev __rte_unused) 1703 { 1704 static const uint32_t ptypes[] = { 1705 RTE_PTYPE_INNER_L2_ETHER, 1706 RTE_PTYPE_INNER_L2_ETHER_VLAN, 1707 RTE_PTYPE_INNER_L2_ETHER_QINQ, 1708 RTE_PTYPE_INNER_L3_IPV4, 1709 RTE_PTYPE_INNER_L3_IPV4_EXT, 1710 RTE_PTYPE_INNER_L3_IPV6, 1711 RTE_PTYPE_INNER_L3_IPV6_EXT, 1712 RTE_PTYPE_INNER_L4_FRAG, 1713 RTE_PTYPE_INNER_L4_UDP, 1714 RTE_PTYPE_INNER_L4_TCP, 1715 RTE_PTYPE_INNER_L4_SCTP, 1716 RTE_PTYPE_L2_ETHER, 1717 RTE_PTYPE_L2_ETHER_VLAN, 1718 RTE_PTYPE_L2_ETHER_QINQ, 1719 RTE_PTYPE_L3_IPV4, 1720 RTE_PTYPE_L3_IPV4_EXT, 1721 RTE_PTYPE_L3_IPV6_EXT, 1722 RTE_PTYPE_L3_IPV6, 1723 RTE_PTYPE_L4_FRAG, 1724 RTE_PTYPE_L4_UDP, 1725 RTE_PTYPE_L4_TCP, 1726 RTE_PTYPE_L4_SCTP, 1727 }; 1728 1729 return ptypes; 1730 } 1731 1732 static int 1733 tap_flow_ctrl_get(struct rte_eth_dev *dev __rte_unused, 1734 struct rte_eth_fc_conf *fc_conf) 1735 { 1736 fc_conf->mode = RTE_FC_NONE; 1737 return 0; 1738 } 1739 1740 static int 1741 tap_flow_ctrl_set(struct rte_eth_dev *dev __rte_unused, 1742 struct rte_eth_fc_conf *fc_conf) 1743 { 1744 if (fc_conf->mode != RTE_FC_NONE) 1745 return -ENOTSUP; 1746 return 0; 1747 } 1748 1749 /** 1750 * DPDK callback to update the RSS hash configuration. 1751 * 1752 * @param dev 1753 * Pointer to Ethernet device structure. 1754 * @param[in] rss_conf 1755 * RSS configuration data. 1756 * 1757 * @return 1758 * 0 on success, a negative errno value otherwise and rte_errno is set. 1759 */ 1760 static int 1761 tap_rss_hash_update(struct rte_eth_dev *dev, 1762 struct rte_eth_rss_conf *rss_conf) 1763 { 1764 if (rss_conf->rss_hf & TAP_RSS_HF_MASK) { 1765 rte_errno = EINVAL; 1766 return -rte_errno; 1767 } 1768 if (rss_conf->rss_key && rss_conf->rss_key_len) { 1769 /* 1770 * Currently TAP RSS key is hard coded 1771 * and cannot be updated 1772 */ 1773 TAP_LOG(ERR, 1774 "port %u RSS key cannot be updated", 1775 dev->data->port_id); 1776 rte_errno = EINVAL; 1777 return -rte_errno; 1778 } 1779 return 0; 1780 } 1781 1782 static int 1783 tap_rx_queue_start(struct rte_eth_dev *dev, uint16_t rx_queue_id) 1784 { 1785 dev->data->rx_queue_state[rx_queue_id] = RTE_ETH_QUEUE_STATE_STARTED; 1786 1787 return 0; 1788 } 1789 1790 static int 1791 tap_tx_queue_start(struct rte_eth_dev *dev, uint16_t tx_queue_id) 1792 { 1793 dev->data->tx_queue_state[tx_queue_id] = RTE_ETH_QUEUE_STATE_STARTED; 1794 1795 return 0; 1796 } 1797 1798 static int 1799 tap_rx_queue_stop(struct rte_eth_dev *dev, uint16_t rx_queue_id) 1800 { 1801 dev->data->rx_queue_state[rx_queue_id] = RTE_ETH_QUEUE_STATE_STOPPED; 1802 1803 return 0; 1804 } 1805 1806 static int 1807 tap_tx_queue_stop(struct rte_eth_dev *dev, uint16_t tx_queue_id) 1808 { 1809 dev->data->tx_queue_state[tx_queue_id] = RTE_ETH_QUEUE_STATE_STOPPED; 1810 1811 return 0; 1812 } 1813 static const struct eth_dev_ops ops = { 1814 .dev_start = tap_dev_start, 1815 .dev_stop = tap_dev_stop, 1816 .dev_close = tap_dev_close, 1817 .dev_configure = tap_dev_configure, 1818 .dev_infos_get = tap_dev_info, 1819 .rx_queue_setup = tap_rx_queue_setup, 1820 .tx_queue_setup = tap_tx_queue_setup, 1821 .rx_queue_start = tap_rx_queue_start, 1822 .tx_queue_start = tap_tx_queue_start, 1823 .rx_queue_stop = tap_rx_queue_stop, 1824 .tx_queue_stop = tap_tx_queue_stop, 1825 .rx_queue_release = tap_rx_queue_release, 1826 .tx_queue_release = tap_tx_queue_release, 1827 .flow_ctrl_get = tap_flow_ctrl_get, 1828 .flow_ctrl_set = tap_flow_ctrl_set, 1829 .link_update = tap_link_update, 1830 .dev_set_link_up = tap_link_set_up, 1831 .dev_set_link_down = tap_link_set_down, 1832 .promiscuous_enable = tap_promisc_enable, 1833 .promiscuous_disable = tap_promisc_disable, 1834 .allmulticast_enable = tap_allmulti_enable, 1835 .allmulticast_disable = tap_allmulti_disable, 1836 .mac_addr_set = tap_mac_set, 1837 .mtu_set = tap_mtu_set, 1838 .set_mc_addr_list = tap_set_mc_addr_list, 1839 .stats_get = tap_stats_get, 1840 .stats_reset = tap_stats_reset, 1841 .dev_supported_ptypes_get = tap_dev_supported_ptypes_get, 1842 .rss_hash_update = tap_rss_hash_update, 1843 .filter_ctrl = tap_dev_filter_ctrl, 1844 }; 1845 1846 static const char *tuntap_types[ETH_TUNTAP_TYPE_MAX] = { 1847 "UNKNOWN", "TUN", "TAP" 1848 }; 1849 1850 static int 1851 eth_dev_tap_create(struct rte_vdev_device *vdev, const char *tap_name, 1852 char *remote_iface, struct rte_ether_addr *mac_addr, 1853 enum rte_tuntap_type type) 1854 { 1855 int numa_node = rte_socket_id(); 1856 struct rte_eth_dev *dev; 1857 struct pmd_internals *pmd; 1858 struct pmd_process_private *process_private; 1859 const char *tuntap_name = tuntap_types[type]; 1860 struct rte_eth_dev_data *data; 1861 struct ifreq ifr; 1862 int i; 1863 1864 TAP_LOG(DEBUG, "%s device on numa %u", tuntap_name, rte_socket_id()); 1865 1866 dev = rte_eth_vdev_allocate(vdev, sizeof(*pmd)); 1867 if (!dev) { 1868 TAP_LOG(ERR, "%s Unable to allocate device struct", 1869 tuntap_name); 1870 goto error_exit_nodev; 1871 } 1872 1873 process_private = (struct pmd_process_private *) 1874 rte_zmalloc_socket(tap_name, sizeof(struct pmd_process_private), 1875 RTE_CACHE_LINE_SIZE, dev->device->numa_node); 1876 1877 if (process_private == NULL) { 1878 TAP_LOG(ERR, "Failed to alloc memory for process private"); 1879 return -1; 1880 } 1881 pmd = dev->data->dev_private; 1882 dev->process_private = process_private; 1883 pmd->dev = dev; 1884 strlcpy(pmd->name, tap_name, sizeof(pmd->name)); 1885 pmd->type = type; 1886 pmd->ka_fd = -1; 1887 pmd->nlsk_fd = -1; 1888 pmd->gso_ctx_mp = NULL; 1889 1890 pmd->ioctl_sock = socket(AF_INET, SOCK_DGRAM, 0); 1891 if (pmd->ioctl_sock == -1) { 1892 TAP_LOG(ERR, 1893 "%s Unable to get a socket for management: %s", 1894 tuntap_name, strerror(errno)); 1895 goto error_exit; 1896 } 1897 1898 /* Setup some default values */ 1899 data = dev->data; 1900 data->dev_private = pmd; 1901 data->dev_flags = RTE_ETH_DEV_INTR_LSC; 1902 data->numa_node = numa_node; 1903 1904 data->dev_link = pmd_link; 1905 data->mac_addrs = &pmd->eth_addr; 1906 /* Set the number of RX and TX queues */ 1907 data->nb_rx_queues = 0; 1908 data->nb_tx_queues = 0; 1909 1910 dev->dev_ops = &ops; 1911 dev->rx_pkt_burst = pmd_rx_burst; 1912 dev->tx_pkt_burst = pmd_tx_burst; 1913 1914 pmd->intr_handle.type = RTE_INTR_HANDLE_EXT; 1915 pmd->intr_handle.fd = -1; 1916 dev->intr_handle = &pmd->intr_handle; 1917 1918 /* Presetup the fds to -1 as being not valid */ 1919 for (i = 0; i < RTE_PMD_TAP_MAX_QUEUES; i++) { 1920 process_private->rxq_fds[i] = -1; 1921 process_private->txq_fds[i] = -1; 1922 } 1923 1924 if (pmd->type == ETH_TUNTAP_TYPE_TAP) { 1925 if (rte_is_zero_ether_addr(mac_addr)) 1926 rte_eth_random_addr((uint8_t *)&pmd->eth_addr); 1927 else 1928 rte_memcpy(&pmd->eth_addr, mac_addr, sizeof(*mac_addr)); 1929 } 1930 1931 /* 1932 * Allocate a TUN device keep-alive file descriptor that will only be 1933 * closed when the TUN device itself is closed or removed. 1934 * This keep-alive file descriptor will guarantee that the TUN device 1935 * exists even when all of its queues are closed 1936 */ 1937 pmd->ka_fd = tun_alloc(pmd, 1); 1938 if (pmd->ka_fd == -1) { 1939 TAP_LOG(ERR, "Unable to create %s interface", tuntap_name); 1940 goto error_exit; 1941 } 1942 TAP_LOG(DEBUG, "allocated %s", pmd->name); 1943 1944 ifr.ifr_mtu = dev->data->mtu; 1945 if (tap_ioctl(pmd, SIOCSIFMTU, &ifr, 1, LOCAL_AND_REMOTE) < 0) 1946 goto error_exit; 1947 1948 if (pmd->type == ETH_TUNTAP_TYPE_TAP) { 1949 memset(&ifr, 0, sizeof(struct ifreq)); 1950 ifr.ifr_hwaddr.sa_family = AF_LOCAL; 1951 rte_memcpy(ifr.ifr_hwaddr.sa_data, &pmd->eth_addr, 1952 RTE_ETHER_ADDR_LEN); 1953 if (tap_ioctl(pmd, SIOCSIFHWADDR, &ifr, 0, LOCAL_ONLY) < 0) 1954 goto error_exit; 1955 } 1956 1957 /* 1958 * Set up everything related to rte_flow: 1959 * - netlink socket 1960 * - tap / remote if_index 1961 * - mandatory QDISCs 1962 * - rte_flow actual/implicit lists 1963 * - implicit rules 1964 */ 1965 pmd->nlsk_fd = tap_nl_init(0); 1966 if (pmd->nlsk_fd == -1) { 1967 TAP_LOG(WARNING, "%s: failed to create netlink socket.", 1968 pmd->name); 1969 goto disable_rte_flow; 1970 } 1971 pmd->if_index = if_nametoindex(pmd->name); 1972 if (!pmd->if_index) { 1973 TAP_LOG(ERR, "%s: failed to get if_index.", pmd->name); 1974 goto disable_rte_flow; 1975 } 1976 if (qdisc_create_multiq(pmd->nlsk_fd, pmd->if_index) < 0) { 1977 TAP_LOG(ERR, "%s: failed to create multiq qdisc.", 1978 pmd->name); 1979 goto disable_rte_flow; 1980 } 1981 if (qdisc_create_ingress(pmd->nlsk_fd, pmd->if_index) < 0) { 1982 TAP_LOG(ERR, "%s: failed to create ingress qdisc.", 1983 pmd->name); 1984 goto disable_rte_flow; 1985 } 1986 LIST_INIT(&pmd->flows); 1987 1988 if (strlen(remote_iface)) { 1989 pmd->remote_if_index = if_nametoindex(remote_iface); 1990 if (!pmd->remote_if_index) { 1991 TAP_LOG(ERR, "%s: failed to get %s if_index.", 1992 pmd->name, remote_iface); 1993 goto error_remote; 1994 } 1995 strlcpy(pmd->remote_iface, remote_iface, RTE_ETH_NAME_MAX_LEN); 1996 1997 /* Save state of remote device */ 1998 tap_ioctl(pmd, SIOCGIFFLAGS, &pmd->remote_initial_flags, 0, REMOTE_ONLY); 1999 2000 /* Replicate remote MAC address */ 2001 if (tap_ioctl(pmd, SIOCGIFHWADDR, &ifr, 0, REMOTE_ONLY) < 0) { 2002 TAP_LOG(ERR, "%s: failed to get %s MAC address.", 2003 pmd->name, pmd->remote_iface); 2004 goto error_remote; 2005 } 2006 rte_memcpy(&pmd->eth_addr, ifr.ifr_hwaddr.sa_data, 2007 RTE_ETHER_ADDR_LEN); 2008 /* The desired MAC is already in ifreq after SIOCGIFHWADDR. */ 2009 if (tap_ioctl(pmd, SIOCSIFHWADDR, &ifr, 0, LOCAL_ONLY) < 0) { 2010 TAP_LOG(ERR, "%s: failed to get %s MAC address.", 2011 pmd->name, remote_iface); 2012 goto error_remote; 2013 } 2014 2015 /* 2016 * Flush usually returns negative value because it tries to 2017 * delete every QDISC (and on a running device, one QDISC at 2018 * least is needed). Ignore negative return value. 2019 */ 2020 qdisc_flush(pmd->nlsk_fd, pmd->remote_if_index); 2021 if (qdisc_create_ingress(pmd->nlsk_fd, 2022 pmd->remote_if_index) < 0) { 2023 TAP_LOG(ERR, "%s: failed to create ingress qdisc.", 2024 pmd->remote_iface); 2025 goto error_remote; 2026 } 2027 LIST_INIT(&pmd->implicit_flows); 2028 if (tap_flow_implicit_create(pmd, TAP_REMOTE_TX) < 0 || 2029 tap_flow_implicit_create(pmd, TAP_REMOTE_LOCAL_MAC) < 0 || 2030 tap_flow_implicit_create(pmd, TAP_REMOTE_BROADCAST) < 0 || 2031 tap_flow_implicit_create(pmd, TAP_REMOTE_BROADCASTV6) < 0) { 2032 TAP_LOG(ERR, 2033 "%s: failed to create implicit rules.", 2034 pmd->name); 2035 goto error_remote; 2036 } 2037 } 2038 2039 rte_eth_dev_probing_finish(dev); 2040 return 0; 2041 2042 disable_rte_flow: 2043 TAP_LOG(ERR, " Disabling rte flow support: %s(%d)", 2044 strerror(errno), errno); 2045 if (strlen(remote_iface)) { 2046 TAP_LOG(ERR, "Remote feature requires flow support."); 2047 goto error_exit; 2048 } 2049 rte_eth_dev_probing_finish(dev); 2050 return 0; 2051 2052 error_remote: 2053 TAP_LOG(ERR, " Can't set up remote feature: %s(%d)", 2054 strerror(errno), errno); 2055 tap_flow_implicit_flush(pmd, NULL); 2056 2057 error_exit: 2058 if (pmd->nlsk_fd != -1) 2059 close(pmd->nlsk_fd); 2060 if (pmd->ka_fd != -1) 2061 close(pmd->ka_fd); 2062 if (pmd->ioctl_sock != -1) 2063 close(pmd->ioctl_sock); 2064 /* mac_addrs must not be freed alone because part of dev_private */ 2065 dev->data->mac_addrs = NULL; 2066 rte_eth_dev_release_port(dev); 2067 2068 error_exit_nodev: 2069 TAP_LOG(ERR, "%s Unable to initialize %s", 2070 tuntap_name, rte_vdev_device_name(vdev)); 2071 2072 return -EINVAL; 2073 } 2074 2075 /* make sure name is a possible Linux network device name */ 2076 static bool 2077 is_valid_iface(const char *name) 2078 { 2079 if (*name == '\0') 2080 return false; 2081 2082 if (strnlen(name, IFNAMSIZ) == IFNAMSIZ) 2083 return false; 2084 2085 while (*name) { 2086 if (*name == '/' || *name == ':' || isspace(*name)) 2087 return false; 2088 name++; 2089 } 2090 return true; 2091 } 2092 2093 static int 2094 set_interface_name(const char *key __rte_unused, 2095 const char *value, 2096 void *extra_args) 2097 { 2098 char *name = (char *)extra_args; 2099 2100 if (value) { 2101 if (!is_valid_iface(value)) { 2102 TAP_LOG(ERR, "TAP invalid remote interface name (%s)", 2103 value); 2104 return -1; 2105 } 2106 strlcpy(name, value, RTE_ETH_NAME_MAX_LEN); 2107 } else { 2108 /* use tap%d which causes kernel to choose next available */ 2109 strlcpy(name, DEFAULT_TAP_NAME "%d", RTE_ETH_NAME_MAX_LEN); 2110 } 2111 return 0; 2112 } 2113 2114 static int 2115 set_remote_iface(const char *key __rte_unused, 2116 const char *value, 2117 void *extra_args) 2118 { 2119 char *name = (char *)extra_args; 2120 2121 if (value) { 2122 if (!is_valid_iface(value)) { 2123 TAP_LOG(ERR, "TAP invalid remote interface name (%s)", 2124 value); 2125 return -1; 2126 } 2127 strlcpy(name, value, RTE_ETH_NAME_MAX_LEN); 2128 } 2129 2130 return 0; 2131 } 2132 2133 static int parse_user_mac(struct rte_ether_addr *user_mac, 2134 const char *value) 2135 { 2136 unsigned int index = 0; 2137 char mac_temp[strlen(ETH_TAP_USR_MAC_FMT) + 1], *mac_byte = NULL; 2138 2139 if (user_mac == NULL || value == NULL) 2140 return 0; 2141 2142 strlcpy(mac_temp, value, sizeof(mac_temp)); 2143 mac_byte = strtok(mac_temp, ":"); 2144 2145 while ((mac_byte != NULL) && 2146 (strlen(mac_byte) <= 2) && 2147 (strlen(mac_byte) == strspn(mac_byte, 2148 ETH_TAP_CMP_MAC_FMT))) { 2149 user_mac->addr_bytes[index++] = strtoul(mac_byte, NULL, 16); 2150 mac_byte = strtok(NULL, ":"); 2151 } 2152 2153 return index; 2154 } 2155 2156 static int 2157 set_mac_type(const char *key __rte_unused, 2158 const char *value, 2159 void *extra_args) 2160 { 2161 struct rte_ether_addr *user_mac = extra_args; 2162 2163 if (!value) 2164 return 0; 2165 2166 if (!strncasecmp(ETH_TAP_MAC_FIXED, value, strlen(ETH_TAP_MAC_FIXED))) { 2167 static int iface_idx; 2168 2169 /* fixed mac = 00:64:74:61:70:<iface_idx> */ 2170 memcpy((char *)user_mac->addr_bytes, "\0dtap", 2171 RTE_ETHER_ADDR_LEN); 2172 user_mac->addr_bytes[RTE_ETHER_ADDR_LEN - 1] = 2173 iface_idx++ + '0'; 2174 goto success; 2175 } 2176 2177 if (parse_user_mac(user_mac, value) != 6) 2178 goto error; 2179 success: 2180 TAP_LOG(DEBUG, "TAP user MAC param (%s)", value); 2181 return 0; 2182 2183 error: 2184 TAP_LOG(ERR, "TAP user MAC (%s) is not in format (%s|%s)", 2185 value, ETH_TAP_MAC_FIXED, ETH_TAP_USR_MAC_FMT); 2186 return -1; 2187 } 2188 2189 /* 2190 * Open a TUN interface device. TUN PMD 2191 * 1) sets tap_type as false 2192 * 2) intakes iface as argument. 2193 * 3) as interface is virtual set speed to 10G 2194 */ 2195 static int 2196 rte_pmd_tun_probe(struct rte_vdev_device *dev) 2197 { 2198 const char *name, *params; 2199 int ret; 2200 struct rte_kvargs *kvlist = NULL; 2201 char tun_name[RTE_ETH_NAME_MAX_LEN]; 2202 char remote_iface[RTE_ETH_NAME_MAX_LEN]; 2203 struct rte_eth_dev *eth_dev; 2204 2205 name = rte_vdev_device_name(dev); 2206 params = rte_vdev_device_args(dev); 2207 memset(remote_iface, 0, RTE_ETH_NAME_MAX_LEN); 2208 2209 if (rte_eal_process_type() == RTE_PROC_SECONDARY && 2210 strlen(params) == 0) { 2211 eth_dev = rte_eth_dev_attach_secondary(name); 2212 if (!eth_dev) { 2213 TAP_LOG(ERR, "Failed to probe %s", name); 2214 return -1; 2215 } 2216 eth_dev->dev_ops = &ops; 2217 eth_dev->device = &dev->device; 2218 rte_eth_dev_probing_finish(eth_dev); 2219 return 0; 2220 } 2221 2222 /* use tun%d which causes kernel to choose next available */ 2223 strlcpy(tun_name, DEFAULT_TUN_NAME "%d", RTE_ETH_NAME_MAX_LEN); 2224 2225 if (params && (params[0] != '\0')) { 2226 TAP_LOG(DEBUG, "parameters (%s)", params); 2227 2228 kvlist = rte_kvargs_parse(params, valid_arguments); 2229 if (kvlist) { 2230 if (rte_kvargs_count(kvlist, ETH_TAP_IFACE_ARG) == 1) { 2231 ret = rte_kvargs_process(kvlist, 2232 ETH_TAP_IFACE_ARG, 2233 &set_interface_name, 2234 tun_name); 2235 2236 if (ret == -1) 2237 goto leave; 2238 } 2239 } 2240 } 2241 pmd_link.link_speed = ETH_SPEED_NUM_10G; 2242 2243 TAP_LOG(DEBUG, "Initializing pmd_tun for %s", name); 2244 2245 ret = eth_dev_tap_create(dev, tun_name, remote_iface, 0, 2246 ETH_TUNTAP_TYPE_TUN); 2247 2248 leave: 2249 if (ret == -1) { 2250 TAP_LOG(ERR, "Failed to create pmd for %s as %s", 2251 name, tun_name); 2252 } 2253 rte_kvargs_free(kvlist); 2254 2255 return ret; 2256 } 2257 2258 /* Request queue file descriptors from secondary to primary. */ 2259 static int 2260 tap_mp_attach_queues(const char *port_name, struct rte_eth_dev *dev) 2261 { 2262 int ret; 2263 struct timespec timeout = {.tv_sec = 1, .tv_nsec = 0}; 2264 struct rte_mp_msg request, *reply; 2265 struct rte_mp_reply replies; 2266 struct ipc_queues *request_param = (struct ipc_queues *)request.param; 2267 struct ipc_queues *reply_param; 2268 struct pmd_process_private *process_private = dev->process_private; 2269 int queue, fd_iterator; 2270 2271 /* Prepare the request */ 2272 memset(&request, 0, sizeof(request)); 2273 strlcpy(request.name, TAP_MP_KEY, sizeof(request.name)); 2274 strlcpy(request_param->port_name, port_name, 2275 sizeof(request_param->port_name)); 2276 request.len_param = sizeof(*request_param); 2277 /* Send request and receive reply */ 2278 ret = rte_mp_request_sync(&request, &replies, &timeout); 2279 if (ret < 0 || replies.nb_received != 1) { 2280 TAP_LOG(ERR, "Failed to request queues from primary: %d", 2281 rte_errno); 2282 return -1; 2283 } 2284 reply = &replies.msgs[0]; 2285 reply_param = (struct ipc_queues *)reply->param; 2286 TAP_LOG(DEBUG, "Received IPC reply for %s", reply_param->port_name); 2287 2288 /* Attach the queues from received file descriptors */ 2289 if (reply_param->rxq_count + reply_param->txq_count != reply->num_fds) { 2290 TAP_LOG(ERR, "Unexpected number of fds received"); 2291 return -1; 2292 } 2293 2294 dev->data->nb_rx_queues = reply_param->rxq_count; 2295 dev->data->nb_tx_queues = reply_param->txq_count; 2296 fd_iterator = 0; 2297 for (queue = 0; queue < reply_param->rxq_count; queue++) 2298 process_private->rxq_fds[queue] = reply->fds[fd_iterator++]; 2299 for (queue = 0; queue < reply_param->txq_count; queue++) 2300 process_private->txq_fds[queue] = reply->fds[fd_iterator++]; 2301 free(reply); 2302 return 0; 2303 } 2304 2305 /* Send the queue file descriptors from the primary process to secondary. */ 2306 static int 2307 tap_mp_sync_queues(const struct rte_mp_msg *request, const void *peer) 2308 { 2309 struct rte_eth_dev *dev; 2310 struct pmd_process_private *process_private; 2311 struct rte_mp_msg reply; 2312 const struct ipc_queues *request_param = 2313 (const struct ipc_queues *)request->param; 2314 struct ipc_queues *reply_param = 2315 (struct ipc_queues *)reply.param; 2316 uint16_t port_id; 2317 int queue; 2318 int ret; 2319 2320 /* Get requested port */ 2321 TAP_LOG(DEBUG, "Received IPC request for %s", request_param->port_name); 2322 ret = rte_eth_dev_get_port_by_name(request_param->port_name, &port_id); 2323 if (ret) { 2324 TAP_LOG(ERR, "Failed to get port id for %s", 2325 request_param->port_name); 2326 return -1; 2327 } 2328 dev = &rte_eth_devices[port_id]; 2329 process_private = dev->process_private; 2330 2331 /* Fill file descriptors for all queues */ 2332 reply.num_fds = 0; 2333 reply_param->rxq_count = 0; 2334 if (dev->data->nb_rx_queues + dev->data->nb_tx_queues > 2335 RTE_MP_MAX_FD_NUM){ 2336 TAP_LOG(ERR, "Number of rx/tx queues exceeds max number of fds"); 2337 return -1; 2338 } 2339 2340 for (queue = 0; queue < dev->data->nb_rx_queues; queue++) { 2341 reply.fds[reply.num_fds++] = process_private->rxq_fds[queue]; 2342 reply_param->rxq_count++; 2343 } 2344 RTE_ASSERT(reply_param->rxq_count == dev->data->nb_rx_queues); 2345 2346 reply_param->txq_count = 0; 2347 for (queue = 0; queue < dev->data->nb_tx_queues; queue++) { 2348 reply.fds[reply.num_fds++] = process_private->txq_fds[queue]; 2349 reply_param->txq_count++; 2350 } 2351 RTE_ASSERT(reply_param->txq_count == dev->data->nb_tx_queues); 2352 2353 /* Send reply */ 2354 strlcpy(reply.name, request->name, sizeof(reply.name)); 2355 strlcpy(reply_param->port_name, request_param->port_name, 2356 sizeof(reply_param->port_name)); 2357 reply.len_param = sizeof(*reply_param); 2358 if (rte_mp_reply(&reply, peer) < 0) { 2359 TAP_LOG(ERR, "Failed to reply an IPC request to sync queues"); 2360 return -1; 2361 } 2362 return 0; 2363 } 2364 2365 /* Open a TAP interface device. 2366 */ 2367 static int 2368 rte_pmd_tap_probe(struct rte_vdev_device *dev) 2369 { 2370 const char *name, *params; 2371 int ret; 2372 struct rte_kvargs *kvlist = NULL; 2373 int speed; 2374 char tap_name[RTE_ETH_NAME_MAX_LEN]; 2375 char remote_iface[RTE_ETH_NAME_MAX_LEN]; 2376 struct rte_ether_addr user_mac = { .addr_bytes = {0} }; 2377 struct rte_eth_dev *eth_dev; 2378 int tap_devices_count_increased = 0; 2379 2380 name = rte_vdev_device_name(dev); 2381 params = rte_vdev_device_args(dev); 2382 2383 if (rte_eal_process_type() == RTE_PROC_SECONDARY) { 2384 eth_dev = rte_eth_dev_attach_secondary(name); 2385 if (!eth_dev) { 2386 TAP_LOG(ERR, "Failed to probe %s", name); 2387 return -1; 2388 } 2389 eth_dev->dev_ops = &ops; 2390 eth_dev->device = &dev->device; 2391 eth_dev->rx_pkt_burst = pmd_rx_burst; 2392 eth_dev->tx_pkt_burst = pmd_tx_burst; 2393 if (!rte_eal_primary_proc_alive(NULL)) { 2394 TAP_LOG(ERR, "Primary process is missing"); 2395 return -1; 2396 } 2397 eth_dev->process_private = (struct pmd_process_private *) 2398 rte_zmalloc_socket(name, 2399 sizeof(struct pmd_process_private), 2400 RTE_CACHE_LINE_SIZE, 2401 eth_dev->device->numa_node); 2402 if (eth_dev->process_private == NULL) { 2403 TAP_LOG(ERR, 2404 "Failed to alloc memory for process private"); 2405 return -1; 2406 } 2407 2408 ret = tap_mp_attach_queues(name, eth_dev); 2409 if (ret != 0) 2410 return -1; 2411 rte_eth_dev_probing_finish(eth_dev); 2412 return 0; 2413 } 2414 2415 speed = ETH_SPEED_NUM_10G; 2416 2417 /* use tap%d which causes kernel to choose next available */ 2418 strlcpy(tap_name, DEFAULT_TAP_NAME "%d", RTE_ETH_NAME_MAX_LEN); 2419 memset(remote_iface, 0, RTE_ETH_NAME_MAX_LEN); 2420 2421 if (params && (params[0] != '\0')) { 2422 TAP_LOG(DEBUG, "parameters (%s)", params); 2423 2424 kvlist = rte_kvargs_parse(params, valid_arguments); 2425 if (kvlist) { 2426 if (rte_kvargs_count(kvlist, ETH_TAP_IFACE_ARG) == 1) { 2427 ret = rte_kvargs_process(kvlist, 2428 ETH_TAP_IFACE_ARG, 2429 &set_interface_name, 2430 tap_name); 2431 if (ret == -1) 2432 goto leave; 2433 } 2434 2435 if (rte_kvargs_count(kvlist, ETH_TAP_REMOTE_ARG) == 1) { 2436 ret = rte_kvargs_process(kvlist, 2437 ETH_TAP_REMOTE_ARG, 2438 &set_remote_iface, 2439 remote_iface); 2440 if (ret == -1) 2441 goto leave; 2442 } 2443 2444 if (rte_kvargs_count(kvlist, ETH_TAP_MAC_ARG) == 1) { 2445 ret = rte_kvargs_process(kvlist, 2446 ETH_TAP_MAC_ARG, 2447 &set_mac_type, 2448 &user_mac); 2449 if (ret == -1) 2450 goto leave; 2451 } 2452 } 2453 } 2454 pmd_link.link_speed = speed; 2455 2456 TAP_LOG(DEBUG, "Initializing pmd_tap for %s", name); 2457 2458 /* Register IPC feed callback */ 2459 if (!tap_devices_count) { 2460 ret = rte_mp_action_register(TAP_MP_KEY, tap_mp_sync_queues); 2461 if (ret < 0 && rte_errno != ENOTSUP) { 2462 TAP_LOG(ERR, "tap: Failed to register IPC callback: %s", 2463 strerror(rte_errno)); 2464 goto leave; 2465 } 2466 } 2467 tap_devices_count++; 2468 tap_devices_count_increased = 1; 2469 ret = eth_dev_tap_create(dev, tap_name, remote_iface, &user_mac, 2470 ETH_TUNTAP_TYPE_TAP); 2471 2472 leave: 2473 if (ret == -1) { 2474 TAP_LOG(ERR, "Failed to create pmd for %s as %s", 2475 name, tap_name); 2476 if (tap_devices_count_increased == 1) { 2477 if (tap_devices_count == 1) 2478 rte_mp_action_unregister(TAP_MP_KEY); 2479 tap_devices_count--; 2480 } 2481 } 2482 rte_kvargs_free(kvlist); 2483 2484 return ret; 2485 } 2486 2487 /* detach a TUNTAP device. 2488 */ 2489 static int 2490 rte_pmd_tap_remove(struct rte_vdev_device *dev) 2491 { 2492 struct rte_eth_dev *eth_dev = NULL; 2493 struct pmd_internals *internals; 2494 2495 /* find the ethdev entry */ 2496 eth_dev = rte_eth_dev_allocated(rte_vdev_device_name(dev)); 2497 if (!eth_dev) 2498 return -ENODEV; 2499 2500 /* mac_addrs must not be freed alone because part of dev_private */ 2501 eth_dev->data->mac_addrs = NULL; 2502 2503 if (rte_eal_process_type() != RTE_PROC_PRIMARY) 2504 return rte_eth_dev_release_port(eth_dev); 2505 2506 tap_dev_close(eth_dev); 2507 2508 internals = eth_dev->data->dev_private; 2509 TAP_LOG(DEBUG, "Closing %s Ethernet device on numa %u", 2510 tuntap_types[internals->type], rte_socket_id()); 2511 2512 close(internals->ioctl_sock); 2513 rte_free(eth_dev->process_private); 2514 if (tap_devices_count == 1) 2515 rte_mp_action_unregister(TAP_MP_KEY); 2516 tap_devices_count--; 2517 rte_eth_dev_release_port(eth_dev); 2518 2519 return 0; 2520 } 2521 2522 static struct rte_vdev_driver pmd_tun_drv = { 2523 .probe = rte_pmd_tun_probe, 2524 .remove = rte_pmd_tap_remove, 2525 }; 2526 2527 static struct rte_vdev_driver pmd_tap_drv = { 2528 .probe = rte_pmd_tap_probe, 2529 .remove = rte_pmd_tap_remove, 2530 }; 2531 2532 RTE_PMD_REGISTER_VDEV(net_tap, pmd_tap_drv); 2533 RTE_PMD_REGISTER_VDEV(net_tun, pmd_tun_drv); 2534 RTE_PMD_REGISTER_ALIAS(net_tap, eth_tap); 2535 RTE_PMD_REGISTER_PARAM_STRING(net_tun, 2536 ETH_TAP_IFACE_ARG "=<string> "); 2537 RTE_PMD_REGISTER_PARAM_STRING(net_tap, 2538 ETH_TAP_IFACE_ARG "=<string> " 2539 ETH_TAP_MAC_ARG "=" ETH_TAP_MAC_ARG_FMT " " 2540 ETH_TAP_REMOTE_ARG "=<string>"); 2541 RTE_LOG_REGISTER(tap_logtype, pmd.net.tap, NOTICE); 2542