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