lael-labs/linux

drivers/net/bonding/bond_main.c+52−3

@@ -3526,6 +3526,47 @@ static void bond_fold_stats(struct rtnl_link_stats64 *_res, · 3525 unmodified lines
3526	}	3526	}
3527	}	3527	}
3528		3528
		3529	#ifdef CONFIG_LOCKDEP
		3530	static int bond_get_lowest_level_rcu(struct net_device *dev)
		3531	{
		3532	struct net_device ldev, next, now, dev_stack[MAX_NEST_DEV + 1];
		3533	struct list_head niter, iter, *iter_stack[MAX_NEST_DEV + 1];
		3534	int cur = 0, max = 0;
		3535
		3536	now = dev;
		3537	iter = &dev->adj_list.lower;
		3538
		3539	while (1) {
		3540	next = NULL;
		3541	while (1) {
		3542	ldev = netdev_next_lower_dev_rcu(now, &iter);
		3543	if (!ldev)
		3544	break;
		3545
		3546	next = ldev;
		3547	niter = &ldev->adj_list.lower;
		3548	dev_stack[cur] = now;
		3549	iter_stack[cur++] = iter;
		3550	if (max <= cur)
		3551	max = cur;
		3552	break;
		3553	}
		3554
		3555	if (!next) {
		3556	if (!cur)
		3557	return max;
		3558	next = dev_stack[--cur];
		3559	niter = iter_stack[cur];
		3560	}
		3561
		3562	now = next;
		3563	iter = niter;
		3564	}
		3565
		3566	return max;
		3567	}
		3568	#endif
		3569
3529	static void bond_get_stats(struct net_device *bond_dev,	3570	static void bond_get_stats(struct net_device *bond_dev,
3530	struct rtnl_link_stats64 *stats)	3571	struct rtnl_link_stats64 *stats)
3531	{	3572	{
@@ -3533,11 +3574,17 @@ static void bond_get_stats(struct net_device *bond_dev, · 1 unmodified line
3533	struct rtnl_link_stats64 temp;	3574	struct rtnl_link_stats64 temp;
3534	struct list_head *iter;	3575	struct list_head *iter;
3535	struct slave *slave;	3576	struct slave *slave;
		3577	int nest_level = 0;
3536		3578
3537	spin_lock(&bond->stats_lock);
3538	memcpy(stats, &bond->bond_stats, sizeof(*stats));
3539		3579
3540	rcu_read_lock();	3580	rcu_read_lock();
		3581	#ifdef CONFIG_LOCKDEP
		3582	nest_level = bond_get_lowest_level_rcu(bond_dev);
		3583	#endif
		3584
		3585	spin_lock_nested(&bond->stats_lock, nest_level);
		3586	memcpy(stats, &bond->bond_stats, sizeof(*stats));
		3587
3541	bond_for_each_slave_rcu(bond, slave, iter) {	3588	bond_for_each_slave_rcu(bond, slave, iter) {
3542	const struct rtnl_link_stats64 *new =	3589	const struct rtnl_link_stats64 *new =
3543	dev_get_stats(slave->dev, &temp);	3590	dev_get_stats(slave->dev, &temp);
@@ -3547,10 +3594,10 @@ static void bond_get_stats(struct net_device *bond_dev, · 3 unmodified lines
3547	/* save off the slave stats for the next run */	3594	/* save off the slave stats for the next run */
3548	memcpy(&slave->slave_stats, new, sizeof(*new));	3595	memcpy(&slave->slave_stats, new, sizeof(*new));
3549	}	3596	}
3550	rcu_read_unlock();
3551		3597
3552	memcpy(&bond->bond_stats, stats, sizeof(*stats));	3598	memcpy(&bond->bond_stats, stats, sizeof(*stats));
3553	spin_unlock(&bond->stats_lock);	3599	spin_unlock(&bond->stats_lock);
		3600	rcu_read_unlock();
3554	}	3601	}
3555		3602
3556	static int bond_do_ioctl(struct net_device bond_dev, struct ifreq ifr, int cmd)	3603	static int bond_do_ioctl(struct net_device bond_dev, struct ifreq ifr, int cmd)
@@ -3640,6 +3687,8 @@ static int bond_do_ioctl(struct net_device bond_dev, struct ifreq ifr, int cmd · 83 unmodified lines
3640	case BOND_RELEASE_OLD:	3687	case BOND_RELEASE_OLD:
3641	case SIOCBONDRELEASE:	3688	case SIOCBONDRELEASE:
3642	res = bond_release(bond_dev, slave_dev);	3689	res = bond_release(bond_dev, slave_dev);
		3690	if (!res)
		3691	netdev_update_lockdep_key(slave_dev);
3643	break;	3692	break;
3644	case BOND_SETHWADDR_OLD:	3693	case BOND_SETHWADDR_OLD:
3645	case SIOCBONDSETHWADDR:	3694	case SIOCBONDSETHWADDR:

drivers/net/bonding/bond_options.c+2−0

@@ -1398,6 +1398,8 @@ static int bond_option_slaves_set(struct bonding *bond, · 1397 unmodified lines
1398	case '-':	1398	case '-':
1399	slave_dbg(bond->dev, dev, "Releasing interface\n");	1399	slave_dbg(bond->dev, dev, "Releasing interface\n");
1400	ret = bond_release(bond->dev, dev);	1400	ret = bond_release(bond->dev, dev);
		1401	if (!ret)
		1402	netdev_update_lockdep_key(dev);
1401	break;	1403	break;
1402		1404
1403	default:	1405	default:

drivers/net/dsa/b53/b53_common.c+3−0

@@ -1366,6 +1366,9 @@ void b53_vlan_add(struct dsa_switch *ds, int port, · 1365 unmodified lines
1366		1366
1367	b53_get_vlan_entry(dev, vid, vl);	1367	b53_get_vlan_entry(dev, vid, vl);
1368		1368
		1369	if (vid == 0 && vid == b53_default_pvid(dev))
		1370	untagged = true;
		1371
1369	vl->members \|= BIT(port);	1372	vl->members \|= BIT(port);
1370	if (untagged && !dsa_is_cpu_port(ds, port))	1373	if (untagged && !dsa_is_cpu_port(ds, port))
1371	vl->untag \|= BIT(port);	1374	vl->untag \|= BIT(port);

drivers/net/ethernet/aquantia/atlantic/aq_ethtool.c+5−0

 	if (flags & ~AQ_PRIV_FLAGS_MASK)
 		return -EOPNOTSUPP;
+	if (hweight32((flags | priv_flags) & AQ_HW_LOOPBACK_MASK) > 1) {
+		netdev_info(ndev, "Can't enable more than one loopback simultaneously\n");
+		return -EINVAL;
+	}
 	cfg->priv_flags = flags;
 	if ((priv_flags ^ flags) & BIT(AQ_HW_LOOPBACK_DMA_NET)) {

drivers/net/ethernet/aquantia/atlantic/aq_filters.c+1−1

@@ -163,7 +163,7 @@ aq_check_approve_fvlan(struct aq_nic_s *aq_nic, · 162 unmodified lines
163	}	163	}
164		164
165	if ((aq_nic->ndev->features & NETIF_F_HW_VLAN_CTAG_FILTER) &&	165	if ((aq_nic->ndev->features & NETIF_F_HW_VLAN_CTAG_FILTER) &&
166	(!test_bit(be16_to_cpu(fsp->h_ext.vlan_tci),	166	(!test_bit(be16_to_cpu(fsp->h_ext.vlan_tci) & VLAN_VID_MASK,
167	aq_nic->active_vlans))) {	167	aq_nic->active_vlans))) {
168	netdev_err(aq_nic->ndev,	168	netdev_err(aq_nic->ndev,
169	"ethtool: unknown vlan-id specified");	169	"ethtool: unknown vlan-id specified");

drivers/net/ethernet/aquantia/atlantic/aq_hw.h+2−0

@@ -337,6 +337,8 @@ struct aq_fw_ops { · 336 unmodified lines
337		337
338	void (enable_ptp)(struct aq_hw_s self, int enable);	338	void (enable_ptp)(struct aq_hw_s self, int enable);
339		339
		340	void (adjust_ptp)(struct aq_hw_s self, uint64_t adj);
		341
340	int (set_eee_rate)(struct aq_hw_s self, u32 speed);	342	int (set_eee_rate)(struct aq_hw_s self, u32 speed);
341		343
342	int (get_eee_rate)(struct aq_hw_s self, u32 *rate,	344	int (get_eee_rate)(struct aq_hw_s self, u32 *rate,

drivers/net/ethernet/aquantia/atlantic/aq_nic.c+3−5

 				     dx_buff->len,
 				     DMA_TO_DEVICE);
-	if (unlikely(dma_mapping_error(aq_nic_get_dev(self), dx_buff->pa)))
+	if (unlikely(dma_mapping_error(aq_nic_get_dev(self), dx_buff->pa))) {
+		ret = 0;
 		goto exit;
+	}
 	first = dx_buff;
 	dx_buff->len_pkt = skb->len;
 	if (likely(frags)) {
 		err = self->aq_hw_ops->hw_ring_tx_xmit(self->aq_hw,
 						       ring, frags);
-		if (err >= 0) {
-			++ring->stats.tx.packets;
-			ring->stats.tx.bytes += skb->len;
-		}
 	} else {
 		err = NETDEV_TX_BUSY;
 	}

drivers/net/ethernet/aquantia/atlantic/aq_pci_func.c+8−5

 	netif_device_detach(nic->ndev);
 	netif_tx_stop_all_queues(nic->ndev);
-	aq_nic_stop(nic);
+	if (netif_running(nic->ndev))
+		aq_nic_stop(nic);
 	if (deep) {
 		aq_nic_deinit(nic, !nic->aq_hw->aq_nic_cfg->wol);
 {
 	struct pci_dev *pdev = to_pci_dev(dev);
 	struct aq_nic_s *nic;
-	int ret;
+	int ret = 0;
 	nic = pci_get_drvdata(pdev);
 			goto err_exit;
 	}
-	ret = aq_nic_start(nic);
+	if (netif_running(nic->ndev)) {
-	if (ret)
+		ret = aq_nic_start(nic);
-		goto err_exit;
+		if (ret)
+			goto err_exit;
+	}
 	netif_device_attach(nic->ndev);
 	netif_tx_start_all_queues(nic->ndev);

drivers/net/ethernet/aquantia/atlantic/aq_ring.c+7−3

 			}
 		}
-		if (unlikely(buff->is_eop))
+		if (unlikely(buff->is_eop)) {
-			dev_kfree_skb_any(buff->skb);
+			++self->stats.rx.packets;
+			self->stats.tx.bytes += buff->skb->len;
+			dev_kfree_skb_any(buff->skb);
+		}
 		buff->pa = 0U;
 		buff->eop_index = 0xffffU;
 		self->sw_head = aq_ring_next_dx(self, self->sw_head);
 				err = 0;
 				goto err_exit;
 			}
-			if (buff->is_error || buff->is_cso_err) {
+			if (buff->is_error ||
+			    (buff->is_lro && buff->is_cso_err)) {
 				buff_ = buff;
 				do {
 					next_ = buff_->next,

drivers/net/ethernet/aquantia/atlantic/aq_ring.h+2−1

 			u32 is_cleaned:1;
 			u32 is_error:1;
 			u32 is_vlan:1;
-			u32 rsvd3:4;
+			u32 is_lro:1;
+			u32 rsvd3:3;
 			u16 eop_index;
 			u16 rsvd4;
 		};

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_b0.c+14−8

@@ -823,6 +823,8 @@ static int hw_atl_b0_hw_ring_rx_receive(struct aq_hw_s *self, · 822 unmodified lines
823	}	823	}
824	}	824	}
825		825
		826	buff->is_lro = !!(HW_ATL_B0_RXD_WB_STAT2_RSCCNT &
		827	rxd_wb->status);
826	if (HW_ATL_B0_RXD_WB_STAT2_EOP & rxd_wb->status) {	828	if (HW_ATL_B0_RXD_WB_STAT2_EOP & rxd_wb->status) {
827	buff->len = rxd_wb->pkt_len %	829	buff->len = rxd_wb->pkt_len %
828	AQ_CFG_RX_FRAME_MAX;	830	AQ_CFG_RX_FRAME_MAX;
@@ -835,8 +837,7 @@ static int hw_atl_b0_hw_ring_rx_receive(struct aq_hw_s *self, · 6 unmodified lines
835	rxd_wb->pkt_len > AQ_CFG_RX_FRAME_MAX ?	837	rxd_wb->pkt_len > AQ_CFG_RX_FRAME_MAX ?
836	AQ_CFG_RX_FRAME_MAX : rxd_wb->pkt_len;	838	AQ_CFG_RX_FRAME_MAX : rxd_wb->pkt_len;
837		839
838	if (HW_ATL_B0_RXD_WB_STAT2_RSCCNT &	840	if (buff->is_lro) {
839	rxd_wb->status) {
840	/* LRO */	841	/* LRO */
841	buff->next = rxd_wb->next_desc_ptr;	842	buff->next = rxd_wb->next_desc_ptr;
842	++ring->stats.rx.lro_packets;	843	++ring->stats.rx.lro_packets;
@@ -884,13 +885,16 @@ static int hw_atl_b0_hw_packet_filter_set(struct aq_hw_s *self, · 41 unmodified lines
884	{	885	{
885	struct aq_nic_cfg_s *cfg = self->aq_nic_cfg;	886	struct aq_nic_cfg_s *cfg = self->aq_nic_cfg;
886	unsigned int i = 0U;	887	unsigned int i = 0U;
		888	u32 vlan_promisc;
		889	u32 l2_promisc;
887		890
888	hw_atl_rpfl2promiscuous_mode_en_set(self,	891	l2_promisc = IS_FILTER_ENABLED(IFF_PROMISC) \|\|
889	IS_FILTER_ENABLED(IFF_PROMISC));	892	!!(cfg->priv_flags & BIT(AQ_HW_LOOPBACK_DMA_NET));
		893	vlan_promisc = l2_promisc \|\| cfg->is_vlan_force_promisc;
890		894
891	hw_atl_rpf_vlan_prom_mode_en_set(self,	895	hw_atl_rpfl2promiscuous_mode_en_set(self, l2_promisc);
892	IS_FILTER_ENABLED(IFF_PROMISC) \|\|	896
893	cfg->is_vlan_force_promisc);	897	hw_atl_rpf_vlan_prom_mode_en_set(self, vlan_promisc);
894		898
895	hw_atl_rpfl2multicast_flr_en_set(self,	899	hw_atl_rpfl2multicast_flr_en_set(self,
896	IS_FILTER_ENABLED(IFF_ALLMULTI) &&	900	IS_FILTER_ENABLED(IFF_ALLMULTI) &&
@@ -1161,6 +1165,8 @@ static int hw_atl_b0_adj_sys_clock(struct aq_hw_s *self, s64 delta) · 264 unmodified lines
1161	{	1165	{
1162	self->ptp_clk_offset += delta;	1166	self->ptp_clk_offset += delta;
1163		1167
		1168	self->aq_fw_ops->adjust_ptp(self, self->ptp_clk_offset);
		1169
1164	return 0;	1170	return 0;
1165	}	1171	}
1166		1172
@@ -1211,7 +1217,7 @@ static int hw_atl_b0_gpio_pulse(struct aq_hw_s *self, u32 index, · 44 unmodified lines
1211	fwreq.ptp_gpio_ctrl.index = index;	1217	fwreq.ptp_gpio_ctrl.index = index;
1212	fwreq.ptp_gpio_ctrl.period = period;	1218	fwreq.ptp_gpio_ctrl.period = period;
1213	/* Apply time offset */	1219	/* Apply time offset */
1214	fwreq.ptp_gpio_ctrl.start = start - self->ptp_clk_offset;	1220	fwreq.ptp_gpio_ctrl.start = start;
1215		1221
1216	size = sizeof(fwreq.msg_id) + sizeof(fwreq.ptp_gpio_ctrl);	1222	size = sizeof(fwreq.msg_id) + sizeof(fwreq.ptp_gpio_ctrl);
1217	return self->aq_fw_ops->send_fw_request(self, &fwreq, size);	1223	return self->aq_fw_ops->send_fw_request(self, &fwreq, size);

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_utils.c+17−2

 #define HW_ATL_MIF_ADDR         0x0208U
 #define HW_ATL_MIF_VAL          0x020CU
+#define HW_ATL_MPI_RPC_ADDR     0x0334U
 #define HW_ATL_RPC_CONTROL_ADR  0x0338U
 #define HW_ATL_RPC_STATE_ADR    0x033CU
 };
 static int hw_atl_utils_ver_match(u32 ver_expected, u32 ver_actual);
 static int hw_atl_utils_mpi_set_state(struct aq_hw_s *self,
 				      enum hal_atl_utils_fw_state_e state);
 static u32 hw_atl_utils_get_mpi_mbox_tid(struct aq_hw_s *self);
 static u32 hw_atl_utils_mpi_get_state(struct aq_hw_s *self);
 static u32 hw_atl_utils_mif_cmd_get(struct aq_hw_s *self);
 static u32 hw_atl_utils_mif_addr_get(struct aq_hw_s *self);
 static u32 hw_atl_utils_rpc_state_get(struct aq_hw_s *self);
+static u32 aq_fw1x_rpc_get(struct aq_hw_s *self);
 int hw_atl_utils_initfw(struct aq_hw_s *self, const struct aq_fw_ops **fw_ops)
 {
 					self, self->mbox_addr,
 					self->mbox_addr != 0U,
 					1000U, 10000U);
+	err = readx_poll_timeout_atomic(aq_fw1x_rpc_get, self,
+					self->rpc_addr,
+					self->rpc_addr != 0U,
+					1000U, 100000U);
 	return err;
 }
 						self, fw.val,
 						sw.tid == fw.tid,
 						1000U, 100000U);
+		if (err < 0)
+			goto err_exit;
+		err = aq_hw_err_from_flags(self);
+		if (err < 0)
+			goto err_exit;
 		if (fw.len == 0xFFFFU) {
 			err = hw_atl_utils_fw_rpc_call(self, sw.len);
 	return aq_hw_read_reg(self, HW_ATL_RPC_STATE_ADR);
 }
+static u32 aq_fw1x_rpc_get(struct aq_hw_s *self)
+{
+	return aq_hw_read_reg(self, HW_ATL_MPI_RPC_ADDR);
+}
 const struct aq_fw_ops aq_fw_1x_ops = {
 	.init = hw_atl_utils_mpi_create,
 	.deinit = hw_atl_fw1x_deinit,

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_utils_fw2x.c+12−0

 #define HW_ATL_FW3X_EXT_CONTROL_ADDR     0x378
 #define HW_ATL_FW3X_EXT_STATE_ADDR       0x37c
+#define HW_ATL_FW3X_PTP_ADJ_LSW_ADDR	 0x50a0
+#define HW_ATL_FW3X_PTP_ADJ_MSW_ADDR	 0x50a4
 #define HW_ATL_FW2X_CAP_PAUSE            BIT(CAPS_HI_PAUSE)
 #define HW_ATL_FW2X_CAP_ASYM_PAUSE       BIT(CAPS_HI_ASYMMETRIC_PAUSE)
 #define HW_ATL_FW2X_CAP_SLEEP_PROXY      BIT(CAPS_HI_SLEEP_PROXY)
 	aq_hw_write_reg(self, HW_ATL_FW3X_EXT_CONTROL_ADDR, ptp_opts);
 }
+static void aq_fw3x_adjust_ptp(struct aq_hw_s *self, uint64_t adj)
+{
+	aq_hw_write_reg(self, HW_ATL_FW3X_PTP_ADJ_LSW_ADDR,
+			(adj >>  0) & 0xffffffff);
+	aq_hw_write_reg(self, HW_ATL_FW3X_PTP_ADJ_MSW_ADDR,
+			(adj >> 32) & 0xffffffff);
+}
 static int aq_fw2x_led_control(struct aq_hw_s *self, u32 mode)
 {
 	if (self->fw_ver_actual < HW_ATL_FW_VER_LED)
 	.enable_ptp         = aq_fw3x_enable_ptp,
 	.led_control        = aq_fw2x_led_control,
 	.set_phyloopback    = aq_fw2x_set_phyloopback,
+	.adjust_ptp         = aq_fw3x_adjust_ptp,
 };

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

 	if (version_printed++ == 0)
 		pr_info("%s", version);
+	/* Clear any pending DMA transactions from crash kernel
+	 * while loading driver in capture kernel.
+	 */
+	if (is_kdump_kernel()) {
+		pci_clear_master(pdev);
+		pcie_flr(pdev);
+	}
 	max_irqs = bnxt_get_max_irq(pdev);
 	dev = alloc_etherdev_mq(sizeof(*bp), max_irqs);
 	if (!dev)
 		dev_close(dev);
 	bnxt_ulp_shutdown(bp);
+	bnxt_clear_int_mode(bp);
+	pci_disable_device(pdev);
 	if (system_state == SYSTEM_POWER_OFF) {
-		bnxt_clear_int_mode(bp);
-		pci_disable_device(pdev);
 		pci_wake_from_d3(pdev, bp->wol);
 		pci_set_power_state(pdev, PCI_D3hot);
 	}

drivers/net/ethernet/broadcom/cnic_defs.h+2−2

@@ -543,13 +543,13 @@ struct l4_kwq_update_pg { · 542 unmodified lines
543	#define L4_KWQ_UPDATE_PG_RESERVERD2_SHIFT 2	543	#define L4_KWQ_UPDATE_PG_RESERVERD2_SHIFT 2
544	#endif	544	#endif
545	#if defined(__BIG_ENDIAN)	545	#if defined(__BIG_ENDIAN)
546	u16 reserverd3;	546	u16 reserved3;
547	u8 da0;	547	u8 da0;
548	u8 da1;	548	u8 da1;
549	#elif defined(__LITTLE_ENDIAN)	549	#elif defined(__LITTLE_ENDIAN)
550	u8 da1;	550	u8 da1;
551	u8 da0;	551	u8 da0;
552	u16 reserverd3;	552	u16 reserved3;
553	#endif	553	#endif
554	#if defined(__BIG_ENDIAN)	554	#if defined(__BIG_ENDIAN)
555	u8 da2;	555	u8 da2;

drivers/net/ethernet/cadence/macb.h+1−0

@@ -652,6 +652,7 @@ · 651 unmodified lines
652	#define MACB_CAPS_GEM_HAS_PTP 0x00000040	652	#define MACB_CAPS_GEM_HAS_PTP 0x00000040
653	#define MACB_CAPS_BD_RD_PREFETCH 0x00000080	653	#define MACB_CAPS_BD_RD_PREFETCH 0x00000080
654	#define MACB_CAPS_NEEDS_RSTONUBR 0x00000100	654	#define MACB_CAPS_NEEDS_RSTONUBR 0x00000100
		655	#define MACB_CAPS_MACB_IS_EMAC 0x08000000
655	#define MACB_CAPS_FIFO_MODE 0x10000000	656	#define MACB_CAPS_FIFO_MODE 0x10000000
656	#define MACB_CAPS_GIGABIT_MODE_AVAILABLE 0x20000000	657	#define MACB_CAPS_GIGABIT_MODE_AVAILABLE 0x20000000
657	#define MACB_CAPS_SG_DISABLED 0x40000000	658	#define MACB_CAPS_SG_DISABLED 0x40000000

drivers/net/ethernet/cadence/macb_main.c+37−29

@@ -572,8 +572,21 @@ static void macb_mac_config(struct phylink_config *config, unsigned int mode, · 571 unmodified lines
572	old_ctrl = ctrl = macb_or_gem_readl(bp, NCFGR);	572	old_ctrl = ctrl = macb_or_gem_readl(bp, NCFGR);
573		573
574	/* Clear all the bits we might set later */	574	/* Clear all the bits we might set later */
575	ctrl &= ~(GEM_BIT(GBE) \| MACB_BIT(SPD) \| MACB_BIT(FD) \| MACB_BIT(PAE) \|	575	ctrl &= ~(MACB_BIT(SPD) \| MACB_BIT(FD) \| MACB_BIT(PAE));
576	GEM_BIT(SGMIIEN) \| GEM_BIT(PCSSEL));	576
		577	if (bp->caps & MACB_CAPS_MACB_IS_EMAC) {
		578	if (state->interface == PHY_INTERFACE_MODE_RMII)
		579	ctrl \|= MACB_BIT(RM9200_RMII);
		580	} else {
		581	ctrl &= ~(GEM_BIT(GBE) \| GEM_BIT(SGMIIEN) \| GEM_BIT(PCSSEL));
		582
		583	/* We do not support MLO_PAUSE_RX yet */
		584	if (state->pause & MLO_PAUSE_TX)
		585	ctrl \|= MACB_BIT(PAE);
		586
		587	if (state->interface == PHY_INTERFACE_MODE_SGMII)
		588	ctrl \|= GEM_BIT(SGMIIEN) \| GEM_BIT(PCSSEL);
		589	}
577		590
578	if (state->speed == SPEED_1000)	591	if (state->speed == SPEED_1000)
579	ctrl \|= GEM_BIT(GBE);	592	ctrl \|= GEM_BIT(GBE);
@@ -583,13 +596,6 @@ static void macb_mac_config(struct phylink_config *config, unsigned int mode, · 3 unmodified lines
583	if (state->duplex)	596	if (state->duplex)
584	ctrl \|= MACB_BIT(FD);	597	ctrl \|= MACB_BIT(FD);
585		598
586	/* We do not support MLO_PAUSE_RX yet */
587	if (state->pause & MLO_PAUSE_TX)
588	ctrl \|= MACB_BIT(PAE);
589
590	if (state->interface == PHY_INTERFACE_MODE_SGMII)
591	ctrl \|= GEM_BIT(SGMIIEN) \| GEM_BIT(PCSSEL);
592
593	/* Apply the new configuration, if any */	599	/* Apply the new configuration, if any */
594	if (old_ctrl ^ ctrl)	600	if (old_ctrl ^ ctrl)
595	macb_or_gem_writel(bp, NCFGR, ctrl);	601	macb_or_gem_writel(bp, NCFGR, ctrl);
@@ -608,9 +614,10 @@ static void macb_mac_link_down(struct phylink_config *config, unsigned int mode, · 12 unmodified lines
608	unsigned int q;	614	unsigned int q;
609	u32 ctrl;	615	u32 ctrl;
610		616
611	for (q = 0, queue = bp->queues; q < bp->num_queues; ++q, ++queue)	617	if (!(bp->caps & MACB_CAPS_MACB_IS_EMAC))
612	queue_writel(queue, IDR,	618	for (q = 0, queue = bp->queues; q < bp->num_queues; ++q, ++queue)
613	bp->rx_intr_mask \| MACB_TX_INT_FLAGS \| MACB_BIT(HRESP));	619	queue_writel(queue, IDR,
		620	bp->rx_intr_mask \| MACB_TX_INT_FLAGS \| MACB_BIT(HRESP));
614		621
615	/* Disable Rx and Tx */	622	/* Disable Rx and Tx */
616	ctrl = macb_readl(bp, NCR) & ~(MACB_BIT(RE) \| MACB_BIT(TE));	623	ctrl = macb_readl(bp, NCR) & ~(MACB_BIT(RE) \| MACB_BIT(TE));
@@ -627,17 +634,19 @@ static void macb_mac_link_up(struct phylink_config *config, unsigned int mode, · 10 unmodified lines
627	struct macb_queue *queue;	634	struct macb_queue *queue;
628	unsigned int q;	635	unsigned int q;
629		636
630	macb_set_tx_clk(bp->tx_clk, bp->speed, ndev);	637	if (!(bp->caps & MACB_CAPS_MACB_IS_EMAC)) {
		638	macb_set_tx_clk(bp->tx_clk, bp->speed, ndev);
631		639
632	/* Initialize rings & buffers as clearing MACB_BIT(TE) in link down	640	/* Initialize rings & buffers as clearing MACB_BIT(TE) in link down
633	* cleared the pipeline and control registers.	641	* cleared the pipeline and control registers.
634	*/	642	*/
635	bp->macbgem_ops.mog_init_rings(bp);	643	bp->macbgem_ops.mog_init_rings(bp);
636	macb_init_buffers(bp);	644	macb_init_buffers(bp);
637		645
638	for (q = 0, queue = bp->queues; q < bp->num_queues; ++q, ++queue)	646	for (q = 0, queue = bp->queues; q < bp->num_queues; ++q, ++queue)
639	queue_writel(queue, IER,	647	queue_writel(queue, IER,
640	bp->rx_intr_mask \| MACB_TX_INT_FLAGS \| MACB_BIT(HRESP));	648	bp->rx_intr_mask \| MACB_TX_INT_FLAGS \| MACB_BIT(HRESP));
		649	}
641		650
642	/* Enable Rx and Tx */	651	/* Enable Rx and Tx */
643	macb_writel(bp, NCR, macb_readl(bp, NCR) \| MACB_BIT(RE) \| MACB_BIT(TE));	652	macb_writel(bp, NCR, macb_readl(bp, NCR) \| MACB_BIT(RE) \| MACB_BIT(TE));
@@ -3790,6 +3799,10 @@ static int at91ether_open(struct net_device *dev) · 3146 unmodified lines
3790	u32 ctl;	3799	u32 ctl;
3791	int ret;	3800	int ret;
3792		3801
		3802	ret = pm_runtime_get_sync(&lp->pdev->dev);
		3803	if (ret < 0)
		3804	return ret;
		3805
3793	/* Clear internal statistics */	3806	/* Clear internal statistics */
3794	ctl = macb_readl(lp, NCR);	3807	ctl = macb_readl(lp, NCR);
3795	macb_writel(lp, NCR, ctl \| MACB_BIT(CLRSTAT));	3808	macb_writel(lp, NCR, ctl \| MACB_BIT(CLRSTAT));
@@ -3854,7 +3867,7 @@ static int at91ether_close(struct net_device *dev) · 58 unmodified lines
3854	q->rx_buffers, q->rx_buffers_dma);	3867	q->rx_buffers, q->rx_buffers_dma);
3855	q->rx_buffers = NULL;	3868	q->rx_buffers = NULL;
3856		3869
3857	return 0;	3870	return pm_runtime_put(&lp->pdev->dev);
3858	}	3871	}
3859		3872
3860	/* Transmit packet */	3873	/* Transmit packet */
@@ -4037,7 +4050,6 @@ static int at91ether_init(struct platform_device *pdev) · 176 unmodified lines
4037	struct net_device *dev = platform_get_drvdata(pdev);	4050	struct net_device *dev = platform_get_drvdata(pdev);
4038	struct macb *bp = netdev_priv(dev);	4051	struct macb *bp = netdev_priv(dev);
4039	int err;	4052	int err;
4040	u32 reg;
4041		4053
4042	bp->queues[0].bp = bp;	4054	bp->queues[0].bp = bp;
4043		4055
@@ -4051,11 +4063,7 @@ static int at91ether_init(struct platform_device *pdev) · 7 unmodified lines
4051		4063
4052	macb_writel(bp, NCR, 0);	4064	macb_writel(bp, NCR, 0);
4053		4065
4054	reg = MACB_BF(CLK, MACB_CLK_DIV32) \| MACB_BIT(BIG);	4066	macb_writel(bp, NCFGR, MACB_BF(CLK, MACB_CLK_DIV32) \| MACB_BIT(BIG));
4055	if (bp->phy_interface == PHY_INTERFACE_MODE_RMII)
4056	reg \|= MACB_BIT(RM9200_RMII);
4057
4058	macb_writel(bp, NCFGR, reg);
4059		4067
4060	return 0;	4068	return 0;
4061	}	4069	}
@@ -4214,7 +4222,7 @@ static const struct macb_config sama5d4_config = { · 152 unmodified lines
4214	};	4222	};
4215		4223
4216	static const struct macb_config emac_config = {	4224	static const struct macb_config emac_config = {
4217	.caps = MACB_CAPS_NEEDS_RSTONUBR,	4225	.caps = MACB_CAPS_NEEDS_RSTONUBR \| MACB_CAPS_MACB_IS_EMAC,
4218	.clk_init = at91ether_clk_init,	4226	.clk_init = at91ether_clk_init,
4219	.init = at91ether_init,	4227	.init = at91ether_init,
4220	};	4228	};

drivers/net/ethernet/cavium/thunder/thunder_bgx.c+59−3

@@ -410,10 +410,19 @@ void bgx_lmac_rx_tx_enable(int node, int bgx_idx, int lmacid, bool enable) · 409 unmodified lines
410	lmac = &bgx->lmac[lmacid];	410	lmac = &bgx->lmac[lmacid];
411		411
412	cfg = bgx_reg_read(bgx, lmacid, BGX_CMRX_CFG);	412	cfg = bgx_reg_read(bgx, lmacid, BGX_CMRX_CFG);
413	if (enable)	413	if (enable) {
414	cfg \|= CMR_PKT_RX_EN \| CMR_PKT_TX_EN;	414	cfg \|= CMR_PKT_RX_EN \| CMR_PKT_TX_EN;
415	else	415
		416	/* enable TX FIFO Underflow interrupt */
		417	bgx_reg_modify(bgx, lmacid, BGX_GMP_GMI_TXX_INT_ENA_W1S,
		418	GMI_TXX_INT_UNDFLW);
		419	} else {
416	cfg &= ~(CMR_PKT_RX_EN \| CMR_PKT_TX_EN);	420	cfg &= ~(CMR_PKT_RX_EN \| CMR_PKT_TX_EN);
		421
		422	/* Disable TX FIFO Underflow interrupt */
		423	bgx_reg_modify(bgx, lmacid, BGX_GMP_GMI_TXX_INT_ENA_W1C,
		424	GMI_TXX_INT_UNDFLW);
		425	}
417	bgx_reg_write(bgx, lmacid, BGX_CMRX_CFG, cfg);	426	bgx_reg_write(bgx, lmacid, BGX_CMRX_CFG, cfg);
418		427
419	if (bgx->is_rgx)	428	if (bgx->is_rgx)
@@ -1535,6 +1544,48 @@ static int bgx_init_phy(struct bgx *bgx) · 1115 unmodified lines
1535	return bgx_init_of_phy(bgx);	1544	return bgx_init_of_phy(bgx);
1536	}	1545	}
1537		1546
		1547	static irqreturn_t bgx_intr_handler(int irq, void *data)
		1548	{
		1549	struct bgx bgx = (struct bgx )data;
		1550	u64 status, val;
		1551	int lmac;
		1552
		1553	for (lmac = 0; lmac < bgx->lmac_count; lmac++) {
		1554	status = bgx_reg_read(bgx, lmac, BGX_GMP_GMI_TXX_INT);
		1555	if (status & GMI_TXX_INT_UNDFLW) {
		1556	pci_err(bgx->pdev, "BGX%d lmac%d UNDFLW\n",
		1557	bgx->bgx_id, lmac);
		1558	val = bgx_reg_read(bgx, lmac, BGX_CMRX_CFG);
		1559	val &= ~CMR_EN;
		1560	bgx_reg_write(bgx, lmac, BGX_CMRX_CFG, val);
		1561	val \|= CMR_EN;
		1562	bgx_reg_write(bgx, lmac, BGX_CMRX_CFG, val);
		1563	}
		1564	/* clear interrupts */
		1565	bgx_reg_write(bgx, lmac, BGX_GMP_GMI_TXX_INT, status);
		1566	}
		1567
		1568	return IRQ_HANDLED;
		1569	}
		1570
		1571	static void bgx_register_intr(struct pci_dev *pdev)
		1572	{
		1573	struct bgx *bgx = pci_get_drvdata(pdev);
		1574	int ret;
		1575
		1576	ret = pci_alloc_irq_vectors(pdev, BGX_LMAC_VEC_OFFSET,
		1577	BGX_LMAC_VEC_OFFSET, PCI_IRQ_ALL_TYPES);
		1578	if (ret < 0) {
		1579	pci_err(pdev, "Req for #%d msix vectors failed\n",
		1580	BGX_LMAC_VEC_OFFSET);
		1581	return;
		1582	}
		1583	ret = pci_request_irq(pdev, GMPX_GMI_TX_INT, bgx_intr_handler, NULL,
		1584	bgx, "BGX%d", bgx->bgx_id);
		1585	if (ret)
		1586	pci_free_irq(pdev, GMPX_GMI_TX_INT, bgx);
		1587	}
		1588
1538	static int bgx_probe(struct pci_dev pdev, const struct pci_device_id ent)	1589	static int bgx_probe(struct pci_dev pdev, const struct pci_device_id ent)
1539	{	1590	{
1540	int err;	1591	int err;
@@ -1550,7 +1601,7 @@ static int bgx_probe(struct pci_dev pdev, const struct pci_device_id ent) · 9 unmodified lines
1550		1601
1551	pci_set_drvdata(pdev, bgx);	1602	pci_set_drvdata(pdev, bgx);
1552		1603
1553	err = pci_enable_device(pdev);	1604	err = pcim_enable_device(pdev);
1554	if (err) {	1605	if (err) {
1555	dev_err(dev, "Failed to enable PCI device\n");	1606	dev_err(dev, "Failed to enable PCI device\n");
1556	pci_set_drvdata(pdev, NULL);	1607	pci_set_drvdata(pdev, NULL);
@@ -1604,6 +1655,8 @@ static int bgx_probe(struct pci_dev pdev, const struct pci_device_id ent) · 47 unmodified lines
1604		1655
1605	bgx_init_hw(bgx);	1656	bgx_init_hw(bgx);
1606		1657
		1658	bgx_register_intr(pdev);
		1659
1607	/* Enable all LMACs */	1660	/* Enable all LMACs */
1608	for (lmac = 0; lmac < bgx->lmac_count; lmac++) {	1661	for (lmac = 0; lmac < bgx->lmac_count; lmac++) {
1609	err = bgx_lmac_enable(bgx, lmac);	1662	err = bgx_lmac_enable(bgx, lmac);
@@ -1620,6 +1673,7 @@ static int bgx_probe(struct pci_dev pdev, const struct pci_device_id ent) · 10 unmodified lines
1620		1673
1621	err_enable:	1674	err_enable:
1622	bgx_vnic[bgx->bgx_id] = NULL;	1675	bgx_vnic[bgx->bgx_id] = NULL;
		1676	pci_free_irq(pdev, GMPX_GMI_TX_INT, bgx);
1623	err_release_regions:	1677	err_release_regions:
1624	pci_release_regions(pdev);	1678	pci_release_regions(pdev);
1625	err_disable_device:	1679	err_disable_device:
@@ -1637,6 +1691,8 @@ static void bgx_remove(struct pci_dev *pdev) · 11 unmodified lines
1637	for (lmac = 0; lmac < bgx->lmac_count; lmac++)	1691	for (lmac = 0; lmac < bgx->lmac_count; lmac++)
1638	bgx_lmac_disable(bgx, lmac);	1692	bgx_lmac_disable(bgx, lmac);
1639		1693
		1694	pci_free_irq(pdev, GMPX_GMI_TX_INT, bgx);
		1695
1640	bgx_vnic[bgx->bgx_id] = NULL;	1696	bgx_vnic[bgx->bgx_id] = NULL;
1641	pci_release_regions(pdev);	1697	pci_release_regions(pdev);
1642	pci_disable_device(pdev);	1698	pci_disable_device(pdev);

drivers/net/ethernet/cavium/thunder/thunder_bgx.h+9−0

@@ -180,6 +180,15 @@ · 179 unmodified lines
180	#define BGX_GMP_GMI_TXX_BURST 0x38228	180	#define BGX_GMP_GMI_TXX_BURST 0x38228
181	#define BGX_GMP_GMI_TXX_MIN_PKT 0x38240	181	#define BGX_GMP_GMI_TXX_MIN_PKT 0x38240
182	#define BGX_GMP_GMI_TXX_SGMII_CTL 0x38300	182	#define BGX_GMP_GMI_TXX_SGMII_CTL 0x38300
		183	#define BGX_GMP_GMI_TXX_INT 0x38500
		184	#define BGX_GMP_GMI_TXX_INT_W1S 0x38508
		185	#define BGX_GMP_GMI_TXX_INT_ENA_W1C 0x38510
		186	#define BGX_GMP_GMI_TXX_INT_ENA_W1S 0x38518
		187	#define GMI_TXX_INT_PTP_LOST BIT_ULL(4)
		188	#define GMI_TXX_INT_LATE_COL BIT_ULL(3)
		189	#define GMI_TXX_INT_XSDEF BIT_ULL(2)
		190	#define GMI_TXX_INT_XSCOL BIT_ULL(1)
		191	#define GMI_TXX_INT_UNDFLW BIT_ULL(0)
183		192
184	#define BGX_MSIX_VEC_0_29_ADDR 0x400000 /* +(0..29) << 4 */	193	#define BGX_MSIX_VEC_0_29_ADDR 0x400000 /* +(0..29) << 4 */
185	#define BGX_MSIX_VEC_0_29_CTL 0x400008	194	#define BGX_MSIX_VEC_0_29_CTL 0x400008

drivers/net/ethernet/davicom/dm9000.c+2−0

@@ -1405,6 +1405,8 @@ static struct dm9000_plat_data dm9000_parse_dt(struct device dev) · 1404 unmodified lines
1405	mac_addr = of_get_mac_address(np);	1405	mac_addr = of_get_mac_address(np);
1406	if (!IS_ERR(mac_addr))	1406	if (!IS_ERR(mac_addr))
1407	ether_addr_copy(pdata->dev_addr, mac_addr);	1407	ether_addr_copy(pdata->dev_addr, mac_addr);
		1408	else if (PTR_ERR(mac_addr) == -EPROBE_DEFER)
		1409	return ERR_CAST(mac_addr);
1408		1410
1409	return pdata;	1411	return pdata;
1410	}	1412	}

drivers/net/ethernet/intel/ice/ice_ethtool.c+38−18

 	else
 		return -EINVAL;
-	/* Tell the OS link is going down, the link will go back up when fw
-	 * says it is ready asynchronously
-	 */
-	ice_print_link_msg(vsi, false);
-	netif_carrier_off(netdev);
-	netif_tx_stop_all_queues(netdev);
 	/* Set the FC mode and only restart AN if link is up */
 	status = ice_set_fc(pi, &aq_failures, link_up);
 		return -EINVAL;
 	}
-	/* hardware only supports an ITR granularity of 2us */
-	if (coalesce_usecs % 2 != 0) {
-		netdev_info(vsi->netdev, "Invalid value, %s-usecs must be even\n",
-			    c_type_str);
-		return -EINVAL;
-	}
 	if (use_adaptive_coalesce) {
 		rc->itr_setting |= ICE_ITR_DYNAMIC;
 	} else {
-		/* store user facing value how it was set */
+		/* save the user set usecs */
 		rc->itr_setting = coalesce_usecs;
-		/* set to static and convert to value HW understands */
+		/* device ITR granularity is in 2 usec increments */
-		rc->target_itr =
+		rc->target_itr = ITR_REG_ALIGN(rc->itr_setting);
-			ITR_TO_REG(ITR_REG_ALIGN(rc->itr_setting));
 	}
 	return 0;
 	return 0;
 }
+/**
+ * ice_print_if_odd_usecs - print message if user tries to set odd [tx|rx]-usecs
+ * @netdev: netdev used for print
+ * @itr_setting: previous user setting
+ * @use_adaptive_coalesce: if adaptive coalesce is enabled or being enabled
+ * @coalesce_usecs: requested value of [tx|rx]-usecs
+ * @c_type_str: either "rx" or "tx" to match user set field of [tx|rx]-usecs
+ */
+static void
+ice_print_if_odd_usecs(struct net_device *netdev, u16 itr_setting,
+		       u32 use_adaptive_coalesce, u32 coalesce_usecs,
+		       const char *c_type_str)
+{
+	if (use_adaptive_coalesce)
+		return;
+	itr_setting = ITR_TO_REG(itr_setting);
+	if (itr_setting != coalesce_usecs && (coalesce_usecs % 2))
+		netdev_info(netdev, "User set %s-usecs to %d, device only supports even values. Rounding down and attempting to set %s-usecs to %d\n",
+			    c_type_str, coalesce_usecs, c_type_str,
+			    ITR_REG_ALIGN(coalesce_usecs));
+}
 /**
  * __ice_set_coalesce - set ITR/INTRL values for the device
  * @netdev: pointer to the netdev associated with this query
 		return -EINVAL;
 	if (q_num < 0) {
+		struct ice_q_vector *q_vector = vsi->q_vectors[0];
 		int v_idx;
+		if (q_vector) {
+			ice_print_if_odd_usecs(netdev, q_vector->rx.itr_setting,
+					       ec->use_adaptive_rx_coalesce,
+					       ec->rx_coalesce_usecs, "rx");
+			ice_print_if_odd_usecs(netdev, q_vector->tx.itr_setting,
+					       ec->use_adaptive_tx_coalesce,
+					       ec->tx_coalesce_usecs, "tx");
+		}
 		ice_for_each_q_vector(vsi, v_idx) {
 			/* In some cases if DCB is configured the num_[rx|tx]q
 			 * can be less than vsi->num_q_vectors. This check

drivers/net/ethernet/intel/ice/ice_txrx.h+1−1

@@ -222,7 +222,7 @@ enum ice_rx_dtype { · 221 unmodified lines
222	#define ICE_ITR_GRAN_S 1 /* ITR granularity is always 2us */	222	#define ICE_ITR_GRAN_S 1 /* ITR granularity is always 2us */
223	#define ICE_ITR_GRAN_US BIT(ICE_ITR_GRAN_S)	223	#define ICE_ITR_GRAN_US BIT(ICE_ITR_GRAN_S)
224	#define ICE_ITR_MASK 0x1FFE /* ITR register value alignment mask */	224	#define ICE_ITR_MASK 0x1FFE /* ITR register value alignment mask */
225	#define ITR_REG_ALIGN(setting) __ALIGN_MASK(setting, ~ICE_ITR_MASK)	225	#define ITR_REG_ALIGN(setting) ((setting) & ICE_ITR_MASK)
226		226
227	#define ICE_ITR_ADAPTIVE_MIN_INC 0x0002	227	#define ICE_ITR_ADAPTIVE_MIN_INC 0x0002
228	#define ICE_ITR_ADAPTIVE_MIN_USECS 0x0002	228	#define ICE_ITR_ADAPTIVE_MIN_USECS 0x0002

drivers/net/ethernet/intel/ice/ice_virtchnl_pf.c+74−60

@@ -1873,6 +1873,48 @@ error_param: · 1872 unmodified lines
1873	NULL, 0);	1873	NULL, 0);
1874	}	1874	}
1875		1875
		1876	/**
		1877	* ice_wait_on_vf_reset - poll to make sure a given VF is ready after reset
		1878	* @vf: The VF being resseting
		1879	*
		1880	* The max poll time is about ~800ms, which is about the maximum time it takes
		1881	* for a VF to be reset and/or a VF driver to be removed.
		1882	*/
		1883	static void ice_wait_on_vf_reset(struct ice_vf *vf)
		1884	{
		1885	int i;
		1886
		1887	for (i = 0; i < ICE_MAX_VF_RESET_TRIES; i++) {
		1888	if (test_bit(ICE_VF_STATE_INIT, vf->vf_states))
		1889	break;
		1890	msleep(ICE_MAX_VF_RESET_SLEEP_MS);
		1891	}
		1892	}
		1893
		1894	/**
		1895	* ice_check_vf_ready_for_cfg - check if VF is ready to be configured/queried
		1896	* @vf: VF to check if it's ready to be configured/queried
		1897	*
		1898	* The purpose of this function is to make sure the VF is not in reset, not
		1899	* disabled, and initialized so it can be configured and/or queried by a host
		1900	* administrator.
		1901	*/
		1902	static int ice_check_vf_ready_for_cfg(struct ice_vf *vf)
		1903	{
		1904	struct ice_pf *pf;
		1905
		1906	ice_wait_on_vf_reset(vf);
		1907
		1908	if (ice_is_vf_disabled(vf))
		1909	return -EINVAL;
		1910
		1911	pf = vf->pf;
		1912	if (ice_check_vf_init(pf, vf))
		1913	return -EBUSY;
		1914
		1915	return 0;
		1916	}
		1917
1876	/**	1918	/**
1877	* ice_set_vf_spoofchk	1919	* ice_set_vf_spoofchk
1878	* @netdev: network interface device structure	1920	* @netdev: network interface device structure
@@ -1890,16 +1932,16 @@ int ice_set_vf_spoofchk(struct net_device *netdev, int vf_id, bool ena) · 11 unmodified lines
1890	enum ice_status status;	1932	enum ice_status status;
1891	struct device *dev;	1933	struct device *dev;
1892	struct ice_vf *vf;	1934	struct ice_vf *vf;
1893	int ret = 0;	1935	int ret;
1894		1936
1895	dev = ice_pf_to_dev(pf);	1937	dev = ice_pf_to_dev(pf);
1896	if (ice_validate_vf_id(pf, vf_id))	1938	if (ice_validate_vf_id(pf, vf_id))
1897	return -EINVAL;	1939	return -EINVAL;
1898		1940
1899	vf = &pf->vf[vf_id];	1941	vf = &pf->vf[vf_id];
1900		1942	ret = ice_check_vf_ready_for_cfg(vf);
1901	if (ice_check_vf_init(pf, vf))	1943	if (ret)
1902	return -EBUSY;	1944	return ret;
1903		1945
1904	vf_vsi = pf->vsi[vf->lan_vsi_idx];	1946	vf_vsi = pf->vsi[vf->lan_vsi_idx];
1905	if (!vf_vsi) {	1947	if (!vf_vsi) {
@@ -2696,7 +2738,7 @@ ice_set_vf_port_vlan(struct net_device *netdev, int vf_id, u16 vlan_id, u8 qos, · 790 unmodified lines
2696	struct ice_vsi *vsi;	2738	struct ice_vsi *vsi;
2697	struct device *dev;	2739	struct device *dev;
2698	struct ice_vf *vf;	2740	struct ice_vf *vf;
2699	int ret = 0;	2741	int ret;
2700		2742
2701	dev = ice_pf_to_dev(pf);	2743	dev = ice_pf_to_dev(pf);
2702	if (ice_validate_vf_id(pf, vf_id))	2744	if (ice_validate_vf_id(pf, vf_id))
@@ -2714,13 +2756,15 @@ ice_set_vf_port_vlan(struct net_device *netdev, int vf_id, u16 vlan_id, u8 qos, · 11 unmodified lines
2714		2756
2715	vf = &pf->vf[vf_id];	2757	vf = &pf->vf[vf_id];
2716	vsi = pf->vsi[vf->lan_vsi_idx];	2758	vsi = pf->vsi[vf->lan_vsi_idx];
2717	if (ice_check_vf_init(pf, vf))	2759
2718	return -EBUSY;	2760	ret = ice_check_vf_ready_for_cfg(vf);
		2761	if (ret)
		2762	return ret;
2719		2763
2720	if (le16_to_cpu(vsi->info.pvid) == vlanprio) {	2764	if (le16_to_cpu(vsi->info.pvid) == vlanprio) {
2721	/* duplicate request, so just return success */	2765	/* duplicate request, so just return success */
2722	dev_dbg(dev, "Duplicate pvid %d request\n", vlanprio);	2766	dev_dbg(dev, "Duplicate pvid %d request\n", vlanprio);
2723	return ret;	2767	return 0;
2724	}	2768	}
2725		2769
2726	/* If PVID, then remove all filters on the old VLAN */	2770	/* If PVID, then remove all filters on the old VLAN */
@@ -2731,7 +2775,7 @@ ice_set_vf_port_vlan(struct net_device *netdev, int vf_id, u16 vlan_id, u8 qos, · 4 unmodified lines
2731	if (vlan_id \|\| qos) {	2775	if (vlan_id \|\| qos) {
2732	ret = ice_vsi_manage_pvid(vsi, vlanprio, true);	2776	ret = ice_vsi_manage_pvid(vsi, vlanprio, true);
2733	if (ret)	2777	if (ret)
2734	goto error_set_pvid;	2778	return ret;
2735	} else {	2779	} else {
2736	ice_vsi_manage_pvid(vsi, 0, false);	2780	ice_vsi_manage_pvid(vsi, 0, false);
2737	vsi->info.pvid = 0;	2781	vsi->info.pvid = 0;
@@ -2744,7 +2788,7 @@ ice_set_vf_port_vlan(struct net_device *netdev, int vf_id, u16 vlan_id, u8 qos, · 6 unmodified lines
2744	/* add new VLAN filter for each MAC */	2788	/* add new VLAN filter for each MAC */
2745	ret = ice_vsi_add_vlan(vsi, vlan_id);	2789	ret = ice_vsi_add_vlan(vsi, vlan_id);
2746	if (ret)	2790	if (ret)
2747	goto error_set_pvid;	2791	return ret;
2748	}	2792	}
2749		2793
2750	/* The Port VLAN needs to be saved across resets the same as the	2794	/* The Port VLAN needs to be saved across resets the same as the
@@ -2752,8 +2796,7 @@ ice_set_vf_port_vlan(struct net_device *netdev, int vf_id, u16 vlan_id, u8 qos, · 1 unmodified line
2752	*/	2796	*/
2753	vf->port_vlan_id = le16_to_cpu(vsi->info.pvid);	2797	vf->port_vlan_id = le16_to_cpu(vsi->info.pvid);
2754		2798
2755	error_set_pvid:	2799	return 0;
2756	return ret;
2757	}	2800	}
2758		2801
2759	/**	2802	/**
@@ -3236,23 +3279,6 @@ ice_get_vf_cfg(struct net_device netdev, int vf_id, struct ifla_vf_info ivi) · 476 unmodified lines
3236	return 0;	3279	return 0;
3237	}	3280	}
3238		3281
3239	/**
3240	* ice_wait_on_vf_reset
3241	* @vf: The VF being resseting
3242	*
3243	* Poll to make sure a given VF is ready after reset
3244	*/
3245	static void ice_wait_on_vf_reset(struct ice_vf *vf)
3246	{
3247	int i;
3248
3249	for (i = 0; i < ICE_MAX_VF_RESET_WAIT; i++) {
3250	if (test_bit(ICE_VF_STATE_INIT, vf->vf_states))
3251	break;
3252	msleep(20);
3253	}
3254	}
3255
3256	/**	3282	/**
3257	* ice_set_vf_mac	3283	* ice_set_vf_mac
3258	* @netdev: network interface device structure	3284	* @netdev: network interface device structure
@@ -3265,29 +3291,21 @@ int ice_set_vf_mac(struct net_device netdev, int vf_id, u8 mac) · 6 unmodified lines
3265	{	3291	{
3266	struct ice_pf *pf = ice_netdev_to_pf(netdev);	3292	struct ice_pf *pf = ice_netdev_to_pf(netdev);
3267	struct ice_vf *vf;	3293	struct ice_vf *vf;
3268	int ret = 0;	3294	int ret;
3269		3295
3270	if (ice_validate_vf_id(pf, vf_id))	3296	if (ice_validate_vf_id(pf, vf_id))
3271	return -EINVAL;	3297	return -EINVAL;
3272		3298
3273	vf = &pf->vf[vf_id];
3274	/* Don't set MAC on disabled VF */
3275	if (ice_is_vf_disabled(vf))
3276	return -EINVAL;
3277
3278	/* In case VF is in reset mode, wait until it is completed. Depending
3279	* on factors like queue disabling routine, this could take ~250ms
3280	*/
3281	ice_wait_on_vf_reset(vf);
3282
3283	if (ice_check_vf_init(pf, vf))
3284	return -EBUSY;
3285
3286	if (is_zero_ether_addr(mac) \|\| is_multicast_ether_addr(mac)) {	3299	if (is_zero_ether_addr(mac) \|\| is_multicast_ether_addr(mac)) {
3287	netdev_err(netdev, "%pM not a valid unicast address\n", mac);	3300	netdev_err(netdev, "%pM not a valid unicast address\n", mac);
3288	return -EINVAL;	3301	return -EINVAL;
3289	}	3302	}
3290		3303
		3304	vf = &pf->vf[vf_id];
		3305	ret = ice_check_vf_ready_for_cfg(vf);
		3306	if (ret)
		3307	return ret;
		3308
3291	/* copy MAC into dflt_lan_addr and trigger a VF reset. The reset	3309	/* copy MAC into dflt_lan_addr and trigger a VF reset. The reset
3292	* flow will use the updated dflt_lan_addr and add a MAC filter	3310	* flow will use the updated dflt_lan_addr and add a MAC filter
3293	* using ice_add_mac. Also set pf_set_mac to indicate that the PF has	3311	* using ice_add_mac. Also set pf_set_mac to indicate that the PF has
@@ -3299,7 +3317,7 @@ int ice_set_vf_mac(struct net_device netdev, int vf_id, u8 mac) · 5 unmodified lines
3299	vf_id, mac);	3317	vf_id, mac);
3300		3318
3301	ice_vc_reset_vf(vf);	3319	ice_vc_reset_vf(vf);
3302	return ret;	3320	return 0;
3303	}	3321	}
3304		3322
3305	/**	3323	/**
@@ -3314,22 +3332,15 @@ int ice_set_vf_trust(struct net_device *netdev, int vf_id, bool trusted) · 8 unmodified lines
3314	{	3332	{
3315	struct ice_pf *pf = ice_netdev_to_pf(netdev);	3333	struct ice_pf *pf = ice_netdev_to_pf(netdev);
3316	struct ice_vf *vf;	3334	struct ice_vf *vf;
		3335	int ret;
3317		3336
3318	if (ice_validate_vf_id(pf, vf_id))	3337	if (ice_validate_vf_id(pf, vf_id))
3319	return -EINVAL;	3338	return -EINVAL;
3320		3339
3321	vf = &pf->vf[vf_id];	3340	vf = &pf->vf[vf_id];
3322	/* Don't set Trusted Mode on disabled VF */	3341	ret = ice_check_vf_ready_for_cfg(vf);
3323	if (ice_is_vf_disabled(vf))	3342	if (ret)
3324	return -EINVAL;	3343	return ret;
3325
3326	/* In case VF is in reset mode, wait until it is completed. Depending
3327	* on factors like queue disabling routine, this could take ~250ms
3328	*/
3329	ice_wait_on_vf_reset(vf);
3330
3331	if (ice_check_vf_init(pf, vf))
3332	return -EBUSY;
3333		3344
3334	/* Check if already trusted */	3345	/* Check if already trusted */
3335	if (trusted == vf->trusted)	3346	if (trusted == vf->trusted)
@@ -3355,13 +3366,15 @@ int ice_set_vf_link_state(struct net_device *netdev, int vf_id, int link_state) · 19 unmodified lines
3355	{	3366	{
3356	struct ice_pf *pf = ice_netdev_to_pf(netdev);	3367	struct ice_pf *pf = ice_netdev_to_pf(netdev);
3357	struct ice_vf *vf;	3368	struct ice_vf *vf;
		3369	int ret;
3358		3370
3359	if (ice_validate_vf_id(pf, vf_id))	3371	if (ice_validate_vf_id(pf, vf_id))
3360	return -EINVAL;	3372	return -EINVAL;
3361		3373
3362	vf = &pf->vf[vf_id];	3374	vf = &pf->vf[vf_id];
3363	if (ice_check_vf_init(pf, vf))	3375	ret = ice_check_vf_ready_for_cfg(vf);
3364	return -EBUSY;	3376	if (ret)
		3377	return ret;
3365		3378
3366	switch (link_state) {	3379	switch (link_state) {
3367	case IFLA_VF_LINK_STATE_AUTO:	3380	case IFLA_VF_LINK_STATE_AUTO:
@@ -3397,14 +3410,15 @@ int ice_get_vf_stats(struct net_device *netdev, int vf_id, · 29 unmodified lines
3397	struct ice_eth_stats *stats;	3410	struct ice_eth_stats *stats;
3398	struct ice_vsi *vsi;	3411	struct ice_vsi *vsi;
3399	struct ice_vf *vf;	3412	struct ice_vf *vf;
		3413	int ret;
3400		3414
3401	if (ice_validate_vf_id(pf, vf_id))	3415	if (ice_validate_vf_id(pf, vf_id))
3402	return -EINVAL;	3416	return -EINVAL;
3403		3417
3404	vf = &pf->vf[vf_id];	3418	vf = &pf->vf[vf_id];
3405		3419	ret = ice_check_vf_ready_for_cfg(vf);
3406	if (ice_check_vf_init(pf, vf))	3420	if (ret)
3407	return -EBUSY;	3421	return ret;
3408		3422
3409	vsi = pf->vsi[vf->lan_vsi_idx];	3423	vsi = pf->vsi[vf->lan_vsi_idx];
3410	if (!vsi)	3424	if (!vsi)

drivers/net/ethernet/intel/ice/ice_virtchnl_pf.h+2−1

@@ -38,7 +38,8 @@ · 37 unmodified lines
38	#define ICE_MAX_POLICY_INTR_PER_VF 33	38	#define ICE_MAX_POLICY_INTR_PER_VF 33
39	#define ICE_MIN_INTR_PER_VF (ICE_MIN_QS_PER_VF + 1)	39	#define ICE_MIN_INTR_PER_VF (ICE_MIN_QS_PER_VF + 1)
40	#define ICE_DFLT_INTR_PER_VF (ICE_DFLT_QS_PER_VF + 1)	40	#define ICE_DFLT_INTR_PER_VF (ICE_DFLT_QS_PER_VF + 1)
41	#define ICE_MAX_VF_RESET_WAIT 15	41	#define ICE_MAX_VF_RESET_TRIES 40
		42	#define ICE_MAX_VF_RESET_SLEEP_MS 20
42		43
43	#define ice_for_each_vf(pf, i) \	44	#define ice_for_each_vf(pf, i) \
44	for ((i) = 0; (i) < (pf)->num_alloc_vfs; (i)++)	45	for ((i) = 0; (i) < (pf)->num_alloc_vfs; (i)++)

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

@@ -200,7 +200,7 @@ int mlx5e_health_report(struct mlx5e_priv *priv, · 199 unmodified lines
200	netdev_err(priv->netdev, err_str);	200	netdev_err(priv->netdev, err_str);
201		201
202	if (!reporter)	202	if (!reporter)
203	return err_ctx->recover(&err_ctx->ctx);	203	return err_ctx->recover(err_ctx->ctx);
204		204
205	return devlink_health_report(reporter, err_str, err_ctx);	205	return devlink_health_report(reporter, err_str, err_ctx);
206	}	206	}

drivers/net/ethernet/mellanox/mlx5/core/en/txrx.h+8−0

@@ -179,6 +179,14 @@ mlx5e_tx_dma_unmap(struct device pdev, struct mlx5e_sq_dma dma) · 178 unmodified lines
179	}	179	}
180	}	180	}
181		181
		182	static inline void mlx5e_rqwq_reset(struct mlx5e_rq *rq)
		183	{
		184	if (rq->wq_type == MLX5_WQ_TYPE_LINKED_LIST_STRIDING_RQ)
		185	mlx5_wq_ll_reset(&rq->mpwqe.wq);
		186	else
		187	mlx5_wq_cyc_reset(&rq->wqe.wq);
		188	}
		189
182	/* SW parser related functions */	190	/* SW parser related functions */
183		191
184	struct mlx5e_swp_spec {	192	struct mlx5e_swp_spec {

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

@@ -712,6 +712,9 @@ int mlx5e_modify_rq_state(struct mlx5e_rq *rq, int curr_state, int next_state) · 711 unmodified lines
712	if (!in)	712	if (!in)
713	return -ENOMEM;	713	return -ENOMEM;
714		714
		715	if (curr_state == MLX5_RQC_STATE_RST && next_state == MLX5_RQC_STATE_RDY)
		716	mlx5e_rqwq_reset(rq);
		717
715	rqc = MLX5_ADDR_OF(modify_rq_in, in, ctx);	718	rqc = MLX5_ADDR_OF(modify_rq_in, in, ctx);
716		719
717	MLX5_SET(modify_rq_in, in, rq_state, curr_state);	720	MLX5_SET(modify_rq_in, in, rq_state, curr_state);

drivers/net/ethernet/mellanox/mlx5/core/eswitch.c+8−12

@@ -459,12 +459,16 @@ static void esw_destroy_legacy_table(struct mlx5_eswitch *esw) · 458 unmodified lines
459		459
460	static int esw_legacy_enable(struct mlx5_eswitch *esw)	460	static int esw_legacy_enable(struct mlx5_eswitch *esw)
461	{	461	{
462	int ret;	462	struct mlx5_vport *vport;
		463	int ret, i;
463		464
464	ret = esw_create_legacy_table(esw);	465	ret = esw_create_legacy_table(esw);
465	if (ret)	466	if (ret)
466	return ret;	467	return ret;
467		468
		469	mlx5_esw_for_each_vf_vport(esw, i, vport, esw->esw_funcs.num_vfs)
		470	vport->info.link_state = MLX5_VPORT_ADMIN_STATE_AUTO;
		471
468	ret = mlx5_eswitch_enable_pf_vf_vports(esw, MLX5_LEGACY_SRIOV_VPORT_EVENTS);	472	ret = mlx5_eswitch_enable_pf_vf_vports(esw, MLX5_LEGACY_SRIOV_VPORT_EVENTS);
469	if (ret)	473	if (ret)
470	esw_destroy_legacy_table(esw);	474	esw_destroy_legacy_table(esw);
@@ -2452,25 +2456,17 @@ out: · 1981 unmodified lines
2452		2456
2453	int mlx5_eswitch_get_vepa(struct mlx5_eswitch esw, u8 setting)	2457	int mlx5_eswitch_get_vepa(struct mlx5_eswitch esw, u8 setting)
2454	{	2458	{
2455	int err = 0;
2456
2457	if (!esw)	2459	if (!esw)
2458	return -EOPNOTSUPP;	2460	return -EOPNOTSUPP;
2459		2461
2460	if (!ESW_ALLOWED(esw))	2462	if (!ESW_ALLOWED(esw))
2461	return -EPERM;	2463	return -EPERM;
2462		2464
2463	mutex_lock(&esw->state_lock);	2465	if (esw->mode != MLX5_ESWITCH_LEGACY)
2464	if (esw->mode != MLX5_ESWITCH_LEGACY) {	2466	return -EOPNOTSUPP;
2465	err = -EOPNOTSUPP;
2466	goto out;
2467	}
2468		2467
2469	*setting = esw->fdb_table.legacy.vepa_uplink_rule ? 1 : 0;	2468	*setting = esw->fdb_table.legacy.vepa_uplink_rule ? 1 : 0;
2470		2469	return 0;
2471	out:
2472	mutex_unlock(&esw->state_lock);
2473	return err;
2474	}	2470	}
2475		2471
2476	int mlx5_eswitch_set_vport_trust(struct mlx5_eswitch *esw,	2472	int mlx5_eswitch_set_vport_trust(struct mlx5_eswitch *esw,

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

@@ -1172,7 +1172,7 @@ static int esw_offloads_start(struct mlx5_eswitch *esw, · 1171 unmodified lines
1172	return -EINVAL;	1172	return -EINVAL;
1173	}	1173	}
1174		1174
1175	mlx5_eswitch_disable(esw, true);	1175	mlx5_eswitch_disable(esw, false);
1176	mlx5_eswitch_update_num_of_vfs(esw, esw->dev->priv.sriov.num_vfs);	1176	mlx5_eswitch_update_num_of_vfs(esw, esw->dev->priv.sriov.num_vfs);
1177	err = mlx5_eswitch_enable(esw, MLX5_ESWITCH_OFFLOADS);	1177	err = mlx5_eswitch_enable(esw, MLX5_ESWITCH_OFFLOADS);
1178	if (err) {	1178	if (err) {
@@ -2065,7 +2065,7 @@ static int esw_offloads_stop(struct mlx5_eswitch *esw, · 886 unmodified lines
2065	{	2065	{
2066	int err, err1;	2066	int err, err1;
2067		2067
2068	mlx5_eswitch_disable(esw, true);	2068	mlx5_eswitch_disable(esw, false);
2069	err = mlx5_eswitch_enable(esw, MLX5_ESWITCH_LEGACY);	2069	err = mlx5_eswitch_enable(esw, MLX5_ESWITCH_LEGACY);
2070	if (err) {	2070	if (err) {
2071	NL_SET_ERR_MSG_MOD(extack, "Failed setting eswitch to legacy");	2071	NL_SET_ERR_MSG_MOD(extack, "Failed setting eswitch to legacy");

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

@@ -35,7 +35,7 @@ · 34 unmodified lines
35	static const unsigned int ESW_POOLS[] = { 4 * 1024 * 1024,	35	static const unsigned int ESW_POOLS[] = { 4 * 1024 * 1024,
36	1 * 1024 * 1024,	36	1 * 1024 * 1024,
37	64 * 1024,	37	64 * 1024,
38	4 * 1024, };	38	128 };
39		39
40	struct mlx5_esw_chains_priv {	40	struct mlx5_esw_chains_priv {
41	struct rhashtable chains_ht;	41	struct rhashtable chains_ht;

drivers/net/ethernet/mellanox/mlx5/core/steering/dr_ste.c+4−1

 	struct mlx5dr_cmd_vport_cap *vport_cap;
 	struct mlx5dr_domain *dmn = sb->dmn;
 	struct mlx5dr_cmd_caps *caps;
+	u8 *bit_mask = sb->bit_mask;
 	u8 *tag = hw_ste->tag;
+	bool source_gvmi_set;
 	DR_STE_SET_TAG(src_gvmi_qp, tag, source_qp, misc, source_sqn);
 	if (!vport_cap)
 		return -EINVAL;
-	if (vport_cap->vport_gvmi)
+	source_gvmi_set = MLX5_GET(ste_src_gvmi_qp, bit_mask, source_gvmi);
+	if (vport_cap->vport_gvmi && source_gvmi_set)
 		MLX5_SET(ste_src_gvmi_qp, tag, source_gvmi, vport_cap->vport_gvmi);
 	misc->source_eswitch_owner_vhca_id = 0;

drivers/net/ethernet/mellanox/mlx5/core/steering/fs_dr.c+7−2

 					 struct mlx5_flow_table *next_ft)
 {
 	struct mlx5dr_table *tbl;
+	u32 flags;
 	int err;
 	if (mlx5_dr_is_fw_table(ft->flags))
 		return mlx5_fs_cmd_get_fw_cmds()->create_flow_table(ns, ft,
 								    log_size,
 								    next_ft);
+	flags = ft->flags;
+	/* turn off encap/decap if not supported for sw-str by fw */
+	if (!MLX5_CAP_FLOWTABLE(ns->dev, sw_owner_reformat_supported))
+		flags = ft->flags & ~(MLX5_FLOW_TABLE_TUNNEL_EN_REFORMAT |
+				      MLX5_FLOW_TABLE_TUNNEL_EN_DECAP);
-	tbl = mlx5dr_table_create(ns->fs_dr_domain.dr_domain,
+	tbl = mlx5dr_table_create(ns->fs_dr_domain.dr_domain, ft->level, flags);
-				  ft->level, ft->flags);
 	if (!tbl) {
 		mlx5_core_err(ns->dev, "Failed creating dr flow_table\n");
 		return -EINVAL;

drivers/net/ethernet/mellanox/mlx5/core/wq.c+30−9

 	print_hex_dump(KERN_WARNING, "", DUMP_PREFIX_OFFSET, 16, 1, wqe, len, false);
 }
+void mlx5_wq_cyc_reset(struct mlx5_wq_cyc *wq)
+{
+	wq->wqe_ctr = 0;
+	wq->cur_sz = 0;
+	mlx5_wq_cyc_update_db_record(wq);
+}
 int mlx5_wq_qp_create(struct mlx5_core_dev *mdev, struct mlx5_wq_param *param,
 		      void *qpc, struct mlx5_wq_qp *wq,
 		      struct mlx5_wq_ctrl *wq_ctrl)
 	return err;
 }
+static void mlx5_wq_ll_init_list(struct mlx5_wq_ll *wq)
+{
+	struct mlx5_wqe_srq_next_seg *next_seg;
+	int i;
+	for (i = 0; i < wq->fbc.sz_m1; i++) {
+		next_seg = mlx5_wq_ll_get_wqe(wq, i);
+		next_seg->next_wqe_index = cpu_to_be16(i + 1);
+	}
+	next_seg = mlx5_wq_ll_get_wqe(wq, i);
+	wq->tail_next = &next_seg->next_wqe_index;
+}
 int mlx5_wq_ll_create(struct mlx5_core_dev *mdev, struct mlx5_wq_param *param,
 		      void *wqc, struct mlx5_wq_ll *wq,
 		      struct mlx5_wq_ctrl *wq_ctrl)
 	u8 log_wq_stride = MLX5_GET(wq, wqc, log_wq_stride);
 	u8 log_wq_sz     = MLX5_GET(wq, wqc, log_wq_sz);
 	struct mlx5_frag_buf_ctrl *fbc = &wq->fbc;
-	struct mlx5_wqe_srq_next_seg *next_seg;
 	int err;
-	int i;
 	err = mlx5_db_alloc_node(mdev, &wq_ctrl->db, param->db_numa_node);
 	if (err) {
 	mlx5_init_fbc(wq_ctrl->buf.frags, log_wq_stride, log_wq_sz, fbc);
-	for (i = 0; i < fbc->sz_m1; i++) {
+	mlx5_wq_ll_init_list(wq);
-		next_seg = mlx5_wq_ll_get_wqe(wq, i);
-		next_seg->next_wqe_index = cpu_to_be16(i + 1);
-	}
-	next_seg = mlx5_wq_ll_get_wqe(wq, i);
-	wq->tail_next = &next_seg->next_wqe_index;
 	wq_ctrl->mdev = mdev;
 	return 0;
 	return err;
 }
+void mlx5_wq_ll_reset(struct mlx5_wq_ll *wq)
+{
+	wq->head = 0;
+	wq->wqe_ctr = 0;
+	wq->cur_sz = 0;
+	mlx5_wq_ll_init_list(wq);
+	mlx5_wq_ll_update_db_record(wq);
+}
 void mlx5_wq_destroy(struct mlx5_wq_ctrl *wq_ctrl)
 {
 	mlx5_frag_buf_free(wq_ctrl->mdev, &wq_ctrl->buf);

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

 		       void *wqc, struct mlx5_wq_cyc *wq,
 		       struct mlx5_wq_ctrl *wq_ctrl);
 void mlx5_wq_cyc_wqe_dump(struct mlx5_wq_cyc *wq, u16 ix, u8 nstrides);
+void mlx5_wq_cyc_reset(struct mlx5_wq_cyc *wq);
 int mlx5_wq_qp_create(struct mlx5_core_dev *mdev, struct mlx5_wq_param *param,
 		      void *qpc, struct mlx5_wq_qp *wq,
 int mlx5_wq_ll_create(struct mlx5_core_dev *mdev, struct mlx5_wq_param *param,
 		      void *wqc, struct mlx5_wq_ll *wq,
 		      struct mlx5_wq_ctrl *wq_ctrl);
+void mlx5_wq_ll_reset(struct mlx5_wq_ll *wq);
 void mlx5_wq_destroy(struct mlx5_wq_ctrl *wq_ctrl);

drivers/net/ethernet/micrel/ks8851_mll.c+9−44

  * chip is busy transferring packet data (RX/TX FIFO accesses).
  */
-/**
- * ks_rdreg8 - read 8 bit register from device
- * @ks	  : The chip information
- * @offset: The register address
- *
- * Read a 8bit register from the chip, returning the result
- */
-static u8 ks_rdreg8(struct ks_net *ks, int offset)
-{
-	u16 data;
-	u8 shift_bit = offset & 0x03;
-	u8 shift_data = (offset & 1) << 3;
-	ks->cmd_reg_cache = (u16) offset | (u16)(BE0 << shift_bit);
-	iowrite16(ks->cmd_reg_cache, ks->hw_addr_cmd);
-	data  = ioread16(ks->hw_addr);
-	return (u8)(data >> shift_data);
-}
 /**
  * ks_rdreg16 - read 16 bit register from device
  * @ks	  : The chip information
 static u16 ks_rdreg16(struct ks_net *ks, int offset)
 {
-	ks->cmd_reg_cache = (u16)offset | ((BE1 | BE0) << (offset & 0x02));
+	ks->cmd_reg_cache = (u16)offset | ((BE3 | BE2) >> (offset & 0x02));
 	iowrite16(ks->cmd_reg_cache, ks->hw_addr_cmd);
 	return ioread16(ks->hw_addr);
 }
-/**
- * ks_wrreg8 - write 8bit register value to chip
- * @ks: The chip information
- * @offset: The register address
- * @value: The value to write
- *
- */
-static void ks_wrreg8(struct ks_net *ks, int offset, u8 value)
-{
-	u8  shift_bit = (offset & 0x03);
-	u16 value_write = (u16)(value << ((offset & 1) << 3));
-	ks->cmd_reg_cache = (u16)offset | (BE0 << shift_bit);
-	iowrite16(ks->cmd_reg_cache, ks->hw_addr_cmd);
-	iowrite16(value_write, ks->hw_addr);
-}
 /**
  * ks_wrreg16 - write 16bit register value to chip
  * @ks: The chip information
 static void ks_wrreg16(struct ks_net *ks, int offset, u16 value)
 {
-	ks->cmd_reg_cache = (u16)offset | ((BE1 | BE0) << (offset & 0x02));
+	ks->cmd_reg_cache = (u16)offset | ((BE3 | BE2) >> (offset & 0x02));
 	iowrite16(ks->cmd_reg_cache, ks->hw_addr_cmd);
 	iowrite16(value, ks->hw_addr);
 }
 {
 	len >>= 1;
 	while (len--)
-		*wptr++ = (u16)ioread16(ks->hw_addr);
+		*wptr++ = be16_to_cpu(ioread16(ks->hw_addr));
 }
 /**
 {
 	len >>= 1;
 	while (len--)
-		iowrite16(*wptr++, ks->hw_addr);
+		iowrite16(cpu_to_be16(*wptr++), ks->hw_addr);
 }
 static void ks_disable_int(struct ks_net *ks)
 	u16 reg_data = 0;
 	/* Regardless of bus width, 8 bit read should always work.*/
-	reg_data = ks_rdreg8(ks, KS_CCR) & 0x00FF;
+	reg_data = ks_rdreg16(ks, KS_CCR);
-	reg_data |= ks_rdreg8(ks, KS_CCR+1) << 8;
 	/* addr/data bus are multiplexed */
 	ks->sharedbus = (reg_data & CCR_SHARED) == CCR_SHARED;
 	/* 1. set sudo DMA mode */
 	ks_wrreg16(ks, KS_RXFDPR, RXFDPR_RXFPAI);
-	ks_wrreg8(ks, KS_RXQCR, (ks->rc_rxqcr | RXQCR_SDA) & 0xff);
+	ks_wrreg16(ks, KS_RXQCR, ks->rc_rxqcr | RXQCR_SDA);
 	/* 2. read prepend data */
 	/**
 	ks_inblk(ks, buf, ALIGN(len, 4));
 	/* 4. reset sudo DMA Mode */
-	ks_wrreg8(ks, KS_RXQCR, ks->rc_rxqcr);
+	ks_wrreg16(ks, KS_RXQCR, ks->rc_rxqcr);
 }
 /**
 	ks->txh.txw[1] = cpu_to_le16(len);
 	/* 1. set sudo-DMA mode */
-	ks_wrreg8(ks, KS_RXQCR, (ks->rc_rxqcr | RXQCR_SDA) & 0xff);
+	ks_wrreg16(ks, KS_RXQCR, ks->rc_rxqcr | RXQCR_SDA);
 	/* 2. write status/lenth info */
 	ks_outblk(ks, ks->txh.txw, 4);
 	/* 3. write pkt data */
 	ks_outblk(ks, (u16 *)pdata, ALIGN(len, 4));
 	/* 4. reset sudo-DMA mode */
-	ks_wrreg8(ks, KS_RXQCR, ks->rc_rxqcr);
+	ks_wrreg16(ks, KS_RXQCR, ks->rc_rxqcr);
 	/* 5. Enqueue Tx(move the pkt from TX buffer into TXQ) */
 	ks_wrreg16(ks, KS_TXQCR, TXQCR_METFE);
 	/* 6. wait until TXQCR_METFE is auto-cleared */

drivers/net/ethernet/mscc/ocelot_board.c+8−0

@@ -114,6 +114,14 @@ static irqreturn_t ocelot_xtr_irq_handler(int irq, void *arg) · 113 unmodified lines
114	if (err != 4)	114	if (err != 4)
115	break;	115	break;
116		116
		117	/* At this point the IFH was read correctly, so it is safe to
		118	* presume that there is no error. The err needs to be reset
		119	* otherwise a frame could come in CPU queue between the while
		120	* condition and the check for error later on. And in that case
		121	* the new frame is just removed and not processed.
		122	*/
		123	err = 0;
		124
117	ocelot_parse_ifh(ifh, &info);	125	ocelot_parse_ifh(ifh, &info);
118		126
119	ocelot_port = ocelot->ports[info.port];	127	ocelot_port = ocelot->ports[info.port];

drivers/net/ethernet/pensando/ionic/ionic_dev.c+7−4

 {
 	struct ionic_dev *idev = &ionic->idev;
 	unsigned long hb_time;
-	u32 fw_status;
+	u8 fw_status;
 	u32 hb;
 	/* wait a little more than one second before testing again */
 	if (time_before(hb_time, (idev->last_hb_time + ionic->watchdog_period)))
 		return 0;
-	/* firmware is useful only if fw_status is non-zero */
+	/* firmware is useful only if the running bit is set and
-	fw_status = ioread32(&idev->dev_info_regs->fw_status);
+	 * fw_status != 0xff (bad PCI read)
-	if (!fw_status)
+	 */
+	fw_status = ioread8(&idev->dev_info_regs->fw_status);
+	if (fw_status == 0xff ||
+	    !(fw_status & IONIC_FW_STS_F_RUNNING))
 		return -ENXIO;
 	/* early FW has no heartbeat, else FW will return non-zero */

drivers/net/ethernet/pensando/ionic/ionic_if.h+1−0

@@ -2445,6 +2445,7 @@ union ionic_dev_info_regs { · 2444 unmodified lines
2445	u8 version;	2445	u8 version;
2446	u8 asic_type;	2446	u8 asic_type;
2447	u8 asic_rev;	2447	u8 asic_rev;
		2448	#define IONIC_FW_STS_F_RUNNING 0x1
2448	u8 fw_status;	2449	u8 fw_status;
2449	u32 fw_heartbeat;	2450	u32 fw_heartbeat;
2450	char fw_version[IONIC_DEVINFO_FWVERS_BUFLEN];	2451	char fw_version[IONIC_DEVINFO_FWVERS_BUFLEN];

drivers/net/ethernet/qlogic/qede/qede.h+2−0

@@ -163,6 +163,8 @@ struct qede_rdma_dev { · 162 unmodified lines
163	struct list_head entry;	163	struct list_head entry;
164	struct list_head rdma_event_list;	164	struct list_head rdma_event_list;
165	struct workqueue_struct *rdma_wq;	165	struct workqueue_struct *rdma_wq;
		166	struct kref refcnt;
		167	struct completion event_comp;
166	bool exp_recovery;	168	bool exp_recovery;
167	};	169	};
168		170

drivers/net/ethernet/qlogic/qede/qede_rdma.c+28−1

 static int qede_rdma_create_wq(struct qede_dev *edev)
 {
 	INIT_LIST_HEAD(&edev->rdma_info.rdma_event_list);
+	kref_init(&edev->rdma_info.refcnt);
+	init_completion(&edev->rdma_info.event_comp);
 	edev->rdma_info.rdma_wq = create_singlethread_workqueue("rdma_wq");
 	if (!edev->rdma_info.rdma_wq) {
 		DP_NOTICE(edev, "qedr: Could not create workqueue\n");
 	}
 }
+static void qede_rdma_complete_event(struct kref *ref)
+{
+	struct qede_rdma_dev *rdma_dev =
+		container_of(ref, struct qede_rdma_dev, refcnt);
+	/* no more events will be added after this */
+	complete(&rdma_dev->event_comp);
+}
 static void qede_rdma_destroy_wq(struct qede_dev *edev)
 {
+	/* Avoid race with add_event flow, make sure it finishes before
+	 * we start accessing the list and cleaning up the work
+	 */
+	kref_put(&edev->rdma_info.refcnt, qede_rdma_complete_event);
+	wait_for_completion(&edev->rdma_info.event_comp);
 	qede_rdma_cleanup_event(edev);
 	destroy_workqueue(edev->rdma_info.rdma_wq);
 }
 	if (!edev->rdma_info.qedr_dev)
 		return;
+	/* We don't want the cleanup flow to start while we're allocating and
+	 * scheduling the work
+	 */
+	if (!kref_get_unless_zero(&edev->rdma_info.refcnt))
+		return; /* already being destroyed */
 	event_node = qede_rdma_get_free_event_node(edev);
 	if (!event_node)
-		return;
+		goto out;
 	event_node->event = event;
 	event_node->ptr = edev;
 	INIT_WORK(&event_node->work, qede_rdma_handle_event);
 	queue_work(edev->rdma_info.rdma_wq, &event_node->work);
+out:
+	kref_put(&edev->rdma_info.refcnt, qede_rdma_complete_event);
 }
 void qede_rdma_dev_event_open(struct qede_dev *edev)

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

@@ -410,7 +410,7 @@ static int bcm5481_config_aneg(struct phy_device *phydev) · 409 unmodified lines
410	struct device_node *np = phydev->mdio.dev.of_node;	410	struct device_node *np = phydev->mdio.dev.of_node;
411	int ret;	411	int ret;
412		412
413	/* Aneg firsly. */	413	/* Aneg firstly. */
414	ret = genphy_config_aneg(phydev);	414	ret = genphy_config_aneg(phydev);
415		415
416	/* Then we can set up the delay. */	416	/* Then we can set up the delay. */
@@ -463,7 +463,7 @@ static int bcm54616s_config_aneg(struct phy_device *phydev) · 46 unmodified lines
463	{	463	{
464	int ret;	464	int ret;
465		465
466	/* Aneg firsly. */	466	/* Aneg firstly. */
467	if (phydev->dev_flags & PHY_BCM_FLAGS_MODE_1000BX)	467	if (phydev->dev_flags & PHY_BCM_FLAGS_MODE_1000BX)
468	ret = genphy_c37_config_aneg(phydev);	468	ret = genphy_c37_config_aneg(phydev);
469	else	469	else

drivers/net/phy/mdio-bcm-iproc.c+20−0

@@ -178,6 +178,23 @@ static int iproc_mdio_remove(struct platform_device *pdev) · 177 unmodified lines
178	return 0;	178	return 0;
179	}	179	}
180		180
		181	#ifdef CONFIG_PM_SLEEP
		182	int iproc_mdio_resume(struct device *dev)
		183	{
		184	struct platform_device *pdev = to_platform_device(dev);
		185	struct iproc_mdio_priv *priv = platform_get_drvdata(pdev);
		186
		187	/* restore the mii clock configuration */
		188	iproc_mdio_config_clk(priv->base);
		189
		190	return 0;
		191	}
		192
		193	static const struct dev_pm_ops iproc_mdio_pm_ops = {
		194	.resume = iproc_mdio_resume
		195	};
		196	#endif /* CONFIG_PM_SLEEP */
		197
181	static const struct of_device_id iproc_mdio_of_match[] = {	198	static const struct of_device_id iproc_mdio_of_match[] = {
182	{ .compatible = "brcm,iproc-mdio", },	199	{ .compatible = "brcm,iproc-mdio", },
183	{ /* sentinel */ },	200	{ /* sentinel */ },
@@ -188,6 +205,9 @@ static struct platform_driver iproc_mdio_driver = { · 4 unmodified lines
188	.driver = {	205	.driver = {
189	.name = "iproc-mdio",	206	.name = "iproc-mdio",
190	.of_match_table = iproc_mdio_of_match,	207	.of_match_table = iproc_mdio_of_match,
		208	#ifdef CONFIG_PM_SLEEP
		209	.pm = &iproc_mdio_pm_ops,
		210	#endif
191	},	211	},
192	.probe = iproc_mdio_probe,	212	.probe = iproc_mdio_probe,
193	.remove = iproc_mdio_remove,	213	.remove = iproc_mdio_remove,

drivers/net/wireguard/device.c+4−3

 	enum { WG_NETDEV_FEATURES = NETIF_F_HW_CSUM | NETIF_F_RXCSUM |
 				    NETIF_F_SG | NETIF_F_GSO |
 				    NETIF_F_GSO_SOFTWARE | NETIF_F_HIGHDMA };
+	const int overhead = MESSAGE_MINIMUM_LENGTH + sizeof(struct udphdr) +
+			     max(sizeof(struct ipv6hdr), sizeof(struct iphdr));
 	dev->netdev_ops = &netdev_ops;
 	dev->hard_header_len = 0;
 	dev->features |= WG_NETDEV_FEATURES;
 	dev->hw_features |= WG_NETDEV_FEATURES;
 	dev->hw_enc_features |= WG_NETDEV_FEATURES;
-	dev->mtu = ETH_DATA_LEN - MESSAGE_MINIMUM_LENGTH -
+	dev->mtu = ETH_DATA_LEN - overhead;
-		   sizeof(struct udphdr) -
+	dev->max_mtu = round_down(INT_MAX, MESSAGE_PADDING_MULTIPLE) - overhead;
-		   max(sizeof(struct ipv6hdr), sizeof(struct iphdr));
 	SET_NETDEV_DEVTYPE(dev, &device_type);

drivers/net/wireguard/receive.c+5−2

 	under_load = skb_queue_len(&wg->incoming_handshakes) >=
 		     MAX_QUEUED_INCOMING_HANDSHAKES / 8;
-	if (under_load)
+	if (under_load) {
 		last_under_load = ktime_get_coarse_boottime_ns();
-	else if (last_under_load)
+	} else if (last_under_load) {
 		under_load = !wg_birthdate_has_expired(last_under_load, 1);
+		if (!under_load)
+			last_under_load = 0;
+	}
 	mac_state = wg_cookie_validate_packet(&wg->cookie_checker, skb,
 					      under_load);
 	if ((under_load && mac_state == VALID_MAC_WITH_COOKIE) ||

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

 static unsigned int calculate_skb_padding(struct sk_buff *skb)
 {
+	unsigned int padded_size, last_unit = skb->len;
+	if (unlikely(!PACKET_CB(skb)->mtu))
+		return ALIGN(last_unit, MESSAGE_PADDING_MULTIPLE) - last_unit;
 	/* We do this modulo business with the MTU, just in case the networking
 	 * layer gives us a packet that's bigger than the MTU. In that case, we
 	 * wouldn't want the final subtraction to overflow in the case of the
-	 * padded_size being clamped.
+	 * padded_size being clamped. Fortunately, that's very rarely the case,
+	 * so we optimize for that not happening.
 	 */
-	unsigned int last_unit = skb->len % PACKET_CB(skb)->mtu;
+	if (unlikely(last_unit > PACKET_CB(skb)->mtu))
-	unsigned int padded_size = ALIGN(last_unit, MESSAGE_PADDING_MULTIPLE);
+		last_unit %= PACKET_CB(skb)->mtu;
-	if (padded_size > PACKET_CB(skb)->mtu)
+	padded_size = min(PACKET_CB(skb)->mtu,
-		padded_size = PACKET_CB(skb)->mtu;
+			  ALIGN(last_unit, MESSAGE_PADDING_MULTIPLE));
 	return padded_size - last_unit;
 }

drivers/net/wireguard/socket.c+0−1

@@ -432,7 +432,6 @@ void wg_socket_reinit(struct wg_device wg, struct sock new4, · 431 unmodified lines
432	wg->incoming_port = ntohs(inet_sk(new4)->inet_sport);	432	wg->incoming_port = ntohs(inet_sk(new4)->inet_sport);
433	mutex_unlock(&wg->socket_update_lock);	433	mutex_unlock(&wg->socket_update_lock);
434	synchronize_rcu();	434	synchronize_rcu();
435	synchronize_net();
436	sock_free(old4);	435	sock_free(old4);
437	sock_free(old6);	436	sock_free(old6);
438	}	437	}

drivers/nfc/pn544/i2c.c+1−0

@@ -225,6 +225,7 @@ static void pn544_hci_i2c_platform_init(struct pn544_i2c_phy *phy) · 224 unmodified lines
225		225
226	out:	226	out:
227	gpiod_set_value_cansleep(phy->gpiod_en, !phy->en_polarity);	227	gpiod_set_value_cansleep(phy->gpiod_en, !phy->en_polarity);
		228	usleep_range(10000, 15000);
228	}	229	}
229		230
230	static void pn544_hci_i2c_enable_mode(struct pn544_i2c_phy *phy, int run_mode)	231	static void pn544_hci_i2c_enable_mode(struct pn544_i2c_phy *phy, int run_mode)

drivers/nfc/pn544/pn544.c+1−1

@@ -682,7 +682,7 @@ static int pn544_hci_tm_send(struct nfc_hci_dev hdev, struct sk_buff skb) · 681 unmodified lines
682	static int pn544_hci_check_presence(struct nfc_hci_dev *hdev,	682	static int pn544_hci_check_presence(struct nfc_hci_dev *hdev,
683	struct nfc_target *target)	683	struct nfc_target *target)
684	{	684	{
685	pr_debug("supported protocol %d\b", target->supported_protocols);	685	pr_debug("supported protocol %d\n", target->supported_protocols);
686	if (target->supported_protocols & (NFC_PROTO_ISO14443_MASK \|	686	if (target->supported_protocols & (NFC_PROTO_ISO14443_MASK \|
687	NFC_PROTO_ISO14443_B_MASK)) {	687	NFC_PROTO_ISO14443_B_MASK)) {
688	return nfc_hci_send_cmd(hdev, target->hci_reader_gate,	688	return nfc_hci_send_cmd(hdev, target->hci_reader_gate,

drivers/s390/net/qeth_core_main.c+1−2

 	}
 	use_rx_sg = (card->options.cq == QETH_CQ_ENABLED) ||
-		    ((skb_len >= card->options.rx_sg_cb) &&
+		    (skb_len > card->options.rx_sg_cb &&
 		     !atomic_read(&card->force_alloc_skb) &&
 		     !IS_OSN(card));
 {
 	int work_done = 0;
-	WARN_ON_ONCE(!budget);
 	*done = false;
 	while (budget) {

drivers/s390/net/qeth_l2_main.c+13−16

 	QETH_CARD_TEXT(card, 2, "vniccsch");
-	/* do not change anything if BridgePort is enabled */
-	if (qeth_bridgeport_is_in_use(card))
-		return -EBUSY;
 	/* check if characteristic and enable/disable are supported */
 	if (!(card->options.vnicc.sup_chars & vnicc) ||
 	    !(card->options.vnicc.set_char_sup & vnicc))
 		return -EOPNOTSUPP;
+	if (qeth_bridgeport_is_in_use(card))
+		return -EBUSY;
 	/* set enable/disable command and store wanted characteristic */
 	if (state) {
 		cmd = IPA_VNICC_ENABLE;
 	QETH_CARD_TEXT(card, 2, "vniccgch");
-	/* do not get anything if BridgePort is enabled */
-	if (qeth_bridgeport_is_in_use(card))
-		return -EBUSY;
 	/* check if characteristic is supported */
 	if (!(card->options.vnicc.sup_chars & vnicc))
 		return -EOPNOTSUPP;
+	if (qeth_bridgeport_is_in_use(card))
+		return -EBUSY;
 	/* if card is ready, query current VNICC state */
 	if (qeth_card_hw_is_reachable(card))
 		rc = qeth_l2_vnicc_query_chars(card);
 	QETH_CARD_TEXT(card, 2, "vniccsto");
-	/* do not change anything if BridgePort is enabled */
-	if (qeth_bridgeport_is_in_use(card))
-		return -EBUSY;
 	/* check if characteristic and set_timeout are supported */
 	if (!(card->options.vnicc.sup_chars & QETH_VNICC_LEARNING) ||
 	    !(card->options.vnicc.getset_timeout_sup & QETH_VNICC_LEARNING))
 		return -EOPNOTSUPP;
+	if (qeth_bridgeport_is_in_use(card))
+		return -EBUSY;
 	/* do we need to do anything? */
 	if (card->options.vnicc.learning_timeout == timeout)
 		return rc;
 	QETH_CARD_TEXT(card, 2, "vniccgto");
-	/* do not get anything if BridgePort is enabled */
-	if (qeth_bridgeport_is_in_use(card))
-		return -EBUSY;
 	/* check if characteristic and get_timeout are supported */
 	if (!(card->options.vnicc.sup_chars & QETH_VNICC_LEARNING) ||
 	    !(card->options.vnicc.getset_timeout_sup & QETH_VNICC_LEARNING))
 		return -EOPNOTSUPP;
+	if (qeth_bridgeport_is_in_use(card))
+		return -EBUSY;
 	/* if card is ready, get timeout. Otherwise, just return stored value */
 	*timeout = card->options.vnicc.learning_timeout;
 	if (qeth_card_hw_is_reachable(card))

include/linux/mlx5/mlx5_ifc.h+4−1

 	u8         nic_rx_multi_path_tirs[0x1];
 	u8         nic_rx_multi_path_tirs_fts[0x1];
 	u8         allow_sniffer_and_nic_rx_shared_tir[0x1];
-	u8	   reserved_at_3[0x1d];
+	u8	   reserved_at_3[0x4];
+	u8	   sw_owner_reformat_supported[0x1];
+	u8	   reserved_at_8[0x18];
 	u8	   encap_general_header[0x1];
 	u8	   reserved_at_21[0xa];
 	u8	   log_max_packet_reformat_context[0x5];

include/linux/netdevice.h+3−4

 #define NET_RX_SUCCESS		0	/* keep 'em coming, baby */
 #define NET_RX_DROP		1	/* packet dropped */
+#define MAX_NEST_DEV 8
 /*
  * Transmit return codes: transmit return codes originate from three different
  * namespaces:
 	     ldev; \
 	     ldev = netdev_lower_get_next(dev, &(iter)))
-struct net_device *netdev_all_lower_get_next(struct net_device *dev,
+struct net_device *netdev_next_lower_dev_rcu(struct net_device *dev,
 					     struct list_head **iter);
-struct net_device *netdev_all_lower_get_next_rcu(struct net_device *dev,
-						 struct list_head **iter);
 int netdev_walk_all_lower_dev(struct net_device *dev,
 			      int (*fn)(struct net_device *lower_dev,
 					void *data),

include/linux/rculist_nulls.h+7−0

@@ -145,6 +145,13 @@ static inline void hlist_nulls_add_tail_rcu(struct hlist_nulls_node *n, · 144 unmodified lines
145	}	145	}
146	}	146	}
147		147
		148	/* after that hlist_nulls_del will work */
		149	static inline void hlist_nulls_add_fake(struct hlist_nulls_node *n)
		150	{
		151	n->pprev = &n->next;
		152	n->next = (struct hlist_nulls_node *)NULLS_MARKER(NULL);
		153	}
		154
148	/**	155	/**
149	* hlist_nulls_for_each_entry_rcu - iterate over rcu list of given type	156	* hlist_nulls_for_each_entry_rcu - iterate over rcu list of given type
150	* @tpos: the type * to use as a loop cursor.	157	* @tpos: the type * to use as a loop cursor.

include/linux/skbuff.h+30−0

  *	@next: Next buffer in list
  *	@prev: Previous buffer in list
  *	@tstamp: Time we arrived/left
+ *	@skb_mstamp_ns: (aka @tstamp) earliest departure time; start point
+ *		for retransmit timer
  *	@rbnode: RB tree node, alternative to next/prev for netem/tcp
+ *	@list: queue head
  *	@sk: Socket we are owned by
+ *	@ip_defrag_offset: (aka @sk) alternate use of @sk, used in
+ *		fragmentation management
  *	@dev: Device we arrived on/are leaving by
+ *	@dev_scratch: (aka @dev) alternate use of @dev when @dev would be %NULL
  *	@cb: Control buffer. Free for use by every layer. Put private vars here
  *	@_skb_refdst: destination entry (with norefcount bit)
  *	@sp: the security path, used for xfrm
  *	@pkt_type: Packet class
  *	@fclone: skbuff clone status
  *	@ipvs_property: skbuff is owned by ipvs
+ *	@inner_protocol_type: whether the inner protocol is
+ *		ENCAP_TYPE_ETHER or ENCAP_TYPE_IPPROTO
+ *	@remcsum_offload: remote checksum offload is enabled
  *	@offload_fwd_mark: Packet was L2-forwarded in hardware
  *	@offload_l3_fwd_mark: Packet was L3-forwarded in hardware
  *	@tc_skip_classify: do not classify packet. set by IFB device
  *	@tc_index: Traffic control index
  *	@hash: the packet hash
  *	@queue_mapping: Queue mapping for multiqueue devices
+ *	@head_frag: skb was allocated from page fragments,
+ *		not allocated by kmalloc() or vmalloc().
  *	@pfmemalloc: skbuff was allocated from PFMEMALLOC reserves
  *	@active_extensions: active extensions (skb_ext_id types)
  *	@ndisc_nodetype: router type (from link layer)
  *	@wifi_acked_valid: wifi_acked was set
  *	@wifi_acked: whether frame was acked on wifi or not
  *	@no_fcs:  Request NIC to treat last 4 bytes as Ethernet FCS
+ *	@encapsulation: indicates the inner headers in the skbuff are valid
+ *	@encap_hdr_csum: software checksum is needed
+ *	@csum_valid: checksum is already valid
  *	@csum_not_inet: use CRC32c to resolve CHECKSUM_PARTIAL
+ *	@csum_complete_sw: checksum was completed by software
+ *	@csum_level: indicates the number of consecutive checksums found in
+ *		the packet minus one that have been verified as
+ *		CHECKSUM_UNNECESSARY (max 3)
  *	@dst_pending_confirm: need to confirm neighbour
  *	@decrypted: Decrypted SKB
  *	@napi_id: id of the NAPI struct this skb came from
+ *	@sender_cpu: (aka @napi_id) source CPU in XPS
  *	@secmark: security marking
  *	@mark: Generic packet mark
+ *	@reserved_tailroom: (aka @mark) number of bytes of free space available
+ *		at the tail of an sk_buff
+ *	@vlan_present: VLAN tag is present
  *	@vlan_proto: vlan encapsulation protocol
  *	@vlan_tci: vlan tag control information
  *	@inner_protocol: Protocol (encapsulation)
+ *	@inner_ipproto: (aka @inner_protocol) stores ipproto when
+ *		skb->inner_protocol_type == ENCAP_TYPE_IPPROTO;
  *	@inner_transport_header: Inner transport layer header (encapsulation)
  *	@inner_network_header: Network layer header (encapsulation)
  *	@inner_mac_header: Link layer header (encapsulation)
 #endif
 #define CLONED_OFFSET()		offsetof(struct sk_buff, __cloned_offset)
+	/* private: */
 	__u8			__cloned_offset[0];
+	/* public: */
 	__u8			cloned:1,
 				nohdr:1,
 				fclone:2,
 #endif
 #define PKT_TYPE_OFFSET()	offsetof(struct sk_buff, __pkt_type_offset)
+	/* private: */
 	__u8			__pkt_type_offset[0];
+	/* public: */
 	__u8			pkt_type:3;
 	__u8			ignore_df:1;
 	__u8			nf_trace:1;
 #define PKT_VLAN_PRESENT_BIT	0
 #endif
 #define PKT_VLAN_PRESENT_OFFSET()	offsetof(struct sk_buff, __pkt_vlan_present_offset)
+	/* private: */
 	__u8			__pkt_vlan_present_offset[0];
+	/* public: */
 	__u8			vlan_present:1;
 	__u8			csum_complete_sw:1;
 	__u8			csum_level:2;

include/net/flow_dissector.h+9−0

 #include <linux/types.h>
 #include <linux/in6.h>
 #include <linux/siphash.h>
+#include <linux/string.h>
 #include <uapi/linux/if_ether.h>
 struct sk_buff;
 	void			*data_end;
 };
+static inline void
+flow_dissector_init_keys(struct flow_dissector_key_control *key_control,
+			 struct flow_dissector_key_basic *key_basic)
+{
+	memset(key_control, 0, sizeof(*key_control));
+	memset(key_basic, 0, sizeof(*key_basic));
+}
 #endif

include/net/sock.h+33−5

  *	struct sock_common - minimal network layer representation of sockets
  *	@skc_daddr: Foreign IPv4 addr
  *	@skc_rcv_saddr: Bound local IPv4 addr
+ *	@skc_addrpair: 8-byte-aligned __u64 union of @skc_daddr & @skc_rcv_saddr
  *	@skc_hash: hash value used with various protocol lookup tables
  *	@skc_u16hashes: two u16 hash values used by UDP lookup tables
  *	@skc_dport: placeholder for inet_dport/tw_dport
  *	@skc_num: placeholder for inet_num/tw_num
+ *	@skc_portpair: __u32 union of @skc_dport & @skc_num
  *	@skc_family: network address family
  *	@skc_state: Connection state
  *	@skc_reuse: %SO_REUSEADDR setting
  *	@skc_reuseport: %SO_REUSEPORT setting
+ *	@skc_ipv6only: socket is IPV6 only
+ *	@skc_net_refcnt: socket is using net ref counting
  *	@skc_bound_dev_if: bound device index if != 0
  *	@skc_bind_node: bind hash linkage for various protocol lookup tables
  *	@skc_portaddr_node: second hash linkage for UDP/UDP-Lite protocol
  *	@skc_prot: protocol handlers inside a network family
  *	@skc_net: reference to the network namespace of this socket
+ *	@skc_v6_daddr: IPV6 destination address
+ *	@skc_v6_rcv_saddr: IPV6 source address
+ *	@skc_cookie: socket's cookie value
  *	@skc_node: main hash linkage for various protocol lookup tables
  *	@skc_nulls_node: main hash linkage for TCP/UDP/UDP-Lite protocol
  *	@skc_tx_queue_mapping: tx queue number for this connection
  *	@skc_flags: place holder for sk_flags
  *		%SO_LINGER (l_onoff), %SO_BROADCAST, %SO_KEEPALIVE,
  *		%SO_OOBINLINE settings, %SO_TIMESTAMPING settings
+ *	@skc_listener: connection request listener socket (aka rsk_listener)
+ *		[union with @skc_flags]
+ *	@skc_tw_dr: (aka tw_dr) ptr to &struct inet_timewait_death_row
+ *		[union with @skc_flags]
  *	@skc_incoming_cpu: record/match cpu processing incoming packets
+ *	@skc_rcv_wnd: (aka rsk_rcv_wnd) TCP receive window size (possibly scaled)
+ *		[union with @skc_incoming_cpu]
+ *	@skc_tw_rcv_nxt: (aka tw_rcv_nxt) TCP window next expected seq number
+ *		[union with @skc_incoming_cpu]
  *	@skc_refcnt: reference count
  *
  *	This is the minimal network layer representation of sockets, the header
   *	@sk_dst_cache: destination cache
   *	@sk_dst_pending_confirm: need to confirm neighbour
   *	@sk_policy: flow policy
+  *	@sk_rx_skb_cache: cache copy of recently accessed RX skb
   *	@sk_receive_queue: incoming packets
   *	@sk_wmem_alloc: transmit queue bytes committed
   *	@sk_tsq_flags: TCP Small Queues flags
   *	@sk_no_check_rx: allow zero checksum in RX packets
   *	@sk_route_caps: route capabilities (e.g. %NETIF_F_TSO)
   *	@sk_route_nocaps: forbidden route capabilities (e.g NETIF_F_GSO_MASK)
+  *	@sk_route_forced_caps: static, forced route capabilities
+  *		(set in tcp_init_sock())
   *	@sk_gso_type: GSO type (e.g. %SKB_GSO_TCPV4)
   *	@sk_gso_max_size: Maximum GSO segment size to build
   *	@sk_gso_max_segs: Maximum number of GSO segments
   *	@sk_frag: cached page frag
   *	@sk_peek_off: current peek_offset value
   *	@sk_send_head: front of stuff to transmit
+  *	@tcp_rtx_queue: TCP re-transmit queue [union with @sk_send_head]
+  *	@sk_tx_skb_cache: cache copy of recently accessed TX skb
   *	@sk_security: used by security modules
   *	@sk_mark: generic packet mark
   *	@sk_cgrp_data: cgroup data for this cgroup
   *	@sk_write_space: callback to indicate there is bf sending space available
   *	@sk_error_report: callback to indicate errors (e.g. %MSG_ERRQUEUE)
   *	@sk_backlog_rcv: callback to process the backlog
+  *	@sk_validate_xmit_skb: ptr to an optional validate function
   *	@sk_destruct: called at sock freeing time, i.e. when all refcnt == 0
   *	@sk_reuseport_cb: reuseport group container
+  *	@sk_bpf_storage: ptr to cache and control for bpf_sk_storage
   *	@sk_rcu: used during RCU grace period
   *	@sk_clockid: clockid used by time-based scheduling (SO_TXTIME)
   *	@sk_txtime_deadline_mode: set deadline mode for SO_TXTIME
+  *	@sk_txtime_report_errors: set report errors mode for SO_TXTIME
   *	@sk_txtime_unused: unused txtime flags
   */
 struct sock {
 	struct sk_filter __rcu	*sk_filter;
 	union {
 		struct socket_wq __rcu	*sk_wq;
+		/* private: */
 		struct socket_wq	*sk_wq_raw;
+		/* public: */
 	};
 #ifdef CONFIG_XFRM
 	struct xfrm_policy __rcu *sk_policy[2];
  * sk_wmem_alloc_get - returns write allocations
  * @sk: socket
  *
- * Returns sk_wmem_alloc minus initial offset of one
+ * Return: sk_wmem_alloc minus initial offset of one
  */
 static inline int sk_wmem_alloc_get(const struct sock *sk)
 {
  * sk_rmem_alloc_get - returns read allocations
  * @sk: socket
  *
- * Returns sk_rmem_alloc
+ * Return: sk_rmem_alloc
  */
 static inline int sk_rmem_alloc_get(const struct sock *sk)
 {
  * sk_has_allocations - check if allocations are outstanding
  * @sk: socket
  *
- * Returns true if socket has write or read allocations
+ * Return: true if socket has write or read allocations
  */
 static inline bool sk_has_allocations(const struct sock *sk)
 {
  * skwq_has_sleeper - check if there are any waiting processes
  * @wq: struct socket_wq
  *
- * Returns true if socket_wq has waiting processes
+ * Return: true if socket_wq has waiting processes
  *
  * The purpose of the skwq_has_sleeper and sock_poll_wait is to wrap the memory
  * barrier call. They were added due to the race found within the tcp code.
  * gfpflags_allow_blocking() isn't enough here as direct reclaim may nest
  * inside other socket operations and end up recursing into sk_page_frag()
  * while it's already in use.
+ *
+ * Return: a per task page_frag if context allows that,
+ * otherwise a per socket one.
  */
 static inline struct page_frag *sk_page_frag(struct sock *sk)
 {
 			   &skb_shinfo(skb)->tskey);
 }
+DECLARE_STATIC_KEY_FALSE(tcp_rx_skb_cache_key);
 /**
  * sk_eat_skb - Release a skb if it is no longer needed
  * @sk: socket to eat this skb from
  * This routine must be called with interrupts disabled or with the socket
  * locked so that the sk_buff queue operation is ok.
 */
-DECLARE_STATIC_KEY_FALSE(tcp_rx_skb_cache_key);
 static inline void sk_eat_skb(struct sock *sk, struct sk_buff *skb)
 {
 	__skb_unlink(skb, &sk->sk_receive_queue);

include/uapi/linux/bpf.h+7−9

  * 		supports redirection to the egress interface, and accepts no
  * 		flag at all.
  *
- * 		The same effect can be attained with the more generic
+ * 		The same effect can also be attained with the more generic
- * 		**bpf_redirect_map**\ (), which requires specific maps to be
+ * 		**bpf_redirect_map**\ (), which uses a BPF map to store the
- * 		used but offers better performance.
+ * 		redirect target instead of providing it directly to the helper.
  * 	Return
  * 		For XDP, the helper returns **XDP_REDIRECT** on success or
  * 		**XDP_ABORTED** on error. For other program types, the values
  * 		the caller. Any higher bits in the *flags* argument must be
  * 		unset.
  *
- * 		When used to redirect packets to net devices, this helper
+ * 		See also bpf_redirect(), which only supports redirecting to an
- * 		provides a high performance increase over **bpf_redirect**\ ().
+ * 		ifindex, but doesn't require a map to do so.
- * 		This is due to various implementation details of the underlying
- * 		mechanisms, one of which is the fact that **bpf_redirect_map**\
- * 		() tries to send packet as a "bulk" to the device.
  * 	Return
- * 		**XDP_REDIRECT** on success, or **XDP_ABORTED** on error.
+ * 		**XDP_REDIRECT** on success, or the value of the two lower bits
+ * 		of the **flags* argument on error.
  *
  * int bpf_sk_redirect_map(struct sk_buff *skb, struct bpf_map *map, u32 key, u64 flags)
  * 	Description

include/uapi/linux/netfilter/nf_conntrack_common.h+11−1

 	IPS_UNTRACKED_BIT = 12,
 	IPS_UNTRACKED = (1 << IPS_UNTRACKED_BIT),
+#ifdef __KERNEL__
+	/* Re-purposed for in-kernel use:
+	 * Tags a conntrack entry that clashed with an existing entry
+	 * on insert.
+	 */
+	IPS_NAT_CLASH_BIT = IPS_UNTRACKED_BIT,
+	IPS_NAT_CLASH = IPS_UNTRACKED,
+#endif
 	/* Conntrack got a helper explicitly attached via CT target. */
 	IPS_HELPER_BIT = 13,
 	IPS_HELPER = (1 << IPS_HELPER_BIT),
 	 */
 	IPS_UNCHANGEABLE_MASK = (IPS_NAT_DONE_MASK | IPS_NAT_MASK |
 				 IPS_EXPECTED | IPS_CONFIRMED | IPS_DYING |
-				 IPS_SEQ_ADJUST | IPS_TEMPLATE | IPS_OFFLOAD),
+				 IPS_SEQ_ADJUST | IPS_TEMPLATE | IPS_UNTRACKED |
+				 IPS_OFFLOAD),
 	__IPS_MAX_BIT = 15,
 };

kernel/bpf/btf.c+3−3

@@ -4142,9 +4142,9 @@ int btf_distill_func_proto(struct bpf_verifier_log *log, · 4141 unmodified lines
4142	* EFAULT - verifier bug	4142	* EFAULT - verifier bug
4143	* 0 - 99% match. The last 1% is validated by the verifier.	4143	* 0 - 99% match. The last 1% is validated by the verifier.
4144	*/	4144	*/
4145	int btf_check_func_type_match(struct bpf_verifier_log *log,	4145	static int btf_check_func_type_match(struct bpf_verifier_log *log,
4146	struct btf btf1, const struct btf_type t1,	4146	struct btf btf1, const struct btf_type t1,
4147	struct btf btf2, const struct btf_type t2)	4147	struct btf btf2, const struct btf_type t2)
4148	{	4148	{
4149	const struct btf_param args1, args2;	4149	const struct btf_param args1, args2;
4150	const char fn1, fn2, s1, s2;	4150	const char fn1, fn2, s1, s2;

kernel/bpf/hashtab.c+53−5

@@ -56,6 +56,7 @@ struct htab_elem { · 55 unmodified lines
56	union {	56	union {
57	struct bpf_htab *htab;	57	struct bpf_htab *htab;
58	struct pcpu_freelist_node fnode;	58	struct pcpu_freelist_node fnode;
		59	struct htab_elem *batch_flink;
59	};	60	};
60	};	61	};
61	};	62	};
@@ -126,6 +127,17 @@ free_elems: · 64 unmodified lines
126	bpf_map_area_free(htab->elems);	127	bpf_map_area_free(htab->elems);
127	}	128	}
128		129
		130	/* The LRU list has a lock (lru_lock). Each htab bucket has a lock
		131	* (bucket_lock). If both locks need to be acquired together, the lock
		132	* order is always lru_lock -> bucket_lock and this only happens in
		133	* bpf_lru_list.c logic. For example, certain code path of
		134	* bpf_lru_pop_free(), which is called by function prealloc_lru_pop(),
		135	* will acquire lru_lock first followed by acquiring bucket_lock.
		136	*
		137	* In hashtab.c, to avoid deadlock, lock acquisition of
		138	* bucket_lock followed by lru_lock is not allowed. In such cases,
		139	* bucket_lock needs to be released first before acquiring lru_lock.
		140	*/
129	static struct htab_elem prealloc_lru_pop(struct bpf_htab htab, void *key,	141	static struct htab_elem prealloc_lru_pop(struct bpf_htab htab, void *key,
130	u32 hash)	142	u32 hash)
131	{	143	{
@@ -1256,10 +1268,12 @@ __htab_map_lookup_and_delete_batch(struct bpf_map *map, · 1124 unmodified lines
1256	void __user *ukeys = u64_to_user_ptr(attr->batch.keys);	1268	void __user *ukeys = u64_to_user_ptr(attr->batch.keys);
1257	void *ubatch = u64_to_user_ptr(attr->batch.in_batch);	1269	void *ubatch = u64_to_user_ptr(attr->batch.in_batch);
1258	u32 batch, max_count, size, bucket_size;	1270	u32 batch, max_count, size, bucket_size;
		1271	struct htab_elem *node_to_free = NULL;
1259	u64 elem_map_flags, map_flags;	1272	u64 elem_map_flags, map_flags;
1260	struct hlist_nulls_head *head;	1273	struct hlist_nulls_head *head;
1261	struct hlist_nulls_node *n;	1274	struct hlist_nulls_node *n;
1262	unsigned long flags;	1275	unsigned long flags = 0;
		1276	bool locked = false;
1263	struct htab_elem *l;	1277	struct htab_elem *l;
1264	struct bucket *b;	1278	struct bucket *b;
1265	int ret = 0;	1279	int ret = 0;
@@ -1319,15 +1333,25 @@ again_nocopy: · 53 unmodified lines
1319	dst_val = values;	1333	dst_val = values;
1320	b = &htab->buckets[batch];	1334	b = &htab->buckets[batch];
1321	head = &b->head;	1335	head = &b->head;
1322	raw_spin_lock_irqsave(&b->lock, flags);	1336	/* do not grab the lock unless need it (bucket_cnt > 0). */
		1337	if (locked)
		1338	raw_spin_lock_irqsave(&b->lock, flags);
1323		1339
1324	bucket_cnt = 0;	1340	bucket_cnt = 0;
1325	hlist_nulls_for_each_entry_rcu(l, n, head, hash_node)	1341	hlist_nulls_for_each_entry_rcu(l, n, head, hash_node)
1326	bucket_cnt++;	1342	bucket_cnt++;
1327		1343
		1344	if (bucket_cnt && !locked) {
		1345	locked = true;
		1346	goto again_nocopy;
		1347	}
		1348
1328	if (bucket_cnt > (max_count - total)) {	1349	if (bucket_cnt > (max_count - total)) {
1329	if (total == 0)	1350	if (total == 0)
1330	ret = -ENOSPC;	1351	ret = -ENOSPC;
		1352	/* Note that since bucket_cnt > 0 here, it is implicit
		1353	* that the locked was grabbed, so release it.
		1354	*/
1331	raw_spin_unlock_irqrestore(&b->lock, flags);	1355	raw_spin_unlock_irqrestore(&b->lock, flags);
1332	rcu_read_unlock();	1356	rcu_read_unlock();
1333	this_cpu_dec(bpf_prog_active);	1357	this_cpu_dec(bpf_prog_active);
@@ -1337,6 +1361,9 @@ again_nocopy: · 3 unmodified lines
1337		1361
1338	if (bucket_cnt > bucket_size) {	1362	if (bucket_cnt > bucket_size) {
1339	bucket_size = bucket_cnt;	1363	bucket_size = bucket_cnt;
		1364	/* Note that since bucket_cnt > 0 here, it is implicit
		1365	* that the locked was grabbed, so release it.
		1366	*/
1340	raw_spin_unlock_irqrestore(&b->lock, flags);	1367	raw_spin_unlock_irqrestore(&b->lock, flags);
1341	rcu_read_unlock();	1368	rcu_read_unlock();
1342	this_cpu_dec(bpf_prog_active);	1369	this_cpu_dec(bpf_prog_active);
@@ -1346,6 +1373,10 @@ again_nocopy: · 3 unmodified lines
1346	goto alloc;	1373	goto alloc;
1347	}	1374	}
1348		1375
		1376	/* Next block is only safe to run if you have grabbed the lock */
		1377	if (!locked)
		1378	goto next_batch;
		1379
1349	hlist_nulls_for_each_entry_safe(l, n, head, hash_node) {	1380	hlist_nulls_for_each_entry_safe(l, n, head, hash_node) {
1350	memcpy(dst_key, l->key, key_size);	1381	memcpy(dst_key, l->key, key_size);
1351		1382
@@ -1370,16 +1401,33 @@ again_nocopy: · 18 unmodified lines
1370	}	1401	}
1371	if (do_delete) {	1402	if (do_delete) {
1372	hlist_nulls_del_rcu(&l->hash_node);	1403	hlist_nulls_del_rcu(&l->hash_node);
1373	if (is_lru_map)	1404
1374	bpf_lru_push_free(&htab->lru, &l->lru_node);	1405	/* bpf_lru_push_free() will acquire lru_lock, which
1375	else	1406	* may cause deadlock. See comments in function
		1407	* prealloc_lru_pop(). Let us do bpf_lru_push_free()
		1408	* after releasing the bucket lock.
		1409	*/
		1410	if (is_lru_map) {
		1411	l->batch_flink = node_to_free;
		1412	node_to_free = l;
		1413	} else {
1376	free_htab_elem(htab, l);	1414	free_htab_elem(htab, l);
		1415	}
1377	}	1416	}
1378	dst_key += key_size;	1417	dst_key += key_size;
1379	dst_val += value_size;	1418	dst_val += value_size;
1380	}	1419	}
1381		1420
1382	raw_spin_unlock_irqrestore(&b->lock, flags);	1421	raw_spin_unlock_irqrestore(&b->lock, flags);
		1422	locked = false;
		1423
		1424	while (node_to_free) {
		1425	l = node_to_free;
		1426	node_to_free = node_to_free->batch_flink;
		1427	bpf_lru_push_free(&htab->lru, &l->lru_node);
		1428	}
		1429
		1430	next_batch:
1383	/* If we are not copying data, we can go to next bucket and avoid	1431	/* If we are not copying data, we can go to next bucket and avoid
1384	* unlocking the rcu.	1432	* unlocking the rcu.
1385	*/	1433	*/

kernel/bpf/offload.c+1−1

@@ -321,7 +321,7 @@ int bpf_prog_offload_info_fill(struct bpf_prog_info *info, · 320 unmodified lines
321		321
322	ulen = info->jited_prog_len;	322	ulen = info->jited_prog_len;
323	info->jited_prog_len = aux->offload->jited_len;	323	info->jited_prog_len = aux->offload->jited_len;
324	if (info->jited_prog_len & ulen) {	324	if (info->jited_prog_len && ulen) {
325	uinsns = u64_to_user_ptr(info->jited_prog_insns);	325	uinsns = u64_to_user_ptr(info->jited_prog_insns);
326	ulen = min_t(u32, info->jited_prog_len, ulen);	326	ulen = min_t(u32, info->jited_prog_len, ulen);
327	if (copy_to_user(uinsns, aux->offload->jited_image, ulen)) {	327	if (copy_to_user(uinsns, aux->offload->jited_image, ulen)) {

net/Kconfig+0−1

@@ -189,7 +189,6 @@ config BRIDGE_NETFILTER · 188 unmodified lines
189	depends on NETFILTER_ADVANCED	189	depends on NETFILTER_ADVANCED
190	select NETFILTER_FAMILY_BRIDGE	190	select NETFILTER_FAMILY_BRIDGE
191	select SKB_EXTENSIONS	191	select SKB_EXTENSIONS
192	default m
193	---help---	192	---help---
194	Enabling this option will let arptables resp. iptables see bridged	193	Enabling this option will let arptables resp. iptables see bridged
195	ARP resp. IP traffic. If you want a bridging firewall, you probably	194	ARP resp. IP traffic. If you want a bridging firewall, you probably

net/bridge/br_stp.c+2−1

@@ -63,7 +63,8 @@ struct net_bridge_port br_get_port(struct net_bridge br, u16 port_no) · 62 unmodified lines
63	{	63	{
64	struct net_bridge_port *p;	64	struct net_bridge_port *p;
65		65
66	list_for_each_entry_rcu(p, &br->port_list, list) {	66	list_for_each_entry_rcu(p, &br->port_list, list,
		67	lockdep_is_held(&br->lock)) {
67	if (p->port_no == port_no)	68	if (p->port_no == port_no)
68	return p;	69	return p;
69	}	70	}

net/core/dev.c+11−23

 #include "net-sysfs.h"
 #define MAX_GRO_SKBS 8
-#define MAX_NEST_DEV 8
 /* This should be increased if a protocol with a bigger head is added. */
 #define GRO_MAX_HEAD (MAX_HEADER + 128)
 	name_node = netdev_name_node_lookup(net, name);
 	if (!name_node)
 		return -ENOENT;
+	/* lookup might have found our primary name or a name belonging
+	 * to another device.
+	 */
+	if (name_node == dev->name_node || name_node->dev != dev)
+		return -EINVAL;
 	__netdev_name_node_alt_destroy(name_node);
 	return 0;
 	qdisc_calculate_pkt_len(skb, q);
 	if (q->flags & TCQ_F_NOLOCK) {
-		if ((q->flags & TCQ_F_CAN_BYPASS) && READ_ONCE(q->empty) &&
+		rc = q->enqueue(skb, q, &to_free) & NET_XMIT_MASK;
-		    qdisc_run_begin(q)) {
+		qdisc_run(q);
-			if (unlikely(test_bit(__QDISC_STATE_DEACTIVATED,
-					      &q->state))) {
-				__qdisc_drop(skb, &to_free);
-				rc = NET_XMIT_DROP;
-				goto end_run;
-			}
-			qdisc_bstats_cpu_update(q, skb);
-			rc = NET_XMIT_SUCCESS;
-			if (sch_direct_xmit(skb, q, dev, txq, NULL, true))
-				__qdisc_run(q);
-end_run:
-			qdisc_run_end(q);
-		} else {
-			rc = q->enqueue(skb, q, &to_free) & NET_XMIT_MASK;
-			qdisc_run(q);
-		}
 		if (unlikely(to_free))
 			kfree_skb_list(to_free);
 	return 0;
 }
-static struct net_device *netdev_next_lower_dev_rcu(struct net_device *dev,
+struct net_device *netdev_next_lower_dev_rcu(struct net_device *dev,
-						    struct list_head **iter)
+					     struct list_head **iter)
 {
 	struct netdev_adjacent *lower;
 	return lower->dev;
 }
+EXPORT_SYMBOL(netdev_next_lower_dev_rcu);
 static u8 __netdev_upper_depth(struct net_device *dev)
 {

net/core/fib_rules.c+1−1

@@ -974,7 +974,7 @@ static int fib_nl_fill_rule(struct sk_buff skb, struct fib_rule rule, · 973 unmodified lines
974		974
975	frh = nlmsg_data(nlh);	975	frh = nlmsg_data(nlh);
976	frh->family = ops->family;	976	frh->family = ops->family;
977	frh->table = rule->table;	977	frh->table = rule->table < 256 ? rule->table : RT_TABLE_COMPAT;
978	if (nla_put_u32(skb, FRA_TABLE, rule->table))	978	if (nla_put_u32(skb, FRA_TABLE, rule->table))
979	goto nla_put_failure;	979	goto nla_put_failure;
980	if (nla_put_u32(skb, FRA_SUPPRESS_PREFIXLEN, rule->suppress_prefixlen))	980	if (nla_put_u32(skb, FRA_SUPPRESS_PREFIXLEN, rule->suppress_prefixlen))

net/core/rtnetlink.c+12−14

 	if (err)
 		return err;
-	alt_ifname = nla_data(attr);
+	alt_ifname = nla_strdup(attr, GFP_KERNEL);
+	if (!alt_ifname)
+		return -ENOMEM;
 	if (cmd == RTM_NEWLINKPROP) {
-		alt_ifname = kstrdup(alt_ifname, GFP_KERNEL);
-		if (!alt_ifname)
-			return -ENOMEM;
 		err = netdev_name_node_alt_create(dev, alt_ifname);
-		if (err) {
+		if (!err)
-			kfree(alt_ifname);
+			alt_ifname = NULL;
-			return err;
-		}
 	} else if (cmd == RTM_DELLINKPROP) {
 		err = netdev_name_node_alt_destroy(dev, alt_ifname);
-		if (err)
-			return err;
 	} else {
-		WARN_ON(1);
+		WARN_ON_ONCE(1);
-		return 0;
+		err = -EINVAL;
 	}
-	*changed = true;
+	kfree(alt_ifname);
-	return 0;
+	if (!err)
+		*changed = true;
+	return err;
 }
 static int rtnl_linkprop(int cmd, struct sk_buff *skb, struct nlmsghdr *nlh,

net/core/skbuff.c+2−4

 		return NULL;
 	}
-	/* use OR instead of assignment to avoid clearing of bits in mask */
 	if (pfmemalloc)
 		skb->pfmemalloc = 1;
 	skb->head_frag = 1;
 		return NULL;
 	}
-	/* use OR instead of assignment to avoid clearing of bits in mask */
 	if (nc->page.pfmemalloc)
 		skb->pfmemalloc = 1;
 	skb->head_frag = 1;
 				      typeof(IPPROTO_IP) proto,
 				      unsigned int off)
 {
-	switch (proto) {
+	int err;
-		int err;
+	switch (proto) {
 	case IPPROTO_TCP:
 		err = skb_maybe_pull_tail(skb, off + sizeof(struct tcphdr),
 					  off + MAX_TCP_HDR_LEN);

net/ethtool/bitset.c+3−0

 				    "mask only allowed in compact bitset");
 		return -EINVAL;
 	}
 	no_mask = tb[ETHTOOL_A_BITSET_NOMASK];
+	if (no_mask)
+		ethnl_bitmap32_clear(bitmap, 0, nbits, mod);
 	nla_for_each_nested(bit_attr, tb[ETHTOOL_A_BITSET_BITS], rem) {
 		bool old_val, new_val;

net/hsr/hsr_framereg.c+2−1

@@ -155,7 +155,8 @@ static struct hsr_node hsr_add_node(struct hsr_priv hsr, · 154 unmodified lines
155	new_node->seq_out[i] = seq_out;	155	new_node->seq_out[i] = seq_out;
156		156
157	spin_lock_bh(&hsr->list_lock);	157	spin_lock_bh(&hsr->list_lock);
158	list_for_each_entry_rcu(node, node_db, mac_list) {	158	list_for_each_entry_rcu(node, node_db, mac_list,
		159	lockdep_is_held(&hsr->list_lock)) {
159	if (ether_addr_equal(node->macaddress_A, addr))	160	if (ether_addr_equal(node->macaddress_A, addr))
160	goto out;	161	goto out;
161	if (ether_addr_equal(node->macaddress_B, addr))	162	if (ether_addr_equal(node->macaddress_B, addr))

net/ipv4/udp.c+5−1

 	inet->inet_dport = 0;
 	sock_rps_reset_rxhash(sk);
 	sk->sk_bound_dev_if = 0;
-	if (!(sk->sk_userlocks & SOCK_BINDADDR_LOCK))
+	if (!(sk->sk_userlocks & SOCK_BINDADDR_LOCK)) {
 		inet_reset_saddr(sk);
+		if (sk->sk_prot->rehash &&
+		    (sk->sk_userlocks & SOCK_BINDPORT_LOCK))
+			sk->sk_prot->rehash(sk);
+	}
 	if (!(sk->sk_userlocks & SOCK_BINDPORT_LOCK)) {
 		sk->sk_prot->unhash(sk);

net/ipv6/ip6_fib.c+4−3

 					found++;
 					break;
 				}
-				if (rt_can_ecmp)
+				fallback_ins = fallback_ins ?: ins;
-					fallback_ins = fallback_ins ?: ins;
 				goto next_iter;
 			}
 	}
 	if (fallback_ins && !found) {
-		/* No ECMP-able route found, replace first non-ECMP one */
+		/* No matching route with same ecmp-able-ness found, replace
+		 * first matching route
+		 */
 		ins = fallback_ins;
 		iter = rcu_dereference_protected(*ins,
 				    lockdep_is_held(&rt->fib6_table->tb6_lock));

net/ipv6/ip6_gre.c+5−3

 		return -ENOENT;
 	switch (type) {
-		struct ipv6_tlv_tnl_enc_lim *tel;
-		__u32 teli;
 	case ICMPV6_DEST_UNREACH:
 		net_dbg_ratelimited("%s: Path to destination invalid or inactive!\n",
 				    t->parms.name);
 			break;
 		}
 		return 0;
-	case ICMPV6_PARAMPROB:
+	case ICMPV6_PARAMPROB: {
+		struct ipv6_tlv_tnl_enc_lim *tel;
+		__u32 teli;
 		teli = 0;
 		if (code == ICMPV6_HDR_FIELD)
 			teli = ip6_tnl_parse_tlv_enc_lim(skb, skb->data);
 					    t->parms.name);
 		}
 		return 0;
+	}
 	case ICMPV6_PKT_TOOBIG:
 		ip6_update_pmtu(skb, net, info, 0, 0, sock_net_uid(net, NULL));
 		return 0;

net/ipv6/ip6_tunnel.c+9−4

 	err = 0;
 	switch (*type) {
-		struct ipv6_tlv_tnl_enc_lim *tel;
-		__u32 mtu, teli;
 	case ICMPV6_DEST_UNREACH:
 		net_dbg_ratelimited("%s: Path to destination invalid or inactive!\n",
 				    t->parms.name);
 			rel_msg = 1;
 		}
 		break;
-	case ICMPV6_PARAMPROB:
+	case ICMPV6_PARAMPROB: {
+		struct ipv6_tlv_tnl_enc_lim *tel;
+		__u32 teli;
 		teli = 0;
 		if ((*code) == ICMPV6_HDR_FIELD)
 			teli = ip6_tnl_parse_tlv_enc_lim(skb, skb->data);
 					    t->parms.name);
 		}
 		break;
-	case ICMPV6_PKT_TOOBIG:
+	}
+	case ICMPV6_PKT_TOOBIG: {
+		__u32 mtu;
 		ip6_update_pmtu(skb, net, htonl(*info), 0, 0,
 				sock_net_uid(net, NULL));
 		mtu = *info - offset;
 			rel_msg = 1;
 		}
 		break;
+	}
 	case NDISC_REDIRECT:
 		ip6_redirect(skb, net, skb->dev->ifindex, 0,
 			     sock_net_uid(net, NULL));

net/ipv6/route.c+1−0

@@ -5198,6 +5198,7 @@ static int ip6_route_multipath_add(struct fib6_config *cfg, · 5197 unmodified lines
5198	*/	5198	*/
5199	cfg->fc_nlinfo.nlh->nlmsg_flags &= ~(NLM_F_EXCL \|	5199	cfg->fc_nlinfo.nlh->nlmsg_flags &= ~(NLM_F_EXCL \|
5200	NLM_F_REPLACE);	5200	NLM_F_REPLACE);
		5201	cfg->fc_nlinfo.nlh->nlmsg_flags \|= NLM_F_CREATE;
5201	nhn++;	5202	nhn++;
5202	}	5203	}
5203		5204

net/mptcp/Kconfig+1−0

@@ -4,6 +4,7 @@ config MPTCP · 3 unmodified lines
4	depends on INET	4	depends on INET
5	select SKB_EXTENSIONS	5	select SKB_EXTENSIONS
6	select CRYPTO_LIB_SHA256	6	select CRYPTO_LIB_SHA256
		7	select CRYPTO
7	help	8	help
8	Multipath TCP (MPTCP) connections send and receive data over multiple	9	Multipath TCP (MPTCP) connections send and receive data over multiple
9	subflows in order to utilize multiple network paths. Each subflow	10	subflows in order to utilize multiple network paths. Each subflow

net/mptcp/protocol.c+19−29

 			    char __user *optval, unsigned int optlen)
 {
 	struct mptcp_sock *msk = mptcp_sk(sk);
-	int ret = -EOPNOTSUPP;
 	struct socket *ssock;
-	struct sock *ssk;
 	pr_debug("msk=%p", msk);
 	/* @@ the meaning of setsockopt() when the socket is connected and
-	 * there are multiple subflows is not defined.
+	 * there are multiple subflows is not yet defined. It is up to the
+	 * MPTCP-level socket to configure the subflows until the subflow
+	 * is in TCP fallback, when TCP socket options are passed through
+	 * to the one remaining subflow.
 	 */
 	lock_sock(sk);
-	ssock = __mptcp_socket_create(msk, MPTCP_SAME_STATE);
+	ssock = __mptcp_tcp_fallback(msk);
-	if (IS_ERR(ssock)) {
+	if (ssock)
-		release_sock(sk);
+		return tcp_setsockopt(ssock->sk, level, optname, optval,
-		return ret;
+				      optlen);
-	}
-	ssk = ssock->sk;
-	sock_hold(ssk);
 	release_sock(sk);
-	ret = tcp_setsockopt(ssk, level, optname, optval, optlen);
+	return -EOPNOTSUPP;
-	sock_put(ssk);
-	return ret;
 }
 static int mptcp_getsockopt(struct sock *sk, int level, int optname,
 			    char __user *optval, int __user *option)
 {
 	struct mptcp_sock *msk = mptcp_sk(sk);
-	int ret = -EOPNOTSUPP;
 	struct socket *ssock;
-	struct sock *ssk;
 	pr_debug("msk=%p", msk);
-	/* @@ the meaning of getsockopt() when the socket is connected and
+	/* @@ the meaning of setsockopt() when the socket is connected and
-	 * there are multiple subflows is not defined.
+	 * there are multiple subflows is not yet defined. It is up to the
+	 * MPTCP-level socket to configure the subflows until the subflow
+	 * is in TCP fallback, when socket options are passed through
+	 * to the one remaining subflow.
 	 */
 	lock_sock(sk);
-	ssock = __mptcp_socket_create(msk, MPTCP_SAME_STATE);
+	ssock = __mptcp_tcp_fallback(msk);
-	if (IS_ERR(ssock)) {
+	if (ssock)
-		release_sock(sk);
+		return tcp_getsockopt(ssock->sk, level, optname, optval,
-		return ret;
+				      option);
-	}
-	ssk = ssock->sk;
-	sock_hold(ssk);
 	release_sock(sk);
-	ret = tcp_getsockopt(ssk, level, optname, optval, option);
+	return -EOPNOTSUPP;
-	sock_put(ssk);
-	return ret;
 }
 static int mptcp_get_port(struct sock *sk, unsigned short snum)

net/mptcp/protocol.h+2−2

@@ -56,8 +56,8 @@ · 55 unmodified lines
56	#define MPTCP_DSS_FLAG_MASK (0x1F)	56	#define MPTCP_DSS_FLAG_MASK (0x1F)
57		57
58	/* MPTCP socket flags */	58	/* MPTCP socket flags */
59	#define MPTCP_DATA_READY BIT(0)	59	#define MPTCP_DATA_READY 0
60	#define MPTCP_SEND_SPACE BIT(1)	60	#define MPTCP_SEND_SPACE 1
61		61
62	/* MPTCP connection sock */	62	/* MPTCP connection sock */
63	struct mptcp_sock {	63	struct mptcp_sock {

net/netfilter/nf_conntrack_core.c+164−28

@@ -894,32 +894,175 @@ static void nf_ct_acct_merge(struct nf_conn *ct, enum ip_conntrack_info ctinfo, · 893 unmodified lines
894	}	894	}
895	}	895	}
896		896
897	/* Resolve race on insertion if this protocol allows this. */	897	static void __nf_conntrack_insert_prepare(struct nf_conn *ct)
		898	{
		899	struct nf_conn_tstamp *tstamp;
		900
		901	atomic_inc(&ct->ct_general.use);
		902	ct->status \|= IPS_CONFIRMED;
		903
		904	/* set conntrack timestamp, if enabled. */
		905	tstamp = nf_conn_tstamp_find(ct);
		906	if (tstamp)
		907	tstamp->start = ktime_get_real_ns();
		908	}
		909
		910	static int __nf_ct_resolve_clash(struct sk_buff *skb,
		911	struct nf_conntrack_tuple_hash *h)
		912	{
		913	/* This is the conntrack entry already in hashes that won race. */
		914	struct nf_conn *ct = nf_ct_tuplehash_to_ctrack(h);
		915	enum ip_conntrack_info ctinfo;
		916	struct nf_conn *loser_ct;
		917
		918	loser_ct = nf_ct_get(skb, &ctinfo);
		919
		920	if (nf_ct_is_dying(ct))
		921	return NF_DROP;
		922
		923	if (!atomic_inc_not_zero(&ct->ct_general.use))
		924	return NF_DROP;
		925
		926	if (((ct->status & IPS_NAT_DONE_MASK) == 0) \|\|
		927	nf_ct_match(ct, loser_ct)) {
		928	struct net *net = nf_ct_net(ct);
		929
		930	nf_ct_acct_merge(ct, ctinfo, loser_ct);
		931	nf_ct_add_to_dying_list(loser_ct);
		932	nf_conntrack_put(&loser_ct->ct_general);
		933	nf_ct_set(skb, ct, ctinfo);
		934
		935	NF_CT_STAT_INC(net, insert_failed);
		936	return NF_ACCEPT;
		937	}
		938
		939	nf_ct_put(ct);
		940	return NF_DROP;
		941	}
		942
		943	/**
		944	* nf_ct_resolve_clash_harder - attempt to insert clashing conntrack entry
		945	*
		946	* @skb: skb that causes the collision
		947	* @repl_idx: hash slot for reply direction
		948	*
		949	* Called when origin or reply direction had a clash.
		950	* The skb can be handled without packet drop provided the reply direction
		951	* is unique or there the existing entry has the identical tuple in both
		952	* directions.
		953	*
		954	* Caller must hold conntrack table locks to prevent concurrent updates.
		955	*
		956	* Returns NF_DROP if the clash could not be handled.
		957	*/
		958	static int nf_ct_resolve_clash_harder(struct sk_buff *skb, u32 repl_idx)
		959	{
		960	struct nf_conn loser_ct = (struct nf_conn )skb_nfct(skb);
		961	const struct nf_conntrack_zone *zone;
		962	struct nf_conntrack_tuple_hash *h;
		963	struct hlist_nulls_node *n;
		964	struct net *net;
		965
		966	zone = nf_ct_zone(loser_ct);
		967	net = nf_ct_net(loser_ct);
		968
		969	/* Reply direction must never result in a clash, unless both origin
		970	* and reply tuples are identical.
		971	*/
		972	hlist_nulls_for_each_entry(h, n, &nf_conntrack_hash[repl_idx], hnnode) {
		973	if (nf_ct_key_equal(h,
		974	&loser_ct->tuplehash[IP_CT_DIR_REPLY].tuple,
		975	zone, net))
		976	return __nf_ct_resolve_clash(skb, h);
		977	}
		978
		979	/* We want the clashing entry to go away real soon: 1 second timeout. */
		980	loser_ct->timeout = nfct_time_stamp + HZ;
		981
		982	/* IPS_NAT_CLASH removes the entry automatically on the first
		983	* reply. Also prevents UDP tracker from moving the entry to
		984	* ASSURED state, i.e. the entry can always be evicted under
		985	* pressure.
		986	*/
		987	loser_ct->status \|= IPS_FIXED_TIMEOUT \| IPS_NAT_CLASH;
		988
		989	__nf_conntrack_insert_prepare(loser_ct);
		990
		991	/* fake add for ORIGINAL dir: we want lookups to only find the entry
		992	* already in the table. This also hides the clashing entry from
		993	* ctnetlink iteration, i.e. conntrack -L won't show them.
		994	*/
		995	hlist_nulls_add_fake(&loser_ct->tuplehash[IP_CT_DIR_ORIGINAL].hnnode);
		996
		997	hlist_nulls_add_head_rcu(&loser_ct->tuplehash[IP_CT_DIR_REPLY].hnnode,
		998	&nf_conntrack_hash[repl_idx]);
		999	return NF_ACCEPT;
		1000	}
		1001
		1002	/**
		1003	* nf_ct_resolve_clash - attempt to handle clash without packet drop
		1004	*
		1005	* @skb: skb that causes the clash
		1006	* @h: tuplehash of the clashing entry already in table
		1007	* @hash_reply: hash slot for reply direction
		1008	*
		1009	* A conntrack entry can be inserted to the connection tracking table
		1010	* if there is no existing entry with an identical tuple.
		1011	*
		1012	* If there is one, @skb (and the assocated, unconfirmed conntrack) has
		1013	* to be dropped. In case @skb is retransmitted, next conntrack lookup
		1014	* will find the already-existing entry.
		1015	*
		1016	* The major problem with such packet drop is the extra delay added by
		1017	* the packet loss -- it will take some time for a retransmit to occur
		1018	* (or the sender to time out when waiting for a reply).
		1019	*
		1020	* This function attempts to handle the situation without packet drop.
		1021	*
		1022	* If @skb has no NAT transformation or if the colliding entries are
		1023	* exactly the same, only the to-be-confirmed conntrack entry is discarded
		1024	* and @skb is associated with the conntrack entry already in the table.
		1025	*
		1026	* Failing that, the new, unconfirmed conntrack is still added to the table
		1027	* provided that the collision only occurs in the ORIGINAL direction.
		1028	* The new entry will be added after the existing one in the hash list,
		1029	* so packets in the ORIGINAL direction will continue to match the existing
		1030	* entry. The new entry will also have a fixed timeout so it expires --
		1031	* due to the collision, it will not see bidirectional traffic.
		1032	*
		1033	* Returns NF_DROP if the clash could not be resolved.
		1034	*/
898	static __cold noinline int	1035	static __cold noinline int
899	nf_ct_resolve_clash(struct net net, struct sk_buff skb,	1036	nf_ct_resolve_clash(struct sk_buff skb, struct nf_conntrack_tuple_hash h,
900	enum ip_conntrack_info ctinfo,	1037	u32 reply_hash)
901	struct nf_conntrack_tuple_hash *h)
902	{	1038	{
903	/* This is the conntrack entry already in hashes that won race. */	1039	/* This is the conntrack entry already in hashes that won race. */
904	struct nf_conn *ct = nf_ct_tuplehash_to_ctrack(h);	1040	struct nf_conn *ct = nf_ct_tuplehash_to_ctrack(h);
905	const struct nf_conntrack_l4proto *l4proto;	1041	const struct nf_conntrack_l4proto *l4proto;
906	enum ip_conntrack_info oldinfo;	1042	enum ip_conntrack_info ctinfo;
907	struct nf_conn *loser_ct = nf_ct_get(skb, &oldinfo);	1043	struct nf_conn *loser_ct;
		1044	struct net *net;
		1045	int ret;
		1046
		1047	loser_ct = nf_ct_get(skb, &ctinfo);
		1048	net = nf_ct_net(loser_ct);
908		1049
909	l4proto = nf_ct_l4proto_find(nf_ct_protonum(ct));	1050	l4proto = nf_ct_l4proto_find(nf_ct_protonum(ct));
910	if (l4proto->allow_clash &&	1051	if (!l4proto->allow_clash)
911	!nf_ct_is_dying(ct) &&	1052	goto drop;
912	atomic_inc_not_zero(&ct->ct_general.use)) {	1053
913	if (((ct->status & IPS_NAT_DONE_MASK) == 0) \|\|	1054	ret = __nf_ct_resolve_clash(skb, h);
914	nf_ct_match(ct, loser_ct)) {	1055	if (ret == NF_ACCEPT)
915	nf_ct_acct_merge(ct, ctinfo, loser_ct);	1056	return ret;
916	nf_conntrack_put(&loser_ct->ct_general);	1057
917	nf_ct_set(skb, ct, oldinfo);	1058	ret = nf_ct_resolve_clash_harder(skb, reply_hash);
918	return NF_ACCEPT;	1059	if (ret == NF_ACCEPT)
919	}	1060	return ret;
920	nf_ct_put(ct);	1061
921	}	1062	drop:
		1063	nf_ct_add_to_dying_list(loser_ct);
922	NF_CT_STAT_INC(net, drop);	1064	NF_CT_STAT_INC(net, drop);
		1065	NF_CT_STAT_INC(net, insert_failed);
923	return NF_DROP;	1066	return NF_DROP;
924	}	1067	}
925		1068
@@ -932,7 +1075,6 @@ __nf_conntrack_confirm(struct sk_buff *skb) · 6 unmodified lines
932	struct nf_conntrack_tuple_hash *h;	1075	struct nf_conntrack_tuple_hash *h;
933	struct nf_conn *ct;	1076	struct nf_conn *ct;
934	struct nf_conn_help *help;	1077	struct nf_conn_help *help;
935	struct nf_conn_tstamp *tstamp;
936	struct hlist_nulls_node *n;	1078	struct hlist_nulls_node *n;
937	enum ip_conntrack_info ctinfo;	1079	enum ip_conntrack_info ctinfo;
938	struct net *net;	1080	struct net *net;
@@ -989,6 +1131,7 @@ __nf_conntrack_confirm(struct sk_buff *skb) · 50 unmodified lines
989		1131
990	if (unlikely(nf_ct_is_dying(ct))) {	1132	if (unlikely(nf_ct_is_dying(ct))) {
991	nf_ct_add_to_dying_list(ct);	1133	nf_ct_add_to_dying_list(ct);
		1134	NF_CT_STAT_INC(net, insert_failed);
992	goto dying;	1135	goto dying;
993	}	1136	}
994		1137
@@ -1009,13 +1152,8 @@ __nf_conntrack_confirm(struct sk_buff *skb) · 14 unmodified lines
1009	setting time, otherwise we'd get timer wrap in	1152	setting time, otherwise we'd get timer wrap in
1010	weird delay cases. */	1153	weird delay cases. */
1011	ct->timeout += nfct_time_stamp;	1154	ct->timeout += nfct_time_stamp;
1012	atomic_inc(&ct->ct_general.use);
1013	ct->status \|= IPS_CONFIRMED;
1014		1155
1015	/* set conntrack timestamp, if enabled. */	1156	__nf_conntrack_insert_prepare(ct);
1016	tstamp = nf_conn_tstamp_find(ct);
1017	if (tstamp)
1018	tstamp->start = ktime_get_real_ns();
1019		1157
1020	/* Since the lookup is lockless, hash insertion must be done after	1158	/* Since the lookup is lockless, hash insertion must be done after
1021	* starting the timer and setting the CONFIRMED bit. The RCU barriers	1159	* starting the timer and setting the CONFIRMED bit. The RCU barriers
@@ -1035,11 +1173,9 @@ __nf_conntrack_confirm(struct sk_buff *skb) · 13 unmodified lines
1035	return NF_ACCEPT;	1173	return NF_ACCEPT;
1036		1174
1037	out:	1175	out:
1038	nf_ct_add_to_dying_list(ct);	1176	ret = nf_ct_resolve_clash(skb, h, reply_hash);
1039	ret = nf_ct_resolve_clash(net, skb, ctinfo, h);
1040	dying:	1177	dying:
1041	nf_conntrack_double_unlock(hash, reply_hash);	1178	nf_conntrack_double_unlock(hash, reply_hash);
1042	NF_CT_STAT_INC(net, insert_failed);
1043	local_bh_enable();	1179	local_bh_enable();
1044	return ret;	1180	return ret;
1045	}	1181	}

net/netfilter/nf_conntrack_proto_udp.c+16−4

 	return false;
 }
+static void nf_conntrack_udp_refresh_unreplied(struct nf_conn *ct,
+					       struct sk_buff *skb,
+					       enum ip_conntrack_info ctinfo,
+					       u32 extra_jiffies)
+{
+	if (unlikely(ctinfo == IP_CT_ESTABLISHED_REPLY &&
+		     ct->status & IPS_NAT_CLASH))
+		nf_ct_kill(ct);
+	else
+		nf_ct_refresh_acct(ct, ctinfo, skb, extra_jiffies);
+}
 /* Returns verdict for packet, and may modify conntracktype */
 int nf_conntrack_udp_packet(struct nf_conn *ct,
 			    struct sk_buff *skb,
 		if (!test_and_set_bit(IPS_ASSURED_BIT, &ct->status))
 			nf_conntrack_event_cache(IPCT_ASSURED, ct);
 	} else {
-		nf_ct_refresh_acct(ct, ctinfo, skb,
+		nf_conntrack_udp_refresh_unreplied(ct, skb, ctinfo,
-				   timeouts[UDP_CT_UNREPLIED]);
+						   timeouts[UDP_CT_UNREPLIED]);
 	}
 	return NF_ACCEPT;
 }
 		if (!test_and_set_bit(IPS_ASSURED_BIT, &ct->status))
 			nf_conntrack_event_cache(IPCT_ASSURED, ct);
 	} else {
-		nf_ct_refresh_acct(ct, ctinfo, skb,
+		nf_conntrack_udp_refresh_unreplied(ct, skb, ctinfo,
-				   timeouts[UDP_CT_UNREPLIED]);
+						   timeouts[UDP_CT_UNREPLIED]);
 	}
 	return NF_ACCEPT;
 }

net/netfilter/nf_flow_table_offload.c+3−3

 {
 	int err;
-	if (!nf_flowtable_hw_offload(flowtable))
-		return 0;
 	if (!dev->netdev_ops->ndo_setup_tc)
 		return -EOPNOTSUPP;
 	struct flow_block_offload bo;
 	int err;
+	if (!nf_flowtable_hw_offload(flowtable))
+		return 0;
 	err = nf_flow_table_offload_cmd(&bo, flowtable, dev, cmd, &extack);
 	if (err < 0)
 		return err;

net/netfilter/nft_set_pipapo.c+3−3

@@ -203,7 +203,7 @@ · 202 unmodified lines
203	* ::	203	* ::
204	*	204	*
205	* rule indices in last field: 0 1	205	* rule indices in last field: 0 1
206	* map to elements: 0x42 0x66	206	* map to elements: 0x66 0x42
207	*	207	*
208	*	208	*
209	* Matching	209	* Matching
@@ -298,7 +298,7 @@ · 88 unmodified lines
298	* ::	298	* ::
299	*	299	*
300	* rule indices in last field: 0 1	300	* rule indices in last field: 0 1
301	* map to elements: 0x42 0x66	301	* map to elements: 0x66 0x42
302	*	302	*
303	* the matching element is at 0x42.	303	* the matching element is at 0x42.
304	*	304	*
@@ -503,7 +503,7 @@ static int pipapo_refill(unsigned long *map, int len, int rules, · 198 unmodified lines
503	return -1;	503	return -1;
504	}	504	}
505		505
506	if (unlikely(match_only)) {	506	if (match_only) {
507	bitmap_clear(map, i, 1);	507	bitmap_clear(map, i, 1);
508	return i;	508	return i;
509	}	509	}

net/netfilter/xt_hashlimit.c+16−6

 #include <linux/netfilter_ipv6/ip6_tables.h>
 #include <linux/mutex.h>
 #include <linux/kernel.h>
+#include <linux/refcount.h>
 #include <uapi/linux/netfilter/xt_hashlimit.h>
 #define XT_HASHLIMIT_ALL (XT_HASHLIMIT_HASH_DIP | XT_HASHLIMIT_HASH_DPT | \
 struct xt_hashlimit_htable {
 	struct hlist_node node;		/* global list of all htables */
-	int use;
+	refcount_t use;
 	u_int8_t family;
 	bool rnd_initialized;
 	for (i = 0; i < hinfo->cfg.size; i++)
 		INIT_HLIST_HEAD(&hinfo->hash[i]);
-	hinfo->use = 1;
+	refcount_set(&hinfo->use, 1);
 	hinfo->count = 0;
 	hinfo->family = family;
 	hinfo->rnd_initialized = false;
 	hlist_for_each_entry(hinfo, &hashlimit_net->htables, node) {
 		if (!strcmp(name, hinfo->name) &&
 		    hinfo->family == family) {
-			hinfo->use++;
+			refcount_inc(&hinfo->use);
 			return hinfo;
 		}
 	}
 static void htable_put(struct xt_hashlimit_htable *hinfo)
 {
-	mutex_lock(&hashlimit_mutex);
+	if (refcount_dec_and_mutex_lock(&hinfo->use, &hashlimit_mutex)) {
-	if (--hinfo->use == 0) {
 		hlist_del(&hinfo->node);
+		mutex_unlock(&hashlimit_mutex);
 		htable_destroy(hinfo);
 	}
-	mutex_unlock(&hashlimit_mutex);
 }
 /* The algorithm used is the Simple Token Bucket Filter (TBF)
 	return hashlimit_mt_common(skb, par, hinfo, &info->cfg, 3);
 }
+#define HASHLIMIT_MAX_SIZE 1048576
 static int hashlimit_mt_check_common(const struct xt_mtchk_param *par,
 				     struct xt_hashlimit_htable **hinfo,
 				     struct hashlimit_cfg3 *cfg,
 	if (cfg->gc_interval == 0 || cfg->expire == 0)
 		return -EINVAL;
+	if (cfg->size > HASHLIMIT_MAX_SIZE) {
+		cfg->size = HASHLIMIT_MAX_SIZE;
+		pr_info_ratelimited("size too large, truncated to %u\n", cfg->size);
+	}
+	if (cfg->max > HASHLIMIT_MAX_SIZE) {
+		cfg->max = HASHLIMIT_MAX_SIZE;
+		pr_info_ratelimited("max too large, truncated to %u\n", cfg->max);
+	}
 	if (par->family == NFPROTO_IPV4) {
 		if (cfg->srcmask > 32 || cfg->dstmask > 32)
 			return -EINVAL;

net/netlabel/netlabel_domainhash.c+2−1

 	if (domain != NULL) {
 		bkt = netlbl_domhsh_hash(domain);
 		bkt_list = &netlbl_domhsh_rcu_deref(netlbl_domhsh)->tbl[bkt];
-		list_for_each_entry_rcu(iter, bkt_list, list)
+		list_for_each_entry_rcu(iter, bkt_list, list,
+					lockdep_is_held(&netlbl_domhsh_lock))
 			if (iter->valid &&
 			    netlbl_family_match(iter->family, family) &&
 			    strcmp(iter->domain, domain) == 0)

net/netlabel/netlabel_unlabeled.c+2−1

@@ -207,7 +207,8 @@ static struct netlbl_unlhsh_iface *netlbl_unlhsh_search_iface(int ifindex) · 206 unmodified lines
207		207
208	bkt = netlbl_unlhsh_hash(ifindex);	208	bkt = netlbl_unlhsh_hash(ifindex);
209	bkt_list = &netlbl_unlhsh_rcu_deref(netlbl_unlhsh)->tbl[bkt];	209	bkt_list = &netlbl_unlhsh_rcu_deref(netlbl_unlhsh)->tbl[bkt];
210	list_for_each_entry_rcu(iter, bkt_list, list)	210	list_for_each_entry_rcu(iter, bkt_list, list,
		211	lockdep_is_held(&netlbl_unlhsh_lock))
211	if (iter->valid && iter->ifindex == ifindex)	212	if (iter->valid && iter->ifindex == ifindex)
212	return iter;	213	return iter;
213		214

net/netlink/af_netlink.c+3−2

 	if (nlk->netlink_bind && groups) {
 		int group;
-		for (group = 0; group < nlk->ngroups; group++) {
+		/* nl_groups is a u32, so cap the maximum groups we can bind */
+		for (group = 0; group < BITS_PER_TYPE(u32); group++) {
 			if (!test_bit(group, &groups))
 				continue;
 			err = nlk->netlink_bind(net, group + 1);
 			netlink_insert(sk, nladdr->nl_pid) :
 			netlink_autobind(sock);
 		if (err) {
-			netlink_undo_bind(nlk->ngroups, groups, sk);
+			netlink_undo_bind(BITS_PER_TYPE(u32), groups, sk);
 			goto unlock;
 		}
 	}

net/openvswitch/datapath.c+6−3

 	struct hlist_head *head;
 	head = vport_hash_bucket(dp, port_no);
-	hlist_for_each_entry_rcu(vport, head, dp_hash_node) {
+	hlist_for_each_entry_rcu(vport, head, dp_hash_node,
+				lockdep_ovsl_is_held()) {
 		if (vport->port_no == port_no)
 			return vport;
 	}
 	int i;
 	for (i = 0; i < DP_VPORT_HASH_BUCKETS; i++) {
-		hlist_for_each_entry_rcu(vport, &dp->ports[i], dp_hash_node) {
+		hlist_for_each_entry_rcu(vport, &dp->ports[i], dp_hash_node,
+					lockdep_ovsl_is_held()) {
 			dev = vport->dev;
 			dev_headroom = netdev_get_fwd_headroom(dev);
 			if (dev_headroom > max_headroom)
 	dp->max_headroom = new_headroom;
 	for (i = 0; i < DP_VPORT_HASH_BUCKETS; i++)
-		hlist_for_each_entry_rcu(vport, &dp->ports[i], dp_hash_node)
+		hlist_for_each_entry_rcu(vport, &dp->ports[i], dp_hash_node,
+					lockdep_ovsl_is_held())
 			netdev_set_rx_headroom(vport->dev, new_headroom);
 }

net/openvswitch/flow_netlink.c+10−8

@@ -2708,10 +2708,6 @@ static int validate_set(const struct nlattr *a, · 2707 unmodified lines
2708	return -EINVAL;	2708	return -EINVAL;
2709		2709
2710	switch (key_type) {	2710	switch (key_type) {
2711	const struct ovs_key_ipv4 *ipv4_key;
2712	const struct ovs_key_ipv6 *ipv6_key;
2713	int err;
2714
2715	case OVS_KEY_ATTR_PRIORITY:	2711	case OVS_KEY_ATTR_PRIORITY:
2716	case OVS_KEY_ATTR_SKB_MARK:	2712	case OVS_KEY_ATTR_SKB_MARK:
2717	case OVS_KEY_ATTR_CT_MARK:	2713	case OVS_KEY_ATTR_CT_MARK:
@@ -2723,7 +2719,9 @@ static int validate_set(const struct nlattr *a, · 5 unmodified lines
2723	return -EINVAL;	2719	return -EINVAL;
2724	break;	2720	break;
2725		2721
2726	case OVS_KEY_ATTR_TUNNEL:	2722	case OVS_KEY_ATTR_TUNNEL: {
		2723	int err;
		2724
2727	if (masked)	2725	if (masked)
2728	return -EINVAL; /* Masked tunnel set not supported. */	2726	return -EINVAL; /* Masked tunnel set not supported. */
2729		2727
@@ -2732,8 +2730,10 @@ static int validate_set(const struct nlattr *a, · 2 unmodified lines
2732	if (err)	2730	if (err)
2733	return err;	2731	return err;
2734	break;	2732	break;
		2733	}
		2734	case OVS_KEY_ATTR_IPV4: {
		2735	const struct ovs_key_ipv4 *ipv4_key;
2735		2736
2736	case OVS_KEY_ATTR_IPV4:
2737	if (eth_type != htons(ETH_P_IP))	2737	if (eth_type != htons(ETH_P_IP))
2738	return -EINVAL;	2738	return -EINVAL;
2739		2739
@@ -2753,8 +2753,10 @@ static int validate_set(const struct nlattr *a, · 13 unmodified lines
2753	return -EINVAL;	2753	return -EINVAL;
2754	}	2754	}
2755	break;	2755	break;
		2756	}
		2757	case OVS_KEY_ATTR_IPV6: {
		2758	const struct ovs_key_ipv6 *ipv6_key;
2756		2759
2757	case OVS_KEY_ATTR_IPV6:
2758	if (eth_type != htons(ETH_P_IPV6))	2760	if (eth_type != htons(ETH_P_IPV6))
2759	return -EINVAL;	2761	return -EINVAL;
2760		2762
@@ -2781,7 +2783,7 @@ static int validate_set(const struct nlattr *a, · 20 unmodified lines
2781	return -EINVAL;	2783	return -EINVAL;
2782		2784
2783	break;	2785	break;
2784		2786	}
2785	case OVS_KEY_ATTR_TCP:	2787	case OVS_KEY_ATTR_TCP:
2786	if ((eth_type != htons(ETH_P_IP) &&	2788	if ((eth_type != htons(ETH_P_IP) &&
2787	eth_type != htons(ETH_P_IPV6)) \|\|	2789	eth_type != htons(ETH_P_IPV6)) \|\|

net/openvswitch/flow_table.c+4−2

 	head = find_bucket(ti, hash);
 	(*n_mask_hit)++;
-	hlist_for_each_entry_rcu(flow, head, flow_table.node[ti->node_ver]) {
+	hlist_for_each_entry_rcu(flow, head, flow_table.node[ti->node_ver],
+				lockdep_ovsl_is_held()) {
 		if (flow->mask == mask && flow->flow_table.hash == hash &&
 		    flow_cmp_masked_key(flow, &masked_key, &mask->range))
 			return flow;
 	hash = ufid_hash(ufid);
 	head = find_bucket(ti, hash);
-	hlist_for_each_entry_rcu(flow, head, ufid_table.node[ti->node_ver]) {
+	hlist_for_each_entry_rcu(flow, head, ufid_table.node[ti->node_ver],
+				lockdep_ovsl_is_held()) {
 		if (flow->ufid_table.hash == hash &&
 		    ovs_flow_cmp_ufid(flow, ufid))
 			return flow;

net/openvswitch/meter.c+2−1

@@ -61,7 +61,8 @@ static struct dp_meter lookup_meter(const struct datapath dp, · 60 unmodified lines
61	struct hlist_head *head;	61	struct hlist_head *head;
62		62
63	head = meter_hash_bucket(dp, meter_id);	63	head = meter_hash_bucket(dp, meter_id);
64	hlist_for_each_entry_rcu(meter, head, dp_hash_node) {	64	hlist_for_each_entry_rcu(meter, head, dp_hash_node,
		65	lockdep_ovsl_is_held()) {
65	if (meter->id == meter_id)	66	if (meter->id == meter_id)
66	return meter;	67	return meter;
67	}	68	}

net/openvswitch/vport.c+2−1

@@ -96,7 +96,8 @@ struct vport ovs_vport_locate(const struct net net, const char *name) · 95 unmodified lines
96	struct hlist_head *bucket = hash_bucket(net, name);	96	struct hlist_head *bucket = hash_bucket(net, name);
97	struct vport *vport;	97	struct vport *vport;
98		98
99	hlist_for_each_entry_rcu(vport, bucket, hash_node)	99	hlist_for_each_entry_rcu(vport, bucket, hash_node,
		100	lockdep_ovsl_is_held())
100	if (!strcmp(name, ovs_vport_name(vport)) &&	101	if (!strcmp(name, ovs_vport_name(vport)) &&
101	net_eq(ovs_dp_get_net(vport->dp), net))	102	net_eq(ovs_dp_get_net(vport->dp), net))
102	return vport;	103	return vport;

net/rds/rdma.c+12−12

 	if (write)
 		gup_flags |= FOLL_WRITE;
-	ret = get_user_pages_fast(user_addr, nr_pages, gup_flags, pages);
+	ret = pin_user_pages_fast(user_addr, nr_pages, gup_flags, pages);
 	if (ret >= 0 && ret < nr_pages) {
-		while (ret--)
+		unpin_user_pages(pages, ret);
-			put_page(pages[ret]);
 		ret = -EFAULT;
 	}
 		 * to release anything.
 		 */
 		if (!need_odp) {
-			for (i = 0 ; i < nents; i++)
+			unpin_user_pages(pages, nr_pages);
-				put_page(sg_page(&sg[i]));
 			kfree(sg);
 		}
 		ret = PTR_ERR(trans_private);
 	if (cookie_ret)
 		*cookie_ret = cookie;
-	if (args->cookie_addr && put_user(cookie, (u64 __user *)(unsigned long) args->cookie_addr)) {
+	if (args->cookie_addr &&
+	    put_user(cookie, (u64 __user *)(unsigned long)args->cookie_addr)) {
+		if (!need_odp) {
+			unpin_user_pages(pages, nr_pages);
+			kfree(sg);
+		}
 		ret = -EFAULT;
 		goto out;
 	}
 			 * is the case for a RDMA_READ which copies from remote
 			 * to local memory
 			 */
-			if (!ro->op_write)
+			unpin_user_pages_dirty_lock(&page, 1, !ro->op_write);
-				set_page_dirty(page);
-			put_page(page);
 		}
 	}
 	/* Mark page dirty if it was possibly modified, which
 	 * is the case for a RDMA_READ which copies from remote
 	 * to local memory */
-	set_page_dirty(page);
+	unpin_user_pages_dirty_lock(&page, 1, true);
-	put_page(page);
 	kfree(ao->op_notifier);
 	ao->op_notifier = NULL;
 	return ret;
 err:
 	if (page)
-		put_page(page);
+		unpin_user_page(page);
 	rm->atomic.op_active = 0;
 	kfree(rm->atomic.op_notifier);

net/sched/cls_flower.c+1−0

@@ -305,6 +305,7 @@ static int fl_classify(struct sk_buff skb, const struct tcf_proto tp, · 304 unmodified lines
305	struct cls_fl_filter *f;	305	struct cls_fl_filter *f;
306		306
307	list_for_each_entry_rcu(mask, &head->masks, list) {	307	list_for_each_entry_rcu(mask, &head->masks, list) {
		308	flow_dissector_init_keys(&skb_key.control, &skb_key.basic);
308	fl_clear_masked_range(&skb_key, mask);	309	fl_clear_masked_range(&skb_key, mask);
309		310
310	skb_flow_dissect_meta(skb, &mask->dissector, &skb_key);	311	skb_flow_dissect_meta(skb, &mask->dissector, &skb_key);

net/sctp/sm_statefuns.c+20−9

 	return true;
 }
+/* Check for format error in an ABORT chunk */
+static inline bool sctp_err_chunk_valid(struct sctp_chunk *chunk)
+{
+	struct sctp_errhdr *err;
+	sctp_walk_errors(err, chunk->chunk_hdr);
+	return (void *)err == (void *)chunk->chunk_end;
+}
 /**********************************************************
  * These are the state functions for handling chunk events.
  **********************************************************/
 		    sctp_bind_addr_state(&asoc->base.bind_addr, &chunk->dest))
 		return sctp_sf_discard_chunk(net, ep, asoc, type, arg, commands);
+	if (!sctp_err_chunk_valid(chunk))
+		return sctp_sf_pdiscard(net, ep, asoc, type, arg, commands);
 	return __sctp_sf_do_9_1_abort(net, ep, asoc, type, arg, commands);
 }
 		    sctp_bind_addr_state(&asoc->base.bind_addr, &chunk->dest))
 		return sctp_sf_discard_chunk(net, ep, asoc, type, arg, commands);
+	if (!sctp_err_chunk_valid(chunk))
+		return sctp_sf_pdiscard(net, ep, asoc, type, arg, commands);
 	/* Stop the T2-shutdown timer. */
 	sctp_add_cmd_sf(commands, SCTP_CMD_TIMER_STOP,
 			SCTP_TO(SCTP_EVENT_TIMEOUT_T2_SHUTDOWN));
 		    sctp_bind_addr_state(&asoc->base.bind_addr, &chunk->dest))
 		return sctp_sf_discard_chunk(net, ep, asoc, type, arg, commands);
+	if (!sctp_err_chunk_valid(chunk))
+		return sctp_sf_pdiscard(net, ep, asoc, type, arg, commands);
 	return __sctp_sf_do_9_1_abort(net, ep, asoc, type, arg, commands);
 }
 	/* See if we have an error cause code in the chunk.  */
 	len = ntohs(chunk->chunk_hdr->length);
-	if (len >= sizeof(struct sctp_chunkhdr) + sizeof(struct sctp_errhdr)) {
+	if (len >= sizeof(struct sctp_chunkhdr) + sizeof(struct sctp_errhdr))
-		struct sctp_errhdr *err;
-		sctp_walk_errors(err, chunk->chunk_hdr);
-		if ((void *)err != (void *)chunk->chunk_end)
-			return sctp_sf_pdiscard(net, ep, asoc, type, arg,
-						commands);
 		error = ((struct sctp_errhdr *)chunk->skb->data)->cause;
-	}
 	sctp_add_cmd_sf(commands, SCTP_CMD_SET_SK_ERR, SCTP_ERROR(ECONNRESET));
 	/* ASSOC_FAILED will DELETE_TCB. */

net/tls/tls_device.c+19−1

@@ -593,7 +593,7 @@ struct tls_record_info tls_get_record(struct tls_offload_context_tx context, · 592 unmodified lines
593	u32 seq, u64 *p_record_sn)	593	u32 seq, u64 *p_record_sn)
594	{	594	{
595	u64 record_sn = context->hint_record_sn;	595	u64 record_sn = context->hint_record_sn;
596	struct tls_record_info *info;	596	struct tls_record_info info, last;
597		597
598	info = context->retransmit_hint;	598	info = context->retransmit_hint;
599	if (!info \|\|	599	if (!info \|\|
@@ -605,6 +605,24 @@ struct tls_record_info tls_get_record(struct tls_offload_context_tx context, · 5 unmodified lines
605	struct tls_record_info, list);	605	struct tls_record_info, list);
606	if (!info)	606	if (!info)
607	return NULL;	607	return NULL;
		608	/* send the start_marker record if seq number is before the
		609	* tls offload start marker sequence number. This record is
		610	* required to handle TCP packets which are before TLS offload
		611	* started.
		612	* And if it's not start marker, look if this seq number
		613	* belongs to the list.
		614	*/
		615	if (likely(!tls_record_is_start_marker(info))) {
		616	/* we have the first record, get the last record to see
		617	* if this seq number belongs to the list.
		618	*/
		619	last = list_last_entry(&context->records_list,
		620	struct tls_record_info, list);
		621
		622	if (!between(seq, tls_record_start_seq(info),
		623	last->end_seq))
		624	return NULL;
		625	}
608	record_sn = context->unacked_record_sn;	626	record_sn = context->unacked_record_sn;
609	}	627	}
610		628

net/xdp/xsk.c+2−0

 static void xsk_flush(struct xdp_sock *xs)
 {
 	xskq_prod_submit(xs->rx);
+	__xskq_cons_release(xs->umem->fq);
 	sock_def_readable(&xs->sk);
 }
 	rcu_read_lock();
 	list_for_each_entry_rcu(xs, &umem->xsk_list, list) {
+		__xskq_cons_release(xs->tx);
 		xs->sk.sk_write_space(&xs->sk);
 	}
 	rcu_read_unlock();

net/xdp/xsk_queue.h+2−1

 {
 	/* To improve performance, only update local state here.
 	 * Reflect this to global state when we get new entries
-	 * from the ring in xskq_cons_get_entries().
+	 * from the ring in xskq_cons_get_entries() and whenever
+	 * Rx or Tx processing are completed in the NAPI loop.
 	 */
 	q->cached_cons++;
 }

tools/include/uapi/linux/bpf.h+7−9

  * 		supports redirection to the egress interface, and accepts no
  * 		flag at all.
  *
- * 		The same effect can be attained with the more generic
+ * 		The same effect can also be attained with the more generic
- * 		**bpf_redirect_map**\ (), which requires specific maps to be
+ * 		**bpf_redirect_map**\ (), which uses a BPF map to store the
- * 		used but offers better performance.
+ * 		redirect target instead of providing it directly to the helper.
  * 	Return
  * 		For XDP, the helper returns **XDP_REDIRECT** on success or
  * 		**XDP_ABORTED** on error. For other program types, the values
  * 		the caller. Any higher bits in the *flags* argument must be
  * 		unset.
  *
- * 		When used to redirect packets to net devices, this helper
+ * 		See also bpf_redirect(), which only supports redirecting to an
- * 		provides a high performance increase over **bpf_redirect**\ ().
+ * 		ifindex, but doesn't require a map to do so.
- * 		This is due to various implementation details of the underlying
- * 		mechanisms, one of which is the fact that **bpf_redirect_map**\
- * 		() tries to send packet as a "bulk" to the device.
  * 	Return
- * 		**XDP_REDIRECT** on success, or **XDP_ABORTED** on error.
+ * 		**XDP_REDIRECT** on success, or the value of the two lower bits
+ * 		of the **flags* argument on error.
  *
  * int bpf_sk_redirect_map(struct sk_buff *skb, struct bpf_map *map, u32 key, u64 flags)
  * 	Description

tools/lib/bpf/libbpf.c+7−1

 #include <endian.h>
 #include <fcntl.h>
 #include <errno.h>
+#include <ctype.h>
 #include <asm/unistd.h>
 #include <linux/err.h>
 #include <linux/kernel.h>
 static char *internal_map_name(struct bpf_object *obj,
 			       enum libbpf_map_type type)
 {
-	char map_name[BPF_OBJ_NAME_LEN];
+	char map_name[BPF_OBJ_NAME_LEN], *p;
 	const char *sfx = libbpf_type_to_btf_name[type];
 	int sfx_len = max((size_t)7, strlen(sfx));
 	int pfx_len = min((size_t)BPF_OBJ_NAME_LEN - sfx_len - 1,
 	snprintf(map_name, sizeof(map_name), "%.*s%.*s", pfx_len, obj->name,
 		 sfx_len, libbpf_type_to_btf_name[type]);
+	/* sanitise map name to characters allowed by kernel */
+	for (p = map_name; *p && p < map_name + sizeof(map_name); p++)
+		if (!isalnum(*p) && *p != '_' && *p != '.')
+			*p = '_';
 	return strdup(map_name);
 }

tools/testing/selftests/bpf/prog_tests/select_reuseport.c+6−2

 		.pass_on_failure = 0,
 	};
-	if (type != SOCK_STREAM)
+	if (type != SOCK_STREAM) {
+		test__skip();
 		return;
+	}
 	/*
 	 * +1 for TCP-SYN and
 		goto out;
 	saved_tcp_fo = read_int_sysctl(TCP_FO_SYSCTL);
+	if (saved_tcp_fo < 0)
+		goto out;
 	saved_tcp_syncookie = read_int_sysctl(TCP_SYNCOOKIE_SYSCTL);
-	if (saved_tcp_syncookie < 0 || saved_tcp_syncookie < 0)
+	if (saved_tcp_syncookie < 0)
 		goto out;
 	if (enable_fastopen())

tools/testing/selftests/bpf/prog_tests/sockmap_basic.c+5−0

@@ -3,6 +3,11 @@ · 2 unmodified lines
3		3
4	#include "test_progs.h"	4	#include "test_progs.h"
5		5
		6	#define TCP_REPAIR 19 /* TCP sock is under repair right now */
		7
		8	#define TCP_REPAIR_ON 1
		9	#define TCP_REPAIR_OFF_NO_WP -1 /* Turn off without window probes */
		10
6	static int connected_socket_v4(void)	11	static int connected_socket_v4(void)
7	{	12	{
8	struct sockaddr_in addr = {	13	struct sockaddr_in addr = {

tools/testing/selftests/net/fib_tests.sh+6−0

 	check_route6 "2001:db8:104::/64 via 2001:db8:101::3 dev veth1 metric 1024"
 	log_test $? 0 "Multipath with single path via multipath attribute"
+	# multipath with dev-only
+	add_initial_route6 "nexthop via 2001:db8:101::2 nexthop via 2001:db8:103::2"
+	run_cmd "$IP -6 ro replace 2001:db8:104::/64 dev veth1"
+	check_route6 "2001:db8:104::/64 dev veth1 metric 1024"
+	log_test $? 0 "Multipath with dev-only"
 	# route replace fails - invalid nexthop 1
 	add_initial_route6 "nexthop via 2001:db8:101::2 nexthop via 2001:db8:103::2"
 	run_cmd "$IP -6 ro replace 2001:db8:104::/64 nexthop via 2001:db8:111::3 nexthop via 2001:db8:103::3"

tools/testing/selftests/net/forwarding/mirror_gre.sh+13−12

 {
 	local tundev=$1; shift
 	local direction=$1; shift
-	local prot=$1; shift
 	local what=$1; shift
-	local swp3mac=$(mac_get $swp3)
+	case "$direction" in
-	local h3mac=$(mac_get $h3)
+	ingress) local src_mac=$(mac_get $h1); local dst_mac=$(mac_get $h2)
+		;;
+	egress) local src_mac=$(mac_get $h2); local dst_mac=$(mac_get $h1)
+		;;
+	esac
 	RET=0
 	mirror_install $swp1 $direction $tundev "matchall $tcflags"
-	tc filter add dev $h3 ingress pref 77 prot $prot \
+	icmp_capture_install h3-${tundev} "src_mac $src_mac dst_mac $dst_mac"
-		flower ip_proto 0x2f src_mac $swp3mac dst_mac $h3mac \
-		action pass
-	mirror_test v$h1 192.0.2.1 192.0.2.2 $h3 77 10
+	mirror_test v$h1 192.0.2.1 192.0.2.2 h3-${tundev} 100 10
-	tc filter del dev $h3 ingress pref 77
+	icmp_capture_uninstall h3-${tundev}
 	mirror_uninstall $swp1 $direction
 	log_test "$direction $what: envelope MAC ($tcflags)"
 test_gretap_mac()
 {
-	test_span_gre_mac gt4 ingress ip "mirror to gretap"
+	test_span_gre_mac gt4 ingress "mirror to gretap"
-	test_span_gre_mac gt4 egress ip "mirror to gretap"
+	test_span_gre_mac gt4 egress "mirror to gretap"
 }
 test_ip6gretap_mac()
 {
-	test_span_gre_mac gt6 ingress ipv6 "mirror to ip6gretap"
+	test_span_gre_mac gt6 ingress "mirror to ip6gretap"
-	test_span_gre_mac gt6 egress ipv6 "mirror to ip6gretap"
+	test_span_gre_mac gt6 egress "mirror to ip6gretap"
 }
 test_all()

tools/testing/selftests/net/forwarding/vxlan_bridge_1d.sh+3−3

@@ -516,9 +516,9 @@ test_tos() · 515 unmodified lines
516	RET=0	516	RET=0
517		517
518	tc filter add dev v1 egress pref 77 prot ip \	518	tc filter add dev v1 egress pref 77 prot ip \
519	flower ip_tos 0x40 action pass	519	flower ip_tos 0x14 action pass
520	vxlan_ping_test $h1 192.0.2.3 "-Q 0x40" v1 egress 77 10	520	vxlan_ping_test $h1 192.0.2.3 "-Q 0x14" v1 egress 77 10
521	vxlan_ping_test $h1 192.0.2.3 "-Q 0x30" v1 egress 77 0	521	vxlan_ping_test $h1 192.0.2.3 "-Q 0x18" v1 egress 77 0
522	tc filter del dev v1 egress pref 77 prot ip	522	tc filter del dev v1 egress pref 77 prot ip
523		523
524	log_test "VXLAN: envelope TOS inheritance"	524	log_test "VXLAN: envelope TOS inheritance"

tools/testing/selftests/wireguard/qemu/Makefile+14−24

 define file_download =
 $(DISTFILES_PATH)/$(1):
 	mkdir -p $(DISTFILES_PATH)
-	flock -x $$@.lock -c '[ -f $$@ ] && exit 0; wget -O $$@.tmp $(MIRROR)$(1) || wget -O $$@.tmp $(2)$(1) || rm -f $$@.tmp'
+	flock -x $$@.lock -c '[ -f $$@ ] && exit 0; wget -O $$@.tmp $(MIRROR)$(1) || wget -O $$@.tmp $(2)$(1) || rm -f $$@.tmp; [ -f $$@.tmp ] || exit 1; if echo "$(3)  $$@.tmp" | sha256sum -c -; then mv $$@.tmp $$@; else rm -f $$@.tmp; exit 71; fi'
-	if echo "$(3)  $$@.tmp" | sha256sum -c -; then mv $$@.tmp $$@; else rm -f $$@.tmp; exit 71; fi
 endef
 $(eval $(call tar_download,MUSL,musl,1.1.24,.tar.gz,https://www.musl-libc.org/releases/,1370c9a812b2cf2a7d92802510cca0058cc37e66a7bedd70051f0a34015022a3))
-$(eval $(call tar_download,LIBMNL,libmnl,1.0.4,.tar.bz2,https://www.netfilter.org/projects/libmnl/files/,171f89699f286a5854b72b91d06e8f8e3683064c5901fb09d954a9ab6f551f81))
 $(eval $(call tar_download,IPERF,iperf,3.7,.tar.gz,https://downloads.es.net/pub/iperf/,d846040224317caf2f75c843d309a950a7db23f9b44b94688ccbe557d6d1710c))
 $(eval $(call tar_download,BASH,bash,5.0,.tar.gz,https://ftp.gnu.org/gnu/bash/,b4a80f2ac66170b2913efbfb9f2594f1f76c7b1afd11f799e22035d63077fb4d))
 $(eval $(call tar_download,IPROUTE2,iproute2,5.4.0,.tar.xz,https://www.kernel.org/pub/linux/utils/net/iproute2/,fe97aa60a0d4c5ac830be18937e18dc3400ca713a33a89ad896ff1e3d46086ae))
 $(eval $(call tar_download,IPTABLES,iptables,1.8.4,.tar.bz2,https://www.netfilter.org/projects/iptables/files/,993a3a5490a544c2cbf2ef15cf7e7ed21af1845baf228318d5c36ef8827e157c))
 $(eval $(call tar_download,NMAP,nmap,7.80,.tar.bz2,https://nmap.org/dist/,fcfa5a0e42099e12e4bf7a68ebe6fde05553383a682e816a7ec9256ab4773faa))
 $(eval $(call tar_download,IPUTILS,iputils,s20190709,.tar.gz,https://github.com/iputils/iputils/archive/s20190709.tar.gz/#,a15720dd741d7538dd2645f9f516d193636ae4300ff7dbc8bfca757bf166490a))
-$(eval $(call tar_download,WIREGUARD_TOOLS,wireguard-tools,1.0.20191226,.tar.xz,https://git.zx2c4.com/wireguard-tools/snapshot/,aa8af0fdc9872d369d8c890a84dbc2a2466b55795dccd5b47721b2d97644b04f))
+$(eval $(call tar_download,WIREGUARD_TOOLS,wireguard-tools,1.0.20200206,.tar.xz,https://git.zx2c4.com/wireguard-tools/snapshot/,f5207248c6a3c3e3bfc9ab30b91c1897b00802ed861e1f9faaed873366078c64))
 KERNEL_BUILD_PATH := $(BUILD_PATH)/kernel$(if $(findstring yes,$(DEBUG_KERNEL)),-debug)
 rwildcard=$(foreach d,$(wildcard $1*),$(call rwildcard,$d/,$2) $(filter $(subst *,%,$2),$d))
 	$(MAKE) -C $(IPERF_PATH)
 	$(STRIP) -s $@
-$(LIBMNL_PATH)/.installed: $(LIBMNL_TAR)
-	flock -s $<.lock tar -C $(BUILD_PATH) -xf $<
-	touch $@
-$(LIBMNL_PATH)/src/.libs/libmnl.a: | $(LIBMNL_PATH)/.installed $(USERSPACE_DEPS)
-	cd $(LIBMNL_PATH) && ./configure --prefix=/ $(CROSS_COMPILE_FLAG) --enable-static --disable-shared
-	$(MAKE) -C $(LIBMNL_PATH)
-	sed -i 's:prefix=.*:prefix=$(LIBMNL_PATH):' $(LIBMNL_PATH)/libmnl.pc
 $(WIREGUARD_TOOLS_PATH)/.installed: $(WIREGUARD_TOOLS_TAR)
+	mkdir -p $(BUILD_PATH)
 	flock -s $<.lock tar -C $(BUILD_PATH) -xf $<
 	touch $@
-$(WIREGUARD_TOOLS_PATH)/src/wg: | $(WIREGUARD_TOOLS_PATH)/.installed $(LIBMNL_PATH)/src/.libs/libmnl.a $(USERSPACE_DEPS)
+$(WIREGUARD_TOOLS_PATH)/src/wg: | $(WIREGUARD_TOOLS_PATH)/.installed $(USERSPACE_DEPS)
-	LDFLAGS="$(LDFLAGS) -L$(LIBMNL_PATH)/src/.libs" $(MAKE) -C $(WIREGUARD_TOOLS_PATH)/src LIBMNL_CFLAGS="-I$(LIBMNL_PATH)/include" LIBMNL_LDLIBS="-lmnl" wg
+	$(MAKE) -C $(WIREGUARD_TOOLS_PATH)/src wg
 	$(STRIP) -s $@
 $(BUILD_PATH)/init: init.c | $(USERSPACE_DEPS)
 $(IPROUTE2_PATH)/.installed: $(IPROUTE2_TAR)
 	mkdir -p $(BUILD_PATH)
 	flock -s $<.lock tar -C $(BUILD_PATH) -xf $<
-	printf 'CC:=$(CC)\nPKG_CONFIG:=pkg-config\nTC_CONFIG_XT:=n\nTC_CONFIG_ATM:=n\nTC_CONFIG_IPSET:=n\nIP_CONFIG_SETNS:=y\nHAVE_ELF:=n\nHAVE_MNL:=y\nHAVE_BERKELEY_DB:=n\nHAVE_LATEX:=n\nHAVE_PDFLATEX:=n\nCFLAGS+=-DHAVE_SETNS -DHAVE_LIBMNL -I$(LIBMNL_PATH)/include\nLDLIBS+=-lmnl' > $(IPROUTE2_PATH)/config.mk
+	printf 'CC:=$(CC)\nPKG_CONFIG:=pkg-config\nTC_CONFIG_XT:=n\nTC_CONFIG_ATM:=n\nTC_CONFIG_IPSET:=n\nIP_CONFIG_SETNS:=y\nHAVE_ELF:=n\nHAVE_MNL:=n\nHAVE_BERKELEY_DB:=n\nHAVE_LATEX:=n\nHAVE_PDFLATEX:=n\nCFLAGS+=-DHAVE_SETNS\n' > $(IPROUTE2_PATH)/config.mk
 	printf 'lib: snapshot\n\t$$(MAKE) -C lib\nip/ip: lib\n\t$$(MAKE) -C ip ip\nmisc/ss: lib\n\t$$(MAKE) -C misc ss\n' >> $(IPROUTE2_PATH)/Makefile
 	touch $@
-$(IPROUTE2_PATH)/ip/ip: | $(IPROUTE2_PATH)/.installed $(LIBMNL_PATH)/src/.libs/libmnl.a $(USERSPACE_DEPS)
+$(IPROUTE2_PATH)/ip/ip: | $(IPROUTE2_PATH)/.installed $(USERSPACE_DEPS)
-	LDFLAGS="$(LDFLAGS) -L$(LIBMNL_PATH)/src/.libs" PKG_CONFIG_LIBDIR="$(LIBMNL_PATH)" $(MAKE) -C $(IPROUTE2_PATH) PREFIX=/ ip/ip
+	$(MAKE) -C $(IPROUTE2_PATH) PREFIX=/ ip/ip
-	$(STRIP) -s $(IPROUTE2_PATH)/ip/ip
+	$(STRIP) -s $@
-$(IPROUTE2_PATH)/misc/ss: | $(IPROUTE2_PATH)/.installed $(LIBMNL_PATH)/src/.libs/libmnl.a $(USERSPACE_DEPS)
+$(IPROUTE2_PATH)/misc/ss: | $(IPROUTE2_PATH)/.installed $(USERSPACE_DEPS)
-	LDFLAGS="$(LDFLAGS) -L$(LIBMNL_PATH)/src/.libs" PKG_CONFIG_LIBDIR="$(LIBMNL_PATH)" $(MAKE) -C $(IPROUTE2_PATH) PREFIX=/ misc/ss
+	$(MAKE) -C $(IPROUTE2_PATH) PREFIX=/ misc/ss
-	$(STRIP) -s $(IPROUTE2_PATH)/misc/ss
+	$(STRIP) -s $@
 $(IPTABLES_PATH)/.installed: $(IPTABLES_TAR)
 	mkdir -p $(BUILD_PATH)
 	sed -i -e "/nfnetlink=[01]/s:=[01]:=0:" -e "/nfconntrack=[01]/s:=[01]:=0:" $(IPTABLES_PATH)/configure
 	touch $@
-$(IPTABLES_PATH)/iptables/xtables-legacy-multi: | $(IPTABLES_PATH)/.installed $(LIBMNL_PATH)/src/.libs/libmnl.a $(USERSPACE_DEPS)
+$(IPTABLES_PATH)/iptables/xtables-legacy-multi: | $(IPTABLES_PATH)/.installed $(USERSPACE_DEPS)
-	cd $(IPTABLES_PATH) && PKG_CONFIG_LIBDIR="$(LIBMNL_PATH)" ./configure --prefix=/ $(CROSS_COMPILE_FLAG) --enable-static --disable-shared --disable-nftables --disable-bpf-compiler --disable-nfsynproxy --disable-libipq --with-kernel=$(BUILD_PATH)/include
+	cd $(IPTABLES_PATH) && ./configure --prefix=/ $(CROSS_COMPILE_FLAG) --enable-static --disable-shared --disable-nftables --disable-bpf-compiler --disable-nfsynproxy --disable-libipq --disable-connlabel --with-kernel=$(BUILD_PATH)/include
 	$(MAKE) -C $(IPTABLES_PATH)
 	$(STRIP) -s $@