tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net

Pull networking fixes from David Miller:
"This pull request is dedicated to the upcoming snowpocalypse parts 2
and 3 in the Pacific Northwest:

1) Drop profiles are broken because some drivers use dev_kfree_skb*
instead of dev_consume_skb*, from Yang Wei.

2) Fix IWLWIFI kconfig deps, from Luca Coelho.

3) Fix percpu maps updating in bpftool, from Paolo Abeni.

4) Missing station release in batman-adv, from Felix Fietkau.

5) Fix some networking compat ioctl bugs, from Johannes Berg.

6) ucc_geth must reset the BQL queue state when stopping the device,
from Mathias Thore.

7) Several XDP bug fixes in virtio_net from Toshiaki Makita.

8) TSO packets must be sent always on queue 0 in stmmac, from Jose
Abreu.

9) Fix socket refcounting bug in RDS, from Eric Dumazet.

10) Handle sparse cpu allocations in bpf selftests, from Martynas
Pumputis.

11) Make sure mgmt frames have enough tailroom in mac80211, from Felix
Feitkau.

12) Use safe list walking in sctp_sendmsg() asoc list traversal, from
Greg Kroah-Hartman.

13) Make DCCP's ccid_hc_[rt]x_parse_options always check for NULL
ccid, from Eric Dumazet.

14) Need to reload WoL password into bcmsysport device after deep
sleeps, from Florian Fainelli.

15) Remove filter from mask before freeing in cls_flower, from Petr
Machata.

16) Missing release and use after free in error paths of s390 qeth
code, from Julian Wiedmann.

17) Fix lockdep false positive in dsa code, from Marc Zyngier.

18) Fix counting of ATU violations in mv88e6xxx, from Andrew Lunn.

19) Fix EQ firmware assert in qed driver, from Manish Chopra.

20) Don't default Caivum PTP to Y in kconfig, from Bjorn Helgaas"

* git://git.kernel.org/pub/scm/linux/kernel/git/davem/net: (116 commits)
net: dsa: b53: Fix for failure when irq is not defined in dt
sit: check if IPv6 enabled before calling ip6_err_gen_icmpv6_unreach()
geneve: should not call rt6_lookup() when ipv6 was disabled
net: Don't default Cavium PTP driver to 'y'
net: broadcom: replace dev_kfree_skb_irq by dev_consume_skb_irq for drop profiles
net: via-velocity: replace dev_kfree_skb_irq by dev_consume_skb_irq for drop profiles
net: tehuti: replace dev_kfree_skb_irq by dev_consume_skb_irq for drop profiles
net: sun: replace dev_kfree_skb_irq by dev_consume_skb_irq for drop profiles
net: fsl_ucc_hdlc: replace dev_kfree_skb_irq by dev_consume_skb_irq for drop profiles
net: fec_mpc52xx: replace dev_kfree_skb_irq by dev_consume_skb_irq for drop profiles
net: smsc: epic100: replace dev_kfree_skb_irq by dev_consume_skb_irq for drop profiles
net: dscc4: replace dev_kfree_skb_irq by dev_consume_skb_irq for drop profiles
net: tulip: de2104x: replace dev_kfree_skb_irq by dev_consume_skb_irq for drop profiles
net: defxx: replace dev_kfree_skb_irq by dev_consume_skb_irq for drop profiles
net/mlx5e: Don't overwrite pedit action when multiple pedit used
net/mlx5e: Update hw flows when encap source mac changed
qed*: Advance drivers version to 8.37.0.20
qed: Change verbosity for coalescing message.
qede: Fix system crash on configuring channels.
qed: Consider TX tcs while deriving the max num_queues for PF.
...

Linus Torvalds 27b4ad62 68090543

+1803 -545
+21
MAINTAINERS
··· 2848 2848 BPF (Safe dynamic programs and tools) 2849 2849 M: Alexei Starovoitov <ast@kernel.org> 2850 2850 M: Daniel Borkmann <daniel@iogearbox.net> 2851 + R: Martin KaFai Lau <kafai@fb.com> 2852 + R: Song Liu <songliubraving@fb.com> 2853 + R: Yonghong Song <yhs@fb.com> 2851 2854 L: netdev@vger.kernel.org 2852 2855 L: linux-kernel@vger.kernel.org 2853 2856 T: git git://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf.git ··· 2876 2873 F: tools/bpf/ 2877 2874 F: tools/lib/bpf/ 2878 2875 F: tools/testing/selftests/bpf/ 2876 + K: bpf 2877 + N: bpf 2879 2878 2880 2879 BPF JIT for ARM 2881 2880 M: Shubham Bansal <illusionist.neo@gmail.com> ··· 12873 12868 F: drivers/net/dsa/realtek-smi* 12874 12869 F: drivers/net/dsa/rtl83* 12875 12870 12871 + REDPINE WIRELESS DRIVER 12872 + M: Amitkumar Karwar <amitkarwar@gmail.com> 12873 + M: Siva Rebbagondla <siva8118@gmail.com> 12874 + L: linux-wireless@vger.kernel.org 12875 + S: Maintained 12876 + F: drivers/net/wireless/rsi/ 12877 + 12876 12878 REGISTER MAP ABSTRACTION 12877 12879 M: Mark Brown <broonie@kernel.org> 12878 12880 L: linux-kernel@vger.kernel.org ··· 13707 13695 L: netdev@vger.kernel.org 13708 13696 S: Supported 13709 13697 F: drivers/net/ethernet/sfc/ 13698 + 13699 + SFF/SFP/SFP+ MODULE SUPPORT 13700 + M: Russell King <linux@armlinux.org.uk> 13701 + L: netdev@vger.kernel.org 13702 + S: Maintained 13703 + F: drivers/net/phy/phylink.c 13704 + F: drivers/net/phy/sfp* 13705 + F: include/linux/phylink.h 13706 + F: include/linux/sfp.h 13710 13707 13711 13708 SGI GRU DRIVER 13712 13709 M: Dimitri Sivanich <sivanich@sgi.com>
+1 -1
drivers/isdn/mISDN/timerdev.c
··· 170 170 spin_lock_irqsave(&timer->dev->lock, flags); 171 171 if (timer->id >= 0) 172 172 list_move_tail(&timer->list, &timer->dev->expired); 173 - spin_unlock_irqrestore(&timer->dev->lock, flags); 174 173 wake_up_interruptible(&timer->dev->wait); 174 + spin_unlock_irqrestore(&timer->dev->lock, flags); 175 175 } 176 176 177 177 static int
-3
drivers/net/dsa/b53/b53_srab.c
··· 511 511 /* Clear all pending interrupts */ 512 512 writel(0xffffffff, priv->regs + B53_SRAB_INTR); 513 513 514 - if (dev->pdata && dev->pdata->chip_id != BCM58XX_DEVICE_ID) 515 - return; 516 - 517 514 for (i = 0; i < B53_N_PORTS; i++) { 518 515 port = &priv->port_intrs[i]; 519 516
+12 -9
drivers/net/dsa/mv88e6xxx/global1_atu.c
··· 314 314 { 315 315 struct mv88e6xxx_chip *chip = dev_id; 316 316 struct mv88e6xxx_atu_entry entry; 317 + int spid; 317 318 int err; 318 319 u16 val; 319 320 ··· 337 336 if (err) 338 337 goto out; 339 338 339 + spid = entry.state; 340 + 340 341 if (val & MV88E6XXX_G1_ATU_OP_AGE_OUT_VIOLATION) { 341 342 dev_err_ratelimited(chip->dev, 342 343 "ATU age out violation for %pM\n", ··· 347 344 348 345 if (val & MV88E6XXX_G1_ATU_OP_MEMBER_VIOLATION) { 349 346 dev_err_ratelimited(chip->dev, 350 - "ATU member violation for %pM portvec %x\n", 351 - entry.mac, entry.portvec); 352 - chip->ports[entry.portvec].atu_member_violation++; 347 + "ATU member violation for %pM portvec %x spid %d\n", 348 + entry.mac, entry.portvec, spid); 349 + chip->ports[spid].atu_member_violation++; 353 350 } 354 351 355 352 if (val & MV88E6XXX_G1_ATU_OP_MISS_VIOLATION) { 356 353 dev_err_ratelimited(chip->dev, 357 - "ATU miss violation for %pM portvec %x\n", 358 - entry.mac, entry.portvec); 359 - chip->ports[entry.portvec].atu_miss_violation++; 354 + "ATU miss violation for %pM portvec %x spid %d\n", 355 + entry.mac, entry.portvec, spid); 356 + chip->ports[spid].atu_miss_violation++; 360 357 } 361 358 362 359 if (val & MV88E6XXX_G1_ATU_OP_FULL_VIOLATION) { 363 360 dev_err_ratelimited(chip->dev, 364 - "ATU full violation for %pM portvec %x\n", 365 - entry.mac, entry.portvec); 366 - chip->ports[entry.portvec].atu_full_violation++; 361 + "ATU full violation for %pM portvec %x spid %d\n", 362 + entry.mac, entry.portvec, spid); 363 + chip->ports[spid].atu_full_violation++; 367 364 } 368 365 mutex_unlock(&chip->reg_lock); 369 366
+10 -15
drivers/net/ethernet/broadcom/bcmsysport.c
··· 520 520 struct ethtool_wolinfo *wol) 521 521 { 522 522 struct bcm_sysport_priv *priv = netdev_priv(dev); 523 - u32 reg; 524 523 525 524 wol->supported = WAKE_MAGIC | WAKE_MAGICSECURE | WAKE_FILTER; 526 525 wol->wolopts = priv->wolopts; ··· 527 528 if (!(priv->wolopts & WAKE_MAGICSECURE)) 528 529 return; 529 530 530 - /* Return the programmed SecureOn password */ 531 - reg = umac_readl(priv, UMAC_PSW_MS); 532 - put_unaligned_be16(reg, &wol->sopass[0]); 533 - reg = umac_readl(priv, UMAC_PSW_LS); 534 - put_unaligned_be32(reg, &wol->sopass[2]); 531 + memcpy(wol->sopass, priv->sopass, sizeof(priv->sopass)); 535 532 } 536 533 537 534 static int bcm_sysport_set_wol(struct net_device *dev, ··· 543 548 if (wol->wolopts & ~supported) 544 549 return -EINVAL; 545 550 546 - /* Program the SecureOn password */ 547 - if (wol->wolopts & WAKE_MAGICSECURE) { 548 - umac_writel(priv, get_unaligned_be16(&wol->sopass[0]), 549 - UMAC_PSW_MS); 550 - umac_writel(priv, get_unaligned_be32(&wol->sopass[2]), 551 - UMAC_PSW_LS); 552 - } 551 + if (wol->wolopts & WAKE_MAGICSECURE) 552 + memcpy(priv->sopass, wol->sopass, sizeof(priv->sopass)); 553 553 554 554 /* Flag the device and relevant IRQ as wakeup capable */ 555 555 if (wol->wolopts) { ··· 2639 2649 unsigned int index, i = 0; 2640 2650 u32 reg; 2641 2651 2642 - /* Password has already been programmed */ 2643 2652 reg = umac_readl(priv, UMAC_MPD_CTRL); 2644 2653 if (priv->wolopts & (WAKE_MAGIC | WAKE_MAGICSECURE)) 2645 2654 reg |= MPD_EN; 2646 2655 reg &= ~PSW_EN; 2647 - if (priv->wolopts & WAKE_MAGICSECURE) 2656 + if (priv->wolopts & WAKE_MAGICSECURE) { 2657 + /* Program the SecureOn password */ 2658 + umac_writel(priv, get_unaligned_be16(&priv->sopass[0]), 2659 + UMAC_PSW_MS); 2660 + umac_writel(priv, get_unaligned_be32(&priv->sopass[2]), 2661 + UMAC_PSW_LS); 2648 2662 reg |= PSW_EN; 2663 + } 2649 2664 umac_writel(priv, reg, UMAC_MPD_CTRL); 2650 2665 2651 2666 if (priv->wolopts & WAKE_FILTER) {
+2
drivers/net/ethernet/broadcom/bcmsysport.h
··· 12 12 #define __BCM_SYSPORT_H 13 13 14 14 #include <linux/bitmap.h> 15 + #include <linux/ethtool.h> 15 16 #include <linux/if_vlan.h> 16 17 #include <linux/net_dim.h> 17 18 ··· 779 778 unsigned int crc_fwd:1; 780 779 u16 rev; 781 780 u32 wolopts; 781 + u8 sopass[SOPASS_MAX]; 782 782 unsigned int wol_irq_disabled:1; 783 783 784 784 /* MIB related fields */
+7 -1
drivers/net/ethernet/broadcom/bnxt/bnxt.c
··· 4973 4973 struct bnxt_cp_ring_info *cpr = &bnapi->cp_ring; 4974 4974 struct bnxt_ring_struct *ring = &cpr->cp_ring_struct; 4975 4975 u32 map_idx = ring->map_idx; 4976 + unsigned int vector; 4976 4977 4978 + vector = bp->irq_tbl[map_idx].vector; 4979 + disable_irq_nosync(vector); 4977 4980 rc = hwrm_ring_alloc_send_msg(bp, ring, type, map_idx); 4978 - if (rc) 4981 + if (rc) { 4982 + enable_irq(vector); 4979 4983 goto err_out; 4984 + } 4980 4985 bnxt_set_db(bp, &cpr->cp_db, type, map_idx, ring->fw_ring_id); 4981 4986 bnxt_db_nq(bp, &cpr->cp_db, cpr->cp_raw_cons); 4987 + enable_irq(vector); 4982 4988 bp->grp_info[i].cp_fw_ring_id = ring->fw_ring_id; 4983 4989 4984 4990 if (!i) {
+1 -1
drivers/net/ethernet/broadcom/sb1250-mac.c
··· 1288 1288 * for transmits, we just free buffers. 1289 1289 */ 1290 1290 1291 - dev_kfree_skb_irq(sb); 1291 + dev_consume_skb_irq(sb); 1292 1292 1293 1293 /* 1294 1294 * .. and advance to the next buffer.
-1
drivers/net/ethernet/cavium/Kconfig
··· 54 54 tristate "Cavium PTP coprocessor as PTP clock" 55 55 depends on 64BIT && PCI 56 56 imply PTP_1588_CLOCK 57 - default y 58 57 ---help--- 59 58 This driver adds support for the Precision Time Protocol Clocks and 60 59 Timestamping coprocessor (PTP) found on Cavium processors.
+2 -1
drivers/net/ethernet/cisco/enic/enic_main.c
··· 1434 1434 * csum is correct or is zero. 1435 1435 */ 1436 1436 if ((netdev->features & NETIF_F_RXCSUM) && !csum_not_calc && 1437 - tcp_udp_csum_ok && ipv4_csum_ok && outer_csum_ok) { 1437 + tcp_udp_csum_ok && outer_csum_ok && 1438 + (ipv4_csum_ok || ipv6)) { 1438 1439 skb->ip_summed = CHECKSUM_UNNECESSARY; 1439 1440 skb->csum_level = encap; 1440 1441 }
+1 -1
drivers/net/ethernet/dec/tulip/de2104x.c
··· 585 585 netif_dbg(de, tx_done, de->dev, 586 586 "tx done, slot %d\n", tx_tail); 587 587 } 588 - dev_kfree_skb_irq(skb); 588 + dev_consume_skb_irq(skb); 589 589 } 590 590 591 591 next:
+1 -1
drivers/net/ethernet/freescale/fec_mpc52xx.c
··· 369 369 dma_unmap_single(dev->dev.parent, bd->skb_pa, skb->len, 370 370 DMA_TO_DEVICE); 371 371 372 - dev_kfree_skb_irq(skb); 372 + dev_consume_skb_irq(skb); 373 373 } 374 374 spin_unlock(&priv->lock); 375 375
+2
drivers/net/ethernet/freescale/ucc_geth.c
··· 1879 1879 u16 i, j; 1880 1880 u8 __iomem *bd; 1881 1881 1882 + netdev_reset_queue(ugeth->ndev); 1883 + 1882 1884 ug_info = ugeth->ug_info; 1883 1885 uf_info = &ug_info->uf_info; 1884 1886
+4 -2
drivers/net/ethernet/marvell/skge.c
··· 152 152 memset(p, 0, regs->len); 153 153 memcpy_fromio(p, io, B3_RAM_ADDR); 154 154 155 - memcpy_fromio(p + B3_RI_WTO_R1, io + B3_RI_WTO_R1, 156 - regs->len - B3_RI_WTO_R1); 155 + if (regs->len > B3_RI_WTO_R1) { 156 + memcpy_fromio(p + B3_RI_WTO_R1, io + B3_RI_WTO_R1, 157 + regs->len - B3_RI_WTO_R1); 158 + } 157 159 } 158 160 159 161 /* Wake on Lan only supported on Yukon chips with rev 1 or above */
+5 -1
drivers/net/ethernet/mellanox/mlx5/core/en/tc_tun.c
··· 256 256 e->m_neigh.family = n->ops->family; 257 257 memcpy(&e->m_neigh.dst_ip, n->primary_key, n->tbl->key_len); 258 258 e->out_dev = out_dev; 259 + e->route_dev = route_dev; 259 260 260 261 /* It's important to add the neigh to the hash table before checking 261 262 * the neigh validity state. So if we'll get a notification, in case the ··· 370 369 e->m_neigh.family = n->ops->family; 371 370 memcpy(&e->m_neigh.dst_ip, n->primary_key, n->tbl->key_len); 372 371 e->out_dev = out_dev; 372 + e->route_dev = route_dev; 373 373 374 374 /* It's importent to add the neigh to the hash table before checking 375 375 * the neigh validity state. So if we'll get a notification, in case the ··· 614 612 struct mlx5_flow_spec *spec, 615 613 struct tc_cls_flower_offload *f, 616 614 void *headers_c, 617 - void *headers_v) 615 + void *headers_v, u8 *match_level) 618 616 { 619 617 int tunnel_type; 620 618 int err = 0; 621 619 622 620 tunnel_type = mlx5e_tc_tun_get_type(filter_dev); 623 621 if (tunnel_type == MLX5E_TC_TUNNEL_TYPE_VXLAN) { 622 + *match_level = MLX5_MATCH_L4; 624 623 err = mlx5e_tc_tun_parse_vxlan(priv, spec, f, 625 624 headers_c, headers_v); 626 625 } else if (tunnel_type == MLX5E_TC_TUNNEL_TYPE_GRETAP) { 626 + *match_level = MLX5_MATCH_L3; 627 627 err = mlx5e_tc_tun_parse_gretap(priv, spec, f, 628 628 headers_c, headers_v); 629 629 } else {
+1 -1
drivers/net/ethernet/mellanox/mlx5/core/en/tc_tun.h
··· 39 39 struct mlx5_flow_spec *spec, 40 40 struct tc_cls_flower_offload *f, 41 41 void *headers_c, 42 - void *headers_v); 42 + void *headers_v, u8 *match_level); 43 43 44 44 #endif //__MLX5_EN_TC_TUNNEL_H__
+4
drivers/net/ethernet/mellanox/mlx5/core/en_rep.c
··· 596 596 if (neigh_connected && !(e->flags & MLX5_ENCAP_ENTRY_VALID)) { 597 597 ether_addr_copy(e->h_dest, ha); 598 598 ether_addr_copy(eth->h_dest, ha); 599 + /* Update the encap source mac, in case that we delete 600 + * the flows when encap source mac changed. 601 + */ 602 + ether_addr_copy(eth->h_source, e->route_dev->dev_addr); 599 603 600 604 mlx5e_tc_encap_flows_add(priv, e); 601 605 }
+1
drivers/net/ethernet/mellanox/mlx5/core/en_rep.h
··· 148 148 unsigned char h_dest[ETH_ALEN]; /* destination eth addr */ 149 149 150 150 struct net_device *out_dev; 151 + struct net_device *route_dev; 151 152 int tunnel_type; 152 153 int tunnel_hlen; 153 154 int reformat_type;
+32 -20
drivers/net/ethernet/mellanox/mlx5/core/en_tc.c
··· 128 128 struct net_device *filter_dev; 129 129 struct mlx5_flow_spec spec; 130 130 int num_mod_hdr_actions; 131 + int max_mod_hdr_actions; 131 132 void *mod_hdr_actions; 132 133 int mirred_ifindex[MLX5_MAX_FLOW_FWD_VPORTS]; 133 134 }; ··· 1303 1302 static int parse_tunnel_attr(struct mlx5e_priv *priv, 1304 1303 struct mlx5_flow_spec *spec, 1305 1304 struct tc_cls_flower_offload *f, 1306 - struct net_device *filter_dev) 1305 + struct net_device *filter_dev, u8 *match_level) 1307 1306 { 1308 1307 struct netlink_ext_ack *extack = f->common.extack; 1309 1308 void *headers_c = MLX5_ADDR_OF(fte_match_param, spec->match_criteria, ··· 1318 1317 int err = 0; 1319 1318 1320 1319 err = mlx5e_tc_tun_parse(filter_dev, priv, spec, f, 1321 - headers_c, headers_v); 1320 + headers_c, headers_v, match_level); 1322 1321 if (err) { 1323 1322 NL_SET_ERR_MSG_MOD(extack, 1324 1323 "failed to parse tunnel attributes"); ··· 1427 1426 struct mlx5_flow_spec *spec, 1428 1427 struct tc_cls_flower_offload *f, 1429 1428 struct net_device *filter_dev, 1430 - u8 *match_level) 1429 + u8 *match_level, u8 *tunnel_match_level) 1431 1430 { 1432 1431 struct netlink_ext_ack *extack = f->common.extack; 1433 1432 void *headers_c = MLX5_ADDR_OF(fte_match_param, spec->match_criteria, ··· 1478 1477 switch (key->addr_type) { 1479 1478 case FLOW_DISSECTOR_KEY_IPV4_ADDRS: 1480 1479 case FLOW_DISSECTOR_KEY_IPV6_ADDRS: 1481 - if (parse_tunnel_attr(priv, spec, f, filter_dev)) 1480 + if (parse_tunnel_attr(priv, spec, f, filter_dev, tunnel_match_level)) 1482 1481 return -EOPNOTSUPP; 1483 1482 break; 1484 1483 default: ··· 1827 1826 struct mlx5_core_dev *dev = priv->mdev; 1828 1827 struct mlx5_eswitch *esw = dev->priv.eswitch; 1829 1828 struct mlx5e_rep_priv *rpriv = priv->ppriv; 1829 + u8 match_level, tunnel_match_level = MLX5_MATCH_NONE; 1830 1830 struct mlx5_eswitch_rep *rep; 1831 - u8 match_level; 1832 1831 int err; 1833 1832 1834 - err = __parse_cls_flower(priv, spec, f, filter_dev, &match_level); 1833 + err = __parse_cls_flower(priv, spec, f, filter_dev, &match_level, &tunnel_match_level); 1835 1834 1836 1835 if (!err && (flow->flags & MLX5E_TC_FLOW_ESWITCH)) { 1837 1836 rep = rpriv->rep; ··· 1847 1846 } 1848 1847 } 1849 1848 1850 - if (flow->flags & MLX5E_TC_FLOW_ESWITCH) 1849 + if (flow->flags & MLX5E_TC_FLOW_ESWITCH) { 1851 1850 flow->esw_attr->match_level = match_level; 1852 - else 1851 + flow->esw_attr->tunnel_match_level = tunnel_match_level; 1852 + } else { 1853 1853 flow->nic_attr->match_level = match_level; 1854 + } 1854 1855 1855 1856 return err; 1856 1857 } ··· 1937 1934 OFFLOAD(UDP_DPORT, 2, udp.dest, 0), 1938 1935 }; 1939 1936 1940 - /* On input attr->num_mod_hdr_actions tells how many HW actions can be parsed at 1941 - * max from the SW pedit action. On success, it says how many HW actions were 1942 - * actually parsed. 1937 + /* On input attr->max_mod_hdr_actions tells how many HW actions can be parsed at 1938 + * max from the SW pedit action. On success, attr->num_mod_hdr_actions 1939 + * says how many HW actions were actually parsed. 1943 1940 */ 1944 1941 static int offload_pedit_fields(struct pedit_headers *masks, 1945 1942 struct pedit_headers *vals, ··· 1963 1960 add_vals = &vals[TCA_PEDIT_KEY_EX_CMD_ADD]; 1964 1961 1965 1962 action_size = MLX5_UN_SZ_BYTES(set_action_in_add_action_in_auto); 1966 - action = parse_attr->mod_hdr_actions; 1967 - max_actions = parse_attr->num_mod_hdr_actions; 1968 - nactions = 0; 1963 + action = parse_attr->mod_hdr_actions + 1964 + parse_attr->num_mod_hdr_actions * action_size; 1965 + 1966 + max_actions = parse_attr->max_mod_hdr_actions; 1967 + nactions = parse_attr->num_mod_hdr_actions; 1969 1968 1970 1969 for (i = 0; i < ARRAY_SIZE(fields); i++) { 1971 1970 f = &fields[i]; ··· 2078 2073 if (!parse_attr->mod_hdr_actions) 2079 2074 return -ENOMEM; 2080 2075 2081 - parse_attr->num_mod_hdr_actions = max_actions; 2076 + parse_attr->max_mod_hdr_actions = max_actions; 2082 2077 return 0; 2083 2078 } 2084 2079 ··· 2124 2119 goto out_err; 2125 2120 } 2126 2121 2127 - err = alloc_mod_hdr_actions(priv, a, namespace, parse_attr); 2128 - if (err) 2129 - goto out_err; 2122 + if (!parse_attr->mod_hdr_actions) { 2123 + err = alloc_mod_hdr_actions(priv, a, namespace, parse_attr); 2124 + if (err) 2125 + goto out_err; 2126 + } 2130 2127 2131 2128 err = offload_pedit_fields(masks, vals, parse_attr, extack); 2132 2129 if (err < 0) ··· 2186 2179 2187 2180 static bool modify_header_match_supported(struct mlx5_flow_spec *spec, 2188 2181 struct tcf_exts *exts, 2182 + u32 actions, 2189 2183 struct netlink_ext_ack *extack) 2190 2184 { 2191 2185 const struct tc_action *a; ··· 2196 2188 u16 ethertype; 2197 2189 int nkeys, i; 2198 2190 2199 - headers_v = MLX5_ADDR_OF(fte_match_param, spec->match_value, outer_headers); 2191 + if (actions & MLX5_FLOW_CONTEXT_ACTION_DECAP) 2192 + headers_v = MLX5_ADDR_OF(fte_match_param, spec->match_value, inner_headers); 2193 + else 2194 + headers_v = MLX5_ADDR_OF(fte_match_param, spec->match_value, outer_headers); 2195 + 2200 2196 ethertype = MLX5_GET(fte_match_set_lyr_2_4, headers_v, ethertype); 2201 2197 2202 2198 /* for non-IP we only re-write MACs, so we're okay */ ··· 2257 2245 2258 2246 if (actions & MLX5_FLOW_CONTEXT_ACTION_MOD_HDR) 2259 2247 return modify_header_match_supported(&parse_attr->spec, exts, 2260 - extack); 2248 + actions, extack); 2261 2249 2262 2250 return true; 2263 2251 }
+6
drivers/net/ethernet/mellanox/mlx5/core/en_tx.c
··· 387 387 num_wqebbs = DIV_ROUND_UP(ds_cnt, MLX5_SEND_WQEBB_NUM_DS); 388 388 contig_wqebbs_room = mlx5_wq_cyc_get_contig_wqebbs(wq, pi); 389 389 if (unlikely(contig_wqebbs_room < num_wqebbs)) { 390 + #ifdef CONFIG_MLX5_EN_IPSEC 391 + struct mlx5_wqe_eth_seg cur_eth = wqe->eth; 392 + #endif 390 393 mlx5e_fill_sq_frag_edge(sq, wq, pi, contig_wqebbs_room); 391 394 mlx5e_sq_fetch_wqe(sq, &wqe, &pi); 395 + #ifdef CONFIG_MLX5_EN_IPSEC 396 + wqe->eth = cur_eth; 397 + #endif 392 398 } 393 399 394 400 /* fill wqe */
+1
drivers/net/ethernet/mellanox/mlx5/core/eswitch.h
··· 312 312 } dests[MLX5_MAX_FLOW_FWD_VPORTS]; 313 313 u32 mod_hdr_id; 314 314 u8 match_level; 315 + u8 tunnel_match_level; 315 316 struct mlx5_fc *counter; 316 317 u32 chain; 317 318 u16 prio;
+9 -8
drivers/net/ethernet/mellanox/mlx5/core/eswitch_offloads.c
··· 160 160 MLX5_SET_TO_ONES(fte_match_set_misc, misc, 161 161 source_eswitch_owner_vhca_id); 162 162 163 - if (attr->match_level == MLX5_MATCH_NONE) 164 - spec->match_criteria_enable = MLX5_MATCH_MISC_PARAMETERS; 165 - else 166 - spec->match_criteria_enable = MLX5_MATCH_OUTER_HEADERS | 167 - MLX5_MATCH_MISC_PARAMETERS; 168 - 169 - if (flow_act.action & MLX5_FLOW_CONTEXT_ACTION_DECAP) 170 - spec->match_criteria_enable |= MLX5_MATCH_INNER_HEADERS; 163 + spec->match_criteria_enable = MLX5_MATCH_MISC_PARAMETERS; 164 + if (flow_act.action & MLX5_FLOW_CONTEXT_ACTION_DECAP) { 165 + if (attr->tunnel_match_level != MLX5_MATCH_NONE) 166 + spec->match_criteria_enable |= MLX5_MATCH_OUTER_HEADERS; 167 + if (attr->match_level != MLX5_MATCH_NONE) 168 + spec->match_criteria_enable |= MLX5_MATCH_INNER_HEADERS; 169 + } else if (attr->match_level != MLX5_MATCH_NONE) { 170 + spec->match_criteria_enable |= MLX5_MATCH_OUTER_HEADERS; 171 + } 171 172 172 173 if (flow_act.action & MLX5_FLOW_CONTEXT_ACTION_MOD_HDR) 173 174 flow_act.modify_id = attr->mod_hdr_id;
+1 -1
drivers/net/ethernet/qlogic/qed/qed.h
··· 53 53 extern const struct qed_common_ops qed_common_ops_pass; 54 54 55 55 #define QED_MAJOR_VERSION 8 56 - #define QED_MINOR_VERSION 33 56 + #define QED_MINOR_VERSION 37 57 57 #define QED_REVISION_VERSION 0 58 58 #define QED_ENGINEERING_VERSION 20 59 59
+5 -3
drivers/net/ethernet/qlogic/qed/qed_l2.c
··· 2216 2216 u16 num_queues = 0; 2217 2217 2218 2218 /* Since the feature controls only queue-zones, 2219 - * make sure we have the contexts [rx, tx, xdp] to 2219 + * make sure we have the contexts [rx, xdp, tcs] to 2220 2220 * match. 2221 2221 */ 2222 2222 for_each_hwfn(cdev, i) { ··· 2226 2226 u16 cids; 2227 2227 2228 2228 cids = hwfn->pf_params.eth_pf_params.num_cons; 2229 - num_queues += min_t(u16, l2_queues, cids / 3); 2229 + cids /= (2 + info->num_tc); 2230 + num_queues += min_t(u16, l2_queues, cids); 2230 2231 } 2231 2232 2232 2233 /* queues might theoretically be >256, but interrupts' ··· 2871 2870 p_hwfn = p_cid->p_owner; 2872 2871 rc = qed_get_queue_coalesce(p_hwfn, coal, handle); 2873 2872 if (rc) 2874 - DP_NOTICE(p_hwfn, "Unable to read queue coalescing\n"); 2873 + DP_VERBOSE(cdev, QED_MSG_DEBUG, 2874 + "Unable to read queue coalescing\n"); 2875 2875 2876 2876 return rc; 2877 2877 }
+1
drivers/net/ethernet/qlogic/qed/qed_sp.h
··· 382 382 * @param p_hwfn 383 383 */ 384 384 void qed_consq_free(struct qed_hwfn *p_hwfn); 385 + int qed_spq_pend_post(struct qed_hwfn *p_hwfn); 385 386 386 387 /** 387 388 * @file
+3
drivers/net/ethernet/qlogic/qed/qed_sp_commands.c
··· 604 604 605 605 p_ent->ramrod.pf_update.update_mf_vlan_flag = true; 606 606 p_ent->ramrod.pf_update.mf_vlan = cpu_to_le16(p_hwfn->hw_info.ovlan); 607 + if (test_bit(QED_MF_UFP_SPECIFIC, &p_hwfn->cdev->mf_bits)) 608 + p_ent->ramrod.pf_update.mf_vlan |= 609 + cpu_to_le16(((u16)p_hwfn->ufp_info.tc << 13)); 607 610 608 611 return qed_spq_post(p_hwfn, p_ent, NULL); 609 612 }
+7 -8
drivers/net/ethernet/qlogic/qed/qed_spq.c
··· 397 397 398 398 qed_eq_prod_update(p_hwfn, qed_chain_get_prod_idx(p_chain)); 399 399 400 + /* Attempt to post pending requests */ 401 + spin_lock_bh(&p_hwfn->p_spq->lock); 402 + rc = qed_spq_pend_post(p_hwfn); 403 + spin_unlock_bh(&p_hwfn->p_spq->lock); 404 + 400 405 return rc; 401 406 } 402 407 ··· 772 767 return 0; 773 768 } 774 769 775 - static int qed_spq_pend_post(struct qed_hwfn *p_hwfn) 770 + int qed_spq_pend_post(struct qed_hwfn *p_hwfn) 776 771 { 777 772 struct qed_spq *p_spq = p_hwfn->p_spq; 778 773 struct qed_spq_entry *p_ent = NULL; ··· 910 905 struct qed_spq_entry *p_ent = NULL; 911 906 struct qed_spq_entry *tmp; 912 907 struct qed_spq_entry *found = NULL; 913 - int rc; 914 908 915 909 if (!p_hwfn) 916 910 return -EINVAL; ··· 967 963 */ 968 964 qed_spq_return_entry(p_hwfn, found); 969 965 970 - /* Attempt to post pending requests */ 971 - spin_lock_bh(&p_spq->lock); 972 - rc = qed_spq_pend_post(p_hwfn); 973 - spin_unlock_bh(&p_spq->lock); 974 - 975 - return rc; 966 + return 0; 976 967 } 977 968 978 969 int qed_consq_alloc(struct qed_hwfn *p_hwfn)
+4 -1
drivers/net/ethernet/qlogic/qede/qede.h
··· 56 56 #include <net/tc_act/tc_gact.h> 57 57 58 58 #define QEDE_MAJOR_VERSION 8 59 - #define QEDE_MINOR_VERSION 33 59 + #define QEDE_MINOR_VERSION 37 60 60 #define QEDE_REVISION_VERSION 0 61 61 #define QEDE_ENGINEERING_VERSION 20 62 62 #define DRV_MODULE_VERSION __stringify(QEDE_MAJOR_VERSION) "." \ ··· 494 494 495 495 /* Datapath functions definition */ 496 496 netdev_tx_t qede_start_xmit(struct sk_buff *skb, struct net_device *ndev); 497 + u16 qede_select_queue(struct net_device *dev, struct sk_buff *skb, 498 + struct net_device *sb_dev, 499 + select_queue_fallback_t fallback); 497 500 netdev_features_t qede_features_check(struct sk_buff *skb, 498 501 struct net_device *dev, 499 502 netdev_features_t features);
+13
drivers/net/ethernet/qlogic/qede/qede_fp.c
··· 1695 1695 return NETDEV_TX_OK; 1696 1696 } 1697 1697 1698 + u16 qede_select_queue(struct net_device *dev, struct sk_buff *skb, 1699 + struct net_device *sb_dev, 1700 + select_queue_fallback_t fallback) 1701 + { 1702 + struct qede_dev *edev = netdev_priv(dev); 1703 + int total_txq; 1704 + 1705 + total_txq = QEDE_TSS_COUNT(edev) * edev->dev_info.num_tc; 1706 + 1707 + return QEDE_TSS_COUNT(edev) ? 1708 + fallback(dev, skb, NULL) % total_txq : 0; 1709 + } 1710 + 1698 1711 /* 8B udp header + 8B base tunnel header + 32B option length */ 1699 1712 #define QEDE_MAX_TUN_HDR_LEN 48 1700 1713
+3
drivers/net/ethernet/qlogic/qede/qede_main.c
··· 631 631 .ndo_open = qede_open, 632 632 .ndo_stop = qede_close, 633 633 .ndo_start_xmit = qede_start_xmit, 634 + .ndo_select_queue = qede_select_queue, 634 635 .ndo_set_rx_mode = qede_set_rx_mode, 635 636 .ndo_set_mac_address = qede_set_mac_addr, 636 637 .ndo_validate_addr = eth_validate_addr, ··· 667 666 .ndo_open = qede_open, 668 667 .ndo_stop = qede_close, 669 668 .ndo_start_xmit = qede_start_xmit, 669 + .ndo_select_queue = qede_select_queue, 670 670 .ndo_set_rx_mode = qede_set_rx_mode, 671 671 .ndo_set_mac_address = qede_set_mac_addr, 672 672 .ndo_validate_addr = eth_validate_addr, ··· 686 684 .ndo_open = qede_open, 687 685 .ndo_stop = qede_close, 688 686 .ndo_start_xmit = qede_start_xmit, 687 + .ndo_select_queue = qede_select_queue, 689 688 .ndo_set_rx_mode = qede_set_rx_mode, 690 689 .ndo_set_mac_address = qede_set_mac_addr, 691 690 .ndo_validate_addr = eth_validate_addr,
+1 -1
drivers/net/ethernet/smsc/epic100.c
··· 1037 1037 skb = ep->tx_skbuff[entry]; 1038 1038 pci_unmap_single(ep->pci_dev, ep->tx_ring[entry].bufaddr, 1039 1039 skb->len, PCI_DMA_TODEVICE); 1040 - dev_kfree_skb_irq(skb); 1040 + dev_consume_skb_irq(skb); 1041 1041 ep->tx_skbuff[entry] = NULL; 1042 1042 } 1043 1043
+10 -4
drivers/net/ethernet/stmicro/stmmac/stmmac_ethtool.c
··· 721 721 { 722 722 unsigned long clk = clk_get_rate(priv->plat->stmmac_clk); 723 723 724 - if (!clk) 725 - return 0; 724 + if (!clk) { 725 + clk = priv->plat->clk_ref_rate; 726 + if (!clk) 727 + return 0; 728 + } 726 729 727 730 return (usec * (clk / 1000000)) / 256; 728 731 } ··· 734 731 { 735 732 unsigned long clk = clk_get_rate(priv->plat->stmmac_clk); 736 733 737 - if (!clk) 738 - return 0; 734 + if (!clk) { 735 + clk = priv->plat->clk_ref_rate; 736 + if (!clk) 737 + return 0; 738 + } 739 739 740 740 return (riwt * 256) / (clk / 1000000); 741 741 }
+13 -4
drivers/net/ethernet/stmicro/stmmac/stmmac_main.c
··· 3023 3023 3024 3024 tx_q = &priv->tx_queue[queue]; 3025 3025 3026 + if (priv->tx_path_in_lpi_mode) 3027 + stmmac_disable_eee_mode(priv); 3028 + 3026 3029 /* Manage oversized TCP frames for GMAC4 device */ 3027 3030 if (skb_is_gso(skb) && priv->tso) { 3028 - if (skb_shinfo(skb)->gso_type & (SKB_GSO_TCPV4 | SKB_GSO_TCPV6)) 3031 + if (skb_shinfo(skb)->gso_type & (SKB_GSO_TCPV4 | SKB_GSO_TCPV6)) { 3032 + /* 3033 + * There is no way to determine the number of TSO 3034 + * capable Queues. Let's use always the Queue 0 3035 + * because if TSO is supported then at least this 3036 + * one will be capable. 3037 + */ 3038 + skb_set_queue_mapping(skb, 0); 3039 + 3029 3040 return stmmac_tso_xmit(skb, dev); 3041 + } 3030 3042 } 3031 3043 3032 3044 if (unlikely(stmmac_tx_avail(priv, queue) < nfrags + 1)) { ··· 3052 3040 } 3053 3041 return NETDEV_TX_BUSY; 3054 3042 } 3055 - 3056 - if (priv->tx_path_in_lpi_mode) 3057 - stmmac_disable_eee_mode(priv); 3058 3043 3059 3044 entry = tx_q->cur_tx; 3060 3045 first_entry = entry;
+1 -1
drivers/net/ethernet/sun/cassini.c
··· 1898 1898 cp->net_stats[ring].tx_packets++; 1899 1899 cp->net_stats[ring].tx_bytes += skb->len; 1900 1900 spin_unlock(&cp->stat_lock[ring]); 1901 - dev_kfree_skb_irq(skb); 1901 + dev_consume_skb_irq(skb); 1902 1902 } 1903 1903 cp->tx_old[ring] = entry; 1904 1904
+1 -1
drivers/net/ethernet/sun/sunbmac.c
··· 781 781 782 782 DTX(("skb(%p) ", skb)); 783 783 bp->tx_skbs[elem] = NULL; 784 - dev_kfree_skb_irq(skb); 784 + dev_consume_skb_irq(skb); 785 785 786 786 elem = NEXT_TX(elem); 787 787 }
+1 -1
drivers/net/ethernet/sun/sunhme.c
··· 1962 1962 this = &txbase[elem]; 1963 1963 } 1964 1964 1965 - dev_kfree_skb_irq(skb); 1965 + dev_consume_skb_irq(skb); 1966 1966 dev->stats.tx_packets++; 1967 1967 } 1968 1968 hp->tx_old = elem;
+1 -1
drivers/net/ethernet/tehuti/tehuti.c
··· 1739 1739 tx_level -= db->rptr->len; /* '-' koz len is negative */ 1740 1740 1741 1741 /* now should come skb pointer - free it */ 1742 - dev_kfree_skb_irq(db->rptr->addr.skb); 1742 + dev_consume_skb_irq(db->rptr->addr.skb); 1743 1743 bdx_tx_db_inc_rptr(db); 1744 1744 } 1745 1745
+1 -1
drivers/net/ethernet/via/via-velocity.c
··· 1740 1740 dma_unmap_single(vptr->dev, tdinfo->skb_dma[i], 1741 1741 le16_to_cpu(pktlen), DMA_TO_DEVICE); 1742 1742 } 1743 - dev_kfree_skb_irq(skb); 1743 + dev_consume_skb_irq(skb); 1744 1744 tdinfo->skb = NULL; 1745 1745 } 1746 1746
+1 -1
drivers/net/fddi/defxx.c
··· 3512 3512 bp->descr_block_virt->xmt_data[comp].long_1, 3513 3513 p_xmt_drv_descr->p_skb->len, 3514 3514 DMA_TO_DEVICE); 3515 - dev_kfree_skb_irq(p_xmt_drv_descr->p_skb); 3515 + dev_consume_skb_irq(p_xmt_drv_descr->p_skb); 3516 3516 3517 3517 /* 3518 3518 * Move to start of next packet by updating completion index
+7 -3
drivers/net/geneve.c
··· 1512 1512 } 1513 1513 #if IS_ENABLED(CONFIG_IPV6) 1514 1514 case AF_INET6: { 1515 - struct rt6_info *rt = rt6_lookup(geneve->net, 1516 - &info->key.u.ipv6.dst, NULL, 0, 1517 - NULL, 0); 1515 + struct rt6_info *rt; 1516 + 1517 + if (!__in6_dev_get(dev)) 1518 + break; 1519 + 1520 + rt = rt6_lookup(geneve->net, &info->key.u.ipv6.dst, NULL, 0, 1521 + NULL, 0); 1518 1522 1519 1523 if (rt && rt->dst.dev) 1520 1524 ldev_mtu = rt->dst.dev->mtu - GENEVE_IPV6_HLEN;
+3 -3
drivers/net/ieee802154/mcr20a.c
··· 905 905 } 906 906 break; 907 907 case (DAR_IRQSTS1_RXIRQ | DAR_IRQSTS1_SEQIRQ): 908 - /* rx is starting */ 909 - dev_dbg(printdev(lp), "RX is starting\n"); 910 - mcr20a_handle_rx(lp); 908 + /* rx is starting */ 909 + dev_dbg(printdev(lp), "RX is starting\n"); 910 + mcr20a_handle_rx(lp); 911 911 break; 912 912 case (DAR_IRQSTS1_RXIRQ | DAR_IRQSTS1_TXIRQ | DAR_IRQSTS1_SEQIRQ): 913 913 if (lp->is_tx) {
+3 -3
drivers/net/ipvlan/ipvlan_main.c
··· 100 100 err = ipvlan_register_nf_hook(read_pnet(&port->pnet)); 101 101 if (!err) { 102 102 mdev->l3mdev_ops = &ipvl_l3mdev_ops; 103 - mdev->priv_flags |= IFF_L3MDEV_MASTER; 103 + mdev->priv_flags |= IFF_L3MDEV_RX_HANDLER; 104 104 } else 105 105 goto fail; 106 106 } else if (port->mode == IPVLAN_MODE_L3S) { 107 107 /* Old mode was L3S */ 108 - mdev->priv_flags &= ~IFF_L3MDEV_MASTER; 108 + mdev->priv_flags &= ~IFF_L3MDEV_RX_HANDLER; 109 109 ipvlan_unregister_nf_hook(read_pnet(&port->pnet)); 110 110 mdev->l3mdev_ops = NULL; 111 111 } ··· 167 167 struct sk_buff *skb; 168 168 169 169 if (port->mode == IPVLAN_MODE_L3S) { 170 - dev->priv_flags &= ~IFF_L3MDEV_MASTER; 170 + dev->priv_flags &= ~IFF_L3MDEV_RX_HANDLER; 171 171 ipvlan_unregister_nf_hook(dev_net(dev)); 172 172 dev->l3mdev_ops = NULL; 173 173 }
+10 -3
drivers/net/phy/dp83640.c
··· 898 898 struct phy_txts *phy_txts) 899 899 { 900 900 struct skb_shared_hwtstamps shhwtstamps; 901 + struct dp83640_skb_info *skb_info; 901 902 struct sk_buff *skb; 902 - u64 ns; 903 903 u8 overflow; 904 + u64 ns; 904 905 905 906 /* We must already have the skb that triggered this. */ 906 - 907 + again: 907 908 skb = skb_dequeue(&dp83640->tx_queue); 908 - 909 909 if (!skb) { 910 910 pr_debug("have timestamp but tx_queue empty\n"); 911 911 return; ··· 919 919 skb = skb_dequeue(&dp83640->tx_queue); 920 920 } 921 921 return; 922 + } 923 + skb_info = (struct dp83640_skb_info *)skb->cb; 924 + if (time_after(jiffies, skb_info->tmo)) { 925 + kfree_skb(skb); 926 + goto again; 922 927 } 923 928 924 929 ns = phy2txts(phy_txts); ··· 1477 1472 static void dp83640_txtstamp(struct phy_device *phydev, 1478 1473 struct sk_buff *skb, int type) 1479 1474 { 1475 + struct dp83640_skb_info *skb_info = (struct dp83640_skb_info *)skb->cb; 1480 1476 struct dp83640_private *dp83640 = phydev->priv; 1481 1477 1482 1478 switch (dp83640->hwts_tx_en) { ··· 1490 1484 /* fall through */ 1491 1485 case HWTSTAMP_TX_ON: 1492 1486 skb_shinfo(skb)->tx_flags |= SKBTX_IN_PROGRESS; 1487 + skb_info->tmo = jiffies + SKB_TIMESTAMP_TIMEOUT; 1493 1488 skb_queue_tail(&dp83640->tx_queue, skb); 1494 1489 break; 1495 1490
-16
drivers/net/phy/marvell.c
··· 847 847 848 848 /* SGMII-to-Copper mode initialization */ 849 849 if (phydev->interface == PHY_INTERFACE_MODE_SGMII) { 850 - 851 850 /* Select page 18 */ 852 851 err = marvell_set_page(phydev, 18); 853 852 if (err < 0) ··· 869 870 err = marvell_set_page(phydev, MII_MARVELL_COPPER_PAGE); 870 871 if (err < 0) 871 872 return err; 872 - 873 - /* There appears to be a bug in the 88e1512 when used in 874 - * SGMII to copper mode, where the AN advertisement register 875 - * clears the pause bits each time a negotiation occurs. 876 - * This means we can never be truely sure what was advertised, 877 - * so disable Pause support. 878 - */ 879 - linkmode_clear_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, 880 - phydev->supported); 881 - linkmode_clear_bit(ETHTOOL_LINK_MODE_Pause_BIT, 882 - phydev->supported); 883 - linkmode_clear_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, 884 - phydev->advertising); 885 - linkmode_clear_bit(ETHTOOL_LINK_MODE_Pause_BIT, 886 - phydev->advertising); 887 873 } 888 874 889 875 return m88e1318_config_init(phydev);
+1 -2
drivers/net/tun.c
··· 866 866 if (rtnl_dereference(tun->xdp_prog)) 867 867 sock_set_flag(&tfile->sk, SOCK_XDP); 868 868 869 - tun_set_real_num_queues(tun); 870 - 871 869 /* device is allowed to go away first, so no need to hold extra 872 870 * refcnt. 873 871 */ ··· 877 879 rcu_assign_pointer(tfile->tun, tun); 878 880 rcu_assign_pointer(tun->tfiles[tun->numqueues], tfile); 879 881 tun->numqueues++; 882 + tun_set_real_num_queues(tun); 880 883 out: 881 884 return err; 882 885 }
+124 -47
drivers/net/virtio_net.c
··· 57 57 #define VIRTIO_XDP_TX BIT(0) 58 58 #define VIRTIO_XDP_REDIR BIT(1) 59 59 60 + #define VIRTIO_XDP_FLAG BIT(0) 61 + 60 62 /* RX packet size EWMA. The average packet size is used to determine the packet 61 63 * buffer size when refilling RX rings. As the entire RX ring may be refilled 62 64 * at once, the weight is chosen so that the EWMA will be insensitive to short- ··· 253 251 */ 254 252 char padding[4]; 255 253 }; 254 + 255 + static bool is_xdp_frame(void *ptr) 256 + { 257 + return (unsigned long)ptr & VIRTIO_XDP_FLAG; 258 + } 259 + 260 + static void *xdp_to_ptr(struct xdp_frame *ptr) 261 + { 262 + return (void *)((unsigned long)ptr | VIRTIO_XDP_FLAG); 263 + } 264 + 265 + static struct xdp_frame *ptr_to_xdp(void *ptr) 266 + { 267 + return (struct xdp_frame *)((unsigned long)ptr & ~VIRTIO_XDP_FLAG); 268 + } 256 269 257 270 /* Converting between virtqueue no. and kernel tx/rx queue no. 258 271 * 0:rx0 1:tx0 2:rx1 3:tx1 ... 2N:rxN 2N+1:txN 2N+2:cvq ··· 479 462 480 463 sg_init_one(sq->sg, xdpf->data, xdpf->len); 481 464 482 - err = virtqueue_add_outbuf(sq->vq, sq->sg, 1, xdpf, GFP_ATOMIC); 465 + err = virtqueue_add_outbuf(sq->vq, sq->sg, 1, xdp_to_ptr(xdpf), 466 + GFP_ATOMIC); 483 467 if (unlikely(err)) 484 468 return -ENOSPC; /* Caller handle free/refcnt */ 485 469 ··· 500 482 { 501 483 struct virtnet_info *vi = netdev_priv(dev); 502 484 struct receive_queue *rq = vi->rq; 503 - struct xdp_frame *xdpf_sent; 504 485 struct bpf_prog *xdp_prog; 505 486 struct send_queue *sq; 506 487 unsigned int len; 488 + int packets = 0; 489 + int bytes = 0; 507 490 int drops = 0; 508 491 int kicks = 0; 509 492 int ret, err; 493 + void *ptr; 510 494 int i; 495 + 496 + /* Only allow ndo_xdp_xmit if XDP is loaded on dev, as this 497 + * indicate XDP resources have been successfully allocated. 498 + */ 499 + xdp_prog = rcu_dereference(rq->xdp_prog); 500 + if (!xdp_prog) 501 + return -ENXIO; 511 502 512 503 sq = virtnet_xdp_sq(vi); 513 504 ··· 526 499 goto out; 527 500 } 528 501 529 - /* Only allow ndo_xdp_xmit if XDP is loaded on dev, as this 530 - * indicate XDP resources have been successfully allocated. 531 - */ 532 - xdp_prog = rcu_dereference(rq->xdp_prog); 533 - if (!xdp_prog) { 534 - ret = -ENXIO; 535 - drops = n; 536 - goto out; 537 - } 538 - 539 502 /* Free up any pending old buffers before queueing new ones. */ 540 - while ((xdpf_sent = virtqueue_get_buf(sq->vq, &len)) != NULL) 541 - xdp_return_frame(xdpf_sent); 503 + while ((ptr = virtqueue_get_buf(sq->vq, &len)) != NULL) { 504 + if (likely(is_xdp_frame(ptr))) { 505 + struct xdp_frame *frame = ptr_to_xdp(ptr); 506 + 507 + bytes += frame->len; 508 + xdp_return_frame(frame); 509 + } else { 510 + struct sk_buff *skb = ptr; 511 + 512 + bytes += skb->len; 513 + napi_consume_skb(skb, false); 514 + } 515 + packets++; 516 + } 542 517 543 518 for (i = 0; i < n; i++) { 544 519 struct xdp_frame *xdpf = frames[i]; ··· 559 530 } 560 531 out: 561 532 u64_stats_update_begin(&sq->stats.syncp); 533 + sq->stats.bytes += bytes; 534 + sq->stats.packets += packets; 562 535 sq->stats.xdp_tx += n; 563 536 sq->stats.xdp_tx_drops += drops; 564 537 sq->stats.kicks += kicks; ··· 1363 1332 1364 1333 static void free_old_xmit_skbs(struct send_queue *sq, bool in_napi) 1365 1334 { 1366 - struct sk_buff *skb; 1367 1335 unsigned int len; 1368 1336 unsigned int packets = 0; 1369 1337 unsigned int bytes = 0; 1338 + void *ptr; 1370 1339 1371 - while ((skb = virtqueue_get_buf(sq->vq, &len)) != NULL) { 1372 - pr_debug("Sent skb %p\n", skb); 1340 + while ((ptr = virtqueue_get_buf(sq->vq, &len)) != NULL) { 1341 + if (likely(!is_xdp_frame(ptr))) { 1342 + struct sk_buff *skb = ptr; 1373 1343 1374 - bytes += skb->len; 1344 + pr_debug("Sent skb %p\n", skb); 1345 + 1346 + bytes += skb->len; 1347 + napi_consume_skb(skb, in_napi); 1348 + } else { 1349 + struct xdp_frame *frame = ptr_to_xdp(ptr); 1350 + 1351 + bytes += frame->len; 1352 + xdp_return_frame(frame); 1353 + } 1375 1354 packets++; 1376 - 1377 - napi_consume_skb(skb, in_napi); 1378 1355 } 1379 1356 1380 1357 /* Avoid overhead when no packets have been processed ··· 1397 1358 u64_stats_update_end(&sq->stats.syncp); 1398 1359 } 1399 1360 1361 + static bool is_xdp_raw_buffer_queue(struct virtnet_info *vi, int q) 1362 + { 1363 + if (q < (vi->curr_queue_pairs - vi->xdp_queue_pairs)) 1364 + return false; 1365 + else if (q < vi->curr_queue_pairs) 1366 + return true; 1367 + else 1368 + return false; 1369 + } 1370 + 1400 1371 static void virtnet_poll_cleantx(struct receive_queue *rq) 1401 1372 { 1402 1373 struct virtnet_info *vi = rq->vq->vdev->priv; ··· 1414 1365 struct send_queue *sq = &vi->sq[index]; 1415 1366 struct netdev_queue *txq = netdev_get_tx_queue(vi->dev, index); 1416 1367 1417 - if (!sq->napi.weight) 1368 + if (!sq->napi.weight || is_xdp_raw_buffer_queue(vi, index)) 1418 1369 return; 1419 1370 1420 1371 if (__netif_tx_trylock(txq)) { ··· 1491 1442 { 1492 1443 struct send_queue *sq = container_of(napi, struct send_queue, napi); 1493 1444 struct virtnet_info *vi = sq->vq->vdev->priv; 1494 - struct netdev_queue *txq = netdev_get_tx_queue(vi->dev, vq2txq(sq->vq)); 1445 + unsigned int index = vq2txq(sq->vq); 1446 + struct netdev_queue *txq; 1495 1447 1448 + if (unlikely(is_xdp_raw_buffer_queue(vi, index))) { 1449 + /* We don't need to enable cb for XDP */ 1450 + napi_complete_done(napi, 0); 1451 + return 0; 1452 + } 1453 + 1454 + txq = netdev_get_tx_queue(vi->dev, index); 1496 1455 __netif_tx_lock(txq, raw_smp_processor_id()); 1497 1456 free_old_xmit_skbs(sq, true); 1498 1457 __netif_tx_unlock(txq); ··· 2452 2395 return -ENOMEM; 2453 2396 } 2454 2397 2398 + old_prog = rtnl_dereference(vi->rq[0].xdp_prog); 2399 + if (!prog && !old_prog) 2400 + return 0; 2401 + 2455 2402 if (prog) { 2456 2403 prog = bpf_prog_add(prog, vi->max_queue_pairs - 1); 2457 2404 if (IS_ERR(prog)) ··· 2463 2402 } 2464 2403 2465 2404 /* Make sure NAPI is not using any XDP TX queues for RX. */ 2466 - if (netif_running(dev)) 2467 - for (i = 0; i < vi->max_queue_pairs; i++) 2405 + if (netif_running(dev)) { 2406 + for (i = 0; i < vi->max_queue_pairs; i++) { 2468 2407 napi_disable(&vi->rq[i].napi); 2408 + virtnet_napi_tx_disable(&vi->sq[i].napi); 2409 + } 2410 + } 2469 2411 2470 - netif_set_real_num_rx_queues(dev, curr_qp + xdp_qp); 2412 + if (!prog) { 2413 + for (i = 0; i < vi->max_queue_pairs; i++) { 2414 + rcu_assign_pointer(vi->rq[i].xdp_prog, prog); 2415 + if (i == 0) 2416 + virtnet_restore_guest_offloads(vi); 2417 + } 2418 + synchronize_net(); 2419 + } 2420 + 2471 2421 err = _virtnet_set_queues(vi, curr_qp + xdp_qp); 2472 2422 if (err) 2473 2423 goto err; 2424 + netif_set_real_num_rx_queues(dev, curr_qp + xdp_qp); 2474 2425 vi->xdp_queue_pairs = xdp_qp; 2475 2426 2476 - for (i = 0; i < vi->max_queue_pairs; i++) { 2477 - old_prog = rtnl_dereference(vi->rq[i].xdp_prog); 2478 - rcu_assign_pointer(vi->rq[i].xdp_prog, prog); 2479 - if (i == 0) { 2480 - if (!old_prog) 2427 + if (prog) { 2428 + for (i = 0; i < vi->max_queue_pairs; i++) { 2429 + rcu_assign_pointer(vi->rq[i].xdp_prog, prog); 2430 + if (i == 0 && !old_prog) 2481 2431 virtnet_clear_guest_offloads(vi); 2482 - if (!prog) 2483 - virtnet_restore_guest_offloads(vi); 2484 2432 } 2433 + } 2434 + 2435 + for (i = 0; i < vi->max_queue_pairs; i++) { 2485 2436 if (old_prog) 2486 2437 bpf_prog_put(old_prog); 2487 - if (netif_running(dev)) 2438 + if (netif_running(dev)) { 2488 2439 virtnet_napi_enable(vi->rq[i].vq, &vi->rq[i].napi); 2440 + virtnet_napi_tx_enable(vi, vi->sq[i].vq, 2441 + &vi->sq[i].napi); 2442 + } 2489 2443 } 2490 2444 2491 2445 return 0; 2492 2446 2493 2447 err: 2494 - for (i = 0; i < vi->max_queue_pairs; i++) 2495 - virtnet_napi_enable(vi->rq[i].vq, &vi->rq[i].napi); 2448 + if (!prog) { 2449 + virtnet_clear_guest_offloads(vi); 2450 + for (i = 0; i < vi->max_queue_pairs; i++) 2451 + rcu_assign_pointer(vi->rq[i].xdp_prog, old_prog); 2452 + } 2453 + 2454 + if (netif_running(dev)) { 2455 + for (i = 0; i < vi->max_queue_pairs; i++) { 2456 + virtnet_napi_enable(vi->rq[i].vq, &vi->rq[i].napi); 2457 + virtnet_napi_tx_enable(vi, vi->sq[i].vq, 2458 + &vi->sq[i].napi); 2459 + } 2460 + } 2496 2461 if (prog) 2497 2462 bpf_prog_sub(prog, vi->max_queue_pairs - 1); 2498 2463 return err; ··· 2700 2613 put_page(vi->rq[i].alloc_frag.page); 2701 2614 } 2702 2615 2703 - static bool is_xdp_raw_buffer_queue(struct virtnet_info *vi, int q) 2704 - { 2705 - if (q < (vi->curr_queue_pairs - vi->xdp_queue_pairs)) 2706 - return false; 2707 - else if (q < vi->curr_queue_pairs) 2708 - return true; 2709 - else 2710 - return false; 2711 - } 2712 - 2713 2616 static void free_unused_bufs(struct virtnet_info *vi) 2714 2617 { 2715 2618 void *buf; ··· 2708 2631 for (i = 0; i < vi->max_queue_pairs; i++) { 2709 2632 struct virtqueue *vq = vi->sq[i].vq; 2710 2633 while ((buf = virtqueue_detach_unused_buf(vq)) != NULL) { 2711 - if (!is_xdp_raw_buffer_queue(vi, i)) 2634 + if (!is_xdp_frame(buf)) 2712 2635 dev_kfree_skb(buf); 2713 2636 else 2714 - put_page(virt_to_head_page(buf)); 2637 + xdp_return_frame(ptr_to_xdp(buf)); 2715 2638 } 2716 2639 } 2717 2640
+1 -1
drivers/net/wan/dscc4.c
··· 1575 1575 dev->stats.tx_packets++; 1576 1576 dev->stats.tx_bytes += skb->len; 1577 1577 } 1578 - dev_kfree_skb_irq(skb); 1578 + dev_consume_skb_irq(skb); 1579 1579 dpriv->tx_skbuff[cur] = NULL; 1580 1580 ++dpriv->tx_dirty; 1581 1581 } else {
+1 -1
drivers/net/wan/fsl_ucc_hdlc.c
··· 482 482 memset(priv->tx_buffer + 483 483 (be32_to_cpu(bd->buf) - priv->dma_tx_addr), 484 484 0, skb->len); 485 - dev_kfree_skb_irq(skb); 485 + dev_consume_skb_irq(skb); 486 486 487 487 priv->tx_skbuff[priv->skb_dirtytx] = NULL; 488 488 priv->skb_dirtytx =
+1 -1
drivers/net/wireless/ath/ath10k/core.c
··· 548 548 { 549 549 .id = WCN3990_HW_1_0_DEV_VERSION, 550 550 .dev_id = 0, 551 - .bus = ATH10K_BUS_PCI, 551 + .bus = ATH10K_BUS_SNOC, 552 552 .name = "wcn3990 hw1.0", 553 553 .continuous_frag_desc = true, 554 554 .tx_chain_mask = 0x7,
+2 -1
drivers/net/wireless/intel/iwlwifi/Kconfig
··· 1 1 config IWLWIFI 2 2 tristate "Intel Wireless WiFi Next Gen AGN - Wireless-N/Advanced-N/Ultimate-N (iwlwifi) " 3 - depends on PCI && HAS_IOMEM 3 + depends on PCI && HAS_IOMEM && CFG80211 4 4 select FW_LOADER 5 5 ---help--- 6 6 Select to build the driver supporting the: ··· 47 47 config IWLWIFI_LEDS 48 48 bool 49 49 depends on LEDS_CLASS=y || LEDS_CLASS=IWLWIFI 50 + depends on IWLMVM || IWLDVM 50 51 select LEDS_TRIGGERS 51 52 select MAC80211_LEDS 52 53 default y
+19 -21
drivers/net/wireless/mediatek/mt76/mt76x0/eeprom.c
··· 212 212 mt76x02_add_rate_power_offset(t, delta); 213 213 } 214 214 215 - void mt76x0_get_power_info(struct mt76x02_dev *dev, u8 *info) 215 + void mt76x0_get_power_info(struct mt76x02_dev *dev, s8 *tp) 216 216 { 217 217 struct mt76x0_chan_map { 218 218 u8 chan; 219 219 u8 offset; 220 220 } chan_map[] = { 221 - { 2, 0 }, { 4, 1 }, { 6, 2 }, { 8, 3 }, 222 - { 10, 4 }, { 12, 5 }, { 14, 6 }, { 38, 0 }, 223 - { 44, 1 }, { 48, 2 }, { 54, 3 }, { 60, 4 }, 224 - { 64, 5 }, { 102, 6 }, { 108, 7 }, { 112, 8 }, 225 - { 118, 9 }, { 124, 10 }, { 128, 11 }, { 134, 12 }, 226 - { 140, 13 }, { 151, 14 }, { 157, 15 }, { 161, 16 }, 227 - { 167, 17 }, { 171, 18 }, { 173, 19 }, 221 + { 2, 0 }, { 4, 2 }, { 6, 4 }, { 8, 6 }, 222 + { 10, 8 }, { 12, 10 }, { 14, 12 }, { 38, 0 }, 223 + { 44, 2 }, { 48, 4 }, { 54, 6 }, { 60, 8 }, 224 + { 64, 10 }, { 102, 12 }, { 108, 14 }, { 112, 16 }, 225 + { 118, 18 }, { 124, 20 }, { 128, 22 }, { 134, 24 }, 226 + { 140, 26 }, { 151, 28 }, { 157, 30 }, { 161, 32 }, 227 + { 167, 34 }, { 171, 36 }, { 175, 38 }, 228 228 }; 229 229 struct ieee80211_channel *chan = dev->mt76.chandef.chan; 230 230 u8 offset, addr; 231 + int i, idx = 0; 231 232 u16 data; 232 - int i; 233 233 234 234 if (mt76x0_tssi_enabled(dev)) { 235 235 s8 target_power; ··· 239 239 else 240 240 data = mt76x02_eeprom_get(dev, MT_EE_2G_TARGET_POWER); 241 241 target_power = (data & 0xff) - dev->mt76.rate_power.ofdm[7]; 242 - info[0] = target_power + mt76x0_get_delta(dev); 243 - info[1] = 0; 242 + *tp = target_power + mt76x0_get_delta(dev); 244 243 245 244 return; 246 245 } 247 246 248 247 for (i = 0; i < ARRAY_SIZE(chan_map); i++) { 249 - if (chan_map[i].chan <= chan->hw_value) { 248 + if (chan->hw_value <= chan_map[i].chan) { 249 + idx = (chan->hw_value == chan_map[i].chan); 250 250 offset = chan_map[i].offset; 251 251 break; 252 252 } ··· 258 258 addr = MT_EE_TX_POWER_DELTA_BW80 + offset; 259 259 } else { 260 260 switch (chan->hw_value) { 261 + case 42: 262 + offset = 2; 263 + break; 261 264 case 58: 262 265 offset = 8; 263 266 break; 264 267 case 106: 265 268 offset = 14; 266 269 break; 267 - case 112: 270 + case 122: 268 271 offset = 20; 269 272 break; 270 273 case 155: ··· 280 277 } 281 278 282 279 data = mt76x02_eeprom_get(dev, addr); 283 - 284 - info[0] = data; 285 - if (!info[0] || info[0] > 0x3f) 286 - info[0] = 5; 287 - 288 - info[1] = data >> 8; 289 - if (!info[1] || info[1] > 0x3f) 290 - info[1] = 5; 280 + *tp = data >> (8 * idx); 281 + if (*tp < 0 || *tp > 0x3f) 282 + *tp = 5; 291 283 } 292 284 293 285 static int mt76x0_check_eeprom(struct mt76x02_dev *dev)
+1 -1
drivers/net/wireless/mediatek/mt76/mt76x0/eeprom.h
··· 26 26 int mt76x0_eeprom_init(struct mt76x02_dev *dev); 27 27 void mt76x0_read_rx_gain(struct mt76x02_dev *dev); 28 28 void mt76x0_get_tx_power_per_rate(struct mt76x02_dev *dev); 29 - void mt76x0_get_power_info(struct mt76x02_dev *dev, u8 *info); 29 + void mt76x0_get_power_info(struct mt76x02_dev *dev, s8 *tp); 30 30 31 31 static inline s8 s6_to_s8(u32 val) 32 32 {
+5 -5
drivers/net/wireless/mediatek/mt76/mt76x0/phy.c
··· 845 845 void mt76x0_phy_set_txpower(struct mt76x02_dev *dev) 846 846 { 847 847 struct mt76_rate_power *t = &dev->mt76.rate_power; 848 - u8 info[2]; 848 + s8 info; 849 849 850 850 mt76x0_get_tx_power_per_rate(dev); 851 - mt76x0_get_power_info(dev, info); 851 + mt76x0_get_power_info(dev, &info); 852 852 853 - mt76x02_add_rate_power_offset(t, info[0]); 853 + mt76x02_add_rate_power_offset(t, info); 854 854 mt76x02_limit_rate_power(t, dev->mt76.txpower_conf); 855 855 dev->mt76.txpower_cur = mt76x02_get_max_rate_power(t); 856 - mt76x02_add_rate_power_offset(t, -info[0]); 856 + mt76x02_add_rate_power_offset(t, -info); 857 857 858 - mt76x02_phy_set_txpower(dev, info[0], info[1]); 858 + mt76x02_phy_set_txpower(dev, info, info); 859 859 } 860 860 861 861 void mt76x0_phy_calibrate(struct mt76x02_dev *dev, bool power_on)
+7 -8
drivers/net/wireless/ti/wlcore/sdio.c
··· 164 164 } 165 165 166 166 sdio_claim_host(func); 167 + /* 168 + * To guarantee that the SDIO card is power cycled, as required to make 169 + * the FW programming to succeed, let's do a brute force HW reset. 170 + */ 171 + mmc_hw_reset(card->host); 172 + 167 173 sdio_enable_func(func); 168 174 sdio_release_host(func); 169 175 ··· 180 174 { 181 175 struct sdio_func *func = dev_to_sdio_func(glue->dev); 182 176 struct mmc_card *card = func->card; 183 - int error; 184 177 185 178 sdio_claim_host(func); 186 179 sdio_disable_func(func); 187 180 sdio_release_host(func); 188 181 189 182 /* Let runtime PM know the card is powered off */ 190 - error = pm_runtime_put(&card->dev); 191 - if (error < 0 && error != -EBUSY) { 192 - dev_err(&card->dev, "%s failed: %i\n", __func__, error); 193 - 194 - return error; 195 - } 196 - 183 + pm_runtime_put(&card->dev); 197 184 return 0; 198 185 } 199 186
+2 -1
drivers/s390/net/qeth_core.h
··· 22 22 #include <linux/hashtable.h> 23 23 #include <linux/ip.h> 24 24 #include <linux/refcount.h> 25 + #include <linux/workqueue.h> 25 26 26 27 #include <net/ipv6.h> 27 28 #include <net/if_inet6.h> ··· 790 789 struct qeth_seqno seqno; 791 790 struct qeth_card_options options; 792 791 792 + struct workqueue_struct *event_wq; 793 793 wait_queue_head_t wait_q; 794 794 spinlock_t mclock; 795 795 unsigned long active_vlans[BITS_TO_LONGS(VLAN_N_VID)]; ··· 964 962 extern const struct attribute_group qeth_device_attr_group; 965 963 extern const struct attribute_group qeth_device_blkt_group; 966 964 extern const struct device_type qeth_generic_devtype; 967 - extern struct workqueue_struct *qeth_wq; 968 965 969 966 int qeth_card_hw_is_reachable(struct qeth_card *); 970 967 const char *qeth_get_cardname_short(struct qeth_card *);
+20 -11
drivers/s390/net/qeth_core_main.c
··· 74 74 static void qeth_release_skbs(struct qeth_qdio_out_buffer *buf); 75 75 static int qeth_init_qdio_out_buf(struct qeth_qdio_out_q *, int); 76 76 77 - struct workqueue_struct *qeth_wq; 78 - EXPORT_SYMBOL_GPL(qeth_wq); 77 + static struct workqueue_struct *qeth_wq; 79 78 80 79 int qeth_card_hw_is_reachable(struct qeth_card *card) 81 80 { ··· 565 566 QETH_DBF_MESSAGE(2, "error %i on device %x when starting next read ccw!\n", 566 567 rc, CARD_DEVID(card)); 567 568 atomic_set(&channel->irq_pending, 0); 569 + qeth_release_buffer(channel, iob); 568 570 card->read_or_write_problem = 1; 569 571 qeth_schedule_recovery(card); 570 572 wake_up(&card->wait_q); ··· 1127 1127 rc = qeth_get_problem(card, cdev, irb); 1128 1128 if (rc) { 1129 1129 card->read_or_write_problem = 1; 1130 + if (iob) 1131 + qeth_release_buffer(iob->channel, iob); 1130 1132 qeth_clear_ipacmd_list(card); 1131 1133 qeth_schedule_recovery(card); 1132 1134 goto out; ··· 1468 1466 CARD_RDEV(card) = gdev->cdev[0]; 1469 1467 CARD_WDEV(card) = gdev->cdev[1]; 1470 1468 CARD_DDEV(card) = gdev->cdev[2]; 1469 + 1470 + card->event_wq = alloc_ordered_workqueue("%s", 0, dev_name(&gdev->dev)); 1471 + if (!card->event_wq) 1472 + goto out_wq; 1471 1473 if (qeth_setup_channel(&card->read, true)) 1472 1474 goto out_ip; 1473 1475 if (qeth_setup_channel(&card->write, true)) ··· 1487 1481 out_channel: 1488 1482 qeth_clean_channel(&card->read); 1489 1483 out_ip: 1484 + destroy_workqueue(card->event_wq); 1485 + out_wq: 1490 1486 dev_set_drvdata(&gdev->dev, NULL); 1491 1487 kfree(card); 1492 1488 out: ··· 1817 1809 QETH_DBF_MESSAGE(2, "Error2 in activating channel rc=%d\n", rc); 1818 1810 QETH_DBF_TEXT_(SETUP, 2, "2err%d", rc); 1819 1811 atomic_set(&channel->irq_pending, 0); 1812 + qeth_release_buffer(channel, iob); 1820 1813 wake_up(&card->wait_q); 1821 1814 return rc; 1822 1815 } ··· 1887 1878 rc); 1888 1879 QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc); 1889 1880 atomic_set(&channel->irq_pending, 0); 1881 + qeth_release_buffer(channel, iob); 1890 1882 wake_up(&card->wait_q); 1891 1883 return rc; 1892 1884 } ··· 2068 2058 } 2069 2059 reply = qeth_alloc_reply(card); 2070 2060 if (!reply) { 2061 + qeth_release_buffer(channel, iob); 2071 2062 return -ENOMEM; 2072 2063 } 2073 2064 reply->callback = reply_cb; ··· 2400 2389 return 0; 2401 2390 } 2402 2391 2403 - static void qeth_free_qdio_out_buf(struct qeth_qdio_out_q *q) 2392 + static void qeth_free_output_queue(struct qeth_qdio_out_q *q) 2404 2393 { 2405 2394 if (!q) 2406 2395 return; 2407 2396 2397 + qeth_clear_outq_buffers(q, 1); 2408 2398 qdio_free_buffers(q->qdio_bufs, QDIO_MAX_BUFFERS_PER_Q); 2409 2399 kfree(q); 2410 2400 } ··· 2479 2467 card->qdio.out_qs[i]->bufs[j] = NULL; 2480 2468 } 2481 2469 out_freeoutq: 2482 - while (i > 0) { 2483 - qeth_free_qdio_out_buf(card->qdio.out_qs[--i]); 2484 - qeth_clear_outq_buffers(card->qdio.out_qs[i], 1); 2485 - } 2470 + while (i > 0) 2471 + qeth_free_output_queue(card->qdio.out_qs[--i]); 2486 2472 kfree(card->qdio.out_qs); 2487 2473 card->qdio.out_qs = NULL; 2488 2474 out_freepool: ··· 2513 2503 qeth_free_buffer_pool(card); 2514 2504 /* free outbound qdio_qs */ 2515 2505 if (card->qdio.out_qs) { 2516 - for (i = 0; i < card->qdio.no_out_queues; ++i) { 2517 - qeth_clear_outq_buffers(card->qdio.out_qs[i], 1); 2518 - qeth_free_qdio_out_buf(card->qdio.out_qs[i]); 2519 - } 2506 + for (i = 0; i < card->qdio.no_out_queues; i++) 2507 + qeth_free_output_queue(card->qdio.out_qs[i]); 2520 2508 kfree(card->qdio.out_qs); 2521 2509 card->qdio.out_qs = NULL; 2522 2510 } ··· 5036 5028 qeth_clean_channel(&card->read); 5037 5029 qeth_clean_channel(&card->write); 5038 5030 qeth_clean_channel(&card->data); 5031 + destroy_workqueue(card->event_wq); 5039 5032 qeth_free_qdio_buffers(card); 5040 5033 unregister_service_level(&card->qeth_service_level); 5041 5034 dev_set_drvdata(&card->gdev->dev, NULL);
+6 -2
drivers/s390/net/qeth_l2_main.c
··· 369 369 qeth_clear_cmd_buffers(&card->read); 370 370 qeth_clear_cmd_buffers(&card->write); 371 371 } 372 + 373 + flush_workqueue(card->event_wq); 372 374 } 373 375 374 376 static int qeth_l2_process_inbound_buffer(struct qeth_card *card, ··· 803 801 804 802 if (cgdev->state == CCWGROUP_ONLINE) 805 803 qeth_l2_set_offline(cgdev); 804 + 805 + cancel_work_sync(&card->close_dev_work); 806 806 if (qeth_netdev_is_registered(card->dev)) 807 807 unregister_netdev(card->dev); 808 808 } ··· 1438 1434 data->card = card; 1439 1435 memcpy(&data->qports, qports, 1440 1436 sizeof(struct qeth_sbp_state_change) + extrasize); 1441 - queue_work(qeth_wq, &data->worker); 1437 + queue_work(card->event_wq, &data->worker); 1442 1438 } 1443 1439 1444 1440 struct qeth_bridge_host_data { ··· 1510 1506 data->card = card; 1511 1507 memcpy(&data->hostevs, hostevs, 1512 1508 sizeof(struct qeth_ipacmd_addr_change) + extrasize); 1513 - queue_work(qeth_wq, &data->worker); 1509 + queue_work(card->event_wq, &data->worker); 1514 1510 } 1515 1511 1516 1512 /* SETBRIDGEPORT support; sending commands */
+3
drivers/s390/net/qeth_l3_main.c
··· 1433 1433 qeth_clear_cmd_buffers(&card->read); 1434 1434 qeth_clear_cmd_buffers(&card->write); 1435 1435 } 1436 + 1437 + flush_workqueue(card->event_wq); 1436 1438 } 1437 1439 1438 1440 /* ··· 2340 2338 if (cgdev->state == CCWGROUP_ONLINE) 2341 2339 qeth_l3_set_offline(cgdev); 2342 2340 2341 + cancel_work_sync(&card->close_dev_work); 2343 2342 if (qeth_netdev_is_registered(card->dev)) 2344 2343 unregister_netdev(card->dev); 2345 2344 qeth_l3_clear_ip_htable(card, 0);
+18 -3
include/linux/filter.h
··· 591 591 return qdisc_skb_cb(skb)->data; 592 592 } 593 593 594 - static inline u32 bpf_prog_run_save_cb(const struct bpf_prog *prog, 595 - struct sk_buff *skb) 594 + static inline u32 __bpf_prog_run_save_cb(const struct bpf_prog *prog, 595 + struct sk_buff *skb) 596 596 { 597 597 u8 *cb_data = bpf_skb_cb(skb); 598 598 u8 cb_saved[BPF_SKB_CB_LEN]; ··· 611 611 return res; 612 612 } 613 613 614 + static inline u32 bpf_prog_run_save_cb(const struct bpf_prog *prog, 615 + struct sk_buff *skb) 616 + { 617 + u32 res; 618 + 619 + preempt_disable(); 620 + res = __bpf_prog_run_save_cb(prog, skb); 621 + preempt_enable(); 622 + return res; 623 + } 624 + 614 625 static inline u32 bpf_prog_run_clear_cb(const struct bpf_prog *prog, 615 626 struct sk_buff *skb) 616 627 { 617 628 u8 *cb_data = bpf_skb_cb(skb); 629 + u32 res; 618 630 619 631 if (unlikely(prog->cb_access)) 620 632 memset(cb_data, 0, BPF_SKB_CB_LEN); 621 633 622 - return BPF_PROG_RUN(prog, skb); 634 + preempt_disable(); 635 + res = BPF_PROG_RUN(prog, skb); 636 + preempt_enable(); 637 + return res; 623 638 } 624 639 625 640 static __always_inline u32 bpf_prog_run_xdp(const struct bpf_prog *prog,
+8
include/linux/netdevice.h
··· 1483 1483 * @IFF_NO_RX_HANDLER: device doesn't support the rx_handler hook 1484 1484 * @IFF_FAILOVER: device is a failover master device 1485 1485 * @IFF_FAILOVER_SLAVE: device is lower dev of a failover master device 1486 + * @IFF_L3MDEV_RX_HANDLER: only invoke the rx handler of L3 master device 1486 1487 */ 1487 1488 enum netdev_priv_flags { 1488 1489 IFF_802_1Q_VLAN = 1<<0, ··· 1515 1514 IFF_NO_RX_HANDLER = 1<<26, 1516 1515 IFF_FAILOVER = 1<<27, 1517 1516 IFF_FAILOVER_SLAVE = 1<<28, 1517 + IFF_L3MDEV_RX_HANDLER = 1<<29, 1518 1518 }; 1519 1519 1520 1520 #define IFF_802_1Q_VLAN IFF_802_1Q_VLAN ··· 1546 1544 #define IFF_NO_RX_HANDLER IFF_NO_RX_HANDLER 1547 1545 #define IFF_FAILOVER IFF_FAILOVER 1548 1546 #define IFF_FAILOVER_SLAVE IFF_FAILOVER_SLAVE 1547 + #define IFF_L3MDEV_RX_HANDLER IFF_L3MDEV_RX_HANDLER 1549 1548 1550 1549 /** 1551 1550 * struct net_device - The DEVICE structure. ··· 4550 4547 static inline bool netif_supports_nofcs(struct net_device *dev) 4551 4548 { 4552 4549 return dev->priv_flags & IFF_SUPP_NOFCS; 4550 + } 4551 + 4552 + static inline bool netif_has_l3_rx_handler(const struct net_device *dev) 4553 + { 4554 + return dev->priv_flags & IFF_L3MDEV_RX_HANDLER; 4553 4555 } 4554 4556 4555 4557 static inline bool netif_is_l3_master(const struct net_device *dev)
+1
include/linux/stmmac.h
··· 184 184 struct clk *pclk; 185 185 struct clk *clk_ptp_ref; 186 186 unsigned int clk_ptp_rate; 187 + unsigned int clk_ref_rate; 187 188 struct reset_control *stmmac_rst; 188 189 struct stmmac_axi *axi; 189 190 int has_gmac4;
+2 -1
include/net/l3mdev.h
··· 153 153 154 154 if (netif_is_l3_slave(skb->dev)) 155 155 master = netdev_master_upper_dev_get_rcu(skb->dev); 156 - else if (netif_is_l3_master(skb->dev)) 156 + else if (netif_is_l3_master(skb->dev) || 157 + netif_has_l3_rx_handler(skb->dev)) 157 158 master = skb->dev; 158 159 159 160 if (master && master->l3mdev_ops->l3mdev_l3_rcv)
+13 -4
include/net/netfilter/nf_tables.h
··· 469 469 int nf_tables_bind_set(const struct nft_ctx *ctx, struct nft_set *set, 470 470 struct nft_set_binding *binding); 471 471 void nf_tables_unbind_set(const struct nft_ctx *ctx, struct nft_set *set, 472 - struct nft_set_binding *binding); 473 - void nf_tables_rebind_set(const struct nft_ctx *ctx, struct nft_set *set, 474 - struct nft_set_binding *binding); 472 + struct nft_set_binding *binding, bool commit); 475 473 void nf_tables_destroy_set(const struct nft_ctx *ctx, struct nft_set *set); 476 474 477 475 /** ··· 719 721 #define NFT_EXPR_STATEFUL 0x1 720 722 #define NFT_EXPR_GC 0x2 721 723 724 + enum nft_trans_phase { 725 + NFT_TRANS_PREPARE, 726 + NFT_TRANS_ABORT, 727 + NFT_TRANS_COMMIT, 728 + NFT_TRANS_RELEASE 729 + }; 730 + 722 731 /** 723 732 * struct nft_expr_ops - nf_tables expression operations 724 733 * ··· 755 750 void (*activate)(const struct nft_ctx *ctx, 756 751 const struct nft_expr *expr); 757 752 void (*deactivate)(const struct nft_ctx *ctx, 758 - const struct nft_expr *expr); 753 + const struct nft_expr *expr, 754 + enum nft_trans_phase phase); 759 755 void (*destroy)(const struct nft_ctx *ctx, 760 756 const struct nft_expr *expr); 761 757 void (*destroy_clone)(const struct nft_ctx *ctx, ··· 1329 1323 struct nft_trans_set { 1330 1324 struct nft_set *set; 1331 1325 u32 set_id; 1326 + bool bound; 1332 1327 }; 1333 1328 1334 1329 #define nft_trans_set(trans) \ 1335 1330 (((struct nft_trans_set *)trans->data)->set) 1336 1331 #define nft_trans_set_id(trans) \ 1337 1332 (((struct nft_trans_set *)trans->data)->set_id) 1333 + #define nft_trans_set_bound(trans) \ 1334 + (((struct nft_trans_set *)trans->data)->bound) 1338 1335 1339 1336 struct nft_trans_chain { 1340 1337 bool update;
+2 -1
kernel/bpf/btf.c
··· 1459 1459 1460 1460 /* "typedef void new_void", "const void"...etc */ 1461 1461 if (!btf_type_is_void(next_type) && 1462 - !btf_type_is_fwd(next_type)) { 1462 + !btf_type_is_fwd(next_type) && 1463 + !btf_type_is_func_proto(next_type)) { 1463 1464 btf_verifier_log_type(env, v->t, "Invalid type_id"); 1464 1465 return -EINVAL; 1465 1466 }
+1 -1
kernel/bpf/cgroup.c
··· 572 572 bpf_compute_and_save_data_end(skb, &saved_data_end); 573 573 574 574 ret = BPF_PROG_RUN_ARRAY(cgrp->bpf.effective[type], skb, 575 - bpf_prog_run_save_cb); 575 + __bpf_prog_run_save_cb); 576 576 bpf_restore_data_end(skb, saved_data_end); 577 577 __skb_pull(skb, offset); 578 578 skb->sk = save_sk;
+2 -2
kernel/bpf/hashtab.c
··· 686 686 } 687 687 688 688 if (htab_is_prealloc(htab)) { 689 - pcpu_freelist_push(&htab->freelist, &l->fnode); 689 + __pcpu_freelist_push(&htab->freelist, &l->fnode); 690 690 } else { 691 691 atomic_dec(&htab->count); 692 692 l->htab = htab; ··· 748 748 } else { 749 749 struct pcpu_freelist_node *l; 750 750 751 - l = pcpu_freelist_pop(&htab->freelist); 751 + l = __pcpu_freelist_pop(&htab->freelist); 752 752 if (!l) 753 753 return ERR_PTR(-E2BIG); 754 754 l_new = container_of(l, struct htab_elem, fnode);
+29 -12
kernel/bpf/percpu_freelist.c
··· 28 28 free_percpu(s->freelist); 29 29 } 30 30 31 - static inline void __pcpu_freelist_push(struct pcpu_freelist_head *head, 32 - struct pcpu_freelist_node *node) 31 + static inline void ___pcpu_freelist_push(struct pcpu_freelist_head *head, 32 + struct pcpu_freelist_node *node) 33 33 { 34 34 raw_spin_lock(&head->lock); 35 35 node->next = head->first; ··· 37 37 raw_spin_unlock(&head->lock); 38 38 } 39 39 40 - void pcpu_freelist_push(struct pcpu_freelist *s, 40 + void __pcpu_freelist_push(struct pcpu_freelist *s, 41 41 struct pcpu_freelist_node *node) 42 42 { 43 43 struct pcpu_freelist_head *head = this_cpu_ptr(s->freelist); 44 44 45 - __pcpu_freelist_push(head, node); 45 + ___pcpu_freelist_push(head, node); 46 + } 47 + 48 + void pcpu_freelist_push(struct pcpu_freelist *s, 49 + struct pcpu_freelist_node *node) 50 + { 51 + unsigned long flags; 52 + 53 + local_irq_save(flags); 54 + __pcpu_freelist_push(s, node); 55 + local_irq_restore(flags); 46 56 } 47 57 48 58 void pcpu_freelist_populate(struct pcpu_freelist *s, void *buf, u32 elem_size, ··· 73 63 for_each_possible_cpu(cpu) { 74 64 again: 75 65 head = per_cpu_ptr(s->freelist, cpu); 76 - __pcpu_freelist_push(head, buf); 66 + ___pcpu_freelist_push(head, buf); 77 67 i++; 78 68 buf += elem_size; 79 69 if (i == nr_elems) ··· 84 74 local_irq_restore(flags); 85 75 } 86 76 87 - struct pcpu_freelist_node *pcpu_freelist_pop(struct pcpu_freelist *s) 77 + struct pcpu_freelist_node *__pcpu_freelist_pop(struct pcpu_freelist *s) 88 78 { 89 79 struct pcpu_freelist_head *head; 90 80 struct pcpu_freelist_node *node; 91 - unsigned long flags; 92 81 int orig_cpu, cpu; 93 82 94 - local_irq_save(flags); 95 83 orig_cpu = cpu = raw_smp_processor_id(); 96 84 while (1) { 97 85 head = per_cpu_ptr(s->freelist, cpu); ··· 97 89 node = head->first; 98 90 if (node) { 99 91 head->first = node->next; 100 - raw_spin_unlock_irqrestore(&head->lock, flags); 92 + raw_spin_unlock(&head->lock); 101 93 return node; 102 94 } 103 95 raw_spin_unlock(&head->lock); 104 96 cpu = cpumask_next(cpu, cpu_possible_mask); 105 97 if (cpu >= nr_cpu_ids) 106 98 cpu = 0; 107 - if (cpu == orig_cpu) { 108 - local_irq_restore(flags); 99 + if (cpu == orig_cpu) 109 100 return NULL; 110 - } 111 101 } 102 + } 103 + 104 + struct pcpu_freelist_node *pcpu_freelist_pop(struct pcpu_freelist *s) 105 + { 106 + struct pcpu_freelist_node *ret; 107 + unsigned long flags; 108 + 109 + local_irq_save(flags); 110 + ret = __pcpu_freelist_pop(s); 111 + local_irq_restore(flags); 112 + return ret; 112 113 }
+4
kernel/bpf/percpu_freelist.h
··· 22 22 struct pcpu_freelist_node *next; 23 23 }; 24 24 25 + /* pcpu_freelist_* do spin_lock_irqsave. */ 25 26 void pcpu_freelist_push(struct pcpu_freelist *, struct pcpu_freelist_node *); 26 27 struct pcpu_freelist_node *pcpu_freelist_pop(struct pcpu_freelist *); 28 + /* __pcpu_freelist_* do spin_lock only. caller must disable irqs. */ 29 + void __pcpu_freelist_push(struct pcpu_freelist *, struct pcpu_freelist_node *); 30 + struct pcpu_freelist_node *__pcpu_freelist_pop(struct pcpu_freelist *); 27 31 void pcpu_freelist_populate(struct pcpu_freelist *s, void *buf, u32 elem_size, 28 32 u32 nr_elems); 29 33 int pcpu_freelist_init(struct pcpu_freelist *);
+10 -2
kernel/bpf/syscall.c
··· 713 713 714 714 if (bpf_map_is_dev_bound(map)) { 715 715 err = bpf_map_offload_lookup_elem(map, key, value); 716 - } else if (map->map_type == BPF_MAP_TYPE_PERCPU_HASH || 717 - map->map_type == BPF_MAP_TYPE_LRU_PERCPU_HASH) { 716 + goto done; 717 + } 718 + 719 + preempt_disable(); 720 + this_cpu_inc(bpf_prog_active); 721 + if (map->map_type == BPF_MAP_TYPE_PERCPU_HASH || 722 + map->map_type == BPF_MAP_TYPE_LRU_PERCPU_HASH) { 718 723 err = bpf_percpu_hash_copy(map, key, value); 719 724 } else if (map->map_type == BPF_MAP_TYPE_PERCPU_ARRAY) { 720 725 err = bpf_percpu_array_copy(map, key, value); ··· 749 744 } 750 745 rcu_read_unlock(); 751 746 } 747 + this_cpu_dec(bpf_prog_active); 748 + preempt_enable(); 752 749 750 + done: 753 751 if (err) 754 752 goto free_value; 755 753
+2 -12
kernel/trace/bpf_trace.c
··· 1204 1204 1205 1205 int bpf_probe_register(struct bpf_raw_event_map *btp, struct bpf_prog *prog) 1206 1206 { 1207 - int err; 1208 - 1209 - mutex_lock(&bpf_event_mutex); 1210 - err = __bpf_probe_register(btp, prog); 1211 - mutex_unlock(&bpf_event_mutex); 1212 - return err; 1207 + return __bpf_probe_register(btp, prog); 1213 1208 } 1214 1209 1215 1210 int bpf_probe_unregister(struct bpf_raw_event_map *btp, struct bpf_prog *prog) 1216 1211 { 1217 - int err; 1218 - 1219 - mutex_lock(&bpf_event_mutex); 1220 - err = tracepoint_probe_unregister(btp->tp, (void *)btp->bpf_func, prog); 1221 - mutex_unlock(&bpf_event_mutex); 1222 - return err; 1212 + return tracepoint_probe_unregister(btp->tp, (void *)btp->bpf_func, prog); 1223 1213 } 1224 1214 1225 1215 int bpf_get_perf_event_info(const struct perf_event *event, u32 *prog_id,
+15 -8
lib/test_rhashtable.c
··· 541 541 static int __init test_insert_dup(struct test_obj_rhl *rhl_test_objects, 542 542 int cnt, bool slow) 543 543 { 544 - struct rhltable rhlt; 544 + struct rhltable *rhlt; 545 545 unsigned int i, ret; 546 546 const char *key; 547 547 int err = 0; 548 548 549 - err = rhltable_init(&rhlt, &test_rht_params_dup); 550 - if (WARN_ON(err)) 549 + rhlt = kmalloc(sizeof(*rhlt), GFP_KERNEL); 550 + if (WARN_ON(!rhlt)) 551 + return -EINVAL; 552 + 553 + err = rhltable_init(rhlt, &test_rht_params_dup); 554 + if (WARN_ON(err)) { 555 + kfree(rhlt); 551 556 return err; 557 + } 552 558 553 559 for (i = 0; i < cnt; i++) { 554 560 rhl_test_objects[i].value.tid = i; 555 - key = rht_obj(&rhlt.ht, &rhl_test_objects[i].list_node.rhead); 561 + key = rht_obj(&rhlt->ht, &rhl_test_objects[i].list_node.rhead); 556 562 key += test_rht_params_dup.key_offset; 557 563 558 564 if (slow) { 559 - err = PTR_ERR(rhashtable_insert_slow(&rhlt.ht, key, 565 + err = PTR_ERR(rhashtable_insert_slow(&rhlt->ht, key, 560 566 &rhl_test_objects[i].list_node.rhead)); 561 567 if (err == -EAGAIN) 562 568 err = 0; 563 569 } else 564 - err = rhltable_insert(&rhlt, 570 + err = rhltable_insert(rhlt, 565 571 &rhl_test_objects[i].list_node, 566 572 test_rht_params_dup); 567 573 if (WARN(err, "error %d on element %d/%d (%s)\n", err, i, cnt, slow? "slow" : "fast")) 568 574 goto skip_print; 569 575 } 570 576 571 - ret = print_ht(&rhlt); 577 + ret = print_ht(rhlt); 572 578 WARN(ret != cnt, "missing rhltable elements (%d != %d, %s)\n", ret, cnt, slow? "slow" : "fast"); 573 579 574 580 skip_print: 575 - rhltable_destroy(&rhlt); 581 + rhltable_destroy(rhlt); 582 + kfree(rhlt); 576 583 577 584 return 0; 578 585 }
+3
net/batman-adv/bat_v_elp.c
··· 104 104 105 105 ret = cfg80211_get_station(real_netdev, neigh->addr, &sinfo); 106 106 107 + /* free the TID stats immediately */ 108 + cfg80211_sinfo_release_content(&sinfo); 109 + 107 110 dev_put(real_netdev); 108 111 if (ret == -ENOENT) { 109 112 /* Node is not associated anymore! It would be
+3 -2
net/batman-adv/hard-interface.c
··· 20 20 #include "main.h" 21 21 22 22 #include <linux/atomic.h> 23 - #include <linux/bug.h> 24 23 #include <linux/byteorder/generic.h> 25 24 #include <linux/errno.h> 26 25 #include <linux/gfp.h> ··· 178 179 parent_dev = __dev_get_by_index((struct net *)parent_net, 179 180 dev_get_iflink(net_dev)); 180 181 /* if we got a NULL parent_dev there is something broken.. */ 181 - if (WARN(!parent_dev, "Cannot find parent device")) 182 + if (!parent_dev) { 183 + pr_err("Cannot find parent device\n"); 182 184 return false; 185 + } 183 186 184 187 if (batadv_mutual_parents(net_dev, net, parent_dev, parent_net)) 185 188 return false;
+2
net/batman-adv/soft-interface.c
··· 221 221 222 222 netif_trans_update(soft_iface); 223 223 vid = batadv_get_vid(skb, 0); 224 + 225 + skb_reset_mac_header(skb); 224 226 ethhdr = eth_hdr(skb); 225 227 226 228 switch (ntohs(ethhdr->h_proto)) {
+2
net/core/filter.c
··· 4112 4112 /* Only some socketops are supported */ 4113 4113 switch (optname) { 4114 4114 case SO_RCVBUF: 4115 + val = min_t(u32, val, sysctl_rmem_max); 4115 4116 sk->sk_userlocks |= SOCK_RCVBUF_LOCK; 4116 4117 sk->sk_rcvbuf = max_t(int, val * 2, SOCK_MIN_RCVBUF); 4117 4118 break; 4118 4119 case SO_SNDBUF: 4120 + val = min_t(u32, val, sysctl_wmem_max); 4119 4121 sk->sk_userlocks |= SOCK_SNDBUF_LOCK; 4120 4122 sk->sk_sndbuf = max_t(int, val * 2, SOCK_MIN_SNDBUF); 4121 4123 break;
+1 -2
net/core/skmsg.c
··· 545 545 struct sk_psock *psock = container_of(gc, struct sk_psock, gc); 546 546 547 547 /* No sk_callback_lock since already detached. */ 548 - if (psock->parser.enabled) 549 - strp_done(&psock->parser.strp); 548 + strp_done(&psock->parser.strp); 550 549 551 550 cancel_work_sync(&psock->work); 552 551
+2 -2
net/dccp/ccid.h
··· 202 202 static inline int ccid_hc_tx_parse_options(struct ccid *ccid, struct sock *sk, 203 203 u8 pkt, u8 opt, u8 *val, u8 len) 204 204 { 205 - if (ccid->ccid_ops->ccid_hc_tx_parse_options == NULL) 205 + if (!ccid || !ccid->ccid_ops->ccid_hc_tx_parse_options) 206 206 return 0; 207 207 return ccid->ccid_ops->ccid_hc_tx_parse_options(sk, pkt, opt, val, len); 208 208 } ··· 214 214 static inline int ccid_hc_rx_parse_options(struct ccid *ccid, struct sock *sk, 215 215 u8 pkt, u8 opt, u8 *val, u8 len) 216 216 { 217 - if (ccid->ccid_ops->ccid_hc_rx_parse_options == NULL) 217 + if (!ccid || !ccid->ccid_ops->ccid_hc_rx_parse_options) 218 218 return 0; 219 219 return ccid->ccid_ops->ccid_hc_rx_parse_options(sk, pkt, opt, val, len); 220 220 }
+4
net/dsa/master.c
··· 205 205 rtnl_unlock(); 206 206 } 207 207 208 + static struct lock_class_key dsa_master_addr_list_lock_key; 209 + 208 210 int dsa_master_setup(struct net_device *dev, struct dsa_port *cpu_dp) 209 211 { 210 212 int ret; ··· 220 218 wmb(); 221 219 222 220 dev->dsa_ptr = cpu_dp; 221 + lockdep_set_class(&dev->addr_list_lock, 222 + &dsa_master_addr_list_lock_key); 223 223 224 224 ret = dsa_master_ethtool_setup(dev); 225 225 if (ret)
+10 -7
net/dsa/slave.c
··· 140 140 static void dsa_slave_change_rx_flags(struct net_device *dev, int change) 141 141 { 142 142 struct net_device *master = dsa_slave_to_master(dev); 143 - 144 - if (change & IFF_ALLMULTI) 145 - dev_set_allmulti(master, dev->flags & IFF_ALLMULTI ? 1 : -1); 146 - if (change & IFF_PROMISC) 147 - dev_set_promiscuity(master, dev->flags & IFF_PROMISC ? 1 : -1); 143 + if (dev->flags & IFF_UP) { 144 + if (change & IFF_ALLMULTI) 145 + dev_set_allmulti(master, 146 + dev->flags & IFF_ALLMULTI ? 1 : -1); 147 + if (change & IFF_PROMISC) 148 + dev_set_promiscuity(master, 149 + dev->flags & IFF_PROMISC ? 1 : -1); 150 + } 148 151 } 149 152 150 153 static void dsa_slave_set_rx_mode(struct net_device *dev) ··· 642 639 int ret; 643 640 644 641 /* Port's PHY and MAC both need to be EEE capable */ 645 - if (!dev->phydev && !dp->pl) 642 + if (!dev->phydev || !dp->pl) 646 643 return -ENODEV; 647 644 648 645 if (!ds->ops->set_mac_eee) ··· 662 659 int ret; 663 660 664 661 /* Port's PHY and MAC both need to be EEE capable */ 665 - if (!dev->phydev && !dp->pl) 662 + if (!dev->phydev || !dp->pl) 666 663 return -ENODEV; 667 664 668 665 if (!ds->ops->get_mac_eee)
+6 -1
net/ipv4/ip_gre.c
··· 1455 1455 { 1456 1456 struct ip_tunnel *t = netdev_priv(dev); 1457 1457 struct ip_tunnel_parm *p = &t->parms; 1458 + __be16 o_flags = p->o_flags; 1459 + 1460 + if ((t->erspan_ver == 1 || t->erspan_ver == 2) && 1461 + !t->collect_md) 1462 + o_flags |= TUNNEL_KEY; 1458 1463 1459 1464 if (nla_put_u32(skb, IFLA_GRE_LINK, p->link) || 1460 1465 nla_put_be16(skb, IFLA_GRE_IFLAGS, 1461 1466 gre_tnl_flags_to_gre_flags(p->i_flags)) || 1462 1467 nla_put_be16(skb, IFLA_GRE_OFLAGS, 1463 - gre_tnl_flags_to_gre_flags(p->o_flags)) || 1468 + gre_tnl_flags_to_gre_flags(o_flags)) || 1464 1469 nla_put_be32(skb, IFLA_GRE_IKEY, p->i_key) || 1465 1470 nla_put_be32(skb, IFLA_GRE_OKEY, p->o_key) || 1466 1471 nla_put_in_addr(skb, IFLA_GRE_LOCAL, p->iph.saddr) ||
+6 -1
net/ipv6/ip6_gre.c
··· 2098 2098 { 2099 2099 struct ip6_tnl *t = netdev_priv(dev); 2100 2100 struct __ip6_tnl_parm *p = &t->parms; 2101 + __be16 o_flags = p->o_flags; 2102 + 2103 + if ((p->erspan_ver == 1 || p->erspan_ver == 2) && 2104 + !p->collect_md) 2105 + o_flags |= TUNNEL_KEY; 2101 2106 2102 2107 if (nla_put_u32(skb, IFLA_GRE_LINK, p->link) || 2103 2108 nla_put_be16(skb, IFLA_GRE_IFLAGS, 2104 2109 gre_tnl_flags_to_gre_flags(p->i_flags)) || 2105 2110 nla_put_be16(skb, IFLA_GRE_OFLAGS, 2106 - gre_tnl_flags_to_gre_flags(p->o_flags)) || 2111 + gre_tnl_flags_to_gre_flags(o_flags)) || 2107 2112 nla_put_be32(skb, IFLA_GRE_IKEY, p->i_key) || 2108 2113 nla_put_be32(skb, IFLA_GRE_OKEY, p->o_key) || 2109 2114 nla_put_in6_addr(skb, IFLA_GRE_LOCAL, &p->laddr) ||
+3 -1
net/ipv6/netfilter.c
··· 23 23 struct sock *sk = sk_to_full_sk(skb->sk); 24 24 unsigned int hh_len; 25 25 struct dst_entry *dst; 26 + int strict = (ipv6_addr_type(&iph->daddr) & 27 + (IPV6_ADDR_MULTICAST | IPV6_ADDR_LINKLOCAL)); 26 28 struct flowi6 fl6 = { 27 29 .flowi6_oif = sk && sk->sk_bound_dev_if ? sk->sk_bound_dev_if : 28 - rt6_need_strict(&iph->daddr) ? skb_dst(skb)->dev->ifindex : 0, 30 + strict ? skb_dst(skb)->dev->ifindex : 0, 29 31 .flowi6_mark = skb->mark, 30 32 .flowi6_uid = sock_net_uid(net, sk), 31 33 .daddr = iph->daddr,
+2
net/ipv6/seg6_iptunnel.c
··· 146 146 } else { 147 147 ip6_flow_hdr(hdr, 0, flowlabel); 148 148 hdr->hop_limit = ip6_dst_hoplimit(skb_dst(skb)); 149 + 150 + memset(IP6CB(skb), 0, sizeof(*IP6CB(skb))); 149 151 } 150 152 151 153 hdr->nexthdr = NEXTHDR_ROUTING;
+2 -1
net/ipv6/sit.c
··· 546 546 } 547 547 548 548 err = 0; 549 - if (!ip6_err_gen_icmpv6_unreach(skb, iph->ihl * 4, type, data_len)) 549 + if (__in6_dev_get(skb->dev) && 550 + !ip6_err_gen_icmpv6_unreach(skb, iph->ihl * 4, type, data_len)) 550 551 goto out; 551 552 552 553 if (t->parms.iph.daddr == 0)
+6 -3
net/l2tp/l2tp_core.c
··· 83 83 #define L2TP_SLFLAG_S 0x40000000 84 84 #define L2TP_SL_SEQ_MASK 0x00ffffff 85 85 86 - #define L2TP_HDR_SIZE_SEQ 10 87 - #define L2TP_HDR_SIZE_NOSEQ 6 86 + #define L2TP_HDR_SIZE_MAX 14 88 87 89 88 /* Default trace flags */ 90 89 #define L2TP_DEFAULT_DEBUG_FLAGS 0 ··· 807 808 __skb_pull(skb, sizeof(struct udphdr)); 808 809 809 810 /* Short packet? */ 810 - if (!pskb_may_pull(skb, L2TP_HDR_SIZE_SEQ)) { 811 + if (!pskb_may_pull(skb, L2TP_HDR_SIZE_MAX)) { 811 812 l2tp_info(tunnel, L2TP_MSG_DATA, 812 813 "%s: recv short packet (len=%d)\n", 813 814 tunnel->name, skb->len); ··· 882 883 tunnel->name, tunnel_id, session_id); 883 884 goto error; 884 885 } 886 + 887 + if (tunnel->version == L2TP_HDR_VER_3 && 888 + l2tp_v3_ensure_opt_in_linear(session, skb, &ptr, &optr)) 889 + goto error; 885 890 886 891 l2tp_recv_common(session, skb, ptr, optr, hdrflags, length); 887 892 l2tp_session_dec_refcount(session);
+20
net/l2tp/l2tp_core.h
··· 301 301 } 302 302 #endif 303 303 304 + static inline int l2tp_v3_ensure_opt_in_linear(struct l2tp_session *session, struct sk_buff *skb, 305 + unsigned char **ptr, unsigned char **optr) 306 + { 307 + int opt_len = session->peer_cookie_len + l2tp_get_l2specific_len(session); 308 + 309 + if (opt_len > 0) { 310 + int off = *ptr - *optr; 311 + 312 + if (!pskb_may_pull(skb, off + opt_len)) 313 + return -1; 314 + 315 + if (skb->data != *optr) { 316 + *optr = skb->data; 317 + *ptr = skb->data + off; 318 + } 319 + } 320 + 321 + return 0; 322 + } 323 + 304 324 #define l2tp_printk(ptr, type, func, fmt, ...) \ 305 325 do { \ 306 326 if (((ptr)->debug) & (type)) \
+3
net/l2tp/l2tp_ip.c
··· 165 165 print_hex_dump_bytes("", DUMP_PREFIX_OFFSET, ptr, length); 166 166 } 167 167 168 + if (l2tp_v3_ensure_opt_in_linear(session, skb, &ptr, &optr)) 169 + goto discard_sess; 170 + 168 171 l2tp_recv_common(session, skb, ptr, optr, 0, skb->len); 169 172 l2tp_session_dec_refcount(session); 170 173
+3
net/l2tp/l2tp_ip6.c
··· 178 178 print_hex_dump_bytes("", DUMP_PREFIX_OFFSET, ptr, length); 179 179 } 180 180 181 + if (l2tp_v3_ensure_opt_in_linear(session, skb, &ptr, &optr)) 182 + goto discard_sess; 183 + 181 184 l2tp_recv_common(session, skb, ptr, optr, 0, skb->len); 182 185 l2tp_session_dec_refcount(session); 183 186
+9 -3
net/mac80211/tx.c
··· 1938 1938 int head_need, bool may_encrypt) 1939 1939 { 1940 1940 struct ieee80211_local *local = sdata->local; 1941 + struct ieee80211_hdr *hdr; 1942 + bool enc_tailroom; 1941 1943 int tail_need = 0; 1942 1944 1943 - if (may_encrypt && sdata->crypto_tx_tailroom_needed_cnt) { 1945 + hdr = (struct ieee80211_hdr *) skb->data; 1946 + enc_tailroom = may_encrypt && 1947 + (sdata->crypto_tx_tailroom_needed_cnt || 1948 + ieee80211_is_mgmt(hdr->frame_control)); 1949 + 1950 + if (enc_tailroom) { 1944 1951 tail_need = IEEE80211_ENCRYPT_TAILROOM; 1945 1952 tail_need -= skb_tailroom(skb); 1946 1953 tail_need = max_t(int, tail_need, 0); ··· 1955 1948 1956 1949 if (skb_cloned(skb) && 1957 1950 (!ieee80211_hw_check(&local->hw, SUPPORTS_CLONED_SKBS) || 1958 - !skb_clone_writable(skb, ETH_HLEN) || 1959 - (may_encrypt && sdata->crypto_tx_tailroom_needed_cnt))) 1951 + !skb_clone_writable(skb, ETH_HLEN) || enc_tailroom)) 1960 1952 I802_DEBUG_INC(local->tx_expand_skb_head_cloned); 1961 1953 else if (head_need || tail_need) 1962 1954 I802_DEBUG_INC(local->tx_expand_skb_head);
+16
net/netfilter/nf_conntrack_core.c
··· 1007 1007 } 1008 1008 1009 1009 if (nf_ct_key_equal(h, tuple, zone, net)) { 1010 + /* Tuple is taken already, so caller will need to find 1011 + * a new source port to use. 1012 + * 1013 + * Only exception: 1014 + * If the *original tuples* are identical, then both 1015 + * conntracks refer to the same flow. 1016 + * This is a rare situation, it can occur e.g. when 1017 + * more than one UDP packet is sent from same socket 1018 + * in different threads. 1019 + * 1020 + * Let nf_ct_resolve_clash() deal with this later. 1021 + */ 1022 + if (nf_ct_tuple_equal(&ignored_conntrack->tuplehash[IP_CT_DIR_ORIGINAL].tuple, 1023 + &ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple)) 1024 + continue; 1025 + 1010 1026 NF_CT_STAT_INC_ATOMIC(net, found); 1011 1027 rcu_read_unlock(); 1012 1028 return 1;
+41 -44
net/netfilter/nf_tables_api.c
··· 116 116 kfree(trans); 117 117 } 118 118 119 + static void nft_set_trans_bind(const struct nft_ctx *ctx, struct nft_set *set) 120 + { 121 + struct net *net = ctx->net; 122 + struct nft_trans *trans; 123 + 124 + if (!nft_set_is_anonymous(set)) 125 + return; 126 + 127 + list_for_each_entry_reverse(trans, &net->nft.commit_list, list) { 128 + if (trans->msg_type == NFT_MSG_NEWSET && 129 + nft_trans_set(trans) == set) { 130 + nft_trans_set_bound(trans) = true; 131 + break; 132 + } 133 + } 134 + } 135 + 119 136 static int nf_tables_register_hook(struct net *net, 120 137 const struct nft_table *table, 121 138 struct nft_chain *chain) ··· 228 211 return err; 229 212 } 230 213 231 - /* either expr ops provide both activate/deactivate, or neither */ 232 - static bool nft_expr_check_ops(const struct nft_expr_ops *ops) 233 - { 234 - if (!ops) 235 - return true; 236 - 237 - if (WARN_ON_ONCE((!ops->activate ^ !ops->deactivate))) 238 - return false; 239 - 240 - return true; 241 - } 242 - 243 214 static void nft_rule_expr_activate(const struct nft_ctx *ctx, 244 215 struct nft_rule *rule) 245 216 { ··· 243 238 } 244 239 245 240 static void nft_rule_expr_deactivate(const struct nft_ctx *ctx, 246 - struct nft_rule *rule) 241 + struct nft_rule *rule, 242 + enum nft_trans_phase phase) 247 243 { 248 244 struct nft_expr *expr; 249 245 250 246 expr = nft_expr_first(rule); 251 247 while (expr != nft_expr_last(rule) && expr->ops) { 252 248 if (expr->ops->deactivate) 253 - expr->ops->deactivate(ctx, expr); 249 + expr->ops->deactivate(ctx, expr, phase); 254 250 255 251 expr = nft_expr_next(expr); 256 252 } ··· 302 296 nft_trans_destroy(trans); 303 297 return err; 304 298 } 305 - nft_rule_expr_deactivate(ctx, rule); 299 + nft_rule_expr_deactivate(ctx, rule, NFT_TRANS_PREPARE); 306 300 307 301 return 0; 308 302 } ··· 1935 1929 */ 1936 1930 int nft_register_expr(struct nft_expr_type *type) 1937 1931 { 1938 - if (!nft_expr_check_ops(type->ops)) 1939 - return -EINVAL; 1940 - 1941 1932 nfnl_lock(NFNL_SUBSYS_NFTABLES); 1942 1933 if (type->family == NFPROTO_UNSPEC) 1943 1934 list_add_tail_rcu(&type->list, &nf_tables_expressions); ··· 2080 2077 (const struct nlattr * const *)info->tb); 2081 2078 if (IS_ERR(ops)) { 2082 2079 err = PTR_ERR(ops); 2083 - goto err1; 2084 - } 2085 - if (!nft_expr_check_ops(ops)) { 2086 - err = -EINVAL; 2087 2080 goto err1; 2088 2081 } 2089 2082 } else ··· 2510 2511 static void nf_tables_rule_release(const struct nft_ctx *ctx, 2511 2512 struct nft_rule *rule) 2512 2513 { 2513 - nft_rule_expr_deactivate(ctx, rule); 2514 + nft_rule_expr_deactivate(ctx, rule, NFT_TRANS_RELEASE); 2514 2515 nf_tables_rule_destroy(ctx, rule); 2515 2516 } 2516 2517 ··· 3707 3708 bind: 3708 3709 binding->chain = ctx->chain; 3709 3710 list_add_tail_rcu(&binding->list, &set->bindings); 3711 + nft_set_trans_bind(ctx, set); 3712 + 3710 3713 return 0; 3711 3714 } 3712 3715 EXPORT_SYMBOL_GPL(nf_tables_bind_set); 3713 3716 3714 - void nf_tables_rebind_set(const struct nft_ctx *ctx, struct nft_set *set, 3715 - struct nft_set_binding *binding) 3716 - { 3717 - if (list_empty(&set->bindings) && nft_set_is_anonymous(set) && 3718 - nft_is_active(ctx->net, set)) 3719 - list_add_tail_rcu(&set->list, &ctx->table->sets); 3720 - 3721 - list_add_tail_rcu(&binding->list, &set->bindings); 3722 - } 3723 - EXPORT_SYMBOL_GPL(nf_tables_rebind_set); 3724 - 3725 3717 void nf_tables_unbind_set(const struct nft_ctx *ctx, struct nft_set *set, 3726 - struct nft_set_binding *binding) 3718 + struct nft_set_binding *binding, bool event) 3727 3719 { 3728 3720 list_del_rcu(&binding->list); 3729 3721 3730 - if (list_empty(&set->bindings) && nft_set_is_anonymous(set) && 3731 - nft_is_active(ctx->net, set)) 3722 + if (list_empty(&set->bindings) && nft_set_is_anonymous(set)) { 3732 3723 list_del_rcu(&set->list); 3724 + if (event) 3725 + nf_tables_set_notify(ctx, set, NFT_MSG_DELSET, 3726 + GFP_KERNEL); 3727 + } 3733 3728 } 3734 3729 EXPORT_SYMBOL_GPL(nf_tables_unbind_set); 3735 3730 3736 3731 void nf_tables_destroy_set(const struct nft_ctx *ctx, struct nft_set *set) 3737 3732 { 3738 - if (list_empty(&set->bindings) && nft_set_is_anonymous(set) && 3739 - nft_is_active(ctx->net, set)) { 3740 - nf_tables_set_notify(ctx, set, NFT_MSG_DELSET, GFP_ATOMIC); 3733 + if (list_empty(&set->bindings) && nft_set_is_anonymous(set)) 3741 3734 nft_set_destroy(set); 3742 - } 3743 3735 } 3744 3736 EXPORT_SYMBOL_GPL(nf_tables_destroy_set); 3745 3737 ··· 6525 6535 nf_tables_rule_notify(&trans->ctx, 6526 6536 nft_trans_rule(trans), 6527 6537 NFT_MSG_DELRULE); 6538 + nft_rule_expr_deactivate(&trans->ctx, 6539 + nft_trans_rule(trans), 6540 + NFT_TRANS_COMMIT); 6528 6541 break; 6529 6542 case NFT_MSG_NEWSET: 6530 6543 nft_clear(net, nft_trans_set(trans)); ··· 6614 6621 nf_tables_rule_destroy(&trans->ctx, nft_trans_rule(trans)); 6615 6622 break; 6616 6623 case NFT_MSG_NEWSET: 6617 - nft_set_destroy(nft_trans_set(trans)); 6624 + if (!nft_trans_set_bound(trans)) 6625 + nft_set_destroy(nft_trans_set(trans)); 6618 6626 break; 6619 6627 case NFT_MSG_NEWSETELEM: 6620 6628 nft_set_elem_destroy(nft_trans_elem_set(trans), ··· 6676 6682 case NFT_MSG_NEWRULE: 6677 6683 trans->ctx.chain->use--; 6678 6684 list_del_rcu(&nft_trans_rule(trans)->list); 6679 - nft_rule_expr_deactivate(&trans->ctx, nft_trans_rule(trans)); 6685 + nft_rule_expr_deactivate(&trans->ctx, 6686 + nft_trans_rule(trans), 6687 + NFT_TRANS_ABORT); 6680 6688 break; 6681 6689 case NFT_MSG_DELRULE: 6682 6690 trans->ctx.chain->use++; ··· 6688 6692 break; 6689 6693 case NFT_MSG_NEWSET: 6690 6694 trans->ctx.table->use--; 6691 - list_del_rcu(&nft_trans_set(trans)->list); 6695 + if (!nft_trans_set_bound(trans)) 6696 + list_del_rcu(&nft_trans_set(trans)->list); 6692 6697 break; 6693 6698 case NFT_MSG_DELSET: 6694 6699 trans->ctx.table->use++;
+25 -37
net/netfilter/nft_compat.c
··· 61 61 return net_generic(net, nft_compat_net_id); 62 62 } 63 63 64 + static void nft_xt_get(struct nft_xt *xt) 65 + { 66 + /* refcount_inc() warns on 0 -> 1 transition, but we can't 67 + * init the reference count to 1 in .select_ops -- we can't 68 + * undo such an increase when another expression inside the same 69 + * rule fails afterwards. 70 + */ 71 + if (xt->listcnt == 0) 72 + refcount_set(&xt->refcnt, 1); 73 + else 74 + refcount_inc(&xt->refcnt); 75 + 76 + xt->listcnt++; 77 + } 78 + 64 79 static bool nft_xt_put(struct nft_xt *xt) 65 80 { 66 81 if (refcount_dec_and_test(&xt->refcnt)) { ··· 306 291 return -EINVAL; 307 292 308 293 nft_xt = container_of(expr->ops, struct nft_xt, ops); 309 - refcount_inc(&nft_xt->refcnt); 294 + nft_xt_get(nft_xt); 310 295 return 0; 311 296 } 312 297 ··· 519 504 return ret; 520 505 521 506 nft_xt = container_of(expr->ops, struct nft_xt, ops); 522 - refcount_inc(&nft_xt->refcnt); 507 + nft_xt_get(nft_xt); 523 508 return 0; 524 509 } 525 510 ··· 573 558 __nft_match_destroy(ctx, expr, nft_expr_priv(expr)); 574 559 } 575 560 576 - static void nft_compat_activate(const struct nft_ctx *ctx, 577 - const struct nft_expr *expr, 578 - struct list_head *h) 579 - { 580 - struct nft_xt *xt = container_of(expr->ops, struct nft_xt, ops); 581 - 582 - if (xt->listcnt == 0) 583 - list_add(&xt->head, h); 584 - 585 - xt->listcnt++; 586 - } 587 - 588 - static void nft_compat_activate_mt(const struct nft_ctx *ctx, 589 - const struct nft_expr *expr) 590 - { 591 - struct nft_compat_net *cn = nft_compat_pernet(ctx->net); 592 - 593 - nft_compat_activate(ctx, expr, &cn->nft_match_list); 594 - } 595 - 596 - static void nft_compat_activate_tg(const struct nft_ctx *ctx, 597 - const struct nft_expr *expr) 598 - { 599 - struct nft_compat_net *cn = nft_compat_pernet(ctx->net); 600 - 601 - nft_compat_activate(ctx, expr, &cn->nft_target_list); 602 - } 603 - 604 561 static void nft_compat_deactivate(const struct nft_ctx *ctx, 605 - const struct nft_expr *expr) 562 + const struct nft_expr *expr, 563 + enum nft_trans_phase phase) 606 564 { 607 565 struct nft_xt *xt = container_of(expr->ops, struct nft_xt, ops); 608 566 609 - if (--xt->listcnt == 0) 610 - list_del_init(&xt->head); 567 + if (phase == NFT_TRANS_ABORT || phase == NFT_TRANS_COMMIT) { 568 + if (--xt->listcnt == 0) 569 + list_del_init(&xt->head); 570 + } 611 571 } 612 572 613 573 static void ··· 838 848 nft_match->ops.eval = nft_match_eval; 839 849 nft_match->ops.init = nft_match_init; 840 850 nft_match->ops.destroy = nft_match_destroy; 841 - nft_match->ops.activate = nft_compat_activate_mt; 842 851 nft_match->ops.deactivate = nft_compat_deactivate; 843 852 nft_match->ops.dump = nft_match_dump; 844 853 nft_match->ops.validate = nft_match_validate; ··· 855 866 856 867 nft_match->ops.size = matchsize; 857 868 858 - nft_match->listcnt = 1; 869 + nft_match->listcnt = 0; 859 870 list_add(&nft_match->head, &cn->nft_match_list); 860 871 861 872 return &nft_match->ops; ··· 942 953 nft_target->ops.size = NFT_EXPR_SIZE(XT_ALIGN(target->targetsize)); 943 954 nft_target->ops.init = nft_target_init; 944 955 nft_target->ops.destroy = nft_target_destroy; 945 - nft_target->ops.activate = nft_compat_activate_tg; 946 956 nft_target->ops.deactivate = nft_compat_deactivate; 947 957 nft_target->ops.dump = nft_target_dump; 948 958 nft_target->ops.validate = nft_target_validate; ··· 952 964 else 953 965 nft_target->ops.eval = nft_target_eval_xt; 954 966 955 - nft_target->listcnt = 1; 967 + nft_target->listcnt = 0; 956 968 list_add(&nft_target->head, &cn->nft_target_list); 957 969 958 970 return &nft_target->ops;
+7 -11
net/netfilter/nft_dynset.c
··· 235 235 return err; 236 236 } 237 237 238 - static void nft_dynset_activate(const struct nft_ctx *ctx, 239 - const struct nft_expr *expr) 240 - { 241 - struct nft_dynset *priv = nft_expr_priv(expr); 242 - 243 - nf_tables_rebind_set(ctx, priv->set, &priv->binding); 244 - } 245 - 246 238 static void nft_dynset_deactivate(const struct nft_ctx *ctx, 247 - const struct nft_expr *expr) 239 + const struct nft_expr *expr, 240 + enum nft_trans_phase phase) 248 241 { 249 242 struct nft_dynset *priv = nft_expr_priv(expr); 250 243 251 - nf_tables_unbind_set(ctx, priv->set, &priv->binding); 244 + if (phase == NFT_TRANS_PREPARE) 245 + return; 246 + 247 + nf_tables_unbind_set(ctx, priv->set, &priv->binding, 248 + phase == NFT_TRANS_COMMIT); 252 249 } 253 250 254 251 static void nft_dynset_destroy(const struct nft_ctx *ctx, ··· 293 296 .eval = nft_dynset_eval, 294 297 .init = nft_dynset_init, 295 298 .destroy = nft_dynset_destroy, 296 - .activate = nft_dynset_activate, 297 299 .deactivate = nft_dynset_deactivate, 298 300 .dump = nft_dynset_dump, 299 301 };
+5 -1
net/netfilter/nft_immediate.c
··· 72 72 } 73 73 74 74 static void nft_immediate_deactivate(const struct nft_ctx *ctx, 75 - const struct nft_expr *expr) 75 + const struct nft_expr *expr, 76 + enum nft_trans_phase phase) 76 77 { 77 78 const struct nft_immediate_expr *priv = nft_expr_priv(expr); 79 + 80 + if (phase == NFT_TRANS_COMMIT) 81 + return; 78 82 79 83 return nft_data_release(&priv->data, nft_dreg_to_type(priv->dreg)); 80 84 }
+7 -11
net/netfilter/nft_lookup.c
··· 121 121 return 0; 122 122 } 123 123 124 - static void nft_lookup_activate(const struct nft_ctx *ctx, 125 - const struct nft_expr *expr) 126 - { 127 - struct nft_lookup *priv = nft_expr_priv(expr); 128 - 129 - nf_tables_rebind_set(ctx, priv->set, &priv->binding); 130 - } 131 - 132 124 static void nft_lookup_deactivate(const struct nft_ctx *ctx, 133 - const struct nft_expr *expr) 125 + const struct nft_expr *expr, 126 + enum nft_trans_phase phase) 134 127 { 135 128 struct nft_lookup *priv = nft_expr_priv(expr); 136 129 137 - nf_tables_unbind_set(ctx, priv->set, &priv->binding); 130 + if (phase == NFT_TRANS_PREPARE) 131 + return; 132 + 133 + nf_tables_unbind_set(ctx, priv->set, &priv->binding, 134 + phase == NFT_TRANS_COMMIT); 138 135 } 139 136 140 137 static void nft_lookup_destroy(const struct nft_ctx *ctx, ··· 222 225 .size = NFT_EXPR_SIZE(sizeof(struct nft_lookup)), 223 226 .eval = nft_lookup_eval, 224 227 .init = nft_lookup_init, 225 - .activate = nft_lookup_activate, 226 228 .deactivate = nft_lookup_deactivate, 227 229 .destroy = nft_lookup_destroy, 228 230 .dump = nft_lookup_dump,
+7 -11
net/netfilter/nft_objref.c
··· 155 155 return -1; 156 156 } 157 157 158 - static void nft_objref_map_activate(const struct nft_ctx *ctx, 159 - const struct nft_expr *expr) 160 - { 161 - struct nft_objref_map *priv = nft_expr_priv(expr); 162 - 163 - nf_tables_rebind_set(ctx, priv->set, &priv->binding); 164 - } 165 - 166 158 static void nft_objref_map_deactivate(const struct nft_ctx *ctx, 167 - const struct nft_expr *expr) 159 + const struct nft_expr *expr, 160 + enum nft_trans_phase phase) 168 161 { 169 162 struct nft_objref_map *priv = nft_expr_priv(expr); 170 163 171 - nf_tables_unbind_set(ctx, priv->set, &priv->binding); 164 + if (phase == NFT_TRANS_PREPARE) 165 + return; 166 + 167 + nf_tables_unbind_set(ctx, priv->set, &priv->binding, 168 + phase == NFT_TRANS_COMMIT); 172 169 } 173 170 174 171 static void nft_objref_map_destroy(const struct nft_ctx *ctx, ··· 182 185 .size = NFT_EXPR_SIZE(sizeof(struct nft_objref_map)), 183 186 .eval = nft_objref_map_eval, 184 187 .init = nft_objref_map_init, 185 - .activate = nft_objref_map_activate, 186 188 .deactivate = nft_objref_map_deactivate, 187 189 .destroy = nft_objref_map_destroy, 188 190 .dump = nft_objref_map_dump,
+3 -3
net/rds/bind.c
··· 78 78 __rds_create_bind_key(key, addr, port, scope_id); 79 79 rcu_read_lock(); 80 80 rs = rhashtable_lookup(&bind_hash_table, key, ht_parms); 81 - if (rs && !sock_flag(rds_rs_to_sk(rs), SOCK_DEAD)) 82 - rds_sock_addref(rs); 83 - else 81 + if (rs && (sock_flag(rds_rs_to_sk(rs), SOCK_DEAD) || 82 + !refcount_inc_not_zero(&rds_rs_to_sk(rs)->sk_refcnt))) 84 83 rs = NULL; 84 + 85 85 rcu_read_unlock(); 86 86 87 87 rdsdebug("returning rs %p for %pI6c:%u\n", rs, addr,
+2 -1
net/rxrpc/recvmsg.c
··· 596 596 } 597 597 error_no_call: 598 598 release_sock(&rx->sk); 599 + error_trace: 599 600 trace_rxrpc_recvmsg(call, rxrpc_recvmsg_return, 0, 0, 0, ret); 600 601 return ret; 601 602 ··· 605 604 wait_error: 606 605 finish_wait(sk_sleep(&rx->sk), &wait); 607 606 call = NULL; 608 - goto error_no_call; 607 + goto error_trace; 609 608 } 610 609 611 610 /**
+5 -1
net/sched/cls_flower.c
··· 1371 1371 if (!tc_skip_hw(fnew->flags)) { 1372 1372 err = fl_hw_replace_filter(tp, fnew, extack); 1373 1373 if (err) 1374 - goto errout_mask; 1374 + goto errout_mask_ht; 1375 1375 } 1376 1376 1377 1377 if (!tc_in_hw(fnew->flags)) ··· 1400 1400 kfree(tb); 1401 1401 kfree(mask); 1402 1402 return 0; 1403 + 1404 + errout_mask_ht: 1405 + rhashtable_remove_fast(&fnew->mask->ht, &fnew->ht_node, 1406 + fnew->mask->filter_ht_params); 1403 1407 1404 1408 errout_mask: 1405 1409 fl_mask_put(head, fnew->mask, false);
+2 -2
net/sctp/socket.c
··· 2027 2027 struct sctp_endpoint *ep = sctp_sk(sk)->ep; 2028 2028 struct sctp_transport *transport = NULL; 2029 2029 struct sctp_sndrcvinfo _sinfo, *sinfo; 2030 - struct sctp_association *asoc; 2030 + struct sctp_association *asoc, *tmp; 2031 2031 struct sctp_cmsgs cmsgs; 2032 2032 union sctp_addr *daddr; 2033 2033 bool new = false; ··· 2053 2053 2054 2054 /* SCTP_SENDALL process */ 2055 2055 if ((sflags & SCTP_SENDALL) && sctp_style(sk, UDP)) { 2056 - list_for_each_entry(asoc, &ep->asocs, asocs) { 2056 + list_for_each_entry_safe(asoc, tmp, &ep->asocs, asocs) { 2057 2057 err = sctp_sendmsg_check_sflags(asoc, sflags, msg, 2058 2058 msg_len); 2059 2059 if (err == 0)
+20
net/sctp/stream.c
··· 84 84 } 85 85 } 86 86 87 + static size_t fa_index(struct flex_array *fa, void *elem, size_t count) 88 + { 89 + size_t index = 0; 90 + 91 + while (count--) { 92 + if (elem == flex_array_get(fa, index)) 93 + break; 94 + index++; 95 + } 96 + 97 + return index; 98 + } 99 + 87 100 /* Migrates chunks from stream queues to new stream queues if needed, 88 101 * but not across associations. Also, removes those chunks to streams 89 102 * higher than the new max. ··· 160 147 161 148 if (stream->out) { 162 149 fa_copy(out, stream->out, 0, min(outcnt, stream->outcnt)); 150 + if (stream->out_curr) { 151 + size_t index = fa_index(stream->out, stream->out_curr, 152 + stream->outcnt); 153 + 154 + BUG_ON(index == stream->outcnt); 155 + stream->out_curr = flex_array_get(out, index); 156 + } 163 157 fa_free(stream->out); 164 158 } 165 159
+10 -1
net/smc/af_smc.c
··· 1505 1505 1506 1506 smc = smc_sk(sk); 1507 1507 lock_sock(sk); 1508 + if (sk->sk_state == SMC_CLOSED && (sk->sk_shutdown & RCV_SHUTDOWN)) { 1509 + /* socket was connected before, no more data to read */ 1510 + rc = 0; 1511 + goto out; 1512 + } 1508 1513 if ((sk->sk_state == SMC_INIT) || 1509 1514 (sk->sk_state == SMC_LISTEN) || 1510 1515 (sk->sk_state == SMC_CLOSED)) ··· 1845 1840 1846 1841 smc = smc_sk(sk); 1847 1842 lock_sock(sk); 1848 - 1843 + if (sk->sk_state == SMC_CLOSED && (sk->sk_shutdown & RCV_SHUTDOWN)) { 1844 + /* socket was connected before, no more data to read */ 1845 + rc = 0; 1846 + goto out; 1847 + } 1849 1848 if (sk->sk_state == SMC_INIT || 1850 1849 sk->sk_state == SMC_LISTEN || 1851 1850 sk->sk_state == SMC_CLOSED)
+10 -11
net/smc/smc_cdc.c
··· 21 21 22 22 /********************************** send *************************************/ 23 23 24 - struct smc_cdc_tx_pend { 25 - struct smc_connection *conn; /* socket connection */ 26 - union smc_host_cursor cursor; /* tx sndbuf cursor sent */ 27 - union smc_host_cursor p_cursor; /* rx RMBE cursor produced */ 28 - u16 ctrl_seq; /* conn. tx sequence # */ 29 - }; 30 - 31 24 /* handler for send/transmission completion of a CDC msg */ 32 25 static void smc_cdc_tx_handler(struct smc_wr_tx_pend_priv *pnd_snd, 33 26 struct smc_link *link, ··· 54 61 55 62 int smc_cdc_get_free_slot(struct smc_connection *conn, 56 63 struct smc_wr_buf **wr_buf, 64 + struct smc_rdma_wr **wr_rdma_buf, 57 65 struct smc_cdc_tx_pend **pend) 58 66 { 59 67 struct smc_link *link = &conn->lgr->lnk[SMC_SINGLE_LINK]; 60 68 int rc; 61 69 62 70 rc = smc_wr_tx_get_free_slot(link, smc_cdc_tx_handler, wr_buf, 71 + wr_rdma_buf, 63 72 (struct smc_wr_tx_pend_priv **)pend); 64 73 if (!conn->alert_token_local) 65 74 /* abnormal termination */ ··· 91 96 struct smc_wr_buf *wr_buf, 92 97 struct smc_cdc_tx_pend *pend) 93 98 { 99 + union smc_host_cursor cfed; 94 100 struct smc_link *link; 95 101 int rc; 96 102 ··· 103 107 conn->local_tx_ctrl.seqno = conn->tx_cdc_seq; 104 108 smc_host_msg_to_cdc((struct smc_cdc_msg *)wr_buf, 105 109 &conn->local_tx_ctrl, conn); 110 + smc_curs_copy(&cfed, &((struct smc_host_cdc_msg *)wr_buf)->cons, conn); 106 111 rc = smc_wr_tx_send(link, (struct smc_wr_tx_pend_priv *)pend); 107 112 if (!rc) 108 - smc_curs_copy(&conn->rx_curs_confirmed, 109 - &conn->local_tx_ctrl.cons, conn); 113 + smc_curs_copy(&conn->rx_curs_confirmed, &cfed, conn); 110 114 111 115 return rc; 112 116 } ··· 117 121 struct smc_wr_buf *wr_buf; 118 122 int rc; 119 123 120 - rc = smc_cdc_get_free_slot(conn, &wr_buf, &pend); 124 + rc = smc_cdc_get_free_slot(conn, &wr_buf, NULL, &pend); 121 125 if (rc) 122 126 return rc; 123 127 124 - return smc_cdc_msg_send(conn, wr_buf, pend); 128 + spin_lock_bh(&conn->send_lock); 129 + rc = smc_cdc_msg_send(conn, wr_buf, pend); 130 + spin_unlock_bh(&conn->send_lock); 131 + return rc; 125 132 } 126 133 127 134 int smc_cdc_get_slot_and_msg_send(struct smc_connection *conn)
+32 -2
net/smc/smc_cdc.h
··· 160 160 #endif 161 161 } 162 162 163 - /* calculate cursor difference between old and new, where old <= new */ 163 + /* calculate cursor difference between old and new, where old <= new and 164 + * difference cannot exceed size 165 + */ 164 166 static inline int smc_curs_diff(unsigned int size, 165 167 union smc_host_cursor *old, 166 168 union smc_host_cursor *new) ··· 185 183 (old->wrap == new->wrap && old->count > new->count)) 186 184 return -smc_curs_diff(size, new, old); 187 185 return smc_curs_diff(size, old, new); 186 + } 187 + 188 + /* calculate cursor difference between old and new, where old <= new and 189 + * difference may exceed size 190 + */ 191 + static inline int smc_curs_diff_large(unsigned int size, 192 + union smc_host_cursor *old, 193 + union smc_host_cursor *new) 194 + { 195 + if (old->wrap < new->wrap) 196 + return min_t(int, 197 + (size - old->count) + new->count + 198 + (new->wrap - old->wrap - 1) * size, 199 + size); 200 + 201 + if (old->wrap > new->wrap) /* wrap has switched from 0xffff to 0x0000 */ 202 + return min_t(int, 203 + (size - old->count) + new->count + 204 + (new->wrap + 0xffff - old->wrap) * size, 205 + size); 206 + 207 + return max_t(int, 0, (new->count - old->count)); 188 208 } 189 209 190 210 static inline void smc_host_cursor_to_cdc(union smc_cdc_cursor *peer, ··· 294 270 smcr_cdc_msg_to_host(local, peer, conn); 295 271 } 296 272 297 - struct smc_cdc_tx_pend; 273 + struct smc_cdc_tx_pend { 274 + struct smc_connection *conn; /* socket connection */ 275 + union smc_host_cursor cursor; /* tx sndbuf cursor sent */ 276 + union smc_host_cursor p_cursor; /* rx RMBE cursor produced */ 277 + u16 ctrl_seq; /* conn. tx sequence # */ 278 + }; 298 279 299 280 int smc_cdc_get_free_slot(struct smc_connection *conn, 300 281 struct smc_wr_buf **wr_buf, 282 + struct smc_rdma_wr **wr_rdma_buf, 301 283 struct smc_cdc_tx_pend **pend); 302 284 void smc_cdc_tx_dismiss_slots(struct smc_connection *conn); 303 285 int smc_cdc_msg_send(struct smc_connection *conn, struct smc_wr_buf *wr_buf,
+1 -1
net/smc/smc_clc.c
··· 378 378 vec.iov_len = sizeof(struct smc_clc_msg_decline); 379 379 len = kernel_sendmsg(smc->clcsock, &msg, &vec, 1, 380 380 sizeof(struct smc_clc_msg_decline)); 381 - if (len < sizeof(struct smc_clc_msg_decline)) 381 + if (len < 0 || len < sizeof(struct smc_clc_msg_decline)) 382 382 len = -EPROTO; 383 383 return len > 0 ? 0 : len; 384 384 }
+1 -8
net/smc/smc_close.c
··· 345 345 346 346 switch (sk->sk_state) { 347 347 case SMC_INIT: 348 - if (atomic_read(&conn->bytes_to_rcv) || 349 - (rxflags->peer_done_writing && 350 - !smc_cdc_rxed_any_close(conn))) { 351 - sk->sk_state = SMC_APPCLOSEWAIT1; 352 - } else { 353 - sk->sk_state = SMC_CLOSED; 354 - sock_put(sk); /* passive closing */ 355 - } 348 + sk->sk_state = SMC_APPCLOSEWAIT1; 356 349 break; 357 350 case SMC_ACTIVE: 358 351 sk->sk_state = SMC_APPCLOSEWAIT1;
+5 -1
net/smc/smc_core.c
··· 128 128 { 129 129 struct smc_link_group *lgr = conn->lgr; 130 130 131 + if (!lgr) 132 + return; 131 133 write_lock_bh(&lgr->conns_lock); 132 134 if (conn->alert_token_local) { 133 135 __smc_lgr_unregister_conn(conn); ··· 302 300 conn->sndbuf_desc->used = 0; 303 301 if (conn->rmb_desc) { 304 302 if (!conn->rmb_desc->regerr) { 305 - conn->rmb_desc->used = 0; 306 303 if (!lgr->is_smcd) { 307 304 /* unregister rmb with peer */ 308 305 smc_llc_do_delete_rkey( 309 306 &lgr->lnk[SMC_SINGLE_LINK], 310 307 conn->rmb_desc); 311 308 } 309 + conn->rmb_desc->used = 0; 312 310 } else { 313 311 /* buf registration failed, reuse not possible */ 314 312 write_lock_bh(&lgr->rmbs_lock); ··· 630 628 local_contact = SMC_REUSE_CONTACT; 631 629 conn->lgr = lgr; 632 630 smc_lgr_register_conn(conn); /* add smc conn to lgr */ 631 + if (delayed_work_pending(&lgr->free_work)) 632 + cancel_delayed_work(&lgr->free_work); 633 633 write_unlock_bh(&lgr->conns_lock); 634 634 break; 635 635 }
+20
net/smc/smc_core.h
··· 52 52 FAILED /* ib_wr_reg_mr response: failure */ 53 53 }; 54 54 55 + struct smc_rdma_sge { /* sges for RDMA writes */ 56 + struct ib_sge wr_tx_rdma_sge[SMC_IB_MAX_SEND_SGE]; 57 + }; 58 + 59 + #define SMC_MAX_RDMA_WRITES 2 /* max. # of RDMA writes per 60 + * message send 61 + */ 62 + 63 + struct smc_rdma_sges { /* sges per message send */ 64 + struct smc_rdma_sge tx_rdma_sge[SMC_MAX_RDMA_WRITES]; 65 + }; 66 + 67 + struct smc_rdma_wr { /* work requests per message 68 + * send 69 + */ 70 + struct ib_rdma_wr wr_tx_rdma[SMC_MAX_RDMA_WRITES]; 71 + }; 72 + 55 73 struct smc_link { 56 74 struct smc_ib_device *smcibdev; /* ib-device */ 57 75 u8 ibport; /* port - values 1 | 2 */ ··· 82 64 struct smc_wr_buf *wr_tx_bufs; /* WR send payload buffers */ 83 65 struct ib_send_wr *wr_tx_ibs; /* WR send meta data */ 84 66 struct ib_sge *wr_tx_sges; /* WR send gather meta data */ 67 + struct smc_rdma_sges *wr_tx_rdma_sges;/*RDMA WRITE gather meta data*/ 68 + struct smc_rdma_wr *wr_tx_rdmas; /* WR RDMA WRITE */ 85 69 struct smc_wr_tx_pend *wr_tx_pends; /* WR send waiting for CQE */ 86 70 /* above four vectors have wr_tx_cnt elements and use the same index */ 87 71 dma_addr_t wr_tx_dma_addr; /* DMA address of wr_tx_bufs */
+3 -3
net/smc/smc_ib.c
··· 289 289 290 290 static void smc_ib_qp_event_handler(struct ib_event *ibevent, void *priv) 291 291 { 292 - struct smc_ib_device *smcibdev = 293 - (struct smc_ib_device *)ibevent->device; 292 + struct smc_link *lnk = (struct smc_link *)priv; 293 + struct smc_ib_device *smcibdev = lnk->smcibdev; 294 294 u8 port_idx; 295 295 296 296 switch (ibevent->event) { ··· 298 298 case IB_EVENT_GID_CHANGE: 299 299 case IB_EVENT_PORT_ERR: 300 300 case IB_EVENT_QP_ACCESS_ERR: 301 - port_idx = ibevent->element.port_num - 1; 301 + port_idx = ibevent->element.qp->port - 1; 302 302 set_bit(port_idx, &smcibdev->port_event_mask); 303 303 schedule_work(&smcibdev->port_event_work); 304 304 break;
+2 -1
net/smc/smc_llc.c
··· 166 166 { 167 167 int rc; 168 168 169 - rc = smc_wr_tx_get_free_slot(link, smc_llc_tx_handler, wr_buf, pend); 169 + rc = smc_wr_tx_get_free_slot(link, smc_llc_tx_handler, wr_buf, NULL, 170 + pend); 170 171 if (rc < 0) 171 172 return rc; 172 173 BUILD_BUG_ON_MSG(
+1 -1
net/smc/smc_pnet.c
··· 27 27 static struct nla_policy smc_pnet_policy[SMC_PNETID_MAX + 1] = { 28 28 [SMC_PNETID_NAME] = { 29 29 .type = NLA_NUL_STRING, 30 - .len = SMC_MAX_PNETID_LEN - 1 30 + .len = SMC_MAX_PNETID_LEN 31 31 }, 32 32 [SMC_PNETID_ETHNAME] = { 33 33 .type = NLA_NUL_STRING,
+31 -33
net/smc/smc_tx.c
··· 165 165 conn->local_tx_ctrl.prod_flags.urg_data_pending = 1; 166 166 167 167 if (!atomic_read(&conn->sndbuf_space) || conn->urg_tx_pend) { 168 + if (send_done) 169 + return send_done; 168 170 rc = smc_tx_wait(smc, msg->msg_flags); 169 - if (rc) { 170 - if (send_done) 171 - return send_done; 171 + if (rc) 172 172 goto out_err; 173 - } 174 173 continue; 175 174 } 176 175 ··· 266 267 267 268 /* sndbuf consumer: actual data transfer of one target chunk with RDMA write */ 268 269 static int smc_tx_rdma_write(struct smc_connection *conn, int peer_rmbe_offset, 269 - int num_sges, struct ib_sge sges[]) 270 + int num_sges, struct ib_rdma_wr *rdma_wr) 270 271 { 271 272 struct smc_link_group *lgr = conn->lgr; 272 - struct ib_rdma_wr rdma_wr; 273 273 struct smc_link *link; 274 274 int rc; 275 275 276 - memset(&rdma_wr, 0, sizeof(rdma_wr)); 277 276 link = &lgr->lnk[SMC_SINGLE_LINK]; 278 - rdma_wr.wr.wr_id = smc_wr_tx_get_next_wr_id(link); 279 - rdma_wr.wr.sg_list = sges; 280 - rdma_wr.wr.num_sge = num_sges; 281 - rdma_wr.wr.opcode = IB_WR_RDMA_WRITE; 282 - rdma_wr.remote_addr = 277 + rdma_wr->wr.wr_id = smc_wr_tx_get_next_wr_id(link); 278 + rdma_wr->wr.num_sge = num_sges; 279 + rdma_wr->remote_addr = 283 280 lgr->rtokens[conn->rtoken_idx][SMC_SINGLE_LINK].dma_addr + 284 281 /* RMBE within RMB */ 285 282 conn->tx_off + 286 283 /* offset within RMBE */ 287 284 peer_rmbe_offset; 288 - rdma_wr.rkey = lgr->rtokens[conn->rtoken_idx][SMC_SINGLE_LINK].rkey; 289 - rc = ib_post_send(link->roce_qp, &rdma_wr.wr, NULL); 285 + rdma_wr->rkey = lgr->rtokens[conn->rtoken_idx][SMC_SINGLE_LINK].rkey; 286 + rc = ib_post_send(link->roce_qp, &rdma_wr->wr, NULL); 290 287 if (rc) { 291 288 conn->local_tx_ctrl.conn_state_flags.peer_conn_abort = 1; 292 289 smc_lgr_terminate(lgr); ··· 309 314 /* SMC-R helper for smc_tx_rdma_writes() */ 310 315 static int smcr_tx_rdma_writes(struct smc_connection *conn, size_t len, 311 316 size_t src_off, size_t src_len, 312 - size_t dst_off, size_t dst_len) 317 + size_t dst_off, size_t dst_len, 318 + struct smc_rdma_wr *wr_rdma_buf) 313 319 { 314 320 dma_addr_t dma_addr = 315 321 sg_dma_address(conn->sndbuf_desc->sgt[SMC_SINGLE_LINK].sgl); 316 - struct smc_link *link = &conn->lgr->lnk[SMC_SINGLE_LINK]; 317 322 int src_len_sum = src_len, dst_len_sum = dst_len; 318 - struct ib_sge sges[SMC_IB_MAX_SEND_SGE]; 319 323 int sent_count = src_off; 320 324 int srcchunk, dstchunk; 321 325 int num_sges; 322 326 int rc; 323 327 324 328 for (dstchunk = 0; dstchunk < 2; dstchunk++) { 329 + struct ib_sge *sge = 330 + wr_rdma_buf->wr_tx_rdma[dstchunk].wr.sg_list; 331 + 325 332 num_sges = 0; 326 333 for (srcchunk = 0; srcchunk < 2; srcchunk++) { 327 - sges[srcchunk].addr = dma_addr + src_off; 328 - sges[srcchunk].length = src_len; 329 - sges[srcchunk].lkey = link->roce_pd->local_dma_lkey; 334 + sge[srcchunk].addr = dma_addr + src_off; 335 + sge[srcchunk].length = src_len; 330 336 num_sges++; 331 337 332 338 src_off += src_len; ··· 340 344 src_len = dst_len - src_len; /* remainder */ 341 345 src_len_sum += src_len; 342 346 } 343 - rc = smc_tx_rdma_write(conn, dst_off, num_sges, sges); 347 + rc = smc_tx_rdma_write(conn, dst_off, num_sges, 348 + &wr_rdma_buf->wr_tx_rdma[dstchunk]); 344 349 if (rc) 345 350 return rc; 346 351 if (dst_len_sum == len) ··· 400 403 /* sndbuf consumer: prepare all necessary (src&dst) chunks of data transmit; 401 404 * usable snd_wnd as max transmit 402 405 */ 403 - static int smc_tx_rdma_writes(struct smc_connection *conn) 406 + static int smc_tx_rdma_writes(struct smc_connection *conn, 407 + struct smc_rdma_wr *wr_rdma_buf) 404 408 { 405 409 size_t len, src_len, dst_off, dst_len; /* current chunk values */ 406 410 union smc_host_cursor sent, prep, prod, cons; ··· 462 464 dst_off, dst_len); 463 465 else 464 466 rc = smcr_tx_rdma_writes(conn, len, sent.count, src_len, 465 - dst_off, dst_len); 467 + dst_off, dst_len, wr_rdma_buf); 466 468 if (rc) 467 469 return rc; 468 470 ··· 483 485 static int smcr_tx_sndbuf_nonempty(struct smc_connection *conn) 484 486 { 485 487 struct smc_cdc_producer_flags *pflags; 488 + struct smc_rdma_wr *wr_rdma_buf; 486 489 struct smc_cdc_tx_pend *pend; 487 490 struct smc_wr_buf *wr_buf; 488 491 int rc; 489 492 490 - spin_lock_bh(&conn->send_lock); 491 - rc = smc_cdc_get_free_slot(conn, &wr_buf, &pend); 493 + rc = smc_cdc_get_free_slot(conn, &wr_buf, &wr_rdma_buf, &pend); 492 494 if (rc < 0) { 493 495 if (rc == -EBUSY) { 494 496 struct smc_sock *smc = 495 497 container_of(conn, struct smc_sock, conn); 496 498 497 - if (smc->sk.sk_err == ECONNABORTED) { 498 - rc = sock_error(&smc->sk); 499 - goto out_unlock; 500 - } 499 + if (smc->sk.sk_err == ECONNABORTED) 500 + return sock_error(&smc->sk); 501 501 rc = 0; 502 502 if (conn->alert_token_local) /* connection healthy */ 503 503 mod_delayed_work(system_wq, &conn->tx_work, 504 504 SMC_TX_WORK_DELAY); 505 505 } 506 - goto out_unlock; 506 + return rc; 507 507 } 508 508 509 + spin_lock_bh(&conn->send_lock); 509 510 if (!conn->local_tx_ctrl.prod_flags.urg_data_present) { 510 - rc = smc_tx_rdma_writes(conn); 511 + rc = smc_tx_rdma_writes(conn, wr_rdma_buf); 511 512 if (rc) { 512 513 smc_wr_tx_put_slot(&conn->lgr->lnk[SMC_SINGLE_LINK], 513 514 (struct smc_wr_tx_pend_priv *)pend); ··· 533 536 534 537 spin_lock_bh(&conn->send_lock); 535 538 if (!pflags->urg_data_present) 536 - rc = smc_tx_rdma_writes(conn); 539 + rc = smc_tx_rdma_writes(conn, NULL); 537 540 if (!rc) 538 541 rc = smcd_cdc_msg_send(conn); 539 542 ··· 595 598 if (to_confirm > conn->rmbe_update_limit) { 596 599 smc_curs_copy(&prod, &conn->local_rx_ctrl.prod, conn); 597 600 sender_free = conn->rmb_desc->len - 598 - smc_curs_diff(conn->rmb_desc->len, &prod, &cfed); 601 + smc_curs_diff_large(conn->rmb_desc->len, 602 + &cfed, &prod); 599 603 } 600 604 601 605 if (conn->local_rx_ctrl.prod_flags.cons_curs_upd_req ||
+41 -5
net/smc/smc_wr.c
··· 160 160 * @link: Pointer to smc_link used to later send the message. 161 161 * @handler: Send completion handler function pointer. 162 162 * @wr_buf: Out value returns pointer to message buffer. 163 + * @wr_rdma_buf: Out value returns pointer to rdma work request. 163 164 * @wr_pend_priv: Out value returns pointer serving as handler context. 164 165 * 165 166 * Return: 0 on success, or -errno on error. ··· 168 167 int smc_wr_tx_get_free_slot(struct smc_link *link, 169 168 smc_wr_tx_handler handler, 170 169 struct smc_wr_buf **wr_buf, 170 + struct smc_rdma_wr **wr_rdma_buf, 171 171 struct smc_wr_tx_pend_priv **wr_pend_priv) 172 172 { 173 173 struct smc_wr_tx_pend *wr_pend; ··· 206 204 wr_ib = &link->wr_tx_ibs[idx]; 207 205 wr_ib->wr_id = wr_id; 208 206 *wr_buf = &link->wr_tx_bufs[idx]; 207 + if (wr_rdma_buf) 208 + *wr_rdma_buf = &link->wr_tx_rdmas[idx]; 209 209 *wr_pend_priv = &wr_pend->priv; 210 210 return 0; 211 211 } ··· 222 218 u32 idx = pend->idx; 223 219 224 220 /* clear the full struct smc_wr_tx_pend including .priv */ 225 - memset(&link->wr_tx_pends[pend->idx], 0, 226 - sizeof(link->wr_tx_pends[pend->idx])); 227 - memset(&link->wr_tx_bufs[pend->idx], 0, 228 - sizeof(link->wr_tx_bufs[pend->idx])); 221 + memset(&link->wr_tx_pends[idx], 0, 222 + sizeof(link->wr_tx_pends[idx])); 223 + memset(&link->wr_tx_bufs[idx], 0, 224 + sizeof(link->wr_tx_bufs[idx])); 229 225 test_and_clear_bit(idx, link->wr_tx_mask); 230 226 return 1; 231 227 } ··· 469 465 lnk->wr_tx_dma_addr + i * SMC_WR_BUF_SIZE; 470 466 lnk->wr_tx_sges[i].length = SMC_WR_TX_SIZE; 471 467 lnk->wr_tx_sges[i].lkey = lnk->roce_pd->local_dma_lkey; 468 + lnk->wr_tx_rdma_sges[i].tx_rdma_sge[0].wr_tx_rdma_sge[0].lkey = 469 + lnk->roce_pd->local_dma_lkey; 470 + lnk->wr_tx_rdma_sges[i].tx_rdma_sge[0].wr_tx_rdma_sge[1].lkey = 471 + lnk->roce_pd->local_dma_lkey; 472 + lnk->wr_tx_rdma_sges[i].tx_rdma_sge[1].wr_tx_rdma_sge[0].lkey = 473 + lnk->roce_pd->local_dma_lkey; 474 + lnk->wr_tx_rdma_sges[i].tx_rdma_sge[1].wr_tx_rdma_sge[1].lkey = 475 + lnk->roce_pd->local_dma_lkey; 472 476 lnk->wr_tx_ibs[i].next = NULL; 473 477 lnk->wr_tx_ibs[i].sg_list = &lnk->wr_tx_sges[i]; 474 478 lnk->wr_tx_ibs[i].num_sge = 1; 475 479 lnk->wr_tx_ibs[i].opcode = IB_WR_SEND; 476 480 lnk->wr_tx_ibs[i].send_flags = 477 481 IB_SEND_SIGNALED | IB_SEND_SOLICITED; 482 + lnk->wr_tx_rdmas[i].wr_tx_rdma[0].wr.opcode = IB_WR_RDMA_WRITE; 483 + lnk->wr_tx_rdmas[i].wr_tx_rdma[1].wr.opcode = IB_WR_RDMA_WRITE; 484 + lnk->wr_tx_rdmas[i].wr_tx_rdma[0].wr.sg_list = 485 + lnk->wr_tx_rdma_sges[i].tx_rdma_sge[0].wr_tx_rdma_sge; 486 + lnk->wr_tx_rdmas[i].wr_tx_rdma[1].wr.sg_list = 487 + lnk->wr_tx_rdma_sges[i].tx_rdma_sge[1].wr_tx_rdma_sge; 478 488 } 479 489 for (i = 0; i < lnk->wr_rx_cnt; i++) { 480 490 lnk->wr_rx_sges[i].addr = ··· 539 521 lnk->wr_tx_mask = NULL; 540 522 kfree(lnk->wr_tx_sges); 541 523 lnk->wr_tx_sges = NULL; 524 + kfree(lnk->wr_tx_rdma_sges); 525 + lnk->wr_tx_rdma_sges = NULL; 542 526 kfree(lnk->wr_rx_sges); 543 527 lnk->wr_rx_sges = NULL; 528 + kfree(lnk->wr_tx_rdmas); 529 + lnk->wr_tx_rdmas = NULL; 544 530 kfree(lnk->wr_rx_ibs); 545 531 lnk->wr_rx_ibs = NULL; 546 532 kfree(lnk->wr_tx_ibs); ··· 574 552 GFP_KERNEL); 575 553 if (!link->wr_rx_ibs) 576 554 goto no_mem_wr_tx_ibs; 555 + link->wr_tx_rdmas = kcalloc(SMC_WR_BUF_CNT, 556 + sizeof(link->wr_tx_rdmas[0]), 557 + GFP_KERNEL); 558 + if (!link->wr_tx_rdmas) 559 + goto no_mem_wr_rx_ibs; 560 + link->wr_tx_rdma_sges = kcalloc(SMC_WR_BUF_CNT, 561 + sizeof(link->wr_tx_rdma_sges[0]), 562 + GFP_KERNEL); 563 + if (!link->wr_tx_rdma_sges) 564 + goto no_mem_wr_tx_rdmas; 577 565 link->wr_tx_sges = kcalloc(SMC_WR_BUF_CNT, sizeof(link->wr_tx_sges[0]), 578 566 GFP_KERNEL); 579 567 if (!link->wr_tx_sges) 580 - goto no_mem_wr_rx_ibs; 568 + goto no_mem_wr_tx_rdma_sges; 581 569 link->wr_rx_sges = kcalloc(SMC_WR_BUF_CNT * 3, 582 570 sizeof(link->wr_rx_sges[0]), 583 571 GFP_KERNEL); ··· 611 579 kfree(link->wr_rx_sges); 612 580 no_mem_wr_tx_sges: 613 581 kfree(link->wr_tx_sges); 582 + no_mem_wr_tx_rdma_sges: 583 + kfree(link->wr_tx_rdma_sges); 584 + no_mem_wr_tx_rdmas: 585 + kfree(link->wr_tx_rdmas); 614 586 no_mem_wr_rx_ibs: 615 587 kfree(link->wr_rx_ibs); 616 588 no_mem_wr_tx_ibs:
+1
net/smc/smc_wr.h
··· 85 85 86 86 int smc_wr_tx_get_free_slot(struct smc_link *link, smc_wr_tx_handler handler, 87 87 struct smc_wr_buf **wr_buf, 88 + struct smc_rdma_wr **wrs, 88 89 struct smc_wr_tx_pend_priv **wr_pend_priv); 89 90 int smc_wr_tx_put_slot(struct smc_link *link, 90 91 struct smc_wr_tx_pend_priv *wr_pend_priv);
+63 -19
net/socket.c
··· 941 941 EXPORT_SYMBOL(dlci_ioctl_set); 942 942 943 943 static long sock_do_ioctl(struct net *net, struct socket *sock, 944 - unsigned int cmd, unsigned long arg, 945 - unsigned int ifreq_size) 944 + unsigned int cmd, unsigned long arg) 946 945 { 947 946 int err; 948 947 void __user *argp = (void __user *)arg; ··· 967 968 } else { 968 969 struct ifreq ifr; 969 970 bool need_copyout; 970 - if (copy_from_user(&ifr, argp, ifreq_size)) 971 + if (copy_from_user(&ifr, argp, sizeof(struct ifreq))) 971 972 return -EFAULT; 972 973 err = dev_ioctl(net, cmd, &ifr, &need_copyout); 973 974 if (!err && need_copyout) 974 - if (copy_to_user(argp, &ifr, ifreq_size)) 975 + if (copy_to_user(argp, &ifr, sizeof(struct ifreq))) 975 976 return -EFAULT; 976 977 } 977 978 return err; ··· 1070 1071 err = open_related_ns(&net->ns, get_net_ns); 1071 1072 break; 1072 1073 default: 1073 - err = sock_do_ioctl(net, sock, cmd, arg, 1074 - sizeof(struct ifreq)); 1074 + err = sock_do_ioctl(net, sock, cmd, arg); 1075 1075 break; 1076 1076 } 1077 1077 return err; ··· 2778 2780 int err; 2779 2781 2780 2782 set_fs(KERNEL_DS); 2781 - err = sock_do_ioctl(net, sock, cmd, (unsigned long)&ktv, 2782 - sizeof(struct compat_ifreq)); 2783 + err = sock_do_ioctl(net, sock, cmd, (unsigned long)&ktv); 2783 2784 set_fs(old_fs); 2784 2785 if (!err) 2785 2786 err = compat_put_timeval(&ktv, up); ··· 2794 2797 int err; 2795 2798 2796 2799 set_fs(KERNEL_DS); 2797 - err = sock_do_ioctl(net, sock, cmd, (unsigned long)&kts, 2798 - sizeof(struct compat_ifreq)); 2800 + err = sock_do_ioctl(net, sock, cmd, (unsigned long)&kts); 2799 2801 set_fs(old_fs); 2800 2802 if (!err) 2801 2803 err = compat_put_timespec(&kts, up); ··· 2990 2994 return dev_ioctl(net, cmd, &ifreq, NULL); 2991 2995 } 2992 2996 2997 + static int compat_ifreq_ioctl(struct net *net, struct socket *sock, 2998 + unsigned int cmd, 2999 + struct compat_ifreq __user *uifr32) 3000 + { 3001 + struct ifreq __user *uifr; 3002 + int err; 3003 + 3004 + /* Handle the fact that while struct ifreq has the same *layout* on 3005 + * 32/64 for everything but ifreq::ifru_ifmap and ifreq::ifru_data, 3006 + * which are handled elsewhere, it still has different *size* due to 3007 + * ifreq::ifru_ifmap (which is 16 bytes on 32 bit, 24 bytes on 64-bit, 3008 + * resulting in struct ifreq being 32 and 40 bytes respectively). 3009 + * As a result, if the struct happens to be at the end of a page and 3010 + * the next page isn't readable/writable, we get a fault. To prevent 3011 + * that, copy back and forth to the full size. 3012 + */ 3013 + 3014 + uifr = compat_alloc_user_space(sizeof(*uifr)); 3015 + if (copy_in_user(uifr, uifr32, sizeof(*uifr32))) 3016 + return -EFAULT; 3017 + 3018 + err = sock_do_ioctl(net, sock, cmd, (unsigned long)uifr); 3019 + 3020 + if (!err) { 3021 + switch (cmd) { 3022 + case SIOCGIFFLAGS: 3023 + case SIOCGIFMETRIC: 3024 + case SIOCGIFMTU: 3025 + case SIOCGIFMEM: 3026 + case SIOCGIFHWADDR: 3027 + case SIOCGIFINDEX: 3028 + case SIOCGIFADDR: 3029 + case SIOCGIFBRDADDR: 3030 + case SIOCGIFDSTADDR: 3031 + case SIOCGIFNETMASK: 3032 + case SIOCGIFPFLAGS: 3033 + case SIOCGIFTXQLEN: 3034 + case SIOCGMIIPHY: 3035 + case SIOCGMIIREG: 3036 + case SIOCGIFNAME: 3037 + if (copy_in_user(uifr32, uifr, sizeof(*uifr32))) 3038 + err = -EFAULT; 3039 + break; 3040 + } 3041 + } 3042 + return err; 3043 + } 3044 + 2993 3045 static int compat_sioc_ifmap(struct net *net, unsigned int cmd, 2994 3046 struct compat_ifreq __user *uifr32) 2995 3047 { ··· 3153 3109 } 3154 3110 3155 3111 set_fs(KERNEL_DS); 3156 - ret = sock_do_ioctl(net, sock, cmd, (unsigned long) r, 3157 - sizeof(struct compat_ifreq)); 3112 + ret = sock_do_ioctl(net, sock, cmd, (unsigned long) r); 3158 3113 set_fs(old_fs); 3159 3114 3160 3115 out: ··· 3253 3210 case SIOCSIFTXQLEN: 3254 3211 case SIOCBRADDIF: 3255 3212 case SIOCBRDELIF: 3213 + case SIOCGIFNAME: 3256 3214 case SIOCSIFNAME: 3257 3215 case SIOCGMIIPHY: 3258 3216 case SIOCGMIIREG: 3259 3217 case SIOCSMIIREG: 3260 - case SIOCSARP: 3261 - case SIOCGARP: 3262 - case SIOCDARP: 3263 - case SIOCATMARK: 3264 3218 case SIOCBONDENSLAVE: 3265 3219 case SIOCBONDRELEASE: 3266 3220 case SIOCBONDSETHWADDR: 3267 3221 case SIOCBONDCHANGEACTIVE: 3268 - case SIOCGIFNAME: 3269 - return sock_do_ioctl(net, sock, cmd, arg, 3270 - sizeof(struct compat_ifreq)); 3222 + return compat_ifreq_ioctl(net, sock, cmd, argp); 3223 + 3224 + case SIOCSARP: 3225 + case SIOCGARP: 3226 + case SIOCDARP: 3227 + case SIOCATMARK: 3228 + return sock_do_ioctl(net, sock, cmd, arg); 3271 3229 } 3272 3230 3273 3231 return -ENOIOCTLCMD;
+21 -8
net/vmw_vsock/virtio_transport.c
··· 75 75 { 76 76 struct virtio_vsock *vsock = virtio_vsock_get(); 77 77 78 + if (!vsock) 79 + return VMADDR_CID_ANY; 80 + 78 81 return vsock->guest_cid; 79 82 } 80 83 ··· 587 584 588 585 virtio_vsock_update_guest_cid(vsock); 589 586 590 - ret = vsock_core_init(&virtio_transport.transport); 591 - if (ret < 0) 592 - goto out_vqs; 593 - 594 587 vsock->rx_buf_nr = 0; 595 588 vsock->rx_buf_max_nr = 0; 596 589 atomic_set(&vsock->queued_replies, 0); ··· 617 618 mutex_unlock(&the_virtio_vsock_mutex); 618 619 return 0; 619 620 620 - out_vqs: 621 - vsock->vdev->config->del_vqs(vsock->vdev); 622 621 out: 623 622 kfree(vsock); 624 623 mutex_unlock(&the_virtio_vsock_mutex); ··· 633 636 flush_work(&vsock->tx_work); 634 637 flush_work(&vsock->event_work); 635 638 flush_work(&vsock->send_pkt_work); 639 + 640 + /* Reset all connected sockets when the device disappear */ 641 + vsock_for_each_connected_socket(virtio_vsock_reset_sock); 636 642 637 643 vdev->config->reset(vdev); 638 644 ··· 669 669 670 670 mutex_lock(&the_virtio_vsock_mutex); 671 671 the_virtio_vsock = NULL; 672 - vsock_core_exit(); 673 672 mutex_unlock(&the_virtio_vsock_mutex); 674 673 675 674 vdev->config->del_vqs(vdev); ··· 701 702 virtio_vsock_workqueue = alloc_workqueue("virtio_vsock", 0, 0); 702 703 if (!virtio_vsock_workqueue) 703 704 return -ENOMEM; 705 + 704 706 ret = register_virtio_driver(&virtio_vsock_driver); 705 707 if (ret) 706 - destroy_workqueue(virtio_vsock_workqueue); 708 + goto out_wq; 709 + 710 + ret = vsock_core_init(&virtio_transport.transport); 711 + if (ret) 712 + goto out_vdr; 713 + 714 + return 0; 715 + 716 + out_vdr: 717 + unregister_virtio_driver(&virtio_vsock_driver); 718 + out_wq: 719 + destroy_workqueue(virtio_vsock_workqueue); 707 720 return ret; 721 + 708 722 } 709 723 710 724 static void __exit virtio_vsock_exit(void) 711 725 { 726 + vsock_core_exit(); 712 727 unregister_virtio_driver(&virtio_vsock_driver); 713 728 destroy_workqueue(virtio_vsock_workqueue); 714 729 }
+2
net/wireless/ap.c
··· 41 41 cfg80211_sched_dfs_chan_update(rdev); 42 42 } 43 43 44 + schedule_work(&cfg80211_disconnect_work); 45 + 44 46 return err; 45 47 } 46 48
+2
net/wireless/core.h
··· 445 445 bool cfg80211_does_bw_fit_range(const struct ieee80211_freq_range *freq_range, 446 446 u32 center_freq_khz, u32 bw_khz); 447 447 448 + extern struct work_struct cfg80211_disconnect_work; 449 + 448 450 /** 449 451 * cfg80211_chandef_dfs_usable - checks if chandef is DFS usable 450 452 * @wiphy: the wiphy to validate against
+1 -1
net/wireless/sme.c
··· 667 667 rtnl_unlock(); 668 668 } 669 669 670 - static DECLARE_WORK(cfg80211_disconnect_work, disconnect_work); 670 + DECLARE_WORK(cfg80211_disconnect_work, disconnect_work); 671 671 672 672 673 673 /*
+1 -5
tools/bpf/bpftool/common.c
··· 297 297 snprintf(path, sizeof(path), "/proc/self/fdinfo/%d", fd); 298 298 299 299 fdi = fopen(path, "r"); 300 - if (!fdi) { 301 - p_err("can't open fdinfo: %s", strerror(errno)); 300 + if (!fdi) 302 301 return NULL; 303 - } 304 302 305 303 while ((n = getline(&line, &line_n, fdi)) > 0) { 306 304 char *value; ··· 311 313 312 314 value = strchr(line, '\t'); 313 315 if (!value || !value[1]) { 314 - p_err("malformed fdinfo!?"); 315 316 free(line); 316 317 return NULL; 317 318 } ··· 323 326 return line; 324 327 } 325 328 326 - p_err("key '%s' not found in fdinfo", key); 327 329 free(line); 328 330 fclose(fdi); 329 331 return NULL;
+24 -9
tools/bpf/bpftool/map.c
··· 347 347 return argv + i; 348 348 } 349 349 350 + /* on per cpu maps we must copy the provided value on all value instances */ 351 + static void fill_per_cpu_value(struct bpf_map_info *info, void *value) 352 + { 353 + unsigned int i, n, step; 354 + 355 + if (!map_is_per_cpu(info->type)) 356 + return; 357 + 358 + n = get_possible_cpus(); 359 + step = round_up(info->value_size, 8); 360 + for (i = 1; i < n; i++) 361 + memcpy(value + i * step, value, info->value_size); 362 + } 363 + 350 364 static int parse_elem(char **argv, struct bpf_map_info *info, 351 365 void *key, void *value, __u32 key_size, __u32 value_size, 352 366 __u32 *flags, __u32 **value_fd) ··· 440 426 argv = parse_bytes(argv, "value", value, value_size); 441 427 if (!argv) 442 428 return -1; 429 + 430 + fill_per_cpu_value(info, value); 443 431 } 444 432 445 433 return parse_elem(argv, info, key, NULL, key_size, value_size, ··· 513 497 jsonw_uint_field(json_wtr, "owner_prog_type", 514 498 prog_type); 515 499 } 516 - if (atoi(owner_jited)) 517 - jsonw_bool_field(json_wtr, "owner_jited", true); 518 - else 519 - jsonw_bool_field(json_wtr, "owner_jited", false); 500 + if (owner_jited) 501 + jsonw_bool_field(json_wtr, "owner_jited", 502 + !!atoi(owner_jited)); 520 503 521 504 free(owner_prog_type); 522 505 free(owner_jited); ··· 568 553 char *owner_prog_type = get_fdinfo(fd, "owner_prog_type"); 569 554 char *owner_jited = get_fdinfo(fd, "owner_jited"); 570 555 571 - printf("\n\t"); 556 + if (owner_prog_type || owner_jited) 557 + printf("\n\t"); 572 558 if (owner_prog_type) { 573 559 unsigned int prog_type = atoi(owner_prog_type); 574 560 ··· 579 563 else 580 564 printf("owner_prog_type %d ", prog_type); 581 565 } 582 - if (atoi(owner_jited)) 583 - printf("owner jited"); 584 - else 585 - printf("owner not jited"); 566 + if (owner_jited) 567 + printf("owner%s jited", 568 + atoi(owner_jited) ? "" : " not"); 586 569 587 570 free(owner_prog_type); 588 571 free(owner_jited);
+3 -2
tools/bpf/bpftool/prog.c
··· 78 78 79 79 static int prog_fd_by_tag(unsigned char *tag) 80 80 { 81 - struct bpf_prog_info info = {}; 82 - __u32 len = sizeof(info); 83 81 unsigned int id = 0; 84 82 int err; 85 83 int fd; 86 84 87 85 while (true) { 86 + struct bpf_prog_info info = {}; 87 + __u32 len = sizeof(info); 88 + 88 89 err = bpf_prog_get_next_id(id, &id); 89 90 if (err) { 90 91 p_err("%s", strerror(errno));
+21 -11
tools/testing/selftests/bpf/bpf_util.h
··· 13 13 unsigned int start, end, possible_cpus = 0; 14 14 char buff[128]; 15 15 FILE *fp; 16 - int n; 16 + int len, n, i, j = 0; 17 17 18 18 fp = fopen(fcpu, "r"); 19 19 if (!fp) { ··· 21 21 exit(1); 22 22 } 23 23 24 - while (fgets(buff, sizeof(buff), fp)) { 25 - n = sscanf(buff, "%u-%u", &start, &end); 26 - if (n == 0) { 27 - printf("Failed to retrieve # possible CPUs!\n"); 28 - exit(1); 29 - } else if (n == 1) { 30 - end = start; 31 - } 32 - possible_cpus = start == 0 ? end + 1 : 0; 33 - break; 24 + if (!fgets(buff, sizeof(buff), fp)) { 25 + printf("Failed to read %s!\n", fcpu); 26 + exit(1); 34 27 } 28 + 29 + len = strlen(buff); 30 + for (i = 0; i <= len; i++) { 31 + if (buff[i] == ',' || buff[i] == '\0') { 32 + buff[i] = '\0'; 33 + n = sscanf(&buff[j], "%u-%u", &start, &end); 34 + if (n <= 0) { 35 + printf("Failed to retrieve # possible CPUs!\n"); 36 + exit(1); 37 + } else if (n == 1) { 38 + end = start; 39 + } 40 + possible_cpus += end - start + 1; 41 + j = i + 1; 42 + } 43 + } 44 + 35 45 fclose(fp); 36 46 37 47 return possible_cpus;
+3 -6
tools/testing/selftests/bpf/test_btf.c
··· 1881 1881 }, 1882 1882 1883 1883 { 1884 - .descr = "func proto (CONST=>TYPEDEF=>FUNC_PROTO)", 1884 + .descr = "func proto (TYPEDEF=>FUNC_PROTO)", 1885 1885 .raw_types = { 1886 1886 BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4), /* [1] */ 1887 1887 BTF_TYPE_INT_ENC(0, 0, 0, 32, 4), /* [2] */ 1888 - BTF_CONST_ENC(4), /* [3] */ 1889 - BTF_TYPEDEF_ENC(NAME_TBD, 5), /* [4] */ 1890 - BTF_FUNC_PROTO_ENC(0, 2), /* [5] */ 1888 + BTF_TYPEDEF_ENC(NAME_TBD, 4), /* [3] */ 1889 + BTF_FUNC_PROTO_ENC(0, 2), /* [4] */ 1891 1890 BTF_FUNC_PROTO_ARG_ENC(0, 1), 1892 1891 BTF_FUNC_PROTO_ARG_ENC(0, 2), 1893 1892 BTF_END_RAW, ··· 1900 1901 .key_type_id = 1, 1901 1902 .value_type_id = 1, 1902 1903 .max_entries = 4, 1903 - .btf_load_err = true, 1904 - .err_str = "Invalid type_id", 1905 1904 }, 1906 1905 1907 1906 {
+1 -1
tools/testing/selftests/netfilter/Makefile
··· 1 1 # SPDX-License-Identifier: GPL-2.0 2 2 # Makefile for netfilter selftests 3 3 4 - TEST_PROGS := nft_trans_stress.sh 4 + TEST_PROGS := nft_trans_stress.sh nft_nat.sh 5 5 6 6 include ../lib.mk
+1 -1
tools/testing/selftests/netfilter/config
··· 1 1 CONFIG_NET_NS=y 2 - NF_TABLES_INET=y 2 + CONFIG_NF_TABLES_INET=y
+762
tools/testing/selftests/netfilter/nft_nat.sh
··· 1 + #!/bin/bash 2 + # 3 + # This test is for basic NAT functionality: snat, dnat, redirect, masquerade. 4 + # 5 + 6 + # Kselftest framework requirement - SKIP code is 4. 7 + ksft_skip=4 8 + ret=0 9 + 10 + nft --version > /dev/null 2>&1 11 + if [ $? -ne 0 ];then 12 + echo "SKIP: Could not run test without nft tool" 13 + exit $ksft_skip 14 + fi 15 + 16 + ip -Version > /dev/null 2>&1 17 + if [ $? -ne 0 ];then 18 + echo "SKIP: Could not run test without ip tool" 19 + exit $ksft_skip 20 + fi 21 + 22 + ip netns add ns0 23 + ip netns add ns1 24 + ip netns add ns2 25 + 26 + ip link add veth0 netns ns0 type veth peer name eth0 netns ns1 27 + ip link add veth1 netns ns0 type veth peer name eth0 netns ns2 28 + 29 + ip -net ns0 link set lo up 30 + ip -net ns0 link set veth0 up 31 + ip -net ns0 addr add 10.0.1.1/24 dev veth0 32 + ip -net ns0 addr add dead:1::1/64 dev veth0 33 + 34 + ip -net ns0 link set veth1 up 35 + ip -net ns0 addr add 10.0.2.1/24 dev veth1 36 + ip -net ns0 addr add dead:2::1/64 dev veth1 37 + 38 + for i in 1 2; do 39 + ip -net ns$i link set lo up 40 + ip -net ns$i link set eth0 up 41 + ip -net ns$i addr add 10.0.$i.99/24 dev eth0 42 + ip -net ns$i route add default via 10.0.$i.1 43 + ip -net ns$i addr add dead:$i::99/64 dev eth0 44 + ip -net ns$i route add default via dead:$i::1 45 + done 46 + 47 + bad_counter() 48 + { 49 + local ns=$1 50 + local counter=$2 51 + local expect=$3 52 + 53 + echo "ERROR: $counter counter in $ns has unexpected value (expected $expect)" 1>&2 54 + ip netns exec $ns nft list counter inet filter $counter 1>&2 55 + } 56 + 57 + check_counters() 58 + { 59 + ns=$1 60 + local lret=0 61 + 62 + cnt=$(ip netns exec $ns nft list counter inet filter ns0in | grep -q "packets 1 bytes 84") 63 + if [ $? -ne 0 ]; then 64 + bad_counter $ns ns0in "packets 1 bytes 84" 65 + lret=1 66 + fi 67 + cnt=$(ip netns exec $ns nft list counter inet filter ns0out | grep -q "packets 1 bytes 84") 68 + if [ $? -ne 0 ]; then 69 + bad_counter $ns ns0out "packets 1 bytes 84" 70 + lret=1 71 + fi 72 + 73 + expect="packets 1 bytes 104" 74 + cnt=$(ip netns exec $ns nft list counter inet filter ns0in6 | grep -q "$expect") 75 + if [ $? -ne 0 ]; then 76 + bad_counter $ns ns0in6 "$expect" 77 + lret=1 78 + fi 79 + cnt=$(ip netns exec $ns nft list counter inet filter ns0out6 | grep -q "$expect") 80 + if [ $? -ne 0 ]; then 81 + bad_counter $ns ns0out6 "$expect" 82 + lret=1 83 + fi 84 + 85 + return $lret 86 + } 87 + 88 + check_ns0_counters() 89 + { 90 + local ns=$1 91 + local lret=0 92 + 93 + cnt=$(ip netns exec ns0 nft list counter inet filter ns0in | grep -q "packets 0 bytes 0") 94 + if [ $? -ne 0 ]; then 95 + bad_counter ns0 ns0in "packets 0 bytes 0" 96 + lret=1 97 + fi 98 + 99 + cnt=$(ip netns exec ns0 nft list counter inet filter ns0in6 | grep -q "packets 0 bytes 0") 100 + if [ $? -ne 0 ]; then 101 + bad_counter ns0 ns0in6 "packets 0 bytes 0" 102 + lret=1 103 + fi 104 + 105 + cnt=$(ip netns exec ns0 nft list counter inet filter ns0out | grep -q "packets 0 bytes 0") 106 + if [ $? -ne 0 ]; then 107 + bad_counter ns0 ns0out "packets 0 bytes 0" 108 + lret=1 109 + fi 110 + cnt=$(ip netns exec ns0 nft list counter inet filter ns0out6 | grep -q "packets 0 bytes 0") 111 + if [ $? -ne 0 ]; then 112 + bad_counter ns0 ns0out6 "packets 0 bytes 0" 113 + lret=1 114 + fi 115 + 116 + for dir in "in" "out" ; do 117 + expect="packets 1 bytes 84" 118 + cnt=$(ip netns exec ns0 nft list counter inet filter ${ns}${dir} | grep -q "$expect") 119 + if [ $? -ne 0 ]; then 120 + bad_counter ns0 $ns$dir "$expect" 121 + lret=1 122 + fi 123 + 124 + expect="packets 1 bytes 104" 125 + cnt=$(ip netns exec ns0 nft list counter inet filter ${ns}${dir}6 | grep -q "$expect") 126 + if [ $? -ne 0 ]; then 127 + bad_counter ns0 $ns$dir6 "$expect" 128 + lret=1 129 + fi 130 + done 131 + 132 + return $lret 133 + } 134 + 135 + reset_counters() 136 + { 137 + for i in 0 1 2;do 138 + ip netns exec ns$i nft reset counters inet > /dev/null 139 + done 140 + } 141 + 142 + test_local_dnat6() 143 + { 144 + local lret=0 145 + ip netns exec ns0 nft -f - <<EOF 146 + table ip6 nat { 147 + chain output { 148 + type nat hook output priority 0; policy accept; 149 + ip6 daddr dead:1::99 dnat to dead:2::99 150 + } 151 + } 152 + EOF 153 + if [ $? -ne 0 ]; then 154 + echo "SKIP: Could not add add ip6 dnat hook" 155 + return $ksft_skip 156 + fi 157 + 158 + # ping netns1, expect rewrite to netns2 159 + ip netns exec ns0 ping -q -c 1 dead:1::99 > /dev/null 160 + if [ $? -ne 0 ]; then 161 + lret=1 162 + echo "ERROR: ping6 failed" 163 + return $lret 164 + fi 165 + 166 + expect="packets 0 bytes 0" 167 + for dir in "in6" "out6" ; do 168 + cnt=$(ip netns exec ns0 nft list counter inet filter ns1${dir} | grep -q "$expect") 169 + if [ $? -ne 0 ]; then 170 + bad_counter ns0 ns1$dir "$expect" 171 + lret=1 172 + fi 173 + done 174 + 175 + expect="packets 1 bytes 104" 176 + for dir in "in6" "out6" ; do 177 + cnt=$(ip netns exec ns0 nft list counter inet filter ns2${dir} | grep -q "$expect") 178 + if [ $? -ne 0 ]; then 179 + bad_counter ns0 ns2$dir "$expect" 180 + lret=1 181 + fi 182 + done 183 + 184 + # expect 0 count in ns1 185 + expect="packets 0 bytes 0" 186 + for dir in "in6" "out6" ; do 187 + cnt=$(ip netns exec ns1 nft list counter inet filter ns0${dir} | grep -q "$expect") 188 + if [ $? -ne 0 ]; then 189 + bad_counter ns1 ns0$dir "$expect" 190 + lret=1 191 + fi 192 + done 193 + 194 + # expect 1 packet in ns2 195 + expect="packets 1 bytes 104" 196 + for dir in "in6" "out6" ; do 197 + cnt=$(ip netns exec ns2 nft list counter inet filter ns0${dir} | grep -q "$expect") 198 + if [ $? -ne 0 ]; then 199 + bad_counter ns2 ns0$dir "$expect" 200 + lret=1 201 + fi 202 + done 203 + 204 + test $lret -eq 0 && echo "PASS: ipv6 ping to ns1 was NATted to ns2" 205 + ip netns exec ns0 nft flush chain ip6 nat output 206 + 207 + return $lret 208 + } 209 + 210 + test_local_dnat() 211 + { 212 + local lret=0 213 + ip netns exec ns0 nft -f - <<EOF 214 + table ip nat { 215 + chain output { 216 + type nat hook output priority 0; policy accept; 217 + ip daddr 10.0.1.99 dnat to 10.0.2.99 218 + } 219 + } 220 + EOF 221 + # ping netns1, expect rewrite to netns2 222 + ip netns exec ns0 ping -q -c 1 10.0.1.99 > /dev/null 223 + if [ $? -ne 0 ]; then 224 + lret=1 225 + echo "ERROR: ping failed" 226 + return $lret 227 + fi 228 + 229 + expect="packets 0 bytes 0" 230 + for dir in "in" "out" ; do 231 + cnt=$(ip netns exec ns0 nft list counter inet filter ns1${dir} | grep -q "$expect") 232 + if [ $? -ne 0 ]; then 233 + bad_counter ns0 ns1$dir "$expect" 234 + lret=1 235 + fi 236 + done 237 + 238 + expect="packets 1 bytes 84" 239 + for dir in "in" "out" ; do 240 + cnt=$(ip netns exec ns0 nft list counter inet filter ns2${dir} | grep -q "$expect") 241 + if [ $? -ne 0 ]; then 242 + bad_counter ns0 ns2$dir "$expect" 243 + lret=1 244 + fi 245 + done 246 + 247 + # expect 0 count in ns1 248 + expect="packets 0 bytes 0" 249 + for dir in "in" "out" ; do 250 + cnt=$(ip netns exec ns1 nft list counter inet filter ns0${dir} | grep -q "$expect") 251 + if [ $? -ne 0 ]; then 252 + bad_counter ns1 ns0$dir "$expect" 253 + lret=1 254 + fi 255 + done 256 + 257 + # expect 1 packet in ns2 258 + expect="packets 1 bytes 84" 259 + for dir in "in" "out" ; do 260 + cnt=$(ip netns exec ns2 nft list counter inet filter ns0${dir} | grep -q "$expect") 261 + if [ $? -ne 0 ]; then 262 + bad_counter ns2 ns0$dir "$expect" 263 + lret=1 264 + fi 265 + done 266 + 267 + test $lret -eq 0 && echo "PASS: ping to ns1 was NATted to ns2" 268 + 269 + ip netns exec ns0 nft flush chain ip nat output 270 + 271 + reset_counters 272 + ip netns exec ns0 ping -q -c 1 10.0.1.99 > /dev/null 273 + if [ $? -ne 0 ]; then 274 + lret=1 275 + echo "ERROR: ping failed" 276 + return $lret 277 + fi 278 + 279 + expect="packets 1 bytes 84" 280 + for dir in "in" "out" ; do 281 + cnt=$(ip netns exec ns0 nft list counter inet filter ns1${dir} | grep -q "$expect") 282 + if [ $? -ne 0 ]; then 283 + bad_counter ns1 ns1$dir "$expect" 284 + lret=1 285 + fi 286 + done 287 + expect="packets 0 bytes 0" 288 + for dir in "in" "out" ; do 289 + cnt=$(ip netns exec ns0 nft list counter inet filter ns2${dir} | grep -q "$expect") 290 + if [ $? -ne 0 ]; then 291 + bad_counter ns0 ns2$dir "$expect" 292 + lret=1 293 + fi 294 + done 295 + 296 + # expect 1 count in ns1 297 + expect="packets 1 bytes 84" 298 + for dir in "in" "out" ; do 299 + cnt=$(ip netns exec ns1 nft list counter inet filter ns0${dir} | grep -q "$expect") 300 + if [ $? -ne 0 ]; then 301 + bad_counter ns0 ns0$dir "$expect" 302 + lret=1 303 + fi 304 + done 305 + 306 + # expect 0 packet in ns2 307 + expect="packets 0 bytes 0" 308 + for dir in "in" "out" ; do 309 + cnt=$(ip netns exec ns2 nft list counter inet filter ns0${dir} | grep -q "$expect") 310 + if [ $? -ne 0 ]; then 311 + bad_counter ns2 ns2$dir "$expect" 312 + lret=1 313 + fi 314 + done 315 + 316 + test $lret -eq 0 && echo "PASS: ping to ns1 OK after nat output chain flush" 317 + 318 + return $lret 319 + } 320 + 321 + 322 + test_masquerade6() 323 + { 324 + local lret=0 325 + 326 + ip netns exec ns0 sysctl net.ipv6.conf.all.forwarding=1 > /dev/null 327 + 328 + ip netns exec ns2 ping -q -c 1 dead:1::99 > /dev/null # ping ns2->ns1 329 + if [ $? -ne 0 ] ; then 330 + echo "ERROR: cannot ping ns1 from ns2 via ipv6" 331 + return 1 332 + lret=1 333 + fi 334 + 335 + expect="packets 1 bytes 104" 336 + for dir in "in6" "out6" ; do 337 + cnt=$(ip netns exec ns1 nft list counter inet filter ns2${dir} | grep -q "$expect") 338 + if [ $? -ne 0 ]; then 339 + bad_counter ns1 ns2$dir "$expect" 340 + lret=1 341 + fi 342 + 343 + cnt=$(ip netns exec ns2 nft list counter inet filter ns1${dir} | grep -q "$expect") 344 + if [ $? -ne 0 ]; then 345 + bad_counter ns2 ns1$dir "$expect" 346 + lret=1 347 + fi 348 + done 349 + 350 + reset_counters 351 + 352 + # add masquerading rule 353 + ip netns exec ns0 nft -f - <<EOF 354 + table ip6 nat { 355 + chain postrouting { 356 + type nat hook postrouting priority 0; policy accept; 357 + meta oif veth0 masquerade 358 + } 359 + } 360 + EOF 361 + ip netns exec ns2 ping -q -c 1 dead:1::99 > /dev/null # ping ns2->ns1 362 + if [ $? -ne 0 ] ; then 363 + echo "ERROR: cannot ping ns1 from ns2 with active ipv6 masquerading" 364 + lret=1 365 + fi 366 + 367 + # ns1 should have seen packets from ns0, due to masquerade 368 + expect="packets 1 bytes 104" 369 + for dir in "in6" "out6" ; do 370 + 371 + cnt=$(ip netns exec ns1 nft list counter inet filter ns0${dir} | grep -q "$expect") 372 + if [ $? -ne 0 ]; then 373 + bad_counter ns1 ns0$dir "$expect" 374 + lret=1 375 + fi 376 + 377 + cnt=$(ip netns exec ns2 nft list counter inet filter ns1${dir} | grep -q "$expect") 378 + if [ $? -ne 0 ]; then 379 + bad_counter ns2 ns1$dir "$expect" 380 + lret=1 381 + fi 382 + done 383 + 384 + # ns1 should not have seen packets from ns2, due to masquerade 385 + expect="packets 0 bytes 0" 386 + for dir in "in6" "out6" ; do 387 + cnt=$(ip netns exec ns1 nft list counter inet filter ns2${dir} | grep -q "$expect") 388 + if [ $? -ne 0 ]; then 389 + bad_counter ns1 ns0$dir "$expect" 390 + lret=1 391 + fi 392 + 393 + cnt=$(ip netns exec ns1 nft list counter inet filter ns2${dir} | grep -q "$expect") 394 + if [ $? -ne 0 ]; then 395 + bad_counter ns2 ns1$dir "$expect" 396 + lret=1 397 + fi 398 + done 399 + 400 + ip netns exec ns0 nft flush chain ip6 nat postrouting 401 + if [ $? -ne 0 ]; then 402 + echo "ERROR: Could not flush ip6 nat postrouting" 1>&2 403 + lret=1 404 + fi 405 + 406 + test $lret -eq 0 && echo "PASS: IPv6 masquerade for ns2" 407 + 408 + return $lret 409 + } 410 + 411 + test_masquerade() 412 + { 413 + local lret=0 414 + 415 + ip netns exec ns0 sysctl net.ipv4.conf.veth0.forwarding=1 > /dev/null 416 + ip netns exec ns0 sysctl net.ipv4.conf.veth1.forwarding=1 > /dev/null 417 + 418 + ip netns exec ns2 ping -q -c 1 10.0.1.99 > /dev/null # ping ns2->ns1 419 + if [ $? -ne 0 ] ; then 420 + echo "ERROR: canot ping ns1 from ns2" 421 + lret=1 422 + fi 423 + 424 + expect="packets 1 bytes 84" 425 + for dir in "in" "out" ; do 426 + cnt=$(ip netns exec ns1 nft list counter inet filter ns2${dir} | grep -q "$expect") 427 + if [ $? -ne 0 ]; then 428 + bad_counter ns1 ns2$dir "$expect" 429 + lret=1 430 + fi 431 + 432 + cnt=$(ip netns exec ns2 nft list counter inet filter ns1${dir} | grep -q "$expect") 433 + if [ $? -ne 0 ]; then 434 + bad_counter ns2 ns1$dir "$expect" 435 + lret=1 436 + fi 437 + done 438 + 439 + reset_counters 440 + 441 + # add masquerading rule 442 + ip netns exec ns0 nft -f - <<EOF 443 + table ip nat { 444 + chain postrouting { 445 + type nat hook postrouting priority 0; policy accept; 446 + meta oif veth0 masquerade 447 + } 448 + } 449 + EOF 450 + ip netns exec ns2 ping -q -c 1 10.0.1.99 > /dev/null # ping ns2->ns1 451 + if [ $? -ne 0 ] ; then 452 + echo "ERROR: cannot ping ns1 from ns2 with active ip masquerading" 453 + lret=1 454 + fi 455 + 456 + # ns1 should have seen packets from ns0, due to masquerade 457 + expect="packets 1 bytes 84" 458 + for dir in "in" "out" ; do 459 + cnt=$(ip netns exec ns1 nft list counter inet filter ns0${dir} | grep -q "$expect") 460 + if [ $? -ne 0 ]; then 461 + bad_counter ns1 ns0$dir "$expect" 462 + lret=1 463 + fi 464 + 465 + cnt=$(ip netns exec ns2 nft list counter inet filter ns1${dir} | grep -q "$expect") 466 + if [ $? -ne 0 ]; then 467 + bad_counter ns2 ns1$dir "$expect" 468 + lret=1 469 + fi 470 + done 471 + 472 + # ns1 should not have seen packets from ns2, due to masquerade 473 + expect="packets 0 bytes 0" 474 + for dir in "in" "out" ; do 475 + cnt=$(ip netns exec ns1 nft list counter inet filter ns2${dir} | grep -q "$expect") 476 + if [ $? -ne 0 ]; then 477 + bad_counter ns1 ns0$dir "$expect" 478 + lret=1 479 + fi 480 + 481 + cnt=$(ip netns exec ns1 nft list counter inet filter ns2${dir} | grep -q "$expect") 482 + if [ $? -ne 0 ]; then 483 + bad_counter ns2 ns1$dir "$expect" 484 + lret=1 485 + fi 486 + done 487 + 488 + ip netns exec ns0 nft flush chain ip nat postrouting 489 + if [ $? -ne 0 ]; then 490 + echo "ERROR: Could not flush nat postrouting" 1>&2 491 + lret=1 492 + fi 493 + 494 + test $lret -eq 0 && echo "PASS: IP masquerade for ns2" 495 + 496 + return $lret 497 + } 498 + 499 + test_redirect6() 500 + { 501 + local lret=0 502 + 503 + ip netns exec ns0 sysctl net.ipv6.conf.all.forwarding=1 > /dev/null 504 + 505 + ip netns exec ns2 ping -q -c 1 dead:1::99 > /dev/null # ping ns2->ns1 506 + if [ $? -ne 0 ] ; then 507 + echo "ERROR: cannnot ping ns1 from ns2 via ipv6" 508 + lret=1 509 + fi 510 + 511 + expect="packets 1 bytes 104" 512 + for dir in "in6" "out6" ; do 513 + cnt=$(ip netns exec ns1 nft list counter inet filter ns2${dir} | grep -q "$expect") 514 + if [ $? -ne 0 ]; then 515 + bad_counter ns1 ns2$dir "$expect" 516 + lret=1 517 + fi 518 + 519 + cnt=$(ip netns exec ns2 nft list counter inet filter ns1${dir} | grep -q "$expect") 520 + if [ $? -ne 0 ]; then 521 + bad_counter ns2 ns1$dir "$expect" 522 + lret=1 523 + fi 524 + done 525 + 526 + reset_counters 527 + 528 + # add redirect rule 529 + ip netns exec ns0 nft -f - <<EOF 530 + table ip6 nat { 531 + chain prerouting { 532 + type nat hook prerouting priority 0; policy accept; 533 + meta iif veth1 meta l4proto icmpv6 ip6 saddr dead:2::99 ip6 daddr dead:1::99 redirect 534 + } 535 + } 536 + EOF 537 + ip netns exec ns2 ping -q -c 1 dead:1::99 > /dev/null # ping ns2->ns1 538 + if [ $? -ne 0 ] ; then 539 + echo "ERROR: cannot ping ns1 from ns2 with active ip6 redirect" 540 + lret=1 541 + fi 542 + 543 + # ns1 should have seen no packets from ns2, due to redirection 544 + expect="packets 0 bytes 0" 545 + for dir in "in6" "out6" ; do 546 + cnt=$(ip netns exec ns1 nft list counter inet filter ns2${dir} | grep -q "$expect") 547 + if [ $? -ne 0 ]; then 548 + bad_counter ns1 ns0$dir "$expect" 549 + lret=1 550 + fi 551 + done 552 + 553 + # ns0 should have seen packets from ns2, due to masquerade 554 + expect="packets 1 bytes 104" 555 + for dir in "in6" "out6" ; do 556 + cnt=$(ip netns exec ns0 nft list counter inet filter ns2${dir} | grep -q "$expect") 557 + if [ $? -ne 0 ]; then 558 + bad_counter ns1 ns0$dir "$expect" 559 + lret=1 560 + fi 561 + done 562 + 563 + ip netns exec ns0 nft delete table ip6 nat 564 + if [ $? -ne 0 ]; then 565 + echo "ERROR: Could not delete ip6 nat table" 1>&2 566 + lret=1 567 + fi 568 + 569 + test $lret -eq 0 && echo "PASS: IPv6 redirection for ns2" 570 + 571 + return $lret 572 + } 573 + 574 + test_redirect() 575 + { 576 + local lret=0 577 + 578 + ip netns exec ns0 sysctl net.ipv4.conf.veth0.forwarding=1 > /dev/null 579 + ip netns exec ns0 sysctl net.ipv4.conf.veth1.forwarding=1 > /dev/null 580 + 581 + ip netns exec ns2 ping -q -c 1 10.0.1.99 > /dev/null # ping ns2->ns1 582 + if [ $? -ne 0 ] ; then 583 + echo "ERROR: cannot ping ns1 from ns2" 584 + lret=1 585 + fi 586 + 587 + expect="packets 1 bytes 84" 588 + for dir in "in" "out" ; do 589 + cnt=$(ip netns exec ns1 nft list counter inet filter ns2${dir} | grep -q "$expect") 590 + if [ $? -ne 0 ]; then 591 + bad_counter ns1 ns2$dir "$expect" 592 + lret=1 593 + fi 594 + 595 + cnt=$(ip netns exec ns2 nft list counter inet filter ns1${dir} | grep -q "$expect") 596 + if [ $? -ne 0 ]; then 597 + bad_counter ns2 ns1$dir "$expect" 598 + lret=1 599 + fi 600 + done 601 + 602 + reset_counters 603 + 604 + # add redirect rule 605 + ip netns exec ns0 nft -f - <<EOF 606 + table ip nat { 607 + chain prerouting { 608 + type nat hook prerouting priority 0; policy accept; 609 + meta iif veth1 ip protocol icmp ip saddr 10.0.2.99 ip daddr 10.0.1.99 redirect 610 + } 611 + } 612 + EOF 613 + ip netns exec ns2 ping -q -c 1 10.0.1.99 > /dev/null # ping ns2->ns1 614 + if [ $? -ne 0 ] ; then 615 + echo "ERROR: cannot ping ns1 from ns2 with active ip redirect" 616 + lret=1 617 + fi 618 + 619 + # ns1 should have seen no packets from ns2, due to redirection 620 + expect="packets 0 bytes 0" 621 + for dir in "in" "out" ; do 622 + 623 + cnt=$(ip netns exec ns1 nft list counter inet filter ns2${dir} | grep -q "$expect") 624 + if [ $? -ne 0 ]; then 625 + bad_counter ns1 ns0$dir "$expect" 626 + lret=1 627 + fi 628 + done 629 + 630 + # ns0 should have seen packets from ns2, due to masquerade 631 + expect="packets 1 bytes 84" 632 + for dir in "in" "out" ; do 633 + cnt=$(ip netns exec ns0 nft list counter inet filter ns2${dir} | grep -q "$expect") 634 + if [ $? -ne 0 ]; then 635 + bad_counter ns1 ns0$dir "$expect" 636 + lret=1 637 + fi 638 + done 639 + 640 + ip netns exec ns0 nft delete table ip nat 641 + if [ $? -ne 0 ]; then 642 + echo "ERROR: Could not delete nat table" 1>&2 643 + lret=1 644 + fi 645 + 646 + test $lret -eq 0 && echo "PASS: IP redirection for ns2" 647 + 648 + return $lret 649 + } 650 + 651 + 652 + # ip netns exec ns0 ping -c 1 -q 10.0.$i.99 653 + for i in 0 1 2; do 654 + ip netns exec ns$i nft -f - <<EOF 655 + table inet filter { 656 + counter ns0in {} 657 + counter ns1in {} 658 + counter ns2in {} 659 + 660 + counter ns0out {} 661 + counter ns1out {} 662 + counter ns2out {} 663 + 664 + counter ns0in6 {} 665 + counter ns1in6 {} 666 + counter ns2in6 {} 667 + 668 + counter ns0out6 {} 669 + counter ns1out6 {} 670 + counter ns2out6 {} 671 + 672 + map nsincounter { 673 + type ipv4_addr : counter 674 + elements = { 10.0.1.1 : "ns0in", 675 + 10.0.2.1 : "ns0in", 676 + 10.0.1.99 : "ns1in", 677 + 10.0.2.99 : "ns2in" } 678 + } 679 + 680 + map nsincounter6 { 681 + type ipv6_addr : counter 682 + elements = { dead:1::1 : "ns0in6", 683 + dead:2::1 : "ns0in6", 684 + dead:1::99 : "ns1in6", 685 + dead:2::99 : "ns2in6" } 686 + } 687 + 688 + map nsoutcounter { 689 + type ipv4_addr : counter 690 + elements = { 10.0.1.1 : "ns0out", 691 + 10.0.2.1 : "ns0out", 692 + 10.0.1.99: "ns1out", 693 + 10.0.2.99: "ns2out" } 694 + } 695 + 696 + map nsoutcounter6 { 697 + type ipv6_addr : counter 698 + elements = { dead:1::1 : "ns0out6", 699 + dead:2::1 : "ns0out6", 700 + dead:1::99 : "ns1out6", 701 + dead:2::99 : "ns2out6" } 702 + } 703 + 704 + chain input { 705 + type filter hook input priority 0; policy accept; 706 + counter name ip saddr map @nsincounter 707 + icmpv6 type { "echo-request", "echo-reply" } counter name ip6 saddr map @nsincounter6 708 + } 709 + chain output { 710 + type filter hook output priority 0; policy accept; 711 + counter name ip daddr map @nsoutcounter 712 + icmpv6 type { "echo-request", "echo-reply" } counter name ip6 daddr map @nsoutcounter6 713 + } 714 + } 715 + EOF 716 + done 717 + 718 + sleep 3 719 + # test basic connectivity 720 + for i in 1 2; do 721 + ip netns exec ns0 ping -c 1 -q 10.0.$i.99 > /dev/null 722 + if [ $? -ne 0 ];then 723 + echo "ERROR: Could not reach other namespace(s)" 1>&2 724 + ret=1 725 + fi 726 + 727 + ip netns exec ns0 ping -c 1 -q dead:$i::99 > /dev/null 728 + if [ $? -ne 0 ];then 729 + echo "ERROR: Could not reach other namespace(s) via ipv6" 1>&2 730 + ret=1 731 + fi 732 + check_counters ns$i 733 + if [ $? -ne 0 ]; then 734 + ret=1 735 + fi 736 + 737 + check_ns0_counters ns$i 738 + if [ $? -ne 0 ]; then 739 + ret=1 740 + fi 741 + reset_counters 742 + done 743 + 744 + if [ $ret -eq 0 ];then 745 + echo "PASS: netns routing/connectivity: ns0 can reach ns1 and ns2" 746 + fi 747 + 748 + reset_counters 749 + test_local_dnat 750 + test_local_dnat6 751 + 752 + reset_counters 753 + test_masquerade 754 + test_masquerade6 755 + 756 + reset_counters 757 + test_redirect 758 + test_redirect6 759 + 760 + for i in 0 1 2; do ip netns del ns$i;done 761 + 762 + exit $ret