Merge tag 'net-5.19-rc5' of git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net

Pull networking fixes from Jakub Kicinski: "Including fixes from netfilter. Current release - new code bugs: - clear msg_get_inq in __sys_recvfrom() and __copy_msghdr_from_user() - mptcp: - invoke MP_FAIL response only when needed - fix shutdown vs fallback race - consistent map handling on failure - octeon_ep: use bitwise AND Previous releases - regressions: - tipc: move bc link creation back to tipc_node_create, fix NPD Previous releases - always broken: - tcp: add a missing nf_reset_ct() in 3WHS handling to prevent socket buffered skbs from keeping refcount on the conntrack module - ipv6: take care of disable_policy when restoring routes - tun: make sure to always disable and unlink NAPI instances - phy: don't trigger state machine while in suspend - netfilter: nf_tables: avoid skb access on nf_stolen - asix: fix "can't send until first packet is send" issue - usb: asix: do not force pause frames support - nxp-nci: don't issue a zero length i2c_master_read() Misc: - ncsi: allow use of proper "mellanox" DT vendor prefix - act_api: add a message for user space if any actions were already flushed before the error was hit" * tag 'net-5.19-rc5' of git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net: (55 commits) net: dsa: felix: fix race between reading PSFP stats and port stats selftest: tun: add test for NAPI dismantle net: tun: avoid disabling NAPI twice net: sparx5: mdb add/del handle non-sparx5 devices net: sfp: fix memory leak in sfp_probe() mlxsw: spectrum_router: Fix rollback in tunnel next hop init net: rose: fix UAF bugs caused by timer handler net: usb: ax88179_178a: Fix packet receiving net: bonding: fix use-after-free after 802.3ad slave unbind ipv6: fix lockdep splat in in6_dump_addrs() net: phy: ax88772a: fix lost pause advertisement configuration net: phy: Don't trigger state machine while in suspend usbnet: fix memory allocation in helpers selftests net: fix kselftest net fatal error NFC: nxp-nci: don't print header length mismatch on i2c error NFC: nxp-nci: Don't issue a zero length i2c_master_read() net: tipc: fix possible refcount leak in tipc_sk_create() nfc: nfcmrvl: Fix irq_of_parse_and_map() return value net: ipv6: unexport __init-annotated seg6_hmac_net_init() ipv6/sit: fix ipip6_tunnel_get_prl return value ...

Linus Torvalds committed 4 years ago

Commit 5e837932 parents 868f9f2 58bf4db58 files · +905 −254Browse files

Unified · Split

58 files

MAINTAINERS +1 −2
drivers/net/bonding/bond_3ad.c +2 −1
drivers/net/bonding/bond_alb.c +1 −1
drivers/net/dsa/bcm_sf2.c +5 −0
drivers/net/dsa/hirschmann/hellcreek_ptp.c +1 −0
drivers/net/dsa/ocelot/felix_vsc9959.c +4 −0
drivers/net/ethernet/marvell/octeon_ep/octep_regs_cn9k_pf.h +1 −1
drivers/net/ethernet/mellanox/mlxsw/spectrum_router.c +13 −1
drivers/net/ethernet/microchip/sparx5/sparx5_switchdev.c +6 −0
drivers/net/ethernet/smsc/epic100.c +2 −2
drivers/net/phy/ax88796b.c +4 −2
drivers/net/phy/dp83822.c +1 −3
drivers/net/phy/phy.c +23 −0
drivers/net/phy/phy_device.c +23 −0
drivers/net/phy/sfp.c +1 −1
drivers/net/tun.c +13 −2
drivers/net/usb/asix.h +1 −2
drivers/net/usb/asix_common.c +1 −0
drivers/net/usb/ax88179_178a.c +76 −25
drivers/net/usb/usbnet.c +2 −2
drivers/nfc/nfcmrvl/i2c.c +3 −3
drivers/nfc/nfcmrvl/spi.c +3 −3
drivers/nfc/nxp-nci/i2c.c +9 −2
include/linux/netdevice.h +1 −1
include/linux/phy.h +6 −0
include/net/netfilter/nf_tables.h +10 −6
include/uapi/linux/mptcp.h +5 −4
net/bridge/br_netfilter_hooks.c +18 −3
net/ipv4/ip_tunnel_core.c +1 −1
net/ipv4/tcp_ipv4.c +5 −1
net/ipv6/addrconf.c +2 −6
net/ipv6/route.c +8 −1
net/ipv6/seg6_hmac.c +0 −1
net/ipv6/sit.c +3 −5
net/mptcp/options.c +4 −3
net/mptcp/pm.c +4 −6
net/mptcp/protocol.c +53 −31
net/mptcp/protocol.h +20 −4
net/mptcp/subflow.c +98 −29
net/ncsi/ncsi-manage.c +2 −1
net/netfilter/nf_tables_core.c +21 −3
net/netfilter/nf_tables_trace.c +24 −20
net/netfilter/nft_set_hash.c +2 −0
net/rose/rose_timer.c +19 −15
net/sched/act_api.c +14 −8
net/socket.c +6 −10
net/tipc/node.c +22 −19
net/tipc/socket.c +1 −0
tools/testing/selftests/bpf/prog_tests/sockmap_ktls.c +75 −9
tools/testing/selftests/net/Makefile +1 −1
tools/testing/selftests/net/bpf/Makefile +1 −1
tools/testing/selftests/net/mptcp/diag.sh +40 −8
tools/testing/selftests/net/mptcp/mptcp_connect.c +1 −1
tools/testing/selftests/net/mptcp/mptcp_inq.c +1 −1
tools/testing/selftests/net/mptcp/mptcp_sockopt.c +1 −1
tools/testing/selftests/net/tun.c +162 −0
tools/testing/selftests/net/udpgso_bench.sh +1 −1
tools/testing/selftests/tc-testing/tc-tests/actions/gact.json +77 −0

MAINTAINERS+1−2

@@ -14397,9 +14397,8 @@ F: Documentation/devicetree/bindings/sound/nxp,tfa989x.yaml · 14396 unmodified lines
14397	F: sound/soc/codecs/tfa989x.c	14397	F: sound/soc/codecs/tfa989x.c
14398		14398
14399	NXP-NCI NFC DRIVER	14399	NXP-NCI NFC DRIVER
14400	R: Charles Gorand <charles.gorand@effinnov.com>
14401	L: linux-nfc@lists.01.org (subscribers-only)	14400	L: linux-nfc@lists.01.org (subscribers-only)
14402	S: Supported	14401	S: Orphan
14403	F: Documentation/devicetree/bindings/net/nfc/nxp,nci.yaml	14402	F: Documentation/devicetree/bindings/net/nfc/nxp,nci.yaml
14404	F: drivers/nfc/nxp-nci	14403	F: drivers/nfc/nxp-nci
14405		14404

drivers/net/bonding/bond_3ad.c+2−1

 				temp_aggregator->num_of_ports--;
 				if (__agg_active_ports(temp_aggregator) == 0) {
 					select_new_active_agg = temp_aggregator->is_active;
-					ad_clear_agg(temp_aggregator);
+					if (temp_aggregator->num_of_ports == 0)
+						ad_clear_agg(temp_aggregator);
 					if (select_new_active_agg) {
 						slave_info(bond->dev, slave->dev, "Removing an active aggregator\n");
 						/* select new active aggregator */

drivers/net/bonding/bond_alb.c+1−1

 		return res;
 	if (rlb_enabled) {
-		bond->alb_info.rlb_enabled = 1;
 		res = rlb_initialize(bond);
 		if (res) {
 			tlb_deinitialize(bond);
 			return res;
 		}
+		bond->alb_info.rlb_enabled = 1;
 	} else {
 		bond->alb_info.rlb_enabled = 0;
 	}

drivers/net/dsa/bcm_sf2.c+5−0

 		if (duplex == DUPLEX_FULL)
 			reg |= DUPLX_MODE;
+		if (tx_pause)
+			reg |= TXFLOW_CNTL;
+		if (rx_pause)
+			reg |= RXFLOW_CNTL;
 		core_writel(priv, reg, offset);
 	}

drivers/net/dsa/hirschmann/hellcreek_ptp.c+1−0

@@ -300,6 +300,7 @@ static int hellcreek_led_setup(struct hellcreek *hellcreek) · 299 unmodified lines
300	const char label, state;	300	const char label, state;
301	int ret = -EINVAL;	301	int ret = -EINVAL;
302		302
		303	of_node_get(hellcreek->dev->of_node);
303	leds = of_find_node_by_name(hellcreek->dev->of_node, "leds");	304	leds = of_find_node_by_name(hellcreek->dev->of_node, "leds");
304	if (!leds) {	305	if (!leds) {
305	dev_err(hellcreek->dev, "No LEDs specified in device tree!\n");	306	dev_err(hellcreek->dev, "No LEDs specified in device tree!\n");

drivers/net/dsa/ocelot/felix_vsc9959.c+4−0

 static void vsc9959_psfp_counters_get(struct ocelot *ocelot, u32 index,
 				      struct felix_stream_filter_counters *counters)
 {
+	mutex_lock(&ocelot->stats_lock);
 	ocelot_rmw(ocelot, SYS_STAT_CFG_STAT_VIEW(index),
 		   SYS_STAT_CFG_STAT_VIEW_M,
 		   SYS_STAT_CFG);
 		     SYS_STAT_CFG_STAT_VIEW(index) |
 		     SYS_STAT_CFG_STAT_CLEAR_SHOT(0x10),
 		     SYS_STAT_CFG);
+	mutex_unlock(&ocelot->stats_lock);
 }
 static int vsc9959_psfp_filter_add(struct ocelot *ocelot, int port,

drivers/net/ethernet/marvell/octeon_ep/octep_regs_cn9k_pf.h+1−1

@@ -52,7 +52,7 @@ · 51 unmodified lines
52		52
53	#define CN93_SDP_EPF_RINFO_SRN(val) ((val) & 0xFF)	53	#define CN93_SDP_EPF_RINFO_SRN(val) ((val) & 0xFF)
54	#define CN93_SDP_EPF_RINFO_RPVF(val) (((val) >> 32) & 0xF)	54	#define CN93_SDP_EPF_RINFO_RPVF(val) (((val) >> 32) & 0xF)
55	#define CN93_SDP_EPF_RINFO_NVFS(val) (((val) >> 48) && 0xFF)	55	#define CN93_SDP_EPF_RINFO_NVFS(val) (((val) >> 48) & 0xFF)
56		56
57	/* SDP Function select */	57	/* SDP Function select */
58	#define CN93_SDP_FUNC_SEL_EPF_BIT_POS 8	58	#define CN93_SDP_FUNC_SEL_EPF_BIT_POS 8

drivers/net/ethernet/mellanox/mlxsw/spectrum_router.c+13−1

 	return 0;
 err_nexthop_neigh_init:
+	list_del(&nh->router_list_node);
+	mlxsw_sp_nexthop_counter_free(mlxsw_sp, nh);
 	mlxsw_sp_nexthop_remove(mlxsw_sp, nh);
 	return err;
 }
 				  const struct fib6_info *rt)
 {
 	struct net_device *dev = rt->fib6_nh->fib_nh_dev;
+	int err;
 	nh->nhgi = nh_grp->nhgi;
 	nh->nh_weight = rt->fib6_nh->fib_nh_weight;
 		return 0;
 	nh->ifindex = dev->ifindex;
-	return mlxsw_sp_nexthop_type_init(mlxsw_sp, nh, dev);
+	err = mlxsw_sp_nexthop_type_init(mlxsw_sp, nh, dev);
+	if (err)
+		goto err_nexthop_type_init;
+	return 0;
+err_nexthop_type_init:
+	list_del(&nh->router_list_node);
+	mlxsw_sp_nexthop_counter_free(mlxsw_sp, nh);
+	return err;
 }
 static void mlxsw_sp_nexthop6_fini(struct mlxsw_sp *mlxsw_sp,

drivers/net/ethernet/microchip/sparx5/sparx5_switchdev.c+6−0

 	u32 mact_entry;
 	int res, err;
+	if (!sparx5_netdevice_check(dev))
+		return -EOPNOTSUPP;
 	if (netif_is_bridge_master(v->obj.orig_dev)) {
 		sparx5_mact_learn(spx5, PGID_CPU, v->addr, v->vid);
 		return 0;
 	u32 mact_entry, res, pgid_entry[3];
 	int err;
+	if (!sparx5_netdevice_check(dev))
+		return -EOPNOTSUPP;
 	if (netif_is_bridge_master(v->obj.orig_dev)) {
 		sparx5_mact_forget(spx5, v->addr, v->vid);
 		return 0;

drivers/net/ethernet/smsc/epic100.c+2−2

 	struct net_device *dev = pci_get_drvdata(pdev);
 	struct epic_private *ep = netdev_priv(dev);
+	unregister_netdev(dev);
 	dma_free_coherent(&pdev->dev, TX_TOTAL_SIZE, ep->tx_ring,
 			  ep->tx_ring_dma);
 	dma_free_coherent(&pdev->dev, RX_TOTAL_SIZE, ep->rx_ring,
 			  ep->rx_ring_dma);
-	unregister_netdev(dev);
 	pci_iounmap(pdev, ep->ioaddr);
-	pci_release_regions(pdev);
 	free_netdev(dev);
+	pci_release_regions(pdev);
 	pci_disable_device(pdev);
 	/* pci_power_off(pdev, -1); */
 }

drivers/net/phy/ax88796b.c+4−2

 	/* Reset PHY, otherwise MII_LPA will provide outdated information.
 	 * This issue is reproducible only with some link partner PHYs
 	 */
-	if (phydev->state == PHY_NOLINK && phydev->drv->soft_reset)
+	if (phydev->state == PHY_NOLINK) {
-		phydev->drv->soft_reset(phydev);
+		phy_init_hw(phydev);
+		phy_start_aneg(phydev);
+	}
 }
 static struct phy_driver asix_driver[] = {

drivers/net/phy/dp83822.c+1−3

@@ -229,9 +229,7 @@ static int dp83822_config_intr(struct phy_device *phydev) · 228 unmodified lines
229	if (misr_status < 0)	229	if (misr_status < 0)
230	return misr_status;	230	return misr_status;
231		231
232	misr_status \|= (DP83822_RX_ERR_HF_INT_EN \|	232	misr_status \|= (DP83822_LINK_STAT_INT_EN \|
233	DP83822_FALSE_CARRIER_HF_INT_EN \|
234	DP83822_LINK_STAT_INT_EN \|
235	DP83822_ENERGY_DET_INT_EN \|	233	DP83822_ENERGY_DET_INT_EN \|
236	DP83822_LINK_QUAL_INT_EN);	234	DP83822_LINK_QUAL_INT_EN);
237		235

drivers/net/phy/phy.c+23−0

@@ -31,6 +31,7 @@ · 30 unmodified lines
31	#include <linux/io.h>	31	#include <linux/io.h>
32	#include <linux/uaccess.h>	32	#include <linux/uaccess.h>
33	#include <linux/atomic.h>	33	#include <linux/atomic.h>
		34	#include <linux/suspend.h>
34	#include <net/netlink.h>	35	#include <net/netlink.h>
35	#include <net/genetlink.h>	36	#include <net/genetlink.h>
36	#include <net/sock.h>	37	#include <net/sock.h>
@@ -976,6 +977,28 @@ static irqreturn_t phy_interrupt(int irq, void *phy_dat) · 939 unmodified lines
976	struct phy_driver *drv = phydev->drv;	977	struct phy_driver *drv = phydev->drv;
977	irqreturn_t ret;	978	irqreturn_t ret;
978		979
		980	/* Wakeup interrupts may occur during a system sleep transition.
		981	* Postpone handling until the PHY has resumed.
		982	*/
		983	if (IS_ENABLED(CONFIG_PM_SLEEP) && phydev->irq_suspended) {
		984	struct net_device *netdev = phydev->attached_dev;
		985
		986	if (netdev) {
		987	struct device *parent = netdev->dev.parent;
		988
		989	if (netdev->wol_enabled)
		990	pm_system_wakeup();
		991	else if (device_may_wakeup(&netdev->dev))
		992	pm_wakeup_dev_event(&netdev->dev, 0, true);
		993	else if (parent && device_may_wakeup(parent))
		994	pm_wakeup_dev_event(parent, 0, true);
		995	}
		996
		997	phydev->irq_rerun = 1;
		998	disable_irq_nosync(irq);
		999	return IRQ_HANDLED;
		1000	}
		1001
979	mutex_lock(&phydev->lock);	1002	mutex_lock(&phydev->lock);
980	ret = drv->handle_interrupt(phydev);	1003	ret = drv->handle_interrupt(phydev);
981	mutex_unlock(&phydev->lock);	1004	mutex_unlock(&phydev->lock);

drivers/net/phy/phy_device.c+23−0

@@ -278,6 +278,15 @@ static __maybe_unused int mdio_bus_phy_suspend(struct device *dev) · 277 unmodified lines
278	if (phydev->mac_managed_pm)	278	if (phydev->mac_managed_pm)
279	return 0;	279	return 0;
280		280
		281	/* Wakeup interrupts may occur during the system sleep transition when
		282	* the PHY is inaccessible. Set flag to postpone handling until the PHY
		283	* has resumed. Wait for concurrent interrupt handler to complete.
		284	*/
		285	if (phy_interrupt_is_valid(phydev)) {
		286	phydev->irq_suspended = 1;
		287	synchronize_irq(phydev->irq);
		288	}
		289
281	/* We must stop the state machine manually, otherwise it stops out of	290	/* We must stop the state machine manually, otherwise it stops out of
282	* control, possibly with the phydev->lock held. Upon resume, netdev	291	* control, possibly with the phydev->lock held. Upon resume, netdev
283	* may call phy routines that try to grab the same lock, and that may	292	* may call phy routines that try to grab the same lock, and that may
@@ -315,6 +324,20 @@ static __maybe_unused int mdio_bus_phy_resume(struct device *dev) · 31 unmodified lines
315	if (ret < 0)	324	if (ret < 0)
316	return ret;	325	return ret;
317	no_resume:	326	no_resume:
		327	if (phy_interrupt_is_valid(phydev)) {
		328	phydev->irq_suspended = 0;
		329	synchronize_irq(phydev->irq);
		330
		331	/* Rerun interrupts which were postponed by phy_interrupt()
		332	* because they occurred during the system sleep transition.
		333	*/
		334	if (phydev->irq_rerun) {
		335	phydev->irq_rerun = 0;
		336	enable_irq(phydev->irq);
		337	irq_wake_thread(phydev->irq, phydev);
		338	}
		339	}
		340
318	if (phydev->attached_dev && phydev->adjust_link)	341	if (phydev->attached_dev && phydev->adjust_link)
319	phy_start_machine(phydev);	342	phy_start_machine(phydev);
320		343

drivers/net/phy/sfp.c+1−1

@@ -2516,7 +2516,7 @@ static int sfp_probe(struct platform_device *pdev) · 2515 unmodified lines
2516		2516
2517	platform_set_drvdata(pdev, sfp);	2517	platform_set_drvdata(pdev, sfp);
2518		2518
2519	err = devm_add_action(sfp->dev, sfp_cleanup, sfp);	2519	err = devm_add_action_or_reset(sfp->dev, sfp_cleanup, sfp);
2520	if (err < 0)	2520	if (err < 0)
2521	return err;	2521	return err;
2522		2522

drivers/net/tun.c+13−2

 	}
 }
+static void tun_napi_enable(struct tun_file *tfile)
+{
+	if (tfile->napi_enabled)
+		napi_enable(&tfile->napi);
+}
 static void tun_napi_disable(struct tun_file *tfile)
 {
 	if (tfile->napi_enabled)
 	tun = rtnl_dereference(tfile->tun);
 	if (tun && clean) {
-		tun_napi_disable(tfile);
+		if (!tfile->detached)
+			tun_napi_disable(tfile);
 		tun_napi_del(tfile);
 	}
 		if (clean) {
 			RCU_INIT_POINTER(tfile->tun, NULL);
 			sock_put(&tfile->sk);
-		} else
+		} else {
 			tun_disable_queue(tun, tfile);
+			tun_napi_disable(tfile);
+		}
 		synchronize_net();
 		tun_flow_delete_by_queue(tun, tun->numqueues + 1);
 		sock_put(&tfile->sk);
 	}
 	list_for_each_entry_safe(tfile, tmp, &tun->disabled, next) {
+		tun_napi_del(tfile);
 		tun_enable_queue(tfile);
 		tun_queue_purge(tfile);
 		xdp_rxq_info_unreg(&tfile->xdp_rxq);
 	if (tfile->detached) {
 		tun_enable_queue(tfile);
+		tun_napi_enable(tfile);
 	} else {
 		sock_hold(&tfile->sk);
 		tun_napi_init(tun, tfile, napi, napi_frags);

drivers/net/usb/asix.h+1−2

@@ -126,8 +126,7 @@ · 125 unmodified lines
126	AX_MEDIUM_RE)	126	AX_MEDIUM_RE)
127		127
128	#define AX88772_MEDIUM_DEFAULT \	128	#define AX88772_MEDIUM_DEFAULT \
129	(AX_MEDIUM_FD \| AX_MEDIUM_RFC \| \	129	(AX_MEDIUM_FD \| AX_MEDIUM_PS \| \
130	AX_MEDIUM_TFC \| AX_MEDIUM_PS \| \
131	AX_MEDIUM_AC \| AX_MEDIUM_RE)	130	AX_MEDIUM_AC \| AX_MEDIUM_RE)
132		131
133	/* AX88772 & AX88178 RX_CTL values */	132	/* AX88772 & AX88178 RX_CTL values */

drivers/net/usb/asix_common.c+1−0

@@ -431,6 +431,7 @@ void asix_adjust_link(struct net_device *netdev) · 430 unmodified lines
431		431
432	asix_write_medium_mode(dev, mode, 0);	432	asix_write_medium_mode(dev, mode, 0);
433	phy_print_status(phydev);	433	phy_print_status(phydev);
		434	usbnet_link_change(dev, phydev->link, 0);
434	}	435	}
435		436
436	int asix_write_gpio(struct usbnet *dev, u16 value, int sleep, int in_pm)	437	int asix_write_gpio(struct usbnet *dev, u16 value, int sleep, int in_pm)

drivers/net/usb/ax88179_178a.c+76−25

@@ -1472,6 +1472,42 @@ static int ax88179_rx_fixup(struct usbnet dev, struct sk_buff skb) · 1471 unmodified lines
1472	* are bundled into this buffer and where we can find an array of	1472	* are bundled into this buffer and where we can find an array of
1473	* per-packet metadata (which contains elements encoded into u16).	1473	* per-packet metadata (which contains elements encoded into u16).
1474	*/	1474	*/
		1475
		1476	/* SKB contents for current firmware:
		1477	* <packet 1> <padding>
		1478	* ...
		1479	* <packet N> <padding>
		1480	* <per-packet metadata entry 1> <dummy header>
		1481	* ...
		1482	* <per-packet metadata entry N> <dummy header>
		1483	* <padding2> <rx_hdr>
		1484	*
		1485	* where:
		1486	* <packet N> contains pkt_len bytes:
		1487	* 2 bytes of IP alignment pseudo header
		1488	* packet received
		1489	* <per-packet metadata entry N> contains 4 bytes:
		1490	* pkt_len and fields AX_RXHDR_*
		1491	* <padding> 0-7 bytes to terminate at
		1492	* 8 bytes boundary (64-bit).
		1493	* <padding2> 4 bytes to make rx_hdr terminate at
		1494	* 8 bytes boundary (64-bit)
		1495	* <dummy-header> contains 4 bytes:
		1496	* pkt_len=0 and AX_RXHDR_DROP_ERR
		1497	* <rx-hdr> contains 4 bytes:
		1498	* pkt_cnt and hdr_off (offset of
		1499	* <per-packet metadata entry 1>)
		1500	*
		1501	* pkt_cnt is number of entrys in the per-packet metadata.
		1502	* In current firmware there is 2 entrys per packet.
		1503	* The first points to the packet and the
		1504	* second is a dummy header.
		1505	* This was done probably to align fields in 64-bit and
		1506	* maintain compatibility with old firmware.
		1507	* This code assumes that <dummy header> and <padding2> are
		1508	* optional.
		1509	*/
		1510
1475	if (skb->len < 4)	1511	if (skb->len < 4)
1476	return 0;	1512	return 0;
1477	skb_trim(skb, skb->len - 4);	1513	skb_trim(skb, skb->len - 4);
@@ -1485,51 +1521,66 @@ static int ax88179_rx_fixup(struct usbnet dev, struct sk_buff skb) · 7 unmodified lines
1485	/* Make sure that the bounds of the metadata array are inside the SKB	1521	/* Make sure that the bounds of the metadata array are inside the SKB
1486	* (and in front of the counter at the end).	1522	* (and in front of the counter at the end).
1487	*/	1523	*/
1488	if (pkt_cnt * 2 + hdr_off > skb->len)	1524	if (pkt_cnt * 4 + hdr_off > skb->len)
1489	return 0;	1525	return 0;
1490	pkt_hdr = (u32 *)(skb->data + hdr_off);	1526	pkt_hdr = (u32 *)(skb->data + hdr_off);
1491		1527
1492	/* Packets must not overlap the metadata array */	1528	/* Packets must not overlap the metadata array */
1493	skb_trim(skb, hdr_off);	1529	skb_trim(skb, hdr_off);
1494		1530
1495	for (; ; pkt_cnt--, pkt_hdr++) {	1531	for (; pkt_cnt > 0; pkt_cnt--, pkt_hdr++) {
		1532	u16 pkt_len_plus_padd;
1496	u16 pkt_len;	1533	u16 pkt_len;
1497		1534
1498	le32_to_cpus(pkt_hdr);	1535	le32_to_cpus(pkt_hdr);
1499	pkt_len = (*pkt_hdr >> 16) & 0x1fff;	1536	pkt_len = (*pkt_hdr >> 16) & 0x1fff;
		1537	pkt_len_plus_padd = (pkt_len + 7) & 0xfff8;
1500		1538
1501	if (pkt_len > skb->len)	1539	/* Skip dummy header used for alignment
		1540	*/
		1541	if (pkt_len == 0)
		1542	continue;
		1543
		1544	if (pkt_len_plus_padd > skb->len)
1502	return 0;	1545	return 0;
1503		1546
1504	/* Check CRC or runt packet */	1547	/* Check CRC or runt packet */
1505	if (((*pkt_hdr & (AX_RXHDR_CRC_ERR \| AX_RXHDR_DROP_ERR)) == 0) &&	1548	if ((*pkt_hdr & (AX_RXHDR_CRC_ERR \| AX_RXHDR_DROP_ERR)) \|\|
1506	pkt_len >= 2 + ETH_HLEN) {	1549	pkt_len < 2 + ETH_HLEN) {
1507	bool last = (pkt_cnt == 0);	1550	dev->net->stats.rx_errors++;
1508		1551	skb_pull(skb, pkt_len_plus_padd);
1509	if (last) {	1552	continue;
1510	ax_skb = skb;	1553	}
1511	} else {
1512	ax_skb = skb_clone(skb, GFP_ATOMIC);
1513	if (!ax_skb)
1514	return 0;
1515	}
1516	ax_skb->len = pkt_len;
1517	/* Skip IP alignment pseudo header */
1518	skb_pull(ax_skb, 2);
1519	skb_set_tail_pointer(ax_skb, ax_skb->len);
1520	ax_skb->truesize = pkt_len + sizeof(struct sk_buff);
1521	ax88179_rx_checksum(ax_skb, pkt_hdr);
1522		1554
1523	if (last)	1555	/* last packet */
1524	return 1;	1556	if (pkt_len_plus_padd == skb->len) {
		1557	skb_trim(skb, pkt_len);
1525		1558
1526	usbnet_skb_return(dev, ax_skb);	1559	/* Skip IP alignment pseudo header */
		1560	skb_pull(skb, 2);
		1561
		1562	skb->truesize = SKB_TRUESIZE(pkt_len_plus_padd);
		1563	ax88179_rx_checksum(skb, pkt_hdr);
		1564	return 1;
1527	}	1565	}
1528		1566
1529	/* Trim this packet away from the SKB */	1567	ax_skb = skb_clone(skb, GFP_ATOMIC);
1530	if (!skb_pull(skb, (pkt_len + 7) & 0xFFF8))	1568	if (!ax_skb)
1531	return 0;	1569	return 0;
		1570	skb_trim(ax_skb, pkt_len);
		1571
		1572	/* Skip IP alignment pseudo header */
		1573	skb_pull(ax_skb, 2);
		1574
		1575	skb->truesize = pkt_len_plus_padd +
		1576	SKB_DATA_ALIGN(sizeof(struct sk_buff));
		1577	ax88179_rx_checksum(ax_skb, pkt_hdr);
		1578	usbnet_skb_return(dev, ax_skb);
		1579
		1580	skb_pull(skb, pkt_len_plus_padd);
1532	}	1581	}
		1582
		1583	return 0;
1533	}	1584	}
1534		1585
1535	static struct sk_buff *	1586	static struct sk_buff *

drivers/net/usb/usbnet.c+2−2

@@ -2004,7 +2004,7 @@ static int __usbnet_read_cmd(struct usbnet *dev, u8 cmd, u8 reqtype, · 2003 unmodified lines
2004	cmd, reqtype, value, index, size);	2004	cmd, reqtype, value, index, size);
2005		2005
2006	if (size) {	2006	if (size) {
2007	buf = kmalloc(size, GFP_KERNEL);	2007	buf = kmalloc(size, GFP_NOIO);
2008	if (!buf)	2008	if (!buf)
2009	goto out;	2009	goto out;
2010	}	2010	}
@@ -2036,7 +2036,7 @@ static int __usbnet_write_cmd(struct usbnet *dev, u8 cmd, u8 reqtype, · 25 unmodified lines
2036	cmd, reqtype, value, index, size);	2036	cmd, reqtype, value, index, size);
2037		2037
2038	if (data) {	2038	if (data) {
2039	buf = kmemdup(data, size, GFP_KERNEL);	2039	buf = kmemdup(data, size, GFP_NOIO);
2040	if (!buf)	2040	if (!buf)
2041	goto out;	2041	goto out;
2042	} else {	2042	} else {

drivers/nfc/nfcmrvl/i2c.c+3−3

@@ -167,9 +167,9 @@ static int nfcmrvl_i2c_parse_dt(struct device_node *node, · 166 unmodified lines
167	pdata->irq_polarity = IRQF_TRIGGER_RISING;	167	pdata->irq_polarity = IRQF_TRIGGER_RISING;
168		168
169	ret = irq_of_parse_and_map(node, 0);	169	ret = irq_of_parse_and_map(node, 0);
170	if (ret < 0) {	170	if (!ret) {
171	pr_err("Unable to get irq, error: %d\n", ret);	171	pr_err("Unable to get irq\n");
172	return ret;	172	return -EINVAL;
173	}	173	}
174	pdata->irq = ret;	174	pdata->irq = ret;
175		175

drivers/nfc/nfcmrvl/spi.c+3−3

@@ -115,9 +115,9 @@ static int nfcmrvl_spi_parse_dt(struct device_node *node, · 114 unmodified lines
115	}	115	}
116		116
117	ret = irq_of_parse_and_map(node, 0);	117	ret = irq_of_parse_and_map(node, 0);
118	if (ret < 0) {	118	if (!ret) {
119	pr_err("Unable to get irq, error: %d\n", ret);	119	pr_err("Unable to get irq\n");
120	return ret;	120	return -EINVAL;
121	}	121	}
122	pdata->irq = ret;	122	pdata->irq = ret;
123		123

drivers/nfc/nxp-nci/i2c.c+9−2

 	skb_put_data(*skb, &header, NXP_NCI_FW_HDR_LEN);
 	r = i2c_master_recv(client, skb_put(*skb, frame_len), frame_len);
-	if (r != frame_len) {
+	if (r < 0) {
+		goto fw_read_exit_free_skb;
+	} else if (r != frame_len) {
 		nfc_err(&client->dev,
 			"Invalid frame length: %u (expected %zu)\n",
 			r, frame_len);
 	skb_put_data(*skb, (void *)&header, NCI_CTRL_HDR_SIZE);
+	if (!header.plen)
+		return 0;
 	r = i2c_master_recv(client, skb_put(*skb, header.plen), header.plen);
-	if (r != header.plen) {
+	if (r < 0) {
+		goto nci_read_exit_free_skb;
+	} else if (r != header.plen) {
 		nfc_err(&client->dev,
 			"Invalid frame payload length: %u (expected %u)\n",
 			r, header.plen);

include/linux/netdevice.h+1−1

@@ -1671,7 +1671,7 @@ enum netdev_priv_flags { · 1670 unmodified lines
1671	IFF_FAILOVER_SLAVE = 1<<28,	1671	IFF_FAILOVER_SLAVE = 1<<28,
1672	IFF_L3MDEV_RX_HANDLER = 1<<29,	1672	IFF_L3MDEV_RX_HANDLER = 1<<29,
1673	IFF_LIVE_RENAME_OK = 1<<30,	1673	IFF_LIVE_RENAME_OK = 1<<30,
1674	IFF_TX_SKB_NO_LINEAR = 1<<31,	1674	IFF_TX_SKB_NO_LINEAR = BIT_ULL(31),
1675	IFF_CHANGE_PROTO_DOWN = BIT_ULL(32),	1675	IFF_CHANGE_PROTO_DOWN = BIT_ULL(32),
1676	};	1676	};
1677		1677

include/linux/phy.h+6−0

  * @mdix_ctrl: User setting of crossover
  * @pma_extable: Cached value of PMA/PMD Extended Abilities Register
  * @interrupts: Flag interrupts have been enabled
+ * @irq_suspended: Flag indicating PHY is suspended and therefore interrupt
+ *                 handling shall be postponed until PHY has resumed
+ * @irq_rerun: Flag indicating interrupts occurred while PHY was suspended,
+ *             requiring a rerun of the interrupt handler after resume
  * @interface: enum phy_interface_t value
  * @skb: Netlink message for cable diagnostics
  * @nest: Netlink nest used for cable diagnostics
 	/* Interrupts are enabled */
 	unsigned interrupts:1;
+	unsigned irq_suspended:1;
+	unsigned irq_rerun:1;
 	enum phy_state state;

include/net/netfilter/nf_tables.h+10−6

 /**
  *	struct nft_traceinfo - nft tracing information and state
  *
+ *	@trace: other struct members are initialised
+ *	@nf_trace: copy of skb->nf_trace before rule evaluation
+ *	@type: event type (enum nft_trace_types)
+ *	@skbid: hash of skb to be used as trace id
+ *	@packet_dumped: packet headers sent in a previous traceinfo message
  *	@pkt: pktinfo currently processed
  *	@basechain: base chain currently processed
  *	@chain: chain currently processed
  *	@rule:  rule that was evaluated
  *	@verdict: verdict given by rule
- *	@type: event type (enum nft_trace_types)
- *	@packet_dumped: packet headers sent in a previous traceinfo message
- *	@trace: other struct members are initialised
  */
 struct nft_traceinfo {
+	bool				trace;
+	bool				nf_trace;
+	bool				packet_dumped;
+	enum nft_trace_types		type:8;
+	u32				skbid;
 	const struct nft_pktinfo	*pkt;
 	const struct nft_base_chain	*basechain;
 	const struct nft_chain		*chain;
 	const struct nft_rule_dp	*rule;
 	const struct nft_verdict	*verdict;
-	enum nft_trace_types		type;
-	bool				packet_dumped;
-	bool				trace;
 };
 void nft_trace_init(struct nft_traceinfo *info, const struct nft_pktinfo *pkt,

include/uapi/linux/mptcp.h+5−4

 #ifndef _UAPI_MPTCP_H
 #define _UAPI_MPTCP_H
+#ifndef __KERNEL__
+#include <netinet/in.h>		/* for sockaddr_in and sockaddr_in6	*/
+#include <sys/socket.h>		/* for struct sockaddr			*/
+#endif
 #include <linux/const.h>
 #include <linux/types.h>
 #include <linux/in.h>		/* for sockaddr_in			*/
 #include <linux/in6.h>		/* for sockaddr_in6			*/
 #include <linux/socket.h>	/* for sockaddr_storage and sa_family	*/
-#ifndef __KERNEL__
-#include <sys/socket.h>		/* for struct sockaddr			*/
-#endif
 #define MPTCP_SUBFLOW_FLAG_MCAP_REM		_BITUL(0)
 #define MPTCP_SUBFLOW_FLAG_MCAP_LOC		_BITUL(1)
 #define MPTCP_SUBFLOW_FLAG_JOIN_REM		_BITUL(2)

net/bridge/br_netfilter_hooks.c+18−3

@@ -1012,9 +1012,24 @@ int br_nf_hook_thresh(unsigned int hook, struct net *net, · 1011 unmodified lines
1012	return okfn(net, sk, skb);	1012	return okfn(net, sk, skb);
1013		1013
1014	ops = nf_hook_entries_get_hook_ops(e);	1014	ops = nf_hook_entries_get_hook_ops(e);
1015	for (i = 0; i < e->num_hook_entries &&	1015	for (i = 0; i < e->num_hook_entries; i++) {
1016	ops[i]->priority <= NF_BR_PRI_BRNF; i++)	1016	/* These hooks have already been called */
1017	;	1017	if (ops[i]->priority < NF_BR_PRI_BRNF)
		1018	continue;
		1019
		1020	/* These hooks have not been called yet, run them. */
		1021	if (ops[i]->priority > NF_BR_PRI_BRNF)
		1022	break;
		1023
		1024	/* take a closer look at NF_BR_PRI_BRNF. */
		1025	if (ops[i]->hook == br_nf_pre_routing) {
		1026	/* This hook diverted the skb to this function,
		1027	* hooks after this have not been run yet.
		1028	*/
		1029	i++;
		1030	break;
		1031	}
		1032	}
1018		1033
1019	nf_hook_state_init(&state, hook, NFPROTO_BRIDGE, indev, outdev,	1034	nf_hook_state_init(&state, hook, NFPROTO_BRIDGE, indev, outdev,
1020	sk, net, okfn);	1035	sk, net, okfn);

net/ipv4/ip_tunnel_core.c+1−1

@@ -410,7 +410,7 @@ int skb_tunnel_check_pmtu(struct sk_buff skb, struct dst_entry encap_dst, · 409 unmodified lines
410	u32 mtu = dst_mtu(encap_dst) - headroom;	410	u32 mtu = dst_mtu(encap_dst) - headroom;
411		411
412	if ((skb_is_gso(skb) && skb_gso_validate_network_len(skb, mtu)) \|\|	412	if ((skb_is_gso(skb) && skb_gso_validate_network_len(skb, mtu)) \|\|
413	(!skb_is_gso(skb) && (skb->len - skb_mac_header_len(skb)) <= mtu))	413	(!skb_is_gso(skb) && (skb->len - skb_network_offset(skb)) <= mtu))
414	return 0;	414	return 0;
415		415
416	skb_dst_update_pmtu_no_confirm(skb, mtu);	416	skb_dst_update_pmtu_no_confirm(skb, mtu);

net/ipv4/tcp_ipv4.c+5−1

 		struct sock *nsk;
 		sk = req->rsk_listener;
-		drop_reason = tcp_inbound_md5_hash(sk, skb,
+		if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb))
+			drop_reason = SKB_DROP_REASON_XFRM_POLICY;
+		else
+			drop_reason = tcp_inbound_md5_hash(sk, skb,
 						   &iph->saddr, &iph->daddr,
 						   AF_INET, dif, sdif);
 		if (unlikely(drop_reason)) {
 			}
 			goto discard_and_relse;
 		}
+		nf_reset_ct(skb);
 		if (nsk == sk) {
 			reqsk_put(req);
 			tcp_v4_restore_cb(skb);

net/ipv6/addrconf.c+2−6

 		goto out;
 	}
-	if (net->ipv6.devconf_all->disable_policy ||
-	    idev->cnf.disable_policy)
-		f6i->dst_nopolicy = true;
 	neigh_parms_data_state_setall(idev->nd_parms);
 	ifa->addr = *cfg->pfx;
 		fillargs->event = RTM_GETMULTICAST;
 		/* multicast address */
-		for (ifmca = rcu_dereference(idev->mc_list);
+		for (ifmca = rtnl_dereference(idev->mc_list);
 		     ifmca;
-		     ifmca = rcu_dereference(ifmca->next), ip_idx++) {
+		     ifmca = rtnl_dereference(ifmca->next), ip_idx++) {
 			if (ip_idx < s_ip_idx)
 				continue;
 			err = inet6_fill_ifmcaddr(skb, ifmca, fillargs);

net/ipv6/route.c+8−1

 	}
 	f6i = ip6_route_info_create(&cfg, gfp_flags, NULL);
-	if (!IS_ERR(f6i))
+	if (!IS_ERR(f6i)) {
 		f6i->dst_nocount = true;
+		if (!anycast &&
+		    (net->ipv6.devconf_all->disable_policy ||
+		     idev->cnf.disable_policy))
+			f6i->dst_nopolicy = true;
+	}
 	return f6i;
 }

net/ipv6/seg6_hmac.c+0−1

@@ -406,7 +406,6 @@ int __net_init seg6_hmac_net_init(struct net *net) · 405 unmodified lines
406		406
407	return rhashtable_init(&sdata->hmac_infos, &rht_params);	407	return rhashtable_init(&sdata->hmac_infos, &rht_params);
408	}	408	}
409	EXPORT_SYMBOL(seg6_hmac_net_init);
410		409
411	void seg6_hmac_exit(void)	410	void seg6_hmac_exit(void)
412	{	411	{

net/ipv6/sit.c+3−5

@@ -323,8 +323,6 @@ static int ipip6_tunnel_get_prl(struct net_device *dev, struct ip_tunnel_prl __u · 322 unmodified lines
323	kcalloc(cmax, sizeof(*kp), GFP_KERNEL_ACCOUNT \| __GFP_NOWARN) :	323	kcalloc(cmax, sizeof(*kp), GFP_KERNEL_ACCOUNT \| __GFP_NOWARN) :
324	NULL;	324	NULL;
325		325
326	rcu_read_lock();
327
328	ca = min(t->prl_count, cmax);	326	ca = min(t->prl_count, cmax);
329		327
330	if (!kp) {	328	if (!kp) {
@@ -341,7 +339,7 @@ static int ipip6_tunnel_get_prl(struct net_device *dev, struct ip_tunnel_prl __u · 10 unmodified lines
341	}	339	}
342	}	340	}
343		341
344	c = 0;	342	rcu_read_lock();
345	for_each_prl_rcu(t->prl) {	343	for_each_prl_rcu(t->prl) {
346	if (c >= cmax)	344	if (c >= cmax)
347	break;	345	break;
@@ -353,7 +351,7 @@ static int ipip6_tunnel_get_prl(struct net_device *dev, struct ip_tunnel_prl __u · 5 unmodified lines
353	if (kprl.addr != htonl(INADDR_ANY))	351	if (kprl.addr != htonl(INADDR_ANY))
354	break;	352	break;
355	}	353	}
356	out:	354
357	rcu_read_unlock();	355	rcu_read_unlock();
358		356
359	len = sizeof(kp) c;	357	len = sizeof(kp) c;
@@ -362,7 +360,7 @@ out: · 2 unmodified lines
362	ret = -EFAULT;	360	ret = -EFAULT;
363		361
364	kfree(kp);	362	kfree(kp);
365		363	out:
366	return ret;	364	return ret;
367	}	365	}
368		366

net/mptcp/options.c+4−3

 	opts->suboptions |= OPTION_MPTCP_RST;
 	opts->reset_transient = subflow->reset_transient;
 	opts->reset_reason = subflow->reset_reason;
+	MPTCP_INC_STATS(sock_net(sk), MPTCP_MIB_MPRSTTX);
 	return true;
 }
 	opts->rcvr_key = msk->remote_key;
 	pr_debug("FASTCLOSE key=%llu", opts->rcvr_key);
+	MPTCP_INC_STATS(sock_net(sk), MPTCP_MIB_MPFASTCLOSETX);
 	return true;
 }
 	opts->fail_seq = subflow->map_seq;
 	pr_debug("MP_FAIL fail_seq=%llu", opts->fail_seq);
+	MPTCP_INC_STATS(sock_net(sk), MPTCP_MIB_MPFAILTX);
 	return true;
 }
 		    mptcp_established_options_mp_fail(sk, &opt_size, remaining, opts)) {
 			*size += opt_size;
 			remaining -= opt_size;
-			MPTCP_INC_STATS(sock_net(sk), MPTCP_MIB_MPFASTCLOSETX);
 		}
 		/* MP_RST can be used with MP_FASTCLOSE and MP_FAIL if there is room */
 		if (mptcp_established_options_rst(sk, skb, &opt_size, remaining, opts)) {
 			*size += opt_size;
 			remaining -= opt_size;
-			MPTCP_INC_STATS(sock_net(sk), MPTCP_MIB_MPRSTTX);
 		}
 		return true;
 	}
 			goto reset;
 		subflow->mp_capable = 0;
 		pr_fallback(msk);
-		__mptcp_do_fallback(msk);
+		mptcp_do_fallback(ssk);
 		return false;
 	}

net/mptcp/pm.c+4−6

@@ -299,23 +299,21 @@ void mptcp_pm_mp_fail_received(struct sock *sk, u64 fail_seq) · 298 unmodified lines
299	{	299	{
300	struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(sk);	300	struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(sk);
301	struct mptcp_sock *msk = mptcp_sk(subflow->conn);	301	struct mptcp_sock *msk = mptcp_sk(subflow->conn);
302	struct sock s = (struct sock )msk;
303		302
304	pr_debug("fail_seq=%llu", fail_seq);	303	pr_debug("fail_seq=%llu", fail_seq);
305		304
306	if (!READ_ONCE(msk->allow_infinite_fallback))	305	if (!READ_ONCE(msk->allow_infinite_fallback))
307	return;	306	return;
308		307
309	if (!READ_ONCE(subflow->mp_fail_response_expect)) {	308	if (!subflow->fail_tout) {
310	pr_debug("send MP_FAIL response and infinite map");	309	pr_debug("send MP_FAIL response and infinite map");
311		310
312	subflow->send_mp_fail = 1;	311	subflow->send_mp_fail = 1;
313	MPTCP_INC_STATS(sock_net(sk), MPTCP_MIB_MPFAILTX);
314	subflow->send_infinite_map = 1;	312	subflow->send_infinite_map = 1;
315	} else if (!sock_flag(sk, SOCK_DEAD)) {	313	tcp_send_ack(sk);
		314	} else {
316	pr_debug("MP_FAIL response received");	315	pr_debug("MP_FAIL response received");
317		316	WRITE_ONCE(subflow->fail_tout, 0);
318	sk_stop_timer(s, &s->sk_timer);
319	}	317	}
320	}	318	}
321		319

net/mptcp/protocol.c+53−31

@@ -500,7 +500,7 @@ static void mptcp_set_timeout(struct sock *sk) · 499 unmodified lines
500	__mptcp_set_timeout(sk, tout);	500	__mptcp_set_timeout(sk, tout);
501	}	501	}
502		502
503	static bool tcp_can_send_ack(const struct sock *ssk)	503	static inline bool tcp_can_send_ack(const struct sock *ssk)
504	{	504	{
505	return !((1 << inet_sk_state_load(ssk)) &	505	return !((1 << inet_sk_state_load(ssk)) &
506	(TCPF_SYN_SENT \| TCPF_SYN_RECV \| TCPF_TIME_WAIT \| TCPF_CLOSE \| TCPF_LISTEN));	506	(TCPF_SYN_SENT \| TCPF_SYN_RECV \| TCPF_TIME_WAIT \| TCPF_CLOSE \| TCPF_LISTEN));
@@ -1245,7 +1245,7 @@ static void mptcp_update_infinite_map(struct mptcp_sock *msk, · 738 unmodified lines
1245	MPTCP_INC_STATS(sock_net(ssk), MPTCP_MIB_INFINITEMAPTX);	1245	MPTCP_INC_STATS(sock_net(ssk), MPTCP_MIB_INFINITEMAPTX);
1246	mptcp_subflow_ctx(ssk)->send_infinite_map = 0;	1246	mptcp_subflow_ctx(ssk)->send_infinite_map = 0;
1247	pr_fallback(msk);	1247	pr_fallback(msk);
1248	__mptcp_do_fallback(msk);	1248	mptcp_do_fallback(ssk);
1249	}	1249	}
1250		1250
1251	static int mptcp_sendmsg_frag(struct sock sk, struct sock ssk,	1251	static int mptcp_sendmsg_frag(struct sock sk, struct sock ssk,
@@ -2175,21 +2175,6 @@ static void mptcp_retransmit_timer(struct timer_list *t) · 923 unmodified lines
2175	sock_put(sk);	2175	sock_put(sk);
2176	}	2176	}
2177		2177
2178	static struct mptcp_subflow_context *
2179	mp_fail_response_expect_subflow(struct mptcp_sock *msk)
2180	{
2181	struct mptcp_subflow_context subflow, ret = NULL;
2182
2183	mptcp_for_each_subflow(msk, subflow) {
2184	if (READ_ONCE(subflow->mp_fail_response_expect)) {
2185	ret = subflow;
2186	break;
2187	}
2188	}
2189
2190	return ret;
2191	}
2192
2193	static void mptcp_timeout_timer(struct timer_list *t)	2178	static void mptcp_timeout_timer(struct timer_list *t)
2194	{	2179	{
2195	struct sock *sk = from_timer(sk, t, sk_timer);	2180	struct sock *sk = from_timer(sk, t, sk_timer);
@@ -2346,6 +2331,11 @@ static void __mptcp_close_ssk(struct sock sk, struct sock ssk, · 150 unmodified lines
2346	kfree_rcu(subflow, rcu);	2331	kfree_rcu(subflow, rcu);
2347	} else {	2332	} else {
2348	/* otherwise tcp will dispose of the ssk and subflow ctx */	2333	/* otherwise tcp will dispose of the ssk and subflow ctx */
		2334	if (ssk->sk_state == TCP_LISTEN) {
		2335	tcp_set_state(ssk, TCP_CLOSE);
		2336	mptcp_subflow_queue_clean(ssk);
		2337	inet_csk_listen_stop(ssk);
		2338	}
2349	__tcp_close(ssk, 0);	2339	__tcp_close(ssk, 0);
2350		2340
2351	/* close acquired an extra ref */	2341	/* close acquired an extra ref */
@@ -2518,27 +2508,50 @@ reset_timer: · 166 unmodified lines
2518	mptcp_reset_timer(sk);	2508	mptcp_reset_timer(sk);
2519	}	2509	}
2520		2510
		2511	/* schedule the timeout timer for the relevant event: either close timeout
		2512	* or mp_fail timeout. The close timeout takes precedence on the mp_fail one
		2513	*/
		2514	void mptcp_reset_timeout(struct mptcp_sock *msk, unsigned long fail_tout)
		2515	{
		2516	struct sock sk = (struct sock )msk;
		2517	unsigned long timeout, close_timeout;
		2518
		2519	if (!fail_tout && !sock_flag(sk, SOCK_DEAD))
		2520	return;
		2521
		2522	close_timeout = inet_csk(sk)->icsk_mtup.probe_timestamp - tcp_jiffies32 + jiffies + TCP_TIMEWAIT_LEN;
		2523
		2524	/* the close timeout takes precedence on the fail one, and here at least one of
		2525	* them is active
		2526	*/
		2527	timeout = sock_flag(sk, SOCK_DEAD) ? close_timeout : fail_tout;
		2528
		2529	sk_reset_timer(sk, &sk->sk_timer, timeout);
		2530	}
		2531
2521	static void mptcp_mp_fail_no_response(struct mptcp_sock *msk)	2532	static void mptcp_mp_fail_no_response(struct mptcp_sock *msk)
2522	{	2533	{
2523	struct mptcp_subflow_context *subflow;	2534	struct sock *ssk = msk->first;
2524	struct sock *ssk;
2525	bool slow;	2535	bool slow;
2526		2536
2527	subflow = mp_fail_response_expect_subflow(msk);	2537	if (!ssk)
2528	if (subflow) {	2538	return;
2529	pr_debug("MP_FAIL doesn't respond, reset the subflow");
2530		2539
2531	ssk = mptcp_subflow_tcp_sock(subflow);	2540	pr_debug("MP_FAIL doesn't respond, reset the subflow");
2532	slow = lock_sock_fast(ssk);	2541
2533	mptcp_subflow_reset(ssk);	2542	slow = lock_sock_fast(ssk);
2534	unlock_sock_fast(ssk, slow);	2543	mptcp_subflow_reset(ssk);
2535	}	2544	WRITE_ONCE(mptcp_subflow_ctx(ssk)->fail_tout, 0);
		2545	unlock_sock_fast(ssk, slow);
		2546
		2547	mptcp_reset_timeout(msk, 0);
2536	}	2548	}
2537		2549
2538	static void mptcp_worker(struct work_struct *work)	2550	static void mptcp_worker(struct work_struct *work)
2539	{	2551	{
2540	struct mptcp_sock *msk = container_of(work, struct mptcp_sock, work);	2552	struct mptcp_sock *msk = container_of(work, struct mptcp_sock, work);
2541	struct sock *sk = &msk->sk.icsk_inet.sk;	2553	struct sock *sk = &msk->sk.icsk_inet.sk;
		2554	unsigned long fail_tout;
2542	int state;	2555	int state;
2543		2556
2544	lock_sock(sk);	2557	lock_sock(sk);
@@ -2575,7 +2588,9 @@ static void mptcp_worker(struct work_struct *work) · 30 unmodified lines
2575	if (test_and_clear_bit(MPTCP_WORK_RTX, &msk->flags))	2588	if (test_and_clear_bit(MPTCP_WORK_RTX, &msk->flags))
2576	__mptcp_retrans(sk);	2589	__mptcp_retrans(sk);
2577		2590
2578	mptcp_mp_fail_no_response(msk);	2591	fail_tout = msk->first ? READ_ONCE(mptcp_subflow_ctx(msk->first)->fail_tout) : 0;
		2592	if (fail_tout && time_after(jiffies, fail_tout))
		2593	mptcp_mp_fail_no_response(msk);
2579		2594
2580	unlock:	2595	unlock:
2581	release_sock(sk);	2596	release_sock(sk);
@@ -2822,6 +2837,7 @@ static void __mptcp_destroy_sock(struct sock *sk) · 240 unmodified lines
2822	static void mptcp_close(struct sock *sk, long timeout)	2837	static void mptcp_close(struct sock *sk, long timeout)
2823	{	2838	{
2824	struct mptcp_subflow_context *subflow;	2839	struct mptcp_subflow_context *subflow;
		2840	struct mptcp_sock *msk = mptcp_sk(sk);
2825	bool do_cancel_work = false;	2841	bool do_cancel_work = false;
2826		2842
2827	lock_sock(sk);	2843	lock_sock(sk);
@@ -2840,10 +2856,16 @@ static void mptcp_close(struct sock *sk, long timeout) · 12 unmodified lines
2840	cleanup:	2856	cleanup:
2841	/* orphan all the subflows */	2857	/* orphan all the subflows */
2842	inet_csk(sk)->icsk_mtup.probe_timestamp = tcp_jiffies32;	2858	inet_csk(sk)->icsk_mtup.probe_timestamp = tcp_jiffies32;
2843	mptcp_for_each_subflow(mptcp_sk(sk), subflow) {	2859	mptcp_for_each_subflow(msk, subflow) {
2844	struct sock *ssk = mptcp_subflow_tcp_sock(subflow);	2860	struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
2845	bool slow = lock_sock_fast_nested(ssk);	2861	bool slow = lock_sock_fast_nested(ssk);
2846		2862
		2863	/* since the close timeout takes precedence on the fail one,
		2864	* cancel the latter
		2865	*/
		2866	if (ssk == msk->first)
		2867	subflow->fail_tout = 0;
		2868
2847	sock_orphan(ssk);	2869	sock_orphan(ssk);
2848	unlock_sock_fast(ssk, slow);	2870	unlock_sock_fast(ssk, slow);
2849	}	2871	}
@@ -2852,13 +2874,13 @@ cleanup: · 2 unmodified lines
2852	sock_hold(sk);	2874	sock_hold(sk);
2853	pr_debug("msk=%p state=%d", sk, sk->sk_state);	2875	pr_debug("msk=%p state=%d", sk, sk->sk_state);
2854	if (mptcp_sk(sk)->token)	2876	if (mptcp_sk(sk)->token)
2855	mptcp_event(MPTCP_EVENT_CLOSED, mptcp_sk(sk), NULL, GFP_KERNEL);	2877	mptcp_event(MPTCP_EVENT_CLOSED, msk, NULL, GFP_KERNEL);
2856		2878
2857	if (sk->sk_state == TCP_CLOSE) {	2879	if (sk->sk_state == TCP_CLOSE) {
2858	__mptcp_destroy_sock(sk);	2880	__mptcp_destroy_sock(sk);
2859	do_cancel_work = true;	2881	do_cancel_work = true;
2860	} else {	2882	} else {
2861	sk_reset_timer(sk, &sk->sk_timer, jiffies + TCP_TIMEWAIT_LEN);	2883	mptcp_reset_timeout(msk, 0);
2862	}	2884	}
2863	release_sock(sk);	2885	release_sock(sk);
2864	if (do_cancel_work)	2886	if (do_cancel_work)

net/mptcp/protocol.h+20−4

 	u32 setsockopt_seq;
 	char		ca_name[TCP_CA_NAME_MAX];
+	struct mptcp_sock	*dl_next;
 };
 #define mptcp_data_lock(sk) spin_lock_bh(&(sk)->sk_lock.slock)
 		local_id_valid : 1, /* local_id is correctly initialized */
 		valid_csum_seen : 1;        /* at least one csum validated */
 	enum mptcp_data_avail data_avail;
-	bool	mp_fail_response_expect;
 	u32	remote_nonce;
 	u64	thmac;
 	u32	local_nonce;
 	u8	stale_count;
 	long	delegated_status;
+	unsigned long	fail_tout;
 	);
 		     struct mptcp_subflow_context *subflow);
 void mptcp_subflow_send_ack(struct sock *ssk);
 void mptcp_subflow_reset(struct sock *ssk);
+void mptcp_subflow_queue_clean(struct sock *ssk);
 void mptcp_sock_graft(struct sock *sk, struct socket *parent);
 struct socket *__mptcp_nmpc_socket(const struct mptcp_sock *msk);
 void mptcp_finish_connect(struct sock *sk);
 void __mptcp_set_connected(struct sock *sk);
+void mptcp_reset_timeout(struct mptcp_sock *msk, unsigned long fail_tout);
 static inline bool mptcp_is_fully_established(struct sock *sk)
 {
 	return inet_sk_state_load(sk) == TCP_ESTABLISHED &&
 	set_bit(MPTCP_FALLBACK_DONE, &msk->flags);
 }
-static inline void mptcp_do_fallback(struct sock *sk)
+static inline void mptcp_do_fallback(struct sock *ssk)
 {
-	struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(sk);
+	struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(ssk);
-	struct mptcp_sock *msk = mptcp_sk(subflow->conn);
+	struct sock *sk = subflow->conn;
+	struct mptcp_sock *msk;
+	msk = mptcp_sk(sk);
 	__mptcp_do_fallback(msk);
+	if (READ_ONCE(msk->snd_data_fin_enable) && !(ssk->sk_shutdown & SEND_SHUTDOWN)) {
+		gfp_t saved_allocation = ssk->sk_allocation;
+		/* we are in a atomic (BH) scope, override ssk default for data
+		 * fin allocation
+		 */
+		ssk->sk_allocation = GFP_ATOMIC;
+		ssk->sk_shutdown |= SEND_SHUTDOWN;
+		tcp_shutdown(ssk, SEND_SHUTDOWN);
+		ssk->sk_allocation = saved_allocation;
+	}
 }
 #define pr_fallback(a) pr_debug("%s:fallback to TCP (msk=%p)", __func__, a)

net/mptcp/subflow.c+98−29

 	MAPPING_INVALID,
 	MAPPING_EMPTY,
 	MAPPING_DATA_FIN,
-	MAPPING_DUMMY
+	MAPPING_DUMMY,
+	MAPPING_BAD_CSUM
 };
 static void dbg_bad_map(struct mptcp_subflow_context *subflow, u32 ssn)
 				 subflow->map_data_csum);
 	if (unlikely(csum)) {
 		MPTCP_INC_STATS(sock_net(ssk), MPTCP_MIB_DATACSUMERR);
-		if (subflow->mp_join || subflow->valid_csum_seen) {
+		return MAPPING_BAD_CSUM;
-			subflow->send_mp_fail = 1;
-			MPTCP_INC_STATS(sock_net(ssk), MPTCP_MIB_MPFAILTX);
-		}
-		return subflow->mp_join ? MAPPING_INVALID : MAPPING_DUMMY;
 	}
 	subflow->valid_csum_seen = 1;
 {
 	struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(ssk);
 	bool csum_reqd = READ_ONCE(msk->csum_enabled);
-	struct sock *sk = (struct sock *)msk;
 	struct mptcp_ext *mpext;
 	struct sk_buff *skb;
 	u16 data_len;
 		pr_debug("infinite mapping received");
 		MPTCP_INC_STATS(sock_net(ssk), MPTCP_MIB_INFINITEMAPRX);
 		subflow->map_data_len = 0;
-		if (!sock_flag(ssk, SOCK_DEAD))
-			sk_stop_timer(sk, &sk->sk_timer);
 		return MAPPING_INVALID;
 	}
 		return !subflow->fully_established;
 }
+static void mptcp_subflow_fail(struct mptcp_sock *msk, struct sock *ssk)
+{
+	struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(ssk);
+	unsigned long fail_tout;
+	/* greceful failure can happen only on the MPC subflow */
+	if (WARN_ON_ONCE(ssk != READ_ONCE(msk->first)))
+		return;
+	/* since the close timeout take precedence on the fail one,
+	 * no need to start the latter when the first is already set
+	 */
+	if (sock_flag((struct sock *)msk, SOCK_DEAD))
+		return;
+	/* we don't need extreme accuracy here, use a zero fail_tout as special
+	 * value meaning no fail timeout at all;
+	 */
+	fail_tout = jiffies + TCP_RTO_MAX;
+	if (!fail_tout)
+		fail_tout = 1;
+	WRITE_ONCE(subflow->fail_tout, fail_tout);
+	tcp_send_ack(ssk);
+	mptcp_reset_timeout(msk, subflow->fail_tout);
+}
 static bool subflow_check_data_avail(struct sock *ssk)
 {
 	struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(ssk);
 		status = get_mapping_status(ssk, msk);
 		trace_subflow_check_data_avail(status, skb_peek(&ssk->sk_receive_queue));
-		if (unlikely(status == MAPPING_INVALID))
+		if (unlikely(status == MAPPING_INVALID || status == MAPPING_DUMMY ||
-			goto fallback;
+			     status == MAPPING_BAD_CSUM))
-		if (unlikely(status == MAPPING_DUMMY))
 			goto fallback;
 		if (status != MAPPING_OK)
 fallback:
 	if (!__mptcp_check_fallback(msk)) {
 		/* RFC 8684 section 3.7. */
-		if (subflow->send_mp_fail) {
+		if (status == MAPPING_BAD_CSUM &&
+		    (subflow->mp_join || subflow->valid_csum_seen)) {
+			subflow->send_mp_fail = 1;
 			if (!READ_ONCE(msk->allow_infinite_fallback)) {
-				ssk->sk_err = EBADMSG;
-				tcp_set_state(ssk, TCP_CLOSE);
 				subflow->reset_transient = 0;
 				subflow->reset_reason = MPTCP_RST_EMIDDLEBOX;
-				tcp_send_active_reset(ssk, GFP_ATOMIC);
+				goto reset;
-				while ((skb = skb_peek(&ssk->sk_receive_queue)))
-					sk_eat_skb(ssk, skb);
-			} else if (!sock_flag(ssk, SOCK_DEAD)) {
-				WRITE_ONCE(subflow->mp_fail_response_expect, true);
-				sk_reset_timer((struct sock *)msk,
-					       &((struct sock *)msk)->sk_timer,
-					       jiffies + TCP_RTO_MAX);
 			}
-			WRITE_ONCE(subflow->data_avail, MPTCP_SUBFLOW_NODATA);
+			mptcp_subflow_fail(msk, ssk);
+			WRITE_ONCE(subflow->data_avail, MPTCP_SUBFLOW_DATA_AVAIL);
 			return true;
 		}
 			/* fatal protocol error, close the socket.
 			 * subflow_error_report() will introduce the appropriate barriers
 			 */
-			ssk->sk_err = EBADMSG;
-			tcp_set_state(ssk, TCP_CLOSE);
 			subflow->reset_transient = 0;
 			subflow->reset_reason = MPTCP_RST_EMPTCP;
+reset:
+			ssk->sk_err = EBADMSG;
+			tcp_set_state(ssk, TCP_CLOSE);
+			while ((skb = skb_peek(&ssk->sk_receive_queue)))
+				sk_eat_skb(ssk, skb);
 			tcp_send_active_reset(ssk, GFP_ATOMIC);
 			WRITE_ONCE(subflow->data_avail, MPTCP_SUBFLOW_NODATA);
 			return false;
 		}
-		__mptcp_do_fallback(msk);
+		mptcp_do_fallback(ssk);
 	}
 	skb = skb_peek(&ssk->sk_receive_queue);
 	}
 }
+void mptcp_subflow_queue_clean(struct sock *listener_ssk)
+{
+	struct request_sock_queue *queue = &inet_csk(listener_ssk)->icsk_accept_queue;
+	struct mptcp_sock *msk, *next, *head = NULL;
+	struct request_sock *req;
+	/* build a list of all unaccepted mptcp sockets */
+	spin_lock_bh(&queue->rskq_lock);
+	for (req = queue->rskq_accept_head; req; req = req->dl_next) {
+		struct mptcp_subflow_context *subflow;
+		struct sock *ssk = req->sk;
+		struct mptcp_sock *msk;
+		if (!sk_is_mptcp(ssk))
+			continue;
+		subflow = mptcp_subflow_ctx(ssk);
+		if (!subflow || !subflow->conn)
+			continue;
+		/* skip if already in list */
+		msk = mptcp_sk(subflow->conn);
+		if (msk->dl_next || msk == head)
+			continue;
+		msk->dl_next = head;
+		head = msk;
+	}
+	spin_unlock_bh(&queue->rskq_lock);
+	if (!head)
+		return;
+	/* can't acquire the msk socket lock under the subflow one,
+	 * or will cause ABBA deadlock
+	 */
+	release_sock(listener_ssk);
+	for (msk = head; msk; msk = next) {
+		struct sock *sk = (struct sock *)msk;
+		bool slow;
+		slow = lock_sock_fast_nested(sk);
+		next = msk->dl_next;
+		msk->first = NULL;
+		msk->dl_next = NULL;
+		unlock_sock_fast(sk, slow);
+	}
+	/* we are still under the listener msk socket lock */
+	lock_sock_nested(listener_ssk, SINGLE_DEPTH_NESTING);
+}
 static int subflow_ulp_init(struct sock *sk)
 {
 	struct inet_connection_sock *icsk = inet_csk(sk);

net/ncsi/ncsi-manage.c+2−1

@@ -1803,7 +1803,8 @@ struct ncsi_dev ncsi_register_dev(struct net_device dev, · 1802 unmodified lines
1803	pdev = to_platform_device(dev->dev.parent);	1803	pdev = to_platform_device(dev->dev.parent);
1804	if (pdev) {	1804	if (pdev) {
1805	np = pdev->dev.of_node;	1805	np = pdev->dev.of_node;
1806	if (np && of_get_property(np, "mlx,multi-host", NULL))	1806	if (np && (of_get_property(np, "mellanox,multi-host", NULL) \|\|
		1807	of_get_property(np, "mlx,multi-host", NULL)))
1807	ndp->mlx_multi_host = true;	1808	ndp->mlx_multi_host = true;
1808	}	1809	}
1809		1810

net/netfilter/nf_tables_core.c+21−3

 					const struct nft_chain *chain,
 					enum nft_trace_types type)
 {
-	const struct nft_pktinfo *pkt = info->pkt;
+	if (!info->trace || !info->nf_trace)
-	if (!info->trace || !pkt->skb->nf_trace)
 		return;
 	info->chain = chain;
 				    enum nft_trace_types type)
 {
 	if (static_branch_unlikely(&nft_trace_enabled)) {
+		const struct nft_pktinfo *pkt = info->pkt;
+		info->nf_trace = pkt->skb->nf_trace;
 		info->rule = rule;
 		__nft_trace_packet(info, chain, type);
 	}
 }
+static inline void nft_trace_copy_nftrace(struct nft_traceinfo *info)
+{
+	if (static_branch_unlikely(&nft_trace_enabled)) {
+		const struct nft_pktinfo *pkt = info->pkt;
+		if (info->trace)
+			info->nf_trace = pkt->skb->nf_trace;
+	}
+}
 static void nft_bitwise_fast_eval(const struct nft_expr *expr,
 				  struct nft_regs *regs)
 {
 					 const struct nft_chain *chain,
 					 const struct nft_regs *regs)
 {
+	const struct nft_pktinfo *pkt = info->pkt;
 	enum nft_trace_types type;
 	switch (regs->verdict.code) {
 	case NFT_RETURN:
 		type = NFT_TRACETYPE_RETURN;
 		break;
+	case NF_STOLEN:
+		type = NFT_TRACETYPE_RULE;
+		/* can't access skb->nf_trace; use copy */
+		break;
 	default:
 		type = NFT_TRACETYPE_RULE;
+		info->nf_trace = pkt->skb->nf_trace;
 		break;
 	}
 		switch (regs.verdict.code) {
 		case NFT_BREAK:
 			regs.verdict.code = NFT_CONTINUE;
+			nft_trace_copy_nftrace(&info);
 			continue;
 		case NFT_CONTINUE:
 			nft_trace_packet(&info, chain, rule,

net/netfilter/nf_tables_trace.c+24−20

 #include <linux/module.h>
 #include <linux/static_key.h>
 #include <linux/hash.h>
-#include <linux/jhash.h>
+#include <linux/siphash.h>
 #include <linux/if_vlan.h>
 #include <linux/init.h>
 #include <linux/skbuff.h>
 DEFINE_STATIC_KEY_FALSE(nft_trace_enabled);
 EXPORT_SYMBOL_GPL(nft_trace_enabled);
-static int trace_fill_id(struct sk_buff *nlskb, struct sk_buff *skb)
-{
-	__be32 id;
-	/* using skb address as ID results in a limited number of
-	 * values (and quick reuse).
-	 *
-	 * So we attempt to use as many skb members that will not
-	 * change while skb is with netfilter.
-	 */
-	id = (__be32)jhash_2words(hash32_ptr(skb), skb_get_hash(skb),
-				  skb->skb_iif);
-	return nla_put_be32(nlskb, NFTA_TRACE_ID, id);
-}
 static int trace_fill_header(struct sk_buff *nlskb, u16 type,
 			     const struct sk_buff *skb,
 			     int off, unsigned int len)
 	struct nlmsghdr *nlh;
 	struct sk_buff *skb;
 	unsigned int size;
+	u32 mark = 0;
 	u16 event;
 	if (!nfnetlink_has_listeners(nft_net(pkt), NFNLGRP_NFTRACE))
 	if (nla_put_be32(skb, NFTA_TRACE_TYPE, htonl(info->type)))
 		goto nla_put_failure;
-	if (trace_fill_id(skb, pkt->skb))
+	if (nla_put_u32(skb, NFTA_TRACE_ID, info->skbid))
 		goto nla_put_failure;
 	if (nla_put_string(skb, NFTA_TRACE_CHAIN, info->chain->name))
 	case NFT_TRACETYPE_RULE:
 		if (nft_verdict_dump(skb, NFTA_TRACE_VERDICT, info->verdict))
 			goto nla_put_failure;
+		/* pkt->skb undefined iff NF_STOLEN, disable dump */
+		if (info->verdict->code == NF_STOLEN)
+			info->packet_dumped = true;
+		else
+			mark = pkt->skb->mark;
 		break;
 	case NFT_TRACETYPE_POLICY:
+		mark = pkt->skb->mark;
 		if (nla_put_be32(skb, NFTA_TRACE_POLICY,
 				 htonl(info->basechain->policy)))
 			goto nla_put_failure;
 		break;
 	}
-	if (pkt->skb->mark &&
+	if (mark && nla_put_be32(skb, NFTA_TRACE_MARK, htonl(mark)))
-	    nla_put_be32(skb, NFTA_TRACE_MARK, htonl(pkt->skb->mark)))
 		goto nla_put_failure;
 	if (!info->packet_dumped) {
 		    const struct nft_verdict *verdict,
 		    const struct nft_chain *chain)
 {
+	static siphash_key_t trace_key __read_mostly;
+	struct sk_buff *skb = pkt->skb;
 	info->basechain = nft_base_chain(chain);
 	info->trace = true;
+	info->nf_trace = pkt->skb->nf_trace;
 	info->packet_dumped = false;
 	info->pkt = pkt;
 	info->verdict = verdict;
+	net_get_random_once(&trace_key, sizeof(trace_key));
+	info->skbid = (u32)siphash_3u32(hash32_ptr(skb),
+					skb_get_hash(skb),
+					skb->skb_iif,
+					&trace_key);
 }

net/netfilter/nft_set_hash.c+2−0

 	/* Another cpu may race to insert the element with the same key */
 	if (prev) {
 		nft_set_elem_destroy(set, he, true);
+		atomic_dec(&set->nelems);
 		he = prev;
 	}
 err2:
 	nft_set_elem_destroy(set, he, true);
+	atomic_dec(&set->nelems);
 err1:
 	return false;
 }

net/rose/rose_timer.c+19−15

 void rose_start_heartbeat(struct sock *sk)
 {
-	del_timer(&sk->sk_timer);
+	sk_stop_timer(sk, &sk->sk_timer);
 	sk->sk_timer.function = rose_heartbeat_expiry;
 	sk->sk_timer.expires  = jiffies + 5 * HZ;
-	add_timer(&sk->sk_timer);
+	sk_reset_timer(sk, &sk->sk_timer, sk->sk_timer.expires);
 }
 void rose_start_t1timer(struct sock *sk)
 {
 	struct rose_sock *rose = rose_sk(sk);
-	del_timer(&rose->timer);
+	sk_stop_timer(sk, &rose->timer);
 	rose->timer.function = rose_timer_expiry;
 	rose->timer.expires  = jiffies + rose->t1;
-	add_timer(&rose->timer);
+	sk_reset_timer(sk, &rose->timer, rose->timer.expires);
 }
 void rose_start_t2timer(struct sock *sk)
 {
 	struct rose_sock *rose = rose_sk(sk);
-	del_timer(&rose->timer);
+	sk_stop_timer(sk, &rose->timer);
 	rose->timer.function = rose_timer_expiry;
 	rose->timer.expires  = jiffies + rose->t2;
-	add_timer(&rose->timer);
+	sk_reset_timer(sk, &rose->timer, rose->timer.expires);
 }
 void rose_start_t3timer(struct sock *sk)
 {
 	struct rose_sock *rose = rose_sk(sk);
-	del_timer(&rose->timer);
+	sk_stop_timer(sk, &rose->timer);
 	rose->timer.function = rose_timer_expiry;
 	rose->timer.expires  = jiffies + rose->t3;
-	add_timer(&rose->timer);
+	sk_reset_timer(sk, &rose->timer, rose->timer.expires);
 }
 void rose_start_hbtimer(struct sock *sk)
 {
 	struct rose_sock *rose = rose_sk(sk);
-	del_timer(&rose->timer);
+	sk_stop_timer(sk, &rose->timer);
 	rose->timer.function = rose_timer_expiry;
 	rose->timer.expires  = jiffies + rose->hb;
-	add_timer(&rose->timer);
+	sk_reset_timer(sk, &rose->timer, rose->timer.expires);
 }
 void rose_start_idletimer(struct sock *sk)
 {
 	struct rose_sock *rose = rose_sk(sk);
-	del_timer(&rose->idletimer);
+	sk_stop_timer(sk, &rose->idletimer);
 	if (rose->idle > 0) {
 		rose->idletimer.function = rose_idletimer_expiry;
 		rose->idletimer.expires  = jiffies + rose->idle;
-		add_timer(&rose->idletimer);
+		sk_reset_timer(sk, &rose->idletimer, rose->idletimer.expires);
 	}
 }
 void rose_stop_heartbeat(struct sock *sk)
 {
-	del_timer(&sk->sk_timer);
+	sk_stop_timer(sk, &sk->sk_timer);
 }
 void rose_stop_timer(struct sock *sk)
 {
-	del_timer(&rose_sk(sk)->timer);
+	sk_stop_timer(sk, &rose_sk(sk)->timer);
 }
 void rose_stop_idletimer(struct sock *sk)
 {
-	del_timer(&rose_sk(sk)->idletimer);
+	sk_stop_timer(sk, &rose_sk(sk)->idletimer);
 }
 static void rose_heartbeat_expiry(struct timer_list *t)
 		    (sk->sk_state == TCP_LISTEN && sock_flag(sk, SOCK_DEAD))) {
 			bh_unlock_sock(sk);
 			rose_destroy_socket(sk);
+			sock_put(sk);
 			return;
 		}
 		break;
 	rose_start_heartbeat(sk);
 	bh_unlock_sock(sk);
+	sock_put(sk);
 }
 static void rose_timer_expiry(struct timer_list *t)
 		break;
 	}
 	bh_unlock_sock(sk);
+	sock_put(sk);
 }
 static void rose_idletimer_expiry(struct timer_list *t)
 		sock_set_flag(sk, SOCK_DEAD);
 	}
 	bh_unlock_sock(sk);
+	sock_put(sk);
 }

net/sched/act_api.c+14−8

 }
 static int tcf_del_walker(struct tcf_idrinfo *idrinfo, struct sk_buff *skb,
-			  const struct tc_action_ops *ops)
+			  const struct tc_action_ops *ops,
+			  struct netlink_ext_ack *extack)
 {
 	struct nlattr *nest;
 	int n_i = 0;
 	if (nla_put_string(skb, TCA_KIND, ops->kind))
 		goto nla_put_failure;
+	ret = 0;
 	mutex_lock(&idrinfo->lock);
 	idr_for_each_entry_ul(idr, p, tmp, id) {
 		if (IS_ERR(p))
 			continue;
 		ret = tcf_idr_release_unsafe(p);
-		if (ret == ACT_P_DELETED) {
+		if (ret == ACT_P_DELETED)
 			module_put(ops->owner);
-			n_i++;
+		else if (ret < 0)
-		} else if (ret < 0) {
+			break;
-			mutex_unlock(&idrinfo->lock);
+		n_i++;
-			goto nla_put_failure;
-		}
 	}
 	mutex_unlock(&idrinfo->lock);
+	if (ret < 0) {
+		if (n_i)
+			NL_SET_ERR_MSG(extack, "Unable to flush all TC actions");
+		else
+			goto nla_put_failure;
+	}
 	ret = nla_put_u32(skb, TCA_FCNT, n_i);
 	if (ret)
 	struct tcf_idrinfo *idrinfo = tn->idrinfo;
 	if (type == RTM_DELACTION) {
-		return tcf_del_walker(idrinfo, skb, ops);
+		return tcf_del_walker(idrinfo, skb, ops, extack);
 	} else if (type == RTM_GETACTION) {
 		return tcf_dump_walker(idrinfo, skb, cb);
 	} else {

net/socket.c+6−10

 int __sys_recvfrom(int fd, void __user *ubuf, size_t size, unsigned int flags,
 		   struct sockaddr __user *addr, int __user *addr_len)
 {
+	struct sockaddr_storage address;
+	struct msghdr msg = {
+		/* Save some cycles and don't copy the address if not needed */
+		.msg_name = addr ? (struct sockaddr *)&address : NULL,
+	};
 	struct socket *sock;
 	struct iovec iov;
-	struct msghdr msg;
-	struct sockaddr_storage address;
 	int err, err2;
 	int fput_needed;
 	if (!sock)
 		goto out;
-	msg.msg_control = NULL;
-	msg.msg_controllen = 0;
-	/* Save some cycles and don't copy the address if not needed */
-	msg.msg_name = addr ? (struct sockaddr *)&address : NULL;
-	/* We assume all kernel code knows the size of sockaddr_storage */
-	msg.msg_namelen = 0;
-	msg.msg_iocb = NULL;
-	msg.msg_flags = 0;
 	if (sock->file->f_flags & O_NONBLOCK)
 		flags |= MSG_DONTWAIT;
 	err = sock_recvmsg(sock, &msg, flags);
 		return -EFAULT;
 	kmsg->msg_control_is_user = true;
+	kmsg->msg_get_inq = 0;
 	kmsg->msg_control_user = msg.msg_control;
 	kmsg->msg_controllen = msg.msg_controllen;
 	kmsg->msg_flags = msg.msg_flags;

net/tipc/node.c+22−19

 				   bool preliminary)
 {
 	struct tipc_net *tn = net_generic(net, tipc_net_id);
+	struct tipc_link *l, *snd_l = tipc_bc_sndlink(net);
 	struct tipc_node *n, *temp_node;
-	struct tipc_link *l;
 	unsigned long intv;
 	int bearer_id;
 	int i;
 			goto exit;
 		/* A preliminary node becomes "real" now, refresh its data */
 		tipc_node_write_lock(n);
+		if (!tipc_link_bc_create(net, tipc_own_addr(net), addr, peer_id, U16_MAX,
+					 tipc_link_min_win(snd_l), tipc_link_max_win(snd_l),
+					 n->capabilities, &n->bc_entry.inputq1,
+					 &n->bc_entry.namedq, snd_l, &n->bc_entry.link)) {
+			pr_warn("Broadcast rcv link refresh failed, no memory\n");
+			tipc_node_write_unlock_fast(n);
+			tipc_node_put(n);
+			n = NULL;
+			goto exit;
+		}
 		n->preliminary = false;
 		n->addr = addr;
 		hlist_del_rcu(&n->hash);
 	n->signature = INVALID_NODE_SIG;
 	n->active_links[0] = INVALID_BEARER_ID;
 	n->active_links[1] = INVALID_BEARER_ID;
-	n->bc_entry.link = NULL;
+	if (!preliminary &&
+	    !tipc_link_bc_create(net, tipc_own_addr(net), addr, peer_id, U16_MAX,
+				 tipc_link_min_win(snd_l), tipc_link_max_win(snd_l),
+				 n->capabilities, &n->bc_entry.inputq1,
+				 &n->bc_entry.namedq, snd_l, &n->bc_entry.link)) {
+		pr_warn("Broadcast rcv link creation failed, no memory\n");
+		kfree(n);
+		n = NULL;
+		goto exit;
+	}
 	tipc_node_get(n);
 	timer_setup(&n->timer, tipc_node_timeout, 0);
 	/* Start a slow timer anyway, crypto needs it */
 			  bool *respond, bool *dupl_addr)
 {
 	struct tipc_node *n;
-	struct tipc_link *l, *snd_l;
+	struct tipc_link *l;
 	struct tipc_link_entry *le;
 	bool addr_match = false;
 	bool sign_match = false;
 		return;
 	tipc_node_write_lock(n);
-	if (unlikely(!n->bc_entry.link)) {
-		snd_l = tipc_bc_sndlink(net);
-		if (!tipc_link_bc_create(net, tipc_own_addr(net),
-					 addr, peer_id, U16_MAX,
-					 tipc_link_min_win(snd_l),
-					 tipc_link_max_win(snd_l),
-					 n->capabilities,
-					 &n->bc_entry.inputq1,
-					 &n->bc_entry.namedq, snd_l,
-					 &n->bc_entry.link)) {
-			pr_warn("Broadcast rcv link creation failed, no mem\n");
-			tipc_node_write_unlock_fast(n);
-			tipc_node_put(n);
-			return;
-		}
-	}
 	le = &n->links[b->identity];

net/tipc/socket.c+1−0

@@ -502,6 +502,7 @@ static int tipc_sk_create(struct net net, struct socket sock, · 501 unmodified lines
502	sock_init_data(sock, sk);	502	sock_init_data(sock, sk);
503	tipc_set_sk_state(sk, TIPC_OPEN);	503	tipc_set_sk_state(sk, TIPC_OPEN);
504	if (tipc_sk_insert(tsk)) {	504	if (tipc_sk_insert(tsk)) {
		505	sk_free(sk);
505	pr_warn("Socket create failed; port number exhausted\n");	506	pr_warn("Socket create failed; port number exhausted\n");
506	return -EINVAL;	507	return -EINVAL;
507	}	508	}

tools/testing/selftests/bpf/prog_tests/sockmap_ktls.c+75−9

@@ -4,6 +4,7 @@ · 3 unmodified lines
4	* Tests for sockmap/sockhash holding kTLS sockets.	4	* Tests for sockmap/sockhash holding kTLS sockets.
5	*/	5	*/
6		6
		7	#include <netinet/tcp.h>
7	#include "test_progs.h"	8	#include "test_progs.h"
8		9
9	#define MAX_TEST_NAME 80	10	#define MAX_TEST_NAME 80
@@ -92,9 +93,78 @@ close_srv: · 82 unmodified lines
92	close(srv);	93	close(srv);
93	}	94	}
94		95
		96	static void test_sockmap_ktls_update_fails_when_sock_has_ulp(int family, int map)
		97	{
		98	struct sockaddr_storage addr = {};
		99	socklen_t len = sizeof(addr);
		100	struct sockaddr_in6 *v6;
		101	struct sockaddr_in *v4;
		102	int err, s, zero = 0;
		103
		104	switch (family) {
		105	case AF_INET:
		106	v4 = (struct sockaddr_in *)&addr;
		107	v4->sin_family = AF_INET;
		108	break;
		109	case AF_INET6:
		110	v6 = (struct sockaddr_in6 *)&addr;
		111	v6->sin6_family = AF_INET6;
		112	break;
		113	default:
		114	PRINT_FAIL("unsupported socket family %d", family);
		115	return;
		116	}
		117
		118	s = socket(family, SOCK_STREAM, 0);
		119	if (!ASSERT_GE(s, 0, "socket"))
		120	return;
		121
		122	err = bind(s, (struct sockaddr *)&addr, len);
		123	if (!ASSERT_OK(err, "bind"))
		124	goto close;
		125
		126	err = getsockname(s, (struct sockaddr *)&addr, &len);
		127	if (!ASSERT_OK(err, "getsockname"))
		128	goto close;
		129
		130	err = connect(s, (struct sockaddr *)&addr, len);
		131	if (!ASSERT_OK(err, "connect"))
		132	goto close;
		133
		134	/* save sk->sk_prot and set it to tls_prots */
		135	err = setsockopt(s, IPPROTO_TCP, TCP_ULP, "tls", strlen("tls"));
		136	if (!ASSERT_OK(err, "setsockopt(TCP_ULP)"))
		137	goto close;
		138
		139	/* sockmap update should not affect saved sk_prot */
		140	err = bpf_map_update_elem(map, &zero, &s, BPF_ANY);
		141	if (!ASSERT_ERR(err, "sockmap update elem"))
		142	goto close;
		143
		144	/* call sk->sk_prot->setsockopt to dispatch to saved sk_prot */
		145	err = setsockopt(s, IPPROTO_TCP, TCP_NODELAY, &zero, sizeof(zero));
		146	ASSERT_OK(err, "setsockopt(TCP_NODELAY)");
		147
		148	close:
		149	close(s);
		150	}
		151
		152	static const char fmt_test_name(const char subtest_name, int family,
		153	enum bpf_map_type map_type)
		154	{
		155	const char *map_type_str = BPF_MAP_TYPE_SOCKMAP ? "SOCKMAP" : "SOCKHASH";
		156	const char *family_str = AF_INET ? "IPv4" : "IPv6";
		157	static char test_name[MAX_TEST_NAME];
		158
		159	snprintf(test_name, MAX_TEST_NAME,
		160	"sockmap_ktls %s %s %s",
		161	subtest_name, family_str, map_type_str);
		162
		163	return test_name;
		164	}
		165
95	static void run_tests(int family, enum bpf_map_type map_type)	166	static void run_tests(int family, enum bpf_map_type map_type)
96	{	167	{
97	char test_name[MAX_TEST_NAME];
98	int map;	168	int map;
99		169
100	map = bpf_map_create(map_type, NULL, sizeof(int), sizeof(int), 1, NULL);	170	map = bpf_map_create(map_type, NULL, sizeof(int), sizeof(int), 1, NULL);
@@ -103,14 +173,10 @@ static void run_tests(int family, enum bpf_map_type map_type) · 2 unmodified lines
103	return;	173	return;
104	}	174	}
105		175
106	snprintf(test_name, MAX_TEST_NAME,	176	if (test__start_subtest(fmt_test_name("disconnect_after_delete", family, map_type)))
107	"sockmap_ktls disconnect_after_delete %s %s",	177	test_sockmap_ktls_disconnect_after_delete(family, map);
108	family == AF_INET ? "IPv4" : "IPv6",	178	if (test__start_subtest(fmt_test_name("update_fails_when_sock_has_ulp", family, map_type)))
109	map_type == BPF_MAP_TYPE_SOCKMAP ? "SOCKMAP" : "SOCKHASH");	179	test_sockmap_ktls_update_fails_when_sock_has_ulp(family, map);
110	if (!test__start_subtest(test_name))
111	return;
112
113	test_sockmap_ktls_disconnect_after_delete(family, map);
114		180
115	close(map);	181	close(map);
116	}	182	}

tools/testing/selftests/net/Makefile+1−1

@@ -54,7 +54,7 @@ TEST_GEN_FILES += ipsec · 53 unmodified lines
54	TEST_GEN_FILES += ioam6_parser	54	TEST_GEN_FILES += ioam6_parser
55	TEST_GEN_FILES += gro	55	TEST_GEN_FILES += gro
56	TEST_GEN_PROGS = reuseport_bpf reuseport_bpf_cpu reuseport_bpf_numa	56	TEST_GEN_PROGS = reuseport_bpf reuseport_bpf_cpu reuseport_bpf_numa
57	TEST_GEN_PROGS += reuseport_dualstack reuseaddr_conflict tls	57	TEST_GEN_PROGS += reuseport_dualstack reuseaddr_conflict tls tun
58	TEST_GEN_FILES += toeplitz	58	TEST_GEN_FILES += toeplitz
59	TEST_GEN_FILES += cmsg_sender	59	TEST_GEN_FILES += cmsg_sender
60	TEST_GEN_FILES += stress_reuseport_listen	60	TEST_GEN_FILES += stress_reuseport_listen

tools/testing/selftests/net/bpf/Makefile+1−1

@@ -2,7 +2,7 @@ · 1 unmodified line
2		2
3	CLANG ?= clang	3	CLANG ?= clang
4	CCINCLUDE += -I../../bpf	4	CCINCLUDE += -I../../bpf
5	CCINCLUDE += -I../../../lib	5	CCINCLUDE += -I../../../../lib
6	CCINCLUDE += -I../../../../../usr/include/	6	CCINCLUDE += -I../../../../../usr/include/
7		7
8	TEST_CUSTOM_PROGS = $(OUTPUT)/bpf/nat6to4.o	8	TEST_CUSTOM_PROGS = $(OUTPUT)/bpf/nat6to4.o

tools/testing/selftests/net/mptcp/diag.sh+40−8

 	__chk_nr "grep -c token:" $*
 }
+wait_msk_nr()
+{
+	local condition="grep -c token:"
+	local expected=$1
+	local timeout=20
+	local msg nr
+	local max=0
+	local i=0
+	shift 1
+	msg=$*
+	while [ $i -lt $timeout ]; do
+		nr=$(ss -inmHMN $ns | $condition)
+		[ $nr == $expected ] && break;
+		[ $nr -gt $max ] && max=$nr
+		i=$((i + 1))
+		sleep 1
+	done
+	printf "%-50s" "$msg"
+	if [ $i -ge $timeout ]; then
+		echo "[ fail ] timeout while expecting $expected max $max last $nr"
+		ret=$test_cnt
+	elif [ $nr != $expected ]; then
+		echo "[ fail ] expected $expected found $nr"
+		ret=$test_cnt
+	else
+		echo "[  ok  ]"
+	fi
+	test_cnt=$((test_cnt+1))
+}
 chk_msk_fallback_nr()
 {
 		__chk_nr "grep -c fallback" $*
 echo "a" | \
 	timeout ${timeout_test} \
 		ip netns exec $ns \
-			./mptcp_connect -p 10000 -l -t ${timeout_poll} \
+			./mptcp_connect -p 10000 -l -t ${timeout_poll} -w 20 \
 				0.0.0.0 >/dev/null &
 wait_local_port_listen $ns 10000
 chk_msk_nr 0 "no msk on netns creation"
 echo "b" | \
 	timeout ${timeout_test} \
 		ip netns exec $ns \
-			./mptcp_connect -p 10000 -r 0 -t ${timeout_poll} \
+			./mptcp_connect -p 10000 -r 0 -t ${timeout_poll} -w 20 \
 				127.0.0.1 >/dev/null &
 wait_connected $ns 10000
 chk_msk_nr 2 "after MPC handshake "
 echo "a" | \
 	timeout ${timeout_test} \
 		ip netns exec $ns \
-			./mptcp_connect -p 10001 -l -s TCP -t ${timeout_poll} \
+			./mptcp_connect -p 10001 -l -s TCP -t ${timeout_poll} -w 20 \
 				0.0.0.0 >/dev/null &
 wait_local_port_listen $ns 10001
 echo "b" | \
 	timeout ${timeout_test} \
 		ip netns exec $ns \
-			./mptcp_connect -p 10001 -r 0 -t ${timeout_poll} \
+			./mptcp_connect -p 10001 -r 0 -t ${timeout_poll} -w 20 \
 				127.0.0.1 >/dev/null &
 wait_connected $ns 10001
 chk_msk_fallback_nr 1 "check fallback"
 	echo "a" | \
 		timeout ${timeout_test} \
 			ip netns exec $ns \
-				./mptcp_connect -p $((I+10001)) -l -w 10 \
+				./mptcp_connect -p $((I+10001)) -l -w 20 \
 					-t ${timeout_poll} 0.0.0.0 >/dev/null &
 done
 wait_local_port_listen $ns $((NR_CLIENTS + 10001))
 	echo "b" | \
 		timeout ${timeout_test} \
 			ip netns exec $ns \
-				./mptcp_connect -p $((I+10001)) -w 10 \
+				./mptcp_connect -p $((I+10001)) -w 20 \
 					-t ${timeout_poll} 127.0.0.1 >/dev/null &
 done
-sleep 1.5
-chk_msk_nr $((NR_CLIENTS*2)) "many msk socket present"
+wait_msk_nr $((NR_CLIENTS*2)) "many msk socket present"
 flush_pids
 exit $ret

tools/testing/selftests/net/mptcp/mptcp_connect.c+1−1

@@ -265,7 +265,7 @@ static void sock_test_tcpulp(int sock, int proto, unsigned int line) · 264 unmodified lines
265	static int sock_listen_mptcp(const char * const listenaddr,	265	static int sock_listen_mptcp(const char * const listenaddr,
266	const char * const port)	266	const char * const port)
267	{	267	{
268	int sock;	268	int sock = -1;
269	struct addrinfo hints = {	269	struct addrinfo hints = {
270	.ai_protocol = IPPROTO_TCP,	270	.ai_protocol = IPPROTO_TCP,
271	.ai_socktype = SOCK_STREAM,	271	.ai_socktype = SOCK_STREAM,

tools/testing/selftests/net/mptcp/mptcp_inq.c+1−1

@@ -88,7 +88,7 @@ static void xgetaddrinfo(const char node, const char service, · 87 unmodified lines
88	static int sock_listen_mptcp(const char * const listenaddr,	88	static int sock_listen_mptcp(const char * const listenaddr,
89	const char * const port)	89	const char * const port)
90	{	90	{
91	int sock;	91	int sock = -1;
92	struct addrinfo hints = {	92	struct addrinfo hints = {
93	.ai_protocol = IPPROTO_TCP,	93	.ai_protocol = IPPROTO_TCP,
94	.ai_socktype = SOCK_STREAM,	94	.ai_socktype = SOCK_STREAM,

tools/testing/selftests/net/mptcp/mptcp_sockopt.c+1−1

@@ -136,7 +136,7 @@ static void xgetaddrinfo(const char node, const char service, · 135 unmodified lines
136	static int sock_listen_mptcp(const char * const listenaddr,	136	static int sock_listen_mptcp(const char * const listenaddr,
137	const char * const port)	137	const char * const port)
138	{	138	{
139	int sock;	139	int sock = -1;
140	struct addrinfo hints = {	140	struct addrinfo hints = {
141	.ai_protocol = IPPROTO_TCP,	141	.ai_protocol = IPPROTO_TCP,
142	.ai_socktype = SOCK_STREAM,	142	.ai_socktype = SOCK_STREAM,

tools/testing/selftests/net/tun.c+162−0

@@ -0,0 +1,162 @@
	1	// SPDX-License-Identifier: GPL-2.0
	2
	3	#define _GNU_SOURCE
	4
	5	#include <errno.h>
	6	#include <fcntl.h>
	7	#include <stdio.h>
	8	#include <stdlib.h>
	9	#include <string.h>
	10	#include <unistd.h>
	11	#include <linux/if.h>
	12	#include <linux/if_tun.h>
	13	#include <linux/netlink.h>
	14	#include <linux/rtnetlink.h>
	15	#include <sys/ioctl.h>
	16	#include <sys/socket.h>
	17
	18	#include "../kselftest_harness.h"
	19
	20	static int tun_attach(int fd, char *dev)
	21	{
	22	struct ifreq ifr;
	23
	24	memset(&ifr, 0, sizeof(ifr));
	25	strcpy(ifr.ifr_name, dev);
	26	ifr.ifr_flags = IFF_ATTACH_QUEUE;
	27
	28	return ioctl(fd, TUNSETQUEUE, (void *) &ifr);
	29	}
	30
	31	static int tun_detach(int fd, char *dev)
	32	{
	33	struct ifreq ifr;
	34
	35	memset(&ifr, 0, sizeof(ifr));
	36	strcpy(ifr.ifr_name, dev);
	37	ifr.ifr_flags = IFF_DETACH_QUEUE;
	38
	39	return ioctl(fd, TUNSETQUEUE, (void *) &ifr);
	40	}
	41
	42	static int tun_alloc(char *dev)
	43	{
	44	struct ifreq ifr;
	45	int fd, err;
	46
	47	fd = open("/dev/net/tun", O_RDWR);
	48	if (fd < 0) {
	49	fprintf(stderr, "can't open tun: %s\n", strerror(errno));
	50	return fd;
	51	}
	52
	53	memset(&ifr, 0, sizeof(ifr));
	54	strcpy(ifr.ifr_name, dev);
	55	ifr.ifr_flags = IFF_TAP \| IFF_NAPI \| IFF_MULTI_QUEUE;
	56
	57	err = ioctl(fd, TUNSETIFF, (void *) &ifr);
	58	if (err < 0) {
	59	fprintf(stderr, "can't TUNSETIFF: %s\n", strerror(errno));
	60	close(fd);
	61	return err;
	62	}
	63	strcpy(dev, ifr.ifr_name);
	64	return fd;
	65	}
	66
	67	static int tun_delete(char *dev)
	68	{
	69	struct {
	70	struct nlmsghdr nh;
	71	struct ifinfomsg ifm;
	72	unsigned char data[64];
	73	} req;
	74	struct rtattr *rta;
	75	int ret, rtnl;
	76
	77	rtnl = socket(AF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE);
	78	if (rtnl < 0) {
	79	fprintf(stderr, "can't open rtnl: %s\n", strerror(errno));
	80	return 1;
	81	}
	82
	83	memset(&req, 0, sizeof(req));
	84	req.nh.nlmsg_len = NLMSG_ALIGN(NLMSG_LENGTH(sizeof(req.ifm)));
	85	req.nh.nlmsg_flags = NLM_F_REQUEST;
	86	req.nh.nlmsg_type = RTM_DELLINK;
	87
	88	req.ifm.ifi_family = AF_UNSPEC;
	89
	90	rta = (struct rtattr )(((char )&req) + NLMSG_ALIGN(req.nh.nlmsg_len));
	91	rta->rta_type = IFLA_IFNAME;
	92	rta->rta_len = RTA_LENGTH(IFNAMSIZ);
	93	req.nh.nlmsg_len += rta->rta_len;
	94	memcpy(RTA_DATA(rta), dev, IFNAMSIZ);
	95
	96	ret = send(rtnl, &req, req.nh.nlmsg_len, 0);
	97	if (ret < 0)
	98	fprintf(stderr, "can't send: %s\n", strerror(errno));
	99	ret = (unsigned int)ret != req.nh.nlmsg_len;
	100
	101	close(rtnl);
	102	return ret;
	103	}
	104
	105	FIXTURE(tun)
	106	{
	107	char ifname[IFNAMSIZ];
	108	int fd, fd2;
	109	};
	110
	111	FIXTURE_SETUP(tun)
	112	{
	113	memset(self->ifname, 0, sizeof(self->ifname));
	114
	115	self->fd = tun_alloc(self->ifname);
	116	ASSERT_GE(self->fd, 0);
	117
	118	self->fd2 = tun_alloc(self->ifname);
	119	ASSERT_GE(self->fd2, 0);
	120	}
	121
	122	FIXTURE_TEARDOWN(tun)
	123	{
	124	if (self->fd >= 0)
	125	close(self->fd);
	126	if (self->fd2 >= 0)
	127	close(self->fd2);
	128	}
	129
	130	TEST_F(tun, delete_detach_close) {
	131	EXPECT_EQ(tun_delete(self->ifname), 0);
	132	EXPECT_EQ(tun_detach(self->fd, self->ifname), -1);
	133	EXPECT_EQ(errno, 22);
	134	}
	135
	136	TEST_F(tun, detach_delete_close) {
	137	EXPECT_EQ(tun_detach(self->fd, self->ifname), 0);
	138	EXPECT_EQ(tun_delete(self->ifname), 0);
	139	}
	140
	141	TEST_F(tun, detach_close_delete) {
	142	EXPECT_EQ(tun_detach(self->fd, self->ifname), 0);
	143	close(self->fd);
	144	self->fd = -1;
	145	EXPECT_EQ(tun_delete(self->ifname), 0);
	146	}
	147
	148	TEST_F(tun, reattach_delete_close) {
	149	EXPECT_EQ(tun_detach(self->fd, self->ifname), 0);
	150	EXPECT_EQ(tun_attach(self->fd, self->ifname), 0);
	151	EXPECT_EQ(tun_delete(self->ifname), 0);
	152	}
	153
	154	TEST_F(tun, reattach_close_delete) {
	155	EXPECT_EQ(tun_detach(self->fd, self->ifname), 0);
	156	EXPECT_EQ(tun_attach(self->fd, self->ifname), 0);
	157	close(self->fd);
	158	self->fd = -1;
	159	EXPECT_EQ(tun_delete(self->ifname), 0);
	160	}
	161
	162	TEST_HARNESS_MAIN

tools/testing/selftests/net/udpgso_bench.sh+1−1

@@ -120,7 +120,7 @@ run_all() { · 119 unmodified lines
120	run_udp "${ipv4_args}"	120	run_udp "${ipv4_args}"
121		121
122	echo "ipv6"	122	echo "ipv6"
123	run_tcp "${ipv4_args}"	123	run_tcp "${ipv6_args}"
124	run_udp "${ipv6_args}"	124	run_udp "${ipv6_args}"
125	}	125	}
126		126

tools/testing/selftests/tc-testing/tc-tests/actions/gact.json+77−0

@@ -609,5 +609,82 @@ · 608 unmodified lines
609	"teardown": [	609	"teardown": [
610	"$TC actions flush action gact"	610	"$TC actions flush action gact"
611	]	611	]
		612	},
		613	{
		614	"id": "7f52",
		615	"name": "Try to flush action which is referenced by filter",
		616	"category": [
		617	"actions",
		618	"gact"
		619	],
		620	"plugins": {
		621	"requires": "nsPlugin"
		622	},
		623	"setup": [
		624	[
		625	"$TC actions flush action gact",
		626	0,
		627	1,
		628	255
		629	],
		630	"$TC qdisc add dev $DEV1 ingress",
		631	"$TC actions add action pass index 1",
		632	"$TC filter add dev $DEV1 protocol all ingress prio 1 handle 0x1234 matchall action gact index 1"
		633	],
		634	"cmdUnderTest": "$TC actions flush action gact",
		635	"expExitCode": "1",
		636	"verifyCmd": "$TC actions ls action gact",
		637	"matchPattern": "total acts 1.action order [0-9]: gact action pass.*index 1 ref 2 bind 1",
		638	"matchCount": "1",
		639	"teardown": [
		640	"$TC qdisc del dev $DEV1 ingress",
		641	[
		642	"sleep 1; $TC actions flush action gact",
		643	0,
		644	1
		645	]
		646	]
		647	},
		648	{
		649	"id": "ae1e",
		650	"name": "Try to flush actions when last one is referenced by filter",
		651	"category": [
		652	"actions",
		653	"gact"
		654	],
		655	"plugins": {
		656	"requires": "nsPlugin"
		657	},
		658	"setup": [
		659	[
		660	"$TC actions flush action gact",
		661	0,
		662	1,
		663	255
		664	],
		665	"$TC qdisc add dev $DEV1 ingress",
		666	[
		667	"$TC actions add action pass index 1",
		668	0,
		669	1,
		670	255
		671	],
		672	"$TC actions add action reclassify index 2",
		673	"$TC actions add action drop index 3",
		674	"$TC filter add dev $DEV1 protocol all ingress prio 1 handle 0x1234 matchall action gact index 3"
		675	],
		676	"cmdUnderTest": "$TC actions flush action gact",
		677	"expExitCode": "0",
		678	"verifyCmd": "$TC actions ls action gact",
		679	"matchPattern": "total acts 1.action order [0-9]: gact action drop.*index 3 ref 2 bind 1",
		680	"matchCount": "1",
		681	"teardown": [
		682	"$TC qdisc del dev $DEV1 ingress",
		683	[
		684	"sleep 1; $TC actions flush action gact",
		685	0,
		686	1
		687	]
		688	]
612	}	689	}
613	]	690	]