lael-labs/linux

Documentation/networking/ip-sysctl.rst+3−4

 	default: initial size of receive buffer used by TCP sockets.
 	This value overrides net.core.rmem_default used by other protocols.
-	Default: 87380 bytes. This value results in window of 65535 with
+	Default: 131072 bytes.
-	default setting of tcp_adv_win_scale and tcp_app_win:0 and a bit
+	This value results in initial window of 65535.
-	less for default tcp_app_win. See below about these variables.
 	max: maximal size of receive buffer allowed for automatically
 	selected receiver buffers for TCP socket. This value does not override
 	net.core.rmem_max.  Calling setsockopt() with SO_RCVBUF disables
 	automatic tuning of that socket's receive buffer size, in which
 	case this value is ignored.
-	Default: between 87380B and 6MB, depending on RAM size.
+	Default: between 131072 and 6MB, depending on RAM size.
 tcp_sack - BOOLEAN
 	Enable select acknowledgments (SACKS).

Documentation/networking/netdev-FAQ.rst+16−0

@@ -272,6 +272,22 @@ to the mailing list, e.g.:: · 271 unmodified lines
272	Posting as one thread is discouraged because it confuses patchwork	272	Posting as one thread is discouraged because it confuses patchwork
273	(as of patchwork 2.2.2).	273	(as of patchwork 2.2.2).
274		274
		275	Can I reproduce the checks from patchwork on my local machine?
		276	--------------------------------------------------------------
		277
		278	Checks in patchwork are mostly simple wrappers around existing kernel
		279	scripts, the sources are available at:
		280
		281	https://github.com/kuba-moo/nipa/tree/master/tests
		282
		283	Running all the builds and checks locally is a pain, can I post my patches and have the patchwork bot validate them?
		284	--------------------------------------------------------------------------------------------------------------------
		285
		286	No, you must ensure that your patches are ready by testing them locally
		287	before posting to the mailing list. The patchwork build bot instance
		288	gets overloaded very easily and netdev@vger really doesn't need more
		289	traffic if we can help it.
		290
275	Any other tips to help ensure my net/net-next patch gets OK'd?	291	Any other tips to help ensure my net/net-next patch gets OK'd?
276	--------------------------------------------------------------	292	--------------------------------------------------------------
277	Attention to detail. Re-read your own work as if you were the	293	Attention to detail. Re-read your own work as if you were the

drivers/atm/idt77252.c+1−10

@@ -3743,16 +3743,7 @@ static int __init idt77252_init(void) · 3742 unmodified lines
3743	struct sk_buff *skb;	3743	struct sk_buff *skb;
3744		3744
3745	printk("%s: at %p\n", __func__, idt77252_init);	3745	printk("%s: at %p\n", __func__, idt77252_init);
3746		3746	BUILD_BUG_ON(sizeof(skb->cb) < sizeof(struct idt77252_skb_prv) + sizeof(struct atm_skb_data));
3747	if (sizeof(skb->cb) < sizeof(struct atm_skb_data) +
3748	sizeof(struct idt77252_skb_prv)) {
3749	printk(KERN_ERR "%s: skb->cb is too small (%lu < %lu)\n",
3750	__func__, (unsigned long) sizeof(skb->cb),
3751	(unsigned long) sizeof(struct atm_skb_data) +
3752	sizeof(struct idt77252_skb_prv));
3753	return -EIO;
3754	}
3755
3756	return pci_register_driver(&idt77252_driver);	3747	return pci_register_driver(&idt77252_driver);
3757	}	3748	}
3758		3749

drivers/atm/idt77252.h+1−1

@@ -789,7 +789,7 @@ struct idt77252_skb_prv { · 788 unmodified lines
789	struct scqe tbd; /* Transmit Buffer Descriptor */	789	struct scqe tbd; /* Transmit Buffer Descriptor */
790	dma_addr_t paddr; /* DMA handle */	790	dma_addr_t paddr; /* DMA handle */
791	u32 pool; /* sb_pool handle */	791	u32 pool; /* sb_pool handle */
792	};	792	} __packed;
793		793
794	#define IDT77252_PRV_TBD(skb) \	794	#define IDT77252_PRV_TBD(skb) \
795	(((struct idt77252_skb_prv *)(ATM_SKB(skb)+1))->tbd)	795	(((struct idt77252_skb_prv *)(ATM_SKB(skb)+1))->tbd)

drivers/net/ethernet/amd/xgbe/xgbe-common.h+14−0

 #define MDIO_PMA_10GBR_FECCTRL		0x00ab
 #endif
+#ifndef MDIO_PMA_RX_CTRL1
+#define MDIO_PMA_RX_CTRL1		0x8051
+#endif
 #ifndef MDIO_PCS_DIG_CTRL
 #define MDIO_PCS_DIG_CTRL		0x8000
 #endif
+#ifndef MDIO_PCS_DIGITAL_STAT
+#define MDIO_PCS_DIGITAL_STAT		0x8010
+#endif
 #ifndef MDIO_AN_XNP
 #define MDIO_AN_XNP			0x0016
 #endif
 #define XGBE_KR_TRAINING_ENABLE		BIT(1)
 #define XGBE_PCS_CL37_BP		BIT(12)
+#define XGBE_PCS_PSEQ_STATE_MASK	0x1c
+#define XGBE_PCS_PSEQ_STATE_POWER_GOOD	0x10
 #define XGBE_AN_CL37_INT_CMPLT		BIT(0)
 #define XGBE_AN_CL37_INT_MASK		0x01
 #define XGBE_PMA_CDR_TRACK_EN_OFF	0x00
 #define XGBE_PMA_CDR_TRACK_EN_ON	0x01
+#define XGBE_PMA_RX_RST_0_MASK		BIT(4)
+#define XGBE_PMA_RX_RST_0_RESET_ON	0x10
+#define XGBE_PMA_RX_RST_0_RESET_OFF	0x00
 /* Bit setting and getting macros
  *  The get macro will extract the current bit field value from within
  *  the variable

drivers/net/ethernet/amd/xgbe/xgbe-drv.c+1−0

@@ -1368,6 +1368,7 @@ static void xgbe_stop(struct xgbe_prv_data *pdata) · 1367 unmodified lines
1368	return;	1368	return;
1369		1369
1370	netif_tx_stop_all_queues(netdev);	1370	netif_tx_stop_all_queues(netdev);
		1371	netif_carrier_off(pdata->netdev);
1371		1372
1372	xgbe_stop_timers(pdata);	1373	xgbe_stop_timers(pdata);
1373	flush_workqueue(pdata->dev_workqueue);	1374	flush_workqueue(pdata->dev_workqueue);

drivers/net/ethernet/amd/xgbe/xgbe-mdio.c+1−2

 							     &an_restart);
 	if (an_restart) {
 		xgbe_phy_config_aneg(pdata);
-		return;
+		goto adjust_link;
 	}
 	if (pdata->phy.link) {
 	pdata->phy_if.phy_impl.stop(pdata);
 	pdata->phy.link = 0;
-	netif_carrier_off(pdata->netdev);
 	xgbe_phy_adjust_link(pdata);
 }

drivers/net/ethernet/amd/xgbe/xgbe-phy-v2.c+38−1

@@ -922,6 +922,9 @@ static bool xgbe_phy_belfuse_phy_quirks(struct xgbe_prv_data *pdata) · 921 unmodified lines
922	if ((phy_id & 0xfffffff0) != 0x03625d10)	922	if ((phy_id & 0xfffffff0) != 0x03625d10)
923	return false;	923	return false;
924		924
		925	/* Reset PHY - wait for self-clearing reset bit to clear */
		926	genphy_soft_reset(phy_data->phydev);
		927
925	/* Disable RGMII mode */	928	/* Disable RGMII mode */
926	phy_write(phy_data->phydev, 0x18, 0x7007);	929	phy_write(phy_data->phydev, 0x18, 0x7007);
927	reg = phy_read(phy_data->phydev, 0x18);	930	reg = phy_read(phy_data->phydev, 0x18);
@@ -1953,6 +1956,27 @@ static void xgbe_phy_set_redrv_mode(struct xgbe_prv_data *pdata) · 1025 unmodified lines
1953	xgbe_phy_put_comm_ownership(pdata);	1956	xgbe_phy_put_comm_ownership(pdata);
1954	}	1957	}
1955		1958
		1959	static void xgbe_phy_rx_reset(struct xgbe_prv_data *pdata)
		1960	{
		1961	int reg;
		1962
		1963	reg = XMDIO_READ_BITS(pdata, MDIO_MMD_PCS, MDIO_PCS_DIGITAL_STAT,
		1964	XGBE_PCS_PSEQ_STATE_MASK);
		1965	if (reg == XGBE_PCS_PSEQ_STATE_POWER_GOOD) {
		1966	/* Mailbox command timed out, reset of RX block is required.
		1967	* This can be done by asseting the reset bit and wait for
		1968	* its compeletion.
		1969	*/
		1970	XMDIO_WRITE_BITS(pdata, MDIO_MMD_PMAPMD, MDIO_PMA_RX_CTRL1,
		1971	XGBE_PMA_RX_RST_0_MASK, XGBE_PMA_RX_RST_0_RESET_ON);
		1972	ndelay(20);
		1973	XMDIO_WRITE_BITS(pdata, MDIO_MMD_PMAPMD, MDIO_PMA_RX_CTRL1,
		1974	XGBE_PMA_RX_RST_0_MASK, XGBE_PMA_RX_RST_0_RESET_OFF);
		1975	usleep_range(40, 50);
		1976	netif_err(pdata, link, pdata->netdev, "firmware mailbox reset performed\n");
		1977	}
		1978	}
		1979
1956	static void xgbe_phy_perform_ratechange(struct xgbe_prv_data *pdata,	1980	static void xgbe_phy_perform_ratechange(struct xgbe_prv_data *pdata,
1957	unsigned int cmd, unsigned int sub_cmd)	1981	unsigned int cmd, unsigned int sub_cmd)
1958	{	1982	{
@@ -1960,9 +1984,11 @@ static void xgbe_phy_perform_ratechange(struct xgbe_prv_data *pdata, · 1 unmodified line
1960	unsigned int wait;	1984	unsigned int wait;
1961		1985
1962	/* Log if a previous command did not complete */	1986	/* Log if a previous command did not complete */
1963	if (XP_IOREAD_BITS(pdata, XP_DRIVER_INT_RO, STATUS))	1987	if (XP_IOREAD_BITS(pdata, XP_DRIVER_INT_RO, STATUS)) {
1964	netif_dbg(pdata, link, pdata->netdev,	1988	netif_dbg(pdata, link, pdata->netdev,
1965	"firmware mailbox not ready for command\n");	1989	"firmware mailbox not ready for command\n");
		1990	xgbe_phy_rx_reset(pdata);
		1991	}
1966		1992
1967	/* Construct the command */	1993	/* Construct the command */
1968	XP_SET_BITS(s0, XP_DRIVER_SCRATCH_0, COMMAND, cmd);	1994	XP_SET_BITS(s0, XP_DRIVER_SCRATCH_0, COMMAND, cmd);
@@ -1984,6 +2010,9 @@ static void xgbe_phy_perform_ratechange(struct xgbe_prv_data *pdata, · 15 unmodified lines
1984		2010
1985	netif_dbg(pdata, link, pdata->netdev,	2011	netif_dbg(pdata, link, pdata->netdev,
1986	"firmware mailbox command did not complete\n");	2012	"firmware mailbox command did not complete\n");
		2013
		2014	/* Reset on error */
		2015	xgbe_phy_rx_reset(pdata);
1987	}	2016	}
1988		2017
1989	static void xgbe_phy_rrc(struct xgbe_prv_data *pdata)	2018	static void xgbe_phy_rrc(struct xgbe_prv_data *pdata)
@@ -2584,6 +2613,14 @@ static int xgbe_phy_link_status(struct xgbe_prv_data pdata, int an_restart) · 594 unmodified lines
2584	if (reg & MDIO_STAT1_LSTATUS)	2613	if (reg & MDIO_STAT1_LSTATUS)
2585	return 1;	2614	return 1;
2586		2615
		2616	if (pdata->phy.autoneg == AUTONEG_ENABLE &&
		2617	phy_data->port_mode == XGBE_PORT_MODE_BACKPLANE) {
		2618	if (!test_bit(XGBE_LINK_INIT, &pdata->dev_state)) {
		2619	netif_carrier_off(pdata->netdev);
		2620	*an_restart = 1;
		2621	}
		2622	}
		2623
2587	/* No link, attempt a receiver reset cycle */	2624	/* No link, attempt a receiver reset cycle */
2588	if (phy_data->rrc_count++ > XGBE_RRC_FREQUENCY) {	2625	if (phy_data->rrc_count++ > XGBE_RRC_FREQUENCY) {
2589	phy_data->rrc_count = 0;	2626	phy_data->rrc_count = 0;

drivers/net/ethernet/aquantia/atlantic/aq_main.c+3−1

 		goto err_exit;
 	err = aq_nic_start(aq_nic);
-	if (err < 0)
+	if (err < 0) {
+		aq_nic_stop(aq_nic);
 		goto err_exit;
+	}
 err_exit:
 	if (err < 0)

drivers/net/ethernet/broadcom/bnxt/bnxt.c+2−1

 			txr->dev_state = BNXT_DEV_STATE_CLOSING;
 		}
 	}
+	/* Drop carrier first to prevent TX timeout */
+	netif_carrier_off(bp->dev);
 	/* Stop all TX queues */
 	netif_tx_disable(bp->dev);
-	netif_carrier_off(bp->dev);
 }
 void bnxt_tx_enable(struct bnxt *bp)

drivers/net/ethernet/broadcom/bnxt/bnxt_devlink.c+2−2

@@ -471,8 +471,8 @@ static int bnxt_dl_info_get(struct devlink dl, struct devlink_info_req req, · 470 unmodified lines
471	if (BNXT_PF(bp) && !bnxt_hwrm_get_nvm_cfg_ver(bp, &nvm_cfg_ver)) {	471	if (BNXT_PF(bp) && !bnxt_hwrm_get_nvm_cfg_ver(bp, &nvm_cfg_ver)) {
472	u32 ver = nvm_cfg_ver.vu32;	472	u32 ver = nvm_cfg_ver.vu32;
473		473
474	sprintf(buf, "%X.%X.%X", (ver >> 16) & 0xF, (ver >> 8) & 0xF,	474	sprintf(buf, "%d.%d.%d", (ver >> 16) & 0xf, (ver >> 8) & 0xf,
475	ver & 0xF);	475	ver & 0xf);
476	rc = bnxt_dl_info_put(bp, req, BNXT_VERSION_STORED,	476	rc = bnxt_dl_info_put(bp, req, BNXT_VERSION_STORED,
477	DEVLINK_INFO_VERSION_GENERIC_FW_PSID,	477	DEVLINK_INFO_VERSION_GENERIC_FW_PSID,
478	buf);	478	buf);

drivers/net/ethernet/chelsio/cxgb4/cxgb4_uld.h+3−0

@@ -46,6 +46,9 @@ · 45 unmodified lines
46	#define MAX_ULD_QSETS 16	46	#define MAX_ULD_QSETS 16
47	#define MAX_ULD_NPORTS 4	47	#define MAX_ULD_NPORTS 4
48		48
		49	/* ulp_mem_io + ulptx_idata + payload + padding */
		50	#define MAX_IMM_ULPTX_WR_LEN (32 + 8 + 256 + 8)
		51
49	/* CPL message priority levels */	52	/* CPL message priority levels */
50	enum {	53	enum {
51	CPL_PRIORITY_DATA = 0, /* data messages */	54	CPL_PRIORITY_DATA = 0, /* data messages */

drivers/net/ethernet/chelsio/cxgb4/sge.c+8−3

  *	@skb: the packet
  *
  *	Returns true if a packet can be sent as an offload WR with immediate
- *	data.  We currently use the same limit as for Ethernet packets.
+ *	data.
+ *	FW_OFLD_TX_DATA_WR limits the payload to 255 bytes due to 8-bit field.
+ *      However, FW_ULPTX_WR commands have a 256 byte immediate only
+ *      payload limit.
  */
 static inline int is_ofld_imm(const struct sk_buff *skb)
 {
 	struct work_request_hdr *req = (struct work_request_hdr *)skb->data;
 	unsigned long opcode = FW_WR_OP_G(ntohl(req->wr_hi));
-	if (opcode == FW_CRYPTO_LOOKASIDE_WR)
+	if (unlikely(opcode == FW_ULPTX_WR))
+		return skb->len <= MAX_IMM_ULPTX_WR_LEN;
+	else if (opcode == FW_CRYPTO_LOOKASIDE_WR)
 		return skb->len <= SGE_MAX_WR_LEN;
 	else
-		return skb->len <= MAX_IMM_TX_PKT_LEN;
+		return skb->len <= MAX_IMM_OFLD_TX_DATA_WR_LEN;
 }
 /**

drivers/net/ethernet/chelsio/inline_crypto/chtls/chtls_cm.h+0−3

@@ -50,9 +50,6 @@ · 49 unmodified lines
50	#define MIN_RCV_WND (24 * 1024U)	50	#define MIN_RCV_WND (24 * 1024U)
51	#define LOOPBACK(x) (((x) & htonl(0xff000000)) == htonl(0x7f000000))	51	#define LOOPBACK(x) (((x) & htonl(0xff000000)) == htonl(0x7f000000))
52		52
53	/* ulp_mem_io + ulptx_idata + payload + padding */
54	#define MAX_IMM_ULPTX_WR_LEN (32 + 8 + 256 + 8)
55
56	/* for TX: a skb must have a headroom of at least TX_HEADER_LEN bytes */	53	/* for TX: a skb must have a headroom of at least TX_HEADER_LEN bytes */
57	#define TX_HEADER_LEN \	54	#define TX_HEADER_LEN \
58	(sizeof(struct fw_ofld_tx_data_wr) + sizeof(struct sge_opaque_hdr))	55	(sizeof(struct fw_ofld_tx_data_wr) + sizeof(struct sge_opaque_hdr))

drivers/net/ethernet/freescale/dpaa2/dpaa2-eth.c+12−2

 		xdp.frame_sz = DPAA2_ETH_RX_BUF_RAW_SIZE;
 		err = xdp_do_redirect(priv->net_dev, &xdp, xdp_prog);
-		if (unlikely(err))
+		if (unlikely(err)) {
+			addr = dma_map_page(priv->net_dev->dev.parent,
+					    virt_to_page(vaddr), 0,
+					    priv->rx_buf_size, DMA_BIDIRECTIONAL);
+			if (unlikely(dma_mapping_error(priv->net_dev->dev.parent, addr))) {
+				free_pages((unsigned long)vaddr, 0);
+			} else {
+				ch->buf_count++;
+				dpaa2_eth_xdp_release_buf(priv, ch, addr);
+			}
 			ch->stats.xdp_drop++;
-		else
+		} else {
 			ch->stats.xdp_redirect++;
+		}
 		break;
 	}

drivers/net/ethernet/freescale/enetc/Kconfig+1−1

@@ -27,7 +27,7 @@ config FSL_ENETC_VF · 26 unmodified lines
27		27
28	config FSL_ENETC_MDIO	28	config FSL_ENETC_MDIO
29	tristate "ENETC MDIO driver"	29	tristate "ENETC MDIO driver"
30	depends on PCI	30	depends on PCI && MDIO_DEVRES && MDIO_BUS
31	help	31	help
32	This driver supports NXP ENETC Central MDIO controller as a PCIe	32	This driver supports NXP ENETC Central MDIO controller as a PCIe
33	physical function (PF) device.	33	physical function (PF) device.

drivers/net/ethernet/freescale/enetc/enetc_pf.c+3−2

 	struct enetc_ndev_priv *priv;
 	priv = netdev_priv(si->ndev);
-	enetc_phylink_destroy(priv);
-	enetc_mdiobus_destroy(pf);
 	if (pf->num_vfs)
 		enetc_sriov_configure(pdev, 0);
 	unregister_netdev(si->ndev);
+	enetc_phylink_destroy(priv);
+	enetc_mdiobus_destroy(pf);
 	enetc_free_msix(priv);
 	enetc_free_si_resources(priv);

drivers/net/ethernet/ibm/ibmvnic.c+32−12

 	if (!ltb->buff)
 		return;
+	/* VIOS automatically unmaps the long term buffer at remote
+	 * end for the following resets:
+	 * FAILOVER, MOBILITY, TIMEOUT.
+	 */
 	if (adapter->reset_reason != VNIC_RESET_FAILOVER &&
-	    adapter->reset_reason != VNIC_RESET_MOBILITY)
+	    adapter->reset_reason != VNIC_RESET_MOBILITY &&
+	    adapter->reset_reason != VNIC_RESET_TIMEOUT)
 		send_request_unmap(adapter, ltb->map_id);
 	dma_free_coherent(dev, ltb->size, ltb->buff, ltb->addr);
 }
 	adapter->state = VNIC_CLOSING;
 	rc = set_link_state(adapter, IBMVNIC_LOGICAL_LNK_DN);
-	if (rc)
-		return rc;
 	adapter->state = VNIC_CLOSED;
-	return 0;
+	return rc;
 }
 static int ibmvnic_close(struct net_device *netdev)
 		skb_copy_from_linear_data(skb, dst, skb->len);
 	}
+	/* post changes to long_term_buff *dst before VIOS accessing it */
+	dma_wmb();
 	tx_pool->consumer_index =
 	    (tx_pool->consumer_index + 1) % tx_pool->num_buffers;
 	unsigned long flags;
 	int ret;
-	/* If failover is pending don't schedule any other reset.
+	/*
+	 * If failover is pending don't schedule any other reset.
 	 * Instead let the failover complete. If there is already a
 	 * a failover reset scheduled, we will detect and drop the
 	 * duplicate reset when walking the ->rwi_list below.
 		goto err;
 	}
-	spin_lock_irqsave(&adapter->rwi_lock, flags);
 	list_for_each(entry, &adapter->rwi_list) {
 		tmp = list_entry(entry, struct ibmvnic_rwi, list);
 		if (tmp->reset_reason == reason) {
 			netdev_dbg(netdev, "Skipping matching reset, reason=%d\n",
 				   reason);
-			spin_unlock_irqrestore(&adapter->rwi_lock, flags);
 			ret = EBUSY;
 			goto err;
 		}
 	rwi = kzalloc(sizeof(*rwi), GFP_ATOMIC);
 	if (!rwi) {
-		spin_unlock_irqrestore(&adapter->rwi_lock, flags);
-		ibmvnic_close(netdev);
 		ret = ENOMEM;
 		goto err;
 	}
 	}
 	rwi->reset_reason = reason;
 	list_add_tail(&rwi->list, &adapter->rwi_list);
-	spin_unlock_irqrestore(&adapter->rwi_lock, flags);
 	netdev_dbg(adapter->netdev, "Scheduling reset (reason %d)\n", reason);
 	schedule_work(&adapter->ibmvnic_reset);
-	return 0;
+	ret = 0;
 err:
+	/* ibmvnic_close() below can block, so drop the lock first */
+	spin_unlock_irqrestore(&adapter->rwi_lock, flags);
+	if (ret == ENOMEM)
+		ibmvnic_close(netdev);
 	return -ret;
 }
 		offset = be16_to_cpu(next->rx_comp.off_frame_data);
 		flags = next->rx_comp.flags;
 		skb = rx_buff->skb;
+		/* load long_term_buff before copying to skb */
+		dma_rmb();
 		skb_copy_to_linear_data(skb, rx_buff->data + offset,
 					length);
 	unsigned long flags;
 	spin_lock_irqsave(&adapter->state_lock, flags);
+	/* If ibmvnic_reset() is scheduling a reset, wait for it to
+	 * finish. Then, set the state to REMOVING to prevent it from
+	 * scheduling any more work and to have reset functions ignore
+	 * any resets that have already been scheduled. Drop the lock
+	 * after setting state, so __ibmvnic_reset() which is called
+	 * from the flush_work() below, can make progress.
+	 */
+	spin_lock_irqsave(&adapter->rwi_lock, flags);
 	adapter->state = VNIC_REMOVING;
+	spin_unlock_irqrestore(&adapter->rwi_lock, flags);
 	spin_unlock_irqrestore(&adapter->state_lock, flags);
 	flush_work(&adapter->ibmvnic_reset);

drivers/net/ethernet/ibm/ibmvnic.h+3−1

 #define IBMVNIC_BUFFS_PER_POOL	100
 #define IBMVNIC_MAX_QUEUES	16
 #define IBMVNIC_MAX_QUEUE_SZ   4096
-#define IBMVNIC_MAX_IND_DESCS  128
+#define IBMVNIC_MAX_IND_DESCS  16
 #define IBMVNIC_IND_ARR_SZ	(IBMVNIC_MAX_IND_DESCS * 32)
 #define IBMVNIC_TSO_BUF_SZ	65536
 	/* Used for serializatin of state field */
 	spinlock_t state_lock;
 	enum ibmvnic_reset_reason reset_reason;
+	/* when taking both state and rwi locks, take state lock first */
+	spinlock_t rwi_lock;
 	struct list_head rwi_list;
 	/* Used for serialization of rwi_list */
 	spinlock_t rwi_lock;

drivers/net/ethernet/mellanox/mlx5/core/devlink.c+9−0

 		return -EOPNOTSUPP;
 	}
+	if (mlx5_lag_is_active(dev)) {
+		NL_SET_ERR_MSG_MOD(extack, "reload is unsupported in Lag mode\n");
+		return -EOPNOTSUPP;
+	}
 	switch (action) {
 	case DEVLINK_RELOAD_ACTION_DRIVER_REINIT:
 		mlx5_unload_one(dev, false);
 		NL_SET_ERR_MSG_MOD(extack, "Device doesn't support RoCE");
 		return -EOPNOTSUPP;
 	}
+	if (mlx5_core_is_mp_slave(dev) || mlx5_lag_is_active(dev)) {
+		NL_SET_ERR_MSG_MOD(extack, "Multi port slave/Lag device can't configure RoCE");
+		return -EOPNOTSUPP;
+	}
 	return 0;
 }

drivers/net/ethernet/mellanox/mlx5/core/en/tc_ct.c+192−67

@@ -12,6 +12,7 @@ · 11 unmodified lines
12	#include <net/flow_offload.h>	12	#include <net/flow_offload.h>
13	#include <net/netfilter/nf_flow_table.h>	13	#include <net/netfilter/nf_flow_table.h>
14	#include <linux/workqueue.h>	14	#include <linux/workqueue.h>
		15	#include <linux/refcount.h>
15	#include <linux/xarray.h>	16	#include <linux/xarray.h>
16		17
17	#include "lib/fs_chains.h"	18	#include "lib/fs_chains.h"
@@ -52,11 +53,11 @@ struct mlx5_tc_ct_priv { · 34 unmodified lines
52	struct mlx5_flow_table *ct_nat;	53	struct mlx5_flow_table *ct_nat;
53	struct mlx5_flow_table *post_ct;	54	struct mlx5_flow_table *post_ct;
54	struct mutex control_lock; /* guards parallel adds/dels */	55	struct mutex control_lock; /* guards parallel adds/dels */
55	struct mutex shared_counter_lock;
56	struct mapping_ctx *zone_mapping;	56	struct mapping_ctx *zone_mapping;
57	struct mapping_ctx *labels_mapping;	57	struct mapping_ctx *labels_mapping;
58	enum mlx5_flow_namespace_type ns_type;	58	enum mlx5_flow_namespace_type ns_type;
59	struct mlx5_fs_chains *chains;	59	struct mlx5_fs_chains *chains;
		60	spinlock_t ht_lock; /* protects ft entries */
60	};	61	};
61		62
62	struct mlx5_ct_flow {	63	struct mlx5_ct_flow {
@@ -125,6 +126,10 @@ struct mlx5_ct_counter { · 62 unmodified lines
125	bool is_shared;	126	bool is_shared;
126	};	127	};
127		128
		129	enum {
		130	MLX5_CT_ENTRY_FLAG_VALID,
		131	};
		132
128	struct mlx5_ct_entry {	133	struct mlx5_ct_entry {
129	struct rhash_head node;	134	struct rhash_head node;
130	struct rhash_head tuple_node;	135	struct rhash_head tuple_node;
@@ -135,6 +140,12 @@ struct mlx5_ct_entry { · 4 unmodified lines
135	struct mlx5_ct_tuple tuple;	140	struct mlx5_ct_tuple tuple;
136	struct mlx5_ct_tuple tuple_nat;	141	struct mlx5_ct_tuple tuple_nat;
137	struct mlx5_ct_zone_rule zone_rules[2];	142	struct mlx5_ct_zone_rule zone_rules[2];
		143
		144	struct mlx5_tc_ct_priv *ct_priv;
		145	struct work_struct work;
		146
		147	refcount_t refcnt;
		148	unsigned long flags;
138	};	149	};
139		150
140	static const struct rhashtable_params cts_ht_params = {	151	static const struct rhashtable_params cts_ht_params = {
@@ -742,6 +753,87 @@ err_attr: · 601 unmodified lines
742	return err;	753	return err;
743	}	754	}
744		755
		756	static bool
		757	mlx5_tc_ct_entry_valid(struct mlx5_ct_entry *entry)
		758	{
		759	return test_bit(MLX5_CT_ENTRY_FLAG_VALID, &entry->flags);
		760	}
		761
		762	static struct mlx5_ct_entry *
		763	mlx5_tc_ct_entry_get(struct mlx5_tc_ct_priv ct_priv, struct mlx5_ct_tuple tuple)
		764	{
		765	struct mlx5_ct_entry *entry;
		766
		767	entry = rhashtable_lookup_fast(&ct_priv->ct_tuples_ht, tuple,
		768	tuples_ht_params);
		769	if (entry && mlx5_tc_ct_entry_valid(entry) &&
		770	refcount_inc_not_zero(&entry->refcnt)) {
		771	return entry;
		772	} else if (!entry) {
		773	entry = rhashtable_lookup_fast(&ct_priv->ct_tuples_nat_ht,
		774	tuple, tuples_nat_ht_params);
		775	if (entry && mlx5_tc_ct_entry_valid(entry) &&
		776	refcount_inc_not_zero(&entry->refcnt))
		777	return entry;
		778	}
		779
		780	return entry ? ERR_PTR(-EINVAL) : NULL;
		781	}
		782
		783	static void mlx5_tc_ct_entry_remove_from_tuples(struct mlx5_ct_entry *entry)
		784	{
		785	struct mlx5_tc_ct_priv *ct_priv = entry->ct_priv;
		786
		787	rhashtable_remove_fast(&ct_priv->ct_tuples_nat_ht,
		788	&entry->tuple_nat_node,
		789	tuples_nat_ht_params);
		790	rhashtable_remove_fast(&ct_priv->ct_tuples_ht, &entry->tuple_node,
		791	tuples_ht_params);
		792	}
		793
		794	static void mlx5_tc_ct_entry_del(struct mlx5_ct_entry *entry)
		795	{
		796	struct mlx5_tc_ct_priv *ct_priv = entry->ct_priv;
		797
		798	mlx5_tc_ct_entry_del_rules(ct_priv, entry);
		799
		800	spin_lock_bh(&ct_priv->ht_lock);
		801	mlx5_tc_ct_entry_remove_from_tuples(entry);
		802	spin_unlock_bh(&ct_priv->ht_lock);
		803
		804	mlx5_tc_ct_counter_put(ct_priv, entry);
		805	kfree(entry);
		806	}
		807
		808	static void
		809	mlx5_tc_ct_entry_put(struct mlx5_ct_entry *entry)
		810	{
		811	if (!refcount_dec_and_test(&entry->refcnt))
		812	return;
		813
		814	mlx5_tc_ct_entry_del(entry);
		815	}
		816
		817	static void mlx5_tc_ct_entry_del_work(struct work_struct *work)
		818	{
		819	struct mlx5_ct_entry *entry = container_of(work, struct mlx5_ct_entry, work);
		820
		821	mlx5_tc_ct_entry_del(entry);
		822	}
		823
		824	static void
		825	__mlx5_tc_ct_entry_put(struct mlx5_ct_entry *entry)
		826	{
		827	struct mlx5e_priv *priv;
		828
		829	if (!refcount_dec_and_test(&entry->refcnt))
		830	return;
		831
		832	priv = netdev_priv(entry->ct_priv->netdev);
		833	INIT_WORK(&entry->work, mlx5_tc_ct_entry_del_work);
		834	queue_work(priv->wq, &entry->work);
		835	}
		836
745	static struct mlx5_ct_counter *	837	static struct mlx5_ct_counter *
746	mlx5_tc_ct_counter_create(struct mlx5_tc_ct_priv *ct_priv)	838	mlx5_tc_ct_counter_create(struct mlx5_tc_ct_priv *ct_priv)
747	{	839	{
@@ -793,16 +885,26 @@ mlx5_tc_ct_shared_counter_get(struct mlx5_tc_ct_priv *ct_priv, · 45 unmodified lines
793	}	885	}
794		886
795	/* Use the same counter as the reverse direction */	887	/* Use the same counter as the reverse direction */
796	mutex_lock(&ct_priv->shared_counter_lock);	888	spin_lock_bh(&ct_priv->ht_lock);
797	rev_entry = rhashtable_lookup_fast(&ct_priv->ct_tuples_ht, &rev_tuple,	889	rev_entry = mlx5_tc_ct_entry_get(ct_priv, &rev_tuple);
798	tuples_ht_params);	890
799	if (rev_entry) {	891	if (IS_ERR(rev_entry)) {
800	if (refcount_inc_not_zero(&rev_entry->counter->refcount)) {	892	spin_unlock_bh(&ct_priv->ht_lock);
801	mutex_unlock(&ct_priv->shared_counter_lock);	893	goto create_counter;
802	return rev_entry->counter;
803	}
804	}	894	}
805	mutex_unlock(&ct_priv->shared_counter_lock);	895
		896	if (rev_entry && refcount_inc_not_zero(&rev_entry->counter->refcount)) {
		897	ct_dbg("Using shared counter entry=0x%p rev=0x%p\n", entry, rev_entry);
		898	shared_counter = rev_entry->counter;
		899	spin_unlock_bh(&ct_priv->ht_lock);
		900
		901	mlx5_tc_ct_entry_put(rev_entry);
		902	return shared_counter;
		903	}
		904
		905	spin_unlock_bh(&ct_priv->ht_lock);
		906
		907	create_counter:
806		908
807	shared_counter = mlx5_tc_ct_counter_create(ct_priv);	909	shared_counter = mlx5_tc_ct_counter_create(ct_priv);
808	if (IS_ERR(shared_counter))	910	if (IS_ERR(shared_counter))
@@ -865,10 +967,14 @@ mlx5_tc_ct_block_flow_offload_add(struct mlx5_ct_ft *ft, · 56 unmodified lines
865	if (!meta_action)	967	if (!meta_action)
866	return -EOPNOTSUPP;	968	return -EOPNOTSUPP;
867		969
868	entry = rhashtable_lookup_fast(&ft->ct_entries_ht, &cookie,	970	spin_lock_bh(&ct_priv->ht_lock);
869	cts_ht_params);	971	entry = rhashtable_lookup_fast(&ft->ct_entries_ht, &cookie, cts_ht_params);
870	if (entry)	972	if (entry && refcount_inc_not_zero(&entry->refcnt)) {
871	return 0;	973	spin_unlock_bh(&ct_priv->ht_lock);
		974	mlx5_tc_ct_entry_put(entry);
		975	return -EEXIST;
		976	}
		977	spin_unlock_bh(&ct_priv->ht_lock);
872		978
873	entry = kzalloc(sizeof(*entry), GFP_KERNEL);	979	entry = kzalloc(sizeof(*entry), GFP_KERNEL);
874	if (!entry)	980	if (!entry)
@@ -877,6 +983,8 @@ mlx5_tc_ct_block_flow_offload_add(struct mlx5_ct_ft *ft, · 2 unmodified lines
877	entry->tuple.zone = ft->zone;	983	entry->tuple.zone = ft->zone;
878	entry->cookie = flow->cookie;	984	entry->cookie = flow->cookie;
879	entry->restore_cookie = meta_action->ct_metadata.cookie;	985	entry->restore_cookie = meta_action->ct_metadata.cookie;
		986	refcount_set(&entry->refcnt, 2);
		987	entry->ct_priv = ct_priv;
880		988
881	err = mlx5_tc_ct_rule_to_tuple(&entry->tuple, flow_rule);	989	err = mlx5_tc_ct_rule_to_tuple(&entry->tuple, flow_rule);
882	if (err)	990	if (err)
@@ -887,35 +995,40 @@ mlx5_tc_ct_block_flow_offload_add(struct mlx5_ct_ft *ft, · 4 unmodified lines
887	if (err)	995	if (err)
888	goto err_set;	996	goto err_set;
889		997
890	err = rhashtable_insert_fast(&ct_priv->ct_tuples_ht,	998	spin_lock_bh(&ct_priv->ht_lock);
891	&entry->tuple_node,	999
892	tuples_ht_params);	1000	err = rhashtable_lookup_insert_fast(&ft->ct_entries_ht, &entry->node,
		1001	cts_ht_params);
		1002	if (err)
		1003	goto err_entries;
		1004
		1005	err = rhashtable_lookup_insert_fast(&ct_priv->ct_tuples_ht,
		1006	&entry->tuple_node,
		1007	tuples_ht_params);
893	if (err)	1008	if (err)
894	goto err_tuple;	1009	goto err_tuple;
895		1010
896	if (memcmp(&entry->tuple, &entry->tuple_nat, sizeof(entry->tuple))) {	1011	if (memcmp(&entry->tuple, &entry->tuple_nat, sizeof(entry->tuple))) {
897	err = rhashtable_insert_fast(&ct_priv->ct_tuples_nat_ht,	1012	err = rhashtable_lookup_insert_fast(&ct_priv->ct_tuples_nat_ht,
898	&entry->tuple_nat_node,	1013	&entry->tuple_nat_node,
899	tuples_nat_ht_params);	1014	tuples_nat_ht_params);
900	if (err)	1015	if (err)
901	goto err_tuple_nat;	1016	goto err_tuple_nat;
902	}	1017	}
		1018	spin_unlock_bh(&ct_priv->ht_lock);
903		1019
904	err = mlx5_tc_ct_entry_add_rules(ct_priv, flow_rule, entry,	1020	err = mlx5_tc_ct_entry_add_rules(ct_priv, flow_rule, entry,
905	ft->zone_restore_id);	1021	ft->zone_restore_id);
906	if (err)	1022	if (err)
907	goto err_rules;	1023	goto err_rules;
908		1024
909	err = rhashtable_insert_fast(&ft->ct_entries_ht, &entry->node,	1025	set_bit(MLX5_CT_ENTRY_FLAG_VALID, &entry->flags);
910	cts_ht_params);	1026	mlx5_tc_ct_entry_put(entry); /* this function reference */
911	if (err)
912	goto err_insert;
913		1027
914	return 0;	1028	return 0;
915		1029
916	err_insert:
917	mlx5_tc_ct_entry_del_rules(ct_priv, entry);
918	err_rules:	1030	err_rules:
		1031	spin_lock_bh(&ct_priv->ht_lock);
919	if (mlx5_tc_ct_entry_has_nat(entry))	1032	if (mlx5_tc_ct_entry_has_nat(entry))
920	rhashtable_remove_fast(&ct_priv->ct_tuples_nat_ht,	1033	rhashtable_remove_fast(&ct_priv->ct_tuples_nat_ht,
921	&entry->tuple_nat_node, tuples_nat_ht_params);	1034	&entry->tuple_nat_node, tuples_nat_ht_params);
@@ -924,47 +1037,43 @@ err_tuple_nat: · 2 unmodified lines
924	&entry->tuple_node,	1037	&entry->tuple_node,
925	tuples_ht_params);	1038	tuples_ht_params);
926	err_tuple:	1039	err_tuple:
		1040	rhashtable_remove_fast(&ft->ct_entries_ht,
		1041	&entry->node,
		1042	cts_ht_params);
		1043	err_entries:
		1044	spin_unlock_bh(&ct_priv->ht_lock);
927	err_set:	1045	err_set:
928	kfree(entry);	1046	kfree(entry);
929	netdev_warn(ct_priv->netdev,	1047	if (err != -EEXIST)
930	"Failed to offload ct entry, err: %d\n", err);	1048	netdev_warn(ct_priv->netdev, "Failed to offload ct entry, err: %d\n", err);
931	return err;	1049	return err;
932	}	1050	}
933		1051
934	static void
935	mlx5_tc_ct_del_ft_entry(struct mlx5_tc_ct_priv *ct_priv,
936	struct mlx5_ct_entry *entry)
937	{
938	mlx5_tc_ct_entry_del_rules(ct_priv, entry);
939	mutex_lock(&ct_priv->shared_counter_lock);
940	if (mlx5_tc_ct_entry_has_nat(entry))
941	rhashtable_remove_fast(&ct_priv->ct_tuples_nat_ht,
942	&entry->tuple_nat_node,
943	tuples_nat_ht_params);
944	rhashtable_remove_fast(&ct_priv->ct_tuples_ht, &entry->tuple_node,
945	tuples_ht_params);
946	mutex_unlock(&ct_priv->shared_counter_lock);
947	mlx5_tc_ct_counter_put(ct_priv, entry);
948
949	}
950
951	static int	1052	static int
952	mlx5_tc_ct_block_flow_offload_del(struct mlx5_ct_ft *ft,	1053	mlx5_tc_ct_block_flow_offload_del(struct mlx5_ct_ft *ft,
953	struct flow_cls_offload *flow)	1054	struct flow_cls_offload *flow)
954	{	1055	{
		1056	struct mlx5_tc_ct_priv *ct_priv = ft->ct_priv;
955	unsigned long cookie = flow->cookie;	1057	unsigned long cookie = flow->cookie;
956	struct mlx5_ct_entry *entry;	1058	struct mlx5_ct_entry *entry;
957		1059
958	entry = rhashtable_lookup_fast(&ft->ct_entries_ht, &cookie,	1060	spin_lock_bh(&ct_priv->ht_lock);
959	cts_ht_params);	1061	entry = rhashtable_lookup_fast(&ft->ct_entries_ht, &cookie, cts_ht_params);
960	if (!entry)	1062	if (!entry) {
		1063	spin_unlock_bh(&ct_priv->ht_lock);
961	return -ENOENT;	1064	return -ENOENT;
		1065	}
962		1066
963	mlx5_tc_ct_del_ft_entry(ft->ct_priv, entry);	1067	if (!mlx5_tc_ct_entry_valid(entry)) {
964	WARN_ON(rhashtable_remove_fast(&ft->ct_entries_ht,	1068	spin_unlock_bh(&ct_priv->ht_lock);
965	&entry->node,	1069	return -EINVAL;
966	cts_ht_params));	1070	}
967	kfree(entry);	1071
		1072	rhashtable_remove_fast(&ft->ct_entries_ht, &entry->node, cts_ht_params);
		1073	mlx5_tc_ct_entry_remove_from_tuples(entry);
		1074	spin_unlock_bh(&ct_priv->ht_lock);
		1075
		1076	mlx5_tc_ct_entry_put(entry);
968		1077
969	return 0;	1078	return 0;
970	}	1079	}
@@ -973,19 +1082,30 @@ static int · 2 unmodified lines
973	mlx5_tc_ct_block_flow_offload_stats(struct mlx5_ct_ft *ft,	1082	mlx5_tc_ct_block_flow_offload_stats(struct mlx5_ct_ft *ft,
974	struct flow_cls_offload *f)	1083	struct flow_cls_offload *f)
975	{	1084	{
		1085	struct mlx5_tc_ct_priv *ct_priv = ft->ct_priv;
976	unsigned long cookie = f->cookie;	1086	unsigned long cookie = f->cookie;
977	struct mlx5_ct_entry *entry;	1087	struct mlx5_ct_entry *entry;
978	u64 lastuse, packets, bytes;	1088	u64 lastuse, packets, bytes;
979		1089
980	entry = rhashtable_lookup_fast(&ft->ct_entries_ht, &cookie,	1090	spin_lock_bh(&ct_priv->ht_lock);
981	cts_ht_params);	1091	entry = rhashtable_lookup_fast(&ft->ct_entries_ht, &cookie, cts_ht_params);
982	if (!entry)	1092	if (!entry) {
		1093	spin_unlock_bh(&ct_priv->ht_lock);
983	return -ENOENT;	1094	return -ENOENT;
		1095	}
		1096
		1097	if (!mlx5_tc_ct_entry_valid(entry) \|\| !refcount_inc_not_zero(&entry->refcnt)) {
		1098	spin_unlock_bh(&ct_priv->ht_lock);
		1099	return -EINVAL;
		1100	}
		1101
		1102	spin_unlock_bh(&ct_priv->ht_lock);
984		1103
985	mlx5_fc_query_cached(entry->counter->counter, &bytes, &packets, &lastuse);	1104	mlx5_fc_query_cached(entry->counter->counter, &bytes, &packets, &lastuse);
986	flow_stats_update(&f->stats, bytes, packets, 0, lastuse,	1105	flow_stats_update(&f->stats, bytes, packets, 0, lastuse,
987	FLOW_ACTION_HW_STATS_DELAYED);	1106	FLOW_ACTION_HW_STATS_DELAYED);
988		1107
		1108	mlx5_tc_ct_entry_put(entry);
989	return 0;	1109	return 0;
990	}	1110	}
991		1111
@@ -1481,11 +1601,9 @@ err_mapping: · 489 unmodified lines
1481	static void	1601	static void
1482	mlx5_tc_ct_flush_ft_entry(void ptr, void arg)	1602	mlx5_tc_ct_flush_ft_entry(void ptr, void arg)
1483	{	1603	{
1484	struct mlx5_tc_ct_priv *ct_priv = arg;
1485	struct mlx5_ct_entry *entry = ptr;	1604	struct mlx5_ct_entry *entry = ptr;
1486		1605
1487	mlx5_tc_ct_del_ft_entry(ct_priv, entry);	1606	mlx5_tc_ct_entry_put(entry);
1488	kfree(entry);
1489	}	1607	}
1490		1608
1491	static void	1609	static void
@@ -1962,6 +2080,7 @@ mlx5_tc_ct_init(struct mlx5e_priv priv, struct mlx5_fs_chains chains, · 470 unmodified lines
1962	goto err_mapping_labels;	2080	goto err_mapping_labels;
1963	}	2081	}
1964		2082
		2083	spin_lock_init(&ct_priv->ht_lock);
1965	ct_priv->ns_type = ns_type;	2084	ct_priv->ns_type = ns_type;
1966	ct_priv->chains = chains;	2085	ct_priv->chains = chains;
1967	ct_priv->netdev = priv->netdev;	2086	ct_priv->netdev = priv->netdev;
@@ -1996,7 +2115,6 @@ mlx5_tc_ct_init(struct mlx5e_priv priv, struct mlx5_fs_chains chains, · 28 unmodified lines
1996		2115
1997	idr_init(&ct_priv->fte_ids);	2116	idr_init(&ct_priv->fte_ids);
1998	mutex_init(&ct_priv->control_lock);	2117	mutex_init(&ct_priv->control_lock);
1999	mutex_init(&ct_priv->shared_counter_lock);
2000	rhashtable_init(&ct_priv->zone_ht, &zone_params);	2118	rhashtable_init(&ct_priv->zone_ht, &zone_params);
2001	rhashtable_init(&ct_priv->ct_tuples_ht, &tuples_ht_params);	2119	rhashtable_init(&ct_priv->ct_tuples_ht, &tuples_ht_params);
2002	rhashtable_init(&ct_priv->ct_tuples_nat_ht, &tuples_nat_ht_params);	2120	rhashtable_init(&ct_priv->ct_tuples_nat_ht, &tuples_nat_ht_params);
@@ -2039,7 +2157,6 @@ mlx5_tc_ct_clean(struct mlx5_tc_ct_priv *ct_priv) · 36 unmodified lines
2039	rhashtable_destroy(&ct_priv->ct_tuples_nat_ht);	2157	rhashtable_destroy(&ct_priv->ct_tuples_nat_ht);
2040	rhashtable_destroy(&ct_priv->zone_ht);	2158	rhashtable_destroy(&ct_priv->zone_ht);
2041	mutex_destroy(&ct_priv->control_lock);	2159	mutex_destroy(&ct_priv->control_lock);
2042	mutex_destroy(&ct_priv->shared_counter_lock);
2043	idr_destroy(&ct_priv->fte_ids);	2160	idr_destroy(&ct_priv->fte_ids);
2044	kfree(ct_priv);	2161	kfree(ct_priv);
2045	}	2162	}
@@ -2061,14 +2178,22 @@ mlx5e_tc_ct_restore_flow(struct mlx5_tc_ct_priv *ct_priv, · 15 unmodified lines
2061	if (!mlx5_tc_ct_skb_to_tuple(skb, &tuple, zone))	2178	if (!mlx5_tc_ct_skb_to_tuple(skb, &tuple, zone))
2062	return false;	2179	return false;
2063		2180
2064	entry = rhashtable_lookup_fast(&ct_priv->ct_tuples_ht, &tuple,	2181	spin_lock(&ct_priv->ht_lock);
2065	tuples_ht_params);	2182
2066	if (!entry)	2183	entry = mlx5_tc_ct_entry_get(ct_priv, &tuple);
2067	entry = rhashtable_lookup_fast(&ct_priv->ct_tuples_nat_ht,	2184	if (!entry) {
2068	&tuple, tuples_nat_ht_params);	2185	spin_unlock(&ct_priv->ht_lock);
2069	if (!entry)	2186	return false;
		2187	}
		2188
		2189	if (IS_ERR(entry)) {
		2190	spin_unlock(&ct_priv->ht_lock);
2070	return false;	2191	return false;
		2192	}
		2193	spin_unlock(&ct_priv->ht_lock);
2071		2194
2072	tcf_ct_flow_table_restore_skb(skb, entry->restore_cookie);	2195	tcf_ct_flow_table_restore_skb(skb, entry->restore_cookie);
		2196	__mlx5_tc_ct_entry_put(entry);
		2197
2073	return true;	2198	return true;
2074	}	2199	}

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

@@ -83,7 +83,7 @@ static inline void mlx5e_xdp_tx_disable(struct mlx5e_priv *priv) · 82 unmodified lines
83		83
84	clear_bit(MLX5E_STATE_XDP_TX_ENABLED, &priv->state);	84	clear_bit(MLX5E_STATE_XDP_TX_ENABLED, &priv->state);
85	/* Let other device's napi(s) and XSK wakeups see our new state. */	85	/* Let other device's napi(s) and XSK wakeups see our new state. */
86	synchronize_rcu();	86	synchronize_net();
87	}	87	}
88		88
89	static inline bool mlx5e_xdp_tx_is_enabled(struct mlx5e_priv *priv)	89	static inline bool mlx5e_xdp_tx_is_enabled(struct mlx5e_priv *priv)

drivers/net/ethernet/mellanox/mlx5/core/en/xsk/setup.c+1−1

@@ -111,7 +111,7 @@ err_free_cparam: · 110 unmodified lines
111	void mlx5e_close_xsk(struct mlx5e_channel *c)	111	void mlx5e_close_xsk(struct mlx5e_channel *c)
112	{	112	{
113	clear_bit(MLX5E_CHANNEL_STATE_XSK, c->state);	113	clear_bit(MLX5E_CHANNEL_STATE_XSK, c->state);
114	synchronize_rcu(); /* Sync with the XSK wakeup and with NAPI. */	114	synchronize_net(); /* Sync with the XSK wakeup and with NAPI. */
115		115
116	mlx5e_close_rq(&c->xskrq);	116	mlx5e_close_rq(&c->xskrq);
117	mlx5e_close_cq(&c->xskrq.cq);	117	mlx5e_close_cq(&c->xskrq.cq);

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

@@ -173,7 +173,7 @@ static inline bool mlx5e_accel_tx_eseg(struct mlx5e_priv *priv, · 172 unmodified lines
173	#endif	173	#endif
174		174
175	#if IS_ENABLED(CONFIG_GENEVE)	175	#if IS_ENABLED(CONFIG_GENEVE)
176	if (skb->encapsulation)	176	if (skb->encapsulation && skb->ip_summed == CHECKSUM_PARTIAL)
177	mlx5e_tx_tunnel_accel(skb, eseg, ihs);	177	mlx5e_tx_tunnel_accel(skb, eseg, ihs);
178	#endif	178	#endif
179		179

drivers/net/ethernet/mellanox/mlx5/core/en_accel/ktls_rx.c+31−35

 	struct mlx5e_ktls_rx_resync_ctx resync;
 };
+static bool mlx5e_ktls_priv_rx_put(struct mlx5e_ktls_offload_context_rx *priv_rx)
+{
+	if (!refcount_dec_and_test(&priv_rx->resync.refcnt))
+		return false;
+	kfree(priv_rx);
+	return true;
+}
+static void mlx5e_ktls_priv_rx_get(struct mlx5e_ktls_offload_context_rx *priv_rx)
+{
+	refcount_inc(&priv_rx->resync.refcnt);
+}
 static int mlx5e_ktls_create_tir(struct mlx5_core_dev *mdev, u32 *tirn, u32 rqtn)
 {
 	int err, inlen;
 	priv_rx = container_of(resync, struct mlx5e_ktls_offload_context_rx, resync);
 	if (unlikely(test_bit(MLX5E_PRIV_RX_FLAG_DELETING, priv_rx->flags))) {
-		refcount_dec(&resync->refcnt);
+		mlx5e_ktls_priv_rx_put(priv_rx);
 		return;
 	}
 	sq = &c->async_icosq;
 	if (resync_post_get_progress_params(sq, priv_rx))
-		refcount_dec(&resync->refcnt);
+		mlx5e_ktls_priv_rx_put(priv_rx);
 }
 static void resync_init(struct mlx5e_ktls_rx_resync_ctx *resync,
 	return err;
 }
-/* Function is called with elevated refcount, it decreases it. */
+/* Function can be called with the refcount being either elevated or not.
+ * It decreases the refcount and may free the kTLS priv context.
+ * Refcount is not elevated only if tls_dev_del has been called, but GET_PSV was
+ * already in flight.
+ */
 void mlx5e_ktls_handle_get_psv_completion(struct mlx5e_icosq_wqe_info *wi,
 					  struct mlx5e_icosq *sq)
 {
 	tls_offload_rx_resync_async_request_end(priv_rx->sk, cpu_to_be32(hw_seq));
 	priv_rx->stats->tls_resync_req_end++;
 out:
-	refcount_dec(&resync->refcnt);
+	mlx5e_ktls_priv_rx_put(priv_rx);
 	dma_unmap_single(dev, buf->dma_addr, PROGRESS_PARAMS_PADDED_SIZE, DMA_FROM_DEVICE);
 	kfree(buf);
 }
 		return false;
 	resync = &priv_rx->resync;
-	refcount_inc(&resync->refcnt);
+	mlx5e_ktls_priv_rx_get(priv_rx);
 	if (unlikely(!queue_work(resync->priv->tls->rx_wq, &resync->work)))
-		refcount_dec(&resync->refcnt);
+		mlx5e_ktls_priv_rx_put(priv_rx);
 	return true;
 }
 	return err;
 }
-/* Elevated refcount on the resync object means there are
- * outstanding operations (uncompleted GET_PSV WQEs) that
- * will read the resync / priv_rx objects once completed.
- * Wait for them to avoid use-after-free.
- */
-static void wait_for_resync(struct net_device *netdev,
-			    struct mlx5e_ktls_rx_resync_ctx *resync)
-{
-#define MLX5E_KTLS_RX_RESYNC_TIMEOUT 20000 /* msecs */
-	unsigned long exp_time = jiffies + msecs_to_jiffies(MLX5E_KTLS_RX_RESYNC_TIMEOUT);
-	unsigned int refcnt;
-	do {
-		refcnt = refcount_read(&resync->refcnt);
-		if (refcnt == 1)
-			return;
-		msleep(20);
-	} while (time_before(jiffies, exp_time));
-	netdev_warn(netdev,
-		    "Failed waiting for kTLS RX resync refcnt to be released (%u).\n",
-		    refcnt);
-}
 void mlx5e_ktls_del_rx(struct net_device *netdev, struct tls_context *tls_ctx)
 {
 	struct mlx5e_ktls_offload_context_rx *priv_rx;
 	priv_rx = mlx5e_get_ktls_rx_priv_ctx(tls_ctx);
 	set_bit(MLX5E_PRIV_RX_FLAG_DELETING, priv_rx->flags);
 	mlx5e_set_ktls_rx_priv_ctx(tls_ctx, NULL);
-	synchronize_rcu(); /* Sync with NAPI */
+	synchronize_net(); /* Sync with NAPI */
 	if (!cancel_work_sync(&priv_rx->rule.work))
 		/* completion is needed, as the priv_rx in the add flow
 		 * is maintained on the wqe info (wi), not on the socket.
 		wait_for_completion(&priv_rx->add_ctx);
 	resync = &priv_rx->resync;
 	if (cancel_work_sync(&resync->work))
-		refcount_dec(&resync->refcnt);
+		mlx5e_ktls_priv_rx_put(priv_rx);
-	wait_for_resync(netdev, resync);
 	priv_rx->stats->tls_del++;
 	if (priv_rx->rule.rule)
 	mlx5_core_destroy_tir(mdev, priv_rx->tirn);
 	mlx5_ktls_destroy_key(mdev, priv_rx->key_id);
-	kfree(priv_rx);
+	/* priv_rx should normally be freed here, but if there is an outstanding
+	 * GET_PSV, deallocation will be delayed until the CQE for GET_PSV is
+	 * processed.
+	 */
+	mlx5e_ktls_priv_rx_put(priv_rx);
 }

drivers/net/ethernet/mellanox/mlx5/core/en_ethtool.c+26−13

 #define MLX5E_MAX_COAL_FRAMES		MLX5_MAX_CQ_COUNT
 static void
-mlx5e_set_priv_channels_coalesce(struct mlx5e_priv *priv, struct ethtool_coalesce *coal)
+mlx5e_set_priv_channels_tx_coalesce(struct mlx5e_priv *priv, struct ethtool_coalesce *coal)
 {
 	struct mlx5_core_dev *mdev = priv->mdev;
 	int tc;
 						coal->tx_coalesce_usecs,
 						coal->tx_max_coalesced_frames);
 		}
+	}
+}
+static void
+mlx5e_set_priv_channels_rx_coalesce(struct mlx5e_priv *priv, struct ethtool_coalesce *coal)
+{
+	struct mlx5_core_dev *mdev = priv->mdev;
+	int i;
+	for (i = 0; i < priv->channels.num; ++i) {
+		struct mlx5e_channel *c = priv->channels.c[i];
 		mlx5_core_modify_cq_moderation(mdev, &c->rq.cq.mcq,
 					       coal->rx_coalesce_usecs,
 	tx_moder->pkts    = coal->tx_max_coalesced_frames;
 	new_channels.params.tx_dim_enabled = !!coal->use_adaptive_tx_coalesce;
-	if (!test_bit(MLX5E_STATE_OPENED, &priv->state)) {
-		priv->channels.params = new_channels.params;
-		goto out;
-	}
-	/* we are opened */
 	reset_rx = !!coal->use_adaptive_rx_coalesce != priv->channels.params.rx_dim_enabled;
 	reset_tx = !!coal->use_adaptive_tx_coalesce != priv->channels.params.tx_dim_enabled;
-	if (!reset_rx && !reset_tx) {
-		mlx5e_set_priv_channels_coalesce(priv, coal);
-		priv->channels.params = new_channels.params;
-		goto out;
-	}
 	if (reset_rx) {
 		u8 mode = MLX5E_GET_PFLAG(&new_channels.params,
 					  MLX5E_PFLAG_RX_CQE_BASED_MODER);
 		mlx5e_reset_tx_moderation(&new_channels.params, mode);
 	}
+	if (!test_bit(MLX5E_STATE_OPENED, &priv->state)) {
+		priv->channels.params = new_channels.params;
+		goto out;
+	}
+	if (!reset_rx && !reset_tx) {
+		if (!coal->use_adaptive_rx_coalesce)
+			mlx5e_set_priv_channels_rx_coalesce(priv, coal);
+		if (!coal->use_adaptive_tx_coalesce)
+			mlx5e_set_priv_channels_tx_coalesce(priv, coal);
+		priv->channels.params = new_channels.params;
+		goto out;
+	}
 	err = mlx5e_safe_switch_channels(priv, &new_channels, NULL, NULL);
 out:

drivers/net/ethernet/mellanox/mlx5/core/en_main.c+16−9

 #include "en/ptp.h"
 #include "qos.h"
 #include "en/trap.h"
+#include "fpga/ipsec.h"
 bool mlx5e_check_fragmented_striding_rq_cap(struct mlx5_core_dev *mdev)
 {
 	if (!mlx5e_check_fragmented_striding_rq_cap(mdev))
 		return false;
-	if (MLX5_IPSEC_DEV(mdev))
+	if (mlx5_fpga_is_ipsec_device(mdev))
 		return false;
 	if (params->xdp_prog) {
 void mlx5e_deactivate_rq(struct mlx5e_rq *rq)
 {
 	clear_bit(MLX5E_RQ_STATE_ENABLED, &rq->state);
-	synchronize_rcu(); /* Sync with NAPI to prevent mlx5e_post_rx_wqes. */
+	synchronize_net(); /* Sync with NAPI to prevent mlx5e_post_rx_wqes. */
 }
 void mlx5e_close_rq(struct mlx5e_rq *rq)
 	struct mlx5_wq_cyc *wq = &sq->wq;
 	clear_bit(MLX5E_SQ_STATE_ENABLED, &sq->state);
-	synchronize_rcu(); /* Sync with NAPI to prevent netif_tx_wake_queue. */
+	synchronize_net(); /* Sync with NAPI to prevent netif_tx_wake_queue. */
 	mlx5e_tx_disable_queue(sq->txq);
 void mlx5e_deactivate_icosq(struct mlx5e_icosq *icosq)
 {
 	clear_bit(MLX5E_SQ_STATE_ENABLED, &icosq->state);
-	synchronize_rcu(); /* Sync with NAPI. */
+	synchronize_net(); /* Sync with NAPI. */
 }
 void mlx5e_close_icosq(struct mlx5e_icosq *sq)
 	struct mlx5e_channel *c = sq->channel;
 	clear_bit(MLX5E_SQ_STATE_ENABLED, &sq->state);
-	synchronize_rcu(); /* Sync with NAPI. */
+	synchronize_net(); /* Sync with NAPI. */
 	mlx5e_destroy_sq(c->mdev, sq->sqn);
 	mlx5e_free_xdpsq_descs(sq);
 	mlx5e_build_create_cq_param(&ccp, c);
-	err = mlx5e_open_cq(c->priv, icocq_moder, &cparam->icosq.cqp, &ccp,
+	err = mlx5e_open_cq(c->priv, icocq_moder, &cparam->async_icosq.cqp, &ccp,
 			    &c->async_icosq.cq);
 	if (err)
 		return err;
-	err = mlx5e_open_cq(c->priv, icocq_moder, &cparam->async_icosq.cqp, &ccp,
+	err = mlx5e_open_cq(c->priv, icocq_moder, &cparam->icosq.cqp, &ccp,
 			    &c->icosq.cq);
 	if (err)
 		goto err_close_async_icosq_cq;
 	u32 buf_size = 0;
 	int i;
+<<<<<<< HEAD
 	if (MLX5_IPSEC_DEV(mdev))
+=======
+#ifdef CONFIG_MLX5_EN_IPSEC
+	if (mlx5_fpga_is_ipsec_device(mdev))
+>>>>>>> 3af409ca278d4a8d50e91f9f7c4c33b175645cf3
 		byte_count += MLX5E_METADATA_ETHER_LEN;
 	if (mlx5e_rx_is_linear_skb(params, xsk)) {
 		return -EINVAL;
 	}
-	if (MLX5_IPSEC_DEV(priv->mdev)) {
+	if (mlx5_fpga_is_ipsec_device(priv->mdev)) {
-		netdev_warn(netdev, "can't set XDP with IPSec offload\n");
+		netdev_warn(netdev,
+			    "XDP is not available on Innova cards with IPsec support\n");
 		return -EINVAL;
 	}

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

@@ -1783,8 +1783,8 @@ int mlx5e_rq_set_handlers(struct mlx5e_rq rq, struct mlx5e_params params, bool · 1782 unmodified lines
1783	rq->dealloc_wqe = mlx5e_dealloc_rx_mpwqe;	1783	rq->dealloc_wqe = mlx5e_dealloc_rx_mpwqe;
1784		1784
1785	rq->handle_rx_cqe = priv->profile->rx_handlers->handle_rx_cqe_mpwqe;	1785	rq->handle_rx_cqe = priv->profile->rx_handlers->handle_rx_cqe_mpwqe;
1786	if (MLX5_IPSEC_DEV(mdev)) {	1786	if (mlx5_fpga_is_ipsec_device(mdev)) {
1787	netdev_err(netdev, "MPWQE RQ with IPSec offload not supported\n");	1787	netdev_err(netdev, "MPWQE RQ with Innova IPSec offload not supported\n");
1788	return -EINVAL;	1788	return -EINVAL;
1789	}	1789	}
1790	if (!rq->handle_rx_cqe) {	1790	if (!rq->handle_rx_cqe) {

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

@@ -4445,7 +4445,7 @@ static int apply_police_params(struct mlx5e_priv *priv, u64 rate, · 4444 unmodified lines
4445	*/	4445	*/
4446	if (rate) {	4446	if (rate) {
4447	rate = (rate * BITS_PER_BYTE) + 500000;	4447	rate = (rate * BITS_PER_BYTE) + 500000;
4448	rate_mbps = max_t(u32, do_div(rate, 1000000), 1);	4448	rate_mbps = max_t(u64, do_div(rate, 1000000), 1);
4449	}	4449	}
4450		4450
4451	err = mlx5_esw_modify_vport_rate(esw, vport_num, rate_mbps);	4451	err = mlx5_esw_modify_vport_rate(esw, vport_num, rate_mbps);

drivers/net/ethernet/mellanox/mlx5/core/fpga/ipsec.c+1−1

@@ -124,7 +124,7 @@ struct mlx5_fpga_ipsec { · 123 unmodified lines
124	struct ida halloc;	124	struct ida halloc;
125	};	125	};
126		126
127	static bool mlx5_fpga_is_ipsec_device(struct mlx5_core_dev *mdev)	127	bool mlx5_fpga_is_ipsec_device(struct mlx5_core_dev *mdev)
128	{	128	{
129	if (!mdev->fpga \|\| !MLX5_CAP_GEN(mdev, fpga))	129	if (!mdev->fpga \|\| !MLX5_CAP_GEN(mdev, fpga))
130	return false;	130	return false;

drivers/net/ethernet/mellanox/mlx5/core/fpga/ipsec.h+2−0

 const struct mlx5_flow_cmds *
 mlx5_fs_cmd_get_default_ipsec_fpga_cmds(enum fs_flow_table_type type);
 void mlx5_fpga_ipsec_build_fs_cmds(void);
+bool mlx5_fpga_is_ipsec_device(struct mlx5_core_dev *mdev);
 #else
 static inline
 const struct mlx5_accel_ipsec_ops *mlx5_fpga_ipsec_ops(struct mlx5_core_dev *mdev)
 }
 static inline void mlx5_fpga_ipsec_build_fs_cmds(void) {};
+static inline bool mlx5_fpga_is_ipsec_device(struct mlx5_core_dev *mdev) { return false; }
 #endif /* CONFIG_MLX5_FPGA_IPSEC */
 #endif	/* __MLX5_FPGA_IPSEC_H__ */

drivers/net/ethernet/mellanox/mlx5/core/health.c+14−8

 	return true;
 }
+static void enter_error_state(struct mlx5_core_dev *dev, bool force)
+{
+	if (mlx5_health_check_fatal_sensors(dev) || force) { /* protected state setting */
+		dev->state = MLX5_DEVICE_STATE_INTERNAL_ERROR;
+		mlx5_cmd_flush(dev);
+	}
+	mlx5_notifier_call_chain(dev->priv.events, MLX5_DEV_EVENT_SYS_ERROR, (void *)1);
+}
 void mlx5_enter_error_state(struct mlx5_core_dev *dev, bool force)
 {
 	bool err_detected = false;
 		goto unlock;
 	}
-	if (mlx5_health_check_fatal_sensors(dev) || force) { /* protected state setting */
+	enter_error_state(dev, force);
-		dev->state = MLX5_DEVICE_STATE_INTERNAL_ERROR;
-		mlx5_cmd_flush(dev);
-	}
-	mlx5_notifier_call_chain(dev->priv.events, MLX5_DEV_EVENT_SYS_ERROR, (void *)1);
 unlock:
 	mutex_unlock(&dev->intf_state_mutex);
 }
 	priv = container_of(health, struct mlx5_priv, health);
 	dev = container_of(priv, struct mlx5_core_dev, priv);
-	mlx5_enter_error_state(dev, false);
+	enter_error_state(dev, false);
 	if (IS_ERR_OR_NULL(health->fw_fatal_reporter)) {
 		if (mlx5_health_try_recover(dev))
 			mlx5_core_err(dev, "health recovery failed\n");
 		mlx5_core_err(dev, "Fatal error %u detected\n", fatal_error);
 		dev->priv.health.fatal_error = fatal_error;
 		print_health_info(dev);
+		dev->state = MLX5_DEVICE_STATE_INTERNAL_ERROR;
 		mlx5_trigger_health_work(dev);
-		goto out;
+		return;
 	}
 	count = ioread32be(health->health_counter);

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

@@ -1445,7 +1445,8 @@ static int init_one(struct pci_dev pdev, const struct pci_device_id id) · 1444 unmodified lines
1445	dev_err(&pdev->dev, "mlx5_crdump_enable failed with error code %d\n", err);	1445	dev_err(&pdev->dev, "mlx5_crdump_enable failed with error code %d\n", err);
1446		1446
1447	pci_save_state(pdev);	1447	pci_save_state(pdev);
1448	devlink_reload_enable(devlink);	1448	if (!mlx5_core_is_mp_slave(dev))
		1449	devlink_reload_enable(devlink);
1449	return 0;	1450	return 0;
1450		1451
1451	err_load_one:	1452	err_load_one:

drivers/net/ethernet/realtek/r8169_main.c+25−0

@@ -2230,6 +2230,31 @@ static void rtl_prepare_power_down(struct rtl8169_private *tp) · 2229 unmodified lines
2230	phy_speed_down(tp->phydev, false);	2230	phy_speed_down(tp->phydev, false);
2231	rtl_wol_enable_rx(tp);	2231	rtl_wol_enable_rx(tp);
2232	}	2232	}
		2233
		2234	switch (tp->mac_version) {
		2235	case RTL_GIGA_MAC_VER_25 ... RTL_GIGA_MAC_VER_26:
		2236	case RTL_GIGA_MAC_VER_29 ... RTL_GIGA_MAC_VER_30:
		2237	case RTL_GIGA_MAC_VER_32 ... RTL_GIGA_MAC_VER_33:
		2238	case RTL_GIGA_MAC_VER_37:
		2239	case RTL_GIGA_MAC_VER_39:
		2240	case RTL_GIGA_MAC_VER_43:
		2241	case RTL_GIGA_MAC_VER_44:
		2242	case RTL_GIGA_MAC_VER_45:
		2243	case RTL_GIGA_MAC_VER_46:
		2244	case RTL_GIGA_MAC_VER_47:
		2245	case RTL_GIGA_MAC_VER_48:
		2246	case RTL_GIGA_MAC_VER_50 ... RTL_GIGA_MAC_VER_63:
		2247	RTL_W8(tp, PMCH, RTL_R8(tp, PMCH) & ~0x80);
		2248	break;
		2249	case RTL_GIGA_MAC_VER_40:
		2250	case RTL_GIGA_MAC_VER_41:
		2251	case RTL_GIGA_MAC_VER_49:
		2252	rtl_eri_clear_bits(tp, 0x1a8, 0xfc000000);
		2253	RTL_W8(tp, PMCH, RTL_R8(tp, PMCH) & ~0x80);
		2254	break;
		2255	default:
		2256	break;
		2257	}
2233	}	2258	}
2234		2259
2235	static void rtl_init_rxcfg(struct rtl8169_private *tp)	2260	static void rtl_init_rxcfg(struct rtl8169_private *tp)

drivers/net/ethernet/xilinx/xilinx_axienet_main.c+12−14

 	lp->options = XAE_OPTION_DEFAULTS;
 	lp->rx_bd_num = RX_BD_NUM_DEFAULT;
 	lp->tx_bd_num = TX_BD_NUM_DEFAULT;
+	lp->clk = devm_clk_get_optional(&pdev->dev, NULL);
+	if (IS_ERR(lp->clk)) {
+		ret = PTR_ERR(lp->clk);
+		goto free_netdev;
+	}
+	ret = clk_prepare_enable(lp->clk);
+	if (ret) {
+		dev_err(&pdev->dev, "Unable to enable clock: %d\n", ret);
+		goto free_netdev;
+	}
 	/* Map device registers */
 	ethres = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 	lp->regs = devm_ioremap_resource(&pdev->dev, ethres);
 	lp->phy_node = of_parse_phandle(pdev->dev.of_node, "phy-handle", 0);
 	if (lp->phy_node) {
-		lp->clk = devm_clk_get(&pdev->dev, NULL);
-		if (IS_ERR(lp->clk)) {
-			dev_warn(&pdev->dev, "Failed to get clock: %ld\n",
-				 PTR_ERR(lp->clk));
-			lp->clk = NULL;
-		} else {
-			ret = clk_prepare_enable(lp->clk);
-			if (ret) {
-				dev_err(&pdev->dev, "Unable to enable clock: %d\n",
-					ret);
-				goto free_netdev;
-			}
-		}
 		ret = axienet_mdio_setup(lp);
 		if (ret)
 			dev_warn(&pdev->dev,

drivers/net/ipa/ipa_main.c+2−2

@@ -580,10 +580,10 @@ ipa_resource_config(struct ipa ipa, const struct ipa_resource_data data) · 579 unmodified lines
580	return -EINVAL;	580	return -EINVAL;
581		581
582	for (i = 0; i < data->resource_src_count; i++)	582	for (i = 0; i < data->resource_src_count; i++)
583	ipa_resource_config_src(ipa, data->resource_src);	583	ipa_resource_config_src(ipa, &data->resource_src[i]);
584		584
585	for (i = 0; i < data->resource_dst_count; i++)	585	for (i = 0; i < data->resource_dst_count; i++)
586	ipa_resource_config_dst(ipa, data->resource_dst);	586	ipa_resource_config_dst(ipa, &data->resource_dst[i]);
587		587
588	return 0;	588	return 0;
589	}	589	}

drivers/net/phy/phy_device.c+17−36

@@ -300,50 +300,22 @@ static int mdio_bus_phy_resume(struct device *dev) · 299 unmodified lines
300		300
301	phydev->suspended_by_mdio_bus = 0;	301	phydev->suspended_by_mdio_bus = 0;
302		302
303	ret = phy_resume(phydev);	303	ret = phy_init_hw(phydev);
304	if (ret < 0)	304	if (ret < 0)
305	return ret;	305	return ret;
306		306
307	no_resume:	307	ret = phy_resume(phydev);
308	if (phydev->attached_dev && phydev->adjust_link)
309	phy_start_machine(phydev);
310
311	return 0;
312	}
313
314	static int mdio_bus_phy_restore(struct device *dev)
315	{
316	struct phy_device *phydev = to_phy_device(dev);
317	struct net_device *netdev = phydev->attached_dev;
318	int ret;
319
320	if (!netdev)
321	return 0;
322
323	ret = phy_init_hw(phydev);
324	if (ret < 0)	308	if (ret < 0)
325	return ret;	309	return ret;
326		310	no_resume:
327	if (phydev->attached_dev && phydev->adjust_link)	311	if (phydev->attached_dev && phydev->adjust_link)
328	phy_start_machine(phydev);	312	phy_start_machine(phydev);
329		313
330	return 0;	314	return 0;
331	}	315	}
332		316
333	static const struct dev_pm_ops mdio_bus_phy_pm_ops = {	317	static SIMPLE_DEV_PM_OPS(mdio_bus_phy_pm_ops, mdio_bus_phy_suspend,
334	.suspend = mdio_bus_phy_suspend,	318	mdio_bus_phy_resume);
335	.resume = mdio_bus_phy_resume,
336	.freeze = mdio_bus_phy_suspend,
337	.thaw = mdio_bus_phy_resume,
338	.restore = mdio_bus_phy_restore,
339	};
340
341	#define MDIO_BUS_PHY_PM_OPS (&mdio_bus_phy_pm_ops)
342
343	#else
344
345	#define MDIO_BUS_PHY_PM_OPS NULL
346
347	#endif /* CONFIG_PM */	319	#endif /* CONFIG_PM */
348		320
349	/**	321	/**
@@ -554,7 +526,7 @@ static const struct device_type mdio_bus_phy_type = { · 204 unmodified lines
554	.name = "PHY",	526	.name = "PHY",
555	.groups = phy_dev_groups,	527	.groups = phy_dev_groups,
556	.release = phy_device_release,	528	.release = phy_device_release,
557	.pm = MDIO_BUS_PHY_PM_OPS,	529	.pm = pm_ptr(&mdio_bus_phy_pm_ops),
558	};	530	};
559		531
560	static int phy_request_driver_module(struct phy_device *dev, u32 phy_id)	532	static int phy_request_driver_module(struct phy_device *dev, u32 phy_id)
@@ -1144,10 +1116,19 @@ int phy_init_hw(struct phy_device *phydev) · 583 unmodified lines
1144	if (ret < 0)	1116	if (ret < 0)
1145	return ret;	1117	return ret;
1146		1118
1147	if (phydev->drv->config_init)	1119	if (phydev->drv->config_init) {
1148	ret = phydev->drv->config_init(phydev);	1120	ret = phydev->drv->config_init(phydev);
		1121	if (ret < 0)
		1122	return ret;
		1123	}
1149		1124
1150	return ret;	1125	if (phydev->drv->config_intr) {
		1126	ret = phydev->drv->config_intr(phydev);
		1127	if (ret < 0)
		1128	return ret;
		1129	}
		1130
		1131	return 0;
1151	}	1132	}
1152	EXPORT_SYMBOL(phy_init_hw);	1133	EXPORT_SYMBOL(phy_init_hw);
1153		1134

drivers/net/wan/lmc/lmc_main.c+3−1

 	spin_lock_init(&sc->lmc_lock);
 	pci_set_master(pdev);
-	printk(KERN_INFO "%s: detected at %lx, irq %d\n", dev->name,
+	printk(KERN_INFO "hdlc: detected at %lx, irq %d\n",
 	       dev->base_addr, dev->irq);
 	err = register_hdlc_device(dev);
         break;
     default:
 	printk(KERN_WARNING "%s: LMC UNKNOWN CARD!\n", dev->name);
+	unregister_hdlc_device(dev);
+	return -EIO;
         break;
     }

drivers/net/wireless/broadcom/b43/phy_n.c+1−1

@@ -5311,7 +5311,7 @@ static void b43_nphy_restore_cal(struct b43_wldev *dev) · 5310 unmodified lines
5311		5311
5312	for (i = 0; i < 4; i++) {	5312	for (i = 0; i < 4; i++) {
5313	if (dev->phy.rev >= 3)	5313	if (dev->phy.rev >= 3)
5314	table[i] = coef[i];	5314	coef[i] = table[i];
5315	else	5315	else
5316	coef[i] = 0;	5316	coef[i] = 0;
5317	}	5317	}

drivers/target/iscsi/cxgbit/cxgbit_target.c+1−2

@@ -86,8 +86,7 @@ static int cxgbit_is_ofld_imm(const struct sk_buff *skb) · 85 unmodified lines
86	if (likely(cxgbit_skcb_flags(skb) & SKCBF_TX_ISO))	86	if (likely(cxgbit_skcb_flags(skb) & SKCBF_TX_ISO))
87	length += sizeof(struct cpl_tx_data_iso);	87	length += sizeof(struct cpl_tx_data_iso);
88		88
89	#define MAX_IMM_TX_PKT_LEN 256	89	return length <= MAX_IMM_OFLD_TX_DATA_WR_LEN;
90	return length <= MAX_IMM_TX_PKT_LEN;
91	}	90	}
92		91
93	/*	92	/*

include/linux/atmdev.h+1−1

@@ -207,7 +207,7 @@ struct atm_skb_data { · 206 unmodified lines
207	struct atm_vcc vcc; / ATM VCC */	207	struct atm_vcc vcc; / ATM VCC */
208	unsigned long atm_options; /* ATM layer options */	208	unsigned long atm_options; /* ATM layer options */
209	unsigned int acct_truesize; /* truesize accounted to vcc */	209	unsigned int acct_truesize; /* truesize accounted to vcc */
210	};	210	} __packed;
211		211
212	#define VCC_HTABLE_SIZE 32	212	#define VCC_HTABLE_SIZE 32
213		213

include/net/act_api.h+1−0

@@ -166,6 +166,7 @@ int tcf_idr_create_from_flags(struct tc_action_net *tn, u32 index, · 165 unmodified lines
166	struct nlattr est, struct tc_action *a,	166	struct nlattr est, struct tc_action *a,
167	const struct tc_action_ops *ops, int bind,	167	const struct tc_action_ops *ops, int bind,
168	u32 flags);	168	u32 flags);
		169	void tcf_idr_insert_many(struct tc_action *actions[]);
169	void tcf_idr_cleanup(struct tc_action_net *tn, u32 index);	170	void tcf_idr_cleanup(struct tc_action_net *tn, u32 index);
170	int tcf_idr_check_alloc(struct tc_action_net tn, u32 index,	171	int tcf_idr_check_alloc(struct tc_action_net tn, u32 index,
171	struct tc_action **a, int bind);	172	struct tc_action **a, int bind);

include/uapi/linux/pkt_cls.h+1−0

@@ -593,6 +593,7 @@ enum { · 592 unmodified lines
593	TCA_FLOWER_KEY_CT_FLAGS_TRACKED = 1 << 3, /* Conntrack has occurred. */	593	TCA_FLOWER_KEY_CT_FLAGS_TRACKED = 1 << 3, /* Conntrack has occurred. */
594	TCA_FLOWER_KEY_CT_FLAGS_INVALID = 1 << 4, /* Conntrack is invalid. */	594	TCA_FLOWER_KEY_CT_FLAGS_INVALID = 1 << 4, /* Conntrack is invalid. */
595	TCA_FLOWER_KEY_CT_FLAGS_REPLY = 1 << 5, /* Packet is in the reply direction. */	595	TCA_FLOWER_KEY_CT_FLAGS_REPLY = 1 << 5, /* Packet is in the reply direction. */
		596	__TCA_FLOWER_KEY_CT_FLAGS_MAX,
596	};	597	};
597		598
598	enum {	599	enum {

kernel/bpf/verifier.c+6−4

 			bool isdiv = BPF_OP(insn->code) == BPF_DIV;
 			struct bpf_insn *patchlet;
 			struct bpf_insn chk_and_div[] = {
-				/* Rx div 0 -> 0 */
+				/* [R,W]x div 0 -> 0 */
 				BPF_RAW_INSN((is64 ? BPF_JMP : BPF_JMP32) |
 					     BPF_JNE | BPF_K, insn->src_reg,
 					     0, 2, 0),
 				*insn,
 			};
 			struct bpf_insn chk_and_mod[] = {
-				/* Rx mod 0 -> Rx */
+				/* [R,W]x mod 0 -> [R,W]x */
 				BPF_RAW_INSN((is64 ? BPF_JMP : BPF_JMP32) |
 					     BPF_JEQ | BPF_K, insn->src_reg,
-					     0, 1, 0),
+					     0, 1 + (is64 ? 0 : 1), 0),
 				*insn,
+				BPF_JMP_IMM(BPF_JA, 0, 0, 1),
+				BPF_MOV32_REG(insn->dst_reg, insn->dst_reg),
 			};
 			patchlet = isdiv ? chk_and_div : chk_and_mod;
 			cnt = isdiv ? ARRAY_SIZE(chk_and_div) :
-				      ARRAY_SIZE(chk_and_mod);
+				      ARRAY_SIZE(chk_and_mod) - (is64 ? 2 : 0);
 			new_prog = bpf_patch_insn_data(env, i + delta, patchlet, cnt);
 			if (!new_prog)

net/appletalk/ddp.c+21−12

 	struct sk_buff *skb;
 	struct net_device *dev;
 	struct ddpehdr *ddp;
-	int size;
+	int size, hard_header_len;
-	struct atalk_route *rt;
+	struct atalk_route *rt, *rt_lo = NULL;
 	int err;
 	if (flags & ~(MSG_DONTWAIT|MSG_CMSG_COMPAT))
 	SOCK_DEBUG(sk, "SK %p: Size needed %d, device %s\n",
 			sk, size, dev->name);
-	size += dev->hard_header_len;
+	hard_header_len = dev->hard_header_len;
+	/* Leave room for loopback hardware header if necessary */
+	if (usat->sat_addr.s_node == ATADDR_BCAST &&
+	    (dev->flags & IFF_LOOPBACK || !(rt->flags & RTF_GATEWAY))) {
+		struct atalk_addr at_lo;
+		at_lo.s_node = 0;
+		at_lo.s_net  = 0;
+		rt_lo = atrtr_find(&at_lo);
+		if (rt_lo && rt_lo->dev->hard_header_len > hard_header_len)
+			hard_header_len = rt_lo->dev->hard_header_len;
+	}
+	size += hard_header_len;
 	release_sock(sk);
 	skb = sock_alloc_send_skb(sk, size, (flags & MSG_DONTWAIT), &err);
 	lock_sock(sk);
 		goto out;
 	skb_reserve(skb, ddp_dl->header_length);
-	skb_reserve(skb, dev->hard_header_len);
+	skb_reserve(skb, hard_header_len);
 	skb->dev = dev;
 	SOCK_DEBUG(sk, "SK %p: Begin build.\n", sk);
 		/* loop back */
 		skb_orphan(skb);
 		if (ddp->deh_dnode == ATADDR_BCAST) {
-			struct atalk_addr at_lo;
+			if (!rt_lo) {
-			at_lo.s_node = 0;
-			at_lo.s_net  = 0;
-			rt = atrtr_find(&at_lo);
-			if (!rt) {
 				kfree_skb(skb);
 				err = -ENETUNREACH;
 				goto out;
 			}
-			dev = rt->dev;
+			dev = rt_lo->dev;
 			skb->dev = dev;
 		}
 		ddp_dl->request(ddp_dl, skb, dev->dev_addr);

net/caif/chnl_net.c+1−4

 	else
 		skb->ip_summed = CHECKSUM_NONE;
-	if (in_interrupt())
+	netif_rx_any_context(skb);
-		netif_rx(skb);
-	else
-		netif_rx_ni(skb);
 	/* Update statistics. */
 	priv->netdev->stats.rx_packets++;

net/core/flow_dissector.c+3−3

 			key_control->addr_type = FLOW_DISSECTOR_KEY_IPV4_ADDRS;
 		}
+		__skb_flow_dissect_ipv4(skb, flow_dissector,
+					target_container, data, iph);
 		if (ip_is_fragment(iph)) {
 			key_control->flags |= FLOW_DIS_IS_FRAGMENT;
 			}
 		}
-		__skb_flow_dissect_ipv4(skb, flow_dissector,
-					target_container, data, iph);
 		break;
 	}
 	case htons(ETH_P_IPV6): {

net/mptcp/options.c+5−5

 {
 	struct mptcp_subflow_context *subflow = mptcp_subflow_ctx(sk);
 	struct mptcp_sock *msk = mptcp_sk(subflow->conn);
+	u64 snd_data_fin_enable, ack_seq;
 	unsigned int dss_size = 0;
-	u64 snd_data_fin_enable;
 	struct mptcp_ext *mpext;
 	unsigned int ack_size;
 	bool ret = false;
 		return ret;
 	}
+	ack_seq = READ_ONCE(msk->ack_seq);
 	if (READ_ONCE(msk->use_64bit_ack)) {
 		ack_size = TCPOLEN_MPTCP_DSS_ACK64;
-		opts->ext_copy.data_ack = READ_ONCE(msk->ack_seq);
+		opts->ext_copy.data_ack = ack_seq;
 		opts->ext_copy.ack64 = 1;
 	} else {
 		ack_size = TCPOLEN_MPTCP_DSS_ACK32;
-		opts->ext_copy.data_ack32 = (uint32_t)READ_ONCE(msk->ack_seq);
+		opts->ext_copy.data_ack32 = (uint32_t)ack_seq;
 		opts->ext_copy.ack64 = 0;
 	}
 	opts->ext_copy.use_ack = 1;
 		msk->wnd_end = new_wnd_end;
 	/* this assumes mptcp_incoming_options() is invoked after tcp_ack() */
-	if (after64(msk->wnd_end, READ_ONCE(msk->snd_nxt)) &&
+	if (after64(msk->wnd_end, READ_ONCE(msk->snd_nxt)))
-	    sk_stream_memory_free(ssk))
 		__mptcp_check_push(sk, ssk);
 	if (after64(new_snd_una, old_snd_una)) {

net/mptcp/protocol.c+36−19

@@ -363,8 +363,6 @@ static void mptcp_check_data_fin_ack(struct sock *sk) · 362 unmodified lines
363		363
364	/* Look for an acknowledged DATA_FIN */	364	/* Look for an acknowledged DATA_FIN */
365	if (mptcp_pending_data_fin_ack(sk)) {	365	if (mptcp_pending_data_fin_ack(sk)) {
366	mptcp_stop_timer(sk);
367
368	WRITE_ONCE(msk->snd_data_fin_enable, 0);	366	WRITE_ONCE(msk->snd_data_fin_enable, 0);
369		367
370	switch (sk->sk_state) {	368	switch (sk->sk_state) {
@@ -458,7 +456,18 @@ static bool mptcp_subflow_cleanup_rbuf(struct sock *ssk) · 87 unmodified lines
458	static void mptcp_cleanup_rbuf(struct mptcp_sock *msk)	456	static void mptcp_cleanup_rbuf(struct mptcp_sock *msk)
459	{	457	{
460	struct sock *ack_hint = READ_ONCE(msk->ack_hint);	458	struct sock *ack_hint = READ_ONCE(msk->ack_hint);
		459	int old_space = READ_ONCE(msk->old_wspace);
461	struct mptcp_subflow_context *subflow;	460	struct mptcp_subflow_context *subflow;
		461	struct sock sk = (struct sock )msk;
		462	bool cleanup;
		463
		464	/* this is a simple superset of what tcp_cleanup_rbuf() implements
		465	* so that we don't have to acquire the ssk socket lock most of the time
		466	* to do actually nothing
		467	*/
		468	cleanup = __mptcp_space(sk) - old_space >= max(0, old_space);
		469	if (!cleanup)
		470	return;
462		471
463	/* if the hinted ssk is still active, try to use it */	472	/* if the hinted ssk is still active, try to use it */
464	if (likely(ack_hint)) {	473	if (likely(ack_hint)) {
@@ -1565,6 +1574,9 @@ out: · 1100 unmodified lines
1565	mptcp_set_timeout(sk, ssk);	1574	mptcp_set_timeout(sk, ssk);
1566	tcp_push(ssk, 0, info.mss_now, tcp_sk(ssk)->nonagle,	1575	tcp_push(ssk, 0, info.mss_now, tcp_sk(ssk)->nonagle,
1567	info.size_goal);	1576	info.size_goal);
		1577	if (!mptcp_timer_pending(sk))
		1578	mptcp_reset_timer(sk);
		1579
1568	if (msk->snd_data_fin_enable &&	1580	if (msk->snd_data_fin_enable &&
1569	msk->snd_nxt + 1 == msk->write_seq)	1581	msk->snd_nxt + 1 == msk->write_seq)
1570	mptcp_schedule_work(sk);	1582	mptcp_schedule_work(sk);
@@ -1868,7 +1880,7 @@ static void __mptcp_splice_receive_queue(struct sock *sk) · 297 unmodified lines
1868	skb_queue_splice_tail_init(&sk->sk_receive_queue, &msk->receive_queue);	1880	skb_queue_splice_tail_init(&sk->sk_receive_queue, &msk->receive_queue);
1869	}	1881	}
1870		1882
1871	static bool __mptcp_move_skbs(struct mptcp_sock *msk, unsigned int rcv)	1883	static bool __mptcp_move_skbs(struct mptcp_sock *msk)
1872	{	1884	{
1873	struct sock sk = (struct sock )msk;	1885	struct sock sk = (struct sock )msk;
1874	unsigned int moved = 0;	1886	unsigned int moved = 0;
@@ -1888,13 +1900,10 @@ static bool __mptcp_move_skbs(struct mptcp_sock *msk, unsigned int rcv) · 13 unmodified lines
1888		1900
1889	slowpath = lock_sock_fast(ssk);	1901	slowpath = lock_sock_fast(ssk);
1890	mptcp_data_lock(sk);	1902	mptcp_data_lock(sk);
		1903	__mptcp_update_rmem(sk);
1891	done = __mptcp_move_skbs_from_subflow(msk, ssk, &moved);	1904	done = __mptcp_move_skbs_from_subflow(msk, ssk, &moved);
1892	mptcp_data_unlock(sk);	1905	mptcp_data_unlock(sk);
1893	if (moved && rcv) {	1906	tcp_cleanup_rbuf(ssk, moved);
1894	WRITE_ONCE(msk->rmem_pending, min(rcv, moved));
1895	tcp_cleanup_rbuf(ssk, 1);
1896	WRITE_ONCE(msk->rmem_pending, 0);
1897	}
1898	unlock_sock_fast(ssk, slowpath);	1907	unlock_sock_fast(ssk, slowpath);
1899	} while (!done);	1908	} while (!done);
1900		1909
@@ -1907,6 +1916,7 @@ static bool __mptcp_move_skbs(struct mptcp_sock *msk, unsigned int rcv) · 6 unmodified lines
1907	ret \|= __mptcp_ofo_queue(msk);	1916	ret \|= __mptcp_ofo_queue(msk);
1908	__mptcp_splice_receive_queue(sk);	1917	__mptcp_splice_receive_queue(sk);
1909	mptcp_data_unlock(sk);	1918	mptcp_data_unlock(sk);
		1919	mptcp_cleanup_rbuf(msk);
1910	}	1920	}
1911	if (ret)	1921	if (ret)
1912	mptcp_check_data_fin((struct sock *)msk);	1922	mptcp_check_data_fin((struct sock *)msk);
@@ -1936,7 +1946,7 @@ static int mptcp_recvmsg(struct sock sk, struct msghdr msg, size_t len, · 23 unmodified lines
1936	target = sock_rcvlowat(sk, flags & MSG_WAITALL, len);	1946	target = sock_rcvlowat(sk, flags & MSG_WAITALL, len);
1937		1947
1938	while (copied < len) {	1948	while (copied < len) {
1939	int bytes_read, old_space;	1949	int bytes_read;
1940		1950
1941	bytes_read = __mptcp_recvmsg_mskq(msk, msg, len - copied);	1951	bytes_read = __mptcp_recvmsg_mskq(msk, msg, len - copied);
1942	if (unlikely(bytes_read < 0)) {	1952	if (unlikely(bytes_read < 0)) {
@@ -1947,14 +1957,11 @@ static int mptcp_recvmsg(struct sock sk, struct msghdr msg, size_t len, · 4 unmodified lines
1947		1957
1948	copied += bytes_read;	1958	copied += bytes_read;
1949		1959
1950	if (skb_queue_empty(&msk->receive_queue) &&
1951	__mptcp_move_skbs(msk, len - copied))
1952	continue;
1953
1954	/* be sure to advertise window change */	1960	/* be sure to advertise window change */
1955	old_space = READ_ONCE(msk->old_wspace);	1961	mptcp_cleanup_rbuf(msk);
1956	if ((tcp_space(sk) - old_space) >= old_space)	1962
1957	mptcp_cleanup_rbuf(msk);	1963	if (skb_queue_empty(&msk->receive_queue) && __mptcp_move_skbs(msk))
		1964	continue;
1958		1965
1959	/* only the master socket status is relevant here. The exit	1966	/* only the master socket status is relevant here. The exit
1960	* conditions mirror closely tcp_recvmsg()	1967	* conditions mirror closely tcp_recvmsg()
@@ -1982,7 +1989,7 @@ static int mptcp_recvmsg(struct sock sk, struct msghdr msg, size_t len, · 21 unmodified lines
1982	/* race breaker: the shutdown could be after the	1989	/* race breaker: the shutdown could be after the
1983	* previous receive queue check	1990	* previous receive queue check
1984	*/	1991	*/
1985	if (__mptcp_move_skbs(msk, len - copied))	1992	if (__mptcp_move_skbs(msk))
1986	continue;	1993	continue;
1987	break;	1994	break;
1988	}	1995	}
@@ -2015,7 +2022,7 @@ static int mptcp_recvmsg(struct sock sk, struct msghdr msg, size_t len, · 26 unmodified lines
2015	/* .. race-breaker: ssk might have gotten new data	2022	/* .. race-breaker: ssk might have gotten new data
2016	* after last __mptcp_move_skbs() returned false.	2023	* after last __mptcp_move_skbs() returned false.
2017	*/	2024	*/
2018	if (unlikely(__mptcp_move_skbs(msk, 0)))	2025	if (unlikely(__mptcp_move_skbs(msk)))
2019	set_bit(MPTCP_DATA_READY, &msk->flags);	2026	set_bit(MPTCP_DATA_READY, &msk->flags);
2020	} else if (unlikely(!test_bit(MPTCP_DATA_READY, &msk->flags))) {	2027	} else if (unlikely(!test_bit(MPTCP_DATA_READY, &msk->flags))) {
2021	/* data to read but mptcp_wait_data() cleared DATA_READY */	2028	/* data to read but mptcp_wait_data() cleared DATA_READY */
@@ -2275,6 +2282,7 @@ static void mptcp_worker(struct work_struct *work) · 253 unmodified lines
2275	if (!test_and_clear_bit(MPTCP_WORK_RTX, &msk->flags))	2282	if (!test_and_clear_bit(MPTCP_WORK_RTX, &msk->flags))
2276	goto unlock;	2283	goto unlock;
2277		2284
		2285	__mptcp_clean_una(sk);
2278	dfrag = mptcp_rtx_head(sk);	2286	dfrag = mptcp_rtx_head(sk);
2279	if (!dfrag)	2287	if (!dfrag)
2280	goto unlock;	2288	goto unlock;
@@ -2943,6 +2951,8 @@ static void mptcp_release_cb(struct sock *sk) · 662 unmodified lines
2943	mptcp_push_pending(sk, 0);	2951	mptcp_push_pending(sk, 0);
2944	spin_lock_bh(&sk->sk_lock.slock);	2952	spin_lock_bh(&sk->sk_lock.slock);
2945	}	2953	}
		2954	if (test_and_clear_bit(MPTCP_ERROR_REPORT, &mptcp_sk(sk)->flags))
		2955	__mptcp_error_report(sk);
2946		2956
2947	/* clear any wmem reservation and errors */	2957	/* clear any wmem reservation and errors */
2948	__mptcp_update_wmem(sk);	2958	__mptcp_update_wmem(sk);
@@ -3319,7 +3329,7 @@ static __poll_t mptcp_check_writeable(struct mptcp_sock *msk) · 370 unmodified lines
3319	struct sock sk = (struct sock )msk;	3329	struct sock sk = (struct sock )msk;
3320		3330
3321	if (unlikely(sk->sk_shutdown & SEND_SHUTDOWN))	3331	if (unlikely(sk->sk_shutdown & SEND_SHUTDOWN))
3322	return 0;	3332	return EPOLLOUT \| EPOLLWRNORM;
3323		3333
3324	if (sk_stream_is_writeable(sk))	3334	if (sk_stream_is_writeable(sk))
3325	return EPOLLOUT \| EPOLLWRNORM;	3335	return EPOLLOUT \| EPOLLWRNORM;
@@ -3352,9 +3362,16 @@ static __poll_t mptcp_poll(struct file file, struct socket sock, · 26 unmodified lines
3352	mask \|= mptcp_check_readable(msk);	3362	mask \|= mptcp_check_readable(msk);
3353	mask \|= mptcp_check_writeable(msk);	3363	mask \|= mptcp_check_writeable(msk);
3354	}	3364	}
		3365	if (sk->sk_shutdown == SHUTDOWN_MASK \|\| state == TCP_CLOSE)
		3366	mask \|= EPOLLHUP;
3355	if (sk->sk_shutdown & RCV_SHUTDOWN)	3367	if (sk->sk_shutdown & RCV_SHUTDOWN)
3356	mask \|= EPOLLIN \| EPOLLRDNORM \| EPOLLRDHUP;	3368	mask \|= EPOLLIN \| EPOLLRDNORM \| EPOLLRDHUP;
3357		3369
		3370	/* This barrier is coupled with smp_wmb() in tcp_reset() */
		3371	smp_rmb();
		3372	if (sk->sk_err)
		3373	mask \|= EPOLLERR;
		3374
3358	return mask;	3375	return mask;
3359	}	3376	}
3360		3377

net/mptcp/protocol.h+7−11

 #define MPTCP_WORK_CLOSE_SUBFLOW 5
 #define MPTCP_PUSH_PENDING	6
 #define MPTCP_CLEAN_UNA		7
+#define MPTCP_ERROR_REPORT	8
 static inline bool before64(__u64 seq1, __u64 seq2)
 {
 	u64		wnd_end;
 	unsigned long	timer_ival;
 	u32		token;
-	int		rmem_pending;
 	int		rmem_released;
 	unsigned long	flags;
 	bool		can_ack;
 static inline int __mptcp_space(const struct sock *sk)
 {
-	return tcp_space(sk) + READ_ONCE(mptcp_sk(sk)->rmem_pending);
+	return tcp_space(sk) + READ_ONCE(mptcp_sk(sk)->rmem_released);
 }
 static inline struct mptcp_data_frag *mptcp_send_head(const struct sock *sk)
 	return list_last_entry(&msk->rtx_queue, struct mptcp_data_frag, list);
 }
-static inline struct mptcp_data_frag *mptcp_rtx_tail(const struct sock *sk)
+static inline struct mptcp_data_frag *mptcp_rtx_head(const struct sock *sk)
 {
 	struct mptcp_sock *msk = mptcp_sk(sk);
-	if (!before64(msk->snd_nxt, READ_ONCE(msk->snd_una)))
+	if (msk->snd_una == READ_ONCE(msk->snd_nxt))
 		return NULL;
-	return list_last_entry(&msk->rtx_queue, struct mptcp_data_frag, list);
-}
-static inline struct mptcp_data_frag *mptcp_rtx_head(const struct sock *sk)
-{
-	struct mptcp_sock *msk = mptcp_sk(sk);
 	return list_first_entry_or_null(&msk->rtx_queue, struct mptcp_data_frag, list);
 }
 	void	(*tcp_data_ready)(struct sock *sk);
 	void	(*tcp_state_change)(struct sock *sk);
 	void	(*tcp_write_space)(struct sock *sk);
+	void	(*tcp_error_report)(struct sock *sk);
 	struct	rcu_head rcu;
 };
 	sk->sk_data_ready = ctx->tcp_data_ready;
 	sk->sk_state_change = ctx->tcp_state_change;
 	sk->sk_write_space = ctx->tcp_write_space;
+	sk->sk_error_report = ctx->tcp_error_report;
 	inet_csk(sk)->icsk_af_ops = ctx->icsk_af_ops;
 }
 bool mptcp_schedule_work(struct sock *sk);
 void __mptcp_check_push(struct sock *sk, struct sock *ssk);
 void __mptcp_data_acked(struct sock *sk);
+void __mptcp_error_report(struct sock *sk);
 void mptcp_subflow_eof(struct sock *sk);
 bool mptcp_update_rcv_data_fin(struct mptcp_sock *msk, u64 data_fin_seq, bool use_64bit);
 void __mptcp_flush_join_list(struct mptcp_sock *msk);

net/mptcp/subflow.c+59−24

 	return msk;
 }
-static int __subflow_init_req(struct request_sock *req, const struct sock *sk_listener)
+static void subflow_init_req(struct request_sock *req, const struct sock *sk_listener)
 {
 	struct mptcp_subflow_request_sock *subflow_req = mptcp_subflow_rsk(req);
 	subflow_req->mp_join = 0;
 	subflow_req->msk = NULL;
 	mptcp_token_init_request(req);
-#ifdef CONFIG_TCP_MD5SIG
-	/* no MPTCP if MD5SIG is enabled on this socket or we may run out of
-	 * TCP option space.
-	 */
-	if (rcu_access_pointer(tcp_sk(sk_listener)->md5sig_info))
-		return -EINVAL;
-#endif
-	return 0;
 }
 static bool subflow_use_different_sport(struct mptcp_sock *msk, const struct sock *sk)
  * Returns an error code if a JOIN has failed and a TCP reset
  * should be sent.
  */
-static int subflow_init_req(struct request_sock *req,
+static int subflow_check_req(struct request_sock *req,
-			    const struct sock *sk_listener,
+			     const struct sock *sk_listener,
-			    struct sk_buff *skb)
+			     struct sk_buff *skb)
 {
 	struct mptcp_subflow_context *listener = mptcp_subflow_ctx(sk_listener);
 	struct mptcp_subflow_request_sock *subflow_req = mptcp_subflow_rsk(req);
 	struct mptcp_options_received mp_opt;
-	int ret;
 	pr_debug("subflow_req=%p, listener=%p", subflow_req, listener);
-	ret = __subflow_init_req(req, sk_listener);
+#ifdef CONFIG_TCP_MD5SIG
-	if (ret)
+	/* no MPTCP if MD5SIG is enabled on this socket or we may run out of
-		return 0;
+	 * TCP option space.
+	 */
+	if (rcu_access_pointer(tcp_sk(sk_listener)->md5sig_info))
+		return -EINVAL;
+#endif
 	mptcp_get_options(skb, &mp_opt);
 	struct mptcp_options_received mp_opt;
 	int err;
-	err = __subflow_init_req(req, sk_listener);
+	subflow_init_req(req, sk_listener);
-	if (err)
-		return err;
 	mptcp_get_options(skb, &mp_opt);
 	if (mp_opt.mp_capable && mp_opt.mp_join)
 	int err;
 	tcp_rsk(req)->is_mptcp = 1;
+	subflow_init_req(req, sk);
 	dst = tcp_request_sock_ipv4_ops.route_req(sk, skb, fl, req);
 	if (!dst)
 		return NULL;
-	err = subflow_init_req(req, sk, skb);
+	err = subflow_check_req(req, sk, skb);
 	if (err == 0)
 		return dst;
 	int err;
 	tcp_rsk(req)->is_mptcp = 1;
+	subflow_init_req(req, sk);
 	dst = tcp_request_sock_ipv6_ops.route_req(sk, skb, fl, req);
 	if (!dst)
 		return NULL;
-	err = subflow_init_req(req, sk, skb);
+	err = subflow_check_req(req, sk, skb);
 	if (err == 0)
 		return dst;
 	mptcp_write_space(sk);
 }
+void __mptcp_error_report(struct sock *sk)
+{
+	struct mptcp_subflow_context *subflow;
+	struct mptcp_sock *msk = mptcp_sk(sk);
+	mptcp_for_each_subflow(msk, subflow) {
+		struct sock *ssk = mptcp_subflow_tcp_sock(subflow);
+		int err = sock_error(ssk);
+		if (!err)
+			continue;
+		/* only propagate errors on fallen-back sockets or
+		 * on MPC connect
+		 */
+		if (sk->sk_state != TCP_SYN_SENT && !__mptcp_check_fallback(msk))
+			continue;
+		inet_sk_state_store(sk, inet_sk_state_load(ssk));
+		sk->sk_err = -err;
+		/* This barrier is coupled with smp_rmb() in mptcp_poll() */
+		smp_wmb();
+		sk->sk_error_report(sk);
+		break;
+	}
+}
+static void subflow_error_report(struct sock *ssk)
+{
+	struct sock *sk = mptcp_subflow_ctx(ssk)->conn;
+	mptcp_data_lock(sk);
+	if (!sock_owned_by_user(sk))
+		__mptcp_error_report(sk);
+	else
+		set_bit(MPTCP_ERROR_REPORT,  &mptcp_sk(sk)->flags);
+	mptcp_data_unlock(sk);
+}
 static struct inet_connection_sock_af_ops *
 subflow_default_af_ops(struct sock *sk)
 {
 	ctx->tcp_data_ready = sk->sk_data_ready;
 	ctx->tcp_state_change = sk->sk_state_change;
 	ctx->tcp_write_space = sk->sk_write_space;
+	ctx->tcp_error_report = sk->sk_error_report;
 	sk->sk_data_ready = subflow_data_ready;
 	sk->sk_write_space = subflow_write_space;
 	sk->sk_state_change = subflow_state_change;
+	sk->sk_error_report = subflow_error_report;
 out:
 	return err;
 }
 	new_ctx->tcp_data_ready = old_ctx->tcp_data_ready;
 	new_ctx->tcp_state_change = old_ctx->tcp_state_change;
 	new_ctx->tcp_write_space = old_ctx->tcp_write_space;
+	new_ctx->tcp_error_report = old_ctx->tcp_error_report;
 	new_ctx->rel_write_seq = 1;
 	new_ctx->tcp_sock = newsk;

net/sched/act_api.c+1−1

@@ -908,7 +908,7 @@ static const struct nla_policy tcf_action_policy[TCA_ACT_MAX + 1] = { · 907 unmodified lines
908	[TCA_ACT_HW_STATS] = NLA_POLICY_BITFIELD32(TCA_ACT_HW_STATS_ANY),	908	[TCA_ACT_HW_STATS] = NLA_POLICY_BITFIELD32(TCA_ACT_HW_STATS_ANY),
909	};	909	};
910		910
911	static void tcf_idr_insert_many(struct tc_action *actions[])	911	void tcf_idr_insert_many(struct tc_action *actions[])
912	{	912	{
913	int i;	913	int i;
914		914

net/sched/cls_api.c+1−0

@@ -3060,6 +3060,7 @@ int tcf_exts_validate(struct net net, struct tcf_proto tp, struct nlattr **tb, · 3059 unmodified lines
3060	act->type = exts->type = TCA_OLD_COMPAT;	3060	act->type = exts->type = TCA_OLD_COMPAT;
3061	exts->actions[0] = act;	3061	exts->actions[0] = act;
3062	exts->nr_actions = 1;	3062	exts->nr_actions = 1;
		3063	tcf_idr_insert_many(exts->actions);
3063	} else if (exts->action && tb[exts->action]) {	3064	} else if (exts->action && tb[exts->action]) {
3064	int err;	3065	int err;
3065		3066

net/sched/cls_flower.c+37−2

@@ -30,6 +30,11 @@ · 29 unmodified lines
30		30
31	#include <uapi/linux/netfilter/nf_conntrack_common.h>	31	#include <uapi/linux/netfilter/nf_conntrack_common.h>
32		32
		33	#define TCA_FLOWER_KEY_CT_FLAGS_MAX \
		34	((__TCA_FLOWER_KEY_CT_FLAGS_MAX - 1) << 1)
		35	#define TCA_FLOWER_KEY_CT_FLAGS_MASK \
		36	(TCA_FLOWER_KEY_CT_FLAGS_MAX - 1)
		37
33	struct fl_flow_key {	38	struct fl_flow_key {
34	struct flow_dissector_key_meta meta;	39	struct flow_dissector_key_meta meta;
35	struct flow_dissector_key_control control;	40	struct flow_dissector_key_control control;
@@ -690,8 +695,10 @@ static const struct nla_policy fl_policy[TCA_FLOWER_MAX + 1] = { · 654 unmodified lines
690	[TCA_FLOWER_KEY_ENC_IP_TTL_MASK] = { .type = NLA_U8 },	695	[TCA_FLOWER_KEY_ENC_IP_TTL_MASK] = { .type = NLA_U8 },
691	[TCA_FLOWER_KEY_ENC_OPTS] = { .type = NLA_NESTED },	696	[TCA_FLOWER_KEY_ENC_OPTS] = { .type = NLA_NESTED },
692	[TCA_FLOWER_KEY_ENC_OPTS_MASK] = { .type = NLA_NESTED },	697	[TCA_FLOWER_KEY_ENC_OPTS_MASK] = { .type = NLA_NESTED },
693	[TCA_FLOWER_KEY_CT_STATE] = { .type = NLA_U16 },	698	[TCA_FLOWER_KEY_CT_STATE] =
694	[TCA_FLOWER_KEY_CT_STATE_MASK] = { .type = NLA_U16 },	699	NLA_POLICY_MASK(NLA_U16, TCA_FLOWER_KEY_CT_FLAGS_MASK),
		700	[TCA_FLOWER_KEY_CT_STATE_MASK] =
		701	NLA_POLICY_MASK(NLA_U16, TCA_FLOWER_KEY_CT_FLAGS_MASK),
695	[TCA_FLOWER_KEY_CT_ZONE] = { .type = NLA_U16 },	702	[TCA_FLOWER_KEY_CT_ZONE] = { .type = NLA_U16 },
696	[TCA_FLOWER_KEY_CT_ZONE_MASK] = { .type = NLA_U16 },	703	[TCA_FLOWER_KEY_CT_ZONE_MASK] = { .type = NLA_U16 },
697	[TCA_FLOWER_KEY_CT_MARK] = { .type = NLA_U32 },	704	[TCA_FLOWER_KEY_CT_MARK] = { .type = NLA_U32 },
@@ -1394,12 +1401,33 @@ static int fl_set_enc_opt(struct nlattr *tb, struct fl_flow_key key, · 696 unmodified lines
1394	return 0;	1401	return 0;
1395	}	1402	}
1396		1403
		1404	static int fl_validate_ct_state(u16 state, struct nlattr *tb,
		1405	struct netlink_ext_ack *extack)
		1406	{
		1407	if (state && !(state & TCA_FLOWER_KEY_CT_FLAGS_TRACKED)) {
		1408	NL_SET_ERR_MSG_ATTR(extack, tb,
		1409	"no trk, so no other flag can be set");
		1410	return -EINVAL;
		1411	}
		1412
		1413	if (state & TCA_FLOWER_KEY_CT_FLAGS_NEW &&
		1414	state & TCA_FLOWER_KEY_CT_FLAGS_ESTABLISHED) {
		1415	NL_SET_ERR_MSG_ATTR(extack, tb,
		1416	"new and est are mutually exclusive");
		1417	return -EINVAL;
		1418	}
		1419
		1420	return 0;
		1421	}
		1422
1397	static int fl_set_key_ct(struct nlattr **tb,	1423	static int fl_set_key_ct(struct nlattr **tb,
1398	struct flow_dissector_key_ct *key,	1424	struct flow_dissector_key_ct *key,
1399	struct flow_dissector_key_ct *mask,	1425	struct flow_dissector_key_ct *mask,
1400	struct netlink_ext_ack *extack)	1426	struct netlink_ext_ack *extack)
1401	{	1427	{
1402	if (tb[TCA_FLOWER_KEY_CT_STATE]) {	1428	if (tb[TCA_FLOWER_KEY_CT_STATE]) {
		1429	int err;
		1430
1403	if (!IS_ENABLED(CONFIG_NF_CONNTRACK)) {	1431	if (!IS_ENABLED(CONFIG_NF_CONNTRACK)) {
1404	NL_SET_ERR_MSG(extack, "Conntrack isn't enabled");	1432	NL_SET_ERR_MSG(extack, "Conntrack isn't enabled");
1405	return -EOPNOTSUPP;	1433	return -EOPNOTSUPP;
@@ -1407,6 +1435,13 @@ static int fl_set_key_ct(struct nlattr **tb, · 1 unmodified line
1407	fl_set_key_val(tb, &key->ct_state, TCA_FLOWER_KEY_CT_STATE,	1435	fl_set_key_val(tb, &key->ct_state, TCA_FLOWER_KEY_CT_STATE,
1408	&mask->ct_state, TCA_FLOWER_KEY_CT_STATE_MASK,	1436	&mask->ct_state, TCA_FLOWER_KEY_CT_STATE_MASK,
1409	sizeof(key->ct_state));	1437	sizeof(key->ct_state));
		1438
		1439	err = fl_validate_ct_state(mask->ct_state,
		1440	tb[TCA_FLOWER_KEY_CT_STATE_MASK],
		1441	extack);
		1442	if (err)
		1443	return err;
		1444
1410	}	1445	}
1411	if (tb[TCA_FLOWER_KEY_CT_ZONE]) {	1446	if (tb[TCA_FLOWER_KEY_CT_ZONE]) {
1412	if (!IS_ENABLED(CONFIG_NF_CONNTRACK_ZONES)) {	1447	if (!IS_ENABLED(CONFIG_NF_CONNTRACK_ZONES)) {

tools/testing/selftests/bpf/test_xdp_redirect.sh+3−7

-#!/bin/sh
+#!/bin/bash
 # Create 2 namespaces with two veth peers, and
 # forward packets in-between using generic XDP
 #
 	ip link set dev veth1 $xdpmode obj test_xdp_redirect.o sec redirect_to_222 &> /dev/null
 	ip link set dev veth2 $xdpmode obj test_xdp_redirect.o sec redirect_to_111 &> /dev/null
-	ip netns exec ns1 ping -c 1 10.1.1.22 &> /dev/null
+	if ip netns exec ns1 ping -c 1 10.1.1.22 &> /dev/null &&
-	local ret1=$?
+	   ip netns exec ns2 ping -c 1 10.1.1.11 &> /dev/null; then
-	ip netns exec ns2 ping -c 1 10.1.1.11 &> /dev/null
-	local ret2=$?
-	if [ $ret1 -eq 0 -a $ret2 -eq 0 ]; then
 		echo "selftests: test_xdp_redirect $xdpmode [PASS]";
 	else
 		ret=1

tools/testing/selftests/net/forwarding/tc_flower.sh+37−1

@@ -3,7 +3,7 @@ · 2 unmodified lines
3		3
4	ALL_TESTS="match_dst_mac_test match_src_mac_test match_dst_ip_test \	4	ALL_TESTS="match_dst_mac_test match_src_mac_test match_dst_ip_test \
5	match_src_ip_test match_ip_flags_test match_pcp_test match_vlan_test \	5	match_src_ip_test match_ip_flags_test match_pcp_test match_vlan_test \
6	match_ip_tos_test match_indev_test match_mpls_label_test \	6	match_ip_tos_test match_indev_testmatch_ip_ttl_test match_mpls_label_test \
7	match_mpls_tc_test match_mpls_bos_test match_mpls_ttl_test \	7	match_mpls_tc_test match_mpls_bos_test match_mpls_ttl_test \
8	match_mpls_lse_test"	8	match_mpls_lse_test"
9	NUM_NETIFS=2	9	NUM_NETIFS=2
@@ -312,6 +312,42 @@ match_ip_tos_test() · 302 unmodified lines
312	log_test "ip_tos match ($tcflags)"	312	log_test "ip_tos match ($tcflags)"
313	}	313	}
314		314
		315	match_ip_ttl_test()
		316	{
		317	RET=0
		318
		319	tc filter add dev $h2 ingress protocol ip pref 1 handle 101 flower \
		320	$tcflags dst_ip 192.0.2.2 ip_ttl 63 action drop
		321	tc filter add dev $h2 ingress protocol ip pref 2 handle 102 flower \
		322	$tcflags dst_ip 192.0.2.2 action drop
		323
		324	$MZ $h1 -c 1 -p 64 -a $h1mac -b $h2mac -A 192.0.2.1 -B 192.0.2.2 \
		325	-t ip "ttl=63" -q
		326
		327	$MZ $h1 -c 1 -p 64 -a $h1mac -b $h2mac -A 192.0.2.1 -B 192.0.2.2 \
		328	-t ip "ttl=63,mf,frag=256" -q
		329
		330	tc_check_packets "dev $h2 ingress" 102 1
		331	check_fail $? "Matched on the wrong filter (no check on ttl)"
		332
		333	tc_check_packets "dev $h2 ingress" 101 2
		334	check_err $? "Did not match on correct filter (ttl=63)"
		335
		336	$MZ $h1 -c 1 -p 64 -a $h1mac -b $h2mac -A 192.0.2.1 -B 192.0.2.2 \
		337	-t ip "ttl=255" -q
		338
		339	tc_check_packets "dev $h2 ingress" 101 3
		340	check_fail $? "Matched on a wrong filter (ttl=63)"
		341
		342	tc_check_packets "dev $h2 ingress" 102 1
		343	check_err $? "Did not match on correct filter (no check on ttl)"
		344
		345	tc filter del dev $h2 ingress protocol ip pref 2 handle 102 flower
		346	tc filter del dev $h2 ingress protocol ip pref 1 handle 101 flower
		347
		348	log_test "ip_ttl match ($tcflags)"
		349	}
		350
315	match_indev_test()	351	match_indev_test()
316	{	352	{
317	RET=0	353	RET=0