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

Pull networking fixes from David Miller: 1) Fix RCU warnings in ipv6 multicast router code, from Madhuparna Bhowmik. 2) Nexthop attributes aren't being checked properly because of mis-initialized iterator, from David Ahern. 3) Revert iop_idents_reserve() change as it caused performance regressions and was just working around what is really a UBSAN bug in the compiler. From Yuqi Jin. 4) Read MAC address properly from ROM in bmac driver (double iteration proceeds past end of address array), from Jeremy Kerr. 5) Add Microsoft Surface device IDs to r8152, from Marc Payne. 6) Prevent reference to freed SKB in __netif_receive_skb_core(), from Boris Sukholitko. 7) Fix ACK discard behavior in rxrpc, from David Howells. 8) Preserve flow hash across packet scrubbing in wireguard, from Jason A. Donenfeld. 9) Cap option length properly for SO_BINDTODEVICE in AX25, from Eric Dumazet. 10) Fix encryption error checking in kTLS code, from Vadim Fedorenko. 11) Missing BPF prog ref release in flow dissector, from Jakub Sitnicki. 12) dst_cache must be used with BH disabled in tipc, from Eric Dumazet. 13) Fix use after free in mlxsw driver, from Jiri Pirko. 14) Order kTLS key destruction properly in mlx5 driver, from Tariq Toukan. 15) Check devm_platform_ioremap_resource() return value properly in several drivers, from Tiezhu Yang. * git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net: (71 commits) net: smsc911x: Fix runtime PM imbalance on error net/mlx4_core: fix a memory leak bug. net: ethernet: ti: cpsw: fix ASSERT_RTNL() warning during suspend net: phy: mscc: fix initialization of the MACsec protocol mode net: stmmac: don't attach interface until resume finishes net: Fix return value about devm_platform_ioremap_resource() net/mlx5: Fix error flow in case of function_setup failure net/mlx5e: CT: Correctly get flow rule net/mlx5e: Update netdev txq on completions during closure net/mlx5: Annotate mutex destroy for root ns net/mlx5: Don't maintain a case of del_sw_func being null net/mlx5: Fix cleaning unmanaged flow tables net/mlx5: Fix memory leak in mlx5_events_init net/mlx5e: Fix inner tirs handling net/mlx5e: kTLS, Destroy key object after destroying the TIS net/mlx5e: Fix allowed tc redirect merged eswitch offload cases net/mlx5: Avoid processing commands before cmdif is ready net/mlx5: Fix a race when moving command interface to events mode net/mlx5: Add command entry handling completion rxrpc: Fix a memory leak in rxkad_verify_response() ...

Linus Torvalds committed 6 years ago

Commit caffb992 parents 0cfc8a8 539d39a112 files · +940 −454Browse files

Unified · Split

112 files

Documentation/devicetree/bindings/net/dsa/b53.txt +3 −0
drivers/net/can/ifi_canfd/ifi_canfd.c +4 −1
drivers/net/can/sun4i_can.c +1 −1
drivers/net/dsa/b53/b53_srab.c +1 −1
drivers/net/dsa/mt7530.c +2 −7
drivers/net/dsa/mt7530.h +1 −0
drivers/net/dsa/ocelot/felix.c +11 −12
drivers/net/dsa/ocelot/felix.h +3 −3
drivers/net/dsa/ocelot/felix_vsc9959.c +10 −12
drivers/net/ethernet/apple/bmac.c +1 −1
drivers/net/ethernet/freescale/ucc_geth.c +7 −6
drivers/net/ethernet/marvell/mvpp2/mvpp2_cls.c +1 −1
drivers/net/ethernet/marvell/pxa168_eth.c +1 −1
drivers/net/ethernet/mellanox/mlx4/fw.c +1 −1
drivers/net/ethernet/mellanox/mlx5/core/cmd.c +55 −4
drivers/net/ethernet/mellanox/mlx5/core/en.h +1 −1
drivers/net/ethernet/mellanox/mlx5/core/en/tc_ct.c +3 −2
drivers/net/ethernet/mellanox/mlx5/core/en/tc_ct.h +3 −1
drivers/net/ethernet/mellanox/mlx5/core/en_accel/ktls.c +1 −1
drivers/net/ethernet/mellanox/mlx5/core/en_main.c +7 −5
drivers/net/ethernet/mellanox/mlx5/core/en_rep.c +4 −8
drivers/net/ethernet/mellanox/mlx5/core/en_rep.h +6 −1
drivers/net/ethernet/mellanox/mlx5/core/en_tc.c +33 −7
drivers/net/ethernet/mellanox/mlx5/core/en_tx.c +6 −3
drivers/net/ethernet/mellanox/mlx5/core/eq.c +3 −0
drivers/net/ethernet/mellanox/mlx5/core/events.c +3 −1
drivers/net/ethernet/mellanox/mlx5/core/fs_core.c +19 −11
drivers/net/ethernet/mellanox/mlx5/core/ipoib/ipoib.c +2 −2
drivers/net/ethernet/mellanox/mlx5/core/main.c +6 −1
drivers/net/ethernet/mellanox/mlxsw/spectrum.c +12 −2
drivers/net/ethernet/mellanox/mlxsw/switchx2.c +8 −0
drivers/net/ethernet/mscc/ocelot.c +1 −1
drivers/net/ethernet/realtek/r8169_main.c +15 −2
drivers/net/ethernet/sgi/ioc3-eth.c +4 −4
drivers/net/ethernet/smsc/smsc911x.c +5 −4
drivers/net/ethernet/stmicro/stmmac/dwmac-ipq806x.c +13 −0
drivers/net/ethernet/stmicro/stmmac/stmmac_main.c +2 −2
drivers/net/ethernet/sun/cassini.c +1 −2
drivers/net/ethernet/ti/am65-cpsw-nuss.c +2 −1
drivers/net/ethernet/ti/cpsw.c +4 −0
drivers/net/ethernet/ti/cpsw_ale.c +1 −1
drivers/net/ethernet/ti/cpsw_priv.c +2 −2
drivers/net/ethernet/ti/netcp_ethss.c +2 −2
drivers/net/ipa/gsi.c +1 −0
drivers/net/netdevsim/dev.c +1 −2
drivers/net/phy/mscc/mscc.h +2 −0
drivers/net/phy/mscc/mscc_mac.h +3 −3
drivers/net/phy/mscc/mscc_macsec.c +10 −6
drivers/net/phy/mscc/mscc_macsec.h +2 −1
drivers/net/phy/mscc/mscc_main.c +4 −0
drivers/net/phy/phy_device.c +2 −2
drivers/net/usb/cdc_ether.c +9 −2
drivers/net/usb/r8152.c +1 −0
drivers/net/wireguard/messages.h +1 −1
drivers/net/wireguard/noise.c +9 −13
drivers/net/wireguard/noise.h +6 −8
drivers/net/wireguard/queueing.h +9 −1
drivers/net/wireguard/receive.c +22 −22
drivers/net/wireguard/selftest/counter.c +12 −5
drivers/net/wireguard/send.c +11 −8
drivers/net/wireless/intel/iwlwifi/pcie/drv.c +4 −0
fs/afs/fs_probe.c +5 −13
fs/afs/vl_probe.c +5 −13
include/linux/mlx5/driver.h +16 −0
include/net/act_api.h +2 −1
include/net/af_rxrpc.h +1 −1
include/net/ip_fib.h +0 −1
include/trace/events/rxrpc.h +42 −10
kernel/bpf/syscall.c +14 −3
net/ax25/af_ax25.c +4 −2
net/core/dev.c +15 −5
net/core/flow_dissector.c +21 −5
net/dsa/tag_mtk.c +15 −0
net/ethtool/netlink.c +2 −2
net/ethtool/strset.c +0 −1
net/ipv4/fib_frontend.c +1 −2
net/ipv4/inet_connection_sock.c +24 −19
net/ipv4/ipip.c +1 −1
net/ipv4/ipmr.c +1 −1
net/ipv4/nexthop.c +2 −1
net/ipv4/route.c +6 −8
net/ipv6/ip6_fib.c +1 −1
net/ipv6/ip6mr.c +3 −2
net/mptcp/crypto.c +9 −15
net/mptcp/options.c +5 −4
net/mptcp/protocol.h +0 −1
net/mptcp/subflow.c +10 −5
net/qrtr/qrtr.c +1 −1
net/rxrpc/Makefile +1 −0
net/rxrpc/ar-internal.h +17 −8
net/rxrpc/call_accept.c +1 −1
net/rxrpc/call_event.c +8 −14
net/rxrpc/input.c +37 −7
net/rxrpc/misc.c +0 −5
net/rxrpc/output.c +3 −6
net/rxrpc/peer_event.c +0 −46
net/rxrpc/peer_object.c +7 −5
net/rxrpc/proc.c +4 −4
net/rxrpc/rtt.c +195 −0
net/rxrpc/rxkad.c +1 −2
net/rxrpc/sendmsg.c +9 −17
net/rxrpc/sysctl.c +0 −9
net/sctp/sm_sideeffect.c +11 −3
net/sctp/sm_statefuns.c +5 −4
net/tipc/udp_media.c +5 −1
net/tls/tls_sw.c +10 −7
security/security.c +14 −2
tools/testing/selftests/bpf/prog_tests/mmap.c +12 −1
tools/testing/selftests/bpf/progs/test_mmap.c +8 −0
tools/testing/selftests/drivers/net/mlxsw/qos_mc_aware.sh +1 −1
tools/testing/selftests/drivers/net/netdevsim/devlink_trap.sh +4 −0
tools/testing/selftests/wireguard/qemu/Makefile +1 −1

Documentation/devicetree/bindings/net/dsa/b53.txt+3−0

@@ -110,6 +110,9 @@ Ethernet switch connected via MDIO to the host, CPU port wired to eth0: · 109 unmodified lines
110	#size-cells = <0>;	110	#size-cells = <0>;
111		111
112	ports {	112	ports {
		113	#address-cells = <1>;
		114	#size-cells = <0>;
		115
113	port0@0 {	116	port0@0 {
114	reg = <0>;	117	reg = <0>;
115	label = "lan1";	118	label = "lan1";

drivers/net/can/ifi_canfd/ifi_canfd.c+4−1

 	u32 id, rev;
 	addr = devm_platform_ioremap_resource(pdev, 0);
+	if (IS_ERR(addr))
+		return PTR_ERR(addr);
 	irq = platform_get_irq(pdev, 0);
-	if (IS_ERR(addr) || irq < 0)
+	if (irq < 0)
 		return -EINVAL;
 	id = readl(addr + IFI_CANFD_IP_ID);

drivers/net/can/sun4i_can.c+1−1

@@ -792,7 +792,7 @@ static int sun4ican_probe(struct platform_device *pdev) · 791 unmodified lines
792		792
793	addr = devm_platform_ioremap_resource(pdev, 0);	793	addr = devm_platform_ioremap_resource(pdev, 0);
794	if (IS_ERR(addr)) {	794	if (IS_ERR(addr)) {
795	err = -EBUSY;	795	err = PTR_ERR(addr);
796	goto exit;	796	goto exit;
797	}	797	}
798		798

drivers/net/dsa/b53/b53_srab.c+1−1

@@ -609,7 +609,7 @@ static int b53_srab_probe(struct platform_device *pdev) · 608 unmodified lines
609		609
610	priv->regs = devm_platform_ioremap_resource(pdev, 0);	610	priv->regs = devm_platform_ioremap_resource(pdev, 0);
611	if (IS_ERR(priv->regs))	611	if (IS_ERR(priv->regs))
612	return -ENOMEM;	612	return PTR_ERR(priv->regs);
613		613
614	dev = b53_switch_alloc(&pdev->dev, &b53_srab_ops, priv);	614	dev = b53_switch_alloc(&pdev->dev, &b53_srab_ops, priv);
615	if (!dev)	615	if (!dev)

drivers/net/dsa/mt7530.c+2−7

 	mt7530_write(priv, MT7530_PVC_P(port),
 		     PORT_SPEC_TAG);
-	/* Disable auto learning on the cpu port */
+	/* Unknown multicast frame forwarding to the cpu port */
-	mt7530_set(priv, MT7530_PSC_P(port), SA_DIS);
+	mt7530_rmw(priv, MT7530_MFC, UNM_FFP_MASK, UNM_FFP(BIT(port)));
-	/* Unknown unicast frame fordwarding to the cpu port */
-	mt7530_set(priv, MT7530_MFC, UNU_FFP(BIT(port)));
 	/* Set CPU port number */
 	if (priv->id == ID_MT7621)
 	/* Enable and reset MIB counters */
 	mt7530_mib_reset(ds);
-	mt7530_clear(priv, MT7530_MFC, UNU_FFP_MASK);
 	for (i = 0; i < MT7530_NUM_PORTS; i++) {
 		/* Disable forwarding by default on all ports */
 		mt7530_rmw(priv, MT7530_PCR_P(i), PCR_MATRIX_MASK,

drivers/net/dsa/mt7530.h+1−0

@@ -31,6 +31,7 @@ enum { · 30 unmodified lines
31	#define MT7530_MFC 0x10	31	#define MT7530_MFC 0x10
32	#define BC_FFP(x) (((x) & 0xff) << 24)	32	#define BC_FFP(x) (((x) & 0xff) << 24)
33	#define UNM_FFP(x) (((x) & 0xff) << 16)	33	#define UNM_FFP(x) (((x) & 0xff) << 16)
		34	#define UNM_FFP_MASK UNM_FFP(~0)
34	#define UNU_FFP(x) (((x) & 0xff) << 8)	35	#define UNU_FFP(x) (((x) & 0xff) << 8)
35	#define UNU_FFP_MASK UNU_FFP(~0)	36	#define UNU_FFP_MASK UNU_FFP(~0)
36	#define CPU_EN BIT(7)	37	#define CPU_EN BIT(7)

drivers/net/dsa/ocelot/felix.c+11−12

 	struct ocelot *ocelot = &felix->ocelot;
 	phy_interface_t *port_phy_modes;
 	resource_size_t switch_base;
+	struct resource res;
 	int port, i, err;
 	ocelot->num_phys_ports = num_phys_ports;
 	for (i = 0; i < TARGET_MAX; i++) {
 		struct regmap *target;
-		struct resource *res;
 		if (!felix->info->target_io_res[i].name)
 			continue;
-		res = &felix->info->target_io_res[i];
+		memcpy(&res, &felix->info->target_io_res[i], sizeof(res));
-		res->flags = IORESOURCE_MEM;
+		res.flags = IORESOURCE_MEM;
-		res->start += switch_base;
+		res.start += switch_base;
-		res->end += switch_base;
+		res.end += switch_base;
-		target = ocelot_regmap_init(ocelot, res);
+		target = ocelot_regmap_init(ocelot, &res);
 		if (IS_ERR(target)) {
 			dev_err(ocelot->dev,
 				"Failed to map device memory space\n");
 	for (port = 0; port < num_phys_ports; port++) {
 		struct ocelot_port *ocelot_port;
 		void __iomem *port_regs;
-		struct resource *res;
 		ocelot_port = devm_kzalloc(ocelot->dev,
 					   sizeof(struct ocelot_port),
 			return -ENOMEM;
 		}
-		res = &felix->info->port_io_res[port];
+		memcpy(&res, &felix->info->port_io_res[port], sizeof(res));
-		res->flags = IORESOURCE_MEM;
+		res.flags = IORESOURCE_MEM;
-		res->start += switch_base;
+		res.start += switch_base;
-		res->end += switch_base;
+		res.end += switch_base;
-		port_regs = devm_ioremap_resource(ocelot->dev, res);
+		port_regs = devm_ioremap_resource(ocelot->dev, &res);
 		if (IS_ERR(port_regs)) {
 			dev_err(ocelot->dev,
 				"failed to map registers for port %d\n", port);

drivers/net/dsa/ocelot/felix.h+3−3

@@ -8,9 +8,9 @@ · 7 unmodified lines
8		8
9	/* Platform-specific information */	9	/* Platform-specific information */
10	struct felix_info {	10	struct felix_info {
11	struct resource *target_io_res;	11	const struct resource *target_io_res;
12	struct resource *port_io_res;	12	const struct resource *port_io_res;
13	struct resource *imdio_res;	13	const struct resource *imdio_res;
14	const struct reg_field *regfields;	14	const struct reg_field *regfields;
15	const u32 const map;	15	const u32 const map;
16	const struct ocelot_ops *ops;	16	const struct ocelot_ops *ops;

drivers/net/dsa/ocelot/felix_vsc9959.c+10−12

 	[GCB]	= vsc9959_gcb_regmap,
 };
-/* Addresses are relative to the PCI device's base address and
+/* Addresses are relative to the PCI device's base address */
- * will be fixed up at ioremap time.
+static const struct resource vsc9959_target_io_res[] = {
- */
-static struct resource vsc9959_target_io_res[] = {
 	[ANA] = {
 		.start	= 0x0280000,
 		.end	= 0x028ffff,
 	},
 };
-static struct resource vsc9959_port_io_res[] = {
+static const struct resource vsc9959_port_io_res[] = {
 	{
 		.start	= 0x0100000,
 		.end	= 0x010ffff,
 /* Port MAC 0 Internal MDIO bus through which the SerDes acting as an
  * SGMII/QSGMII MAC PCS can be found.
  */
-static struct resource vsc9959_imdio_res = {
+static const struct resource vsc9959_imdio_res = {
 	.start		= 0x8030,
 	.end		= 0x8040,
 	.name		= "imdio",
 	struct device *dev = ocelot->dev;
 	resource_size_t imdio_base;
 	void __iomem *imdio_regs;
-	struct resource *res;
+	struct resource res;
 	struct enetc_hw *hw;
 	struct mii_bus *bus;
 	int port;
 	imdio_base = pci_resource_start(felix->pdev,
 					felix->info->imdio_pci_bar);
-	res = felix->info->imdio_res;
+	memcpy(&res, felix->info->imdio_res, sizeof(res));
-	res->flags = IORESOURCE_MEM;
+	res.flags = IORESOURCE_MEM;
-	res->start += imdio_base;
+	res.start += imdio_base;
-	res->end += imdio_base;
+	res.end += imdio_base;
-	imdio_regs = devm_ioremap_resource(dev, res);
+	imdio_regs = devm_ioremap_resource(dev, &res);
 	if (IS_ERR(imdio_regs)) {
 		dev_err(dev, "failed to map internal MDIO registers\n");
 		return PTR_ERR(imdio_regs);

drivers/net/ethernet/apple/bmac.c+1−1

@@ -1182,7 +1182,7 @@ bmac_get_station_address(struct net_device dev, unsigned char ea) · 1181 unmodified lines
1182	int i;	1182	int i;
1183	unsigned short data;	1183	unsigned short data;
1184		1184
1185	for (i = 0; i < 6; i++)	1185	for (i = 0; i < 3; i++)
1186	{	1186	{
1187	reset_and_select_srom(dev);	1187	reset_and_select_srom(dev);
1188	data = read_srom(dev, i + EnetAddressOffset/2, SROMAddressBits);	1188	data = read_srom(dev, i + EnetAddressOffset/2, SROMAddressBits);

drivers/net/ethernet/freescale/ucc_geth.c+7−6

@@ -42,6 +42,7 @@ · 41 unmodified lines
42	#include <soc/fsl/qe/ucc.h>	42	#include <soc/fsl/qe/ucc.h>
43	#include <soc/fsl/qe/ucc_fast.h>	43	#include <soc/fsl/qe/ucc_fast.h>
44	#include <asm/machdep.h>	44	#include <asm/machdep.h>
		45	#include <net/sch_generic.h>
45		46
46	#include "ucc_geth.h"	47	#include "ucc_geth.h"
47		48
@@ -1548,11 +1549,8 @@ static int ugeth_disable(struct ucc_geth_private *ugeth, enum comm_dir mode) · 1500 unmodified lines
1548		1549
1549	static void ugeth_quiesce(struct ucc_geth_private *ugeth)	1550	static void ugeth_quiesce(struct ucc_geth_private *ugeth)
1550	{	1551	{
1551	/* Prevent any further xmits, plus detach the device. */	1552	/* Prevent any further xmits */
1552	netif_device_detach(ugeth->ndev);	1553	netif_tx_stop_all_queues(ugeth->ndev);
1553
1554	/* Wait for any current xmits to finish. */
1555	netif_tx_disable(ugeth->ndev);
1556		1554
1557	/* Disable the interrupt to avoid NAPI rescheduling. */	1555	/* Disable the interrupt to avoid NAPI rescheduling. */
1558	disable_irq(ugeth->ug_info->uf_info.irq);	1556	disable_irq(ugeth->ug_info->uf_info.irq);
@@ -1565,7 +1563,10 @@ static void ugeth_activate(struct ucc_geth_private *ugeth) · 6 unmodified lines
1565	{	1563	{
1566	napi_enable(&ugeth->napi);	1564	napi_enable(&ugeth->napi);
1567	enable_irq(ugeth->ug_info->uf_info.irq);	1565	enable_irq(ugeth->ug_info->uf_info.irq);
1568	netif_device_attach(ugeth->ndev);	1566
		1567	/* allow to xmit again */
		1568	netif_tx_wake_all_queues(ugeth->ndev);
		1569	__netdev_watchdog_up(ugeth->ndev);
1569	}	1570	}
1570		1571
1571	/* Called every time the controller might need to be made	1572	/* Called every time the controller might need to be made

drivers/net/ethernet/marvell/mvpp2/mvpp2_cls.c+1−1

@@ -1070,7 +1070,7 @@ void mvpp2_cls_oversize_rxq_set(struct mvpp2_port *port) · 1069 unmodified lines
1070	(port->first_rxq >> MVPP2_CLS_OVERSIZE_RXQ_LOW_BITS));	1070	(port->first_rxq >> MVPP2_CLS_OVERSIZE_RXQ_LOW_BITS));
1071		1071
1072	val = mvpp2_read(port->priv, MVPP2_CLS_SWFWD_PCTRL_REG);	1072	val = mvpp2_read(port->priv, MVPP2_CLS_SWFWD_PCTRL_REG);
1073	val \|= MVPP2_CLS_SWFWD_PCTRL_MASK(port->id);	1073	val &= ~MVPP2_CLS_SWFWD_PCTRL_MASK(port->id);
1074	mvpp2_write(port->priv, MVPP2_CLS_SWFWD_PCTRL_REG, val);	1074	mvpp2_write(port->priv, MVPP2_CLS_SWFWD_PCTRL_REG, val);
1075	}	1075	}
1076		1076

drivers/net/ethernet/marvell/pxa168_eth.c+1−1

@@ -1418,7 +1418,7 @@ static int pxa168_eth_probe(struct platform_device *pdev) · 1417 unmodified lines
1418		1418
1419	pep->base = devm_platform_ioremap_resource(pdev, 0);	1419	pep->base = devm_platform_ioremap_resource(pdev, 0);
1420	if (IS_ERR(pep->base)) {	1420	if (IS_ERR(pep->base)) {
1421	err = -ENOMEM;	1421	err = PTR_ERR(pep->base);
1422	goto err_netdev;	1422	goto err_netdev;
1423	}	1423	}
1424		1424

drivers/net/ethernet/mellanox/mlx4/fw.c+1−1

@@ -2734,7 +2734,7 @@ void mlx4_opreq_action(struct work_struct *work) · 2733 unmodified lines
2734	if (err) {	2734	if (err) {
2735	mlx4_err(dev, "Failed to retrieve required operation: %d\n",	2735	mlx4_err(dev, "Failed to retrieve required operation: %d\n",
2736	err);	2736	err);
2737	return;	2737	goto out;
2738	}	2738	}
2739	MLX4_GET(modifier, outbox, GET_OP_REQ_MODIFIER_OFFSET);	2739	MLX4_GET(modifier, outbox, GET_OP_REQ_MODIFIER_OFFSET);
2740	MLX4_GET(token, outbox, GET_OP_REQ_TOKEN_OFFSET);	2740	MLX4_GET(token, outbox, GET_OP_REQ_TOKEN_OFFSET);

drivers/net/ethernet/mellanox/mlx5/core/cmd.c+55−4

@@ -848,6 +848,14 @@ static void free_msg(struct mlx5_core_dev dev, struct mlx5_cmd_msg msg); · 847 unmodified lines
848	static void mlx5_free_cmd_msg(struct mlx5_core_dev *dev,	848	static void mlx5_free_cmd_msg(struct mlx5_core_dev *dev,
849	struct mlx5_cmd_msg *msg);	849	struct mlx5_cmd_msg *msg);
850		850
		851	static bool opcode_allowed(struct mlx5_cmd *cmd, u16 opcode)
		852	{
		853	if (cmd->allowed_opcode == CMD_ALLOWED_OPCODE_ALL)
		854	return true;
		855
		856	return cmd->allowed_opcode == opcode;
		857	}
		858
851	static void cmd_work_handler(struct work_struct *work)	859	static void cmd_work_handler(struct work_struct *work)
852	{	860	{
853	struct mlx5_cmd_work_ent *ent = container_of(work, struct mlx5_cmd_work_ent, work);	861	struct mlx5_cmd_work_ent *ent = container_of(work, struct mlx5_cmd_work_ent, work);
@@ -861,6 +869,7 @@ static void cmd_work_handler(struct work_struct *work) · 7 unmodified lines
861	int alloc_ret;	869	int alloc_ret;
862	int cmd_mode;	870	int cmd_mode;
863		871
		872	complete(&ent->handling);
864	sem = ent->page_queue ? &cmd->pages_sem : &cmd->sem;	873	sem = ent->page_queue ? &cmd->pages_sem : &cmd->sem;
865	down(sem);	874	down(sem);
866	if (!ent->page_queue) {	875	if (!ent->page_queue) {
@@ -913,7 +922,9 @@ static void cmd_work_handler(struct work_struct *work) · 46 unmodified lines
913		922
914	/* Skip sending command to fw if internal error */	923	/* Skip sending command to fw if internal error */
915	if (pci_channel_offline(dev->pdev) \|\|	924	if (pci_channel_offline(dev->pdev) \|\|
916	dev->state == MLX5_DEVICE_STATE_INTERNAL_ERROR) {	925	dev->state == MLX5_DEVICE_STATE_INTERNAL_ERROR \|\|
		926	cmd->state != MLX5_CMDIF_STATE_UP \|\|
		927	!opcode_allowed(&dev->cmd, ent->op)) {
917	u8 status = 0;	928	u8 status = 0;
918	u32 drv_synd;	929	u32 drv_synd;
919		930
@@ -978,6 +989,11 @@ static int wait_func(struct mlx5_core_dev dev, struct mlx5_cmd_work_ent ent) · 58 unmodified lines
978	struct mlx5_cmd *cmd = &dev->cmd;	989	struct mlx5_cmd *cmd = &dev->cmd;
979	int err;	990	int err;
980		991
		992	if (!wait_for_completion_timeout(&ent->handling, timeout) &&
		993	cancel_work_sync(&ent->work)) {
		994	ent->ret = -ECANCELED;
		995	goto out_err;
		996	}
981	if (cmd->mode == CMD_MODE_POLLING \|\| ent->polling) {	997	if (cmd->mode == CMD_MODE_POLLING \|\| ent->polling) {
982	wait_for_completion(&ent->done);	998	wait_for_completion(&ent->done);
983	} else if (!wait_for_completion_timeout(&ent->done, timeout)) {	999	} else if (!wait_for_completion_timeout(&ent->done, timeout)) {
@@ -985,12 +1001,17 @@ static int wait_func(struct mlx5_core_dev dev, struct mlx5_cmd_work_ent ent) · 1 unmodified line
985	mlx5_cmd_comp_handler(dev, 1UL << ent->idx, true);	1001	mlx5_cmd_comp_handler(dev, 1UL << ent->idx, true);
986	}	1002	}
987		1003
		1004	out_err:
988	err = ent->ret;	1005	err = ent->ret;
989		1006
990	if (err == -ETIMEDOUT) {	1007	if (err == -ETIMEDOUT) {
991	mlx5_core_warn(dev, "%s(0x%x) timeout. Will cause a leak of a command resource\n",	1008	mlx5_core_warn(dev, "%s(0x%x) timeout. Will cause a leak of a command resource\n",
992	mlx5_command_str(msg_to_opcode(ent->in)),	1009	mlx5_command_str(msg_to_opcode(ent->in)),
993	msg_to_opcode(ent->in));	1010	msg_to_opcode(ent->in));
		1011	} else if (err == -ECANCELED) {
		1012	mlx5_core_warn(dev, "%s(0x%x) canceled on out of queue timeout.\n",
		1013	mlx5_command_str(msg_to_opcode(ent->in)),
		1014	msg_to_opcode(ent->in));
994	}	1015	}
995	mlx5_core_dbg(dev, "err %d, delivery status %s(%d)\n",	1016	mlx5_core_dbg(dev, "err %d, delivery status %s(%d)\n",
996	err, deliv_status_to_str(ent->status), ent->status);	1017	err, deliv_status_to_str(ent->status), ent->status);
@@ -1026,6 +1047,7 @@ static int mlx5_cmd_invoke(struct mlx5_core_dev dev, struct mlx5_cmd_msg in, · 29 unmodified lines
1026	ent->token = token;	1047	ent->token = token;
1027	ent->polling = force_polling;	1048	ent->polling = force_polling;
1028		1049
		1050	init_completion(&ent->handling);
1029	if (!callback)	1051	if (!callback)
1030	init_completion(&ent->done);	1052	init_completion(&ent->done);
1031		1053
@@ -1045,6 +1067,8 @@ static int mlx5_cmd_invoke(struct mlx5_core_dev dev, struct mlx5_cmd_msg in, · 13 unmodified lines
1045	err = wait_func(dev, ent);	1067	err = wait_func(dev, ent);
1046	if (err == -ETIMEDOUT)	1068	if (err == -ETIMEDOUT)
1047	goto out;	1069	goto out;
		1070	if (err == -ECANCELED)
		1071	goto out_free;
1048		1072
1049	ds = ent->ts2 - ent->ts1;	1073	ds = ent->ts2 - ent->ts1;
1050	op = MLX5_GET(mbox_in, in->first.data, opcode);	1074	op = MLX5_GET(mbox_in, in->first.data, opcode);
@@ -1391,6 +1415,22 @@ static void create_debugfs_files(struct mlx5_core_dev *dev) · 340 unmodified lines
1391	mlx5_cmdif_debugfs_init(dev);	1415	mlx5_cmdif_debugfs_init(dev);
1392	}	1416	}
1393		1417
		1418	void mlx5_cmd_allowed_opcode(struct mlx5_core_dev *dev, u16 opcode)
		1419	{
		1420	struct mlx5_cmd *cmd = &dev->cmd;
		1421	int i;
		1422
		1423	for (i = 0; i < cmd->max_reg_cmds; i++)
		1424	down(&cmd->sem);
		1425	down(&cmd->pages_sem);
		1426
		1427	cmd->allowed_opcode = opcode;
		1428
		1429	up(&cmd->pages_sem);
		1430	for (i = 0; i < cmd->max_reg_cmds; i++)
		1431	up(&cmd->sem);
		1432	}
		1433
1394	static void mlx5_cmd_change_mod(struct mlx5_core_dev *dev, int mode)	1434	static void mlx5_cmd_change_mod(struct mlx5_core_dev *dev, int mode)
1395	{	1435	{
1396	struct mlx5_cmd *cmd = &dev->cmd;	1436	struct mlx5_cmd *cmd = &dev->cmd;
@@ -1667,12 +1707,14 @@ static int cmd_exec(struct mlx5_core_dev dev, void in, int in_size, void *out, · 270 unmodified lines
1667	int err;	1707	int err;
1668	u8 status = 0;	1708	u8 status = 0;
1669	u32 drv_synd;	1709	u32 drv_synd;
		1710	u16 opcode;
1670	u8 token;	1711	u8 token;
1671		1712
		1713	opcode = MLX5_GET(mbox_in, in, opcode);
1672	if (pci_channel_offline(dev->pdev) \|\|	1714	if (pci_channel_offline(dev->pdev) \|\|
1673	dev->state == MLX5_DEVICE_STATE_INTERNAL_ERROR) {	1715	dev->state == MLX5_DEVICE_STATE_INTERNAL_ERROR \|\|
1674	u16 opcode = MLX5_GET(mbox_in, in, opcode);	1716	dev->cmd.state != MLX5_CMDIF_STATE_UP \|\|
1675		1717	!opcode_allowed(&dev->cmd, opcode)) {
1676	err = mlx5_internal_err_ret_value(dev, opcode, &drv_synd, &status);	1718	err = mlx5_internal_err_ret_value(dev, opcode, &drv_synd, &status);
1677	MLX5_SET(mbox_out, out, status, status);	1719	MLX5_SET(mbox_out, out, status, status);
1678	MLX5_SET(mbox_out, out, syndrome, drv_synd);	1720	MLX5_SET(mbox_out, out, syndrome, drv_synd);
@@ -1937,6 +1979,7 @@ int mlx5_cmd_init(struct mlx5_core_dev *dev) · 258 unmodified lines
1937	goto err_free_page;	1979	goto err_free_page;
1938	}	1980	}
1939		1981
		1982	cmd->state = MLX5_CMDIF_STATE_DOWN;
1940	cmd->checksum_disabled = 1;	1983	cmd->checksum_disabled = 1;
1941	cmd->max_reg_cmds = (1 << cmd->log_sz) - 1;	1984	cmd->max_reg_cmds = (1 << cmd->log_sz) - 1;
1942	cmd->bitmask = (1UL << cmd->max_reg_cmds) - 1;	1985	cmd->bitmask = (1UL << cmd->max_reg_cmds) - 1;
@@ -1974,6 +2017,7 @@ int mlx5_cmd_init(struct mlx5_core_dev *dev) · 31 unmodified lines
1974	mlx5_core_dbg(dev, "descriptor at dma 0x%llx\n", (unsigned long long)(cmd->dma));	2017	mlx5_core_dbg(dev, "descriptor at dma 0x%llx\n", (unsigned long long)(cmd->dma));
1975		2018
1976	cmd->mode = CMD_MODE_POLLING;	2019	cmd->mode = CMD_MODE_POLLING;
		2020	cmd->allowed_opcode = CMD_ALLOWED_OPCODE_ALL;
1977		2021
1978	create_msg_cache(dev);	2022	create_msg_cache(dev);
1979		2023
@@ -2013,3 +2057,10 @@ void mlx5_cmd_cleanup(struct mlx5_core_dev *dev) · 33 unmodified lines
2013	dma_pool_destroy(cmd->pool);	2057	dma_pool_destroy(cmd->pool);
2014	}	2058	}
2015	EXPORT_SYMBOL(mlx5_cmd_cleanup);	2059	EXPORT_SYMBOL(mlx5_cmd_cleanup);
		2060
		2061	void mlx5_cmd_set_state(struct mlx5_core_dev *dev,
		2062	enum mlx5_cmdif_state cmdif_state)
		2063	{
		2064	dev->cmd.state = cmdif_state;
		2065	}
		2066	EXPORT_SYMBOL(mlx5_cmd_set_state);

drivers/net/ethernet/mellanox/mlx5/core/en.h+1−1

@@ -1121,7 +1121,7 @@ void mlx5e_close_drop_rq(struct mlx5e_rq *drop_rq); · 1120 unmodified lines
1121	int mlx5e_create_indirect_rqt(struct mlx5e_priv *priv);	1121	int mlx5e_create_indirect_rqt(struct mlx5e_priv *priv);
1122		1122
1123	int mlx5e_create_indirect_tirs(struct mlx5e_priv *priv, bool inner_ttc);	1123	int mlx5e_create_indirect_tirs(struct mlx5e_priv *priv, bool inner_ttc);
1124	void mlx5e_destroy_indirect_tirs(struct mlx5e_priv *priv, bool inner_ttc);	1124	void mlx5e_destroy_indirect_tirs(struct mlx5e_priv *priv);
1125		1125
1126	int mlx5e_create_direct_rqts(struct mlx5e_priv priv, struct mlx5e_tir tirs);	1126	int mlx5e_create_direct_rqts(struct mlx5e_priv priv, struct mlx5e_tir tirs);
1127	void mlx5e_destroy_direct_rqts(struct mlx5e_priv priv, struct mlx5e_tir tirs);	1127	void mlx5e_destroy_direct_rqts(struct mlx5e_priv priv, struct mlx5e_tir tirs);

drivers/net/ethernet/mellanox/mlx5/core/en/tc_ct.c+3−2

 		       struct netlink_ext_ack *extack)
 {
 	struct mlx5_tc_ct_priv *ct_priv = mlx5_tc_ct_get_ct_priv(priv);
+	struct flow_rule *rule = flow_cls_offload_flow_rule(f);
 	struct flow_dissector_key_ct *mask, *key;
 	bool trk, est, untrk, unest, new;
 	u32 ctstate = 0, ctstate_mask = 0;
 	u16 ct_state, ct_state_mask;
 	struct flow_match_ct match;
-	if (!flow_rule_match_key(f->rule, FLOW_DISSECTOR_KEY_CT))
+	if (!flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_CT))
 		return 0;
 	if (!ct_priv) {
 		return -EOPNOTSUPP;
 	}
-	flow_rule_match_ct(f->rule, &match);
+	flow_rule_match_ct(rule, &match);
 	key = match.key;
 	mask = match.mask;

drivers/net/ethernet/mellanox/mlx5/core/en/tc_ct.h+3−1

@@ -130,7 +130,9 @@ mlx5_tc_ct_parse_match(struct mlx5e_priv *priv, · 129 unmodified lines
130	struct flow_cls_offload *f,	130	struct flow_cls_offload *f,
131	struct netlink_ext_ack *extack)	131	struct netlink_ext_ack *extack)
132	{	132	{
133	if (!flow_rule_match_key(f->rule, FLOW_DISSECTOR_KEY_CT))	133	struct flow_rule *rule = flow_cls_offload_flow_rule(f);
		134
		135	if (!flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_CT))
134	return 0;	136	return 0;
135		137
136	NL_SET_ERR_MSG_MOD(extack, "mlx5 tc ct offload isn't enabled.");	138	NL_SET_ERR_MSG_MOD(extack, "mlx5 tc ct offload isn't enabled.");

drivers/net/ethernet/mellanox/mlx5/core/en_accel/ktls.c+1−1

@@ -69,8 +69,8 @@ static void mlx5e_ktls_del(struct net_device *netdev, · 68 unmodified lines
69	struct mlx5e_ktls_offload_context_tx *tx_priv =	69	struct mlx5e_ktls_offload_context_tx *tx_priv =
70	mlx5e_get_ktls_tx_priv_ctx(tls_ctx);	70	mlx5e_get_ktls_tx_priv_ctx(tls_ctx);
71		71
72	mlx5_ktls_destroy_key(priv->mdev, tx_priv->key_id);
73	mlx5e_destroy_tis(priv->mdev, tx_priv->tisn);	72	mlx5e_destroy_tis(priv->mdev, tx_priv->tisn);
		73	mlx5_ktls_destroy_key(priv->mdev, tx_priv->key_id);
74	kvfree(tx_priv);	74	kvfree(tx_priv);
75	}	75	}
76		76

drivers/net/ethernet/mellanox/mlx5/core/en_main.c+7−5

 		mlx5_core_modify_tir(mdev, priv->indir_tir[tt].tirn, in, inlen);
 	}
-	if (!mlx5e_tunnel_inner_ft_supported(priv->mdev))
+	/* Verify inner tirs resources allocated */
+	if (!priv->inner_indir_tir[0].tirn)
 		return;
 	for (tt = 0; tt < MLX5E_NUM_INDIR_TIRS; tt++) {
 	return err;
 }
-void mlx5e_destroy_indirect_tirs(struct mlx5e_priv *priv, bool inner_ttc)
+void mlx5e_destroy_indirect_tirs(struct mlx5e_priv *priv)
 {
 	int i;
 	for (i = 0; i < MLX5E_NUM_INDIR_TIRS; i++)
 		mlx5e_destroy_tir(priv->mdev, &priv->indir_tir[i]);
-	if (!inner_ttc || !mlx5e_tunnel_inner_ft_supported(priv->mdev))
+	/* Verify inner tirs resources allocated */
+	if (!priv->inner_indir_tir[0].tirn)
 		return;
 	for (i = 0; i < MLX5E_NUM_INDIR_TIRS; i++)
 err_destroy_direct_tirs:
 	mlx5e_destroy_direct_tirs(priv, priv->direct_tir);
 err_destroy_indirect_tirs:
-	mlx5e_destroy_indirect_tirs(priv, true);
+	mlx5e_destroy_indirect_tirs(priv);
 err_destroy_direct_rqts:
 	mlx5e_destroy_direct_rqts(priv, priv->direct_tir);
 err_destroy_indirect_rqts:
 	mlx5e_destroy_direct_tirs(priv, priv->xsk_tir);
 	mlx5e_destroy_direct_rqts(priv, priv->xsk_tir);
 	mlx5e_destroy_direct_tirs(priv, priv->direct_tir);
-	mlx5e_destroy_indirect_tirs(priv, true);
+	mlx5e_destroy_indirect_tirs(priv);
 	mlx5e_destroy_direct_rqts(priv, priv->direct_tir);
 	mlx5e_destroy_rqt(priv, &priv->indir_rqt);
 	mlx5e_close_drop_rq(&priv->drop_rq);

drivers/net/ethernet/mellanox/mlx5/core/en_rep.c+4−8

 	return netdev->netdev_ops == &mlx5e_netdev_ops_uplink_rep;
 }
-bool mlx5e_eswitch_rep(struct net_device *netdev)
+bool mlx5e_eswitch_vf_rep(struct net_device *netdev)
 {
-	if (netdev->netdev_ops == &mlx5e_netdev_ops_rep ||
+	return netdev->netdev_ops == &mlx5e_netdev_ops_rep;
-	    netdev->netdev_ops == &mlx5e_netdev_ops_uplink_rep)
-		return true;
-	return false;
 }
 static void mlx5e_build_rep_params(struct net_device *netdev)
 err_destroy_direct_tirs:
 	mlx5e_destroy_direct_tirs(priv, priv->direct_tir);
 err_destroy_indirect_tirs:
-	mlx5e_destroy_indirect_tirs(priv, false);
+	mlx5e_destroy_indirect_tirs(priv);
 err_destroy_direct_rqts:
 	mlx5e_destroy_direct_rqts(priv, priv->direct_tir);
 err_destroy_indirect_rqts:
 	mlx5e_destroy_rep_root_ft(priv);
 	mlx5e_destroy_ttc_table(priv, &priv->fs.ttc);
 	mlx5e_destroy_direct_tirs(priv, priv->direct_tir);
-	mlx5e_destroy_indirect_tirs(priv, false);
+	mlx5e_destroy_indirect_tirs(priv);
 	mlx5e_destroy_direct_rqts(priv, priv->direct_tir);
 	mlx5e_destroy_rqt(priv, &priv->indir_rqt);
 	mlx5e_close_drop_rq(&priv->drop_rq);

drivers/net/ethernet/mellanox/mlx5/core/en_rep.h+6−1

 void mlx5e_rep_queue_neigh_stats_work(struct mlx5e_priv *priv);
-bool mlx5e_eswitch_rep(struct net_device *netdev);
+bool mlx5e_eswitch_vf_rep(struct net_device *netdev);
 bool mlx5e_eswitch_uplink_rep(struct net_device *netdev);
+static inline bool mlx5e_eswitch_rep(struct net_device *netdev)
+{
+	return mlx5e_eswitch_vf_rep(netdev) ||
+	       mlx5e_eswitch_uplink_rep(netdev);
+}
 #else /* CONFIG_MLX5_ESWITCH */
 static inline bool mlx5e_is_uplink_rep(struct mlx5e_priv *priv) { return false; }

drivers/net/ethernet/mellanox/mlx5/core/en_tc.c+33−7

 	return true;
 }
+static bool same_port_devs(struct mlx5e_priv *priv, struct mlx5e_priv *peer_priv)
+{
+	return priv->mdev == peer_priv->mdev;
+}
 static bool same_hw_devs(struct mlx5e_priv *priv, struct mlx5e_priv *peer_priv)
 {
 	struct mlx5_core_dev *fmdev, *pmdev;
 }
-static bool is_merged_eswitch_dev(struct mlx5e_priv *priv,
+static bool is_merged_eswitch_vfs(struct mlx5e_priv *priv,
 				  struct net_device *peer_netdev)
 {
 	struct mlx5e_priv *peer_priv;
 	peer_priv = netdev_priv(peer_netdev);
 	return (MLX5_CAP_ESW(priv->mdev, merged_eswitch) &&
-		mlx5e_eswitch_rep(priv->netdev) &&
+		mlx5e_eswitch_vf_rep(priv->netdev) &&
-		mlx5e_eswitch_rep(peer_netdev) &&
+		mlx5e_eswitch_vf_rep(peer_netdev) &&
 		same_hw_devs(priv, peer_priv));
 }
 bool mlx5e_encap_take(struct mlx5e_encap_entry *e)
 {
 	return refcount_inc_not_zero(&e->refcnt);
 	return err;
 }
+static bool same_hw_reps(struct mlx5e_priv *priv,
+			 struct net_device *peer_netdev)
+{
+	struct mlx5e_priv *peer_priv;
+	peer_priv = netdev_priv(peer_netdev);
+	return mlx5e_eswitch_rep(priv->netdev) &&
+	       mlx5e_eswitch_rep(peer_netdev) &&
+	       same_hw_devs(priv, peer_priv);
+}
+static bool is_lag_dev(struct mlx5e_priv *priv,
+		       struct net_device *peer_netdev)
+{
+	return ((mlx5_lag_is_sriov(priv->mdev) ||
+		 mlx5_lag_is_multipath(priv->mdev)) &&
+		 same_hw_reps(priv, peer_netdev));
+}
 bool mlx5e_is_valid_eswitch_fwd_dev(struct mlx5e_priv *priv,
 				    struct net_device *out_dev)
 {
-	if (is_merged_eswitch_dev(priv, out_dev))
+	if (is_merged_eswitch_vfs(priv, out_dev))
+		return true;
+	if (is_lag_dev(priv, out_dev))
 		return true;
 	return mlx5e_eswitch_rep(out_dev) &&
-	       same_hw_devs(priv, netdev_priv(out_dev));
+	       same_port_devs(priv, netdev_priv(out_dev));
 }
 static bool is_duplicated_output_device(struct net_device *dev,

drivers/net/ethernet/mellanox/mlx5/core/en_tx.c+6−3

 void mlx5e_free_txqsq_descs(struct mlx5e_txqsq *sq)
 {
 	struct mlx5e_tx_wqe_info *wi;
+	u32 dma_fifo_cc, nbytes = 0;
+	u16 ci, sqcc, npkts = 0;
 	struct sk_buff *skb;
-	u32 dma_fifo_cc;
-	u16 sqcc;
-	u16 ci;
 	int i;
 	sqcc = sq->cc;
 		}
 		dev_kfree_skb_any(skb);
+		npkts++;
+		nbytes += wi->num_bytes;
 		sqcc += wi->num_wqebbs;
 	}
 	sq->dma_fifo_cc = dma_fifo_cc;
 	sq->cc = sqcc;
+	netdev_tx_completed_queue(sq->txq, npkts, nbytes);
 }
 #ifdef CONFIG_MLX5_CORE_IPOIB

drivers/net/ethernet/mellanox/mlx5/core/eq.c+3−0

 		.nent = MLX5_NUM_CMD_EQE,
 		.mask[0] = 1ull << MLX5_EVENT_TYPE_CMD,
 	};
+	mlx5_cmd_allowed_opcode(dev, MLX5_CMD_OP_CREATE_EQ);
 	err = setup_async_eq(dev, &table->cmd_eq, &param, "cmd");
 	if (err)
 		goto err1;
 	mlx5_cmd_use_events(dev);
+	mlx5_cmd_allowed_opcode(dev, CMD_ALLOWED_OPCODE_ALL);
 	param = (struct mlx5_eq_param) {
 		.irq_index = 0,
 	mlx5_cmd_use_polling(dev);
 	cleanup_async_eq(dev, &table->cmd_eq, "cmd");
 err1:
+	mlx5_cmd_allowed_opcode(dev, CMD_ALLOWED_OPCODE_ALL);
 	mlx5_eq_notifier_unregister(dev, &table->cq_err_nb);
 	return err;
 }

drivers/net/ethernet/mellanox/mlx5/core/events.c+3−1

 	events->dev = dev;
 	dev->priv.events = events;
 	events->wq = create_singlethread_workqueue("mlx5_events");
-	if (!events->wq)
+	if (!events->wq) {
+		kfree(events);
 		return -ENOMEM;
+	}
 	INIT_WORK(&events->pcie_core_work, mlx5_pcie_event);
 	return 0;

drivers/net/ethernet/mellanox/mlx5/core/fs_core.c+19−11

 		if (node->del_hw_func)
 			node->del_hw_func(node);
 		if (parent_node) {
-			/* Only root namespace doesn't have parent and we just
-			 * need to free its node.
-			 */
 			down_write_ref_node(parent_node, locked);
 			list_del_init(&node->list);
-			if (node->del_sw_func)
-				node->del_sw_func(node);
-			up_write_ref_node(parent_node, locked);
-		} else {
-			kfree(node);
 		}
+		node->del_sw_func(node);
+		if (parent_node)
+			up_write_ref_node(parent_node, locked);
 		node = NULL;
 	}
 	if (!node && parent_node)
 	fs_get_obj(ft, node);
 	rhltable_destroy(&ft->fgs_hash);
-	fs_get_obj(prio, ft->node.parent);
+	if (ft->node.parent) {
-	prio->num_ft--;
+		fs_get_obj(prio, ft->node.parent);
+		prio->num_ft--;
+	}
 	kfree(ft);
 }
 	return 0;
 }
+static void del_sw_root_ns(struct fs_node *node)
+{
+	struct mlx5_flow_root_namespace *root_ns;
+	struct mlx5_flow_namespace *ns;
+	fs_get_obj(ns, node);
+	root_ns = container_of(ns, struct mlx5_flow_root_namespace, ns);
+	mutex_destroy(&root_ns->chain_lock);
+	kfree(node);
+}
 static struct mlx5_flow_root_namespace
 *create_root_ns(struct mlx5_flow_steering *steering,
 		enum fs_flow_table_type table_type)
 	ns = &root_ns->ns;
 	fs_init_namespace(ns);
 	mutex_init(&root_ns->chain_lock);
-	tree_init_node(&ns->node, NULL, NULL);
+	tree_init_node(&ns->node, NULL, del_sw_root_ns);
 	tree_add_node(&ns->node, NULL);
 	return root_ns;

drivers/net/ethernet/mellanox/mlx5/core/ipoib/ipoib.c+2−2

@@ -396,7 +396,7 @@ static int mlx5i_init_rx(struct mlx5e_priv *priv) · 395 unmodified lines
396	err_destroy_direct_tirs:	396	err_destroy_direct_tirs:
397	mlx5e_destroy_direct_tirs(priv, priv->direct_tir);	397	mlx5e_destroy_direct_tirs(priv, priv->direct_tir);
398	err_destroy_indirect_tirs:	398	err_destroy_indirect_tirs:
399	mlx5e_destroy_indirect_tirs(priv, true);	399	mlx5e_destroy_indirect_tirs(priv);
400	err_destroy_direct_rqts:	400	err_destroy_direct_rqts:
401	mlx5e_destroy_direct_rqts(priv, priv->direct_tir);	401	mlx5e_destroy_direct_rqts(priv, priv->direct_tir);
402	err_destroy_indirect_rqts:	402	err_destroy_indirect_rqts:
@@ -412,7 +412,7 @@ static void mlx5i_cleanup_rx(struct mlx5e_priv *priv) · 9 unmodified lines
412	{	412	{
413	mlx5i_destroy_flow_steering(priv);	413	mlx5i_destroy_flow_steering(priv);
414	mlx5e_destroy_direct_tirs(priv, priv->direct_tir);	414	mlx5e_destroy_direct_tirs(priv, priv->direct_tir);
415	mlx5e_destroy_indirect_tirs(priv, true);	415	mlx5e_destroy_indirect_tirs(priv);
416	mlx5e_destroy_direct_rqts(priv, priv->direct_tir);	416	mlx5e_destroy_direct_rqts(priv, priv->direct_tir);
417	mlx5e_destroy_rqt(priv, &priv->indir_rqt);	417	mlx5e_destroy_rqt(priv, &priv->indir_rqt);
418	mlx5e_close_drop_rq(&priv->drop_rq);	418	mlx5e_close_drop_rq(&priv->drop_rq);

drivers/net/ethernet/mellanox/mlx5/core/main.c+6−1

 		goto err_cmd_cleanup;
 	}
+	mlx5_cmd_set_state(dev, MLX5_CMDIF_STATE_UP);
 	err = mlx5_core_enable_hca(dev, 0);
 	if (err) {
 		mlx5_core_err(dev, "enable hca failed\n");
 err_disable_hca:
 	mlx5_core_disable_hca(dev, 0);
 err_cmd_cleanup:
+	mlx5_cmd_set_state(dev, MLX5_CMDIF_STATE_DOWN);
 	mlx5_cmd_cleanup(dev);
 	return err;
 	}
 	mlx5_reclaim_startup_pages(dev);
 	mlx5_core_disable_hca(dev, 0);
+	mlx5_cmd_set_state(dev, MLX5_CMDIF_STATE_DOWN);
 	mlx5_cmd_cleanup(dev);
 	return 0;
 	err = mlx5_function_setup(dev, boot);
 	if (err)
-		goto out;
+		goto err_function;
 	if (boot) {
 		err = mlx5_init_once(dev);
 		mlx5_cleanup_once(dev);
 function_teardown:
 	mlx5_function_teardown(dev, boot);
+err_function:
 	dev->state = MLX5_DEVICE_STATE_INTERNAL_ERROR;
 	mutex_unlock(&dev->intf_state_mutex);

drivers/net/ethernet/mellanox/mlxsw/spectrum.c+12−2

 			mlxsw_sp_port_remove(mlxsw_sp, i);
 	mlxsw_sp_cpu_port_remove(mlxsw_sp);
 	kfree(mlxsw_sp->ports);
+	mlxsw_sp->ports = NULL;
 }
 static int mlxsw_sp_ports_create(struct mlxsw_sp *mlxsw_sp)
 	mlxsw_sp_cpu_port_remove(mlxsw_sp);
 err_cpu_port_create:
 	kfree(mlxsw_sp->ports);
+	mlxsw_sp->ports = NULL;
 	return err;
 }
 	return mlxsw_core_res_get(mlxsw_core, local_ports_in_x_res_id);
 }
+static struct mlxsw_sp_port *
+mlxsw_sp_port_get_by_local_port(struct mlxsw_sp *mlxsw_sp, u8 local_port)
+{
+	if (mlxsw_sp->ports && mlxsw_sp->ports[local_port])
+		return mlxsw_sp->ports[local_port];
+	return NULL;
+}
 static int mlxsw_sp_port_split(struct mlxsw_core *mlxsw_core, u8 local_port,
 			       unsigned int count,
 			       struct netlink_ext_ack *extack)
 	int i;
 	int err;
-	mlxsw_sp_port = mlxsw_sp->ports[local_port];
+	mlxsw_sp_port = mlxsw_sp_port_get_by_local_port(mlxsw_sp, local_port);
 	if (!mlxsw_sp_port) {
 		dev_err(mlxsw_sp->bus_info->dev, "Port number \"%d\" does not exist\n",
 			local_port);
 	int offset;
 	int i;
-	mlxsw_sp_port = mlxsw_sp->ports[local_port];
+	mlxsw_sp_port = mlxsw_sp_port_get_by_local_port(mlxsw_sp, local_port);
 	if (!mlxsw_sp_port) {
 		dev_err(mlxsw_sp->bus_info->dev, "Port number \"%d\" does not exist\n",
 			local_port);

drivers/net/ethernet/mellanox/mlxsw/switchx2.c+8−0

 		if (mlxsw_sx_port_created(mlxsw_sx, i))
 			mlxsw_sx_port_remove(mlxsw_sx, i);
 	kfree(mlxsw_sx->ports);
+	mlxsw_sx->ports = NULL;
 }
 static int mlxsw_sx_ports_create(struct mlxsw_sx *mlxsw_sx)
 		if (mlxsw_sx_port_created(mlxsw_sx, i))
 			mlxsw_sx_port_remove(mlxsw_sx, i);
 	kfree(mlxsw_sx->ports);
+	mlxsw_sx->ports = NULL;
 	return err;
 }
 	u8 module, width;
 	int err;
+	if (!mlxsw_sx->ports || !mlxsw_sx->ports[local_port]) {
+		dev_err(mlxsw_sx->bus_info->dev, "Port number \"%d\" does not exist\n",
+			local_port);
+		return -EINVAL;
+	}
 	if (new_type == DEVLINK_PORT_TYPE_AUTO)
 		return -EOPNOTSUPP;

drivers/net/ethernet/mscc/ocelot.c+1−1

@@ -1467,7 +1467,7 @@ static void ocelot_port_attr_ageing_set(struct ocelot *ocelot, int port, · 1466 unmodified lines
1467	unsigned long ageing_clock_t)	1467	unsigned long ageing_clock_t)
1468	{	1468	{
1469	unsigned long ageing_jiffies = clock_t_to_jiffies(ageing_clock_t);	1469	unsigned long ageing_jiffies = clock_t_to_jiffies(ageing_clock_t);
1470	u32 ageing_time = jiffies_to_msecs(ageing_jiffies) / 1000;	1470	u32 ageing_time = jiffies_to_msecs(ageing_jiffies);
1471		1471
1472	ocelot_set_ageing_time(ocelot, ageing_time);	1472	ocelot_set_ageing_time(ocelot, ageing_time);
1473	}	1473	}

drivers/net/ethernet/realtek/r8169_main.c+15−2

 		RTL_R32(tp, EPHYAR) & EPHYAR_DATA_MASK : ~0;
 }
+static void r8168fp_adjust_ocp_cmd(struct rtl8169_private *tp, u32 *cmd, int type)
+{
+	/* based on RTL8168FP_OOBMAC_BASE in vendor driver */
+	if (tp->mac_version == RTL_GIGA_MAC_VER_52 && type == ERIAR_OOB)
+		*cmd |= 0x7f0 << 18;
+}
 DECLARE_RTL_COND(rtl_eriar_cond)
 {
 	return RTL_R32(tp, ERIAR) & ERIAR_FLAG;
 static void _rtl_eri_write(struct rtl8169_private *tp, int addr, u32 mask,
 			   u32 val, int type)
 {
+	u32 cmd = ERIAR_WRITE_CMD | type | mask | addr;
 	BUG_ON((addr & 3) || (mask == 0));
 	RTL_W32(tp, ERIDR, val);
-	RTL_W32(tp, ERIAR, ERIAR_WRITE_CMD | type | mask | addr);
+	r8168fp_adjust_ocp_cmd(tp, &cmd, type);
+	RTL_W32(tp, ERIAR, cmd);
 	rtl_udelay_loop_wait_low(tp, &rtl_eriar_cond, 100, 100);
 }
 static u32 _rtl_eri_read(struct rtl8169_private *tp, int addr, int type)
 {
-	RTL_W32(tp, ERIAR, ERIAR_READ_CMD | type | ERIAR_MASK_1111 | addr);
+	u32 cmd = ERIAR_READ_CMD | type | ERIAR_MASK_1111 | addr;
+	r8168fp_adjust_ocp_cmd(tp, &cmd, type);
+	RTL_W32(tp, ERIAR, cmd);
 	return rtl_udelay_loop_wait_high(tp, &rtl_eriar_cond, 100, 100) ?
 		RTL_R32(tp, ERIDR) : ~0;

drivers/net/ethernet/sgi/ioc3-eth.c+4−4

@@ -848,14 +848,14 @@ static int ioc3eth_probe(struct platform_device *pdev) · 847 unmodified lines
848	ip = netdev_priv(dev);	848	ip = netdev_priv(dev);
849	ip->dma_dev = pdev->dev.parent;	849	ip->dma_dev = pdev->dev.parent;
850	ip->regs = devm_platform_ioremap_resource(pdev, 0);	850	ip->regs = devm_platform_ioremap_resource(pdev, 0);
851	if (!ip->regs) {	851	if (IS_ERR(ip->regs)) {
852	err = -ENOMEM;	852	err = PTR_ERR(ip->regs);
853	goto out_free;	853	goto out_free;
854	}	854	}
855		855
856	ip->ssram = devm_platform_ioremap_resource(pdev, 1);	856	ip->ssram = devm_platform_ioremap_resource(pdev, 1);
857	if (!ip->ssram) {	857	if (IS_ERR(ip->ssram)) {
858	err = -ENOMEM;	858	err = PTR_ERR(ip->ssram);
859	goto out_free;	859	goto out_free;
860	}	860	}
861		861

drivers/net/ethernet/smsc/smsc911x.c+5−4

 	retval = smsc911x_init(dev);
 	if (retval < 0)
-		goto out_disable_resources;
+		goto out_init_fail;
 	netif_carrier_off(dev);
 	retval = smsc911x_mii_init(pdev, dev);
 	if (retval) {
 		SMSC_WARN(pdata, probe, "Error %i initialising mii", retval);
-		goto out_disable_resources;
+		goto out_init_fail;
 	}
 	retval = register_netdev(dev);
 	if (retval) {
 		SMSC_WARN(pdata, probe, "Error %i registering device", retval);
-		goto out_disable_resources;
+		goto out_init_fail;
 	} else {
 		SMSC_TRACE(pdata, probe,
 			   "Network interface: \"%s\"", dev->name);
 	return 0;
-out_disable_resources:
+out_init_fail:
 	pm_runtime_put(&pdev->dev);
 	pm_runtime_disable(&pdev->dev);
+out_disable_resources:
 	(void)smsc911x_disable_resources(pdev);
 out_enable_resources_fail:
 	smsc911x_free_resources(pdev);

drivers/net/ethernet/stmicro/stmmac/dwmac-ipq806x.c+13−0

@@ -319,6 +319,19 @@ static int ipq806x_gmac_probe(struct platform_device *pdev) · 318 unmodified lines
319	/* Enable PTP clock */	319	/* Enable PTP clock */
320	regmap_read(gmac->nss_common, NSS_COMMON_CLK_GATE, &val);	320	regmap_read(gmac->nss_common, NSS_COMMON_CLK_GATE, &val);
321	val \|= NSS_COMMON_CLK_GATE_PTP_EN(gmac->id);	321	val \|= NSS_COMMON_CLK_GATE_PTP_EN(gmac->id);
		322	switch (gmac->phy_mode) {
		323	case PHY_INTERFACE_MODE_RGMII:
		324	val \|= NSS_COMMON_CLK_GATE_RGMII_RX_EN(gmac->id) \|
		325	NSS_COMMON_CLK_GATE_RGMII_TX_EN(gmac->id);
		326	break;
		327	case PHY_INTERFACE_MODE_SGMII:
		328	val \|= NSS_COMMON_CLK_GATE_GMII_RX_EN(gmac->id) \|
		329	NSS_COMMON_CLK_GATE_GMII_TX_EN(gmac->id);
		330	break;
		331	default:
		332	/* We don't get here; the switch above will have errored out */
		333	unreachable();
		334	}
322	regmap_write(gmac->nss_common, NSS_COMMON_CLK_GATE, val);	335	regmap_write(gmac->nss_common, NSS_COMMON_CLK_GATE, val);
323		336
324	if (gmac->phy_mode == PHY_INTERFACE_MODE_SGMII) {	337	if (gmac->phy_mode == PHY_INTERFACE_MODE_SGMII) {

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c+2−2

 			return ret;
 	}
-	netif_device_attach(ndev);
 	mutex_lock(&priv->lock);
 	stmmac_reset_queues_param(priv);
 	phylink_mac_change(priv->phylink, true);
+	netif_device_attach(ndev);
 	return 0;
 }
 EXPORT_SYMBOL_GPL(stmmac_resume);

drivers/net/ethernet/sun/cassini.c+1−2

 					  cas_cacheline_size)) {
 			dev_err(&pdev->dev, "Could not set PCI cache "
 			       "line size\n");
-			goto err_write_cacheline;
+			goto err_out_free_res;
 		}
 	}
 #endif
 err_out_free_res:
 	pci_release_regions(pdev);
-err_write_cacheline:
 	/* Try to restore it in case the error occurred after we
 	 * set it.
 	 */

drivers/net/ethernet/ti/am65-cpsw-nuss.c+2−1

@@ -1895,8 +1895,9 @@ static int am65_cpsw_nuss_probe(struct platform_device *pdev) · 1894 unmodified lines
1895	ale_params.nu_switch_ale = true;	1895	ale_params.nu_switch_ale = true;
1896		1896
1897	common->ale = cpsw_ale_create(&ale_params);	1897	common->ale = cpsw_ale_create(&ale_params);
1898	if (!common->ale) {	1898	if (IS_ERR(common->ale)) {
1899	dev_err(dev, "error initializing ale engine\n");	1899	dev_err(dev, "error initializing ale engine\n");
		1900	ret = PTR_ERR(common->ale);
1900	goto err_of_clear;	1901	goto err_of_clear;
1901	}	1902	}
1902		1903

drivers/net/ethernet/ti/cpsw.c+4−0

 	struct cpsw_common *cpsw = dev_get_drvdata(dev);
 	int i;
+	rtnl_lock();
 	for (i = 0; i < cpsw->data.slaves; i++)
 		if (cpsw->slaves[i].ndev)
 			if (netif_running(cpsw->slaves[i].ndev))
 				cpsw_ndo_stop(cpsw->slaves[i].ndev);
+	rtnl_unlock();
 	/* Select sleep pin state */
 	pinctrl_pm_select_sleep_state(dev);

drivers/net/ethernet/ti/cpsw_ale.c+1−1

@@ -955,7 +955,7 @@ struct cpsw_ale cpsw_ale_create(struct cpsw_ale_params params) · 954 unmodified lines
955		955
956	ale = devm_kzalloc(params->dev, sizeof(*ale), GFP_KERNEL);	956	ale = devm_kzalloc(params->dev, sizeof(*ale), GFP_KERNEL);
957	if (!ale)	957	if (!ale)
958	return NULL;	958	return ERR_PTR(-ENOMEM);
959		959
960	ale->p0_untag_vid_mask =	960	ale->p0_untag_vid_mask =
961	devm_kmalloc_array(params->dev, BITS_TO_LONGS(VLAN_N_VID),	961	devm_kmalloc_array(params->dev, BITS_TO_LONGS(VLAN_N_VID),

drivers/net/ethernet/ti/cpsw_priv.c+2−2

@@ -490,9 +490,9 @@ int cpsw_init_common(struct cpsw_common cpsw, void __iomem ss_regs, · 489 unmodified lines
490	ale_params.ale_ports = CPSW_ALE_PORTS_NUM;	490	ale_params.ale_ports = CPSW_ALE_PORTS_NUM;
491		491
492	cpsw->ale = cpsw_ale_create(&ale_params);	492	cpsw->ale = cpsw_ale_create(&ale_params);
493	if (!cpsw->ale) {	493	if (IS_ERR(cpsw->ale)) {
494	dev_err(dev, "error initializing ale engine\n");	494	dev_err(dev, "error initializing ale engine\n");
495	return -ENODEV;	495	return PTR_ERR(cpsw->ale);
496	}	496	}
497		497
498	dma_params.dev = dev;	498	dma_params.dev = dev;

drivers/net/ethernet/ti/netcp_ethss.c+2−2

@@ -3704,9 +3704,9 @@ static int gbe_probe(struct netcp_device netcp_device, struct device dev, · 3703 unmodified lines
3704	ale_params.nu_switch_ale = true;	3704	ale_params.nu_switch_ale = true;
3705	}	3705	}
3706	gbe_dev->ale = cpsw_ale_create(&ale_params);	3706	gbe_dev->ale = cpsw_ale_create(&ale_params);
3707	if (!gbe_dev->ale) {	3707	if (IS_ERR(gbe_dev->ale)) {
3708	dev_err(gbe_dev->dev, "error initializing ale engine\n");	3708	dev_err(gbe_dev->dev, "error initializing ale engine\n");
3709	ret = -ENODEV;	3709	ret = PTR_ERR(gbe_dev->ale);
3710	goto free_sec_ports;	3710	goto free_sec_ports;
3711	} else {	3711	} else {
3712	dev_dbg(gbe_dev->dev, "Created a gbe ale engine\n");	3712	dev_dbg(gbe_dev->dev, "Created a gbe ale engine\n");

drivers/net/ipa/gsi.c+1−0

@@ -1392,6 +1392,7 @@ static int gsi_channel_poll(struct napi_struct *napi, int budget) · 1391 unmodified lines
1392	while (count < budget) {	1392	while (count < budget) {
1393	struct gsi_trans *trans;	1393	struct gsi_trans *trans;
1394		1394
		1395	count++;
1395	trans = gsi_channel_poll_one(channel);	1396	trans = gsi_channel_poll_one(channel);
1396	if (!trans)	1397	if (!trans)
1397	break;	1398	break;

drivers/net/netdevsim/dev.c+1−2

@@ -858,8 +858,7 @@ nsim_dev_devlink_trap_policer_counter_get(struct devlink *devlink, · 857 unmodified lines
858	return -EINVAL;	858	return -EINVAL;
859		859
860	cnt = &nsim_dev->trap_data->trap_policers_cnt_arr[policer->id - 1];	860	cnt = &nsim_dev->trap_data->trap_policers_cnt_arr[policer->id - 1];
861	p_drops = cnt;	861	p_drops = (cnt)++;
862	*cnt += jiffies % 64;
863		862
864	return 0;	863	return 0;
865	}	864	}

drivers/net/phy/mscc/mscc.h+2−0

 	u64 *stats;
 	int nstats;
 	bool pkg_init;
+	/* PHY address within the package. */
+	u8 addr;
 	/* For multiple port PHYs; the MDIO address of the base PHY in the
 	 * package.
 	 */

drivers/net/phy/mscc/mscc_mac.h+3−3

@@ -152,8 +152,8 @@ · 151 unmodified lines
152	#define MSCC_MAC_PAUSE_CFG_STATE_PAUSE_STATE BIT(0)	152	#define MSCC_MAC_PAUSE_CFG_STATE_PAUSE_STATE BIT(0)
153	#define MSCC_MAC_PAUSE_CFG_STATE_MAC_TX_PAUSE_GEN BIT(4)	153	#define MSCC_MAC_PAUSE_CFG_STATE_MAC_TX_PAUSE_GEN BIT(4)
154		154
155	#define MSCC_PROC_0_IP_1588_TOP_CFG_STAT_MODE_CTL 0x2	155	#define MSCC_PROC_IP_1588_TOP_CFG_STAT_MODE_CTL 0x2
156	#define MSCC_PROC_0_IP_1588_TOP_CFG_STAT_MODE_CTL_PROTOCOL_MODE(x) (x)	156	#define MSCC_PROC_IP_1588_TOP_CFG_STAT_MODE_CTL_PROTOCOL_MODE(x) (x)
157	#define MSCC_PROC_0_IP_1588_TOP_CFG_STAT_MODE_CTL_PROTOCOL_MODE_M GENMASK(2, 0)	157	#define MSCC_PROC_IP_1588_TOP_CFG_STAT_MODE_CTL_PROTOCOL_MODE_M GENMASK(2, 0)
158		158
159	#endif /* _MSCC_PHY_LINE_MAC_H_ */	159	#endif /* _MSCC_PHY_LINE_MAC_H_ */

drivers/net/phy/mscc/mscc_macsec.c+10−6

@@ -316,6 +316,8 @@ static void vsc8584_macsec_mac_init(struct phy_device *phydev, · 315 unmodified lines
316	/* Must be called with mdio_lock taken */	316	/* Must be called with mdio_lock taken */
317	static int __vsc8584_macsec_init(struct phy_device *phydev)	317	static int __vsc8584_macsec_init(struct phy_device *phydev)
318	{	318	{
		319	struct vsc8531_private *priv = phydev->priv;
		320	enum macsec_bank proc_bank;
319	u32 val;	321	u32 val;
320		322
321	vsc8584_macsec_block_init(phydev, MACSEC_INGR);	323	vsc8584_macsec_block_init(phydev, MACSEC_INGR);
@@ -351,12 +353,14 @@ static int __vsc8584_macsec_init(struct phy_device *phydev) · 29 unmodified lines
351	val \|= MSCC_FCBUF_ENA_CFG_TX_ENA \| MSCC_FCBUF_ENA_CFG_RX_ENA;	353	val \|= MSCC_FCBUF_ENA_CFG_TX_ENA \| MSCC_FCBUF_ENA_CFG_RX_ENA;
352	vsc8584_macsec_phy_write(phydev, FC_BUFFER, MSCC_FCBUF_ENA_CFG, val);	354	vsc8584_macsec_phy_write(phydev, FC_BUFFER, MSCC_FCBUF_ENA_CFG, val);
353		355
354	val = vsc8584_macsec_phy_read(phydev, IP_1588,	356	proc_bank = (priv->addr < 2) ? PROC_0 : PROC_2;
355	MSCC_PROC_0_IP_1588_TOP_CFG_STAT_MODE_CTL);	357
356	val &= ~MSCC_PROC_0_IP_1588_TOP_CFG_STAT_MODE_CTL_PROTOCOL_MODE_M;	358	val = vsc8584_macsec_phy_read(phydev, proc_bank,
357	val \|= MSCC_PROC_0_IP_1588_TOP_CFG_STAT_MODE_CTL_PROTOCOL_MODE(4);	359	MSCC_PROC_IP_1588_TOP_CFG_STAT_MODE_CTL);
358	vsc8584_macsec_phy_write(phydev, IP_1588,	360	val &= ~MSCC_PROC_IP_1588_TOP_CFG_STAT_MODE_CTL_PROTOCOL_MODE_M;
359	MSCC_PROC_0_IP_1588_TOP_CFG_STAT_MODE_CTL, val);	361	val \|= MSCC_PROC_IP_1588_TOP_CFG_STAT_MODE_CTL_PROTOCOL_MODE(4);
		362	vsc8584_macsec_phy_write(phydev, proc_bank,
		363	MSCC_PROC_IP_1588_TOP_CFG_STAT_MODE_CTL, val);
360		364
361	return 0;	365	return 0;
362	}	366	}

drivers/net/phy/mscc/mscc_macsec.h+2−1

 	FC_BUFFER   = 0x04,
 	HOST_MAC    = 0x05,
 	LINE_MAC    = 0x06,
-	IP_1588     = 0x0e,
+	PROC_0      = 0x0e,
+	PROC_2      = 0x0f,
 	MACSEC_INGR = 0x38,
 	MACSEC_EGR  = 0x3c,
 };

drivers/net/phy/mscc/mscc_main.c+4−0

 	else
 		vsc8531->base_addr = phydev->mdio.addr - addr;
+	vsc8531->addr = addr;
 	/* Some parts of the init sequence are identical for every PHY in the
 	 * package. Some parts are modifying the GPIO register bank which is a
 	 * set of registers that are affecting all PHYs, a few resetting the
 	else
 		vsc8531->base_addr = phydev->mdio.addr - addr;
+	vsc8531->addr = addr;
 	/* Some parts of the init sequence are identical for every PHY in the
 	 * package. Some parts are modifying the GPIO register bank which is a
 	 * set of registers that are affecting all PHYs, a few resetting the

drivers/net/phy/phy_device.c+2−2

@@ -1233,7 +1233,7 @@ int phy_sfp_probe(struct phy_device *phydev, · 1232 unmodified lines
1233	const struct sfp_upstream_ops *ops)	1233	const struct sfp_upstream_ops *ops)
1234	{	1234	{
1235	struct sfp_bus *bus;	1235	struct sfp_bus *bus;
1236	int ret;	1236	int ret = 0;
1237		1237
1238	if (phydev->mdio.dev.fwnode) {	1238	if (phydev->mdio.dev.fwnode) {
1239	bus = sfp_bus_find_fwnode(phydev->mdio.dev.fwnode);	1239	bus = sfp_bus_find_fwnode(phydev->mdio.dev.fwnode);
@@ -1245,7 +1245,7 @@ int phy_sfp_probe(struct phy_device *phydev, · 5 unmodified lines
1245	ret = sfp_bus_add_upstream(bus, phydev, ops);	1245	ret = sfp_bus_add_upstream(bus, phydev, ops);
1246	sfp_bus_put(bus);	1246	sfp_bus_put(bus);
1247	}	1247	}
1248	return 0;	1248	return ret;
1249	}	1249	}
1250	EXPORT_SYMBOL(phy_sfp_probe);	1250	EXPORT_SYMBOL(phy_sfp_probe);
1251		1251

drivers/net/usb/cdc_ether.c+9−2

 	.driver_info = 0,
 },
-/* Microsoft Surface 3 dock (based on Realtek RTL8153) */
+/* Microsoft Surface Ethernet Adapter (based on Realtek RTL8153) */
 {
 	USB_DEVICE_AND_INTERFACE_INFO(MICROSOFT_VENDOR_ID, 0x07c6, USB_CLASS_COMM,
 			USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
 	.driver_info = 0,
 },
-	/* TP-LINK UE300 USB 3.0 Ethernet Adapters (based on Realtek RTL8153) */
+/* Microsoft Surface Ethernet Adapter (based on Realtek RTL8153B) */
+{
+	USB_DEVICE_AND_INTERFACE_INFO(MICROSOFT_VENDOR_ID, 0x0927, USB_CLASS_COMM,
+			USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),
+	.driver_info = 0,
+},
+/* TP-LINK UE300 USB 3.0 Ethernet Adapters (based on Realtek RTL8153) */
 {
 	USB_DEVICE_AND_INTERFACE_INFO(TPLINK_VENDOR_ID, 0x0601, USB_CLASS_COMM,
 			USB_CDC_SUBCLASS_ETHERNET, USB_CDC_PROTO_NONE),

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

@@ -6880,6 +6880,7 @@ static const struct usb_device_id rtl8152_table[] = { · 6879 unmodified lines
6880	{REALTEK_USB_DEVICE(VENDOR_ID_REALTEK, 0x8153)},	6880	{REALTEK_USB_DEVICE(VENDOR_ID_REALTEK, 0x8153)},
6881	{REALTEK_USB_DEVICE(VENDOR_ID_MICROSOFT, 0x07ab)},	6881	{REALTEK_USB_DEVICE(VENDOR_ID_MICROSOFT, 0x07ab)},
6882	{REALTEK_USB_DEVICE(VENDOR_ID_MICROSOFT, 0x07c6)},	6882	{REALTEK_USB_DEVICE(VENDOR_ID_MICROSOFT, 0x07c6)},
		6883	{REALTEK_USB_DEVICE(VENDOR_ID_MICROSOFT, 0x0927)},
6883	{REALTEK_USB_DEVICE(VENDOR_ID_SAMSUNG, 0xa101)},	6884	{REALTEK_USB_DEVICE(VENDOR_ID_SAMSUNG, 0xa101)},
6884	{REALTEK_USB_DEVICE(VENDOR_ID_LENOVO, 0x304f)},	6885	{REALTEK_USB_DEVICE(VENDOR_ID_LENOVO, 0x304f)},
6885	{REALTEK_USB_DEVICE(VENDOR_ID_LENOVO, 0x3062)},	6886	{REALTEK_USB_DEVICE(VENDOR_ID_LENOVO, 0x3062)},

drivers/net/wireguard/messages.h+1−1

@@ -32,7 +32,7 @@ enum cookie_values { · 31 unmodified lines
32	};	32	};
33		33
34	enum counter_values {	34	enum counter_values {
35	COUNTER_BITS_TOTAL = 2048,	35	COUNTER_BITS_TOTAL = 8192,
36	COUNTER_REDUNDANT_BITS = BITS_PER_LONG,	36	COUNTER_REDUNDANT_BITS = BITS_PER_LONG,
37	COUNTER_WINDOW_SIZE = COUNTER_BITS_TOTAL - COUNTER_REDUNDANT_BITS	37	COUNTER_WINDOW_SIZE = COUNTER_BITS_TOTAL - COUNTER_REDUNDANT_BITS
38	};	38	};

drivers/net/wireguard/noise.c+9−13

 	if (unlikely(!keypair))
 		return NULL;
+	spin_lock_init(&keypair->receiving_counter.lock);
 	keypair->internal_id = atomic64_inc_return(&keypair_counter);
 	keypair->entry.type = INDEX_HASHTABLE_KEYPAIR;
 	keypair->entry.peer = peer;
 	memzero_explicit(output, BLAKE2S_HASH_SIZE + 1);
 }
-static void symmetric_key_init(struct noise_symmetric_key *key)
-{
-	spin_lock_init(&key->counter.receive.lock);
-	atomic64_set(&key->counter.counter, 0);
-	memset(key->counter.receive.backtrack, 0,
-	       sizeof(key->counter.receive.backtrack));
-	key->birthdate = ktime_get_coarse_boottime_ns();
-	key->is_valid = true;
-}
 static void derive_keys(struct noise_symmetric_key *first_dst,
 			struct noise_symmetric_key *second_dst,
 			const u8 chaining_key[NOISE_HASH_LEN])
 {
+	u64 birthdate = ktime_get_coarse_boottime_ns();
 	kdf(first_dst->key, second_dst->key, NULL, NULL,
 	    NOISE_SYMMETRIC_KEY_LEN, NOISE_SYMMETRIC_KEY_LEN, 0, 0,
 	    chaining_key);
-	symmetric_key_init(first_dst);
+	first_dst->birthdate = second_dst->birthdate = birthdate;
-	symmetric_key_init(second_dst);
+	first_dst->is_valid = second_dst->is_valid = true;
 }
 static bool __must_check mix_dh(u8 chaining_key[NOISE_HASH_LEN],
 	u8 e[NOISE_PUBLIC_KEY_LEN];
 	u8 ephemeral_private[NOISE_PUBLIC_KEY_LEN];
 	u8 static_private[NOISE_PUBLIC_KEY_LEN];
+	u8 preshared_key[NOISE_SYMMETRIC_KEY_LEN];
 	down_read(&wg->static_identity.lock);
 	memcpy(chaining_key, handshake->chaining_key, NOISE_HASH_LEN);
 	memcpy(ephemeral_private, handshake->ephemeral_private,
 	       NOISE_PUBLIC_KEY_LEN);
+	memcpy(preshared_key, handshake->preshared_key,
+	       NOISE_SYMMETRIC_KEY_LEN);
 	up_read(&handshake->lock);
 	if (state != HANDSHAKE_CREATED_INITIATION)
 		goto fail;
 	/* psk */
-	mix_psk(chaining_key, hash, key, handshake->preshared_key);
+	mix_psk(chaining_key, hash, key, preshared_key);
 	/* {} */
 	if (!message_decrypt(NULL, src->encrypted_nothing,
 	memzero_explicit(chaining_key, NOISE_HASH_LEN);
 	memzero_explicit(ephemeral_private, NOISE_PUBLIC_KEY_LEN);
 	memzero_explicit(static_private, NOISE_PUBLIC_KEY_LEN);
+	memzero_explicit(preshared_key, NOISE_SYMMETRIC_KEY_LEN);
 	up_read(&wg->static_identity.lock);
 	return ret_peer;
 }

drivers/net/wireguard/noise.h+6−8

 #include <linux/mutex.h>
 #include <linux/kref.h>
-union noise_counter {
+struct noise_replay_counter {
-	struct {
+	u64 counter;
-		u64 counter;
+	spinlock_t lock;
-		unsigned long backtrack[COUNTER_BITS_TOTAL / BITS_PER_LONG];
+	unsigned long backtrack[COUNTER_BITS_TOTAL / BITS_PER_LONG];
-		spinlock_t lock;
-	} receive;
-	atomic64_t counter;
 };
 struct noise_symmetric_key {
 	u8 key[NOISE_SYMMETRIC_KEY_LEN];
-	union noise_counter counter;
 	u64 birthdate;
 	bool is_valid;
 };
 struct noise_keypair {
 	struct index_hashtable_entry entry;
 	struct noise_symmetric_key sending;
+	atomic64_t sending_counter;
 	struct noise_symmetric_key receiving;
+	struct noise_replay_counter receiving_counter;
 	__le32 remote_index;
 	bool i_am_the_initiator;
 	struct kref refcount;

drivers/net/wireguard/queueing.h+9−1

 	return real_protocol && skb->protocol == real_protocol;
 }
-static inline void wg_reset_packet(struct sk_buff *skb)
+static inline void wg_reset_packet(struct sk_buff *skb, bool encapsulating)
 {
+	u8 l4_hash = skb->l4_hash;
+	u8 sw_hash = skb->sw_hash;
+	u32 hash = skb->hash;
 	skb_scrub_packet(skb, true);
 	memset(&skb->headers_start, 0,
 	       offsetof(struct sk_buff, headers_end) -
 		       offsetof(struct sk_buff, headers_start));
+	if (encapsulating) {
+		skb->l4_hash = l4_hash;
+		skb->sw_hash = sw_hash;
+		skb->hash = hash;
+	}
 	skb->queue_mapping = 0;
 	skb->nohdr = 0;
 	skb->peeked = 0;

drivers/net/wireguard/receive.c+22−22

@@ -245,20 +245,20 @@ static void keep_key_fresh(struct wg_peer *peer) · 244 unmodified lines
245	}	245	}
246	}	246	}
247		247
248	static bool decrypt_packet(struct sk_buff skb, struct noise_symmetric_key key)	248	static bool decrypt_packet(struct sk_buff skb, struct noise_keypair keypair)
249	{	249	{
250	struct scatterlist sg[MAX_SKB_FRAGS + 8];	250	struct scatterlist sg[MAX_SKB_FRAGS + 8];
251	struct sk_buff *trailer;	251	struct sk_buff *trailer;
252	unsigned int offset;	252	unsigned int offset;
253	int num_frags;	253	int num_frags;
254		254
255	if (unlikely(!key))	255	if (unlikely(!keypair))
256	return false;	256	return false;
257		257
258	if (unlikely(!READ_ONCE(key->is_valid) \|\|	258	if (unlikely(!READ_ONCE(keypair->receiving.is_valid) \|\|
259	wg_birthdate_has_expired(key->birthdate, REJECT_AFTER_TIME) \|\|	259	wg_birthdate_has_expired(keypair->receiving.birthdate, REJECT_AFTER_TIME) \|\|
260	key->counter.receive.counter >= REJECT_AFTER_MESSAGES)) {	260	keypair->receiving_counter.counter >= REJECT_AFTER_MESSAGES)) {
261	WRITE_ONCE(key->is_valid, false);	261	WRITE_ONCE(keypair->receiving.is_valid, false);
262	return false;	262	return false;
263	}	263	}
264		264
@@ -283,7 +283,7 @@ static bool decrypt_packet(struct sk_buff skb, struct noise_symmetric_key key) · 18 unmodified lines
283		283
284	if (!chacha20poly1305_decrypt_sg_inplace(sg, skb->len, NULL, 0,	284	if (!chacha20poly1305_decrypt_sg_inplace(sg, skb->len, NULL, 0,
285	PACKET_CB(skb)->nonce,	285	PACKET_CB(skb)->nonce,
286	key->key))	286	keypair->receiving.key))
287	return false;	287	return false;
288		288
289	/* Another ugly situation of pushing and pulling the header so as to	289	/* Another ugly situation of pushing and pulling the header so as to
@@ -298,41 +298,41 @@ static bool decrypt_packet(struct sk_buff skb, struct noise_symmetric_key key) · 8 unmodified lines
298	}	298	}
299		299
300	/* This is RFC6479, a replay detection bitmap algorithm that avoids bitshifts */	300	/* This is RFC6479, a replay detection bitmap algorithm that avoids bitshifts */
301	static bool counter_validate(union noise_counter *counter, u64 their_counter)	301	static bool counter_validate(struct noise_replay_counter *counter, u64 their_counter)
302	{	302	{
303	unsigned long index, index_current, top, i;	303	unsigned long index, index_current, top, i;
304	bool ret = false;	304	bool ret = false;
305		305
306	spin_lock_bh(&counter->receive.lock);	306	spin_lock_bh(&counter->lock);
307		307
308	if (unlikely(counter->receive.counter >= REJECT_AFTER_MESSAGES + 1 \|\|	308	if (unlikely(counter->counter >= REJECT_AFTER_MESSAGES + 1 \|\|
309	their_counter >= REJECT_AFTER_MESSAGES))	309	their_counter >= REJECT_AFTER_MESSAGES))
310	goto out;	310	goto out;
311		311
312	++their_counter;	312	++their_counter;
313		313
314	if (unlikely((COUNTER_WINDOW_SIZE + their_counter) <	314	if (unlikely((COUNTER_WINDOW_SIZE + their_counter) <
315	counter->receive.counter))	315	counter->counter))
316	goto out;	316	goto out;
317		317
318	index = their_counter >> ilog2(BITS_PER_LONG);	318	index = their_counter >> ilog2(BITS_PER_LONG);
319		319
320	if (likely(their_counter > counter->receive.counter)) {	320	if (likely(their_counter > counter->counter)) {
321	index_current = counter->receive.counter >> ilog2(BITS_PER_LONG);	321	index_current = counter->counter >> ilog2(BITS_PER_LONG);
322	top = min_t(unsigned long, index - index_current,	322	top = min_t(unsigned long, index - index_current,
323	COUNTER_BITS_TOTAL / BITS_PER_LONG);	323	COUNTER_BITS_TOTAL / BITS_PER_LONG);
324	for (i = 1; i <= top; ++i)	324	for (i = 1; i <= top; ++i)
325	counter->receive.backtrack[(i + index_current) &	325	counter->backtrack[(i + index_current) &
326	((COUNTER_BITS_TOTAL / BITS_PER_LONG) - 1)] = 0;	326	((COUNTER_BITS_TOTAL / BITS_PER_LONG) - 1)] = 0;
327	counter->receive.counter = their_counter;	327	counter->counter = their_counter;
328	}	328	}
329		329
330	index &= (COUNTER_BITS_TOTAL / BITS_PER_LONG) - 1;	330	index &= (COUNTER_BITS_TOTAL / BITS_PER_LONG) - 1;
331	ret = !test_and_set_bit(their_counter & (BITS_PER_LONG - 1),	331	ret = !test_and_set_bit(their_counter & (BITS_PER_LONG - 1),
332	&counter->receive.backtrack[index]);	332	&counter->backtrack[index]);
333		333
334	out:	334	out:
335	spin_unlock_bh(&counter->receive.lock);	335	spin_unlock_bh(&counter->lock);
336	return ret;	336	return ret;
337	}	337	}
338		338
@@ -472,19 +472,19 @@ int wg_packet_rx_poll(struct napi_struct *napi, int budget) · 133 unmodified lines
472	if (unlikely(state != PACKET_STATE_CRYPTED))	472	if (unlikely(state != PACKET_STATE_CRYPTED))
473	goto next;	473	goto next;
474		474
475	if (unlikely(!counter_validate(&keypair->receiving.counter,	475	if (unlikely(!counter_validate(&keypair->receiving_counter,
476	PACKET_CB(skb)->nonce))) {	476	PACKET_CB(skb)->nonce))) {
477	net_dbg_ratelimited("%s: Packet has invalid nonce %llu (max %llu)\n",	477	net_dbg_ratelimited("%s: Packet has invalid nonce %llu (max %llu)\n",
478	peer->device->dev->name,	478	peer->device->dev->name,
479	PACKET_CB(skb)->nonce,	479	PACKET_CB(skb)->nonce,
480	keypair->receiving.counter.receive.counter);	480	keypair->receiving_counter.counter);
481	goto next;	481	goto next;
482	}	482	}
483		483
484	if (unlikely(wg_socket_endpoint_from_skb(&endpoint, skb)))	484	if (unlikely(wg_socket_endpoint_from_skb(&endpoint, skb)))
485	goto next;	485	goto next;
486		486
487	wg_reset_packet(skb);	487	wg_reset_packet(skb, false);
488	wg_packet_consume_data_done(peer, skb, &endpoint);	488	wg_packet_consume_data_done(peer, skb, &endpoint);
489	free = false;	489	free = false;
490		490
@@ -511,8 +511,8 @@ void wg_packet_decrypt_worker(struct work_struct *work) · 20 unmodified lines
511	struct sk_buff *skb;	511	struct sk_buff *skb;
512		512
513	while ((skb = ptr_ring_consume_bh(&queue->ring)) != NULL) {	513	while ((skb = ptr_ring_consume_bh(&queue->ring)) != NULL) {
514	enum packet_state state = likely(decrypt_packet(skb,	514	enum packet_state state =
515	&PACKET_CB(skb)->keypair->receiving)) ?	515	likely(decrypt_packet(skb, PACKET_CB(skb)->keypair)) ?
516	PACKET_STATE_CRYPTED : PACKET_STATE_DEAD;	516	PACKET_STATE_CRYPTED : PACKET_STATE_DEAD;
517	wg_queue_enqueue_per_peer_napi(skb, state);	517	wg_queue_enqueue_per_peer_napi(skb, state);
518	if (need_resched())	518	if (need_resched())

drivers/net/wireguard/selftest/counter.c+12−5

 #ifdef DEBUG
 bool __init wg_packet_counter_selftest(void)
 {
+	struct noise_replay_counter *counter;
 	unsigned int test_num = 0, i;
-	union noise_counter counter;
 	bool success = true;
-#define T_INIT do {                                               \
+	counter = kmalloc(sizeof(*counter), GFP_KERNEL);
-		memset(&counter, 0, sizeof(union noise_counter)); \
+	if (unlikely(!counter)) {
-		spin_lock_init(&counter.receive.lock);            \
+		pr_err("nonce counter self-test malloc: FAIL\n");
+		return false;
+	}
+#define T_INIT do {                                    \
+		memset(counter, 0, sizeof(*counter));  \
+		spin_lock_init(&counter->lock);        \
 	} while (0)
 #define T_LIM (COUNTER_WINDOW_SIZE + 1)
 #define T(n, v) do {                                                  \
 		++test_num;                                           \
-		if (counter_validate(&counter, n) != (v)) {           \
+		if (counter_validate(counter, n) != (v)) {            \
 			pr_err("nonce counter self-test %u: FAIL\n",  \
 			       test_num);                             \
 			success = false;                              \
 	if (success)
 		pr_info("nonce counter self-tests: pass\n");
+	kfree(counter);
 	return success;
 }
 #endif

drivers/net/wireguard/send.c+11−8

 	rcu_read_lock_bh();
 	keypair = rcu_dereference_bh(peer->keypairs.current_keypair);
 	send = keypair && READ_ONCE(keypair->sending.is_valid) &&
-	       (atomic64_read(&keypair->sending.counter.counter) > REKEY_AFTER_MESSAGES ||
+	       (atomic64_read(&keypair->sending_counter) > REKEY_AFTER_MESSAGES ||
 		(keypair->i_am_the_initiator &&
 		 wg_birthdate_has_expired(keypair->sending.birthdate, REKEY_AFTER_TIME)));
 	rcu_read_unlock_bh();
 	struct sk_buff *trailer;
 	int num_frags;
+	/* Force hash calculation before encryption so that flow analysis is
+	 * consistent over the inner packet.
+	 */
+	skb_get_hash(skb);
 	/* Calculate lengths. */
 	padding_len = calculate_skb_padding(skb);
 	trailer_len = padding_len + noise_encrypted_len(0);
 		skb_list_walk_safe(first, skb, next) {
 			if (likely(encrypt_packet(skb,
 					PACKET_CB(first)->keypair))) {
-				wg_reset_packet(skb);
+				wg_reset_packet(skb, true);
 			} else {
 				state = PACKET_STATE_DEAD;
 				break;
 void wg_packet_send_staged_packets(struct wg_peer *peer)
 {
-	struct noise_symmetric_key *key;
 	struct noise_keypair *keypair;
 	struct sk_buff_head packets;
 	struct sk_buff *skb;
 	rcu_read_unlock_bh();
 	if (unlikely(!keypair))
 		goto out_nokey;
-	key = &keypair->sending;
+	if (unlikely(!READ_ONCE(keypair->sending.is_valid)))
-	if (unlikely(!READ_ONCE(key->is_valid)))
 		goto out_nokey;
-	if (unlikely(wg_birthdate_has_expired(key->birthdate,
+	if (unlikely(wg_birthdate_has_expired(keypair->sending.birthdate,
 					      REJECT_AFTER_TIME)))
 		goto out_invalid;
 		 */
 		PACKET_CB(skb)->ds = ip_tunnel_ecn_encap(0, ip_hdr(skb), skb);
 		PACKET_CB(skb)->nonce =
-				atomic64_inc_return(&key->counter.counter) - 1;
+				atomic64_inc_return(&keypair->sending_counter) - 1;
 		if (unlikely(PACKET_CB(skb)->nonce >= REJECT_AFTER_MESSAGES))
 			goto out_invalid;
 	}
 	return;
 out_invalid:
-	WRITE_ONCE(key->is_valid, false);
+	WRITE_ONCE(keypair->sending.is_valid, false);
 out_nokey:
 	wg_noise_keypair_put(keypair, false);

drivers/net/wireless/intel/iwlwifi/pcie/drv.c+4−0

 			iwl_trans->cfg = &iwl_ax101_cfg_quz_hr;
 		else if (iwl_trans->cfg == &iwl_ax201_cfg_qu_hr)
 			iwl_trans->cfg = &iwl_ax201_cfg_quz_hr;
+		else if (iwl_trans->cfg == &killer1650s_2ax_cfg_qu_b0_hr_b0)
+			iwl_trans->cfg = &iwl_ax1650s_cfg_quz_hr;
+		else if (iwl_trans->cfg == &killer1650i_2ax_cfg_qu_b0_hr_b0)
+			iwl_trans->cfg = &iwl_ax1650i_cfg_quz_hr;
 	}
 #endif

fs/afs/fs_probe.c+5−13

 	struct afs_server *server = call->server;
 	unsigned int server_index = call->server_index;
 	unsigned int index = call->addr_ix;
-	unsigned int rtt = UINT_MAX;
+	unsigned int rtt_us = 0;
 	bool have_result = false;
-	u64 _rtt;
 	int ret = call->error;
 	_enter("%pU,%u", &server->uuid, index);
 		}
 	}
-	/* Get the RTT and scale it to fit into a 32-bit value that represents
+	rtt_us = rxrpc_kernel_get_srtt(call->net->socket, call->rxcall);
-	 * over a minute of time so that we can access it with one instruction
+	if (rtt_us < server->probe.rtt) {
-	 * on a 32-bit system.
+		server->probe.rtt = rtt_us;
-	 */
-	_rtt = rxrpc_kernel_get_rtt(call->net->socket, call->rxcall);
-	_rtt /= 64;
-	rtt = (_rtt > UINT_MAX) ? UINT_MAX : _rtt;
-	if (rtt < server->probe.rtt) {
-		server->probe.rtt = rtt;
 		alist->preferred = index;
 		have_result = true;
 	}
 	spin_unlock(&server->probe_lock);
 	_debug("probe [%u][%u] %pISpc rtt=%u ret=%d",
-	       server_index, index, &alist->addrs[index].transport,
+	       server_index, index, &alist->addrs[index].transport, rtt_us, ret);
-	       (unsigned int)rtt, ret);
 	have_result |= afs_fs_probe_done(server);
 	if (have_result)

fs/afs/vl_probe.c+5−13

 	struct afs_addr_list *alist = call->alist;
 	struct afs_vlserver *server = call->vlserver;
 	unsigned int server_index = call->server_index;
+	unsigned int rtt_us = 0;
 	unsigned int index = call->addr_ix;
-	unsigned int rtt = UINT_MAX;
 	bool have_result = false;
-	u64 _rtt;
 	int ret = call->error;
 	_enter("%s,%u,%u,%d,%d", server->name, server_index, index, ret, call->abort_code);
 		}
 	}
-	/* Get the RTT and scale it to fit into a 32-bit value that represents
+	rtt_us = rxrpc_kernel_get_srtt(call->net->socket, call->rxcall);
-	 * over a minute of time so that we can access it with one instruction
+	if (rtt_us < server->probe.rtt) {
-	 * on a 32-bit system.
+		server->probe.rtt = rtt_us;
-	 */
-	_rtt = rxrpc_kernel_get_rtt(call->net->socket, call->rxcall);
-	_rtt /= 64;
-	rtt = (_rtt > UINT_MAX) ? UINT_MAX : _rtt;
-	if (rtt < server->probe.rtt) {
-		server->probe.rtt = rtt;
 		alist->preferred = index;
 		have_result = true;
 	}
 	spin_unlock(&server->probe_lock);
 	_debug("probe [%u][%u] %pISpc rtt=%u ret=%d",
-	       server_index, index, &alist->addrs[index].transport,
+	       server_index, index, &alist->addrs[index].transport, rtt_us, ret);
-	       (unsigned int)rtt, ret);
 	have_result |= afs_vl_probe_done(server);
 	if (have_result) {

include/linux/mlx5/driver.h+16−0

 	MLX5_PORT_DOWN      = 2,
 };
+enum mlx5_cmdif_state {
+	MLX5_CMDIF_STATE_UNINITIALIZED,
+	MLX5_CMDIF_STATE_UP,
+	MLX5_CMDIF_STATE_DOWN,
+};
 struct mlx5_cmd_first {
 	__be32		data[4];
 };
 struct mlx5_cmd {
 	struct mlx5_nb    nb;
+	enum mlx5_cmdif_state	state;
 	void	       *cmd_alloc_buf;
 	dma_addr_t	alloc_dma;
 	int		alloc_size;
 	struct semaphore sem;
 	struct semaphore pages_sem;
 	int	mode;
+	u16     allowed_opcode;
 	struct mlx5_cmd_work_ent *ent_arr[MLX5_MAX_COMMANDS];
 	struct dma_pool *pool;
 	struct mlx5_cmd_debug dbg;
 	struct delayed_work	cb_timeout_work;
 	void		       *context;
 	int			idx;
+	struct completion	handling;
 	struct completion	done;
 	struct mlx5_cmd        *cmd;
 	struct work_struct	work;
 	return min_t(u32, last_frag_stride_idx - fbc->strides_offset, fbc->sz_m1);
 }
+enum {
+	CMD_ALLOWED_OPCODE_ALL,
+};
 int mlx5_cmd_init(struct mlx5_core_dev *dev);
 void mlx5_cmd_cleanup(struct mlx5_core_dev *dev);
+void mlx5_cmd_set_state(struct mlx5_core_dev *dev,
+			enum mlx5_cmdif_state cmdif_state);
 void mlx5_cmd_use_events(struct mlx5_core_dev *dev);
 void mlx5_cmd_use_polling(struct mlx5_core_dev *dev);
+void mlx5_cmd_allowed_opcode(struct mlx5_core_dev *dev, u16 opcode);
 struct mlx5_async_ctx {
 	struct mlx5_core_dev *dev;

include/net/act_api.h+2−1

@@ -75,7 +75,8 @@ static inline void tcf_tm_dump(struct tcf_t dtm, const struct tcf_t stm) · 74 unmodified lines
75	{	75	{
76	dtm->install = jiffies_to_clock_t(jiffies - stm->install);	76	dtm->install = jiffies_to_clock_t(jiffies - stm->install);
77	dtm->lastuse = jiffies_to_clock_t(jiffies - stm->lastuse);	77	dtm->lastuse = jiffies_to_clock_t(jiffies - stm->lastuse);
78	dtm->firstuse = jiffies_to_clock_t(jiffies - stm->firstuse);	78	dtm->firstuse = stm->firstuse ?
		79	jiffies_to_clock_t(jiffies - stm->firstuse) : 0;
79	dtm->expires = jiffies_to_clock_t(stm->expires);	80	dtm->expires = jiffies_to_clock_t(stm->expires);
80	}	81	}
81		82

include/net/af_rxrpc.h+1−1

@@ -59,7 +59,7 @@ bool rxrpc_kernel_abort_call(struct socket , struct rxrpc_call , · 58 unmodified lines
59	void rxrpc_kernel_end_call(struct socket , struct rxrpc_call );	59	void rxrpc_kernel_end_call(struct socket , struct rxrpc_call );
60	void rxrpc_kernel_get_peer(struct socket , struct rxrpc_call ,	60	void rxrpc_kernel_get_peer(struct socket , struct rxrpc_call ,
61	struct sockaddr_rxrpc *);	61	struct sockaddr_rxrpc *);
62	u64 rxrpc_kernel_get_rtt(struct socket , struct rxrpc_call );	62	u32 rxrpc_kernel_get_srtt(struct socket , struct rxrpc_call );
63	int rxrpc_kernel_charge_accept(struct socket *, rxrpc_notify_rx_t,	63	int rxrpc_kernel_charge_accept(struct socket *, rxrpc_notify_rx_t,
64	rxrpc_user_attach_call_t, unsigned long, gfp_t,	64	rxrpc_user_attach_call_t, unsigned long, gfp_t,
65	unsigned int);	65	unsigned int);

include/net/ip_fib.h+0−1

@@ -257,7 +257,6 @@ struct fib_dump_filter { · 256 unmodified lines
257	u32 table_id;	257	u32 table_id;
258	/* filter_set is an optimization that an entry is set */	258	/* filter_set is an optimization that an entry is set */
259	bool filter_set;	259	bool filter_set;
260	bool dump_all_families;
261	bool dump_routes;	260	bool dump_routes;
262	bool dump_exceptions;	261	bool dump_exceptions;
263	unsigned char protocol;	262	unsigned char protocol;

include/trace/events/rxrpc.h+42−10

 TRACE_EVENT(rxrpc_rtt_rx,
 	    TP_PROTO(struct rxrpc_call *call, enum rxrpc_rtt_rx_trace why,
 		     rxrpc_serial_t send_serial, rxrpc_serial_t resp_serial,
-		     s64 rtt, u8 nr, s64 avg),
+		     u32 rtt, u32 rto),
-	    TP_ARGS(call, why, send_serial, resp_serial, rtt, nr, avg),
+	    TP_ARGS(call, why, send_serial, resp_serial, rtt, rto),
 	    TP_STRUCT__entry(
 		    __field(unsigned int,		call		)
 		    __field(enum rxrpc_rtt_rx_trace,	why		)
-		    __field(u8,				nr		)
 		    __field(rxrpc_serial_t,		send_serial	)
 		    __field(rxrpc_serial_t,		resp_serial	)
-		    __field(s64,			rtt		)
+		    __field(u32,			rtt		)
-		    __field(u64,			avg		)
+		    __field(u32,			rto		)
 			     ),
 	    TP_fast_assign(
 		    __entry->send_serial = send_serial;
 		    __entry->resp_serial = resp_serial;
 		    __entry->rtt = rtt;
-		    __entry->nr = nr;
+		    __entry->rto = rto;
-		    __entry->avg = avg;
 			   ),
-	    TP_printk("c=%08x %s sr=%08x rr=%08x rtt=%lld nr=%u avg=%lld",
+	    TP_printk("c=%08x %s sr=%08x rr=%08x rtt=%u rto=%u",
 		      __entry->call,
 		      __print_symbolic(__entry->why, rxrpc_rtt_rx_traces),
 		      __entry->send_serial,
 		      __entry->resp_serial,
 		      __entry->rtt,
-		      __entry->nr,
+		      __entry->rto)
-		      __entry->avg)
 	    );
 TRACE_EVENT(rxrpc_timer,
 		      __entry->serial)
 	    );
+TRACE_EVENT(rxrpc_rx_discard_ack,
+	    TP_PROTO(unsigned int debug_id, rxrpc_serial_t serial,
+		     rxrpc_seq_t first_soft_ack, rxrpc_seq_t call_ackr_first,
+		     rxrpc_seq_t prev_pkt, rxrpc_seq_t call_ackr_prev),
+	    TP_ARGS(debug_id, serial, first_soft_ack, call_ackr_first,
+		    prev_pkt, call_ackr_prev),
+	    TP_STRUCT__entry(
+		    __field(unsigned int,	debug_id	)
+		    __field(rxrpc_serial_t,	serial		)
+		    __field(rxrpc_seq_t,	first_soft_ack)
+		    __field(rxrpc_seq_t,	call_ackr_first)
+		    __field(rxrpc_seq_t,	prev_pkt)
+		    __field(rxrpc_seq_t,	call_ackr_prev)
+			     ),
+	    TP_fast_assign(
+		    __entry->debug_id		= debug_id;
+		    __entry->serial		= serial;
+		    __entry->first_soft_ack	= first_soft_ack;
+		    __entry->call_ackr_first	= call_ackr_first;
+		    __entry->prev_pkt		= prev_pkt;
+		    __entry->call_ackr_prev	= call_ackr_prev;
+			   ),
+	    TP_printk("c=%08x r=%08x %08x<%08x %08x<%08x",
+		      __entry->debug_id,
+		      __entry->serial,
+		      __entry->first_soft_ack,
+		      __entry->call_ackr_first,
+		      __entry->prev_pkt,
+		      __entry->call_ackr_prev)
+	    );
 #endif /* _TRACE_RXRPC_H */
 /* This part must be outside protection */

kernel/bpf/syscall.c+14−3

@@ -623,9 +623,20 @@ static int bpf_map_mmap(struct file filp, struct vm_area_struct vma) · 622 unmodified lines
623		623
624	mutex_lock(&map->freeze_mutex);	624	mutex_lock(&map->freeze_mutex);
625		625
626	if ((vma->vm_flags & VM_WRITE) && map->frozen) {	626	if (vma->vm_flags & VM_WRITE) {
627	err = -EPERM;	627	if (map->frozen) {
628	goto out;	628	err = -EPERM;
		629	goto out;
		630	}
		631	/* map is meant to be read-only, so do not allow mapping as
		632	* writable, because it's possible to leak a writable page
		633	* reference and allows user-space to still modify it after
		634	* freezing, while verifier will assume contents do not change
		635	*/
		636	if (map->map_flags & BPF_F_RDONLY_PROG) {
		637	err = -EACCES;
		638	goto out;
		639	}
629	}	640	}
630		641
631	/* set default open/close callbacks */	642	/* set default open/close callbacks */

net/ax25/af_ax25.c+4−2

@@ -635,8 +635,10 @@ static int ax25_setsockopt(struct socket *sock, int level, int optname, · 634 unmodified lines
635	break;	635	break;
636		636
637	case SO_BINDTODEVICE:	637	case SO_BINDTODEVICE:
638	if (optlen > IFNAMSIZ)	638	if (optlen > IFNAMSIZ - 1)
639	optlen = IFNAMSIZ;	639	optlen = IFNAMSIZ - 1;
		640
		641	memset(devname, 0, sizeof(devname));
640		642
641	if (copy_from_user(devname, optval, optlen)) {	643	if (copy_from_user(devname, optval, optlen)) {
642	res = -EFAULT;	644	res = -EFAULT;

net/core/dev.c+15−5

 	return 0;
 }
-static int __netif_receive_skb_core(struct sk_buff *skb, bool pfmemalloc,
+static int __netif_receive_skb_core(struct sk_buff **pskb, bool pfmemalloc,
 				    struct packet_type **ppt_prev)
 {
 	struct packet_type *ptype, *pt_prev;
 	rx_handler_func_t *rx_handler;
+	struct sk_buff *skb = *pskb;
 	struct net_device *orig_dev;
 	bool deliver_exact = false;
 	int ret = NET_RX_DROP;
 		ret2 = do_xdp_generic(rcu_dereference(skb->dev->xdp_prog), skb);
 		preempt_enable();
-		if (ret2 != XDP_PASS)
+		if (ret2 != XDP_PASS) {
-			return NET_RX_DROP;
+			ret = NET_RX_DROP;
+			goto out;
+		}
 		skb_reset_mac_len(skb);
 	}
 	}
 out:
+	/* The invariant here is that if *ppt_prev is not NULL
+	 * then skb should also be non-NULL.
+	 *
+	 * Apparently *ppt_prev assignment above holds this invariant due to
+	 * skb dereferencing near it.
+	 */
+	*pskb = skb;
 	return ret;
 }
 	struct packet_type *pt_prev = NULL;
 	int ret;
-	ret = __netif_receive_skb_core(skb, pfmemalloc, &pt_prev);
+	ret = __netif_receive_skb_core(&skb, pfmemalloc, &pt_prev);
 	if (pt_prev)
 		ret = INDIRECT_CALL_INET(pt_prev->func, ipv6_rcv, ip_rcv, skb,
 					 skb->dev, pt_prev, orig_dev);
 		struct packet_type *pt_prev = NULL;
 		skb_list_del_init(skb);
-		__netif_receive_skb_core(skb, pfmemalloc, &pt_prev);
+		__netif_receive_skb_core(&skb, pfmemalloc, &pt_prev);
 		if (!pt_prev)
 			continue;
 		if (pt_curr != pt_prev || od_curr != orig_dev) {

net/core/flow_dissector.c+21−5

 	return ret;
 }
-int skb_flow_dissector_bpf_prog_detach(const union bpf_attr *attr)
+static int flow_dissector_bpf_prog_detach(struct net *net)
 {
 	struct bpf_prog *attached;
-	struct net *net;
-	net = current->nsproxy->net_ns;
 	mutex_lock(&flow_dissector_mutex);
 	attached = rcu_dereference_protected(net->flow_dissector_prog,
 					     lockdep_is_held(&flow_dissector_mutex));
 	return 0;
 }
+int skb_flow_dissector_bpf_prog_detach(const union bpf_attr *attr)
+{
+	return flow_dissector_bpf_prog_detach(current->nsproxy->net_ns);
+}
+static void __net_exit flow_dissector_pernet_pre_exit(struct net *net)
+{
+	/* We're not racing with attach/detach because there are no
+	 * references to netns left when pre_exit gets called.
+	 */
+	if (rcu_access_pointer(net->flow_dissector_prog))
+		flow_dissector_bpf_prog_detach(net);
+}
+static struct pernet_operations flow_dissector_pernet_ops __net_initdata = {
+	.pre_exit = flow_dissector_pernet_pre_exit,
+};
 /**
  * __skb_flow_get_ports - extract the upper layer ports and return them
  * @skb: sk_buff to extract the ports from
 	skb_flow_dissector_init(&flow_keys_basic_dissector,
 				flow_keys_basic_dissector_keys,
 				ARRAY_SIZE(flow_keys_basic_dissector_keys));
-	return 0;
-}
+	return register_pernet_subsys(&flow_dissector_pernet_ops);
+}
 core_initcall(init_default_flow_dissectors);

net/dsa/tag_mtk.c+15−0

 #define MTK_HDR_XMIT_TAGGED_TPID_8100	1
 #define MTK_HDR_RECV_SOURCE_PORT_MASK	GENMASK(2, 0)
 #define MTK_HDR_XMIT_DP_BIT_MASK	GENMASK(5, 0)
+#define MTK_HDR_XMIT_SA_DIS		BIT(6)
 static struct sk_buff *mtk_tag_xmit(struct sk_buff *skb,
 				    struct net_device *dev)
 	struct dsa_port *dp = dsa_slave_to_port(dev);
 	u8 *mtk_tag;
 	bool is_vlan_skb = true;
+	unsigned char *dest = eth_hdr(skb)->h_dest;
+	bool is_multicast_skb = is_multicast_ether_addr(dest) &&
+				!is_broadcast_ether_addr(dest);
 	/* Build the special tag after the MAC Source Address. If VLAN header
 	 * is present, it's required that VLAN header and special tag is
 		     MTK_HDR_XMIT_UNTAGGED;
 	mtk_tag[1] = (1 << dp->index) & MTK_HDR_XMIT_DP_BIT_MASK;
+	/* Disable SA learning for multicast frames */
+	if (unlikely(is_multicast_skb))
+		mtk_tag[1] |= MTK_HDR_XMIT_SA_DIS;
 	/* Tag control information is kept for 802.1Q */
 	if (!is_vlan_skb) {
 		mtk_tag[2] = 0;
 {
 	int port;
 	__be16 *phdr, hdr;
+	unsigned char *dest = eth_hdr(skb)->h_dest;
+	bool is_multicast_skb = is_multicast_ether_addr(dest) &&
+				!is_broadcast_ether_addr(dest);
 	if (unlikely(!pskb_may_pull(skb, MTK_HDR_LEN)))
 		return NULL;
 	if (!skb->dev)
 		return NULL;
+	/* Only unicast or broadcast frames are offloaded */
+	if (likely(!is_multicast_skb))
+		skb->offload_fwd_mark = 1;
 	return skb;
 }

net/ethtool/netlink.c+2−2

@@ -342,7 +342,7 @@ static int ethnl_default_doit(struct sk_buff skb, struct genl_info info) · 341 unmodified lines
342	ret = ops->reply_size(req_info, reply_data);	342	ret = ops->reply_size(req_info, reply_data);
343	if (ret < 0)	343	if (ret < 0)
344	goto err_cleanup;	344	goto err_cleanup;
345	reply_len = ret;	345	reply_len = ret + ethnl_reply_header_size();
346	ret = -ENOMEM;	346	ret = -ENOMEM;
347	rskb = ethnl_reply_init(reply_len, req_info->dev, ops->reply_cmd,	347	rskb = ethnl_reply_init(reply_len, req_info->dev, ops->reply_cmd,
348	ops->hdr_attr, info, &reply_payload);	348	ops->hdr_attr, info, &reply_payload);
@@ -588,7 +588,7 @@ static void ethnl_default_notify(struct net_device *dev, unsigned int cmd, · 239 unmodified lines
588	ret = ops->reply_size(req_info, reply_data);	588	ret = ops->reply_size(req_info, reply_data);
589	if (ret < 0)	589	if (ret < 0)
590	goto err_cleanup;	590	goto err_cleanup;
591	reply_len = ret;	591	reply_len = ret + ethnl_reply_header_size();
592	ret = -ENOMEM;	592	ret = -ENOMEM;
593	skb = genlmsg_new(reply_len, GFP_KERNEL);	593	skb = genlmsg_new(reply_len, GFP_KERNEL);
594	if (!skb)	594	if (!skb)

net/ethtool/strset.c+0−1

@@ -324,7 +324,6 @@ static int strset_reply_size(const struct ethnl_req_info *req_base, · 323 unmodified lines
324	int len = 0;	324	int len = 0;
325	int ret;	325	int ret;
326		326
327	len += ethnl_reply_header_size();
328	for (i = 0; i < ETH_SS_COUNT; i++) {	327	for (i = 0; i < ETH_SS_COUNT; i++) {
329	const struct strset_info *set_info = &data->sets[i];	328	const struct strset_info *set_info = &data->sets[i];
330		329

net/ipv4/fib_frontend.c+1−2

 	else
 		filter->dump_exceptions = false;
-	filter->dump_all_families = (rtm->rtm_family == AF_UNSPEC);
 	filter->flags    = rtm->rtm_flags;
 	filter->protocol = rtm->rtm_protocol;
 	filter->rt_type  = rtm->rtm_type;
 	if (filter.table_id) {
 		tb = fib_get_table(net, filter.table_id);
 		if (!tb) {
-			if (filter.dump_all_families)
+			if (rtnl_msg_family(cb->nlh) != PF_INET)
 				return skb->len;
 			NL_SET_ERR_MSG(cb->extack, "ipv4: FIB table does not exist");

net/ipv4/inet_connection_sock.c+24−19

 #include <net/addrconf.h>
 #if IS_ENABLED(CONFIG_IPV6)
-/* match_wildcard == true:  IPV6_ADDR_ANY equals to any IPv6 addresses if IPv6
+/* match_sk*_wildcard == true:  IPV6_ADDR_ANY equals to any IPv6 addresses
- *                          only, and any IPv4 addresses if not IPv6 only
+ *				if IPv6 only, and any IPv4 addresses
- * match_wildcard == false: addresses must be exactly the same, i.e.
+ *				if not IPv6 only
- *                          IPV6_ADDR_ANY only equals to IPV6_ADDR_ANY,
+ * match_sk*_wildcard == false: addresses must be exactly the same, i.e.
- *                          and 0.0.0.0 equals to 0.0.0.0 only
+ *				IPV6_ADDR_ANY only equals to IPV6_ADDR_ANY,
+ *				and 0.0.0.0 equals to 0.0.0.0 only
  */
 static bool ipv6_rcv_saddr_equal(const struct in6_addr *sk1_rcv_saddr6,
 				 const struct in6_addr *sk2_rcv_saddr6,
 				 __be32 sk1_rcv_saddr, __be32 sk2_rcv_saddr,
 				 bool sk1_ipv6only, bool sk2_ipv6only,
-				 bool match_wildcard)
+				 bool match_sk1_wildcard,
+				 bool match_sk2_wildcard)
 {
 	int addr_type = ipv6_addr_type(sk1_rcv_saddr6);
 	int addr_type2 = sk2_rcv_saddr6 ? ipv6_addr_type(sk2_rcv_saddr6) : IPV6_ADDR_MAPPED;
 		if (!sk2_ipv6only) {
 			if (sk1_rcv_saddr == sk2_rcv_saddr)
 				return true;
-			if (!sk1_rcv_saddr || !sk2_rcv_saddr)
+			return (match_sk1_wildcard && !sk1_rcv_saddr) ||
-				return match_wildcard;
+				(match_sk2_wildcard && !sk2_rcv_saddr);
 		}
 		return false;
 	}
 	if (addr_type == IPV6_ADDR_ANY && addr_type2 == IPV6_ADDR_ANY)
 		return true;
-	if (addr_type2 == IPV6_ADDR_ANY && match_wildcard &&
+	if (addr_type2 == IPV6_ADDR_ANY && match_sk2_wildcard &&
 	    !(sk2_ipv6only && addr_type == IPV6_ADDR_MAPPED))
 		return true;
-	if (addr_type == IPV6_ADDR_ANY && match_wildcard &&
+	if (addr_type == IPV6_ADDR_ANY && match_sk1_wildcard &&
 	    !(sk1_ipv6only && addr_type2 == IPV6_ADDR_MAPPED))
 		return true;
 }
 #endif
-/* match_wildcard == true:  0.0.0.0 equals to any IPv4 addresses
+/* match_sk*_wildcard == true:  0.0.0.0 equals to any IPv4 addresses
- * match_wildcard == false: addresses must be exactly the same, i.e.
+ * match_sk*_wildcard == false: addresses must be exactly the same, i.e.
- *                          0.0.0.0 only equals to 0.0.0.0
+ *				0.0.0.0 only equals to 0.0.0.0
  */
 static bool ipv4_rcv_saddr_equal(__be32 sk1_rcv_saddr, __be32 sk2_rcv_saddr,
-				 bool sk2_ipv6only, bool match_wildcard)
+				 bool sk2_ipv6only, bool match_sk1_wildcard,
+				 bool match_sk2_wildcard)
 {
 	if (!sk2_ipv6only) {
 		if (sk1_rcv_saddr == sk2_rcv_saddr)
 			return true;
-		if (!sk1_rcv_saddr || !sk2_rcv_saddr)
+		return (match_sk1_wildcard && !sk1_rcv_saddr) ||
-			return match_wildcard;
+			(match_sk2_wildcard && !sk2_rcv_saddr);
 	}
 	return false;
 }
 					    sk2->sk_rcv_saddr,
 					    ipv6_only_sock(sk),
 					    ipv6_only_sock(sk2),
+					    match_wildcard,
 					    match_wildcard);
 #endif
 	return ipv4_rcv_saddr_equal(sk->sk_rcv_saddr, sk2->sk_rcv_saddr,
-				    ipv6_only_sock(sk2), match_wildcard);
+				    ipv6_only_sock(sk2), match_wildcard,
+				    match_wildcard);
 }
 EXPORT_SYMBOL(inet_rcv_saddr_equal);
 					    tb->fast_rcv_saddr,
 					    sk->sk_rcv_saddr,
 					    tb->fast_ipv6_only,
-					    ipv6_only_sock(sk), true);
+					    ipv6_only_sock(sk), true, false);
 #endif
 	return ipv4_rcv_saddr_equal(tb->fast_rcv_saddr, sk->sk_rcv_saddr,
-				    ipv6_only_sock(sk), true);
+				    ipv6_only_sock(sk), true, false);
 }
 /* Obtain a reference to a local port for the given sock,

net/ipv4/ipip.c+1−1

@@ -698,7 +698,7 @@ out: · 697 unmodified lines
698		698
699	rtnl_link_failed:	699	rtnl_link_failed:
700	#if IS_ENABLED(CONFIG_MPLS)	700	#if IS_ENABLED(CONFIG_MPLS)
701	xfrm4_tunnel_deregister(&mplsip_handler, AF_INET);	701	xfrm4_tunnel_deregister(&mplsip_handler, AF_MPLS);
702	xfrm_tunnel_mplsip_failed:	702	xfrm_tunnel_mplsip_failed:
703		703
704	#endif	704	#endif

net/ipv4/ipmr.c+1−1

@@ -2613,7 +2613,7 @@ static int ipmr_rtm_dumproute(struct sk_buff skb, struct netlink_callback cb) · 2612 unmodified lines
2613		2613
2614	mrt = ipmr_get_table(sock_net(skb->sk), filter.table_id);	2614	mrt = ipmr_get_table(sock_net(skb->sk), filter.table_id);
2615	if (!mrt) {	2615	if (!mrt) {
2616	if (filter.dump_all_families)	2616	if (rtnl_msg_family(cb->nlh) != RTNL_FAMILY_IPMR)
2617	return skb->len;	2617	return skb->len;
2618		2618
2619	NL_SET_ERR_MSG(cb->extack, "ipv4: MR table does not exist");	2619	NL_SET_ERR_MSG(cb->extack, "ipv4: MR table does not exist");

net/ipv4/nexthop.c+2−1

 	return 0;
 nla_put_failure:
+	nlmsg_cancel(skb, nlh);
 	return -EMSGSIZE;
 }
 		if (!valid_group_nh(nh, len, extack))
 			return -EINVAL;
 	}
-	for (i = NHA_GROUP + 1; i < __NHA_MAX; ++i) {
+	for (i = NHA_GROUP_TYPE + 1; i < __NHA_MAX; ++i) {
 		if (!tb[i])
 			continue;

net/ipv4/route.c+6−8

@@ -491,18 +491,16 @@ u32 ip_idents_reserve(u32 hash, int segs) · 490 unmodified lines
491	atomic_t *p_id = ip_idents + hash % IP_IDENTS_SZ;	491	atomic_t *p_id = ip_idents + hash % IP_IDENTS_SZ;
492	u32 old = READ_ONCE(*p_tstamp);	492	u32 old = READ_ONCE(*p_tstamp);
493	u32 now = (u32)jiffies;	493	u32 now = (u32)jiffies;
494	u32 new, delta = 0;	494	u32 delta = 0;
495		495
496	if (old != now && cmpxchg(p_tstamp, old, now) == old)	496	if (old != now && cmpxchg(p_tstamp, old, now) == old)
497	delta = prandom_u32_max(now - old);	497	delta = prandom_u32_max(now - old);
498		498
499	/* Do not use atomic_add_return() as it makes UBSAN unhappy */	499	/* If UBSAN reports an error there, please make sure your compiler
500	do {	500	* supports -fno-strict-overflow before reporting it that was a bug
501	old = (u32)atomic_read(p_id);	501	* in UBSAN, and it has been fixed in GCC-8.
502	new = old + delta + segs;	502	*/
503	} while (atomic_cmpxchg(p_id, old, new) != old);	503	return atomic_add_return(segs + delta, p_id) - segs;
504
505	return new - segs;
506	}	504	}
507	EXPORT_SYMBOL(ip_idents_reserve);	505	EXPORT_SYMBOL(ip_idents_reserve);
508		506

net/ipv6/ip6_fib.c+1−1

@@ -664,7 +664,7 @@ static int inet6_dump_fib(struct sk_buff skb, struct netlink_callback cb) · 663 unmodified lines
664	if (arg.filter.table_id) {	664	if (arg.filter.table_id) {
665	tb = fib6_get_table(net, arg.filter.table_id);	665	tb = fib6_get_table(net, arg.filter.table_id);
666	if (!tb) {	666	if (!tb) {
667	if (arg.filter.dump_all_families)	667	if (rtnl_msg_family(cb->nlh) != PF_INET6)
668	goto out;	668	goto out;
669		669
670	NL_SET_ERR_MSG_MOD(cb->extack, "FIB table does not exist");	670	NL_SET_ERR_MSG_MOD(cb->extack, "FIB table does not exist");

net/ipv6/ip6mr.c+3−2

 #ifdef CONFIG_IPV6_MROUTE_MULTIPLE_TABLES
 #define ip6mr_for_each_table(mrt, net) \
 	list_for_each_entry_rcu(mrt, &net->ipv6.mr6_tables, list, \
-				lockdep_rtnl_is_held())
+				lockdep_rtnl_is_held() || \
+				list_empty(&net->ipv6.mr6_tables))
 static struct mr_table *ip6mr_mr_table_iter(struct net *net,
 					    struct mr_table *mrt)
 		mrt = ip6mr_get_table(sock_net(skb->sk), filter.table_id);
 		if (!mrt) {
-			if (filter.dump_all_families)
+			if (rtnl_msg_family(cb->nlh) != RTNL_FAMILY_IP6MR)
 				return skb->len;
 			NL_SET_ERR_MSG_MOD(cb->extack, "MR table does not exist");

net/mptcp/crypto.c+9−15

 void mptcp_crypto_hmac_sha(u64 key1, u64 key2, u8 *msg, int len, void *hmac)
 {
 	u8 input[SHA256_BLOCK_SIZE + SHA256_DIGEST_SIZE];
-	__be32 mptcp_hashed_key[SHA256_DIGEST_WORDS];
-	__be32 *hash_out = (__force __be32 *)hmac;
 	struct sha256_state state;
 	u8 key1be[8];
 	u8 key2be[8];
 	sha256_init(&state);
 	sha256_update(&state, input, SHA256_BLOCK_SIZE + SHA256_DIGEST_SIZE);
-	sha256_final(&state, (u8 *)mptcp_hashed_key);
+	sha256_final(&state, (u8 *)hmac);
-	/* takes only first 160 bits */
-	for (i = 0; i < 5; i++)
-		hash_out[i] = mptcp_hashed_key[i];
 }
 #ifdef CONFIG_MPTCP_HMAC_TEST
 };
 /* we can't reuse RFC 4231 test vectors, as we have constraint on the
- * input and key size, and we truncate the output.
+ * input and key size.
  */
 static struct test_cast tests[] = {
 	{
 		.key = "0b0b0b0b0b0b0b0b",
 		.msg = "48692054",
-		.result = "8385e24fb4235ac37556b6b886db106284a1da67",
+		.result = "8385e24fb4235ac37556b6b886db106284a1da671699f46db1f235ec622dcafa",
 	},
 	{
 		.key = "aaaaaaaaaaaaaaaa",
 		.msg = "dddddddd",
-		.result = "2c5e219164ff1dca1c4a92318d847bb6b9d44492",
+		.result = "2c5e219164ff1dca1c4a92318d847bb6b9d44492984e1eb71aff9022f71046e9",
 	},
 	{
 		.key = "0102030405060708",
 		.msg = "cdcdcdcd",
-		.result = "e73b9ba9969969cefb04aa0d6df18ec2fcc075b6",
+		.result = "e73b9ba9969969cefb04aa0d6df18ec2fcc075b6f23b4d8c4da736a5dbbc6e7d",
 	},
 };
 static int __init test_mptcp_crypto(void)
 {
-	char hmac[20], hmac_hex[41];
+	char hmac[32], hmac_hex[65];
 	u32 nonce1, nonce2;
 	u64 key1, key2;
 	u8 msg[8];
 		put_unaligned_be32(nonce2, &msg[4]);
 		mptcp_crypto_hmac_sha(key1, key2, msg, 8, hmac);
-		for (j = 0; j < 20; ++j)
+		for (j = 0; j < 32; ++j)
 			sprintf(&hmac_hex[j << 1], "%02x", hmac[j] & 0xff);
-		hmac_hex[40] = 0;
+		hmac_hex[64] = 0;
-		if (memcmp(hmac_hex, tests[i].result, 40))
+		if (memcmp(hmac_hex, tests[i].result, 64))
 			pr_err("test %d failed, got %s expected %s", i,
 			       hmac_hex, tests[i].result);
 		else

net/mptcp/options.c+5−4

 #define pr_fmt(fmt) "MPTCP: " fmt
 #include <linux/kernel.h>
+#include <crypto/sha.h>
 #include <net/tcp.h>
 #include <net/mptcp.h>
 #include "protocol.h"
 static u64 add_addr_generate_hmac(u64 key1, u64 key2, u8 addr_id,
 				  struct in_addr *addr)
 {
-	u8 hmac[MPTCP_ADDR_HMAC_LEN];
+	u8 hmac[SHA256_DIGEST_SIZE];
 	u8 msg[7];
 	msg[0] = addr_id;
 	mptcp_crypto_hmac_sha(key1, key2, msg, 7, hmac);
-	return get_unaligned_be64(hmac);
+	return get_unaligned_be64(&hmac[SHA256_DIGEST_SIZE - sizeof(u64)]);
 }
 #if IS_ENABLED(CONFIG_MPTCP_IPV6)
 static u64 add_addr6_generate_hmac(u64 key1, u64 key2, u8 addr_id,
 				   struct in6_addr *addr)
 {
-	u8 hmac[MPTCP_ADDR_HMAC_LEN];
+	u8 hmac[SHA256_DIGEST_SIZE];
 	u8 msg[19];
 	msg[0] = addr_id;
 	mptcp_crypto_hmac_sha(key1, key2, msg, 19, hmac);
-	return get_unaligned_be64(hmac);
+	return get_unaligned_be64(&hmac[SHA256_DIGEST_SIZE - sizeof(u64)]);
 }
 #endif

net/mptcp/protocol.h+0−1

@@ -81,7 +81,6 @@ · 80 unmodified lines
81		81
82	/* MPTCP ADD_ADDR flags */	82	/* MPTCP ADD_ADDR flags */
83	#define MPTCP_ADDR_ECHO BIT(0)	83	#define MPTCP_ADDR_ECHO BIT(0)
84	#define MPTCP_ADDR_HMAC_LEN 20
85	#define MPTCP_ADDR_IPVERSION_4 4	84	#define MPTCP_ADDR_IPVERSION_4 4
86	#define MPTCP_ADDR_IPVERSION_6 6	85	#define MPTCP_ADDR_IPVERSION_6 6
87		86

net/mptcp/subflow.c+10−5

 #include <linux/module.h>
 #include <linux/netdevice.h>
 #include <crypto/algapi.h>
+#include <crypto/sha.h>
 #include <net/sock.h>
 #include <net/inet_common.h>
 #include <net/inet_hashtables.h>
 				       const struct sk_buff *skb)
 {
 	struct mptcp_subflow_request_sock *subflow_req = mptcp_subflow_rsk(req);
-	u8 hmac[MPTCPOPT_HMAC_LEN];
+	u8 hmac[SHA256_DIGEST_SIZE];
 	struct mptcp_sock *msk;
 	int local_id;
 /* validate received truncated hmac and create hmac for third ACK */
 static bool subflow_thmac_valid(struct mptcp_subflow_context *subflow)
 {
-	u8 hmac[MPTCPOPT_HMAC_LEN];
+	u8 hmac[SHA256_DIGEST_SIZE];
 	u64 thmac;
 	subflow_generate_hmac(subflow->remote_key, subflow->local_key,
 			subflow->ssn_offset = TCP_SKB_CB(skb)->seq;
 		}
 	} else if (subflow->mp_join) {
+		u8 hmac[SHA256_DIGEST_SIZE];
 		pr_debug("subflow=%p, thmac=%llu, remote_nonce=%u",
 			 subflow, subflow->thmac,
 			 subflow->remote_nonce);
 		subflow_generate_hmac(subflow->local_key, subflow->remote_key,
 				      subflow->local_nonce,
 				      subflow->remote_nonce,
-				      subflow->hmac);
+				      hmac);
+		memcpy(subflow->hmac, hmac, MPTCPOPT_HMAC_LEN);
 		if (skb)
 			subflow->ssn_offset = TCP_SKB_CB(skb)->seq;
 			       const struct mptcp_options_received *mp_opt)
 {
 	const struct mptcp_subflow_request_sock *subflow_req;
-	u8 hmac[MPTCPOPT_HMAC_LEN];
+	u8 hmac[SHA256_DIGEST_SIZE];
 	struct mptcp_sock *msk;
 	bool ret;
 			      subflow_req->local_nonce, hmac);
 	ret = true;
-	if (crypto_memneq(hmac, mp_opt->hmac, sizeof(hmac)))
+	if (crypto_memneq(hmac, mp_opt->hmac, MPTCPOPT_HMAC_LEN))
 		ret = false;
 	sock_put((struct sock *)msk);

net/qrtr/qrtr.c+1−1

@@ -854,7 +854,7 @@ static int qrtr_bcast_enqueue(struct qrtr_node node, struct sk_buff skb, · 853 unmodified lines
854	}	854	}
855	mutex_unlock(&qrtr_node_lock);	855	mutex_unlock(&qrtr_node_lock);
856		856
857	qrtr_local_enqueue(node, skb, type, from, to);	857	qrtr_local_enqueue(NULL, skb, type, from, to);
858		858
859	return 0;	859	return 0;
860	}	860	}

net/rxrpc/Makefile+1−0

@@ -25,6 +25,7 @@ rxrpc-y := \ · 24 unmodified lines
25	peer_event.o \	25	peer_event.o \
26	peer_object.o \	26	peer_object.o \
27	recvmsg.o \	27	recvmsg.o \
		28	rtt.o \
28	security.o \	29	security.o \
29	sendmsg.o \	30	sendmsg.o \
30	skbuff.o \	31	skbuff.o \

net/rxrpc/ar-internal.h+17−8

@@ -7,6 +7,7 @@ · 6 unmodified lines
7		7
8	#include <linux/atomic.h>	8	#include <linux/atomic.h>
9	#include <linux/seqlock.h>	9	#include <linux/seqlock.h>
		10	#include <linux/win_minmax.h>
10	#include <net/net_namespace.h>	11	#include <net/net_namespace.h>
11	#include <net/netns/generic.h>	12	#include <net/netns/generic.h>
12	#include <net/sock.h>	13	#include <net/sock.h>
@@ -311,11 +312,14 @@ struct rxrpc_peer { · 298 unmodified lines
311	#define RXRPC_RTT_CACHE_SIZE 32	312	#define RXRPC_RTT_CACHE_SIZE 32
312	spinlock_t rtt_input_lock; /* RTT lock for input routine */	313	spinlock_t rtt_input_lock; /* RTT lock for input routine */
313	ktime_t rtt_last_req; /* Time of last RTT request */	314	ktime_t rtt_last_req; /* Time of last RTT request */
314	u64 rtt; /* Current RTT estimate (in nS) */	315	unsigned int rtt_count; /* Number of samples we've got */
315	u64 rtt_sum; /* Sum of cache contents */	316
316	u64 rtt_cache[RXRPC_RTT_CACHE_SIZE]; /* Determined RTT cache */	317	u32 srtt_us; /* smoothed round trip time << 3 in usecs */
317	u8 rtt_cursor; /* next entry at which to insert */	318	u32 mdev_us; /* medium deviation */
318	u8 rtt_usage; /* amount of cache actually used */	319	u32 mdev_max_us; /* maximal mdev for the last rtt period */
		320	u32 rttvar_us; /* smoothed mdev_max */
		321	u32 rto_j; /* Retransmission timeout in jiffies */
		322	u8 backoff; /* Backoff timeout */
319		323
320	u8 cong_cwnd; /* Congestion window size */	324	u8 cong_cwnd; /* Congestion window size */
321	};	325	};
@@ -1041,7 +1045,6 @@ extern unsigned long rxrpc_idle_ack_delay; · 719 unmodified lines
1041	extern unsigned int rxrpc_rx_window_size;	1045	extern unsigned int rxrpc_rx_window_size;
1042	extern unsigned int rxrpc_rx_mtu;	1046	extern unsigned int rxrpc_rx_mtu;
1043	extern unsigned int rxrpc_rx_jumbo_max;	1047	extern unsigned int rxrpc_rx_jumbo_max;
1044	extern unsigned long rxrpc_resend_timeout;
1045		1048
1046	extern const s8 rxrpc_ack_priority[];	1049	extern const s8 rxrpc_ack_priority[];
1047		1050
@@ -1069,8 +1072,6 @@ void rxrpc_send_keepalive(struct rxrpc_peer *); · 21 unmodified lines
1069	* peer_event.c	1072	* peer_event.c
1070	*/	1073	*/
1071	void rxrpc_error_report(struct sock *);	1074	void rxrpc_error_report(struct sock *);
1072	void rxrpc_peer_add_rtt(struct rxrpc_call *, enum rxrpc_rtt_rx_trace,
1073	rxrpc_serial_t, rxrpc_serial_t, ktime_t, ktime_t);
1074	void rxrpc_peer_keepalive_worker(struct work_struct *);	1075	void rxrpc_peer_keepalive_worker(struct work_struct *);
1075		1076
1076	/*	1077	/*
@@ -1102,6 +1103,14 @@ extern const struct seq_operations rxrpc_peer_seq_ops; · 25 unmodified lines
1102	void rxrpc_notify_socket(struct rxrpc_call *);	1103	void rxrpc_notify_socket(struct rxrpc_call *);
1103	int rxrpc_recvmsg(struct socket , struct msghdr , size_t, int);	1104	int rxrpc_recvmsg(struct socket , struct msghdr , size_t, int);
1104		1105
		1106	/*
		1107	* rtt.c
		1108	*/
		1109	void rxrpc_peer_add_rtt(struct rxrpc_call *, enum rxrpc_rtt_rx_trace,
		1110	rxrpc_serial_t, rxrpc_serial_t, ktime_t, ktime_t);
		1111	unsigned long rxrpc_get_rto_backoff(struct rxrpc_peer *, bool);
		1112	void rxrpc_peer_init_rtt(struct rxrpc_peer *);
		1113
1105	/*	1114	/*
1106	* rxkad.c	1115	* rxkad.c
1107	*/	1116	*/

net/rxrpc/call_accept.c+1−1

@@ -248,7 +248,7 @@ static void rxrpc_send_ping(struct rxrpc_call call, struct sk_buff skb) · 247 unmodified lines
248	struct rxrpc_skb_priv *sp = rxrpc_skb(skb);	248	struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
249	ktime_t now = skb->tstamp;	249	ktime_t now = skb->tstamp;
250		250
251	if (call->peer->rtt_usage < 3 \|\|	251	if (call->peer->rtt_count < 3 \|\|
252	ktime_before(ktime_add_ms(call->peer->rtt_last_req, 1000), now))	252	ktime_before(ktime_add_ms(call->peer->rtt_last_req, 1000), now))
253	rxrpc_propose_ACK(call, RXRPC_ACK_PING, sp->hdr.serial,	253	rxrpc_propose_ACK(call, RXRPC_ACK_PING, sp->hdr.serial,
254	true, true,	254	true, true,

net/rxrpc/call_event.c+8−14

 	} else {
 		unsigned long now = jiffies, ack_at;
-		if (call->peer->rtt_usage > 0)
+		if (call->peer->srtt_us != 0)
-			ack_at = nsecs_to_jiffies(call->peer->rtt);
+			ack_at = usecs_to_jiffies(call->peer->srtt_us >> 3);
 		else
 			ack_at = expiry;
 static void rxrpc_resend(struct rxrpc_call *call, unsigned long now_j)
 {
 	struct sk_buff *skb;
-	unsigned long resend_at;
+	unsigned long resend_at, rto_j;
 	rxrpc_seq_t cursor, seq, top;
-	ktime_t now, max_age, oldest, ack_ts, timeout, min_timeo;
+	ktime_t now, max_age, oldest, ack_ts;
 	int ix;
 	u8 annotation, anno_type, retrans = 0, unacked = 0;
 	_enter("{%d,%d}", call->tx_hard_ack, call->tx_top);
-	if (call->peer->rtt_usage > 1)
+	rto_j = call->peer->rto_j;
-		timeout = ns_to_ktime(call->peer->rtt * 3 / 2);
-	else
-		timeout = ms_to_ktime(rxrpc_resend_timeout);
-	min_timeo = ns_to_ktime((1000000000 / HZ) * 4);
-	if (ktime_before(timeout, min_timeo))
-		timeout = min_timeo;
 	now = ktime_get_real();
-	max_age = ktime_sub(now, timeout);
+	max_age = ktime_sub(now, jiffies_to_usecs(rto_j));
 	spin_lock_bh(&call->lock);
 	}
 	resend_at = nsecs_to_jiffies(ktime_to_ns(ktime_sub(now, oldest)));
-	resend_at += jiffies + rxrpc_resend_timeout;
+	resend_at += jiffies + rto_j;
 	WRITE_ONCE(call->resend_at, resend_at);
 	if (unacked)
 					rxrpc_timer_set_for_resend);
 		spin_unlock_bh(&call->lock);
 		ack_ts = ktime_sub(now, call->acks_latest_ts);
-		if (ktime_to_ns(ack_ts) < call->peer->rtt)
+		if (ktime_to_us(ack_ts) < (call->peer->srtt_us >> 3))
 			goto out;
 		rxrpc_propose_ACK(call, RXRPC_ACK_PING, 0, true, false,
 				  rxrpc_propose_ack_ping_for_lost_ack);

net/rxrpc/input.c+37−7

 		/* We analyse the number of packets that get ACK'd per RTT
 		 * period and increase the window if we managed to fill it.
 		 */
-		if (call->peer->rtt_usage == 0)
+		if (call->peer->rtt_count == 0)
 			goto out;
 		if (ktime_before(skb->tstamp,
-				 ktime_add_ns(call->cong_tstamp,
+				 ktime_add_us(call->cong_tstamp,
-					      call->peer->rtt)))
+					      call->peer->srtt_us >> 3)))
 			goto out_no_clear_ca;
 		change = rxrpc_cong_rtt_window_end;
 		call->cong_tstamp = skb->tstamp;
 	}
 }
+/*
+ * Return true if the ACK is valid - ie. it doesn't appear to have regressed
+ * with respect to the ack state conveyed by preceding ACKs.
+ */
+static bool rxrpc_is_ack_valid(struct rxrpc_call *call,
+			       rxrpc_seq_t first_pkt, rxrpc_seq_t prev_pkt)
+{
+	rxrpc_seq_t base = READ_ONCE(call->ackr_first_seq);
+	if (after(first_pkt, base))
+		return true; /* The window advanced */
+	if (before(first_pkt, base))
+		return false; /* firstPacket regressed */
+	if (after_eq(prev_pkt, call->ackr_prev_seq))
+		return true; /* previousPacket hasn't regressed. */
+	/* Some rx implementations put a serial number in previousPacket. */
+	if (after_eq(prev_pkt, base + call->tx_winsize))
+		return false;
+	return true;
+}
 /*
  * Process an ACK packet.
  *
 	}
 	/* Discard any out-of-order or duplicate ACKs (outside lock). */
-	if (before(first_soft_ack, call->ackr_first_seq) ||
+	if (!rxrpc_is_ack_valid(call, first_soft_ack, prev_pkt)) {
-	    before(prev_pkt, call->ackr_prev_seq))
+		trace_rxrpc_rx_discard_ack(call->debug_id, sp->hdr.serial,
+					   first_soft_ack, call->ackr_first_seq,
+					   prev_pkt, call->ackr_prev_seq);
 		return;
+	}
 	buf.info.rxMTU = 0;
 	ioffset = offset + nr_acks + 3;
 	spin_lock(&call->input_lock);
 	/* Discard any out-of-order or duplicate ACKs (inside lock). */
-	if (before(first_soft_ack, call->ackr_first_seq) ||
+	if (!rxrpc_is_ack_valid(call, first_soft_ack, prev_pkt)) {
-	    before(prev_pkt, call->ackr_prev_seq))
+		trace_rxrpc_rx_discard_ack(call->debug_id, sp->hdr.serial,
+					   first_soft_ack, call->ackr_first_seq,
+					   prev_pkt, call->ackr_prev_seq);
 		goto out;
+	}
 	call->acks_latest_ts = skb->tstamp;
 	call->ackr_first_seq = first_soft_ack;

net/rxrpc/misc.c+0−5

  */
 unsigned int rxrpc_rx_jumbo_max = 4;
-/*
- * Time till packet resend (in milliseconds).
- */
-unsigned long rxrpc_resend_timeout = 4 * HZ;
 const s8 rxrpc_ack_priority[] = {
 	[0]				= 0,
 	[RXRPC_ACK_DELAY]		= 1,

net/rxrpc/output.c+3−6

 	    (test_and_clear_bit(RXRPC_CALL_EV_ACK_LOST, &call->events) ||
 	     retrans ||
 	     call->cong_mode == RXRPC_CALL_SLOW_START ||
-	     (call->peer->rtt_usage < 3 && sp->hdr.seq & 1) ||
+	     (call->peer->rtt_count < 3 && sp->hdr.seq & 1) ||
 	     ktime_before(ktime_add_ms(call->peer->rtt_last_req, 1000),
 			  ktime_get_real())))
 		whdr.flags |= RXRPC_REQUEST_ACK;
 		if (whdr.flags & RXRPC_REQUEST_ACK) {
 			call->peer->rtt_last_req = skb->tstamp;
 			trace_rxrpc_rtt_tx(call, rxrpc_rtt_tx_data, serial);
-			if (call->peer->rtt_usage > 1) {
+			if (call->peer->rtt_count > 1) {
 				unsigned long nowj = jiffies, ack_lost_at;
-				ack_lost_at = nsecs_to_jiffies(2 * call->peer->rtt);
+				ack_lost_at = rxrpc_get_rto_backoff(call->peer, retrans);
-				if (ack_lost_at < 1)
-					ack_lost_at = 1;
 				ack_lost_at += nowj;
 				WRITE_ONCE(call->ack_lost_at, ack_lost_at);
 				rxrpc_reduce_call_timer(call, ack_lost_at, nowj,

net/rxrpc/peer_event.c+0−46

@@ -295,52 +295,6 @@ static void rxrpc_distribute_error(struct rxrpc_peer *peer, int error, · 294 unmodified lines
295	}	295	}
296	}	296	}
297		297
298	/*
299	* Add RTT information to cache. This is called in softirq mode and has
300	* exclusive access to the peer RTT data.
301	*/
302	void rxrpc_peer_add_rtt(struct rxrpc_call *call, enum rxrpc_rtt_rx_trace why,
303	rxrpc_serial_t send_serial, rxrpc_serial_t resp_serial,
304	ktime_t send_time, ktime_t resp_time)
305	{
306	struct rxrpc_peer *peer = call->peer;
307	s64 rtt;
308	u64 sum = peer->rtt_sum, avg;
309	u8 cursor = peer->rtt_cursor, usage = peer->rtt_usage;
310
311	rtt = ktime_to_ns(ktime_sub(resp_time, send_time));
312	if (rtt < 0)
313	return;
314
315	spin_lock(&peer->rtt_input_lock);
316
317	/* Replace the oldest datum in the RTT buffer */
318	sum -= peer->rtt_cache[cursor];
319	sum += rtt;
320	peer->rtt_cache[cursor] = rtt;
321	peer->rtt_cursor = (cursor + 1) & (RXRPC_RTT_CACHE_SIZE - 1);
322	peer->rtt_sum = sum;
323	if (usage < RXRPC_RTT_CACHE_SIZE) {
324	usage++;
325	peer->rtt_usage = usage;
326	}
327
328	spin_unlock(&peer->rtt_input_lock);
329
330	/* Now recalculate the average */
331	if (usage == RXRPC_RTT_CACHE_SIZE) {
332	avg = sum / RXRPC_RTT_CACHE_SIZE;
333	} else {
334	avg = sum;
335	do_div(avg, usage);
336	}
337
338	/* Don't need to update this under lock */
339	peer->rtt = avg;
340	trace_rxrpc_rtt_rx(call, why, send_serial, resp_serial, rtt,
341	usage, avg);
342	}
343
344	/*	298	/*
345	* Perform keep-alive pings.	299	* Perform keep-alive pings.
346	*/	300	*/

net/rxrpc/peer_object.c+7−5

 		spin_lock_init(&peer->rtt_input_lock);
 		peer->debug_id = atomic_inc_return(&rxrpc_debug_id);
+		rxrpc_peer_init_rtt(peer);
 		if (RXRPC_TX_SMSS > 2190)
 			peer->cong_cwnd = 2;
 		else if (RXRPC_TX_SMSS > 1095)
 EXPORT_SYMBOL(rxrpc_kernel_get_peer);
 /**
- * rxrpc_kernel_get_rtt - Get a call's peer RTT
+ * rxrpc_kernel_get_srtt - Get a call's peer smoothed RTT
  * @sock: The socket on which the call is in progress.
  * @call: The call to query
  *
- * Get the call's peer RTT.
+ * Get the call's peer smoothed RTT.
  */
-u64 rxrpc_kernel_get_rtt(struct socket *sock, struct rxrpc_call *call)
+u32 rxrpc_kernel_get_srtt(struct socket *sock, struct rxrpc_call *call)
 {
-	return call->peer->rtt;
+	return call->peer->srtt_us >> 3;
 }
-EXPORT_SYMBOL(rxrpc_kernel_get_rtt);
+EXPORT_SYMBOL(rxrpc_kernel_get_srtt);

net/rxrpc/proc.c+4−4

@@ -222,7 +222,7 @@ static int rxrpc_peer_seq_show(struct seq_file seq, void v) · 221 unmodified lines
222	seq_puts(seq,	222	seq_puts(seq,
223	"Proto Local "	223	"Proto Local "
224	" Remote "	224	" Remote "
225	" Use CW MTU LastUse RTT Rc\n"	225	" Use CW MTU LastUse RTT RTO\n"
226	);	226	);
227	return 0;	227	return 0;
228	}	228	}
@@ -236,15 +236,15 @@ static int rxrpc_peer_seq_show(struct seq_file seq, void v) · 7 unmodified lines
236	now = ktime_get_seconds();	236	now = ktime_get_seconds();
237	seq_printf(seq,	237	seq_printf(seq,
238	"UDP %-47.47s %-47.47s %3u"	238	"UDP %-47.47s %-47.47s %3u"
239	" %3u %5u %6llus %12llu %2u\n",	239	" %3u %5u %6llus %8u %8u\n",
240	lbuff,	240	lbuff,
241	rbuff,	241	rbuff,
242	atomic_read(&peer->usage),	242	atomic_read(&peer->usage),
243	peer->cong_cwnd,	243	peer->cong_cwnd,
244	peer->mtu,	244	peer->mtu,
245	now - peer->last_tx_at,	245	now - peer->last_tx_at,
246	peer->rtt,	246	peer->srtt_us >> 3,
247	peer->rtt_cursor);	247	jiffies_to_usecs(peer->rto_j));
248		248
249	return 0;	249	return 0;
250	}	250	}

net/rxrpc/rtt.c+195−0

@@ -0,0 +1,195 @@
	1	// SPDX-License-Identifier: GPL-2.0
	2	/* RTT/RTO calculation.
	3	*
	4	* Adapted from TCP for AF_RXRPC by David Howells (dhowells@redhat.com)
	5	*
	6	* https://tools.ietf.org/html/rfc6298
	7	* https://tools.ietf.org/html/rfc1122#section-4.2.3.1
	8	* http://ccr.sigcomm.org/archive/1995/jan95/ccr-9501-partridge87.pdf
	9	*/
	10
	11	#include <linux/net.h>
	12	#include "ar-internal.h"
	13
	14	#define RXRPC_RTO_MAX ((unsigned)(120 * HZ))
	15	#define RXRPC_TIMEOUT_INIT ((unsigned)(1HZ)) / RFC6298 2.1 initial RTO value */
	16	#define rxrpc_jiffies32 ((u32)jiffies) /* As rxrpc_jiffies32 */
	17	#define rxrpc_min_rtt_wlen 300 /* As sysctl_tcp_min_rtt_wlen */
	18
	19	static u32 rxrpc_rto_min_us(struct rxrpc_peer *peer)
	20	{
	21	return 200;
	22	}
	23
	24	static u32 __rxrpc_set_rto(const struct rxrpc_peer *peer)
	25	{
	26	return _usecs_to_jiffies((peer->srtt_us >> 3) + peer->rttvar_us);
	27	}
	28
	29	static u32 rxrpc_bound_rto(u32 rto)
	30	{
	31	return min(rto, RXRPC_RTO_MAX);
	32	}
	33
	34	/*
	35	* Called to compute a smoothed rtt estimate. The data fed to this
	36	* routine either comes from timestamps, or from segments that were
	37	* known _not_ to have been retransmitted [see Karn/Partridge
	38	* Proceedings SIGCOMM 87]. The algorithm is from the SIGCOMM 88
	39	* piece by Van Jacobson.
	40	* NOTE: the next three routines used to be one big routine.
	41	* To save cycles in the RFC 1323 implementation it was better to break
	42	* it up into three procedures. -- erics
	43	*/
	44	static void rxrpc_rtt_estimator(struct rxrpc_peer *peer, long sample_rtt_us)
	45	{
	46	long m = sample_rtt_us; /* RTT */
	47	u32 srtt = peer->srtt_us;
	48
	49	/* The following amusing code comes from Jacobson's
	50	* article in SIGCOMM '88. Note that rtt and mdev
	51	* are scaled versions of rtt and mean deviation.
	52	* This is designed to be as fast as possible
	53	* m stands for "measurement".
	54	*
	55	* On a 1990 paper the rto value is changed to:
	56	* RTO = rtt + 4 * mdev
	57	*
	58	* Funny. This algorithm seems to be very broken.
	59	* These formulae increase RTO, when it should be decreased, increase
	60	* too slowly, when it should be increased quickly, decrease too quickly
	61	* etc. I guess in BSD RTO takes ONE value, so that it is absolutely
	62	* does not matter how to _calculate_ it. Seems, it was trap
	63	* that VJ failed to avoid. 8)
	64	*/
	65	if (srtt != 0) {
	66	m -= (srtt >> 3); /* m is now error in rtt est */
	67	srtt += m; /* rtt = 7/8 rtt + 1/8 new */
	68	if (m < 0) {
	69	m = -m; /* m is now abs(error) */
	70	m -= (peer->mdev_us >> 2); /* similar update on mdev */
	71	/* This is similar to one of Eifel findings.
	72	* Eifel blocks mdev updates when rtt decreases.
	73	* This solution is a bit different: we use finer gain
	74	* for mdev in this case (alpha*beta).
	75	* Like Eifel it also prevents growth of rto,
	76	* but also it limits too fast rto decreases,
	77	* happening in pure Eifel.
	78	*/
	79	if (m > 0)
	80	m >>= 3;
	81	} else {
	82	m -= (peer->mdev_us >> 2); /* similar update on mdev */
	83	}
	84
	85	peer->mdev_us += m; /* mdev = 3/4 mdev + 1/4 new */
	86	if (peer->mdev_us > peer->mdev_max_us) {
	87	peer->mdev_max_us = peer->mdev_us;
	88	if (peer->mdev_max_us > peer->rttvar_us)
	89	peer->rttvar_us = peer->mdev_max_us;
	90	}
	91	} else {
	92	/* no previous measure. */
	93	srtt = m << 3; /* take the measured time to be rtt */
	94	peer->mdev_us = m << 1; /* make sure rto = 3rtt /
	95	peer->rttvar_us = max(peer->mdev_us, rxrpc_rto_min_us(peer));
	96	peer->mdev_max_us = peer->rttvar_us;
	97	}
	98
	99	peer->srtt_us = max(1U, srtt);
	100	}
	101
	102	/*
	103	* Calculate rto without backoff. This is the second half of Van Jacobson's
	104	* routine referred to above.
	105	*/
	106	static void rxrpc_set_rto(struct rxrpc_peer *peer)
	107	{
	108	u32 rto;
	109
	110	/* 1. If rtt variance happened to be less 50msec, it is hallucination.
	111	* It cannot be less due to utterly erratic ACK generation made
	112	* at least by solaris and freebsd. "Erratic ACKs" has _nothing_
	113	* to do with delayed acks, because at cwnd>2 true delack timeout
	114	* is invisible. Actually, Linux-2.4 also generates erratic
	115	* ACKs in some circumstances.
	116	*/
	117	rto = __rxrpc_set_rto(peer);
	118
	119	/* 2. Fixups made earlier cannot be right.
	120	* If we do not estimate RTO correctly without them,
	121	* all the algo is pure shit and should be replaced
	122	* with correct one. It is exactly, which we pretend to do.
	123	*/
	124
	125	/* NOTE: clamping at RXRPC_RTO_MIN is not required, current algo
	126	* guarantees that rto is higher.
	127	*/
	128	peer->rto_j = rxrpc_bound_rto(rto);
	129	}
	130
	131	static void rxrpc_ack_update_rtt(struct rxrpc_peer *peer, long rtt_us)
	132	{
	133	if (rtt_us < 0)
	134	return;
	135
	136	//rxrpc_update_rtt_min(peer, rtt_us);
	137	rxrpc_rtt_estimator(peer, rtt_us);
	138	rxrpc_set_rto(peer);
	139
	140	/* RFC6298: only reset backoff on valid RTT measurement. */
	141	peer->backoff = 0;
	142	}
	143
	144	/*
	145	* Add RTT information to cache. This is called in softirq mode and has
	146	* exclusive access to the peer RTT data.
	147	*/
	148	void rxrpc_peer_add_rtt(struct rxrpc_call *call, enum rxrpc_rtt_rx_trace why,
	149	rxrpc_serial_t send_serial, rxrpc_serial_t resp_serial,
	150	ktime_t send_time, ktime_t resp_time)
	151	{
	152	struct rxrpc_peer *peer = call->peer;
	153	s64 rtt_us;
	154
	155	rtt_us = ktime_to_us(ktime_sub(resp_time, send_time));
	156	if (rtt_us < 0)
	157	return;
	158
	159	spin_lock(&peer->rtt_input_lock);
	160	rxrpc_ack_update_rtt(peer, rtt_us);
	161	if (peer->rtt_count < 3)
	162	peer->rtt_count++;
	163	spin_unlock(&peer->rtt_input_lock);
	164
	165	trace_rxrpc_rtt_rx(call, why, send_serial, resp_serial,
	166	peer->srtt_us >> 3, peer->rto_j);
	167	}
	168
	169	/*
	170	* Get the retransmission timeout to set in jiffies, backing it off each time
	171	* we retransmit.
	172	*/
	173	unsigned long rxrpc_get_rto_backoff(struct rxrpc_peer *peer, bool retrans)
	174	{
	175	u64 timo_j;
	176	u8 backoff = READ_ONCE(peer->backoff);
	177
	178	timo_j = peer->rto_j;
	179	timo_j <<= backoff;
	180	if (retrans && timo_j * 2 <= RXRPC_RTO_MAX)
	181	WRITE_ONCE(peer->backoff, backoff + 1);
	182
	183	if (timo_j < 1)
	184	timo_j = 1;
	185
	186	return timo_j;
	187	}
	188
	189	void rxrpc_peer_init_rtt(struct rxrpc_peer *peer)
	190	{
	191	peer->rto_j = RXRPC_TIMEOUT_INIT;
	192	peer->mdev_us = jiffies_to_usecs(RXRPC_TIMEOUT_INIT);
	193	peer->backoff = 0;
	194	//minmax_reset(&peer->rtt_min, rxrpc_jiffies32, ~0U);
	195	}

net/rxrpc/rxkad.c+1−2

 	ret = rxkad_decrypt_ticket(conn, skb, ticket, ticket_len, &session_key,
 				   &expiry, _abort_code);
 	if (ret < 0)
-		goto temporary_error_free_resp;
+		goto temporary_error_free_ticket;
 	/* use the session key from inside the ticket to decrypt the
 	 * response */
 temporary_error_free_ticket:
 	kfree(ticket);
-temporary_error_free_resp:
 	kfree(response);
 temporary_error:
 	/* Ignore the response packet if we got a temporary error such as

net/rxrpc/sendmsg.c+9−17

 					    struct rxrpc_call *call)
 {
 	rxrpc_seq_t tx_start, tx_win;
-	signed long rtt2, timeout;
+	signed long rtt, timeout;
-	u64 rtt;
-	rtt = READ_ONCE(call->peer->rtt);
+	rtt = READ_ONCE(call->peer->srtt_us) >> 3;
-	rtt2 = nsecs_to_jiffies64(rtt) * 2;
+	rtt = usecs_to_jiffies(rtt) * 2;
-	if (rtt2 < 2)
+	if (rtt < 2)
-		rtt2 = 2;
+		rtt = 2;
-	timeout = rtt2;
+	timeout = rtt;
 	tx_start = READ_ONCE(call->tx_hard_ack);
 	for (;;) {
 			return -EINTR;
 		if (tx_win != tx_start) {
-			timeout = rtt2;
+			timeout = rtt;
 			tx_start = tx_win;
 		}
 		_debug("need instant resend %d", ret);
 		rxrpc_instant_resend(call, ix);
 	} else {
-		unsigned long now = jiffies, resend_at;
+		unsigned long now = jiffies;
+		unsigned long resend_at = now + call->peer->rto_j;
-		if (call->peer->rtt_usage > 1)
-			resend_at = nsecs_to_jiffies(call->peer->rtt * 3 / 2);
-		else
-			resend_at = rxrpc_resend_timeout;
-		if (resend_at < 1)
-			resend_at = 1;
-		resend_at += now;
 		WRITE_ONCE(call->resend_at, resend_at);
 		rxrpc_reduce_call_timer(call, resend_at, now,
 					rxrpc_timer_set_for_send);

net/rxrpc/sysctl.c+0−9

@@ -71,15 +71,6 @@ static struct ctl_table rxrpc_sysctl_table[] = { · 70 unmodified lines
71	.extra1 = (void *)&one_jiffy,	71	.extra1 = (void *)&one_jiffy,
72	.extra2 = (void *)&max_jiffies,	72	.extra2 = (void *)&max_jiffies,
73	},	73	},
74	{
75	.procname = "resend_timeout",
76	.data = &rxrpc_resend_timeout,
77	.maxlen = sizeof(unsigned long),
78	.mode = 0644,
79	.proc_handler = proc_doulongvec_ms_jiffies_minmax,
80	.extra1 = (void *)&one_jiffy,
81	.extra2 = (void *)&max_jiffies,
82	},
83		74
84	/* Non-time values */	75	/* Non-time values */
85	{	76	{

net/sctp/sm_sideeffect.c+11−3

 			timeout = asoc->timeouts[cmd->obj.to];
 			BUG_ON(!timeout);
-			timer->expires = jiffies + timeout;
+			/*
-			sctp_association_hold(asoc);
+			 * SCTP has a hard time with timer starts.  Because we process
-			add_timer(timer);
+			 * timer starts as side effects, it can be hard to tell if we
+			 * have already started a timer or not, which leads to BUG
+			 * halts when we call add_timer. So here, instead of just starting
+			 * a timer, if the timer is already started, and just mod
+			 * the timer with the shorter of the two expiration times
+			 */
+			if (!timer_pending(timer))
+				sctp_association_hold(asoc);
+			timer_reduce(timer, jiffies + timeout);
 			break;
 		case SCTP_CMD_TIMER_RESTART:

net/sctp/sm_statefuns.c+5−4

 	/* Update the content of current association. */
 	sctp_add_cmd_sf(commands, SCTP_CMD_UPDATE_ASSOC, SCTP_ASOC(new_asoc));
 	sctp_add_cmd_sf(commands, SCTP_CMD_EVENT_ULP, SCTP_ULPEVENT(ev));
-	if (sctp_state(asoc, SHUTDOWN_PENDING) &&
+	if ((sctp_state(asoc, SHUTDOWN_PENDING) ||
+	     sctp_state(asoc, SHUTDOWN_SENT)) &&
 	    (sctp_sstate(asoc->base.sk, CLOSING) ||
 	     sock_flag(asoc->base.sk, SOCK_DEAD))) {
-		/* if were currently in SHUTDOWN_PENDING, but the socket
+		/* If the socket has been closed by user, don't
-		 * has been closed by user, don't transition to ESTABLISHED.
+		 * transition to ESTABLISHED. Instead trigger SHUTDOWN
-		 * Instead trigger SHUTDOWN bundled with COOKIE_ACK.
+		 * bundled with COOKIE_ACK.
 		 */
 		sctp_add_cmd_sf(commands, SCTP_CMD_REPLY, SCTP_CHUNK(repl));
 		return sctp_sf_do_9_2_start_shutdown(net, ep, asoc,

net/tipc/udp_media.c+5−1

 			 struct udp_bearer *ub, struct udp_media_addr *src,
 			 struct udp_media_addr *dst, struct dst_cache *cache)
 {
-	struct dst_entry *ndst = dst_cache_get(cache);
+	struct dst_entry *ndst;
 	int ttl, err = 0;
+	local_bh_disable();
+	ndst = dst_cache_get(cache);
 	if (dst->proto == htons(ETH_P_IP)) {
 		struct rtable *rt = (struct rtable *)ndst;
 					   src->port, dst->port, false);
 #endif
 	}
+	local_bh_enable();
 	return err;
 tx_error:
+	local_bh_enable();
 	kfree_skb(skb);
 	return err;
 }

net/tls/tls_sw.c+10−7

 static int bpf_exec_tx_verdict(struct sk_msg *msg, struct sock *sk,
 			       bool full_record, u8 record_type,
-			       size_t *copied, int flags)
+			       ssize_t *copied, int flags)
 {
 	struct tls_context *tls_ctx = tls_get_ctx(sk);
 	struct tls_sw_context_tx *ctx = tls_sw_ctx_tx(tls_ctx);
 	psock = sk_psock_get(sk);
 	if (!psock || !policy) {
 		err = tls_push_record(sk, flags, record_type);
-		if (err && err != -EINPROGRESS) {
+		if (err && sk->sk_err == EBADMSG) {
 			*copied -= sk_msg_free(sk, msg);
 			tls_free_open_rec(sk);
+			err = -sk->sk_err;
 		}
 		if (psock)
 			sk_psock_put(sk, psock);
 	switch (psock->eval) {
 	case __SK_PASS:
 		err = tls_push_record(sk, flags, record_type);
-		if (err && err != -EINPROGRESS) {
+		if (err && sk->sk_err == EBADMSG) {
 			*copied -= sk_msg_free(sk, msg);
 			tls_free_open_rec(sk);
+			err = -sk->sk_err;
 			goto out_err;
 		}
 		break;
 	unsigned char record_type = TLS_RECORD_TYPE_DATA;
 	bool is_kvec = iov_iter_is_kvec(&msg->msg_iter);
 	bool eor = !(msg->msg_flags & MSG_MORE);
-	size_t try_to_copy, copied = 0;
+	size_t try_to_copy;
+	ssize_t copied = 0;
 	struct sk_msg *msg_pl, *msg_en;
 	struct tls_rec *rec;
 	int required_size;
 	release_sock(sk);
 	mutex_unlock(&tls_ctx->tx_lock);
-	return copied ? copied : ret;
+	return copied > 0 ? copied : ret;
 }
 static int tls_sw_do_sendpage(struct sock *sk, struct page *page,
 	struct sk_msg *msg_pl;
 	struct tls_rec *rec;
 	int num_async = 0;
-	size_t copied = 0;
+	ssize_t copied = 0;
 	bool full_record;
 	int record_room;
 	int ret = 0;
 	}
 sendpage_end:
 	ret = sk_stream_error(sk, flags, ret);
-	return copied ? copied : ret;
+	return copied > 0 ? copied : ret;
 }
 int tls_sw_sendpage_locked(struct sock *sk, struct page *page,

security/security.c+14−2

@@ -1965,8 +1965,20 @@ EXPORT_SYMBOL(security_ismaclabel); · 1964 unmodified lines
1965		1965
1966	int security_secid_to_secctx(u32 secid, char *secdata, u32 seclen)	1966	int security_secid_to_secctx(u32 secid, char *secdata, u32 seclen)
1967	{	1967	{
1968	return call_int_hook(secid_to_secctx, -EOPNOTSUPP, secid, secdata,	1968	struct security_hook_list *hp;
1969	seclen);	1969	int rc;
		1970
		1971	/*
		1972	* Currently, only one LSM can implement secid_to_secctx (i.e this
		1973	* LSM hook is not "stackable").
		1974	*/
		1975	hlist_for_each_entry(hp, &security_hook_heads.secid_to_secctx, list) {
		1976	rc = hp->hook.secid_to_secctx(secid, secdata, seclen);
		1977	if (rc != LSM_RET_DEFAULT(secid_to_secctx))
		1978	return rc;
		1979	}
		1980
		1981	return LSM_RET_DEFAULT(secid_to_secctx);
1970	}	1982	}
1971	EXPORT_SYMBOL(security_secid_to_secctx);	1983	EXPORT_SYMBOL(security_secid_to_secctx);
1972		1984

tools/testing/selftests/bpf/prog_tests/mmap.c+12−1

 	const size_t map_sz = roundup_page(sizeof(struct map_data));
 	const int zero = 0, one = 1, two = 2, far = 1500;
 	const long page_size = sysconf(_SC_PAGE_SIZE);
-	int err, duration = 0, i, data_map_fd, data_map_id, tmp_fd;
+	int err, duration = 0, i, data_map_fd, data_map_id, tmp_fd, rdmap_fd;
 	struct bpf_map *data_map, *bss_map;
 	void *bss_mmaped = NULL, *map_mmaped = NULL, *tmp1, *tmp2;
 	struct test_mmap__bss *bss_data;
 	data_map = skel->maps.data_map;
 	data_map_fd = bpf_map__fd(data_map);
+	rdmap_fd = bpf_map__fd(skel->maps.rdonly_map);
+	tmp1 = mmap(NULL, 4096, PROT_READ | PROT_WRITE, MAP_SHARED, rdmap_fd, 0);
+	if (CHECK(tmp1 != MAP_FAILED, "rdonly_write_mmap", "unexpected success\n")) {
+		munmap(tmp1, 4096);
+		goto cleanup;
+	}
+	/* now double-check if it's mmap()'able at all */
+	tmp1 = mmap(NULL, 4096, PROT_READ, MAP_SHARED, rdmap_fd, 0);
+	if (CHECK(tmp1 == MAP_FAILED, "rdonly_read_mmap", "failed: %d\n", errno))
+		goto cleanup;
 	/* get map's ID */
 	memset(&map_info, 0, map_info_sz);
 	err = bpf_obj_get_info_by_fd(data_map_fd, &map_info, &map_info_sz);

tools/testing/selftests/bpf/progs/test_mmap.c+8−0

@@ -7,6 +7,14 @@ · 6 unmodified lines
7		7
8	char _license[] SEC("license") = "GPL";	8	char _license[] SEC("license") = "GPL";
9		9
		10	struct {
		11	__uint(type, BPF_MAP_TYPE_ARRAY);
		12	__uint(max_entries, 4096);
		13	__uint(map_flags, BPF_F_MMAPABLE \| BPF_F_RDONLY_PROG);
		14	__type(key, __u32);
		15	__type(value, char);
		16	} rdonly_map SEC(".maps");
		17
10	struct {	18	struct {
11	__uint(type, BPF_MAP_TYPE_ARRAY);	19	__uint(type, BPF_MAP_TYPE_ARRAY);
12	__uint(max_entries, 512 * 4); /* at least 4 pages of data */	20	__uint(max_entries, 512 * 4); /* at least 4 pages of data */

tools/testing/selftests/drivers/net/mlxsw/qos_mc_aware.sh+1−1

@@ -300,7 +300,7 @@ test_uc_aware() · 299 unmodified lines
300	local i	300	local i
301		301
302	for ((i = 0; i < attempts; ++i)); do	302	for ((i = 0; i < attempts; ++i)); do
303	if $ARPING -c 1 -I $h1 -b 192.0.2.66 -q -w 0.1; then	303	if $ARPING -c 1 -I $h1 -b 192.0.2.66 -q -w 1; then
304	((passes++))	304	((passes++))
305	fi	305	fi
306		306

tools/testing/selftests/drivers/net/netdevsim/devlink_trap.sh+4−0

 	local packets_t0
 	local packets_t1
+	RET=0
 	if [ $(devlink_trap_policers_num_get) -eq 0 ]; then
 		check_err 1 "Failed to dump policers"
 	fi
 trap_policer_bind_test()
 {
+	RET=0
 	devlink trap group set $DEVLINK_DEV group l2_drops policer 1
 	check_err $? "Failed to bind a valid policer"
 	if [ $(devlink_trap_group_policer_get "l2_drops") -ne 1 ]; then

tools/testing/selftests/wireguard/qemu/Makefile+1−1

@@ -44,7 +44,7 @@ endef · 43 unmodified lines
44	$(eval $(call tar_download,MUSL,musl,1.2.0,.tar.gz,https://musl.libc.org/releases/,c6de7b191139142d3f9a7b5b702c9cae1b5ee6e7f57e582da9328629408fd4e8))	44	$(eval $(call tar_download,MUSL,musl,1.2.0,.tar.gz,https://musl.libc.org/releases/,c6de7b191139142d3f9a7b5b702c9cae1b5ee6e7f57e582da9328629408fd4e8))
45	$(eval $(call tar_download,IPERF,iperf,3.7,.tar.gz,https://downloads.es.net/pub/iperf/,d846040224317caf2f75c843d309a950a7db23f9b44b94688ccbe557d6d1710c))	45	$(eval $(call tar_download,IPERF,iperf,3.7,.tar.gz,https://downloads.es.net/pub/iperf/,d846040224317caf2f75c843d309a950a7db23f9b44b94688ccbe557d6d1710c))
46	$(eval $(call tar_download,BASH,bash,5.0,.tar.gz,https://ftp.gnu.org/gnu/bash/,b4a80f2ac66170b2913efbfb9f2594f1f76c7b1afd11f799e22035d63077fb4d))	46	$(eval $(call tar_download,BASH,bash,5.0,.tar.gz,https://ftp.gnu.org/gnu/bash/,b4a80f2ac66170b2913efbfb9f2594f1f76c7b1afd11f799e22035d63077fb4d))
47	$(eval $(call tar_download,IPROUTE2,iproute2,5.4.0,.tar.xz,https://www.kernel.org/pub/linux/utils/net/iproute2/,fe97aa60a0d4c5ac830be18937e18dc3400ca713a33a89ad896ff1e3d46086ae))	47	$(eval $(call tar_download,IPROUTE2,iproute2,5.6.0,.tar.xz,https://www.kernel.org/pub/linux/utils/net/iproute2/,1b5b0e25ce6e23da7526ea1da044e814ad85ba761b10dd29c2b027c056b04692))
48	$(eval $(call tar_download,IPTABLES,iptables,1.8.4,.tar.bz2,https://www.netfilter.org/projects/iptables/files/,993a3a5490a544c2cbf2ef15cf7e7ed21af1845baf228318d5c36ef8827e157c))	48	$(eval $(call tar_download,IPTABLES,iptables,1.8.4,.tar.bz2,https://www.netfilter.org/projects/iptables/files/,993a3a5490a544c2cbf2ef15cf7e7ed21af1845baf228318d5c36ef8827e157c))
49	$(eval $(call tar_download,NMAP,nmap,7.80,.tar.bz2,https://nmap.org/dist/,fcfa5a0e42099e12e4bf7a68ebe6fde05553383a682e816a7ec9256ab4773faa))	49	$(eval $(call tar_download,NMAP,nmap,7.80,.tar.bz2,https://nmap.org/dist/,fcfa5a0e42099e12e4bf7a68ebe6fde05553383a682e816a7ec9256ab4773faa))
50	$(eval $(call tar_download,IPUTILS,iputils,s20190709,.tar.gz,https://github.com/iputils/iputils/archive/s20190709.tar.gz/#,a15720dd741d7538dd2645f9f516d193636ae4300ff7dbc8bfca757bf166490a))	50	$(eval $(call tar_download,IPUTILS,iputils,s20190709,.tar.gz,https://github.com/iputils/iputils/archive/s20190709.tar.gz/#,a15720dd741d7538dd2645f9f516d193636ae4300ff7dbc8bfca757bf166490a))