Merge branch 'ena-fixes' · tjh.dev/kernel@72f299b

+9 -20

drivers/net/ethernet/amazon/ena/ena_com.c

··· 2400 2400 return -EOPNOTSUPP; 2401 2401 } 2402 2402 2403 - switch (func) { 2404 - case ENA_ADMIN_TOEPLITZ: 2405 - if (key) { 2406 - if (key_len != sizeof(hash_key->key)) { 2407 - netdev_err(ena_dev->net_device, 2408 - "key len (%u) doesn't equal the supported size (%zu)\n", 2409 - key_len, sizeof(hash_key->key)); 2410 - return -EINVAL; 2411 - } 2412 - memcpy(hash_key->key, key, key_len); 2413 - rss->hash_init_val = init_val; 2414 - hash_key->key_parts = key_len / sizeof(hash_key->key[0]); 2403 + if ((func == ENA_ADMIN_TOEPLITZ) && key) { 2404 + if (key_len != sizeof(hash_key->key)) { 2405 + netdev_err(ena_dev->net_device, 2406 + "key len (%u) doesn't equal the supported size (%zu)\n", 2407 + key_len, sizeof(hash_key->key)); 2408 + return -EINVAL; 2415 2409 } 2416 - break; 2417 - case ENA_ADMIN_CRC32: 2418 - rss->hash_init_val = init_val; 2419 - break; 2420 - default: 2421 - netdev_err(ena_dev->net_device, "Invalid hash function (%d)\n", 2422 - func); 2423 - return -EINVAL; 2410 + memcpy(hash_key->key, key, key_len); 2411 + hash_key->key_parts = key_len / sizeof(hash_key->key[0]); 2424 2412 } 2425 2413 2414 + rss->hash_init_val = init_val; 2426 2415 old_func = rss->hash_func; 2427 2416 rss->hash_func = func; 2428 2417 rc = ena_com_set_hash_function(ena_dev);

+1 -5

drivers/net/ethernet/amazon/ena/ena_ethtool.c

··· 887 887 switch (tuna->id) { 888 888 case ETHTOOL_RX_COPYBREAK: 889 889 len = *(u32 *)data; 890 - if (len > adapter->netdev->mtu) { 891 - ret = -EINVAL; 892 - break; 893 - } 894 - adapter->rx_copybreak = len; 890 + ret = ena_set_rx_copybreak(adapter, len); 895 891 break; 896 892 default: 897 893 ret = -EINVAL;

+60 -23

drivers/net/ethernet/amazon/ena/ena_netdev.c

··· 374 374 375 375 static int ena_xdp_execute(struct ena_ring *rx_ring, struct xdp_buff *xdp) 376 376 { 377 + u32 verdict = ENA_XDP_PASS; 377 378 struct bpf_prog *xdp_prog; 378 379 struct ena_ring *xdp_ring; 379 - u32 verdict = XDP_PASS; 380 380 struct xdp_frame *xdpf; 381 381 u64 *xdp_stat; 382 382 ··· 393 393 if (unlikely(!xdpf)) { 394 394 trace_xdp_exception(rx_ring->netdev, xdp_prog, verdict); 395 395 xdp_stat = &rx_ring->rx_stats.xdp_aborted; 396 - verdict = XDP_ABORTED; 396 + verdict = ENA_XDP_DROP; 397 397 break; 398 398 } 399 399 ··· 409 409 410 410 spin_unlock(&xdp_ring->xdp_tx_lock); 411 411 xdp_stat = &rx_ring->rx_stats.xdp_tx; 412 + verdict = ENA_XDP_TX; 412 413 break; 413 414 case XDP_REDIRECT: 414 415 if (likely(!xdp_do_redirect(rx_ring->netdev, xdp, xdp_prog))) { 415 416 xdp_stat = &rx_ring->rx_stats.xdp_redirect; 417 + verdict = ENA_XDP_REDIRECT; 416 418 break; 417 419 } 418 420 trace_xdp_exception(rx_ring->netdev, xdp_prog, verdict); 419 421 xdp_stat = &rx_ring->rx_stats.xdp_aborted; 420 - verdict = XDP_ABORTED; 422 + verdict = ENA_XDP_DROP; 421 423 break; 422 424 case XDP_ABORTED: 423 425 trace_xdp_exception(rx_ring->netdev, xdp_prog, verdict); 424 426 xdp_stat = &rx_ring->rx_stats.xdp_aborted; 427 + verdict = ENA_XDP_DROP; 425 428 break; 426 429 case XDP_DROP: 427 430 xdp_stat = &rx_ring->rx_stats.xdp_drop; 431 + verdict = ENA_XDP_DROP; 428 432 break; 429 433 case XDP_PASS: 430 434 xdp_stat = &rx_ring->rx_stats.xdp_pass; 435 + verdict = ENA_XDP_PASS; 431 436 break; 432 437 default: 433 438 bpf_warn_invalid_xdp_action(rx_ring->netdev, xdp_prog, verdict); 434 439 xdp_stat = &rx_ring->rx_stats.xdp_invalid; 440 + verdict = ENA_XDP_DROP; 435 441 } 436 442 437 443 ena_increase_stat(xdp_stat, 1, &rx_ring->syncp); ··· 518 512 struct bpf_prog *prog, 519 513 int first, int count) 520 514 { 515 + struct bpf_prog *old_bpf_prog; 521 516 struct ena_ring *rx_ring; 522 517 int i = 0; 523 518 524 519 for (i = first; i < count; i++) { 525 520 rx_ring = &adapter->rx_ring[i]; 526 - xchg(&rx_ring->xdp_bpf_prog, prog); 527 - if (prog) { 521 + old_bpf_prog = xchg(&rx_ring->xdp_bpf_prog, prog); 522 + 523 + if (!old_bpf_prog && prog) { 528 524 ena_xdp_register_rxq_info(rx_ring); 529 525 rx_ring->rx_headroom = XDP_PACKET_HEADROOM; 530 - } else { 526 + } else if (old_bpf_prog && !prog) { 531 527 ena_xdp_unregister_rxq_info(rx_ring); 532 528 rx_ring->rx_headroom = NET_SKB_PAD; 533 529 } ··· 680 672 ring->ena_dev = adapter->ena_dev; 681 673 ring->per_napi_packets = 0; 682 674 ring->cpu = 0; 675 + ring->numa_node = 0; 683 676 ring->no_interrupt_event_cnt = 0; 684 677 u64_stats_init(&ring->syncp); 685 678 } ··· 784 775 tx_ring->next_to_use = 0; 785 776 tx_ring->next_to_clean = 0; 786 777 tx_ring->cpu = ena_irq->cpu; 778 + tx_ring->numa_node = node; 787 779 return 0; 788 780 789 781 err_push_buf_intermediate_buf: ··· 917 907 rx_ring->next_to_clean = 0; 918 908 rx_ring->next_to_use = 0; 919 909 rx_ring->cpu = ena_irq->cpu; 910 + rx_ring->numa_node = node; 920 911 921 912 return 0; 922 913 } ··· 1630 1619 * we expect, then we simply drop it 1631 1620 */ 1632 1621 if (unlikely(rx_ring->ena_bufs[0].len > ENA_XDP_MAX_MTU)) 1633 - return XDP_DROP; 1622 + return ENA_XDP_DROP; 1634 1623 1635 1624 ret = ena_xdp_execute(rx_ring, xdp); 1636 1625 1637 1626 /* The xdp program might expand the headers */ 1638 - if (ret == XDP_PASS) { 1627 + if (ret == ENA_XDP_PASS) { 1639 1628 rx_info->page_offset = xdp->data - xdp->data_hard_start; 1640 1629 rx_ring->ena_bufs[0].len = xdp->data_end - xdp->data; 1641 1630 } ··· 1674 1663 xdp_init_buff(&xdp, ENA_PAGE_SIZE, &rx_ring->xdp_rxq); 1675 1664 1676 1665 do { 1677 - xdp_verdict = XDP_PASS; 1666 + xdp_verdict = ENA_XDP_PASS; 1678 1667 skb = NULL; 1679 1668 ena_rx_ctx.ena_bufs = rx_ring->ena_bufs; 1680 1669 ena_rx_ctx.max_bufs = rx_ring->sgl_size; ··· 1702 1691 xdp_verdict = ena_xdp_handle_buff(rx_ring, &xdp); 1703 1692 1704 1693 /* allocate skb and fill it */ 1705 - if (xdp_verdict == XDP_PASS) 1694 + if (xdp_verdict == ENA_XDP_PASS) 1706 1695 skb = ena_rx_skb(rx_ring, 1707 1696 rx_ring->ena_bufs, 1708 1697 ena_rx_ctx.descs, ··· 1720 1709 /* Packets was passed for transmission, unmap it 1721 1710 * from RX side. 1722 1711 */ 1723 - if (xdp_verdict == XDP_TX || xdp_verdict == XDP_REDIRECT) { 1712 + if (xdp_verdict & ENA_XDP_FORWARDED) { 1724 1713 ena_unmap_rx_buff(rx_ring, 1725 1714 &rx_ring->rx_buffer_info[req_id]); 1726 1715 rx_ring->rx_buffer_info[req_id].page = NULL; 1727 1716 } 1728 1717 } 1729 - if (xdp_verdict != XDP_PASS) { 1718 + if (xdp_verdict != ENA_XDP_PASS) { 1730 1719 xdp_flags |= xdp_verdict; 1720 + total_len += ena_rx_ctx.ena_bufs[0].len; 1731 1721 res_budget--; 1732 1722 continue; 1733 1723 } ··· 1772 1760 ena_refill_rx_bufs(rx_ring, refill_required); 1773 1761 } 1774 1762 1775 - if (xdp_flags & XDP_REDIRECT) 1763 + if (xdp_flags & ENA_XDP_REDIRECT) 1776 1764 xdp_do_flush_map(); 1777 1765 1778 1766 return work_done; ··· 1826 1814 static void ena_unmask_interrupt(struct ena_ring *tx_ring, 1827 1815 struct ena_ring *rx_ring) 1828 1816 { 1817 + u32 rx_interval = tx_ring->smoothed_interval; 1829 1818 struct ena_eth_io_intr_reg intr_reg; 1830 - u32 rx_interval = 0; 1819 + 1831 1820 /* Rx ring can be NULL when for XDP tx queues which don't have an 1832 1821 * accompanying rx_ring pair. 1833 1822 */ ··· 1866 1853 if (likely(tx_ring->cpu == cpu)) 1867 1854 goto out; 1868 1855 1856 + tx_ring->cpu = cpu; 1857 + if (rx_ring) 1858 + rx_ring->cpu = cpu; 1859 + 1869 1860 numa_node = cpu_to_node(cpu); 1861 + 1862 + if (likely(tx_ring->numa_node == numa_node)) 1863 + goto out; 1864 + 1870 1865 put_cpu(); 1871 1866 1872 1867 if (numa_node != NUMA_NO_NODE) { 1873 1868 ena_com_update_numa_node(tx_ring->ena_com_io_cq, numa_node); 1874 - if (rx_ring) 1869 + tx_ring->numa_node = numa_node; 1870 + if (rx_ring) { 1871 + rx_ring->numa_node = numa_node; 1875 1872 ena_com_update_numa_node(rx_ring->ena_com_io_cq, 1876 1873 numa_node); 1874 + } 1877 1875 } 1878 - 1879 - tx_ring->cpu = cpu; 1880 - if (rx_ring) 1881 - rx_ring->cpu = cpu; 1882 1876 1883 1877 return; 1884 1878 out: ··· 2007 1987 if (ena_com_get_adaptive_moderation_enabled(rx_ring->ena_dev)) 2008 1988 ena_adjust_adaptive_rx_intr_moderation(ena_napi); 2009 1989 1990 + ena_update_ring_numa_node(tx_ring, rx_ring); 2010 1991 ena_unmask_interrupt(tx_ring, rx_ring); 2011 1992 } 2012 - 2013 - ena_update_ring_numa_node(tx_ring, rx_ring); 2014 1993 2015 1994 ret = rx_work_done; 2016 1995 } else { ··· 2395 2376 ctx.mem_queue_type = ena_dev->tx_mem_queue_type; 2396 2377 ctx.msix_vector = msix_vector; 2397 2378 ctx.queue_size = tx_ring->ring_size; 2398 - ctx.numa_node = cpu_to_node(tx_ring->cpu); 2379 + ctx.numa_node = tx_ring->numa_node; 2399 2380 2400 2381 rc = ena_com_create_io_queue(ena_dev, &ctx); 2401 2382 if (rc) { ··· 2463 2444 ctx.mem_queue_type = ENA_ADMIN_PLACEMENT_POLICY_HOST; 2464 2445 ctx.msix_vector = msix_vector; 2465 2446 ctx.queue_size = rx_ring->ring_size; 2466 - ctx.numa_node = cpu_to_node(rx_ring->cpu); 2447 + ctx.numa_node = rx_ring->numa_node; 2467 2448 2468 2449 rc = ena_com_create_io_queue(ena_dev, &ctx); 2469 2450 if (rc) { ··· 2822 2803 adapter->xdp_num_queues + 2823 2804 adapter->num_io_queues); 2824 2805 return dev_was_up ? ena_up(adapter) : 0; 2806 + } 2807 + 2808 + int ena_set_rx_copybreak(struct ena_adapter *adapter, u32 rx_copybreak) 2809 + { 2810 + struct ena_ring *rx_ring; 2811 + int i; 2812 + 2813 + if (rx_copybreak > min_t(u16, adapter->netdev->mtu, ENA_PAGE_SIZE)) 2814 + return -EINVAL; 2815 + 2816 + adapter->rx_copybreak = rx_copybreak; 2817 + 2818 + for (i = 0; i < adapter->num_io_queues; i++) { 2819 + rx_ring = &adapter->rx_ring[i]; 2820 + rx_ring->rx_copybreak = rx_copybreak; 2821 + } 2822 + 2823 + return 0; 2825 2824 } 2826 2825 2827 2826 int ena_update_queue_count(struct ena_adapter *adapter, u32 new_channel_count)

+15 -2

drivers/net/ethernet/amazon/ena/ena_netdev.h

··· 262 262 bool disable_meta_caching; 263 263 u16 no_interrupt_event_cnt; 264 264 265 - /* cpu for TPH */ 265 + /* cpu and NUMA for TPH */ 266 266 int cpu; 267 - /* number of tx/rx_buffer_info's entries */ 267 + int numa_node; 268 + 269 + /* number of tx/rx_buffer_info's entries */ 268 270 int ring_size; 269 271 270 272 enum ena_admin_placement_policy_type tx_mem_queue_type; ··· 394 392 395 393 int ena_update_queue_count(struct ena_adapter *adapter, u32 new_channel_count); 396 394 395 + int ena_set_rx_copybreak(struct ena_adapter *adapter, u32 rx_copybreak); 396 + 397 397 int ena_get_sset_count(struct net_device *netdev, int sset); 398 398 399 399 static inline void ena_reset_device(struct ena_adapter *adapter, ··· 412 408 ENA_XDP_CURRENT_MTU_TOO_LARGE, 413 409 ENA_XDP_NO_ENOUGH_QUEUES, 414 410 }; 411 + 412 + enum ENA_XDP_ACTIONS { 413 + ENA_XDP_PASS = 0, 414 + ENA_XDP_TX = BIT(0), 415 + ENA_XDP_REDIRECT = BIT(1), 416 + ENA_XDP_DROP = BIT(2) 417 + }; 418 + 419 + #define ENA_XDP_FORWARDED (ENA_XDP_TX | ENA_XDP_REDIRECT) 415 420 416 421 static inline bool ena_xdp_present(struct ena_adapter *adapter) 417 422 {

Configure Feed

Configure Feed